/*

* Copyright (c) 2002-2008 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

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

* which accompanies this distribution, and is available

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

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:  Implementation of the decorator class for navigation

*                pane controls.

*

*/

// SYSTEM INCLUDE FILES

#include <AknsUtils.h>

#include <AknsDrawUtils.h>

#include <aknlayoutscalable_avkon.cdl.h>

#include <layoutmetadata.cdl.h>

#include <touchfeedback.h>

#include <AknTasHook.h>

// USER INCLUDE FILES

#include "aknappui.h"

#include "aknconsts.h"

#include "aknnavilabel.h"

#include "aknnavide.h"

#include "AknNaviObserver.h"

#include "AknUtils.h"

#include "AknStatuspaneUtils.h"

#include "AknNaviDecoratorObserver.h"

#include "akntabgrp.h"

#include "akntitle.h"

#include "AknTitlePaneLabel.h"

const TInt KEikNavidePointerRepeatInterval = 500000;  // in micro seconds

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

NONSHARABLE_CLASS( CAknNavigationDecoratorExtension ) : public CBase

    {

public:

    enum

        {

        ENaviDecoratorNoSide = 0,

        ENaviDecoratorLeftSide,

        ENaviDecoratorRightSide

        };

public:

    static CAknNavigationDecoratorExtension* NewL();

    ~CAknNavigationDecoratorExtension();

private:

    CAknNavigationDecoratorExtension();

    CAknNavigationDecoratorExtension( const CAknNavigationDecoratorExtension* aExtension );

public:

    CPeriodic* iTimer;

    TInt iEffectTimerCount;

    TInt iOutermostRepeats;

    TInt iBlinkingSide;

    };

CAknNavigationDecoratorExtension* CAknNavigationDecoratorExtension::NewL()

    {

    CAknNavigationDecoratorExtension* naviExtension = 

        new (ELeave) CAknNavigationDecoratorExtension();

    return naviExtension;

    }

CAknNavigationDecoratorExtension::CAknNavigationDecoratorExtension() : 

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

    {

    }

CAknNavigationDecoratorExtension::~CAknNavigationDecoratorExtension()

    {

    }

// -----------------------------------------------------------------------------

// IsMaskAllBlack

//

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

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

//

// Returns: Boolean value.

// -----------------------------------------------------------------------------

//

static TBool IsMaskAllBlack( CFbsBitmap* bitmap )

    {

    if ( !bitmap )

        {

        return EFalse;

        }

    TSize size( bitmap->SizeInPixels() );

    if ( size.iWidth > 8 )

        {

        return EFalse;

        }

    TBuf8<8> scanLineBuf;

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

        {

        bitmap->GetScanLine( scanLineBuf,

                             TPoint( 0, y ),

                             size.iWidth,

                             EGray256 );

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

            {

            if ( scanLineBuf[x] != 0 )

                {

                return EFalse;

                }

            }

        }

    return ETrue;

    }

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

EXPORT_C CAknNavigationDecorator* CAknNavigationDecorator::NewL(

    CAknNavigationControlContainer* /*aNavigationControlContainer*/,

    CCoeControl* aDecoratedControl,

    TControlType aType )

    {

    CleanupStack::PushL( aDecoratedControl );

    CAknNavigationDecorator* self = new (ELeave) CAknNavigationDecorator;

    self->iDecoratedControl = aDecoratedControl;

    CleanupStack::Pop( aDecoratedControl );

    // Control type must be set before calling constructor.

    self->iControlType = aType;

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self ); // self

    AKNTASHOOK_ADDL( self, "CAknNavigationDecorator" );

    return self;

    }

EXPORT_C CAknNavigationDecorator::~CAknNavigationDecorator()

    {

    AKNTASHOOK_REMOVE();

    if ( iContainer )

        {

        iContainer->Pop( this );

        }

    if ( iLayoutStyleTimer )

        {

        iLayoutStyleTimer->Cancel();

        delete iLayoutStyleTimer;

        }

    if( iExtension && iExtension->iTimer )

        {

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

            {

            CancelTimer();

            }

        delete iExtension->iTimer;

        }

    delete iExtension;    

    delete iDecoratedControl;

    }

