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

**

** 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 "hbtoolbar_p.h"

#include "hbtoolbar.h"

#include "hbaction.h"

#include "hbtoolbutton.h"

#include "hbtoolbutton_p.h"

#include "hbapplication.h"

#include "hbnamespace_p.h"

#include "hbtoolbarextension.h"

#include "hbtoolbarextension_p.h"

#include "hbwidget_p.h"

#include "hbinstance.h"

#include "hbactionmanager_p.h"

#include "hbcolorscheme.h"

#include <hbwidgetfeedback.h>

#include <QGraphicsLinearLayout>

#include <QGraphicsSceneResizeEvent>

#include <QWidget> // for QWIDGETSIZE_MAX

#include <QActionEvent>

#include <QDebug>

#ifdef HB_EFFECTS

#include "hbeffectinternal_p.h"

#define HB_TOOLBAR_ITEM_TYPE "HB_TOOLBAR"

bool HbToolBarPrivate::effectsLoaded = false;

#endif

//If minimum button size cannot be calculated

//more button will appear after default button count is exceeded

static const int DEFAULT_TOOLBUTTON_COUNT = 5;

HbToolBarPrivate::HbToolBarPrivate() :

        mLayout(0),

        mPressedDownButton(0),

        mPreviouslyPressedDownButton(0),

        mOrientation(Qt::Horizontal),

        actionManager(0),

        hasEffects(false),

        hidingInProgress(false),

        delayedHide(false),

        delayedStartEffects(false),

        emitVisibilityChangeSignal(false),

        minimumToolButtonSize(QSizeF()),

        maxToolBarButtons(-1),

        moreExtension(0),

        moreExtensionButton(0),

        mDialogToolBar(false),

        mDoLayoutPending(true),

        mOrientationEffectsRunning(false),

        mSuppressNextAppearEffect(false),

{

}

HbToolBarPrivate::~HbToolBarPrivate()

{

    if (moreExtension) {

        moreExtension->deleteLater();

    }

    foreach (HbToolButton *button, mToolButtons) {

        delete button;

        button = 0;

    }

}

void HbToolBarPrivate::init()

{

}

void HbToolBarPrivate::doLazyInit()

{

#ifdef HB_EFFECTS

    hasEffects = effectsLoaded;

    if (effectsLoaded) {

        return;

    }

    hasEffects = HbEffectInternal::add(HB_TOOLBAR_ITEM_TYPE, "toolbar_appear", "appear");

    if (hasEffects) {

        hasEffects = HbEffectInternal::add(HB_TOOLBAR_ITEM_TYPE,

                                           "toolbar_appear_left", "appear_left");

    }

    if (hasEffects) {

        hasEffects = HbEffectInternal::add(HB_TOOLBAR_ITEM_TYPE,

                                           "toolbar_appear_right", "appear_right");

    }

    if (hasEffects) {

        hasEffects = HbEffectInternal::add(HB_TOOLBAR_ITEM_TYPE,

                                           "toolbar_disappear", "disappear");

    }

    if (hasEffects) {

        hasEffects = HbEffectInternal::add(HB_TOOLBAR_ITEM_TYPE,

                                           "toolbar_disappear_left", "disappear_left");

    }

    if (hasEffects) {

        hasEffects = HbEffectInternal::add(HB_TOOLBAR_ITEM_TYPE,

                                           "toolbar_disappear_right", "disappear_right");

    }

    if (hasEffects) {

        hasEffects = HbEffectInternal::add(HB_TOOLBAR_ITEM_TYPE,

                                           "toolbar_orient_appear", "appear_orient");

    }

    if (hasEffects) {

        hasEffects = HbEffectInternal::add(HB_TOOLBAR_ITEM_TYPE,

                                           "toolbar_orient_disappear", "disappear_orient");

    }

    if (hasEffects) {

        hasEffects = HbEffectInternal::add(HB_TOOLBAR_ITEM_TYPE,

                                           "toolbar_orient_appear_right", "appear_orient_right");

    }

    if (hasEffects) {

        hasEffects = HbEffectInternal::add(HB_TOOLBAR_ITEM_TYPE,

                                           "toolbar_orient_disappear_right", "disappear_orient_right");

    }

    if (hasEffects) {

        hasEffects = HbEffectInternal::add(HB_TOOLBAR_ITEM_TYPE,

                                           "toolbar_orient_appear_left", "appear_orient_left");

    }

    if (hasEffects) {

        hasEffects = HbEffectInternal::add(HB_TOOLBAR_ITEM_TYPE,

                                           "toolbar_orient_disappear_left", "disappear_orient_left");

    }

    effectsLoaded = true;

#endif    

}

//This will be used by hbscreen to control when

//toolbar layouting is handled

