# This is the PyQt5 build script.
#
# Copyright (c) 2023 Riverbank Computing Limited <info@riverbankcomputing.com>
# 
# This file is part of PyQt5.
# 
# This file may be used under the terms of the GNU General Public License
# version 3.0 as published by the Free Software Foundation and appearing in
# the file LICENSE included in the packaging of this file.  Please review the
# following information to ensure the GNU General Public License version 3.0
# requirements will be met: http://www.gnu.org/copyleft/gpl.html.
# 
# If you do not wish to use this file under the terms of the GPL version 3.0
# then you may purchase a commercial license.  For more information contact
# info@riverbankcomputing.com.
# 
# This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
# WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.


import glob
import os
import sys

from pyqtbuild import PyQtBindings, PyQtProject, QmakeTargetInstallable
from sipbuild import (Buildable, BuildableModule, Installable, Option,
        UserException)


# The minimum sip module ABI version needed.
ABI_VERSION = '12.13'


class PyQt(PyQtProject):
    """ The PyQt5 project. """

    def __init__(self):
        """ Initialise the project. """

        # We specify the name of the sip module because PyQt-builder doesn't
        # provide it if we are creating an sdist.
        super().__init__(abi_version=ABI_VERSION, sip_module='PyQt5.sip',
                dunder_init=True, tag_prefix='Qt', console_scripts=[
                    'pylupdate5 = PyQt5.pylupdate_main:main',
                    'pyrcc5 = PyQt5.pyrcc_main:main',
                    'pyuic5 = PyQt5.uic.pyuic:main'])

        # Each set of bindings must appear after any set they depend on.
        self.bindings_factories = [QtCore, QtNetwork, QtGui, QtWidgets, QtQml,
            QAxContainer, QtAndroidExtras, QtBluetooth, QtDBus, QtDesigner,
            Enginio, QtHelp, QtMacExtras, QtMultimedia, QtMultimediaWidgets,
            QtNfc, QtOpenGL, QtPositioning, QtLocation, QtPrintSupport,
            QtQuick, QtQuick3D, QtQuickWidgets, QtRemoteObjects, QtSensors,
            QtSerialPort, QtSql, QtSvg, QtTest, QtTextToSpeech, QtWebChannel,
            QtWebKit, QtWebKitWidgets, QtWebSockets, QtWinExtras, QtX11Extras,
            QtXml, QtXmlPatterns, Qt, _QOpenGLFunctions_2_0,
            _QOpenGLFunctions_2_1, _QOpenGLFunctions_4_1_Core,
            _QOpenGLFunctions_ES2, pylupdate, pyrcc]

    def apply_user_defaults(self, tool):
        """ Set default values where needed. """

        if self.license_dir is None:
            self.license_dir = os.path.join(self.root_dir, 'sip')
        else:
            self.license_dir = os.path.abspath(self.license_dir)

        super().apply_user_defaults(tool)

        if not self.tools:
            self.console_scripts = []

    def get_dunder_init(self):
        """ Return the contents of the __init__.py file to install. """

        with open(os.path.join(self.root_dir, '__init__.py')) as f:
            dunder_init = f.read()

        if self.py_platform == 'win32':
            dunder_init += """

def find_qt():
    import os, sys

    qtcore_dll = '\\\\Qt5Core.dll'

    dll_dir = os.path.dirname(sys.executable)
    if not os.path.isfile(dll_dir + qtcore_dll):
        path = os.environ['PATH']

        dll_dir = os.path.dirname(__file__) + '\\\\Qt5\\\\bin'
        if os.path.isfile(dll_dir + qtcore_dll):
            path = dll_dir + ';' + path
            os.environ['PATH'] = path
        else:
            for dll_dir in path.split(';'):
                if os.path.isfile(dll_dir + qtcore_dll):
                    break
            else:
                return

    try:
        os.add_dll_directory(dll_dir)
    except AttributeError:
        pass


find_qt()
del find_qt
"""

        return dunder_init

    def get_options(self):
        """ Return the sequence of configurable options. """

        # Get the standard options.
        options = super().get_options()

        # Add our new options.
        options.append(
                Option('confirm_license', option_type=bool,
                        help="confirm acceptance of the license"))

        options.append(
                Option('license_dir', option_type=str,
                        help="the license file can be found in DIR",
                        metavar="DIR"))

        options.append(
                Option('qt_shared', option_type=bool,
                        help="assume Qt has been built as shared libraries"))

        options.append(
                Option('designer_plugin', option_type=bool, inverted=True,
                        help="disable the building of the Python plugin for Qt Designer"))

        options.append(
                Option('qml_plugin', option_type=bool, inverted=True,
                        help="disable the building of the Python plugin for qmlscene"))

        options.append(
                Option('dbus', option_type=str,
                        help="the directory containing the dbus/dbus-python.h file",
                        metavar="DIR"))

        options.append(
                Option('dbus_python', option_type=bool, inverted=True,
                        help="disable the Qt support for the dbus-python package"))

        options.append(
                Option('tools', option_type=bool, inverted=True,
                        help="disable the building of pyuic5, pyrcc5 and pylupdate5"))

        return options

    def update(self, tool):
        """ Update the configuration. """

        if tool not in Option.BUILD_TOOLS:
            return

        # Check we support the version of Qt.
        if self.builder.qt_version >> 16 != 5:
            raise UserException(
                    "Qt v5 is required, not v{0}".format(
                            self.builder.qt_version_str))

        # Automatically confirm the license if there might not be a command
        # line option to do so.
        if tool == 'pep517':
            self.confirm_license = True

        self._check_license()

        # Handle the platform tag (allowing for win32-g++).
        if self.py_platform.startswith('win32'):
            plattag = 'WS_WIN'
        elif self.py_platform == 'darwin':
            plattag = 'WS_MACX'
        else:
            plattag = 'WS_X11'

        self.bindings['QtCore'].tags.append(plattag)

        # Make sure the bindings are buildable.
        super().update(tool)

        # PyQtWebEngine needs to know if QtWebChannel is available.
        if 'QtWebChannel' not in self.bindings:
            qtcore = self.bindings.get('QtCore')
            if qtcore is not None:
                qtcore.disabled_features.append('PyQt_WebChannel')

        # Add the composite module.
        if 'Qt' in self.bindings:
            self._add_composite_module()

        # Always install the uic module.
        installable = Installable('uic', target_subdir='PyQt5')
        installable.files.append(os.path.join(self.root_dir, 'pyuic', 'uic'))
        self.installables.append(installable)

        # If any set of bindings is being built as a debug version then assume
        # the plugins and DBus support should as well.
        for bindings in self.bindings.values():
            if bindings.debug:
                others_debug = True
                break
        else:
            others_debug = self.py_debug

        # Add the plugins.  For the moment we don't include them in wheels.
        # This may change when we improve the bundling of Qt.
        if tool in ('build', 'install'):
            if self.designer_plugin and 'QtDesigner' in self.bindings:
                self._add_plugin('designer', "Qt Designer", 'pyqt5',
                        'designer', others_debug)

            if self.qml_plugin and 'QtQml' in self.bindings:
                self._add_plugin('qmlscene', "qmlscene", 'pyqt5qmlplugin',
                        'PyQt5', others_debug)

        # Add the dbus-python support.
        if self.dbus_python:
            self._add_dbus(others_debug)

    def _add_composite_module(self):
        """ Add the bindings for the composite module. """

        sip_file = os.path.join(self.build_dir, 'Qt.sip')
        sip_f = self.open_for_writing(sip_file)

        sip_f.write('''%CompositeModule PyQt5.Qt

''')

        for bindings in self.bindings.values():
            if not bindings.internal:
                sip_f.write(
                        '%Include {}\n'.format(
                                bindings.sip_file.replace('\\', '/')))

        sip_f.close()

        self.bindings['Qt'].sip_file = sip_file

    def _add_dbus(self, debug):
        """ Add the dbus-python support. """

        self.progress(
                "Checking to see if the dbus-python support should be built")

        # See if dbus-python is installed.
        try:
            import dbus.mainloop
        except ImportError:
            self.progress(
                    "The dbus-python package does not seem to be installed.")
            return

        dbus_module_dir = dbus.mainloop.__path__[0]

        # Get the flags for the DBus library.
        dbus_inc_dirs = []
        dbus_lib_dirs = []
        dbus_libs = []

        args = ['pkg-config', '--cflags-only-I', '--libs dbus-1']

        for line in self.read_command_pipe(args, fatal=False):
            for flag in line.strip().split():
                if flag.startswith('-I'):
                    dbus_inc_dirs.append(flag[2:])
                elif flag.startswith('-L'):
                    dbus_lib_dirs.append(flag[2:])
                elif flag.startswith('-l'):
                    dbus_libs.append(flag[2:])

        if not any([dbus_inc_dirs, dbus_lib_dirs, dbus_libs]):
            self.progress("DBus v1 does not seem to be installed.")

        # Try and find dbus-python.h.  The current PyPI package doesn't install
        # it.  We look where DBus itself is installed.
        if self.dbus:
            dbus_inc_dirs.append(self.dbus)

        for d in dbus_inc_dirs:
            if os.path.isfile(os.path.join(d, 'dbus', 'dbus-python.h')):
                break
        else:
            self.progress(
                    "dbus/dbus-python.h could not be found and so the "
                    "dbus-python support module will be disabled. If "
                    "dbus-python is installed then use the --dbus argument to "
                    "explicitly specify the directory containing "
                    "dbus/dbus-python.h.")
            return

        # Create the buildable.
        sources_dir = os.path.join(self.root_dir, 'dbus')

        buildable = BuildableModule(self, 'dbus', 'dbus.mainloop.pyqt5',
                uses_limited_api=True)
        buildable.builder_settings.append('QT -= gui')
        buildable.sources.extend(glob.glob(os.path.join(sources_dir, '*.cpp')))
        buildable.headers.extend(glob.glob(os.path.join(sources_dir, '*.h')))
        buildable.include_dirs.extend(dbus_inc_dirs)
        buildable.library_dirs.extend(dbus_lib_dirs)
        buildable.libraries.extend(dbus_libs)
        buildable.debug = debug

        self.buildables.append(buildable)

    def _add_plugin(self, name, user_name, target_name, target_subdir, debug):
        """ Add a plugin to the project buildables. """

        builder = self.builder

        # Check we have a shared interpreter library.
        if not self.py_pylib_shlib:
            self.progress("The {0} plugin was disabled because a shared Python library couldn't be found.".format(user_name))
            return

        # Where the plugin will (eventually) be installed.
        target_plugin_dir = os.path.join(
                builder.qt_configuration['QT_INSTALL_PLUGINS'], target_subdir)

        # Create the buildable and add it to the builder.
        buildable = Buildable(self, name)
        self.buildables.append(buildable)

        # The platform-specific name of the plugin file.
        if self.py_platform == 'win32':
            target_name = target_name + '.dll'
        elif self.py_platform == 'darwin':
            target_name = 'lib' + target_name + '.dylib'
        else:
            target_name = 'lib' + target_name + '.so'

        # Create the corresponding installable.
        installable = QmakeTargetInstallable(target_name, target_plugin_dir)
        buildable.installables.append(installable)

        # Create the .pro file.
        self.progress(
                "Generating the {0} plugin .pro file".format(user_name))

        root_plugin_dir = os.path.join(self.root_dir, name)

        with open(os.path.join(root_plugin_dir, name + '.pro-in')) as f:
            prj = f.read()

        prj = prj.replace('@QTCONFIG@', 'debug' if debug else 'release')
        prj = prj.replace('@PYINCDIR@',
                builder.qmake_quote(self.py_include_dir))
        prj = prj.replace('@SIPINCDIR@', builder.qmake_quote(self.build_dir))
        prj = prj.replace('@PYLINK@',
                '-L{} -l{}'.format(self.py_pylib_dir, self.py_pylib_lib))
        prj = prj.replace('@PYSHLIB@', self.py_pylib_shlib)
        prj = prj.replace('@QTPLUGINDIR@',
                builder.qmake_quote(target_plugin_dir))

        # Write the .pro file.
        pro_path = os.path.join(buildable.build_dir, name + '.pro')
        pro_f = self.open_for_writing(pro_path)

        pro_f.write(prj)

        pro_f.write('''
INCLUDEPATH += {}
VPATH = {}
'''.format(builder.qmake_quote(root_plugin_dir), builder.qmake_quote(root_plugin_dir)))

        pro_f.write('\n'.join(builder.qmake_settings) + '\n')

        pro_f.close()

    def _check_license(self):
        """ Handle the validation of the PyQt5 license. """

        # We read the license.py file as data.
        license_py = os.path.join(self.root_dir, 'license.py')

        if os.path.isfile(license_py):
            ltype = lname = lfile = None

            with open(license_py) as lf:
                for line in lf:
                    parts = line.split('=')
                    if len(parts) == 2:
                        name, value = parts

                        name = name.strip()
                        value = value.strip()[1:-1]

                        if name == 'LicenseType':
                            ltype = value
                        elif name == 'LicenseName':
                            lname = value
                        elif name == 'LicenseFile':
                            lfile = value

            if lname is None or lfile is None:
                ltype = None
        else:
            ltype = None

        # Default to the GPL.
        if ltype is None:
            ltype = 'GPL'
            lname = "GNU General Public License"
            lfile = 'pyqt-gpl.sip'

        self.progress(
                "This is the {0} version of PyQt {1} (licensed under the {2}) "
                        "for Python {3} on {4}.".format(
                                ltype, self.version_str, lname,
                                sys.version.split()[0], sys.platform))

        # Confirm the license if not already done.
        if not self.confirm_license:
            loptions = """
Type 'L' to view the license.
"""

            sys.stdout.write(loptions)
            sys.stdout.write("""Type 'yes' to accept the terms of the license.
Type 'no' to decline the terms of the license.

""")

            while True:
                sys.stdout.write("Do you accept the terms of the license? ")
                sys.stdout.flush()

                try:
                    resp = sys.stdin.readline()
                except KeyboardInterrupt:
                    raise SystemExit
                except:
                    resp = ""

                resp = resp.strip().lower()

                if resp == "yes":
                    break

                if resp == "no":
                    sys.exit()

                if resp == 'l':
                    os.system('more LICENSE')

        # Check that the license file exists and fix its syntax.
        src_lfile = os.path.join(self.license_dir, lfile)

        if os.path.isfile(src_lfile):
            self.progress("Found the license file '{0}'.".format(lfile))
            self._fix_license(src_lfile,
                    os.path.join(self.build_dir, lfile + '5'))

            # Make sure sip can find the license file.
            self.sip_include_dirs.append(self.build_dir)
        else:
            raise UserException(
                    "Please copy the license file '{0}' to '{1}'".format(lfile,
                            self.license_dir))

    def _fix_license(self, src_lfile, dst_lfile):
        """ Copy the license file and fix it so that it conforms to the SIP v5
        syntax.
        """

        with open(src_lfile) as f:
            f5 = self.open_for_writing(dst_lfile)

            for line in f:
                if line.startswith('%License'):
                    anno_start = line.find('/')
                    anno_end = line.rfind('/')

                    if anno_start < 0 or anno_end < 0 or anno_start == anno_end:
                        f5.close()

                        raise UserException(
                                "'{0}' has missing annotations".format(name))

                    annos = line[anno_start + 1:anno_end].split(', ')
                    annos5 = [anno[0].lower() + anno[1:] for anno in annos]

                    f5.write('%License(')
                    f5.write(', '.join(annos5))
                    f5.write(')\n')
                else:
                    f5.write(line)

            f5.close()


