From f38ff5fbc2ee4f65c17974fe94f5b49bb813aee3 Mon Sep 17 00:00:00 2001 From: Jonathan Schleifer Date: Sun, 2 Apr 2017 22:51:55 +0200 Subject: [PATCH] Initial commit --- .gitignore | 4 + ObjQt.pro | 35 ++++++ QtCore/QtChildEvent.h | 15 +++ QtCore/QtChildEvent.mm | 53 +++++++++ QtCore/QtCoreApplication.h | 17 +++ QtCore/QtCoreApplication.mm | 97 +++++++++++++++ QtCore/QtEvent.h | 22 ++++ QtCore/QtEvent.mm | 74 ++++++++++++ QtCore/QtObject.h | 60 ++++++++++ QtCore/QtObject.mm | 225 +++++++++++++++++++++++++++++++++++ QtCore/QtThread.h | 22 ++++ QtCore/QtThread.mm | 98 +++++++++++++++ QtGui/QtGuiApplication.h | 21 ++++ QtGui/QtGuiApplication.mm | 110 +++++++++++++++++ QtWidgets/QtApplication.h | 22 ++++ QtWidgets/QtApplication.mm | 120 +++++++++++++++++++ common/QtOwnershipManaging.h | 6 + common/helpers.h | 15 +++ 18 files changed, 1016 insertions(+) create mode 100644 .gitignore create mode 100644 ObjQt.pro create mode 100644 QtCore/QtChildEvent.h create mode 100644 QtCore/QtChildEvent.mm create mode 100644 QtCore/QtCoreApplication.h create mode 100644 QtCore/QtCoreApplication.mm create mode 100644 QtCore/QtEvent.h create mode 100644 QtCore/QtEvent.mm create mode 100644 QtCore/QtObject.h create mode 100644 QtCore/QtObject.mm create mode 100644 QtCore/QtThread.h create mode 100644 QtCore/QtThread.mm create mode 100644 QtGui/QtGuiApplication.h create mode 100644 QtGui/QtGuiApplication.mm create mode 100644 QtWidgets/QtApplication.h create mode 100644 QtWidgets/QtApplication.mm create mode 100644 common/QtOwnershipManaging.h create mode 100644 common/helpers.h diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..ed84614 --- /dev/null +++ b/.gitignore @@ -0,0 +1,4 @@ +*~ +.qmake.stash +build +Makefile diff --git a/ObjQt.pro b/ObjQt.pro new file mode 100644 index 0000000..879e870 --- /dev/null +++ b/ObjQt.pro @@ -0,0 +1,35 @@ +TEMPLATE = lib +TARGET = ObjQt +DESTDIR = build +OBJECTS_DIR = build +QT += core gui widgets + +INCLUDEPATH += common \ + QtCore \ + QtGui \ + QtWidgets + +HEADERS += common/helpers.h \ + common/QtOwnershipManaging.h \ + QtCore/QtChildEvent.h \ + QtCore/QtCoreApplication.h \ + QtCore/QtEvent.h \ + QtCore/QtObject.h \ + QtCore/QtThread.h \ + QtGui/QtGuiApplication.h \ + QtWidgets/QtApplication.h + +SOURCES += QtCore/QtChildEvent.mm \ + QtCore/QtCoreApplication.mm \ + QtCore/QtEvent.mm \ + QtCore/QtObject.mm \ + QtCore/QtThread.mm \ + QtGui/QtGuiApplication.mm \ + QtWidgets/QtApplication.mm + +QMAKE_CXXFLAGS += $$system("objfw-config --cppflags --objcflags --cxxflags") +QMAKE_CXXFLAGS_WARN_ON = -Wall \ + -Werror \ + -Wsemicolon-before-method-body \ + -Wobjc-missing-property-synthesis +LIBS += $$system("objfw-config --ldflags --libs") diff --git a/QtCore/QtChildEvent.h b/QtCore/QtChildEvent.h new file mode 100644 index 0000000..810848e --- /dev/null +++ b/QtCore/QtChildEvent.h @@ -0,0 +1,15 @@ +#import "QtEvent.h" + +@class QtObject; + +@interface QtChildEvent: QtEvent +@property (readonly) QChildEvent *qChildEvent; +@property (readonly, getter=isAdded) bool added; +@property (readonly, retain) QtObject *child; +@property (readonly, getter=isPolished) bool polished; +@property (readonly, getter=isRemoved) bool removed; + +- initWithQChildEvent: (QChildEvent*)qChildEvent; +- initWithType: (QChildEvent::Type)type + child: (QtObject*)child; +@end diff --git a/QtCore/QtChildEvent.mm b/QtCore/QtChildEvent.mm new file mode 100644 index 0000000..e386179 --- /dev/null +++ b/QtCore/QtChildEvent.mm @@ -0,0 +1,53 @@ +#import "QtChildEvent.h" +#import "QtObject.h" + +@implementation QtChildEvent +- initWithQEvent: (QEvent*)event +{ + OF_INVALID_INIT_METHOD +} + +- initWithQChildEvent: (QChildEvent*)event +{ + return [super initWithQEvent: event]; +} + +- initWithType: (QChildEvent::Type)type + child: (QtObject*)child +{ + try { + return [self initWithQChildEvent: + new QChildEvent(type, [child qObject])]; + } catch (const std::bad_alloc &e) { + self = [super initWithQEvent: NULL]; + [self release]; + throw; + } +} + +- (QChildEvent*)qChildEvent +{ + return dynamic_cast(_qEvent); +} + +- (bool)isAdded +{ + return [self qChildEvent]->added(); +} + +- (QtObject*)child +{ + return [[[QtObject alloc] + initWithQObject: [self qChildEvent]->child()] autorelease]; +} + +- (bool)isPolished +{ + return [self qChildEvent]->polished(); +} + +- (bool)isRemoved +{ + return [self qChildEvent]->removed(); +} +@end diff --git a/QtCore/QtCoreApplication.h b/QtCore/QtCoreApplication.h new file mode 100644 index 0000000..9f3af32 --- /dev/null +++ b/QtCore/QtCoreApplication.h @@ -0,0 +1,17 @@ +#import "QtObject.h" + +#include + +@interface QtCoreApplication: QtObject +@property (readonly) QCoreApplication *qCoreApplication; +@property (copy) OFString *applicationName, *applicationVersion; +@property (copy) OFString *organizationDomain, *organizationName; +@property (getter=isQuitLockEnabled) bool quitLockEnabled; + +- initWithQCoreApplication: (QCoreApplication*)qCoreApplication; +- (void)installNativeEventFilter: (QAbstractNativeEventFilter*)filterObject; +- (void)quit; +- (void)removeNativeEventFilter: (QAbstractNativeEventFilter*)filterObject; +- (bool)sendEvent: (QtEvent*)event + receiver: (QtObject*)receiver; +@end diff --git a/QtCore/QtCoreApplication.mm b/QtCore/QtCoreApplication.mm new file mode 100644 index 0000000..f17a983 --- /dev/null +++ b/QtCore/QtCoreApplication.mm @@ -0,0 +1,97 @@ +#import "QtCoreApplication.h" +#import "QtEvent.h" + +#import "helpers.h" + +@implementation QtCoreApplication +- initWithQObject: (QObject*)qObject +{ + OF_INVALID_INIT_METHOD +} + +- initWithQCoreApplication: (QCoreApplication*)qCoreApplication +{ + return [super initWithQObject: qCoreApplication]; +} + +- (QCoreApplication*)qCoreApplication +{ + return qobject_cast(_qObject); +} + +- (OFString*)applicationName +{ + return QToOFString([self qCoreApplication]->applicationName()); +} + +- (void)setApplicationName: (OFString*)applicationName +{ + [self qCoreApplication]->setApplicationName( + OFToQString(applicationName)); +} + +- (OFString*)applicationVersion +{ + return QToOFString([self qCoreApplication]->applicationVersion()); +} + +- (void)installNativeEventFilter: (QAbstractNativeEventFilter*)filterObject +{ + [self qCoreApplication]->installNativeEventFilter(filterObject); +} + +- (void)setApplicationVersion: (OFString*)applicationVersion +{ + [self qCoreApplication]->setApplicationVersion( + OFToQString(applicationVersion)); +} + +- (OFString*)organizationDomain +{ + return QToOFString([self qCoreApplication]->organizationDomain()); +} + +- (void)setOrganizationDomain: (OFString*)organizationDomain +{ + [self qCoreApplication]->setOrganizationDomain( + OFToQString(organizationDomain)); +} + +- (OFString*)organizationName +{ + return QToOFString([self qCoreApplication]->organizationName()); +} + +- (void)setOrganizationName: (OFString*)organizationName +{ + [self qCoreApplication]->setOrganizationName( + OFToQString(organizationName)); +} + +- (void)quit +{ + [self qCoreApplication]->quit(); +} + +- (bool)isQuitLockEnabled +{ + return [self qCoreApplication]->isQuitLockEnabled(); +} + +- (void)setQuitLockEnabled: (bool)quitLockEnabled +{ + [self qCoreApplication]->setQuitLockEnabled(quitLockEnabled); +} + +- (void)removeNativeEventFilter: (QAbstractNativeEventFilter*)filterObject +{ + [self qCoreApplication]->removeNativeEventFilter(filterObject); +} + +- (bool)sendEvent: (QtEvent*)event + receiver: (QtObject*)receiver +{ + return [self qCoreApplication]->notify( + [receiver qObject], [event qEvent]); +} +@end diff --git a/QtCore/QtEvent.h b/QtCore/QtEvent.h new file mode 100644 index 0000000..c7ec905 --- /dev/null +++ b/QtCore/QtEvent.h @@ -0,0 +1,22 @@ +#import + +#import "QtOwnershipManaging.h" + +#include + +@interface QtEvent: OFObject +{ + QEvent *_qEvent; + bool _ownsEvent; +} + +@property (readonly) QEvent *qEvent; +@property (getter=isAccepted) bool accepted; +@property (readonly, getter=isSpontaneous) bool spontaneous; +@property (readonly) QEvent::Type type; + ++ (int)registerEventType: (int)hint; +- initWithQEvent: (QEvent*)qEvent; +- (void)accept; +- (void)ignore; +@end diff --git a/QtCore/QtEvent.mm b/QtCore/QtEvent.mm new file mode 100644 index 0000000..b5abf01 --- /dev/null +++ b/QtCore/QtEvent.mm @@ -0,0 +1,74 @@ +#import "QtEvent.h" + +@implementation QtEvent +@synthesize qEvent = _eEvent; + ++ (int)registerEventType: (int)hint +{ + return QEvent::registerEventType(hint); +} + +- init +{ + OF_INVALID_INIT_METHOD +} + +- initWithQEvent: (QEvent*)qEvent +{ + self = [super init]; + + _qEvent = qEvent; + + return self; +} + +- (void)dealloc +{ + if (_ownsEvent) + delete _qEvent; + + [super dealloc]; +} + +- (void)takeOwnership +{ + OF_ENSURE(!_ownsEvent); + _ownsEvent = true; +} + +- (void)giveUpOwnership +{ + OF_ENSURE(_ownsEvent); + _ownsEvent = false; +} + +- (void)accept +{ + _qEvent->accept(); +} + +- (void)ignore +{ + _qEvent->ignore(); +} + +- (bool)isAccepted +{ + return _qEvent->isAccepted(); +} + +- (void)setAccepted: (bool)accepted +{ + _qEvent->setAccepted(accepted); +} + +- (bool)isSpontaneous +{ + return _qEvent->spontaneous(); +} + +- (QEvent::Type)type +{ + return _qEvent->type(); +} +@end diff --git a/QtCore/QtObject.h b/QtCore/QtObject.h new file mode 100644 index 0000000..7e1f671 --- /dev/null +++ b/QtCore/QtObject.h @@ -0,0 +1,60 @@ +#import + +#import "QtOwnershipManaging.h" + +#include + +@class QtEvent; +@class QtThread; + +@interface QtObject: OFObject +{ + QObject *_qObject; + bool _ownsObject; +} + +@property (readonly) QObject *qObject; +@property (readonly) const QMetaObject *metaObject; +@property (retain) QtObject *parent; +@property (copy) OFString *objectName; + +- initWithQObject: (QObject*)qObject; +- (bool)setBlockSignals: (bool)block; +- (OFArray OF_GENERIC(QtObject*)*)children; +- (QMetaObject::Connection)connectSignal: (OFString*)signal + sender: (QtObject*)sender + method: (OFString*)method + type: (Qt::ConnectionType)type; +- (bool)disconnectSignal: (OFString*)signal + receiver: (QtObject*)receiver + method: (OFString*)method; +- (bool)disconnectAllSignalsForReceiver: (QtObject*)receiver + method: (OFString*)method; +- (void)dumpObjectInfo; +- (void)dumpObjectTree; +- (OFArray OF_GENERIC(OFDataArray*)*)dynamicPropertyNames; +- (bool)handleEvent: (QtEvent*)event; +- (bool)filterEvent: (QtEvent*)event + forObject: (QtObject*)watched; +// MISSING: T findChild(const QString &name = QString(), +// Qt::FindChildOptions options = Qt::FindChildrenRecursively) const; +// MISSING QList findChildren(const QString &name = QString(), +// Qt::FindChildOptions options = Qt::FindChildrenRecursively) const; +// MISSING: QList findChildren(const QRegExp ®Exp, +// Qt::FindChildOptions options = Qt::FindChildrenRecursively) const; +- (bool)inheritsClassWithName: (OFString*)className; +- (void)installEventFilter: (QtObject*)filterObj; +- (bool)isWidgetType; +- (bool)isWindowType; +- (void)killTimerWithID: (int)ID; +- (void)moveToThread: (QtThread*)targetThread; +- (QVariant)propertyForName: (OFString*)name; +- (void)removeEventFilter: (QtObject*)obj; +- (bool)setProperty: (QVariant&)value + forName: (OFString*)name; +- (bool)signalsBlocked; +- (int)startTimerWithInterval: (int)interval + type: (Qt::TimerType)type; +- (QtThread*)thread; +- (void)deleteLater; +@end diff --git a/QtCore/QtObject.mm b/QtCore/QtObject.mm new file mode 100644 index 0000000..04791a6 --- /dev/null +++ b/QtCore/QtObject.mm @@ -0,0 +1,225 @@ +#import "QtObject.h" +#import "QtEvent.h" +#import "QtThread.h" + +#import "helpers.h" + +#include + +@implementation QtObject +@synthesize qObject = _qObject; + +- init +{ + OF_INVALID_INIT_METHOD +} + +- initWithQObject: (QObject*)qObject +{ + self = [super init]; + + _qObject = qObject; + + return self; +} + +- (void)dealloc +{ + if (_ownsObject) + delete _qObject; + + [super dealloc]; +} + +- (void)takeOwnership +{ + OF_ENSURE(!_ownsObject); + _ownsObject = true; +} + +- (void)giveUpOwnership +{ + OF_ENSURE(_ownsObject); + _ownsObject = false; +} + +- (OFString*)objectName +{ + return QToOFString(_qObject->objectName()); +} + +- (void)setObjectName: (OFString*)objectName +{ + _qObject->setObjectName(OFToQString(objectName)); +} + +- (bool)setBlockSignals: (bool)block +{ + return _qObject->blockSignals(block); +} + +- (OFArray OF_GENERIC(QtObject*)*)children +{ + const QObjectList &qChildren = _qObject->children(); + OFMutableArray *children = [OFMutableArray arrayWithCapacity: + qChildren.count()]; + void *pool = objc_autoreleasePoolPush(); + + for (QObject *qChild: qChildren) + [children addObject: + [[[QtObject alloc] initWithQObject: qChild] autorelease]]; + + objc_autoreleasePoolPop(pool); + + return children; +} + +- (QMetaObject::Connection)connectSignal: (OFString*)signal + sender: (QtObject*)sender + method: (OFString*)method + type: (Qt::ConnectionType)type +{ + return _qObject->connect([sender qObject], + [signal UTF8String], [method UTF8String], type); +} + +- (bool)disconnectSignal: (OFString*)signal + receiver: (QtObject*)receiver + method: (OFString*)method +{ + return _qObject->disconnect([signal UTF8String], [receiver qObject], + [method UTF8String]); +} + +- (bool)disconnectAllSignalsForReceiver: (QtObject*)receiver + method: (OFString*)method +{ + return _qObject->disconnect([receiver qObject], [method UTF8String]); +} + +- (void)dumpObjectInfo +{ + _qObject->dumpObjectInfo(); +} + +- (void)dumpObjectTree +{ + _qObject->dumpObjectTree(); +} + +- (OFArray OF_GENERIC(OFDataArray*)*)dynamicPropertyNames +{ + const QList &qDynamicPropertyNames = + _qObject->dynamicPropertyNames(); + OFMutableArray *dynamicPropertyNames = + [OFMutableArray arrayWithCapacity: qDynamicPropertyNames.count()]; + void *pool = objc_autoreleasePoolPush(); + + for (const QByteArray &qDynamicPropertyName: qDynamicPropertyNames) { + OFDataArray *dynamicPropertyName = [OFDataArray dataArray]; + [dynamicPropertyName addItems: qDynamicPropertyName.data() + count: qDynamicPropertyName.count()]; + [dynamicPropertyNames addObject: dynamicPropertyName]; + } + + objc_autoreleasePoolPop(pool); + + return dynamicPropertyNames; +} + +- (bool)handleEvent: (QtEvent*)event +{ + return _qObject->event([event qEvent]); +} + +- (bool)filterEvent: (QtEvent*)event + forObject: (QtObject*)watched +{ + return _qObject->eventFilter([watched qObject], [event qEvent]); +} + +- (bool)inheritsClassWithName: (OFString*)className +{ + return _qObject->inherits([className UTF8String]); +} + +- (void)installEventFilter: (QtObject*)filterObj +{ + _qObject->installEventFilter([filterObj qObject]); +} + +- (bool)isWidgetType +{ + return _qObject->isWidgetType(); +} + +- (bool)isWindowType +{ + return _qObject->isWindowType(); +} + +- (void)killTimerWithID: (int)ID +{ + _qObject->killTimer(ID); +} + +- (const QMetaObject*)metaObject +{ + return _qObject->metaObject(); +} + +- (void)moveToThread: (QtThread*)targetThread +{ + _qObject->moveToThread([targetThread qThread]); +} + +- (QtObject*)parent +{ + return [[[QtObject alloc] + initWithQObject: _qObject->parent()] autorelease]; +} + +- (void)setParent: (QtObject*)parent +{ + _qObject->setParent([parent qObject]); +} + +- (QVariant)propertyForName: (OFString*)name +{ + return _qObject->property([name UTF8String]); +} + +- (void)removeEventFilter: (QtObject*)obj +{ + _qObject->removeEventFilter([obj qObject]); +} + +- (bool)setProperty: (QVariant&)value + forName: (OFString*)name +{ + return _qObject->setProperty([name UTF8String], value); +} + +- (bool)signalsBlocked +{ + return _qObject->signalsBlocked(); +} + +- (int)startTimerWithInterval: (int)interval + type: (Qt::TimerType)type +{ + return _qObject->startTimer(interval, type); +} + +- (QtThread*)thread +{ + return [[[QtThread alloc] + initWithQThread: _qObject->thread()] autorelease]; +} + +- (void)deleteLater +{ + OF_ENSURE(!_ownsObject); + _qObject->deleteLater(); +} +@end diff --git a/QtCore/QtThread.h b/QtCore/QtThread.h new file mode 100644 index 0000000..d311320 --- /dev/null +++ b/QtCore/QtThread.h @@ -0,0 +1,22 @@ +#import "QtObject.h" + +#include + +@interface QtThread: QtObject +@property (readonly) QThread *qThread; +@property QAbstractEventDispatcher *eventDispatcher; +@property (readonly, getter=isFinished) bool finished; +@property (readonly, getter=isInterruptionRequested) bool interruptionRequested; +@property (readonly, getter=isRunning) bool running; +@property (readonly) int loopLevel; +@property QThread::Priority priority; +@property unsigned int stackSize; + +- initWithQThread: (QThread*)qThread; +- (void)exitWithReturnCode: (int)returnCode; +- (void)requestInterruption; +- (bool)waitForMilliseconds: (unsigned long)time; +- (void)quit; +- (void)startWithPriority: (QThread::Priority)priority; +- (void)terminate; +@end diff --git a/QtCore/QtThread.mm b/QtCore/QtThread.mm new file mode 100644 index 0000000..bb98ce8 --- /dev/null +++ b/QtCore/QtThread.mm @@ -0,0 +1,98 @@ +#import "QtThread.h" + +@implementation QtThread: QtObject +- initWithQObject: (QObject*)qObject +{ + OF_INVALID_INIT_METHOD +} + +- initWithQThread: (QThread*)qThread +{ + return [super initWithQObject: qThread]; +} + +- (QThread*)qThread +{ + return qobject_cast(_qObject); +} + +- (QAbstractEventDispatcher*)eventDispatcher +{ + return [self qThread]->eventDispatcher(); +} + +- (void)setEventDispatcher: (QAbstractEventDispatcher*)eventDispatcher +{ + [self qThread]->setEventDispatcher(eventDispatcher); +} + +- (void)exitWithReturnCode: (int)returnCode +{ + [self qThread]->exit(returnCode); +} + +- (bool)isFinished +{ + return [self qThread]->isFinished(); +} + +- (bool)isInterruptionRequested +{ + return [self qThread]->isInterruptionRequested(); +} + +- (bool)isRunning +{ + return [self qThread]->isRunning(); +} + +- (int)loopLevel +{ + return [self qThread]->loopLevel(); +} + +- (QThread::Priority)priority +{ + return [self qThread]->priority(); +} + +- (void)setPriority: (QThread::Priority)priority +{ + [self qThread]->setPriority(priority); +} + +- (void)requestInterruption +{ + [self qThread]->requestInterruption(); +} + +- (unsigned int)stackSize +{ + return [self qThread]->stackSize(); +} + +- (void)setStackSize: (unsigned int)stackSize +{ + [self qThread]->setStackSize(stackSize); +} + +- (bool)waitForMilliseconds: (unsigned long)time +{ + return [self qThread]->wait(time); +} + +- (void)quit +{ + [self qThread]->quit(); +} + +- (void)startWithPriority: (QThread::Priority)priority +{ + [self qThread]->start(priority); +} + +- (void)terminate +{ + [self qThread]->terminate(); +} +@end diff --git a/QtGui/QtGuiApplication.h b/QtGui/QtGuiApplication.h new file mode 100644 index 0000000..956125d --- /dev/null +++ b/QtGui/QtGuiApplication.h @@ -0,0 +1,21 @@ +#import "QtCoreApplication.h" + +#include + +@interface QtGuiApplication: QtCoreApplication +@property (readonly) QGuiApplication *qGuiApplication; +@property (copy) OFString *applicationDisplayName; +@property (copy) OFString *desktopFileName; +@property Qt::LayoutDirection layoutDirection; +@property (readonly, copy) OFString *platformName; +@property (readonly) QScreen *primaryScreen; +@property bool quitOnLastWindowClosed; +@property QIcon windowIcon; + +- initWithQGuiApplication: (QGuiApplication*)qGuiApplication; +- (double)devicePixelRatio; +- (bool)isSavingSession; +- (bool)isSessionRestored; +- (OFString*)sessionID; +- (OFString*)sessionKey; +@end diff --git a/QtGui/QtGuiApplication.mm b/QtGui/QtGuiApplication.mm new file mode 100644 index 0000000..bb15d7f --- /dev/null +++ b/QtGui/QtGuiApplication.mm @@ -0,0 +1,110 @@ +#import "QtGuiApplication.h" + +#import "helpers.h" + +#include + +@implementation QtGuiApplication +- initWithQCoreApplication: (QCoreApplication*)qCoreApplication +{ + OF_INVALID_INIT_METHOD +} + +- initWithQGuiApplication: (QGuiApplication*)qGuiApplication +{ + return [super initWithQCoreApplication: qGuiApplication]; +} + +- (QGuiApplication*)qGuiApplication +{ + return qobject_cast(_qObject); +} + +- (OFString*)applicationDisplayName +{ + return QToOFString([self qGuiApplication]->applicationDisplayName()); +} + +- (void)setApplicationDisplayName: (OFString*)applicationDisplayName +{ + [self qGuiApplication]->setApplicationDisplayName( + OFToQString(applicationDisplayName)); +} + +- (OFString*)desktopFileName +{ + return QToOFString([self qGuiApplication]->desktopFileName()); +} + +- (void)setDesktopFileName: (OFString*)desktopFileName +{ + [self qGuiApplication]->setDesktopFileName( + OFToQString(desktopFileName)); +} + +- (double)devicePixelRatio +{ + return [self qGuiApplication]->devicePixelRatio(); +} + +- (bool)isSavingSession +{ + return [self qGuiApplication]->isSavingSession(); +} + +- (bool)isSessionRestored +{ + return [self qGuiApplication]->isSessionRestored(); +} + +- (Qt::LayoutDirection)layoutDirection +{ + return [self qGuiApplication]->layoutDirection(); +} + +- (void)setLayoutDirection: (Qt::LayoutDirection)layoutDirection +{ + [self qGuiApplication]->setLayoutDirection(layoutDirection); +} + +- (OFString*)platformName +{ + return QToOFString([self qGuiApplication]->platformName()); +} + +- (QScreen*)primaryScreen +{ + return [self qGuiApplication]->primaryScreen(); +} + +- (bool)quitOnLastWindowClosed +{ + return [self qGuiApplication]->quitOnLastWindowClosed(); +} + +- (void)setQuitOnLastWindowClosed: (bool)quitOnLastWindowClosed +{ + [self qGuiApplication]->setQuitOnLastWindowClosed( + quitOnLastWindowClosed); +} + +- (OFString*)sessionID +{ + return QToOFString([self qGuiApplication]->sessionId()); +} + +- (OFString*)sessionKey +{ + return QToOFString([self qGuiApplication]->sessionKey()); +} + +- (QIcon)windowIcon +{ + return [self qGuiApplication]->windowIcon(); +} + +- (void)setWindowIcon: (QIcon)windowIcon +{ + [self qGuiApplication]->setWindowIcon(windowIcon); +} +@end diff --git a/QtWidgets/QtApplication.h b/QtWidgets/QtApplication.h new file mode 100644 index 0000000..b449f1b --- /dev/null +++ b/QtWidgets/QtApplication.h @@ -0,0 +1,22 @@ +#import "QtGuiApplication.h" + +#include + +@interface QtApplication: QtGuiApplication +@property (readonly) QApplication *qApplication; +@property bool autoSipEnabled; +@property int cursorFlashTime; +@property int doubleClickInterval; +@property QSize globalStrut; +@property int keyboardInputInterval; +@property int startDragDistance; +@property int startDragTime; +@property (copy) OFString *styleSheet; +@property int wheelScrollLines; + +- initWithQApplication: (QApplication*)qApplication; +- (void)aboutQt; +- (bool)autoSipEnabled; +- (void)closeAllWindows; +- (void)setAutoSipEnabled: (bool)enabled; +@end diff --git a/QtWidgets/QtApplication.mm b/QtWidgets/QtApplication.mm new file mode 100644 index 0000000..c4fe85d --- /dev/null +++ b/QtWidgets/QtApplication.mm @@ -0,0 +1,120 @@ +#import "QtApplication.h" + +#import "helpers.h" + +@implementation QtApplication +- initWithQGuiApplication: (QGuiApplication*)qGuiApplication +{ + OF_INVALID_INIT_METHOD +} + +- initWithQApplication: (QApplication*)qApplication +{ + return [super initWithQGuiApplication: qApplication]; +} + +- (QApplication*)qApplication +{ + return qobject_cast(_qObject); +} + +- (bool)autoSipEnabled +{ + return [self qApplication]->autoSipEnabled(); +} + +- (void)setAutoSipEnabled: (bool)autoSipEnabled +{ + [self qApplication]->setAutoSipEnabled(autoSipEnabled); +} + +- (int)cursorFlashTime +{ + return [self qApplication]->cursorFlashTime(); +} + +- (void)setCursorFlashTime: (int)cursorFlashTime +{ + [self qApplication]->setCursorFlashTime(cursorFlashTime); +} + +- (int)doubleClickInterval +{ + return [self qApplication]->doubleClickInterval(); +} + +- (void)setDoubleClickInterval: (int)doubleClickInterval +{ + [self qApplication]->setDoubleClickInterval(doubleClickInterval); +} + +- (QSize)globalStrut +{ + return [self qApplication]->globalStrut(); +} + +- (void)setGlobalStrut: (QSize)globalStrut +{ + [self qApplication]->setGlobalStrut(globalStrut); +} + +- (int)keyboardInputInterval +{ + return [self qApplication]->keyboardInputInterval(); +} + +- (void)setKeyboardInputInterval: (int)keyboardInputInterval +{ + [self qApplication]->setKeyboardInputInterval(keyboardInputInterval); +} + +- (int)startDragDistance +{ + return [self qApplication]->startDragDistance(); +} + +- (void)setStartDragDistance: (int)startDragDistance +{ + [self qApplication]->setStartDragDistance(startDragDistance); +} + +- (int)startDragTime +{ + return [self qApplication]->startDragTime(); +} + +- (void)setStartDragTime: (int)startDragTime +{ + [self qApplication]->setStartDragTime(startDragTime); +} + +- (OFString*)styleSheet +{ + return QToOFString([self qApplication]->styleSheet()); +} + +- (void)setStyleSheet: (OFString*)styleSheet +{ + [self qApplication]->setStyleSheet(OFToQString(styleSheet)); +} + +- (int)wheelScrollLines +{ + return [self qApplication]->wheelScrollLines(); +} + +- (void)setWheelScrollLines: (int)wheelScrollLines +{ + [self qApplication]->setWheelScrollLines(wheelScrollLines); +} + +- (void)aboutQt +{ + [self qApplication]->aboutQt(); +} + +- (void)closeAllWindows +{ + [self qApplication]->closeAllWindows(); +} +@end diff --git a/common/QtOwnershipManaging.h b/common/QtOwnershipManaging.h new file mode 100644 index 0000000..28f71bf --- /dev/null +++ b/common/QtOwnershipManaging.h @@ -0,0 +1,6 @@ +#import + +@protocol QtOwnershipManaging +- (void)takeOwnership; +- (void)giveUpOwnership; +@end diff --git a/common/helpers.h b/common/helpers.h new file mode 100644 index 0000000..5d70873 --- /dev/null +++ b/common/helpers.h @@ -0,0 +1,15 @@ +#import + +#include + +inline OFString* +QToOFString(const QString &qString) +{ + return [OFString stringWithUTF8String: qString.toUtf8()]; +} + +inline QString +OFToQString(OFString *string) +{ + return QString::fromUtf8([string UTF8String]); +}