QAxBase Class

Die Klasse QAxBase ist eine abstrakte Klasse, die eine API für die Initialisierung und den Zugriff auf ein COM-Objekt bietet. Mehr...

Kopfzeile: #include <QAxBase>
CMake: find_package(Qt6 REQUIRED COMPONENTS AxContainer)
target_link_libraries(mytarget PRIVATE Qt6::AxContainer)
qmake: QT += axcontainer
Vererbt von:

QAxObject und QAxWidget

Öffentliche Typen

Öffentliche Funktionen

virtual ~QAxBase()
QVariant asVariant() const
ulong classContext() const
void clear()
QString control() const
void disableClassInfo()
void disableEventSink()
void disableMetaObject()
QVariant dynamicCall(const char *function, const QVariant &var1 = QVariant(), const QVariant &var2 = QVariant(), const QVariant &var3 = QVariant(), const QVariant &var4 = QVariant(), const QVariant &var5 = QVariant(), const QVariant &var6 = QVariant(), const QVariant &var7 = QVariant(), const QVariant &var8 = QVariant())
QVariant dynamicCall(const char *function, QList<QVariant> &vars)
QString generateDocumentation()
bool isNull() const
QAxBase::PropertyBag propertyBag() const
virtual bool propertyWritable(const char *prop) const
long queryInterface(const QUuid &uuid, void **iface) const
QAxObject *querySubObject(const char *name, const QVariant &var1 = QVariant(), const QVariant &var2 = QVariant(), const QVariant &var3 = QVariant(), const QVariant &var4 = QVariant(), const QVariant &var5 = QVariant(), const QVariant &var6 = QVariant(), const QVariant &var7 = QVariant(), const QVariant &var8 = QVariant())
QAxObject *querySubObject(const char *name, QList<QVariant> &vars)
void setClassContext(ulong classContext)
void setPropertyBag(const QAxBase::PropertyBag &bag)
virtual void setPropertyWritable(const char *prop, bool ok)
QStringList verbs() const

Geschützte Funktionen

QAxBase()
virtual bool initialize(IUnknown **ptr)
bool initializeActive(IUnknown **ptr)
bool initializeFromFile(IUnknown **ptr)
bool initializeLicensed(IUnknown **ptr)
bool initializeRemote(IUnknown **ptr)

Detaillierte Beschreibung

QAxBase ist eine abstrakte Klasse, die nicht direkt verwendet werden kann, sondern über die Unterklassen QAxObject und QAxWidget instanziiert wird. Diese Klasse bietet die API für den direkten Zugriff auf das COM-Objekt über ihre IUnknown-Implementierung. Wenn das COM-Objekt die IDispatch-Schnittstelle implementiert, werden die Eigenschaften und Methoden dieses Objekts als Qt-Eigenschaften und Slots verfügbar.

connect(buttonBack, SIGNAL(clicked()), webBrowser, SLOT(GoBack()));

Eigenschaften, die durch die IDispatch-Implementierung des Objekts offengelegt werden, können über das vom Qt-Objektmodell bereitgestellte Eigenschaftssystem gelesen und geschrieben werden (beide Unterklassen sind QObjects, so dass Sie QObject::setProperty() und QObject::property() verwenden können). Eigenschaften mit mehreren Parametern werden nicht unterstützt.

activeX->setProperty("text", "some text");
int value = activeX->property("value");

Schreibfunktionen für Eigenschaften und andere Methoden, die von der IDispatch-Implementierung des Objekts bereitgestellt werden, können direkt mit dynamicCall() oder indirekt als Slots, die mit einem Signal verbunden sind, aufgerufen werden.

webBrowser->dynamicCall("GoHome()");

Ausgehende Ereignisse, die vom COM-Objekt unterstützt werden, werden als Standard Qt-Signale ausgegeben.

connect(webBrowser, SIGNAL(TitleChanged(QString)),
        this, SLOT(setCaption(QString)));

QAxBase konvertiert transparent zwischen COM-Datentypen und den entsprechenden Qt-Datentypen. Einige COM-Typen haben keine äquivalente Qt-Datenstruktur.

