okeyconfigmanager.cpp

Go to the documentation of this file.

#include "okeyconfigmanager.h"

#include "okeyconfigmanager_p.h"

namespace Opie {
namespace Core {
namespace Internal {
    /*
     * the virtual and hardware key events have both issues...
     */
    void fixupKeys( int& key, int &mod, QKeyEvent* e ) {
        key = e->key();
        mod = e->state();
       /*
        * virtual keyboard
        * else change the button mod only
        */
        if ( key == 0 ) {
            key = e->ascii();
            if (  key > 96 && key < 123)
                key -=  32;
        }else{
            int new_mod = 0;
            if ( mod & 256 )
                new_mod |= Qt::ShiftButton;
            else if ( mod & 512 )
                new_mod |= Qt::ControlButton;
            else if ( mod & 1024 )
                new_mod |= Qt::AltButton;

            mod = new_mod == 0? mod : new_mod;
        }
    }
}

OKeyPair::OKeyPair( int key, int mod )
    : m_key( key ), m_mod( mod )
{}

OKeyPair::~OKeyPair() {}


bool OKeyPair::isEmpty()const {
    return ( ( m_key == -1 )&& ( m_mod == -1 ) );
}

int OKeyPair::keycode()const {
    return m_key;
}

int OKeyPair::modifier()const {
    return m_mod;
}


void OKeyPair::setKeycode( int key ) {
    m_key = key;
}

void OKeyPair::setModifier( int mod ) {
    m_mod = mod;
}

OKeyPair OKeyPair::returnKey() {
    return OKeyPair( Qt::Key_Return, 0 );
}

OKeyPair OKeyPair::leftArrowKey() {
    return OKeyPair( Qt::Key_Left, 0 );
}

OKeyPair OKeyPair::rightArrowKey() {
    return OKeyPair( Qt::Key_Right, 0 );
}

OKeyPair OKeyPair::upArrowKey() {
    return OKeyPair( Qt::Key_Up, 0 );
}

OKeyPair OKeyPair::downArrowKey() {
    return OKeyPair( Qt::Key_Down, 0 );
}

OKeyPair OKeyPair::emptyKey() {
    return OKeyPair();
}

OKeyPair::List OKeyPair::hardwareKeys() {
    const QValueList<Opie::Core::ODeviceButton> but = Opie::Core::ODevice::inst()->buttons();
    OKeyPair::List lst;

    for ( QValueList<Opie::Core::ODeviceButton>::ConstIterator it = but.begin();
          it != but.end(); ++it )
        lst.append( OKeyPair( (*it).keycode(), 0 ) );


    return lst;
}

bool OKeyPair::operator==( const OKeyPair& pair)const {
    if ( m_key != pair.m_key ) return false;
    if ( m_mod != pair.m_mod ) return false;

    return true;
}

bool OKeyPair::operator!=( const OKeyPair& pair)const  {
    return !(*this == pair);
}


OKeyConfigItem::OKeyConfigItem( const QString& text, const QCString& config_key,
                                const QPixmap& pix, int id, const OKeyPair& def,
                                QObject *caller,
                                const char* slot )
    : m_text( text ), m_config( config_key ), m_pix( pix ),
      m_id( id ), m_def( def ),
      m_obj( caller ), m_str( slot ) {}

OKeyConfigItem::OKeyConfigItem( const Opie::Core::ODeviceButton& b )
    : m_text( b.userText() ), m_pix( b.pixmap() ), m_id( -1 ),
      m_key( OKeyPair( b.keycode(), 0 ) ), m_def( OKeyPair( b.keycode(), 0 ) )
{}


OKeyConfigItem::~OKeyConfigItem() {}


QString OKeyConfigItem::text()const {
    return m_text;
}

QPixmap OKeyConfigItem::pixmap()const {
    return m_pix;
}

OKeyPair OKeyConfigItem::keyPair()const {
    return m_key;
}

OKeyPair OKeyConfigItem::defaultKeyPair()const {
    return m_def;
}


int OKeyConfigItem::id()const{
    return m_id;
}

QCString OKeyConfigItem::configKey()const {
    return m_config;
}

QObject* OKeyConfigItem::object()const{
    return m_obj;
}

QCString OKeyConfigItem::slot()const {
    return m_str;
}

void OKeyConfigItem::setText( const QString& text ) {
    m_text = text;
}

void OKeyConfigItem::setPixmap( const QPixmap& pix ) {
    m_pix = pix;
}

void OKeyConfigItem::setKeyPair( const OKeyPair& key) {
    m_key = key;
}

void OKeyConfigItem::setDefaultKeyPair( const OKeyPair& key ) {
    m_def = key;
}

void OKeyConfigItem::setConfigKey( const QCString& str) {
    m_config = str;
    m_config.detach();
}

void OKeyConfigItem::setId( int id ) {
    m_id = id;
}

bool OKeyConfigItem::isEmpty()const {
    if ( !m_def.isEmpty()  ) return false;
    if ( !m_key.isEmpty()  ) return false;
    if ( !m_text.isEmpty() ) return false;
    if ( m_id != -1       ) return false;

    return true;
}

bool OKeyConfigItem::operator==( const OKeyConfigItem& conf )const {
/*    if ( isEmpty() == conf.isEmpty() ) return true;
    else if ( isEmpty() != conf.isEmpty() ) return false;
    else if ( !isEmpty()!= conf.isEmpty() ) return false;
*/

    if ( m_id != conf.m_id )     return false;
    if ( m_obj != conf.m_obj )   return false;
    if ( m_text != conf.m_text ) return false;
    if ( m_key != conf.m_key )   return false;
    if ( m_def != conf.m_def )   return false;



    return true;

}

bool OKeyConfigItem::operator!=( const OKeyConfigItem& conf )const {
    return !( *this == conf );
}

OKeyConfigManager::OKeyConfigManager( Opie::Core::OConfig* conf,
                                      const QString& group,
                                      const OKeyPair::List& black,
                                      bool grabkeyboard, QObject* par,
                                      const char* name)
    : QObject( par, name ), m_conf( conf ), m_group( group ),
      m_blackKeys( black ), m_grab( grabkeyboard ), m_map( 0 ){
    if ( m_grab )
        QPEApplication::grabKeyboard();
    m_event_mask = OKeyConfigManager::MaskReleased;
}


OKeyConfigManager::~OKeyConfigManager() {
    if ( m_grab )
        QPEApplication::ungrabKeyboard();
    delete m_map;
}

void OKeyConfigManager::load() {
    Opie::Core::OConfigGroupSaver grp( m_conf, m_group );

    /*
     * Read each item
     */
    int key, mod;
    for( OKeyConfigItem::List::Iterator it = m_keys.begin(); it != m_keys.end(); ++it ) {
        key = m_conf->readNumEntry( (*it).configKey()+"key",
                                    (*it).defaultKeyPair().keycode()  );
        mod = m_conf->readNumEntry( (*it).configKey()+"mod",
                                    (*it).defaultKeyPair().modifier() );
        OKeyPair okey( key, mod );

        if (  !m_blackKeys.contains( okey ) && key != -1  && mod != -1 )
            (*it).setKeyPair( okey );
        else
            (*it).setKeyPair( OKeyPair::emptyKey() );
    }
    delete m_map; m_map = 0;
}

void OKeyConfigManager::save() {
    Opie::Core::OConfigGroupSaver grp( m_conf, m_group );

    /*
     * Write each item
     */
    for( OKeyConfigItem::List::Iterator it = m_keys.begin();it != m_keys.end(); ++it ) {
        /* skip empty items */
        if ( (*it).isEmpty() )
            continue;
        OKeyPair pair = (*it).keyPair();
        OKeyPair deft = (*it).defaultKeyPair();
        /*
         * don't write if it is the default setting
         * FIXME allow to remove Keys from config
        if (  (pair.keycode() == deft.keycode()) &&
              (pair.modifier()== deft.modifier() ) )
            return;
        */

        m_conf->writeEntry((*it).configKey()+"key", pair.keycode()  );
        m_conf->writeEntry((*it).configKey()+"mod", pair.modifier() );
    }
    m_conf->write();
}

OKeyConfigItem OKeyConfigManager::handleKeyEvent( QKeyEvent* e ) {
   /*
    * Fix Up issues with Qt/E, my keybard, and virtual input
    * methods
    * First my Keyboard delivers 256,512,1024 for shift/ctrl/alt instead of the button state
    * Also key() on virtual inputmethods are zero and only ascii. We need to fix upper and lower
    * case ascii
    */
    int key, mod;
    Opie::Core::Internal::fixupKeys( key, mod, e );

    OKeyConfigItem::List _keyList =  keyList( key );
    if ( _keyList.isEmpty() )
        return OKeyConfigItem();

    OKeyConfigItem item;
    for ( OKeyConfigItem::List::Iterator it = _keyList.begin(); it != _keyList.end();
          ++it ) {
        if ( (*it).keyPair().modifier() == mod ) {
            item = *it;
            break;
        }

    }

    return item;
}

int OKeyConfigManager::handleKeyEventId( QKeyEvent* ev) {
    return handleKeyEvent( ev ).id();
}

void OKeyConfigManager::addKeyConfig( const OKeyConfigItem& item ) {
    m_keys.append( item );
    delete m_map; m_map = 0;
}

void OKeyConfigManager::removeKeyConfig( const OKeyConfigItem& item ) {
    m_keys.remove( item );
    delete m_map; m_map = 0;
}

void OKeyConfigManager::clearKeyConfig() {
    m_keys.clear();
    delete m_map; m_map = 0;
}

Opie::Core::OKeyConfigItem::List OKeyConfigManager::keyConfigList()const{
    return m_keys;
}

void OKeyConfigManager::addToBlackList( const OKeyPair& key) {
    m_blackKeys.append( key );
    delete m_map; m_map = 0;
}


void OKeyConfigManager::removeFromBlackList( const OKeyPair& key ) {
    m_blackKeys.remove( key );
    delete m_map; m_map = 0;
}


void OKeyConfigManager::clearBlackList() {
    m_blackKeys.clear();
    delete m_map; m_map = 0;
}


OKeyPair::List OKeyConfigManager::blackList()const {
    return m_blackKeys;
}


void OKeyConfigManager::handleWidget( QWidget* wid ) {
    wid->installEventFilter( this );
}

bool OKeyConfigManager::eventFilter( QObject* obj, QEvent* ev) {
    if ( !obj->isWidgetType() )
        return false;

    /*
     * check  if we care for the event
     */
    if ( (ev->type() != QEvent::KeyPress||!testEventMask(MaskPressed)) &&
        (ev->type() != QEvent::KeyRelease||!testEventMask(MaskReleased)) )
        return false;

    QKeyEvent *key = static_cast<QKeyEvent*>( ev );
    OKeyConfigItem item =  handleKeyEvent( key );

    if ( item.isEmpty() )
        return false;

    QWidget *wid = static_cast<QWidget*>( obj );

    if ( item.object() && !item.slot().isEmpty() ) {
        connect( this, SIGNAL( actionActivated(QWidget*, QKeyEvent*)),
                 item.object(), item.slot().data() );
        emit actionActivated(wid, key);
        disconnect( this, SIGNAL(actionActivated(QWidget*,QKeyEvent*)),
                    item.object(), item.slot().data() );
    }
    emit actionActivated( wid, key, item );

    return true;
}

OKeyConfigItem::List OKeyConfigManager::keyList( int keycode) {
   /*
    * Create the map if not existing anymore
    */
    if ( !m_map ) {
        m_map = new OKeyMapConfigPrivate;
        /* for every key */
        for ( OKeyConfigItem::List::Iterator it = m_keys.begin();
              it!= m_keys.end(); ++it ) {

            bool add = true;
            /* see if this key is blocked */
            OKeyPair pair = (*it).keyPair();
            for ( OKeyPair::List::Iterator pairIt = m_blackKeys.begin();
                  pairIt != m_blackKeys.end(); ++pairIt ) {
                if ( (*pairIt).keycode()  == pair.keycode() &&
                     (*pairIt).modifier() == pair.modifier() ) {
                    add = false;
                    break;
                }
            }
            /* check if we added it */
            if ( add )
                (*m_map)[pair.keycode()].append( *it );
        }
    }
    return (*m_map)[keycode];
}

}
}

---