Added TQt4 HEAD

1 files changed, 2098 insertions, 0 deletions

diff --git a/tqtinterface/qt4/src/kernel/tqaccel.cpp b/tqtinterface/qt4/src/kernel/tqaccel.cpp
new file mode 100644
index 0000000..fd47345
--- /dev/null
+++ b/tqtinterface/qt4/src/kernel/tqaccel.cpp
@@ -0,0 +1,2098 @@
+#include "tqtglobaldefines.h"
+
+#if 0
+
+/****************************************************************************
+**
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the Qt3Support module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial Usage
+** Licensees holding valid Qt Commercial licenses may use this file in
+** accordance with the Qt Commercial License Agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Nokia.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "tqaccel.h"
+
+#include "tqsignal.h"
+#include "Qt/qapplication.h"
+#include "Qt/qwidget.h"
+#include "tqptrlist.h"
+#include "Qt/qwhatsthis.h"
+#include "Qt/qpointer.h"
+#include "Qt/qstatusbar.h"
+#include "Qt/qdockwidget.h"
+#include "Qt/qevent.h"
+#include "Qt/qkeysequence.h"
+// #include "private/qapplication_p.h"
+
+QT_BEGIN_NAMESPACE
+
+using namespace Qt;
+
+/*!
+    \class TQAccel
+    \brief The TQAccel class handles keyboard accelerator and shortcut keys.
+
+    \compat
+
+    A keyboard accelerator triggers an action when a certain key
+    combination is pressed. The accelerator handles all keyboard
+    activity for all the children of one top-level widget, so it is
+    not affected by the keyboard focus.
+
+    In most cases, you will not need to use this class directly. Use
+    the QAction class to create actions with accelerators that can be
+    used in both menus and toolbars. If you're only interested in
+    menus use Q3MenuData::insertItem() or Q3MenuData::setAccel() to make
+    accelerators for operations that are also available on menus. Many
+    widgets automatically generate accelerators, such as QAbstractButton,
+    QGroupBox, QLabel (with QLabel::setBuddy()), QMenuBar, and QTabBar.
+    Example:
+    \snippet doc/src/snippets/code/src_qt3support_other_q3accel.cpp 0
+
+    A TQAccel tqcontains a list of accelerator items that can be
+    manipulated using insertItem(), removeItem(), clear(), key() and
+    findKey().
+
+    Each accelerator item consists of an identifier and a \l
+    QKeySequence. A single key sequence consists of a keyboard code
+    combined with modifiers (Qt::SHIFT, Qt::CTRL, Qt::ALT, or
+    Qt::UNICODE_ACCEL). For example, Qt::CTRL + Qt::Key_P could be a shortcut
+    for printing a document. As an alternative, use Qt::UNICODE_ACCEL with the
+    tqunicode code point of the character. For example, Qt::UNICODE_ACCEL
+    + 'A' gives the same accelerator as Qt::Key_A.
+
+    When an accelerator key is pressed, the accelerator sends out the
+    signal activated() with a number that identifies this particular
+    accelerator item. Accelerator items can also be individually
+    connected, so that two different keys will activate two different
+    Q_SLOTS (see connectItem() and disconnectItem()).
+
+    The activated() signal is \e not emitted when two or more
+    accelerators match the same key.  Instead, the first matching
+    accelerator sends out the activatedAmbiguously() signal. By
+    pressing the key multiple times, users can navigate between all
+    matching accelerators. Some standard controls like QPushButton and
+    QCheckBox connect the activatedAmbiguously() signal to the
+    harmless setFocus() slot, whereas activated() is connected to a
+    slot invoking the button's action. Most controls, like QLabel and
+    QTabBar, treat activated() and activatedAmbiguously() as
+    equivalent.
+
+    Use setEnabled() to enable or disable all the items in an
+    accelerator, or setItemEnabled() to enable or disable individual
+    items. An item is active only when both the TQAccel and the item
+    itself are enabled.
+
+    The function setWhatsThis() specifies a help text that appears
+    when the user presses an accelerator key in What's This mode.
+
+    The accelerator will be deleted when \e parent is deleted,
+    and will consume relevant key events until then.
+
+    Please note that the accelerator
+    \snippet doc/src/snippets/code/src_qt3support_other_q3accel.cpp 1
+    can be triggered with both the 'M' key, and with Shift+M,
+    unless a second accelerator is defined for the Shift+M
+    combination.
+
+
+    Example:
+    \snippet doc/src/snippets/code/src_qt3support_other_q3accel.cpp 2
+
+    \sa QKeyEvent QWidget::keyPressEvent()
+    QAbstractButton::setAccel() QLabel::setBuddy() QKeySequence
+*/
+
+
+struct TQAccelItem {                                // internal accelerator item
+    TQAccelItem(const QKeySequence &k, int i)
+        { key=k; id=i; enabled=true; signal=0; }
+   ~TQAccelItem()               { delete signal; }
+    int id;
+    QKeySequence key;
+    bool enabled;
+    TQSignal *signal;
+    QString whatsthis;
+};
+
+
+typedef TQPtrList<TQAccelItem> TQAccelList; // internal accelerator list
+
+class TQAccelPrivate {
+public:
+    TQAccelPrivate(TQAccel* p);
+    ~TQAccelPrivate();
+    TQAccelList aitems;
+    bool enabled;
+    QPointer<QWidget> watch;
+    bool ignorewhatsthis;
+    TQAccel* parent;
+
+    void activate(TQAccelItem* item);
+    void activateAmbiguously(TQAccelItem* item);
+};
+
+class TQAccelManager {
+public:
+    static TQAccelManager* self() { return self_ptr ? self_ptr : new TQAccelManager; }
+    void registerAccel(TQAccelPrivate* a) { accels.append(a); }
+    void unregisterAccel(TQAccelPrivate* a) { accels.removeRef(a); if (accels.isEmpty()) delete this; }
+    bool tryAccelEvent(QWidget* w, QKeyEvent* e);
+    bool dispatchAccelEvent(QWidget* w, QKeyEvent* e);
+    bool tryComposeUnicode(QWidget* w, QKeyEvent* e);
+
+private:
+    TQAccelManager()
+        : currentState(QKeySequence::NoMatch), clash(-1), metaComposeUnicode(false),composedUnicode(0)
+        { setFuncPtr(); self_ptr = this; }
+    ~TQAccelManager() { self_ptr = 0; }
+    void setFuncPtr();
+
+    bool correctSubWindow(QWidget *w, TQAccelPrivate* d);
+    QKeySequence::SequenceMatch match(QKeyEvent* e, TQAccelItem* item, QKeySequence& temp);
+    int translateModifiers(ButtonState state);
+
+    TQPtrList<TQAccelPrivate> accels;
+    static TQAccelManager* self_ptr;
+    QKeySequence::SequenceMatch currentState;
+    QKeySequence intermediate;
+    int clash;
+    bool metaComposeUnicode;
+    int composedUnicode;
+};
+TQAccelManager* TQAccelManager::self_ptr = 0;
+
+bool Q_COMPAT_EXPORT qt_tryAccelEvent(QWidget* w, QKeyEvent*  e){
+    return TQAccelManager::self()->tryAccelEvent(w, e);
+}
+
+bool Q_COMPAT_EXPORT qt_dispatchAccelEvent(QWidget* w, QKeyEvent*  e){
+    return TQAccelManager::self()->dispatchAccelEvent(w, e);
+}
+
+bool Q_COMPAT_EXPORT qt_tryComposeUnicode(QWidget* w, QKeyEvent*  e){
+    return TQAccelManager::self()->tryComposeUnicode(w, e);
+}
+
+void TQAccelManager::setFuncPtr() {
+    if (qApp->d_func()->qt_compat_used)
+        return;
+    QApplicationPrivate *data = static_cast<QApplicationPrivate*>(qApp->d_ptr.data());
+    data->qt_tryAccelEvent = qt_tryAccelEvent;
+    data->qt_tryComposeUnicode = qt_tryComposeUnicode;
+    data->qt_dispatchAccelEvent = qt_dispatchAccelEvent;
+    data->qt_compat_used = true;
+}
+
+#ifdef Q_WS_MAC
+static bool qt_accel_no_shortcuts = true;
+#else
+static bool qt_accel_no_shortcuts = false;
+#endif
+void Q_COMPAT_EXPORT qt_set_accel_auto_shortcuts(bool b) { qt_accel_no_shortcuts = b; }
+
+/*
+    \internal
+    Returns true if the accel is in the current subwindow, else false.
+*/
+bool TQAccelManager::correctSubWindow(QWidget* w, TQAccelPrivate* d) {
+#if !defined (Q_OS_MACX)
+     if (!d->watch || !d->watch->isVisible() || !d->watch->isEnabled())
+#else
+    if (!d->watch || (!d->watch->isVisible() && !d->watch->inherits("QMenuBar")) || !d->watch->isEnabled())
+#endif
+        return false;
+    QWidget* tlw = w->window();
+    QWidget* wtlw = d->watch->window();
+
+    /* if we live in a floating dock window, keep our parent's
+     * accelerators working */
+#ifndef QT_NO_MAINWINDOW
+    if ((tlw->windowType() == Qt::Dialog) && tlw->parentWidget() && qobject_cast<QDockWidget*>(tlw))
+        return tlw->parentWidget()->window() == wtlw;
+
+    if (wtlw  != tlw)
+        return false;
+#endif
+    /* if we live in a MDI subwindow, ignore the event if we are
+       not the active document window */
+    QWidget* sw = d->watch;
+    while (sw && sw->windowType() != Qt::SubWindow)
+        sw = sw->parentWidget(true);
+    if (sw)  { // we are in a subwindow indeed
+        QWidget* fw = w;
+        while (fw && fw != sw)
+            fw = fw->parentWidget(true);
+        if (fw != sw) // focus widget not in our subwindow
+            return false;
+    }
+    return true;
+}
+
+inline int TQAccelManager::translateModifiers(ButtonState state)
+{
+    int result = 0;
+    if (state & ShiftButton)
+        result |= SHIFT;
+    if (state & ControlButton)
+        result |= CTRL;
+    if (state & MetaButton)
+        result |= META;
+    if (state & AltButton)
+        result |= ALT;
+    return result;
+}
+
+/*
+    \internal
+    Matches the current intermediate key sequence + the latest
+    keyevent, with and AccelItem. Returns Identical,
+    PartialMatch or NoMatch, and fills \a temp with the
+    resulting key sequence.
+*/
+QKeySequence::SequenceMatch TQAccelManager::match(QKeyEvent *e, TQAccelItem* item, QKeySequence& temp)
+{
+    QKeySequence::SequenceMatch result = QKeySequence::NoMatch;
+    int index = intermediate.count();
+    temp = intermediate;
+
+    int modifier = translateModifiers(e->state());
+
+    if (e->key() && e->key() != Key_unknown) {
+        int key = e->key()  | modifier;
+        if (e->key() == Key_BackTab) {
+            /*
+            In QApplication, we map shift+tab to shift+backtab.
+            This code here reverts the mapping in a way that keeps
+            backtab and shift+tab accelerators working, in that
+            order, meaning backtab has priority.*/
+            key &= ~SHIFT;
+
+            temp.setKey(key, index);
+            if (QKeySequence::NoMatch != (result = temp.matches(item->key)))
+                return result;
+            if (e->state() & ShiftButton)
+                key |= SHIFT;
+            key = Key_Tab | (key & MODIFIER_MASK);
+            temp.setKey(key, index);
+            if (QKeySequence::NoMatch != (result = temp.matches(item->key)))
+                return result;
+        } else {
+            temp.setKey(key, index);
+            if (QKeySequence::NoMatch != (result = temp.matches(item->key)))
+                return result;
+        }
+
+        if (key == Key_BackTab) {
+            if (e->state() & ShiftButton)
+                key |= SHIFT;
+            temp.setKey(key, index);
+            if (QKeySequence::NoMatch != (result = temp.matches(item->key)))
+                return result;
+        }
+    }
+    if (!e->text().isEmpty()) {
+        temp.setKey((int)e->text()[0].tqunicode() | UNICODE_ACCEL | modifier, index);
+        result = temp.matches(item->key);
+    }
+    return result;
+}
+
+bool TQAccelManager::tryAccelEvent(QWidget* w, QKeyEvent* e)
+{
+    if (QKeySequence::NoMatch == currentState) {
+        e->t = QEvent::AccelOverride;
+        e->ignore();
+        QApplication::sendSpontaneousEvent(w, e);
+        if (e->isAccepted())
+            return false;
+    }
+    e->t = QEvent::Accel;
+    e->ignore();
+    QApplication::sendSpontaneousEvent(w, e);
+    return e->isAccepted();
+}
+
+bool TQAccelManager::tryComposeUnicode(QWidget* w, QKeyEvent* e)
+{
+    if (metaComposeUnicode) {
+        int value = e->key() - Key_0;
+        // Ignore acceloverrides so we don't trigger
+        // accels on keypad when Meta compose is on
+        if ((e->type() == QEvent::AccelOverride) &&
+             (e->state() == Qt::Keypad + Qt::MetaButton)) {
+            e->accept();
+        // Meta compose start/continue
+        } else if ((e->type() == QEvent::KeyPress) &&
+             (e->state() == Qt::Keypad + Qt::MetaButton)) {
+            if (value >= 0 && value <= 9) {
+                composedUnicode *= 10;
+                composedUnicode += value;
+                return true;
+            } else {
+                // Composing interrupted, dispatch!
+                if (composedUnicode) {
+                    QChar ch(composedUnicode);
+                    QString s(ch);
+                    QKeyEvent kep(QEvent::KeyPress, 0, ch.row() ? 0 : ch.cell(), 0, s);
+                    QKeyEvent ker(QEvent::KeyRelease, 0, ch.row() ? 0 : ch.cell(), 0, s);
+                    QApplication::sendEvent(w, &kep);
+                    QApplication::sendEvent(w, &ker);
+                }
+                composedUnicode = 0;
+                return true;
+            }
+        // Meta compose end, dispatch
+        } else if ((e->type() == QEvent::KeyRelease) &&
+                    (e->key() == Key_Meta) &&
+                    (composedUnicode != 0)) {
+            if ((composedUnicode > 0) &&
+                 (composedUnicode < 0xFFFE)) {
+                QChar ch(composedUnicode);
+                QString s(ch);
+                QKeyEvent kep(QEvent::KeyPress, 0, ch.row() ? 0 : ch.cell(), 0, s);
+                QKeyEvent ker(QEvent::KeyRelease, 0, ch.row() ? 0 : ch.cell(), 0, s);
+                QApplication::sendEvent(w, &kep);
+                QApplication::sendEvent(w, &ker);
+            }
+            composedUnicode = 0;
+            return true;
+        }
+    }
+    return false;
+}
+
+/*
+    \internal
+    Checks for possible accelerators, if no widget
+    ate the keypres, or we are in the middle of a
+    partial key sequence.
+*/
+bool TQAccelManager::dispatchAccelEvent(QWidget* w, QKeyEvent* e)
+{
+#ifndef QT_NO_STATUSBAR
+    // Needs to be declared and used here because of "goto doclash"
+    QStatusBar* mainStatusBar = 0;
+#endif
+
+    // Modifiers can NOT be accelerators...
+    if (e->key() >= Key_Shift &&
+         e->key() <= Key_Alt)
+         return false;
+
+    QKeySequence::SequenceMatch result = QKeySequence::NoMatch;
+    QKeySequence tocheck, partial;
+    TQAccelPrivate* accel = 0;
+    TQAccelItem* item = 0;
+    TQAccelPrivate* firstaccel = 0;
+    TQAccelItem* firstitem = 0;
+    TQAccelPrivate* lastaccel = 0;
+    TQAccelItem* lastitem = 0;
+
+    QKeyEvent pe = *e;
+    int n = -1;
+    int hasShift = (e->state()&Qt::ShiftButton)?1:0;
+    bool identicalDisabled = false;
+    bool matchFound = false;
+    do {
+        accel = accels.first();
+        matchFound = false;
+        while (accel) {
+            if (correctSubWindow(w, accel)) {
+                if (accel->enabled) {
+                    item = accel->aitems.last();
+                    while(item) {
+                        if (QKeySequence::Identical == (result = match(&pe, item, tocheck))) {
+                            if (item->enabled) {
+                                if (!firstaccel) {
+                                    firstaccel = accel;
+                                    firstitem = item;
+                                }
+                                lastaccel = accel;
+                                lastitem = item;
+                                n++;
+                                matchFound = true;
+                                if (n > QMAX(clash,0))
+                                    goto doclash;
+                            } else {
+                                identicalDisabled = true;
+                            }
+                        }
+                        if (item->enabled && QKeySequence::PartialMatch == result) {
+                            partial = tocheck;
+                            matchFound = true;
+                        }
+                        item = accel->aitems.prev();
+                    }
+                } else {
+                    item = accel->aitems.last();
+                    while(item) {
+                        if (QKeySequence::Identical == match(&pe, item, tocheck))
+                            identicalDisabled = true;
+                        item = accel->aitems.prev();
+                    }
+                }
+            }
+            accel = accels.next();
+        }
+        pe = QKeyEvent(QEvent::Accel, pe.key(), pe.ascii(), pe.state()&~Qt::ShiftButton, pe.text());
+    } while (hasShift-- && !matchFound && !identicalDisabled);
+
+#ifndef QT_NO_STATUSBAR
+    mainStatusBar = (QStatusBar*) w->window()->child(0, "QStatusBar");
+#endif
+    if (n < 0) { // no match found
+        currentState = partial.count() ? QKeySequence::PartialMatch : QKeySequence::NoMatch;
+#ifndef QT_NO_STATUSBAR
+        // Only display message if we are, or were, in a partial match
+        if (mainStatusBar && (QKeySequence::PartialMatch == currentState || intermediate.count())) {
+            if (currentState == QKeySequence::PartialMatch) {
+                mainStatusBar->showMessage((QString)partial + QLatin1String(", ..."));
+            } else if (!identicalDisabled) {
+                QString message = TQAccel::tr("%1, %2 not defined").
+                    arg((QString)intermediate).
+                    arg(QKeySequence::encodeString(e->key() | translateModifiers(e->state())));
+                mainStatusBar->showMessage(message, 2000);
+                // Since we're a NoMatch, reset the clash count
+                clash = -1;
+            } else {
+            	mainStatusBar->clearMessage();
+            }
+        }
+#endif
+
+        bool eatKey = (QKeySequence::PartialMatch == currentState || intermediate.count());
+        intermediate = partial;
+        if (eatKey)
+            e->accept();
+        return eatKey;
+    } else if (n == 0) { // found exactly one match
+        clash = -1; // reset
+#ifndef QT_NO_STATUSBAR
+        if (currentState == QKeySequence::PartialMatch && mainStatusBar)
+                mainStatusBar->clearMessage();
+#endif
+        currentState = QKeySequence::NoMatch; // Free sequence keylock
+        intermediate = QKeySequence();
+        lastaccel->activate(lastitem);
+        e->accept();
+        return true;
+    }
+
+ doclash: // found more than one match
+#ifndef QT_NO_STATUSBAR
+    if (!mainStatusBar) // if "goto doclash", we need to get status bar again.
+        mainStatusBar = (QStatusBar*) w->window()->child(0, "QStatusBar");
+#endif
+
+    QString message = TQAccel::tr("Ambiguous %1 not handled").arg((QString)tocheck);
+    if (clash >= 0 && n > clash) { // pick next  match
+        intermediate = QKeySequence();
+        currentState = QKeySequence::NoMatch; // Free sequence keylock
+        clash++;
+#ifndef QT_NO_STATUSBAR
+        if (mainStatusBar &&
+             !lastitem->signal &&
+             !(lastaccel->parent->tqreceivers(SIGNAL(activatedAmbiguously(int)))))
+            mainStatusBar->showMessage(message, 2000);
+#endif
+        lastaccel->activateAmbiguously(lastitem);
+    } else { // start (or wrap) with the first matching
+        intermediate = QKeySequence();
+        currentState = QKeySequence::NoMatch; // Free sequence keylock
+        clash = 0;
+#ifndef QT_NO_STATUSBAR
+        if (mainStatusBar &&
+             !firstitem->signal &&
+             !(firstaccel->parent->tqreceivers(SIGNAL(activatedAmbiguously(int)))))
+            mainStatusBar->showMessage(message, 2000);
+#endif
+        firstaccel->activateAmbiguously(firstitem);
+    }
+    e->accept();
+    return true;
+}
+
+TQAccelPrivate::TQAccelPrivate(TQAccel* p)
+    : parent(p)
+{
+    TQAccelManager::self()->registerAccel(this);
+    aitems.setAutoDelete(true);
+    ignorewhatsthis = false;
+}
+
+TQAccelPrivate::~TQAccelPrivate()
+{
+    TQAccelManager::self()->unregisterAccel(this);
+}
+
+static TQAccelItem *find_id(TQAccelList &list, int id)
+{
+    register TQAccelItem *item = list.first();
+    while (item && item->id != id)
+        item = list.next();
+    return item;
+}
+
+static TQAccelItem *find_key(TQAccelList &list, const QKeySequence &key)
+{
+    register TQAccelItem *item = list.first();
+    while (item && !(item->key == key))
+        item = list.next();
+    return item;
+}
+
+/*!
+    Constructs a TQAccel object called \a name, with parent \a parent.
+    The accelerator operates on \a parent.
+*/
+
+TQAccel::TQAccel(QWidget *parent, const char *name)
+    : TQT_BASE_OBJECT_NAME(parent, name)
+{
+    d = new TQAccelPrivate(this);
+    d->enabled = true;
+    d->watch = parent;
+#if defined(QT_CHECK_NULL)
+    if (!d->watch)
+        qWarning("TQAccel: An accelerator must have a parent or a watch widget");
+#endif
+}
+
+/*!
+    Constructs a TQAccel object called \a name, that operates on \a
+    watch, and is a child of \a parent.
+
+    This constructor is not needed for normal application programming.
+*/
+TQAccel::TQAccel(QWidget* watch, TQT_BASE_OBJECT_NAME *parent, const char *name)
+    : TQT_BASE_OBJECT_NAME(parent, name)
+{
+    d = new TQAccelPrivate(this);
+    d->enabled = true;
+    d->watch = watch;
+#if defined(QT_CHECK_NULL)
+    if (!d->watch)
+        qWarning("TQAccel: An accelerator must have a parent or a watch widget");
+#endif
+}
+
+/*!
+    Destroys the accelerator object and frees all allocated resources.
+*/
+
+TQAccel::~TQAccel()
+{
+    delete d;
+}
+
+
+/*!
+    \fn void TQAccel::activated(int id)
+
+    This signal is emitted when the user types the shortcut's key
+    sequence. \a id is a number that identifies this particular
+    accelerator item.
+
+    \sa activatedAmbiguously()
+*/
+
+/*!
+    \fn void TQAccel::activatedAmbiguously(int id)
+
+    This signal is emitted when the user types a shortcut key
+    sequence that is ambiguous. For example, if one key sequence is a
+    "prefix" for another and the user types these keys it isn't clear
+    if they want the shorter key sequence, or if they're about to
+    type more to complete the longer key sequence. \a id is a number
+    that identifies this particular accelerator item.
+
+    \sa activated()
+*/
+
+/*!
+    Returns true if the accelerator is enabled; otherwise returns
+    false.
+
+    \sa setEnabled(), isItemEnabled()
+*/
+
+bool TQAccel::isEnabled() const
+{
+    return d->enabled;
+}
+
+
+/*!
+    Enables the accelerator if \a enable is true, or disables it if \a
+    enable is false.
+
+    Individual keys can also be enabled or disabled using
+    setItemEnabled(). To work, a key must be an enabled item in an
+    enabled TQAccel.
+
+    \sa isEnabled(), setItemEnabled()
+*/
+
+void TQAccel::setEnabled(bool enable)
+{
+    d->enabled = enable;
+}
+
+
+/*!
+    Returns the number of accelerator items in this accelerator.
+*/
+
+uint TQAccel::count() const
+{
+    return d->aitems.count();
+}
+
+
+static int get_seq_id()
+{
+    static int seq_no = -2;  // -1 is used as return value in findKey()
+    return seq_no--;
+}
+
+/*!
+    Inserts an accelerator item and returns the item's identifier.
+
+    \a key is a key code and an optional combination of SHIFT, CTRL
+    and ALT. \a id is the accelerator item id.
+
+    If \a id is negative, then the item will be assigned a unique
+    negative identifier less than -1.
+
+    \snippet doc/src/snippets/code/src_qt3support_other_q3accel.cpp 3
+*/
+
+int TQAccel::insertItem(const QKeySequence& key, int id)
+{
+    if (id == -1)
+        id = get_seq_id();
+    d->aitems.insert(0, new TQAccelItem(key,id));
+    return id;
+}
+
+/*!
+    Removes the accelerator item with the identifier \a id.
+*/
+
+void TQAccel::removeItem(int id)
+{
+    if (find_id(d->aitems, id))
+        d->aitems.remove();
+}
+
+
+/*!
+    Removes all accelerator items.
+*/
+
+void TQAccel::clear()
+{
+    d->aitems.clear();
+}
+
+
+/*!
+    Returns the key sequence of the accelerator item with identifier
+    \a id, or an invalid key sequence (0) if the id cannot be found.
+*/
+
+QKeySequence TQAccel::key(int id)
+{
+    TQAccelItem *item = find_id(d->aitems, id);
+    return item ? item->key : QKeySequence(0);
+}
+
+
+/*!
+    Returns the identifier of the accelerator item with the key code
+    \a key, or -1 if the item cannot be found.
+*/
+
+int TQAccel::findKey(const QKeySequence& key) const
+{
+    TQAccelItem *item = find_key(d->aitems, key);
+    return item ? item->id : -1;
+}
+
+
+/*!
+    Returns true if the accelerator item with the identifier \a id is
+    enabled. Returns false if the item is disabled or cannot be found.
+
+    \sa setItemEnabled(), isEnabled()
+*/
+
+bool TQAccel::isItemEnabled(int id) const
+{
+    TQAccelItem *item = find_id(d->aitems, id);
+    return item ? item->enabled : false;
+}
+
+
+/*!
+    Enables the accelerator item with the identifier \a id if \a
+    enable is true, and disables item \a id if \a enable is false.
+
+    To work, an item must be enabled and be in an enabled TQAccel.
+
+    \sa isItemEnabled(), isEnabled()
+*/
+
+void TQAccel::setItemEnabled(int id, bool enable)
+{
+    TQAccelItem *item = find_id(d->aitems, id);
+    if (item)
+        item->enabled = enable;
+}
+
+
+/*!
+    Connects the accelerator item \a id to the slot \a member of \a
+    receiver. Returns true if the connection is successful.
+
+    \snippet doc/src/snippets/code/src_qt3support_other_q3accel.cpp 4
+
+    Of course, you can also send a signal as \a member.
+
+    Normally accelerators are connected to Q_SLOTS which then receive
+    the \c activated(int id) signal with the id of the accelerator
+    item that was activated. If you choose to connect a specific
+    accelerator item using this function, the \c activated() signal is
+    emitted if the associated key sequence is pressed but no \c
+    activated(int id) signal is emitted.
+
+    \sa disconnectItem(), TQT_BASE_OBJECT_NAME::connect()
+*/
+
+bool TQAccel::connectItem(int id, const TQT_BASE_OBJECT_NAME *receiver, const char *member)
+{
+    TQAccelItem *item = find_id(d->aitems, id);
+    if (item) {
+        if (!item->signal) {
+            item->signal = new TQSignal;
+            Q_CHECK_PTR(item->signal);
+        }
+        return item->signal->connect(receiver, member);
+    }
+    return false;
+}
+
+/*!
+    Disconnects the accelerator item identified by \a id from
+    the function called \a member in the \a receiver object.
+    Returns true if the connection existed and the disconnect
+    was successful.
+
+    \sa connectItem(), TQT_BASE_OBJECT_NAME::disconnect()
+*/
+
+bool TQAccel::disconnectItem(int id, const TQT_BASE_OBJECT_NAME *receiver,
+                             const char *member)
+{
+    TQAccelItem *item = find_id(d->aitems, id);
+    if (item && item->signal)
+        return item->signal->disconnect(receiver, member);
+    return false;
+}
+
+void TQAccelPrivate::activate(TQAccelItem* item)
+{
+#ifndef QT_NO_WHATSTHIS
+    if (QWhatsThis::inWhatsThisMode() && !ignorewhatsthis) {
+        QWhatsThis::showText(QCursor::pos(), item->whatsthis);
+        return;
+    }
+#endif
+    if (item->signal)
+        item->signal->activate();
+    else
+        emit parent->activated(item->id);
+}
+
+void TQAccelPrivate::activateAmbiguously(TQAccelItem* item)
+{
+    if (item->signal)
+        item->signal->activate();
+    else
+        emit parent->activatedAmbiguously(item->id);
+}
+
+
+/*!
+    Returns the shortcut key sequence for \a str, or an invalid key
+    sequence (0) if \a str has no shortcut sequence.
+
+    For example, shortcutKey("E&xit") returns QKeySequence(Qt::ALT +
+    Qt::Key_X), shortcutKey("&Quit") returns QKeySequence(Qt::ALT +
+    Qt::Key_Q), and shortcutKey("Quit") returns QKeySequence().
+*/
+
+QKeySequence TQAccel::shortcutKey(const QString &str)
+{
+    if(qt_accel_no_shortcuts)
+        return QKeySequence();
+
+    int p = 0;
+    while (p >= 0) {
+        p = str.find(QLatin1Char('&'), p) + 1;
+        if (p <= 0 || p >= (int)str.length())
+            return 0;
+        if (str[p] != QLatin1Char('&')) {
+            QChar c = str[p];
+            if (c.isPrint()) {
+                char ltr = c.upper().latin1();
+                if (ltr >= (char)Key_A && ltr <= (char)Key_Z)
+                    c = QLatin1Char(ltr);
+                else
+                    c = c.lower();
+                return QKeySequence(c.tqunicode() + ALT + UNICODE_ACCEL);
+            }
+        }
+        p++;
+    }
+    return QKeySequence();
+}
+
+/*! \obsolete
+
+   Creates an accelerator string for the key \a k.
+   For instance CTRL+Key_O gives "Ctrl+O". The "Ctrl" etc.
+   are translated (using TQT_BASE_OBJECT_NAME::tr()) in the "TQAccel" context.
+
+   The function is superfluous. Cast the QKeySequence \a k to a
+   QString for the same effect.
+*/
+QString TQAccel::keyToString(QKeySequence k)
+{
+    return (QString) k;
+}
+
+/*!\obsolete
+
+  Returns an accelerator code for the string \a s. For example
+  "Ctrl+O" gives CTRL+UNICODE_ACCEL+'O'. The strings "Ctrl",
+  "Shift", "Alt" are recognized, as well as their translated
+  equivalents in the "TQAccel" context (using TQT_BASE_OBJECT_NAME::tr()). Returns 0
+  if \a s is not recognized.
+
+  This function is typically used with \link TQT_BASE_OBJECT_NAME::tr() tr
+  \endlink(), so that accelerator keys can be tqreplaced in
+  translations:
+
+  \snippet doc/src/snippets/code/src_qt3support_other_q3accel.cpp 5
+
+  Notice the "File|Open" translator comment. It is by no means
+  necessary, but it provides some context for the human translator.
+
+  The function is superfluous. Construct a QKeySequence from the
+  string \a s for the same effect.
+
+  \sa TQT_BASE_OBJECT_NAME::tr(), {Internationalization with Qt}
+*/
+QKeySequence TQAccel::stringToKey(const QString & s)
+{
+    return QKeySequence(s);
+}
+
+
+/*!
+    Sets a What's This help text for the accelerator item \a id to \a
+    text.
+
+    The text will be shown when the application is in What's This mode
+    and the user hits the accelerator key.
+
+    To set What's This help on a menu item (with or without an
+    accelerator key), use Q3MenuData::setWhatsThis().
+
+    \sa whatsThis(), QWhatsThis::inWhatsThisMode(), QAction::setWhatsThis()
+*/
+void TQAccel::setWhatsThis(int id, const QString& text)
+{
+    TQAccelItem *item = find_id(d->aitems, id);
+    if (item)
+        item->whatsthis = text;
+}
+
+/*!
+    Returns the What's This help text for the specified item \a id or
+    an empty string if no text has been specified.
+
+    \sa setWhatsThis()
+*/
+QString TQAccel::whatsThis(int id) const
+{
+
+    TQAccelItem *item = find_id(d->aitems, id);
+    return item? item->whatsthis : QString();
+}
+
+/*!\internal */
+void TQAccel::setIgnoreWhatsThis(bool b)
+{
+    d->ignorewhatsthis = b;
+}
+
+/*!\internal */
+bool TQAccel::ignoreWhatsThis() const
+{
+    return d->ignorewhatsthis;
+}
+
+/*!
+    \fn void TQAccel::repairEventFilter()
+    \internal
+*/
+
+QT_END_NAMESPACE
+
+#else // USE_QT4
+
+/****************************************************************************
+**
+** Implementation of TQAccel class
+**
+** Created : 950419
+**
+** Copyright (C) 2010 Timothy Pearson and (C) 1992-2008 Trolltech ASA.
+**
+** This file is part of the kernel module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#include "tqaccel.h"
+
+#ifndef TQT_NO_ACCEL
+
+#include "tqsignal.h"
+#include "tqapplication.h"
+#include "tqwidget.h"
+#include "tqptrlist.h"
+#include "tqwhatsthis.h"
+#include "tqguardedptr.h"
+#include "tqstatusbar.h"
+#include "tqdockwindow.h"
+#include "tqsignalslotimp.h"
+/*!
+    \class TQAccel tqaccel.h
+    \brief The TQAccel class handles keyboard accelerator and shortcut keys.
+
+    \ingroup misc
+
+    A keyboard accelerator triggers an action when a certain key
+    combination is pressed. The accelerator handles all keyboard
+    activity for all the tqchildren of one top-level widget, so it is
+    not affected by the keyboard focus.
+
+    In most cases, you will not need to use this class directly. Use
+    the TQAction class to create actions with accelerators that can be
+    used in both menus and toolbars. If you're only interested in
+    menus use TQMenuData::insertItem() or TQMenuData::setAccel() to make
+    accelerators for operations that are also available on menus. Many
+    widgets automatically generate accelerators, such as TQButton,
+    TQGroupBox, TQLabel (with TQLabel::setBuddy()), TQMenuBar and TQTabBar.
+    Example:
+    \code
+	TQPushButton p( "&Exit", tqparent ); // automatic shortcut ALT+Key_E
+	TQPopupMenu *fileMenu = new fileMenu( tqparent );
+	fileMenu->insertItem( "Undo", tqparent, TQT_SLOT(undo()), CTRL+Key_Z );
+    \endcode
+
+    A TQAccel tqcontains a list of accelerator items that can be
+    manipulated using insertItem(), removeItem(), clear(), key() and
+    tqfindKey().
+
+    Each accelerator item consists of an identifier and a \l
+    TQKeySequence. A single key sequence consists of a keyboard code
+    combined with modifiers (\c SHIFT, \c CTRL, \c ALT or \c
+    UNICODE_ACCEL). For example, \c{CTRL + Key_P} could be a shortcut
+    for printing a document. The key codes are listed in \c
+    tqnamespace.h. As an alternative, use \c UNICODE_ACCEL with the
+    tqunicode code point of the character. For example, \c{UNICODE_ACCEL
+    + 'A'} gives the same accelerator as \c Key_A.
+
+    When an accelerator key is pressed, the accelerator sends out the
+    signal activated() with a number that identifies this particular
+    accelerator item. Accelerator items can also be individually
+    connected, so that two different keys will activate two different
+    Q_SLOTS (see connectItem() and disconnectItem()).
+
+    The activated() signal is \e not emitted when two or more
+    accelerators match the same key.  Instead, the first matching
+    accelerator sends out the activatedAmbiguously() signal. By
+    pressing the key multiple times, users can navigate between all
+    matching accelerators. Some standard controls like TQPushButton and
+    TQCheckBox connect the activatedAmbiguously() signal to the
+    harmless setFocus() slot, whereas activated() is connected to a
+    slot invoking the button's action.	Most controls, like TQLabel and
+    TQTabBar, treat activated() and activatedAmbiguously() as
+    equivalent.
+
+    Use setEnabled() to enable or disable all the items in an
+    accelerator, or setItemEnabled() to enable or disable individual
+    items. An item is active only when both the TQAccel and the item
+    itself are enabled.
+
+    The function setWhatsThis() specifies a help text that appears
+    when the user presses an accelerator key in What's This mode.
+
+    The accelerator will be deleted when \e tqparent is deleted,
+    and will consume relevant key events until then.
+
+    Please note that the accelerator
+    \code
+	accelerator->insertItem( TQKeySequence("M") );
+    \endcode
+    can be triggered with both the 'M' key, and with Shift+M,
+    unless a second accelerator is defined for the Shift+M
+    combination.
+
+
+    Example:
+    \code
+	TQAccel *a = new TQAccel( myWindow );	   // create accels for myWindow
+	a->connectItem( a->insertItem(Key_P+CTRL), // adds Ctrl+P accelerator
+			myWindow,		   // connected to myWindow's
+			TQT_SLOT(printDoc()) );	   // printDoc() slot
+    \endcode
+
+    \sa TQKeyEvent TQWidget::keyPressEvent() TQMenuData::setAccel()
+    TQButton::setAccel() TQLabel::setBuddy() TQKeySequence
+    \link guibooks.html#fowler GUI Design Handbook: Keyboard Shortcuts \endlink.
+*/
+
+
+struct TQAccelItem {				// internal accelerator item
+    TQAccelItem( const TQKeySequence &k, int i )
+	{ key=k; id=i; enabled=TRUE; signal=0; }
+   ~TQAccelItem()	       { delete signal; }
+    int		    id;
+    TQKeySequence    key;
+    bool	    enabled;
+    TQSignal	   *signal;
+    TQString	    whatsthis;
+};
+
+
+typedef TQPtrList<TQAccelItem> TQAccelList; // internal accelerator list
+
+class TQAccelPrivate : public TQt {
+public:
+    TQAccelPrivate( TQAccel* p );
+    ~TQAccelPrivate();
+    TQAccelList aitems;
+    bool enabled;
+    TQGuardedPtr<TQWidget> watch;
+    bool ignorewhatsthis;
+    TQAccel* tqparent;
+
+    void activate( TQAccelItem* item );
+    void activateAmbiguously( TQAccelItem* item );
+};
+
+class TQAccelManager : public TQt {
+public:
+    static TQAccelManager* self() { return self_ptr ? self_ptr : new TQAccelManager; }
+    void registerAccel( TQAccelPrivate* a ) { accels.append( a ); }
+    void unregisterAccel( TQAccelPrivate* a ) { accels.removeRef( a ); if ( accels.isEmpty() ) delete this; }
+    bool tryAccelEvent( TQWidget* w, TQKeyEvent* e );
+    bool dispatchAccelEvent( TQWidget* w, TQKeyEvent* e );
+    bool tryComposeUnicode( TQWidget* w, TQKeyEvent* e );
+
+private:
+    TQAccelManager():currentState(TQt::NoMatch), clash(-1) { self_ptr = this; }
+    ~TQAccelManager() { self_ptr = 0; }
+
+    bool correctSubWindow( TQWidget *w, TQAccelPrivate* d );
+    SequenceMatch match( TQKeyEvent* e, TQAccelItem* item, TQKeySequence& temp );
+    int translateModifiers( ButtonState state );
+
+    TQPtrList<TQAccelPrivate> accels;
+    static TQAccelManager* self_ptr;
+    TQt::SequenceMatch currentState;
+    TQKeySequence intermediate;
+    int clash;
+};
+TQAccelManager* TQAccelManager::self_ptr = 0;
+
+bool TQ_EXPORT qt_tryAccelEvent( TQWidget* w, TQKeyEvent*  e){
+    return TQAccelManager::self()->tryAccelEvent( w, e );
+}
+
+bool TQ_EXPORT qt_dispatchAccelEvent( TQWidget* w, TQKeyEvent*  e){
+    return TQAccelManager::self()->dispatchAccelEvent( w, e );
+}
+
+bool TQ_EXPORT qt_tryComposeUnicode( TQWidget* w, TQKeyEvent*  e){
+    return TQAccelManager::self()->tryComposeUnicode( w, e );
+}
+
+#ifdef TQ_WS_MAC
+static bool qt_accel_no_shortcuts = TRUE;
+#else
+static bool qt_accel_no_shortcuts = FALSE;
+#endif
+void TQ_EXPORT qt_setAccelAutoShortcuts(bool b) { qt_accel_no_shortcuts = b; }
+
+/*
+    \internal
+    Returns TRUE if the accel is in the current subwindow, else FALSE.
+*/
+bool TQAccelManager::correctSubWindow( TQWidget* w, TQAccelPrivate* d ) {
+#if !defined ( TQ_OS_MACX )
+     if ( !d->watch || !d->watch->isVisible() || !d->watch->isEnabled() )
+#else
+    if ( !d->watch || (!d->watch->isVisible() && !d->watch->inherits( "TQMenuBar" )) || !d->watch->isEnabled() )
+#endif
+	return FALSE;
+    TQWidget* tlw = w->tqtopLevelWidget();
+    TQWidget* wtlw = d->watch->tqtopLevelWidget();
+
+    /* if we live in a floating dock window, keep our tqparent's
+     * accelerators working */
+#ifndef TQT_NO_MAINWINDOW
+    if ( tlw->isDialog() && tlw->parentWidget() && ::tqqt_cast<TQDockWindow*>(tlw) )	// [FIXME] Can I safely use the TQT_TQOBJECT macro here?
+	return tlw->parentWidget()->tqtopLevelWidget() == wtlw;
+
+    if ( wtlw  != tlw )
+	return FALSE;
+#endif
+    /* if we live in a MDI subwindow, ignore the event if we are
+       not the active document window */
+    TQWidget* sw = d->watch;
+    while ( sw && !sw->testWFlags( WSubWindow ) )
+	sw = sw->parentWidget( TRUE );
+    if ( sw )  { // we are in a subwindow indeed
+	TQWidget* fw = w;
+	while ( fw && fw != sw )
+	    fw = fw->parentWidget( TRUE );
+	if ( fw != sw ) // focus widget not in our subwindow
+	    return FALSE;
+    }
+    return TRUE;
+}
+
+inline int TQAccelManager::translateModifiers( ButtonState state )
+{
+    int result = 0;
+    if ( state & ShiftButton )
+	result |= SHIFT;
+    if ( state & ControlButton )
+	result |= CTRL;
+    if ( state & MetaButton )
+	result |= META;
+    if ( state & AltButton )
+	result |= ALT;
+    return result;
+}
+
+/*
+    \internal
+    Matches the current intermediate key sequence + the latest
+    keyevent, with and AccelItem. Returns Identical,
+    PartialMatch or NoMatch, and fills \a temp with the
+    resulting key sequence.
+*/
+TQt::SequenceMatch TQAccelManager::match( TQKeyEvent *e, TQAccelItem* item, TQKeySequence& temp )
+{
+    SequenceMatch result = TQt::NoMatch;
+    int index = intermediate.count();
+    temp = intermediate;
+
+    int modifier = translateModifiers( e->state() );
+
+    if ( e->key() && e->key() != Key_unknown) {
+	int key = e->key()  | modifier;
+	if ( e->key() == Key_BackTab ) {
+	    /*
+	    In TQApplication, we map shift+tab to shift+backtab.
+	    This code here reverts the mapping in a way that keeps
+	    backtab and shift+tab accelerators working, in that
+	    order, meaning backtab has priority.*/
+	    key &= ~SHIFT;
+
+	    temp.setKey( key, index );
+	    if ( TQt::NoMatch != (result = temp.matches( item->key )) )
+		return result;
+	    if ( e->state() & ShiftButton )
+		key |= SHIFT;
+	    key = Key_Tab | ( key & MODIFIER_MASK );
+	    temp.setKey( key, index );
+	    if ( TQt::NoMatch != (result = temp.matches( item->key )) )
+		return result;
+	} else {
+	    temp.setKey( key, index );
+	    if ( TQt::NoMatch != (result = temp.matches( item->key )) )
+		return result;
+	}
+
+	if ( key == Key_BackTab ) {
+	    if ( e->state() & ShiftButton )
+		key |= SHIFT;
+	    temp.setKey( key, index );
+	    if ( TQt::NoMatch != (result = temp.matches( item->key )) )
+		return result;
+	}
+    }
+    if ( !e->text().isEmpty() ) {
+	temp.setKey( (int)e->text()[0].unicode() | UNICODE_ACCEL | modifier, index );
+	result = temp.matches( item->key );
+    }
+    return result;
+}
+
+bool TQAccelManager::tryAccelEvent( TQWidget* w, TQKeyEvent* e )
+{
+    if ( TQt::NoMatch == currentState ) {
+	e->t = TQEvent::AccelOverride;
+	e->ignore();
+	TQAccel::sendSpontaneousKeyEvent( TQT_TQOBJECT(w), e );
+	if ( e->isAccepted() )
+	    return FALSE;
+    }
+    e->t = TQEvent::Accel;
+    e->ignore();
+    TQAccel::sendSpontaneousKeyEvent( TQT_TQOBJECT(w), e );
+    return e->isAccepted();
+}
+
+bool TQAccelManager::tryComposeUnicode( TQWidget* w, TQKeyEvent* e )
+{
+    if ( TQApplication::metaComposeUnicode ) {
+	int value = e->key() - Key_0;
+	// Ignore acceloverrides so we don't trigger
+	// accels on keypad when Meta compose is on
+	if ( (e->type() == TQEvent::AccelOverride) &&
+	     (e->state() == TQt::Keypad + TQt::MetaButton) ) {
+	    e->accept();
+	// Meta compose start/continue
+	} else if ( (e->type() == TQEvent::KeyPress) &&
+	     (e->state() == TQt::Keypad + TQt::MetaButton) ) {
+	    if ( value >= 0 && value <= 9 ) {
+		TQApplication::composedUnicode *= 10;
+		TQApplication::composedUnicode += value;
+		return TRUE;
+	    } else {
+		// Composing interrupted, dispatch!
+		if ( TQApplication::composedUnicode ) {
+		    TQChar ch( TQApplication::composedUnicode );
+		    TQString s( ch );
+		    TQKeyEvent kep( TQEvent::KeyPress, 0, ch.row() ? 0 : ch.cell(), 0, s );
+		    TQKeyEvent ker( TQEvent::KeyRelease, 0, ch.row() ? 0 : ch.cell(), 0, s );
+		    TQApplication::sendEvent( w, &kep );
+		    TQApplication::sendEvent( w, &ker );
+		}
+		TQApplication::composedUnicode = 0;
+		return TRUE;
+	    }
+	// Meta compose end, dispatch
+	} else if ( (e->type() == TQEvent::KeyRelease) &&
+		    (e->key() == Key_Meta) &&
+		    (TQApplication::composedUnicode != 0) ) {
+	    if ( (TQApplication::composedUnicode > 0) &&
+		 (TQApplication::composedUnicode < 0xFFFE) ) {
+		TQChar ch( TQApplication::composedUnicode );
+		TQString s( ch );
+		TQKeyEvent kep( TQEvent::KeyPress, 0, ch.row() ? 0 : ch.cell(), 0, s );
+		TQKeyEvent ker( TQEvent::KeyRelease, 0, ch.row() ? 0 : ch.cell(), 0, s );
+		TQApplication::sendEvent( w, &kep );
+		TQApplication::sendEvent( w, &ker );
+	    }
+	    TQApplication::composedUnicode = 0;
+	    return TRUE;
+	}
+    }
+    return FALSE;
+}
+
+/*
+    \internal
+    Checks for possible accelerators, if no widget
+    ate the keypres, or we are in the middle of a
+    partial key sequence.
+*/
+bool TQAccelManager::dispatchAccelEvent( TQWidget* w, TQKeyEvent* e )
+{
+#ifndef TQT_NO_STATUSBAR
+    // Needs to be declared and used here because of "goto doclash"
+    TQStatusBar* maintqStatusBar = 0;
+#endif
+
+    // Modifiers can NOT be accelerators...
+    if ( e->key() >= Key_Shift &&
+	 e->key() <= Key_Alt )
+	 return FALSE;
+
+    SequenceMatch result = TQt::NoMatch;
+    TQKeySequence tocheck, partial;
+    TQAccelPrivate* accel = 0;
+    TQAccelItem* item = 0;
+    TQAccelPrivate* firstaccel = 0;
+    TQAccelItem* firstitem = 0;
+    TQAccelPrivate* lastaccel = 0;
+    TQAccelItem* lastitem = 0;
+
+    TQKeyEvent pe = *e;
+    int n = -1;
+    int hasShift = (e->state()&ShiftButton)?1:0;
+    bool identicalDisabled = FALSE;
+    bool matchFound = FALSE;
+    do {
+	accel = accels.first();
+	matchFound = FALSE;
+	while ( accel ) {
+	    if ( correctSubWindow( w, accel ) ) {
+		if ( accel->enabled ) {
+		    item = accel->aitems.last();
+		    while( item ) {
+			if ( TQt::Identical == (result = match( &pe, item, tocheck )) ) {
+			    if ( item->enabled ) {
+				if ( !firstaccel ) {
+				    firstaccel = accel;
+				    firstitem = item;
+				}
+				lastaccel = accel;
+				lastitem = item;
+				n++;
+				matchFound = TRUE;
+				if ( n > TQMAX(clash,0) )
+				    goto doclash;
+			    } else {
+				identicalDisabled = TRUE;
+			    }
+			}
+			if ( item->enabled && TQt::PartialMatch == result ) {
+			    partial = tocheck;
+			    matchFound = TRUE;
+			}
+			item = accel->aitems.prev();
+		    }
+		} else {
+		    item = accel->aitems.last();
+		    while( item ) {
+			if ( TQt::Identical == match( &pe, item, tocheck ) )
+			    identicalDisabled = TRUE;
+			item = accel->aitems.prev();
+		    }
+		}
+	    }
+	    accel = accels.next();
+	}
+	pe = TQKeyEvent( TQEvent::Accel, pe.key(), pe.ascii(), pe.state()&~ShiftButton, pe.text() );
+    } while ( hasShift-- && !matchFound && !identicalDisabled );
+
+#ifndef TQT_NO_STATUSBAR
+    maintqStatusBar = (TQStatusBar*) w->tqtopLevelWidget()->child( 0, "TQStatusBar" );
+#endif
+    if ( n < 0 ) { // no match found
+	currentState = partial.count() ? PartialMatch : NoMatch;
+#ifndef TQT_NO_STATUSBAR
+	// Only display message if we are, or were, in a partial match
+	if ( maintqStatusBar && (PartialMatch == currentState || intermediate.count() ) ) {
+	    if ( currentState == TQt::PartialMatch ) {
+		maintqStatusBar->message( (TQString)partial + ", ...", 0 );
+	    } else if (!identicalDisabled) {
+		TQString message = TQAccel::tr("%1, %2 not defined").
+		    arg( (TQString)intermediate ).
+		    arg( TQKeySequence::encodeString( e->key() | translateModifiers(e->state()) ) );
+		maintqStatusBar->message( message, 2000 );
+		// Since we're a NoMatch, reset the clash count
+		clash = -1;
+	    } else {
+	    	maintqStatusBar->clear();
+	    }
+	}
+#endif
+
+	bool eatKey = (PartialMatch == currentState || intermediate.count() );
+	intermediate = partial;
+	if ( eatKey )
+	    e->accept();
+	return eatKey;
+    } else if ( n == 0 ) { // found exactly one match
+	clash = -1; // reset
+#ifndef TQT_NO_STATUSBAR
+	if ( currentState == TQt::PartialMatch && maintqStatusBar )
+		maintqStatusBar->clear();
+#endif
+	currentState = TQt::NoMatch; // Free sequence keylock
+	intermediate = TQKeySequence();
+	lastaccel->activate( lastitem );
+	e->accept();
+	return TRUE;
+    }
+
+ doclash: // found more than one match
+#ifndef TQT_NO_STATUSBAR
+    if ( !maintqStatusBar ) // if "goto doclash", we need to get statusbar again.
+	maintqStatusBar = (TQStatusBar*) w->tqtopLevelWidget()->child( 0, "TQStatusBar" );
+#endif
+
+    TQString message = TQAccel::tr( "Ambiguous \"%1\" not handled" ).arg( (TQString)tocheck );
+    if ( clash >= 0 && n > clash ) { // pick next  match
+	intermediate = TQKeySequence();
+	currentState = TQt::NoMatch; // Free sequence keylock
+	clash++;
+#ifndef TQT_NO_STATUSBAR
+	if ( maintqStatusBar &&
+	     !lastitem->signal &&
+	     !(lastaccel->tqparent->tqreceivers( "activatedAmbiguously(int)" )) )
+	    maintqStatusBar->message( message, 2000 );
+#endif
+	lastaccel->activateAmbiguously( lastitem );
+    } else { // start (or wrap) with the first matching
+	intermediate = TQKeySequence();
+	currentState = TQt::NoMatch; // Free sequence keylock
+	clash = 0;
+#ifndef TQT_NO_STATUSBAR
+	if ( maintqStatusBar &&
+	     !firstitem->signal &&
+	     !(firstaccel->tqparent->tqreceivers( "activatedAmbiguously(int)" )) )
+	    maintqStatusBar->message( message, 2000 );
+#endif
+	firstaccel->activateAmbiguously( firstitem );
+    }
+    e->accept();
+    return TRUE;
+}
+
+TQAccelPrivate::TQAccelPrivate( TQAccel* p )
+    : tqparent( p )
+{
+    TQAccelManager::self()->registerAccel( this );
+    aitems.setAutoDelete( TRUE );
+    ignorewhatsthis = FALSE;
+}
+
+TQAccelPrivate::~TQAccelPrivate()
+{
+    TQAccelManager::self()->unregisterAccel( this );
+}
+
+static TQAccelItem *tqfind_id( TQAccelList &list, int id )
+{
+    register TQAccelItem *item = list.first();
+    while ( item && item->id != id )
+	item = list.next();
+    return item;
+}
+
+static TQAccelItem *tqfind_key( TQAccelList &list, const TQKeySequence &key )
+{
+    register TQAccelItem *item = list.first();
+    while ( item && !( item->key == key ) )
+	item = list.next();
+    return item;
+}
+
+/*!
+    Constructs a TQAccel object called \a name, with tqparent \a tqparent.
+    The accelerator operates on \a tqparent.
+*/
+
+TQAccel::TQAccel( TQWidget *tqparent, const char *name )
+    : TQObject( TQT_TQOBJECT(tqparent), name )
+{
+    d = new TQAccelPrivate( this );
+    d->enabled = TRUE;
+    d->watch = tqparent;
+#if defined(TQT_CHECK_NULL)
+    if ( !d->watch )
+	qWarning( "TQAccel: An accelerator must have a tqparent or a watch widget" );
+#endif
+}
+
+/*!
+    Constructs a TQAccel object called \a name, that operates on \a
+    watch, and is a child of \a tqparent.
+
+    This constructor is not needed for normal application programming.
+*/
+TQAccel::TQAccel( TQWidget* watch, TQObject *tqparent, const char *name )
+    : TQObject( tqparent, name )
+{
+    d = new TQAccelPrivate( this );
+    d->enabled = TRUE;
+    d->watch = watch;
+#if defined(TQT_CHECK_NULL)
+    if ( !d->watch )
+	qWarning( "TQAccel: An accelerator must have a tqparent or a watch widget" );
+#endif
+}
+
+/*!
+    Constructs a TQAccel object called \a name, that operates on \a
+    watch, and is a child of \a tqparent.
+
+    This constructor is not needed for normal application programming.
+*/
+TQAccel::TQAccel( TQWidget* watch, TQWidget *tqparent, const char *name )
+    : TQObject( TQT_TQOBJECT(tqparent), name )
+{
+    d = new TQAccelPrivate( this );
+    d->enabled = TRUE;
+    d->watch = watch;
+#if defined(TQT_CHECK_NULL)
+    if ( !d->watch )
+	qWarning( "TQAccel: An accelerator must have a tqparent or a watch widget" );
+#endif
+}
+
+/*!
+    Destroys the accelerator object and frees all allocated resources.
+*/
+
+TQAccel::~TQAccel()
+{
+    delete d;
+}
+
+
+/*!
+    \fn void TQAccel::activated( int id )
+
+    This signal is emitted when an accelerator key is pressed. \a id
+    is a number that identifies this particular accelerator item.
+
+    \sa activatedAmbiguously()
+*/
+
+/*!
+    \fn void TQAccel::activatedAmbiguously( int id )
+
+    This signal is emitted when an accelerator key is pressed. \a id
+    is a number that identifies this particular accelerator item.
+
+    \sa activated()
+*/
+
+
+/*!
+    Returns TRUE if the accelerator is enabled; otherwise returns
+    FALSE.
+
+    \sa setEnabled(), isItemEnabled()
+*/
+
+bool TQAccel::isEnabled() const
+{
+    return d->enabled;
+}
+
+
+/*!
+    Enables the accelerator if \a enable is TRUE, or disables it if \a
+    enable is FALSE.
+
+    Individual keys can also be enabled or disabled using
+    setItemEnabled(). To work, a key must be an enabled item in an
+    enabled TQAccel.
+
+    \sa isEnabled(), setItemEnabled()
+*/
+
+void TQAccel::setEnabled( bool enable )
+{
+    d->enabled = enable;
+}
+
+
+/*!
+    Returns the number of accelerator items in this accelerator.
+*/
+
+uint TQAccel::count() const
+{
+    return d->aitems.count();
+}
+
+
+static int get_seq_id()
+{
+    static int seq_no = -2;  // -1 is used as return value in tqfindKey()
+    return seq_no--;
+}
+
+/*!
+    Inserts an accelerator item and returns the item's identifier.
+
+    \a key is a key code and an optional combination of SHIFT, CTRL
+    and ALT. \a id is the accelerator item id.
+
+    If \a id is negative, then the item will be assigned a unique
+    negative identifier less than -1.
+
+    \code
+	TQAccel *a = new TQAccel( myWindow );	   // create accels for myWindow
+	a->insertItem( CTRL + Key_P, 200 );	   // Ctrl+P, e.g. to print document
+	a->insertItem( ALT + Key_X, 201 );	   // Alt+X, e.g. to quit
+	a->insertItem( UNICODE_ACCEL + 'q', 202 ); // Unicode 'q', e.g. to quit
+	a->insertItem( Key_D );			   // gets a unique negative id < -1
+	a->insertItem( CTRL + SHIFT + Key_P );	   // gets a unique negative id < -1
+    \endcode
+*/
+
+int TQAccel::insertItem( const TQKeySequence& key, int id )
+{
+    if ( id == -1 )
+	id = get_seq_id();
+    d->aitems.insert( 0, new TQAccelItem(key,id) );
+    return id;
+}
+
+/*!
+    Removes the accelerator item with the identifier \a id.
+*/
+
+void TQAccel::removeItem( int id )
+{
+    if ( tqfind_id( d->aitems, id) )
+	d->aitems.remove();
+}
+
+
+/*!
+    Removes all accelerator items.
+*/
+
+void TQAccel::clear()
+{
+    d->aitems.clear();
+}
+
+
+/*!
+    Returns the key sequence of the accelerator item with identifier
+    \a id, or an invalid key sequence (0) if the id cannot be found.
+*/
+
+TQKeySequence TQAccel::key( int id )
+{
+    TQAccelItem *item = tqfind_id( d->aitems, id);
+    return item ? item->key : TQKeySequence( 0 );
+}
+
+
+/*!
+    Returns the identifier of the accelerator item with the key code
+    \a key, or -1 if the item cannot be found.
+*/
+
+int TQAccel::tqfindKey( const TQKeySequence& key ) const
+{
+    TQAccelItem *item = tqfind_key( d->aitems, key );
+    return item ? item->id : -1;
+}
+
+
+/*!
+    Returns TRUE if the accelerator item with the identifier \a id is
+    enabled. Returns FALSE if the item is disabled or cannot be found.
+
+    \sa setItemEnabled(), isEnabled()
+*/
+
+bool TQAccel::isItemEnabled( int id ) const
+{
+    TQAccelItem *item = tqfind_id( d->aitems, id);
+    return item ? item->enabled : FALSE;
+}
+
+
+/*!
+    Enables the accelerator item with the identifier \a id if \a
+    enable is TRUE, and disables item \a id if \a enable is FALSE.
+
+    To work, an item must be enabled and be in an enabled TQAccel.
+
+    \sa isItemEnabled(), isEnabled()
+*/
+
+void TQAccel::setItemEnabled( int id, bool enable )
+{
+    TQAccelItem *item = tqfind_id( d->aitems, id);
+    if ( item )
+	item->enabled = enable;
+}
+
+
+/*!
+    Connects the accelerator item \a id to the slot \a member of \a
+    receiver.
+
+    \code
+	a->connectItem( 201, mainView, TQT_SLOT(quit()) );
+    \endcode
+
+    Of course, you can also send a signal as \a member.
+
+    Normally accelerators are connected to Q_SLOTS which then receive
+    the \c activated(int id) signal with the id of the accelerator
+    item that was activated. If you choose to connect a specific
+    accelerator item using this function, the \c activated() signal is
+    emitted if the associated key sequence is pressed but no \c
+    activated(int id) signal is emitted.
+
+    \sa disconnectItem()
+*/
+
+bool TQAccel::connectItem( int id, const TQT_BASE_OBJECT_NAME *receiver, const char *member )
+{
+    TQAccelItem *item = tqfind_id( d->aitems, id);
+    if ( item ) {
+	if ( !item->signal ) {
+	    item->signal = new TQSignal;
+	    TQ_CHECK_PTR( item->signal );
+	}
+	return item->signal->connect( receiver, member );
+    }
+    return FALSE;
+}
+
+/*!
+    Disconnects an accelerator item with id \a id from the function
+    called \a member in the \a receiver object.
+
+    \sa connectItem()
+*/
+
+bool TQAccel::disconnectItem( int id, const TQT_BASE_OBJECT_NAME *receiver,
+			     const char *member )
+{
+    TQAccelItem *item = tqfind_id( d->aitems, id);
+    if ( item && item->signal )
+	return item->signal->disconnect( receiver, member );
+    return FALSE;
+}
+
+void TQAccelPrivate::activate( TQAccelItem* item )
+{
+#ifndef TQT_NO_WHATSTHIS
+    if ( TQWhatsThis::inWhatsThisMode() && !ignorewhatsthis ) {
+	TQWhatsThis::leaveWhatsThisMode( item->whatsthis );
+	return;
+    }
+#endif
+    if ( item->signal )
+	item->signal->activate();
+    else
+	emit tqparent->activated( item->id );
+}
+
+void TQAccelPrivate::activateAmbiguously( TQAccelItem* item )
+{
+    if ( item->signal )
+	item->signal->activate();
+    else
+	emit tqparent->activatedAmbiguously( item->id );
+}
+
+
+/*!
+    Returns the shortcut key sequence for \a str, or an invalid key
+    sequence (0) if \a str has no shortcut sequence.
+
+    For example, shortcutKey("E&amp;xit") returns ALT+Key_X,
+    shortcutKey("&amp;Quit") returns ALT+Key_Q and shortcutKey("Quit")
+    returns 0. (In code that does not inherit the TQt namespace class,
+    you must write e.g. TQt::ALT+TQt::Key_Q.)
+
+    We provide a \link accelerators.html list of common accelerators
+    \endlink in English. At the time of writing, Microsoft and Open
+    Group do not appear to have issued equivalent recommendations for
+    other languages.
+*/
+
+TQKeySequence TQAccel::shortcutKey( const TQString &str )
+{
+    if(qt_accel_no_shortcuts)
+	return TQKeySequence();
+
+    int p = 0;
+    while ( p >= 0 ) {
+	p = str.tqfind( '&', p ) + 1;
+	if ( p <= 0 || p >= (int)str.length() )
+	    return 0;
+	if ( str[p] != '&' ) {
+	    TQChar c = str[p];
+	    if ( c.isPrint() ) {
+	        char ltr = c.upper().latin1();
+	        if ( ltr >= (char)Qt::Key_A && ltr <= (char)Qt::Key_Z )
+                    c = ltr;
+                else
+                    c = c.lower();
+		return TQKeySequence( c.tqunicode() + Qt::ALT + Qt::UNICODE_ACCEL );
+	    }
+	}
+	p++;
+    }
+    return TQKeySequence();
+}
+
+/*! \obsolete
+
+   Creates an accelerator string for the key \a k.
+   For instance CTRL+Key_O gives "Ctrl+O". The "Ctrl" etc.
+   are translated (using TQObject::tr()) in the "TQAccel" context.
+
+   The function is superfluous. Cast the TQKeySequence \a k to a
+   TQString for the same effect.
+*/
+TQString TQAccel::keyToString( TQKeySequence k )
+{
+    return (TQString) k;
+}
+
+/*!\obsolete
+
+  Returns an accelerator code for the string \a s. For example
+  "Ctrl+O" gives CTRL+UNICODE_ACCEL+'O'. The strings "Ctrl",
+  "Shift", "Alt" are recognized, as well as their translated
+  equivalents in the "TQAccel" context (using TQObject::tr()). Returns 0
+  if \a s is not recognized.
+
+  This function is typically used with \link TQObject::tr() tr
+  \endlink(), so that accelerator keys can be tqreplaced in
+  translations:
+
+  \code
+    TQPopupMenu *file = new TQPopupMenu( this );
+    file->insertItem( p1, tr("&Open..."), this, TQT_SLOT(open()),
+		      TQAccel::stringToKey(tr("Ctrl+O", "File|Open")) );
+  \endcode
+
+  Notice the \c "File|Open" translator comment. It is by no means
+  necessary, but it provides some context for the human translator.
+
+
+  The function is superfluous. Construct a TQKeySequence from the
+  string \a s for the same effect.
+
+  \sa TQObject::tr()
+      \link i18n.html Internationalization with TQt \endlink
+*/
+TQKeySequence TQAccel::stringToKey( const TQString & s )
+{
+    return TQKeySequence( s );
+}
+
+
+/*!
+    Sets a What's This help text for the accelerator item \a id to \a
+    text.
+
+    The text will be shown when the application is in What's This mode
+    and the user hits the accelerator key.
+
+    To set What's This help on a menu item (with or without an
+    accelerator key), use TQMenuData::setWhatsThis().
+
+    \sa whatsThis(), TQWhatsThis::inWhatsThisMode(),
+    TQMenuData::setWhatsThis(), TQAction::setWhatsThis()
+*/
+void TQAccel::setWhatsThis( int id, const TQString& text )
+{
+
+    TQAccelItem *item = tqfind_id( d->aitems, id);
+    if ( item )
+	item->whatsthis = text;
+}
+
+/*!
+    Returns the What's This help text for the specified item \a id or
+    TQString::null if no text has been specified.
+
+    \sa setWhatsThis()
+*/
+TQString TQAccel::whatsThis( int id ) const
+{
+
+    TQAccelItem *item = tqfind_id( d->aitems, id);
+    return item? item->whatsthis : TQString::null;
+}
+
+/*!\internal */
+void TQAccel::setIgnoreWhatsThis( bool b)
+{
+    d->ignorewhatsthis = b;
+}
+
+/*!\internal */
+bool TQAccel::ignoreWhatsThis() const
+{
+    return d->ignorewhatsthis;
+}
+
+
+/*!
+
+\page accelerators.html
+
+\title Standard Accelerator Keys
+
+Applications invariably need to define accelerator keys for actions.
+TQt fully supports accelerators, for example with \l TQAccel::shortcutKey().
+
+Here are Microsoft's recommendations for accelerator keys, with
+comments about the Open Group's recommendations where they exist
+and differ. For most commands, the Open Group either has no advice or
+agrees with Microsoft.
+
+The emboldened letter plus Alt is Microsoft's recommended choice, and
+we recommend supporting it. For an Apply button, for example, we
+recommend TQButton::setText( \link TQWidget::tr() tr \endlink("&amp;Apply") );
+
+If you have conflicting commands (e.g. About and Apply buttons in the
+same dialog), you must decide for yourself.
+
+\list
+\i <b><u>A</u></b>bout
+\i Always on <b><u>T</u></b>op
+\i <b><u>A</u></b>pply
+\i <b><u>B</u></b>ack
+\i <b><u>B</u></b>rowse
+\i <b><u>C</u></b>lose (CDE: Alt+F4; Alt+F4 is "close window" in Windows)
+\i <b><u>C</u></b>opy (CDE: Ctrl+C, Ctrl+Insert)
+\i <b><u>C</u></b>opy Here
+\i Create <b><u>S</u></b>hortcut
+\i Create <b><u>S</u></b>hortcut Here
+\i Cu<b><u>t</u></b>
+\i <b><u>D</u></b>elete
+\i <b><u>E</u></b>dit
+\i <b><u>E</u></b>xit (CDE: E<b><u>x</u></b>it)
+\i <b><u>E</u></b>xplore
+\i <b><u>F</u></b>ile
+\i <b><u>F</u></b>ind
+\i <b><u>H</u></b>elp
+\i Help <b><u>T</u></b>opics
+\i <b><u>H</u></b>ide
+\i <b><u>I</u></b>nsert
+\i Insert <b><u>O</u></b>bject
+\i <b><u>L</u></b>ink Here
+\i Ma<b><u>x</u></b>imize
+\i Mi<b><u>n</u></b>imize
+\i <b><u>M</u></b>ove
+\i <b><u>M</u></b>ove Here
+\i <b><u>N</u></b>ew
+\i <b><u>N</u></b>ext
+\i <b><u>N</u></b>o
+\i <b><u>O</u></b>pen
+\i Open <b><u>W</u></b>ith
+\i Page Set<b><u>u</u></b>p
+\i <b><u>P</u></b>aste
+\i Paste <b><u>L</u></b>ink
+\i Paste <b><u>S</u></b>hortcut
+\i Paste <b><u>S</u></b>pecial
+\i <b><u>P</u></b>ause
+\i <b><u>P</u></b>lay
+\i <b><u>P</u></b>rint
+\i <b><u>P</u></b>rint Here
+\i P<b><u>r</u></b>operties
+\i <b><u>Q</u></b>uick View
+\i <b><u>R</u></b>edo (CDE: Ctrl+Y, Shift+Alt+Backspace)
+\i <b><u>R</u></b>epeat
+\i <b><u>R</u></b>estore
+\i <b><u>R</u></b>esume
+\i <b><u>R</u></b>etry
+\i <b><u>R</u></b>un
+\i <b><u>S</u></b>ave
+\i Save <b><u>A</u></b>s
+\i Select <b><u>A</u></b>ll
+\i Se<b><u>n</u></b>d To
+\i <b><u>S</u></b>how
+\i <b><u>S</u></b>ize
+\i S<b><u>p</u></b>lit
+\i <b><u>S</u></b>top
+\i <b><u>U</u></b>ndo (CDE: Ctrl+Z or Alt+Backspace)
+\i <b><u>V</u></b>iew
+\i <b><u>W</u></b>hat's This?
+\i <b><u>W</u></b>indow
+\i <b><u>Y</u></b>es
+\endlist
+
+There are also a lot of other keys and actions (that use other
+modifier keys than Alt). See the Microsoft and The Open Group
+documentation for details.
+
+The \link http://www.amazon.com/exec/obidos/ASIN/0735605661/trolltech/t
+Microsoft book \endlink has ISBN 0735605661. The corresponding Open Group
+book is very hard to tqfind, rather expensive and we cannot recommend
+it. However, if you really want it, OGPubs@opengroup.org might be able
+to help. Ask them for ISBN 1859121047.
+
+*/
+
+/*! \obsolete  serves no purpose anymore */
+void TQAccel::repairEventFilter() {}
+/*! \obsolete	serves no purpose anymore */
+bool TQAccel::eventFilter( TQObject *, TQEvent * ) { return FALSE; }
+#endif // TQT_NO_ACCEL
+
+#endif // USE_QT4
\ No newline at end of file