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

 * 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 <eikappui.h>

#include <eikmenub.h>

#include <eikhkeyt.h>

#include <eikkeys.h>

#include <avkon.hrh>

#include <gulbordr.h>

#include <aknborders.h>

#ifdef RD_SCALABLE_UI_V2

#include <aknstyluspopupmenu.h>

#endif //RD_SCALABLE_UI_V2

#include <swtlaffacade.h>

#include <eswtcore.rsg>

#include "eswtmobileextensions.h"

#include "eswtcore.hrh"

#include "swtmenu.h"

#include "swtmenubar.h"

#include "swtmenuarranger.h"

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

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

// CSwtMenuArranger::CSwtMenuArranger

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

//

inline CSwtMenuArranger::CSwtMenuArranger(MSwtDisplay& aDisplay)

        : iDisplay(aDisplay)

{

}

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

// CSwtMenuArranger::~CSwtMenuArranger

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

//

CSwtMenuArranger::~CSwtMenuArranger()

{

    // Beware that, currently, menu arranger is deleted before

    // command arranger in CSwtDisplay::PrepareToExit()

    iOpenedMenus.Reset();

    // Cannot use protected delete

    if (iDefaultMenuBar)

    {

        iDefaultMenuBar->Dispose();

        iDefaultMenuBar = NULL;

    }

    if (iStylusPopup)

    {

        TRAP_IGNORE(iStylusPopup->HandleControlEventL(iMenuBar, MCoeControlObserver::EEventRequestExit));

    }

    // Remove our menubar control and restore menubar in its initial state

    if (iMenuBar)

    {

        CEikonEnv* env = iDisplay.CoeEnv();

        ASSERT(env);

        CEikMenuBar* oldMenuBar = env->AppUiFactory()->SwapMenuBar(iOldEikMenuBar);

        ASSERT(EikMenuBar() == oldMenuBar);

        // SetEmphasis mihg get called a second time here if the menu bar to be

        // destroyed is hosting a FEP edit menu for instance. SetEmphasis must

        // not update the stack anymore second time.

        if (EikMenuBar()->IsDisplayed())

        {

            EikMenuBar()->StopDisplayingMenuBar();

        }

        iMenuBar->RemoveFromControlStack();

        delete iMenuBar;

        iMenuBar = NULL;

    }

    iOpenedMenus.Close();

    iOpenedMenuPanes.Close();

    iOpenedMenuPanesVisibility.Close();

    delete iOptionsString;

    iOptionsString = NULL;

#ifdef RD_SCALABLE_UI_V2

    delete iStylusPopup;

#endif //RD_SCALABLE_UI_V2    

    // Not own

    iCommandMenu = NULL;

    iCommandMenuOk = NULL;

    iCurrentMenuBar = NULL;

    iOldEikMenuBar = NULL;

}

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

// CSwtMenuArranger::ConstructL

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

//

void CSwtMenuArranger::ConstructL()

{

    iOptionsString = iDisplay.CoeEnv()->AllocReadResourceL(

                         R_SWT_SOFTKEY_TEXT_OPTIONS);

    iDefaultMenuBar = CSwtMenu::NewL(iDisplay, NULL, KSwtStyleBar);

    iMenuBar = CSwtMenuBar::NewL(*this);

    CEikonEnv* env = iDisplay.CoeEnv();

    ASSERT(env);

    iOldEikMenuBar = env->AppUiFactory()->SwapMenuBar(EikMenuBar());

    if (iOldEikMenuBar)

    {

        if (iOldEikMenuBar->IsVisible())

        {

            iOldEikMenuBar->StopDisplayingMenuBar();

        }

    }

    // WARNING: Do not add to control stack the CEikMenuBar directly.

    // This is the correct way but there is no way of enforcing it.

    iMenuBar->AddToControlStackL();

    // Current menubar is set after AddToStackL so that

    // it stays null if AddToStackL Leaves

    iCurrentMenuBar = iDefaultMenuBar;

    // Set cached image size

    UpdateImageSize();

}

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

// CSwtMenuArranger::NewL

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

//

CSwtMenuArranger* CSwtMenuArranger::NewL(MSwtDisplay& aDisplay)

{

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

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

}

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

// CSwtMenuArranger::GetFocusedControl

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

//

const MSwtControl* CSwtMenuArranger::GetFocusedControl() const

{

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

    if (activeShell)

    {

        return activeShell->FocusControl();

    }

    return NULL;

}

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

// CSwtMenuArranger::GetActiveMenuBar

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

//

const MSwtMenu* CSwtMenuArranger::GetActiveMenuBar() const

{

    const MSwtControl* focusedControl = GetFocusedControl();

    if (focusedControl && focusedControl->IsDecorations())

    {

        return const_cast<MSwtControl*>(focusedControl)->DecorationsInterface()->MenuBar();

    }

    else

    {

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

        if (activeShell)

            return activeShell->Decorations()->MenuBar();

    }

    return NULL;

}

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

