/*

* Copyright (c) 2005-2007 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 concrete touch pane class.

*

*/

// INCLUDE FILES

#include <eikaufty.h>   // MEikAppUiFactory

#include <eikenv.h>     // CEikonEnv

#include <eikapp.h>     // CEikApplication

#include <eikpanic.h>

#include <AknCapServerClient.h> // RAknUiServer

#include <barsread.h>           // TResourceReader

#include <AknDef.h>             // View ids

#include <AknsUtils.h>

#include <AknsDrawUtils.h>

#include <AknsFrameBackgroundControlContext.h>

#include <aknview.h>            // CAknView

#include <aknViewAppUi.h>       // CAknViewAppUi

#include <StringLoader.h>       // StringLoader

#include <hlplch.h>             // HlpLauncher

#include <AknSgcc.h>

#include <AknUtils.h>

#include <AknStatuspaneUtils.h>

#include <aknbutton.h>

#include <akntoolbar.h>

#include <aknfeppensupportinterface.h> // MAknFepPenSupportInterface

#include <AknCapServerDefs.h>

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

#include <avkon.mbg>

#include <avkon.rsg>

#include <aknpriv.rsg>

#include <layoutmetadata.cdl.h>

#include <aknlayoutscalable_avkon.cdl.h>

#include <gfxtranseffect/gfxtranseffect.h> 

#include <akntranseffect.h>

#include <akntransitionutils.h>

#include "touchtoolbardata.h"

#include "akntouchpane.hrh"

#include "akntouchpane.h"

#ifdef RD_SCALABLE_UI_V2

const TInt KDisableToolbar = 0xfff1;

const TInt KEnableToolbar = 0xfff2;

// UIDs for contacts application.

#ifdef RD_PHONEBOOK2

#define KAknTouchPaneContactsAppUid TUid::Uid(0x101f4cce)

#else

#define KAknTouchPaneContactsAppUid TUid::Uid(0x101f87b1)

#endif

#define KAknTouchPaneContactsViewUid TUid::Uid(1)

// UIDs for dialler application.

#define KAknTouchPaneDiallerAppUid TUid::Uid(0x100058B3)

#define KAknTouchPaneDiallerViewUid TUid::Uid(0x10282D81)

#define KTouchPaneDiallerVievCommand TUid::Uid(0x1)

#define KAknTouchPaneHelpAppUid TUid::Uid(0x10005234)

#define KAknTouchPaneAutoLockAppUid TUid::Uid(0x100059B5)

// Class for storing touch pane item description.

class TAknTouchPaneItem

    {

public:

    TAknTouchPaneItem()

        : iPriority( -1 ),

          iId( ETouchPaneElementNone ),

          iPlugin( NULL ) {}

    TInt iPriority;

    TUint iId;

    TUint iPlugin;

    };

// Enumeration for touch pane flags.

enum TAknTouchPaneFlags

    {

    ENoAutomaticVisibilityChanges   = 0,

    ETouchPaneActive                = 1,

    EHasForeground                  = 2,

    EShellIconActive                = 3,

    ESwapperIconActive              = 4,

    EIdleViewIconActive             = 5,

    EDiallerIconActive              = 6,

    ERotateIconActive               = 7,

    EHelpIconActive                 = 8,

    EInputMethodIconActive          = 9,

    EToolbarIconActive              = 10,

    EContactsIconActive            = 11

    };

#endif // RD_SCALABLE_UI_V2

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

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

// RectFromLayout

// Gets a rect by mapping the given component layout with the given parent

// rect.

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

//

#ifdef RD_SCALABLE_UI_V2

TRect RectFromLayout( const TRect& aParent,

    const TAknWindowComponentLayout& aComponentLayout )

    {

    TAknLayoutRect layoutRect;

    layoutRect.LayoutRect( aParent, aComponentLayout.LayoutLine() );

    return layoutRect.Rect();

    }

