/*******************************************************************************

 * Copyright (c) 2005, 2010 Nokia Corporation and/or its subsidiary(-ies).

 * All rights reserved. This program and the accompanying materials

 * are made available under the terms of the Eclipse Public License v1.0

 * which accompanies this distribution, and is available at

 * http://www.eclipse.org/legal/epl-v10.html

 *

 * Contributors:

 *     Nokia Corporation - S60 implementation

 *******************************************************************************/

#include <aknenv.h>

#include <avkon.hrh>

#include <AknUtils.h>

#include "swtcommandarranger.h"

#include "swtcommandcontainer.h"

#include "swtcommandmenu.h"

static const TInt KPositiveCbaCategory = 0;

static const TInt KNegativeCbaCategory = 1;

static const TInt KCommandGroupCategory = 3;

static const TInt KPositiveCbaButton = 0;

static const TInt KNegativeCbaButton = 1;

static const TInt KMSKCbaButton = 2;

const TInt KPositionsInCBAForSoftkeys[KCbaButtonCountMax] =

{

    0, // Left softkey

    2, // Right softkey

    3  // Middle softkey

};

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

inline CSwtCommandArranger::CSwtCommandArranger(MSwtDisplay& aDisplay)

        : iDisplay(aDisplay)

        , iCba(aDisplay.UiUtils().Cba())

{

    iCbaCommands.Reset();

    iDefaultCommand = NULL;

    iClearCommand = NULL;

    iSelectionCommand = NULL;

    iHelpCommand = NULL;

}

CSwtCommandArranger::~CSwtCommandArranger()

{

    delete iSearchedContainer;

    // Clean our mess in CBA (in case some commands weren't disposed?)

    ClearCba();

    // Clean our mess in menus (in case some commands weren't disposed?)

    ClearMenu();

    // Cannot use protected delete

    if (iCommandMenu)

    {

        // The command menu is removed from the menu arranger

        iDisplay.MenuArranger().SetCommandMenu(NULL);

        iCommandMenu->Dispose();

        iCommandMenu = NULL;

    }

    // Cannot use protected delete

    if (iCommandMenuOK)

    {

        iCommandMenuOK->Dispose();

        iCommandMenuOK = NULL;

    }

#ifdef RD_SCALABLE_UI_V2

    if (iStylusPopupMenuCommands)

    {

        iStylusPopupMenuCommands->Reset();

        iStylusPopupMenuCommands->Dispose();

        iStylusPopupMenuCommands = NULL;

    }

#endif //RD_SCALABLE_UI_V2

    // All commands should have been disposed (and therefore removed

    // from following array) when arranger is deleted

    ASSERT(iCommands.Count() == 0);

    iCommands.Close();

    iCommandCascadeMenus.Close();

#ifdef _lint

    iDefaultCommand = NULL;

    iClearCommand   = NULL;

    iSelectionCommand = NULL;

    iHelpCommand = NULL;

#endif

}

void CSwtCommandArranger::ConstructL()

{

    iButtonCount = KCbaButtonCountMax;//iCba.ButtonCount();

    iSearchedContainer = CSwtCommandContainer::NewL();

    iCommandMenu = CSwtCommandMenu::NewL(iDisplay);

#ifndef RD_JAVA_S60_RELEASE_9_2

    iCommandMenuOK = CSwtCommandMenu::NewL(iDisplay);

#endif

#ifdef RD_SCALABLE_UI_V2

    iStylusPopupMenuCommands = CSwtCommandMenu::NewL(iDisplay);

#endif //RD_SCALABLE_UI_V2

    // The command menu is set to the menu arranger

    iDisplay.MenuArranger().SetCommandMenu(iCommandMenu);

}

CSwtCommandArranger* CSwtCommandArranger::NewL(MSwtDisplay& aDisplay)

{

    CSwtCommandArranger* self = new(ELeave) CSwtCommandArranger(aDisplay);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

}

const MSwtControl* CSwtCommandArranger::GetFocusedControl() const

{

    const MSwtShell* activeShell = iDisplay.UiUtils().GetActiveShell();

    if (activeShell)

    {

        return activeShell->FocusControl();

    }

    return NULL;

}

const MSwtControl* CSwtCommandArranger::GetFirstFocusedControl() const

{

    // Get pointer to first control (the one that is actually focused) to process

    const MSwtControl* firstFocusedControl = GetFocusedControl();

    if (!firstFocusedControl && iDisplay.UiUtils().GetActiveShell())

    {

        firstFocusedControl = iDisplay.UiUtils().GetActiveShell()->Control();

    }

    return firstFocusedControl;

}

