| -rw-r--r-- | libopie2/opieui/okeyconfigwidget.cpp | 408 | ||||
| -rw-r--r-- | libopie2/opieui/okeyconfigwidget.h | 142 |
2 files changed, 529 insertions, 21 deletions
diff --git a/libopie2/opieui/okeyconfigwidget.cpp b/libopie2/opieui/okeyconfigwidget.cpp new file mode 100644 index 0000000..d52a55f --- a/dev/null +++ b/libopie2/opieui/okeyconfigwidget.cpp @@ -0,0 +1,408 @@ +#include "okeyconfigwidget.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::Modifier + * + * @see Qt::Modifier + * @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 ) { + +} + +/** + * Set the modifier key + * + * @param the Modifier key + * @see Qt::Modifier + * @see modifier() + */ +void OKeyPair::setModifier( int 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 + */ +OKeyPairList OKeyPair::hardwareKeys() { + const QValueList<Opie::Core::ODeviceButton> but = Opie::Core::ODevice::inst()->buttons(); + OKeyPairList lst; + + for ( QValueList<Opie::Core::ODeviceButton>::Iterator it = but.begin(); + it != but.end(); ++it ) + lst.append( OKeyPair( (*it).keycode(), 0 ) ); + + + return lst; +} + +/** + * 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. + * + * @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 + * + */ +OKeyConfigItem::OKeyConfigItem( const QString& text, const QCString& config_key, + const QPixmap& pix, int id, const OKeyPair& def, + const OKeyPair& key) + : m_text( text ), m_config( config_key ), m_pix( pix ), + m_id( id ), m_def( def ), m_key( key ) {} + +/** + * 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 ) ) +{} + + +/** + * 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; +} + +/** + * 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; + + return true; +} + +/** + * \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){ + * 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, + bool grabkeyboard, QObject* par, + const char* name) + : QObject( par, name ), m_conf( conf ), m_group( group ), + m_blackKeys( black ), m_grab( grabkeyboard ) +{} + + +/** + * Destructor + */ +OKeyConfigWidget::~OKeyConfigWidget() {} + +/** + * Load the Configuration from the OConfig + * If a Key is restricted but was in the config we will + * make the empty + * We will change the group of the OConfig Item! + */ +void OKeyConfigWidget::load() { + m_conf->setGroup( m_group ); + + /* + * Read each item + */ + int key, mod; + for( OKeyConfigItemList::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() ); + (*it).setKeyPair( OKeyPair(key, mod) ); + } +} + +/** + * We will save the current configuration + * to the OConfig. We will change the group. + */ +void OKeyConfigWidget::save() { + +} diff --git a/libopie2/opieui/okeyconfigwidget.h b/libopie2/opieui/okeyconfigwidget.h index bcbb579..0d5d26f 100644 --- a/libopie2/opieui/okeyconfigwidget.h +++ b/libopie2/opieui/okeyconfigwidget.h @@ -1,102 +1,202 @@ +/* + * 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 <qhbox.h> #include <qvaluelist.h> class QKeyEvent; namespace Opie { namespace Ui { + +/** + * \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; + 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(); + +private: + int m_key = -1; + int m_mod = -1; + 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; OKeyConfigItem( const QString& text = QString::null , const QCString& config_key = QCString(), const QPixmap& symbol = QPixmap(), - int key = 0, int mod = 0, - int default_key = 0, int default_modified = 0 ); + int id = -1, + const OKeyPair& set = OKeyPair::emptyKey(), + const OKeyPair& def = OKeyPair::emptyKey() ); + OKeyConfigItem( const Opie::Core::ODeviceButton& ); ~OKeyConfigItem(); + bool operator==( const OKeyConfigItem& ); + bool operator!=( const OKeyConfigItem& ); + QString text()const; QPixmap pixmap()const; - int key()const; - int modifier()const; - int defaultKey()const; - int defaultModifier()const; + int id()const; + + OKeyPair keyPair()const; + OKeyPair defaultKeyPair()const; + QCString configKey()const; void setText( const QString& text ); void setPixmap( const QPixmap& ); - void setKey( int ); - void setModied( int ); - void setDefaultKey( int ); - void setDefaultModifier( int ); + void setKeyPair( const OKeyPair& ); + void setDefaultKeyPair( const OKeyPair& ); - bool isConfigured()const; bool isEmpty()const; + +protected: + void setId( int id ); + void setConfigKey( const QCString& ); + private: + int m_id; QString m_text; QCString m_config; QPixmap m_pix; - int m_key; - int m_mod; - int m_defKey; - int m_defMod; + OKeyPair m_key; + OKeyPair m_def; class Private; Private *d; }; -class OKeyConfig : public QObject { + +/** + * \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. + * + * @since 1.1.2 + */ +class OKeyConfigManager : public QObject { Q_OBJECT public: - OKeyConfig(Opie::Core::OConfig *conf = 0, bool grabkeyboard); - ~OKeyConfig(); + OKeyConfigManager(Opie::Core::OConfig *conf = 0, + const QString& group = QString::null, + OKeyPairList &block = OKeyPairList(), + bool grabkeyboard = false, QObject *= 0, + const char* name = 0 ); + ~OKeyConfigManager(); void load(); void save(); OKeyConfigItem handleKeyEvent( QKeyEvent* ); QString handleKeyEventString( QKeyEvent* ); void addKeyConfig( const OKeyConfigItem& ); void removeKeyConfig( const OKeyConfigItem& ); + void addBlackList( const OKeyPair& ); + void removeBlackList( const OKeyPair& ); + void clearBlackList(); + OKeyPairList blackList()const; + void handleWidget( QWidget* ); + + bool eventFilter( QObject*, QEvent* ); signals: - void keyConfigChanged( OKeyConfig* ); - void actionActivated( QWidget*, QKeyEvent*, const OKeyConfigItem& ); + void keyConfigChanged( Opie::Ui::OKeyConfigManager* ); + void actionActivated( QWidget*, QKeyEvent*, const Opie::Ui::OKeyConfigItem& ); private: + OKeyPairList m_blackKeys; OKeyConfigItemList m_keys; QValueList<QWidget*> m_widgets; + Opie::Core::OConfig *m_conf; + QString m_group; + bool m_grab : 1; class Private; Private *d; }; class OKeyConfigWidget : public QHBox { Q_OBJECT public: enum ChangeMode { Imediate, Queu }; OKeyConfigWidget( QWidget* parent = 0, const char* name = 0, WFlags fl = 0 ); - OKeyConfigWidget( OKeyConfig *, QWidget* parent = 0, const char* = 0, WFlags = 0 ); + OKeyConfigWidget( OKeyConfigManager *, QWidget* parent = 0, const char* = 0, WFlags = 0 ); ~OKeyConfigWidget(); void setChangeMode( enum ChangeMode ); ChangeMode changeMode()const; + void setKeyConfig( OKeyConfigManager* ); + void reload(); + void save(); private: + OKeyConfigManager* m_manager; class Private; Private *d; }; } } |