| LICENSE.XSVG.txt |
|
1185 |
- |
| qabstractlayoutstyleinfo.cpp |
|
271 |
- |
| qabstractlayoutstyleinfo_p.h |
controls1 |
1831 |
- |
| qastchandler.cpp |
|
4407 |
- |
| qastchandler_p.h |
|
923 |
- |
| qdesktopservices.cpp |
!
\class QDesktopServices
\brief The QDesktopServices class provides methods for accessing common desktop services.
\since 4.2
\ingroup desktop
\inmodule QtGui
Many desktop environments provide services that can be used by applications to
perform common tasks, such as opening a web page, in a way that is both consistent
and takes into account the user's application preferences.
This class contains functions that provide simple interfaces to these services
that indicate whether they succeeded or failed.
The openUrl() function is used to open files located at arbitrary URLs in external
applications. For URLs that correspond to resources on the local filing system
(where the URL scheme is "file"), a suitable application will be used to open the
file; otherwise, a web browser will be used to fetch and display the file.
The user's desktop settings control whether certain executable file types are
opened for browsing, or if they are executed instead. Some desktop environments
are configured to prevent users from executing files obtained from non-local URLs,
or to ask the user's permission before doing so.
\section1 URL Handlers
The behavior of the openUrl() function can be customized for individual URL
schemes to allow applications to override the default handling behavior for
certain types of URLs.
The dispatch mechanism allows only one custom handler to be used for each URL
scheme; this is set using the setUrlHandler() function. Each handler is
implemented as a slot which accepts only a single QUrl argument.
The existing handlers for each scheme can be removed with the
unsetUrlHandler() function. This returns the handling behavior for the given
scheme to the default behavior.
This system makes it easy to implement a help system, for example. Help could be
provided in labels and text browsers using \uicontrol{help://myapplication/mytopic}
URLs, and by registering a handler it becomes possible to display the help text
inside the application:
\snippet code/src_gui_util_qdesktopservices.cpp 0
\snippet code/src_gui_util_qdesktopservices.cpp setUrlHandler
If inside the handler you decide that you can't open the requested
URL, you can just call QDesktopServices::openUrl() again with the
same argument, and it will try to open the URL using the
appropriate mechanism for the user's desktop environment.
Combined with platform specific settings, the schemes registered by the
openUrl() function can also be exposed to other applications, opening up
for application deep linking or a very basic URL-based IPC mechanism.
\sa QSystemTrayIcon, QProcess, QStandardPaths
|
12680 |
- |
| qdesktopservices.h |
|
710 |
- |
| qedidparser.cpp |
Decode the PNP ID from three 5 bit words packed into 2 bytes
/--08--\/--09--\
7654321076543210
|\---/\---/\---/
R C1 C2 C3 |
9253 |
- |
| qedidparser_p.h |
|
1446 |
- |
| qedidvendortable_p.h |
This lookup table was generated from https://github.com/vcrhonek/hwdata/raw/master/pnp.ids
Do not change this file directly, instead edit the
qtbase/util/edid/qedidvendortable.py script and regenerate this file.
|
140751 |
- |
| qgraphicsframecapture.cpp |
|
2680 |
- |
| qgraphicsframecapture_p.h |
|
1286 |
- |
| qgraphicsframecapture_p_p.h |
|
1930 |
- |
| qgraphicsframecapturemetal.mm |
|
5386 |
- |
| qgraphicsframecapturemetal_p_p.h |
|
1610 |
- |
| qgraphicsframecapturerenderdoc.cpp |
!
\class QGraphicsFrameCaptureRenderDoc
\internal
\brief The QGraphicsFrameCaptureRenderDoc class provides a way to capture a record of draw calls
for different graphics APIs.
\since 6.6
\inmodule QtGui
For applications that render using graphics APIs like Vulkan or OpenGL, it would be
convenient to have a way to check the draw calls done by the application. Specially
for applications that make a large amount of draw calls and the output is different
from what is expected.
This class acts as a wrapper over \l {https://renderdoc.org/}{RenderDoc} that allows
applications to capture a rendered frame either programmatically, by clicking a key
on the keyboard or both. The captured frame could be viewed later using RenderDoc GUI.
Read the \l {https://renderdoc.org/docs/index.html} {RenderDoc Documentation}
for more information.
\section1 API device handle
The functions that capture a frame like QGraphicsFrameCaptureRenderDoc::startCaptureFrame takes a device
pointer as argument. This pointer is unique for each graphics API and is associated
with the window that will be captured. This pointer has a default value of \c nullptr.
If no value is passed to the function the underlying API will try to find the device to
use, but it is not guaranteed specially in a multi-window applications.
For OpenGL, the pointer should be the OpenGL context on the platform OpenGL is being
used. For example, on Windows it should be \c HGLRC.
For Vulkan, the pointer should point to the dispatch table within the \c VkInstance.
|
11474 |
- |
| qgraphicsframecapturerenderdoc_p_p.h |
|
1346 |
- |
| qgridlayoutengine.cpp |
|
64739 |
- |
| qgridlayoutengine_p.h |
Minimal container to store Qt::Orientation-discriminated values.
The salient feature is the indexing operator, which takes
Qt::Orientation (and assumes it's passed only Qt::Horizontal or Qt::Vertical).
|
16533 |
- |
| qguisvg.cpp |
|
18821 |
- |
| qguisvg_p.h |
|
1812 |
- |
| qhexstring_p.h |
|
1712 |
- |
| qktxhandler.cpp |
quint8 keyAndValue[keyAndValueByteSize];
quint8 valuePadding[3 - ((keyAndValueByteSize + 3) % 4)];
|
13157 |
- |
| qktxhandler_p.h |
|
1101 |
- |
| qlayoutpolicy.cpp |
!
\class QLayoutPolicy
\inmodule QtGui
\internal
|
3058 |
- |
| qlayoutpolicy_p.h |
|
5095 |
- |
| qpkmhandler.cpp |
|
2702 |
- |
| qpkmhandler_p.h |
|
840 |
- |
| qt_attribution.json |
|
786 |
- |
| qtexturefiledata.cpp |
|
9094 |
- |
| qtexturefiledata_p.h |
|
2746 |
- |
| qtexturefilehandler_p.h |
|
1109 |
- |
| qtexturefilereader.cpp |
|
1944 |
- |
| qtexturefilereader_p.h |
|
1211 |
- |
| qundogroup.cpp |
!
\class QUndoGroup
\brief The QUndoGroup class is a group of QUndoStack objects.
\since 4.2
\inmodule QtGui
For an overview of the Qt's undo framework, see the
\l{qundo.html}{overview}.
An application often has multiple undo stacks, one for each opened document. At the
same time, an application usually has one undo action and one redo action, which
triggers undo or redo in the active document.
QUndoGroup is a group of QUndoStack objects, one of which may be active. It has
an undo() and redo() slot, which calls QUndoStack::undo() and QUndoStack::redo()
for the active stack. It also has the functions createUndoAction() and createRedoAction().
The actions returned by these functions behave in the same way as those returned by
QUndoStack::createUndoAction() and QUndoStack::createRedoAction() of the active
stack.
Stacks are added to a group with addStack() and removed with removeStack(). A stack
is implicitly added to a group when it is created with the group as its parent
QObject.
It is the programmer's responsibility to specify which stack is active by
calling QUndoStack::setActive(), usually when the associated document window receives focus.
The active stack may also be set with setActiveStack(), and is returned by activeStack().
When a stack is added to a group using addStack(), the group does not take ownership
of the stack. This means the stack has to be deleted separately from the group. When
a stack is deleted, it is automatically removed from a group. A stack may belong to
only one group. Adding it to another group will cause it to be removed from the previous
group.
A QUndoGroup is also useful in conjunction with QUndoView. If a QUndoView is
set to watch a group using QUndoView::setGroup(), it will update itself to display
the active stack.
|
14733 |
- |
| qundogroup.h |
|
1616 |
- |
| qundostack.cpp |
!
\class QUndoCommand
\brief The QUndoCommand class is the base class of all commands stored on a QUndoStack.
\since 4.2
\inmodule QtGui
For an overview of Qt's Undo Framework, see the
\l{Overview of Qt's Undo Framework}{overview document}.
A QUndoCommand represents a single editing action on a document; for example,
inserting or deleting a block of text in a text editor. QUndoCommand can apply
a change to the document with redo() and undo the change with undo(). The
implementations for these functions must be provided in a derived class.
\snippet code/src_gui_util_qundostack.cpp 0
A QUndoCommand has an associated text(). This is a short string
describing what the command does. It is used to update the text
properties of the stack's undo and redo actions; see
QUndoStack::createUndoAction() and QUndoStack::createRedoAction().
QUndoCommand objects are owned by the stack they were pushed on.
QUndoStack deletes a command if it has been undone and a new command is pushed. For example:
\snippet code/src_gui_util_qundostack.cpp 1
In effect, when a command is pushed, it becomes the top-most command
on the stack.
To support command compression, QUndoCommand has an id() and the virtual function
mergeWith(). These functions are used by QUndoStack::push().
To support command macros, a QUndoCommand object can have any number of child
commands. Undoing or redoing the parent command will cause the child
commands to be undone or redone. A command can be assigned
to a parent explicitly in the constructor. In this case, the command
will be owned by the parent.
The parent in this case is usually an empty command, in that it doesn't
provide its own implementation of undo() and redo(). Instead, it uses
the base implementations of these functions, which simply call undo() or
redo() on all its children. The parent should, however, have a meaningful
text().
\snippet code/src_gui_util_qundostack.cpp 2
Another way to create macros is to use the convenience functions
QUndoStack::beginMacro() and QUndoStack::endMacro().
\sa QUndoStack
|
40732 |
- |
| qundostack.h |
|
3086 |
- |
| qundostack_p.h |
!
\internal
\brief Holds the presentation state for an Undo or Redo command.
This structure serves a change-detection purpose.
|
2493 |
- |
| qvalidator.cpp |
!
\class QValidator
\brief The QValidator class provides validation of input text.
\inmodule QtGui
The class itself is abstract. Two subclasses, \l QIntValidator and
\l QDoubleValidator, provide basic numeric-range checking, and \l
QRegularExpressionValidator provides general checking using a custom regular
expression.
If the built-in validators aren't sufficient, you can subclass
QValidator. The class has two virtual functions: validate() and
fixup().
\l validate() must be implemented by every subclass. It returns
\l Invalid, \l Intermediate or \l Acceptable depending on whether
its argument is valid (for the subclass's definition of valid).
These three states require some explanation. An \l Invalid string
is \e clearly invalid. \l Intermediate is less obvious: the
concept of validity is difficult to apply when the string is
incomplete (still being edited). QValidator defines \l Intermediate
as the property of a string that is neither clearly invalid nor
acceptable as a final result. \l Acceptable means that the string
is acceptable as a final result. One might say that any string
that is a plausible intermediate state during entry of an \l
Acceptable string is \l Intermediate.
Here are some examples:
\list
\li For a line edit that accepts integers from 10 to 1000 inclusive,
42 and 123 are \l Acceptable, the empty string, 5, or 1234 are \l
Intermediate, and "asdf" and 10114 is \l Invalid.
\li For an editable combobox that accepts URLs, any well-formed URL
is \l Acceptable, "http://example.com/," is \l Intermediate
(it might be a cut and paste action that accidentally took in a
comma at the end), the empty string is \l Intermediate (the user
might select and delete all of the text in preparation for entering
a new URL) and "http:///./" is \l Invalid.
\li For a spin box that accepts lengths, "11cm" and "1in" are \l
Acceptable, "11" and the empty string are \l Intermediate, and
"http://example.com" and "hour" are \l Invalid.
\endlist
\l fixup() is provided for validators that can repair some user
errors. The default implementation does nothing. QLineEdit, for
example, will call fixup() if the user presses Enter (or Return)
and the content is not currently valid. This allows the fixup()
function the opportunity of performing some magic to make an \l
Invalid string \l Acceptable.
A validator has a locale, set with setLocale(). It is typically used
to parse localized data. For example, QIntValidator and QDoubleValidator
use it to parse localized representations of integers and doubles.
QValidator is typically used with QLineEdit, QSpinBox and
QComboBox.
\sa QIntValidator, QDoubleValidator, QRegularExpressionValidator, {Line Edits Example}
|
32890 |
- |
| qvalidator.h |
|
4590 |
- |