void CSwtCommandArranger::ClearCba()

{

    // Clear right softkey command and observer added by calling UpdateRightSoftkeyCommandAndObserver

    // if there are

    if (iRightSoftkeyObserverAddedByControl)

    {

        // remove command observer for right softkey added by control

        iCba.RemoveCommandObserver(KPositionsInCBAForSoftkeys[ KNegativeCbaButton ]);

        iRightSoftkeyObserverAddedByControl = EFalse;

    }

    if (iRightSoftkeyCommandIdFromControl)

    {

        // remove command added by control

        iCba.RemoveCommandFromStack(KPositionsInCBAForSoftkeys[ KNegativeCbaButton ],

                                    iRightSoftkeyCommandIdFromControl);

        iRightSoftkeyCommandIdFromControl = 0;

    }

    // For each command that has been mapped to CBA, clean the correponding CBA button

    for (TInt cbaIndex = 0; cbaIndex < iButtonCount; ++cbaIndex)

    {

        if (iCbaCommands[cbaIndex])

        {

            TInt commandId = KSwtCommandBaseId + cbaIndex;

            // Remove our command observer as it's still there

            iCba.RemoveCommandObserver(KPositionsInCBAForSoftkeys[cbaIndex]);

            // Remove our command from stack (even if someone else push another command on top of it)

            iCba.RemoveCommandFromStack(KPositionsInCBAForSoftkeys[cbaIndex], commandId);

        }

        else if (cbaIndex == KMSKCbaButton)

        {

            MEikButtonGroup* lButtonGroup = iCba.ButtonGroup();

            TInt cmdID = lButtonGroup->CommandId(KPositionsInCBAForSoftkeys[KMSKCbaButton]);

            iCba.RemoveCommandFromStack(KPositionsInCBAForSoftkeys[KMSKCbaButton], cmdID);

            if (cmdID == EAknSoftkeyContextOptions || cmdID == KSwtCommandBaseId + KMSKCbaButton)

            {

                iCba.RemoveCommandObserver(KPositionsInCBAForSoftkeys[KMSKCbaButton]);

            }

        }

    }

    // Clear array of CBA commands

    iCbaCommands.Reset();

    // Refresh CBA

    if (iCba.IsVisible())

    {

        iCba.DrawDeferred();

    }

}

void CSwtCommandArranger::RefreshCba(TBool aFocusedControlOnly)

{

    // Compute CBA and Menu with active shell commands

    TRAPD(err, ComputeAndRefreshCbaAndMenuL(aFocusedControlOnly));

    if (err)

    {

        CleanCbaAndMenuAfterLeaveInCompute();

    }

}

void CSwtCommandArranger::ClearMenu()

{

    iCommandMenu->Reset();

    for (TInt menuIndex = 0; menuIndex < iCommandCascadeMenus.Count(); ++menuIndex)

    {

        iCommandCascadeMenus[menuIndex]->Reset();

        iCommandCascadeMenus[menuIndex]->Dispose();

    }

    iCommandCascadeMenus.Reset();

    if (iCommandMenuOK)

    {

        iCommandMenuOK->Reset();

    }

    if (iDisplay.MenuArranger().EikMenuBar()->IsDisplayed())

    {

        iDisplay.MenuArranger().StopDisplayingMenuBar();

    }

#ifdef RD_SCALABLE_UI_V2

    TRAP_IGNORE(iDisplay.MenuArranger().CloseStylusPopupMenuL());

}

void CSwtCommandArranger::ComputeAndRefreshCbaAndMenuL(TBool aFocusedControlOnly)