class OpenGLBindings(PyQtBindings):
    """ Encapsulate internal OpenGL functions bindings. """

    def __init__(self, project, version):
        """ Initialise the bindings. """

        super().__init__(project, '_QOpenGLFunctions_' + version,
                test_headers=['qopenglfunctions_{}.h'.format(version.lower())],
                test_statement='new QOpenGLFunctions_{}()'.format(version),
                internal=True)

    def is_buildable(self):
        """ Return True if the bindings are buildable. """

        # Check that the QtGui bindings are being built.
        qtgui = self.project.bindings.get('QtGui')
        if qtgui is None:
            return False

        # Check if all OpenGL support is disabled.
        if 'PyQt_OpenGL' in qtgui.disabled_features:
            return False

        # Check if OpenGL desktop support has been disabled.
        if 'PyQt_Desktop_OpenGL' in qtgui.disabled_features:
            if self.is_desktop_opengl():
                return False
        else:
            if not self.is_desktop_opengl():
                return False

        # Run the standard configuration checks.
        return super().is_buildable()

    def is_desktop_opengl(self):
        """ Return True if the bindings are for desktop OpenGL. """

        return True


class Qt(PyQtBindings):
    """ The Qt composite module. """

    def __init__(self, project):
        """ Initialise the bindings. """

        # We specify 'internal' to avoid the generation of .api and .pyi files
        # and the installation of the .sip files.
        super().__init__(project, 'Qt', qmake_QT=['-core', '-gui'],
                internal=True)


