1 /*

     2  * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

     3  * All rights reserved.

     4  * This component and the accompanying materials are made available

     5  * under the terms of "Eclipse Public License v1.0"

     6  * which accompanies this distribution, and is available

     7  * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8  *

     9  * Initial Contributors:

    10  * Nokia Corporation - initial contribution.

    11  *

    12  * Contributors:

    13  *

    14  * Description:

    15  *

    16  */

    17 

    18 #include "msgconversationviewitem.h"

    19 

    20 // SYSTEM INCLUDES

    21 #include <QDateTime>

    22 #include "debugtraces.h"

    23 #include <QDir>

    24 #include <QChar>

    25 #include <QStringBuilder>

    26 #include <HbTextItem>

    27 #include <HbIconItem>

    28 #include <HbIconAnimationManager>

    29 #include <HbIconAnimator>

    30 #include <HbExtendedLocale>

    31 #include <ccsdefs.h>

    32 #include <HbInstance>

    33 

    34 // USER INCLUDES

    35 #include "msgconversationwidget.h"

    36 #include "msgviewdefines.h"

    37 #include "msgviewutils.h"

    38 #include "convergedmessage.h"

    39 #include "conversationsenginedefines.h"

    40 

    41 // LOCAL CONSTANTS

    42 static const char MSG_OUTBOX_ICON[]     = "qtg_small_outbox";

    43 static const char MSG_FAIL_ICON[]       = "qtg_small_fail";

    44 static const char ANIMATION_FILE[]      = ":/qtg_anim_loading.axml";

    45 static const char ANIMATION_ICON_NAME[] = "qtg_anim_loading";

    46 static const char VCARD_ICON[]          = "qtg_large_mycard";

    47 static const char IMAGE_ICON[]          = "qtg_small_image";

    48 static const char CORRUPTED_ICON[]      = "qtg_small_corrupted";

    49 static const char MSG_VIDEO_ICON[]      = "qtg_small_video";

    50 

    51 // @see hbi18ndef.h

    52 static const char DATE_FORMAT[] = r_qtn_date_short_with_zero;

    53 static const char TIME_FORMAT[] = r_qtn_time_usual_with_zero;

    54 

    55 // LOCALIZATION

    56 #define LOC_RINGING_TONE hbTrId("txt_messaging_dpopinfo_ringing_tone")

    57 #define LOC_BUSINESS_CARD hbTrId("txt_messaging_list_business_card")

    58 #define LOC_CALENDAR_EVENT hbTrId("txt_messaging_list_calendar_event")

    59 #define LOC_UNSUPPORTED_MSG_TYPE hbTrId("txt_messaging_list_listview_unsupported_message_type")

    60 #define LOC_RESEND_AT hbTrId("txt_messaging_list_resend_at_time")

    61 

    62 //---------------------------------------------------------------

    63 // MsgConversationViewItem::MsgConversationViewItem

    64 // Constructor

    65 //---------------------------------------------------------------

    66 MsgConversationViewItem::MsgConversationViewItem(QGraphicsItem* parent) :

    67     HbListViewItem(parent), mIncoming(false), mConversation(0),

    68             mIncomingMsgStateIconItem(0), mOutgoingMsgStateIconItem(0)

    69 {

    70 }

    71 

    72 //---------------------------------------------------------------

    73 // MsgConversationViewItem::MsgConversationViewItem

    74 // Destructor

    75 //---------------------------------------------------------------

    76 MsgConversationViewItem::~MsgConversationViewItem()

    77 {

    78 }

    79 

    80 //---------------------------------------------------------------

    81 // MsgConversationViewItem::createItem

    82 // Create a new decorator item.

    83 //---------------------------------------------------------------

    84 MsgConversationViewItem* MsgConversationViewItem::createItem()

    85 {

    86     MsgConversationViewItem *item = new MsgConversationViewItem(*this);

    87     item->init();

    88     return item;

    89 }

    90 

    91 //---------------------------------------------------------------

    92 // MsgConversationViewItem::updateChildItems

    93 //

    94 //---------------------------------------------------------------

    95 void MsgConversationViewItem::updateChildItems()

    96 {

    97     QModelIndex index = modelIndex();

    98 

    99 #ifdef _DEBUG_TRACES_

   100     qCritical() << "START MsgConversationViewItem::updateChildItems: "

   101             << index.data(ConvergedMsgId).toInt();

   102 #endif

   103 

   104     int messageType = index.data(MessageType).toInt();

   105     int messageSubType = index.data(MessageSubType).toInt();

   106 

   107     

   108     if (messageType == ConvergedMessage::Sms)

   109         {

   110         	updateSmsTypeItem(index);

   111         }

   112     else if (messageType == ConvergedMessage::Mms || messageType

   113             == ConvergedMessage::MmsNotification || messageType

   114             == ConvergedMessage::BT)

   115         {

   116         updateMmsTypeItem(index, messageType, messageSubType);

   117         }

   118     else if (messageType == ConvergedMessage::BioMsg)

   119         {

   120         if (messageSubType == ConvergedMessage::VCard || messageSubType

   121                 == ConvergedMessage::RingingTone)

   122             {

   123             updateMmsTypeItem(index, messageType, messageSubType);

   124             }

   125         else

   126             {

   127             updateSmsTypeItem(index, messageSubType);

   128             }

   129         }

   130 

   131 #ifdef _DEBUG_TRACES_

   132     qCritical() << "END MsgConversationViewItem::updateChildItems: "

   133             << index.data(ConvergedMsgId).toInt();

   134 #endif

   135 

   136     repolish();

   137     HbListViewItem::updateChildItems();

   138     }

   139 

   140 //---------------------------------------------------------------

   141 // MsgConversationViewItem::updateSmsTypeItem

   142 // @see header file

   143 //---------------------------------------------------------------

   144 void MsgConversationViewItem::updateSmsTypeItem(const QModelIndex& index,

   145     int messageSubType)

   146 {

   147 

   148     mIncoming = false;

   149     mConversation->resetProperties();

   150     

   151     int direction = index.data(Direction).toInt();

   152     

   153     if (direction == ConvergedMessage::Incoming)

   154         {

   155         setIncoming(true);

   156         mConversation->setIncoming(true);

   157 

   158         mIncomingMsgStateIconItem->setVisible(false);

   159     }

   160     else if (direction == ConvergedMessage::Outgoing)

   161         {

   162         setIncoming(false);

   163         mConversation->setIncoming(false);

   164 

   165         int sendingState = index.data(SendingState).toInt();

   166         mConversation->setSendingState(sendingState);

   167         setMessageStateIcon(sendingState);

   168         }

   169 

   170     bool unreadStatus = index.data(UnReadStatus).toBool();

   171     mConversation->setUnread(unreadStatus);

   172 

   173     mConversation->drawBubbleFrame();

   174     mConversation->drawNewItemFrame();

   175 

   176     QDateTime dateTime;

   177     dateTime.setTime_t(index.data(TimeStamp).toUInt());

   178     QString resendStateNote((index.data(SendingState).toInt()

   179                     == ConvergedMessage::Resend) ? LOC_RESEND_AT : "");

   180 

   181     HbExtendedLocale locale = HbExtendedLocale::system();

   182     QString date = locale.format(dateTime.date(), DATE_FORMAT);

   183     QString time = locale.format(dateTime.time(), TIME_FORMAT);

   184 

   185     if (dateTime.date() == QDateTime::currentDateTime().date()) {

   186         mConversation->setTimeStamp(resendStateNote % time);

   187     }

   188     else {

   189         mConversation->setTimeStamp(resendStateNote % date);

   190     }

   191 

   192     if (messageSubType == ConvergedMessage::VCal)

   193         {

   194          mConversation->setSubject(LOC_UNSUPPORTED_MSG_TYPE);

   195         }

   196     else

   197         {

   198         QString bodyText = index.data(BodyText).toString();

   199         bodyText.replace(QChar::ParagraphSeparator, QChar::LineSeparator);

   200         bodyText.replace('\r', QChar::LineSeparator);

   201         mConversation->setBodyText(bodyText);

   202         }

   203     

   204     //repolish

   205     mConversation->repolishWidget();

   206     }

   207 

   208 //---------------------------------------------------------------

   209 // MsgConversationViewItem::updateMmsTypeItem

   210 // @see header file

   211 //---------------------------------------------------------------

   212 void MsgConversationViewItem::updateMmsTypeItem(const QModelIndex& index,

   213         int messageType, int messageSubType)

   214     {

   215     // create widget

   216     if (!mConversation)

   217         {

   218         mConversation = new MsgConversationWidget(this);

   219         HbStyle::setItemName(mConversation, "msgconvwidget");

   220         }

   221     mIncoming = false;

   222     mConversation->resetProperties();

   223     

   224     mConversation->setMMS(true);

   225     int direction = index.data(Direction).toInt();

   226     QString bodyText = index.data(BodyText).toString();

   227 

   228     if (direction == ConvergedMessage::Incoming)

   229         {

   230         setIncoming(true);

   231         mConversation->setIncoming(true);

   232 

   233         if (messageType == ConvergedMessage::MmsNotification)

   234             {

   235             mConversation->setMMSNotification(true);

   236             int notificationState = index.data(NotificationStatus).toInt();

   237             mConversation->setNotificationState(notificationState);

   238             setNotificationStateIcon(notificationState);

   239             }

   240         else

   241             {

   242             mIncomingMsgStateIconItem->setVisible(false);

   243             }

   244         }

   245     else if (direction == ConvergedMessage::Outgoing)

   246         {

   247         setIncoming(false);

   248         mConversation->setIncoming(false);

   249 

   250         int sendingState = index.data(SendingState).toInt();

   251         mConversation->setSendingState(sendingState);

   252         setMessageStateIcon(sendingState);

   253         }

   254 

   255     bool unreadStatus = index.data(UnReadStatus).toBool();

   256     mConversation->setUnread(unreadStatus);

   257 

   258     mConversation->drawBubbleFrame();

   259     mConversation->drawNewItemFrame();

   260 

   261     QDateTime dateTime;

   262     dateTime.setTime_t(index.data(TimeStamp).toUInt());

   263     QString resendStateNote((index.data(SendingState).toInt()

   264             == ConvergedMessage::Resend) ? LOC_RESEND_AT : "");

   265 

   266     HbExtendedLocale locale = HbExtendedLocale::system();

   267     QString date = locale.format(dateTime.date(), DATE_FORMAT);

   268     QString time = locale.format(dateTime.time(), TIME_FORMAT);

   269 

   270     if (dateTime.date() == QDateTime::currentDateTime().date()) {

   271         mConversation->setTimeStamp(resendStateNote % time);

   272     }

   273     else {

   274         mConversation->setTimeStamp(resendStateNote % date);

   275     }

   276 

   277     if (messageType == ConvergedMessage::Mms)

   278         {

   279         //preview path

   280         QString previewPath = index.data(Attachments).toString();

   281         QString subject = index.data(Subject).toString();

   282 

   283         int msgProperty = index.data(MessageProperty).toInt();

   284         bool hasAttachments = (msgProperty & EPreviewAttachment) ? true : false;

   285 

   286         if (hasAttachments)

   287             {

   288             mConversation->setAttachment();

   289             }

   290         else

   291             {

   292             mConversation->setAttachment(false);

   293             }

   294         

   295         // Now set the media contents

   296         

   297         //preview image

   298         bool hasImage = (msgProperty & EPreviewImage) ? true : false;

   299         if (hasImage)

   300           {

   301             mConversation->setImage(true);

   302             HbIcon previewIcon;

   303             if (msgProperty & EPreviewProtectedImage)

   304               {

   305                 previewIcon = HbIcon(IMAGE_ICON);

   306               }

   307             else if (msgProperty & EPreviewCorruptedImage)

   308               {

   309                 // TODO: Change to official icon.

   310                 previewIcon = HbIcon(CORRUPTED_ICON);

   311               }

   312             else

   313               {

   314                 QVariant previewData = index.data(PreviewIcon);

   315                 previewIcon = qvariant_cast<HbIcon> (previewData);

   316               }

   317             mConversation->setPreviewIcon(previewIcon);

   318           }

   319 

   320         bool hasVideo = (msgProperty & EPreviewVideo) ? true : false;

   321         if (hasVideo)

   322           {

   323             mConversation->setVideo(true);

   324             HbIcon videoPreviewIcon;

   325             if (msgProperty & EPreviewProtectedVideo)

   326               {

   327                 videoPreviewIcon = HbIcon(MSG_VIDEO_ICON);

   328               }

   329             else if (msgProperty & EPreviewCorruptedVideo)

   330               {

   331                 videoPreviewIcon = HbIcon(CORRUPTED_ICON);

   332               }

   333             else

   334               {

   335                 videoPreviewIcon = HbIcon(MSG_VIDEO_ICON);

   336               }

   337             mConversation->setPreviewIcon(videoPreviewIcon);

   338           }

   339         bool hasAudio = (msgProperty & EPreviewAudio) ? true : false;              

   340         if (hasAudio)

   341           {

   342             mConversation->setAudio(true);

   343             if (msgProperty & EPreviewProtectedAudio)

   344               {

   345                 mConversation->displayAudioIcon();

   346               }

   347             else if (msgProperty & EPreviewCorruptedAudio)

   348               {

   349 				mConversation->displayAudioIcon(CORRUPTED_ICON);

   350               }

   351             else

   352               {

   353                 mConversation->displayAudioIcon();

   354               }

   355           }

   356 

   357         int priority = index.data(MessagePriority).toInt();

   358         mConversation->setPriority(priority);

   359         mConversation->setSubject(subject);

   360         mConversation->setBodyText(bodyText);

   361         }

   362     else if (messageType == ConvergedMessage::BioMsg)

   363         {

   364         if (messageSubType == ConvergedMessage::RingingTone)

   365             {

   366             mConversation->setImage(false);

   367             mConversation->setAudio(true);

   368             mConversation->displayAudioIcon();

   369             mConversation->setSubject(LOC_RINGING_TONE);

   370             mConversation->setBodyText(bodyText);

   371             }

   372         else if (messageSubType == ConvergedMessage::VCard)

   373             {

   374             mConversation->setImage(false);

   375             mConversation->setAudio(true);

   376             mConversation->displayAudioIcon(VCARD_ICON);

   377             mConversation->setSubject(LOC_BUSINESS_CARD);

   378             mConversation->setBodyText(bodyText);

   379             }

   380         }

   381     else if (messageType == ConvergedMessage::BT)

   382         {

   383         QString deviceName = index.data(ConversationAddress).toString();

   384         mConversation->setSubject(deviceName);

   385         QString blueToothBody;

   386         if (messageSubType == ConvergedMessage::VCard)

   387             {

   388             mConversation->setImage(false);

   389             mConversation->setAudio(true);

   390             mConversation->displayAudioIcon(VCARD_ICON);

   391             blueToothBody.append(LOC_BUSINESS_CARD);

   392             blueToothBody.append(QChar::LineSeparator);

   393             blueToothBody.append(bodyText);

   394             }

   395         else

   396             {

   397             blueToothBody.append(bodyText);

   398             }

   399         mConversation->setBodyText(blueToothBody);

   400         }

   401     else if (messageType == ConvergedMessage::MmsNotification)

   402         {

   403         QString subject = index.data(Subject).toString();

   404         int priority = index.data(MessagePriority).toInt();

   405         mConversation->setPriority(priority);

   406         mConversation->setSubject(subject);

   407         mConversation->setBodyText(bodyText);

   408         }

   409     

   410     //repolish widget

   411     mConversation->repolishWidget();

   412     }

   413 

   414 //---------------------------------------------------------------

   415 // MsgConversationViewItem::containsPoint

   416 //

   417 //---------------------------------------------------------------

   418 bool MsgConversationViewItem::containsPoint(const QPointF& point)

   419 {

   420     return mConversation->boundingRect(). contains(mConversation->mapFromScene(

   421         point));

   422 }

   423 

   424 //---------------------------------------------------------------

   425 // MsgConversationViewItem::setIncoming

   426 // @see header file

   427 //---------------------------------------------------------------

   428 void MsgConversationViewItem::setIncoming(bool incoming)

   429 {

   430     mIncoming = incoming;

   431 

   432     if (mIncoming)

   433     {

   434         HbStyle::setItemName(mOutgoingMsgStateIconItem, "");

   435         mOutgoingMsgStateIconItem->setVisible(false);

   436         HbStyle::setItemName(mIncomingMsgStateIconItem, "msgStateIconIncoming");

   437         mIncomingMsgStateIconItem->setIcon(HbIcon());

   438         mIncomingMsgStateIconItem->setVisible(false);

   439     }

   440     else

   441     {

   442         HbStyle::setItemName(mIncomingMsgStateIconItem, "");

   443         mIncomingMsgStateIconItem->setVisible(false);

   444         HbStyle::setItemName(mOutgoingMsgStateIconItem, "msgStateIconOutgoing");

   445         mOutgoingMsgStateIconItem->setIcon(HbIcon());

   446         mOutgoingMsgStateIconItem->setVisible(false);

   447     }

   448 }

   449 

   450 //---------------------------------------------------------------

   451 // MsgConversationViewItem::isIncoming

   452 // @see header file

   453 //---------------------------------------------------------------

   454 bool MsgConversationViewItem::isIncoming()

   455 {

   456     return mIncoming;

   457 }

   458 

   459 //---------------------------------------------------------------

   460 // MsgConversationViewItem::setMessageStateIcon

   461 // @see header file

   462 //---------------------------------------------------------------

   463 void MsgConversationViewItem::setMessageStateIcon(int messageState)

   464 {

   465     HbIconAnimator& iconAnimator = mOutgoingMsgStateIconItem->animator();

   466 

   467     switch (messageState)

   468     {

   469         case ConvergedMessage::Waiting:

   470         case ConvergedMessage::Scheduled:

   471         case ConvergedMessage::Sending:

   472         {

   473             HbIconAnimationManager::global()->addDefinitionFile(ANIMATION_FILE);

   474             mOutgoingMsgStateIconItem->setIconName(ANIMATION_ICON_NAME);

   475             mOutgoingMsgStateIconItem->setVisible(true);

   476             iconAnimator.startAnimation();

   477             break;

   478         }     

   479         case ConvergedMessage::Suspended:

   480         case ConvergedMessage::Resend:

   481         {

   482             iconAnimator.stopAnimation();

   483             mOutgoingMsgStateIconItem->setIconName(MSG_OUTBOX_ICON);

   484             mOutgoingMsgStateIconItem->setVisible(true);

   485             break;

   486         }

   487         case ConvergedMessage::Failed:

   488         {

   489             iconAnimator.stopAnimation();

   490             mOutgoingMsgStateIconItem->setIconName(MSG_FAIL_ICON);

   491             mOutgoingMsgStateIconItem->setVisible(true);

   492             break;

   493         }   

   494         case ConvergedMessage::Unknown:

   495         default:

   496         {

   497             iconAnimator.stopAnimation();

   498             mOutgoingMsgStateIconItem->setVisible(false);

   499             break;

   500         }

   501     }

   502 }

   503 

   504 //---------------------------------------------------------------

   505 // MsgConversationViewItem::setNotificationStateIcon

   506 // @see header file

   507 //---------------------------------------------------------------

   508 

   509 void MsgConversationViewItem::setNotificationStateIcon(int notificationState)

   510 {

   511     HbIconAnimator& iconAnimator = mIncomingMsgStateIconItem->animator();

   512     HbIconAnimationManager* iconAnimationManager =

   513             HbIconAnimationManager::global();

   514     switch (notificationState)

   515     {

   516         case ConvergedMessage::NotifRetrieving:

   517         case ConvergedMessage::NotifWaiting:

   518         { 

   519             //TODO: Temp icon until official icons are received

   520             bool defined = iconAnimationManager->addDefinitionFile(

   521                 ANIMATION_FILE);

   522             HbIcon animIcon;

   523             animIcon.setIconName(ANIMATION_ICON_NAME);

   524             QSizeF size = mIncomingMsgStateIconItem->size();

   525             mIncomingMsgStateIconItem->setIcon(animIcon);

   526             mIncomingMsgStateIconItem->setVisible(true);

   527             iconAnimator.startAnimation();

   528             break;

   529         }     

   530         default:

   531         {

   532             iconAnimator.stopAnimation();

   533             mIncomingMsgStateIconItem->setVisible(false);

   534             break;

   535         }

   536     }

   537 }

   538 

   539 //---------------------------------------------------------------

   540 // MsgConversationViewItem::pressStateChanged

   541 // @see header file

   542 //---------------------------------------------------------------

   543 void MsgConversationViewItem::pressStateChanged (bool pressed, bool animate)

   544 {

   545     mConversation->pressStateChanged(pressed, animate);

   546 }

   547 

   548 //---------------------------------------------------------------

   549 // MsgConversationViewItem::init

   550 // @see header file

   551 //---------------------------------------------------------------

   552 void MsgConversationViewItem::init()

   553 {

   554     mConversation = new MsgConversationWidget(this);

   555     HbStyle::setItemName(mConversation, "msgconvwidget");

   556 

   557     mIncomingMsgStateIconItem = new HbIconItem(this);

   558     HbStyle::setItemName(mIncomingMsgStateIconItem, "msgStateIconIncoming");

   559 

   560     mOutgoingMsgStateIconItem = new HbIconItem(this);

   561     HbStyle::setItemName(mOutgoingMsgStateIconItem, "msgStateIconOutgoing");

   562 

   563     HbMainWindow *mainWindow = hbInstance->allMainWindows()[0];

   564 

   565     connect(mainWindow, SIGNAL(orientationChanged(Qt::Orientation)), this,

   566         SLOT(orientationchanged(Qt::Orientation)), Qt::UniqueConnection);

   567 

   568     // Force polish to get all the sub-item properties right.

   569     polishEvent();

   570 }

   571 

   572 //---------------------------------------------------------------

   573 // MsgConversationViewItem::orientationchanged

   574 // @see header file

   575 //---------------------------------------------------------------

   576 void MsgConversationViewItem::orientationchanged(Qt::Orientation orientation)

   577 {

   578     Q_UNUSED(orientation)

   579     QDEBUG_WRITE("MsgConversationViewItem:orientationchanged start.")

   580 

   581     repolish();

   582 

   583     QDEBUG_WRITE("MsgConversationViewItem:orientationchanged end.")

   584 }

   585 

   586 // EOF