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

**

** Copyright (C) 2008-2010 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

** Contact: Nokia Corporation (developer.feedback@nokia.com)

**

** This file is part of the HbCore module of the UI Extensions for Mobile.

**

** GNU Lesser General Public License Usage

** This file may be used under the terms of the GNU Lesser General Public

** License version 2.1 as published by the Free Software Foundation and

** appearing in the file LICENSE.LGPL included in the packaging of this file.

** Please review the following information to ensure the GNU Lesser General

** Public License version 2.1 requirements will be met:

** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at developer.feedback@nokia.com.

**

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

#include "hbmenu.h"

#include "hbmenu_p.h"

#include "hbmenuitem_p.h"

#include "hbaction.h"

#include <hbwidgetfeedback.h>

#include "hbinstance.h"

#include "hbmenucontainer_p.h"

#ifdef HB_EFFECTS

#include "hbeffect.h"

#include "hbeffectinternal_p.h"

bool HbMenuPrivate::menuEffectsLoaded = false;

#endif

#include "hbglobal_p.h"

#include <QPointer>

Q_DECLARE_METATYPE (QAction*)// krazy:exclude=qclasses

HbMenuPrivate::HbMenuPrivate():

    HbPopupPrivate(),

    menuItemView(0),

    subMenuAction(0),

    activeSubMenu(0),

    resultAction(0),

    actionTriggered(false),

    menuType(HbMenu::ContextMenu),

    mSubMenuItem(0),

    mRightMargin(0.0),

    mDownMargin(0.0),

    delayMenuConstruction(true),

    receiverToDisconnectOnClose(0)

{

}

HbMenuPrivate::~HbMenuPrivate()

{

}

void HbMenuPrivate::init()

{

    Q_Q(HbMenu);

    subMenuAction = new HbAction(q);

    subMenuAction->setMenu(q);

    q->setTimeout(HbPopup::ContextMenuTimeout);

    q->setBackgroundFaded(false);

}

void HbMenuPrivate::addPopupEffects()

{

#ifdef HB_EFFECTS

    effectType = "HB_MENU";

    hasEffects = menuEffectsLoaded;

    if (menuEffectsLoaded)

        return;

    menuEffectsLoaded = true;

    hasEffects = HbEffectInternal::add("HB_MENU", "menu_appear", "appear");

    if (hasEffects) {

        //We load the disappear effect only if appear effect was also loaded

        hasEffects = HbEffectInternal::add("HB_MENU", "menu_disappear", "disappear");

        if (hasEffects) {

            hasEffects = HbEffectInternal::add("HB_menuitem", "menuitem_press", "clicked");

        }

        if (hasEffects ) {

            hasEffects = HbEffectInternal::add("HB_POPUP",

                                               "dialog_rotate",

                                               "orientationswitch");

        }

    }

#endif

}

void HbMenuPrivate::_q_triggerAction(HbMenuItem *currentItem)

{

    Q_Q(HbMenu);

    if (currentItem && currentItem->action()){

        HbWidgetFeedback::triggered(currentItem, Hb::InstantClicked);

#ifdef HB_EFFECTS

        if (hasEffects) {

            HbEffect::start(currentItem, "HB_menuitem", "clicked");

        }

#endif

        HbAction *hbAction = qobject_cast<HbAction *>(currentItem->action());

        if (hbAction && hbAction->menu() && !actionTriggered) {

            hbAction->trigger();

            stopTimeout();

            openSubmenu(currentItem);

        } else {

            q->close();

            resultAction = hbAction;

            if (!actionTriggered) { // prevent duplicate events

                currentItem->action()->trigger();

            }

            actionTriggered = true;

        }

    }

}

void HbMenuPrivate::createMenuView()

{

    Q_Q(HbMenu);

    if (!menuItemView && q->actions().count()){

        menuItemView = new HbMenuListView(q, q);        

        HbStyle::setItemName(menuItemView, "content");

        //This optimises case of options menu which otherwise updates its primitives twice.

        if (menuType ==  HbMenu::OptionsMenu)

            q->setFrameType(HbPopup::Strong);

    	else

            q->setFrameType(HbPopup::Weak);

        if (polished)//This check can be removed once base class repolish is fixed.

            q->repolish();

    }	

}

