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  · 

Qutlook Example (ActiveQt)

Files:

The Qutlook example demonstrates the use of ActiveQt to automate Outlook. The example makes use of the dumpcpp tool to generate a C++ namespace for the type library describing the Outlook Object Model.

The project file for the example looks like this:

    TEMPLATE = app
    TARGET   = qutlook
    CONFIG  += qaxcontainer

    TYPELIBS = $$system(dumpcpp -getfile {00062FFF-0000-0000-C000-000000000046})

    isEmpty(TYPELIBS) {
        message("Microsoft Outlook type library not found!")
        REQUIRES += Outlook
    } else {
        HEADERS  = addressview.h
        SOURCES  = addressview.cpp main.cpp
    }

The project file uses the dumpcpp tool to add an MS Outlook type library to the project. If this fails, then the generated makefile will just print an error message, otherwise the build step will now run the dumpcpp tool on the type library, and generate a header and a cpp file (in this case, msoutl.h and msoutl.cpp) that declares and implement an easy to use API to the Outlook objects.

    class AddressView : public QWidget
    {
        Q_OBJECT

    public:
        AddressView(QWidget *parent = 0);

    protected slots:
        void addEntry();
        void changeEntry();
        void itemSelected(const QModelIndex &index);

        void updateOutlook();

    protected:
        AddressBookModel *model;

        QTreeView *treeView;
        QPushButton *add, *change;
        QLineEdit *iFirstName, *iLastName, *iAddress, *iEMail;
    };

The AddressView class is a QWidget subclass for the user interface. The QTreeView widget will display the contents of Outlook's Contact folder as provided by the model.

    #include "addressview.h"
    #include "msoutl.h"
    #include <QtGui>

    class AddressBookModel : public QAbstractListModel
    {
    public:
        AddressBookModel(AddressView *parent);
        ~AddressBookModel();

        int rowCount(const QModelIndex &parent = QModelIndex()) const;
        int columnCount(const QModelIndex &parent) const;
        QVariant headerData(int section, Qt::Orientation orientation, int role) const;
        QVariant data(const QModelIndex &index, int role) const;

        void changeItem(const QModelIndex &index, const QString &firstName, const QString &lastName, const QString &address, const QString &email);
        void addItem(const QString &firstName, const QString &lastName, const QString &address, const QString &email);
        void update();

    private:
        Outlook::Application outlook;
        Outlook::Items * contactItems;

        mutable QHash<QModelIndex, QStringList> cache;
    };

The AddressBookModel class is a QAbstractListModel subclass that communicates directly with Outlook, using a QHash for caching.

    AddressBookModel::AddressBookModel(AddressView *parent)
    : QAbstractListModel(parent)
    {
        if (!outlook.isNull()) {
            Outlook::NameSpace session(outlook.Session());
            session.Logon();
            Outlook::MAPIFolder *folder = session.GetDefaultFolder(Outlook::olFolderContacts);
            contactItems = new Outlook::Items(folder->Items());
            connect(contactItems, SIGNAL(ItemAdd(IDispatch*)), parent, SLOT(updateOutlook()));
            connect(contactItems, SIGNAL(ItemChange(IDispatch*)), parent, SLOT(updateOutlook()));
            connect(contactItems, SIGNAL(ItemRemove()), parent, SLOT(updateOutlook()));

            delete folder;
        }
    }

The constructor initializes Outlook. The various signals Outlook provides to notify about contents changes are connected to the updateOutlook() slot.

    AddressBookModel::~AddressBookModel()
    {
        delete contactItems;

        if (!outlook.isNull())
            Outlook::NameSpace(outlook.Session()).Logoff();
    }

The destructor logs off from the session.

    int AddressBookModel::rowCount(const QModelIndex &) const
    {
        return contactItems ? contactItems->Count() : 0;
    }

    int AddressBookModel::columnCount(const QModelIndex &parent) const
    {
        return 4;
    }

The rowCount() implementation returns the number of entries as reported by Outlook. columnCount and headerData are implemented to show four columns in the tree view.

    QVariant AddressBookModel::headerData(int section, Qt::Orientation orientation, int role) const
    {
        if (role != Qt::DisplayRole)
            return QVariant();

        switch (section) {
        case 0:
            return tr("First Name");
        case 1:
            return tr("Last Name");
        case 2:
            return tr("Address");
        case 3:
            return tr("Email");
        default:
            break;
        }

        return QVariant();
    }

The headerData() implementation returns hardcoded strings.

    QVariant AddressBookModel::data(const QModelIndex &index, int role) const
    {
        if (!index.isValid() || role != Qt::DisplayRole)
            return QVariant();

        QStringList data;
        if (cache.contains(index)) {
            data = cache.value(index);
        } else {
            Outlook::ContactItem contact(contactItems->Item(index.row() + 1));
            data << contact.FirstName() << contact.LastName() << contact.HomeAddress() << contact.Email1Address();
            cache.insert(index, data);
        }

        if (index.column() < data.count())
            return data.at(index.column());

        return QVariant();
    }

The data() implementation is the core of the model. If the requested data is in the cache the cached value is used, otherwise the data is acquired from Outlook.

    void AddressBookModel::changeItem(const QModelIndex &index, const QString &firstName, const QString &lastName, const QString &address, const QString &email)
    {
        Outlook::ContactItem item(contactItems->Item(index.row() + 1));

        item.SetFirstName(firstName);
        item.SetLastName(lastName);
        item.SetHomeAddress(address);
        item.SetEmail1Address(email);

        item.Save();

        cache.take(index);
    }

