class KAction

# class KAction | Class to encapsulate user-driven action or event. More...
Definition | `#include <kaction.h>`
Inherits | QObject (qt) [public ]
Inherited by | KActionMenu, KActionSeparator, KFontAction, KFontSizeAction, KListAction, KRadioAction, KRecentFilesAction, KSelectAction, KToggleAction, KToggleToolBarAction, KToolBarPopupAction, KWidgetAction
List of all Methods
Annotated List
Files
Globals
Hierarchy
Index

#### Public Methods

- KAction ( const QString& text, const KShortcut& cut, const QObject* receiver, const char* slot, KActionCollection* parent, const char* name )
- KAction ( const QString& text, const QIconSet& pix, const KShortcut& cut, const QObject* receiver, const char* slot, KActionCollection* parent, const char* name )
- KAction ( const QString& text, const QString& pix, const KShortcut& cut, const QObject* receiver, const char* slot, KActionCollection* parent, const char* name )
- KAction ( const KGuiItem& item, const KShortcut& cut, const QObject* receiver, const char* slot, KActionCollection* parent, const char* name )
- KAction ( const QString& text, const KShortcut& cut = KShortcut(), QObject* parent = 0, const char* name = 0 )
- KAction ( const QString& text, const KShortcut& cut, const QObject* receiver, const char* slot, QObject* parent, const char* name = 0 )
- KAction ( const QString& text, const QIconSet& pix, const KShortcut& cut = KShortcut(), QObject* parent = 0, const char* name = 0 )
- KAction ( const QString& text, const QString& pix, const KShortcut& cut = KShortcut(), QObject* parent = 0, const char* name = 0 )
- KAction ( const QString& text, const QIconSet& pix, const KShortcut& cut, const QObject* receiver, const char* slot, QObject* parent, const char* name = 0 )
- KAction ( const QString& text, const QString& pix, const KShortcut& cut, const QObject* receiver, const char* slot, QObject* parent, const char* name = 0 )
- KAction ( QObject* parent = 0, const char* name = 0 )
- virtual ~KAction ()
- virtual int plug ( QWidget *w, int index = -1 )
- virtual void plugAccel (KAccel *accel, bool configurable = true)
- virtual void unplug ( QWidget *w )
- virtual void unplugAccel ()
- virtual bool isPlugged () const
- bool isPlugged ( const QWidget *container ) const
- virtual bool isPlugged ( const QWidget *container, int id ) const
- virtual bool isPlugged ( const QWidget *container, const QWidget *_representative ) const
- QWidget* container ( int index ) const
- int itemId ( int index ) const
- QWidget* representative ( int index ) const
- int containerCount () const
- uint kaccelCount () const
- virtual bool hasIcon () const
- bool hasIconSet () const
- virtual QString plainText () const
- virtual QString text () const
- virtual const KShortcut& shortcut () const
- virtual const KShortcut& shortcutDefault () const
- QString shortcutText () const
- void setShortcutText ( const QString& )
- virtual bool isEnabled () const
- virtual bool isShortcutConfigurable () const
- virtual QString group () const
- virtual QString whatsThis () const
- virtual QString toolTip () const
- virtual QIconSet iconSet ( KIcon::Group group, int size=0 ) const
- QIconSet iconSet () const
- virtual QString icon () const
- KActionCollection * parentCollection () const
- void unplugAll ()
- int accel () const
- QString statusText () const
- void setAccel ( int key )
- void setStatusText ( const QString &text )
- int menuId ( int i )

#### Public Slots

- virtual void setText (const QString &text)
- virtual bool setShortcut ( const KShortcut& )
- virtual void setGroup ( const QString& )
- virtual void setWhatsThis ( const QString& text )
- virtual void setToolTip ( const QString& )
- virtual void setIconSet ( const QIconSet &iconSet )
- virtual void setIcon ( const QString& icon )
- virtual void setEnabled (bool enable)
- virtual void setShortcutConfigurable ( bool )
- virtual void activate ()

#### Signals

- void activated ()
- void enabled ( bool )

#### Public Static Methods

- static int getToolButtonID ()

#### Protected Methods