void HbMenuPrivate::delayedLayout()

{

    createMenuView();

    if(menuItemView)

        menuItemView->doDelayedLayout();

    delayMenuConstruction = false;

}

void HbMenuPrivate::changeToOptionsMenu()

{

    menuType = HbMenu::OptionsMenu;

}

HbMenuItem *HbMenuPrivate::subMenuItem()

{

    return mSubMenuItem;

}

void HbMenuPrivate::setSubMenuItem(HbMenuItem *menuItem)

{

    mSubMenuItem = menuItem;

}

void HbMenuPrivate::_q_onActionTriggered()

{

    Q_Q(HbMenu);

       HbAction *action = qobject_cast<HbAction *>(q->sender());

    if (action && !action->menu() ) { // do not trigger from opening submenu

        emit q->triggered(action);

    }

}

void HbMenuPrivate::_q_subMenuItemTriggered(HbAction *action)

{

    Q_Q(HbMenu);    

    // do not close the menu tree if the triggered action is

    // submenu item

    if (!action->menu()) { 

        q->close();

    } else {

        stopTimeout();

    }

}

void HbMenuPrivate::actionAdded(QActionEvent *actionEvent)

{

    if (delayMenuConstruction)

        return;

    Q_Q(HbMenu);

    QObject::connect(actionEvent->action(), SIGNAL(triggered()), q, SLOT(_q_onActionTriggered()));

    if (actionEvent->action()->isVisible()){        

        createMenuView();        

        menuItemView->addActionItem(actionEvent->action());

    }

}

void HbMenuPrivate::actionRemoved(QActionEvent *actionEvent)

{

    if (delayMenuConstruction)

        return;

    Q_Q(HbMenu);

    QObject::disconnect(actionEvent->action(), 0, q, 0);

    if (menuItemView)

        menuItemView->removeActionItem(actionEvent->action());

}

void HbMenuPrivate::actionChanged(QActionEvent *actionEvent)

{

    if (delayMenuConstruction)

        return;

    if (menuItemView)

        menuItemView->updateActionItem(actionEvent->action());

}

/*

   Returns current focusable action based on current row of the menuItemView or index if specified.

   If there is no focusable action it returns 0.

   Also returns the active item representing the active action or 0.

*/

HbAction *HbMenuPrivate::activeAction(HbMenuItem *&activeItem) const

{

    if(!menuItemView)

        return 0;

    HbAction *action = 0;

    HbMenuItem *currentItem = menuItemView->currentItem();

    if(currentItem && currentItem->action() && currentItem->action()->isVisible() &&

       currentItem->action()->isEnabled() && !currentItem->action()->isSeparator()) {

        action = static_cast<HbAction*>(currentItem->action());

        activeItem = currentItem;

    }

    return action;

}

/*

  Convenience overload

*/

HbAction *HbMenuPrivate::activeAction() const

{

    HbMenuItem* activeItem = 0;

    return activeAction(activeItem);

}

/*

  Opens a submenu for activeItem. If activeItem is 0 it uses activeAction() to determine active item

  and opens submenu for it if active action has submenu.

*/

void HbMenuPrivate::openSubmenu(HbMenuItem *activeItem)

{

    Q_Q(HbMenu);

    if (!activeItem) {

        activeAction(activeItem);

    }

    if (activeItem && activeItem->action() && activeItem->action()->isEnabled()) {

        HbAction *hbAction = qobject_cast<HbAction *>(activeItem->action());

        q->setActiveAction(hbAction);

        if (!hbAction)

            return;

        HbMenu *subMenu = hbAction->menu();

        if ( subMenu ) {

            subMenu->setLayoutDirection(q->layoutDirection());

            activeSubMenu = subMenu; 

            subMenu->setTimeout(timeout); 

            QObject::disconnect(subMenu, SIGNAL(aboutToClose()), q, SLOT(_q_subMenuTimedOut()));

            QObject::connect(subMenu, SIGNAL(aboutToClose()), q, SLOT(_q_subMenuTimedOut()));

            QObject::connect(subMenu, SIGNAL(triggered(HbAction*)), q, SLOT(_q_subMenuItemTriggered(HbAction*)));

            subMenu->show();

            // Reset the active submenu so that mouse event handling works.

            // huh ? activeSubMenu = 0;

        }

    }

}