{

    if (iCbaIsBeingComputed)

        return;

    iCbaIsBeingComputed = ETrue;

    MSwtMenuArranger& menuArranger = iDisplay.MenuArranger();

    iClearCommand = NULL;

    iHelpCommand = NULL;

    iDefaultCommand = NULL;

    iSelectionCommand = NULL;

    iCbaIndexWhenComputeLeave = 0;

    iNumberOfContextOptionMenuItems = 0;

    // Get pointer to first control (the one that is actually focused) to process

    const MSwtControl* control = GetFirstFocusedControl();

#ifdef RD_JAVA_S60_RELEASE_9_2

    if (control)

    {

        control = control->GetShell().Control();

    }

#endif // RD_JAVA_S60_RELEASE_9_2

    const MSwtControl* focusedControl(control);

    TFixedArray<TBool, KCbaButtonCountMax> cbaIsAvailable;

    TInt cbaIndex;

    // Ask focused control for CBA buttons availability

    if (control != NULL)

    {

        for (cbaIndex = 0; cbaIndex < iButtonCount; ++cbaIndex)

        {

            if (control->CbaButtonIsUsed(cbaIndex))

            {

                cbaIsAvailable[cbaIndex] = EFalse;

            }

            else

            {

                cbaIsAvailable[cbaIndex] = ETrue;

            }

        }

    }

    else

    {

        for (cbaIndex = 0; cbaIndex < iButtonCount; ++cbaIndex)

        {

            cbaIsAvailable[cbaIndex] = ETrue;

        }

    }

    // Clear commands in CBA and menus

    // It is important to clear menu before the cba.

    ClearMenu();

    ClearCba();

    // Go through list of commands belonging to focused control and its parents

    TBool itIsNotTheFirstControlWithCommands = EFalse;

    while (control)

    {

        // Find command container of control

        TLinearOrder<CSwtCommandContainer> containerOrder(CSwtCommandArranger::CommandContainerCompare);

        iSearchedContainer->SetParentControl(*control);

        TInt indexOfContainer = iCommands.FindInOrder(iSearchedContainer, containerOrder);

        // If control has commands then process them

        if (indexOfContainer != KErrNotFound)

        {

            // Add a separator in the command menu before appending the new commands to it

            if (itIsNotTheFirstControlWithCommands)

            {

                if (iCommandMenuOK)

                {

                }

            }

            else

            {

                itIsNotTheFirstControlWithCommands = ETrue;

            }

            RPointerArray<MSwtCommand>& commands = iCommands[indexOfContainer]->Commands();

            // commands are ordered by priority

            for (TInt commandIndex = 0; commandIndex < commands.Count(); ++commandIndex)

            {

                // Assign command to corresponding CBA button if available

                if (commands[commandIndex] != NULL)

                {

                    // Find selection type command.

                    // This selection type command can substitute for MSK selection operation

                    // that is handled by list, listbox, listview or table

                    if (!iSelectionCommand && control == focusedControl

                            && &(commands[commandIndex]->ParentControl()) == focusedControl

                            && commands[commandIndex]->Type() == MSwtCommand::ESelect)

                    {

                        iSelectionCommand = commands[commandIndex];

                    }

                    // Assign command to CBA buttons and menus.

                    AssignCommandToCbaAndMenuL(

                        cbaIsAvailable,

                        *commands[commandIndex],

                        *control,

                        indexOfContainer);

                }

            }

        }

        if (aFocusedControlOnly)

        {

            break;

        }

        // Stop going through parents if we encounter a (modal or not) shell

        if (control->IsShell() /*&& ((control->Style() & KSwtModalityMask)!=KSwtStyleModeless)*/)

        {

            control = NULL;

        }

        // Next control

        else

        {

            MSwtComposite* parent = control->GetParent();

            control = (parent) ? parent->Control() : NULL;

        }

    }

    // Check if the Options command is needed:

    //  - if there are menu items

    //  - if there are more than one command in command menu

    //  - if there is one command and this item is a command group

    TBool optionsCmdNeeded = EFalse;

    TBool isFullscreen = (iDisplay.UiUtils().GetActiveShell()) ?

                         iDisplay.UiUtils().GetActiveShell()->FullScreenMode() : EFalse;

    if (menuArranger.HasMenuItems())

    {

        optionsCmdNeeded = ETrue;

    }

    else if (iCommandMenu->CountDisplayableItems() > 1)

    {

        optionsCmdNeeded = ETrue;

    }

    else if (iCommandMenu->CountDisplayableItems() == 1)

    {

        if (isFullscreen)

        {

            optionsCmdNeeded = ETrue;

        }

        else

        {

            const RPointerArray<MSwtCommand>& menuItems = iCommandMenu->Commands();

            for (TInt indexMenuItem = 0; indexMenuItem < menuItems.Count(); indexMenuItem++)

            {

                if (menuItems[indexMenuItem]->IsEnabled()

                        && menuItems[indexMenuItem]->Type() == MSwtCommand::ECommandGroup)

                {

                    optionsCmdNeeded = ETrue;

                }

            }

        }

    }

    // Update the options command:

    //  - if the options command is not set and needed, it is added to the cba.

    //  - if the options command is already set and no more needed, it is removed from cba;

    //  - if the options command is already set and is still needed, nothing is done;

    if (optionsCmdNeeded && !menuArranger.IsOptionsCommandAdded())

    {

        menuArranger.AddOptionsCommandL();

    }

    else if (!optionsCmdNeeded && menuArranger.IsOptionsCommandAdded())

    {

        menuArranger.RemoveOptionsCommand();

    }

    // If options command has already been added,

    // no other command can be set to left cba button

    if (menuArranger.IsOptionsCommandAdded())

    {

        // The left cba command is set to null

        //  in case that a command has been set earlier

        iCbaCommands[KPositiveCbaButton] = NULL;

        // Since the options command is set, the left cba button is not available

        cbaIsAvailable[KPositiveCbaButton] = EFalse;

    }

    // Compute the number of items available in context options menu

    // Includes the default command, the OK (or SELECT) commands and

    // the menu items provided by a control (retrieved by GetControlMenu)

    ComputeNumberOfContextOptionsMenuItems();

    // For each command that has been mapped to CBA, set the correponding CBA button

    cbaIndex = 0;

    iCbaIndexWhenComputeLeave = 0;

    while (cbaIndex < iButtonCount)

    {

        iCbaIndexWhenComputeLeave = 2 * cbaIndex;

        if (iCbaCommands[cbaIndex])

        {

            TInt commandId = KSwtCommandBaseId + cbaIndex;

            // Update command bar

            iCba.UpdateCommandObserverL(

                KPositionsInCBAForSoftkeys[cbaIndex],

                *this);

            ++iCbaIndexWhenComputeLeave;

            iCba.AddCommandToStackL(

                KPositionsInCBAForSoftkeys[cbaIndex],

                commandId,

                iCbaCommands[cbaIndex]->Text());

            // Dimming

            // Set default command

            if (iCbaCommands[cbaIndex] == iDefaultCommand)

            {

                iCba.SetDefaultCommand(commandId);

            }

        }

        // If MSK not already set, assign it to CBA

        // if MSK enabled and not in fullscreen mode

        else if (AknLayoutUtils::MSKEnabled()

                 && cbaIndex == KMSKCbaButton

                 && !isFullscreen)

        {

            ASSERT(iCbaCommands[KMSKCbaButton] == NULL);

            AssignMSKToCbaL();

        }

        ++cbaIndex;

    }

    // Refresh CBA

    if (iCba.IsVisible())

    {

        iCba.DrawDeferred();

    }

    iCbaIsBeingComputed = EFalse;

}