// CSwtMenuArranger::GetCascadeMenu

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

//

const MSwtMenu* CSwtMenuArranger::GetCascadeMenu(

    const CEikMenuPaneItem::SData& aItemData) const

{

    const MSwtMenu* cascadeMenu = NULL;

    TInt count = iOpenedMenus.Count() - 1;

    for (TInt i = count; i >= 0; i--)

    {

        cascadeMenu = iOpenedMenus[i]->GetCascadeMenu(aItemData);

        if (cascadeMenu)

        {

            break;

        }

    }

    return cascadeMenu;

}

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

// CSwtMenuArranger::ComputeCurrentMenuBar

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

//

void CSwtMenuArranger::ComputeCurrentMenuBar()

{

    iCurrentMenuBar = GetActiveMenuBar();

    if (!iCurrentMenuBar)

    {

        iCurrentMenuBar = iDefaultMenuBar;

    }

    ASSERT(iCurrentMenuBar);

}

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

// CSwtMenuArranger::GetCurrentPopupMenu

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

//

const MSwtMenu* CSwtMenuArranger::GetCurrentPopupMenu() const

{

    const MSwtControl* focusedControl = GetFocusedControl();

    if (!focusedControl)

    {

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

        if (activeShell)

            focusedControl = activeShell->Control();

    }

    return focusedControl ? focusedControl->GetPopupMenu() : NULL;

}

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

// CSwtMenuArranger::GetCurrentControlMenu

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

//

const MSwtMenu* CSwtMenuArranger::GetCurrentControlMenu() const

{

    const MSwtControl* focusedCtrl = GetFocusedControl();

    if (focusedCtrl)

    {

        return focusedCtrl->GetControlMenu();

    }

    else

    {

        return NULL;

    }

}

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

// CSwtMenuArranger::OpenedMenusHaveRadioGroup

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

//

TBool CSwtMenuArranger::OpenedMenusHaveRadioGroup() const

{

    TInt count = iOpenedMenus.Count();

    for (TInt i = 0; i < count; i++)

    {

        const MSwtMenu* menu = iOpenedMenus[i];

        if (menu && menu->HasRadioGroup())

        {

            return ETrue;

        }

    }

    return EFalse;

}

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

// CSwtMenuArranger::RefreshCba

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

//

void CSwtMenuArranger::RefreshCba(TBool aCommandArrangerRefreshRequired,

                                  TBool aFocusedControlOnly)

{

    MSwtCommandArranger* commandArranger = iDisplay.CommandArranger();

    if (commandArranger)

    {

        if (aCommandArrangerRefreshRequired)

        {

            commandArranger->RefreshCba(aFocusedControlOnly);

        }

    }

    else

    {

        TRAP_IGNORE(UpdateOptionsCommandL());

    }

}

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

// CSwtMenuArranger::HandlePaneVisibilityChangeL

// Do not use CEikMenuPane::IsVisible() inside this function!

// - Deregisters menu panes as they become invisible

// - Removes menus of the panes becoming invisible

// - Posts Show, Hide menu events for the menus contained by the changing pane.

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

//

void CSwtMenuArranger::HandlePaneVisibilityChangeL(CEikMenuPane* aPane, TBool aStatus)

{

    CEikMenuPane* pane(NULL);

    TInt paneIndex = iOpenedMenuPanes.Find(aPane);

    if (paneIndex == KErrNotFound)

    {

        return;

    }

    // Resolution change causes the cascade panes to get window shown event again.

    if (iOpenedMenuPanesVisibility[paneIndex] == aStatus)

    {

        return;

    }

    else

    {

        iOpenedMenuPanesVisibility[paneIndex] = aStatus;

    }

    pane = iOpenedMenuPanes[paneIndex];

    TInt compress(EFalse);

    for (TInt i = iOpenedMenus.Count() - 1; i >= 0; i--)

    {

        MSwtMenu* menu = iOpenedMenus[i];

        if (menu && menu->Host() == pane)

        {

            if (aStatus)

            {

                if (menu->JavaPeer())   // CommandMenu has no peer

                {

                    iDisplay.PostShowEventL(menu->JavaPeer());

                }

            }

            else

            {

                if (menu->JavaPeer())   // CommandMenu has no peer

                {

                    iDisplay.PostHideEventL(menu->JavaPeer());

                }

                menu->SetHost(NULL);

                iOpenedMenus.Remove(i);

                compress = ETrue;

            }

        }

    }

    if (compress)

    {

        iOpenedMenus.Compress();

    }

    // Deregister pane.

    if (!aStatus)

    {

        iOpenedMenuPanes.Remove(paneIndex);

        iOpenedMenuPanesVisibility.Remove(paneIndex);

        iOpenedMenuPanes.Compress();

        iOpenedMenuPanesVisibility.Compress();

    }

}

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