void HbMenuPrivate::_q_subMenuTimedOut()

{

    Q_Q(HbMenu);

    if( menuTimedOut (activeSubMenu) ) {

        if ( activeSubMenu ) {

            activeSubMenu->disconnect();

        }

        timedOut = true;

        q->close();

    } else {

        startTimeout();

    }

}

void HbMenuPrivate::_q_handleMenuAfterOrientationChange()

{

    Q_Q(HbMenu);

    if ( menuType == HbMenu::ContextMenu || menuType == HbMenu::OptionsMenu ) {

        if(activeSubMenu){

            HbAction* action = activeSubMenu->activeAction();

            if(action) {

                closeMenuRecursively(action);

            }

            closeSubmenu();

        }

        q->close();

    }

}

/*!

 closes the menu after Orientation change

*/

void HbMenuPrivate::closeMenuAfterOrientationChange()

{

    Q_Q(HbMenu);

    HbMainWindow* w(q->mainWindow());

    if ( w ){

        QObject::disconnect( w, SIGNAL(aboutToChangeOrientation()),

                             q, SLOT(_q_handleMenuAfterOrientationChange()));

        QObject::connect( w, SIGNAL(aboutToChangeOrientation()),

                 q, SLOT(_q_handleMenuAfterOrientationChange()));

    }

}

void HbMenuPrivate::closeMenuRecursively(HbAction* menuAction)

{

    if(menuAction->menu() && menuAction->menu()->activeAction()) {

        closeMenuRecursively(menuAction->menu()->activeAction());

    }

    if(menuAction->menu()) {

        menuAction->menu()->close();

    }

}

bool HbMenuPrivate::menuTimedOut(HbMenu* menu)

{

    return (menu && menu->timeout() > 0 && HbMenuPrivate::d_ptr(menu)->timedOut);

}

void HbMenuPrivate::closeSubmenu()

{

    // Check whether this is a submenu.

    if (activeSubMenu) {

        activeSubMenu->close();

    }

}

void HbMenuPrivate::setSubMenuPosition()

{

    Q_Q(HbMenu);

    if (mSubMenuItem) {        

        qreal upperEdge = mSubMenuItem->scenePos().y() + mSubMenuItem->size().height() * 2 / 3;

        QSizeF windowSize = QSizeF(0,0);

        if (q->mainWindow()) {

            windowSize = q->mainWindow()->layoutRect().size();

        }

        if (windowSize.height() - mDownMargin - q->preferredHeight() < upperEdge) {

            upperEdge = windowSize.height() - mDownMargin - q->preferredHeight();

        }

        if (q->layoutDirection() == Qt::LeftToRight) {

            qreal leftEdge = mSubMenuItem->scenePos().x() +

                             mSubMenuItem->size().width() - mRightMargin;

            if ((windowSize.width() - q->size().width()) < leftEdge) {

                leftEdge = mSubMenuItem->scenePos().x() +

                           mSubMenuItem->size().width() +

                           mRightMargin - q->size().width();

            }

            q->setPreferredPos(QPointF(leftEdge, upperEdge));

        } else {

            qreal rightEdge = mSubMenuItem->scenePos().x() + mRightMargin;

            if ((rightEdge - q->size().width()) < 0) {

                rightEdge = mSubMenuItem->scenePos().x() - mRightMargin +

                            q->size().width();

            }

            q->setPreferredPos(QPointF(rightEdge, upperEdge), HbPopup::TopRightCorner);

        }

    }

}

