kdecore Library API Documentation

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 <qpopupmenu.h>
00024 #include <qstring.h>
00025 #include <qtimer.h>
00026 
00027 #include <kaccelbase.h>
00028 #include <kapplication.h>
00029 #include <kdebug.h>
00030 #include <klocale.h>
00031 #include <kshortcut.h>
00032 
00033 #include "kaccelprivate.h"
00034 
00035 #ifdef Q_WS_X11
00036 #   include <X11/Xlib.h>
00037 #   ifdef KeyPress // needed for --enable-final
00038         // defined by X11 headers
00039         const int XKeyPress = KeyPress;
00040 #       undef KeyPress
00041 #   endif
00042 #endif
00043 
00044 // TODO: Put in kaccelbase.cpp
00045 //---------------------------------------------------------------------
00046 // KAccelEventHandler
00047 //---------------------------------------------------------------------
00048 
00049 bool g_bKillAccelOverride = false;
00050 
00051 class KAccelEventHandler : public QWidget
00052 {
00053  public:
00054     static KAccelEventHandler* self()
00055     {
00056         if( !g_pSelf )
00057             g_pSelf = new KAccelEventHandler;
00058         return g_pSelf;
00059     }
00060     
00061     static bool active() { return g_bActive; }
00062     static void accelActivated( bool b ) { g_bAccelActivated = b; }
00063     
00064  private:
00065     KAccelEventHandler();
00066 
00067 #   ifdef Q_WS_X11
00068     bool x11Event( XEvent* pEvent );
00069 #   endif
00070 
00071     static KAccelEventHandler* g_pSelf;
00072     static bool g_bActive;
00073     static bool g_bAccelActivated;
00074 };
00075 
00076 KAccelEventHandler* KAccelEventHandler::g_pSelf = 0;
00077 bool KAccelEventHandler::g_bActive = false;
00078 bool KAccelEventHandler::g_bAccelActivated = false;
00079 
00080 KAccelEventHandler::KAccelEventHandler()
00081 {
00082 #   ifdef Q_WS_X11
00083         kapp->installX11EventFilter( this );
00084 #   endif
00085 }
00086 
00087 #ifdef Q_WS_X11
00088 bool KAccelEventHandler::x11Event( XEvent* pEvent )
00089 {
00090     if( QWidget::keyboardGrabber() || !kapp->focusWidget() )
00091         return false;
00092     
00093     if( pEvent->type == XKeyPress ) {
00094         KKeyNative keyNative( pEvent );
00095         KKey key( keyNative );
00096         key.simplify();
00097         int keyCodeQt = key.keyCodeQt();
00098         int state = 0;
00099         if( key.modFlags() & KKey::SHIFT ) state |= Qt::ShiftButton;
00100         if( key.modFlags() & KKey::CTRL )  state |= Qt::ControlButton;
00101         if( key.modFlags() & KKey::ALT )   state |= Qt::AltButton;
00102         
00103         QKeyEvent ke( QEvent::AccelOverride, keyCodeQt, 0,  state );
00104         ke.ignore();
00105         
00106         g_bActive = true;
00107         g_bAccelActivated = false;
00108         kapp->sendEvent( kapp->focusWidget(), &ke );
00109         g_bActive = false;
00110         
00111         // If the Override event was accepted from a non-KAccel widget,
00112         //  then kill the next AccelOverride in KApplication::notify.
00113         if( ke.isAccepted() && !g_bAccelActivated )
00114             g_bKillAccelOverride = true;
00115         
00116         // Stop event processing if a KDE accelerator was activated.
00117         return g_bAccelActivated;
00118     }
00119     
00120     return false;
00121 }
00122 #endif // Q_WS_X11
00123 
00124 //---------------------------------------------------------------------
00125 // KAccelPrivate
00126 //---------------------------------------------------------------------
00127 
00128 KAccelPrivate::KAccelPrivate( KAccel* pParent, QWidget* pWatch )
00129 : KAccelBase( KAccelBase::QT_KEYS )
00130 {
00131     //kdDebug(125) << "KAccelPrivate::KAccelPrivate( pParent = " << pParent << " ): this = " << this << endl;
00132     m_pAccel = pParent;
00133     m_pWatch = pWatch;
00134     m_bAutoUpdate = true;
00135     connect( (QAccel*)m_pAccel, SIGNAL(activated(int)), this, SLOT(slotKeyPressed(int)) );
00136 
00137     if( m_pWatch )
00138         m_pWatch->installEventFilter( this );
00139     KAccelEventHandler::self();
00140 }
00141 
00142 void KAccelPrivate::setEnabled( bool bEnabled )
00143 {
00144     m_bEnabled = bEnabled;
00145     ((QAccel*)m_pAccel)->setEnabled( bEnabled );
00146 }
00147 
00148 bool KAccelPrivate::setEnabled( const QString& sAction, bool bEnable )
00149 {
00150     kdDebug(125) << "KAccelPrivate::setEnabled( \"" << sAction << "\", " << bEnable << " ): this = " << this << endl;
00151     KAccelAction* pAction = actionPtr( sAction );
00152     if( !pAction )
00153         return false;
00154     if( pAction->isEnabled() == bEnable )
00155         return true;
00156 
00157     pAction->setEnabled( bEnable );
00158 
00159     QMap<int, KAccelAction*>::iterator it = m_mapIDToAction.begin();
00160     for( ; it != m_mapIDToAction.end(); ++it ) {
00161         if( *it == pAction )
00162             ((QAccel*)m_pAccel)->setItemEnabled( it.key(), bEnable );
00163     }
00164     return true;
00165 }
00166 
00167 bool KAccelPrivate::removeAction( const QString& sAction )
00168 {
00169     // FIXME: getID() doesn't contains any useful 
00170     //  information!  Use mapIDToAction. --ellis, 2/May/2002
00171     //  Or maybe KAccelBase::remove() takes care of QAccel indirectly...
00172     KAccelAction* pAction = actions().actionPtr( sAction );
00173     if( pAction ) {
00174         int nID = pAction->getID();
00175         //bool b = actions().removeAction( sAction );
00176         bool b = KAccelBase::remove( sAction );
00177         ((QAccel*)m_pAccel)->removeItem( nID );
00178         return b;
00179     } else
00180         return false;
00181 }
00182 
00183 bool KAccelPrivate::emitSignal( KAccelBase::Signal signal )
00184 {
00185     if( signal == KAccelBase::KEYCODE_CHANGED ) {
00186         m_pAccel->emitKeycodeChanged();
00187         return true;
00188     }
00189     return false;
00190 }
00191 
00192 bool KAccelPrivate::connectKey( KAccelAction& action, const KKeyServer::Key& key )
00193 {
00194     uint keyQt = key.keyCodeQt();
00195     int nID = ((QAccel*)m_pAccel)->insertItem( keyQt );
00196     m_mapIDToAction[nID] = &action;
00197     m_mapIDToKey[nID] = keyQt;
00198 
00199     if( action.objSlotPtr() && action.methodSlotPtr() ) {
00200         ((QAccel*)m_pAccel)->connectItem( nID, action.objSlotPtr(), action.methodSlotPtr() );
00201         if( !action.isEnabled() )
00202             ((QAccel*)m_pAccel)->setItemEnabled( nID, false );
00203     }
00204 
00205     kdDebug(125) << "KAccelPrivate::connectKey( \"" << action.name() << "\", " << key.key().toStringInternal() << " = 0x" << QString::number(keyQt,16) << " ): id = " << nID << " m_pObjSlot = " << action.objSlotPtr() << endl;
00206     //kdDebug(125) << "m_pAccel = " << m_pAccel << endl;
00207     return nID != 0;
00208 }
00209 
00210 bool KAccelPrivate::connectKey( const KKeyServer::Key& key )
00211 {
00212     uint keyQt = key.keyCodeQt();
00213     int nID = ((QAccel*)m_pAccel)->insertItem( keyQt );
00214 
00215     m_mapIDToKey[nID] = keyQt;
00216 
00217     kdDebug(125) << "KAccelPrivate::connectKey( " << key.key().toStringInternal() << " = 0x" << QString::number(keyQt,16) << " ): id = " << nID << endl;
00218     return nID != 0;
00219 }
00220 
00221 bool KAccelPrivate::disconnectKey( KAccelAction& action, const KKeyServer::Key& key )
00222 {
00223     int keyQt = key.keyCodeQt();
00224     QMap<int, int>::iterator it = m_mapIDToKey.begin();
00225     for( ; it != m_mapIDToKey.end(); ++it ) {
00226         //kdDebug(125) << "m_mapIDToKey[" << it.key() << "] = " << QString::number(*it,16) << " == " << QString::number(keyQt,16) << endl;
00227         if( *it == keyQt ) {
00228             int nID = it.key();
00229             kdDebug(125) << "KAccelPrivate::disconnectKey( \"" << action.name() << "\", 0x" << QString::number(keyQt,16) << " ) : id = " << nID << " m_pObjSlot = " << action.objSlotPtr() << endl;
00230             ((QAccel*)m_pAccel)->removeItem( nID );
00231             m_mapIDToAction.remove( nID );
00232             m_mapIDToKey.remove( it );
00233             return true;
00234         }
00235     }
00236     //kdWarning(125) << kdBacktrace() << endl;
00237     kdWarning(125) << "Didn't find key in m_mapIDToKey." << endl;
00238     return false;
00239 }
00240 
00241 bool KAccelPrivate::disconnectKey( const KKeyServer::Key& key )
00242 {
00243     int keyQt = key.keyCodeQt();
00244     kdDebug(125) << "KAccelPrivate::disconnectKey( 0x" << QString::number(keyQt,16) << " )" << endl;
00245     QMap<int, int>::iterator it = m_mapIDToKey.begin();
00246     for( ; it != m_mapIDToKey.end(); ++it ) {
00247         if( *it == keyQt ) {
00248             ((QAccel*)m_pAccel)->removeItem( it.key() );
00249             m_mapIDToKey.remove( it );
00250             return true;
00251         }
00252     }
00253     //kdWarning(125) << kdBacktrace() << endl;
00254     kdWarning(125) << "Didn't find key in m_mapIDTokey." << endl;
00255     return false;
00256 }
00257 
00258 void KAccelPrivate::slotKeyPressed( int id )
00259 {
00260     kdDebug(125) << "KAccelPrivate::slotKeyPressed( " << id << " )" << endl;
00261     
00262     if( m_mapIDToKey.contains( id ) ) {
00263         KKey key = m_mapIDToKey[id];
00264         KKeySequence seq( key );
00265         QPopupMenu* pMenu = createPopupMenu( m_pWatch, seq );
00266 
00267         // If there was only one action mapped to this key,
00268         //  and that action is not a multi-key shortcut,
00269         //  then activated it without popping up the menu.
00270         // This is needed for when there are multiple actions
00271         //  with the same shortcut where all but one is disabled.
00272         // pMenu->count() also counts the menu title, so one shortcut will give count = 2.
00273         if( pMenu->count() == 2 && static_cast<int>( pMenu->accel(1) ) == 0 ) { // ### use the faster isEmpty() once we require Qt 3.1 (Simon)
00274             int iAction = pMenu->idAt(1);
00275             slotMenuActivated( iAction );
00276         } else {
00277             connect( pMenu, SIGNAL(activated(int)), this, SLOT(slotMenuActivated(int)) );
00278             pMenu->exec( m_pWatch->mapToGlobal( QPoint( 0, 0 ) ) );
00279             disconnect( pMenu, SIGNAL(activated(int)), this, SLOT(slotMenuActivated(int)) );
00280         }
00281         delete pMenu;
00282     }
00283 }
00284 
00285 void KAccelPrivate::slotShowMenu()
00286 {
00287 }
00288 
00289 void KAccelPrivate::slotMenuActivated( int iAction )
00290 {
00291     kdDebug(125) << "KAccelPrivate::slotMenuActivated( " << iAction << " )" << endl;
00292     KAccelAction* pAction = actions().actionPtr( iAction );
00293     if( pAction ) {
00294         connect( this, SIGNAL(menuItemActivated()), pAction->objSlotPtr(), pAction->methodSlotPtr() );
00295         emit menuItemActivated();
00296         disconnect( this, SIGNAL(menuItemActivated()), pAction->objSlotPtr(), pAction->methodSlotPtr() );
00297     }
00298 }
00299 
00300 bool KAccelPrivate::eventFilter( QObject* /*pWatched*/, QEvent* pEvent )
00301 {
00302     if( KAccelEventHandler::active() && pEvent->type() == QEvent::AccelOverride && m_bEnabled ) {
00303         QKeyEvent* pKeyEvent = (QKeyEvent*) pEvent;
00304         KKey key( pKeyEvent );
00305         kdDebug(125) << "KAccelPrivate::eventFilter( AccelOverride ): this = " << this << ", key = " << key.toStringInternal() << endl;
00306         int keyCodeQt = key.keyCodeQt();
00307         QMap<int, int>::iterator it = m_mapIDToKey.begin();
00308         for( ; it != m_mapIDToKey.end(); ++it ) {
00309             if( (*it) == keyCodeQt ) {
00310                 int nID = it.key();
00311                 kdDebug(125) << "shortcut found!" << endl;
00312                 if( m_mapIDToAction.contains( nID ) ) {
00313                     // TODO: reduce duplication between here and slotMenuActivated
00314                     KAccelAction* pAction = m_mapIDToAction[nID];
00315                     if( !pAction->isEnabled() ) 
00316                         continue;
00317                     connect( this, SIGNAL(menuItemActivated()), pAction->objSlotPtr(), pAction->methodSlotPtr() );
00318                     emit menuItemActivated();
00319                     disconnect( this, SIGNAL(menuItemActivated()), pAction->objSlotPtr(), pAction->methodSlotPtr() );
00320                 } else
00321                     slotKeyPressed( nID );
00322                 
00323                 pKeyEvent->accept();
00324                 KAccelEventHandler::accelActivated( true );
00325                 return true;
00326             }
00327         }
00328     }
00329     return false;
00330 }
00331 
00332 //---------------------------------------------------------------------
00333 // KAccel
00334 //---------------------------------------------------------------------
00335 
00336 KAccel::KAccel( QWidget* pParent, const char* psName )
00337 : QAccel( pParent, (psName) ? psName : "KAccel-QAccel" )
00338 {
00339     kdDebug(125) << "KAccel( pParent = " << pParent << ", psName = " << psName << " ): this = " << this << endl;
00340     d = new KAccelPrivate( this, pParent );
00341 }
00342 
00343 KAccel::KAccel( QWidget* watch, QObject* pParent, const char* psName )
00344 : QAccel( watch, pParent, (psName) ? psName : "KAccel-QAccel" )
00345 {
00346     kdDebug(125) << "KAccel( watch = " << watch << ", pParent = " << pParent << ", psName = " << psName << " ): this = " << this << endl;
00347     if( !watch )
00348         kdDebug(125) << kdBacktrace() << endl;
00349     d = new KAccelPrivate( this, watch );
00350 }
00351 
00352 KAccel::~KAccel()
00353 {
00354     kdDebug(125) << "~KAccel(): this = " << this << endl;
00355     delete d;
00356 }
00357 
00358 KAccelActions& KAccel::actions()             { return d->actions(); }
00359 const KAccelActions& KAccel::actions() const { return d->actions(); }
00360 bool KAccel::isEnabled()                     { return d->isEnabled(); }
00361 void KAccel::setEnabled( bool bEnabled )     { d->setEnabled( bEnabled ); }
00362 bool KAccel::setAutoUpdate( bool bAuto )     { return d->setAutoUpdate( bAuto ); }
00363 
00364 KAccelAction* KAccel::insert( const QString& sAction, const QString& sLabel, const QString& sWhatsThis,
00365         const KShortcut& cutDef,
00366         const QObject* pObjSlot, const char* psMethodSlot,
00367         bool bConfigurable, bool bEnabled )
00368 {
00369     return d->insert( sAction, sLabel, sWhatsThis,
00370         cutDef, cutDef,
00371         pObjSlot, psMethodSlot,
00372         bConfigurable, bEnabled );
00373 }
00374 
00375 KAccelAction* KAccel::insert( const QString& sAction, const QString& sLabel, const QString& sWhatsThis,
00376         const KShortcut& cutDef3, const KShortcut& cutDef4,
00377         const QObject* pObjSlot, const char* psMethodSlot,
00378         bool bConfigurable, bool bEnabled )
00379 {
00380     return d->insert( sAction, sLabel, sWhatsThis,
00381         cutDef3, cutDef4,
00382         pObjSlot, psMethodSlot,
00383         bConfigurable, bEnabled );
00384 }
00385 
00386 KAccelAction* KAccel::insert( const char* psAction, const KShortcut& cutDef,
00387         const QObject* pObjSlot, const char* psMethodSlot,
00388         bool bConfigurable, bool bEnabled )
00389 {
00390     return d->insert( psAction, i18n(psAction), QString::null,
00391         cutDef, cutDef,
00392         pObjSlot, psMethodSlot,
00393         bConfigurable, bEnabled );
00394 }
00395 
00396 KAccelAction* KAccel::insert( KStdAccel::StdAccel id,
00397         const QObject* pObjSlot, const char* psMethodSlot,
00398         bool bConfigurable, bool bEnabled )
00399 {
00400     QString sAction = KStdAccel::action( id );
00401     if( sAction.isEmpty() )
00402         return 0;
00403 
00404     KAccelAction* pAction = d->insert( sAction, KStdAccel::label( id ), KStdAccel::whatsThis( id ),
00405         KStdAccel::shortcutDefault3( id ), KStdAccel::shortcutDefault4( id ),
00406         pObjSlot, psMethodSlot,
00407         bConfigurable, bEnabled );
00408     if( pAction )
00409         pAction->setShortcut( KStdAccel::shortcut( id ) );
00410 
00411     return pAction;
00412 }
00413 
00414 bool KAccel::remove( const QString& sAction )
00415     { return d->removeAction( sAction ); }
00416 bool KAccel::updateConnections()
00417     { return d->updateConnections(); }
00418 
00419 const KShortcut& KAccel::shortcut( const QString& sAction ) const
00420 {
00421     const KAccelAction* pAction = actions().actionPtr( sAction );
00422     return (pAction) ? pAction->shortcut() : KShortcut::null();
00423 }
00424 
00425 bool KAccel::setSlot( const QString& sAction, const QObject* pObjSlot, const char* psMethodSlot )
00426     { return d->setActionSlot( sAction, pObjSlot, psMethodSlot ); }
00427 
00428 bool KAccel::setEnabled( const QString& sAction, bool bEnable )
00429     { return d->setEnabled( sAction, bEnable ); }
00430 
00431 bool KAccel::setShortcut( const QString& sAction, const KShortcut& cut )
00432 {
00433     kdDebug(125) << "KAccel::setShortcut( \"" << sAction << "\", " << cut.toStringInternal() << " )" << endl;
00434     KAccelAction* pAction = actions().actionPtr( sAction );
00435     if( pAction ) {
00436         if( pAction->shortcut() != cut )
00437             return d->setShortcut( sAction, cut );
00438         return true;
00439     }
00440     return false;
00441 }
00442 
00443 const QString& KAccel::configGroup() const
00444     { return d->configGroup(); }
00445 // for kdegames/ksirtet
00446 void KAccel::setConfigGroup( const QString& s )
00447     { d->setConfigGroup( s ); }
00448 
00449 bool KAccel::readSettings( KConfigBase* pConfig )
00450 {
00451     d->readSettings( pConfig );
00452     return true;
00453 }
00454 
00455 bool KAccel::writeSettings( KConfigBase* pConfig ) const
00456     { d->writeSettings( pConfig ); return true; }
00457 
00458 void KAccel::emitKeycodeChanged()
00459 {
00460     kdDebug(125) << "KAccel::emitKeycodeChanged()" << endl;
00461     emit keycodeChanged();
00462 }
00463 
00464 #ifndef KDE_NO_COMPAT
00465 //------------------------------------------------------------
00466 // Obsolete methods -- for backward compatibility
00467 //------------------------------------------------------------
00468 
00469 bool KAccel::insertItem( const QString& sLabel, const QString& sAction,
00470         const char* cutsDef,
00471         int /*nIDMenu*/, QPopupMenu *, bool bConfigurable )
00472 {
00473     KShortcut cut( cutsDef );
00474     bool b = d->insert( sAction, sLabel, QString::null,
00475         cut, cut,
00476         0, 0,
00477         bConfigurable ) != 0;
00478     return b;
00479 }
00480 
00481 bool KAccel::insertItem( const QString& sLabel, const QString& sAction,
00482         int key,
00483         int /*nIDMenu*/, QPopupMenu*, bool bConfigurable )
00484 {
00485     KShortcut cut;
00486     cut.init( QKeySequence(key) );
00487     KAccelAction* pAction = d->insert( sAction, sLabel, QString::null,
00488         cut, cut,
00489         0, 0,
00490         bConfigurable );
00491     return pAction != 0;
00492 }
00493 
00494 // Used in kdeutils/kjots
00495 bool KAccel::insertStdItem( KStdAccel::StdAccel id, const QString& sLabel )
00496 {
00497     KAccelAction* pAction = d->insert( KStdAccel::action( id ), sLabel, QString::null,
00498         KStdAccel::shortcutDefault3( id ), KStdAccel::shortcutDefault4( id ),
00499         0, 0 );
00500     if( pAction )
00501         pAction->setShortcut( KStdAccel::shortcut( id ) );
00502 
00503     return true;
00504 }
00505 
00506 bool KAccel::connectItem( const QString& sAction, const QObject* pObjSlot, const char* psMethodSlot, bool bActivate )
00507 {
00508     kdDebug(125) << "KAccel::connectItem( " << sAction << ", " << pObjSlot << ", " << psMethodSlot << " )" << endl;
00509     if( bActivate == false )
00510         d->setActionEnabled( sAction, false );
00511     bool b = setSlot( sAction, pObjSlot, psMethodSlot );
00512     if( bActivate == true )
00513         d->setActionEnabled( sAction, true );
00514     return b;
00515 }
00516 
00517 bool KAccel::removeItem( const QString& sAction )
00518     { return d->removeAction( sAction ); }
00519 
00520 bool KAccel::setItemEnabled( const QString& sAction, bool bEnable )
00521     { return setEnabled( sAction, bEnable ); }
00522 
00523 void KAccel::changeMenuAccel( QPopupMenu *menu, int id, const QString& action )
00524 {
00525     KAccelAction* pAction = actions().actionPtr( action );
00526     QString s = menu->text( id );
00527     if( !pAction || s.isEmpty() )
00528         return;
00529 
00530     int i = s.find( '\t' );
00531 
00532     QString k = pAction->shortcut().seq(0).toString();
00533     if( k.isEmpty() )
00534         return;
00535 
00536     if ( i >= 0 )
00537         s.replace( i+1, s.length()-i, k );
00538     else {
00539         s += '\t';
00540         s += k;
00541     }
00542 
00543     QPixmap *pp = menu->pixmap(id);
00544     if( pp && !pp->isNull() )
00545         menu->changeItem( *pp, s, id );
00546     else
00547         menu->changeItem( s, id );
00548 }
00549 
00550 void KAccel::changeMenuAccel( QPopupMenu *menu, int id, KStdAccel::StdAccel accel )
00551 {
00552     changeMenuAccel( menu, id, KStdAccel::name( accel ) );
00553 }
00554 
00555 int KAccel::stringToKey( const QString& sKey )
00556 {
00557     return KKey( sKey ).keyCodeQt();
00558 }
00559 
00560 int KAccel::currentKey( const QString& sAction ) const
00561 {
00562     KAccelAction* pAction = d->actionPtr( sAction );
00563     if( pAction )
00564         return pAction->shortcut().keyCodeQt();
00565     return 0;
00566 }
00567 
00568 QString KAccel::findKey( int key ) const
00569 {
00570     KAccelAction* pAction = d->actionPtr( KKey(key) );
00571     if( pAction )
00572         return pAction->name();
00573     else
00574         return QString::null;
00575 }
00576 #endif // !KDE_NO_COMPAT
00577 
00578 void KAccel::virtual_hook( int, void* )
00579 { /*BASE::virtual_hook( id, data );*/ }
00580 
00581 #include <kaccel.moc>
00582 #include <kaccelprivate.moc>
KDE Logo
This file is part of the documentation for kdelibs Version 3.1.0.
Documentation copyright © 1996-2002 the KDE developers.
Generated on Wed Oct 8 12:20:39 2003 by doxygen 1.2.18 written by Dimitri van Heesch, © 1997-2001