/**************************************************************************** ** ** 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::quit() */ /*! \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 Starting to Compose
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 Composing
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 Completing
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 &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 &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 &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 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 ); }