Only GUI config is left

2 files changed, 453 insertions, 106 deletions

diff --git a/libopie2/opieui/okeyconfigwidget.cpp b/libopie2/opieui/okeyconfigwidget.cpp
index 4482754..b4f1c5e 100644
--- a/libopie2/opieui/okeyconfigwidget.cpp
+++ b/libopie2/opieui/okeyconfigwidget.cpp
@@ -1,292 +1,330 @@
 #include "okeyconfigwidget.h"
 
+#include <opie2/olistview.h>
 
+#include <qgroupbox.h>
+#include <qradiobutton.h>
+#include <qpushbutton.h>
+#include <qbuttongroup.h>
+
+#include <qaccel.h>
+#include <qlayout.h>
+#include <qlabel.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;
+    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
  */
-OKeyPairList OKeyPair::hardwareKeys() {
+OKeyPair::List OKeyPair::hardwareKeys() {
     const QValueList<Opie::Core::ODeviceButton> but = Opie::Core::ODevice::inst()->buttons();
-    OKeyPairList lst;
+    OKeyPair::List lst;
 
-    for ( QValueList<Opie::Core::ODeviceButton>::Iterator it = but.begin();
+    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) {
     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) {
     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 key The OKeyPair used
  * @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,
-                                const OKeyPair& key)
+                                QObject *caller,
+                                const char* slot )
     : m_text( text ), m_config( config_key ), m_pix( pix ),
-      m_id( id ), m_def( def ), m_key( key ) {}
+      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( Opie::Core::ODeviceButton& b )
-    : m_text( b.userText() ), m_pix( b.pixmap() ), m_id( -1 )
-      m_def( OKeyPair( b.keycode(), 0 ) ), m_key( OKeyPair( b.keycode(), 0 ) )
+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;
 }
 
 /**
@@ -308,210 +346,213 @@ void OKeyConfigItem::setConfigKey( const QCString& str) {
 }
 
 /**
  * @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;
 
     return true;
 }
 
 /**
  * Check if the KeyPairs are the same
  */
 bool OKeyConfigItem::operator==( const OKeyConfigItem& conf ) {
     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_text != conf.m_text ) return false;
-    if ( m_pix != conf.m_pix )   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 ) {
     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::Accept){
+ *  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,
-                                      OKeyPairList black,
+                                      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 )
-{}
+      m_blackKeys( black ), m_grab( grabkeyboard ), m_map( 0 ){
+    if ( m_grab )
+        QPEApplication::grabKeyboard();
+}
 
 
 /**
  * Destructor
  */
-OKeyConfigManager::~OKeyConfigManager() {}
+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 of the OConfig Item!
  *
  * @see OKeyPair::emptyKey
  */
