KeyboardTranslator.h

Go to the documentation of this file.

/*
    This source file is part of Konsole, a terminal emulator.

    Copyright 2007-2008 by Robert Knight <robertknight@gmail.com>

    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.
*/

#ifndef KEYBOARDTRANSLATOR_H
#define KEYBOARDTRANSLATOR_H

// Qt
#include <QtCore/QHash>
#include <QtCore/QList>
//#include <QtGui/QKeySequence>
#include <QtCore/QMetaType>

// Konsole
#include "konsole_export.h"

class QIODevice;
class QTextStream;

namespace Konsole
{
class KONSOLEPRIVATE_EXPORT KeyboardTranslator
{
public:
    enum State {
        NoState = 0,
        NewLineState = 1,
        AnsiState = 2,
        CursorKeysState = 4,
        AlternateScreenState = 8,
        AnyModifierState = 16,
        ApplicationKeypadState = 32
    };
    Q_DECLARE_FLAGS(States, State)

    
    enum Command {
        NoCommand = 0,
        SendCommand = 1,
        ScrollPageUpCommand = 2,
        ScrollPageDownCommand = 4,
        ScrollLineUpCommand = 8,
        ScrollLineDownCommand = 16,
        ScrollUpToTopCommand = 32,
        ScrollDownToBottomCommand = 64,
        EraseCommand = 256
    };
    Q_DECLARE_FLAGS(Commands, Command)

    
    class Entry
    {
    public:
        Entry();

        bool isNull() const;

        Command command() const;
        void setCommand(Command aCommand);

        QByteArray text(bool expandWildCards = false,
                        Qt::KeyboardModifiers keyboardModifiers = Qt::NoModifier) const;

        void setText(const QByteArray& aText);

        QByteArray escapedText(bool expandWildCards = false,
                               Qt::KeyboardModifiers modifiers = Qt::NoModifier) const;

        int keyCode() const;
        void setKeyCode(int aKeyCode);

        Qt::KeyboardModifiers modifiers() const;

        Qt::KeyboardModifiers modifierMask() const;

        void setModifiers(Qt::KeyboardModifiers modifiers);
        void setModifierMask(Qt::KeyboardModifiers modifiers);

        States state() const;

        States stateMask() const;

        void setState(States aState);
        void setStateMask(States aStateMask);

        //QKeySequence keySequence() const;

        QString conditionToString() const;

        QString resultToString(bool expandWildCards = false,
                               Qt::KeyboardModifiers modifiers = Qt::NoModifier) const;

        bool matches(int keyCode ,
                     Qt::KeyboardModifiers modifiers ,
                     States flags) const;

        bool operator==(const Entry& rhs) const;

    private:
        void insertModifier(QString& item , int modifier) const;
        void insertState(QString& item , int state) const;
        QByteArray unescape(const QByteArray& text) const;

        int _keyCode;
        Qt::KeyboardModifiers _modifiers;
        Qt::KeyboardModifiers _modifierMask;
        States _state;
        States _stateMask;

        Command _command;
        QByteArray _text;
    };

    explicit KeyboardTranslator(const QString& name);

    //KeyboardTranslator(const KeyboardTranslator& other);

    QString name() const;

    void setName(const QString& name);

    QString description() const;

    void setDescription(const QString& description);

    Entry findEntry(int keyCode ,
                    Qt::KeyboardModifiers modifiers ,
                    States state = NoState) const;

    void addEntry(const Entry& entry);

    void replaceEntry(const Entry& existing , const Entry& replacement);

    void removeEntry(const Entry& entry);

    QList<Entry> entries() const;

private:
    // All entries in this translator, indexed by their keycode
    QMultiHash<int, Entry> _entries;

