mtoolbarview.cpp

Go to the documentation of this file.

/***************************************************************************
**
** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation (directui@nokia.com)
**
** This file is part of libmeegotouch.
**
** If you have questions regarding the use of this file, please contact
** Nokia at directui@nokia.com.
**
** This library is free software; you can redistribute it and/or
** modify it 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.
**
****************************************************************************/

#include <QGraphicsLinearLayout>
#include "mtoolbar.h"
#include "mtoolbar_p.h"
#include "mtoolbarlayoutpolicy.h"
#include "mtheme.h"
#include "mbutton.h"
#include "mbuttongroup.h"
#include "mwidgetaction.h"
#include "private/mwidgetview_p.h"

#include "mlayout.h"
#include "mlinearlayoutpolicy.h"
#include "mtextedit.h"
#include "mtoolbarview.h"
#include "mtoolbarview_p.h"
#include "mscalableimage.h"
#include "mscenemanager.h"


MToolBarViewPrivate::MToolBarViewPrivate(MToolBar *controller)
    : QObject(),
      q_ptr(0),
      layout(0),
      landscapePolicy(0),
      portraitPolicy(0),
      buttonGroup(0),
      iconsEnabled(true),
      labelsEnabled(false),
      labelOnlyAsCommonButton(true)
{
    this->controller = controller;
    controller->installEventFilter(this);
}


MToolBarViewPrivate::~MToolBarViewPrivate()
{
    removeEventFilter(controller);
    if(buttonGroup) {
        delete buttonGroup;
        buttonGroup = NULL;
    }
    QHashIterator<QAction *, MWidget *> iterator(leasedWidgets);
    while (iterator.hasNext()) {
        iterator.next();

        if (!releaseWidget(iterator.key(), iterator.value()))
            delete iterator.value(); //Is this the right thing to do ?
    }
    qDeleteAll(buttons);
    delete layout;
    layout = NULL;
}

void MToolBarViewPrivate::init()
{
    layout = new MLayout;
    layout->setAnimation(NULL);
    layout->setContentsMargins(0, 0, 0, 0);

    landscapePolicy = new MToolBarLayoutPolicy(layout);
    landscapePolicy->setStyleName("ToolBarLandscapePolicy");
    layout->setLandscapePolicy(landscapePolicy);

    portraitPolicy = new MToolBarLayoutPolicy(layout);
    portraitPolicy->setStyleName("ToolBarPortraitPolicy");
    layout->setPortraitPolicy(portraitPolicy);

    QGraphicsLinearLayout *controllerlayout = (QGraphicsLinearLayout *)(controller->layout());
    controllerlayout->addItem(layout);

    //Add any existing actions now
    foreach(QAction *action, controller->actions()) {
        add(action);
    }

    updateWidgetAlignment();
}

int MToolBarViewPrivate::policyIndexForAddingAction(QAction *action, MToolBarLayoutPolicy *policy) const {
    Q_Q(const MToolBarView);
    //We need to add the action's given widget to the policy
    //This is a bit complicated because we ideally want to add it in the right place,
    //preserving the same order as in the controller->actions()
    QList< QAction *> actions = controller->actions();
    int parentIndex = actions.indexOf(action)+1;
    int index = policy->widgetCount();
    while(parentIndex < actions.size()) {
        MWidget *w = q->getWidget(actions.at(parentIndex));
        if(w) {
            int policyIndex = policy->widgetIndexOf(w);
            if(policyIndex >= 0) {
                index = policyIndex;
                break;
            }
        }
        parentIndex++;
    }
    if(policy->roomForWidget(index, hasTextEditWidget(action)))
        return index;
    return -1;
}

void MToolBarViewPrivate::add(QAction *action)
{
    if (!action || !action->isVisible() || hasUnusableWidget(action))
        return; //Cancel adding action

    // add to policies only if the action is visible
    int landscapeIndex = -1;
    int portraitIndex = -1;
    if (isLocationValid(action, MAction::ToolBarLandscapeLocation))
        landscapeIndex = policyIndexForAddingAction(action, landscapePolicy);
    if (isLocationValid(action, MAction::ToolBarPortraitLocation))
        portraitIndex = policyIndexForAddingAction(action, portraitPolicy);

    if (landscapeIndex == -1 && portraitIndex == -1)
        return; //Cancel adding action
    MWidget *widget = createWidget(action);
    Q_ASSERT(widget);

    updateWidgetFromAction(widget, action);

    if (landscapeIndex != -1)
        landscapePolicy->insertWidgetAndRemoveOverflow( landscapeIndex, widget );
    if (portraitIndex != -1)
        portraitPolicy->insertWidgetAndRemoveOverflow( portraitIndex, widget );

    updateEmptinessProperty();
}

