--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/emailuis/nmailuiengine/src/nmmessagelistmodel.cpp Tue Aug 31 15:04:17 2010 +0300
@@ -0,0 +1,679 @@
+/*
+* Copyright (c) 2009 - 2010 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description:
+*
+*/
+
+#include "nmuiengineheaders.h"
+
+static const int NmFolderTypeRole = Qt::UserRole+1;
+
+/*!
+ \class NmMessageListModel
+ \brief The NmMessageListModel class represents data model for mailbox list.
+ @alpha
+
+ The NmMessageListModel class uses NmMessageEnvelope class to represent data returned in its'
+ data method to get all information needed for one list row for a widget by calling the method
+ once.
+*/
+
+/*!
+ Class constructor.
+*/
+NmMessageListModel::NmMessageListModel(NmDataManager &dataManager,
+ QObject *parent /* = 0 */)
+: QStandardItemModel(parent),
+ mDataManager(dataManager),
+ mDividersActive(false),
+ mParentPtr(NULL),
+ mCurrentFolderType(NmFolderInbox),
+ mIgnoreFolderIds(false)
+{
+ NM_FUNCTION;
+
+ // Check for setting whether dividers are active
+ // mDividersActive = ...
+ // update also the test cases
+}
+
+
+/*!
+ Class destructor.
+*/
+NmMessageListModel::~NmMessageListModel()
+{
+ NM_FUNCTION;
+
+ clear();
+}
+
+
+/*!
+ Returns data specified by \a index. Only Qt::DisplayRole is supported in \a role.
+ The refresh method must have been called before this method can return any real data.
+*/
+QVariant NmMessageListModel::data(const QModelIndex &index, int role) const
+{
+ NM_FUNCTION;
+
+ QVariant qVariant;
+
+ if (index.isValid()){
+ if (role == Qt::DisplayRole) {
+ NmMessageListModelItem *item =
+ static_cast<NmMessageListModelItem*>(itemFromIndex(index));
+ qVariant = QVariant::fromValue(item);
+ }
+ else if (role == NmFolderTypeRole) {
+ qVariant = QVariant(mCurrentFolderType);
+ }
+ }
+
+ return qVariant;
+}
+
+
+/*!
+ This refreshes the data of the model.
+
+ \param mailboxId The ID of the mailbox.
+ \param folderId The ID of the folder.
+ \param messageEnvelopeList A list containing the message meta data.
+*/
+void NmMessageListModel::refresh(
+ const NmId mailboxId,
+ const NmId folderId,
+ const QList<NmMessageEnvelope*> &messageEnvelopeList)
+{
+ NM_FUNCTION;
+
+ // Store the current mailbox and folder IDs.
+ mCurrentMailboxId = mailboxId;
+ mCurrentFolderId = folderId;
+
+ // Store the type of the currently displayed folder.
+ mCurrentFolderType = mDataManager.folderTypeById(mailboxId, folderId);
+
+ // Clear the model.
+ clear();
+
+ // Add the items from the given list.
+ NmMessageEnvelope* insertedMessage(NULL);
+ int parentCount(0);
+ int childCount(0);
+
+ for (int i(0); i < messageEnvelopeList.count(); i++) {
+ NmMessageEnvelope *nextMessage = messageEnvelopeList[i];
+ // imap and pop is using common sent, outbox or draft folder
+ // for all mailboxes, here we want to filter out messages that
+ // are not under this mailbox
+ bool insert(true);
+ if (nextMessage
+ && (NmFolderSent == mCurrentFolderType
+ || NmFolderOutbox == mCurrentFolderType
+ || NmFolderDrafts == mCurrentFolderType)) {
+ insert = (mCurrentMailboxId == nextMessage->mailboxId());
+ }
+ if (insert) {
+ if (mDividersActive &&
+ !messagesBelongUnderSameDivider(insertedMessage, nextMessage)) {
+ insertDividerIntoModel(nextMessage, parentCount);
+ parentCount++;
+ childCount = 0;
+ }
+
+ insertMessageIntoModel(nextMessage, childCount, false);
+ insertedMessage = nextMessage;
+ childCount++;
+ }
+ }
+}
+
+
+/*!
+ insertDividerIntoModel. Function inserts divider into model.
+*/
+void NmMessageListModel::insertDividerIntoModel(
+ NmMessageEnvelope *messageForDivider,
+ int parentRow)
+{
+ NM_FUNCTION;
+
+ mParentPtr = createTitleDividerItem(messageForDivider);
+ insertRow(parentRow,mParentPtr);
+ mParentPtr->callEmitDataChanged();
+}
+
+/*!
+ Function inserts message into model. Message can be inserted
+ either to root or to parent. If parent is zero, item is added into root.
+*/
+void NmMessageListModel::insertMessageIntoModel(
+ NmMessageEnvelope *messageEnvelope, int childRow, bool emitSignal)
+{
+ NM_FUNCTION;
+
+ NmMessageListModelItem *mailItem = createMessageItem(messageEnvelope);
+ if (mParentPtr) {
+ // Add under parent divider
+ mParentPtr->insertRow(childRow, mailItem);
+ }
+ else {
+ // No dividers, add under root item
+ insertRow(childRow,mailItem);
+ }
+ if (emitSignal) {
+ mailItem->callEmitDataChanged();
+ }
+}
+
+/*!
+ Function checks whether the messages can be drawn under same title divider
+ Check is done depending of the current sorting criteria
+*/
+bool NmMessageListModel::messagesBelongUnderSameDivider(
+ const NmMessageEnvelope *message1,
+ const NmMessageEnvelope *message2) const
+{
+ NM_FUNCTION;
+
+ bool retVal(false);
+ // First check pointer validity
+ if (message1 && message2) {
+ // Switch here for other sort modes
+ // Date based comparison
+ QDateTime sentTime1 = message1->sentTime().toLocalTime();
+ QDateTime sentTime2 = message2->sentTime().toLocalTime();
+ if ( sentTime1.date() == sentTime2.date()) {
+ retVal = true;
+ }
+ }
+ return retVal;
+}
+
+
+/*!
+ Handles the message events.
+
+ \param event The type of the message event.
+ \param folderId The folder containing the message.
+ \param messageIds A list of message IDs related to the event.
+*/
+void NmMessageListModel::handleMessageEvent(NmMessageEvent event,
+ const NmId &folderId,
+ const QList<NmId> &messageIds,
+ const NmId &mailboxId)
+{
+ NM_FUNCTION;
+ const int idCount = messageIds.count();
+
+ // Folder ID does not concern us if this model instance is used for e.g.
+ // searching messages.
+ if (!mIgnoreFolderIds) {
+ if (folderId == 0) {
+ // Const cast is used here because also the input parameter has to
+ // be changed.
+ const_cast<NmId&>(folderId) =
+ mDataManager.getStandardFolderId(mailboxId, NmFolderInbox);
+ NmUiStartParam *startParam =
+ new NmUiStartParam(NmUiViewMessageList, mailboxId, folderId);
+ emit setNewParam(startParam);
+ }
+
+ if (mCurrentFolderId == 0) {
+ // Folder ID was not known at time when the mailbox opened and we
+ // know that because of events the subscription is valid only for
+ // the current mailbox.
+ mCurrentFolderId = folderId;
+ }
+ // MailboxId checking here is done because we want to filter out messages
+ // that belongs to other mailboxes in case of imap/pop sent, outbox or draft folder
+ if (mCurrentFolderId != folderId || mCurrentMailboxId != mailboxId) {
+ // The event does not concern the folder currently being displayed.
+ // Thus, ignore it.
+ return;
+ }
+ }
+
+ // Go through the given message IDs and do the appropriate operations
+ // according to the type of the event.
+ for (int i(0); i < idCount; ++i) {
+ switch (event) {
+ case NmMessageChanged: {
+ updateMessageEnvelope(mailboxId, folderId, messageIds[i]);
+ break;
+ }
+ case NmMessageCreated: {
+ // mIgnoreFolderIds is true if (and only if) this model is used
+ // for mail search purposes and thus, we do not want the model
+ // to handle "message created" events. Issue to consider:
+ // renaming mIgonreFolderIds => mModelUsedForSearch or something
+ // similar.
+ if (!mIgnoreFolderIds && !itemFromModel(messageIds[i])) {
+ insertNewMessageIntoModel(mailboxId, folderId, messageIds[i]);
+ }
+
+ break;
+ }
+ case NmMessageFound: {
+ if (!itemFromModel(messageIds[i])) {
+ insertNewMessageIntoModel(mailboxId, folderId, messageIds[i]);
+ }
+
+ break;
+ }
+ case NmMessageDeleted: {
+ removeMessageFromModel(messageIds[i]);
+ break;
+ }
+ }
+ }
+}
+
+
+/*!
+ Function inserts new message into correct position to model.
+ A new title divider is created if it is needed.
+*/
+void NmMessageListModel::insertNewMessageIntoModel(
+ const NmId &mailboxId,
+ const NmId &folderId,
+ const NmId &msgId)
+{
+ NM_FUNCTION;
+
+ // envelope ownership is here
+ NmMessageEnvelope *newMsgEnve = mDataManager.envelopeById(mailboxId, folderId, msgId);
+ if (newMsgEnve) {
+ int rowIndex(getInsertionIndex(*newMsgEnve));
+ if (!mDividersActive) {
+ if (rowIndex > -1){
+ insertMessageIntoModel(newMsgEnve, rowIndex, true);
+ } else {
+ NmMessageListModelItem *mailItem = createMessageItem(newMsgEnve);
+ appendRow(mailItem);
+ mailItem->callEmitDataChanged();
+ }
+ } else {
+ // model contain items, message goes to the middle of the list
+ if (rowIndex > 0) {
+ int dividerIndex(0);
+ QList<QStandardItem*> items = findItems("*", Qt::MatchWildcard | Qt::MatchRecursive);
+ QModelIndex index = items[rowIndex]->index();
+ NmMessageListModelItem *item = static_cast<NmMessageListModelItem*>(itemFromIndex(index));
+ NmMessageEnvelope *replacedEnve = item->envelopePtr();
+ if (messagesBelongUnderSameDivider(newMsgEnve,replacedEnve)) {
+ // find the index of the divider and insert message as child object
+ // dividerIndex is not actually used here but function sets
+ // the correct parent pointer
+ dividerIndex = dividerInsertionIndex(rowIndex);
+ insertMessageIntoModel(newMsgEnve, 0, true);
+ } else {
+ // create new divider and find the correct index for it
+ dividerIndex = dividerInsertionIndex(rowIndex);
+ insertDividerIntoModel(newMsgEnve, dividerIndex);
+ // Insert message as a first child under new divider
+ insertMessageIntoModel(newMsgEnve, 0, true);
+ }
+ items.clear();
+ }
+ // first mail item in the model,
+ // insert new divider to index 0 and new message as a child.
+ else if (0 == rowIndex) {
+ insertDividerIntoModel(newMsgEnve, rowIndex);
+ insertMessageIntoModel(newMsgEnve, 0, true);
+ }
+ // this will go to the last item of the list and create new title divider
+ else {
+ mParentPtr = createTitleDividerItem(newMsgEnve);
+ appendRow(mParentPtr);
+ mParentPtr->callEmitDataChanged();
+ NmMessageListModelItem *mailItem = createMessageItem(newMsgEnve);
+ // Add under parent divider
+ mParentPtr->appendRow(mailItem);
+ mailItem->callEmitDataChanged();
+ }
+ }
+ }
+ delete newMsgEnve;
+}
+
+/*!
+ Function check model index in which the new message should be inserted
+ with the currently active sort mode.
+*/
+int NmMessageListModel::getInsertionIndex(
+ const NmMessageEnvelope &envelope) const
+{
+ NM_FUNCTION;
+
+ int ret(NmNotFoundError);
+
+ // Date+descending sort mode based comparison.
+ // Go through model and compare sent times with QDateTime >= comparison operation.
+ QList<QStandardItem*> items = findItems("*", Qt::MatchWildcard | Qt::MatchRecursive);
+ int count(items.count());
+ bool found(false);
+ int i(0);
+ while (i < count && !found) {
+ QModelIndex index = items[i]->index();
+ NmMessageListModelItem *item = static_cast<NmMessageListModelItem*>(itemFromIndex(index));
+ if (NmMessageListModelItem::NmMessageItemMessage == item->itemType()) {
+ found = envelope.sentTime() >= item->envelope().sentTime();
+ if (found) {
+ ret = i;
+ }
+ }
+ i++;
+ }
+ if (0 == count) {
+ ret = NmNoError;
+ }
+ items.clear();
+ return ret;
+}
+
+/*!
+ Function finds preceding title divider index and sets the
+ mParentPtr variable.
+*/
+int NmMessageListModel::dividerInsertionIndex(int messageIndex)
+{
+ NM_FUNCTION;
+
+ bool found(false);
+ int ret(NmNoError);
+ QModelIndex index;
+ QList<QStandardItem*> items = findItems("*", Qt::MatchWildcard | Qt::MatchRecursive);
+ for (int i = messageIndex-1; i >= 0 && !found; i--) {
+ index = items[i]->index();
+ NmMessageListModelItem *item = static_cast<NmMessageListModelItem*>(itemFromIndex(index));
+ if(item->itemType() == NmMessageListModelItem::NmMessageItemTitleDivider) {
+ found = true;
+ mParentPtr = static_cast<NmMessageListModelItem*>(itemFromIndex(index));
+ ret = index.row();
+ }
+ }
+ items.clear();
+ return ret;
+}
+
+/*!
+ Create title divider item
+*/
+NmMessageListModelItem *NmMessageListModel::createTitleDividerItem(
+ NmMessageEnvelope *messageForDivider)
+{
+ NM_FUNCTION;
+
+ NmMessageListModelItem *item = new NmMessageListModelItem();
+ item->setItemType(NmMessageListModelItem::NmMessageItemTitleDivider);
+
+ QDate sentLocalDate = messageForDivider->sentTime().toLocalTime().date();
+ QDate currentdate = QDate::currentDate();
+
+ if (sentLocalDate == currentdate) {
+ // NOTE: when dividers are taken in to use hbTrId macro should used here,
+ // to be clarified how to access ts-file (located under ui component)
+ item->setTitleDivider(tr("Today", "txt_nmailuiengine_divider_today"));
+ item->setText(tr("Today", "txt_nmailuiengine_divider_today"));
+ }
+ else {
+ QLocale locale;
+ QString divider = locale.toString(sentLocalDate, QLocale::LongFormat);
+ item->setTitleDivider(divider);
+ item->setText(divider);
+ }
+ item->setEnvelope(*messageForDivider);
+ item->setData(Hb::ParentItem, Hb::ItemTypeRole);
+ return item;
+}
+
+/*!
+ Create message item
+*/
+NmMessageListModelItem *NmMessageListModel::createMessageItem(
+ NmMessageEnvelope *envelope)
+{
+ NM_FUNCTION;
+
+ NmMessageListModelItem *mailItem = new NmMessageListModelItem();
+ mailItem->setEnvelope(*envelope);
+ mailItem->setItemType(NmMessageListModelItem::NmMessageItemMessage);
+ mailItem->setData(Hb::StandardItem, Hb::ItemTypeRole);
+ return mailItem;
+}
+
+/*!
+ Returns divider state
+*/
+bool NmMessageListModel::dividersActive()
+{
+ NM_FUNCTION;
+
+ return mDividersActive;
+}
+
+/*!
+ Set divider state
+*/
+void NmMessageListModel::setDividers(bool active)
+{
+ NM_FUNCTION;
+
+ mDividersActive = active;
+}
+
+/*!
+ Change item property if differs
+*/
+void NmMessageListModel::setEnvelopeProperties(
+ NmEnvelopeProperties property,
+ const QList<NmId> &messageIds)
+{
+ NM_FUNCTION;
+
+ for (int i(0); i < messageIds.count(); i++) {
+ updateEnvelope(property, messageIds[i]);
+ }
+}
+
+
+/*!
+ Returns the ID of the current mailbox.
+*/
+NmId NmMessageListModel::currentMailboxId()
+{
+ NM_FUNCTION;
+
+ return mCurrentMailboxId;
+}
+
+
+/*!
+ Sets whether the model should ignore the folder IDs or not. The folder IDs
+ should be ignored e.g. when the model is used for searching messages
+ (i.e. used by the search view).
+
+ \param ignore If true, will ignore the folder IDs.
+*/
+void NmMessageListModel::setIgnoreFolderIds(bool ignore)
+{
+ NM_FUNCTION;
+
+ mIgnoreFolderIds = ignore;
+}
+
+
+/*!
+ Remove message from model if message exists in model
+*/
+void NmMessageListModel::removeMessageFromModel(const NmId &msgId)
+{
+ NM_FUNCTION;
+
+ QList<QStandardItem*> items = findItems("*", Qt::MatchWildcard | Qt::MatchRecursive);
+ int count(items.count());
+ bool found(false);
+ int i(0);
+ while (!found && i < count) {
+ QModelIndex index = items[i]->index();
+ NmMessageListModelItem *item = static_cast<NmMessageListModelItem*>(itemFromIndex(index));
+ if (NmMessageListModelItem::NmMessageItemMessage == item->itemType()
+ && msgId == item->envelope().messageId()) {
+ found = true;
+ // dividers are not active, just remove message
+ if (!mDividersActive) {
+ removeItem(index.row(), *item);
+ } else {
+ // check the type from previous item
+ QModelIndex prevIndex = items[i-1]->index();
+ NmMessageListModelItem* previous = static_cast<NmMessageListModelItem*>(itemFromIndex(prevIndex));
+ if (NmMessageListModelItem::NmMessageItemTitleDivider == previous->itemType()) {
+ // previous item is title divider
+ if (i < (count-1)) {
+ // if this is not last item in the list, check next item
+ QModelIndex nextIndex = items[i+1]->index();
+ NmMessageListModelItem* next = static_cast<NmMessageListModelItem*>(itemFromIndex(nextIndex));
+ if (NmMessageListModelItem::NmMessageItemMessage == next->itemType()) {
+ // next item is message, divider should not be removed
+ removeItem(index.row(), *item);
+ } else {
+ // next item is another divider, remove also divider
+ removeItem(index.row(), *item);
+ removeItem(prevIndex.row(), *previous);
+ }
+ } else {
+ // this is the last message in list, remove also divider
+ removeItem(index.row(), *item);
+ removeItem(prevIndex.row(), *previous);
+ }
+ } else {
+ // previous item is message, title divider should not be deleted
+ removeItem(index.row(), *item);
+ }
+ }
+ }
+ i++;
+ }
+ items.clear();
+}
+
+/*!
+ Helper function to remove row
+*/
+void NmMessageListModel::removeItem(int row, NmMessageListModelItem &item)
+{
+ NM_FUNCTION;
+
+ QStandardItem *parent = item.parent();
+ removeRow(row, indexFromItem(parent));
+}
+
+/*!
+ Search item from model
+*/
+NmMessageListModelItem *NmMessageListModel::itemFromModel(const NmId &messageId)
+{
+ NM_FUNCTION;
+
+ QList<QStandardItem*> items = findItems("*", Qt::MatchWildcard | Qt::MatchRecursive);
+ int count(items.count());
+ bool found(false);
+ int i(0);
+ NmMessageListModelItem *ret(NULL);
+ while (i < count && !found) {
+ NmMessageListModelItem *item =
+ static_cast<NmMessageListModelItem*>(itemFromIndex(items[i]->index()));
+ if (NmMessageListModelItem::NmMessageItemMessage == item->itemType()
+ && messageId == item->envelope().messageId()) {
+ found = true;
+ ret = item;
+ }
+ i++;
+ }
+ return ret;
+}
+
+/*!
+ Helper function for envelope comparison
+*/
+bool NmMessageListModel::changed(const NmMessageEnvelope &first, const NmMessageEnvelope &second)
+{
+ NM_FUNCTION;
+
+ return first != second;
+}
+
+/*!
+ Updates envelope if something is changed
+*/
+void NmMessageListModel::updateMessageEnvelope(const NmId &mailboxId,
+ const NmId &folderId,
+ const NmId &msgId)
+{
+ NM_FUNCTION;
+
+ NmMessageListModelItem *item = itemFromModel(msgId);
+ // envelope ownership is here
+ NmMessageEnvelope *newEnvelope = mDataManager.envelopeById(mailboxId, folderId, msgId);
+ if (item && newEnvelope) {
+ if (changed(*item->envelopePtr(), *newEnvelope)) {
+ // function takes envelope ownership
+ item->setEnvelope(newEnvelope);
+ } else {
+ delete newEnvelope;
+ newEnvelope = NULL;
+ }
+ }
+}
+
+/*!
+ Update envelope property
+*/
+void NmMessageListModel::updateEnvelope(NmEnvelopeProperties property, const NmId &msgId)
+{
+ NM_FUNCTION;
+
+ NmMessageListModelItem *item = itemFromModel(msgId);
+ if (item) {
+ bool changed(false);
+ NmMessageEnvelope *envelope = item->envelopePtr();
+ switch (property)
+ {
+ case MarkAsRead:
+ {
+ if (!envelope->isRead()) {
+ envelope->setRead(true);
+ changed = true;
+ }
+ break;
+ }
+ case MarkAsUnread:
+ {
+ if (envelope->isRead()) {
+ envelope->setRead(false);
+ changed = true;
+ }
+ break;
+ }
+ default:
+ break;
+ }
+ if (changed) {
+ item->callEmitDataChanged();
+ }
+ }
+}