- KToolBar* toolBar ( int index ) const
- QPopupMenu* popupMenu ( int index ) const
- void removeContainer ( int index )
- int findContainer ( const QWidget* widget ) const
- void plugMainWindowAccel ( QWidget *w )
- void addContainer ( QWidget* parent, int id )
- void addContainer ( QWidget* parent, QWidget* representative )
- virtual void updateShortcut ( int i )
- virtual void updateShortcut ( QPopupMenu* menu, int id )
- virtual void updateGroup ( int id )
- virtual void updateText (int i )
- virtual void updateEnabled (int i)
- virtual void updateIconSet (int i)
- virtual void updateIcon ( int i)
- virtual void updateToolTip ( int id )
- virtual void updateWhatsThis ( int i )
- QString whatsThisWithIcon () const
- virtual void virtual_hook ( int id, void* data )

#### Protected Slots

- virtual void slotDestroyed ()
- virtual void slotKeycodeChanged ()
- virtual void slotActivated ()

#### Protected Members

- KActionCollection *m_parentCollection

## Detailed Description

The KAction class (and derived and super classes) provides a way to easily encapsulate a "real" user-selected action or event in your program.

For instance, a user may want to `paste` the contents of the clipboard or `scroll` `down` a document or `quit` the application. These are all `actions` -- events that the user causes to happen. The KAction class allows the developer to deal with these actions in an easy and intuitive manner.

Specifically, the KAction class encapsulated the various attributes to an event/action. For instance, an action might have an icon that goes along with it (a clipboard for a "paste" action or scissors for a "cut" action). The action might have some text to describe the action. It will certainly have a method or function that actually `executes` the action! All these attributes are contained within the KAction object.

The advantage of dealing with Actions is that you can manipulate the Action without regard to the GUI representation of it. For instance, in the "normal" way of dealing with actions like "cut", you would manually insert a item for Cut into a menu and a button into a toolbar. If you want to disable the cut action for a moment (maybe nothing is selected), you woud have to hunt down the pointer to the menu item and the toolbar button and disable both individually. Setting the menu item and toolbar item up uses very similar code - but has to be done twice!

With the Action concept, you simply "plug" the Action into whatever GUI element you want. The KAction class will then take care of correctly defining the menu item (with icons, accelerators, text, etc) or toolbar button.. or whatever. From then on, if you manipulate the Action at all, the effect will propogate through all GUI representations of it. Back to the "cut" example: if you want to disable the Cut Action, you would simply do 'cutAction->setEnabled(false)' and the menuitem and button would instantly be disabled!

This is the biggest advantage to the Action concept -- there is a one-to-one relationship between the "real" action and `all` GUI representations of it.

KAction emits the activated() signal if the user activated the corresponding GUI element ( menu item, toolbar button, etc. )

If you are in the situation of wanting to map the activated() signal of multiple action objects to one slot, with a special argument bound to each action, then you might consider using QSignalMapper . A tiny example:

     QSignalMapper *desktopNumberMapper = new QSignalMapper( this );
     connect( desktopNumberMapper, SIGNAL( mapped( int ) ),
              this, SLOT( moveWindowToDesktop( int ) ) );

     for ( uint i = 0; i < numberOfDesktops; ++i ) {
         KAction *desktopAction = new KAction( i18n( "Move Window To Desktop %i" ).arg( i ), ... );
         connect( desktopAction, SIGNAL( activated() ), desktopNumberMapper, SLOT( map() ) );
         desktopNumberMapper->setMapping( desktopAction, i );
     }

### General Usage:

The steps to using actions are roughly as follows

- Decide which attributes you want to associate with a given action (icons, text, keyboard shortcut, etc)
- Create the action using KAction (or derived or super class).
- "Plug" the Action into whatever GUI element you want. Typically, this will be a menu or toolbar.

### Detailed Example:

Here is an example of enabling a "New [document]" action

     KAction *newAct = new KAction(i18n("&New"), "filenew",
                                   KStdAccel::shortcut(KStdAccel::New),
                                   this, SLOT(fileNew()),
                                   actionCollection(), "new");

