2 files changed, 88 insertions, 4 deletions

diff --git a/libopie2/opiecore/okeyconfigmanager.cpp b/libopie2/opiecore/okeyconfigmanager.cpp
index e6055e0..18740ef 100644
--- a/libopie2/opiecore/okeyconfigmanager.cpp
+++ b/libopie2/opiecore/okeyconfigmanager.cpp
@@ -380,128 +380,139 @@ bool OKeyConfigItem::isEmpty()const {
     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 );
 }
 
+/*! \enum OKeyConfigManager::EventMask
+     <a name="Eventmask flags"></a>
+     This enum is used to tell OKeyConfigManager which type of key events should inspected.
+
+     <ul>
+         <li>\c MaskPressed When a key is pressed an action performs
+         <li>\c MaskReleased When a key is released an action performs
+     </ul>
+*/
+
 /**
  * \brief c'tor
  * The Constructor for a OKeyConfigManager
  *
  * You can use this manager in multiple ways. Either make it handle
- * QKeyEvents
+ * QKeyEvents. The EventMask is set to OKeyConfigManager::MaskReleased by default.
  *
  * \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();
+    m_event_mask = OKeyConfigManager::MaskReleased;
 }
 
 
 /**
  * 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 )
@@ -645,65 +656,66 @@ void OKeyConfigManager::removeFromBlackList( const OKeyPair& key ) {
  * 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 )
+    if ( (ev->type() != QEvent::KeyPress||!testEventMask(MaskPressed)) &&
+        (ev->type() != QEvent::KeyRelease||!testEventMask(MaskReleased)) )
         return false;
 
     QKeyEvent *key = static_cast<QKeyEvent*>( ev );
     OKeyConfigItem item =  handleKeyEvent( key );
 
     if ( item.isEmpty() )
         return false;
 
     QWidget *wid = static_cast<QWidget*>( obj );
 
     if ( item.object() && !item.slot().isEmpty() ) {
         connect( this, SIGNAL( actionActivated(QWidget*, QKeyEvent*)),
                  item.object(), item.slot().data() );
         emit actionActivated(wid, key);
         disconnect( this, SIGNAL(actionActivated(QWidget*,QKeyEvent*)),
                     item.object(), item.slot().data() );
     }
     emit actionActivated( wid, key, item );
 
     return true;
 }
 
 /**
  * @internal
  */
 OKeyConfigItem::List OKeyConfigManager::keyList( int keycode) {
    /*
     * Create the map if not existing anymore
     */
     if ( !m_map ) {
         m_map = new OKeyMapConfigPrivate;
         /* for every key */
diff --git a/libopie2/opiecore/okeyconfigmanager.h b/libopie2/opiecore/okeyconfigmanager.h
index d610375..b861675 100644
--- a/libopie2/opiecore/okeyconfigmanager.h
+++ b/libopie2/opiecore/okeyconfigmanager.h
@@ -105,101 +105,173 @@ 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!
+ * You need to load and 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,
+                      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* );
 
+    /**
+     * Sets the event mask flags aMask.
+     *
+     * aMask is a combination of OKeyConfigManager::EventMask
+     *
+     * @see eventMask(), testEventMask(), addEventMask(), clearEventMask()
+     */
+    void setEventMask(uint aMask);
+    /**
+     * Returns the event mask flags set.
+     *
+     * aMask is a combination of OKeyConfigManager::EventMask
+     *
+     * @see setEventMask(), testEventMask(), addEventMask(), clearEventMask()
+     */
+    uint eventMask()const;
+    /**
+     * Test if the event mask flag aMask is set.
+     *
+     * @param aMask one of OKeyConfigManager::EventMask
+     *
+     * @see eventMask(), setEventMask(), addEventMask(), clearEventMask()
+     */
+    bool testEventMask(uint aMask);
+    /**
+     * Add the event mask flag aMask.
+     *
+     * @param aMask one of OKeyConfigManager::EventMask
+     *
+     * @see eventMask(), setEventMask(), addEventMask(), clearEventMask()
+     */
+    void addEventMask(uint aMask);
+    /**
+     * Clears the event mask flag aMask.
+     *
+     * @param aMask is one of OKeyConfigManager::EventMask
+     *
+     * @see eventMask(), testEventMask(), addEventMask(), setEventMask()
+     */
+    void clearEventMask(uint aMask);
+
     OKeyConfigItem::List keyConfigList()const;
+
+    enum EventMask {
+        MaskPressed = 0x1,
+        MaskReleased = 0x2,
+    };
 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;
+    uint m_event_mask;
 };
 
+inline bool OKeyConfigManager::testEventMask(uint aMask)
+{
+    return (m_event_mask&aMask)!=0;
+}
+
+inline void OKeyConfigManager::addEventMask(uint aMask)
+{
+    m_event_mask |= aMask;
+}
+
+inline void OKeyConfigManager::clearEventMask(uint aMask)
+{
+    m_event_mask &= ~aMask;
+}
+
+inline void OKeyConfigManager::setEventMask(uint aMask)
+{
+    m_event_mask = aMask;
+}
+
+inline uint OKeyConfigManager::eventMask()const
+{
+    return  m_event_mask;
+}
+
 }
 }
 
 #endif