/*

* Copyright (c) 2005-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:  Popup toolbar component

*

*/

// INCLUDE FILES

#include <akntoolbar.h>

#include <akntoolbarobserver.h> 

#include <aknbutton.h>  // CAknButton

#include <akntouchpane.h> // CAknTouchPane

#include "akntoolbaritem.h" 

#include <akntoolbarextension.h>

#include <barsread.h>   // TResourceReader

#include <eikfctry.h>   // SEikControlInfo

#include <eikappui.h>   // CEikAppUi

#include <eikpanic.h>

#include <avkon.hrh>

#include <eikon.hrh>    // toolbar flags

#include <aknappui.h>  

#include <systemwarninglevels.hrh> // KRAMGOODTHRESHOLD

#include <eikbtgpc.h>   // CEikButtonGroupContainer

#include <avkon.rsg>

#include <aknViewAppUi.h>

#include <aknview.h>

#include <AknsDrawUtils.h>

#include <AknsControlContext.h>

#include <aknlayout.cdl.h>

#include <skinlayout.cdl.h>

#include <aknlayoutscalable_avkon.cdl.h>

#include <AknUtils.h>

#include <AknsFrameBackgroundControlContext.h>

#include <layoutmetadata.cdl.h>

#include <AknPriv.hrh>

#include <hal.h>

#include <AknsMaskedLayerBackgroundControlContext.h>

#include <AknSgcc.h>

#include <AknStatuspaneUtils.h>

#include <AknsConstants.h>

#include <centralrepository.h>

#include <AknSkinsInternalCRKeys.h>

#include <eikdialg.h>

#include <eikapp.h>

#include <AknDef.h>

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

#include <touchfeedback.h>

#include <eikcolib.h>

#include <gfxtranseffect/gfxtranseffect.h> 

#include <akntranseffect.h>

#include <akntransitionutils.h>

#include "touchtoolbardata.h"

// CONSTANTS

const TInt KLineArrayGranularity = 5;

const TInt KFocusedNone = -1;

const TInt KSelectedNone = -2;

const TInt KToolbarButtonBeforeTimeout = 300; 

const TInt KToolbarButtonInViewTimeout = 5000; 

const TInt KFixedtoolbarButtons = 3; // Number of buttons fixed toolbar has to have

//const TUint32 KToolbarColorKey = 0x00000000; // ARGB

const TUint32 KToolbarBgColor = 0x00000000;

const TInt KToolBarBgAlpha = 0x7F;

#ifdef RD_SCALABLE_UI_V2

const TInt KDisableToolbar = 0xfff1; 

const TInt KEnableToolbar = 0xfff2; 

#endif

// toolbar's internal flags

enum TInternalFlags

    {

    EInIdle,                // toolbar is shown in idle view

    ESlidingSupported,      // whether toolbar can be show up with sliding effect if it is needed

    EWithSliding,           // defines whether toolbar should be shown with sliding effect

    ENoItemsVisible,        // used to check if no items are visible, this is needed to know if CBA needs to be created again

    EShown,                 // whether toolbar is shown right now( IsVisible() is not safe enough because can be changed from outside with MakeVisible()

    EShowingAgain,          // used to check if toolbar is shown again when allready shown, this is needed for not sliding when toolbar is allready shown

    ESliding,               // set if toolbar is currently sliding

    EFixedShown,            // tells to fixed toolbar if it needs to be shown when the layout is good

    ECalledFromFW,          // indicates to SetToolbarVisibility that it was called by the framework

    EAppOverrideVisibility, // indicates whether fixed toolbar visibility has been overriden by the application

    EDisabled,              // whether toolbar is disabled or not

    EDrawBackground,        // whether only toolbar background should be drawn

    EItemsHidden,            // whether application has called HideItemsAndDrawOnlyBackground

    EItemsHiddenWithPriority,    // whether application has called HideItemsAndDrawOnlyBackground with priority

    ESwitchForItemsHidden,   // switch for clearing EItemsHidden when the toolbar is to be shown

    EDefaultToolbar          //used for hideitemsanddrawonlybackground

    };

