Split the KeyConfig Manager and Widget into Ui and Core parts

Adjust the only user...
Don't add a 2nd example to core but mention the one for the classes
in opieui/okeyconfigwidget

17 files changed, 1046 insertions, 1005 deletions

diff --git a/libopie2/examples/opiecore/okeyconfigmanager/README b/libopie2/examples/opiecore/okeyconfigmanager/README
new file mode 100644
index 0000000..327b7c2
--- a/dev/null
+++ b/libopie2/examples/opiecore/okeyconfigmanager/README
@@ -0,0 +1 @@
+See opieui/okeyconfigwidget for an example of possible usage
\ No newline at end of file
diff --git a/libopie2/examples/opieui/okeyconfigwidget/testwidget.cpp b/libopie2/examples/opieui/okeyconfigwidget/testwidget.cpp
index 10b52f9..5c7bac2 100644
--- a/libopie2/examples/opieui/okeyconfigwidget/testwidget.cpp
+++ b/libopie2/examples/opieui/okeyconfigwidget/testwidget.cpp
@@ -28,9 +28,9 @@ public:
     ~MainWindow() {}
 private slots:
     void slotClicked();
 private:
-    Opie::Ui::OKeyConfigManager *m_manager;
+    Opie::Core::OKeyConfigManager *m_manager;
 };
 
 
 OPIE_EXPORT_APP(  Opie::Core::OApplicationFactory<MainWindow> )
@@ -75,25 +75,25 @@ TestMainWindow::TestMainWindow( QWidget* parent, const char* slot, WFlags fl )
 
     m_config  = new Opie::Core::OConfig( "test_config_foo" );
 
     /* generate the black list */
-    Opie::Ui::OKeyPair::List blackList;
-    blackList.append( Opie::Ui::OKeyPair::leftArrowKey() );
-    blackList.append( Opie::Ui::OKeyPair::rightArrowKey() );
-    blackList.append( Opie::Ui::OKeyPair::downArrowKey() );
-    blackList.append( Opie::Ui::OKeyPair::upArrowKey() );
+    Opie::Core::OKeyPair::List blackList;
+    blackList.append( Opie::Core::OKeyPair::leftArrowKey() );
+    blackList.append( Opie::Core::OKeyPair::rightArrowKey() );
+    blackList.append( Opie::Core::OKeyPair::downArrowKey() );
+    blackList.append( Opie::Core::OKeyPair::upArrowKey() );
 
