ObjQt  Check-in [4ae247a25d]

@interface QtChildEvent: QtEvent
@property (readonly, nonatomic) QChildEvent *qChildEvent;
@property (readonly, nonatomic, getter=isAdded) bool added;
@property (readonly, nonatomic) QtObject *child;
@property (readonly, nonatomic, getter=isPolished) bool polished;
@property (readonly, nonatomic, getter=isRemoved) bool removed;

- (instancetype)initWithQEvent: (QEvent *)event OF_UNAVAILABLE;
- (instancetype)initWithQChildEvent:
    (QChildEvent *)qChildEvent OF_DESIGNATED_INITIALIZER;
- (instancetype)initWithType: (QChildEvent::Type)type
		       child: (QtObject *)child;
@end

namespace ObjQt {

static OF_INLINE QtChildEvent *
toOF(QChildEvent *qChildEvent)
{
	if (qChildEvent == NULL)
		return nil;

	return [[[QtChildEvent alloc]
	    initWithQChildEvent: qChildEvent] autorelease];
}

static OF_INLINE QChildEvent *
toQt(QtChildEvent *childEvent)
{
	return childEvent.qChildEvent;
}

}

#import "QtChildEvent.h"
#import "QtObject.h"

using ObjQt::toOF;
using ObjQt::toQt;

@implementation QtChildEvent
- (instancetype)initWithQEvent: (QEvent *)event
{
	OF_INVALID_INIT_METHOD
}

- (instancetype)initWithQChildEvent: (QChildEvent *)event
{
	return [super initWithQEvent: event];
}

- (instancetype)initWithType: (QChildEvent::Type)type
		       child: (QtObject *)child
{
	try {
		self = [self initWithQChildEvent:
		    new QChildEvent(type, toQt(child))];

		[self takeOwnership];

@interface QtCoreApplication: QtObject
@property (readonly, nonatomic) QCoreApplication *qCoreApplication;
@property (nonatomic, copy) OFString *applicationName, *applicationVersion;
@property (nonatomic, copy) OFString *organizationDomain, *organizationName;
@property (nonatomic, getter=isQuitLockEnabled) bool quitLockEnabled;

- (instancetype)initWithQObject: (QObject *)qObject OF_UNAVAILABLE;
- (instancetype)initWithQCoreApplication: (QCoreApplication *)qCoreApplication
    OF_DESIGNATED_INITIALIZER;
- (void)installNativeEventFilter: (QAbstractNativeEventFilter *)filterObject;
- (void)quit;
- (void)removeNativeEventFilter: (QAbstractNativeEventFilter *)filterObject;
- (bool)sendEvent: (QtEvent *)event
	 receiver: (QtObject *)receiver;
@end

	return [[[QtCoreApplication alloc]
	    initWithQCoreApplication: qCoreApplication] autorelease];
}

static OF_INLINE QCoreApplication *
toQt(QtCoreApplication *coreApplication)
{
	return coreApplication.qCoreApplication;
}

}

#import "QtEvent.h"
#import "OFString+QString.h"

using ObjQt::toOF;
using ObjQt::toQt;

@implementation QtCoreApplication
- (instancetype)initWithQObject: (QObject *)qObject
{
	OF_INVALID_INIT_METHOD
}

- (instancetype)initWithQCoreApplication: (QCoreApplication *)qCoreApplication
{
	return [super initWithQObject: qCoreApplication];
}