void HbToolBarPrivate::delayedConstruction()

{

}

void HbToolBarPrivate::setOrientation( Qt::Orientation orientation )

{

    if ( mOrientation != orientation ) {

        mOrientation = orientation;

        emit core.orientationChanged();

        updateButtonsLayoutDirection();

    }

}

void HbToolBarPrivate::calculateMaximumButtons() {

    Q_Q(HbToolBar);

    maxToolBarButtons = DEFAULT_TOOLBUTTON_COUNT;

    if (!minimumToolButtonSize.isEmpty()) {

        if (mOrientation == Qt::Horizontal) {

            if ((q->size().width() > 0) && (q->size().width() > minimumToolButtonSize.width()))

                maxToolBarButtons = int(q->size().width() / minimumToolButtonSize.width());

        } else {

            if ((q->size().height() > 0) && (q->size().height() > minimumToolButtonSize.height()))

                maxToolBarButtons = int(q->size().height() / minimumToolButtonSize.height());

        }

    }

}

//This is called when new action is added and toolbar is visible and polished.

//we check if a full layout is needed if not just add the

//new button in right place.

void HbToolBarPrivate::actionAdded(int index)

{

    if (fullUpdateNeeded()){

        doLayout();

        return;

    }

    if (mVisibleToolButtons.count()<=maxToolBarButtons){

        HbToolButton *button = mVisibleToolButtons.at(index);

        prepareButtonForToolbar(button);

        mLayout->insertItem(index, button);

    }

    else{

        if (moreExtension){

            prepareButtonForExtension(mVisibleToolButtons.at(index));

            HbToolBarExtensionPrivate::d_ptr(moreExtension)->doLayout();

        }

    }

    updateButtons(maxToolBarButtons);

}

//This is called when new action is removed and toolbar is visible and polished.

//we check if a full layout is needed if not just remove the

//button from right place.

void HbToolBarPrivate::actionRemoved(int index,HbToolButton *button)

{

    if (fullUpdateNeeded(index)){

        doLayout();

        return;

    }

    if (index<=maxToolBarButtons -1){

        if (mLayout && button){

            mLayout->removeItem(button);

            mLayout->invalidate();

            mLayout->activate();

            updateButtons(maxToolBarButtons);

        }

    }

    else if(moreExtension){

        int buttonindex = HbToolBarExtensionPrivate::d_ptr(moreExtension)->mToolButtons.indexOf(button);

        if (buttonindex != -1){

            HbToolBarExtensionPrivate::d_ptr(moreExtension)->mToolButtons.removeAt(buttonindex);

            HbToolBarExtensionPrivate::d_ptr(moreExtension)->doLayout();

        }

    }

}

//This is called when toolbar receives resize event.

//we check if a full layout is needed than call doLayout.

//if maxVisiblebuttons have changed than also we do a complete

//layout

void HbToolBarPrivate::updateToolBarForSizeChange()

{

    if (mDoLayoutPending || maxToolBarButtons == -1 || !minimumToolButtonSize.isValid()){

        doLayout();

        return;

    }

    const int currentMaxButtons = maxToolBarButtons;

    calculateMaximumButtons();

    if (currentMaxButtons == maxToolBarButtons)

        return;

    if (mVisibleToolButtons.count()<=maxToolBarButtons  &&

        (!moreExtensionButton  ||

         (moreExtensionButton &&

          !HbToolButtonPrivate::d_ptr(moreExtensionButton)->action->isVisible()))) {

        return;

    }

    doLayout();

}

//Here we check if a full update for toolbar is needed or not

bool HbToolBarPrivate::fullUpdateNeeded()

{

    if (maxToolBarButtons == -1 || !minimumToolButtonSize.isValid() || !mLayout)

        return true;

    int totalButtons = mVisibleToolButtons.count()-1;

    if (totalButtons>maxToolBarButtons -1 &&

        (!moreExtensionButton  ||

         (moreExtensionButton &&

          !HbToolButtonPrivate::d_ptr(moreExtensionButton)->action->isVisible()))) {

        return true;

    }

    if (totalButtons<=maxToolBarButtons  &&

        (moreExtensionButton &&

         HbToolButtonPrivate::d_ptr(moreExtensionButton)->action->isVisible())) {

        return true;

    }

    return false;

}

//Here we check if a full update for toolbar is needed or not

bool HbToolBarPrivate::fullUpdateNeeded(int index)

{

    if (maxToolBarButtons == -1 || !minimumToolButtonSize.isValid() || !mLayout)

        return true;

    if (index>maxToolBarButtons -1 &&  (!moreExtensionButton  || (moreExtensionButton && !moreExtensionButton ->isVisible())))

        return true;

    if (index<=maxToolBarButtons  && ((moreExtensionButton && moreExtensionButton ->isVisible()) ||

                                      (moreExtension &&  mVisibleToolButtons.count() >= maxToolBarButtons)))

        return true;

    return false;

}