// Control stack priority for toolbar to enable view deactivation

const TInt KCoeStackToolbarPriority = ECoeStackPriorityCba; 

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

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

// CAknToolbar::NewL

// Two-phased constructor.

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

//

EXPORT_C CAknToolbar* CAknToolbar::NewL( const TInt aResourceId )

    {

    CAknToolbar* self = NewLC( aResourceId );

    CleanupStack::Pop( self );

    return self;

    }

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

// CAknToolbar::NewLC

// Two-phased constructor.

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

//

EXPORT_C CAknToolbar* CAknToolbar::NewLC( const TInt aResourceId )

    {

    CAknToolbar* self = new ( ELeave ) CAknToolbar();

    CleanupStack::PushL( self );

    self->ConstructL();

    self->ConstructFromResourceL( aResourceId );

    AKNTASHOOK_ADDL( self, "CAknToolbar" );

    return self;

    }

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

// CAknToolbar::CAknToolbar

// C++ default constructor.

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

//

CAknToolbar::CAknToolbar()

    : iItems( KLineArrayGranularity ),

      iVisibleItems( KLineArrayGranularity ),

      iFocusedItem( KFocusedNone ),

      iSelectedItem( KSelectedNone ),

      iInitialFocusedItem ( KFocusedNone ),

      iLastFocusedItem(  KFocusedNone ),

      iOrientation( EAknOrientationHorizontal ), 

      iSoftkeyResource( R_AVKON_SOFTKEYS_SELECT_CLOSE__SELECT ),

      iPreviousItem( KSelectedNone ),

      iDrawingPriority( ECoeWinPriorityLow )

    {

    CEikApplication* application = iAvkonAppUi->Application();

    if ( application )

        {

        TVwsViewId idleView;

        TInt err = AknDef::GetPhoneIdleViewId( idleView );

        if ( application->AppDllUid() == idleView.iAppUid )

            {

            iInternalFlags.Set( EInIdle );

            }

        }

    }

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

// Destructor

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

//

EXPORT_C CAknToolbar::~CAknToolbar()

    {

    AKNTASHOOK_REMOVE();

    SetFocus( EFalse );

    CEikonEnv::Static()->EikAppUi()->RemoveFromStack( this );

    iVisibleItems.Reset();

    iItems.ResetAndDestroy();

    delete iToolbarCba;    

    delete iFrameContext;

    delete iBgContext; 

    if ( iIdle && iIdle->IsActive() )

        {

        iIdle->Cancel(); 

        }

    delete iIdle; 

    iToolbarObserver = NULL; // not owned

    GfxTransEffect::Deregister( this );

    CTouchToolbarData* d = CTouchToolbarData::GetData( this );

    if ( d )

        {

        CAknTransitionUtils::RemoveObserver( d, 

            CAknTransitionUtils::EEventControlTransitionFinished );

        CAknTransitionUtils::RemoveData( reinterpret_cast<TInt>( this ) );

        delete d;

        }

    }

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

// CAknToolbar::ConstructL

// Symbian 2nd phase constructor.

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

//

void CAknToolbar::ConstructL()

    {            

    // create control's window

    CreateWindowL();

    SetFocusing( EFalse ); 

    DrawableWindow()->SetPointerGrab( ETrue );

    DrawableWindow()->SetShadowDisabled( ETrue );

    DrawableWindow()->SetOrdinalPosition( 0, ECoeWinPriorityNeverAtFront );

    CEikonEnv::Static()->EikAppUi()->AddToStackL( this, KCoeStackToolbarPriority,

        ECoeStackFlagRefusesFocus | ECoeStackFlagRefusesAllKeys );

    SetComponentsToInheritVisibility( ETrue );

    SetShown( EFalse );

    iBgIID = KAknsIIDNone;

    }

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

// CAknToolbar::CountComponentControls

// Gets the number of controls contained in a compound control.

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

//

EXPORT_C TInt CAknToolbar::CountComponentControls() const

    {

    return iVisibleItems.Count();

    }

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