- (QCoreApplication *)qCoreApplication
{
	return qobject_cast<QCoreApplication *>(_qObject);

@property (readonly, nonatomic) QEvent *qEvent;
@property (nonatomic, getter=isAccepted) bool accepted;
@property (readonly, nonatomic, getter=isSpontaneous) bool spontaneous;
@property (readonly, nonatomic) QEvent::Type type;

+ (int)registerEventType: (int)hint;
- (instancetype)init OF_UNAVAILABLE;
- (instancetype)initWithQEvent: (QEvent *)qEvent OF_DESIGNATED_INITIALIZER;
- (void)accept;
- (void)ignore;
@end

namespace ObjQt {

static OF_INLINE QtEvent *
toOF(QEvent *qEvent)
{
	if (qEvent == NULL)
		return nil;

	return [[[QtEvent alloc] initWithQEvent: qEvent] autorelease];
}

static OF_INLINE QEvent *
toQt(QtEvent *event)
{
	return event.qEvent;
}

}

@synthesize qEvent = _qEvent;

+ (int)registerEventType: (int)hint
{
	return QEvent::registerEventType(hint);
}

- (instancetype)init
{
	OF_INVALID_INIT_METHOD
}

- (instancetype)initWithQEvent: (QEvent *)qEvent
{
	self = [super init];

	_qEvent = qEvent;

	return self;
}

@property (retain, nonatomic) QtObject *parent;
@property (copy, nonatomic) OFString *objectName;
@property (readonly, nonatomic) OFArray OF_GENERIC(QtObject *) *children;
@property (readonly, nonatomic)
    OFArray OF_GENERIC(OFData *) *dynamicPropertyNames;
@property (readonly, nonatomic) QtThread *thread;

- (instancetype)init OF_UNAVAILABLE;
- (instancetype)initWithQObject: (QObject *)qObject OF_DESIGNATED_INITIALIZER;
- (bool)setBlockSignals: (bool)block;
- (QMetaObject::Connection)connectSignal: (OFString *)signal
				  sender: (QtObject *)sender
				  method: (OFString *)method
				    type: (Qt::ConnectionType)type;
- (bool)disconnectSignal: (OFString *)signal
		receiver: (QtObject *)receiver

	return [[[QtObject alloc] initWithQObject: qObject] autorelease];
}

static OF_INLINE QObject *
toQt(QtObject *object)
{
	return object.qObject;
}

}

using ObjQt::toOF;
using ObjQt::toQt;

@implementation QtObject
@synthesize qObject = _qObject;

- (instancetype)init
{
	OF_INVALID_INIT_METHOD
}

- (instancetype)initWithQObject: (QObject *)qObject
{
	self = [super init];

	_qObject = qObject;

	return self;
}

- (QMetaObject::Connection)connectSignal: (OFString *)signal
				  sender: (QtObject *)sender
				  method: (OFString *)method
				    type: (Qt::ConnectionType)type
{
	return _qObject->connect(toQt(sender),
	    signal.UTF8String, method.UTF8String, type);
}

- (bool)disconnectSignal: (OFString *)signal
		receiver: (QtObject *)receiver
		  method: (OFString *)method
{
	return _qObject->disconnect(signal.UTF8String, toQt(receiver),
	    method.UTF8String);
}

- (bool)disconnectAllSignalsForReceiver: (QtObject *)receiver
				 method: (OFString *)method
{
	return _qObject->disconnect(toQt(receiver), method.UTF8String);
}

- (void)dumpObjectInfo
{
	_qObject->dumpObjectInfo();
}

	  forObject: (QtObject *)watched
{
	return _qObject->eventFilter(toQt(watched), toQt(event));
}

- (bool)inheritsClassWithName: (OFString *)className
{
	return _qObject->inherits(className.UTF8String);
}

- (void)installEventFilter: (QtObject *)filterObj
{
	_qObject->installEventFilter(toQt(filterObj));
}

- (void)setParent: (QtObject *)parent
{
	_qObject->setParent(toQt(parent));
}

- (QVariant)propertyForName: (OFString *)name
{
	return _qObject->property(name.UTF8String);
}

- (void)removeEventFilter: (QtObject *)obj
{
	_qObject->removeEventFilter(toQt(obj));
}

- (bool)setProperty: (QVariant &)value
	    forName: (OFString *)name
{
	return _qObject->setProperty(name.UTF8String, value);
}

- (bool)signalsBlocked
{
	return _qObject->signalsBlocked();
}

@property (readonly, nonatomic, getter=isInterruptionRequested)
    bool interruptionRequested;
