/*

* Copyright (c) 2002-2004 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 for wrapper for a menu

*

*/

// System includes

#include <utf.h>

#include <aknappui.h>

#include <e32base.h>

#include <coecntrl.h>

#include <eikbtgpc.h>

#include <eikcba.h>

#include <barsread.h>

#include <eiksoftkeyimage.h>

#include <aknlayoutscalable_avkon.cdl.h>

#include <layoutmetadata.cdl.h>

#include <AknStatuspaneUtils.h>

#include <AknUtils.h>

#include <AknIconUtils.h>

#include <eikspane.h>

#include <AknSgcc.h>

#include <aknview.h>

// User includes

#include "xnnodepluginif.h"

#include "xntype.h"

#include "xnproperty.h"

#include "xndompropertyvalue.h"

#include "xndomproperty.h"

#include "xndomlist.h"

#include "xnuienginepluginif.h"

#include "xncomponent.h"

#include "xnappuiadapter.h"

#include "xnbitmap.h"

#include "xnmenuadapter.h"

#include "xncomponentnodeimpl.h"

#include "c_xnutils.h"

#undef _AVKON_CBA_LSC

_LIT8( KWidgetSpecific, "Menu/WidgetSpecific" );

_LIT8( KViewSpecific, "Menu/ViewSpecific" );

_LIT8( KWidgetsHidden, "Menu/WidgetsHidden" );

_LIT8( KWidgetsShown, "Menu/WidgetsShown" );

_LIT8( KEditMode, "Menu/EditMode" );

_LIT8( KAlwaysShown, "Menu/AlwaysShown" );

_LIT8( KHsShowHelp, "hs_show_help" );

const TInt KMenuCommandFirst         = 6000;

const TInt KMenuCommandLast          = 6199;

const TInt KCBACommandFirst          = 6200;

const TInt KCBACommandSecond         = 6201;

const TInt KCBACommandMiddle         = 6202; 

const TInt KXnMenuArrayGranularity   = 6;

const TInt KWideScreenWidth          = 640;

using namespace XnPropertyNames;

static CXnNodePluginIf* FindChildL(CXnNodePluginIf& aNode, 

    const TDesC8& aType, const TDesC8& aTarget = KNullDesC8);

class CXnSoftkeyItem: public CBase

    { 

public:           

    CXnSoftkeyItem() 

    : iNode( NULL ),         

      iPosition( 0 ), 

      iCommandId( 0 ),      

      iLabel( NULL ),

      iBitmap( NULL ),

      iMask( NULL ),

      iImageOn( EFalse ),  

      iInvertMask( EFalse ),

      iPreserveAspectRatio( EFalse ),            

      iUpdateAppearance( ETrue ),

      iOwnBitmaps( ETrue ),

      iDefault( EFalse ),

      iId( KAknsIIDQsnIconColors ),

      iBmpFile( NULL ),

      iBmp( 0 ),

      iBmpM( 0 )

        {

        }  

    ~CXnSoftkeyItem()

        {

        Reset();            

        }

    void Reset()

        {

        delete iLabel;

        iLabel = NULL;        

        if ( iOwnBitmaps )

            {

            delete iBitmap;

            iBitmap = NULL;

            delete iMask;            

            iMask = NULL;            

            }

        else

            {

            iBitmap = NULL;

            iMask = NULL;

            }

        iImageOn = EFalse;        

        iInvertMask = EFalse;

        iPreserveAspectRatio = EFalse;

        delete iBmpFile;

        iBmpFile = NULL;

        }        

    CXnNodePluginIf* iNode;

    TInt             iPosition;

    TInt             iCommandId;    

    HBufC*           iLabel;

    CFbsBitmap*      iBitmap;

    CFbsBitmap*      iMask;    

    TBool            iImageOn;

    TBool            iInvertMask;

    TBool            iPreserveAspectRatio;    

    TBool            iUpdateAppearance;

    TBool            iOwnBitmaps;

    TBool            iDefault;

    TAknsItemID      iId;

    HBufC*           iBmpFile;

    TInt32           iBmp;

    TInt32           iBmpM;

    };

inline TAknWindowComponentLayout DoCompose( TAknWindowComponentLayout aLine1, 

    TAknWindowComponentLayout aLine2 ) 

    { 

    return TAknWindowComponentLayout::Compose( aLine1, aLine2 ); 

    }

