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 of the decorator class for navigation

    15 *                pane controls.

    16 *

    17 */

    18 

    19 

    20 // SYSTEM INCLUDE FILES

    21 #include <AknsUtils.h>

    22 #include <AknsDrawUtils.h>

    23 #include <aknlayoutscalable_avkon.cdl.h>

    24 #include <layoutmetadata.cdl.h>

    25 #include <touchfeedback.h>

    26 

    27 #include <AknTasHook.h>

    28 // USER INCLUDE FILES

    29 #include "aknappui.h"

    30 #include "aknconsts.h"

    31 #include "aknnavilabel.h"

    32 #include "aknnavide.h"

    33 #include "AknNaviObserver.h"

    34 #include "AknUtils.h"

    35 #include "AknStatuspaneUtils.h"

    36 #include "AknNaviDecoratorObserver.h"

    37 #include "akntabgrp.h"

    38 #include "akntitle.h"

    39 #include "AknTitlePaneLabel.h"

    40 

    41 

    42 const TInt KEikNavidePointerRepeatInterval = 500000;  // in micro seconds

    43 

    44 

    45 // ============================= LOCAL FUNCTIONS ===============================

    46 

    47 NONSHARABLE_CLASS( CAknNavigationDecoratorExtension ) : public CBase

    48     {

    49 public:

    50     enum

    51         {

    52         ENaviDecoratorNoSide = 0,

    53         ENaviDecoratorLeftSide,

    54         ENaviDecoratorRightSide

    55         };

    56     

    57 public:

    58     static CAknNavigationDecoratorExtension* NewL();

    59     ~CAknNavigationDecoratorExtension();

    60     

    61 private:

    62     CAknNavigationDecoratorExtension();

    63     CAknNavigationDecoratorExtension( const CAknNavigationDecoratorExtension* aExtension );

    64     

    65 public:

    66     CPeriodic* iTimer;

    67     TInt iEffectTimerCount;

    68     TInt iOutermostRepeats;

    69     TInt iBlinkingSide;

    70     };

    71 

    72 CAknNavigationDecoratorExtension* CAknNavigationDecoratorExtension::NewL()

    73     {

    74     CAknNavigationDecoratorExtension* naviExtension = 

    75         new (ELeave) CAknNavigationDecoratorExtension();

    76     return naviExtension;

    77     }

    78 

    79 CAknNavigationDecoratorExtension::CAknNavigationDecoratorExtension() : 

    80     iTimer(NULL), iEffectTimerCount(0), iOutermostRepeats(0), iBlinkingSide(0)

    81     {

    82     }

    83 

    84 CAknNavigationDecoratorExtension::~CAknNavigationDecoratorExtension()

    85     {

    86     }

    87     

    88 // -----------------------------------------------------------------------------

    89 // IsMaskAllBlack

    90 //

    91 // Checks whether the given bitmap is all black (first row ignored).

    92 // The width of the bitmap is assumed to be 8 or less (sufficient for arrows).

    93 //

    94 // Returns: Boolean value.

    95 // -----------------------------------------------------------------------------

    96 //

    97 static TBool IsMaskAllBlack( CFbsBitmap* bitmap )

    98     {

    99     if ( !bitmap )

   100         {

   101         return EFalse;

   102         }

   103 

   104     TSize size( bitmap->SizeInPixels() );

   105 

   106     if ( size.iWidth > 8 )

   107         {

   108         return EFalse;

   109         }

   110         

   111     TBuf8<8> scanLineBuf;

   112 

   113     for ( TInt y = 1; y < size.iHeight; y++ )

   114         {

   115         bitmap->GetScanLine( scanLineBuf,

   116                              TPoint( 0, y ),

   117                              size.iWidth,

   118                              EGray256 );

   119         for ( TInt x = 0; x < size.iWidth; x++ )

   120             {

   121             if ( scanLineBuf[x] != 0 )

   122                 {

   123                 return EFalse;

   124                 }

   125             }

   126         }

   127 

   128     return ETrue;

   129     }

   130 

   131 // ============================ MEMBER FUNCTIONS ===============================

   132 

   133 EXPORT_C CAknNavigationDecorator* CAknNavigationDecorator::NewL(

   134     CAknNavigationControlContainer* /*aNavigationControlContainer*/,

   135     CCoeControl* aDecoratedControl,

   136     TControlType aType )

   137     {

   138     CleanupStack::PushL( aDecoratedControl );

   139     CAknNavigationDecorator* self = new (ELeave) CAknNavigationDecorator;

   140 

   141     self->iDecoratedControl = aDecoratedControl;

   142 

   143     CleanupStack::Pop( aDecoratedControl );

   144     

   145     // Control type must be set before calling constructor.

   146     self->iControlType = aType;

   147     

   148     CleanupStack::PushL( self );

   149     self->ConstructL();

   150     CleanupStack::Pop( self ); // self

   151     AKNTASHOOK_ADDL( self, "CAknNavigationDecorator" );

   152     return self;

   153     }

   154 

   155 EXPORT_C CAknNavigationDecorator::~CAknNavigationDecorator()

   156     {

   157     AKNTASHOOK_REMOVE();

   158     if ( iContainer )

   159         {

   160         iContainer->Pop( this );

   161         }

   162 

   163     if ( iLayoutStyleTimer )

   164         {

   165         iLayoutStyleTimer->Cancel();

   166         delete iLayoutStyleTimer;

   167         }

   168         

   169     if( iExtension && iExtension->iTimer )

   170         {

   171         if ( iExtension->iTimer->IsActive() )

   172             {

   173             CancelTimer();

   174             }

   175 

   176         delete iExtension->iTimer;

   177         }

   178     

   179     delete iExtension;    

   180     delete iDecoratedControl;

   181     }

   182 

   183 

   184 EXPORT_C void CAknNavigationDecorator::ConstructL()

   185     {

   186     iDecoratedControl->SetObserver( this );

   187 

   188     iNaviArrowsVisible    = EFalse;

   189     iNaviArrowLeftDimmed  = ETrue;

   190     iNaviArrowRightDimmed = ETrue;

   191     

   192     TBool isLandscape( Layout_Meta_Data::IsLandscapeOrientation() );

   193     

   194     iLayoutStyleTimer = CPeriodic::NewL( CActive::EPriorityIdle );

   195     if ( AknStatuspaneUtils::FlatLayoutActive() &&

   196          !isLandscape )

   197         {

   198         iLayoutFlags |= ENaviControlLayoutNarrow;

   199         iLayoutFlags |= ENaviControlLayoutModeForced;

   200         }

   201 

   202     // Wide layout is used in usual portrait mode,

   203     // except for tabs in non-touch layouts.

   204     else if ( AknStatuspaneUtils::UsualLayoutActive() &&

   205               !isLandscape &&

   206               ( iControlType != ETabGroup ||

   207                 AknLayoutUtils::PenEnabled() ) )

   208         {

   209         iLayoutFlags |= ENaviControlLayoutWide;

   210         iLayoutFlags |= ENaviControlLayoutModeForced;

   211         }

   212     else

   213         {        

   214         iLayoutFlags |= ENaviControlLayoutNormal;

   215         iLayoutFlags |= ENaviControlLayoutModeAutomatic;

   216         }

   217     

   218     iExtension = CAknNavigationDecoratorExtension::NewL();

   219     

   220     ActivateL();

   221     }

   222 

   223 EXPORT_C CCoeControl* CAknNavigationDecorator::DecoratedControl()

   224     {

   225     // In case the decorated control is of the ENaviVolume type, this

   226     // function returns the CAknVolumeControl object which is a component

   227     // control of the volume popup, instead of the volume popup control itself.

   228     // This is in order to maintain BC.

   229     if ( iControlType == ENaviVolume )

   230         {

   231         CCoeControl* volumeControl = iDecoratedControl->ComponentControl( 5 );

   232         

   233         if ( volumeControl )

   234             {

   235             return volumeControl;

   236             }

   237         }

   238 

   239     return iDecoratedControl;

   240     }

   241 

   242 EXPORT_C void CAknNavigationDecorator::MakeScrollButtonVisible( TBool aVisible )

   243     {

   244     TBool differ = ( iNaviArrowsVisible != aVisible );

   245     

   246     iNaviArrowsVisible = aVisible;

   247     

   248     if ( iControlType == ENaviLabel )

   249         {

   250         if ( iNaviArrowsVisible )

   251             {

   252             STATIC_CAST( CAknNaviLabel*, iDecoratedControl )->

   253                 SetNaviLabelType( CAknNaviLabel::ENavigationLabel );

   254             }

   255         else

   256             {

   257             STATIC_CAST( CAknNaviLabel*, iDecoratedControl )->

   258                 SetNaviLabelType( CAknNaviLabel::EAdditionalInfoLabel );

   259             }

   260         }

   261     else if ( iControlType == ETabGroup )

   262         {

   263         static_cast<CAknTabGroup*>(

   264             iDecoratedControl )->SetNaviArrowsVisible( aVisible );

   265         }

   266 

   267     if ( differ )

   268         {

   269         SizeChanged();

   270         }

   271     }

   272 

   273 EXPORT_C TBool CAknNavigationDecorator::ScrollButtonVisible() const

   274     {

   275     return iNaviArrowsVisible;

   276     }

   277 

   278 EXPORT_C void CAknNavigationDecorator::SetScrollButtonDimmed(

   279     TScrollButton aButton,

   280     TBool aDimmed )

   281     {

   282     if ( aButton == ELeftButton )

   283         {

   284         iNaviArrowLeftDimmed = aDimmed;

   285 

   286         if ( aDimmed )

   287             {

   288             iExtension->iBlinkingSide = 

   289                 CAknNavigationDecoratorExtension::ENaviDecoratorRightSide;

   290             }

   291         }

   292     if ( aButton == ERightButton )

   293         {

   294         iNaviArrowRightDimmed = aDimmed;

   295 

   296         if ( aDimmed )

   297             {

   298             iExtension->iBlinkingSide = 

   299                 CAknNavigationDecoratorExtension::ENaviDecoratorLeftSide;

   300             }

   301         }

   302     }

   303 

   304 EXPORT_C TBool CAknNavigationDecorator::IsScrollButtonDimmed(

   305     TScrollButton aButton ) const

   306     {

   307     if ( aButton == ELeftButton )

   308         {

   309         return iNaviArrowLeftDimmed;

   310         }

   311     if ( aButton == ERightButton )

   312         {

   313         return iNaviArrowRightDimmed;

   314         }

   315     return ETrue;

   316     }

   317 

   318 EXPORT_C void CAknNavigationDecorator::SetControlType( TControlType aType )

   319     {

   320     iControlType = aType;

   321     }

   322 

   323 EXPORT_C CAknNavigationDecorator::TControlType CAknNavigationDecorator::ControlType() const

   324     {

   325     return iControlType;

   326     }

   327 

   328 EXPORT_C void CAknNavigationDecorator::SizeChanged()

   329     {

   330     if ( iControlType == ENaviVolume )

   331         {

   332         // The control for ENaviVolume type does not reside in the navi pane

   333         // anymore, so the control size doesn't need to be adjusted if navi pane

   334         // size changes.

   335         return;

   336         }

   337     

   338     TBool isLandscape( Layout_Meta_Data::IsLandscapeOrientation() );

   339     TBool flatLayout( AknStatuspaneUtils::FlatLayoutActive() );

   340     

   341     if ( isLandscape &&

   342          flatLayout &&

   343          !AknLayoutUtils::PenEnabled() &&

   344          NaviControlLayoutMode() == ENaviControlLayoutModeAutomatic &&

   345          NaviControlLayoutStyle() == ENaviControlLayoutNormal )

   346         {

   347         if ( iLayoutStyleTimer && !iLayoutStyleTimer->IsActive() )

   348             {

   349             InitLayoutStyleTimer();

   350             }            

   351         }

   352     else

   353         {

   354         CancelLayoutStyleTimer();

   355         }    

   356     

   357     TBool wideInUseInLsc( EFalse );

   358     

   359     if ( NaviControlLayoutStyle() != ENaviControlLayoutNarrow &&

   360          flatLayout &&

   361          !isLandscape )

   362         {

   363         iLayoutFlags &= ~ENaviControlLayoutNormal;

   364         iLayoutFlags &= ~ENaviControlLayoutWide;

   365         iLayoutFlags |= ENaviControlLayoutNarrow;

   366         }

   367 

   368     // Only flat layout supports narrow mode for now.

   369     if ( NaviControlLayoutStyle() == ENaviControlLayoutNarrow )

   370         {

   371         if ( !flatLayout ||

   372              ( isLandscape && AknLayoutUtils::PenEnabled() ) )

   373             {

   374             iLayoutFlags &= ~ENaviControlLayoutNarrow;           

   375             iLayoutFlags |= ENaviControlLayoutNormal; 

   376             }

   377         }

   378     // Wide layout is supported only in portrait mode.

   379     else if ( NaviControlLayoutStyle() == ENaviControlLayoutWide )

   380         {

   381         if ( Layout_Meta_Data::IsLandscapeOrientation() )

   382             {

   383             wideInUseInLsc = ETrue;

   384             }

   385         }

   386     

   387     if ( NaviControlLayoutStyle() == ENaviControlLayoutNarrow &&

   388          NaviControlLayoutStyleSupported( ENaviControlLayoutNarrow ) )

   389         {

   390         SizeChangedInNarrowLayout();

   391         }

   392     else if ( NaviControlLayoutStyle() == ENaviControlLayoutWide &&

   393               !wideInUseInLsc )

   394         {

   395         SizeChangedInWideLayout();

   396         }

   397     else // Normal layout

   398         {

   399         SizeChangedInNormalLayout();

   400         }

   401 

   402     // Finally call the navi arrow bitmap getter, as it will

   403     // resize the navi arrows to correct size.

   404     if ( iContainer )

   405         {

   406         iContainer->NaviArrowBitmap( 0 );

   407         iContainer->NaviArrowBitmap( 1 );

   408         }

   409     }

   410 

   411 void CAknNavigationDecorator::SizeChangedInNormalLayout()

   412     {

   413     TRect rect;

   414     TRect leftArrowRect;

   415     TRect rightArrowRect;

   416     

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

   418     if ( statusPane && 

   419          statusPane->CurrentLayoutResId() == R_AVKON_STATUS_PANE_LAYOUT_USUAL_EXT &&

   420          iControlType == ETabGroup )

   421         {

   422         // At the moment this special handling is required for tab group

   423         // in portrait mode, because tabs don't support wide navi pane layout yet.

   424         TAknLayoutRect layoutRect;

   425             

   426         TRect screenRect;

   427         AknLayoutUtils::LayoutMetricsRect( AknLayoutUtils::EScreen, screenRect );

   428         

   429         TBool isHDLayoutActive( AknStatuspaneUtils::HDLayoutActive() );

   430                     

   431         TAknWindowComponentLayout topArea( 

   432             AknLayoutScalable_Avkon::area_top_pane( isHDLayoutActive ? 8 : 0 ) );

   433         TAknWindowComponentLayout spLayout(

   434             AknLayoutScalable_Avkon::status_pane( isHDLayoutActive ? 1 : 0 ) );

   435             

   436         TAknWindowComponentLayout layout(

   437                 TAknWindowComponentLayout::Compose( topArea, spLayout ) );

   438                 

   439         layoutRect.LayoutRect( screenRect, layout );

   440         TRect spRect( layoutRect.Rect() );

   441                 

   442         layoutRect.LayoutRect(

   443             spRect,

   444             AknLayoutScalable_Avkon::navi_pane( isHDLayoutActive ? 8 : 5 ) );

   445         rect = layoutRect.Rect();

   446         rect.Move( -rect.iTl.iX, -rect.iTl.iY );

   447         leftArrowRect  = NaviArrowRect( ELeftButton,  EFalse, rect );

   448         rightArrowRect = NaviArrowRect( ERightButton, EFalse, rect );

   449         }

   450     else

   451         {

   452         rect = ParentRect();

   453         

   454         if ( iControlType == ENaviVolume &&

   455              !Layout_Meta_Data::IsLandscapeOrientation() &&

   456              AknStatuspaneUtils::SmallLayoutActive() )

   457             {

   458             // Small status pane volume control has it's own positions for

   459             // navi arrows, but in landscape the data doesn't exist

   460             // so normal navi arrow positions are used.

   461             

   462             // These layout data items aren't mirrored.

   463             TBool layoutMirrored( AknLayoutUtils::LayoutMirrored() );

   464             

   465             TRect naviPaneRect;

   466             AknLayoutUtils::LayoutMetricsRect( AknLayoutUtils::ENaviPane,

   467                                                naviPaneRect );

   468                                                

   469             naviPaneRect.Move( -naviPaneRect.iTl.iX,

   470                                -naviPaneRect.iTl.iY );

   471             

   472             TAknLayoutRect layoutRect;

   473             layoutRect.LayoutRect(

   474                 naviPaneRect,

   475                 layoutMirrored ?

   476                     AknLayoutScalable_Avkon::status_small_pane_g6( 0 ) :

   477                     AknLayoutScalable_Avkon::status_small_pane_g5( 0 ) );

   478             leftArrowRect = layoutRect.Rect();

   479 

   480             layoutRect.LayoutRect(

   481                 naviPaneRect,

   482                 layoutMirrored ?

   483                     AknLayoutScalable_Avkon::status_small_pane_g5( 0 ) :

   484                     AknLayoutScalable_Avkon::status_small_pane_g6( 0 ) );

   485             rightArrowRect = layoutRect.Rect();   

   486             }

   487         else

   488             {

   489             leftArrowRect = NaviArrowRect( ELeftButton );

   490             rightArrowRect = NaviArrowRect( ERightButton );

   491             }

   492         }

   493 

   494     if ( iControlType == ETabGroup )

   495         {

   496         rect = DecoratedTabControlRect( AknLayoutUtils::PenEnabled(),

   497                                         ETrue );

   498         }

   499 

   500     iArrowRightSize = rightArrowRect.Size();

   501     iArrowLeftSize  = leftArrowRect.Size();

   502     

   503     iArrowRightPos = TPoint( rightArrowRect.iTl.iX, rect.iTl.iY );

   504     iArrowLeftPos  = TPoint( leftArrowRect.iTl.iX, rect.iTl.iY );

   505     

   506     TSize rectSize( rect.Size() );

   507     

   508     // In case the decorated control is tab group, the tab layout mode

   509     // must be set before it's size is set.

   510     if ( iControlType == ETabGroup )

   511         {

   512         CAknTabGroup* tabGroup = static_cast <CAknTabGroup*> (iDecoratedControl);

   513         TRAP_IGNORE( tabGroup->SetNarrowTabLayoutL( EFalse ) );

   514         }

   515     

   516     if ( ScrollButtonVisible() )

   517         {

   518         iDecoratedControl->SetRect( rect );

   519         }

   520     else

   521         {

   522         iDecoratedControl->SetRect( Rect() );

   523         }

   524     }

   525 

   526 

   527 void CAknNavigationDecorator::SizeChangedInNarrowLayout()

   528     {

   529     TRect rect( DecoratedControlNarrowRect( this->ControlType() ) );

   530     

   531     TRect leftArrowRect( NaviArrowRect( ELeftButton, ETrue ) );

   532     TRect rightArrowRect( NaviArrowRect( ERightButton, ETrue ) );

   533 

   534     iArrowRightSize = rightArrowRect.Size();

   535     iArrowRightPos  = rightArrowRect.iTl;

   536     

   537     iArrowLeftSize  = leftArrowRect.Size();

   538     iArrowLeftPos   = leftArrowRect.iTl;

   539 

   540     // Tab group is handled specificly... 

   541     if ( iControlType == ETabGroup )

   542         {

   543         // Note. Size is set bigger than normally. 

   544         // Tabs take this into account in layout calculations (akntabgrp.cpp).

   545         iDecoratedControl->SetRect( Rect() ); 

   546         CAknTabGroup* tabGroup = static_cast <CAknTabGroup*> (iDecoratedControl);

   547         // This sets tab size using animation.

   548         TBool useAnimation( Layout_Meta_Data::IsLandscapeOrientation() );

   549         TRAP_IGNORE( tabGroup->SetNarrowTabLayoutL( ETrue, useAnimation ) );

   550         }

   551     else

   552         {

   553         if ( ScrollButtonVisible() )

   554             {

   555             iDecoratedControl->SetRect( TRect( iArrowLeftPos.iX + iArrowLeftSize.iWidth,

   556                                                rect.iTl.iY,

   557                                                iArrowRightPos.iX,

   558                                                rect.iBr.iY ) );

   559             }

   560         else

   561             {

   562             iDecoratedControl->SetRect( rect );

   563             }

   564         }                 

   565     }

   566 

   567 

   568 void CAknNavigationDecorator::SizeChangedInWideLayout()

   569     {

   570     TRect rect( Rect() );

   571     TRect parentRect;

   572 

   573     if ( iControlType == ETabGroup &&

   574          !AknLayoutUtils::PenEnabled() )

   575         {

   576         parentRect = DecoratedTabControlRect( EFalse, ETrue );

   577         }

   578     else

   579         {

   580         parentRect = ParentRect();

   581         }

   582 

   583     if ( rect.Width()  < parentRect.Width() ||

   584          rect.Height() < parentRect.Height() )

   585         {

   586         rect = parentRect;

   587         }

   588 

   589     TRect leftArrowRect( NaviArrowRect( ELeftButton ) );

   590     TRect rightArrowRect( NaviArrowRect( ERightButton ) );

   591 

   592     iArrowRightSize = rightArrowRect.Size();

   593     iArrowLeftSize  = leftArrowRect.Size();

   594 

   595     if ( ScrollButtonVisible() )

   596         {

   597         rect.iTl.iX += iArrowRightSize.iWidth;

   598         rect.iBr.iX -= iArrowLeftSize.iWidth;

   599         }

   600     

   601     if ( parentRect.Height() < rect.Height() )

   602         {

   603         iArrowRightPos = TPoint( rect.iBr.iX, parentRect.iTl.iY );

   604         iArrowLeftPos = TPoint( rect.iTl.iX - iArrowLeftSize.iWidth, parentRect.iTl.iY );

   605         }

   606     else

   607         {

   608         iArrowRightPos = TPoint( rect.iBr.iX, rightArrowRect.iTl.iY );

   609         iArrowLeftPos = TPoint( rect.iTl.iX - iArrowLeftSize.iWidth, iArrowRightPos.iY );

   610         }

   611 

   612     // In case the decorated control is tab group, the tab layout mode

   613     // must be set before it's size is set.

   614     if ( iControlType == ETabGroup )

   615         {

   616         CAknTabGroup* tabGroup = static_cast <CAknTabGroup*> ( iDecoratedControl );

   617         TRAP_IGNORE( tabGroup->SetNarrowTabLayoutL( EFalse) );

   618         }

   619 

   620     iDecoratedControl->SetRect( rect );

   621     }

   622 

   623 EXPORT_C TInt CAknNavigationDecorator::CountComponentControls() const

   624     {

   625     if ( iContainer && iDecoratedControl )

   626         {

   627         return 1;

   628         }

   629 

   630     return 0;

   631     }

   632 

   633 

   634 EXPORT_C CCoeControl* CAknNavigationDecorator::ComponentControl(TInt /*aIndex*/) const

   635     {

   636     // DecoratedControl() isn't declared as const but doesn't actually

   637     // change anything.

   638     return ( const_cast<CAknNavigationDecorator*>(this)->DecoratedControl() );

   639     }

   640 

   641 

   642 EXPORT_C void* CAknNavigationDecorator::ExtensionInterface( TUid /*aInterface*/ ) 

   643     { 

   644     return NULL;

   645     }

   646 

   647    

   648 // ---------------------------------------------------------------------------

   649 // CAknNavigationDecorator::HandlePointerEventL

   650 // Handles pointer events by checking first if the pointer event was

   651 // in the arrow areas and sending the arrow event to observer,

   652 // and if not sending the pointer event to all child components.

   653 // ---------------------------------------------------------------------------

   654 //

   655 EXPORT_C void CAknNavigationDecorator::HandlePointerEventL(

   656     const TPointerEvent& aPointerEvent )

   657     {

   658     if ( AknLayoutUtils::PenEnabled() )

   659         {

   660         TRect naviPaneRect( ParentRect() );

   661         TRect parentRect = naviPaneRect;

   662         

   663         TRect statusPaneRect;

   664         AknLayoutUtils::LayoutMetricsRect(

   665             AknLayoutUtils::EStatusPane, statusPaneRect );

   666         

   667         // In certain status pane layouts the navi pane has extended

   668         // touch responsive area in the layout data which is larger

   669         // than the actual decorator size.

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

   671         if ( statusPane )

   672             {

   673             TInt currentLayoutResId( statusPane->CurrentLayoutResId() );

   674             

   675             if ( currentLayoutResId == R_AVKON_WIDESCREEN_PANE_LAYOUT_USUAL ||

   676                  currentLayoutResId == R_AVKON_WIDESCREEN_PANE_LAYOUT_IDLE )

   677                 {

   678                 TAknLayoutRect layoutRect;

   679                 layoutRect.LayoutRect(

   680                     statusPaneRect,

   681                     AknLayoutScalable_Avkon::aid_touch_navi_pane() );

   682                 parentRect = layoutRect.Rect();

   683                 

   684                 // Make the parent rect navi pane relative and move it so

   685                 // that the bottom sides of the real navi pane area and the

   686                 // touch pane responsive area are aligned. This means

   687                 // that the iTl.iY will become negative, which is required

   688                 // for pointer events in which the down event happens

   689                 // inside the decorator rect, but the up event in the

   690                 // extended area above the decorator rect.

   691                 parentRect.Move( -parentRect.iTl.iX,

   692                                  -( parentRect.iTl.iY +

   693                                     ( parentRect.Height() -

   694                                       naviPaneRect.Height() ) ) );

   695                 }

   696             }

   697 

   698         TRect rightArrowTabRect( iArrowRightPos, iArrowRightSize );

   699         TRect leftArrowTabRect( iArrowLeftPos, iArrowLeftSize );

   700         

   701         // Get tab arrow touch aid rects from layout data, they extend the

   702         // arrow areas bit to the decorated control's area to make the arrows

   703         // more "finger usable".

   704         TAknLayoutRect arrowAidLayout;

   705         arrowAidLayout.LayoutRect(

   706             statusPaneRect,

   707             AknLayoutScalable_Avkon::aid_touch_tab_arrow_left(

   708                 Layout_Meta_Data::IsLandscapeOrientation() ? 2 : 0 ) );

   709         

   710         // The arrows are the same size so use only the other's width.

   711         TInt aidWidth( arrowAidLayout.Rect().Width() );

   712         

   713         rightArrowTabRect.iTl.iX -= aidWidth;

   714         leftArrowTabRect.iBr.iX  += aidWidth;

   715                 

   716         TBool rightArrowTapped(

   717             iNaviArrowsVisible &&

   718             !iNaviArrowRightDimmed &&

   719             rightArrowTabRect.Contains( aPointerEvent.iPosition ) );

   720             

   721         TBool leftArrowTapped(

   722             iNaviArrowsVisible &&

   723             !iNaviArrowLeftDimmed &&

   724             leftArrowTabRect.Contains( aPointerEvent.iPosition ) );

   725         

   726         // Inform controls if tapped to arrows.

   727         if ( aPointerEvent.iType == TPointerEvent::EButton1Down ||

   728              aPointerEvent.iType == TPointerEvent::EButtonRepeat )

   729             {

   730             // Detects whether tap hits left arrow.

   731             if ( leftArrowTapped && iNaviDecoratorObserver )

   732                 {

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

   734                 if ( feedback &&

   735                      ( iDecoratedControl && !iDecoratedControl->IsDimmed() ) )

   736                     {

   737                     TTouchLogicalFeedback feedbackType =

   738                         ( aPointerEvent.iType == TPointerEvent::EButtonRepeat ?

   739                               ETouchFeedbackSensitiveButton :

   740                               ETouchFeedbackBasicButton );

   741                     feedback->InstantFeedback( this, feedbackType, aPointerEvent );

   742                     }

   743 

   744                 iNaviDecoratorObserver->HandleNaviDecoratorEventL(

   745                     MAknNaviDecoratorObserver::EAknNaviDecoratorEventLeftTabArrow );

   746 

   747                 // Request pointer repeat to implement longtapping

   748                 Window().RequestPointerRepeatEvent(

   749                     KEikNavidePointerRepeatInterval, leftArrowTabRect );

   750 

   751                 // Don't pass the event to children as the tap point

   752                 // may be in the decorated control's area and it's

   753                 // already handled here.

   754                 }

   755             // Detects whether tap hits right arrow.

   756             else if ( rightArrowTapped && iNaviDecoratorObserver )

   757                 {

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

   759                 if ( feedback &&

   760                      ( iDecoratedControl && !iDecoratedControl->IsDimmed() ) )

   761                     {

   762                     TTouchLogicalFeedback feedbackType =

   763                         ( aPointerEvent.iType == TPointerEvent::EButtonRepeat ?

   764                               ETouchFeedbackSensitiveButton :

   765                               ETouchFeedbackBasicButton );

   766                     feedback->InstantFeedback( this, feedbackType, aPointerEvent );

   767                     }

   768 

   769                 iNaviDecoratorObserver->HandleNaviDecoratorEventL(

   770                     MAknNaviDecoratorObserver::EAknNaviDecoratorEventRightTabArrow );

   771 

   772                 // Request pointer repeat to implement longtapping

   773                 Window().RequestPointerRepeatEvent(

   774                     KEikNavidePointerRepeatInterval, rightArrowTabRect );

   775 

   776                 // Don't pass the event to children as the tap point

   777                 // may be in the decorated control's area and it's

   778                 // already handled here.

   779                 }

   780             else

   781                 {

   782                 // Pass the pointer events to children.

   783                 CCoeControl::HandlePointerEventL( aPointerEvent );

   784                 }

   785 

   786             // check if navi label was hit

   787             }

   788         else if ( aPointerEvent.iType == TPointerEvent::EButton1Up )

   789             {

   790             if ( iControlType == ENaviLabel )

   791                 {

   792                 if ( parentRect.Contains( aPointerEvent.iPosition ) &&

   793                      iNaviDecoratorObserver )

   794                     {

   795                     iNaviDecoratorObserver->HandleNaviDecoratorEventL(

   796                         MAknNaviDecoratorObserver::EAknNaviDecoratorEventNaviLabel );

   797                     }

   798                 }

   799             else if( !rightArrowTapped && !leftArrowTapped )

   800                 {

   801                 CCoeControl::HandlePointerEventL( aPointerEvent );

   802                 }

   803             

   804             // feedback is also given on up event from arrows

   805             if ( rightArrowTapped || leftArrowTapped )

   806                 {

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

   808                 if ( feedback &&

   809                      ( iDecoratedControl && !iDecoratedControl->IsDimmed() ) )

   810                     {

   811                     feedback->InstantFeedback( this, 

   812                                                ETouchFeedbackBasicButton,

   813                                                ETouchFeedbackVibra,

   814                                                aPointerEvent );

   815                     }

   816                 }

   817             }

   818         else

   819             {

   820             if ( !rightArrowTapped && !leftArrowTapped )

   821                 {

   822                 // Pass other pointer events to children if it

   823                 // happened outside the arrow areas.

   824                 CCoeControl::HandlePointerEventL( aPointerEvent );

   825                 }

   826             }

   827         }

   828     }

   829 

   830 

   831 EXPORT_C void CAknNavigationDecorator::HandleControlEventL(

   832     CCoeControl* /*aControl*/, TCoeEvent aEventType )

   833     {

   834     TInt event = aEventType;

   835     switch ( event )

   836         {

   837         case MAknNavigationObserver::ENaviEventHandleNavigation:

   838             {

   839             iNaviArrowRightDimmed = EFalse;

   840             iNaviArrowLeftDimmed  = EFalse;

   841             break;

   842             }

   843         case MAknNavigationObserver::ENaviEventRightMostItemReached:

   844             {

   845             iNaviArrowRightDimmed = ETrue;

   846             iNaviArrowLeftDimmed  = EFalse;

   847             break;

   848             }

   849         case MAknNavigationObserver::ENaviEventLeftMostItemReached:

   850             {

   851             iNaviArrowRightDimmed = EFalse;

   852             iNaviArrowLeftDimmed  = ETrue;

   853             break;

   854             }

   855         case MAknNavigationObserver::ENaviEventOneItemExists:

   856             {

   857             iNaviArrowRightDimmed = ETrue;

   858             iNaviArrowLeftDimmed  = ETrue;

   859             break;

   860             }

   861         case MAknNavigationObserver::ENaviEventAlreadyLeftmostItem:

   862             {

   863 #ifdef RD_ANIMATION_EFFECTS 

   864             iExtension->iBlinkingSide = 

   865                     CAknNavigationDecoratorExtension::ENaviDecoratorRightSide;           

   866             StartTimerL();

   867             return;

   868 #else

   869             break;

   870 #endif // RD_ANIMATION_EFFECTS

   871             }

   872         case MAknNavigationObserver::ENaviEventAlreadyRightmostItem:

   873             {

   874 #ifdef RD_ANIMATION_EFFECTS

   875             iExtension->iBlinkingSide = 

   876                     CAknNavigationDecoratorExtension::ENaviDecoratorLeftSide;

   877             StartTimerL();

   878             return;

   879 #else // RD_ANIMATION_EFFECTS

   880             break;

   881 #endif

   882             }

   883         case MAknNavigationObserver::ENaviEventRedrawNeeded:

   884             break;

   885         default:

   886             break;

   887         }

   888     

   889     ReportEventL( MCoeControlObserver::EEventStateChanged );

   890     

   891     MCoeControlObserver* observer = Observer();

   892     // If event was not sent yet to the navigation control container, send it now

   893     if ( iContainer && observer != iContainer )

   894         {

   895         SetObserver( iContainer );

   896         ReportEventL( MCoeControlObserver::EEventStateChanged );

   897         SetObserver( observer );

   898         }

   899     }

   900 

   901 

   902 EXPORT_C void CAknNavigationDecorator::Draw( const TRect& /*aRect*/ ) const

   903     {

   904     // Draw navigation pane scroll indicator arrows if visible

   905     if ( iNaviArrowsVisible && iContainer )

   906         {

   907         CWindowGc& gc = SystemGc();

   908         

   909         CFbsBitmap* colorbmp = iContainer->NaviColorBitmap();

   910 

   911         if ( !iNaviArrowLeftDimmed )

   912             {

   913             CFbsBitmap* arrowBmp = &( iContainer->NaviArrowBitmap( 0 ) );

   914             CFbsBitmap* arrowMask = &( iContainer->NaviArrowBitmap( 1 ) );

   915             

   916             TPoint arrowPos( iArrowLeftPos );

   917             

   918             if ( arrowBmp )

   919                 {

   920                 TInt arrowHeight( arrowBmp->SizeInPixels().iHeight );

   921                 if ( arrowHeight < Size().iHeight )

   922                     {

   923                     arrowPos.iY = ( Size().iHeight - arrowHeight ) / 2;

   924                     }

   925                 }

   926                     

   927             if( colorbmp && !IsMaskAllBlack( arrowMask ) )

   928                 {

   929                 gc.BitBltMasked(

   930                     arrowPos,

   931                     colorbmp, 

   932                     TRect( iArrowLeftSize ),

   933                     arrowMask,

   934                     ETrue );

   935                 }

   936             else

   937                 {

   938                 gc.BitBltMasked(

   939                     arrowPos,

   940                     arrowBmp, 

   941                     TRect( iArrowLeftSize ),

   942                     arrowMask,

   943                     ETrue );

   944                 }

   945             }

   946         

   947         if ( !iNaviArrowRightDimmed )

   948             {

   949             CFbsBitmap* arrowBmp = &( iContainer->NaviArrowBitmap( 2 ) );

   950             CFbsBitmap* arrowMask = &( iContainer->NaviArrowBitmap( 3 ) );

   951             

   952             TPoint arrowPos( iArrowRightPos );

   953             

   954             if ( arrowBmp )

   955                 {

   956                 TInt arrowHeight( arrowBmp->SizeInPixels().iHeight );

   957                 if ( arrowHeight < Size().iHeight )

   958                     {

   959                     arrowPos.iY = ( Size().iHeight - arrowHeight ) / 2;

   960                     }

   961                 }

   962             

   963             if( colorbmp && !IsMaskAllBlack( arrowMask ) )

   964                 {

   965                 gc.BitBltMasked(

   966                     arrowPos,

   967                     colorbmp, 

   968                     TRect( iArrowRightSize ),

   969                     arrowMask,

   970                     ETrue );

   971                 }

   972             else

   973                 {

   974                 gc.BitBltMasked(

   975                     arrowPos,

   976                     arrowBmp,

   977                     TRect( iArrowRightSize ),

   978                     arrowMask,

   979                     ETrue );

   980                 }

   981             }

   982         }

   983     }

   984 

   985 void CAknNavigationDecorator::SetNaviStack(

   986     CAknNavigationControlContainer* aContainer )

   987     {

   988     iContainer = aContainer;

   989 

   990     if ( iContainer &&

   991          iControlType == ETabGroup )

   992         {

   993         CAknTabGroup* tabGroup =

   994             static_cast <CAknTabGroup*> ( iDecoratedControl );

   995         tabGroup->SetDecoratorLayout( iLayoutFlags & ENaviControlLayoutNarrow );

   996         }

   997     }

   998 

   999 // ---------------------------------------------------------------------------

  1000 // CAknNavigationDecorator::SetNaviDecoratorObserver

  1001 // Sets observer for navidecorator.

  1002 // ---------------------------------------------------------------------------

  1003 //  

  1004 EXPORT_C void CAknNavigationDecorator::SetNaviDecoratorObserver(

  1005     MAknNaviDecoratorObserver* aObserver )

  1006     {

  1007     if ( AknLayoutUtils::PenEnabled() )

  1008         {

  1009         iNaviDecoratorObserver = aObserver;

  1010         }

  1011     }

  1012 

  1013 

  1014 // ---------------------------------------------------------------------------

  1015 // CAknNavigationDecorator::ParentRect

  1016 // Returns the navigation decorator rectangle.

  1017 // ---------------------------------------------------------------------------

  1018 //

  1019 TRect CAknNavigationDecorator::ParentRect()

  1020     {

  1021     return DecoratedControlRect( iControlType, iNaviArrowsVisible );

  1022     }

  1023 

  1024 

  1025 // ---------------------------------------------------------------------------

  1026 // CAknNavigationDecorator::DecoratedControlNarrowRect

  1027 // Returns the navigation decorator rectangle used in the narrow layout.

  1028 // ---------------------------------------------------------------------------

  1029 //

  1030 TRect CAknNavigationDecorator::DecoratedControlNarrowRect(

  1031     TInt /*aControlType*/ )

  1032     {

  1033     TBool landscape( Layout_Meta_Data::IsLandscapeOrientation() );

  1034 

  1035     // Status pane area

  1036     TRect statusPaneRect;

  1037     AknLayoutUtils::LayoutMetricsRect(

  1038         AknLayoutUtils::EStatusPane, statusPaneRect );

  1039         

  1040     // Navi pane area

  1041     TRect naviPaneRect;

  1042     AknLayoutUtils::LayoutMetricsRect(

  1043         AknLayoutUtils::ENaviPane, naviPaneRect );

  1044 

  1045     // Short navi pane

  1046     TAknLayoutRect naviSrtRect;        

  1047     naviSrtRect.LayoutRect(

  1048         statusPaneRect,

  1049         AknLayoutScalable_Avkon::navi_pane_srt( 0 ) );        

  1050 

  1051     TRect rect( naviSrtRect.Rect() );

  1052         

  1053     // Set relative to navipane coordinates

  1054     rect.Move( -naviPaneRect.iTl.iX, 0 );

  1055     rect.iTl.iY = 0;

  1056     rect.SetHeight( naviSrtRect.Rect().Height() );

  1057 

  1058     return rect;

  1059     }

  1060 

  1061 

  1062 // ---------------------------------------------------------------------------

  1063 // CAknNavigationDecorator::DecoratedControlRect

  1064 // Returns the rectangle of the navigation decorator in relation to the

  1065 // navi pane.

  1066 // ---------------------------------------------------------------------------

  1067 //

  1068 TRect CAknNavigationDecorator::DecoratedControlRect( TInt aControlType,

  1069                                                      TBool aArrowsUsed )

  1070     {

  1071     TRect rect;

  1072 

  1073     switch ( aControlType )

  1074         {

  1075         case ETabGroup:

  1076             {

  1077             rect = DecoratedTabControlRect( ETrue, aArrowsUsed );

  1078             break;

  1079             }

  1080         case ENaviVolume:

  1081             {

  1082             rect = DecoratedVolumeControlRect();

  1083             break;

  1084             }

  1085         default:

  1086             {

  1087             rect = DecoratedDefaultControlRect();

  1088             break;

  1089             }

  1090         }

  1091 

  1092     return rect;

  1093     }

  1094 

  1095 

  1096 // ---------------------------------------------------------------------------

  1097 // CAknNavigationDecorator::DecoratedControlRect

  1098 // Returns the default rectangle of the navigation decorator.

  1099 // ---------------------------------------------------------------------------

  1100 //

  1101 TRect CAknNavigationDecorator::DecoratedDefaultControlRect()

  1102     {

  1103     TRect rect;

  1104     

  1105     TRect naviPaneRect;

  1106     AknLayoutUtils::LayoutMetricsRect( AknLayoutUtils::ENaviPane, naviPaneRect );

  1107 

  1108     if ( AknStatuspaneUtils::SmallLayoutActive() )

  1109         {

  1110         // screen

  1111         TRect screenRect;

  1112         AknLayoutUtils::LayoutMetricsRect( AknLayoutUtils::EScreen, screenRect );

  1113     

  1114         // top area

  1115         TAknLayoutRect topAreaLayoutRect;        

  1116         topAreaLayoutRect.LayoutRect(

  1117             screenRect,

  1118             AknLayoutScalable_Avkon::area_top_pane( 1 ) );

  1119         

  1120         // small statuspane      

  1121         TAknLayoutRect statusPaneLayoutRect;

  1122         statusPaneLayoutRect.LayoutRect(

  1123             topAreaLayoutRect.Rect(),

  1124             AknLayoutScalable_Avkon::status_small_pane() );

  1125         TRect statusPaneRect( statusPaneLayoutRect.Rect() );

  1126         

  1127         TAknWindowComponentLayout signalPaneLayout(

  1128             AknLayoutScalable_Avkon::status_small_pane_g2( 0 ) );

  1129         TAknLayoutRect signalPaneLayoutRect;

  1130         signalPaneLayoutRect.LayoutRect( statusPaneRect, signalPaneLayout );

  1131 

  1132         rect = statusPaneRect; 

  1133 

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