This line creates our action. It says that wherever this action is displayed, it will use "&New" as the text, the standard icon, and the standard shortcut. It further says that whenever this action is invoked, it will use the fileNew() slot to execute it.

     QPopupMenu *file = new QPopupMenu;
     newAct->plug(file);

That just inserted the action into the File menu. The point is, it's not important in which menu it is: all manipulation of the item is done through the newAct object.

     newAct->plug(toolBar());

And this inserted the Action into the main toolbar as a button.

That's it!

If you want to disable that action sometime later, you can do so with

     newAct->setEnabled(false)

and both the menuitem in File and the toolbar button will instantly be disabled.

Note: if you are using a "standard" action like "new", "paste", "quit", or any other action described in the KDE UI Standards, please use the methods in the KStdAction class rather than defining your own.

### Usage Within the XML Framework:

If you are using KAction within the context of the XML menu and toolbar building framework, then there are a few tiny changes. The first is that you must insert your new action into an action collection. The action collection (a KActionCollection) is, logically enough, a central collection of all of the actions defined in your application. The XML UI framework code in KXMLGUI classes needs access to this collection in order to build up the GUI (it's how the builder code knows which actions are valid and which aren't).

Also, if you use the XML builder framework, then you do not ever have to plug your actions into containers manually. The framework does that for you.

See also: KStdAction

KAction ( const QString& text, const KShortcut& cut, const QObject* receiver, const char* slot, KActionCollection* parent, const char* name ) | ### KAction

Constructs an action with text, potential keyboard shortcut, and a SLOT to call when this action is invoked by the user.

If you do not want or have a keyboard shortcut, set the `cut` param to 0.

