diff options
Diffstat (limited to 'src/qt3support/widgets/q3toolbar.cpp')
| -rw-r--r-- | src/qt3support/widgets/q3toolbar.cpp | 840 |
1 files changed, 840 insertions, 0 deletions
diff --git a/src/qt3support/widgets/q3toolbar.cpp b/src/qt3support/widgets/q3toolbar.cpp new file mode 100644 index 0000000..dc0a9fd --- /dev/null +++ b/src/qt3support/widgets/q3toolbar.cpp @@ -0,0 +1,840 @@ +/**************************************************************************** +** +** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies). +** Contact: Qt Software Information (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 either Technology Preview License Agreement or the +** Beta Release License Agreement. +** +** 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.0, included in the file LGPL_EXCEPTION.txt in this +** package. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 3.0 as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU General Public License version 3.0 requirements will be +** met: http://www.gnu.org/copyleft/gpl.html. +** +** If you are unsure which license is appropriate for your use, please +** contact the sales department at qt-sales@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"); +} + +/*! + \reimp +*/ + +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 |