← Back to branch summary

~mterry/qtorganizer5-eds/cleanup-packaging

« back to all changes in this revision

Viewing changes to qorganizer/qorganizer-eds-engine.h

  • Committer: Renato Araujo Oliveira Filho
  • Date: 2013-08-14 21:23:01 UTC
  • Revision ID: renato.filho@canonical.com-20130814212301-cmqs3nv48cvzy9qq
Initial commit.

Show diffs side-by-side

added added

removed removed

Lines of Context:
qorganizer/qorganizer-eds-engine.h
 
1
/*
 
2
 * Copyright 2013 Canonical Ltd.
 
3
 *
 
4
 * This file is part of canonical-pim-service.
 
5
 *
 
6
 * contact-service-app is free software; you can redistribute it and/or modify
 
7
 * it under the terms of the GNU General Public License as published by
 
8
 * the Free Software Foundation; version 3.
 
9
 *
 
10
 * contact-service-app is distributed in the hope that it will be useful,
 
11
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
12
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
13
 * GNU General Public License for more details.
 
14
 *
 
15
 * You should have received a copy of the GNU General Public License
 
16
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
17
 */
 
18
 
 
19
#ifndef QORGANIZER_EDS_ENGINE_H
 
20
#define QORGANIZER_EDS_ENGINE_H
 
21
 
 
22
#include "qorganizer-eds-collection-engineid.h"
 
23
 
 
24
#include <QtOrganizer/QOrganizerItemId>
 
25
#include <QtOrganizer/QOrganizerItemFetchHint>
 
26
#include <QtOrganizer/QOrganizerManager>
 
27
#include <QtOrganizer/QOrganizerManagerEngine>
 
28
#include <QtOrganizer/QOrganizerItemSortOrder>
 
29
#include <QtOrganizer/QOrganizerItemFilter>
 
30
#include <QtOrganizer/QOrganizerItemChangeSet>
 
31
#include <QtOrganizer/QOrganizerCollectionId>
 
32
 
 
33
#include <libecal/libecal.h>
 
34
class FetchRequestData;
 
35
class SaveRequestData;
 
36
class RemoveRequestData;
 
37
 
 
38
class QOrganizerEDSEngine : public QtOrganizer::QOrganizerManagerEngine
 