/*!

    @beta

    @hbcore

    \class HbMenu

    \brief HbMenu is a menu widget for use in HbView.

    \image html hbmenu.png A menu with checkable items and a sub-menu.

    Use an HbMenu to show a list of options. There are two main types of menus:

    - The view options menu

    - Context menus (popup menus)

    There is one view options menu for each view.

    It is shown by tapping the title bar. You can access the view options menu by calling

    HbView::menu() which returns a pointer to a new empty menu if one does not already exist.

    You can create any number of context menus.

    Context menus are usually invoked by a user action, such as tapping a widget.

    A menu contains a list of items. You can add three kinds of items to a menu:

    - Actions

    - Sub-menus

    - Separators

    An action is an object of class HbAction that performs an action when it is triggered.

    Use addAction() to add an action to a menu. Actions can be checkable (QAction::setCheckable).

    Use clearActions() to clear all actions from a menu.

    Use removeAction() to remove individual actions from a menu.

    A sub-menu is a menu that is nested within another menu. Use addMenu() or insertMenu() to add a sub-menu to a menu.

    Sub-menus can be nested within sub-menus.

    Separators group related items in a menu.

    Use addSeparator() or insertSeparator() to create and add a separator to a menu.

    \image html hbmenu.png A menu with checkable actions and a sub-menu.

    After you add an action to your menu, you specify a receiver object and its slot (you can also

    add an action and specify a receiver slot at the same time).

    The receiver is notifed when the action is triggered (QAction::triggered()).

    HbMenu also has a triggered() menu signal, which signals which HbAction was triggered in the menu.

    Context menu example:

    A menu and a few actions are created. The triggered() signal of the menu is connected to

    the mute() function of the enclosing class (implementation not shown).

    The exec() function shows the menu.

    User needs to connect to "longPress" signal and implement corresponding slot. This enables

    longpress events to be received from list.

    \dontinclude decoratorlistdemo/contentwidget.cpp

    \skip // Create new menu

    \until ( coords );

    \sa HbDialog, HbView

*/

/*!

    \property HbMenu::menuType

    \brief

*/

/*!

    \fn void HbMenu::triggered(HbAction *action)

    This signal is emitted when one of the action items is selected.

    \param action the action that was triggered in the menu.

 */

/*!

    \enum HbMenu::MenuType

    This enum describes different types of HbMenu.

*/

/*!

    \var HbMenu::ContextMenu

    ContextMenu is a menu which position is set by user.

*/

/*!

    \var HbMenu::OptionMenu

    OptionMenu is set by HbView. Its position cannot be changed.

*/

/*!

    \var HbMenu::SubMenu

    Menu becomes SubMenu when it is added to another menu.

*/

/*!

    Constructs a menu with \a parent graphics item.

    \param parent is the parent graphics item.

*/

HbMenu::HbMenu(QGraphicsItem *parent) :

        HbPopup(*new HbMenuPrivate, parent)

{

    Q_D(HbMenu);

    d->q_ptr = this;

    d->init();

    setModal(true);

}

/*!

    Constructs a menu with \a title and \a parent graphics item.

    \param title is the menu title.

    \param parent is the parent graphics item.

*/

HbMenu::HbMenu(const QString &title, QGraphicsItem *parent) :

        HbPopup(*new HbMenuPrivate, parent)

{

    Q_D(HbMenu);

    d->q_ptr = this;

    d->init();

    setTitle(title);

}

HbMenu::HbMenu(HbMenuPrivate &dd, QGraphicsItem *parent) :

        HbPopup(dd, parent)

{

    Q_D(HbMenu);

    d->q_ptr = this;

    d->init();

}

HbMenu::~HbMenu()

{

    if (!scene() || !scene()->property("destructed").isValid()) {

        foreach (QAction *action, actions()) {// krazy:exclude=qclasses

            HbAction* hbAction = qobject_cast<HbAction *>(action);

            if (hbAction){

                if (hbAction->menu()) {

                    hbAction->menu()->deleteLater();

                }

                hbAction->setMenu((HbMenu*)0);

            }

        }

    }

}