// CAknToolbar::ConstructFromResourceL

// Constructs controls from a resource file.

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

//

void CAknToolbar::ConstructFromResourceL( TResourceReader& aReader )

    {

    aReader.ReadInt8(); //version, not used currently

    aReader.ReadInt8();  //lines, not used currently

    iFlags = aReader.ReadInt32();

    TBool enableTransparency = CAknEnv::Static()->TransparencyEnabled() && 

        ( ( !( iFlags & KAknToolbarFixed ) && 

                !( iFlags & KAknToolbarFloatingUnTransparent ) ) || 

        ( iFlags & KAknToolbarTransparent && iFlags & KAknToolbarFixed ) ); 

    if( enableTransparency ) 

        {

        Window().SetRequiredDisplayMode( EColor16MA ); // Without this, ACT does not work in all cases in HW

        TInt err = Window().SetTransparencyAlphaChannel();

        if ( err == KErrNone ) // it should all ways be true in NGA

            {

            // Set the window initially completely transparent. This needs to be called only once.

            Window().SetBackgroundColor(~0);

            }

        }

    iFrameContext = CAknsFrameBackgroundControlContext::NewL( KAknsIIDQsnFrPopupSub, 

            TRect(), TRect(), ( iFlags & KAknToolbarFixed )? ETrue : EFalse );  

    iBgContext = CAknsBasicBackgroundControlContext::NewL(

        KAknsIIDQsnBgScreen, TRect(), ETrue );

    SetWithSliding( ETrue ); 

    TInt softkeyResource = aReader.ReadUint32(); //softkeys

    if ( softkeyResource > 0 )

        {

        iSoftkeyResource = softkeyResource; 

        }

    const TInt controlCount = aReader.ReadInt16();

    for ( TInt ii = 0; ii < controlCount; ii++ )

        {

        CAknToolbarItem* item = ConstructControlLC( aReader ); 

        if ( item )

            {

            if ( IsSupportedItemType( item->ControlType() ) )

                {

                iItems.AppendL( item );

                CleanupStack::Pop( item ); 

                }

            else

                {

                // we don't support this type

                CleanupStack::PopAndDestroy( item ); 

                }

            }

        }

    aReader.ReadInt32(); // extension link, not used currently

    SetOrientation( iOrientation ); 

    // If toolbar is fixed need to set size for toolbar so that it can reduce 

    // the rects correctly. 

    if ( iFlags & KAknToolbarFixed )

        {

        if ( iFlags & KAknToolbarDefault )

            {

            SetDimmed( ETrue ); 

            }

        SetFocusing( EFalse ); 

        SetRect( CalculateSizeAndPosition() ); 

        }

    AdjustAllButtons();

    }

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

// CAknToolbar::ConstructFromResourceL

// Constructs controls from a resource file.

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

//

void CAknToolbar::ConstructFromResourceL( const TInt aResourceId ) 

    {    

    TResourceReader reader;

    iCoeEnv->CreateResourceReaderLC( reader, aResourceId );

    ConstructFromResourceL( reader );

    CleanupStack::PopAndDestroy();

    iToolbarResourceId = aResourceId;

    }

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

// CAknToolbar::ControlOrNull

// Gets a pointer to the specified control.

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

//

EXPORT_C CCoeControl* CAknToolbar::ControlOrNull( const TInt aControlId ) const

    {

    for ( TInt ii = 0; ii < iItems.Count(); ii++ )

        {

        CAknToolbarItem* item = iItems[ii];

        if ( item->CommandId() == aControlId )

            {

            return item->Control();

            }

        }

    return NULL;

    }

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

// CAknToolbar::SetToolbarVisibility

// Shows or hides toolbar.

// The position of the top left corner should be set in advance.

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

//

EXPORT_C void CAknToolbar::SetToolbarVisibility( const TBool aVisible )

    {

    SetToolbarVisibility( aVisible, ETrue );

    }

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

// CAknToolbar::SetToolbarVisibility

