summaryrefslogtreecommitdiffstats
path: root/tqtinterface/qt4/src/widgets/tqaction.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'tqtinterface/qt4/src/widgets/tqaction.cpp')
-rw-r--r--tqtinterface/qt4/src/widgets/tqaction.cpp2145
1 files changed, 2145 insertions, 0 deletions
diff --git a/tqtinterface/qt4/src/widgets/tqaction.cpp b/tqtinterface/qt4/src/widgets/tqaction.cpp
new file mode 100644
index 0000000..8ffa773
--- /dev/null
+++ b/tqtinterface/qt4/src/widgets/tqaction.cpp
@@ -0,0 +1,2145 @@
+/****************************************************************************
+**
+** Implementation of TQAction class
+**
+** Copyright (C) 2000-2008 Trolltech ASA. All rights reserved.
+**
+** 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 "tqaction.h"
+
+#ifndef TQT_NO_ACTION
+
+#include "tqtoolbar.h"
+#include "tqptrlist.h"
+#include "tqpopupmenu.h"
+#include "tqaccel.h"
+#include "tqtoolbutton.h"
+#include "tqcombobox.h"
+#include "tqtooltip.h"
+#include "tqwhatsthis.h"
+#include "tqstatusbar.h"
+#include "tqobjectlist.h"
+
+
+/*!
+ \class TQAction tqaction.h
+ \brief The TQAction class provides an abstract user interface
+ action that can appear both in menus and tool bars.
+
+ \ingroup basic
+ \ingroup application
+ \mainclass
+
+ 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 TQAction may contain an icon, a menu text, an accelerator, a
+ status text, a whats 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().
+
+ Once a TQAction has been created it should be added to the relevant
+ menu and toolbar and then connected to the slot which will perform
+ the action. For example:
+
+ \quotefile action/application.cpp
+ \skipto TQPixmap( fileopen
+ \printuntil connect
+
+ We create a "File Save" action with a menu text of "&Save" and
+ \e{Ctrl+S} as the keyboard accelerator. We connect the
+ fileSaveAction's activated() signal to our own save() slot. Note
+ that at this point there is no menu or toolbar action, we'll add
+ them next:
+
+ \skipto new TQToolBar
+ \printline
+ \skipto fileSaveAction->addTo
+ \printline
+ \skipto new TQPopupMenu
+ \printuntil insertItem
+ \skipto fileSaveAction->addTo
+ \printline
+
+ We create a toolbar and add our fileSaveAction to it. Similarly we
+ create a menu, add a top-level menu item, and add our
+ fileSaveAction.
+
+ We recommend that actions are created as tqchildren of the window
+ that they are used in. In most cases actions will be tqchildren 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 TQActionPrivate
+{
+public:
+ TQActionPrivate(TQAction *act);
+ ~TQActionPrivate();
+ TQIconSet *iconset;
+ TQString text;
+ TQString menutext;
+ TQString tooltip;
+ TQString statustip;
+ TQString whatsthis;
+#ifndef TQT_NO_ACCEL
+ TQKeySequence key;
+ TQAccel* accel;
+ int accelid;
+#endif
+ uint enabled : 1;
+ uint visible : 1;
+ uint toggleaction : 1;
+ uint on : 1;
+ uint forceDisabled : 1;
+ uint forceInvisible : 1;
+#ifndef TQT_NO_TOOLTIP
+ TQToolTipGroup tipGroup;
+#endif
+ TQActionGroupPrivate* d_group;
+ TQAction *action;
+
+ struct MenuItem {
+ MenuItem():popup(0),id(0){}
+ TQPopupMenu* 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) {}
+ TQComboBox *combo;
+ int id;
+ };
+ TQPtrList<MenuItem> menuitems;
+ TQPtrList<TQToolButton> toolbuttons;
+ TQPtrList<ComboItem> comboitems;
+
+ enum Update { Icons = 1, Visibility = 2, State = 4, EverythingElse = 8 };
+ void update( uint upd = EverythingElse );
+
+ TQString menuText() const;
+ TQString toolTip() const;
+ TQString statusTip() const;
+};
+
+TQActionPrivate::TQActionPrivate(TQAction *act)
+ : iconset( 0 ),
+#ifndef TQT_NO_ACCEL
+ key( 0 ), accel( 0 ), accelid( 0 ),
+#endif
+ enabled( TRUE ), visible( TRUE ), toggleaction( FALSE ), on( FALSE ),
+ forceDisabled( FALSE ), forceInvisible( FALSE ),
+#ifndef TQT_NO_TOOLTIP
+ tipGroup( 0 ),
+#endif
+ d_group( 0 ), action(act)
+{
+ menuitems.setAutoDelete( TRUE );
+ comboitems.setAutoDelete( TRUE );
+#ifndef TQT_NO_TOOLTIP
+ tipGroup.setDelay( FALSE );
+#endif
+}
+
+TQActionPrivate::~TQActionPrivate()
+{
+ TQPtrListIterator<TQToolButton> ittb( toolbuttons );
+ TQToolButton *tb;
+
+ while ( ( tb = ittb.current() ) ) {
+ ++ittb;
+ delete tb;
+ }
+
+ TQPtrListIterator<TQActionPrivate::MenuItem> itmi( menuitems);
+ TQActionPrivate::MenuItem* mi;
+ while ( ( mi = itmi.current() ) ) {
+ ++itmi;
+ TQPopupMenu* menu = mi->popup;
+ if ( menu->tqfindItem( mi->id ) )
+ menu->removeItem( mi->id );
+ }
+
+ TQPtrListIterator<TQActionPrivate::ComboItem> itci(comboitems);
+ TQActionPrivate::ComboItem* ci;
+ while ( ( ci = itci.current() ) ) {
+ ++itci;
+ TQComboBox* combo = ci->combo;
+ combo->clear();
+ TQActionGroup *group = ::tqqt_cast<TQActionGroup*>(action->tqparent());
+ TQObjectList *siblings = group ? group->queryList("TQAction") : 0;
+ if (siblings) {
+ TQObjectListIt it(*siblings);
+ while (it.current()) {
+ TQAction *sib = ::tqqt_cast<TQAction*>(it.current());
+ ++it;
+ sib->removeFrom(combo);
+ }
+ it = TQObjectListIt(*siblings);
+ while (it.current()) {
+ TQAction *sib = ::tqqt_cast<TQAction*>(it.current());
+ ++it;
+ if (sib == action)
+ continue;
+ sib->addTo(combo);
+ }
+ }
+ delete siblings;
+ }
+
+#ifndef TQT_NO_ACCEL
+ delete accel;
+#endif
+ delete iconset;
+}
+
+class TQActionGroupPrivate
+{
+public:
+ uint exclusive: 1;
+ uint dropdown: 1;
+ TQPtrList<TQAction> actions;
+ TQAction* selected;
+ TQAction* separatorAction;
+
+ struct MenuItem {
+ MenuItem():popup(0),id(0){}
+ TQPopupMenu* popup;
+ int id;
+ };
+
+ TQPtrList<TQComboBox> comboboxes;
+ TQPtrList<TQToolButton> menubuttons;
+ TQPtrList<MenuItem> menuitems;
+ TQPtrList<TQPopupMenu> popupmenus;
+
+ void update( const TQActionGroup * );
+};
+
+void TQActionPrivate::update( uint upd )
+{
+ for ( TQPtrListIterator<MenuItem> it( menuitems); it.current(); ++it ) {
+ MenuItem* mi = it.current();
+ TQString t = menuText();
+#ifndef TQT_NO_ACCEL
+ if ( key )
+ t += '\t' + TQAccel::keyToString( 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 ( iconset )
+ mi->popup->changeItem( mi->id, *iconset, t );
+ else
+ mi->popup->changeItem( mi->id, TQIconSet(), t );
+ }
+ if ( upd & EverythingElse ) {
+ mi->popup->changeItem( mi->id, t );
+ if ( !whatsthis.isEmpty() )
+ mi->popup->TQMenuData::setWhatsThis( mi->id, whatsthis );
+ if ( toggleaction ) {
+ mi->popup->setCheckable( TRUE );
+ mi->popup->setItemChecked( mi->id, on );
+ }
+ }
+ }
+ for ( TQPtrListIterator<TQToolButton> it2(toolbuttons); it2.current(); ++it2 ) {
+ TQToolButton* btn = it2.current();
+ if ( upd & State ) {
+ btn->setEnabled( enabled );
+ if ( toggleaction )
+ btn->setOn( on );
+ }
+ if ( upd & Visibility )
+ visible ? btn->show() : btn->hide();
+ if ( upd & Icons ) {
+ if ( iconset )
+ btn->setIconSet( *iconset );
+ else
+ btn->setIconSet( TQIconSet() );
+ }
+ if ( upd & EverythingElse ) {
+ btn->setToggleButton( toggleaction );
+ if ( !text.isEmpty() )
+ btn->setTextLabel( text, FALSE );
+#ifndef TQT_NO_TOOLTIP
+ TQToolTip::remove( btn );
+ TQToolTip::add( btn, toolTip(), &tipGroup, statusTip() );
+#endif
+#ifndef TQT_NO_WHATSTHIS
+ TQWhatsThis::remove( btn );
+ if ( !whatsthis.isEmpty() )
+ TQWhatsThis::add( btn, whatsthis );
+#endif
+ }
+ }
+#ifndef TQT_NO_ACCEL
+ if ( accel ) {
+ accel->setEnabled( enabled && visible );
+ if ( !whatsthis.isEmpty() )
+ accel->setWhatsThis( accelid, whatsthis );
+ }
+#endif
+ // Only used by actiongroup
+ for ( TQPtrListIterator<ComboItem> it3( comboitems ); it3.current(); ++it3 ) {
+ ComboItem *ci = it3.current();
+ if ( !ci->combo )
+ return;
+ if ( iconset )
+ ci->combo->changeItem( iconset->pixmap(), text, ci->id );
+ else
+ ci->combo->changeItem( text, ci->id );
+ }
+}
+
+TQString TQActionPrivate::menuText() const
+{
+ if ( menutext.isNull() ) {
+ TQString t(text);
+ t.tqreplace('&', "&&");
+ return t;
+ }
+ return menutext;
+}
+
+TQString TQActionPrivate::toolTip() const
+{
+ if ( tooltip.isNull() ) {
+#ifndef TQT_NO_ACCEL
+ if ( accel )
+ return text + " (" + TQAccel::keyToString( accel->key( accelid )) + ")";
+#endif
+ return text;
+ }
+ return tooltip;
+}
+
+TQString TQActionPrivate::statusTip() const
+{
+ if ( statustip.isNull() )
+ return toolTip();
+ return statustip;
+}
+
+/*
+ internal: guesses a descriptive text from a menu text
+ */
+static TQString qt_stripMenuText( TQString s )
+{
+ s.remove( TQString::tqfromLatin1("...") );
+ s.remove( TQChar('&' ) );
+ return s.stripWhiteSpace();
+}
+
+/*!
+ Constructs an action called \a name with tqparent \a tqparent.
+
+ If \a tqparent is a TQActionGroup, the new action inserts itself into
+ \a tqparent.
+
+ For accelerators and status tips to work, \a tqparent must either be
+ a widget, or an action group whose tqparent 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.
+*/
+TQAction::TQAction( TQT_BASE_OBJECT_NAME* tqparent, const char* name )
+ : TQObject( TQT_TQOBJECT(tqparent), name )
+{
+ d = new TQActionPrivate(this);
+ init();
+}
+
+/*! \obsolete
+ Constructs an action called \a name with tqparent \a tqparent.
+
+ If \a toggle is TRUE the action will be a toggle action, otherwise
+ it will be a command action.
+
+ If \a tqparent is a TQActionGroup, the new action inserts itself into
+ \a tqparent.
+
+ For accelerators and status tips to work, \a tqparent must either be
+ a widget, or an action group whose tqparent is a widget.
+*/
+TQAction::TQAction( TQT_BASE_OBJECT_NAME* tqparent, const char* name, bool toggle )
+ : TQObject( TQT_TQOBJECT(tqparent), name )
+{
+ d = new TQActionPrivate(this);
+ d->toggleaction = toggle;
+ init();
+}
+
+
+#ifndef TQT_NO_ACCEL
+
+/*!
+ This constructor creates an action with the following properties:
+ the icon or iconset \a icon, the menu text \a menuText and
+ keyboard accelerator \a accel. It is a child of \a tqparent and
+ called \a name.
+
+ If \a tqparent is a TQActionGroup, the action automatically becomes
+ a member of it.
+
+ For accelerators and status tips to work, \a tqparent must either be
+ a widget, or an action group whose tqparent is a widget.
+
+ The action uses a stripped version of \a menuText (e.g. "\&Menu
+ Option..." becomes "Menu Option") as descriptive text for
+ toolbuttons. 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.
+*/
+TQAction::TQAction( const TQIconSet& icon, const TQString& menuText, TQKeySequence accel,
+ TQT_BASE_OBJECT_NAME* tqparent, const char* name )
+ : TQObject( TQT_TQOBJECT(tqparent), name )
+{
+ d = new TQActionPrivate(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 the menu
+ text \a menuText and keyboard accelerator \a accel. It is a child
+ of \a tqparent and called \a name.
+
+ If \a tqparent is a TQActionGroup, the action automatically becomes
+ a member of it.
+
+ For accelerators and status tips to work, \a tqparent must either be
+ a widget, or an action group whose tqparent is a widget.
+
+ The action uses a stripped version of \a menuText (e.g. "\&Menu
+ Option..." becomes "Menu Option") as descriptive text for
+ toolbuttons. 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.
+*/
+TQAction::TQAction( const TQString& menuText, TQKeySequence accel,
+ TQT_BASE_OBJECT_NAME* tqparent, const char* name )
+ : TQObject( TQT_TQOBJECT(tqparent), name )
+{
+ d = new TQActionPrivate(this);
+ d->text = qt_stripMenuText( menuText );
+ d->menutext = menuText;
+ setAccel( accel );
+ init();
+}
+
+/*! \obsolete
+ This constructor creates an action with the following properties:
+ the description \a text, the icon or iconset \a icon, the menu
+ text \a menuText and keyboard accelerator \a accel. It is a child
+ of \a tqparent 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 tqparent is a TQActionGroup, the action automatically becomes
+ a member of it.
+
+ For accelerators and status tips to work, \a tqparent must either be
+ a widget, or an action group whose tqparent 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().
+*/
+TQAction::TQAction( const TQString& text, const TQIconSet& icon, const TQString& menuText, TQKeySequence accel, TQT_BASE_OBJECT_NAME* tqparent, const char* name, bool toggle )
+ : TQObject( TQT_TQOBJECT(tqparent), name )
+{
+ d = new TQActionPrivate(this);
+ d->toggleaction = toggle;
+ if ( !icon.isNull() )
+ setIconSet( icon );
+
+ d->text = text;
+ d->menutext = menuText;
+ setAccel( accel );
+ init();
+}
+
+/*! \obsolete
+ 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 tqparent is \a tqparent 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 tqparent if \a
+ tqparent is a TQActionGroup.
+
+ For accelerators and status tips to work, \a tqparent must either be
+ a widget, or an action group whose tqparent 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().
+*/
+TQAction::TQAction( const TQString& text, const TQString& menuText, TQKeySequence accel, TQT_BASE_OBJECT_NAME* tqparent, const char* name, bool toggle )
+ : TQObject( TQT_TQOBJECT(tqparent), name )
+{
+ d = new TQActionPrivate(this);
+ d->toggleaction = toggle;
+ d->text = text;
+ d->menutext = menuText;
+ setAccel( accel );
+ init();
+}
+#endif
+
+/*!
+ \internal
+*/
+void TQAction::init()
+{
+ if ( ::tqqt_cast<TQActionGroup*>(tqparent()) )
+ ((TQActionGroup*) tqparent())->add( this ); // insert into action group
+}
+
+/*!
+ Destroys the object and frees allocated resources.
+*/
+
+TQAction::~TQAction()
+{
+ delete d;
+}
+
+/*!
+ \property TQAction::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 (TQIconSet::isNull() is passed into this function,
+ the icon of the action is cleared.
+
+ (See the action/toggleaction/toggleaction.cpp example.)
+
+*/
+void TQAction::setIconSet( const TQIconSet& icon )
+{
+ register TQIconSet *i = d->iconset;
+ if ( !icon.isNull() )
+ d->iconset = new TQIconSet( icon );
+ else
+ d->iconset = 0;
+ delete i;
+ d->update( TQActionPrivate::Icons );
+}
+
+TQIconSet TQAction::iconSet() const
+{
+ if ( d->iconset )
+ return *d->iconset;
+ return TQIconSet();
+}
+
+/*!
+ \property TQAction::text
+ \brief the action's descriptive text
+
+ If \l TQMainWindow::usesTextLabel is TRUE, the text appears as a
+ label in the relevant tool button. It also serves as the default
+ text in menus and tool tips if these have not been specifically
+ defined. There is no default text.
+
+ \sa setMenuText() setToolTip() setStatusTip()
+*/
+void TQAction::setText( const TQString& text )
+{
+ d->text = text;
+ d->update();
+}
+
+TQString TQAction::text() const
+{
+ return d->text;
+}
+
+
+/*!
+ \property TQAction::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 TQAction::setMenuText( const TQString& text )
+{
+ if ( d->menutext == text )
+ return;
+
+ d->menutext = text;
+ d->update();
+}
+
+TQString TQAction::menuText() const
+{
+ return d->menuText();
+}
+
+/*!
+ \property TQAction::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 TQAction::setToolTip( const TQString& tip )
+{
+ if ( d->tooltip == tip )
+ return;
+
+ d->tooltip = tip;
+ d->update();
+}
+
+TQString TQAction::toolTip() const
+{
+ return d->toolTip();
+}
+
+/*!
+ \property TQAction::statusTip
+ \brief the action's status tip
+
+ The statusTip is displayed on all status bars that this action's
+ toplevel tqparent widget provides.
+
+ If no status tip is defined, the action uses the tool tip text.
+
+ There is no default statusTip text.
+
+ \sa setStatusTip() setToolTip()
+*/
+//#### Please reimp for TQActionGroup!
+//#### For consistency reasons even action groups should show
+//#### status tips (as they already do with tool tips)
+//#### Please change TQActionGroup class doc appropriately after
+//#### reimplementation.
+void TQAction::setStatusTip( const TQString& tip )
+{
+ if ( d->statustip == tip )
+ return;
+
+ d->statustip = tip;
+ d->update();
+}
+
+TQString TQAction::statusTip() const
+{
+ return d->statusTip();
+}
+
+/*!
+ \property TQAction::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
+ TQStyleSheet for the list of supported tags). There is no default
+ "What's This" text.
+
+ \sa TQWhatsThis
+*/
+void TQAction::setWhatsThis( const TQString& whatsThis )
+{
+ if ( d->whatsthis == whatsThis )
+ return;
+ d->whatsthis = whatsThis;
+ d->update();
+}
+
+TQString TQAction::whatsThis() const
+{
+ return d->whatsthis;
+}
+
+
+#ifndef TQT_NO_ACCEL
+/*!
+ \property TQAction::accel
+ \brief the action's accelerator key
+
+ The keycodes can be found in \l TQt::Key and \l TQt::Modifier. There
+ is no default accelerator key.
+*/
+//#### Please reimp for TQActionGroup!
+//#### For consistency reasons even TQActionGroups should respond to
+//#### their accelerators and e.g. open the relevant submenu.
+//#### Please change appropriate TQActionGroup class doc after
+//#### reimplementation.
+void TQAction::setAccel( const TQKeySequence& key )
+{
+ if ( d->key == key )
+ return;
+
+ d->key = key;
+ delete d->accel;
+ d->accel = 0;
+
+ if ( !(int)key ) {
+ d->update();
+ return;
+ }
+
+ TQObject* p = tqparent();
+ while ( p && !p->isWidgetType() ) {
+ p = p->tqparent();
+ }
+ if ( p ) {
+ d->accel = new TQAccel( (TQWidget*)p, this, "qt_action_accel" );
+ d->accelid = d->accel->insertItem( d->key );
+ d->accel->connectItem( d->accelid, this, TQT_SLOT( internalActivation() ) );
+ }
+#if defined(TQT_CHECK_STATE)
+ else
+ qWarning( "TQAction::setAccel() (%s) requires widget in tqparent chain", name() );
+#endif
+ d->update();
+}
+
+
+TQKeySequence TQAction::accel() const
+{
+ return d->key;
+}
+#endif
+
+
+/*!
+ \property TQAction::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
+ TQActionGroup with the \l TQActionGroup::exclusive property set to
+ TRUE.
+*/
+void TQAction::setToggleAction( bool enable )
+{
+ if ( enable == (bool)d->toggleaction )
+ return;
+
+ if ( !enable )
+ d->on = FALSE;
+
+ d->toggleaction = enable;
+ d->update();
+}
+
+bool TQAction::isToggleAction() const
+{
+ return d->toggleaction;
+}
+
+/*!
+ Activates the action and executes all connected Q_SLOTS.
+ This only works for actions that are not toggle action.
+
+ \sa toggle()
+*/
+void TQAction::activate()
+{
+ if ( isToggleAction() ) {
+#if defined(TQT_CHECK_STATE)
+ qWarning( "TQAction::%s() (%s) Toggle actions "
+ "can not be activated", "activate", name() );
+#endif
+ return;
+ }
+ emit activated();
+}
+
+/*!
+ Toggles the state of a toggle action.
+
+ \sa on, activate(), toggled(), isToggleAction()
+*/
+void TQAction::toggle()
+{
+ if ( !isToggleAction() ) {
+#if defined(TQT_CHECK_STATE)
+ qWarning( "TQAction::%s() (%s) Only toggle actions "
+ "can be switched", "toggle", name() );
+#endif
+ return;
+ }
+ setOn( !isOn() );
+}
+
+/*!
+ \property TQAction::on
+ \brief whether a toggle action is on
+
+ This property is always on (TRUE) for command actions and
+ \l{TQActionGroup}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 TQAction::setOn( bool enable )
+{
+ if ( !isToggleAction() ) {
+#if defined(TQT_CHECK_STATE)
+ if ( enable )
+ qWarning( "TQAction::%s() (%s) Only toggle actions "
+ "can be switched", "setOn", name() );
+#endif
+ return;
+ }
+ if ( enable == (bool)d->on )
+ return;
+ d->on = enable;
+ d->update( TQActionPrivate::State );
+ emit toggled( enable );
+}
+
+bool TQAction::isOn() const
+{
+ return d->on;
+}
+
+/*!
+ \property TQAction::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 TQAction::whatsThis property is set.
+*/
+void TQAction::setEnabled( bool enable )
+{
+ d->forceDisabled = !enable;
+
+ if ( (bool)d->enabled == enable )
+ return;
+
+ d->enabled = enable;
+ d->update( TQActionPrivate::State );
+}
+
+bool TQAction::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 TQAction::setDisabled( bool disable )
+{
+ setEnabled( !disable );
+}
+
+/*!
+ \property TQAction::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 TQAction::tqsetVisible( bool visible )
+{
+ d->forceInvisible = !visible;
+
+ if ( (bool)d->visible == visible )
+ return;
+ d->visible = visible;
+ d->update( TQActionPrivate::Visibility );
+#if (TQT_VERSION-0 >= 0x040000)
+#error "TQAction::tqsetVisible function wants to be virtual. Also add virtual change() function"
+#endif
+ if ( d->d_group ) //### this function wants to be virtual in 4.0
+ d->d_group->update( (TQActionGroup*) this );
+}
+
+/*
+ Returns TRUE if the action is visible (e.g. in menus and
+ toolbars); otherwise returns FALSE.
+*/
+bool TQAction::isVisible() const
+{
+ return d->visible;
+}
+
+/*! \internal
+*/
+void TQAction::internalActivation()
+{
+ if ( isToggleAction() )
+ setOn( !isOn() );
+ emit activated();
+}
+
+/*! \internal
+*/
+void TQAction::toolButtonToggled( bool on )
+{
+ if ( !isToggleAction() )
+ return;
+ setOn( on );
+}
+
+/*!
+ Adds this action to widget \a w.
+
+ Currently actions may be added to TQToolBar and TQPopupMenu 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 TQToolBar or TQPopupMenu the
+ action will not be added and FALSE will be returned.)
+
+ \sa removeFrom()
+*/
+bool TQAction::addTo( TQWidget* w )
+{
+#ifndef TQT_NO_TOOLBAR
+ if ( ::tqqt_cast<TQToolBar*>(w) ) {
+ if ( !qstrcmp( name(), "qt_separator_action" ) ) {
+ ((TQToolBar*)w)->addSeparator();
+ } else {
+ TQCString bname = name() + TQCString( "_action_button" );
+ TQToolButton* btn = new TQToolButton( (TQToolBar*) w, bname );
+ addedTo( btn, w );
+ btn->setToggleButton( d->toggleaction );
+ d->toolbuttons.append( btn );
+ if ( d->iconset )
+ btn->setIconSet( *d->iconset );
+ d->update( TQActionPrivate::State | TQActionPrivate::Visibility | TQActionPrivate::EverythingElse ) ;
+ connect( btn, TQT_SIGNAL( clicked() ), this, TQT_SIGNAL( activated() ) );
+ connect( btn, TQT_SIGNAL( toggled(bool) ), this, TQT_SLOT( toolButtonToggled(bool) ) );
+ connect( btn, TQT_SIGNAL( destroyed() ), this, TQT_SLOT( objectDestroyed() ) );
+#ifndef TQT_NO_TOOLTIP
+ connect( &(d->tipGroup), TQT_SIGNAL(showTip(const TQString&)), this, TQT_SLOT(showtqStatusText(const TQString&)) );
+ connect( &(d->tipGroup), TQT_SIGNAL(removeTip()), this, TQT_SLOT(cleartqStatusText()) );
+#endif
+ }
+ } else
+#endif
+ if ( ::tqqt_cast<TQPopupMenu*>(w) ) {
+ TQActionPrivate::MenuItem* mi = new TQActionPrivate::MenuItem;
+ mi->popup = (TQPopupMenu*) w;
+ TQIconSet* diconset = d->iconset;
+ if ( !qstrcmp( name(), "qt_separator_action" ) )
+ mi->id = ((TQPopupMenu*)w)->insertSeparator();
+ else if ( diconset )
+ mi->id = mi->popup->insertItem( *diconset, TQString::tqfromLatin1("") );
+ else
+ mi->id = mi->popup->insertItem( TQString::tqfromLatin1("") );
+ addedTo( mi->popup->indexOf( mi->id ), mi->popup );
+ mi->popup->connectItem( mi->id, this, TQT_SLOT(internalActivation()) );
+ d->menuitems.append( mi );
+ d->update( TQActionPrivate::State | TQActionPrivate::Visibility | TQActionPrivate::EverythingElse ) ;
+ w->tqtopLevelWidget()->className();
+ connect( mi->popup, TQT_SIGNAL(highlighted(int)), this, TQT_SLOT(menutqStatusText(int)) );
+ connect( mi->popup, TQT_SIGNAL(aboutToHide()), this, TQT_SLOT(cleartqStatusText()) );
+ connect( mi->popup, TQT_SIGNAL( destroyed() ), this, TQT_SLOT( objectDestroyed() ) );
+ // Makes only sense when called by TQActionGroup::addTo
+ } else if ( ::tqqt_cast<TQComboBox*>(w) ) {
+ TQActionPrivate::ComboItem *ci = new TQActionPrivate::ComboItem;
+ ci->combo = (TQComboBox*)w;
+ connect( ci->combo, TQT_SIGNAL( destroyed() ), this, TQT_SLOT( objectDestroyed() ) );
+ ci->id = ci->combo->count();
+ if ( qstrcmp( name(), "qt_separator_action" ) ) {
+ if ( d->iconset )
+ ci->combo->insertItem( d->iconset->pixmap(), text() );
+ else
+ ci->combo->insertItem( text() );
+ } else {
+ ci->id = -1;
+ }
+ d->comboitems.append( ci );
+
+ d->update( TQActionPrivate::State | TQActionPrivate::EverythingElse );
+ } else {
+ qWarning( "TQAction::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 TQAction::addedTo( TQWidget *actionWidget, TQWidget *container )
+{
+ TQ_UNUSED( actionWidget );
+ TQ_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 TQAction::addedTo( int index, TQPopupMenu *menu )
+{
+ TQ_UNUSED( index );
+ TQ_UNUSED( menu );
+}
+
+/*!
+ Sets the status message to \a text
+*/
+void TQAction::showtqStatusText( const TQString& text )
+{
+#ifndef TQT_NO_STATUSBAR
+ // tqfind out whether we are clearing the status bar by the popup that actually set the text
+ static TQPopupMenu *lastmenu = 0;
+ TQObject *s = (TQObject*)sender();
+ if ( s ) {
+ TQPopupMenu *menu = (TQPopupMenu*)s->tqqt_cast( "TQPopupMenu" );
+ if ( menu && !!text )
+ lastmenu = menu;
+ else if ( menu && text.isEmpty() ) {
+ if ( lastmenu && menu != lastmenu )
+ return;
+ lastmenu = 0;
+ }
+ }
+
+ TQObject* par = tqparent();
+ TQObject* lpar = 0;
+ TQStatusBar *bar = 0;
+ while ( par && !bar ) {
+ lpar = par;
+ bar = (TQStatusBar*)par->child( 0, "TQStatusBar", FALSE );
+ par = par->tqparent();
+ }
+ if ( !bar && lpar ) {
+ TQObjectList *l = lpar->queryList( "TQStatusBar" );
+ if ( !l )
+ return;
+ // #### hopefully the last one is the one of the mainwindow...
+ bar = (TQStatusBar*)l->last();
+ delete l;
+ }
+ if ( bar ) {
+ if ( text.isEmpty() )
+ bar->clear();
+ else
+ bar->message( text );
+ }
+#endif
+}
+
+/*!
+ Sets the status message to the menu item's status text, or to the
+ tooltip, if there is no status text.
+*/
+void TQAction::menutqStatusText( int id )
+{
+ static int lastId = 0;
+ TQString text;
+ TQPtrListIterator<TQActionPrivate::MenuItem> it( d->menuitems);
+ TQActionPrivate::MenuItem* mi;
+ while ( ( mi = it.current() ) ) {
+ ++it;
+ if ( mi->id == id ) {
+ text = statusTip();
+ break;
+ }
+ }
+
+ if ( !text.isEmpty() )
+ showtqStatusText( text );
+ else if ( id != lastId )
+ cleartqStatusText();
+ lastId = id;
+}
+
+/*!
+ Clears the status text.
+*/
+void TQAction::cleartqStatusText()
+{
+ if (!statusTip().isEmpty())
+ showtqStatusText( TQString::null );
+}
+
+/*!
+ Removes the action from widget \a w.
+
+ Returns TRUE if the action was removed successfully; otherwise
+ returns FALSE.
+
+ \sa addTo()
+*/
+bool TQAction::removeFrom( TQWidget* w )
+{
+#ifndef TQT_NO_TOOLBAR
+ if ( ::tqqt_cast<TQToolBar*>(w) ) {
+ TQPtrListIterator<TQToolButton> it( d->toolbuttons);
+ TQToolButton* btn;
+ while ( ( btn = it.current() ) ) {
+ ++it;
+ if ( btn->parentWidget() == w ) {
+ d->toolbuttons.removeRef( btn );
+ disconnect( btn, TQT_SIGNAL( destroyed() ), this, TQT_SLOT( objectDestroyed() ) );
+ delete btn;
+ // no need to disconnect from statusbar
+ }
+ }
+ } else
+#endif
+ if ( ::tqqt_cast<TQPopupMenu*>(w) ) {
+ TQPtrListIterator<TQActionPrivate::MenuItem> it( d->menuitems);
+ TQActionPrivate::MenuItem* mi;
+ while ( ( mi = it.current() ) ) {
+ ++it;
+ if ( mi->popup == w ) {
+ disconnect( mi->popup, TQT_SIGNAL(highlighted(int)), this, TQT_SLOT(menutqStatusText(int)) );
+ disconnect( mi->popup, TQT_SIGNAL(aboutToHide()), this, TQT_SLOT(cleartqStatusText()) );
+ disconnect( mi->popup, TQT_SIGNAL( destroyed() ), this, TQT_SLOT( objectDestroyed() ) );
+ mi->popup->removeItem( mi->id );
+ d->menuitems.removeRef( mi );
+ }
+ }
+ } else if ( ::tqqt_cast<TQComboBox*>(w) ) {
+ TQPtrListIterator<TQActionPrivate::ComboItem> it( d->comboitems );
+ TQActionPrivate::ComboItem *ci;
+ while ( ( ci = it.current() ) ) {
+ ++it;
+ if ( ci->combo == w ) {
+ disconnect( ci->combo, TQT_SIGNAL(destroyed()), this, TQT_SLOT(objectDestroyed()) );
+ d->comboitems.removeRef( ci );
+ }
+ }
+ } else {
+ qWarning( "TQAction::removeFrom(), unknown object" );
+ return FALSE;
+ }
+ return TRUE;
+}
+
+/*!
+ \internal
+*/
+void TQAction::objectDestroyed()
+{
+ const TQObject* obj = TQT_TQOBJECT(sender());
+ TQPtrListIterator<TQActionPrivate::MenuItem> it( d->menuitems );
+ TQActionPrivate::MenuItem* mi;
+ while ( ( mi = it.current() ) ) {
+ ++it;
+ if ( TQT_TQOBJECT(mi->popup) == obj )
+ d->menuitems.removeRef( mi );
+ }
+ TQActionPrivate::ComboItem *ci;
+ TQPtrListIterator<TQActionPrivate::ComboItem> it2( d->comboitems );
+ while ( ( ci = it2.current() ) ) {
+ ++it2;
+ if ( TQT_TQOBJECT(ci->combo) == obj )
+ d->comboitems.removeRef( ci );
+ }
+ d->toolbuttons.removeRef( (TQToolButton*) obj );
+}
+
+/*!
+ \fn void TQAction::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 TQAction::toggled(bool on)
+
+ This signal is emitted when a toggle action changes state; command
+ actions and \l{TQActionGroup}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, e.g.
+
+ \quotefile action/toggleaction/toggleaction.cpp
+ \skipto TQMainWindow * window
+ \printline TQMainWindow * window
+ \skipto labelonoffaction
+ \printline labelonoffaction
+ \skipto connect
+ \printuntil setUsesTextLabel
+
+ \sa activated() setToggleAction() setOn()
+*/
+
+void TQActionGroupPrivate::update( const TQActionGroup* that )
+{
+ for ( TQPtrListIterator<TQAction> it( actions ); it.current(); ++it ) {
+ if ( that->isEnabled() && !it.current()->d->forceDisabled ) {
+ it.current()->setEnabled( TRUE );
+ } else if ( !that->isEnabled() && it.current()->isEnabled() ) {
+ it.current()->setEnabled( FALSE );
+ it.current()->d->forceDisabled = FALSE;
+ }
+ if ( that->isVisible() && !it.current()->d->forceInvisible ) {
+ it.current()->tqsetVisible( TRUE );
+ } else if ( !that->isVisible() && it.current()->isVisible() ) {
+ it.current()->tqsetVisible( FALSE );
+ it.current()->d->forceInvisible = FALSE;
+ }
+ }
+ for ( TQPtrListIterator<TQComboBox> cb( comboboxes ); cb.current(); ++cb ) {
+ TQComboBox *combobox = cb.current();
+ combobox->setEnabled( that->isEnabled() );
+ combobox->setShown( that->isVisible() );
+
+#ifndef TQT_NO_TOOLTIP
+ TQToolTip::remove( combobox );
+ if ( !!that->toolTip() )
+ TQToolTip::add( combobox, that->toolTip() );
+#endif
+#ifndef TQT_NO_WHATSTHIS
+ TQWhatsThis::remove( combobox );
+ if ( !!that->whatsThis() )
+ TQWhatsThis::add( combobox, that->whatsThis() );
+#endif
+
+ }
+ for ( TQPtrListIterator<TQToolButton> mb( menubuttons ); mb.current(); ++mb ) {
+ TQToolButton *button = mb.current();
+ 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 TQT_NO_TOOLTIP
+ TQToolTip::remove( mb.current() );
+ if ( !!that->toolTip() )
+ TQToolTip::add( button, that->toolTip() );
+#endif
+#ifndef TQT_NO_WHATSTHIS
+ TQWhatsThis::remove( button );
+ if ( !!that->whatsThis() )
+ TQWhatsThis::add( button, that->whatsThis() );
+#endif
+ }
+ for ( TQPtrListIterator<TQActionGroupPrivate::MenuItem> pu( menuitems ); pu.current(); ++pu ) {
+ TQWidget* tqparent = pu.current()->popup->parentWidget();
+ if ( ::tqqt_cast<TQPopupMenu*>(tqparent) ) {
+ TQPopupMenu* ppopup = (TQPopupMenu*)tqparent;
+ ppopup->setItemEnabled( pu.current()->id, that->isEnabled() );
+ ppopup->setItemVisible( pu.current()->id, that->isVisible() );
+ } else {
+ pu.current()->popup->setEnabled( that->isEnabled() );
+ }
+ }
+ for ( TQPtrListIterator<TQPopupMenu> pm( popupmenus ); pm.current(); ++pm ) {
+ TQPopupMenu *popup = pm.current();
+ TQPopupMenu *tqparent = ::tqqt_cast<TQPopupMenu*>(popup->parentWidget());
+ if ( !tqparent )
+ continue;
+
+ int index;
+ tqparent->tqfindPopup( popup, &index );
+ int id = tqparent->idAt( index );
+ if ( !that->iconSet().isNull() )
+ tqparent->changeItem( id, that->iconSet(), that->menuText() );
+ else
+ tqparent->changeItem( id, that->menuText() );
+ tqparent->setItemEnabled( id, that->isEnabled() );
+#ifndef TQT_NO_ACCEL
+ tqparent->setAccel( that->accel(), id );
+#endif
+ }
+}
+
+/*!
+ \class TQActionGroup tqaction.h
+ \brief The TQActionGroup class groups actions together.
+
+ \ingroup basic
+ \ingroup application
+
+ 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.
+
+ Here's an example from examples/textedit:
+ \quotefile textedit/textedit.cpp
+ \skipto TQActionGroup
+ \printuntil connect
+
+ Here we create a new action group. Since the action group is exclusive
+ by default, only one of the actions in the group is ever active at any
+ one time. We then connect the group's selected() signal to our
+ textAlign() slot.
+
+ \printuntil actionAlignLeft->setToggleAction
+
+ We create a left align action, add it to the toolbar and the menu
+ and make it a toggle action. We create center and right align
+ actions in exactly the same way.
+
+ \omit
+ A TQActionGroup emits an activated() signal when one of its actions
+ is activated.
+ \endomit
+ The actions in an action group emit their activated() (and for
+ toggle actions, toggled()) Q_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
+ tqparent. Actions can have separators dividing them using
+ addSeparator(). Action groups are added to widgets with addTo().
+*/
+
+/*!
+ Constructs an action group called \a name, with tqparent \a tqparent.
+
+ The action group is exclusive by default. Call setExclusive(FALSE) to make
+ the action group non-exclusive.
+*/
+TQActionGroup::TQActionGroup( TQT_BASE_OBJECT_NAME* tqparent, const char* name )
+ : TQAction( TQT_TQOBJECT(tqparent), name )
+{
+ d = new TQActionGroupPrivate;
+ d->exclusive = TRUE;
+ d->dropdown = FALSE;
+ d->selected = 0;
+ d->separatorAction = 0;
+ TQAction::d->d_group = d;
+
+ connect( this, TQT_SIGNAL(selected(TQAction*)), TQT_SLOT(internalToggle(TQAction*)) );
+}
+
+/*!
+ Constructs an action group called \a name, with tqparent \a tqparent.
+
+ If \a exclusive is TRUE only one toggle action in the group will
+ ever be active.
+
+ \sa exclusive
+*/
+TQActionGroup::TQActionGroup( TQT_BASE_OBJECT_NAME* tqparent, const char* name, bool exclusive )
+ : TQAction( TQT_TQOBJECT(tqparent), name )
+{
+ d = new TQActionGroupPrivate;
+ d->exclusive = exclusive;
+ d->dropdown = FALSE;
+ d->selected = 0;
+ d->separatorAction = 0;
+ TQAction::d->d_group = d;
+
+ connect( this, TQT_SIGNAL(selected(TQAction*)), TQT_SLOT(internalToggle(TQAction*)) );
+}
+
+/*!
+ Destroys the object and frees allocated resources.
+*/
+
+TQActionGroup::~TQActionGroup()
+{
+ TQPtrListIterator<TQActionGroupPrivate::MenuItem> mit( d->menuitems );
+ while ( mit.current() ) {
+ TQActionGroupPrivate::MenuItem *mi = mit.current();
+ ++mit;
+ if ( mi->popup )
+ mi->popup->disconnect( TQT_SIGNAL(destroyed()), this, TQT_SLOT(objectDestroyed()) );
+ }
+
+ TQPtrListIterator<TQComboBox> cbit( d->comboboxes );
+ while ( cbit.current() ) {
+ TQComboBox *cb = cbit.current();
+ ++cbit;
+ cb->disconnect( TQT_SIGNAL(destroyed()), this, TQT_SLOT(objectDestroyed()) );
+ }
+ TQPtrListIterator<TQToolButton> mbit( d->menubuttons );
+ while ( mbit.current() ) {
+ TQToolButton *mb = mbit.current();
+ ++mbit;
+ mb->disconnect( TQT_SIGNAL(destroyed()), this, TQT_SLOT(objectDestroyed()) );
+ }
+ TQPtrListIterator<TQPopupMenu> pmit( d->popupmenus );
+ while ( pmit.current() ) {
+ TQPopupMenu *pm = pmit.current();
+ ++pmit;
+ pm->disconnect( TQT_SIGNAL(destroyed()), this, TQT_SLOT(objectDestroyed()) );
+ }
+
+ delete d->separatorAction;
+ d->menubuttons.setAutoDelete( TRUE );
+ d->comboboxes.setAutoDelete( TRUE );
+ d->menuitems.setAutoDelete( TRUE );
+ d->popupmenus.setAutoDelete( TRUE );
+ delete d;
+}
+
+/*!
+ \property TQActionGroup::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 TQAction::toggleAction
+*/
+void TQActionGroup::setExclusive( bool enable )
+{
+ d->exclusive = enable;
+}
+
+bool TQActionGroup::isExclusive() const
+{
+ return d->exclusive;
+}
+
+/*!
+ \property TQActionGroup::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 TQAction::text and \l
+ TQAction::iconSet properties shown. Non-exclusive groups are
+ represented by a tool button showing their \l TQAction::iconSet and
+ -- depending on \l TQMainWindow::usesTextLabel() -- text()
+ property.
+
+ In a popup menu the member actions are displayed in a submenu.
+
+ Changing usesDropDown only affects \e subsequent calls to addTo().
+
+ Note that setting this property for actions in a combobox causes
+ calls to their \link TQAction::tqsetVisible()\endlink,
+ \link TQAction::setEnabled()\endlink, and
+ \link TQAction::setDisabled()\endlink functions to have no effect.
+
+ This property's default is FALSE.
+
+*/
+void TQActionGroup::setUsesDropDown( bool enable )
+{
+ d->dropdown = enable;
+}
+
+bool TQActionGroup::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 tqparent, so this function is not usually used.
+
+ \sa addTo()
+*/
+void TQActionGroup::add( TQAction* action )
+{
+ if ( d->actions.tqcontainsRef( 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, TQT_SIGNAL( destroyed() ), this, TQT_SLOT( childDestroyed() ) );
+ connect( action, TQT_SIGNAL( activated() ), this, TQT_SIGNAL( activated() ) );
+ connect( action, TQT_SIGNAL( toggled(bool) ), this, TQT_SLOT( childToggled(bool) ) );
+
+ for ( TQPtrListIterator<TQComboBox> cb( d->comboboxes ); cb.current(); ++cb ) {
+ action->addTo( cb.current() );
+ }
+ for ( TQPtrListIterator<TQToolButton> mb( d->menubuttons ); mb.current(); ++mb ) {
+ TQPopupMenu* popup = mb.current()->popup();
+ if ( !popup )
+ continue;
+ action->addTo( popup );
+ }
+ for ( TQPtrListIterator<TQActionGroupPrivate::MenuItem> mi( d->menuitems ); mi.current(); ++mi ) {
+ TQPopupMenu* popup = mi.current()->popup;
+ if ( !popup )
+ continue;
+ action->addTo( popup );
+ }
+}
+
+/*!
+ Adds a separator to the group.
+*/
+void TQActionGroup::addSeparator()
+{
+ if ( !d->separatorAction )
+ d->separatorAction = new TQAction( 0, "qt_separator_action" );
+ d->actions.append( d->separatorAction );
+}
+
+
+/*! \fn void TQActionGroup::insert( TQAction* a )
+
+ \obsolete
+
+ Use add() instead, or better still create the action with the action
+ group as its tqparent.
+ */
+
+/*!
+ 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 TQActionGroup::addTo( TQWidget* w )
+{
+#ifndef TQT_NO_TOOLBAR
+ if ( ::tqqt_cast<TQToolBar*>(w) ) {
+ if ( d->dropdown ) {
+ if ( !d->exclusive ) {
+ TQPtrListIterator<TQAction> it( d->actions);
+ if ( !it.current() )
+ return TRUE;
+
+ TQAction *defAction = it.current();
+
+ TQToolButton* btn = new TQToolButton( (TQToolBar*) w, "qt_actiongroup_btn" );
+ addedTo( btn, w );
+ connect( btn, TQT_SIGNAL(destroyed()), TQT_SLOT(objectDestroyed()) );
+ d->menubuttons.append( btn );
+
+ if ( !iconSet().isNull() )
+ btn->setIconSet( iconSet() );
+ else if ( !defAction->iconSet().isNull() )
+ btn->setIconSet( defAction->iconSet() );
+ if ( !!text() )
+ btn->setTextLabel( text() );
+ else if ( !!defAction->text() )
+ btn->setTextLabel( defAction->text() );
+#ifndef TQT_NO_TOOLTIP
+ if ( !!toolTip() )
+ TQToolTip::add( btn, toolTip() );
+ else if ( !!defAction->toolTip() )
+ TQToolTip::add( btn, defAction->toolTip() );
+#endif
+#ifndef TQT_NO_WHATSTHIS
+ if ( !!whatsThis() )
+ TQWhatsThis::add( btn, whatsThis() );
+ else if ( !!defAction->whatsThis() )
+ TQWhatsThis::add( btn, defAction->whatsThis() );
+#endif
+
+ connect( btn, TQT_SIGNAL( clicked() ), defAction, TQT_SIGNAL( activated() ) );
+ connect( btn, TQT_SIGNAL( toggled(bool) ), defAction, TQT_SLOT( toolButtonToggled(bool) ) );
+ connect( btn, TQT_SIGNAL( destroyed() ), defAction, TQT_SLOT( objectDestroyed() ) );
+
+ TQPopupMenu *menu = new TQPopupMenu( btn, "qt_actiongroup_menu" );
+ btn->setPopupDelay( 0 );
+ btn->setPopup( menu );
+
+ while( it.current() ) {
+ it.current()->addTo( menu );
+ ++it;
+ }
+ d->update( this );
+ return TRUE;
+ } else {
+ TQComboBox *box = new TQComboBox( FALSE, w, "qt_actiongroup_combo" );
+ addedTo( box, w );
+ connect( box, TQT_SIGNAL(destroyed()), TQT_SLOT(objectDestroyed()) );
+ d->comboboxes.append( box );
+#ifndef TQT_NO_TOOLTIP
+ if ( !!toolTip() )
+ TQToolTip::add( box, toolTip() );
+#endif
+#ifndef TQT_NO_WHATSTHIS
+ if ( !!whatsThis() )
+ TQWhatsThis::add( box, whatsThis() );
+#endif
+
+ int onIndex = 0;
+ bool foundOn = FALSE;
+ for ( TQPtrListIterator<TQAction> it( d->actions); it.current(); ++it ) {
+ TQAction *action = it.current();
+ if ( !foundOn )
+ foundOn = action->isOn();
+ if ( qstrcmp( action->name(), "qt_separator_action" ) && !foundOn )
+ onIndex++;
+ action->addTo( box );
+ }
+ if ( foundOn )
+ box->setCurrentItem( onIndex );
+ connect( box, TQT_SIGNAL(activated(int)), this, TQT_SLOT( internalComboBoxActivated(int)) );
+ connect( box, TQT_SIGNAL(highlighted(int)), this, TQT_SLOT( internalComboBoxHighlighted(int)) );
+ d->update( this );
+ return TRUE;
+ }
+ }
+ } else
+#endif
+ if ( ::tqqt_cast<TQPopupMenu*>(w) ) {
+ TQPopupMenu *popup;
+ if ( d->dropdown ) {
+ TQPopupMenu *menu = (TQPopupMenu*)w;
+ popup = new TQPopupMenu( w, "qt_actiongroup_menu" );
+ d->popupmenus.append( popup );
+ connect( popup, TQT_SIGNAL(destroyed()), TQT_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 );
+
+ TQActionGroupPrivate::MenuItem *item = new TQActionGroupPrivate::MenuItem;
+ item->id = id;
+ item->popup = popup;
+ d->menuitems.append( item );
+ } else {
+ popup = (TQPopupMenu*)w;
+ }
+ for ( TQPtrListIterator<TQAction> it( d->actions); it.current(); ++it ) {
+ // #### do an addedTo( index, popup, action), need to tqfind out index
+ it.current()->addTo( popup );
+ }
+ return TRUE;
+ }
+
+ for ( TQPtrListIterator<TQAction> it( d->actions); it.current(); ++it ) {
+ // #### do an addedTo( index, popup, action), need to tqfind out index
+ it.current()->addTo( w );
+ }
+
+ return TRUE;
+}
+
+/*! \reimp
+*/
+bool TQActionGroup::removeFrom( TQWidget* w )
+{
+ for ( TQPtrListIterator<TQAction> it( d->actions); it.current(); ++it ) {
+ it.current()->removeFrom( w );
+ }
+
+#ifndef TQT_NO_TOOLBAR
+ if ( ::tqqt_cast<TQToolBar*>(w) ) {
+ TQPtrListIterator<TQComboBox> cb( d->comboboxes );
+ while( cb.current() ) {
+ TQComboBox *box = cb.current();
+ ++cb;
+ if ( box->parentWidget() == w )
+ delete box;
+ }
+ TQPtrListIterator<TQToolButton> mb( d->menubuttons );
+ while( mb.current() ) {
+ TQToolButton *btn = mb.current();
+ ++mb;
+ if ( btn->parentWidget() == w )
+ delete btn;
+ }
+ } else
+#endif
+ if ( ::tqqt_cast<TQPopupMenu*>(w) ) {
+ TQPtrListIterator<TQActionGroupPrivate::MenuItem> pu( d->menuitems );
+ while ( pu.current() ) {
+ TQActionGroupPrivate::MenuItem *mi = pu.current();
+ ++pu;
+ if ( d->dropdown && mi->popup )
+ ( (TQPopupMenu*)w )->removeItem( mi->id );
+ delete mi->popup;
+ }
+ }
+
+ return TRUE;
+}
+
+/*! \internal
+*/
+void TQActionGroup::childToggled( bool b )
+{
+ if ( !isExclusive() )
+ return;
+ TQAction* s = (TQAction*) sender();
+ if ( b ) {
+ if ( s != d->selected ) {
+ d->selected = s;
+ for ( TQPtrListIterator<TQAction> it( d->actions); it.current(); ++it ) {
+ if ( it.current()->isToggleAction() && it.current() != s )
+ it.current()->setOn( FALSE );
+ }
+ emit activated();
+ emit selected( s );
+ } else if ( !s->isToggleAction() ) {
+ emit activated();
+ }
+ } else {
+ if ( s == d->selected ) {
+ // at least one has to be selected
+ s->setOn( TRUE );
+ }
+ }
+}
+
+/*! \internal
+*/
+void TQActionGroup::childDestroyed()
+{
+ d->actions.removeRef( (TQAction*) sender() );
+ if ( d->selected == sender() )
+ d->selected = 0;
+}
+
+/*! \reimp
+*/
+void TQActionGroup::setEnabled( bool enable )
+{
+ if ( enable == isEnabled() )
+ return;
+
+ TQAction::setEnabled( enable );
+ d->update( this );
+}
+
+/*! \reimp
+*/
+void TQActionGroup::setToggleAction( bool toggle )
+{
+ for ( TQPtrListIterator<TQAction> it( d->actions); it.current(); ++it )
+ it.current()->setToggleAction( toggle );
+
+ TQAction::setToggleAction( TRUE );
+ d->update( this );
+}
+
+/*! \reimp
+*/
+void TQActionGroup::setOn( bool on )
+{
+ for ( TQPtrListIterator<TQAction> it( d->actions); it.current(); ++it ) {
+ TQAction *act = it.current();
+ if ( act->isToggleAction() )
+ act->setOn( on );
+ }
+
+ TQAction::setOn( on );
+ d->update( this );
+}
+
+/*! \reimp
+*/
+void TQActionGroup::setIconSet( const TQIconSet& icon )
+{
+ TQAction::setIconSet( icon );
+ d->update( this );
+}
+
+/*! \reimp
+*/
+void TQActionGroup::setText( const TQString& txt )
+{
+ if ( txt == text() )
+ return;
+
+ TQAction::setText( txt );
+ d->update( this );
+}
+
+/*! \reimp
+*/
+void TQActionGroup::setMenuText( const TQString& text )
+{
+ if ( text == menuText() )
+ return;
+
+ TQAction::setMenuText( text );
+ d->update( this );
+}
+
+/*! \reimp
+*/
+void TQActionGroup::setToolTip( const TQString& text )
+{
+ if ( text == toolTip() )
+ return;
+ for ( TQPtrListIterator<TQAction> it( d->actions); it.current(); ++it ) {
+ if ( it.current()->toolTip().isNull() )
+ it.current()->setToolTip( text );
+ }
+ TQAction::setToolTip( text );
+ d->update( this );
+}
+
+/*! \reimp
+*/
+void TQActionGroup::setWhatsThis( const TQString& text )
+{
+ if ( text == whatsThis() )
+ return;
+ for ( TQPtrListIterator<TQAction> it( d->actions); it.current(); ++it ) {
+ if ( it.current()->whatsThis().isNull() )
+ it.current()->setWhatsThis( text );
+ }
+ TQAction::setWhatsThis( text );
+ d->update( this );
+}
+
+/*! \reimp
+*/
+void TQActionGroup::childEvent( TQChildEvent *e )
+{
+ if ( !e->removed() )
+ return;
+
+ TQAction *action = ::tqqt_cast<TQAction*>(e->child());
+ if ( !action )
+ return;
+
+ for ( TQPtrListIterator<TQComboBox> cb( d->comboboxes ); cb.current(); ++cb ) {
+ for ( int i = 0; i < cb.current()->count(); i++ ) {
+ if ( cb.current()->text( i ) == action->text() ) {
+ cb.current()->removeItem( i );
+ break;
+ }
+ }
+ }
+ for ( TQPtrListIterator<TQToolButton> mb( d->menubuttons ); mb.current(); ++mb ) {
+ TQPopupMenu* popup = mb.current()->popup();
+ if ( !popup )
+ continue;
+ action->removeFrom( popup );
+ }
+ for ( TQPtrListIterator<TQActionGroupPrivate::MenuItem> mi( d->menuitems ); mi.current(); ++mi ) {
+ TQPopupMenu* popup = mi.current()->popup;
+ if ( !popup )
+ continue;
+ action->removeFrom( popup );
+ }
+}
+
+/*!
+ \fn void TQActionGroup::selected( TQAction* )
+
+ This signal is emitted from exclusive groups when toggle actions
+ change state.
+
+ The argument is the action whose state changed to "on".
+
+ \sa setExclusive(), isOn() TQAction::toggled()
+*/
+
+/*! \internal
+*/
+void TQActionGroup::internalComboBoxActivated( int index )
+{
+ TQAction *a = 0;
+ for ( int i = 0; i <= index && i < (int)d->actions.count(); ++i ) {
+ a = d->actions.at( i );
+ if ( a && !qstrcmp( a->name(), "qt_separator_action" ) )
+ index++;
+ }
+ a = d->actions.at( index );
+ if ( a ) {
+ if ( a != d->selected ) {
+ d->selected = a;
+ for ( TQPtrListIterator<TQAction> it( d->actions); it.current(); ++it ) {
+ if ( it.current()->isToggleAction() && it.current() != a )
+ it.current()->setOn( FALSE );
+ }
+ if ( a->isToggleAction() )
+ a->setOn( TRUE );
+
+ emit activated();
+ if ( a->isToggleAction() )
+ emit selected( d->selected );
+ emit ((TQActionGroup*)a)->activated();
+ } else if ( !a->isToggleAction() ) {
+ emit activated();
+ emit ((TQActionGroup*)a)->activated();
+ }
+ a->cleartqStatusText();
+ }
+}
+
+/*! \internal
+*/
+void TQActionGroup::internalComboBoxHighlighted( int index )
+{
+ TQAction *a = 0;
+ for ( int i = 0; i <= index && i < (int)d->actions.count(); ++i ) {
+ a = d->actions.at( i );
+ if ( a && !qstrcmp( a->name(), "qt_separator_action" ) )
+ index++;
+ }
+ a = d->actions.at( index );
+ if ( a )
+ a->showtqStatusText(a->statusTip());
+ else
+ cleartqStatusText();
+}
+
+/*! \internal
+*/
+void TQActionGroup::internalToggle( TQAction *a )
+{
+ int index = d->actions.tqfind( a );
+ if ( index == -1 )
+ return;
+
+ int lastItem = index;
+ for ( int i = 0; i < lastItem; i++ ) {
+ TQAction *action = d->actions.at( i );
+ if ( !qstrcmp( action->name(), "qt_separator_action" ) )
+ index--;
+ }
+
+ for ( TQPtrListIterator<TQComboBox> it( d->comboboxes); it.current(); ++it )
+ it.current()->setCurrentItem( index );
+}
+
+/*! \internal
+*/
+void TQActionGroup::objectDestroyed()
+{
+ const TQObject* obj = TQT_TQOBJECT(sender());
+ d->menubuttons.removeRef( (TQToolButton*)obj );
+ for ( TQPtrListIterator<TQActionGroupPrivate::MenuItem> mi( d->menuitems ); mi.current(); ++mi ) {
+ if ( TQT_TQOBJECT(mi.current()->popup) == obj ) {
+ d->menuitems.removeRef( mi.current() );
+ break;
+ }
+ }
+ d->popupmenus.removeRef( (TQPopupMenu*)obj );
+ d->comboboxes.removeRef( (TQComboBox*)obj );
+}
+
+/*!
+ \internal
+
+ 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 TQActionGroup::addedTo( TQWidget *actionWidget, TQWidget *container, TQAction *a )
+{
+ TQ_UNUSED( actionWidget );
+ TQ_UNUSED( container );
+ TQ_UNUSED( a );
+}
+
+/*!
+ \overload
+ \internal
+
+ 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 TQActionGroup::addedTo( int index, TQPopupMenu *menu, TQAction *a )
+{
+ TQ_UNUSED( index );
+ TQ_UNUSED( menu );
+ TQ_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 TQActionGroup::addedTo( TQWidget *actionWidget, TQWidget *container )
+{
+ TQ_UNUSED( actionWidget );
+ TQ_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 TQActionGroup::addedTo( int index, TQPopupMenu *menu )
+{
+ TQ_UNUSED( index );
+ TQ_UNUSED( menu );
+}
+
+#endif