EXPORT_C void CAknNavigationDecorator::ConstructL()

    {

    iDecoratedControl->SetObserver( this );

    iNaviArrowsVisible    = EFalse;

    iNaviArrowLeftDimmed  = ETrue;

    iNaviArrowRightDimmed = ETrue;

    TBool isLandscape( Layout_Meta_Data::IsLandscapeOrientation() );

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

    if ( AknStatuspaneUtils::FlatLayoutActive() &&

         !isLandscape )

        {

        iLayoutFlags |= ENaviControlLayoutNarrow;

        iLayoutFlags |= ENaviControlLayoutModeForced;

        }

    // Wide layout is used in usual portrait mode,

    // except for tabs in non-touch layouts.

    else if ( AknStatuspaneUtils::UsualLayoutActive() &&

              !isLandscape &&

              ( iControlType != ETabGroup ||

                AknLayoutUtils::PenEnabled() ) )

        {

        iLayoutFlags |= ENaviControlLayoutWide;

        iLayoutFlags |= ENaviControlLayoutModeForced;

        }

    else

        {        

        iLayoutFlags |= ENaviControlLayoutNormal;

        iLayoutFlags |= ENaviControlLayoutModeAutomatic;

        }

    iExtension = CAknNavigationDecoratorExtension::NewL();

    ActivateL();

    }

EXPORT_C CCoeControl* CAknNavigationDecorator::DecoratedControl()

    {

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

    // function returns the CAknVolumeControl object which is a component

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

    // This is in order to maintain BC.

    if ( iControlType == ENaviVolume )

        {

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

        if ( volumeControl )

            {

            return volumeControl;

            }

        }

    return iDecoratedControl;

    }

EXPORT_C void CAknNavigationDecorator::MakeScrollButtonVisible( TBool aVisible )

    {

    TBool differ = ( iNaviArrowsVisible != aVisible );

    iNaviArrowsVisible = aVisible;

    if ( iControlType == ENaviLabel )

        {

        if ( iNaviArrowsVisible )

            {

            STATIC_CAST( CAknNaviLabel*, iDecoratedControl )->

                SetNaviLabelType( CAknNaviLabel::ENavigationLabel );

            }

        else

            {

            STATIC_CAST( CAknNaviLabel*, iDecoratedControl )->

                SetNaviLabelType( CAknNaviLabel::EAdditionalInfoLabel );

            }

        }

    else if ( iControlType == ETabGroup )

        {

        static_cast<CAknTabGroup*>(

            iDecoratedControl )->SetNaviArrowsVisible( aVisible );

        }

    if ( differ )

        {

        SizeChanged();

        }

    }

EXPORT_C TBool CAknNavigationDecorator::ScrollButtonVisible() const

    {

    return iNaviArrowsVisible;

    }

EXPORT_C void CAknNavigationDecorator::SetScrollButtonDimmed(

    TScrollButton aButton,

    TBool aDimmed )

    {

    if ( aButton == ELeftButton )

        {

        iNaviArrowLeftDimmed = aDimmed;

        if ( aDimmed )

            {

            iExtension->iBlinkingSide = 

                CAknNavigationDecoratorExtension::ENaviDecoratorRightSide;

            }

        }

    if ( aButton == ERightButton )

        {

        iNaviArrowRightDimmed = aDimmed;

        if ( aDimmed )

            {

            iExtension->iBlinkingSide = 

                CAknNavigationDecoratorExtension::ENaviDecoratorLeftSide;

            }

        }

    }

EXPORT_C TBool CAknNavigationDecorator::IsScrollButtonDimmed(

    TScrollButton aButton ) const

    {

    if ( aButton == ELeftButton )

        {

        return iNaviArrowLeftDimmed;

        }

    if ( aButton == ERightButton )

        {

        return iNaviArrowRightDimmed;

        }

    return ETrue;

    }

EXPORT_C void CAknNavigationDecorator::SetControlType( TControlType aType )

    {

    iControlType = aType;

    }

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

    {

    return iControlType;

    }