//calculates minimum button size

void HbToolBarPrivate::calculateButtonMinimumSize()

{

    HbToolButton *button = mVisibleToolButtons.first();

    //Avoiding unnecessary polish, so setting parameters for first button

    prepareButtonForToolbar(button);

    minimumToolButtonSize = HbToolButtonPrivate::d_ptr(button)->getMinimumSize();

}

//We prepare  button to be added to toolbarextension(in more button)

void HbToolBarPrivate::prepareButtonForExtension(HbToolButton *button)

{

    if(!moreExtension)

        return;

    HbToolBarExtensionPrivate::d_ptr(moreExtension)->mToolButtons.append(button);

    updateButtonStyle(button, false);

    setExtensionLayout(button, true);

    if (!button->parentItem() || button->parentItem() != moreExtension->contentWidget()){

        button->setSizePolicy(QSizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred));

        QAction *action = HbToolButtonPrivate::d_ptr(button)->action;

        QObject::connect(action, SIGNAL(triggered(bool)),

                         moreExtension, SLOT(close()));

        button->setParentItem(moreExtension->contentWidget());

    }

}

//We prepare button to be added for toolbar

void HbToolBarPrivate::prepareButtonForToolbar(HbToolButton *button)

{

    Q_Q(HbToolBar);

    updateButtonStyle(button, true);

    if (!button->parentItem() || button->parentItem() != q){

        bool movingFromExtension = moreExtension && (button->parentItem() == moreExtension->contentWidget());

        button->setParentItem(q);

        setExtensionLayout(button, false);

        // tool buttons should eat all the space in the toolbar

        if (mOrientation == Qt::Horizontal)

            button->setSizePolicy(QSizePolicy(QSizePolicy::Ignored, QSizePolicy::Preferred));

        else

            button->setSizePolicy(QSizePolicy(QSizePolicy::Preferred, QSizePolicy::Ignored));

        if (movingFromExtension){

            QAction *action = HbToolButtonPrivate::d_ptr(button)->action;

            QObject::disconnect(action, SIGNAL(triggered(bool) ),

                                moreExtension, SLOT(close()));

            HbToolButtonPrivate::d_ptr(button)->setExtensionBackgroundVisible(false);

        }

    }

}

//resets all visible buttons list.This is called when actionChange event is received

//by toolbar and from doLayout when mDoLayoutPending is true

void HbToolBarPrivate::resetVisibleButtonsList()

{

    mVisibleToolButtons.clear();

    foreach(HbToolButton *button, mToolButtons) {

        QAction *action = HbToolButtonPrivate::d_ptr(button)->action;

        if (action->isVisible()) {

            mVisibleToolButtons.append(button);

            button->setVisible(true);

        } else {

            button->setVisible(false);

        }

    }

}

//creates a new toolbutton and calls actionAdded if update is true.

//update can be true in cases where toolbar is polished and actionAdded

//event is received by toolbar.

//we emit visibilitychanged signal here if this is the firstAction added in cases

//after toolbar is polished and visible.

void HbToolBarPrivate::createToolButton(QAction *newAction, bool update)

{

    Q_Q(HbToolBar);

    if(!newAction)

        return;

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

    // Find out index where to insert button

    int index = q->actions().indexOf(newAction);

    HbToolButton *button = new HbToolButton;

    if (hbAction) {

        // Lets give the action manager possibility to calculate position for the action

        if (hbAction->commandRole() != HbAction::NoRole) {

            // Create action manager when needed

            if (!actionManager) {

                actionManager = new HbActionManager(HbView::ToolBar, q, q->mainWindow());

            }

            if (actionManager){

                index = actionManager->position(hbAction, q->actions(), mVisibleToolButtons.count());

            }

        }

        button->setAction(hbAction);

    }

    else {

        // The new action's type is QAction.

        HbToolButtonPrivate::d_ptr(button)->action = newAction;

        QObject::connect(newAction, SIGNAL(triggered()), button, SLOT(_q_actionTriggered()));

        QObject::connect(newAction, SIGNAL(changed()), button, SLOT(_q_actionChanged()));

    }

    HbToolButtonPrivate::d_ptr(button)->mDialogToolBar = mDialogToolBar;

    setButtonLayoutDirection(*button);

    mToolButtons.insert(index, button);

    if (newAction->isVisible()){

        int visibleIndex = 0;

        for (int i = 0; i < index; i++) {

            QAction *action = HbToolButtonPrivate::d_ptr(mToolButtons.at(i))->action;

            if (action->isVisible())

                visibleIndex++;

        }

        mVisibleToolButtons.insert(visibleIndex, button);

        if (update){

            if (emitVisibilityChangeSignal) {

                delayedStartEffects = !mSuppressNextAppearEffect;

                QMetaObject::invokeMethod(&core, "visibilityChanged");

                emitVisibilityChangeSignal = false;

            }

            actionAdded(visibleIndex);

        }

    }

}

