FCL/sf/app/commonemail: comparison emailuis/nmailuiengine/src/nmuiengine.cpp

equal deleted inserted replaced

-:00c7ae862740
+:d845db10c0d4
 const QString syncIndicatorName = "com.nokia.nmail.indicatorplugin.sync/1.0";
 /*!
 Constructor
 */
 NmUiEngine::NmUiEngine()
 : mMailboxListModel(NULL),
 mInboxListModel(NULL),
 mMessageListModel(NULL),
 mMessageSearchListModel(NULL),
 mSendOperation(NULL),
 mRemoveDraftOperation(NULL),
 mSaveDraftOperation(NULL),
 mDraftMessage(NULL)
 {
 NM_FUNCTION;
 mPluginFactory = NmDataPluginFactory::instance();
 mDataManager = new NmDataManager();
 // Connect to the plugins to receive change notifications
 QList<QObject*> *dataPlugins = mPluginFactory->pluginInstances();
 for (int i(0); i < dataPlugins->count(); i++) {
 // connet mailbox events
 QObject::connect(plugin, SIGNAL(mailboxEvent(NmMailboxEvent, const QList<NmId> &)),
 this, SLOT(handleMailboxEvent(NmMailboxEvent, const QList<NmId> &)),
 Qt::UniqueConnection);
 // connect message events
 QObject::connect(plugin,
 SIGNAL(messageEvent(NmMessageEvent, const NmId &, const QList<NmId> &, const NmId&)),
 this, SLOT(handleMessageEvent(NmMessageEvent, const NmId &, const QList<NmId> &, const NmId &)),
 Qt::UniqueConnection);
 // connect connection events
 QObject::connect(plugin,
 SIGNAL(connectionEvent(NmConnectState, const NmId &, const int)),
 this,
 SLOT(handleConnectEvent(NmConnectState, const NmId &, const int)),
 Qt::UniqueConnection);
 // do the subscriptions also
 NmDataPluginInterface *pluginInterface = mPluginFactory->interfaceInstance(plugin);
 if (pluginInterface) {
 QList<NmId> mailboxIdList;
 pluginInterface->listMailboxIds(mailboxIdList);
 Class destructor.
 */
 NmUiEngine::~NmUiEngine()
 {
 NM_FUNCTION;
-HbIndicator indicator;
+enableSyncIndicator(false);
-indicator.deactivate(syncIndicatorName, QVariant());
 if (mMessageSearchListModel) {
 delete mMessageSearchListModel;
 mMessageSearchListModel = NULL;
 }
 if (mSendOperation && mSendOperation->isRunning()) {
 mSendOperation->cancelOperation();
 }
 if (mRemoveDraftOperation && mRemoveDraftOperation->isRunning()) {
 mRemoveDraftOperation->cancelOperation();
 }
 if (mSaveDraftOperation && mSaveDraftOperation->isRunning()) {
 mSaveDraftOperation->cancelOperation();
 }
 */
 NmUiEngine *NmUiEngine::instance()
 {
 NM_FUNCTION;
 if (!mInstance) {
 	mInstance = new NmUiEngine();
 }
 mReferenceCount++;
 return mInstance;
 */
 void NmUiEngine::releaseInstance(NmUiEngine *&instance)
 {
 NM_FUNCTION;
 //can't have passed out instances if we don't have any
 if (mInstance) {
 if(instance == mInstance) {
 instance = NULL;
 mReferenceCount--;
 updated dynamically. The ownership of the model object is not moved to the caller.
 */
 NmMailboxListModel &NmUiEngine::mailboxListModel()
 {
 NM_FUNCTION;
 if (!mMailboxListModel) {
 refreshMailboxListModel(); // creates the model too
 }
 return *mMailboxListModel;
 }
 /*!
 Populate the list model with the mailbox and top level folder objects. The model is
 updated dynamically. Creates the model if needed.
 */
 void NmUiEngine::refreshMailboxListModel()
 {
 NM_FUNCTION;
 if (!mMailboxListModel) {
 mMailboxListModel = new NmMailboxListModel(*mDataManager);
 // Connect the model to the plugins to receive change notifications
 QList<QObject*> *dataPlugins = mPluginFactory->pluginInstances();
 for (int i = 0; i < dataPlugins->count(); i++) {
 QObject *plugin = (*dataPlugins)[i];
 if (plugin) {
 }
 }
 } else {
 mMailboxListModel->clear();
 }
 QList<NmMailbox*> mailboxList;
 mDataManager->listMailboxes(mailboxList);
 mMailboxListModel->refresh(mailboxList);
 while (!mailboxList.isEmpty()) {
 delete mailboxList.takeFirst();
 }
 }
 /*!
 Returns a message list model for a folder identified by \a mailboxId and
 \a folderId. The model is updated dynamically. The ownership of the model
 object is not moved to the caller.
 */
 NmMessageListModel &NmUiEngine::messageListModel(const NmId &mailboxId,
 const NmId &folderId)
 QObject *plugin = mPluginFactory->pluginInstance(mailboxId);
 bool isInbox(false);
 if (standardFolderId(mailboxId,NmFolderInbox)==folderId){
 isInbox=true;
 }
 if (plugin) {
 // Connect plugin message events to handler slot messageEventForListModel
 QObject::connect(plugin, SIGNAL(messageEvent(NmMessageEvent, const NmId &,
 const QList<NmId> &, const NmId&)),
 this, SLOT(messageEventForListModel(NmMessageEvent,
 const NmId &, const QList<NmId> &, const NmId&)), Qt::UniqueConnection );
 // Create inbox list model only once when entering to inbox for the first time
 // or re-create inbox list model when mailbox has changed
 if ((!mInboxListModel&&isInbox)||
 (mInboxListModel&&isInbox&&mailboxId!=mInboxListModel->currentMailboxId())){
 // Delete previous model and set to NULL. Deleting model will also
 // delete all items in model.
 if (mInboxListModel){
 delete mInboxListModel;
 mInboxListModel=NULL;
 }
 // Create new inbox model
 mInboxListModel = new NmMessageListModel(*mDataManager);
 // Initial fill up of inbox list model, otherwise updated in the background
 QList<NmMessageEnvelope*> messageEnvelopeList;
 mDataManager->listMessages(mailboxId, folderId, messageEnvelopeList);
 mInboxListModel->refresh(mailboxId, folderId, messageEnvelopeList);
 if (mMessageListModel){
 delete mMessageListModel;
 mMessageListModel=NULL;
 }
 mMessageListModel = new NmMessageListModel(*mDataManager);
 // Fill up other model
 QList<NmMessageEnvelope*> messageEnvelopeList;
 mDataManager->listMessages(mailboxId, folderId, messageEnvelopeList);
 mMessageListModel->refresh(mailboxId, folderId, messageEnvelopeList);
 while (!messageEnvelopeList.isEmpty()) {
 delete messageEnvelopeList.takeFirst();
 }
 }
 }
 // Connect sync state changed
 if (plugin){
 QObject::connect(
 plugin, SIGNAL(syncStateEvent(NmSyncState, const NmOperationCompletionEvent &)),
 this, SLOT(handleSyncStateEvent(NmSyncState, const NmOperationCompletionEvent &)),
 Qt::UniqueConnection);
 }
 NmMessageListModel* ret(NULL);
 if (isInbox){
 ret = mInboxListModel;
 // Inbox list model is queried, other model is not
 // needed anymore and memory should be freeded
 if (mMessageListModel){
 delete mMessageListModel;
 mMessageListModel=NULL;
 }
 }
 else {
 ret = mMessageListModel;
 }
 return *ret;
 }
 \return A message list model.
 */
 NmMessageListModel &NmUiEngine::messageListModelForSearch(const NmId &mailboxId)
 {
 NM_FUNCTION;
 Q_UNUSED(mailboxId);
 if (!mMessageSearchListModel) {
 mMessageSearchListModel = new NmMessageListModel(*mDataManager);
 mMessageSearchListModel->setIgnoreFolderIds(true);
 return *mMessageSearchListModel;
 }
 /*!
 Get the identifier of the standard folder of a type \a folderType
 from the mailbox \a mailboxId.
 */
 NmId NmUiEngine::standardFolderId(
 const NmId &mailboxId,
 NmFolderType folderType)
 {
 NM_FUNCTION;
 NmId value;
 if (folderType != NmFolderOther) {
 NmDataPluginInterface *plugin =
 mPluginFactory->interfaceInstance(mailboxId);
 if(plugin) {
 NmMessage *NmUiEngine::message(const NmId &mailboxId,
 const NmId &folderId,
 const NmId &messageId)
 {
 NM_FUNCTION;
 NmMessage *message = mDataManager->message(mailboxId, folderId, messageId);
 return message;
 }
 /*!
 QPointer<NmOperation> NmUiEngine::fetchMessage( const NmId &mailboxId,
 const NmId &folderId,
 const NmId &messageId )
 {
 NM_FUNCTION;
 QPointer<NmOperation> value(NULL);
 NmDataPluginInterface *plugin =
 mPluginFactory->interfaceInstance(mailboxId);
 if (plugin) {
 value = plugin->fetchMessage(mailboxId, folderId, messageId);
 const NmId &folderId,
 const NmId &messageId,
 const NmId &messagePartId)
 {
 NM_FUNCTION;
 QPointer<NmOperation> value(NULL);
 NmDataPluginInterface *plugin =
 mPluginFactory->interfaceInstance(mailboxId);
 if (plugin) {
 value = plugin->fetchMessagePart(mailboxId, folderId, messageId, messagePartId);
 const NmId &folderId,
 const NmId &messageId,
 const QList<NmId> &messagePartIds)
 {
 NM_FUNCTION;
 QPointer<NmOperation> value(NULL);
 NmDataPluginInterface *plugin =
 mPluginFactory->interfaceInstance(mailboxId);
 if (plugin) {
 value = plugin->fetchMessageParts(mailboxId, folderId, messageId, messagePartIds);
 const NmId &folderId,
 const NmId &messageId,
 const NmId &messagePartId)
 {
 NM_FUNCTION;
 NmDataPluginInterface *plugin =
 mPluginFactory->interfaceInstance(mailboxId);
 if (plugin) {
 return plugin->messagePartFile(mailboxId, folderId, messageId, messagePartId);
 }
 const NmId &folderId,
 const NmId &messageId,
 NmMessagePart &messagePart)
 {
 NM_FUNCTION;
 return mDataManager->contentToMessagePart(mailboxId, folderId, messageId, messagePart);
 }
 /*!
 int NmUiEngine::deleteMessages(const NmId &mailboxId,
 const NmId &folderId,
 const QList<NmId> &messageIdList)
 {
 NM_FUNCTION;
 int result(NmNotFoundError);
 bool isInbox(false);
 if (standardFolderId(mailboxId,NmFolderInbox)==folderId){
 isInbox=true;
 }
 if (isInbox&&mInboxListModel){
 mInboxListModel->handleMessageEvent(NmMessageDeleted, folderId,
 messageIdList, mailboxId);
 }
 else if (mMessageListModel) {
 	    mMessageListModel->handleMessageEvent(NmMessageDeleted, folderId,
 messageIdList, mailboxId);
 	}
 const NmId &folderId,
 NmEnvelopeProperties property,
 const QList<const NmMessageEnvelope*> &envelopeList)
 {
 NM_FUNCTION;
 QPointer<NmStoreEnvelopesOperation> operation(NULL);
 NmMessageListModel *theMessageListModel = mMessageListModel;
 if (!theMessageListModel) {
 theMessageListModel = &messageListModel(mailboxId, folderId);
 }
 if (theMessageListModel && envelopeList.count()) {
 QList<NmId> messageIdList;
 for (int i(0); i < envelopeList.count(); i++){
 messageIdList.append(envelopeList[i]->messageId());
 }
 theMessageListModel->setEnvelopeProperties(property, messageIdList);
 Operation is automatically deleted after completion or cancelling.
 */
 QPointer<NmMessageCreationOperation> NmUiEngine::createNewMessage(const NmId &mailboxId)
 {
 NM_FUNCTION;
 QPointer<NmMessageCreationOperation> value(NULL);
 NmDataPluginInterface *plugin =
 mPluginFactory->interfaceInstance(mailboxId);
 if (plugin) {
 value = plugin->createNewMessage(mailboxId);
 QPointer<NmMessageCreationOperation> NmUiEngine::createForwardMessage(
 const NmId &mailboxId,
 const NmId &originalMessageId)
 {
 NM_FUNCTION;
 QPointer<NmMessageCreationOperation> value(NULL);
 NmDataPluginInterface *plugin =
 mPluginFactory->interfaceInstance(mailboxId);
 if (plugin) {
 value = plugin->createForwardMessage(mailboxId, originalMessageId);
 const NmId &mailboxId,
 const NmId &originalMessageId,
 bool replyAll)
 {
 NM_FUNCTION;
 QPointer<NmMessageCreationOperation> value(NULL);
 NmDataPluginInterface *plugin =
 mPluginFactory->interfaceInstance(mailboxId);
 if (plugin) {
 value = plugin->createReplyMessage(mailboxId, originalMessageId, replyAll);
 Saves a message (into message store).
 */
 int NmUiEngine::saveMessage(const NmMessage &message)
 {
 NM_FUNCTION;
 const NmId &mailboxId = message.envelope().mailboxId();
 int ret(NmNotFoundError);
 NmDataPluginInterface *plugin =
 mPluginFactory->interfaceInstance(mailboxId);
 if (plugin) {
 Refreshes mailbox.
 */
 int NmUiEngine::refreshMailbox(const NmId &mailboxId )
 {
 NM_FUNCTION;
 int ret(NmNotFoundError);
 NmDataPluginInterface *plugin =
 mPluginFactory->interfaceInstance(mailboxId);
 if (plugin) {
 ret = plugin->refreshMailbox(mailboxId);
 if (NmNoError == ret) {
-HbIndicator indicator;
+enableSyncIndicator(true);
-indicator.activate(syncIndicatorName, QVariant());
 }
 }
 return ret;
 }
 Online mailbox.
 */
 int NmUiEngine::goOnline(const NmId &mailboxId )
 {
 NM_FUNCTION;
 int ret(NmNotFoundError);
 NmDataPluginInterface *plugin =
 mPluginFactory->interfaceInstance(mailboxId);
 if (plugin) {
 ret = plugin->goOnline(mailboxId);
 Offline mailbox.
 */
 int NmUiEngine::goOffline(const NmId &mailboxId )
 {
 NM_FUNCTION;
 int ret(NmNotFoundError);
 NmDataPluginInterface *plugin =
 mPluginFactory->interfaceInstance(mailboxId);
 if (plugin) {
 ret = plugin->goOffline(mailboxId);
 const NmId &mailboxId,
 const NmId &folderId,
 const NmId &messageId)
 {
 NM_FUNCTION;
 int result(NmNotFoundError);
 NmDataPluginInterface *plugin =
 mPluginFactory->interfaceInstance(mailboxId);
 if (plugin) {
 result = plugin->removeMessage(mailboxId, folderId, messageId);
 return result;
 }
 /*!
 Handles draft message deletion after editor has closed, takes ownership of message.
 */
 void NmUiEngine::removeDraftMessage(NmMessage *message)
 {
 NM_FUNCTION;
 if (message) {
 NmDataPluginInterface *plugin =
 mPluginFactory->interfaceInstance(message->envelope().mailboxId());
 if (plugin) {
 // to be on the safer side:
 // we shouldn't even be here if mRemoveDraftOperation != NULL
 if (mRemoveDraftOperation && mRemoveDraftOperation->isRunning()) {
 mRemoveDraftOperation->cancelOperation();
 }
 // ownership of message changes
 mRemoveDraftOperation = plugin->removeDraftMessage(message);
 if (mRemoveDraftOperation) {
 connect(mRemoveDraftOperation,
 SIGNAL(operationCompleted(int)),
 this,
 SLOT(handleCompletedRemoveDraftOperation()));
 }
 }
 }
 }
 /*!
 Handles draft message saving after editor has closed, takes ownership of message.
 */
 void NmUiEngine::saveDraftMessage(NmMessage *message,
 const QList<NmOperation*> &preliminaryOperations)
 {
 NM_FUNCTION;
 if (message) {
 NmDataPluginInterface *plugin =
 mPluginFactory->interfaceInstance(message->envelope().mailboxId());
 if (plugin) {
 // to be on the safer side:
 // we shouldn't even be here if mSaveDraftOperation != NULL
 if (mSaveDraftOperation && mSaveDraftOperation->isRunning()) {
 mSaveDraftOperation->cancelOperation();
 }
 mSaveDraftOperation = plugin->saveMessageWithSubparts(*message);
 if (mSaveDraftOperation) {
 // Ownership of message changes but saveMessageWithSubparts operation only makes a
 // copy so we handle the msg object deletion in engine. mDraftMessage is deleted
 // in handleCompletedSaveDraftOperation once operation finishes.
 if(mDraftMessage) {
 delete mDraftMessage;
 mDraftMessage = NULL;
 }
 mDraftMessage = message;
 message = NULL;
 for (int i(0); i < preliminaryOperations.count(); i++ ) {
 QPointer<NmOperation> op = preliminaryOperations[i];
 mSaveDraftOperation->addPreliminaryOperation(op);
 }
 connect(mSaveDraftOperation,
 SIGNAL(operationCompleted(int)),
 this,
 SLOT(handleCompletedSaveDraftOperation()));
 }
 }
 }
 }
 Sends the given message.
 */
 void NmUiEngine::sendMessage(NmMessage *message, const QList<NmOperation *> &preliminaryOperations)
 {
 NM_FUNCTION;
 //First trigger message storing
 if (message) {
 NmDataPluginInterface *plugin =
 mPluginFactory->interfaceInstance(message->envelope().mailboxId());
 if (plugin) {
 // to be on the safer side:
 // we shouldn't even be here if mSendOperation != NULL
 if (mSendOperation && mSendOperation->isRunning()) {
 mSendOperation->cancelOperation();
 if (mSendOperation) {
 for (int i(0); i < preliminaryOperations.count(); i++ ) {
 QPointer<NmOperation> op = preliminaryOperations[i];
 mSendOperation->addPreliminaryOperation(op);
 }
 connect(mSendOperation,
 SIGNAL(operationCompleted(int)),
 this,
 SLOT(handleCompletedSendOperation()));
 }
 }
 }
 }
 Is sending operation in progress.
 */
 bool NmUiEngine::isSendingMessage() const
 {
 NM_FUNCTION;
 int ret(false);
 if (mSendOperation && mSendOperation->isRunning()) {
 ret = true;
 }
 return ret;
 Returns a pointer to the message that is being sent. Returns NULL if not sending.
 */
 const NmMessage *NmUiEngine::messageBeingSent() const
 {
 NM_FUNCTION;
 const NmMessage *message = NULL;
 if (mSendOperation != NULL) {
 message = mSendOperation->getMessage();
 }
 return message;
 }
 /*!
 Add file attachment into given message. Return the operation object for
 QPointer<NmAddAttachmentsOperation> NmUiEngine::addAttachments(
 const NmMessage &message,
 const QList<QString> &fileList)
 {
 NM_FUNCTION;
 NmDataPluginInterface *plugin =
 mPluginFactory->interfaceInstance(message.envelope().mailboxId());
 QPointer<NmAddAttachmentsOperation> ret(NULL);
 if (plugin) {
 ret = plugin->addAttachments(message, fileList);
 }
 return ret;
 }
 QPointer<NmOperation> NmUiEngine::removeAttachment(
 const NmMessage &message,
 const NmId &attachmentPartId)
 {
 NM_FUNCTION;
 NmDataPluginInterface *plugin =
 mPluginFactory->interfaceInstance(message.envelope().mailboxId());
 QPointer<NmOperation> ret(NULL);
 if (plugin) {
 ret = plugin->removeAttachment(message, attachmentPartId);
 }
 return ret;
 }
 Returns the current sync state of the mailbox
 */
 NmSyncState NmUiEngine::syncState(const NmId& mailboxId)
 {
 NM_FUNCTION;
 NmDataPluginInterface *plugin =
 mPluginFactory->interfaceInstance(mailboxId);
 if (plugin) {
 return plugin->syncState(mailboxId);
 }
 Returns the current connection state of the mailbox
 */
 NmConnectState NmUiEngine::connectionState(const NmId& mailboxId)
 {
 NM_FUNCTION;
 NmDataPluginInterface *plugin =
 mPluginFactory->interfaceInstance(mailboxId);
 if (plugin) {
 return plugin->connectionState(mailboxId);
 }
 */
 int NmUiEngine::search(const NmId &mailboxId,
 const QStringList &searchStrings)
 {
 NM_FUNCTION;
 // Get the plugin instance.
 QObject *pluginInstance = mPluginFactory->pluginInstance(mailboxId);
 if (pluginInstance) {
 // Make sure the required signals are connected.
 this, SIGNAL(matchFound(const NmId &, const NmId &)),
 Qt::UniqueConnection);
 connect(pluginInstance, SIGNAL(matchFound(const NmId &, const NmId &)),
 this, SLOT(handleMatchFound(const NmId &, const NmId &)),
 Qt::UniqueConnection);
 connect(pluginInstance, SIGNAL(searchComplete()),
 this, SIGNAL(searchComplete()),
 Qt::UniqueConnection);
 }
 int retVal(NmNoError);
 // Get the plugin interface.
 if (pluginInterface) {
 // Start the search.
 retVal = pluginInterface->search(mailboxId, searchStrings);
 }
 return retVal;
 }
 /*!
 \return A possible error code.
 */
 int NmUiEngine::cancelSearch(const NmId &mailboxId)
 {
 NM_FUNCTION;
 int retVal(NmNoError);
 // Get the plugin interface.
 NmDataPluginInterface *pluginInterface =
 mPluginFactory->interfaceInstance(mailboxId);
 if (pluginInterface) {
 // Cancel the search.
 retVal = pluginInterface->cancelSearch(mailboxId);
 }
 return retVal;
 }
 /*!
+Get mailbox folder type by folder id
+\param mailboxId id of the mailbox
+\param folderId id of the folder
 \return Folder type
 */
 NmFolderType NmUiEngine::folderTypeById(NmId mailboxId, NmId folderId)
 {
 NM_FUNCTION;
 NmFolderType ret(NmFolderInbox);
 if (mDataManager){
 ret = mDataManager->folderTypeById(mailboxId,folderId);
 }
 return ret;
 }
 /*!
 \param folderId Id of active folder, 0 if application is closed.
 */
 void NmUiEngine::updateActiveFolder(const NmId &mailboxId, const NmId &folderId)
 {
 NM_FUNCTION;
 NmApplicationStateInterface *interface =
 mPluginFactory->applicationStateInterfaceInstance(mailboxId);
 if (interface) {
 interface->updateActiveFolder(mailboxId, folderId);
 }
 }
 Handle completed send operation.
 */
 void NmUiEngine::handleCompletedSendOperation()
 {
 NM_FUNCTION;
 emit sendOperationCompleted();
 }
 /*!
 Handle completed remove draft operation.
 */
 void NmUiEngine::handleCompletedRemoveDraftOperation()
 {
 NM_FUNCTION;
 // draft message deletion observing not yet implemented...
 }
 /*!
 Handle completed save draft operation.
 */
 void NmUiEngine::handleCompletedSaveDraftOperation()
 {
 NM_FUNCTION;
 // delete message object since it's not needed anymore
 if(mDraftMessage) {
 delete mDraftMessage;
 mDraftMessage = NULL;
 }
 Handles synch operation related events
 */
 void NmUiEngine::handleSyncStateEvent(NmSyncState syncState, const NmOperationCompletionEvent &event)
 {
 NM_FUNCTION;
 if ( syncState == SyncComplete ) {
 // signal for reporting about (sync) operation completion status
 emit operationCompleted(event);
-HbIndicator indicator;
-indicator.deactivate(syncIndicatorName, QVariant());
+enableSyncIndicator(false);
 }
 // signal for handling sync state icons
 emit syncStateEvent(syncState, event.mMailboxId);
 }
 /*!
-Emits signals based on message events coming from plugins.
+Enable or disable sync indicator
+\param enabled true if indicator is enabled, false if disabled
+*/
+void NmUiEngine::enableSyncIndicator(bool enabled)
+{
+	NM_FUNCTION;
+HbIndicator indicator;
+if (enabled) {
+indicator.activate(syncIndicatorName, QVariant());
+	}
+else {
+indicator.deactivate(syncIndicatorName, QVariant());
+	}
+}
+/*!
+Emits signals based on message events coming from plugins.
 Currently only NmMessageDeleted is handled.
 */
 void NmUiEngine::handleMessageEvent(NmMessageEvent event,
 const NmId &folderId,
 const QList<NmId> &messageIds,
 const NmId& mailboxId)
 {
 NM_FUNCTION;
 switch (event) {
 case NmMessageDeleted:
 {
 for (int i(0); i < messageIds.count(); i++) {
 emit messageDeleted(mailboxId, folderId, messageIds[i]);
 }
 break;
 }
 default:
 break;
 }
 }
 /*!
 Emits signals based on mailbox events coming from plugins.
 Currently only NmMailboxDeleted is handled.
 */
 void NmUiEngine::handleMailboxEvent(NmMailboxEvent event,
 const QList<NmId> &mailboxIds)
 {
 NM_FUNCTION;
 switch (event) {
 case NmMailboxDeleted:
 {
 for (int i(0); i < mailboxIds.count(); i++) {
 emit mailboxDeleted(mailboxIds[i]);
 }
 break;
 }
 default:
 break;
 }
 }
 \param folderId The ID of the folder where the message is located.
 */
 void NmUiEngine::handleMatchFound(const NmId &messageId, const NmId &folderId)
 {
 NM_FUNCTION;
 if (!mMessageSearchListModel) {
 // No search list model!
 return;
 }
 active mailbox is always alove whereas mMessageListModel can represent
 other folder in the device (sent, outbox, drafts, etc.)
 */
 void NmUiEngine::messageEventForListModel(NmMessageEvent event,
 const NmId &folderId,
 const QList<NmId> &messageIds,
 const NmId& mailboxId)
 {
 NM_FUNCTION;
 // Forward event to both list models. Models will take care of checking
 // whether event really belongs to current mailbox & folder
 if (mInboxListModel){
 mInboxListModel->handleMessageEvent(event, folderId,
 messageIds, mailboxId);
 }
 if (mMessageListModel){
 mMessageListModel->handleMessageEvent(event, folderId,
 messageIds, mailboxId);
 }
 }
 /*!
 receives events when going online, and offline.
 */
 void NmUiEngine::handleConnectEvent(NmConnectState connectState, const NmId &mailboxId, const int errorCode)
 {
 NM_FUNCTION;
 // signal for connection state icon handling
 emit connectionEvent(connectState, mailboxId);
 // in case going offline w/ error, emit signal to UI
 if ( connectState == Disconnected && errorCode!= NmNoError ) {
 NmOperationCompletionEvent event={NoOp, errorCode, mailboxId, 0, 0};
 emit operationCompleted(event);
 }
 }
 /*!
 returns full mailbox id from plain account id
 */
 NmId NmUiEngine::getPluginIdByMailboxId(quint32 accountId)
 {
 NM_FUNCTION;
 NmId fullId = NULL;
 fullId.setId32(accountId);
 QList<NmId> mailboxList;
 if(mDataManager){
 mDataManager->listMailboxIds(mailboxList);

changeset 51	d845db10c0d4
parent 47	f83bd4ae1fe3
child 62	a8c646b56683