kdeui Library API Documentation

kactionclasses.cpp

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