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 if ( dynamic_cast<QLabel*>( it->m_widget ) && it->m_widget->inherits("KURLLabel") )
00240 continue;
00241
00242 int tprop = it->m_widget->metaObject()->findProperty("text", true);
00243 if (tprop != -1) {
00244 if (checkChange(contents[cnt]))
00245 it->m_widget->setProperty("text", contents[cnt].accelerated());
00246 } else {
00247 tprop = it->m_widget->metaObject()->findProperty("title", true);
00248 if (tprop != -1 && checkChange(contents[cnt]))
00249 it->m_widget->setProperty("title", contents[cnt].accelerated());
00250 }
00251 }
00252
00253
00254 for (Item *it = item->m_children->first(); it != 0;
00255 it = item->m_children->next())
00256 {
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 (*it).setAccel(-1);
00691 }
00692
00693
00694 for (uint cnt=0; cnt<accel_strings.count(); ++cnt)
00695 {
00696 int max = 0, index = -1, accel = -1;
00697
00698
00699 for (uint i=0; i<accel_strings.count(); ++i)
00700 {
00701 int a;
00702 int m = accel_strings[i].maxWeight(a, used);
00703 if (m>max)
00704 {
00705 max = m;
00706 index = i;
00707 accel = a;
00708 }
00709 }
00710
00711
00712 if (index < 0)
00713 return;
00714
00715
00716 if (accel >= 0)
00717 {
00718 result[index].setAccel(accel);
00719 used.append(result[index].accelerator());
00720 }
00721
00722
00723 accel_strings[index] = KAccelString();
00724 }
00725 }
00726
00727
00728
00729
00730
00731
00732
00733
00734 KPopupAccelManager::KPopupAccelManager(QPopupMenu *popup)
00735 : QObject(popup), m_popup(popup), m_count(-1)
00736 {
00737 aboutToShow();
00738 connect(popup, SIGNAL(aboutToShow()), SLOT(aboutToShow()));
00739 }
00740
00741
00742 void KPopupAccelManager::aboutToShow()
00743 {
00744
00745
00746
00747
00748
00749 if (m_count != (int)m_popup->count())
00750 {
00751 findMenuEntries(m_entries);
00752 calculateAccelerators();
00753 m_count = m_popup->count();
00754 }
00755 else
00756 {
00757 KAccelStringList entries;
00758 findMenuEntries(entries);
00759 if (entries != m_entries)
00760 {
00761 m_entries = entries;
00762 calculateAccelerators();
00763 }
00764 }
00765 }
00766
00767
00768 void KPopupAccelManager::calculateAccelerators()
00769 {
00770
00771 QString used;
00772 KAccelManagerAlgorithm::findAccelerators(m_entries, used);
00773
00774
00775 setMenuEntries(m_entries);
00776 }
00777
00778
00779 void KPopupAccelManager::findMenuEntries(KAccelStringList &list)
00780 {
00781 QMenuItem *mitem;
00782 QString s;
00783
00784 list.clear();
00785
00786
00787 for (uint i=0; i<m_popup->count(); i++)
00788 {
00789 mitem = m_popup->findItem(m_popup->idAt(i));
00790 if (mitem->isSeparator())
00791 continue;
00792
00793 s = mitem->text();
00794
00795
00796 int weight = 50;
00797 if (s.contains('\t'))
00798 weight = 0;
00799
00800 list.append(KAccelString(s, weight));
00801
00802
00803 if (mitem->popup())
00804 KPopupAccelManager::manage(mitem->popup());
00805 }
00806 }
00807
00808
00809 void KPopupAccelManager::setMenuEntries(const KAccelStringList &list)
00810 {
00811 QMenuItem *mitem;
00812
00813 uint cnt = 0;
00814 for (uint i=0; i<m_popup->count(); i++)
00815 {
00816 mitem = m_popup->findItem(m_popup->idAt(i));
00817 if (mitem->isSeparator())
00818 continue;
00819
00820 if (KAcceleratorManagerPrivate::checkChange(list[cnt]))
00821 mitem->setText(list[cnt].accelerated());
00822 cnt++;
00823 }
00824 }
00825
00826
00827 void KPopupAccelManager::manage(QPopupMenu *popup)
00828 {
00829
00830 if (popup->child(0, "KPopupAccelManager", false) == 0 )
00831 new KPopupAccelManager(popup);
00832 }
00833
00834 void QWidgetStackAccelManager::manage( QWidgetStack *stack )
00835 {
00836 if ( stack->child( 0, "QWidgetStackAccelManager", false ) == 0 )
00837 new QWidgetStackAccelManager( stack );
00838 }
00839
00840 QWidgetStackAccelManager::QWidgetStackAccelManager(QWidgetStack *stack)
00841 : QObject(stack), m_stack(stack)
00842 {
00843 aboutToShow(stack->visibleWidget());
00844 connect(stack, SIGNAL(aboutToShow(QWidget *)), SLOT(aboutToShow(QWidget *)));
00845 }
00846
00847 bool QWidgetStackAccelManager::eventFilter ( QObject * watched, QEvent * e )
00848 {
00849 if ( e->type() == QEvent::Show && qApp->activeWindow() ) {
00850 KAcceleratorManager::manage( qApp->activeWindow() );
00851 watched->removeEventFilter( this );
00852 }
00853 return false;
00854 }
00855
00856 void QWidgetStackAccelManager::aboutToShow(QWidget *child)
00857 {
00858 if (!child)
00859 {
00860 kdDebug(125) << "null pointer given to aboutToShow" << endl;
00861 return;
00862 }
00863
00864 child->installEventFilter( this );
00865 }
00866
00867 void KAcceleratorManager::setNoAccel( QWidget *widget )
00868 {
00869 KAcceleratorManagerPrivate::ignored_widgets[widget] = 1;
00870 }
00871
00872 #include "kaccelmanager_private.moc"