Source Code (Use browser search to find items of interest.)
Class Index
qt'QCustomEvent (./qt-2.1.0/src/kernel/qevent.h:412)
class Q_EXPORT QCustomEvent : public QEvent
{
public:
QCustomEvent( int type );
QCustomEvent( Type type, void *data )
: QEvent(type), d(data) {};
void *data() const { return d; }
void setData( void* data ) { d = data; }
private:
void *d;
};
qt'QCustomEvent::QCustomEvent() (./qt-2.1.0/src/kernel/qevent.cpp:1072)
QCustomEvent::QCustomEvent( int type )
: QEvent( (QEvent::Type)type ), d( 0 )
{
#if defined(CHECK_RANGE)
if ( type < (int)QEvent::User )
qWarning( "QCustomEvent: Illegal type id." );
#endif
}
/*!
\fn QCustomEvent::QCustomEvent( Type type, void *data )
Constructs a custom event object with the event type \a type and a
pointer to \a data. (Note that any int value may safely be casted to
QEvent::Type).
*/
/*!
\fn void QCustomEvent::setData( void* data )
Sets the generic data pointer to \a data.
\sa data()
*/
/*!
\fn void *QCustomEvent::data() const
Returns a pointer to the generic event data.
\sa setData()
*/
/*!
\fn QDragMoveEvent::QDragMoveEvent( const QPoint& pos, Type type )
Creates a QDragMoveEvent for which the mouse is at point \a pos,
and the given event \a type.
Note that internal state is also involved with QDragMoveEvent,
so it is not useful to create these yourself.
*/
/*!
\fn void QDragMoveEvent::accept( const QRect & r )
The same as accept(), but also notifies that future moves will
also be acceptable if they remain within the rectangle \a r on the
widget - this can improve performance, but may also be ignored by
the underlying system.
If the rectangle \link QRect::isEmpty() is empty\endlink, then drag
move events will be sent continuously. This is useful if the source is
scrolling in a timer event.
*/
/*!
\fn void QDragMoveEvent::ignore( const QRect & r)
The opposite of accept(const QRect&).
*/
/*!
\fn QRect QDragMoveEvent::answerRect() const
Returns the rectangle for which the acceptance of
the move event applies.
*/
/*!
\fn QDropEvent::QDropEvent( const QPoint& pos )
Creates a QDropEvent for which the mouse is at point \a pos.
Note that internal state is also involved with QDropEvent,
so it is not useful to create these yourself.
*/
/*!
\fn const QPoint& QDropEvent::pos() const
Returns the position where the drop was made.
*/
/*!
\fn bool QDropEvent::isAccepted () const
Returns TRUE if the drop target accepts the event.
*/
/*!
\fn void QDropEvent::accept(bool y=TRUE)
\reimp
Call this to indicate whether the event provided data which your
widget processed. To get the data, use encodedData(), or
preferably, the decode() methods of existing QDragObject subclasses,
such as QTextDrag::decode(), or your own subclasses.
\warning To accept or reject the drop, call acceptAction(), not this
function. This function indicates whether you processed the event
at all.
\sa acceptAction()
*/
/*!
\fn void QDropEvent::acceptAction(bool y=TRUE)
Call this to indicate that the action described by action() is accepted,
not merely the default copy action. If you call acceptAction(TRUE),
there is no need to also call accept(TRUE).
*/
/*!
\fn void QDragMoveEvent::accept( bool y )
\reimp
\internal
Remove in 3.0
*/
/*!
\fn void QDragMoveEvent::ignore()
\reimp
\internal
Remove in 3.0
*/
/*!
\enum QDropEvent::Action
This type describes the action which a source requests that a target
perform with dropped data. The values are:
<ul>
<li>\c Copy - the default action. The source simply users the data
provided in the operation.
<li>\c Link. The source should somehow create a link to the location
specified by the data.
<li>\c Move. The source should somehow move the object from the location
specified by the data to a new location.
<li>\c Private. The target has special knowledge of the MIME type, which
the source should respond to similar to a Copy.
<li>\c UserAction. The source and target can co-operate using special
actions. This feature is not supported in Qt at this time.
</ul>
The Link and Move actions only makes sense if the data is
a reference, such as text/uri-list file lists (see QUriDrag).
*/
/*!
\fn void QDropEvent::setAction( Action a )
Sets the action. This is used internally, you should not need to
call this in your code - the \e source decides the action, not the
target.
*/
/*!
\fn Action QDropEvent::action() const
Returns the Action which the target is requesting be performed with
the data. If your application understands the action and can
process the supplied data, call acceptAction(); if your application
can process the supplied data but can only perform the Copy action,
call accept().
*/
/*!
\fn void QDropEvent::ignore()
The opposite of accept().
*/
/*! \fn bool QDropEvent::isActionAccepted () const
Returns TRUE if the drop action was accepted by the drop site, and
FALSE if not.
*/
/*! \fn void QDropEvent::setPoint (const QPoint & np)
Sets the drop to happen at \a np. You do normally not need to use
this as it will be set internally before your widget receives the
drop event.
*/ // ### here too - what coordinate system?
/*!
\class QDragEnterEvent qevent.h
\brief The event sent to widgets when a drag-and-drop first drags onto it.
This event is always immediate followed by a QDragMoveEvent, thus you need
only respond to one or the other event. Note that this class inherits most
of its functionality from QDragMoveEvent, which in turn inherits most
of its functionality from QDropEvent.
\sa QDragLeaveEvent, QDragMoveEvent, QDropEvent
*/
/*!
\fn QDragEnterEvent::QDragEnterEvent (const QPoint & pos)
Constructs a QDragEnterEvent entering at the given point.
Note that QDragEnterEvent constructed outside of the Qt internals
will not work - they currently rely on internal state.
*/
/*!
\class QDragLeaveEvent qevent.h
\brief The event sent to widgets when a drag-and-drop leaves it.
This event is always preceded by a QDragEnterEvent and a series
of QDragMoveEvent. It is not sent if a QDropEvent is sent instead.
\sa QDragEnterEvent, QDragMoveEvent, QDropEvent
*/
/*!
\fn QDragLeaveEvent::QDragLeaveEvent()
Constructs a QDragLeaveEvent.
Note that QDragLeaveEvent constructed outside of the Qt internals
will not work - they currently rely on internal state.
*/
/*!
\class QHideEvent qevent.h
\brief The event sent after a widget is hidden.
This event is sent just before QWidget::hide() returns, and also when
a top-level window has been hidden (iconified) by the user.
\sa QShowEvent
*/
/*!
\fn QHideEvent::QHideEvent(bool spontaneous)
Constructs a QHideEvent. \a spontaneous is TRUE if the event
originated outside the application - ie. the user hid the window via the
window manager controls.
*/
/*!
\fn bool QHideEvent::spontaneous () const
Returns TRUE if the event originated outside the application -
ie. the user hid the window via the window manager controls, either
by iconifying the window or by switching to another virtual desktop where
the window isn't visible. The window will become hidden, but not withdrawn.
If the window was iconified, QWidget::isMinimized() is TRUE.
*/
/*!
\class QShowEvent qevent.h
\brief The event sent when a widget is shown.
There are two kind of show events: spontaneous show events by the
window system and internal show events. Spontaneous show events are
sent just after the window system shows the window, including after
a top-level window has been shown (un-iconified) by the
user. Internal show events are delivered just before the widget
becomes visible.
\sa QHideEvent
*/
/*!
\fn QShowEvent::QShowEvent(bool spontaneous)
Constructs a QShowEvent. \a spontaneous is TRUE if the event
originated outside the application - ie. the user revealed the window via the
window manager controls.
*/
/*!
\fn bool QShowEvent::spontaneous () const
Returns TRUE if the event
originated outside the application - ie. the user revealed the window via the
window manager controls.
*/
/*!
\fn QByteArray QDropEvent::data(const char* f) const
\obsolete
Use QDropEvent::encodedData().
*/
/*!
Destructs the event. If it was \link
QApplication::postEvent() posted \endlink,
it will be removed from the list of events to be posted.
\internal
It used to print an error (useful for people who posted events
that were on the stack).
*/