Add Qt3 development HEAD version

1 files changed, 2571 insertions, 0 deletions

diff --git a/src/kernel/qevent.cpp b/src/kernel/qevent.cpp
new file mode 100644
index 0000000..c428966
--- /dev/null
+++ b/src/kernel/qevent.cpp
@@ -0,0 +1,2571 @@
+/****************************************************************************
+**
+** Implementation of event classes
+**
+** Created : 931029
+**
+** Copyright (C) 1992-2008 Trolltech ASA.  All rights reserved.
+**
+** This file is part of the kernel module of the Qt 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 Qt 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 [email protected].
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.QPL
+** included in the packaging of this file.  Licensees holding valid Qt
+** Commercial licenses may use this file in accordance with the Qt
+** 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 "qevent.h"
+#include "qcursor.h"
+#include "qapplication.h"
+
+
+/*!
+    \class QEvent qevent.h
+    \brief The QEvent class is the base class of all
+    event classes. Event objects contain event parameters.
+
+    \ingroup events
+    \ingroup environment
+
+    Qt's main event loop (QApplication::exec()) fetches native window
+    system events from the event queue, translates them into QEvents
+    and sends the translated events to QObjects.
+
+    In general, events come from the underlying window system
+    (spontaneous() returns TRUE) but it is also possible to manually
+    send events using QApplication::sendEvent() and
+    QApplication::postEvent() (spontaneous() returns FALSE).
+
+    QObjects receive events by having their QObject::event() function
+    called. The function can be reimplemented in subclasses to
+    customize event handling and add additional event types;
+    QWidget::event() is a notable example. By default, events are
+    dispatched to event handlers like QObject::timerEvent() and
+    QWidget::mouseMoveEvent(). QObject::installEventFilter() allows an
+    object to intercept events destined for another object.
+
+    The basic QEvent contains only an event type parameter.
+    Subclasses of QEvent contain additional parameters that describe
+    the particular event.
+
+    \sa QObject::event() QObject::installEventFilter()
+    QWidget::event() QApplication::sendEvent()
+    QApplication::postEvent() QApplication::processEvents()
+*/
+
+
+/*!
+    \enum Qt::ButtonState
+
+    This enum type describes the state of the mouse and the modifier
+    buttons.
+
+    \value NoButton  used when the button state does not refer to any
+    button (see QMouseEvent::button()).
+    \value LeftButton  set if the left button is pressed, or if this
+    event refers to the left button. (The left button may be
+    the right button on left-handed mice.)
+    \value RightButton  the right button.
+    \value MidButton  the middle button.
+    \value ShiftButton  a Shift key on the keyboard is also pressed.
+    \value ControlButton  a Ctrl key on the keyboard is also pressed.
+    \value AltButton  an Alt key on the keyboard is also pressed.
+    \value MetaButton a Meta key on the keyboard is also pressed.
+    \value Keypad  a keypad button is pressed.
+    \value KeyButtonMask a mask for ShiftButton, ControlButton,
+    AltButton and MetaButton.
+    \value MouseButtonMask a mask for LeftButton, RightButton and MidButton.
+*/
+
+/*!
+    \enum QEvent::Type
+
+    This enum type defines the valid event types in Qt. The event
+    types and the specialized classes for each type are these:
+
+    \value None  Not an event.
+    \value Accessibility  Accessibility information is requested
+    \value Timer  Regular timer events, \l{QTimerEvent}.
+    \value MouseButtonPress  Mouse press, \l{QMouseEvent}.
+    \value MouseButtonRelease  Mouse release, \l{QMouseEvent}.
+    \value MouseButtonDblClick  Mouse press again, \l{QMouseEvent}.
+    \value MouseMove  Mouse move, \l{QMouseEvent}.
+    \value KeyPress  Key press (including Shift, for example), \l{QKeyEvent}.
+    \value KeyRelease  Key release, \l{QKeyEvent}.
+    \value IMStart  The start of input method composition, \l{QIMEvent}.
+    \value IMCompose  Input method composition is taking place, \l{QIMEvent}.
+    \value IMEnd  The end of input method composition, \l{QIMEvent}.
+    \value FocusIn  Widget gains keyboard focus, \l{QFocusEvent}.
+    \value FocusOut  Widget loses keyboard focus, \l{QFocusEvent}.
+    \value Enter  Mouse enters widget's boundaries.
+    \value Leave  Mouse leaves widget's boundaries.
+    \value Paint  Screen update necessary, \l{QPaintEvent}.
+    \value Move  Widget's position changed, \l{QMoveEvent}.
+    \value Resize  Widget's size changed, \l{QResizeEvent}.
+    \value Show  Widget was shown on screen, \l{QShowEvent}.
+    \value Hide  Widget was hidden, \l{QHideEvent}.
+    \value ShowToParent  A child widget has been shown.
+    \value HideToParent  A child widget has been hidden.
+    \value Close  Widget was closed (permanently), \l{QCloseEvent}.
+    \value ShowNormal  Widget should be shown normally (obsolete).
+    \value ShowMaximized  Widget should be shown maximized (obsolete).
+    \value ShowMinimized  Widget should be shown minimized (obsolete).
+    \value ShowFullScreen  Widget should be shown full-screen (obsolete).
+    \value ShowWindowRequest  Widget's window should be shown (obsolete).
+    \value DeferredDelete  The object will be deleted after it has
+    cleaned up.
+    \value Accel  Key press in child for shortcut key handling, \l{QKeyEvent}.
+    \value Wheel  Mouse wheel rolled, \l{QWheelEvent}.
+    \value ContextMenu  Context popup menu, \l{QContextMenuEvent}
+    \value AccelOverride  Key press in child, for overriding shortcut key handling, \l{QKeyEvent}.
+    \value AccelAvailable internal.
+    \value WindowActivate  Window was activated.
+    \value WindowDeactivate  Window was deactivated.
+    \value CaptionChange  Widget's caption changed.
+    \value IconChange  Widget's icon changed.
+    \value ParentFontChange  Font of the parent widget changed.
+    \value ApplicationFontChange  Default application font changed.
+    \value PaletteChange  Palette of the widget changed.
+    \value ParentPaletteChange  Palette of the parent widget changed.
+    \value ApplicationPaletteChange  Default application palette changed.
+    \value Clipboard  Clipboard contents have changed.
+    \value SockAct  Socket activated, used to implement \l{QSocketNotifier}.
+    \value DragEnter  A drag-and-drop enters widget, \l{QDragEnterEvent}.
+    \value DragMove  A drag-and-drop is in progress, \l{QDragMoveEvent}.
+    \value DragLeave  A drag-and-drop leaves widget, \l{QDragLeaveEvent}.
+    \value Drop  A drag-and-drop is completed, \l{QDropEvent}.
+    \value DragResponse  Internal event used by Qt on some platforms.
+    \value ChildInserted  Object gets a child, \l{QChildEvent}.
+    \value ChildRemoved  Object loses a child, \l{QChildEvent}.
+    \value LayoutHint  Widget child has changed layout properties.
+    \value ActivateControl  Internal event used by Qt on some platforms.
+    \value DeactivateControl  Internal event used by Qt on some platforms.
+    \value LanguageChange  The application translation changed, \l{QTranslator}
+    \value LayoutDirectionChange  The direction of layouts changed
+    \value LocaleChange  The system locale changed
+    \value Quit  Reserved.
+    \value Create  Reserved.
+    \value Destroy  Reserved.
+    \value Reparent  Reserved.
+    \value Speech  Reserved for speech input.
+    \value TabletMove  A Wacom Tablet Move Event.
+    \value Style  Internal use only
+    \value TabletPress  A Wacom Tablet Press Event
+    \value TabletRelease  A Wacom Tablet Release Event
+    \value OkRequest  Internal event used by Qt on some platforms.
+    \value HelpRequest  Internal event used by Qt on some platforms.
+    \value IconDrag     Internal event used by Qt on some platforms when proxy icon is dragged.
+    \value WindowStateChange The window's state, i.e. minimized,
+    maximized or full-screen, has changed. See \l{QWidget::windowState()}.
+    \value WindowBlocked The window is modally blocked
+    \value WindowUnblocked The window leaves modal blocking
+
+    \value User  User defined event.
+    \value MaxUser  Last user event id.
+
+    User events should have values between User and MaxUser inclusive.
+*/
+/*!
+    \fn QEvent::QEvent( Type type )
+
+    Contructs an event object of type \a type.
+*/
+
+/*!
+    \fn QEvent::Type QEvent::type() const
+
+    Returns the event type.
+*/
+
+/*!
+    \fn bool QEvent::spontaneous() const
+
+    Returns TRUE if the event originated outside the application, i.e.
+    it is a system event; otherwise returns FALSE.
+*/
+
+
+/*!
+    \class QTimerEvent qevent.h
+    \brief The QTimerEvent class contains parameters that describe a
+    timer event.
+
+    \ingroup events
+
+    Timer events are sent at regular intervals to objects that have
+    started one or more timers. Each timer has a unique identifier. A
+    timer is started with QObject::startTimer().
+
+    The QTimer class provides a high-level programming interface that
+    uses signals instead of events. It also provides one-shot timers.
+
+    The event handler QObject::timerEvent() receives timer events.
+
+    \sa QTimer, QObject::timerEvent(), QObject::startTimer(),
+    QObject::killTimer(), QObject::killTimers()
+*/
+
+/*!
+    \fn QTimerEvent::QTimerEvent( int timerId )
+
+    Constructs a timer event object with the timer identifier set to
+    \a timerId.
+*/
+
+/*!
+    \fn int QTimerEvent::timerId() const
+
+    Returns the unique timer identifier, which is the same identifier
+    as returned from QObject::startTimer().
+*/
+
+
+/*!
+    \class QMouseEvent qevent.h
+    \ingroup events
+
+    \brief The QMouseEvent class contains parameters that describe a mouse event.
+
+    Mouse events occur when a mouse button is pressed or released
+    inside a widget or when the mouse cursor is moved.
+
+    Mouse move events will occur only when a mouse button is pressed
+    down, unless mouse tracking has been enabled with
+    QWidget::setMouseTracking().
+
+    Qt automatically grabs the mouse when a mouse button is pressed
+    inside a widget; the widget will continue to receive mouse events
+    until the last mouse button is released.
+
+    A mouse event contains a special accept flag that indicates
+    whether the receiver wants the event. You should call
+    QMouseEvent::ignore() if the mouse event is not handled by your
+    widget. A mouse event is propagated up the parent widget chain
+    until a widget accepts it with QMouseEvent::accept() or an event
+    filter consumes it.
+
+    The functions pos(), x() and y() give the cursor position relative
+    to the widget that receives the mouse event. If you move the
+    widget as a result of the mouse event, use the global position
+    returned by globalPos() to avoid a shaking motion.
+
+    The QWidget::setEnabled() function can be used to enable or
+    disable mouse and keyboard events for a widget.
+
+    The event handlers QWidget::mousePressEvent(),
+    QWidget::mouseReleaseEvent(), QWidget::mouseDoubleClickEvent() and
+    QWidget::mouseMoveEvent() receive mouse events.
+
+    \sa QWidget::setMouseTracking(), QWidget::grabMouse(),
+    QCursor::pos()
+*/
+
+/*!
+    \fn QMouseEvent::QMouseEvent( Type type, const QPoint &pos, int button, int state )
+
+    Constructs a mouse event object.
+
+    The \a type parameter must be one of \c QEvent::MouseButtonPress,
+    \c QEvent::MouseButtonRelease, \c QEvent::MouseButtonDblClick or
+    \c QEvent::MouseMove.
+
+    The \a pos parameter specifies the position relative to the
+    receiving widget. \a button specifies the \link Qt::ButtonState
+    button\endlink that caused the event, which should be \c
+    Qt::NoButton (0), if \a type is \c MouseMove. \a state is the
+    \link Qt::ButtonState ButtonState\endlink at the time of the
+    event.
+
+    The globalPos() is initialized to QCursor::pos(), which may not be
+    appropriate. Use the other constructor to specify the global
+    position explicitly.
+*/
+
+QMouseEvent::QMouseEvent( Type type, const QPoint &pos, int button, int state )
+    : QEvent(type), p(pos), b(button),s((ushort)state), accpt(TRUE){
+	g = QCursor::pos();
+}
+
+
+/*!
+    \fn QMouseEvent::QMouseEvent( Type type, const QPoint &pos, const QPoint &globalPos,  int button, int state )
+
+    Constructs a mouse event object.
+
+    The \a type parameter must be \c QEvent::MouseButtonPress, \c
+    QEvent::MouseButtonRelease, \c QEvent::MouseButtonDblClick or \c
+    QEvent::MouseMove.
+
+    The \a pos parameter specifies the position relative to the
+    receiving widget. \a globalPos is the position in absolute
+    coordinates. \a button specifies the \link Qt::ButtonState
+    button\endlink that caused the event, which should be \c
+    Qt::NoButton (0), if \a type is \c MouseMove. \a state is the
+    \link Qt::ButtonState ButtonState\endlink at the time of the
+    event.
+
+*/
+
+/*!
+    \fn const QPoint &QMouseEvent::pos() const
+
+    Returns the position of the mouse pointer relative to the widget
+    that received the event.
+
+    If you move the widget as a result of the mouse event, use the
+    global position returned by globalPos() to avoid a shaking motion.
+
+    \sa x(), y(), globalPos()
+*/
+
+/*!
+    \fn const QPoint &QMouseEvent::globalPos() const
+
+    Returns the global position of the mouse pointer \e{at the time
+    of the event}. This is important on asynchronous window systems
+    like X11. Whenever you move your widgets around in response to
+    mouse events, globalPos() may differ a lot from the current
+    pointer position QCursor::pos(), and from QWidget::mapToGlobal(
+    pos() ).
+
+    \sa globalX(), globalY()
+*/
+
+/*!
+    \fn int QMouseEvent::x() const
+
+    Returns the x-position of the mouse pointer, relative to the
+    widget that received the event.
+
+    \sa y(), pos()
+*/
+
+/*!
+    \fn int QMouseEvent::y() const
+
+    Returns the y-position of the mouse pointer, relative to the
+    widget that received the event.
+
+    \sa x(), pos()
+*/
+
+/*!
+    \fn int QMouseEvent::globalX() const
+
+    Returns the global x-position of the mouse pointer at the time of
+    the event.
+
+    \sa globalY(), globalPos()
+*/
+
+/*!
+    \fn int QMouseEvent::globalY() const
+
+    Returns the global y-position of the mouse pointer at the time of
+    the event.
+
+    \sa globalX(), globalPos()
+*/
+
+/*!
+    \fn ButtonState QMouseEvent::button() const
+
+    Returns the button that caused the event.
+
+    Possible return values are \c LeftButton, \c RightButton, \c
+    MidButton and \c NoButton.
+
+    Note that the returned value is always \c NoButton for mouse move
+    events.
+
+    \sa state() Qt::ButtonState
+*/
+
+
+/*!
+    \fn ButtonState QMouseEvent::state() const
+
+    Returns the button state (a combination of mouse buttons and
+    keyboard modifiers), i.e. what buttons and keys were being pressed
+    immediately before the event was generated.
+
+    This means that if you have a \c QEvent::MouseButtonPress or a \c
+    QEvent::MouseButtonDblClick state() will \e not include the mouse
+    button that's pressed. But once the mouse button has been
+    released, the \c QEvent::MouseButtonRelease event will have the
+    button() that was pressed.
+
+    This value is mainly interesting for \c QEvent::MouseMove; for the
+    other cases, button() is more useful.
+
+    The returned value is \c LeftButton, \c RightButton, \c MidButton,
+    \c ShiftButton, \c ControlButton and \c AltButton OR'ed together.
+
+    \sa button() stateAfter() Qt::ButtonState
+*/
+
+/*!
+    \fn ButtonState QMouseEvent::stateAfter() const
+
+    Returns the state of buttons after the event.
+
+    \sa state() Qt::ButtonState
+*/
+Qt::ButtonState QMouseEvent::stateAfter() const
+{
+    return Qt::ButtonState(state()^button());
+}
+
+
+
+/*!
+    \fn bool QMouseEvent::isAccepted() const
+
+    Returns TRUE if the receiver of the event wants to keep the key;
+    otherwise returns FALSE.
+*/
+
+/*!
+    \fn void QMouseEvent::accept()
+
+    Sets the accept flag of the mouse event object.
+
+    Setting the accept parameter indicates that the receiver of the
+    event wants the mouse event. Unwanted mouse events are sent to the
+    parent widget.
+
+    The accept flag is set by default.
+
+    \sa ignore()
+*/
+
+
+/*!
+    \fn void QMouseEvent::ignore()
+
+    Clears the accept flag parameter of the mouse event object.
+
+    Clearing the accept parameter indicates that the event receiver
+    does not want the mouse event. Unwanted mouse events are sent to
+    the parent widget.
+
+    The accept flag is set by default.
+
+    \sa accept()
+*/
+
+
+/*!
+    \class QWheelEvent qevent.h
+    \brief The QWheelEvent class contains parameters that describe a wheel event.
+
+    \ingroup events
+
+    Wheel events are sent to the widget under the mouse, and if that widget
+    does not handle the event they are sent to the focus widget. The rotation
+    distance is provided by delta(). The functions pos() and globalPos() return
+    the mouse pointer location at the time of the event.
+
+    A wheel event contains a special accept flag that indicates
+    whether the receiver wants the event. You should call
+    QWheelEvent::accept() if you handle the wheel event; otherwise it
+    will be sent to the parent widget.
+
+    The QWidget::setEnable() function can be used to enable or disable
+    mouse and keyboard events for a widget.
+
+    The event handler QWidget::wheelEvent() receives wheel events.
+
+    \sa QMouseEvent, QWidget::grabMouse()
+*/
+
+/*!
+    \fn Orientation QWheelEvent::orientation() const
+
+    Returns the wheel's orientation.
+*/
+
+/*!
+    \fn QWheelEvent::QWheelEvent( const QPoint &pos, int delta, int state, Orientation orient = Vertical );
+
+    Constructs a wheel event object.
+
+    The globalPos() is initialized to QCursor::pos(), i.e. \a pos,
+    which is usually (but not always) right. Use the other constructor
+    if you need to specify the global position explicitly. \a delta
+    contains the rotation distance, \a state holds the keyboard
+    modifier flags at the time of the event and \a orient holds the
+    wheel's orientation.
+
+    \sa pos(), delta(), state()
+*/
+#ifndef QT_NO_WHEELEVENT
+QWheelEvent::QWheelEvent( const QPoint &pos, int delta, int state, Orientation orient )
+    : QEvent(Wheel), p(pos), d(delta), s((ushort)state),
+      accpt(TRUE), o(orient)
+{
+    g = QCursor::pos();
+}
+#endif
+/*!
+    \fn QWheelEvent::QWheelEvent( const QPoint &pos, const QPoint& globalPos, int delta, int state, Orientation orient = Vertical  )
+
+    Constructs a wheel event object. The position when the event
+    occurred is given in \a pos and \a globalPos. \a delta contains
+    the rotation distance, \a state holds the keyboard modifier flags
+    at the time of the event and \a orient holds the wheel's
+    orientation.
+
+    \sa pos(), globalPos(), delta(), state()
+*/
+
+/*!
+    \fn int QWheelEvent::delta() const
+
+    Returns the distance that the wheel is rotated expressed in
+    multiples or divisions of the \e{wheel delta}, which is currently
+    defined to be 120. A positive value indicates that the wheel was
+    rotated forwards away from the user; a negative value indicates
+    that the wheel was rotated backwards toward the user.
+
+    The \e{wheel delta} constant was defined to be 120 by wheel mouse
+    vendors to allow building finer-resolution wheels in the future,
+    including perhaps a freely rotating wheel with no notches. The
+    expectation is that such a device would send more messages per
+    rotation but with a smaller value in each message.
+*/
+
+/*!
+    \fn const QPoint &QWheelEvent::pos() const
+
+    Returns the position of the mouse pointer, relative to the widget
+    that received the event.
+
+    If you move your widgets around in response to mouse
+    events, use globalPos() instead of this function.
+
+    \sa x(), y(), globalPos()
+*/
+
+/*!
+    \fn int QWheelEvent::x() const
+
+    Returns the x-position of the mouse pointer, relative to the
+    widget that received the event.
+
+    \sa y(), pos()
+*/
+
+/*!
+    \fn int QWheelEvent::y() const
+
+    Returns the y-position of the mouse pointer, relative to the
+    widget that received the event.
+
+    \sa x(), pos()
+*/
+
+
+/*!
+    \fn const QPoint &QWheelEvent::globalPos() const
+
+    Returns the global position of the mouse pointer \e{at the time
+    of the event}. This is important on asynchronous window systems
+    such as X11; whenever you move your widgets around in response to
+    mouse events, globalPos() can differ a lot from the current
+    pointer position QCursor::pos().
+
+    \sa globalX(), globalY()
+*/
+
+/*!
+    \fn int QWheelEvent::globalX() const
+
+    Returns the global x-position of the mouse pointer at the time of
+    the event.
+
+    \sa globalY(), globalPos()
+*/
+
+/*!
+    \fn int QWheelEvent::globalY() const
+
+    Returns the global y-position of the mouse pointer at the time of
+    the event.
+
+    \sa globalX(), globalPos()
+*/
+
+
+/*!
+    \fn ButtonState QWheelEvent::state() const
+
+    Returns the keyboard modifier flags of the event.
+
+    The returned value is \c ShiftButton, \c ControlButton, and \c
+    AltButton OR'ed together.
+*/
+
+/*!
+    \fn bool QWheelEvent::isAccepted() const
+
+    Returns TRUE if the receiver of the event handles the wheel event;
+    otherwise returns FALSE.
+*/
+
+/*!
+    \fn void QWheelEvent::accept()
+
+    Sets the accept flag of the wheel event object.
+
+    Setting the accept parameter indicates that the receiver of the
+    event wants the wheel event. Unwanted wheel events are sent to the
+    parent widget.
+
+    The accept flag is set by default.
+
+    \sa ignore()
+*/
+
+/*!
+    \fn void QWheelEvent::ignore()
+
+    Clears the accept flag parameter of the wheel event object.
+
+    Clearing the accept parameter indicates that the event receiver
+    does not want the wheel event. Unwanted wheel events are sent to
+    the parent widget. The accept flag is set by default.
+
+    \sa accept()
+*/
+
+
+/*!
+    \enum Qt::Modifier
+
+    This enum type describes the keyboard modifier keys supported by
+    Qt.
+
+    \value SHIFT the Shift keys provided on all standard keyboards.
+    \value META the Meta keys.
+    \value CTRL the Ctrl keys.
+    \value ALT the normal Alt keys, but not e.g. AltGr.
+    \value MODIFIER_MASK is a mask of Shift, Ctrl, Alt and Meta.
+    \value UNICODE_ACCEL the accelerator is specified as a Unicode code
+    point, not as a Qt Key.
+*/
+
+/*!
+    \class QKeyEvent qevent.h
+    \brief The QKeyEvent class contains describes a key event.
+
+    \ingroup events
+
+    Key events occur when a key is pressed or released when a widget
+    has keyboard input focus.
+
+  A key event contains a special accept flag that indicates whether the
+  receiver wants the key event.  You should call QKeyEvent::ignore() if the
+  key press or release event is not handled by your widget. A key event is
+  propagated up the parent widget chain until a widget accepts it with
+  QKeyEvent::accept() or an event filter consumes it.
+  Key events for multi media keys are ignored by default. You should call
+  QKeyEvent::accept() if your widget handles those events.
+
+    The QWidget::setEnable() function can be used to enable or disable
+    mouse and keyboard events for a widget.
+
+    The event handlers QWidget::keyPressEvent() and
+    QWidget::keyReleaseEvent() receive key events.
+
+    \sa QFocusEvent, QWidget::grabKeyboard()
+*/
+
+/*!
+    \fn QKeyEvent::QKeyEvent( Type type, int key, int ascii, int state,
+			      const QString& text, bool autorep, ushort count )
+
+    Constructs a key event object.
+
+    The \a type parameter must be \c QEvent::KeyPress or \c
+    QEvent::KeyRelease. If \a key is 0 the event is not a result of a
+    known key (e.g. it may be the result of a compose sequence or
+    keyboard macro). \a ascii is the ASCII code of the key that was
+    pressed or released. \a state holds the keyboard modifiers. \a
+    text is the Unicode text that the key generated. If \a autorep is
+    TRUE, isAutoRepeat() will be TRUE. \a count is the number of
+    single keys.
+
+    The accept flag is set to TRUE.
+*/
+
+/*!
+    \fn int QKeyEvent::key() const
+
+    Returns the code of the key that was pressed or released.
+
+    See \l Qt::Key for the list of keyboard codes. These codes are
+    independent of the underlying window system.
+
+    A value of either 0 or Key_unknown means that the event is not
+    the result of a known key (e.g. it may be the result of a compose
+    sequence or a keyboard macro, or due to key event compression).
+
+    Applications should not use the Qt latin 1 keycodes between 128
+    and 255, but should rather use the QKeyEvent::text(). This is
+    mainly for compatibility.
+
+    \sa QWidget::setKeyCompression()
+*/
+
+/*!
+    \fn int QKeyEvent::ascii() const
+
+    Returns the ASCII code of the key that was pressed or released. We
+    recommend using text() instead.
+
+    \sa text()
+*/
+
+/*!
+    \fn QString QKeyEvent::text() const
+
+    Returns the Unicode text that this key generated. The text returned
+    migth be empty, which is the case when pressing or
+    releasing modifying keys as Shift, Control, Alt and Meta. In these
+    cases key() will contain a valid value.
+
+    \sa QWidget::setKeyCompression()
+*/
+
+/*!
+    \fn ButtonState QKeyEvent::state() const
+
+    Returns the keyboard modifier flags that existed immediately
+    before the event occurred.
+
+    The returned value is \c ShiftButton, \c ControlButton, \c AltButton
+    and \c MetaButton OR'ed together.
+
+    \sa stateAfter()
+*/
+
+/*!
+    \fn ButtonState QKeyEvent::stateAfter() const
+
+    Returns the keyboard modifier flags that existed immediately after
+    the event occurred.
+
+    \warning This function cannot be trusted.
+
+    \sa state()
+*/
+//###### We must check with XGetModifierMapping
+Qt::ButtonState QKeyEvent::stateAfter() const
+{
+    if ( key() == Key_Shift )
+	return Qt::ButtonState(state()^ShiftButton);
+    if ( key() == Key_Control )
+	return Qt::ButtonState(state()^ControlButton);
+    if ( key() == Key_Alt )
+	return Qt::ButtonState(state()^AltButton);
+    if ( key() == Key_Meta )
+	return Qt::ButtonState(state()^MetaButton);
+    return state();
+}
+
+/*!
+    \fn bool QKeyEvent::isAccepted() const
+
+    Returns TRUE if the receiver of the event wants to keep the key;
+    otherwise returns FALSE
+*/
+
+/*!
+    \fn void QKeyEvent::accept()
+
+    Sets the accept flag of the key event object.
+
+    Setting the accept parameter indicates that the receiver of the
+    event wants the key event. Unwanted key events are sent to the
+    parent widget.
+
+    The accept flag is set by default.
+
+    \sa ignore()
+*/
+
+/*!
+    \fn bool QKeyEvent::isAutoRepeat() const
+
+    Returns TRUE if this event comes from an auto-repeating key and
+    FALSE if it comes from an initial key press.
+
+    Note that if the event is a multiple-key compressed event that is
+    partly due to auto-repeat, this function could return either TRUE
+    or FALSE indeterminately.
+*/
+
+/*!
+    \fn int QKeyEvent::count() const
+
+    Returns the number of single keys for this event. If text() is not
+    empty, this is simply the length of the string.
+
+    \sa QWidget::setKeyCompression()
+*/
+
+/*!
+    \fn void QKeyEvent::ignore()
+
+    Clears the accept flag parameter of the key event object.
+
+    Clearing the accept parameter indicates that the event receiver
+    does not want the key event. Unwanted key events are sent to the
+    parent widget.
+
+    The accept flag is set by default.
+
+    \sa accept()
+*/
+
+/*!
+    \enum Qt::Key
+
+    The key names used by Qt.
+
+    \value Key_Escape
+    \value Key_Tab
+    \value Key_Backtab
+    \value Key_Backspace
+    \value Key_Return
+    \value Key_Enter
+    \value Key_Insert
+    \value Key_Delete
+    \value Key_Pause
+    \value Key_Print
+    \value Key_SysReq
+    \value Key_Home
+    \value Key_End
+    \value Key_Left
+    \value Key_Up
+    \value Key_Right
+    \value Key_Down
+    \value Key_Prior
+    \value Key_Next
+    \value Key_Shift
+    \value Key_Control
+    \value Key_Meta
+    \value Key_Alt
+    \value Key_CapsLock
+    \value Key_NumLock
+    \value Key_ScrollLock
+    \value Key_Clear
+    \value Key_F1
+    \value Key_F2
+    \value Key_F3
+    \value Key_F4
+    \value Key_F5
+    \value Key_F6
+    \value Key_F7
+    \value Key_F8
+    \value Key_F9
+    \value Key_F10
+    \value Key_F11
+    \value Key_F12
+    \value Key_F13
+    \value Key_F14
+    \value Key_F15
+    \value Key_F16
+    \value Key_F17
+    \value Key_F18
+    \value Key_F19
+    \value Key_F20
+    \value Key_F21
+    \value Key_F22
+    \value Key_F23
+    \value Key_F24
+    \value Key_F25
+    \value Key_F26
+    \value Key_F27
+    \value Key_F28
+    \value Key_F29
+    \value Key_F30
+    \value Key_F31
+    \value Key_F32
+    \value Key_F33
+    \value Key_F34
+    \value Key_F35
+    \value Key_Super_L
+    \value Key_Super_R
+    \value Key_Menu
+    \value Key_Hyper_L
+    \value Key_Hyper_R
+    \value Key_Help
+    \value Key_Space
+    \value Key_Any
+    \value Key_Exclam
+    \value Key_QuoteDbl
+    \value Key_NumberSign
+    \value Key_Dollar
+    \value Key_Percent
+    \value Key_Ampersand
+    \value Key_Apostrophe
+    \value Key_ParenLeft
+    \value Key_ParenRight
+    \value Key_Asterisk
+    \value Key_Plus
+    \value Key_Comma
+    \value Key_Minus
+    \value Key_Period
+    \value Key_Slash
+    \value Key_0
+    \value Key_1
+    \value Key_2
+    \value Key_3
+    \value Key_4
+    \value Key_5
+    \value Key_6
+    \value Key_7
+    \value Key_8
+    \value Key_9
+    \value Key_Colon
+    \value Key_Semicolon
+    \value Key_Less
+    \value Key_Equal
+    \value Key_Greater
+    \value Key_Question
+    \value Key_At
+    \value Key_A
+    \value Key_B
+    \value Key_C
+    \value Key_D
+    \value Key_E
+    \value Key_F
+    \value Key_G
+    \value Key_H
+    \value Key_I
+    \value Key_J
+    \value Key_K
+    \value Key_L
+    \value Key_M
+    \value Key_N
+    \value Key_O
+    \value Key_P
+    \value Key_Q
+    \value Key_R
+    \value Key_S
+    \value Key_T
+    \value Key_U
+    \value Key_V
+    \value Key_W
+    \value Key_X
+    \value Key_Y
+    \value Key_Z
+    \value Key_BracketLeft
+    \value Key_Backslash
+    \value Key_BracketRight
+    \value Key_AsciiCircum
+    \value Key_Underscore
+    \value Key_QuoteLeft
+    \value Key_BraceLeft
+    \value Key_Bar
+    \value Key_BraceRight
+    \value Key_AsciiTilde
+
+    \value Key_nobreakspace
+    \value Key_exclamdown
+    \value Key_cent
+    \value Key_sterling
+    \value Key_currency
+    \value Key_yen
+    \value Key_brokenbar
+    \value Key_section
+    \value Key_diaeresis
+    \value Key_copyright
+    \value Key_ordfeminine
+    \value Key_guillemotleft
+    \value Key_notsign
+    \value Key_hyphen
+    \value Key_registered
+    \value Key_macron
+    \value Key_degree
+    \value Key_plusminus
+    \value Key_twosuperior
+    \value Key_threesuperior
+    \value Key_acute
+    \value Key_mu
+    \value Key_paragraph
+    \value Key_periodcentered
+    \value Key_cedilla
+    \value Key_onesuperior
+    \value Key_masculine
+    \value Key_guillemotright
+    \value Key_onequarter
+    \value Key_onehalf
+    \value Key_threequarters
+    \value Key_questiondown
+    \value Key_Agrave
+    \value Key_Aacute
+    \value Key_Acircumflex
+    \value Key_Atilde
+    \value Key_Adiaeresis
+    \value Key_Aring
+    \value Key_AE
+    \value Key_Ccedilla
+    \value Key_Egrave
+    \value Key_Eacute
+    \value Key_Ecircumflex
+    \value Key_Ediaeresis
+    \value Key_Igrave
+    \value Key_Iacute
+    \value Key_Icircumflex
+    \value Key_Idiaeresis
+    \value Key_ETH
+    \value Key_Ntilde
+    \value Key_Ograve
+    \value Key_Oacute
+    \value Key_Ocircumflex
+    \value Key_Otilde
+    \value Key_Odiaeresis
+    \value Key_multiply
+    \value Key_Ooblique
+    \value Key_Ugrave
+    \value Key_Uacute
+    \value Key_Ucircumflex
+    \value Key_Udiaeresis
+    \value Key_Yacute
+    \value Key_THORN
+    \value Key_ssharp
+    \value Key_agrave
+    \value Key_aacute
+    \value Key_acircumflex
+    \value Key_atilde
+    \value Key_adiaeresis
+    \value Key_aring
+    \value Key_ae
+    \value Key_ccedilla
+    \value Key_egrave
+    \value Key_eacute
+    \value Key_ecircumflex
+    \value Key_ediaeresis
+    \value Key_igrave
+    \value Key_iacute
+    \value Key_icircumflex
+    \value Key_idiaeresis
+    \value Key_eth
+    \value Key_ntilde
+    \value Key_ograve
+    \value Key_oacute
+    \value Key_ocircumflex
+    \value Key_otilde
+    \value Key_odiaeresis
+    \value Key_division
+    \value Key_oslash
+    \value Key_ugrave
+    \value Key_uacute
+    \value Key_ucircumflex
+    \value Key_udiaeresis
+    \value Key_yacute
+    \value Key_thorn
+    \value Key_ydiaeresis
+
+    Multimedia keys
+
+    \value Key_Back
+    \value Key_Forward
+    \value Key_Stop
+    \value Key_Refresh
+
+    \value Key_VolumeDown
+    \value Key_VolumeMute
+    \value Key_VolumeUp
+    \value Key_BassBoost
+    \value Key_BassUp
+    \value Key_BassDown
+    \value Key_TrebleUp
+    \value Key_TrebleDown
+
+    \value Key_MediaPlay
+    \value Key_MediaStop
+    \value Key_MediaPrev
+    \value Key_MediaNext
+    \value Key_MediaRecord
+
+    \value Key_HomePage
+    \value Key_Favorites
+    \value Key_Search
+    \value Key_Standby
+    \value Key_OpenUrl
+
+    \value Key_LaunchMail
+    \value Key_LaunchMedia
+    \value Key_Launch0
+    \value Key_Launch1
+    \value Key_Launch2
+    \value Key_Launch3
+    \value Key_Launch4
+    \value Key_Launch5
+    \value Key_Launch6
+    \value Key_Launch7
+    \value Key_Launch8
+    \value Key_Launch9
+    \value Key_LaunchA
+    \value Key_LaunchB
+    \value Key_LaunchC
+    \value Key_LaunchD
+    \value Key_LaunchE
+    \value Key_LaunchF
+
+    \value Key_MediaLast
+
+    \value Key_unknown
+
+    \value Key_Direction_L internal use only
+    \value Key_Direction_R internal use only
+
+*/
+
+
+/*!
+    \class QFocusEvent qevent.h
+    \brief The QFocusEvent class contains event parameters for widget focus
+    events.
+
+    \ingroup events
+
+    Focus events are sent to widgets when the keyboard input focus
+    changes. Focus events occur due to mouse actions, keypresses (e.g.
+    Tab or Backtab), the window system, popup menus, keyboard
+    shortcuts or other application specific reasons. The reason for a
+    particular focus event is returned by reason() in the appropriate
+    event handler.
+
+    The event handlers QWidget::focusInEvent() and
+    QWidget::focusOutEvent() receive focus events.
+
+    Use setReason() to set the reason for all focus events, and
+    resetReason() to set the reason for all focus events to the reason
+    in force before the last setReason() call.
+
+    \sa QWidget::setFocus(), QWidget::setFocusPolicy()
+*/
+
+/*!
+    \fn QFocusEvent::QFocusEvent( Type type )
+
+    Constructs a focus event object.
+
+    The \a type parameter must be either \c QEvent::FocusIn or \c
+    QEvent::FocusOut.
+*/
+
+
+
+QFocusEvent::Reason QFocusEvent::m_reason = QFocusEvent::Other;
+QFocusEvent::Reason QFocusEvent::prev_reason = QFocusEvent::Other;
+
+
+/*!
+    \enum QFocusEvent::Reason
+
+    This enum specifies why the focus changed.
+
+    \value Mouse  because of a mouse action.
+    \value Tab  because of a Tab press.
+    \value Backtab  because of a Backtab press
+	    (possibly including Shift/Control, e.g. Shift+Tab).
+    \value ActiveWindow  because the window system made this window (in)active.
+    \value Popup  because the application opened/closed a popup that grabbed/released focus.
+    \value Shortcut  because of a keyboard shortcut.
+    \value Other  any other reason, usually application-specific.
+
+    See the \link focus.html keyboard focus overview\endlink for more
+    about focus.
+*/
+
+/*!
+    Returns the reason for this focus event.
+
+    \sa setReason()
+ */
+QFocusEvent::Reason QFocusEvent::reason()
+{
+    return m_reason;
+}
+
+/*!
+    Sets the reason for all future focus events to \a reason.
+
+    \sa reason(), resetReason()
+ */
+void QFocusEvent::setReason( Reason reason )
+{
+    prev_reason = m_reason;
+    m_reason = reason;
+}
+
+/*!
+    Resets the reason for all future focus events to the value before
+    the last setReason() call.
+
+    \sa reason(), setReason()
+ */
+void QFocusEvent::resetReason()
+{
+    m_reason = prev_reason;
+}
+
+/*!
+    \fn bool QFocusEvent::gotFocus() const
+
+    Returns TRUE if the widget received the text input focus;
+    otherwise returns FALSE.
+*/
+
+/*!
+    \fn bool QFocusEvent::lostFocus() const
+
+    Returns TRUE if the widget lost the text input focus; otherwise
+    returns FALSE.
+*/
+
+
+/*!
+    \class QPaintEvent qevent.h
+    \brief The QPaintEvent class contains event parameters for paint events.
+
+    \ingroup events
+
+    Paint events are sent to widgets that need to update themselves,
+    for instance when part of a widget is exposed because a covering
+    widget is moved.
+
+    The event contains a region() that needs to be updated, and a
+    rect() that is the bounding rectangle of that region. Both are
+    provided because many widgets can't make much use of region(), and
+    rect() can be much faster than region().boundingRect(). Painting
+    is clipped to region() during processing of a paint event.
+
+    The erased() function returns TRUE if the region() has been
+    cleared to the widget's background (see
+    QWidget::backgroundMode()), and FALSE if the region's contents are
+    arbitrary.
+
+    \sa QPainter QWidget::update() QWidget::repaint()
+    QWidget::paintEvent() QWidget::backgroundMode() QRegion
+*/
+
+/*!
+    \fn QPaintEvent::QPaintEvent( const QRegion &paintRegion, bool erased=TRUE )
+
+    Constructs a paint event object with the region that should be
+    updated. The region is given by \a paintRegion. If \a erased is
+    TRUE the region will be cleared before repainting.
+*/
+
+/*!
+    \fn QPaintEvent::QPaintEvent( const QRect &paintRect, bool erased=TRUE )
+
+    Constructs a paint event object with the rectangle that should be
+    updated. The region is also given by \a paintRect. If \a erased is
+    TRUE the region will be cleared before repainting.
+*/
+
+/*!
+    \fn QPaintEvent::QPaintEvent( const QRegion &paintRegion, const QRect &paintRect, bool erased=TRUE )
+
+    Constructs a paint event object with the rectangle \a paintRect
+    that should be updated. The region is given by \a paintRegion. If
+    \a erased is TRUE the region will be cleared before repainting.
+*/
+
+/*!
+    \fn const QRect &QPaintEvent::rect() const
+
+    Returns the rectangle that should be updated.
+
+    \sa region(), QPainter::setClipRect()
+*/
+
+/*!
+    \fn const QRegion &QPaintEvent::region() const
+
+    Returns the region that should be updated.
+
+    \sa rect(), QPainter::setClipRegion()
+*/
+
+/*!
+    \fn bool QPaintEvent::erased() const
+
+    Returns TRUE if the paint event region (or rectangle) has been
+    erased with the widget's background; otherwise returns FALSE.
+*/
+
+/*!
+    \class QMoveEvent qevent.h
+    \brief The QMoveEvent class contains event parameters for move events.
+
+    \ingroup events
+
+    Move events are sent to widgets that have been moved to a new position
+    relative to their parent.
+
+    The event handler QWidget::moveEvent() receives move events.
+
+    \sa QWidget::move(), QWidget::setGeometry()
+*/
+
+/*!
+    \fn QMoveEvent::QMoveEvent( const QPoint &pos, const QPoint &oldPos )
+
+    Constructs a move event with the new and old widget positions, \a
+    pos and \a oldPos respectively.
+*/
+
+/*!
+    \fn const QPoint &QMoveEvent::pos() const
+
+    Returns the new position of the widget. This excludes the window
+    frame for top level widgets.
+*/
+
+/*!
+    \fn const QPoint &QMoveEvent::oldPos() const
+
+    Returns the old position of the widget.
+*/
+
+
+/*!
+    \class QResizeEvent qevent.h
+    \brief The QResizeEvent class contains event parameters for resize events.
+
+    \ingroup events
+
+    Resize events are sent to widgets that have been resized.
+
+    The event handler QWidget::resizeEvent() receives resize events.
+
+    \sa QWidget::resize(), QWidget::setGeometry()
+*/
+
+/*!
+    \fn QResizeEvent::QResizeEvent( const QSize &size, const QSize &oldSize )
+
+    Constructs a resize event with the new and old widget sizes, \a
+    size and \a oldSize respectively.
+*/
+
+/*!
+    \fn const QSize &QResizeEvent::size() const
+
+    Returns the new size of the widget, which is the same as
+    QWidget::size().
+*/
+
+/*!
+    \fn const QSize &QResizeEvent::oldSize() const
+
+    Returns the old size of the widget.
+*/
+
+
+/*!
+    \class QCloseEvent qevent.h
+    \brief The QCloseEvent class contains parameters that describe a close event.
+
+    \ingroup events
+
+    Close events are sent to widgets that the user wants to close,
+    usually by choosing "Close" from the window menu, or by clicking
+    the `X' titlebar button. They are also sent when you call
+    QWidget::close() to close a widget programmatically.
+
+    Close events contain a flag that indicates whether the receiver
+    wants the widget to be closed or not. When a widget accepts the
+    close event, it is hidden (and destroyed if it was created with
+    the \c WDestructiveClose flag). If it refuses to accept the close
+    event nothing happens. (Under X11 it is possible that the window
+    manager will forcibly close the window; but at the time of writing
+    we are not aware of any window manager that does this.)
+
+    The application's main widget -- QApplication::mainWidget() --
+    is a special case. When it accepts the close event, Qt leaves the
+    main event loop and the application is immediately terminated
+    (i.e. it returns from the call to QApplication::exec() in the
+    main() function).
+
+    The event handler QWidget::closeEvent() receives close events. The
+    default implementation of this event handler accepts the close
+    event. If you do not want your widget to be hidden, or want some
+    special handing, you should reimplement the event handler.
+
+    The \link simple-application.html#closeEvent closeEvent() in the
+    Application Walkthrough\endlink shows a close event handler that
+    asks whether to save a document before closing.
+
+    If you want the widget to be deleted when it is closed, create it
+    with the \c WDestructiveClose widget flag. This is very useful for
+    independent top-level windows in a multi-window application.
+
+    \l{QObject}s emits the \link QObject::destroyed()
+    destroyed()\endlink signal when they are deleted.
+
+    If the last top-level window is closed, the
+    QApplication::lastWindowClosed() signal is emitted.
+
+    The isAccepted() function returns TRUE if the event's receiver has
+    agreed to close the widget; call accept() to agree to close the
+    widget and call ignore() if the receiver of this event does not
+    want the widget to be closed.
+
+    \sa QWidget::close(), QWidget::hide(), QObject::destroyed(),
+    QApplication::setMainWidget(), QApplication::lastWindowClosed(),
+    QApplication::exec(), QApplication::quit()
+*/
+
+/*!
+    \fn QCloseEvent::QCloseEvent()
+
+    Constructs a close event object with the accept parameter flag set
+    to FALSE.
+
+    \sa accept()
+*/
+
+/*!
+    \fn bool QCloseEvent::isAccepted() const
+
+    Returns TRUE if the receiver of the event has agreed to close the
+    widget; otherwise returns FALSE.
+
+    \sa accept(), ignore()
+*/
+
+/*!
+    \fn void QCloseEvent::accept()
+
+    Sets the accept flag of the close event object.
+
+    Setting the accept flag indicates that the receiver of this event
+    agrees to close the widget.
+
+    The accept flag is \e not set by default.
+
+    If you choose to accept in QWidget::closeEvent(), the widget will
+    be hidden. If the widget's \c WDestructiveClose flag is set, it
+    will also be destroyed.
+
+    \sa ignore(), QWidget::hide()
+*/
+
+/*!
+    \fn void QCloseEvent::ignore()
+
+    Clears the accept flag of the close event object.
+
+    Clearing the accept flag indicates that the receiver of this event
+    does not want the widget to be closed.
+
+    The close event is constructed with the accept flag cleared.
+
+    \sa accept()
+*/
+
+/*!
+   \class QIconDragEvent qevent.h
+   \brief The QIconDragEvent class signals that a main icon drag has begun.
+
+    \ingroup events
+
+    Icon drag events are sent to widgets when the main icon of a window has been dragged away.
+    On Mac OS X this is fired when the proxy icon of a window is dragged off titlebar, in response to
+    this event is is normal to begin using drag and drop.
+*/
+
+/*!
+    \fn QIconDragEvent::QIconDragEvent()
+
+    Constructs an icon drag event object with the accept parameter
+    flag set to FALSE.
+
+    \sa accept()
+*/
+
+/*!
+    \fn bool QIconDragEvent::isAccepted() const
+
+    Returns TRUE if the receiver of the event has started a drag and
+    drop operation; otherwise returns FALSE.
+
+    \sa accept(), ignore()
+*/
+
+/*!
+    \fn void QIconDragEvent::accept()
+
+    Sets the accept flag of the icon drag event object.
+
+    Setting the accept flag indicates that the receiver of this event
+    has started a drag and drop oeration.
+
+    The accept flag is \e not set by default.
+
+    \sa ignore(), QWidget::hide()
+*/
+
+/*!
+    \fn void QIconDragEvent::ignore()
+
+    Clears the accept flag of the icon drag object.
+
+    Clearing the accept flag indicates that the receiver of this event
+    has not handled the icon drag as a result other events can be sent.
+
+    The icon drag event is constructed with the accept flag cleared.
+
+    \sa accept()
+*/
+
+/*!
+    \class QContextMenuEvent qevent.h
+    \brief The QContextMenuEvent class contains parameters that describe a context menu event.
+
+    \ingroup events
+
+    Context menu events are sent to widgets when a user triggers a
+    context menu. What triggers this is platform dependent. For
+    example, on Windows, pressing the menu button or releasing the
+    right mouse button will cause this event to be sent.
+
+    When this event occurs it is customary to show a QPopupMenu with a
+    context menu, if this is relevant to the context.
+
+    Context menu events contain a special accept flag that indicates
+    whether the receiver accepted the event. If the event handler does
+    not accept the event, then whatever triggered the event will be
+    handled as a regular input event if possible.
+
+    \sa QPopupMenu
+*/
+
+/*!
+    \fn QContextMenuEvent::QContextMenuEvent( Reason reason, const QPoint &pos, const QPoint &globalPos, int state )
+
+    Constructs a context menu event object with the accept parameter
+    flag set to FALSE.
+
+    The \a reason parameter must be \c QContextMenuEvent::Mouse or \c
+    QContextMenuEvent::Keyboard.
+
+    The \a pos parameter specifies the mouse position relative to the
+    receiving widget. \a globalPos is the mouse position in absolute
+    coordinates. \a state is the ButtonState at the time of the event.
+*/
+
+
+/*!
+    \fn QContextMenuEvent::QContextMenuEvent( Reason reason, const QPoint &pos, int state )
+
+    Constructs a context menu event object with the accept parameter
+    flag set to FALSE.
+
+    The \a reason parameter must be \c QContextMenuEvent::Mouse or \c
+    QContextMenuEvent::Keyboard.
+
+    The \a pos parameter specifies the mouse position relative to the
+    receiving widget. \a state is the ButtonState at the time of the
+    event.
+
+    The globalPos() is initialized to QCursor::pos(), which may not be
+    appropriate. Use the other constructor to specify the global
+    position explicitly.
+*/
+
+QContextMenuEvent::QContextMenuEvent( Reason reason, const QPoint &pos, int state )
+    : QEvent( ContextMenu ), p( pos ), accpt(TRUE), consum(TRUE),
+    reas( reason ), s((ushort)state)
+{
+    gp = QCursor::pos();
+}
+
+/*!
+    \fn const QPoint &QContextMenuEvent::pos() const
+
+    Returns the position of the mouse pointer relative to the widget
+    that received the event.
+
+    \sa x(), y(), globalPos()
+*/
+
+/*!
+    \fn int QContextMenuEvent::x() const
+
+    Returns the x-position of the mouse pointer, relative to the
+    widget that received the event.
+
+    \sa y(), pos()
+*/
+
+/*!
+    \fn int QContextMenuEvent::y() const
+
+    Returns the y-position of the mouse pointer, relative to the
+    widget that received the event.
+
+    \sa x(), pos()
+*/
+
+/*!
+    \fn const QPoint &QContextMenuEvent::globalPos() const
+
+    Returns the global position of the mouse pointer at the time of
+    the event.
+
+    \sa x(), y(), pos()
+*/
+
+/*!
+    \fn int QContextMenuEvent::globalX() const
+
+    Returns the global x-position of the mouse pointer at the time of
+    the event.
+
+    \sa globalY(), globalPos()
+*/
+
+/*!
+    \fn int QContextMenuEvent::globalY() const
+
+    Returns the global y-position of the mouse pointer at the time of
+    the event.
+
+    \sa globalX(), globalPos()
+*/
+
+/*!
+    \fn ButtonState QContextMenuEvent::state() const
+
+    Returns the button state (a combination of mouse buttons and
+    keyboard modifiers), i.e. what buttons and keys were being
+    pressed immediately before the event was generated.
+
+    The returned value is \c LeftButton, \c RightButton, \c MidButton,
+    \c ShiftButton, \c ControlButton and \c AltButton OR'ed together.
+*/
+
+/*!
+    \fn bool QContextMenuEvent::isConsumed() const
+
+    Returns TRUE (which stops propagation of the event) if the
+    receiver has blocked the event; otherwise returns FALSE.
+
+    \sa accept(), ignore(), consume()
+*/
+
+/*!
+    \fn void QContextMenuEvent::consume()
+
+    Sets the consume flag of the context event object.
+
+    Setting the consume flag indicates that the receiver of this event
+    does not want the event to be propagated further (i.e. not sent to
+    parent classes.)
+
+    The consumed flag is not set by default.
+
+    \sa ignore() accept()
+*/
+
+/*!
+    \fn bool QContextMenuEvent::isAccepted() const
+
+    Returns TRUE if the receiver has processed the event; otherwise
+    returns FALSE.
+
+    \sa accept(), ignore(), consume()
+*/
+
+/*!
+    \fn void QContextMenuEvent::accept()
+
+    Sets the accept flag of the context event object.
+
+    Setting the accept flag indicates that the receiver of this event
+    has processed the event. Processing the event means you did
+    something with it and it will be implicitly consumed.
+
+    The accept flag is not set by default.
+
+    \sa ignore() consume()
+*/
+
+/*!
+    \fn void QContextMenuEvent::ignore()
+
+    Clears the accept flag of the context event object.
+
+    Clearing the accept flag indicates that the receiver of this event
+    does not need to show a context menu. This will implicitly remove
+    the consumed flag as well.
+
+    The accept flag is not set by default.
+
+    \sa accept() consume()
+*/
+
+/*!
+    \enum QContextMenuEvent::Reason
+
+    This enum describes the reason the ContextMenuEvent was sent. The
+    values are:
+
+    \value Mouse The mouse caused the event to be sent. Normally this
+    means the right mouse button was clicked, but this is platform
+    specific.
+
+    \value Keyboard The keyboard caused this event to be sent. On
+    Windows this means the menu button was pressed.
+
+    \value Other The event was sent by some other means (i.e. not by
+    the mouse or keyboard).
+*/
+
+
+/*!
+    \fn QContextMenuEvent::Reason QContextMenuEvent::reason() const
+
+    Returns the reason for this context event.
+*/
+
+
+/*!
+    \class QIMEvent qevent.h
+    \brief The QIMEvent class provides parameters for input method events.
+
+    \ingroup events
+
+    Input method events are sent to widgets when an input method is
+    used to enter text into a widget. Input methods are widely used to
+    enter text in Asian and other complex languages.
+
+    The events are of interest to widgets that accept keyboard input
+    and want to be able to correctly handle complex languages. Text
+    input in such languages is usually a three step process.
+
+    \list 1
+    \i <b>Starting to Compose</b><br>
+    When the user presses the first key on a keyboard an input context
+    is created. This input context will contain a string with the
+    typed characters.
+
+    \i <b>Composing</b><br>
+    With every new key pressed, the input method will try to create a
+    matching string for the text typed so far. While the input context
+    is active, the user can only move the cursor inside the string
+    belonging to this input context.
+
+    \i <b>Completing</b><br>
+    At some point, e.g. when the user presses the Spacebar, they get
+    to this stage, where they can choose from a number of strings that
+    match the text they have typed so far. The user can press Enter to
+    confirm their choice or Escape to cancel the input; in either case
+    the input context will be closed.
+    \endlist
+
+    Note that the particular key presses used for a given input
+    context may differ from those we've mentioned here, i.e. they may
+    not be Spacebar, Enter and Escape.
+
+    These three stages are represented by three different types of
+    events. The IMStartEvent, IMComposeEvent and IMEndEvent. When a
+    new input context is created, an IMStartEvent will be sent to the
+    widget and delivered to the \l QWidget::imStartEvent() function.
+    The widget can then update internal data structures to reflect
+    this.
+
+    After this, an IMComposeEvent will be sent to the widget for
+    every key the user presses. It will contain the current
+    composition string the widget has to show and the current cursor
+    position within the composition string. This string is temporary
+    and can change with every key the user types, so the widget will
+    need to store the state before the composition started (the state
+    it had when it received the IMStartEvent). IMComposeEvents will be
+    delivered to the \l QWidget::imComposeEvent() function.
+
+    Usually, widgets try to mark the part of the text that is part of
+    the current composition in a way that is visible to the user. A
+    commonly used visual cue is to use a dotted underline.
+
+    After the user has selected the final string, an IMEndEvent will
+    be sent to the widget. The event contains the final string the
+    user selected, and could be empty if they canceled the
+    composition. This string should be accepted as the final text the
+    user entered, and the intermediate composition string should be
+    cleared. These events are delivered to \l QWidget::imEndEvent().
+
+    If the user clicks another widget, taking the focus out of the
+    widget where the composition is taking place the IMEndEvent will
+    be sent and the string it holds will be the result of the
+    composition up to that point (which may be an empty string).
+*/
+
+/*!
+    \fn  QIMEvent::QIMEvent( Type type, const QString &text, int cursorPosition )
+
+    Constructs a new QIMEvent with the accept flag set to FALSE. \a
+    type can be one of QEvent::IMStartEvent, QEvent::IMComposeEvent
+    or QEvent::IMEndEvent. \a text contains the current compostion
+    string and \a cursorPosition the current position of the cursor
+    inside \a text.
+*/
+
+/*!
+    \fn const QString &QIMEvent::text() const
+
+    Returns the composition text. This is a null string for an
+    IMStartEvent, and contains the final accepted string (which may be
+    empty) in the IMEndEvent.
+*/
+
+/*!
+    \fn int QIMEvent::cursorPos() const
+
+    Returns the current cursor position inside the composition string.
+    Will return -1 for IMStartEvent and IMEndEvent.
+*/
+
+/*!
+    \fn int QIMEvent::selectionLength() const
+
+    Returns the number of characters in the composition string (
+    starting at cursorPos() ) that should be marked as selected by the
+    input widget receiving the event.
+    Will return 0 for IMStartEvent and IMEndEvent.
+*/
+
+/*!
+    \fn bool QIMEvent::isAccepted() const
+
+    Returns TRUE if the receiver of the event processed the event;
+    otherwise returns FALSE.
+*/
+
+/*!
+    \fn void QIMEvent::accept()
+
+    Sets the accept flag of the input method event object.
+
+    Setting the accept parameter indicates that the receiver of the
+    event processed the input method event.
+
+    The accept flag is not set by default.
+
+    \sa ignore()
+*/
+
+
+/*!
+    \fn void QIMEvent::ignore()
+
+    Clears the accept flag parameter of the input method event object.
+
+    Clearing the accept parameter indicates that the event receiver
+    does not want the input method event.
+
+    The accept flag is cleared by default.
+
+    \sa accept()
+*/
+
+/*!
+    \class QTabletEvent qevent.h
+    \brief The QTabletEvent class contains parameters that describe a Tablet
+    event.
+
+    \ingroup events
+
+    Tablet Events are generated from a Wacom&copy; tablet. Most of
+    the time you will want to deal with events from the tablet as if
+    they were events from a mouse, for example retrieving the position
+    with x(), y(), pos(), globalX(), globalY() and globalPos(). In
+    some situations you may wish to retrieve the extra information
+    provided by the tablet device driver, for example, you might want
+    to adjust color brightness based on pressure. QTabletEvent allows
+    you to get the pressure(), the xTilt() and yTilt(), as well as the
+    type of device being used with device() (see \l{TabletDevice}).
+
+    A tablet event contains a special accept flag that indicates
+    whether the receiver wants the event. You should call
+    QTabletEvent::accept() if you handle the tablet event; otherwise
+    it will be sent to the parent widget.
+
+    The QWidget::setEnabled() function can be used to enable or
+    disable mouse and keyboard events for a widget.
+
+  The event handler QWidget::tabletEvent() receives all three types of tablet
+  events.  Qt will first send a tabletEvent and then, if it is not accepted,
+  it will send a mouse event.  This allows applications that don't utilize
+  tablets to use a tablet like a mouse while also enabling those who want to
+  use both tablets and mouses differently.
+
+*/
+
+/*!
+    \enum QTabletEvent::TabletDevice
+
+    This enum defines what type of device is generating the event.
+
+    \value NoDevice    No device, or an unknown device.
+    \value Puck    A Puck (a device that is similar to a flat mouse with
+    a transparent circle with cross-hairs).
+    \value Stylus  A Stylus (the narrow end of the pen).
+    \value Eraser  An Eraser (the broad end of the pen).
+    \omit
+    \value Menu  A menu button was pressed (currently unimplemented).
+*/
+
+/*!
+  \fn QTabletEvent::QTabletEvent( Type t, const QPoint &pos,
+                                  const QPoint &globalPos, int device,
+                                  int pressure, int xTilt, int yTilt,
+				  const QPair<int,int> &uId )
+  Construct a tablet event of type \a t.  The position of when the event occurred is given
+  int \a pos and \a globalPos.  \a device contains the \link TabletDevice device type\endlink,
+  \a pressure contains the pressure exerted on the \a device, \a xTilt and \a yTilt contain
+  \a device's degree of tilt from the X and Y axis respectively.  The \a uId contains an
+  event id.
+
+  On Irix, \a globalPos will contain the high-resolution coordinates received from the
+  tablet device driver, instead of from the windowing system.
+
+  \sa pos(), globalPos(), device(), pressure(), xTilt(), yTilt()
+*/
+
+QTabletEvent::QTabletEvent( Type t, const QPoint &pos, const QPoint &globalPos, int device,
+			    int pressure, int xTilt, int yTilt,
+			    const QPair<int, int> &uId )
+    : QEvent( t ),
+      mPos( pos ),
+      mGPos( globalPos ),
+      mDev( device ),
+      mPress( pressure ),
+      mXT( xTilt ),
+      mYT( yTilt ),
+      mType( uId.first ),
+      mPhy( uId.second ),
+      mbAcc(TRUE)
+{}
+
+/*!
+  \obsolete
+  \fn QTabletEvent::QTabletEvent( const QPoint &pos, const QPoint &globalPos, int device, int pressure, int xTilt, int yTilt, const QPair<int,int> &uId )
+
+    Constructs a tablet event object. The position when the event
+    occurred is is given in \a pos and \a globalPos. \a device
+    contains the \link TabletDevice device type\endlink, \a pressure
+    contains the pressure exerted on the \a device, \a xTilt and \a
+    yTilt contain the \a device's degrees of tilt from the X and Y
+    axis respectively. The \a uId contains an event id.
+
+    On Irix, \a globalPos will contain the high-resolution coordinates
+    received from the tablet device driver, instead of from the
+    windowing system.
+
+  \sa pos(), globalPos(), device(), pressure(), xTilt(), yTilt()
+*/
+
+/*!
+    \fn TabletDevices QTabletEvent::device() const
+
+    Returns the type of device that generated the event. Useful if you
+    want one end of the pen to do something different than the other.
+
+    \sa TabletDevice
+*/
+
+/*!
+    \fn int QTabletEvent::pressure() const
+
+    Returns the pressure that is exerted on the device. This number is
+    a value from 0 (no pressure) to 255 (maximum pressure). The
+    pressure is always scaled to be within this range no matter how
+    many pressure levels the underlying hardware supports.
+*/
+
+/*!
+    \fn int QTabletEvent::xTilt() const
+
+    Returns the difference from the perpendicular in the X Axis.
+    Positive values are towards the tablet's physical right. The angle
+    is in the range -60 to +60 degrees.
+
+    \sa yTilt()
+*/
+
+/*!
+    \fn int QTabletEvent::yTilt() const
+
+    Returns the difference from the perpendicular in the Y Axis.
+    Positive values are towards the bottom of the tablet. The angle is
+    within the range -60 to +60 degrees.
+
+    \sa xTilt()
+*/
+
+/*!
+    \fn const QPoint &QTabletEvent::pos() const
+
+    Returns the position of the device, relative to the widget that
+    received the event.
+
+    If you move widgets around in response to mouse events, use
+    globalPos() instead of this function.
+
+    \sa x(), y(), globalPos()
+*/
+
+/*!
+    \fn int QTabletEvent::x() const
+
+    Returns the x-position of the device, relative to the widget that
+    received the event.
+
+    \sa y(), pos()
+*/
+
+/*!
+    \fn int QTabletEvent::y() const
+
+    Returns the y-position of the device, relative to the widget that
+    received the event.
+
+    \sa x(), pos()
+*/
+
+/*!
+    \fn const QPoint &QTabletEvent::globalPos() const
+
+    Returns the global position of the device \e{at the time of the
+    event}. This is important on asynchronous windows systems like X11;
+    whenever you move your widgets around in response to mouse events,
+    globalPos() can differ significantly from the current position
+    QCursor::pos().
+
+    \sa globalX(), globalY()
+*/
+
+/*!
+    \fn int QTabletEvent::globalX() const
+
+    Returns the global x-position of the mouse pointer at the time of
+    the event.
+
+    \sa globalY(), globalPos()
+*/
+
+/*!
+    \fn int QTabletEvent::globalY() const
+
+    Returns the global y-position of the mouse pointer at the time of
+    the event.
+
+    \sa globalX(), globalPos()
+*/
+
+/*!
+    \fn bool QTabletEvent::isAccepted() const
+
+    Returns TRUE if the receiver of the event handles the tablet
+    event; otherwise returns FALSE.
+*/
+
+/*!
+    \fn void QTabletEvent::accept()
+
+    Sets the accept flag of the tablet event object.
+
+    Setting the accept flag indicates that the receiver of the event
+    wants the tablet event. Unwanted tablet events are sent to the
+    parent widget.
+
+    The accept flag is set by default.
+
+    \sa ignore()
+*/
+
+/*!
+    \fn void QTabletEvent::ignore()
+
+    Clears the accept flag parameter of the tablet event object.
+
+    Clearing the accept flag indicates that the event receiver does
+    not want the tablet event. Unwanted tablet events are sent to the
+    parent widget.
+
+    The accept flag is set by default.
+
+    \sa accept()
+*/
+
+/*!
+    \fn QPair<int, int> QTabletEvent::uniqueId()
+
+    Returns a unique ID for the current device. It is possible to
+    generate a unique ID for any Wacom&copy; device. This makes it
+    possible to differentiate between multiple devices being used at
+    the same time on the tablet. The \c first member contains a value
+    for the type, the \c second member contains a physical ID obtained
+    from the device. Each combination of these values is unique. Note:
+    for different platforms, the \c first value is different due to
+    different driver implementations.
+*/
+
+/*!
+    \class QChildEvent qevent.h
+    \brief The QChildEvent class contains event parameters for child object
+    events.
+
+    \ingroup events
+
+    Child events are sent to objects when children are inserted or
+    removed.
+
+    A \c ChildRemoved event is sent immediately, but a \c
+    ChildInserted event is \e posted (with QApplication::postEvent()).
+
+    Note that if a child is removed immediately after it is inserted,
+    the \c ChildInserted event may be suppressed, but the \c
+    ChildRemoved event will always be sent. In this case there will be
+    a \c ChildRemoved event without a corresponding \c ChildInserted
+    event.
+
+    The handler for these events is QObject::childEvent().
+*/
+
+/*!
+    \fn QChildEvent::QChildEvent( Type type, QObject *child )
+
+    Constructs a child event object. The \a child is the object that
+    is to be removed or inserted.
+
+    The \a type parameter must be either \c QEvent::ChildInserted or
+    \c QEvent::ChildRemoved.
+*/
+
+/*!
+    \fn QObject *QChildEvent::child() const
+
+    Returns the child widget that was inserted or removed.
+*/
+
+/*!
+    \fn bool QChildEvent::inserted() const
+
+    Returns TRUE if the widget received a new child; otherwise returns
+    FALSE.
+*/
+
+/*!
+    \fn bool QChildEvent::removed() const
+
+    Returns TRUE if the object lost a child; otherwise returns FALSE.
+*/
+
+
+
+
+/*!
+    \class QCustomEvent qevent.h
+    \brief The QCustomEvent class provides support for custom events.
+
+    \ingroup events
+
+    QCustomEvent is a generic event class for user-defined events.
+    User defined events can be sent to widgets or other QObject
+    instances using QApplication::postEvent() or
+    QApplication::sendEvent(). Subclasses of QObject can easily
+    receive custom events by implementing the QObject::customEvent()
+    event handler function.
+
+    QCustomEvent objects should be created with a type ID that
+    uniquely identifies the event type. To avoid clashes with the
+    Qt-defined events types, the value should be at least as large as
+    the value of the "User" entry in the QEvent::Type enum.
+
+    QCustomEvent contains a generic void* data member that may be used
+    for transferring event-specific data to the receiver. Note that
+    since events are normally delivered asynchronously, the data
+    pointer, if used, must remain valid until the event has been
+    received and processed.
+
+    QCustomEvent can be used as-is for simple user-defined event
+    types, but normally you will want to make a subclass of it for
+    your event types. In a subclass, you can add data members that are
+    suitable for your event type.
+
+    Example:
+    \code
+    class ColorChangeEvent : public QCustomEvent
+    {
+    public:
+	ColorChangeEvent( QColor color )
+	    : QCustomEvent( 65432 ), c( color ) {}
+	QColor color() const { return c; }
+    private:
+	QColor c;
+    };
+
+    // To send an event of this custom event type:
+
+    ColorChangeEvent* ce = new ColorChangeEvent( blue );
+    QApplication::postEvent( receiver, ce );  // Qt will delete it when done
+
+    // To receive an event of this custom event type:
+
+    void MyWidget::customEvent( QCustomEvent * e )
+    {
+	if ( e->type() == 65432 ) {  // It must be a ColorChangeEvent
+	    ColorChangeEvent* ce = (ColorChangeEvent*)e;
+	    newColor = ce->color();
+	}
+    }
+    \endcode
+
+    \sa QWidget::customEvent(), QApplication::notify()
+*/
+
+
+/*!
+    Constructs a custom event object with event type \a type. The
+    value of \a type must be at least as large as QEvent::User. The
+    data pointer is set to 0.
+*/
+
+QCustomEvent::QCustomEvent( int type )
+    : QEvent( (QEvent::Type)type ), d( 0 )
+{
+}
+
+
+/*!
+    \fn QCustomEvent::QCustomEvent( Type type, void *data )
+
+    Constructs a custom event object with the event type \a type and a
+    pointer to \a data. (Note that any int value may safely be cast to
+    QEvent::Type).
+*/
+
+
+/*!
+    \fn void QCustomEvent::setData( void* data )
+
+    Sets the generic data pointer to \a data.
+
+    \sa data()
+*/
+
+/*!
+    \fn void *QCustomEvent::data() const
+
+    Returns a pointer to the generic event data.
+
+    \sa setData()
+*/
+
+
+
+/*!
+    \fn QDragMoveEvent::QDragMoveEvent( const QPoint& pos, Type type )
+
+    Creates a QDragMoveEvent for which the mouse is at point \a pos,
+    and the event is of type \a type.
+
+    \warning Do not create a QDragMoveEvent yourself since these
+    objects rely on Qt's internal state.
+*/
+
+/*!
+    \fn void QDragMoveEvent::accept( const QRect & r )
+
+    The same as accept(), but also notifies that future moves will
+    also be acceptable if they remain within the rectangle \a r on the
+    widget: this can improve performance, but may also be ignored by
+    the underlying system.
+
+    If the rectangle is \link QRect::isEmpty() empty\endlink, then
+    drag move events will be sent continuously. This is useful if the
+    source is scrolling in a timer event.
+*/
+
+/*!
+    \fn void QDragMoveEvent::ignore( const QRect & r)
+
+    The opposite of accept(const QRect&), i.e. says that moves within
+    rectangle \a r are not acceptable (will be ignored).
+*/
+
+/*!
+    \fn QRect QDragMoveEvent::answerRect() const
+
+    Returns the rectangle for which the acceptance of the move event
+    applies.
+*/
+
+
+
+/*!
+    \fn const QPoint& QDropEvent::pos() const
+
+    Returns the position where the drop was made.
+*/
+
+/*!
+    \fn bool QDropEvent::isAccepted () const
+
+    Returns TRUE if the drop target accepts the event; otherwise
+    returns FALSE.
+*/
+
+/*!
+    \fn void QDropEvent::accept(bool y=TRUE)
+
+    Call this function to indicate whether the event provided data
+    which your widget processed. Set \a y to TRUE (the default) if
+    your widget could process the data, otherwise set \a y to FALSE.
+    To get the data, use encodedData(), or preferably, the decode()
+    methods of existing QDragObject subclasses, such as
+    QTextDrag::decode(), or your own subclasses.
+
+    \sa acceptAction()
+*/
+
+/*!
+    \fn void QDropEvent::acceptAction(bool y=TRUE)
+
+    Call this to indicate that the action described by action() is
+    accepted (i.e. if \a y is TRUE, which is the default), not merely
+    the default copy action. If you call acceptAction(TRUE), there is
+    no need to also call accept(TRUE).
+*/
+
+/*!
+  \fn void QDragMoveEvent::accept( bool y )
+  \reimp
+  \internal
+  Remove in 3.0
+*/
+
+/*!
+  \fn void QDragMoveEvent::ignore()
+  \reimp
+  \internal
+  Remove in 3.0
+*/
+
+
+/*!
+    \enum QDropEvent::Action
+
+    This enum describes the action which a source requests that a
+    target perform with dropped data.
+
+    \value Copy The default action. The source simply uses the data
+		provided in the operation.
+    \value Link The source should somehow create a link to the
+		location specified by the data.
+    \value Move The source should somehow move the object from the
+		location specified by the data to a new location.
+    \value Private  The target has special knowledge of the MIME type,
+		which the source should respond to in a similar way to
+		a Copy.
+    \value UserAction  The source and target can co-operate using
+		special actions. This feature is not currently
+		supported.
+
+    The Link and Move actions only makes sense if the data is a
+    reference, for example, text/uri-list file lists (see QUriDrag).
+*/
+
+/*!
+    \fn void QDropEvent::setAction( Action a )
+
+    Sets the action to \a a. This is used internally, you should not
+    need to call this in your code: the \e source decides the action,
+    not the target.
+*/
+
+/*!
+    \fn Action QDropEvent::action() const
+
+    Returns the Action which the target is requesting to be performed
+    with the data. If your application understands the action and can
+    process the supplied data, call acceptAction(); if your
+    application can process the supplied data but can only perform the
+    Copy action, call accept().
+*/
+
+/*!
+    \fn void QDropEvent::ignore()
+
+    The opposite of accept(), i.e. you have ignored the drop event.
+*/
+
+/*!
+    \fn bool QDropEvent::isActionAccepted () const
+
+    Returns TRUE if the drop action was accepted by the drop site;
+    otherwise returns FALSE.
+*/
+
+
+/*!
+    \fn void QDropEvent::setPoint (const QPoint & np)
+
+    Sets the drop to happen at point \a np. You do not normally need
+    to use this as it will be set internally before your widget
+    receives the drop event.
+*/ // ### here too - what coordinate system?
+
+
+/*!
+    \class QDragEnterEvent qevent.h
+    \brief The QDragEnterEvent class provides an event which is sent to the widget when a drag and drop first drags onto the widget.
+
+    \ingroup events
+    \ingroup draganddrop
+
+    This event is always immediately followed by a QDragMoveEvent, so
+    you only need to respond to one or the other event. This class
+    inherits most of its functionality from QDragMoveEvent, which in
+    turn inherits most of its functionality from QDropEvent.
+
+    \sa QDragLeaveEvent, QDragMoveEvent, QDropEvent
+*/
+
+/*!
+    \fn QDragEnterEvent::QDragEnterEvent (const QPoint & pos)
+
+    Constructs a QDragEnterEvent entering at the given point, \a pos.
+
+    \warning Do not create a QDragEnterEvent yourself since these
+    objects rely on Qt's internal state.
+*/
+
+/*!
+    \class QDragLeaveEvent qevent.h
+    \brief The QDragLeaveEvent class provides an event which is sent to the widget when a drag and drop leaves the widget.
+
+    \ingroup events
+    \ingroup draganddrop
+
+    This event is always preceded by a QDragEnterEvent and a series of
+    \l{QDragMoveEvent}s. It is not sent if a QDropEvent is sent
+    instead.
+
+    \sa QDragEnterEvent, QDragMoveEvent, QDropEvent
+*/
+
+/*!
+    \fn QDragLeaveEvent::QDragLeaveEvent()
+
+    Constructs a QDragLeaveEvent.
+
+    \warning Do not create a QDragLeaveEvent yourself since these
+    objects rely on Qt's internal state.
+*/
+
+/*!
+    \class QHideEvent qevent.h
+    \brief The QHideEvent class provides an event which is sent after a widget is hidden.
+
+    \ingroup events
+
+    This event is sent just before QWidget::hide() returns, and also
+    when a top-level window has been hidden (iconified) by the user.
+
+    If spontaneous() is TRUE the event originated outside the
+    application, i.e. the user hid the window using the window manager
+    controls, either by iconifying the window or by switching to
+    another virtual desktop where the window isn't visible. The window
+    will become hidden but not withdrawn. If the window was iconified,
+    QWidget::isMinimized() returns TRUE.
+
+    \sa QShowEvent
+*/
+
+/*!
+    \fn QHideEvent::QHideEvent()
+
+    Constructs a QHideEvent.
+*/
+
+/*!
+    \class QShowEvent qevent.h
+    \brief The QShowEvent class provides an event which is sent when a widget is shown.
+
+    \ingroup events
+
+    There are two kinds of show events: show events caused by the
+    window system (spontaneous) and internal show events. Spontaneous
+    show events are sent just after the window system shows the
+    window, including after a top-level window has been shown
+    (un-iconified) by the user. Internal show events are delivered
+    just before the widget becomes visible.
+
+    \sa QHideEvent
+*/
+
+/*!
+    \fn QShowEvent::QShowEvent()
+
+    Constructs a QShowEvent.
+*/
+
+
+/*!
+  \fn QByteArray QDropEvent::data(const char* f) const
+
+  \obsolete
+
+  Use QDropEvent::encodedData().
+*/
+
+
+/*!
+  Destroys the event. If it was \link
+  QApplication::postEvent() posted \endlink,
+  it will be removed from the list of events to be posted.
+*/
+
+QEvent::~QEvent()
+{
+    if ( posted && qApp )
+	QApplication::removePostedEvent( this );
+}