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"