@property (readonly, nonatomic, getter=isRunning) bool running;
@property (readonly, nonatomic) int loopLevel;
@property (nonatomic) QThread::Priority priority;
@property (nonatomic) unsigned int stackSize;

- (instancetype)initWithQObject: (QObject *)qObject OF_UNAVAILABLE;
- (instancetype)initWithQThread: (QThread *)qThread OF_DESIGNATED_INITIALIZER;
- (void)exitWithReturnCode: (int)returnCode;
- (void)requestInterruption;
- (bool)waitForMilliseconds: (unsigned long)time;
- (void)quit;
- (void)startWithPriority: (QThread::Priority)priority;
- (void)terminate;
@end

	return [[[QtThread alloc] initWithQThread: qThread] autorelease];
}

static OF_INLINE QThread *
toQt(QtThread *thread)
{
	return thread.qThread;
}

}

 */

#import "QtThread.h"

using ObjQt::toQt;

@implementation QtThread: QtObject
- (instancetype)initWithQObject: (QObject *)qObject
{
	OF_INVALID_INIT_METHOD
}

- (instancetype)initWithQThread: (QThread *)qThread
{
	return [super initWithQObject: qThread];
}

- (QThread *)qThread
{
	return qobject_cast<QThread *>(_qObject);

@property (readonly, nonatomic) OFString *platformName;
@property (readonly, nonatomic) QScreen *primaryScreen;
@property (nonatomic) bool quitsOnLastWindowClosed;
@property (nonatomic) QIcon windowIcon;
@property (readonly, nonatomic) OFString *sessionID;
@property (readonly, nonatomic) OFString *sessionKey;

- (instancetype)initWithQCoreApplication: (QCoreApplication *)qCoreApplication
    OF_UNAVAILABLE;
- (instancetype)initWithQGuiApplication: (QGuiApplication *)qGuiApplication
    OF_DESIGNATED_INITIALIZER;
- (double)devicePixelRatio;
- (bool)isSavingSession;
- (bool)isSessionRestored;
@end

namespace ObjQt {

	return [[[QtGUIApplication alloc]
	    initWithQGuiApplication: qGuiApplication] autorelease];
}

static OF_INLINE QGuiApplication *
toQt(QtGUIApplication *GUIApplication)
{
	return GUIApplication.qGuiApplication;
}

}

#include <QIcon>

using ObjQt::toOF;
using ObjQt::toQt;

@implementation QtGUIApplication
- (instancetype)initWithQCoreApplication: (QCoreApplication *)qCoreApplication
{
	OF_INVALID_INIT_METHOD
}

- (instancetype)initWithQGuiApplication: (QGuiApplication *)qGuiApplication
{
	return [super initWithQCoreApplication: qGuiApplication];
}