Die unterstützten COM-Datentypen sind in der ersten Spalte der folgenden Tabelle aufgeführt. In der zweiten Spalte steht der Qt-Typ, der mit den Eigenschaftsfunktionen von QObject verwendet werden kann. Die dritte Spalte ist der Qt-Typ, der im Prototyp der generierten Signale und Slots für In-Parameter verwendet wird, und die letzte Spalte ist der Qt-Typ, der im Prototyp der Signale und Slots für Out-Parameter verwendet wird.

COM-TypQt-EigenschaftIn-ParameterAus-Parameter
VARIANT_BOOLboolboolbool&
BSTRQStringconst QString&QString&
char, short, int, longintintint&
uchar, ushort, uint, ulonguintuintuint&
float, doubledoubledoubledouble&
DATEQDateTimeconst QDateTime&QDateTime&
CYqlonglongqlonglongqlonglong&
OLE_COLORQColorconst QColor&QColor&
SAFEARRAY(VARIANT)QList<QVariant>const QList<QVariant>&QList<QVariant>&
SAFEARRAY(int), SAFEARRAY(double), SAFEARRAY(Date)QList<QVariant>const QList<QVariant>&QList<QVariant>&
SAFEARRAY(BYTE)QByteArrayconst QByteArray&QByteArray&
SAFEARRAY(BSTR)QStringListconst QStringList&QStringList&
VARIANTtypabhängigconst QVariant&QVariant&
IFontDisp*QFontconst QFont&QFont&
IPictureDisp*QPixmapconst QPixmap&QPixmap&
IDispatch*QAxObject*QAxBase::asVariant()QAxObject* (Rückgabewert)
IUnknown*QAxObject*QAxBase::asVariant()QAxObject* (Rückgabewert)
SCODE, DECIMALnicht unterstütztnicht unterstütztnicht unterstützt
VARIANT* (seit Qt 4.5)nicht unterstütztQVariant&QVariant&

Unterstützt werden auch Aufzählungen und Typedefs zu unterstützten Typen.

Um die Methoden einer COM-Schnittstelle aufzurufen, die durch die folgende IDL beschrieben wird

dispinterface IControl
{
properties:
    [id(1)] BSTR text;
    [id(2)] IFontDisp *font;

methods:
    [id(6)] void showColumn([in] int i);
    [id(3)] bool addColumn([in] BSTR t);
    [id(4)] int fillList([in, out] SAFEARRAY(VARIANT) *list);
    [id(5)] IDispatch *item([in] int i);
};

beschrieben werden, verwenden Sie die QAxBase API wie folgt:

QAxObject object("<CLSID>");

QString text = object.property("text").toString();
object.setProperty("font", QFont("Times New Roman", 12));

connect(this, SIGNAL(clicked(int)), &object, SLOT(showColumn(int)));
bool ok = object.dynamicCall("addColumn(const QString&)", "Column 1").toBool();

QList<QVariant> varlist;
QList<QVariant> parameters;
parameters << QVariant(varlist);
int n = object.dynamicCall("fillList(QList<QVariant>&)", parameters).toInt();

QAxObject *item = object.querySubItem("item(int)", 5);

Beachten Sie, dass die QList, die das Objekt füllen soll, als Element in der Parameterliste von QVariants angegeben werden muss.

Wenn Sie auf Eigenschaften zugreifen oder Parameter von nicht unterstützten Datentypen übergeben müssen, müssen Sie direkt auf das COM-Objekt über seine IDispatch Implementierung oder andere Schnittstellen zugreifen. Diese Schnittstellen können über queryInterface() abgerufen werden.

IUnknown *iface = 0;
activeX->queryInterface(IID_IUnknown, (void**)&iface);
if (iface) {
    // use the interface
    iface->Release();
}

Um die Definition der COM-Schnittstellen zu erhalten, müssen Sie die Header-Dateien verwenden, die mit der Komponente, die Sie verwenden möchten, geliefert werden. Einige Compiler können auch Typbibliotheken mit der Compilerdirektive #import importieren. In der Komponentendokumentation finden Sie heraus, welche Typbibliotheken Sie importieren müssen und wie Sie sie verwenden können.

Wenn Sie auf Ereignisse reagieren müssen, die Parameter von nicht unterstützten Datentypen übergeben, können Sie das generische Signal verwenden, das die Ereignisdaten so liefert, wie sie vom COM-Ereignis bereitgestellt werden.

Siehe auch QAxObject, QAxWidget, QAxScript, und ActiveQt Framework.

