KeyboardTranslator.h 17 KB
Newer Older
1 2 3
/*
    This source file is part of Konsole, a terminal emulator.

4
    Copyright 2007-2008 by Robert Knight <robertknight@gmail.com>
5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
    02110-1301  USA.
*/

22 23 24
#ifndef KEYBOARDTRANSLATOR_H
#define KEYBOARDTRANSLATOR_H

25
// Qt
26 27 28 29
#include <QHash>
#include <QList>
#include <QString>
#include <QMetaType>
30

31
// Konsole
Laurent Montel's avatar
Laurent Montel committed
32
#include "konsoleprivate_export.h"
33

34
class QIODevice;
35
class QTextStream;
36

Kurt Hindenburg's avatar
Kurt Hindenburg committed
37
namespace Konsole {
Jekyll Wu's avatar
Jekyll Wu committed
38
/**
39
 * A converter which maps between key sequences pressed by the user and the
40 41 42 43 44 45 46 47 48 49 50
 * character strings which should be sent to the terminal and commands
 * which should be invoked when those character sequences are pressed.
 *
 * Konsole supports multiple keyboard translators, allowing the user to
 * specify the character sequences which are sent to the terminal
 * when particular key sequences are pressed.
 *
 * A key sequence is defined as a key code, associated keyboard modifiers
 * (Shift,Ctrl,Alt,Meta etc.) and state flags which indicate the state
 * which the terminal must be in for the key sequence to apply.
 */
51
class KONSOLEPRIVATE_EXPORT KeyboardTranslator
52 53
{
public:
Jekyll Wu's avatar
Jekyll Wu committed
54
    /**
55 56 57 58
     * The meaning of a particular key sequence may depend upon the state which
     * the terminal emulation is in.  Therefore findEntry() may return a different
     * Entry depending upon the state flags supplied.
     *
Jekyll Wu's avatar
Jekyll Wu committed
59
     * This enum describes the states which may be associated with a particular
60 61
     * entry in the keyboard translation entry.
     */
Kurt Hindenburg's avatar
Kurt Hindenburg committed
62
    enum State {
63 64 65 66 67 68
        /** Indicates that no special state is active */
        NoState = 0,
        /**
         * TODO More documentation
         */
        NewLineState = 1,
Jekyll Wu's avatar
Jekyll Wu committed
69
        /**
70
         * Indicates that the terminal is in 'ANSI' mode.
71 72 73 74 75 76 77 78 79
         * TODO: More documentation
         */
        AnsiState = 2,
        /**
         * TODO More documentation
         */
        CursorKeysState = 4,
        /**
         * Indicates that the alternate screen ( typically used by interactive programs
Jekyll Wu's avatar
Jekyll Wu committed
80
         * such as screen or vim ) is active
81
         */
82
        AlternateScreenState = 8,
Jekyll Wu's avatar
Jekyll Wu committed
83
        /** Indicates that any of the modifier keys is active. */
84 85 86
        AnyModifierState = 16,
        /** Indicates that the numpad is in application mode. */
        ApplicationKeypadState = 32
87
    };
Kurt Hindenburg's avatar
Kurt Hindenburg committed
88
    Q_DECLARE_FLAGS(States, State)
89 90 91 92

    /**
     * This enum describes commands which are associated with particular key sequences.
     */
Kurt Hindenburg's avatar
Kurt Hindenburg committed
93
    enum Command {
94 95 96 97 98 99 100 101 102 103 104 105
        /** Indicates that no command is associated with this command sequence */
        NoCommand = 0,
        /** TODO Document me */
        SendCommand = 1,
        /** Scroll the terminal display up one page */
        ScrollPageUpCommand = 2,
        /** Scroll the terminal display down one page */
        ScrollPageDownCommand = 4,
        /** Scroll the terminal display up one line */
        ScrollLineUpCommand = 8,
        /** Scroll the terminal display down one line */
        ScrollLineDownCommand = 16,
106 107 108 109
        /** Scroll the terminal display up to the start of history */
        ScrollUpToTopCommand = 32,
        /** Scroll the terminal display down to the end of history */
        ScrollDownToBottomCommand = 64,
110
        /** Echos the operating system specific erase character. */
111
        EraseCommand = 256
112
    };
Kurt Hindenburg's avatar
Kurt Hindenburg committed
113
    Q_DECLARE_FLAGS(Commands, Command)
114 115 116 117 118 119 120 121 122

    /**
     * Represents an association between a key sequence pressed by the user
     * and the character sequence and commands associated with it for a particular
     * KeyboardTranslator.
     */
    class Entry
    {
    public:
Jekyll Wu's avatar
Jekyll Wu committed
123
        /**
124 125 126 127
         * Constructs a new entry for a keyboard translator.
         */
        Entry();

Jekyll Wu's avatar
Jekyll Wu committed
128
        /**
129
         * Returns true if this entry is null.
Jekyll Wu's avatar
Jekyll Wu committed
130
         * This is true for newly constructed entries which have no properties set.
131 132 133
         */
        bool isNull() const;

134 135
        /** Returns the commands associated with this entry */
        Command command() const;
136
        /** Sets the command associated with this entry. */
137
        void setCommand(Command aCommand);
138

Jekyll Wu's avatar
Jekyll Wu committed
139 140
        /**
         * Returns the character sequence associated with this entry, optionally replacing
141 142 143
         * wildcard '*' characters with numbers to indicate the keyboard modifiers being pressed.
         *
         * TODO: The numbers used to replace '*' characters are taken from the Konsole/KDE 3 code.
Jekyll Wu's avatar
Jekyll Wu committed
144
         * Document them.
145 146
         *
         * @param expandWildCards Specifies whether wild cards (occurrences of the '*' character) in
Jekyll Wu's avatar
Jekyll Wu committed
147
         * the entry should be replaced with a number to indicate the modifier keys being pressed.
148
         *
Kurt Hindenburg's avatar
Kurt Hindenburg committed
149
         * @param keyboardModifiers The keyboard modifiers being pressed.
150 151
         */
        QByteArray text(bool expandWildCards = false,
152
                        Qt::KeyboardModifiers keyboardModifiers = Qt::NoModifier) const;
153

154
        /** Sets the character sequence associated with this entry */
Kurt Hindenburg's avatar
Kurt Hindenburg committed
155
        void setText(const QByteArray &aText);
156

Jekyll Wu's avatar
Jekyll Wu committed
157
        /**
158 159 160
         * Returns the character sequence associated with this entry,
         * with any non-printable characters replaced with escape sequences.
         *
Robert Knight's avatar
 
Robert Knight committed
161
         * eg. \\E for Escape, \\t for tab, \\n for new line.
162 163 164
         *
         * @param expandWildCards See text()
         * @param modifiers See text()
165
         */
166 167
        QByteArray escapedText(bool expandWildCards = false,
                               Qt::KeyboardModifiers modifiers = Qt::NoModifier) const;
168

169 170
        /** Returns the character code ( from the Qt::Key enum ) associated with this entry */
        int keyCode() const;
171
        /** Sets the character code associated with this entry */
172
        void setKeyCode(int aKeyCode);
173

Jekyll Wu's avatar
Jekyll Wu committed
174 175
        /**
         * Returns a bitwise-OR of the enabled keyboard modifiers associated with this entry.
176 177 178 179
         * If a modifier is set in modifierMask() but not in modifiers(), this means that the entry
         * only matches when that modifier is NOT pressed.
         *
         * If a modifier is not set in modifierMask() then the entry matches whether the modifier
Jekyll Wu's avatar
Jekyll Wu committed
180
         * is pressed or not.
181
         */
182
        Qt::KeyboardModifiers modifiers() const;
183 184

        /** Returns the keyboard modifiers which are valid in this entry.  See modifiers() */
185
        Qt::KeyboardModifiers modifierMask() const;
186 187

        /** See modifiers() */
Kurt Hindenburg's avatar
Kurt Hindenburg committed
188
        void setModifiers(Qt::KeyboardModifiers modifiers);
189
        /** See modifierMask() and modifiers() */
Kurt Hindenburg's avatar
Kurt Hindenburg committed
190
        void setModifierMask(Qt::KeyboardModifiers modifiers);
191

Jekyll Wu's avatar
Jekyll Wu committed
192 193 194
        /**
         * Returns a bitwise-OR of the enabled state flags associated with this entry.
         * If flag is set in stateMask() but not in state(), this means that the entry only
195 196 197
         * matches when the terminal is NOT in that state.
         *
         * If a state is not set in stateMask() then the entry matches whether the terminal
Jekyll Wu's avatar
Jekyll Wu committed
198
         * is in that state or not.
199
         */
200
        States state() const;
201

202
        /** Returns the state flags which are valid in this entry.  See state() */
203
        States stateMask() const;
204 205

        /** See state() */
206
        void setState(States aState);
207
        /** See stateMask() */
208
        void setStateMask(States aStateMask);
209

Jekyll Wu's avatar
Jekyll Wu committed
210 211
        /**
         * Returns the key code and modifiers associated with this entry
212 213
         * as a QKeySequence
         */
214 215
        //QKeySequence keySequence() const;

Jekyll Wu's avatar
Jekyll Wu committed
216
        /**
217 218 219 220
         * Returns this entry's conditions ( ie. its key code, modifier and state criteria )
         * as a string.
         */
        QString conditionToString() const;
221

222 223 224
        /**
         * Returns this entry's result ( ie. its command or character sequence )
         * as a string.
225 226 227
         *
         * @param expandWildCards See text()
         * @param modifiers See text()
228
         */
229 230
        QString resultToString(bool expandWildCards = false,
                               Qt::KeyboardModifiers modifiers = Qt::NoModifier) const;
231

Jekyll Wu's avatar
Jekyll Wu committed
232
        /**
233 234 235
         * Returns true if this entry matches the given key sequence, specified
         * as a combination of @p keyCode , @p modifiers and @p state.
         */
Kurt Hindenburg's avatar
Kurt Hindenburg committed
236
        bool matches(int keyCode, Qt::KeyboardModifiers modifiers, States flags) const;
237

Kurt Hindenburg's avatar
Kurt Hindenburg committed
238
        bool operator==(const Entry &rhs) const;
239

240
    private:
Kurt Hindenburg's avatar
Kurt Hindenburg committed
241 242 243
        void insertModifier(QString &item, int modifier) const;
        void insertState(QString &item, int state) const;
        QByteArray unescape(const QByteArray &text) const;
244

245
        int _keyCode;
246 247 248 249
        Qt::KeyboardModifiers _modifiers;
        Qt::KeyboardModifiers _modifierMask;
        States _state;
        States _stateMask;
250 251

        Command _command;
252
        QByteArray _text;
253 254 255
    };

    /** Constructs a new keyboard translator with the given @p name */
Kurt Hindenburg's avatar
Kurt Hindenburg committed
256
    explicit KeyboardTranslator(const QString &name);
257

258
    //KeyboardTranslator(const KeyboardTranslator& other);
259

260 261 262
    /** Returns the name of this keyboard translator */
    QString name() const;

263
    /** Sets the name of this keyboard translator */
Kurt Hindenburg's avatar
Kurt Hindenburg committed
264
    void setName(const QString &name);
265

266 267 268 269
    /** Returns the descriptive name of this keyboard translator */
    QString description() const;

    /** Sets the descriptive name of this keyboard translator */
Kurt Hindenburg's avatar
Kurt Hindenburg committed
270
    void setDescription(const QString &description);
271

272 273 274
    /**
     * Looks for an entry in this keyboard translator which matches the given
     * key code, keyboard modifiers and state flags.
Jekyll Wu's avatar
Jekyll Wu committed
275
     *
276 277
     * Returns the matching entry if found or a null Entry otherwise ( ie.
     * entry.isNull() will return true )
278 279 280 281 282
     *
     * @param keyCode A key code from the Qt::Key enum
     * @param modifiers A combination of modifiers
     * @param state Optional flags which specify the current state of the terminal
     */
Kurt Hindenburg's avatar
Kurt Hindenburg committed
283
    Entry findEntry(int keyCode, Qt::KeyboardModifiers modifiers, States state = NoState) const;
284

Jekyll Wu's avatar
Jekyll Wu committed
285
    /**
286 287 288
     * Adds an entry to this keyboard translator's table.  Entries can be looked up according
     * to their key sequence using findEntry()
     */
Kurt Hindenburg's avatar
Kurt Hindenburg committed
289
    void addEntry(const Entry &entry);
290

291
    /**
292 293
     * Replaces an entry in the translator.  If the @p existing entry is null,
     * then this is equivalent to calling addEntry(@p replacement)
294
     */
Kurt Hindenburg's avatar
Kurt Hindenburg committed
295
    void replaceEntry(const Entry &existing, const Entry &replacement);
296 297 298 299

    /**
     * Removes an entry from the table.
     */
Kurt Hindenburg's avatar
Kurt Hindenburg committed
300
    void removeEntry(const Entry &entry);
301

302
    /** Returns a list of all entries in the translator. */
303
    QList<Entry> entries() const;
304

305
private:
Jekyll Wu's avatar
Jekyll Wu committed
306 307
    // All entries in this translator, indexed by their keycode
    QMultiHash<int, Entry> _entries;
Robert Knight's avatar
 
Robert Knight committed
308

309
    QString _name;
310
    QString _description;
311
};
André Wöbbeking's avatar
André Wöbbeking committed
312 313
Q_DECLARE_OPERATORS_FOR_FLAGS(KeyboardTranslator::States)
Q_DECLARE_OPERATORS_FOR_FLAGS(KeyboardTranslator::Commands)
314

315 316 317 318 319 320
class FallbackKeyboardTranslator : public KeyboardTranslator
{
public:
    FallbackKeyboardTranslator();
};

Jekyll Wu's avatar
Jekyll Wu committed
321 322
/**
 * Parses the contents of a Keyboard Translator (.keytab) file and
323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341
 * returns the entries found in it.
 *
 * Usage example:
 *
 * @code
 *  QFile source( "/path/to/keytab" );
 *  source.open( QIODevice::ReadOnly );
 *
 *  KeyboardTranslator* translator = new KeyboardTranslator( "name-of-translator" );
 *
 *  KeyboardTranslatorReader reader(source);
 *  while ( reader.hasNextEntry() )
 *      translator->addEntry(reader.nextEntry());
 *
 *  source.close();
 *
 *  if ( !reader.parseError() )
 *  {
 *      // parsing succeeded, do something with the translator
Jekyll Wu's avatar
Jekyll Wu committed
342
 *  }
343 344 345 346 347 348 349 350 351 352
 *  else
 *  {
 *      // parsing failed
 *  }
 * @endcode
 */
class KeyboardTranslatorReader
{
public:
    /** Constructs a new reader which parses the given @p source */
Kurt Hindenburg's avatar
Kurt Hindenburg committed
353
    explicit KeyboardTranslatorReader(QIODevice *source);
354 355
    ~KeyboardTranslatorReader();

Kurt Hindenburg's avatar
Kurt Hindenburg committed
356 357
    KeyboardTranslatorReader(const KeyboardTranslatorReader &) = delete;
    KeyboardTranslatorReader &operator=(const KeyboardTranslatorReader &) = delete;
358

Jekyll Wu's avatar
Jekyll Wu committed
359 360 361
    /**
     * Returns the description text.
     * TODO: More documentation
362 363
     */
    QString description() const;
364 365