This is the most common KAction used when you do not have a corresponding icon (note that it won't appear in the current version of the "Edit ToolBar" dialog, because an action needs an icon to be plugged in a toolbar...).

Parameters:

text | The text that will be displayed.
cut | The corresponding keyboard shortcut.
receiver | The SLOT's parent.
slot | The SLOT to invoke to execute this action.
parent | This action's parent.
name | An internal name for this action.

KAction ( const QString& text, const QIconSet& pix, const KShortcut& cut, const QObject* receiver, const char* slot, KActionCollection* parent, const char* name ) | ### KAction

Constructs an action with text, icon, potential keyboard shortcut, and a SLOT to call when this action is invoked by the user.

If you do not want or have a keyboard shortcut, set the `cut` param to 0.

This is the other common KAction used. Use it when you `do` have a corresponding icon.

Parameters:

text | The text that will be displayed.
pix | The icon to display.
cut | The corresponding keyboard shortcut.
receiver | The SLOT's parent.
slot | The SLOT to invoke to execute this action.
parent | This action's parent.
name | An internal name for this action.

KAction ( const QString& text, const QString& pix, const KShortcut& cut, const QObject* receiver, const char* slot, KActionCollection* parent, const char* name ) | ### KAction

Constructs an action with text, icon, potential keyboard shortcut, and a SLOT to call when this action is invoked by the user. The icon is loaded on demand later based on where it is plugged in.

If you do not want or have a keyboard shortcut, set the `cut` param to 0.

This is the other common KAction used. Use it when you `do` have a corresponding icon.

Parameters:

text | The text that will be displayed.
pix | The icon to display.
cut | The corresponding keyboard shortcut (shortcut).
receiver | The SLOT's parent.
slot | The SLOT to invoke to execute this action.
parent | This action's parent.
name | An internal name for this action.

KAction ( const KGuiItem& item, const KShortcut& cut, const QObject* receiver, const char* slot, KActionCollection* parent, const char* name ) | ### KAction

The same as the above constructor, but with a KGuiItem providing the text and icon.

Parameters:

item | The KGuiItem with the label and (optional) icon.

KAction ( const QString& text, const KShortcut& cut = KShortcut(), QObject* parent = 0, const char* name = 0 ) | ### KAction

@obsolete

KAction ( const QString& text, const KShortcut& cut, const QObject* receiver, const char* slot, QObject* parent, const char* name = 0 ) | ### KAction

@obsolete

KAction ( const QString& text, const QIconSet& pix, const KShortcut& cut = KShortcut(), QObject* parent = 0, const char* name = 0 ) | ### KAction

@obsolete

KAction ( const QString& text, const QString& pix, const KShortcut& cut = KShortcut(), QObject* parent = 0, const char* name = 0 ) | ### KAction

@obsolete

KAction ( const QString& text, const QIconSet& pix, const KShortcut& cut, const QObject* receiver, const char* slot, QObject* parent, const char* name = 0 ) | ### KAction

@obsolete

KAction ( const QString& text, const QString& pix, const KShortcut& cut, const QObject* receiver, const char* slot, QObject* parent, const char* name = 0 ) | ### KAction

@obsolete

KAction ( QObject* parent = 0, const char* name = 0 ) | ### KAction

@obsolete

~KAction () | ### ~KAction

[virtual]

Standard destructor

int plug ( QWidget *w, int index = -1 ) | ### plug

[virtual]

"Plug" or insert this action into a given widget.

This will typically be a menu or a toolbar. From this point on, you will never need to directly manipulate the item in the menu or toolbar. You do all enabling/disabling/manipulation directly with your KAction object.

Parameters:

w | The GUI element to display this action

void plugAccel (KAccel *accel, bool configurable = true) | ### plugAccel

[virtual]

"Plug" or insert this action into a given KAccel.

Parameters:

accel | The KAccel collection which holds this accel
configurable | If the shortcut is configurable via the KAccel configuration dialog (this is somehow deprecated since there is now a KAction key configuration dialog).

void unplug ( QWidget *w ) | ### unplug

[virtual]

"Unplug" or remove this action from a given widget.

This will typically be a menu or a toolbar. This is rarely used in "normal" application. Typically, it would be used if your application has several views or modes, each with a completely different menu structure. If you simply want to disable an action for a given period, use setEnabled() instead.

Parameters:

w | Remove the action from this GUI element.

void unplugAccel () | ### unplugAccel

[virtual]

Disconnect this action from the KAccel.

bool isPlugged () | ### isPlugged

[const virtual]

returns whether the action is plugged into any container widget or not.

bool isPlugged ( const QWidget *container ) | ### isPlugged

[const]

returns whether the action is plugged into the given container

bool isPlugged ( const QWidget *container, int id ) | ### isPlugged

[const virtual]

returns whether the action is plugged into the given container with the given, container specific, id (often menu or toolbar id ) .

bool isPlugged ( const QWidget *container, const QWidget *_representative ) | ### isPlugged

[const virtual]

returns whether the action is plugged into the given container with the given, container specific, representative container widget item.

QWidget* container ( int index ) | ### container

[const]

int itemId ( int index ) | ### itemId

[const]

QWidget* representative ( int index ) | ### representative

[const]

int containerCount () | ### containerCount

[const]

uint kaccelCount () | ### kaccelCount

[const]

bool hasIcon () | ### hasIcon

[const virtual]

bool hasIconSet () | ### hasIconSet

[const]

QString plainText () | ### plainText

[const virtual]

QString text () | ### text

[const virtual]

Get the text associated with this action.

const KShortcut& shortcut () | ### shortcut

[const virtual]

Get the keyboard shortcut associated with this action.

const KShortcut& shortcutDefault () | ### shortcutDefault

[const virtual]

Get the default shortcut for this action.

QString shortcutText () | ### shortcutText

[const]

void setShortcutText ( const QString& ) | ### setShortcutText

bool isEnabled () | ### isEnabled

[const virtual]

Returns true if this action is enabled.

bool isShortcutConfigurable () | ### isShortcutConfigurable

[const virtual]

Returns true if this action's shortcut is configurable.

QString group () | ### group

[const virtual]

QString whatsThis () | ### whatsThis

[const virtual]

Get the What's this text for the action.

QString toolTip () | ### toolTip

[const virtual]

Get the tooltip text for the action.

QIconSet iconSet ( KIcon::Group group, int size=0 ) | ### iconSet

[const virtual]

Get the QIconSet from which the icons used to display this action will be chosen.

QIconSet iconSet () | ### iconSet

[const]

QString icon () | ### icon

[const virtual]

KActionCollection * parentCollection () | ### parentCollection

[const]

int getToolButtonID () | ### getToolButtonID

[static]

Generate a toolbar button id. Made public for reimplementations.

void unplugAll () | ### unplugAll

void setText (const QString &text) | ### setText

[virtual slot]

Sets the text associated with this action. The text is used for menu and toolbar labels etc.

bool setShortcut ( const KShortcut& ) | ### setShortcut

[virtual slot]

Sets the keyboard shortcut associated with this action.

void setGroup ( const QString& ) | ### setGroup

[virtual slot]

void setWhatsThis ( const QString& text ) | ### setWhatsThis

[virtual slot]

Sets the What's this text for the action. This text will be displayed when a widget that has been created by plugging this action into a container is clicked on in What's this mode.

The What's this text can include QML markup as well as raw text.

void setToolTip ( const QString& ) | ### setToolTip

[virtual slot]

Sets the tooltip text for the action. This will be used as a tooltip for a toolbar button, as a statusbar help-text for a menu item, and it also appears in the toolbar editor, to describe the action.

void setIconSet ( const QIconSet &iconSet ) | ### setIconSet

[virtual slot]

Sets the QIconSet from which the icons used to display this action will be chosen.

void setIcon ( const QString& icon ) | ### setIcon

[virtual slot]

void setEnabled (bool enable) | ### setEnabled

[virtual slot]

Enables or disables this action. All uses of this action (eg. in menus or toolbars) will be updated to reflect the state of the action.

void setShortcutConfigurable ( bool ) | ### setShortcutConfigurable

[virtual slot]

Indicate whether the user may configure the action's shortcut.

void activate () | ### activate

[virtual slot]

Emulate user's interaction programmatically, by activating the action. The implementation simply emits activated().

void slotDestroyed () | ### slotDestroyed

[protected slots virtual slot]

void slotKeycodeChanged () | ### slotKeycodeChanged

[protected slots virtual slot]

void slotActivated () | ### slotActivated

[protected slots virtual slot]

KToolBar* toolBar ( int index ) | ### toolBar

[protected const]

QPopupMenu* popupMenu ( int index ) | ### popupMenu

[protected const]

void removeContainer ( int index ) | ### removeContainer

[protected]

int findContainer ( const QWidget* widget ) | ### findContainer

[protected const]

void plugMainWindowAccel ( QWidget *w ) | ### plugMainWindowAccel

[protected]

void addContainer ( QWidget* parent, int id ) | ### addContainer

[protected]

void addContainer ( QWidget* parent, QWidget* representative ) | ### addContainer

[protected]

void updateShortcut ( int i ) | ### updateShortcut

[protected virtual]

void updateShortcut ( QPopupMenu* menu, int id ) | ### updateShortcut

[protected virtual]

void updateGroup ( int id ) | ### updateGroup

[protected virtual]

void updateText (int i ) | ### updateText

[protected virtual]

void updateEnabled (int i) | ### updateEnabled

[protected virtual]

void updateIconSet (int i) | ### updateIconSet

[protected virtual]

void updateIcon ( int i) | ### updateIcon

[protected virtual]

void updateToolTip ( int id ) | ### updateToolTip

[protected virtual]

void updateWhatsThis ( int i ) | ### updateWhatsThis

[protected virtual]

KActionCollection * m_parentCollection | ### m_parentCollection

[protected]

QString whatsThisWithIcon () | ### whatsThisWithIcon

[protected const]

void activated () | ### activated

[signal]

void enabled ( bool ) | ### enabled

[signal]

int accel () | ### accel

[const]

Get the keyboard accelerator associated with this action.

QString statusText () | ### statusText

[const]

void setAccel ( int key ) | ### setAccel

Sets the keyboard accelerator associated with this action.

void setStatusText ( const QString &text ) | ### setStatusText

int menuId ( int i ) | ### menuId

void virtual_hook ( int id, void* data ) | ### virtual_hook

[protected virtual]

Generated by: root on macppc.ports.openbsd.org on Sat Sep 6 10:36:37 2003, using kdoc 2.0a54.