inline TAknTextComponentLayout DoComposeText( TAknWindowComponentLayout aLine1, 

    TAknTextComponentLayout aLine2 ) 

    { 

    return TAknWindowComponentLayout::ComposeText( aLine1, aLine2 ); 

    }

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

// IsNodeVisibleL

// 

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

//

static TBool IsNodeVisibleL(CXnNodePluginIf& aNode)

    {          

    CXnProperty* propVisibility = aNode.VisibilityL();

    if( propVisibility )

        {

        const TDesC8& visibility = propVisibility->StringValue();

        if( visibility == XnPropertyNames::style::common::visibility::KHidden )

            {

            return EFalse;

            }    

        }

    CXnProperty* propDisplay = aNode.DisplayL();

    if( propDisplay )

        {

        const TDesC8& display = propDisplay->StringValue();

        if( display == XnPropertyNames::style::common::display::KNone )

            {

            return EFalse;

            }

        }

    CXnProperty* propDisabled = aNode.GetPropertyL( XnPropertyNames::common::KDisabled );

    if( propDisabled )

        {

        const TDesC8& disabled = propDisabled->StringValue();

        if( disabled == XnPropertyNames::KTrue )

            {

            return EFalse;

            }

        }

    return ETrue;

    }

#ifdef _AVKON_CBA_LSC

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

// 

// Calculate touch sensitive softkey area for Top button (landscape)

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

static TRect SoftkeyRectTopTouch()

    {

    TRect screen;

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

    TAknLayoutRect layoutRect;

    TAknWindowComponentLayout rightAreaLayout(

            AknLayoutScalable_Avkon::area_side_right_pane( 0 ) );

    layoutRect.LayoutRect( screen, DoCompose( rightAreaLayout,

            AknLayoutScalable_Avkon::sctrl_sk_top_pane() ).LayoutLine() );

    TRect topSKRect( layoutRect.Rect() );

    layoutRect.LayoutRect( topSKRect, 

                    AknLayoutScalable_Avkon::aid_touch_sctrl_top().LayoutLine() );

    return layoutRect.Rect();

    }

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

// 

// Calculate touch sensitive softkey area for right button (portrait)

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

static TRect SoftkeyRectRightTouch()

    {

    TRect screen;

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

    TAknLayoutRect layoutRect;

    TAknWindowComponentLayout bottomAreaLayout(

            AknLayoutScalable_Avkon::area_bottom_pane( 0 ) );

    layoutRect.LayoutRect( screen, DoCompose( bottomAreaLayout,

            AknLayoutScalable_Avkon::control_bg_pane() ).LayoutLine() );

    TRect rightSKRect( layoutRect.Rect() );

    layoutRect.LayoutRect(

    		rightSKRect,

            AknLayoutScalable_Avkon::aid_touch_ctrl_right().LayoutLine() );

    return layoutRect.Rect();

    }

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

// 

// Calculate touch sensitive softkey area for left button (portrait)

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

static TRect SoftkeyRectLeftTouch()

    {

    TRect screen;

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

    TAknLayoutRect layoutRect;

    TAknWindowComponentLayout bottomAreaLayout(

            AknLayoutScalable_Avkon::area_bottom_pane( 0 ) );

    layoutRect.LayoutRect( screen, DoCompose( bottomAreaLayout,

            AknLayoutScalable_Avkon::control_bg_pane() ).LayoutLine() );

    TRect leftSKRect( layoutRect.Rect() );

    layoutRect.LayoutRect(

    		leftSKRect,

            AknLayoutScalable_Avkon::aid_touch_ctrl_left().LayoutLine() );

    return layoutRect.Rect();

    }

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

// 

// Calculate touch sensitive softkey area for Bottom button (landscape)

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

static TRect SoftkeyRectBottomTouch()

    {

    TRect screen;

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

    TAknLayoutRect layoutRect;

    TAknWindowComponentLayout rightAreaLayout( AknLayoutScalable_Avkon::area_side_right_pane( 0 ) );

    layoutRect.LayoutRect( screen, DoCompose( rightAreaLayout,

                    AknLayoutScalable_Avkon::sctrl_sk_bottom_pane() ).LayoutLine() );

    TRect bottomSKRect( layoutRect.Rect() );

    layoutRect.LayoutRect( bottomSKRect,

                    AknLayoutScalable_Avkon::aid_touch_sctrl_bottom().LayoutLine() );

    return layoutRect.Rect();

    }