EXPORT_C void CAknNavigationDecorator::SizeChanged()

    {

    if ( iControlType == ENaviVolume )

        {

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

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

        // size changes.

        return;

        }

    TBool isLandscape( Layout_Meta_Data::IsLandscapeOrientation() );

    TBool flatLayout( AknStatuspaneUtils::FlatLayoutActive() );

    if ( isLandscape &&

         flatLayout &&

         !AknLayoutUtils::PenEnabled() &&

         NaviControlLayoutMode() == ENaviControlLayoutModeAutomatic &&

         NaviControlLayoutStyle() == ENaviControlLayoutNormal )

        {

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

            {

            InitLayoutStyleTimer();

            }            

        }

    else

        {

        CancelLayoutStyleTimer();

        }    

    TBool wideInUseInLsc( EFalse );

    if ( NaviControlLayoutStyle() != ENaviControlLayoutNarrow &&

         flatLayout &&

         !isLandscape )

        {

        iLayoutFlags &= ~ENaviControlLayoutNormal;

        iLayoutFlags &= ~ENaviControlLayoutWide;

        iLayoutFlags |= ENaviControlLayoutNarrow;

        }

    // Only flat layout supports narrow mode for now.

    if ( NaviControlLayoutStyle() == ENaviControlLayoutNarrow )

        {

        if ( !flatLayout ||

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

            {

            iLayoutFlags &= ~ENaviControlLayoutNarrow;           

            iLayoutFlags |= ENaviControlLayoutNormal; 

            }

        }

    // Wide layout is supported only in portrait mode.

    else if ( NaviControlLayoutStyle() == ENaviControlLayoutWide )

        {

        if ( Layout_Meta_Data::IsLandscapeOrientation() )

            {

            wideInUseInLsc = ETrue;

            }

        }

    if ( NaviControlLayoutStyle() == ENaviControlLayoutNarrow &&

         NaviControlLayoutStyleSupported( ENaviControlLayoutNarrow ) )

        {

        SizeChangedInNarrowLayout();

        }

    else if ( NaviControlLayoutStyle() == ENaviControlLayoutWide &&

              !wideInUseInLsc )

        {

        SizeChangedInWideLayout();

        }

    else // Normal layout

        {

        SizeChangedInNormalLayout();

        }

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

    // resize the navi arrows to correct size.

    if ( iContainer )

        {

        iContainer->NaviArrowBitmap( 0 );

        iContainer->NaviArrowBitmap( 1 );

        }

    }

void CAknNavigationDecorator::SizeChangedInNormalLayout()

    {

    TRect rect;

    TRect leftArrowRect;

    TRect rightArrowRect;

    CEikStatusPaneBase* statusPane = CEikStatusPaneBase::Current();

    if ( statusPane && 

         statusPane->CurrentLayoutResId() == R_AVKON_STATUS_PANE_LAYOUT_USUAL_EXT &&

         iControlType == ETabGroup )

        {

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

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

        TAknLayoutRect layoutRect;

        TRect screenRect;

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

        TBool isHDLayoutActive( AknStatuspaneUtils::HDLayoutActive() );

        TAknWindowComponentLayout topArea( 

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

        TAknWindowComponentLayout spLayout(

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

        TAknWindowComponentLayout layout(

                TAknWindowComponentLayout::Compose( topArea, spLayout ) );

        layoutRect.LayoutRect( screenRect, layout );

        TRect spRect( layoutRect.Rect() );

        layoutRect.LayoutRect(

            spRect,

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

        rect = layoutRect.Rect();

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

        leftArrowRect  = NaviArrowRect( ELeftButton,  EFalse, rect );

        rightArrowRect = NaviArrowRect( ERightButton, EFalse, rect );

        }

    else

        {

        rect = ParentRect();

        if ( iControlType == ENaviVolume &&

             !Layout_Meta_Data::IsLandscapeOrientation() &&

             AknStatuspaneUtils::SmallLayoutActive() )

            {

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

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

            // so normal navi arrow positions are used.

            // These layout data items aren't mirrored.

            TBool layoutMirrored( AknLayoutUtils::LayoutMirrored() );

            TRect naviPaneRect;

            AknLayoutUtils::LayoutMetricsRect( AknLayoutUtils::ENaviPane,

                                               naviPaneRect );

            naviPaneRect.Move( -naviPaneRect.iTl.iX,

                               -naviPaneRect.iTl.iY );

            TAknLayoutRect layoutRect;

            layoutRect.LayoutRect(

                naviPaneRect,

                layoutMirrored ?

                    AknLayoutScalable_Avkon::status_small_pane_g6( 0 ) :

                    AknLayoutScalable_Avkon::status_small_pane_g5( 0 ) );

            leftArrowRect = layoutRect.Rect();

            layoutRect.LayoutRect(

                naviPaneRect,

                layoutMirrored ?

                    AknLayoutScalable_Avkon::status_small_pane_g5( 0 ) :

                    AknLayoutScalable_Avkon::status_small_pane_g6( 0 ) );

            rightArrowRect = layoutRect.Rect();   

            }

        else

            {

            leftArrowRect = NaviArrowRect( ELeftButton );

            rightArrowRect = NaviArrowRect( ERightButton );

            }

        }

    if ( iControlType == ETabGroup )

        {

        rect = DecoratedTabControlRect( AknLayoutUtils::PenEnabled(),

                                        ETrue );

        }

    iArrowRightSize = rightArrowRect.Size();

    iArrowLeftSize  = leftArrowRect.Size();

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

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

    TSize rectSize( rect.Size() );

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

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

    if ( iControlType == ETabGroup )

        {

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

        TRAP_IGNORE( tabGroup->SetNarrowTabLayoutL( EFalse ) );

        }

    if ( ScrollButtonVisible() )

        {

        iDecoratedControl->SetRect( rect );

        }

    else

        {

        iDecoratedControl->SetRect( Rect() );

        }

    }

void CAknNavigationDecorator::SizeChangedInNarrowLayout()

    {