class QAxContainer(PyQtBindings):
    """ The QAxContainer bindings. """

    def __init__(self, project):
        """ Initialise the bindings. """

        super().__init__(project, 'QAxContainer', qmake_QT=['axcontainer'],
                test_headers=['qaxobject.h'], test_statement='new QAxObject()')


class QtAndroidExtras(PyQtBindings):
    """ The QtAndroidExtras bindings. """

    def __init__(self, project):
        """ Initialise the bindings. """

        super().__init__(project, 'QtAndroidExtras',
                qmake_QT=['androidextras'], test_headers=['QtAndroid'],
                test_statement='QtAndroid::androidSdkVersion()')


class QtBluetooth(PyQtBindings):
    """ The QtBluetooth bindings. """

    def __init__(self, project):
        """ Initialise the bindings. """

        super().__init__(project, 'QtBluetooth', qmake_QT=['bluetooth'],
                test_headers=['qbluetoothaddress.h'],
                test_statement='new QBluetoothAddress()')


class QtCore(PyQtBindings):
    """ The QtCore bindings. """

    def __init__(self, project):
        """ Initialise the bindings. """

        super().__init__(project, 'QtCore', qmake_QT=['-gui'],
                define_macros=['QT_KEYPAD_NAVIGATION'])

    def generate(self):
        """ Generate the bindings source code and return the corresponding
        buildable.
        """

        # This is re-implemented so that we can update the buildable to include
        # the embedded sip flags.  Note that this support is deprecated and can
        # be removed once support for sip4 has been dropped.

        project = self.project

        # The embedded flags.
        sip_flags = ['-n', project.sip_module]

        if project.py_debug:
            sip_flags.append('-D')

        for tag in self.tags:
            sip_flags.append('-t')
            sip_flags.append(tag)

        for bindings in project.bindings.values():
            for feature in bindings.disabled_features:
                sip_flags.append('-x')
                sip_flags.append(feature)

        buildable = super().generate()

        cpp = 'qpycore_post_init.cpp'
        in_path = os.path.join(project.root_dir, 'qpy', 'QtCore', cpp + '.in')
        out_path = os.path.join(buildable.build_dir, cpp)

        out_f = project.open_for_writing(out_path)

        with open(in_path) as in_f:
            code = in_f.read()
            code = code.replace('@@PYQT_SIP_FLAGS@@', ' '.join(sip_flags))
            out_f.write(code)

        out_f.close()

        buildable.sources.append(cpp)

        return buildable

    def handle_test_output(self, test_output):
        """ Handle the output from the external test program and return True if
        the bindings are buildable.
        """

        project = self.project

        if not project.qt_shared and test_output[0] == 'shared':
            project.qt_shared = True

        return super().handle_test_output(test_output[1:])