void MToolBarViewPrivate::remove(QAction *action, bool hideOnly)
{
    MButton *button = buttons.value(action);
    MWidget *leased = leasedWidgets.value(action);
    MWidget *widget = (button != 0) ? button : leased;
    if(!widget)
        return;

    if (button && buttonGroup)
        buttonGroup->removeButton(button);
    if(hideOnly) {
        landscapePolicy->removeWidget(widget);
        portraitPolicy->removeWidget(widget);
        if (button)
            button->setChecked(false);
    } else {
        //Need to fully remove the action
        layout->removeItem(widget);

        if (button) {
            buttons.remove(action);
            delete button;
        } else {
            releaseWidget(action, leased);
            leasedWidgets.remove(action);
        }
    }

    //There might be space now any actions not already added.  Signal a change action which
    //will check if an item now has room to be shown
    foreach(QAction *action2, controller->actions()) {
        if (action2 != action && action2->isVisible() &&
            (isLocationValid(action2, MAction::ToolBarLandscapeLocation) ||
             isLocationValid(action2, MAction::ToolBarPortraitLocation)))
            change(action2);
    }
    updateEmptinessProperty();
}

void MToolBarViewPrivate::change(QAction *action)
{
    Q_Q(MToolBarView);
    if(hasUnusableWidget(action))
        return;
    if(!action->isVisible()) {
        remove(action, true); //Remove action, but only hiding the widget, not deleting/releasing it
        return;
    }
    bool validInLandscape = isLocationValid(action, MAction::ToolBarLandscapeLocation);
    bool validInPortrait = isLocationValid(action, MAction::ToolBarPortraitLocation);
    if (!validInLandscape && !validInPortrait) {
        remove(action, true);
        return;
    }

    //Check that the widget is in the controller actions
    QList< QAction *> actions = controller->actions();
    int indexOfAction = actions.indexOf(action);
    if(indexOfAction == -1) {
        remove(action, false); // I don't think this is possible
        return;
    }

    MWidget *widget = q->getWidget(action);
    if (!widget) {
        //We need to add the action
        add(action);
        return;
    }
    if(buttonGroup) {
        MButton *button = buttons.value(action);
        if(button)
            buttonGroup->addButton(button);
    }

    //We have now an action and a widget for it
    int landscapeIndex = landscapePolicy->widgetIndexOf(widget);
    int portraitIndex = portraitPolicy->widgetIndexOf(widget);
    if(!validInLandscape && landscapeIndex >= 0) {
        //We are showing it in landscape view but should not be
        landscapePolicy->removeWidgetAt(landscapeIndex);
    }
    if(!validInPortrait && portraitIndex >= 0) {
        //We are showing it in portrait view but should not be
        portraitPolicy->removeWidgetAt(portraitIndex);
    }

    updateWidgetFromAction(widget, action);

    if(validInLandscape && landscapeIndex == -1) {
        int index = policyIndexForAddingAction(action, landscapePolicy);
        if(index != -1)
            landscapePolicy->insertWidgetAndRemoveOverflow( index, widget );
    }
    if(validInPortrait && portraitIndex == -1) {
        int index = policyIndexForAddingAction(action, portraitPolicy);
        if(index != -1)
            portraitPolicy->insertWidgetAndRemoveOverflow( index, widget );
    }
}

void MToolBarViewPrivate::updateWidgetFromAction(MWidget *widget, QAction *action) const
{
    widget->setEnabled(action->isEnabled());
    MButton *button = qobject_cast<MButton *>(widget);
    if (button) {
        // Update button data accordingly
        button->setCheckable(action->isCheckable());
        button->setChecked(action->isChecked());

        // Only update the text and icon if we created the button
        if (buttons.contains(action)) {
            button->setText(action->text());
            button->setTextVisible(labelsEnabled);

            MAction *mAction = qobject_cast<MAction *>(action);
            if (mAction) {
                button->setIconID(mAction->iconID());
                button->setIconVisible(iconsEnabled);
            }

            updateViewAndStyling(button);
        }
    }
}

