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

equal deleted inserted replaced

-:139d4b7b2938
+:99bcbff212ad
 */
 NmUiEngine *NmUiEngine::mInstance;
 int NmUiEngine::mReferenceCount;
+const QString syncIndicatorName = "com.nokia.hb.nmsyncindicator/1.0";
 /*!
 Constructor
 */
 NmUiEngine::NmUiEngine()
 : mMailboxListModel(NULL),
+mInboxListModel(NULL),
 mMessageListModel(NULL),
 mMessageSearchListModel(NULL),
-mSendOperation(NULL)
+mSendOperation(NULL),
-{
+mRemoveDraftOperation(NULL),
+mSaveDraftOperation(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++) {
 /*!
 Destructor
 */
 NmUiEngine::~NmUiEngine()
 {
+NM_FUNCTION;
 if (mMessageSearchListModel) {
 delete mMessageSearchListModel;
 mMessageSearchListModel = NULL;
 }
+if (mInboxListModel) {
+delete mInboxListModel;
+mInboxListModel = NULL;
+}
 if (mMessageListModel) {
 delete mMessageListModel;
 mMessageListModel = NULL;
 }
 if (mMailboxListModel) {
 NmDataPluginFactory::releaseInstance(mPluginFactory);
 delete mDataManager;
 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--;
 Returns a list model populated with the mailbox and top level folder objects. The model is
 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();
 object is not moved to the caller.
 */
 NmMessageListModel &NmUiEngine::messageListModel(const NmId &mailboxId,
 const NmId &folderId)
 {
-if (!mMessageListModel) {
+NM_FUNCTION;
-mMessageListModel = new NmMessageListModel(*mDataManager);
-}
-else {
-mMessageListModel->clear();
-}
 QObject *plugin = mPluginFactory->pluginInstance(mailboxId);
+bool isInbox(false);
-if (plugin) {
+if (standardFolderId(mailboxId,NmFolderInbox)==folderId){
-QObject::connect(plugin,
+isInbox=true;
-SIGNAL(messageEvent(NmMessageEvent, const NmId &, const QList<NmId> &, const NmId&)),
+}
-mMessageListModel,
+if (plugin) {
-SLOT(handleMessageEvent(NmMessageEvent, const NmId &, const QList<NmId> &)),
+// Connect plugin message events to handler slot messageEventForListModel
-Qt::UniqueConnection );
+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);
+while (!messageEnvelopeList.isEmpty()) {
+delete messageEnvelopeList.takeFirst();
+}
+}
+// Selected folder is not inbox folder for the mailbox
+else if (!isInbox){
+// Recreate model for other folders when needed, previous model
+// items are deleted from the memory with the old model
+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);
+}
-// No need for mailbox event subscription here, already done in
+NmMessageListModel* ret(NULL);
-// constructor.
+if (isInbox){
-}
+ret = mInboxListModel;
+// Inbox list model is queried, other model is not
-QList<NmMessageEnvelope*> messageEnvelopeList;
+// needed anymore and memory should be freeded
-mDataManager->listMessages(mailboxId, folderId, messageEnvelopeList);
+if (mMessageListModel){
-mMessageListModel->refresh(mailboxId, folderId, messageEnvelopeList);
+delete mMessageListModel;
+mMessageListModel=NULL;
-while (!messageEnvelopeList.isEmpty()) {
+}
-delete messageEnvelopeList.takeFirst();
+}
-}
+else {
+ret = mMessageListModel;
-return *mMessageListModel;
+}
+return *ret;
 }
 /*!
 Returns a message list model used in the search view.
 \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);
 QObject *plugin = mPluginFactory->pluginInstance(mailboxId);
 if (plugin) {
 QObject::connect(plugin,
-SIGNAL(messageEvent(NmMessageEvent, const NmId &, const QList<NmId> &, const NmId&)),
+SIGNAL(messageEvent(NmMessageEvent, const NmId &, const QList<NmId> &, const NmId &)),
 mMessageSearchListModel,
-SLOT(handleMessageEvent(NmMessageEvent, const NmId &, const QList<NmId> &)),
+SLOT(handleMessageEvent(NmMessageEvent, const NmId &, const QList<NmId> &, const NmId &)),
 Qt::UniqueConnection);
 }
 // Refresh to set the mailbox ID.
 QList<NmMessageEnvelope*> messageEnvelopeList;
 */
 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 )
 {
-NMLOG("NmUiEngine::fetchMessage() <---");
+NM_FUNCTION;
 QPointer<NmOperation> value(NULL);
 NmDataPluginInterface *plugin =
 mPluginFactory->interfaceInstance(mailboxId);
 if (plugin) {
 value = plugin->fetchMessage(mailboxId, folderId, messageId);
 const NmId &mailboxId,
 const NmId &folderId,
 const NmId &messageId,
 const NmId &messagePartId)
 {
-NMLOG("NmUiEngine::fetchMessagePart() <---");
+NM_FUNCTION;
 QPointer<NmOperation> value(NULL);
 NmDataPluginInterface *plugin =
 mPluginFactory->interfaceInstance(mailboxId);
 if (plugin) {
 value = plugin->fetchMessagePart(mailboxId, folderId, messageId, messagePartId);
 const NmId &mailboxId,
 const NmId &folderId,
 const NmId &messageId,
 const QList<NmId> &messagePartIds)
 {
-NMLOG("NmUiEngine::fetchMessageParts() <---");
+NM_FUNCTION;
 QPointer<NmOperation> value(NULL);
 NmDataPluginInterface *plugin =
 mPluginFactory->interfaceInstance(mailboxId);
 if (plugin) {
 value = plugin->fetchMessageParts(mailboxId, folderId, messageId, messagePartIds);
 const NmId &mailboxId,
 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 &mailboxId,
 const NmId &folderId,
 const NmId &messageId,
 NmMessagePart &messagePart)
 {
+NM_FUNCTION;
 return mDataManager->contentToMessagePart(mailboxId, folderId, messageId, messagePart);
 }
-/*!
-Deletes messages from model and routes call to plugin
+/*!
-*/
+Deletes messages from the model and forwards the call to plugin.
-int NmUiEngine::deleteMessages(
-	const NmId &mailboxId,
+\param mailboxId The ID of the mailbox which contains the deleted message(s).
-	const NmId &folderId,
+\param folderId The ID of the folder which contains the deleted message(s).
-	const QList<NmId> &messageIdList)
+\param messageIdList A list containing the IDs of the message to be deleted.
-{
+\return A possible error code (returned by the plugin).
+*/
+int NmUiEngine::deleteMessages(const NmId &mailboxId,
+const NmId &folderId,
+const QList<NmId> &messageIdList)
+{
+NM_FUNCTION;
 int result(NmNotFoundError);
-	if (mMessageListModel) {
-	    mMessageListModel->handleMessageEvent(NmMessageDeleted, folderId, messageIdList);
+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);
 	}
-NmDataPluginInterface *plugin =
-mPluginFactory->interfaceInstance(mailboxId);
+	// If the search list model exists and contains message, remove the
-if (plugin) {
+	// message from it too.
-result = plugin->deleteMessages(
+	if (mMessageSearchListModel && mMessageSearchListModel->rowCount()) {
-	            mailboxId, folderId, messageIdList);
+mMessageSearchListModel->handleMessageEvent(NmMessageDeleted, folderId,
-}
+messageIdList, mailboxId);
+	}
+NmDataPluginInterface *plugin =
+mPluginFactory->interfaceInstance(mailboxId);
+if (plugin) {
+result = plugin->deleteMessages(mailboxId, folderId, messageIdList);
+}
 	return result;
 }
-/*!
-Sets envelope property given in argument.
+/*!
-Operation is automatically deleted after completion or cancelling.
+Sets the envelope property for the given envelopes.
+The operation is automatically deleted after the completion or cancelling.
+\param mailboxId The ID of the mailbox containing the envelope(s).
+\param folderId The ID of the folder containing the envelope(s).
+\param property The property to set.
+\param envelopeList The list containing the envelopes.
+\return The constructed operation.
 */
 QPointer<NmStoreEnvelopesOperation> NmUiEngine::setEnvelopes(
 const NmId &mailboxId,
 const NmId &folderId,
 NmEnvelopeProperties property,
 const QList<const NmMessageEnvelope*> &envelopeList)
 {
-NMLOG("NmUiEngine::setEnvelopes() <---");
+NM_FUNCTION;
 QPointer<NmStoreEnvelopesOperation> operation(NULL);
-if (mMessageListModel && envelopeList.count()) {
+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());
 }
-mMessageListModel->setEnvelopeProperties(
-property, messageIdList);
+theMessageListModel->setEnvelopeProperties(property, messageIdList);
-// Store new envelopes to plugin
+if (mMessageSearchListModel && mMessageSearchListModel->rowCount()) {
+// Update the envelopes in the search list model as well.
+mMessageSearchListModel->setEnvelopeProperties(property,
+messageIdList);
+}
+// Store the new envelopes to plugin.
 NmDataPluginInterface *plugin =
 mPluginFactory->interfaceInstance(mailboxId);
 if (plugin) {
-operation = plugin->storeEnvelopes(
+operation =
-mailboxId, folderId, envelopeList);
+plugin->storeEnvelopes(mailboxId, folderId, envelopeList);
 }
 messageIdList.clear();
 }
-NMLOG("NmUiEngine::setEnvelopes() --->");
 return operation;
 }
 /*!
 Creates a new message (into Drafts-folder).
 Operation is automatically deleted after completion or cancelling.
 */
 QPointer<NmMessageCreationOperation> NmUiEngine::createNewMessage(const NmId &mailboxId)
 {
-NMLOG("NmUiEngine::createNewMessage() <---");
+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)
 {
-NMLOG("NmUiEngine::createForwardMessage() <---");
+NM_FUNCTION;
 QPointer<NmMessageCreationOperation> value(NULL);
 NmDataPluginInterface *plugin =
 mPluginFactory->interfaceInstance(mailboxId);
 if (plugin) {
 value = plugin->createForwardMessage(mailboxId, originalMessageId);
 QPointer<NmMessageCreationOperation> NmUiEngine::createReplyMessage(
 const NmId &mailboxId,
 const NmId &originalMessageId,
 bool replyAll)
 {
-NMLOG("NmUiEngine::createReplyMessage() <---");
+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;
+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);
 int NmUiEngine::removeMessage(
 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();
+}
+// ownership of message changes
+mSaveDraftOperation = plugin->saveMessageWithSubparts(*message);
+// don't put this to mOperations as we need to handle this
+// operation separately
+if (mSaveDraftOperation) {
+for (int i(0); i < preliminaryOperations.count(); i++ ) {
+QPointer<NmOperation> op = preliminaryOperations[i];
+mSaveDraftOperation->addPreliminaryOperation(op);
+}
+connect(mSaveDraftOperation,
+SIGNAL(operationCompleted(int)),
+this,
+SLOT(handleCompletedSaveDraftOperation()));
+// message object is not needed any more, so delete it
+delete message;
+message = NULL;
+}
+}
+}
+}
 /*!
 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());
 /*!
 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();
 }
 */
 QPointer<NmAddAttachmentsOperation> NmUiEngine::addAttachments(
 const NmMessage &message,
 const QList<QString> &fileList)
 {
-NMLOG("NmUiEngine::addAttachments() <---");
+NM_FUNCTION;
 NmDataPluginInterface *plugin =
 mPluginFactory->interfaceInstance(message.envelope().mailboxId());
 QPointer<NmAddAttachmentsOperation> ret(NULL);
 if (plugin) {
 */
 QPointer<NmOperation> NmUiEngine::removeAttachment(
 const NmMessage &message,
 const NmId &attachmentPartId)
 {
-NMLOG("NmUiEngine::removeAttachments() <---");
+NM_FUNCTION;
 NmDataPluginInterface *plugin =
 mPluginFactory->interfaceInstance(message.envelope().mailboxId());
 QPointer<NmOperation> ret(NULL);
 if (plugin) {
 ret = plugin->removeAttachment(message, attachmentPartId);
 }
-return ret;
-}
-/*!
-Operation is automatically deleted after completion or cancelling.
-*/
-QPointer<NmCheckOutboxOperation> NmUiEngine::checkOutbox(const NmId &mailboxId)
-{
-NMLOG("NmUiEngine::checkOutbox() <---");
-NmDataPluginInterface *plugin =
-mPluginFactory->interfaceInstance(mailboxId);
-QPointer<NmCheckOutboxOperation> ret(NULL);
-if (plugin) {
-ret = plugin->checkOutbox(mailboxId);
-}
 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);
 }
 \return A possible error code.
 */
 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.
 \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);
 /*!
 \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 mailboxId Id of active mailbox, 0 if application is closed.
 \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()
 {
-NMLOG("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;
+// draft message saving observing not yet implemented...
 }
 /*!
 Handles synch operation related events
 */
 void NmUiEngine::handleSyncStateEvent(NmSyncState syncState, const NmOperationCompletionEvent &event)
 {
-NMLOG("NmUiEngine::handleSyncStateEvent()");
+NM_FUNCTION;
 if ( syncState == SyncComplete ) {
 // signal for reporting about (sync) operation completion status
 emit operationCompleted(event);
+HbIndicator indicator;
+indicator.deactivate(syncIndicatorName, QVariant());
 }
 // signal for handling sync state icons
 emit syncStateEvent(syncState, event.mMailboxId);
 }
 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]);
 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]);
 \param messageId The ID of the found message.
 \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;
 }
-// Add the found message into the search model.
+// Resolve the folder type.
-QList<NmId> messageIdList;
+NmId mailboxId = mMessageSearchListModel->currentMailboxId();
-messageIdList.append(messageId);
+NmFolderType folderType = folderTypeById(mailboxId, folderId);
-mMessageSearchListModel->handleMessageEvent(NmMessageFound,
+// Do not display matches from outbox or draft folders.
-folderId,
+if (folderType != NmFolderOutbox && folderType != NmFolderDrafts) {
-messageIdList);
+// Add the found message into the search model.
-}
+QList<NmId> messageIdList;
+messageIdList.append(messageId);
+mMessageSearchListModel->handleMessageEvent(NmMessageFound, folderId,
+messageIdList, mailboxId);
+}
+}
+/*!
+Function sens events from plugin to both models. Inbox model for
+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 ) {

changeset 43	99bcbff212ad
parent 40	2c62ef3caffd
child 44	c2d07d913565