class QtDBus(PyQtBindings):
    """ The QtDBus bindings. """

    def __init__(self, project):
        """ Initialise the bindings. """

        super().__init__(project, 'QtDBus', qmake_QT=['dbus', '-gui'],
                test_headers=['qdbusconnection.h'],
                test_statement='QDBusConnection::systemBus()')


class QtDesigner(PyQtBindings):
    """ The QtDesigner bindings. """

    def __init__(self, project):
        """ Initialise the bindings. """

        super().__init__(project, 'QtDesigner', qmake_QT=['designer'],
                test_headers=['QExtensionFactory', 'customwidget.h'],
                test_statement='new QExtensionFactory()')

    def is_buildable(self):
        """ Return True if the bindings are buildable. """

        project = self.project

        if not project.qt_shared:
            project.progress(
                    "The QtDesigner bindings are disabled with a static Qt "
                    "installation")
            return False

        return super().is_buildable()


class Enginio(PyQtBindings):
    """ The Enginio bindings. """

    def __init__(self, project):
        """ Initialise the bindings. """

        super().__init__(project, 'Enginio', qmake_QT=['enginio'],
                test_headers=['enginioclient.h'],
                test_statement='new EnginioClient()')


class QtGui(PyQtBindings):
    """ The QtGui bindings. """

    def __init__(self, project):
        """ Initialise the bindings. """

        super().__init__(project, 'QtGui')


