summaryrefslogtreecommitdiffabout
path: root/microkde/kdecore/kshortcut.h
Unidiff
Diffstat (limited to 'microkde/kdecore/kshortcut.h') (more/less context) (ignore whitespace changes)
-rw-r--r--microkde/kdecore/kshortcut.h846
1 files changed, 846 insertions, 0 deletions
diff --git a/microkde/kdecore/kshortcut.h b/microkde/kdecore/kshortcut.h
new file mode 100644
index 0000000..4813734
--- a/dev/null
+++ b/microkde/kdecore/kshortcut.h
@@ -0,0 +1,846 @@
1/* This file is part of the KDE libraries
2 Copyright (C) 2001,2002 Ellis Whitehead <ellis@kde.org>
3
4 This library is free software; you can redistribute it and/or
5 modify it under the terms of the GNU Library General Public
6 License as published by the Free Software Foundation; either
7 version 2 of the License, or (at your option) any later version.
8
9 This library is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 Library General Public License for more details.
13
14 You should have received a copy of the GNU Library General Public License
15 along with this library; see the file COPYING.LIB. If not, write to
16 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
17 Boston, MA 02111-1307, USA.
18*/
19
20#ifndef __KSHORTCUT_H
21#define __KSHORTCUT_H
22/*US
23#include <qkeysequence.h>
24#include <qstring.h>
25
26class QKeyEvent;
27class KKeyNative;
28*/
29/**
30* A KKey object represents a single key with possible modifiers
31* (Shift, Ctrl, Alt, Win). It can represent both keys which are
32* understood by Qt as well as those which are additionally supported
33* by the underlying system (e.g. X11).
34* @see KKeyNative
35* @see KKeySequence
36* @see KShortcut
37*/
38/*US
39class KKey
40{
41 public:
42*/
43 /**
44 * The number of flags.
45 * @see ModFlag
46 */
47/*US
48 enum { MOD_FLAG_COUNT = 4 };
49 enum { QtWIN = (Qt::ALT << 1) };
50*/
51 /**
52 * Flags to represent the modifiers. You can combine modifiers
53 * by ORing them.
54 */
55/*US
56 enum ModFlag {
57 SHIFT = 0x01,
58 CTRL = 0x02,
59 ALT = 0x04,
60 WIN = 0x08
61 };
62*/
63 /**
64 * Creates a new null KKey.
65 * @see clear()
66 * @see isNull()
67 * @see null()
68 */
69 //USKKey();
70
71 /**
72 * Creates a new key for the given Qt key code.
73 * @param keyQt the qt keycode
74 * @see Qt::Key
75 */
76 //USKKey( int keyQt );
77
78 /**
79 * Creates a new key from the first key code of the given key sequence.
80 * @param keySeq the key sequence that contains the key
81 */
82 //USKKey( const QKeySequence& keySeq );
83
84 /**
85 * Extracts the key from the given key event.
86 * @param keyEvent the key event to get the key from
87 */
88 //USKKey( const QKeyEvent* keyEvent );
89
90 /**
91 * Copy constructor.
92 */
93 //USKKey( const KKey& key );
94
95 /**
96 * Creates a new key from the given description. The form of the description
97 * is "[modifier+[modifier+]]+key", for example "e", "CTRL+q" or
98 * "CTRL+ALT+DEL". Allowed modifiers are "SHIFT", "CTRL", "ALT", "WIN" and
99 * "META". "WIN" and "META" are equivalent. Modifiers are not case-sensitive.
100 * @param key the description of the key
101 * @see KKeyServer::Sym::init()
102 */
103 //USKKey( const QString& key );
104 /**
105 * @internal
106 */
107 //USKKey( uint key, uint mod );
108 //US~KKey();
109
110 // Initialization methods
111 /**
112 * Clears the key. The key is null after calling this function.
113 * @see isNull()
114 */
115 //USvoid clear();
116
117 /**
118 * Initializes the key with the given Qt key code.
119 * @param keyQt the qt keycode
120 * @return true if successful, false otherwise
121 * @see Qt::Key
122 */
123 //USbool init( int keyQt );
124
125 /**
126 * Initializes the key with the first key code of the given key sequence.
127 * @param keySeq the key sequence that contains the key
128 * @return true if successful, false otherwise
129 */
130 //USbool init( const QKeySequence& keySeq );
131
132 /**
133 * Initializes the key by extracting the code from the given key event.
134 * @param keyEvent the key event to get the key from
135 * @return true if successful, false otherwise
136 */
137 //USbool init( const QKeyEvent* keyEvent );
138
139 /**
140 * Copies the given key.
141 * @param key the key to copy
142 * @return true if successful, false otherwise
143 */
144 //USbool init( const KKey& key );
145
146 /**
147 * Initializes the key with the given description. The form of the description
148 * is "[modifier+[modifier+]]+key", for example "e", "CTRL+q" or
149 * "CTRL+ALT+DEL". Allowed modifiers are "SHIFT", "CTRL", "ALT", "WIN" and
150 * "META". "WIN" and "META" are equivalent. Modifiers are not case-sensitive.
151 * @param key the description of the key
152 * @return true if successful, false otherwise
153 * @see KKeyServer::Sym::init()
154 */
155 //USbool init( const QString& );
156
157 /**
158 * @internal
159 */
160 //USbool init( uint key, uint mod );
161
162 /**
163 * Copies the key.
164 */
165 //USKKey& operator =( const KKey& key )
166 //US { init( key ); return *this; }
167
168 // Query methods.
169 /**
170 * Returns true if the key is null (after @ref clear() or empty
171 * constructor).
172 * @return true if the key is null
173 * @see clear()
174 * @see null()
175 */
176 //USbool isNull() const;
177
178 /**
179 * @internal
180 */
181 //USbool isValidQt() const;
182
183 /**
184 * @internal
185 */
186 //USbool isValidNative() const;
187
188 /**
189 * @internal
190 */
191 //USuint sym() const;
192 /**
193 * @internal
194 */
195 //USuint modFlags() const;
196
197 // Comparison Methods
198 /**
199 * Compares this key with the given KKey object. Returns a negative
200 * number if the given KKey is larger, 0 if they are equal and
201 * a positive number this KKey is larger. The returned value
202 * is the difference between the symbol or, if the symbols
203 * are equal, the difference between the encoded modifiers.
204 * @param key the key to compare with this key
205 * @return a negative number if the given KKey is larger, 0 if
206 * they are equal and a positive number this KKey is larger
207 */
208 //USint compare( const KKey& key ) const;
209
210 /**
211 * Compares the symbol and modifiers of both keys.
212 * @see compare()
213 */
214 //USbool operator == ( const KKey& key ) const
215 //US { return compare( key ) == 0; }
216 /**
217 * Compares the symbol and modifiers of both keys.
218 * @see compare()
219 */
220 //USbool operator != ( const KKey& key ) const
221 //US { return compare( key ) != 0; }
222 /**
223 * Compares the symbol and modifiers of both keys.
224 * @see compare()
225 */
226 //USbool operator < ( const KKey& key ) const
227 //US { return compare( key ) < 0; }
228
229 // Conversion methods.
230 /**
231 * Returns the qt key code.
232 * @return the qt key code or 0 if there is no key set.
233 * @see Qt::Key
234 */
235 //USint keyCodeQt() const;
236
237 /**
238 * Returns a human-readable representation of the key in the form
239 * "modifier+key".
240 * @return the string representation of the key
241 */
242 //USQString toString() const;
243
244 /**
245 * @internal
246 */
247//US QString toStringInternal() const;
248
249 // Operation methods
250 /**
251 * @internal
252 */
253 //USvoid simplify();
254
255 /**
256 * Returns a null key.
257 * @return the null key
258 * @see isNull()
259 * @see clear()
260 */
261 //USstatic KKey& null();
262
263 /**
264 * Returns a user-readable representation of the given modifiers.
265 * @param f the modifiers to convert
266 * @return the string representation of the modifiers
267 */
268 //USstatic QString modFlagLabel( ModFlag f );
269
270//US private:
271 /*
272 * Under X11, m_key will hold an X11 key symbol.
273 * For Qt/Embedded, it will hold the Qt key code.
274 */
275 /**
276 * Returns the native key symbol value key. Under X11, this is the X
277 * keycode. Under Qt/Embedded, this is the Qt keycode.
278 * @see /usr/include/X11/keysymdef.h
279 * @see qnamespace.h
280 */
281 //USuint m_sym;
282 /**
283 * m_mod holds the
284 */
285 //USuint m_mod;
286
287//US private:
288 //USfriend class KKeyNative;
289//US};
290
291/**
292* A KKeySequence object holds a sequence of up to 4 keys.
293* Ex: Ctrl+X,I
294* @see KKey
295* @see KShortcut
296*/
297
298//USclass KKeySequence
299//US{
300//US public:
301 /// Defines the maximum length of the key sequence
302//US enum { MAX_KEYS = 4 };
303
304 /**
305 * Create a new null key sequence.
306 * @see isNull()
307 * @see null()
308 * @see clear()
309 */
310 //USKKeySequence();
311
312 /**
313 * Copies the given qt key sequence.
314 * @param keySeq the qt key sequence to copy
315 */
316 //USKKeySequence( const QKeySequence& keySeq );
317
318 /**
319 * Create a new key sequence that only contains the given key.
320 * @param key the key to add
321 */
322 //USKKeySequence( const KKey& key );
323
324 /**
325 * Create a new key sequence that only contains the given key.
326 * @param key the key to add
327 */
328 //USKKeySequence( const KKeyNative& key );
329
330 /**
331 * Copies the given key sequence.
332 * @param keySeq the key sequence to copy
333 */
334 //USKKeySequence( const KKeySequence& keySeq );
335
336 /**
337 * Creates a new key sequence that contains the given key sequence.
338 * The description consists of comma-separated keys as
339 * required by @ref KKey::KKey(const QString&).
340 * @param keySeq the description of the key
341 * @see KKeyServer::Sym::init()
342 * @see KKey::KKey(const QString&)
343 */
344 //USKKeySequence( const QString& keySeq );
345
346 //US~KKeySequence();
347
348 /**
349 * Clears the key sequence. The key sequence is null after calling this
350 * function.
351 * @see isNull()
352 */
353 //USvoid clear();
354
355 /**
356 * Copies the given qt key sequence over this key sequence.
357 * @param keySeq the qt key sequence to copy
358 * @return true if successful, false otherwise
359 */
360 //USbool init( const QKeySequence& keySeq );
361
362 /**
363 * Initializes the key sequence to only contain the given key.
364 * @param key the key to set
365 * @return true if successful, false otherwise
366 */
367 //USbool init( const KKey& key );
368
369 /**
370 * Initializes the key sequence to only contain the given key.
371 * @param key the key to set
372 * @return true if successful, false otherwise
373 */
374 //USbool init( const KKeyNative& key );
375
376 /**
377 * Copies the given key sequence over this key sequence.
378 * @param keySeq the key sequence to copy
379 * @return true if successful, false otherwise
380 */
381 //USbool init( const KKeySequence& keySeq );
382
383 /**
384 * Initializes this key sequence to contain the given key sequence.
385 * The description consists of comma-separated keys as
386 * required by @ref KKey::KKey(const QString&).
387 * @param key the description of the key
388 * @return true if successful, false otherwise
389 * @see KKeyServer::Sym::init()
390 * @see KKey::KKey(const QString&)
391 */
392 //USbool init( const QString& key );
393
394 /**
395 * Copy the given key sequence into this sequence.
396 */
397 //USKKeySequence& operator =( const KKeySequence& seq )
398 //US { init( seq ); return *this; }
399
400 /**
401 * Returns the number of key strokes of this sequence.
402 * @return the number of key strokes
403 * @see MAX_KEYS
404 */
405 //USuint count() const;
406
407 /**
408 * Return the @p i'th key of this sequence, or a null key if there
409 * are less then i keys.
410 * @param i the key to retrieve
411 * @return the @p i'th key, or @ref KKey::null() if there are less
412 * than i keys
413 * @see MAX_KEYS
414 */
415 //USconst KKey& key( uint i ) const;
416
417 /**
418 * @internal
419 */
420 //USbool isTriggerOnRelease() const;
421
422 /**
423 * Sets the @p i'th key of the sequence. You can not introduce gaps
424 * in a sequence, so you must use an @p i <= @ref count(). Also note that
425 * the maximum length of a key sequence is @ref MAX_KEYS.
426 * @param i the position of the new key (<= @ref count(), <= @ref MAX_KEYS)
427 * @param key the key to set
428 * @return true if successful, false otherwise
429 */
430 //USbool setKey( uint i, const KKey& key );
431
432 /**
433 * @internal
434 */
435 //USvoid setTriggerOnRelease( bool );
436
437 /**
438 * Returns true if the key sequence is null (after @ref clear() or empty
439 * constructor).
440 * @return true if the key sequence is null
441 * @see clear()
442 * @see null()
443 */
444//US bool isNull() const;
445
446 /**
447 * Returns true if this key sequence begins with the given sequence.
448 * @param keySeq the key sequence to search
449 * @return true if this key sequence begins with the given sequence
450 */
451 //USbool startsWith( const KKeySequence& keySeq ) const;
452
453 /**
454 * Compares this object with the given key sequence. Returns a negative
455 * number if the given KKeySequence is larger, 0 if they are equal and
456 * a positive number this KKeySequence is larger. Key sequences are
457 * compared by comparing the individual keys, starting from the beginning
458 * until an unequal key has been found. If a sequence contains more
459 * keys, it is considered larger.
460 * @param keySeq the key sequence to compare to
461 * @return a negative number if the given KKeySequence is larger, 0 if
462 * they are equal and a positive number this KKeySequence is larger
463 * @see KKey::sequence
464 */
465 //USint compare( const KKeySequence& keySeq ) const;
466
467 /**
468 * Compares the keys of both sequences.
469 * @see compare()
470 */
471 //USbool operator == ( const KKeySequence& seq ) const
472 //US { return compare( seq ) == 0; }
473
474 /**
475 * Compares the keys of both sequences.
476 * @see compare()
477 */
478 //USbool operator != ( const KKeySequence& seq ) const
479 //US { return compare( seq ) != 0; }
480
481 /**
482 * Compares the keys of both sequences.
483 * @see compare()
484 */
485 //USbool operator < ( const KKeySequence& seq ) const
486 //US { return compare( seq ) < 0; }
487 // TODO: consider adding Qt::SequenceMatch matches(...) methods for QKeySequence equivalence
488
489 /**
490 * Converts this key sequence to a QKeySequence.
491 * @return the QKeySequence
492 */
493 //USQKeySequence qt() const;
494
495 /**
496 * Returns the qt key code of the first key.
497 * @return the qt key code of the first key
498 * @see Qt::Key
499 * @see KKey::keyCodeQt()
500 */
501 //USint keyCodeQt() const;
502
503 /**
504 * Returns the key sequence as a number of key presses as
505 * returned by @ref KKey::toString(), seperated by commas.
506 * @return the string represenation of this key sequence
507 * @see KKey::toString()
508 */
509 //USQString toString() const;
510
511 /**
512 * @internal
513 */
514//US QString toStringInternal() const;
515
516 /**
517 * Returns a null key sequence.
518 * @return the null key sequence
519 * @see isNull()
520 * @see clear()
521 */
522 //USstatic KKeySequence& null();
523
524//US protected:
525 //USuchar m_nKeys;
526 //USuchar m_bTriggerOnRelease;
527 // BCI: m_rgvar should be renamed to m_rgkey for KDE 4.0
528 //USKKey m_rgvar[MAX_KEYS];
529
530//US private:
531 //USclass KKeySequencePrivate* d;
532 //USfriend class KKeyNative;
533//US};
534
535/**
536* The KShortcut class is used to represent a keyboard shortcut to an action.
537* A shortcut is normally a single key with modifiers, such as Ctrl+V.
538* A KShortcut object may also contain an alternate key which will also
539* activate the action it's associated to, as long as no other actions have
540* defined that key as their primary key. Ex: Ctrl+V;Shift+Insert.
541*/
542
543class KShortcut
544{
545 public:
546 /**
547 * The maximum number of key sequences that can be contained in
548 * a KShortcut.
549 */
550 enum { MAX_SEQUENCES = 2 };
551
552 /**
553 * Creates a new null shortcut.
554 * @see null()
555 * @see isNull()
556 * @see clear()
557 */
558 KShortcut() {}
559
560 /**
561 * Creates a new shortcut with the given Qt key code
562 * as the only key sequence.
563 * @param keyQt the qt keycode
564 * @see Qt::Key
565 */
566 KShortcut( int keyQt ) {}
567
568 /**
569 * Creates a new shortcut that contains only the given qt key
570 * sequence.
571 * @param keySeq the qt key sequence to add
572 */
573 //USKShortcut( const QKeySequence& keySeq ) {}
574
575 /**
576 * Creates a new shortcut that contains only the given key
577 * in its only sequence.
578 * @param key the key to add
579 */
580 //USKShortcut( const KKey& key );
581
582 /**
583 * Creates a new shortcut that contains only the given key
584 * sequence.
585 * @param keySeq the key sequence to add
586 */
587 //USKShortcut( const KKeySequence& keySeq );
588
589 /**
590 * Copies the given shortcut.
591 * @param shortcut the shortcut to add
592 */
593 //USKShortcut( const KShortcut& shortcut );
594
595 /**
596 * Creates a new key sequence that contains the given key sequence.
597 * The description consists of semicolon-separated keys as
598 * used in @ref KKeySequence::KKeySequence(const QString&).
599 * @param shortcut the description of the key
600 * @see KKeySequence::KKeySequence(const QString&)
601 */
602 KShortcut( const char* shortcut ) {}
603
604 /**
605 * Creates a new key sequence that contains the given key sequence.
606 * The description consists of semicolon-separated keys as
607 * used in @ref KKeySequence::KKeySequence(const QString&).
608 * @param shortcut the description of the key
609 * @see KKeySequence::KKeySequence(const QString&)
610 */
611 KShortcut( const QString& shortcut ) {}
612 ~KShortcut() {}
613
614 /**
615 * Clears the shortcut. The shortcut is null after calling this
616 * function.
617 * @see isNull()
618 */
619 //USvoid clear();
620
621 /**
622 * Initializes the shortcut with the given Qt key code
623 * as the only key sequence.
624 * @param keyQt the qt keycode
625 * @see Qt::Key
626 */
627 //USbool init( int keyQt );
628
629 /**
630 * Initializes the shortcut with the given qt key sequence.
631 * @param keySeq the qt key sequence to add
632 */
633 //USbool init( const QKeySequence& keySeq );
634
635 /**
636 * Initializes the shortcut with the given key as its only sequence.
637 * @param key the key to add
638 */
639 //USbool init( const KKey& key );
640
641 /**
642 * Initializes the shortcut with the given qt key sequence.
643 * @param keySeq the qt key sequence to add
644 */
645 //USbool init( const KKeySequence& keySeq );
646
647 /**
648 * Copies the given shortcut.
649 * @param shortcut the shortcut to add
650 */
651 //USbool init( const KShortcut& shortcut );
652
653 /**
654 * Initializes the key sequence with the given key sequence.
655 * The description consists of semicolon-separated keys as
656 * used in @ref KKeySequence::KKeySequence(const QString&).
657 * @param shortcut the description of the key
658 * @see KKeySequence::KKeySequence(const QString&)
659 */
660 //USbool init( const QString& shortcut );
661
662 /**
663 * Copies the given shortcut over this shortcut.
664 */
665 //USKShortcut& operator =( const KShortcut& cut )
666 //US { init( cut ); return *this; }
667
668 /**
669 * Returns the number of sequences that are in this
670 * shortcut.
671 * @return the number of sequences
672 * @ref MAX_SEQUENCES
673 */
674 //USuint count() const;
675
676 /**
677 * Returns the @p i'th key sequence of this shortcut.
678 * @param i the number of the key sequence to retrieve
679 * @return the @p i'th sequence or @ref KKeySequence::null() if
680 * there are less than @p i key sequences
681 * @ref MAX_SEQUENCES
682 */
683 //USconst KKeySequence& seq( uint i ) const;
684
685 /**
686 * Returns the key code of the first key sequence, or
687 * null if there is no first key sequence.
688 * @return the key code of the first sequence's first key
689 * @see Qt::Key
690 * @see KKeySequence::keyCodeQt()
691 */
692 //USint keyCodeQt() const;
693
694 /**
695 * Returns true if the shortcut is null (after @ref clear() or empty
696 * constructor).
697 * @return true if the shortcut is null
698 * @see clear()
699 * @see null()
700 */
701 bool isNull() const { return true; }
702
703 /**
704 * Compares this object with the given shortcut. Returns a negative
705 * number if the given shortcut is larger, 0 if they are equal and
706 * a positive number this shortcut is larger. Shortcuts are
707 * compared by comparing the individual key sequences, starting from the
708 * beginning until an unequal key sequences has been found. If a shortcut
709 * contains more key sequences, it is considered larger.
710 * @param shortcut the shortcut to compare to
711 * @return a negative number if the given KShortcut is larger, 0 if
712 * they are equal and a positive number this KShortcut is larger
713 * @see KKey::compare()
714 * @see KKeyShortcut::compare()
715 */
716 //USint compare( const KShortcut& shortcut ) const;
717
718 /**
719 * Compares the sequences of both shortcuts.
720 * @see compare()
721 */
722 //USbool operator == ( const KShortcut& cut ) const
723 //US { return compare( cut ) == 0; }
724
725 /**
726 * Compares the sequences of both shortcuts.
727 * @see compare()
728 */
729 //USbool operator != ( const KShortcut& cut ) const
730 //US { return compare( cut ) != 0; }
731
732 /**
733 * Compares the sequences of both shortcuts.
734 * @see compare()
735 */
736 //USbool operator < ( const KShortcut& cut ) const
737 //US { return compare( cut ) < 0; }
738
739 /**
740 * Checks whether this shortcut contains a sequence that starts
741 * with the given key.
742 * @param key the key to check
743 * @return true if a key sequence starts with the key
744 */
745 //USbool contains( const KKey& key ) const;
746
747 /**
748 * Checks whether this shortcut contains a sequence that starts
749 * with the given key.
750 * @param key the key to check
751 * @return true if a key sequence starts with the key
752 */
753 //USbool contains( const KKeyNative& key ) const;
754
755 /**
756 * Checks whether this shortcut contains the given sequence.
757 * @param keySeq the key sequence to check
758 * @return true if the shortcut has the given key sequence
759 */
760 //USbool contains( const KKeySequence& keySeq ) const;
761
762 /**
763 * Sets the @p i'th key sequence of the shortcut. You can not introduce
764 * gaps in the list of sequences, so you must use an @i <= @ref count().
765 * Also note that the maximum number of key sequences is @ref MAX_SEQUENCES.
766 * @param i the position of the new key sequence(<= @ref count(),
767 * <= @ref MAX_SEQUENCES)
768 * @param keySeq the key sequence to set
769 * @return true if successful, false otherwise
770 */
771 //USbool setSeq( uint i, const KKeySequence& keySeq );
772
773 /**
774 * Appends the given key sequence.
775 * @param keySeq the key sequence to add
776 * @return true if successful, false otherwise
777 * @see setSeq()
778 * @see MAX_SEQUENCES
779 */
780 //USbool append( const KKeySequence& keySeq );
781
782 /**
783 * Appends the given key
784 * @param spec the key to add
785 * @return true if successful, false otherwise
786 * @see setSeq()
787 * @see MAX_SEQUENCES
788 * @since 3.2
789 */
790 //USbool append( const KKey& spec );
791
792 /**
793 * Appends the sequences from the given shortcut.
794 * @param cut the shortcut to append
795 * @return true if successful, false otherwise
796 * @see MAX_SEQUENCES
797 * @since 3.2
798 */
799 //USbool append( const KShortcut& cut );
800
801 /**
802 * Converts this shortcut to a key sequence. The first key sequence
803 * will be taken.
804 */
805 //USoperator QKeySequence () const;
806
807 /**
808 * Returns a description of the shortcut as semicolon-separated
809 * ket sequences, as returned by @ref KKeySequence::toString().
810 * @return the string represenation of this shortcut
811 * @see KKey::toString()
812 * @see KKeySequence::toString()
813 */
814 //USQString toString() const;
815
816 /**
817 * @internal
818 */
819 QString toStringInternal( const KShortcut* pcutDefault = 0 ) const
820 {
821 return "EMPTY IMPL.";
822 }
823
824 /**
825 * Returns a null shortcut.
826 * @return the null shortcut
827 * @see isNull()
828 * @see clear()
829 */
830 //USstatic KShortcut& null();
831
832//US protected:
833 //USuint m_nSeqs;
834 //USKKeySequence m_rgseq[MAX_SEQUENCES];
835
836//US private:
837 //USclass KShortcutPrivate* d;
838 //USfriend class KKeyNative;
839
840//US#ifndef KDE_NO_COMPAT
841//US public:
842 //USoperator int () const { return keyCodeQt(); }
843//US#endif
844};
845
846#endif // __KSHORTCUT_H