bool MToolBarViewPrivate::eventFilter(QObject *obj, QEvent *e)
{
    switch (e->type()) {
        case QEvent::ActionRemoved:
            remove(static_cast<QActionEvent *>(e)->action(), false);
            break;
        case QEvent::ActionAdded:
            add(static_cast<QActionEvent *>(e)->action());
            break;
        case QEvent::ActionChanged:
            change(static_cast<QActionEvent *>(e)->action());
            break;

        case QEvent::DynamicPropertyChange:
            {
                QDynamicPropertyChangeEvent *propertyEvent = static_cast<QDynamicPropertyChangeEvent*>(e);
                if (propertyEvent->propertyName() == _M_IsEnabledPreservingSelection) {
                    bool enabledPreservingSelection = obj->property(_M_IsEnabledPreservingSelection).toBool();
                    setEnabledPreservingSelection(enabledPreservingSelection);
                } else if (propertyEvent->propertyName() == "widgetAlignment")
                    updateWidgetAlignment();
            }
            break;

        default:
            break;
    }
    return QObject::eventFilter(obj, e);
}

MWidget *MToolBarViewPrivate::createWidget(QAction *action)
{
    Q_Q(MToolBarView);
    // If widget is not already created then create it
    MWidget *widget = buttons.value(action);
    if (!widget)
        widget = leasedWidgets.value(action);
    if (!widget) {
        MWidgetAction *widgetAction = qobject_cast<MWidgetAction *>(action);
        if (widgetAction) {
            widget = widgetAction->requestWidget(NULL);
            leasedWidgets.insert(action, widget);
            widget->show();
        } else {
            MButton *button = new MButton;
            button->setMinimumSize(0,0);

            button->setObjectName("toolbaractioncommand");
            if (action && !action->objectName().isEmpty())
                button->setObjectName(button->objectName() + "_" + action->objectName());

            if(buttonGroup) {
                button->setCheckable(action->isCheckable());
                //We can't set button->checked until we've added it to the scene
                buttonGroup->addButton(button);
                connect(button, SIGNAL(toggled(bool)), q, SLOT(_q_groupButtonClicked(bool)));
                connect(action, SIGNAL(toggled(bool)), q, SLOT(_q_groupActionToggled(bool)));
            }

            connect(button, SIGNAL(clicked(bool)), action, SIGNAL(triggered()));

            buttons.insert(action, button);
            widget = button;
        }
    }
    Q_ASSERT(widget);
    return widget;
}
bool MToolBarViewPrivate::isLocationValid(QAction *action, MAction::Location loc) const
{
    MAction *mAction = qobject_cast<MAction *>(action);
    if(!mAction)
        return true; //A normal QAction is valid to place on toolbar
    return mAction->location().testFlag(loc);
}

bool MToolBarViewPrivate::releaseWidget(QAction *action, MWidget *widget) const
{
    MWidgetAction *widgetAction = qobject_cast<MWidgetAction *>(action);
    if (widgetAction) {
        widgetAction->releaseWidget(widget);
    }
    return (widgetAction != 0);
}

bool MToolBarViewPrivate::hasTextEditWidget(QAction *action) const
{
    MTextEdit *textEditWidget = 0;
    MWidgetAction *widgetAction = qobject_cast<MWidgetAction *>(action);
    if (widgetAction) {
        textEditWidget = qobject_cast<MTextEdit *>(widgetAction->widget());
    }
    return (textEditWidget != 0);
}

bool MToolBarViewPrivate::hasUnusableWidget(QAction *action) const
{
    if( buttons.contains(action) || leasedWidgets.contains(action) )
        return false; //If we are already using it, it must be usable
    MWidgetAction *widgetAction = qobject_cast<MWidgetAction *>(action);
    if(!widgetAction || !widgetAction->widget())
        return false; //We can create a button for it
    return widgetAction->isWidgetInUse();
}

MWidget *MToolBarView::getWidget(QAction *action) const
{
    Q_D(const MToolBarView);
    MWidget *button = d->buttons.value(action);
    if( button )
        return button;
    return d->leasedWidgets.value(action);
}

MWidget *MToolBarViewPrivate::getWidget(QAction *action) const
{
    return buttons.value(action);
}