class QtHelp(PyQtBindings):
    """ The QtHelp bindings. """

    def __init__(self, project):
        """ Initialise the bindings. """

        super().__init__(project, 'QtHelp', qmake_QT=['help'],
                test_headers=['qhelpengine.h'],
                test_statement='new QHelpEngine("foo")')


class QtLocation(PyQtBindings):
    """ The QtLocation bindings. """

    def __init__(self, project):
        """ Initialise the bindings. """

        super().__init__(project, 'QtLocation', qmake_QT=['location'],
                test_headers=['qplace.h'], test_statement='new QPlace()')


class QtMacExtras(PyQtBindings):
    """ The QtMacExtras bindings. """

    def __init__(self, project):
        """ Initialise the bindings. """

        super().__init__(project, 'QtMacExtras', qmake_QT=['macextras'],
                test_headers=['qmacpasteboardmime.h'],
                test_statement='class Foo : public QMacPasteboardMime {}')


class QtMultimedia(PyQtBindings):
    """ The QtMultimedia bindings. """

    def __init__(self, project):
        """ Initialise the bindings. """

        super().__init__(project, 'QtMultimedia', qmake_QT=['multimedia'],
                test_headers=['QAudioDeviceInfo'],
                test_statement='new QAudioDeviceInfo()')


