summaryrefslogtreecommitdiff
path: root/libopie2/opieui
Side-by-side diff
Diffstat (limited to 'libopie2/opieui') (more/less context) (show whitespace changes)
-rw-r--r--libopie2/opieui/okeyconfigwidget.cpp73
-rw-r--r--libopie2/opieui/okeyconfigwidget.h10
2 files changed, 60 insertions, 23 deletions
diff --git a/libopie2/opieui/okeyconfigwidget.cpp b/libopie2/opieui/okeyconfigwidget.cpp
index 3e08416..8967d77 100644
--- a/libopie2/opieui/okeyconfigwidget.cpp
+++ b/libopie2/opieui/okeyconfigwidget.cpp
@@ -1,60 +1,62 @@
#include "okeyconfigwidget.h"
#include "okeyconfigwidget_p.h"
#include <qgroupbox.h>
#include <qradiobutton.h>
#include <qpushbutton.h>
#include <qbuttongroup.h>
-
+#include <qmessagebox.h>
#include <qaccel.h>
#include <qlayout.h>
#include <qlabel.h>
+
+/* non gui */
#include <qtimer.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::ButtonState
@@ -114,107 +116,107 @@ OKeyPair OKeyPair::rightArrowKey() {
/**
* 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
*/
OKeyPair::List OKeyPair::hardwareKeys() {
const QValueList<Opie::Core::ODeviceButton> but = Opie::Core::ODevice::inst()->buttons();
OKeyPair::List lst;
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) {
+bool OKeyPair::operator==( const OKeyPair& pair)const {
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) {
+bool OKeyPair::operator!=( const OKeyPair& pair)const {
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 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,
QObject *caller,
const char* slot )
: m_text( text ), m_config( config_key ), m_pix( pix ),
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()
@@ -326,312 +328,310 @@ void OKeyConfigItem::setPixmap( const QPixmap& pix ) {
* @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 ) {
+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 ) {
+bool OKeyConfigItem::operator!=( const OKeyConfigItem& conf )const {
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 ) {
+ 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 ) {
+ for( OKeyConfigItem::List::Iterator it = m_keys.begin();it != m_keys.end(); ++it ) {
+ /* skip empty items */
if ( (*it).isEmpty() )
continue;
OKeyPair pair = (*it).keyPair();
OKeyPair deft = (*it).defaultKeyPair();
/*
* don't write if it is the default setting
- * FIXME allow to remove Keys
+ * FIXME allow to remove Keys from config
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, mod;
Opie::Ui::Private::fixupKeys( key, mod, e );
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;
}
/**
@@ -715,96 +715,99 @@ OKeyConfigItem::List OKeyConfigManager::keyList( int keycode) {
namespace Opie {
namespace Ui {
namespace Private {
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() );
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() );
}
+ /*
+ * the virtual and hardware key events have both issues...
+ */
void fixupKeys( int& key, int &mod, QKeyEvent* e ) {
key = e->key();
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::ControlButton;
else if ( mod & 1024 )
new_mod |= Qt::AltButton;
mod = new_mod == 0? mod : new_mod;
}
}
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;
}
}
}
}
@@ -963,248 +966,280 @@ 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() )
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());
updateItem( item, OKeyPair::emptyKey() );
}
void OKeyConfigWidget::slotDefaultKey() {
m_none->setChecked( false );
m_cus ->setChecked( false );
m_btn ->setEnabled( false );
m_def ->setChecked( true );
if ( !m_view->currentItem() || !m_view->currentItem()->parent() )
return;
Opie::Ui::Private::OKeyListViewItem *item = static_cast<Opie::Ui::Private::OKeyListViewItem*>(m_view->currentItem());
updateItem( item, item->item().defaultKeyPair() );
}
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;
}
void OKeyConfigWidget::slotConfigure() {
if ( !m_view->currentItem() || !m_view->currentItem()->parent() )
return;
/* FIXME make use of OModalHelper */
OKeyChooserConfigDialog dlg( this, "Dialog Name", true );
dlg.setCaption(tr("Configure Key"));
connect(&dlg, SIGNAL(keyCaptured()), &dlg, SLOT(accept()) );
if ( QPEApplication::execDialog( &dlg ) == QDialog::Accepted ) {
Opie::Ui::Private::OKeyListViewItem *item = static_cast<Opie::Ui::Private::OKeyListViewItem*>(m_view->currentItem());
updateItem( item, dlg.keyPair() );
}
}
+bool OKeyConfigWidget::sanityCheck( Opie::Ui::Private::OKeyListViewItem* item,
+ const OKeyPair& newItem ) {
+ OKeyPair::List bList = item->manager()->blackList();
+ for ( OKeyPair::List::Iterator it = bList.begin(); it != bList.end(); ++it ) {
+ /* black list matched */
+ if ( *it == newItem ) {
+ QMessageBox::warning( 0, tr("Key is on BlackList" ),
+ tr("<qt>The Key you choose is on the black list "
+ "and may not be used with this manager. Please "
+ "use a different key.</qt>" ) );
+ return false;
+ }
+ }
+ /* no we need to check the other items which is dog slow */
+ QListViewItemIterator it( item->parent() );
+ while ( it.current() ) {
+ /* if not our parent and not us */
+ if (it.current()->parent() && it.current() != item) {
+ /* damn already given away*/
+ if ( newItem == static_cast<Opie::Ui::Private::OKeyListViewItem*>(it.current() )->item().keyPair() ) {
+ QMessageBox::warning( 0, tr("Key is already assigned" ),
+ tr("<qt>The Key you choose is already taken by "
+ "a different Item of your config. Please try"
+ "using a different key.</qt>" ) );
+ return false;
+ }
+ }
+ ++it;
+ }
+
+ return true;
+}
+
void OKeyConfigWidget::updateItem( Opie::Ui::Private::OKeyListViewItem *item,
const OKeyPair& newItem) {
/* sanity check
* check against the blacklist of the manager
* check if another item uses this key which is o(n) at least
*/
- if ( !newItem.isEmpty() ) {
+ if ( !newItem.isEmpty() && !sanityCheck(item, newItem ))
+ return;
+
- }
/*
* If immediate we need to remove and readd the key
*/
if ( m_mode == Imediate )
item->manager()->removeKeyConfig( item->item() );
item->item().setKeyPair( newItem );
item->updateText();
if ( m_mode == Imediate )
item->manager()->addKeyConfig( item->item() );
}
/////
OKeyChooserConfigDialog::OKeyChooserConfigDialog( QWidget* par, const char* nam,
bool mod, WFlags fl )
: QDialog( par, nam, mod, fl ), m_virtKey( false ), m_keyPair( OKeyPair::emptyKey() ) ,
m_key( 0 ), m_mod( 0 ) {
setFocusPolicy( StrongFocus );
QHBoxLayout *lay = new QHBoxLayout( this );
QLabel *lbl = new QLabel( tr("Configure Key" ), this );
lay->addWidget( lbl );
lbl->setFocusPolicy( NoFocus );
m_lbl = new QLabel( this );
lay->addWidget( m_lbl );
m_lbl->setFocusPolicy( NoFocus );
m_timer = new QTimer( this );
connect(m_timer, SIGNAL(timeout()),
this, SLOT(slotTimeUp()) );
}
OKeyChooserConfigDialog::~OKeyChooserConfigDialog() {
}
Opie::Ui::OKeyPair OKeyChooserConfigDialog::keyPair()const{
return m_keyPair;
}
void OKeyChooserConfigDialog::keyPressEvent( QKeyEvent* ev ) {
QDialog::keyPressEvent( ev );
if ( ev->isAutoRepeat() )
return;
- qWarning( "Key Press Event" );
int mod, key;
Opie::Ui::Private::fixupKeys( key,mod, ev );
/* either we used software keyboard
* or we've true support
*/
if ( !m_virtKey && !ev->key()) {
m_virtKey = true;
m_keyPair = OKeyPair( key, mod );
}else{
mod = 0;
switch( key ) {
case Qt::Key_Control:
mod = Qt::ControlButton;
break;
case Qt::Key_Shift:
mod = Qt::ShiftButton;
break;
case Qt::Key_Alt:
mod = Qt::AltButton;
break;
default:
break;
}
- if (mod ) {
+ if (mod )
m_mod |= mod;
- }else
+ else
m_key = key;
if ( ( !mod || m_key ) && !m_timer->isActive() )
- m_timer->start( 50, true );
+ m_timer->start( 150, true );
m_keyPair = OKeyPair( m_key, m_mod );
}
m_lbl->setText( Opie::Ui::Private::keyToString( m_keyPair ) );
}
void OKeyChooserConfigDialog::keyReleaseEvent( QKeyEvent* ev ) {
m_timer->stop();
QDialog::keyPressEvent( ev );
if ( ev->isAutoRepeat() )
return;
if ( m_virtKey && !ev->key()) {
m_virtKey = false;
slotTimeUp();
}else {
int mod = 0;
int key = ev->key();
switch( key ) {
case Qt::Key_Control:
mod = Qt::ControlButton;
break;
case Qt::Key_Shift:
mod = Qt::ShiftButton;
break;
case Qt::Key_Alt:
mod = Qt::AltButton;
break;
default:
break;
}
if (mod )
m_mod &= ~mod;
else
m_key = key;
m_keyPair = OKeyPair( m_key, m_mod );
m_lbl->setText( Opie::Ui::Private::keyToString( m_keyPair ) );
}
}
void OKeyChooserConfigDialog::slotTimeUp() {
m_mod = m_key = 0;
QTimer::singleShot(0, this, SIGNAL(keyCaptured()) );
diff --git a/libopie2/opieui/okeyconfigwidget.h b/libopie2/opieui/okeyconfigwidget.h
index 9e26719..f75ed99 100644
--- a/libopie2/opieui/okeyconfigwidget.h
+++ b/libopie2/opieui/okeyconfigwidget.h
@@ -4,144 +4,144 @@
*/
#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 <qcstring.h>
#include <qhbox.h>
#include <qvaluelist.h>
class QKeyEvent;
class QLabel;
class QPushButton;
class QListViewItem;
class QRadioButton;
class QTimer;
namespace Opie {
namespace Ui {
namespace Private {
class OKeyConfigWidgetPrivate;
typedef QValueList<OKeyConfigWidgetPrivate> OKeyConfigWidgetPrivateList;
class OKeyListViewItem;
}
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> List;
OKeyPair( int key = -1, int modifier = -1);
~OKeyPair();
- bool operator==( const OKeyPair& );
- bool operator!=( const OKeyPair& );
+ bool operator==( const OKeyPair& )const;
+ bool operator!=( const OKeyPair& )const;
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 OKeyPair::List hardwareKeys();
private:
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> List;
OKeyConfigItem( const QString& text = QString::null , const QCString& config_key = QCString(),
const QPixmap& symbol = QPixmap(),
int id = -1,
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& );
+ bool operator==( const OKeyConfigItem& )const;
+ bool operator!=( const OKeyConfigItem& )const;
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:
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
@@ -208,96 +208,98 @@ private:
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:
+ static bool sanityCheck( Opie::Ui::Private::OKeyListViewItem* man,
+ const OKeyPair& newItem );
void updateItem( Opie::Ui::Private::OKeyListViewItem* man,
const OKeyPair& newItem);
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 slots: