/****************************************************************************
**
** Implementation of TQToolBar class
**
** Created : 980315
**
** Copyright (C) 2010 Timothy Pearson and (C) 1992-2008 Trolltech ASA.
**
** This file is part of the widgets module of the TQt 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 TQt 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.TQPL
** included in the packaging of this file. Licensees holding valid TQt
** Commercial licenses may use this file in accordance with the TQt
** 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 "tqtoolbar.h"
#ifndef TQT_NO_TOOLBAR
#include "tqmainwindow.h"
#include "tqtooltip.h"
#include "tqcursor.h"
#include "tqlayout.h"
#include "tqframe.h"
#include "tqobjectlist.h"
#include "tqpainter.h"
#include "tqdrawutil.h"
#include "tqtoolbutton.h"
#include "tqpopupmenu.h"
#include "tqcombobox.h"
#include "tqtimer.h"
#include "tqwidgetlist.h"
#include "tqstyle.h"
#include "tqapplication.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 TQToolBarExtensionWidget;
class TQToolBarPrivate
{
public:
TQToolBarPrivate() : moving( FALSE ) {
}
bool moving;
TQToolBarExtensionWidget *extension;
TQPopupMenu *extensionPopup;
};
class TQToolBarSeparator : public TQWidget
{
Q_OBJECT
TQ_OBJECT
public:
TQToolBarSeparator( Qt::Orientation, TQToolBar *tqparent, const char* name=0 );
TQSize tqsizeHint() const;
Qt::Orientation orientation() const { return orient; }
public Q_SLOTS:
void setOrientation( Qt::Orientation );
protected:
void styleChange( TQStyle& );
void paintEvent( TQPaintEvent * );
private:
Qt::Orientation orient;
};
class TQToolBarExtensionWidget : public TQWidget
{
Q_OBJECT
TQ_OBJECT
public:
TQToolBarExtensionWidget( TQWidget *w );
void setOrientation( Qt::Orientation o );
TQToolButton *button() const { return tb; }
protected:
void resizeEvent( TQResizeEvent *e ) {
TQWidget::resizeEvent( e );
layOut();
}
private:
void layOut();
TQToolButton *tb;
Qt::Orientation orient;
};
TQToolBarExtensionWidget::TQToolBarExtensionWidget( TQWidget *w )
: TQWidget( w, "qt_dockwidget_internal" )
{
tb = new TQToolButton( this, "qt_toolbar_ext_button" );
tb->setAutoRaise( TRUE );
setOrientation( Qt::Horizontal );
}
void TQToolBarExtensionWidget::setOrientation( Qt::Orientation o )
{
orient = o;
if ( orient == Qt::Horizontal )
tb->setPixmap( TQPixmap( (const char **)arrow_h_xpm ) );
else
tb->setPixmap( TQPixmap( (const char **)arrow_v_xpm ) );
layOut();
}
void TQToolBarExtensionWidget::layOut()
{
tb->setGeometry( 2, 2, width() - 4, height() - 4 );
}
TQToolBarSeparator::TQToolBarSeparator(Qt::Orientation o , TQToolBar *tqparent,
const char* name )
: TQWidget( tqparent, name )
{
connect( tqparent, TQT_SIGNAL(orientationChanged(Qt::Orientation)),
this, TQT_SLOT(setOrientation(Qt::Orientation)) );
setOrientation( o );
setBackgroundMode( tqparent->backgroundMode() );
setBackgroundOrigin( ParentOrigin );
tqsetSizePolicy( TQSizePolicy( TQSizePolicy::Minimum, TQSizePolicy::Minimum ) );
}
void TQToolBarSeparator::setOrientation( Qt::Orientation o )
{
orient = o;
}
void TQToolBarSeparator::styleChange( TQStyle& )
{
setOrientation( orient );
}
TQSize TQToolBarSeparator::tqsizeHint() const
{
int extent = tqstyle().tqpixelMetric( TQStyle::PM_DockWindowSeparatorExtent,
this );
if ( orient == Qt::Horizontal )
return TQSize( extent, 0 );
else
return TQSize( 0, extent );
}
void TQToolBarSeparator::paintEvent( TQPaintEvent * )
{
TQPainter p( this );
TQStyle::SFlags flags = TQStyle::Style_Default;
if ( orientation() == Qt::Horizontal )
flags |= TQStyle::Style_Horizontal;
tqstyle().tqdrawPrimitive( TQStyle::PE_DockWindowSeparator, &p, rect(),
tqcolorGroup(), flags );
}
#include "tqtoolbar.tqmoc"
/*!
\class TQToolBar tqtoolbar.h
\brief The TQToolBar class provides a movable panel containing
widgets such as tool buttons.
\ingroup application
\mainclass
A toolbar is a panel that tqcontains 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
TQMainWindow the user can drag toolbars within and between the
\link TQDockArea dock areas\endlink. Toolbars can also be dragged
out of any dock area to float freely as top-level windows.
TQToolBar is a specialization of TQDockWindow, and so provides all
the functionality of a TQDockWindow.
To use TQToolBar you simply create a TQToolBar as a child of a
TQMainWindow, create a number of TQToolButton 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 TQToolBar
\printuntil fileSaveAction
This extract from the \l application/application.cpp example shows
the creation of a new toolbar as a child of a TQMainWindow and
adding two TQActions.
You may use most widgets within a toolbar, with TQToolButton and
TQComboBox being the most common.
If you create a new widget on an already visible TQToolBar, this
widget will automatically become visible without needing a show()
call. (This differs from every other TQt widget container. We
recommend calling show() anyway since we hope to fix this anomaly
in a future release.)
TQToolBars, like TQDockWindows, are located in \l{TQDockArea}s or
float as top-level windows. TQMainWindow provides four TQDockAreas
(top, left, right and bottom). When you create a new toolbar (as
in the example above) as a child of a TQMainWindow the toolbar will
be added to the top dock area. You can move it to another dock
area (or float it) by calling TQMainWindow::moveDockWindow(). TQDock
areas lay out their windows in \link tqdockarea.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. TQToolButtons are represented in the menu using
their textLabel property, other TQButton subclasses are represented
using their text property, and TQComboBoxes 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, TQDockArea 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 TQToolbar (dock window)
\sa TQToolButton TQMainWindow \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 TQToolBar::TQToolBar( const TQString &label,
TQMainWindow *, 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 tqparent and is
managed by \a tqparent. 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.
*/
TQToolBar::TQToolBar( const TQString &label,
TQMainWindow * tqparent, TQt::ToolBarDock dock,
bool newLine, const char * name )
: TQDockWindow( InDock, tqparent, name, 0, TRUE )
{
mw = tqparent;
init();
if ( tqparent )
tqparent->addToolBar( this, label, dock, newLine );
}
/*!
Constructs an empty horizontal toolbar.
The toolbar is called \a name and is a child of \a tqparent and is
managed by \a mainWindow. The \a label and \a newLine parameters
are passed straight to TQMainWindow::addDockWindow(). \a name and
the widget flags \a f are passed on to the TQDockWindow constructor.
Use this constructor if you want to create torn-off (undocked,
floating) toolbars or toolbars in the \link TQStatusBar status
bar\endlink.
*/
TQToolBar::TQToolBar( const TQString &label, TQMainWindow * mainWindow,
TQWidget * tqparent, bool newLine, const char * name,
WFlags f )
: TQDockWindow( InDock, tqparent, name, f, TRUE )
{
mw = mainWindow;
init();
clearWFlags( (WFlags)(TQt::WType_Dialog | WStyle_Customize | TQt::WStyle_NoBorder) );
reparent( tqparent, TQPoint( 0, 0 ), FALSE );
if ( mainWindow )
mainWindow->addToolBar( this, label, TQt::DockUnmanaged, newLine );
}
/*!
\overload
Constructs an empty toolbar called \a name, with tqparent \a tqparent,
in its \a tqparent's top dock area, without any label and without
requiring a newline.
*/
TQToolBar::TQToolBar( TQMainWindow * tqparent, const char * name )
: TQDockWindow( InDock, tqparent, name, 0, TRUE )
{
mw = tqparent;
init();
if ( tqparent )
tqparent->addToolBar( this, TQString(), TQt::DockTop );
}
/*!
\internal
Common initialization code. Requires that \c mw and \c o are set.
Does not call TQMainWindow::addDockWindow().
*/
void TQToolBar::init()
{
d = new TQToolBarPrivate;
d->extension = 0;
d->extensionPopup = 0;
sw = 0;
setBackgroundMode( TQt::PaletteButton);
setFocusPolicy( Qt::NoFocus );
setFrameStyle( TQFrame::ToolBarPanel | TQFrame::Raised);
boxLayout()->setSpacing(tqstyle().tqpixelMetric(TQStyle::PM_ToolBarItemSpacing));
}
/*!
\reimp
*/
TQToolBar::~TQToolBar()
{
delete d;
d = 0;
}
/*!
\reimp
*/
void TQToolBar::setOrientation( Qt::Orientation o )
{
TQDockWindow::setOrientation( o );
if (d->extension)
d->extension->setOrientation( o );
TQObjectList *childs = queryList( "TQToolBarSeparator" );
if ( childs ) {
TQObject *ob = 0;
for ( ob = childs->first(); ob; ob = childs->next() ) {
TQToolBarSeparator* w = (TQToolBarSeparator*)ob;
w->setOrientation( o );
}
}
delete childs;
}
/*!
Adds a separator to the right/bottom of the toolbar.
*/
void TQToolBar::addSeparator()
{
(void) new TQToolBarSeparator( orientation(), this, "toolbar separator" );
}
/*!
\reimp
*/
void TQToolBar::styleChange( TQStyle& )
{
TQObjectList *childs = queryList( "TQWidget" );
if ( childs ) {
TQObject *ob = 0;
for ( ob = childs->first(); ob; ob = childs->next() ) {
TQWidget *w = (TQWidget*)ob;
if ( ::tqqt_cast<TQToolButton*>(w) || ::tqqt_cast<TQToolBarSeparator*>(w) )
w->setStyle( &tqstyle() );
}
}
delete childs;
boxLayout()->setSpacing(tqstyle().tqpixelMetric(TQStyle::PM_ToolBarItemSpacing));
}
/*!
\reimp.
*/
void TQToolBar::show()
{
TQDockWindow::show();
if ( mw )
mw->triggerLayout( FALSE );
checkForExtension( size() );
}
/*!
\reimp
*/
void TQToolBar::hide()
{
TQDockWindow::hide();
if ( mw )
mw->triggerLayout( FALSE );
}
/*!
Returns a pointer to the TQMainWindow which manages this toolbar.
*/
TQMainWindow * TQToolBar::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 TQMainWindow
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 TQMainWindow::setRightJustification(), setVerticalStretchable(),
setHorizontalStretchable()
*/
void TQToolBar::setStretchableWidget( TQWidget * w )
{
sw = w;
boxLayout()->setStretchFactor( w, 1 );
if ( !isHorizontalStretchable() && !isVerticalStretchable() ) {
if ( orientation() == Qt::Horizontal )
setHorizontalStretchable( TRUE );
else
setVerticalStretchable( TRUE );
}
}
/*!
\reimp
*/
bool TQToolBar::event( TQEvent * e )
{
bool r = TQDockWindow::event( e );
// After the event filters have dealt with it, do our stuff.
if ( e->type() == TQEvent::ChildInserted ) {
TQObject * child = TQT_TQOBJECT(((TQChildEvent*)e)->child());
if ( child && child->isWidgetType() && !(TQT_TQWIDGET(child)->isTopLevel())
&& TQT_BASE_OBJECT(child->tqparent()) == TQT_BASE_OBJECT(this)
&& tqstrcmp("qt_dockwidget_internal", child->name()) != 0 ) {
boxLayout()->addWidget( (TQWidget*)child );
if ( isVisible() ) {
if ( TQT_TQWIDGET(child)->testWState( TQt::WState_CreatedHidden ) )
TQT_TQWIDGET(child)->show();
checkForExtension( size() );
}
}
if ( child && child->isWidgetType() && TQT_BASE_OBJECT(child) == TQT_BASE_OBJECT(sw) )
boxLayout()->setStretchFactor( TQT_TQWIDGET(child), 1 );
} else if ( e->type() == TQEvent::Show ) {
tqlayout()->activate();
} else if ( e->type() == TQEvent::LayoutHint && place() == OutsideDock ) {
adjustSize();
}
return r;
}
/*!
\property TQToolBar::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 TQToolBar::setLabel( const TQString & label )
{
l = label;
setCaption( l );
}
TQString TQToolBar::label() const
{
return l;
}
/*!
Deletes all the toolbar's child widgets.
*/
void TQToolBar::clear()
{
if ( childrenListObject().isEmpty() )
return;
TQObjectListIt it( childrenListObject() );
TQObject * obj;
while( (obj=it.current()) != 0 ) {
++it;
if ( obj->isWidgetType() &&
qstrcmp( "qt_dockwidget_internal", obj->name() ) != 0 )
delete obj;
}
}
/*!
\reimp
*/
TQSize TQToolBar::tqminimumSize() const
{
if ( orientation() == Qt::Horizontal )
return TQSize( 0, TQDockWindow::tqminimumSize().height() );
return TQSize( TQDockWindow::tqminimumSize().width(), 0 );
}
/*!
\reimp
*/
TQSize TQToolBar::tqminimumSizeHint() const
{
if ( orientation() == Qt::Horizontal )
return TQSize( 0, TQDockWindow::tqminimumSizeHint().height() );
return TQSize( TQDockWindow::tqminimumSizeHint().width(), 0 );
}
void TQToolBar::createPopup()
{
if (!d->extensionPopup) {
d->extensionPopup = new TQPopupMenu( this, "qt_dockwidget_internal" );
connect( d->extensionPopup, TQT_SIGNAL( aboutToShow() ), this, TQT_SLOT( createPopup() ) );
}
if (!d->extension) {
d->extension = new TQToolBarExtensionWidget( 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
TQObjectList *childlist = d->extensionPopup->queryList( "TQPopupMenu", 0, FALSE, TRUE );
childlist->setAutoDelete(TRUE);
delete childlist;
childlist = queryList( "TQWidget", 0, FALSE, TRUE );
TQObjectListIt it( *childlist );
bool hide = FALSE;
bool doHide = FALSE;
int id;
while ( it.current() ) {
int j = 2;
if ( !it.current()->isWidgetType() || TQT_BASE_OBJECT(it.current()) == TQT_BASE_OBJECT(d->extension->button()) ||
qstrcmp( "qt_dockwidget_internal", it.current()->name() ) == 0 ) {
++it;
continue;
}
TQWidget *w = (TQWidget*)it.current();
#ifndef TQT_NO_COMBOBOX
if ( ::tqqt_cast<TQComboBox*>(w) )
j = 1;
#endif
hide = FALSE;
TQPoint p = w->parentWidget()->mapTo( this, w->tqgeometry().bottomRight() );
if ( orientation() == Qt::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 ( ::tqqt_cast<TQToolButton*>(w) ) {
TQToolButton *b = (TQToolButton*)w;
TQString 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, TQT_TQOBJECT(b), TQT_SLOT( emulateClick() ) ) ;
if ( b->isToggleButton() )
d->extensionPopup->setItemChecked( id, b->isOn() );
if ( !b->isEnabled() )
d->extensionPopup->setItemEnabled( id, FALSE );
} else if ( ::tqqt_cast<TQButton*>(w) ) {
TQButton *b = (TQButton*)w;
TQString s = b->text();
if ( s.isEmpty() )
s = "";
if ( b->pixmap() )
id = d->extensionPopup->insertItem( *b->pixmap(), s, TQT_TQOBJECT(b), TQT_SLOT( emulateClick() ) );
else
id = d->extensionPopup->insertItem( s, TQT_TQOBJECT(b), TQT_SLOT( emulateClick() ) );
if ( b->isToggleButton() )
d->extensionPopup->setItemChecked( id, b->isOn() );
if ( !b->isEnabled() )
d->extensionPopup->setItemEnabled( id, FALSE );
#ifndef TQT_NO_COMBOBOX
} else if ( ::tqqt_cast<TQComboBox*>(w) ) {
TQComboBox *c = (TQComboBox*)w;
if ( c->count() != 0 ) {
#ifndef TQT_NO_WIDGET_TOPEXTRA
TQString s = c->caption();
#else
TQString s;
#endif
if ( s.isEmpty() )
s = c->currentText();
uint maxItems = 0;
TQPopupMenu *cp = new TQPopupMenu(d->extensionPopup);
cp->setEnabled(c->isEnabled());
d->extensionPopup->insertItem( s, cp );
connect( cp, TQT_SIGNAL( activated(int) ), c, TQT_SLOT( internalActivate(int) ) );
for ( int i = 0; i < c->count(); ++i ) {
TQString 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->tqsizeHint().height();
maxItems = TQApplication::desktop()->height() * 10 / h;
}
} else if ( cp->count() >= maxItems - 1 ) {
TQPopupMenu* sp = new TQPopupMenu(d->extensionPopup);
cp->insertItem( tr( "More..." ), sp );
cp = sp;
connect( cp, TQT_SIGNAL( activated(int) ), c, TQT_SLOT( internalActivate(int) ) );
}
}
}
#endif //TQT_NO_COMBOBOX
}
}
++it;
}
delete childlist;
}
/*!
\reimp
*/
void TQToolBar::resizeEvent( TQResizeEvent *e )
{
checkForExtension( e->size() );
}
void TQToolBar::checkForExtension( const TQSize &sz )
{
if (!isVisible())
return;
bool tooSmall;
if ( orientation() == Qt::Horizontal )
tooSmall = sz.width() < tqsizeHint().width();
else
tooSmall = sz.height() < tqsizeHint().height();
if ( tooSmall ) {
createPopup();
if ( d->extensionPopup->count() ) {
if ( orientation() == Qt::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 TQToolBar::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