00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020 #include "kaccelmanager.h"
00021
00022 #include <qapplication.h>
00023 #include <qcheckbox.h>
00024 #include <qcombobox.h>
00025 #include <qgroupbox.h>
00026 #include <qlabel.h>
00027 #include <qlineedit.h>
00028 #include <qmenubar.h>
00029 #include <qmemarray.h>
00030 #include <qmetaobject.h>
00031 #include <qmainwindow.h>
00032 #include <qobjectlist.h>
00033 #include <qpopupmenu.h>
00034 #include <qptrlist.h>
00035 #include <qpushbutton.h>
00036 #include <qradiobutton.h>
00037 #include <qspinbox.h>
00038 #include <qtabbar.h>
00039 #include <qtextview.h>
00040 #include <qwidget.h>
00041 #include <qwidgetstack.h>
00042
00043 #include <kstdaction.h>
00044 #include <kstaticdeleter.h>
00045 #include <kdebug.h>
00046
00047
00048 #include "kaccelmanager_private.h"
00049 #include "../kdeui/kstdaction_p.h"
00050
00051
00052
00053
00054
00055
00056
00057
00058
00059
00060
00061
00062
00063
00064
00065
00066
00067
00068
00069
00070
00071
00072
00073 class KAcceleratorManagerPrivate
00074 {
00075 public:
00076
00077 static void manage(QWidget *widget);
00078 static bool programmers_mode;
00079 static bool standardName(const QString &str);
00080
00081 static bool checkChange(const KAccelString &as) {
00082 QString t2 = as.accelerated();
00083 QString t1 = as.originalText();
00084 if (t1 != t2)
00085 {
00086 if (as.accel() == -1) {
00087 removed_string += "<tr><td>" + QStyleSheet::escape(t1) + "</td></tr>";
00088 } else if (as.originalAccel() == -1) {
00089 added_string += "<tr><td>" + QStyleSheet::escape(t2) + "</td></tr>";
00090 } else {
00091 changed_string += "<tr><td>" + QStyleSheet::escape(t1) + "</td>";
00092 changed_string += "<td>" + QStyleSheet::escape(t2) + "</td></tr>";
00093 }
00094 return true;
00095 }
00096 return false;
00097 }
00098 static QString changed_string;
00099 static QString added_string;
00100 static QString removed_string;
00101 static QMap<QWidget *, int> ignored_widgets;
00102
00103 private:
00104 class Item;
00105 public:
00106 typedef QPtrList<Item> ItemList;
00107
00108 private:
00109 static void traverseChildren(QWidget *widget, Item *item);
00110
00111 static void manageWidget(QWidget *widget, Item *item);
00112 static void manageMenuBar(QMenuBar *mbar, Item *item);
00113 static void manageTabBar(QTabBar *bar, Item *item);
00114
00115 static void calculateAccelerators(Item *item, QString &used);
00116
00117 class Item
00118 {
00119 public:
00120
00121 Item() : m_widget(0), m_children(0), m_index(-1) {};
00122 ~Item();
00123
00124 void addChild(Item *item);
00125
00126 QWidget *m_widget;
00127 KAccelString m_content;
00128 ItemList *m_children;
00129 int m_index;
00130
00131 };
00132 };
00133
00134
00135 bool KAcceleratorManagerPrivate::programmers_mode = false;
00136 QString KAcceleratorManagerPrivate::changed_string;
00137 QString KAcceleratorManagerPrivate::added_string;
00138 QString KAcceleratorManagerPrivate::removed_string;
00139 static QStringList *kaccmp_sns = 0;
00140 static KStaticDeleter<QStringList> kaccmp_sns_d;
00141 QMap<QWidget*, int> KAcceleratorManagerPrivate::ignored_widgets;
00142
00143 bool KAcceleratorManagerPrivate::standardName(const QString &str)
00144 {
00145 if (!kaccmp_sns)
00146 kaccmp_sns_d.setObject(kaccmp_sns, new QStringList(KStdAction::internal_stdNames()));
00147 return kaccmp_sns->contains(str);
00148 }
00149
00150 KAcceleratorManagerPrivate::Item::~Item()
00151 {
00152 delete m_children;
00153 }
00154
00155
00156 void KAcceleratorManagerPrivate::Item::addChild(Item *item)
00157 {
00158 if (!m_children) {
00159 m_children = new ItemList;
00160 m_children->setAutoDelete(true);
00161 }
00162
00163 m_children->append(item);
00164 }
00165
00166 void KAcceleratorManagerPrivate::manage(QWidget *widget)
00167 {
00168 if (!widget)
00169 {
00170 kdDebug(125) << "null pointer given to manage" << endl;
00171 return;
00172 }
00173
00174 if (dynamic_cast<QPopupMenu*>(widget))
00175 {
00176
00177 KPopupAccelManager::manage(static_cast<QPopupMenu*>(widget));
00178 return;
00179 }
00180
00181 Item *root = new Item;
00182
00183 manageWidget(widget, root);
00184
00185 QString used;
00186 calculateAccelerators(root, used);
00187 delete root;
00188 }
00189
00190
00191 void KAcceleratorManagerPrivate::calculateAccelerators(Item *item, QString &used)
00192 {
00193 if (!item->m_children)
00194 return;
00195
00196
00197 KAccelStringList contents;
00198 for (Item *it = item->m_children->first(); it != 0;
00199 it = item->m_children->next())
00200 {
00201 contents << it->m_content;
00202 }
00203
00204
00205 KAccelManagerAlgorithm::findAccelerators(contents, used);
00206
00207
00208 int cnt = -1;
00209 for (Item *it = item->m_children->first(); it != 0;
00210 it = item->m_children->next())
00211 {
00212 cnt++;
00213
00214 QTabBar *tabBar = dynamic_cast<QTabBar*>(it->m_widget);
00215 if (tabBar)
00216 {
00217 if (checkChange(contents[cnt]))
00218 tabBar->tabAt(it->m_index)->setText(contents[cnt].accelerated());
00219 continue;
00220 }
00221 QMenuBar *menuBar = dynamic_cast<QMenuBar*>(it->m_widget);
00222 if (menuBar)
00223 {
00224 if (it->m_index >= 0)
00225 {
00226 QMenuItem *mitem = menuBar->findItem(menuBar->idAt(it->m_index));
00227 if (mitem)
00228 {
00229 checkChange(contents[cnt]);
00230 mitem->setText(contents[cnt].accelerated());
00231 }
00232 continue;
00233 }
00234 }
00235
00236 if ( dynamic_cast<QGroupBox*>( it->m_widget ) )
00237 continue;
00238
00239 kdDebug(125) << "write " << cnt << " " << it->m_widget->className() << " " <<contents[cnt].accelerated() << endl;
00240
00241 int tprop = it->m_widget->metaObject()->findProperty("text", true);
00242 if (tprop != -1) {
00243 if (checkChange(contents[cnt]))
00244 it->m_widget->setProperty("text", contents[cnt].accelerated());
00245 } else {
00246 tprop = it->m_widget->metaObject()->findProperty("title", true);
00247 if (tprop != -1 && checkChange(contents[cnt]))
00248 it->m_widget->setProperty("title", contents[cnt].accelerated());
00249 }
00250 }
00251
00252
00253 for (Item *it = item->m_children->first(); it != 0;
00254 it = item->m_children->next())
00255 {
00256 kdDebug(125) << "children " << it->m_widget->className() << endl;
00257 if (it->m_widget && it->m_widget->isVisibleTo( item->m_widget ) )
00258 calculateAccelerators(it, used);
00259 }
00260 }
00261
00262
00263 void KAcceleratorManagerPrivate::traverseChildren(QWidget *widget, Item *item)
00264 {
00265 QObjectList *childList = widget->queryList("QWidget", 0, false, false);
00266 for ( QObject *it = childList->first(); it; it = childList->next() )
00267 {
00268 QWidget *w = static_cast<QWidget*>(it);
00269
00270 if ( !w->isVisibleTo( widget ) || w->isTopLevel() )
00271 continue;
00272
00273 if ( KAcceleratorManagerPrivate::ignored_widgets.find( w ) != KAcceleratorManagerPrivate::ignored_widgets.end() )
00274 continue;
00275
00276 manageWidget(w, item);
00277 }
00278 delete childList;
00279 }
00280
00281 void KAcceleratorManagerPrivate::manageWidget(QWidget *w, Item *item)
00282 {
00283
00284
00285 QTabBar *tabBar = dynamic_cast<QTabBar*>(w);
00286 if (tabBar)
00287 {
00288 manageTabBar(tabBar, item);
00289 return;
00290 }
00291
00292 QWidgetStack *wds = dynamic_cast<QWidgetStack*>( w );
00293 if ( wds )
00294 {
00295 QWidgetStackAccelManager::manage( wds );
00296
00297 }
00298
00299 QPopupMenu *popupMenu = dynamic_cast<QPopupMenu*>(w);
00300 if (popupMenu)
00301 {
00302
00303 KPopupAccelManager::manage(popupMenu);
00304 return;
00305 }
00306
00307 QWidgetStack *wdst = dynamic_cast<QWidgetStack*>( w );
00308 if ( wdst )
00309 {
00310 QWidgetStackAccelManager::manage( wdst );
00311
00312 }
00313
00314 QMenuBar *menuBar = dynamic_cast<QMenuBar*>(w);
00315 if (menuBar)
00316 {
00317 manageMenuBar(menuBar, item);
00318 return;
00319 }
00320
00321 if (dynamic_cast<QComboBox*>(w) || dynamic_cast<QLineEdit*>(w) ||
00322 dynamic_cast<QTextEdit*>(w) || dynamic_cast<QTextView*>(w) ||
00323 dynamic_cast<QSpinBox*>(w) || w->qt_cast( "KMultiTabBar" ))
00324 return;
00325
00326
00327 QLabel *label = dynamic_cast<QLabel*>(w);
00328 if ( label ) {
00329 if ( !label->buddy() )
00330 label = 0;
00331 else {
00332 if ( label->textFormat() == Qt::RichText ||
00333 ( label->textFormat() == Qt::AutoText &&
00334 QStyleSheet::mightBeRichText( label->text() ) ) )
00335 label = 0;
00336 }
00337 }
00338
00339 if (w->isFocusEnabled() || label || dynamic_cast<QGroupBox*>(w) || dynamic_cast<QRadioButton*>( w ))
00340 {
00341 QString content;
00342 QVariant variant;
00343 int tprop = w->metaObject()->findProperty("text", true);
00344 if (tprop != -1) {
00345 const QMetaProperty* p = w->metaObject()->property( tprop, true );
00346 if ( p && p->isValid() )
00347 w->qt_property( tprop, 1, &variant );
00348 else
00349 tprop = -1;
00350 }
00351
00352 if (tprop == -1) {
00353 tprop = w->metaObject()->findProperty("title", true);
00354 if (tprop != -1) {
00355 const QMetaProperty* p = w->metaObject()->property( tprop, true );
00356 if ( p && p->isValid() )
00357 w->qt_property( tprop, 1, &variant );
00358 }
00359 }
00360
00361 if (variant.isValid())
00362 content = variant.toString();
00363
00364 if (!content.isEmpty())
00365 {
00366 Item *i = new Item;
00367 i->m_widget = w;
00368
00369
00370 int weight = KAccelManagerAlgorithm::DEFAULT_WEIGHT;
00371 if (dynamic_cast<QPushButton*>(w) || dynamic_cast<QCheckBox*>(w) || dynamic_cast<QRadioButton*>(w) || dynamic_cast<QLabel*>(w))
00372 weight = KAccelManagerAlgorithm::ACTION_ELEMENT_WEIGHT;
00373
00374
00375 if (dynamic_cast<QGroupBox*>(w))
00376 weight = KAccelManagerAlgorithm::GROUP_BOX_WEIGHT;
00377
00378
00379 if (w->inherits("KDialogBaseButton"))
00380 weight += KAccelManagerAlgorithm::DIALOG_BUTTON_EXTRA_WEIGHT;
00381
00382 i->m_content = KAccelString(content, weight);
00383 item->addChild(i);
00384 }
00385 }
00386 traverseChildren(w, item);
00387 }
00388
00389 void KAcceleratorManagerPrivate::manageTabBar(QTabBar *bar, Item *item)
00390 {
00391 for (int i=0; i<bar->count(); i++)
00392 {
00393 QString content = bar->tabAt(i)->text();
00394 if (content.isEmpty())
00395 continue;
00396
00397 Item *it = new Item;
00398 item->addChild(it);
00399 it->m_widget = bar;
00400 it->m_index = i;
00401 it->m_content = KAccelString(content);
00402 }
00403 }
00404
00405 void KAcceleratorManagerPrivate::manageMenuBar(QMenuBar *mbar, Item *item)
00406 {
00407 QMenuItem *mitem;
00408 QString s;
00409
00410 for (uint i=0; i<mbar->count(); ++i)
00411 {
00412 mitem = mbar->findItem(mbar->idAt(i));
00413 if (!mitem)
00414 continue;
00415
00416
00417 if (mitem->isSeparator())
00418 continue;
00419
00420 s = mitem->text();
00421 if (!s.isEmpty())
00422 {
00423 Item *it = new Item;
00424 item->addChild(it);
00425 it->m_content =
00426 KAccelString(s,
00427
00428 KAccelManagerAlgorithm::MENU_TITLE_WEIGHT);
00429
00430 it->m_widget = mbar;
00431 it->m_index = i;
00432 }
00433
00434
00435 if (mitem->popup())
00436 KPopupAccelManager::manage(mitem->popup());
00437 }
00438 }
00439
00440
00441
00442
00443
00444
00445
00446
00447
00448
00449 void KAcceleratorManager::manage(QWidget *widget)
00450 {
00451 KAcceleratorManager::manage(widget, false);
00452 }
00453
00454 void KAcceleratorManager::manage(QWidget *widget, bool programmers_mode)
00455 {
00456 kdDebug(125) << "KAcceleratorManager::manage\n";
00457 KAcceleratorManagerPrivate::changed_string = QString::null;
00458 KAcceleratorManagerPrivate::added_string = QString::null;
00459 KAcceleratorManagerPrivate::removed_string = QString::null;
00460 KAcceleratorManagerPrivate::programmers_mode = programmers_mode;
00461 KAcceleratorManagerPrivate::manage(widget);
00462 }
00463
00464 void KAcceleratorManager::last_manage(QString &added, QString &changed, QString &removed)
00465 {
00466 added = KAcceleratorManagerPrivate::added_string;
00467 changed = KAcceleratorManagerPrivate::changed_string;
00468 removed = KAcceleratorManagerPrivate::removed_string;
00469 }
00470
00471
00472
00473
00474
00475
00476
00477
00478 KAccelString::KAccelString(const QString &input, int initialWeight)
00479 : m_pureText(input), m_weight()
00480 {
00481 m_orig_accel = m_pureText.find("(!)&");
00482 if (m_orig_accel != -1)
00483 m_pureText.remove(m_orig_accel, 4);
00484
00485 m_orig_accel = m_pureText.find("(&&)");
00486 if (m_orig_accel != -1)
00487 m_pureText.replace(m_orig_accel, 4, "&");
00488
00489 m_origText = m_pureText;
00490
00491 if (m_pureText.contains('\t'))
00492 m_pureText = m_pureText.left(m_pureText.find('\t'));
00493
00494 m_orig_accel = m_accel = stripAccelerator(m_pureText);
00495
00496 kdDebug(125) << input << " " << m_orig_accel << " " << m_accel << " " << m_pureText << endl;
00497 if (initialWeight == -1)
00498 initialWeight = KAccelManagerAlgorithm::DEFAULT_WEIGHT;
00499
00500 calculateWeights(initialWeight);
00501
00502
00503 }
00504
00505
00506 QString KAccelString::accelerated() const
00507 {
00508 QString result = m_origText;
00509 if (result.isEmpty())
00510 return result;
00511
00512 if (KAcceleratorManagerPrivate::programmers_mode)
00513 {
00514 if (m_accel != m_orig_accel) {
00515 int oa = m_orig_accel;
00516
00517 if (m_accel >= 0) {
00518 result.insert(m_accel, "(!)&");
00519 if (m_accel < m_orig_accel)
00520 oa += 4;
00521 }
00522 if (m_orig_accel >= 0)
00523 result.replace(oa, 1, "(&&)");
00524 }
00525 } else {
00526 if (m_accel >= 0 && m_orig_accel != m_accel) {
00527 result.remove(m_orig_accel, 1);
00528 result.insert(m_accel, "&");
00529 }
00530 }
00531 return result;
00532 }
00533
00534
00535 QChar KAccelString::accelerator() const
00536 {
00537 if ((m_accel < 0) || (m_accel > (int)m_pureText.length()))
00538 return QChar();
00539
00540 return m_pureText[m_accel].lower();
00541 }
00542
00543
00544 void KAccelString::calculateWeights(int initialWeight)
00545 {
00546 m_weight.resize(m_pureText.length());
00547
00548 uint pos = 0;
00549 bool start_character = true;
00550
00551 while (pos<m_pureText.length())
00552 {
00553 QChar c = m_pureText[pos];
00554
00555 int weight = initialWeight+1;
00556
00557
00558 if (pos == 0)
00559 weight += KAccelManagerAlgorithm::FIRST_CHARACTER_EXTRA_WEIGHT;
00560
00561
00562 if (start_character)
00563 {
00564 weight += KAccelManagerAlgorithm::WORD_BEGINNING_EXTRA_WEIGHT;
00565 start_character = false;
00566 }
00567
00568
00569 if (pos < 50)
00570 weight += (50-pos);
00571
00572
00573 if ((int)pos == accel()) {
00574 weight += KAccelManagerAlgorithm::WANTED_ACCEL_EXTRA_WEIGHT;
00575
00576 if (KAcceleratorManagerPrivate::standardName(m_origText)) {
00577 weight += KAccelManagerAlgorithm::STANDARD_ACCEL;
00578 }
00579 }
00580
00581
00582 if (!c.isLetterOrNumber())
00583 {
00584 weight = 0;
00585 start_character = true;
00586 }
00587
00588 m_weight[pos] = weight;
00589
00590 ++pos;
00591 }
00592 }
00593
00594
00595 int KAccelString::stripAccelerator(QString &text)
00596 {
00597
00598 int p = 0;
00599
00600 while (p >= 0)
00601 {
00602 p = text.find('&', p)+1;
00603
00604 if (p <= 0 || p >= (int)text.length())
00605 return -1;
00606
00607 if (text[p] != '&')
00608 {
00609 QChar c = text[p];
00610 if (c.isPrint())
00611 {
00612 text.remove(p-1,1);
00613 return p-1;
00614 }
00615 }
00616
00617 p++;
00618 }
00619
00620 return -1;
00621 }
00622
00623
00624 int KAccelString::maxWeight(int &index, const QString &used)
00625 {
00626 int max = 0;
00627 index = -1;
00628
00629 for (uint pos=0; pos<m_pureText.length(); ++pos)
00630 if (used.find(m_pureText[pos], 0, FALSE) == -1 && m_pureText[pos].latin1() != 0)
00631 if (m_weight[pos] > max)
00632 {
00633 max = m_weight[pos];
00634 index = pos;
00635 }
00636
00637 return max;
00638 }
00639
00640
00641 void KAccelString::dump()
00642 {
00643 QString s;
00644 for (uint i=0; i<m_weight.count(); ++i)
00645 s += QString("%1(%2) ").arg(pure()[i]).arg(m_weight[i]);
00646 kdDebug() << "s " << s << endl;
00647 }
00648
00649
00650
00651
00652
00653
00654
00655
00656
00657
00658
00659
00660
00661
00662
00663
00664
00665
00666
00667
00668
00669
00670
00671
00672
00673
00674
00675
00676
00677
00678
00679
00680
00681
00682
00683 void KAccelManagerAlgorithm::findAccelerators(KAccelStringList &result, QString &used)
00684 {
00685 kdDebug(125) << "findAccelerators\n";
00686 KAccelStringList accel_strings = result;
00687
00688
00689 for (KAccelStringList::Iterator it = result.begin(); it != result.end(); ++it) {
00690 kdDebug(125) << "reset " << ( *it ).pure() << endl;
00691 (*it).setAccel(-1);
00692 }
00693
00694
00695 for (uint cnt=0; cnt<accel_strings.count(); ++cnt)
00696 {
00697 kdDebug(125) << "cnt " << accel_strings[cnt].pure() << endl;
00698 int max = 0, index = -1, accel = -1;
00699
00700
00701 for (uint i=0; i<accel_strings.count(); ++i)
00702 {
00703 int a;
00704 int m = accel_strings[i].maxWeight(a, used);
00705 if (m>max)
00706 {
00707 max = m;
00708 index = i;
00709 accel = a;
00710 }
00711 }
00712
00713
00714 if (index < 0)
00715 return;
00716
00717
00718 if (accel >= 0)
00719 {
00720 result[index].setAccel(accel);
00721 used.append(result[index].accelerator());
00722 }
00723
00724
00725 accel_strings[index] = KAccelString();
00726 }
00727 }
00728
00729
00730
00731
00732
00733
00734
00735
00736 KPopupAccelManager::KPopupAccelManager(QPopupMenu *popup)
00737 : QObject(popup), m_popup(popup), m_count(-1)
00738 {
00739 aboutToShow();
00740 connect(popup, SIGNAL(aboutToShow()), SLOT(aboutToShow()));
00741 }
00742
00743
00744 void KPopupAccelManager::aboutToShow()
00745 {
00746
00747
00748
00749
00750
00751 if (m_count != (int)m_popup->count())
00752 {
00753 findMenuEntries(m_entries);
00754 calculateAccelerators();
00755 m_count = m_popup->count();
00756 }
00757 else
00758 {
00759 KAccelStringList entries;
00760 findMenuEntries(entries);
00761 if (entries != m_entries)
00762 {
00763 m_entries = entries;
00764 calculateAccelerators();
00765 }
00766 }
00767 }
00768
00769
00770 void KPopupAccelManager::calculateAccelerators()
00771 {
00772
00773 QString used;
00774 KAccelManagerAlgorithm::findAccelerators(m_entries, used);
00775
00776
00777 setMenuEntries(m_entries);
00778 }
00779
00780
00781 void KPopupAccelManager::findMenuEntries(KAccelStringList &list)
00782 {
00783 QMenuItem *mitem;
00784 QString s;
00785
00786 list.clear();
00787
00788
00789 for (uint i=0; i<m_popup->count(); i++)
00790 {
00791 mitem = m_popup->findItem(m_popup->idAt(i));
00792 if (mitem->isSeparator())
00793 continue;
00794
00795 s = mitem->text();
00796
00797
00798 int weight = 50;
00799 if (s.contains('\t'))
00800 weight = 0;
00801
00802 list.append(KAccelString(s, weight));
00803
00804
00805 if (mitem->popup())
00806 KPopupAccelManager::manage(mitem->popup());
00807 }
00808 }
00809
00810
00811 void KPopupAccelManager::setMenuEntries(const KAccelStringList &list)
00812 {
00813 QMenuItem *mitem;
00814
00815 uint cnt = 0;
00816 for (uint i=0; i<m_popup->count(); i++)
00817 {
00818 mitem = m_popup->findItem(m_popup->idAt(i));
00819 if (mitem->isSeparator())
00820 continue;
00821
00822 if (KAcceleratorManagerPrivate::checkChange(list[cnt]))
00823 mitem->setText(list[cnt].accelerated());
00824 cnt++;
00825 }
00826 }
00827
00828
00829 void KPopupAccelManager::manage(QPopupMenu *popup)
00830 {
00831
00832 if (popup->child(0, "KPopupAccelManager", false) == 0 )
00833 new KPopupAccelManager(popup);
00834 }
00835
00836 void QWidgetStackAccelManager::manage( QWidgetStack *stack )
00837 {
00838 if ( stack->child( 0, "QWidgetStackAccelManager", false ) == 0 )
00839 new QWidgetStackAccelManager( stack );
00840 }
00841
00842 QWidgetStackAccelManager::QWidgetStackAccelManager(QWidgetStack *stack)
00843 : QObject(stack), m_stack(stack)
00844 {
00845 aboutToShow(stack->visibleWidget());
00846 connect(stack, SIGNAL(aboutToShow(QWidget *)), SLOT(aboutToShow(QWidget *)));
00847 }
00848
00849 bool QWidgetStackAccelManager::eventFilter ( QObject * watched, QEvent * e )
00850 {
00851 if ( e->type() == QEvent::Show && qApp->activeWindow() ) {
00852 KAcceleratorManager::manage( qApp->activeWindow() );
00853 watched->removeEventFilter( this );
00854 }
00855 return false;
00856 }
00857
00858 void QWidgetStackAccelManager::aboutToShow(QWidget *child)
00859 {
00860 if (!child)
00861 {
00862 kdDebug(125) << "null pointer given to aboutToShow" << endl;
00863 return;
00864 }
00865
00866 child->installEventFilter( this );
00867 }
00868
00869 void KAcceleratorManager::setNoAccel( QWidget *widget )
00870 {
00871 KAcceleratorManagerPrivate::ignored_widgets[widget] = 1;
00872 }
00873
00874 #include "kaccelmanager_private.moc"