/*

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

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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:  This class represents the Widget Extension object

*

*/

// INCLUDE FILES

#include "MenuClient.h"

#include "MenuItemClient.h"

#include "Menu.h"

#include "MenuItem.h"

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES

// CONSTANTS

const TInt KMenuItemCommandIdBase = 20000;

const TInt KMaxOptionsMenu = 63;

// MACROS

// LOCAL CONSTANTS AND MACROS

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// The binary tree representation of a multiway tree is based on

// first child-next sibling representation of the tree. In this representation

// every node is linked with its leftmost child and its next (right nearest)

// sibling.

/*

Example: Consider the following multiway tree

                        1

                      / | \

                     /  |  \

                    /   |   \

                   2    3    4

                  / \        |

                 5   6       7

                            / \

                           8   9

This tree can be represented in first child-next sibling manner as follows :

                        1

                       /

                      /

                     /

                    2---3---4

                   /       /

                  5---6   7

                         /

                        8---9

If we look at the first child-next sibling representation of the tree closely,

we will see that it forms a binary tree. To see this better, rotate every

next-sibling edge 45 degrees clockwise. After that, the following binary tree is got:

                        1

                       /

                      2

                     / \

                    5   3

                     \   \

                      6   4

                         /

                        7

                       /

                      8

                       \

                        9

*/

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

// CMenuClient::NewL

//

//

//

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

CMenuClient* CMenuClient::NewL(MWidgetCallback& aWidgetCallback, 

                               MWidgetEngineCallbacks& aWidgetEngineCallback)

{

    CMenuClient* self = new ( ELeave ) CMenuClient(aWidgetCallback,aWidgetEngineCallback);

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    return self;

}

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

// CMenuClient::CMenuClient

//

//

//

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

CMenuClient::CMenuClient(MWidgetCallback& aWidgetCallback, 

                         MWidgetEngineCallbacks& aWidgetEngineCallback) : 

                        iWidgetCallback(&aWidgetCallback), 

                        m_widgetenginecallback(&aWidgetEngineCallback),

                        m_jsmenu(0),            

                        m_jsmenuitemctr(0)

{

}

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

// CMenuClient::~CMenuClient

//

//

//

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

CMenuClient::~CMenuClient()

{

    // delete tree

    if ( iMenuRoot )

        {

        deleteTree( iMenuRoot->firstChild() );

        delete iMenuRoot;

        iMenuRoot = NULL;

        }

    iCascadeArr.Close();

}

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

// CMenuClient::ConstructL

//

//

//

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

void CMenuClient::ConstructL()

{        

}

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

// CMenuClient::jsmenu

//

//

//

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

KJS::JSMenu* CMenuClient::jsmenu(MJSObjectProtector* aProtector) 

{ 

    if (!m_jsmenu) {

        m_jsmenu = new KJS::JSMenu(this, aProtector);

    }

    return m_jsmenu; 

}

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

// CMenuClient::jsmenuitem

//

//

//

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

KJS::JSMenuItemConstructor* CMenuClient::jsmenuitem(MJSObjectProtector* protector) 

{

    if (!m_jsmenuitemctr){

        m_jsmenuitemctr = new KJS::JSMenuItemConstructor(this, protector);

    }

    return m_jsmenuitemctr;    

}

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

// CMenuClient::addOptionMenuItemsL

//

//

//

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

//

void CMenuClient::addOptionMenuItemsL(CEikMenuPane& aMenuPane, TInt aResourceId)

{

    CMenuItem* node = NULL;

    CMenuItem* parentNode = NULL;

    TInt parentInternalId = -1;

    //one of the cascade menu pane

    if ( aResourceId >= R_CASCADE_MENU_1 )  {

        for ( TInt i = 0; i < iCascadeArr.Count(); i++ ) {

            if ( iCascadeArr[i].iResourceId == aResourceId ) {

                parentInternalId = iCascadeArr[i].parentInternalId;

                parentNode = findNodeById( iMenuRoot, parentInternalId, EReal );

                if ( parentNode )

                    break;

            }

        }

        if ( parentInternalId != -1 && parentNode ) {

            menuItemSelected( parentInternalId + KMenuItemCommandIdBase );

            node = parentNode->firstChild();

        }

    }

    else {

        // constructing root pane

        iResourceId = R_CASCADE_MENU_1;

        //invoke menu onshow callback

        if ( m_jsmenu && m_jsmenu->onShowCallback() ) {

            m_jsmenu->onShowCallback()->InvokeCall();

        }

        if ( aMenuPane.NumberOfItemsInPane() > 1 ) {

            aMenuPane.DeleteBetweenMenuItems( 0, aMenuPane.NumberOfItemsInPane() - 2 );

        }

        if ( iMenuRoot ) {

            node = iMenuRoot->firstChild();

        }

    }

    if ( node ) {

        //add first child

        addMenuItem( aMenuPane, node, parentInternalId == -1 );

        //add all other children (siblings of first child)

        CMenuItem* sibling = node->nextSibling();

        while( sibling ) {

            addMenuItem( aMenuPane, sibling, parentInternalId == -1 );

            sibling = sibling->nextSibling();

        }

    }

}

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

// CMenuClient::menuShowed

//

//

//

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

void CMenuClient::menuShowed()

{

    if ( m_jsmenu && m_jsmenu->onShowCallback() ) {

        m_jsmenu->onShowCallback()->InvokeCall();

    }

}

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

// CMenuClient::menuItemSelected

//

//

//

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

void CMenuClient::menuItemSelected( TInt aInternalId )

{

    TInt cmdId = 0;

    if (menuItemObserver(aInternalId, cmdId )) {

        menuItemObserver(aInternalId, cmdId)->InvokeCall(cmdId);

    }

}

////////////////////////////////////////////////////////////////////////////////

// From MWidgetExtension

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

// CMenuClient::HandleCommandL

//

//

//

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

//

TBool CMenuClient::HandleCommandL( TInt aCommandId )

{

    if ( aCommandId == EAknSoftkeyExit && m_jsmenu && m_jsmenu->rightKeyCallback() ) {

        m_jsmenu->rightKeyCallback()->InvokeCall();

        return ETrue;

    }

    if ( aCommandId == EAknSoftkeyOptions && m_jsmenu && m_jsmenu->leftKeyCallback() ) {

            m_jsmenu->leftKeyCallback()->InvokeCall();

            return ETrue;

    }

    return EFalse;

}

////////////////////////////////////////////////////////////////////////////////

//From MJSMenuCallbacks

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

// CMenuClient::setRightSoftKeyLabel

//

//

//

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

//

void CMenuClient::setRightSoftKeyLabel( const TDesC& aText )

{

    m_widgetenginecallback->setRightSoftKeyLabel(aText); 

}

////////////////////////////////////////////////////////////////////////////////

//From MJSMenuCallbacks

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

// CMenuClient::setLeftSoftKeyLabel

//

//

//

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

//

void CMenuClient::setLeftSoftKeyLabel( const TDesC& aText )

{

    m_widgetenginecallback->setLeftSoftKeyLabel(aText); 

}

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

// CMenuClient::clearMenuItems

//

//

//

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

//

void CMenuClient::clearMenuItems()

{

    if ( iMenuRoot )

        showTree( iMenuRoot->firstChild(), EFalse );  

}

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

// CMenuClient::getFromMenuItemCollection

//

//

//

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

//

void* CMenuClient::getFromMenuItemCollection( const TDesC& aTextVal ) 

{

    CMenuItem* node = NULL;

    node = findNodeByText( iMenuRoot, aTextVal );

    if ( node )

        return node->obj();

    return NULL;

}

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

// CMenuClient::getFromMenuItemCollection

//

//

//

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

//

void* CMenuClient::getFromMenuItemCollection( TInt aCmdId ) 

{

    CMenuItem* node = NULL;

    node = findNodeByCmdId( iMenuRoot, aCmdId );

    if ( node )

        return node->obj();

    return NULL;

}

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

// CMenuClient::hideSoftkeys

//

//

//

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

//

void CMenuClient::hideSoftkeys()

{    

    iWidgetCallback->SetSoftkeysVisible(EFalse);

}

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

// CMenuClient::showSoftkeys

//

//

//

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

//

void CMenuClient::showSoftkeys()        

{   

    iWidgetCallback->SetSoftkeysVisible(ETrue);

}

////////////////////////////////////////////////////////////////////////////////

//From MJSMenuItemCallbacks

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

// CMenuClient::createOptionsMenuItem

//

//

//

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

//

TInt CMenuClient::createOptionsMenuItem( const TDesC& aText, TInt aCmdId, TInt aInternalId, void* aObj )

{    

    if ( !iMenuRoot ) {

        iMenuRoot = CMenuItem::NewL( _L(""), -1, -1 );

    }

    CMenuItem* item = CMenuItem::NewL(aText, aCmdId, aInternalId, EFalse, iMenuRoot, aObj, EFalse);

    return append( iMenuRoot, item );            

}

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

// CMenuClient::addOptionsMenuItem

//

//

//

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

//

TInt CMenuClient::addOptionsMenuItem( TInt aInternalId, TInt aParentInternalId, TBool aShow )

{    

    if ( !iMenuRoot ) {

        iMenuRoot = CMenuItem::NewL( _L(""), -1, -1 );

    }    

    // Find item in actual or real tree by the internal id

    CMenuItem* item = findNodeById( iMenuRoot, aInternalId, ERealOrVirtual );

    if ( !item )

        return KErrGeneral;

    if ( aShow ) {

        // if there is a clash by cmdid or text of this item or any of its descendents 

        // with any real tree item return KErrAlreadyExists

        if ( findNodeByCmdId( iMenuRoot, item->cmdId() ) || 

            findNodeByText( iMenuRoot, item->text() ) || 

            isDuplicate( item->firstChild() ) ) {

            return KErrAlreadyExists;

        }

    }

    // Find parent in real or virtual tree

    CMenuItem* parent = findNodeById( iMenuRoot, aParentInternalId, ERealOrVirtual );

    // if this is a new parent, rearrange the tree

    CMenuItem* currParent = item->parent();

    if ( ( aParentInternalId == -1 && aShow ) || 

        ( currParent && currParent->internalId() != aParentInternalId ) ) {

        rearrangeTree( parent, item, aShow );// item is deleted in RearrangeTree

        return KErrNone;

    }

    return KErrGeneral;

}

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

// CMenuClient::deleteMenuItem

//

//

//

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

//

void CMenuClient::deleteMenuItem( TInt aInternalId )

{    

    CMenuItem* item = NULL;

    CMenuItem* node = findNodeById( iMenuRoot, aInternalId, EReal );

    if ( !node )

        return;

    CMenuItem* parent = node->parent();

    if ( !parent || !parent->firstChild() )

        return;

    //it could be first child

    if ( parent->firstChild()->internalId() == aInternalId ) {

        item = parent->firstChild();

        //the sibling of firstchild will be the new firstchild

        parent->setFirstChild( item->nextSibling() );

    }    

    //or one of the sibling of firstchild

    else {

        CMenuItem* prev = parent->firstChild();

        if ( prev ) {

            item = prev->nextSibling();

        }

        while( item ) {

            if ( item->internalId() == aInternalId ) {

                prev->setNextSibling( item->nextSibling() );

                break;

            }

            prev = item;

            item = item->nextSibling();

        }

    }

    if ( item && item->internalId() == aInternalId ) {

        // rearrange the tree and insert the item and its children in the virtual tree

        rearrangeTree( iMenuRoot, item, EFalse );      

        return;          

    }  

}