You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
816 lines
23 KiB
816 lines
23 KiB
/****************************************************************************
|
|
**
|
|
** Implementation of QToolBar class
|
|
**
|
|
** Created : 980315
|
|
**
|
|
** Copyright (C) 1992-2008 Trolltech ASA. All rights reserved.
|
|
**
|
|
** This file is part of the widgets module of the Qt GUI Toolkit.
|
|
**
|
|
** This file may be used under the terms of the GNU General
|
|
** Public License versions 2.0 or 3.0 as published by the Free
|
|
** Software Foundation and appearing in the files LICENSE.GPL2
|
|
** and LICENSE.GPL3 included in the packaging of this file.
|
|
** Alternatively you may (at your option) use any later version
|
|
** of the GNU General Public License if such license has been
|
|
** publicly approved by Trolltech ASA (or its successors, if any)
|
|
** and the KDE Free Qt Foundation.
|
|
**
|
|
** Please review the following information to ensure GNU General
|
|
** Public Licensing requirements will be met:
|
|
** http://trolltech.com/products/qt/licenses/licensing/opensource/.
|
|
** If you are unsure which license is appropriate for your use, please
|
|
** review the following information:
|
|
** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
|
|
** or contact the sales department at sales@trolltech.com.
|
|
**
|
|
** This file may be used under the terms of the Q Public License as
|
|
** defined by Trolltech ASA and appearing in the file LICENSE.QPL
|
|
** included in the packaging of this file. Licensees holding valid Qt
|
|
** Commercial licenses may use this file in accordance with the Qt
|
|
** Commercial License Agreement provided with the Software.
|
|
**
|
|
** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
|
|
** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
|
|
** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
|
|
** herein.
|
|
**
|
|
**********************************************************************/
|
|
|
|
#include "qtoolbar.h"
|
|
#ifndef QT_NO_TOOLBAR
|
|
|
|
#include "qmainwindow.h"
|
|
#include "qtooltip.h"
|
|
#include "qcursor.h"
|
|
#include "qlayout.h"
|
|
#include "qframe.h"
|
|
#include "qobjectlist.h"
|
|
#include "qpainter.h"
|
|
#include "qdrawutil.h"
|
|
#include "qtoolbutton.h"
|
|
#include "qpopupmenu.h"
|
|
#include "qcombobox.h"
|
|
#include "qtimer.h"
|
|
#include "qwidgetlist.h"
|
|
#include "qstyle.h"
|
|
|
|
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 QToolBarExtensionWidget;
|
|
|
|
class QToolBarPrivate
|
|
{
|
|
public:
|
|
QToolBarPrivate() : moving( FALSE ) {
|
|
}
|
|
|
|
bool moving;
|
|
QToolBarExtensionWidget *extension;
|
|
QPopupMenu *extensionPopup;
|
|
};
|
|
|
|
|
|
class QToolBarSeparator : public QWidget
|
|
{
|
|
Q_OBJECT
|
|
public:
|
|
QToolBarSeparator( Orientation, QToolBar *parent, const char* name=0 );
|
|
|
|
QSize sizeHint() const;
|
|
Orientation orientation() const { return orient; }
|
|
public slots:
|
|
void setOrientation( Orientation );
|
|
protected:
|
|
void styleChange( QStyle& );
|
|
void paintEvent( QPaintEvent * );
|
|
|
|
private:
|
|
Orientation orient;
|
|
};
|
|
|
|
class QToolBarExtensionWidget : public QWidget
|
|
{
|
|
Q_OBJECT
|
|
|
|
public:
|
|
QToolBarExtensionWidget( QWidget *w );
|
|
void setOrientation( Orientation o );
|
|
QToolButton *button() const { return tb; }
|
|
|
|
protected:
|
|
void resizeEvent( QResizeEvent *e ) {
|
|
QWidget::resizeEvent( e );
|
|
layOut();
|
|
}
|
|
|
|
private:
|
|
void layOut();
|
|
QToolButton *tb;
|
|
Orientation orient;
|
|
|
|
};
|
|
|
|
QToolBarExtensionWidget::QToolBarExtensionWidget( QWidget *w )
|
|
: QWidget( w, "qt_dockwidget_internal" )
|
|
{
|
|
tb = new QToolButton( this, "qt_toolbar_ext_button" );
|
|
tb->setAutoRaise( TRUE );
|
|
setOrientation( Horizontal );
|
|
}
|
|
|
|
void QToolBarExtensionWidget::setOrientation( Orientation o )
|
|
{
|
|
orient = o;
|
|
if ( orient == Horizontal )
|
|
tb->setPixmap( QPixmap( (const char **)arrow_h_xpm ) );
|
|
else
|
|
tb->setPixmap( QPixmap( (const char **)arrow_v_xpm ) );
|
|
layOut();
|
|
}
|
|
|
|
void QToolBarExtensionWidget::layOut()
|
|
{
|
|
tb->setGeometry( 2, 2, width() - 4, height() - 4 );
|
|
}
|
|
|
|
QToolBarSeparator::QToolBarSeparator(Orientation o , QToolBar *parent,
|
|
const char* name )
|
|
: QWidget( parent, name )
|
|
{
|
|
connect( parent, SIGNAL(orientationChanged(Orientation)),
|
|
this, SLOT(setOrientation(Orientation)) );
|
|
setOrientation( o );
|
|
setBackgroundMode( parent->backgroundMode() );
|
|
setBackgroundOrigin( ParentOrigin );
|
|
setSizePolicy( QSizePolicy( QSizePolicy::Minimum, QSizePolicy::Minimum ) );
|
|
}
|
|
|
|
|
|
|
|
void QToolBarSeparator::setOrientation( Orientation o )
|
|
{
|
|
orient = o;
|
|
}
|
|
|
|
void QToolBarSeparator::styleChange( QStyle& )
|
|
{
|
|
setOrientation( orient );
|
|
}
|
|
|
|
QSize QToolBarSeparator::sizeHint() const
|
|
{
|
|
int extent = style().pixelMetric( QStyle::PM_DockWindowSeparatorExtent,
|
|
this );
|
|
if ( orient == Horizontal )
|
|
return QSize( extent, 0 );
|
|
else
|
|
return QSize( 0, extent );
|
|
}
|
|
|
|
void QToolBarSeparator::paintEvent( QPaintEvent * )
|
|
{
|
|
QPainter p( this );
|
|
QStyle::SFlags flags = QStyle::Style_Default;
|
|
|
|
if ( orientation() == Horizontal )
|
|
flags |= QStyle::Style_Horizontal;
|
|
|
|
style().drawPrimitive( QStyle::PE_DockWindowSeparator, &p, rect(),
|
|
colorGroup(), flags );
|
|
}
|
|
|
|
#include "qtoolbar.moc"
|
|
|
|
|
|
/*!
|
|
\class QToolBar qtoolbar.h
|
|
\brief The QToolBar class provides a movable panel containing
|
|
widgets such as tool buttons.
|
|
|
|
\ingroup application
|
|
\mainclass
|
|
|
|
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
|
|
QMainWindow the user can drag toolbars within and between the
|
|
\link QDockArea dock areas\endlink. Toolbars can also be dragged
|
|
out of any dock area to float freely as top-level windows.
|
|
|
|
QToolBar is a specialization of QDockWindow, and so provides all
|
|
the functionality of a QDockWindow.
|
|
|
|
To use QToolBar you simply create a QToolBar as a child of a
|
|
QMainWindow, 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().
|
|
|
|
\quotefile action/application.cpp
|
|
\skipto new QToolBar
|
|
\printuntil fileSaveAction
|
|
|
|
This extract from the \l application/application.cpp example shows
|
|
the creation of a new toolbar as a child of a QMainWindow and
|
|
adding two QActions.
|
|
|
|
You may use most widgets within a toolbar, with QToolButton and
|
|
QComboBox being the most common.
|
|
|
|
If you create a new widget on an already visible QToolBar, 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.)
|
|
|
|
QToolBars, like QDockWindows, are located in \l{QDockArea}s or
|
|
float as top-level windows. QMainWindow provides four QDockAreas
|
|
(top, left, right and bottom). When you create a new toolbar (as
|
|
in the example above) as a child of a QMainWindow the toolbar will
|
|
be added to the top dock area. You can move it to another dock
|
|
area (or float it) by calling QMainWindow::moveDockWindow(). QDock
|
|
areas lay out their windows in \link qdockarea.html#lines
|
|
Lines\endlink.
|
|
|
|
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 QButton 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, QDockArea 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 QMainWindow \link http://www.iarchitect.com/visual.htm Parts of Isys on Visual Design\endlink \link guibooks.html#fowler GUI Design Handbook: Tool Bar\endlink.
|
|
*/
|
|
|
|
/*!
|
|
\fn QToolBar::QToolBar( const QString &label,
|
|
QMainWindow *, ToolBarDock = Top,
|
|
bool newLine = FALSE, const char * name = 0 );
|
|
\obsolete
|
|
*/
|
|
|
|
/*!
|
|
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.
|
|
*/
|
|
|
|
QToolBar::QToolBar( const QString &label,
|
|
QMainWindow * parent, QMainWindow::ToolBarDock dock,
|
|
bool newLine, const char * name )
|
|
: QDockWindow( 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 QMainWindow::addDockWindow(). \a name and
|
|
the widget flags \a f are passed on to the QDockWindow constructor.
|
|
|
|
Use this constructor if you want to create torn-off (undocked,
|
|
floating) toolbars or toolbars in the \link QStatusBar status
|
|
bar\endlink.
|
|
*/
|
|
|
|
QToolBar::QToolBar( const QString &label, QMainWindow * mainWindow,
|
|
QWidget * parent, bool newLine, const char * name,
|
|
WFlags f )
|
|
: QDockWindow( InDock, parent, name, f, TRUE )
|
|
{
|
|
mw = mainWindow;
|
|
init();
|
|
|
|
clearWFlags( WType_Dialog | WStyle_Customize | WStyle_NoBorder );
|
|
reparent( parent, QPoint( 0, 0 ), FALSE );
|
|
|
|
if ( mainWindow )
|
|
mainWindow->addToolBar( this, label, QMainWindow::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.
|
|
*/
|
|
|
|
QToolBar::QToolBar( QMainWindow * parent, const char * name )
|
|
: QDockWindow( InDock, parent, name, 0, TRUE )
|
|
{
|
|
mw = parent;
|
|
init();
|
|
|
|
if ( parent )
|
|
parent->addToolBar( this, QString::null, QMainWindow::DockTop );
|
|
}
|
|
|
|
/*!
|
|
\internal
|
|
|
|
Common initialization code. Requires that \c mw and \c o are set.
|
|
Does not call QMainWindow::addDockWindow().
|
|
*/
|
|
void QToolBar::init()
|
|
{
|
|
d = new QToolBarPrivate;
|
|
d->extension = 0;
|
|
d->extensionPopup = 0;
|
|
sw = 0;
|
|
|
|
setBackgroundMode( PaletteButton);
|
|
setFocusPolicy( NoFocus );
|
|
setFrameStyle( QFrame::ToolBarPanel | QFrame::Raised);
|
|
boxLayout()->setSpacing(style().pixelMetric(QStyle::PM_ToolBarItemSpacing));
|
|
}
|
|
|
|
/*!
|
|
\reimp
|
|
*/
|
|
|
|
QToolBar::~QToolBar()
|
|
{
|
|
delete d;
|
|
d = 0;
|
|
}
|
|
|
|
/*!
|
|
\reimp
|
|
*/
|
|
|
|
void QToolBar::setOrientation( Orientation o )
|
|
{
|
|
QDockWindow::setOrientation( o );
|
|
if (d->extension)
|
|
d->extension->setOrientation( o );
|
|
QObjectList *childs = queryList( "QToolBarSeparator" );
|
|
if ( childs ) {
|
|
QObject *ob = 0;
|
|
for ( ob = childs->first(); ob; ob = childs->next() ) {
|
|
QToolBarSeparator* w = (QToolBarSeparator*)ob;
|
|
w->setOrientation( o );
|
|
}
|
|
}
|
|
delete childs;
|
|
}
|
|
|
|
/*!
|
|
Adds a separator to the right/bottom of the toolbar.
|
|
*/
|
|
|
|
void QToolBar::addSeparator()
|
|
{
|
|
(void) new QToolBarSeparator( orientation(), this, "toolbar separator" );
|
|
}
|
|
|
|
/*!
|
|
\reimp
|
|
*/
|
|
|
|
void QToolBar::styleChange( QStyle& )
|
|
{
|
|
QObjectList *childs = queryList( "QWidget" );
|
|
if ( childs ) {
|
|
QObject *ob = 0;
|
|
for ( ob = childs->first(); ob; ob = childs->next() ) {
|
|
QWidget *w = (QWidget*)ob;
|
|
if ( ::qt_cast<QToolButton*>(w) || ::qt_cast<QToolBarSeparator*>(w) )
|
|
w->setStyle( &style() );
|
|
}
|
|
}
|
|
delete childs;
|
|
boxLayout()->setSpacing(style().pixelMetric(QStyle::PM_ToolBarItemSpacing));
|
|
}
|
|
|
|
/*!
|
|
\reimp.
|
|
*/
|
|
|
|
void QToolBar::show()
|
|
{
|
|
QDockWindow::show();
|
|
if ( mw )
|
|
mw->triggerLayout( FALSE );
|
|
checkForExtension( size() );
|
|
}
|
|
|
|
|
|
/*!
|
|
\reimp
|
|
*/
|
|
|
|
void QToolBar::hide()
|
|
{
|
|
QDockWindow::hide();
|
|
if ( mw )
|
|
mw->triggerLayout( FALSE );
|
|
}
|
|
|
|
/*!
|
|
Returns a pointer to the QMainWindow which manages this toolbar.
|
|
*/
|
|
|
|
QMainWindow * QToolBar::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 QMainWindow
|
|
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 QMainWindow::setRightJustification(), setVerticalStretchable(),
|
|
setHorizontalStretchable()
|
|
*/
|
|
|
|
void QToolBar::setStretchableWidget( QWidget * w )
|
|
{
|
|
sw = w;
|
|
boxLayout()->setStretchFactor( w, 1 );
|
|
|
|
if ( !isHorizontalStretchable() && !isVerticalStretchable() ) {
|
|
if ( orientation() == Horizontal )
|
|
setHorizontalStretchable( TRUE );
|
|
else
|
|
setVerticalStretchable( TRUE );
|
|
}
|
|
}
|
|
|
|
|
|
/*!
|
|
\reimp
|
|
*/
|
|
|
|
bool QToolBar::event( QEvent * e )
|
|
{
|
|
bool r = QDockWindow::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)->isTopLevel()
|
|
&& child->parent() == this
|
|
&& qstrcmp("qt_dockwidget_internal", child->name()) != 0 ) {
|
|
boxLayout()->addWidget( (QWidget*)child );
|
|
if ( isVisible() ) {
|
|
if ( ((QWidget*)child)->testWState( WState_CreatedHidden ) )
|
|
((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 QToolBar::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 QToolBar::setLabel( const QString & label )
|
|
{
|
|
l = label;
|
|
setCaption( l );
|
|
}
|
|
|
|
QString QToolBar::label() const
|
|
{
|
|
return l;
|
|
}
|
|
|
|
|
|
/*!
|
|
Deletes all the toolbar's child widgets.
|
|
*/
|
|
|
|
void QToolBar::clear()
|
|
{
|
|
if ( !children() )
|
|
return;
|
|
QObjectListIt it( *children() );
|
|
QObject * obj;
|
|
while( (obj=it.current()) != 0 ) {
|
|
++it;
|
|
if ( obj->isWidgetType() &&
|
|
qstrcmp( "qt_dockwidget_internal", obj->name() ) != 0 )
|
|
delete obj;
|
|
}
|
|
}
|
|
|
|
/*!
|
|
\reimp
|
|
*/
|
|
|
|
QSize QToolBar::minimumSize() const
|
|
{
|
|
if ( orientation() == Horizontal )
|
|
return QSize( 0, QDockWindow::minimumSize().height() );
|
|
return QSize( QDockWindow::minimumSize().width(), 0 );
|
|
}
|
|
|
|
/*!
|
|
\reimp
|
|
*/
|
|
|
|
QSize QToolBar::minimumSizeHint() const
|
|
{
|
|
if ( orientation() == Horizontal )
|
|
return QSize( 0, QDockWindow::minimumSizeHint().height() );
|
|
return QSize( QDockWindow::minimumSizeHint().width(), 0 );
|
|
}
|
|
|
|
void QToolBar::createPopup()
|
|
{
|
|
if (!d->extensionPopup) {
|
|
d->extensionPopup = new QPopupMenu( this, "qt_dockwidget_internal" );
|
|
connect( d->extensionPopup, SIGNAL( aboutToShow() ), this, SLOT( createPopup() ) );
|
|
}
|
|
|
|
if (!d->extension) {
|
|
d->extension = new QToolBarExtensionWidget( this );
|
|
d->extension->setOrientation(orientation());
|
|
d->extension->button()->setPopup( d->extensionPopup );
|
|
d->extension->button()->setPopupDelay( -1 );
|
|
}
|
|
|
|
d->extensionPopup->clear();
|
|
// clear doesn't delete submenus, so do this explicitly
|
|
QObjectList *childlist = d->extensionPopup->queryList( "QPopupMenu", 0, FALSE, TRUE );
|
|
childlist->setAutoDelete(TRUE);
|
|
delete childlist;
|
|
|
|
childlist = queryList( "QWidget", 0, FALSE, TRUE );
|
|
QObjectListIt it( *childlist );
|
|
bool hide = FALSE;
|
|
bool doHide = FALSE;
|
|
int id;
|
|
while ( it.current() ) {
|
|
int j = 2;
|
|
if ( !it.current()->isWidgetType() || it.current() == d->extension->button() ||
|
|
qstrcmp( "qt_dockwidget_internal", it.current()->name() ) == 0 ) {
|
|
++it;
|
|
continue;
|
|
}
|
|
QWidget *w = (QWidget*)it.current();
|
|
#ifndef QT_NO_COMBOBOX
|
|
if ( ::qt_cast<QComboBox*>(w) )
|
|
j = 1;
|
|
#endif
|
|
hide = FALSE;
|
|
QPoint p = w->parentWidget()->mapTo( this, w->geometry().bottomRight() );
|
|
if ( orientation() == Horizontal ) {
|
|
if ( p.x() > ( doHide ? width() - d->extension->width() / j : width() ) )
|
|
hide = TRUE;
|
|
} else {
|
|
if ( p.y() > ( doHide ? height()- d->extension->height() / j : height() ) )
|
|
hide = TRUE;
|
|
}
|
|
if ( hide && w->isVisible() ) {
|
|
doHide = TRUE;
|
|
if ( ::qt_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( emulateClick() ) ) ;
|
|
if ( b->isToggleButton() )
|
|
d->extensionPopup->setItemChecked( id, b->isOn() );
|
|
if ( !b->isEnabled() )
|
|
d->extensionPopup->setItemEnabled( id, FALSE );
|
|
} else if ( ::qt_cast<QButton*>(w) ) {
|
|
QButton *b = (QButton*)w;
|
|
QString s = b->text();
|
|
if ( s.isEmpty() )
|
|
s = "";
|
|
if ( b->pixmap() )
|
|
id = d->extensionPopup->insertItem( *b->pixmap(), s, b, SLOT( emulateClick() ) );
|
|
else
|
|
id = d->extensionPopup->insertItem( s, b, SLOT( emulateClick() ) );
|
|
if ( b->isToggleButton() )
|
|
d->extensionPopup->setItemChecked( id, b->isOn() );
|
|
if ( !b->isEnabled() )
|
|
d->extensionPopup->setItemEnabled( id, FALSE );
|
|
#ifndef QT_NO_COMBOBOX
|
|
} else if ( ::qt_cast<QComboBox*>(w) ) {
|
|
QComboBox *c = (QComboBox*)w;
|
|
if ( c->count() != 0 ) {
|
|
#ifndef QT_NO_WIDGET_TOPEXTRA
|
|
QString s = c->caption();
|
|
#else
|
|
QString s;
|
|
#endif
|
|
if ( s.isEmpty() )
|
|
s = c->currentText();
|
|
uint maxItems = 0;
|
|
QPopupMenu *cp = new QPopupMenu(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->count() == 10 ) {
|
|
int h = cp->sizeHint().height();
|
|
maxItems = QApplication::desktop()->height() * 10 / h;
|
|
}
|
|
} else if ( cp->count() >= maxItems - 1 ) {
|
|
QPopupMenu* sp = new QPopupMenu(d->extensionPopup);
|
|
cp->insertItem( tr( "More..." ), sp );
|
|
cp = sp;
|
|
connect( cp, SIGNAL( activated(int) ), c, SLOT( internalActivate(int) ) );
|
|
}
|
|
}
|
|
}
|
|
#endif //QT_NO_COMBOBOX
|
|
}
|
|
}
|
|
++it;
|
|
}
|
|
delete childlist;
|
|
}
|
|
|
|
|
|
/*!
|
|
\reimp
|
|
*/
|
|
|
|
void QToolBar::resizeEvent( QResizeEvent *e )
|
|
{
|
|
checkForExtension( e->size() );
|
|
}
|
|
|
|
void QToolBar::checkForExtension( const QSize &sz )
|
|
{
|
|
if (!isVisible())
|
|
return;
|
|
|
|
bool tooSmall;
|
|
if ( orientation() == Horizontal )
|
|
tooSmall = sz.width() < sizeHint().width();
|
|
else
|
|
tooSmall = sz.height() < sizeHint().height();
|
|
|
|
if ( tooSmall ) {
|
|
createPopup();
|
|
if ( d->extensionPopup->count() ) {
|
|
if ( orientation() == Horizontal )
|
|
d->extension->setGeometry( width() - 20, 1, 20, height() - 2 );
|
|
else
|
|
d->extension->setGeometry( 1, 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;
|
|
}
|
|
}
|
|
|
|
|
|
/*!
|
|
\reimp
|
|
*/
|
|
|
|
void QToolBar::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.
|
|
*/
|
|
#endif
|