39
{
 
40
    Q_OBJECT
 
41
 
 
42
public:
 
43
    static QOrganizerEDSEngine *createEDSEngine(const QMap<QString, QString>& parameters);
 
44
 
 
45
    ~QOrganizerEDSEngine();
 
46
 
 
47
    // URI reporting
 
48
    QString managerName() const;
 
49
    QMap<QString, QString> managerParameters() const;
 
50
 
 
51
 
 
52
    // items
 
53
    QList<QtOrganizer::QOrganizerItem> items(const QList<QtOrganizer::QOrganizerItemId> &itemIds,
 
54
                                              const QtOrganizer::QOrganizerItemFetchHint &fetchHint,
 
55
                                              QMap<int, QtOrganizer::QOrganizerManager::Error> *errorMap,
 
56
                                              QtOrganizer::QOrganizerManager::Error *error);
 
57
 
 
58
    QList<QtOrganizer::QOrganizerItem> items(const QtOrganizer::QOrganizerItemFilter &filter,
 
59
                                              const QDateTime &startDateTime,
 
60
                                              const QDateTime &endDateTime,
 
61
                                              int maxCount,
 
62
                                              const QList<QtOrganizer::QOrganizerItemSortOrder> &sortOrders,
 
63
                                              const QtOrganizer::QOrganizerItemFetchHint &fetchHint,
 
64
                                              QtOrganizer::QOrganizerManager::Error *error);
 
65
 
 
66
 
 
67
    QList<QtOrganizer::QOrganizerItemId> itemIds(const QtOrganizer::QOrganizerItemFilter &filter,
 
68
                                                  const QDateTime &startDateTime,
 
69
                                                  const QDateTime &endDateTime,
 
70
                                                  const QList<QtOrganizer::QOrganizerItemSortOrder> &sortOrders,
 
71
                                                  QtOrganizer::QOrganizerManager::Error *error);
 
72
 
 
73
    QList<QtOrganizer::QOrganizerItem> itemOccurrences(const QtOrganizer::QOrganizerItem &parentItem,
 
74
                                                        const QDateTime &startDateTime,
 
75
                                                        const QDateTime &endDateTime,
 
76
                                                        int maxCount,
 
77
                                                        const QtOrganizer::QOrganizerItemFetchHint &fetchHint,
 
78
                                                        QtOrganizer::QOrganizerManager::Error *error);
 
79
 
 
80
    QList<QtOrganizer::QOrganizerItem> itemsForExport(const QDateTime &startDateTime,
 
81
                                                       const QDateTime &endDateTime,
 
82
                                                       const QtOrganizer::QOrganizerItemFilter &filter,
 
83
                                                       const QList<QtOrganizer::QOrganizerItemSortOrder> &sortOrders,
 
84
                                                       const QtOrganizer::QOrganizerItemFetchHint &fetchHint,
 
85
                                                       QtOrganizer::QOrganizerManager::Error *error);
 
86
 
 
87
    bool saveItems(QList<QtOrganizer::QOrganizerItem> *items,
 
88
                   const QList<QtOrganizer::QOrganizerItemDetail::DetailType> &detailMask,
 
89
                   QMap<int, QtOrganizer::QOrganizerManager::Error> *errorMap,
 
90
                   QtOrganizer::QOrganizerManager::Error *error);
 
91
 
 
92
    bool removeItems(const QList<QtOrganizer::QOrganizerItemId> &itemIds,
 
93
                     QMap<int, QtOrganizer::QOrganizerManager::Error> *errorMap,
 
94
                     QtOrganizer::QOrganizerManager::Error *error);
 
95
 
 
96
    // collections
 
97
    QtOrganizer::QOrganizerCollection defaultCollection(QtOrganizer::QOrganizerManager::Error* error);
 
98
    QtOrganizer::QOrganizerCollection collection(const QtOrganizer::QOrganizerCollectionId &collectionId,
 
99
                                                  QtOrganizer::QOrganizerManager::Error *error);
 
100
    QList<QtOrganizer::QOrganizerCollection> collections(QtOrganizer::QOrganizerManager::Error* error);
 
101
    bool saveCollection(QtOrganizer::QOrganizerCollection* collection, QtOrganizer::QOrganizerManager::Error* error);
 
102
    bool removeCollection(const QtOrganizer::QOrganizerCollectionId& collectionId, QtOrganizer::QOrganizerManager::Error* error);
 
103
 
 
104
    // Asynchronous Request Support
 
105
    virtual void requestDestroyed(QtOrganizer::QOrganizerAbstractRequest* req);
 
106
    virtual bool startRequest(QtOrganizer::QOrganizerAbstractRequest* req);
 
107
    virtual bool cancelRequest(QtOrganizer::QOrganizerAbstractRequest* req);
 
108
    virtual bool waitForRequestFinished(QtOrganizer::QOrganizerAbstractRequest* req, int msecs);
 
109
 
 
110
    // Capabilities reporting
 
111
    virtual QList<QtOrganizer::QOrganizerItemFilter::FilterType> supportedFilters() const;
 
112
    virtual QList<QtOrganizer::QOrganizerItemDetail::DetailType> supportedItemDetails(QtOrganizer::QOrganizerItemType::ItemType itemType) const;
 
113
    virtual QList<QtOrganizer::QOrganizerItemType::ItemType> supportedItemTypes() const;
 
114
 
 
115
protected:
 
116
    QOrganizerEDSEngine();
 
117
/*
 
118
    // Implement "signal coalescing" for batch functions via change set
 
119
    virtual bool saveItem(QtOrganizer::QOrganizerItem* theOrganizerItem,
 
120
                          QtOrganizer::QOrganizerItemChangeSet& changeSet,
 
121
                          QtOrganizer::QOrganizerManager::Error* error);
 
122
    virtual bool removeItem(const QtOrganizer::QOrganizerItemId& organizeritemId,
 
123
                            QtOrganizer::QOrganizerItemChangeSet& changeSet,
 
124
                            QtOrganizer::QOrganizerManager::Error* error);
 
125
    virtual bool removeOccurrence(const QtOrganizer::QOrganizerItem& organizeritem,
 
126
                                  QtOrganizer::QOrganizerItemChangeSet& changeSet,
 
127
                                  QtOrganizer::QOrganizerManager::Error* error);
 
128
*/
 
129
 
 
130
private:
 
131
    QList<QtOrganizer::QOrganizerCollection> m_collections;
 
132
    QMap<QString, QOrganizerEDSCollectionEngineId*> m_collectionsMap;
 
133
 
 
134
    QtOrganizer::QOrganizerCollection m_defaultCollection;
 
135
    QList<FetchRequestData*> m_pendingFetchRequest;
 
136
 
 
137
    void loadCollections();
 
138
    static QList<QtOrganizer::QOrganizerItem> parseEvents(QOrganizerEDSCollectionEngineId *collection, GSList *events);
 
139
    static GSList *parseItems(QList<QtOrganizer::QOrganizerItem> items);
 
140
 
 
141
    // glib callback
 
142
    void itemsAsync(QtOrganizer::QOrganizerItemFetchRequest *req);
 
143
    static void itemsAsyncStart(FetchRequestData *data);
 
144
    static void itemsAsyncConnected(GObject *source_object, GAsyncResult *res, FetchRequestData *data);
 
145
    static void itemsAsyncListed(GObject *source_object, GAsyncResult *res, FetchRequestData *data);
 
146
 
 
147
    void saveItemsAsync(QtOrganizer::QOrganizerItemSaveRequest *req);
 
148
    static void saveItemsAsyncConnected(GObject *source_object, GAsyncResult *res, SaveRequestData *data);
 
149
    static void saveItemsAsyncCreated(GObject *source_object, GAsyncResult *res, SaveRequestData *data);
 
150
    static void saveItemsAsyncModified(GObject *source_object, GAsyncResult *res, SaveRequestData *data);
 
151
 
 
152
    void removeItemsAsync(QtOrganizer::QOrganizerItemRemoveRequest *req);
 
153
    static void removeItemsAsyncStart(RemoveRequestData *data);
 
154
    static void removeItemsAsyncConnected(GObject *source_object, GAsyncResult *res, RemoveRequestData *data);
 
155
    static void removeItemsAsyncRemoved(GObject *source_object, GAsyncResult *res, RemoveRequestData *data);
 
156
/*
 
157
    QList<QtOrganizer::QOrganizerItem> internalItemOccurrences(const QtOrganizer::QOrganizerItem& parentItem,
 
158
                                                               const QDateTime& periodStart,
 
159
                                                               const QDateTime& periodEnd,
 
160
                                                               int maxCount,
 
161
                                                               bool includeExceptions,
 
162
                                                               bool sortItems,
 
163
                                                               QList<QDate> *exceptionDates,
 
164
                                                               QtOrganizer::QOrganizerManager::Error* error) const;
 
165
 
 
166
    QList<QtOrganizer::QOrganizerItem> internalItems(const QDateTime& startDate,
 
167
                                                     const QDateTime& endDate,
 
168
                                                     const QtOrganizer::QOrganizerItemFilter& filter,
 
169
                                                     const QList<QtOrganizer::QOrganizerItemSortOrder>& sortOrders,
 
170
                                                     const QtOrganizer::QOrganizerItemFetchHint& fetchHint,
 
171
                                                     QtOrganizer::QOrganizerManager::Error* error,
 
172
                                                     bool forExport) const;
 
173
    QtOrganizer::QOrganizerItem item(const QtOrganizer::QOrganizerItemId& organizeritemId) const;
 
174
    */
 
175
        friend class FetchRequestData;
 
176
};
 
177
 
 
178
#endif