1 /*

     2 * Copyright (c) 2002 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 

    19 

    20 #include <eikimage.h>

    21 #include <eikprogi.h>

    22 

    23 #include <avkon.mbg>

    24 #include <aknconsts.h>

    25 #include <AknPanic.h>

    26 #include <AknUtils.h>

    27 #include <AknLayoutDef.h>

    28 #include <AknLayout.lag>

    29 

    30 #include "aknnotecontrol.h"

    31 #include "notelaf.h"

    32 #include "aknnoteattributes.h"

    33 #include "akntextcontrol.h"

    34 

    35 #include <aknlayoutscalable_avkon.cdl.h>

    36 #include <AknsDrawUtils.h>

    37 #include <AknsFrameBackgroundControlContext.h>

    38 #include <eikbtgpc.h>  // CEikButtonGroupContainer

    39 

    40 // Skin layout macros

    41 #include <skinlayout.cdl.h>

    42 using namespace SkinLayout;

    43 

    44 #include <AknIconUtils.h>

    45 #include "aknappui.h"

    46 

    47 #include <eikdialg.h>

    48 #include <eikdialogext.h>

    49 #include <touchfeedback.h>

    50 

    51 #include <AknTasHook.h> // for testability hooks

    52 const TInt KRate = 95;    // 95% similar rate

    53 const TInt KFullColor = 255;

    54 

    55 // ---------------------------------------------

    56 // CONSTRUCTION - DESTRUCTION

    57 // ---------------------------------------------

    58 

    59 /**

    60  * The class default constructor. 

    61  *

    62  * 

    63  */

    64 EXPORT_C CAknNoteControl::CAknNoteControl()

    65     {

    66     AKNTASHOOK_ADD( this, "CAknNoteControl" );

    67     }

    68 

    69 /**

    70  * The class destructor. 

    71  *

    72  * 

    73  */

    74 EXPORT_C CAknNoteControl::~CAknNoteControl()

    75     {

    76     AKNTASHOOK_REMOVE();

    77     MTouchFeedback* feedback = MTouchFeedback::Instance();

    78     if ( feedback )

    79         {

    80         feedback->RemoveFeedbackForControl( this );

    81         }

    82 

    83     delete iAttributes;

    84     delete iLineWidths;

    85     }

    86 

    87 void CAknNoteControl::ConstructFromResourceL(TResourceReader &aRes)

    88     {

    89     

    90     delete iLineWidths;

    91     iLineWidths = 0;

    92 

    93     iLineWidths = new(ELeave)CArrayFixFlat<TInt>(5);

    94     iNoteLayout = aRes.ReadUint16();

    95 

    96     delete iAttributes;

    97     iAttributes = NULL;

    98     iAttributes = new (ELeave)CAknNoteAttributes(this);

    99     iAttributes->ConstructFromResourceL(aRes);

   100     

   101     CreateDefaultImageL();

   102     ReduceImageIfNeeded();

   103 

   104     ParseTextL();

   105     

   106     iAttributes->iBgContext->SetCenter(KAknsIIDQsnFrPopupCenterNote);

   107     

   108     if( CAknEnv::Static()->TransparencyEnabled() )

   109         {

   110         CEikDialog* dlg;

   111         MopGetObject( dlg );

   112         if ( dlg )

   113             {

   114             dlg->Extension()->iPublicFlags.Set( CEikDialogExtension::EClipChildControlRect );

   115             }

   116         }

   117     }

   118 

   119 void CAknNoteControl::Reset()

   120     {

   121     // Used by sleeping notes when going to background,

   122     // in order to stop and delete animations

   123     CancelAnimation();

   124     }

   125 

   126 

   127 // -----------------------------------------

   128 //  CCOECONTROL METHODS

   129 // -----------------------------------------

   130 void CAknNoteControl::Draw(const TRect& /*aRect*/) const

   131     {   

   132     MAknsSkinInstance* skin = AknsUtils::SkinInstance();

   133 

   134     MAknsControlContext* cc = iAttributes->iBgContext;

   135     

   136 #ifdef RD_UI_TRANSITION_EFFECTS_POPUPS

   137     //Controls _have_to_ get gc through CCoeControl::SystemGc to be transition compatible.

   138     CWindowGc& gc = SystemGc();

   139 #else    

   140     //iAttributes->iBgRect should be always valid

   141     CWindowGc& gc = iCoeEnv->SystemGc();

   142 #endif  

   143 

   144     TBool oomError = EFalse;

   145     if( CAknEnv::Static()->TransparencyEnabled() )

   146         {

   147         oomError = !AknsDrawUtils::Background( skin, cc, this, gc,

   148             iAttributes->iBgRect.IsEmpty()?LayoutRect():iAttributes->iBgRect, KAknsDrawParamNoClearUnderImage);

   149         }

   150     else

   151         {

   152         oomError = !AknsDrawUtils::Background( skin, cc, this, gc,

   153             iAttributes->iBgRect.IsEmpty()?LayoutRect():iAttributes->iBgRect, KAknsDrawParamDefault);

   154         }

   155 

   156     if( oomError )

   157     {

   158         MAknsSkinInstance* skin = AknsUtils::SkinInstance();

   159         TRgb color;

   160         TInt error = AknsUtils::GetCachedColor( skin, color,

   161             KAknsIIDQsnTextColors, EAknsCIQsnTextColorsCG19 );

   162 

   163         TInt redcolor = color.Red();

   164         TInt bluecolor = color.Blue();

   165         TInt greencolor = color.Green();

   166         // test if the color is too similar to white color

   167         if ( redcolor > KFullColor * KRate / 100 || 

   168              bluecolor > KFullColor * KRate / 100 || 

   169              greencolor > KFullColor * KRate / 100 )

   170             {

   171             color = KRgbBlack;

   172             }

   173         for (TInt i=0; i < NumberOfLines(); i++)

   174             {

   175             AknLayoutUtils::LayoutLabel

   176              ( TextControl()->Line( i ),LayoutRect(),AKN_LAYOUT_TEXT_Note_pop_up_window_texts_Line_1( i ) );

   177 

   178             if (!error)

   179                 {

   180                 // Ignore error

   181                 TRAP_IGNORE( AknLayoutUtils::OverrideControlColorL( *TextControl()->Line(i), 

   182                     EColorLabelText, color ) );

   183                 }

   184             }

   185     }

   186     if (iImageHasShadow)

   187         {

   188         iShadowRect.DrawRect( gc );

   189         }   

   190     }

   191     

   192 EXPORT_C void CAknNoteControl::HandlePointerEventL(const TPointerEvent& aPointerEvent) 

   193     { 

   194     CAknControl::HandlePointerEventL(aPointerEvent); 

   195     if (iAttributes->iFlags.IsSet( ENoteLeftSKWhenTapped ) && 

   196        (aPointerEvent.iType == TPointerEvent::EButton1Up) &&

   197        Rect().Contains( aPointerEvent.iPosition ) )

   198         {

   199         // Left soft key press

   200         TRawEvent event;

   201         event.Set(TRawEvent::EKeyDown, EStdKeyDevice0);

   202         CEikonEnv::Static()->WsSession().SimulateRawEvent(event);

   203         event.Set(TRawEvent::EKeyUp, EStdKeyDevice0);

   204         CEikonEnv::Static()->WsSession().SimulateRawEvent(event);

   205         }

   206     }

   207 

   208 EXPORT_C void* CAknNoteControl::ExtensionInterface( TUid /*aInterface*/ ) 

   209     { 

   210     return NULL;

   211     }

   212 

   213 CCoeControl* CAknNoteControl::ComponentControl(TInt aIndex) const

   214     {

   215     const CCoeControl* controls[] = {Icon(),TextControl(),ProgressBar(),

   216                                         Image(),Animation()};

   217     for (TUint ii=0;ii<sizeof(controls)/sizeof(CCoeControl*);ii++)

   218       if (controls[ii] && aIndex-- == 0)

   219           return const_cast<CCoeControl*>(controls[ii]);

   220     return NULL;

   221     }

   222 

   223 

   224 TInt CAknNoteControl::CountComponentControls() const

   225     {

   226     if (!Attributes())

   227         {

   228         return 0;

   229         }

   230     TInt count = 0;

   231     const CCoeControl* controls[] = { Icon(),TextControl(),ProgressBar(),

   232                                         Image(), Animation() };

   233     for (TUint ii=0;ii<sizeof(controls)/sizeof(CCoeControl*);ii++)

   234         if (controls[ii])

   235             count++;

   236     return count;

   237     }

   238 

   239 TSize CAknNoteControl::MinimumSize()

   240     {   

   241     TAknWindowLineLayout dialogLay;

   242     WindowLayout( dialogLay );

   243 

   244     TAknLayoutRect dialogLayRect;

   245     dialogLayRect.LayoutRect(iAvkonAppUi->ApplicationRect(), dialogLay);

   246     TSize dialogSize = dialogLayRect.Rect().Size();

   247 #ifndef RD_NO_DIALOG_BORDERS

   248     TRect parent(TPoint(0,0),dialogSize);

   249 

   250     TAknWindowLineLayout internalLay = AKN_LAYOUT_WINDOW_Note_pop_up_window_graphics_Line_5(parent);

   251 

   252     if ( iNoteLayout == ENotificationWithGraphicsLayout ||

   253          iNoteLayout == ETextualNotificationLayout )

   254         {

   255         internalLay = AKN_LAYOUT_WINDOW_Notification_pop_up_window_graphics__text__Line_5(parent);

   256         }

   257 

   258     TAknLayoutRect internalLayRect;

   259     internalLayRect.LayoutRect(parent, internalLay);

   260 

   261     return internalLayRect.Rect().Size();

   262 #else

   263     return dialogSize;

   264 #endif

   265     }

   266 

   267 /**

   268  * Do layout. 

   269  *

   270  * Always do layout even when there might be no need for it (e.g.

   271  * because nothing has changed). This method is called by the 

   272  * CONE framework when the size or position of the control is

   273  * changed and hence layout must always be done. 

   274  *

   275  * Do not call this method when you need to do layout for reasons

   276  * different than the size or position of the control changing.

   277  * Call Layout instead.

   278  */

   279 void CAknNoteControl::SizeChanged()

   280     {  

   281     DoLayout();

   282     }

   283 

   284 /** 

   285  * Code shared between SizeChanged() and Layout().

   286  *

   287  */

   288 void CAknNoteControl::DoLayout()

   289     {

   290     TextControl()->SetRect(LayoutRect());

   291     switch(iNoteLayout)

   292         {

   293     case EGeneralLayout:

   294         GeneralNoteLayout();

   295         if(iAttributes->iFlags.IsSet(ENoteAnimationStarted))

   296             {

   297             CancelAnimation();

   298             TRAP_IGNORE(StartAnimationL());

   299             }

   300         break;

   301     case EProgressLayout:

   302     case EWaitLayout:

   303         {

   304         ProgressNoteLayout();

   305         if(iAttributes->iFlags.IsSet(ENoteAnimationStarted))

   306             {

   307             iAttributes->CancelAnimation();

   308             TRAP_IGNORE(iAttributes->StartAnimationL());

   309             }

   310         break;

   311         }

   312     case ENoteWithImageLayout:

   313     case ETextualNotificationLayout:

   314     case ENotificationWithGraphicsLayout:

   315         ImageNoteLayout();

   316         break;

   317         }

   318 

   319     Attributes()->SetLayoutDone(CAknNoteAttributes::EControl);

   320 

   321     if ( iAttributes->iFlags.IsSet( ENoteLeftSKWhenTapped ) )

   322         {

   323         MTouchFeedback* feedback = MTouchFeedback::Instance();

   324         CFeedbackSpec* spec = CFeedbackSpec::New();

   325         if ( feedback && spec )

   326             {

   327             spec->AddFeedback( ETouchEventStylusDown, 

   328                                ETouchFeedbackBasicButton );

   329             spec->AddFeedback( ETouchEventStylusUp, 

   330                                ETouchFeedbackBasicButton,

   331                                ETouchFeedbackVibra );

   332             feedback->SetFeedbackArea( this, 0, Rect(), spec );

   333             delete spec;

   334             }

   335         }

   336     }

   337 

   338 /**

   339  *

   340  * This is used by a dialog to layout the control correctly.

   341  *

   342  */

   343 void CAknNoteControl::WindowLayout( TAknWindowLineLayout& aLayout ) const

   344     {

   345     TIndex laf(NumberOfLines());

   346     AknLayoutUtils::TAknCbaLocation cbaLocation( AknLayoutUtils::CbaLocation() );

   347     TInt variety( 0 );

   348     

   349     switch(iNoteLayout)

   350         {

   351         case ENoteWithImageLayout:

   352             if ( cbaLocation == AknLayoutUtils::EAknCbaLocationRight )

   353                 {

   354                 variety = 1;

   355                 }

   356             else if ( cbaLocation == AknLayoutUtils::EAknCbaLocationLeft )

   357                 {

   358                 variety = 2;

   359                 }

   360             else

   361                 {

   362                 variety = 0;

   363                 }

   364                         

   365             aLayout = AknLayoutScalable_Avkon::popup_note_image_window( variety );

   366             break;

   367         case ETextualNotificationLayout:

   368             if ( cbaLocation == AknLayoutUtils::EAknCbaLocationRight )

   369                 {

   370                 variety = 4;

   371                 }

   372             else if ( cbaLocation == AknLayoutUtils::EAknCbaLocationLeft )

   373                 {

   374                 variety = 8;

   375                 }

   376             else

   377                 {

   378                 variety = 0;

   379                 }

   380             

   381             aLayout = AknLayoutScalable_Avkon::popup_snote_single_text_window( variety +

   382                 (laf.Lines() >= 2 ? laf.Lines() - 1 : 0) );

   383             break;

   384         case ENotificationWithGraphicsLayout:

   385             if ( cbaLocation == AknLayoutUtils::EAknCbaLocationRight )

   386                 {

   387                 variety = 4;

   388                 }

   389             else if ( cbaLocation == AknLayoutUtils::EAknCbaLocationLeft )

   390                 {

   391                 variety = 8;

   392                 }

   393             else

   394                 {

   395                 variety = 0;

   396                 }

   397             

   398             aLayout = AknLayoutScalable_Avkon::popup_snote_single_graphic_window( variety +

   399                 (laf.Lines() >= 2 ? laf.Lines() - 1 : 0) );

   400             break;

   401         case EProgressLayout:

   402         case EWaitLayout:

   403             if ( cbaLocation == AknLayoutUtils::EAknCbaLocationRight )

   404                 {

   405                 variety = 3;

   406                 }

   407             else if ( cbaLocation == AknLayoutUtils::EAknCbaLocationLeft )

   408                 {

   409                 variety = 6;

   410                 }

   411             else

   412                 {

   413                 variety = 0;

   414                 }

   415             

   416             aLayout = AknLayoutScalable_Avkon::popup_note_wait_window( variety +

   417                 laf.PopupNoteWaitWindow() );

   418             break;

   419 

   420         case EGeneralLayout:

   421         default: //default case should never be the case

   422             if ( cbaLocation == AknLayoutUtils::EAknCbaLocationRight )

   423                 {

   424                 variety = 3;

   425                 }

   426             else if ( cbaLocation == AknLayoutUtils::EAknCbaLocationLeft )

   427                 {

   428                 variety = 6;

   429                 }

   430             else

   431                 {

   432                 variety = 0;

   433                 }

   434             

   435             aLayout = AknLayoutScalable_Avkon::popup_note_window( variety +

   436                 laf.PopupNoteWindow() );

   437             break;

   438         }

   439     }

   440 

   441 /**

   442  * Return the note height 

   443  *

   444  * The note height is taken from the layout compiler and

   445  * depends on number of lines and the note layout type. 

   446  * 

   447  * @return The note height in pixels.

   448  */

   449 EXPORT_C TInt CAknNoteControl::NoteHeight() const

   450     {

   451     TAknWindowLineLayout dialogLay;

   452     WindowLayout( dialogLay );

   453 

   454     TAknLayoutRect windowLayRect;

   455     windowLayRect.LayoutRect(iAvkonAppUi->ApplicationRect(), dialogLay);

   456     return windowLayRect.Rect().Height();

   457     }

   458 

   459 /**

   460  * Return the note width 

   461  *

   462  * The note width is taken from the layout compiler. 

   463  * Contrary to the note height, the note width does not depend on

   464  * from note layout type or on number of lines. 

   465  * 

   466  * @return The note width in pixels

   467  */

   468 EXPORT_C TInt CAknNoteControl::NoteWidth() const

   469     {

   470     TAknWindowLineLayout dialogLay;

   471     WindowLayout( dialogLay );

   472 

   473     TAknLayoutRect windowLayRect;

   474     windowLayRect.LayoutRect(iAvkonAppUi->ApplicationRect(), dialogLay);

   475     return windowLayRect.Rect().Width();

   476     }

   477 

   478 

   479 // ----------------------------------------

   480 //  LAYOUT METHODS

   481 // ----------------------------------------

   482 

   483 /**

   484  *  GENERAL NOTES LAYOUT

   485  */

   486 void CAknNoteControl::GeneralNoteLayout()

   487     {

   488     GeneralNoteLabelLayout();

   489     GeneralNoteIconLayout();

   490     }

   491 

   492 /**

   493  * Layout for text in general notes

   494  */

   495 void CAknNoteControl::GeneralNoteLabelLayout()

   496     {

   497     MAknsSkinInstance* skin = AknsUtils::SkinInstance();

   498     TRgb color;

   499     TInt error = AknsUtils::GetCachedColor( skin, color,

   500         KAknsIIDQsnTextColors, EAknsCIQsnTextColorsCG19 );

   501 

   502     for (TInt i=0; i < NumberOfLines(); i++)

   503         {

   504         AknLayoutUtils::LayoutLabel

   505          (TextControl()->Line(i),LayoutRect(),AKN_LAYOUT_TEXT_Note_pop_up_window_texts_Line_1(i));

   506 

   507         if (!error)

   508             {

   509             // Ignore error

   510             TRAP_IGNORE( AknLayoutUtils::OverrideControlColorL( *TextControl()->Line(i), 

   511                 EColorLabelText, color ) );

   512             }

   513         }

   514     }

   515 

   516 /**

   517  * Layout for image or animation in general notes

   518  */

   519 void CAknNoteControl::GeneralNoteIconLayout()

   520     {

   521     if (Image())

   522         AknLayoutUtils::LayoutImage(Image(), LayoutRect(), AKN_LAYOUT_WINDOW_Note_pop_up_window_elements_Line_1);

   523 

   524     if (Animation())

   525         AknLayoutUtils::LayoutControl(Animation(), LayoutRect(), AKN_LAYOUT_WINDOW_Note_pop_up_window_elements_Line_1);

   526     }

   527 

   528 

   529 

   530 /**

   531  *  PROGRESS NOTES LAYOUT

   532  */

   533 void CAknNoteControl::ProgressNoteLayout()

   534     {

   535     ProgressNoteLabelLayout();

   536     ProgressNoteProgressBarLayout();

   537     ProgressNoteIconLayout();

   538     ProgressNoteNumberTypeIndicationLayout();

   539     }

   540 

   541 /**

   542  * Layout for text in progress notes

   543  */

   544 void CAknNoteControl::ProgressNoteLabelLayout()

   545     {

   546     MAknsSkinInstance* skin = AknsUtils::SkinInstance();

   547     TRgb color;

   548     TInt error = AknsUtils::GetCachedColor( skin, color,

   549         KAknsIIDQsnTextColors, EAknsCIQsnTextColorsCG19 );

   550 

   551     TInt nLines = Min (KPNMaxNumLines, NumberOfLines());

   552     TIndex lafIndex(nLines,Icon()!=NULL);

   553 

   554     for (TInt i=0; i < nLines; i++)

   555         {

   556         AknLayoutUtils::LayoutLabel( TextControl()->Line(i),

   557             LayoutRect(),AKN_LAYOUT_TEXT_Wait_or_progress_note_pop_up_window_texts_Line_1

   558          (lafIndex.WNPWindowTextsLine1(i),i,i));

   559 

   560         if (!error)

   561           {

   562             // Ignore error

   563             TRAP_IGNORE( AknLayoutUtils::OverrideControlColorL( *TextControl()->Line(i), 

   564                 EColorLabelText, color ) );

   565             }

   566         }

   567     }

   568 

   569 /**

   570  * Layout for progress bar in progress notes

   571  */

   572 void CAknNoteControl::ProgressNoteProgressBarLayout()

   573     {

   574     TInt nLines = Min (KPNMaxNumLines, NumberOfLines());

   575 

   576     // New parameter added to Wait_or_progress_note_pop_up_window_elements_Line_2 layout API.

   577     TInt tIndex = 0;

   578     if (nLines == 3)

   579         {

   580         tIndex = 1;

   581         }

   582     if (nLines >= 4)

   583         {

   584         tIndex = 2;

   585         }

   586 

   587     if (ProgressBar())

   588         AknLayoutUtils::LayoutControl(ProgressBar(), LayoutRect(), AKN_LAYOUT_WINDOW_Wait_or_progress_note_pop_up_window_elements_Line_2(tIndex));

   589     

   590     if(Animation()) //Progress Bar Animation

   591         AknLayoutUtils::LayoutControl(Animation(), LayoutRect(), AKN_LAYOUT_WINDOW_Wait_or_progress_note_pop_up_window_elements_Line_2(tIndex));

   592     }

   593 

   594 /**

   595  * Layout for icon in progress notes

   596  */

   597 void CAknNoteControl::ProgressNoteIconLayout()

   598     {   

   599     if (Image())

   600         AknLayoutUtils::LayoutImage(Image(), LayoutRect(), AKN_LAYOUT_WINDOW_Wait_or_progress_note_pop_up_window_elements_Line_1);

   601     }

   602 

   603 /**

   604  * Layout for nti (number type indication) icon in progress notes

   605  */

   606 void CAknNoteControl::ProgressNoteNumberTypeIndicationLayout()

   607     {

   608     if (Icon())

   609         AknLayoutUtils::LayoutImage(Icon(), LayoutRect(), AKN_LAYOUT_WINDOW_Wait_or_progress_note_pop_up_window_elements_Line_4);

   610     }

   611 

   612 /**

   613  * IMAGE NOTES LAYOUT

   614  */

   615 void CAknNoteControl::ImageNoteLayout()

   616     {

   617     ImageNoteLabelLayout();

   618     if ( iNoteLayout != ENotificationWithGraphicsLayout &&

   619          iNoteLayout != ETextualNotificationLayout )

   620         {

   621         ImageNoteShadowLayout();

   622         }

   623     else if ( iAttributes )

   624         {

   625         iAttributes->iBgContext->SetCenter(KAknsIIDQsnFrPopupCenterSnote);

   626         }

   627     

   628     ImageNoteImageLayout();

   629     AnimationNoteLayout();

   630     ImageNoteNumberTypeIndicationLayout();

   631     }

   632 

   633 /**

   634  * Layout for text in image notes

   635  */

   636 void CAknNoteControl::ImageNoteLabelLayout()

   637     {

   638     

   639     TInt nLines = NumberOfLines();

   640 

   641     TSize imageSize = Image() ? Image()->Bitmap()->SizeInPixels() : 

   642         Animation() ? Animation()->BitmapAnimData()->Size() : TSize(0,0);

   643 

   644     MAknsSkinInstance* skin = AknsUtils::SkinInstance();

   645     TRgb color;

   646     TInt error = AknsUtils::GetCachedColor( skin, color,

   647         KAknsIIDQsnTextColors, EAknsCIQsnTextColorsCG19 );

   648 

   649     if ( iNoteLayout == ENoteWithImageLayout ) 

   650         {

   651         nLines = Min(KINMaxNumLines, nLines);

   652     

   653         TIndex lafIndex(nLines,Icon()!=NULL,imageSize);

   654         

   655         for (TInt i=0; i < nLines; i++)

   656             {

   657 

   658             AknLayoutUtils::LayoutLabel(TextControl()->Line(i),LayoutRect(),

   659                 AKN_LAYOUT_TEXT_Note_with_an_image_pop_up_window_texts_Line_1(

   660                 lafIndex.NWIPWindowTextsLine1L(i),lafIndex.NWIPWindowTextsLine1R(i),

   661                 lafIndex.NWIPWindowTextsLine1B(i),lafIndex.NWIPWindowTextsLine1W(i)));

   662 

   663             if (!error)

   664               {

   665                 // Ignore error

   666                 TRAP_IGNORE( AknLayoutUtils::OverrideControlColorL( 

   667                     *TextControl()->Line(i), 

   668                     EColorLabelText, color ) );

   669               }

   670             }

   671         }

   672     else // Soft Notification layouts

   673         {   

   674         for (TInt i=0; i < nLines; i++)

   675             {

   676             AknLayoutUtils::LayoutLabel(

   677                 TextControl()->Line(i),

   678                 LayoutRect(),

   679                 (!imageSize.iWidth)?

   680                 AKN_LAYOUT_TEXT_Notification_pop_up_window_texts__text__Line_1(i):

   681                 AKN_LAYOUT_TEXT_Notification_pop_up_window_texts__graphic__Line_1(i));

   682 

   683             if (!error)

   684               {

   685                 // Ignore error

   686                 TRAP_IGNORE( AknLayoutUtils::OverrideControlColorL( 

   687                     *TextControl()->Line(i), 

   688                     EColorLabelText, color ) );

   689               }

   690             }

   691 

   692         }

   693     }

   694 

   695 /**

   696  * Layout for animation in image notes

   697  */

   698 void CAknNoteControl::AnimationNoteLayout()

   699     {

   700     if (Animation())

   701         AknLayoutUtils::LayoutControl(Animation(), LayoutRect(), 

   702                 GetImageLayout(Animation()->BitmapAnimData()->Size()) );

   703     }

   704 

   705 

   706 /**

   707  * Layout for image in image notes

   708  */

   709 void CAknNoteControl::ImageNoteImageLayout()

   710     {

   711     if (Image())

   712         {

   713         AknLayoutUtils::LayoutImage(Image(), LayoutRect(), 

   714             GetImageLayout(Image()->Bitmap()->SizeInPixels()));

   715         }

   716     }

   717 

   718 /**

   719  * Layout for image shadow in image notes

   720  */

   721 void CAknNoteControl::ImageNoteShadowLayout()

   722     {

   723     if (Image())

   724         {

   725         iShadowRect.LayoutRect( LayoutRect(), 

   726             GetImageShadowLayout(Image()->Bitmap()->SizeInPixels()) );

   727         

   728         iImageHasShadow = ETrue;

   729         }

   730     }

   731 

   732 /**

   733  * Layout for number type indication in image notes

   734  */

   735 void CAknNoteControl::ImageNoteNumberTypeIndicationLayout()

   736     {

   737     if ( iNoteLayout == ETextualNotificationLayout || iNoteLayout == ENotificationWithGraphicsLayout )

   738         {

   739         return;

   740         }   

   741 

   742     if (Icon())

   743         {

   744         AknLayoutUtils::LayoutImage(Icon(), LayoutRect(), AKN_LAYOUT_WINDOW_Note_with_an_image_pop_up_window_elements_Line_13);

   745         }

   746     }

   747 

   748 /**

   749  * Return layout table to be used for images in image notes.

   750  * Table is different according to image size,

   751  *

   752  * Images with a size different from the supported sizes are laid out 

   753  * as if they were 44X48 images. If they are smaller their

   754  * size is used. If they are bigger the are cropped to 44X48 

   755  * (@see ReduceImageIfNeeded)

   756  */

   757 TAknWindowLineLayout CAknNoteControl::GetImageLayout(const TSize& /*aSize*/) 

   758     {

   759     // can go on with the biggest

   760     TAknWindowLineLayout lay (AKN_LAYOUT_WINDOW_Note_with_an_image_pop_up_window_elements_Line_12);

   761 

   762     if ( iNoteLayout == ENotificationWithGraphicsLayout )

   763         {

   764         lay = AKN_LAYOUT_WINDOW_Notification_pop_up_window_elements__graphic__Line_2;

   765         }

   766 

   767     return lay;

   768     }

   769 

   770 /**

   771  * Return layout table to be used for image shadows in image notes.

   772  * Table is different according to image size.

   773  *

   774  * Shadows for images with a size different than the supported sizes are laid 

   775  * out as if they were biggest supported images. If they are smaller their

   776  * size is used. If they are bigger the are cropped to the biggest supported size 

   777  * (@see ReduceImageIfNeeded)

   778  */

   779 TAknWindowLineLayout CAknNoteControl::GetImageShadowLayout(const TSize& /*aSize*/) 

   780     {

   781     // can go on with the biggest

   782     TAknWindowLineLayout lay (AKN_LAYOUT_WINDOW_Note_with_an_image_pop_up_window_elements_Line_11);

   783     return lay; 

   784     }

   785 

   786 

   787 /**

   788  * Do layout.

   789  *

   790  * Before doing layout parse the text (This might be redundant except

   791  * when the control attributs are trasfered but is left here to avoid

   792  * breaking the functionality of this exported method).

   793  *

   794  * Layout is done only if it is needed, i.e. if the attributes indicates

   795  * that something has changed in such a way that layout needs to be performed

   796  * again, e.g. a line of text has been added.

   797  *

   798  * This method assumes that the rect of the control has not been changed. On the

   799  * contrary, SizeChanged does not assume that the rect is the same and hence 

   800  * always performs layout.

   801  */

   802 EXPORT_C void CAknNoteControl::Layout()

   803     {

   804     TRAP_IGNORE(ParseTextL());

   805 

   806     if (!Attributes()->IsLayoutNeeded(CAknNoteAttributes::EControl))

   807         return;

   808 

   809     DoLayout();

   810 

   811     }

   812 

   813 /**

   814  * Return rectangle used in layout operations. 

   815  *

   816  * Layout information in LAF is relative to the size of the dialog and not to the

   817  * size of the internal area (dialog size - margins from UIKLAF). Therefore when

   818  * doing layout do not use Rect(), but LayoutRect() - which returns the size of the

   819  * dialog. Position is always (0,0) - top 

   820  *

   821  * @return Rectangle equal to dialog rectangle only shifted by the dialog margins

   822  */

   823 TRect CAknNoteControl::LayoutRect() const

   824     {   

   825     TAknLayoutRect layout;

   826     

   827     TAknWindowLineLayout window;

   828     WindowLayout( window );    

   829     

   830     TRect mainPane;

   831     AknLayoutUtils::LayoutMetricsRect( AknLayoutUtils::EPopupParent, mainPane );

   832     layout.LayoutRect( mainPane, window );

   833     TRect rect = layout.Rect().Size();

   834        

   835     if ( iNoteLayout == ENotificationWithGraphicsLayout ||

   836          iNoteLayout == ETextualNotificationLayout )

   837         {

   838         TAknLayoutRect layRect;

   839         TPoint topLeft = Position();

   840         layRect.LayoutRect(rect, AknLayoutScalable_Avkon::bg_popup_window_pane_cp9(0));

   841             

   842         topLeft.iX -= layRect.Rect().iTl.iX;

   843         topLeft.iY -= layRect.Rect().iTl.iY;

   844 

   845         TPoint bottomRight (topLeft);

   846         bottomRight.iY += rect.Height(); 

   847         bottomRight.iX += rect.Width();

   848 

   849         rect = TRect(topLeft,bottomRight);      

   850         }        

   851     return rect;

   852     }

   853 

   854 /**

   855  * Use layout information to determine line widths

   856  */

   857 void CAknNoteControl::SetLineWidthsL()

   858     {

   859     if (!iLineWidths)

   860         return;

   861 

   862     iLineWidths->Reset();

   863 

   864     TAknLayoutText text;

   865     switch(iNoteLayout)

   866         {

   867         case EGeneralLayout:

   868             {

   869             for (TInt i=0; i < KGNMaxNumLines; i++)

   870                 {

   871                 TAknTextLineLayout lay = AKN_LAYOUT_TEXT_Note_pop_up_window_texts_Line_1(i);

   872                 text.LayoutText(LayoutRect(), lay);

   873                 TInt width = text.TextRect().Width();

   874                 

   875                 iLineWidths->AppendL(width,1);

   876                 }

   877             }

   878             break;

   879         case EProgressLayout:

   880         case EWaitLayout:

   881             {

   882             TIndex lafIndex(KPNMaxNumLines,Icon()!=NULL);

   883             for (TInt i=0; i < KPNMaxNumLines; i++)

   884                 {

   885                 TAknTextLineLayout lay = AKN_LAYOUT_TEXT_Wait_or_progress_note_pop_up_window_texts_Line_1

   886                     (lafIndex.WNPWindowTextsLine1(i),i,i);

   887                 text.LayoutText(LayoutRect(), lay);

   888                 TInt width = text.TextRect().Width();

   889                 

   890                 iLineWidths->AppendL(width,1);

   891                 }

   892 

   893             }

   894             break;

   895         case ENoteWithImageLayout:

   896             {        

   897             TSize imageSize = Image() ? Image()->Bitmap()->SizeInPixels() : 

   898                 Animation() ? Animation()->BitmapAnimData()->Size() : TSize(0,0);

   899 

   900             TIndex lafIndex(KINMaxNumLines,Icon()!=NULL,imageSize);

   901         

   902             for (TInt i=0; i < KINMaxNumLines; i++)

   903                 {

   904                 TAknTextLineLayout lay = AKN_LAYOUT_TEXT_Note_with_an_image_pop_up_window_texts_Line_1(

   905                     lafIndex.NWIPWindowTextsLine1L(i),lafIndex.NWIPWindowTextsLine1R(i),

   906                     lafIndex.NWIPWindowTextsLine1B(i),lafIndex.NWIPWindowTextsLine1W(i));

   907                 text.LayoutText(LayoutRect(), lay);

   908                 TInt width = text.TextRect().Width();

   909             

   910                 iLineWidths->AppendL(width,1);

   911                 }

   912             }

   913             break;

   914         case ETextualNotificationLayout:

   915             {

   916             TAknTextLineLayout lay = AKN_LAYOUT_TEXT_Notification_pop_up_window_texts__text__Line_1(0);                

   917             for (TInt i=0; i < KGNMaxNumLines; i++)

   918                 {

   919                 text.LayoutText(LayoutRect(), lay);

   920                 TInt width = text.TextRect().Width();

   921                 iLineWidths->AppendL(width,1);

   922                 }

   923             }

   924             break;

   925 

   926         case ENotificationWithGraphicsLayout:

   927             {       

   928             for (TInt i=0; i < KGNMaxNumLines; i++)

   929                 {

   930                 TAknTextLineLayout lay = AKN_LAYOUT_TEXT_Notification_pop_up_window_texts__graphic__Line_1(i>=2?i-1:0);

   931                 text.LayoutText(LayoutRect(), lay);

   932                 TInt width = text.TextRect().Width();

   933                 iLineWidths->AppendL(width,1);

   934                 }

   935             }

   936             break;

   937         }

   938     }

   939 

   940 void CAknNoteControl::CreateDefaultImageL()

   941     {

   942 

   943     if (iNoteLayout == EWaitLayout || iNoteLayout == EProgressLayout) 

   944         {

   945         CEikImage* image = new(ELeave) CEikImage;

   946         CleanupStack::PushL(image);

   947         

   948         // Check if skinned image could be used

   949         MAknsSkinInstance* skin = AknsUtils::SkinInstance();

   950 

   951         CFbsBitmap* bitmap = NULL;

   952         CFbsBitmap* mask = NULL;

   953        

   954         AknsUtils::CreateIconL(

   955             skin, KAknsIIDQgnNoteProgress,

   956             bitmap, mask,

   957             KAvkonBitmapFile,

   958             EMbmAvkonQgn_note_progress, EMbmAvkonQgn_note_progress_mask);

   959 

   960         image->SetPicture(bitmap,mask);

   961 

   962         CleanupStack::Pop(); //image

   963         Attributes()->SetImageL(image);

   964         }

   965     }

   966 

   967 /**

   968  *

   969  * The CONST CAST is ok because the bitmap is owned by the image

   970  */

   971 void CAknNoteControl::ReduceImageIfNeeded()

   972     {

   973     if (Image())

   974         {

   975         // set the size of the image

   976         TAknLayoutRect rect;

   977         rect.LayoutRect( Rect(), 

   978             AKN_LAYOUT_WINDOW_Note_with_an_image_pop_up_window_elements_Line_12 );

   979         AknIconUtils::SetSize( CONST_CAST( CFbsBitmap*, Image()->Bitmap() ), 

   980             rect.Rect().Size() );

   981  

   982         // see if the bitmap size needs to be reduced

   983         TSize size = Image()->Bitmap()->SizeInPixels();

   984 

   985         TInt width = rect.Rect().Width();

   986         TInt height = rect.Rect().Height();

   987         if ( size.iWidth >= width || size.iHeight >= height )

   988             {//image does not fit

   989             TInt newWidth  = Min( size.iWidth,  width );

   990             TInt newHeight = Min( size.iHeight, height );

   991 

   992             if (Image()->Bitmap())

   993                 CONST_CAST(CFbsBitmap*,Image()->Bitmap())->Resize(TSize(newWidth,newHeight));

   994             

   995             if (Image()->Mask())

   996                 CONST_CAST(CFbsBitmap*,Image()->Mask())->Resize(TSize(newWidth,newHeight));

   997             }

   998         }

   999     }

  1000 

  1001 void CAknNoteControl::ParseTextL()

  1002     {

  1003     TAknLayoutText textRect;

  1004 

  1005     if ( iNoteLayout == ENotificationWithGraphicsLayout || iNoteLayout == ETextualNotificationLayout )

  1006         {

  1007         textRect.LayoutText(LayoutRect(), AKN_LAYOUT_TEXT_Notification_pop_up_window_texts__text__Line_1(1));

  1008         }

  1009     else 

  1010         {

  1011         textRect.LayoutText(LayoutRect(), AKN_LAYOUT_TEXT_Wait_or_progress_note_pop_up_window_texts_Line_1(1,1,1));

  1012         }  

  1013 

  1014     const CFont *font = textRect.Font();

  1015         

  1016     SetLineWidthsL(); // Make the division again to prevent errors when resolution has changed

  1017     Attributes()->ParseTextL( font, iLineWidths);

  1018     }

  1019 

  1020 

  1021 // -------------------------------------------

  1022 // EXPORTED API

  1023 // -------------------------------------------

  1024 

  1025 /**

  1026  * Set the note image 

  1027  *

  1028  * Set the image in the note attributes. This reduces the

  1029  * size of the image if necessary (only fixed set of

  1030  * image sizes if supported). Perform layout only for

  1031  * the control. The dialog will not be resized. 

  1032  * 

  1033  */

  1034 EXPORT_C void CAknNoteControl::SetImageL(CEikImage* aImage)

  1035     {

  1036     Attributes()->SetImageL(aImage);

  1037     Layout();

  1038     }

  1039 

  1040 /**

  1041  * Set the note animation 

  1042  *

  1043  * Set the animation in the note attributes.

  1044  * Perform layout only for the control. 

  1045  * The dialog will not be resized. 

  1046  * 

  1047  */

  1048 EXPORT_C void CAknNoteControl::SetAnimationL(TInt aResource)

  1049     {

  1050     Attributes()->SetAnimationL(aResource);

  1051     Layout();

  1052     }

  1053 

  1054 /**

  1055  * Set the note icon 

  1056  *

  1057  * Set the icon in the note attributes.

  1058  * Perform layout only for the control. 

  1059  * The dialog will not be resized. 

  1060  * 

  1061  */

  1062 EXPORT_C void CAknNoteControl::SetIconL(CEikImage* aIcon)

  1063     { 

  1064     Attributes()->SetIconL(aIcon);

  1065     Layout();

  1066     }

  1067 

  1068 /**

  1069  * Set the progress bar final value 

  1070  *

  1071  * Set the progress bar final value in the note attributes. 

  1072  * 

  1073  */

  1074 EXPORT_C void CAknNoteControl::SetFinalProgressValue(TInt aValue)

  1075     {

  1076     Attributes()->SetFinalProgressValue(aValue);

  1077     }

  1078 

  1079 /**

  1080  * Increment the progress bar and draw

  1081  * 

  1082  * @see CEikProgressInfo

  1083  */

  1084 EXPORT_C TInt CAknNoteControl::IncrementBarsAndDraw(TInt aIncrement)

  1085     {

  1086     return Attributes()->IncrementBarsAndDraw(aIncrement);

  1087     }

  1088 

  1089 /**

  1090  * Create the progress bar

  1091  *

  1092  * @see CEikProgressInfo

  1093  */

  1094 EXPORT_C void CAknNoteControl::CreateProgressBarL()

  1095     {

  1096     if ( ( iNoteLayout == EProgressLayout ) || ( iNoteLayout == EWaitLayout ) )

  1097         {

  1098         Attributes()->CreateProgressBarL();

  1099         }

  1100     else

  1101         {

  1102         User::Leave( KErrGeneral );

  1103         }

  1104     }

  1105 

  1106 /**

  1107  * Return the progress bar

  1108  *

  1109  * @return The progress bar

  1110  *

  1111  * @see CEikProgressInfo

  1112  */

  1113 

  1114 EXPORT_C CEikProgressInfo* CAknNoteControl::GetProgressInfo()

  1115     {

  1116     return ProgressBar();

  1117     }

  1118 

  1119 /**

  1120  * Start the note animation

  1121  *

  1122  * @see CAknBitmapAnimation

  1123  */

  1124 EXPORT_C void CAknNoteControl::StartAnimationL()

  1125     {

  1126     Attributes()->StartAnimationL();

  1127     }

  1128 

  1129 /**

  1130  * Stop the note animation

  1131  *

  1132  * @see CAknBitmapAnimation

  1133  */

  1134 EXPORT_C TInt CAknNoteControl::CancelAnimation()