    /** Returns true if there is another entry in the source stream */
366
    bool hasNextEntry();
367
    /** Returns the next entry found in the source stream */
Kurt Hindenburg's avatar
Kurt Hindenburg committed
368
    KeyboardTranslator::Entry nextEntry();
369

Jekyll Wu's avatar
Jekyll Wu committed
370
    /**
371 372 373
     * Returns true if an error occurred whilst parsing the input or
     * false if no error occurred.
     */
374 375
    bool parseError();

376 377 378 379
    /**
     * Parses a condition and result string for a translator entry
     * and produces a keyboard translator entry.
     *
Jekyll Wu's avatar
Jekyll Wu committed
380
     * The condition and result strings are in the same format as in
381
     */
Kurt Hindenburg's avatar
Kurt Hindenburg committed
382
    static KeyboardTranslator::Entry createEntry(const QString &condition, const QString &result);
383
private:
Kurt Hindenburg's avatar
Kurt Hindenburg committed
384 385
    struct Token {
        enum Type {
386 387 388 389 390 391 392 393 394 395
            TitleKeyword,
            TitleText,
            KeyKeyword,
            KeySequence,
            Command,
            OutputText
        };
        Type type;
        QString text;
    };
Kurt Hindenburg's avatar
Kurt Hindenburg committed
396
    QList<Token> tokenize(const QString &);
397
    void readNext();
Kurt Hindenburg's avatar
Kurt Hindenburg committed
398 399 400 401 402 403 404 405 406 407
    bool decodeSequence(const QString &, int &keyCode, Qt::KeyboardModifiers &modifiers,
                        Qt::KeyboardModifiers &modifierMask, KeyboardTranslator::States &state,
                        KeyboardTranslator::States &stateFlags);