#endif // RD_SCALABLE_UI_V2

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

// Reads default touch pane content from the resources.

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

//

#ifdef RD_SCALABLE_UI_V2

TUint ReadDefaultTouchPaneContentL( RArray<TAknTouchPaneItem>& aItems )

    {

    TResourceReader reader;

    CEikonEnv::Static()->CreateResourceReaderLC( reader, R_AKNPRIV_TOUCHPANE );

    TUint flags = reader.ReadUint32();

    TAknTouchPaneItem item;

    for ( TUint itemCount = reader.ReadInt16(); itemCount > 0; itemCount-- )

        {

        TUint version = reader.ReadUint8();

        if ( version != 1 )

            {

            User::Leave( KErrNotSupported );

            }

        item.iPriority = reader.ReadUint8();

        item.iId = reader.ReadUint8();

        item.iPlugin = reader.ReadUint32();

        aItems.AppendL( item );

        }

    CleanupStack::PopAndDestroy(); // reader

    return flags;

    };

#endif // RD_SCALABLE_UI_V2

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

// Reads the given resource and modifies the given item set based on the

// customizations specified in the resource.

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

//

#ifdef RD_SCALABLE_UI_V2

void ReadCustomTouchPaneContentL( TInt aResourceId,

    RArray<TAknTouchPaneItem>& aItems, TBool aAllowCustomization )

    {

    TResourceReader reader;

    CEikonEnv::Static()->CreateResourceReaderLC( reader, aResourceId );

    // Check resource version.

    const TUint version = reader.ReadUint8();

    if ( version != 1 )

        {

        User::Leave( KErrNotSupported );

        }

    // Read application specific touch pane flags.

    const TUint flags = reader.ReadUint32();

    if ( flags & EAknNoTouchPane )

        {

        aItems.Reset();

        }

    else if ( aAllowCustomization && ( flags & EAknCustomTouchPane ) )

        {

        const TInt itemCount = reader.ReadInt16();

        for ( TInt ii = itemCount; ii > 0; --ii )

            {

            // Read custom item.

            const TInt version = reader.ReadInt8();

            if ( version != 1 )

                {

                User::Leave( KErrNotSupported );

                }

            const TUint id = reader.ReadUint8();

            const TUint plugin = reader.ReadUint32();

            // Find optional item with lowest priority.

            TInt optionalItemPriority = 0;

            TInt optionalItemIndex = -1;

            for ( TInt jj = aItems.Count() - 1; jj >= 0; --jj )

                {

                if ( aItems[jj].iPriority > optionalItemPriority )

                    {

                    optionalItemPriority = aItems[jj].iPriority;

                    optionalItemIndex = jj;

                    }

                }

            // Replace optional item.

            if ( optionalItemIndex >= 0 )

                {

                aItems[optionalItemIndex].iPriority = -1;

                aItems[optionalItemIndex].iId = id;

                aItems[optionalItemIndex].iPlugin = plugin;

                }

            }

        }

    CleanupStack::PopAndDestroy(); // reader

    return;

    }

#endif // RD_SCALABLE_UI_V2

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

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

// CAknTouchPane::CAknTouchPane

// C++ default constructor.

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

//

#ifdef RD_SCALABLE_UI_V2

CAknTouchPane::CAknTouchPane()

    : iAppUi( iAvkonAppUi ),

      iUid( TUid::Null() )

    {

    __ASSERT_DEBUG( iAppUi, User::Invariant() );

    SetMopParent( iAppUi );

    CApaApplication* application = iAppUi->Application();

    if ( application )

        {

        iUid = application->AppDllUid();

        }

    iFlags.Assign( ETouchPaneActive, iUid != KAknTouchPaneAutoLockAppUid );

    }

#endif // RD_SCALABLE_UI_V2

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

// CAknTouchPane::ConstructL

// Symbian 2nd phase constructor.

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

//

#ifdef RD_SCALABLE_UI_V2