-    m_manager = new Opie::Ui::OKeyConfigManager( m_config, "Key Group",
+    m_manager = new Opie::Core::OKeyConfigManager( m_config, "Key Group",
                                                  blackList, false, this, "Key Manager" );
 
-    m_manager->addKeyConfig( Opie::Ui::OKeyConfigItem( tr( "Delete Action" ), "delete_key", QPixmap(),
-                                                       10, Opie::Ui::OKeyPair( Qt::Key_D, Qt::ShiftButton ), this,
+    m_manager->addKeyConfig( Opie::Core::OKeyConfigItem( tr( "Delete Action" ), "delete_key", QPixmap(),
+                                                       10, Opie::Core::OKeyPair( Qt::Key_D, Qt::ShiftButton ), this,
                                                        SLOT(slotDelete(QWidget*,QKeyEvent*)) ) );
-    m_manager->addKeyConfig( Opie::Ui::OKeyConfigItem( tr( "Show Action" ), "show_key", QPixmap(),
-                                                       11, Opie::Ui::OKeyPair( Qt::Key_S, Qt::AltButton ) ) );
+    m_manager->addKeyConfig( Opie::Core::OKeyConfigItem( tr( "Show Action" ), "show_key", QPixmap(),
+                                                       11, Opie::Core::OKeyPair( Qt::Key_S, Qt::AltButton ) ) );
 
-    connect(m_manager, SIGNAL(actionActivated(QWidget*,QKeyEvent*,const Opie::Ui::OKeyConfigItem&)),
-            this, SLOT(slotAction(QWidget*, QKeyEvent*, const Opie::Ui::OKeyConfigItem&)) );
+    connect(m_manager, SIGNAL(actionActivated(QWidget*,QKeyEvent*,const Opie::Core::OKeyConfigItem&)),
+            this, SLOT(slotAction(QWidget*, QKeyEvent*, const Opie::Core::OKeyConfigItem&)) );
 // when commenting the line below out the keyPressEvent will work
     m_manager->handleWidget( this );
     m_manager->load();
 }
@@ -102,9 +102,9 @@ TestMainWindow::~TestMainWindow() {
     m_manager->save();
     delete m_config;
 }
 
-Opie::Ui::OKeyConfigManager* TestMainWindow::manager() {
+Opie::Core::OKeyConfigManager* TestMainWindow::manager() {
     return m_manager;
 }
 
 /*
@@ -120,9 +120,9 @@ void TestMainWindow::keyPressEvent( QKeyEvent* ev ) {
 void TestMainWindow::slotDelete( QWidget* wid, QKeyEvent* ev ) {
     qWarning( "Slot Delete %d %d %d", wid, ev->key(), ev->state() );
 }
 
-void TestMainWindow::slotAction( QWidget* wid, QKeyEvent* ev, const Opie::Ui::OKeyConfigItem& item) {
+void TestMainWindow::slotAction( QWidget* wid, QKeyEvent* ev, const Opie::Core::OKeyConfigItem& item) {
     qWarning( "Slot Action %d %d %d %s %d", wid, ev->key(), ev->state(), item.text().latin1(),  item.id() );
 }
 
 #include "testwidget.moc"
diff --git a/libopie2/examples/opieui/okeyconfigwidget/testwidget.h b/libopie2/examples/opieui/okeyconfigwidget/testwidget.h
index b95c225..6ecb346 100644
--- a/libopie2/examples/opieui/okeyconfigwidget/testwidget.h
+++ b/libopie2/examples/opieui/okeyconfigwidget/testwidget.h
@@ -7,14 +7,14 @@
 
 namespace Opie{
 namespace Ui{
     class OTabWidget;
-    class OKeyConfigManager;
     class OListView;
-    class OKeyConfigItem;
 }
 namespace Core {
     class OConfig;
+    class OKeyConfigManager;
+    class OKeyConfigItem;
 }
 }
 class QKeyEvent;
 
@@ -25,16 +25,16 @@ public:
 
     TestMainWindow(QWidget* parent, const char*, WFlags fl );
     ~TestMainWindow();
 
-    Opie::Ui::OKeyConfigManager *manager();
+    Opie::Core::OKeyConfigManager *manager();
 protected:
     void keyPressEvent( QKeyEvent* );
 private slots:
     void slotDelete( QWidget*, QKeyEvent* );
-    void slotAction( QWidget*, QKeyEvent*, const Opie::Ui::OKeyConfigItem& );
+    void slotAction( QWidget*, QKeyEvent*, const Opie::Core::OKeyConfigItem& );
 private:
     Opie::Core::OConfig *m_config;
-    Opie::Ui::OKeyConfigManager *m_manager;
+    Opie::Core::OKeyConfigManager *m_manager;
 };
 
 #endif
diff --git a/libopie2/opiecore/okeyconfigmanager.cpp b/libopie2/opiecore/okeyconfigmanager.cpp
new file mode 100644
index 0000000..e6055e0
--- a/dev/null
+++ b/libopie2/opiecore/okeyconfigmanager.cpp
@@ -0,0 +1,733 @@
+#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;
+        }
+    }
+}
+
+/**
+ * The default Constructor of a OKeyPair.
+ * A Key and a Modifier ( Alt/Shift/Ctrl )
+ * needs to be supplied.
+ * Use Qt::Key for the information.
+ * The default arguments  create an Empty OKeyPair. If you
+ * want to get an empty OKeyPair use the static method for getting
+ * the emptyKey()
+ *
+ * @see OKeyPair OKeyPair::emptyKey()
+ */
+OKeyPair::OKeyPair( int key, int mod )
+    : m_key( key ), m_mod( mod )
+{}
+
+/**
+ * The destructor
+ */
+OKeyPair::~OKeyPair() {}
+
+
+/**
+ * Is this OKeyPair empty/valid?
+ */
+bool OKeyPair::isEmpty()const {
+    return ( ( m_key == -1 )&& ( m_mod == -1 ) );
+}
+
+/**
+ * get the keycode for this OKeyPair. The Key relates to Qt::Key.
+ *
+ * @see Qt::Key
+ * @see setKey
+ */
+int OKeyPair::keycode()const {
+    return m_key;
+}
+
+/**
+ * get the modifier key for this OKeyPair. The Modifier State relates
+ * to the Qt::ButtonState
+ *
+ * @see Qt::ButtonState
+ * @see setModifier
+ */
+int OKeyPair::modifier()const {
+    return m_mod;
+}
+
+
+/**
+ * Set the keycode
+ * @param key The Keycode to set
+ *
+ * @see keycode()
+ * @see Qt::Key
+ */
+void OKeyPair::setKeycode( int key ) {
+    m_key = key;
+}
+
+/**
+ * Set the modifier key
+ *
+ * @param the Modifier key
+ * @see Qt::ButtonState
+ * @see modifier()
+ */
+void OKeyPair::setModifier( int mod ) {
+    m_mod = mod;
+}
+
+/**
+ * Return  an OKeyPair for the Return Key without any modifier.
+ */
+OKeyPair OKeyPair::returnKey() {
+    return OKeyPair( Qt::Key_Return, 0 );
+}
+
+/**
+ * Return an OKeyPair for the Left Arrow Key
+ * without any modifier Key
+ */
+OKeyPair OKeyPair::leftArrowKey() {
+    return OKeyPair( Qt::Key_Left, 0 );
+}
+
+/**
+ * Return an OKeyPair for the Right Arrow Key
+ * without any modifier Key
+ */
+OKeyPair OKeyPair::rightArrowKey() {
+    return OKeyPair( Qt::Key_Right, 0 );
+}
+
+/**
+ * Return an OKeyPair for the Up Arrow Key
+ * without any modifier Key
+ */
+OKeyPair OKeyPair::upArrowKey() {
+    return OKeyPair( Qt::Key_Up, 0 );
+}
+
+/**
+ * Return an OKeyPair for the Down Arrow Key
+ * without any modifier Key
+ */
+OKeyPair OKeyPair::downArrowKey() {
+    return OKeyPair( Qt::Key_Down, 0 );
+}
+
+/**
+ * Return an Empty OKeyPair
+ */
+OKeyPair OKeyPair::emptyKey() {
+    return OKeyPair();
+}
+
+/**
+ * This functions uses the Opie::Core::ODevice::buttons
+ * for OKeyPairList
+ *
+ * @see Opie::Core::ODevice
+ * @see Opie::Core::ODeviceButton
+ * @see Opie::Core::ODevice::button
+ */
+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;
+}
+
+/**
+ * Equals operator. Check if two OKeyPairs have the same key and modifier
+ * @see operator!=
+ */
+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;
+}
+
+/**
+ * Not equal operator. calls the equal operator internally
+ */
+bool OKeyPair::operator!=( const OKeyPair& pair)const  {
+    return !(*this == pair);
+}
+
+
+/**
+ * The normal Constructor  to create a OKeyConfigItem
+ *
+ * You can set the the key paramater of this item but if
+ * you use this item with the OKeyConfigManager your setting
+ * will be overwritten.
+ * You can also specify a QObject and slot which sould get called
+ * once this item is activated. This slot only works if you
+ * use the OKeyConfigManager.
+ * The actual Key is read by load()
+ *
+ * \code
+ * void MySlot::create(){
+ *    OKeyConfigItem item(tr("Delete"),"delete",Resource::loadPixmap("trash"),
+ *                        123, OKeyPair(Qt::Key_D,Qt::ControlButton),
+ *                        this,SLOT(slotDelete(QWidget*,QKeyEvent*)));
+ * }
+ * \endcode
+ *
+ * @param text The text exposed to the user
+ * @param config_key The key used in the config
+ * @param pix A Pixmap associated  with this Item
+ * @param def The OKeyPair used as default
+ * @param caller The object where the slot exists
+ * @param slot The slot which should get called
+ *
+ */
+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 ) {}
+
+/**
+ * A special Constructor for converting from an Opie::Core::ODeviceButton
+ * delivered by Opie::Core::ODevice::buttons()
+ * There is no Config Key set and both default key and key are set
+ * to Opie::Core::ODeviceButton::keycode() and 0 to modifier
+ *
+ * @see Opie::Core::ODevice
+ * @see Opie::Core::ODeviceButton
+ * @see Opie::Core::ODevice::buttons()
+ */
+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 ) )
+{}
+
+
+/**
+ * Destructor
+ */
+OKeyConfigItem::~OKeyConfigItem() {}
+
+
+/**
+ * The text exposed to the user
+ *
+ * @see setText
+ */
+QString OKeyConfigItem::text()const {
+    return m_text;
+}
+
+/**
+ * The pixmap shown to the user for your action/key
+ *
+ * @see setPixmap
+ */
+QPixmap OKeyConfigItem::pixmap()const {
+    return m_pix;
+}
+
+/**
+ * Return the OKeyPair this OKeyConfigItem is configured for.
+ *
+ * @see setKeyPair
+ */
+OKeyPair OKeyConfigItem::keyPair()const {
+    return m_key;
+}
+
+/**
+ * Return the default OKeyPair
+ * @see setDefaultKeyPair
+ */
+OKeyPair OKeyConfigItem::defaultKeyPair()const {
+    return m_def;
+}
+
+
+/**
+ * Return the Id you assigned to this item.
+ * setting is only possible by the constructor
+ */
+int OKeyConfigItem::id()const{
+    return m_id;
+}
+
+/**
+ * reutrn the Config Key. Setting it is only possible
+ * by the constructor
+ */
+QCString OKeyConfigItem::configKey()const {
+    return m_config;
+}
+
+/**
+ * @internal
+ */
+QObject* OKeyConfigItem::object()const{
+    return m_obj;
+}
+
+/**
+ * @internal
+ */
+QCString OKeyConfigItem::slot()const {
+    return m_str;
+}
+
+/**
+ * Set the text
+ *
+ * @param text Set the Text of this Action to text
+ * @see text()
+ */
+void OKeyConfigItem::setText( const QString& text ) {
+    m_text = text;
+}
+
+/**
+ * Set the pixmap of this action
+ *
+ * @param pix The Pixmap to set
+ * @see pixmap()
+ */
+void OKeyConfigItem::setPixmap( const QPixmap& pix ) {
+    m_pix = pix;
+}
+
+/**
+ * Set the KeyPair the OKeyConfigItem uses.
+ * Your set Key could get overwritten if you use
+ * the manager or GUI to configure the key
+ *
+ * @param key Set the OKeyPair used
+ * @see keyPair()
+ */
+void OKeyConfigItem::setKeyPair( const OKeyPair& key) {
+    m_key = key;
+}
+
+/**
+ * Set the default KeyPair.
+ *
+ * @param key The default keypair
+ * @see defaultKeyPair()
+ */
+void OKeyConfigItem::setDefaultKeyPair( const OKeyPair& key ) {
+    m_def = key;
+}
+
+/**
+ * @internal
+ */
+void OKeyConfigItem::setConfigKey( const QCString& str) {
+    m_config = str;
+    m_config.detach();
+}
+
+/**
+ * @internal
+ */
+void OKeyConfigItem::setId( int id ) {
+    m_id = id;
+}
+
+/**
+ * If the item is not configured isEmpty() will return true
+ * It is empty if no text is present and no default
+ * and no configured key
+ */
+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;
+}
+
+/**
+ * Check if the KeyPairs are the same
+ */
+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 );
+}
+
+/**
+ * \brief c'tor
+ * The Constructor for a OKeyConfigManager
+ *
+ * You can use this manager in multiple ways. Either make it handle
+ * QKeyEvents
+ *
+ * \code
+ * Opie::Core::Config conf = oApp->config();
+ * Opie::Core::OKeyPairList blackList;
+ * blackList.append(Opie::Core::OKeyPair::leftArrowKey());
+ * blackList.append(Opie::Core::OKeyPair::rightArrowKey());
+ * Opie::Core::OKeyConfigManager *manager = new Opie::Core::OKeyConfigManager(conf,"key_actions",blackList,
+ *                                                                        false);
+ * QListView *view = new QListView();
+ * manager->handleWidget(view);
+ * manager->addKeyConfig( Opie::Core::OKeyPair::returnKey());
+ * manager->load();
+ *
+ * connect(manager,SIGNAL(actionActivated(QWidget*,QKeyEvent*,const Opie::Core::OKeyConfigItem&)),
+ *         this,SLOT(slotHandleKey(QWidget*,QKeyEvent*,const Opie::Core::OKeyConfigItem&)));
+ *
+ * ....
+ *
+ * void update(){
+ *  QDialog diag(true);
+ *  QHBoxLayout *lay = new QHBoxLayout(&diag);
+ *  Opie::Ui::OKeyConfigWidget *wid = new Opie::Ui::OKeyConfigWidget(manager,&diag);
+ *  wid->setChangeMode(Opie::Ui::OKeyConfigWidget::Queu);
+ *  lay->addWidget(wid);
+ *  if(QPEApplication::execDialog( &diag)== QDialog::Accepted){
+ *        wid->save();
+ *  }
+ * }
+ *
+ * ....
+ * MyListView::keyPressEvent( QKeyEvent* e ){
+ *     Opie::Ui::OKeyConfigItem item = manager->handleKeyEvent(e);
+ *     if(!item.isEmpty() ){
+ *         switch(item.id()){
+ *           case My_Delete_Key:
+ *             break;
+ *         }
+ *     }
+ * }
+ *
+ * \endcode
+ *
+ * @param conf The Config where the KeySetting should be stored
+ * @param group The group where the KeySetting will be stored
+ * @param black Which keys shouldn't be allowed to handle
+ * @param grabkeyboard Calls QPEApplication::grabKeyboard to allow handling of DeviceButtons
+ * @param par The parent/owner of this manager
+ * @param name The name of this object
+ */
+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();
+}
+
+
+/**
+ * Destructor
+ */
+OKeyConfigManager::~OKeyConfigManager() {
+    if ( m_grab )
+        QPEApplication::ungrabKeyboard();
+}
+
+/**
+ * Load the Configuration  from the OConfig
+ * If a Key is restricted but was in the config we will
+ * make it be the empty key paur
+ * We will change the group but restore to the previous.
+ *
+ * @see OKeyPair::emptyKey
+ */
+void OKeyConfigManager::load() {
+    Opie::Core::OConfigGroupSaver( 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( OKeyPair(key, mod) );
+        else
+            (*it).setKeyPair( OKeyPair::emptyKey() );
+    }
+    delete m_map; m_map = 0;
+}
+
+/**
+ * We will save the current configuration
+ * to the OConfig. We will change the group but restore
+ * to the previous
+ */
+void OKeyConfigManager::save() {
+    Opie::Core::OConfigGroupSaver( 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();
+}
+
+/**
+ * This is function uses a QMap internally  but you can have the same keycode
+ * with different modifier key. The behaviour is undefined if you add a OKeyConfigItem
+ * with same keycode and modifier key. The GUI takes care that a user can't
+ * cofigure two keys.
+ *
+ * Make sure you call e->ignore if you don't want to handle this event
+ */
+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;
+}
+
+/**
+ * Return the associated id of the item or -1 if no item
+ * matched the key
+ *
+ * @see handleKeyEvent
+ */
+int OKeyConfigManager::handleKeyEventId( QKeyEvent* ev) {
+    return handleKeyEvent( ev ).id();
+}
+
+/**
+ * Add Key Config to the List of items
+ */
+void OKeyConfigManager::addKeyConfig( const OKeyConfigItem& item ) {
+    m_keys.append( item );
+    delete m_map; m_map = 0;
+}
+
+/**
+ * Remove the Key from the Config. Internal lists will be destroyed
+ * and rebuild on demand later
+ */
+void OKeyConfigManager::removeKeyConfig( const OKeyConfigItem& item ) {
+    m_keys.remove( item );
+    delete m_map; m_map = 0;
+}
+
+/**
+ * Clears the complete list
+ */
+void OKeyConfigManager::clearKeyConfig() {
+    m_keys.clear();
+    delete m_map; m_map = 0;
+}
+
+/**
+ *
+ */
+Opie::Core::OKeyConfigItem::List OKeyConfigManager::keyConfigList()const{
+    return m_keys;
+}
+
+/**
+ * Add this OKeyPair to the blackList.
+ * Internal lists will be destroyed
+ */
+void OKeyConfigManager::addToBlackList( const OKeyPair& key) {
+    m_blackKeys.append( key );
+    delete m_map; m_map = 0;
+}
+
+
+/**
+ * Remove this OKeyPair from the black List
+ * Internal lists will be destroyed
+ */
+void OKeyConfigManager::removeFromBlackList( const OKeyPair& key ) {
+    m_blackKeys.remove( key );
+    delete m_map; m_map = 0;
+}
+
+
+/**
+ * Clear the blackList
+ */
+void OKeyConfigManager::clearBlackList() {
+    m_blackKeys.clear();
+    delete m_map; m_map = 0;
+}
+
+
+/**
+ * Return a copy of the blackList
+ */
+OKeyPair::List OKeyConfigManager::blackList()const {
+    return m_blackKeys;
+}
+
+
+/**
+ * Ask the Manager to handle KeyEvents for you.
+ * All handled keys will emit a QSignal and return true
+ * that it handled the keyevent
+ */
+void OKeyConfigManager::handleWidget( QWidget* wid ) {
+    wid->installEventFilter( this );
+}
+
+/**
+ * @internal
+ */
+bool OKeyConfigManager::eventFilter( QObject* obj, QEvent* ev) {
+    if ( !obj->isWidgetType() )
+        return false;
+
+    if ( ev->type() != QEvent::KeyPress && ev->type() != QEvent::KeyRelease )
+        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;
+}
+
+/**
+ * @internal
+ */
+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];
+}
+
+}
+}
diff --git a/libopie2/opiecore/okeyconfigmanager.h b/libopie2/opiecore/okeyconfigmanager.h
new file mode 100644
index 0000000..d610375
--- a/dev/null
+++ b/libopie2/opiecore/okeyconfigmanager.h
@@ -0,0 +1,205 @@
+/*
+ * Copyright (C) 2004
+ * LGPL v2  zecke@handhelds.org
+ */
+
+
+#ifndef ODP_KEY_MANAGER_WIDGET_H
+#define ODP_KEY_MANAGER_WIDGET_H
+
+#include <opie2/oconfig.h>
+#include <opie2/odevice.h>
+
+#include <qstring.h>
+#include <qpixmap.h>
+#include <qcstring.h>
+#include <qvaluelist.h>
+
+namespace Opie {
+namespace Core {
+
+/**
+ * \brief small class representing a Key with possible modifiers
+ * This class holds information about key code and possible
+ * modifier state. That is the lowest level of the key input
+ * functions.
+ * There are also static methods to get special keys.
+ * OKeyPair will be used with \see OKeyConfigItem
+ *
+ * @since 1.2
+ */
+class OKeyPair {
+public:
+    typedef QValueList<OKeyPair> List;
+    OKeyPair( int key = -1, int modifier = -1);
+    ~OKeyPair();
+
+    bool operator==( const OKeyPair& )const;
+    bool operator!=( const OKeyPair& )const;
+
+    bool isEmpty()const;
+
+    int keycode()const;
+    int modifier()const;
+
+    void setKeycode( int );
+    void setModifier( int );
+
+    static OKeyPair returnKey();
+    static OKeyPair leftArrowKey();
+    static OKeyPair rightArrowKey();
+    static OKeyPair upArrowKey();
+    static OKeyPair downArrowKey();
+    static OKeyPair emptyKey();
+    static OKeyPair::List hardwareKeys();
+
+private:
+    int m_key;
+    int m_mod;
+    class Private;
+    Private* d;
+};
+
+/**
+ * A class to represent an OKeyPair.
+ * It consists out of a Text exposed to the user, Config Key Item,
+ * Pixmap, A default OKeyPair and the set OKeyPair.
+ * You can also pass an id to it
+ *
+ * @since 1.1.2
+ */
+class OKeyConfigItem {
+    friend class OKeyConfigManager;
+public:
+    typedef QValueList<OKeyConfigItem> List;
+    OKeyConfigItem( const QString& text = QString::null , const QCString& config_key = QCString(),
+                    const QPixmap& symbol  = QPixmap(),
+                    int id = -1,
+                    const OKeyPair& def = OKeyPair::emptyKey(),
+                    QObject *caller = 0, const char* slot = 0);
+    OKeyConfigItem( const Opie::Core::ODeviceButton& );
+    ~OKeyConfigItem();
+
+    bool operator==( const OKeyConfigItem& )const;
+    bool operator!=( const OKeyConfigItem& )const;
+
+    QString text()const;
+    QPixmap pixmap()const;
+    int id()const;
+
+
+
+    OKeyPair keyPair()const;
+    OKeyPair defaultKeyPair()const;
+    QCString configKey()const;
+
+
+    void setText( const QString& text );
+    void setPixmap( const QPixmap& );
+    void setKeyPair( const OKeyPair& );
+    void setDefaultKeyPair( const OKeyPair& );
+
+    bool isEmpty()const;
+
+protected:
+    QObject *object()const;
+    QCString slot()const;
+    void setId( int id );
+    void setConfigKey( const QCString& );
+
+private:
+    QString  m_text;
+    QCString m_config;
+    QPixmap  m_pix;
+    int m_id;
+    OKeyPair m_key;
+    OKeyPair m_def;
+    QObject *m_obj;
+    QCString m_str;
+    class Private;
+    Private *d;
+};
+
+
+
+/**
+ * \brief A manager  to load and save Key Actions and get notified
+ * This is the Manager for KeyActions.
+ * You can say from which config and group to read data, to grab the
+ * keyboard to handle hardware keys, you can supply a blacklist of
+ * keys which should not be used by allowed to be used.
+ * You can even pass this manager to a Widget to do the configuration for you.
+ * You need to add OKeyConfigItem for your keys and then issue a load() to
+ * read the Key information.
+ * You can either handle the QKeyEvent yourself and ask this class if it is
+ * handled by your action and let give you the action. Or you can install
+ * the event filter and get a signal.
+ * You need to load ans save yourself!
+ *
+ * @since 1.1.2
+ */
+class OKeyConfigManager : public QObject {
+    Q_OBJECT
+    typedef QMap<int, OKeyConfigItem::List> OKeyMapConfigPrivate;
+public:
+    OKeyConfigManager(Opie::Core::OConfig *conf = 0,
+                      const QString& group = QString::null,
+                      const OKeyPair::List &block = OKeyPair::List(),
+                      bool grabkeyboard = false,  QObject * par = 0,
+                      const char* name = 0      );
+    ~OKeyConfigManager();
+
+    void load();
+    void save();
+
+    OKeyConfigItem handleKeyEvent( QKeyEvent* );
+    int            handleKeyEventId( QKeyEvent* );
+
+    void addKeyConfig( const OKeyConfigItem& );
+    void removeKeyConfig( const OKeyConfigItem& );
+    void clearKeyConfig();
+
+    void addToBlackList( const OKeyPair& );
+    void removeFromBlackList( const OKeyPair& );
+    void clearBlackList();
+    OKeyPair::List blackList()const;
+
+    void handleWidget( QWidget* );
+
+    bool eventFilter( QObject*, QEvent* );
+
+    OKeyConfigItem::List keyConfigList()const;
+signals:
+    /**
+     * The Signals are triggered on KeyPress and KeyRelease!
+     * You can check the isDown of the QKeyEvent
+     * @see QKeyEvent
+     */
+    void actionActivated( QWidget*, QKeyEvent*, const Opie::Core::OKeyConfigItem& );
+
+    /**
+     * This Signal correspondents to the OKeyConfigItem slot
+     * and object
+     *
+     * @see OKeyConfigItem::slot
+     * @see OKeyConfigItem::object
+     */
+    void actionActivated( QWidget* par, QKeyEvent* key);
+
+private:
+    OKeyConfigItem::List keyList( int );
+    OKeyConfigItem::List m_keys;
+    QValueList<QWidget*> m_widgets;
+    Opie::Core::OConfig *m_conf;
+    QString m_group;
+    OKeyPair::List m_blackKeys;
+    bool m_grab : 1;
+    OKeyMapConfigPrivate *m_map;
+    class Private;
+    Private *d;
+};
+
+}
+}
+
+#endif
diff --git a/libopie2/opiecore/okeyconfigmanager_p.h b/libopie2/opiecore/okeyconfigmanager_p.h
new file mode 100644
index 0000000..0fe1056
--- a/dev/null
+++ b/libopie2/opiecore/okeyconfigmanager_p.h
@@ -0,0 +1,9 @@
+
+namespace Opie {
+namespace Core {
+namespace Internal {
+void fixupKeys( int&, int&, QKeyEvent* );
+}
+}
+}
+
diff --git a/libopie2/opiecore/opiecore.pro b/libopie2/opiecore/opiecore.pro
index ae0af77..171bb0c 100644
--- a/libopie2/opiecore/opiecore.pro
+++ b/libopie2/opiecore/opiecore.pro
@@ -5,8 +5,9 @@ HEADERS     = oapplication.h            \
               oconfig.h                 \
               odebug.h                  \
               oglobal.h                 \
               oglobalsettings.h         \