void MToolBarViewPrivate::setEnabledPreservingSelection(bool enabled)
{
    // To ensure that buttons/widgets are restored correctly to their original state,
    // AND the state of their associated actions with the enabled parameter

    for (QHash<QAction *, MButton *>::const_iterator bit = buttons.constBegin(); bit != buttons.constEnd(); ++bit) {
        QAction *action = bit.key();
        MButton *button = bit.value();
        if (!button->isChecked()) {
            button->setEnabled(enabled && action->isEnabled());
        }
    }

    for (QHash<QAction *, MWidget *>::const_iterator wit = leasedWidgets.constBegin(); wit != leasedWidgets.constEnd(); ++wit) {
        QAction *action = wit.key();
        MWidget *widget = wit.value();
        MButton *button = qobject_cast<MButton *>(widget);
        if (!button || !button->isChecked()) {
            widget->setEnabled(enabled && action->isEnabled());
        }
    }
}

void MToolBarViewPrivate::_q_groupButtonClicked(bool checked)
{
    Q_Q(MToolBarView);
    MButton *button = qobject_cast<MButton *>(q->sender());
    if(!button)
        return; //impossible?

    button->setChecked(checked);

    QAction *action = buttons.key(button);
    if(action->isChecked() != checked)
        action->setChecked(checked);
}

void MToolBarViewPrivate::_q_groupActionToggled(bool checked)
{
    Q_Q(MToolBarView);
    QAction* action = qobject_cast<QAction *>(q->sender());
    Q_ASSERT(action);
    MButton *button = buttons.value(action);
    if (button) {
        button->setChecked(checked);
    }
}

void MToolBarViewPrivate::setCapacity(int newCapacity)
{
    if (newCapacity == -1)
        newCapacity = MToolBarLayoutPolicy::unlimitedCapacity;

    setCapacity(newCapacity, portraitPolicy);
    setCapacity(newCapacity, landscapePolicy);
}

void MToolBarViewPrivate::setCapacity(int newCapacity, MToolBarLayoutPolicy *policy)
{
    if (policy->maxWidgetSlots() == newCapacity)
        return;

    bool newRoom = (policy->effectiveMaxWidgetSlots() < newCapacity && policy->freeWidgetSlots() == 0);

    policy->setMaxWidgetSlots(newCapacity);

    if (newRoom)
        addActionsFromLeftOvers();
}

void MToolBarViewPrivate::addActionsFromLeftOvers()
{
    foreach (QAction *action, controller->actions()) {
        if (action->isVisible() &&
            (isLocationValid(action, MAction::ToolBarLandscapeLocation) ||
             isLocationValid(action, MAction::ToolBarPortraitLocation)))
            change(action);
    }
}

void MToolBarViewPrivate::setIconsEnabled(bool enabled)
{
    iconsEnabled = enabled;

    for (QHash<QAction *, MButton *>::const_iterator bit = buttons.constBegin(); bit != buttons.constEnd(); ++bit) {
        MButton *button = bit.value();
        if (button)
            button->setIconVisible(iconsEnabled);
    }
}

void MToolBarViewPrivate::setLabelsEnabled(bool enabled)
{
    labelsEnabled = enabled;

    for (QHash<QAction *, MButton *>::const_iterator bit = buttons.constBegin(); bit != buttons.constEnd(); ++bit) {
        MButton *button = bit.value();
        if (isLabelOnly(button))
            button->setTextVisible(true);
        else if (button)
            button->setTextVisible(labelsEnabled);
    }
}

void MToolBarViewPrivate::setSpacesEnabled(bool enabled)
{
    landscapePolicy->setSpacesBetween(enabled);
    portraitPolicy->setSpacesBetween(enabled);
}

void MToolBarViewPrivate::updateViewAndStyling(MButton *button) const
{
    QString toolBarButtonDefaultViewType = buttonGroup ? "toolbartab" : "toolbar";

    if (isLabelOnly(button)) {
        // Only label -> could use different styling
        button->setTextVisible(true); //In this case we will show label (as it is all we have)
        if (labelOnlyAsCommonButton) {
            if (button->viewType() != MButton::defaultType)
                button->setViewType(MButton::defaultType);
            button->setStyleName("ToolBarLabelOnlyCommonButton");
        } else {
            if (button->viewType() != toolBarButtonDefaultViewType)
                button->setViewType(toolBarButtonDefaultViewType);
            button->setStyleName("ToolBarLabelOnlyButton");
        }
    } else {
        if (button->viewType() != toolBarButtonDefaultViewType)
            button->setViewType(toolBarButtonDefaultViewType);
        button->setStyleName("ToolBarIconButton");
        button->setTextVisible(labelsEnabled);
    }
}

