/****************************************************************************
**
** 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 requirements will be met:
** http://trolltech.com/products/qt/licenses/licensing/opensource/.
** If you are unsure which license is appropriate for your use, please
** review the following information:
** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
** or contact the sales department at sales@trolltech.com.
**
** This file may be used under the terms of the Q Public License as
** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
** included in the packaging of this file. Licensees holding valid TQt
** Commercial licenses may use this file in accordance with the TQt
** Commercial License Agreement provided with the Software.
**
** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
** herein.
**
**********************************************************************/
#include "ntqevent.h"
#include "ntqcursor.h"
#include "ntqapplication.h"
/*!
\class TQEvent ntqevent.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 ntqevent.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 ntqevent.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 ntqevent.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 ntqevent.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 ntqevent.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 ntqevent.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 ntqevent.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 ntqevent.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 ntqevent.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 ntqevent.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 ntqevent.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 ntqevent.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 ntqevent.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 ntqevent.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 ntqevent.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 ntqevent.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 ntqevent.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 ntqevent.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 ntqevent.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 && tqApp )
TQApplication::removePostedEvent( this );
}