// If flag RD_SCALABLE_UI_V2 is not defined, toolbar is always focusing. 

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

//

EXPORT_C void CAknToolbar::SetToolbarVisibility( const TBool aVisible,

                                                 const TBool aFocusing )

    {

    if ( iInternalFlags.IsSet( EDisabled ) )

        {

        return; 

        }

    TBool visible = aVisible;

    if ( iInternalFlags.IsSet( ECalledFromFW ) )

        {

        if ( iInternalFlags.IsSet( EAppOverrideVisibility ) )

            {

            visible = EFalse;

            }

        }

    else

        {

        if ( aVisible )

            {

            iInternalFlags.Clear( EAppOverrideVisibility );

            }

        else

            {

            iInternalFlags.Set( EAppOverrideVisibility );

            }

        }        

    if ( iFlags & KAknToolbarFixed )

        {

        if ( visible )

            {

            iInternalFlags.Set( EFixedShown );

            }

        else

            {

            iInternalFlags.Clear( EFixedShown );

            }

        if ( visible && ( !AknLayoutUtils::PenEnabled() || 

            ( !Layout_Meta_Data::IsLandscapeOrientation() && iFlags & KAknToolbarDefault ) ) )

            {

            return; 

            }

        }

    if ( iFlags & KAknToolbarAlwaysFocusing )

        {

        SetFocusing( ETrue );

        }

    else

        {

#ifdef RD_SCALABLE_UI_V2

        if ( iFlags & KAknToolbarFixed )

            {

            SetFocusing( EFalse );             

            }

        else

            {

            SetFocusing( aFocusing );

            }

#else

        SetFocusing( ETrue ); 

#endif

        }

    if ( iInternalFlags.IsSet( EShown ) && visible )

        {

        if ( iFlags & KAknToolbarFixed )

            {

            return; 

            }

        if ( iInternalFlags.IsSet( EShown ) )

            {

            //using IsVisible() to avoide setting flag when toolbar is invisible.  

            if ( IsVisible() )

                {

                iInternalFlags.Set( EShowingAgain );

                }            

            ShowViaIdle(); 

            }

        return;

        }

    if ( visible )

        {

        if ( !(iFlags & KAknToolbarFixed ) )

            {

            ShowViaIdle(); 

            }

        else

            {

            TRAPD( err, ShowToolbarL() );

            if ( err != KErrNone )

                {

                // if we failed then softkeys should be deleted just in case if they 

                // were created before leave

                delete iToolbarCba;

                iToolbarCba = NULL;

                SetFocus( EFalse );

                CEikonEnv::Static()->EikAppUi()->UpdateStackedControlFlags( this, 

                    ~0, ECoeStackFlagRefusesFocus | ECoeStackFlagRefusesAllKeys );

                }

            }

        }

    else

        {

        TRAP_IGNORE( HideToolbarL() );

        }

    }

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

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

//

static CTouchToolbarData* CheckRegistration( CCoeControl* aControl )

    {

    TInt key = reinterpret_cast<TInt>( aControl );

    TBool selectPressed = EFalse;

    CTouchToolbarData* data = reinterpret_cast<CTouchToolbarData*>( 

                                        CAknTransitionUtils::GetData( key ) );

    if ( data && data->SelectPressed() )

        {

        selectPressed = ETrue;

        }

    // If we're not already registered from the touchpane, register here for

    // a toolbar transition without the touchpane.

    if ( !data || !data->BetweenRegisterAndBegin() )

        {

        // We need to reset the data here, to make sure that

        // DemarcationRectSet() is false below.

        TRect rect;

        if ( CTouchToolbarData::SetData( aControl, rect, EFalse ) != 

             KErrNone )

            {

            return NULL;

            }

        // if already registered, then the toolbar client may have chosen a different

        // effect for the toolbar

        if( !GfxTransEffect::IsRegistered( aControl ) )

            {

            GfxTransEffect::Register( aControl, KGfxToolbarControlUid, EFalse );

            }

        GfxTransEffect::Enable();