- (QGuiApplication *)qGuiApplication
{
	return qobject_cast<QGuiApplication *>(_qObject);

@end

namespace ObjQt {

static OF_INLINE QPaintDevice *
toQt(id <QtPaintDevice> paintDevice)
{
	return paintDevice.qPaintDevice;
}

}

using ObjQt::toQt;

@implementation QtPaintDevice
@dynamic qObject;

- (QPaintDevice *)qPaintDevice
{
	return dynamic_cast<QPaintDevice *>(self.qObject);
}

- (int)colorCount
{
	return toQt(self)->colorCount();
}

@property (nonatomic, getter=isDown) bool down;
@property (nonatomic) QIcon icon;
@property (nonatomic) of_dimension_t iconSize;
@property (nonatomic) QKeySequence shortcut;
@property (nonatomic, copy) OFString *text;
@property (readonly, nonatomic) QButtonGroup *group;

- (instancetype)initWithQWidget: (QWidget *)qWidget OF_UNAVAILABLE;
- (instancetype)initWithQAbstractButton: (QAbstractButton *)qAbstractButton
    OF_DESIGNATED_INITIALIZER;
@end

namespace ObjQt {

static OF_INLINE QtAbstractButton *
toOF(QAbstractButton *qAbstractButton)
{
	if (qAbstractButton == NULL)
		return nil;

	return [[[QtAbstractButton alloc]
	    initWithQAbstractButton: qAbstractButton] autorelease];
}

static OF_INLINE QAbstractButton *
toQt(QtAbstractButton *abstractButton)
{
	return abstractButton.qAbstractButton;
}

}

#import "helpers.h"

using ObjQt::toOF;
using ObjQt::toQt;

@implementation QtAbstractButton
- (instancetype)initWithQWidget: (QWidget *)qWidget
{
	OF_INVALID_INIT_METHOD
}

- (instancetype)initWithQAbstractButton: (QAbstractButton *)qAbstractButton
{
	return [super initWithQWidget: qAbstractButton];
}

- (QAbstractButton *)qAbstractButton
{
	return qobject_cast<QAbstractButton *>(_qObject);

@property (copy, nonatomic) OFString *statusTip;
@property (copy, nonatomic) OFString *text;
@property (copy, nonatomic) OFString *toolTip;
@property (nonatomic, getter=isVisible) bool visible;
@property (copy, nonatomic) OFString *whatsThis;
@property (readonly, nonatomic)
    OFArray OF_GENERIC(QtWidget *) *associatedWidgets;
@property (nonatomic, setter=setSeparator:) bool isSeparator;
@property (readonly, nonatomic) QtWidget *parentWidget;

- (instancetype)initWithQObject: (QObject *)qObject OF_UNAVAILABLE;
- (instancetype)initWithQAction: (QAction *)qAction OF_DESIGNATED_INITIALIZER;
- (QActionGroup *)actionGroup;
- (void)activate: (QAction::ActionEvent)event;
- (QList<QGraphicsWidget *>)associatedGraphicsWidgets;
- (QVariant)data;
- (QMenu *)menu;
- (void)setActionGroup: (QActionGroup *)group;
- (void)setData: (const QVariant &)data;

	return [[[QtAction alloc] initWithQAction: qAction] autorelease];
}

static OF_INLINE QAction *
toQt(QtAction *action)
{
	return action.qAction;
}

}

#import "QtWidget.h"
#import "OFString+QString.h"

using ObjQt::toOF;
using ObjQt::toQt;

@implementation QtAction
- (instancetype)initWithQObject: (QObject *)qObject
{
	OF_INVALID_INIT_METHOD
}

- (instancetype)initWithQAction: (QAction *)qAction
{
	return [super initWithQObject: qAction];
}

- (QAction *)qAction
{
	return qobject_cast<QAction *>(_qObject);

@property (nonatomic) of_dimension_t globalStrut;
@property (nonatomic) int keyboardInputInterval;
@property (nonatomic) int startDragDistance;
@property (nonatomic) int startDragTime;
@property (nonatomic, copy) OFString *styleSheet;
@property (nonatomic) int wheelScrollLines;

- (instancetype)initWithQGuiApplication: (QGuiApplication *)qGuiApplication
    OF_UNAVAILABLE;
- (instancetype)initWithQApplication: (QApplication *)qApplication
    OF_DESIGNATED_INITIALIZER;
- (void)aboutQt;
- (void)closeAllWindows;
@end

namespace ObjQt {

static OF_INLINE QtApplication *
toOF(QApplication *qApplication)
{
	if (qApplication == NULL)
		return nil;

	return [[[QtApplication alloc]
	    initWithQApplication: qApplication] autorelease];
}

static OF_INLINE QApplication *
toQt(QtApplication *application)
{
	return application.qApplication;
}

}

#import "helpers.h"

using ObjQt::toOF;
using ObjQt::toQt;

@implementation QtApplication
- (instancetype)initWithQGuiApplication: (QGuiApplication *)qGuiApplication
{
	OF_INVALID_INIT_METHOD
}

- (instancetype)initWithQApplication: (QApplication *)qApplication
{
	return [super initWithQGuiApplication: qApplication];
}

- (QApplication *)qApplication
{
	return qobject_cast<QApplication *>(_qObject);

@property (copy, nonatomic) OFString *windowTitle;
@property (readonly, nonatomic) OFArray OF_GENERIC(QtAction *) *actions;
@property (readonly, nonatomic) bool isActiveWindow;
@property (nonatomic) QStyle *style;
@property (readonly, nonatomic) of_rectangle_t windowFrameGeometry;
@property (readonly, nonatomic) of_rectangle_t windowFrameRect;

- (instancetype)initWithQObject: (QObject *)qObject OF_UNAVAILABLE;
- (instancetype)initWithQGraphicsWidget: (QGraphicsWidget *)qGraphicsWidget
    OF_DESIGNATED_INITIALIZER;
- (void)addAction: (QtAction *)action;
- (void)addActions: (OFArray OF_GENERIC(QtAction *) *)actions;
- (void)adjustSize;
- (QtGraphicsWidget *)focusWidget;
- (void)getWindowFrameMarginsWithLeft: (qreal *)left
				  top: (qreal *)top

	return [[[QtGraphicsWidget alloc]
	    initWithQGraphicsWidget: qGraphicsWidget] autorelease];
}

static OF_INLINE QGraphicsWidget *
toQt(QtGraphicsWidget *graphicsWidget)
{
	return graphicsWidget.qGraphicsWidget;
}

}