#endif

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

// 

// Calculate (whole) softkey area for Bottom button (landscape)

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

static TBool HDLayoutActive()

    {

    TInt resourceId = 0;

    CEikStatusPaneBase* statusPane = CEikStatusPaneBase::Current();

    if ( statusPane ) // Return the resource ID of app statuspane if it exists.

        {

        resourceId = statusPane->CurrentLayoutResId();

        }

    else // If this app does not have statuspane, then we ask the layout from AknCapServer.

        {

        resourceId = CAknSgcClient::CurrentStatuspaneResource();

        }    

    TBool retVal = EFalse;

    if ( Layout_Meta_Data::IsLandscapeOrientation() )

        {

        // Can be widescreen only in landscape orientation.

        retVal = ( resourceId == R_AVKON_WIDESCREEN_PANE_LAYOUT_USUAL ||

                   resourceId == R_AVKON_WIDESCREEN_PANE_LAYOUT_IDLE  ||

                   resourceId == R_AVKON_WIDESCREEN_PANE_LAYOUT_USUAL_FLAT ||

                   resourceId == R_AVKON_WIDESCREEN_PANE_LAYOUT_IDLE_FLAT );

        }

    return retVal;

    }

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

// 

// Calculate softkey image graphics area for Bottom button (landscape)

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

static TRect SoftkeyRectBottomGraphics()

    {

    TRect screen;

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

    TAknWindowComponentLayout rightAreaLayout(

        AknLayoutScalable_Avkon::area_side_right_pane( 0 ) );

    TAknWindowComponentLayout bottomSKLayout(

        DoCompose( rightAreaLayout,

                   AknLayoutScalable_Avkon::sctrl_sk_bottom_pane() ) );

    // Calculate softkey rects.

    // Left (bottom in landscape) softkey layout.

    TAknLayoutRect leftSoftkeyLayoutRect;

    leftSoftkeyLayoutRect.LayoutRect( screen,

                                      bottomSKLayout.LayoutLine() );

    TRect leftSoftKeyButtonRect( leftSoftkeyLayoutRect.Rect() );

    // Calculate softkey image layout.

    // Left (bottom in landscape) softkey layout.

    TAknWindowLineLayout leftSoftkeyImageLayout( 

        DoCompose(

            bottomSKLayout,

            AknLayoutScalable_Avkon::sctrl_sk_bottom_pane_g1() ).LayoutLine() );

    TAknLayoutRect qgn_graf_sk_left;

    qgn_graf_sk_left.LayoutRect( screen, leftSoftkeyImageLayout );

    return qgn_graf_sk_left.Rect();    

    }

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

// 

// Calculate softkey image graphics area for Top button (landscape)

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

static TRect SoftkeyRectTopGraphics()

    {

    TRect screen;

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

    TAknWindowComponentLayout rightAreaLayout(

        AknLayoutScalable_Avkon::area_side_right_pane( 0 ) );

    TAknWindowComponentLayout topSKLayout(

        DoCompose( rightAreaLayout,

                   AknLayoutScalable_Avkon::sctrl_sk_top_pane() ) );

    // Calculate softkey rects.

    // Right (top in landscape) softkey layout.

    TAknLayoutRect rightSoftkeyLayoutRect;

    rightSoftkeyLayoutRect.LayoutRect( screen,

                                       topSKLayout.LayoutLine() );

    TRect rightSoftKeyButtonRect( rightSoftkeyLayoutRect.Rect() );

    // Left (bottom in landscape) softkey layout.

    // Right (top in landscape) softkey layout.

    TAknWindowLineLayout rightSoftkeyImageLayout( 

        DoCompose(

            topSKLayout,

            AknLayoutScalable_Avkon::sctrl_sk_top_pane_g1() ).LayoutLine() );

    TAknLayoutRect qgn_graf_sk_right;

    qgn_graf_sk_right.LayoutRect( screen, rightSoftkeyImageLayout );

    return qgn_graf_sk_right.Rect();    

    }

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

// SoftkeyRectL

// Calculate soft key rect

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

