qxttabwidget.cpp

Go to the documentation of this file.

/****************************************************************************
 **
 ** Copyright (C) Qxt Foundation. Some rights reserved.
 **
 ** This file is part of the QxtGui module of the Qxt library.
 **
 ** This library is free software; you can redistribute it and/or modify it
 ** under the terms of the Common Public License, version 1.0, as published
 ** by IBM, and/or under the terms of the GNU Lesser General Public License,
 ** version 2.1, as published by the Free Software Foundation.
 **
 ** This file is provided "AS IS", without WARRANTIES OR CONDITIONS OF ANY
 ** KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT LIMITATION, ANY
 ** WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY OR
 ** FITNESS FOR A PARTICULAR PURPOSE.
 **
 ** You should have received a copy of the CPL and the LGPL along with this
 ** file. See the LICENSE file and the cpl1.0.txt/lgpl-2.1.txt files
 ** included with the source distribution for more information.
 ** If you did not receive a copy of the licenses, contact the Qxt Foundation.
 **
 ** <http://libqxt.org>  <foundation@libqxt.org>
 **
 ****************************************************************************/
#include "qxttabwidget.h"
#include "qxttabwidget_p.h"
#include "qxttabbar.h"
#include <QContextMenuEvent>
#include <QApplication>
#include <QTabBar>
#include <QAction>
#include <QMovie>
#include <QMenu>

QxtTabWidgetPrivate::QxtTabWidgetPrivate() : always(true), policy(Qt::DefaultContextMenu)
{
}

int QxtTabWidgetPrivate::tabIndexAt(const QPoint& pos) const
{
    const int count = qxt_p().count();
    const QTabBar* tabBar = qxt_p().tabBar();
    for (int i = 0; i < count; ++i)
        if (tabBar->tabRect(i).contains(pos))
            return i;
    return -1;
}

void QxtTabWidgetPrivate::setMovieFrame(int frame)
{
    Q_UNUSED(frame);
    QMovie* movie = static_cast<QMovie*>(sender());
    if (movie)
    {
        int index = animations.indexOf(movie);
        if (index != -1)
            qxt_p().setTabIcon(index, movie->currentPixmap());
    }
}

QxtTabWidget::QxtTabWidget(QWidget* parent) : QTabWidget(parent)
{
    QXT_INIT_PRIVATE(QxtTabWidget);
    QTabWidget::setTabBar(new QxtTabBar);
}

QxtTabWidget::~QxtTabWidget()
{
}

bool QxtTabWidget::alwaysShowTabBar() const
{
    return qxt_d().always;
}

void QxtTabWidget::setAlwaysShowTabBar(bool always)
{
    qxt_d().always = always;
    tabBar()->setVisible(always || count() > 1);
}

QxtTabWidget::TabMovementMode QxtTabWidget::tabMovementMode() const
{
    return TabMovementMode(tabBar()->tabMovementMode());
}

void QxtTabWidget::setTabMovementMode(TabMovementMode mode)
{
    tabBar()->setTabMovementMode(QxtTabBar::TabMovementMode(mode));
}

Qt::ContextMenuPolicy QxtTabWidget::tabContextMenuPolicy() const
{
    return qxt_d().policy;
}

void QxtTabWidget::setTabContextMenuPolicy(Qt::ContextMenuPolicy policy)
{
    qxt_d().policy = policy;
}

void QxtTabWidget::addTabAction(int index, QAction* action)
{
    insertTabAction(index, 0, action);
}

QAction* QxtTabWidget::addTabAction(int index, const QString& text)
{
    return addTabAction(index, QIcon(), text, 0, 0);
}

QAction* QxtTabWidget::addTabAction(int index, const QIcon& icon, const QString& text)
{
    return addTabAction(index, icon, text, 0, 0);
}

QAction* QxtTabWidget::addTabAction(int index, const QString& text, const QObject* receiver, const char* member, const QKeySequence& shortcut)
{
    return addTabAction(index, QIcon(), text, receiver, member, shortcut);
}

QAction* QxtTabWidget::addTabAction(int index, const QIcon& icon, const QString& text, const QObject* receiver, const char* member, const QKeySequence& shortcut)
{
    QAction* action = new QAction(icon, text, this);
    addTabAction(index, action);
    if (receiver && member)
        connect(action, SIGNAL(triggered()), receiver, member);
    action->setShortcut(shortcut);
    return action;
}

void QxtTabWidget::addTabActions(int index, QList<QAction*> actions)
{
    foreach(QAction* action, actions)
    {
        insertTabAction(index, 0, action);
    }
}

void QxtTabWidget::clearTabActions(int index)
{
    Q_ASSERT(index >= 0 && index < qxt_d().actions.count());

    while (qxt_d().actions[index].count())
    {
        QAction* action = qxt_d().actions[index].last();
        removeTabAction(index, action);
        if (action->parent() == this)
            delete action;
    }
}

void QxtTabWidget::insertTabAction(int index, QAction* before, QAction* action)
{
    Q_ASSERT(index >= 0 && index < qxt_d().actions.count());

    if (!action)
    {
        qWarning("QxtTabWidget::insertTabAction: Attempt to insert a null action");
        return;
    }

    const Actions& actions = qxt_d().actions.at(index);
    if (actions.contains(action))
        removeTabAction(index, action);

    int pos = actions.indexOf(before);
    if (pos < 0)
    {
        before = 0;
        pos = actions.count();
    }
    qxt_d().actions[index].insert(pos, action);

    QActionEvent e(QEvent::ActionAdded, action, before);
    QApplication::sendEvent(this, &e);
}

void QxtTabWidget::insertTabActions(int index, QAction* before, QList<QAction*> actions)
{
    foreach(QAction* action, actions)
    {
        insertTabAction(index, before, action);
    }
}

void QxtTabWidget::removeTabAction(int index, QAction* action)
{
    Q_ASSERT(index >= 0 && index < qxt_d().actions.count());

    if (!action)
    {
        qWarning("QxtTabWidget::removeTabAction: Attempt to remove a null action");
        return;
    }

    if (qxt_d().actions[index].removeAll(action))
    {
        QActionEvent e(QEvent::ActionRemoved, action);
        QApplication::sendEvent(this, &e);
    }
}

QList<QAction*> QxtTabWidget::tabActions(int index) const
{
    Q_ASSERT(index >= 0 && index < qxt_d().actions.count());
    return qxt_d().actions.at(index);
}

QMovie* QxtTabWidget::tabAnimation(int index) const
{
    Q_ASSERT(index >= 0 && index < qxt_d().animations.count());
    return qxt_d().animations.at(index);
}

void QxtTabWidget::setTabAnimation(int index, QMovie* animation, bool start)
{
    Q_ASSERT(index >= 0 && index < qxt_d().animations.count());
    delete takeTabAnimation(index);
    qxt_d().animations[index] = animation;
    if (animation)
    {
        connect(animation, SIGNAL(frameChanged(int)), &qxt_d(), SLOT(setMovieFrame(int)));
        if (start)
            animation->start();
    }
}

void QxtTabWidget::setTabAnimation(int index, const QString& fileName, bool start)
{
    setTabAnimation(index, new QMovie(fileName, QByteArray(), this), start);
}

QMovie* QxtTabWidget::takeTabAnimation(int index)
{
    Q_ASSERT(index >= 0 && index < qxt_d().animations.count());
    QMovie* animation = qxt_d().animations.at(index);
    qxt_d().animations[index] = 0;
    return animation;
}

QxtTabBar* QxtTabWidget::tabBar() const
{
    return qobject_cast<QxtTabBar*>(QTabWidget::tabBar());
}

void QxtTabWidget::tabInserted(int index)
{
    Q_ASSERT(index >= 0);
    Q_ASSERT(index <= qxt_d().actions.count());
    Q_ASSERT(index <= qxt_d().animations.count());
    qxt_d().actions.insert(index, Actions());
    qxt_d().animations.insert(index, 0);
    tabBar()->setVisible(qxt_d().always || count() > 1);
}

void QxtTabWidget::tabRemoved(int index)
{
    Q_ASSERT(index >= 0);
    Q_ASSERT(index < qxt_d().actions.count());
    Q_ASSERT(index < qxt_d().animations.count());
    qxt_d().actions.removeAt(index);
    qxt_d().animations.removeAt(index);
    tabBar()->setVisible(qxt_d().always || count() > 1);
}

void QxtTabWidget::contextMenuEvent(QContextMenuEvent* event)
{
    const QPoint& pos = event->pos();
    if (!tabBar()->geometry().contains(pos))
        return QTabWidget::contextMenuEvent(event);

    const int index = qxt_d().tabIndexAt(event->pos());
    switch (qxt_d().policy)
    {
    case Qt::NoContextMenu:
        event->ignore();
        break;

#if QT_VERSION >= 0x040200
    case Qt::PreventContextMenu:
        event->accept();
        break;
#endif // QT_VERSION

    case Qt::ActionsContextMenu:
        if (index != -1 && qxt_d().actions.at(index).count())
        {
            QMenu::exec(qxt_d().actions.at(index), event->globalPos());
        }
        break;

    case Qt::CustomContextMenu:
        if (index != -1)
        {
            emit tabContextMenuRequested(index, event->globalPos());
        }
        break;

    case Qt::DefaultContextMenu:
    default:
        if (index != -1)
        {
            tabContextMenuEvent(index, event);
        }
        break;
    }
}

void QxtTabWidget::tabContextMenuEvent(int index, QContextMenuEvent* event)
{
    Q_UNUSED(index);
    event->ignore();
}