class QtMultimediaWidgets(PyQtBindings):
    """ The QtMultimediaWidgets bindings. """

    def __init__(self, project):
        """ Initialise the bindings. """

        super().__init__(project, 'QtMultimediaWidgets',
                qmake_QT=['multimediawidgets', 'multimedia'],
                test_headers=['QVideoWidget'],
                test_statement='new QVideoWidget()')


class QtNetwork(PyQtBindings):
    """ The QtNetwork bindings. """

    def __init__(self, project):
        """ Initialise the bindings. """

        super().__init__(project, 'QtNetwork', qmake_QT=['network', '-gui'])


class QtNfc(PyQtBindings):
    """ The QtNfc bindings. """

    def __init__(self, project):
        """ Initialise the bindings. """

        super().__init__(project, 'QtNfc', qmake_QT=['nfc', '-gui'],
                test_headers=['qnearfieldmanager.h'],
                test_statement='new QNearFieldManager()')


class QtOpenGL(PyQtBindings):
    """ The QtOpenGL bindings. """

    def __init__(self, project):
        """ Initialise the bindings. """

        super().__init__(project, 'QtOpenGL', qmake_QT=['opengl'],
                test_headers=['qgl.h'], test_statement='new QGLWidget()')


class QtPositioning(PyQtBindings):
    """ The QtPositioning bindings. """

    def __init__(self, project):
        """ Initialise the bindings. """

        super().__init__(project, 'QtPositioning', qmake_QT=['positioning'],
                test_headers=['qgeoaddress.h'],
                test_statement='new QGeoAddress()')


class QtPrintSupport(PyQtBindings):
    """ The QtPrintSupport bindings. """

    def __init__(self, project):
        """ Initialise the bindings. """

        super().__init__(project, 'QtPrintSupport', qmake_QT=['printsupport'])


class QtQml(PyQtBindings):
    """ The QtQml bindings. """

    def __init__(self, project):
        """ Initialise the bindings. """

        super().__init__(project, 'QtQml', qmake_QT=['qml'],
                test_headers=['qjsengine.h'], test_statement='new QJSEngine()')


class QtQuick(PyQtBindings):
    """ The QtQuick bindings. """

    def __init__(self, project):
        """ Initialise the bindings. """

        super().__init__(project, 'QtQuick', qmake_QT=['quick'],
                test_headers=['qquickwindow.h'],
                test_statement='new QQuickWindow()')


class QtQuick3D(PyQtBindings):
    """ The QtQuick3D bindings. """

    def __init__(self, project):
        """ Initialise the bindings. """

        super().__init__(project, 'QtQuick3D', qmake_QT=['quick3d'],
                test_headers=['qquick3d.h'],
                test_statement='QQuick3D::idealSurfaceFormat()')


