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

**

** 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 <QFile>

#include <QDebug>

#include <QAction>

#include "hbinstance.h"

#include "hbmenu.h"

#include "hbactionmanager_p.h"

#include "hbactionmanagerxmlparser_p.h"

#include "hbmainwindow.h"

/*

     @proto

     @hbcore

    \class HbActionManager

    \brief HbActionManager is the class that calculates the position of 

    an action inside of a container (options menu or toolbar). 

    Calcutation is based the UI commands container template that is read

    automatically.

    \internal

*/

/* 

    Constructor.

*/

HbActionManager::HbActionManager(HbView::ActionContainer container, 

                                 QObject *parent, 

                                 HbMainWindow *mainWindow) :

    QObject(parent), container(container), orientation(Qt::Vertical)

{

    if (mainWindow) {

        connect(mainWindow, SIGNAL(aboutToChangeOrientation()),

                this, SLOT(orientationAboutToChange()));

        orientation = mainWindow->orientation();

    }

    createTemplate();

    if (container == HbView::OptionsMenu) {

        parent->installEventFilter(this);

    }

}

/* 

    Destructor.

*/

HbActionManager::~HbActionManager()

{

    actionTemplate.clear();

}

/* 

    Calculates and returns the position of the action 

    based on the container template.

*/

int HbActionManager::position(QAction *aAction, QList<QAction *> actions, int maxPos) const

{

    if (actions.count() == 0) {

        return 0;

    }

    if (maxPos < 0) {

        maxPos = actions.count();

    }

    // try to downcast aAction. If that fails, return a fallback value

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

    if (!action){

        return maxPos;

    }

    int index = templateIndex(action);

    if (index == -1) {

        return maxPos;

    }

    int pos(0);

    foreach (QAction *qaction, actions) {

        HbAction *containerAction = qobject_cast<HbAction *>(qaction);

        if (!containerAction) {

            break;

        }

        int containerIndex = templateIndex(containerAction);

        if (index < containerIndex) {

            break;

        }

        else {

            pos++;

        }

    }

    if (pos > maxPos) {

        pos = maxPos;

    }

    return pos;

}

/*

    Adds a new item to the container template. Used by HbActionManagerXmlParser.

    \internal

 */

void HbActionManager::addItem(HbAction::CommandRole role)

{ 

    TemplateItem item(role);

    actionTemplate.append(item);

}

/* 

    Calculates and returns the action based on the container template.

*/

QAction *HbActionManager::orderedAction(const int index, QList<QAction *> actions)

{

    QAction *action = 0;

    if (orderedActions.isEmpty()) {

        foreach (QAction *qaction, actions) {

            HbAction *containerAction = qobject_cast<HbAction *>(qaction);

            if (orderedActions.isEmpty()) {

                orderedActions.append(containerAction);

            }

            else {

                int containerIndex = templateIndex(containerAction);

                int i = 0;

                for (i = 0; i < orderedActions.size(); i++) {

                    int index = templateIndex(orderedActions[i]);

                    if (containerIndex < index) {

                        orderedActions.insert(i, containerAction);

                        break;

                    }

                }

                if (i == orderedActions.size()) {

                    orderedActions.append(containerAction);

                }

            }

        }

    }

    if (index >= 0 && index < orderedActions.size()) {

        action = orderedActions[index];

    }

    return action;

}

/*

   This signal is emitted when orientation change starts.

    \sa HbMainWindow aboutToChangeOrientation

 */

void HbActionManager::orientationAboutToChange()

{

    if (orientation == Qt::Vertical) {

        orientation = Qt::Horizontal;

    }

    else {

        orientation = Qt::Vertical;

    }

    actionTemplate.clear();

    createTemplate();

}

bool HbActionManager::eventFilter(QObject *object, QEvent *event)

{

    Q_UNUSED(object);

    if ((event->type() == QEvent::ActionAdded || event->type() == QEvent::ActionRemoved) &&

        !orderedActions.isEmpty()) {

        orderedActions.clear();

    }

    return false;

}

void HbActionManager::createTemplate()

{

    QFile file;

    QString path(":/actionmanager/");

    if (container == HbView::ToolBar) {

        if (orientation == Qt::Vertical) {

            file.setFileName(path + "action_template_toolbar_vertical.xml");

        }

        else {

            file.setFileName(path + "action_template_toolbar_horizontal.xml");

        }

    }

    else {

        if (orientation == Qt::Vertical) {

            file.setFileName(path + "action_template_menu_vertical.xml");

            }

        else {

            file.setFileName(path + "action_template_menu_horizontal.xml");

        }

    }

    if (!file.open(QIODevice::ReadOnly)) {

        qWarning("HbActionManager::createTemplate: opening file failed");

     } 

    else {

        HbActionManagerXmlParser reader(this);

        if (!reader.read(&file)) {

            qWarning("HbActionManager::createTemplate: reading file failed");

        }        

    }

}

int HbActionManager::templateIndex(HbAction *action) const

{

    TemplateItem item(action->commandRole());

    int index = actionTemplate.indexOf(item);

    return index;

}