    static bool parseAsModifier(const QString &item, Qt::KeyboardModifier &modifier);
    static bool parseAsStateFlag(const QString &item, KeyboardTranslator::State &state);
    static bool parseAsKeyCode(const QString &item, int &keyCode);
    static bool parseAsCommand(const QString &text, KeyboardTranslator::Command &command);

    QIODevice *_source;
408 409 410
    QString _description;
    KeyboardTranslator::Entry _nextEntry;
    bool _hasNext;
411 412
};

413 414 415 416
/** Writes a keyboard translation to disk. */
class KeyboardTranslatorWriter
{
public:
Jekyll Wu's avatar
Jekyll Wu committed
417
    /**
418 419 420
     * Constructs a new writer which saves data into @p destination.
     * The caller is responsible for closing the device when writing is complete.
     */
Kurt Hindenburg's avatar
Kurt Hindenburg committed
421
    explicit KeyboardTranslatorWriter(QIODevice *destination);
422 423
    ~KeyboardTranslatorWriter();

Kurt Hindenburg's avatar
Kurt Hindenburg committed
424 425
    KeyboardTranslatorWriter(const KeyboardTranslatorWriter &) = delete;
    KeyboardTranslatorWriter &operator=(const KeyboardTranslatorWriter &) = delete;
426

Jekyll Wu's avatar
Jekyll Wu committed
427 428 429
    /**
     * Writes the header for the keyboard translator.
     * @param description Description of the keyboard translator.
430
     */
Kurt Hindenburg's avatar
Kurt Hindenburg committed
431
    void writeHeader(const QString &description);
432
    /** Writes a translator entry. */
Kurt Hindenburg's avatar
Kurt Hindenburg committed
433
    void writeEntry(const KeyboardTranslator::Entry &entry);
434 435

private:
Kurt Hindenburg's avatar
Kurt Hindenburg committed
436 437
    QIODevice *_destination;
    QTextStream *_writer;
438 439
};

Kurt Hindenburg's avatar
Kurt Hindenburg committed
440 441 442 443
inline int KeyboardTranslator::Entry::keyCode() const
{
    return _keyCode;
}
Kurt Hindenburg's avatar
Kurt Hindenburg committed
444

445
inline void KeyboardTranslator::Entry::setKeyCode(int aKeyCode)
Kurt Hindenburg's avatar
Kurt Hindenburg committed
446
{
447
    _keyCode = aKeyCode;
Kurt Hindenburg's avatar
Kurt Hindenburg committed
448
}
449

Kurt Hindenburg's avatar
Kurt Hindenburg committed
450 451
inline void KeyboardTranslator::Entry::setModifiers(Qt::KeyboardModifiers modifier)
{
452
    _modifiers = modifier;
453
}
Kurt Hindenburg's avatar
Kurt Hindenburg committed
454

Kurt Hindenburg's avatar
Kurt Hindenburg committed
455 456 457 458
inline Qt::KeyboardModifiers KeyboardTranslator::Entry::modifiers() const
{
    return _modifiers;
}
459

Kurt Hindenburg's avatar
Kurt Hindenburg committed
460
inline void KeyboardTranslator::Entry::setModifierMask(Qt::KeyboardModifiers mask)
Kurt Hindenburg's avatar
Kurt Hindenburg committed
461 462 463
{
    _modifierMask = mask;
}
Kurt Hindenburg's avatar
Kurt Hindenburg committed
464

Kurt Hindenburg's avatar
Kurt Hindenburg committed
465 466 467
inline Qt::KeyboardModifiers KeyboardTranslator::Entry::modifierMask() const
{
    return _modifierMask;
468
}
469

470 471
inline bool KeyboardTranslator::Entry::isNull() const
{
Kurt Hindenburg's avatar
Kurt Hindenburg committed
472
    return *this == Entry();
473 474
}

475
inline void KeyboardTranslator::Entry::setCommand(Command aCommand)
Kurt Hindenburg's avatar
Kurt Hindenburg committed
476
{
477
    _command = aCommand;
Kurt Hindenburg's avatar
Kurt Hindenburg committed
478
}
Kurt Hindenburg's avatar
Kurt Hindenburg committed
479

Kurt Hindenburg's avatar
Kurt Hindenburg committed
480 481 482
inline KeyboardTranslator::Command KeyboardTranslator::Entry::command() const
{
    return _command;
483
}
484

Kurt Hindenburg's avatar
Kurt Hindenburg committed
485
inline void KeyboardTranslator::Entry::setText(const QByteArray &aText)
Kurt Hindenburg's avatar
Kurt Hindenburg committed
486
{
487
    _text = unescape(aText);
488
}
Kurt Hindenburg's avatar
Kurt Hindenburg committed
489

490 491 492 493
inline int oneOrZero(int value)
{
    return value ? 1 : 0;
}
Kurt Hindenburg's avatar
Kurt Hindenburg committed
494

495
inline QByteArray KeyboardTranslator::Entry::text(bool expandWildCards,
Kurt Hindenburg's avatar
Kurt Hindenburg committed
496
                                                  Qt::KeyboardModifiers keyboardModifiers) const
497 498
{
    QByteArray expandedText = _text;
499

Kurt Hindenburg's avatar
Kurt Hindenburg committed
500
    if (expandWildCards) {
501
        int modifierValue = 1;
502
        modifierValue += oneOrZero(keyboardModifiers & Qt::ShiftModifier);
Kurt Hindenburg's avatar
Kurt Hindenburg committed
503
        modifierValue += oneOrZero(keyboardModifiers & Qt::AltModifier) << 1;
504
        modifierValue += oneOrZero(keyboardModifiers & Qt::ControlModifier) << 2;
505

Kurt Hindenburg's avatar
Kurt Hindenburg committed
506
        for (int i = 0; i < _text.length(); i++) {
Kurt Hindenburg's avatar
Kurt Hindenburg committed
507
            if (expandedText[i] == '*') {
508
                expandedText[i] = '0' + modifierValue;
Kurt Hindenburg's avatar
Kurt Hindenburg committed
509
            }
510 511 512
        }
    }

Kurt Hindenburg's avatar
Kurt Hindenburg committed
513
    return expandedText;
514
}
515

516
inline void KeyboardTranslator::Entry::setState(States aState)
Kurt Hindenburg's avatar
Kurt Hindenburg committed
517
{
518
    _state = aState;
Kurt Hindenburg's avatar
Kurt Hindenburg committed
519
}
Kurt Hindenburg's avatar
Kurt Hindenburg committed
520

Kurt Hindenburg's avatar
Kurt Hindenburg committed
521 522 523
inline KeyboardTranslator::States KeyboardTranslator::Entry::state() const
{
    return _state;
524 525
}

526
inline void KeyboardTranslator::Entry::setStateMask(States aStateMask)
Kurt Hindenburg's avatar
Kurt Hindenburg committed
527
{
528
    _stateMask = aStateMask;
Kurt Hindenburg's avatar
Kurt Hindenburg committed
529
}
Kurt Hindenburg's avatar
Kurt Hindenburg committed
530

Kurt Hindenburg's avatar
Kurt Hindenburg committed
531 532 533
inline KeyboardTranslator::States KeyboardTranslator::Entry::stateMask() const
{
    return _stateMask;
534
}
Stephan Binner's avatar
Stephan Binner committed
535
}
536

André Wöbbeking's avatar
André Wöbbeking committed
537
Q_DECLARE_METATYPE(Konsole::KeyboardTranslator::Entry)
Kurt Hindenburg's avatar
Kurt Hindenburg committed
538
Q_DECLARE_METATYPE(const Konsole::KeyboardTranslator *)
539 540

#endif // KEYBOARDTRANSLATOR_H