qtpy/uic.py

   1 import os
   2
   3 from . import PYSIDE6, PYSIDE2, PYQT5, PYQT6
   4 from .QtWidgets import QComboBox
   5
   6
   7 if PYQT6:
   8
   9     from PyQt6.uic import *
  10
  11 elif PYQT5:
  12
  13     from PyQt5.uic import *
  14
  15 else:
  16
  17     __all__ = ['loadUi', 'loadUiType']
  18
  19     # In PySide, loadUi does not exist, so we define it using QUiLoader, and
  20     # then make sure we expose that function. This is adapted from qt-helpers
  21     # which was released under a 3-clause BSD license:
  22     # qt-helpers - a common front-end to various Qt modules
  23     #
  24     # Copyright (c) 2015, Chris Beaumont and Thomas Robitaille
  25     #
  26     # All rights reserved.
  27     #
  28     # Redistribution and use in source and binary forms, with or without
  29     # modification, are permitted provided that the following conditions are
  30     # met:
  31     #
  32     #  * Redistributions of source code must retain the above copyright
  33     #    notice, this list of conditions and the following disclaimer.
  34     #  * Redistributions in binary form must reproduce the above copyright
  35     #    notice, this list of conditions and the following disclaimer in the
  36     #    documentation and/or other materials provided with the
  37     #    distribution.
  38     #  * Neither the name of the Glue project nor the names of its contributors
  39     #    may be used to endorse or promote products derived from this software
  40     #    without specific prior written permission.
  41     #
  42     # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
  43     # IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
  44     # THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  45     # PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
  46     # CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  47     # EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  48     # PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  49     # PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  50     # LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  51     # NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  52     # SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  53     #
  54     # Which itself was based on the solution at
  55     #
  56     # https://gist.github.com/cpbotha/1b42a20c8f3eb9bb7cb8
  57     #
  58     # which was released under the MIT license:
  59     #
  60     # Copyright (c) 2011 Sebastian Wiesner <lunaryorn@gmail.com>
  61     # Modifications by Charl Botha <cpbotha@vxlabs.com>
  62     #
  63     # Permission is hereby granted, free of charge, to any person obtaining a
  64     # copy of this software and associated documentation files (the "Software"),
  65     # to deal in the Software without restriction, including without limitation
  66     # the rights to use, copy, modify, merge, publish, distribute, sublicense,
  67     # and/or sell copies of the Software, and to permit persons to whom the
  68     # Software is furnished to do so, subject to the following conditions:
  69     #
  70     # The above copyright notice and this permission notice shall be included in
  71     # all copies or substantial portions of the Software.
  72     #
  73     # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  74     # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  75     # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  76     # THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  77     # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  78     # FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  79     # DEALINGS IN THE SOFTWARE.
  80
  81     if PYSIDE6:
  82         from PySide6.QtCore import QMetaObject
  83         from PySide6.QtUiTools import QUiLoader
  84     elif PYSIDE2:
  85         from PySide2.QtCore import QMetaObject
  86         from PySide2.QtUiTools import QUiLoader
  87         try:
  88             from pyside2uic import compileUi
  89             # Patch UIParser as xml.etree.Elementree.Element.getiterator
  90             # was deprecated since Python 3.2 and removed in Python 3.9
  91             # https://docs.python.org/3.9/whatsnew/3.9.html#removed
  92             from pyside2uic.uiparser import UIParser
  93             from xml.etree.ElementTree import Element
  94             class ElemPatched(Element):
  95                 def getiterator(self, *args, **kwargs):
  96                     return self.iter(*args, **kwargs)
  97             def readResources(self, elem):
  98                 return self._readResources(ElemPatched(elem))
  99             UIParser._readResources = UIParser.readResources
 100             UIParser.readResources = readResources
 101         except ImportError:
 102             pass
 103
 104     class UiLoader(QUiLoader):
 105         """
 106         Subclass of :class:`~PySide.QtUiTools.QUiLoader` to create the user
 107         interface in a base instance.
 108
 109         Unlike :class:`~PySide.QtUiTools.QUiLoader` itself this class does not
 110         create a new instance of the top-level widget, but creates the user
 111         interface in an existing instance of the top-level class if needed.
 112
 113         This mimics the behaviour of :func:`PyQt4.uic.loadUi`.
 114         """
 115
 116         def __init__(self, baseinstance, customWidgets=None):
 117             """
 118             Create a loader for the given ``baseinstance``.
 119
 120             The user interface is created in ``baseinstance``, which must be an
 121             instance of the top-level class in the user interface to load, or a
 122             subclass thereof.
 123
 124             ``customWidgets`` is a dictionary mapping from class name to class
 125             object for custom widgets. Usually, this should be done by calling
 126             registerCustomWidget on the QUiLoader, but with PySide 1.1.2 on
 127             Ubuntu 12.04 x86_64 this causes a segfault.
 128
 129             ``parent`` is the parent object of this loader.
 130             """
 131
 132             QUiLoader.__init__(self, baseinstance)
 133
 134             self.baseinstance = baseinstance
 135
 136             if customWidgets is None:
 137                 self.customWidgets = {}
 138             else:
 139                 self.customWidgets = customWidgets
 140
 141         def createWidget(self, class_name, parent=None, name=''):
 142             """
 143             Function that is called for each widget defined in ui file,
 144             overridden here to populate baseinstance instead.
 145             """
 146
 147             if parent is None and self.baseinstance:
 148                 # supposed to create the top-level widget, return the base
 149                 # instance instead
 150                 return self.baseinstance
 151
 152             else:
 153
 154                 # For some reason, Line is not in the list of available
 155                 # widgets, but works fine, so we have to special case it here.
 156                 if class_name in self.availableWidgets() or class_name == 'Line':
 157                     # create a new widget for child widgets
 158                     widget = QUiLoader.createWidget(self, class_name, parent, name)
 159
 160                 else:
 161                     # If not in the list of availableWidgets, must be a custom
 162                     # widget. This will raise KeyError if the user has not
 163                     # supplied the relevant class_name in the dictionary or if
 164                     # customWidgets is empty.
 165                     try:
 166                         widget = self.customWidgets[class_name](parent)
 167                     except KeyError as error:
 168                         raise Exception(
 169                             f'No custom widget {class_name} '
 170                             'found in customWidgets'
 171                             ) from error
 172
 173                 if self.baseinstance:
 174                     # set an attribute for the new child widget on the base
 175                     # instance, just like PyQt4.uic.loadUi does.
 176                     setattr(self.baseinstance, name, widget)
 177
 178                 return widget
 179
 180     def _get_custom_widgets(ui_file):
 181         """
 182         This function is used to parse a ui file and look for the <customwidgets>
 183         section, then automatically load all the custom widget classes.
 184         """
 185
 186         import sys
 187         import importlib
 188         from xml.etree.ElementTree import ElementTree
 189
 190         # Parse the UI file
 191         etree = ElementTree()
 192         ui = etree.parse(ui_file)
 193
 194         # Get the customwidgets section
 195         custom_widgets = ui.find('customwidgets')
 196
 197         if custom_widgets is None:
 198             return {}
 199
 200         custom_widget_classes = {}
 201
 202         for custom_widget in list(custom_widgets):
 203
 204             cw_class = custom_widget.find('class').text
 205             cw_header = custom_widget.find('header').text
 206
 207             module = importlib.import_module(cw_header)
 208
 209             custom_widget_classes[cw_class] = getattr(module, cw_class)
 210
 211         return custom_widget_classes
 212
 213     def loadUi(uifile, baseinstance=None, workingDirectory=None):
 214         """
 215         Dynamically load a user interface from the given ``uifile``.
 216
 217         ``uifile`` is a string containing a file name of the UI file to load.
 218
 219         If ``baseinstance`` is ``None``, the a new instance of the top-level
 220         widget will be created. Otherwise, the user interface is created within
 221         the given ``baseinstance``. In this case ``baseinstance`` must be an
 222         instance of the top-level widget class in the UI file to load, or a
 223         subclass thereof. In other words, if you've created a ``QMainWindow``
 224         interface in the designer, ``baseinstance`` must be a ``QMainWindow``
 225         or a subclass thereof, too. You cannot load a ``QMainWindow`` UI file
 226         with a plain :class:`~PySide.QtGui.QWidget` as ``baseinstance``.
 227
 228         :method:`~PySide.QtCore.QMetaObject.connectSlotsByName()` is called on
 229         the created user interface, so you can implemented your slots according
 230         to its conventions in your widget class.
 231
 232         Return ``baseinstance``, if ``baseinstance`` is not ``None``. Otherwise
 233         return the newly created instance of the user interface.
 234         """
 235
 236         # We parse the UI file and import any required custom widgets
 237         customWidgets = _get_custom_widgets(uifile)
 238
 239         loader = UiLoader(baseinstance, customWidgets)
 240
 241         if workingDirectory is not None:
 242             loader.setWorkingDirectory(workingDirectory)
 243
 244         widget = loader.load(uifile)
 245         QMetaObject.connectSlotsByName(widget)
 246         return widget
 247
 248     def loadUiType(uifile, from_imports=False):
 249         """Load a .ui file and return the generated form class and
 250         the Qt base class.
 251
 252         The "loadUiType" command convert the ui file to py code
 253         in-memory first and then execute it in a special frame to
 254         retrieve the form_class.
 255
 256         Credit: https://stackoverflow.com/a/14195313/15954282
 257         """
 258
 259         import sys
 260         from io import StringIO
 261         from xml.etree.ElementTree import ElementTree
 262
 263         from . import QtWidgets
 264
 265         # Parse the UI file
 266         etree = ElementTree()
 267         ui = etree.parse(uifile)
 268
 269         widget_class = ui.find('widget').get('class')
 270         form_class = ui.find('class').text
 271
 272         with open(uifile, encoding="utf-8") as fd:
 273             code_stream = StringIO()
 274             frame = {}
 275
 276             compileUi(fd, code_stream, indent=0, from_imports=from_imports)
 277             pyc = compile(code_stream.getvalue(), '<string>', 'exec')
 278             exec(pyc, frame)
 279
 280             # Fetch the base_class and form class based on their type in the
 281             # xml from designer
 282             form_class = frame['Ui_%s' % form_class]
 283             base_class = getattr(QtWidgets, widget_class)
 284
 285         return form_class, base_class