void CSwtCommandArranger::AssignCommandToCbaAndMenuL(

    TFixedArray<TBool, KCbaButtonCountMax>& aCbaIsAvailable,

    const MSwtCommand& aCommand,

    const MSwtControl& aControl,

    const TInt& aIndexOfContainer)

{

    TInt commandCategory = CSwtCommandArranger::CbaCategoryOfCommand(aCommand);

    CSwtCommandMenu* commandCascadeMenu = NULL;

    const MSwtShell* activeShell = iDisplay.UiUtils().GetActiveShell();

    switch (commandCategory)

    {

    case KPositiveCbaCategory:

    {

        // Set left cba button

        // Handle Help and Clear command

        if (aCommand.IsEnabled())

        {

            // Set the Help command if the type of command is Help

            if ((!iHelpCommand)

                    && (aCommand.Type() == MSwtCommand::EHelp))

            {

                iHelpCommand = &aCommand;

            }

            // If command is positive category, enabled and the type of command is Delete,

            // set the Clear command

            if ((!iClearCommand)

                    && (!aControl.IsKeyUsed(EKeyBackspace))

                    && (aCommand.Type() == MSwtCommand::EDelete))

            {

                iClearCommand = &aCommand;

            }

        }

        if (!iDisplay.MenuArranger().HasMenuItems()

                && activeShell && !activeShell->FullScreenMode())

        {

            // If left button is available, the button can be set

            // Otherwise if the command currently set is disabled and the new one is enabled,

            // then the left button can be set with the new command.

            if ((aCbaIsAvailable[KPositiveCbaButton])

                    || (iCbaCommands[KPositiveCbaButton]

                        && !iCbaCommands[KPositiveCbaButton]->IsEnabled()

                        && aCommand.IsEnabled()))

            {

                // CBA may contain only one positive command