-Bugfixes on compare operator and isEmpty

-Implement saving from the widget to the manager
-Fix Ctrl vs Alt mixup

Yeah now the user can select between none and default

A OKeyChooserDialog will soon be implemented

2 files changed, 119 insertions, 15 deletions

diff --git a/libopie2/opieui/okeyconfigwidget.cpp b/libopie2/opieui/okeyconfigwidget.cpp
index 273f15b..41be1be 100644
--- a/libopie2/opieui/okeyconfigwidget.cpp
+++ b/libopie2/opieui/okeyconfigwidget.cpp
@@ -300,362 +300,372 @@ QCString OKeyConfigItem::slot()const {
  *
  * @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 ) {
-    if ( isEmpty() == conf.isEmpty() ) return true;
+/*    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 ) {
     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 of the OConfig Item!
  *
  * @see OKeyPair::emptyKey
  */
 void OKeyConfigManager::load() {
     m_conf->setGroup( 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.
  */
 void OKeyConfigManager::save() {
     m_conf->setGroup( m_group );
 
     /*
      * Write each item
      */
     for( OKeyConfigItem::List::Iterator it = m_keys.begin();
          it != m_keys.end(); ++it ) {
         if ( (*it).isEmpty() )
             continue;
         OKeyPair pair = (*it).keyPair();
         OKeyPair deft = (*it).defaultKeyPair();
-        /* don't write if it is the default setting */
+        /*
+         * don't write if it is the default setting
+         * FIXME allow to remove Keys
         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() );
     }
 }
 
 /**
  * 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 = e->key();
     int 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::AltButton;
-        else if ( mod & 1024 )
             new_mod |= Qt::ControlButton;
+        else if ( mod & 1024 )
+            new_mod |= Qt::AltButton;
 
         mod = new_mod == 0? mod : new_mod;
     }
 
     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 );
+    qWarning( "m_keys count is now %d", m_keys.count() );
     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 );
+    qWarning( "m_keys count is now %d", m_keys.count() );
     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 );
 }
 
@@ -676,369 +686,424 @@ bool OKeyConfigManager::eventFilter( QObject* obj, QEvent* ev) {
         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];
 }
 
 
 
 /////////////////////////
 //////// Widget Starts Here
 namespace Opie {
 namespace Ui {
 namespace Private {
     static QString keyToString( const OKeyPair& );
     class OKeyListViewItem : public Opie::Ui::OListViewItem {
     public:
         OKeyListViewItem( const OKeyConfigItem& item, OKeyConfigManager*, Opie::Ui::OListViewItem* parent);
         ~OKeyListViewItem();
 
         void setDefault();
 
         OKeyConfigItem& item();
+        OKeyConfigItem origItem()const;
         void setItem( const OKeyConfigItem& item );
+        void updateText();
 
         OKeyConfigManager *manager();
     private:
         OKeyConfigItem m_item;
+        OKeyConfigItem m_origItem;
         OKeyConfigManager* m_manager;
 
     };
 
     OKeyListViewItem::OKeyListViewItem( const OKeyConfigItem& item, OKeyConfigManager* man, OListViewItem* parent)
         : Opie::Ui::OListViewItem( parent ), m_manager( man )  {
+        m_origItem = item;
         setItem( item );
     }
     OKeyListViewItem::~OKeyListViewItem() {}
     OKeyConfigItem &OKeyListViewItem::item(){
         return m_item;
     }
+    OKeyConfigItem  OKeyListViewItem::origItem() const{
+        return m_origItem;
+    }
     OKeyConfigManager* OKeyListViewItem::manager() {
         return m_manager;
     }
     void OKeyListViewItem::setItem( const OKeyConfigItem& item ) {
         m_item = 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.keyPair().isEmpty() ? setText( 2, QObject::tr( "None" ) ) :
+                                     setText( 2, keyToString( m_item.keyPair() ) );
+
+        m_item.defaultKeyPair().isEmpty() ? setText( 3, QObject::tr( "None" ) ) :
+                                            setText  ( 3, keyToString( m_item.defaultKeyPair() ) );
+    }
+    void OKeyListViewItem::updateText() {
+        m_item.keyPair().isEmpty() ? setText( 2, QObject::tr( "None" ) ) :
+                                     setText( 2, keyToString( m_item.keyPair() ) );
     }
 
     QString keyToString( const OKeyPair& pair ) {
         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;
     }
 
 }
 }
 }
 
 
 
 ////////////////////////
 
 
 
 
 
 /**
  *
  * 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" ) );
+    m_view->setRootIsDecorated( true );
     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 ->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 );
 
+    connect(m_btn, SIGNAL(clicked()),
+            this, SLOT(slotConfigure()));
 
-    m_box = gr;
+    m_box = box;
 }
 
 /**
  * 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() {
     Opie::Ui::Private::OKeyConfigWidgetPrivateList::Iterator it;
     for ( it = m_list.begin(); it != m_list.end(); ++it ) {
         OListViewItem *item = new OListViewItem( m_view, (*it).name );
         OKeyConfigItem::List list = (*it).manager->keyConfigList();
         for (OKeyConfigItem::List::Iterator keyIt = list.begin(); keyIt != list.end();++keyIt )
             (void )new  Opie::Ui::Private::OKeyListViewItem(*keyIt, (*it).manager, item );
 
     }
 }
 
 /**
  * Saves if in Queue Mode. It'll update the supplied
  * OKeyConfigManager objects.
  * If in Queue mode it'll just return
  */
 void OKeyConfigWidget::save() {
+    /*
+     * Iterate over all config items
+     */
+    QListViewItemIterator it( m_view );
+    while ( it.current() ) {
+        if (it.current()->parent() ) {
+            Opie::Ui::Private::OKeyListViewItem *item = static_cast<Opie::Ui::Private::OKeyListViewItem*>( it.current() );
+            OKeyConfigManager *man = item->manager();
+            man->removeKeyConfig( item->origItem() );
+            man->addKeyConfig( item->item() );
+        }
+        ++it;
+    }
+
 
 }
 
 
 /**
  * @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();
+        m_lbl->setText(  tr("Default: " )+ item->text( 3 ) );
         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() {
     qWarning( "No Key" );
     m_none->setChecked( true );
     m_cus ->setChecked( false );
     m_btn ->setEnabled( false );
     m_def ->setChecked( false );
 
-    if ( !m_view->currentItem() || m_view->currentItem()->parent() )
+    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() );
+    item->updateText();
 
     if ( m_mode == Imediate )
         item->manager()->addKeyConfig( item->item() );
 
 }
 
 void OKeyConfigWidget::slotDefaultKey() {
-    qWarning( "Slot Default Key" );
-    m_none->setChecked( true );
+    m_none->setChecked( false );
     m_cus ->setChecked( false );
     m_btn ->setEnabled( false );
-    m_def ->setChecked( false );
+    m_def ->setChecked( true );
 
-    if ( !m_view->currentItem() || m_view->currentItem()->parent() )
+    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() );
+    item->updateText();
 
     if ( m_mode == Imediate )
         item->manager()->addKeyConfig( item->item() );
 }
 
 void OKeyConfigWidget::slotCustomKey() {
-    qWarning( "SlotCustom Key" );
     m_cus ->setChecked( true );
     m_btn ->setEnabled( true );
     m_def ->setChecked( false );
     m_none->setChecked( false );
 
-    if ( !m_view->currentItem() || m_view->currentItem()->parent() )
+    if ( !m_view->currentItem() || !m_view->currentItem()->parent() )
         return;
 
 }
 
+void OKeyConfigWidget::slotConfigure() {
+
+}
+
+
+OKeyChooserConfigDialog::OKeyChooserConfigDialog( QWidget* par, const char* nam,
+                                                  bool mod, WFlags fl )
+    : QDialog( par, nam, mod, fl ) {
+}
+
+OKeyChooserConfigDialog::~OKeyChooserConfigDialog() {
+}
+
+Opie::Ui::OKeyPair OKeyChooserConfigDialog::keyPair()const{
+}
+
+void OKeyChooserConfigDialog::keyPressEvent( QKeyEvent* ev ) {
+    ev->ignore();
+}
+
+void OKeyChooserConfigDialog::keyReleaseEvent( QKeyEvent* ev ) {
+    ev->ignore();
+}
diff --git a/libopie2/opieui/okeyconfigwidget.h b/libopie2/opieui/okeyconfigwidget.h
index a7a5f48..8d2a1ef 100644
--- a/libopie2/opieui/okeyconfigwidget.h
+++ b/libopie2/opieui/okeyconfigwidget.h
@@ -187,84 +187,123 @@ 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.
  * 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:
     /**
      * 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();
 
     void setChangeMode( enum ChangeMode );
     ChangeMode changeMode()const;
 
     void insert( const QString& name, OKeyConfigManager* );
 
     void load();
     void save();
 
 private slots:
     void slotListViewItem(  QListViewItem* );
     void slotNoKey();
     void slotDefaultKey();
     void slotCustomKey();
-
+    void slotConfigure();
 
 private:
     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;
 };
 
+
+/**
+ * This is a small dialog that allows you to
+ * capture a key sequence.
+ * If you want it to close after a key was captured you
+ * can use this code snippet.
+ *
+ * \code
+ *  OKeyChooserConfigDialog diag(0,0,true);
+ *  connect(&diag,SIGNAL(keyCaptured()),
+ *         this,SLOT(accept()));
+ *  if( QPEApplication::execDialog(&diag) == QDialog::Accept ){
+ *     take_the_key_and_do_something
+ *  }
+ *
+ * \endcode
+ *
+ */
+class OKeyChooserConfigDialog : public QDialog {
+    Q_OBJECT
+public:
+    OKeyChooserConfigDialog( QWidget* parent = 0, const char* name = 0, bool modal = false, WFlags fl = 0 );
+    ~OKeyChooserConfigDialog();
+
+    OKeyPair keyPair()const;
+
+protected:
+    void keyPressEvent( QKeyEvent* );
+    void keyReleaseEvent( QKeyEvent* );
+
+signals:
+    void keyCaptured();
+
+private:
+    OKeyPair m_keyPair;
+    class Private;
+    Private *d;
+};
+
 }
 }
 
 
 #endif