diff options
Diffstat (limited to 'src/kernel/qevent.cpp')
| -rw-r--r-- | src/kernel/qevent.cpp | 2571 |
1 files changed, 2571 insertions, 0 deletions
diff --git a/src/kernel/qevent.cpp b/src/kernel/qevent.cpp new file mode 100644 index 000000000..6881c806a --- /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 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 retquirements 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 "qevent.h" +#include "qcursor.h" +#include "qapplication.h" + + +/*! + \class TQEvent qevent.h + \brief The TQEvent class is the base class of all + event classes. Event objects contain event parameters. + + \ingroup events + \ingroup environment + + TQt's main event loop (TQApplication::exec()) fetches native window + system events from the event queue, translates them into TQEvents + and sends the translated events to TQObjects. + + In general, events come from the underlying window system + (spontaneous() returns TRUE) but it is also possible to manually + send events using TQApplication::sendEvent() and + TQApplication::postEvent() (spontaneous() returns FALSE). + + TQObjects receive events by having their TQObject::event() function + called. The function can be reimplemented in subclasses to + customize event handling and add additional event types; + TQWidget::event() is a notable example. By default, events are + dispatched to event handlers like TQObject::timerEvent() and + TQWidget::mouseMoveEvent(). TQObject::installEventFilter() allows an + object to intercept events destined for another object. + + The basic TQEvent contains only an event type parameter. + Subclasses of TQEvent contain additional parameters that describe + the particular event. + + \sa TQObject::event() TQObject::installEventFilter() + TQWidget::event() TQApplication::sendEvent() + TQApplication::postEvent() TQApplication::processEvents() +*/ + + +/*! + \enum TQt::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 TQMouseEvent::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 TQEvent::Type + + This enum type defines the valid event types in TQt. 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{TQTimerEvent}. + \value MouseButtonPress Mouse press, \l{TQMouseEvent}. + \value MouseButtonRelease Mouse release, \l{TQMouseEvent}. + \value MouseButtonDblClick Mouse press again, \l{TQMouseEvent}. + \value MouseMove Mouse move, \l{TQMouseEvent}. + \value KeyPress Key press (including Shift, for example), \l{TQKeyEvent}. + \value KeyRelease Key release, \l{TQKeyEvent}. + \value IMStart The start of input method composition, \l{TQIMEvent}. + \value IMCompose Input method composition is taking place, \l{TQIMEvent}. + \value IMEnd The end of input method composition, \l{TQIMEvent}. + \value FocusIn Widget gains keyboard focus, \l{TQFocusEvent}. + \value FocusOut Widget loses keyboard focus, \l{TQFocusEvent}. + \value Enter Mouse enters widget's boundaries. + \value Leave Mouse leaves widget's boundaries. + \value Paint Screen update necessary, \l{TQPaintEvent}. + \value Move Widget's position changed, \l{TQMoveEvent}. + \value Resize Widget's size changed, \l{TQResizeEvent}. + \value Show Widget was shown on screen, \l{TQShowEvent}. + \value Hide Widget was hidden, \l{TQHideEvent}. + \value ShowToParent A child widget has been shown. + \value HideToParent A child widget has been hidden. + \value Close Widget was closed (permanently), \l{TQCloseEvent}. + \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{TQKeyEvent}. + \value Wheel Mouse wheel rolled, \l{TQWheelEvent}. + \value ContextMenu Context popup menu, \l{TQContextMenuEvent} + \value AccelOverride Key press in child, for overriding shortcut key handling, \l{TQKeyEvent}. + \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{TQSocketNotifier}. + \value DragEnter A drag-and-drop enters widget, \l{TQDragEnterEvent}. + \value DragMove A drag-and-drop is in progress, \l{TQDragMoveEvent}. + \value DragLeave A drag-and-drop leaves widget, \l{TQDragLeaveEvent}. + \value Drop A drag-and-drop is completed, \l{TQDropEvent}. + \value DragResponse Internal event used by TQt on some platforms. + \value ChildInserted Object gets a child, \l{TQChildEvent}. + \value ChildRemoved Object loses a child, \l{TQChildEvent}. + \value LayoutHint Widget child has changed layout properties. + \value ActivateControl Internal event used by TQt on some platforms. + \value DeactivateControl Internal event used by TQt on some platforms. + \value LanguageChange The application translation changed, \l{TQTranslator} + \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 TQt on some platforms. + \value HelpRequest Internal event used by TQt on some platforms. + \value IconDrag Internal event used by TQt 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{TQWidget::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 TQEvent::TQEvent( Type type ) + + Contructs an event object of type \a type. +*/ + +/*! + \fn TQEvent::Type TQEvent::type() const + + Returns the event type. +*/ + +/*! + \fn bool TQEvent::spontaneous() const + + Returns TRUE if the event originated outside the application, i.e. + it is a system event; otherwise returns FALSE. +*/ + + +/*! + \class TQTimerEvent qevent.h + \brief The TQTimerEvent 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 TQObject::startTimer(). + + The TQTimer class provides a high-level programming interface that + uses signals instead of events. It also provides one-shot timers. + + The event handler TQObject::timerEvent() receives timer events. + + \sa TQTimer, TQObject::timerEvent(), TQObject::startTimer(), + TQObject::killTimer(), TQObject::killTimers() +*/ + +/*! + \fn TQTimerEvent::TQTimerEvent( int timerId ) + + Constructs a timer event object with the timer identifier set to + \a timerId. +*/ + +/*! + \fn int TQTimerEvent::timerId() const + + Returns the unique timer identifier, which is the same identifier + as returned from TQObject::startTimer(). +*/ + + +/*! + \class TQMouseEvent qevent.h + \ingroup events + + \brief The TQMouseEvent 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 + TQWidget::setMouseTracking(). + + TQt 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 + TQMouseEvent::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 TQMouseEvent::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 TQWidget::setEnabled() function can be used to enable or + disable mouse and keyboard events for a widget. + + The event handlers TQWidget::mousePressEvent(), + TQWidget::mouseReleaseEvent(), TQWidget::mouseDoubleClickEvent() and + TQWidget::mouseMoveEvent() receive mouse events. + + \sa TQWidget::setMouseTracking(), TQWidget::grabMouse(), + TQCursor::pos() +*/ + +/*! + \fn TQMouseEvent::TQMouseEvent( Type type, const TQPoint &pos, int button, int state ) + + Constructs a mouse event object. + + The \a type parameter must be one of \c TQEvent::MouseButtonPress, + \c TQEvent::MouseButtonRelease, \c TQEvent::MouseButtonDblClick or + \c TQEvent::MouseMove. + + The \a pos parameter specifies the position relative to the + receiving widget. \a button specifies the \link TQt::ButtonState + button\endlink that caused the event, which should be \c + TQt::NoButton (0), if \a type is \c MouseMove. \a state is the + \link TQt::ButtonState ButtonState\endlink at the time of the + event. + + The globalPos() is initialized to TQCursor::pos(), which may not be + appropriate. Use the other constructor to specify the global + position explicitly. +*/ + +TQMouseEvent::TQMouseEvent( Type type, const TQPoint &pos, int button, int state ) + : TQEvent(type), p(pos), b(button),s((ushort)state), accpt(TRUE){ + g = TQCursor::pos(); +} + + +/*! + \fn TQMouseEvent::TQMouseEvent( Type type, const TQPoint &pos, const TQPoint &globalPos, int button, int state ) + + Constructs a mouse event object. + + The \a type parameter must be \c TQEvent::MouseButtonPress, \c + TQEvent::MouseButtonRelease, \c TQEvent::MouseButtonDblClick or \c + TQEvent::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 TQt::ButtonState + button\endlink that caused the event, which should be \c + TQt::NoButton (0), if \a type is \c MouseMove. \a state is the + \link TQt::ButtonState ButtonState\endlink at the time of the + event. + +*/ + +/*! + \fn const TQPoint &TQMouseEvent::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 TQPoint &TQMouseEvent::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 TQCursor::pos(), and from TQWidget::mapToGlobal( + pos() ). + + \sa globalX(), globalY() +*/ + +/*! + \fn int TQMouseEvent::x() const + + Returns the x-position of the mouse pointer, relative to the + widget that received the event. + + \sa y(), pos() +*/ + +/*! + \fn int TQMouseEvent::y() const + + Returns the y-position of the mouse pointer, relative to the + widget that received the event. + + \sa x(), pos() +*/ + +/*! + \fn int TQMouseEvent::globalX() const + + Returns the global x-position of the mouse pointer at the time of + the event. + + \sa globalY(), globalPos() +*/ + +/*! + \fn int TQMouseEvent::globalY() const + + Returns the global y-position of the mouse pointer at the time of + the event. + + \sa globalX(), globalPos() +*/ + +/*! + \fn ButtonState TQMouseEvent::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() TQt::ButtonState +*/ + + +/*! + \fn ButtonState TQMouseEvent::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 TQEvent::MouseButtonPress or a \c + TQEvent::MouseButtonDblClick state() will \e not include the mouse + button that's pressed. But once the mouse button has been + released, the \c TQEvent::MouseButtonRelease event will have the + button() that was pressed. + + This value is mainly interesting for \c TQEvent::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() TQt::ButtonState +*/ + +/*! + \fn ButtonState TQMouseEvent::stateAfter() const + + Returns the state of buttons after the event. + + \sa state() TQt::ButtonState +*/ +TQt::ButtonState TQMouseEvent::stateAfter() const +{ + return TQt::ButtonState(state()^button()); +} + + + +/*! + \fn bool TQMouseEvent::isAccepted() const + + Returns TRUE if the receiver of the event wants to keep the key; + otherwise returns FALSE. +*/ + +/*! + \fn void TQMouseEvent::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 TQMouseEvent::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 TQWheelEvent qevent.h + \brief The TQWheelEvent 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 + TQWheelEvent::accept() if you handle the wheel event; otherwise it + will be sent to the parent widget. + + The TQWidget::setEnable() function can be used to enable or disable + mouse and keyboard events for a widget. + + The event handler TQWidget::wheelEvent() receives wheel events. + + \sa TQMouseEvent, TQWidget::grabMouse() +*/ + +/*! + \fn Orientation TQWheelEvent::orientation() const + + Returns the wheel's orientation. +*/ + +/*! + \fn TQWheelEvent::TQWheelEvent( const TQPoint &pos, int delta, int state, Orientation orient = Vertical ); + + Constructs a wheel event object. + + The globalPos() is initialized to TQCursor::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 +TQWheelEvent::TQWheelEvent( const TQPoint &pos, int delta, int state, Orientation orient ) + : TQEvent(Wheel), p(pos), d(delta), s((ushort)state), + accpt(TRUE), o(orient) +{ + g = TQCursor::pos(); +} +#endif +/*! + \fn TQWheelEvent::TQWheelEvent( const TQPoint &pos, const TQPoint& 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 TQWheelEvent::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 TQPoint &TQWheelEvent::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 TQWheelEvent::x() const + + Returns the x-position of the mouse pointer, relative to the + widget that received the event. + + \sa y(), pos() +*/ + +/*! + \fn int TQWheelEvent::y() const + + Returns the y-position of the mouse pointer, relative to the + widget that received the event. + + \sa x(), pos() +*/ + + +/*! + \fn const TQPoint &TQWheelEvent::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 TQCursor::pos(). + + \sa globalX(), globalY() +*/ + +/*! + \fn int TQWheelEvent::globalX() const + + Returns the global x-position of the mouse pointer at the time of + the event. + + \sa globalY(), globalPos() +*/ + +/*! + \fn int TQWheelEvent::globalY() const + + Returns the global y-position of the mouse pointer at the time of + the event. + + \sa globalX(), globalPos() +*/ + + +/*! + \fn ButtonState TQWheelEvent::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 TQWheelEvent::isAccepted() const + + Returns TRUE if the receiver of the event handles the wheel event; + otherwise returns FALSE. +*/ + +/*! + \fn void TQWheelEvent::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 TQWheelEvent::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 TQt::Modifier + + This enum type describes the keyboard modifier keys supported by + TQt. + + \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 TQt Key. +*/ + +/*! + \class TQKeyEvent qevent.h + \brief The TQKeyEvent 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 TQKeyEvent::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 + TQKeyEvent::accept() or an event filter consumes it. + Key events for multi media keys are ignored by default. You should call + TQKeyEvent::accept() if your widget handles those events. + + The TQWidget::setEnable() function can be used to enable or disable + mouse and keyboard events for a widget. + + The event handlers TQWidget::keyPressEvent() and + TQWidget::keyReleaseEvent() receive key events. + + \sa TQFocusEvent, TQWidget::grabKeyboard() +*/ + +/*! + \fn TQKeyEvent::TQKeyEvent( Type type, int key, int ascii, int state, + const TQString& text, bool autorep, ushort count ) + + Constructs a key event object. + + The \a type parameter must be \c TQEvent::KeyPress or \c + TQEvent::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 TQKeyEvent::key() const + + Returns the code of the key that was pressed or released. + + See \l TQt::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 TQt latin 1 keycodes between 128 + and 255, but should rather use the TQKeyEvent::text(). This is + mainly for compatibility. + + \sa TQWidget::setKeyCompression() +*/ + +/*! + \fn int TQKeyEvent::ascii() const + + Returns the ASCII code of the key that was pressed or released. We + recommend using text() instead. + + \sa text() +*/ + +/*! + \fn TQString TQKeyEvent::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 TQWidget::setKeyCompression() +*/ + +/*! + \fn ButtonState TQKeyEvent::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 TQKeyEvent::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 +TQt::ButtonState TQKeyEvent::stateAfter() const +{ + if ( key() == Key_Shift ) + return TQt::ButtonState(state()^ShiftButton); + if ( key() == Key_Control ) + return TQt::ButtonState(state()^ControlButton); + if ( key() == Key_Alt ) + return TQt::ButtonState(state()^AltButton); + if ( key() == Key_Meta ) + return TQt::ButtonState(state()^MetaButton); + return state(); +} + +/*! + \fn bool TQKeyEvent::isAccepted() const + + Returns TRUE if the receiver of the event wants to keep the key; + otherwise returns FALSE +*/ + +/*! + \fn void TQKeyEvent::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 TQKeyEvent::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 TQKeyEvent::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 TQWidget::setKeyCompression() +*/ + +/*! + \fn void TQKeyEvent::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 TQt::Key + + The key names used by TQt. + + \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 TQFocusEvent qevent.h + \brief The TQFocusEvent 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 TQWidget::focusInEvent() and + TQWidget::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 TQWidget::setFocus(), TQWidget::setFocusPolicy() +*/ + +/*! + \fn TQFocusEvent::TQFocusEvent( Type type ) + + Constructs a focus event object. + + The \a type parameter must be either \c TQEvent::FocusIn or \c + TQEvent::FocusOut. +*/ + + + +TQFocusEvent::Reason TQFocusEvent::m_reason = TQFocusEvent::Other; +TQFocusEvent::Reason TQFocusEvent::prev_reason = TQFocusEvent::Other; + + +/*! + \enum TQFocusEvent::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() + */ +TQFocusEvent::Reason TQFocusEvent::reason() +{ + return m_reason; +} + +/*! + Sets the reason for all future focus events to \a reason. + + \sa reason(), resetReason() + */ +void TQFocusEvent::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 TQFocusEvent::resetReason() +{ + m_reason = prev_reason; +} + +/*! + \fn bool TQFocusEvent::gotFocus() const + + Returns TRUE if the widget received the text input focus; + otherwise returns FALSE. +*/ + +/*! + \fn bool TQFocusEvent::lostFocus() const + + Returns TRUE if the widget lost the text input focus; otherwise + returns FALSE. +*/ + + +/*! + \class TQPaintEvent qevent.h + \brief The TQPaintEvent 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 + TQWidget::backgroundMode()), and FALSE if the region's contents are + arbitrary. + + \sa TQPainter TQWidget::update() TQWidget::repaint() + TQWidget::paintEvent() TQWidget::backgroundMode() TQRegion +*/ + +/*! + \fn TQPaintEvent::TQPaintEvent( const TQRegion &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 TQPaintEvent::TQPaintEvent( const TQRect &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 TQPaintEvent::TQPaintEvent( const TQRegion &paintRegion, const TQRect &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 TQRect &TQPaintEvent::rect() const + + Returns the rectangle that should be updated. + + \sa region(), TQPainter::setClipRect() +*/ + +/*! + \fn const TQRegion &TQPaintEvent::region() const + + Returns the region that should be updated. + + \sa rect(), TQPainter::setClipRegion() +*/ + +/*! + \fn bool TQPaintEvent::erased() const + + Returns TRUE if the paint event region (or rectangle) has been + erased with the widget's background; otherwise returns FALSE. +*/ + +/*! + \class TQMoveEvent qevent.h + \brief The TQMoveEvent 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 TQWidget::moveEvent() receives move events. + + \sa TQWidget::move(), TQWidget::setGeometry() +*/ + +/*! + \fn TQMoveEvent::TQMoveEvent( const TQPoint &pos, const TQPoint &oldPos ) + + Constructs a move event with the new and old widget positions, \a + pos and \a oldPos respectively. +*/ + +/*! + \fn const TQPoint &TQMoveEvent::pos() const + + Returns the new position of the widget. This excludes the window + frame for top level widgets. +*/ + +/*! + \fn const TQPoint &TQMoveEvent::oldPos() const + + Returns the old position of the widget. +*/ + + +/*! + \class TQResizeEvent qevent.h + \brief The TQResizeEvent class contains event parameters for resize events. + + \ingroup events + + Resize events are sent to widgets that have been resized. + + The event handler TQWidget::resizeEvent() receives resize events. + + \sa TQWidget::resize(), TQWidget::setGeometry() +*/ + +/*! + \fn TQResizeEvent::TQResizeEvent( const TQSize &size, const TQSize &oldSize ) + + Constructs a resize event with the new and old widget sizes, \a + size and \a oldSize respectively. +*/ + +/*! + \fn const TQSize &TQResizeEvent::size() const + + Returns the new size of the widget, which is the same as + TQWidget::size(). +*/ + +/*! + \fn const TQSize &TQResizeEvent::oldSize() const + + Returns the old size of the widget. +*/ + + +/*! + \class TQCloseEvent qevent.h + \brief The TQCloseEvent 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 + TQWidget::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 -- TQApplication::mainWidget() -- + is a special case. When it accepts the close event, TQt leaves the + main event loop and the application is immediately terminated + (i.e. it returns from the call to TQApplication::exec() in the + main() function). + + The event handler TQWidget::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{TQObject}s emits the \link TQObject::destroyed() + destroyed()\endlink signal when they are deleted. + + If the last top-level window is closed, the + TQApplication::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 TQWidget::close(), TQWidget::hide(), TQObject::destroyed(), + TQApplication::setMainWidget(), TQApplication::lastWindowClosed(), + TQApplication::exec(), TQApplication::tquit() +*/ + +/*! + \fn TQCloseEvent::TQCloseEvent() + + Constructs a close event object with the accept parameter flag set + to FALSE. + + \sa accept() +*/ + +/*! + \fn bool TQCloseEvent::isAccepted() const + + Returns TRUE if the receiver of the event has agreed to close the + widget; otherwise returns FALSE. + + \sa accept(), ignore() +*/ + +/*! + \fn void TQCloseEvent::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 TQWidget::closeEvent(), the widget will + be hidden. If the widget's \c WDestructiveClose flag is set, it + will also be destroyed. + + \sa ignore(), TQWidget::hide() +*/ + +/*! + \fn void TQCloseEvent::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 TQIconDragEvent qevent.h + \brief The TQIconDragEvent 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 TQIconDragEvent::TQIconDragEvent() + + Constructs an icon drag event object with the accept parameter + flag set to FALSE. + + \sa accept() +*/ + +/*! + \fn bool TQIconDragEvent::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 TQIconDragEvent::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(), TQWidget::hide() +*/ + +/*! + \fn void TQIconDragEvent::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 TQContextMenuEvent qevent.h + \brief The TQContextMenuEvent 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 TQPopupMenu 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 TQPopupMenu +*/ + +/*! + \fn TQContextMenuEvent::TQContextMenuEvent( Reason reason, const TQPoint &pos, const TQPoint &globalPos, int state ) + + Constructs a context menu event object with the accept parameter + flag set to FALSE. + + The \a reason parameter must be \c TQContextMenuEvent::Mouse or \c + TQContextMenuEvent::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 TQContextMenuEvent::TQContextMenuEvent( Reason reason, const TQPoint &pos, int state ) + + Constructs a context menu event object with the accept parameter + flag set to FALSE. + + The \a reason parameter must be \c TQContextMenuEvent::Mouse or \c + TQContextMenuEvent::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 TQCursor::pos(), which may not be + appropriate. Use the other constructor to specify the global + position explicitly. +*/ + +TQContextMenuEvent::TQContextMenuEvent( Reason reason, const TQPoint &pos, int state ) + : TQEvent( ContextMenu ), p( pos ), accpt(TRUE), consum(TRUE), + reas( reason ), s((ushort)state) +{ + gp = TQCursor::pos(); +} + +/*! + \fn const TQPoint &TQContextMenuEvent::pos() const + + Returns the position of the mouse pointer relative to the widget + that received the event. + + \sa x(), y(), globalPos() +*/ + +/*! + \fn int TQContextMenuEvent::x() const + + Returns the x-position of the mouse pointer, relative to the + widget that received the event. + + \sa y(), pos() +*/ + +/*! + \fn int TQContextMenuEvent::y() const + + Returns the y-position of the mouse pointer, relative to the + widget that received the event. + + \sa x(), pos() +*/ + +/*! + \fn const TQPoint &TQContextMenuEvent::globalPos() const + + Returns the global position of the mouse pointer at the time of + the event. + + \sa x(), y(), pos() +*/ + +/*! + \fn int TQContextMenuEvent::globalX() const + + Returns the global x-position of the mouse pointer at the time of + the event. + + \sa globalY(), globalPos() +*/ + +/*! + \fn int TQContextMenuEvent::globalY() const + + Returns the global y-position of the mouse pointer at the time of + the event. + + \sa globalX(), globalPos() +*/ + +/*! + \fn ButtonState TQContextMenuEvent::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 TQContextMenuEvent::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 TQContextMenuEvent::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 TQContextMenuEvent::isAccepted() const + + Returns TRUE if the receiver has processed the event; otherwise + returns FALSE. + + \sa accept(), ignore(), consume() +*/ + +/*! + \fn void TQContextMenuEvent::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 TQContextMenuEvent::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 TQContextMenuEvent::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 TQContextMenuEvent::Reason TQContextMenuEvent::reason() const + + Returns the reason for this context event. +*/ + + +/*! + \class TQIMEvent qevent.h + \brief The TQIMEvent 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 TQWidget::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 TQWidget::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 TQWidget::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 TQIMEvent::TQIMEvent( Type type, const TQString &text, int cursorPosition ) + + Constructs a new TQIMEvent with the accept flag set to FALSE. \a + type can be one of TQEvent::IMStartEvent, TQEvent::IMComposeEvent + or TQEvent::IMEndEvent. \a text contains the current compostion + string and \a cursorPosition the current position of the cursor + inside \a text. +*/ + +/*! + \fn const TQString &TQIMEvent::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 TQIMEvent::cursorPos() const + + Returns the current cursor position inside the composition string. + Will return -1 for IMStartEvent and IMEndEvent. +*/ + +/*! + \fn int TQIMEvent::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 TQIMEvent::isAccepted() const + + Returns TRUE if the receiver of the event processed the event; + otherwise returns FALSE. +*/ + +/*! + \fn void TQIMEvent::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 TQIMEvent::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 TQTabletEvent qevent.h + \brief The TQTabletEvent class contains parameters that describe a Tablet + event. + + \ingroup events + + Tablet Events are generated from a Wacom© 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. TQTabletEvent 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 + TQTabletEvent::accept() if you handle the tablet event; otherwise + it will be sent to the parent widget. + + The TQWidget::setEnabled() function can be used to enable or + disable mouse and keyboard events for a widget. + + The event handler TQWidget::tabletEvent() receives all three types of tablet + events. TQt 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 TQTabletEvent::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 TQTabletEvent::TQTabletEvent( Type t, const TQPoint &pos, + const TQPoint &globalPos, int device, + int pressure, int xTilt, int yTilt, + const TQPair<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() +*/ + +TQTabletEvent::TQTabletEvent( Type t, const TQPoint &pos, const TQPoint &globalPos, int device, + int pressure, int xTilt, int yTilt, + const TQPair<int, int> &uId ) + : TQEvent( t ), + mPos( pos ), + mGPos( globalPos ), + mDev( device ), + mPress( pressure ), + mXT( xTilt ), + mYT( yTilt ), + mType( uId.first ), + mPhy( uId.second ), + mbAcc(TRUE) +{} + +/*! + \obsolete + \fn TQTabletEvent::TQTabletEvent( const TQPoint &pos, const TQPoint &globalPos, int device, int pressure, int xTilt, int yTilt, const TQPair<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 TQTabletEvent::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 TQTabletEvent::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 TQTabletEvent::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 TQTabletEvent::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 TQPoint &TQTabletEvent::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 TQTabletEvent::x() const + + Returns the x-position of the device, relative to the widget that + received the event. + + \sa y(), pos() +*/ + +/*! + \fn int TQTabletEvent::y() const + + Returns the y-position of the device, relative to the widget that + received the event. + + \sa x(), pos() +*/ + +/*! + \fn const TQPoint &TQTabletEvent::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 + TQCursor::pos(). + + \sa globalX(), globalY() +*/ + +/*! + \fn int TQTabletEvent::globalX() const + + Returns the global x-position of the mouse pointer at the time of + the event. + + \sa globalY(), globalPos() +*/ + +/*! + \fn int TQTabletEvent::globalY() const + + Returns the global y-position of the mouse pointer at the time of + the event. + + \sa globalX(), globalPos() +*/ + +/*! + \fn bool TQTabletEvent::isAccepted() const + + Returns TRUE if the receiver of the event handles the tablet + event; otherwise returns FALSE. +*/ + +/*! + \fn void TQTabletEvent::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 TQTabletEvent::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 TQPair<int, int> TQTabletEvent::uniqueId() + + Returns a unique ID for the current device. It is possible to + generate a unique ID for any Wacom© 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 TQChildEvent qevent.h + \brief The TQChildEvent 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 TQApplication::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 TQObject::childEvent(). +*/ + +/*! + \fn TQChildEvent::TQChildEvent( Type type, TQObject *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 TQEvent::ChildInserted or + \c TQEvent::ChildRemoved. +*/ + +/*! + \fn TQObject *TQChildEvent::child() const + + Returns the child widget that was inserted or removed. +*/ + +/*! + \fn bool TQChildEvent::inserted() const + + Returns TRUE if the widget received a new child; otherwise returns + FALSE. +*/ + +/*! + \fn bool TQChildEvent::removed() const + + Returns TRUE if the object lost a child; otherwise returns FALSE. +*/ + + + + +/*! + \class TQCustomEvent qevent.h + \brief The TQCustomEvent class provides support for custom events. + + \ingroup events + + TQCustomEvent is a generic event class for user-defined events. + User defined events can be sent to widgets or other TQObject + instances using TQApplication::postEvent() or + TQApplication::sendEvent(). Subclasses of TQObject can easily + receive custom events by implementing the TQObject::customEvent() + event handler function. + + TQCustomEvent objects should be created with a type ID that + uniquely identifies the event type. To avoid clashes with the + TQt-defined events types, the value should be at least as large as + the value of the "User" entry in the TQEvent::Type enum. + + TQCustomEvent 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. + + TQCustomEvent 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 TQCustomEvent + { + public: + ColorChangeEvent( TQColor color ) + : TQCustomEvent( 65432 ), c( color ) {} + TQColor color() const { return c; } + private: + TQColor c; + }; + + // To send an event of this custom event type: + + ColorChangeEvent* ce = new ColorChangeEvent( blue ); + TQApplication::postEvent( receiver, ce ); // TQt will delete it when done + + // To receive an event of this custom event type: + + void MyWidget::customEvent( TQCustomEvent * e ) + { + if ( e->type() == 65432 ) { // It must be a ColorChangeEvent + ColorChangeEvent* ce = (ColorChangeEvent*)e; + newColor = ce->color(); + } + } + \endcode + + \sa TQWidget::customEvent(), TQApplication::notify() +*/ + + +/*! + Constructs a custom event object with event type \a type. The + value of \a type must be at least as large as TQEvent::User. The + data pointer is set to 0. +*/ + +TQCustomEvent::TQCustomEvent( int type ) + : TQEvent( (TQEvent::Type)type ), d( 0 ) +{ +} + + +/*! + \fn TQCustomEvent::TQCustomEvent( 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 + TQEvent::Type). +*/ + + +/*! + \fn void TQCustomEvent::setData( void* data ) + + Sets the generic data pointer to \a data. + + \sa data() +*/ + +/*! + \fn void *TQCustomEvent::data() const + + Returns a pointer to the generic event data. + + \sa setData() +*/ + + + +/*! + \fn TQDragMoveEvent::TQDragMoveEvent( const TQPoint& pos, Type type ) + + Creates a TQDragMoveEvent for which the mouse is at point \a pos, + and the event is of type \a type. + + \warning Do not create a TQDragMoveEvent yourself since these + objects rely on TQt's internal state. +*/ + +/*! + \fn void TQDragMoveEvent::accept( const TQRect & 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 TQRect::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 TQDragMoveEvent::ignore( const TQRect & r) + + The opposite of accept(const TQRect&), i.e. says that moves within + rectangle \a r are not acceptable (will be ignored). +*/ + +/*! + \fn TQRect TQDragMoveEvent::answerRect() const + + Returns the rectangle for which the acceptance of the move event + applies. +*/ + + + +/*! + \fn const TQPoint& TQDropEvent::pos() const + + Returns the position where the drop was made. +*/ + +/*! + \fn bool TQDropEvent::isAccepted () const + + Returns TRUE if the drop target accepts the event; otherwise + returns FALSE. +*/ + +/*! + \fn void TQDropEvent::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 TQDragObject subclasses, such as + TQTextDrag::decode(), or your own subclasses. + + \sa acceptAction() +*/ + +/*! + \fn void TQDropEvent::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 TQDragMoveEvent::accept( bool y ) + \reimp + \internal + Remove in 3.0 +*/ + +/*! + \fn void TQDragMoveEvent::ignore() + \reimp + \internal + Remove in 3.0 +*/ + + +/*! + \enum TQDropEvent::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 TQUriDrag). +*/ + +/*! + \fn void TQDropEvent::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 TQDropEvent::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 TQDropEvent::ignore() + + The opposite of accept(), i.e. you have ignored the drop event. +*/ + +/*! + \fn bool TQDropEvent::isActionAccepted () const + + Returns TRUE if the drop action was accepted by the drop site; + otherwise returns FALSE. +*/ + + +/*! + \fn void TQDropEvent::setPoint (const TQPoint & 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 TQDragEnterEvent qevent.h + \brief The TQDragEnterEvent 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 TQDragMoveEvent, so + you only need to respond to one or the other event. This class + inherits most of its functionality from TQDragMoveEvent, which in + turn inherits most of its functionality from TQDropEvent. + + \sa TQDragLeaveEvent, TQDragMoveEvent, TQDropEvent +*/ + +/*! + \fn TQDragEnterEvent::TQDragEnterEvent (const TQPoint & pos) + + Constructs a TQDragEnterEvent entering at the given point, \a pos. + + \warning Do not create a TQDragEnterEvent yourself since these + objects rely on TQt's internal state. +*/ + +/*! + \class TQDragLeaveEvent qevent.h + \brief The TQDragLeaveEvent 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 TQDragEnterEvent and a series of + \l{TQDragMoveEvent}s. It is not sent if a TQDropEvent is sent + instead. + + \sa TQDragEnterEvent, TQDragMoveEvent, TQDropEvent +*/ + +/*! + \fn TQDragLeaveEvent::TQDragLeaveEvent() + + Constructs a TQDragLeaveEvent. + + \warning Do not create a TQDragLeaveEvent yourself since these + objects rely on TQt's internal state. +*/ + +/*! + \class TQHideEvent qevent.h + \brief The TQHideEvent class provides an event which is sent after a widget is hidden. + + \ingroup events + + This event is sent just before TQWidget::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, + TQWidget::isMinimized() returns TRUE. + + \sa TQShowEvent +*/ + +/*! + \fn TQHideEvent::TQHideEvent() + + Constructs a TQHideEvent. +*/ + +/*! + \class TQShowEvent qevent.h + \brief The TQShowEvent 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 TQHideEvent +*/ + +/*! + \fn TQShowEvent::TQShowEvent() + + Constructs a TQShowEvent. +*/ + + +/*! + \fn TQByteArray TQDropEvent::data(const char* f) const + + \obsolete + + Use TQDropEvent::encodedData(). +*/ + + +/*! + Destroys the event. If it was \link + TQApplication::postEvent() posted \endlink, + it will be removed from the list of events to be posted. +*/ + +TQEvent::~TQEvent() +{ + if ( posted && qApp ) + TQApplication::removePostedEvent( this ); +} |