using ObjQt::toQt;

@implementation QtGraphicsObject
@end

@implementation QtGraphicsWidget

- (instancetype)initWithQObject: (QObject *)qObject
{
	OF_INVALID_INIT_METHOD
}

- (instancetype)initWithQGraphicsWidget: (QGraphicsWidget *)qGraphicsWidget
{
	return [super initWithQObject: qGraphicsWidget];
}

- (QGraphicsWidget *)qGraphicsWidget
{
	return dynamic_cast<QGraphicsWidget *>(self.qObject);
}

- (bool)autoFillBackground
{
	return toQt(self)->autoFillBackground();
}

@interface QtPushButton: QtAbstractButton
@property (readonly, nonatomic) QPushButton *qPushButton;
@property (nonatomic) QMenu *menu;
@property (nonatomic) bool autoDefault;
@property (nonatomic, getter=isDefault, setter=setDefault:) bool default_;
@property (nonatomic, getter=isFlat) bool flat;

- (instancetype)initWithQAbstractButton: (QAbstractButton *)qAbstractButton
    OF_UNAVAILABLE;
- (instancetype)initWithQPushButton: (QPushButton *)qPushButton
    OF_DESIGNATED_INITIALIZER;
- (instancetype)initWithText: (OFString *)text;
- (instancetype)initWithIcon: (QIcon)icon
			text: (OFString *)text;
@end

namespace ObjQt {

static OF_INLINE QtPushButton *
toOF(QPushButton *qPushButton)
{
	if (qPushButton == NULL)
		return nil;

	return [[[QtPushButton alloc]
	    initWithQPushButton: qPushButton] autorelease];
}

static OF_INLINE QPushButton *
toQt(QtPushButton *pushButton)
{
	return pushButton.qPushButton;
}

}

#import "helpers.h"

using ObjQt::toOF;
using ObjQt::toQt;

@implementation QtPushButton
- (instancetype)initWithQAbstractButton: (QAbstractButton *)qAbstractButton
{
	OF_INVALID_INIT_METHOD
}

- (instancetype)initWithQPushButton: (QPushButton *)qPushButton
{
	return [super initWithQAbstractButton: qPushButton];
}

- (instancetype)initWithText: (OFString *)text
{
	try {
		self = [self initWithQPushButton:
		    new QPushButton(toQt(text))];

		[self takeOwnership];

		return self;
	} catch (const std::bad_alloc &e) {
		self = [self initWithQPushButton: NULL];
		[self release];
		throw;
	}
}