class QtQuickWidgets(PyQtBindings):
    """ The QtQuickWidgets bindings. """

    def __init__(self, project):
        """ Initialise the bindings. """

        super().__init__(project, 'QtQuickWidgets', qmake_QT=['quickwidgets'],
                test_headers=['qquickwidget.h'],
                test_statement='new QQuickWidget()')


class QtRemoteObjects(PyQtBindings):
    """ The QtRemoteObjects bindings. """

    def __init__(self, project):
        """ Initialise the bindings. """

        super().__init__(project, 'QtRemoteObjects',
                qmake_QT=['remoteobjects', '-gui'],
                test_headers=['qtremoteobjectsversion.h'],
                test_statement='const char *v = QTREMOTEOBJECTS_VERSION_STR')


class QtSensors(PyQtBindings):
    """ The QtSensors bindings. """

    def __init__(self, project):
        """ Initialise the bindings. """

        super().__init__(project, 'QtSensors', qmake_QT=['sensors'],
                test_headers=['qsensor.h'],
                test_statement='new QSensor(QByteArray())')


class QtSerialPort(PyQtBindings):
    """ The QtSerialPort bindings. """

    def __init__(self, project):
        """ Initialise the bindings. """

        super().__init__(project, 'QtSerialPort', qmake_QT=['serialport'],
                test_headers=['qserialport.h'],
                test_statement='new QSerialPort()')


class QtSql(PyQtBindings):
    """ The QtSql bindings. """

    def __init__(self, project):
        """ Initialise the bindings. """

        super().__init__(project, 'QtSql', qmake_QT=['sql', 'widgets'],
                test_headers=['qsqldatabase.h'],
                test_statement='new QSqlDatabase()')


class QtSvg(PyQtBindings):
    """ The QtSvg bindings. """

    def __init__(self, project):
        """ Initialise the bindings. """

        super().__init__(project, 'QtSvg', qmake_QT=['svg'],
                test_headers=['qsvgwidget.h'],
                test_statement='new QSvgWidget()')


class QtTest(PyQtBindings):
    """ The QtTest bindings. """

    def __init__(self, project):
        """ Initialise the bindings. """

        super().__init__(project, 'QtTest', qmake_QT=['testlib', 'widgets'],
                test_headers=['QtTest'], test_statement='QTest::qSleep(0)')


class QtTextToSpeech(PyQtBindings):
    """ The QtTextToSpeech bindings. """

    def __init__(self, project):
        """ Initialise the bindings. """

        super().__init__(project, 'QtTextToSpeech',
                qmake_QT=['texttospeech', '-gui'],
                test_headers=['QTextToSpeech'],
                test_statement='new QTextToSpeech()')


class QtWebChannel(PyQtBindings):
    """ The QtWebChannel bindings. """

    def __init__(self, project):
        """ Initialise the bindings. """

        super().__init__(project, 'QtWebChannel',
                qmake_QT=['webchannel', 'network', '-gui'],
                test_headers=['qwebchannel.h'],
                test_statement='new QWebChannel()')


class QtWebKit(PyQtBindings):
    """ The QtWebKit bindings. """

    def __init__(self, project):
        """ Initialise the bindings. """

        super().__init__(project, 'QtWebKit', qmake_QT=['webkit', 'network'],
                test_headers=['qwebkitglobal.h'],
                test_statement='qWebKitVersion()')


class QtWebKitWidgets(PyQtBindings):
    """ The QtWebKitWidgets bindings. """

    def __init__(self, project):
        """ Initialise the bindings. """

        super().__init__(project, 'QtWebKitWidgets',
                qmake_QT=['webkitwidgets', 'printsupport'],
                test_headers=['qwebpage.h'], test_statement='new QWebPage()')


class QtWebSockets(PyQtBindings):
    """ The QtWebSockets bindings. """

    def __init__(self, project):
        """ Initialise the bindings. """

        super().__init__(project, 'QtWebSockets',
                qmake_QT=['websockets', '-gui'], test_headers=['qwebsocket.h'],
                test_statement='new QWebSocket()')


