diff options
Diffstat (limited to 'sources/pyside6/PySide6/doc')
-rw-r--r-- | sources/pyside6/PySide6/doc/qtqml_functions.rst | 152 | ||||
-rw-r--r-- | sources/pyside6/PySide6/doc/qtquicktest.rst | 62 | ||||
-rw-r--r-- | sources/pyside6/PySide6/doc/qtuitools.rst | 68 |
3 files changed, 282 insertions, 0 deletions
diff --git a/sources/pyside6/PySide6/doc/qtqml_functions.rst b/sources/pyside6/PySide6/doc/qtqml_functions.rst new file mode 100644 index 000000000..31801b245 --- /dev/null +++ b/sources/pyside6/PySide6/doc/qtqml_functions.rst @@ -0,0 +1,152 @@ +// @snippet qmlregistersingletoninstance +.. py:function:: qmlRegisterSingletonInstance(pytype: type,\ + uri: str,\ + versionMajor: int,\ + versionMinor: int,\ + typeName: str,\ + instanceObject: object) -> int + + :param type pytype: Python class + :param str uri: uri to use while importing the component in QML + :param int versionMajor: major version + :param int versionMinor: minor version + :param str typeName: name exposed to QML + :param object instanceObject: singleton object to be registered + :return: int (the QML type id) + +This function registers a singleton Python object *instanceObject*, with a +particular *uri* and *typeName*. Its version is a combination of *versionMajor* +and *versionMinor*. Use this function to register an object of the given type +*pytype* as a singleton type. +// @snippet qmlregistersingletoninstance + +// @snippet qmlregistersingletontype_qobject_nocallback +.. py:function:: qmlRegisterSingletonType(pytype: type, uri: str, versionMajor: int, versionMinor: int, typeName: str) -> int + + :param type pytype: Python class + :param str uri: uri to use while importing the component in QML + :param int versionMajor: major version + :param int versionMinor: minor version + :param str typeName: name exposed to QML + :return: int (the QML type id) + +This function registers a Python type as a singleton in the QML system. + +Alternatively, the :ref:`QmlSingleton` decorator can be used. +// @snippet qmlregistersingletontype_qobject_nocallback + +// @snippet qmlregistersingletontype_qobject_callback +.. py:function:: qmlRegisterSingletonType(pytype: type, uri: str, versionMajor: int, versionMinor: int, typeName: str, callback: object) -> int + + :param type pytype: Python class + :param str uri: uri to use while importing the component in QML + :param int versionMajor: major version + :param int versionMinor: minor version + :param str typeName: name exposed to QML + :param object callback: Python callable (to handle Python type) + :return: int (the QML type id) + +This function registers a Python type as a singleton in the QML system using +the provided callback (which gets a QQmlEngine as a parameter) to generate the +singleton. +// @snippet qmlregistersingletontype_qobject_callback + +// @snippet qmlregistersingletontype_qjsvalue +.. py:function:: qmlRegisterSingletonType(uri: str, versionMajor: int, versionMinor: int, typeName: str, callback: object) -> int + + :param str uri: uri to use while importing the component in QML + :param int versionMajor: major version + :param int versionMinor: minor version + :param str typeName: name exposed to QML + :param object callback: Python callable (to handle QJSValue) + :return: int (the QML type id) + +This function registers a QJSValue as a singleton in the QML system using the +provided callback (which gets a QQmlEngine as a parameter) to generate the +singleton. +// @snippet qmlregistersingletontype_qjsvalue + +// @snippet qmlregistertype +.. py:function:: qmlRegisterType(pytype: type, uri: str, versionMajor: int, versionMinor: int, qmlName: str) -> int + + :param type pytype: Python class + :param str uri: uri to use while importing the component in QML + :param int versionMajor: major version + :param int versionMinor: minor version + :param str qmlName: name exposed to QML + :return: int (the QML type id) + +This function registers the Python *type* in the QML system with the name +*qmlName*, in the library imported from *uri* having the version number +composed from *versionMajor* and *versionMinor*. For example, this registers a +Python class 'MySliderItem' as a QML type named 'Slider' for version '1.0' of a +module called 'com.mycompany.qmlcomponents': + + :: + + qmlRegisterType(MySliderItem, "com.mycompany.qmlcomponents", 1, 0, "Slider") + +Once this is registered, the type can be used in QML by importing the specified +module name and version number: + + :: + + import com.mycompany.qmlcomponents 1.0 + + Slider { ... } + +Note that it's perfectly reasonable for a library to register types to older +versions than the actual version of the library. Indeed, it is normal for the +new library to allow QML written to previous versions to continue to work, even +if more advanced versions of some of its types are available. +// @snippet qmlregistertype + +// @snippet qmlregisteruncreatabletype +.. py:function:: qmlRegisterUncreatableType(pytype: type, uri: str, versionMajor: int, versionMinor: int, qmlName: str, noCreationReason: str) -> int + + :param type pytype: Python class + :param str uri: uri to use while importing the component in QML + :param int versionMajor: major version + :param int versionMinor: minor version + :param str qmlName: name exposed to QML + :param str noCreationReason: Error message shown when trying to create the QML type + :return: int (the QML type id) + +This function registers the Python *type* in the QML system as an uncreatable +type with the name *qmlName*, in the library imported from *uri* having the +version number composed from *versionMajor* and *versionMinor*, showing +*noCreationReason* as an error message when creating the type is attempted. For +example, this registers a Python class 'MySliderItem' as a QML type named +'Slider' for version '1.0' of a module called 'com.mycompany.qmlcomponents': + + :: + qmlRegisterUncreatableType(MySliderItem, "com.mycompany.qmlcomponents", 1, 0, "Slider", "Slider cannot be created.") + +Note that it's perfectly reasonable for a library to register types to older +versions than the actual version of the library. Indeed, it is normal for the +new library to allow QML written to previous versions to continue to work, even +if more advanced versions of some of its types are available. + +Alternatively, the :ref:`QmlUncreatable` decorator can be used. +// @snippet qmlregisteruncreatabletype + +// @snippet qqmlengine-singletoninstance-qmltypeid +Returns the instance of a singleton type that was registered under qmlTypeId. +For ``QObject``-derived singleton types, the ``QObject`` instance is returned, +otherwise a ``QJSValue`` or ``None``. + +It is recommended to store the QML type id, e.g. as a static member in the +singleton class. The lookup via qmlTypeId() is costly. +// @snippet qqmlengine-singletoninstance-qmltypeid + +// @snippet qqmlengine-singletoninstance-typename Returns the instance of a +singleton type named typeName from the module specified by uri. +For ``QObject``-derived singleton types, the ``QObject`` instance is returned, +otherwise a ``QJSValue`` or ``None``. + +This method can be used as an alternative to calling qmlTypeId followed by the +id based overload of singletonInstance. This is convenient when one only needs +to do a one time setup of a singleton; if repeated access to the singleton is +required, caching its typeId will allow faster subsequent access via the +type-id based overload. +// @snippet qqmlengine-singletoninstance-typename diff --git a/sources/pyside6/PySide6/doc/qtquicktest.rst b/sources/pyside6/PySide6/doc/qtquicktest.rst new file mode 100644 index 000000000..9df2af071 --- /dev/null +++ b/sources/pyside6/PySide6/doc/qtquicktest.rst @@ -0,0 +1,62 @@ +// @snippet quick_test_main_documentation + +Sets up the entry point for a Qt Quick Test application. +The ``name`` argument uniquely identifies this set of tests. + +``sys.argv`` should be passed to the ``argv`` argument to ensure +propagation of the command line arguments. + +.. note:: The function assumes that your test sources are in the current + directory, unless the ``QUICK_TEST_SOURCE_DIR`` environment + variable is set or a directory is passed in ``dir``. + +The following snippet demonstrates the use of this function: + +.. code-block:: Python + + import sys + from PySide6.QtQuickTest import QUICK_TEST_MAIN + + ex = QUICK_TEST_MAIN("example", sys.argv) + sys.exit(ex) + + +// @snippet quick_test_main_documentation + +// @snippet quick_test_main_with_setup_documentation + +Sets up the entry point for a Qt Quick Test application. +The ``name`` argument uniquely identifies this set of tests. + +``sys.argv`` should be passed to the ``argv`` argument to ensure +propagation of the command line arguments. + +This function is identical to ``QUICK_TEST_MAIN()``, except that it takes an +additional argument ``setup``, the type of a ``QObject``-derived +class which will be instantiated. With this class, it is possible to define +additional setup code to execute before running the QML test. + +The following snippet demonstrates the use of this function: + +.. code-block:: Python + + import sys + from PySide6.QtQuickTest import QUICK_TEST_MAIN_WITH_SETUP + + class CustomTestSetup(QObject): + def __init__(self, parent=None): + super().__init__(parent) + + @Slot(QQmlEngine) + def qmlEngineAvailable(self, qmlEngine): + pass + + ex = QUICK_TEST_MAIN_WITH_SETUP("qquicktestsetup", CustomTestSetup, sys.argv) + sys.exit(ex) + + +.. note:: The function assumes that your test sources are in the current + directory, unless the ``QUICK_TEST_SOURCE_DIR`` environment + variable is set or a directory is passed in ``dir``. + +// @snippet quick_test_main_with_setup_documentation diff --git a/sources/pyside6/PySide6/doc/qtuitools.rst b/sources/pyside6/PySide6/doc/qtuitools.rst new file mode 100644 index 000000000..a8856f1af --- /dev/null +++ b/sources/pyside6/PySide6/doc/qtuitools.rst @@ -0,0 +1,68 @@ +// @snippet quiloader-registercustomwidget +Registers a Python created custom widget to QUiLoader, so it can be recognized +when loading a `.ui` file. The custom widget type is passed via the +``customWidgetType`` argument. This is needed when you want to override a +virtual method of some widget in the interface, since duck punching will not +work with widgets created by QUiLoader based on the contents of the `.ui` file. + +(Remember that +`duck punching virtual methods is an invitation for your own demise! <https://doc.qt.io/qtforpython/shiboken6/wordsofadvice.html#duck-punching-and-virtual-methods>`_) + +Let's see an obvious example. If you want to create a new widget it's probable you'll end up +overriding :class:`~PySide6.QtGui.QWidget`'s :meth:`~PySide6.QtGui.QWidget.paintEvent` method. + +.. code-block:: python + + class Circle(QWidget): + def paintEvent(self, event): + with QPainter(self) as painter: + painter.setPen(self.pen) + painter.setBrush(QBrush(self.color)) + painter.drawEllipse(event.rect().center(), 20, 20) + + # ... + + loader = QUiLoader() + loader.registerCustomWidget(Circle) + circle = loader.load('circle.ui') + circle.show() + + # ... +// @snippet quiloader-registercustomwidget + +// @snippet loaduitype +.. currentmodule:: PySide6.QtUiTools + +loadUiType +*********** +.. py:function:: loadUiType(uifile: str) -> tuple(object, object) + + :param str uifile: The name of the `.ui` file + :return: tuple(object, object) + +This function generates and loads a `.ui` file at runtime, and it returns +a `tuple` containing the reference to the Python class, and the base class. + +We recommend not to use this approach as the workflow should be to generate a Python file +from the `.ui` file, and then import and load it to use it, but we do understand that +there are some corner cases when such functionality is required. + +The internal process relies on `uic` being in the PATH. +The `pyside6-uic` wrapper uses a shipped `uic` that is located in the +`site-packages/PySide6/uic`, so PATH needs to be updated to use that if there +is no `uic` in the system. + +A simple use case is:: + + from PySide6.QtUiTools import loadUiType + + generated_class, base_class = loadUiType("themewidget.ui") + # the values will be: + # (<class '__main__.Ui_ThemeWidgetForm'>, <class 'PySide6.QtWidgets.QWidget'>) + + widget = base_class() + form = generated_class() + form.setupUi(widget) + # form.a_widget_member.a_method_of_member() + widget.show() +// @snippet loaduitype |