calendarui/controller/src/calenicons.cpp
branchRCL_3
changeset 21 9711e452b5e9
parent 5 42814f902fe6
child 67 1539a383d7b6
equal deleted inserted replaced
20:21239b3bcd78 21:9711e452b5e9
    18 
    18 
    19 #include "calendarui_debug.h"
    19 #include "calendarui_debug.h"
    20 #include "calenicons.h"
    20 #include "calenicons.h"
    21 #include "calendar.hrh"
    21 #include "calendar.hrh"
    22 
    22 
       
    23 #include <CalenUid.h> 
    23 #include <aknconsts.h>
    24 #include <aknconsts.h>
    24 #include <data_caging_path_literals.hrh>
    25 #include <data_caging_path_literals.hrh>
    25 #include <AknIconArray.h>
    26 #include <AknIconArray.h>
    26 #include <AknsDrawUtils.h>
    27 #include <AknsDrawUtils.h>
    27 #include <avkon.mbg>
    28 #include <avkon.mbg>
   307 // CalenIcons::GetIcon
   308 // CalenIcons::GetIcon
   308 // Gets an icon according to the icon index being passed in 
   309 // Gets an icon according to the icon index being passed in 
   309 // (other items were commented in a header).
   310 // (other items were commented in a header).
   310 // ---------------------------------------------------------
   311 // ---------------------------------------------------------
   311 //
   312 //
   312 EXPORT_C CGulIcon* CCalenIcons::GetIconL( MCalenServices::TCalenIcons aIndex ) const
   313 EXPORT_C CGulIcon* CCalenIcons::GetIconL( MCalenServices::TCalenIcons aIndex, const TInt aViewId ) const 
   313     {
   314     {
   314     TRACE_ENTRY_POINT;
   315     TRACE_ENTRY_POINT;
   315     CGulIcon* icon;
   316     CGulIcon* icon;
   316     // Alarm and repeat icon. Color skinned with day view icon color 
   317     // Alarm and repeat icon. Color skinned with day view icon color 
   317     // FIXME: highlight coloring in lists doesn't work for icons.
   318     // FIXME: highlight coloring in lists doesn't work for icons.
   318     // When Avkon suplies some method to do that, change these 
   319     // When Avkon suplies some method to do that, change these 
   319     TAknsItemID colorGroup = KAknsIIDQsnIconColors;
   320     TAknsItemID colorGroup = KAknsIIDQsnIconColors;
   320     TInt colorIndex = EAknsCIQsnIconColorsCG19;
   321     TInt colorIndex = EAknsCIQsnIconColorsCG19;
       
   322     TInt colorIndexToDo = EAknsCIQsnIconColorsCG13;
   321     TRgb nonSkinColor = AKN_LAF_COLOR(215);
   323     TRgb nonSkinColor = AKN_LAF_COLOR(215);
   322     CFbsBitmap* bitmap = NULL;
   324     CFbsBitmap* bitmap = NULL;
   323     CFbsBitmap* mask = NULL;
   325     CFbsBitmap* mask = NULL;
   324     
   326     
   325     switch( aIndex )
   327     switch( aIndex )
   368                                                           EMbmCalendarQgn_indi_cdr_todo_mask );
   370                                                           EMbmCalendarQgn_indi_cdr_todo_mask );
   369             }
   371             }
   370             break;
   372             break;
   371         case MCalenServices::ECalenAlarmIcon:
   373         case MCalenServices::ECalenAlarmIcon:
   372             {
   374             {
   373             AknsUtils::CreateColorIconLC( AknsUtils::SkinInstance(), 
   375             if(aViewId == KCalenTodoViewUidValue || 
   374                                                      KAknsIIDQgnIndiAlarmAdd,
   376                aViewId == KCalenEventViewUidValue || 
   375                                                      colorGroup,
   377                aViewId == KCalenMissedAlarmsViewUidValue ||
   376                                                      colorIndex,
   378                aViewId == KCalenMissedEventViewUidValue )
   377                                                      bitmap, mask,
   379                 {
   378                                                      AknIconUtils::AvkonIconFileName(),
   380                 AknsUtils::CreateColorIconLC( AknsUtils::SkinInstance(), 
   379                                                      EMbmAvkonQgn_indi_alarm_add,
   381                                                          KAknsIIDQgnIndiAlarmAdd,
   380                                                      EMbmAvkonQgn_indi_alarm_add_mask,
   382                                                          colorGroup,
   381                                                      nonSkinColor);
   383                                                          colorIndexToDo,
   382             icon = CGulIcon::NewL( bitmap, mask );
   384                                                          bitmap, mask,
   383             CleanupStack::Pop( 2 ); // bitmap, mask
   385                                                          AknIconUtils::AvkonIconFileName(),
   384             }
   386                                                          EMbmAvkonQgn_indi_alarm_add,
   385             break;
   387                                                          EMbmAvkonQgn_indi_alarm_add_mask,
       
   388                                                          nonSkinColor);
       
   389                 icon = CGulIcon::NewL( bitmap, mask );
       
   390                 CleanupStack::Pop( 2 ); // bitmap, mask
       
   391                 break;
       
   392                 }
       
   393             else 
       
   394                 {
       
   395                 AknsUtils::CreateColorIconLC( AknsUtils::SkinInstance(), 
       
   396                                                        KAknsIIDQgnIndiAlarmAdd,
       
   397                                                        colorGroup,
       
   398                                                        colorIndex,
       
   399                                                        bitmap, mask,
       
   400                                                        AknIconUtils::AvkonIconFileName(),
       
   401                                                        EMbmAvkonQgn_indi_alarm_add,
       
   402                                                        EMbmAvkonQgn_indi_alarm_add_mask,
       
   403                                                        nonSkinColor);
       
   404                 icon = CGulIcon::NewL( bitmap, mask );
       
   405                 CleanupStack::Pop( 2 ); // bitmap, mask
       
   406                 break;
       
   407                 }                
       
   408             }
       
   409             
   386         case MCalenServices::ECalenRepeatIcon:
   410         case MCalenServices::ECalenRepeatIcon:
   387             {
   411             {
   388             AknsUtils::CreateColorIconLC( AknsUtils::SkinInstance(), 
   412             if(aViewId == KCalenTodoViewUidValue || 
   389                                                      KAknsIIDQgnIndiRepeatAdd,
   413                aViewId == KCalenEventViewUidValue || 
   390                                                      colorGroup,
   414                aViewId == KCalenMissedAlarmsViewUidValue ||
   391                                                      colorIndex,
   415                aViewId == KCalenMissedEventViewUidValue )
   392                                                      bitmap, mask,
   416                 {
   393                                                      iIconFile,
   417                 AknsUtils::CreateColorIconLC( AknsUtils::SkinInstance(), 
   394                                                      EMbmCalendarQgn_indi_repeat_add,
   418                                                          KAknsIIDQgnIndiRepeatAdd,
   395                                                      EMbmCalendarQgn_indi_repeat_add_mask,
   419                                                          colorGroup,
   396                                                      nonSkinColor);
   420                                                          colorIndexToDo,
   397             icon = CGulIcon::NewL(bitmap, mask);
   421                                                          bitmap, mask,
   398             CleanupStack::Pop( 2 );
   422                                                          iIconFile,
   399             }
   423                                                          EMbmCalendarQgn_indi_repeat_add,
   400             break;
   424                                                          EMbmCalendarQgn_indi_repeat_add_mask,
       
   425                                                          nonSkinColor);
       
   426                 icon = CGulIcon::NewL(bitmap, mask);
       
   427                 CleanupStack::Pop( 2 );
       
   428                 break;
       
   429                 }
       
   430             else
       
   431                 {
       
   432                 AknsUtils::CreateColorIconLC( AknsUtils::SkinInstance(), 
       
   433                                                          KAknsIIDQgnIndiRepeatAdd,
       
   434                                                          colorGroup,
       
   435                                                          colorIndex,
       
   436                                                          bitmap, mask,
       
   437                                                          iIconFile,
       
   438                                                          EMbmCalendarQgn_indi_repeat_add,
       
   439                                                          EMbmCalendarQgn_indi_repeat_add_mask,
       
   440                                                          nonSkinColor);
       
   441                 icon = CGulIcon::NewL(bitmap, mask);
       
   442                 CleanupStack::Pop( 2 );
       
   443                 break;
       
   444                 }
       
   445             }
       
   446            
   401         case MCalenServices::ECalenRepeatExceptionIcon:
   447         case MCalenServices::ECalenRepeatExceptionIcon:
   402             {
   448             {
   403             AknsUtils::CreateColorIconLC(AknsUtils::SkinInstance(), 
   449             if(aViewId == KCalenTodoViewUidValue || 
   404                                          KAknsIIDQgnIndiRepeatExceptionAdd,
   450                aViewId == KCalenEventViewUidValue || 
   405                                          colorGroup,
   451                aViewId == KCalenMissedAlarmsViewUidValue ||
   406                                          colorIndex,
   452                aViewId == KCalenMissedEventViewUidValue )
   407                                          bitmap, mask,
   453                 {
   408                                          iIconFile,
   454                 AknsUtils::CreateColorIconLC(AknsUtils::SkinInstance(), 
   409                                          EMbmCalendarQgn_indi_repeat_exception_add,
   455                                              KAknsIIDQgnIndiRepeatExceptionAdd,
   410                                          EMbmCalendarQgn_indi_repeat_exception_add_mask,
   456                                              colorGroup,
   411                                          nonSkinColor);
   457                                              colorIndexToDo,
   412             icon = CGulIcon::NewL(bitmap, mask);
   458                                              bitmap, mask,
   413             CleanupStack::Pop(2); // bitmap, mask;
   459                                              iIconFile,
   414             }
   460                                              EMbmCalendarQgn_indi_repeat_exception_add,
   415             break;
   461                                              EMbmCalendarQgn_indi_repeat_exception_add_mask,
       
   462                                              nonSkinColor);
       
   463                 icon = CGulIcon::NewL(bitmap, mask);
       
   464                 CleanupStack::Pop(2); // bitmap, mask;
       
   465                 break;
       
   466                 }
       
   467             else
       
   468                 {
       
   469                 AknsUtils::CreateColorIconLC(AknsUtils::SkinInstance(), 
       
   470                                              KAknsIIDQgnIndiRepeatExceptionAdd,
       
   471                                              colorGroup,
       
   472                                              colorIndex,
       
   473                                              bitmap, mask,
       
   474                                              iIconFile,
       
   475                                              EMbmCalendarQgn_indi_repeat_exception_add,
       
   476                                              EMbmCalendarQgn_indi_repeat_exception_add_mask,
       
   477                                              nonSkinColor);
       
   478                 icon = CGulIcon::NewL(bitmap, mask);
       
   479                 CleanupStack::Pop(2); // bitmap, mask;
       
   480                 break;
       
   481                 }
       
   482                 
       
   483             }
   416         case MCalenServices::ECalenNotePriorityLow:
   484         case MCalenServices::ECalenNotePriorityLow:
   417             {
   485             {
   418             AknsUtils::CreateColorIconLC(AknsUtils::SkinInstance(), 
   486             if(aViewId == KCalenTodoViewUidValue || 
   419                                          KAknsIIDQgnIndiTodoLowAdd,
   487                aViewId == KCalenEventViewUidValue || 
   420                                          colorGroup,
   488                aViewId == KCalenMissedAlarmsViewUidValue ||
   421                                          colorIndex,
   489                aViewId == KCalenMissedEventViewUidValue )
   422                                          bitmap, mask,
   490                 {
   423                                          iIconFile,
   491                 AknsUtils::CreateColorIconLC(AknsUtils::SkinInstance(), 
   424                                          EMbmCalendarQgn_indi_todo_low_add,
   492                                              KAknsIIDQgnIndiTodoLowAdd,
   425                                          EMbmCalendarQgn_indi_todo_low_add_mask,
   493                                              colorGroup,
   426                                          nonSkinColor);
   494                                              colorIndexToDo,
   427             icon = CGulIcon::NewL(bitmap, mask);
   495                                              bitmap, mask,
   428             CleanupStack::Pop(2); // bitmap, mask;
   496                                              iIconFile,
   429             }
   497                                              EMbmCalendarQgn_indi_todo_low_add,
   430             break;
   498                                              EMbmCalendarQgn_indi_todo_low_add_mask,
       
   499                                              nonSkinColor);
       
   500                 icon = CGulIcon::NewL(bitmap, mask);
       
   501                 CleanupStack::Pop(2); // bitmap, mask;
       
   502                 break;
       
   503                 }
       
   504             else 
       
   505                 {
       
   506                 AknsUtils::CreateColorIconLC(AknsUtils::SkinInstance(), 
       
   507                                                          KAknsIIDQgnIndiTodoLowAdd,
       
   508                                                          colorGroup,
       
   509                                                          colorIndex,
       
   510                                                          bitmap, mask,
       
   511                                                          iIconFile,
       
   512                                                          EMbmCalendarQgn_indi_todo_low_add,
       
   513                                                          EMbmCalendarQgn_indi_todo_low_add_mask,
       
   514                                                          nonSkinColor);
       
   515                 icon = CGulIcon::NewL(bitmap, mask);
       
   516                 CleanupStack::Pop(2); // bitmap, mask;
       
   517                 break;
       
   518                 }                           
       
   519             }
       
   520             
   431         case MCalenServices::ECalenNotePriorityHigh:
   521         case MCalenServices::ECalenNotePriorityHigh:
   432             {
   522             {
   433             AknsUtils::CreateColorIconLC(AknsUtils::SkinInstance(), 
   523             if(aViewId == KCalenTodoViewUidValue || 
   434                                          KAknsIIDQgnIndiTodoHighAdd,
   524                aViewId == KCalenEventViewUidValue || 
   435                                          colorGroup,
   525                aViewId == KCalenMissedAlarmsViewUidValue ||
   436                                          colorIndex,
   526                aViewId == KCalenMissedEventViewUidValue )
   437                                          bitmap, mask,
   527                 {
   438                                          iIconFile,
   528                 AknsUtils::CreateColorIconLC(AknsUtils::SkinInstance(), 
   439                                          EMbmCalendarQgn_indi_todo_high_add,
   529                                              KAknsIIDQgnIndiTodoHighAdd,
   440                                          EMbmCalendarQgn_indi_todo_high_add_mask,
   530                                              colorGroup,
   441                                          nonSkinColor );
   531                                              colorIndexToDo,
   442             icon = CGulIcon::NewL(bitmap, mask);
   532                                              bitmap, mask,
   443             CleanupStack::Pop(2); // bitmap, mask;
   533                                              iIconFile,
   444             }
   534                                              EMbmCalendarQgn_indi_todo_high_add,
   445             break;
   535                                              EMbmCalendarQgn_indi_todo_high_add_mask,
       
   536                                              nonSkinColor );
       
   537                 icon = CGulIcon::NewL(bitmap, mask);
       
   538                 CleanupStack::Pop(2); // bitmap, mask;
       
   539                 break;
       
   540                 }
       
   541             else 
       
   542                 {
       
   543                 AknsUtils::CreateColorIconLC(AknsUtils::SkinInstance(), 
       
   544                                                          KAknsIIDQgnIndiTodoHighAdd,
       
   545                                                          colorGroup,
       
   546                                                          colorIndex,
       
   547                                                          bitmap, mask,
       
   548                                                          iIconFile,
       
   549                                                          EMbmCalendarQgn_indi_todo_high_add,
       
   550                                                          EMbmCalendarQgn_indi_todo_high_add_mask,
       
   551                                                          nonSkinColor );
       
   552                 icon = CGulIcon::NewL(bitmap, mask);
       
   553                 CleanupStack::Pop(2); // bitmap, mask;
       
   554                 break;
       
   555                 }
       
   556             }
   446         case MCalenServices::ECalenTodoIconUndone:
   557         case MCalenServices::ECalenTodoIconUndone:
   447             {
   558             {
   448             icon = CreateBitmapSkinnedIconL( KAknsIIDQgnPropTodoUndone,
   559             icon = CreateBitmapSkinnedIconL( KAknsIIDQgnPropTodoUndone,
   449                                                         iIconFile, 
   560                                                         iIconFile, 
   450                                                         EMbmCalendarQgn_prop_todo_undone,
   561                                                         EMbmCalendarQgn_prop_todo_undone,