Viadeo Twitter Google Bookmarks ! Facebook Digg del.icio.us MySpace Yahoo MyWeb Blinklist Netvouz Reddit Simpy StumbleUpon Bookmarks Windows Live Favorites 
Logo Documentation Qt ·  Page d'accueil  ·  Toutes les classes  ·  Classes principales  ·  Annotées  ·  Classes groupées  ·  Modules  ·  Fonctions  · 

COM App Example (ActiveQt)

Files:

The COM App example shows how to use ActiveQt to develop a Qt application that can be automated via COM. Different QObject based classes are exposed as COM objects that communicate with the GUI of the running Qt application. The APIs of those COM objects has been designed to resemble the APIs of standard COM applications; i.e. those from Microsoft Office.

    class Application : public QObject
    {
        Q_OBJECT

        Q_CLASSINFO("ClassID", "{b50a71db-c4a7-4551-8d14-49983566afee}")
        Q_CLASSINFO("InterfaceID", "{4a427759-16ef-4ed8-be79-59ffe5789042}")
        Q_CLASSINFO("RegisterObject", "yes")

        Q_PROPERTY(DocumentList* documents READ documents)
        Q_PROPERTY(QString id READ id)
        Q_PROPERTY(bool visible READ isVisible WRITE setVisible)

    public:
        Application(QObject *parent = 0);
        DocumentList *documents() const;

        QString id() const { return objectName(); }

        void setVisible(bool on);
        bool isVisible() const;

        QTabWidget *window() const { return ui; }

    public slots:
        void quit();

    private:
        DocumentList *docs;

        QTabWidget *ui;
    };

The first class Application represents the application object. It exposes read-only properties documents and id to get access to the list of documents, and an identifier. A read/write property visible controls whether the QTabWidget-based user interface of the application should be visible, and a slot quit() terminates the application.

The RegisterObject attribute is set to make sure that instances of this class are registered in COM's running object table (ROT) - this allows COM clients to connect to an already instantiated COM object.

    class DocumentList : public QObject
    {
        Q_OBJECT

        Q_CLASSINFO("ClassID", "{496b761d-924b-4554-a18a-8f3704d2a9a6}")
        Q_CLASSINFO("InterfaceID", "{6c9e30e8-3ff6-4e6a-9edc-d219d074a148}")

        Q_PROPERTY(Application* application READ application)
        Q_PROPERTY(int count READ count)

    public:
        DocumentList(Application *application);

        int count() const;
        Application *application() const;

    public slots:
        Document *addDocument();
        Document *item(int index) const;

    private:
        QList<Document*> list;
    };

The DocumentList class stores a list of documents. It provides an API to read the number of documents, to access each document by index and to create a new document. The application property returns the root object.

    class Document : public QObject
    {
        Q_OBJECT

        Q_CLASSINFO("ClassID", "{2b5775cd-72c2-43da-bc3b-b0e8d1e1c4f7}")
        Q_CLASSINFO("InterfaceID", "{2ce1761e-07a3-415c-bd11-0eab2c7283de}")

        Q_PROPERTY(Application *application READ application)
        Q_PROPERTY(QString title READ title WRITE setTitle)

    public:
        Document(DocumentList *list);
        ~Document();

        Application *application() const;

        QString title() const;
        void setTitle(const QString &title);

    private:
        QWidget *page;
    };

The Document class finally represents a document in the application. Each document is represented by a page in the application's tab widget, and has a title that is readable and writable through the document's API. The application property again returns the root object.

    Document::Document(DocumentList *list)
    : QObject(list)
    {
        QTabWidget *tabs = list->application()->window();
        page = new QWidget(tabs);
        page->setWindowTitle("Unnamed");
        tabs->addTab(page, page->windowTitle());

        page->show();
    }

    Document::~Document()
    {
        delete page;
    }

    Application *Document::application() const
    {
        return qobject_cast<DocumentList*>(parent())->application();
    }

    QString Document::title() const
    {
        return page->windowTitle();
    }

    void Document::setTitle(const QString &t)
    {
        page->setWindowTitle(t);

        QTabWidget *tabs = application()->window();
        int index = tabs->indexOf(page);
        tabs->setTabText(index, page->windowTitle());
    }

The implementation of the Document class creates a new page for the tab widget, and uses the title of that page for the title property. The page is deleted when the document is deleted.

    DocumentList::DocumentList(Application *application)
    : QObject(application)
    {
    }

    Application *DocumentList::application() const
    {
        return qobject_cast<Application*>(parent());
    }

    int DocumentList::count() const
    {
        return list.count();
    }

    Document *DocumentList::item(int index) const
    {
        if (index >= list.count())
            return 0;

        return list.at(index);
    }

    Document *DocumentList::addDocument()
    {
        Document *document = new Document(this);
        list.append(document);

        return document;
    }

The DocumentList implementation is straightforward.

    Application::Application(QObject *parent)
    : QObject(parent), ui(0)
    {
        ui = new QTabWidget;

        setObjectName("From QAxFactory");
        docs = new DocumentList(this);
    }

    DocumentList *Application::documents() const
    {
        return docs;
    }

    void Application::setVisible(bool on)
    {
        ui->setShown(on);
    }

    bool Application::isVisible() const
    {
        return ui->isVisible();
    }

    void Application::quit()
    {
        delete docs;
        docs = 0;

        delete ui;
        ui = 0;
        QTimer::singleShot(0, qApp, SLOT(quit()));
    }

    #include "main.moc"