void MToolBarViewPrivate::updateWidgetAlignment()
{
    QVariant v = controller->property("widgetAlignment");
    Qt::AlignmentFlag alignment = v.isValid() ? static_cast<Qt::AlignmentFlag>(v.toInt()) : Qt::AlignHCenter;

    /* In here the Qt::Alignment is used like this:
       Qt::Alignment is used like this:
       AlignLeft = no prereserved slots on left
       AlignRight = no prereserved slots on right
       AlignJustify = no prereserved slots on left and right
       AlignHCenter = preseserved slots on left and right */

    landscapePolicy->setWidgetAlignment(alignment, v.isValid() ? true : false);
    portraitPolicy->setWidgetAlignment(alignment, v.isValid() ? true : false);

    if (alignment != Qt::AlignHCenter || !v.isValid())
        addActionsFromLeftOvers();
}

void MToolBarViewPrivate::updateEmptinessProperty()
{
    controller->setProperty("emptyInLandscape", landscapePolicy->widgetCount() == 0);
    controller->setProperty("emptyInPortrait", portraitPolicy->widgetCount() == 0);
}

void MToolBarViewPrivate::setLabelOnlyAsCommonButton(bool enable)
{
    if (labelOnlyAsCommonButton == enable)
        return;

    labelOnlyAsCommonButton = enable;

    for (QHash<QAction *, MButton *>::const_iterator bit = buttons.constBegin(); bit != buttons.constEnd(); ++bit) {
        MButton *button = bit.value();
        if (isLabelOnly(button))
            updateViewAndStyling(button);
    }

    landscapePolicy->setLabelOnlyButtonCentering(labelOnlyAsCommonButton);
    portraitPolicy->setLabelOnlyButtonCentering(labelOnlyAsCommonButton);
}

bool MToolBarViewPrivate::isLabelOnly(MButton *button) const
{
    return (button && !button->text().isEmpty() && button->iconID().isEmpty());
}


MToolBarView::MToolBarView(MToolBar *controller) :
    MWidgetView(controller),
    d_ptr(new MToolBarViewPrivate(controller))
{
    Q_D(MToolBarView);
    d->q_ptr = this;
    d->init();
}

MToolBarView::MToolBarView(MToolBarViewPrivate &dd, MToolBar *controller) :
    MWidgetView(controller),
    d_ptr(&dd)
{
    Q_D(MToolBarView);
    d->q_ptr = this;
    d->controller = controller;
    d->init();
}

MToolBarView::~MToolBarView()
{
    delete d_ptr;
}

QRectF MToolBarView::boundingRect() const
{
    QRectF br = MWidgetView::boundingRect();
    if (style()->dropShadowImage()) {
        br.setTop(-style()->dropShadowImage()->pixmap()->size().height());
    }
    return br;
}

void MToolBarView::drawBackground(QPainter *painter, const QStyleOptionGraphicsItem *option) const
{
    Q_D(const MToolBarView);

    //draw shadow on top of the actual toolbar on portrait mode
    if (d->controller->sceneManager() && d->controller->sceneManager()->orientation() == M::Portrait) {
        if (style()->dropShadowImage()) {
            style()->dropShadowImage()->draw(0,
                    -style()->dropShadowImage()->pixmap()->size().height(),
                    boundingRect().width(),
                    style()->dropShadowImage()->pixmap()->size().height(),
                    painter);
        }
    }
    MWidgetView::drawBackground(painter, option);
}

void MToolBarView::applyStyle()
{
    Q_D(MToolBarView);

    MWidgetView::applyStyle();

    d->setSpacesEnabled(style()->hasSpaces());
    d->setIconsEnabled(style()->hasIcons());
    d->setLabelsEnabled(style()->hasLabels());
    d->setLabelOnlyAsCommonButton(style()->labelOnlyAsCommonButton());
    d->setCapacity(style()->capacity());
    d->updateEmptinessProperty();
}

// bind view and controller together
M_REGISTER_VIEW_NEW(MToolBarView, MToolBar)

#include "moc_mtoolbarview.cpp"