diff --git a/akonadi/kmime/CMakeLists.txt b/akonadi/kmime/CMakeLists.txt index db14a987e..fa9b634b8 100644 --- a/akonadi/kmime/CMakeLists.txt +++ b/akonadi/kmime/CMakeLists.txt @@ -1,42 +1,44 @@ include_directories( ${CMAKE_SOURCE_DIR}/ ${QT_QTDBUS_INCLUDE_DIR} ${Boost_INCLUDE_DIR} ) add_subdirectory( tests ) set( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DQT_NO_CAST_FROM_ASCII -DQT_NO_CAST_TO_ASCII ${KDE4_ENABLE_EXCEPTIONS}" ) ########### next target ############### set( kmimeakonadi_LIB_SRC + addressattribute.cpp localfolders.cpp localfoldersbuildjob.cpp messagemodel.cpp messageparts.cpp messagethreadingattribute.cpp messagethreaderproxymodel.cpp resourcesynchronizationjob.cpp # copied from playground/pim/akonaditest/resourcetester ) kde4_add_kcfg_files( kmimeakonadi_LIB_SRC localfolderssettings.kcfgc ) install( FILES localfolders.kcfg DESTINATION ${KCFG_INSTALL_DIR} ) kde4_add_library( akonadi-kmime SHARED ${kmimeakonadi_LIB_SRC} ) target_link_libraries( akonadi-kmime akonadi-kde kmime ${QT_QTGUI_LIBRARY} ${KDE4_KDECORE_LIBS} ${KDE4_KIO_LIBS} ) set_target_properties( akonadi-kmime PROPERTIES VERSION ${GENERIC_LIB_VERSION} SOVERSION ${GENERIC_LIB_SOVERSION} ) install(TARGETS akonadi-kmime EXPORT kdepimlibsLibraryTargets ${INSTALL_TARGETS_DEFAULT_ARGS}) ########### install files ############### install( FILES + addressattribute.h localfolders.h akonadi-kmime_export.h messagemodel.h messageparts.h messagethreadingattribute.h messagethreaderproxymodel.h DESTINATION ${INCLUDE_INSTALL_DIR}/akonadi/kmime COMPONENT Devel ) diff --git a/akonadi/kmime/addressattribute.cpp b/akonadi/kmime/addressattribute.cpp new file mode 100644 index 000000000..4ab5469c9 --- /dev/null +++ b/akonadi/kmime/addressattribute.cpp @@ -0,0 +1,142 @@ +/* + Copyright 2009 Constantin Berzan + + This library is free software; you can redistribute it and/or modify it + under the terms of the GNU Library General Public License as published by + the Free Software Foundation; either version 2 of the License, or (at your + option) any later version. + + This library is distributed in the hope that it will be useful, but WITHOUT + ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + FITNESS FOR A PARTICULAR PURPOSE. See the GNU Library General Public + License for more details. + + You should have received a copy of the GNU Library General Public License + along with this library; see the file COPYING.LIB. If not, write to the + Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA + 02110-1301, USA. +*/ + +#include "addressattribute.h" + +#include + +#include + +#include + +using namespace Akonadi; + +/** + @internal +*/ +class AddressAttribute::Private +{ + public: + QString mFrom; + QStringList mTo; + QStringList mCc; + QStringList mBcc; +}; + +AddressAttribute::AddressAttribute( const QString &from, const QStringList &to, + const QStringList &cc, const QStringList &bcc ) + : d( new Private ) +{ + d->mFrom = from; + d->mTo = to; + d->mCc = cc; + d->mBcc = bcc; +} + +AddressAttribute::~AddressAttribute() +{ + delete d; +} + +AddressAttribute* AddressAttribute::clone() const +{ + return new AddressAttribute( d->mFrom, d->mTo, d->mCc, d->mBcc ); +} + +QByteArray AddressAttribute::type() const +{ + static const QByteArray sType( "AddressAttribute" ); + return sType; +} + +QByteArray AddressAttribute::serialized() const +{ + QByteArray serializedData; + QDataStream serializer( &serializedData, QIODevice::WriteOnly ); + serializer.setVersion( QDataStream::Qt_4_5 ); + serializer << d->mFrom; + serializer << d->mTo; + serializer << d->mCc; + serializer << d->mBcc; + return serializedData; +} + +void AddressAttribute::deserialize( const QByteArray &data ) +{ + QDataStream deserializer( data ); + deserializer.setVersion( QDataStream::Qt_4_5 ); + deserializer >> d->mFrom; + deserializer >> d->mTo; + deserializer >> d->mCc; + deserializer >> d->mBcc; +} + +QString AddressAttribute::from() const +{ + return d->mFrom; +} + +void AddressAttribute::setFrom( const QString &from ) +{ + d->mFrom = from; +} + +QStringList AddressAttribute::to() const +{ + return d->mTo; +} + +void AddressAttribute::setTo( const QStringList &to ) +{ + d->mTo = to; +} + +QStringList AddressAttribute::cc() const +{ + return d->mCc; +} + +void AddressAttribute::setCc( const QStringList &cc ) +{ + d->mCc = cc; +} + +QStringList AddressAttribute::bcc() const +{ + return d->mBcc; +} + +void AddressAttribute::setBcc( const QStringList &bcc ) +{ + d->mBcc = bcc; +} + +// Register the attribute when the library is loaded. +namespace { + +bool dummy() +{ + using namespace Akonadi; + AttributeFactory::registerAttribute(); + return true; +} + +const bool registered = dummy(); + +} diff --git a/akonadi/kmime/addressattribute.h b/akonadi/kmime/addressattribute.h new file mode 100644 index 000000000..796fbb350 --- /dev/null +++ b/akonadi/kmime/addressattribute.h @@ -0,0 +1,112 @@ +/* + Copyright 2009 Constantin Berzan + + This library is free software; you can redistribute it and/or modify it + under the terms of the GNU Library General Public License as published by + the Free Software Foundation; either version 2 of the License, or (at your + option) any later version. + + This library is distributed in the hope that it will be useful, but WITHOUT + ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + FITNESS FOR A PARTICULAR PURPOSE. See the GNU Library General Public + License for more details. + + You should have received a copy of the GNU Library General Public License + along with this library; see the file COPYING.LIB. If not, write to the + Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA + 02110-1301, USA. +*/ + +#ifndef AKONADI_ADDRESSATTRIBUTE_H +#define AKONADI_ADDRESSATTRIBUTE_H + +#include "akonadi-kmime_export.h" + +#include +#include + +#include + +namespace MailTransport { + class Transport; +} + +namespace Akonadi { + +/** + Attribute storing the From, To, Cc, Bcc addresses of a message. + + @author Constantin Berzan + @since 4.4 +*/ +class AKONADI_KMIME_EXPORT AddressAttribute : public Akonadi::Attribute +{ + public: + /** + Creates a new AddressAttribute. + */ + explicit AddressAttribute( const QString &from = QString(), + const QStringList &to = QStringList(), + const QStringList &cc = QStringList(), + const QStringList &bcc = QStringList() ); + /** + Destroys the AddressAttribute. + */ + virtual ~AddressAttribute(); + + + /* reimpl */ + virtual AddressAttribute* clone() const; + virtual QByteArray type() const; + virtual QByteArray serialized() const; + virtual void deserialize( const QByteArray &data ); + + /** + Returns the address of the sender. + */ + QString from() const; + + /** + Sets the address of the sender. + */ + void setFrom( const QString &from ); + + /** + Returns the addresses of the "To:" receivers. + */ + QStringList to() const; + + /** + Sets the addresses of the "To:" receivers." + */ + void setTo( const QStringList &to ); + + /** + Returns the addresses of the "Cc:" receivers. + */ + QStringList cc() const; + + /** + Sets the addresses of the "Cc:" receivers." + */ + void setCc( const QStringList &cc ); + + /** + Returns the addresses of the "Bcc:" receivers. + */ + QStringList bcc() const; + + /** + Sets the addresses of the "Bcc:" receivers." + */ + void setBcc( const QStringList &bcc ); + + private: + class Private; + Private *const d; + +}; + +} // namespace Akonadi + +#endif // AKONADI_ADDRESSATTRIBUTE_H diff --git a/akonadi/kmime/localfoldersbuildjob_p.h b/akonadi/kmime/localfoldersbuildjob_p.h index 05fb9bc25..f58868808 100644 --- a/akonadi/kmime/localfoldersbuildjob_p.h +++ b/akonadi/kmime/localfoldersbuildjob_p.h @@ -1,83 +1,83 @@ /* Copyright (c) 2009 Constantin Berzan This library is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Library General Public License for more details. You should have received a copy of the GNU Library General Public License along with this library; see the file COPYING.LIB. If not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */ #ifndef AKONADI_LOCALFOLDERSBUILDJOB_P_H #define AKONADI_LOCALFOLDERSBUILDJOB_P_H #include #include namespace Akonadi { /** A job building and fetching the local folder structure for LocalFolders. Whether this job is allowed to create stuff or not is determined by whether the LocalFolders who created it is the main instance of LocalFolders or not. (This is done to avoid race conditions.) Logic if main instance: 1) if loading the resource from config fails, create the resource. 2) if after fetching, some collections need to be created / modified, do that. 3) if creating / modification succeeded -> success. else -> failure. Logic if not main instance: 1) if loading the resource from config fails -> failure. 2) if after fetching, some collections need to be created / modified -> failure. 2) if all collections were fetched ok -> success. @author Constantin Berzan @since 4.4 */ class LocalFoldersBuildJob : public TransactionSequence { Q_OBJECT public: /** @param canBuild Whether this job is allowed to build the folder structure (as opposed to only fetching it). */ - LocalFoldersBuildJob( bool canBuild, QObject *parent = 0 ); + explicit LocalFoldersBuildJob( bool canBuild, QObject *parent = 0 ); ~LocalFoldersBuildJob(); const Collection::List &defaultFolders() const; //const QSet &customFolders() const; protected: /* reimpl */ virtual void doStart(); private: class Private; friend class Private; Private *const d; Q_PRIVATE_SLOT( d, void resourceCreateResult( KJob* ) ) Q_PRIVATE_SLOT( d, void resourceSyncResult( KJob* ) ) Q_PRIVATE_SLOT( d, void collectionFetchResult( KJob* ) ) Q_PRIVATE_SLOT( d, void collectionCreateResult( KJob* ) ) Q_PRIVATE_SLOT( d, void collectionModifyResult( KJob* ) ) }; } // namespace Akonadi #endif // AKONADI_LOCALFOLDERSBUILDJOB_P_H diff --git a/akonadi/resourcebase.h b/akonadi/resourcebase.h index 1689a7da7..4388fe620 100644 --- a/akonadi/resourcebase.h +++ b/akonadi/resourcebase.h @@ -1,534 +1,533 @@ /* This file is part of akonadiresources. Copyright (c) 2006 Till Adam Copyright (c) 2007 Volker Krause This library is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Library General Public License for more details. You should have received a copy of the GNU Library General Public License along with this library; see the file COPYING.LIB. If not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */ #ifndef AKONADI_RESOURCEBASE_H #define AKONADI_RESOURCEBASE_H #include "akonadi_export.h" #include #include #include class KJob; class ResourceAdaptor; class TransportAdaptor; namespace Akonadi { class ResourceBasePrivate; /** * @short The base class for all Akonadi resources. * * This class should be used as a base class by all resource agents, * because it encapsulates large parts of the protocol between * resource agent, agent manager and the Akonadi storage. * * It provides many convenience methods to make implementing a * new Akonadi resource agent as simple as possible. * *