static TRect SoftkeyRectL( CEikButtonGroupContainer& aContainer, TInt aPos, TBool aImageOn )

    {

    TRect rect;

    if( AknStatuspaneUtils::StaconPaneActive() )   

        {

        TInt variety( 0 );

        if( AknStatuspaneUtils::StaconSoftKeysLeft() )

            {

            variety = 1;

            }

        TRect parentRect( iAvkonAppUi->ApplicationRect() );

        switch( aPos )

            {

            case CEikButtonGroupContainer::ELeftSoftkeyPosition:

                {

                TAknWindowComponentLayout layout0( AknLayoutScalable_Avkon::area_bottom_pane( 2 ) );

                TAknWindowComponentLayout layout1( AknLayoutScalable_Avkon::stacon_bottom_pane() );

                // If clock is shown in stacon, cba area is smaller.

                TInt bottomCbaVariety( variety );

                if( AknStatuspaneUtils::ExtendedStaconPaneActive() )

                    {

                    bottomCbaVariety += 2;

                    }

                TAknWindowComponentLayout layout2( AknLayoutScalable_Avkon::control_bottom_pane_stacon( bottomCbaVariety ) );    

                if( aImageOn ) 

                    {

                    // Icon layout

                    TAknWindowComponentLayout iconLayout( AknLayoutScalable_Avkon::control_bottom_pane_stacon_g1() );

                    TAknWindowComponentLayout lskIconLayout( DoCompose( layout0, 

                        DoCompose( layout1, DoCompose( layout2, iconLayout ) ) ) );

                    TAknWindowLineLayout lskIcon( lskIconLayout.LayoutLine() );                    

                    TAknLayoutRect qgn_icon_lsk;

                    qgn_icon_lsk.LayoutRect( parentRect, lskIcon );

                    rect = qgn_icon_lsk.Rect();

                    }

                else

                    {

                    // Text layout

                    TAknTextComponentLayout textLayout( AknLayoutScalable_Avkon::control_bottom_pane_stacon_t1( variety ) );

                    TAknTextComponentLayout lskTextLayout( DoComposeText( layout0, 

                        DoComposeText( layout1, DoComposeText( layout2, textLayout ) ) ) );

                    TAknTextLineLayout lskText( lskTextLayout.LayoutLine() );                

                    TAknLayoutText qgn_text_lsk;

                    qgn_text_lsk.LayoutText( parentRect, lskText );

                    rect = qgn_text_lsk.TextRect();

                    }                       

                }

                break;

            case CEikButtonGroupContainer::ERightSoftkeyPosition:

                {                                            

                TAknWindowComponentLayout layout0( AknLayoutScalable_Avkon::area_top_pane( 2 ) );

                TAknWindowComponentLayout layout1( AknLayoutScalable_Avkon::stacon_top_pane() );

                TInt topCbaVariety( variety );

                if( AknStatuspaneUtils::ExtendedStaconPaneActive() )

                    {

                    topCbaVariety += 4;

                    }

                TAknWindowComponentLayout layout2( AknLayoutScalable_Avkon::control_top_pane_stacon( topCbaVariety ) );    

                if( aImageOn ) 

                    {

                    // Icon layout

                    TAknWindowComponentLayout iconLayout( AknLayoutScalable_Avkon::control_top_pane_stacon_g1() );

                    TAknWindowComponentLayout rskIconLayout( DoCompose( layout0, 

                        DoCompose( layout1, DoCompose( layout2, iconLayout ) ) ) );

                    TAknWindowLineLayout rskIcon( rskIconLayout.LayoutLine() );                    

                    TAknLayoutRect qgn_icon_rsk;

                    qgn_icon_rsk.LayoutRect( parentRect, rskIcon );

                    rect = qgn_icon_rsk.Rect();

                    }

                else

                    {

                    // Text layout                                                          

                    TAknTextComponentLayout textLayout( AknLayoutScalable_Avkon::control_top_pane_stacon_t1( variety ) );

                    TAknTextComponentLayout rskTextLayout( DoComposeText( layout0, 

                        DoComposeText( layout1, DoComposeText( layout2, textLayout ) ) ) );

                    TAknTextLineLayout rskText( rskTextLayout.LayoutLine() );                

                    TAknLayoutText qgn_text_rsk;

                    qgn_text_rsk.LayoutText( parentRect, rskText );

                    rect = qgn_text_rsk.TextRect();

                    }      

                }

                break;