KeyModifiers.cpp

Go to the documentation of this file.

#include "KeyModifiers.h"

KeyModifiers::KeyModifiers()
{
        qDebug("KeyModifiers::KeyModifiers()");
        m_pTimer = new QTimer(this);
        connect(m_pTimer, SIGNAL(timeout()),
                        this, SLOT(resetToggles()));
        init();
}

KeyModifiers::~KeyModifiers()
{
        qDebug("KeyModifiers::~KeyModifiers()");
        delete m_pTimer;
        clear();
}

void KeyModifiers::addType(const QString& type)
{
        if(m_types.contains(type) == false){
                qDebug("addType[%s][%x]", type.latin1(), m_bitmask);
                m_types.insert(type, m_bitmask);
                m_bitmask = m_bitmask << 1;
        }
}

ModifierInfo* KeyModifiers::assign(const QString& type, int keycode,
        int keymask, bool mode)
{
        m_info = new ModifierInfo(type, keycode, keymask, mode);
        addType(type);
        m_modifiers.append(m_info);
        if(mode){
                m_togglekeys.append(m_info);
        }
        assignRelease(m_info, keycode);
        return(m_info);
}

void KeyModifiers::assignRelease(int keycode)
{
        assignRelease(m_info, keycode);
}

void KeyModifiers::assignRelease(ModifierInfo* info, int keycode)
{
        if(m_releasekeys.contains(keycode) == false){
                m_releasekeys.insert(keycode, new ModifierList);
        }
        m_releasekeys[keycode]->append(info);
}

void KeyModifiers::setToggle()
{
        setToggle(m_info);
}

void KeyModifiers::setToggle(ModifierInfo* info)
{
        info->toggle_mode = true;
        m_togglekeys.append(info);
}

void KeyModifiers::keepToggles()
{
        if(m_timeout > 0){
                m_pTimer->start(m_timeout, true);
        }
}

bool KeyModifiers::pressKey(int keycode, int modifiers)
{
        int keymask;

        keymask = getState(modifiers, true);
        
        for(ModifierList::Iterator it=m_modifiers.begin();
                        it!=m_modifiers.end(); ++it){
                if((*it)->keycode == keycode
                        && ((*it)->keymask & keymask) == (*it)->keymask){
                        (*it)->pressed = true;
                        if((*it)->toggle_mode){
                                /* change toggle state */
                                (*it)->toggled = !((*it)->toggled);
                                if((*it)->toggled){
                                        keepToggles();
                                } else {
                                        m_pTimer->stop();
                                }
                        }
                        return(true);
                }
        }
        return(false);
}

bool KeyModifiers::isModifier(int keycode)
{
        if(keycode == Qt::Key_Shift
                || keycode == Qt::Key_Control
                || keycode == Qt::Key_Alt
                || keycode == Qt::Key_Meta
                || keycode == Qt::Key_F22){
                return(true);
        } else {
                return(false);
        }
}

void KeyModifiers::releaseKey(int keycode)
{
        if(m_releasekeys.contains(keycode)){
                ModifierList* list = m_releasekeys[keycode];
                for(ModifierList::Iterator it=(*list).begin();
                                it!=(*list).end(); ++it){
                        (*it)->pressed = false;
                }
        }
}

int KeyModifiers::getState()
{
        int state = 0;
        for(ModifierList::Iterator it=m_modifiers.begin();
                        it!=m_modifiers.end(); ++it){
                if((*it)->pressed || (*it)->toggled){
                        state |= m_types[(*it)->type];
                }
        }
        return(state);
}

int KeyModifiers::getState(int modifiers, bool reset)
{
        int state = getState();
        int mask;

        mask = getMask("Shift");
        if(modifiers & Qt::ShiftButton){
                state |= mask;
        } else {
                if(reset){
                        state &= ~mask;
                }
        }
        mask = getMask("Control");
        if(modifiers & Qt::ControlButton){
                state |= mask;
        } else {
                if(reset){
                        state &= ~mask;
                }
        }
        mask = getMask("Alt");
        if(modifiers & Qt::AltButton){
                state |= mask;
        } else {
                if(reset){
                        state &= ~mask;
                }
        }

        return(state);
}

int KeyModifiers::getModifiers(int modifiers)
{
        int state = getState();

        if(state & getMask("Shift")){
                modifiers |= Qt::ShiftButton;
        }
        if(state & getMask("Control")){
                modifiers |= Qt::ControlButton;
        }
        if(state & getMask("Alt")){
                modifiers |= Qt::AltButton;
        }

        return(modifiers);
}

int KeyModifiers::getMask(const QString& type)
{
        if(m_types.contains(type)){
                return(m_types[type]);
        } else {
                return(0);
        }
}

void KeyModifiers::clear()
{
        m_types.clear();

        m_togglekeys.clear();

        for(ModifierList::Iterator it=m_modifiers.begin();
                        it!=m_modifiers.end(); ++it){
                delete *it;
        }
        m_modifiers.clear();

        for(QMap<int, ModifierList*>::Iterator it=m_releasekeys.begin();
                        it!=m_releasekeys.end(); ++it){
                delete *it;
        }
        m_releasekeys.clear();
}

void KeyModifiers::init()
{
        m_bitmask = 0x00000001;
        addType("Shift");
        addType("Control");
        addType("Alt");

        ConfigEx& cfg = ConfigEx::getInstance("keyhelper");

        cfg.setGroup("Global");

        QString timeout = cfg.readEntry("ToggleTimeout", "10");
        int msec = timeout.toInt();
        msec *= 1000; /* sec to msec */
        m_timeout = msec;
}

void KeyModifiers::reset()
{
        clear();
        init();
}

bool KeyModifiers::isToggled()
{
        for(ModifierList::Iterator it=m_togglekeys.begin();
                        it!=m_togglekeys.end(); ++it){
                if((*it)->toggled){
                        return(true);
                }
        }
        return(false);
}

void KeyModifiers::resetToggles()
{
        for(ModifierList::Iterator it=m_togglekeys.begin();
                        it!=m_togglekeys.end(); ++it){
                (*it)->toggled = false;
        }
        m_pTimer->stop();
}

void KeyModifiers::resetStates()
{
        for(ModifierList::Iterator it=m_modifiers.begin();
                        it!=m_modifiers.end(); ++it){
                (*it)->pressed = false;
        }
        resetToggles();
}

void KeyModifiers::statistics()
{
        qWarning("KeyModifiers::statistics()");
        for(ModifierList::Iterator it=m_modifiers.begin();
                        it!=m_modifiers.end(); ++it){
                qWarning(" [%s][%x][%x][%d][%d]",
                        (*it)->type.latin1(),
                        (*it)->keycode,
                        (*it)->keymask,
                        (*it)->pressed,
                        (*it)->toggled);
                for(QMap<int, ModifierList*>::Iterator it2=m_releasekeys.begin();
                                it2!=m_releasekeys.end(); ++it2){
                        for(ModifierList::Iterator it3=(*it2)->begin();
                                        it3!=(*it2)->end(); ++it3){
                                if(*it == *it3){
                                        qWarning("  release[%x]", it2.key());
                                }
                        }
                }
        }
}

---