// CSwtMenuArranger::ResetOpenedLists

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

//

void CSwtMenuArranger::ResetOpenedLists()

{

    TInt count = iOpenedMenus.Count();

    for (TInt i = 0; i < count; i++)

    {

        if (iOpenedMenus[i])

        {

            iOpenedMenus[i]->SetHost(NULL);

        }

    }

    iOpenedMenus.Reset();

    iOpenedMenuPanes.Reset();

    iOpenedMenuPanesVisibility.Reset();

}

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

// CSwtMenuArranger::UpdateImageSize

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

//

void CSwtMenuArranger::UpdateImageSize()

{

    TRect mainRect;

    AknLayoutUtils::LayoutMetricsRect(AknLayoutUtils::EMainPane, mainRect);

    TAknLayoutRect iconLayoutRect = CSwtLafFacade::GetLayoutRect(

                                        CSwtLafFacade::EListSinglePaneG1Cp2, mainRect, 0);

    iImageSize = iconLayoutRect.Rect().Size();

}

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

// CSwtMenuArranger::ControlFocusLost

// From MSwtMenuArranger

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

//

void CSwtMenuArranger::ControlFocusLost()

{

    // If the control loses focus we do not close the menu in case it is open.

    // The menu will be closed by one of the focus or activity gained functions.

    // The reason for not closing the menu is that when the menu is opened,

    // the focused control will lose focus.

    if (!EikMenuBar()->IsDisplayed())

    {

        // Swap menu bar with active shell's one

        ComputeCurrentMenuBar();

        RefreshCba(EFalse);

    }

}

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

// CSwtMenuArranger::ControlFocusGained

// From MSwtMenuArranger

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

//

void CSwtMenuArranger::ControlFocusGained(const MSwtControl& aControl)

{

    // If the shell owning aControl (the control whose focus changed)

    // is the active shell, the menu bar should be updated.

    if (&(aControl.GetShell()) == iDisplay.UiUtils().GetActiveShell())

    {

        // If there's a focus change while displaying menus

        // (means focus change is done programatically)

        // then displayed menus are invalid (popup + commands)

        // => stop displaying them

        if (EikMenuBar()->IsDisplayed())

        {

            StopDisplayingMenuBar();

        }

        // Swap menu bar with active shell's one

        ComputeCurrentMenuBar();

        RefreshCba(EFalse);

    }

}

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

// CSwtMenuArranger::ActiveShellLost

// From MSwtMenuArranger

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

//

void CSwtMenuArranger::ActiveShellLost()

{

    // If there's a focus change while displaying menus

    // (means focus change is done programatically)

    // then displayed menus are invalid (popup + commands)

    // => stop displaying them

    if (EikMenuBar()->IsDisplayed())

    {

        StopDisplayingMenuBar();

    }

    ComputeCurrentMenuBar();

    RefreshCba(EFalse);

}

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

// CSwtMenuArranger::ActiveShellGained

// From MSwtMenuArranger

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

//

void CSwtMenuArranger::ActiveShellGained(const MSwtShell& /*aShell*/)

{

    // Loss of previously active shell (if any) must have been processed already

    // One exception: when a shell is disposed, it doesn't notify its activity

    // loss

    // If there's a focus change while displaying menus

    // (means focus change is done programatically)

    // then displayed menus are invalid (popup + commands)

    // => stop displaying them

    if (EikMenuBar()->IsDisplayed())

    {

        StopDisplayingMenuBar();

    }

    ComputeCurrentMenuBar();

    RefreshCba(EFalse);

}

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

// CSwtMenuArranger::MenuBarSetOnDecorations

// From MSwtMenuArranger

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

//

void CSwtMenuArranger::MenuBarSetOnDecorations()

{

    const MSwtMenu* menuBar = GetActiveMenuBar();

    // Check if it is necessary to recompute the menu bar

    if (((menuBar) && (iCurrentMenuBar != menuBar))

            || ((!menuBar) && (iCurrentMenuBar != iDefaultMenuBar)))

    {

        if (EikMenuBar()->IsDisplayed())

        {

            StopDisplayingMenuBar();

        }

        else if (!menuBar)

        {

            // If the menubar got removed, reset internal state.

            StopDisplayingMenuBar();

        }

        ComputeCurrentMenuBar();

        RefreshCba();

    }

}

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

// CSwtMenuArranger::SetCommandMenu

// From MSwtMenuArranger

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

//

void CSwtMenuArranger::SetCommandMenu(const MSwtMenu* aCommandMenu)

{

    iCommandMenu = aCommandMenu;

}

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

// CSwtMenuArranger::SetContextMenu

// From MSwtMenuArranger

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