- (instancetype)initWithIcon: (QIcon)icon
			text: (OFString *)text
{
	try {
		self = [self initWithQPushButton:
		    new QPushButton(icon, toQt(text))];

		[self takeOwnership];

@property (readonly, nonatomic) QtWidget *nativeParentWidget;
@property (readonly, nonatomic) QtWidget *nextInFocusChain;
@property (readonly, nonatomic) QtWidget *parentWidget;
@property (readonly, nonatomic) QtWidget *previousInFocusChain;
@property (readonly, nonatomic) QtWidget *window;
@property (readonly, nonatomic) OFString *windowRole;

- (instancetype)initWithQObject: (QObject *)qObject OF_UNAVAILABLE;
- (instancetype)initWithQWidget: (QWidget *)qWidget OF_DESIGNATED_INITIALIZER;
- (void)activateWindow;
- (void)addAction: (QtAction *)action;
- (void)addActions: (OFArray OF_GENERIC(QtAction *) *)actions;
- (void)adjustSize;
- (QPalette::ColorRole)backgroundRole;
- (QBackingStore *)backingStore;
- (QtWidget *)childAt: (of_point_t)point;

	return [[[QtWidget alloc] initWithQWidget: qWidget] autorelease];
}

static OF_INLINE QWidget *
toQt(QtWidget *widget)
{
	return widget.qWidget;
}

}

@implementation QtWidget
+ (void)initialize
{
	if (self == [QtWidget class])
		[self inheritMethodsFromClass: [QtPaintDevice class]];
}

- (instancetype)initWithQObject: (QObject *)qObject
{
	OF_INVALID_INIT_METHOD
}

- (instancetype)initWithQWidget: (QWidget *)qWidget
{
	return [super initWithQObject: qWidget];
}

- (QWidget *)qWidget
{
	return qobject_cast<QWidget *>(_qObject);

 */

#import <ObjFW/ObjFW.h>

#include <QColor>

@interface OFColor (QColor)
@property (readonly, nonatomic) QColor qColor;

+ (instancetype)colorWithQColor: (const QColor &)qColor;
- (instancetype)initWithQColor: (const QColor &)qColor;

@end

namespace ObjQt {

static OF_INLINE OFColor *
toOF(const QColor &qColor)
{
	if (!qColor.isValid())
		return nil;

	return [OFColor colorWithQColor: qColor];
}

static OF_INLINE QColor
toQt(OFColor *color)
{
	if (color == nil)
		return QColor();

	return color.qColor;
}

}

 */

#import <ObjFW/ObjFW.h>

#include <QByteArray>

@interface OFData (QByteArray)
@property (readonly, nonatomic) QByteArray qByteArray;

+ (instancetype)dataWithQByteArray: (const QByteArray &)qByteArray;
- (instancetype)initWithQByteArray: (const QByteArray &)qByteArray;

@end

namespace ObjQt {

static OF_INLINE OFData *
toOF(const QByteArray &qByteArray)
{
	if (qByteArray.isNull())
		return nil;

	return [OFData dataWithQByteArray: qByteArray];
}

static OF_INLINE QByteArray
toQt(OFData *data)
{
	if (data == nil)
		return QByteArray();

	return data.qByteArray;
}

}

{
	return [self initWithItems: qByteArray.data()
			     count: qByteArray.count()];
}

- (QByteArray)qByteArray
{
	return QByteArray((const char *)self.items, self.count * self.itemSize);

}
@end

 */

#import <ObjFW/ObjFW.h>

#include <QString>

@interface OFString (QString)
@property (readonly, nonatomic) QString qString;

+ (instancetype)stringWithQString: (const QString &)qString;
- (instancetype)initWithQString: (const QString &)qString;

@end

namespace ObjQt {

static OF_INLINE OFString *
toOF(const QString &qString)
{
	if (qString.isNull())
		return nil;

	return [OFString stringWithQString: qString];
}

static OF_INLINE QString
toQt(OFString *string)
{
	if (string == nil)
		return QString();

	return string.qString;
}

}

- (QString)qString
{
	static_assert(sizeof(char16_t) == sizeof(QChar),
	    "char16_t and QChar have a different size!");

	void *pool = objc_autoreleasePoolPush();
	QString ret = QString((QChar *)self.UTF16String);

	objc_autoreleasePoolPop(pool);

	return ret;
}
@end