    QString _name;
    QString _description;
};
Q_DECLARE_OPERATORS_FOR_FLAGS(KeyboardTranslator::States)
Q_DECLARE_OPERATORS_FOR_FLAGS(KeyboardTranslator::Commands)

class FallbackKeyboardTranslator : public KeyboardTranslator
{
public:
    FallbackKeyboardTranslator();
};

class KeyboardTranslatorReader
{
public:
    explicit KeyboardTranslatorReader(QIODevice* source);

    QString description() const;

    bool hasNextEntry();
    KeyboardTranslator::Entry nextEntry();

    bool parseError();

    static KeyboardTranslator::Entry createEntry(const QString& condition ,
            const QString& result);
private:
    struct Token {
        enum Type {
            TitleKeyword,
            TitleText,
            KeyKeyword,
            KeySequence,
            Command,
            OutputText
        };
        Type type;
        QString text;
    };
    QList<Token> tokenize(const QString&);
    void readNext();
    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;
    QString _description;
    KeyboardTranslator::Entry _nextEntry;
    bool _hasNext;
};

class KeyboardTranslatorWriter
{
public:
    explicit KeyboardTranslatorWriter(QIODevice* destination);
    ~KeyboardTranslatorWriter();

    void writeHeader(const QString& description);
    void writeEntry(const KeyboardTranslator::Entry& entry);

private:
    QIODevice* _destination;
    QTextStream* _writer;
};

inline int KeyboardTranslator::Entry::keyCode() const
{
    return _keyCode;
}
inline void KeyboardTranslator::Entry::setKeyCode(int aKeyCode)
{
    _keyCode = aKeyCode;
}

inline void KeyboardTranslator::Entry::setModifiers(Qt::KeyboardModifiers modifier)
{
    _modifiers = modifier;
}
inline Qt::KeyboardModifiers KeyboardTranslator::Entry::modifiers() const
{
    return _modifiers;
}

inline void  KeyboardTranslator::Entry::setModifierMask(Qt::KeyboardModifiers mask)
{
    _modifierMask = mask;
}
inline Qt::KeyboardModifiers KeyboardTranslator::Entry::modifierMask() const
{
    return _modifierMask;
}

inline bool KeyboardTranslator::Entry::isNull() const
{
    return (*this == Entry());
}

inline void KeyboardTranslator::Entry::setCommand(Command aCommand)
{
    _command = aCommand;
}
inline KeyboardTranslator::Command KeyboardTranslator::Entry::command() const
{
    return _command;
}

inline void KeyboardTranslator::Entry::setText(const QByteArray& aText)
{
    _text = unescape(aText);
}
inline int oneOrZero(int value)
{
    return value ? 1 : 0;
}
inline QByteArray KeyboardTranslator::Entry::text(bool expandWildCards,
        Qt::KeyboardModifiers keyboardModifiers) const
{
    QByteArray expandedText = _text;

    if (expandWildCards) {
        int modifierValue = 1;
        modifierValue += oneOrZero(keyboardModifiers & Qt::ShiftModifier);
        modifierValue += oneOrZero(keyboardModifiers & Qt::AltModifier)     << 1;
        modifierValue += oneOrZero(keyboardModifiers & Qt::ControlModifier) << 2;

        for (int i = 0; i < _text.length(); i++) {
            if (expandedText[i] == '*')
                expandedText[i] = '0' + modifierValue;
        }
    }

    return expandedText;
}

inline void KeyboardTranslator::Entry::setState(States aState)
{
    _state = aState;
}
inline KeyboardTranslator::States KeyboardTranslator::Entry::state() const
{
    return _state;
}

inline void KeyboardTranslator::Entry::setStateMask(States aStateMask)
{
    _stateMask = aStateMask;
}
inline KeyboardTranslator::States KeyboardTranslator::Entry::stateMask() const
{
    return _stateMask;
}
}

Q_DECLARE_METATYPE(Konsole::KeyboardTranslator::Entry)
Q_DECLARE_METATYPE(const Konsole::KeyboardTranslator*)

#endif // KEYBOARDTRANSLATOR_H