summaryrefslogtreecommitdiff
Side-by-side diff
Diffstat (more/less context) (ignore whitespace changes)
-rw-r--r--libopie2/opieui/okeyconfigwidget.cpp408
-rw-r--r--libopie2/opieui/okeyconfigwidget.h142
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;
};
}
}