void CAknTouchPane::ConstructL( RArray<TAknTouchPaneItem>& aItems )

    {

    CreateWindowL();

    Window().SetPointerGrab( ETrue );

    Window().SetNonFading( ETrue );

    Window().SetOrdinalPosition( 0, ECoeWinPriorityHigh );

    SetFocusing( EFalse );

    InitComponentArrayL();

    CCoeControl* component = NULL;

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

        {

        if ( aItems[ii].iId != ETouchPaneElementPlugin )

            {

            component = ConstructDefaultComponentL( aItems[ii].iId );

            }

        if ( component )

            {

            Components().AppendLC( component, KCoeNoControlId );

            CleanupStack::Pop( component );

            component = NULL;

            }

        }

    iBgContext = CAknsBasicBackgroundControlContext::NewL(

        KAknsIIDQsnBgScreen, TRect(), ETrue );

    iFrameContext = CAknsFrameBackgroundControlContext::NewL(

        KAknsIIDNone, TRect(), TRect(), ETrue );

    // Touch pane is set visible only in touch layouts.

    if ( AknLayoutUtils::PenEnabled() && Layout_Meta_Data::IsTouchPaneEnabled() )

        {

        SetWindowLayout();

        CCoeControl::MakeVisible( ETrue );

        }

    else

        {

        CCoeControl::MakeVisible( EFalse );

        }

    ActivateL();

    }

#endif // RD_SCALABLE_UI_V2

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

// CAknTouchPane::NewL

// Two-phased constructor.

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

//

#ifdef RD_SCALABLE_UI_V2

EXPORT_C CAknTouchPane* CAknTouchPane::NewL()

    {

    return CAknTouchPane::NewL( NULL );

    }

#else

EXPORT_C CAknTouchPane* CAknTouchPane::NewL()

    {

    return NULL;

    }

#endif // RD_SCALABLE_UI_V2

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

// CAknTouchPane::NewL

// Two-phased constructor.

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

//

#ifdef RD_SCALABLE_UI_V2

EXPORT_C CAknTouchPane* CAknTouchPane::NewL( TInt aResourceId )

    {

    RArray<TAknTouchPaneItem> items;

    CleanupClosePushL( items );

    const TUint flags = ReadDefaultTouchPaneContentL( items );

    if ( aResourceId )

        {

        ReadCustomTouchPaneContentL( aResourceId, items,

            !( flags & EAknDisabeTouchPaneCustomizations ) );

        }

    else if ( !( flags & EAknConstructTouchPaneByDefault ) )

        {

        items.Reset();

        }

    CAknTouchPane* self = NULL;

    if ( items.Count() )

        {

        self = new ( ELeave ) CAknTouchPane;

        CleanupStack::PushL( self );

        self->ConstructL( items );

        CleanupStack::Pop( self );

        }

    CleanupStack::Pop( &items );

    items.Close();

    AKNTASHOOK_ADDL( self, "CAknTouchPane" );

    return self;

    }

#else

EXPORT_C CAknTouchPane* CAknTouchPane::NewL( TInt )

    {

    return NULL;

    }

#endif // RD_SCALABLE_UI_V2

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

// CAknTouchPane::~CAknTouchPane

// Destructor.

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

//

EXPORT_C CAknTouchPane::~CAknTouchPane()

    {

    AKNTASHOOK_REMOVE();

#ifdef RD_SCALABLE_UI_V2

    DeregisterControlPositions();

    if ( iAppUi )

        {

        iAppUi->RemoveFromStack( this );

        iAppUi = NULL; // Not owned

        }

    // Although, these elements are owned by touch pane, they are deleted

    // through component array.

    iShellIcon = NULL;

    iSwapperIcon = NULL;

    iIdleViewIcon = NULL;

    iDiallerIcon = NULL;

    iRotateIcon = NULL;

    iHelpIcon = NULL;

    iInputMethodIcon = NULL;

    iToolbarIcon = NULL;

    iContactsIcon = NULL;

    iObserver = NULL; // Not owned

    delete iBgContext;

    delete iFrameContext;

#endif // RD_SCALABLE_UI_V2

    }

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