+	      okeyconfigmanager.h       \
               oprocess.h                \
               oprocctrl.h               \
               osmartpointer.h           \
               ostorageinfo.h            \
@@ -16,8 +17,9 @@ SOURCES     = oapplication.cpp          \
               oconfig.cpp               \
               odebug.cpp                \
               oglobal.cpp               \
               oglobalsettings.cpp       \
+	      okeyconfigmanager.cpp     \
               oprocess.cpp              \
               oprocctrl.cpp             \
               ostorageinfo.cpp          \
 	      xmltree.cpp
diff --git a/libopie2/opieui/okeyconfigwidget.cpp b/libopie2/opieui/okeyconfigwidget.cpp
index d6d34f5..1991381 100644
--- a/libopie2/opieui/okeyconfigwidget.cpp
+++ b/libopie2/opieui/okeyconfigwidget.cpp
@@ -13,709 +13,11 @@
 
 /* non gui */
 #include <qtimer.h>
 
-
-using namespace Opie::Ui;
-
-
-
-/**
- * The default Constructor of a OKeyPair.
- * A Key and a Modifier ( Alt/Shift/Ctrl )
- * needs to be supplied.
- * Use Qt::Key for the information.
- * The default arguments  create an Empty OKeyPair. If you
- * want to get an empty OKeyPair use the static method for getting
- * the emptyKey()
- *
- * @see OKeyPair OKeyPair::emptyKey()
- */
-OKeyPair::OKeyPair( int key, int mod )
-    : m_key( key ), m_mod( mod )
-{}
-
-/**
- * The destructor
- */
-OKeyPair::~OKeyPair() {}
-
-
-/**
- * Is this OKeyPair empty/valid?
- */
-bool OKeyPair::isEmpty()const {
-    return ( ( m_key == -1 )&& ( m_mod == -1 ) );
-}
-
-/**
- * get the keycode for this OKeyPair. The Key relates to Qt::Key.
- *
- * @see Qt::Key
- * @see setKey
- */
-int OKeyPair::keycode()const {
-    return m_key;
-}
-
-/**
- * get the modifier key for this OKeyPair. The Modifier State relates
- * to the Qt::ButtonState
- *
- * @see Qt::ButtonState
- * @see setModifier
- */
-int OKeyPair::modifier()const {
-    return m_mod;
-}
-
-
-/**
- * Set the keycode
- * @param key The Keycode to set
- *
- * @see keycode()
- * @see Qt::Key
- */
-void OKeyPair::setKeycode( int key ) {
-    m_key = key;
-}
-
-/**
- * Set the modifier key
- *
- * @param the Modifier key
- * @see Qt::ButtonState
- * @see modifier()
- */
-void OKeyPair::setModifier( int mod ) {
-    m_mod = mod;
-}
-
-/**
- * Return  an OKeyPair for the Return Key without any modifier.
- */
-OKeyPair OKeyPair::returnKey() {
-    return OKeyPair( Qt::Key_Return, 0 );
-}
-
-/**
- * Return an OKeyPair for the Left Arrow Key
- * without any modifier Key
- */
-OKeyPair OKeyPair::leftArrowKey() {
-    return OKeyPair( Qt::Key_Left, 0 );
-}
-
-/**
- * Return an OKeyPair for the Right Arrow Key
- * without any modifier Key
- */
-OKeyPair OKeyPair::rightArrowKey() {
-    return OKeyPair( Qt::Key_Right, 0 );
-}
-
-/**
- * Return an OKeyPair for the Up Arrow Key
- * without any modifier Key
- */
-OKeyPair OKeyPair::upArrowKey() {
-    return OKeyPair( Qt::Key_Up, 0 );
-}
-
-/**
- * Return an OKeyPair for the Down Arrow Key
- * without any modifier Key
- */
-OKeyPair OKeyPair::downArrowKey() {
-    return OKeyPair( Qt::Key_Down, 0 );
-}
-
-/**
- * Return an Empty OKeyPair
- */
-OKeyPair OKeyPair::emptyKey() {
-    return OKeyPair();
-}
-
-/**
- * This functions uses the Opie::Core::ODevice::buttons
- * for OKeyPairList
- *
- * @see Opie::Core::ODevice
- * @see Opie::Core::ODeviceButton
- * @see Opie::Core::ODevice::button
- */
-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;
-}
-
-/**
- * Equals operator. Check if two OKeyPairs have the same key and modifier
- * @see operator!=
- */
-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;
-}
-
-/**
- * Not equal operator. calls the equal operator internally
- */
-bool OKeyPair::operator!=( const OKeyPair& pair)const  {
-    return !(*this == pair);
-}
-
-
-/**
- * The normal Constructor  to create a OKeyConfigItem
- *
- * You can set the the key paramater of this item but if
- * you use this item with the OKeyConfigManager your setting
- * will be overwritten.
- * You can also specify a QObject and slot which sould get called
- * once this item is activated. This slot only works if you
- * use the OKeyConfigManager.
- * The actual Key is read by load()
- *
- * \code
- * void MySlot::create(){
- *    OKeyConfigItem item(tr("Delete"),"delete",Resource::loadPixmap("trash"),
- *                        123, OKeyPair(Qt::Key_D,Qt::ControlButton),
- *                        this,SLOT(slotDelete(QWidget*,QKeyEvent*)));
- * }
- * \endcode
- *
- * @param text The text exposed to the user
- * @param config_key The key used in the config
- * @param pix A Pixmap associated  with this Item
- * @param def The OKeyPair used as default
- * @param caller The object where the slot exists
- * @param slot The slot which should get called
- *
- */
-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 ) {}
-
-/**
- * A special Constructor for converting from an Opie::Core::ODeviceButton
- * delivered by Opie::Core::ODevice::buttons()
- * There is no Config Key set and both default key and key are set
- * to Opie::Core::ODeviceButton::keycode() and 0 to modifier
- *
- * @see Opie::Core::ODevice
- * @see Opie::Core::ODeviceButton
- * @see Opie::Core::ODevice::buttons()
- */
-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 ) )
-{}
-
-
-/**
- * Destructor
- */
-OKeyConfigItem::~OKeyConfigItem() {}
-
-
-/**
- * The text exposed to the user
- *
- * @see setText
- */
-QString OKeyConfigItem::text()const {
-    return m_text;
-}
-
-/**
- * The pixmap shown to the user for your action/key
- *
- * @see setPixmap
- */
-QPixmap OKeyConfigItem::pixmap()const {
-    return m_pix;
-}
-
-/**
- * Return the OKeyPair this OKeyConfigItem is configured for.
- *
- * @see setKeyPair
- */
-OKeyPair OKeyConfigItem::keyPair()const {
-    return m_key;
-}
-
-/**
- * Return the default OKeyPair
- * @see setDefaultKeyPair
- */
-OKeyPair OKeyConfigItem::defaultKeyPair()const {
-    return m_def;
-}
-
-
-/**
- * Return the Id you assigned to this item.
- * setting is only possible by the constructor
- */
-int OKeyConfigItem::id()const{
-    return m_id;
-}
-
-/**
- * reutrn the Config Key. Setting it is only possible
- * by the constructor
- */
-QCString OKeyConfigItem::configKey()const {
-    return m_config;
-}
-
-/**
- * @internal
- */
-QObject* OKeyConfigItem::object()const{
-    return m_obj;
-}
-
-/**
- * @internal
- */
-QCString OKeyConfigItem::slot()const {
-    return m_str;
-}
-
-/**
- * Set the text
- *
- * @param text Set the Text of this Action to text
- * @see text()
- */
-void OKeyConfigItem::setText( const QString& text ) {
-    m_text = text;
-}
-
-/**
- * Set the pixmap of this action
- *
- * @param pix The Pixmap to set
- * @see pixmap()
- */
-void OKeyConfigItem::setPixmap( const QPixmap& pix ) {
-    m_pix = pix;
-}
-
-/**
- * Set the KeyPair the OKeyConfigItem uses.
- * Your set Key could get overwritten if you use
- * the manager or GUI to configure the key
- *
- * @param key Set the OKeyPair used
- * @see keyPair()
- */
-void OKeyConfigItem::setKeyPair( const OKeyPair& key) {
-    m_key = key;
-}
-
-/**
- * Set the default KeyPair.
- *
- * @param key The default keypair
- * @see defaultKeyPair()
- */
-void OKeyConfigItem::setDefaultKeyPair( const OKeyPair& key ) {
-    m_def = key;
-}
-
-/**
- * @internal
- */
-void OKeyConfigItem::setConfigKey( const QCString& str) {
-    m_config = str;
-    m_config.detach();
-}
-
-/**
- * @internal
- */
-void OKeyConfigItem::setId( int id ) {
-    m_id = id;
-}
-
-/**
- * If the item is not configured isEmpty() will return true
- * It is empty if no text is present and no default
- * and no configured key
- */
-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;
-}
-
-/**
- * Check if the KeyPairs are the same
- */
-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 );
-}
-
-/**
- * \brief c'tor
- * The Constructor for a OKeyConfigManager
- *
- * You can use this manager in multiple ways. Either make it handle
- * QKeyEvents
- *
- * \code
- * Opie::Core::Config conf = oApp->config();
- * Opie::Ui::OKeyPairList blackList;
- * blackList.append(Opie::Ui::OKeyPair::leftArrowKey());
- * blackList.append(Opie::Ui::OKeyPair::rightArrowKey());
- * Opie::Ui::OKeyConfigManager *manager = new Opie::Ui::OKeyConfigManager(conf,"key_actions",blackList,
- *                                                                        false);
- * QListView *view = new QListView();
- * manager->handleWidget(view);
- * manager->addKeyConfig( Opie::Ui::OKeyPair::returnKey());
- * manager->load();
- *
- * connect(manager,SIGNAL(actionActivated(QWidget*,QKeyEvent*,const Opie::Ui::OKeyConfigItem&)),
- *         this,SLOT(slotHandleKey(QWidget*,QKeyEvent*,const Opie::Ui::OKeyConfigItem&)));
- *
- * ....
- *
- * void update(){
- *  QDialog diag(true);
- *  QHBoxLayout *lay = new QHBoxLayout(&diag);
- *  Opie::Ui::OKeyConfigWidget *wid = new Opie::Ui::OKeyConfigWidget(manager,&diag);
- *  wid->setChangeMode(Opie::Ui::OKeyConfigWidget::Queu);
- *  lay->addWidget(wid);
- *  if(QPEApplication::execDialog( &diag)== QDialog::Accepted){
- *        wid->save();
- *  }
- * }
- *
- * ....
- * MyListView::keyPressEvent( QKeyEvent* e ){
- *     Opie::Ui::OKeyConfigItem item = manager->handleKeyEvent(e);
- *     if(!item.isEmpty() ){
- *         switch(item.id()){
- *           case My_Delete_Key:
- *             break;
- *         }
- *     }
- * }
- *
- * \endcode
- *
- * @param conf The Config where the KeySetting should be stored
- * @param group The group where the KeySetting will be stored
- * @param black Which keys shouldn't be allowed to handle
- * @param grabkeyboard Calls QPEApplication::grabKeyboard to allow handling of DeviceButtons
- * @param par The parent/owner of this manager
- * @param name The name of this object
- */
-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();
-}
-
-
-/**
- * Destructor
- */
-OKeyConfigManager::~OKeyConfigManager() {
-    if ( m_grab )
-        QPEApplication::ungrabKeyboard();
-}
-
-/**
- * Load the Configuration  from the OConfig
- * If a Key is restricted but was in the config we will
- * make it be the empty key paur
- * We will change the group but restore to the previous.
- *
- * @see OKeyPair::emptyKey
- */
-void OKeyConfigManager::load() {
-    Opie::Core::OConfigGroupSaver( 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( OKeyPair(key, mod) );
-        else
-            (*it).setKeyPair( OKeyPair::emptyKey() );
-    }
-    delete m_map; m_map = 0;
-}
-
-/**
- * We will save the current configuration
- * to the OConfig. We will change the group but restore
- * to the previous
- */
-void OKeyConfigManager::save() {
-    Opie::Core::OConfigGroupSaver( 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();
-}
-
-/**
- * This is function uses a QMap internally  but you can have the same keycode
- * with different modifier key. The behaviour is undefined if you add a OKeyConfigItem
- * with same keycode and modifier key. The GUI takes care that a user can't
- * cofigure two keys.
- *
- * Make sure you call e->ignore if you don't want to handle this event
- */
-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::Ui::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;
-}
-
-/**
- * Return the associated id of the item or -1 if no item
- * matched the key
- *
- * @see handleKeyEvent
- */
-int OKeyConfigManager::handleKeyEventId( QKeyEvent* ev) {
-    return handleKeyEvent( ev ).id();
-}
-
-/**
- * Add Key Config to the List of items
- */
-void OKeyConfigManager::addKeyConfig( const OKeyConfigItem& item ) {
-    m_keys.append( item );
-    delete m_map; m_map = 0;
-}
-
-/**
- * Remove the Key from the Config. Internal lists will be destroyed
- * and rebuild on demand later
- */
-void OKeyConfigManager::removeKeyConfig( const OKeyConfigItem& item ) {
-    m_keys.remove( item );
-    delete m_map; m_map = 0;
-}
-
-/**
- * Clears the complete list
- */
-void OKeyConfigManager::clearKeyConfig() {
-    m_keys.clear();
-    delete m_map; m_map = 0;
-}
-
-/**
- *
- */
-Opie::Ui::OKeyConfigItem::List OKeyConfigManager::keyConfigList()const{
-    return m_keys;
-}
-
-/**
- * Add this OKeyPair to the blackList.
- * Internal lists will be destroyed
- */
-void OKeyConfigManager::addToBlackList( const OKeyPair& key) {
-    m_blackKeys.append( key );
-    delete m_map; m_map = 0;
-}
-
-
-/**
- * Remove this OKeyPair from the black List
- * Internal lists will be destroyed
- */
-void OKeyConfigManager::removeFromBlackList( const OKeyPair& key ) {
-    m_blackKeys.remove( key );
-    delete m_map; m_map = 0;
-}
-
-
-/**
- * Clear the blackList
- */
-void OKeyConfigManager::clearBlackList() {
-    m_blackKeys.clear();
-    delete m_map; m_map = 0;
-}
-
-
-/**
- * Return a copy of the blackList
- */
-OKeyPair::List OKeyConfigManager::blackList()const {
-    return m_blackKeys;
-}
-
-
-/**
- * Ask the Manager to handle KeyEvents for you.
- * All handled keys will emit a QSignal and return true
- * that it handled the keyevent
- */
-void OKeyConfigManager::handleWidget( QWidget* wid ) {
-    wid->installEventFilter( this );
-}
-
-/**
- * @internal
- */
-bool OKeyConfigManager::eventFilter( QObject* obj, QEvent* ev) {
-    if ( !obj->isWidgetType() )
-        return false;
-
-    if ( ev->type() != QEvent::KeyPress && ev->type() != QEvent::KeyRelease )
-        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;
-}
-
-/**
- * @internal
- */
-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];
-}
-
+using Opie::Core::OKeyConfigItem;
+using Opie::Core::OKeyPair;
+using Opie::Core::OKeyConfigManager;
 
 namespace Opie {
 namespace Ui {
 namespace Internal {
@@ -761,35 +63,8 @@ namespace Internal {
 
         return QAccel::keyToString( mod + pair.keycode() );
     }
 
-    /*
-     * 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;
-        }
-    }
-
     struct OKeyConfigWidgetPrivate{
         OKeyConfigWidgetPrivate(const QString& = QString::null,
                                 OKeyConfigManager* = 0);
         bool operator==( const OKeyConfigWidgetPrivate& );
@@ -808,10 +83,9 @@ namespace Internal {
         return true;
     }
 
 }
-}
-}
+
 
 
 
 ////////////////////////
@@ -1155,9 +429,9 @@ OKeyChooserConfigDialog::OKeyChooserConfigDialog( QWidget* par, const char* nam,
 
 OKeyChooserConfigDialog::~OKeyChooserConfigDialog() {
 }
 
-Opie::Ui::OKeyPair OKeyChooserConfigDialog::keyPair()const{
+Opie::Core::OKeyPair OKeyChooserConfigDialog::keyPair()const{
     return m_keyPair;
 }
 
 void OKeyChooserConfigDialog::keyPressEvent( QKeyEvent* ev ) {
@@ -1166,9 +440,9 @@ void OKeyChooserConfigDialog::keyPressEvent( QKeyEvent* ev ) {
     if ( ev->isAutoRepeat() )
         return;
 
     int mod, key;
-    Opie::Ui::Internal::fixupKeys( key,mod, ev );
+    Opie::Core::Internal::fixupKeys( key,mod, ev );
 
     /* either we used software keyboard
      * or we've true support
      */
@@ -1246,4 +520,8 @@ void OKeyChooserConfigDialog::keyReleaseEvent( QKeyEvent* ev ) {
 void OKeyChooserConfigDialog::slotTimeUp() {
     m_mod = m_key = 0;
     QTimer::singleShot(0, this, SIGNAL(keyCaptured()) );
 }
+
+
+}
+}
diff --git a/libopie2/opieui/okeyconfigwidget.h b/libopie2/opieui/okeyconfigwidget.h
index bb8eb6c..d11054c 100644
--- a/libopie2/opieui/okeyconfigwidget.h
+++ b/libopie2/opieui/okeyconfigwidget.h
@@ -6,16 +6,12 @@
 
 #ifndef ODP_KEY_CONFIG_WIDGET_H
 #define ODP_KEY_CONFIG_WIDGET_H
 
-#include <opie2/oconfig.h>
-#include <opie2/odevice.h>
+#include <opie2/okeyconfigmanager.h>
 
-#include <qstring.h>
-#include <qpixmap.h>
-#include <qcstring.h>
 #include <qhbox.h>
-#include <qvaluelist.h>
+
 
 class QKeyEvent;
 class QLabel;
 class QPushButton;
@@ -32,189 +28,8 @@ namespace Internal {
 }
     class OListViewItem;
     class OListView;
 
-/**
- * \brief small class representing a Key with possible modifiers
- * This class holds information about key code and possible
- * modifier state. That is the lowest level of the key input
- * functions.
- * There are also static methods to get special keys.
- * OKeyPair will be used with \see OKeyConfigItem
- *
- * @since 1.2
- */
-class OKeyPair {
-public:
-    typedef QValueList<OKeyPair> List;
-    OKeyPair( int key = -1, int modifier = -1);
-    ~OKeyPair();
-
-    bool operator==( const OKeyPair& )const;
-    bool operator!=( const OKeyPair& )const;
-
-    bool isEmpty()const;
-
-    int keycode()const;
-    int modifier()const;
-
-    void setKeycode( int );
-    void setModifier( int );
-
-    static OKeyPair returnKey();
-    static OKeyPair leftArrowKey();
-    static OKeyPair rightArrowKey();
-    static OKeyPair upArrowKey();
-    static OKeyPair downArrowKey();
-    static OKeyPair emptyKey();
-    static OKeyPair::List hardwareKeys();
-
-private:
-    int m_key;
-    int m_mod;
-    class Private;
-    Private* d;
-};
-
-/**
- * A class to represent an OKeyPair.
- * It consists out of a Text exposed to the user, Config Key Item,
- * Pixmap, A default OKeyPair and the set OKeyPair.
- * You can also pass an id to it
- *
- * @since 1.1.2
- */
-class OKeyConfigItem {
-    friend class OKeyConfigManager;
-public:
-    typedef QValueList<OKeyConfigItem> List;
-    OKeyConfigItem( const QString& text = QString::null , const QCString& config_key = QCString(),
-                    const QPixmap& symbol  = QPixmap(),
-                    int id = -1,
-                    const OKeyPair& def = OKeyPair::emptyKey(),
-                    QObject *caller = 0, const char* slot = 0);
-    OKeyConfigItem( const Opie::Core::ODeviceButton& );
-    ~OKeyConfigItem();
-
-    bool operator==( const OKeyConfigItem& )const;
-    bool operator!=( const OKeyConfigItem& )const;
-
-    QString text()const;
-    QPixmap pixmap()const;
-    int id()const;
-
-
-
-    OKeyPair keyPair()const;
-    OKeyPair defaultKeyPair()const;
-    QCString configKey()const;
-
-
-    void setText( const QString& text );
-    void setPixmap( const QPixmap& );
-    void setKeyPair( const OKeyPair& );
-    void setDefaultKeyPair( const OKeyPair& );
-
-    bool isEmpty()const;
-
-protected:
-    QObject *object()const;
-    QCString slot()const;
-    void setId( int id );
-    void setConfigKey( const QCString& );
-
-private:
-    QString  m_text;
-    QCString m_config;
-    QPixmap  m_pix;
-    int m_id;
-    OKeyPair m_key;
-    OKeyPair m_def;
-    QObject *m_obj;
-    QCString m_str;
-    class Private;
-    Private *d;
-};
-
-
-
-/**
- * \brief A manager  to load and save Key Actions and get notified
- * This is the Manager for KeyActions.
- * You can say from which config and group to read data, to grab the
- * keyboard to handle hardware keys, you can supply a blacklist of
- * keys which should not be used by allowed to be used.
- * You can even pass this manager to a Widget to do the configuration for you.
- * You need to add OKeyConfigItem for your keys and then issue a load() to
- * read the Key information.
- * You can either handle the QKeyEvent yourself and ask this class if it is
- * handled by your action and let give you the action. Or you can install
- * the event filter and get a signal.
- * You need to load ans save yourself!
- *
- * @since 1.1.2
- */
-class OKeyConfigManager : public QObject {
-    Q_OBJECT
-    typedef QMap<int, OKeyConfigItem::List> OKeyMapConfigPrivate;
-public:
-    OKeyConfigManager(Opie::Core::OConfig *conf = 0,
-                      const QString& group = QString::null,
-                      const OKeyPair::List &block = OKeyPair::List(),
-                      bool grabkeyboard = false,  QObject * par = 0,
-                      const char* name = 0      );
-    ~OKeyConfigManager();
-
-    void load();
-    void save();
-
-    OKeyConfigItem handleKeyEvent( QKeyEvent* );
-    int            handleKeyEventId( QKeyEvent* );
-
-    void addKeyConfig( const OKeyConfigItem& );
-    void removeKeyConfig( const OKeyConfigItem& );
-    void clearKeyConfig();
-
-    void addToBlackList( const OKeyPair& );
-    void removeFromBlackList( const OKeyPair& );
-    void clearBlackList();
-    OKeyPair::List blackList()const;
-
-    void handleWidget( QWidget* );
-
-    bool eventFilter( QObject*, QEvent* );
-
-    OKeyConfigItem::List keyConfigList()const;
-signals:
-    /**
-     * The Signals are triggered on KeyPress and KeyRelease!
-     * You can check the isDown of the QKeyEvent
-     * @see QKeyEvent
-     */
-    void actionActivated( QWidget*, QKeyEvent*, const Opie::Ui::OKeyConfigItem& );
-
-    /**
-     * This Signal correspondents to the OKeyConfigItem slot
-     * and object
-     *
-     * @see OKeyConfigItem::slot
-     * @see OKeyConfigItem::object
-     */
-    void actionActivated( QWidget* par, QKeyEvent* key);
-
-private:
-    OKeyConfigItem::List keyList( int );
-    OKeyConfigItem::List m_keys;
-    QValueList<QWidget*> m_widgets;
-    Opie::Core::OConfig *m_conf;
-    QString m_group;
-    OKeyPair::List m_blackKeys;
-    bool m_grab : 1;
-    OKeyMapConfigPrivate *m_map;
-    class Private;
-    Private *d;
-};
-
 
 /**
  * With this Widget you can let the Keyboard Shortcuts
  * be configured by the user.
@@ -239,9 +54,9 @@ public:
 
     void setChangeMode( enum ChangeMode );
     ChangeMode changeMode()const;
 
-    void insert( const QString& name, OKeyConfigManager* );
+    void insert( const QString& name, Opie::Core::OKeyConfigManager* );
 
     void load();
     void save();
 
@@ -253,11 +68,11 @@ private slots:
     void slotConfigure();
 
 private:
     static bool sanityCheck(  Opie::Ui::Internal::OKeyListViewItem* man,
-                              const OKeyPair& newItem );
+                              const Opie::Core::OKeyPair& newItem );
     void updateItem( Opie::Ui::Internal::OKeyListViewItem* man,
-                     const OKeyPair& newItem);
+                     const Opie::Core::OKeyPair& newItem);
     void initUi();
     Opie::Ui::OListView *m_view;
     Opie::Ui::Internal::OKeyConfigWidgetPrivateList m_list;
     QLabel *m_lbl;
@@ -292,9 +107,9 @@ class OKeyChooserConfigDialog : public QDialog {
 public:
     OKeyChooserConfigDialog( QWidget* parent = 0, const char* name = 0, bool modal = false, WFlags fl = 0 );
     ~OKeyChooserConfigDialog();
 
-    OKeyPair keyPair()const;
+    Opie::Core::OKeyPair keyPair()const;
 
 protected:
     void keyPressEvent( QKeyEvent* );
     void keyReleaseEvent( QKeyEvent* );
@@ -308,9 +123,9 @@ private slots:
 private:
     QTimer *m_timer;
     QLabel *m_lbl;
     bool m_virtKey : 1;
-    OKeyPair m_keyPair;
+    Opie::Core::OKeyPair m_keyPair;
     int m_key, m_mod;
     class Private;
     Private *d;
 };
diff --git a/libopie2/opieui/okeyconfigwidget_p.h b/libopie2/opieui/okeyconfigwidget_p.h
index 7690846..4dece4d 100644
--- a/libopie2/opieui/okeyconfigwidget_p.h
+++ b/libopie2/opieui/okeyconfigwidget_p.h
@@ -2,31 +2,33 @@
  * Only Internal implemented in the same .cpp file anyway
  */
 #include <opie2/olistview.h>
 
+#include <opie2/okeyconfigmanager_p.h>
 
 namespace Opie {
 namespace Ui {
 namespace Internal {
-    static QString keyToString( const OKeyPair& );
-    static void fixupKeys( int&, int&, QKeyEvent* );
+    static QString keyToString( const Opie::Core::OKeyPair& );
     class OKeyListViewItem : public Opie::Ui::OListViewItem {
     public:
-        OKeyListViewItem( const OKeyConfigItem& item, OKeyConfigManager*, Opie::Ui::OListViewItem* parent);
+        OKeyListViewItem( const Opie::Core::OKeyConfigItem& item,
+                          Opie::Core::OKeyConfigManager*,
+                          Opie::Ui::OListViewItem* parent);
         ~OKeyListViewItem();
 
         void setDefault();
 
-        OKeyConfigItem& item();
-        OKeyConfigItem origItem()const;
-        void setItem( const OKeyConfigItem& item );
+        Opie::Core::OKeyConfigItem& item();
+        Opie::Core::OKeyConfigItem origItem()const;
+        void setItem( const Opie::Core::OKeyConfigItem& item );
         void updateText();
 
-        OKeyConfigManager *manager();
+        Opie::Core::OKeyConfigManager *manager();
     private:
-        OKeyConfigItem m_item;
-        OKeyConfigItem m_origItem;
-        OKeyConfigManager* m_manager;
+        Opie::Core::OKeyConfigItem m_item;
+        Opie::Core::OKeyConfigItem m_origItem;
+        Opie::Core::OKeyConfigManager* m_manager;
 
     };
 }
 }
diff --git a/noncore/graphics/opie-eye/gui/iconview.cpp b/noncore/graphics/opie-eye/gui/iconview.cpp
index 7e4164b..2a49786 100644
--- a/noncore/graphics/opie-eye/gui/iconview.cpp
+++ b/noncore/graphics/opie-eye/gui/iconview.cpp
@@ -32,9 +32,9 @@
 #include <qtimer.h>
 #include <qstyle.h>
 
 
-using Opie::Ui::OKeyConfigItem;
+using Opie::Core::OKeyConfigItem;
 
 /*
  * The Icons, Request Cache and IconViewItem for the IconView
  */
@@ -155,9 +155,9 @@ PIconView::~PIconView() {
     m_viewManager->save();
     delete m_viewManager;
 }
 
-Opie::Ui::OKeyConfigManager* PIconView::manager() {
+Opie::Core::OKeyConfigManager* PIconView::manager() {
     return m_viewManager;
 }
 
 
@@ -165,32 +165,32 @@ Opie::Ui::OKeyConfigManager* PIconView::manager() {
  * init the KeyBoard Shortcuts
  * called from the c'tor
  */
 void PIconView::initKeys() {
-    Opie::Ui::OKeyPair::List lst;
-    lst.append( Opie::Ui::OKeyPair::upArrowKey() );
-    lst.append( Opie::Ui::OKeyPair::downArrowKey() );
-    lst.append( Opie::Ui::OKeyPair::leftArrowKey() );
-    lst.append( Opie::Ui::OKeyPair::rightArrowKey() );
-    lst.append( Opie::Ui::OKeyPair::returnKey() );
-
-    m_viewManager = new Opie::Ui::OKeyConfigManager(m_cfg, "View-KeyBoard-Config",
+    Opie::Core::OKeyPair::List lst;
+    lst.append( Opie::Core::OKeyPair::upArrowKey() );
+    lst.append( Opie::Core::OKeyPair::downArrowKey() );
+    lst.append( Opie::Core::OKeyPair::leftArrowKey() );
+    lst.append( Opie::Core::OKeyPair::rightArrowKey() );
+    lst.append( Opie::Core::OKeyPair::returnKey() );
+
+    m_viewManager = new Opie::Core::OKeyConfigManager(m_cfg, "View-KeyBoard-Config",
                                                     lst, false,this, "keyconfig name" );
     m_viewManager->addKeyConfig( OKeyConfigItem(tr("Beam Current Item") , "beam",
                                                 Resource::loadPixmap("beam"), BeamItem,
-                                                Opie::Ui::OKeyPair(Qt::Key_B, Qt::ShiftButton),
+                                                Opie::Core::OKeyPair(Qt::Key_B, Qt::ShiftButton),
                                                 this, SLOT(slotBeam())) );
     m_viewManager->addKeyConfig( OKeyConfigItem(tr("Delete Current Item"), "delete",
                                                 Resource::loadPixmap("trash"), DeleteItem,
-                                                Opie::Ui::OKeyPair(Qt::Key_D, Qt::ShiftButton),
+                                                Opie::Core::OKeyPair(Qt::Key_D, Qt::ShiftButton),
                                                 this, SLOT(slotTrash())) );
     m_viewManager->addKeyConfig( OKeyConfigItem(tr("View Current Item"), "view",
                                                 Resource::loadPixmap("1to1"), ViewItem,
-                                                Opie::Ui::OKeyPair(Qt::Key_V, Qt::ShiftButton),
+                                                Opie::Core::OKeyPair(Qt::Key_V, Qt::ShiftButton),
                                                 this, SLOT(slotShowImage())));
     m_viewManager->addKeyConfig( OKeyConfigItem(tr("Show Image Info") , "info",
                                                 Resource::loadPixmap("DocumentTypeWord"), InfoItem,
-                                                Opie::Ui::OKeyPair(Qt::Key_I, Qt::ShiftButton ),
+                                                Opie::Core::OKeyPair(Qt::Key_I, Qt::ShiftButton ),
                                                 this, SLOT(slotImageInfo()) ) );
     m_viewManager->load();
     m_viewManager->handleWidget( m_view );
 }
diff --git a/noncore/graphics/opie-eye/gui/iconview.h b/noncore/graphics/opie-eye/gui/iconview.h
index a4ca0bc..9cf7b3e 100644
--- a/noncore/graphics/opie-eye/gui/iconview.h
+++ b/noncore/graphics/opie-eye/gui/iconview.h
@@ -18,10 +18,8 @@ class Ir;
 
 namespace Opie {
 namespace Core{
     class OConfig;
-}
-namespace Ui {
     class OKeyConfigManager;
 }
 }
 
@@ -34,9 +32,9 @@ class PIconView : public QVBox {
 public:
     PIconView( QWidget* wid, Opie::Core::OConfig *cfg );
     ~PIconView();
     void resetView();
-    Opie::Ui::OKeyConfigManager* manager();
+    Opie::Core::OKeyConfigManager* manager();
 
 signals:
     void sig_showInfo( const QString& );
     void sig_display( const QString& );
@@ -72,9 +70,9 @@ private slots:
 /**/
     void slotThumbInfo(const QString&, const QString&);
     void slotThumbNail(const QString&, const QPixmap&);
 private:
-    Opie::Ui::OKeyConfigManager *m_viewManager;
+    Opie::Core::OKeyConfigManager *m_viewManager;
     Opie::Core::OConfig *m_cfg;
     QComboBox* m_views;
     QIconView* m_view;
     QString m_path;
diff --git a/noncore/graphics/opie-eye/gui/imageinfoui.cpp b/noncore/graphics/opie-eye/gui/imageinfoui.cpp
index 0b3250c..27a67a6 100644
--- a/noncore/graphics/opie-eye/gui/imageinfoui.cpp
+++ b/noncore/graphics/opie-eye/gui/imageinfoui.cpp
@@ -45,9 +45,9 @@ imageinfo::imageinfo(const QString&_path, QWidget* parent,  const char* name, WF
     initKeys();
     slotChangeName(_path);
 }
 
-Opie::Ui::OKeyConfigManager* imageinfo::manager()
+Opie::Core::OKeyConfigManager* imageinfo::manager()
 {
     if (!m_viewManager) {
         initKeys();
     }
@@ -62,21 +62,21 @@ void imageinfo::initKeys()
         m_cfg = new Opie::Core::OConfig("phunkview");
         m_cfg->setGroup("imageinfo_keys" );
     }
 #endif
-    Opie::Ui::OKeyPair::List lst;
-    lst.append( Opie::Ui::OKeyPair::upArrowKey() );
-    lst.append( Opie::Ui::OKeyPair::downArrowKey() );
-    lst.append( Opie::Ui::OKeyPair::leftArrowKey() );
-    lst.append( Opie::Ui::OKeyPair::rightArrowKey() );
-    lst.append( Opie::Ui::OKeyPair::returnKey() );
-
-    m_viewManager = new Opie::Ui::OKeyConfigManager(m_cfg, "imageinfo_keys",
+    Opie::Core::OKeyPair::List lst;
+    lst.append( Opie::Core::OKeyPair::upArrowKey() );
+    lst.append( Opie::Core::OKeyPair::downArrowKey() );
+    lst.append( Opie::Core::OKeyPair::leftArrowKey() );
+    lst.append( Opie::Core::OKeyPair::rightArrowKey() );
+    lst.append( Opie::Core::OKeyPair::returnKey() );
+
+    m_viewManager = new Opie::Core::OKeyConfigManager(m_cfg, "imageinfo_keys",
                                                     lst, false,this, "keyconfig name" );
-    m_viewManager->addKeyConfig( Opie::Ui::OKeyConfigItem(tr("View Full Image"), "infoview",
-                                                Resource::loadPixmap("1to1"), ViewItem,
-                                                Opie::Ui::OKeyPair(Qt::Key_V, Qt::ShiftButton),
-                                                this, SLOT(slotShowImage())));
+    m_viewManager->addKeyConfig( Opie::Core::OKeyConfigItem(tr("View Full Image"), "infoview",
+                                                            Resource::loadPixmap("1to1"), ViewItem,
+                                                            Opie::Core::OKeyPair(Qt::Key_V, Qt::ShiftButton),
+                                                            this, SLOT(slotShowImage())));
     m_viewManager->load();
     m_viewManager->handleWidget( this );
     m_viewManager->handleWidget( TextView1 );
 }
diff --git a/noncore/graphics/opie-eye/gui/imageinfoui.h b/noncore/graphics/opie-eye/gui/imageinfoui.h
index c9b83a1..bc99bf9 100644
--- a/noncore/graphics/opie-eye/gui/imageinfoui.h
+++ b/noncore/graphics/opie-eye/gui/imageinfoui.h
@@ -14,10 +14,8 @@ class QTextView;
 
 namespace Opie {
     namespace Core {
         class OConfig;
-    }
-    namespace Ui {
         class OKeyConfigManager;
     }
 }
 
@@ -33,9 +31,9 @@ public:
     imageinfo(const QString&_path, QWidget* parent = 0, const char* name = 0, WFlags fl = 0 );
     virtual ~imageinfo();
 
     void setDestructiveClose();
-    Opie::Ui::OKeyConfigManager* manager();
+    Opie::Core::OKeyConfigManager* manager();
 
 signals:
     void dispImage(const QString&);
     void sig_return();
@@ -55,9 +53,9 @@ protected:
     QVBoxLayout* imageinfoLayout;
     QString currentFile;
 
     Opie::Core::OConfig * m_cfg;
-    Opie::Ui::OKeyConfigManager*m_viewManager;
+    Opie::Core::OKeyConfigManager*m_viewManager;
     void initKeys();
 
 protected slots:
     virtual void slot_fullInfo(const QString&, const QString&);
diff --git a/noncore/graphics/opie-eye/gui/imageview.cpp b/noncore/graphics/opie-eye/gui/imageview.cpp
index e43bbff..2078b19 100644
--- a/noncore/graphics/opie-eye/gui/imageview.cpp
+++ b/noncore/graphics/opie-eye/gui/imageview.cpp
@@ -22,9 +22,9 @@ ImageView::~ImageView()
         delete m_viewManager;
     }
 }
 
-Opie::Ui::OKeyConfigManager* ImageView::manager()
+Opie::Core::OKeyConfigManager* ImageView::manager()
 {
     if (!m_viewManager) {
         initKeys();
     }
@@ -37,20 +37,20 @@ void ImageView::initKeys()
     if (!m_cfg) {
         m_cfg = new Opie::Core::OConfig("phunkview");
         m_cfg->setGroup("image_view_keys" );
     }
-    Opie::Ui::OKeyPair::List lst;
-    lst.append( Opie::Ui::OKeyPair::upArrowKey() );
-    lst.append( Opie::Ui::OKeyPair::downArrowKey() );
-    lst.append( Opie::Ui::OKeyPair::leftArrowKey() );
-    lst.append( Opie::Ui::OKeyPair::rightArrowKey() );
-    lst.append( Opie::Ui::OKeyPair::returnKey() );
-
-    m_viewManager = new Opie::Ui::OKeyConfigManager(m_cfg, "image_view_keys",
+    Opie::Core::OKeyPair::List lst;
+    lst.append( Opie::Core::OKeyPair::upArrowKey() );
+    lst.append( Opie::Core::OKeyPair::downArrowKey() );
+    lst.append( Opie::Core::OKeyPair::leftArrowKey() );
+    lst.append( Opie::Core::OKeyPair::rightArrowKey() );
+    lst.append( Opie::Core::OKeyPair::returnKey() );
+
+    m_viewManager = new Opie::Core::OKeyConfigManager(m_cfg, "image_view_keys",
                                                     lst, false,this, "image_view_keys" );
-    m_viewManager->addKeyConfig( Opie::Ui::OKeyConfigItem(tr("View Image Info"), "imageviewinfo",
+    m_viewManager->addKeyConfig( Opie::Core::OKeyConfigItem(tr("View Image Info"), "imageviewinfo",
                                                 Resource::loadPixmap("1to1"), ViewInfo,
-                                                Opie::Ui::OKeyPair(Qt::Key_I,Qt::ShiftButton),
+                                                Opie::Core::OKeyPair(Qt::Key_I,Qt::ShiftButton),
                                                 this, SLOT(slotShowImageInfo())));
     m_viewManager->handleWidget( this );
     m_viewManager->load();
 }
diff --git a/noncore/graphics/opie-eye/gui/imageview.h b/noncore/graphics/opie-eye/gui/imageview.h
index f61c93f..87e2b32 100644
--- a/noncore/graphics/opie-eye/gui/imageview.h
+++ b/noncore/graphics/opie-eye/gui/imageview.h
@@ -6,10 +6,8 @@
 
 namespace Opie {
     namespace Core {
         class OConfig;
-    }
-    namespace Ui {
         class OKeyConfigManager;
     }
 }
 
@@ -23,17 +21,17 @@ class ImageView:public ImageScrollView
 
 public:
     ImageView(Opie::Core::OConfig *cfg, QWidget* parent, const char* name = 0, WFlags fl = 0 );
     virtual ~ImageView();
-    Opie::Ui::OKeyConfigManager* manager();
+    Opie::Core::OKeyConfigManager* manager();
 
 signals:
     void dispImageInfo(const QString&);
     void sig_return();
 
 protected:
     Opie::Core::OConfig * m_cfg;
-    Opie::Ui::OKeyConfigManager*m_viewManager;
+    Opie::Core::OKeyConfigManager*m_viewManager;
     void initKeys();
 protected slots:
     virtual void slotShowImageInfo();
 };
diff --git a/noncore/graphics/opie-eye/gui/mainwindow.h b/noncore/graphics/opie-eye/gui/mainwindow.h
index 042d568..59dba30 100644
--- a/noncore/graphics/opie-eye/gui/mainwindow.h
+++ b/noncore/graphics/opie-eye/gui/mainwindow.h
@@ -13,11 +13,13 @@
 
 
 namespace Opie {
 namespace Ui{
-    class OKeyConfigManager;
     class OWidgetStack;
 }
+namespace Core{
+    class OKeyConfigManager;
+}
 }
 
 class PIconView;
 class imageinfo;