-void OKeyConfigWidget::load() {
+void OKeyConfigManager::load() {
     m_conf->setGroup( m_group );
 
     /*
      * Read each item
      */
     int key, mod;
-    for( OKeyConfigItemList::Iterator it = m_keys.begin();
+    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.
  */
-void OKeyConfigWidget::save() {
+void OKeyConfigManager::save() {
     m_conf->setGroup( m_group );
 
     /*
      * Write each item
      */
-    int key, mod;
-    for( OKeyConfigItemList::Iterator it = m_keys.begin();
+    for( OKeyConfigItem::List::Iterator it = m_keys.begin();
          it != m_keys.end(); ++it ) {
         if ( (*it).isEmpty() )
             continue;
         OKeyPair pair = (*it).keyPair();
-        m_conf->writeEntry(pair.configKey()+"key", pair.keycode()  );
-        m_conf->writeEntry(pair.configKey()+"mod", pair.modifier() );
+        m_conf->writeEntry((*it).configKey()+"key", pair.keycode()  );
+        m_conf->writeEntry((*it).configKey()+"mod", pair.modifier() );
     }
 }
 
 /**
  * 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 ) {
-    OKeyConfigItemList keyList =  keyList( e->key() );
-    if ( keyList.isEmpty() )
+    OKeyConfigItem::List _keyList =  keyList( e->key() );
+    if ( _keyList.isEmpty() )
         return OKeyConfigItem();
 
     OKeyConfigItem item;
-    for ( OKeyConfigItemList::Iterator it = keyList.begin(); it != keyList.end();
+    for ( OKeyConfigItem::List::Iterator it = _keyList.begin(); it != _keyList.end();
           ++it ) {
         if ( (*it).keyPair().modifier() == e->state() ) {
             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
@@ -533,173 +574,420 @@ void OKeyConfigManager::clearKeyConfig() {
 /**
  * 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
  */
-OKeyPairList OKeyConfigManager::blackList()const {
+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;
 
-    emit actionActivated( static_cast<QWidget*>( obj ), key, item );
+    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
  */
-OKeyConfigItemList OKeyConfigManager::keyList( int keycode) {
+OKeyConfigItem::List OKeyConfigManager::keyList( int keycode) {
+   /*
+    * Create the map if not existing anymore
+    */
     if ( !m_map ) {
         m_map = new OKeyMapConfigPrivate;
         /* for every key */
-        for ( OKeyConfigItemList::Iterator it = m_keys.begin();
+        for ( OKeyConfigItem::List::Iterator it = m_keys.begin();
               it!= m_keys.end(); ++it ) {
+
             bool add = true;
             /* see if this key is blocked */
-            for ( OKeyPairList::Iterator pairIt = m_blackKeys.begin();
+            OKeyPair pair = (*it).keyPair();
+            for ( OKeyPair::List::Iterator pairIt = m_blackKeys.begin();
                   pairIt != m_blackKeys.end(); ++pairIt ) {
-                if ( (*pairIt).keycode()  == (*it).keycode() &&
-                     (*pairIt).modifier() == (*it).modifier() ) {
+                if ( (*pairIt).keycode()  == pair.keycode() &&
+                     (*pairIt).modifier() == pair.modifier() ) {
                     add = false;
                     break;
                 }
             }
             /* check if we added it */
-            if ( add ) {
-                if ( m_map->contains( (*it).keycode() ) )
-                    (m_map[(*it).keycode()]).append( *it );
-                else
-                    m_map.insert( (*it).keycode(), OKeyConfigItemList( *it ) );
-            }
+            if ( add )
+                (*m_map)[pair.keycode()].append( *it );
         }
     }
-    return m_map[keycode];
+    return (*m_map)[keycode];
 }
 
 
 
 /////////////////////////
 //////// Widget Starts Here
 namespace Opie {
 namespace Ui {
 namespace Private {
     static QString keyToString( const OKeyPair& );
-    class OItemBox : public QHBox {
-        Q_OBJECT
+    class OKeyListViewItem : public Opie::Ui::OListViewItem {
     public:
-        OItemBox( const OKeyConfigItem& item, QWidget* parent = 0, const char* name = 0,  WFlags fl = 0);
-        ~OItemBox();
+        OKeyListViewItem( const OKeyConfigItem& item, OKeyConfigManager*, Opie::Ui::OListViewItem* parent);
+        ~OKeyListViewItem();
 
-        OKeyConfigItem item()const;
+        void setDefault();
+
+        OKeyConfigItem& item();
         void setItem( const OKeyConfigItem& item );
-    private slots:
-        void slotClicked();
-    signals:
-        void configureBox( OItemBox* );
+
+        OKeyConfigManager *manager();
     private:
-        QLabel *m_pix;
-        QLabel *m_text;
-        QPushButton *m_btn;
         OKeyConfigItem m_item;
-    };
-
-    OItemBox::OItemBox( const OKeyConfigItem& item, QWidget* parent,
-                        const char* name, WFlags fl )
-        : QHBox( parent, name, fl ),  {
-        m_pix  = new QLabel( this );
-        m_text = new QLabel( this );
-        m_btn  = new QPushButton( this );
+        OKeyConfigManager* m_manager;
 
-        connect(m_btn, SIGNAL(clicked()),
-                this, SLOT(slotClicked()));
+    };
 
+    OKeyListViewItem::OKeyListViewItem( const OKeyConfigItem& item, OKeyConfigManager* man, OListViewItem* parent)
+        : Opie::Ui::OListViewItem( parent ), m_manager( man )  {
         setItem( item );
     }
-
-    OItemBox::~OItemBox() {}
-    OKeyConfigItem OItemBox::item()const{
+    OKeyListViewItem::~OKeyListViewItem() {}
+    OKeyConfigItem &OKeyListViewItem::item(){
         return m_item;
     }
-    void OKeyConfigItem::setItem( const OKeyConfigItem& item ) {
-        m_item = item;
-        m_pix ->setPixmap( item.pixmap() );
-        m_text->setText( item.text() );
-        m_btn->setText( keyToString( item.keyPair() ) );
+    OKeyConfigManager* OKeyListViewItem::manager() {
+        return m_manager;
     }
-    void OKeyConfigItem::slotClicked() {
-        emit configureBox( this );
+    void OKeyListViewItem::setItem( const OKeyConfigItem& item ) {
+        setPixmap( 0, m_item.pixmap() );
+        setText  ( 1, m_item.text() );
+        setText  ( 2, keyToString( m_item.keyPair() ) );
+        setText  ( 3, keyToString( m_item.defaultKeyPair() ) );
+        m_item  = item;
     }
 
     QString keyToString( const OKeyPair& pair ) {
-        QStringList mod;
-        if ( ( pair.modifier() & Qt::ShiftButton )== Qt::ShiftButton )
-            mod.append( QObject::tr( "Shift", "The Keyboard key" ) );
-        if ( ( pair.modifier() & Qt::ControlButton )== Qt::ControlButton )
-            mod.append( QObject::tr( "Ctrl", "The Ctrl key" ) );
-        if ( ( pair.modifier() & Qt::AltButton ) )== Qt::AltButton )
-            mod.append( QObject::tr( "Alt", "The keyboard Alt Key" ) );
+        int mod = 0;
+        if ( pair.modifier() & Qt::ShiftButton )
+            mod |= Qt::SHIFT;
+        if ( pair.modifier() & Qt::ControlButton )
+            mod |= Qt::CTRL;
+        if ( pair.modifier() & Qt::AltButton )
+            mod |= Qt::ALT;
+
+        return QAccel::keyToString( mod + pair.keycode() );
+    }
+
+    struct OKeyConfigWidgetPrivate{
+        OKeyConfigWidgetPrivate(const QString& = QString::null,
+                                OKeyConfigManager* = 0);
+        bool operator==( const OKeyConfigWidgetPrivate& );
+        QString name;
+        OKeyConfigManager *manager;
+    };
 
+    OKeyConfigWidgetPrivate::OKeyConfigWidgetPrivate( const QString& _name,
+                                                      OKeyConfigManager* man )
+        : name( _name ), manager( man ){}
 
+    bool OKeyConfigWidgetPrivate::operator==( const OKeyConfigWidgetPrivate& item) {
+        if ( manager != item.manager) return false;
+        if ( name    !=  item.name  ) return false;
+
+        return true;
     }
+
 }
 }
 }
 
 
 
 ////////////////////////
 
 
 
-#include "okeyconfigwidget.moc"
+
+
+/**
+ *
+ * This is a c'tor. You still need to pass the OKeyConfigManager
+ * and then issue a load.
+ * The default mode is Immediate
+ *
+ */
+OKeyConfigWidget::OKeyConfigWidget( QWidget* parent, const char *name, WFlags fl )
+    : QWidget( parent, name, fl ) {
+    initUi();
+}
+
+
+
+/**
+ * c'tor
+ */
+OKeyConfigWidget::~OKeyConfigWidget() {
+}
+
+
+/**
+ * @internal
+ */
+void OKeyConfigWidget::initUi() {
+    QBoxLayout *layout   = new QVBoxLayout( this );
+    QGridLayout *gridLay = new QGridLayout( 2, 2 );
+    layout->addLayout( gridLay, 10 );
+    gridLay->setRowStretch( 1, 10 ); // let only the ListView strecth
+
+/*
+ * LISTVIEW with the Keys
+ */
+    m_view = new Opie::Ui::OListView( this );
+    m_view->setFocus();
+    m_view->setAllColumnsShowFocus( true );
+    m_view->addColumn( tr("Pixmap") );
+    m_view->addColumn( tr("Name","Name of the Action in the ListView Header" ) );
+    m_view->addColumn( tr("Key" ) );
+    m_view->addColumn( tr("Default Key" ) );
+    connect(m_view, SIGNAL(currentChanged(QListViewItem*)),
+            this, SLOT(slotListViewItem(QListViewItem*)) );
+
+    gridLay->addMultiCellWidget( m_view, 1, 1, 0, 1 );
+
+/*
+ * GROUP with button info
+ */
+
+    QGroupBox *box = new QGroupBox( this );
+    box ->setEnabled( false );
+    box ->setTitle(  tr("Shortcut for Selected Action") );
+    box ->setFrameStyle( QFrame::Box | QFrame::Sunken );
+    layout->addWidget( box, 1 );
+
+    gridLay = new QGridLayout( box, 3, 4 );
+    gridLay->addRowSpacing( 0, fontMetrics().lineSpacing() );
+    gridLay->setMargin( 4 );
+
+    QButtonGroup *gr = new QButtonGroup( box );
+    gr->hide();
+    gr->setExclusive( true );
+
+    QRadioButton *rad = new QRadioButton( tr( "&None" ), box );
+    connect( rad, SIGNAL(clicked()),
+             this, SLOT(slotNoKey()) );
+    gr->insert( rad, 10 );
+    gridLay->addWidget( rad, 1, 0 );
+    m_none = rad;
+
+    rad = new QRadioButton( tr("&Default" ), box );
+    connect( rad, SIGNAL(clicked()),
+             this, SLOT(slotDefaultKey()) );
+    gr->insert( rad, 11 );
+    gridLay->addWidget( rad, 1, 1 );
+    m_def = rad;
+
+    rad = new QRadioButton( tr("C&ustom"), box );
+    connect( rad, SIGNAL(clicked()),
+             this, SLOT(slotCustomKey()) );
+    gr->insert( rad, 12 );
+    gridLay->addWidget( rad, 1, 2 );
+    m_cus = rad;
+
+    m_btn = new QPushButton( tr("Configure Key"), box );
+    gridLay->addWidget( m_btn, 1, 4 );
+
+    m_lbl= new QLabel( tr( "Default: " ), box );
+    gridLay->addWidget( m_lbl, 2, 0 );
+
+
+    m_box = gr;
+}
+
+/**
+ * Set the ChangeMode.
+ * You need to call this function prior to load
+ * If you call this function past load the behaviour is undefined
+ * But caling load again is safe
+ */
+void OKeyConfigWidget::setChangeMode( enum ChangeMode mode) {
+    m_mode = mode;
+}
+
+
+/**
+ * return the current mode
+ */
+OKeyConfigWidget::ChangeMode OKeyConfigWidget::changeMode()const {
+    return m_mode;
+}
+
+
+/**
+ * insert these items before calling load
+ */
+void OKeyConfigWidget::insert( const QString& str, OKeyConfigManager* man ) {
+    Opie::Ui::Private::OKeyConfigWidgetPrivate root( str, man );
+    m_list.append(root);
+}
+
+
+/**
+ * loads the items and allows editing them
+ */
+void OKeyConfigWidget::load() {
+
+}
+
+/**
+ * Saves if in Queue Mode. It'll update the supplied
+ * OKeyConfigManager objects.
+ * If in Queue mode it'll just return
+ */
+void OKeyConfigWidget::save() {
+
+}
+
+
+/**
+ * @internal
+ */
+void OKeyConfigWidget::slotListViewItem( QListViewItem* _item) {
+    if ( !_item || !_item->parent() ) {
+        m_box->setEnabled( false );
+        m_none->setChecked( true );
+        m_btn ->setEnabled( false );
+        m_def ->setChecked( false );
+        m_cus ->setChecked( false );
+    }else{
+        m_box->setEnabled( true );
+        Opie::Ui::Private::OKeyListViewItem *item = static_cast<Opie::Ui::Private::OKeyListViewItem*>( _item );
+        OKeyConfigItem keyItem= item->item();
+        if ( keyItem.keyPair().isEmpty() ) {
+            m_none->setChecked( true );
+            m_btn ->setEnabled( false );
+            m_def ->setChecked( false );
+            m_cus ->setChecked( false );
+        }else {
+            m_none->setChecked( false );
+            m_cus ->setChecked( true );
+            m_btn ->setEnabled( true );
+            m_def ->setChecked( false );
+        }
+    }
+}
+
+void OKeyConfigWidget::slotNoKey() {
+    m_none->setChecked( true );
+    m_cus ->setChecked( false );
+    m_btn ->setEnabled( false );
+    m_def ->setChecked( false );
+
+    if ( !m_view->currentItem() || m_view->currentItem()->parent() )
+        return;
+
+
+
+    /*
+     * If immediate we need to remove and readd the key
+     */
+    Opie::Ui::Private::OKeyListViewItem *item =  static_cast<Opie::Ui::Private::OKeyListViewItem*>(m_view->currentItem());
+    if ( m_mode == Imediate )
+        item->manager()->removeKeyConfig( item->item() );
+    item->item().setKeyPair( OKeyPair::emptyKey() );
+
+    if ( m_mode == Imediate )
+        item->manager()->addKeyConfig( item->item() );
+
+}
+
+void OKeyConfigWidget::slotDefaultKey() {
+    m_none->setChecked( true );
+    m_cus ->setChecked( false );
+    m_btn ->setEnabled( false );
+    m_def ->setChecked( false );
+
+    if ( !m_view->currentItem() || m_view->currentItem()->parent() )
+        return;
+
+    Opie::Ui::Private::OKeyListViewItem *item =  static_cast<Opie::Ui::Private::OKeyListViewItem*>(m_view->currentItem());
+
+   /*
+    * If immediate we need to remove and readd the key
+    */
+    if ( m_mode == Imediate )
+        item->manager()->removeKeyConfig( item->item() );
+
+    item->item().setKeyPair( item->item().defaultKeyPair() );
+
+    if ( m_mode == Imediate )
+        item->manager()->addKeyConfig( item->item() );
+}
+
+void OKeyConfigWidget::slotCustomKey() {
+    m_cus ->setChecked( true );
+    m_btn ->setEnabled( true );
+    m_def ->setChecked( false );
+    m_none->setChecked( false );
+
+    if ( !m_view->currentItem() || m_view->currentItem()->parent() )
+        return;
+
+}
+
diff --git a/libopie2/opieui/okeyconfigwidget.h b/libopie2/opieui/okeyconfigwidget.h
index 414ee7e..b3309af 100644
--- a/libopie2/opieui/okeyconfigwidget.h
+++ b/libopie2/opieui/okeyconfigwidget.h
@@ -1,209 +1,268 @@
 /*
  * Copyright (C) 2004
  * LGPL v2  zecke@handhelds.org
  */
 
 
 #ifndef ODP_KEY_CONFIG_WIDGET_H
 #define ODP_KEY_CONFIG_WIDGET_H
 
 #include <opie2/oconfig.h>
 #include <opie2/odevice.h>
 
 #include <qstring.h>
 #include <qpixmap.h>
-#include <qbytearray.h>
+#include <qcstring.h>
 #include <qhbox.h>
 #include <qvaluelist.h>
 
 class QKeyEvent;
+class QLabel;
+class QPushButton;
+class QListViewItem;
+class QRadioButton;
 
 namespace Opie {
 namespace Ui {
-
+namespace Private {
+    class OKeyConfigWidgetPrivate;
+    typedef QValueList<OKeyConfigWidgetPrivate> OKeyConfigWidgetPrivateList;
+}
+    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> OKeyPairList;
+    typedef QValueList<OKeyPair> List;
     OKeyPair( int key = -1, int modifier = -1);
     ~OKeyPair();
 
     bool operator==( const OKeyPair& );
     bool operator!=( const OKeyPair& );
 
     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 OKeyPairList hardwareKeys();
+    static OKeyPair::List hardwareKeys();
 
 private:
-    int m_key = -1;
-    int m_mod = -1;
+    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> OKeyConfigItemList;
+    typedef QValueList<OKeyConfigItem> List;
     OKeyConfigItem( const QString& text = QString::null , const QCString& config_key = QCString(),
                     const QPixmap& symbol  = QPixmap(),
                     int id = -1,
-                    const OKeyPair& set = OKeyPair::emptyKey(),
-                    const OKeyPair& def = OKeyPair::emptyKey() );
+                    const OKeyPair& def = OKeyPair::emptyKey(),
+                    QObject *caller = 0, const char* slot = 0);
     OKeyConfigItem( const Opie::Core::ODeviceButton& );
     ~OKeyConfigItem();
 
     bool operator==( const OKeyConfigItem& );
     bool operator!=( const OKeyConfigItem& );
 
     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:
-    int m_id;
     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<it, OKeyConfigItemList> OKeyMapConfigPrivate;
+    typedef QMap<int, OKeyConfigItem::List> OKeyMapConfigPrivate;
 public:
     OKeyConfigManager(Opie::Core::OConfig *conf = 0,
                       const QString& group = QString::null,
-                      OKeyPairList &block = OKeyPairList(),
-                      bool grabkeyboard = false,  QObject *= 0,
+                      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();
-    OKeyPairList blackList()const;
+    OKeyPair::List blackList()const;
 
     void handleWidget( QWidget* );
 
     bool eventFilter( QObject*, QEvent* );
 signals:
-    void keyConfigChanged( Opie::Ui::OKeyConfigManager* );
+    /**
+     * 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:
-    OKeyConfigItemList keyList( int );
-    OKeyPairList m_blackKeys;
-    OKeyConfigItemList m_keys;
+    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;
 };
 
 
-class OKeyConfigWidget : public QHBox {
+/**
+ * With this Widget you can let the Keyboard Shortcuts
+ * be configured by the user.
+ * There are two ways you can use this widget. Either in a tab were
+ * all changes are immediately getting into effect or in a queue
+ * were you ask for saving. Save won't write the data but only set
+ * it to the OKeyConfigManager
+ *
+ * @since 1.2
+ */
+class OKeyConfigWidget : public QWidget {
     Q_OBJECT
+
 public:
-    enum ChangeMode { Imediate, Queu };
+    /**
+     * Immediate Apply the change directly to the underlying OKeyConfigManager
+     * Queue Save all items and then apply when you save()
+     */
+    enum ChangeMode { Imediate, Queue };
     OKeyConfigWidget( QWidget* parent = 0, const char* name = 0, WFlags fl = 0 );
-    OKeyConfigWidget( OKeyConfigManager *, QWidget* parent = 0, const char* = 0, WFlags = 0 );
     ~OKeyConfigWidget();
 
     void setChangeMode( enum ChangeMode );
     ChangeMode changeMode()const;
 
-    void setKeyConfig( OKeyConfigManager* );
+    void insert( const QString& name, OKeyConfigManager* );
 
-    void reload();
+    void load();
     void save();
+
+private slots:
+    void slotListViewItem(  QListViewItem* );
+    void slotNoKey();
+    void slotDefaultKey();
+    void slotCustomKey();
+
+
 private:
-    OKeyConfigManager* m_manager;
+    void initUi();
+    Opie::Ui::OListView *m_view;
+    Opie::Ui::Private::OKeyConfigWidgetPrivateList m_list;
+    QLabel *m_lbl;
+    QPushButton *m_btn;
+    QRadioButton *m_def, *m_cus, *m_none;
+    QWidget* m_box;
+    ChangeMode m_mode;
     class Private;
     Private *d;
 };
 
 }
 }
 
 
 #endif