// CAknTouchPane::ReduceRect

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

//

#ifdef RD_SCALABLE_UI_V2

EXPORT_C void CAknTouchPane::ReduceRect( TRect& aBoundingRect ) const

    {

    if ( !IsVisible() )

        {

        return;

        }

    TRect rect( Position(), Size() );

    if ( rect.Intersects( aBoundingRect ) )

        {

        rect.Intersection( aBoundingRect );

        if ( Layout_Meta_Data::IsLandscapeOrientation() )

            {

            aBoundingRect.iTl.iX = rect.iBr.iX;

            }

        else 

            {

            aBoundingRect.iTl.iY = rect.iBr.iY;

            }

        }

    }

#else

EXPORT_C void CAknTouchPane::ReduceRect( TRect& ) const

    {

    }

#endif // RD_SCALABLE_UI_V2

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

// CAknTouchPane::SetObserver

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

//

#ifdef RD_SCALABLE_UI_V2

EXPORT_C void CAknTouchPane::SetObserver( MAknTouchPaneObserver* aObserver )

    {

    iObserver = aObserver;

    }

#else

EXPORT_C void CAknTouchPane::SetObserver( MAknTouchPaneObserver* )

    {

    }

#endif // RD_SCALABLE_UI_V2

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

// CAknTouchPane::SetVisibilityMode

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

//

EXPORT_C void CAknTouchPane::SetVisibilityMode( TVisibilityMode aMode )

    {

#ifdef RD_SCALABLE_UI_V2

    if ( aMode == EAutomaticVisibilityChanges )

        {

        iFlags.Clear( ENoAutomaticVisibilityChanges );

        }

    else if ( aMode == EManualVisibilityChanges )

        {

        iFlags.Set( ENoAutomaticVisibilityChanges );

        }

#else

    (void)aMode;

#endif // RD_SCALABLE_UI_V2

    }

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

// CAknTouchPane::AllowInputMethodActivation

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

//

#ifdef RD_SCALABLE_UI_V2

EXPORT_C void CAknTouchPane::AllowInputMethodActivation( TBool aValue )

    {

    if ( iInputMethodIcon )

        {

        iFlags.Assign( EInputMethodIconActive, aValue );

        // Icon dimming is updated only when touch pane is active.

        if ( iFlags.IsSet( ETouchPaneActive ) )

            {

            iInputMethodIcon->SetDimmed( !aValue );

            Window().Invalidate( iInputMethodIcon->Rect() );

            }

        }

    }

#else

EXPORT_C void CAknTouchPane::AllowInputMethodActivation( TBool )

    {

    }

#endif // RD_SCALABLE_UI_V2

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

// CAknTouchPane::SetInputMethodIconActivated

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

//

#ifdef RD_SCALABLE_UI_V2

EXPORT_C void CAknTouchPane::SetInputMethodIconActivated( TBool aActivated )

    {

    if ( iInputMethodIcon )

        {

        iInputMethodIcon->SetCurrentState( aActivated ? 1 : 0, 

            !iInputMethodIcon->IsDimmed() );

        }

    }

#else

EXPORT_C void CAknTouchPane::SetInputMethodIconActivated( TBool )

    {

    }

#endif // RD_SCALABLE_UI_V2

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

// CAknTouchPane::RefreshL

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

//

EXPORT_C void CAknTouchPane::RefreshL()

    {

#ifdef RD_SCALABLE_UI_V2

    if ( iHelpIcon && iUid != KAknTouchPaneHelpAppUid )

        {

        CArrayFix<TCoeHelpContext>* help = iAppUi->AppHelpContextL();

        TBool helpActive = help && help->Count();

        iFlags.Assign( EHelpIconActive, helpActive );