class QtWidgets(PyQtBindings):
    """ The QtWidgets bindings. """

    def __init__(self, project):
        """ Initialise the bindings. """

        super().__init__(project, 'QtWidgets', qmake_QT=['widgets'],
                test_headers=['qwidget.h'], test_statement='new QWidget()')


class QtWinExtras(PyQtBindings):
    """ The QtWinExtras bindings. """

    def __init__(self, project):
        """ Initialise the bindings. """

        super().__init__(project, 'QtWinExtras',
                qmake_QT=['winextras', 'widgets'], test_headers=['QtWin'],
                test_statement='QtWin::isCompositionEnabled()')


class QtX11Extras(PyQtBindings):
    """ The QtX11Extras bindings. """

    def __init__(self, project):
        """ Initialise the bindings. """

        super().__init__(project, 'QtX11Extras', qmake_QT=['x11extras'],
                test_headers=['QX11Info'],
                test_statement='QX11Info::display()')


class QtXml(PyQtBindings):
    """ The QtXml bindings. """

    def __init__(self, project):
        """ Initialise the bindings. """

        super().__init__(project, 'QtXml', qmake_QT=['xml', '-gui'],
                test_headers=['qdom.h'], test_statement='new QDomDocument()')


class QtXmlPatterns(PyQtBindings):
    """ The QtXmlPatterns bindings. """

    def __init__(self, project):
        """ Initialise the bindings. """

        super().__init__(project, 'QtXmlPatterns',
                qmake_QT=['xmlpatterns', '-gui', 'network'],
                test_headers=['qxmlname.h'], test_statement='new QXmlName()')


class _QOpenGLFunctions_2_0(OpenGLBindings):
    """ The _QOpenGLFunctions_2_0 bindings. """

    def __init__(self, project):
        """ Initialise the bindings. """

        super().__init__(project, '2_0')


class _QOpenGLFunctions_2_1(OpenGLBindings):
    """ The _QOpenGLFunctions_2_1 bindings. """

    def __init__(self, project):
        """ Initialise the bindings. """

        super().__init__(project, '2_1')


class _QOpenGLFunctions_4_1_Core(OpenGLBindings):
    """ The _QOpenGLFunctions_4_1_Core bindings. """

    def __init__(self, project):
        """ Initialise the bindings. """

        super().__init__(project, '4_1_Core')


class _QOpenGLFunctions_ES2(OpenGLBindings):
    """ The _QOpenGLFunctions_ES2 bindings. """

    def __init__(self, project):
        """ Initialise the bindings. """

        super().__init__(project, 'ES2')

    def is_desktop_opengl(self):
        """ Return True if the bindings are for desktop OpenGL. """

        return False


class pylupdate(PyQtBindings):
    """ The pylupdate bindings. """

    def __init__(self, project):
        """ Initialise the bindings. """

        super().__init__(project, 'pylupdate', qmake_QT=['xml', '-gui'],
                internal=True)

    def generate(self):
        """ Generate the bindings source code and return the corresponding
        buildable.
        """

        # This is re-implemented so that we can update the buildable to include
        # pylupdate_main.py.

        project = self.project

        buildable = super().generate()

        installable = Installable('pylupdate_main', target_subdir='PyQt5')
        installable.files.append(
                os.path.join(project.root_dir, 'pylupdate',
                        'pylupdate_main.py'))
        buildable.installables.append(installable)

        return buildable

    def is_buildable(self):
        """ Return True if the bindings are buildable. """

        return self.project.tools


class pyrcc(PyQtBindings):
    """ The pyrcc bindings. """

    def __init__(self, project):
        """ Initialise the bindings. """

        super().__init__(project, 'pyrcc', qmake_QT=['xml', '-gui'],
                internal=True)

    def generate(self):
        """ Generate the bindings source code and return the corresponding
        buildable.
        """

        # This is re-implemented so that we can update the buildable to include
        # pyrcc_main.py.

        project = self.project

        buildable = super().generate()

        installable = Installable('pyrcc_main', target_subdir='PyQt5')
        installable.files.append(
                os.path.join(project.root_dir, 'pyrcc', 'pyrcc_main.py'))
        buildable.installables.append(installable)

        return buildable

    def is_buildable(self):
        """ Return True if the bindings are buildable. """

        return self.project.tools