Dokumentation der Mitgliedstypen

[alias] QAxBase::PropertyBag

Eine QMap<QString,QVariant>, die Eigenschaften als Name:Wert-Paare speichern kann.

Dokumentation der Mitgliedsfunktionen

[protected] QAxBase::QAxBase()

Erzeugt ein QAxBase-Objekt.

[virtual noexcept] QAxBase::~QAxBase()

Beendet das COM-Objekt und vernichtet das Objekt QAxBase.

Siehe auch clear().

QVariant QAxBase::asVariant() const

Gibt eine QVariant zurück, die das COM-Objekt umhüllt. Die Variante kann dann als Parameter z.B. in dynamicCall() verwendet werden.

ulong QAxBase::classContext() const

Gibt den Kontext zurück, in dem das ActiveX-Steuerelement ausgeführt wird (standardmäßig CLSCTX_SERVER).

Siehe auch setClassContext().

void QAxBase::clear()

Trennt die Verbindung und vernichtet das COM-Objekt.

Wenn Sie diese Funktion neu implementieren, müssen Sie auch den Destruktor neu implementieren, um clear() aufzurufen, und diese Implementierung am Ende Ihrer clear()-Funktion aufrufen.

QString QAxBase::control() const

Gibt das ActiveX-Steuerelement zurück.

void QAxBase::disableClassInfo()

Deaktiviert die Generierung von Klasseninformationen für diesen ActiveX-Container. Wenn Sie keine Klasseninformationen über das ActiveX-Steuerelement benötigen, verwenden Sie diese Funktion, um die Erzeugung von Meta-Objekten zu beschleunigen.

Beachten Sie, dass diese Funktion unmittelbar nach der Konstruktion des Objekts aufgerufen werden muss

void QAxBase::disableEventSink()

Deaktiviert die Implementierung der Ereignissenke für diesen ActiveX-Container. Wenn Sie nicht beabsichtigen, auf die Ereignisse des ActiveX-Steuerelements zu hören, verwenden Sie diese Funktion, um die Erzeugung des Metaobjekts zu beschleunigen.

Einige ActiveX-Steuerelemente können instabil sein, wenn sie mit einer Ereignissenke verbunden sind. Um OLE-Ereignisse zu erhalten, müssen Sie Standard-COM-Methoden verwenden, um Ihre eigene Ereignissenke zu registrieren. Verwenden Sie queryInterface(), um Zugriff auf das rohe COM-Objekt zu erhalten.

Beachten Sie, dass diese Funktion unmittelbar nach der Erstellung des Objekts aufgerufen werden sollte.

void QAxBase::disableMetaObject()

Deaktiviert die Erzeugung von Meta-Objekten für diesen ActiveX-Container. Dies deaktiviert auch die Erzeugung von Ereignissen und Klasseninformationen. Wenn Sie nicht beabsichtigen, die Qt-Meta-Objekt-Implementierung zu verwenden, rufen Sie diese Funktion auf, um die Instanziierung des Steuerelements zu beschleunigen. Sie werden immer noch in der Lage sein, das Objekt über dynamicCall() aufzurufen, aber Signale, Slots und Eigenschaften werden nicht mit QObject APIs verfügbar sein.

Einige ActiveX-Steuerelemente sind möglicherweise instabil, wenn sie mit OLE-Automatisierung verwendet werden. Verwenden Sie standardmäßige COM-Methoden, um diese Steuerelemente über die von queryInterface() bereitgestellten COM-Schnittstellen zu verwenden.

Beachten Sie, dass diese Funktion unmittelbar nach der Erstellung des Objekts aufgerufen werden muss.

QVariant QAxBase::dynamicCall(const char *function, const QVariant &var1 = QVariant(), const QVariant &var2 = QVariant(), const QVariant &var3 = QVariant(), const QVariant &var4 = QVariant(), const QVariant &var5 = QVariant(), const QVariant &var6 = QVariant(), const QVariant &var7 = QVariant(), const QVariant &var8 = QVariant())

Ruft die Methode des COM-Objekts function auf, wobei die Parameter var1, var1, var2, var3, var4, var5, var6, var7 und var8 übergeben werden, und gibt den von der Methode zurückgegebenen Wert oder ein ungültiges QVariant zurück, wenn die Methode keinen Wert zurückgibt oder der Funktionsaufruf fehlgeschlagen ist.

