summaryrefslogtreecommitdiffabout
path: root/microkde/kdeui/kactionclasses.h
Unidiff
Diffstat (limited to 'microkde/kdeui/kactionclasses.h') (more/less context) (ignore whitespace changes)
-rw-r--r--microkde/kdeui/kactionclasses.h1223
1 files changed, 1223 insertions, 0 deletions
diff --git a/microkde/kdeui/kactionclasses.h b/microkde/kdeui/kactionclasses.h
new file mode 100644
index 0000000..f6e7a0f
--- a/dev/null
+++ b/microkde/kdeui/kactionclasses.h
@@ -0,0 +1,1223 @@
1/* This file is part of the KDE libraries
2 Copyright (C) 1999 Reginald Stadlbauer <reggie@kde.org>
3 (C) 1999 Simon Hausmann <hausmann@kde.org>
4 (C) 2000 Nicolas Hadacek <haadcek@kde.org>
5 (C) 2000 Kurt Granroth <granroth@kde.org>
6 (C) 2000 Michael Koch <koch@kde.org>
7 (C) 2001 Holger Freyther <freyther@kde.org>
8 (C) 2002 Ellis Whitehead <ellis@kde.org>
9
10 This library is free software; you can redistribute it and/or
11 modify it under the terms of the GNU Library General Public
12 License version 2 as published by the Free Software Foundation.
13
14 This library is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 Library General Public License for more details.
18
19 You should have received a copy of the GNU Library General Public License
20 along with this library; see the file COPYING.LIB. If not, write to
21 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
22 Boston, MA 02111-1307, USA.
23*/
24//$Id$
25
26#ifndef __kactionclasses_h__
27#define __kactionclasses_h__
28
29#include <kaction.h>
30
31//US#include <qkeysequence.h>
32//US#include <qobject.h>
33//US#include <qvaluelist.h>
34//US#include <qguardedptr.h>
35//US#include <kguiitem.h>
36#include <kshortcut.h>
37//US#include <kstdaction.h>
38//US#include <kicontheme.h>
39
40class QMenuBar;
41class QPopupMenu;
42//USclass QComboBox;
43//USclass QPoint;
44//USclass QIconSet;
45//USclass QString;
46//USclass KToolBar;
47
48//USclass KAccel;
49//USclass KAccelActions;
50class KConfig;
51//USclass KConfigBase;
52class KURL;
53//USclass KInstance;
54
55
56//US class KToolBar needs to be replaced
57class KToolBar;
58class KActionCollection;
59
60//US class KPopupMenu needs to be replaced
61//US class KPopupMenu;
62//USclass KMainWindow;
63
64/**
65 * Checkbox like action.
66 *
67 * This action provides two states: checked or not.
68 *
69 * @short Checkbox like action.
70 */
71class KToggleAction : public KAction
72{
73 Q_OBJECT
74 Q_PROPERTY( bool checked READ isChecked WRITE setChecked )
75 Q_PROPERTY( QString exclusiveGroup READ exclusiveGroup WRITE setExclusiveGroup )
76public:
77
78 /**
79 * Constructs a toggle action with text and potential keyboard
80 * accelerator but nothing else. Use this only if you really
81 * know what you are doing.
82 *
83 * @param text The text that will be displayed.
84 * @param cut The corresponding keyboard accelerator (shortcut).
85 * @param parent This action's parent.
86 * @param name An internal name for this action.
87 */
88 KToggleAction( const QString& text, const KShortcut& cut = KShortcut(), QObject* parent = 0, const char* name = 0 );
89
90 /**
91 * @param text The text that will be displayed.
92 * @param cut The corresponding keyboard accelerator (shortcut).
93 * @param receiver The SLOT's parent.
94 * @param slot The SLOT to invoke to execute this action.
95 * @param parent This action's parent.
96 * @param name An internal name for this action.
97 */
98 KToggleAction( const QString& text, const KShortcut& cut,
99 const QObject* receiver, const char* slot, QObject* parent, const char* name = 0 );
100
101 /**
102 * @param text The text that will be displayed.
103 * @param pix The icons that go with this action.
104 * @param cut The corresponding keyboard accelerator (shortcut).
105 * @param parent This action's parent.
106 * @param name An internal name for this action.
107 */
108 KToggleAction( const QString& text, const QIconSet& pix, const KShortcut& cut = KShortcut(),
109 QObject* parent = 0, const char* name = 0 );
110
111 /**
112 * @param text The text that will be displayed.
113 * @param pix The dynamically loaded icon that goes with this action.
114 * @param cut The corresponding keyboard accelerator (shortcut).
115 * @param parent This action's parent.
116 * @param name An internal name for this action.
117 */
118 KToggleAction( const QString& text, const QString& pix, const KShortcut& cut = KShortcut(),
119 QObject* parent = 0, const char* name = 0 );
120
121 /**
122 * @param text The text that will be displayed.
123 * @param pix The icons that go with this action.
124 * @param cut The corresponding keyboard accelerator (shortcut).
125 * @param receiver The SLOT's parent.
126 * @param slot The SLOT to invoke to execute this action.
127 * @param parent This action's parent.
128 * @param name An internal name for this action.
129 */
130 KToggleAction( const QString& text, const QIconSet& pix, const KShortcut& cut,
131 const QObject* receiver, const char* slot, QObject* parent, const char* name = 0 );
132
133 /**
134 * @param text The text that will be displayed.
135 * @param pix The dynamically loaded icon that goes with this action.
136 * @param cut The corresponding keyboard accelerator (shortcut).
137 * @param receiver The SLOT's parent.
138 * @param slot The SLOT to invoke to execute this action.
139 * @param parent This action's parent.
140 * @param name An internal name for this action.
141 */
142 KToggleAction( const QString& text, const QString& pix, const KShortcut& cut,
143 const QObject* receiver, const char* slot,
144 QObject* parent, const char* name = 0 );
145
146 /**
147 * @param parent This action's parent.
148 * @param name An internal name for this action.
149 */
150 KToggleAction( QObject* parent = 0, const char* name = 0 );
151
152 /**
153 * Destructor
154 */
155 virtual ~KToggleAction();
156
157 /**
158 * "Plug" or insert this action into a given widget.
159 *
160 * This will typically be a menu or a toolbar. From this point
161 * on, you will never need to directly manipulate the item in the
162 * menu or toolbar. You do all enabling/disabling/manipulation
163 * directly with your KToggleAction object.
164 *
165 * @param widget The GUI element to display this action.
166 * @param index The index of the item.
167 */
168 virtual int plug( QWidget* widget, int index = -1 );
169
170 /**
171 * Returns the actual state of the action.
172 */
173 bool isChecked() const;
174
175 /**
176 * @return which "exclusive group" this action is part of.
177 * @see setExclusiveGroup
178 */
179 QString exclusiveGroup() const;
180
181 /**
182 * Defines which "exclusive group" this action is part of.
183 * In a given exclusive group, only one toggle action can be checked
184 * at a any moment. Checking an action unchecks the other actions
185 * of the group.
186 */
187 virtual void setExclusiveGroup( const QString& name );
188
189public slots:
190 /**
191 * Sets the state of the action.
192 */
193 virtual void setChecked( bool );
194
195protected slots:
196 virtual void slotActivated();
197
198protected:
199 virtual void updateChecked( int id );
200
201signals:
202 void toggled( bool );
203
204protected:
205 virtual void virtual_hook( int id, void* data );
206private:
207 class KToggleActionPrivate;
208 KToggleActionPrivate *d;
209};
210
211/**
212 * An action that operates like a radio button. At any given time
213 * only a single action from the group will be active.
214 */
215class KRadioAction : public KToggleAction
216{
217 Q_OBJECT
218public:
219 /**
220 * Constructs a radio action with text and potential keyboard
221 * accelerator but nothing else. Use this only if you really
222 * know what you are doing.
223 *
224 * @param text The text that will be displayed.
225 * @param cut The corresponding keyboard accelerator (shortcut).
226 * @param parent This action's parent.
227 * @param name An internal name for this action.
228 */
229 KRadioAction( const QString& text, const KShortcut& cut = KShortcut(), QObject* parent = 0, const char* name = 0 );
230
231 /**
232 * @param text The text that will be displayed.
233 * @param cut The corresponding keyboard accelerator (shortcut).
234 * @param receiver The SLOT's parent.
235 * @param slot The SLOT to invoke to execute this action.
236 * @param parent This action's parent.
237 * @param name An internal name for this action.
238 */
239 KRadioAction( const QString& text, const KShortcut& cut,
240 const QObject* receiver, const char* slot, QObject* parent, const char* name = 0 );
241
242 /**
243 * @param text The text that will be displayed.
244 * @param pix The icons that go with this action.
245 * @param cut The corresponding keyboard accelerator (shortcut).
246 * @param parent This action's parent.
247 * @param name An internal name for this action.
248 */
249 KRadioAction( const QString& text, const QIconSet& pix, const KShortcut& cut = KShortcut(),
250 QObject* parent = 0, const char* name = 0 );
251
252 /**
253 * @param text The text that will be displayed.
254 * @param pix The dynamically loaded icon that goes with this action.
255 * @param cut The corresponding keyboard accelerator (shortcut).
256 * @param parent This action's parent.
257 * @param name An internal name for this action.
258 */
259 KRadioAction( const QString& text, const QString& pix, const KShortcut& cut = KShortcut(),
260 QObject* parent = 0, const char* name = 0 );
261
262 /**
263 * @param text The text that will be displayed.
264 * @param pix The icons that go with this action.
265 * @param cut The corresponding keyboard accelerator (shortcut).
266 * @param receiver The SLOT's parent.
267 * @param slot The SLOT to invoke to execute this action.
268 * @param parent This action's parent.
269 * @param name An internal name for this action.
270 */
271 KRadioAction( const QString& text, const QIconSet& pix, const KShortcut& cut,
272 const QObject* receiver, const char* slot, QObject* parent, const char* name = 0 );
273
274 /**
275 * @param text The text that will be displayed.
276 * @param pix The dynamically loaded icon that goes with this action.
277 * @param cut The corresponding keyboard accelerator (shortcut).
278 * @param receiver The SLOT's parent.
279 * @param slot The SLOT to invoke to execute this action.
280 * @param parent This action's parent.
281 * @param name An internal name for this action.
282 */
283 KRadioAction( const QString& text, const QString& pix, const KShortcut& cut,
284 const QObject* receiver, const char* slot,
285 QObject* parent, const char* name = 0 );
286
287 /**
288 * @param parent This action's parent.
289 * @param name An internal name for this action.
290 */
291 KRadioAction( QObject* parent = 0, const char* name = 0 );
292
293protected:
294 virtual void slotActivated();
295
296protected:
297 virtual void virtual_hook( int id, void* data );
298private:
299 class KRadioActionPrivate;
300 KRadioActionPrivate *d;
301};
302
303/**
304 * Action for selecting one of several items.
305 *
306 * This action shows up a submenu with a list of items.
307 * One of them can be checked. If the user clicks on an item
308 * this item will automatically be checked,
309 * the formerly checked item becomes unchecked.
310 * There can be only one item checked at a time.
311 *
312 * @short Action for selecting one of several items
313 */
314class KSelectAction : public KAction
315{
316 Q_OBJECT
317 Q_PROPERTY( int currentItem READ currentItem WRITE setCurrentItem )
318 Q_PROPERTY( QStringList items READ items WRITE setItems )
319 Q_PROPERTY( bool editable READ isEditable WRITE setEditable )
320 Q_PROPERTY( int comboWidth READ comboWidth WRITE setComboWidth )
321 Q_PROPERTY( QString currentText READ currentText )
322 Q_PROPERTY( bool menuAccelsEnabled READ menuAccelsEnabled WRITE setMenuAccelsEnabled )
323public:
324
325 /**
326 * Constructs a select action with text and potential keyboard
327 * accelerator but nothing else. Use this only if you really
328 * know what you are doing.
329 *
330 * @param text The text that will be displayed.
331 * @param cut The corresponding keyboard accelerator (shortcut).
332 * @param parent This action's parent.
333 * @param name An internal name for this action.
334 */
335 KSelectAction( const QString& text, const KShortcut& cut = KShortcut(), QObject* parent = 0, const char* name = 0 );
336
337 /**
338 * @param text The text that will be displayed.
339 * @param cut The corresponding keyboard accelerator (shortcut).
340 * @param receiver The SLOT's parent.
341 * @param slot The SLOT to invoke to execute this action.
342 * @param parent This action's parent.
343 * @param name An internal name for this action.
344 */
345 KSelectAction( const QString& text, const KShortcut& cut,
346 const QObject* receiver, const char* slot, QObject* parent, const char* name = 0 );
347
348 /**
349 * @param text The text that will be displayed.
350 * @param pix The icons that go with this action.
351 * @param cut The corresponding keyboard accelerator (shortcut).
352 * @param parent This action's parent.
353 * @param name An internal name for this action.
354 */
355 KSelectAction( const QString& text, const QIconSet& pix, const KShortcut& cut = KShortcut(),
356 QObject* parent = 0, const char* name = 0 );
357
358 /**
359 * @param text The text that will be displayed.
360 * @param pix The dynamically loaded icon that goes with this action.
361 * @param cut The corresponding keyboard accelerator (shortcut).
362 * @param parent This action's parent.
363 * @param name An internal name for this action.
364 */
365 KSelectAction( const QString& text, const QString& pix, const KShortcut& cut = KShortcut(),
366 QObject* parent = 0, const char* name = 0 );
367
368 /**
369 * @param text The text that will be displayed.
370 * @param pix The icons that go with this action.
371 * @param cut The corresponding keyboard accelerator (shortcut).
372 * @param receiver The SLOT's parent.
373 * @param slot The SLOT to invoke to execute this action.
374 * @param parent This action's parent.
375 * @param name An internal name for this action.
376 */
377 KSelectAction( const QString& text, const QIconSet& pix, const KShortcut& cut,
378 const QObject* receiver, const char* slot, QObject* parent, const char* name = 0 );
379
380 /**
381 * @param text The text that will be displayed.
382 * @param pix The dynamically loaded icon that goes with this action.
383 * @param cut The corresponding keyboard accelerator (shortcut).
384 * @param receiver The SLOT's parent.
385 * @param slot The SLOT to invoke to execute this action.
386 * @param parent This action's parent.
387 * @param name An internal name for this action.
388 */
389 KSelectAction( const QString& text, const QString& pix, const KShortcut& cut,
390 const QObject* receiver, const char* slot,
391 QObject* parent, const char* name = 0 );
392
393 /**
394 * @param parent This action's parent.
395 * @param name An internal name for this action.
396 */
397 KSelectAction( QObject* parent = 0, const char* name = 0 );
398
399 /**
400 * Destructor
401 */
402 virtual ~KSelectAction();
403
404 /**
405 * "Plug" or insert this action into a given widget.
406 *
407 * This will typically be a menu or a toolbar.
408 * From this point on, you will never need to directly
409 * manipulate the item in the menu or toolbar.
410 * You do all enabling/disabling/manipulation directly with your KSelectAction object.
411 *
412 * @param widget The GUI element to display this action.
413 * @param index The index of the item.
414 */
415 virtual int plug( QWidget* widget, int index = -1 );
416
417 /**
418 * When this action is plugged into a toolbar, it creates a combobox.
419 * @return true if the combo editable.
420 */
421 virtual bool isEditable() const;
422
423 /**
424 * @return the items that can be selected with this action.
425 * Use setItems to set them.
426 */
427 virtual QStringList items() const;
428
429 virtual void changeItem( int index, const QString& text );
430
431 virtual QString currentText() const;
432
433 virtual int currentItem() const;
434
435 /**
436 * When this action is plugged into a toolbar, it creates a combobox.
437 * This returns the maximum width set by setComboWidth
438 */
439 virtual int comboWidth() const;
440
441 QPopupMenu* popupMenu() const;
442
443 /**
444 * Deprecated. See @ref setMenuAccelsEnabled .
445 * @since 3.1
446 */
447 void setRemoveAmpersandsInCombo( bool b );
448 /// @since 3.1
449 bool removeAmpersandsInCombo() const;
450
451 /**
452 * Sets whether any occurence of the ampersand character ( &amp; ) in items
453 * should be interpreted as keyboard accelerator for items displayed in a
454 * menu or not.
455 * @since 3.1
456 */
457 void setMenuAccelsEnabled( bool b );
458 /// @since 3.1
459 bool menuAccelsEnabled() const;
460
461public slots:
462 /**
463 * Sets the currently checked item.
464 *
465 * @param index Index of the item (remember the first item is zero).
466 */
467 virtual void setCurrentItem( int index );
468
469 /**
470 * Sets the items to be displayed in this action
471 * You need to call this.
472 */
473 virtual void setItems( const QStringList &lst );
474
475 /**
476 * Clears up all the items in this action
477 */
478 virtual void clear();
479
480 /**
481 * When this action is plugged into a toolbar, it creates a combobox.
482 * This makes the combo editable or read-only.
483 */
484 virtual void setEditable( bool );
485
486 /**
487 * When this action is plugged into a toolbar, it creates a combobox.
488 * This gives a _maximum_ size to the combobox.
489 * The minimum size is automatically given by the contents (the items).
490 */
491 virtual void setComboWidth( int width );
492
493protected:
494 virtual void changeItem( int id, int index, const QString& text );
495
496 /**
497 * Depending on the menuAccelsEnabled property this method will return the
498 * actions items in a way for inclusion in a combobox with the ampersand
499 * character removed from all items or not.
500 * @since 3.1
501 */
502 QStringList comboItems() const;
503
504protected slots:
505 virtual void slotActivated( int id );
506 virtual void slotActivated( const QString &text );
507 virtual void slotActivated();
508
509signals:
510 void activated( int index );
511 void activated( const QString& text );
512
513protected:
514 virtual void updateCurrentItem( int id );
515
516 virtual void updateComboWidth( int id );
517
518 virtual void updateItems( int id );
519
520 virtual void updateClear( int id );
521
522protected:
523 virtual void virtual_hook( int id, void* data );
524private:
525 void setupMenu() const;
526 class KSelectActionPrivate;
527 KSelectActionPrivate *d;
528
529};
530
531/// Remove this class in KDE-4.0. It doesn't add _anything_ to KSelectAction
532/**
533 * @deprecated Use KSelectAction instead.
534 */
535class KListAction : public KSelectAction
536{
537 Q_OBJECT
538public:
539 /**
540 * Constructs a list action with text and potential keyboard
541 * accelerator but nothing else. Use this only if you really
542 * know what you are doing.
543 *
544 * @param text The text that will be displayed.
545 * @param cut The corresponding keyboard accelerator (shortcut).
546 * @param parent This action's parent.
547 * @param name An internal name for this action.
548 */
549 KListAction( const QString& text, const KShortcut& cut = KShortcut(), QObject* parent = 0,
550 const char* name = 0 );
551
552 /**
553 * @param text The text that will be displayed.
554 * @param cut The corresponding keyboard accelerator (shortcut).
555 * @param receiver The SLOT's parent.
556 * @param slot The SLOT to invoke to execute this action.
557 * @param parent This action's parent.
558 * @param name An internal name for this action.
559 */
560 KListAction( const QString& text, const KShortcut& cut, const QObject* receiver,
561 const char* slot, QObject* parent, const char* name = 0 );
562
563 /**
564 * @param text The text that will be displayed.
565 * @param pix The icons that go with this action.
566 * @param cut The corresponding keyboard accelerator (shortcut).
567 * @param parent This action's parent.
568 * @param name An internal name for this action.
569 */
570 KListAction( const QString& text, const QIconSet& pix, const KShortcut& cut = KShortcut(),
571 QObject* parent = 0, const char* name = 0 );
572
573 /**
574 * @param text The text that will be displayed.
575 * @param pix The dynamically loaded icon that goes with this action.
576 * @param cut The corresponding keyboard accelerator (shortcut).
577 * @param parent This action's parent.
578 * @param name An internal name for this action.
579 */
580 KListAction( const QString& text, const QString& pix, const KShortcut& cut = KShortcut(),
581 QObject* parent = 0, const char* name = 0 );
582
583 /**
584 * @param text The text that will be displayed.
585 * @param pix The icons that go with this action.
586 * @param cut The corresponding keyboard accelerator (shortcut).
587 * @param receiver The SLOT's parent.
588 * @param slot The SLOT to invoke to execute this action.
589 * @param parent This action's parent.
590 * @param name An internal name for this action.
591 */
592 KListAction( const QString& text, const QIconSet& pix, const KShortcut& cut,
593 const QObject* receiver, const char* slot, QObject* parent,
594 const char* name = 0 );
595
596 /**
597 * @param text The text that will be displayed.
598 * @param pix The dynamically loaded icon that goes with this action.
599 * @param cut The corresponding keyboard accelerator (shortcut).
600 * @param receiver The SLOT's parent.
601 * @param slot The SLOT to invoke to execute this action.
602 * @param parent This action's parent.
603 * @param name An internal name for this action.
604 */
605 KListAction( const QString& text, const QString& pix, const KShortcut& cut,
606 const QObject* receiver, const char* slot, QObject* parent,
607 const char* name = 0 );
608
609 /**
610 * @param parent This action's parent.
611 * @param name An internal name for this action.
612 */
613 KListAction( QObject* parent = 0, const char* name = 0 );
614
615 /**
616 * Destructor
617 */
618 virtual ~KListAction();
619
620
621 virtual QString currentText() const;
622 virtual int currentItem() const;
623
624
625public slots:
626 /**
627 * Sets the currently checked item.
628 *
629 * @param index Index of the item (remember the first item is zero).
630 */
631 virtual void setCurrentItem( int index );
632
633protected:
634 virtual void virtual_hook( int id, void* data );
635private:
636 class KListActionPrivate;
637 KListActionPrivate *d;
638};
639
640/**
641 * This class is an action to handle a recent files submenu.
642 * The best way to create the action is to use KStdAction::openRecent.
643 * Then you simply need to call @ref loadEntries on startup, @ref saveEntries
644 * on shutdown, @ref addURL when your application loads/saves a file.
645 *
646 * @author Michael Koch
647 * @short Recent files action
648 */
649class KRecentFilesAction : public KListAction // TODO public KSelectAction
650{
651 Q_OBJECT
652 Q_PROPERTY( uint maxItems READ maxItems WRITE setMaxItems )
653public:
654 /**
655 * @param text The text that will be displayed.
656 * @param cut The corresponding keyboard accelerator (shortcut).
657 * @param parent This action's parent.
658 * @param name An internal name for this action.
659 * @param maxItems The maximum number of files to display
660 */
661 KRecentFilesAction( const QString& text, const KShortcut& cut,
662 QObject* parent, const char* name = 0,
663 uint maxItems = 10 );
664
665 /**
666 * @param text The text that will be displayed.
667 * @param cut The corresponding keyboard accelerator (shortcut).
668 * @param receiver The SLOT's parent.
669 * @param slot The SLOT to invoke when a URL is selected.
670 * Its signature is of the form slotURLSelected( const KURL & ).
671 * @param parent This action's parent.
672 * @param name An internal name for this action.
673 * @param maxItems The maximum number of files to display
674 */
675 KRecentFilesAction( const QString& text, const KShortcut& cut,
676 const QObject* receiver, const char* slot,
677 QObject* parent, const char* name = 0,
678 uint maxItems = 10 );
679
680 /**
681 * @param text The text that will be displayed.
682 * @param pix The icons that go with this action.
683 * @param cut The corresponding keyboard accelerator (shortcut).
684 * @param parent This action's parent.
685 * @param name An internal name for this action.
686 * @param maxItems The maximum number of files to display
687 */
688 KRecentFilesAction( const QString& text, const QIconSet& pix, const KShortcut& cut,
689 QObject* parent, const char* name = 0,
690 uint maxItems = 10 );
691
692 /**
693 * @param text The text that will be displayed.
694 * @param pix The dynamically loaded icon that goes with this action.
695 * @param cut The corresponding keyboard accelerator (shortcut).
696 * @param parent This action's parent.
697 * @param name An internal name for this action.
698 * @param maxItems The maximum number of files to display
699 */
700 KRecentFilesAction( const QString& text, const QString& pix, const KShortcut& cut,
701 QObject* parent, const char* name = 0,
702 uint maxItems = 10 );
703
704 /**
705 * @param text The text that will be displayed.
706 * @param pix The icons that go with this action.
707 * @param cut The corresponding keyboard accelerator (shortcut).
708 * @param receiver The SLOT's parent.
709 * @param slot The SLOT to invoke when a URL is selected.
710 * Its signature is of the form slotURLSelected( const KURL & ).
711 * @param parent This action's parent.
712 * @param name An internal name for this action.
713 * @param maxItems The maximum number of files to display
714 */
715 KRecentFilesAction( const QString& text, const QIconSet& pix, const KShortcut& cut,
716 const QObject* receiver, const char* slot,
717 QObject* parent, const char* name = 0,
718 uint maxItems = 10 );
719
720 /**
721 * @param text The text that will be displayed.
722 * @param pix The dynamically loaded icon that goes with this action.
723 * @param cut The corresponding keyboard accelerator (shortcut).
724 * @param receiver The SLOT's parent.
725 * @param slot The SLOT to invoke when a URL is selected.
726 * Its signature is of the form slotURLSelected( const KURL & ).
727 * @param parent This action's parent.
728 * @param name An internal name for this action.
729 * @param maxItems The maximum number of files to display
730 */
731 KRecentFilesAction( const QString& text, const QString& pix, const KShortcut& cut,
732 const QObject* receiver, const char* slot,
733 QObject* parent, const char* name = 0,
734 uint maxItems = 10 );
735
736 /**
737 * @param parent This action's parent.
738 * @param name An internal name for this action.
739 * @param maxItems The maximum number of files to display
740 */
741 KRecentFilesAction( QObject* parent = 0, const char* name = 0,
742 uint maxItems = 10 );
743
744 /**
745 * Destructor.
746 */
747 virtual ~KRecentFilesAction();
748
749 /**
750 * Returns the maximum of items in the recent files list.
751 */
752 uint maxItems() const;
753
754public slots:
755 /**
756 * Sets the maximum of items in the recent files list.
757 * The default for this value is 10 set in the constructor.
758 *
759 * If this value is lesser than the number of items currently
760 * in the recent files list the last items are deleted until
761 * the number of items are equal to the new maximum.
762 */
763 void setMaxItems( uint maxItems );
764
765 /**
766 * Loads the recent files entries from a given KConfig object.
767 * You can provide the name of the group used to load the entries.
768 * If the groupname is empty, entries are load from a group called 'RecentFiles'
769 *
770 * This method does not effect the active group of KConfig.
771 */
772 void loadEntries( KConfig* config, QString groupname=QString::null );
773
774 /**
775 * Saves the current recent files entries to a given KConfig object.
776 * You can provide the name of the group used to load the entries.
777 * If the groupname is empty, entries are saved to a group called 'RecentFiles'
778 *
779 * This method does not effect the active group of KConfig.
780 */
781 void saveEntries( KConfig* config, QString groupname=QString::null );
782
783public slots:
784 /**
785 * Add URL to recent files list.
786 *
787 * @param url The URL of the file
788 */
789 void addURL( const KURL& url );
790
791 /**
792 * Remove an URL from the recent files list.
793 *
794 * @param url The URL of the file
795 */
796 void removeURL( const KURL& url );
797
798 /**
799 * Removes all entries from the recent files list.
800 */
801 void clearURLList();
802
803signals:
804
805 /**
806 * This signal gets emited when the user selects an URL.
807 *
808 * @param url The URL thats the user selected.
809 */
810 void urlSelected( const KURL& url );
811
812protected slots:
813 /**
814 *
815 */
816 void itemSelected( const QString& string );
817
818protected:
819 virtual void virtual_hook( int id, void* data );
820private:
821 void init();
822
823 class KRecentFilesActionPrivate;
824 KRecentFilesActionPrivate *d;
825};
826
827class KFontAction : public KSelectAction
828{
829 Q_OBJECT
830 Q_PROPERTY( QString font READ font WRITE setFont )
831public:
832 KFontAction( const QString& text, const KShortcut& cut = KShortcut(), QObject* parent = 0,
833 const char* name = 0 );
834 KFontAction( const QString& text, const KShortcut& cut,
835 const QObject* receiver, const char* slot, QObject* parent,
836 const char* name = 0 );
837 KFontAction( const QString& text, const QIconSet& pix, const KShortcut& cut = KShortcut(),
838 QObject* parent = 0, const char* name = 0 );
839 KFontAction( const QString& text, const QString& pix, const KShortcut& cut = KShortcut(),
840 QObject* parent = 0, const char* name = 0 );
841 KFontAction( const QString& text, const QIconSet& pix, const KShortcut& cut,
842 const QObject* receiver, const char* slot, QObject* parent,
843 const char* name = 0 );
844 KFontAction( const QString& text, const QString& pix, const KShortcut& cut,
845 const QObject* receiver, const char* slot, QObject* parent,
846 const char* name = 0 );
847
848 KFontAction( QObject* parent = 0, const char* name = 0 );
849 ~KFontAction();
850
851 QString font() const {
852 return currentText();
853 }
854
855 int plug( QWidget*, int index = -1 );
856
857public slots:
858 void setFont( const QString &family );
859
860protected:
861 virtual void virtual_hook( int id, void* data );
862private:
863 class KFontActionPrivate;
864 KFontActionPrivate *d;
865};
866
867class KFontSizeAction : public KSelectAction
868{
869 Q_OBJECT
870 Q_PROPERTY( int fontSize READ fontSize WRITE setFontSize )
871public:
872 KFontSizeAction( const QString& text, const KShortcut& cut = KShortcut(), QObject* parent = 0,
873 const char* name = 0 );
874 KFontSizeAction( const QString& text, const KShortcut& cut, const QObject* receiver,
875 const char* slot, QObject* parent, const char* name = 0 );
876 KFontSizeAction( const QString& text, const QIconSet& pix, const KShortcut& cut = KShortcut(),
877 QObject* parent = 0, const char* name = 0 );
878 KFontSizeAction( const QString& text, const QString& pix, const KShortcut& cut = KShortcut(),
879 QObject* parent = 0, const char* name = 0 );
880 KFontSizeAction( const QString& text, const QIconSet& pix, const KShortcut& cut,
881 const QObject* receiver, const char* slot,
882 QObject* parent, const char* name = 0 );
883 KFontSizeAction( const QString& text, const QString& pix, const KShortcut& cut,
884 const QObject* receiver, const char* slot,
885 QObject* parent, const char* name = 0 );
886 KFontSizeAction( QObject* parent = 0, const char* name = 0 );
887
888 virtual ~KFontSizeAction();
889
890 virtual int fontSize() const;
891
892public slots:
893 virtual void setFontSize( int size );
894
895protected slots:
896 virtual void slotActivated( int );
897 virtual void slotActivated( const QString& );
898 virtual void slotActivated() { KAction::slotActivated(); }
899
900signals:
901 void fontSizeChanged( int );
902
903private:
904 void init();
905
906
907protected:
908 virtual void virtual_hook( int id, void* data );
909private:
910 class KFontSizeActionPrivate;
911 KFontSizeActionPrivate *d;
912};
913
914
915/**
916 * A KActionMenu is an action that holds a sub-menu of other actions.
917 * insert() and remove() allow to insert and remove actions into this action-menu.
918 * Plugged in a popupmenu, it will create a submenu.
919 * Plugged in a toolbar, it will create a button with a popup menu.
920 *
921 * This is the action used by the XMLGUI since it holds other actions.
922 * If you want a submenu for selecting one tool among many (without icons), see KSelectAction.
923 * See also setDelayed about the main action.
924 */
925class KActionMenu : public KAction
926{
927 Q_OBJECT
928 Q_PROPERTY( bool delayed READ delayed WRITE setDelayed )
929 Q_PROPERTY( bool stickyMenu READ stickyMenu WRITE setStickyMenu )
930
931public:
932 KActionMenu( const QString& text, QObject* parent = 0,
933 const char* name = 0 );
934 KActionMenu( const QString& text, const QIconSet& icon,
935 QObject* parent = 0, const char* name = 0 );
936 KActionMenu( const QString& text, const QString& icon,
937 QObject* parent = 0, const char* name = 0 );
938 KActionMenu( QObject* parent = 0, const char* name = 0 );
939 virtual ~KActionMenu();
940
941 virtual void insert( KAction*, int index = -1 );
942 virtual void remove( KAction* );
943
944//US KPopupMenu* popupMenu() const;
945 QPopupMenu* popupMenu() const;
946 void popup( const QPoint& global );
947
948 /**
949 * Returns true if this action creates a delayed popup menu
950 * when plugged in a KToolbar.
951 */
952 bool delayed() const;
953 /**
954 * If set to true, this action will create a delayed popup menu
955 * when plugged in a KToolbar. Otherwise it creates a normal popup.
956 * Default: delayed
957 *
958 * Remember that if the "main" action (the toolbar button itself)
959 * cannot be clicked, then you should call setDelayed(false).
960 *
961 * On the opposite, if the main action can be clicked, it can only happen
962 * in a toolbar: in a menu, the parent of a submenu can't be activated.
963 * To get a "normal" menu item when plugged a menu (and no submenu)
964 * use KToolBarPopupAction.
965 */
966 void setDelayed(bool _delayed);
967
968 /**
969 * Returns true if this action creates a sticky popup menu.
970 * See @ref setStickyMenu.
971 */
972 bool stickyMenu() const;
973 /**
974 * If set to true, this action will create a sticky popup menu
975 * when plugged in a KToolbar.
976 * "Sticky", means it's visible until a selection is made or the mouse is
977 * clicked elsewhere. This feature allows you to make a selection without
978 * having to press and hold down the mouse while making a selection.
979 * Default: sticky.
980 */
981 void setStickyMenu(bool sticky);
982
983 virtual int plug( QWidget* widget, int index = -1 );
984
985protected:
986 virtual void virtual_hook( int id, void* data );
987private:
988 class KActionMenuPrivate;
989 KActionMenuPrivate *d;
990};
991
992/**
993 * This action is a normal action everywhere, except in a toolbar
994 * where it also has a popupmenu (optionnally delayed). This action is designed
995 * for history actions (back/forward, undo/redo) and for any other action
996 * that has more detail in a toolbar than in a menu (e.g. tool chooser
997 * with "Other" leading to a dialog...).
998 */
999class KToolBarPopupAction : public KAction
1000{
1001 Q_OBJECT
1002 Q_PROPERTY( bool delayed READ delayed WRITE setDelayed )
1003 Q_PROPERTY( bool stickyMenu READ stickyMenu WRITE setStickyMenu )
1004
1005public:
1006 //Not all constructors - because we need an icon, since this action only makes
1007 // sense when being plugged at least in a toolbar.
1008 /**
1009 * Create a KToolBarPopupAction, with a text, an icon, an optionnal accelerator,
1010 * parent and name.
1011 *
1012 * @param text The text that will be displayed.
1013 * @param icon The icon to display.
1014 * @param cut The corresponding keyboard accelerator (shortcut).
1015 * @param parent This action's parent.
1016 * @param name An internal name for this action.
1017 */
1018 KToolBarPopupAction( const QString& text, const QString& icon, const KShortcut& cut = KShortcut(),
1019 QObject* parent = 0, const char* name = 0 );
1020
1021 /**
1022 * Create a KToolBarPopupAction, with a text, an icon, an accelerator,
1023 * a slot connected to the action, parent and name.
1024 *
1025 * If you do not want or have a keyboard accelerator, set the
1026 * @p cut param to 0.
1027 *
1028 * @param text The text that will be displayed.
1029 * @param icon The icon to display.
1030 * @param cut The corresponding keyboard accelerator (shortcut).
1031 * @param receiver The SLOT's owner.
1032 * @param slot The SLOT to invoke to execute this action.
1033 * @param parent This action's parent.
1034 * @param name An internal name for this action.
1035 */
1036 KToolBarPopupAction( const QString& text, const QString& icon, const KShortcut& cut,
1037 const QObject* receiver, const char* slot,
1038 QObject* parent = 0, const char* name = 0 );
1039
1040 /**
1041 * Create a KToolBarPopupAction, with a KGuiItem, an accelerator,
1042 * a slot connected to the action, parent and name. The text and the
1043 * icon are taken from the KGuiItem.
1044 *
1045 * If you do not want or have a keyboard accelerator, set the
1046 * @p cut param to 0.
1047 *
1048 * @param item The text and icon that will be displayed.
1049 * @param cut The corresponding keyboard accelerator (shortcut).
1050 * @param receiver The SLOT's owner.
1051 * @param slot The SLOT to invoke to execute this action.
1052 * @param parent This action's parent.
1053 * @param name An internal name for this action.
1054 */
1055
1056 KToolBarPopupAction( const KGuiItem& item, const KShortcut& cut,
1057 const QObject* receiver, const char* slot,
1058 KActionCollection* parent, const char* name );
1059
1060 virtual ~KToolBarPopupAction();
1061
1062 virtual int plug( QWidget *widget, int index = -1 );
1063
1064 /**
1065 * The popup menu that is shown when clicking (some time) on the toolbar
1066 * button. You may want to plug items into it on creation, or connect to
1067 * aboutToShow for a more dynamic menu.
1068 */
1069//US KPopupMenu *popupMenu() const;
1070 QPopupMenu *popupMenu() const;
1071
1072 /**
1073 * Returns true if this action creates a delayed popup menu
1074 * when plugged in a KToolbar.
1075 */
1076 bool delayed() const;
1077 /**
1078 * If set to true, this action will create a delayed popup menu
1079 * when plugged in a KToolbar. Otherwise it creates a normal popup.
1080 * Default: delayed.
1081 */
1082 void setDelayed(bool delayed);
1083 /**
1084 * Returns true if this action creates a sticky popup menu.
1085 * See @ref setStickyMenu.
1086 */
1087 bool stickyMenu() const;
1088 /**
1089 * If set to true, this action will create a sticky popup menu
1090 * when plugged in a KToolbar.
1091 * "Sticky", means it's visible until a selection is made or the mouse is
1092 * clicked elsewhere. This feature allows you to make a selection without
1093 * having to press and hold down the mouse while making a selection.
1094 * Only available if delayed() is true.
1095 * Default: sticky.
1096 */
1097 void setStickyMenu(bool sticky);
1098
1099private:
1100//US KPopupMenu *m_popup;
1101 QPopupMenu *m_popup;
1102 bool m_delayed:1;
1103 bool m_stickyMenu:1;
1104protected:
1105 virtual void virtual_hook( int id, void* data );
1106private:
1107 class KToolBarPopupActionPrivate;
1108 KToolBarPopupActionPrivate *d;
1109};
1110
1111/**
1112 * An action that takes care of everything associated with
1113 * showing or hiding a toolbar by a menu action. It will
1114 * show or hide the toolbar with the given name when
1115 * activated, and check or uncheck itself if the toolbar
1116 * is manually shown or hidden.
1117 *
1118 * If you need to perfom some additional action when the
1119 * toolbar is shown or hidden, connect to the toggled(bool)
1120 * signal. It will be emitted after the toolbar's
1121 * visibility has changed, whenever it changes.
1122 * @since 3.1
1123 */
1124class KToggleToolBarAction : public KToggleAction
1125{
1126 Q_OBJECT
1127public:
1128 /**
1129 * Create a KToggleToolbarAction that manages the toolbar
1130 * named toolBarName. This can be either the name of a
1131 * toolbar in an xml ui file, or a toolbar programmatically
1132 * created with that name.
1133 */
1134 KToggleToolBarAction( const char* toolBarName, const QString& text,
1135 KActionCollection* parent, const char* name );
1136 KToggleToolBarAction( KToolBar *toolBar, const QString &text,
1137 KActionCollection *parent, const char *name );
1138 virtual ~KToggleToolBarAction();
1139
1140 virtual int plug( QWidget*, int index = -1 );
1141
1142 KToolBar *toolBar() {
1143 return m_toolBar;
1144 }
1145
1146public slots:
1147 virtual void setChecked( bool );
1148
1149private:
1150 QCString m_toolBarName;
1151 QGuardedPtr<KToolBar> m_toolBar;
1152protected:
1153 virtual void virtual_hook( int id, void* data );
1154private:
1155 class KToggleToolBarActionPrivate;
1156 KToggleToolBarActionPrivate *d;
1157};
1158
1159/**
1160 * An action that automatically embeds a widget into a
1161 * toolbar.
1162 */
1163class KWidgetAction : public KAction
1164{
1165 Q_OBJECT
1166public:
1167 /**
1168 * Create an action that will embed widget into a toolbar
1169 * when plugged. This action may only be plugged into
1170 * a toolbar.
1171 */
1172 KWidgetAction( QWidget* widget, const QString& text,
1173 const KShortcut& cut,
1174 const QObject* receiver, const char* slot,
1175 KActionCollection* parent, const char* name );
1176 virtual ~KWidgetAction();
1177
1178 /**
1179 * Returns the widget associated with this action.
1180 */
1181 QWidget* widget() { return m_widget; }
1182
1183 void setAutoSized( bool );
1184
1185 /**
1186 * Plug the action. The widget passed to the constructor
1187 * will be reparented to w, which must inherit KToolBar.
1188 */
1189 virtual int plug( QWidget* w, int index = -1 );
1190 /**
1191 * Unplug the action. Ensures that the action is not
1192 * destroyed. It will be hidden and reparented to 0L instead.
1193 */
1194 virtual void unplug( QWidget *w );
1195protected slots:
1196 void slotToolbarDestroyed();
1197private:
1198 QGuardedPtr<QWidget> m_widget;
1199 bool m_autoSized;
1200protected:
1201 virtual void virtual_hook( int id, void* data );
1202private:
1203 class KWidgetActionPrivate;
1204 KWidgetActionPrivate *d;
1205};
1206
1207class KActionSeparator : public KAction
1208{
1209 Q_OBJECT
1210public:
1211 KActionSeparator( QObject* parent = 0, const char* name = 0 );
1212 virtual ~KActionSeparator();
1213
1214 virtual int plug( QWidget*, int index = -1 );
1215
1216protected:
1217 virtual void virtual_hook( int id, void* data );
1218private:
1219 class KActionSeparatorPrivate;
1220 KActionSeparatorPrivate *d;
1221};
1222
1223#endif