How to write a resource

* * The following provides an overview of what you need to do to implement * your own Akonadi resource. In the following, the term 'backend' refers * to the entity the resource connects with Akonadi, be it a single file * or a remote server. * * @todo Complete this (online/offline state management) * *
Basic %Resource Framework
* * The following is needed to create a new resource: * - A new class deriving from Akonadi::ResourceBase, implementing at least all * pure-virtual methods, see below for further details. * - call init() in your main() function. * - a .desktop file similar to the following example * \code * [Desktop Entry] * Encoding=UTF-8 * Name=My Akonadi Resource * Type=AkonadiResource * Exec=akonadi_my_resource * Icon=my-icon * * X-Akonadi-MimeTypes= * X-Akonadi-Capabilities=Resource * X-Akonadi-Identifier=akonadi_my_resource * \endcode * *
Handling PIM Items
* * To follow item changes in the backend, the following steps are necessary: * - Implement retrieveItems() to synchronize all items in the given * collection. If the backend supports incremental retrieval, * implementing support for that is recommended to improve performance. * - Convert the items provided by the backend to Akonadi items. * This typically happens either in retrieveItems() if you retrieved * the collection synchronously (not recommended for network backends) or * in the result slot of the asynchronous retrieval job. * Converting means to create Akonadi::Item objects for every retrieved * item. It's very important that every object has its remote identifier set. * - Call itemsRetrieved() or itemsRetrievedIncremental() respectively * with the item objects created above. The Akonadi storage will then be * updated automatically. Note that it is usually not necessary to manipulate * any item in the Akonadi storage manually. * * To fetch item data on demand, the method retrieveItem() needs to be * reimplemented. Fetch the requested data there and call itemRetrieved() * with the result item. * * To write local changes back to the backend, you need to re-implement * the following three methods: * - itemAdded() * - itemChanged() * - itemRemoved() * Note that these three functions don't get the full payload of the items by default, * you need to change the item fetch scope of the change recorder to fetch the full * payload. This can be expensive with big payloads, though.
* Once you have handled changes in these methods call changeCommitted(). * These methods are called whenever a local item related to this resource is * added, modified or deleted. They are only called if the resource is online, otherwise * all changes are recorded and replayed as soon the resource is online again. * *
Handling Collections
* * To follow collection changes in the backend, the following steps are necessary: * - Implement retrieveCollections() to retrieve collections from the backend. * If the backend supports incremental collections updates, implementing * support for that is recommended to improve performance. * - Convert the collections of the backend to Akonadi collections. * This typically happens either in retrieveCollections() if you retrieved * the collection synchronously (not recommended for network backends) or * in the result slot of the asynchronous retrieval job. * Converting means to create Akonadi::Collection objects for every retrieved * collection. It's very important that every object has its remote identifier * and its parent remote identifier set. * - Call collectionsRetrieved() or collectionsRetrievedIncremental() respectively * with the collection objects created above. The Akonadi storage will then be * updated automatically. Note that it is usually not necessary to manipulate * any collection in the Akonadi storage manually. * * * To write local collection changes back to the backend, you need to re-implement * the following three methods: * - collectionAdded() * - collectionChanged() * - collectionRemoved() * Once you have handled changes in these methods call changeCommitted(). * These methods are called whenever a local collection related to this resource is * added, modified or deleted. They are only called if the resource is online, otherwise * all changes are recorded and replayed as soon the resource is online again. * * @todo Convenience base class for collection-less resources */ // FIXME_API: API dox need to be updated for Observer approach (kevin) class AKONADI_EXPORT ResourceBase : public AgentBase { Q_OBJECT public: /** * @short Interface for resources supporting sending messages. * * A Transport object attached to a resource tells MailTransport that * the resource supports sending messages. The resource must also have * the "MailTransport" capability flag. * * To implement a transport-enabled resource, inherit from both * ResourceBase and ResourceBase::Transport, implement the virtual method * sendItem(), and call emitTransportResult() when finished sending. * * @todo add code example * - * TODO figure out what to do about data, from, to, cc, bcc from - * TransportManager::TransportJob. See comments in MT/AkonadiJob. + * @see TransportManager::AkonadiJob * * @author Constantin Berzan * @since 4.4 */ class AKONADI_EXPORT Transport { public: Transport(); virtual ~Transport(); virtual void sendItem( Akonadi::Item::Id message ) = 0; }; /** * Use this method in the main function of your resource * application to initialize your resource subclass. * This method also takes care of creating a KApplication * object and parsing command line arguments. * * @note In case the given class is also derived from AgentBase::Observer * it gets registered as its own observer (see AgentBase::Observer), e.g. * resourceInstance->registerObserver( resourceInstance ); * * @code * * class MyResource : public ResourceBase * { * ... * }; * * int main( int argc, char **argv ) * { * return ResourceBase::init( argc, argv ); * } * * @endcode */ template static int init( int argc, char **argv ) { const QString id = parseArguments( argc, argv ); KApplication app; T* r = new T( id ); // check if T also inherits AgentBase::Observer and // if it does, automatically register it on itself Observer *observer = dynamic_cast( r ); if ( observer != 0 ) r->registerObserver( observer ); // Check if T also inherits ResourceBase::Transport and // if it does, automatically register it on itself. Transport *transport = dynamic_cast( r ); if ( transport != 0 ) r->registerTransport( r ); return init( r ); } /** * Registers the given transport object for sending messages. */ void registerTransport( Transport *transport ); /** * This method is used to set the name of the resource. */ //FIXME_API: make sure location is renamed to this by resourcebase void setName( const QString &name ); /** * Returns the name of the resource. */ QString name() const; Q_SIGNALS: /** * This signal is emitted whenever the name of the resource has changed. * * @param name The new name of the resource. */ void nameChanged( const QString &name ); /** * Emitted when a full synchronization has been completed. */ void synchronized(); /** * Emitted when an item has been sent. * @param item The id of the item that was sent. * @param success The success of the sending operation. * @param message An optional textual explanation of the result. * @see Transport. * @since 4.4 */ void transportResult( qlonglong item, bool success, const QString &message ); protected Q_SLOTS: /** * Retrieve the collection tree from the remote server and supply it via * collectionsRetrieved() or collectionsRetrievedIncremental(). * @see collectionsRetrieved(), collectionsRetrievedIncremental() */ virtual void retrieveCollections() = 0; /** * Retrieve all (new/changed) items in collection @p collection. * It is recommended to use incremental retrieval if the backend supports that * and provide the result by calling itemsRetrievedIncremental(). * If incremental retrieval is not possible, provide the full listing by calling * itemsRetrieved( const Item::List& ). * In any case, ensure that all items have a correctly set remote identifier * to allow synchronizing with items already existing locally. * In case you don't want to use the built-in item syncing code, store the retrieved * items manually and call itemsRetrieved() once you are done. * @param collection The collection whose items to retrieve. * @see itemsRetrieved( const Item::List& ), itemsRetrievedIncremental(), itemsRetrieved(), currentCollection() */ virtual void retrieveItems( const Akonadi::Collection &collection ) = 0; /** * Retrieve a single item from the backend. The item to retrieve is provided as @p item. * Add the requested payload parts and call itemRetrieved() when done. * @param item The empty item whose payload should be retrieved. Use this object when delivering * the result instead of creating a new item to ensure conflict detection will work. * @param parts The item parts that should be retrieved. * @return false if there is an immediate error when retrieving the item. * @see itemRetrieved() */ virtual bool retrieveItem( const Akonadi::Item &item, const QSet &parts ) = 0; protected: /** * Creates a base resource. * * @param id The instance id of the resource. */ ResourceBase( const QString & id ); /** * Destroys the base resource. */ ~ResourceBase(); /** * Call this method from retrieveItem() once the result is available. * * @param item The retrieved item. */ void itemRetrieved( const Item &item ); /** * Resets the dirty flag of the given item and updates the remote id. * * Call whenever you have successfully written changes back to the server. * This implicitly calls changeProcessed(). * @param item The changed item. */ void changeCommitted( const Item &item ); /** * Call whenever you have successfully handled or ignored a collection * change notification. * * This will update the remote identifier of @p collection if necessary, * as well as any other collection attributes. * This implicitly calls changeProcessed(). * @param collection The collection which changes have been handled. */ void changeCommitted( const Collection &collection ); /** * Call this to supply the full folder tree retrieved from the remote server. * * @param collections A list of collections. * @see collectionsRetrievedIncremental() */ void collectionsRetrieved( const Collection::List &collections ); /** * Call this to supply incrementally retrieved collections from the remote server. * * @param changedCollections Collections that have been added or changed. * @param removedCollections Collections that have been deleted. * @see collectionsRetrieved() */ void collectionsRetrievedIncremental( const Collection::List &changedCollections, const Collection::List &removedCollections ); /** * Enable collection streaming, that is collections don't have to be delivered at once * as result of a retrieveCollections() call but can be delivered by multiple calls * to collectionsRetrieved() or collectionsRetrievedIncremental(). When all collections * have been retrieved, call collectionsRetrievalDone(). * @param enable @c true if collection streaming should be enabled, @c false by default */ void setCollectionStreamingEnabled( bool enable ); /** * Call this method to indicate you finished synchronizing the collection tree. * * This is not needed if you use the built in syncing without collection streaming * and call collectionsRetrieved() or collectionRetrievedIncremental() instead. * If collection streaming is enabled, call this method once all collections have been delivered * using collectionsRetrieved() or collectionsRetrievedIncremental(). */ void collectionsRetrievalDone(); /** * Call this method to supply the full collection listing from the remote server. * * If the remote server supports incremental listing, it's strongly * recommended to use itemsRetrievedIncremental() instead. * @param items A list of items. * @see itemsRetrievedIncremental(). */ void itemsRetrieved( const Item::List &items ); /** * Call this method when you want to use the itemsRetrieved() method * in streaming mode and indicate the amount of items that will arrive * that way. * @deprecated Use setItemStreamingEnabled( true ) + itemsRetrieved[Incremental]() * + itemsRetrieved() instead. */ void setTotalItems( int amount ); /** * Enable item streaming. * Item streaming is disabled by default. * @param enable @c true if items are delivered in chunks rather in one big block. */ void setItemStreamingEnabled( bool enable ); /** * Call this method to supply incrementally retrieved items from the remote server. * * @param changedItems Items changed in the backend. * @param removedItems Items removed from the backend. */ void itemsRetrievedIncremental( const Item::List &changedItems, const Item::List &removedItems ); /** * Call this method to indicate you finished synchronizing the current collection. * * This is not needed if you use the built in syncing without item streaming * and call itemsRetrieved() or itemsRetrievedIncremental() instead. * If item streaming is enabled, call this method once all items have been delivered * using itemsRetrieved() or itemsRetrievedIncremental(). * @see retrieveItems() */ void itemsRetrievalDone(); /** * Call this method to remove all items and collections of the resource from the * server cache. * * The method should be used whenever the configuration of the resource has changed * and therefor the cached items might not be valid any longer. * * @since 4.3 */ void clearCache(); /** * Returns the collection that is currently synchronized. */ Collection currentCollection() const; /** * Returns the item that is currently retrieved. */ Item currentItem() const; /** * This method is called whenever the resource should start synchronize all data. */ void synchronize(); /** * This method is called whenever the collection with the given @p id * shall be synchronized. */ void synchronizeCollection( qint64 id ); /** * Refetches the Collections. */ void synchronizeCollectionTree(); /** * Stops the execution of the current task and continues with the next one. */ void cancelTask(); /** * Stops the execution of the current task and continues with the next one. * Additionally an error message is emitted. */ void cancelTask( const QString &error ); /** * Stops the execution of the current task and continues with the next one. * The current task will be tried again later. * * @since 4.3 */ void deferTask(); /** * Inherited from AgentBase. */ void doSetOnline( bool online ); /** * Emits the transportResult() signal. * Call this if you resource inherits from ResourceBase::Transport. * @param item The id of the item that was sent. * @param success True if the sending operation succeeded. * @param message An optional textual explanation of the result. * @see Transport. * @since 4.4 */ void emitTransportResult( Akonadi::Item::Id &item, bool success, const QString &message = QString() ); private: static QString parseArguments( int, char** ); static int init( ResourceBase *r ); // dbus resource interface friend class ::ResourceAdaptor; friend class ::TransportAdaptor; // D-Bus calls: void send( Akonadi::Item::Id message ); bool requestItemDelivery( qint64 uid, const QString &remoteId, const QString &mimeType, const QStringList &parts ); private: Q_DECLARE_PRIVATE( ResourceBase ) Q_PRIVATE_SLOT( d_func(), void slotDeliveryDone( KJob* ) ) Q_PRIVATE_SLOT( d_func(), void slotCollectionSyncDone( KJob* ) ) Q_PRIVATE_SLOT( d_func(), void slotDeleteResourceCollection() ) Q_PRIVATE_SLOT( d_func(), void slotDeleteResourceCollectionDone( KJob* ) ) Q_PRIVATE_SLOT( d_func(), void slotCollectionDeletionDone( KJob* ) ) Q_PRIVATE_SLOT( d_func(), void slotLocalListDone( KJob* ) ) Q_PRIVATE_SLOT( d_func(), void slotSynchronizeCollection( const Akonadi::Collection& ) ) Q_PRIVATE_SLOT( d_func(), void slotCollectionListDone( KJob* ) ) Q_PRIVATE_SLOT( d_func(), void slotItemSyncDone( KJob* ) ) Q_PRIVATE_SLOT( d_func(), void slotPercent( KJob*, unsigned long ) ) }; } #ifndef AKONADI_RESOURCE_MAIN /** * Convenience Macro for the most common main() function for Akonadi resources. */ #define AKONADI_RESOURCE_MAIN( resourceClass ) \ int main( int argc, char **argv ) \ { \ return Akonadi::ResourceBase::init( argc, argv ); \ } #endif #endif