Wenn function eine Methode des Objekts ist, muss die Zeichenkette als vollständiger Prototyp angegeben werden, z. B. so, wie sie in einem QObject::connect()-Aufruf geschrieben werden würde.

activeX->dynamicCall("Navigate(const QString&)", "www.qt-project.org");

Alternativ kann eine Funktion aufgerufen werden, indem die Parameter eingebettet in die Zeichenkette übergeben werden, z. B. kann die obige Funktion auch aufgerufen werden mit

activeX->dynamicCall("Navigate(\"www.qt-project.org\")");

Alle Parameter werden als Strings übergeben; es hängt von der Steuerung ab, ob sie korrekt interpretiert werden, und ist langsamer als die Verwendung des Prototyps mit korrekt typisierten Parametern.

Wenn function eine Eigenschaft ist, muss der String der Name der Eigenschaft sein. Der Property Setter wird aufgerufen, wenn var1 eine gültige QVariant ist, andernfalls wird der Getter aufgerufen.

activeX->dynamicCall("Value", 5);
QString text = activeX->dynamicCall("Text").toString();

Beachten Sie, dass es schneller ist, Eigenschaften mit QObject::property() und QObject::setProperty() zu holen und zu setzen.

dynamicCall() kann auch verwendet werden, um Objekte mit einem disabled metaobject Wrapper aufzurufen, was die Leistung erheblich verbessern kann, insbesondere wenn viele verschiedene Objekte unterschiedlichen Typs während eines Automatisierungsprozesses aufgerufen werden. ActiveQt validiert dann allerdings keine Parameter.

Es ist nur möglich, Funktionen über dynamicCall() aufzurufen, die Parameter oder Rückgabewerte von Datentypen haben, die von QVariant unterstützt werden. Eine Liste der unterstützten und nicht unterstützten Datentypen finden Sie in der Dokumentation der Klasse QAxBase. Wenn Sie Funktionen aufrufen möchten, die nicht unterstützte Datentypen in der Parameterliste haben, verwenden Sie queryInterface(), um die entsprechende COM-Schnittstelle abzurufen, und verwenden Sie die Funktion direkt.

IWebBrowser2 *webBrowser = 0;
activeX->queryInterface(IID_IWebBrowser2, (void **)&webBrowser);
if (webBrowser) {
    webBrowser->Navigate2(pvarURL);
    webBrowser->Release();
}

Dies ist auch effizienter.

QVariant QAxBase::dynamicCall(const char *function, QList<QVariant> &vars)

Dies ist eine überladene Funktion.

Ruft die Methode des COM-Objekts function auf, wobei die Parameter in vars übergeben werden, und gibt den von der Methode zurückgegebenen Wert zurück. Wenn die Methode keinen Wert zurückgibt oder wenn der Funktionsaufruf fehlgeschlagen ist, gibt diese Funktion ein ungültiges QVariant Objekt zurück.

Die QVariant Objekte in vars werden aktualisiert, wenn die Methode Out-Parameter hat.

QString QAxBase::generateDocumentation()

Gibt eine Rich-Text-Zeichenkette mit der Dokumentation für das umhüllte COM-Objekt zurück. Geben Sie die Zeichenkette in eine HTML-Datei aus, oder verwenden Sie sie z.B. in einem QTextBrowser Widget.

[virtual protected] bool QAxBase::initialize(IUnknown **ptr)

Diese virtuelle Funktion wird von setControl() aufgerufen und erstellt das gewünschte COM-Objekt. ptr wird auf die IUnknown-Implementierung des Objekts gesetzt. Die Funktion gibt true zurück, wenn die Objektinitialisierung erfolgreich war; andernfalls gibt die Funktion false zurück.

Die Standardimplementierung interpretiert die von control() zurückgegebene Zeichenkette und ruft initializeRemote(), initializeLicensed() oder initializeActive() auf, wenn die Zeichenkette den jeweiligen Mustern entspricht. Wenn control() der Name einer vorhandenen Datei ist, wird initializeFromFile() aufgerufen. Wird kein Muster gefunden oder schlägt die Initialisierung aus der Ferne oder über eine Lizenz fehl, wird CoCreateInstance direkt zur Erstellung des Objekts verwendet.

