00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027 #include "kactionclasses.h"
00028
00029 #include <assert.h>
00030
00031 #include <qcursor.h>
00032 #include <qclipboard.h>
00033 #include <qfontdatabase.h>
00034 #include <qobjectlist.h>
00035 #include <qwhatsthis.h>
00036 #include <qtimer.h>
00037
00038 #include <dcopclient.h>
00039 #include <dcopref.h>
00040 #include <kaccel.h>
00041 #include <kapplication.h>
00042 #include <kconfig.h>
00043 #include <kdebug.h>
00044 #include <kfontcombo.h>
00045 #include <kfontdialog.h>
00046 #include <klocale.h>
00047 #include <kmainwindow.h>
00048 #include <kmenubar.h>
00049 #include <kpopupmenu.h>
00050 #include <ktoolbar.h>
00051 #include <ktoolbarbutton.h>
00052 #include <kurl.h>
00053 #include <kstandarddirs.h>
00054 #include <kstringhandler.h>
00055
00056 class KToggleAction::KToggleActionPrivate
00057 {
00058 public:
00059 KToggleActionPrivate()
00060 {
00061 m_checked = false;
00062 m_checkedGuiItem = 0;
00063 }
00064
00065 bool m_checked;
00066 QString m_exclusiveGroup;
00067 KGuiItem* m_checkedGuiItem;
00068 };
00069
00070 KToggleAction::KToggleAction( const QString& text, const KShortcut& cut,
00071 QObject* parent,
00072 const char* name )
00073 : KAction( text, cut, parent, name )
00074 {
00075 d = new KToggleActionPrivate;
00076 }
00077
00078 KToggleAction::KToggleAction( const QString& text, const KShortcut& cut,
00079 const QObject* receiver, const char* slot,
00080 QObject* parent, const char* name )
00081 : KAction( text, cut, receiver, slot, parent, name )
00082 {
00083 d = new KToggleActionPrivate;
00084 }
00085
00086 KToggleAction::KToggleAction( const QString& text, const QIconSet& pix,
00087 const KShortcut& cut,
00088 QObject* parent, const char* name )
00089 : KAction( text, pix, cut, parent, name )
00090 {
00091 d = new KToggleActionPrivate;
00092 }
00093
00094 KToggleAction::KToggleAction( const QString& text, const QString& pix,
00095 const KShortcut& cut,
00096 QObject* parent, const char* name )
00097 : KAction( text, pix, cut, parent, name )
00098 {
00099 d = new KToggleActionPrivate;
00100 }
00101
00102 KToggleAction::KToggleAction( const QString& text, const QIconSet& pix,
00103 const KShortcut& cut,
00104 const QObject* receiver,
00105 const char* slot, QObject* parent,
00106 const char* name )
00107 : KAction( text, pix, cut, receiver, slot, parent, name )
00108 {
00109 d = new KToggleActionPrivate;
00110 }
00111
00112 KToggleAction::KToggleAction( const QString& text, const QString& pix,
00113 const KShortcut& cut,
00114 const QObject* receiver,
00115 const char* slot, QObject* parent,
00116 const char* name )
00117 : KAction( text, pix, cut, receiver, slot, parent, name )
00118 {
00119 d = new KToggleActionPrivate;
00120 }
00121
00122 KToggleAction::KToggleAction( QObject* parent, const char* name )
00123 : KAction( parent, name )
00124 {
00125 d = new KToggleActionPrivate;
00126 }
00127
00128 KToggleAction::~KToggleAction()
00129 {
00130 delete d->m_checkedGuiItem;
00131 delete d;
00132 }
00133
00134 int KToggleAction::plug( QWidget* widget, int index )
00135 {
00136 if ( !::qt_cast<QPopupMenu *>( widget ) && !::qt_cast<KToolBar *>( widget ) )
00137 {
00138 kdWarning() << "Can not plug KToggleAction in " << widget->className() << endl;
00139 return -1;
00140 }
00141 if (kapp && !kapp->authorizeKAction(name()))
00142 return -1;
00143
00144 int _index = KAction::plug( widget, index );
00145 if ( _index == -1 )
00146 return _index;
00147
00148 if ( ::qt_cast<KToolBar *>( widget ) ) {
00149 KToolBar *bar = static_cast<KToolBar *>( widget );
00150
00151 bar->setToggle( itemId( _index ), true );
00152 bar->setButton( itemId( _index ), isChecked() );
00153 }
00154
00155 if ( d->m_checked )
00156 updateChecked( _index );
00157
00158 return _index;
00159 }
00160
00161 void KToggleAction::setChecked( bool c )
00162 {
00163 if ( c == d->m_checked )
00164 return;
00165
00166
00167 d->m_checked = c;
00168
00169 int len = containerCount();
00170
00171 for( int i = 0; i < len; ++i )
00172 updateChecked( i );
00173
00174 if ( c && parent() && !exclusiveGroup().isEmpty() ) {
00175 const QObjectList *list = parent()->children();
00176 if ( list ) {
00177 QObjectListIt it( *list );
00178 for( ; it.current(); ++it ) {
00179 if ( ::qt_cast<KToggleAction *>( it.current() ) && it.current() != this &&
00180 static_cast<KToggleAction*>(it.current())->exclusiveGroup() == exclusiveGroup() ) {
00181 KToggleAction *a = static_cast<KToggleAction*>(it.current());
00182 if( a->isChecked() ) {
00183 a->setChecked( false );
00184 emit a->toggled( false );
00185 }
00186 }
00187 }
00188 }
00189 }
00190 }
00191
00192 void KToggleAction::updateChecked( int id )
00193 {
00194 QWidget *w = container( id );
00195
00196 if ( ::qt_cast<QPopupMenu *>( w ) ) {
00197 QPopupMenu* pm = static_cast<QPopupMenu*>(w);
00198 int itemId_ = itemId( id );
00199 if ( !d->m_checkedGuiItem )
00200 pm->setItemChecked( itemId_, d->m_checked );
00201 else {
00202 const KGuiItem* gui = d->m_checked ? d->m_checkedGuiItem : &guiItem();
00203 if ( d->m_checkedGuiItem->hasIcon() )
00204 pm->changeItem( itemId_, gui->iconSet( KIcon::Small ), gui->text() );
00205 else
00206 pm->changeItem( itemId_, gui->text() );
00207 if ( !d->m_checkedGuiItem->whatsThis().isEmpty() )
00208 pm->setWhatsThis( itemId_, gui->whatsThis() );
00209 updateShortcut( pm, itemId_ );
00210 }
00211 }
00212 else if ( ::qt_cast<QMenuBar *>( w ) )
00213 static_cast<QMenuBar*>(w)->setItemChecked( itemId( id ), d->m_checked );
00214 else if ( ::qt_cast<KToolBar *>( w ) )
00215 {
00216 QWidget* r = static_cast<KToolBar*>( w )->getButton( itemId( id ) );
00217 if ( r && ::qt_cast<KToolBarButton *>( r ) ) {
00218 static_cast<KToolBar*>( w )->setButton( itemId( id ), d->m_checked );
00219 if ( d->m_checkedGuiItem && d->m_checkedGuiItem->hasIcon() ) {
00220 const KGuiItem* gui = d->m_checked ? d->m_checkedGuiItem : &guiItem();
00221 static_cast<KToolBar*>( w )->setButtonIconSet( itemId( id ), gui->iconSet( KIcon::Toolbar ) );
00222 }
00223 }
00224 }
00225 }
00226
00227 void KToggleAction::slotActivated()
00228 {
00229 setChecked( !isChecked() );
00230 KAction::slotActivated();
00231 emit toggled( isChecked() );
00232 }
00233
00234 bool KToggleAction::isChecked() const
00235 {
00236 return d->m_checked;
00237 }
00238
00239 void KToggleAction::setExclusiveGroup( const QString& name )
00240 {
00241 d->m_exclusiveGroup = name;
00242 }
00243
00244 QString KToggleAction::exclusiveGroup() const
00245 {
00246 return d->m_exclusiveGroup;
00247 }
00248
00249 void KToggleAction::setCheckedState( const KGuiItem& checkedItem )
00250 {
00251 delete d->m_checkedGuiItem;
00252 d->m_checkedGuiItem = new KGuiItem( checkedItem );
00253 }
00254
00255 QString KToggleAction::toolTip() const
00256 {
00257 if ( d->m_checkedGuiItem && d->m_checked )
00258 return d->m_checkedGuiItem->toolTip();
00259 else
00260 return KAction::toolTip();
00261 }
00262
00263 KRadioAction::KRadioAction( const QString& text, const KShortcut& cut,
00264 QObject* parent, const char* name )
00265 : KToggleAction( text, cut, parent, name )
00266 {
00267 }
00268
00269 KRadioAction::KRadioAction( const QString& text, const KShortcut& cut,
00270 const QObject* receiver, const char* slot,
00271 QObject* parent, const char* name )
00272 : KToggleAction( text, cut, receiver, slot, parent, name )
00273 {
00274 }
00275
00276 KRadioAction::KRadioAction( const QString& text, const QIconSet& pix,
00277 const KShortcut& cut,
00278 QObject* parent, const char* name )
00279 : KToggleAction( text, pix, cut, parent, name )
00280 {
00281 }
00282
00283 KRadioAction::KRadioAction( const QString& text, const QString& pix,
00284 const KShortcut& cut,
00285 QObject* parent, const char* name )
00286 : KToggleAction( text, pix, cut, parent, name )
00287 {
00288 }
00289
00290 KRadioAction::KRadioAction( const QString& text, const QIconSet& pix,
00291 const KShortcut& cut,
00292 const QObject* receiver, const char* slot,
00293 QObject* parent, const char* name )
00294 : KToggleAction( text, pix, cut, receiver, slot, parent, name )
00295 {
00296 }
00297
00298 KRadioAction::KRadioAction( const QString& text, const QString& pix,
00299 const KShortcut& cut,
00300 const QObject* receiver, const char* slot,
00301 QObject* parent, const char* name )
00302 : KToggleAction( text, pix, cut, receiver, slot, parent, name )
00303 {
00304 }
00305
00306 KRadioAction::KRadioAction( QObject* parent, const char* name )
00307 : KToggleAction( parent, name )
00308 {
00309 }
00310
00311 void KRadioAction::slotActivated()
00312 {
00313 if ( isChecked() )
00314 {
00315 const QObject *senderObj = sender();
00316
00317 if ( !senderObj || !::qt_cast<const KToolBarButton *>( senderObj ) )
00318 return;
00319
00320 const_cast<KToolBarButton *>( static_cast<const KToolBarButton *>( senderObj ) )->on( true );
00321
00322 return;
00323 }
00324
00325 KToggleAction::slotActivated();
00326 }
00327
00328 class KSelectAction::KSelectActionPrivate
00329 {
00330 public:
00331 KSelectActionPrivate()
00332 {
00333 m_edit = false;
00334 m_menuAccelsEnabled = true;
00335 m_menu = 0;
00336 m_current = -1;
00337 m_comboWidth = -1;
00338 }
00339 bool m_edit;
00340 bool m_menuAccelsEnabled;
00341 QPopupMenu *m_menu;
00342 int m_current;
00343 int m_comboWidth;
00344 QStringList m_list;
00345
00346 QString makeMenuText( const QString &_text )
00347 {
00348 if ( m_menuAccelsEnabled )
00349 return _text;
00350 QString text = _text;
00351 uint i = 0;
00352 while ( i < text.length() ) {
00353 if ( text[ i ] == '&' ) {
00354 text.insert( i, '&' );
00355 i += 2;
00356 }
00357 else
00358 ++i;
00359 }
00360 return text;
00361 }
00362 };
00363
00364 KSelectAction::KSelectAction( const QString& text, const KShortcut& cut,
00365 QObject* parent, const char* name )
00366 : KAction( text, cut, parent, name )
00367 {
00368 d = new KSelectActionPrivate;
00369 }
00370
00371 KSelectAction::KSelectAction( const QString& text, const KShortcut& cut,
00372 const QObject* receiver, const char* slot,
00373 QObject* parent, const char* name )
00374 : KAction( text, cut, receiver, slot, parent, name )
00375 {
00376 d = new KSelectActionPrivate;
00377 }
00378
00379 KSelectAction::KSelectAction( const QString& text, const QIconSet& pix,
00380 const KShortcut& cut,
00381 QObject* parent, const char* name )
00382 : KAction( text, pix, cut, parent, name )
00383 {
00384 d = new KSelectActionPrivate;
00385 }
00386
00387 KSelectAction::KSelectAction( const QString& text, const QString& pix,
00388 const KShortcut& cut,
00389 QObject* parent, const char* name )
00390 : KAction( text, pix, cut, parent, name )
00391 {
00392 d = new KSelectActionPrivate;
00393 }
00394
00395 KSelectAction::KSelectAction( const QString& text, const QIconSet& pix,
00396 const KShortcut& cut,
00397 const QObject* receiver,
00398 const char* slot, QObject* parent,
00399 const char* name )
00400 : KAction( text, pix, cut, receiver, slot, parent, name )
00401 {
00402 d = new KSelectActionPrivate;
00403 }
00404
00405 KSelectAction::KSelectAction( const QString& text, const QString& pix,
00406 const KShortcut& cut,
00407 const QObject* receiver,
00408 const char* slot, QObject* parent,
00409 const char* name )
00410 : KAction( text, pix, cut, receiver, slot, parent, name )
00411 {
00412 d = new KSelectActionPrivate;
00413 }
00414
00415 KSelectAction::KSelectAction( QObject* parent, const char* name )
00416 : KAction( parent, name )
00417 {
00418 d = new KSelectActionPrivate;
00419 }
00420
00421 KSelectAction::~KSelectAction()
00422 {
00423 assert(d);
00424 delete d->m_menu;
00425 delete d; d = 0;
00426 }
00427
00428 void KSelectAction::setCurrentItem( int id )
00429 {
00430 if ( id >= (int)d->m_list.count() ) {
00431 Q_ASSERT(id < (int)d->m_list.count());
00432 return;
00433 }
00434
00435 if ( d->m_menu )
00436 {
00437 if ( d->m_current >= 0 )
00438 d->m_menu->setItemChecked( d->m_current, false );
00439 if ( id >= 0 )
00440 d->m_menu->setItemChecked( id, true );
00441 }
00442
00443 d->m_current = id;
00444
00445 int len = containerCount();
00446
00447 for( int i = 0; i < len; ++i )
00448 updateCurrentItem( i );
00449
00450
00451
00452
00453 }
00454
00455 void KSelectAction::setComboWidth( int width )
00456 {
00457 if ( width < 0 )
00458 return;
00459
00460 d->m_comboWidth=width;
00461
00462 int len = containerCount();
00463
00464 for( int i = 0; i < len; ++i )
00465 updateComboWidth( i );
00466
00467 }
00468 QPopupMenu* KSelectAction::popupMenu() const
00469 {
00470 kdDebug(129) << "KAction::popupMenu()" << endl;
00471 if ( !d->m_menu )
00472 {
00473 d->m_menu = new KPopupMenu(0L, "KSelectAction::popupMenu()");
00474 setupMenu();
00475 if ( d->m_current >= 0 )
00476 d->m_menu->setItemChecked( d->m_current, true );
00477 }
00478
00479 return d->m_menu;
00480 }
00481
00482 void KSelectAction::setupMenu() const
00483 {
00484 if ( !d->m_menu )
00485 return;
00486 d->m_menu->clear();
00487
00488 QStringList::ConstIterator it = d->m_list.begin();
00489 for( uint id = 0; it != d->m_list.end(); ++it, ++id ) {
00490 QString text = *it;
00491 if ( !text.isEmpty() )
00492 d->m_menu->insertItem( d->makeMenuText( text ), this, SLOT( slotActivated( int ) ), 0, id );
00493 else
00494 d->m_menu->insertSeparator();
00495 }
00496 }
00497
00498 void KSelectAction::changeItem( int index, const QString& text )
00499 {
00500 if ( index < 0 || index >= (int)d->m_list.count() )
00501 {
00502 kdWarning() << "KSelectAction::changeItem Index out of scope" << endl;
00503 return;
00504 }
00505
00506 d->m_list[ index ] = text;
00507
00508 if ( d->m_menu )
00509 d->m_menu->changeItem( index, d->makeMenuText( text ) );
00510
00511 int len = containerCount();
00512 for( int i = 0; i < len; ++i )
00513 changeItem( i, index, text );
00514 }
00515
00516 void KSelectAction::changeItem( int id, int index, const QString& text)
00517 {
00518 if ( index < 0 )
00519 return;
00520
00521 QWidget* w = container( id );
00522 if ( ::qt_cast<KToolBar *>( w ) )
00523 {
00524 QWidget* r = (static_cast<KToolBar*>( w ))->getWidget( itemId( id ) );
00525 if ( ::qt_cast<QComboBox *>( r ) )
00526 {
00527 QComboBox *b = static_cast<QComboBox*>( r );
00528 b->changeItem(text, index );
00529 }
00530 }
00531 }
00532
00533 void KSelectAction::setItems( const QStringList &lst )
00534 {
00535 d->m_list = lst;
00536 d->m_current = -1;
00537
00538 setupMenu();
00539
00540 int len = containerCount();
00541 for( int i = 0; i < len; ++i )
00542 updateItems( i );
00543
00544
00545 setEnabled ( lst.count() > 0 || d->m_edit );
00546 }
00547
00548 QStringList KSelectAction::items() const
00549 {
00550 return d->m_list;
00551 }
00552
00553 QString KSelectAction::currentText() const
00554 {
00555 if ( currentItem() < 0 )
00556 return QString::null;
00557
00558 return d->m_list[ currentItem() ];
00559 }
00560
00561 int KSelectAction::currentItem() const
00562 {
00563 return d->m_current;
00564 }
00565
00566 void KSelectAction::updateCurrentItem( int id )
00567 {
00568 if ( d->m_current < 0 )
00569 return;
00570
00571 QWidget* w = container( id );
00572 if ( ::qt_cast<KToolBar *>( w ) ) {
00573 QWidget* r = static_cast<KToolBar*>( w )->getWidget( itemId( id ) );
00574 if ( ::qt_cast<QComboBox *>( r ) ) {
00575 QComboBox *b = static_cast<QComboBox*>( r );
00576 b->setCurrentItem( d->m_current );
00577 }
00578 }
00579 }
00580
00581 int KSelectAction::comboWidth() const
00582 {
00583 return d->m_comboWidth;
00584 }
00585
00586 void KSelectAction::updateComboWidth( int id )
00587 {
00588 QWidget* w = container( id );
00589 if ( ::qt_cast<KToolBar *>( w ) ) {
00590 QWidget* r = static_cast<KToolBar*>( w )->getWidget( itemId( id ) );
00591 if ( ::qt_cast<QComboBox *>( r ) ) {
00592 QComboBox *cb = static_cast<QComboBox*>( r );
00593 cb->setMinimumWidth( d->m_comboWidth );
00594 cb->setMaximumWidth( d->m_comboWidth );
00595 }
00596 }
00597 }
00598
00599 void KSelectAction::updateItems( int id )
00600 {
00601 kdDebug(129) << "KAction::updateItems( " << id << ", lst )" << endl;
00602 QWidget* w = container( id );
00603 if ( ::qt_cast<KToolBar *>( w ) ) {
00604 QWidget* r = static_cast<KToolBar*>( w )->getWidget( itemId( id ) );
00605 if ( ::qt_cast<QComboBox *>( r ) ) {
00606 QComboBox *cb = static_cast<QComboBox*>( r );
00607 cb->clear();
00608 QStringList lst = comboItems();
00609 QStringList::ConstIterator it = lst.begin();
00610 for( ; it != lst.end(); ++it )
00611 cb->insertItem( *it );
00612
00613
00614
00615
00616 cb->unsetFont();
00617 }
00618 }
00619 }
00620
00621 int KSelectAction::plug( QWidget *widget, int index )
00622 {
00623 if (kapp && !kapp->authorizeKAction(name()))
00624 return -1;
00625 kdDebug(129) << "KAction::plug( " << widget << ", " << index << " )" << endl;
00626 if ( ::qt_cast<QPopupMenu *>( widget) )
00627 {
00628
00629 (void)popupMenu();
00630
00631 QPopupMenu* menu = static_cast<QPopupMenu*>( widget );
00632 int id;
00633 if ( hasIcon() )
00634 id = menu->insertItem( iconSet(), text(), d->m_menu, -1, index );
00635 else
00636 id = menu->insertItem( text(), d->m_menu, -1, index );
00637
00638 if ( !isEnabled() )
00639 menu->setItemEnabled( id, false );
00640
00641 QString wth = whatsThis();
00642 if ( !wth.isEmpty() )
00643 menu->setWhatsThis( id, wth );
00644
00645 addContainer( menu, id );
00646 connect( menu, SIGNAL( destroyed() ), this, SLOT( slotDestroyed() ) );
00647
00648 return containerCount() - 1;
00649 }
00650 else if ( ::qt_cast<KToolBar *>( widget ) )
00651 {
00652 KToolBar* bar = static_cast<KToolBar*>( widget );
00653 int id_ = KAction::getToolButtonID();
00654 bar->insertCombo( comboItems(), id_, isEditable(),
00655 SIGNAL( activated( const QString & ) ), this,
00656 SLOT( slotActivated( const QString & ) ), isEnabled(),
00657 toolTip(), -1, index );
00658
00659 QComboBox *cb = bar->getCombo( id_ );
00660 if ( cb )
00661 {
00662 if (!isEditable()) cb->setFocusPolicy(QWidget::NoFocus);
00663 cb->setMinimumWidth( cb->sizeHint().width() );
00664 if ( d->m_comboWidth > 0 )
00665 {
00666 cb->setMinimumWidth( d->m_comboWidth );
00667 cb->setMaximumWidth( d->m_comboWidth );
00668 }
00669 cb->setInsertionPolicy( QComboBox::NoInsertion );
00670 QWhatsThis::add( cb, whatsThis() );
00671 }
00672
00673 addContainer( bar, id_ );
00674
00675 connect( bar, SIGNAL( destroyed() ), this, SLOT( slotDestroyed() ) );
00676
00677 updateCurrentItem( containerCount() - 1 );
00678
00679 return containerCount() - 1;
00680 }
00681 else if ( ::qt_cast<QMenuBar *>( widget ) )
00682 {
00683
00684 (void)popupMenu();
00685
00686 QMenuBar* menu = static_cast<QMenuBar*>( widget );
00687 int id = menu->insertItem( text(), d->m_menu, -1, index );
00688
00689 if ( !isEnabled() )
00690 menu->setItemEnabled( id, false );
00691
00692 QString wth = whatsThis();
00693 if ( !wth.isEmpty() )
00694 menu->setWhatsThis( id, wth );
00695
00696 addContainer( menu, id );
00697 connect( menu, SIGNAL( destroyed() ), this, SLOT( slotDestroyed() ) );
00698
00699 return containerCount() - 1;
00700 }
00701
00702 kdWarning() << "Can not plug KAction in " << widget->className() << endl;
00703 return -1;
00704 }
00705
00706 QStringList KSelectAction::comboItems() const
00707 {
00708 if( d->m_menuAccelsEnabled ) {
00709 QStringList lst;
00710 QStringList::ConstIterator it = d->m_list.begin();
00711 for( ; it != d->m_list.end(); ++it )
00712 {
00713 QString item = *it;
00714 int i = item.find( '&' );
00715 if ( i > -1 )
00716 item = item.remove( i, 1 );
00717 lst.append( item );
00718 }
00719 return lst;
00720 }
00721 else
00722 return d->m_list;
00723 }
00724
00725 void KSelectAction::clear()
00726 {
00727 if ( d->m_menu )
00728 d->m_menu->clear();
00729
00730 int len = containerCount();
00731 for( int i = 0; i < len; ++i )
00732 updateClear( i );
00733 }
00734
00735 void KSelectAction::updateClear( int id )
00736 {
00737 QWidget* w = container( id );
00738 if ( ::qt_cast<KToolBar *>( w ) ) {
00739 QWidget* r = static_cast<KToolBar*>( w )->getWidget( itemId( id ) );
00740 if ( ::qt_cast<QComboBox *>( r ) ) {
00741 QComboBox *b = static_cast<QComboBox*>( r );
00742 b->clear();
00743 }
00744 }
00745 }
00746
00747 void KSelectAction::slotActivated( int id )
00748 {
00749 if ( d->m_current == id )
00750 return;
00751
00752 setCurrentItem( id );
00753
00754
00755 QTimer::singleShot( 0, this, SLOT( slotActivated() ) );
00756 }
00757
00758 void KSelectAction::slotActivated( const QString &text )
00759 {
00760 if ( isEditable() )
00761 {
00762 QStringList lst = items();
00763 if(!lst.contains(text))
00764 {
00765 lst.append( text );
00766 setItems( lst );
00767 }
00768 }
00769
00770 int i = items().findIndex( text );
00771 if ( i > -1 )
00772 setCurrentItem( i );
00773 else
00774 setCurrentItem( comboItems().findIndex( text ) );
00775
00776
00777 QTimer::singleShot( 0, this, SLOT( slotActivated() ) );
00778 }
00779
00780 void KSelectAction::slotActivated()
00781 {
00782 KAction::slotActivated();
00783 kdDebug(129) << "KSelectAction::slotActivated currentItem=" << currentItem() << " currentText=" << currentText() << endl;
00784 emit activated( currentItem() );
00785 emit activated( currentText() );
00786 }
00787
00788 void KSelectAction::setEditable( bool edit )
00789 {
00790 d->m_edit = edit;
00791 }
00792
00793 bool KSelectAction::isEditable() const
00794 {
00795 return d->m_edit;
00796 }
00797
00798 void KSelectAction::setRemoveAmpersandsInCombo( bool b )
00799 {
00800 setMenuAccelsEnabled( b );
00801 }
00802
00803 bool KSelectAction::removeAmpersandsInCombo() const
00804 {
00805 return menuAccelsEnabled( );
00806 }
00807
00808 void KSelectAction::setMenuAccelsEnabled( bool b )
00809 {
00810 d->m_menuAccelsEnabled = b;
00811 }
00812
00813 bool KSelectAction::menuAccelsEnabled() const
00814 {
00815 return d->m_menuAccelsEnabled;
00816 }
00817
00818 class KListAction::KListActionPrivate
00819 {
00820 public:
00821 KListActionPrivate()
00822 {
00823 m_current = 0;
00824 }
00825 int m_current;
00826 };
00827
00828 KListAction::KListAction( const QString& text, const KShortcut& cut,
00829 QObject* parent, const char* name )
00830 : KSelectAction( text, cut, parent, name )
00831 {
00832 d = new KListActionPrivate;
00833 }
00834
00835 KListAction::KListAction( const QString& text, const KShortcut& cut,
00836 const QObject* receiver, const char* slot,
00837 QObject* parent, const char* name )
00838 : KSelectAction( text, cut, parent, name )
00839 {
00840 d = new KListActionPrivate;
00841 if ( receiver )
00842 connect( this, SIGNAL( activated( int ) ), receiver, slot );
00843 }
00844
00845 KListAction::KListAction( const QString& text, const QIconSet& pix,
00846 const KShortcut& cut,
00847 QObject* parent, const char* name )
00848 : KSelectAction( text, pix, cut, parent, name )
00849 {
00850 d = new KListActionPrivate;
00851 }
00852
00853 KListAction::KListAction( const QString& text, const QString& pix,
00854 const KShortcut& cut,
00855 QObject* parent, const char* name )
00856 : KSelectAction( text, pix, cut, parent, name )
00857 {
00858 d = new KListActionPrivate;
00859 }
00860
00861 KListAction::KListAction( const QString& text, const QIconSet& pix,
00862 const KShortcut& cut, const QObject* receiver,
00863 const char* slot, QObject* parent,
00864 const char* name )
00865 : KSelectAction( text, pix, cut, parent, name )
00866 {
00867 d = new KListActionPrivate;
00868 if ( receiver )
00869 connect( this, SIGNAL( activated( int ) ), receiver, slot );
00870 }
00871
00872 KListAction::KListAction( const QString& text, const QString& pix,
00873 const KShortcut& cut, const QObject* receiver,
00874 const char* slot, QObject* parent,
00875 const char* name )
00876 : KSelectAction( text, pix, cut, parent, name )
00877 {
00878 d = new KListActionPrivate;
00879 if ( receiver )
00880 connect( this, SIGNAL( activated( int ) ), receiver, slot );
00881 }
00882
00883 KListAction::KListAction( QObject* parent, const char* name )
00884 : KSelectAction( parent, name )
00885 {
00886 d = new KListActionPrivate;
00887 }
00888
00889 KListAction::~KListAction()
00890 {
00891 delete d; d = 0;
00892 }
00893
00894 void KListAction::setCurrentItem( int index )
00895 {
00896 KSelectAction::setCurrentItem( index );
00897 d->m_current = index;
00898
00899
00900
00901
00902 }
00903
00904 QString KListAction::currentText() const
00905 {
00906 if ( currentItem() < 0 )
00907 return QString::null;
00908
00909 return items()[ currentItem() ];
00910 }
00911
00912 int KListAction::currentItem() const
00913 {
00914 return d->m_current;
00915 }
00916
00917 class KRecentFilesAction::KRecentFilesActionPrivate
00918 {
00919 public:
00920 KRecentFilesActionPrivate()
00921 {
00922 m_maxItems = 0;
00923 m_popup = 0;
00924 }
00925 uint m_maxItems;
00926 KPopupMenu *m_popup;
00927 };
00928
00929 KRecentFilesAction::KRecentFilesAction( const QString& text,
00930 const KShortcut& cut,
00931 QObject* parent, const char* name,
00932 uint maxItems )
00933 : KListAction( text, cut, parent, name)
00934 {
00935 d = new KRecentFilesActionPrivate;
00936 d->m_maxItems = maxItems;
00937
00938 init();
00939 }
00940
00941 KRecentFilesAction::KRecentFilesAction( const QString& text,
00942 const KShortcut& cut,
00943 const QObject* receiver,
00944 const char* slot,
00945 QObject* parent, const char* name,
00946 uint maxItems )
00947 : KListAction( text, cut, parent, name)
00948 {
00949 d = new KRecentFilesActionPrivate;
00950 d->m_maxItems = maxItems;
00951
00952 init();
00953
00954 if ( receiver )
00955 connect( this, SIGNAL(urlSelected(const KURL&)),
00956 receiver, slot );
00957 }
00958
00959 KRecentFilesAction::KRecentFilesAction( const QString& text,
00960 const QIconSet& pix,
00961 const KShortcut& cut,
00962 QObject* parent, const char* name,
00963 uint maxItems )
00964 : KListAction( text, pix, cut, parent, name)
00965 {
00966 d = new KRecentFilesActionPrivate;
00967 d->m_maxItems = maxItems;
00968
00969 init();
00970 }
00971
00972 KRecentFilesAction::KRecentFilesAction( const QString& text,
00973 const QString& pix,
00974 const KShortcut& cut,
00975 QObject* parent, const char* name,
00976 uint maxItems )
00977 : KListAction( text, pix, cut, parent, name)
00978 {
00979 d = new KRecentFilesActionPrivate;
00980 d->m_maxItems = maxItems;
00981
00982 init();
00983 }
00984
00985 KRecentFilesAction::KRecentFilesAction( const QString& text,
00986 const QIconSet& pix,
00987 const KShortcut& cut,
00988 const QObject* receiver,
00989 const char* slot,
00990 QObject* parent, const char* name,
00991 uint maxItems )
00992 : KListAction( text, pix, cut, parent, name)
00993 {
00994 d = new KRecentFilesActionPrivate;
00995 d->m_maxItems = maxItems;
00996
00997 init();
00998
00999 if ( receiver )
01000 connect( this, SIGNAL(urlSelected(const KURL&)),
01001 receiver, slot );
01002 }
01003
01004 KRecentFilesAction::KRecentFilesAction( const QString& text,
01005 const QString& pix,
01006 const KShortcut& cut,
01007 const QObject* receiver,
01008 const char* slot,
01009 QObject* parent, const char* name,
01010 uint maxItems )
01011 : KListAction( text, pix, cut, parent, name)
01012 {
01013 d = new KRecentFilesActionPrivate;
01014 d->m_maxItems = maxItems;
01015
01016 init();
01017
01018 if ( receiver )
01019 connect( this, SIGNAL(urlSelected(const KURL&)),
01020 receiver, slot );
01021 }
01022
01023 KRecentFilesAction::KRecentFilesAction( QObject* parent, const char* name,
01024 uint maxItems )
01025 : KListAction( parent, name )
01026 {
01027 d = new KRecentFilesActionPrivate;
01028 d->m_maxItems = maxItems;
01029
01030 init();
01031 }
01032
01033 void KRecentFilesAction::init()
01034 {
01035 KRecentFilesAction *that = const_cast<KRecentFilesAction*>(this);
01036 that->d->m_popup = new KPopupMenu;
01037 connect(d->m_popup, SIGNAL(aboutToShow()), this, SLOT(menuAboutToShow()));
01038 connect(d->m_popup, SIGNAL(activated(int)), this, SLOT(menuItemActivated(int)));
01039 connect( this, SIGNAL( activated( const QString& ) ),
01040 this, SLOT( itemSelected( const QString& ) ) );
01041
01042 setMenuAccelsEnabled( false );
01043 }
01044
01045 KRecentFilesAction::~KRecentFilesAction()
01046 {
01047 delete d->m_popup;
01048 delete d; d = 0;
01049 }
01050
01051 uint KRecentFilesAction::maxItems() const
01052 {
01053 return d->m_maxItems;
01054 }
01055
01056 void KRecentFilesAction::setMaxItems( uint maxItems )
01057 {
01058 QStringList lst = items();
01059 uint oldCount = lst.count();
01060
01061
01062 d->m_maxItems = maxItems;
01063
01064
01065 while( lst.count() > maxItems )
01066 {
01067
01068 lst.remove( lst.last() );
01069 }
01070
01071
01072 if( lst.count() != oldCount )
01073 setItems( lst );
01074 }
01075
01076 void KRecentFilesAction::addURL( const KURL& url )
01077 {
01078 if ( url.isLocalFile() && !KGlobal::dirs()->relativeLocation("tmp", url.path()).startsWith("/"))
01079 return;
01080 QString file = url.pathOrURL();
01081 QStringList lst = items();
01082
01083
01084 lst.remove( file );
01085
01086
01087 if( lst.count() == d->m_maxItems )
01088 {
01089
01090 lst.remove( lst.last() );
01091 }
01092
01093
01094 lst.prepend( file );
01095 setItems( lst );
01096 }
01097
01098 void KRecentFilesAction::removeURL( const KURL& url )
01099 {
01100 QStringList lst = items();
01101 QString file = url.pathOrURL();
01102
01103
01104 if( lst.count() > 0 )
01105 {
01106 lst.remove( file );
01107 setItems( lst );
01108 }
01109 }
01110
01111 void KRecentFilesAction::clearURLList()
01112 {
01113 clear();
01114 }
01115
01116 void KRecentFilesAction::loadEntries( KConfig* config, QString groupname)
01117 {
01118 QString key;
01119 QString value;
01120 QString oldGroup;
01121 QStringList lst;
01122
01123 oldGroup = config->group();
01124
01125 if (groupname.isEmpty())
01126 groupname = "RecentFiles";
01127 config->setGroup( groupname );
01128
01129
01130 for( unsigned int i = 1 ; i <= d->m_maxItems ; i++ )
01131 {
01132 key = QString( "File%1" ).arg( i );
01133 value = config->readPathEntry( key );
01134
01135 if (!value.isNull())
01136 lst.append( value );
01137 }
01138
01139
01140 setItems( lst );
01141
01142 config->setGroup( oldGroup );
01143 }
01144
01145 void KRecentFilesAction::saveEntries( KConfig* config, QString groupname )
01146 {
01147 QString key;
01148 QString value;
01149 QString oldGroup;
01150 QStringList lst = items();
01151
01152 oldGroup = config->group();
01153
01154 if (groupname.isEmpty())
01155 groupname = "RecentFiles";
01156 config->deleteGroup( groupname, true );
01157 config->setGroup( groupname );
01158
01159
01160 for( unsigned int i = 1 ; i <= lst.count() ; i++ )
01161 {
01162 key = QString( "File%1" ).arg( i );
01163 value = lst[ i - 1 ];
01164 config->writePathEntry( key, value );
01165 }
01166
01167 config->setGroup( oldGroup );
01168 }
01169
01170 void KRecentFilesAction::itemSelected( const QString& text )
01171 {
01172 emit urlSelected( KURL( text ) );
01173 }
01174
01175 void KRecentFilesAction::menuItemActivated( int id )
01176 {
01177 emit urlSelected( KURL(d->m_popup->text(id)) );
01178 }
01179
01180 void KRecentFilesAction::menuAboutToShow()
01181 {
01182 KPopupMenu *menu = d->m_popup;
01183 menu->clear();
01184 QStringList list = items();
01185 for ( QStringList::Iterator it = list.begin(); it != list.end(); ++it )
01186 menu->insertItem(*it);
01187 }
01188
01189 int KRecentFilesAction::plug( QWidget *widget, int index )
01190 {
01191 if (kapp && !kapp->authorizeKAction(name()))
01192 return -1;
01193
01194
01195 if ( ::qt_cast<KToolBar *>( widget ) )
01196 {
01197 KToolBar *bar = (KToolBar *)widget;
01198
01199 int id_ = KAction::getToolButtonID();
01200
01201 KInstance * instance;
01202 if ( m_parentCollection )
01203 instance = m_parentCollection->instance();
01204 else
01205 instance = KGlobal::instance();
01206
01207 bar->insertButton( icon(), id_, SIGNAL( clicked() ), this,
01208 SLOT( slotClicked() ), isEnabled(), plainText(),
01209 index, instance );
01210
01211 addContainer( bar, id_ );
01212
01213 connect( bar, SIGNAL( destroyed() ), this, SLOT( slotDestroyed() ) );
01214
01215 bar->setDelayedPopup( id_, d->m_popup, true);
01216
01217 if ( !whatsThis().isEmpty() )
01218 QWhatsThis::add( bar->getButton( id_ ), whatsThisWithIcon() );
01219
01220 return containerCount() - 1;
01221 }
01222
01223 return KListAction::plug( widget, index );
01224 }
01225
01226 void KRecentFilesAction::slotClicked()
01227 {
01228 KAction::slotActivated();
01229 }
01230
01231 void KRecentFilesAction::slotActivated(const QString& text)
01232 {
01233 KListAction::slotActivated(text);
01234 }
01235
01236
01237 void KRecentFilesAction::slotActivated(int id)
01238 {
01239 KListAction::slotActivated(id);
01240 }
01241
01242
01243 void KRecentFilesAction::slotActivated()
01244 {
01245 emit activated( currentItem() );
01246 emit activated( currentText() );
01247 }
01248
01249
01250 class KFontAction::KFontActionPrivate
01251 {
01252 public:
01253 KFontActionPrivate()
01254 {
01255 }
01256 QStringList m_fonts;
01257 };
01258
01259 KFontAction::KFontAction( const QString& text,
01260 const KShortcut& cut, QObject* parent,
01261 const char* name )
01262 : KSelectAction( text, cut, parent, name )
01263 {
01264 d = new KFontActionPrivate;
01265 KFontChooser::getFontList( d->m_fonts, 0 );
01266 KSelectAction::setItems( d->m_fonts );
01267 setEditable( true );
01268 }
01269
01270 KFontAction::KFontAction( const QString& text, const KShortcut& cut,
01271 const QObject* receiver, const char* slot,
01272 QObject* parent, const char* name )
01273 : KSelectAction( text, cut, receiver, slot, parent, name )
01274 {
01275 d = new KFontActionPrivate;
01276 KFontChooser::getFontList( d->m_fonts, 0 );
01277 KSelectAction::setItems( d->m_fonts );
01278 setEditable( true );
01279 }
01280
01281 KFontAction::KFontAction( const QString& text, const QIconSet& pix,
01282 const KShortcut& cut,
01283 QObject* parent, const char* name )
01284 : KSelectAction( text, pix, cut, parent, name )
01285 {
01286 d = new KFontActionPrivate;
01287 KFontChooser::getFontList( d->m_fonts, 0 );
01288 KSelectAction::setItems( d->m_fonts );
01289 setEditable( true );
01290 }
01291
01292 KFontAction::KFontAction( const QString& text, const QString& pix,
01293 const KShortcut& cut,
01294 QObject* parent, const char* name )
01295 : KSelectAction( text, pix, cut, parent, name )
01296 {
01297 d = new KFontActionPrivate;
01298 KFontChooser::getFontList( d->m_fonts, 0 );
01299 KSelectAction::setItems( d->m_fonts );
01300 setEditable( true );
01301 }
01302
01303 KFontAction::KFontAction( const QString& text, const QIconSet& pix,
01304 const KShortcut& cut,
01305 const QObject* receiver, const char* slot,
01306 QObject* parent, const char* name )
01307 : KSelectAction( text, pix, cut, receiver, slot, parent, name )
01308 {
01309 d = new KFontActionPrivate;
01310 KFontChooser::getFontList( d->m_fonts, 0 );
01311 KSelectAction::setItems( d->m_fonts );
01312 setEditable( true );
01313 }
01314
01315 KFontAction::KFontAction( const QString& text, const QString& pix,
01316 const KShortcut& cut,
01317 const QObject* receiver, const char* slot,
01318 QObject* parent, const char* name )
01319 : KSelectAction( text, pix, cut, receiver, slot, parent, name )
01320 {
01321 d = new KFontActionPrivate;
01322 KFontChooser::getFontList( d->m_fonts, 0 );
01323 KSelectAction::setItems( d->m_fonts );
01324 setEditable( true );
01325 }
01326
01327 KFontAction::KFontAction( uint fontListCriteria, const QString& text,
01328 const KShortcut& cut, QObject* parent,
01329 const char* name )
01330 : KSelectAction( text, cut, parent, name )
01331 {
01332 d = new KFontActionPrivate;
01333 KFontChooser::getFontList( d->m_fonts, fontListCriteria );
01334 KSelectAction::setItems( d->m_fonts );
01335 setEditable( true );
01336 }
01337
01338 KFontAction::KFontAction( uint fontListCriteria, const QString& text, const QString& pix,
01339 const KShortcut& cut,
01340 QObject* parent, const char* name )
01341 : KSelectAction( text, pix, cut, parent, name )
01342 {
01343 d = new KFontActionPrivate;
01344 KFontChooser::getFontList( d->m_fonts, fontListCriteria );
01345 KSelectAction::setItems( d->m_fonts );
01346 setEditable( true );
01347 }
01348
01349 KFontAction::KFontAction( QObject* parent, const char* name )
01350 : KSelectAction( parent, name )
01351 {
01352 d = new KFontActionPrivate;
01353 KFontChooser::getFontList( d->m_fonts, 0 );
01354 KSelectAction::setItems( d->m_fonts );
01355 setEditable( true );
01356 }
01357
01358 KFontAction::~KFontAction()
01359 {
01360 delete d;
01361 d = 0;
01362 }
01363
01364
01365
01366
01367 void KFontAction::setFont( const QString &family )
01368 {
01369 QString lowerName = family.lower();
01370 int i = 0;
01371 for ( QStringList::Iterator it = d->m_fonts.begin(); it != d->m_fonts.end(); ++it, ++i )
01372 {
01373 if ((*it).lower() == lowerName)
01374 {
01375 setCurrentItem(i);
01376 return;
01377 }
01378 }
01379 i = lowerName.find(" [");
01380 if (i>-1)
01381 {
01382 lowerName = lowerName.left(i);
01383 i = 0;
01384 for ( QStringList::Iterator it = d->m_fonts.begin(); it != d->m_fonts.end(); ++it, ++i )
01385 {
01386 if ((*it).lower() == lowerName)
01387 {
01388 setCurrentItem(i);
01389 return;
01390 }
01391 }
01392 }
01393
01394 lowerName += " [";
01395 i = 0;
01396 for ( QStringList::Iterator it = d->m_fonts.begin(); it != d->m_fonts.end(); ++it, ++i )
01397 {
01398 if ((*it).lower().startsWith(lowerName))
01399 {
01400 setCurrentItem(i);
01401 return;
01402 }
01403 }
01404 kdDebug(129) << "Font not found " << family.lower() << endl;
01405 }
01406
01407 int KFontAction::plug( QWidget *w, int index )
01408 {
01409 if (kapp && !kapp->authorizeKAction(name()))
01410 return -1;
01411 if ( ::qt_cast<KToolBar *>( w ) )
01412 {
01413 KToolBar* bar = static_cast<KToolBar*>( w );
01414 int id_ = KAction::getToolButtonID();
01415 KFontCombo *cb = new KFontCombo( items(), bar );
01416 connect( cb, SIGNAL( activated( const QString & ) ),
01417 SLOT( slotActivated( const QString & ) ) );
01418 cb->setEnabled( isEnabled() );
01419 bar->insertWidget( id_, comboWidth(), cb, index );
01420 cb->setMinimumWidth( cb->sizeHint().width() );
01421
01422 addContainer( bar, id_ );
01423
01424 connect( bar, SIGNAL( destroyed() ), this, SLOT( slotDestroyed() ) );
01425
01426 updateCurrentItem( containerCount() - 1 );
01427
01428 return containerCount() - 1;
01429 }
01430 else return KSelectAction::plug( w, index );
01431 }
01432
01433 class KFontSizeAction::KFontSizeActionPrivate
01434 {
01435 public:
01436 KFontSizeActionPrivate()
01437 {
01438 }
01439 };
01440
01441 KFontSizeAction::KFontSizeAction( const QString& text,
01442 const KShortcut& cut,
01443 QObject* parent, const char* name )
01444 : KSelectAction( text, cut, parent, name )
01445 {
01446 init();
01447 }
01448
01449 KFontSizeAction::KFontSizeAction( const QString& text,
01450 const KShortcut& cut,
01451 const QObject* receiver, const char* slot,
01452 QObject* parent, const char* name )
01453 : KSelectAction( text, cut, receiver, slot, parent, name )
01454 {
01455 init();
01456 }
01457
01458 KFontSizeAction::KFontSizeAction( const QString& text, const QIconSet& pix,
01459 const KShortcut& cut,
01460 QObject* parent, const char* name )
01461 : KSelectAction( text, pix, cut, parent, name )
01462 {
01463 init();
01464 }
01465
01466 KFontSizeAction::KFontSizeAction( const QString& text, const QString& pix,
01467 const KShortcut& cut,
01468 QObject* parent, const char* name )
01469 : KSelectAction( text, pix, cut, parent, name )
01470 {
01471 init();
01472 }
01473
01474 KFontSizeAction::KFontSizeAction( const QString& text, const QIconSet& pix,
01475 const KShortcut& cut,
01476 const QObject* receiver,
01477 const char* slot, QObject* parent,
01478 const char* name )
01479 : KSelectAction( text, pix, cut, receiver, slot, parent, name )
01480 {
01481 init();
01482 }
01483
01484 KFontSizeAction::KFontSizeAction( const QString& text, const QString& pix,
01485 const KShortcut& cut,
01486 const QObject* receiver,
01487 const char* slot, QObject* parent,
01488 const char* name )
01489 : KSelectAction( text, pix, cut, receiver, slot, parent, name )
01490 {
01491 init();
01492 }
01493
01494 KFontSizeAction::KFontSizeAction( QObject* parent, const char* name )
01495 : KSelectAction( parent, name )
01496 {
01497 init();
01498 }
01499
01500 KFontSizeAction::~KFontSizeAction()
01501 {
01502 delete d;
01503 d = 0;
01504 }
01505
01506 void KFontSizeAction::init()
01507 {
01508 d = new KFontSizeActionPrivate;
01509
01510 setEditable( true );
01511 QFontDatabase fontDB;
01512 QValueList<int> sizes = fontDB.standardSizes();
01513 QStringList lst;
01514 for ( QValueList<int>::Iterator it = sizes.begin(); it != sizes.end(); ++it )
01515 lst.append( QString::number( *it ) );
01516
01517 setItems( lst );
01518 }
01519
01520 void KFontSizeAction::setFontSize( int size )
01521 {
01522 if ( size == fontSize() ) {
01523 setCurrentItem( items().findIndex( QString::number( size ) ) );
01524 return;
01525 }
01526
01527 if ( size < 1 ) {
01528 kdWarning() << "KFontSizeAction: Size " << size << " is out of range" << endl;
01529 return;
01530 }
01531
01532 int index = items().findIndex( QString::number( size ) );
01533 if ( index == -1 ) {
01534
01535 QValueList<int> lst;
01536
01537 QStringList itemsList = items();
01538 for (QStringList::Iterator it = itemsList.begin() ; it != itemsList.end() ; ++it)
01539 lst.append( (*it).toInt() );
01540
01541 lst.append( size );
01542
01543 qHeapSort( lst );
01544
01545 QStringList strLst;
01546 for (QValueList<int>::Iterator it = lst.begin() ; it != lst.end() ; ++it)
01547 strLst.append( QString::number(*it) );
01548 KSelectAction::setItems( strLst );
01549
01550 index = lst.findIndex( size );
01551 setCurrentItem( index );
01552 }
01553 else
01554 setCurrentItem( index );
01555
01556
01557
01558
01559
01560
01561 }
01562
01563 int KFontSizeAction::fontSize() const
01564 {
01565 return currentText().toInt();
01566 }
01567
01568 void KFontSizeAction::slotActivated( int index )
01569 {
01570 KSelectAction::slotActivated( index );
01571
01572 emit fontSizeChanged( items()[ index ].toInt() );
01573 }
01574
01575 void KFontSizeAction::slotActivated( const QString& size )
01576 {
01577 setFontSize( size.toInt() );
01578 KSelectAction::slotActivated( size );
01579 emit fontSizeChanged( size.toInt() );
01580 }
01581
01582 class KActionMenu::KActionMenuPrivate
01583 {
01584 public:
01585 KActionMenuPrivate()
01586 {
01587 m_popup = new KPopupMenu(0L,"KActionMenu::KActionMenuPrivate");
01588 m_delayed = true;
01589 m_stickyMenu = true;
01590 }
01591 ~KActionMenuPrivate()
01592 {
01593 delete m_popup; m_popup = 0;
01594 }
01595 KPopupMenu *m_popup;
01596 bool m_delayed;
01597 bool m_stickyMenu;
01598 };
01599
01600 KActionMenu::KActionMenu( QObject* parent, const char* name )
01601 : KAction( parent, name )
01602 {
01603 d = new KActionMenuPrivate;
01604 setShortcutConfigurable( false );
01605 }
01606
01607 KActionMenu::KActionMenu( const QString& text, QObject* parent,
01608 const char* name )
01609 : KAction( text, 0, parent, name )
01610 {
01611 d = new KActionMenuPrivate;
01612 setShortcutConfigurable( false );
01613 }
01614
01615 KActionMenu::KActionMenu( const QString& text, const QIconSet& icon,
01616 QObject* parent, const char* name )
01617 : KAction( text, icon, 0, parent, name )
01618 {
01619 d = new KActionMenuPrivate;
01620 setShortcutConfigurable( false );
01621 }
01622
01623 KActionMenu::KActionMenu( const QString& text, const QString& icon,
01624 QObject* parent, const char* name )
01625 : KAction( text, icon, 0, parent, name )
01626 {
01627 d = new KActionMenuPrivate;
01628 setShortcutConfigurable( false );
01629 }
01630
01631 KActionMenu::~KActionMenu()
01632 {
01633 unplugAll();
01634 kdDebug(129) << "KActionMenu::~KActionMenu()" << endl;
01635 delete d; d = 0;
01636 }
01637
01638 void KActionMenu::popup( const QPoint& global )
01639 {
01640 popupMenu()->popup( global );
01641 }
01642
01643 KPopupMenu* KActionMenu::popupMenu() const
01644 {
01645 return d->m_popup;
01646 }
01647
01648 void KActionMenu::insert( KAction* cmd, int index )
01649 {
01650 if ( cmd )
01651 cmd->plug( d->m_popup, index );
01652 }
01653
01654 void KActionMenu::remove( KAction* cmd )
01655 {
01656 if ( cmd )
01657 cmd->unplug( d->m_popup );
01658 }
01659
01660 bool KActionMenu::delayed() const {
01661 return d->m_delayed;
01662 }
01663
01664 void KActionMenu::setDelayed(bool _delayed) {
01665 d->m_delayed = _delayed;
01666 }
01667
01668 bool KActionMenu::stickyMenu() const {
01669 return d->m_stickyMenu;
01670 }
01671
01672 void KActionMenu::setStickyMenu(bool sticky) {
01673 d->m_stickyMenu = sticky;
01674 }
01675
01676 int KActionMenu::plug( QWidget* widget, int index )
01677 {
01678 if (kapp && !kapp->authorizeKAction(name()))
01679 return -1;
01680 kdDebug(129) << "KAction::plug( " << widget << ", " << index << " )" << endl;
01681 if ( ::qt_cast<QPopupMenu *>( widget ) )
01682 {
01683 QPopupMenu* menu = static_cast<QPopupMenu*>( widget );
01684 int id;
01685 if ( hasIcon() )
01686 id = menu->insertItem( iconSet(), text(), d->m_popup, -1, index );
01687 else
01688 id = menu->insertItem( text(), d->m_popup, -1, index );
01689
01690 if ( !isEnabled() )
01691 menu->setItemEnabled( id, false );
01692
01693 addContainer( menu, id );
01694 connect( menu, SIGNAL( destroyed() ), this, SLOT( slotDestroyed() ) );
01695
01696 if ( m_parentCollection )
01697 m_parentCollection->connectHighlight( menu, this );
01698
01699 return containerCount() - 1;
01700 }
01701 else if ( ::qt_cast<KToolBar *>( widget ) )
01702 {
01703 KToolBar *bar = static_cast<KToolBar *>( widget );
01704
01705 int id_ = KAction::getToolButtonID();
01706
01707 if ( icon().isEmpty() && !iconSet().isNull() )
01708 bar->insertButton( iconSet().pixmap(), id_, SIGNAL( clicked() ), this,
01709 SLOT( slotActivated() ), isEnabled(), plainText(),
01710 index );
01711 else
01712 {
01713 KInstance *instance;
01714
01715 if ( m_parentCollection )
01716 instance = m_parentCollection->instance();
01717 else
01718 instance = KGlobal::instance();
01719
01720 bar->insertButton( icon(), id_, SIGNAL( clicked() ), this,
01721 SLOT( slotActivated() ), isEnabled(), plainText(),
01722 index, instance );
01723 }
01724
01725 addContainer( bar, id_ );
01726
01727 if (!whatsThis().isEmpty())
01728 QWhatsThis::add( bar->getButton(id_), whatsThis() );
01729
01730 connect( bar, SIGNAL( destroyed() ), this, SLOT( slotDestroyed() ) );
01731
01732 if (delayed()) {
01733 bar->setDelayedPopup( id_, popupMenu(), stickyMenu() );
01734 } else {
01735 bar->getButton(id_)->setPopup(popupMenu(), stickyMenu() );
01736 }
01737
01738 if ( m_parentCollection )
01739 m_parentCollection->connectHighlight( bar, this );
01740
01741 return containerCount() - 1;
01742 }
01743 else if ( ::qt_cast<QMenuBar *>( widget ) )
01744 {
01745 QMenuBar *bar = static_cast<QMenuBar *>( widget );
01746
01747 int id;
01748
01749 id = bar->insertItem( text(), popupMenu(), -1, index );
01750
01751 if ( !isEnabled() )
01752 bar->setItemEnabled( id, false );
01753
01754 addContainer( bar, id );
01755 connect( bar, SIGNAL( destroyed() ), this, SLOT( slotDestroyed() ) );
01756
01757 return containerCount() - 1;
01758 }
01759
01760 return -1;
01761 }
01762
01764
01765 KToolBarPopupAction::KToolBarPopupAction( const QString& text,
01766 const QString& icon,
01767 const KShortcut& cut,
01768 QObject* parent, const char* name )
01769 : KAction( text, icon, cut, parent, name )
01770 {
01771 m_popup = 0;
01772 m_delayed = true;
01773 m_stickyMenu = true;
01774 }
01775
01776 KToolBarPopupAction::KToolBarPopupAction( const QString& text,
01777 const QString& icon,
01778 const KShortcut& cut,
01779 const QObject* receiver,
01780 const char* slot, QObject* parent,
01781 const char* name )
01782 : KAction( text, icon, cut, receiver, slot, parent, name )
01783 {
01784 m_popup = 0;
01785 m_delayed = true;
01786 m_stickyMenu = true;
01787 }
01788
01789 KToolBarPopupAction::KToolBarPopupAction( const KGuiItem& item,
01790 const KShortcut& cut,
01791 const QObject* receiver,
01792 const char* slot, KActionCollection* parent,
01793 const char* name )
01794 : KAction( item, cut, receiver, slot, parent, name )
01795 {
01796 m_popup = 0;
01797 m_delayed = true;
01798 m_stickyMenu = true;
01799 }
01800
01801 KToolBarPopupAction::~KToolBarPopupAction()
01802 {
01803 delete m_popup;
01804 }
01805
01806 bool KToolBarPopupAction::delayed() const {
01807 return m_delayed;
01808 }
01809
01810 void KToolBarPopupAction::setDelayed(bool delayed) {
01811 m_delayed = delayed;
01812 }
01813
01814 bool KToolBarPopupAction::stickyMenu() const {
01815 return m_stickyMenu;
01816 }
01817
01818 void KToolBarPopupAction::setStickyMenu(bool sticky) {
01819 m_stickyMenu = sticky;
01820 }
01821
01822 int KToolBarPopupAction::plug( QWidget *widget, int index )
01823 {
01824 if (kapp && !kapp->authorizeKAction(name()))
01825 return -1;
01826
01827
01828 if ( ::qt_cast<KToolBar *>( widget ) )
01829 {
01830 KToolBar *bar = (KToolBar *)widget;
01831
01832 int id_ = KAction::getToolButtonID();
01833
01834 if ( icon().isEmpty() && !iconSet().isNull() ) {
01835 bar->insertButton( iconSet().pixmap(), id_, SIGNAL( buttonClicked(int, Qt::ButtonState) ), this,
01836 SLOT( slotButtonClicked(int, Qt::ButtonState) ),
01837 isEnabled(), plainText(),
01838 index );
01839 } else {
01840 KInstance * instance;
01841 if ( m_parentCollection )
01842 instance = m_parentCollection->instance();
01843 else
01844 instance = KGlobal::instance();
01845
01846 bar->insertButton( icon(), id_, SIGNAL( buttonClicked(int, Qt::ButtonState) ), this,
01847 SLOT( slotButtonClicked(int, Qt::ButtonState) ),
01848 isEnabled(), plainText(),
01849 index, instance );
01850 }
01851
01852 addContainer( bar, id_ );
01853
01854 connect( bar, SIGNAL( destroyed() ), this, SLOT( slotDestroyed() ) );
01855
01856 if (delayed()) {
01857 bar->setDelayedPopup( id_, popupMenu(), stickyMenu() );
01858 } else {
01859 bar->getButton(id_)->setPopup(popupMenu(), stickyMenu());
01860 }
01861
01862 if ( !whatsThis().isEmpty() )
01863 QWhatsThis::add( bar->getButton( id_ ), whatsThisWithIcon() );
01864
01865 return containerCount() - 1;
01866 }
01867
01868 return KAction::plug( widget, index );
01869 }
01870
01871 KPopupMenu *KToolBarPopupAction::popupMenu() const
01872 {
01873 if ( !m_popup ) {
01874 KToolBarPopupAction *that = const_cast<KToolBarPopupAction*>(this);
01875 that->m_popup = new KPopupMenu;
01876 }
01877 return m_popup;
01878 }
01879
01881
01882 KToggleToolBarAction::KToggleToolBarAction( const char* toolBarName,
01883 const QString& text, KActionCollection* parent, const char* name )
01884 : KToggleAction( text, KShortcut(), parent, name )
01885 , m_toolBarName( toolBarName )
01886 , m_toolBar( 0L )
01887 {
01888 }
01889
01890 KToggleToolBarAction::KToggleToolBarAction( KToolBar *toolBar, const QString &text,
01891 KActionCollection *parent, const char *name )
01892 : KToggleAction( text, KShortcut(), parent, name )
01893 , m_toolBarName( 0 ), m_toolBar( toolBar )
01894 {
01895 }
01896
01897 KToggleToolBarAction::~KToggleToolBarAction()
01898 {
01899 }
01900
01901 int KToggleToolBarAction::plug( QWidget* w, int index )
01902 {
01903 if (kapp && !kapp->authorizeKAction(name()))
01904 return -1;
01905
01906 if ( !m_toolBar ) {
01907
01908 QWidget * tl = w;
01909 QWidget * n;
01910 while ( !tl->isDialog() && ( n = tl->parentWidget() ) )
01911 tl = n;
01912
01913 KMainWindow * mw = dynamic_cast<KMainWindow *>(tl);
01914
01915 if ( mw )
01916 m_toolBar = mw->toolBar( m_toolBarName );
01917 }
01918
01919 if( m_toolBar ) {
01920 setChecked( m_toolBar->isVisible() );
01921 connect( m_toolBar, SIGNAL(visibilityChanged(bool)), this, SLOT(setChecked(bool)) );
01922
01923 connect( m_toolBar, SIGNAL(visibilityChanged(bool)), this, SIGNAL(toggled(bool)) );
01924 } else {
01925 setEnabled( false );
01926 }
01927
01928 return KToggleAction::plug( w, index );
01929 }
01930
01931 void KToggleToolBarAction::setChecked( bool c )
01932 {
01933 if( m_toolBar && c != m_toolBar->isVisible() ) {
01934 if( c ) {
01935 m_toolBar->show();
01936 } else {
01937 m_toolBar->hide();
01938 }
01939 QMainWindow* mw = m_toolBar->mainWindow();
01940 if ( mw && ::qt_cast<KMainWindow *>( mw ) )
01941 static_cast<KMainWindow *>( mw )->setSettingsDirty();
01942 }
01943 KToggleAction::setChecked( c );
01944 }
01945
01947
01948 KToggleFullScreenAction::KToggleFullScreenAction( const KShortcut &cut,
01949 const QObject* receiver, const char* slot,
01950 QObject* parent, QWidget* window,
01951 const char* name )
01952 : KToggleAction( QString::null, cut, receiver, slot, parent, name ),
01953 window( NULL )
01954 {
01955 setWindow( window );
01956 }
01957
01958 KToggleFullScreenAction::~KToggleFullScreenAction()
01959 {
01960 }
01961
01962 void KToggleFullScreenAction::setWindow( QWidget* w )
01963 {
01964 if( window )
01965 window->removeEventFilter( this );
01966 window = w;
01967 if( window )
01968 window->installEventFilter( this );
01969 }
01970
01971 void KToggleFullScreenAction::setChecked( bool c )
01972 {
01973 if (c)
01974 {
01975 setText(i18n("Exit F&ull Screen Mode"));
01976 setIcon("window_nofullscreen");
01977 }
01978 else
01979 {
01980 setText(i18n("F&ull Screen Mode"));
01981 setIcon("window_fullscreen");
01982 }
01983 KToggleAction::setChecked( c );
01984 }
01985
01986 bool KToggleFullScreenAction::eventFilter( QObject* o, QEvent* e )
01987 {
01988 if( o == window )
01989 #if QT_VERSION >= 0x030300
01990 if( e->type() == QEvent::WindowStateChange )
01991 #else
01992 if( e->type() == QEvent::ShowFullScreen || e->type() == QEvent::ShowNormal
01993 || e->type() == QEvent::ShowMaximized || e->type() == QEvent::ShowMinimized )
01994 #endif
01995 {
01996 if( window->isFullScreen() != isChecked())
01997 slotActivated();
01998 }
01999 return false;
02000 }
02001
02003
02004 KWidgetAction::KWidgetAction( QWidget* widget,
02005 const QString& text, const KShortcut& cut,
02006 const QObject* receiver, const char* slot,
02007 KActionCollection* parent, const char* name )
02008 : KAction( text, cut, receiver, slot, parent, name )
02009 , m_widget( widget )
02010 , m_autoSized( false )
02011 {
02012 connect( this, SIGNAL(enabled(bool)), widget, SLOT(setEnabled(bool)) );
02013 }
02014
02015 KWidgetAction::~KWidgetAction()
02016 {
02017 }
02018
02019 void KWidgetAction::setAutoSized( bool autoSized )
02020 {
02021 if( m_autoSized == autoSized )
02022 return;
02023
02024 m_autoSized = autoSized;
02025
02026 if( !m_widget || !isPlugged() )
02027 return;
02028
02029 KToolBar* toolBar = (KToolBar*)m_widget->parent();
02030 int i = findContainer( toolBar );
02031 if ( i == -1 )
02032 return;
02033 int id = itemId( i );
02034
02035 toolBar->setItemAutoSized( id, m_autoSized );
02036 }
02037
02038 int KWidgetAction::plug( QWidget* w, int index )
02039 {
02040 if (kapp && !kapp->authorizeKAction(name()))
02041 return -1;
02042
02043 if ( !::qt_cast<KToolBar *>( w ) ) {
02044 kdError() << "KWidgetAction::plug: KWidgetAction must be plugged into KToolBar." << endl;
02045 return -1;
02046 }
02047 if ( !m_widget ) {
02048 kdError() << "KWidgetAction::plug: Widget was deleted or null!" << endl;
02049 return -1;
02050 }
02051
02052 KToolBar* toolBar = static_cast<KToolBar*>( w );
02053
02054 int id = KAction::getToolButtonID();
02055
02056 m_widget->reparent( toolBar, QPoint() );
02057 toolBar->insertWidget( id, 0, m_widget, index );
02058 toolBar->setItemAutoSized( id, m_autoSized );
02059
02060 QWhatsThis::add( m_widget, whatsThis() );
02061 addContainer( toolBar, id );
02062
02063 connect( toolBar, SIGNAL( toolbarDestroyed() ), this, SLOT( slotToolbarDestroyed() ) );
02064 connect( toolBar, SIGNAL( destroyed() ), this, SLOT( slotDestroyed() ) );
02065
02066 return containerCount() - 1;
02067 }
02068
02069 void KWidgetAction::unplug( QWidget *w )
02070 {
02071 if( !m_widget || !isPlugged() )
02072 return;
02073
02074 KToolBar* toolBar = (KToolBar*)m_widget->parent();
02075 if ( toolBar == w )
02076 {
02077 disconnect( toolBar, SIGNAL( toolbarDestroyed() ), this, SLOT( slotToolbarDestroyed() ) );
02078 m_widget->reparent( 0L, QPoint(), false );
02079 }
02080 KAction::unplug( w );
02081 }
02082
02083 void KWidgetAction::slotToolbarDestroyed()
02084 {
02085
02086 Q_ASSERT( isPlugged() );
02087 if( !m_widget || !isPlugged() )
02088 return;
02089
02090
02091 m_widget->reparent( 0L, QPoint(), false );
02092 }
02093
02095
02096 KActionSeparator::KActionSeparator( QObject *parent, const char *name )
02097 : KAction( parent, name )
02098 {
02099 }
02100
02101 KActionSeparator::~KActionSeparator()
02102 {
02103 }
02104
02105 int KActionSeparator::plug( QWidget *widget, int index )
02106 {
02107 if ( ::qt_cast<QPopupMenu *>( widget) )
02108 {
02109 QPopupMenu* menu = static_cast<QPopupMenu*>( widget );
02110
02111 int id = menu->insertSeparator( index );
02112
02113 addContainer( menu, id );
02114 connect( menu, SIGNAL( destroyed() ), this, SLOT( slotDestroyed() ) );
02115
02116 return containerCount() - 1;
02117 }
02118 else if ( ::qt_cast<QMenuBar *>( widget ) )
02119 {
02120 QMenuBar *menuBar = static_cast<QMenuBar *>( widget );
02121
02122 int id = menuBar->insertSeparator( index );
02123
02124 addContainer( menuBar, id );
02125
02126 connect( menuBar, SIGNAL( destroyed() ), this, SLOT( slotDestroyed() ) );
02127
02128 return containerCount() - 1;
02129 }
02130 else if ( ::qt_cast<KToolBar *>( widget ) )
02131 {
02132 KToolBar *toolBar = static_cast<KToolBar *>( widget );
02133
02134 int id = toolBar->insertSeparator( index );
02135
02136 addContainer( toolBar, id );
02137
02138 connect( toolBar, SIGNAL( destroyed() ), this, SLOT( slotDestroyed() ) );
02139
02140 return containerCount() - 1;
02141 }
02142
02143 return -1;
02144 }
02145
02146 KPasteTextAction::KPasteTextAction( const QString& text,
02147 const QString& icon,
02148 const KShortcut& cut,
02149 const QObject* receiver,
02150 const char* slot, QObject* parent,
02151 const char* name)
02152 : KAction( text, icon, cut, receiver, slot, parent, name )
02153 {
02154 m_popup = new KPopupMenu;
02155 connect(m_popup, SIGNAL(aboutToShow()), this, SLOT(menuAboutToShow()));
02156 connect(m_popup, SIGNAL(activated(int)), this, SLOT(menuItemActivated(int)));
02157 m_popup->setCheckable(true);
02158 m_mixedMode = true;
02159 }
02160
02161 KPasteTextAction::~KPasteTextAction()
02162 {
02163 delete m_popup;
02164 }
02165
02166 void KPasteTextAction::setMixedMode(bool mode)
02167 {
02168 m_mixedMode = mode;
02169 }
02170
02171 int KPasteTextAction::plug( QWidget *widget, int index )
02172 {
02173 if (kapp && !kapp->authorizeKAction(name()))
02174 return -1;
02175 if ( ::qt_cast<KToolBar *>( widget ) )
02176 {
02177 KToolBar *bar = (KToolBar *)widget;
02178
02179 int id_ = KAction::getToolButtonID();
02180
02181 KInstance * instance;
02182 if ( m_parentCollection )
02183 instance = m_parentCollection->instance();
02184 else
02185 instance = KGlobal::instance();
02186
02187 bar->insertButton( icon(), id_, SIGNAL( clicked() ), this,
02188 SLOT( slotActivated() ), isEnabled(), plainText(),
02189 index, instance );
02190
02191 addContainer( bar, id_ );
02192
02193 connect( bar, SIGNAL( destroyed() ), this, SLOT( slotDestroyed() ) );
02194
02195 bar->setDelayedPopup( id_, m_popup, true );
02196
02197 if ( !whatsThis().isEmpty() )
02198 QWhatsThis::add( bar->getButton( id_ ), whatsThisWithIcon() );
02199
02200 return containerCount() - 1;
02201 }
02202
02203 return KAction::plug( widget, index );
02204 }
02205
02206 void KPasteTextAction::menuAboutToShow()
02207 {
02208 m_popup->clear();
02209 QStringList list;
02210 DCOPClient *client = kapp->dcopClient();
02211 if (client->isAttached() && client->isApplicationRegistered("klipper")) {
02212 DCOPRef klipper("klipper","klipper");
02213 DCOPReply reply = klipper.call("getClipboardHistoryMenu");
02214 if (reply.isValid())
02215 list = reply;
02216 }
02217 QString clipboardText = qApp->clipboard()->text(QClipboard::Clipboard);
02218 if (list.isEmpty())
02219 list << clipboardText;
02220 bool found = false;
02221 for ( QStringList::ConstIterator it = list.begin(); it != list.end(); ++it )
02222 {
02223 QString text = KStringHandler::cEmSqueeze((*it).simplifyWhiteSpace(), m_popup->fontMetrics(), 20);
02224 text.replace("&", "&&");
02225 int id = m_popup->insertItem(text);
02226 if (!found && *it == clipboardText)
02227 {
02228 m_popup->setItemChecked(id, true);
02229 found = true;
02230 }
02231 }
02232 }
02233
02234 void KPasteTextAction::menuItemActivated( int id)
02235 {
02236 DCOPClient *client = kapp->dcopClient();
02237 if (client->isAttached() && client->isApplicationRegistered("klipper")) {
02238 DCOPRef klipper("klipper","klipper");
02239 DCOPReply reply = klipper.call("getClipboardHistoryItem(int)", m_popup->indexOf(id));
02240 if (!reply.isValid())
02241 return;
02242 QString clipboardText = reply;
02243 reply = klipper.call("setClipboardContents(QString)", clipboardText);
02244 if (reply.isValid())
02245 kdDebug(129) << "Clipboard: " << qApp->clipboard()->text(QClipboard::Clipboard) << endl;
02246 }
02247 QTimer::singleShot(20, this, SLOT(slotActivated()));
02248 }
02249
02250 void KPasteTextAction::slotActivated()
02251 {
02252 if (!m_mixedMode) {
02253 QWidget *w = qApp->widgetAt(QCursor::pos(), true);
02254 QMimeSource *data = QApplication::clipboard()->data();
02255 if (!data->provides("text/plain") && w) {
02256 m_popup->popup(w->mapToGlobal(QPoint(0, w->height())));
02257 } else
02258 KAction::slotActivated();
02259 } else
02260 KAction::slotActivated();
02261 }
02262
02263
02264 void KToggleAction::virtual_hook( int id, void* data )
02265 { KAction::virtual_hook( id, data ); }
02266
02267 void KRadioAction::virtual_hook( int id, void* data )
02268 { KToggleAction::virtual_hook( id, data ); }
02269
02270 void KSelectAction::virtual_hook( int id, void* data )
02271 { KAction::virtual_hook( id, data ); }
02272
02273 void KListAction::virtual_hook( int id, void* data )
02274 { KSelectAction::virtual_hook( id, data ); }
02275
02276 void KRecentFilesAction::virtual_hook( int id, void* data )
02277 { KListAction::virtual_hook( id, data ); }
02278
02279 void KFontAction::virtual_hook( int id, void* data )
02280 { KSelectAction::virtual_hook( id, data ); }
02281
02282 void KFontSizeAction::virtual_hook( int id, void* data )
02283 { KSelectAction::virtual_hook( id, data ); }
02284
02285 void KActionMenu::virtual_hook( int id, void* data )
02286 { KAction::virtual_hook( id, data ); }
02287
02288 void KToolBarPopupAction::virtual_hook( int id, void* data )
02289 { KAction::virtual_hook( id, data ); }
02290
02291 void KToggleToolBarAction::virtual_hook( int id, void* data )
02292 { KToggleAction::virtual_hook( id, data ); }
02293
02294 void KToggleFullScreenAction::virtual_hook( int id, void* data )
02295 { KToggleAction::virtual_hook( id, data ); }
02296
02297 void KWidgetAction::virtual_hook( int id, void* data )
02298 { KAction::virtual_hook( id, data ); }
02299
02300 void KActionSeparator::virtual_hook( int id, void* data )
02301 { KAction::virtual_hook( id, data ); }
02302
02303 void KPasteTextAction::virtual_hook( int id, void* data )
02304 { KAction::virtual_hook( id, data ); }
02305
02306
02307
02308
02309 #include "kactionclasses.moc"