//called from doLayout.We update the more button and extension as needed

void HbToolBarPrivate::updateExtension(bool moreButtonNeeded)

{

    Q_Q(HbToolBar);

    if (moreExtension) {

        HbToolBarExtensionPrivate::d_ptr(moreExtension)->mToolButtons.clear();

        HbToolBarExtensionPrivate::d_ptr(moreExtension)->contentWidget->setLayout(0);

        HbToolButtonPrivate::d_ptr(moreExtensionButton)->action->setVisible(moreButtonNeeded);

        moreExtensionButton->setVisible(moreButtonNeeded);

    }

    else if (moreButtonNeeded && !moreExtension)  {

        moreExtension = new HbToolBarExtension();

        moreExtensionButton = new HbToolButton(moreExtension->extensionAction(), q);

        moreExtensionButton->setSizePolicy(QSizePolicy(QSizePolicy::Ignored, QSizePolicy::Ignored));

        HbIcon extensionIcon("qtg_mono_more");

        moreExtension->extensionAction()->setIcon(extensionIcon);

        initToolBarExtension(moreExtension);

        HbToolButtonPrivate::d_ptr(moreExtensionButton)->setToolBarPosition(

                HbToolButtonPrivate::TB_End);

        moreExtensionButton->setProperty(BUTTONSTYLE, HbToolButtonPrivate::ToolButtonIcon);

    }

}

void HbToolBarPrivate::startAppearOrientEffect()

{

    Q_Q(HbToolBar);

    if (!q->isVisible() && !mOrientationEffectsRunning)

        return;

    updateToolBarForSizeChange();

    QGraphicsItem *parentItem = q->parentItem();

    if (parentItem && q->orientation() == Qt::Horizontal) {

        QRectF extRect(0.0,

                       parentItem->boundingRect().height(),

                       q->boundingRect().width(),

                       q->boundingRect().height());

        HbEffect::start(q, HB_TOOLBAR_ITEM_TYPE, "appear_orient");

    } else if (parentItem && q->orientation() == Qt::Vertical) {

        QRectF extRect(parentItem->boundingRect().width(),

                       parentItem->boundingRect().height() - q->boundingRect().height(),

                       q->boundingRect().width(),

                       q->boundingRect().height());

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

            HbEffect::start(q, HB_TOOLBAR_ITEM_TYPE, "appear_orient_right", q, 0, QVariant(), extRect);

        else if (q->layoutDirection() == Qt::RightToLeft) {

            extRect.setX(-extRect.x());

            HbEffect::start(q, HB_TOOLBAR_ITEM_TYPE, "appear_orient_left", q, 0, QVariant(), extRect);

        }

    }

    q->setVisible(true);

    mOrientationEffectsRunning = false;

}

void HbToolBarPrivate::startDisappearOrientEffect()

{

    Q_Q(HbToolBar);

    if (!q->isVisible())

        return;

    QGraphicsItem *parentItem = q->parentItem();

    if ( moreExtension && moreExtension->isVisible() ) {

        moreExtension->hide();

    }

    if (parentItem && q->orientation() == Qt::Horizontal) {

        QRectF extRect(0.0,

                       parentItem->boundingRect().height(),

                       q->boundingRect().width(),

                       q->boundingRect().height());

        HbEffect::start(q, HB_TOOLBAR_ITEM_TYPE, "disappear_orient",q,"_q_delayedHide");

    } else if (parentItem && q->orientation() == Qt::Vertical) {

        QRectF extRect(parentItem->boundingRect().width(),

                       parentItem->boundingRect().height() - q->boundingRect().height(),

                       q->boundingRect().width(),

                       q->boundingRect().height());

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

            HbEffect::start(q, HB_TOOLBAR_ITEM_TYPE, "disappear_orient_right", q,"_q_delayedHide", QVariant(), extRect);

        else if (q->layoutDirection() == Qt::RightToLeft) {

            extRect.setX(-q->boundingRect().width());

            HbEffect::start(q, HB_TOOLBAR_ITEM_TYPE, "disappear_orient_left", q,"_q_delayedHide", QVariant(), extRect);

        }

    }

  mOrientationEffectsRunning = true;

}

//Does a complete update of toolbar

void HbToolBarPrivate::doLayout()

{    

    Q_Q(HbToolBar);

    if (q->actions().isEmpty()){