kdecore Library: kaccel.cpp Source File (kdecore Library)

| # kdecore Library API Documentation
Overview | Class Hierarchy | Classes | Classes (annotated) | Members | Namespaces | Source Files

# kaccel.cpp

    00001 /*
    00002     Copyright (c) 2001,2002 Ellis Whitehead <ellis@kde.org>
    00003
    00004     This library is free software; you can redistribute it and/or
    00005     modify it under the terms of the GNU Library General Public
    00006     License as published by the Free Software Foundation; either
    00007     version 2 of the License, or (at your option) any later version.
    00008
    00009     This library is distributed in the hope that it will be useful,
    00010     but WITHOUT ANY WARRANTY; without even the implied warranty of
    00011     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    00012     Library General Public License for more details.
    00013
    00014     You should have received a copy of the GNU Library General Public License
    00015     along with this library; see the file COPYING.LIB.  If not, write to
    00016     the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
    00017     Boston, MA 02111-1307, USA.
    00018 */
    00019
    00020 #include "kaccel.h"
    00021
    00022 #include <qaccel.h>
    00023 #include <qguardedptr.h>
    00024 #include <qpopupmenu.h>
    00025 #include <qstring.h>
    00026 #include <qtimer.h>
    00027
    00028 #include "kaccelbase.h"
    00029 #include <kapplication.h>
    00030 #include <kdebug.h>
    00031 #include <klocale.h>
    00032 #include <kshortcut.h>
    00033
    00034 #include "kaccelprivate.h"
    00035
    00036 #ifdef Q_WS_X11
    00037 #   include <X11/Xlib.h>
    00038 #   ifdef KeyPress // needed for --enable-final
    00039         // defined by X11 headers
    00040         const int XKeyPress = KeyPress;
    00041 #       undef KeyPress
    00042 #   endif
    00043 #endif
    00044
    00045 // TODO: Put in kaccelbase.cpp
    00046 //---------------------------------------------------------------------
    00047 // KAccelEventHandler
    00048 //---------------------------------------------------------------------
    00049 //
    00050 // In KAccelEventHandler::x11Event we do our own X11 keyboard event handling
    00051 // This allows us to map the Win key to Qt::MetaButton, Qt does not know about
    00052 // the Win key.
    00053 //
    00054 // KAccelEventHandler::x11Event will generate an AccelOverride event. The
    00055 // AccelOverride event is abused a bit to ensure that KAccelPrivate::eventFilter
    00056 // (as an event filter on the toplevel widget) will get the key event first
    00057 // (in the form of AccelOverride) before any of the intermediate widgets are
    00058 // able to process it.
    00059 //
    00060 // Qt normally sends an AccelOverride, Accel and then a KeyPress event.
    00061 // A widget can accept the AccelOverride event in which case the Accel event will be
    00062 // skipped and the KeyPress is followed immediately.
    00063 // If the Accel event is accepted, no KeyPress event will follow.
    00064 //
    00065 // KAccelEventHandler::x11Event converts a X11 keyboard event into an AccelOverride
    00066 // event, there are now two possibilities:
    00067 //
    00068 // 1) If KAccel intercepts the AccelOverride we are done and can consider the X11
    00069 // keyboard event as handled.
    00070 // 2) If another widget accepts the AccelOverride, it will expect to get a normal
    00071 // Qt generated KeyPress event afterwards. So we let Qt handle the X11 keyboard event
    00072 // again. However, this will first generate an AccelOverride event, and we already
    00073 // had send that one. To compnesate for this, the global event filter in KApplication
    00074 // is instructed to eat the next AccelOveride event. Qt will then send a normal KeyPress
    00075 // event and from then on everything is normal again.
    00076 //
    00077 // kde_g_bKillAccelOverride is used to tell KApplication::notify to eat the next
    00078 // AccelOverride event.
    00079
    00080 bool kde_g_bKillAccelOverride = false;
    00081
    00082 class KAccelEventHandler : public QWidget
    00083 {
    00084  public:
    00085     static KAccelEventHandler* self()
    00086     {
    00087         if( !g_pSelf )
    00088             g_pSelf = new KAccelEventHandler;
    00089         return g_pSelf;
    00090     }
    00091
    00092     static void accelActivated( bool b ) { g_bAccelActivated = b; }
    00093
    00094  private:
    00095     KAccelEventHandler();
    00096
    00097 #   ifdef Q_WS_X11
    00098     bool x11Event( XEvent* pEvent );
    00099 #   endif
    00100
    00101     static KAccelEventHandler* g_pSelf;
    00102     static bool g_bAccelActivated;
    00103 };
    00104
    00105 KAccelEventHandler* KAccelEventHandler::g_pSelf = 0;
    00106 bool KAccelEventHandler::g_bAccelActivated = false;
    00107
    00108 KAccelEventHandler::KAccelEventHandler()
    00109     : QWidget( 0, "KAccelEventHandler" )
    00110 {
    00111 #   ifdef Q_WS_X11
    00112     if ( kapp )
    00113         kapp->installX11EventFilter( this );
    00114 #   endif
    00115 }
    00116
    00117 #ifdef Q_WS_X11
    00118 bool    qt_try_modal( QWidget *, XEvent * );
    00119
    00120 bool KAccelEventHandler::x11Event( XEvent* pEvent )
    00121 {
    00122     if( QWidget::keyboardGrabber() || !kapp->focusWidget() )
    00123         return false;
    00124
    00125     if ( !qt_try_modal(kapp->focusWidget(), pEvent) )
    00126             return false;
    00127
    00128     if( pEvent->type == XKeyPress ) {
    00129         KKeyNative keyNative( pEvent );
    00130         KKey key( keyNative );
    00131         key.simplify();
    00132         int keyCodeQt = key.keyCodeQt();
    00133         int state = 0;
    00134         if( key.modFlags() & KKey::SHIFT ) state |= Qt::ShiftButton;
    00135         if( key.modFlags() & KKey::CTRL )  state |= Qt::ControlButton;
    00136         if( key.modFlags() & KKey::ALT )   state |= Qt::AltButton;
    00137         if( key.modFlags() & KKey::WIN )   state |= Qt::MetaButton;
    00138
    00139         QKeyEvent ke( QEvent::AccelOverride, keyCodeQt, 0,  state );
    00140         ke.ignore();
    00141
    00142         g_bAccelActivated = false;
    00143         kapp->sendEvent( kapp->focusWidget(), &ke );
    00144
    00145         // If the Override event was accepted from a non-KAccel widget,
    00146         //  then kill the next AccelOverride in KApplication::notify.
    00147         if( ke.isAccepted() && !g_bAccelActivated )
    00148             kde_g_bKillAccelOverride = true;
    00149
    00150         // Stop event processing if a KDE accelerator was activated.
    00151         return g_bAccelActivated;
    00152     }
    00153
    00154     return false;
    00155 }
    00156 #endif // Q_WS_X11
    00157
    00158 //---------------------------------------------------------------------
    00159 // KAccelPrivate
    00160 //---------------------------------------------------------------------
    00161
    00162 KAccelPrivate::KAccelPrivate( KAccel* pParent, QWidget* pWatch )
    00163 : KAccelBase( KAccelBase::QT_KEYS )
    00164 {
    00165     //kdDebug(125) << "KAccelPrivate::KAccelPrivate( pParent = " << pParent << " ): this = " << this << endl;
    00166     m_pAccel = pParent;
    00167     m_pWatch = pWatch;
    00168     m_bAutoUpdate = true;
    00169     connect( (QAccel*)m_pAccel, SIGNAL(activated(int)), this, SLOT(slotKeyPressed(int)) );
    00170
    00171     if( m_pWatch )
    00172         m_pWatch->installEventFilter( this );
    00173     KAccelEventHandler::self();
    00174 }
    00175
    00176 void KAccelPrivate::setEnabled( bool bEnabled )
    00177 {
    00178     m_bEnabled = bEnabled;
    00179     ((QAccel*)m_pAccel)->setEnabled( bEnabled );
    00180 }
    00181
    00182 bool KAccelPrivate::setEnabled( const QString& sAction, bool bEnable )
    00183 {
    00184     kdDebug(125) << "KAccelPrivate::setEnabled( \"" << sAction << "\", " << bEnable << " ): this = " << this << endl;
    00185     KAccelAction* pAction = actionPtr( sAction );
    00186     if( !pAction )
    00187         return false;
    00188     if( pAction->isEnabled() == bEnable )
    00189         return true;
    00190
    00191     pAction->setEnabled( bEnable );
    00192
    00193     QMap<int, KAccelAction*>::const_iterator it = m_mapIDToAction.begin();
    00194     for( ; it != m_mapIDToAction.end(); ++it ) {
    00195         if( *it == pAction )
    00196             ((QAccel*)m_pAccel)->setItemEnabled( it.key(), bEnable );
    00197     }
    00198     return true;
    00199 }
    00200
    00201 bool KAccelPrivate::removeAction( const QString& sAction )
    00202 {
    00203     // FIXME: getID() doesn't contains any useful
    00204     //  information!  Use mapIDToAction. --ellis, 2/May/2002
    00205     //  Or maybe KAccelBase::remove() takes care of QAccel indirectly...
    00206     KAccelAction* pAction = actions().actionPtr( sAction );
    00207     if( pAction ) {
    00208         int nID = pAction->getID();
    00209         //bool b = actions().removeAction( sAction );
    00210         bool b = KAccelBase::remove( sAction );
    00211         ((QAccel*)m_pAccel)->removeItem( nID );
    00212         return b;
    00213     } else
    00214         return false;
    00215 }
    00216
    00217 bool KAccelPrivate::emitSignal( KAccelBase::Signal signal )
    00218 {
    00219     if( signal == KAccelBase::KEYCODE_CHANGED ) {
    00220         m_pAccel->emitKeycodeChanged();
    00221         return true;
    00222     }
    00223     return false;
    00224 }
    00225
    00226 bool KAccelPrivate::connectKey( KAccelAction& action, const KKeyServer::Key& key )
    00227 {
    00228     uint keyQt = key.keyCodeQt();
    00229     int nID = ((QAccel*)m_pAccel)->insertItem( keyQt );
    00230     m_mapIDToAction[nID] = &action;
    00231     m_mapIDToKey[nID] = keyQt;
    00232
    00233     if( action.objSlotPtr() && action.methodSlotPtr() ) {
    00234         ((QAccel*)m_pAccel)->connectItem( nID, action.objSlotPtr(), action.methodSlotPtr() );
    00235         if( !action.isEnabled() )
    00236             ((QAccel*)m_pAccel)->setItemEnabled( nID, false );
    00237     }
    00238
    00239     kdDebug(125) << "KAccelPrivate::connectKey( \"" << action.name() << "\", " << key.key().toStringInternal() << " = 0x" << QString::number(keyQt,16) << " ): id = " << nID << " m_pObjSlot = " << action.objSlotPtr() << endl;
    00240     //kdDebug(125) << "m_pAccel = " << m_pAccel << endl;
    00241     return nID != 0;
    00242 }
    00243
    00244 bool KAccelPrivate::connectKey( const KKeyServer::Key& key )
    00245 {
    00246     uint keyQt = key.keyCodeQt();
    00247     int nID = ((QAccel*)m_pAccel)->insertItem( keyQt );
    00248
    00249     m_mapIDToKey[nID] = keyQt;
    00250
    00251     kdDebug(125) << "KAccelPrivate::connectKey( " << key.key().toStringInternal() << " = 0x" << QString::number(keyQt,16) << " ): id = " << nID << endl;
    00252     return nID != 0;
    00253 }
    00254
    00255 bool KAccelPrivate::disconnectKey( KAccelAction& action, const KKeyServer::Key& key )
    00256 {
    00257     int keyQt = key.keyCodeQt();
    00258     QMap<int, int>::iterator it = m_mapIDToKey.begin();
    00259     for( ; it != m_mapIDToKey.end(); ++it ) {
    00260         //kdDebug(125) << "m_mapIDToKey[" << it.key() << "] = " << QString::number(*it,16) << " == " << QString::number(keyQt,16) << endl;
    00261         if( *it == keyQt ) {
    00262             int nID = it.key();
    00263             kdDebug(125) << "KAccelPrivate::disconnectKey( \"" << action.name() << "\", 0x" << QString::number(keyQt,16) << " ) : id = " << nID << " m_pObjSlot = " << action.objSlotPtr() << endl;
    00264             ((QAccel*)m_pAccel)->removeItem( nID );
    00265             m_mapIDToAction.remove( nID );
    00266             m_mapIDToKey.remove( it );
    00267             return true;
    00268         }
    00269     }
    00270     //kdWarning(125) << kdBacktrace() << endl;
    00271     kdWarning(125) << "Didn't find key in m_mapIDToKey." << endl;
    00272     return false;
    00273 }
    00274
    00275 bool KAccelPrivate::disconnectKey( const KKeyServer::Key& key )
    00276 {
    00277     int keyQt = key.keyCodeQt();
    00278     kdDebug(125) << "KAccelPrivate::disconnectKey( 0x" << QString::number(keyQt,16) << " )" << endl;
    00279     QMap<int, int>::iterator it = m_mapIDToKey.begin();
    00280     for( ; it != m_mapIDToKey.end(); ++it ) {
    00281         if( *it == keyQt ) {
    00282             ((QAccel*)m_pAccel)->removeItem( it.key() );
    00283             m_mapIDToKey.remove( it );
    00284             return true;
    00285         }
    00286     }
    00287     //kdWarning(125) << kdBacktrace() << endl;
    00288     kdWarning(125) << "Didn't find key in m_mapIDTokey." << endl;
    00289     return false;
    00290 }
    00291
    00292 void KAccelPrivate::slotKeyPressed( int id )
    00293 {
    00294     kdDebug(125) << "KAccelPrivate::slotKeyPressed( " << id << " )" << endl;
    00295
    00296     if( m_mapIDToKey.contains( id ) ) {
    00297         KKey key = m_mapIDToKey[id];
    00298         KKeySequence seq( key );
    00299         QPopupMenu* pMenu = createPopupMenu( m_pWatch, seq );
    00300
    00301         // If there was only one action mapped to this key,
    00302         //  and that action is not a multi-key shortcut,
    00303         //  then activated it without popping up the menu.
    00304         // This is needed for when there are multiple actions
    00305         //  with the same shortcut where all but one is disabled.
    00306         // pMenu->count() also counts the menu title, so one shortcut will give count = 2.
    00307         if( pMenu->count() == 2 && pMenu->accel(1).isEmpty() ) {
    00308             int iAction = pMenu->idAt(1);
    00309             slotMenuActivated( iAction );
    00310         } else {
    00311             connect( pMenu, SIGNAL(activated(int)), this, SLOT(slotMenuActivated(int)) );
    00312             pMenu->exec( m_pWatch->mapToGlobal( QPoint( 0, 0 ) ) );
    00313             disconnect( pMenu, SIGNAL(activated(int)), this, SLOT(slotMenuActivated(int)) );
    00314         }
    00315         delete pMenu;
    00316     }
    00317 }
    00318
    00319 void KAccelPrivate::slotShowMenu()
    00320 {
    00321 }
    00322
    00323 void KAccelPrivate::slotMenuActivated( int iAction )
    00324 {
    00325     kdDebug(125) << "KAccelPrivate::slotMenuActivated( " << iAction << " )" << endl;
    00326     KAccelAction* pAction = actions().actionPtr( iAction );
    00327     if( pAction ) {
    00328         connect( this, SIGNAL(menuItemActivated()), pAction->objSlotPtr(), pAction->methodSlotPtr() );
    00329         emit menuItemActivated();
    00330         disconnect( this, SIGNAL(menuItemActivated()), pAction->objSlotPtr(), pAction->methodSlotPtr() );
    00331     }
    00332 }
    00333
    00334 bool KAccelPrivate::eventFilter( QObject* /*pWatched*/, QEvent* pEvent )
    00335 {
    00336     if( pEvent->type() == QEvent::AccelOverride && m_bEnabled ) {
    00337         QKeyEvent* pKeyEvent = (QKeyEvent*) pEvent;
    00338         KKey key( pKeyEvent );
    00339         kdDebug(125) << "KAccelPrivate::eventFilter( AccelOverride ): this = " << this << ", key = " << key.toStringInternal() << endl;
    00340         int keyCodeQt = key.keyCodeQt();
    00341         QMap<int, int>::iterator it = m_mapIDToKey.begin();
    00342         for( ; it != m_mapIDToKey.end(); ++it ) {
    00343             if( (*it) == keyCodeQt ) {
    00344                 int nID = it.key();
    00345                 kdDebug(125) << "shortcut found!" << endl;
    00346                 if( m_mapIDToAction.contains( nID ) ) {
    00347                     // TODO: reduce duplication between here and slotMenuActivated
    00348                     KAccelAction* pAction = m_mapIDToAction[nID];
    00349                     if( !pAction->isEnabled() )
    00350                         continue;
    00351                     QGuardedPtr<KAccelPrivate> me = this;
    00352                     connect( this, SIGNAL(menuItemActivated()), pAction->objSlotPtr(), pAction->methodSlotPtr() );
    00353                     emit menuItemActivated();
    00354                     if (me) {
    00355                         disconnect( me, SIGNAL(menuItemActivated()), pAction->objSlotPtr(), pAction->methodSlotPtr() );
    00356                     }
    00357                 } else
    00358                     slotKeyPressed( nID );
    00359
    00360                 pKeyEvent->accept();
    00361                 KAccelEventHandler::accelActivated( true );
    00362                 return true;
    00363             }
    00364         }
    00365     }
    00366     return false;
    00367 }
    00368
    00369 //---------------------------------------------------------------------
    00370 // KAccel
    00371 //---------------------------------------------------------------------
    00372
    00373 KAccel::KAccel( QWidget* pParent, const char* psName )
    00374 : QAccel( pParent, (psName) ? psName : "KAccel-QAccel" )
    00375 {
    00376     kdDebug(125) << "KAccel( pParent = " << pParent << ", psName = " << psName << " ): this = " << this << endl;
    00377     d = new KAccelPrivate( this, pParent );
    00378 }
    00379
    00380 KAccel::KAccel( QWidget* watch, QObject* pParent, const char* psName )
    00381 : QAccel( watch, pParent, (psName) ? psName : "KAccel-QAccel" )
    00382 {
    00383     kdDebug(125) << "KAccel( watch = " << watch << ", pParent = " << pParent << ", psName = " << psName << " ): this = " << this << endl;
    00384     if( !watch )
    00385         kdDebug(125) << kdBacktrace() << endl;
    00386     d = new KAccelPrivate( this, watch );
    00387 }
    00388
    00389 KAccel::~KAccel()
    00390 {
    00391     kdDebug(125) << "~KAccel(): this = " << this << endl;
    00392     delete d;
    00393 }
    00394
    00395 KAccelActions& KAccel::actions()             { return d->actions(); }
    00396 const KAccelActions& KAccel::actions() const { return d->actions(); }
    00397 bool KAccel::isEnabled()                     { return d->isEnabled(); }
    00398 void KAccel::setEnabled( bool bEnabled )     { d->setEnabled( bEnabled ); }
    00399 bool KAccel::setAutoUpdate( bool bAuto )     { return d->setAutoUpdate( bAuto ); }
    00400
    00401 KAccelAction* KAccel::insert( const QString& sAction, const QString& sLabel, const QString& sWhatsThis,
    00402         const KShortcut& cutDef,
    00403         const QObject* pObjSlot, const char* psMethodSlot,
    00404         bool bConfigurable, bool bEnabled )
    00405 {
    00406     return d->insert( sAction, sLabel, sWhatsThis,
    00407         cutDef, cutDef,
    00408         pObjSlot, psMethodSlot,
    00409         bConfigurable, bEnabled );
    00410 }
    00411
    00412 KAccelAction* KAccel::insert( const QString& sAction, const QString& sLabel, const QString& sWhatsThis,
    00413         const KShortcut& cutDef3, const KShortcut& cutDef4,
    00414         const QObject* pObjSlot, const char* psMethodSlot,
    00415         bool bConfigurable, bool bEnabled )
    00416 {
    00417     return d->insert( sAction, sLabel, sWhatsThis,
    00418         cutDef3, cutDef4,
    00419         pObjSlot, psMethodSlot,
    00420         bConfigurable, bEnabled );
    00421 }
    00422
    00423 KAccelAction* KAccel::insert( const char* psAction, const KShortcut& cutDef,
    00424         const QObject* pObjSlot, const char* psMethodSlot,
    00425         bool bConfigurable, bool bEnabled )
    00426 {
    00427     return d->insert( psAction, i18n(psAction), QString::null,
    00428         cutDef, cutDef,
    00429         pObjSlot, psMethodSlot,
    00430         bConfigurable, bEnabled );
    00431 }
    00432
    00433 KAccelAction* KAccel::insert( KStdAccel::StdAccel id,
    00434         const QObject* pObjSlot, const char* psMethodSlot,
    00435         bool bConfigurable, bool bEnabled )
    00436 {
    00437     QString sAction = KStdAccel::name( id );
    00438     if( sAction.isEmpty() )
    00439         return 0;
    00440
    00441     KAccelAction* pAction = d->insert( sAction, KStdAccel::label( id ), KStdAccel::whatsThis( id ),
    00442         KStdAccel::shortcutDefault3( id ), KStdAccel::shortcutDefault4( id ),
    00443         pObjSlot, psMethodSlot,
    00444         bConfigurable, bEnabled );
    00445     if( pAction )
    00446         pAction->setShortcut( KStdAccel::shortcut( id ) );
    00447
    00448     return pAction;
    00449 }
    00450
    00451 bool KAccel::remove( const QString& sAction )
    00452     { return d->removeAction( sAction ); }
    00453 bool KAccel::updateConnections()
    00454     { return d->updateConnections(); }
    00455
    00456 const KShortcut& KAccel::shortcut( const QString& sAction ) const
    00457 {
    00458     const KAccelAction* pAction = actions().actionPtr( sAction );
    00459     return (pAction) ? pAction->shortcut() : KShortcut::null();
    00460 }
    00461
    00462 bool KAccel::setSlot( const QString& sAction, const QObject* pObjSlot, const char* psMethodSlot )
    00463     { return d->setActionSlot( sAction, pObjSlot, psMethodSlot ); }
    00464
    00465 bool KAccel::setEnabled( const QString& sAction, bool bEnable )
    00466     { return d->setEnabled( sAction, bEnable ); }
    00467
    00468 bool KAccel::setShortcut( const QString& sAction, const KShortcut& cut )
    00469 {
    00470     kdDebug(125) << "KAccel::setShortcut( \"" << sAction << "\", " << cut.toStringInternal() << " )" << endl;
    00471     KAccelAction* pAction = actions().actionPtr( sAction );
    00472     if( pAction ) {
    00473         if( pAction->shortcut() != cut )
    00474             return d->setShortcut( sAction, cut );
    00475         return true;
    00476     }
    00477     return false;
    00478 }
    00479
    00480 const QString& KAccel::configGroup() const
    00481     { return d->configGroup(); }
    00482 // for kdegames/ksirtet
    00483 void KAccel::setConfigGroup( const QString& s )
    00484     { d->setConfigGroup( s ); }
    00485
    00486 bool KAccel::readSettings( KConfigBase* pConfig )
    00487 {
    00488     d->readSettings( pConfig );
    00489     return true;
    00490 }
    00491
    00492 bool KAccel::writeSettings( KConfigBase* pConfig ) const
    00493     { d->writeSettings( pConfig ); return true; }
    00494
    00495 void KAccel::emitKeycodeChanged()
    00496 {
    00497     kdDebug(125) << "KAccel::emitKeycodeChanged()" << endl;
    00498     emit keycodeChanged();
    00499 }
    00500
    00501 #ifndef KDE_NO_COMPAT
    00502 //------------------------------------------------------------
    00503 // Obsolete methods -- for backward compatibility
    00504 //------------------------------------------------------------
    00505
    00506 bool KAccel::insertItem( const QString& sLabel, const QString& sAction,
    00507         const char* cutsDef,
    00508         int /*nIDMenu*/, QPopupMenu *, bool bConfigurable )
    00509 {
    00510     KShortcut cut( cutsDef );
    00511     bool b = d->insert( sAction, sLabel, QString::null,
    00512         cut, cut,
    00513         0, 0,
    00514         bConfigurable ) != 0;
    00515     return b;
    00516 }
    00517
    00518 bool KAccel::insertItem( const QString& sLabel, const QString& sAction,
    00519         int key,
    00520         int /*nIDMenu*/, QPopupMenu*, bool bConfigurable )
    00521 {
    00522     KShortcut cut;
    00523     cut.init( QKeySequence(key) );
    00524     KAccelAction* pAction = d->insert( sAction, sLabel, QString::null,
    00525         cut, cut,
    00526         0, 0,
    00527         bConfigurable );
    00528     return pAction != 0;
    00529 }
    00530
    00531 // Used in kdeutils/kjots
    00532 bool KAccel::insertStdItem( KStdAccel::StdAccel id, const QString& sLabel )
    00533 {
    00534     KAccelAction* pAction = d->insert( KStdAccel::name( id ), sLabel, QString::null,
    00535         KStdAccel::shortcutDefault3( id ), KStdAccel::shortcutDefault4( id ),
    00536         0, 0 );
    00537     if( pAction )
    00538         pAction->setShortcut( KStdAccel::shortcut( id ) );
    00539
    00540     return true;
    00541 }
    00542
    00543 bool KAccel::connectItem( const QString& sAction, const QObject* pObjSlot, const char* psMethodSlot, bool bActivate )
    00544 {
    00545     kdDebug(125) << "KAccel::connectItem( " << sAction << ", " << pObjSlot << ", " << psMethodSlot << " )" << endl;
    00546     if( bActivate == false )
    00547         d->setActionEnabled( sAction, false );
    00548     bool b = setSlot( sAction, pObjSlot, psMethodSlot );
    00549     if( bActivate == true )
    00550         d->setActionEnabled( sAction, true );
    00551     return b;
    00552 }
    00553
    00554 bool KAccel::removeItem( const QString& sAction )
    00555     { return d->removeAction( sAction ); }
    00556
    00557 bool KAccel::setItemEnabled( const QString& sAction, bool bEnable )
    00558     { return setEnabled( sAction, bEnable ); }
    00559
    00560 void KAccel::changeMenuAccel( QPopupMenu *menu, int id, const QString& action )
    00561 {
    00562     KAccelAction* pAction = actions().actionPtr( action );
    00563     QString s = menu->text( id );
    00564     if( !pAction || s.isEmpty() )
    00565         return;
    00566
    00567     int i = s.find( '\t' );
    00568
    00569     QString k = pAction->shortcut().seq(0).toString();
    00570     if( k.isEmpty() )
    00571         return;
    00572
    00573     if ( i >= 0 )
    00574         s.replace( i+1, s.length()-i, k );
    00575     else {
    00576         s += '\t';
    00577         s += k;
    00578     }
    00579
    00580     QPixmap *pp = menu->pixmap(id);
    00581     if( pp && !pp->isNull() )
    00582         menu->changeItem( *pp, s, id );
    00583     else
    00584         menu->changeItem( s, id );
    00585 }
    00586
    00587 void KAccel::changeMenuAccel( QPopupMenu *menu, int id, KStdAccel::StdAccel accel )
    00588 {
    00589     changeMenuAccel( menu, id, KStdAccel::name( accel ) );
    00590 }
    00591
    00592 int KAccel::stringToKey( const QString& sKey )
    00593 {
    00594     return KKey( sKey ).keyCodeQt();
    00595 }
    00596
    00597 int KAccel::currentKey( const QString& sAction ) const
    00598 {
    00599     KAccelAction* pAction = d->actionPtr( sAction );
    00600     if( pAction )
    00601         return pAction->shortcut().keyCodeQt();
    00602     return 0;
    00603 }
    00604
    00605 QString KAccel::findKey( int key ) const
    00606 {
    00607     KAccelAction* pAction = d->actionPtr( KKey(key) );
    00608     if( pAction )
    00609         return pAction->name();
    00610     else
    00611         return QString::null;
    00612 }
    00613 #endif // !KDE_NO_COMPAT
    00614
    00615 void KAccel::virtual_hook( int, void* )
    00616 { /*BASE::virtual_hook( id, data );*/ }
    00617
    00618 #include "kaccel.moc"
    00619 #include "kaccelprivate.moc"

This file is part of the documentation for kdecore Library Version 3.4.1.
Documentation copyright © 1996-2004 the KDE developers.
Generated on Sat Jun 11 20:18:00 2005 by doxygen 1.4.1 written by Dimitri van Heesch, © 1997-2003