Einzelheiten zu den unterstützten Mustern finden Sie in der Dokumentation der Eigenschaft QAxBaseWidget::control.

Die in ptr zurückgegebene Schnittstelle muss genau einmal referenziert werden, wenn diese Funktion zurückkehrt. Die Schnittstelle, die z. B. von CoCreateInstance bereitgestellt wird, ist bereits referenziert und muss nicht erneut referenziert werden.

[protected] bool QAxBase::initializeActive(IUnknown **ptr)

Stellt eine Verbindung zu einer aktiven Instanz her, die auf dem aktuellen Rechner läuft, und gibt die Schnittstelle IUnknown zu dem laufenden Objekt in ptr zurück. Diese Funktion gibt bei Erfolg true zurück, andernfalls false.

Diese Funktion wird von initialize() aufgerufen, wenn die Kontrollzeichenfolge die Teilzeichenkette "}&" enthält.

Siehe auch initialize().

[protected] bool QAxBase::initializeFromFile(IUnknown **ptr)

Erzeugt das COM-Objekt, das den Dateinamen in der Control-Eigenschaft verarbeitet, und gibt die Schnittstelle IUnknown zu dem Objekt in ptr zurück. Diese Funktion gibt bei Erfolg true zurück, andernfalls false.

Diese Funktion wird von initialize() aufgerufen, wenn die Steuerzeichenfolge der Name einer vorhandenen Datei ist.

Siehe auch initialize().

[protected] bool QAxBase::initializeLicensed(IUnknown **ptr)

Erzeugt eine Instanz eines lizenzierten Steuerelements und gibt die Schnittstelle IUnknown an das Objekt in ptr zurück. Diese Funktion gibt bei Erfolg true zurück, andernfalls false.

Diese Funktion wird von initialize() aufgerufen, wenn die Steuerzeichenfolge die Teilzeichenkette "}:" enthält. Der Lizenzschlüssel muss auf diese Teilzeichenkette folgen.

Siehe auch initialize().

[protected] bool QAxBase::initializeRemote(IUnknown **ptr)

Erzeugt die Instanz auf einem entfernten Server und gibt die Schnittstelle IUnknown zu dem Objekt in ptr zurück. Diese Funktion gibt bei Erfolg true zurück, andernfalls false.

Diese Funktion wird von initialize() aufgerufen, wenn die Kontrollzeichenkette die Teilzeichenkette "/{" enthält. Die Informationen über den entfernten Rechner müssen vor der Teilzeichenkette angegeben werden.

Siehe auch initialize().

bool QAxBase::isNull() const

Gibt true zurück, wenn es kein COM-Objekt gibt, das von diesem Wrapper geladen wurde; andernfalls wird false zurückgegeben.

Siehe auch control().

QAxBase::PropertyBag QAxBase::propertyBag() const

Gibt eine Name:Wert-Map aller Eigenschaften zurück, die von dem COM-Objekt bereitgestellt werden.

Dies ist effizienter, als mehrere Eigenschaften einzeln abzurufen, wenn das COM-Objekt Property Bags unterstützt.

Warnung: Es ist nicht garantiert, dass die Property Bag-Implementierung des COM-Objekts alle Eigenschaften zurückgibt oder dass die zurückgegebenen Eigenschaften dieselben sind, die über die IDispatch-Schnittstelle verfügbar sind.

Siehe auch setPropertyBag().

[virtual] bool QAxBase::propertyWritable(const char *prop) const

Gibt true zurück, wenn die Eigenschaft prop beschreibbar ist; andernfalls wird false zurückgegeben. Standardmäßig sind alle Eigenschaften beschreibbar.

Achtung! Abhängig von der Implementierung des Steuerelements kann diese Einstellung für einige Eigenschaften ignoriert werden.

Siehe auch setPropertyWritable(), QAxBaseWidget::propertyChanged(), und QAxBaseObject::propertyChanged().

long QAxBase::queryInterface(const QUuid &uuid, void **iface) const

Fordert die Schnittstelle uuid von dem COM-Objekt an und setzt den Wert von iface auf die bereitgestellte Schnittstelle oder auf 0, wenn die angeforderte Schnittstelle nicht bereitgestellt werden konnte.

Gibt das Ergebnis der QueryInterface-Implementierung des COM-Objekts zurück.

Siehe auch control().

QAxObject *QAxBase::querySubObject(const char *name, const QVariant &var1 = QVariant(), const QVariant &var2 = QVariant(), const QVariant &var3 = QVariant(), const QVariant &var4 = QVariant(), const QVariant &var5 = QVariant(), const QVariant &var6 = QVariant(), const QVariant &var7 = QVariant(), const QVariant &var8 = QVariant())

Gibt einen Zeiger auf ein QAxObject zurück, das das von der Methode oder Eigenschaft name bereitgestellte COM-Objekt umhüllt, wobei die Parameter var1, var1, var2, var3, var4, var5, var6, var7 und var8 übergeben werden.

Wenn name von einer Methode bereitgestellt wird, muss der String den vollständigen Funktionsprototyp enthalten.

Wenn name eine Eigenschaft ist, muss der String der Name der Eigenschaft sein, und var1, ... var8 werden ignoriert.

Das zurückgegebene QAxObject ist ein Kind dieses Objekts (das entweder vom Typ QAxObject oder QAxWidget ist) und wird gelöscht, wenn dieses Objekt gelöscht wird. Es ist jedoch sicher, das zurückgegebene Objekt selbst zu löschen, und Sie sollten dies tun, wenn Sie über Listen von Unterobjekten iterieren.

COM-fähige Anwendungen verfügen in der Regel über ein Objektmodell, das bestimmte Elemente der Anwendung als Versandschnittstellen veröffentlicht. Verwenden Sie diese Methode, um in der Hierarchie des Objektmodells zu navigieren, z.B.

QAxWidget outlook("Outlook.Application");
QAxObject *session = outlook.querySubObject("Session");
if (session) {
    QAxObject *defFolder = session->querySubObject(
                            "GetDefaultFolder(OlDefaultFolders)",
                            "olFolderContacts");
    //...
}

QAxObject *QAxBase::querySubObject(const char *name, QList<QVariant> &vars)

Dies ist eine überladene Funktion.

Die Objekte QVariant in vars werden aktualisiert, wenn die Methode Out-Parameter hat.

void QAxBase::setClassContext(ulong classContext)

Legt den Kontext fest, in dem das ActiveX-Steuerelement ausgeführt werden soll classContext

Beeinflusst das Argument "dwClsContext" beim Aufruf von CoCreateInstance. Dies kann verwendet werden, um den In-Proc- oder Out-of-Proc-Start für Steuerelemente zu steuern, die beide Alternativen unterstützen. Es kann auch verwendet werden, um Kontrollberechtigungen zu ändern/reduzieren, wenn es mit CLSCTX_ENABLE_CLOAKING und einem Impersonation Token verwendet wird.

Beachten Sie, dass diese Funktion vor setControl() aufgerufen werden muss, um eine Wirkung zu erzielen.

Siehe auch classContext().

void QAxBase::setPropertyBag(const QAxBase::PropertyBag &bag)

Setzt die Eigenschaften des COM-Objekts auf die entsprechenden Werte in bag.

Warnung: Sie sollten nur Property Bags setzen, die von der Funktion propertyBag zurückgegeben wurden, da nicht garantiert werden kann, dass die Property Bag-Implementierung des COM-Objekts die gleichen Eigenschaften unterstützt, die über die IDispatch-Schnittstelle verfügbar sind.

Siehe auch propertyBag().

[virtual] void QAxBase::setPropertyWritable(const char *prop, bool ok)

Setzt die Eigenschaft prop auf beschreibbar, wenn ok wahr ist, andernfalls wird prop auf schreibgeschützt gesetzt. Standardmäßig sind alle Eigenschaften beschreibbar.

Achtung! Abhängig von der Implementierung des Steuerelements kann diese Einstellung für einige Eigenschaften ignoriert werden.

Siehe auch propertyWritable(), QAxBaseWidget::propertyChanged(), und QAxBaseObject::propertyChanged().

QStringList QAxBase::verbs() const

Gibt die Liste der Verben zurück, die das COM-Objekt ausführen kann. Wenn das Objekt IOleObject nicht implementiert oder keine Verben unterstützt, gibt diese Funktion eine leere Stringliste zurück.

Beachten Sie, dass die OLE-Standardverben (OLEIVERB_SHOW usw.) nicht in der Liste enthalten sind.

© 2025 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.