1 /*

     2 * Copyright (c) 2002-2008 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:  Implementation for the default control in the

    15 *                status pane's title pane.

    16 *

    17 */

    18 

    19 

    20 // SYSTEM INCLUDE FILES

    21 #include <eikclbd.h>

    22 #include <eikfutil.h>

    23 #include <eikappui.h>

    24 #include <eikapp.h>

    25 #include <eikspane.h>

    26 #include <apgcli.h>

    27 #include <eiklabel.h>

    28 #include <eikimage.h>

    29 #include <gulalign.h>

    30 #include <avkon.rsg>

    31 #include <AknLayout.lag>

    32 #include <AknsDrawUtils.h>

    33 #include <AknBidiTextUtils.h>

    34 #include <PUAcodes.hrh>

    35 #include <AknPictographInterface.h>

    36 #include <AknPictographDrawerInterface.h>

    37 #include <aknlayoutscalable_avkon.cdl.h>

    38 #include <eikenv.h>

    39 #include <layoutmetadata.cdl.h>

    40 

    41 #include <AknTasHook.h>

    42 // USER INCLUDE FILES

    43 #include "aknappui.h"

    44 #include "AknUtils.h"

    45 #include "avkon.hrh"

    46 #include "AknPanic.h"

    47 #include "akntitle.h"

    48 #include "aknconsts.h"

    49 #include "AknStatuspaneUtils.h"

    50 #include "AknTitlePaneLabel.h"

    51 #include "AknTitlePaneObserver.h"

    52 #include "aknnavi.h"

    53 #include "aknnavide.h"

    54 

    55 // Titlepane flags

    56 enum TTitlePaneControlFlags

    57     {

    58     EAknTitlePaneButton1DownInTitleRect = 0x00000001

    59     };

    60 

    61 // Scrolling related constants

    62 const TInt KScrollPauseBeforeScroll     = 1000000; // 1.0s

    63 const TInt KScrollPauseBeforeFadeOut    = 2000000; // 2s

    64 const TInt KScrollPauseBeforeFadeIn     = 500000;  // 0.5s

    65 const TInt KScrollFadeInFadeOutDuration = 1000000; // 1s

    66 

    67 const TInt KTitleMaxLines = 2;

    68 

    69 NONSHARABLE_CLASS( CAknTitlePaneExtension )

    70     : public CBase,

    71       public MAknPictographAnimatorCallBack

    72     {

    73 public:

    74     static CAknTitlePaneExtension* NewL( CAknTitlePane& aOwner );

    75     ~CAknTitlePaneExtension();

    76 

    77 private: // From MAknPictographAnimatorCallBack

    78     void DrawPictographArea();

    79 

    80 private:

    81     CAknTitlePaneExtension( CAknTitlePane& aOwner );

    82     void ConstructL();

    83 

    84 public:

    85     CAknTitlePane&           iOwner;

    86     CEikImage*               iTitleImage;

    87     CAknPictographInterface* iPictoInterface;

    88 

    89     TInt                     iFlags;

    90 

    91     TBool                    iSmallImageShown;

    92     TBool                    iScrollEffectEnabled;

    93     TBool                    iScrollEffectNeeded;

    94     TInt                     iCurrentNumberOfTextLines;

    95     TInt                     iLimitedNumberOfTextLines;

    96 

    97     TBool                    iImageAutoscaling;

    98     TBool                    iSmallImageAutoscaling;

    99     };

   100 

   101 

   102 // ----------------------------------------------------------------------------

   103 // CAknTitlePaneExtension::NewL

   104 // Two-phased constructor.

   105 // ----------------------------------------------------------------------------

   106 //

   107 CAknTitlePaneExtension* CAknTitlePaneExtension::NewL( CAknTitlePane& aOwner )

   108     {

   109     CAknTitlePaneExtension* self =

   110         new( ELeave ) CAknTitlePaneExtension( aOwner );

   111 

   112     CleanupStack::PushL( self );

   113     self->ConstructL();

   114     CleanupStack::Pop( self );

   115 

   116     return self;

   117     }

   118 

   119 

   120 // ----------------------------------------------------------------------------

   121 // CAknTitlePaneExtension::~CAknTitlePaneExtension

   122 // Destructor.

   123 // ----------------------------------------------------------------------------

   124 //

   125 CAknTitlePaneExtension::~CAknTitlePaneExtension()

   126     {

   127     delete iTitleImage;

   128     delete iPictoInterface;

   129     }

   130 

   131 

   132 // ----------------------------------------------------------------------------

   133 // CAknTitlePaneExtension::CAknTitlePaneExtension

   134 // C++ constructor.

   135 // ----------------------------------------------------------------------------

   136 //

   137 CAknTitlePaneExtension::CAknTitlePaneExtension( CAknTitlePane& aOwner )

   138     : iOwner( aOwner )

   139     {

   140     }

   141 

   142 

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

   144 // CAknTitlePaneExtension::ConstructL

   145 // Second-phase constructor.

   146 // ----------------------------------------------------------------------------

   147 //

   148 void CAknTitlePaneExtension::ConstructL()

   149     {

   150     iTitleImage = new( ELeave ) CEikImage;

   151     iTitleImage->SetContainerWindowL( iOwner );

   152     iTitleImage->SetNonFocusing();

   153     iTitleImage->ActivateL();

   154 

   155     // Returns NULL if not supported.

   156     iPictoInterface = CAknPictographInterface::NewL( iOwner, *this );

   157     iScrollEffectEnabled = EFalse;

   158     }

   159 

   160 

   161 // ----------------------------------------------------------------------------

   162 // CAknTitlePaneExtension::DrawPictographArea

   163 // Draws the pictographs.

   164 // ----------------------------------------------------------------------------

   165 //

   166 void CAknTitlePaneExtension::DrawPictographArea()

   167     {

   168     iOwner.DrawDeferred();

   169     }

   170 

   171 

   172 // ----------------------------------------------------------------------------

   173 // CAknTitlePane::CAknTitlePane

   174 // Default constructor.

   175 // ----------------------------------------------------------------------------

   176 //

   177 EXPORT_C CAknTitlePane::CAknTitlePane()

   178     {

   179     AKNTASHOOK_ADD( this, "CAknTitlePane" );

   180     }

   181 

   182 

   183 // ----------------------------------------------------------------------------

   184 // CAknTitlePane::~CAknTitlePane

   185 // Destructor.

   186 // ----------------------------------------------------------------------------

   187 //

   188 EXPORT_C CAknTitlePane::~CAknTitlePane()

   189     {

   190     AKNTASHOOK_REMOVE();

   191     AknsUtils::DeregisterControlPosition( this );

   192 

   193     delete iTitleText;

   194     delete iDefaultTitleText;

   195     delete iTitleLabel;

   196     delete iExtension;

   197     }

   198 

   199 

   200 // ----------------------------------------------------------------------------

   201 // CAknTitlePane::ConstructL

   202 // Second-phase constructor.

   203 // ----------------------------------------------------------------------------

   204 //

   205 EXPORT_C void CAknTitlePane::ConstructL()

   206     {

   207     CommonConstructL();

   208     SetTextToDefaultL();

   209 

   210     if ( AknLayoutUtils::PenEnabled() )

   211         {

   212         // set flags to default values

   213         iExtension->iFlags = 0;

   214         }

   215     }

   216 

   217 

   218 // ----------------------------------------------------------------------------

   219 // CAknTitlePane::ConstructFromResourceL

   220 // Resource constructor.

   221 // ----------------------------------------------------------------------------

   222 //

   223 EXPORT_C void CAknTitlePane::ConstructFromResourceL( TResourceReader& aReader )

   224     {

   225     CommonConstructL();

   226     ReadFromResourceFileL( aReader );

   227     }

   228 

   229 

   230 // ----------------------------------------------------------------------------

   231 // CAknTitlePane::SetTextL

   232 // Sets the title pane text.

   233 // ----------------------------------------------------------------------------

   234 //

   235 EXPORT_C void CAknTitlePane::SetTextL( const TDesC& aText )

   236     {

   237     SetText( aText.AllocL(), EFalse );

   238     }

   239 

   240 

   241 

   242 // ----------------------------------------------------------------------------

   243 // CAknTitlePane::SetText

   244 // Sets the title pane text.

   245 // ----------------------------------------------------------------------------

   246 //

   247 EXPORT_C void CAknTitlePane::SetText( HBufC* aText )

   248     {

   249     SetText( aText, EFalse );

   250     }

   251 

   252 

   253 // ----------------------------------------------------------------------------

   254 // CAknTitlePane::SetSmallPicture

   255 // Sets the small title pane picture.

   256 // ----------------------------------------------------------------------------

   257 //

   258 EXPORT_C void CAknTitlePane::SetSmallPicture( const CFbsBitmap* aBitmap,

   259                                               const CFbsBitmap* aMaskBitmap,

   260                                               TBool aVisible )

   261     {

   262     if ( iExtension->iTitleImage )

   263         {

   264         // If NULL image is given, previous (existing) image is shown.

   265         if ( aBitmap )

   266             {

   267             iExtension->iTitleImage->SetPictureOwnedExternally( EFalse );

   268             iExtension->iTitleImage->SetPicture( aBitmap, aMaskBitmap );

   269 

   270             if ( iExtension->iTitleImage->Bitmap() &&

   271                  iExtension->iTitleImage->Bitmap()->SizeInPixels() == TSize( 0, 0 ) )

   272                 {

   273                 // Picture is scaled by title pane if the bitmap's

   274                 // size is not set.

   275                 iExtension->iSmallImageAutoscaling = ETrue;

   276                 }

   277             else

   278                 {

   279                 iExtension->iSmallImageAutoscaling = EFalse;

   280                 }

   281             }

   282 

   283         if ( aVisible )

   284             {

   285             iExtension->iSmallImageShown = ETrue;

   286             iImageShown = EFalse;

   287             }

   288         else

   289             {

   290             iExtension->iSmallImageShown = EFalse;

   291             iImageShown = EFalse;

   292             }

   293 

   294         SizeChanged();

   295         DrawDeferred();

   296         }

   297     }

   298 

   299 

   300 // ----------------------------------------------------------------------------

   301 // CAknTitlePane::SetPicture

   302 // Sets the large title pane picture (operator logo).

   303 // ----------------------------------------------------------------------------

   304 //

   305 EXPORT_C void CAknTitlePane::SetPicture( const CFbsBitmap* aBitmap,

   306                                          const CFbsBitmap* aMaskBitmap )

   307     {

   308     if ( iExtension && iExtension->iTitleImage )

   309         {

   310         // If NULL image is given, previous (existing) image is shown.

   311         if ( aBitmap )

   312             {

   313             iExtension->iTitleImage->SetPictureOwnedExternally( EFalse );

   314             iExtension->iTitleImage->SetPicture( aBitmap, aMaskBitmap );

   315 

   316             if ( iExtension->iTitleImage->Bitmap() &&

   317                  iExtension->iTitleImage->Bitmap()->SizeInPixels() == TSize( 0, 0 ) )

   318                 {

   319                 // Picture is scaled by title pane if the bitmap's

   320                 // size is not set.

   321                 iExtension->iImageAutoscaling = ETrue;

   322                 }

   323             else

   324                 {

   325                 iExtension->iImageAutoscaling = EFalse;

   326                 }

   327             }

   328 

   329         iImageShown = ETrue;

   330         iExtension->iSmallImageShown = EFalse;

   331         SizeChanged();

   332         DrawDeferred();

   333         }

   334     }

   335 

   336 

   337 // ----------------------------------------------------------------------------

   338 // CAknTitlePane::SetSmallPictureFromFileL

   339 // Sets the small title pane picture from a file.

   340 // Used by the resource constructor.

   341 // ----------------------------------------------------------------------------

   342 //

   343 void CAknTitlePane::SetSmallPictureFromFileL( const TDesC& aFileName,

   344                                               TInt aMainId,

   345                                               TInt aMaskId )

   346     {

   347     if ( iExtension && iExtension->iTitleImage )

   348         {

   349         CEikImage*& img = iExtension->iTitleImage;

   350         delete img;

   351         img = NULL;

   352 

   353         img = new (ELeave) CEikImage;

   354         img->CreatePictureFromFileL( aFileName, aMainId, aMaskId );

   355 

   356         iImageShown = EFalse;

   357         iExtension->iSmallImageShown = ETrue;

   358 

   359         iExtension->iTitleImage->SetPictureOwnedExternally( EFalse );

   360 

   361         if ( iExtension->iTitleImage->Bitmap() &&

   362              iExtension->iTitleImage->Bitmap()->SizeInPixels() == TSize( 0, 0 ) )

   363                 {

   364                 // Picture is scaled by title pane if the bitmap's

   365                 // size is not set.

   366                 iExtension->iSmallImageAutoscaling = ETrue;

   367                 }

   368             else

   369                 {

   370                 iExtension->iSmallImageAutoscaling = EFalse;

   371                 }

   372 

   373         SizeChanged();

   374         DrawDeferred();

   375         }

   376     }

   377 

   378 

   379 // ----------------------------------------------------------------------------

   380 // CAknTitlePane::SetPictureFromFileL

   381 // Sets the large title pane picture (operator logo) from a file.

   382 // ----------------------------------------------------------------------------

   383 //

   384 EXPORT_C void CAknTitlePane::SetPictureFromFileL( const TDesC& aFileName,

   385                                                   TInt aMainId,

   386                                                   TInt aMaskId )

   387     {

   388     CEikImage*& img = iExtension->iTitleImage;

   389 

   390     delete img;

   391     img = NULL;

   392 

   393     img = new (ELeave) CEikImage;

   394     img->SetContainerWindowL( *this );

   395     img->SetNonFocusing();

   396     img->ActivateL();

   397     img->CreatePictureFromFileL( aFileName, aMainId, aMaskId );

   398 

   399     iImageShown = ETrue;

   400     iExtension->iSmallImageShown = EFalse;

   401 

   402     if ( iExtension->iTitleImage &&

   403          iExtension->iTitleImage->Bitmap() &&

   404          iExtension->iTitleImage->Bitmap()->SizeInPixels() == TSize( 0, 0 ) )

   405         {

   406         iExtension->iImageAutoscaling = ETrue;

   407         }

   408     else

   409         {

   410         iExtension->iImageAutoscaling = EFalse;

   411         }

   412 

   413     SizeChanged();

   414     DrawDeferred();

   415     }

   416 

   417 

   418 // ----------------------------------------------------------------------------

   419 // CAknTitlePane::SetFromResourceL

   420 // Sets the title pane content from a resource.

   421 // ----------------------------------------------------------------------------

   422 //

   423 EXPORT_C void CAknTitlePane::SetFromResourceL( TResourceReader& aReader )

   424     {

   425     if ( !iTitleLabel && !iExtension ) // not constructed yet

   426         {

   427         ConstructFromResourceL( aReader );

   428         }

   429     else // update from resource

   430         {

   431         ReadFromResourceFileL(aReader);

   432         }

   433     }

   434 

   435 

   436 // ----------------------------------------------------------------------------

   437 // CAknTitlePane::SetTextToDefaultL

   438 // Sets the title pane text to default (application name).

   439 // ----------------------------------------------------------------------------

   440 //

   441 EXPORT_C void CAknTitlePane::SetTextToDefaultL()

   442     {

   443     iExtension->iScrollEffectEnabled = EFalse;

   444 

   445     if ( iDefaultTitleText )

   446         {

   447         SetTextL( *iDefaultTitleText );

   448         return;

   449         }

   450 

   451     TBool textSet = EFalse;

   452     RApaLsSession lsSession;

   453     TInt ret = lsSession.Connect();

   454     if ( ret == KErrNone )

   455         {

   456         CleanupClosePushL( lsSession );

   457         TApaAppInfo appInfo;

   458         ret = lsSession.GetAppInfo( appInfo, AppUid() );

   459         if ( ret == KErrNone )

   460             {

   461             iDefaultTitleText = appInfo.iCaption.AllocL();

   462             SetTextL( *iDefaultTitleText );

   463             textSet = ETrue;

   464             }

   465         CleanupStack::PopAndDestroy( &lsSession);

   466         }

   467 

   468     if ( !textSet )

   469         {

   470         SetTextL( KTitlePaneDefaultText );

   471         }

   472     }

   473 

   474 

   475 // ----------------------------------------------------------------------------

   476 // CAknTitlePane::PrepareContext

   477 // Updates the text color for the window context from skin.

   478 // ----------------------------------------------------------------------------

   479 //

   480 EXPORT_C void CAknTitlePane::PrepareContext( CWindowGc& aGc ) const

   481     {

   482     if ( !iImageShown )

   483         {

   484         TRgb color;

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

   486         TInt error = AknsUtils::GetCachedColor( skin,

   487                                                 color,

   488                                                 KAknsIIDQsnTextColors,

   489                                                 EAknsCIQsnTextColorsCG1 );

   490         if ( !error )

   491             {

   492             aGc.SetPenColor( color );

   493             }

   494         }

   495     }

   496 

   497 

   498 // ----------------------------------------------------------------------------

   499 // CAknTitlePane::SizeChanged

   500 // Handles size change events.

   501 // ----------------------------------------------------------------------------

   502 //

   503 EXPORT_C void CAknTitlePane::SizeChanged()

   504     {

   505     // No fading if staconpane is active, because status pane

   506     // and control pane are combined.

   507     SetContainerWindowNonFading( AknStatuspaneUtils::StaconPaneActive() );

   508 

   509     // If fonts are destroyed with ENV destruction sequence, then abort.

   510     // TBD is a way to detect it right, we use this hack instead for now.

   511     if ( !( iEikonEnv->Alert() ) )

   512         {

   513         return;

   514         }

   515 

   516     TInt spLayout( AknStatuspaneUtils::CurrentStatusPaneLayoutResId() );

   517     

   518     if ( AknStatuspaneUtils::StaconPaneActive() )

   519         {

   520         SizeChangedInStaconPane();

   521         }

   522     else if ( AknStatuspaneUtils::FlatLayoutActive() )

   523         {

   524         SizeChangedInFlatStatusPane();

   525         }

   526     else if ( AknStatuspaneUtils::ExtendedLayoutActive() ||

   527               spLayout == R_AVKON_STATUS_PANE_LAYOUT_VT ||

   528               spLayout == R_AVKON_STATUS_PANE_LAYOUT_VT_MIRRORED )

   529         {

   530         // Use the extended title pane layout also for

   531         // the video telephony status pane layout, since

   532         // two-row title text is no longer supported.

   533         SizeChangedInExtendedStatusPane();

   534         }

   535     else

   536         {

   537         SizeChangedInNormalStatusPane();

   538         }

   539         

   540     // Update also the navi pane size, because in flat status pane layout

   541     // it draws part of the title pane if narrow navi pane

   542     // layout is in use.

   543     CEikStatusPaneBase* statusPane = CEikStatusPaneBase::Current();

   544     if ( statusPane )

   545         {

   546         CCoeControl* naviPane = NULL;

   547         

   548         TRAP_IGNORE(

   549             naviPane = statusPane->ContainerControlL(

   550                 TUid::Uid( EEikStatusPaneUidNavi ) ) );

   551         

   552         if ( naviPane )

   553             {

   554             naviPane->DrawDeferred();

   555             }

   556         }

   557     }

   558 

   559 

   560 // ----------------------------------------------------------------------------

   561 // CAknTitlePane::PositionChanged

   562 // Handles position change events.

   563 // ----------------------------------------------------------------------------

   564 //

   565 EXPORT_C void CAknTitlePane::PositionChanged()

   566     {

   567     AknsUtils::RegisterControlPosition( this );

   568     }

   569 

   570 

   571 // ----------------------------------------------------------------------------

   572 // CAknTitlePane::HandleResourceChange

   573 // Handles resource change events.

   574 // ----------------------------------------------------------------------------

   575 //

   576 EXPORT_C void CAknTitlePane::HandleResourceChange( TInt aType )

   577     {

   578     CCoeControl::HandleResourceChange( aType );

   579 

   580     if ( aType == KEikDynamicLayoutVariantSwitch ||

   581          aType == KEikColorResourceChange ||

   582          aType == KAknsMessageSkinChange )

   583         {

   584         SizeChanged();

   585         DrawDeferred();

   586         }

   587     }

   588 

   589 

   590 // ----------------------------------------------------------------------------

   591 // CAknTitlePane::CountComponentControls

   592 // Returns the amount of component controls.

   593 // ----------------------------------------------------------------------------

   594 //

   595 EXPORT_C TInt CAknTitlePane::CountComponentControls() const

   596     {

   597     TInt controls( 0 );

   598 

   599     if ( ( AknStatuspaneUtils::StaconPaneActive() ||

   600            AknStatuspaneUtils::FlatLayoutActive() ||

   601            AknStatuspaneUtils::ExtendedLayoutActive()) &&

   602            !iImageShown )

   603         {

   604         // Both small image and text can be show simultaneusly

   605         if ( iTitleLabel )

   606             {

   607             controls++;

   608             }

   609 

   610         if ( iExtension->iSmallImageShown &&

   611              iExtension->iTitleImage )

   612             {

   613             controls++;

   614             }

   615         }

   616     else

   617         {

   618         // Only image or text can be shown simultaneusly

   619         if ( ( iImageShown &&

   620                iExtension->iTitleImage ) ||

   621              ( !iImageShown && iTitleLabel ) )

   622             {

   623             controls++;

   624             }

   625         }

   626 

   627     return controls;

   628     }

   629 

   630 

   631 // ----------------------------------------------------------------------------

   632 // CAknTitlePane::ComponentControl

   633 // Gets a component control by a control index.

   634 // ----------------------------------------------------------------------------

   635 //

   636 EXPORT_C CCoeControl* CAknTitlePane::ComponentControl( TInt aIndex ) const

   637     {

   638     CCoeControl* componentControl = NULL;

   639 

   640     if ( ( AknStatuspaneUtils::StaconPaneActive() ||

   641            AknStatuspaneUtils::FlatLayoutActive() ||

   642            AknStatuspaneUtils::ExtendedLayoutActive() ) &&

   643          !iImageShown )

   644         {

   645         // Both image and text can be show simultaneusly

   646         if ( aIndex == 0 && iExtension->iSmallImageShown )

   647             {

   648             componentControl = iExtension->iTitleImage;

   649             }

   650         else

   651             {

   652             componentControl = iTitleLabel;

   653             }

   654         }

   655     else

   656         {

   657         // Only image or text can be shown simultaneusly

   658         if ( iImageShown )

   659             {

   660             componentControl = iExtension->iTitleImage;

   661             }

   662         else

   663             {

   664             componentControl = iTitleLabel;

   665             }

   666         }

   667 

   668     return componentControl;

   669     }

   670 

   671 

   672 // ----------------------------------------------------------------------------

   673 // CAknTitlePane::Draw

   674 // Draws the title pane.

   675 // ----------------------------------------------------------------------------

   676 //

   677 EXPORT_C void CAknTitlePane::Draw( const TRect& aRect ) const

   678     {

   679     const TUid KActiveIdle2Uid = {0x102750F0};

   680 

   681     if ( AppUid() == KActiveIdle2Uid )

   682         {

   683         CWindowGc& gc = SystemGc();

   684         TRgb rgb(TRgb::Color16MA(0));

   685         gc.SetDrawMode(CGraphicsContext::EDrawModeWriteAlpha);

   686         gc.SetBrushStyle(CGraphicsContext::ESolidBrush);

   687         gc.SetBrushColor(rgb);

   688         gc.Clear( aRect );

   689         return;

   690         }

   691 

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

   693 

   694     TRect rect( Rect() );

   695 

   696     CWindowGc& gc=SystemGc();

   697 

   698     if ( AknStatuspaneUtils::StaconPaneActive() ||

   699          AknStatuspaneUtils::FlatLayoutActive() )

   700         {

   701         MAknsControlContext* cc = AknsDrawUtils::ControlContext( this );

   702 

   703         if( !AknsDrawUtils::Background( skin, cc, this, gc, rect ) )

   704             {

   705             gc.SetPenStyle( CGraphicsContext::ENullPen );

   706             gc.SetBrushStyle( CGraphicsContext::ESolidBrush );

   707             gc.SetBrushColor(

   708                 AKN_LAF_COLOR( KStatusPaneBackgroundGraphicsColorUsual ) );

   709             gc.DrawRect( rect );

   710             }

   711         }

   712     else

   713         {

   714         gc.SetBrushStyle( CGraphicsContext::ESolidBrush );

   715         gc.SetBrushColor( AKN_LAF_COLOR( KStatusPaneBackgroundColor ) );

   716         AknsDrawUtils::Background( skin,

   717                                    AknsDrawUtils::ControlContext( this ),

   718                                    this,

   719                                    gc,

   720                                    rect );

   721         }

   722     }

   723 

   724 

   725 // ----------------------------------------------------------------------------

   726 // CAknTitlePane::CommonConstructL

   727 // Common second-phase constructor for normal and resource construction.

   728 // ----------------------------------------------------------------------------

   729 //

   730 void CAknTitlePane::CommonConstructL()

   731     {

   732     iTitleLabel = new (ELeave) CAknTitlePaneLabel;

   733     // we do logical to visual conversion ourselves while wrapping text

   734     iTitleLabel->UseLogicalToVisualConversion( EFalse );

   735 

   736     iExtension = CAknTitlePaneExtension::NewL( *this );

   737 

   738     if ( iExtension->iPictoInterface )

   739         {

   740         iTitleLabel->SetPictographInterface( *iExtension->iPictoInterface );

   741         }

   742 

   743     iTitleLabel->SetContainerWindowL( *this );

   744     iTitleLabel->SetNonFocusing();

   745     iTitleLabel->ActivateL();

   746 

   747     // Observer is needed with pensupport

   748     iTitlePaneObserver = NULL;

   749 

   750     SetControlContext( this );

   751     }

   752 

   753 

   754 // ----------------------------------------------------------------------------

   755 // CAknTitlePane::AppUid

   756 // Gets the application UID.

   757 // ----------------------------------------------------------------------------

   758 //

   759 TUid CAknTitlePane::AppUid() const

   760     {

   761     CEikApplication* app = iEikonEnv->EikAppUi()->Application();

   762     if ( app )

   763         {

   764         return app->AppDllUid();

   765         }

   766     else

   767         {

   768         return KNullUid;

   769         }

   770     }

   771 

   772 

   773 NONSHARABLE_CLASS( CTextLayoutManager ) : public CBase

   774     {

   775 public:

   776     enum TLayout

   777         {

   778         ENoLayout,

   779         EOneLineLayout,

   780         ETwoLineLayout

   781         };

   782 

   783 public:

   784     CTextLayoutManager( const TInt aOneLineLayoutWidth,

   785                         const TInt aTwoLineLayoutWidth,

   786                         const CFont* aOneLineFont,

   787                         const CFont* aTwoLineFont )

   788       : iOneLineWidth( aOneLineLayoutWidth ),

   789         iTwoLineWidth( aTwoLineLayoutWidth ),

   790         iOneLineFont( aOneLineFont ),

   791         iTwoLineFont( aTwoLineFont )

   792         {}

   793 

   794     static CTextLayoutManager* NewLC( const TInt aOneLineLayoutWidth,

   795                                       const TInt aTwoLineLayoutWidth,

   796                                       const CFont* aOneLineFont,

   797                                       const CFont* aTwoLineFont );

   798     void ConstructL();

   799     ~CTextLayoutManager();

   800 

   801     void Reset();

   802     void DoLayoutL( TInt aLineNum, const TDesC& aText );

   803     const TLayout& Layout() const;

   804 

   805     TInt Lines() const;

   806     const TDesC& Text() const;

   807 

   808 private:

   809     TInt                  iOneLineWidth;

   810     TInt                  iTwoLineWidth;

   811     const CFont*          iOneLineFont; // not owned

   812     const CFont*          iTwoLineFont; // not owned

   813 

   814     CArrayFixFlat<TInt>*  iLineWidthArray;

   815     HBufC*                iText;

   816     TLayout               iLayout;

   817 

   818     };

   819 

   820 

   821 CTextLayoutManager* CTextLayoutManager::NewLC( const TInt aOneLineLayoutWidth,

   822                                                const TInt aTwoLineLayoutWidth,

   823                                                const CFont* aOneLineFont,

   824                                                const CFont* aTwoLineFont )

   825     {

   826     CTextLayoutManager* self = new (ELeave) CTextLayoutManager(

   827         aOneLineLayoutWidth, aTwoLineLayoutWidth, aOneLineFont, aTwoLineFont );

   828     CleanupStack::PushL( self );

   829 

   830     self->ConstructL();

   831     return self;

   832     }

   833 

   834 

   835 void CTextLayoutManager::ConstructL()

   836     {

   837     iLineWidthArray = new (ELeave) CArrayFixFlat<TInt>( KTitleMaxLines );

   838     }

   839 

   840 

   841 CTextLayoutManager::~CTextLayoutManager()

   842     {

   843     if ( iLineWidthArray )

   844         {

   845         iLineWidthArray->Reset();

   846         }

   847 

   848     delete iLineWidthArray;

   849     delete iText;

   850     }

   851 

   852 

   853 void CTextLayoutManager::Reset()

   854     {

   855     delete iText;

   856     iText = NULL;

   857 

   858     if ( iLineWidthArray )

   859         {

   860         iLineWidthArray->Reset();

   861         }

   862     iLayout = ENoLayout;

   863     }

   864 

   865 

   866 void CTextLayoutManager::DoLayoutL( TInt aLineNum, const TDesC& aText )

   867     {

   868     __ASSERT_DEBUG( aLineNum == 1 || aLineNum == 2,

   869                     Panic( EAknPanicNotSupported ) );

   870 

   871     __ASSERT_DEBUG( iLineWidthArray->Count() == 0,

   872                     Panic( EAknPanicSelfCheckFailure ) );

   873 

   874     const CFont* font = NULL;

   875 

   876     if ( aLineNum == 1 )

   877         {

   878         iLineWidthArray->AppendL( iOneLineWidth );

   879         if ( iTwoLineWidth )

   880             {

   881             // Added only if there exists 2nd line.

   882             iLineWidthArray->AppendL( iTwoLineWidth );

   883             }

   884         font    = iOneLineFont;

   885         iLayout = EOneLineLayout;

   886         }

   887     else

   888         {

   889         iLineWidthArray->AppendL( iOneLineWidth );

   890         if ( iTwoLineWidth )

   891             {

   892             // Added only if there exists 2nd line.

   893             iLineWidthArray->AppendL( iTwoLineWidth );

   894             }

   895         font    = iTwoLineFont;

   896         iLayout = ETwoLineLayout;

   897         }

   898 

   899     __ASSERT_DEBUG( iText == NULL, Panic( EAknPanicNullPointer ) );

   900 

   901     if ( !iText )

   902         {

   903         // +1 is for line ends

   904         iText = HBufC::NewL(

   905             aText.Length() + KTitleMaxLines * (KAknBidiExtraSpacePerLine + 1) );

   906         }

   907 

   908     TPtr ptr = iText->Des();

   909     AknBidiTextUtils::ConvertToVisualAndWrapToStringL(

   910         aText, *iLineWidthArray, *font, ptr, ETrue );

   911 

   912     }

   913 

   914 

   915 /**

   916  * Return type of layout set in DoLayout operation, either one line

   917  * layout or two line layout.

   918  */

   919 const CTextLayoutManager::TLayout& CTextLayoutManager::Layout() const

   920     {

   921     return iLayout;

   922     }

   923 

   924 

   925 /**

   926  * Return number of lines by locating \n chars

   927  * in the text. These have been inserted by wrapping

   928  * algorithm.

   929  */

   930 TInt CTextLayoutManager::Lines() const

   931     {

   932     __ASSERT_DEBUG( iText, Panic( EAknPanicNullPointer ) );

   933     TInt nLines = 0;

   934     TInt pos = iText->Length();

   935 

   936     do

   937         {

   938         TPtrC ptrC( iText->Left( pos ) );

   939         pos = ptrC.LocateReverseF( '\n' );

   940         }

   941     while ( pos >= 0 && ++nLines );

   942     return nLines;

   943     }

   944 

   945 

   946 const TDesC& CTextLayoutManager::Text() const

   947     {

   948     __ASSERT_DEBUG( iText, Panic( EAknPanicNullPointer ) );

   949     return *iText;

   950     }

   951 

   952 

   953 // ----------------------------------------------------------------------------

   954 // CAknTitlePane::FormatTitlePaneLabelL

   955 // Formats the title pane text.

   956 // ----------------------------------------------------------------------------

   957 //

   958 TInt CAknTitlePane::FormatTitlePaneLabelL( const TInt aOneLineLayoutWidth,

   959                                            const TInt aTwoLineLayoutWidth,

   960                                            const CFont* aOneLineFont,

   961                                            const CFont* aTwoLineFont )

   962     {

   963     if ( !iTitleLabel )

   964         {

   965         return 0;

   966         }

   967 

   968     if ( Rect().Width() < 1 )

   969         {

   970         iTitleLabel->SetTextL( *iTitleText );

   971         return 0;

   972         }

   973 

   974     TPtr ptr( iTitleText->Des() );

   975     TBuf<1> stripCharacters;

   976     stripCharacters.Append( KPuaCodeLineFeedSymbol );

   977     AknTextUtils::StripCharacters( ptr, stripCharacters );

   978 

   979     // Check if 2nd line usage has been limited

   980     TInt oneLineLayoutWidth = aOneLineLayoutWidth;

   981     TInt twoLineLayoutWidth = aTwoLineLayoutWidth;

   982     if ( iExtension && iExtension->iLimitedNumberOfTextLines > 0 &&

   983          iExtension->iLimitedNumberOfTextLines < MaxNumberOfVisibleTextRows() )

   984         {

   985         twoLineLayoutWidth = 0;

   986         }

   987 

   988     // We remove control chars here if one line layout is in use,

   989     // but we don't touch the original text because if we go to

   990     // 2-line layout we would not have the line feeds anymore

   991     // that some text may contain.

   992     HBufC* titleText = iTitleText->AllocLC();

   993 

   994     if ( twoLineLayoutWidth == 0 )

   995         {

   996         iTitleLabel->ReplaceControlCharacters( titleText, ETrue );

   997         }

   998     else

   999         {

  1000         iTitleLabel->ReplaceControlCharacters( titleText, EFalse );

  1001         }

  1002 

  1003     CTextLayoutManager* layoutMgr = CTextLayoutManager::NewLC(

  1004         oneLineLayoutWidth, twoLineLayoutWidth, aOneLineFont, aTwoLineFont );

  1005 

  1006     layoutMgr->DoLayoutL( 1, *titleText );

  1007     if ( layoutMgr->Lines() > 1 )

  1008         {

  1009         layoutMgr->Reset();

  1010         layoutMgr->DoLayoutL( 2, *titleText );

  1011         }

  1012 

  1013     const CTextLayoutManager::TLayout& layout( layoutMgr->Layout() );

  1014 

  1015     TInt lines =

  1016         layout == CTextLayoutManager::ETwoLineLayout ? 2 : layoutMgr->Lines();

  1017 

  1018     iTitleLabel->SetTextL( layoutMgr->Text() );

  1019 

  1020     TBool truncated = iTitleLabel->Text()->Locate( KEllipsis ) != KErrNotFound;

  1021 

  1022     if ( iExtension )

  1023         {

  1024         iExtension->iCurrentNumberOfTextLines = lines;

  1025         }

  1026 

  1027     if ( iExtension )

  1028         {

  1029         iExtension->iScrollEffectNeeded = truncated;

  1030         }

  1031 

  1032     CleanupStack::PopAndDestroy( 2, titleText ); // titleText, layoutMgr

  1033     return lines;

  1034     }

  1035 

  1036 

  1037 // ----------------------------------------------------------------------------

  1038 // CAknTitlePane::ReadFromResourceFileL

  1039 // Updates title pane content from a resource file.

  1040 // ----------------------------------------------------------------------------

  1041 //

  1042 void CAknTitlePane::ReadFromResourceFileL( TResourceReader& aReader )

  1043     {

  1044     if ( iTitleLabel )

  1045         {

  1046         iTitleLabel->InvalidateText();

  1047         }

  1048 

  1049     delete iTitleText;

  1050     iTitleText = NULL;

  1051     iTitleText = aReader.ReadHBufCL();

  1052 

  1053     HBufC* bitmapFile = aReader.ReadHBufCL(); // bmp filename

  1054     TInt bitmapId     = aReader.ReadInt16();  // bmp id

  1055     TInt maskId       = aReader.ReadInt16();  // bmp mask id

  1056 

  1057     if ( !iTitleText )

  1058         {

  1059         if ( bitmapFile )

  1060             {

  1061             CleanupStack::PushL( bitmapFile );

  1062             if ( bitmapId != KErrNotFound )

  1063                 {

  1064                 SetPictureFromFileL( *bitmapFile, bitmapId, maskId );

  1065                 }

  1066             else

  1067                 {

  1068                 SetTextToDefaultL();

  1069                 }

  1070             CleanupStack::PopAndDestroy( bitmapFile );

  1071             }

  1072         else

  1073             {

  1074             SetTextToDefaultL();

  1075             }

  1076         }

  1077     else

  1078         {

  1079         if ( bitmapFile )

  1080             {

  1081             CleanupStack::PushL( bitmapFile );

  1082             if ( bitmapId != KErrNotFound )

  1083                 {

  1084                 SetSmallPictureFromFileL( *bitmapFile, bitmapId, maskId );

  1085                 }

  1086             else

  1087                 {

  1088                 SetTextToDefaultL();

  1089                 }

  1090             CleanupStack::PopAndDestroy( bitmapFile );

  1091             }

  1092 

  1093         iImageShown = EFalse;

  1094         SizeChanged();

  1095         DrawDeferred();

  1096         }

  1097     }

  1098 

  1099 

  1100 // ----------------------------------------------------------------------------

  1101 // CAknTitlePane::SizeChangedInNormalStatusPane

  1102 // Handles size change events in normal status pane layout.

  1103 // ----------------------------------------------------------------------------

  1104 //

  1105 void CAknTitlePane::SizeChangedInNormalStatusPane()

  1106     {

  1107     AknsUtils::RegisterControlPosition( this );

  1108 

  1109     TRect rect( Rect() );

  1110 

  1111     if ( iTitleLabel && !iImageShown )

  1112         {

  1113         __ASSERT_DEBUG( iTitleText, Panic( EAknPanicNullPointer ) );

  1114 

  1115         TInt indexW( 0 );

  1116         if ( AknStatuspaneUtils::IdleLayoutActive() )

  1117             {   // Is battery pane visible in current layout

  1118             indexW = 1;

  1119             }

  1120 

  1121         TAknTextLineLayout oneLineLayout(

  1122             AknLayoutScalable_Avkon::title_pane_t1( 0 ).LayoutLine() );

  1123 

  1124         const TAknMultiLineTextLayout twoLineLayout(

  1125             AKN_LAYOUT_MULTILINE_TEXT_Title_pane_texts_Line_2( indexW, 2 ) );

  1126 

  1127         // if text would truncate, then try to use

  1128         // smaller font with one line layout

  1129         if ( !TextFits( oneLineLayout ) )

  1130             {

  1131             oneLineLayout =

  1132                 AknLayoutScalable_Avkon::title_pane_t2( 1 ).LayoutLine();

  1133             }

  1134