| -rw-r--r-- | libopie2/opieui/okeyconfigwidget.cpp | 452 | ||||
| -rw-r--r-- | libopie2/opieui/okeyconfigwidget.h | 107 |
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,27 +1,36 @@ #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() {} @@ -43,180 +52,195 @@ bool OKeyPair::isEmpty()const { 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 { @@ -237,48 +261,62 @@ OKeyPair OKeyConfigItem::keyPair()const { * @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 * @@ -316,194 +354,197 @@ void OKeyConfigItem::setId( int 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 */ @@ -541,165 +582,412 @@ void OKeyConfigManager::addToBlackList( const OKeyPair& key) { /** * 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 |