The changeItem() slot is called when the user changes the current entry using the user interface. The Outlook item is accessed using the Outlook API, and is modified using the property setters. Finally, the item is saved to Outlook, and removed from the cache. Note that the model does not signal the view of the data change, as Outlook will emit a signal on it's own.

    void AddressBookModel::addItem(const QString &firstName, const QString &lastName, const QString &address, const QString &email)
    {
        Outlook::ContactItem item(outlook.CreateItem(Outlook::olContactItem));
        if (!item.isNull()) {
            item.SetFirstName(firstName);
            item.SetLastName(lastName);
            item.SetHomeAddress(address);
            item.SetEmail1Address(email);

            item.Save();
        }
    }

The addItem() slot calls the CreateItem method of Outlook to create a new contact item, sets the properties of the new item to the values entered by the user and saves the item.

    void AddressBookModel::update()
    {
        cache.clear();

        emit reset();
    }

The update() slot clears the cache, and emits the reset() signal to notify the view about the data change requiring a redraw of the contents.

    AddressView::AddressView(QWidget *parent)
    : QWidget(parent)
    {
        QGridLayout *mainGrid = new QGridLayout(this);

        QLabel *liFirstName = new QLabel("First &Name", this);
        liFirstName->resize(liFirstName->sizeHint());
        mainGrid->addWidget(liFirstName, 0, 0);

        QLabel *liLastName = new QLabel("&Last Name", this);
        liLastName->resize(liLastName->sizeHint());
        mainGrid->addWidget(liLastName, 0, 1);

        QLabel *liAddress = new QLabel("Add&ress", this);
        liAddress->resize(liAddress->sizeHint());
        mainGrid->addWidget(liAddress, 0, 2);

        QLabel *liEMail = new QLabel("&E-Mail", this);
        liEMail->resize(liEMail->sizeHint());
        mainGrid->addWidget(liEMail, 0, 3);

        add = new QPushButton("A&dd", this);
        add->resize(add->sizeHint());
        mainGrid->addWidget(add, 0, 4);
        connect(add, SIGNAL(clicked()), this, SLOT(addEntry()));

        iFirstName = new QLineEdit(this);
        iFirstName->resize(iFirstName->sizeHint());
        mainGrid->addWidget(iFirstName, 1, 0);
        liFirstName->setBuddy(iFirstName);

        iLastName = new QLineEdit(this);
        iLastName->resize(iLastName->sizeHint());
        mainGrid->addWidget(iLastName, 1, 1);
        liLastName->setBuddy(iLastName);

        iAddress = new QLineEdit(this);
        iAddress->resize(iAddress->sizeHint());
        mainGrid->addWidget(iAddress, 1, 2);
        liAddress->setBuddy(iAddress);

        iEMail = new QLineEdit(this);
        iEMail->resize(iEMail->sizeHint());
        mainGrid->addWidget(iEMail, 1, 3);
        liEMail->setBuddy(iEMail);

        change = new QPushButton("&Change", this);
        change->resize(change->sizeHint());
        mainGrid->addWidget(change, 1, 4);
        connect(change, SIGNAL(clicked()), this, SLOT(changeEntry()));

        treeView = new QTreeView(this);
        treeView->setSelectionMode(QTreeView::SingleSelection);
        treeView->setRootIsDecorated(false);

        model = new AddressBookModel(this);
        treeView->setModel(model);

        connect(treeView->selectionModel(), SIGNAL(currentChanged(QModelIndex, QModelIndex)), this, SLOT(itemSelected(QModelIndex)));

        mainGrid->addWidget(treeView, 2, 0, 1, 5);
    }

    void AddressView::updateOutlook()
    {
        model->update();
    }

    void AddressView::addEntry()
    {
        if (!iFirstName->text().isEmpty() || !iLastName->text().isEmpty() ||
             !iAddress->text().isEmpty() || !iEMail->text().isEmpty()) {
            model->addItem(iFirstName->text(), iFirstName->text(), iAddress->text(), iEMail->text());
        }

        iFirstName->setText("");
        iLastName->setText("");
        iAddress->setText("");
        iEMail->setText("");
    }

    void AddressView::changeEntry()
    {
        QModelIndex current = treeView->currentIndex();

        if (current.isValid())
            model->changeItem(current, iFirstName->text(), iLastName->text(), iAddress->text(), iEMail->text());
    }

    void AddressView::itemSelected(const QModelIndex &index)
    {
        if (!index.isValid())
            return;

        QAbstractItemModel *model = treeView->model();
        iFirstName->setText(model->data(model->index(index.row(), 0)).toString());
        iLastName->setText(model->data(model->index(index.row(), 1)).toString());
        iAddress->setText(model->data(model->index(index.row(), 2)).toString());
        iEMail->setText(model->data(model->index(index.row(), 3)).toString());
    }

The rest of the file implements the user interface using only Qt APIs, i.e. without communicating with Outlook directly.

    #include "addressview.h"
    #include <QApplication>

    int main(int argc, char ** argv)
    {
        QApplication a(argc, argv);

        AddressView view;
        view.setWindowTitle("Qt Example - Looking at Outlook");
        view.show();

        return a.exec();
    }

The main() entry point function finally instantiates the user interface and enters the event loop.

To build the example you must first build the QAxContainer library. Then run your make tool in examples/activeqt/qutlook and run the resulting qutlook.exe.

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 64
  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. Les développeurs ignorent-ils trop les failles découvertes dans leur code ? Prenez-vous en compte les remarques des autres ? 17
  4. BlackBerry 10 : premières images du prochain OS de RIM qui devrait intégrer des widgets et des tuiles inspirées de Windows Phone 0
  5. Quelles nouveautés de C++11 Visual C++ doit-il rapidement intégrer ? Donnez-nous votre avis 10
  6. Adieu qmake, bienvenue qbs : Qt Building Suite, un outil déclaratif et extensible pour la compilation de projets Qt 17
  7. La rubrique Qt a besoin de vous ! 1
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