diff options
Diffstat (limited to 'src/qt3support/widgets')
53 files changed, 28798 insertions, 0 deletions
diff --git a/src/qt3support/widgets/q3action.cpp b/src/qt3support/widgets/q3action.cpp new file mode 100644 index 0000000..d79d70a --- /dev/null +++ b/src/qt3support/widgets/q3action.cpp @@ -0,0 +1,2236 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the Qt3Support module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, 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 qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "q3action.h" + +#ifndef QT_NO_ACTION + +#include "qevent.h" +#include "q3toolbar.h" +#include "qlist.h" +#include "q3popupmenu.h" +#include "q3accel.h" +#include "qtoolbutton.h" +#include "qcombobox.h" +#include "qtooltip.h" +#include "qwhatsthis.h" +#include "qstatusbar.h" +#include "qaction.h" + +QT_BEGIN_NAMESPACE + +/*! + \class Q3Action + \brief The Q3Action class provides an abstract user interface + action that can appear both in menus and tool bars. + + \compat + + In GUI applications many commands can be invoked via a menu + option, a toolbar button and a keyboard accelerator. Since the + same action must be performed regardless of how the action was + invoked, and since the menu and toolbar should be kept in sync, it + is useful to represent a command as an \e action. An action can be + added to a menu and a toolbar and will automatically keep them in + sync. For example, if the user presses a Bold toolbar button the + Bold menu item will automatically be checked. + + A Q3Action may contain an icon, a menu text, an accelerator, a + status text, a "What's This?" text and a tool tip. Most of these can + be set in the constructor. They can also be set independently with + setIconSet(), setText(), setMenuText(), setToolTip(), + setStatusTip(), setWhatsThis() and setAccel(). + + An action may be a toggle action e.g. a Bold toolbar button, or a + command action, e.g. 'Open File' to invoke an open file dialog. + Toggle actions emit the toggled() signal when their state changes. + Both command and toggle actions emit the activated() signal when + they are invoked. Use setToggleAction() to set an action's toggled + status. To see if an action is a toggle action use + isToggleAction(). A toggle action may be "on", isOn() returns + true, or "off", isOn() returns false. + + Actions are added to widgets (menus or toolbars) using addTo(), + and removed using removeFrom(). Note that when using Q3ToolBar and + Q3PopupMenu, their actions must be Q3Actions. + + Once a Q3Action has been created it should be added to the relevant + menu and toolbar and then connected to the slot which will perform + the action. + + We recommend that actions are created as children of the window + that they are used in. In most cases actions will be children of + the application's main window. + + To prevent recursion, don't create an action as a child of a + widget that the action is later added to. +*/ + +class Q3ActionPrivate +{ +public: + Q3ActionPrivate(Q3Action *act); + ~Q3ActionPrivate(); + QIcon *icon; + QString text; + QString menutext; + QString tooltip; + QString statustip; + QString whatsthis; +#ifndef QT_NO_ACCEL + QKeySequence key; + Q3Accel* accel; + int accelid; +#endif + uint enabled : 1; + uint visible : 1; + uint toggleaction : 1; + uint on : 1; + uint forceDisabled : 1; + uint forceInvisible : 1; + Q3ActionGroupPrivate* d_group; + Q3Action *action; + + struct MenuItem { + MenuItem():popup(0),id(0){} + Q3PopupMenu* popup; + int id; + }; + // ComboItem is only necessary for actions that are + // in dropdown/exclusive actiongroups. The actiongroup + // will clean this up + struct ComboItem { + ComboItem():combo(0), id(0) {} + QComboBox *combo; + int id; + }; + //just bindings to the Qt4.0 widgets + struct Action4Item { + Action4Item():widget(0){} + QWidget* widget; + static QAction *action; + }; + QList<Action4Item *> action4items; + QList<MenuItem *> menuitems; + QList<QToolButton *> toolbuttons; + QList<ComboItem *> comboitems; + + enum Update { Icons = 1, Visibility = 2, State = 4, EverythingElse = 8 }; + void update(uint upd = EverythingElse); + + QString menuText() const; + QString toolTip() const; + QString statusTip() const; +}; +QAction *Q3ActionPrivate::Action4Item::action = 0; + +Q3ActionPrivate::Q3ActionPrivate(Q3Action *act) + : icon(0), +#ifndef QT_NO_ACCEL + key(0), accel(0), accelid(0), +#endif + enabled(true), visible(true), toggleaction(false), on(false), + forceDisabled(false), forceInvisible(false) + , d_group(0), action(act) +{ +} + +Q3ActionPrivate::~Q3ActionPrivate() +{ + QList<QToolButton*>::Iterator ittb(toolbuttons.begin()); + QToolButton *tb; + + while (ittb != toolbuttons.end()) { + tb = *ittb; + ++ittb; + delete tb; + } + + QList<Q3ActionPrivate::MenuItem*>::Iterator itmi(menuitems.begin()); + Q3ActionPrivate::MenuItem* mi; + while (itmi != menuitems.end()) { + mi = *itmi; + ++itmi; + Q3PopupMenu* menu = mi->popup; + if (menu->findItem(mi->id)) + menu->removeItem(mi->id); + } + qDeleteAll(menuitems); + + QList<Q3ActionPrivate::Action4Item*>::Iterator itmi4(action4items.begin()); + Q3ActionPrivate::Action4Item* mi4; + while (itmi4 != action4items.end()) { + mi4 = *itmi4; + ++itmi4; + mi4->widget->removeAction(mi4->action); + } + delete Q3ActionPrivate::Action4Item::action; + Q3ActionPrivate::Action4Item::action = 0; + qDeleteAll(action4items); + + QList<Q3ActionPrivate::ComboItem*>::Iterator itci(comboitems.begin()); + Q3ActionPrivate::ComboItem* ci; + while (itci != comboitems.end()) { + ci = *itci; + ++itci; + QComboBox* combo = ci->combo; + combo->clear(); + Q3ActionGroup *group = qobject_cast<Q3ActionGroup*>(action->parent()); + if (group) { + QObjectList siblings = group->queryList("Q3Action"); + + for (int i = 0; i < siblings.size(); ++i) { + Q3Action *sib = qobject_cast<Q3Action*>(siblings.at(i)); + sib->removeFrom(combo); + } + for (int i = 0; i < siblings.size(); ++i) { + Q3Action *sib = qobject_cast<Q3Action*>(siblings.at(i)); + if (sib == action) + continue; + sib->addTo(combo); + } + } + } + qDeleteAll(comboitems); + +#ifndef QT_NO_ACCEL + delete accel; +#endif + delete icon; +} + +class Q3ActionGroupPrivate +{ +public: + uint exclusive: 1; + uint dropdown: 1; + QList<Q3Action*> actions; + Q3Action* selected; + Q3Action* separatorAction; + + struct MenuItem { + MenuItem():popup(0),id(0){} + Q3PopupMenu* popup; + int id; + }; + struct Action4Item { + Action4Item():widget(0){} + QWidget* widget; + static QAction *action; + }; + QList<Action4Item *> action4items; + QList<QComboBox*> comboboxes; + QList<QToolButton*> menubuttons; + QList<MenuItem*> menuitems; + QList<Q3PopupMenu*> popupmenus; + + void update(const Q3ActionGroup *); +}; +QAction *Q3ActionGroupPrivate::Action4Item::action = 0; + +void Q3ActionPrivate::update(uint upd) +{ + for (QList<MenuItem*>::Iterator it(menuitems.begin()); it != menuitems.end(); ++it) { + MenuItem* mi = *it; + QString t = menuText(); +#ifndef QT_NO_ACCEL + if (key) + t += QLatin1Char('\t') + (QString)QKeySequence(key); +#endif + if (upd & State) { + mi->popup->setItemEnabled(mi->id, enabled); + if (toggleaction) + mi->popup->setItemChecked(mi->id, on); + } + if (upd & Visibility) + mi->popup->setItemVisible(mi->id, visible); + + if (upd & Icons) { + if (icon) + mi->popup->changeItem(mi->id, *icon, t); + else + mi->popup->changeItem(mi->id, QIcon(), t); + } + if (upd & EverythingElse) { + mi->popup->changeItem(mi->id, t); + if (!whatsthis.isEmpty()) + mi->popup->setWhatsThis(mi->id, whatsthis); + if (toggleaction) { + mi->popup->setCheckable(true); + mi->popup->setItemChecked(mi->id, on); + } + } + } + if(QAction *act = Action4Item::action) { + if (upd & Visibility) + act->setVisible(visible); + if (upd & Icons) { + if (icon) + act->setIcon(*icon); + else + act->setIcon(QIcon()); + } + if (upd & EverythingElse) { + QString text = action->menuText(); +#ifndef QT_NO_ACCEL + if (key) + text += QLatin1Char('\t') + (QString)QKeySequence(key); +#endif + act->setText(text); + act->setToolTip(statusTip()); + act->setWhatsThis(whatsthis); + } + } + for (QList<QToolButton*>::Iterator it2(toolbuttons.begin()); it2 != toolbuttons.end(); ++it2) { + QToolButton* btn = *it2; + if (upd & State) { + btn->setEnabled(enabled); + if (toggleaction) + btn->setOn(on); + } + if (upd & Visibility) + visible ? btn->show() : btn->hide(); + if (upd & Icons) { + if (icon) + btn->setIconSet(*icon); + else + btn->setIconSet(QIcon()); + } + if (upd & EverythingElse) { + btn->setToggleButton(toggleaction); + if (!text.isEmpty()) + btn->setTextLabel(text, false); +#ifndef QT_NO_TOOLTIP + btn->setToolTip(toolTip()); +#endif +#ifndef QT_NO_STATUSTIP + btn->setStatusTip(statusTip()); +#endif +#ifndef QT_NO_WHATSTHIS + QWhatsThis::remove(btn); + if (!whatsthis.isEmpty()) + QWhatsThis::add(btn, whatsthis); +#endif + } + } +#ifndef QT_NO_ACCEL + if (accel) { + accel->setEnabled(enabled && visible); + if (!whatsthis.isEmpty()) + accel->setWhatsThis(accelid, whatsthis); + } +#endif + // Only used by actiongroup + for (QList<ComboItem*>::Iterator it3(comboitems.begin()); it3 != comboitems.end(); ++it3) { + ComboItem *ci = *it3; + if (!ci->combo) + return; + if (ci->id == -1) { + ci->id = ci->combo->count(); + if (icon) + ci->combo->insertItem(icon->pixmap(), text); + else + ci->combo->insertItem(text); + } else { + if (icon) + ci->combo->changeItem(icon->pixmap(), text, ci->id); + else + ci->combo->changeItem(text, ci->id); + } + } +} + +QString Q3ActionPrivate::menuText() const +{ + if (menutext.isNull()) { + QString t(text); + t.replace(QLatin1Char('&'), QLatin1String("&&")); + return t; + } + return menutext; +} + +QString Q3ActionPrivate::toolTip() const +{ + if (tooltip.isNull()) { +#ifndef QT_NO_ACCEL + if (accel) + return text + QLatin1String(" (") + (QString)QKeySequence(accel->key(accelid)) + QLatin1Char(')'); +#endif + return text; + } + return tooltip; +} + +QString Q3ActionPrivate::statusTip() const +{ + if (statustip.isNull()) + return toolTip(); + return statustip; +} + +/* + internal: guesses a descriptive text from a menu text + */ +static QString qt_stripMenuText(QString s) +{ + s.remove(QLatin1String("...")); + s.remove(QLatin1Char('&')); + return s.trimmed(); +} + +/*! + Constructs an action called \a name with parent \a parent. + + If \a parent is a Q3ActionGroup, the new action inserts itself into + \a parent. + + For accelerators and status tips to work, \a parent must either be + a widget, or an action group whose parent is a widget. + + \warning To prevent recursion, don't create an action as a child + of a widget that the action is later added to. +*/ +Q3Action::Q3Action(QObject* parent, const char* name) + : QObject(parent, name) +{ + d = new Q3ActionPrivate(this); + init(); +} + +/*! + Constructs an action called \a name with parent \a parent. + + If \a toggle is true the action will be a toggle action, otherwise + it will be a command action. + + If \a parent is a Q3ActionGroup, the new action inserts itself into + \a parent. + + For accelerators and status tips to work, \a parent must either be + a widget, or an action group whose parent is a widget. +*/ +Q3Action::Q3Action(QObject* parent, const char* name, bool toggle) + : QObject(parent, name) +{ + d = new Q3ActionPrivate(this); + d->toggleaction = toggle; + init(); +} + + +#ifndef QT_NO_ACCEL + +/*! + This constructor creates an action with the following properties: + the icon or icon \a icon, the menu text \a menuText and + keyboard accelerator \a accel. It is a child of \a parent and + called \a name. + + If \a parent is a Q3ActionGroup, the action automatically becomes + a member of it. + + For accelerators and status tips to work, \a parent must either be + a widget, or an action group whose parent is a widget. + + The action uses a stripped version of \a menuText (e.g. "\&Menu + Option..." becomes "Menu Option") as descriptive text for + tool buttons. You can override this by setting a specific + description with setText(). The same text and \a accel will be + used for tool tips and status tips unless you provide text for + these using setToolTip() and setStatusTip(). + + Call setToggleAction(true) to make the action a toggle action. + + \warning To prevent recursion, don't create an action as a child + of a widget that the action is later added to. +*/ +Q3Action::Q3Action(const QIcon& icon, const QString& menuText, QKeySequence accel, + QObject* parent, const char* name) + : QObject(parent, name) +{ + d = new Q3ActionPrivate(this); + if (!icon.isNull()) + setIconSet(icon); + d->text = qt_stripMenuText(menuText); + d->menutext = menuText; + setAccel(accel); + init(); +} + +/*! + This constructor results in an icon-less action with the menu + text \a menuText and keyboard accelerator \a accel. It is a child + of \a parent and called \a name. + + If \a parent is a Q3ActionGroup, the action automatically becomes + a member of it. + + For accelerators and status tips to work, \a parent must either be + a widget, or an action group whose parent is a widget. + + The action uses a stripped version of \a menuText (e.g. "\&Menu + Option..." becomes "Menu Option") as descriptive text for + tool buttons. You can override this by setting a specific + description with setText(). The same text and \a accel will be + used for tool tips and status tips unless you provide text for + these using setToolTip() and setStatusTip(). + + Call setToggleAction(true) to make the action a toggle action. + + \warning To prevent recursion, don't create an action as a child + of a widget that the action is later added to. +*/ +Q3Action::Q3Action(const QString& menuText, QKeySequence accel, + QObject* parent, const char* name) + : QObject(parent, name) +{ + d = new Q3ActionPrivate(this); + d->text = qt_stripMenuText(menuText); + d->menutext = menuText; + setAccel(accel); + init(); +} + +/*! + This constructor creates an action with the following properties: + the description \a text, the icon or icon \a icon, the menu + text \a menuText and keyboard accelerator \a accel. It is a child + of \a parent and called \a name. If \a toggle is true the action + will be a toggle action, otherwise it will be a command action. + + If \a parent is a Q3ActionGroup, the action automatically becomes + a member of it. + + For accelerators and status tips to work, \a parent must either be + a widget, or an action group whose parent is a widget. + + The \a text and \a accel will be used for tool tips and status + tips unless you provide specific text for these using setToolTip() + and setStatusTip(). +*/ +Q3Action::Q3Action(const QString& text, const QIcon& icon, const QString& menuText, QKeySequence accel, QObject* parent, const char* name, bool toggle) + : QObject(parent, name) +{ + d = new Q3ActionPrivate(this); + d->toggleaction = toggle; + if (!icon.isNull()) + setIconSet(icon); + + d->text = text; + d->menutext = menuText; + setAccel(accel); + init(); +} + +/*! + This constructor results in an icon-less action with the + description \a text, the menu text \a menuText and the keyboard + accelerator \a accel. Its parent is \a parent and it is called \a + name. If \a toggle is true the action will be a toggle action, + otherwise it will be a command action. + + The action automatically becomes a member of \a parent if \a + parent is a Q3ActionGroup. + + For accelerators and status tips to work, \a parent must either be + a widget, or an action group whose parent is a widget. + + The \a text and \a accel will be used for tool tips and status + tips unless you provide specific text for these using setToolTip() + and setStatusTip(). +*/ +Q3Action::Q3Action(const QString& text, const QString& menuText, QKeySequence accel, QObject* parent, const char* name, bool toggle) + : QObject(parent, name) +{ + d = new Q3ActionPrivate(this); + d->toggleaction = toggle; + d->text = text; + d->menutext = menuText; + setAccel(accel); + init(); +} +#endif + +/*! + \internal +*/ +void Q3Action::init() +{ + if (qobject_cast<Q3ActionGroup*>(parent())) + ((Q3ActionGroup*) parent())->add(this); // insert into action group +} + +/*! + Destroys the object and frees allocated resources. +*/ + +Q3Action::~Q3Action() +{ + delete d; +} + +/*! + \property Q3Action::iconSet + \brief the action's icon + + The icon is used as the tool button icon and in the menu to the + left of the menu text. There is no default icon. + + If a null icon (QIcon::isNull() is passed into this function, + the icon of the action is cleared. + + (See the action/toggleaction/toggleaction.cpp example.) + +*/ +void Q3Action::setIconSet(const QIcon& icon) +{ + register QIcon *i = d->icon; + if (!icon.isNull()) + d->icon = new QIcon(icon); + else + d->icon = 0; + delete i; + d->update(Q3ActionPrivate::Icons); +} + +QIcon Q3Action::iconSet() const +{ + if (d->icon) + return *d->icon; + return QIcon(); +} + +/*! + \property Q3Action::text + \brief the action's descriptive text + + \sa setMenuText() setToolTip() setStatusTip() +*/ +void Q3Action::setText(const QString& text) +{ + d->text = text; + d->update(); +} + +QString Q3Action::text() const +{ + return d->text; +} + + +/*! + \property Q3Action::menuText + \brief the action's menu text + + If the action is added to a menu the menu option will consist of + the icon (if there is one), the menu text and the accelerator (if + there is one). If the menu text is not explicitly set in the + constructor or by using setMenuText() the action's description + text will be used as the menu text. There is no default menu text. + + \sa text +*/ +void Q3Action::setMenuText(const QString& text) +{ + if (d->menutext == text) + return; + + d->menutext = text; + d->update(); +} + +QString Q3Action::menuText() const +{ + return d->menuText(); +} + +/*! + \property Q3Action::toolTip + \brief the action's tool tip + + This text is used for the tool tip. If no status tip has been set + the tool tip will be used for the status tip. + + If no tool tip is specified the action's text is used, and if that + hasn't been specified the description text is used as the tool tip + text. + + There is no default tool tip text. + + \sa setStatusTip() setAccel() +*/ +void Q3Action::setToolTip(const QString& tip) +{ + if (d->tooltip == tip) + return; + + d->tooltip = tip; + d->update(); +} + +QString Q3Action::toolTip() const +{ + return d->toolTip(); +} + +/*! + \property Q3Action::statusTip + \brief the action's status tip + + The statusTip is displayed on all status bars that this action's + top-level parent widget provides. + + If no status tip is defined, the action uses the tool tip text. + + There is no default statusTip text. + + \sa setToolTip() +*/ +void Q3Action::setStatusTip(const QString& tip) +{ + // Old comment: ### Please reimp for Q3ActionGroup! + // For consistency reasons even action groups should show + // status tips (as they already do with tool tips) + // Please change Q3ActionGroup class doc appropriately after + // reimplementation. + + if (d->statustip == tip) + return; + + d->statustip = tip; + d->update(); +} + +QString Q3Action::statusTip() const +{ + return d->statusTip(); +} + +/*! + \property Q3Action::whatsThis + \brief the action's "What's This?" help text + + The whats this text is used to provide a brief description of the + action. The text may contain rich text (HTML-like tags -- see + QStyleSheet for the list of supported tags). There is no default + "What's This?" text. + + \sa QWhatsThis +*/ +void Q3Action::setWhatsThis(const QString& whatsThis) +{ + if (d->whatsthis == whatsThis) + return; + d->whatsthis = whatsThis; + d->update(); +} + +QString Q3Action::whatsThis() const +{ + return d->whatsthis; +} + + +#ifndef QT_NO_ACCEL +/*! + \property Q3Action::accel + \brief the action's accelerator key + + The keycodes can be found in \l Qt::Key and \l Qt::Modifier. There + is no default accelerator key. +*/ +//#### Please reimp for Q3ActionGroup! +//#### For consistency reasons even Q3ActionGroups should respond to +//#### their accelerators and e.g. open the relevant submenu. +//#### Please change appropriate Q3ActionGroup class doc after +//#### reimplementation. +void Q3Action::setAccel(const QKeySequence& key) +{ + if (d->key == key) + return; + + d->key = key; + delete d->accel; + d->accel = 0; + + if (!(int)key) { + d->update(); + return; + } + + QObject* p = parent(); + while (p && !p->isWidgetType()) { + p = p->parent(); + } + if (p) { + d->accel = new Q3Accel((QWidget*)p, this, "qt_action_accel"); + d->accelid = d->accel->insertItem(d->key); + d->accel->connectItem(d->accelid, this, SLOT(internalActivation())); + } else + qWarning("Q3Action::setAccel() (%s) requires widget in parent chain", objectName().toLocal8Bit().data()); + d->update(); +} + + +QKeySequence Q3Action::accel() const +{ + return d->key; +} +#endif + + +/*! + \property Q3Action::toggleAction + \brief whether the action is a toggle action + + A toggle action is one which has an on/off state. For example a + Bold toolbar button is either on or off. An action which is not a + toggle action is a command action; a command action is simply + executed, e.g. file save. This property's default is false. + + In some situations, the state of one toggle action should depend + on the state of others. For example, "Left Align", "Center" and + "Right Align" toggle actions are mutually exclusive. To achieve + exclusive toggling, add the relevant toggle actions to a + Q3ActionGroup with the \l Q3ActionGroup::exclusive property set to + true. +*/ +void Q3Action::setToggleAction(bool enable) +{ + if (enable == (bool)d->toggleaction) + return; + + if (!enable) + d->on = false; + + d->toggleaction = enable; + d->update(); +} + +bool Q3Action::isToggleAction() const +{ + return d->toggleaction; +} + +/*! + Activates the action and executes all connected slots. + This only works for actions that are not toggle actions. + + \sa toggle() +*/ +void Q3Action::activate() +{ + if (isToggleAction()) { +#if defined(QT_CHECK_STATE) + qWarning("Q3Action::%s() (%s) Toggle actions " + "can not be activated", "activate", objectName().toLocal8Bit().data()); +#endif + return; + } + emit activated(); +} + +/*! + Toggles the state of a toggle action. + + \sa on, activate(), toggled(), isToggleAction() +*/ +void Q3Action::toggle() +{ + if (!isToggleAction()) { + qWarning("Q3Action::%s() (%s) Only toggle actions " + "can be switched", "toggle", objectName().toLocal8Bit().data()); + return; + } + setOn(!isOn()); +} + +/*! + \property Q3Action::on + \brief whether a toggle action is on + + This property is always on (true) for command actions and + \l{Q3ActionGroup}s; setOn() has no effect on them. For action's + where isToggleAction() is true, this property's default value is + off (false). + + \sa toggleAction +*/ +void Q3Action::setOn(bool enable) +{ + if (!isToggleAction()) { + if (enable) + qWarning("Q3Action::%s() (%s) Only toggle actions " + "can be switched", "setOn", objectName().toLocal8Bit().data()); + return; + } + if (enable == (bool)d->on) + return; + d->on = enable; + d->update(Q3ActionPrivate::State); + emit toggled(enable); +} + +bool Q3Action::isOn() const +{ + return d->on; +} + +/*! + \property Q3Action::enabled + \brief whether the action is enabled + + Disabled actions can't be chosen by the user. They don't disappear + from the menu/tool bar but are displayed in a way which indicates + that they are unavailable, e.g. they might be displayed grayed + out. + + What's this? help on disabled actions is still available provided + the \l Q3Action::whatsThis property is set. +*/ +void Q3Action::setEnabled(bool enable) +{ + d->forceDisabled = !enable; + + if ((bool)d->enabled == enable) + return; + + d->enabled = enable; + d->update(Q3ActionPrivate::State); +} + +bool Q3Action::isEnabled() const +{ + return d->enabled; +} + +/*! + Disables the action if \a disable is true; otherwise + enables the action. + + See the \l enabled documentation for more information. +*/ +void Q3Action::setDisabled(bool disable) +{ + setEnabled(!disable); +} + +/*! + \property Q3Action::visible + \brief whether the action can be seen (e.g. in menus and toolbars) + + If \e visible is true the action can be seen (e.g. in menus and + toolbars) and chosen by the user; if \e visible is false the + action cannot be seen or chosen by the user. + + Actions which are not visible are \e not grayed out; they do not + appear at all. +*/ +void Q3Action::setVisible(bool visible) +{ + d->forceInvisible = !visible; + + if ((bool)d->visible == visible) + return; + + d->visible = visible; + d->update(Q3ActionPrivate::Visibility); +} + +/* + Returns true if the action is visible (e.g. in menus and + toolbars); otherwise returns false. +*/ +bool Q3Action::isVisible() const +{ + return d->visible; +} + +/*! \internal +*/ +void Q3Action::internalActivation() +{ + if (isToggleAction()) + setOn(!isOn()); + emit activated(); +} + +/*! \internal +*/ +void Q3Action::toolButtonToggled(bool on) +{ + if (!isToggleAction()) + return; + setOn(on); +} + +/*! + Adds this action to widget \a w. + + Currently actions may be added to Q3ToolBar and Q3PopupMenu widgets. + + An action added to a tool bar is automatically displayed as a tool + button; an action added to a pop up menu appears as a menu option. + + addTo() returns true if the action was added successfully and + false otherwise. (If \a w is not a Q3ToolBar or Q3PopupMenu the + action will not be added and false will be returned.) + + \sa removeFrom() +*/ +bool Q3Action::addTo(QWidget* w) +{ +#ifndef QT_NO_TOOLBAR + if (qobject_cast<Q3ToolBar*>(w)) { + if (objectName() == QLatin1String("qt_separator_action")) { + ((Q3ToolBar*)w)->addSeparator(); + } else { + QString bname = objectName() + QLatin1String("_action_button"); + QToolButton* btn = new QToolButton((Q3ToolBar*) w); + btn->setObjectName(bname); + addedTo(btn, w); + btn->setToggleButton(d->toggleaction); + d->toolbuttons.append(btn); + if (d->icon) + btn->setIconSet(*d->icon); + d->update(Q3ActionPrivate::State | Q3ActionPrivate::Visibility | Q3ActionPrivate::EverythingElse) ; + connect(btn, SIGNAL(clicked()), this, SIGNAL(activated())); + connect(btn, SIGNAL(toggled(bool)), this, SLOT(toolButtonToggled(bool))); + connect(btn, SIGNAL(destroyed()), this, SLOT(objectDestroyed())); + } + } else +#endif + if (qobject_cast<Q3PopupMenu*>(w)) { + Q3ActionPrivate::MenuItem* mi = new Q3ActionPrivate::MenuItem; + mi->popup = (Q3PopupMenu*) w; + QIcon* dicon = d->icon; + if (objectName() == QLatin1String("qt_separator_action")) + mi->id = ((Q3PopupMenu*)w)->insertSeparator(); + else if (dicon) + mi->id = mi->popup->insertItem(*dicon, QString::fromLatin1("")); + else + mi->id = mi->popup->insertItem(QString::fromLatin1("")); + addedTo(mi->popup->indexOf(mi->id), mi->popup); + mi->popup->connectItem(mi->id, this, SLOT(internalActivation())); + d->menuitems.append(mi); + d->update(Q3ActionPrivate::State | Q3ActionPrivate::Visibility | Q3ActionPrivate::EverythingElse); + connect(mi->popup, SIGNAL(highlighted(int)), this, SLOT(menuStatusText(int))); + connect(mi->popup, SIGNAL(aboutToHide()), this, SLOT(clearStatusText())); + connect(mi->popup, SIGNAL(destroyed()), this, SLOT(objectDestroyed())); + // Makes only sense when called by Q3ActionGroup::addTo + } else if (qobject_cast<QComboBox*>(w)) { + Q3ActionPrivate::ComboItem *ci = new Q3ActionPrivate::ComboItem; + ci->combo = (QComboBox*)w; + connect(ci->combo, SIGNAL(destroyed()), this, SLOT(objectDestroyed())); + ci->id = ci->combo->count(); + if (objectName() == QLatin1String("qt_separator_action")) { + if (d->icon) + ci->combo->insertItem(d->icon->pixmap(), text()); + else + ci->combo->insertItem(text()); + } else { + ci->id = -1; + } + d->comboitems.append(ci); + d->update(Q3ActionPrivate::State | Q3ActionPrivate::EverythingElse); + } else if(qobject_cast<QMenu*>(w)) { + Q3ActionPrivate::Action4Item *act = new Q3ActionPrivate::Action4Item; + if(!act->action) { //static + act->action = new QAction(this); + if (objectName() == QLatin1String("qt_separator_action")) + act->action->setSeparator(true); + } + act->widget = w; + act->widget->addAction(act->action); + d->action4items.append(act); + d->update(Q3ActionPrivate::State | Q3ActionPrivate::EverythingElse); + } else { + qWarning("Q3Action::addTo(), unknown object"); + return false; + } + return true; +} + +/*! + This function is called from the addTo() function when it has + created a widget (\a actionWidget) for the action in the \a + container. +*/ + +void Q3Action::addedTo(QWidget *actionWidget, QWidget *container) +{ + Q_UNUSED(actionWidget); + Q_UNUSED(container); +} + +/*! + \overload + + This function is called from the addTo() function when it has + created a menu item at the index position \a index in the popup + menu \a menu. +*/ + +void Q3Action::addedTo(int index, Q3PopupMenu *menu) +{ + Q_UNUSED(index); + Q_UNUSED(menu); +} + +/*! + Sets the status message to \a text +*/ +void Q3Action::showStatusText(const QString& text) +{ +#ifndef QT_NO_STATUSBAR + // find out whether we are clearing the status bar by the popup that actually set the text + static Q3PopupMenu *lastmenu = 0; + QObject *s = (QObject*)sender(); + if (s) { + Q3PopupMenu *menu = qobject_cast<Q3PopupMenu*>(s); + if (menu && text.size()) + lastmenu = menu; + else if (menu && text.isEmpty()) { + if (lastmenu && menu != lastmenu) + return; + lastmenu = 0; + } + } + + QObject* par = parent(); + QObject* lpar = 0; + QStatusBar *bar = 0; + while (par && !bar) { + lpar = par; + bar = (QStatusBar*)par->child(0, "QStatusBar", false); + par = par->parent(); + } + if (!bar && lpar) { + QObjectList l = lpar->queryList("QStatusBar"); + if (l.isEmpty()) + return; + // #### hopefully the last one is the one of the mainwindow... + bar = static_cast<QStatusBar*>(l.at(l.size()-1)); + } + if (bar) { + if (text.isEmpty()) + bar->clearMessage(); + else + bar->showMessage(text); + } +#endif +} + +/*! + Sets the status message to the menu item's status text, or to the + tooltip, if there is no status text. +*/ +void Q3Action::menuStatusText(int id) +{ + static int lastId = 0; + QString text; + QList<Q3ActionPrivate::MenuItem*>::Iterator it(d->menuitems.begin()); + while (it != d->menuitems.end()) { + if ((*it)->id == id) { + text = statusTip(); + break; + } + ++it; + } + + if (!text.isEmpty()) + showStatusText(text); + else if (id != lastId) + clearStatusText(); + lastId = id; +} + +/*! + Clears the status text. +*/ +void Q3Action::clearStatusText() +{ + if (!statusTip().isEmpty()) + showStatusText(QString()); +} + +/*! + Removes the action from widget \a w. + + Returns true if the action was removed successfully; otherwise + returns false. + + \sa addTo() +*/ +bool Q3Action::removeFrom(QWidget* w) +{ +#ifndef QT_NO_TOOLBAR + if (qobject_cast<Q3ToolBar*>(w)) { + QList<QToolButton*>::Iterator it(d->toolbuttons.begin()); + QToolButton* btn; + while (it != d->toolbuttons.end()) { + btn = *it; + ++it; + if (btn->parentWidget() == w) { + d->toolbuttons.removeAll(btn); + disconnect(btn, SIGNAL(destroyed()), this, SLOT(objectDestroyed())); + delete btn; + // no need to disconnect from status bar + } + } + } else +#endif + if (qobject_cast<Q3PopupMenu*>(w)) { + QList<Q3ActionPrivate::MenuItem*>::Iterator it(d->menuitems.begin()); + Q3ActionPrivate::MenuItem* mi; + while (it != d->menuitems.end()) { + mi = *it; + ++it; + if (mi->popup == w) { + disconnect(mi->popup, SIGNAL(highlighted(int)), this, SLOT(menuStatusText(int))); + disconnect(mi->popup, SIGNAL(aboutToHide()), this, SLOT(clearStatusText())); + disconnect(mi->popup, SIGNAL(destroyed()), this, SLOT(objectDestroyed())); + mi->popup->removeItem(mi->id); + d->menuitems.removeAll(mi); + delete mi; + } + } + } else if (qobject_cast<QComboBox*>(w)) { + QList<Q3ActionPrivate::ComboItem*>::Iterator it(d->comboitems.begin()); + Q3ActionPrivate::ComboItem *ci; + while (it != d->comboitems.end()) { + ci = *it; + ++it; + if (ci->combo == w) { + disconnect(ci->combo, SIGNAL(destroyed()), this, SLOT(objectDestroyed())); + d->comboitems.removeAll(ci); + delete ci; + } + } + } else if (qobject_cast<QMenu*>(w)) { + QList<Q3ActionPrivate::Action4Item*>::Iterator it(d->action4items.begin()); + Q3ActionPrivate::Action4Item *a4i; + while (it != d->action4items.end()) { + a4i = *it; + ++it; + if (a4i->widget == w) { + a4i->widget->removeAction(a4i->action); + d->action4items.removeAll(a4i); + delete a4i; + } + } + } else { + qWarning("Q3Action::removeFrom(), unknown object"); + return false; + } + return true; +} + +/*! + \internal +*/ +void Q3Action::objectDestroyed() +{ + const QObject* obj = sender(); + Q3ActionPrivate::MenuItem* mi; + for (int i = 0; i < d->menuitems.size();) { + mi = d->menuitems.at(i); + ++i; + if (mi->popup == obj) { + d->menuitems.removeAll(mi); + delete mi; + } + } + Q3ActionPrivate::ComboItem *ci; + QList<Q3ActionPrivate::ComboItem*>::Iterator it2(d->comboitems.begin()); + while (it2 != d->comboitems.end()) { + ci = *it2; + ++it2; + if (ci->combo == obj) { + d->comboitems.removeAll(ci); + delete ci; + } + } + d->toolbuttons.removeAll((QToolButton *)obj); +} + +/*! + \fn void Q3Action::activated() + + This signal is emitted when an action is activated by the user, + e.g. when the user clicks a menu option or a toolbar button or + presses an action's accelerator key combination. + + Connect to this signal for command actions. Connect to the + toggled() signal for toggle actions. +*/ + +/*! + \fn void Q3Action::toggled(bool on) + + This signal is emitted when a toggle action changes state; command + actions and \l{Q3ActionGroup}s don't emit toggled(). + + The \a on argument denotes the new state: If \a on is true the + toggle action is switched on, and if \a on is false the toggle + action is switched off. + + To trigger a user command depending on whether a toggle action has + been switched on or off connect it to a slot that takes a bool to + indicate the state. + + \sa activated() setToggleAction() setOn() +*/ + +void Q3ActionGroupPrivate::update(const Q3ActionGroup* that) +{ + for (QList<Q3Action*>::Iterator it(actions.begin()); it != actions.end(); ++it) { + if (that->isEnabled() && !(*it)->d->forceDisabled) + (*it)->setEnabled(true); + else if (!that->isEnabled() && (*it)->isEnabled()) { + (*it)->setEnabled(false); + (*it)->d->forceDisabled = false; + } + if (that->isVisible() && !(*it)->d->forceInvisible) { + (*it)->setVisible(true); + } else if (!that->isVisible() && (*it)->isVisible()) { + (*it)->setVisible(false); + (*it)->d->forceInvisible = false; + } + } + for (QList<QComboBox*>::Iterator cb(comboboxes.begin()); cb != comboboxes.end(); ++cb) { + QComboBox *combobox = *cb; + combobox->setEnabled(that->isEnabled()); + combobox->setShown(that->isVisible()); + +#ifndef QT_NO_TOOLTIP + QToolTip::remove(combobox); + if (that->toolTip().size()) + QToolTip::add(combobox, that->toolTip()); +#endif +#ifndef QT_NO_WHATSTHIS + QWhatsThis::remove(combobox); + if (that->whatsThis().size()) + QWhatsThis::add(combobox, that->whatsThis()); +#endif + + } + for (QList<QToolButton*>::Iterator mb(menubuttons.begin()); mb != menubuttons.end(); ++mb) { + QToolButton *button = *mb; + button->setEnabled(that->isEnabled()); + button->setShown(that->isVisible()); + + if (!that->text().isNull()) + button->setTextLabel(that->text()); + if (!that->iconSet().isNull()) + button->setIconSet(that->iconSet()); + +#ifndef QT_NO_TOOLTIP + QToolTip::remove(*mb); + if (that->toolTip().size()) + QToolTip::add(button, that->toolTip()); +#endif +#ifndef QT_NO_WHATSTHIS + QWhatsThis::remove(button); + if (that->whatsThis().size()) + QWhatsThis::add(button, that->whatsThis()); +#endif + } + if(QAction *act = Q3ActionGroupPrivate::Action4Item::action) { + act->setVisible(that->isVisible()); + act->setEnabled(that->isEnabled()); + } + for (QList<Q3ActionGroupPrivate::MenuItem*>::Iterator pu(menuitems.begin()); pu != menuitems.end(); ++pu) { + QWidget* parent = (*pu)->popup->parentWidget(); + if (qobject_cast<Q3PopupMenu*>(parent)) { + Q3PopupMenu* ppopup = (Q3PopupMenu*)parent; + ppopup->setItemEnabled((*pu)->id, that->isEnabled()); + ppopup->setItemVisible((*pu)->id, that->isVisible()); + } else { + (*pu)->popup->setEnabled(that->isEnabled()); + } + } + for (QList<Q3PopupMenu*>::Iterator pm(popupmenus.begin()); pm != popupmenus.end(); ++pm) { + Q3PopupMenu *popup = *pm; + Q3PopupMenu *parent = qobject_cast<Q3PopupMenu*>(popup->parentWidget()); + if (!parent) + continue; + + int index; + parent->findPopup(popup, &index); + int id = parent->idAt(index); + if (!that->iconSet().isNull()) + parent->changeItem(id, that->iconSet(), that->menuText()); + else + parent->changeItem(id, that->menuText()); + parent->setItemEnabled(id, that->isEnabled()); +#ifndef QT_NO_ACCEL + parent->setAccel(that->accel(), id); +#endif + } +} + +/*! + \class Q3ActionGroup + \brief The Q3ActionGroup class groups actions together. + + \compat + + In some situations it is useful to group actions together. For + example, if you have a left justify action, a right justify action + and a center action, only one of these actions should be active at + any one time, and one simple way of achieving this is to group the + actions together in an action group. + + An action group can also be added to a menu or a toolbar as a + single unit, with all the actions within the action group + appearing as separate menu options and toolbar buttons. + + The actions in an action group emit their activated() (and for + toggle actions, toggled()) signals as usual. + + The setExclusive() function is used to ensure that only one action + is active at any one time: it should be used with actions which + have their \c toggleAction set to true. + + Action group actions appear as individual menu options and toolbar + buttons. For exclusive action groups use setUsesDropDown() to + display the actions in a subwidget of any widget the action group + is added to. For example, the actions would appear in a combobox + in a toolbar or as a submenu in a menu. + + Actions can be added to an action group using add(), but normally + they are added by creating the action with the action group as + parent. Actions can have separators dividing them using + addSeparator(). Action groups are added to widgets with addTo(). +*/ + +/*! + Constructs an action group called \a name, with parent \a parent. + + The action group is exclusive by default. Call setExclusive(false) to make + the action group non-exclusive. +*/ +Q3ActionGroup::Q3ActionGroup(QObject* parent, const char* name) + : Q3Action(parent, name) +{ + d = new Q3ActionGroupPrivate; + d->exclusive = true; + d->dropdown = false; + d->selected = 0; + d->separatorAction = 0; + + connect(this, SIGNAL(selected(Q3Action*)), SLOT(internalToggle(Q3Action*))); +} + +/*! + Constructs an action group called \a name, with parent \a parent. + + If \a exclusive is true only one toggle action in the group will + ever be active. + + \sa exclusive +*/ +Q3ActionGroup::Q3ActionGroup(QObject* parent, const char* name, bool exclusive) + : Q3Action(parent, name) +{ + d = new Q3ActionGroupPrivate; + d->exclusive = exclusive; + d->dropdown = false; + d->selected = 0; + d->separatorAction = 0; + + connect(this, SIGNAL(selected(Q3Action*)), SLOT(internalToggle(Q3Action*))); +} + +/*! + Destroys the object and frees allocated resources. +*/ + +Q3ActionGroup::~Q3ActionGroup() +{ + QList<Q3ActionGroupPrivate::MenuItem*>::Iterator mit(d->menuitems.begin()); + while (mit != d->menuitems.end()) { + Q3ActionGroupPrivate::MenuItem *mi = *mit; + ++mit; + if (mi->popup) + mi->popup->disconnect(SIGNAL(destroyed()), this, SLOT(objectDestroyed())); + } + + QList<QComboBox*>::Iterator cbit(d->comboboxes.begin()); + while (cbit != d->comboboxes.end()) { + QComboBox *cb = *cbit; + ++cbit; + cb->disconnect(SIGNAL(destroyed()), this, SLOT(objectDestroyed())); + } + QList<QToolButton*>::Iterator mbit(d->menubuttons.begin()); + while (mbit != d->menubuttons.end()) { + QToolButton *mb = *mbit; + ++mbit; + mb->disconnect(SIGNAL(destroyed()), this, SLOT(objectDestroyed())); + } + QList<Q3PopupMenu*>::Iterator pmit(d->popupmenus.begin()); + while (pmit != d->popupmenus.end()) { + Q3PopupMenu *pm = *pmit; + ++pmit; + pm->disconnect(SIGNAL(destroyed()), this, SLOT(objectDestroyed())); + } + + QList<Q3ActionGroupPrivate::Action4Item*>::Iterator itmi4(d->action4items.begin()); + Q3ActionGroupPrivate::Action4Item* mi4; + while (itmi4 != d->action4items.end()) { + mi4 = *itmi4; + ++itmi4; + mi4->widget->removeAction(mi4->action); + } + delete Q3ActionPrivate::Action4Item::action; + Q3ActionPrivate::Action4Item::action = 0; + + delete d->separatorAction; + while (!d->menubuttons.isEmpty()) + delete d->menubuttons.takeFirst(); + while (!d->comboboxes.isEmpty()) + delete d->comboboxes.takeFirst(); + while (!d->menuitems.isEmpty()) + delete d->menuitems.takeFirst(); + while (!d->popupmenus.isEmpty()) + delete d->popupmenus.takeFirst(); + delete d; +} + +/*! + \property Q3ActionGroup::exclusive + \brief whether the action group does exclusive toggling + + If exclusive is true only one toggle action in the action group + can ever be active at any one time. If the user chooses another + toggle action in the group the one they chose becomes active and + the one that was active becomes inactive. + + \sa Q3Action::toggleAction +*/ +void Q3ActionGroup::setExclusive(bool enable) +{ + d->exclusive = enable; +} + +bool Q3ActionGroup::isExclusive() const +{ + return d->exclusive; +} + +/*! + \property Q3ActionGroup::usesDropDown + \brief whether the group's actions are displayed in a subwidget of + the widgets the action group is added to + + Exclusive action groups added to a toolbar display their actions + in a combobox with the action's \l Q3Action::text and \l + Q3Action::iconSet properties shown. Non-exclusive groups are + represented by a tool button showing their \l Q3Action::iconSet and + text() property. + + In a popup menu the member actions are displayed in a submenu. + + Changing usesDropDown only affects \e subsequent calls to addTo(). + + This property's default is false. + +*/ +void Q3ActionGroup::setUsesDropDown(bool enable) +{ + d->dropdown = enable; +} + +bool Q3ActionGroup::usesDropDown() const +{ + return d->dropdown; +} + +/*! + Adds action \a action to this group. + + Normally an action is added to a group by creating it with the + group as parent, so this function is not usually used. + + \sa addTo() +*/ +void Q3ActionGroup::add(Q3Action* action) +{ + if (d->actions.contains(action)) + return; + + d->actions.append(action); + + if (action->whatsThis().isNull()) + action->setWhatsThis(whatsThis()); + if (action->toolTip().isNull()) + action->setToolTip(toolTip()); + if (!action->d->forceDisabled) + action->d->enabled = isEnabled(); + if (!action->d->forceInvisible) + action->d->visible = isVisible(); + + connect(action, SIGNAL(destroyed()), this, SLOT(childDestroyed())); + connect(action, SIGNAL(activated()), this, SIGNAL(activated())); + connect(action, SIGNAL(toggled(bool)), this, SLOT(childToggled(bool))); + connect(action, SIGNAL(activated()), this, SLOT(childActivated())); + + for (QList<QComboBox*>::Iterator cb(d->comboboxes.begin()); cb != d->comboboxes.end(); ++cb) + action->addTo(*cb); + for (QList<QToolButton*>::Iterator mb(d->menubuttons.begin()); mb != d->menubuttons.end(); ++mb) { + QMenu* menu = (*mb)->popup(); + if (!menu) + continue; + action->addTo(menu); + } + for (QList<Q3ActionGroupPrivate::Action4Item*>::Iterator ac(d->action4items.begin()); + ac != d->action4items.end(); ++ac) + action->addTo((*ac)->action->menu()); + for (QList<Q3ActionGroupPrivate::MenuItem*>::Iterator mi(d->menuitems.begin()); + mi != d->menuitems.end(); ++mi) { + Q3PopupMenu* popup = (*mi)->popup; + if (!popup) + continue; + action->addTo(popup); + } +} + +/*! + Adds a separator to the group. +*/ +void Q3ActionGroup::addSeparator() +{ + if (!d->separatorAction) + d->separatorAction = new Q3Action(0, "qt_separator_action"); + d->actions.append(d->separatorAction); +} + + +/*! + Adds this action group to the widget \a w. + + If isExclusive() is false or usesDropDown() is false, the actions within + the group are added to the widget individually. For example, if the widget + is a menu, the actions will appear as individual menu options, and + if the widget is a toolbar, the actions will appear as toolbar buttons. + + If both isExclusive() and usesDropDown() are true, the actions + are presented either in a combobox (if \a w is a toolbar) or in a + submenu (if \a w is a menu). + + All actions should be added to the action group \e before the + action group is added to the widget. If actions are added to the + action group \e after the action group has been added to the + widget these later actions will \e not appear. + + \sa setExclusive() setUsesDropDown() removeFrom() +*/ +bool Q3ActionGroup::addTo(QWidget *w) +{ +#ifndef QT_NO_TOOLBAR + if (qobject_cast<Q3ToolBar*>(w)) { + if (d->dropdown) { + if (!d->exclusive) { + QList<Q3Action*>::Iterator it(d->actions.begin()); + if (it == d->actions.end() || !(*it)) + return true; + + Q3Action *defAction = *it; + + QToolButton* btn = new QToolButton((Q3ToolBar*) w, "qt_actiongroup_btn"); + addedTo(btn, w); + connect(btn, SIGNAL(destroyed()), SLOT(objectDestroyed())); + d->menubuttons.append(btn); + + if (!iconSet().isNull()) + btn->setIconSet(iconSet()); + else if (!defAction->iconSet().isNull()) + btn->setIconSet(defAction->iconSet()); + if (text().size()) + btn->setTextLabel(text()); + else if (defAction->text().size()) + btn->setTextLabel(defAction->text()); +#ifndef QT_NO_TOOLTIP + if (toolTip().size()) + QToolTip::add(btn, toolTip()); + else if (defAction->toolTip().size()) + QToolTip::add(btn, defAction->toolTip()); +#endif +#ifndef QT_NO_WHATSTHIS + if (whatsThis().size()) + QWhatsThis::add(btn, whatsThis()); + else if (defAction->whatsThis().size()) + QWhatsThis::add(btn, defAction->whatsThis()); +#endif + + connect(btn, SIGNAL(clicked()), defAction, SIGNAL(activated())); + connect(btn, SIGNAL(toggled(bool)), defAction, SLOT(toolButtonToggled(bool))); + connect(btn, SIGNAL(destroyed()), defAction, SLOT(objectDestroyed())); + + Q3PopupMenu *menu = new Q3PopupMenu(btn, "qt_actiongroup_menu"); + btn->setPopupDelay(0); + btn->setPopup(menu); + btn->setPopupMode(QToolButton::MenuButtonPopup); + + while (it != d->actions.end()) { + (*it)->addTo(menu); + ++it; + } + d->update(this); + return true; + } else { + QComboBox *box = new QComboBox(false, w, "qt_actiongroup_combo"); + addedTo(box, w); + connect(box, SIGNAL(destroyed()), SLOT(objectDestroyed())); + d->comboboxes.append(box); +#ifndef QT_NO_TOOLTIP + if (toolTip().size()) + QToolTip::add(box, toolTip()); +#endif +#ifndef QT_NO_WHATSTHIS + if (whatsThis().size()) + QWhatsThis::add(box, whatsThis()); +#endif + int onIndex = 0; + bool foundOn = false; + for (QList<Q3Action*>::Iterator it(d->actions.begin()); it != d->actions.end(); ++it) { + Q3Action *action = *it; + if (!foundOn) + foundOn = action->isOn(); + if (action->objectName() != QLatin1String("qt_separator_action") && !foundOn) + onIndex++; + action->addTo(box); + } + if (foundOn) + box->setCurrentItem(onIndex); + connect(box, SIGNAL(activated(int)), this, SLOT(internalComboBoxActivated(int))); + connect(box, SIGNAL(highlighted(int)), this, SLOT(internalComboBoxHighlighted(int))); + d->update(this); + return true; + } + } + } else +#endif + if (qobject_cast<Q3PopupMenu*>(w)) { + Q3PopupMenu *popup; + if (d->dropdown) { + Q3PopupMenu *menu = (Q3PopupMenu*)w; + popup = new Q3PopupMenu(w, "qt_actiongroup_menu"); + d->popupmenus.append(popup); + connect(popup, SIGNAL(destroyed()), SLOT(objectDestroyed())); + + int id; + if (!iconSet().isNull()) { + if (menuText().isEmpty()) + id = menu->insertItem(iconSet(), text(), popup); + else + id = menu->insertItem(iconSet(), menuText(), popup); + } else { + if (menuText().isEmpty()) + id = menu->insertItem(text(), popup); + else + id = menu->insertItem(menuText(), popup); + } + + addedTo(menu->indexOf(id), menu); + + Q3ActionGroupPrivate::MenuItem *item = new Q3ActionGroupPrivate::MenuItem; + item->id = id; + item->popup = popup; + d->menuitems.append(item); + } else { + popup = (Q3PopupMenu*)w; + } + for (QList<Q3Action*>::Iterator it(d->actions.begin()); it != d->actions.end(); ++it) { + // #### do an addedTo(index, popup, action), need to find out index + (*it)->addTo(popup); + } + return true; + } + if (qobject_cast<QMenu*>(w)) { + QMenu *menu = (QMenu*)w; + if (d->dropdown) { + Q3ActionGroupPrivate::Action4Item *ai = new Q3ActionGroupPrivate::Action4Item; + if(!ai->action) { //static + ai->action = menu->menuAction(); + if (!iconSet().isNull()) + ai->action->setIcon(iconSet()); + if (menuText().isEmpty()) + ai->action->setText(text()); + else + ai->action->setText(menuText()); + } + addedTo(w, w); + ai->widget = w; + ai->widget->addAction(Q3ActionGroupPrivate::Action4Item::action); + d->action4items.append(ai); + menu = ai->action->menu(); + } + for (QList<Q3Action*>::Iterator it(d->actions.begin()); it != d->actions.end(); ++it) + (*it)->addTo(menu); + return true; + } + for (QList<Q3Action*>::Iterator it(d->actions.begin()); it != d->actions.end(); ++it) { + // #### do an addedTo(index, popup, action), need to find out index + (*it)->addTo(w); + } + return true; +} + +/*! \reimp +*/ +bool Q3ActionGroup::removeFrom(QWidget* w) +{ + for (QList<Q3Action*>::Iterator it(d->actions.begin()); it != d->actions.end(); ++it) + (*it)->removeFrom(w); + +#ifndef QT_NO_TOOLBAR + if (qobject_cast<Q3ToolBar*>(w)) { + QList<QComboBox*>::Iterator cb(d->comboboxes.begin()); + while (cb != d->comboboxes.end()) { + QComboBox *box = *cb; + ++cb; + if (box->parentWidget() == w) + delete box; + } + QList<QToolButton*>::Iterator mb(d->menubuttons.begin()); + while (mb != d->menubuttons.end()) { + QToolButton *btn = *mb; + ++mb; + if (btn->parentWidget() == w) + delete btn; + } + } else +#endif + if (qobject_cast<Q3PopupMenu*>(w)) { + QList<Q3ActionGroupPrivate::MenuItem*>::Iterator pu(d->menuitems.begin()); + while (pu != d->menuitems.end()) { + Q3ActionGroupPrivate::MenuItem *mi = *pu; + ++pu; + if (d->dropdown && mi->popup) + ((Q3PopupMenu*)w)->removeItem(mi->id); + delete mi->popup; + } + } + if (qobject_cast<QMenu*>(w)) { + QList<Q3ActionGroupPrivate::Action4Item*>::Iterator it(d->action4items.begin()); + Q3ActionGroupPrivate::Action4Item *a4i; + while (it != d->action4items.end()) { + a4i = *it; + ++it; + if (a4i->widget == w) { + a4i->widget->removeAction(a4i->action); + d->action4items.removeAll(a4i); + delete a4i; + } + } + } + return true; +} + +/*! \internal +*/ +void Q3ActionGroup::childToggled(bool b) +{ + if (!isExclusive()) + return; + Q3Action* s = qobject_cast<Q3Action*>(sender()); + if (!s) + return; + if (b) { + if (s != d->selected) { + d->selected = s; + for (QList<Q3Action*>::Iterator it(d->actions.begin()); it != d->actions.end(); ++it) { + if ((*it)->isToggleAction() && (*it) != s) + (*it)->setOn(false); + } + emit selected(s); + } + } else { + if (s == d->selected) { + // at least one has to be selected + s->setOn(true); + } + } +} + +/*! \internal +*/ +void Q3ActionGroup::childActivated() +{ + Q3Action* s = qobject_cast<Q3Action*>(sender()); + if (s) { + emit activated(s); + emit Q3Action::activated(); + } +} + + +/*! \internal +*/ +void Q3ActionGroup::childDestroyed() +{ + d->actions.removeAll((Q3Action *)sender()); + if (d->selected == sender()) + d->selected = 0; +} + +/*! \reimp +*/ +void Q3ActionGroup::setEnabled(bool enable) +{ + if (enable == isEnabled()) + return; + Q3Action::setEnabled(enable); + d->update(this); +} + +/*! \reimp +*/ +void Q3ActionGroup::setToggleAction(bool toggle) +{ + for (QList<Q3Action*>::Iterator it(d->actions.begin()); it != d->actions.end(); ++it) + (*it)->setToggleAction(toggle); + Q3Action::setToggleAction(true); + d->update(this); +} + +/*! \reimp +*/ +void Q3ActionGroup::setOn(bool on) +{ + for (QList<Q3Action*>::Iterator it(d->actions.begin()); it != d->actions.end(); ++it) { + Q3Action *act = *it; + if (act->isToggleAction()) + act->setOn(on); + } + Q3Action::setOn(on); + d->update(this); +} + +/*! \reimp + */ +void Q3ActionGroup::setVisible(bool visible) +{ + Q3Action::setVisible(visible); + d->update(this); +} + +/*! \reimp +*/ +void Q3ActionGroup::setIconSet(const QIcon& icon) +{ + Q3Action::setIconSet(icon); + d->update(this); +} + +/*! \reimp +*/ +void Q3ActionGroup::setText(const QString& txt) +{ + if (txt == text()) + return; + + Q3Action::setText(txt); + d->update(this); +} + +/*! \reimp +*/ +void Q3ActionGroup::setMenuText(const QString& text) +{ + if (text == menuText()) + return; + + Q3Action::setMenuText(text); + d->update(this); +} + +/*! \reimp +*/ +void Q3ActionGroup::setToolTip(const QString& text) +{ + if (text == toolTip()) + return; + for (QList<Q3Action*>::Iterator it(d->actions.begin()); it != d->actions.end(); ++it) { + if ((*it)->toolTip().isNull()) + (*it)->setToolTip(text); + } + Q3Action::setToolTip(text); + d->update(this); +} + +/*! \reimp +*/ +void Q3ActionGroup::setWhatsThis(const QString& text) +{ + if (text == whatsThis()) + return; + for (QList<Q3Action*>::Iterator it(d->actions.begin()); it != d->actions.end(); ++it) { + if ((*it)->whatsThis().isNull()) + (*it)->setWhatsThis(text); + } + Q3Action::setWhatsThis(text); + d->update(this); +} + +/*! \reimp +*/ +void Q3ActionGroup::childEvent(QChildEvent *e) +{ + if (!e->removed()) + return; + + Q3Action *action = qobject_cast<Q3Action*>(e->child()); + if (!action) + return; + + for (QList<QComboBox*>::Iterator cb(d->comboboxes.begin()); + cb != d->comboboxes.end(); ++cb) { + for (int i = 0; i < (*cb)->count(); i++) { + if ((*cb)->text(i) == action->text()) { + (*cb)->removeItem(i); + break; + } + } + } + for (QList<QToolButton*>::Iterator mb(d->menubuttons.begin()); + mb != d->menubuttons.end(); ++mb) { + QMenu* popup = (*mb)->popup(); + if (!popup) + continue; + action->removeFrom(popup); + } + for (QList<Q3ActionGroupPrivate::MenuItem*>::Iterator mi(d->menuitems.begin()); + mi != d->menuitems.end(); ++mi) { + Q3PopupMenu* popup = (*mi)->popup; + if (!popup) + continue; + action->removeFrom(popup); + } + if(QAction *act = Q3ActionGroupPrivate::Action4Item::action) + action->removeFrom(act->menu()); +} + +/*! + \fn void Q3ActionGroup::selected(Q3Action* action) + + This signal is emitted from exclusive groups when toggle actions + change state. + + The argument is the \a action whose state changed to "on". + + \sa setExclusive(), isOn() Q3Action::toggled() +*/ + +/*! + \fn void Q3ActionGroup::activated(Q3Action* action) + + This signal is emitted from groups when one of its actions gets + activated. + + The argument is the \a action which was activated. + + \sa setExclusive(), isOn() Q3Action::toggled() +*/ + + +/*! \internal +*/ +void Q3ActionGroup::internalComboBoxActivated(int index) +{ + if (index == -1) + return; + + Q3Action *a = 0; + for (int i = 0; i <= index && i < (int)d->actions.count(); ++i) { + a = d->actions.at(i); + if (a && a->objectName() == QLatin1String("qt_separator_action")) + index++; + } + a = d->actions.at(index); + if (a) { + if (a != d->selected) { + d->selected = a; + for (QList<Q3Action*>::Iterator it(d->actions.begin()); it != d->actions.end(); ++it) { + if ((*it)->isToggleAction() && (*it) != a) + (*it)->setOn(false); + } + if (a->isToggleAction()) + a->setOn(true); + + emit activated(a); + emit Q3Action::activated(); + emit a->activated(); + if (a->isToggleAction()) + emit selected(d->selected); + } else if (!a->isToggleAction()) { + emit activated(a); + emit Q3Action::activated(); + emit a->activated(); + } + a->clearStatusText(); + } +} + +/*! \internal +*/ +void Q3ActionGroup::internalComboBoxHighlighted(int index) +{ + Q3Action *a = 0; + for (int i = 0; i <= index && i < (int)d->actions.count(); ++i) { + a = d->actions.at(i); + if (a && a->objectName() == QLatin1String("qt_separator_action")) + index++; + } + a = d->actions.at(index); + if (a) + a->showStatusText(a->statusTip()); + else + clearStatusText(); +} + +/*! \internal +*/ +void Q3ActionGroup::internalToggle(Q3Action *a) +{ + int index = d->actions.indexOf(a); + if (index == -1) + return; + + int lastItem = index; + for (int i=0; i<lastItem; ++i) { + Q3Action *action = d->actions.at(i); + if (action->objectName() == QLatin1String("qt_separator_action")) + --index; + } + + for (QList<QComboBox*>::Iterator it(d->comboboxes.begin()); + it != d->comboboxes.end(); ++it) + (*it)->setCurrentItem(index); +} + +/*! \internal +*/ +void Q3ActionGroup::objectDestroyed() +{ + const QObject* obj = sender(); + d->menubuttons.removeAll((QToolButton *)obj); + for (QList<Q3ActionGroupPrivate::MenuItem *>::Iterator mi(d->menuitems.begin()); + mi != d->menuitems.end(); ++mi) { + if ((*mi)->popup == obj) { + d->menuitems.removeAll(*mi); + delete *mi; + break; + } + } + d->popupmenus.removeAll((Q3PopupMenu*)obj); + d->comboboxes.removeAll((QComboBox*)obj); +} + +/*! + This function is called from the addTo() function when it has + created a widget (\a actionWidget) for the child action \a a in + the \a container. +*/ + +void Q3ActionGroup::addedTo(QWidget *actionWidget, QWidget *container, Q3Action *a) +{ + Q_UNUSED(actionWidget); + Q_UNUSED(container); + Q_UNUSED(a); +} + +/*! + \overload + + This function is called from the addTo() function when it has + created a menu item for the child action at the index position \a + index in the popup menu \a menu. +*/ + +void Q3ActionGroup::addedTo(int index, Q3PopupMenu *menu, Q3Action *a) +{ + Q_UNUSED(index); + Q_UNUSED(menu); + Q_UNUSED(a); +} + +/*! + \reimp + \overload + + This function is called from the addTo() function when it has + created a widget (\a actionWidget) in the \a container. +*/ + +void Q3ActionGroup::addedTo(QWidget *actionWidget, QWidget *container) +{ + Q_UNUSED(actionWidget); + Q_UNUSED(container); +} + +/*! + \reimp + \overload + + This function is called from the addTo() function when it has + created a menu item at the index position \a index in the popup + menu \a menu. +*/ + +void Q3ActionGroup::addedTo(int index, Q3PopupMenu *menu) +{ + Q_UNUSED(index); + Q_UNUSED(menu); +} + +/*! + \fn void Q3ActionGroup::insert(Q3Action *action) + + Use add(\a action) instead. +*/ + +QT_END_NAMESPACE + +#endif diff --git a/src/qt3support/widgets/q3action.h b/src/qt3support/widgets/q3action.h new file mode 100644 index 0000000..58c15b0 --- /dev/null +++ b/src/qt3support/widgets/q3action.h @@ -0,0 +1,225 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the Qt3Support module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, 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 qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef Q3ACTION_H +#define Q3ACTION_H + +#include <QtGui/qicon.h> +#include <QtGui/qkeysequence.h> +#include <QtCore/qobject.h> +#include <QtCore/qstring.h> + +QT_BEGIN_HEADER + +QT_BEGIN_NAMESPACE + +QT_MODULE(Qt3SupportLight) + +#ifndef QT_NO_ACTION + +class Q3ActionPrivate; +class Q3ActionGroupPrivate; +class QStatusBar; +class Q3PopupMenu; +class QToolTipGroup; +class QWidget; + +class Q_COMPAT_EXPORT Q3Action : public QObject +{ + Q_OBJECT + Q_PROPERTY(bool toggleAction READ isToggleAction WRITE setToggleAction) + Q_PROPERTY(bool on READ isOn WRITE setOn) + Q_PROPERTY(bool enabled READ isEnabled WRITE setEnabled) + Q_PROPERTY(QIcon iconSet READ iconSet WRITE setIconSet) + Q_PROPERTY(QString text READ text WRITE setText) + Q_PROPERTY(QString menuText READ menuText WRITE setMenuText) + Q_PROPERTY(QString toolTip READ toolTip WRITE setToolTip) + Q_PROPERTY(QString statusTip READ statusTip WRITE setStatusTip) + Q_PROPERTY(QString whatsThis READ whatsThis WRITE setWhatsThis) +#ifndef QT_NO_ACCEL + Q_PROPERTY(QKeySequence accel READ accel WRITE setAccel) +#endif + Q_PROPERTY(bool visible READ isVisible WRITE setVisible) + +public: + Q3Action(QObject* parent, const char* name = 0); +#ifndef QT_NO_ACCEL + Q3Action(const QString& menuText, QKeySequence accel, + QObject* parent, const char* name = 0); + Q3Action(const QIcon& icon, const QString& menuText, QKeySequence accel, + QObject* parent, const char* name = 0); + + Q3Action(const QString& text, const QIcon& icon, const QString& menuText, QKeySequence accel, + QObject* parent, const char* name = 0, bool toggle = false); // obsolete + Q3Action(const QString& text, const QString& menuText, QKeySequence accel, QObject* parent, + const char* name = 0, bool toggle = false); // obsolete +#endif + Q3Action(QObject* parent, const char* name , bool toggle); // obsolete + ~Q3Action(); + + virtual void setIconSet(const QIcon&); + QIcon iconSet() const; + virtual void setText(const QString&); + QString text() const; + virtual void setMenuText(const QString&); + QString menuText() const; + virtual void setToolTip(const QString&); + QString toolTip() const; + virtual void setStatusTip(const QString&); + QString statusTip() const; + virtual void setWhatsThis(const QString&); + QString whatsThis() const; +#ifndef QT_NO_ACCEL + virtual void setAccel(const QKeySequence& key); + QKeySequence accel() const; +#endif + virtual void setToggleAction(bool); + + bool isToggleAction() const; + bool isOn() const; + bool isEnabled() const; + bool isVisible() const; + virtual bool addTo(QWidget*); + virtual bool removeFrom(QWidget*); + +protected: + virtual void addedTo(QWidget *actionWidget, QWidget *container); + virtual void addedTo(int index, Q3PopupMenu *menu); + +public Q_SLOTS: + void activate(); + void toggle(); + virtual void setOn(bool); + virtual void setEnabled(bool); + void setDisabled(bool); + virtual void setVisible(bool); + +Q_SIGNALS: + void activated(); + void toggled(bool); + +private Q_SLOTS: + void internalActivation(); + void toolButtonToggled(bool); + void objectDestroyed(); + void menuStatusText(int id); + void showStatusText(const QString&); + void clearStatusText(); + +private: + Q_DISABLE_COPY(Q3Action) + + void init(); + + Q3ActionPrivate* d; + + friend class Q3ActionPrivate; + friend class Q3ActionGroup; + friend class Q3ActionGroupPrivate; +}; + +class Q_COMPAT_EXPORT Q3ActionGroup : public Q3Action +{ + Q_OBJECT + Q_PROPERTY(bool exclusive READ isExclusive WRITE setExclusive) + Q_PROPERTY(bool usesDropDown READ usesDropDown WRITE setUsesDropDown) + +public: + Q3ActionGroup(QObject* parent, const char* name = 0); + Q3ActionGroup(QObject* parent, const char* name , bool exclusive ); // obsolete + ~Q3ActionGroup(); + void setExclusive(bool); + bool isExclusive() const; + void add(Q3Action* a); + void addSeparator(); + bool addTo(QWidget*); + bool removeFrom(QWidget*); + void setEnabled(bool); + void setToggleAction(bool toggle); + void setOn(bool on); + void setVisible(bool); + + void setUsesDropDown(bool enable); + bool usesDropDown() const; + + void setIconSet(const QIcon &); + void setText(const QString&); + void setMenuText(const QString&); + void setToolTip(const QString&); + void setWhatsThis(const QString&); + +protected: + void childEvent(QChildEvent*); + virtual void addedTo(QWidget *actionWidget, QWidget *container, Q3Action *a); + virtual void addedTo(int index, Q3PopupMenu *menu, Q3Action *a); + virtual void addedTo(QWidget *actionWidget, QWidget *container); + virtual void addedTo(int index, Q3PopupMenu *menu); + +Q_SIGNALS: + void selected(Q3Action*); + void activated(Q3Action *); + +private Q_SLOTS: + void childToggled(bool); + void childActivated(); + void childDestroyed(); + void internalComboBoxActivated(int); + void internalComboBoxHighlighted(int); + void internalToggle(Q3Action*); + void objectDestroyed(); + +private: + Q3ActionGroupPrivate* d; + +public: + void insert(Q3Action *a) { add(a); } + +private: + Q_DISABLE_COPY(Q3ActionGroup) +}; + +#endif // QT_NO_ACTION + +QT_END_NAMESPACE + +QT_END_HEADER + +#endif // Q3ACTION_H diff --git a/src/qt3support/widgets/q3button.cpp b/src/qt3support/widgets/q3button.cpp new file mode 100644 index 0000000..65ca16b --- /dev/null +++ b/src/qt3support/widgets/q3button.cpp @@ -0,0 +1,127 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the Qt3Support module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, 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 qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "q3button.h" +#include "qpainter.h" + +QT_BEGIN_NAMESPACE + +/*! + \class Q3Button + \brief The Q3Button class is a compatibility base class of button + widgets + + \compat + + \bold{In new code, use QAbstractButton.} + + To subclass Q3Button, you must reimplement at least drawButton() + (to draw the button's outline) and drawButtonLabel() (to draw its + text or pixmap). It is generally advisable to reimplement + sizeHint() as well, and sometimes hitButton() (to determine + whether a button press is within the button). +*/ + +/*! + Constructs a standard button called \a name with parent \a parent, + using the widget flags \a f. +*/ + +Q3Button::Q3Button( QWidget *parent, const char *name, Qt::WindowFlags f ) + : QAbstractButton( parent, name, f ) +{ +} + +/*! + Destroys the button. + */ +Q3Button::~Q3Button() +{ +} + +/*! + \fn void Q3Button::paintEvent( QPaintEvent *event) + + Handles paint events, received in \a event, for buttons. Small and + typically complex buttons are painted double-buffered to reduce + flicker. The actually drawing is done in the virtual functions + drawButton() and drawButtonLabel(). + + \sa drawButton(), drawButtonLabel() +*/ +void Q3Button::paintEvent( QPaintEvent *) +{ + QPainter p(this); + drawButton( &p ); +} + +/*! + \fn void Q3Button::drawButton( QPainter *painter) + + Draws the button on the given \a painter. The default + implementation does nothing. + + This virtual function is reimplemented by subclasses to draw real + buttons. At some point, these reimplementations should call + drawButtonLabel(). + + \sa drawButtonLabel(), paintEvent() +*/ +void Q3Button::drawButton( QPainter * ) +{ +} + +/*! + \fn void Q3Button::drawButtonLabel( QPainter *painter ) + + Draws the button text or pixmap on the given \a painter. + + This virtual function is reimplemented by subclasses to draw real + buttons. It is invoked by drawButton(). + + \sa drawButton(), paintEvent() +*/ + +void Q3Button::drawButtonLabel( QPainter * ) +{ +} + +QT_END_NAMESPACE diff --git a/src/qt3support/widgets/q3button.h b/src/qt3support/widgets/q3button.h new file mode 100644 index 0000000..699585c --- /dev/null +++ b/src/qt3support/widgets/q3button.h @@ -0,0 +1,71 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the Qt3Support module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, 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 qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef Q3BUTTON_H +#define Q3BUTTON_H + +#include <QtGui/qabstractbutton.h> + +QT_BEGIN_HEADER + +QT_BEGIN_NAMESPACE + +QT_MODULE(Qt3SupportLight) + +class Q_COMPAT_EXPORT Q3Button : public QAbstractButton +{ + Q_OBJECT +public: + Q3Button( QWidget* parent=0, const char* name=0, Qt::WindowFlags f=0 ); + ~Q3Button(); + +protected: + virtual void drawButton( QPainter * ); + virtual void drawButtonLabel( QPainter * ); + void paintEvent( QPaintEvent * ); + +}; + +QT_END_NAMESPACE + +QT_END_HEADER + +#endif // Q3BUTTON_H diff --git a/src/qt3support/widgets/q3buttongroup.cpp b/src/qt3support/widgets/q3buttongroup.cpp new file mode 100644 index 0000000..7349a79 --- /dev/null +++ b/src/qt3support/widgets/q3buttongroup.cpp @@ -0,0 +1,565 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the Qt3Support module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, 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 qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "q3buttongroup.h" +#include "qabstractbutton.h" +#include "qmap.h" +#include "qapplication.h" +#include "qradiobutton.h" +#include "qevent.h" +#include "qset.h" + +QT_BEGIN_NAMESPACE + +/*! + \class Q3ButtonGroup + \brief The Q3ButtonGroup widget organizes QAbstractButton widgets in a group. + + \compat + + A button group widget makes it easier to deal with groups of + buttons. Each button in a button group has a unique identifier. + The button group emits a clicked() signal with this identifier + when a button in the group is clicked. This makes a button group + particularly useful when you have several similar buttons and want + to connect all their clicked() signals to a single slot. + + An \link setExclusive() exclusive\endlink button group switches + off all toggle buttons except the one that was clicked. A button + group is, by default, non-exclusive. Note that all radio buttons + that are inserted into a button group are mutually exclusive even + if the button group is non-exclusive. (See + setRadioButtonExclusive().) + + There are two ways of using a button group: + \list + \i The button group is the parent widget of a number of buttons, + i.e. the button group is the parent argument in the button + constructor. The buttons are assigned identifiers 0, 1, 2, etc., + in the order they are created. A Q3ButtonGroup can display a frame + and a title because it inherits Q3GroupBox. + \i The button group is an invisible widget and the contained + buttons have some other parent widget. In this usage, each button + must be manually inserted, using insert(), into the button group + and given an identifier. + \endlist + + A button can be removed from the group with remove(). A pointer to + a button with a given id can be obtained using find(). The id of a + button is available using id(). A button can be set \e on with + setButton(). The number of buttons in the group is returned by + count(). + + \sa QPushButton, QCheckBox, QRadioButton +*/ + +/*! + \property Q3ButtonGroup::exclusive + \brief whether the button group is exclusive + + If this property is true, then the buttons in the group are + toggled, and to untoggle a button you must click on another button + in the group. The default value is false. +*/ + +/*! + \property Q3ButtonGroup::radioButtonExclusive + \brief whether the radio buttons in the group are exclusive + + If this property is true (the default), the \link QRadioButton + radio buttons\endlink in the group are treated exclusively. +*/ + + +/*! + Constructs a button group with no title. + + The \a parent and \a name arguments are passed to the QWidget + constructor. +*/ + +Q3ButtonGroup::Q3ButtonGroup(QWidget *parent, const char *name) + : Q3GroupBox(parent, name) +{ + init(); +} + +/*! + Constructs a button group with the title \a title. + + The \a parent and \a name arguments are passed to the QWidget + constructor. +*/ + +Q3ButtonGroup::Q3ButtonGroup(const QString &title, QWidget *parent, + const char *name) + : Q3GroupBox(title, parent, name) +{ + init(); +} + +/*! + Constructs a button group with no title. Child widgets will be + arranged in \a strips rows or columns (depending on \a + orientation). + + The \a parent and \a name arguments are passed to the QWidget + constructor. +*/ + +Q3ButtonGroup::Q3ButtonGroup(int strips, Qt::Orientation orientation, + QWidget *parent, const char *name) + : Q3GroupBox(strips, orientation, parent, name) +{ + init(); +} + +/*! + Constructs a button group with title \a title. Child widgets will + be arranged in \a strips rows or columns (depending on \a + orientation). + + The \a parent and \a name arguments are passed to the QWidget + constructor. +*/ + +Q3ButtonGroup::Q3ButtonGroup(int strips, Qt::Orientation orientation, + const QString &title, QWidget *parent, + const char *name) + : Q3GroupBox(strips, orientation, title, parent, name) +{ + init(); +} + +/*! + Initializes the button group. +*/ + +void Q3ButtonGroup::init() +{ + group.setExclusive(false); + radio_excl = true; +} + +/*! Destructor. */ + +Q3ButtonGroup::~Q3ButtonGroup() +{ +} + +bool Q3ButtonGroup::isExclusive() const +{ + return group.exclusive(); +} + +void Q3ButtonGroup::setExclusive(bool enable) +{ + group.setExclusive(enable); +} + + +/*! + Inserts the \a button with the identifier \a id into the button + group. Returns the button identifier. + + Buttons are normally inserted into a button group automatically by + passing the button group as the parent when the button is + constructed. So it is not necessary to manually insert buttons + that have this button group as their parent widget. An exception + is when you want custom identifiers instead of the default 0, 1, + 2, etc., or if you want the buttons to have some other parent. + + The button is assigned the identifier \a id or an automatically + generated identifier. It works as follows: If \a id >= 0, this + identifier is assigned. If \a id == -1 (default), the identifier + is equal to the number of buttons in the group. If \a id is any + other negative integer, for instance -2, a unique identifier + (negative integer \<= -2) is generated. No button has an id of -1. + + \sa find(), remove(), setExclusive() +*/ + +int Q3ButtonGroup::insert(QAbstractButton *button, int id) +{ + remove_helper(button); + return insert_helper(button, id); +} + +int Q3ButtonGroup::insert_helper(QAbstractButton *button, int id) +{ + if (isExclusive() || !qobject_cast<QRadioButton*>(button)) + group.addButton(button); + + static int seq_no = -2; + if (id < -1) + id = seq_no--; + else if (id == -1) + id = buttonIds.count(); + buttonIds.insert(id, button); + connect(button, SIGNAL(pressed()) , SLOT(buttonPressed())); + connect(button, SIGNAL(released()), SLOT(buttonReleased())); + connect(button, SIGNAL(clicked()) , SLOT(buttonClicked())); + connect(button, SIGNAL(destroyed()) , SLOT(buttonDestroyed())); + return id; +} + +/*! + Returns the number of buttons in the group. +*/ +int Q3ButtonGroup::count() const +{ + fixChildren(); + return buttonIds.count(); +} + +/*! + Removes the \a button from the button group. + + \sa insert() +*/ + +void Q3ButtonGroup::remove(QAbstractButton *button) +{ + fixChildren(); + remove_helper(button); +} + +void Q3ButtonGroup::remove_helper(QAbstractButton *button) +{ + QMap<int, QAbstractButton*>::Iterator it = buttonIds.begin(); + while (it != buttonIds.end()) { + if (it.value() == button) { + buttonIds.erase(it); + button->disconnect(this); + group.removeButton(button); + break; + } + ++it; + } +} + + +/*! + Returns the button with the specified identifier \a id, or 0 if + the button was not found. +*/ + +QAbstractButton *Q3ButtonGroup::find(int id) const +{ + fixChildren(); + return buttonIds.value(id); +} + + +/*! + \fn void Q3ButtonGroup::pressed(int id) + + This signal is emitted when a button in the group is \link + QAbstractButton::pressed() pressed\endlink. The \a id argument is the + button's identifier. + + \sa insert() +*/ + +/*! + \fn void Q3ButtonGroup::released(int id) + + This signal is emitted when a button in the group is \link + QAbstractButton::released() released\endlink. The \a id argument is the + button's identifier. + + \sa insert() +*/ + +/*! + \fn void Q3ButtonGroup::clicked(int id) + + This signal is emitted when a button in the group is \link + QAbstractButton::clicked() clicked\endlink. The \a id argument is the + button's identifier. + + \sa insert() +*/ + + +/*! + \internal + This slot is activated when one of the buttons in the group emits the + QAbstractButton::pressed() signal. +*/ + +void Q3ButtonGroup::buttonPressed() +{ + QAbstractButton *senderButton = qobject_cast<QAbstractButton *>(sender()); + Q_ASSERT(senderButton); + int senderId = id(senderButton); + if (senderId != -1) + emit pressed(senderId); +} + +/*! + \internal + This slot is activated when one of the buttons in the group emits the + QAbstractButton::released() signal. +*/ + +void Q3ButtonGroup::buttonReleased() +{ + QAbstractButton *senderButton = qobject_cast<QAbstractButton *>(sender()); + Q_ASSERT(senderButton); + int senderId = id(senderButton); + if (senderId != -1) + emit released(senderId); +} + +/*! + \internal + This slot is activated when one of the buttons in the group emits the + QAbstractButton::clicked() signal. +*/ + +void Q3ButtonGroup::buttonClicked() +{ + QAbstractButton *senderButton = qobject_cast<QAbstractButton *>(sender()); + Q_ASSERT(senderButton); + int senderId = id(senderButton); + if (senderId != -1) + emit clicked(senderId); +} + +/*! + \internal +*/ +void Q3ButtonGroup::buttonDestroyed() +{ + int id = buttonIds.key(static_cast<QAbstractButton *>(sender()), -1); + if (id != -1) + buttonIds.remove(id); +} + +void Q3ButtonGroup::setButton(int id) +{ + QAbstractButton *b = find(id); + if (b) + b->setOn(true); +} + +void Q3ButtonGroup::setRadioButtonExclusive(bool on) +{ + radio_excl = on; +} + + +/*! + Returns the selected toggle button if exactly one is selected; + otherwise returns 0. + + \sa selectedId() +*/ + +QAbstractButton *Q3ButtonGroup::selected() const +{ + fixChildren(); + QAbstractButton *candidate = 0; + QMap<int, QAbstractButton*>::ConstIterator it = buttonIds.constBegin(); + while (it != buttonIds.constEnd()) { + if (it.value()->isCheckable() && it.value()->isChecked()) { + if (candidate) + return 0; + candidate = it.value(); + } + ++it; + } + return candidate; +} + +/*! + \property Q3ButtonGroup::selectedId + \brief The id of the selected toggle button. + + If no toggle button is selected, id() returns -1. + + If setButton() is called on an exclusive group, the button with + the given id will be set to on and all the others will be set to + off. + + \sa selected() +*/ + +int Q3ButtonGroup::selectedId() const +{ + return id(selected()); +} + + +/*! + Returns the id of \a button, or -1 if \a button is not a member of + this group. + + \sa selectedId() +*/ + +int Q3ButtonGroup::id(QAbstractButton *button) const +{ + fixChildren(); + QMap<int, QAbstractButton*>::ConstIterator it = buttonIds.constBegin(); + while (it != buttonIds.constEnd()) { + if (it.value() == button) + return it.key(); + ++it; + } + return -1; +} + + +/*! + \reimp +*/ +bool Q3ButtonGroup::event(QEvent * e) +{ + if (e->type() == QEvent::ChildInserted) { + QChildEvent * ce = (QChildEvent *) e; + if (QAbstractButton *button = qobject_cast<QAbstractButton*>(ce->child())) { + button->setAutoExclusive(false); + if (group.exclusive() || qobject_cast<QRadioButton*>(button)) { + button->setAutoExclusive(true); + QMap<int, QAbstractButton*>::ConstIterator it = buttonIds.constBegin(); + while (it != buttonIds.constEnd()) { + if (it.value() == button) + return Q3GroupBox::event(e); + ++it; + } + } + insert(button, id(button)); + } + } + return Q3GroupBox::event(e); +} + +void Q3ButtonGroup::fixChildren() const +{ + if (children().count() == buttonIds.count()) + return; // small optimization, all our children have ids. + + QSet<QAbstractButton*> set; + for (QMap<int, QAbstractButton*>::ConstIterator it = buttonIds.constBegin(); + it != buttonIds.constEnd(); ++it) + set.insert(*it); + // Use children() instead of qFindChildren<QAbstractButton*> because the search + // should not be recursive.We match with the behavior of Qt3 + const QObjectList childList = children(); + Q_FOREACH(QObject* obj, childList) { + QAbstractButton *button = qobject_cast<QAbstractButton*>(obj); + if ( button && !set.contains(button)) + const_cast<Q3ButtonGroup*>(this)->insert_helper(button); + } +} + + +/*! + \class Q3HButtonGroup + \brief The Q3HButtonGroup widget organizes button widgets in a + group with one horizontal row. + + \compat + + Q3HButtonGroup is a convenience class that offers a thin layer on + top of Q3ButtonGroup. From a layout point of view it is effectively + a Q3HBoxWidget that offers a frame with a title and is specifically + designed for buttons. From a functionality point of view it is a + Q3ButtonGroup. + + \sa Q3VButtonGroup +*/ + +/*! + \fn Q3HButtonGroup::Q3HButtonGroup(QWidget *parent, const char *name) + + Constructs a horizontal button group with no title. + + The \a parent and \a name arguments are passed to the QWidget + constructor. +*/ + +/*! + \fn Q3HButtonGroup::Q3HButtonGroup(const QString &title, QWidget *parent, + const char *name) + + Constructs a horizontal button group with the title \a title. + + The \a parent and \a name arguments are passed to the QWidget + constructor. +*/ + +/*! + \class Q3VButtonGroup + \brief The Q3VButtonGroup widget organizes button widgets in a + vertical column. + + \compat + + Q3VButtonGroup is a convenience class that offers a thin layer on top + of Q3ButtonGroup. Think of it as a QVBoxWidget that offers a frame with a + title and is specifically designed for buttons. + + \sa Q3HButtonGroup +*/ + +/*! + \fn Q3VButtonGroup::Q3VButtonGroup(QWidget *parent, const char *name) + + Constructs a vertical button group with no title. + + The \a parent and \a name arguments are passed on to the QWidget + constructor. +*/ + +/*! + \fn Q3VButtonGroup::Q3VButtonGroup(const QString &title, QWidget *parent, + const char *name) + + Constructs a vertical button group with the title \a title. + + The \a parent and \a name arguments are passed on to the QWidget + constructor. +*/ + +QT_END_NAMESPACE diff --git a/src/qt3support/widgets/q3buttongroup.h b/src/qt3support/widgets/q3buttongroup.h new file mode 100644 index 0000000..83ea594 --- /dev/null +++ b/src/qt3support/widgets/q3buttongroup.h @@ -0,0 +1,152 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the Qt3Support module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, 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 qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef Q3BUTTONGROUP_H +#define Q3BUTTONGROUP_H + +#include <QtGui/qbuttongroup.h> +#include <Qt3Support/q3groupbox.h> +#include <QtCore/qmap.h> + +QT_BEGIN_HEADER + +QT_BEGIN_NAMESPACE + +QT_MODULE(Qt3SupportLight) + +class QAbstractButton; + +class Q_COMPAT_EXPORT Q3ButtonGroup : public Q3GroupBox +{ + Q_OBJECT + Q_PROPERTY(bool exclusive READ isExclusive WRITE setExclusive) + Q_PROPERTY(bool radioButtonExclusive READ isRadioButtonExclusive WRITE setRadioButtonExclusive) + Q_PROPERTY(int selectedId READ selectedId WRITE setButton) + +public: + Q3ButtonGroup(QWidget* parent=0, const char* name=0); + Q3ButtonGroup(const QString &title, + QWidget* parent=0, const char* name=0); + Q3ButtonGroup(int columns, Qt::Orientation o, + QWidget* parent=0, const char* name=0); + Q3ButtonGroup(int columns, Qt::Orientation o, const QString &title, + QWidget* parent=0, const char* name=0); + ~Q3ButtonGroup(); + + bool isExclusive() const; + bool isRadioButtonExclusive() const { return radio_excl; } + void setExclusive(bool); + void setRadioButtonExclusive(bool); + +public: + int insert(QAbstractButton *, int id=-1); + void remove(QAbstractButton *); + QAbstractButton *find(int id) const; + int id(QAbstractButton *) const; + int count() const; + + void setButton(int id); + + QAbstractButton *selected() const; + int selectedId() const; + +Q_SIGNALS: + void pressed(int id); + void released(int id); + void clicked(int id); + +protected Q_SLOTS: + void buttonPressed(); + void buttonReleased(); + void buttonClicked(); + +protected: + bool event(QEvent * e); + +private Q_SLOTS: + void buttonDestroyed(); + +private: + Q_DISABLE_COPY(Q3ButtonGroup) + + void init(); + void fixChildren() const; + int insert_helper(QAbstractButton* , int id=-1); + void remove_helper(QAbstractButton *); + + bool excl_grp; // Not used. + bool radio_excl; + QMap<int, QAbstractButton*> buttonIds; + QButtonGroup group; +}; + +class Q_COMPAT_EXPORT Q3VButtonGroup : public Q3ButtonGroup +{ + Q_OBJECT +public: + inline Q3VButtonGroup(QWidget* parent=0, const char* name=0) + : Q3ButtonGroup(1, Qt::Horizontal /* sic! */, parent, name) {} + inline Q3VButtonGroup(const QString &title, QWidget* parent=0, const char* name=0) + : Q3ButtonGroup(1, Qt::Horizontal /* sic! */, title, parent, name) {} + +private: + Q_DISABLE_COPY(Q3VButtonGroup) +}; + + +class Q_COMPAT_EXPORT Q3HButtonGroup : public Q3ButtonGroup +{ + Q_OBJECT +public: + inline Q3HButtonGroup(QWidget* parent=0, const char* name=0) + : Q3ButtonGroup(1, Qt::Vertical /* sic! */, parent, name) {} + inline Q3HButtonGroup(const QString &title, QWidget* parent=0, const char* name=0) + : Q3ButtonGroup(1, Qt::Vertical /* sic! */, title, parent, name) {} + +private: + Q_DISABLE_COPY(Q3HButtonGroup) +}; + +QT_END_NAMESPACE + +QT_END_HEADER + +#endif // Q3BUTTONGROUP_H diff --git a/src/qt3support/widgets/q3combobox.cpp b/src/qt3support/widgets/q3combobox.cpp new file mode 100644 index 0000000..e8341ac --- /dev/null +++ b/src/qt3support/widgets/q3combobox.cpp @@ -0,0 +1,2357 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the Qt3Support module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, 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 qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "q3combobox.h" +#ifndef QT_NO_COMBOBOX +#include "qpainter.h" +#include "qdrawutil.h" +#include "qpixmap.h" +#include "qtimer.h" +#include "qapplication.h" +#include "qlineedit.h" +#include "qbitmap.h" +#include "qstringlist.h" +#include "qstyle.h" +#include "qevent.h" +#include "qmenu.h" +#include "qmenudata.h" +#include "qstyleoption.h" +#include "qdesktopwidget.h" +#include "q3popupmenu.h" +#include "q3listbox.h" +#include "q3strlist.h" +#include "q3frame.h" +#include <limits.h> +#include <qdebug.h> +#ifndef QT_NO_EFFECTS +# include <private/qeffects_p.h> +#endif +#if defined(QT_ACCESSIBILITY_SUPPORT) +#include "qaccessible.h" +#endif + +QT_BEGIN_NAMESPACE + +/*! + \class Q3ComboBox + \brief The Q3ComboBox widget is a combined button and popup list. + \since 4.1 + \compat + + A combobox is a selection widget which displays the current item + and can pop up a list of items. A combobox may be editable in + which case the user can enter arbitrary strings. + + Comboboxes provide a means of showing the user's current choice + out of a list of options in a way that takes up the minimum amount + of screen space. + + Q3ComboBox supports three different display styles: Aqua/Motif 1.x, + Motif 2.0 and Windows. In Motif 1.x, a combobox was called + XmOptionMenu. In Motif 2.0, OSF introduced an improved combobox + and named that XmComboBox. Q3ComboBox provides both. + + Q3ComboBox provides two different constructors. The simplest + constructor creates an "old-style" combobox in Motif (or Aqua) + style: + \snippet doc/src/snippets/code/src_qt3support_widgets_q3combobox.cpp 0 + + The other constructor creates a new-style combobox in Motif style, + and can create both read-only and editable comboboxes: + \snippet doc/src/snippets/code/src_qt3support_widgets_q3combobox.cpp 1 + + New-style comboboxes use a list box in both Motif and Windows + styles, and both the content size and the on-screen size of the + list box can be limited with sizeLimit() and setMaxCount() + respectively. Old-style comboboxes use a popup in Aqua and Motif + style, and that popup will happily grow larger than the desktop if + you put enough data into it. + + The two constructors create identical-looking comboboxes in + Windows style. + + Comboboxes can contain pixmaps as well as strings; the + insertItem() and changeItem() functions are suitably overloaded. + For editable comboboxes, the function clearEdit() is provided, + to clear the displayed string without changing the combobox's + contents. + + A combobox emits two signals, activated() and highlighted(), when + a new item has been activated (selected) or highlighted (made + current). Both signals exist in two versions, one with a \c + QString argument and one with an \c int argument. If the user + highlights or activates a pixmap, only the \c int signals are + emitted. Whenever the text of an editable combobox is changed the + textChanged() signal is emitted. + + When the user enters a new string in an editable combobox, the + widget may or may not insert it, and it can insert it in several + locations. The default policy is is \c AtBottom but you can change + this using setInsertionPolicy(). + + It is possible to constrain the input to an editable combobox + using QValidator; see setValidator(). By default, any input is + accepted. + + If the combobox is not editable then it has a default + focusPolicy() of \c TabFocus, i.e. it will not grab focus if + clicked. This differs from both Windows and Motif. If the combobox + is editable then it has a default focusPolicy() of \c StrongFocus, + i.e. it will grab focus if clicked. + + A combobox can be populated using the insert functions, + insertStringList() and insertItem() for example. Items can be + changed with changeItem(). An item can be removed with + removeItem() and all items can be removed with clear(). The text + of the current item is returned by currentText(), and the text of + a numbered item is returned with text(). The current item can be + set with setCurrentItem() or setCurrentText(). The number of items + in the combobox is returned by count(); the maximum number of + items can be set with setMaxCount(). You can allow editing using + setEditable(). For editable comboboxes you can set auto-completion + using setAutoCompletion() and whether or not the user can add + duplicates is set with setDuplicatesEnabled(). + + Depending on the style, Q3ComboBox will use a list box or a + popup menu to display the list of items. See setListBox() for + more information. + + \sa QComboBox, QLineEdit, QSpinBox + {GUI Design Handbook}{GUI Design Handbook: Combo Box, Drop-Down List Box} +*/ + + +/*! + \enum Q3ComboBox::Policy + + This enum specifies what the Q3ComboBox should do when a new string + is entered by the user. + + \value NoInsertion the string will not be inserted into the + combobox. + + \value AtTop insert the string as the first item in the combobox. + + \value AtCurrent replace the previously selected item with the + string the user has entered. + + \value AtBottom insert the string as the last item in the + combobox. + + \value AfterCurrent insert the string after the previously + selected item. + + \value BeforeCurrent insert the string before the previously + selected item. + + activated() is always emitted when the string is entered. + + If inserting the new string would cause the combobox to breach its + content size limit, the item at the other end of the list is + deleted. The definition of "other end" is + implementation-dependent. + + \omitvalue NoInsert + \omitvalue InsertAtTop + \omitvalue InsertAtCurrent + \omitvalue InsertAtBottom + \omitvalue InsertAfterCurrent + \omitvalue InsertBeforeCurrent +*/ + + +/*! + \fn void Q3ComboBox::activated( int index ) + + This signal is emitted when a new item has been activated + (selected). The \a index is the position of the item in the + combobox. + + This signal is not emitted if the item is changed + programmatically, e.g. using setCurrentItem(). +*/ + +/*! + \overload + \fn void Q3ComboBox::activated( const QString &string ) + + This signal is emitted when a new item has been activated + (selected). \a string is the selected string. + + You can also use the activated(int) signal, but be aware that its + argument is meaningful only for selected strings, not for user + entered strings. +*/ + +/*! + \fn void Q3ComboBox::highlighted( int index ) + + This signal is emitted when a new item has been set to be the + current item. The \a index is the position of the item in the + combobox. + + This signal is not emitted if the item is changed + programmatically, e.g. using setCurrentItem(). +*/ + +/*! + \overload + \fn void Q3ComboBox::highlighted( const QString &string ) + + This signal is emitted when a new item has been set to be the + current item. \a string is the item's text. + + You can also use the highlighted(int) signal. +*/ + +/*! + \fn void Q3ComboBox::textChanged( const QString &string ) + + This signal is used for editable comboboxes. It is emitted + whenever the contents of the text entry field changes. \a string + contains the new text. +*/ + +/*! + \property Q3ComboBox::autoCompletion + \brief whether auto-completion is enabled + + This property can only be set for editable comboboxes, for + non-editable comboboxes it has no effect. It is false by default. +*/ + +/*! + \property Q3ComboBox::autoResize + \brief whether auto-resize is enabled + \obsolete + + If this property is set to true then the combobox will resize + itself whenever its contents change. The default is false. +*/ + +/*! + \property Q3ComboBox::count + \brief the number of items in the combobox +*/ + +/*! + \property Q3ComboBox::currentItem + \brief the index of the current item in the combobox + + Note that the activated() and highlighted() signals are only + emitted when the user changes the current item, not when it is + changed programmatically. +*/ + +/*! + \property Q3ComboBox::currentText + \brief the text of the combobox's current item +*/ + +/*! + \property Q3ComboBox::duplicatesEnabled + \brief whether duplicates are allowed + + If the combobox is editable and the user enters some text in the + combobox's lineedit and presses Enter (and the insertionPolicy() + is not \c NoInsertion), then what happens is this: + \list + \i If the text is not already in the list, the text is inserted. + \i If the text is in the list and this property is true (the + default), the text is inserted. + \i If the text is in the list and this property is false, the text + is \e not inserted; instead the item which has matching text becomes + the current item. + \endlist + + This property only affects user-interaction. You can use + insertItem() to insert duplicates if you wish regardless of this + setting. +*/ + +/*! + \property Q3ComboBox::editable + \brief whether the combobox is editable + + This property's default is false. Note that the combobox will be + cleared if this property is set to true for a 1.x Motif style + combobox. To avoid this, use setEditable() before inserting any + items. Also note that the 1.x version of Motif didn't have any + editable comboboxes, so the combobox will change its appearance + to a 2.0 style Motif combobox is it is set to be editable. +*/ + +/*! + \property Q3ComboBox::insertionPolicy + \brief the position of the items inserted by the user + + The default insertion policy is \c AtBottom. See \l Policy. +*/ + +/*! + \property Q3ComboBox::maxCount + \brief the maximum number of items allowed in the combobox +*/ + +/*! + \property Q3ComboBox::sizeLimit + \brief the maximum on-screen size of the combobox. + + This property is ignored for both Motif 1.x style and non-editable + comboboxes in Mac style. The default limit is ten + lines. If the number of items in the combobox is or grows larger + than lines, a scroll bar is added. +*/ + +class Q3ComboBoxPopup : public Q3PopupMenu +{ +public: + Q3ComboBoxPopup( QWidget *parent=0, const char *name=0 ) + : Q3PopupMenu( parent, name ) + { + } + + int itemHeight( int index ) + { + return Q3PopupMenu::itemHeight( index ); + } +}; + +static inline QString escapedComboString(const QString &str) +{ + QString stringToReturn = str; + return stringToReturn.replace(QLatin1Char('&'), QLatin1String("&&")); +} + +class Q3ComboBoxPopupItem : public QMenuItem +{ + Q3ListBoxItem *li; + QSize sc; // Size cache optimization +public: + Q3ComboBoxPopupItem(Q3ListBoxItem *i) : QMenuItem(), li(i), sc(0, 0) { } + virtual bool fullSpan() const { return true; } + virtual void paint( QPainter*, const QColorGroup&, bool, bool, int, int, int, int); + virtual QSize sizeHint() { if (sc.isNull()) sc = QSize(li->width(li->listBox()), QMAX(25, li->height(li->listBox()))); return sc; } +}; +void Q3ComboBoxPopupItem::paint( QPainter* p, const QColorGroup&, bool, + bool, int x, int y, int, int) +{ + p->save(); + p->translate(x, y + ((sizeHint().height() / 2) - (li->height(li->listBox()) / 2))); + li->paint(p); + p->restore(); +} + + +class Q3ComboBoxData +{ +public: + Q3ComboBoxData( Q3ComboBox *cb ): current( 0 ), arrowDown(false), ed( 0 ), usingLBox( false ), pop( 0 ), lBox( 0 ), combo( cb ) + { + duplicatesEnabled = true; + cb->setSizePolicy( QSizePolicy( QSizePolicy::Minimum, QSizePolicy::Fixed ) ); + } + + inline bool usingListBox() { return usingLBox; } + inline Q3ListBox * listBox() { return lBox; } + inline Q3ComboBoxPopup * popup() { return pop; } + void updateLinedGeometry(); + + void setListBox( Q3ListBox *l ) { lBox = l ; usingLBox = true; + l->setMouseTracking( true );} + + void setPopupMenu( Q3ComboBoxPopup * pm, bool isPopup=true ) + { pop = pm; if(isPopup) usingLBox = false; } + + QStyleOptionComboBox getStyleOption() const + { + QStyleOptionComboBox opt; + opt.init(combo); + if (!combo->editable() && combo->hasFocus()) + opt.state |= QStyle::State_Selected; + opt.subControls = QStyle::SC_All; + if (arrowDown) { + opt.activeSubControls = QStyle::SC_ComboBoxArrow; + opt.state |= QStyle::State_Sunken; + } + opt.editable = combo->editable(); + opt.frame = 1; // ### get from style? + if (current > -1 && current < combo->count()) { + opt.currentText = combo->text(current); + if (combo->pixmap(current)) + opt.currentIcon = QIcon(*combo->pixmap(current)); + } + opt.iconSize = QSize(22, 22); // ### need a sane value here +// if (container && container->isVisible()) +// opt.state |= QStyle::State_On; + return opt; + } + + int current; + int maxCount; + int sizeLimit; + Q3ComboBox::Policy p; + bool autoresize; + bool poppedUp; + bool mouseWasInsidePopup; + bool arrowPressed; + bool arrowDown; + bool discardNextMousePress; + bool shortClick; + bool useCompletion; + bool completeNow; + int completeAt; + bool duplicatesEnabled; + int fullHeight, currHeight; + + QLineEdit * ed; // /bin/ed rules! + QTimer *completionTimer; + + QSize sizeHint; + QHash<int, QPixmap> popupPixmaps; + +private: + bool usingLBox; + Q3ComboBoxPopup *pop; + Q3ListBox *lBox; + Q3ComboBox *combo; +}; + +void Q3ComboBoxData::updateLinedGeometry() +{ + if ( !ed || !combo ) + return; + + QStyleOptionComboBox opt = getStyleOption(); + QRect r = combo->style()->subControlRect( + QStyle::CC_ComboBox, &opt, QStyle::SC_ComboBoxEditField, combo); + + const QPixmap *pix = current < combo->count() ? combo->pixmap( current ) : 0; + if ( pix && pix->width() < r.width() ) + r.setLeft( r.left() + pix->width() + 4 ); + if ( r != ed->geometry() ) + ed->setGeometry( r ); +} + +static inline bool checkInsertIndex( const char *method, const char * name, + int count, int *index) +{ + bool range_err = (*index > count); +#if defined(QT_CHECK_RANGE) + if ( range_err ) + qWarning( "Q3ComboBox::%s: (%s) Index %d out of range", + method, name ? name : "<no name>", *index ); +#else + Q_UNUSED( method ) + Q_UNUSED( name ) +#endif + if ( *index < 0 ) // append + *index = count; + return !range_err; +} + + +static inline bool checkIndex( const char *method, const char * name, + int count, int index ) +{ + bool range_err = (index >= count); +#if defined(QT_CHECK_RANGE) + if ( range_err ) + qWarning( "Q3ComboBox::%s: (%s) Index %i out of range", + method, name ? name : "<no name>", index ); +#else + Q_UNUSED( method ) + Q_UNUSED( name ) +#endif + return !range_err; +} + + + +/*! + Constructs a combobox widget with parent \a parent called \a name. + + This constructor creates a popup list if the program uses Motif + (or Aqua) look and feel; this is compatible with Motif 1.x and + Aqua. + + Note: If you use this constructor to create your Q3ComboBox, then + the pixmap() function will always return 0. To workaround this, + use the other constructor. + +*/ + + + +Q3ComboBox::Q3ComboBox( QWidget *parent, const char *name ) + : QWidget( parent, name, Qt::WNoAutoErase ) +{ + d = new Q3ComboBoxData( this ); + QStyleOptionComboBox opt; + opt.init(this); + if ( style()->styleHint(QStyle::SH_ComboBox_Popup, &opt, this) || + style()->styleHint(QStyle::SH_GUIStyle, &opt, this) == Qt::MotifStyle ) { + d->setPopupMenu( new Q3ComboBoxPopup( this, "in-combo" ) ); + d->popup()->setFont( font() ); + connect( d->popup(), SIGNAL(activated(int)), + SLOT(internalActivate(int)) ); + connect( d->popup(), SIGNAL(highlighted(int)), + SLOT(internalHighlight(int)) ); + } else { + setUpListBox(); + } + d->ed = 0; + d->current = 0; + d->maxCount = INT_MAX; + d->sizeLimit = 10; + d->p = AtBottom; + d->autoresize = false; + d->poppedUp = false; + d->arrowDown = false; + d->arrowPressed = false; + d->discardNextMousePress = false; + d->shortClick = false; + d->useCompletion = false; + d->completeAt = 0; + d->completeNow = false; + d->completionTimer = new QTimer( this ); + + setFocusPolicy( Qt::TabFocus ); + setBackgroundMode( Qt::PaletteButton ); +} + + +/*! + Constructs a combobox with a maximum size and either Motif 2.0 or + Windows look and feel. + + The input field can be edited if \a rw is true, otherwise the user + may only choose one of the items in the combobox. + + The \a parent and \a name arguments are passed on to the QWidget + constructor. +*/ + + +Q3ComboBox::Q3ComboBox( bool rw, QWidget *parent, const char *name ) + : QWidget( parent, name, Qt::WNoAutoErase ) +{ + d = new Q3ComboBoxData( this ); + setUpListBox(); + + QStyleOptionComboBox opt = d->getStyleOption(); + if(d->popup() && style()->styleHint(QStyle::SH_ComboBox_Popup, &opt, this)) + d->popup()->setItemChecked(d->current, false); + d->maxCount = INT_MAX; + setSizeLimit(10); + d->p = AtBottom; + d->autoresize = false; + d->poppedUp = false; + d->arrowDown = false; + d->discardNextMousePress = false; + d->shortClick = false; + d->useCompletion = false; + d->completeAt = 0; + d->completeNow = false; + d->completionTimer = new QTimer( this ); + + setFocusPolicy( Qt::StrongFocus ); + + d->ed = 0; + if ( rw ) + setUpLineEdit(); + setBackgroundMode( Qt::PaletteButton, Qt::PaletteBase ); +} + + + +/*! + Destroys the combobox. +*/ + +Q3ComboBox::~Q3ComboBox() +{ + delete d; +} + +void Q3ComboBox::setDuplicatesEnabled( bool enable ) +{ + d->duplicatesEnabled = enable; +} + +bool Q3ComboBox::duplicatesEnabled() const +{ + return d->duplicatesEnabled; +} + +int Q3ComboBox::count() const +{ + if ( d->usingListBox() ) + return d->listBox()->count(); + else if (d->popup()) + return d->popup()->count(); + else + return 0; +} + + +/*! + \overload + + Inserts the \a list of strings at position \a index in the + combobox. + + This is only for compatibility since it does not support Unicode + strings. See insertStringList(). +*/ + +void Q3ComboBox::insertStrList( const Q3StrList &list, int index ) +{ + insertStrList( &list, index ); +} + +/*! + \overload + + Inserts the \a list of strings at position \a index in the + combobox. + + This is only for compatibility since it does not support Unicode + strings. See insertStringList(). +*/ + +void Q3ComboBox::insertStrList( const Q3StrList *list, int index ) +{ + if ( !list ) { +#if defined(QT_CHECK_NULL) + Q_ASSERT( list != 0 ); +#endif + return; + } + Q3StrListIterator it( *list ); + const char* tmp; + if ( index < 0 ) + index = count(); + while ( (tmp=it.current()) ) { + ++it; + if ( d->usingListBox() ) + d->listBox()->insertItem( QString::fromLatin1(tmp), index ); + else + d->popup()->insertItem( escapedComboString(QString::fromLatin1(tmp)), index, index ); + if ( index++ == d->current && d->current < count() ) { + if ( d->ed ) { + d->ed->setText( text( d->current ) ); + d->updateLinedGeometry(); + } else + update(); + currentChanged(); + } + } + if ( index != count() ) + reIndex(); +} + +/*! + Inserts the \a list of strings at position \a index in the + combobox. +*/ + +void Q3ComboBox::insertStringList( const QStringList &list, int index ) +{ + QStringList::ConstIterator it = list.begin(); + if ( index < 0 ) + index = count(); + while ( it != list.end() ) { + if ( d->usingListBox() ) + d->listBox()->insertItem( *it, index ); + else + d->popup()->insertItem( escapedComboString(*it), index, index ); + if ( index++ == d->current && d->current < count() ) { + if ( d->ed ) { + d->ed->setText( text( d->current ) ); + d->updateLinedGeometry(); + } else + update(); + currentChanged(); + } + ++it; + } + if ( index != count() ) + reIndex(); +} + +/*! + Inserts the array of char * \a strings at position \a index in the + combobox. + + The \a numStrings argument is the number of strings. If \a + numStrings is -1 (default), the \a strings array must be + terminated with 0. + + Example: + \snippet doc/src/snippets/code/src_qt3support_widgets_q3combobox.cpp 2 + + \sa insertStringList() +*/ + +void Q3ComboBox::insertStrList( const char **strings, int numStrings, int index) +{ + if ( !strings ) { +#if defined(QT_CHECK_NULL) + Q_ASSERT( strings != 0 ); +#endif + return; + } + if ( index < 0 ) + index = count(); + int i = 0; + while ( (numStrings<0 && strings[i]!=0) || i<numStrings ) { + if ( d->usingListBox() ) + d->listBox()->insertItem( QString::fromLatin1(strings[i]), index ); + else + d->popup()->insertItem( escapedComboString(QString::fromLatin1(strings[i])), index, index ); + i++; + if ( index++ == d->current && d->current < count() ) { + if ( d->ed ) { + d->ed->setText( text( d->current ) ); + d->updateLinedGeometry(); + } else + update(); + currentChanged(); + } + } + if ( index != count() ) + reIndex(); +} + + +/*! + Inserts a text item with text \a t, at position \a index. The item + will be appended if \a index is negative. +*/ + +void Q3ComboBox::insertItem( const QString &t, int index ) +{ + int cnt = count(); + if ( !checkInsertIndex( "insertItem", name(), cnt, &index ) ) + return; + if ( d->usingListBox() ) + d->listBox()->insertItem( t, index ); + else + d->popup()->insertItem( escapedComboString(t), index, index ); + if ( index != cnt ) + reIndex(); + if ( index == d->current && d->current < count() ) { + if ( d->ed ) { + d->ed->setText( text( d->current ) ); + d->updateLinedGeometry(); + } else + update(); + } + if ( index == d->current ) + currentChanged(); +} + +/*! + \overload + + Inserts a \a pixmap item at position \a index. The item will be + appended if \a index is negative. +*/ + +void Q3ComboBox::insertItem( const QPixmap &pixmap, int index ) +{ + int cnt = count(); + if ( !checkInsertIndex( "insertItem", name(), cnt, &index ) ) + return; + if ( d->usingListBox() ) + d->listBox()->insertItem( pixmap, index ); + else + d->popup()->insertItem( pixmap, index, index ); + if ( index != cnt ) + reIndex(); + if ( index == d->current && d->current < count() ) { + if ( d->ed ) { + d->ed->setText( text( d->current ) ); + d->updateLinedGeometry(); + } else + update(); + } + if ( index == d->current ) + currentChanged(); +} + +/*! + \overload + + Inserts a \a pixmap item with additional text \a text at position + \a index. The item will be appended if \a index is negative. +*/ + +void Q3ComboBox::insertItem( const QPixmap &pixmap, const QString& text, int index ) +{ + int cnt = count(); + if ( !checkInsertIndex( "insertItem", name(), cnt, &index ) ) + return; + if ( d->usingListBox() ) + d->listBox()->insertItem( pixmap, text, index ); + else + d->popup()->insertItem( pixmap, escapedComboString(text), index, index ); + if ( index != cnt ) + reIndex(); + if ( index == d->current && d->current < count() ) { + if ( d->ed ) { + d->ed->setText( this->text( d->current ) ); + d->updateLinedGeometry(); + } else + update(); + } + if ( index == d->current ) + currentChanged(); +} + + +/*! + Removes the item at position \a index. +*/ + +void Q3ComboBox::removeItem( int index ) +{ + int cnt = count(); + if ( !checkIndex( "removeItem", name(), cnt, index ) ) + return; + if ( d->usingListBox() ) { + QStyleOptionComboBox opt = d->getStyleOption(); + if ( style()->styleHint(QStyle::SH_ComboBox_Popup, &opt, this) && d->popup() ) + d->popup()->removeItemAt( index ); + d->listBox()->removeItem( index ); + } else { + d->popup()->removeItemAt( index ); + } + if ( index != cnt-1 ) + reIndex(); + if ( index == d->current ) { + if ( d->ed ) { + QString s = QString::fromLatin1(""); + if (d->current < cnt - 1) + s = text( d->current ); + d->ed->setText( s ); + d->updateLinedGeometry(); + } + else { + if ( d->usingListBox() ) { + d->current = d->listBox()->currentItem(); + } else { + if (d->current > count()-1 && d->current > 0) + d->current--; + } + update(); + } + currentChanged(); + } + else { + if ( !d->ed ) { + if (d->current < cnt - 1) + setCurrentItem( d->current ); + else + setCurrentItem( d->current - 1 ); + } + } + +} + + +/*! + Removes all combobox items. +*/ + +void Q3ComboBox::clear() +{ + QStyleOptionComboBox opt = d->getStyleOption(); + if ( d->usingListBox() ) { + if ( style()->styleHint(QStyle::SH_ComboBox_Popup, &opt, this) && d->popup() ) + d->popup()->clear(); + d->listBox()->resize( 0, 0 ); + d->listBox()->clear(); + } else { + d->popup()->clear(); + } + + if(d->popup() && style()->styleHint(QStyle::SH_ComboBox_Popup, &opt, this)) + d->popup()->setItemChecked(d->current, false); + d->current = 0; + if ( d->ed ) { + d->ed->setText( QString::fromLatin1("") ); + d->updateLinedGeometry(); + } + currentChanged(); +} + + +QString Q3ComboBox::currentText() const +{ + if ( d->ed ) + return d->ed->text(); + else if ( d->current < count() ) + return text( currentItem() ); + else + return QString::null; +} + +void Q3ComboBox::setCurrentText( const QString& txt ) +{ + int i; + for ( i = 0; i < count(); i++) + if ( text( i ) == txt ) + break; + if ( i < count() ) + setCurrentItem( i ); + else if ( d->ed ) + d->ed->setText( txt ); + else + changeItem( txt, currentItem() ); +} + + +/*! + Returns the text item at position \a index, or QString::null if + the item is not a string. + + \sa currentText() +*/ + +QString Q3ComboBox::text( int index ) const +{ + if ( !checkIndex( "text", name(), count(), index ) ) + return QString::null; + if ( d->usingListBox() ) { + return d->listBox()->text( index ); + } else { + QString retText = d->popup()->text(index); + retText.replace(QLatin1String("&&"), QString(QLatin1Char('&'))); + return retText; + } +} + +/*! + Returns the pixmap item at position \a index, or 0 if the item is + not a pixmap. +*/ + +const QPixmap *Q3ComboBox::pixmap( int index ) const +{ + if ( !checkIndex( "pixmap", name(), count(), index ) ) + return 0; + + if (d->usingListBox()) { + return d->listBox()->pixmap( index ); + } else { + d->popupPixmaps[index] = d->popup()->pixmap(index); + return d->popupPixmaps[index].isNull() ? 0 : &d->popupPixmaps[index]; + } +} + +/*! + Replaces the item at position \a index with the text \a t. +*/ + +void Q3ComboBox::changeItem( const QString &t, int index ) +{ + if ( !checkIndex( "changeItem", name(), count(), index ) ) + return; + if ( d->usingListBox() ) + d->listBox()->changeItem( t, index ); + else + d->popup()->changeItem(index, t); + if ( index == d->current ) { + if ( d->ed ) { + d->ed->setText( text( d->current ) ); + d->updateLinedGeometry(); + } else + update(); + } +} + +/*! + \overload + + Replaces the item at position \a index with the pixmap \a im, + unless the combobox is editable. + + \sa insertItem() +*/ + +void Q3ComboBox::changeItem( const QPixmap &im, int index ) +{ + if ( !checkIndex( "changeItem", name(), count(), index ) ) + return; + if ( d->usingListBox() ) + d->listBox()->changeItem( im, index ); + else + d->popup()->changeItem(index, im); + if ( index == d->current ) + update(); +} + +/*! + \overload + + Replaces the item at position \a index with the pixmap \a im and + the text \a t. + + \sa insertItem() +*/ + +void Q3ComboBox::changeItem( const QPixmap &im, const QString &t, int index ) +{ + if ( !checkIndex( "changeItem", name(), count(), index ) ) + return; + if ( d->usingListBox() ) + d->listBox()->changeItem( im, t, index ); + else + d->popup()->changeItem(index, im, t); + if ( index == d->current ) + update(); +} + + +int Q3ComboBox::currentItem() const +{ + return d->current; +} + +void Q3ComboBox::setCurrentItem( int index ) +{ + if ( index == d->current && !d->ed ) { + return; + } + if ( !checkIndex( "setCurrentItem", name(), count(), index ) ) { + return; + } + + if ( d->usingListBox() && !( listBox()->item(index) && listBox()->item(index)->isSelectable() ) ) + return; + + QStyleOptionComboBox opt = d->getStyleOption(); + if(d->popup() && style()->styleHint(QStyle::SH_ComboBox_Popup, &opt, this)) + d->popup()->setItemChecked(d->current, false); + d->current = index; + d->completeAt = 0; + if ( d->ed ) { + d->ed->setText( text( index ) ); + d->updateLinedGeometry(); + } + // ### We want to keep ListBox's currentItem in sync, even if NOT popuped... + if ( d->usingListBox() && d->listBox() ) { + d->listBox()->setCurrentItem( index ); + } else { + internalHighlight( index ); + // internalActivate( index ); ### this leads to weird behavior, as in 3.0.1 + } + + currentChanged(); +} + +/*! + Returns true if auto-resize is enabled; otherwise returns false. + + \sa autoResize +*/ + +bool Q3ComboBox::autoResize() const +{ + return d->autoresize; +} + +/*! + If \a enable is true, enable auto-resize; disable it otherwise. + + \sa autoResize +*/ + +void Q3ComboBox::setAutoResize( bool enable ) +{ + if ( (bool)d->autoresize != enable ) { + d->autoresize = enable; + if ( enable ) + adjustSize(); + } +} + + +/*! + \reimp + + This implementation caches the size hint to avoid resizing when + the contents change dynamically. To invalidate the cached value + call setFont(). +*/ +QSize Q3ComboBox::sizeHint() const +{ + if ( isVisible() && d->sizeHint.isValid() ) + return d->sizeHint; + + constPolish(); + int i, w; + QFontMetrics fm = fontMetrics(); + + int maxW = count() ? 18 : 7 * fm.width(QLatin1Char('x')) + 18; + int maxH = QMAX( fm.lineSpacing(), 14 ) + 2; + + if ( !d->usingListBox() ) { + w = d->popup()->sizeHint().width() - 2* d->popup()->frameWidth(); + if ( w > maxW ) + maxW = w; + } else { + for( i = 0; i < count(); i++ ) { + w = d->listBox()->item( i )->width( d->listBox() ); + if ( w > maxW ) + maxW = w; + } + } + + QStyleOptionComboBox opt = d->getStyleOption(); + d->sizeHint = (style()->sizeFromContents(QStyle::CT_ComboBox, &opt, QSize(maxW, maxH), this). + expandedTo(QApplication::globalStrut())); + + return d->sizeHint; +} + + +/*! + \internal + Receives activated signals from an internal popup list and emits + the activated() signal. +*/ + +void Q3ComboBox::internalActivate( int index ) +{ + QStyleOptionComboBox opt = d->getStyleOption(); + if ( d->current != index ) { + if ( !d->usingListBox() || listBox()->item( index )->isSelectable() ) { + if (d->popup() && style()->styleHint(QStyle::SH_ComboBox_Popup, &opt, this)) + d->popup()->setItemChecked(d->current, false); + d->current = index; + currentChanged(); + } + } + if ( d->usingListBox() ) + popDownListBox(); + else + d->popup()->removeEventFilter( this ); + d->poppedUp = false; + + QString t( text( index ) ); + if ( d->ed ) { + d->ed->setText( t ); + d->updateLinedGeometry(); + } + emit activated( index ); + emit activated( t ); +} + +/*! + \internal + Receives highlighted signals from an internal popup list and emits + the highlighted() signal. +*/ + +void Q3ComboBox::internalHighlight( int index ) +{ + emit highlighted( index ); + QString t = text( index ); + if ( !t.isNull() ) + emit highlighted( t ); +} + +/*! + \internal + Receives timeouts after a click. Used to decide if a Motif style + popup should stay up or not after a click. +*/ +void Q3ComboBox::internalClickTimeout() +{ + d->shortClick = false; +} + +/*! + Sets the palette for both the combobox button and the combobox + popup list to \a palette. +*/ + +void Q3ComboBox::setPalette( const QPalette &palette ) +{ + QWidget::setPalette( palette ); + if ( d->listBox() ) + d->listBox()->setPalette( palette ); + if ( d->popup() ) + d->popup()->setPalette( palette ); +} + +/*! + Sets the font for both the combobox button and the combobox popup + list to \a font. +*/ + +void Q3ComboBox::setFont( const QFont &font ) +{ + d->sizeHint = QSize(); // invalidate size hint + QWidget::setFont( font ); + if ( d->usingListBox() ) + d->listBox()->setFont( font ); + else + d->popup()->setFont( font ); + if (d->ed) + d->ed->setFont( font ); + if ( d->autoresize ) + adjustSize(); +} + + +/*!\reimp +*/ + +void Q3ComboBox::resizeEvent( QResizeEvent * e ) +{ + if ( d->ed ) + d->updateLinedGeometry(); + if ( d->listBox() ) + d->listBox()->resize( width(), d->listBox()->height() ); + QWidget::resizeEvent( e ); +} + +/*!\reimp +*/ + +void Q3ComboBox::paintEvent( QPaintEvent * ) +{ + QPainter p( this ); + const QColorGroup & g = colorGroup(); + p.setPen(g.text()); + + if ( width() < 5 || height() < 5 ) { + qDrawShadePanel( &p, rect(), g, false, 2, + &g.brush( QColorGroup::Button ) ); + return; + } + + QStyleOptionComboBox opt = d->getStyleOption(); + bool reverse = QApplication::reverseLayout(); + if ( !d->usingListBox() && + style()->styleHint(QStyle::SH_GUIStyle) == Qt::MotifStyle) { // motif 1.x style + int dist, buttonH, buttonW; + dist = 8; + buttonH = 7; + buttonW = 11; + int xPos; + int x0; + int w = width() - dist - buttonW - 1; + if ( reverse ) { + xPos = dist + 1; + x0 = xPos + 4; + } else { + xPos = w; + x0 = 4; + } + qDrawShadePanel( &p, rect(), g, false, + style()->pixelMetric(QStyle::PM_DefaultFrameWidth, &opt, this), + &g.brush( QColorGroup::Button ) ); + qDrawShadePanel( &p, xPos, (height() - buttonH)/2, + buttonW, buttonH, g, false, + style()->pixelMetric(QStyle::PM_DefaultFrameWidth, &opt, this) ); + QRect clip( x0, 2, w - 2 - 4 - 5, height() - 4 ); + QString str = d->popup()->text( this->d->current ); + if ( !str.isNull() ) { + p.drawText( clip, Qt::AlignCenter | Qt::TextSingleLine, str ); + } + + QPixmap pix = d->popup()->pixmap( this->d->current ); + QIcon iconSet = d->popup()->iconSet( this->d->current ); + if (!pix.isNull() || !iconSet.isNull()) { + QPixmap pm = ( !pix.isNull() ? pix : iconSet.pixmap() ); + p.setClipRect( clip ); + p.drawPixmap( 4, (height()-pm.height())/2, pm ); + p.setClipping( false ); + } + + if ( hasFocus() ) + p.drawRect( xPos - 5, 4, width() - xPos + 1 , height() - 8 ); + } else if(!d->usingListBox()) { + style()->drawComplexControl(QStyle::CC_ComboBox, &opt, &p, this); + QRect re = style()->subControlRect(QStyle::CC_ComboBox, &opt, + QStyle::SC_ComboBoxEditField, this); + p.setClipRect( re ); + + QString str = d->popup()->text( this->d->current ); + QPixmap pix = d->popup()->pixmap( this->d->current ); + if ( !str.isNull() ) { + p.save(); + p.setFont(font()); + QFontMetrics fm(font()); + int x = re.x(), y = re.y() + fm.ascent(); + x += pix.width() + 5; + p.drawText( x, y, str ); + p.restore(); + } + if (!pix.isNull()) { + p.fillRect(re.x(), re.y(), pix.width() + 4, re.height(), + colorGroup().brush(QColorGroup::Base)); + p.drawPixmap(re.x() + 2, re.y() + (re.height() - pix.height()) / 2, pix); + } + } else { + style()->drawComplexControl(QStyle::CC_ComboBox, &opt, &p, this); + QRect re = style()->subControlRect(QStyle::CC_ComboBox, &opt, + QStyle::SC_ComboBoxEditField, this); + p.setClipRect(re); + + if ( !d->ed ) { + Q3ListBoxItem * item = d->listBox()->item( d->current ); + if ( item ) { + int itemh = item->height( d->listBox() ); + p.translate( re.x(), re.y() + (re.height() - itemh)/2 ); + item->paint( &p ); + } + } else if ( d->listBox() && d->listBox()->item( d->current ) ) { + Q3ListBoxItem * item = d->listBox()->item( d->current ); + const QPixmap *pix = item->pixmap(); + if ( pix ) { + p.fillRect( re.x(), re.y(), pix->width() + 4, re.height(), + colorGroup().brush( QColorGroup::Base ) ); + p.drawPixmap( re.x() + 2, re.y() + + ( re.height() - pix->height() ) / 2, *pix ); + } + } + p.setClipping( false ); + } +} + + +/*!\reimp +*/ + +void Q3ComboBox::mousePressEvent( QMouseEvent *e ) +{ + if ( e->button() != Qt::LeftButton ) + return; + if ( d->discardNextMousePress ) { + d->discardNextMousePress = false; + return; + } + + QStyleOptionComboBox opt = d->getStyleOption(); + QRect arrowRect = style()->subControlRect(QStyle::CC_ComboBox, &opt, QStyle::SC_ComboBoxArrow + , this); + + // Correction for motif style, where arrow is smaller + // and thus has a rect that doesn't fit the button. + arrowRect.setHeight( QMAX( height() - (2 * arrowRect.y()), arrowRect.height() ) ); + + if ( count() && ( !editable() || arrowRect.contains( e->pos() ) ) ) { + d->arrowPressed = false; + + if ( d->usingListBox() ) { + listBox()->blockSignals( true ); + qApp->sendEvent( listBox(), e ); // trigger the listbox's autoscroll + listBox()->setCurrentItem(d->current); + listBox()->blockSignals( false ); + popup(); + if ( arrowRect.contains( e->pos() ) ) { + d->arrowPressed = true; + d->arrowDown = true; + repaint( false ); + } + } else { + popup(); + } + QTimer::singleShot( 200, this, SLOT(internalClickTimeout())); + d->shortClick = true; + } +} + +/*!\reimp +*/ + +void Q3ComboBox::mouseMoveEvent( QMouseEvent * ) +{ +} + +/*!\reimp +*/ + +void Q3ComboBox::mouseReleaseEvent( QMouseEvent * ) +{ +} + +/*!\reimp +*/ + +void Q3ComboBox::mouseDoubleClickEvent( QMouseEvent *e ) +{ + mousePressEvent( e ); +} + + +/*!\reimp +*/ + +void Q3ComboBox::keyPressEvent( QKeyEvent *e ) +{ + bool handleEventHere = d->usingListBox() || !d->poppedUp; + + int c = currentItem(); + if ( ( e->key() == Qt::Key_F4 && e->state() == 0 ) || + ( e->key() == Qt::Key_Down && (e->state() & Qt::AltModifier) ) || + ( !d->ed && e->key() == Qt::Key_Space ) ) { + if ( count() ) { + if ( !d->usingListBox() ) + d->popup()->setActiveItem( this->d->current ); + popup(); + } + return; + } else if ( handleEventHere && e->key() == Qt::Key_Up ) { + if ( c > 0 ) + setCurrentItem( c-1 ); + } else if ( handleEventHere && e->key() == Qt::Key_Down ) { + if ( ++c < count() ) + setCurrentItem( c ); + } else if ( handleEventHere && e->key() == Qt::Key_Home && ( !d->ed || !d->ed->hasFocus() ) ) { + setCurrentItem( 0 ); + } else if ( handleEventHere && e->key() == Qt::Key_End && ( !d->ed || !d->ed->hasFocus() ) ) { + setCurrentItem( count()-1 ); + } else if ( !d->ed && e->ascii() >= 32 && !e->text().isEmpty() ) { + if ( !d->completionTimer->isActive() ) { + d->completeAt = 0; + c = completionIndex( e->text(), ++c ); + if ( c >= 0 ) { + setCurrentItem( c ); + d->completeAt = e->text().length(); + } + } else { + d->completionTimer->stop(); + QString ct = currentText().left( d->completeAt ) + e->text(); + c = completionIndex( ct, c ); + if ( c < 0 && d->completeAt > 0 ) { + c = completionIndex( e->text(), 0 ); + ct = e->text(); + } + d->completeAt = 0; + if ( c >= 0 ) { + setCurrentItem( c ); + d->completeAt = ct.length(); + } + } + d->completionTimer->start( 400, true ); + } else { + e->ignore(); + return; + } + + c = currentItem(); + if ( count() && !text( c ).isNull() ) + emit activated( text( c ) ); + emit activated( c ); +} + + +/*!\reimp +*/ + +void Q3ComboBox::focusInEvent( QFocusEvent * e ) +{ + QWidget::focusInEvent( e ); + d->completeNow = false; + d->completeAt = 0; +} + +/*!\reimp +*/ + +void Q3ComboBox::focusOutEvent( QFocusEvent * e ) +{ + QWidget::focusOutEvent( e ); + d->completeNow = false; + d->completeAt = 0; +} + +/*!\reimp +*/ +#ifndef QT_NO_WHEELEVENT +void Q3ComboBox::wheelEvent( QWheelEvent *e ) +{ + if ( d->poppedUp ) { + if ( d->usingListBox() ) { + QApplication::sendEvent( d->listBox(), e ); + } + } else { + if ( e->delta() > 0 ) { + int c = currentItem(); + if ( c > 0 ) { + setCurrentItem( c-1 ); + emit activated( currentItem() ); + emit activated( currentText() ); + } + } else { + int c = currentItem(); + if ( ++c < count() ) { + setCurrentItem( c ); + emit activated( currentItem() ); + emit activated( currentText() ); + } + } + e->accept(); + } +} +#endif + +/*! + \internal + Calculates the listbox height needed to contain all items, or as + many as the list box is supposed to contain. +*/ +static int listHeight( Q3ListBox *l, int sl ) +{ + if ( l->count() > 0 ) + return QMIN( l->count(), (uint)sl) * l->item( 0 )->height(l); + else + return l->sizeHint().height(); +} + + +/*! + Pops up the combobox popup list. + + If the list is empty, no items appear. +*/ + +void Q3ComboBox::popup() +{ + if ( !count() || d->poppedUp ) + return; + + QStyleOptionComboBox opt = d->getStyleOption(); + if( !d->usingListBox() || style()->styleHint(QStyle::SH_ComboBox_Popup, &opt, this) ) { + if(d->usingListBox()) { + if(!d->popup()) { + Q3ComboBoxPopup *p = new Q3ComboBoxPopup( this, "in-combo" ); + d->setPopupMenu( p, false ); + p->setFont( font() ); + connect( p, SIGNAL(activated(int)), SLOT(internalActivate(int)) ); + connect( p, SIGNAL(highlighted(int)), SLOT(internalHighlight(int)) ); + } + d->popup()->clear(); + for(unsigned int i = 0; i < d->listBox()->count(); i++) { + Q3ListBoxItem *item = d->listBox()->item(i); + if(item->rtti() == Q3ListBoxText::RTTI) { + d->popup()->insertItem(escapedComboString(item->text()), i, i); + } else if(item->rtti() == Q3ListBoxPixmap::RTTI) { + if(item->pixmap()) + d->popup()->insertItem(QIcon(*item->pixmap()), escapedComboString(item->text()), i, i); + else + d->popup()->insertItem(escapedComboString(item->text()), i, i); + } else { + d->popup()->insertItem(new Q3ComboBoxPopupItem(item), i, i); + } + } + } + d->popup()->installEventFilter( this ); + if(d->popup() && style()->styleHint(QStyle::SH_ComboBox_Popup, &opt, this)) + d->popup()->setItemChecked(this->d->current, true); + d->popup()->popup( mapToGlobal( QPoint(0,0) ), this->d->current ); + update(); + } else { + // Send all listbox events to eventFilter(): + Q3ListBox* lb = d->listBox(); + lb->triggerUpdate( true ); + lb->installEventFilter( this ); + d->mouseWasInsidePopup = false; + int w = lb->variableWidth() ? lb->sizeHint().width() : width(); + int h = listHeight( lb, d->sizeLimit ) + 2; + QRect screen = QApplication::desktop()->availableGeometry( this ); + + int sx = screen.x(); // screen pos + int sy = screen.y(); + int sw = screen.width(); // screen width + int sh = screen.height(); // screen height + QPoint pos = mapToGlobal( QPoint(0,height()) ); + // ## Similar code is in QPopupMenu + int x = pos.x(); + int y = pos.y(); + + // the complete widget must be visible + if ( x + w > sx + sw ) + x = sx+sw - w; + if ( x < sx ) + x = sx; + if (y + h > sy+sh && y - h - height() >= 0 ) + y = y - h - height(); + + opt.rect = QRect(x, y, w, h); + QRect rect = style()->subControlRect(QStyle::CC_ComboBox, &opt, + QStyle::SC_ComboBoxListBoxPopup, this); + + // work around older styles that don't implement the combobox + // listbox popup subcontrol + if ( rect.isNull() ) + rect.setRect( x, y, w, h ); + lb->setGeometry( rect ); + + lb->raise(); + bool block = lb->signalsBlocked(); + lb->blockSignals( true ); + Q3ListBoxItem* currentLBItem = 0; + if ( editable() && currentText() != text( currentItem() ) ) + currentLBItem = lb->findItem( currentText() ); + + currentLBItem = currentLBItem ? currentLBItem : lb->item( d->current ); + + lb->setCurrentItem( currentLBItem ); + lb->setContentsPos( lb->contentsX(), + lb->viewportToContents( lb->itemRect( currentLBItem ).topLeft() ).y() ); + + // set the current item to also be the selected item if it isn't already + if ( currentLBItem && currentLBItem->isSelectable() && !currentLBItem->isSelected() ) + lb->setSelected( currentLBItem, true ); + lb->blockSignals( block ); + lb->setVScrollBarMode(Q3ScrollView::Auto); + +#ifndef QT_NO_EFFECTS + if ( QApplication::isEffectEnabled( Qt::UI_AnimateCombo ) ) { + if ( lb->y() < mapToGlobal(QPoint(0,0)).y() ) + qScrollEffect( lb, QEffects::UpScroll ); + else + qScrollEffect( lb ); + } else +#endif + lb->show(); + } + d->poppedUp = true; +} + + +/*! + Updates the widget mask. + + \sa QWidget::setMask() +*/ +void Q3ComboBox::updateMask() +{ + QBitmap bm( size() ); + bm.fill( Qt::color0 ); + + QStyleOptionComboBox opt = d->getStyleOption(); + { + QPainter p(&bm); + p.initFrom(this); + p.fillRect(opt.rect, Qt::color1); // qcommonstyle old drawComplexControl implementation + } + + setMask( bm ); +} + +/*! + \internal + Pops down (removes) the combobox popup list box. +*/ +void Q3ComboBox::popDownListBox() +{ + Q_ASSERT( d->usingListBox() ); + d->listBox()->removeEventFilter( this ); + d->listBox()->viewport()->removeEventFilter( this ); + d->listBox()->hide(); + d->listBox()->setCurrentItem( d->current ); + if ( d->arrowDown ) { + d->arrowDown = false; + repaint( false ); + } + d->poppedUp = false; +} + + +/*! + \internal + Re-indexes the identifiers in the popup list. +*/ + +void Q3ComboBox::reIndex() +{ + if ( !d->usingListBox() ) { + int cnt = count(); + while ( cnt-- ) + d->popup()->setId( cnt, cnt ); + } +} + +/*! + \internal + Repaints the combobox. +*/ + +void Q3ComboBox::currentChanged() +{ + if ( d->autoresize ) + adjustSize(); + update(); + +#if defined(QT_ACCESSIBILITY_SUPPORT) + QAccessible::updateAccessibility( this, 0, QAccessible::ValueChanged ); +#endif +} + +/*! \reimp + + \internal + + The event filter steals events from the popup or listbox when they + are popped up. It makes the popup stay up after a short click in + motif style. In windows style it toggles the arrow button of the + combobox field, and activates an item and takes down the listbox + when the mouse button is released. +*/ + +bool Q3ComboBox::eventFilter( QObject *object, QEvent *event ) +{ + QStyleOptionComboBox opt = d->getStyleOption(); + if ( !event ) + return true; + else if ( object == d->ed ) { + if ( event->type() == QEvent::KeyPress ) { + bool isAccepted = ( (QKeyEvent*)event )->isAccepted(); + keyPressEvent( (QKeyEvent *)event ); + if ( ((QKeyEvent *)event)->isAccepted() ) { + d->completeNow = false; + return true; + } else if ( ((QKeyEvent *)event)->key() != Qt::Key_End ) { + d->completeNow = true; + d->completeAt = d->ed->cursorPosition(); + } + if ( isAccepted ) + ( (QKeyEvent*)event )->accept(); + else + ( (QKeyEvent*)event )->ignore(); + } else if ( event->type() == QEvent::KeyRelease ) { + keyReleaseEvent( (QKeyEvent *)event ); + return ((QKeyEvent *)event)->isAccepted(); + } else if ( event->type() == QEvent::FocusIn ) { + focusInEvent( (QFocusEvent *)event ); + } else if ( event->type() == QEvent::FocusOut ) { + focusOutEvent( (QFocusEvent *)event ); + } else if ( d->useCompletion && d->completeNow ) { + d->completeNow = false; + if ( !d->ed->text().isNull() && + d->ed->cursorPosition() > d->completeAt && + d->ed->cursorPosition() == (int)d->ed->text().length() ) { + QString ct( d->ed->text() ); + int i = completionIndex( ct, currentItem() ); + if ( i > -1 ) { + QString it = text( i ); + d->ed->validateAndSet( it, ct.length(), + ct.length(), it.length() ); + d->current = i; + // ### sets current item without emitting signals. This is to + // make sure the right item is current if you change current with + // wheel/up/down. While typing current is not valid anyway. Fix properly + // in 4.0. + } + } + } + } else if ( d->usingListBox() && ( object == d->listBox() || + object == d->listBox()->viewport() )) { + QMouseEvent *e = (QMouseEvent*)event; + switch( event->type() ) { + case QEvent::MouseMove: + if ( !d->mouseWasInsidePopup ) { + QPoint pos = e->pos(); + if ( d->listBox()->rect().contains( pos ) ) + d->mouseWasInsidePopup = true; + // Check if arrow button should toggle + if ( d->arrowPressed ) { + QPoint comboPos; + comboPos = mapFromGlobal( d->listBox()->mapToGlobal(pos) ); + QRect arrowRect = style()->subControlRect(QStyle::CC_ComboBox, &opt, + QStyle::SC_ComboBoxArrow, this); + if ( arrowRect.contains( comboPos ) ) { + if ( !d->arrowDown ) { + d->arrowDown = true; + repaint( false ); + } + } else { + if ( d->arrowDown ) { + d->arrowDown = false; + repaint( false ); + } + } + } + } else if ((e->state() & ( Qt::RightButton | Qt::LeftButton | Qt::MidButton ) ) == 0 && + style()->styleHint(QStyle::SH_ComboBox_ListMouseTracking, &opt, this)) { + QWidget *mouseW = QApplication::widgetAt( e->globalPos(), true ); + if ( mouseW == d->listBox()->viewport() ) { //### + QMouseEvent m( QEvent::MouseMove, e->pos(), e->globalPos(), + Qt::NoButton, Qt::LeftButton ); + QApplication::sendEvent( object, &m ); //### Evil + return true; + } + } + + break; + case QEvent::MouseButtonRelease: + if ( d->listBox()->rect().contains( e->pos() ) ) { + QMouseEvent tmp( QEvent::MouseButtonDblClick, + e->pos(), e->button(), e->state() ) ; + // will hide popup + QApplication::sendEvent( object, &tmp ); + return true; + } else { + if ( d->mouseWasInsidePopup ) { + popDownListBox(); + } else { + d->arrowPressed = false; + if ( d->arrowDown ) { + d->arrowDown = false; + repaint( false ); + } + } + } + break; + case QEvent::MouseButtonDblClick: + case QEvent::MouseButtonPress: + if ( !d->listBox()->rect().contains( e->pos() ) ) { + QPoint globalPos = d->listBox()->mapToGlobal(e->pos()); + if ( QApplication::widgetAt( globalPos, true ) == this ) { + d->discardNextMousePress = true; + // avoid popping up again + } + popDownListBox(); + return true; + } + break; + case QEvent::KeyPress: + switch( ((QKeyEvent *)event)->key() ) { + case Qt::Key_Up: + case Qt::Key_Down: + if ( !(((QKeyEvent *)event)->state() & Qt::AltModifier) ) + break; + case Qt::Key_F4: + case Qt::Key_Escape: + if ( d->poppedUp ) { + popDownListBox(); + return true; + } + break; + case Qt::Key_Enter: + case Qt::Key_Return: + // work around QDialog's enter handling + return false; + default: + break; + } + break; + case QEvent::Hide: + popDownListBox(); + break; + default: + break; + } + } else if ( (!d->usingListBox() || style()->styleHint(QStyle::SH_ComboBox_Popup, &opt, this)) && + object == d->popup() ) { + QMouseEvent *e = (QMouseEvent*)event; + switch ( event->type() ) { + case QEvent::MouseButtonRelease: + if ( d->shortClick ) { + QMouseEvent tmp( QEvent::MouseMove, + e->pos(), e->button(), e->state() ) ; + // highlight item, but don't pop down: + QApplication::sendEvent( object, &tmp ); + return true; + } + break; + case QEvent::MouseButtonDblClick: + case QEvent::MouseButtonPress: + if ( !d->popup()->rect().contains( e->pos() ) ) { + d->poppedUp = false; + d->arrowDown = false; + // remove filter, event will take down popup: + d->popup()->removeEventFilter( this ); + // ### uglehack! + // call internalHighlight so the highlighed signal + // will be emitted at least as often as necessary. + // it may be called more often than necessary + internalHighlight( d->current ); + } + break; + case QEvent::Hide: + d->poppedUp = false; + break; + default: + break; + } + } + return QWidget::eventFilter( object, event ); +} + + +/*! + Returns the index of the first item \e after \a startingAt of + which \a prefix is a case-insensitive prefix. Returns -1 if no + items start with \a prefix. +*/ + +int Q3ComboBox::completionIndex( const QString & prefix, + int startingAt = 0 ) const +{ + int start = startingAt; + if ( start < 0 || start >= count() ) + start = 0; + if ( start >= count() ) + return -1; + QString match = prefix.lower(); + if ( match.length() < 1 ) + return start; + + QString current; + int i = start; + do { + current = text( i ).lower(); + if ( current.startsWith( match ) ) + return i; + i++; + if ( i == count() ) + i = 0; + } while ( i != start ); + return -1; +} + +int Q3ComboBox::sizeLimit() const +{ + return d ? d->sizeLimit : INT_MAX; +} + +void Q3ComboBox::setSizeLimit( int lines ) +{ + d->sizeLimit = lines; +} + + +int Q3ComboBox::maxCount() const +{ + return d ? d->maxCount : INT_MAX; +} + +void Q3ComboBox::setMaxCount( int count ) +{ + int l = this->count(); + while( --l > count ) + removeItem( l ); + d->maxCount = count; +} + +Q3ComboBox::Policy Q3ComboBox::insertionPolicy() const +{ + return d->p; +} + +void Q3ComboBox::setInsertionPolicy( Policy policy ) +{ + d->p = policy; +} + + + +/*! + Internal slot to keep the line editor up to date. +*/ + +void Q3ComboBox::returnPressed() +{ + QString s( d->ed->text() ); + + if ( s.isEmpty() ) + return; + + int c = 0; + bool doInsert = true; + if ( !d->duplicatesEnabled ) { + for ( int i = 0; i < count(); ++i ) { + if ( s == text( i ) ) { + doInsert = false; + c = i; + break; + } + } + } + + if ( doInsert ) { + if ( insertionPolicy() != NoInsert ) { + int cnt = count(); + while ( cnt >= d->maxCount ) { + removeItem( --cnt ); + } + } + + switch ( insertionPolicy() ) { + case InsertAtCurrent: + if (count() == 0) + insertItem(s); + else if ( s != text( currentItem() ) ) + changeItem( s, currentItem() ); + emit activated( currentItem() ); + emit activated( s ); + return; + case NoInsert: + emit activated( s ); + return; + case InsertAtTop: + c = 0; + break; + case InsertAtBottom: + c = count(); + break; + case InsertBeforeCurrent: + c = currentItem(); + break; + case InsertAfterCurrent: + c = count() == 0 ? 0 : currentItem() + 1; + break; + } + insertItem( s, c ); + } + + setCurrentItem( c ); + emit activated( c ); + emit activated( s ); +} + + +/*! + Enables the combobox if \a enable is true; otherwise disables it. + + \sa QWidget::enabled +*/ + +void Q3ComboBox::setEnabled( bool enable ) +{ + if ( !enable ) { + if ( d->usingListBox() ) { + popDownListBox(); + } else { + d->popup()->removeEventFilter( this ); + d->popup()->close(); + d->poppedUp = false; + } + } + QWidget::setEnabled( enable ); +} + + + +/*! + Applies the validator \a v to the combobox so that only text which + is valid according to \a v is accepted. + + This function does nothing if the combobox is not editable. + + \sa validator() clearValidator() QValidator +*/ + +void Q3ComboBox::setValidator( const QValidator * v ) +{ + if ( d && d->ed ) + d->ed->setValidator( v ); +} + + +/*! + Returns the validator which constrains editing for this combobox + if there is one; otherwise returns 0. + + \sa setValidator() clearValidator() QValidator +*/ + +const QValidator * Q3ComboBox::validator() const +{ + return d && d->ed ? d->ed->validator() : 0; +} + + +/*! + This slot is equivalent to setValidator( 0 ). +*/ + +void Q3ComboBox::clearValidator() +{ + if ( d && d->ed ) + d->ed->setValidator( 0 ); +} + + +/*! + Sets the combobox to use \a newListBox instead of the current list + box or popup. As a side effect, it clears the combobox of its + current contents. + + \warning Q3ComboBox assumes that newListBox->text(n) returns + non-null for 0 \<= n \< newListbox->count(). This assumption is + necessary because of the line edit in Q3ComboBox. +*/ + +void Q3ComboBox::setListBox( Q3ListBox * newListBox ) +{ + clear(); + + if ( d->usingListBox() ) { + delete d->listBox(); + } else { + delete d->popup(); + d->setPopupMenu(0, false); + } + + newListBox->reparent( this, Qt::WType_Popup, QPoint(0,0), false ); + d->setListBox( newListBox ); + d->listBox()->setFont( font() ); + d->listBox()->setPalette( palette() ); + d->listBox()->setVScrollBarMode(Q3ScrollView::AlwaysOff); + d->listBox()->setHScrollBarMode(Q3ScrollView::AlwaysOff); + d->listBox()->setFrameStyle( Q3Frame::Box | Q3Frame::Plain ); + d->listBox()->setLineWidth( 1 ); + d->listBox()->resize( 100, 10 ); + + connect( d->listBox(), SIGNAL(selected(int)), + SLOT(internalActivate(int)) ); + connect( d->listBox(), SIGNAL(highlighted(int)), + SLOT(internalHighlight(int))); +} + + +/*! + Returns the current list box, or 0 if there is no list box. + (Q3ComboBox can use QPopupMenu instead of QListBox.) Provided to + match setListBox(). + + \sa setListBox() +*/ + +Q3ListBox * Q3ComboBox::listBox() const +{ + return d && d->usingListBox() ? d->listBox() : 0; +} + +/*! + Returns the line edit, or 0 if there is no line edit. + + Only editable listboxes have a line editor. +*/ +QLineEdit* Q3ComboBox::lineEdit() const +{ + return d->ed; +} + + + +/*! + Clears the line edit without changing the combobox's contents. + Does nothing if the combobox isn't editable. + + This is particularly useful when using a combobox as a line edit + with history. For example you can connect the combobox's + activated() signal to clearEdit() in order to present the user + with a new, empty line as soon as Enter is pressed. + + \sa setEditText() +*/ + +void Q3ComboBox::clearEdit() +{ + if ( d && d->ed ) + d->ed->clear(); +} + + +/*! + Sets the text in the line edit to \a newText without changing the + combobox's contents. Does nothing if the combobox isn't editable. + + This is useful e.g. for providing a good starting point for the + user's editing and entering the change in the combobox only when + the user presses Enter. + + \sa clearEdit() insertItem() +*/ + +void Q3ComboBox::setEditText( const QString &newText ) +{ + if ( d && d->ed ) { + d->updateLinedGeometry(); + d->ed->setText( newText ); + } +} + +void Q3ComboBox::setAutoCompletion( bool enable ) +{ + d->useCompletion = enable; + d->completeNow = false; +} + + +bool Q3ComboBox::autoCompletion() const +{ + return d->useCompletion; +} + +/*! + \internal + */ +void Q3ComboBox::styleChange( QStyle& s ) +{ + d->sizeHint = QSize(); // invalidate size hint... + if ( d->ed ) + d->updateLinedGeometry(); + QWidget::styleChange( s ); +} + +bool Q3ComboBox::editable() const +{ + return d->ed != 0; +} + +void Q3ComboBox::setEditable( bool y ) +{ + if ( y == editable() ) + return; + if ( y ) { + if ( !d->usingListBox() ) + setUpListBox(); + setUpLineEdit(); + d->ed->show(); + if ( currentItem() ) + setEditText( currentText() ); + } else { + delete d->ed; + d->ed = 0; + } + + setFocusPolicy(Qt::StrongFocus); + updateGeometry(); + update(); +} + + +void Q3ComboBox::setUpListBox() +{ + d->setListBox( new Q3ListBox( this, "in-combo", Qt::WType_Popup ) ); + d->listBox()->setFont( font() ); + d->listBox()->setPalette( palette() ); + d->listBox()->setVScrollBarMode( Q3ListBox::AlwaysOff ); + d->listBox()->setHScrollBarMode( Q3ListBox::AlwaysOff ); + d->listBox()->setFrameStyle( Q3Frame::Box | Q3Frame::Plain ); + d->listBox()->setLineWidth( 1 ); + d->listBox()->resize( 100, 10 ); + + connect( d->listBox(), SIGNAL(selected(int)), + SLOT(internalActivate(int)) ); + connect( d->listBox(), SIGNAL(highlighted(int)), + SLOT(internalHighlight(int))); +} + + +void Q3ComboBox::setUpLineEdit() +{ + if ( !d->ed ) + setLineEdit( new QLineEdit( this, "combo edit" ) ); +} + +/*! + Sets the line edit to use \a edit instead of the current line edit. +*/ + +void Q3ComboBox::setLineEdit( QLineEdit *edit ) +{ + if ( !edit ) { +#if defined(QT_CHECK_NULL) + Q_ASSERT( edit != 0 ); +#endif + return; + } + + edit->setText( currentText() ); + delete d->ed; + d->ed = edit; + + if ( edit->parent() != this ) + edit->reparent( this, QPoint(0,0), false ); + + connect (edit, SIGNAL(textChanged(QString)), + this, SIGNAL(textChanged(QString)) ); + connect( edit, SIGNAL(returnPressed()), SLOT(returnPressed()) ); + + edit->setFrame( false ); + d->updateLinedGeometry(); + edit->installEventFilter( this ); + setFocusProxy( edit ); + setFocusPolicy(Qt::StrongFocus); + setInputMethodEnabled( true ); + + if ( !d->usingListBox() ) + setUpListBox(); + + if ( isVisible() ) + edit->show(); + + updateGeometry(); + update(); +} + +/*! + Hides the combobox. + + \sa QWidget::hide() +*/ +void Q3ComboBox::hide() +{ + QWidget::hide(); + + if (listBox()) + listBox()->hide(); + else if (d->popup()) + d->popup()->hide(); +} + +QT_END_NAMESPACE + +#endif // QT_NO_COMBOBOX diff --git a/src/qt3support/widgets/q3combobox.h b/src/qt3support/widgets/q3combobox.h new file mode 100644 index 0000000..813831e --- /dev/null +++ b/src/qt3support/widgets/q3combobox.h @@ -0,0 +1,224 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the Qt3Support module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, 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 qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef Q3COMBOBOX_H +#define Q3COMBOBOX_H + +#include <QtGui/qwidget.h> + +QT_BEGIN_HEADER + +QT_BEGIN_NAMESPACE + +QT_MODULE(Qt3SupportLight) + +#ifndef QT_NO_COMBOBOX + +class Q3StrList; +class QStringList; +class QLineEdit; +class QValidator; +class Q3ListBox; +class Q3ComboBoxData; +class QWheelEvent; + +class Q_COMPAT_EXPORT Q3ComboBox : public QWidget +{ + Q_OBJECT + Q_ENUMS( Policy ) + Q_PROPERTY( bool editable READ editable WRITE setEditable ) + Q_PROPERTY( int count READ count ) + Q_PROPERTY( QString currentText READ currentText WRITE setCurrentText DESIGNABLE false ) + Q_PROPERTY( int currentItem READ currentItem WRITE setCurrentItem ) + Q_PROPERTY( bool autoResize READ autoResize WRITE setAutoResize DESIGNABLE false ) + Q_PROPERTY( int sizeLimit READ sizeLimit WRITE setSizeLimit ) + Q_PROPERTY( int maxCount READ maxCount WRITE setMaxCount ) + Q_PROPERTY( Policy insertionPolicy READ insertionPolicy WRITE setInsertionPolicy ) + Q_PROPERTY( bool autoCompletion READ autoCompletion WRITE setAutoCompletion ) + Q_PROPERTY( bool duplicatesEnabled READ duplicatesEnabled WRITE setDuplicatesEnabled ) + +public: + Q3ComboBox( QWidget* parent=0, const char* name=0 ); + Q3ComboBox( bool rw, QWidget* parent=0, const char* name=0 ); + ~Q3ComboBox(); + + int count() const; + + void insertStringList( const QStringList &, int index=-1 ); + void insertStrList( const Q3StrList &, int index=-1 ); + void insertStrList( const Q3StrList *, int index=-1 ); + void insertStrList( const char **, int numStrings=-1, int index=-1); + + void insertItem( const QString &text, int index=-1 ); + void insertItem( const QPixmap &pixmap, int index=-1 ); + void insertItem( const QPixmap &pixmap, const QString &text, int index=-1 ); + + void removeItem( int index ); + + int currentItem() const; + virtual void setCurrentItem( int index ); + + QString currentText() const; + virtual void setCurrentText( const QString& ); + + QString text( int index ) const; + const QPixmap *pixmap( int index ) const; + + void changeItem( const QString &text, int index ); + void changeItem( const QPixmap &pixmap, int index ); + void changeItem( const QPixmap &pixmap, const QString &text, int index ); + + bool autoResize() const; + virtual void setAutoResize( bool ); + QSize sizeHint() const; + + void setPalette( const QPalette & ); + void setFont( const QFont & ); + void setEnabled( bool ); + + virtual void setSizeLimit( int ); + int sizeLimit() const; + + virtual void setMaxCount( int ); + int maxCount() const; + + enum Policy { NoInsertion, + AtTop, + AtCurrent, + AtBottom, + AfterCurrent, + BeforeCurrent, + NoInsert = NoInsertion, + InsertAtTop = AtTop, + InsertAtCurrent = AtCurrent, + InsertAtBottom = AtBottom, + InsertAfterCurrent = AfterCurrent, + InsertBeforeCurrent = BeforeCurrent + }; + + virtual void setInsertionPolicy( Policy policy ); + Policy insertionPolicy() const; + + virtual void setValidator( const QValidator * ); + const QValidator * validator() const; + + virtual void setListBox( Q3ListBox * ); + Q3ListBox * listBox() const; + + virtual void setLineEdit( QLineEdit *edit ); + QLineEdit* lineEdit() const; + + virtual void setAutoCompletion( bool ); + bool autoCompletion() const; + + bool eventFilter( QObject *object, QEvent *event ); + + void setDuplicatesEnabled( bool enable ); + bool duplicatesEnabled() const; + + bool editable() const; + void setEditable( bool ); + + virtual void popup(); + + void hide(); + +public Q_SLOTS: + void clear(); + void clearValidator(); + void clearEdit(); + virtual void setEditText( const QString &); + +Q_SIGNALS: + void activated( int index ); + void highlighted( int index ); + void activated( const QString &); + void highlighted( const QString &); + void textChanged( const QString &); + +private Q_SLOTS: + void internalActivate( int ); + void internalHighlight( int ); + void internalClickTimeout(); + void returnPressed(); + +protected: + void paintEvent( QPaintEvent * ); + void resizeEvent( QResizeEvent * ); + void mousePressEvent( QMouseEvent * ); + void mouseMoveEvent( QMouseEvent * ); + void mouseReleaseEvent( QMouseEvent * ); + void mouseDoubleClickEvent( QMouseEvent * ); + void keyPressEvent( QKeyEvent *e ); + void focusInEvent( QFocusEvent *e ); + void focusOutEvent( QFocusEvent *e ); +#ifndef QT_NO_WHEELEVENT + void wheelEvent( QWheelEvent *e ); +#endif + void styleChange( QStyle& ); + + void updateMask(); + +private: + void setUpListBox(); + void setUpLineEdit(); + void popDownListBox(); + void reIndex(); + void currentChanged(); + int completionIndex( const QString &, int ) const; + + Q3ComboBoxData *d; + +private: // Disabled copy constructor and operator= +#if defined(Q_DISABLE_COPY) + Q3ComboBox( const Q3ComboBox & ); + Q3ComboBox &operator=( const Q3ComboBox & ); +#endif +}; + + +#endif // QT_NO_COMBOBOX + +QT_END_NAMESPACE + +QT_END_HEADER + +#endif // Q3COMBOBOX_H diff --git a/src/qt3support/widgets/q3datetimeedit.cpp b/src/qt3support/widgets/q3datetimeedit.cpp new file mode 100644 index 0000000..6d35523 --- /dev/null +++ b/src/qt3support/widgets/q3datetimeedit.cpp @@ -0,0 +1,2807 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the Qt3Support module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, 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 qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "q3datetimeedit.h" + +#ifndef QT_NO_DATETIMEEDIT + +#include <private/q3richtext_p.h> +#include "qevent.h" +#include "q3rangecontrol.h" +#include "qapplication.h" +#include "qpixmap.h" +#include "qlist.h" +#include "qstring.h" +#include "qstyle.h" + +#if defined(Q_WS_WIN) +#include "qt_windows.h" +#endif + +QT_BEGIN_NAMESPACE + +#define QDATETIMEEDIT_HIDDEN_CHAR QLatin1Char('0') + +class Q_COMPAT_EXPORT QNumberSection +{ +public: + QNumberSection(int selStart = 0, int selEnd = 0, bool separat = true, int actual = -1) + : selstart(selStart), selend(selEnd), act(actual), sep(separat) + {} + int selectionStart() const { return selstart; } + void setSelectionStart(int s) { selstart = s; } + int selectionEnd() const { return selend; } + void setSelectionEnd(int s) { selend = s; } + int width() const { return selend - selstart; } + int index() const { return act; } + bool separator() const { return sep; } + Q_DUMMY_COMPARISON_OPERATOR(QNumberSection) +private: + signed int selstart :12; + signed int selend :12; + signed int act :7; + bool sep :1; +}; + +static QString *lDateSep = 0; +static QString *lTimeSep = 0; +static bool lAMPM = false; +static QString *lAM = 0; +static QString *lPM = 0; +static Q3DateEdit::Order lOrder = Q3DateEdit::YMD; +static int refcount = 0; + +static void cleanup() +{ + delete lDateSep; + lDateSep = 0; + delete lTimeSep; + lTimeSep = 0; + delete lAM; + lAM = 0; + delete lPM; + lPM = 0; +} + +/*! +\internal +try to get the order of DMY and the date/time separator from the locale settings +*/ +static void readLocaleSettings() +{ + int dpos, mpos, ypos; + cleanup(); + + lDateSep = new QString(); + lTimeSep = new QString(); + +#if defined(Q_WS_WIN) + wchar_t data[10]; + GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_SDATE, data, 10); + *lDateSep = QString::fromWCharArray(data); + GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_STIME, data, 10); + *lTimeSep = QString::fromWCharArray(data); + GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_ITIME, data, 10); + lAMPM = QString::fromWCharArray(data).toInt() == 0; + GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_S1159, data, 10); + QString am = QString::fromWCharArray(data); + if (!am.isEmpty()) + lAM = new QString(am); + GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_S2359, data, 10); + QString pm = QString::fromWCharArray(data); + if (!pm.isEmpty() ) + lPM = new QString(pm); +#else + *lDateSep = QLatin1Char('-'); + *lTimeSep = QLatin1Char(':'); +#endif + QString d = QDate(1999, 11, 22).toString(Qt::LocalDate); + dpos = d.indexOf(QLatin1String("22")); + mpos = d.indexOf(QLatin1String("11")); + ypos = d.indexOf(QLatin1String("99")); + if (dpos > -1 && mpos > -1 && ypos > -1) { + // test for DMY, MDY, YMD, YDM + if (dpos < mpos && mpos < ypos) { + lOrder = Q3DateEdit::DMY; + } else if (mpos < dpos && dpos < ypos) { + lOrder = Q3DateEdit::MDY; + } else if (ypos < mpos && mpos < dpos) { + lOrder = Q3DateEdit::YMD; + } else if (ypos < dpos && dpos < mpos) { + lOrder = Q3DateEdit::YDM; + } else { + // cannot determine the dateformat - use the default + return; + } + + // this code needs to change if new formats are added + +#ifndef Q_WS_WIN + QString sep = d.mid(qMin(dpos, mpos) + 2, QABS(dpos - mpos) - 2); + if (d.count(sep) == 2) { + *lDateSep = sep; + } +#endif + } + +#ifndef Q_WS_WIN + QString t = QTime(11, 22, 33).toString(Qt::LocalDate); + dpos = t.indexOf(QLatin1String("11")); + mpos = t.indexOf(QLatin1String("22")); + ypos = t.indexOf(QLatin1String("33")); + // We only allow hhmmss + if (dpos > -1 && dpos < mpos && mpos < ypos) { + QString sep = t.mid(dpos + 2, mpos - dpos - 2); + if (sep == t.mid(mpos + 2, ypos - mpos - 2)) { + *lTimeSep = sep; + } + } +#endif +} + +static Q3DateEdit::Order localOrder() { + if (!lDateSep) { + readLocaleSettings(); + } + return lOrder; +} + +static QString localDateSep() { + if (!lDateSep) { + readLocaleSettings(); + } + return *lDateSep; +} + +static QString localTimeSep() { + if (!lTimeSep) { + readLocaleSettings(); + } + return *lTimeSep; +} + +class Q3DateTimeEditorPrivate +{ +public: + Q3DateTimeEditorPrivate() + : frm(true), + parag(new Q3TextParagraph(0, 0, 0, false)), + focusSec(0) + { + parag->formatter()->setWrapEnabled(false); + cursor = new Q3TextCursor(0); + cursor->setParagraph(parag); + offset = 0; + sep = localDateSep(); + refcount++; + } + ~Q3DateTimeEditorPrivate() + { + delete parag; + delete cursor; + if (!--refcount) + cleanup(); + } + + void appendSection(const QNumberSection& sec) + { + sections.append(sec); + + } + void clearSections() + { + sections.clear(); + } + void setSectionSelection(int sec, int selstart, int selend) + { + if (sec < 0 || sec >= sections.count()) + return; + sections[sec].setSelectionStart(selstart); + sections[sec].setSelectionEnd(selend); + } + uint sectionCount() const { return (uint)sections.count(); } + void setSeparator(const QString& s) { sep = s; } + QString separator() const { return sep; } + + void setFrame(bool f) { frm = f; } + bool frame() const { return frm; } + + int focusSection() const { return focusSec; } + int section(const QPoint& p) + { + cursor->place(p + QPoint(offset, 0), parag); + int idx = cursor->index(); + for (int i = 0; i < sections.count(); ++i) { + if (idx >= sections[i].selectionStart() && + idx <= sections[i].selectionEnd()) + return i; + } + return -1; + } + QNumberSection section(int idx) const + { + return sections[idx]; + } + bool setFocusSection(int idx) + { + if (idx > (int)sections.count()-1 || idx < 0) + return false; + if (idx != focusSec) { + focusSec = idx; + applyFocusSelection(); + return true; + } + return false; + } + + bool inSectionSelection(int idx) + { + for (int i = 0; i < sections.count(); ++i) { + if (idx >= sections[i].selectionStart() && + idx <= sections[i].selectionEnd()) + return true; + } + return false; + } + + void paint(const QString& txt, bool focus, QPainter& p, + const QPalette&pal, const QRect& rect, QStyle *style) + { + int fw = 0; + if (frm) + fw = style->pixelMetric(QStyle::PM_DefaultFrameWidth); + + parag->truncate(0); + parag->append(txt); + if (!focus) + parag->removeSelection(Q3TextDocument::Standard); + else { + applyFocusSelection(); + } + + /* color all QDATETIMEEDIT_HIDDEN_CHAR chars to background color */ + Q3TextFormat *fb = parag->formatCollection()->format(p.font(), + pal.base().color()); + Q3TextFormat *nf = parag->formatCollection()->format(p.font(), + pal.text().color()); + for (int i = 0; i < txt.length(); ++i) { + parag->setFormat(i, 1, nf); + if (inSectionSelection(i)) + continue; + if (txt.at(i) == QDATETIMEEDIT_HIDDEN_CHAR) + parag->setFormat(i, 1, fb); + else + parag->setFormat(i, 1, nf); + } + fb->removeRef(); + nf->removeRef(); + + QRect r(rect.x(), rect.y(), rect.width() - 2 * (2 + fw), rect.height()); + parag->pseudoDocument()->docRect = r; + parag->invalidate(0); + parag->format(); + + int xoff = 2 + fw - offset; + int yoff = (rect.height() - parag->rect().height() + 1) / 2; + if (yoff < 0) + yoff = 0; + + p.translate(xoff, yoff); + parag->paint(p, pal, 0, true); + if (frm) + p.translate(-xoff, -yoff); + } + + void resize(const QSize& size) { sz = size; } + + int mapSection(int sec) + { + return (sec >= 0 && sec < sections.count() ? sections[sec].index() : -1); + } + +protected: + void applyFocusSelection() + { + if (focusSec > -1 && focusSec < sections.count()) { + int selstart = sections[focusSec].selectionStart(); + int selend = sections[focusSec].selectionEnd(); + parag->setSelection(Q3TextDocument::Standard, selstart, selend); + parag->format(); + if (parag->at(selstart)->x < offset || + parag->at(selend)->x + parag->string()->width(selend) > offset + sz.width()) { + offset = parag->at(selstart)->x; + } + } + } +private: + bool frm; + Q3TextParagraph *parag; + Q3TextCursor *cursor; + QSize sz; + int focusSec; + QList< QNumberSection > sections; + QString sep; + int offset; +}; + +class Q3DateTimeEditor : public QWidget +{ + Q_OBJECT +public: + Q3DateTimeEditor(Q3DateTimeEditBase *widget, QWidget *parent, const char* name=0); + ~Q3DateTimeEditor(); + + void setControlWidget(Q3DateTimeEditBase * widget); + Q3DateTimeEditBase * controlWidget() const; + + void setSeparator(const QString& s); + QString separator() const; + + int focusSection() const; + bool setFocusSection(int s); + void appendSection(const QNumberSection& sec); + void clearSections(); + void setSectionSelection(int sec, int selstart, int selend); + bool eventFilter(QObject *o, QEvent *e); + int sectionAt(const QPoint &p); + int mapSection(int sec); + +protected: + void init(); + bool event(QEvent *e); + void resizeEvent(QResizeEvent *); + void paintEvent(QPaintEvent *); + void mousePressEvent(QMouseEvent *e); + +private: + Q3DateTimeEditBase* cw; + Q3DateTimeEditorPrivate* d; +}; + +class QDateTimeSpinWidget : public Q3SpinWidget +{ + Q_OBJECT +public: + QDateTimeSpinWidget(QWidget *parent, const char *name) + : Q3SpinWidget(parent, name) + { + } + + void changeEvent(QEvent *e) + { + if (e->type() == QEvent::EnabledChange && isEnabled()) { + Q3DateEdit *de = qobject_cast<Q3DateEdit*>(parentWidget()); + if (de) { + setUpEnabled(de->date() < de->maxValue()); + setDownEnabled(de->date() > de->minValue()); + } else { + setUpEnabled(true); + setDownEnabled(true); + } + } + } + void enabledChange(bool notenabled) + { + Q3DateEdit *de = qobject_cast<Q3DateEdit*>(parentWidget()); + if (de && !notenabled) { + setUpEnabled(de->date() < de->maxValue()); + setDownEnabled(de->date() > de->minValue()); + } else { + setUpEnabled(!notenabled); + setDownEnabled(!notenabled); + } + } + + +protected: +#ifndef QT_NO_WHEELEVENT + void wheelEvent(QWheelEvent *e) + { + Q3DateTimeEditor *editor = qobject_cast<Q3DateTimeEditor*>(editWidget()); + Q_ASSERT(editor); + if (!editor) + return; + + int section = editor->sectionAt(e->pos()); + editor->setFocusSection(section); + + if (section == -1) + return; + Q3SpinWidget::wheelEvent(e); + } +#endif +}; + +/*! + Constructs an empty datetime editor with parent \a parent and + called \a name. +*/ +Q3DateTimeEditor::Q3DateTimeEditor(Q3DateTimeEditBase *widget, QWidget *parent, const char * name) + : QWidget(parent, name) +{ + d = new Q3DateTimeEditorPrivate(); + cw = widget; + init(); +} + +/*! + Destroys the object and frees any allocated resources. +*/ + +Q3DateTimeEditor::~Q3DateTimeEditor() +{ + delete d; +} + +/*! \internal + +*/ + +void Q3DateTimeEditor::init() +{ + setBackgroundRole(QPalette::Base); + setFocusSection(-1); + installEventFilter(this); + setFocusPolicy(Qt::WheelFocus); +} + + +/*! \reimp + +*/ + +bool Q3DateTimeEditor::event(QEvent *e) +{ + if (e->type() == QEvent::FocusIn || e->type() == QEvent::FocusOut) { + if (e->type() == QEvent::FocusOut) + qApp->sendEvent(cw, e); + update(rect()); + } else if (e->type() == QEvent::ShortcutOverride) { + QKeyEvent* ke = (QKeyEvent*) e; + switch (ke->key()) { + case Qt::Key_Delete: + case Qt::Key_Backspace: + case Qt::Key_Up: + case Qt::Key_Down: + case Qt::Key_Left: + case Qt::Key_Right: + ke->accept(); + default: + break; + } + } + return QWidget::event(e); +} + +/*! \reimp + +*/ + +void Q3DateTimeEditor::resizeEvent(QResizeEvent *e) +{ + d->resize(e->size()); + QWidget::resizeEvent(e); +} + + +/*! \reimp + +*/ + +void Q3DateTimeEditor::paintEvent(QPaintEvent *) +{ + QString txt; + for (uint i = 0; i < d->sectionCount(); ++i) { + txt += cw->sectionFormattedText(i); + if (i < d->sectionCount()-1) { + if (d->section(i+1).separator()) + txt += d->separator(); + else + txt += QLatin1Char(' '); + } + } + + QPainter p(this); + const QBrush &bg = palette().brush(isEnabled() ? QPalette::Base : QPalette::Window); + p.fillRect(0, 0, width(), height(), bg); + d->paint(txt, hasFocus(), p, palette(), rect(), style()); +} + + +/*! + Returns the section index at point \a p. +*/ +int Q3DateTimeEditor::sectionAt(const QPoint &p) +{ + return d->section(p); +} + +int Q3DateTimeEditor::mapSection(int sec) +{ + return d->mapSection(sec); +} + + +/*! \reimp + +*/ + +void Q3DateTimeEditor::mousePressEvent(QMouseEvent *e) +{ + QPoint p(e->pos().x(), 0); + int sec = sectionAt(p); + if (sec != -1) { + cw->setFocusSection(sec); + repaint(rect()); + } +} + +/*! \reimp + +*/ +bool Q3DateTimeEditor::eventFilter(QObject *o, QEvent *e) +{ + if (o == this) { + if (e->type() == QEvent::KeyPress) { + QKeyEvent *ke = (QKeyEvent*)e; + switch (ke->key()) { + case Qt::Key_Right: + if (d->focusSection() < (int)d->sectionCount()-1) { + if (cw->setFocusSection(focusSection()+1)) + repaint(rect()); + } + return true; + case Qt::Key_Left: + if (d->focusSection() > 0) { + if (cw->setFocusSection(focusSection()-1)) + repaint(rect()); + } + return true; + case Qt::Key_Up: + cw->stepUp(); + return true; + case Qt::Key_Down: + cw->stepDown(); + return true; + case Qt::Key_Backspace: + if (qobject_cast<Q3DateEdit*>(cw)) + ((Q3DateEdit*)cw)->removeFirstNumber(d->focusSection()); + else if (qobject_cast<Q3TimeEdit*>(cw)) + ((Q3TimeEdit*)cw)->removeFirstNumber(d->focusSection()); + return true; + case Qt::Key_Delete: + cw->removeLastNumber(d->focusSection()); + return true; + case Qt::Key_Tab: + case Qt::Key_BackTab: { + if (ke->state() == Qt::ControlButton) + return false; + QWidget *w = this; + bool hadDateEdit = false; + while (w) { + if (qobject_cast<QDateTimeSpinWidget*>(w) || qobject_cast<Q3DateTimeEdit*>(w)) + break; + hadDateEdit = hadDateEdit || qobject_cast<Q3DateEdit*>(w); + w = w->parentWidget(); + } + if (w) { + if (!qobject_cast<Q3DateTimeEdit*>(w)) { + w = w->parentWidget(); + } else { + Q3DateTimeEdit *ed = (Q3DateTimeEdit*)w; + if (hadDateEdit && ke->key() == Qt::Key_Tab) { + ed->timeEdit()->setFocus(); + return true; + } else if (!hadDateEdit && ke->key() == Qt::Key_BackTab) { + ed->dateEdit()->setFocus(); + return true; + } else { + while (w && !qobject_cast<Q3DateTimeEdit*>(w)) + w = w->parentWidget(); + } + } + qApp->sendEvent(w, e); + return true; + } + } break; + default: + QString txt = ke->text().toLower(); + if (!txt.isEmpty() && !separator().isEmpty() && txt[0] == separator()[0]) { + // do the same thing as KEY_RIGHT when the user presses the separator key + if (d->focusSection() < 2) { + if (cw->setFocusSection(focusSection()+1)) + repaint(rect()); + } + return true; + } else if (!txt.isEmpty() && qobject_cast<Q3TimeEdit*>(cw) && focusSection() == (int) d->sectionCount()-1) { + // the first character of the AM/PM indicator toggles if the section has focus + Q3TimeEdit *te = (Q3TimeEdit*)cw; + QTime time = te->time(); + if (lAMPM && lAM && lPM && (te->display()&Q3TimeEdit::AMPM)) { + if (txt[0] == (*lAM).toLower()[0] && time.hour() >= 12) { + time.setHMS(time.hour()-12, time.minute(), time.second(), time.msec()); + te->setTime(time); + } else if (txt[0] == (*lPM).toLower()[0] && time.hour() < 12) { + time.setHMS(time.hour()+12, time.minute(), time.second(), time.msec()); + te->setTime(time); + } + } + } + + int num = txt[0].digitValue(); + if (num != -1) { + cw->addNumber(d->focusSection(), num); + return true; + } + } + } + } + return false; +} + + +/*! + Appends the number section \a sec to the editor. +*/ + +void Q3DateTimeEditor::appendSection(const QNumberSection& sec) +{ + d->appendSection(sec); +} + +/*! + Removes all sections from the editor. +*/ + +void Q3DateTimeEditor::clearSections() +{ + d->clearSections(); +} + +/*! + Sets the selection of \a sec to start at \a selstart and end at \a + selend. +*/ + +void Q3DateTimeEditor::setSectionSelection(int sec, int selstart, int selend) +{ + d->setSectionSelection(sec, selstart, selend); +} + +/*! + Sets the separator for all numbered sections to \a s. Note that + currently, only the first character of \a s is used. +*/ + +void Q3DateTimeEditor::setSeparator(const QString& s) +{ + d->setSeparator(s); + update(); +} + + +/*! + Returns the editor's separator. +*/ + +QString Q3DateTimeEditor::separator() const +{ + return d->separator(); +} + +/*! + Returns the number of the section that has focus. +*/ + +int Q3DateTimeEditor::focusSection() const +{ + return d->focusSection(); +} + + +/*! + Sets the focus to section \a sec. If \a sec does not exist, + nothing happens. +*/ + +bool Q3DateTimeEditor::setFocusSection(int sec) +{ + return d->setFocusSection(sec); +} + +/*! + \class Q3DateTimeEditBase + \brief The Q3DateTimeEditBase class provides an abstraction for date and edit editors. + + \compat + + Small abstract class that provides some functions that are common + for both Q3DateEdit and Q3TimeEdit. It is used internally by + Q3DateTimeEditor. +*/ + +/*! + \fn Q3DateTimeEditBase::Q3DateTimeEditBase(QWidget *, const char*) + \internal +*/ + +/*! + \fn Q3DateTimeEditBase::setFocusSection(int) + \internal +*/ + +/*! \fn QString Q3DateTimeEditBase::sectionFormattedText(int sec) + \internal + + Pure virtual function which returns the formatted text of section \a + sec. + +*/ + +/*! \fn void Q3DateTimeEditBase::stepUp() + \internal + + Pure virtual slot which is called whenever the user increases the + number in a section by pressing the widget's arrow buttons or the + keyboard's arrow keys. +*/ + +/*! \fn void Q3DateTimeEditBase::stepDown() + \internal + + Pure virtual slot which is called whenever the user decreases the + number in a section by pressing the widget's arrow buttons or the + keyboard's arrow keys. + +*/ + +/*! \fn void Q3DateTimeEditBase::addNumber(int sec, int num) + \internal + + Pure virtual function which is called whenever the user types a number. + \a sec indicates the section where the number should be added. \a + num is the number that was pressed. +*/ + +/*! \fn void Q3DateTimeEditBase::removeLastNumber(int sec) + \internal + + Pure virtual function which is called whenever the user tries to + remove the last number from \a sec by pressing the delete key. +*/ + +//////////////// + +class Q3DateEditPrivate +{ +public: + int y; + int m; + int d; + // remembers the last entry for the day. + // if the day is 31 and you cycle through the months, + // the day will be 31 again if you reach a month with 31 days + // otherwise it will be the highest day in the month + int dayCache; + int yearSection; + int monthSection; + int daySection; + Q3DateEdit::Order ord; + bool overwrite; + bool adv; + int timerId; + bool typing; + QDate min; + QDate max; + bool changed; + Q3DateTimeEditor *ed; + Q3SpinWidget *controls; +}; + + +/*! + \class Q3DateEdit + \brief The Q3DateEdit class provides a date editor. + + \compat + + Q3DateEdit allows the user to edit dates by using the keyboard or + the arrow keys to increase/decrease date values. The arrow keys + can be used to move from section to section within the Q3DateEdit + box. Dates appear in accordance with the local date/time settings + or in year, month, day order if the system doesn't provide this + information. It is recommended that the Q3DateEdit be initialised + with a date, e.g. + + \snippet doc/src/snippets/code/src_qt3support_widgets_q3datetimeedit.cpp 0 + + Here we've created a new Q3DateEdit object initialised with today's + date and restricted the valid date range to today plus or minus + 365 days. We've set the order to month, day, year. If the auto + advance property is true (as we've set it here) when the user + completes a section of the date, e.g. enters two digits for the + month, they are automatically taken to the next section. + + The maximum and minimum values for a date value in the date editor + default to the maximum and minimum values for a QDate. You can + change this by calling setMinValue(), setMaxValue() or setRange(). + + Terminology: A Q3DateEdit widget comprises three 'sections', one + each for the year, month and day. You can change the separator + character using Q3DateTimeEditor::setSeparator(), by default the + separator will be taken from the systems settings. If that is + not possible, it defaults to "-". + + \img datetimewidgets.png Date Time Widgets + + \sa QDate Q3TimeEdit Q3DateTimeEdit +*/ + +/*! + \enum Q3DateEdit::Order + + This enum defines the order in which the sections that comprise a + date appear. + + \value MDY month-day-year + \value DMY day-month-year + \value YMD year-month-day (the default) + \omitvalue YDM +*/ + +/*! + \enum Q3TimeEdit::Display + + This enum defines the sections that comprise a time + + \value Hours The hours section + \value Minutes The minutes section + \value Seconds The seconds section + \value AMPM The AM/PM section + + The values can be or'ed together to show any combination. +*/ + +/*! + Constructs an empty date editor which is a child of \a parent and + called name \a name. +*/ + +Q3DateEdit::Q3DateEdit(QWidget * parent, const char * name) + : Q3DateTimeEditBase(parent, name) +{ + init(); + updateButtons(); +} + +/*! + \overload + + Constructs a date editor with the initial value \a date, parent \a + parent and called \a name. + + The date editor is initialized with \a date. +*/ + +Q3DateEdit::Q3DateEdit(const QDate& date, QWidget * parent, const char * name) + : Q3DateTimeEditBase(parent, name) +{ + init(); + setDate(date); +} + +/*! \internal +*/ +void Q3DateEdit::init() +{ + d = new Q3DateEditPrivate(); + d->controls = new QDateTimeSpinWidget(this, 0); + d->ed = new Q3DateTimeEditor(this, d->controls); + d->controls->setEditWidget(d->ed); + setFocusProxy(d->ed); + connect(d->controls, SIGNAL(stepUpPressed()), SLOT(stepUp())); + connect(d->controls, SIGNAL(stepDownPressed()), SLOT(stepDown())); + connect(this, SIGNAL(valueChanged(QDate)), SLOT(updateButtons())); + d->ed->appendSection(QNumberSection(0,4)); + d->ed->appendSection(QNumberSection(5,7)); + d->ed->appendSection(QNumberSection(8,10)); + + d->yearSection = -1; + d->monthSection = -1; + d->daySection = -1; + + d->y = 0; + d->m = 0; + d->d = 0; + d->dayCache = 0; + setOrder(localOrder()); + setFocusSection(0); + d->overwrite = true; + d->adv = false; + d->timerId = 0; + d->typing = false; + d->min = QDate(1752, 9, 14); + d->max = QDate(8000, 12, 31); + d->changed = false; + + setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Fixed); + + refcount++; +} + +/*! + Destroys the object and frees any allocated resources. +*/ + +Q3DateEdit::~Q3DateEdit() +{ + delete d; + if (!--refcount) + cleanup(); +} + +/*! + \property Q3DateEdit::minValue + + \brief the editor's minimum value + + Setting the minimum date value is equivalent to calling + Q3DateEdit::setRange(\e d, maxValue()), where \e d is the minimum + date. The default minimum date is 1752-09-14. + + \sa maxValue setRange() +*/ + +QDate Q3DateEdit::minValue() const +{ + return d->min; +} + +/*! + \property Q3DateEdit::maxValue + + \brief the editor's maximum value + + Setting the maximum date value for the editor is equivalent to + calling Q3DateEdit::setRange(minValue(), \e d), where \e d is the + maximum date. The default maximum date is 8000-12-31. + + \sa minValue setRange() +*/ + +QDate Q3DateEdit::maxValue() const +{ + return d->max; +} + + +/*! + Sets the valid input range for the editor to be from \a min to \a + max inclusive. If \a min is invalid no minimum date will be set. + Similarly, if \a max is invalid no maximum date will be set. +*/ + +void Q3DateEdit::setRange(const QDate& min, const QDate& max) +{ + if (min.isValid()) + d->min = min; + if (max.isValid()) + d->max = max; +} + +/*! + Sets the separator to \a s. Note that currently only the first + character of \a s is used. +*/ + +void Q3DateEdit::setSeparator(const QString& s) +{ + d->ed->setSeparator(s); +} + +/*! + Returns the editor's separator. +*/ + +QString Q3DateEdit::separator() const +{ + return d->ed->separator(); +} + + +/*! + Enables/disables the push buttons according to the min/max date + for this widget. +*/ + +void Q3DateEdit::updateButtons() +{ + if (!isEnabled()) + return; + + bool upEnabled = date() < maxValue(); + bool downEnabled = date() > minValue(); + + d->controls->setUpEnabled(upEnabled); + d->controls->setDownEnabled(downEnabled); +} + +/*! \reimp + */ +void Q3DateEdit::resizeEvent(QResizeEvent *) +{ + d->controls->resize(width(), height()); +} + +/*! \reimp + +*/ +QSize Q3DateEdit::sizeHint() const +{ + ensurePolished(); + QFontMetrics fm(font()); + int fw = style()->pixelMetric(QStyle::PM_DefaultFrameWidth, 0, this); + int h = qMax(fm.lineSpacing(), 14) + 2; + int w = 2 + fm.width(QLatin1Char('9')) * 8 + fm.width(d->ed->separator()) * 2 + d->controls->upRect().width() + fw * 4; + + return QSize(w, qMax(h + fw * 2,20)).expandedTo(QApplication::globalStrut()); +} + +/*! \reimp + +*/ +QSize Q3DateEdit::minimumSizeHint() const +{ + return sizeHint(); +} + + +/*! + Returns the formatted number for section \a sec. This will + correspond to either the year, month or day section, depending on + the current display order. + + \sa setOrder() +*/ + +QString Q3DateEdit::sectionFormattedText(int sec) +{ + QString txt; + txt = sectionText(sec); + if (d->typing && sec == d->ed->focusSection()) + d->ed->setSectionSelection(sec, sectionOffsetEnd(sec) - txt.length(), + sectionOffsetEnd(sec)); + else + d->ed->setSectionSelection(sec, sectionOffsetEnd(sec) - sectionLength(sec), + sectionOffsetEnd(sec)); + txt = txt.rightJustified(sectionLength(sec), QDATETIMEEDIT_HIDDEN_CHAR); + return txt; +} + + +/*! + Returns the desired length (number of digits) of section \a sec. + This will correspond to either the year, month or day section, + depending on the current display order. + + \sa setOrder() +*/ + +int Q3DateEdit::sectionLength(int sec) const +{ + int val = 0; + if (sec == d->yearSection) { + val = 4; + } else if (sec == d->monthSection) { + val = 2; + } else if (sec == d->daySection) { + val = 2; + } + return val; +} + +/*! + Returns the text of section \a sec. This will correspond to either + the year, month or day section, depending on the current display + order. + + \sa setOrder() +*/ + +QString Q3DateEdit::sectionText(int sec) const +{ + int val = 0; + if (sec == d->yearSection) { + val = d->y; + } else if (sec == d->monthSection) { + val = d->m; + } else if (sec == d->daySection) { + val = d->d; + } + return QString::number(val); +} + +/*! \internal + + Returns the end of the section offset \a sec. + +*/ + +int Q3DateEdit::sectionOffsetEnd(int sec) const +{ + if (sec == d->yearSection) { + switch(d->ord) { + case DMY: + case MDY: + return sectionOffsetEnd(sec-1) + separator().length() + sectionLength(sec); + case YMD: + case YDM: + return sectionLength(sec); + } + } else if (sec == d->monthSection) { + switch(d->ord) { + case DMY: + case YDM: + case YMD: + return sectionOffsetEnd(sec-1) + separator().length() + sectionLength(sec); + case MDY: + return sectionLength(sec); + } + } else if (sec == d->daySection) { + switch(d->ord) { + case DMY: + return sectionLength(sec); + case YMD: + case MDY: + case YDM: + return sectionOffsetEnd(sec-1) + separator().length() + sectionLength(sec); + } + } + return 0; +} + + +/*! + \property Q3DateEdit::order + \brief the order in which the year, month and day appear + + The default order is locale dependent. + + \sa Order +*/ + +void Q3DateEdit::setOrder(Q3DateEdit::Order order) +{ + d->ord = order; + switch(d->ord) { + case DMY: + d->yearSection = 2; + d->monthSection = 1; + d->daySection = 0; + break; + case MDY: + d->yearSection = 2; + d->monthSection = 0; + d->daySection = 1; + break; + case YMD: + d->yearSection = 0; + d->monthSection = 1; + d->daySection = 2; + break; + case YDM: + d->yearSection = 0; + d->monthSection = 2; + d->daySection = 1; + break; + } + if (isVisible()) + d->ed->repaint(d->ed->rect()); +} + + +Q3DateEdit::Order Q3DateEdit::order() const +{ + return d->ord; +} + + +/*! \internal + +*/ +void Q3DateEdit::stepUp() +{ + int sec = d->ed->focusSection(); + bool accepted = false; + if (sec == d->yearSection) { + if (!outOfRange(d->y+1, d->m, d->d)) { + accepted = true; + setYear(d->y+1); + } + } else if (sec == d->monthSection) { + if (!outOfRange(d->y, d->m+1, d->d)) { + accepted = true; + setMonth(d->m+1); + } + } else if (sec == d->daySection) { + if (!outOfRange(d->y, d->m, d->d+1)) { + accepted = true; + setDay(d->d+1); + } + } + if (accepted) { + d->changed = false; + emit valueChanged(date()); + } + d->ed->repaint(d->ed->rect()); +} + + + +/*! \internal + +*/ + +void Q3DateEdit::stepDown() +{ + int sec = d->ed->focusSection(); + bool accepted = false; + if (sec == d->yearSection) { + if (!outOfRange(d->y-1, d->m, d->d)) { + accepted = true; + setYear(d->y-1); + } + } else if (sec == d->monthSection) { + if (!outOfRange(d->y, d->m-1, d->d)) { + accepted = true; + setMonth(d->m-1); + } + } else if (sec == d->daySection) { + if (!outOfRange(d->y, d->m, d->d-1)) { + accepted = true; + setDay(d->d-1); + } + } + if (accepted) { + d->changed = false; + emit valueChanged(date()); + } + d->ed->repaint(d->ed->rect()); +} + +/*! + Sets the year to \a year, which must be a valid year. The range + currently supported is from 1752 to 8000. + + \sa QDate +*/ + +void Q3DateEdit::setYear(int year) +{ + if (year < 1752) + year = 1752; + if (year > 8000) + year = 8000; + if (!outOfRange(year, d->m, d->d)) { + d->y = year; + setMonth(d->m); + int tmp = d->dayCache; + setDay(d->dayCache); + d->dayCache = tmp; + } +} + + +/*! + Sets the month to \a month, which must be a valid month, i.e. + between 1 and 12. +*/ + +void Q3DateEdit::setMonth(int month) +{ + if (month < 1) + month = 1; + if (month > 12) + month = 12; + if (!outOfRange(d->y, month, d->d)) { + d->m = month; + int tmp = d->dayCache; + setDay(d->dayCache); + d->dayCache = tmp; + } +} + + +/*! + Sets the day to \a day, which must be a valid day. The function + will ensure that the \a day set is valid for the month and year. +*/ + +void Q3DateEdit::setDay(int day) +{ + if (day < 1) + day = 1; + if (day > 31) + day = 31; + if (d->m > 0 && d->y > 1752) { + while (!QDate::isValid(d->y, d->m, day)) + --day; + if (!outOfRange(d->y, d->m, day)) + d->d = day; + } else if (d->m > 0) { + if (day > 0 && day < 32) { + if (!outOfRange(d->y, d->m, day)) + d->d = day; + } + } + d->dayCache = d->d; +} + + +/*! + \property Q3DateEdit::date + \brief the editor's date value. + + If the date property is not valid, the editor displays all zeroes + and Q3DateEdit::date() will return an invalid date. It is strongly + recommended that the editor is given a default date value (e.g. + currentDate()). That way, attempts to set the date property to an + invalid date will fail. + + When changing the date property, if the date is less than + minValue(), or is greater than maxValue(), nothing happens. +*/ + +void Q3DateEdit::setDate(const QDate& date) +{ + if (!date.isValid()) { + d->y = 0; + d->m = 0; + d->d = 0; + d->dayCache = 0; + } else { + if (date > maxValue() || date < minValue()) + return; + d->y = date.year(); + d->m = date.month(); + d->d = date.day(); + d->dayCache = d->d; + emit valueChanged(date); + } + d->changed = false; + d->ed->repaint(d->ed->rect()); +} + +QDate Q3DateEdit::date() const +{ + if (QDate::isValid(d->y, d->m, d->d)) + return QDate(d->y, d->m, d->d); + return QDate(); +} + +/*! \internal + + Returns true if \a y, \a m, \a d is out of range, otherwise returns + false. + + \sa setRange() + +*/ + +bool Q3DateEdit::outOfRange(int y, int m, int d) const +{ + if (QDate::isValid(y, m, d)) { + QDate currentDate(y, m, d); + if (currentDate > maxValue() || + currentDate < minValue()) { + //## outOfRange should set overwrite? + return true; + } + return false; + } + return false; /* assume ok */ +} + +/*! \internal + +*/ + +void Q3DateEdit::addNumber(int sec, int num) +{ + if (sec == -1) + return; + if (d->timerId) + killTimer(d->timerId); + d->timerId = 0; + bool overwrite = false; + bool accepted = false; + d->typing = true; + QString txt; + if (sec == d->yearSection) { + txt = QString::number(d->y); + if (d->overwrite || txt.length() == 4) { + accepted = true; + d->y = num; + } else { + txt += QString::number(num); + if (txt.length() == 4 ) { + const int val = qBound(1792, txt.toInt(), 8000); + if (outOfRange(val, d->m, d->d)) { + txt = QString::number(d->y); + } else { + accepted = true; + d->y = val; + } + } else { + accepted = true; + d->y = txt.toInt(); + } + if (d->adv && txt.length() == 4) { + d->ed->setFocusSection(d->ed->focusSection()+1); + overwrite = true; + } + } + } else if (sec == d->monthSection) { + txt = QString::number(d->m); + if (d->overwrite || txt.length() == 2) { + accepted = true; + d->m = num; + } else { + txt += QString::number(num); + int temp = txt.toInt(); + if (temp > 12) + temp = num; + if (outOfRange(d->y, temp, d->d)) + txt = QString::number(d->m); + else { + accepted = true; + d->m = temp; + } + if (d->adv && txt.length() == 2) { + d->ed->setFocusSection(d->ed->focusSection()+1); + overwrite = true; + } + } + } else if (sec == d->daySection) { + txt = QString::number(d->d); + if (d->overwrite || txt.length() == 2) { + accepted = true; + d->d = num; + d->dayCache = d->d; + } else { + txt += QString::number(num); + int temp = txt.toInt(); + if (temp > 31) + temp = num; + if (outOfRange(d->y, d->m, temp)) + txt = QString::number(d->d); + else { + accepted = true; + d->d = temp; + d->dayCache = d->d; + } + if (d->adv && txt.length() == 2) { + d->ed->setFocusSection(d->ed->focusSection()+1); + overwrite = true; + } + } + } + if (accepted) { + d->changed = false; + emit valueChanged(date()); + } + d->overwrite = overwrite; + d->timerId = startTimer(qApp->doubleClickInterval()*4); + d->ed->repaint(d->ed->rect()); +} + + +/*! \internal + +*/ + +bool Q3DateEdit::setFocusSection(int s) +{ + if (s != d->ed->focusSection()) { + if (d->timerId) + killTimer(d->timerId); + d->timerId = 0; + d->overwrite = true; + d->typing = false; + fix(); // will emit valueChanged if necessary + } + return d->ed->setFocusSection(s); +} + + +/*! + Attempts to fix any invalid date entries. + + The rules applied are as follows: + + \list + \i If the year has four digits it is left unchanged. + \i If the year has two digits, the year will be changed to four + digits in the range current year - 70 to current year + 29. + \i If the year has three digits in the range 100..999, the + current millennium, i.e. 2000, will be added giving a year + in the range 2100..2999. + \i If the day or month is 0 then it will be set to 1 or the + minimum valid day/month in the range. + \endlist +*/ + +void Q3DateEdit::fix() +{ + bool changed = false; + int currentYear = QDate::currentDate().year(); + int year = d->y; + if (year < 100) { + int currentCentury = currentYear / 100; + year += currentCentury * 100; + if (currentYear > year) { + if (currentYear > year + 70) + year += 100; + } else { + if (year >= currentYear + 30) + year -= 100; + } + changed = true; + } else if (year < 1000) { + int currentMillennium = currentYear / 10; + year += currentMillennium * 10; + changed = true; + } else if (d->d == 0) { + d->d = 1; + changed = true; + } else if (d->m == 0) { + d->m = 1; + changed = true; + } + if (outOfRange(year, d->m, d->d)) { + if (minValue().isValid() && date() < minValue()) { + d->d = minValue().day(); + d->dayCache = d->d; + d->m = minValue().month(); + d->y = minValue().year(); + } + if (date() > maxValue()) { + d->d = maxValue().day(); + d->dayCache = d->d; + d->m = maxValue().month(); + d->y = maxValue().year(); + } + changed = true; + } else if (changed) + setYear(year); + if (changed) { + emit valueChanged(date()); + d->changed = false; + } +} + + +/*! \reimp + +*/ + +bool Q3DateEdit::event(QEvent *e) +{ + if(e->type() == QEvent::FocusOut) { + d->typing = false; + fix(); + // the following can't be done in fix() because fix() called + // from all over the place and it will break the old behaviour + if (!QDate::isValid(d->y, d->m, d->d)) { + d->dayCache = d->d; + int i = d->d; + for (; i > 0; i--) { + d->d = i; + if (QDate::isValid(d->y, d->m, d->d)) + break; + } + d->changed = true; + } + if (d->changed) { + emit valueChanged(date()); + d->changed = false; + } + } else if (e->type() == QEvent::LocaleChange) { + readLocaleSettings(); + d->ed->setSeparator(localDateSep()); + setOrder(localOrder()); + } + return Q3DateTimeEditBase::event(e); +} + +/*! + \internal + + Function which is called whenever the user tries to + remove the first number from \a sec by pressing the backspace key. +*/ + +void Q3DateEdit::removeFirstNumber(int sec) +{ + if (sec == -1) + return; + QString txt; + if (sec == d->yearSection) { + txt = QString::number(d->y); + txt = txt.mid(1, txt.length()) + QLatin1Char('0'); + d->y = txt.toInt(); + } else if (sec == d->monthSection) { + txt = QString::number(d->m); + txt = txt.mid(1, txt.length()) + QLatin1Char('0'); + d->m = txt.toInt(); + } else if (sec == d->daySection) { + txt = QString::number(d->d); + txt = txt.mid(1, txt.length()) + QLatin1Char('0'); + d->d = txt.toInt(); + d->dayCache = d->d; + } + d->ed->repaint(d->ed->rect()); +} + +/*! \internal + +*/ + +void Q3DateEdit::removeLastNumber(int sec) +{ + if (sec == -1) + return; + QString txt; + if (sec == d->yearSection) { + txt = QString::number(d->y); + txt = txt.mid(0, txt.length()-1); + d->y = txt.toInt(); + } else if (sec == d->monthSection) { + txt = QString::number(d->m); + txt = txt.mid(0, txt.length()-1); + d->m = txt.toInt(); + } else if (sec == d->daySection) { + txt = QString::number(d->d); + txt = txt.mid(0, txt.length()-1); + d->d = txt.toInt(); + d->dayCache = d->d; + } + d->ed->repaint(d->ed->rect()); +} + +/*! + \property Q3DateEdit::autoAdvance + \brief whether the editor automatically advances to the next + section + + If autoAdvance is true, the editor will automatically advance + focus to the next date section if a user has completed a section. + The default is false. +*/ + +void Q3DateEdit::setAutoAdvance(bool advance) +{ + d->adv = advance; +} + + +bool Q3DateEdit::autoAdvance() const +{ + return d->adv; +} + +/*! \reimp +*/ + +void Q3DateEdit::timerEvent(QTimerEvent *) +{ + d->overwrite = true; +} + +/*! + \fn void Q3DateEdit::valueChanged(const QDate& date) + + This signal is emitted whenever the editor's value changes. The \a + date parameter is the new value. +*/ + +/////////// + +class Q3TimeEditPrivate +{ +public: + int h; + int m; + int s; + uint display; + bool adv; + bool overwrite; + int timerId; + bool typing; + QTime min; + QTime max; + bool changed; + Q3DateTimeEditor *ed; + Q3SpinWidget *controls; +}; + +/*! + \class Q3TimeEdit + \brief The Q3TimeEdit class provides a time editor. + + \compat + + Q3TimeEdit allows the user to edit times by using the keyboard or + the arrow keys to increase/decrease time values. The arrow keys + can be used to move from section to section within the Q3TimeEdit + box. The user can automatically be moved to the next section once + they complete a section using setAutoAdvance(). Times appear in + hour, minute, second order. It is recommended that the Q3TimeEdit + is initialised with a time, e.g. + \snippet doc/src/snippets/code/src_qt3support_widgets_q3datetimeedit.cpp 1 + Here we've created a Q3TimeEdit widget set to the current time. + We've also set the minimum value to the current time and the + maximum time to one hour from now. + + The maximum and minimum values for a time value in the time editor + default to the maximum and minimum values for a QTime. You can + change this by calling setMinValue(), setMaxValue() or setRange(). + + Terminology: A QTimeWidget consists of three sections, one each + for the hour, minute and second. You can change the separator + character using setSeparator(), by default the separator is read + from the system's settings. + + \img datetimewidgets.png Date Time Widgets + + \sa QTime Q3DateEdit Q3DateTimeEdit +*/ + + +/*! + Constructs an empty time edit with parent \a parent and called \a + name. +*/ + +Q3TimeEdit::Q3TimeEdit(QWidget * parent, const char * name) + : Q3DateTimeEditBase(parent, name) +{ + init(); +} + +/*! + \overload + + Constructs a time edit with the initial time value, \a time, + parent \a parent and called \a name. +*/ + +Q3TimeEdit::Q3TimeEdit(const QTime& time, QWidget * parent, const char * name) + : Q3DateTimeEditBase(parent, name) +{ + init(); + setTime(time); +} + +/*! \internal + */ + +void Q3TimeEdit::init() +{ + d = new Q3TimeEditPrivate(); + d->controls = new QDateTimeSpinWidget(this, 0); + d->ed = new Q3DateTimeEditor(this, d->controls, "time edit base"); + d->controls->setEditWidget(d->ed); + setFocusProxy(d->ed); + connect(d->controls, SIGNAL(stepUpPressed()), SLOT(stepUp())); + connect(d->controls, SIGNAL(stepDownPressed()), SLOT(stepDown())); + + d->ed->appendSection(QNumberSection(0,0, true, 0)); + d->ed->appendSection(QNumberSection(0,0, true, 1)); + d->ed->appendSection(QNumberSection(0,0, true, 2)); + d->ed->setSeparator(localTimeSep()); + + d->h = 0; + d->m = 0; + d->s = 0; + d->display = Hours | Minutes | Seconds; + if (lAMPM) { + d->display |= AMPM; + d->ed->appendSection(QNumberSection(0,0, false, 3)); + } + d->adv = false; + d->overwrite = true; + d->timerId = 0; + d->typing = false; + d->min = QTime(0, 0, 0); + d->max = QTime(23, 59, 59); + d->changed = false; + + setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Fixed); + + refcount++; +} + +/*! + Destroys the object and frees any allocated resources. +*/ + +Q3TimeEdit::~Q3TimeEdit() +{ + delete d; + if (!--refcount) + cleanup(); +} + +/*! + \property Q3TimeEdit::minValue + \brief the minimum time value + + Setting the minimum time value is equivalent to calling + Q3TimeEdit::setRange(\e t, maxValue()), where \e t is the minimum + time. The default minimum time is 00:00:00. + + \sa maxValue setRange() +*/ + +QTime Q3TimeEdit::minValue() const +{ + return d->min; +} + +/*! + \property Q3TimeEdit::maxValue + \brief the maximum time value + + Setting the maximum time value is equivalent to calling + Q3TimeEdit::setRange(minValue(), \e t), where \e t is the maximum + time. The default maximum time is 23:59:59. + + \sa minValue setRange() +*/ + +QTime Q3TimeEdit::maxValue() const +{ + return d->max; +} + + +/*! + Sets the valid input range for the editor to be from \a min to \a + max inclusive. If \a min is invalid no minimum time is set. + Similarly, if \a max is invalid no maximum time is set. +*/ + +void Q3TimeEdit::setRange(const QTime& min, const QTime& max) +{ + if (min.isValid()) + d->min = min; + if (max.isValid()) + d->max = max; +} + +/*! + \property Q3TimeEdit::display + \brief the sections that are displayed in the time edit + + The value can be any combination of the values in the Display enum. + By default, the widget displays hours, minutes and seconds. +*/ +void Q3TimeEdit::setDisplay(uint display) +{ + if (d->display == display) + return; + + d->ed->clearSections(); + d->display = display; + if (d->display & Hours) + d->ed->appendSection(QNumberSection(0,0, true, 0)); + if (d->display & Minutes) + d->ed->appendSection(QNumberSection(0,0, true, 1)); + if (d->display & Seconds) + d->ed->appendSection(QNumberSection(0,0, true, 2)); + if (d->display & AMPM) + d->ed->appendSection(QNumberSection(0,0, false, 3)); + + d->ed->setFocusSection(0); + d->ed->update(); +} + +uint Q3TimeEdit::display() const +{ + return d->display; +} + +/*! + \property Q3TimeEdit::time + \brief the editor's time value. + + When changing the time property, if the time is less than + minValue(), or is greater than maxValue(), nothing happens. +*/ + +void Q3TimeEdit::setTime(const QTime& time) +{ + if (!time.isValid()) { + d->h = 0; + d->m = 0; + d->s = 0; + } else { + if (time > maxValue() || time < minValue()) + return; + d->h = time.hour(); + d->m = time.minute(); + d->s = time.second(); + emit valueChanged(time); + } + d->changed = false; + d->ed->repaint(d->ed->rect()); +} + +QTime Q3TimeEdit::time() const +{ + if (QTime::isValid(d->h, d->m, d->s)) + return QTime(d->h, d->m, d->s); + return QTime(); +} + +/*! + \property Q3TimeEdit::autoAdvance + \brief whether the editor automatically advances to the next + section + + If autoAdvance is true, the editor will automatically advance + focus to the next time section if a user has completed a section. + The default is false. +*/ + +void Q3TimeEdit::setAutoAdvance(bool advance) +{ + d->adv = advance; +} + +bool Q3TimeEdit::autoAdvance() const +{ + return d->adv; +} + +/*! + Sets the separator to \a s. Note that currently only the first + character of \a s is used. +*/ + +void Q3TimeEdit::setSeparator(const QString& s) +{ + d->ed->setSeparator(s); +} + +/*! + Returns the editor's separator. +*/ + +QString Q3TimeEdit::separator() const +{ + return d->ed->separator(); +} + + +/*! + \fn void Q3TimeEdit::valueChanged(const QTime& time) + + This signal is emitted whenever the editor's value changes. The \a + time parameter is the new value. +*/ + +/*! \reimp + +*/ + +bool Q3TimeEdit::event(QEvent *e) +{ + if (e->type() == QEvent::FocusOut) { + d->typing = false; + if (d->changed) { + emit valueChanged(time()); + d->changed = false; + } + } else if (e->type() == QEvent::LocaleChange) { + readLocaleSettings(); + d->ed->setSeparator(localTimeSep()); + } + return Q3DateTimeEditBase::event(e); +} + +/*! \reimp + +*/ + +void Q3TimeEdit::timerEvent(QTimerEvent *) +{ + d->overwrite = true; +} + + +/*! \internal + +*/ + +void Q3TimeEdit::stepUp() +{ + int sec = d->ed->mapSection(d->ed->focusSection()); + bool accepted = true; + switch(sec) { + case 0: + if (!outOfRange(d->h+1, d->m, d->s)) + setHour(d->h+1); + else + setHour(d->min.hour()); + break; + case 1: + if (!outOfRange(d->h, d->m+1, d->s)) + setMinute(d->m+1); + else + setMinute(d->min.minute()); + break; + case 2: + if (!outOfRange(d->h, d->m, d->s+1)) + setSecond(d->s+1); + else + setSecond(d->min.second()); + break; + case 3: + if (d->h < 12) + setHour(d->h+12); + else + setHour(d->h-12); + break; + default: + accepted = false; + qWarning("Q3TimeEdit::stepUp: Focus section out of range!"); + break; + } + if (accepted) { + d->changed = false; + emit valueChanged(time()); + } + d->ed->repaint(d->ed->rect()); +} + + +/*! \internal + +*/ + +void Q3TimeEdit::stepDown() +{ + int sec = d->ed->mapSection(d->ed->focusSection()); + + bool accepted = true; + switch(sec) { + case 0: + if (!outOfRange(d->h-1, d->m, d->s)) + setHour(d->h-1); + else + setHour(d->max.hour()); + break; + case 1: + if (!outOfRange(d->h, d->m-1, d->s)) + setMinute(d->m-1); + else + setMinute(d->max.minute()); + break; + case 2: + if (!outOfRange(d->h, d->m, d->s-1)) + setSecond(d->s-1); + else + setSecond(d->max.second()); + break; + case 3: + if (d->h > 11) + setHour(d->h-12); + else + setHour(d->h+12); + break; + default: + accepted = false; + qWarning("Q3TimeEdit::stepDown: Focus section out of range!"); + break; + } + if (accepted) { + d->changed = false; + emit valueChanged(time()); + } + d->ed->repaint(d->ed->rect()); +} + + +/*! + Returns the formatted number for section \a sec. This will + correspond to either the hour, minute or second section, depending + on \a sec. +*/ + +QString Q3TimeEdit::sectionFormattedText(int sec) +{ + QString txt; + txt = sectionText(sec); + txt = txt.rightJustified(2, QDATETIMEEDIT_HIDDEN_CHAR); + int offset = sec*2+sec*separator().length() + txt.length(); + if (d->typing && sec == d->ed->focusSection()) + d->ed->setSectionSelection(sec, offset - txt.length(), offset); + else + d->ed->setSectionSelection(sec, offset - txt.length(), offset); + + return txt; +} + + +/*! \internal + +*/ + +bool Q3TimeEdit::setFocusSection(int sec) +{ + if (sec != d->ed->focusSection()) { + if (d->timerId) + killTimer(d->timerId); + d->timerId = 0; + d->overwrite = true; + d->typing = false; + QString txt = sectionText(sec); + txt = txt.rightJustified(2, QDATETIMEEDIT_HIDDEN_CHAR); + int offset = sec*2+sec*separator().length() + txt.length(); + d->ed->setSectionSelection(sec, offset - txt.length(), offset); + if (d->changed) { + emit valueChanged(time()); + d->changed = false; + } + } + return d->ed->setFocusSection(sec); +} + + +/*! + Sets the hour to \a h, which must be a valid hour, i.e. in the + range 0..24. +*/ + +void Q3TimeEdit::setHour(int h) +{ + if (h < 0) + h = 0; + if (h > 23) + h = 23; + d->h = h; +} + + +/*! + Sets the minute to \a m, which must be a valid minute, i.e. in the + range 0..59. +*/ + +void Q3TimeEdit::setMinute(int m) +{ + if (m < 0) + m = 0; + if (m > 59) + m = 59; + d->m = m; +} + + +/*! + Sets the second to \a s, which must be a valid second, i.e. in the + range 0..59. +*/ + +void Q3TimeEdit::setSecond(int s) +{ + if (s < 0) + s = 0; + if (s > 59) + s = 59; + d->s = s; +} + + +/*! \internal + + Returns the text of section \a sec. + +*/ + +QString Q3TimeEdit::sectionText(int sec) +{ + sec = d->ed->mapSection(sec); + + QString txt; + switch(sec) { + case 0: + if (!(d->display & AMPM) || (d->h < 13 && d->h)) { // I wished the day stared at 0:00 for everybody + txt = QString::number(d->h); + } else { + if (d->h) + txt = QString::number(d->h - 12); + else + txt = QLatin1String("12"); + } + break; + case 1: + txt = QString::number(d->m); + break; + case 2: + txt = QString::number(d->s); + break; + case 3: + if (d->h < 12) { + if (lAM) + txt = *lAM; + else + txt = QString::fromLatin1("AM"); + } else { + if (lPM) + txt = *lPM; + else + txt = QString::fromLatin1("PM"); + } + break; + default: + break; + } + return txt; +} + + +/*! \internal + Returns true if \a h, \a m, and \a s are out of range. + */ + +bool Q3TimeEdit::outOfRange(int h, int m, int s) const +{ + if (QTime::isValid(h, m, s)) { + QTime currentTime(h, m, s); + if (currentTime > maxValue() || + currentTime < minValue()) + return true; + else + return false; + } + return true; +} + +/*! \internal + +*/ + +void Q3TimeEdit::addNumber(int sec, int num) +{ + if (sec == -1) + return; + sec = d->ed->mapSection(sec); + if (d->timerId) + killTimer(d->timerId); + d->timerId = 0; + bool overwrite = false; + bool accepted = false; + d->typing = true; + QString txt; + + switch(sec) { + case 0: + txt = (d->display & AMPM && d->h > 12) ? + QString::number(d->h - 12) : QString::number(d->h); + + if (d->overwrite || txt.length() == 2) { + if (d->display & AMPM && num == 0) + break; // Don't process 0 in 12 hour clock mode + if (d->display & AMPM && d->h > 11) + num += 12; + if (!outOfRange(num, d->m, d->s)) { + accepted = true; + d->h = num; + } + } else { + txt += QString::number(num); + int temp = txt.toInt(); + + if (d->display & AMPM) { + if (temp == 12) { + if (d->h < 12) { + temp = 0; + } + accepted = true; + } else if (outOfRange(temp + 12, d->m, d->s)) { + txt = QString::number(d->h); + } else { + if (d->h > 11) { + temp += 12; + } + accepted = true; + } + } else if (!(d->display & AMPM) && outOfRange(temp, d->m, d->s)) { + txt = QString::number(d->h); + } else { + accepted = true; + } + + if (accepted) + d->h = temp; + + if (d->adv && txt.length() == 2) { + setFocusSection(d->ed->focusSection()+1); + overwrite = true; + } + } + break; + + case 1: + txt = QString::number(d->m); + if (d->overwrite || txt.length() == 2) { + if (!outOfRange(d->h, num, d->s)) { + accepted = true; + d->m = num; + } + } else { + txt += QString::number(num); + int temp = txt.toInt(); + if (temp > 59) + temp = num; + if (outOfRange(d->h, temp, d->s)) + txt = QString::number(d->m); + else { + accepted = true; + d->m = temp; + } + if (d->adv && txt.length() == 2) { + setFocusSection(d->ed->focusSection()+1); + overwrite = true; + } + } + break; + + case 2: + txt = QString::number(d->s); + if (d->overwrite || txt.length() == 2) { + if (!outOfRange(d->h, d->m, num)) { + accepted = true; + d->s = num; + } + } else { + txt += QString::number(num); + int temp = txt.toInt(); + if (temp > 59) + temp = num; + if (outOfRange(d->h, d->m, temp)) + txt = QString::number(d->s); + else { + accepted = true; + d->s = temp; + } + if (d->adv && txt.length() == 2) { + setFocusSection(d->ed->focusSection()+1); + overwrite = true; + } + } + break; + + case 3: + break; + + default: + break; + } + d->changed = !accepted; + if (accepted) + emit valueChanged(time()); + d->overwrite = overwrite; + d->timerId = startTimer(qApp->doubleClickInterval()*4); + d->ed->repaint(d->ed->rect()); +} + + +/*! + \internal + + Function which is called whenever the user tries to + remove the first number from \a sec by pressing the backspace key. +*/ + +void Q3TimeEdit::removeFirstNumber(int sec) +{ + if (sec == -1) + return; + sec = d->ed->mapSection(sec); + QString txt; + switch(sec) { + case 0: + txt = QString::number(d->h); + break; + case 1: + txt = QString::number(d->m); + break; + case 2: + txt = QString::number(d->s); + break; + } + txt = txt.mid(1, txt.length()) + QLatin1Char('0'); + switch(sec) { + case 0: + d->h = txt.toInt(); + break; + case 1: + d->m = txt.toInt(); + break; + case 2: + d->s = txt.toInt(); + break; + } + d->ed->repaint(d->ed->rect()); +} + +/*! \internal + +*/ +void Q3TimeEdit::removeLastNumber(int sec) +{ + if (sec == -1) + return; + sec = d->ed->mapSection(sec); + QString txt; + switch(sec) { + case 0: + txt = QString::number(d->h); + break; + case 1: + txt = QString::number(d->m); + break; + case 2: + txt = QString::number(d->s); + break; + } + txt = txt.mid(0, txt.length()-1); + switch(sec) { + case 0: + d->h = txt.toInt(); + break; + case 1: + d->m = txt.toInt(); + break; + case 2: + d->s = txt.toInt(); + break; + } + d->ed->repaint(d->ed->rect()); +} + +/*! \reimp + */ +void Q3TimeEdit::resizeEvent(QResizeEvent *) +{ + d->controls->resize(width(), height()); +} + +/*! \reimp +*/ +QSize Q3TimeEdit::sizeHint() const +{ + ensurePolished(); + QFontMetrics fm(font()); + int fw = style()->pixelMetric(QStyle::PM_DefaultFrameWidth, 0, this); + int h = fm.lineSpacing() + 2; + int w = 2 + fm.width(QLatin1Char('9')) * 6 + fm.width(d->ed->separator()) * 2 + + d->controls->upRect().width() + fw * 4; + if (d->display & AMPM) { + if (lAM) + w += fm.width(*lAM) + 4; + else + w += fm.width(QString::fromLatin1("AM")) + 4; + } + + return QSize(w, qMax(h + fw * 2,20)).expandedTo(QApplication::globalStrut()); +} + +/*! \reimp +*/ +QSize Q3TimeEdit::minimumSizeHint() const +{ + return sizeHint(); +} + +/*! + \internal + Enables/disables the push buttons according to the min/max time + for this widget. +*/ + +void Q3TimeEdit::updateButtons() +{ + if (!isEnabled()) + return; + + bool upEnabled = time() < maxValue(); + bool downEnabled = time() > minValue(); + + d->controls->setUpEnabled(upEnabled); + d->controls->setDownEnabled(downEnabled); +} + + +class Q3DateTimeEditPrivate +{ +public: + bool adv; +}; + +/*! + \class Q3DateTimeEdit + \brief The Q3DateTimeEdit class combines a Q3DateEdit and Q3TimeEdit + widget into a single widget for editing datetimes. + + \compat + + Q3DateTimeEdit consists of a Q3DateEdit and Q3TimeEdit widget placed + side by side and offers the functionality of both. The user can + edit the date and time by using the keyboard or the arrow keys to + increase/decrease date or time values. The Tab key can be used to + move from section to section within the Q3DateTimeEdit widget, and + the user can be moved automatically when they complete a section + using setAutoAdvance(). The datetime can be set with + setDateTime(). + + The date format is read from the system's locale settings. It is + set to year, month, day order if that is not possible. See + Q3DateEdit::setOrder() to change this. Times appear in the order + hours, minutes, seconds using the 24 hour clock. + + It is recommended that the Q3DateTimeEdit is initialised with a + datetime, e.g. + \snippet doc/src/snippets/code/src_qt3support_widgets_q3datetimeedit.cpp 2 + Here we've created a new Q3DateTimeEdit set to the current date and + time, and set the date to have a minimum date of now and a maximum + date of a week from now. + + Terminology: A Q3DateEdit widget consists of three 'sections', one + each for the year, month and day. Similarly a Q3TimeEdit consists + of three sections, one each for the hour, minute and second. The + character that separates each date section is specified with + setDateSeparator(); similarly setTimeSeparator() is used for the + time sections. + + \img datetimewidgets.png Date Time Widgets + + \sa Q3DateEdit Q3TimeEdit +*/ + +/*! + Constructs an empty datetime edit with parent \a parent and called + \a name. +*/ +Q3DateTimeEdit::Q3DateTimeEdit(QWidget * parent, const char * name) + : QWidget(parent, name) +{ + init(); +} + + +/*! + \overload + + Constructs a datetime edit with the initial value \a datetime, + parent \a parent and called \a name. +*/ +Q3DateTimeEdit::Q3DateTimeEdit(const QDateTime& datetime, + QWidget * parent, const char * name) + : QWidget(parent, name) +{ + init(); + setDateTime(datetime); +} + + + +/*! + Destroys the object and frees any allocated resources. +*/ + +Q3DateTimeEdit::~Q3DateTimeEdit() +{ + delete d; +} + + +/*! \fn void Q3DateTimeEdit::resizeEvent(QResizeEvent *event) + \reimp + + Intercepts and handles the resize \a event, which hase a + special meaning for the Q3DateTimeEdit. +*/ +void Q3DateTimeEdit::resizeEvent(QResizeEvent *) +{ + int dw = de->sizeHint().width(); + int tw = te->sizeHint().width(); + int w = width(); + int h = height(); + int extra = w - (dw + tw); + + if (tw + extra < 0) { + dw = w; + } else { + dw += 9 * extra / 16; + } + tw = w - dw; + + de->setGeometry(0, 0, dw, h); + te->setGeometry(dw, 0, tw, h); +} + +/*! \reimp +*/ + +QSize Q3DateTimeEdit::minimumSizeHint() const +{ + QSize dsh = de->minimumSizeHint(); + QSize tsh = te->minimumSizeHint(); + return QSize(dsh.width() + tsh.width(), + qMax(dsh.height(), tsh.height())); +} + +/*! \internal + */ + +void Q3DateTimeEdit::init() +{ + d = new Q3DateTimeEditPrivate(); + de = new Q3DateEdit(this, "qt_datetime_dateedit"); + te = new Q3TimeEdit(this, "qt_datetime_timeedit"); + d->adv = false; + connect(de, SIGNAL(valueChanged(QDate)), this, SLOT(newValue(QDate))); + connect(te, SIGNAL(valueChanged(QTime)), this, SLOT(newValue(QTime))); + setFocusProxy(de); + setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Fixed); +} + +/*! \reimp + */ + +QSize Q3DateTimeEdit::sizeHint() const +{ + ensurePolished(); + QSize dsh = de->sizeHint(); + QSize tsh = te->sizeHint(); + return QSize(dsh.width() + tsh.width(), + qMax(dsh.height(), tsh.height())); +} + +/*! + \property Q3DateTimeEdit::dateTime + \brief the editor's datetime value + + The datetime edit's datetime which may be an invalid datetime. +*/ + +void Q3DateTimeEdit::setDateTime(const QDateTime & dt) +{ + if (dt.isValid()) { + de->setDate(dt.date()); + te->setTime(dt.time()); + emit valueChanged(dt); + } +} + +QDateTime Q3DateTimeEdit::dateTime() const +{ + return QDateTime(de->date(), te->time()); +} + +/*! + \fn void Q3DateTimeEdit::valueChanged(const QDateTime& datetime) + + This signal is emitted every time the date or time changes. The \a + datetime argument is the new datetime. +*/ + + +/*! \internal + + Re-emits the value \a d. + */ + +void Q3DateTimeEdit::newValue(const QDate&) +{ + QDateTime dt = dateTime(); + emit valueChanged(dt); +} + +/*! \internal + \overload + Re-emits the value \a t. + */ + +void Q3DateTimeEdit::newValue(const QTime&) +{ + QDateTime dt = dateTime(); + emit valueChanged(dt); +} + + +/*! + Sets the auto advance property of the editor to \a advance. If set + to true, the editor will automatically advance focus to the next + date or time section if the user has completed a section. +*/ + +void Q3DateTimeEdit::setAutoAdvance(bool advance) +{ + de->setAutoAdvance(advance); + te->setAutoAdvance(advance); +} + +/*! + Returns true if auto-advance is enabled, otherwise returns false. + + \sa setAutoAdvance() +*/ + +bool Q3DateTimeEdit::autoAdvance() const +{ + return de->autoAdvance(); +} + +/*! + \fn Q3DateEdit* Q3DateTimeEdit::dateEdit() + + Returns the internal widget used for editing the date part of the + datetime. +*/ + +/*! + \fn Q3TimeEdit* Q3DateTimeEdit::timeEdit() + + Returns the internal widget used for editing the time part of the + datetime. +*/ + +QT_END_NAMESPACE + +#include "q3datetimeedit.moc" + +#endif diff --git a/src/qt3support/widgets/q3datetimeedit.h b/src/qt3support/widgets/q3datetimeedit.h new file mode 100644 index 0000000..9a2da91 --- /dev/null +++ b/src/qt3support/widgets/q3datetimeedit.h @@ -0,0 +1,288 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the Qt3Support module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, 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 qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef Q3DATETIMEEDIT_H +#define Q3DATETIMEEDIT_H + +#include <QtGui/qwidget.h> +#include <QtCore/qstring.h> +#include <QtCore/qdatetime.h> + +QT_BEGIN_HEADER + +QT_BEGIN_NAMESPACE + +QT_MODULE(Qt3SupportLight) + +#ifndef QT_NO_DATETIMEEDIT + +class Q_COMPAT_EXPORT Q3DateTimeEditBase : public QWidget +{ + Q_OBJECT +public: + Q3DateTimeEditBase(QWidget* parent=0, const char* name=0) + : QWidget(parent) { setObjectName(QString::fromAscii(name)); } + + virtual bool setFocusSection(int sec) = 0; + virtual QString sectionFormattedText(int sec) = 0; + virtual void addNumber(int sec, int num) = 0; + virtual void removeLastNumber(int sec) = 0; + +public Q_SLOTS: + virtual void stepUp() = 0; + virtual void stepDown() = 0; + +private: + Q_DISABLE_COPY(Q3DateTimeEditBase) +}; + +class Q3DateEditPrivate; + +class Q_COMPAT_EXPORT Q3DateEdit : public Q3DateTimeEditBase +{ + Q_OBJECT + Q_ENUMS(Order) + Q_PROPERTY(Order order READ order WRITE setOrder) + Q_PROPERTY(QDate date READ date WRITE setDate USER true) + Q_PROPERTY(bool autoAdvance READ autoAdvance WRITE setAutoAdvance) + Q_PROPERTY(QDate maxValue READ maxValue WRITE setMaxValue) + Q_PROPERTY(QDate minValue READ minValue WRITE setMinValue) + +public: + Q3DateEdit(QWidget* parent=0, const char* name=0); + Q3DateEdit(const QDate& date, QWidget* parent=0, const char* name=0); + ~Q3DateEdit(); + + enum Order { DMY, MDY, YMD, YDM }; + + QSize sizeHint() const; + QSize minimumSizeHint() const; + +public Q_SLOTS: + virtual void setDate(const QDate& date); + +public: + QDate date() const; + virtual void setOrder(Order order); + Order order() const; + virtual void setAutoAdvance(bool advance); + bool autoAdvance() const; + + virtual void setMinValue(const QDate& d) { setRange(d, maxValue()); } + QDate minValue() const; + virtual void setMaxValue(const QDate& d) { setRange(minValue(), d); } + QDate maxValue() const; + virtual void setRange(const QDate& min, const QDate& max); + QString separator() const; + virtual void setSeparator(const QString& s); + + // Make removeFirstNumber() virtual in Q3DateTimeEditBase in 4.0 + void removeFirstNumber(int sec); + +Q_SIGNALS: + void valueChanged(const QDate& date); + +protected: + bool event(QEvent *e); + void timerEvent(QTimerEvent *); + void resizeEvent(QResizeEvent *); + void stepUp(); + void stepDown(); + QString sectionFormattedText(int sec); + void addNumber(int sec, int num); + + void removeLastNumber(int sec); + bool setFocusSection(int s); + + virtual void setYear(int year); + virtual void setMonth(int month); + virtual void setDay(int day); + virtual void fix(); + virtual bool outOfRange(int y, int m, int d) const; + +protected Q_SLOTS: + void updateButtons(); + +private: + Q_DISABLE_COPY(Q3DateEdit) + + void init(); + int sectionOffsetEnd(int sec) const; + int sectionLength(int sec) const; + QString sectionText(int sec) const; + Q3DateEditPrivate* d; +}; + +class Q3TimeEditPrivate; + +class Q_COMPAT_EXPORT Q3TimeEdit : public Q3DateTimeEditBase +{ + Q_OBJECT + Q_FLAGS(Display) + Q_PROPERTY(QTime time READ time WRITE setTime USER true) + Q_PROPERTY(bool autoAdvance READ autoAdvance WRITE setAutoAdvance) + Q_PROPERTY(QTime maxValue READ maxValue WRITE setMaxValue) + Q_PROPERTY(QTime minValue READ minValue WRITE setMinValue) + Q_PROPERTY(Display display READ display WRITE setDisplay) + +public: + enum Display { + Hours = 0x01, + Minutes = 0x02, + Seconds = 0x04, + /*Reserved = 0x08,*/ + AMPM = 0x10 + }; + + Q3TimeEdit(QWidget* parent=0, const char* name=0); + Q3TimeEdit(const QTime& time, QWidget* parent=0, const char* name=0); + ~Q3TimeEdit(); + + QSize sizeHint() const; + QSize minimumSizeHint() const; + +public Q_SLOTS: + virtual void setTime(const QTime& time); + +public: + QTime time() const; + virtual void setAutoAdvance(bool advance); + bool autoAdvance() const; + + virtual void setMinValue(const QTime& d) { setRange(d, maxValue()); } + QTime minValue() const; + virtual void setMaxValue(const QTime& d) { setRange(minValue(), d); } + QTime maxValue() const; + virtual void setRange(const QTime& min, const QTime& max); + QString separator() const; + virtual void setSeparator(const QString& s); + + uint display() const; + void setDisplay(uint disp); + + // Make removeFirstNumber() virtual in Q3DateTimeEditBase in 4.0 + void removeFirstNumber(int sec); + +Q_SIGNALS: + void valueChanged(const QTime& time); + +protected: + bool event(QEvent *e); + void timerEvent(QTimerEvent *e); + void resizeEvent(QResizeEvent *); + void stepUp(); + void stepDown(); + QString sectionFormattedText(int sec); + void addNumber(int sec, int num); + void removeLastNumber(int sec); + bool setFocusSection(int s); + + virtual bool outOfRange(int h, int m, int s) const; + virtual void setHour(int h); + virtual void setMinute(int m); + virtual void setSecond(int s); + +protected Q_SLOTS: + void updateButtons(); + +private: + Q_DISABLE_COPY(Q3TimeEdit) + + void init(); + QString sectionText(int sec); + Q3TimeEditPrivate* d; +}; + + +class Q3DateTimeEditPrivate; + +class Q_COMPAT_EXPORT Q3DateTimeEdit : public QWidget +{ + Q_OBJECT + Q_PROPERTY(QDateTime dateTime READ dateTime WRITE setDateTime USER true) + +public: + Q3DateTimeEdit(QWidget* parent=0, const char* name=0); + Q3DateTimeEdit(const QDateTime& datetime, QWidget* parent=0, + const char* name=0); + ~Q3DateTimeEdit(); + + QSize sizeHint() const; + QSize minimumSizeHint() const; + +public Q_SLOTS: + virtual void setDateTime(const QDateTime & dt); + +public: + QDateTime dateTime() const; + + Q3DateEdit* dateEdit() { return de; } + Q3TimeEdit* timeEdit() { return te; } + + virtual void setAutoAdvance(bool advance); + bool autoAdvance() const; + +Q_SIGNALS: + void valueChanged(const QDateTime& datetime); + +protected: + void init(); + void resizeEvent(QResizeEvent *); + +protected Q_SLOTS: + void newValue(const QDate& d); + void newValue(const QTime& t); + +private: + Q_DISABLE_COPY(Q3DateTimeEdit) + + Q3DateEdit* de; + Q3TimeEdit* te; + Q3DateTimeEditPrivate* d; +}; + +#endif // QT_NO_DATETIMEEDIT + +QT_END_NAMESPACE + +QT_END_HEADER + +#endif // Q3DATETIMEEDIT_H diff --git a/src/qt3support/widgets/q3dockarea.cpp b/src/qt3support/widgets/q3dockarea.cpp new file mode 100644 index 0000000..0fce67b --- /dev/null +++ b/src/qt3support/widgets/q3dockarea.cpp @@ -0,0 +1,1351 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the Qt3Support module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, 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 qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "q3dockarea.h" + +#ifndef QT_NO_MAINWINDOW +#include "qsplitter.h" +#include "qevent.h" +#include "qlayout.h" +#include "qapplication.h" +#include "qpainter.h" +#include "qmap.h" +#include "q3mainwindow.h" +#include "q3toolbar.h" + +QT_BEGIN_NAMESPACE + +//#define QDOCKAREA_DEBUG + +struct Q3DockData +{ + Q3DockData() : w(0), rect() {} + Q3DockData(Q3DockWindow *dw, const QRect &r) : w(dw), rect(r) {} + Q3DockWindow *w; + QRect rect; + + Q_DUMMY_COMPARISON_OPERATOR(Q3DockData) +}; + +static int fix_x(Q3DockWindow* w, int width = -1) { + if (QApplication::reverseLayout()) { + if (width < 0) + width = w->width(); + return w->parentWidget()->width() - w->x() - width; + } + return w->x(); +} +static int fix_x(Q3DockWindow* w, int x, int width = -1) { + if (QApplication::reverseLayout()) { + if (width < 0) + width = w->width(); + return w->parentWidget()->width() - x - width; + } + return x; +} + +static QPoint fix_pos(Q3DockWindow* w) { + if (QApplication::reverseLayout()) { + QPoint p = w->pos(); + p.rx() = w->parentWidget()->width() - p.x() - w->width(); + return p; + } + return w->pos(); +} + + +void Q3DockAreaLayout::setGeometry(const QRect &r) +{ + QLayout::setGeometry(r); + layoutItems(r); +} + +QLayoutItem *Q3DockAreaLayout::itemAt(int) const +{ + return 0; //### +} + +QLayoutItem *Q3DockAreaLayout::takeAt(int) +{ + return 0; //### +} + +int Q3DockAreaLayout::count() const +{ + return 0; //### +} + + +QSize Q3DockAreaLayout::sizeHint() const +{ + if (dockWindows->isEmpty()) + return QSize(0, 0); + + if (dirty) { + Q3DockAreaLayout *that = (Q3DockAreaLayout *) this; + that->layoutItems(geometry()); + } + + int w = 0; + int h = 0; + int y = -1; + int x = -1; + int ph = 0; + int pw = 0; + for (int i = 0; i < dockWindows->size(); ++i) { + Q3DockWindow *dw = dockWindows->at(i); + int plush = 0, plusw = 0; + if (dw->isHidden()) + continue; + if (hasHeightForWidth()) { + if (y != dw->y()) + plush = ph; + y = dw->y(); + ph = dw->height(); + } else { + if (x != dw->x()) + plusw = pw; + x = dw->x(); + pw = dw->width(); + } + h = qMax(h, dw->height() + plush); + w = qMax(w, dw->width() + plusw); + } + + if (hasHeightForWidth()) + return QSize(0, h); + return QSize(w, 0); +} + +bool Q3DockAreaLayout::hasHeightForWidth() const +{ + return orient == Qt::Horizontal; +} + +void Q3DockAreaLayout::init() +{ + dirty = true; + cached_width = 0; + cached_height = 0; + cached_hfw = -1; + cached_wfh = -1; +} + +void Q3DockAreaLayout::invalidate() +{ + dirty = true; + cached_width = 0; + cached_height = 0; + QLayout::invalidate(); +} + +static int start_pos(const QRect &r, Qt::Orientation o) +{ + if (o == Qt::Horizontal) { + return qMax(0, r.x()); + } else { + return qMax(0, r.y()); + } +} + +static void add_size(int s, int &pos, Qt::Orientation o) +{ + if (o == Qt::Horizontal) { + pos += s; + } else { + pos += s; + } +} + +static int space_left(const QRect &r, int pos, Qt::Orientation o) +{ + if (o == Qt::Horizontal) { + return (r.x() + r.width()) - pos; + } else { + return (r.y() + r.height()) - pos; + } +} + +static int dock_extent(Q3DockWindow *w, Qt::Orientation o, int maxsize) +{ + if (o == Qt::Horizontal) + return qMin(maxsize, qMax(w->sizeHint().width(), w->fixedExtent().width())); + else + return qMin(maxsize, qMax(w->sizeHint().height(), w->fixedExtent().height())); +} + +static int dock_strut(Q3DockWindow *w, Qt::Orientation o) +{ + if (o != Qt::Horizontal) { + int wid; + if ((wid = w->fixedExtent().width()) != -1) + return qMax(wid, qMax(w->minimumSize().width(), w->minimumSizeHint().width())); + return qMax(w->sizeHint().width(), qMax(w->minimumSize().width(), w->minimumSizeHint().width())); + } else { + int hei; + if ((hei = w->fixedExtent().height()) != -1) + return qMax(hei, qMax(w->minimumSizeHint().height(), w->minimumSize().height())); + return qMax(w->sizeHint().height(), qMax(w->minimumSizeHint().height(), w->minimumSize().height())); + } +} + +static void set_geometry(Q3DockWindow *w, int pos, int sectionpos, int extent, int strut, Qt::Orientation o) +{ + if (o == Qt::Horizontal) + w->setGeometry(fix_x(w, pos, extent), sectionpos, extent, strut); + else + w->setGeometry(sectionpos, pos, strut, extent); +} + +static int size_extent(const QSize &s, Qt::Orientation o, bool swap = false) +{ + return o == Qt::Horizontal ? (swap ? s.height() : s.width()) : (swap ? s.width() : s.height()); +} + +static int point_pos(const QPoint &p, Qt::Orientation o, bool swap = false) +{ + return o == Qt::Horizontal ? (swap ? p.y() : p.x()) : (swap ? p.x() : p.y()); +} + +static void shrink_extend(Q3DockWindow *dw, int &dockExtend, int /*spaceLeft*/, Qt::Orientation o) +{ + Q3ToolBar *tb = qobject_cast<Q3ToolBar*>(dw); + if (o == Qt::Horizontal) { + int mw = 0; + if (!tb) + mw = dw->minimumWidth(); + else + mw = dw->sizeHint().width(); + dockExtend = mw; + } else { + int mh = 0; + if (!tb) + mh = dw->minimumHeight(); + else + mh = dw->sizeHint().height(); + dockExtend = mh; + } +} + +static void place_line(QList<Q3DockData> &lastLine, Qt::Orientation o, int linestrut, int fullextent, int tbstrut, int maxsize, Q3DockAreaLayout *) +{ + Q3DockWindow *last = 0; + QRect lastRect; + for (QList<Q3DockData>::Iterator it = lastLine.begin(); it != lastLine.end(); ++it) { + if (tbstrut != -1 && qobject_cast<Q3ToolBar*>((*it).w)) + (*it).rect.setHeight(tbstrut); + if (!last) { + last = (*it).w; + lastRect = (*it).rect; + continue; + } + if (!last->isStretchable()) { + int w = qMin(lastRect.width(), maxsize); + set_geometry(last, lastRect.x(), lastRect.y(), w, lastRect.height(), o); + } else { + int w = qMin((*it).rect.x() - lastRect.x(), maxsize); + set_geometry(last, lastRect.x(), lastRect.y(), w, + last->isResizeEnabled() ? linestrut : lastRect.height(), o); + } + last = (*it).w; + lastRect = (*it).rect; + } + if (!last) + return; + if (!last->isStretchable()) { + int w = qMin(lastRect.width(), maxsize); + set_geometry(last, lastRect.x(), lastRect.y(), w, lastRect.height(), o); + } else { + int w = qMin(fullextent - lastRect.x() - (o == Qt::Vertical ? 1 : 0), maxsize); + set_geometry(last, lastRect.x(), lastRect.y(), w, + last->isResizeEnabled() ? linestrut : lastRect.height(), o); + } +} + +QSize Q3DockAreaLayout::minimumSize() const +{ + if (dockWindows->isEmpty()) + return QSize(0, 0); + + if (dirty) { + Q3DockAreaLayout *that = (Q3DockAreaLayout *) this; + that->layoutItems(geometry()); + } + + int s = 0; + + for (int i = 0; i < dockWindows->size(); ++i) { + Q3DockWindow *dw = dockWindows->at(i); + if (dw->isHidden()) + continue; + s = qMax(s, dock_strut(dw, orientation())); + } + + return orientation() == Qt::Horizontal ? QSize(0, s ? s+2 : 0) : QSize(s, 0); +} + + + +int Q3DockAreaLayout::layoutItems(const QRect &rect, bool testonly) +{ + if (dockWindows->isEmpty()) + return 0; + + dirty = false; + + // some corrections + QRect r = rect; + if (orientation() == Qt::Vertical) + r.setHeight(r.height() - 3); + + // init + lines.clear(); + ls.clear(); + int start = start_pos(r, orientation()); + int pos = start; + int sectionpos = 0; + int linestrut = 0; + QList<Q3DockData> lastLine; + int tbstrut = -1; + int maxsize = size_extent(rect.size(), orientation()); + int visibleWindows = 0; + + // go through all widgets in the dock + for (int i = 0; i < dockWindows->size(); ++i) { + Q3DockWindow *dw = dockWindows->at(i); + if (dw->isHidden()) + continue; + ++visibleWindows; + // find position for the widget: This is the maximum of the + // end of the previous widget and the offset of the widget. If + // the position + the width of the widget dosn't fit into the + // dock, try moving it a bit back, if possible. + int op = pos; + int dockExtend = dock_extent(dw, orientation(), maxsize); + if (!dw->isStretchable()) { + pos = qMax(pos, dw->offset()); + if (pos + dockExtend > size_extent(r.size(), orientation()) - 1) + pos = qMax(op, size_extent(r.size(), orientation()) - 1 - dockExtend); + } + if (!lastLine.isEmpty() && !dw->newLine() && space_left(rect, pos, orientation()) < dockExtend) + shrink_extend(dw, dockExtend, space_left(rect, pos, orientation()), orientation()); + // if the current widget doesn't fit into the line anymore and it is not the first widget of the line + if (!lastLine.isEmpty() && + (space_left(rect, pos, orientation()) < dockExtend || dw->newLine())) { + if (!testonly) // place the last line, if not in test mode + place_line(lastLine, orientation(), linestrut, size_extent(r.size(), orientation()), tbstrut, maxsize, this); + // remember the line coordinats of the last line + if (orientation() == Qt::Horizontal) + lines.append(QRect(0, sectionpos, r.width(), linestrut)); + else + lines.append(QRect(sectionpos, 0, linestrut, r.height())); + // do some clearing for the next line + lastLine.clear(); + sectionpos += linestrut; + linestrut = 0; + pos = start; + tbstrut = -1; + } + + // remember first widget of a line + if (lastLine.isEmpty()) { + ls.append(dw); + // try to make the best position + int op = pos; + if (!dw->isStretchable()) + pos = qMax(pos, dw->offset()); + if (pos + dockExtend > size_extent(r.size(), orientation()) - 1) + pos = qMax(op, size_extent(r.size(), orientation()) - 1 - dockExtend); + } + // do some calculations and add the remember the rect which the docking widget requires for the placing + QRect dwRect(pos, sectionpos, dockExtend, dock_strut(dw, orientation() )); + lastLine.append(Q3DockData(dw, dwRect)); + if (qobject_cast<Q3ToolBar*>(dw)) + tbstrut = qMax(tbstrut, dock_strut(dw, orientation())); + linestrut = qMax(dock_strut(dw, orientation()), linestrut); + add_size(dockExtend, pos, orientation()); + } + + // if some stuff was not placed/stored yet, do it now + if (!testonly) + place_line(lastLine, orientation(), linestrut, size_extent(r.size(), orientation()), tbstrut, maxsize, this); + if (orientation() == Qt::Horizontal) + lines.append(QRect(0, sectionpos, r.width(), linestrut)); + else + lines.append(QRect(sectionpos, 0, linestrut, r.height())); + if (lines.size() >= 2 && *(--lines.end()) == *(--(--lines.end()))) + lines.removeLast(); + + bool hadResizable = false; + for (int i = 0; i < dockWindows->size(); ++i) { + Q3DockWindow *dw = dockWindows->at(i); + if (!dw->isVisibleTo(parentWidget)) + continue; + hadResizable = hadResizable || dw->isResizeEnabled(); + dw->updateSplitterVisibility(visibleWindows > 1); //!dw->area()->isLastDockWindow(dw)); + if (Q3ToolBar *tb = qobject_cast<Q3ToolBar *>(dw)) + tb->checkForExtension(dw->size()); + } + return sectionpos + linestrut; +} + +int Q3DockAreaLayout::heightForWidth(int w) const +{ + if (dockWindows->isEmpty() && parentWidget) + return parentWidget->minimumHeight(); + + if (cached_width != w) { + Q3DockAreaLayout * mthis = (Q3DockAreaLayout*)this; + mthis->cached_width = w; + int h = mthis->layoutItems(QRect(0, 0, w, 0), true); + mthis->cached_hfw = h; + return h; + } + + return cached_hfw; +} + +int Q3DockAreaLayout::widthForHeight(int h) const +{ + if (cached_height != h) { + Q3DockAreaLayout * mthis = (Q3DockAreaLayout*)this; + mthis->cached_height = h; + int w = mthis->layoutItems(QRect(0, 0, 0, h), true); + mthis->cached_wfh = w; + return w; + } + return cached_wfh; +} + + + + +/*! + \class Q3DockArea + \brief The Q3DockArea class manages and lays out Q3DockWindows. + + \compat + + A Q3DockArea is a container which manages a list of + \l{Q3DockWindow}s which it lays out within its area. In cooperation + with the \l{Q3DockWindow}s it is responsible for the docking and + undocking of \l{Q3DockWindow}s and moving them inside the dock + area. Q3DockAreas also handle the wrapping of \l{Q3DockWindow}s to + fill the available space as compactly as possible. Q3DockAreas can + contain Q3ToolBars since Q3ToolBar is a Q3DockWindow subclass. + + QMainWindow contains four Q3DockAreas which you can use for your + Q3ToolBars and Q3DockWindows, so in most situations you do not + need to use the Q3DockArea class directly. Although QMainWindow + contains support for its own dock areas, you can't add new ones. + You also can't add a Q3DockArea to your own subclass of QWidget. + It won't be shown. + + \img qmainwindow-qdockareas.png QMainWindow's Q3DockAreas + + \target lines + \section1 Lines. + + Q3DockArea uses the concept of lines. A line is a horizontal + region which may contain dock windows side-by-side. A dock area + may have room for more than one line. When dock windows are docked + into a dock area they are usually added at the right hand side of + the top-most line that has room (unless manually placed by the + user). When users move dock windows they may leave empty lines or + gaps in non-empty lines. Qt::Dock windows can be lined up to + minimize wasted space using the lineUp() function. + + The Q3DockArea class maintains a position list of all its child + dock windows. Qt::Dock windows are added to a dock area from position + 0 onwards. Qt::Dock windows are laid out sequentially in position + order from left to right, and in the case of multiple lines of + dock windows, from top to bottom. If a dock window is floated it + still retains its position since this is where the window will + return if the user double clicks its caption. A dock window's + position can be determined with hasDockWindow(). The position can + be changed with moveDockWindow(). + + To dock or undock a dock window use Q3DockWindow::dock() and + Q3DockWindow::undock() respectively. If you want to control which + dock windows can dock in a dock area use setAcceptDockWindow(). To + see if a dock area contains a particular dock window use + \l{hasDockWindow()}; to see how many dock windows a dock area + contains use count(). + + The streaming operators can write the positions of the dock + windows in the dock area to a QTextStream. The positions can be + read back later to restore the saved positions. + + Save the positions to a QTextStream: + \snippet doc/src/snippets/code/src_qt3support_widgets_q3dockarea.cpp 0 + + Restore the positions from a QTextStream: + \snippet doc/src/snippets/code/src_qt3support_widgets_q3dockarea.cpp 1 +*/ + +/*! + \property Q3DockArea::handlePosition + \brief where the dock window splitter handle is placed in the dock + area + + The default position is \c Normal. +*/ + +/*! + \property Q3DockArea::orientation + \brief the dock area's orientation + + There is no default value; the orientation is specified in the + constructor. +*/ + +/*! + \enum Q3DockArea::HandlePosition + + A dock window has two kinds of handles, the dock window handle + used for dragging the dock window, and the splitter handle used to + resize the dock window in relation to other dock windows using a + splitter. (The splitter handle is only visible for docked + windows.) + + This enum specifies where the dock window splitter handle is + placed in the dock area. + + \value Normal The splitter handles of dock windows are placed at + the right or bottom. + + \value Reverse The splitter handles of dock windows are placed at + the left or top. +*/ + +/*! + Constructs a Q3DockArea with orientation \a o, HandlePosition \a h, + parent \a parent and called \a name. +*/ + +Q3DockArea::Q3DockArea(Qt::Orientation o, HandlePosition h, QWidget *parent, const char *name) + : QWidget(parent, name), orient(o), layout(0), hPos(h) +{ + layout = new Q3DockAreaLayout(this, o, &dockWindows, 0, 0, "toollayout"); + installEventFilter(this); +} + +/*! + Destroys the dock area and all the dock windows docked in the dock + area. + + Does not affect any floating dock windows or dock windows in other + dock areas, even if they first appeared in this dock area. + Floating dock windows are effectively top level windows and are + not child windows of the dock area. When a floating dock window is + docked (dragged into a dock area) its parent becomes the dock + area. +*/ + +Q3DockArea::~Q3DockArea() +{ + while (!dockWindows.isEmpty()) + delete dockWindows.takeFirst(); +} + +/*! + Moves the Q3DockWindow \a w within the dock area. If \a w is not + already docked in this area, \a w is docked first. If \a index is + -1 or larger than the number of docked widgets, \a w is appended + at the end, otherwise it is inserted at the position \a index. +*/ + +void Q3DockArea::moveDockWindow(Q3DockWindow *w, int index) +{ + invalidateFixedSizes(); + Q3DockWindow *dockWindow = 0; + int dockWindowIndex = findDockWindow(w); + if (dockWindowIndex == -1) { + dockWindow = w; + bool vis = dockWindow->isVisible(); + dockWindow->setParent(this); + dockWindow->move(0, 0); + if(vis) + dockWindow->show(); + w->installEventFilter(this); + updateLayout(); + setSizePolicy(QSizePolicy(orientation() == Qt::Horizontal ? QSizePolicy::Expanding : QSizePolicy::Minimum, + orientation() == Qt::Vertical ? QSizePolicy::Expanding : QSizePolicy::Minimum)); + dockWindows.append(w); + } else { + if (w->parent() != this) { + bool vis = w->isVisible(); + w->setParent(this); + w->move(0, 0); + if(vis) + w->show(); + } + if (index == -1) { + dockWindows.removeAll(w); + dockWindows.append(w); + } + } + + w->dockArea = this; + w->curPlace = Q3DockWindow::InDock; + w->updateGui(); + + if (index != -1 && index < (int)dockWindows.count()) { + dockWindows.removeAll(w); + dockWindows.insert(index, w); + } +} + +/*! + Returns true if the dock area contains the dock window \a w; + otherwise returns false. If \a index is not 0 it will be set as + follows: if the dock area contains the dock window *\a{index} is + set to \a w's index position; otherwise *\a{index} is set to -1. +*/ + +bool Q3DockArea::hasDockWindow(Q3DockWindow *w, int *index) +{ + int i = dockWindows.indexOf(w); + if (index) + *index = i; + return i != -1; +} + +int Q3DockArea::lineOf(int index) +{ + QList<Q3DockWindow *> lineStarts = layout->lineStarts(); + int i = 0; + for (; i < lineStarts.size(); ++i) { + Q3DockWindow *w = lineStarts.at(i); + if (dockWindows.indexOf(w) >= index) + return i; + } + return i; +} + +/*! + \overload + + Moves the dock window \a w inside the dock area where \a p is the + new position (in global screen coordinates), \a r is the suggested + rectangle of the dock window and \a swap specifies whether or not + the orientation of the docked widget needs to be changed. + + This function is used internally by Q3DockWindow. You shouldn't + need to call it yourself. +*/ + +void Q3DockArea::moveDockWindow(Q3DockWindow *w, const QPoint &p, const QRect &r, bool swap) +{ + invalidateFixedSizes(); + int mse = -10; + bool hasResizable = false; + for (int i = 0; i < dockWindows.size(); ++i) { + Q3DockWindow *dw = dockWindows.at(i); + if (dw->isHidden()) + continue; + if (dw->isResizeEnabled()) + hasResizable = true; + if (orientation() != Qt::Horizontal) + mse = qMax(qMax(dw->fixedExtent().width(), dw->width()), mse); + else + mse = qMax(qMax(dw->fixedExtent().height(), dw->height()), mse); + } + if (!hasResizable && w->isResizeEnabled()) { + if (orientation() != Qt::Horizontal) + mse = qMax(w->fixedExtent().width(), mse); + else + mse = qMax(w->fixedExtent().height(), mse); + } + + Q3DockWindow *dockWindow = 0; + int dockWindowIndex = findDockWindow(w); + QList<Q3DockWindow *> lineStarts = layout->lineStarts(); + QList<QRect> lines = layout->lineList(); + bool wasAloneInLine = false; + QPoint pos = mapFromGlobal(p); + int line = lineOf(dockWindowIndex); + QRect lr; + if (line < lines.size()) + lr = lines.at(line); + if (dockWindowIndex != -1) { + if (lineStarts.contains(w) + && ((dockWindowIndex < dockWindows.count() - 1 + && lineStarts.contains(dockWindows.at(dockWindowIndex + 1))) + || dockWindowIndex == dockWindows.count() - 1)) + wasAloneInLine = true; + dockWindow = dockWindows.takeAt(dockWindowIndex); + if (!wasAloneInLine) { // only do the pre-layout if the widget isn't the only one in its line + if (lineStarts.contains(dockWindow) && dockWindowIndex < dockWindows.count()) + dockWindows.at(dockWindowIndex)->setNewLine(true); + layout->layoutItems(QRect(0, 0, width(), height()), true); + } + } else { + dockWindow = w; + bool vis = dockWindow->isVisible(); + dockWindow->setParent(this); + dockWindow->move(0, 0); + if(vis) + dockWindow->show(); + if (swap) + dockWindow->resize(dockWindow->height(), dockWindow->width()); + w->installEventFilter(this); + } + + lineStarts = layout->lineStarts(); + lines = layout->lineList(); + + QRect rect = QRect(mapFromGlobal(r.topLeft()), r.size()); + if (orientation() == Qt::Horizontal && QApplication::reverseLayout()) { + rect = QRect(width() - rect.x() - rect.width(), rect.y(), rect.width(), rect.height()); + pos.rx() = width() - pos.x(); + } + dockWindow->setOffset(point_pos(rect.topLeft(), orientation())); + if (orientation() == Qt::Horizontal) { + int offs = dockWindow->offset(); + if (width() - offs < dockWindow->minimumWidth()) + dockWindow->setOffset(width() - dockWindow->minimumWidth()); + } else { + int offs = dockWindow->offset(); + if (height() - offs < dockWindow->minimumHeight()) + dockWindow->setOffset(height() - dockWindow->minimumHeight()); + } + + if (dockWindows.isEmpty()) { + dockWindows.append(dockWindow); + } else { + int dockLine = -1; + bool insertLine = false; + int i = 0; + QRect lineRect; + // find the line which we touched with the mouse + for (QList<QRect>::Iterator it = lines.begin(); it != lines.end(); ++it, ++i) { + if (point_pos(pos, orientation(), true) >= point_pos((*it).topLeft(), orientation(), true) && + point_pos(pos, orientation(), true) <= point_pos((*it).topLeft(), orientation(), true) + + size_extent((*it).size(), orientation(), true)) { + dockLine = i; + lineRect = *it; + break; + } + } + if (dockLine == -1) { // outside the dock... + insertLine = true; + if (point_pos(pos, orientation(), true) < 0) // insert as first line + dockLine = 0; + else + dockLine = (int)lines.count(); // insert after the last line ### size_t/int cast + } else { // inside the dock (we have found a dockLine) + if (point_pos(pos, orientation(), true) < + point_pos(lineRect.topLeft(), orientation(), true) + 4) { // mouse was at the very beginning of the line + insertLine = true; // insert a new line before that with the docking widget + } else if (point_pos(pos, orientation(), true) > + point_pos(lineRect.topLeft(), orientation(), true) + + size_extent(lineRect.size(), orientation(), true) - 4) { // mouse was at the very and of the line + insertLine = true; // insert a line after that with the docking widget + dockLine++; + } + } + + if (!insertLine && wasAloneInLine && lr.contains(pos)) // if we are alone in a line and just moved in there, re-insert it + insertLine = true; + +#if defined(QDOCKAREA_DEBUG) + qDebug("insert in line %d, and insert that line: %d", dockLine, insertLine); + qDebug(" (btw, we have %d lines)", lines.count()); +#endif + Q3DockWindow *dw = 0; + if (dockLine >= (int)lines.count()) { // insert after last line + dockWindows.append(dockWindow); + dockWindow->setNewLine(true); +#if defined(QDOCKAREA_DEBUG) + qDebug("insert at the end"); +#endif + } else if (dockLine == 0 && insertLine) { // insert before first line + dockWindows.insert(0, dockWindow); + dockWindows.at(1)->setNewLine(true); +#if defined(QDOCKAREA_DEBUG) + qDebug("insert at the begin"); +#endif + } else { // insert somewhere in between + // make sure each line start has a new line + for (int i = 0; i < lineStarts.size(); ++i) { + dw = lineStarts.at(i); + dw->setNewLine(true); + } + + // find the index of the first widget in the search line + int searchLine = dockLine; +#if defined(QDOCKAREA_DEBUG) + qDebug("search line start of %d", searchLine); +#endif + Q3DockWindow *lsw = lineStarts.at(searchLine); + int index = dockWindows.indexOf(lsw); + if (index == -1) { // the linestart widget hasn't been found, try to find it harder + if (lsw == w && dockWindowIndex <= dockWindows.count()) + index = dockWindowIndex; + else + index = 0; + } +#if defined(QDOCKAREA_DEBUG) + qDebug(" which starts at %d", index); +#endif + if (!insertLine) { // if we insert the docking widget in the existing line + // find the index for the widget + bool inc = true; + bool firstTime = true; + for (int i = index; i < dockWindows.size(); ++i) { + dw = dockWindows.at(i); + if (orientation() == Qt::Horizontal) + dw->setFixedExtentWidth(-1); + else + dw->setFixedExtentHeight(-1); + if (!firstTime && lineStarts.contains(dw)) // we are in the next line, so break + break; + if (point_pos(pos, orientation()) < + point_pos(fix_pos(dw), orientation()) + size_extent(dw->size(), orientation()) / 2) { + inc = false; + } + if (inc) + index++; + firstTime = false; + } +#if defined(QDOCKAREA_DEBUG) + qDebug("insert at index: %d", index); +#endif + // if we insert it just before a widget which has a new line, transfer the newline to the docking widget + // but not if we didn't only mave a widget in its line which was alone in the line before + if (!(wasAloneInLine && lr.contains(pos)) + && index >= 0 && index < dockWindows.count() && + dockWindows.at(index)->newLine() && lineOf(index) == dockLine) { +#if defined(QDOCKAREA_DEBUG) + qDebug("get rid of the old newline and get me one"); +#endif + dockWindows.at(index)->setNewLine(false); + dockWindow->setNewLine(true); + } else if (wasAloneInLine && lr.contains(pos)) { + dockWindow->setNewLine(true); + } else { // if we are somewhere in a line, get rid of the newline + dockWindow->setNewLine(false); + } + } else { // insert in a new line, so make sure the dock widget and the widget which will be after it have a newline +#if defined(QDOCKAREA_DEBUG) + qDebug("insert a new line"); +#endif + if (index < dockWindows.count()) { +#if defined(QDOCKAREA_DEBUG) + qDebug("give the widget at %d a newline", index); +#endif + Q3DockWindow* nldw = dockWindows.at(index); + if (nldw) + nldw->setNewLine(true); + } +#if defined(QDOCKAREA_DEBUG) + qDebug("give me a newline"); +#endif + dockWindow->setNewLine(true); + } + // finally insert the widget + dockWindows.insert(index, dockWindow); + } + } + + if (mse != -10 && w->isResizeEnabled()) { + if (orientation() != Qt::Horizontal) + w->setFixedExtentWidth(qMin(qMax(w->minimumWidth(), mse), w->sizeHint().width())); + else + w->setFixedExtentHeight(qMin(qMax(w->minimumHeight(), mse), w->sizeHint().height())); + } + + updateLayout(); + setSizePolicy(QSizePolicy(orientation() == Qt::Horizontal ? QSizePolicy::Expanding : QSizePolicy::Minimum, + orientation() == Qt::Vertical ? QSizePolicy::Expanding : QSizePolicy::Minimum)); +} + +/*! + Removes the dock window \a w from the dock area. If \a + makeFloating is true, \a w gets floated, and if \a swap is true, + the orientation of \a w gets swapped. If \a fixNewLines is true + (the default) newlines in the area will be fixed. + + You should never need to call this function yourself. Use + Q3DockWindow::dock() and Q3DockWindow::undock() instead. +*/ + +void Q3DockArea::removeDockWindow(Q3DockWindow *w, bool makeFloating, bool swap, bool fixNewLines) +{ + w->removeEventFilter(this); + Q3DockWindow *dockWindow = 0; + int i = findDockWindow(w); + if (i == -1) + return; + dockWindow = dockWindows.at(i); + dockWindows.removeAt(i); + QList<Q3DockWindow *> lineStarts = layout->lineStarts(); + if (fixNewLines && lineStarts.contains(dockWindow) && i < dockWindows.count()) + dockWindows.at(i)->setNewLine(true); + if (makeFloating) { + QWidget *p = parentWidget() ? parentWidget() : window(); + dockWindow->setParent(p, Qt::WType_Dialog | Qt::WStyle_Customize | Qt::WStyle_NoBorder | Qt::WStyle_Tool); + dockWindow->move(0, 0); + } + if (swap) + dockWindow->resize(dockWindow->height(), dockWindow->width()); + updateLayout(); + if (dockWindows.isEmpty()) + setSizePolicy(QSizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred)); +} + +int Q3DockArea::findDockWindow(Q3DockWindow *w) +{ + return dockWindows.indexOf(w); +} + +void Q3DockArea::updateLayout() +{ + layout->invalidate(); + layout->activate(); +} + +/*! \reimp + */ + +bool Q3DockArea::eventFilter(QObject *o, QEvent *e) +{ + if (e->type() == QEvent::Close) { + if (qobject_cast<Q3DockWindow*>(o)) { + o->removeEventFilter(this); + QApplication::sendEvent(o, e); + if (((QCloseEvent*)e)->isAccepted()) + removeDockWindow((Q3DockWindow*)o, false, false); + return true; + } + } + return false; +} + +/*! \internal + + Invalidates the offset of the next dock window in the dock area. + */ + +void Q3DockArea::invalidNextOffset(Q3DockWindow *dw) +{ + int i = dockWindows.indexOf(dw); + if (i == -1 || i >= (int)dockWindows.count() - 1) + return; + if ((dw = dockWindows.at(++i))) + dw->setOffset(0); +} + +/*! + \property Q3DockArea::count + \brief the number of dock windows in the dock area +*/ +int Q3DockArea::count() const +{ + return dockWindows.count(); +} + +/*! + \property Q3DockArea::empty + \brief whether the dock area is empty +*/ + +bool Q3DockArea::isEmpty() const +{ + return dockWindows.isEmpty(); +} + + +/*! + Returns a list of the dock windows in the dock area. +*/ + +QList<Q3DockWindow *> Q3DockArea::dockWindowList() const +{ + return dockWindows; +} + +/*! + Lines up the dock windows in this dock area to minimize wasted + space. If \a keepNewLines is true, only space within lines is + cleaned up. If \a keepNewLines is false the number of lines might + be changed. +*/ + +void Q3DockArea::lineUp(bool keepNewLines) +{ + for (int i = 0; i < dockWindows.size(); ++i) { + Q3DockWindow *dw = dockWindows.at(i); + dw->setOffset(0); + if (!keepNewLines) + dw->setNewLine(false); + } + layout->invalidate(); + layout->activate(); +} + +Q3DockArea::DockWindowData *Q3DockArea::dockWindowData(Q3DockWindow *w) +{ + DockWindowData *data = new DockWindowData; + data->index = findDockWindow(w); + if (data->index == -1) { + delete data; + return 0; + } + QList<Q3DockWindow *> lineStarts = layout->lineStarts(); + int i = -1; + for (int j = 0; j < dockWindows.size(); ++j) { + Q3DockWindow *dw = dockWindows.at(j); + if (lineStarts.contains(dw)) + ++i; + if (dw == w) + break; + } + data->line = i; + data->offset = point_pos(QPoint(fix_x(w), w->y()), orientation()); + data->area = this; + data->fixedExtent = w->fixedExtent(); + return data; +} + +void Q3DockArea::dockWindow(Q3DockWindow *dockWindow, DockWindowData *data) +{ + if (!data) + return; + + dockWindow->setParent(this); + dockWindow->move(0, 0); + + dockWindow->installEventFilter(this); + dockWindow->dockArea = this; + dockWindow->updateGui(); + + if (dockWindows.isEmpty()) { + dockWindows.append(dockWindow); + } else { + QList<Q3DockWindow *> lineStarts = layout->lineStarts(); + int index = 0; + if (lineStarts.count() > data->line) + index = dockWindows.indexOf(lineStarts.at(data->line)); + if (index == -1) + index = 0; + bool firstTime = true; + int offset = data->offset; + for (int i = index; i < dockWindows.size(); ++i) { + Q3DockWindow *dw = dockWindows.at(i); + if (!firstTime && lineStarts.contains(dw)) + break; + if (offset < + point_pos(fix_pos(dw), orientation()) + size_extent(dw->size(), orientation()) / 2) + break; + index++; + firstTime = false; + } + if (index >= 0 && index < dockWindows.count() && + dockWindows.at(index)->newLine() && lineOf(index) == data->line) { + dockWindows.at(index)->setNewLine(false); + dockWindow->setNewLine(true); + } else { + dockWindow->setNewLine(false); + } + + dockWindows.insert(index, dockWindow); + } + dockWindow->show(); + + dockWindow->setFixedExtentWidth(data->fixedExtent.width()); + dockWindow->setFixedExtentHeight(data->fixedExtent.height()); + + updateLayout(); + setSizePolicy(QSizePolicy(orientation() == Qt::Horizontal ? QSizePolicy::Expanding : QSizePolicy::Minimum, + orientation() == Qt::Vertical ? QSizePolicy::Expanding : QSizePolicy::Minimum)); + +} + +/*! + Returns true if dock window \a dw could be docked into the dock + area; otherwise returns false. + + \sa setAcceptDockWindow() +*/ + +bool Q3DockArea::isDockWindowAccepted(Q3DockWindow *dw) +{ + if (!dw) + return false; + if (forbiddenWidgets.contains(dw)) + return false; + + Q3MainWindow *mw = qobject_cast<Q3MainWindow*>(parentWidget()); + if (!mw) + return true; + if (!mw->hasDockWindow(dw)) + return false; + if (!mw->isDockEnabled(this)) + return false; + if (!mw->isDockEnabled(dw, this)) + return false; + return true; +} + +/*! + If \a accept is true, dock window \a dw can be docked in the dock + area. If \a accept is false, dock window \a dw cannot be docked in + the dock area. + + \sa isDockWindowAccepted() +*/ + +void Q3DockArea::setAcceptDockWindow(Q3DockWindow *dw, bool accept) +{ + if (accept) + forbiddenWidgets.removeAll(dw); + else if (!forbiddenWidgets.contains(dw)) + forbiddenWidgets.append(dw); +} + +void Q3DockArea::invalidateFixedSizes() +{ + for (int i = 0; i < dockWindows.size(); ++i) { + Q3DockWindow *dw = dockWindows.at(i); + if (orientation() == Qt::Horizontal) + dw->setFixedExtentWidth(-1); + else + dw->setFixedExtentHeight(-1); + } +} + +int Q3DockArea::maxSpace(int hint, Q3DockWindow *dw) +{ + int index = findDockWindow(dw); + if (index == -1 || index + 1 >= (int)dockWindows.count()) { + if (orientation() == Qt::Horizontal) + return dw->width(); + return dw->height(); + } + + Q3DockWindow *w = 0; + int i = 0; + do { + w = dockWindows.at(index + (++i)); + } while (i + 1 < (int)dockWindows.count() && (!w || w->isHidden())); + if (!w || !w->isResizeEnabled() || i >= (int)dockWindows.count()) { + if (orientation() == Qt::Horizontal) + return dw->width(); + return dw->height(); + } + int min = 0; + Q3ToolBar *tb = qobject_cast<Q3ToolBar*>(w); + if (orientation() == Qt::Horizontal) { + w->setFixedExtentWidth(-1); + if (!tb) + min = qMax(w->minimumSize().width(), w->minimumSizeHint().width()); + else + min = w->sizeHint().width(); + } else { + w->setFixedExtentHeight(-1); + if (!tb) + min = qMax(w->minimumSize().height(), w->minimumSizeHint().height()); + else + min = w->sizeHint().height(); + } + + int diff = hint - (orientation() == Qt::Horizontal ? dw->width() : dw->height()); + + if ((orientation() == Qt::Horizontal ? w->width() : w->height()) - diff < min) + hint = (orientation() == Qt::Horizontal ? dw->width() : dw->height()) + (orientation() == Qt::Horizontal ? w->width() : w->height()) - min; + + diff = hint - (orientation() == Qt::Horizontal ? dw->width() : dw->height()); + if (orientation() == Qt::Horizontal) + w->setFixedExtentWidth(w->width() - diff); + else + w->setFixedExtentHeight(w->height() - diff); + return hint; +} + +void Q3DockArea::setFixedExtent(int d, Q3DockWindow *dw) +{ + QList<Q3DockWindow *> lst; + for (int i = 0; i < dockWindows.size(); ++i) { + Q3DockWindow *w = dockWindows.at(i); + if (w->isHidden()) + continue; + if (orientation() == Qt::Horizontal) { + if (dw->y() != w->y()) + continue; + } else { + if (dw->x() != w->x()) + continue; + } + if (orientation() == Qt::Horizontal) + d = qMax(d, w->minimumHeight()); + else + d = qMax(d, w->minimumWidth()); + if (w->isResizeEnabled()) + lst.append(w); + } + for (int i = 0; i < lst.size(); ++i) { + Q3DockWindow *w = lst.at(i); + if (orientation() == Qt::Horizontal) + w->setFixedExtentHeight(d); + else + w->setFixedExtentWidth(d); + } +} + +bool Q3DockArea::isLastDockWindow(Q3DockWindow *dw) +{ + int i = dockWindows.indexOf(dw); + if (i == -1 || i >= (int)dockWindows.count() - 1) + return true; + Q3DockWindow *w = 0; + if ((w = dockWindows.at(++i))) { + if (orientation() == Qt::Horizontal && dw->y() < w->y()) + return true; + if (orientation() == Qt::Vertical && dw->x() < w->x()) + return true; + } else { + return true; + } + return false; +} + +#ifndef QT_NO_TEXTSTREAM + +/*! + \relates Q3DockArea + + Writes the layout of the dock windows in dock area \a dockArea to + the text stream \a ts. +*/ + +QTextStream &operator<<(QTextStream &ts, const Q3DockArea &dockArea) +{ + QString str; + QList<Q3DockWindow *> l = dockArea.dockWindowList(); + + for (int i = 0; i < l.size(); ++i) { + Q3DockWindow *dw = l.at(i); + str += QLatin1Char('[') + QString(dw->windowTitle()) + QLatin1Char(',') + QString::number((int)dw->offset()) + + QLatin1Char(',') + QString::number((int)dw->newLine()) + QLatin1Char(',') + QString::number(dw->fixedExtent().width()) + + QLatin1Char(',') + QString::number(dw->fixedExtent().height()) + QLatin1Char(',') + QString::number((int)!dw->isHidden()) + QLatin1Char(']'); + } + ts << str << endl; + + return ts; +} + +/*! + \relates Q3DockArea + + Reads the layout description of the dock windows in dock area \a + dockArea from the text stream \a ts and restores it. The layout + description must have been previously written by the operator<<() + function. +*/ + +QTextStream &operator>>(QTextStream &ts, Q3DockArea &dockArea) +{ + QString s = ts.readLine(); + + QString name, offset, newLine, width, height, visible; + + enum State { Pre, Name, Offset, NewLine, Width, Height, Visible, Post }; + int state = Pre; + QChar c; + QList<Q3DockWindow *> l = dockArea.dockWindowList(); + + for (int i = 0; i < s.length(); ++i) { + c = s[i]; + if (state == Pre && c == QLatin1Char('[')) { + state++; + continue; + } + if (c == QLatin1Char(',') && + (state == Name || state == Offset || state == NewLine || state == Width || state == Height)) { + state++; + continue; + } + if (state == Visible && c == QLatin1Char(']')) { + for (int j = 0; j < l.size(); ++j) { + Q3DockWindow *dw = l.at(j); + if (QString(dw->windowTitle()) == name) { + dw->setNewLine((bool)newLine.toInt()); + dw->setOffset(offset.toInt()); + dw->setFixedExtentWidth(width.toInt()); + dw->setFixedExtentHeight(height.toInt()); + if (!(bool)visible.toInt()) + dw->hide(); + else + dw->show(); + break; + } + } + + name = offset = newLine = width = height = visible = QLatin1String(""); + + state = Pre; + continue; + } + if (state == Name) + name += c; + else if (state == Offset) + offset += c; + else if (state == NewLine) + newLine += c; + else if (state == Width) + width += c; + else if (state == Height) + height += c; + else if (state == Visible) + visible += c; + } + + dockArea.QWidget::layout()->invalidate(); + dockArea.QWidget::layout()->activate(); + return ts; +} +#endif + +QT_END_NAMESPACE + +#endif //QT_NO_MAINWINDOW diff --git a/src/qt3support/widgets/q3dockarea.h b/src/qt3support/widgets/q3dockarea.h new file mode 100644 index 0000000..a784d37 --- /dev/null +++ b/src/qt3support/widgets/q3dockarea.h @@ -0,0 +1,199 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the Qt3Support module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, 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 qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef Q3DOCKAREA_H +#define Q3DOCKAREA_H + +#include <QtGui/qwidget.h> +#include <QtCore/qlist.h> +#include <Qt3Support/q3dockwindow.h> +#include <QtGui/qlayout.h> +#include <QtCore/qpointer.h> + +QT_BEGIN_HEADER + +QT_BEGIN_NAMESPACE + +QT_MODULE(Qt3SupportLight) + +#ifndef QT_NO_MAINWINDOW + +class QBoxLayout; +class Q3DockAreaLayout; +class QMouseEvent; +class Q3DockWindowResizeHandle; +class Q3DockAreaPrivate; +class QTextStream; + +class Q_COMPAT_EXPORT Q3DockAreaLayout : public QLayout +{ + Q_OBJECT + friend class Q3DockArea; + +public: + Q3DockAreaLayout(QWidget* parent, Qt::Orientation o, QList<Q3DockWindow *> *wl, int space = -1, int margin = -1, const char *name = 0) + : QLayout(parent), orient(o), dirty(true), dockWindows(wl), parentWidget(parent) + { + if (space != -1) + setSpacing(space); + if (margin != -1) + setMargin(margin); + setObjectName(QString::fromAscii(name)); + init(); + } + ~Q3DockAreaLayout() {} + + void addItem(QLayoutItem *) {} + bool hasHeightForWidth() const; + int heightForWidth(int) const; + int widthForHeight(int) const; + QSize sizeHint() const; + QSize minimumSize() const; + QLayoutItem *itemAt(int) const; + QLayoutItem *takeAt(int); + int count() const; + Qt::Orientations expandingDirections() const { return Qt::Orientations(0); } + void invalidate(); + Qt::Orientation orientation() const { return orient; } + QList<QRect> lineList() const { return lines; } + QList<Q3DockWindow *> lineStarts() const { return ls; } + +protected: + void setGeometry(const QRect&); + +private: + Q_DISABLE_COPY(Q3DockAreaLayout) + + void init(); + int layoutItems(const QRect&, bool testonly = false); + Qt::Orientation orient; + bool dirty; + int cached_width, cached_height; + int cached_hfw, cached_wfh; + QList<Q3DockWindow *> *dockWindows; + QWidget *parentWidget; + QList<QRect> lines; + QList<Q3DockWindow *> ls; +}; + +class Q_COMPAT_EXPORT Q3DockArea : public QWidget +{ + Q_OBJECT + Q_ENUMS(HandlePosition) + Q_PROPERTY(Qt::Orientation orientation READ orientation) + Q_PROPERTY(int count READ count) + Q_PROPERTY(bool empty READ isEmpty) + Q_PROPERTY(HandlePosition handlePosition READ handlePosition) + + friend class Q3DockWindow; + friend class Q3DockWindowResizeHandle; + friend class Q3DockAreaLayout; + +public: + enum HandlePosition { Normal, Reverse }; + + Q3DockArea(Qt::Orientation o, HandlePosition h = Normal, QWidget* parent=0, const char* name=0); + ~Q3DockArea(); + + void moveDockWindow(Q3DockWindow *w, const QPoint &globalPos, const QRect &rect, bool swap); + void removeDockWindow(Q3DockWindow *w, bool makeFloating, bool swap, bool fixNewLines = true); + void moveDockWindow(Q3DockWindow *w, int index = -1); + bool hasDockWindow(Q3DockWindow *w, int *index = 0); + + void invalidNextOffset(Q3DockWindow *dw); + + Qt::Orientation orientation() const { return orient; } + HandlePosition handlePosition() const { return hPos; } + + bool eventFilter(QObject *, QEvent *); + bool isEmpty() const; + int count() const; + QList<Q3DockWindow *> dockWindowList() const; + + bool isDockWindowAccepted(Q3DockWindow *dw); + void setAcceptDockWindow(Q3DockWindow *dw, bool accept); + +public Q_SLOTS: + void lineUp(bool keepNewLines); + +private: + struct DockWindowData + { + int index; + int offset; + int line; + QSize fixedExtent; + QPointer<Q3DockArea> area; + }; + + int findDockWindow(Q3DockWindow *w); + int lineOf(int index); + DockWindowData *dockWindowData(Q3DockWindow *w); + void dockWindow(Q3DockWindow *dockWindow, DockWindowData *data); + void updateLayout(); + void invalidateFixedSizes(); + int maxSpace(int hint, Q3DockWindow *dw); + void setFixedExtent(int d, Q3DockWindow *dw); + bool isLastDockWindow(Q3DockWindow *dw); + +private: + Q_DISABLE_COPY(Q3DockArea) + + Qt::Orientation orient; + QList<Q3DockWindow *> dockWindows; + Q3DockAreaLayout *layout; + HandlePosition hPos; + QList<Q3DockWindow *> forbiddenWidgets; + Q3DockAreaPrivate *d; +}; + +#ifndef QT_NO_TEXTSTREAM +Q_COMPAT_EXPORT QTextStream &operator<<(QTextStream &, const Q3DockArea &); +Q_COMPAT_EXPORT QTextStream &operator>>(QTextStream &, Q3DockArea &); +#endif + +#endif // QT_NO_MAINWINDOW + +QT_END_NAMESPACE + +QT_END_HEADER + +#endif // Q3DOCKAREA_H diff --git a/src/qt3support/widgets/q3dockwindow.cpp b/src/qt3support/widgets/q3dockwindow.cpp new file mode 100644 index 0000000..c6e491c --- /dev/null +++ b/src/qt3support/widgets/q3dockwindow.cpp @@ -0,0 +1,2115 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the Qt3Support module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, 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 qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "q3dockwindow.h" + +#ifndef QT_NO_MAINWINDOW +#include "qapplication.h" +#include "qcursor.h" +#include "qdesktopwidget.h" +#include "q3dockarea.h" +#include "qevent.h" +#include "qlayout.h" +#include "q3mainwindow.h" +#include "qpainter.h" +#include "qpointer.h" +#include "qstyle.h" +#include "qstyleoption.h" +#include "qtimer.h" +#include "q3toolbar.h" +#include "qtoolbutton.h" +#include "qtooltip.h" +#include <private/q3titlebar_p.h> +#include <private/qwidgetresizehandler_p.h> +#include <qrubberband.h> +#include <qdebug.h> + +QT_BEGIN_NAMESPACE + +#ifdef Q_WS_MAC +static bool default_opaque = true; +#else +static bool default_opaque = false; +#endif + +class Q3DockWindowPrivate +{ +}; + +class Q3DockWindowResizeHandle : public QWidget +{ + Q_OBJECT + +public: + Q3DockWindowResizeHandle(Qt::Orientation o, QWidget *parent, Q3DockWindow *w, const char* /*name*/=0); + void setOrientation(Qt::Orientation o); + Qt::Orientation orientation() const { return orient; } + + QSize sizeHint() const; + +protected: + void paintEvent(QPaintEvent *); + void mouseMoveEvent(QMouseEvent *); + void mousePressEvent(QMouseEvent *); + void mouseReleaseEvent(QMouseEvent *); + bool event(QEvent *event); + +private: + void startLineDraw(); + void endLineDraw(); + void drawLine(const QPoint &globalPos); + +private: + Qt::Orientation orient; + bool mousePressed; + QRubberBand *rubberBand; + QPoint lastPos, firstPos; + Q3DockWindow *dockWindow; + bool mouseOver; +}; + +Q3DockWindowResizeHandle::Q3DockWindowResizeHandle(Qt::Orientation o, QWidget *parent, + Q3DockWindow *w, const char *) + : QWidget(parent, "qt_dockwidget_internal"), mousePressed(false), rubberBand(0), dockWindow(w), + mouseOver(false) +{ + setOrientation(o); +} + +QSize Q3DockWindowResizeHandle::sizeHint() const +{ + QStyleOptionQ3DockWindow opt; + opt.init(this); + if (!dockWindow->area() || dockWindow->area()->orientation() == Qt::Horizontal) + opt.state |= QStyle::State_Horizontal; + + opt.rect = rect(); + opt.docked = dockWindow->area(); + opt.closeEnabled = dockWindow->isCloseEnabled(); + int sw = 2 * style()->pixelMetric(QStyle::PM_SplitterWidth, &opt, this) / 3; + return (style()->sizeFromContents(QStyle::CT_Q3DockWindow, &opt, QSize(sw, sw), this).expandedTo(QApplication::globalStrut())); +} + +void Q3DockWindowResizeHandle::setOrientation(Qt::Orientation o) +{ + orient = o; + if (o == Qt::Horizontal) { +#ifndef QT_NO_CURSOR + setCursor(Qt::splitVCursor); +#endif + setSizePolicy(QSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed)); + } else { +#ifndef QT_NO_CURSOR + setCursor(Qt::splitHCursor); +#endif + setSizePolicy(QSizePolicy(QSizePolicy::Fixed, QSizePolicy::Expanding)); + } +} + +void Q3DockWindowResizeHandle::mousePressEvent(QMouseEvent *e) +{ + e->ignore(); + if (e->button() != Qt::LeftButton) + return; + e->accept(); + mousePressed = true; + if (!dockWindow->opaqueMoving()) + startLineDraw(); + lastPos = firstPos = e->globalPos(); + if (!dockWindow->opaqueMoving()) + drawLine(e->globalPos()); +} + +void Q3DockWindowResizeHandle::mouseMoveEvent(QMouseEvent *e) +{ + if (!mousePressed) + return; + if (!dockWindow->opaqueMoving()) { + if (orientation() != dockWindow->area()->orientation()) { + if (orientation() == Qt::Horizontal) { + int minpos = dockWindow->area()->mapToGlobal(QPoint(0, 0)).y(); + int maxpos = dockWindow->area()->mapToGlobal(QPoint(0, 0)).y() + dockWindow->area()->height(); + if (e->globalPos().y() < minpos || e->globalPos().y() > maxpos) + return; + } else { + int minpos = dockWindow->area()->mapToGlobal(QPoint(0, 0)).x(); + int maxpos = dockWindow->area()->mapToGlobal(QPoint(0, 0)).x() + dockWindow->area()->width(); + if (e->globalPos().x() < minpos || e->globalPos().x() > maxpos) + return; + } + } else { + QWidget *w = dockWindow->area()->window(); + if (w) { + if (orientation() == Qt::Horizontal) { + int minpos = w->mapToGlobal(QPoint(0, 0)).y(); + int maxpos = w->mapToGlobal(QPoint(0, 0)).y() + w->height(); + if (e->globalPos().y() < minpos || e->globalPos().y() > maxpos) + return; + } else { + int minpos = w->mapToGlobal(QPoint(0, 0)).x(); + int maxpos = w->mapToGlobal(QPoint(0, 0)).x() + w->width(); + if (e->globalPos().x() < minpos || e->globalPos().x() > maxpos) + return; + } + } + } + } + + if (!dockWindow->opaqueMoving()) + drawLine(lastPos); + lastPos = e->globalPos(); + if (dockWindow->opaqueMoving()) { + mouseReleaseEvent(e); + mousePressed = true; + firstPos = e->globalPos(); + } + if (!dockWindow->opaqueMoving()) + drawLine(e->globalPos()); +} + +void Q3DockWindowResizeHandle::mouseReleaseEvent(QMouseEvent *e) +{ + if (mousePressed) { + if (!dockWindow->opaqueMoving()) { + drawLine(lastPos); + endLineDraw(); + } + if (orientation() != dockWindow->area()->orientation()) + dockWindow->area()->invalidNextOffset(dockWindow); + if (orientation() == Qt::Horizontal) { + int dy; + if (dockWindow->area()->handlePosition() == Q3DockArea::Normal || orientation() != dockWindow->area()->orientation()) + dy = e->globalPos().y() - firstPos.y(); + else + dy = firstPos.y() - e->globalPos().y(); + int d = dockWindow->height() + dy; + if (orientation() != dockWindow->area()->orientation()) { + dockWindow->setFixedExtentHeight(-1); + d = qMax(d, dockWindow->minimumHeight()); + int ms = dockWindow->area()->maxSpace(d, dockWindow); + d = qMin(d, ms); + dockWindow->setFixedExtentHeight(d); + } else { + dockWindow->area()->setFixedExtent(d, dockWindow); + } + } else { + int dx; + if (dockWindow->area()->handlePosition() == Q3DockArea::Normal || orientation() != dockWindow->area()->orientation()) + dx = e->globalPos().x() - firstPos.x(); + else + dx = firstPos.x() - e->globalPos().x(); + int d = dockWindow->width() + dx; + if (orientation() != dockWindow->area()->orientation()) { + dockWindow->setFixedExtentWidth(-1); + d = qMax(d, dockWindow->minimumWidth()); + int ms = dockWindow->area()->maxSpace(d, dockWindow); + d = qMin(d, ms); + dockWindow->setFixedExtentWidth(d); + } else { + dockWindow->area()->setFixedExtent(d, dockWindow); + } + } + } + + QApplication::postEvent(dockWindow->area(), new QEvent(QEvent::LayoutHint)); + mousePressed = false; +} + +bool Q3DockWindowResizeHandle::event(QEvent *event) +{ + switch (event->type()) { + case QEvent::HoverEnter: + if (!mouseOver) { + mouseOver = true; + update(); + } + break; + case QEvent::HoverLeave: + if (mouseOver) { + mouseOver = false; + update(); + } + break; + default: + break; + } + return QWidget::event(event); +} + +void Q3DockWindowResizeHandle::paintEvent(QPaintEvent *) +{ + QPainter p(this); + QStyleOption opt(0); + opt.init(this); + if (orientation() == Qt::Horizontal) + opt.state |= QStyle::State_Horizontal; + style()->drawPrimitive(QStyle::PE_IndicatorDockWidgetResizeHandle, &opt, &p, this); +} + +void Q3DockWindowResizeHandle::startLineDraw() +{ + if (rubberBand) + endLineDraw(); + rubberBand = new QRubberBand(QRubberBand::Line); + rubberBand->setGeometry(-1, -1, 1, 1); + rubberBand->show(); +} + +void Q3DockWindowResizeHandle::endLineDraw() +{ + delete rubberBand; + rubberBand = 0; +} + +void Q3DockWindowResizeHandle::drawLine(const QPoint &globalPos) +{ + QPoint start = mapToGlobal(QPoint(0, 0)); + QPoint starta = dockWindow->area()->mapToGlobal(QPoint(0, 0)); + QPoint end = globalPos; + if (orientation() == Qt::Horizontal) { + if (orientation() == dockWindow->orientation()) + rubberBand->setGeometry(starta.x(), end.y(), dockWindow->area()->width(), height()); + else + rubberBand->setGeometry(start.x(), end.y(), width(), height()); + } else { + if (orientation() == dockWindow->orientation()) + rubberBand->setGeometry(end.x(), starta.y(), width(), dockWindow->area()->height()); + else + rubberBand->setGeometry(end.x(), start.y(), width(), height()); + } +} + +static QPoint realWidgetPos(Q3DockWindow *w) +{ + if (!w->parentWidget() || w->place() == Q3DockWindow::OutsideDock) + return w->pos(); + return w->parentWidget()->mapToGlobal(w->geometry().topLeft()); +} + +class Q3DockWindowHandle : public QWidget +{ + Q_OBJECT + Q_PROPERTY(QString windowTitle READ windowTitle) + friend class Q3DockWindow; + friend class Q3DockWindowTitleBar; + +public: + Q3DockWindowHandle(Q3DockWindow *dw); + void updateGui(); + + QSize minimumSizeHint() const; + QSize minimumSize() const { return minimumSizeHint(); } + QSize sizeHint() const { return minimumSize(); } + void setOpaqueMoving(bool b) { opaque = b; } + + QString windowTitle() const { return dockWindow->windowTitle(); } + +signals: + void doubleClicked(); + +protected: + void paintEvent(QPaintEvent *e); + void resizeEvent(QResizeEvent *e); + void mousePressEvent(QMouseEvent *e); + void mouseMoveEvent(QMouseEvent *e); + void mouseReleaseEvent(QMouseEvent *e); + void mouseDoubleClickEvent(QMouseEvent *e); + void keyPressEvent(QKeyEvent *e); + void keyReleaseEvent(QKeyEvent *e); + void changeEvent(QEvent *); + +private slots: + void minimize(); + +private: + Q3DockWindow *dockWindow; + QPoint offset; + QToolButton *closeButton; + QTimer *timer; + uint opaque : 1; + uint mousePressed : 1; + uint hadDblClick : 1; + uint ctrlDown : 1; + QPointer<QWidget> oldFocus; +}; + +class Q3DockWindowTitleBar : public Q3TitleBar +{ + Q_OBJECT + friend class Q3DockWindow; + friend class Q3DockWindowHandle; + +public: + Q3DockWindowTitleBar(Q3DockWindow *dw); + void updateGui(); + void setOpaqueMoving(bool b) { opaque = b; } + +protected: + void resizeEvent(QResizeEvent *e); + void mousePressEvent(QMouseEvent *e); + void mouseMoveEvent(QMouseEvent *e); + void mouseReleaseEvent(QMouseEvent *e); + void mouseDoubleClickEvent(QMouseEvent *e); + void keyPressEvent(QKeyEvent *e); + void keyReleaseEvent(QKeyEvent *e); + +private: + Q3DockWindow *dockWindow; + QPoint offset; + uint mousePressed : 1; + uint hadDblClick : 1; + uint opaque : 1; + uint ctrlDown : 1; + QPointer<QWidget> oldFocus; + +}; + +Q3DockWindowHandle::Q3DockWindowHandle(Q3DockWindow *dw) + : QWidget(dw, "qt_dockwidget_internal"), dockWindow(dw), + closeButton(0), opaque(default_opaque), mousePressed(false) +{ + ctrlDown = false; + timer = new QTimer(this); + connect(timer, SIGNAL(timeout()), this, SLOT(minimize())); +#if defined(Q_WS_WIN) && !defined(QT_NO_CURSOR) + setCursor(Qt::SizeAllCursor); +#endif +} + +void Q3DockWindowHandle::paintEvent(QPaintEvent *e) +{ + if (!dockWindow->dockArea && !opaque) + return; + QPainter p(this); + QStyleOptionQ3DockWindow opt; + opt.init(this); + if (!dockWindow->area() || dockWindow->area()->orientation() == Qt::Horizontal) + opt.state |= QStyle::State_Horizontal; + + opt.rect = rect(); + opt.docked = dockWindow->area(); + opt.closeEnabled = dockWindow->isCloseEnabled(); + opt.rect = QStyle::visualRect(opt.direction, opt.rect, + style()->subElementRect(QStyle::SE_Q3DockWindowHandleRect, &opt, this)); + style()->drawPrimitive(QStyle::PE_IndicatorToolBarHandle, &opt, &p, this); + QWidget::paintEvent(e); +} + +void Q3DockWindowHandle::keyPressEvent(QKeyEvent *e) +{ + if (!mousePressed) + return; + if (e->key() == Qt::Key_Control) { + ctrlDown = true; + dockWindow->handleMove(mapFromGlobal(QCursor::pos()) - offset, QCursor::pos(), !opaque); + } +} + +void Q3DockWindowHandle::keyReleaseEvent(QKeyEvent *e) +{ + if (!mousePressed) + return; + if (e->key() == Qt::Key_Control) { + ctrlDown = false; + dockWindow->handleMove(mapFromGlobal(QCursor::pos()) - offset, QCursor::pos(), !opaque); + } +} + +void Q3DockWindowHandle::mousePressEvent(QMouseEvent *e) +{ + if (!dockWindow->dockArea) + return; + ctrlDown = (e->state() & Qt::ControlButton) == Qt::ControlButton; + oldFocus = qApp->focusWidget(); + setFocus(); + e->ignore(); + if (e->button() != Qt::LeftButton) + return; + e->accept(); + hadDblClick = false; + mousePressed = true; + offset = e->pos(); + dockWindow->startRectDraw(mapToGlobal(e->pos()), !opaque); + if (!opaque) + qApp->installEventFilter(dockWindow); +} + +void Q3DockWindowHandle::mouseMoveEvent(QMouseEvent *e) +{ + if (!mousePressed || e->pos() == offset) + return; + ctrlDown = (e->state() & Qt::ControlButton) == Qt::ControlButton; + dockWindow->handleMove(e->pos() - offset, e->globalPos(), !opaque); + if (opaque) + dockWindow->updatePosition(e->globalPos()); +} + +void Q3DockWindowHandle::mouseReleaseEvent(QMouseEvent *e) +{ + ctrlDown = false; + qApp->removeEventFilter(dockWindow); + if (oldFocus) + oldFocus->setFocus(); + if (!mousePressed) + return; + dockWindow->endRectDraw(!opaque); + mousePressed = false; +#ifdef Q_WS_MAC + releaseMouse(); +#endif + if (!hadDblClick && offset == e->pos()) { + timer->start(QApplication::doubleClickInterval(), true); + } else if (!hadDblClick) { + dockWindow->updatePosition(e->globalPos()); + } + if (opaque) + dockWindow->titleBar->mousePressed = false; + if (dockWindow->parentWidget()) + QApplication::postEvent(dockWindow->parentWidget(), new QEvent(QEvent::LayoutHint)); +} + +void Q3DockWindowHandle::minimize() +{ + if (!dockWindow->area()) + return; + + Q3MainWindow *mw = qobject_cast<Q3MainWindow*>(dockWindow->area()->parentWidget()); + if (mw && mw->isDockEnabled(dockWindow, Qt::DockMinimized)) + mw->moveDockWindow(dockWindow, Qt::DockMinimized); +} + +void Q3DockWindowHandle::resizeEvent(QResizeEvent *) +{ + updateGui(); +} + +void Q3DockWindowHandle::updateGui() +{ + updateGeometry(); + + if (!closeButton) { + closeButton = new QToolButton(this, "qt_close_button1"); +#ifndef QT_NO_CURSOR + closeButton->setCursor(Qt::ArrowCursor); +#endif + QStyleOption opt(0); + opt.init(closeButton); + closeButton->setIcon(style()->standardIcon(QStyle::SP_DockWidgetCloseButton, &opt, + closeButton)); + closeButton->setFixedSize(12, 12); + connect(closeButton, SIGNAL(clicked()), + dockWindow, SLOT(hide())); + } + + if (dockWindow->isCloseEnabled() && dockWindow->area()) + closeButton->show(); + else + closeButton->hide(); + + if (!dockWindow->area()) + return; + + if (dockWindow->area()->orientation() == Qt::Horizontal) { + int off = (width() - closeButton->width() - 1) / 2; + closeButton->move(off, 2); + } else { + int off = (height() - closeButton->height() - 1) / 2; + int x = QApplication::reverseLayout() ? 2 : width() - closeButton->width() - 2; + closeButton->move(x, off); + } +} + +void Q3DockWindowHandle::changeEvent(QEvent *ev) +{ + if(ev->type() == QEvent::StyleChange) { + if (closeButton) { + QStyleOption opt(0); + opt.init(closeButton); + closeButton->setIcon(style()->standardIcon(QStyle::SP_DockWidgetCloseButton, + &opt, closeButton)); + } + } + QWidget::changeEvent(ev); +} + +QSize Q3DockWindowHandle::minimumSizeHint() const +{ + if (!dockWindow->dockArea) + return QSize(0, 0); + int wh = dockWindow->isCloseEnabled() ? 17 : style()->pixelMetric(QStyle::PM_ToolBarHandleExtent, 0, this); + if (dockWindow->orientation() == Qt::Horizontal) + return QSize(wh, 0); + return QSize(0, wh); +} + +void Q3DockWindowHandle::mouseDoubleClickEvent(QMouseEvent *e) +{ + e->ignore(); + if (e->button() != Qt::LeftButton) + return; + e->accept(); + timer->stop(); + emit doubleClicked(); + hadDblClick = true; + if (dockWindow->parentWidget()) + QApplication::postEvent(dockWindow->parentWidget(), new QEvent(QEvent::LayoutHint)); +} + +Q3DockWindowTitleBar::Q3DockWindowTitleBar(Q3DockWindow *dw) + : Q3TitleBar(0, dw), dockWindow(dw), + mousePressed(false), hadDblClick(false), opaque(default_opaque) +{ + setObjectName(QLatin1String("qt_dockwidget_internal")); + ctrlDown = false; + setMouseTracking(true); + QStyleOptionTitleBar opt = getStyleOption(); + setFixedHeight(style()->pixelMetric(QStyle::PM_TitleBarHeight, &opt, this)); + connect(this, SIGNAL(doClose()), dockWindow, SLOT(hide())); +} + +void Q3DockWindowTitleBar::keyPressEvent(QKeyEvent *e) +{ + if (!mousePressed) + return; + if (e->key() == Qt::Key_Control) { + ctrlDown = true; + dockWindow->handleMove(mapFromGlobal(QCursor::pos()) - offset, QCursor::pos(), !opaque); + } +} + +void Q3DockWindowTitleBar::keyReleaseEvent(QKeyEvent *e) +{ + if (!mousePressed) + return; + if (e->key() == Qt::Key_Control) { + ctrlDown = false; + dockWindow->handleMove(mapFromGlobal(QCursor::pos()) - offset, QCursor::pos(), !opaque); + } +} + +void Q3DockWindowTitleBar::mousePressEvent(QMouseEvent *e) +{ + QStyleOptionTitleBar opt; + opt.init(this); + opt.subControls = QStyle::SC_All; + opt.activeSubControls = QStyle::SC_None; + opt.text = windowTitle(); + //################ + QIcon icon = windowIcon(); + QSize s = icon.actualSize(QSize(64, 64)); + opt.icon = icon.pixmap(s); + opt.titleBarState = window() ? window()->windowState() : static_cast<Qt::WindowStates>(Qt::WindowNoState); + opt.titleBarFlags = fakeWindowFlags(); + QStyle::SubControl tbctrl = style()->hitTestComplexControl(QStyle::CC_TitleBar, &opt, + e->pos(), this); + + if (tbctrl < QStyle::SC_TitleBarLabel && tbctrl != QStyle::SC_None) { + Q3TitleBar::mousePressEvent(e); + return; + } + + ctrlDown = (e->state() & Qt::ControlButton) == Qt::ControlButton; + oldFocus = qApp->focusWidget(); +// setFocus activates the window, which deactivates the main window +// not what we want, and not required anyway on Windows +#ifndef Q_WS_WIN + setFocus(); +#endif + + e->ignore(); + if (e->button() != Qt::LeftButton) + return; + if (e->y() < 3 && dockWindow->isResizeEnabled()) + return; + + e->accept(); + bool oldPressed = mousePressed; + mousePressed = true; + hadDblClick = false; + offset = e->pos(); + dockWindow->startRectDraw(mapToGlobal(e->pos()), !opaque); +// grabMouse resets the Windows mouse press count, so we never receive a double click on Windows +// not required on Windows, and did work on X11, too, but no problem there in the first place +#ifndef Q_WS_WIN + if(!oldPressed && dockWindow->opaqueMoving()) + grabMouse(); +#else + Q_UNUSED(oldPressed); +#endif +} + +void Q3DockWindowTitleBar::mouseMoveEvent(QMouseEvent *e) +{ + if (!mousePressed) { + Q3TitleBar::mouseMoveEvent(e); + return; + } + + ctrlDown = (e->state() & Qt::ControlButton) == Qt::ControlButton; + e->accept(); + dockWindow->handleMove(e->pos() - offset, e->globalPos(), !opaque); +} + +void Q3DockWindowTitleBar::mouseReleaseEvent(QMouseEvent *e) +{ + if (!mousePressed) { + Q3TitleBar::mouseReleaseEvent(e); + return; + } + + ctrlDown = false; + qApp->removeEventFilter(dockWindow); + if (oldFocus) + oldFocus->setFocus(); + + if (dockWindow->place() == Q3DockWindow::OutsideDock) + dockWindow->raise(); + + if(dockWindow->opaqueMoving()) + releaseMouse(); + if (!mousePressed) + return; + dockWindow->endRectDraw(!opaque); + mousePressed = false; + if (!hadDblClick) + dockWindow->updatePosition(e->globalPos()); + if (opaque) { + dockWindow->horHandle->mousePressed = false; + dockWindow->verHandle->mousePressed = false; + } + if (dockWindow->parentWidget()) + QApplication::postEvent(dockWindow->parentWidget(), new QEvent(QEvent::LayoutHint)); +} + +void Q3DockWindowTitleBar::resizeEvent(QResizeEvent *e) +{ + updateGui(); + Q3TitleBar::resizeEvent(e); +} + +void Q3DockWindowTitleBar::updateGui() +{ + if (dockWindow->isCloseEnabled()) { + setFakeWindowFlags(fakeWindowFlags() | Qt::WStyle_SysMenu); + } else { + setFakeWindowFlags(fakeWindowFlags() & ~Qt::WStyle_SysMenu); + } +} + +void Q3DockWindowTitleBar::mouseDoubleClickEvent(QMouseEvent *) +{ + emit doubleClicked(); + hadDblClick = true; + if (dockWindow->parentWidget()) + QApplication::postEvent(dockWindow->parentWidget(), new QEvent(QEvent::LayoutHint)); +} + +/*! + \class Q3DockWindow + \brief The Q3DockWindow class provides a widget which can be docked + inside a Q3DockArea or floated as a top level window on the + desktop. + + \compat + + This class handles moving, resizing, docking and undocking dock + windows. Q3ToolBar is a subclass of Q3DockWindow so the + functionality provided for dock windows is available with the same + API for toolbars. + + \img qmainwindow-qdockareas.png Q3DockWindows in a Q3DockArea + \caption Two Q3DockWindows (\l{Q3ToolBar}s) in a \l Q3DockArea + + \img qdockwindow.png A Q3DockWindow + \caption A Floating Q3DockWindow + + If the user drags the dock window into the dock area the dock + window will be docked. If the user drags the dock area outside any + dock areas the dock window will be undocked (floated) and will + become a top level window. Double clicking a floating dock + window's title bar will dock the dock window to the last dock area + it was docked in. Double clicking a docked dock window's handle + will undock (float) the dock window. + \omit + Single clicking a docked dock window's handle will minimize the + dock window (only its handle will appear, below the menu bar). + Single clicking the minimized handle will restore the dock window + to the last dock area that it was docked in. + \endomit + If the user clicks the close button (which appears on floating + dock windows by default) the dock window will disappear. You can + control whether or not a dock window has a close button with + setCloseMode(). + + Q3MainWindow provides four dock areas (top, left, right and bottom) + which can be used by dock windows. For many applications using the + dock areas provided by Q3MainWindow is sufficient. (See the \l + Q3DockArea documentation if you want to create your own dock + areas.) In Q3MainWindow a right-click popup menu (the dock window + menu) is available which lists dock windows and can be used to + show or hide them. (The popup menu only lists dock windows that + have a \link QWidget::setWindowTitle() caption\endlink.) + + When you construct a dock window you \e must pass it a Q3DockArea + or a Q3MainWindow as its parent if you want it docked. Pass 0 for + the parent if you want it floated. + + \snippet doc/src/snippets/code/src_qt3support_widgets_q3dockwindow.cpp 0 + + In the example above we create a new Q3ToolBar in the constructor + of a Q3MainWindow subclass (so that the \e this pointer points to + the Q3MainWindow). By default the toolbar will be added to the \c + Top dock area, but we've moved it to the \c Left dock area. + + A dock window is often used to contain a single widget. In these + cases the widget can be set by calling setWidget(). If you're + constructing a dock window that contains multiple widgets, e.g. a + toolbar, arrange the widgets within a box layout inside the dock + window. To do this use the boxLayout() function to get a pointer + to the dock window's box layout, then add widgets to the layout + using the box layout's QBoxLayout::addWidget() function. The dock + window will dynamically set the orientation of the layout to be + vertical or horizontal as necessary, although you can control this + yourself with setOrientation(). + + Although a common use of dock windows is for toolbars, they can be + used with any widgets. When using larger + widgets it may make sense for the dock window to be resizable by + calling setResizeEnabled(). Resizable dock windows are given + splitter-like handles to allow the user to resize them within + their dock area. When resizable dock windows are undocked they + become top level windows and can be resized like any other top + level windows, e.g. by dragging a corner or edge. + + Qt::Dock windows can be docked and undocked using dock() and undock(). + A dock window's orientation can be set with setOrientation(). You + can also use Q3DockArea::moveDockWindow(). If you're using a + Q3MainWindow, Q3MainWindow::moveDockWindow() and + Q3MainWindow::removeDockWindow() are available. + + A dock window can have some preferred settings, for example, you + can set a preferred offset from the left edge (or top edge for + vertical dock areas) of the dock area using setOffset(). If you'd + prefer a dock window to start on a new line when it is docked use + setNewLine(). The setFixedExtentWidth() and setFixedExtentHeight() + functions can be used to define the dock window's preferred size, + and the setHorizontallyStretchable() and setVerticallyStretchable() + functions set whether the dock window can be stretched or not. + Dock windows can be moved by default, but this can be changed with + setMovingEnabled(). When a dock window is moved it is shown as a + rectangular outline, but it can be shown normally using + setOpaqueMoving(). + + When a dock window's visibility changes, i.e. it is shown or + hidden, the visibilityChanged() signal is emitted. When a dock + window is docked, undocked or moved inside the dock area the + placeChanged() signal is emitted. +*/ + +/*! + \enum Q3DockWindow::Place + + This enum specifies the possible locations for a Q3DockWindow: + + \value InDock Inside a Q3DockArea. + \value OutsideDock Floating as a top level window on the desktop. +*/ + +/*! + \enum Q3DockWindow::CloseMode + + This enum type specifies when (if ever) a dock window has a close + button. + + \value Never The dock window never has a close button and cannot + be closed by the user. + \value Docked The dock window has a close button only when + docked. + \value Undocked The dock window has a close button only when + floating. + \value Always The dock window always has a close button. + \omit + Note that dock windows can always be minimized if the user clicks + their dock window handle when they are docked. + \endomit +*/ + +/*! + \fn void Q3DockWindow::setHorizontalStretchable(bool b) + + If \a b is true the dock window is set to be horizontally + stretchable. +*/ +/*! + \fn void Q3DockWindow::setVerticalStretchable(bool b) + + If \a b is true the dock window is set to be vertically + stretchable. +*/ +/*! + \fn bool Q3DockWindow::isHorizontalStretchable() const + + Returns true if the dock window can be stretched horizontally; + otherwise returns false. +*/ +/*! + \fn bool Q3DockWindow::isVerticalStretchable() const + + Returns true if the dock window can be stretched vertically; + otherwise returns false. +*/ +/*! + \fn void Q3DockWindow::orientationChanged(Qt::Orientation o) + + This signal is emitted when the orientation of the dock window is + changed. The new orientation is \a o. +*/ + +/*! + \fn void Q3DockWindow::placeChanged(Q3DockWindow::Place p) + + This signal is emitted when the dock window is docked (\a p is \c + InDock), undocked (\a p is \c OutsideDock) or moved inside the + the dock area. + + \sa Q3DockArea::moveDockWindow(), Q3DockArea::removeDockWindow(), + Q3MainWindow::moveDockWindow(), Q3MainWindow::removeDockWindow() +*/ + +/*! + \fn void Q3DockWindow::visibilityChanged(bool visible) + + This signal is emitted when the visibility of the dock window + relatively to its dock area is changed. If \a visible is true, the + Q3DockWindow is now visible to the dock area, otherwise it has been + hidden. + + A dock window can be hidden if it has a close button which the + user has clicked. In the case of a Q3MainWindow a dock window can + have its visibility changed (hidden or shown) by clicking its name + in the dock window menu that lists the Q3MainWindow's dock windows. +*/ + +/*! + \fn Q3DockArea *Q3DockWindow::area() const + + Returns the dock area in which this dock window is docked, or 0 if + the dock window is floating. +*/ + +/*! + \property Q3DockWindow::place + \brief the location where the dock window is placed + + This is either \c InDock or \c OutsideDock. + + \sa Q3DockArea::moveDockWindow(), Q3DockArea::removeDockWindow(), + Q3MainWindow::moveDockWindow(), Q3MainWindow::removeDockWindow() +*/ + +/*! + Constructs a Q3DockWindow with parent \a parent, called \a name and + with widget flags \a f. +*/ + +Q3DockWindow::Q3DockWindow(QWidget* parent, const char* name, Qt::WindowFlags f) + : Q3Frame(parent, name, f | Qt::WType_Dialog | Qt::WStyle_Customize | Qt::WStyle_NoBorder) +{ + curPlace = InDock; + isToolbar = false; + init(); +} + +/*! + Constructs a Q3DockWindow with parent \a parent, called \a name and + with widget flags \a f. + + If \a p is \c InDock, the dock window is docked into a dock area + and \a parent \e must be a Q3DockArea or a Q3MainWindow. If the \a + parent is a Q3MainWindow the dock window will be docked in the main + window's \c Top dock area. + + If \a p is \c OutsideDock, the dock window is created as a floating + window. + + We recommend creating the dock area \c InDock with a Q3MainWindow + as parent then calling Q3MainWindow::moveDockWindow() to move the + dock window where you want it. +*/ + +Q3DockWindow::Q3DockWindow(Place p, QWidget *parent, const char *name, Qt::WindowFlags f) + : Q3Frame(parent, name, f | Qt::WType_Dialog | Qt::WStyle_Customize | Qt::WStyle_NoBorder) +{ + curPlace = p; + isToolbar = false; + init(); +} + +/*! \internal +*/ + +Q3DockWindow::Q3DockWindow(Place p, QWidget *parent, const char *name, Qt::WindowFlags f, bool toolbar) + : Q3Frame(parent, name, f | Qt::WType_Dialog | Qt::WStyle_Customize | Qt::WStyle_NoBorder) +{ + curPlace = p; + isToolbar = toolbar; + init(); +} + +class Q3DockWindowGridLayout : public QGridLayout +{ +public: + Q3DockWindowGridLayout(QWidget *parent, int nRows, int nCols) + : QGridLayout(parent, nRows, nCols) {}; + + Qt::Orientations expandingDirections() const + { + return 0; + } +}; + +void Q3DockWindow::init() +{ + wid = 0; + rubberBand = 0; + dockArea = 0; + tmpDockArea = 0; + resizeEnabled = false; + moveEnabled = true; + nl = false; + opaque = default_opaque; + cMode = Never; + offs = 0; + fExtent = QSize(-1, -1); + dockWindowData = 0; + lastPos = QPoint(-1, -1); + lastSize = QSize(-1, -1); + stretchable[Qt::Horizontal] = false; + stretchable[Qt::Vertical] = false; + + widgetResizeHandler = new QWidgetResizeHandler(this); + widgetResizeHandler->setMovingEnabled(false); + + titleBar = new Q3DockWindowTitleBar(this); + verHandle = new Q3DockWindowHandle(this); + verHandle->setSizePolicy(QSizePolicy(QSizePolicy::Fixed, QSizePolicy::Preferred)); + horHandle = new Q3DockWindowHandle(this); + horHandle->setSizePolicy(QSizePolicy(QSizePolicy::Preferred, QSizePolicy::Fixed)); + + vHandleLeft = new Q3DockWindowResizeHandle(Qt::Vertical, this, this, "vert. handle"); + vHandleRight = new Q3DockWindowResizeHandle(Qt::Vertical, this, this, "vert. handle"); + hHandleTop = new Q3DockWindowResizeHandle(Qt::Horizontal, this, this, "horz. handle"); + hHandleBottom = new Q3DockWindowResizeHandle(Qt::Horizontal, this, this, "horz. handle"); + + // Creating inner layout + hbox = new QVBoxLayout(); + vbox = new QHBoxLayout(); + childBox = new QBoxLayout(QBoxLayout::LeftToRight); + vbox->addSpacing(2); + vbox->addWidget(verHandle); + vbox->addStretch(0); + vbox->addLayout(childBox, 1); + vbox->addStretch(0); + + hbox->setResizeMode(QLayout::FreeResize); + hbox->setMargin(isResizeEnabled() || curPlace == OutsideDock ? 2 : 0); + hbox->setSpacing(1); + hbox->addWidget(titleBar); + hbox->addWidget(horHandle); + hbox->addLayout(vbox); + + // Set up the initial handle layout for Qt::Vertical + // Handle layout will change on calls to setOrienation() + QGridLayout *glayout = new Q3DockWindowGridLayout(this, 3, 3); + glayout->setResizeMode(QLayout::Minimum); + glayout->addMultiCellWidget(hHandleTop, 0, 0, 1, 1); + glayout->addMultiCellWidget(hHandleBottom, 2, 2, 1, 1); + glayout->addMultiCellWidget(vHandleLeft, 0, 2, 0, 0); + glayout->addMultiCellWidget(vHandleRight, 0, 2, 2, 2); + glayout->addLayout(hbox, 1, 1); + glayout->setRowStretch(1, 1); + glayout->setColStretch(1, 1); + + hHandleBottom->hide(); + vHandleRight->hide(); + hHandleTop->hide(); + vHandleLeft->hide(); + setFrameStyle(Q3Frame::StyledPanel | Q3Frame::Raised); + setLineWidth(2); + + if (parentWidget()) + parentWidget()->installEventFilter(this); + QWidget *mw = parentWidget(); + Q3DockArea *da = qobject_cast<Q3DockArea*>(parentWidget()); + if (da) { + if (curPlace == InDock) + da->moveDockWindow(this); + mw = da->parentWidget(); + } + if (qobject_cast<Q3MainWindow*>(mw)) { + if (place() == InDock) { + Qt::Dock myDock = Qt::DockTop; + // make sure we put the window in the correct dock. + if (dockArea) { + Q3MainWindow *mainw = (Q3MainWindow*)mw; + // I'm not checking if it matches the top because I've + // done the assignment to it above. + if (dockArea == mainw->leftDock()) + myDock = Qt::DockLeft; + else if (dockArea == mainw->rightDock()) + myDock = Qt::DockRight; + else if (dockArea == mainw->bottomDock()) + myDock = Qt::DockBottom; + } + ((Q3MainWindow*)mw)->addDockWindow(this, myDock); + } + moveEnabled = ((Q3MainWindow*)mw)->dockWindowsMovable(); + opaque = ((Q3MainWindow*)mw)->opaqueMoving(); + } + + updateGui(); + + connect(titleBar, SIGNAL(doubleClicked()), this, SLOT(dock())); + connect(verHandle, SIGNAL(doubleClicked()), this, SLOT(undock())); + connect(horHandle, SIGNAL(doubleClicked()), this, SLOT(undock())); + connect(this, SIGNAL(orientationChanged(Qt::Orientation)), + this, SLOT(setOrientation(Qt::Orientation))); +} + +/*! + Sets the orientation of the dock window to \a o. The orientation + is propagated to the layout boxLayout(). + + \warning All undocked Q3ToolBars will always have a horizontal orientation. +*/ + +void Q3DockWindow::setOrientation(Qt::Orientation o) +{ + QGridLayout *glayout = (QGridLayout*)layout(); + glayout->removeWidget(hHandleTop); + glayout->removeWidget(hHandleBottom); + glayout->removeWidget(vHandleLeft); + glayout->removeWidget(vHandleRight); + + if (o == Qt::Horizontal) { + // Set up the new layout as + // 3 3 3 1 = vHandleLeft 4 = hHandleBottom + // 1 X 2 2 = vHandleRight X = Inner Layout + // 4 4 4 3 = hHandleTop + glayout->addMultiCellWidget(hHandleTop, 0, 0, 0, 2); + glayout->addMultiCellWidget(hHandleBottom, 2, 2, 0, 2); + glayout->addMultiCellWidget(vHandleLeft, 1, 1, 0, 0); + glayout->addMultiCellWidget(vHandleRight, 1, 1, 2, 2); + } else { + // Set up the new layout as + // 1 3 2 1 = vHandleLeft 4 = hHandleBottom + // 1 X 2 2 = vHandleRight X = Inner Layout + // 1 4 2 3 = hHandleTop + glayout->addMultiCellWidget(hHandleTop, 0, 0, 1, 1); + glayout->addMultiCellWidget(hHandleBottom, 2, 2, 1, 1); + glayout->addMultiCellWidget(vHandleLeft, 0, 2, 0, 0); + glayout->addMultiCellWidget(vHandleRight, 0, 2, 2, 2); + } + boxLayout()->setDirection(o == Qt::Horizontal ? QBoxLayout::LeftToRight : QBoxLayout::TopToBottom); + QApplication::sendPostedEvents(this, QEvent::LayoutHint); + QEvent *e = new QEvent(QEvent::LayoutHint); + QApplication::postEvent(this, e); +} + +/*! + Destroys the dock window and its child widgets. +*/ + +Q3DockWindow::~Q3DockWindow() +{ + qApp->removeEventFilter(this); + if (area()) + area()->removeDockWindow(this, false, false); + Q3DockArea *a = area(); + if (!a && dockWindowData) + a = ((Q3DockArea::DockWindowData*)dockWindowData)->area; + Q3MainWindow *mw = a ? qobject_cast<Q3MainWindow*>(a->parentWidget()) : 0; + if (mw) + mw->removeDockWindow(this); + + delete (Q3DockArea::DockWindowData*)dockWindowData; +} + +/*! \reimp +*/ + +void Q3DockWindow::resizeEvent(QResizeEvent *e) +{ + Q3Frame::resizeEvent(e); + updateGui(); +} + + +void Q3DockWindow::swapRect(QRect &r, Qt::Orientation o, const QPoint &offset, Q3DockArea *) +{ + r.setSize(QSize(r.height(), r.width())); + bool reverse = QApplication::reverseLayout(); + if (o == Qt::Horizontal) + r.moveBy(-r.width()/2, 0); + else + r.moveBy(reverse ? - r.width() : 0, -r.height() / 2 ); + r.moveBy(offset.x(), offset.y()); +} + +QWidget *Q3DockWindow::areaAt(const QPoint &gp) +{ + QWidget *w = qApp->widgetAt(gp); + + if (w && (w == this || w == titleBar) && parentWidget()) + w = parentWidget()->childAt(parentWidget()->mapFromGlobal(gp)); + + while (w) { + if (qobject_cast<Q3DockArea*>(w)) { + Q3DockArea *a = (Q3DockArea*)w; + if (a->isDockWindowAccepted(this)) + return w; + } + if (qobject_cast<Q3MainWindow*>(w)) { + Q3MainWindow *mw = (Q3MainWindow*)w; + Q3DockArea *a = mw->dockingArea(mw->mapFromGlobal(gp)); + if (a && a->isDockWindowAccepted(this)) + return a; + } + w = w->isWindow() ? 0 : (QWidget *)w->parent(); + } + return 0; +} + +void Q3DockWindow::handleMove(const QPoint &pos, const QPoint &gp, bool drawRect) +{ + if (!rubberBand) + return; + + currRect = QRect(realWidgetPos(this), size()); + QWidget *w = areaAt(gp); + if (titleBar->ctrlDown || horHandle->ctrlDown || verHandle->ctrlDown) + w = 0; + currRect.moveBy(pos.x(), pos.y()); + if (!qobject_cast<Q3DockArea*>(w)) { + if (startOrientation != Qt::Horizontal && qobject_cast<Q3ToolBar*>(this)) + swapRect(currRect, Qt::Horizontal, startOffset, (Q3DockArea*)w); + if (drawRect) { + rubberBand->setGeometry(currRect); + } else { + QPoint mp(mapToGlobal(pos)); + if(place() == InDock) { + undock(); + if(titleBar) { + mp = QPoint(titleBar->width() / 2, titleBar->height() / 2); + QMouseEvent me(QEvent::MouseButtonPress, mp, Qt::LeftButton, 0); + QApplication::sendEvent(titleBar, &me); + mp = titleBar->mapToGlobal(mp); + } + } + move(mp); + } + state = OutsideDock; + return; + } + + Q3DockArea *area = (Q3DockArea*)w; + if(area->isVisible()) { + state = InDock; + Qt::Orientation o = (area ? area->orientation() : + (boxLayout()->direction() == QBoxLayout::LeftToRight || + boxLayout()->direction() == QBoxLayout::RightToLeft ? + Qt::Horizontal : Qt::Vertical)); + if (startOrientation != o) + swapRect(currRect, o, startOffset, area); + if (drawRect) { + rubberBand->setGeometry(currRect); + } + tmpDockArea = area; + } +} + +void Q3DockWindow::updateGui() +{ + if (curPlace == OutsideDock) { + hbox->setMargin(2); + horHandle->hide(); + verHandle->hide(); + if (moveEnabled) + titleBar->show(); + else + titleBar->hide(); + titleBar->updateGui(); + hHandleTop->hide(); + vHandleLeft->hide(); + hHandleBottom->hide(); + vHandleRight->hide(); + setLineWidth(2); + widgetResizeHandler->setActive(isResizeEnabled()); + } else { + hbox->setMargin(0); + titleBar->hide(); + if (orientation() == Qt::Horizontal) { + horHandle->hide(); + if (moveEnabled) + verHandle->show(); + else + verHandle->hide(); +#ifdef Q_WS_MAC + if(horHandle->mousePressed) { + horHandle->mousePressed = false; + verHandle->mousePressed = true; + verHandle->grabMouse(); + } +#endif + verHandle->updateGui(); + } else { + if (moveEnabled) + horHandle->show(); + else + horHandle->hide(); + horHandle->updateGui(); +#ifdef Q_WS_MAC + if(verHandle->mousePressed) { + verHandle->mousePressed = false; + horHandle->mousePressed = true; + horHandle->grabMouse(); + } +#endif + verHandle->hide(); + } + if (isResizeEnabled()) { + if (orientation() == Qt::Horizontal) { + hHandleBottom->raise(); + hHandleTop->raise(); + } else { + vHandleRight->raise(); + vHandleLeft->raise(); + } + + if (area()) { + if (orientation() == Qt::Horizontal) { + if (area()->handlePosition() == Q3DockArea::Normal) { + hHandleBottom->show(); + hHandleTop->hide(); + } else { + hHandleTop->show(); + hHandleBottom->hide(); + } + if (!area()->isLastDockWindow(this)) + vHandleRight->show(); + else + vHandleRight->hide(); + vHandleLeft->hide(); + } else { + if ((area()->handlePosition() == Q3DockArea::Normal) != QApplication::reverseLayout()) { + vHandleRight->show(); + vHandleLeft->hide(); + } else { + vHandleLeft->show(); + vHandleRight->hide(); + } + if (!area()->isLastDockWindow(this)) + hHandleBottom->show(); + else + hHandleBottom->hide(); + hHandleTop->hide(); + } + } + } +#ifndef Q_OS_WINCE + if (moveEnabled) + setLineWidth(1); + else + setLineWidth(0); +#endif + widgetResizeHandler->setActive(false); + } +} + +void Q3DockWindow::updatePosition(const QPoint &globalPos) +{ + if (curPlace == OutsideDock && state == InDock) + lastSize = size(); + + bool doAdjustSize = curPlace != state && state == OutsideDock; + bool doUpdate = true; + bool doOrientationChange = true; + if (state != curPlace && state == InDock) { + doUpdate = false; + curPlace = state; + updateGui(); + QApplication::sendPostedEvents(); + } + Qt::Orientation oo = orientation(); + + if (state == InDock) { + if (tmpDockArea) { + bool differentDocks = false; + if (dockArea && dockArea != tmpDockArea) { + differentDocks = true; + delete (Q3DockArea::DockWindowData*)dockWindowData; + dockWindowData = dockArea->dockWindowData(this); + dockArea->removeDockWindow(this, false, false); + } + dockArea = tmpDockArea; + if (differentDocks) { + if (doUpdate) { + doUpdate = false; + curPlace = state; + updateGui(); + } + emit orientationChanged(tmpDockArea->orientation()); + doOrientationChange = false; + } else { + updateGui(); + } + dockArea->moveDockWindow(this, globalPos, currRect, startOrientation != oo); + } + } else { + if (dockArea) { + Q3MainWindow *mw = (Q3MainWindow*)dockArea->parentWidget(); + if (qobject_cast<Q3MainWindow*>(mw) && + (!mw->isDockEnabled(Qt::DockTornOff) || + !mw->isDockEnabled(this, Qt::DockTornOff))) + return; + delete (Q3DockArea::DockWindowData*)dockWindowData; + dockWindowData = dockArea->dockWindowData(this); + dockArea->removeDockWindow(this, true, + startOrientation != Qt::Horizontal && qobject_cast<Q3ToolBar*>(this)); + } + dockArea = 0; + QPoint topLeft = currRect.topLeft(); + QRect screen = qApp->desktop()->availableGeometry(topLeft); + if (!screen.contains(topLeft)) { + topLeft.setY(qMax(topLeft.y(), screen.top())); + topLeft.setY(qMin(topLeft.y(), screen.bottom()-height())); + topLeft.setX(qMax(topLeft.x(), screen.left())); + topLeft.setX(qMin(topLeft.x(), screen.right()-width())); + } + move(topLeft); + } + + if (curPlace == InDock && state == OutsideDock && !qobject_cast<Q3ToolBar*>(this)) { + if (lastSize != QSize(-1, -1)) + resize(lastSize); + } + + if (doUpdate) { + curPlace = state; + updateGui(); + } + if (doOrientationChange) + emit orientationChanged(orientation()); + tmpDockArea = 0; + if (doAdjustSize) { + QApplication::sendPostedEvents(this, QEvent::LayoutHint); + if (qobject_cast<Q3ToolBar*>(this)) + adjustSize(); + if (lastSize == QSize(-1, -1)) + setAttribute(Qt::WA_Resized, false); // Ensures size is recalculated (non-opaque). + show(); + if (parentWidget() && isWindow()) + parentWidget()->setActiveWindow(); + + } + + emit placeChanged(curPlace); +} + +/*! + Sets the dock window's main widget to \a w. + + \sa boxLayout() +*/ + +void Q3DockWindow::setWidget(QWidget *w) +{ + wid = w; + boxLayout()->addWidget(w); + updateGui(); +} + +/*! + Returns the dock window's main widget. + + \sa setWidget() +*/ + +QWidget *Q3DockWindow::widget() const +{ + return wid; +} + +void Q3DockWindow::startRectDraw(const QPoint &so, bool drawRect) +{ + state = place(); + if (rubberBand) + endRectDraw(!opaque); + rubberBand = new QRubberBand(QRubberBand::Rectangle); + currRect = QRect(realWidgetPos(this), size()); + if (drawRect) { + rubberBand->setGeometry(currRect); + } + startOrientation = orientation(); + startOffset = mapFromGlobal(so); + rubberBand->show(); +} + +void Q3DockWindow::endRectDraw(bool) +{ + delete rubberBand; + rubberBand = 0; +} + +/*! + \reimp +*/ +void Q3DockWindow::drawFrame(QPainter *p) +{ + if (place() == InDock) { + Q3Frame::drawFrame(p); + return; + } + + QStyleOptionFrame opt; + opt.rect = rect(); + opt.palette = palette(); + opt.state = QStyle::State_None; + if (titleBar->isActive()) + opt.state |= QStyle::State_Active; + opt.lineWidth = lineWidth(); + opt.midLineWidth = midLineWidth(); + + style()->drawPrimitive(QStyle::PE_FrameWindow, &opt, p, this); +} + +/*! + \reimp +*/ +void Q3DockWindow::drawContents(QPainter *p) +{ + // This is only used by the PocketPC style. We probably need to revist later. + QStyleOption opt(0, QStyleOption::SO_Default); + opt.init(this); + if (titleBar->isActive()) + opt.state |= QStyle::State_Active; + style()->drawControl(QStyle::CE_Q3DockWindowEmptyArea, &opt, p, this); +} + +/*! + \property Q3DockWindow::resizeEnabled + \brief whether the dock window is resizeable + + A resizeable dock window can be resized using splitter-like + handles inside a dock area and like every other top level window + when floating. + + A dock window is both horizontally and vertically stretchable if + you call setResizeEnabled(true). + + This property is false by default. + + \sa setVerticallyStretchable() setHorizontallyStretchable() +*/ + +void Q3DockWindow::setResizeEnabled(bool b) +{ + resizeEnabled = b; + updateGui(); +} + +/*! + \property Q3DockWindow::movingEnabled + \brief whether the user can move the dock window within the dock + area, move the dock window to another dock area, or float the dock + window. + + This property is true by default. +*/ + +void Q3DockWindow::setMovingEnabled(bool b) +{ + moveEnabled = b; + updateGui(); +} + +bool Q3DockWindow::isResizeEnabled() const +{ + return resizeEnabled; +} + +bool Q3DockWindow::isMovingEnabled() const +{ + return moveEnabled; +} + +/*! + \property Q3DockWindow::closeMode + \brief the close mode of a dock window + + Defines when (if ever) the dock window has a close button. The + choices are \c Never, \c Docked (i.e. only when docked), \c + Undocked (only when undocked, i.e. floated) or \c Always. + + The default is \c Never. +*/ + +void Q3DockWindow::setCloseMode(int m) +{ + cMode = m; + if (place() == InDock) { + horHandle->updateGui(); + verHandle->updateGui(); + } else { + titleBar->updateGui(); + } +} + +/*! + Returns true if the dock window has a close button; otherwise + returns false. The result depends on the dock window's \l Place + and its \l CloseMode. + + \sa setCloseMode() +*/ + +bool Q3DockWindow::isCloseEnabled() const +{ + return (((cMode & Docked) == Docked && place() == InDock) || + ((cMode & Undocked) == Undocked && place() == OutsideDock)); +} + +int Q3DockWindow::closeMode() const +{ + return cMode; +} + +/*! + \property Q3DockWindow::horizontallyStretchable + \brief whether the dock window is horizontally stretchable. + + A dock window is horizontally stretchable if you call + setHorizontallyStretchable(true) or setResizeEnabled(true). + + \warning Stretchability is broken. You must call + setResizeEnabled(true) to get proper behavior and even then + Q3DockWindow does not limit stretchablilty. + + \sa setResizeEnabled() +*/ + +void Q3DockWindow::setHorizontallyStretchable(bool b) +{ + stretchable[Qt::Horizontal] = b; +} + +/*! + \property Q3DockWindow::verticallyStretchable + \brief whether the dock window is vertically stretchable. + + A dock window is vertically stretchable if you call + setVerticallyStretchable(true) or setResizeEnabled(true). + + \sa setResizeEnabled() + + \warning Stretchability is broken. You must call + setResizeEnabled(true) to get proper behavior and even then + Q3DockWindow does not limit stretchablilty. +*/ + +void Q3DockWindow::setVerticallyStretchable(bool b) +{ + stretchable[Qt::Vertical] = b; +} + +bool Q3DockWindow::isHorizontallyStretchable() const +{ + return isResizeEnabled() || stretchable[Qt::Horizontal]; +} + +bool Q3DockWindow::isVerticallyStretchable() const +{ + return isResizeEnabled() || stretchable[Qt::Vertical]; +} + +/*! + \property Q3DockWindow::stretchable + \brief whether the dock window is stretchable in the current + orientation() + + This property can be set using setHorizontallyStretchable() and + setVerticallyStretchable(), or with setResizeEnabled(). + + \warning Stretchability is broken. You must call + setResizeEnabled(true) to get proper behavior and even then + Q3DockWindow does not limit stretchablilty. + + \sa setResizeEnabled() +*/ + +bool Q3DockWindow::isStretchable() const +{ + if (orientation() == Qt::Horizontal) + return isHorizontallyStretchable(); + return isVerticallyStretchable(); +} + +/*! + Returns the orientation of the dock window. + + \sa orientationChanged() +*/ + +Qt::Orientation Q3DockWindow::orientation() const +{ + if (dockArea) + return dockArea->orientation(); + if (qobject_cast<const Q3ToolBar*>(this)) + return Qt::Horizontal; + return (((Q3DockWindow*)this)->boxLayout()->direction() == QBoxLayout::LeftToRight || + ((Q3DockWindow*)this)->boxLayout()->direction() == QBoxLayout::RightToLeft ? + Qt::Horizontal : Qt::Vertical); +} + +int Q3DockWindow::offset() const +{ + return offs; +} + +/*! + \property Q3DockWindow::offset + \brief the dock window's preferred offset from the dock area's + left edge (top edge for vertical dock areas) + + The default is 0. +*/ + +void Q3DockWindow::setOffset(int o) +{ + offs = o; +} + +/*! + Returns the dock window's preferred size (fixed extent). + + \sa setFixedExtentWidth() setFixedExtentHeight() +*/ + +QSize Q3DockWindow::fixedExtent() const +{ + return fExtent; +} + +/*! + Sets the dock window's preferred width for its fixed extent (size) + to \a w. + + \sa setFixedExtentHeight() +*/ + +void Q3DockWindow::setFixedExtentWidth(int w) +{ + fExtent.setWidth(w); +} + +/*! + Sets the dock window's preferred height for its fixed extent + (size) to \a h. + + \sa setFixedExtentWidth() +*/ + +void Q3DockWindow::setFixedExtentHeight(int h) +{ + fExtent.setHeight(h); +} + +/*! + \property Q3DockWindow::newLine + \brief whether the dock window prefers to start a new line in the + dock area. + + The default is false, i.e. the dock window doesn't require a new + line in the dock area. +*/ + +void Q3DockWindow::setNewLine(bool b) +{ + nl = b; +} + +bool Q3DockWindow::newLine() const +{ + return nl; +} + +/*! + Returns the layout which is used for adding widgets to the dock + window. The layout's orientation is set automatically to match the + orientation of the dock window. You can add widgets to the layout + using the box layout's QBoxLayout::addWidget() function. + + If the dock window only needs to contain a single widget use + setWidget() instead. + + \sa setWidget() setOrientation() +*/ + +QBoxLayout *Q3DockWindow::boxLayout() +{ + return childBox; +} + +/*! \reimp + */ + +QSize Q3DockWindow::sizeHint() const +{ + QSize sh(Q3Frame::sizeHint()); + if (place() == InDock) + sh = sh.expandedTo(fixedExtent()); + sh = sh.expandedTo(QSize(16, 16)); + if (area()) { + if (area()->orientation() == Qt::Horizontal && !vHandleRight->isVisible()) + sh.setWidth(sh.width() + 2 * style()->pixelMetric(QStyle::PM_SplitterWidth, 0, this) / 3); + else if (area()->orientation() == Qt::Vertical && !hHandleBottom->isVisible()) + sh.setHeight(sh.height() + 2 * style()->pixelMetric(QStyle::PM_SplitterWidth, 0, this) / 3); + } + return sh; +} + +/*! \internal + */ + +QSize Q3DockWindow::minimumSize() const +{ + QSize ms(Q3Frame::minimumSize()); + if (place() == InDock) + ms = ms.expandedTo(fixedExtent()); + ms = ms.expandedTo(QSize(16, 16)); + if (area()) { + if (area()->orientation() == Qt::Horizontal && !vHandleRight->isVisible()) + ms.setWidth(ms.width() + 2 * style()->pixelMetric(QStyle::PM_SplitterWidth, 0, this) / 3); + else if (area()->orientation() == Qt::Vertical && !hHandleBottom->isVisible()) + ms.setHeight(ms.height() + 2 * style()->pixelMetric(QStyle::PM_SplitterWidth, 0, this) / 3); + } + return ms; +} + +/*! \reimp + */ + +QSize Q3DockWindow::minimumSizeHint() const +{ + QSize msh(Q3Frame::minimumSize()); + if (place() == InDock) + msh = msh.expandedTo(fixedExtent()); + msh = msh.expandedTo(QSize(16, 16)); + if (area()) { + if (area()->orientation() == Qt::Horizontal && !vHandleRight->isVisible()) + msh.setWidth(msh.width() + 2 * style()->pixelMetric(QStyle::PM_SplitterWidth, 0, this) / 3); + else if (area()->orientation() == Qt::Vertical && !hHandleBottom->isVisible()) + msh.setHeight(msh.height() + 2 * style()->pixelMetric(QStyle::PM_SplitterWidth, 0, this) / 3); + } + return msh; +} + +/*! + \fn void Q3DockWindow::undock() + + Undocks the Q3DockWindow from its current dock area if it is + docked; otherwise does nothing. + + \sa dock() Q3DockArea::moveDockWindow(), + Q3DockArea::removeDockWindow(), Q3MainWindow::moveDockWindow(), + Q3MainWindow::removeDockWindow() +*/ + +/*! + \fn void Q3DockWindow::undock(QWidget *widget) + + Undocks the specified \a widget from its current dock area if it is + docked; otherwise does nothing. + + \sa dock() Q3DockArea::moveDockWindow(), + Q3DockArea::removeDockWindow(), Q3MainWindow::moveDockWindow(), + Q3MainWindow::removeDockWindow() +*/ +void Q3DockWindow::undock(QWidget *w) +{ + Q3MainWindow *mw = 0; + if (area()) + mw = qobject_cast<Q3MainWindow*>(area()->parentWidget()); + if (mw && !mw->isDockEnabled(this, Qt::DockTornOff)) + return; + if ((place() == OutsideDock && !w)) + return; + + QPoint p(50, 50); + if (window()) + p = window()->pos() + QPoint(20, 20); + if (dockArea) { + delete (Q3DockArea::DockWindowData*)dockWindowData; + dockWindowData = dockArea->dockWindowData(this); + dockArea->removeDockWindow(this, true, orientation() != Qt::Horizontal && qobject_cast<Q3ToolBar*>(this)); + } + dockArea = 0; + if (lastPos != QPoint(-1, -1) && lastPos.x() > 0 && lastPos.y() > 0) + move(lastPos); + else + move(p); + if (lastSize != QSize(-1, -1)) + resize(lastSize); + curPlace = OutsideDock; + updateGui(); + emit orientationChanged(orientation()); + QApplication::sendPostedEvents(this, QEvent::LayoutHint); + if (qobject_cast<Q3ToolBar*>(this)) + adjustSize(); + if (!w) { + if (!parentWidget() || parentWidget()->isVisible()) { + if (lastSize == QSize(-1, -1)) + setAttribute(Qt::WA_Resized, false);// Ensures size is recalculated (opaque). + show(); + } + } else { + setParent(w, 0); + move(-width() - 5, -height() - 5); + resize(1, 1); + show(); + } + if (parentWidget() && isWindow()) + parentWidget()->setActiveWindow(); + emit placeChanged(place()); +} + +void Q3DockWindow::removeFromDock(bool fixNewLines) +{ + if (dockArea) + dockArea->removeDockWindow(this, false, false, fixNewLines); +} + +/*! + Docks the dock window into the last dock area in which it was + docked. + + If the dock window has no last dock area (e.g. it was created as a + floating window and has never been docked), or if the last dock + area it was docked in does not exist (e.g. the dock area has been + deleted), nothing happens. + + The dock window will dock with the dock area regardless of the return value + of Q3DockArea::isDockWindowAccepted(). + + \sa undock() Q3DockArea::moveDockWindow(), + Q3DockArea::removeDockWindow(), Q3MainWindow::moveDockWindow(), + Q3MainWindow::removeDockWindow(), Q3DockArea::isDockWindowAccepted() + +*/ + +void Q3DockWindow::dock() +{ + if (!(Q3DockArea::DockWindowData*)dockWindowData || + !((Q3DockArea::DockWindowData*)dockWindowData)->area) + return; + curPlace = InDock; + lastPos = pos(); + lastSize = size(); + ((Q3DockArea::DockWindowData*)dockWindowData)-> + area->dockWindow(this, (Q3DockArea::DockWindowData*)dockWindowData); + emit orientationChanged(orientation()); + emit placeChanged(place()); +} + +/*! \reimp + */ + +void Q3DockWindow::hideEvent(QHideEvent *e) +{ + Q3Frame::hideEvent(e); +} + +/*! \reimp + */ + +void Q3DockWindow::showEvent(QShowEvent *e) +{ + if (curPlace == OutsideDock && (parent() && parent()->objectName() == QLatin1String("qt_hide_dock"))) { + QRect sr = qApp->desktop()->availableGeometry(this); + if (!sr.contains(pos())) { + int nx = qMin(qMax(x(), sr.x()), sr.right()-width()); + int ny = qMin(qMax(y(), sr.y()), sr.bottom()-height()); + move(nx, ny); + } + } + + Q3Frame::showEvent(e); +} + +/*! + \property Q3DockWindow::opaqueMoving + \brief whether the dock window will be shown normally whilst it is + being moved. + + If this property is false, (the default), the dock window will be + represented by an outline rectangle whilst it is being moved. + + \warning Currently opaque moving has some problems and we do not + recommend using it at this time. We expect to fix these problems + in a future release. +*/ + +void Q3DockWindow::setOpaqueMoving(bool b) +{ + opaque = b; + horHandle->setOpaqueMoving(b); + verHandle->setOpaqueMoving(b); + titleBar->setOpaqueMoving(b); +} + +bool Q3DockWindow::opaqueMoving() const +{ + return opaque; +} + +void Q3DockWindow::updateSplitterVisibility(bool visible) +{ + if (area() && isResizeEnabled()) { + if (orientation() == Qt::Horizontal) { + if (visible) + vHandleRight->show(); + else + vHandleRight->hide(); + vHandleLeft->hide(); + } else { + if (visible) + hHandleBottom->show(); + else + hHandleBottom->hide(); + hHandleTop->hide(); + } + } +} + +/*! \reimp */ +bool Q3DockWindow::eventFilter(QObject * o, QEvent *e) +{ + if (!o->isWidgetType()) + return false; + + if (e->type() == QEvent::KeyPress && + (horHandle->mousePressed || + verHandle->mousePressed || + titleBar->mousePressed)) { + QKeyEvent *ke = (QKeyEvent*)e; + if (ke->key() == Qt::Key_Escape) { + horHandle->mousePressed = + verHandle->mousePressed = + titleBar->mousePressed = false; + endRectDraw(!opaque); + qApp->removeEventFilter(this); + return true; + } + } else if (((QWidget*)o)->window() != this && place() == OutsideDock && isWindow()) { + if ((e->type() == QEvent::WindowDeactivate || + e->type() == QEvent::WindowActivate)) + event(e); + } + return false; +} + +/*! \reimp */ +bool Q3DockWindow::event(QEvent *e) +{ + switch (e->type()) { + case QEvent::WindowDeactivate: + if (place() == OutsideDock && isWindow() && parentWidget() + && parentWidget()->isActiveWindow()) + return true; + break; + case QEvent::HideToParent: + emit visibilityChanged(false); + break; + case QEvent::ShowToParent: + emit visibilityChanged(true); + break; + case QEvent::WindowTitleChange: + { + QString s = Q3Frame::windowTitle(); + titleBar->setWindowTitle(s); +#ifndef QT_NO_TOOLTIP + horHandle->setToolTip(s); + verHandle->setToolTip(s); +#endif + break; + } + default: + break; + } + return Q3Frame::event(e); +} + +/*! + Returns the dock window's title. +*/ +QString Q3DockWindow::windowTitle() const +{ + return titleBar->windowTitle(); +} + +/*! \reimp */ +void Q3DockWindow::contextMenuEvent(QContextMenuEvent *e) +{ + QObject *o = this; + while (o) { + if (qobject_cast<Q3MainWindow*>(o)) + break; + o = o->parent(); + } + if (!o || ! ((Q3MainWindow*)o)->showDockMenu(e->globalPos())) + e->ignore(); +} + +QT_END_NAMESPACE + +#include "q3dockwindow.moc" + +#endif //QT_NO_MAINWINDOW diff --git a/src/qt3support/widgets/q3dockwindow.h b/src/qt3support/widgets/q3dockwindow.h new file mode 100644 index 0000000..bf53a82 --- /dev/null +++ b/src/qt3support/widgets/q3dockwindow.h @@ -0,0 +1,239 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the Qt3Support module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, 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 qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef Q3DOCKWINDOW_H +#define Q3DOCKWINDOW_H + +#include <Qt3Support/q3frame.h> + +QT_BEGIN_HEADER + +QT_BEGIN_NAMESPACE + +QT_MODULE(Qt3SupportLight) + +#ifndef QT_NO_MAINWINDOW + +class Q3DockWindowHandle; +class Q3DockWindowTitleBar; +class QPainter; +class Q3DockWindowResizeHandle; +class QBoxLayout; +class QHBoxLayout; +class QVBoxLayout; +class Q3DockArea; +class QWidgetResizeHandler; +class Q3MainWindow; +class Q3DockAreaLayout; +class Q3DockWindowPrivate; +class Q3ToolBar; +class QWindowsXPStyle; +class QRubberBand; + +class Q_COMPAT_EXPORT Q3DockWindow : public Q3Frame +{ + Q_OBJECT + Q_ENUMS(CloseMode Place) + Q_PROPERTY(int closeMode READ closeMode WRITE setCloseMode) + Q_PROPERTY(bool resizeEnabled READ isResizeEnabled WRITE setResizeEnabled) + Q_PROPERTY(bool movingEnabled READ isMovingEnabled WRITE setMovingEnabled) + Q_PROPERTY(bool horizontallyStretchable READ isHorizontallyStretchable WRITE setHorizontallyStretchable) + Q_PROPERTY(bool verticallyStretchable READ isVerticallyStretchable WRITE setVerticallyStretchable) + Q_PROPERTY(bool stretchable READ isStretchable) + Q_PROPERTY(bool newLine READ newLine WRITE setNewLine) + Q_PROPERTY(bool opaqueMoving READ opaqueMoving WRITE setOpaqueMoving) + Q_PROPERTY(int offset READ offset WRITE setOffset) + Q_PROPERTY(Place place READ place) + + friend class Q3DockWindowHandle; + friend class Q3DockWindowTitleBar; + friend class Q3DockArea; + friend class Q3DockAreaLayout; + friend class Q3MainWindow; + friend class QCEMainWindow; + friend class Q3ToolBar; + friend class QWindowsXPStyle; + +public: + enum Place { InDock, OutsideDock }; + enum CloseMode { Never = 0, Docked = 1, Undocked = 2, Always = Docked | Undocked }; + + Q3DockWindow(Place p = InDock, QWidget* parent=0, const char* name=0, Qt::WindowFlags f = 0); + Q3DockWindow(QWidget* parent, const char* name=0, Qt::WindowFlags f = 0); + ~Q3DockWindow(); + + virtual void setWidget(QWidget *w); + QWidget *widget() const; + + Place place() const { return curPlace; } + + Q3DockArea *area() const; + + virtual void setCloseMode(int m); + bool isCloseEnabled() const; + int closeMode() const; + + virtual void setResizeEnabled(bool b); + virtual void setMovingEnabled(bool b); + bool isResizeEnabled() const; + bool isMovingEnabled() const; + + virtual void setHorizontallyStretchable(bool b); + virtual void setVerticallyStretchable(bool b); + bool isHorizontallyStretchable() const; + bool isVerticallyStretchable() const; + void setHorizontalStretchable(bool b) { setHorizontallyStretchable(b); } + void setVerticalStretchable(bool b) { setVerticallyStretchable(b); } + bool isHorizontalStretchable() const { return isHorizontallyStretchable(); } + bool isVerticalStretchable() const { return isVerticallyStretchable(); } + bool isStretchable() const; + + virtual void setOffset(int o); + int offset() const; + + virtual void setFixedExtentWidth(int w); + virtual void setFixedExtentHeight(int h); + QSize fixedExtent() const; + + virtual void setNewLine(bool b); + bool newLine() const; + + Qt::Orientation orientation() const; + + QSize sizeHint() const; + QSize minimumSize() const; + QSize minimumSizeHint() const; + + QBoxLayout *boxLayout(); + + virtual void setOpaqueMoving(bool b); + bool opaqueMoving() const; + + bool eventFilter(QObject *o, QEvent *e); + + QString windowTitle() const; + +Q_SIGNALS: + void orientationChanged(Qt::Orientation o); + void placeChanged(Q3DockWindow::Place p); + void visibilityChanged(bool); + +public Q_SLOTS: + virtual void undock(QWidget *w); + virtual void undock() { undock(0); } + virtual void dock(); + virtual void setOrientation(Qt::Orientation o); + +protected: + void resizeEvent(QResizeEvent *e); + void showEvent(QShowEvent *e); + void hideEvent(QHideEvent *e); + void contextMenuEvent(QContextMenuEvent *e); + + void drawFrame(QPainter *); + void drawContents(QPainter *); + + bool event(QEvent *e); + +private Q_SLOTS: + void toggleVisible() { setVisible(!isVisible()); } + +private: + Q3DockWindow(Place p, QWidget* parent, const char* name, Qt::WindowFlags f, bool toolbar); + + void handleMove(const QPoint &pos, const QPoint &gp, bool drawRect); + void updateGui(); + void updateSplitterVisibility(bool visible); + + void startRectDraw(const QPoint &so, bool drawRect); + void endRectDraw(bool drawRect); + void updatePosition(const QPoint &globalPos ); + QWidget *areaAt(const QPoint &gp); + void removeFromDock(bool fixNewLines = true); + void swapRect(QRect &r, Qt::Orientation o, const QPoint &offset, Q3DockArea *area); + void init(); + +private: + Q3DockWindowHandle *horHandle, *verHandle; + Q3DockWindowTitleBar *titleBar; + QWidget *wid; + QRubberBand *rubberBand; + Q3DockArea *dockArea, *tmpDockArea; + QRect currRect; + Place curPlace; + Place state; + bool resizeEnabled : 1; + bool moveEnabled : 1; + bool nl : 1; + bool opaque : 1; + bool isToolbar : 1; + bool stretchable[3]; + Qt::Orientation startOrientation; + int cMode; + QPoint startOffset; + int offs; + QSize fExtent; + Q3DockWindowResizeHandle *hHandleTop, *hHandleBottom, *vHandleLeft, *vHandleRight; + QVBoxLayout *hbox; + QHBoxLayout *vbox; + QBoxLayout *childBox; + void *dockWindowData; + QPoint lastPos; + QSize lastSize; + QWidgetResizeHandler *widgetResizeHandler; + Q3DockWindowPrivate *d; + +private: + Q_DISABLE_COPY(Q3DockWindow) +}; + +inline Q3DockArea *Q3DockWindow::area() const +{ + return dockArea; +} + +#endif // QT_NO_MAINWINDOW + +QT_END_NAMESPACE + +QT_END_HEADER + +#endif // Q3DOCKWINDOW_H diff --git a/src/qt3support/widgets/q3frame.cpp b/src/qt3support/widgets/q3frame.cpp new file mode 100644 index 0000000..7798d46 --- /dev/null +++ b/src/qt3support/widgets/q3frame.cpp @@ -0,0 +1,200 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the Qt3Support module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, 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 qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "q3frame.h" +#include "qevent.h" +#include "qpainter.h" + +QT_BEGIN_NAMESPACE + +/*! \class Q3Frame + + \compat +*/ + +/*! + Creates a new frame with the given \a parent, object \a name, and + with widget flags \a f. +*/ +Q3Frame::Q3Frame(QWidget* parent, const char* name, Qt::WindowFlags f) + :QFrame(parent, f), marg(0) +{ + if (name) + setObjectName(QLatin1String(name)); + setAttribute(Qt::WA_LayoutOnEntireRect); +} + +/*! + Destructs the frame. +*/ +Q3Frame::~Q3Frame() +{ +} + +/*! + Paints the frame (or part of the frame) that's necessary, + depending on the \a event. +*/ +void Q3Frame::paintEvent(QPaintEvent * event) +{ + QPainter paint(this); + if (!contentsRect().contains(event->rect())) { + paint.save(); + paint.setClipRegion(event->region().intersected(frameRect())); + drawFrame(&paint); + paint.restore(); + } + if (event->rect().intersects(contentsRect())) { + paint.setClipRegion(event->region().intersected(contentsRect())); + drawContents(&paint); + } +} + +/*! + \fn void Q3Frame::drawContents(QPainter *painter) + + Virtual function that draws the contents of the frame on the given + \a painter. + + The QPainter is already open when you get it, and you must leave + it open. Painter \link QPainter::setWorldMatrix() + transformations\endlink are switched off on entry. If you + transform the painter, remember to take the frame into account and + \link QPainter::resetXForm() reset transformation\endlink before + returning. + + This function is reimplemented by subclasses that draw something + inside the frame. It should only draw inside contentsRect(). The + default function does nothing. + + \sa contentsRect(), QPainter::setClipRect() +*/ + +void Q3Frame::drawContents(QPainter *) +{ +} + +/*! + Draws the frame using the painter \a p and the current frame + attributes and color group. The rectangle inside the frame is not + affected. + + This function is virtual, but in general you do not need to + reimplement it. If you do, note that the QPainter is already open + and must remain open. + + \sa frameRect(), contentsRect(), drawContents(), frameStyle(), setPalette() +*/ + +void Q3Frame::drawFrame(QPainter *p) +{ + QFrame::drawFrame(p); +} + +/*! + \fn void Q3Frame::resizeEvent(QResizeEvent *event) + + This just calls frameChanged(); it does not make use of the \a + event itself. +*/ +void Q3Frame::resizeEvent(QResizeEvent *e) +{ + if (e->size() == e->oldSize()) + frameChanged(); +} + +/*! + Virtual function that is called when the frame style, line width + or mid-line width changes. + + This function can be reimplemented by subclasses that need to know + when the frame attributes change. +*/ + +void Q3Frame::frameChanged() +{ +} + + +/*! + \property Q3Frame::margin + \brief the width of the margin + + The margin is the distance between the innermost pixel of the + frame and the outermost pixel of contentsRect(). It is included in + frameWidth(). + + The margin is filled according to backgroundMode(). + + The default value is 0. + + \sa lineWidth(), frameWidth() +*/ + +void Q3Frame::setMargin(int w) +{ + if (marg == w) + return; + marg = w; + update(); + frameChanged(); +} + +/*! + \property Q3Frame::contentsRect + \brief the frame's contents rectangle (including the margins) +*/ +QRect Q3Frame::contentsRect() const +{ + QRect cr(QFrame::contentsRect()); + cr.adjust(marg, marg, -marg, -marg); + return cr; +} + +/*! + Returns the width of the frame (including the margin). +*/ +int Q3Frame::frameWidth() const +{ + return QFrame::frameWidth() + marg; +} + +QT_END_NAMESPACE diff --git a/src/qt3support/widgets/q3frame.h b/src/qt3support/widgets/q3frame.h new file mode 100644 index 0000000..05092b5 --- /dev/null +++ b/src/qt3support/widgets/q3frame.h @@ -0,0 +1,90 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the Qt3Support module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, 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 qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef Q3FRAME_H +#define Q3FRAME_H + +#include <QtGui/qframe.h> + +QT_BEGIN_HEADER + +QT_BEGIN_NAMESPACE + +QT_MODULE(Qt3SupportLight) + +class Q_COMPAT_EXPORT Q3Frame : public QFrame +{ + Q_OBJECT + Q_PROPERTY(int margin READ margin WRITE setMargin) + Q_PROPERTY(QRect contentsRect READ contentsRect) + +public: + Q3Frame(QWidget* parent, const char* name = 0, Qt::WindowFlags f = 0); + ~Q3Frame(); +#ifndef qdoc + bool lineShapesOk() const { return true; } +#endif + + int margin() const { return marg; } + void setMargin(int); + + QRect contentsRect() const; + int frameWidth() const; + +protected: + void paintEvent(QPaintEvent *); + void resizeEvent(QResizeEvent *); + + virtual void frameChanged(); + virtual void drawFrame(QPainter *); + virtual void drawContents(QPainter *); + +private: + Q_DISABLE_COPY(Q3Frame) + + int marg; +}; + +QT_END_NAMESPACE + +QT_END_HEADER + +#endif // Q3FRAME_H diff --git a/src/qt3support/widgets/q3grid.cpp b/src/qt3support/widgets/q3grid.cpp new file mode 100644 index 0000000..46c12fb --- /dev/null +++ b/src/qt3support/widgets/q3grid.cpp @@ -0,0 +1,138 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the Qt3Support module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, 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 qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "q3grid.h" +#include "qlayout.h" +#include "qapplication.h" + +QT_BEGIN_NAMESPACE + +/*! + \class Q3Grid + \brief The Q3Grid widget provides simple geometry management of its children. + + \compat + + The grid places its widgets either in columns or in rows depending + on its orientation. + + The number of rows \e or columns is defined in the constructor. + All the grid's children will be placed and sized in accordance + with their sizeHint() and sizePolicy(). + + Use setMargin() to add space around the grid itself, and + setSpacing() to add space between the widgets. + + \sa Q3VBox Q3HBox QGridLayout +*/ + +/*! + \typedef Q3Grid::Direction + \internal +*/ + +/*! + Constructs a grid widget with parent \a parent, called \a name. + If \a orient is \c Horizontal, \a n specifies the number of + columns. If \a orient is \c Vertical, \a n specifies the number of + rows. The widget flags \a f are passed to the Q3Frame constructor. +*/ +Q3Grid::Q3Grid(int n, Qt::Orientation orient, QWidget *parent, const char *name, + Qt::WindowFlags f) + : Q3Frame(parent, name, f) +{ + int nCols, nRows; + if (orient == Qt::Horizontal) { + nCols = n; + nRows = -1; + } else { + nCols = -1; + nRows = n; + } + (new QGridLayout(this, nRows, nCols, 0, 0, name))->setAutoAdd(true); +} + + + +/*! + Constructs a grid widget with parent \a parent, called \a name. + \a n specifies the number of columns. The widget flags \a f are + passed to the Q3Frame constructor. + */ +Q3Grid::Q3Grid(int n, QWidget *parent, const char *name, Qt::WindowFlags f) + : Q3Frame(parent, name, f) +{ + (new QGridLayout(this, -1, n, 0, 0, name))->setAutoAdd(true); +} + + +/*! + Sets the spacing between the child widgets to \a space. +*/ + +void Q3Grid::setSpacing(int space) +{ + if (layout()) + layout()->setSpacing(space); +} + + +/*!\reimp + */ +void Q3Grid::frameChanged() +{ + if (layout()) + layout()->setMargin(frameWidth()); +} + + +/*! + \reimp +*/ + +QSize Q3Grid::sizeHint() const +{ + QWidget *mThis = (QWidget*)this; + QApplication::sendPostedEvents(mThis, QEvent::ChildInserted); + return Q3Frame::sizeHint(); +} + +QT_END_NAMESPACE diff --git a/src/qt3support/widgets/q3grid.h b/src/qt3support/widgets/q3grid.h new file mode 100644 index 0000000..544145d --- /dev/null +++ b/src/qt3support/widgets/q3grid.h @@ -0,0 +1,79 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the Qt3Support module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, 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 qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef Q3GRID_H +#define Q3GRID_H + +#include <Qt3Support/q3frame.h> + +QT_BEGIN_HEADER + +QT_BEGIN_NAMESPACE + +QT_MODULE(Qt3SupportLight) + +class QGridLayout; + +class Q_COMPAT_EXPORT Q3Grid : public Q3Frame +{ + Q_OBJECT +public: + Q3Grid(int n, QWidget* parent=0, const char* name=0, Qt::WindowFlags f = 0); + Q3Grid(int n, Qt::Orientation orient, QWidget* parent=0, const char* name=0, + Qt::WindowFlags f = 0); + + void setSpacing(int); + QSize sizeHint() const; + + typedef Qt::Orientation Direction; + +protected: + void frameChanged(); + +private: + Q_DISABLE_COPY(Q3Grid) +}; + +QT_END_NAMESPACE + +QT_END_HEADER + +#endif // Q3GRID_H diff --git a/src/qt3support/widgets/q3gridview.cpp b/src/qt3support/widgets/q3gridview.cpp new file mode 100644 index 0000000..7de2f45 --- /dev/null +++ b/src/qt3support/widgets/q3gridview.cpp @@ -0,0 +1,367 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the Qt3Support module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, 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 qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + + +#include "q3gridview.h" +#include "qpainter.h" + +QT_BEGIN_NAMESPACE + +using namespace Qt; + +/*! + \class Q3GridView + \brief The Q3GridView class provides an abstract base for + fixed-size grids. + + \compat + + A grid view consists of a number of abstract cells organized in + rows and columns. The cells have a fixed size and are identified + with a row index and a column index. The top-left cell is in row + 0, column 0. The bottom-right cell is in row numRows()-1, column + numCols()-1. + + You can define \l{Q3GridView::numRows} {numRows}, + \l{Q3GridView::numCols} {numCols}, \l{Q3GridView::cellWidth} + {cellWidth} and \l{Q3GridView::cellHeight} {cellHeight}. Reimplement + the pure virtual function paintCell() to draw the contents of a + cell. + + With ensureCellVisible(), you can ensure a certain cell is + visible. With rowAt() and columnAt() you can find a cell based on + the given x- and y-coordinates. + + If you need to monitor changes to the grid's dimensions (i.e. when + numRows or numCols is changed), reimplement the dimensionChange() + change handler. + + Note: the row and column indices are always given in the order, + row (vertical offset) then column (horizontal offset). This order + is the opposite of all pixel operations, which are given in the + order x (horizontal offset), y (vertical offset). + + Q3GridView is a very simple abstract class based on Q3ScrollView. It + is designed to simplify the task of drawing many cells of the same + size in a potentially scrollable canvas. If you need rows and + columns with different sizes, use a Q3Table instead. If you need a + simple list of items, use a Q3ListBox. If you need to present + hierarichal data use a Q3ListView, and if you need random objects + at random positions, consider using either a Q3IconView or a + Q3Canvas. +*/ + + +/*! + Constructs a grid view. + + The \a parent, \a name and widget flag, \a f, arguments are passed + to the Q3ScrollView constructor. +*/ +Q3GridView::Q3GridView(QWidget *parent, const char *name, Qt::WindowFlags f) + : Q3ScrollView(parent, name, f | WStaticContents), + nrows(5), ncols(5), cellw(12), cellh(12) +{ + viewport()->setBackgroundMode(PaletteBase); + setBackgroundMode(PaletteBackground, PaletteBase); + viewport()->setFocusProxy(this); +} + +/*! + Destroys the grid view. +*/ +Q3GridView::~Q3GridView() +{ +} + +void Q3GridView::updateGrid() +{ + resizeContents(ncols * cellw, nrows * cellh); +} + +/*! + \property Q3GridView::numRows + \brief The number of rows in the grid + + \sa numCols +*/ +void Q3GridView::setNumRows(int numRows) +{ + int oldnrows = nrows; + nrows = numRows; + dimensionChange(oldnrows, ncols); + updateGrid(); +} + +/*! + \property Q3GridView::numCols + \brief The number of columns in the grid + + \sa numRows +*/ +void Q3GridView::setNumCols(int numCols) +{ + int oldncols = ncols; + ncols = numCols; + dimensionChange(nrows, oldncols); + updateGrid(); +} + +/*! + \property Q3GridView::cellWidth + \brief The width of a grid column + + All columns in a grid view have the same width. + + \sa cellHeight +*/ +void Q3GridView::setCellWidth(int cellWidth) +{ + cellw = cellWidth; + updateGrid(); + updateContents(); +} + +/*! + \property Q3GridView::cellHeight + \brief The height of a grid row + + All rows in a grid view have the same height. + + \sa cellWidth +*/ +void Q3GridView::setCellHeight(int cellHeight) +{ + cellh = cellHeight; + updateGrid(); + updateContents(); +} + +/*! + Returns the geometry of cell (\a row, \a column) in the content + coordinate system. + + \sa cellRect() +*/ +QRect Q3GridView::cellGeometry(int row, int column) +{ + QRect r; + if (row >= 0 && row < nrows && column >= 0 && column < ncols) + r.setRect(cellw * column, cellh * row, cellw, cellh); + return r; +} + +/*! + Repaints cell (\a row, \a column). + + If \a erase is true, Qt erases the area of the cell before the + paintCell() call; otherwise no erasing takes place. + + \sa QWidget::repaint() +*/ +void Q3GridView::repaintCell(int row, int column, bool erase) +{ + repaintContents(cellGeometry(row, column), erase); +} + +/*! + Updates cell (\a row, \a column). + + \sa QWidget::update() +*/ +void Q3GridView::updateCell(int row, int column) +{ + updateContents(cellGeometry(row, column)); +} + +/*! + Ensures cell (\a row, \a column) is visible, scrolling the grid + view if necessary. +*/ +void Q3GridView::ensureCellVisible(int row, int column) +{ + QRect r = cellGeometry(row, column); + ensureVisible(r.x(), r.y(), r.width(), r.height()); +} + +/*! + This function fills the \a cw pixels wide and \a ch pixels high + rectangle starting at position (\a cx, \a cy) with the background + color using the painter \a p. + + paintEmptyArea() is invoked by drawContents() to erase or fill + unused areas. +*/ + +void Q3GridView::paintEmptyArea(QPainter *p, int cx ,int cy, int cw, int ch) +{ + if (gridSize().width() >= contentsWidth() && gridSize().height() >= contentsHeight()) + return; + // Region of the rect we should draw + contentsToViewport(cx, cy, cx, cy); + QRegion reg(QRect(cx, cy, cw, ch)); + // Subtract the table from it + reg = reg.subtracted(QRect(contentsToViewport(QPoint(0, 0)), gridSize())); + + // And draw the rectangles (transformed as needed) + QVector<QRect> r = reg.rects(); + const QBrush &brush = backgroundBrush(); + for (int i = 0; i < (int)r.count(); ++i) + p->fillRect(r[ i ], brush); +} + +/*!\reimp + */ +void Q3GridView::drawContents(QPainter *p, int cx, int cy, int cw, int ch) +{ + int colfirst = columnAt(cx); + int collast = columnAt(cx + cw); + int rowfirst = rowAt(cy); + int rowlast = rowAt(cy + ch); + + if (rowfirst == -1 || colfirst == -1) { + paintEmptyArea(p, cx, cy, cw, ch); + return; + } + + if (collast < 0 || collast >= ncols) + collast = ncols-1; + if (rowlast < 0 || rowlast >= nrows) + rowlast = nrows-1; + + // Go through the rows + for (int r = rowfirst; r <= rowlast; ++r) { + // get row position and height + int rowp = r * cellh; + + // Go through the columns in the row r + // if we know from where to where, go through [colfirst, collast], + // else go through all of them + for (int c = colfirst; c <= collast; ++c) { + // get position and width of column c + int colp = c * cellw; + // Translate painter and draw the cell + p->translate(colp, rowp); + paintCell(p, r, c); + p->translate(-colp, -rowp); + } + } + + // Paint empty rects + paintEmptyArea(p, cx, cy, cw, ch); +} + +/*! + \reimp + + (Implemented to get rid of a compiler warning.) +*/ +void Q3GridView::drawContents(QPainter *) +{ +} + +/*! + \fn void Q3GridView::dimensionChange(int oldNumRows, int oldNumCols) + + This change handler is called whenever any of the grid's + dimensions change. \a oldNumRows and \a oldNumCols contain the + old dimensions, numRows() and numCols() contain the new + dimensions. +*/ +void Q3GridView::dimensionChange(int, int) {} + + + +/*! + \fn int Q3GridView::rowAt(int y) const + + Returns the number of the row at position \a y. \a y must be given + in content coordinates. + + \sa columnAt() +*/ + +/*! + \fn int Q3GridView::columnAt(int x) const + + Returns the number of the column at position \a x. \a x must be + given in content coordinates. + + \sa rowAt() +*/ + +/*! + \fn void Q3GridView::paintCell(QPainter *p, int row, int col) + + This pure virtual function is called to paint the single cell at + (\a row, \a col) using painter \a p. The painter must be open when + paintCell() is called and must remain open. + + The coordinate system is \link QPainter::translate() translated + \endlink so that the origin is at the top-left corner of the cell + to be painted, i.e. \e cell coordinates. Do not scale or shear + the coordinate system (or if you do, restore the transformation + matrix before you return). + + The painter is not clipped by default in order to get maximum + efficiency. If you want clipping, use + + \snippet doc/src/snippets/code/src_qt3support_widgets_q3gridview.cpp 0 +*/ + +/*! + \fn QRect Q3GridView::cellRect() const + + Returns the geometry of a cell in a cell's coordinate system. This + is a convenience function useful in paintCell(). It is equivalent + to QRect(0, 0, cellWidth(), cellHeight()). + + \sa cellGeometry() + +*/ + +/*! + \fn QSize Q3GridView::gridSize() const + + Returns the size of the grid in pixels. +*/ + +QT_END_NAMESPACE diff --git a/src/qt3support/widgets/q3gridview.h b/src/qt3support/widgets/q3gridview.h new file mode 100644 index 0000000..a46c6fc --- /dev/null +++ b/src/qt3support/widgets/q3gridview.h @@ -0,0 +1,137 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the Qt3Support module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, 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 qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef Q3GRIDVIEW_H +#define Q3GRIDVIEW_H + +#include <Qt3Support/q3scrollview.h> + +QT_BEGIN_HEADER + +QT_BEGIN_NAMESPACE + +QT_MODULE(Qt3SupportLight) + +class Q3GridViewPrivate; + +class Q_COMPAT_EXPORT Q3GridView : public Q3ScrollView +{ + Q_OBJECT + Q_PROPERTY(int numRows READ numRows WRITE setNumRows) + Q_PROPERTY(int numCols READ numCols WRITE setNumCols) + Q_PROPERTY(int cellWidth READ cellWidth WRITE setCellWidth) + Q_PROPERTY(int cellHeight READ cellHeight WRITE setCellHeight) +public: + + Q3GridView(QWidget *parent=0, const char *name=0, Qt::WindowFlags f=0); + ~Q3GridView(); + + int numRows() const; + virtual void setNumRows(int); + int numCols() const; + virtual void setNumCols(int); + + int cellWidth() const; + virtual void setCellWidth(int); + int cellHeight() const; + virtual void setCellHeight(int); + + QRect cellRect() const; + QRect cellGeometry(int row, int column); + QSize gridSize() const; + + int rowAt(int y) const; + int columnAt(int x) const; + + void repaintCell(int row, int column, bool erase=true); + void updateCell(int row, int column); + void ensureCellVisible(int row, int column); + +protected: + virtual void paintCell(QPainter *, int row, int col) = 0; + virtual void paintEmptyArea(QPainter *p, int cx, int cy, int cw, int ch); + + void drawContents(QPainter *p, int cx, int cy, int cw, int ch); + + virtual void dimensionChange(int, int); + +private: + void drawContents(QPainter*); + void updateGrid(); + + int nrows; + int ncols; + int cellw; + int cellh; + Q3GridViewPrivate* d; + + Q_DISABLE_COPY(Q3GridView) +}; + +inline int Q3GridView::cellWidth() const +{ return cellw; } + +inline int Q3GridView::cellHeight() const +{ return cellh; } + +inline int Q3GridView::rowAt(int y) const +{ return y / cellh; } + +inline int Q3GridView::columnAt(int x) const +{ return x / cellw; } + +inline int Q3GridView::numRows() const +{ return nrows; } + +inline int Q3GridView::numCols() const +{return ncols; } + +inline QRect Q3GridView::cellRect() const +{ return QRect(0, 0, cellw, cellh); } + +inline QSize Q3GridView::gridSize() const +{ return QSize(ncols * cellw, nrows * cellh); } + +QT_END_NAMESPACE + +QT_END_HEADER + +#endif // Q3GRIDVIEW_H diff --git a/src/qt3support/widgets/q3groupbox.cpp b/src/qt3support/widgets/q3groupbox.cpp new file mode 100644 index 0000000..b4414fb --- /dev/null +++ b/src/qt3support/widgets/q3groupbox.cpp @@ -0,0 +1,964 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the Qt3Support module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, 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 qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "q3groupbox.h" + +#include "qlayout.h" +#include "qpainter.h" +#include "qbitmap.h" +#include "q3accel.h" +#include "qradiobutton.h" +#include "qdrawutil.h" +#include "qapplication.h" +#include "qstyle.h" +#include "qcheckbox.h" +#include "qaccessible.h" +#include "qstyleoption.h" +#include "qdebug.h" + +QT_BEGIN_NAMESPACE + +/*! + \class Q3GroupBox + \brief The Q3GroupBox widget provides a group box frame with a title. + + \compat + + A group box provides a frame, a title and a keyboard shortcut, and + displays various other widgets inside itself. The title is on top, + the keyboard shortcut moves keyboard focus to one of the group + box's child widgets, and the child widgets are usually laid out + horizontally (or vertically) inside the frame. + + The simplest way to use it is to create a group box with the + desired number of columns (or rows) and orientation, and then just + create widgets with the group box as parent. + + It is also possible to change the orientation() and number of + columns() after construction, or to ignore all the automatic + layout support and manage the layout yourself. You can add 'empty' + spaces to the group box with addSpace(). + + Q3GroupBox also lets you set the title() (normally set in the + constructor) and the title's alignment(). + + You can change the spacing used by the group box with + setInsideMargin() and setInsideSpacing(). To minimize space + consumption, you can remove the right, left and bottom edges of + the frame with setFlat(). + + \sa QButtonGroup +*/ + +class QCheckBox; + +class Q3GroupBoxPrivate +{ +public: + Q3GroupBoxPrivate(Q3GroupBox *w): + q(w), vbox(0), grid(0), row(0), col(0), nRows(0), nCols(0), dir(Qt::Horizontal), + spac(5), marg(11), + checkbox(0), + frameStyle(Q3GroupBox::GroupBoxPanel | Q3GroupBox::Sunken), + lineWidth(1), midLineWidth(0), frameWidth(0), + leftFrameWidth(0), rightFrameWidth(0), + topFrameWidth(0), bottomFrameWidth(0) {} + + void updateFrameWidth(); + void updateStyledFrameWidths(); + + Q3GroupBox *q; + QVBoxLayout *vbox; + QGridLayout *grid; + int row; + int col; + int nRows, nCols; + Qt::Orientation dir; + int spac, marg; + + QCheckBox *checkbox; + + int frameStyle; + int oldFrameStyle; + short lineWidth, //line width + midLineWidth; //midline width + int frameWidth; + short leftFrameWidth, rightFrameWidth, + topFrameWidth, bottomFrameWidth; +}; + +/*! + \internal + Updates the frame widths from the style. +*/ +void Q3GroupBoxPrivate::updateStyledFrameWidths() +{ + QStyleOptionFrameV2 opt; + opt.initFrom(q); + QRect cr = q->style()->subElementRect(QStyle::SE_FrameContents, &opt, q); + leftFrameWidth = cr.left() - opt.rect.left(); + topFrameWidth = cr.top() - opt.rect.top(); + rightFrameWidth = opt.rect.right() - cr.right(), + bottomFrameWidth = opt.rect.bottom() - cr.bottom(); + frameWidth = qMax(qMax(leftFrameWidth, rightFrameWidth), + qMax(topFrameWidth, bottomFrameWidth)); +} + +/*! + \internal + Updated the frameWidth parameter. +*/ + +void Q3GroupBoxPrivate::updateFrameWidth() +{ + QRect fr = q->frameRect(); + + int frameShape = frameStyle & QFrame::Shape_Mask; + int frameShadow = frameStyle & QFrame::Shadow_Mask; + + frameWidth = -1; + + switch (frameShape) { + + case QFrame::NoFrame: + frameWidth = 0; + break; + + case QFrame::Box: + case QFrame::HLine: + case QFrame::VLine: + switch (frameShadow) { + case QFrame::Plain: + frameWidth = lineWidth; + break; + case QFrame::Raised: + case QFrame::Sunken: + frameWidth = (short)(lineWidth*2 + midLineWidth); + break; + } + break; + + case QFrame::StyledPanel: + updateStyledFrameWidths(); + break; + + case QFrame::WinPanel: + frameWidth = 2; + break; + + + case QFrame::Panel: + switch (frameShadow) { + case QFrame::Plain: + case QFrame::Raised: + case QFrame::Sunken: + frameWidth = lineWidth; + break; + } + break; + } + + if (frameWidth == -1) // invalid style + frameWidth = 0; + + q->setFrameRect(fr); +} + + + + + +/*! + Constructs a group box widget with no title. + + The \a parent and \a name arguments are passed to the QWidget + constructor. + + This constructor does not do automatic layout. +*/ + +Q3GroupBox::Q3GroupBox(QWidget *parent, const char *name) + : QGroupBox(parent, name) +{ + init(); +} + +/*! + Constructs a group box with the title \a title. + + The \a parent and \a name arguments are passed to the QWidget + constructor. + + This constructor does not do automatic layout. +*/ + +Q3GroupBox::Q3GroupBox(const QString &title, QWidget *parent, const char *name) + : QGroupBox(parent, name) +{ + init(); + setTitle(title); +} + +/*! + Constructs a group box with no title. Child widgets will be + arranged in \a strips rows or columns (depending on \a + orientation). + + The \a parent and \a name arguments are passed to the QWidget + constructor. +*/ + +Q3GroupBox::Q3GroupBox(int strips, Qt::Orientation orientation, + QWidget *parent, const char *name) + : QGroupBox(parent, name) +{ + init(); + setColumnLayout(strips, orientation); +} + +/*! + Constructs a group box titled \a title. Child widgets will be + arranged in \a strips rows or columns (depending on \a + orientation). + + The \a parent and \a name arguments are passed to the QWidget + constructor. +*/ + +Q3GroupBox::Q3GroupBox(int strips, Qt::Orientation orientation, + const QString &title, QWidget *parent, + const char *name) + : QGroupBox(parent, name) +{ + init(); + setTitle(title); + setColumnLayout(strips, orientation); +} + +/*! + Destroys the group box. +*/ +Q3GroupBox::~Q3GroupBox() +{ + delete d; +} + +void Q3GroupBox::init() +{ + d = new Q3GroupBoxPrivate(this); +} + + +/*! \reimp +*/ +void Q3GroupBox::resizeEvent(QResizeEvent *e) +{ + QGroupBox::resizeEvent(e); +} + + +/*! + Adds an empty cell at the next free position. If \a size is + greater than 0, the empty cell takes \a size to be its fixed width + (if orientation() is \c Horizontal) or height (if orientation() is + \c Vertical). + + Use this method to separate the widgets in the group box or to + skip the next free cell. For performance reasons, call this method + after calling setColumnLayout() or by changing the \l + Q3GroupBox::columns or \l Q3GroupBox::orientation properties. It is + generally a good idea to call these methods first (if needed at + all), and insert the widgets and spaces afterwards. +*/ +void Q3GroupBox::addSpace(int size) +{ + QApplication::sendPostedEvents(this, QEvent::ChildInserted); + + if (d->nCols <= 0 || d->nRows <= 0) + return; + + if (d->row >= d->nRows || d->col >= d->nCols) + d->grid->expand(d->row+1, d->col+1); + + if (size > 0) { + QSpacerItem *spacer + = new QSpacerItem((d->dir == Qt::Horizontal) ? 0 : size, + (d->dir == Qt::Vertical) ? 0 : size, + QSizePolicy::Fixed, QSizePolicy::Fixed); + d->grid->addItem(spacer, d->row, d->col); + } + + skip(); +} + +/*! + \property Q3GroupBox::columns + \brief the number of columns or rows (depending on \l Q3GroupBox::orientation) in the group box + + Usually it is not a good idea to set this property because it is + slow (it does a complete layout). It is best to set the number + of columns directly in the constructor. +*/ +int Q3GroupBox::columns() const +{ + if (d->dir == Qt::Horizontal) + return d->nCols; + return d->nRows; +} + +void Q3GroupBox::setColumns(int c) +{ + setColumnLayout(c, d->dir); +} + +/*! + Returns the width of the empty space between the items in the + group and the frame of the group. + + Only applies if the group box has a defined orientation. + + The default is usually 11, by may vary depending on the platform + and style. + + \sa setInsideMargin(), orientation +*/ +int Q3GroupBox::insideMargin() const +{ + return d->marg; +} + +/*! + Returns the width of the empty space between each of the items + in the group. + + Only applies if the group box has a defined orientation. + + The default is usually 5, by may vary depending on the platform + and style. + + \sa setInsideSpacing(), orientation +*/ +int Q3GroupBox::insideSpacing() const +{ + return d->spac; +} + +/*! + Sets the width of the inside margin to \a m pixels. + + \sa insideMargin() +*/ +void Q3GroupBox::setInsideMargin(int m) +{ + d->marg = m; + setColumnLayout(columns(), d->dir); +} + +/*! + Sets the width of the empty space between each of the items in + the group to \a s pixels. + + \sa insideSpacing() +*/ +void Q3GroupBox::setInsideSpacing(int s) +{ + d->spac = s; + setColumnLayout(columns(), d->dir); +} + +/*! + \property Q3GroupBox::orientation + \brief the group box's orientation + + A horizontal group box arranges its children in columns, while a + vertical group box arranges them in rows. + + Usually it is not a good idea to set this property because it is + slow (it does a complete layout). It is better to set the + orientation directly in the constructor. +*/ +void Q3GroupBox::setOrientation(Qt::Orientation o) +{ + setColumnLayout(columns(), o); +} + + +Qt::Orientation Q3GroupBox::orientation() const +{ + return d->dir; +} + +/*! + Changes the layout of the group box. This function is only useful + in combination with the default constructor that does not take any + layout information. This function will put all existing children + in the new layout. It is not good Qt programming style to call + this function after children have been inserted. Sets the number + of columns or rows to be \a strips, depending on \a direction. + + \sa orientation columns +*/ +void Q3GroupBox::setColumnLayout(int strips, Qt::Orientation direction) +{ + if (layout()) + delete layout(); + + d->vbox = 0; + d->grid = 0; + + if (strips < 0) // if 0, we create the d->vbox but not the d->grid. See below. + return; + + d->vbox = new QVBoxLayout(this, d->marg, 0); + + d->nCols = 0; + d->nRows = 0; + d->dir = direction; + + // Send all child events and ignore them. Otherwise we will end up + // with doubled insertion. This won't do anything because d->nCols == + // d->nRows == 0. + QApplication::sendPostedEvents(this, QEvent::ChildInserted); + + // if 0 or smaller , create a vbox-layout but no grid. This allows + // the designer to handle its own grid layout in a group box. + if (strips <= 0) + return; + + d->dir = direction; + if (d->dir == Qt::Horizontal) { + d->nCols = strips; + d->nRows = 1; + } else { + d->nCols = 1; + d->nRows = strips; + } + d->grid = new QGridLayout(d->nRows, d->nCols, d->spac); + d->row = d->col = 0; + d->grid->setAlignment(Qt::AlignTop); + d->vbox->addLayout(d->grid); + + // Add all children + QObjectList childList = children(); + if (!childList.isEmpty()) { + for (int i = 0; i < childList.size(); ++i) { + QObject *o = childList.at(i); + if (o->isWidgetType() && o != d->checkbox) + insertWid(static_cast<QWidget *>(o)); + } + } +} + +/*!\reimp */ +void Q3GroupBox::childEvent(QChildEvent *c) +{ + QGroupBox::childEvent(c); + if (!c->inserted() || !c->child()->isWidgetType()) + return; + if (d->grid) { + insertWid((QWidget*)c->child()); + } +} + +void Q3GroupBox::insertWid(QWidget* w) +{ + if (d->row >= d->nRows || d->col >= d->nCols) + d->grid->expand(d->row+1, d->col+1); + d->grid->addWidget(w, d->row, d->col); + skip(); +} + + +void Q3GroupBox::skip() +{ + // Same as QGrid::skip() + if (d->dir == Qt::Horizontal) { + if (d->col+1 < d->nCols) { + d->col++; + } else { + d->col = 0; + d->row++; + } + } else { //Vertical + if (d->row+1 < d->nRows) { + d->row++; + } else { + d->row = 0; + d->col++; + } + } +} + + +/*! \reimp */ +void Q3GroupBox::changeEvent(QEvent *ev) +{ + QGroupBox::changeEvent(ev); +} + +/*! \reimp */ +bool Q3GroupBox::event(QEvent *e) +{ + if (e->type()==QEvent::Paint) + { + QStyleOptionGroupBox opt; + initStyleOption(&opt); + opt.lineWidth=d->lineWidth; + opt.midLineWidth=d->midLineWidth; + QPainter p(this); + if (frameShape()==GroupBoxPanel) + { + style()->drawComplexControl(QStyle::CC_GroupBox, &opt, &p, this); + } + else { + //in case it is a Paint event with a frame shape different from the group box + const QRect textRect = style()->subControlRect(QStyle::CC_GroupBox, &opt, QStyle::SC_GroupBoxLabel, this); + const QRect checkBoxRect = style()->subControlRect(QStyle::CC_GroupBox, &opt, QStyle::SC_GroupBoxCheckBox, this); + + // Draw title + if ((opt.subControls & QStyle::SC_GroupBoxLabel) && !opt.text.isEmpty()) { + QColor textColor = opt.textColor; + if (textColor.isValid()) + p.setPen(textColor); + int alignment = int(opt.textAlignment); + if (!style()->styleHint(QStyle::SH_UnderlineShortcut, &opt, this)) + alignment |= Qt::TextHideMnemonic; + + style()->drawItemText(&p, textRect, Qt::TextShowMnemonic | Qt::AlignHCenter | alignment, + opt.palette, opt.state & QStyle::State_Enabled, opt.text, + textColor.isValid() ? QPalette::NoRole : QPalette::WindowText); + + if (opt.state & QStyle::State_HasFocus) { + QStyleOptionFocusRect fropt; + fropt.QStyleOption::operator=(opt); + fropt.rect = textRect; + style()->drawPrimitive(QStyle::PE_FrameFocusRect, &fropt, &p, this); + } + } + + // Draw checkbox + if (opt.subControls & QStyle::SC_GroupBoxCheckBox) { + QStyleOptionButton box; + box.QStyleOption::operator=(opt); + box.rect = checkBoxRect; + style()->drawPrimitive(QStyle::PE_IndicatorCheckBox, &box, &p, this); + } + + //sets clipping + QRegion region(rect()); + if (!title().isEmpty()) { + bool ltr = layoutDirection() == Qt::LeftToRight; + QRect finalRect = checkBoxRect.united(textRect); + if (isCheckable()) + finalRect.adjust(ltr ? -4 : 0, 0, ltr ? 0 : 4, 0); + region -= finalRect; + } + p.setClipRegion(region); + + drawFrame(&p); + } + return false; + } + return QGroupBox::event(e); +} + +/*! + \fn void Q3GroupBox::drawFrame(QPainter *p) + \internal +*/ + +void Q3GroupBox::drawFrame(QPainter *p) +{ + QPoint p1, p2; + QStyleOptionFrame opt; + opt.init(this); + + int frameShape = d->frameStyle & QFrame::Shape_Mask; + int frameShadow = d->frameStyle & QFrame::Shadow_Mask; + + int lw = 0; + int mlw = 0; + opt.rect = frameRect(); + + switch (frameShape) { + case QFrame::Box: + case QFrame::HLine: + case QFrame::VLine: + case QFrame::StyledPanel: + lw = d->lineWidth; + mlw = d->midLineWidth; + break; + default: + // most frame styles do not handle customized line and midline widths + // (see updateFrameWidth()). + lw = d->frameWidth; + break; + } + opt.lineWidth = lw; + opt.midLineWidth = mlw; + if (frameShadow == Sunken) + opt.state |= QStyle::State_Sunken; + else if (frameShadow == Raised) + opt.state |= QStyle::State_Raised; + + switch (frameShape) { + case Box: + if (frameShadow == Plain) + qDrawPlainRect(p, opt.rect, opt.palette.foreground().color(), lw); + else + qDrawShadeRect(p, opt.rect, opt.palette, frameShadow == Sunken, lw, mlw); + break; + + case StyledPanel: + style()->drawPrimitive(QStyle::PE_Frame, &opt, p, this); + break; + + case Panel: + if (frameShadow == Plain) + qDrawPlainRect(p, opt.rect, opt.palette.foreground().color(), lw); + else + qDrawShadePanel(p, opt.rect, opt.palette, frameShadow == Sunken, lw); + break; + + case WinPanel: + if (frameShadow == Plain) + qDrawPlainRect(p, opt.rect, opt.palette.foreground().color(), lw); + else + qDrawWinPanel(p, opt.rect, opt.palette, frameShadow == Sunken); + break; + case HLine: + case VLine: + if (frameShape == HLine) { + p1 = QPoint(opt.rect.x(), opt.rect.height() / 2); + p2 = QPoint(opt.rect.x() + opt.rect.width(), p1.y()); + } else { + p1 = QPoint(opt.rect.x()+opt.rect.width() / 2, 0); + p2 = QPoint(p1.x(), opt.rect.height()); + } + if (frameShadow == Plain) { + QPen oldPen = p->pen(); + p->setPen(QPen(opt.palette.foreground().color(), lw)); + p->drawLine(p1, p2); + p->setPen(oldPen); + } else { + qDrawShadeLine(p, p1, p2, opt.palette, frameShadow == Sunken, lw, mlw); + } + break; + } + +#ifdef QT_KEYPAD_NAVIGATION + if (QApplication::keypadNavigationEnabled() && hasFocus()) { + QStyleOptionFocusRect fopt; + fopt.init(this); + fopt.state |= QStyle::State_KeyboardFocusChange; + fopt.rect = frameRect(); + style()->drawPrimitive(QStyle::PE_FrameFocusRect, &fopt, p, this); + } +#endif +} + +/*! + \property Q3GroupBox::frameShadow + \brief the frame shadow value from the frame style + + \sa frameStyle() +*/ + +/* + \enum Q3GroupBox::FrameShape + + This enum defines the available frame shapes a group box can + have. All values have equivalents in QFrame. + + \value Box QFrame::Box + \value Sunken QFrame::Sunken + \value Plain QFrame::Plain + \value Raised QFrame::Raised + \value MShadow QFrame::Shadow_Mask + \value NoFrame QFrame::NoFrame + \value Panel QFrame::Panel + \value StyledPanel QFrame::StyledPanel + \value HLine QFrame::HLine + \value VLine QFrame::VLine + \value WinPanel QFrame::WinPanel + \value ToolBarPanel QFrame::StyledPanel + \value MenuBarPanel = QFrame::StyledPanel + \value PopupPanel QFrame::StyledPanel + \value LineEditPanel QFrame::StyledPanel + \value TabWidgetPanel QFrame::StyledPanel + \value GroupBoxPanel 0x0007 + \value MShape QFrame::Shape_Mask +*/ + + +void Q3GroupBox::setFrameShadow(DummyFrame s) +{ + setFrameStyle((d->frameStyle & MShape) | s); +} + +Q3GroupBox::DummyFrame Q3GroupBox::frameShadow() const +{ + return (DummyFrame) (d->frameStyle & MShadow); +} + +/*! + \property Q3GroupBox::frameShape + \brief the frame shape value from the frame style + + \sa frameStyle(), frameShadow() +*/ + +void Q3GroupBox::setFrameShape(DummyFrame s) +{ + setFrameStyle((d->frameStyle & MShadow) | s); +} + +Q3GroupBox::DummyFrame Q3GroupBox::frameShape() const +{ + return (DummyFrame) (d->frameStyle & MShape); +} + +/*! + \fn void Q3GroupBox::setFrameStyle(int style) + + Sets the frame style to \a style. The style is the bitwise OR + between a frame shape and a frame shadow style. +*/ + +void Q3GroupBox::setFrameStyle(int style) +{ + if (!testAttribute(Qt::WA_WState_OwnSizePolicy)) { + switch (style & MShape) { + case HLine: + setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Fixed); + break; + case VLine: + setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Minimum); + break; + default: + if ((d->frameStyle & MShape) == HLine || (d->frameStyle & MShape) == VLine) + setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred); + } + setAttribute(Qt::WA_WState_OwnSizePolicy, false); + } + d->frameStyle = style; + update(); + d->updateFrameWidth(); + d->oldFrameStyle = style; +} + +/*! + \fn int Q3GroupBox::frameStyle() const + + Returns the frame style. +*/ + +int Q3GroupBox::frameStyle() const +{ + return d->frameStyle; +} + +/*! + \property Q3GroupBox::lineWidth + \brief This property holds the width of the line. + + \sa frameStyle(), frameShadow() +*/ + +void Q3GroupBox::setLineWidth(int w) +{ + if (short(w) == d->lineWidth) + return; + d->lineWidth = short(w); + d->updateFrameWidth(); +} + +int Q3GroupBox::lineWidth() const +{ + return d->lineWidth; +} + +/*! + \property Q3GroupBox::midLineWidth + \brief This property holds the width of the mid-line. + + \sa frameStyle(), frameShadow() +*/ + +void Q3GroupBox::setMidLineWidth(int w) +{ + if (short(w) == d->midLineWidth) + return; + d->midLineWidth = short(w); + d->updateFrameWidth(); +} + +int Q3GroupBox::midLineWidth() const +{ + return d->midLineWidth; +} + +/*! + \property Q3GroupBox::frameRect + \brief the bounding rectangle of the frame of the group box. +*/ + +/*! + \fn QRect Q3GroupBox::frameRect() const + \internal +*/ + +QRect Q3GroupBox::frameRect() const +{ + QStyleOptionGroupBox opt; + initStyleOption(&opt); + QRect fr = style()->subControlRect(QStyle::CC_GroupBox, &opt, QStyle::SC_GroupBoxFrame, this); + return fr; +} + +/*! + \fn void Q3GroupBox::setFrameRect(QRect) + \internal +*/ + +void Q3GroupBox::setFrameRect(QRect r) +{ + QRect cr = r.isValid() ? r : rect(); + if ((d->frameStyle & QFrame::Shape_Mask) == StyledPanel) { + cr.adjust(d->leftFrameWidth, d->topFrameWidth, -d->rightFrameWidth, -d->bottomFrameWidth); + } else + cr.adjust(d->frameWidth, d->frameWidth, -d->frameWidth, -d->frameWidth); + setContentsMargins(cr.left(), cr.top(), rect().right() - cr.right(), rect().bottom() - cr.bottom()); +} + +/*! + \fn int Q3GroupBox::frameWidth() const + \internal +*/ + +int Q3GroupBox::frameWidth() const +{ + return d->frameWidth; +} + +#if defined(Q_MOC_RUN) +/*! + \enum Q3GroupBox::FrameShape + \internal + + \value Box + \value Sunken + \value Plain + \value Raised + \value MShadow + \value NoFrame + \value Panel + \value StyledPanel + \value HLine + \value VLine + \value GroupBoxPanel + \value WinPanel + \value ToolBarPanel + \value MenuBarPanel + \value PopupPanel + \value LineEditPanel + \value TabWidgetPanel + \value MShape +*/ +#else +/*! + \enum Q3GroupBox::DummyFrame + \internal + + \value Box + \value Sunken + \value Plain + \value Raised + \value MShadow + \value NoFrame + \value Panel + \value StyledPanel + \value HLine + \value VLine + \value GroupBoxPanel + \value WinPanel + \value ToolBarPanel + \value MenuBarPanel + \value PopupPanel + \value LineEditPanel + \value TabWidgetPanel + \value MShape +*/ +#endif + +/*! + \typedef Q3GroupBox::FrameShape + \internal +*/ + +/*! + \property Q3GroupBox::margin + \brief the width of the margin around the contents of the + group box. +*/ + +/*! + \fn void Q3GroupBox::setMargin(int margin) + \since 4.2 + + Sets the width of the margin around the contents of the widget to \a margin. + + This function uses QWidget::setContentsMargins() to set the margin. + \sa margin(), QWidget::setContentsMargins() +*/ + +/*! + \fn int Q3GroupBox::margin() const + \since 4.2 + + Returns the width of the margin around the contents of the widget. + + This function uses QWidget::getContentsMargins() to get the margin. + + \sa setMargin(), QWidget::getContentsMargins() +*/ + +QT_END_NAMESPACE diff --git a/src/qt3support/widgets/q3groupbox.h b/src/qt3support/widgets/q3groupbox.h new file mode 100644 index 0000000..0a6a44b --- /dev/null +++ b/src/qt3support/widgets/q3groupbox.h @@ -0,0 +1,159 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the Qt3Support module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, 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 qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef Q3GROUPBOX_H +#define Q3GROUPBOX_H + +#include <QtGui/qgroupbox.h> + +QT_BEGIN_HEADER + +QT_BEGIN_NAMESPACE + +QT_MODULE(Qt3SupportLight) + +class Q3GroupBoxPrivate; + +class Q_COMPAT_EXPORT Q3GroupBox : public QGroupBox +{ + Q_OBJECT +public: + enum +#if defined(Q_MOC_RUN) + FrameShape +#else + DummyFrame +#endif + { Box = QFrame::Box, Sunken = QFrame::Sunken, Plain = QFrame::Plain, + Raised = QFrame::Raised, MShadow=QFrame::Shadow_Mask, NoFrame = QFrame::NoFrame, + Panel = QFrame::Panel, StyledPanel = QFrame::StyledPanel, HLine = QFrame::HLine, + VLine = QFrame::VLine, + WinPanel = QFrame::WinPanel,ToolBarPanel = QFrame::StyledPanel, + MenuBarPanel = QFrame::StyledPanel, PopupPanel = QFrame::StyledPanel, + LineEditPanel = QFrame::StyledPanel,TabWidgetPanel = QFrame::StyledPanel, + GroupBoxPanel = 0x0007, + MShape = QFrame::Shape_Mask}; + + typedef DummyFrame FrameShape; + Q_ENUMS(FrameShape) + + Q_PROPERTY(Qt::Orientation orientation READ orientation WRITE setOrientation DESIGNABLE false) + Q_PROPERTY(int columns READ columns WRITE setColumns DESIGNABLE false) + + Q_PROPERTY(QRect frameRect READ frameRect WRITE setFrameRect DESIGNABLE false) + Q_PROPERTY(FrameShape frameShape READ frameShape WRITE setFrameShape) + Q_PROPERTY(FrameShape frameShadow READ frameShadow WRITE setFrameShadow) + Q_PROPERTY(int lineWidth READ lineWidth WRITE setLineWidth) + Q_PROPERTY(int midLineWidth READ midLineWidth WRITE setMidLineWidth) + Q_PROPERTY(int margin READ margin WRITE setMargin) + +public: + explicit Q3GroupBox(QWidget* parent=0, const char* name=0); + explicit Q3GroupBox(const QString &title, + QWidget* parent=0, const char* name=0); + Q3GroupBox(int strips, Qt::Orientation o, + QWidget* parent=0, const char* name=0); + Q3GroupBox(int strips, Qt::Orientation o, const QString &title, + QWidget* parent=0, const char* name=0); + ~Q3GroupBox(); + + virtual void setColumnLayout(int strips, Qt::Orientation o); + + int columns() const; + void setColumns(int); + + Qt::Orientation orientation() const; + void setOrientation(Qt::Orientation); + + int insideMargin() const; + int insideSpacing() const; + void setInsideMargin(int m); + void setInsideSpacing(int s); + + void addSpace(int); + + void setFrameRect(QRect); + QRect frameRect() const; +#ifdef qdoc + void setFrameShadow(FrameShape); + FrameShape frameShadow() const; + void setFrameShape(FrameShape); + FrameShape frameShape() const; +#else + void setFrameShadow(DummyFrame); + DummyFrame frameShadow() const; + void setFrameShape(DummyFrame); + DummyFrame frameShape() const; +#endif + void setFrameStyle(int); + int frameStyle() const; + int frameWidth() const; + void setLineWidth(int); + int lineWidth() const; + void setMargin(int margin) { setContentsMargins(margin, margin, margin, margin); } + int margin() const + { int margin; int dummy; getContentsMargins(&margin, &dummy, &dummy, &dummy); return margin; } + void setMidLineWidth(int); + int midLineWidth() const; + +protected: + void childEvent(QChildEvent *); + void resizeEvent(QResizeEvent *); + void changeEvent(QEvent *); + bool event(QEvent *); + +private: + void skip(); + void init(); + void calculateFrame(); + void insertWid(QWidget*); + void drawFrame(QPainter *p); + + Q3GroupBoxPrivate * d; + + Q_DISABLE_COPY(Q3GroupBox) +}; + +QT_END_NAMESPACE + +QT_END_HEADER + +#endif // Q3GROUPBOX_H diff --git a/src/qt3support/widgets/q3hbox.cpp b/src/qt3support/widgets/q3hbox.cpp new file mode 100644 index 0000000..8c89b63 --- /dev/null +++ b/src/qt3support/widgets/q3hbox.cpp @@ -0,0 +1,145 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the Qt3Support module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, 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 qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "q3hbox.h" +#include "qlayout.h" +#include "qapplication.h" + +QT_BEGIN_NAMESPACE + +/*! + \class Q3HBox + \brief The Q3HBox widget provides horizontal geometry management + for its child widgets. + + \compat + + All the horizontal box's child widgets will be placed alongside + each other and sized according to their sizeHint()s. + + Use setMargin() to add space around the edges, and use + setSpacing() to add space between the widgets. Use + setStretchFactor() if you want the widgets to be different sizes + in proportion to one another. (See \link layout.html + Layouts\endlink for more information on stretch factors.) + + \img qhbox-m.png Q3HBox + + \sa QHBoxLayout Q3VBox Q3Grid +*/ + + +/*! + Constructs an hbox widget with parent \a parent, called \a name. + The parent, name and widget flags, \a f, are passed to the Q3Frame + constructor. +*/ +Q3HBox::Q3HBox(QWidget *parent, const char *name, Qt::WindowFlags f) + :Q3Frame(parent, name, f) +{ + (new QHBoxLayout(this, frameWidth(), frameWidth(), name))->setAutoAdd(true); +} + + +/*! + Constructs a horizontal hbox if \a horizontal is TRUE, otherwise + constructs a vertical hbox (also known as a vbox). + + This constructor is provided for the QVBox class. You should never + need to use it directly. + + The \a parent, \a name and widget flags, \a f, are passed to the + Q3Frame constructor. +*/ + +Q3HBox::Q3HBox(bool horizontal, QWidget *parent , const char *name, Qt::WindowFlags f) + :Q3Frame(parent, name, f) +{ + (new QBoxLayout(this, horizontal ? QBoxLayout::LeftToRight : QBoxLayout::Down, + frameWidth(), frameWidth(), name))->setAutoAdd(true); +} + +/*!\reimp + */ +void Q3HBox::frameChanged() +{ + if (layout()) + layout()->setMargin(frameWidth()); +} + + +/*! + Sets the spacing between the child widgets to \a space. +*/ + +void Q3HBox::setSpacing(int space) +{ + if (layout()) + layout()->setSpacing(space); +} + + +/*! + \reimp +*/ + +QSize Q3HBox::sizeHint() const +{ + QWidget *mThis = (QWidget*)this; + QApplication::sendPostedEvents(mThis, QEvent::ChildInserted); + return Q3Frame::sizeHint(); +} + +/*! + Sets the stretch factor of widget \a w to \a stretch. Returns true if + \a w is found. Otherwise returns false. + + \sa QBoxLayout::setStretchFactor() \link layout.html Layouts\endlink +*/ +bool Q3HBox::setStretchFactor(QWidget* w, int stretch) +{ + QApplication::sendPostedEvents(this, QEvent::ChildInserted); + if (QBoxLayout *lay = qobject_cast<QBoxLayout *>(layout())) + return lay->setStretchFactor(w, stretch); + return false; +} + +QT_END_NAMESPACE diff --git a/src/qt3support/widgets/q3hbox.h b/src/qt3support/widgets/q3hbox.h new file mode 100644 index 0000000..abe3900 --- /dev/null +++ b/src/qt3support/widgets/q3hbox.h @@ -0,0 +1,77 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the Qt3Support module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, 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 qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef Q3HBOX_H +#define Q3HBOX_H + +#include <Qt3Support/q3frame.h> + +QT_BEGIN_HEADER + +QT_BEGIN_NAMESPACE + +QT_MODULE(Qt3SupportLight) + +class QBoxLayout; + +class Q_COMPAT_EXPORT Q3HBox : public Q3Frame +{ + Q_OBJECT +public: + Q3HBox(QWidget* parent=0, const char* name=0, Qt::WindowFlags f=0); + + void setSpacing(int); + bool setStretchFactor(QWidget*, int stretch); + QSize sizeHint() const; + +protected: + Q3HBox(bool horizontal, QWidget* parent, const char* name, Qt::WindowFlags f = 0); + void frameChanged(); + +private: + Q_DISABLE_COPY(Q3HBox) +}; + +QT_END_NAMESPACE + +QT_END_HEADER + +#endif // Q3HBOX_H diff --git a/src/qt3support/widgets/q3header.cpp b/src/qt3support/widgets/q3header.cpp new file mode 100644 index 0000000..bbe156a --- /dev/null +++ b/src/qt3support/widgets/q3header.cpp @@ -0,0 +1,2040 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the Qt3Support module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, 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 qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "q3header.h" +#ifndef QT_NO_HEADER +#include "qapplication.h" +#include "qbitarray.h" +#include "qcursor.h" +#include "qdrawutil.h" +#include "qevent.h" +#include "qpainter.h" +#include "qpixmap.h" +#include "qstyle.h" +#include "qstyleoption.h" +#include "qvector.h" + +QT_BEGIN_NAMESPACE + +class Q3HeaderData +{ +public: + Q3HeaderData(int n) + { + count = n; + sizes.resize(n); + positions.resize(n); + labels.resize(n); + nullStringLabels.resize(n); + icons.resize(n); + i2s.resize(n); + s2i.resize(n); + clicks.resize(n); + resize.resize(n); + int p =0; + for (int i = 0; i < n; i ++) { + sizes[i] = 88; + i2s[i] = i; + s2i[i] = i; + positions[i] = p; + p += sizes[i]; + } + clicks_default = true; + resize_default = true; + clicks.fill(clicks_default); + resize.fill(resize_default); + move = true; + sortSection = -1; + sortDirection = true; + positionsDirty = true; + lastPos = 0; + fullSize = -2; + pos_dirty = false; + is_a_table_header = false; + focusIdx = 0; + } + ~Q3HeaderData() + { + for (int i = 0; i < icons.size(); ++i) + delete icons.at(i); + } + + + QVector<int> sizes; + int height; // we abuse the heights as widths for vertical layout + bool heightDirty; + QVector<int> positions; // sorted by index + QVector<QString> labels; + QVector<QIcon *> icons; + QVector<int> i2s; + QVector<int> s2i; + + QBitArray clicks; + QBitArray resize; + QBitArray nullStringLabels; + uint move : 1; + uint clicks_default : 1; // default value for new clicks bits + uint resize_default : 1; // default value for new resize bits + uint pos_dirty : 1; + uint is_a_table_header : 1; + bool sortDirection; + bool positionsDirty; + int sortSection; + int count; + int lastPos; + int fullSize; + int focusIdx; + int pressDelta; + + int sectionAt(int pos) { + // positions is sorted by index, not by section + if (!count) + return -1; + int l = 0; + int r = count - 1; + int i = ((l+r+1) / 2); + while (r - l) { + if (positions[i] > pos) + r = i -1; + else + l = i; + i = ((l+r+1) / 2); + } + if (positions[i] <= pos && pos <= positions[i] + sizes[i2s[i]]) + return i2s[i]; + return -1; + } +}; + +static QStyleOptionHeader getStyleOption(const Q3Header *header, int section) +{ + QStyleOptionHeader opt; + opt.init(header); + opt.section = section; + opt.textAlignment = Qt::AlignVCenter; + opt.iconAlignment = Qt::AlignVCenter; + if (header->iconSet(section)) + opt.icon = *header->iconSet(section); + opt.text = header->label(section); + if (header->orientation() == Qt::Horizontal) + opt.state = QStyle::State_Horizontal; + return opt; +} + +bool qt_get_null_label_bit(Q3HeaderData *data, int section) +{ + return data->nullStringLabels.testBit(section); +} + +void qt_set_null_label_bit(Q3HeaderData *data, int section, bool b) +{ + data->nullStringLabels.setBit(section, b); +} + +/*! + \class Q3Header + \brief The Q3Header class provides a header row or column, e.g. for + tables and listviews. + + \compat + + This class provides a header, e.g. a vertical header to display + row labels, or a horizontal header to display column labels. It is + used by Q3Table and Q3ListView for example. + + A header is composed of one or more \e sections, each of which can + display a text label and an \link QIcon icon\endlink. A sort + indicator (an arrow) can also be displayed using + setSortIndicator(). + + Sections are added with addLabel() and removed with removeLabel(). + The label and icon are set in addLabel() and can be changed + later with setLabel(). Use count() to retrieve the number of + sections in the header. + + The orientation of the header is set with setOrientation(). If + setStretchEnabled() is true, the sections will expand to take up + the full width (height for vertical headers) of the header. The + user can resize the sections manually if setResizeEnabled() is + true. Call adjustHeaderSize() to have the sections resize to + occupy the full width (or height). + + A section can be moved with moveSection(). If setMovingEnabled() + is true (the default)the user may drag a section from one position + to another. If a section is moved, the index positions at which + sections were added (with addLabel()), may not be the same after the + move. You don't have to worry about this in practice because the + Q3Header API works in terms of section numbers, so it doesn't matter + where a particular section has been moved to. + + If you want the current index position of a section call + mapToIndex() giving it the section number. (This is the number + returned by the addLabel() call which created the section.) If you + want to get the section number of a section at a particular index + position call mapToSection() giving it the index number. + + Here's an example to clarify mapToSection() and mapToIndex(): + + \table + \header \i41 Index positions + \row \i 0 \i 1 \i 2 \i 3 + \header \i41 Original section ordering + \row \i Sect 0 \i Sect 1 \i Sect 2 \i Sect 3 + \header \i41 Ordering after the user moves a section + \row \i Sect 0 \i Sect 2 \i Sect 3 \i Sect 1 + \endtable + + \table + \header \i \e k \i mapToSection(\e k) \i mapToIndex(\e k) + \row \i 0 \i 0 \i 0 + \row \i 1 \i 2 \i 3 + \row \i 2 \i 3 \i 1 + \row \i 3 \i 1 \i 2 + \endtable + + In the example above, if we wanted to find out which section is at + index position 3 we'd call mapToSection(3) and get a section + number of 1 since section 1 was moved. Similarly, if we wanted to + know which index position section 2 occupied we'd call + mapToIndex(2) and get an index of 1. + + Q3Header provides the clicked(), pressed() and released() signals. + If the user changes the size of a section, the sizeChange() signal + is emitted. If you want to have a sizeChange() signal emitted + continuously whilst the user is resizing (rather than just after + the resizing is finished), use setTracking(). If the user moves a + section the indexChange() signal is emitted. + + \sa Q3ListView Q3Table +*/ + + + +/*! + Constructs a horizontal header called \a name, with parent \a + parent. +*/ + +Q3Header::Q3Header(QWidget *parent, const char *name) + : QWidget(parent, name, Qt::WStaticContents) +{ + orient = Qt::Horizontal; + init(0); +} + +/*! + Constructs a horizontal header called \a name, with \a n sections + and parent \a parent. +*/ + +Q3Header::Q3Header(int n, QWidget *parent, const char *name) + : QWidget(parent, name, Qt::WStaticContents) +{ + orient = Qt::Horizontal; + init(n); +} + +/*! + Destroys the header and all its sections. +*/ + +Q3Header::~Q3Header() +{ + delete d; + d = 0; +} + +/*! \reimp + */ + +void Q3Header::showEvent(QShowEvent *e) +{ + calculatePositions(); + QWidget::showEvent(e); +} + +/*! + \fn void Q3Header::sizeChange(int section, int oldSize, int newSize) + + This signal is emitted when the user has changed the size of a \a + section from \a oldSize to \a newSize. This signal is typically + connected to a slot that repaints the table or list that contains + the header. +*/ + +/*! + \fn void Q3Header::clicked(int section) + + If isClickEnabled() is true, this signal is emitted when the user + clicks section \a section. + + \sa pressed(), released() +*/ + +/*! + \fn void Q3Header::pressed(int section) + + This signal is emitted when the user presses section \a section + down. + + \sa released() +*/ + +/*! + \fn void Q3Header::released(int section) + + This signal is emitted when section \a section is released. + + \sa pressed() +*/ + + +/*! + \fn void Q3Header::indexChange(int section, int fromIndex, int toIndex) + + This signal is emitted when the user moves section \a section from + index position \a fromIndex, to index position \a toIndex. +*/ + +/*! + \fn void Q3Header::moved(int fromIndex, int toIndex) + + Use indexChange() instead. + + This signal is emitted when the user has moved the section which + is displayed at the index \a fromIndex to the index \a toIndex. +*/ + +/*! + \fn void Q3Header::sectionClicked(int index) + + Use clicked() instead. + + This signal is emitted when a part of the header is clicked. \a + index is the index at which the section is displayed. + + In a list view this signal would typically be connected to a slot + that sorts the specified column (or row). +*/ + +/*! \fn int Q3Header::cellSize(int) const + + Use sectionSize() instead. + + Returns the size in pixels of the section that is displayed at + the index \a i. +*/ + +/*! + \fn void Q3Header::sectionHandleDoubleClicked(int section) + + This signal is emitted when the user doubleclicks on the edge + (handle) of section \a section. +*/ + +/*! + + Use sectionPos() instead. + + Returns the position in pixels of the section that is displayed at the + index \a i. The position is measured from the start of the header. +*/ + +int Q3Header::cellPos(int i) const +{ + if (i == count() && i > 0) + return d->positions[i-1] + d->sizes[d->i2s[i-1]]; // compatibility + return sectionPos(mapToSection(i)); +} + + +/*! + \property Q3Header::count + \brief the number of sections in the header +*/ + +int Q3Header::count() const +{ + return d->count; +} + + +/*! + \property Q3Header::tracking + \brief whether the sizeChange() signal is emitted continuously + + If tracking is on, the sizeChange() signal is emitted continuously + while the mouse is moved (i.e. when the header is resized), + otherwise it is only emitted when the mouse button is released at + the end of resizing. + + Tracking defaults to false. +*/ + + +/* + Initializes with \a n columns. +*/ +void Q3Header::init(int n) +{ + state = Idle; + cachedPos = 0; // unused + d = new Q3HeaderData(n); + d->height = 0; + d->heightDirty = true; + offs = 0; + if(reverse()) + offs = d->lastPos - width(); + oldHandleIdx = oldHIdxSize = handleIdx = 0; + + setMouseTracking(true); + trackingIsOn = false; + setBackgroundRole(QPalette::Button); + setSizePolicy(QSizePolicy(QSizePolicy::Preferred, QSizePolicy::Fixed)); + setAttribute(Qt::WA_PaintOutsidePaintEvent); +} + +/*! + \property Q3Header::orientation + \brief the header's orientation + + The orientation is either Qt::Vertical or Qt::Horizontal (the + default). + + Call setOrientation() before adding labels if you don't provide a + size parameter otherwise the sizes will be incorrect. +*/ + +void Q3Header::setOrientation(Qt::Orientation orientation) +{ + if (orient == orientation) + return; + orient = orientation; + if (orient == Qt::Horizontal) + setSizePolicy(QSizePolicy(QSizePolicy::Preferred, QSizePolicy::Fixed)); + else + setSizePolicy(QSizePolicy(QSizePolicy::Fixed, QSizePolicy::Preferred)); + update(); + updateGeometry(); +} + + +/* + Paints a rectangle starting at \a p, with length \s. +*/ +void Q3Header::paintRect(int p, int s) +{ + QPainter paint(this); + paint.setPen(QPen(Qt::black, 1, Qt::DotLine)); + if (reverse()) + paint.drawRect(p - s, 3, s, height() - 5); + else if (orient == Qt::Horizontal) + paint.drawRect(p, 3, s, height() - 5); + else + paint.drawRect(3, p, height() - 5, s); +} + +/* + Marks the division line at \a idx. +*/ +void Q3Header::markLine(int idx) +{ + QPainter paint(this); + paint.setPen(QPen(Qt::black, 1, Qt::DotLine)); + int MARKSIZE = style()->pixelMetric(QStyle::PM_HeaderMarkSize); + int p = pPos(idx); + int x = p - MARKSIZE/2; + int y = 2; + int x2 = p + MARKSIZE/2; + int y2 = height() - 3; + if (orient == Qt::Vertical) { + int t = x; x = y; y = t; + t = x2; x2 = y2; y2 = t; + } + + paint.drawLine(x, y, x2, y); + paint.drawLine(x, y+1, x2, y+1); + + paint.drawLine(x, y2, x2, y2); + paint.drawLine(x, y2-1, x2, y2-1); + + paint.drawLine(x, y, x, y2); + paint.drawLine(x+1, y, x+1, y2); + + paint.drawLine(x2, y, x2, y2); + paint.drawLine(x2-1, y, x2-1, y2); +} + +/* + Removes the mark at the division line at \a idx. +*/ +void Q3Header::unMarkLine(int idx) +{ + if (idx < 0) + return; + int MARKSIZE = style()->pixelMetric(QStyle::PM_HeaderMarkSize); + int p = pPos(idx); + int x = p - MARKSIZE/2; + int y = 2; + int x2 = p + MARKSIZE/2; + int y2 = height() - 3; + if (orient == Qt::Vertical) { + int t = x; x = y; y = t; + t = x2; x2 = y2; y2 = t; + } + repaint(x, y, x2-x+1, y2-y+1); +} + +/*! \fn int Q3Header::cellAt(int) const + + Use sectionAt() instead. + + Returns the index at which the section is displayed, which contains + \a pos in widget coordinates, or -1 if \a pos is outside the header + sections. +*/ + +/* + Tries to find a line that is not a neighbor of \c handleIdx. +*/ +int Q3Header::findLine(int c) +{ + int i = 0; + if (c > d->lastPos || (reverse() && c < 0)) { + return d->count; + } else { + int section = sectionAt(c); + if (section < 0) + return handleIdx; + i = d->s2i[section]; + } + int MARKSIZE = style()->pixelMetric(QStyle::PM_HeaderMarkSize); + if (i == handleIdx) + return i; + if (i == handleIdx - 1 && pPos(handleIdx) - c > MARKSIZE/2) + return i; + if (i == handleIdx + 1 && c - pPos(i) > MARKSIZE/2) + return i + 1; + if (c - pPos(i) > pSize(i) / 2) + return i + 1; + else + return i; +} + +/*! + Returns the handle at position \a p, or -1 if there is no handle at \a p. +*/ +int Q3Header::handleAt(int p) +{ + int section = d->sectionAt(p); + if (section >= 0) { + int GripMargin = (bool)d->resize[section] ? + style()->pixelMetric(QStyle::PM_HeaderGripMargin) : 0; + int index = d->s2i[section]; + if ((index > 0 && p < d->positions[index] + GripMargin) || + (p > d->positions[index] + d->sizes[section] - GripMargin)) { + if (index > 0 && p < d->positions[index] + GripMargin) + section = d->i2s[--index]; + // don't show icon if streaching is enabled it is at the end of the last section + if (d->resize.testBit(section) && (d->fullSize == -2 || index != count() - 1)) { + return section; + } + } + } + + return -1; +} + +/*! + Use moveSection() instead. + + Moves the section that is currently displayed at index \a fromIdx + to index \a toIdx. +*/ + +void Q3Header::moveCell(int fromIdx, int toIdx) +{ + moveSection(mapToSection(fromIdx), toIdx); +} + + + +/*! + Move and signal and repaint. + */ + +void Q3Header::handleColumnMove(int fromIdx, int toIdx) +{ + int s = d->i2s[fromIdx]; + if (fromIdx < toIdx) + toIdx++; //Convert to + QRect r = sRect(fromIdx); + r |= sRect(toIdx); + moveSection(s, toIdx); + update(r); + emit moved(fromIdx, toIdx); + emit indexChange(s, fromIdx, toIdx); +} + +/*! + \reimp +*/ +void Q3Header::keyPressEvent(QKeyEvent *e) +{ + int i = d->focusIdx; + if (e->key() == Qt::Key_Space) { + //don't do it if we're doing something with the mouse + if (state == Idle && d->clicks[d->i2s[d->focusIdx] ]) { + handleIdx = i; + state = Pressed; + repaint(sRect(handleIdx)); + emit pressed(d->i2s[i]); + } + } else if ((orientation() == Qt::Horizontal && (e->key() == Qt::Key_Right || e->key() == Qt::Key_Left)) + || (orientation() == Qt::Vertical && (e->key() == Qt::Key_Up || e->key() == Qt::Key_Down))) { + int dir = e->key() == Qt::Key_Right || e->key() == Qt::Key_Down ? 1 : -1; + int s = d->i2s[i]; + if (e->state() & Qt::ControlButton && d->resize[s]) { + //resize + int step = e->state() & Qt::ShiftButton ? dir : 10*dir; + int c = d->positions[i] + d->sizes[s] + step; + handleColumnResize(i, c, true); + } else if (e->state() & (Qt::AltButton|Qt::MetaButton) && d->move) { + //move section + int i2 = (i + count() + dir) % count(); + d->focusIdx = i2; + handleColumnMove(i, i2); + } else { + //focus on different section + QRect r = sRect(d->focusIdx); + d->focusIdx = (d->focusIdx + count() + dir) % count(); + r |= sRect(d->focusIdx); + update(r); + } + } else { + e->ignore(); + } +} + +/*! + \reimp +*/ +void Q3Header::keyReleaseEvent(QKeyEvent *e) +{ + switch (e->key()) { + case Qt::Key_Space: + //double check that this wasn't started with the mouse + if (state == Pressed && handleIdx == d->focusIdx) { + repaint(sRect(handleIdx)); + int section = d->i2s[d->focusIdx]; + emit released(section); + emit sectionClicked(handleIdx); + emit clicked(section); + state = Idle; + handleIdx = -1; + } + break; + default: + e->ignore(); + } +} + + +/*! + \reimp +*/ +void Q3Header::mousePressEvent(QMouseEvent *e) +{ + if (e->button() != Qt::LeftButton || state != Idle) + return; + oldHIdxSize = handleIdx; + handleIdx = 0; + int c = orient == Qt::Horizontal ? e->pos().x() : e->pos().y(); + c += offset(); + if (reverse()) + c = d->lastPos - c; + + int section = d->sectionAt(c); + if (section < 0) + return; + int GripMargin = (bool)d->resize[section] ? + style()->pixelMetric(QStyle::PM_HeaderGripMargin) : 0; + int index = d->s2i[section]; + + if ((index > 0 && c < d->positions[index] + GripMargin) || + (c > d->positions[index] + d->sizes[section] - GripMargin)) { + if (c < d->positions[index] + GripMargin) + handleIdx = index-1; + else + handleIdx = index; + if (d->lastPos <= (orient == Qt::Horizontal ? width() : + height()) && d->fullSize != -2 && handleIdx == count() - 1) { + handleIdx = -1; + return; + } + oldHIdxSize = d->sizes[d->i2s[handleIdx]]; + state = d->resize[d->i2s[handleIdx] ] ? Sliding : Blocked; + } else if (index >= 0) { + oldHandleIdx = handleIdx = index; + moveToIdx = -1; + state = d->clicks[d->i2s[handleIdx] ] ? Pressed : Blocked; + clickPos = c; + repaint(sRect(handleIdx)); + if(oldHandleIdx != handleIdx) + repaint(sRect(oldHandleIdx)); + emit pressed(section); + } + + d->pressDelta = c - (d->positions[handleIdx] + d->sizes[d->i2s[handleIdx]]); +} + +/*! + \reimp +*/ +void Q3Header::mouseReleaseEvent(QMouseEvent *e) +{ + if (e->button() != Qt::LeftButton) + return; + int oldOldHandleIdx = oldHandleIdx; + State oldState = state; + state = Idle; + switch (oldState) { + case Pressed: { + int section = d->i2s[handleIdx]; + emit released(section); + if (sRect(handleIdx).contains(e->pos())) { + oldHandleIdx = handleIdx; + emit sectionClicked(handleIdx); + emit clicked(section); + } else { + handleIdx = oldHandleIdx; + } + repaint(sRect(handleIdx)); + if (oldOldHandleIdx != handleIdx) + repaint(sRect(oldOldHandleIdx)); + } break; + case Sliding: { + int c = orient == Qt::Horizontal ? e->pos().x() : e->pos().y(); + c += offset(); + if (reverse()) + c = d->lastPos - c; + handleColumnResize(handleIdx, c - d->pressDelta, true); + } break; + case Moving: { +#ifndef QT_NO_CURSOR + unsetCursor(); +#endif + int section = d->i2s[handleIdx]; + if (handleIdx != moveToIdx && moveToIdx != -1) { + moveSection(section, moveToIdx); + handleIdx = oldHandleIdx; + emit moved(handleIdx, moveToIdx); + emit indexChange(section, handleIdx, moveToIdx); + emit released(section); + repaint(); // a bit overkill, but removes the handle as well + } else { + if (sRect(handleIdx).contains(e->pos())) { + oldHandleIdx = handleIdx; + emit released(section); + emit sectionClicked(handleIdx); + emit clicked(section); + } else { + handleIdx = oldHandleIdx; + } + repaint(sRect(handleIdx)); + if(oldOldHandleIdx != handleIdx) + repaint(sRect(oldOldHandleIdx)); + } + break; + } + case Blocked: + //nothing + break; + default: + // empty, probably. Idle, at any rate. + break; + } +} + +/*! + \reimp +*/ +void Q3Header::mouseMoveEvent(QMouseEvent *e) +{ + int c = orient == Qt::Horizontal ? e->pos().x() : e->pos().y(); + c += offset(); + + int pos = c; + if(reverse()) + c = d->lastPos - c; + + switch(state) { + case Idle: +#ifndef QT_NO_CURSOR + if (handleAt(c) < 0) + unsetCursor(); + else if (orient == Qt::Horizontal) + setCursor(Qt::splitHCursor); + else + setCursor(Qt::splitVCursor); +#endif + break; + case Blocked: + break; + case Pressed: + if (QABS(c - clickPos) > 4 && d->move) { + state = Moving; + moveToIdx = -1; +#ifndef QT_NO_CURSOR + if (orient == Qt::Horizontal) + setCursor(Qt::SizeHorCursor); + else + setCursor(Qt::SizeVerCursor); +#endif + } + break; + case Sliding: + handleColumnResize(handleIdx, c, false, false); + break; + case Moving: { + int newPos = findLine(pos); + if (newPos != moveToIdx) { + if (moveToIdx == handleIdx || moveToIdx == handleIdx + 1) + repaint(sRect(handleIdx)); + else + unMarkLine(moveToIdx); + moveToIdx = newPos; + if (moveToIdx == handleIdx || moveToIdx == handleIdx + 1) + paintRect(pPos(handleIdx), pSize(handleIdx)); + else + markLine(moveToIdx); + } + break; + } + default: + qWarning("Q3Header::mouseMoveEvent: (%s) unknown state", objectName().toLocal8Bit().data()); + break; + } +} + +/*! \reimp */ + +void Q3Header::mouseDoubleClickEvent(QMouseEvent *e) +{ + int p = orient == Qt::Horizontal ? e->pos().x() : e->pos().y(); + p += offset(); + if(reverse()) + p = d->lastPos - p; + + int header = handleAt(p); + if (header >= 0) + emit sectionHandleDoubleClicked(header); +} + +/* + Handles resizing of sections. This means it redraws the relevant parts + of the header. +*/ + +void Q3Header::handleColumnResize(int index, int c, bool final, bool recalcAll) +{ + int section = d->i2s[index]; + int GripMargin = (bool)d->resize[section] ? + style()->pixelMetric(QStyle::PM_HeaderGripMargin) : 0; + int lim = d->positions[index] + 2*GripMargin; + if (c == lim) + return; + if (c < lim) + c = lim; + int oldSize = d->sizes[section]; + int newSize = c - d->positions[index]; + d->sizes[section] = newSize; + + calculatePositions(!recalcAll, !recalcAll ? section : 0); + + int pos = d->positions[index]-offset(); + if(reverse()) // repaint the whole thing. Could be optimized (lars) + repaint(0, 0, width(), height()); + else if (orient == Qt::Horizontal) + repaint(pos, 0, width() - pos, height()); + else + repaint(0, pos, width(), height() - pos); + + int os = 0, ns = 0; + if (tracking() && oldSize != newSize) { + os = oldSize; + ns = newSize; + emit sizeChange(section, oldSize, newSize); + } else if (!tracking() && final && oldHIdxSize != newSize) { + os = oldHIdxSize; + ns = newSize; + emit sizeChange(section, oldHIdxSize, newSize); + } + + if (os != ns) { + if (d->fullSize == -1) { + d->fullSize = count() - 1; + adjustHeaderSize(); + d->fullSize = -1; + } else if (d->fullSize >= 0) { + int old = d->fullSize; + d->fullSize = count() - 1; + adjustHeaderSize(); + d->fullSize = old; + } + } +} + +/*! + Returns the rectangle covered by the section at index \a index. +*/ + +QRect Q3Header::sRect(int index) +{ + + int section = mapToSection(index); + if (count() > 0 && index >= count()) { + int s = d->positions[count() - 1] - offset() + + d->sizes[mapToSection(count() - 1)]; + if (orient == Qt::Horizontal) + return QRect(s, 0, width() - s + 10, height()); + else + return QRect(0, s, width(), height() - s + 10); + } + if (section < 0) + return rect(); // ### eeeeevil + + if (reverse()) + return QRect( d->lastPos - d->positions[index] - d->sizes[section] -offset(), + 0, d->sizes[section], height()); + else if (orient == Qt::Horizontal) + return QRect( d->positions[index]-offset(), 0, d->sizes[section], height()); + else + return QRect(0, d->positions[index]-offset(), width(), d->sizes[section]); +} + +/*! + Returns the rectangle covered by section \a section. +*/ + +QRect Q3Header::sectionRect(int section) const +{ + int index = mapToIndex(section); + if (section < 0) + return rect(); // ### eeeeevil + + if (reverse()) + return QRect( d->lastPos - d->positions[index] - d->sizes[section] -offset(), + 0, d->sizes[section], height()); + else if (orient == Qt::Horizontal) + return QRect( d->positions[index]-offset(), 0, d->sizes[section], height()); + else + return QRect(0, d->positions[index]-offset(), width(), d->sizes[section]); +} + +/*! + \overload + + Sets the icon for section \a section to \a icon and the text to + \a s. The section's width is set to \a size if \a size \>= 0; + otherwise it is left unchanged. + + If the section does not exist, nothing happens. +*/ + +void Q3Header::setLabel(int section, const QIcon& icon, + const QString &s, int size) +{ + if (section < 0 || section >= count()) + return; + delete d->icons[section]; + d->icons[section] = new QIcon(icon); + setLabel(section, s, size); +} + +/*! + Sets the text of section \a section to \a s. The section's width + is set to \a size if \a size \>= 0; otherwise it is left + unchanged. Any icon set that has been set for this section remains + unchanged. + + If the section does not exist, nothing happens. +*/ +void Q3Header::setLabel(int section, const QString &s, int size) +{ + if (section < 0 || section >= count()) + return; + d->labels[section] = s; + d->nullStringLabels.setBit(section, s.isNull()); + + setSectionSizeAndHeight(section, size); + + if (updatesEnabled()) { + updateGeometry(); + calculatePositions(); + update(); + } +} + + +bool qt_qheader_label_return_null_strings = false; +/*! + Returns the text for section \a section. If the section does not + exist, returns an empty string. +*/ +QString Q3Header::label(int section) const +{ + if (section < 0 || section >= count()) + return QString(); + QString l = d->labels.value(section); + if (!l.isNull()) + return l; + if (d->nullStringLabels.testBit(section) || qt_qheader_label_return_null_strings) + return l; + else + return QString::number(section + 1); +} + +/*! + Returns the icon set for section \a section. If the section does + not exist, 0 is returned. +*/ + +QIcon *Q3Header::iconSet(int section) const +{ + if (section < 0 || section >= count()) + return 0; + return d->icons[section]; +} + + +/*! + \overload + + Adds a new section with icon \a icon and label text \a s. + Returns the index position where the section was added (at the + right for horizontal headers, at the bottom for vertical headers). + The section's width is set to \a size, unless size is negative in + which case the size is calculated taking account of the size of + the text. +*/ +int Q3Header::addLabel(const QIcon& icon, const QString &s, int size) +{ + int n = count() + 1; + d->icons.resize(n + 1); + d->icons.insert(n - 1, new QIcon(icon)); + return addLabel(s, size); +} + +/*! + Removes section \a section. If the section does not exist, nothing + happens. +*/ +void Q3Header::removeLabel(int section) +{ + if (section < 0 || section > count() - 1) + return; + + int index = d->s2i[section]; + int n = --d->count; + int i; + for (i = section; i < n; ++i) { + d->sizes[i] = d->sizes[i+1]; + d->labels[i] = d->labels[i+1]; + d->labels[i+1] = QString(); + d->nullStringLabels[i] = d->nullStringLabels[i+1]; + d->nullStringLabels[i+1] = 0; + d->icons[i] = d->icons[i+1]; + d->icons[i+1] = 0; + } + + d->sizes.resize(n); + d->positions.resize(n); + d->labels.resize(n); + d->nullStringLabels.resize(n); + d->icons.resize(n); + + for (i = section; i < n; ++i) + d->s2i[i] = d->s2i[i+1]; + d->s2i.resize(n); + + if (updatesEnabled()) { + for (i = 0; i < n; ++i) + if (d->s2i[i] > index) + --d->s2i[i]; + } + + for (i = index; i < n; ++i) + d->i2s[i] = d->i2s[i+1]; + d->i2s.resize(n); + + if (updatesEnabled()) { + for (i = 0; i < n; ++i) + if (d->i2s[i] > section) + --d->i2s[i]; + } + + if (updatesEnabled()) { + updateGeometry(); + calculatePositions(); + update(); + } +} + +QSize Q3Header::sectionSizeHint(int section, const QFontMetrics& fm) const +{ + int iw = 0; + int ih = 0; + if (d->icons[section] != 0) { + QSize isize = d->icons[section]->pixmap(style()->pixelMetric(QStyle::PM_SmallIconSize), + QIcon::Normal).size(); + iw = isize.width() + 2; + ih = isize.height(); + } + + QRect bound; + QString label = d->labels[section]; + if (!label.isNull() || d->nullStringLabels.testBit(section)) { + int lines = label.count(QLatin1Char('\n')) + 1; + int w = 0; + if (lines > 1) { + bound.setHeight(fm.height() + fm.lineSpacing() * (lines - 1)); + QStringList list = label.split(QLatin1Char('\n')); + for (int i=0; i < list.count(); ++i) { + int tmpw = fm.width(list.at(i)); + w = QMAX(w, tmpw); + } + } else { + bound.setHeight(fm.height()); + w = fm.width(label); + } + bound.setWidth(w); + } + int arrowWidth = 0; + if (d->sortSection == section) + arrowWidth = ((orient == Qt::Horizontal ? height() : width()) / 2) + 8; + int height = qMax(bound.height() + 2, ih) + 4; + int width = bound.width() + style()->pixelMetric(QStyle::PM_HeaderMargin) * 4 + + iw + arrowWidth; + return QSize(width, height); +} + +/* + Sets d->sizes[\a section] to a bounding rect based on its size + hint and font metrics, but constrained by \a size. It also updates + d->height. +*/ +void Q3Header::setSectionSizeAndHeight(int section, int size) +{ + QSize sz = sectionSizeHint(section, fontMetrics()); + + if (size < 0) { + if (d->sizes[section] < 0) + d->sizes[section] = (orient == Qt::Horizontal) ? sz.width() + : sz.height(); + } else { + d->sizes[section] = size; + } + + int newHeight = (orient == Qt::Horizontal) ? sz.height() : sz.width(); + if (newHeight > d->height) { + d->height = newHeight; + } else if (newHeight < d->height) { + /* + We could be smarter, but we aren't. This makes a difference + only for users with many columns and '\n's in their headers + at the same time. + */ + d->heightDirty = true; + } +} + +/*! + Adds a new section with label text \a s. Returns the index + position where the section was added (at the right for horizontal + headers, at the bottom for vertical headers). The section's width + is set to \a size. If \a size \< 0, an appropriate size for the + text \a s is chosen. +*/ +int Q3Header::addLabel(const QString &s, int size) +{ + int n = ++d->count; + if ((int)d->icons.size() < n ) + d->icons.resize(n); + if ((int)d->sizes.size() < n ) { + d->labels.resize(n); + d->nullStringLabels.resize(n); + d->sizes.resize(n); + d->positions.resize(n); + d->i2s.resize(n); + d->s2i.resize(n); + d->clicks.resize(n); + d->resize.resize(n); + } + int section = d->count - 1; + if (!d->is_a_table_header || !s.isNull()) { + d->labels.insert(section, s); + d->nullStringLabels.setBit(section, s.isNull()); + } + + if (size >= 0 && s.isNull() && d->is_a_table_header) { + d->sizes[section] = size; + } else { + d->sizes[section] = -1; + setSectionSizeAndHeight(section, size); + } + + int index = section; + d->positions[index] = d->lastPos; + + d->s2i[section] = index; + d->i2s[index] = section; + d->clicks.setBit(section, d->clicks_default); + d->resize.setBit(section, d->resize_default); + + if (updatesEnabled()) { + updateGeometry(); + calculatePositions(); + update(); + } + return index; +} + +void Q3Header::resizeArrays(int size) +{ + d->icons.resize(size); + d->labels.resize(size); + d->nullStringLabels.resize(size); + d->sizes.resize(size); + d->positions.resize(size); + d->i2s.resize(size); + d->s2i.resize(size); + d->clicks.resize(size); + d->resize.resize(size); +} + +void Q3Header::setIsATableHeader(bool b) +{ + d->is_a_table_header = b; +} + +/*! \reimp */ +QSize Q3Header::sizeHint() const +{ + int width; + int height; + + ensurePolished(); + QFontMetrics fm = fontMetrics(); + + if (d->heightDirty) { + d->height = fm.lineSpacing() + 6; + for (int i = 0; i < count(); i++) { + int h = orient == Qt::Horizontal ? + sectionSizeHint(i, fm).height() : sectionSizeHint(i, fm).width(); + d->height = qMax(d->height, h); + } + d->heightDirty = false; + } + + if (orient == Qt::Horizontal) { + height = fm.lineSpacing() + 6; + width = 0; + height = qMax(height, d->height); + for (int i = 0; i < count(); i++) + width += d->sizes[i]; + } else { + width = fm.width(QLatin1Char(' ')); + height = 0; + width = qMax(width, d->height); + for (int i = 0; i < count(); i++) + height += d->sizes[i]; + } + QStyleOptionHeader opt = getStyleOption(this, 0); + return style()->sizeFromContents(QStyle::CT_Q3Header, &opt, QSize(width, height), + this).expandedTo(QApplication::globalStrut()); +} + +/*! + \property Q3Header::offset + \brief the header's left-most (or top-most) visible pixel + + Setting this property will scroll the header so that \e offset + becomes the left-most (or top-most for vertical headers) visible + pixel. +*/ +int Q3Header::offset() const +{ + if (reverse()) + return d->lastPos - width() - offs; + return offs; +} + +void Q3Header::setOffset(int x) +{ + int oldOff = offset(); + offs = x; + if(d->lastPos < (orient == Qt::Horizontal ? width() : height())) + offs = 0; + else if (reverse()) + offs = d->lastPos - width() - x; + if (orient == Qt::Horizontal) + scroll(oldOff-offset(), 0); + else + scroll(0, oldOff-offset()); +} + + + +/* + Returns the position of actual division line \a i in widget + coordinates. May return a position outside the widget. + + Note that the last division line is numbered count(). (There is one + more line than the number of sections). +*/ +int Q3Header::pPos(int i) const +{ + int pos; + if (i == count()) + pos = d->lastPos; + else + pos = d->positions[i]; + if (reverse()) + pos = d->lastPos - pos; + return pos - offset(); +} + + +/* + Returns the size of the section at index position \a i. +*/ +int Q3Header::pSize(int i) const +{ + return d->sizes[d->i2s[i]]; +} + +/*! + Use mapToSection() instead. + + Translates from actual index \a a (index at which the section is displayed) to + logical index of the section. Returns -1 if \a a is outside the legal range. + + \sa mapToActual() +*/ + +int Q3Header::mapToLogical(int a) const +{ + return mapToSection(a); +} + + +/*! + Use mapToIndex() instead. + + Translates from logical index \a l to actual index (index at which the section \a l is displayed) . + Returns -1 if \a l is outside the legal range. + + \sa mapToLogical() +*/ + +int Q3Header::mapToActual(int l) const +{ + return mapToIndex(l); +} + + +/*! + Use resizeSection() instead. + + Sets the size of the section \a section to \a s pixels. + + \warning does not repaint or send out signals +*/ + +void Q3Header::setCellSize(int section, int s) +{ + if (section < 0 || section >= count()) + return; + d->sizes[section] = s; + if (updatesEnabled()) + calculatePositions(); + else + d->positionsDirty = true; +} + + +/*! + If \a enable is true the user may resize section \a section; + otherwise the section may not be manually resized. + + If \a section is negative (the default) then the \a enable value + is set for all existing sections and will be applied to any new + sections that are added. + Example: + \snippet doc/src/snippets/code/src_qt3support_widgets_q3header.cpp 0 + + If the user resizes a section, a sizeChange() signal is emitted. + + \sa setMovingEnabled() setClickEnabled() setTracking() +*/ + +void Q3Header::setResizeEnabled(bool enable, int section) +{ + if (section < 0) { + d->resize.fill(enable); + // and future ones... + d->resize_default = enable; + } else if (section < count()) { + d->resize[section] = enable; + } +} + + +/*! + \property Q3Header::moving + \brief whether the header sections can be moved + + If this property is true (the default) the user can move sections. + If the user moves a section the indexChange() signal is emitted. + + \sa setClickEnabled(), setResizeEnabled() +*/ + +void Q3Header::setMovingEnabled(bool enable) +{ + d->move = enable; +} + + +/*! + If \a enable is true, any clicks on section \a section will result + in clicked() signals being emitted; otherwise the section will + ignore clicks. + + If \a section is -1 (the default) then the \a enable value is set + for all existing sections and will be applied to any new sections + that are added. + + \sa setMovingEnabled(), setResizeEnabled() +*/ + +void Q3Header::setClickEnabled(bool enable, int section) +{ + if (section < 0) { + d->clicks.fill(enable); + // and future ones... + d->clicks_default = enable; + } else if (section < count()) { + d->clicks[section] = enable; + } +} + + +/*! + Paints the section at position \a index, inside rectangle \a fr + (which uses widget coordinates) using painter \a p. + + Calls paintSectionLabel(). +*/ + +void Q3Header::paintSection(QPainter *p, int index, const QRect& fr) +{ + int section = mapToSection(index); + QStyleOptionHeader opt = getStyleOption(this, section); + opt.state |= QStyle::State_Raised; + opt.rect = fr; + + if (section < 0) { + style()->drawControl(QStyle::CE_Header, &opt, p, this); + return; + } + + if (sectionSize(section) <= 0) + return; + + opt.state = (orient == Qt::Horizontal ? QStyle::State_Horizontal : QStyle::State_None); + if (d->sortSection == section) + opt.sortIndicator = d->sortDirection ? QStyleOptionHeader::SortDown : QStyleOptionHeader::SortUp; + + if (isEnabled()) + opt.state |= QStyle::State_Enabled; + if (isClickEnabled(section) && (state == Pressed || state == Moving) && index == handleIdx) + opt.state |= QStyle::State_Sunken; //currently pressed + if (!(opt.state & QStyle::State_Sunken)) + opt.state |= QStyle::State_Raised; + p->setBrushOrigin(fr.topLeft()); + if (d->clicks[section]) { + style()->drawControl(QStyle::CE_Header, &opt, p, this); + } else { + p->save(); + p->setClipRect(fr); // hack to keep styles working + opt.rect.setRect(fr.x() + 1, fr.y(), fr.width(), fr.height()); + style()->drawControl(QStyle::CE_Header, &opt, p, this); + if (orient == Qt::Horizontal) { + p->setPen(palette().color(QPalette::Mid)); + p->drawLine(fr.x() - 1, fr.y() + fr.height() - 1, + fr.x() + fr.width() - 1, fr.y() + fr.height() - 1); + p->drawLine(fr.x() + fr.width() - 1, fr.y(), + fr.x() + fr.width() - 1, fr.y() + fr.height() - 1); + } else { + p->setPen(palette().color(QPalette::Mid)); + p->drawLine(fr.x() + width() - 1, fr.y(), + fr.x() + fr.width() - 1, fr.y() + fr.height() - 1); + p->drawLine(fr.x(), fr.y() + fr.height() - 1, + fr.x() + fr.width() - 1, fr.y() + fr.height() - 1); + p->setPen(palette().color(QPalette::Light)); + if (index > 0) + p->drawLine(fr.x(), fr.y(), fr.x() + fr.width() - 1, fr.y()); + if (index == count() - 1) { + p->drawLine(fr.x(), fr.y() + fr.height() - 1, + fr.x() + fr.width() - 1, fr.y() + fr.height() - 1); + p->setPen(palette().color(QPalette::Mid)); + p->drawLine(fr.x(), fr.y() + fr.height() - 2, + fr.x() + fr.width() - 1, fr.y() + fr.height() - 2); + } + } + p->restore(); + } +} + +/*! + Paints the label of the section at position \a index, inside + rectangle \a fr (which uses widget coordinates) using painter \a + p. + + Called by paintSection() +*/ +void Q3Header::paintSectionLabel(QPainter *p, int index, const QRect& fr) +{ + int section = mapToSection(index); + if (section < 0) + return; + + int dx = 0, dy = 0; + QStyleOptionHeader opt = getStyleOption(this, section); + if (d->sortSection == section) + opt.sortIndicator = d->sortDirection ? QStyleOptionHeader::SortDown : QStyleOptionHeader::SortUp; + if (index == handleIdx && (state == Pressed || state == Moving)) { + dx = style()->pixelMetric(QStyle::PM_ButtonShiftHorizontal, &opt, this); + dy = style()->pixelMetric(QStyle::PM_ButtonShiftVertical, &opt, this); + opt.state |= QStyle::State_Sunken; + } + if (isEnabled()) + opt.state |= QStyle::State_Enabled; + + + opt.rect.setRect(fr.x() + style()->pixelMetric(QStyle::PM_HeaderMargin) + dx, fr.y() + 2 + dy, + fr.width() - 6, fr.height() - 4); + + style()->drawControl(QStyle::CE_HeaderLabel, &opt, p, this); + + int arrowWidth = (orient == Qt::Horizontal ? height() : width()) / 2; + int arrowHeight = fr.height() - 6; + QSize ssh = sectionSizeHint(section, p->fontMetrics()); + int tw = (orient == Qt::Horizontal ? ssh.width() : ssh.height()); + int ew = 0; + + if (style()->styleHint(QStyle::SH_Header_ArrowAlignment, 0, this) & Qt::AlignRight) + ew = fr.width() - tw - 8; + if (d->sortSection == section && tw <= fr.width()) { + if (reverse()) { + tw = fr.width() - tw; + ew = fr.width() - ew - tw; + } + opt.state = QStyle::State_None; + if (isEnabled()) + opt.state |= QStyle::State_Enabled; + if (d->sortDirection) + opt.state |= QStyle::State_DownArrow; + else + opt.state |= QStyle::State_UpArrow; + QRect ar(fr.x() + tw - arrowWidth - 6 + ew, 4, arrowWidth, arrowHeight); + if (label(section).isRightToLeft()) + ar.moveBy( 2*(fr.right() - ar.right()) + ar.width() - fr.width(), 0 ); + opt.rect = ar; + style()->drawPrimitive(QStyle::PE_IndicatorHeaderArrow, &opt, p, this); + } +} + + +/*! \reimp */ +void Q3Header::paintEvent(QPaintEvent *e) +{ + QPainter p(this); + p.setPen(palette().buttonText().color()); + int pos = orient == Qt::Horizontal ? e->rect().left() : e->rect().top(); + int id = mapToIndex(sectionAt(pos + offset())); + if (id < 0) { + if (pos > 0) + id = d->count; + else if (reverse()) + id = d->count - 1; + else + id = 0; + } + if (reverse()) { + for (int i = id; i >= 0; i--) { + QRect r = sRect(i); + paintSection(&p, i, r); + if (r.right() >= e->rect().right()) + return; + } + } else { + if (count() > 0) { + for (int i = id; i <= count(); i++) { + QRect r = sRect(i); + /* + If the last section is clickable (and thus is + painted raised), draw the virtual section count() + as well. Otherwise it looks ugly. + */ + if (i < count() || d->clicks[mapToSection(count() - 1)]) + paintSection(&p, i, r); + if (hasFocus() && d->focusIdx == i) { + QStyleOptionFocusRect opt; + opt.rect.setRect(r.x()+2, r.y()+2, r.width()-4, r.height()-4); + opt.palette = palette(); + opt.state = QStyle::State_None; + style()->drawPrimitive(QStyle::PE_FrameFocusRect, &opt, &p, this); + } + if ((orient == Qt::Horizontal && r. right() >= e->rect().right()) + || (orient == Qt::Vertical && r. bottom() >= e->rect().bottom())) + return; + } + } + } +} + +/*! + \overload + + Sets the sort indicator to \a ascending. Use the other overload instead. +*/ + +void Q3Header::setSortIndicator(int section, bool ascending) +{ + d->sortSection = section; + if (section != -1) + oldHandleIdx = section; + d->sortDirection = ascending; + update(); + updateGeometry(); +} + +/*! + \fn void Q3Header::setSortIndicator(int section, Qt::SortOrder order) + + Sets a sort indicator onto the specified \a section. The indicator's + \a order is either Ascending or Descending. + + Only one section can show a sort indicator at any one time. If you + don't want any section to show a sort indicator pass a \a section + number of -1. + + \sa sortIndicatorSection(), sortIndicatorOrder() +*/ + +/*! + Returns the section showing the sort indicator or -1 if there is no sort indicator. + + \sa setSortIndicator(), sortIndicatorOrder() +*/ + +int Q3Header::sortIndicatorSection() const +{ + return d->sortSection; +} + +/*! + Returns the implied sort order of the Q3Headers sort indicator. + + \sa setSortIndicator(), sortIndicatorSection() +*/ + +Qt::SortOrder Q3Header::sortIndicatorOrder() const +{ + return d->sortDirection ? Qt::AscendingOrder : Qt::DescendingOrder; +} + +/*! + Resizes section \a section to \a s pixels wide (or high). +*/ + +void Q3Header::resizeSection(int section, int s) +{ + setCellSize(section, s); + update(); +} + +/*! + Returns the width (or height) of the \a section in pixels. +*/ + +int Q3Header::sectionSize(int section) const +{ + if (section < 0 || section >= count()) + return 0; + return d->sizes[section]; +} + +/*! + Returns the position (in pixels) at which the \a section starts. + + \sa offset() +*/ + +int Q3Header::sectionPos(int section) const +{ + if (d->positionsDirty) + ((Q3Header *)this)->calculatePositions(); + if (section < 0 || section >= count() ) + return 0; + return d->positions[d->s2i[section]]; +} + +/*! + Returns the index of the section which contains the position \a + pos given in pixels from the left (or top). + + \sa offset() +*/ + +int Q3Header::sectionAt(int pos) const +{ + if (reverse()) + pos = d->lastPos - pos; + return d->sectionAt(pos); +} + +/*! + Returns the number of the section that is displayed at index + position \a index. +*/ + +int Q3Header::mapToSection(int index) const +{ + return (index >= 0 && index < count()) ? d->i2s[index] : -1; +} + +/*! + Returns the index position at which section \a section is + displayed. +*/ + +int Q3Header::mapToIndex(int section) const +{ + return (section >= 0 && section < count()) ? d->s2i[section] : -1; +} + +/*! + Moves section \a section to index position \a toIndex. +*/ + +void Q3Header::moveSection(int section, int toIndex) +{ + int fromIndex = mapToIndex(section); + if (fromIndex == toIndex || + fromIndex < 0 || fromIndex > count() || + toIndex < 0 || toIndex > count()) + return; + int i; + int idx = d->i2s[fromIndex]; + if (fromIndex < toIndex) { + for (i = fromIndex; i < toIndex - 1; i++) { + int t; + d->i2s[i] = t = d->i2s[i+1]; + d->s2i[t] = i; + } + d->i2s[toIndex-1] = idx; + d->s2i[idx] = toIndex-1; + } else { + for (i = fromIndex; i > toIndex; i--) { + int t; + d->i2s[i] = t = d->i2s[i-1]; + d->s2i[t] = i; + } + d->i2s[toIndex] = idx; + d->s2i[idx] = toIndex; + } + calculatePositions(); +} + +/*! + Returns true if section \a section is clickable; otherwise returns + false. + + If \a section is out of range (negative or larger than count() - + 1): returns true if all sections are clickable; otherwise returns + false. + + \sa setClickEnabled() +*/ + +bool Q3Header::isClickEnabled(int section) const +{ + if (section >= 0 && section < count()) { + return (bool)d->clicks[section]; + } + + for (int i = 0; i < count(); ++i) { + if (!d->clicks[i]) + return false; + } + return true; +} + +/*! + Returns true if section \a section is resizeable; otherwise + returns false. + + If \a section is -1 then this function applies to all sections, + i.e. returns true if all sections are resizeable; otherwise + returns false. + + \sa setResizeEnabled() +*/ + +bool Q3Header::isResizeEnabled(int section) const +{ + if (section >= 0 && section < count()) { + return (bool)d->resize[section]; + } + + for (int i = 0; i < count();++i) { + if (!d->resize[i]) + return false; + } + return true; +} + +bool Q3Header::isMovingEnabled() const +{ + return d->move; +} + +/*! \internal */ + +void Q3Header::setUpdatesEnabled(bool enable) +{ + if (enable) + calculatePositions(); + QWidget::setUpdatesEnabled(enable); +} + + +bool Q3Header::reverse () const +{ +#if 0 + return (orient == Qt::Horizontal && QApplication::reverseLayout()); +#else + return false; +#endif +} + +/*! \reimp */ +void Q3Header::resizeEvent(QResizeEvent *e) +{ + if (e) + QWidget::resizeEvent(e); + + if(d->lastPos < width()) { + offs = 0; + } + + if (e) { + adjustHeaderSize(orientation() == Qt::Horizontal ? + width() - e->oldSize().width() : height() - e->oldSize().height()); + if ((orientation() == Qt::Horizontal && height() != e->oldSize().height()) + || (orientation() == Qt::Vertical && width() != e->oldSize().width())) + update(); + } else + adjustHeaderSize(); +} + +/*! + \fn void Q3Header::adjustHeaderSize() + + Adjusts the size of the sections to fit the size of the header as + completely as possible. Only sections for which isStretchEnabled() + is true will be resized. +*/ + +void Q3Header::adjustHeaderSize(int diff) +{ + if (!count()) + return; + + // we skip the adjustHeaderSize when trying to resize the last column which is set to stretchable + if (d->fullSize == (count() -1) && + (d->lastPos - d->sizes[count() -1]) > (orient == Qt::Horizontal ? width() : height())) + return; + + if (d->fullSize >= 0) { + int sec = mapToSection(d->fullSize); + int lsec = mapToSection(count() - 1); + int ns = sectionSize(sec) + + (orientation() == Qt::Horizontal ? + width() : height()) - (sectionPos(lsec) + sectionSize(lsec)); + int os = sectionSize(sec); + if (ns < 20) + ns = 20; + setCellSize(sec, ns); + repaint(); + emit sizeChange(sec, os, ns); + } else if (d->fullSize == -1) { + int df = diff / count(); + int part = orientation() == Qt::Horizontal ? width() / count() : height() / count(); + for (int i = 0; i < count() - 1; ++i) { + int sec = mapToIndex(i); + int os = sectionSize(sec); + int ns = diff != -1 ? os + df : part; + if (ns < 20) + ns = 20; + setCellSize(sec, ns); + emit sizeChange(sec, os, ns); + } + int sec = mapToIndex(count() - 1); + int ns = (orientation() == Qt::Horizontal ? width() : height()) - sectionPos(sec); + int os = sectionSize(sec); + if (ns < 20) + ns = 20; + setCellSize(sec, ns); + repaint(); + emit sizeChange(sec, os, ns); + } +} + +/*! + Returns the total width of all the header columns. +*/ +int Q3Header::headerWidth() const +{ + if (d->pos_dirty) { + ((Q3Header*)this)->calculatePositions(); + d->pos_dirty = false; + } + return d->lastPos; +} + +void Q3Header::calculatePositions(bool onlyVisible, int start) +{ + d->positionsDirty = false; + d->lastPos = count() > 0 ? d->positions[start] : 0; + for (int i = start; i < count(); i++) { + d->positions[i] = d->lastPos; + d->lastPos += d->sizes[d->i2s[i]]; + if (onlyVisible && d->lastPos > offset() + + (orientation() == Qt::Horizontal ? width() : height())) + break; + } + d->pos_dirty = onlyVisible; +} + + +/*! + \property Q3Header::stretching + \brief whether the header sections always take up the full width + (or height) of the header +*/ + + +/*! + If \a b is true, section \a section will be resized when the + header is resized, so that the sections take up the full width (or + height for vertical headers) of the header; otherwise section \a + section will be set to be unstretchable and will not resize when + the header is resized. + + If \a section is -1, and if \a b is true, then all sections will + be resized equally when the header is resized so that they take up + the full width (or height for vertical headers) of the header; + otherwise all the sections will be set to be unstretchable and + will not resize when the header is resized. + + \sa adjustHeaderSize() +*/ + +void Q3Header::setStretchEnabled(bool b, int section) +{ + if (b) + d->fullSize = section; + else + d->fullSize = -2; + adjustHeaderSize(); +} + +bool Q3Header::isStretchEnabled() const +{ + return d->fullSize == -1; +} + +/*! + \overload + + Returns true if section \a section will resize to take up the full + width (or height) of the header; otherwise returns false. If at + least one section has stretch enabled the sections will always + take up the full width of the header. + + \sa setStretchEnabled() +*/ + +bool Q3Header::isStretchEnabled(int section) const +{ + return d->fullSize == section; +} + +/*! + \reimp +*/ +void Q3Header::changeEvent(QEvent *ev) +{ + if(ev->type() == QEvent::FontChange) { + QFontMetrics fm = fontMetrics(); + d->height = (orient == Qt::Horizontal) ? fm.lineSpacing() + 6 : fm.width(QLatin1Char(' ')); + } + QWidget::changeEvent(ev); +} + +QT_END_NAMESPACE + +#endif // QT_NO_HEADER diff --git a/src/qt3support/widgets/q3header.h b/src/qt3support/widgets/q3header.h new file mode 100644 index 0000000..a7ac1c9 --- /dev/null +++ b/src/qt3support/widgets/q3header.h @@ -0,0 +1,225 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the Qt3Support module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, 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 qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef Q3HEADER_H +#define Q3HEADER_H + +#include <QtGui/qicon.h> +#include <QtGui/qwidget.h> +#include <QtCore/qstring.h> + +QT_BEGIN_HEADER + +QT_BEGIN_NAMESPACE + +QT_MODULE(Qt3SupportLight) + +#ifndef QT_NO_HEADER + +class QShowEvent; +class Q3HeaderData; +class Q3Table; +class Q3ListView; + +class Q_COMPAT_EXPORT Q3Header : public QWidget +{ + friend class Q3Table; + friend class Q3TableHeader; + friend class Q3ListView; + + Q_OBJECT + Q_PROPERTY(Qt::Orientation orientation READ orientation WRITE setOrientation) + Q_PROPERTY(bool tracking READ tracking WRITE setTracking) + Q_PROPERTY(int count READ count) + Q_PROPERTY(int offset READ offset WRITE setOffset) + Q_PROPERTY(bool moving READ isMovingEnabled WRITE setMovingEnabled) + Q_PROPERTY(bool stretching READ isStretchEnabled WRITE setStretchEnabled) + +public: + Q3Header(QWidget* parent=0, const char* name=0); + Q3Header(int, QWidget* parent=0, const char* name=0); + ~Q3Header(); + + int addLabel(const QString &, int size = -1); + int addLabel(const QIcon&, const QString &, int size = -1); + void removeLabel(int section); + virtual void setLabel(int, const QString &, int size = -1); + virtual void setLabel(int, const QIcon&, const QString &, int size = -1); + QString label(int section) const; + QIcon* iconSet(int section) const; + + virtual void setOrientation(Qt::Orientation); + Qt::Orientation orientation() const; + virtual void setTracking(bool enable); + bool tracking() const; + + virtual void setClickEnabled(bool, int section = -1); + virtual void setResizeEnabled(bool, int section = -1); + virtual void setMovingEnabled(bool); + virtual void setStretchEnabled(bool b, int section); + void setStretchEnabled(bool b) { setStretchEnabled(b, -1); } + bool isClickEnabled(int section = -1) const; + bool isResizeEnabled(int section = -1) const; + bool isMovingEnabled() const; + bool isStretchEnabled() const; + bool isStretchEnabled(int section) const; + + void resizeSection(int section, int s); + int sectionSize(int section) const; + int sectionPos(int section) const; + int sectionAt(int pos) const; + int count() const; + int headerWidth() const; + QRect sectionRect(int section) const; + + virtual void setCellSize(int , int); // obsolete, do not use + int cellSize(int i) const { return sectionSize(mapToSection(i)); } // obsolete, do not use + int cellPos(int) const; // obsolete, do not use + int cellAt(int pos) const { return mapToIndex(sectionAt(pos + offset())); } // obsolete, do not use + + int offset() const; + + QSize sizeHint() const; + + int mapToSection(int index) const; + int mapToIndex(int section) const; + int mapToLogical(int) const; // obsolete, do not use + int mapToActual(int) const; // obsolete, do not use + + void moveSection(int section, int toIndex); + virtual void moveCell(int, int); // obsolete, do not use + + void setSortIndicator(int section, bool ascending = true); // obsolete, do not use + inline void setSortIndicator(int section, Qt::SortOrder order) + { setSortIndicator(section, (order == Qt::AscendingOrder)); } + int sortIndicatorSection() const; + Qt::SortOrder sortIndicatorOrder() const; + + void adjustHeaderSize() { adjustHeaderSize(-1); } + +public Q_SLOTS: + void setUpdatesEnabled(bool enable); + virtual void setOffset(int pos); + +Q_SIGNALS: + void clicked(int section); + void pressed(int section); + void released(int section); + void sizeChange(int section, int oldSize, int newSize); + void indexChange(int section, int fromIndex, int toIndex); + void sectionClicked(int); // obsolete, do not use + void moved(int, int); // obsolete, do not use + void sectionHandleDoubleClicked(int section); + +protected: + void paintEvent(QPaintEvent *); + void showEvent(QShowEvent *e); + void resizeEvent(QResizeEvent *e); + QRect sRect(int index); + + virtual void paintSection(QPainter *p, int index, const QRect& fr); + virtual void paintSectionLabel(QPainter* p, int index, const QRect& fr); + + void changeEvent(QEvent *); + void mousePressEvent(QMouseEvent *); + void mouseReleaseEvent(QMouseEvent *); + void mouseMoveEvent(QMouseEvent *); + void mouseDoubleClickEvent(QMouseEvent *); + + void keyPressEvent(QKeyEvent *); + void keyReleaseEvent(QKeyEvent *); + +private: + void handleColumnMove(int fromIdx, int toIdx); + void adjustHeaderSize(int diff); + void init(int); + + void paintRect(int p, int s); + void markLine(int idx); + void unMarkLine(int idx); + int pPos(int i) const; + int pSize(int i) const; + int findLine(int); + int handleAt(int p); + bool reverse() const; + void calculatePositions(bool onlyVisible = false, int start = 0); + void handleColumnResize(int, int, bool, bool = true); + QSize sectionSizeHint(int section, const QFontMetrics& fm) const; + void setSectionSizeAndHeight(int section, int size); + + void resizeArrays(int size); + void setIsATableHeader(bool b); + int offs; + int handleIdx; + int oldHIdxSize; + int moveToIdx; + enum State { Idle, Sliding, Pressed, Moving, Blocked }; + State state; + int clickPos; + bool trackingIsOn; + int oldHandleIdx; + int cachedPos; // not used + Qt::Orientation orient; + + Q3HeaderData *d; + +private: + Q_DISABLE_COPY(Q3Header) +}; + + +inline Qt::Orientation Q3Header::orientation() const +{ + return orient; +} + +inline void Q3Header::setTracking(bool enable) { trackingIsOn = enable; } +inline bool Q3Header::tracking() const { return trackingIsOn; } + +extern Q_COMPAT_EXPORT bool qt_qheader_label_return_null_strings; // needed for professional edition + +#endif // QT_NO_HEADER + +QT_END_NAMESPACE + +QT_END_HEADER + +#endif // Q3HEADER_H diff --git a/src/qt3support/widgets/q3hgroupbox.cpp b/src/qt3support/widgets/q3hgroupbox.cpp new file mode 100644 index 0000000..f5672a0 --- /dev/null +++ b/src/qt3support/widgets/q3hgroupbox.cpp @@ -0,0 +1,92 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the Qt3Support module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, 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 qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "q3hgroupbox.h" + +QT_BEGIN_NAMESPACE + +/*! + \class Q3HGroupBox + + \brief The Q3HGroupBox widget organizes widgets in a group with one + horizontal row. + + \compat + + Q3HGroupBox is a convenience class that offers a thin layer on top + of Q3GroupBox. Think of it as a Q3HBox that offers a frame with a + title. + + \sa Q3VGroupBox +*/ + +/*! + Constructs a horizontal group box with no title. + + The \a parent and \a name arguments are passed to the QWidget + constructor. +*/ +Q3HGroupBox::Q3HGroupBox( QWidget *parent, const char *name ) + : Q3GroupBox( 1, Qt::Vertical /* sic! */, parent, name ) +{ +} + +/*! + Constructs a horizontal group box with the title \a title. + + The \a parent and \a name arguments are passed to the QWidget + constructor. +*/ + +Q3HGroupBox::Q3HGroupBox( const QString &title, QWidget *parent, + const char *name ) + : Q3GroupBox( 1, Qt::Vertical /* sic! */, title, parent, name ) +{ +} + +/*! + Destroys the horizontal group box, deleting its child widgets. +*/ +Q3HGroupBox::~Q3HGroupBox() +{ +} + +QT_END_NAMESPACE diff --git a/src/qt3support/widgets/q3hgroupbox.h b/src/qt3support/widgets/q3hgroupbox.h new file mode 100644 index 0000000..b2c8ebd --- /dev/null +++ b/src/qt3support/widgets/q3hgroupbox.h @@ -0,0 +1,69 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the Qt3Support module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, 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 qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef Q3HGROUPBOX_H +#define Q3HGROUPBOX_H + +#include <Qt3Support/q3groupbox.h> + +QT_BEGIN_HEADER + +QT_BEGIN_NAMESPACE + +QT_MODULE(Qt3SupportLight) + +class Q_COMPAT_EXPORT Q3HGroupBox : public Q3GroupBox +{ + Q_OBJECT +public: + Q3HGroupBox( QWidget* parent=0, const char* name=0 ); + Q3HGroupBox( const QString &title, QWidget* parent=0, const char* name=0 ); + ~Q3HGroupBox(); + +private: + Q_DISABLE_COPY(Q3HGroupBox) +}; + +QT_END_NAMESPACE + +QT_END_HEADER + +#endif // Q3HGROUPBOX_H diff --git a/src/qt3support/widgets/q3mainwindow.cpp b/src/qt3support/widgets/q3mainwindow.cpp new file mode 100644 index 0000000..6e066d3 --- /dev/null +++ b/src/qt3support/widgets/q3mainwindow.cpp @@ -0,0 +1,2427 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the Qt3Support module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, 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 qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "q3mainwindow.h" +#ifndef QT_NO_MAINWINDOW + +#include "qapplication.h" +#include "qbitmap.h" +#include "qcursor.h" +#include "qdatetime.h" +#include "q3dockarea.h" +#include "qevent.h" +#include "qlayout.h" +#include "qmap.h" +#include "qmenubar.h" +#include "qpainter.h" +#include "q3popupmenu.h" +#include "q3scrollview.h" +#include "qstatusbar.h" +#include "qstringlist.h" +#include "qstyle.h" +#include "qstyleoption.h" +#include "qtimer.h" +#include "q3toolbar.h" +#include "qtooltip.h" +#include "qwhatsthis.h" +#ifdef Q_WS_MAC +# include <private/qt_mac_p.h> +#endif + +#include <private/q3mainwindow_p.h> + +QT_BEGIN_NAMESPACE + +class QHideDock; + +/* Q3MainWindowLayout, respects widthForHeight layouts (like the left + and right docks are) +*/ + +class Q3MainWindowLayout : public QLayout +{ + Q_OBJECT + +public: + Q3MainWindowLayout(Q3MainWindow *mw); + ~Q3MainWindowLayout() {} + + void addItem(QLayoutItem *); + void setLeftDock(Q3DockArea *l); + void setRightDock(Q3DockArea *r); + void setCentralWidget(QWidget *w); + bool hasHeightForWidth() const { return false; } + QSize sizeHint() const; + QSize minimumSize() const; + QLayoutItem *itemAt(int) const { return 0; } //### + QLayoutItem *takeAt(int) { return 0; } //### + int count() const { return 0; } //### + +protected: + void setGeometry(const QRect &r) { + QLayout::setGeometry(r); + layoutItems(r); + } + +private: + int layoutItems(const QRect&, bool testonly = false); + int extraPixels() const; + + Q3DockArea *left, *right; + QWidget *central; + Q3MainWindow *mainWindow; + +}; + +QSize Q3MainWindowLayout::sizeHint() const +{ + int w = 0; + int h = 0; + + if (left) { + w += left->sizeHint().width(); + h = qMax(h, left->sizeHint().height()); + } + if (right) { + w += right->sizeHint().width(); + h = qMax(h, right->sizeHint().height()); + } + if (central) { + w += central->sizeHint().width(); + int diff = extraPixels(); + h = qMax(h, central->sizeHint().height() + diff); + } + return QSize(w, h); +} + +QSize Q3MainWindowLayout::minimumSize() const +{ + int w = 0; + int h = 0; + + if (left) { + QSize ms = left->minimumSizeHint().expandedTo(left->minimumSize()); + w += ms.width(); + h = qMax(h, ms.height()); + } + if (right) { + QSize ms = right->minimumSizeHint().expandedTo(right->minimumSize()); + w += ms.width(); + h = qMax(h, ms.height()); + } + if (central) { + QSize min = central->minimumSize().isNull() ? + central->minimumSizeHint() : central->minimumSize(); + w += min.width(); + int diff = extraPixels(); + h = qMax(h, min.height() + diff); + } + return QSize(w, h); +} + +Q3MainWindowLayout::Q3MainWindowLayout(Q3MainWindow *mw) + : left(0), right(0), central(0) +{ + mainWindow = mw; +} + +void Q3MainWindowLayout::setLeftDock(Q3DockArea *l) +{ + left = l; +} + +void Q3MainWindowLayout::setRightDock(Q3DockArea *r) +{ + right = r; +} + +void Q3MainWindowLayout::setCentralWidget(QWidget *w) +{ + central = w; +} + +int Q3MainWindowLayout::layoutItems(const QRect &r, bool testonly) +{ + if (!left && !central && !right) + return 0; + + int wl = 0, wr = 0; + if (left) + wl = ((Q3DockAreaLayout*)left->QWidget::layout())->widthForHeight(r.height()); + if (right) + wr = ((Q3DockAreaLayout*)right->QWidget::layout())->widthForHeight(r.height()); + int w = r.width() - wr - wl; + if (w < 0) + w = 0; + + int diff = extraPixels(); + if (!testonly) { + QRect g(geometry()); + if (left) + left->setGeometry(QRect(g.x(), g.y() + diff, wl, r.height() - diff)); + if (right) + right->setGeometry(QRect(g.x() + g.width() - wr, g.y() + diff, wr, r.height() - diff)); + if (central) + central->setGeometry(g.x() + wl, g.y() + diff, w, r.height() - diff); + } + + w = wl + wr; + if (central) + w += central->minimumSize().width(); + return w; +} + +int Q3MainWindowLayout::extraPixels() const +{ + if (mainWindow->d_func()->topDock->isEmpty() && + !(mainWindow->d_func()->leftDock->isEmpty() && + mainWindow->d_func()->rightDock->isEmpty())) { + return 2; + } else { + return 0; + } +} + +void Q3MainWindowLayout::addItem(QLayoutItem * /* item */) +{ +} + +/* + QHideToolTip and QHideDock - minimized dock +*/ + +#if 0 +class QHideToolTip : public QToolTip +{ +public: + QHideToolTip(QWidget *parent) : QToolTip(parent) {} + + void maybeTip(const QPoint &pos); +}; +#endif + + +class QHideDock : public QWidget +{ + Q_OBJECT + +public: + QHideDock(Q3MainWindow *parent) : QWidget(parent, "qt_hide_dock") { + hide(); + setFixedHeight(style()->pixelMetric(QStyle::PM_DockWidgetHandleExtent, 0, this) + 3); + pressedHandle = -1; + pressed = false; + setMouseTracking(true); + win = parent; +#if 0 + tip = new QHideToolTip(this); +#endif + } + ~QHideDock() + { +#if 0 + delete tip; +#endif + } + +protected: + void paintEvent(QPaintEvent *e) { + QObjectList childList = children(); + if (childList.isEmpty()) + return; + QPainter p(this); + p.setClipRegion(e->rect()); + p.fillRect(e->rect(), palette().brush(QPalette::Window)); + int x = 0; + for (int i = 0; i < childList.size(); ++i) { + QObject *o = childList.at(i); + Q3DockWindow *dw = qobject_cast<Q3DockWindow*>(o); + if (!dw || !dw->isVisible()) + continue; + QStyleOptionQ3DockWindow opt; + opt.rect.setRect(x, 0, 30, 10); + opt.palette = palette(); + opt.docked = dw->area(); + opt.closeEnabled = dw->isCloseEnabled(); + opt.state = QStyle::State_None; + if (i == pressedHandle) + opt.state |= QStyle::State_On; + + style()->drawPrimitive(QStyle::PE_IndicatorToolBarHandle, &opt, &p, this); + x += 30; + } + } + + void mousePressEvent(QMouseEvent *e) { + pressed = true; + QObjectList childList = children(); + if (childList.isEmpty()) + return; + mouseMoveEvent(e); + pressedHandle = -1; + + if (e->button() == Qt::RightButton && win->isDockMenuEnabled()) { + // ### TODO: HideDock menu + } else { + mouseMoveEvent(e); + } + } + + void mouseMoveEvent(QMouseEvent *e) { + QObjectList childList = children(); + if (childList.isEmpty()) + return; + if (!pressed) + return; + int x = 0; + if (e->y() >= 0 && e->y() <= height()) { + for (int i = 0; i < childList.size(); ++i) { + QObject *o = childList.at(i); + Q3DockWindow *dw = qobject_cast<Q3DockWindow*>(o); + if (!dw || !dw->isVisible()) + continue; + if (e->x() >= x && e->x() <= x + 30) { + int old = pressedHandle; + pressedHandle = i; + if (pressedHandle != old) + repaint(); + return; + } + x += 30; + } + } + int old = pressedHandle; + pressedHandle = -1; + if (old != -1) + repaint(); + } + + void mouseReleaseEvent(QMouseEvent *e) { + pressed = false; + if (pressedHandle == -1) + return; + QObjectList childList = children(); + if (childList.isEmpty()) + return; + if (e->button() == Qt::LeftButton) { + if (e->y() >= 0 && e->y() <= height()) { + QObject *o = childList.at(pressedHandle); + Q3DockWindow *dw = qobject_cast<Q3DockWindow*>(o); + if (dw) { + dw->show(); + dw->dock(); + } + } + } + pressedHandle = -1; + repaint(); + } + + bool eventFilter(QObject *o, QEvent *e) { + if (o == this || !o->isWidgetType()) + return QWidget::eventFilter(o, e); + if (e->type() == QEvent::HideToParent || + e->type() == QEvent::ShowToParent) + updateState(); + return QWidget::eventFilter(o, e); + } + + void updateState() { + bool visible = true; + QObjectList childList = children(); + if (childList.isEmpty()) + return; + for (int i = 0; i < childList.size(); ++i) { + QObject *o = childList.at(i); + Q3DockWindow *dw = qobject_cast<Q3DockWindow*>(o); + if (!dw) + continue; + if (dw->isHidden()) { + visible = false; + continue; + } + if (!dw->isVisible()) + continue; + visible = true; + break; + } + + if (visible) + show(); + else + hide(); + win->triggerLayout(false); + update(); + } + + void childEvent(QChildEvent *e) { + QWidget::childEvent(e); + if (e->type() == QEvent::ChildInserted) + e->child()->installEventFilter(this); + else + e->child()->removeEventFilter(this); + updateState(); + } + +private: + Q3MainWindow *win; + int pressedHandle; + bool pressed; +#if 0 + QHideToolTip *tip; + friend class QHideToolTip; +#endif +}; + +#if 0 +void QHideToolTip::maybeTip(const QPoint &pos) +{ + if (!parentWidget()) + return; + QHideDock *dock = (QHideDock*)parentWidget(); + + QObjectList dchilds = dock->children(); + if (dchilds.isEmpty()) + return; + int x = 0; + for (int i = 0; i < dchilds.size(); ++i) { + QObject *o = dchilds.at(i); + Q3DockWindow *dw = qobject_cast<Q3DockWindow*>(o); + if (!dw || !dw->isVisible()) + continue; + if (pos.x() >= x && pos.x() <= x + 30) { + Q3DockWindow *dw = (Q3DockWindow*)o; + if (!dw->windowTitle().isEmpty()) + tip(QRect(x, 0, 30, dock->height()), dw->windowTitle()); + return; + } + x += 30; + } +} +#endif + +/*! + \class Q3MainWindow + \brief The Q3MainWindow class provides a main application window, + with a menu bar, dock windows (e.g. for toolbars), and a status + bar. + + \compat + + Main windows are most often used to provide menus, toolbars and a + status bar around a large central widget, such as a text edit, + drawing canvas or QWorkspace (for MDI applications). Q3MainWindow + is usually subclassed since this makes it easier to encapsulate + the central widget, menus and toolbars as well as the window's + state. Subclassing makes it possible to create the slots that are + called when the user clicks menu items or toolbar buttons. + + We'll briefly review adding menu items and + toolbar buttons then describe the facilities of Q3MainWindow + itself. + + \snippet doc/src/snippets/code/src_qt3support_widgets_q3mainwindow.cpp 0 + + Q3MainWindows may be created in their own right as shown above. + The central widget is set with setCentralWidget(). Popup menus can + be added to the default menu bar, widgets can be added to the + status bar, toolbars and dock windows can be added to any of the + dock areas. + + The main window will take care of the dock areas, and the geometry + of the central widget, but all other aspects of the central widget + are left to you. Q3MainWindow automatically detects the creation of + a menu bar or status bar if you specify the Q3MainWindow as parent, + or you can use the provided menuBar() and statusBar() functions. + The functions menuBar() and statusBar() create a suitable widget + if one doesn't exist, and update the window's layout to make + space. + + New dock windows and toolbars can be added to a Q3MainWindow using + addDockWindow(). Qt::Dock windows can be moved using moveDockWindow() + and removed with removeDockWindow(). Q3MainWindow allows default + dock window (toolbar) docking in all its dock areas (\c Top, \c + Left, \c Right, \c Bottom). You can use setDockEnabled() to + enable and disable docking areas for dock windows. When adding or + moving dock windows you can specify their 'edge' (dock area). The + currently available edges are: \c Top, \c Left, \c Right, \c + Bottom, \c Minimized (effectively a 'hidden' dock area) and \c + TornOff (floating). See \l Qt::Dock for an explanation of these + areas. Note that the *ToolBar functions are included for backward + compatibility; all new code should use the *DockWindow functions. + QToolbar is a subclass of Q3DockWindow so all functions that work + with dock windows work on toolbars in the same way. + + \target dwm + If the user clicks the close button, then the dock window is + hidden. A dock window can be hidden or unhidden by the user by + right clicking a dock area and clicking the name of the relevant + dock window on the pop up dock window menu. This menu lists the + names of every dock window; visible dock windows have a tick + beside their names. The dock window menu is created automatically + as required by createDockWindowMenu(). Since it may not always be + appropriate for a dock window to appear on this menu the + setAppropriate() function is used to inform the main window + whether or not the dock window menu should include a particular + dock window. Double clicking a dock window handle (usually on the + left-hand side of the dock window) undocks (floats) the dock + window. Double clicking a floating dock window's title bar will + dock the floating dock window. (See also + \l{Q3MainWindow::DockWindows}.) + + Some functions change the appearance of a Q3MainWindow globally: + \list + \i Q3DockWindow::setHorizontalStretchable() and + Q3DockWindow::setVerticalStretchable() are used to make specific dock + windows or toolbars stretchable. + \i setUsesBigPixmaps() is used to set whether tool buttons should + draw small or large pixmaps (see QIcon for more information). + \i setUsesTextLabel() is used to set whether tool buttons + should display a textual label in addition to pixmaps + (see QToolButton for more information). + \endlist + + The user can drag dock windows into any enabled docking area. Qt::Dock + windows can also be dragged \e within a docking area, for example + to rearrange the order of some toolbars. Qt::Dock windows can also be + dragged outside any docking area (undocked or 'floated'). Being + able to drag dock windows can be enabled (the default) and + disabled using setDockWindowsMovable(). + + The \c Minimized edge is a hidden dock area. If this dock area is + enabled the user can hide (minimize) a dock window or show (restore) + a minimized dock window by clicking the dock window handle. If the + user hovers the mouse cursor over one of the handles, the caption of + the dock window is displayed in a tool tip (see + Q3DockWindow::windowTitle() or Q3ToolBar::label()), so if you enable the + \c Minimized dock area, it is best to specify a meaningful caption + or label for each dock window. To minimize a dock window + programmatically use moveDockWindow() with an edge of \c Minimized. + + Qt::Dock windows are moved transparently by default, i.e. during the + drag an outline rectangle is drawn on the screen representing the + position of the dock window as it moves. If you want the dock + window to be shown normally whilst it is moved use + setOpaqueMoving(). + + The location of a dock window, i.e. its dock area and position + within the dock area, can be determined by calling getLocation(). + Movable dock windows can be lined up to minimize wasted space with + lineUpDockWindows(). Pointers to the dock areas are available from + topDock(), leftDock(), rightDock() and bottomDock(). A customize + menu item is added to the pop up dock window menu if + isCustomizable() returns true; it returns false by default. + Reimplement isCustomizable() and customize() if you want to offer + this extra menu item, for example, to allow the user to change + settings relating to the main window and its toolbars and dock + windows. + + The main window's menu bar is fixed (at the top) by default. If + you want a movable menu bar, create a QMenuBar as a stretchable + widget inside its own movable dock window and restrict this dock + window to only live within the \c Top or \c Bottom dock: + + \snippet doc/src/snippets/code/src_qt3support_widgets_q3mainwindow.cpp 1 + + An application with multiple dock windows can choose to save the + current dock window layout in order to restore it later, e.g. in + the next session. You can do this by using the streaming operators + for Q3MainWindow. + + To save the layout and positions of all the dock windows do this: + + \snippet doc/src/snippets/code/src_qt3support_widgets_q3mainwindow.cpp 2 + + To restore the dock window positions and sizes (normally when the + application is next started), do the following: + + \snippet doc/src/snippets/code/src_qt3support_widgets_q3mainwindow.cpp 3 + + The QSettings class can be used in conjunction with the streaming + operators to store the application's settings. + + Q3MainWindow's management of dock windows and toolbars is done + transparently behind-the-scenes by Q3DockArea. + + For multi-document interfaces (MDI), use a QWorkspace as the + central widget. + + Adding dock windows, e.g. toolbars, to Q3MainWindow's dock areas is + straightforward. If the supplied dock areas are not sufficient for + your application we suggest that you create a QWidget subclass and + add your own dock areas (see \l Q3DockArea) to the subclass since + Q3MainWindow provides functionality specific to the standard dock + areas it provides. + + \sa Q3ToolBar Q3DockWindow QStatusBar QAction QMenuBar Q3PopupMenu QDialog +*/ + +/*! + \enum Q3MainWindow::DockWindows + + Right-clicking a dock area will pop-up the dock window menu + (createDockWindowMenu() is called automatically). When called in + code you can specify what items should appear on the menu with + this enum. + + \value OnlyToolBars The menu will list all the toolbars, but not + any other dock windows. + + \value NoToolBars The menu will list dock windows but not + toolbars. + + \value AllDockWindows The menu will list all toolbars and other + dock windows. (This is the default.) +*/ + +/*! + \fn void Q3MainWindow::addToolBar(Q3DockWindow *dockWindow, + Qt::Dock position, bool newLine); + + Adds a new toolbar to the \a dockWindow. The toolbar is placed in + the given \a position. If \a newLine is true the toolbar is put on + a new line. +*/ + +/*! + \fn void Q3MainWindow::addToolBar(Q3DockWindow *dockWindow, const + QString &label, Qt::Dock position, bool newLine) + \overload + + The toolbar has the caption \a label and is placed in the given \a + position. +*/ + +/*! + \fn void Q3MainWindow::moveToolBar(Q3DockWindow *dockWindow, Qt::Dock position); + + Moves the given \a dockWindow into the given \a position. +*/ + +/*! + \fn void Q3MainWindow::moveToolBar(Q3DockWindow *dockWindow, + Qt::Dock position, bool nl, int index, int extraOffset) + \overload + + The \a dockWindow is made the \a{index}-th item in the toolbar, + moved over by \a extraOffset. If \a nl is true, the dock window is + put on a new line. +*/ + +/*! + \fn void Q3MainWindow::removeToolBar(Q3DockWindow *dockWindow); + + Removes the toolbar from the given \a dockWindow. +*/ + +/*! + \fn void Q3MainWindow::lineUpToolBars(bool keepNewLines); + + Lines up the toolbars. Line breaks are preserved if \a + keepNewLines is true. +*/ + +/*! + \fn void Q3MainWindow::toolBarPositionChanged(Q3ToolBar *toolbar); + + This signal is emitted when a \a toolbar is moved. +*/ + +/*! + \fn bool Q3MainWindow::toolBarsMovable() const + + Returns true if the window allows its toolbars to be moved; otherwise + returns false. +*/ + +/*! + \fn void Q3MainWindow::setToolBarsMovable(bool b) + If \a b is true the tool bars can be moved. +*/ + +/*! + Constructs an empty main window. The \a parent, \a name and widget + flags \a f, are passed on to the QWidget constructor. + + By default, the widget flags are set to Qt::WType_TopLevel rather + than 0 as they are with QWidget. If you don't want your + Q3MainWindow to be a top level widget then you will need to set \a + f to 0. +*/ + +Q3MainWindow::Q3MainWindow(QWidget * parent, const char * name, Qt::WindowFlags f) + : QWidget(*new Q3MainWindowPrivate, parent, f) +{ + Q_D(Q3MainWindow); + setObjectName(QLatin1String(name)); +#ifdef Q_WS_MAC + d->opaque = true; +#else + d->opaque = false; +#endif + installEventFilter(this); + d->topDock = new Q3DockArea(Qt::Horizontal, Q3DockArea::Normal, this, "qt_top_dock"); + d->topDock->installEventFilter(this); + d->bottomDock = new Q3DockArea(Qt::Horizontal, Q3DockArea::Reverse, this, "qt_bottom_dock"); + d->bottomDock->installEventFilter(this); + d->leftDock = new Q3DockArea(Qt::Vertical, Q3DockArea::Normal, this, "qt_left_dock"); + d->leftDock->installEventFilter(this); + d->rightDock = new Q3DockArea(Qt::Vertical, Q3DockArea::Reverse, this, "qt_right_dock"); + d->rightDock->installEventFilter(this); + d->hideDock = new QHideDock(this); +} + + +/*! + Destroys the object and frees any allocated resources. +*/ + +Q3MainWindow::~Q3MainWindow() +{ + delete layout(); +} + +#ifndef QT_NO_MENUBAR +/*! + Sets this main window to use the menu bar \a newMenuBar. + + The existing menu bar (if any) is deleted along with its contents. + + \sa menuBar() +*/ + +void Q3MainWindow::setMenuBar(QMenuBar * newMenuBar) +{ + Q_D(Q3MainWindow); + if (!newMenuBar) + return; + if (d->mb) + delete d->mb; + d->mb = newMenuBar; + d->mb->installEventFilter(this); + triggerLayout(); +} + + +/*! + Returns the menu bar for this window. + + If there isn't one, then menuBar() creates an empty menu bar. + + \sa statusBar() +*/ + +QMenuBar * Q3MainWindow::menuBar() const +{ + Q_D(const Q3MainWindow); + if (d->mb) + return d->mb; + + QObjectList l = queryList("QMenuBar", 0, false, false); + QMenuBar * b; + if (l.size()) { + b = static_cast<QMenuBar *>(l.at(0)); + } else { + b = new QMenuBar((Q3MainWindow *)this); + b->setObjectName(QLatin1String("automatic menu bar")); + b->show(); + } + d->mb = b; + d->mb->installEventFilter(const_cast<Q3MainWindow *>(this)); + ((Q3MainWindow *)this)->triggerLayout(); + return b; +} +#endif // QT_NO_MENUBAR + +/*! + Sets this main window to use the status bar \a newStatusBar. + + The existing status bar (if any) is deleted along with its + contents. + + Note that \a newStatusBar \e must be a child of this main window, + and that it is not automatically displayed. If you call this + function after show(), you will probably also need to call + newStatusBar->show(). + + \sa setMenuBar() statusBar() +*/ + +void Q3MainWindow::setStatusBar(QStatusBar * newStatusBar) +{ + Q_D(Q3MainWindow); + if (!newStatusBar || newStatusBar == d->sb) + return; + if (d->sb) + delete d->sb; + d->sb = newStatusBar; +#if 0 + // ### this code can cause unnecessary creation of a tool tip group + connect(toolTipGroup(), SIGNAL(showTip(QString)), + d->sb, SLOT(showMessage(QString))); + connect(toolTipGroup(), SIGNAL(removeTip()), + d->sb, SLOT(clearMessage())); +#endif + d->sb->installEventFilter(this); + triggerLayout(); +} + + +/*! + Returns this main window's status bar. If there isn't one, + statusBar() creates an empty status bar, and if necessary a tool + tip group too. + + \sa menuBar() +*/ + +QStatusBar * Q3MainWindow::statusBar() const +{ + Q_D(const Q3MainWindow); + if (d->sb) + return d->sb; + + QObjectList l = queryList("QStatusBar", 0, false, false); + QStatusBar * s; + if (l.size()) { + s = (QStatusBar *)l.at(0); + } else { + s = new QStatusBar((Q3MainWindow *)this, "automatic status bar"); + s->show(); + } + ((Q3MainWindow *)this)->setStatusBar(s); + ((Q3MainWindow *)this)->triggerLayout(true); + return s; +} + + +#if 0 +/*! + Sets this main window to use the tool tip group \a + newToolTipGroup. + + The existing tool tip group (if any) is deleted along with its + contents. All the tool tips connected to it lose the ability to + display the group texts. + + \sa menuBar() +*/ + +void Q3MainWindow::setToolTipGroup(QToolTipGroup * newToolTipGroup) +{ + Q_D(Q3MainWindow); + if (!newToolTipGroup || newToolTipGroup == d->ttg) + return; + if (d->ttg) + delete d->ttg; + d->ttg = newToolTipGroup; + + connect(toolTipGroup(), SIGNAL(showTip(QString)), + statusBar(), SLOT(showMessage(QString))); + connect(toolTipGroup(), SIGNAL(removeTip()), + statusBar(), SLOT(clearMessage())); +} + + +/*! + Returns this main window's tool tip group. If there isn't one, + toolTipGroup() creates an empty tool tip group. + + \sa menuBar() statusBar() +*/ +QToolTipGroup * Q3MainWindow::toolTipGroup() const +{ + Q_D(const Q3MainWindow); + if (d->ttg) + return d->ttg; + + QToolTipGroup * t = new QToolTipGroup((Q3MainWindow*)this, + "automatic tool tip group"); + ((Q3MainWindowPrivate*)d)->ttg = t; + return t; +} +#endif + + +/*! + If \a enable is true then users can dock windows in the \a dock + area. If \a enable is false users cannot dock windows in the \a + dock dock area. + + Users can dock (drag) dock windows into any enabled dock area. +*/ + +void Q3MainWindow::setDockEnabled(Qt::Dock dock, bool enable) +{ + d_func()->docks.insert(dock, enable); +} + + +/*! + Returns true if the \a dock dock area is enabled, i.e. it can + accept user dragged dock windows; otherwise returns false. + + \sa setDockEnabled() +*/ + +bool Q3MainWindow::isDockEnabled(Qt::Dock dock) const +{ + return d_func()->docks[dock]; +} + +/*! + \overload + + Returns true if dock area \a area is enabled, i.e. it can accept + user dragged dock windows; otherwise returns false. + + \sa setDockEnabled() +*/ + +bool Q3MainWindow::isDockEnabled(Q3DockArea *area) const +{ + Q_D(const Q3MainWindow); + if (area == d->leftDock) + return d->docks[Qt::DockLeft]; + if (area == d->rightDock) + return d->docks[Qt::DockRight]; + if (area == d->topDock) + return d->docks[Qt::DockTop]; + if (area == d->bottomDock) + return d->docks[Qt::DockBottom]; + return false; +} + +/*! + \overload + + If \a enable is true then users can dock the \a dw dock window in + the \a dock area. If \a enable is false users cannot dock the \a + dw dock window in the \a dock area. + + In general users can dock (drag) dock windows into any enabled + dock area. Using this function particular dock areas can be + enabled (or disabled) as docking points for particular dock + windows. +*/ + + +void Q3MainWindow::setDockEnabled(Q3DockWindow *dw, Qt::Dock dock, bool enable) +{ + Q_D(Q3MainWindow); + if (!d->dockWindows.contains(dw)) { + d->dockWindows.append(dw); + connect(dw, SIGNAL(placeChanged(Q3DockWindow::Place)), + this, SLOT(slotPlaceChanged())); + } + QString s; + s.sprintf("%p_%d", (void*)dw, (int)dock); + if (enable) + d->disabledDocks.removeAll(s); + else if (!d->disabledDocks.contains(s)) + d->disabledDocks << s; + switch (dock) { + case Qt::DockTop: + topDock()->setAcceptDockWindow(dw, enable); + break; + case Qt::DockLeft: + leftDock()->setAcceptDockWindow(dw, enable); + break; + case Qt::DockRight: + rightDock()->setAcceptDockWindow(dw, enable); + break; + case Qt::DockBottom: + bottomDock()->setAcceptDockWindow(dw, enable); + break; + default: + break; + } +} + +/*! + \overload + + Returns true if dock area \a area is enabled for the dock window + \a dw; otherwise returns false. + + \sa setDockEnabled() +*/ + +bool Q3MainWindow::isDockEnabled(Q3DockWindow *dw, Q3DockArea *area) const +{ + Q_D(const Q3MainWindow); + if (!isDockEnabled(area)) + return false; + Qt::Dock dock; + if (area == d->leftDock) + dock = Qt::DockLeft; + else if (area == d->rightDock) + dock = Qt::DockRight; + else if (area == d->topDock) + dock = Qt::DockTop; + else if (area == d->bottomDock) + dock = Qt::DockBottom; + else + return false; + return isDockEnabled(dw, dock); +} + +/*! + \overload + + Returns true if dock area \a dock is enabled for the dock window + \a tb; otherwise returns false. + + \sa setDockEnabled() +*/ + +bool Q3MainWindow::isDockEnabled(Q3DockWindow *tb, Qt::Dock dock) const +{ + if (!isDockEnabled(dock)) + return false; + QString s; + s.sprintf("%p_%d", (void*)tb, (int)dock); + return !d_func()->disabledDocks.contains(s); +} + + + +/*! + Adds \a dockWindow to the \a edge dock area. + + If \a newLine is false (the default) then the \a dockWindow is + added at the end of the \a edge. For vertical edges the end is at + the bottom, for horizontal edges (including \c Minimized) the end + is at the right. If \a newLine is true a new line of dock windows + is started with \a dockWindow as the first (left-most and + top-most) dock window. + + If \a dockWindow is managed by another main window, it is first + removed from that window. +*/ + +void Q3MainWindow::addDockWindow(Q3DockWindow *dockWindow, + Qt::Dock edge, bool newLine) +{ + Q_D(Q3MainWindow); +#if defined (Q_WS_MAC) && !defined(QT_MAC_USE_COCOA) + extern WindowPtr qt_mac_window_for(const QWidget*); //qwidget_mac.cpp + if(isWindow() && edge == Qt::DockTop) { + d->createWinId(); + ChangeWindowAttributes(qt_mac_window_for(this), kWindowToolbarButtonAttribute, 0); + } +#endif + moveDockWindow(dockWindow, edge); + dockWindow->setNewLine(newLine); + if (!d->dockWindows.contains(dockWindow)) { + d->dockWindows.append(dockWindow); + connect(dockWindow, SIGNAL(placeChanged(Q3DockWindow::Place)), + this, SLOT(slotPlaceChanged())); + dockWindow->installEventFilter(this); + } + dockWindow->setOpaqueMoving(d->opaque); +} + + +/*! + \overload + + Adds \a dockWindow to the dock area with label \a label. + + If \a newLine is false (the default) the \a dockWindow is added at + the end of the \a edge. For vertical edges the end is at the + bottom, for horizontal edges (including \c Minimized) the end is + at the right. If \a newLine is true a new line of dock windows is + started with \a dockWindow as the first (left-most and top-most) + dock window. + + If \a dockWindow is managed by another main window, it is first + removed from that window. +*/ + +void Q3MainWindow::addDockWindow(Q3DockWindow * dockWindow, const QString &label, + Qt::Dock edge, bool newLine) +{ + addDockWindow(dockWindow, edge, newLine); +#ifndef QT_NO_TOOLBAR + Q3ToolBar *tb = qobject_cast<Q3ToolBar*>(dockWindow); + if (tb) + tb->setLabel(label); +#endif +} + +/*! + Moves \a dockWindow to the end of the \a edge. + + For vertical edges the end is at the bottom, for horizontal edges + (including \c Minimized) the end is at the right. + + If \a dockWindow is managed by another main window, it is first + removed from that window. +*/ + +void Q3MainWindow::moveDockWindow(Q3DockWindow * dockWindow, Qt::Dock edge) +{ + Q_D(Q3MainWindow); + Qt::Orientation oo = dockWindow->orientation(); + switch (edge) { + case Qt::DockTop: + if (dockWindow->area() != d->topDock) + dockWindow->removeFromDock(false); + d->topDock->moveDockWindow(dockWindow); + emit dockWindowPositionChanged(dockWindow); + break; + case Qt::DockBottom: + if (dockWindow->area() != d->bottomDock) + dockWindow->removeFromDock(false); + d->bottomDock->moveDockWindow(dockWindow); + emit dockWindowPositionChanged(dockWindow); + break; + case Qt::DockRight: + if (dockWindow->area() != d->rightDock) + dockWindow->removeFromDock(false); + d->rightDock->moveDockWindow(dockWindow); + emit dockWindowPositionChanged(dockWindow); + break; + case Qt::DockLeft: + if (dockWindow->area() != d->leftDock) + dockWindow->removeFromDock(false); + d->leftDock->moveDockWindow(dockWindow); + emit dockWindowPositionChanged(dockWindow); + break; + case Qt::DockTornOff: + dockWindow->undock(); + break; + case Qt::DockMinimized: + dockWindow->undock(d->hideDock); + break; + case Qt::DockUnmanaged: + break; + } + + if (oo != dockWindow->orientation()) + dockWindow->setOrientation(dockWindow->orientation()); +} + +/*! + \overload + + Moves \a dockWindow to position \a index within the \a edge dock + area. + + Any dock windows with positions \a index or higher have their + position number incremented and any of these on the same line are + moved right (down for vertical dock areas) to make room. + + If \a nl is true, a new dock window line is created below the line + in which the moved dock window appears and the moved dock window, + with any others with higher positions on the same line, is moved + to this new line. + + The \a extraOffset is the space to put between the left side of + the dock area (top side for vertical dock areas) and the dock + window. (This is mostly used for restoring dock windows to the + positions the user has dragged them to.) + + If \a dockWindow is managed by another main window, it is first + removed from that window. +*/ + +void Q3MainWindow::moveDockWindow(Q3DockWindow * dockWindow, Qt::Dock edge, bool nl, int index, int extraOffset) +{ + Q_D(Q3MainWindow); + Qt::Orientation oo = dockWindow->orientation(); + + dockWindow->setNewLine(nl); + dockWindow->setOffset(extraOffset); + switch (edge) { + case Qt::DockTop: + if (dockWindow->area() != d->topDock) + dockWindow->removeFromDock(false); + d->topDock->moveDockWindow(dockWindow, index); + break; + case Qt::DockBottom: + if (dockWindow->area() != d->bottomDock) + dockWindow->removeFromDock(false); + d->bottomDock->moveDockWindow(dockWindow, index); + break; + case Qt::DockRight: + if (dockWindow->area() != d->rightDock) + dockWindow->removeFromDock(false); + d->rightDock->moveDockWindow(dockWindow, index); + break; + case Qt::DockLeft: + if (dockWindow->area() != d->leftDock) + dockWindow->removeFromDock(false); + d->leftDock->moveDockWindow(dockWindow, index); + break; + case Qt::DockTornOff: + dockWindow->undock(); + break; + case Qt::DockMinimized: + dockWindow->undock(d->hideDock); + break; + case Qt::DockUnmanaged: + break; + } + + if (oo != dockWindow->orientation()) + dockWindow->setOrientation(dockWindow->orientation()); +} + +/*! + Removes \a dockWindow from the main window's docking area, + provided \a dockWindow is non-null and managed by this main + window. +*/ + +void Q3MainWindow::removeDockWindow(Q3DockWindow * dockWindow) +{ + Q_D(Q3MainWindow); + +#if defined (Q_WS_MAC) && !defined (QT_MAC_USE_COCOA) + extern WindowPtr qt_mac_window_for(const QWidget*); //qwidget_mac.cpp + if(isWindow() && dockWindow->area() == topDock() && !dockWindows(Qt::DockTop).count()) + ChangeWindowAttributes(qt_mac_window_for(this), 0, kWindowToolbarButtonAttribute); +#endif + + dockWindow->hide(); + d->dockWindows.removeAll(dockWindow); + disconnect(dockWindow, SIGNAL(placeChanged(Q3DockWindow::Place)), + this, SLOT(slotPlaceChanged())); + dockWindow->removeEventFilter(this); +} + +/*! + Sets up the geometry management of the window. It is called + automatically when needed, so you shouldn't need to call it. +*/ + +void Q3MainWindow::setUpLayout() +{ + Q_D(Q3MainWindow); +#ifndef QT_NO_MENUBAR + if (!d->mb) { + // slightly evil hack here. reconsider this + QObjectList l = queryList("QMenuBar", 0, false, false); + if (l.size()) + d->mb = menuBar(); + } +#endif + if (!d->sb) { + // as above. + QObjectList l = queryList("QStatusBar", 0, false, false); + if (l.size()) + d->sb = statusBar(); + } + + if (!d->tll) { + d->tll = new QBoxLayout(this, QBoxLayout::Down); + d->tll->setResizeMode(minimumSize().isNull() ? QLayout::Minimum : QLayout::FreeResize); + d->mwl = new Q3MainWindowLayout(this); + } else { + d->tll->setMenuBar(0); + QLayoutItem *item; + while ((item = d->tll->takeAt(0))) { + if (item != d->mwl) + delete item; + } + } + +#ifndef QT_NO_MENUBAR + if (d->mb && d->mb->isVisibleTo(this)) { + d->tll->setMenuBar(d->mb); + if (style()->styleHint(QStyle::SH_MainWindow_SpaceBelowMenuBar, 0, this)) + d->tll->addSpacing(d->movable ? 1 : 2); + } +#endif + + d->tll->addWidget(d->hideDock); + if(d->topDock->parentWidget() == this) + d->tll->addWidget(d->topDock); + + Q3MainWindowLayout *mwl = d->mwl; + d->tll->addItem(mwl); + d->tll->setStretchFactor(mwl, 1); + + if(d->leftDock->parentWidget() == this) + mwl->setLeftDock(d->leftDock); + if (centralWidget()) + mwl->setCentralWidget(centralWidget()); + if(d->rightDock->parentWidget() == this) + mwl->setRightDock(d->rightDock); + + if(d->bottomDock->parentWidget() == this) + d->tll->addWidget(d->bottomDock); + + if (d->sb && d->sb->parentWidget() == this) { + d->tll->addWidget(d->sb, 0); + // make the sb stay on top of tool bars if there isn't enough space + d->sb->raise(); + } +} + +/*! \reimp */ +void Q3MainWindow::setVisible(bool visible) +{ + Q_D(Q3MainWindow); + if (visible) { + if (!d->tll) + setUpLayout(); + + // show all floating dock windows not explicitly hidden + if (!isVisible()) { + for (int i = 0; i < d->dockWindows.size(); ++i) { + Q3DockWindow *dw = d->dockWindows.at(i); + if (dw->isWindow() && !dw->isVisible() && !dw->testAttribute(Qt::WA_WState_Hidden)) { + reinterpret_cast<Q3MainWindow *>(dw)->setAttribute(Qt::WA_WState_Hidden); + dw->show(); + } + } + } + } else if (isVisible()) { + for (int i = 0; i < d->dockWindows.size(); ++i) { + Q3DockWindow *dw = d->dockWindows.at(i); + if (dw->isWindow() && dw->isVisible()) { + dw->hide(); // implicit hide, so clear forcehide + reinterpret_cast<Q3MainWindow *>(dw)->setAttribute(Qt::WA_WState_Hidden, false); + } + } + } + QWidget::setVisible(visible); +} + + +/*! \reimp */ +QSize Q3MainWindow::sizeHint() const +{ + Q3MainWindow* that = (Q3MainWindow*) this; + // Workaround: because d->tll get's deleted in + // totalSizeHint->polish->sendPostedEvents->childEvent->triggerLayout + QApplication::sendPostedEvents(that, QEvent::ChildInserted); + if (!that->d_func()->tll) + that->setUpLayout(); + return that->d_func()->tll->totalSizeHint(); +} + +/*! \reimp */ +QSize Q3MainWindow::minimumSizeHint() const +{ + Q_D(const Q3MainWindow); + if (!d->tll) { + Q3MainWindow* that = (Q3MainWindow*) this; + that->setUpLayout(); + } + return d->tll->totalMinimumSize(); +} + +/*! + Sets the central widget for this main window to \a w. + + The central widget is surrounded by the left, top, right and + bottom dock areas. The menu bar is above the top dock area. + + \sa centralWidget() +*/ + +void Q3MainWindow::setCentralWidget(QWidget * w) +{ + Q_D(Q3MainWindow); + if (d->mc) + d->mc->removeEventFilter(this); + d->mc = w; + if (d->mc) + d->mc->installEventFilter(this); + triggerLayout(); +} + + +/*! + Returns a pointer to the main window's central widget. + + The central widget is surrounded by the left, top, right and + bottom dock areas. The menu bar is above the top dock area. + + \sa setCentralWidget() +*/ + +QWidget * Q3MainWindow::centralWidget() const +{ + return d_func()->mc; +} + + +/*! \reimp */ + +void Q3MainWindow::paintEvent(QPaintEvent *) +{ + Q_D(Q3MainWindow); + if (d->mb && + style()->styleHint(QStyle::SH_MainWindow_SpaceBelowMenuBar, 0, this)) { + QPainter p(this); + int y = d->mb->height() + 1; + QStyleOption opt(0, QStyleOption::SO_Default); + opt.rect.setRect(0, y, width(), 1); + opt.palette = palette(); + opt.state = QStyle::State_Sunken; + style()->drawPrimitive(QStyle::PE_Q3Separator, &opt, &p, this); + } +} + + +bool Q3MainWindow::dockMainWindow(QObject *dock) const +{ + while (dock) { + if (dock->parent() && + dock->parent() == const_cast<Q3MainWindow*>(this)) + return true; + if (qobject_cast<Q3MainWindow*>(dock->parent())) + return false; + dock = dock->parent(); + } + return false; +} + +/*! + \reimp +*/ + +bool Q3MainWindow::eventFilter(QObject* o, QEvent *e) +{ + Q_D(Q3MainWindow); + if (e->type() == QEvent::Show && o == this) { + if (!d->tll) + setUpLayout(); + d->tll->activate(); + } else if (e->type() == QEvent::ContextMenu && d->dockMenu && + ((qobject_cast<Q3DockArea*>(o) && dockMainWindow(o)) || o == d->hideDock || o == d->mb)) { + if (showDockMenu(((QMouseEvent*)e)->globalPos())) { + ((QContextMenuEvent*)e)->accept(); + return true; + } + } + + return QWidget::eventFilter(o, e); +} + + +/*! + Monitors events, received in \a e, to ensure the layout is updated. +*/ +void Q3MainWindow::childEvent(QChildEvent* e) +{ + Q_D(Q3MainWindow); + if (e->type() == QEvent::ChildRemoved) { + if (e->child() == 0 || + !e->child()->isWidgetType() || + ((QWidget*)e->child())->isWindow()) { + // nothing + } else if (e->child() == d->sb) { + d->sb = 0; + triggerLayout(); + } else if (e->child() == d->mb) { + d->mb = 0; + triggerLayout(); + } else if (e->child() == d->mc) { + d->mc = 0; + d->mwl->setCentralWidget(0); + triggerLayout(); + } else if (qobject_cast<Q3DockWindow*>(e->child())) { + removeDockWindow((Q3DockWindow *)(e->child())); + d->appropriate.remove((Q3DockWindow*)e->child()); + triggerLayout(); + } + } else if (e->type() == QEvent::ChildInserted && !d->sb) { + d->sb = qobject_cast<QStatusBar*>(e->child()); + if (d->sb) { + if (d->tll) { + if (!d->tll->findWidget(d->sb)) + d->tll->addWidget(d->sb); + } else { + triggerLayout(); + } + } + } +} + +/*! + \reimp +*/ + +bool Q3MainWindow::event(QEvent * e) +{ + Q_D(Q3MainWindow); +#ifndef QT_NO_STATUSTIP + if (e->type() == QEvent::StatusTip) { + if (d->sb) { + d->sb->showMessage(static_cast<QStatusTipEvent*>(e)->tip()); + return true; + } + } +#endif + if (e->type() == QEvent::ToolBarChange) { + // Keep compatibility with the Qt 3 main window, use the real main window + // or reimplement if you want proper handling. + int deltaH = 0; + Q3DockArea *area = topDock(); + if (area->width() >= area->height()) { + deltaH = area->sizeHint().height(); + if (!area->isVisible()) { + area->show(); + } else { + area->hide(); + deltaH = -deltaH; + } + } + + if (deltaH) { + QApplication::sendPostedEvents(this, QEvent::LayoutRequest); + resize(width(), height() + deltaH); + } + return true; + } + if (e->type() == QEvent::ChildRemoved && ((QChildEvent*)e)->child() == d->mc) { + d->mc->removeEventFilter(this); + d->mc = 0; + d->mwl->setCentralWidget(0); + } + + if (e->type() == QEvent::MenubarUpdated) { + QMenubarUpdatedEvent * const event = static_cast<QMenubarUpdatedEvent *>(e); + if (event->menuBar() && event->menuBar()->parent() == this) { + triggerLayout(); + update(); + } + } + return QWidget::event(e); +} + + +/*! + \property Q3MainWindow::usesBigPixmaps + \brief whether big pixmaps are enabled + + If false (the default), the tool buttons will use small pixmaps; + otherwise big pixmaps will be used. + + Tool buttons and other widgets that wish to respond to this + setting are responsible for reading the correct state on startup, + and for connecting to the main window's widget's + pixmapSizeChanged() signal. +*/ + +bool Q3MainWindow::usesBigPixmaps() const +{ + return d_func()->ubp; +} + +void Q3MainWindow::setUsesBigPixmaps(bool enable) +{ + Q_D(Q3MainWindow); + if (enable == (bool)d->ubp) + return; + + d->ubp = enable; + emit pixmapSizeChanged(enable); + + QObjectList l = queryList("QLayout"); + for (int i = 0; i < l.size(); ++i) + static_cast<QLayout *>(l.at(i))->activate(); +} + +/*! + \property Q3MainWindow::usesTextLabel + \brief whether text labels for toolbar buttons are enabled + + If disabled (the default), the tool buttons will not use text + labels. If enabled, text labels will be used. + + Tool buttons and other widgets that wish to respond to this + setting are responsible for reading the correct state on startup, + and for connecting to the main window's widget's + usesTextLabelChanged() signal. + + \sa QToolButton::setUsesTextLabel() +*/ + +bool Q3MainWindow::usesTextLabel() const +{ + return d_func()->utl; +} + + +void Q3MainWindow::setUsesTextLabel(bool enable) +{ + Q_D(Q3MainWindow); + if (enable == (bool)d->utl) + return; + + d->utl = enable; + emit usesTextLabelChanged(enable); + + QObjectList l = queryList("QLayout"); + for (int i = 0; i < l.size(); ++i) + static_cast<QLayout *>(l.at(i))->activate(); + triggerLayout(false); +} + + +/*! + \fn void Q3MainWindow::pixmapSizeChanged(bool b) + + This signal is emitted whenever the setUsesBigPixmaps() is called + with a value different to the current setting. The new value is + passed in \a b. All widgets that should respond to such changes, + e.g. toolbar buttons, must connect to this signal. +*/ + +/*! + \fn void Q3MainWindow::usesTextLabelChanged(bool b) + + This signal is emitted whenever the setUsesTextLabel() is called + with a value different to the current setting. The new value is + passed in \a b. All widgets that should respond to such changes, + e.g. toolbar buttons, must connect to this signal. +*/ + +/*! + \fn void Q3MainWindow::dockWindowPositionChanged(Q3DockWindow *dockWindow) + + This signal is emitted when the \a dockWindow has changed its + position. A change in position occurs when a dock window is moved + within its dock area or moved to another dock area (including the + \c Minimized and \c TearOff dock areas). + + \sa getLocation() +*/ + +void Q3MainWindow::setRightJustification(bool enable) +{ + Q_D(Q3MainWindow); + if (enable == (bool)d->justify) + return; + d->justify = enable; + triggerLayout(true); +} + + +/*! + \property Q3MainWindow::rightJustification + \brief whether the main window right-justifies its dock windows + + If disabled (the default), stretchable dock windows are expanded, + and non-stretchable dock windows are given the minimum space they + need. Since most dock windows are not stretchable, this usually + results in an unjustified right edge (or unjustified bottom edge + for a vertical dock area). If enabled, the main window will + right-justify its dock windows. + + \sa Q3DockWindow::setVerticalStretchable(), Q3DockWindow::setHorizontalStretchable() +*/ + +bool Q3MainWindow::rightJustification() const +{ + return d_func()->justify; +} + +/*! \internal + */ + +void Q3MainWindow::triggerLayout(bool deleteLayout) +{ + Q_D(Q3MainWindow); + if (deleteLayout || !d->tll) + setUpLayout(); + QApplication::postEvent(this, new QEvent(QEvent::LayoutHint)); +} + +/*! + Enters 'What's This?' mode and returns immediately. + + This is the same as QWhatsThis::enterWhatsThisMode(), but + implemented as a main window object's slot. This way it can easily + be used for popup menus, for example: + + \snippet doc/src/snippets/code/src_qt3support_widgets_q3mainwindow.cpp 4 + + \sa Q3WhatsThis::enterWhatsThisMode() +*/ +void Q3MainWindow::whatsThis() +{ +#ifndef QT_NO_WHATSTHIS + QWhatsThis::enterWhatsThisMode(); +#endif +} + +/*! + Finds the location of the dock window \a dw. + + If the \a dw dock window is found in the main window the function + returns true and populates the \a dock variable with the dw's dock + area and the \a index with the dw's position within the dock area. + It also sets \a nl to true if the \a dw begins a new line + (otherwise false), and \a extraOffset with the dock window's offset. + + If the \a dw dock window is not found then the function returns + false and the state of \a dock, \a index, \a nl and \a extraOffset + is undefined. + + If you want to save and restore dock window positions then use + operator>>() and operator<<(). +*/ + +bool Q3MainWindow::getLocation(Q3DockWindow *dw, Qt::Dock &dock, int &index, bool &nl, int &extraOffset) const +{ + Q_D(const Q3MainWindow); + dock = Qt::DockTornOff; + if (d->topDock->hasDockWindow(dw, &index)) + dock = Qt::DockTop; + else if (d->bottomDock->hasDockWindow(dw, &index)) + dock = Qt::DockBottom; + else if (d->leftDock->hasDockWindow(dw, &index)) + dock = Qt::DockLeft; + else if (d->rightDock->hasDockWindow(dw, &index)) + dock = Qt::DockRight; + else if (dw->parentWidget() == d->hideDock) { + index = 0; + dock = Qt::DockMinimized; + } else { + index = 0; + } + nl = dw->newLine(); + extraOffset = dw->offset(); + return true; +} + +#ifndef QT_NO_TOOLBAR +/*! + Returns a list of all the toolbars which are in the \a dock dock + area, regardless of their state. + + For example, the \c TornOff dock area may contain closed toolbars + but these are returned along with the visible toolbars. + + \sa dockWindows() +*/ + +QList<Q3ToolBar *> Q3MainWindow::toolBars(Qt::Dock dock) const +{ + QList<Q3DockWindow *> lst = dockWindows(dock); + QList<Q3ToolBar *> tbl; + for (int i = 0; i < lst.size(); ++i) { + Q3ToolBar *tb = qobject_cast<Q3ToolBar *>(lst.at(i)); + if (tb) + tbl.append(tb); + } + return tbl; +} +#endif + +/*! + Returns a list of all the dock windows which are in the \a dock + dock area, regardless of their state. + + For example, the Qt::DockTornOff dock area may contain closed dock + windows but these are returned along with the visible dock + windows. +*/ + +QList<Q3DockWindow *> Q3MainWindow::dockWindows(Qt::Dock dock) const +{ + Q_D(const Q3MainWindow); + QList<Q3DockWindow *> lst; + switch (dock) { + case Qt::DockTop: + return d->topDock->dockWindowList(); + case Qt::DockBottom: + return d->bottomDock->dockWindowList(); + case Qt::DockLeft: + return d->leftDock->dockWindowList(); + case Qt::DockRight: + return d->rightDock->dockWindowList(); + case Qt::DockTornOff: { + for (int i = 0; i < d->dockWindows.size(); ++i) { + Q3DockWindow *w = d->dockWindows.at(i); + if (!w->area() && w->place() == Q3DockWindow::OutsideDock) + lst.append(w); + } + } + return lst; + case Qt::DockMinimized: { + QObjectList childList = d->hideDock->children(); + for (int i = 0; i < childList.size(); ++i) { + Q3DockWindow *dw = qobject_cast<Q3DockWindow*>(childList.at(i)); + if (dw) + lst.append(dw); + } + } + return lst; + default: + break; + } + return lst; +} + +/*! + \overload + + Returns the list of dock windows which belong to this main window, + regardless of which dock area they are in or what their state is, + (e.g. irrespective of whether they are visible or not). +*/ + +QList<Q3DockWindow *> Q3MainWindow::dockWindows() const +{ + return d_func()->dockWindows; +} + +void Q3MainWindow::setDockWindowsMovable(bool enable) +{ + Q_D(Q3MainWindow); + d->movable = enable; + QObjectList l = queryList("Q3DockWindow"); + for (int i = 0; i < l.size(); ++i) + static_cast<Q3DockWindow*>(l.at(i))->setMovingEnabled(enable); +} + +/*! + \property Q3MainWindow::dockWindowsMovable + \brief whether the dock windows are movable + + If true (the default), the user will be able to move movable dock + windows from one Q3MainWindow dock area to another, including the + \c TearOff area (i.e. where the dock window floats freely as a + window in its own right), and the \c Minimized area (where only + the dock window's handle is shown below the menu bar). Movable + dock windows can also be moved within Q3MainWindow dock areas, i.e. + to rearrange them within a dock area. + + If false the user will not be able to move any dock windows. + + By default dock windows are moved transparently (i.e. only an + outline rectangle is shown during the drag), but this setting can + be changed with setOpaqueMoving(). + + \sa setDockEnabled(), setOpaqueMoving() +*/ + +bool Q3MainWindow::dockWindowsMovable() const +{ + return d_func()->movable; +} + +void Q3MainWindow::setOpaqueMoving(bool b) +{ + Q_D(Q3MainWindow); + d->opaque = b; + QObjectList l = queryList("Q3DockWindow"); + for (int i = 0; i < l.size(); ++i) + static_cast<Q3DockWindow*>(l.at(i))->setOpaqueMoving(b); +} + +/*! + \property Q3MainWindow::opaqueMoving + \brief whether dock windows are moved opaquely + + If true the dock windows of the main window are shown opaquely + (i.e. it shows the toolbar as it looks when docked) whilst it is + being moved. If false (the default) they are shown transparently, + (i.e. as an outline rectangle). + + \warning Opaque moving of toolbars and dockwindows is known to + have several problems. We recommend avoiding the use of this + feature for the time being. We intend fixing the problems in a + future release. +*/ + +bool Q3MainWindow::opaqueMoving() const +{ + return d_func()->opaque; +} + +/*! + This function will line up dock windows within the visible dock + areas (\c Top, \c Left, \c Right and \c Bottom) as compactly as + possible. + + If \a keepNewLines is true, all dock windows stay on their + original lines. If \a keepNewLines is false then newlines may be + removed to achieve the most compact layout possible. + + The method only works if dockWindowsMovable() returns true. +*/ + +void Q3MainWindow::lineUpDockWindows(bool keepNewLines) +{ + Q_D(const Q3MainWindow); + if (!dockWindowsMovable()) + return; + d->topDock->lineUp(keepNewLines); + d->leftDock->lineUp(keepNewLines); + d->rightDock->lineUp(keepNewLines); + d->bottomDock->lineUp(keepNewLines); +} + +/*! + Returns true, if the dock window menu is enabled; otherwise + returns false. + + The menu lists the (appropriate()) dock windows (which may be + shown or hidden), and has a "Line Up Dock Windows" menu item. It + will also have a "Customize" menu item if isCustomizable() returns + true. + + \sa setDockEnabled(), lineUpDockWindows() appropriate() + setAppropriate() +*/ + +bool Q3MainWindow::isDockMenuEnabled() const +{ + return d_func()->dockMenu; +} + +/*! + If \a b is true, then right clicking on a dock window or dock area + will pop up the dock window menu. If \a b is false, right clicking + a dock window or dock area will not pop up the menu. + + The menu lists the (appropriate()) dock windows (which may be + shown or hidden), and has a "Line Up Dock Windows" item. It will + also have a "Customize" menu item if isCustomizable() returns + true. + + \sa lineUpDockWindows(), isDockMenuEnabled() +*/ + +void Q3MainWindow::setDockMenuEnabled(bool b) +{ + d_func()->dockMenu = b; +} + +/*! + Creates the dock window menu which contains all toolbars (if \a + dockWindows is \c OnlyToolBars), all dock windows (if \a + dockWindows is \c NoToolBars) or all toolbars and dock windows (if + \a dockWindows is \c AllDockWindows - the default). + + This function is called internally when necessary, e.g. when the + user right clicks a dock area (providing isDockMenuEnabled() + returns true). You can reimplement this function if you wish to + customize the behavior. + + The menu items representing the toolbars and dock windows are + checkable. The visible dock windows are checked and the hidden + dock windows are unchecked. The user can click a menu item to + change its state (show or hide the dock window). + + The list and the state are always kept up-to-date. + + Toolbars and dock windows which are not appropriate in the current + context (see setAppropriate()) are not listed in the menu. + + The menu also has a menu item for lining up the dock windows. + + If isCustomizable() returns true, a Customize menu item is added + to the menu, which if clicked will call customize(). The + isCustomizable() function we provide returns false and customize() + does nothing, so they must be reimplemented in a subclass to be + useful. +*/ + +Q3PopupMenu *Q3MainWindow::createDockWindowMenu(DockWindows dockWindows) const +{ + Q_D(const Q3MainWindow); + QObjectList l = queryList("Q3DockWindow"); + if (l.isEmpty()) + return 0; + + Q3PopupMenu *menu = new Q3PopupMenu((Q3MainWindow*)this); + menu->setObjectName(QLatin1String("qt_customize_menu")); + d->dockWindowModes.replace( menu, dockWindows ); + menu->setCheckable(true); + connect( menu, SIGNAL(aboutToShow()), this, SLOT(menuAboutToShow()) ); + return menu; +} + +/*! + This slot is called from the aboutToShow() signal of the default + dock menu of the mainwindow. The default implementation + initializes the menu with all dock windows and toolbars in this + slot. +*/ + +void Q3MainWindow::menuAboutToShow() +{ + Q_D(Q3MainWindow); + Q3PopupMenu *menu = (Q3PopupMenu*)sender(); + menu->clear(); + + DockWindows dockWindows; + { + QMap<Q3PopupMenu*, DockWindows>::Iterator it = d->dockWindowModes.find( menu ); + if ( it == d->dockWindowModes.end() ) + return; + dockWindows = (*it); + } + + QObjectList l = queryList("Q3DockWindow"); + bool empty = true; + if (!l.isEmpty()) { + if (dockWindows == AllDockWindows || dockWindows == NoToolBars) { + for (int i = 0; i < l.size(); ++i) { + Q3DockWindow *dw = (Q3DockWindow*)l.at(i); + if (!appropriate(dw) || qobject_cast<Q3ToolBar*>(dw) || !dockMainWindow(dw)) + continue; + QString label = dw->windowTitle(); + if (!label.isEmpty()) { + QAction *act = menu->addAction(label); + act->setCheckable(true); + act->setChecked(dw->isVisible()); + QObject::connect(act, SIGNAL(triggered()), dw, SLOT(toggleVisible())); + empty = false; + } + } + } + if (!empty) { + menu->addSeparator(); + empty = true; + } +#ifndef QT_NO_TOOLBAR + if (dockWindows == AllDockWindows || dockWindows == OnlyToolBars) { + for (int i = 0; i < l.size(); ++i) { + Q3ToolBar *tb = qobject_cast<Q3ToolBar*>(l.at(i)); + if (!tb || !appropriate(tb) || !dockMainWindow(tb)) + continue; + QString label = tb->label(); + if (!label.isEmpty()) { + QAction *act = menu->addAction(label); + act->setCheckable(true); + act->setChecked(tb->isVisible()); + QObject::connect(act, SIGNAL(triggered()), tb, SLOT(toggleVisible())); + empty = false; + } + } + } +#endif + } + if (!empty) { + menu->addSeparator(); + empty = true; + } + + if (dockWindowsMovable()) + menu->addAction(tr("Line up"), this, SLOT(doLineUp())); + if (isCustomizable()) + menu->addAction(tr("Customize..."), this, SLOT(customize())); +} + + +/*! + Shows the dock menu at the position \a globalPos. The menu lists + the dock windows so that they can be shown (or hidden), lined up, + and possibly customized. Returns true if the menu is shown; + otherwise returns false. + + If you want a custom menu, reimplement this function. You can + create the menu from scratch or call createDockWindowMenu() and + modify the result. + + The default implementation uses the dock window menu which gets + created by createDockWindowMenu(). You can reimplement + createDockWindowMenu() if you want to use your own specialized + popup menu. +*/ + +bool Q3MainWindow::showDockMenu(const QPoint &globalPos) +{ + Q_D(Q3MainWindow); + if (!d->dockMenu) + return false; + + if(Q3PopupMenu *ret = createDockWindowMenu()) { + ret->exec(globalPos); + delete ret; + return true; + } + return false; +} + +void Q3MainWindow::slotPlaceChanged() +{ + QObject* obj = (QObject*)sender(); + Q3DockWindow *dw = qobject_cast<Q3DockWindow*>(obj); + if (dw) + emit dockWindowPositionChanged(dw); +#ifndef QT_NO_TOOLBAR + Q3ToolBar *tb = qobject_cast<Q3ToolBar*>(obj); + if (tb) + emit toolBarPositionChanged(tb); +#endif +} + +/*! + \internal + For internal use of Q3DockWindow only. + */ + +Q3DockArea *Q3MainWindow::dockingArea(const QPoint &p) +{ + Q_D(Q3MainWindow); + int mh = d->mb ? d->mb->height() : 0; + int sh = d->sb ? d->sb->height() : 0; + if (p.x() >= -5 && p.x() <= 100 && p.y() > mh && p.y() - height() - sh) + return d->leftDock; + if (p.x() >= width() - 100 && p.x() <= width() + 5 && p.y() > mh && p.y() - height() - sh) + return d->rightDock; + if (p.y() >= -5 && p.y() < mh + 100 && p.x() >= 0 && p.x() <= width()) + return d->topDock; + if (p.y() >= height() - sh - 100 && p.y() <= height() + 5 && p.x() >= 0 && p.x() <= width()) + return d->bottomDock; + return 0; +} + +/*! + Returns true if \a dw is a dock window known to the main window; + otherwise returns false. +*/ + +bool Q3MainWindow::hasDockWindow(Q3DockWindow *dw) +{ + return d_func()->dockWindows.contains(dw); +} + +/*! + Returns the \c Left dock area + + \sa rightDock() topDock() bottomDock() +*/ + +Q3DockArea *Q3MainWindow::leftDock() const +{ + return d_func()->leftDock; +} + +/*! + Returns the \c Right dock area + + \sa leftDock() topDock() bottomDock() +*/ + +Q3DockArea *Q3MainWindow::rightDock() const +{ + return d_func()->rightDock; +} + +/*! + Returns the \c Top dock area + + \sa bottomDock() leftDock() rightDock() +*/ + +Q3DockArea *Q3MainWindow::topDock() const +{ + return d_func()->topDock; +} + +/*! + Returns a pointer the \c Bottom dock area + + \sa topDock() leftDock() rightDock() +*/ + +Q3DockArea *Q3MainWindow::bottomDock() const +{ + return d_func()->bottomDock; +} + +/*! + This function is called when the user clicks the Customize menu + item on the dock window menu. + + The customize menu item will only appear if isCustomizable() + returns true (it returns false by default). + + The function is intended, for example, to provide the user with a + means of telling the application that they wish to customize the + main window, dock windows or dock areas. + + The default implementation does nothing and the Customize menu + item is not shown on the right-click menu by default. If you want + the item to appear then reimplement isCustomizable() to return + true, and reimplement this function to do whatever you want. + + \sa isCustomizable() +*/ + +void Q3MainWindow::customize() +{ +} + +/*! + Returns true if the dock area dock window menu includes the + Customize menu item (which calls customize() when clicked). + Returns false by default, i.e. the popup menu will not contain a + Customize menu item. You will need to reimplement this function + and set it to return true if you wish the user to be able to see + the dock window menu. + + \sa customize() +*/ + +bool Q3MainWindow::isCustomizable() const +{ + return false; +} + +/*! + Returns true if it is appropriate to include a menu item for the + \a dw dock window in the dock window menu; otherwise returns + false. + + The user is able to change the state (show or hide) a dock window + that has a menu item by clicking the item. + + Call setAppropriate() to indicate whether or not a particular dock + window should appear on the popup menu. + + \sa setAppropriate() +*/ + +bool Q3MainWindow::appropriate(Q3DockWindow *dw) const +{ + Q_D(const Q3MainWindow); + QMap<Q3DockWindow*, bool>::ConstIterator it = d->appropriate.find(dw); + if (it == d->appropriate.end()) + return true; + return *it; +} + +/*! + Use this function to control whether or not the \a dw dock + window's caption should appear as a menu item on the dock window + menu that lists the dock windows. + + If \a a is true then the \a dw will appear as a menu item on the + dock window menu. The user is able to change the state (show or + hide) a dock window that has a menu item by clicking the item; + depending on the state of your application, this may or may not be + appropriate. If \a a is false the \a dw will not appear on the + popup menu. + + \sa showDockMenu() isCustomizable() customize() +*/ + +void Q3MainWindow::setAppropriate(Q3DockWindow *dw, bool a) +{ + d_func()->appropriate.insert(dw, a); +} + +#ifndef QT_NO_TEXTSTREAM +static void saveDockArea(QTextStream &ts, Q3DockArea *a) +{ + QList<Q3DockWindow *> l = a->dockWindowList(); + for (int i = 0; i < l.size(); ++i) { + Q3DockWindow *dw = l.at(i); + ts << QString(dw->windowTitle()); + ts << ','; + } + ts << endl; + ts << *a; +} + +/*! + \relates Q3MainWindow + + Writes the layout (sizes and positions) of the dock windows in the + dock areas of the Q3MainWindow \a mainWindow, including \c + Minimized and \c TornOff dock windows, to the text stream \a ts. + + This can be used, for example, in conjunction with QSettings to + save the user's layout when the \a mainWindow receives a + close event. + + \sa QWidget::closeEvent() +*/ + +QTextStream &operator<<(QTextStream &ts, const Q3MainWindow &mainWindow) +{ + QList<Q3DockWindow *> l = mainWindow.dockWindows(Qt::DockMinimized); + for (int i = 0; i < l.size(); ++i) { + Q3DockWindow *dw = l.at(i); + ts << dw->windowTitle(); + ts << ','; + } + ts << endl; + + l = mainWindow.dockWindows(Qt::DockTornOff); + for (int i = 0; i < l.size(); ++i) { + Q3DockWindow *dw = l.at(i); + ts << dw->windowTitle(); + ts << ','; + } + ts << endl; + for (int i = 0; i < l.size(); ++i) { + Q3DockWindow *dw = l.at(i); + ts << '[' << dw->windowTitle() << ',' + << (int)dw->geometry().x() << ',' + << (int)dw->geometry().y() << ',' + << (int)dw->geometry().width() << ',' + << (int)dw->geometry().height() << ',' + << (int)dw->isVisible() << ']'; + } + ts << endl; + + saveDockArea(ts, mainWindow.topDock()); + saveDockArea(ts, mainWindow.bottomDock()); + saveDockArea(ts, mainWindow.rightDock()); + saveDockArea(ts, mainWindow.leftDock()); + return ts; +} + +static void loadDockArea(const QStringList &names, Q3DockArea *a, Qt::Dock dl, QList<Q3DockWindow *> &l, Q3MainWindow *mw, QTextStream &ts) +{ + for (QStringList::ConstIterator it = names.begin(); it != names.end(); ++it) { + for (int i = 0; i < l.size(); ++i) { + Q3DockWindow *dw = l.at(i); + if (dw->windowTitle() == *it) { + mw->addDockWindow(dw, dl); + break; + } + } + } + if (a) { + ts >> *a; + } else if (dl == Qt::DockTornOff) { + QString s = ts.readLine(); + enum State { Pre, Name, X, Y, Width, Height, Visible, Post }; + int state = Pre; + QString name, x, y, w, h, visible; + QChar c; + for (int i = 0; i < (int)s.length(); ++i) { + c = s[i]; + if (state == Pre && c == QLatin1Char('[')) { + state++; + continue; + } + if (c == QLatin1Char(',') && + (state == Name || state == X || state == Y || state == Width || state == Height)) { + state++; + continue; + } + if (state == Visible && c == QLatin1Char(']')) { + for (int i = 0; i < l.size(); ++i) { + Q3DockWindow *dw = l.at(i); + if (QString(dw->windowTitle()) == name) { + if (!qobject_cast<Q3ToolBar*>(dw)) + dw->setGeometry(x.toInt(), y.toInt(), w.toInt(), h.toInt()); + else + dw->setGeometry(x.toInt(), y.toInt(), dw->width(), dw->height()); + if (!(bool)visible.toInt()) + dw->hide(); + else + dw->show(); + break; + } + } + + name = x = y = w = h = visible = QLatin1String(""); + + state = Pre; + continue; + } + if (state == Name) + name += c; + else if (state == X) + x += c; + else if (state == Y) + y += c; + else if (state == Width) + w += c; + else if (state == Height) + h += c; + else if (state == Visible) + visible += c; + } + } +} + +/*! + \relates Q3MainWindow + + Reads the layout (sizes and positions) of the dock windows in the + dock areas of the Q3MainWindow \a mainWindow from the text stream, + \a ts, including \c Minimized and \c TornOff dock windows. + Restores the dock windows and dock areas to these sizes and + positions. The layout information must be in the format produced + by operator<<(). + + This can be used, for example, in conjunction with QSettings to + restore the user's layout. +*/ + +QTextStream &operator>>(QTextStream &ts, Q3MainWindow &mainWindow) +{ + QList<Q3DockWindow *> l = mainWindow.dockWindows(); + + QString s = ts.readLine(); + QStringList names = s.split(QLatin1Char(',')); + loadDockArea(names, 0, Qt::DockMinimized, l, &mainWindow, ts); + + s = ts.readLine(); + names = s.split(QLatin1Char(',')); + loadDockArea(names, 0, Qt::DockTornOff, l, &mainWindow, ts); + + int i = 0; + Q3DockArea *areas[] = { mainWindow.topDock(), mainWindow.bottomDock(), mainWindow.rightDock(), mainWindow.leftDock() }; + for (int dl = (int)Qt::DockTop; dl != (int)Qt::DockMinimized; ++dl, ++i) { + s = ts.readLine(); + names = s.split(QLatin1Char(',')); + loadDockArea(names, areas[i], (Qt::Dock)dl, l, &mainWindow, ts); + } + return ts; +} +#endif + +QT_END_NAMESPACE + +#include "q3mainwindow.moc" + +#endif diff --git a/src/qt3support/widgets/q3mainwindow.h b/src/qt3support/widgets/q3mainwindow.h new file mode 100644 index 0000000..300be76 --- /dev/null +++ b/src/qt3support/widgets/q3mainwindow.h @@ -0,0 +1,267 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the Qt3Support module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, 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 qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef Q3MAINWINDOW_H +#define Q3MAINWINDOW_H + +#include <QtGui/qwidget.h> +#include <Qt3Support/q3toolbar.h> +#include <QtCore/qtextstream.h> + +QT_BEGIN_HEADER + +QT_BEGIN_NAMESPACE + +QT_MODULE(Qt3SupportLight) + +#ifndef QT_NO_MAINWINDOW + +class QMenuBar; +class QStatusBar; +class QToolTipGroup; +class Q3MainWindowPrivate; +class Q3MainWindowLayout; +class Q3PopupMenu; +class QHideDock; +template<class T> class QList; + +class Q_COMPAT_EXPORT Q3MainWindow: public QWidget +{ + Q_OBJECT + Q_DECLARE_PRIVATE(Q3MainWindow) + + Q_PROPERTY(bool rightJustification READ rightJustification WRITE setRightJustification DESIGNABLE false) + Q_PROPERTY(bool usesBigPixmaps READ usesBigPixmaps WRITE setUsesBigPixmaps) + Q_PROPERTY(bool usesTextLabel READ usesTextLabel WRITE setUsesTextLabel) + Q_PROPERTY(bool dockWindowsMovable READ dockWindowsMovable WRITE setDockWindowsMovable) + Q_PROPERTY(bool opaqueMoving READ opaqueMoving WRITE setOpaqueMoving) + +public: + Q3MainWindow(QWidget* parent=0, const char* name=0, Qt::WindowFlags f = Qt::WType_TopLevel); + ~Q3MainWindow(); + +#ifndef QT_NO_MENUBAR + QMenuBar * menuBar() const; +#endif + QStatusBar * statusBar() const; +#if 0 + QToolTipGroup * toolTipGroup() const; +#endif + + virtual void setCentralWidget(QWidget *); + QWidget * centralWidget() const; + + virtual void setDockEnabled(Qt::Dock dock, bool enable); + bool isDockEnabled(Qt::Dock dock) const; + bool isDockEnabled(Q3DockArea *area) const; + virtual void setDockEnabled(Q3DockWindow *tb, Qt::Dock dock, bool enable); + bool isDockEnabled(Q3DockWindow *tb, Qt::Dock dock) const; + bool isDockEnabled(Q3DockWindow *tb, Q3DockArea *area) const; + + virtual void addDockWindow(Q3DockWindow *, Qt::Dock = Qt::DockTop, bool newLine = false); + virtual void addDockWindow(Q3DockWindow *, const QString &label, + Qt::Dock = Qt::DockTop, bool newLine = false); + virtual void moveDockWindow(Q3DockWindow *, Qt::Dock = Qt::DockTop); + virtual void moveDockWindow(Q3DockWindow *, Qt::Dock, bool nl, int index, int extraOffset = -1); + virtual void removeDockWindow(Q3DockWindow *); + + void setVisible(bool); + QSize sizeHint() const; + QSize minimumSizeHint() const; + + bool rightJustification() const; + bool usesBigPixmaps() const; + bool usesTextLabel() const; + bool dockWindowsMovable() const; + bool opaqueMoving() const; + + bool eventFilter(QObject*, QEvent*); + + bool getLocation(Q3DockWindow *tb, Qt::Dock &dock, int &index, bool &nl, int &extraOffset) const; + + QList<Q3DockWindow *> dockWindows(Qt::Dock dock) const; + QList<Q3DockWindow *> dockWindows() const; + void lineUpDockWindows(bool keepNewLines = false); + + bool isDockMenuEnabled() const; + + // compatibility stuff + bool hasDockWindow(Q3DockWindow *dw); +#ifndef QT_NO_TOOLBAR + void addToolBar(Q3DockWindow *, Qt::Dock = Qt::DockTop, bool newLine = false); + void addToolBar(Q3DockWindow *, const QString &label, + Qt::Dock = Qt::DockTop, bool newLine = false); + void moveToolBar(Q3DockWindow *, Qt::Dock = Qt::DockTop); + void moveToolBar(Q3DockWindow *, Qt::Dock, bool nl, int index, int extraOffset = -1); + void removeToolBar(Q3DockWindow *); + + bool toolBarsMovable() const; + QList<Q3ToolBar *> toolBars(Qt::Dock dock) const; + void lineUpToolBars(bool keepNewLines = false); +#endif + + virtual Q3DockArea *dockingArea(const QPoint &p); + Q3DockArea *leftDock() const; + Q3DockArea *rightDock() const; + Q3DockArea *topDock() const; + Q3DockArea *bottomDock() const; + + virtual bool isCustomizable() const; + + bool appropriate(Q3DockWindow *dw) const; + + enum DockWindows { OnlyToolBars, NoToolBars, AllDockWindows }; + virtual Q3PopupMenu *createDockWindowMenu(DockWindows dockWindows = AllDockWindows) const; + +public Q_SLOTS: + virtual void setRightJustification(bool); + virtual void setUsesBigPixmaps(bool); + virtual void setUsesTextLabel(bool); + virtual void setDockWindowsMovable(bool); + virtual void setOpaqueMoving(bool); + virtual void setDockMenuEnabled(bool); + virtual void whatsThis(); + virtual void setAppropriate(Q3DockWindow *dw, bool a); + virtual void customize(); + + // compatibility stuff + void setToolBarsMovable(bool); + +Q_SIGNALS: + void pixmapSizeChanged(bool); + void usesTextLabelChanged(bool); + void dockWindowPositionChanged(Q3DockWindow *); + +#ifndef QT_NO_TOOLBAR + // compatibility stuff + void toolBarPositionChanged(Q3ToolBar *); +#endif + +protected Q_SLOTS: + virtual void setUpLayout(); + virtual bool showDockMenu(const QPoint &globalPos); + void menuAboutToShow(); + +protected: + void paintEvent(QPaintEvent *); + void childEvent(QChildEvent *); + bool event(QEvent *); + +private Q_SLOTS: + void slotPlaceChanged(); + void doLineUp() { lineUpDockWindows(true); } + +private: + Q_DISABLE_COPY(Q3MainWindow) + + void triggerLayout(bool deleteLayout = true); + bool dockMainWindow(QObject *dock) const; + +#ifndef QT_NO_MENUBAR + virtual void setMenuBar(QMenuBar *); +#endif + virtual void setStatusBar(QStatusBar *); +#if 0 + virtual void setToolTipGroup(QToolTipGroup *); +#endif + + friend class Q3DockWindow; + friend class QMenuBarPrivate; + friend class QHideDock; + friend class Q3ToolBar; + friend class Q3MainWindowLayout; +}; + +#ifndef QT_NO_TOOLBAR +inline void Q3MainWindow::addToolBar(Q3DockWindow *w, Qt::ToolBarDock dock, bool newLine) +{ + addDockWindow(w, dock, newLine); +} + +inline void Q3MainWindow::addToolBar(Q3DockWindow *w, const QString &label, + Qt::ToolBarDock dock, bool newLine) +{ + addDockWindow(w, label, dock, newLine); +} + +inline void Q3MainWindow::moveToolBar(Q3DockWindow *w, Qt::ToolBarDock dock) +{ + moveDockWindow(w, dock); +} + +inline void Q3MainWindow::moveToolBar(Q3DockWindow *w, Qt::ToolBarDock dock, bool nl, int index, int extraOffset) +{ + moveDockWindow(w, dock, nl, index, extraOffset); +} + +inline void Q3MainWindow::removeToolBar(Q3DockWindow *w) +{ + removeDockWindow(w); +} + +inline bool Q3MainWindow::toolBarsMovable() const +{ + return dockWindowsMovable(); +} + +inline void Q3MainWindow::lineUpToolBars(bool keepNewLines) +{ + lineUpDockWindows(keepNewLines); +} + +inline void Q3MainWindow::setToolBarsMovable(bool b) +{ + setDockWindowsMovable(b); +} +#endif + +#ifndef QT_NO_TEXTSTREAM +Q_COMPAT_EXPORT QTextStream &operator<<(QTextStream &, const Q3MainWindow &); +Q_COMPAT_EXPORT QTextStream &operator>>(QTextStream &, Q3MainWindow &); +#endif + +#endif // QT_NO_MAINWINDOW + +QT_END_NAMESPACE + +QT_END_HEADER + +#endif // Q3MAINWINDOW_H diff --git a/src/qt3support/widgets/q3mainwindow_p.h b/src/qt3support/widgets/q3mainwindow_p.h new file mode 100644 index 0000000..d17a1ba --- /dev/null +++ b/src/qt3support/widgets/q3mainwindow_p.h @@ -0,0 +1,116 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the Qt3Support module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, 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 qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef Q3MAINWINDOW_P_H +#define Q3MAINWINDOW_P_H + +// +// W A R N I N G +// ------------- +// +// This file is not part of the Qt API. It exists purely as an +// implementation detail. This header file may change from version to +// version without notice, or even be removed. +// +// We mean it. +// + +#include <private/qwidget_p.h> + +QT_BEGIN_NAMESPACE + +class Q3MainWindowLayout; + +class Q3MainWindowPrivate : public QWidgetPrivate +{ + Q_DECLARE_PUBLIC(Q3MainWindow) +public: + Q3MainWindowPrivate() + : mb(0), sb(0), ttg(0), mc(0), tll(0), mwl(0), ubp(false), utl(false), + justify(false), movable(true), opaque(false), dockMenu(true) + { + docks.insert(Qt::DockTop, true); + docks.insert(Qt::DockBottom, true); + docks.insert(Qt::DockLeft, true); + docks.insert(Qt::DockRight, true); + docks.insert(Qt::DockMinimized, false); + docks.insert(Qt::DockTornOff, true); + } + + ~Q3MainWindowPrivate() + { + } + +#ifndef QT_NO_MENUBAR + mutable QMenuBar * mb; +#else + mutable QWidget * mb; +#endif + QStatusBar * sb; + QToolTipGroup * ttg; + + QWidget * mc; + + QBoxLayout * tll; + Q3MainWindowLayout * mwl; + + uint ubp :1; + uint utl :1; + uint justify :1; + uint movable :1; + uint opaque :1; + uint dockMenu :1; + + Q3DockArea *topDock, *bottomDock, *leftDock, *rightDock; + + QList<Q3DockWindow *> dockWindows; + QMap<Qt::Dock, bool> docks; + QStringList disabledDocks; + QHideDock *hideDock; + + QPointer<Q3PopupMenu> rmbMenu, tbMenu, dwMenu; + QMap<Q3DockWindow*, bool> appropriate; + mutable QMap<Q3PopupMenu*, Q3MainWindow::DockWindows> dockWindowModes; +}; + +QT_END_NAMESPACE + +#endif // Q3MAINWINDOW_P_H diff --git a/src/qt3support/widgets/q3popupmenu.cpp b/src/qt3support/widgets/q3popupmenu.cpp new file mode 100644 index 0000000..78b400a --- /dev/null +++ b/src/qt3support/widgets/q3popupmenu.cpp @@ -0,0 +1,190 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the Qt3Support module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, 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 qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ +#include "q3popupmenu.h" + +QT_BEGIN_NAMESPACE + +/*! + \class Q3PopupMenu + \brief The Q3PopupMenu class is a thin compatibility wrapper around QMenu. + \compat + + Use QMenu in new applications. Note that the menu's actions must + be \l {Q3Action}s. +*/ + +/*! + \fn Q3PopupMenu::Q3PopupMenu(QWidget *parent, const char *name) + + Constructs a menu with the given \a parent and \a name. +*/ + +/*! + \fn int Q3PopupMenu::exec() + + Pops up the menu and returns the ID of the action that was + selected. + + \sa QMenu::exec() +*/ + +/*! + \fn int Q3PopupMenu::exec(const QPoint & pos, int indexAtPoint) + + Pops up the menu at coordinate \a pos and returns the ID of the + action that was selected. + + If \a indexAtPoint is specified, the menu will pop up with the + item at index \a indexAtPoint under the mouse cursor. + + \sa QMenu::exec() +*/ + + +/*! + \fn void Q3PopupMenu::setFrameRect(QRect) + \internal +*/ + +/*! + \fn QRect Q3PopupMenu::frameRect() const + \internal +*/ +/*! + \enum Q3PopupMenu::DummyFrame + \internal + + \value Box + \value Sunken + \value Plain + \value Raised + \value MShadow + \value NoFrame + \value Panel + \value StyledPanel + \value HLine + \value VLine + \value GroupBoxPanel + \value WinPanel + \value ToolBarPanel + \value MenuBarPanel + \value PopupPanel + \value LineEditPanel + \value TabWidgetPanel + \value MShape +*/ + +/*! + \fn void Q3PopupMenu::setFrameShadow(DummyFrame) + \internal +*/ + +/*! + \fn DummyFrame Q3PopupMenu::frameShadow() const + \internal +*/ + +/*! + \fn void Q3PopupMenu::setFrameShape(DummyFrame) + \internal +*/ + +/*! + \fn DummyFrame Q3PopupMenu::frameShape() const + \internal +*/ + +/*! + \fn void Q3PopupMenu::setFrameStyle(int) + \internal +*/ + +/*! + \fn int Q3PopupMenu::frameStyle() const + \internal +*/ + +/*! + \fn int Q3PopupMenu::frameWidth() const + \internal +*/ + +/*! + \fn void Q3PopupMenu::setLineWidth(int) + \internal +*/ + +/*! + \fn int Q3PopupMenu::lineWidth() const + \internal +*/ + +/*! + \fn void Q3PopupMenu::setMargin(int margin) + \since 4.2 + + Sets the width of the margin around the contents of the widget to \a margin. + + This function uses QWidget::setContentsMargins() to set the margin. + \sa margin(), QWidget::setContentsMargins() +*/ + +/*! + \fn int Q3PopupMenu::margin() const + \since 4.2 + + Returns the width of the margin around the contents of the widget. + + This function uses QWidget::getContentsMargins() to get the margin. + \sa setMargin(), QWidget::getContentsMargins() +*/ + +/*! + \fn void Q3PopupMenu::setMidLineWidth(int) + \internal +*/ + +/*! + \fn int Q3PopupMenu::midLineWidth() const + \internal +*/ + +QT_END_NAMESPACE diff --git a/src/qt3support/widgets/q3popupmenu.h b/src/qt3support/widgets/q3popupmenu.h new file mode 100644 index 0000000..4238692 --- /dev/null +++ b/src/qt3support/widgets/q3popupmenu.h @@ -0,0 +1,93 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the Qt3Support module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, 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 qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef Q3POPUPMENU_H +#define Q3POPUPMENU_H + +#include <QtGui/qmenu.h> + +QT_BEGIN_HEADER + +QT_BEGIN_NAMESPACE + +QT_MODULE(Qt3SupportLight) + +class Q_COMPAT_EXPORT Q3PopupMenu : public QMenu +{ + Q_OBJECT +public: + inline Q3PopupMenu(QWidget *parent = 0, const char *name = 0) : QMenu(parent) + { setObjectName(QLatin1String(name)); } + + inline int exec() { return findIdForAction(QMenu::exec()); } + inline int exec(const QPoint & pos, int indexAtPoint = 0) { + return findIdForAction(QMenu::exec(pos, actions().value(indexAtPoint))); + } + + void setFrameRect(QRect) {} + QRect frameRect() const { return QRect(); } + enum DummyFrame { Box, Sunken, Plain, Raised, MShadow, NoFrame, Panel, StyledPanel, + HLine, VLine, GroupBoxPanel, WinPanel, ToolBarPanel, MenuBarPanel, + PopupPanel, LineEditPanel, TabWidgetPanel, MShape }; + void setFrameShadow(DummyFrame) {} + DummyFrame frameShadow() const { return Plain; } + void setFrameShape(DummyFrame) {} + DummyFrame frameShape() const { return NoFrame; } + void setFrameStyle(int) {} + int frameStyle() const { return 0; } + int frameWidth() const { return 0; } + void setLineWidth(int) {} + int lineWidth() const { return 0; } + void setMargin(int margin) { setContentsMargins(margin, margin, margin, margin); } + int margin() const + { int margin; int dummy; getContentsMargins(&margin, &dummy, &dummy, &dummy); return margin; } + void setMidLineWidth(int) {} + int midLineWidth() const { return 0; } + +private: + Q_DISABLE_COPY(Q3PopupMenu) +}; + +QT_END_NAMESPACE + +QT_END_HEADER + +#endif // QPOPUPMENU_H diff --git a/src/qt3support/widgets/q3progressbar.cpp b/src/qt3support/widgets/q3progressbar.cpp new file mode 100644 index 0000000..dc3ccb9 --- /dev/null +++ b/src/qt3support/widgets/q3progressbar.cpp @@ -0,0 +1,464 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the Qt3Support module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, 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 qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "q3progressbar.h" +#ifndef QT_NO_PROGRESSBAR +#include "qpainter.h" +#include "qdrawutil.h" +#include "qpixmap.h" +#include "qstyle.h" +#include "qstyleoption.h" +#ifndef QT_NO_ACCESSIBILITY +#include "qaccessible.h" +#endif +#include "qevent.h" +#include <limits.h> + +QT_BEGIN_NAMESPACE + +/*! + \class Q3ProgressBar + \brief The Q3ProgressBar widget provides a horizontal progress bar. + + \compat + + A progress bar is used to give the user an indication of the + progress of an operation and to reassure them that the application + is still running. + + The progress bar uses the concept of \e steps; you give it the + total number of steps and the number of steps completed so far and + it will display the percentage of steps that have been completed. + You can specify the total number of steps in the constructor or + later with setTotalSteps(). The current number of steps is set + with setProgress(). The progress bar can be rewound to the + beginning with reset(). + + If the total is given as 0 the progress bar shows a busy indicator + instead of a percentage of steps. This is useful, for example, + when using QFtp or QHttp to download items when they are unable to + determine the size of the item being downloaded. + + \sa QProgressDialog + + \inlineimage qprogbar-m.png Screenshot in Motif style + \inlineimage qprogbar-w.png Screenshot in Windows style + + \sa QProgressDialog +*/ + + +/*! \obsolete + Constructs a progress bar. + + The total number of steps is set to 100 by default. + + The \a parent, \a name and widget flags, \a f, are passed on to + the QFrame::QFrame() constructor. + + \sa setTotalSteps() +*/ + +Q3ProgressBar::Q3ProgressBar(QWidget *parent, const char *name, Qt::WindowFlags f) + : QFrame(parent, f), + total_steps(100), + progress_val(-1), + percentage(-1), + center_indicator(true), + percentage_visible(true), + d(0) +{ + setObjectName(QLatin1String(name)); + setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed); + initFrame(); +} + + +/*! \obsolete + Constructs a progress bar. + + The \a totalSteps is the total number of steps that need to be + completed for the operation which this progress bar represents. + For example, if the operation is to examine 50 files, this value + would be 50. Before examining the first file, call setProgress(0); + call setProgress(50) after examining the last file. + + The \a parent, \a name and widget flags, \a f, are passed to the + QFrame::QFrame() constructor. + + \sa setTotalSteps(), setProgress() +*/ + +Q3ProgressBar::Q3ProgressBar(int totalSteps, QWidget *parent, const char *name, Qt::WindowFlags f) + : QFrame(parent, f), + total_steps(totalSteps), + progress_val(-1), + percentage(-1), + center_indicator(true), + percentage_visible(true), + d(0) +{ + setObjectName(QLatin1String(name)); + setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed); + initFrame(); +} +#endif + +/*! + Constructs a progress bar. + + The total number of steps is set to 100 by default. + + The \a parent, and widget flags, \a f, are passed on to + the QFrame::QFrame() constructor. + + \sa setTotalSteps() +*/ + +Q3ProgressBar::Q3ProgressBar(QWidget *parent, Qt::WindowFlags f) + : QFrame(parent, f), + total_steps(100), + progress_val(-1), + percentage(-1), + center_indicator(true), + percentage_visible(true), + d(0) +{ + setSizePolicy(QSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed)); + initFrame(); +} + + +/*! + Constructs a progress bar. + + The \a totalSteps is the total number of steps that need to be + completed for the operation which this progress bar represents. + For example, if the operation is to examine 50 files, this value + would be 50. Before examining the first file, call setProgress(0); + call setProgress(50) after examining the last file. + + The \a parent, and widget flags, \a f, are passed to the + QFrame::QFrame() constructor. + + \sa setTotalSteps(), setProgress() +*/ + +Q3ProgressBar::Q3ProgressBar(int totalSteps, QWidget *parent, Qt::WindowFlags f) + : QFrame(parent, f), + total_steps(totalSteps), + progress_val(-1), + percentage(-1), + center_indicator(true), + percentage_visible(true), + d(0) +{ + setSizePolicy(QSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed)); + initFrame(); +} + + +/*! + Reset the progress bar. The progress bar "rewinds" and shows no + progress. +*/ + +void Q3ProgressBar::reset() +{ + progress_val = -1; + percentage = -1; + setIndicator(progress_str, progress_val, total_steps); + repaint(); +} + + +/*! + \property Q3ProgressBar::totalSteps + \brief The total number of steps. + + If totalSteps is 0, the progress bar will display a busy + indicator. +*/ + +void Q3ProgressBar::setTotalSteps(int totalSteps) +{ + total_steps = totalSteps; + + // Current progress is invalid if larger than total + if (total_steps < progress_val) + progress_val = -1; + + if (isVisible() && + (setIndicator(progress_str, progress_val, total_steps) || !total_steps)) + repaint(); +} + + +/*! + \property Q3ProgressBar::progress + \brief The current amount of progress + + This property is -1 if progress counting has not started. +*/ + +void Q3ProgressBar::setProgress(int progress) +{ + if (progress == progress_val || + progress < 0 || ((progress > total_steps) && total_steps)) + return; + + int old_progress_val = progress_val; + progress_val = progress; + + if (setIndicator(progress_str, progress_val, total_steps) + || ( total_steps == 0 || (width() * progress_val / total_steps != width() * old_progress_val / total_steps ))) + repaint(); + +#ifndef QT_NO_ACCESSIBILITY + QAccessible::updateAccessibility(this, 0, QAccessible::ValueChanged); +#endif +} + +/*! + \overload + + Sets the amount of progress to \a progress and the total number of + steps to \a totalSteps. + + \sa setTotalSteps() +*/ + +void Q3ProgressBar::setProgress(int progress, int totalSteps) +{ + if (total_steps != totalSteps) + setTotalSteps(totalSteps); + setProgress(progress); +} + +/*! + \property Q3ProgressBar::progressString + \brief the amount of progress as a string + + This property is an empty string if progress counting has not started. +*/ + +static QStyleOptionProgressBar getStyleOption(const Q3ProgressBar *pb) +{ + QStyleOptionProgressBar opt; + opt.init(pb); + opt.rect = pb->contentsRect(); + opt.minimum = 0; + opt.maximum = pb->totalSteps(); + opt.progress = pb->progress(); + if (pb->centerIndicator()) + opt.textAlignment = Qt::AlignCenter; + else + opt.textAlignment = Qt::AlignAuto; + opt.textVisible = pb->percentageVisible(); + opt.text = pb->progressString(); + return opt; +} + +/*! + \reimp +*/ +QSize Q3ProgressBar::sizeHint() const +{ + ensurePolished(); + QFontMetrics fm = fontMetrics(); + QStyleOptionProgressBar opt = getStyleOption(this); + int cw = style()->pixelMetric(QStyle::PM_ProgressBarChunkWidth, &opt, this); + return style()->sizeFromContents(QStyle::CT_ProgressBar, &opt, + QSize(cw * 7 + fm.width(QLatin1Char('0')) * 4, fm.height() + 8), this); +} + +/*! + \reimp +*/ +QSize Q3ProgressBar::minimumSizeHint() const +{ + return sizeHint(); +} + +/*! + \property Q3ProgressBar::centerIndicator + \brief whether the indicator string should be centered +*/ + +void Q3ProgressBar::setCenterIndicator(bool on) +{ + if (on == center_indicator) + return; + center_indicator = on; + repaint(); +} + +/*! + \property Q3ProgressBar::percentageVisible + \brief whether the current progress value is displayed + + The default is true. + + \sa centerIndicator +*/ +void Q3ProgressBar::setPercentageVisible(bool on) +{ + if (on == percentage_visible) + return; + percentage_visible = on; + repaint(); +} + +/*! + \reimp +*/ +void Q3ProgressBar::setVisible(bool visible) +{ + if (visible) + setIndicator(progress_str, progress_val, total_steps); + QFrame::setVisible(visible); +} + +void Q3ProgressBar::initFrame() +{ + setFrameStyle(QFrame::NoFrame); +} + +/*! + \reimp +*/ +void Q3ProgressBar::changeEvent(QEvent *ev) +{ + if(ev->type() == QEvent::StyleChange) + initFrame(); + QFrame::changeEvent(ev); +} + + +/*! + This method is called to generate the text displayed in the center + (or in some styles, to the left) of the progress bar. + + The \a progress may be negative, indicating that the progress bar + is in the "reset" state before any progress is set. + + The default implementation is the percentage of completion or + blank in the reset state. The percentage is calculated based on + the \a progress and \a totalSteps. You can set the \a indicator + text if you wish. + + To allow efficient repainting of the progress bar, this method + should return false if the string is unchanged from the last call + to this function. +*/ + +bool Q3ProgressBar::setIndicator(QString & indicator, int progress, + int totalSteps) +{ + if (!totalSteps) + return false; + if (progress < 0) { + indicator = QString::fromLatin1(""); + return true; + } else { + // Get the values down to something usable. + if (totalSteps > INT_MAX/1000) { + progress /= 1000; + totalSteps /= 1000; + } + + int np = progress * 100 / totalSteps; + if (np != percentage) { + percentage = np; + indicator.sprintf("%d%%", np); + return true; + } else { + return false; + } + } +} + + +/*! + \reimp +*/ +void Q3ProgressBar::paintEvent(QPaintEvent *) +{ + QPainter paint(this); + QPainter *p = &paint; + drawFrame(p); + + QStyleOptionProgressBar opt = getStyleOption(this); + opt.rect = style()->subElementRect(QStyle::SE_ProgressBarGroove, &opt, this); + + style()->drawControl(QStyle::CE_ProgressBarGroove, &opt, p, this); + opt.rect = contentsRect(); + opt.rect = style()->subElementRect(QStyle::SE_ProgressBarContents, &opt, this); + style()->drawControl(QStyle::CE_ProgressBarContents, &opt, p, this); + + if (percentageVisible()) { + opt.rect = contentsRect(); + opt.rect = style()->subElementRect(QStyle::SE_ProgressBarLabel, &opt, this); + style()->drawControl(QStyle::CE_ProgressBarLabel, &opt, p, this); + } +} + +/*! + \fn void Q3ProgressBar::setMargin(int margin) + \since 4.2 + + Sets the width of the margin around the contents of the widget to \a margin. + + This function uses QWidget::setContentsMargins() to set the margin. + \sa margin(), QWidget::setContentsMargins() +*/ + +/*! + \fn int Q3ProgressBar::margin() const + \since 4.2 + + Returns the width of the margin around the contents of the widget. + + This function uses QWidget::getContentsMargins() to get the margin. + \sa setMargin(), QWidget::getContentsMargins() +*/ + +QT_END_NAMESPACE diff --git a/src/qt3support/widgets/q3progressbar.h b/src/qt3support/widgets/q3progressbar.h new file mode 100644 index 0000000..cc1887f --- /dev/null +++ b/src/qt3support/widgets/q3progressbar.h @@ -0,0 +1,148 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the Qt3Support module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, 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 qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef Q3PROGRESSBAR_H +#define Q3PROGRESSBAR_H + +#include <QtGui/qframe.h> + +QT_BEGIN_HEADER + +QT_BEGIN_NAMESPACE + +QT_MODULE(Qt3SupportLight) + +#ifndef QT_NO_PROGRESSBAR + +class Q3ProgressBarPrivate; + +class Q_COMPAT_EXPORT Q3ProgressBar : public QFrame +{ + Q_OBJECT + Q_PROPERTY(int totalSteps READ totalSteps WRITE setTotalSteps) + Q_PROPERTY(int progress READ progress WRITE setProgress) + Q_PROPERTY(QString progressString READ progressString) + Q_PROPERTY(bool centerIndicator READ centerIndicator WRITE setCenterIndicator) + Q_PROPERTY(bool percentageVisible READ percentageVisible WRITE setPercentageVisible) + +public: + Q3ProgressBar(QWidget *parent, const char *name, Qt::WindowFlags f=0); + Q3ProgressBar(int totalSteps, QWidget *parent, const char *name, + Qt::WindowFlags f=0); + Q3ProgressBar(QWidget *parent = 0, Qt::WindowFlags f = 0); + Q3ProgressBar(int totalSteps, QWidget *parent = 0, Qt::WindowFlags f=0); + + int totalSteps() const; + int progress() const; + const QString &progressString() const; + + QSize sizeHint() const; + QSize minimumSizeHint() const; + + void setCenterIndicator(bool on); + bool centerIndicator() const; + + bool percentageVisible() const; + void setPercentageVisible(bool); + + void setVisible(bool visible); + + void setMargin(int margin) { setContentsMargins(margin, margin, margin, margin); } + int margin() const + { int margin; int dummy; getContentsMargins(&margin, &dummy, &dummy, &dummy); return margin; } + +public Q_SLOTS: + void reset(); + virtual void setTotalSteps(int totalSteps); + virtual void setProgress(int progress); + void setProgress(int progress, int totalSteps); + +protected: + void paintEvent(QPaintEvent *); + virtual bool setIndicator(QString &progress_str, int progress, int totalSteps); + void changeEvent(QEvent *); + +private: + Q_DISABLE_COPY(Q3ProgressBar) + + int total_steps; + int progress_val; + int percentage; + QString progress_str; + bool center_indicator : 1; + bool percentage_visible : 1; + Q3ProgressBarPrivate *d; + void initFrame(); +}; + + +inline int Q3ProgressBar::totalSteps() const +{ + return total_steps; +} + +inline int Q3ProgressBar::progress() const +{ + return progress_val; +} + +inline const QString &Q3ProgressBar::progressString() const +{ + return progress_str; +} + +inline bool Q3ProgressBar::centerIndicator() const +{ + return center_indicator; +} + +inline bool Q3ProgressBar::percentageVisible() const +{ + return percentage_visible; +} + +#endif // QT_NO_PROGRESSBAR + +QT_END_NAMESPACE + +QT_END_HEADER + +#endif // Q3PROGRESSBAR_H diff --git a/src/qt3support/widgets/q3rangecontrol.cpp b/src/qt3support/widgets/q3rangecontrol.cpp new file mode 100644 index 0000000..39f05c1 --- /dev/null +++ b/src/qt3support/widgets/q3rangecontrol.cpp @@ -0,0 +1,550 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the Qt3Support module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, 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 qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "q3rangecontrol.h" +#ifndef QT_NO_RANGECONTROL +#include "qglobal.h" +#include <limits.h> + +QT_BEGIN_NAMESPACE + +/*! + \class Q3RangeControl + \brief The Q3RangeControl class provides an integer value within a range. + + \compat + + Although originally designed for the QScrollBar widget, the + Q3RangeControl can also be used in conjunction with other widgets + such as QSlider and QSpinBox. Here are the five main concepts in + the class: + + \list 1 + + \i \e{Current value} The bounded integer that + Q3RangeControl maintains. value() returns it, and several + functions, including setValue(), set it. + + \i \e{Minimum} The lowest value that value() can ever + return. Returned by minValue() and set by setRange() or one of the + constructors. + + \i \e{Maximum} The highest value that value() can ever + return. Returned by maxValue() and set by setRange() or one of the + constructors. + + \i \e{Line step} The smaller of two natural steps that + Q3RangeControl provides and typically corresponds to the user + pressing an arrow key. The line step is returned by lineStep() + and set using setSteps(). The functions addLine() and + subtractLine() respectively increment and decrement the current + value by lineStep(). + + \i \e{Page step} The larger of two natural steps that + Q3RangeControl provides and typically corresponds to the user + pressing PageUp or PageDown. The page step is returned by + pageStep() and set using setSteps(). The functions addPage() and + substractPage() respectively increment and decrement the current + value by pageStep(). + + \endlist + + Unity (1) may be viewed as a third step size. setValue() lets you + set the current value to any integer in the allowed range, not + just minValue() + \e n * lineStep() for integer values of \e n. + Some widgets may allow the user to set any value at all; others + may just provide multiples of lineStep() or pageStep(). + + Q3RangeControl provides three virtual functions that are well + suited for updating the on-screen representation of range controls + and emitting signals: valueChange(), rangeChange() and + stepChange(). + + Q3RangeControl also provides a function called bound() which lets + you force arbitrary integers to be within the allowed range of the + range control. + + We recommend that all widgets that inherit Q3RangeControl provide + at least a signal called valueChanged(); many widgets will want to + provide addStep(), addPage(), substractStep() and substractPage() + as slots. + + Note that you must use multiple inheritance if you plan to + implement a widget using Q3RangeControl because Q3RangeControl is + not derived from QWidget. +*/ + + +/*! + Constructs a range control with a minimum value of 0, maximum + value of 99, line step of 1, page step of 10 and initial value 0. +*/ + +Q3RangeControl::Q3RangeControl() +{ + minVal = 0; + maxVal = 99; + line = 1; + page = 10; + val = 0; + prevVal = -1; + d = 0; +} + +/*! + Constructs a range control whose value can never be smaller than + \a minValue or greater than \a maxValue, whose line step size is + \a lineStep and page step size is \a pageStep and whose value is + initially \a value (which is guaranteed to be in range using + bound()). +*/ + +Q3RangeControl::Q3RangeControl(int minValue, int maxValue, + int lineStep, int pageStep, + int value) +{ + minVal = minValue; + maxVal = maxValue; + line = QABS(lineStep); + page = QABS(pageStep); + prevVal = minVal - 1; + val = bound(value); + d = 0; +} + +/*! + Destroys the range control +*/ + +Q3RangeControl::~Q3RangeControl() +{ +} + + +/*! + \fn int Q3RangeControl::value() const + + Returns the current range control value. This is guaranteed to be + within the range [minValue(), maxValue()]. + + \sa setValue() prevValue() +*/ + +/*! + \fn int Q3RangeControl::prevValue() const + + Returns the previous value of the range control. "Previous value" + means the value before the last change occurred. Setting a new + range may affect the value, too, because the value is forced to be + inside the specified range. When the range control is initially + created, this is the same as value(). + + prevValue() can be outside the current legal range if a call to + setRange() causes the current value to change. For example, if the + range was [0, 1000] and the current value is 500, setRange(0, 400) + makes value() return 400 and prevValue() return 500. + + \sa value() setRange() +*/ + +/*! + Sets the range control's value to \a value and forces it to be + within the legal range. + + Calls the virtual valueChange() function if the new value is + different from the previous value. The old value can still be + retrieved using prevValue(). + + \sa value() +*/ + +void Q3RangeControl::setValue(int value) +{ + directSetValue(value); + if (prevVal != val) + valueChange(); +} + +/*! + Sets the range control \a value directly without calling + valueChange(). + + Forces the new \a value to be within the legal range. + + You will rarely have to call this function. However, if you want + to change the range control's value inside the overloaded method + valueChange(), setValue() would call the function valueChange() + again. To avoid this recursion you must use directSetValue() + instead. + + \sa setValue() +*/ + +void Q3RangeControl::directSetValue(int value) +{ + prevVal = val; + val = bound(value); +} + +/*! + Equivalent to \c{setValue(value() + pageStep())}. + + If the value is changed, then valueChange() is called. + + \sa subtractPage() addLine() setValue() +*/ + +void Q3RangeControl::addPage() +{ + setValue(value() + pageStep()); +} + +/*! + Equivalent to \c{setValue(value() - pageStep())}. + + If the value is changed, then valueChange() is called. + + \sa addPage() subtractLine() setValue() +*/ + +void Q3RangeControl::subtractPage() +{ + setValue(value() - pageStep()); +} + +/*! + Equivalent to \c{setValue(value() + lineStep())}. + + If the value is changed, then valueChange() is called. + + \sa subtractLine() addPage() setValue() +*/ + +void Q3RangeControl::addLine() +{ + setValue(value() + lineStep()); +} + +/*! + Equivalent to \c{setValue(value() - lineStep())}. + + If the value is changed, then valueChange() is called. + + \sa addLine() subtractPage() setValue() +*/ + +void Q3RangeControl::subtractLine() +{ + setValue(value() - lineStep()); +} + + +/*! + \fn int Q3RangeControl::minValue() const + + Returns the minimum value of the range. + + \sa setMinValue() setRange() maxValue() +*/ + +/*! + \fn int Q3RangeControl::maxValue() const + + Returns the maximum value of the range. + + \sa setMaxValue() setRange() minValue() +*/ + +/*! + Sets the minimum value of the range to \a minVal. + + If necessary, the maxValue() is adjusted so that the range remains + valid. + + \sa minValue() setMaxValue() +*/ +void Q3RangeControl::setMinValue(int minVal) +{ + int maxVal = maxValue(); + if (maxVal < minVal) + maxVal = minVal; + setRange(minVal, maxVal); +} + +/*! + Sets the minimum value of the range to \a maxVal. + + If necessary, the minValue() is adjusted so that the range remains + valid. + + \sa maxValue() setMinValue() +*/ +void Q3RangeControl::setMaxValue(int maxVal) +{ + int minVal = minValue(); + if (minVal > maxVal) + minVal = maxVal; + setRange(minVal, maxVal); +} + +/*! + Sets the range control's minimum value to \a minValue and its + maximum value to \a maxValue. + + Calls the virtual rangeChange() function if one or both of the new + minimum and maximum values are different from the previous + setting. Calls the virtual valueChange() function if the current + value is adjusted because it was outside the new range. + + If \a maxValue is smaller than \a minValue, \a minValue becomes + the only legal value. + + \sa minValue() maxValue() +*/ + +void Q3RangeControl::setRange(int minValue, int maxValue) +{ + if (minValue > maxValue) { + qWarning("Q3RangeControl::setRange: minValue %d > maxValue %d", + minValue, maxValue); + maxValue = minValue; + } + if (minValue == minVal && maxValue == maxVal) + return; + minVal = minValue; + maxVal = maxValue; + int tmp = bound(val); + rangeChange(); + if (tmp != val) { + prevVal = val; + val = tmp; + valueChange(); + } +} + + +/*! + \fn int Q3RangeControl::lineStep() const + + Returns the line step. + + \sa setSteps() pageStep() +*/ + +/*! + \fn int Q3RangeControl::pageStep() const + + Returns the page step. + + \sa setSteps() lineStep() +*/ + +/*! + Sets the range's line step to \a lineStep and page step to \a + pageStep. + + Calls the virtual stepChange() function if the new line step + or page step are different from the previous settings. + + \sa lineStep() pageStep() setRange() +*/ + +void Q3RangeControl::setSteps(int lineStep, int pageStep) +{ + if (lineStep != line || pageStep != page) { + line = QABS(lineStep); + page = QABS(pageStep); + stepChange(); + } +} + + +/*! + This virtual function is called whenever the range control value + changes. You can reimplement it if you want to be notified when + the value changes. The default implementation does nothing. + + Note that this method is called after the value has changed. The + previous value can be retrieved using prevValue(). + + \sa setValue(), addPage(), subtractPage(), addLine(), + subtractLine() rangeChange(), stepChange() +*/ + +void Q3RangeControl::valueChange() +{ +} + + +/*! + This virtual function is called whenever the range control's range + changes. You can reimplement it if you want to be notified when + the range changes. The default implementation does nothing. + + Note that this method is called after the range has changed. + + \sa setRange(), valueChange(), stepChange() +*/ + +void Q3RangeControl::rangeChange() +{ +} + + +/*! + This virtual function is called whenever the range control's + line or page step settings change. You can reimplement it if you + want to be notified when the step changes. The default + implementation does nothing. + + Note that this method is called after a step setting has changed. + + \sa setSteps(), rangeChange(), valueChange() +*/ + +void Q3RangeControl::stepChange() +{ +} + + +/*! + Forces the value \a v to be within the range from minValue() to + maxValue() inclusive, and returns the result. + + This function is provided so that you can easily force other + numbers than value() into the allowed range. You do not need to + call it in order to use Q3RangeControl itself. + + \sa setValue() value() minValue() maxValue() +*/ + +int Q3RangeControl::bound(int v) const +{ + if (v < minVal) + return minVal; + if (v > maxVal) + return maxVal; + return v; +} + + +/*! + Converts \a logical_val to a pixel position. minValue() maps to 0, + maxValue() maps to \a span and other values are distributed evenly + in-between. + + This function can handle the entire integer range without + overflow, providing \a span is \<= 4096. + + Calling this method is useful when actually drawing a range + control such as a QScrollBar on-screen. + + \sa valueFromPosition() +*/ + +int Q3RangeControl::positionFromValue(int logical_val, int span) const +{ + if (span <= 0 || logical_val < minValue() || maxValue() <= minValue()) + return 0; + if (logical_val > maxValue()) + return span; + + uint range = maxValue() - minValue(); + uint p = logical_val - minValue(); + + if (range > (uint)INT_MAX/4096) { + const int scale = 4096*2; + return ((p/scale) * span) / (range/scale); + // ### the above line is probably not 100% correct + // ### but fixing it isn't worth the extreme pain... + } else if (range > (uint)span) { + return (2*p*span + range) / (2*range); + } else { + uint div = span / range; + uint mod = span % range; + return p*div + (2*p*mod + range) / (2*range); + } + //equiv. to (p*span)/range + 0.5 + // no overflow because of this implicit assumption: + // span <= 4096 +} + + +/*! + Converts the pixel position \a pos to a value. 0 maps to + minValue(), \a span maps to maxValue() and other values are + distributed evenly in-between. + + This function can handle the entire integer range without + overflow. + + Calling this method is useful if you actually implemented a range + control widget such as QScrollBar and want to handle mouse press + events. This function then maps screen coordinates to the logical + values. + + \sa positionFromValue() +*/ + +int Q3RangeControl::valueFromPosition(int pos, int span) const +{ + if (span <= 0 || pos <= 0) + return minValue(); + if (pos >= span) + return maxValue(); + + uint range = maxValue() - minValue(); + + if ((uint)span > range) + return minValue() + (2*pos*range + span) / (2*span); + else { + uint div = range / span; + uint mod = range % span; + return minValue() + pos*div + (2*pos*mod + span) / (2*span); + } + // equiv. to minValue() + (pos*range)/span + 0.5 + // no overflow because of this implicit assumption: + // pos <= span < sqrt(INT_MAX+0.0625)+0.25 ~ sqrt(INT_MAX) +} + +QT_END_NAMESPACE + +#endif // QT_NO_RANGECONTROL diff --git a/src/qt3support/widgets/q3rangecontrol.h b/src/qt3support/widgets/q3rangecontrol.h new file mode 100644 index 0000000..412dc9e --- /dev/null +++ b/src/qt3support/widgets/q3rangecontrol.h @@ -0,0 +1,194 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the Qt3Support module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, 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 qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef Q3RANGECONTROL_H +#define Q3RANGECONTROL_H + +#include <QtCore/qglobal.h> +#include <QtGui/qwidget.h> + +QT_BEGIN_HEADER + +QT_BEGIN_NAMESPACE + +QT_MODULE(Qt3SupportLight) + +#ifndef QT_NO_RANGECONTROL + +class Q3RangeControlPrivate; + +class Q_COMPAT_EXPORT Q3RangeControl +{ +public: + Q3RangeControl(); + Q3RangeControl(int minValue, int maxValue, + int lineStep, int pageStep, int value); + virtual ~Q3RangeControl(); + + int value() const; + void setValue(int); + void addPage(); + void subtractPage(); + void addLine(); + void subtractLine(); + + int minValue() const; + int maxValue() const; + void setRange(int minValue, int maxValue); + void setMinValue(int minVal); + void setMaxValue(int minVal); + + int lineStep() const; + int pageStep() const; + void setSteps(int line, int page); + + int bound(int) const; + +protected: + int positionFromValue(int val, int space) const; + int valueFromPosition(int pos, int space) const; + void directSetValue(int val); + int prevValue() const; + + virtual void valueChange(); + virtual void rangeChange(); + virtual void stepChange(); + +private: + int minVal, maxVal; + int line, page; + int val, prevVal; + + Q3RangeControlPrivate * d; + +private: + Q_DISABLE_COPY(Q3RangeControl) +}; + + +inline int Q3RangeControl::value() const +{ return val; } + +inline int Q3RangeControl::prevValue() const +{ return prevVal; } + +inline int Q3RangeControl::minValue() const +{ return minVal; } + +inline int Q3RangeControl::maxValue() const +{ return maxVal; } + +inline int Q3RangeControl::lineStep() const +{ return line; } + +inline int Q3RangeControl::pageStep() const +{ return page; } + + +#endif // QT_NO_RANGECONTROL + +#ifndef QT_NO_SPINWIDGET + +class Q3SpinWidgetPrivate; +class Q_COMPAT_EXPORT Q3SpinWidget : public QWidget +{ + Q_OBJECT +public: + Q3SpinWidget(QWidget* parent=0, const char* name=0); + ~Q3SpinWidget(); + + void setEditWidget(QWidget * widget); + QWidget * editWidget(); + + QRect upRect() const; + QRect downRect() const; + + void setUpEnabled(bool on); + void setDownEnabled(bool on); + + bool isUpEnabled() const; + bool isDownEnabled() const; + + enum ButtonSymbols { UpDownArrows, PlusMinus }; + virtual void setButtonSymbols(ButtonSymbols bs); + ButtonSymbols buttonSymbols() const; + + void arrange(); + +Q_SIGNALS: + void stepUpPressed(); + void stepDownPressed(); + +public Q_SLOTS: + void stepUp(); + void stepDown(); + +protected: + void mousePressEvent(QMouseEvent *e); + void resizeEvent(QResizeEvent* ev); + void mouseReleaseEvent(QMouseEvent *e); + void mouseMoveEvent(QMouseEvent *e); +#ifndef QT_NO_WHEELEVENT + void wheelEvent(QWheelEvent *); +#endif + void changeEvent(QEvent *); + void paintEvent(QPaintEvent *); + +private Q_SLOTS: + void timerDone(); + void timerDoneEx(); + +private: + Q3SpinWidgetPrivate * d; + + void updateDisplay(); + +private: + Q_DISABLE_COPY(Q3SpinWidget) +}; + +#endif // QT_NO_RANGECONTROL + +QT_END_NAMESPACE + +QT_END_HEADER + +#endif // Q3RANGECONTROL_H diff --git a/src/qt3support/widgets/q3scrollview.cpp b/src/qt3support/widgets/q3scrollview.cpp new file mode 100644 index 0000000..ea45d6f --- /dev/null +++ b/src/qt3support/widgets/q3scrollview.cpp @@ -0,0 +1,2807 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the Qt3Support module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, 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 qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "qwidget.h" +#ifndef QT_NO_SCROLLVIEW +#include "qscrollbar.h" +#include "qpainter.h" +#include "qpixmap.h" +#include "qcursor.h" +#include "q3scrollview.h" +#include "q3ptrdict.h" +#include "qapplication.h" +#include "qtimer.h" +#include "qstyle.h" +#include "q3ptrlist.h" +#include "qevent.h" +#include "q3listview.h" +#ifdef Q_WS_MAC +# include "private/qt_mac_p.h" +#endif + +QT_BEGIN_NAMESPACE + +using namespace Qt; + +static const int coord_limit = 4000; +static const int autoscroll_margin = 16; +static const int initialScrollTime = 30; +static const int initialScrollAccel = 5; + +struct QSVChildRec { + QSVChildRec(QWidget* c, int xx, int yy) : + child(c), + x(xx), y(yy) + { + } + + void hideOrShow(Q3ScrollView* sv, QWidget* clipped_viewport); + void moveTo(Q3ScrollView* sv, int xx, int yy, QWidget* clipped_viewport) + { + if (x != xx || y != yy) { + x = xx; + y = yy; + hideOrShow(sv,clipped_viewport); + } + } + QWidget* child; + int x, y; +}; + +void QSVChildRec::hideOrShow(Q3ScrollView* sv, QWidget* clipped_viewport) +{ + if (clipped_viewport) { + if (x+child->width() < sv->contentsX()+clipped_viewport->x() + || x > sv->contentsX()+clipped_viewport->width() + || y+child->height() < sv->contentsY()+clipped_viewport->y() + || y > sv->contentsY()+clipped_viewport->height()) { + child->move(clipped_viewport->width(), + clipped_viewport->height()); + } else { + child->move(x-sv->contentsX()-clipped_viewport->x(), + y-sv->contentsY()-clipped_viewport->y()); + } + } else { + child->move(x-sv->contentsX(), y-sv->contentsY()); + } +} + +class QAbstractScrollAreaWidget : public QWidget +{ + Q_OBJECT + +public: + QAbstractScrollAreaWidget(Q3ScrollView* parent=0, const char* name=0, Qt::WindowFlags f = 0) + : QWidget(parent, name, f) + { + setAutoFillBackground(true); + } +}; + +class QClipperWidget : public QWidget +{ + Q_OBJECT + +public: + QClipperWidget(QWidget * parent=0, const char * name=0, Qt::WindowFlags f=0) + : QWidget (parent,name,f) {} +}; + +QT_BEGIN_INCLUDE_NAMESPACE +#include "q3scrollview.moc" +QT_END_INCLUDE_NAMESPACE + +class Q3ScrollViewData { +public: + Q3ScrollViewData(Q3ScrollView* parent, int vpwflags) : + hbar(new QScrollBar(Qt::Horizontal, parent, "qt_hbar")), + vbar(new QScrollBar(Qt::Vertical, parent, "qt_vbar")), + viewport(new QAbstractScrollAreaWidget(parent, "qt_viewport", QFlag(vpwflags))), + clipped_viewport(0), + flags(vpwflags), + vx(0), vy(0), vwidth(1), vheight(1), +#ifndef QT_NO_DRAGANDDROP + autoscroll_timer(parent, "scrollview autoscroll timer"), + drag_autoscroll(true), +#endif + scrollbar_timer(parent, "scrollview scrollbar timer"), + inresize(false), use_cached_size_hint(true) + { + l_marg = r_marg = t_marg = b_marg = 0; + viewport->polish(); + vMode = Q3ScrollView::Auto; + hMode = Q3ScrollView::Auto; + corner = 0; + vbar->setSteps(20, 1/*set later*/); + hbar->setSteps(20, 1/*set later*/); + policy = Q3ScrollView::Default; + signal_choke = false; + static_bg = false; + fake_scroll = false; + hbarPressed = false; + vbarPressed = false; + hbar->setLayoutDirection(Qt::LeftToRight); + } + ~Q3ScrollViewData(); + + QSVChildRec* rec(QWidget* w) { return childDict.find(w); } + QSVChildRec* ancestorRec(QWidget* w); + QSVChildRec* addChildRec(QWidget* w, int x, int y) + { + QSVChildRec *r = new QSVChildRec(w,x,y); + children.append(r); + childDict.insert(w, r); + return r; + } + void deleteChildRec(QSVChildRec* r) + { + childDict.remove(r->child); + children.removeRef(r); + delete r; + } + + void hideOrShowAll(Q3ScrollView* sv, bool isScroll = false); + void moveAllBy(int dx, int dy); + bool anyVisibleChildren(); + void autoMove(Q3ScrollView* sv); + void autoResize(Q3ScrollView* sv); + void autoResizeHint(Q3ScrollView* sv); + void viewportResized(int w, int h); + + QScrollBar* hbar; + QScrollBar* vbar; + bool hbarPressed; + bool vbarPressed; + QAbstractScrollAreaWidget* viewport; + QClipperWidget* clipped_viewport; + int flags; + Q3PtrList<QSVChildRec> children; + Q3PtrDict<QSVChildRec> childDict; + QWidget* corner; + int vx, vy, vwidth, vheight; // for drawContents-style usage + int l_marg, r_marg, t_marg, b_marg; + Q3ScrollView::ResizePolicy policy; + Q3ScrollView::ScrollBarMode vMode; + Q3ScrollView::ScrollBarMode hMode; +#ifndef QT_NO_DRAGANDDROP + QPoint cpDragStart; + QTimer autoscroll_timer; + int autoscroll_time; + int autoscroll_accel; + bool drag_autoscroll; +#endif + QTimer scrollbar_timer; + + uint static_bg : 1; + uint fake_scroll : 1; + + // This variable allows ensureVisible to move the contents then + // update both the sliders. Otherwise, updating the sliders would + // cause two image scrolls, creating ugly flashing. + // + uint signal_choke : 1; + + // This variables indicates in updateScrollBars() that we are + // in a resizeEvent() and thus don't want to flash scroll bars + uint inresize : 1; + uint use_cached_size_hint : 1; + QSize cachedSizeHint; + + inline int contentsX() const { return -vx; } + inline int contentsY() const { return -vy; } + inline int contentsWidth() const { return vwidth; } +}; + +inline Q3ScrollViewData::~Q3ScrollViewData() +{ + children.setAutoDelete(true); +} + +QSVChildRec* Q3ScrollViewData::ancestorRec(QWidget* w) +{ + if (clipped_viewport) { + while (w->parentWidget() != clipped_viewport) { + w = w->parentWidget(); + if (!w) return 0; + } + } else { + while (w->parentWidget() != viewport) { + w = w->parentWidget(); + if (!w) return 0; + } + } + return rec(w); +} + +void Q3ScrollViewData::hideOrShowAll(Q3ScrollView* sv, bool isScroll) +{ + if (!clipped_viewport) + return; + if (clipped_viewport->x() <= 0 + && clipped_viewport->y() <= 0 + && clipped_viewport->width()+clipped_viewport->x() >= + viewport->width() + && clipped_viewport->height()+clipped_viewport->y() >= + viewport->height()) { + // clipped_viewport still covers viewport + if(static_bg) + clipped_viewport->repaint(true); + else if ((!isScroll && !clipped_viewport->testAttribute(Qt::WA_StaticContents)) || static_bg) + clipped_viewport->update(); + } else { + // Re-center + int nx = (viewport->width() - clipped_viewport->width()) / 2; + int ny = (viewport->height() - clipped_viewport->height()) / 2; + clipped_viewport->move(nx,ny); + clipped_viewport->update(); + } + for (QSVChildRec *r = children.first(); r; r=children.next()) { + r->hideOrShow(sv, clipped_viewport); + } +} + +void Q3ScrollViewData::moveAllBy(int dx, int dy) +{ + if (clipped_viewport && !static_bg) { + clipped_viewport->move(clipped_viewport->x()+dx, + clipped_viewport->y()+dy); + } else { + for (QSVChildRec *r = children.first(); r; r=children.next()) { + r->child->move(r->child->x()+dx,r->child->y()+dy); + } + if (static_bg) + viewport->repaint(true); + } +} + +bool Q3ScrollViewData::anyVisibleChildren() +{ + for (QSVChildRec *r = children.first(); r; r=children.next()) { + if (r->child->isVisible()) return true; + } + return false; +} + +void Q3ScrollViewData::autoMove(Q3ScrollView* sv) +{ + if (policy == Q3ScrollView::AutoOne) { + QSVChildRec* r = children.first(); + if (r) + sv->setContentsPos(-r->child->x(),-r->child->y()); + } +} + +void Q3ScrollViewData::autoResize(Q3ScrollView* sv) +{ + if (policy == Q3ScrollView::AutoOne) { + QSVChildRec* r = children.first(); + if (r) + sv->resizeContents(r->child->width(),r->child->height()); + } +} + +void Q3ScrollViewData::autoResizeHint(Q3ScrollView* sv) +{ + if (policy == Q3ScrollView::AutoOne) { + QSVChildRec* r = children.first(); + if (r) { + QSize s = r->child->sizeHint(); + if (s.isValid()) + r->child->resize(s); + } + } else if (policy == Q3ScrollView::AutoOneFit) { + QSVChildRec* r = children.first(); + if (r) { + QSize sh = r->child->sizeHint(); + sh = sh.boundedTo(r->child->maximumSize()); + sv->resizeContents(sh.width(), sh.height()); + } + } +} + +void Q3ScrollViewData::viewportResized(int w, int h) +{ + if (policy == Q3ScrollView::AutoOneFit) { + QSVChildRec* r = children.first(); + if (r) { + QSize sh = r->child->sizeHint(); + sh = sh.boundedTo(r->child->maximumSize()); + r->child->resize(QMAX(w,sh.width()), QMAX(h,sh.height())); + } + + } +} + + +/*! + \class Q3ScrollView + \brief The Q3ScrollView widget provides a scrolling area with on-demand scroll bars. + + \compat + + The Q3ScrollView is a large canvas - potentially larger than the + coordinate system normally supported by the underlying window + system. This is important because it is quite easy to go beyond + these limitations (e.g. many web pages are more than 32000 pixels + high). Additionally, the Q3ScrollView can have QWidgets positioned + on it that scroll around with the drawn content. These sub-widgets + can also have positions outside the normal coordinate range (but + they are still limited in size). + + To provide content for the widget, inherit from Q3ScrollView, + reimplement drawContents() and use resizeContents() to set the + size of the viewed area. Use addChild() and moveChild() to + position widgets on the view. + + To use Q3ScrollView effectively it is important to understand its + widget structure in the three styles of use: a single large child + widget, a large panning area with some widgets and a large panning + area with many widgets. + + \section1 Using One Big Widget + + \img qscrollview-vp2.png + + The first, simplest usage of Q3ScrollView (depicted above), is + appropriate for scrolling areas that are never more than about + 4000 pixels in either dimension (this is about the maximum + reliable size on X11 servers). In this usage, you just make one + large child in the Q3ScrollView. The child should be a child of the + viewport() of the scrollview and be added with addChild(): + \snippet doc/src/snippets/code/src_qt3support_widgets_q3scrollview.cpp 0 + You can go on to add arbitrary child widgets to the single child + in the scrollview as you would with any widget: + \snippet doc/src/snippets/code/src_qt3support_widgets_q3scrollview.cpp 1 + + Here the Q3ScrollView has four children: the viewport(), the + verticalScrollBar(), the horizontalScrollBar() and a small + cornerWidget(). The viewport() has one child: the QWidget. The + QWidget has the three QLabel objects as child widgets. When the view + is scrolled, the QWidget is moved; its children move with it as + child widgets normally do. + + \section1 Using a Very Big View with Some Widgets + + \img qscrollview-vp.png + + The second usage of Q3ScrollView (depicted above) is appropriate + when few, if any, widgets are on a very large scrolling area that + is potentially larger than 4000 pixels in either dimension. In + this usage you call resizeContents() to set the size of the area + and reimplement drawContents() to paint the contents. You may also + add some widgets by making them children of the viewport() and + adding them with addChild() (this is the same as the process for + the single large widget in the previous example): + \snippet doc/src/snippets/code/src_qt3support_widgets_q3scrollview.cpp 2 + Here, the Q3ScrollView has the same four children: the viewport(), + the verticalScrollBar(), the horizontalScrollBar() and a small + cornerWidget(). The viewport() has the three QLabel objects as + child widgets. When the view is scrolled, the scrollview moves the + child widgets individually. + + \section1 Using a Very Big View with Many Widgets + + \img qscrollview-cl.png + + The final usage of Q3ScrollView (depicted above) is appropriate + when many widgets are on a very large scrolling area that is + potentially larger than 4000 pixels in either dimension. In this + usage you call resizeContents() to set the size of the area and + reimplement drawContents() to paint the contents. You then call + enableClipper(true) and add widgets, again by making them children + of the viewport(), and adding them with addChild(): + \snippet doc/src/snippets/code/src_qt3support_widgets_q3scrollview.cpp 3 + + Here, the Q3ScrollView has four children: the clipper() (not the + viewport() this time), the verticalScrollBar(), the + horizontalScrollBar() and a small cornerWidget(). The clipper() + has one child: the viewport(). The viewport() has the same three + labels as child widgets. When the view is scrolled the viewport() + is moved; its children move with it as child widgets normally do. + + \target allviews + \section1 Details Relevant for All Views + + Normally you will use the first or third method if you want any + child widgets in the view. + + Note that the widget you see in the scrolled area is the + viewport() widget, not the Q3ScrollView itself. So to turn mouse + tracking on, for example, use viewport()->setMouseTracking(true). + + To enable drag-and-drop, you would setAcceptDrops(true) on the + Q3ScrollView (because drag-and-drop events propagate to the + parent). But to work out the logical position in the view, you + would need to map the drop co-ordinate from being relative to the + Q3ScrollView to being relative to the contents; use the function + viewportToContents() for this. + + To handle mouse events on the scrolling area, subclass scrollview + as you would subclass other widgets, but rather than + reimplementing mousePressEvent(), reimplement + contentsMousePressEvent() instead. The contents specific event + handlers provide translated events in the coordinate system of the + scrollview. If you reimplement mousePressEvent(), you'll get + called only when part of the Q3ScrollView is clicked: and the only + such part is the "corner" (if you don't set a cornerWidget()) and + the frame; everything else is covered up by the viewport, clipper + or scroll bars. + + When you construct a Q3ScrollView, some of the window flags apply + to the viewport() instead of being sent to the QWidget constructor + for the Q3ScrollView. + + \list + + \i An image-manipulation widget would use \c + WNoAutoErase|WStaticContents because the widget draws all pixels + itself, and when its size increases, it only needs a paint event + for the new part because the old part remains unchanged. + + \i A scrolling game widget in which the background scrolls as the + characters move might use \c WNoAutoErase (in addition to \c + WStaticContents) so that the window system background does not + flash in and out during scrolling. + + \i A word processing widget might use \c WNoAutoErase and repaint + itself line by line to get a less-flickery resizing. If the widget + is in a mode in which no text justification can take place, it + might use \c WStaticContents too, so that it would only get a + repaint for the newly visible parts. + + \endlist + + Child widgets may be moved using addChild() or moveChild(). Use + childX() and childY() to get the position of a child widget. + + A widget may be placed in the corner between the vertical and + horizontal scroll bars with setCornerWidget(). You can get access + to the scroll bars using horizontalScrollBar() and + verticalScrollBar(), and to the viewport with viewport(). The + scroll view can be scrolled using scrollBy(), ensureVisible(), + setContentsPos() or center(). + + The visible area is given by visibleWidth() and visibleHeight(), + and the contents area by contentsWidth() and contentsHeight(). The + contents may be repainted using one of the repaintContents() or + updateContents() functions. + + Coordinate conversion is provided by contentsToViewport() and + viewportToContents(). + + The contentsMoving() signal is emitted just before the contents + are moved to a new position. + + \warning Q3ScrollView currently does not erase the background when + resized, i.e. you must always clear the background manually in + scrollview subclasses. This will change in a future version of Qt + and we recommend specifying the \c WNoAutoErase flag explicitly. +*/ + + +/*! + \enum Q3ScrollView::ResizePolicy + + This enum type is used to control a Q3ScrollView's reaction to + resize events. + + \value Default the Q3ScrollView selects one of the other settings + automatically when it has to. In this version of Qt, Q3ScrollView + changes to \c Manual if you resize the contents with + resizeContents() and to \c AutoOne if a child is added. + + \value Manual the contents stays the size set by resizeContents(). + + \value AutoOne if there is only one child widget the contents stays + the size of that widget. Otherwise the behavior is undefined. + + \value AutoOneFit if there is only one child widget the contents stays + the size of that widget's sizeHint(). If the scrollview is resized + larger than the child's sizeHint(), the child will be resized to + fit. If there is more than one child, the behavior is undefined. + +*/ +//#### The widget will be resized to its sizeHint() when a LayoutHint event +//#### is received + +/*! + Constructs a Q3ScrollView called \a name with parent \a parent and + widget flags \a f. + + The widget flags \c WStaticContents, \c WNoAutoErase and \c + WPaintClever are propagated to the viewport() widget. The other + widget flags are propagated to the parent constructor as usual. +*/ + +Q3ScrollView::Q3ScrollView(QWidget *parent, const char *name, Qt::WindowFlags f) : + Q3Frame(parent, name, f & (~WStaticContents) & (~WNoAutoErase) & (~WResizeNoErase)) +{ + WindowFlags flags = WResizeNoErase | (f&WPaintClever) | (f&WRepaintNoErase) | (f&WStaticContents); + d = new Q3ScrollViewData(this, flags); + +#ifndef QT_NO_DRAGANDDROP + connect(&d->autoscroll_timer, SIGNAL(timeout()), + this, SLOT(doDragAutoScroll())); +#endif + + connect(d->hbar, SIGNAL(valueChanged(int)), + this, SLOT(hslide(int))); + connect(d->vbar, SIGNAL(valueChanged(int)), + this, SLOT(vslide(int))); + + connect(d->hbar, SIGNAL(sliderPressed()), this, SLOT(hbarIsPressed())); + connect(d->hbar, SIGNAL(sliderReleased()), this, SLOT(hbarIsReleased())); + connect(d->vbar, SIGNAL(sliderPressed()), this, SLOT(vbarIsPressed())); + connect(d->vbar, SIGNAL(sliderReleased()), this, SLOT(vbarIsReleased())); + + + d->viewport->installEventFilter(this); + + connect(&d->scrollbar_timer, SIGNAL(timeout()), + this, SLOT(updateScrollBars())); + + setFrameStyle(Q3Frame::StyledPanel | Q3Frame::Sunken); + setLineWidth(style()->pixelMetric(QStyle::PM_DefaultFrameWidth)); + setSizePolicy(QSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding)); +} + + +/*! + Destroys the Q3ScrollView. Any children added with addChild() will + be deleted. +*/ +Q3ScrollView::~Q3ScrollView() +{ + // Be careful not to get all those useless events... + if (d->clipped_viewport) + d->clipped_viewport->removeEventFilter(this); + else + d->viewport->removeEventFilter(this); + + // order is important + // ~QWidget may cause a WM_ERASEBKGND on Windows + delete d->vbar; + d->vbar = 0; + delete d->hbar; + d->hbar = 0; + delete d->viewport; + d->viewport = 0; + delete d; + d = 0; +} + +/*! + \fn void Q3ScrollView::horizontalSliderPressed() + + This signal is emitted whenever the user presses the horizontal slider. +*/ +/*! + \fn void Q3ScrollView::horizontalSliderReleased() + + This signal is emitted whenever the user releases the horizontal slider. +*/ +/*! + \fn void Q3ScrollView::verticalSliderPressed() + + This signal is emitted whenever the user presses the vertical slider. +*/ +/*! + \fn void Q3ScrollView::verticalSliderReleased() + + This signal is emitted whenever the user releases the vertical slider. +*/ +void Q3ScrollView::hbarIsPressed() +{ + d->hbarPressed = true; + emit(horizontalSliderPressed()); +} + +void Q3ScrollView::hbarIsReleased() +{ + d->hbarPressed = false; + emit(horizontalSliderReleased()); +} + +/*! + Returns true if horizontal slider is pressed by user; otherwise returns false. +*/ +bool Q3ScrollView::isHorizontalSliderPressed() +{ + return d->hbarPressed; +} + +void Q3ScrollView::vbarIsPressed() +{ + d->vbarPressed = true; + emit(verticalSliderPressed()); +} + +void Q3ScrollView::vbarIsReleased() +{ + d->vbarPressed = false; + emit(verticalSliderReleased()); +} + +/*! + Returns true if vertical slider is pressed by user; otherwise returns false. +*/ +bool Q3ScrollView::isVerticalSliderPressed() +{ + return d->vbarPressed; +} + +/*! + \internal +*/ +void Q3ScrollView::styleChange(QStyle& old) +{ + QWidget::styleChange(old); + updateScrollBars(); + d->cachedSizeHint = QSize(); +} + +/*! + \internal +*/ +void Q3ScrollView::fontChange(const QFont &old) +{ + QWidget::fontChange(old); + updateScrollBars(); + d->cachedSizeHint = QSize(); +} + +void Q3ScrollView::hslide(int pos) +{ + if (!d->signal_choke) { + moveContents(-pos, -d->contentsY()); + QApplication::syncX(); + } +} + +void Q3ScrollView::vslide(int pos) +{ + if (!d->signal_choke) { + moveContents(-d->contentsX(), -pos); + QApplication::syncX(); + } +} + +/*! + Called when the horizontal scroll bar geometry changes. This is + provided as a protected function so that subclasses can do + interesting things such as providing extra buttons in some of the + space normally used by the scroll bars. + + The default implementation simply gives all the space to \a hbar. + The new geometry is given by \a x, \a y, \a w and \a h. + + \sa setVBarGeometry() +*/ +void Q3ScrollView::setHBarGeometry(QScrollBar& hbar, + int x, int y, int w, int h) +{ + hbar.setGeometry(x, y, w, h); +} + +/*! + Called when the vertical scroll bar geometry changes. This is + provided as a protected function so that subclasses can do + interesting things such as providing extra buttons in some of the + space normally used by the scroll bars. + + The default implementation simply gives all the space to \a vbar. + The new geometry is given by \a x, \a y, \a w and \a h. + + \sa setHBarGeometry() +*/ +void Q3ScrollView::setVBarGeometry(QScrollBar& vbar, + int x, int y, int w, int h) +{ + vbar.setGeometry(x, y, w, h); +} + + +/*! + Returns the viewport size for size (\a x, \a y). + + The viewport size depends on (\a x, \a y) (the size of the contents), + the size of this widget and the modes of the horizontal and + vertical scroll bars. + + This function permits widgets that can trade vertical and + horizontal space for each other to control scroll bar appearance + better. For example, a word processor or web browser can control + the width of the right margin accurately, whether or not there + needs to be a vertical scroll bar. +*/ + +QSize Q3ScrollView::viewportSize(int x, int y) const +{ + int fw = frameWidth(); + int lmarg = fw+d->l_marg; + int rmarg = fw+d->r_marg; + int tmarg = fw+d->t_marg; + int bmarg = fw+d->b_marg; + + int w = width(); + int h = height(); + + bool needh, needv; + bool showh, showv; + int hsbExt = horizontalScrollBar()->sizeHint().height(); + int vsbExt = verticalScrollBar()->sizeHint().width(); + + if (d->policy != AutoOne || d->anyVisibleChildren()) { + // Do we definitely need the scroll bar? + needh = w-lmarg-rmarg < x; + needv = h-tmarg-bmarg < y; + + // Do we intend to show the scroll bar? + if (d->hMode == AlwaysOn) + showh = true; + else if (d->hMode == AlwaysOff) + showh = false; + else + showh = needh; + + if (d->vMode == AlwaysOn) + showv = true; + else if (d->vMode == AlwaysOff) + showv = false; + else + showv = needv; + + // Given other scroll bar will be shown, NOW do we need one? + if (showh && h-vsbExt-tmarg-bmarg < y) { + if (d->vMode == Auto) + showv=true; + } + if (showv && w-hsbExt-lmarg-rmarg < x) { + if (d->hMode == Auto) + showh=true; + } + } else { + // Scroll bars not needed, only show scroll bar that are always on. + showh = d->hMode == AlwaysOn; + showv = d->vMode == AlwaysOn; + } + + return QSize(w-lmarg-rmarg - (showv ? vsbExt : 0), + h-tmarg-bmarg - (showh ? hsbExt : 0)); +} + + +/*! + Updates scroll bars: all possibilities are considered. You should + never need to call this in your code. +*/ +void Q3ScrollView::updateScrollBars() +{ + if(!horizontalScrollBar() && !verticalScrollBar()) + return; + + // I support this should use viewportSize()... but it needs + // so many of the temporary variables from viewportSize. hm. + int fw = frameWidth(); + int lmarg = fw+d->l_marg; + int rmarg = fw+d->r_marg; + int tmarg = fw+d->t_marg; + int bmarg = fw+d->b_marg; + + int w = width(); + int h = height(); + + int portw, porth; + + bool needh; + bool needv; + bool showh; + bool showv; + bool showc = false; + + int hsbExt = horizontalScrollBar()->sizeHint().height(); + int vsbExt = verticalScrollBar()->sizeHint().width(); + + QSize oldVisibleSize(visibleWidth(), visibleHeight()); + + if (d->policy != AutoOne || d->anyVisibleChildren()) { + // Do we definitely need the scroll bar? + needh = w-lmarg-rmarg < d->contentsWidth(); + if (d->inresize) + needh = !horizontalScrollBar()->isHidden(); + needv = h-tmarg-bmarg < contentsHeight(); + + // Do we intend to show the scroll bar? + if (d->hMode == AlwaysOn) + showh = true; + else if (d->hMode == AlwaysOff) + showh = false; + else + showh = needh; + + if (d->vMode == AlwaysOn) + showv = true; + else if (d->vMode == AlwaysOff) + showv = false; + else + showv = needv; + +#ifdef Q_WS_MAC + bool mac_need_scroll = false; + if(!parentWidget()) { + mac_need_scroll = true; + } else { + QWidget *tlw = window(); +#ifndef QT_MAC_USE_COCOA + QPoint tlw_br = QPoint(tlw->width(), tlw->height()), + my_br = qt_mac_posInWindow(this) + QPoint(w, h); + if(my_br.x() >= tlw_br.x() - 3 && my_br.y() >= tlw_br.y() - 3) +#endif + mac_need_scroll = true; + } + if(mac_need_scroll) { +#ifndef QT_MAC_USE_COCOA + WindowAttributes attr; + GetWindowAttributes((WindowPtr)handle(), &attr); + mac_need_scroll = (attr & kWindowResizableAttribute); +#endif + } + if(mac_need_scroll) { + showc = true; + if(d->vMode == Auto) + showv = true; + if(d->hMode == Auto) + showh = true; + } +#endif + + // Given other scroll bar will be shown, NOW do we need one? + if (showh && h-vsbExt-tmarg-bmarg < contentsHeight()) { + needv=true; + if (d->vMode == Auto) + showv=true; + } + if (showv && !d->inresize && w-hsbExt-lmarg-rmarg < d->contentsWidth()) { + needh=true; + if (d->hMode == Auto) + showh=true; + } + } else { + // Scrollbars not needed, only show scroll bar that are always on. + needh = needv = false; + showh = d->hMode == AlwaysOn; + showv = d->vMode == AlwaysOn; + } + + bool sc = d->signal_choke; + d->signal_choke=true; + + // Hide unneeded scroll bar, calculate viewport size + if (showh) { + porth=h-hsbExt-tmarg-bmarg; + } else { + if (!needh) + d->hbar->setValue(0); + d->hbar->hide(); + porth=h-tmarg-bmarg; + } + if (showv) { + portw=w-vsbExt-lmarg-rmarg; + } else { + if (!needv) + d->vbar->setValue(0); + d->vbar->hide(); + portw=w-lmarg-rmarg; + } + + // Configure scroll bars that we will show + if (needv) { + d->vbar->setRange(0, contentsHeight()-porth); + d->vbar->setSteps(Q3ScrollView::d->vbar->lineStep(), porth); + } else { + d->vbar->setRange(0, 0); + } + if (needh) { + d->hbar->setRange(0, QMAX(0, d->contentsWidth()-portw)); + d->hbar->setSteps(Q3ScrollView::d->hbar->lineStep(), portw); + } else { + d->hbar->setRange(0, 0); + } + + // Position the scroll bars, viewport and corner widget. + int bottom; + bool reverse = QApplication::reverseLayout(); + int xoffset = (reverse && (showv || cornerWidget())) ? vsbExt : 0; + int xpos = reverse ? 0 : w - vsbExt; + bool frameContentsOnly = + style()->styleHint(QStyle::SH_ScrollView_FrameOnlyAroundContents); + + if(! frameContentsOnly) { + if (reverse) + xpos += fw; + else + xpos -= fw; + } + if (showh) { + int right = (showc || showv || cornerWidget()) ? w-vsbExt : w; + if (! frameContentsOnly) + setHBarGeometry(*d->hbar, fw + xoffset, h-hsbExt-fw, + right-fw-fw, hsbExt); + else + setHBarGeometry(*d->hbar, 0 + xoffset, h-hsbExt, right, + hsbExt); + bottom=h-hsbExt; + } else { + bottom=h; + } + if (showv) { + clipper()->setGeometry(lmarg + xoffset, tmarg, + w-vsbExt-lmarg-rmarg, + bottom-tmarg-bmarg); + d->viewportResized(w-vsbExt-lmarg-rmarg, bottom-tmarg-bmarg); + if (! frameContentsOnly) + changeFrameRect(QRect(0, 0, w, h)); + else + changeFrameRect(QRect(xoffset, 0, w-vsbExt, bottom)); + if (showc || cornerWidget()) { + if (! frameContentsOnly) + setVBarGeometry(*d->vbar, xpos, + fw, vsbExt, + h-hsbExt-fw-fw); + else + setVBarGeometry(*d->vbar, xpos, 0, + vsbExt, + h-hsbExt); + } + else { + if (! frameContentsOnly) + setVBarGeometry(*d->vbar, xpos, + fw, vsbExt, + bottom-fw-fw); + else + setVBarGeometry(*d->vbar, xpos, 0, + vsbExt, bottom); + } + } else { + if (! frameContentsOnly) + changeFrameRect(QRect(0, 0, w, h)); + else + changeFrameRect(QRect(0, 0, w, bottom)); + clipper()->setGeometry(lmarg, tmarg, + w-lmarg-rmarg, bottom-tmarg-bmarg); + d->viewportResized(w-lmarg-rmarg, bottom-tmarg-bmarg); + } + + QWidget *corner = d->corner; + if (d->corner) { + if (! frameContentsOnly) + corner->setGeometry(xpos, + h-hsbExt-fw, + vsbExt, + hsbExt); + else + corner->setGeometry(xpos, + h-hsbExt, + vsbExt, + hsbExt); + } + + d->signal_choke=sc; + + if (d->contentsX()+visibleWidth() > d->contentsWidth()) { + int x; +#if 0 + if (reverse) + x =QMIN(0,d->contentsWidth()-visibleWidth()); + else +#endif + x =QMAX(0,d->contentsWidth()-visibleWidth()); + d->hbar->setValue(x); + // Do it even if it is recursive + moveContents(-x, -d->contentsY()); + } + if (d->contentsY()+visibleHeight() > contentsHeight()) { + int y=QMAX(0,contentsHeight()-visibleHeight()); + d->vbar->setValue(y); + // Do it even if it is recursive + moveContents(-d->contentsX(), -y); + } + + // Finally, show the scroll bars + if (showh && (d->hbar->isHidden() || !d->hbar->isVisible())) + d->hbar->show(); + if (showv && (d->vbar->isHidden() || !d->vbar->isVisible())) + d->vbar->show(); + + d->signal_choke=true; + d->vbar->setValue(d->contentsY()); + d->hbar->setValue(d->contentsX()); + d->signal_choke=false; + + QSize newVisibleSize(visibleWidth(), visibleHeight()); + if (d->clipped_viewport && oldVisibleSize != newVisibleSize) { + QResizeEvent e(newVisibleSize, oldVisibleSize); + viewportResizeEvent(&e); + } +} + + +/*! + \reimp +*/ +void Q3ScrollView::setVisible(bool visible) +{ + if (visible && !isVisible()) { + QWidget::setVisible(visible); + updateScrollBars(); + d->hideOrShowAll(this); + } else { + QWidget::setVisible(visible); + } +} + +/*! + \internal + */ +void Q3ScrollView::resize(int w, int h) +{ + QWidget::resize(w, h); +} + +/*! + \internal +*/ +void Q3ScrollView::resize(const QSize& s) +{ + resize(s.width(), s.height()); +} + +/*! + \reimp +*/ +void Q3ScrollView::resizeEvent(QResizeEvent* event) +{ + Q3Frame::resizeEvent(event); + +#if 0 + if (QApplication::reverseLayout()) { + d->fake_scroll = true; + scrollBy(-event->size().width() + event->oldSize().width(), 0); + d->fake_scroll = false; + } +#endif + + bool inresize = d->inresize; + d->inresize = true; + updateScrollBars(); + d->inresize = inresize; + d->scrollbar_timer.start(0, true); + + d->hideOrShowAll(this); +} + + + +/*! + \reimp +*/ +void Q3ScrollView::mousePressEvent(QMouseEvent * e) +{ + e->ignore(); +} + +/*! + \reimp +*/ +void Q3ScrollView::mouseReleaseEvent(QMouseEvent *e) +{ + e->ignore(); +} + + +/*! + \reimp +*/ +void Q3ScrollView::mouseDoubleClickEvent(QMouseEvent *e) +{ + e->ignore(); +} + +/*! + \reimp +*/ +void Q3ScrollView::mouseMoveEvent(QMouseEvent *e) +{ + e->ignore(); +} + +/*! + \reimp +*/ +#ifndef QT_NO_WHEELEVENT +void Q3ScrollView::wheelEvent(QWheelEvent *e) +{ + QWheelEvent ce(viewport()->mapFromGlobal(e->globalPos()), + e->globalPos(), e->delta(), e->state()); + viewportWheelEvent(&ce); + if (!ce.isAccepted()) { + if (e->orientation() == Horizontal && horizontalScrollBar()) + horizontalScrollBar()->event(e); + else if (e->orientation() == Vertical && verticalScrollBar()) + verticalScrollBar()->event(e); + } else { + e->accept(); + } +} +#endif + +/*! + \reimp +*/ +void Q3ScrollView::contextMenuEvent(QContextMenuEvent *e) +{ + if (e->reason() != QContextMenuEvent::Keyboard) { + e->ignore(); + return; + } + + QContextMenuEvent ce(e->reason(), viewport()->mapFromGlobal(e->globalPos()), + e->globalPos(), e->state()); + viewportContextMenuEvent(&ce); + if (ce.isAccepted()) + e->accept(); + else + e->ignore(); +} + +Q3ScrollView::ScrollBarMode Q3ScrollView::vScrollBarMode() const +{ + return d->vMode; +} + + +/*! + \enum Q3ScrollView::ScrollBarMode + + This enum type describes the various modes of Q3ScrollView's scroll + bars. + + \value Auto Q3ScrollView shows a scroll bar when the content is + too large to fit and not otherwise. This is the default. + + \value AlwaysOff Q3ScrollView never shows a scroll bar. + + \value AlwaysOn Q3ScrollView always shows a scroll bar. + + (The modes for the horizontal and vertical scroll bars are + independent.) +*/ + + +/*! + \property Q3ScrollView::vScrollBarMode + \brief the mode for the vertical scroll bar + + The default mode is Q3ScrollView::Auto. + + \sa hScrollBarMode +*/ +void Q3ScrollView::setVScrollBarMode(ScrollBarMode mode) +{ + if (d->vMode != mode) { + d->vMode = mode; + updateScrollBars(); + } +} + + +/*! + \property Q3ScrollView::hScrollBarMode + \brief the mode for the horizontal scroll bar + + The default mode is Q3ScrollView::Auto. + + \sa vScrollBarMode +*/ +Q3ScrollView::ScrollBarMode Q3ScrollView::hScrollBarMode() const +{ + return d->hMode; +} + +void Q3ScrollView::setHScrollBarMode(ScrollBarMode mode) +{ + if (d->hMode != mode) { + d->hMode = mode; + updateScrollBars(); + } +} + + +/*! + Returns the widget in the corner between the two scroll bars. + + By default, no corner widget is present. +*/ +QWidget* Q3ScrollView::cornerWidget() const +{ + return d->corner; +} + +/*! + Sets the widget in the \a corner between the two scroll bars. + + You will probably also want to set at least one of the scroll bar + modes to \c AlwaysOn. + + Passing 0 shows no widget in the corner. + + Any previous \a corner widget is hidden. + + You may call setCornerWidget() with the same widget at different + times. + + All widgets set here will be deleted by the Q3ScrollView when it is + destroyed unless you separately reparent the widget after setting + some other corner widget (or 0). + + Any \e newly set widget should have no current parent. + + By default, no corner widget is present. + + \sa setVScrollBarMode(), setHScrollBarMode() +*/ +void Q3ScrollView::setCornerWidget(QWidget* corner) +{ + QWidget* oldcorner = d->corner; + if (oldcorner != corner) { + if (oldcorner) oldcorner->hide(); + d->corner = corner; + if (corner) corner->setParent(this); + updateScrollBars(); + if (corner) corner->show(); + } +} + + +void Q3ScrollView::setResizePolicy(ResizePolicy r) +{ + d->policy = r; +} + +/*! + \property Q3ScrollView::resizePolicy + \brief the resize policy + + The default is \c Default. + + \sa ResizePolicy +*/ +Q3ScrollView::ResizePolicy Q3ScrollView::resizePolicy() const +{ + return d->policy; +} + +/*! + \internal +*/ +void Q3ScrollView::setEnabled(bool enable) +{ + Q3Frame::setEnabled(enable); +} + +/*! + Removes the \a child widget from the scrolled area. Note that this + happens automatically if the \a child is deleted. +*/ +void Q3ScrollView::removeChild(QWidget* child) +{ + if (!d || !child) // First check in case we are destructing + return; + + QSVChildRec *r = d->rec(child); + if (r) d->deleteChildRec(r); +} + +/*! + \internal +*/ +void Q3ScrollView::removeChild(QObject* child) +{ + Q3Frame::removeChild(child); +} + +/*! + Inserts the widget, \a child, into the scrolled area positioned at + (\a x, \a y). The position defaults to (0, 0). If the child is + already in the view, it is just moved. + + You may want to call enableClipper(true) if you add a large number + of widgets. +*/ +void Q3ScrollView::addChild(QWidget* child, int x, int y) +{ + if (!child) { +#if defined(QT_CHECK_NULL) + qWarning("Q3ScrollView::addChild(): Cannot add null child"); +#endif + return; + } + child->polish(); + child->setBackgroundOrigin(WidgetOrigin); + + if (child->parentWidget() == viewport()) { + // May already be there + QSVChildRec *r = d->rec(child); + if (r) { + r->moveTo(this,x,y,d->clipped_viewport); + if (d->policy > Manual) { + d->autoResizeHint(this); + d->autoResize(this); // #### better to just deal with this one widget! + } + return; + } + } + + if (d->children.isEmpty() && d->policy != Manual) { + if (d->policy == Default) + setResizePolicy(AutoOne); + child->installEventFilter(this); + } else if (d->policy == AutoOne) { + child->removeEventFilter(this); //#### ????? + setResizePolicy(Manual); + } + if (child->parentWidget() != viewport()) { + child->reparent(viewport(), 0, QPoint(0,0), false); + } + d->addChildRec(child,x,y)->hideOrShow(this, d->clipped_viewport); + + if (d->policy > Manual) { + d->autoResizeHint(this); + d->autoResize(this); // #### better to just deal with this one widget! + } +} + +/*! + Repositions the \a child widget to (\a x, \a y). This function is + the same as addChild(). +*/ +void Q3ScrollView::moveChild(QWidget* child, int x, int y) +{ + addChild(child,x,y); +} + +/*! + Returns the X position of the given \a child widget. Use this + rather than QWidget::x() for widgets added to the view. + + This function returns 0 if \a child has not been added to the view. +*/ +int Q3ScrollView::childX(QWidget* child) +{ + QSVChildRec *r = d->rec(child); + return r ? r->x : 0; +} + +/*! + Returns the Y position of the given \a child widget. Use this + rather than QWidget::y() for widgets added to the view. + + This function returns 0 if \a child has not been added to the view. +*/ +int Q3ScrollView::childY(QWidget* child) +{ + QSVChildRec *r = d->rec(child); + return r ? r->y : 0; +} + +/*! \fn bool Q3ScrollView::childIsVisible(QWidget*) + \obsolete + + Returns true if \a child is visible. This is equivalent + to child->isVisible(). +*/ + +/*! \fn void Q3ScrollView::showChild(QWidget* child, bool y) + \obsolete + + Sets the visibility of \a child. Equivalent to + QWidget::show() or QWidget::hide(). +*/ + +/*! + This event filter ensures the scroll bars are updated when a + single contents widget is resized, shown, hidden or destroyed; it + passes mouse events to the Q3ScrollView. The event is in \a e and + the object is in \a obj. +*/ + +bool Q3ScrollView::eventFilter(QObject *obj, QEvent *e) +{ + bool disabled = !(qobject_cast<QWidget*>(obj)->isEnabled()); + if (!d) + return false; // we are destructing + if (obj == d->viewport || obj == d->clipped_viewport) { + switch (e->type()) { + /* Forward many events to viewport...() functions */ + case QEvent::Paint: + viewportPaintEvent((QPaintEvent*)e); + break; + case QEvent::Resize: + if (!d->clipped_viewport) + viewportResizeEvent((QResizeEvent *)e); + break; + case QEvent::MouseButtonPress: + if (disabled) + return false; + viewportMousePressEvent((QMouseEvent*)e); + if (((QMouseEvent*)e)->isAccepted()) + return true; + break; + case QEvent::MouseButtonRelease: + if (disabled) + return false; + viewportMouseReleaseEvent((QMouseEvent*)e); + if (((QMouseEvent*)e)->isAccepted()) + return true; + break; + case QEvent::MouseButtonDblClick: + if (disabled) + return false; + viewportMouseDoubleClickEvent((QMouseEvent*)e); + if (((QMouseEvent*)e)->isAccepted()) + return true; + break; + case QEvent::MouseMove: + if (disabled) + return false; + viewportMouseMoveEvent((QMouseEvent*)e); + if (((QMouseEvent*)e)->isAccepted()) + return true; + break; +#ifndef QT_NO_DRAGANDDROP + case QEvent::DragEnter: + if (disabled) + return false; + viewportDragEnterEvent((QDragEnterEvent*)e); + break; + case QEvent::DragMove: { + if (disabled) + return false; + if (d->drag_autoscroll) { + QPoint vp = ((QDragMoveEvent*) e)->pos(); + QRect inside_margin(autoscroll_margin, autoscroll_margin, + visibleWidth() - autoscroll_margin * 2, + visibleHeight() - autoscroll_margin * 2); + if (!inside_margin.contains(vp)) { + startDragAutoScroll(); + // Keep sending move events + ((QDragMoveEvent*)e)->accept(QRect(0,0,0,0)); + } + } + viewportDragMoveEvent((QDragMoveEvent*)e); + } break; + case QEvent::DragLeave: + if (disabled) + return false; + stopDragAutoScroll(); + viewportDragLeaveEvent((QDragLeaveEvent*)e); + break; + case QEvent::Drop: + if (disabled) + return false; + stopDragAutoScroll(); + viewportDropEvent((QDropEvent*)e); + break; +#endif // QT_NO_DRAGANDDROP +#ifndef QT_NO_WHEELEVENT + case QEvent::Wheel: + if (disabled) + return false; + break; +#endif + case QEvent::ContextMenu: + if (disabled) + return false; + viewportContextMenuEvent((QContextMenuEvent*)e); + if (((QContextMenuEvent*)e)->isAccepted()) + return true; + break; + case QEvent::ChildRemoved: + removeChild((QWidget*)((QChildEvent*)e)->child()); + break; + case QEvent::LayoutHint: + d->autoResizeHint(this); + break; + default: + break; + } + } else if (d && d->rec((QWidget*)obj)) { // must be a child + if (e->type() == QEvent::Resize) + d->autoResize(this); + else if (e->type() == QEvent::Move) + d->autoMove(this); + } + return Q3Frame::eventFilter(obj, e); // always continue with standard event processing +} + +/*! + This event handler is called whenever the Q3ScrollView receives a + mousePressEvent(): the press position in \a e is translated to be a point + on the contents. +*/ +void Q3ScrollView::contentsMousePressEvent(QMouseEvent* e) +{ + e->ignore(); +} + +/*! + This event handler is called whenever the Q3ScrollView receives a + mouseReleaseEvent(): the release position in \a e is translated to be a + point on the contents. +*/ +void Q3ScrollView::contentsMouseReleaseEvent(QMouseEvent* e) +{ + e->ignore(); +} + +/*! + This event handler is called whenever the Q3ScrollView receives a + mouseDoubleClickEvent(): the click position in \a e is translated to be a + point on the contents. + + The default implementation generates a normal mouse press event. +*/ +void Q3ScrollView::contentsMouseDoubleClickEvent(QMouseEvent* e) +{ + contentsMousePressEvent(e); // try mouse press event +} + +/*! + This event handler is called whenever the Q3ScrollView receives a + mouseMoveEvent(): the mouse position in \a e is translated to be a point + on the contents. +*/ +void Q3ScrollView::contentsMouseMoveEvent(QMouseEvent* e) +{ + e->ignore(); +} + +#ifndef QT_NO_DRAGANDDROP + +/*! + This event handler is called whenever the Q3ScrollView receives a + dragEnterEvent(): the drag position is translated to be a point + on the contents. + + The default implementation does nothing. The \a event parameter is + ignored. +*/ +void Q3ScrollView::contentsDragEnterEvent(QDragEnterEvent * /* event */) +{ +} + +/*! + This event handler is called whenever the Q3ScrollView receives a + dragMoveEvent(): the drag position is translated to be a point on + the contents. + + The default implementation does nothing. The \a event parameter is + ignored. +*/ +void Q3ScrollView::contentsDragMoveEvent(QDragMoveEvent * /* event */) +{ +} + +/*! + This event handler is called whenever the Q3ScrollView receives a + dragLeaveEvent(): the drag position is translated to be a point + on the contents. + + The default implementation does nothing. The \a event parameter is + ignored. +*/ +void Q3ScrollView::contentsDragLeaveEvent(QDragLeaveEvent * /* event */) +{ +} + +/*! + This event handler is called whenever the Q3ScrollView receives a + dropEvent(): the drop position is translated to be a point on the + contents. + + The default implementation does nothing. The \a event parameter is + ignored. +*/ + +void Q3ScrollView::contentsDropEvent(QDropEvent * /* event */) +{ +} + +#endif // QT_NO_DRAGANDDROP + +/*! + This event handler is called whenever the Q3ScrollView receives a + wheelEvent() in \a{e}: the mouse position is translated to be a + point on the contents. +*/ +#ifndef QT_NO_WHEELEVENT +void Q3ScrollView::contentsWheelEvent(QWheelEvent * e) +{ + e->ignore(); +} +#endif +/*! + This event handler is called whenever the Q3ScrollView receives a + contextMenuEvent() in \a{e}: the mouse position is translated to + be a point on the contents. +*/ +void Q3ScrollView::contentsContextMenuEvent(QContextMenuEvent *e) +{ + e->ignore(); +} + +/*! + This is a low-level painting routine that draws the viewport + contents. Reimplement this if drawContents() is too high-level + (for example, if you don't want to open a QPainter on the + viewport). The paint event is passed in \a pe. +*/ +void Q3ScrollView::viewportPaintEvent(QPaintEvent* pe) +{ + QWidget* vp = viewport(); + + QPainter p(vp); + QRect r = pe->rect(); + + if (d->clipped_viewport) { + QRect rr( + -d->clipped_viewport->x(), -d->clipped_viewport->y(), + d->viewport->width(), d->viewport->height() + ); + r &= rr; + if (r.isValid()) { + int ex = r.x() + d->clipped_viewport->x() + d->contentsX(); + int ey = r.y() + d->clipped_viewport->y() + d->contentsY(); + int ew = r.width(); + int eh = r.height(); + drawContentsOffset(&p, + d->contentsX()+d->clipped_viewport->x(), + d->contentsY()+d->clipped_viewport->y(), + ex, ey, ew, eh); + } + } else { + r &= d->viewport->rect(); + int ex = r.x() + d->contentsX(); + int ey = r.y() + d->contentsY(); + int ew = r.width(); + int eh = r.height(); + drawContentsOffset(&p, d->contentsX(), d->contentsY(), ex, ey, ew, eh); + } +} + + +/*! + To provide simple processing of events on the contents, this + function receives all resize events sent to the viewport. + + The default implementation does nothing. The \a event parameter is + ignored. + + \sa QWidget::resizeEvent() +*/ +void Q3ScrollView::viewportResizeEvent(QResizeEvent * /* event */) +{ +} + +/*! \internal + + To provide simple processing of events on the contents, this + function receives all mouse press events sent to the viewport, + translates the event and calls contentsMousePressEvent(). + + \sa contentsMousePressEvent(), QWidget::mousePressEvent() +*/ +void Q3ScrollView::viewportMousePressEvent(QMouseEvent* e) +{ + QMouseEvent ce(e->type(), viewportToContents(e->pos()), + e->globalPos(), e->button(), e->state()); + contentsMousePressEvent(&ce); + if (!ce.isAccepted()) + e->ignore(); +} + +/*!\internal + + To provide simple processing of events on the contents, this function + receives all mouse release events sent to the viewport, translates + the event and calls contentsMouseReleaseEvent(). + + \sa QWidget::mouseReleaseEvent() +*/ +void Q3ScrollView::viewportMouseReleaseEvent(QMouseEvent* e) +{ + QMouseEvent ce(e->type(), viewportToContents(e->pos()), + e->globalPos(), e->button(), e->state()); + contentsMouseReleaseEvent(&ce); + if (!ce.isAccepted()) + e->ignore(); +} + +/*!\internal + + To provide simple processing of events on the contents, this function + receives all mouse double click events sent to the viewport, + translates the event and calls contentsMouseDoubleClickEvent(). + + \sa QWidget::mouseDoubleClickEvent() +*/ +void Q3ScrollView::viewportMouseDoubleClickEvent(QMouseEvent* e) +{ + QMouseEvent ce(e->type(), viewportToContents(e->pos()), + e->globalPos(), e->button(), e->state()); + contentsMouseDoubleClickEvent(&ce); + if (!ce.isAccepted()) + e->ignore(); +} + +/*!\internal + + To provide simple processing of events on the contents, this function + receives all mouse move events sent to the viewport, translates the + event and calls contentsMouseMoveEvent(). + + \sa QWidget::mouseMoveEvent() +*/ +void Q3ScrollView::viewportMouseMoveEvent(QMouseEvent* e) +{ + QMouseEvent ce(e->type(), viewportToContents(e->pos()), + e->globalPos(), e->button(), e->state()); + contentsMouseMoveEvent(&ce); + if (!ce.isAccepted()) + e->ignore(); +} + +#ifndef QT_NO_DRAGANDDROP + +/*!\internal + + To provide simple processing of events on the contents, this function + receives all drag enter events sent to the viewport, translates the + event and calls contentsDragEnterEvent(). + + \sa QWidget::dragEnterEvent() +*/ +void Q3ScrollView::viewportDragEnterEvent(QDragEnterEvent* e) +{ + e->setPoint(viewportToContents(e->pos())); + contentsDragEnterEvent(e); + e->setPoint(contentsToViewport(e->pos())); +} + +/*!\internal + + To provide simple processing of events on the contents, this function + receives all drag move events sent to the viewport, translates the + event and calls contentsDragMoveEvent(). + + \sa QWidget::dragMoveEvent() +*/ +void Q3ScrollView::viewportDragMoveEvent(QDragMoveEvent* e) +{ + e->setPoint(viewportToContents(e->pos())); + contentsDragMoveEvent(e); + e->setPoint(contentsToViewport(e->pos())); +} + +/*!\internal + + To provide simple processing of events on the contents, this function + receives all drag leave events sent to the viewport and calls + contentsDragLeaveEvent(). + + \sa QWidget::dragLeaveEvent() +*/ +void Q3ScrollView::viewportDragLeaveEvent(QDragLeaveEvent* e) +{ + contentsDragLeaveEvent(e); +} + +/*!\internal + + To provide simple processing of events on the contents, this function + receives all drop events sent to the viewport, translates the event + and calls contentsDropEvent(). + + \sa QWidget::dropEvent() +*/ +void Q3ScrollView::viewportDropEvent(QDropEvent* e) +{ + e->setPoint(viewportToContents(e->pos())); + contentsDropEvent(e); + e->setPoint(contentsToViewport(e->pos())); +} + +#endif // QT_NO_DRAGANDDROP + +/*!\internal + + To provide simple processing of events on the contents, this function + receives all wheel events sent to the viewport, translates the + event and calls contentsWheelEvent(). + + \sa QWidget::wheelEvent() +*/ +#ifndef QT_NO_WHEELEVENT +void Q3ScrollView::viewportWheelEvent(QWheelEvent* e) +{ + /* + Different than standard mouse events, because wheel events might + be sent to the focus widget if the widget-under-mouse doesn't want + the event itself. + */ + QWheelEvent ce(viewportToContents(e->pos()), + e->globalPos(), e->delta(), e->state()); + contentsWheelEvent(&ce); + if (ce.isAccepted()) + e->accept(); + else + e->ignore(); +} +#endif + +/*! \internal + + To provide simple processing of events on the contents, this function + receives all context menu events sent to the viewport, translates the + event and calls contentsContextMenuEvent(). +*/ +void Q3ScrollView::viewportContextMenuEvent(QContextMenuEvent *e) +{ + QContextMenuEvent ce(e->reason(), viewportToContents(e->pos()), e->globalPos(), e->state()); + contentsContextMenuEvent(&ce); + if (ce.isAccepted()) + e->accept(); + else + e->ignore(); +} + +/*! + Returns the component horizontal scroll bar. It is made available + to allow accelerators, autoscrolling, etc. + + It should not be used for other purposes. + + This function never returns 0. +*/ +QScrollBar* Q3ScrollView::horizontalScrollBar() const +{ + return d->hbar; +} + +/*! + Returns the component vertical scroll bar. It is made available to + allow accelerators, autoscrolling, etc. + + It should not be used for other purposes. + + This function never returns 0. +*/ +QScrollBar* Q3ScrollView::verticalScrollBar() const { + return d->vbar; +} + + +/*! + Scrolls the content so that the point (\a x, \a y) is visible with at + least 50-pixel margins (if possible, otherwise centered). +*/ +void Q3ScrollView::ensureVisible(int x, int y) +{ + ensureVisible(x, y, 50, 50); +} + +/*! + \overload + + Scrolls the content so that the point (\a x, \a y) is visible with at + least the \a xmargin and \a ymargin margins (if possible, + otherwise centered). +*/ +void Q3ScrollView::ensureVisible(int x, int y, int xmargin, int ymargin) +{ + int pw=visibleWidth(); + int ph=visibleHeight(); + + int cx=-d->contentsX(); + int cy=-d->contentsY(); + int cw=d->contentsWidth(); + int ch=contentsHeight(); + + if (pw < xmargin*2) + xmargin=pw/2; + if (ph < ymargin*2) + ymargin=ph/2; + + if (cw <= pw) { + xmargin=0; + cx=0; + } + if (ch <= ph) { + ymargin=0; + cy=0; + } + + if (x < -cx+xmargin) + cx = -x+xmargin; + else if (x >= -cx+pw-xmargin) + cx = -x+pw-xmargin; + + if (y < -cy+ymargin) + cy = -y+ymargin; + else if (y >= -cy+ph-ymargin) + cy = -y+ph-ymargin; + + if (cx > 0) + cx=0; + else if (cx < pw-cw && cw>pw) + cx=pw-cw; + + if (cy > 0) + cy=0; + else if (cy < ph-ch && ch>ph) + cy=ph-ch; + + setContentsPos(-cx, -cy); +} + +/*! + Scrolls the content so that the point (\a x, \a y) is in the top-left + corner. +*/ +void Q3ScrollView::setContentsPos(int x, int y) +{ +#if 0 + // bounds checking... + if (QApplication::reverseLayout()) + if (x > d->contentsWidth() - visibleWidth()) x = d->contentsWidth() - visibleWidth(); + else +#endif + if (x < 0) x = 0; + if (y < 0) y = 0; + // Choke signal handling while we update BOTH sliders. + d->signal_choke=true; + moveContents(-x, -y); + d->vbar->setValue(y); + d->hbar->setValue(x); + d->signal_choke=false; +} + +/*! + Scrolls the content by \a dx to the left and \a dy upwards. +*/ +void Q3ScrollView::scrollBy(int dx, int dy) +{ + setContentsPos(QMAX(d->contentsX()+dx, 0), QMAX(d->contentsY()+dy, 0)); +} + +/*! + Scrolls the content so that the point (\a x, \a y) is in the center + of visible area. +*/ +void Q3ScrollView::center(int x, int y) +{ + ensureVisible(x, y, 32000, 32000); +} + +/*! + \overload + + Scrolls the content so that the point (\a x, \a y) is visible with + the \a xmargin and \a ymargin margins (as fractions of visible + the area). + + For example: + \list + \i Margin 0.0 allows (x, y) to be on the edge of the visible area. + \i Margin 0.5 ensures that (x, y) is in middle 50% of the visible area. + \i Margin 1.0 ensures that (x, y) is in the center of the visible area. + \endlist +*/ +void Q3ScrollView::center(int x, int y, float xmargin, float ymargin) +{ + int pw=visibleWidth(); + int ph=visibleHeight(); + ensureVisible(x, y, int(xmargin/2.0*pw+0.5), int(ymargin/2.0*ph+0.5)); +} + + +/*! + \fn void Q3ScrollView::contentsMoving(int x, int y) + + This signal is emitted just before the contents are moved to + position (\a x, \a y). + + \sa contentsX(), contentsY() +*/ + +/*! + Moves the contents by (\a x, \a y). +*/ +void Q3ScrollView::moveContents(int x, int y) +{ + if (-x+visibleWidth() > d->contentsWidth()) +#if 0 + if(QApplication::reverseLayout()) + x=QMAX(0,-d->contentsWidth()+visibleWidth()); + else +#endif + x=QMIN(0,-d->contentsWidth()+visibleWidth()); + if (-y+visibleHeight() > contentsHeight()) + y=QMIN(0,-contentsHeight()+visibleHeight()); + + int dx = x - d->vx; + int dy = y - d->vy; + + if (!dx && !dy) + return; // Nothing to do + + emit contentsMoving(-x, -y); + + d->vx = x; + d->vy = y; + + if (d->clipped_viewport || d->static_bg) { + // Cheap move (usually) + d->moveAllBy(dx,dy); + } else if (/*dx && dy ||*/ + (QABS(dy) * 5 > visibleHeight() * 4) || + (QABS(dx) * 5 > visibleWidth() * 4) + ) + { + // Big move + if (viewport()->updatesEnabled()) + viewport()->update(); + d->moveAllBy(dx,dy); + } else if (!d->fake_scroll || d->contentsWidth() > visibleWidth()) { + // Small move + clipper()->scroll(dx,dy); + } + d->hideOrShowAll(this, true); +} + +/*! + \property Q3ScrollView::contentsX + \brief the X coordinate of the contents that are at the left edge of + the viewport. +*/ +int Q3ScrollView::contentsX() const +{ + return d->contentsX(); +} + +/*! + \property Q3ScrollView::contentsY + \brief the Y coordinate of the contents that are at the top edge of + the viewport. +*/ +int Q3ScrollView::contentsY() const +{ + return d->contentsY(); +} + +/*! + \property Q3ScrollView::contentsWidth + \brief the width of the contents area +*/ +int Q3ScrollView::contentsWidth() const +{ + return d->contentsWidth(); +} + +/*! + \property Q3ScrollView::contentsHeight + \brief the height of the contents area +*/ +int Q3ScrollView::contentsHeight() const +{ + return d->vheight; +} + +/*! + Sets the size of the contents area to \a w pixels wide and \a h + pixels high and updates the viewport accordingly. +*/ +void Q3ScrollView::resizeContents(int w, int h) +{ + int ow = d->vwidth; + int oh = d->vheight; + d->vwidth = w; + d->vheight = h; + + d->scrollbar_timer.start(0, true); + + if (d->children.isEmpty() && d->policy == Default) + setResizePolicy(Manual); + + if (ow > w) { + // Swap + int t=w; + w=ow; + ow=t; + } + // Refresh area ow..w + if (ow < visibleWidth() && w >= 0) { + if (ow < 0) + ow = 0; + if (w > visibleWidth()) + w = visibleWidth(); + clipper()->update(d->contentsX()+ow, 0, w-ow, visibleHeight()); + } + + if (oh > h) { + // Swap + int t=h; + h=oh; + oh=t; + } + // Refresh area oh..h + if (oh < visibleHeight() && h >= 0) { + if (oh < 0) + oh = 0; + if (h > visibleHeight()) + h = visibleHeight(); + clipper()->update(0, d->contentsY()+oh, visibleWidth(), h-oh); + } +} + +/*! + Calls update() on a rectangle defined by \a x, \a y, \a w, \a h, + translated appropriately. If the rectangle is not visible, nothing + is repainted. + + \sa repaintContents() +*/ +void Q3ScrollView::updateContents(int x, int y, int w, int h) +{ + if (!isVisible() || !updatesEnabled()) + return; + + QWidget* vp = viewport(); + + // Translate + x -= d->contentsX(); + y -= d->contentsY(); + + if (x < 0) { + w += x; + x = 0; + } + if (y < 0) { + h += y; + y = 0; + } + + if (w < 0 || h < 0) + return; + if (x > visibleWidth() || y > visibleHeight()) + return; + + if (w > visibleWidth()) + w = visibleWidth(); + if (h > visibleHeight()) + h = visibleHeight(); + + if (d->clipped_viewport) { + // Translate clipper() to viewport() + x -= d->clipped_viewport->x(); + y -= d->clipped_viewport->y(); + } + + vp->update(x, y, w, h); +} + +/*! + \overload + + Updates the contents in rectangle \a r +*/ +void Q3ScrollView::updateContents(const QRect& r) +{ + updateContents(r.x(), r.y(), r.width(), r.height()); +} + +/*! + \overload +*/ +void Q3ScrollView::updateContents() +{ + updateContents(d->contentsX(), d->contentsY(), visibleWidth(), visibleHeight()); +} + +/*! + \overload + + Repaints the contents of rectangle \a r. If \a erase is true the + background is cleared using the background color. +*/ +void Q3ScrollView::repaintContents(const QRect& r, bool erase) +{ + repaintContents(r.x(), r.y(), r.width(), r.height(), erase); +} + + +/*! + \overload + + Repaints the contents. If \a erase is true the background is + cleared using the background color. +*/ +void Q3ScrollView::repaintContents(bool erase) +{ + repaintContents(d->contentsX(), d->contentsY(), visibleWidth(), visibleHeight(), erase); +} + + +/*! + Calls repaint() on a rectangle defined by \a x, \a y, \a w, \a h, + translated appropriately. If the rectangle is not visible, nothing + is repainted. If \a erase is true the background is cleared using + the background color. + + \sa updateContents() +*/ +void Q3ScrollView::repaintContents(int x, int y, int w, int h, bool /*erase*/) +{ + if (!isVisible() || !updatesEnabled()) + return; + + QWidget* vp = viewport(); + + // Translate logical to clipper() + x -= d->contentsX(); + y -= d->contentsY(); + + if (x < 0) { + w += x; + x = 0; + } + if (y < 0) { + h += y; + y = 0; + } + + if (w < 0 || h < 0) + return; + if (w > visibleWidth()) + w = visibleWidth(); + if (h > visibleHeight()) + h = visibleHeight(); + + if (d->clipped_viewport) { + // Translate clipper() to viewport() + x -= d->clipped_viewport->x(); + y -= d->clipped_viewport->y(); + } + + vp->update(x, y, w, h); +} + + +/*! + For backward-compatibility only. It is easier to use + drawContents(QPainter*,int,int,int,int). + + The default implementation translates the painter appropriately + and calls drawContents(QPainter*,int,int,int,int). See + drawContents() for an explanation of the parameters \a p, \a + offsetx, \a offsety, \a clipx, \a clipy, \a clipw and \a cliph. +*/ +void Q3ScrollView::drawContentsOffset(QPainter* p, int offsetx, int offsety, int clipx, int clipy, int clipw, int cliph) +{ + p->translate(-offsetx,-offsety); + drawContents(p, clipx, clipy, clipw, cliph); +} + +/*! + \fn void Q3ScrollView::drawContents(QPainter* p, int clipx, int clipy, int clipw, int cliph) + + Reimplement this function if you are viewing a drawing area rather + than a widget. + + The function should draw the rectangle (\a clipx, \a clipy, \a + clipw, \a cliph) of the contents using painter \a p. The clip + rectangle is in the scrollview's coordinates. + + For example: + \snippet doc/src/snippets/code/src_qt3support_widgets_q3scrollview.cpp 4 + + The clip rectangle and translation of the painter \a p is already + set appropriately. +*/ +void Q3ScrollView::drawContents(QPainter*, int, int, int, int) +{ +} + + +/*! + \reimp +*/ +void Q3ScrollView::frameChanged() +{ + // slight ugle-hack - the listview header needs readjusting when + // changing the frame + if (Q3ListView *lv = qobject_cast<Q3ListView *>(this)) + lv->triggerUpdate(); + Q3Frame::frameChanged(); + updateScrollBars(); +} + + +/*! + Returns the viewport widget of the scrollview. This is the widget + containing the contents widget or which is the drawing area. +*/ +QWidget* Q3ScrollView::viewport() const +{ + if (d->clipped_viewport) + return d->clipped_viewport; + return d->viewport; +} + +/*! + Returns the clipper widget. Contents in the scrollview are + ultimately clipped to be inside the clipper widget. + + You should not need to use this function. + + \sa visibleWidth(), visibleHeight() +*/ +QWidget* Q3ScrollView::clipper() const +{ + return d->viewport; +} + +/*! + \property Q3ScrollView::visibleWidth + \brief the horizontal amount of the content that is visible +*/ +int Q3ScrollView::visibleWidth() const +{ + return clipper()->width(); +} + +/*! + \property Q3ScrollView::visibleHeight + \brief the vertical amount of the content that is visible +*/ +int Q3ScrollView::visibleHeight() const +{ + return clipper()->height(); +} + + +void Q3ScrollView::changeFrameRect(const QRect& r) +{ + QRect oldr = frameRect(); + if (oldr != r) { + QRect cr = contentsRect(); + QRegion fr(frameRect()); + fr = fr.subtracted(contentsRect()); + setFrameRect(r); + if (isVisible()) { + cr = cr.intersected(contentsRect()); + fr = fr.united(frameRect()); + fr = fr.subtracted(cr); + if (!fr.isEmpty()) + update(fr); + } + } +} + + +/*! + Sets the margins around the scrolling area to \a left, \a top, \a + right and \a bottom. This is useful for applications such as + spreadsheets with "locked" rows and columns. The marginal space is + \e inside the frameRect() and is left blank; reimplement + drawFrame() or put widgets in the unused area. + + By default all margins are zero. + + \sa frameChanged() +*/ +void Q3ScrollView::setMargins(int left, int top, int right, int bottom) +{ + if (left == d->l_marg && + top == d->t_marg && + right == d->r_marg && + bottom == d->b_marg) + return; + + d->l_marg = left; + d->t_marg = top; + d->r_marg = right; + d->b_marg = bottom; + updateScrollBars(); +} + + +/*! + Returns the left margin. + + \sa setMargins() +*/ +int Q3ScrollView::leftMargin() const +{ + return d->l_marg; +} + + +/*! + Returns the top margin. + + \sa setMargins() +*/ +int Q3ScrollView::topMargin() const +{ + return d->t_marg; +} + + +/*! + Returns the right margin. + + \sa setMargins() +*/ +int Q3ScrollView::rightMargin() const +{ + return d->r_marg; +} + + +/*! + Returns the bottom margin. + + \sa setMargins() +*/ +int Q3ScrollView::bottomMargin() const +{ + return d->b_marg; +} + +/*! + \reimp +*/ +bool Q3ScrollView::focusNextPrevChild(bool next) +{ + // Makes sure that the new focus widget is on-screen, if + // necessary by scrolling the scroll view. + bool retval = Q3Frame::focusNextPrevChild(next); + if (retval) { + QWidget *w = window()->focusWidget(); + if (isAncestorOf(w)) { + QSVChildRec *r = d->ancestorRec(w); + if (r && (r->child == w || w->isVisibleTo(r->child))) { + QPoint cp = r->child->mapToGlobal(QPoint(0, 0)); + QPoint cr = w->mapToGlobal(QPoint(0, 0)) - cp; + ensureVisible(r->x + cr.x() + w->width()/2, r->y + cr.y() + w->height()/2, + w->width()/2, w->height()/2); + } + } + } + return retval; +} + + + +/*! + When a large numbers of child widgets are in a scrollview, + especially if they are close together, the scrolling performance + can suffer greatly. If \a y is true the scrollview will use an + extra widget to group child widgets. + + Note that you may only call enableClipper() prior to adding + widgets. +*/ +void Q3ScrollView::enableClipper(bool y) +{ + if (!d->clipped_viewport == !y) + return; + if (d->children.count()) + qFatal("May only call Q3ScrollView::enableClipper() before adding widgets"); + if (y) { + d->clipped_viewport = new QClipperWidget(clipper(), "qt_clipped_viewport", QFlag(d->flags)); + d->clipped_viewport->setGeometry(-coord_limit/2,-coord_limit/2, + coord_limit,coord_limit); + d->clipped_viewport->setBackgroundMode(d->viewport->backgroundMode()); + d->viewport->setBackgroundMode(NoBackground); // no exposures for this + d->viewport->removeEventFilter(this); + d->clipped_viewport->installEventFilter(this); + d->clipped_viewport->show(); + } else { + delete d->clipped_viewport; + d->clipped_viewport = 0; + } +} + +/*! + Sets the scrollview to have a static background if \a y is true, + or a scrolling background if \a y is false. By default, the + background is scrolling. + + Be aware that this mode is quite slow, as a full repaint of the + visible area has to be triggered on every contents move. + + \sa hasStaticBackground() +*/ +void Q3ScrollView::setStaticBackground(bool y) +{ + d->static_bg = y; +} + +/*! + Returns true if Q3ScrollView uses a static background; otherwise + returns false. + + \sa setStaticBackground() +*/ +bool Q3ScrollView::hasStaticBackground() const +{ + return d->static_bg; +} + +/*! + \overload + + Returns the point \a p translated to a point on the viewport() + widget. +*/ +QPoint Q3ScrollView::contentsToViewport(const QPoint& p) const +{ + if (d->clipped_viewport) { + return QPoint(p.x() - d->contentsX() - d->clipped_viewport->x(), + p.y() - d->contentsY() - d->clipped_viewport->y()); + } else { + return QPoint(p.x() - d->contentsX(), + p.y() - d->contentsY()); + } +} + +/*! + \overload + + Returns the point on the viewport \a vp translated to a point in + the contents. +*/ +QPoint Q3ScrollView::viewportToContents(const QPoint& vp) const +{ + if (d->clipped_viewport) { + return QPoint(vp.x() + d->contentsX() + d->clipped_viewport->x(), + vp.y() + d->contentsY() + d->clipped_viewport->y()); + } else { + return QPoint(vp.x() + d->contentsX(), + vp.y() + d->contentsY()); + } +} + + +/*! + Translates a point (\a x, \a y) in the contents to a point (\a vx, + \a vy) on the viewport() widget. +*/ +void Q3ScrollView::contentsToViewport(int x, int y, int& vx, int& vy) const +{ + const QPoint v = contentsToViewport(QPoint(x,y)); + vx = v.x(); + vy = v.y(); +} + +/*! + Translates a point (\a vx, \a vy) on the viewport() widget to a + point (\a x, \a y) in the contents. +*/ +void Q3ScrollView::viewportToContents(int vx, int vy, int& x, int& y) const +{ + const QPoint c = viewportToContents(QPoint(vx,vy)); + x = c.x(); + y = c.y(); +} + +/*! + \reimp +*/ +QSize Q3ScrollView::sizeHint() const +{ + if (d->use_cached_size_hint && d->cachedSizeHint.isValid()) + return d->cachedSizeHint; + + constPolish(); + int f = 2 * frameWidth(); + int h = fontMetrics().height(); + QSize sz(f, f); + if (d->policy > Manual) { + QSVChildRec *r = d->children.first(); + if (r) { + QSize cs = r->child->sizeHint(); + if (cs.isValid()) + sz += cs.boundedTo(r->child->maximumSize()); + else + sz += r->child->size(); + } + } else { + sz += QSize(d->contentsWidth(), contentsHeight()); + } + if (d->vMode == AlwaysOn) + sz.setWidth(sz.width() + d->vbar->sizeHint().width()); + if (d->hMode == AlwaysOn) + sz.setHeight(sz.height() + d->hbar->sizeHint().height()); + return sz.expandedTo(QSize(12 * h, 8 * h)) + .boundedTo(QSize(36 * h, 24 * h)); +} + + +/*! + \reimp +*/ +QSize Q3ScrollView::minimumSizeHint() const +{ + int h = fontMetrics().height(); + if (h < 10) + h = 10; + int f = 2 * frameWidth(); + return QSize((6 * h) + f, (4 * h) + f); +} + + +/*! + \reimp + + (Implemented to get rid of a compiler warning.) +*/ +void Q3ScrollView::drawContents(QPainter *) +{ +} + +#ifndef QT_NO_DRAGANDDROP + +/*! + \internal +*/ +void Q3ScrollView::startDragAutoScroll() +{ + if (!d->autoscroll_timer.isActive()) { + d->autoscroll_time = initialScrollTime; + d->autoscroll_accel = initialScrollAccel; + d->autoscroll_timer.start(d->autoscroll_time); + } +} + + +/*! + \internal +*/ +void Q3ScrollView::stopDragAutoScroll() +{ + d->autoscroll_timer.stop(); +} + + +/*! + \internal +*/ +void Q3ScrollView::doDragAutoScroll() +{ + QPoint p = d->viewport->mapFromGlobal(QCursor::pos()); + + if (d->autoscroll_accel-- <= 0 && d->autoscroll_time) { + d->autoscroll_accel = initialScrollAccel; + d->autoscroll_time--; + d->autoscroll_timer.start(d->autoscroll_time); + } + int l = QMAX(1, (initialScrollTime- d->autoscroll_time)); + + int dx = 0, dy = 0; + if (p.y() < autoscroll_margin) { + dy = -l; + } else if (p.y() > visibleHeight() - autoscroll_margin) { + dy = +l; + } + if (p.x() < autoscroll_margin) { + dx = -l; + } else if (p.x() > visibleWidth() - autoscroll_margin) { + dx = +l; + } + if (dx || dy) { + scrollBy(dx,dy); + } else { + stopDragAutoScroll(); + } +} + + +/*! + \property Q3ScrollView::dragAutoScroll + \brief whether autoscrolling in drag move events is enabled + + If this property is set to true (the default), the Q3ScrollView + automatically scrolls the contents in drag move events if the user + moves the cursor close to a border of the view. Of course this + works only if the viewport accepts drops. Specifying false + disables this autoscroll feature. +*/ + +void Q3ScrollView::setDragAutoScroll(bool b) +{ + d->drag_autoscroll = b; +} + +bool Q3ScrollView::dragAutoScroll() const +{ + return d->drag_autoscroll; +} + +#endif // QT_NO_DRAGANDDROP + +/*!\internal + */ +void Q3ScrollView::setCachedSizeHint(const QSize &sh) const +{ + if (isVisible() && !d->cachedSizeHint.isValid()) + d->cachedSizeHint = sh; +} + +/*!\internal + */ +void Q3ScrollView::disableSizeHintCaching() +{ + d->use_cached_size_hint = false; +} + +/*!\internal + */ +QSize Q3ScrollView::cachedSizeHint() const +{ + return d->use_cached_size_hint ? d->cachedSizeHint : QSize(); +} + +QT_END_NAMESPACE + +#endif // QT_NO_SCROLLVIEW diff --git a/src/qt3support/widgets/q3scrollview.h b/src/qt3support/widgets/q3scrollview.h new file mode 100644 index 0000000..8579dbb --- /dev/null +++ b/src/qt3support/widgets/q3scrollview.h @@ -0,0 +1,253 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the Qt3Support module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, 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 qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef Q3SCROLLVIEW_H +#define Q3SCROLLVIEW_H + +#include <Qt3Support/q3frame.h> +#include <QtGui/qscrollbar.h> + +QT_BEGIN_HEADER + +QT_BEGIN_NAMESPACE + +QT_MODULE(Qt3SupportLight) + +class Q3ScrollViewData; + +class Q_COMPAT_EXPORT Q3ScrollView : public Q3Frame +{ + Q_OBJECT + Q_ENUMS( ResizePolicy ScrollBarMode ) + Q_PROPERTY( ResizePolicy resizePolicy READ resizePolicy WRITE setResizePolicy ) + Q_PROPERTY( ScrollBarMode vScrollBarMode READ vScrollBarMode WRITE setVScrollBarMode ) + Q_PROPERTY( ScrollBarMode hScrollBarMode READ hScrollBarMode WRITE setHScrollBarMode ) + Q_PROPERTY( int visibleWidth READ visibleWidth ) + Q_PROPERTY( int visibleHeight READ visibleHeight ) + Q_PROPERTY( int contentsWidth READ contentsWidth ) + Q_PROPERTY( int contentsHeight READ contentsHeight ) + Q_PROPERTY( int contentsX READ contentsX ) + Q_PROPERTY( int contentsY READ contentsY ) + Q_PROPERTY( bool dragAutoScroll READ dragAutoScroll WRITE setDragAutoScroll ) + +public: + Q3ScrollView(QWidget* parent=0, const char* name=0, Qt::WindowFlags f=0); + ~Q3ScrollView(); + + enum ResizePolicy { Default, Manual, AutoOne, AutoOneFit }; + virtual void setResizePolicy( ResizePolicy ); + ResizePolicy resizePolicy() const; + + void styleChange( QStyle & ); + void removeChild(QWidget* child); + virtual void addChild( QWidget* child, int x=0, int y=0 ); + virtual void moveChild( QWidget* child, int x, int y ); + int childX(QWidget* child); + int childY(QWidget* child); + bool childIsVisible(QWidget* child) { return child->isVisible(); } // obsolete functions + void showChild(QWidget* child, bool yes=true) { child->setVisible(yes); } + + enum ScrollBarMode { Auto, AlwaysOff, AlwaysOn }; + + ScrollBarMode vScrollBarMode() const; + virtual void setVScrollBarMode( ScrollBarMode ); + + ScrollBarMode hScrollBarMode() const; + virtual void setHScrollBarMode( ScrollBarMode ); + + QWidget* cornerWidget() const; + virtual void setCornerWidget(QWidget*); + + // ### 4.0: Consider providing a factory function for scrollbars + // (e.g. make the two following functions virtual) + QScrollBar* horizontalScrollBar() const; + QScrollBar* verticalScrollBar() const; + QWidget* viewport() const; + QWidget* clipper() const; + + int visibleWidth() const; + int visibleHeight() const; + + int contentsWidth() const; + int contentsHeight() const; + int contentsX() const; + int contentsY() const; + + void resize( int w, int h ); + void resize( const QSize& ); + void setVisible(bool visible); + + void updateContents( int x, int y, int w, int h ); + void updateContents( const QRect& r ); + void updateContents(); + void repaintContents( int x, int y, int w, int h, bool erase=true ); + void repaintContents( const QRect& r, bool erase=true ); + void repaintContents( bool erase=true ); + void contentsToViewport( int x, int y, int& vx, int& vy ) const; + void viewportToContents( int vx, int vy, int& x, int& y ) const; + QPoint contentsToViewport( const QPoint& ) const; + QPoint viewportToContents( const QPoint& ) const; + void enableClipper( bool y ); + + void setStaticBackground( bool y ); + bool hasStaticBackground() const; + + QSize viewportSize( int, int ) const; + QSize sizeHint() const; + QSize minimumSizeHint() const; + + void removeChild(QObject* child); + + bool isHorizontalSliderPressed(); + bool isVerticalSliderPressed(); + + virtual void setDragAutoScroll( bool b ); + bool dragAutoScroll() const; + +Q_SIGNALS: + void contentsMoving(int x, int y); + void horizontalSliderPressed(); + void horizontalSliderReleased(); + void verticalSliderPressed(); + void verticalSliderReleased(); + +public Q_SLOTS: + virtual void resizeContents( int w, int h ); + void scrollBy( int dx, int dy ); + virtual void setContentsPos( int x, int y ); + void ensureVisible(int x, int y); + void ensureVisible(int x, int y, int xmargin, int ymargin); + void center(int x, int y); + void center(int x, int y, float xmargin, float ymargin); + + void updateScrollBars(); // ### virtual in 4.0 + void setEnabled( bool enable ); + +protected: + virtual void drawContents(QPainter*, int cx, int cy, int cw, int ch); + virtual void drawContentsOffset(QPainter*, int ox, int oy, + int cx, int cy, int cw, int ch); + + + virtual void contentsMousePressEvent( QMouseEvent* ); + virtual void contentsMouseReleaseEvent( QMouseEvent* ); + virtual void contentsMouseDoubleClickEvent( QMouseEvent* ); + virtual void contentsMouseMoveEvent( QMouseEvent* ); + virtual void contentsDragEnterEvent( QDragEnterEvent * ); + virtual void contentsDragMoveEvent( QDragMoveEvent * ); + virtual void contentsDragLeaveEvent( QDragLeaveEvent * ); + virtual void contentsDropEvent( QDropEvent * ); + virtual void contentsWheelEvent( QWheelEvent * ); + virtual void contentsContextMenuEvent( QContextMenuEvent * ); + + + virtual void viewportPaintEvent( QPaintEvent* ); + virtual void viewportResizeEvent( QResizeEvent* ); + virtual void viewportMousePressEvent( QMouseEvent* ); + virtual void viewportMouseReleaseEvent( QMouseEvent* ); + virtual void viewportMouseDoubleClickEvent( QMouseEvent* ); + virtual void viewportMouseMoveEvent( QMouseEvent* ); + virtual void viewportDragEnterEvent( QDragEnterEvent * ); + virtual void viewportDragMoveEvent( QDragMoveEvent * ); + virtual void viewportDragLeaveEvent( QDragLeaveEvent * ); + virtual void viewportDropEvent( QDropEvent * ); + virtual void viewportWheelEvent( QWheelEvent * ); + virtual void viewportContextMenuEvent( QContextMenuEvent * ); + + void frameChanged(); + +public: + virtual void setMargins(int left, int top, int right, int bottom); + int leftMargin() const; + int topMargin() const; + int rightMargin() const; + int bottomMargin() const; +protected: + + bool focusNextPrevChild( bool next ); + + virtual void setHBarGeometry(QScrollBar& hbar, int x, int y, int w, int h); + virtual void setVBarGeometry(QScrollBar& vbar, int x, int y, int w, int h); + + void resizeEvent(QResizeEvent*); + void mousePressEvent( QMouseEvent * ); + void mouseReleaseEvent( QMouseEvent * ); + void mouseDoubleClickEvent( QMouseEvent * ); + void mouseMoveEvent( QMouseEvent * ); + void wheelEvent( QWheelEvent * ); + void contextMenuEvent( QContextMenuEvent * ); + bool eventFilter( QObject *, QEvent *e ); + + void setCachedSizeHint( const QSize &sh ) const; + QSize cachedSizeHint() const; + void fontChange( const QFont & ); + +private: + void drawContents( QPainter* ); + void moveContents(int x, int y); + + Q3ScrollViewData* d; + +private Q_SLOTS: + void hslide(int); + void vslide(int); + void hbarIsPressed(); + void hbarIsReleased(); + void vbarIsPressed(); + void vbarIsReleased(); + void doDragAutoScroll(); + void startDragAutoScroll(); + void stopDragAutoScroll(); + +private: // Disabled copy constructor and operator= + Q_DISABLE_COPY(Q3ScrollView) + void changeFrameRect(const QRect&); + +public: + void disableSizeHintCaching(); + +}; + +QT_END_NAMESPACE + +QT_END_HEADER + +#endif // Q3SCROLLVIEW_H diff --git a/src/qt3support/widgets/q3spinwidget.cpp b/src/qt3support/widgets/q3spinwidget.cpp new file mode 100644 index 0000000..32ac981 --- /dev/null +++ b/src/qt3support/widgets/q3spinwidget.cpp @@ -0,0 +1,475 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the Qt3Support module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, 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 qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "q3rangecontrol.h" + +#ifndef QT_NO_SPINWIDGET + +#include "qabstractspinbox.h" +#include "qevent.h" +#include "qpainter.h" +#include "qrect.h" +#include "qstyle.h" +#include "qstyleoption.h" +#include "qtimer.h" + +QT_BEGIN_NAMESPACE + +class Q3SpinWidgetPrivate +{ +public: + Q3SpinWidgetPrivate() + : upEnabled(true), + downEnabled(true), + theButton(0), + buttonDown(0), + timerUp(0), + bsyms(Q3SpinWidget::UpDownArrows), + ed (0) {} + uint upEnabled :1; + uint downEnabled :1; + uint theButton :2; + uint buttonDown :2; + uint timerUp : 1; + QRect up; + QRect down; + QTimer auRepTimer; + Q3SpinWidget::ButtonSymbols bsyms; + QWidget *ed; + void startTimer(int msec) { auRepTimer.start(msec, true); } + void startTimer(bool up, int msec) { timerUp = up; startTimer(msec); } + void stopTimer() { auRepTimer.stop(); } +}; + +/*! + \class Q3SpinWidget + \brief The Q3SpinWidget class is an internal range control related class. + + \internal + + Constructs an empty range control widget with parent \a parent + called \a name. + +*/ + +Q3SpinWidget::Q3SpinWidget(QWidget* parent, const char* name) + : QWidget(parent, name) +{ + d = new Q3SpinWidgetPrivate(); + connect(&d->auRepTimer, SIGNAL(timeout()), this, SLOT(timerDone())); + setFocusPolicy(Qt::StrongFocus); + + arrange(); + updateDisplay(); +} + + +/*! Destroys the object and frees any allocated resources. + +*/ + +Q3SpinWidget::~Q3SpinWidget() +{ + delete d; +} + +/*! */ +QWidget * Q3SpinWidget::editWidget() +{ + return d->ed; +} + +/*! + Sets the editing widget to \a w. +*/ +void Q3SpinWidget::setEditWidget(QWidget * w) +{ + if (w) { + if (w->parentWidget() != this) + w->setParent(this); + setFocusProxy(w); + } + d->ed = w; + arrange(); + updateDisplay(); +} + +/*! \reimp + +*/ + +void Q3SpinWidget::mousePressEvent(QMouseEvent *e) +{ + if (e->button() != Qt::LeftButton) { + d->stopTimer(); + d->buttonDown = 0; + d->theButton = 0; + repaint(d->down.united(d->up)); + return; + } + + uint oldButtonDown = d->buttonDown; + + if (d->down.contains(e->pos()) && d->downEnabled) + d->buttonDown = 1; + else if (d->up.contains(e->pos()) && d->upEnabled) + d->buttonDown = 2; + else + d->buttonDown = 0; + + d->theButton = d->buttonDown; + if (oldButtonDown != d->buttonDown) { + if (!d->buttonDown) { + repaint(d->down.united(d->up)); + } else if (d->buttonDown & 1) { + repaint(d->down); + stepDown(); + d->startTimer(false, 300); + } else if (d->buttonDown & 2) { + repaint(d->up); + stepUp(); + d->startTimer(true, 300); + } + } + + if (!oldButtonDown && !d->buttonDown) + e->ignore(); + +} + +static QStyleOptionSpinBox getStyleOption(const Q3SpinWidget *spin) +{ + QStyleOptionSpinBox opt; + opt.init(spin); + opt.frame = true; + opt.subControls = 0; + opt.buttonSymbols = (QAbstractSpinBox::ButtonSymbols)spin->buttonSymbols(); + opt.stepEnabled = 0; + if (spin->isUpEnabled()) + opt.stepEnabled |= QAbstractSpinBox::StepUpEnabled; + if (spin->isDownEnabled()) + opt.stepEnabled |= QAbstractSpinBox::StepDownEnabled; + opt.activeSubControls = 0; + return opt; +} + +/*! + +*/ + +void Q3SpinWidget::arrange() +{ + QStyleOptionSpinBox opt = getStyleOption(this); + d->up = style()->subControlRect(QStyle::CC_SpinBox, &opt, QStyle::SC_SpinBoxUp, this); + d->down = style()->subControlRect(QStyle::CC_SpinBox, &opt, QStyle::SC_SpinBoxDown, this); + if (d->ed) { + QRect r = style()->subControlRect(QStyle::CC_SpinBox, &opt, + QStyle::SC_SpinBoxEditField, this); + d->ed->setGeometry(r); + } +} + +/*! + +*/ + +void Q3SpinWidget::stepUp() +{ + emit stepUpPressed(); +} + +void Q3SpinWidget::resizeEvent(QResizeEvent*) +{ + arrange(); +} + +/*! + +*/ + +void Q3SpinWidget::stepDown() +{ + emit stepDownPressed(); +} + + +void Q3SpinWidget::timerDone() +{ + // we use a double timer to make it possible for users to do + // something with 0-timer on valueChanged. + QTimer::singleShot(1, this, SLOT(timerDoneEx())); +} + +void Q3SpinWidget::timerDoneEx() +{ + if (!d->buttonDown) + return; + if (d->timerUp) + stepUp(); + else + stepDown(); + d->startTimer(100); +} + + +/*! + The event is passed in \a e. +*/ + +void Q3SpinWidget::mouseReleaseEvent(QMouseEvent *e) +{ + if (e->button() != Qt::LeftButton) + return; + + uint oldButtonDown = d->theButton; + d->theButton = 0; + if (oldButtonDown != d->theButton) { + if (oldButtonDown & 1) + repaint(d->down); + else if (oldButtonDown & 2) + repaint(d->up); + } + d->stopTimer(); + d->buttonDown = 0; + + if (!oldButtonDown && !d->buttonDown) + e->ignore(); +} + + +/*! + The event is passed in \a e. +*/ + +void Q3SpinWidget::mouseMoveEvent(QMouseEvent *e) +{ + if (!(e->state() & Qt::LeftButton)) + return; + + uint oldButtonDown = d->theButton; + if (oldButtonDown & 1 && !d->down.contains(e->pos())) { + d->stopTimer(); + d->theButton = 0; + repaint(d->down); + } else if (oldButtonDown & 2 && !d->up.contains(e->pos())) { + d->stopTimer(); + d->theButton = 0; + repaint(d->up); + } else if (!oldButtonDown && d->up.contains(e->pos()) && d->buttonDown & 2) { + d->startTimer(500); + d->theButton = 2; + repaint(d->up); + } else if (!oldButtonDown && d->down.contains(e->pos()) && d->buttonDown & 1) { + d->startTimer(500); + d->theButton = 1; + repaint(d->down); + } + + if (!oldButtonDown && !d->buttonDown) + e->ignore(); +} + + +/*! + The event is passed in \a e. +*/ +#ifndef QT_NO_WHEELEVENT +void Q3SpinWidget::wheelEvent(QWheelEvent *e) +{ + e->accept(); + static float offset = 0; + static Q3SpinWidget* offset_owner = 0; + if (offset_owner != this) { + offset_owner = this; + offset = 0; + } + offset += -e->delta()/120; + if (QABS(offset) < 1) + return; + int ioff = int(offset); + int i; + for(i=0; i < QABS(ioff); i++) + offset > 0 ? stepDown() : stepUp(); + offset -= ioff; +} +#endif + +/*! + +*/ +void Q3SpinWidget::paintEvent(QPaintEvent *) +{ + QPainter p(this); + QStyleOptionSpinBox opt = getStyleOption(this); + + if (d->theButton & 1) { + opt.activeSubControls = QStyle::SC_SpinBoxDown; + opt.state |= QStyle::State_Sunken; + } else if (d->theButton & 2) { + opt.activeSubControls = QStyle::SC_SpinBoxUp; + opt.state |= QStyle::State_Sunken; + } else + opt.activeSubControls = QStyle::SC_None; + opt.rect = style()->subControlRect(QStyle::CC_SpinBox, &opt, QStyle::SC_SpinBoxFrame, this); + opt.subControls = QStyle::SC_All; + style()->drawComplexControl(QStyle::CC_SpinBox, &opt, &p, this); +} + + +// ### What does the QEvent passed in contain? It used to be the previous style. +/*! + The previous style is passed in \a ev. +*/ +void Q3SpinWidget::changeEvent(QEvent *ev) +{ + if(ev->type() == QEvent::StyleChange) { + arrange(); + } else if(ev->type() == QEvent::ActivationChange) { + if (!isActiveWindow() && d->buttonDown) { //was active, but lost focus + d->stopTimer(); + d->buttonDown = 0; + d->theButton = 0; + } + } else if(ev->type() == QEvent::EnabledChange) { + d->upEnabled = isEnabled(); + d->downEnabled = isEnabled(); + updateDisplay(); + } + QWidget::changeEvent(ev); +} + +/*! +*/ + +QRect Q3SpinWidget::upRect() const +{ + return d->up; +} + +/*! +*/ + +QRect Q3SpinWidget::downRect() const +{ + return d->down; +} + +/*! +*/ + +void Q3SpinWidget::updateDisplay() +{ + if (!isEnabled()) { + d->upEnabled = false; + d->downEnabled = false; + } + if (d->theButton & 1 && (d->downEnabled) == 0) { + d->theButton &= ~1; + d->buttonDown &= ~1; + } + + if (d->theButton & 2 && (d->upEnabled) == 0) { + d->theButton &= ~2; + d->buttonDown &= ~2; + } + repaint(); +} + +/*! + Sets up-enabled to \a on. +*/ + +void Q3SpinWidget::setUpEnabled(bool on) +{ + if ((bool)d->upEnabled != on) { + d->upEnabled = on; + updateDisplay(); + } +} + +/*! +*/ + +bool Q3SpinWidget::isUpEnabled() const +{ + return d->upEnabled; +} + +/*! + Sets down-enabled to \a on. +*/ + +void Q3SpinWidget::setDownEnabled(bool on) +{ + if ((bool)d->downEnabled != on) { + d->downEnabled = on; + updateDisplay(); + } +} + +/*! +*/ + +bool Q3SpinWidget::isDownEnabled() const +{ + return d->downEnabled; +} + +/*! + Sets the button symbol to \a bs. +*/ + +void Q3SpinWidget::setButtonSymbols(ButtonSymbols bs) +{ + d->bsyms = bs; +} + +/*! +*/ + +Q3SpinWidget::ButtonSymbols Q3SpinWidget::buttonSymbols() const +{ + return d->bsyms; +} + +QT_END_NAMESPACE + +#endif diff --git a/src/qt3support/widgets/q3titlebar.cpp b/src/qt3support/widgets/q3titlebar.cpp new file mode 100644 index 0000000..61b7c12 --- /dev/null +++ b/src/qt3support/widgets/q3titlebar.cpp @@ -0,0 +1,630 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the Qt3Support module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, 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 qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "qplatformdefs.h" + +#ifndef QT_NO_TITLEBAR + +#include "qapplication.h" +#include "qcursor.h" +#include "qdatetime.h" +#include "qevent.h" +#include "qimage.h" +#include "qpainter.h" +#include "qiodevice.h" +#include "qpixmap.h" +#include "qstyle.h" +#include "qstyleoption.h" +#include "qtimer.h" +#include "qtooltip.h" +#include "qdebug.h" +#if defined(Q_WS_WIN) +#include "qt_windows.h" +#endif + +#include "private/qapplication_p.h" +#include "private/q3titlebar_p.h" +#include "private/qwidget_p.h" + +QT_BEGIN_NAMESPACE + +class Q3TitleBarPrivate : public QWidgetPrivate +{ + Q_DECLARE_PUBLIC(Q3TitleBar) +public: + Q3TitleBarPrivate() + : toolTip(0), act(0), window(0), movable(1), pressed(0), autoraise(0), inevent(0) + { + } + + Qt::WindowFlags flags; + QStyle::SubControl buttonDown; + QPoint moveOffset; + QToolTip *toolTip; + bool act :1; + QWidget* window; + bool movable :1; + bool pressed :1; + bool autoraise :1; + bool inevent : 1; + + int titleBarState() const; + QStyleOptionTitleBar getStyleOption() const; + void readColors(); +}; + +inline int Q3TitleBarPrivate::titleBarState() const +{ + uint state = window ? window->windowState() : static_cast<Qt::WindowStates>(Qt::WindowNoState); + state |= uint(act ? QStyle::State_Active : QStyle::State_None); + return (int)state; +} + +QStyleOptionTitleBar Q3TitleBarPrivate::getStyleOption() const +{ + Q_Q(const Q3TitleBar); + QStyleOptionTitleBar opt; + opt.init(q); + opt.text = q->windowTitle(); + //################ + QIcon icon = q->windowIcon(); + QSize s = icon.actualSize(QSize(64, 64)); + opt.icon = icon.pixmap(s); + opt.subControls = QStyle::SC_All; + opt.activeSubControls = QStyle::SC_None; + opt.titleBarState = titleBarState(); + opt.titleBarFlags = flags; + return opt; +} + +Q3TitleBar::Q3TitleBar(QWidget *w, QWidget *parent, Qt::WindowFlags f) + : QWidget(*new Q3TitleBarPrivate, parent, Qt::WStyle_Customize | Qt::WStyle_NoBorder) +{ + Q_D(Q3TitleBar); + if (f == 0 && w) + f = w->windowFlags(); + d->flags = f; + d->window = w; + d->buttonDown = QStyle::SC_None; + d->act = 0; + if (w) { + if (w->minimumSize() == w->maximumSize()) + d->flags &= ~Qt::WindowMaximizeButtonHint; + setWindowTitle(w->windowTitle()); + } + + d->readColors(); + setSizePolicy(QSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed)); + setMouseTracking(true); + setAutoRaise(style()->styleHint(QStyle::SH_TitleBar_AutoRaise, 0, this)); +} + +void Q3TitleBar::setFakeWindowFlags(Qt::WindowFlags f) +{ + Q_D(Q3TitleBar); + d->flags = f; +} + +Qt::WindowFlags Q3TitleBar::fakeWindowFlags() const +{ + Q_D(const Q3TitleBar); + return d->flags; +} + +Q3TitleBar::~Q3TitleBar() +{ +} + +QStyleOptionTitleBar Q3TitleBar::getStyleOption() const +{ + return d_func()->getStyleOption(); +} + +#ifdef Q_WS_WIN +static inline QRgb colorref2qrgb(COLORREF col) +{ + return qRgb(GetRValue(col),GetGValue(col),GetBValue(col)); +} +#endif + +void Q3TitleBarPrivate::readColors() +{ + Q_Q(Q3TitleBar); + QPalette pal = q->palette(); + + bool colorsInitialized = false; + +#ifdef Q_WS_WIN // ask system properties on windows + if (QApplication::desktopSettingsAware()) { + pal.setColor(QPalette::Active, QPalette::Highlight, colorref2qrgb(GetSysColor(COLOR_ACTIVECAPTION))); + pal.setColor(QPalette::Inactive, QPalette::Highlight, colorref2qrgb(GetSysColor(COLOR_INACTIVECAPTION))); + pal.setColor(QPalette::Active, QPalette::HighlightedText, colorref2qrgb(GetSysColor(COLOR_CAPTIONTEXT))); + pal.setColor(QPalette::Inactive, QPalette::HighlightedText, colorref2qrgb(GetSysColor(COLOR_INACTIVECAPTIONTEXT))); + colorsInitialized = true; + BOOL gradient = false; + SystemParametersInfo(SPI_GETGRADIENTCAPTIONS, 0, &gradient, 0); + if (gradient) { + pal.setColor(QPalette::Active, QPalette::Base, colorref2qrgb(GetSysColor(COLOR_GRADIENTACTIVECAPTION))); + pal.setColor(QPalette::Inactive, QPalette::Base, colorref2qrgb(GetSysColor(COLOR_GRADIENTINACTIVECAPTION))); + } else { + pal.setColor(QPalette::Active, QPalette::Base, pal.color(QPalette::Active, QPalette::Highlight)); + pal.setColor(QPalette::Inactive, QPalette::Base, pal.color(QPalette::Inactive, QPalette::Highlight)); + } + } +#endif // Q_WS_WIN + if (!colorsInitialized) { + pal.setColor(QPalette::Active, QPalette::Highlight, + pal.color(QPalette::Active, QPalette::Highlight)); + pal.setColor(QPalette::Active, QPalette::Base, + pal.color(QPalette::Active, QPalette::Highlight)); + pal.setColor(QPalette::Inactive, QPalette::Highlight, + pal.color(QPalette::Inactive, QPalette::Dark)); + pal.setColor(QPalette::Inactive, QPalette::Base, + pal.color(QPalette::Inactive, QPalette::Dark)); + pal.setColor(QPalette::Inactive, QPalette::HighlightedText, + pal.color(QPalette::Inactive, QPalette::Window)); + } + + q->setPalette(pal); + q->setActive(act); +} + +void Q3TitleBar::changeEvent(QEvent *ev) +{ + if(ev->type() == QEvent::ModifiedChange) + update(); + QWidget::changeEvent(ev); +} + +void Q3TitleBar::mousePressEvent(QMouseEvent *e) +{ + Q_D(Q3TitleBar); + if (!d->act) + emit doActivate(); + if (e->button() == Qt::LeftButton) { + d->pressed = true; + QStyleOptionTitleBar opt = d->getStyleOption(); + QStyle::SubControl ctrl = style()->hitTestComplexControl(QStyle::CC_TitleBar, &opt, + e->pos(), this); + switch (ctrl) { + case QStyle::SC_TitleBarSysMenu: + if (d->flags & Qt::WindowSystemMenuHint) { + d->buttonDown = QStyle::SC_None; + static QTime *t = 0; + static Q3TitleBar *tc = 0; + if (!t) + t = new QTime; + if (tc != this || t->elapsed() > QApplication::doubleClickInterval()) { + emit showOperationMenu(); + t->start(); + tc = this; + } else { + tc = 0; + emit doClose(); + return; + } + } + break; + + case QStyle::SC_TitleBarShadeButton: + case QStyle::SC_TitleBarUnshadeButton: + if (d->flags & Qt::WindowShadeButtonHint) + d->buttonDown = ctrl; + break; + + case QStyle::SC_TitleBarNormalButton: + if (d->flags & Qt::WindowMinMaxButtonsHint) + d->buttonDown = ctrl; + break; + + case QStyle::SC_TitleBarMinButton: + if (d->flags & Qt::WindowMinimizeButtonHint) + d->buttonDown = ctrl; + break; + + case QStyle::SC_TitleBarMaxButton: + if (d->flags & Qt::WindowMaximizeButtonHint) + d->buttonDown = ctrl; + break; + + case QStyle::SC_TitleBarCloseButton: + if (d->flags & Qt::WindowSystemMenuHint) + d->buttonDown = ctrl; + break; + + case QStyle::SC_TitleBarLabel: + d->buttonDown = ctrl; + d->moveOffset = mapToParent(e->pos()); + break; + + default: + break; + } + repaint(); + } else { + d->pressed = false; + } +} + +void Q3TitleBar::contextMenuEvent(QContextMenuEvent *e) +{ + Q_D(Q3TitleBar); + QStyleOptionTitleBar opt = d->getStyleOption(); + QStyle::SubControl ctrl = style()->hitTestComplexControl(QStyle::CC_TitleBar, &opt, e->pos(), + this); + if(ctrl == QStyle::SC_TitleBarLabel || ctrl == QStyle::SC_TitleBarSysMenu) { + e->accept(); + emit popupOperationMenu(e->globalPos()); + } else { + e->ignore(); + } +} + +void Q3TitleBar::mouseReleaseEvent(QMouseEvent *e) +{ + Q_D(Q3TitleBar); + if (e->button() == Qt::LeftButton && d->pressed) { + e->accept(); + QStyleOptionTitleBar opt = d->getStyleOption(); + QStyle::SubControl ctrl = style()->hitTestComplexControl(QStyle::CC_TitleBar, &opt, + e->pos(), this); + d->pressed = false; + if (ctrl == d->buttonDown) { + d->buttonDown = QStyle::SC_None; + repaint(); + switch(ctrl) { + case QStyle::SC_TitleBarShadeButton: + case QStyle::SC_TitleBarUnshadeButton: + if(d->flags & Qt::WindowShadeButtonHint) + emit doShade(); + break; + + case QStyle::SC_TitleBarNormalButton: + if(d->flags & Qt::WindowMaximizeButtonHint) + emit doNormal(); + break; + + case QStyle::SC_TitleBarMinButton: + if(d->flags & Qt::WindowMinimizeButtonHint) { + if (d->window && d->window->isMinimized()) + emit doNormal(); + else + emit doMinimize(); + } + break; + + case QStyle::SC_TitleBarMaxButton: + if(d->flags & Qt::WindowMaximizeButtonHint) { + if(d->window && d->window->isMaximized()) + emit doNormal(); + else + emit doMaximize(); + } + break; + + case QStyle::SC_TitleBarCloseButton: + if(d->flags & Qt::WindowSystemMenuHint) { + d->buttonDown = QStyle::SC_None; + repaint(); + emit doClose(); + return; + } + break; + + default: + break; + } + } + } else { + e->ignore(); + } +} + +void Q3TitleBar::mouseMoveEvent(QMouseEvent *e) +{ + Q_D(Q3TitleBar); + e->accept(); + switch (d->buttonDown) { + case QStyle::SC_None: + if(autoRaise()) + repaint(); + break; + case QStyle::SC_TitleBarSysMenu: + break; + case QStyle::SC_TitleBarShadeButton: + case QStyle::SC_TitleBarUnshadeButton: + case QStyle::SC_TitleBarNormalButton: + case QStyle::SC_TitleBarMinButton: + case QStyle::SC_TitleBarMaxButton: + case QStyle::SC_TitleBarCloseButton: + { + QStyle::SubControl last_ctrl = d->buttonDown; + QStyleOptionTitleBar opt = d->getStyleOption(); + d->buttonDown = style()->hitTestComplexControl(QStyle::CC_TitleBar, &opt, e->pos(), this); + if (d->buttonDown != last_ctrl) + d->buttonDown = QStyle::SC_None; + repaint(); + d->buttonDown = last_ctrl; + } + break; + + case QStyle::SC_TitleBarLabel: + if (d->buttonDown == QStyle::SC_TitleBarLabel && d->movable && d->pressed) { + if ((d->moveOffset - mapToParent(e->pos())).manhattanLength() >= 4) { + QPoint p = mapFromGlobal(e->globalPos()); + + QWidget *parent = d->window ? d->window->parentWidget() : 0; + if(parent && parent->inherits("Q3WorkspaceChild")) { + QWidget *workspace = parent->parentWidget(); + p = workspace->mapFromGlobal(e->globalPos()); + if (!workspace->rect().contains(p)) { + if (p.x() < 0) + p.rx() = 0; + if (p.y() < 0) + p.ry() = 0; + if (p.x() > workspace->width()) + p.rx() = workspace->width(); + if (p.y() > workspace->height()) + p.ry() = workspace->height(); + } + } + + QPoint pp = p - d->moveOffset; + if (!parentWidget()->isMaximized()) + parentWidget()->move(pp); + } + } else { + QStyle::SubControl last_ctrl = d->buttonDown; + d->buttonDown = QStyle::SC_None; + if(d->buttonDown != last_ctrl) + repaint(); + } + break; + default: + break; + } +} + +void Q3TitleBar::resizeEvent(QResizeEvent *r) +{ + QWidget::resizeEvent(r); + cutText(); +} + +bool Q3TitleBar::isTool() const +{ + return (d_func()->flags & Qt::WindowType_Mask) == Qt::Tool; +} + +void Q3TitleBar::paintEvent(QPaintEvent *) +{ + Q_D(Q3TitleBar); + QStyleOptionTitleBar opt = d->getStyleOption(); + opt.subControls = QStyle::SC_TitleBarLabel; + opt.activeSubControls = d->buttonDown; + if (d->flags & Qt::WindowSystemMenuHint) { + opt.subControls |= QStyle::SC_TitleBarSysMenu | QStyle::SC_TitleBarCloseButton; + if (d->window && (d->flags & Qt::WindowShadeButtonHint)) { + if (d->window->isMinimized()) + opt.subControls |= QStyle::SC_TitleBarUnshadeButton; + else + opt.subControls |= QStyle::SC_TitleBarShadeButton; + } + if (d->window && (d->flags & Qt::WindowMinMaxButtonsHint)) { + if(d->window && d->window->isMinimized()) + opt.subControls |= QStyle::SC_TitleBarNormalButton; + else + opt.subControls |= QStyle::SC_TitleBarMinButton; + } + if (d->window && (d->flags & Qt::WindowMaximizeButtonHint) && !d->window->isMaximized()) + opt.subControls |= QStyle::SC_TitleBarMaxButton; + } + QStyle::SubControl under_mouse = QStyle::SC_None; + + if (underMouse()) { + under_mouse = style()->hitTestComplexControl(QStyle::CC_TitleBar, &opt, + mapFromGlobal(QCursor::pos()), this); + opt.activeSubControls |= under_mouse; + if (d->pressed) + opt.state |= QStyle::State_Sunken; + else if(autoRaise()) + opt.state |= QStyle::State_MouseOver; + } + + opt.palette.setCurrentColorGroup(usesActiveColor() ? QPalette::Active : QPalette::Inactive); + + QPainter p(this); + if (!windowTitle().isEmpty()) + opt.titleBarFlags |= Qt::WindowTitleHint; + style()->drawComplexControl(QStyle::CC_TitleBar, &opt, &p, this); +} + +void Q3TitleBar::mouseDoubleClickEvent(QMouseEvent *e) +{ + Q_D(Q3TitleBar); + if (e->button() != Qt::LeftButton) { + e->ignore(); + return; + } + e->accept(); + QStyleOptionTitleBar opt = d->getStyleOption(); + switch (style()->hitTestComplexControl(QStyle::CC_TitleBar, &opt, e->pos(), this)) { + case QStyle::SC_TitleBarLabel: + emit doubleClicked(); + break; + + case QStyle::SC_TitleBarSysMenu: + if (d->flags & Qt::WStyle_SysMenu) + emit doClose(); + break; + + default: + break; + } +} + +void Q3TitleBar::cutText() +{ + Q_D(Q3TitleBar); + QFontMetrics fm(font()); + QStyleOptionTitleBar opt = d->getStyleOption(); + int maxw = style()->subControlRect(QStyle::CC_TitleBar, &opt, QStyle::SC_TitleBarLabel, + this).width(); + if (!d->window) + return; + + QString txt = d->window->windowTitle(); + if (style()->styleHint(QStyle::SH_TitleBar_ModifyNotification, 0, this) && d->window + && d->window->isWindowModified()) + txt += QLatin1String(" *"); + + QString cuttext = txt; + if (fm.width(txt + QLatin1Char('m')) > maxw) { + int i = txt.length(); + int dotlength = fm.width(QLatin1String("...")); + while (i>0 && fm.width(txt.left(i)) + dotlength > maxw) + i--; + if(i != (int)txt.length()) + cuttext = txt.left(i) + QLatin1String("..."); + } + + setWindowTitle(cuttext); +} + + +void Q3TitleBar::leaveEvent(QEvent *) +{ + if(autoRaise() && !d_func()->pressed) + repaint(); +} + +void Q3TitleBar::enterEvent(QEvent *) +{ + if(autoRaise() && !d_func()->pressed) + repaint(); + QEvent e(QEvent::Leave); + QApplication::sendEvent(parentWidget(), &e); +} + +void Q3TitleBar::setActive(bool active) +{ + Q_D(Q3TitleBar); + if (d->act == active) + return ; + + d->act = active; + update(); +} + +bool Q3TitleBar::isActive() const +{ + return d_func()->act; +} + +bool Q3TitleBar::usesActiveColor() const +{ + return (isActive() && isActiveWindow()) || + (!window() && QWidget::window()->isActiveWindow()); +} + +QWidget *Q3TitleBar::window() const +{ + return d_func()->window; +} + +bool Q3TitleBar::event(QEvent *e) +{ + Q_D(Q3TitleBar); + if (d->inevent) + return QWidget::event(e); + d->inevent = true; + if (e->type() == QEvent::ApplicationPaletteChange) { + d->readColors(); + return true; + } else if (e->type() == QEvent::WindowActivate) { + setActive(d->act); + } else if (e->type() == QEvent::WindowDeactivate) { + bool wasActive = d->act; + setActive(false); + d->act = wasActive; + } else if (e->type() == QEvent::WindowIconChange) { + update(); + } else if (e->type() == QEvent::WindowTitleChange) { + cutText(); + update(); + } + + d->inevent = false; + return QWidget::event(e); +} + +void Q3TitleBar::setMovable(bool b) +{ + d_func()->movable = b; +} + +bool Q3TitleBar::isMovable() const +{ + return d_func()->movable; +} + +void Q3TitleBar::setAutoRaise(bool b) +{ + d_func()->autoraise = b; +} + +bool Q3TitleBar::autoRaise() const +{ + return d_func()->autoraise; +} + +QSize Q3TitleBar::sizeHint() const +{ + ensurePolished(); + QStyleOptionTitleBar opt = d_func()->getStyleOption(); + QRect menur = style()->subControlRect(QStyle::CC_TitleBar, &opt, + QStyle::SC_TitleBarSysMenu, this); + return QSize(menur.width(), style()->pixelMetric(QStyle::PM_TitleBarHeight, &opt, this)); +} + +QT_END_NAMESPACE + +#endif //QT_NO_TITLEBAR diff --git a/src/qt3support/widgets/q3titlebar_p.h b/src/qt3support/widgets/q3titlebar_p.h new file mode 100644 index 0000000..b14b3bd --- /dev/null +++ b/src/qt3support/widgets/q3titlebar_p.h @@ -0,0 +1,134 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the Qt3Support module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, 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 qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef Q3TITLEBAR_P_H +#define Q3TITLEBAR_P_H + +// +// W A R N I N G +// ------------- +// +// This file is not part of the Qt API. It exists purely as an +// implementation detail. This header file may change from version to +// version without notice, or even be removed. +// +// We mean it. +// + +#include "qwidget.h" +#include "qstyleoption.h" + +QT_BEGIN_NAMESPACE + +#if !defined(QT_NO_TITLEBAR) + +class QToolTip; +class Q3TitleBarPrivate; +class QPixmap; + +class Q_COMPAT_EXPORT Q3TitleBar : public QWidget +{ + Q_OBJECT + Q_DECLARE_PRIVATE(Q3TitleBar) + Q_PROPERTY(bool autoRaise READ autoRaise WRITE setAutoRaise) + Q_PROPERTY(bool movable READ isMovable WRITE setMovable) + +public: + Q3TitleBar (QWidget *w, QWidget *parent, Qt::WindowFlags f = 0); + ~Q3TitleBar(); + + bool isActive() const; + bool usesActiveColor() const; + + bool isMovable() const; + void setMovable(bool); + + bool autoRaise() const; + void setAutoRaise(bool); + + QWidget *window() const; + bool isTool() const; + + QSize sizeHint() const; + QStyleOptionTitleBar getStyleOption() const; + + // These flags are fake, stored in QTitleBarPrivate. They are not set as the widget's window flags. + void setFakeWindowFlags(Qt::WindowFlags f); + Qt::WindowFlags fakeWindowFlags() const; + +public Q_SLOTS: + void setActive(bool); + +Q_SIGNALS: + void doActivate(); + void doNormal(); + void doClose(); + void doMaximize(); + void doMinimize(); + void doShade(); + void showOperationMenu(); + void popupOperationMenu(const QPoint&); + void doubleClicked(); + +protected: + bool event(QEvent *); + void resizeEvent(QResizeEvent *); + void contextMenuEvent(QContextMenuEvent *); + void changeEvent(QEvent *); + void mousePressEvent(QMouseEvent *); + void mouseDoubleClickEvent(QMouseEvent *); + void mouseReleaseEvent(QMouseEvent *); + void mouseMoveEvent(QMouseEvent *); + void enterEvent(QEvent *e); + void leaveEvent(QEvent *e); + void paintEvent(QPaintEvent *p); + + virtual void cutText(); + +private: + Q_DISABLE_COPY(Q3TitleBar) +}; + +#endif + +QT_END_NAMESPACE + +#endif //Q3TITLEBAR_P_H diff --git a/src/qt3support/widgets/q3toolbar.cpp b/src/qt3support/widgets/q3toolbar.cpp new file mode 100644 index 0000000..3b3f508 --- /dev/null +++ b/src/qt3support/widgets/q3toolbar.cpp @@ -0,0 +1,840 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the Qt3Support module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, 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 qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "q3toolbar.h" +#ifndef QT_NO_TOOLBAR + +#include "q3mainwindow.h" +#include "qapplication.h" +#include "q3combobox.h" +#include "qcursor.h" +#include "qdesktopwidget.h" +#include "qdrawutil.h" +#include "qevent.h" +#include "qframe.h" +#include "qlayout.h" +#include "qmap.h" +#include "qpainter.h" +#include "q3popupmenu.h" +#include "qstyle.h" +#include "qstyleoption.h" +#include "qtimer.h" +#include "qtoolbutton.h" +#include "qtooltip.h" + +QT_BEGIN_NAMESPACE + +static const char * const arrow_v_xpm[] = { + "7 9 3 1", + " c None", + ". c #000000", + "+ c none", + ".+++++.", + "..+++..", + "+..+..+", + "++...++", + ".++.++.", + "..+++..", + "+..+..+", + "++...++", + "+++.+++"}; + +static const char * const arrow_h_xpm[] = { + "9 7 3 1", + " c None", + ". c #000000", + "+ c none", + "..++..+++", + "+..++..++", + "++..++..+", + "+++..++..", + "++..++..+", + "+..++..++", + "..++..+++"}; + +class Q3ToolBarExtensionWidget; + +class Q3ToolBarPrivate +{ +public: + Q3ToolBarPrivate() : moving(false), checkingExtension(false) { + } + + bool moving; + bool checkingExtension; + Q3ToolBarExtensionWidget *extension; + Q3PopupMenu *extensionPopup; + + QMap<QAction *, QWidget *> actions; +}; + + +class Q3ToolBarSeparator : public QWidget +{ + Q_OBJECT +public: + Q3ToolBarSeparator(Qt::Orientation, Q3ToolBar *parent, const char* name=0); + + QSize sizeHint() const; + Qt::Orientation orientation() const { return orient; } +public slots: + void setOrientation(Qt::Orientation); +protected: + void changeEvent(QEvent *); + void paintEvent(QPaintEvent *); + +private: + Qt::Orientation orient; +}; + +class Q3ToolBarExtensionWidget : public QWidget +{ + Q_OBJECT + +public: + Q3ToolBarExtensionWidget(QWidget *w); + void setOrientation(Qt::Orientation o); + QToolButton *button() const { return tb; } + +protected: + void resizeEvent(QResizeEvent *e) { + QWidget::resizeEvent(e); + layOut(); + } + +private: + void layOut(); + QToolButton *tb; + Qt::Orientation orient; + +}; + +Q3ToolBarExtensionWidget::Q3ToolBarExtensionWidget(QWidget *w) + : QWidget(w, "qt_dockwidget_internal") +{ + tb = new QToolButton(this, "qt_toolbar_ext_button"); + tb->setAutoRaise(true); + setOrientation(Qt::Horizontal); + setAutoFillBackground(true); +} + +void Q3ToolBarExtensionWidget::setOrientation(Qt::Orientation o) +{ + orient = o; + if (orient == Qt::Horizontal) + tb->setIcon(QPixmap((const char **)arrow_h_xpm)); + else + tb->setIcon(QPixmap((const char **)arrow_v_xpm)); + layOut(); +} + +void Q3ToolBarExtensionWidget::layOut() +{ + tb->setGeometry(2, 2, width() - 4, height() - 4); +} + +Q3ToolBarSeparator::Q3ToolBarSeparator(Qt::Orientation o , Q3ToolBar *parent, + const char* name) + : QWidget(parent, name) +{ + connect(parent, SIGNAL(orientationChanged(Qt::Orientation)), + this, SLOT(setOrientation(Qt::Orientation))); + setOrientation(o); + setSizePolicy(QSizePolicy(QSizePolicy::Minimum, QSizePolicy::Minimum)); +} + + + +void Q3ToolBarSeparator::setOrientation(Qt::Orientation o) +{ + orient = o; +} + +void Q3ToolBarSeparator::changeEvent(QEvent *ev) +{ + if(ev->type() == QEvent::StyleChange) + setOrientation(orient); + QWidget::changeEvent(ev); +} + +static QStyleOption getStyleOption(const Q3ToolBarSeparator *tbs) +{ + QStyleOption opt(0); + opt.rect = tbs->rect(); + opt.palette = tbs->palette(); + if (tbs->orientation() == Qt::Horizontal) + opt.state = QStyle::State_Horizontal; + else + opt.state = QStyle::State_None; + return opt; +} + +QSize Q3ToolBarSeparator::sizeHint() const +{ + QStyleOption opt = getStyleOption(this); + int extent = style()->pixelMetric(QStyle::PM_ToolBarSeparatorExtent, &opt, this); + if (orient == Qt::Horizontal) + return QSize(extent, 0); + else + return QSize(0, extent); +} + +void Q3ToolBarSeparator::paintEvent(QPaintEvent *) +{ + QPainter p(this); + QStyleOption opt = getStyleOption(this); + style()->drawPrimitive(QStyle::PE_Q3DockWindowSeparator, &opt, &p, this); +} + +QT_BEGIN_INCLUDE_NAMESPACE +#include "q3toolbar.moc" +QT_END_INCLUDE_NAMESPACE + + +/*! + \class Q3ToolBar + \brief The Q3ToolBar class provides a movable panel containing + widgets such as tool buttons. + + \compat + + A toolbar is a panel that contains a set of controls, usually + represented by small icons. It's purpose is to provide quick + access to frequently used commands or options. Within a + Q3MainWindow the user can drag toolbars within and between the + \link Q3DockArea dock areas\endlink. Toolbars can also be dragged + out of any dock area to float freely as top-level windows. + + Q3ToolBar is a specialization of QDockWindow, and so provides all + the functionality of a QDockWindow. + + To use Q3ToolBar you simply create a Q3ToolBar as a child of a + Q3MainWindow, create a number of QToolButton widgets (or other + widgets) in left to right (or top to bottom) order and call + addSeparator() when you want a separator. When a toolbar is + floated the caption used is the label given in the constructor + call. This can be changed with setLabel(). + + You may use most widgets within a toolbar, with QToolButton and + QComboBox being the most common. But note that the toolbar's + actions must be \l {Q3Action}s. + + If you create a new widget on an already visible Q3ToolBar, this + widget will automatically become visible without needing a show() + call. (This differs from every other Qt widget container. We + recommend calling show() anyway since we hope to fix this anomaly + in a future release.) + + Q3ToolBars, like QDockWindows, are located in \l{Q3DockArea}s or + float as top-level windows. Q3MainWindow provides four Q3DockAreas + (top, left, right and bottom). When you create a new toolbar (as + in the example above) as a child of a Q3MainWindow the toolbar will + be added to the top dock area. You can move it to another dock + area (or float it) by calling Q3MainWindow::moveDockWindow(). Dock + areas lay out their windows in lines. + + If the main window is resized so that the area occupied by the + toolbar is too small to show all its widgets a little arrow button + (which looks like a right-pointing chevron, '»') will appear + at the right or bottom of the toolbar depending on its + orientation. Clicking this button pops up a menu that shows the + 'overflowing' items. QToolButtons are represented in the menu using + their textLabel property, other QAbstractButton subclasses are represented + using their text property, and QComboBoxes are represented as submenus, + with the caption text being used in the submenu item. + + Usually a toolbar will get precisely the space it needs. However, + with setHorizontalStretchable(), setVerticalStretchable() or + setStretchableWidget() you can tell the main window to expand the + toolbar to fill all available space in the specified orientation. + + The toolbar arranges its buttons either horizontally or vertically + (see orientation() for details). Generally, Q3DockArea will set the + orientation correctly for you, but you can set it yourself with + setOrientation() and track any changes by connecting to the + orientationChanged() signal. + + You can use the clear() method to remove all items from a toolbar. + + \img qdockwindow.png Toolbar (dock window) + \caption A floating QToolbar (dock window) + + \sa QToolButton Q3MainWindow +*/ + +/*! + Constructs an empty toolbar. + + The toolbar is called \a name and is a child of \a parent and is + managed by \a parent. It is initially located in dock area \a dock + and is labeled \a label. If \a newLine is true the toolbar will be + placed on a new line in the dock area. +*/ + +Q3ToolBar::Q3ToolBar(const QString &label, + Q3MainWindow * parent, Qt::ToolBarDock dock, + bool newLine, const char * name) + : Q3DockWindow(InDock, parent, name, 0, true) +{ + mw = parent; + init(); + + if (parent) + parent->addToolBar(this, label, dock, newLine); +} + + +/*! + Constructs an empty horizontal toolbar. + + The toolbar is called \a name and is a child of \a parent and is + managed by \a mainWindow. The \a label and \a newLine parameters + are passed straight to Q3MainWindow::addDockWindow(). \a name and + the widget flags \a f are passed on to the Q3DockWindow constructor. + + Use this constructor if you want to create torn-off (undocked, + floating) toolbars or toolbars in the \link QStatusBar status + bar\endlink. +*/ + +Q3ToolBar::Q3ToolBar(const QString &label, Q3MainWindow * mainWindow, + QWidget * parent, bool newLine, const char * name, + Qt::WindowFlags f) + : Q3DockWindow(InDock, parent, name, f, true) +{ + mw = mainWindow; + init(); + + setParent(parent); + + if (mainWindow) + mainWindow->addToolBar(this, label, Qt::DockUnmanaged, newLine); +} + + +/*! + \overload + + Constructs an empty toolbar called \a name, with parent \a parent, + in its \a parent's top dock area, without any label and without + requiring a newline. +*/ + +Q3ToolBar::Q3ToolBar(Q3MainWindow * parent, const char * name) + : Q3DockWindow(InDock, parent, name, 0, true) +{ + mw = parent; + init(); + + if (parent) + parent->addToolBar(this, QString(), Qt::DockTop); +} + +/*! + \internal + + Common initialization code. Requires that \c mw and \c o are set. + Does not call Q3MainWindow::addDockWindow(). +*/ +void Q3ToolBar::init() +{ + d = new Q3ToolBarPrivate; + d->extension = 0; + d->extensionPopup = 0; + sw = 0; + + setBackgroundRole(QPalette::Button); + setFocusPolicy(Qt::NoFocus); + setFrameStyle(QFrame::ToolBarPanel | QFrame::Raised); +} + +/*! + Destructor. +*/ + +Q3ToolBar::~Q3ToolBar() +{ + delete d; +} + +/*! + \reimp +*/ + +void Q3ToolBar::setOrientation(Qt::Orientation o) +{ + Q3DockWindow::setOrientation(o); + if (d->extension) + d->extension->setOrientation(o); + QObjectList childList = children(); + for (int i = 0; i < childList.size(); ++i) { + Q3ToolBarSeparator* w = qobject_cast<Q3ToolBarSeparator*>(childList.at(i)); + if (w) + w->setOrientation(o); + } +} + +/*! + Adds a separator to the right/bottom of the toolbar. +*/ + +void Q3ToolBar::addSeparator() +{ + (void) new Q3ToolBarSeparator(orientation(), this, "toolbar separator"); +} + +/*! + \internal +*/ + +void Q3ToolBar::styleChange(QStyle &oldStyle) +{ + Q3DockWindow::styleChange(oldStyle); +} + + +/*! + \reimp +*/ +void Q3ToolBar::setVisible(bool visible) +{ + Q3DockWindow::setVisible(visible); + if (mw) + mw->triggerLayout(false); + if (visible) + checkForExtension(size()); +} + +/*! + Returns a pointer to the Q3MainWindow which manages this toolbar. +*/ + +Q3MainWindow * Q3ToolBar::mainWindow() const +{ + return mw; +} + + +/*! + Sets the widget \a w to be expanded if this toolbar is requested + to stretch. + + The request to stretch might occur because Q3MainWindow + right-justifies the dock area the toolbar is in, or because this + toolbar's isVerticalStretchable() or isHorizontalStretchable() is + set to true. + + If you call this function and the toolbar is not yet stretchable, + setStretchable() is called. + + \sa Q3MainWindow::setRightJustification(), setVerticalStretchable(), + setHorizontalStretchable() +*/ + +void Q3ToolBar::setStretchableWidget(QWidget * w) +{ + sw = w; + boxLayout()->setStretchFactor(w, 1); + + if (!isHorizontalStretchable() && !isVerticalStretchable()) { + if (orientation() == Qt::Horizontal) + setHorizontalStretchable(true); + else + setVerticalStretchable(true); + } +} + + +/*! + \reimp +*/ + +bool Q3ToolBar::event(QEvent * e) +{ + bool r = Q3DockWindow::event(e); + // After the event filters have dealt with it, do our stuff. + if (e->type() == QEvent::ChildInserted) { + QObject * child = ((QChildEvent*)e)->child(); + if (child && child->isWidgetType() && !((QWidget*)child)->isWindow() + && child->parent() == this + && QLatin1String("qt_dockwidget_internal") != child->objectName()) { + boxLayout()->addWidget((QWidget*)child); + QLayoutItem *item = boxLayout()->itemAt(boxLayout()->indexOf((QWidget*)child)); + if (QToolButton *button = qobject_cast<QToolButton*>(child)) { + item->setAlignment(Qt::AlignHCenter); + button->setFocusPolicy(Qt::NoFocus); + if (mw) { + QObject::connect(mw, SIGNAL(pixmapSizeChanged(bool)), + button, SLOT(setUsesBigPixmap(bool))); + button->setUsesBigPixmap(mw->usesBigPixmaps()); + QObject::connect(mw, SIGNAL(usesTextLabelChanged(bool)), + child, SLOT(setUsesTextLabel(bool))); + button->setUsesTextLabel(mw->usesTextLabel()); + } + button->setAutoRaise(true); + } + if (isVisible()) { + // toolbar compatibility: we auto show widgets that + // are not explicitly hidden + if (((QWidget*)child)->testAttribute(Qt::WA_WState_Hidden) + && !((QWidget*)child)->testAttribute(Qt::WA_WState_ExplicitShowHide)) + ((QWidget*)child)->show(); + checkForExtension(size()); + } + } + if (child && child->isWidgetType() && ((QWidget*)child) == sw) + boxLayout()->setStretchFactor((QWidget*)child, 1); + } else if (e->type() == QEvent::Show) { + layout()->activate(); + } else if (e->type() == QEvent::LayoutHint && place() == OutsideDock) { + adjustSize(); + } + return r; +} + + +/*! + \property Q3ToolBar::label + \brief the toolbar's label. + + If the toolbar is floated the label becomes the toolbar window's + caption. There is no default label text. +*/ + +void Q3ToolBar::setLabel(const QString & label) +{ + l = label; + setWindowTitle(l); +} + +QString Q3ToolBar::label() const +{ + return l; +} + + +/*! + Deletes all the toolbar's child widgets. +*/ + +void Q3ToolBar::clear() +{ + QObjectList childList = children(); + d->extension = 0; + d->extensionPopup = 0; //they will both be destroyed by the following code + for (int i = 0; i < childList.size(); ++i) { + QObject *obj = childList.at(i); + if (obj->isWidgetType() && QLatin1String("qt_dockwidget_internal") != obj->objectName()) + delete obj; + } +} + +/*! + \internal +*/ + +QSize Q3ToolBar::minimumSize() const +{ + if (orientation() == Qt::Horizontal) + return QSize(0, Q3DockWindow::minimumSize().height()); + return QSize(Q3DockWindow::minimumSize().width(), 0); +} + +/*! + \reimp +*/ + +QSize Q3ToolBar::minimumSizeHint() const +{ + if (orientation() == Qt::Horizontal) + return QSize(0, Q3DockWindow::minimumSizeHint().height()); + return QSize(Q3DockWindow::minimumSizeHint().width(), 0); +} + +void Q3ToolBar::createPopup() +{ + if (!d->extensionPopup) { + d->extensionPopup = new Q3PopupMenu(this, "qt_dockwidget_internal"); + connect(d->extensionPopup, SIGNAL(aboutToShow()), this, SLOT(createPopup())); + } + + if (!d->extension) { + d->extension = new Q3ToolBarExtensionWidget(this); + d->extension->setOrientation(orientation()); + d->extension->button()->setPopup(d->extensionPopup); + d->extension->button()->setPopupMode(QToolButton::InstantPopup); + } + + d->extensionPopup->clear(); + + // delete submenus + QObjectList popups = d->extensionPopup->queryList("Q3PopupMenu", 0, false, true); + while (!popups.isEmpty()) + delete popups.takeFirst(); + + QObjectList childlist = queryList("QWidget", 0, false, true); + bool hide = false; + bool doHide = false; + int id; + for (int i = 0; i < childlist.size(); ++i) { + QObject *obj = childlist.at(i); + if (!obj->isWidgetType() || obj == d->extension->button() || obj == d->extensionPopup + || QLatin1String("qt_dockwidget_internal") == obj->objectName()) { + continue; + } + int j = 2; + QWidget *w = (QWidget*)obj; + if (qobject_cast<Q3ComboBox*>(w)) + j = 1; + hide = false; + + const int padding = 4; // extra pixels added by the layout hierarchy + QPoint p(mapTo(this, w->geometry().bottomRight())); + if (orientation() == Qt::Horizontal) { + if ((p.x() > (doHide ? width() - d->extension->width() / j - padding : width() - padding)) + || (p.x() > parentWidget()->width() - d->extension->width())) + hide = true; + } else { + if ((p.y() > (doHide ? height()- d->extension->height() / j - padding : height() - padding)) + || (p.y() > parentWidget()->height() - d->extension->height())) + hide = true; + } + if (hide && w->isVisible()) { + doHide = true; + if (qobject_cast<QToolButton*>(w)) { + QToolButton *b = (QToolButton*)w; + QString s = b->textLabel(); + if (s.isEmpty()) + s = b->text(); + if (b->popup() && b->popupDelay() == 0) + id = d->extensionPopup->insertItem(b->iconSet(), s, b->popup()); + else + id = d->extensionPopup->insertItem(b->iconSet(), s, b, SLOT(click())) ; + if (b->isToggleButton()) + d->extensionPopup->setItemChecked(id, b->isOn()); + if (!b->isEnabled()) + d->extensionPopup->setItemEnabled(id, false); + } else if (qobject_cast<QAbstractButton*>(w)) { + QAbstractButton *b = (QAbstractButton*)w; + QString s = b->text(); + if (s.isEmpty()) + s = QLatin1String(""); + if (b->pixmap()) + id = d->extensionPopup->insertItem(*b->pixmap(), s, b, SLOT(click())); + else + id = d->extensionPopup->insertItem(s, b, SLOT(click())); + if (b->isToggleButton()) + d->extensionPopup->setItemChecked(id, b->isOn()); + if (!b->isEnabled()) + d->extensionPopup->setItemEnabled(id, false); +#ifndef QT_NO_COMBOBOX + } else if (qobject_cast<Q3ComboBox*>(w)) { + Q3ComboBox *c = (Q3ComboBox*)w; + if (c->count() != 0) { + QString s = c->windowTitle(); + if (s.isEmpty()) + s = c->currentText(); + int maxItems = 0; + Q3PopupMenu *cp = new Q3PopupMenu(d->extensionPopup); + cp->setEnabled(c->isEnabled()); + d->extensionPopup->insertItem(s, cp); + connect(cp, SIGNAL(activated(int)), c, SLOT(internalActivate(int))); + for (int i = 0; i < c->count(); ++i) { + QString tmp = c->text(i); + cp->insertItem(tmp, i); + if (c->currentText() == tmp) + cp->setItemChecked(i, true); + if (!maxItems) { + if (cp->actions().count() == 10) { + int h = cp->sizeHint().height(); + maxItems = QApplication::desktop()->height() * 10 / h; + } + } else if (cp->actions().count() >= maxItems - 1) { + Q3PopupMenu* sp = new Q3PopupMenu(d->extensionPopup); + cp->insertItem(tr("More..."), sp); + cp = sp; + connect(cp, SIGNAL(activated(int)), c, SLOT(internalActivate(int))); + } + } + } +#endif //QT_NO_COMBOBOX + } + } + } +} + +/*! + \reimp +*/ + +void Q3ToolBar::resizeEvent(QResizeEvent *e) +{ + Q3DockWindow::resizeEvent(e); + checkForExtension(e->size()); +} + +/*! + \internal + + This function is called when an action is triggered. The relevant + information is passed in the event \a e. +*/ +void Q3ToolBar::actionEvent(QActionEvent *e) +{ + if (e->type() == QEvent::ActionAdded) { + QAction *a = e->action(); + QWidget *w; + if (a->isSeparator()) { + w = new Q3ToolBarSeparator(orientation(), this, "toolbar separator"); + } else { + QToolButton* btn = new QToolButton(this); + btn->setDefaultAction(a); + w = btn; + } + d->actions.insert(a, w); + } else if (e->type() == QEvent::ActionRemoved) { + QAction *a = e->action(); + delete d->actions.take(a); + } +} + + +void Q3ToolBar::checkForExtension(const QSize &sz) +{ + if (!isVisible()) + return; + + if (d->checkingExtension) + return; + d->checkingExtension = true; + + bool tooSmall; + if (orientation() == Qt::Horizontal) + tooSmall = sz.width() < sizeHint().width(); + else + tooSmall = sz.height() < sizeHint().height(); + + if (tooSmall) { + createPopup(); + if (d->extensionPopup->actions().count()) { + // parentWidget()->width() used since the Q3ToolBar width + // will never be less than minimumSize() + if (orientation() == Qt::Horizontal) + d->extension->setGeometry((parentWidget() ? parentWidget()->width() : width()) - 20, + 1, 20, height() - 2); + else + d->extension->setGeometry(1, (parentWidget() ? parentWidget()->height() : height()) - 20, + width() - 2, 20); + d->extension->show(); + d->extension->raise(); + } else { + delete d->extension; + d->extension = 0; + delete d->extensionPopup; + d->extensionPopup = 0; + } + } else { + delete d->extension; + d->extension = 0; + delete d->extensionPopup; + d->extensionPopup = 0; + } + d->checkingExtension = false; +} + + +/*! + \internal +*/ + +void Q3ToolBar::setMinimumSize(int, int) +{ +} + +/* from chaunsee: + +1. Tool Bars should contain only high-frequency functions. Avoid putting +things like About and Exit on a tool bar unless they are frequent functions. + +2. All tool bar buttons must have some keyboard access method (it can be a +menu or shortcut key or a function in a dialog box that can be accessed +through the keyboard). + +3. Make tool bar functions as efficient as possible (the common example is to +Print in Microsoft applications, it doesn't bring up the Print dialog box, it +prints immediately to the default printer). + +4. Avoid turning tool bars into graphical menu bars. To me, a tool bar should +be efficient. Once you make almost all the items in a tool bar into graphical +pull-down menus, you start to lose efficiency. + +5. Make sure that adjacent icons are distinctive. There are some tool bars +where you see a group of 4-5 icons that represent related functions, but they +are so similar that you can't differentiate among them. These tool bars are +often a poor attempt at a "common visual language". + +6. Use any de facto standard icons of your platform (for windows use the +cut, copy and paste icons provided in dev kits rather than designing your +own). + +7. Avoid putting a highly destructive tool bar button (delete database) by a +safe, high-frequency button (Find) -- this will yield 1-0ff errors). + +8. Tooltips in many Microsoft products simply reiterate the menu text even +when that is not explanatory. Consider making your tooltips slightly more +verbose and explanatory than the corresponding menu item. + +9. Keep the tool bar as stable as possible when you click on different +objects. Consider disabling tool bar buttons if they are used in most, but not +all contexts. + +10. If you have multiple tool bars (like the Microsoft MMC snap-ins have), +put the most stable tool bar to at the left with less stable ones to the +right. This arrangement (stable to less stable) makes the tool bar somewhat +more predictable. + +11. Keep a single tool bar to fewer than 20 items divided into 4-7 groups of +items. +*/ + +QT_END_NAMESPACE + +#endif diff --git a/src/qt3support/widgets/q3toolbar.h b/src/qt3support/widgets/q3toolbar.h new file mode 100644 index 0000000..9e5c514 --- /dev/null +++ b/src/qt3support/widgets/q3toolbar.h @@ -0,0 +1,122 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the Qt3Support module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, 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 qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef Q3TOOLBAR_H +#define Q3TOOLBAR_H + +#include <Qt3Support/q3dockwindow.h> + +QT_BEGIN_HEADER + +QT_BEGIN_NAMESPACE + +QT_MODULE(Qt3SupportLight) + +#ifndef QT_NO_TOOLBAR + +class Q3MainWindow; +class Q3ToolBarPrivate; + +class Q_COMPAT_EXPORT Q3ToolBar: public Q3DockWindow +{ + Q_OBJECT + Q_PROPERTY(QString label READ label WRITE setLabel) + +public: + Q3ToolBar(const QString &label, + Q3MainWindow *, Qt::ToolBarDock = Qt::DockTop, + bool newLine = false, const char* name=0); + Q3ToolBar(const QString &label, Q3MainWindow *, QWidget *, + bool newLine = false, const char* name=0, Qt::WindowFlags f = 0); + Q3ToolBar(Q3MainWindow* parent=0, const char* name=0); + ~Q3ToolBar(); + + void addSeparator(); + + void setVisible(bool visible); + + Q3MainWindow * mainWindow() const; + + virtual void setStretchableWidget(QWidget *); + + bool event(QEvent * e); + + virtual void setLabel(const QString &); + QString label() const; + + virtual void clear(); + + QSize minimumSize() const; + QSize minimumSizeHint() const; + + void setOrientation(Qt::Orientation o); + void setMinimumSize(int minw, int minh); + +protected: + void resizeEvent(QResizeEvent *e); + void styleChange(QStyle &); + void actionEvent(QActionEvent *); + +private Q_SLOTS: + void createPopup(); + +private: + void init(); + void checkForExtension(const QSize &sz); + Q3ToolBarPrivate * d; + Q3MainWindow * mw; + QWidget * sw; + QString l; + + friend class Q3MainWindow; + friend class Q3DockAreaLayout; + +private: + Q_DISABLE_COPY(Q3ToolBar) +}; + +#endif // QT_NO_TOOLBAR + +QT_END_NAMESPACE + +QT_END_HEADER + +#endif // Q3TOOLBAR_H diff --git a/src/qt3support/widgets/q3vbox.cpp b/src/qt3support/widgets/q3vbox.cpp new file mode 100644 index 0000000..82112cd --- /dev/null +++ b/src/qt3support/widgets/q3vbox.cpp @@ -0,0 +1,72 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the Qt3Support module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, 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 qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + + +#include "q3vbox.h" + +QT_BEGIN_NAMESPACE + +/*! + \class Q3VBox + \brief The Q3VBox widget provides vertical geometry management of + its child widgets. + + \compat + + All its child widgets will be placed vertically and sized + according to their sizeHint()s. + + \img qvbox-m.png Q3VBox + + \sa Q3HBox +*/ + + +/*! + Constructs a vbox widget called \a name with parent \a parent and + widget flags \a f. + */ +Q3VBox::Q3VBox( QWidget *parent, const char *name, Qt::WindowFlags f ) + :Q3HBox( false, parent, name, f ) +{ +} + +QT_END_NAMESPACE diff --git a/src/qt3support/widgets/q3vbox.h b/src/qt3support/widgets/q3vbox.h new file mode 100644 index 0000000..34fedb7 --- /dev/null +++ b/src/qt3support/widgets/q3vbox.h @@ -0,0 +1,67 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the Qt3Support module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, 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 qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef Q3VBOX_H +#define Q3VBOX_H + +#include <Qt3Support/q3hbox.h> + +QT_BEGIN_HEADER + +QT_BEGIN_NAMESPACE + +QT_MODULE(Qt3SupportLight) + +class Q_COMPAT_EXPORT Q3VBox : public Q3HBox +{ + Q_OBJECT +public: + Q3VBox(QWidget* parent=0, const char* name=0, Qt::WindowFlags f=0); + +private: + Q_DISABLE_COPY(Q3VBox) +}; + +QT_END_NAMESPACE + +QT_END_HEADER + +#endif // Q3VBOX_H diff --git a/src/qt3support/widgets/q3vgroupbox.cpp b/src/qt3support/widgets/q3vgroupbox.cpp new file mode 100644 index 0000000..c39a6d7 --- /dev/null +++ b/src/qt3support/widgets/q3vgroupbox.cpp @@ -0,0 +1,92 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the Qt3Support module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, 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 qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "q3vgroupbox.h" + +QT_BEGIN_NAMESPACE + +/*! + \class Q3VGroupBox + + \brief The Q3VGroupBox widget organizes widgets in a group with one + vertical column. + + \compat + + Q3VGroupBox is a convenience class that offers a thin layer on top + of Q3GroupBox. Think of it as a Q3VBox that offers a frame with a + title. + + \sa Q3HGroupBox +*/ + +/*! + Constructs a horizontal group box with no title. + + The \a parent and \a name arguments are passed to the QWidget + constructor. +*/ +Q3VGroupBox::Q3VGroupBox( QWidget *parent, const char *name ) + : Q3GroupBox( 1, Qt::Horizontal /* sic! */, parent, name ) +{ +} + +/*! + Constructs a horizontal group box with the title \a title. + + The \a parent and \a name arguments are passed to the QWidget + constructor. +*/ + +Q3VGroupBox::Q3VGroupBox( const QString &title, QWidget *parent, + const char *name ) + : Q3GroupBox( 1, Qt::Horizontal /* sic! */, title, parent, name ) +{ +} + +/*! + Destroys the horizontal group box, deleting its child widgets. +*/ +Q3VGroupBox::~Q3VGroupBox() +{ +} + +QT_END_NAMESPACE diff --git a/src/qt3support/widgets/q3vgroupbox.h b/src/qt3support/widgets/q3vgroupbox.h new file mode 100644 index 0000000..f4fb5ed --- /dev/null +++ b/src/qt3support/widgets/q3vgroupbox.h @@ -0,0 +1,69 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the Qt3Support module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, 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 qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef Q3VGROUPBOX_H +#define Q3VGROUPBOX_H + +#include <Qt3Support/q3groupbox.h> + +QT_BEGIN_HEADER + +QT_BEGIN_NAMESPACE + +QT_MODULE(Qt3SupportLight) + +class Q_COMPAT_EXPORT Q3VGroupBox : public Q3GroupBox +{ + Q_OBJECT +public: + Q3VGroupBox( QWidget* parent=0, const char* name=0 ); + Q3VGroupBox( const QString &title, QWidget* parent=0, const char* name=0 ); + ~Q3VGroupBox(); + +private: + Q_DISABLE_COPY(Q3VGroupBox) +}; + +QT_END_NAMESPACE + +QT_END_HEADER + +#endif // Q3VGROUPBOX_H diff --git a/src/qt3support/widgets/q3whatsthis.cpp b/src/qt3support/widgets/q3whatsthis.cpp new file mode 100644 index 0000000..30d3801 --- /dev/null +++ b/src/qt3support/widgets/q3whatsthis.cpp @@ -0,0 +1,220 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the Qt3Support module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, 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 qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "q3whatsthis.h" +#ifndef QT_NO_WHATSTHIS +#include "qapplication.h" +#include "qwidget.h" +#include "qevent.h" + +QT_BEGIN_NAMESPACE + +/*! \class Q3WhatsThis + \compat +*/ + +/*! + Constructs a new "What's This?" object for \a widget. +*/ +Q3WhatsThis::Q3WhatsThis(QWidget *widget) + : QObject(widget) +{ + if (widget) + widget->installEventFilter(this); +} + +/*! + Destroys the "What's This?" object. +*/ +Q3WhatsThis::~Q3WhatsThis() +{ +} + +/*! + \internal + + Handles "What's This?" events. +*/ +bool Q3WhatsThis::eventFilter(QObject *o, QEvent *e) +{ + if (o != parent() || !o->isWidgetType()) + return false; + + if (e->type() == QEvent::WhatsThis) { + QString s = text(static_cast<QHelpEvent*>(e)->pos()); + if (!s.isEmpty()) + QWhatsThis::showText(static_cast<QHelpEvent*>(e)->globalPos(), s, static_cast<QWidget*>(o)); + } else if (e->type() == QEvent::QueryWhatsThis) { + QString s = text(static_cast<QHelpEvent*>(e)->pos()); + if (s.isEmpty()) + return false; + } else if (e->type() == QEvent::WhatsThisClicked) { + QString href = static_cast<QWhatsThisClickedEvent*>(e)->href(); + if (clicked(href)) + QWhatsThis::hideText(); + } else { + return false; + } + return true; +} + +/*! + This virtual function returns the text for position \a pos in the + widget that this "What's This?" object documents. If there is no + "What's This?" text for the position, an empty string is returned. + + The default implementation returns an empty string. +*/ +QString Q3WhatsThis::text(const QPoint & /* pos */) +{ + if (parent() && parent()->isWidgetType()) + return static_cast<QWidget*>(parent())->whatsThis(); + return QString(); +} + +/*! + This virtual function is called when the user clicks inside the + "What's this?" window. \a href is the link the user clicked on, or + an empty string if there was no link. + + If the function returns true (the default), the "What's this?" + window is closed, otherwise it remains visible. + + The default implementation ignores \a href and returns true. +*/ +bool Q3WhatsThis::clicked(const QString & /* href */) +{ + return true; +} + +/*! + \fn void Q3WhatsThis::enterWhatsThisMode() + + Enters "What's This?" mode and returns immediately. + + Qt will install a special cursor and take over mouse input until + the user clicks somewhere. It then shows any help available and + ends "What's This?" mode. Finally, Qt removes the special cursor + and help window and then restores ordinary event processing, at + which point the left mouse button is no longer pressed. + + The user can also use the Esc key to leave "What's This?" mode. + + \sa inWhatsThisMode(), leaveWhatsThisMode() +*/ + +/*! + \fn bool Q3WhatsThis::inWhatsThisMode() + + Returns true if the application is in "What's This?" mode; + otherwise returns false. + + \sa enterWhatsThisMode(), leaveWhatsThisMode() +*/ + +/*! + \fn void Q3WhatsThis::add(QWidget *widget, const QString &text) + + Adds \a text as "What's This?" help for \a widget. If the text is + rich text formatted (i.e. it contains markup) it will be rendered + with the default stylesheet QStyleSheet::defaultSheet(). + + The text is destroyed if the widget is later destroyed, so it need + not be explicitly removed. + + \sa remove() +*/ + +/*! + \fn void Q3WhatsThis::remove(QWidget *widget) + + Removes the "What's This?" help associated with the \a widget. + This happens automatically if the widget is destroyed. + + \sa add() +*/ + +/*! + \fn void Q3WhatsThis::leaveWhatsThisMode(const QString& text = QString(), const QPoint& pos = QCursor::pos(), QWidget* widget = 0) + + This function is used internally by widgets that support + QWidget::customWhatsThis(); applications do not usually call it. + An example of such a widget is Q3PopupMenu: menus still work + normally in "What's This?" mode but also provide help texts for + individual menu items. + + If \a text is not empty, a "What's This?" help window is + displayed at the global screen position \a pos. If widget \a widget is + not 0 and has its own dedicated QWhatsThis object, this object + will receive clicked() messages when the user clicks on hyperlinks + inside the help text. + + \sa inWhatsThisMode(), enterWhatsThisMode(), clicked() +*/ + +/*! + \fn void Q3WhatsThis::display(const QString &text, const QPoint &pos, QWidget *widget) + + Display \a text in a help window at the global screen position \a + pos. + + If widget \a widget is not 0 and has its own dedicated QWhatsThis + object, this object will receive clicked() messages when the user + clicks on hyperlinks inside the help text. + + \sa clicked() +*/ + +/*! + Creates a QToolButton preconfigured to enter "What's This?" mode + when clicked. You will often use this with a tool bar as \a + parent: + + \snippet doc/src/snippets/code/src_qt3support_widgets_q3whatsthis.cpp 0 +*/ +QToolButton *Q3WhatsThis::whatsThisButton(QWidget * parent) +{ + return QWhatsThis::whatsThisButton(parent); +} + +QT_END_NAMESPACE + +#endif // QT_NO_WHATSTHIS diff --git a/src/qt3support/widgets/q3whatsthis.h b/src/qt3support/widgets/q3whatsthis.h new file mode 100644 index 0000000..cf841b6 --- /dev/null +++ b/src/qt3support/widgets/q3whatsthis.h @@ -0,0 +1,89 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the Qt3Support module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, 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 qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef Q3WHATSTHIS_H +#define Q3WHATSTHIS_H + +#include <QtGui/qcursor.h> +#include <QtGui/qwhatsthis.h> +#include <QtGui/qwidget.h> + +QT_BEGIN_HEADER + +QT_BEGIN_NAMESPACE + +QT_MODULE(Qt3SupportLight) + +#ifndef QT_NO_WHATSTHIS + +class QToolButton; + +class Q_COMPAT_EXPORT Q3WhatsThis: public QObject +{ + Q_OBJECT +public: + Q3WhatsThis(QWidget *); + ~Q3WhatsThis(); + bool eventFilter(QObject *, QEvent *); + + static inline void enterWhatsThisMode() { QWhatsThis::enterWhatsThisMode(); } + static inline bool inWhatsThisMode() { return QWhatsThis::inWhatsThisMode(); } + + static inline void add(QWidget *w, const QString &s) { w->setWhatsThis(s); } + static inline void remove(QWidget *w) { w->setWhatsThis(QString()); } + static QToolButton * whatsThisButton(QWidget * parent); + static inline void leaveWhatsThisMode(const QString& text = QString(), const QPoint& pos = QCursor::pos(), QWidget* w = 0) + { QWhatsThis::showText(pos, text, w); } + static inline void display(const QString& text, const QPoint& pos = QCursor::pos(), QWidget* w = 0) + { QWhatsThis::showText(pos, text, w); } + + virtual QString text(const QPoint &); + virtual bool clicked(const QString& href); + +}; + +#endif // QT_NO_WHATSTHIS + +QT_END_NAMESPACE + +QT_END_HEADER + +#endif // Q3WHATSTHIS_H diff --git a/src/qt3support/widgets/q3widgetstack.cpp b/src/qt3support/widgets/q3widgetstack.cpp new file mode 100644 index 0000000..320c089 --- /dev/null +++ b/src/qt3support/widgets/q3widgetstack.cpp @@ -0,0 +1,571 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the Qt3Support module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, 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 qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "q3widgetstack.h" +#include "qlayout.h" +#include "private/qlayoutengine_p.h" +#include "qapplication.h" +#include "qpainter.h" + +QT_BEGIN_NAMESPACE + +using namespace Qt; + +class Q3WidgetStackPrivate { +public: + class Invisible: public QWidget + { + public: + Invisible(Q3WidgetStack * parent): QWidget(parent, "qt_invisible_widgetstack") + { + setBackgroundMode(NoBackground); + } + const char * className() const + { + return "Q3WidgetStackPrivate::Invisible"; + } + protected: + void paintEvent(QPaintEvent *) + { + QPainter(this).eraseRect(rect()); + } + }; + + int nextNegativeID; + int nextPositiveID; +}; + + + +/*! + \class Q3WidgetStack + \brief The Q3WidgetStack class provides a stack of widgets of which + only the top widget is user-visible. + + \compat + + The application programmer can move any widget to the top of the + stack at any time using raiseWidget(), and add or remove widgets + using addWidget() and removeWidget(). It is not sufficient to pass + the widget stack as parent to a widget which should be inserted into + the widgetstack. + + visibleWidget() is the \e get equivalent of raiseWidget(); it + returns a pointer to the widget that is currently at the top of + the stack. + + Q3WidgetStack also provides the ability to manipulate widgets + through application-specified integer IDs. You can also translate + from widget pointers to IDs using id() and from IDs to widget + pointers using widget(). These numeric IDs are unique (per + Q3WidgetStack, not globally), but Q3WidgetStack does not attach any + additional meaning to them. + + The default widget stack is frameless, but you can use the usual + Q3Frame functions (such as setFrameStyle()) to add a frame. + + Q3WidgetStack provides a signal, aboutToShow(), which is emitted + just before a managed widget is shown. + + \sa Q3TabDialog QTabWidget QTabBar Q3Frame +*/ + + +/*! + Constructs an empty widget stack. + + The \a parent, \a name and \a f arguments are passed to the Q3Frame + constructor. +*/ +Q3WidgetStack::Q3WidgetStack(QWidget * parent, const char *name, Qt::WindowFlags f) + : Q3Frame(parent, name, f) //## merge constructors in 4.0 +{ + init(); +} + +void Q3WidgetStack::init() +{ + d = new Q3WidgetStackPrivate(); + d->nextNegativeID = -2; + d->nextPositiveID = 0; + dict = new Q3IntDict<QWidget>; + focusWidgets = 0; + topWidget = 0; + invisible = 0; + invisible = new Q3WidgetStackPrivate::Invisible(this); + invisible->hide(); +} + + +/*! + Destroys the object and frees any allocated resources. +*/ + +Q3WidgetStack::~Q3WidgetStack() +{ + delete focusWidgets; + delete d; + delete dict; +} + + +/*! + Adds widget \a w to this stack of widgets, with ID \a id. + + If you pass an id \>= 0 this ID is used. If you pass an \a id of + -1 (the default), the widgets will be numbered automatically. If + you pass -2 a unique negative integer will be generated. No widget + has an ID of -1. Returns the ID or -1 on failure (e.g. \a w is 0). + + If you pass an id that is already used, then a unique negative + integer will be generated to prevent two widgets having the same + id. + + If \a w already exists in the stack the widget will be removed first. + + If \a w is not a child of this Q3WidgetStack moves it using + reparent(). +*/ + +int Q3WidgetStack::addWidget(QWidget * w, int id) +{ + if (!w || w == invisible || invisible == 0) + return -1; + + // prevent duplicates + removeWidget(w); + + if (id >= 0 && dict->find(id)) + id = -2; + if (id < -1) + id = d->nextNegativeID--; + else if (id == -1) + id = d->nextPositiveID++; + else + d->nextPositiveID = qMax(d->nextPositiveID, id + 1); + // use id >= 0 as-is + + dict->insert(id, w); + + // preserve existing focus + QWidget * f = w->focusWidget(); + while(f && f != w) + f = f->parentWidget(); + if (f) { + if (!focusWidgets) + focusWidgets = new Q3PtrDict<QWidget>(17); + focusWidgets->replace(w, w->focusWidget()); + } + + w->hide(); + if (w->parent() != this) + w->reparent(this, contentsRect().topLeft(), false); + w->setGeometry(contentsRect()); + updateGeometry(); + return id; +} + + +/*! + Removes widget \a w from this stack of widgets. Does not delete \a + w. If \a w is the currently visible widget, no other widget is + substituted. + + \sa visibleWidget() raiseWidget() +*/ + +void Q3WidgetStack::removeWidget(QWidget * w) +{ + int i; + if (!w || (i = id(w)) == -1) + return ; + + dict->take(i); + if (w == topWidget) + topWidget = 0; + if (dict->isEmpty()) + invisible->hide(); // let background shine through again + updateGeometry(); +} + + +/*! + Raises the widget with ID \a id to the top of the widget stack. + + \sa visibleWidget() +*/ + +void Q3WidgetStack::raiseWidget(int id) +{ + if (id == -1) + return; + QWidget * w = dict->find(id); + if (w) + raiseWidget(w); +} + +static bool isChildOf(QWidget* child, QWidget *parent) +{ + if (!child) + return false; + QObjectList list = parent->children(); + for (int i = 0; i < list.size(); ++i) { + QObject *obj = list.at(i); + if (!obj->isWidgetType()) + continue; + QWidget *widget = static_cast<QWidget *>(obj); + if (!widget->isWindow()) + continue; + if (widget == child || isChildOf(child, widget)) + return true; + } + return false; +} + +/*! + \overload + + Raises widget \a w to the top of the widget stack. +*/ + +void Q3WidgetStack::raiseWidget(QWidget *w) +{ + if (!w || w == invisible || w->parent() != this || w == topWidget) + return; + + if (id(w) == -1) + addWidget(w); + if (!isVisible()) { + topWidget = w; + return; + } + + if (w->maximumSize().width() < invisible->width() + || w->maximumSize().height() < invisible->height()) + invisible->setBackgroundMode(backgroundMode()); + else if (invisible->backgroundMode() != NoBackground) + invisible->setBackgroundMode(NoBackground); + + if (invisible->isHidden()) { + invisible->setGeometry(contentsRect()); + invisible->lower(); + invisible->show(); + QApplication::sendPostedEvents(invisible, QEvent::ShowWindowRequest); + } + + // try to move focus onto the incoming widget if focus + // was somewhere on the outgoing widget. + if (topWidget) { + QWidget * fw = window()->focusWidget(); + if (topWidget->isAncestorOf(fw)) { // focus was on old page + // look for the best focus widget we can find + QWidget *p = w->focusWidget(); + if (!p) { + // second best == first child widget in the focus chain + QWidget *i = fw; + while ((i = i->nextInFocusChain()) != fw) { + if (((i->focusPolicy() & Qt::TabFocus) == Qt::TabFocus) + && !i->focusProxy() && i->isVisibleTo(w) && i->isEnabled() + && w->isAncestorOf(i)) { + p = i; + break; + } + } + } + if (p) + p->setFocus(); + } else { + // the focus wasn't on the old page, so we have to ensure focus doesn't go to + // the widget in the page that last had focus when we show the page again. + QWidget *oldfw = topWidget->focusWidget(); + if (oldfw) + oldfw->clearFocus(); + } + } + + if (isVisible()) { + emit aboutToShow(w); + int i = id(w); + if (i != -1) + emit aboutToShow(i); + } + + topWidget = w; + + QObjectList c = children(); + for (int i = 0; i < c.size(); ++i) { + QObject * o = c.at(i); + if (o->isWidgetType() && o != w && o != invisible) + static_cast<QWidget *>(o)->hide(); + } + + w->setGeometry(invisible->geometry()); + w->show(); +} + +/*! + \reimp +*/ + +void Q3WidgetStack::frameChanged() +{ + Q3Frame::frameChanged(); + setChildGeometries(); +} + + +/*! + \internal +*/ + +void Q3WidgetStack::setFrameRect(const QRect & r) +{ + // ### this function used to be virtual in QFrame in Qt 3; it is no longer virtual in Qt 4 + Q3Frame::setFrameRect(r); + setChildGeometries(); +} + + +/*! + Fixes up the children's geometries. +*/ + +void Q3WidgetStack::setChildGeometries() +{ + invisible->setGeometry(contentsRect()); + if (topWidget) + topWidget->setGeometry(invisible->geometry()); +} + + +/*! + \reimp +*/ +void Q3WidgetStack::setVisible(bool visible) +{ + if (visible) { + // Reimplemented in order to set the children's geometries + // appropriately and to pick the first widget as d->topWidget if no + // topwidget was defined + QObjectList c = children(); + if (!isVisible() && !c.isEmpty()) { + for (int i = 0; i < c.size(); ++i) { + QObject * o = c.at(i); + if (o->isWidgetType()) { + if (!topWidget && o != invisible) + topWidget = static_cast<QWidget*>(o); + if (o == topWidget) + static_cast<QWidget *>(o)->show(); + else + static_cast<QWidget *>(o)->hide(); + } + } + setChildGeometries(); + } + } + Q3Frame::setVisible(visible); +} + + +/*! + Returns the widget with ID \a id. Returns 0 if this widget stack + does not manage a widget with ID \a id. + + \sa id() addWidget() +*/ + +QWidget * Q3WidgetStack::widget(int id) const +{ + return id != -1 ? dict->find(id) : 0; +} + + +/*! + Returns the ID of the \a widget. Returns -1 if \a widget is 0 or + is not being managed by this widget stack. + + \sa widget() addWidget() +*/ + +int Q3WidgetStack::id(QWidget * widget) const +{ + if (!widget) + return -1; + + Q3IntDictIterator<QWidget> it(*dict); + while (it.current() && it.current() != widget) + ++it; + return it.current() == widget ? it.currentKey() : -1; +} + + +/*! + Returns the currently visible widget (the one at the top of the + stack), or 0 if nothing is currently being shown. + + \sa aboutToShow() id() raiseWidget() +*/ + +QWidget * Q3WidgetStack::visibleWidget() const +{ + return topWidget; +} + + +/*! + \fn void Q3WidgetStack::aboutToShow(int id) + + This signal is emitted just before a managed widget is shown if + that managed widget has an ID != -1. The \a id parameter is the numeric + ID of the widget. + + If you call visibleWidget() in a slot connected to aboutToShow(), + the widget it returns is the one that is currently visible, not + the one that is about to be shown. +*/ + + +/*! + \fn void Q3WidgetStack::aboutToShow(QWidget *widget) + + \overload + + This signal is emitted just before a managed widget is shown. The + argument is a pointer to the \a widget. + + If you call visibleWidget() in a slot connected to aboutToShow(), + the widget returned is the one that is currently visible, not the + one that is about to be shown. +*/ + + +/*! + \reimp +*/ + +void Q3WidgetStack::resizeEvent(QResizeEvent * e) +{ + Q3Frame::resizeEvent(e); + setChildGeometries(); +} + + +/*! + \reimp +*/ + +QSize Q3WidgetStack::sizeHint() const +{ + constPolish(); + + QSize size(0, 0); + + Q3IntDictIterator<QWidget> it(*dict); + QWidget *w; + + while ((w = it.current()) != 0) { + ++it; + QSize sh = w->sizeHint(); + if (w->sizePolicy().horData() == QSizePolicy::Ignored) + sh.rwidth() = 0; + if (w->sizePolicy().verData() == QSizePolicy::Ignored) + sh.rheight() = 0; +#ifndef QT_NO_LAYOUT + size = size.expandedTo(sh).expandedTo(qSmartMinSize(w)); +#endif + } + if (size.isNull()) + size = QSize(128, 64); + size += QSize(2*frameWidth(), 2*frameWidth()); + return size; +} + + +/*! + \reimp +*/ +QSize Q3WidgetStack::minimumSizeHint() const +{ + constPolish(); + + QSize size(0, 0); + + Q3IntDictIterator<QWidget> it(*dict); + QWidget *w; + + while ((w = it.current()) != 0) { + ++it; + QSize sh = w->minimumSizeHint(); + if (w->sizePolicy().horData() == QSizePolicy::Ignored) + sh.rwidth() = 0; + if (w->sizePolicy().verData() == QSizePolicy::Ignored) + sh.rheight() = 0; +#ifndef QT_NO_LAYOUT + size = size.expandedTo(sh).expandedTo(w->minimumSize()); +#endif + } + if (size.isNull()) + size = QSize(64, 32); + size += QSize(2*frameWidth(), 2*frameWidth()); + return size; +} + +/*! + \reimp +*/ +void Q3WidgetStack::childEvent(QChildEvent *e) +{ + if (e->child()->isWidgetType() && e->removed()) + removeWidget((QWidget *) e->child()); +} + + +/*! + \reimp +*/ +bool Q3WidgetStack::event(QEvent* e) +{ + if (e->type() == QEvent::LayoutRequest || e->type() == QEvent::LayoutHint ) + updateGeometry(); // propgate layout hints to parent + return Q3Frame::event(e); +} + +QT_END_NAMESPACE diff --git a/src/qt3support/widgets/q3widgetstack.h b/src/qt3support/widgets/q3widgetstack.h new file mode 100644 index 0000000..3d10fd4 --- /dev/null +++ b/src/qt3support/widgets/q3widgetstack.h @@ -0,0 +1,112 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the Qt3Support module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, 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 qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef Q3WIDGETSTACK_H +#define Q3WIDGETSTACK_H + +#include <Qt3Support/q3frame.h> +#include <Qt3Support/q3intdict.h> +#include <Qt3Support/q3ptrdict.h> + +QT_BEGIN_HEADER + +QT_BEGIN_NAMESPACE + +QT_MODULE(Qt3SupportLight) + +class Q3WidgetStackPrivate; + + +class Q_COMPAT_EXPORT Q3WidgetStack: public Q3Frame +{ + Q_OBJECT +public: + Q3WidgetStack(QWidget* parent, const char* name=0, Qt::WindowFlags f=0); + + ~Q3WidgetStack(); + + int addWidget(QWidget *, int = -1); + void removeWidget(QWidget *); + + QSize sizeHint() const; + QSize minimumSizeHint() const; + void setVisible(bool visible); + + QWidget * widget(int) const; + int id(QWidget *) const; + + QWidget * visibleWidget() const; + + void setFrameRect(const QRect &); + +Q_SIGNALS: + void aboutToShow(int); + void aboutToShow(QWidget *); + +public Q_SLOTS: + void raiseWidget(int); + void raiseWidget(QWidget *); + +protected: + void frameChanged(); + void resizeEvent(QResizeEvent *); + bool event(QEvent* e); + + virtual void setChildGeometries(); + void childEvent(QChildEvent *); + +private: + void init(); + + Q3WidgetStackPrivate * d; + Q3IntDict<QWidget> * dict; + Q3PtrDict<QWidget> * focusWidgets; + QWidget * topWidget; + QWidget * invisible; + + Q_DISABLE_COPY(Q3WidgetStack) +}; + +QT_END_NAMESPACE + +QT_END_HEADER + +#endif // Q3WIDGETSTACK_H diff --git a/src/qt3support/widgets/widgets.pri b/src/qt3support/widgets/widgets.pri new file mode 100644 index 0000000..9bd6fb4 --- /dev/null +++ b/src/qt3support/widgets/widgets.pri @@ -0,0 +1,58 @@ +# Qt compat module + +HEADERS += \ + widgets/q3action.h \ + widgets/q3buttongroup.h \ + widgets/q3datetimeedit.h \ + widgets/q3dockarea.h \ + widgets/q3dockwindow.h \ + widgets/q3frame.h \ + widgets/q3vbox.h \ + widgets/q3vgroupbox.h \ + widgets/q3hbox.h \ + widgets/q3hgroupbox.h \ + widgets/q3grid.h \ + widgets/q3gridview.h \ + widgets/q3groupbox.h \ + widgets/q3header.h \ + widgets/q3mainwindow.h \ + widgets/q3mainwindow_p.h \ + widgets/q3progressbar.h \ + widgets/q3scrollview.h \ + widgets/q3titlebar_p.h \ + widgets/q3toolbar.h \ + widgets/q3whatsthis.h \ + widgets/q3widgetstack.h \ + widgets/q3button.h \ + widgets/q3rangecontrol.h \ + widgets/q3popupmenu.h \ + widgets/q3combobox.h + +SOURCES += \ + widgets/q3action.cpp \ + widgets/q3buttongroup.cpp \ + widgets/q3datetimeedit.cpp \ + widgets/q3dockarea.cpp \ + widgets/q3dockwindow.cpp \ + widgets/q3frame.cpp \ + widgets/q3vbox.cpp \ + widgets/q3vgroupbox.cpp \ + widgets/q3hbox.cpp \ + widgets/q3hgroupbox.cpp \ + widgets/q3grid.cpp \ + widgets/q3gridview.cpp \ + widgets/q3groupbox.cpp \ + widgets/q3header.cpp \ + widgets/q3mainwindow.cpp \ + widgets/q3progressbar.cpp \ + widgets/q3scrollview.cpp \ + widgets/q3titlebar.cpp \ + widgets/q3toolbar.cpp \ + widgets/q3whatsthis.cpp \ + widgets/q3widgetstack.cpp \ + widgets/q3button.cpp \ + widgets/q3rangecontrol.cpp \ + widgets/q3spinwidget.cpp \ + widgets/q3popupmenu.cpp \ + widgets/q3combobox.cpp + |