| qaccessibilityhints.cpp |
!
\class QAccessibilityHints
\since 6.10
\brief The QAccessibilityHints class contains platform specific accessibility hints and settings.
\inmodule QtGui
This class bundles together platform specific accessibility settings, and can be accessed from
\l QStyleHints::accessibility.
\sa QStyleHints
|
2785 |
- |
| qaccessibilityhints.h |
|
1308 |
- |
| qaccessibilityhints_p.h |
|
1160 |
- |
| qaction.cpp |
internal: guesses a descriptive text from a text suited for a menu entry
|
35861 |
- |
| qaction.h |
These are templates so that instantiation happens only in calling code, when
QWidget, QMenu, and QGraphicsWidget can be expected to be fully defined.
|
7648 |
- |
| qaction_p.h |
|
2530 |
- |
| qactiongroup.cpp |
! \internal |
10033 |
- |
| qactiongroup.h |
|
1846 |
- |
| qactiongroup_p.h |
|
1437 |
- |
| qclipboard.cpp |
!
\class QClipboard
\brief The QClipboard class provides access to the window system clipboard.
\inmodule QtGui
The clipboard offers a simple mechanism to copy and paste data
between applications.
QClipboard supports the same data types that QDrag does, and uses
similar mechanisms. For advanced clipboard usage read \l{Drag and
Drop}.
There is a single QClipboard object in an application, accessible
as QGuiApplication::clipboard().
Example:
\snippet code/src_gui_kernel_qclipboard.cpp 0
QClipboard features some convenience functions to access common
data types: setText() allows the exchange of Unicode text and
setPixmap() and setImage() allows the exchange of QPixmaps and
QImages between applications. The setMimeData() function is the
ultimate in flexibility: it allows you to add any QMimeData into
the clipboard. There are corresponding getters for each of these,
e.g. text(), image() and pixmap(). You can clear the clipboard by
calling clear().
A typical example of the use of these functions follows:
\snippet droparea/droparea.cpp 0
\section1 Notes for X11 Users
\list
\li The X11 Window System has the concept of a separate selection
and clipboard. When text is selected, it is immediately available
as the global mouse selection. The global mouse selection may
later be copied to the clipboard. By convention, the middle mouse
button is used to paste the global mouse selection.
\li X11 also has the concept of ownership; if you change the
selection within a window, X11 will only notify the owner and the
previous owner of the change, i.e. it will not notify all
applications that the selection or clipboard data changed.
\li Lastly, the X11 clipboard is event driven, i.e. the clipboard
will not function properly if the event loop is not running.
Similarly, it is recommended that the contents of the clipboard
are stored or retrieved in direct response to user-input events,
e.g. mouse button or key presses and releases. You should not
store or retrieve the clipboard contents in response to timer or
non-user-input events.
\li Since there is no standard way to copy and paste files between
applications on X11, various MIME types and conventions are currently
in use. For instance, Nautilus expects files to be supplied with a
\c{x-special/gnome-copied-files} MIME type with data beginning with
the cut/copy action, a newline character, and the URL of the file.
\endlist
\section1 Notes for \macos Users
\macos supports a separate find buffer that holds the current
search string in Find operations. This find clipboard can be accessed
by specifying the FindBuffer mode.
\section1 Notes for Windows and \macos Users
\list
\li Windows and \macos do not support the global mouse
selection; they only supports the global clipboard, i.e. they
only add text to the clipboard when an explicit copy or cut is
made.
\li Windows and \macos does not have the concept of ownership;
the clipboard is a fully global resource so all applications are
notified of changes.
\endlist
\section1 Notes for Android Users
On Android only these mime types are supported: text/plain, text/html, and text/uri-list.
\sa QGuiApplication
|
17619 |
- |
| qclipboard.h |
|
1906 |
- |
| qcursor.cpp |
!
\class QCursor
\brief The QCursor class provides a mouse cursor with an arbitrary
shape.
\inmodule QtGui
\ingroup appearance
\ingroup shared
This class is mainly used to create mouse cursors that are
associated with particular widgets and to get and set the position
of the mouse cursor.
Qt has a number of standard cursor shapes, but you can also make
custom cursor shapes based on a QBitmap, a mask and a hotspot.
To associate a cursor with a widget, use QWidget::setCursor(). To
associate a cursor with all widgets (normally for a short period
of time), use QGuiApplication::setOverrideCursor().
To set a cursor shape use QCursor::setShape() or use the QCursor
constructor which takes the shape as argument, or you can use one
of the predefined cursors defined in the \l Qt::CursorShape enum.
If you want to create a cursor with your own bitmap, either use
the QCursor constructor which takes a bitmap and a mask or the
constructor which takes a pixmap as arguments.
To set or get the position of the mouse cursor use the static
methods QCursor::pos() and QCursor::setPos().
\b{Note:} It is possible to create a QCursor before
QGuiApplication, but it is not useful except as a place-holder for a
real QCursor created after QGuiApplication. Attempting to use a
QCursor that was created before QGuiApplication will result in a
crash.
\section1 A Note for X11 Users
On X11, Qt supports the \l{Xcursor}{Xcursor}
library, which allows for full color icon themes. The table below
shows the cursor name used for each Qt::CursorShape value. If a
cursor cannot be found using the name shown below, a standard X11
cursor will be used instead. Note: X11 does not provide
appropriate cursors for all possible Qt::CursorShape values. It
is possible that some cursors will be taken from the Xcursor
theme, while others will use an internal bitmap cursor.
\table
\header \li Shape \li Qt::CursorShape Value \li Cursor Name
\li Shape \li Qt::CursorShape Value \li Cursor Name
\row \li \inlineimage cursor-arrow.png {Arrow cursor}
\li Qt::ArrowCursor \li \c left_ptr
\li \inlineimage cursor-sizev.png {Vertical resize cursor}
\li Qt::SizeVerCursor \li \c size_ver
\row \li \inlineimage cursor-uparrow.png {Up arrow cursor}
\li Qt::UpArrowCursor \li \c up_arrow
\li \inlineimage cursor-sizeh.png {Horizontal resize cursor}
\li Qt::SizeHorCursor \li \c size_hor
\row \li \inlineimage cursor-cross.png {Cross cursor}
\li Qt::CrossCursor \li \c cross
\li \inlineimage cursor-sizeb.png {Diagonal resize cursor}
\li Qt::SizeBDiagCursor \li \c size_bdiag
\row \li \inlineimage cursor-ibeam.png {I-beam cursor}
\li Qt::IBeamCursor \li \c ibeam
\li \inlineimage cursor-sizef.png {Diagonal resize cursor}
\li Qt::SizeFDiagCursor \li \c size_fdiag
\row \li \inlineimage cursor-wait.png {Wait cursor}
\li Qt::WaitCursor \li \c wait
\li \inlineimage cursor-sizeall.png {Move cursor}
\li Qt::SizeAllCursor \li \c size_all
\row \li \inlineimage cursor-busy.png {Busy cursor}
\li Qt::BusyCursor \li \c left_ptr_watch
\li \inlineimage cursor-vsplit.png {Vertical split cursor}
\li Qt::SplitVCursor \li \c split_v
\row \li \inlineimage cursor-forbidden.png {Forbidden cursor}
\li Qt::ForbiddenCursor \li \c forbidden
\li \inlineimage cursor-hsplit.png {Horizontal split cursor}
\li Qt::SplitHCursor \li \c split_h
\row \li \inlineimage cursor-hand.png {Pointing hand cursor}
\li Qt::PointingHandCursor \li \c pointing_hand
\li \inlineimage cursor-openhand.png {Open hand cursor}
\li Qt::OpenHandCursor \li \c openhand
\row \li \inlineimage cursor-whatsthis.png {What's this cursor}
\li Qt::WhatsThisCursor \li \c whats_this
\li \inlineimage cursor-closedhand.png {Closed hand cursor}
\li Qt::ClosedHandCursor \li \c closedhand
\row \li
\li Qt::DragMoveCursor \li \c dnd-move or \c move
\li
\li Qt::DragCopyCursor \li \c dnd-copy or \c copy
\row \li
\li Qt::DragLinkCursor \li \c dnd-link or \c link
\endtable
\sa QWidget
|
21453 |
- |
| qcursor.h |
### The fake cursor has to go first with old qdoc.
|
3141 |
- |
| qcursor_p.h |
|
1258 |
- |
| qdnd.cpp |
|
2135 |
- |
| qdnd_p.h |
|
1949 |
- |
| qdrag.cpp |
!
\class QDrag
\inmodule QtGui
\ingroup draganddrop
\brief The QDrag class provides support for MIME-based drag and drop data
transfer.
Drag and drop is an intuitive way for users to copy or move data around in an
application, and is used in many desktop environments as a mechanism for copying
data between applications. Drag and drop support in Qt is centered around the
QDrag class that handles most of the details of a drag and drop operation.
The data to be transferred by the drag and drop operation is contained in a
QMimeData object. This is specified with the setMimeData() function in the
following way:
\snippet dragging/mainwindow.cpp 1
Note that setMimeData() assigns ownership of the QMimeData object to the
QDrag object. The QDrag must be constructed on the heap with a parent QObject
to ensure that Qt can clean up after the drag and drop operation has been
completed.
A pixmap can be used to represent the data while the drag is in
progress, and will move with the cursor to the drop target. This
pixmap typically shows an icon that represents the MIME type of
the data being transferred, but any pixmap can be set with
setPixmap(). The cursor's hot spot can be given a position
relative to the top-left corner of the pixmap with the
setHotSpot() function. The following code positions the pixmap so
that the cursor's hot spot points to the center of its bottom
edge:
\snippet separations/finalwidget.cpp 2
\note On X11, the pixmap may not be able to keep up with the mouse
movements if the hot spot causes the pixmap to be displayed
directly under the cursor.
The source and target widgets can be found with source() and target().
These functions are often used to determine whether drag and drop operations
started and finished at the same widget, so that special behavior can be
implemented.
QDrag only deals with the drag and drop operation itself. It is up to the
developer to decide when a drag operation begins, and how a QDrag object should
be constructed and used. For a given widget, it is often necessary to
reimplement \l{QWidget::mousePressEvent()}{mousePressEvent()} to determine
whether the user has pressed a mouse button, and reimplement
\l{QWidget::mouseMoveEvent()}{mouseMoveEvent()} to check whether a QDrag is
required.
\sa {Drag and Drop}, QClipboard, QMimeData, {Draggable Icons Example},
{Draggable Text Example}, {Drop Site Example}
|
11012 |
- |
| qdrag.h |
|
1463 |
- |
| qevent.cpp |
check that covariant return is safe to add |
166128 |
- |
| qevent.h |
|
36551 |
- |
| qevent_p.h |
!
\internal
\since 6.9
This class provides a way to store copies of QEvents. QEvents can otherwise
only be copied by \l{QEvent::clone()}{cloning}, which allocates the copy on
the heap. By befriending concrete QEvent subclasses, QEventStorage gains
access to their protected copy constructors.
It is similar to std::optional, but with a more targeted API.
Note that by storing an event in QEventStorage, it may be sliced.
|
4549 |
- |
| qeventpoint.cpp |
! \class QEventPoint
\brief The QEventPoint class provides information about a point in a QPointerEvent.
\since 6.0
\inmodule QtGui
|
21237 |
- |
| qeventpoint.h |
|
6053 |
- |
| qeventpoint_p.h |
end |
4724 |
- |
| qgenericplugin.cpp |
!
\class QGenericPlugin
\ingroup plugins
\inmodule QtGui
\brief The QGenericPlugin class is an abstract base class for
plugins.
A mouse plugin can be created by subclassing
QGenericPlugin and reimplementing the pure virtual create()
function. By exporting the derived class using the
Q_PLUGIN_METADATA() macro, The default implementation of the
QGenericPluginFactory class will automatically detect the plugin and
load the driver into the server application at run-time. See \l
{How to Create Qt Plugins} for details.
The json metadata file should contain a list of keys supported by this
plugin.
\sa QGenericPluginFactory
|
1765 |
- |
| qgenericplugin.h |
|
735 |
- |
| qgenericpluginfactory.cpp |
!
\class QGenericPluginFactory
\ingroup plugins
\inmodule QtGui
\brief The QGenericPluginFactory class creates plugin drivers.
\sa QGenericPlugin
|
1624 |
- |
| qgenericpluginfactory.h |
|
573 |
- |
| qguiapplication.cpp |
|
178797 |
- |
| qguiapplication.h |
|
6559 |
- |
| qguiapplication_p.h |
|
16580 |
- |
| qguiapplication_platform.h |
|
3225 |
- |
| qguivariant.cpp |
|
4787 |
- |
| qhighdpiscaling.cpp |
|
32235 |
- |
| qhighdpiscaling_p.h |
origin |
13959 |
- |
| qinputdevice.cpp |
!
\class QInputDevice
\brief The QInputDevice class describes a device from which a QInputEvent originates.
\since 6.0
\inmodule QtGui
Each QInputEvent contains a QInputDevice pointer to allow accessing
device-specific properties like type, capabilities and seat. It is the
responsibility of the platform or generic plug-ins to discover, create and
register an instance of this class corresponding to each available input
device, via QWindowSystemInterface::registerInputDevice(), before
generating any input event referring to that device.
Applications do not need to instantiate this class, but can read the
instances pointed to by QInputEvent::device() and QInputDevice::devices().
|
13382 |
- |
| qinputdevice.h |
|
3059 |
- |
| qinputdevice_p.h |
|
2929 |
- |
| qinputdevicemanager.cpp |
!
\class QInputDeviceManager
\internal
\brief QInputDeviceManager acts as a communication hub between QtGui and the input handlers.
On embedded platforms the input handling code is either compiled into the platform
plugin or is loaded dynamically as a generic plugin without any interface. The input
handler in use may also change between each run (e.g. evdevmouse/keyboard/touch
vs. libinput). QWindowSystemInterface is too limiting when Qt (the platform plugin) is
acting as a windowing system, and is one way only.
QInputDeviceManager solves this by providing a global object that is used to communicate
from the input handlers to the rest of Qt (e.g. the number of connected mice, which may
be important information for the cursor drawing code), and vice-versa (e.g. to indicate
to the input handler that a manual cursor position change was requested by the
application via QCursor::setPos and thus any internal state has to be updated accordingly).
|
3042 |
- |
| qinputdevicemanager_p.h |
|
1574 |
- |
| qinputdevicemanager_p_p.h |
|
1194 |
- |
| qinputmethod.cpp |
!
\internal
|
12727 |
- |
| qinputmethod.h |
|
2762 |
- |
| qinputmethod_p.h |
|
1473 |
- |
| qinternalmimedata.cpp |
|
7202 |
- |
| qinternalmimedata_p.h |
|
1651 |
- |
| qkeymapper.cpp |
!
\class QKeyMapper
\since 4.2
\internal
\sa QObject
|
2545 |
- |
| qkeymapper_p.h |
|
1686 |
- |
| qkeysequence.cpp |
!
\fn void qt_set_sequence_auto_mnemonic(bool b)
\relates QKeySequence
Specifies whether mnemonics for menu items, labels, etc., should
be honored or not. On Windows and X11, this feature is
on by default; on \macos, it is off. When this feature is off
(that is, when \a b is false), QKeySequence::mnemonic() always
returns an empty string.
\note This function is not declared in any of Qt's header files.
To use it in your application, declare the function prototype
before calling it.
\sa QShortcut
|
78682 |
- |
| qkeysequence.h |
QKeySequence stream functions
*************************************************************************** |
5572 |
- |
| qkeysequence_p.h |
|
1585 |
- |
| qoffscreensurface.cpp |
!
\class QOffscreenSurface
\inmodule QtGui
\since 5.1
\brief The QOffscreenSurface class represents an offscreen surface in the underlying platform.
QOffscreenSurface is intended to be used with QOpenGLContext to allow rendering with OpenGL in
an arbitrary thread without the need to create a QWindow.
Even though the surface is typically renderable, the surface's pixels are not accessible.
QOffscreenSurface should only be used to create OpenGL resources such as textures
or framebuffer objects.
An application will typically use QOffscreenSurface to perform some time-consuming tasks in a
separate thread in order to avoid stalling the main rendering thread. Resources created in the
QOffscreenSurface's context can be shared with the main OpenGL context. Some common use cases
are asynchronous texture uploads or rendering into a QOpenGLFramebufferObject.
How the offscreen surface is implemented depends on the underlying platform, but it will
typically use a pixel buffer (pbuffer). If the platform doesn't implement or support
offscreen surfaces, QOffscreenSurface will use an invisible QWindow internally.
\note Due to the fact that QOffscreenSurface is backed by a QWindow on some platforms,
cross-platform applications must ensure that create() is only called on the main (GUI)
thread. The QOffscreenSurface is then safe to be used with
\l{QOpenGLContext::makeCurrent()}{makeCurrent()} on other threads, but the
initialization and destruction must always happen on the main (GUI) thread.
\note In order to create an offscreen surface that is guaranteed to be compatible with
a given context and window, make sure to set the format to the context's or the
window's actual format, that is, the QSurfaceFormat returned from
QOpenGLContext::format() or QWindow::format() \e{after the context or window has been
created}. Passing the format returned from QWindow::requestedFormat() to setFormat()
may result in an incompatible offscreen surface since the underlying windowing system
interface may offer a different set of configurations for window and pbuffer surfaces.
\note Some platforms may utilize a surfaceless context extension (for example
EGL_KHR_surfaceless_context) when available. In this case there will be no underlying
native surface. For the use cases of QOffscreenSurface (rendering to FBOs, texture
upload) this is not a problem.
|
11994 |
- |
| qoffscreensurface.h |
|
1536 |
- |
| qoffscreensurface_p.h |
|
1464 |
- |
| qoffscreensurface_platform.h |
|
1068 |
- |
| qopenglcontext.cpp |
!
\internal
This function is used by Qt::AA_ShareOpenGLContexts and the Qt
WebEngine to set up context sharing across multiple windows. Do
not use it for any other purpose.
Please maintain the binary compatibility of these functions.
|
46514 |
- |
| qopenglcontext.h |
|
4274 |
- |
| qopenglcontext_p.h |
|
7547 |
- |
| qopenglcontext_platform.h |
|
2743 |
- |
| qpaintdevicewindow.cpp |
!
\class QPaintDeviceWindow
\inmodule QtGui
\since 5.4
\brief Convenience subclass of QWindow that is also a QPaintDevice.
QPaintDeviceWindow is like a regular QWindow, with the added functionality
of being a paint device too. Whenever the content needs to be updated,
the virtual paintEvent() function is called. Subclasses, that reimplement
this function, can then simply open a QPainter on the window.
\note This class cannot directly be used in applications. It rather serves
as a base for subclasses like QOpenGLWindow.
\sa QOpenGLWindow
|
5619 |
- |
| qpaintdevicewindow.h |
|
1163 |
- |
| qpaintdevicewindow_p.h |
|
2094 |
- |
| qpalette.cpp |
!
\internal
Derive undefined \l PlaceholderText colors from \l Text colors.
Unless already set, PlaceholderText colors will be derived from their Text pendents.
Colors of existing PlaceHolderText brushes will not be replaced.
\a alpha represents the dim factor as a percentage. By default, a PlaceHolderText color
becomes a 50% more transparent version of the corresponding Text color.
|
39889 |
- |
| qpalette.h |
|
7673 |
- |
| qpalette_p.h |
|
2458 |
- |
| qpixelformat.cpp |
!
\class QPixelFormat
\inmodule QtGui
\since 5.4
\brief QPixelFormat is a class for describing different pixel
layouts in graphics buffers.
In Qt there is a often a need to represent the layout of the pixels in a
graphics buffer. QPixelFormat can describe up to 5 color channels and 1 alpha
channel, including details about how these channels are represented in memory
individually and in relation to each other.
The typeInterpretation() and byteOrder() determines how each pixel should be
read/interpreted, while alphaSize(), alphaUsage(), alphaPosition(), and
premultiplied() describes the position and properties of the possible alpha
channel.
There is no support for describing YUV's macro pixels. Instead a list of
\l{QPixelFormat::YUVLayout}{YUV formats} is provided. When a QPixelFormat
describes a YUV format, the bitsPerPixel() value is deduced from the YUV layout.
|
24291 |
- |
| qpixelformat.h |
|
17919 |
- |
| qplatformclipboard.cpp |
!
\class QPlatformClipboard
\since 5.0
\internal
\preliminary
\ingroup qpa
\brief The QPlatformClipboard class provides an abstraction for the system clipboard.
|
1867 |
- |
| qplatformclipboard.h |
|
1167 |
- |
| qplatformcursor.cpp |
!
\class QPlatformCursor
\since 5.0
\internal
\preliminary
\ingroup qpa
\brief The QPlatformCursor class provides information about
pointer device events (movement, buttons), and requests to change
the currently displayed cursor.
Note that QPlatformCursor does not include any graphics for
display. An application that sets a QCursor may provide its own
graphics.
\sa QPlatformCursorImage
|
29895 |
- |
| qplatformcursor.h |
|
2418 |
- |
| qplatformdialoghelper.cpp |
!
\class QPlatformDialogHelper
\since 5.0
\internal
\ingroup qpa
\brief The QPlatformDialogHelper class allows for platform-specific customization of dialogs.
|
29511 |
- |
| qplatformdialoghelper.h |
|
15160 |
- |
| qplatformdrag.cpp |
!
\class QPlatformDrag
\since 5.0
\internal
\preliminary
\ingroup qpa
\brief The QPlatformDrag class provides an abstraction for drag.
|
4594 |
- |
| qplatformdrag.h |
|
1811 |
- |
| qplatformgraphicsbuffer.cpp |
!
\class QPlatformGraphicsBuffer
\inmodule QtGui
\since 5.5
\brief The QPlatformGraphicsBuffer is a windowsystem abstraction for native graphics buffers
Different platforms have different ways of representing graphics buffers. On
some platforms, it is possible to create one graphics buffer that you can bind
to a texture and also get main memory access to the image bits. On the
other hand, on some platforms all graphics buffer abstraction is completely
hidden.
QPlatformGraphicsBuffer is an abstraction of a single Graphics Buffer.
There is no public constructor nor any public factory function.
\internal
|
6546 |
- |
| qplatformgraphicsbuffer.h |
|
2042 |
- |
| qplatformgraphicsbufferhelper.cpp |
!
\namespace QPlatformGraphicsBufferHelper
\inmodule QtGui
\internal
|
8919 |
- |
| qplatformgraphicsbufferhelper.h |
|
763 |
- |
| qplatforminputcontext.cpp |
!
\class QPlatformInputContext
\since 5.0
\internal
\preliminary
\ingroup qpa
\brief The QPlatformInputContext class abstracts the input method dependent data and composing state.
An input method is responsible for inputting complex text that cannot
be inputted via simple keymap. It converts a sequence of input
events (typically key events) into a text string through the input
method specific converting process. The class of the processes are
widely ranging from simple finite state machine to complex text
translator that pools a whole paragraph of a text with text
editing capability to perform grammar and semantic analysis.
To abstract such different input method specific intermediate
information, Qt offers the QPlatformInputContext as base class. The
concept is well known as 'input context' in the input method
domain. An input context is created for a text widget in response
to a demand. It is ensured that an input context is prepared for
an input method before input to a text widget.
QPlatformInputContext provides an interface the actual input methods
can derive from by reimplementing methods.
\sa QInputMethod
|
11070 |
- |
| qplatforminputcontext.h |
|
2363 |
- |
| qplatforminputcontext_p.h |
|
910 |
- |
| qplatforminputcontextfactory.cpp |
|
2188 |
- |
| qplatforminputcontextfactory_p.h |
|
1005 |
- |
| qplatforminputcontextplugin.cpp |
|
490 |
- |
| qplatforminputcontextplugin_p.h |
|
1140 |
- |
| qplatformintegration.cpp |
!
Accessor for the platform integration's fontdatabase.
Default implementation returns a default QPlatformFontDatabase.
\sa QPlatformFontDatabase
|
23729 |
- |
| qplatformintegration.h |
|
6949 |
- |
| qplatformintegrationfactory.cpp |
!
\internal
Returns the list of valid keys, i.e. the keys this factory can
create styles for.
\sa create()
|
1285 |
- |
| qplatformintegrationfactory_p.h |
|
994 |
- |
| qplatformintegrationplugin.cpp |
|
945 |
- |
| qplatformintegrationplugin.h |
|
1219 |
- |
| qplatformkeymapper.cpp |
Should return a list of possible key combinations for the given key event.
For example, given a US English keyboard layout, the key event Shift+5
can represent both a "Shift+5" key combination, as well as just "%".
|
1252 |
- |
| qplatformkeymapper.h |
|
952 |
- |
| qplatformmenu.cpp |
|
1251 |
- |
| qplatformmenu.h |
|
4537 |
- |
| qplatformmenu_p.h |
|
1261 |
- |
| qplatformnativeinterface.cpp |
!
\class QPlatformNativeInterface
\since 5.0
\internal
\preliminary
\ingroup qpa
\brief The QPlatformNativeInterface class provides an abstraction for retrieving native
resource handles.
|
3929 |
- |
| qplatformnativeinterface.h |
|
2984 |
- |
| qplatformoffscreensurface.cpp |
!
Returns the platform screen handle corresponding to this QPlatformOffscreenSurface.
|
1278 |
- |
| qplatformoffscreensurface.h |
|
1727 |
- |
| qplatformopenglcontext.cpp |
!
\class QPlatformOpenGLContext
\since 4.8
\internal
\preliminary
\ingroup qpa
\brief The QPlatformOpenGLContext class provides an abstraction for native GL contexts.
In QPA the way to support OpenGL or OpenVG or other technologies that requires a native GL
context is through the QPlatformOpenGLContext wrapper.
There is no factory function for QPlatformOpenGLContexts, but rather only one accessor function.
The only place to retrieve a QPlatformOpenGLContext from is through a QPlatformWindow.
The context which is current for a specific thread can be collected by the currentContext()
function. This is how QPlatformOpenGLContext also makes it possible to use the Qt GUI module
withhout using QOpenGLWidget. When using QOpenGLContext::currentContext(), it will ask
QPlatformOpenGLContext for the currentContext. Then a corresponding QOpenGLContext will be returned,
which maps to the QPlatformOpenGLContext.
|
4782 |
- |
| qplatformopenglcontext.h |
|
3073 |
- |
| qplatformscreen.cpp |
!
This function is called when Qt needs to be able to grab the content of a window.
Returns the content of the window specified with the WId handle within the boundaries of
QRect(x,y,width,height).
|
15425 |
- |
| qplatformscreen.h |
|
5121 |
- |
| qplatformscreen_p.h |
|
2305 |
- |
| qplatformservices.cpp |
!
\class QPlatformServices
\since 5.0
\internal
\preliminary
\ingroup qpa
\brief The QPlatformServices provides the backend for desktop-related functionality.
|
2444 |
- |
| qplatformservices.h |
|
1446 |
- |
| qplatformsessionmanager.cpp |
|
2347 |
- |
| qplatformsessionmanager.h |
|
2148 |
- |
| qplatformsharedgraphicscache.cpp |
!
\class QPlatformSharedGraphicsCache
\since 5.0
\internal
\preliminary
\ingroup qpa
\brief The QPlatformSharedGraphicsCache is an abstraction of a cross-process graphics cache.
If supported, it is possible to retrieve a QPlatformSharedGraphicsCache object from the
platform integration. This is typically used to store graphical items which should be shared
between several processes.
Items are requested from the cache by calling requestItems(). If the cache contains the
requested items in the requested cache, the itemsAvailable() signal is emitted with the ID of
the graphical buffer and each item's coordinates inside the buffer. Before requesting items
from a cache, the user must call ensureCacheInitialized() to set the correct parameters for
the cache.
If the cache does not yet contain the requested items, it will emit a similar itemsMissing()
signal. The client can then call updateItems() with rasterizations of the items and they will be
entered into the shared cache. As the items are rendered into the cache, itemsAvailable() signals
will be emitted for each of the items which have previously been requested and which have not
yet been reported as ready.
Using beginRequestBatch() and endRequestBatch(), it's possible to batch glyph requests, which
could improve performance in cases where you have a sequence of requests pending, and you
do not need the results during this sequence.
|
11837 |
- |
| qplatformsharedgraphicscache.h |
|
2371 |
- |
| qplatformsurface.cpp |
!
\class QPlatformSurface
\since 5.0
\internal
\preliminary
\ingroup qpa
\brief The QPlatformSurface class provides an abstraction for a surface.
|
1382 |
- |
| qplatformsurface.h |
|
1275 |
- |
| qplatformsystemtrayicon.cpp |
!
\class QPlatformSystemTrayIcon
\inmodule QtGui
\brief The QPlatformSystemTrayIcon class abstracts the system tray icon and interaction.
\internal
\sa QSystemTrayIcon
|
4690 |
- |
| qplatformsystemtrayicon.h |
|
1863 |
- |
| qplatformtheme.cpp |
!
\class QPlatformTheme
\since 5.0
\internal
\preliminary
\ingroup qpa
\brief The QPlatformTheme class allows customizing the UI based on themes.
See the init_platform function in qguiapplication.cpp for the complete
platform initialization process.
|
49730 |
- |
| qplatformtheme.h |
|
9193 |
- |
| qplatformtheme_p.h |
|
1061 |
- |
| qplatformthemefactory.cpp |
!
\internal
Returns the list of valid keys, i.e. the keys this factory can
create styles for.
\sa create()
|
1419 |
- |
| qplatformthemefactory_p.h |
|
907 |
- |
| qplatformthemeplugin.cpp |
!
\class QPlatformThemePlugin
\since 5.0
\internal
\preliminary
\ingroup qpa
\brief The QPlatformThemePlugin class provides an abstraction for theme plugins.
|
633 |
- |
| qplatformthemeplugin.h |
|
1046 |
- |
| qplatformwindow.cpp |
!
Constructs a platform window with the given top level window.
|
32888 |
- |
| qplatformwindow.h |
|
4686 |
- |
| qplatformwindow_p.h |
|
5338 |
- |
| qpointingdevice.cpp |
!
\class QPointingDevice
\brief The QPointingDevice class describes a device from which mouse, touch or tablet events originate.
\since 6.0
\ingroup events
\inmodule QtGui
Each QPointerEvent contains a QPointingDevice pointer to allow accessing
device-specific properties like type and capabilities. It is the
responsibility of the platform or generic plug-ins to register the
available pointing devices via QWindowSystemInterface before generating any
pointer events. Applications do not need to instantiate this class, they
should just access the global instances pointed to by QPointerEvent::device().
|
32361 |
- |
| qpointingdevice.h |
|
4712 |
- |
| qpointingdevice_p.h |
! \internal
This struct (stored in activePoints) holds persistent state between event deliveries.
|
4730 |
- |
| qrasterwindow.cpp |
!
\class QRasterWindow
\inmodule QtGui
\since 5.4
\brief QRasterWindow is a convenience class for using QPainter on a QWindow.
QRasterWindow is a QWindow with a raster-based, non-OpenGL surface. On top of
the functionality offered by QWindow, QRasterWindow adds a virtual
paintEvent() function and the possibility to open a QPainter on itself. The
underlying paint engine will be the raster one, meaning that all drawing will
happen on the CPU. For performing accelerated, OpenGL-based drawing, use
QOpenGLWindow instead.
Internally the class is thin wrapper for QWindow and QBackingStore
and is very similar to the \l{Raster Window Example}{Raster Window
Example} that uses these classes directly.
\sa QPaintDeviceWindow::paintEvent(), QPaintDeviceWindow::update()
|
2959 |
- |
| qrasterwindow.h |
|
807 |
- |
| qscreen.cpp |
!
\class QScreen
\since 5.0
\brief The QScreen class is used to query screen properties.
\inmodule QtGui
A note on logical vs physical dots per inch: physical DPI is based on the
actual physical pixel sizes when available, and is useful for print preview
and other cases where it's desirable to know the exact physical dimensions
of screen displayed contents.
Logical dots per inch are used to convert font and user interface elements
from point sizes to pixel sizes, and might be different from the physical
dots per inch. The logical dots per inch are sometimes user-settable in the
desktop environment's settings panel, to let the user globally control UI
and font sizes in different applications.
\note Both physical and logical DPI are expressed in device-independent dots.
Multiply by QScreen::devicePixelRatio() to get device-dependent density.
To obtain a QScreen object, use QGuiApplication::primaryScreen() for the
primary screen, or QGuiApplication::screens() to get a list of all screens.
\sa QGuiApplication::primaryScreen()
\sa QGuiApplication::screens()
\inmodule QtGui
|
27739 |
- |
| qscreen.h |
|
5462 |
- |
| qscreen_p.h |
|
1473 |
- |
| qscreen_platform.h |
|
1620 |
- |
| qsessionmanager.cpp |
!
\class QSessionManager
\brief The QSessionManager class provides access to the session manager.
\inmodule QtGui
A session manager in a desktop environment (in which Qt GUI applications
live) keeps track of a session, which is a group of running applications,
each of which has a particular state. The state of an application contains
(most notably) the documents the application has open and the position and
size of its windows.
The session manager is used to save the session, e.g., when the machine is
shut down, and to restore a session, e.g., when the machine is started up.
We recommend that you use QSettings to save an application's settings,
for example, window positions, recently used files, etc. When the
application is restarted by the session manager, you can restore the
settings.
QSessionManager provides an interface between the application and the
platform's session manager. In Qt, session management requests for action
are handled by the two signals QGuiApplication::commitDataRequest() and
QGuiApplication::saveStateRequest(). Both provide a reference to a
QSessionManager object as argument. The session manager can only be
accessed in slots invoked by these signals.
No user interaction is possible \e unless the application gets explicit
permission from the session manager. You ask for permission by calling
allowsInteraction() or, if it is really urgent, allowsErrorInteraction().
Qt does not enforce this, but the session manager may.
You can try to abort the shutdown process by calling cancel().
For sophisticated session managers provided on Unix/X11, QSessionManager
offers further possibilities to fine-tune an application's session
management behavior: setRestartCommand(), setDiscardCommand(),
setRestartHint(), setProperty(), requestPhase2(). See the respective
function descriptions for further details.
\sa QGuiApplication, {Session Management}
|
12921 |
- |
| qsessionmanager.h |
|
1632 |
- |
| qsessionmanager_p.h |
|
1113 |
- |
| qshapedpixmapdndwindow.cpp |
|
2225 |
- |
| qshapedpixmapdndwindow_p.h |
|
1209 |
- |
| qshortcut.cpp |
!
\class QShortcut
\brief The QShortcut class is used to create keyboard shortcuts.
\ingroup events
\inmodule QtGui
The QShortcut class provides a way of connecting keyboard
shortcuts to Qt's \l{signals and slots} mechanism, so that
objects can be informed when a shortcut is executed. The shortcut
can be set up to contain all the key presses necessary to
describe a keyboard shortcut, including the states of modifier
keys such as \uicontrol Shift, \uicontrol Ctrl, and \uicontrol Alt.
\target mnemonic
In widget applications, certain widgets can use '&' in front of a character.
This will automatically create a mnemonic (a shortcut) for that character,
e.g. "E&xit" will create the shortcut \uicontrol Alt+X (use '&&'
to display an actual ampersand). The widget might consume and perform
an action on a given shortcut. On X11 the ampersand will not be
shown and the character will be underlined. On Windows, shortcuts
are normally not displayed until the user presses the \uicontrol Alt
key, but this is a setting the user can change. On Mac, shortcuts
are disabled by default. Call \l qt_set_sequence_auto_mnemonic() to
enable them. However, because mnemonic shortcuts do not fit in
with Aqua's guidelines, Qt will not show the shortcut character
underlined.
For applications that use menus, it may be more convenient to
use the convenience functions provided in the QMenu class to
assign keyboard shortcuts to menu items as they are created.
Alternatively, shortcuts may be associated with other types of
actions in the QAction class.
The simplest way to create a shortcut for a particular widget is
to construct the shortcut with a key sequence. For example:
\snippet code/src_gui_kernel_qshortcut.cpp 0
When the user types the \l{QKeySequence}{key sequence}
for a given shortcut, the shortcut's activated() signal is
emitted. (In the case of ambiguity, the activatedAmbiguously()
signal is emitted.) A shortcut is "listened for" by Qt's event
loop when the shortcut's parent widget is receiving events.
A shortcut's key sequence can be set with setKey() and retrieved
with key(). A shortcut can be enabled or disabled with
setEnabled(), and can have "What's This?" help text set with
setWhatsThis().
\sa QShortcutEvent, QKeySequence, QAction
|
18840 |
- |
| qshortcut.h |
|
9082 |
- |
| qshortcut_p.h |
\internal
Private data accessed through d-pointer.
|
1444 |
- |
| qshortcutmap.cpp |
\internal
Entry data for QShortcutMap
Contains:
Keysequence for entry
Pointer to parent owning the sequence
|
23104 |
- |
| qshortcutmap_p.h |
|
2276 |
- |
| qsimpledrag.cpp |
!
\class QBasicDrag
\brief QBasicDrag is a base class for implementing platform drag and drop.
\since 5.0
\internal
\ingroup qpa
QBasicDrag implements QPlatformDrag::drag() by running a local event loop in which
it tracks mouse movements and moves the drag icon (QShapedPixmapWindow) accordingly.
It provides new virtuals allowing for querying whether the receiving window
(within the Qt application or outside) accepts the drag and sets the state accordingly.
|
15220 |
- |
| qsimpledrag_p.h |
|
3202 |
- |
| qstylehints.cpp |
!
\class QStyleHints
\since 5.0
\brief The QStyleHints class contains platform specific hints and settings.
\inmodule QtGui
An object of this class, obtained from QGuiApplication, provides access to certain global
user interface parameters of the current platform.
The platform provides most of these settings, and they are typically read-only.
End users can usually adjust them through platform-specific configuration mechanisms.
However, you can also adjust some settings programmatically through dedicated setter
functions, (for example, setColorScheme() or setShowShortcutsInContextMenus()),
which can be useful for testing or specialized application behavior. Any such adjustments
apply only to the current application.
Authors of custom user interface components should read
relevant settings to allow the components to exhibit the same behavior and feel as other
components.
\sa QGuiApplication::styleHints()
|
26305 |
- |
| qstylehints.h |
|
7645 |
- |
| qstylehints_p.h |
|
1762 |
- |
| qsurface.cpp |
!
\class QSurface
\inmodule QtGui
\since 5.0
\brief The QSurface class is an abstraction of renderable surfaces in Qt.
The size of the surface is accessible with the size() function. The rendering
specific attributes of the surface are accessible through the format() function.
|
3497 |
- |
| qsurface.h |
|
1446 |
- |
| qsurfaceformat.cpp |
!
\class QSurfaceFormat
\since 5.0
\brief The QSurfaceFormat class represents the format of a QSurface.
\inmodule QtGui
The format includes the size of the color buffers, red, green, and blue;
the size of the alpha buffer; the size of the depth and stencil buffers;
and number of samples per pixel for multisampling. In addition, the format
contains surface configuration parameters such as OpenGL profile and
version for rendering, whether or not to enable stereo buffers, and swap
behaviour.
\note When troubleshooting context or window format issues, it can be
helpful to enable the logging category \c{qt.qpa.gl}. Depending on the
platform, this may print useful debug information when it comes to OpenGL
initialization and the native visual or framebuffer configurations which
QSurfaceFormat gets mapped to.
|
24019 |
- |
| qsurfaceformat.h |
|
4163 |
- |
| qt_gui_pch.h |
This is a precompiled header file for use in Xcode / Mac GCC /
GCC >= 3.4 / VC to greatly speed the building of Qt. It may also be
of use to people developing their own project, but it is probably
better to define your own header. Use of this header is currently
UNSUPPORTED.
|
878 |
- |
| qtestsupport_gui.cpp |
!
\since 5.0
\overload
The \a timeout is in milliseconds.
|
18458 |
- |
| qtestsupport_gui.h |
|
5143 |
- |
| qtguiglobal.h |
|
355 |
- |
| qtguiglobal_p.h |
|
626 |
- |
| qwindow.cpp |
|
105678 |
- |
| qwindow.h |
|
12147 |
- |
| qwindow_p.h |
|
5342 |
- |
| qwindowdefs.h |
|
1399 |
- |
| qwindowdefs_win.h |
|
1444 |
- |
| qwindowsysteminterface.cpp |
!
\internal
The QWindowSystemHelper creates synchronously delivered events on the stack, unless
the calling thread is not the Gui thread.
Asynchronously delivered events, and events created outside the Gui thread are
allocated on the heap.
|
57747 |
- |
| qwindowsysteminterface.h |
|
18501 |
- |
| qwindowsysteminterface_p.h |
|
21053 |
- |