The Application class initializes the user interface in the constructor, and shows and hides it in the implementation of setVisible(). The object name (accessible through the id property) is set to "From QAxFactory" to indicate that this COM object has been created by COM. Note that there is no destructor that would delete the QTabWidget - this is instead done in the quit() slot, before calling QApplication::quit() through a single-shot-timer, which is necessary ensure that the COM call to the slot is complete.

    QAXFACTORY_BEGIN("{edd3e836-f537-4c6f-be7d-6014c155cc7a}", "{b7da3de8-83bb-4bbe-9ab7-99a05819e201}")
       QAXCLASS(Application)
       QAXTYPE(Document)
       QAXTYPE(DocumentList)
    QAXFACTORY_END()

The classes are exported from the server using the QAxFactory macros. Only Application objects can be instantiated from outside - the other APIs can only be used after accessing the respective objects throught the Application API.

    int main(int argc, char **argv)
    {
        QApplication app(argc, argv);
        app.setQuitOnLastWindowClosed(false);

        // started by COM - don't do anything
        if (QAxFactory::isServer())
            return app.exec();

        // started by user
        Application appobject(0);
        appobject.setObjectName("From Application");

        QAxFactory::startServer();
        QAxFactory::registerActiveObject(&appobject);

        appobject.setVisible(true);

        QObject::connect(qApp, SIGNAL(lastWindowClosed()), &appobject, SLOT(quit()));

        return app.exec();
    }

The main() entry point function creates a QApplication, and just enters the event loop if the application has been started by COM. If the application has been started by the user, then the Application object is created and the object name is set to "From Application". Then the COM server is started, and the application object is registered with COM. It is now accessible to COM clients through the client-specific APIs.

Application exiting is controlled explicitly - if COM started the application, then the client code has to call quit(); if the user started the application, then the application terminates when the last window has been closed.

Finally, the user interface is made visible, and the event loop is started.

A simple Visual Basic application could now access this Qt application. In VB, start a new "Standard Exe" project and add a project reference to the comappLib type library. Create a form with a listbox "DocumentList", a static label "DocumentsCount" and a command button "NewDocument". Finally, implement the code for the form like this:

    Private Application As comappLib.Application
    Private MyApp As Boolean

    Private Sub UpdateList()
        DocumentList.Clear
        DocumentsCount.Caption = Application.documents.Count
        For Index = 0 To Application.documents.Count - 1
           DocumentList.AddItem (Application.documents.Item(Index).Title)
        Next
    End Sub

    Private Sub Form_Load()
        On Error GoTo CreateNew
        Set Application = GetObject(, "comapp.Application")
        MyApp = False
        GoTo Initialized
    CreateNew:
        On Error GoTo InitializeFailed
        Set Application = New Application
        Application.Visible = True
        MyApp = True
    Initialized:
        Caption = Application.id
        UpdateList
    InitializeFailed:
    End Sub

    Private Sub Form_Unload(Cancel As Integer)
        If MyApp Then
            Application.quit
        End If
    End Sub

    Private Sub NewDocument_Click()
        Application.documents.addDocument
        UpdateList
    End Sub

To build the example you must first build the QAxServer library. Then run qmake and your make tool in examples\activeqt\comapp.

Publicité

Best Of

Actualités les plus lues

Semaine
Mois
Année
  1. « Quelque chose ne va vraiment pas avec les développeurs "modernes" », un développeur à "l'ancienne" critique la multiplication des bibliothèques 94
  2. Apercevoir la troisième dimension ou l'utilisation multithreadée d'OpenGL dans Qt, un article des Qt Quarterly traduit par Guillaume Belz 0
  3. Pourquoi les programmeurs sont-ils moins payés que les gestionnaires de programmes ? Manquent-ils de pouvoir de négociation ? 45
  4. Les développeurs ignorent-ils trop les failles découvertes dans leur code ? Prenez-vous en compte les remarques des autres ? 17
  5. Les développeurs détestent-ils les antivirus ? Un programmeur manifeste sa haine envers ces solutions de sécurité 6
  6. Quelles nouveautés de C++11 Visual C++ doit-il rapidement intégrer ? Donnez-nous votre avis 10
  7. Qt Commercial : Digia organise un webinar gratuit le 27 mars sur la conception d'interfaces utilisateur et d'applications avec le framework 0
Page suivante

Le blog Digia au hasard

Logo

Créer des applications avec un style Metro avec Qt, exemples en QML et C++, un article de Digia Qt traduit par Thibaut Cuvelier

Le blog Digia est l'endroit privilégié pour la communication sur l'édition commerciale de Qt, où des réponses publiques sont apportées aux questions les plus posées au support. Lire l'article.

Communauté

Ressources

Liens utiles

Contact

  • Vous souhaitez rejoindre la rédaction ou proposer un tutoriel, une traduction, une question... ? Postez dans le forum Contribuez ou contactez-nous par MP ou par email (voir en bas de page).

Qt dans le magazine

Cette page est une traduction d'une page de la documentation de Qt, écrite par Nokia Corporation and/or its subsidiary(-ies). Les éventuels problèmes résultant d'une mauvaise traduction ne sont pas imputables à Nokia. Qt 4.1
Copyright © 2012 Developpez LLC. Tous droits réservés Developpez LLC. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents et images sans l'autorisation expresse de Developpez LLC. Sinon, vous encourez selon la loi jusqu'à 3 ans de prison et jusqu'à 300 000 E de dommages et intérêts. Cette page est déposée à la SACD.
Vous avez déniché une erreur ? Un bug ? Une redirection cassée ? Ou tout autre problème, quel qu'il soit ? Ou bien vous désirez participer à ce projet de traduction ? N'hésitez pas à nous contacter ou par MP !
 
 
 
 
Partenaires

Hébergement Web