/*

* 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 ),

      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;

            default: