Пример #1
0
def show_version():
    print("[Pyslvs " + version_number + "]",
          "Python Version: {0:d}.{1:d}.{2:d}".format(*version_info[:3]))
    try:
        try:
            from PyQt5.QtCore import qVersion
        except:
            from PyQt4.QtCore import qVersion
        print("Qt Version: {0}".format(qVersion().strip()))
    except:
        print("No Qt.")
    try:
        try:
            from PyQt5.QtCore import PYQT_VERSION_STR as pyqtVersion
        except:
            from PyQt4.QtCore import PYQT_VERSION_STR as pyqtVersion
        print("PyQt Version:", pyqtVersion.strip())
    except:
        print("No PyQt.")
    try:
        from sip import SIP_VERSION_STR as sipVersion
        print("Sip Version:", sipVersion.strip())
    except:
        print("No Sip.")
    try:
        try:
            from PyQt5.Qsci import QSCINTILLA_VERSION_STR as qsciVersion
        except:
            from PyQt4.Qsci import QSCINTILLA_VERSION_STR as qsciVersion
        print("QScintilla Version:", qsciVersion.strip())
    except:
        print("No QScintilla.")
    print("-------")
Пример #2
0
def compat_getFrameDimensions(frame, cbname):
    if PYQT_VERSION_STR.startswith('4'):
        girth, ok = frame.evaluateJavaScript('document.getElementById("%s").offsetWidth;' % cbname).toInt()
        height, ok = frame.evaluateJavaScript('document.getElementById("%s").offsetHeight;' % cbname).toInt()
    else:
        girth = int(frame.evaluateJavaScript('document.getElementById("%s").offsetWidth;' % cbname))
        height = frame.evaluateJavaScript('document.getElementById("%s").offsetHeight;' % cbname)
    return girth, height
Пример #3
0
def compat_getFrameDimensions(frame, cbname):
    if PYQT_VERSION_STR.startswith('4'):
        girth, ok = frame.evaluateJavaScript('document.getElementById("%s").offsetWidth;' % cbname).toInt()
        height, ok = frame.evaluateJavaScript('document.getElementById("%s").offsetHeight;' % cbname).toInt()
    else:
        girth = int(frame.evaluateJavaScript('document.getElementById("%s").offsetWidth;' % cbname))
        height = frame.evaluateJavaScript('document.getElementById("%s").offsetHeight;' % cbname)
    return girth, height
Пример #4
0
def compat_isNone(state):
    if PYQT_VERSION_STR.startswith('4'):
        return state.isNull()

    # WTF! (QByteArray == None) is True!
    if state is None:
        return True

    return not len(state)
Пример #5
0
    def initialize(self) -> None:
        super().initialize()

        self._mesh_file_handler = MeshFileHandler(self) #type: MeshFileHandler
        self._workspace_file_handler = WorkspaceFileHandler(self) #type: WorkspaceFileHandler

        # For some reason, with Qt 5.9 and up, the default "windows" style seems like Windows 95. We have to set the
        # style to "fusion" so it looks less ugly.
        pyqt_version_parts = [int(n) for n in PYQT_VERSION_STR.split(".")]
        if len(pyqt_version_parts) < 2:  # Make sure there are at less 2 parts in the version
            pyqt_version_parts += [0 for _ in range(2 - len(pyqt_version_parts))]
        if pyqt_version_parts[0] == 5 and pyqt_version_parts[1] > 8:
            self.setStyle("fusion")

        # For some reason, with Qt 5.9 and up, the default "windows" style seems like Windows 95. We have to set the
        # style to "fusion" so it looks less ugly.
        pyqt_version_parts = [int(n) for n in PYQT_VERSION_STR.split(".")]
        if len(pyqt_version_parts) < 2:  # Make sure there are at less 2 parts in the version
            pyqt_version_parts += [0 for _ in range(2 - len(pyqt_version_parts))]
        if pyqt_version_parts[0] == 5 and pyqt_version_parts[1] > 8:
            self.setStyle("fusion")

        self.setAttribute(Qt.AA_UseDesktopOpenGL)
        major_version, minor_version, profile = OpenGLContext.detectBestOpenGLVersion()

        if major_version is None and minor_version is None and profile is None:
            Logger.log("e", "Startup failed because OpenGL version probing has failed: tried to create a 2.0 and 4.1 context. Exiting")
            QMessageBox.critical(None, "Failed to probe OpenGL",
                                 "Could not probe OpenGL. This program requires OpenGL 2.0 or higher. Please check your video card drivers.")
            sys.exit(1)
        else:
            opengl_version_str = OpenGLContext.versionAsText(major_version, minor_version, profile)
            Logger.log("d", "Detected most suitable OpenGL context version: %s", opengl_version_str)
        OpenGLContext.setDefaultFormat(major_version, minor_version, profile = profile)

        self._qml_import_paths.append(os.path.join(os.path.dirname(sys.executable), "qml"))
        self._qml_import_paths.append(os.path.join(self.getInstallPrefix(), "Resources", "qml"))

        Logger.log("i", "Initializing job queue ...")
        self._job_queue = JobQueue()
        self._job_queue.jobFinished.connect(self._onJobFinished)

        Logger.log("i", "Initializing version upgrade manager ...")
        self._version_upgrade_manager = VersionUpgradeManager(self)
Пример #6
0
def compat_strList(dwcls):
    if PYQT_VERSION_STR.startswith('4'):
        return dwcls.toStringList()
    return dwcls
Пример #7
0
def compat_toByteArray(strobj):
    if PYQT_VERSION_STR.startswith('4'):
        return strobj.toByteArray()
    return strobj
Пример #8
0
def compat_toStr(qstate):
    if PYQT_VERSION_STR.startswith('4'):
        return str(qstate.toString())
    return str(qstate)
Пример #9
0
#    GNU General Public License for more details.
#
#    You should have received a copy of the GNU General Public License
#    along with this program; if not, write to the Free Software
#    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

print('Qtvcp python plugin found:',__file__)
# HAL only widgets
from qtvcp.plugins.simplewidgets_plugin import *
from qtvcp.plugins.led_plugin import LEDPlugin
from qtvcp.plugins.hal_label_plugin import HALLabelPlugin
from qtvcp.plugins.detach_tabs_plugin import DetachTabWidgetPlugin
from qtvcp.plugins.round_progress_bar_plugin import RoundProgressBarPlugin
from PyQt5.QtCore import PYQT_VERSION_STR
try:
    v = PYQT_VERSION_STR.split('.')
    if int(v[1]) > 10:
        from qtvcp.plugins.joypad_plugin import *
except:
    print('PyQt version {} to old for JoyPad widget'.format(PYQT_VERSION_STR))

# plain widgets
from qtvcp.plugins.nurbs_editor_plugin import NurbsEditorPlugin

# Linuxcnc widgets
from qtvcp.plugins.container_plugin import StateEnableGridLayoutPlugin
from qtvcp.plugins.container_plugin import JointEnableWidgetPlugin
from qtvcp.plugins.graphics_plugin import GCodeGraphicsPlugin
from qtvcp.plugins.widgets_plugin import *
from qtvcp.plugins.state_led_plugin import StateLEDPlugin
from qtvcp.plugins.status_label_plugin import StatusLabelPlugin
Пример #10
0
    try:
        sip.setapi('QString', 2)
        sip.setapi('QVariant', 2)
    except AttributeError:
        # PyQt < v4.6. The actual check is done by requirements.check_qt()
        # call from spyder.py
        pass

    try:
        from PyQt4.QtCore import PYQT_VERSION_STR as __version__  # analysis:ignore
    except ImportError:
        # Switching to PySide
        API = os.environ['QT_API'] = 'pyside'
        API_NAME = 'PySide'
    else:
        is_old_pyqt = __version__.startswith(('4.4', '4.5', '4.6', '4.7'))
        is_pyqt46 = __version__.startswith('4.6')
        import sip
        try:
            API_NAME += (" (API v%d)" % sip.getapi('QString'))
        except AttributeError:
            pass

if API == 'pyside':
    try:
        from PySide import __version__  # analysis:ignore
    except ImportError:
        raise ImportError("Spyder requires PySide or PyQt to be installed")
    else:
        is_old_pyqt = is_pyqt46 = False
Пример #11
0
            sip.setapi('QDateTime', 2)
            sip.setapi('QTextStream', 2)
            sip.setapi('QTime', 2)
            sip.setapi('QUrl', 2)
        except (AttributeError, ValueError):
            # PyQt < v4.6
            pass
        from PyQt4.Qt import PYQT_VERSION_STR as PYQT_VERSION  # analysis:ignore
        from PyQt4.Qt import QT_VERSION_STR as QT_VERSION  # analysis:ignore
        PYSIDE_VERSION = None
        PYQT5 = False
        PYQT4 = True
    except ImportError:
        API = os.environ['QT_API'] = 'pyside'
    else:
        is_old_pyqt = PYQT_VERSION.startswith(('4.4', '4.5', '4.6', '4.7'))
        is_pyqt46 = PYQT_VERSION.startswith('4.6')

if API in PYSIDE_API:
    try:
        from PySide import __version__ as PYSIDE_VERSION  # analysis:ignore
        from PySide.QtCore import __version__ as QT_VERSION  # analysis:ignore
        PYQT_VERSION = None
        PYQT5 = PYSIDE2 = False
        PYSIDE = True
    except ImportError:
        raise PythonQtError('No Qt bindings could be found')

# If a correct API name is passed to QT_API and it could not be found,
# switches to another and informs through the warning
if API != initial_api and binding_specified:
Пример #12
0
# Qt内嵌谷歌引擎BUG太多,实在是不好用->改用开源谷歌引擎  目前部分替换
from PyQt5.QtCore import PYQT_VERSION_STR, QCoreApplication, Qt, QProcess
# 判断版本号
if int(PYQT_VERSION_STR.replace('.', '')) >= 560:
    from PyQt5.QtWebEngineWidgets import *
    # 处理闪屏、黑屏问题 必须放在 Application 实例化前
    QCoreApplication.setAttribute(Qt.AA_UseSoftwareOpenGL)
else:
    from PyQt5.QtWebKit import *
    from PyQt5.QtWebKitWidgets import *

import multiprocessing, requests, platform, ctypes
from multiprocessing import Process, Queue
from importlib import import_module
from utils.envir import *


# 主界面
def main_ui(ui, app):
    if gol.get_value('ui_show', 0) == 0:
        ui.showMaximized()
    elif gol.get_value('ui_show', 0) == 1:
        ui.showFullScreen()
    else:
        ui.show()
    app.exec_()


#
def equip_ui(ui, app):
    ui.show()
the correct python and PyQt versions. In case this fails, error messages are written to
stderr and we exit with returncode ERR_CODE.

Module Attributes:
    PYQT_VERSION: The currently installed PyQt version as tuple if any.
    PYQT_REQUIRED_VERSION: The minimum PyQt version required.
    PYTHON_REQUIRED_VERSION: The minimum python version required.
    ERR_CODE: Returncode used with sys.exit.
"""

import sys

try:
    from PyQt5.QtCore import PYQT_VERSION_STR

    PYQT_VERSION = tuple(map(int, PYQT_VERSION_STR.split(".")))
except ImportError:  # pragma: no cover  # PyQt is there in tests, using None is tested
    # We check explicitly for None before using the tuple version
    PYQT_VERSION = None  # type: ignore

PYTHON_REQUIRED_VERSION = (3, 6)
PYQT_REQUIRED_VERSION = (5, 9, 2)
ERR_CODE = 2


def check_python_version():
    """Ensure the python version is new enough."""
    if sys.version_info < PYTHON_REQUIRED_VERSION:
        _exit_version("python", PYTHON_REQUIRED_VERSION, sys.version_info[:3])

Пример #14
0
##but WITHOUT ANY WARRANTY; without even the implied warranty of
##MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
##GNU Affero General Public License for more details.
##
##You should have received a copy of the GNU Affero General Public License
##along with this program; if not, write to the Free Software
##Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

from sys import version_info
import platform
import argparse
import requests
try:
    from PyQt5.QtCore import qVersion, PYQT_VERSION_STR
    Qt_Version = qVersion().strip()
    PyQt_Version = PYQT_VERSION_STR.strip()
except ImportError:
    Qt_Version = "No Qt"
    PyQt_Version = "No PyQt"

VERSION = (18, 2, 0, 'release')

INFO = (
    "Pyslvs {}.{}.{}({})".format(*VERSION),
    "OS Type: {} {} [{}]".format(platform.system(), platform.release(),
                                 platform.machine()),
    "Python Version: {v.major}.{v.minor}.{v.micro}({v.releaselevel})".format(
        v=version_info), "Python Compiler: {}".format(
            platform.python_compiler()), "Qt Version: {}".format(Qt_Version),
    "PyQt Version: {}".format(PyQt_Version))
Пример #15
0
            sip.setapi("QTextStream", 2)
            sip.setapi("QTime", 2)
            sip.setapi("QUrl", 2)
        except AttributeError:
            # PyQt < v4.6
            pass
        from PyQt4.Qt import PYQT_VERSION_STR as PYQT_VERSION  # analysis:ignore
        from PyQt4.Qt import QT_VERSION_STR as QT_VERSION  # analysis:ignore

        PYSIDE_VERSION = None
        PYQT5 = False
        PYQT4 = True
    except ImportError:
        API = os.environ["QT_API"] = "pyside"
    else:
        is_old_pyqt = PYQT_VERSION.startswith(("4.4", "4.5", "4.6", "4.7"))
        is_pyqt46 = PYQT_VERSION.startswith("4.6")

if API in PYSIDE_API:
    try:
        from PySide import __version__ as PYSIDE_VERSION  # analysis:ignore
        from PySide.QtCore import __version__ as QT_VERSION  # analysis:ignore

        PYQT_VERSION = None
        PYQT5 = PYSIDE2 = False
        PYSIDE = True
    except ImportError:
        raise PythonQtError("No Qt bindings could be found")

# If a correct API name is passed to QT_API and it could not be found,
# switches to another and informs through the warning
Пример #16
0
            sip.setapi('QDateTime', 2)
            sip.setapi('QTextStream', 2)
            sip.setapi('QTime', 2)
            sip.setapi('QUrl', 2)
        except (AttributeError, ValueError):
            # PyQt < v4.6
            pass
        from PyQt4.Qt import PYQT_VERSION_STR as PYQT_VERSION  # analysis:ignore
        from PyQt4.Qt import QT_VERSION_STR as QT_VERSION  # analysis:ignore
        PYSIDE_VERSION = None
        PYQT5 = False
        PYQT4 = True
    except ImportError:
        API = os.environ['QT_API'] = 'pyside'
    else:
        is_old_pyqt = PYQT_VERSION.startswith(('4.4', '4.5', '4.6', '4.7'))
        is_pyqt46 = PYQT_VERSION.startswith('4.6')

if API in PYSIDE_API:
    try:
        from PySide import __version__ as PYSIDE_VERSION  # analysis:ignore
        from PySide.QtCore import __version__ as QT_VERSION  # analysis:ignore
        PYQT_VERSION = None
        PYQT5 = PYSIDE2 = False
        PYSIDE = True
    except ImportError:
        raise PythonQtError('No Qt bindings could be found')

# If a correct API name is passed to QT_API and it could not be found,
# switches to another and informs through the warning
if API != initial_api:
Пример #17
0
                                 QDoubleValidator, QFocusEvent, QFont,
                                 QKeyEvent, QKeySequence, QIcon, QImage,
                                 QImageWriter, QIntValidator, QLinearGradient,
                                 QMouseEvent, QMovie, QPainter, QPainterPath,
                                 QPalette, QPen, QPixmap, QPolygon,
                                 QRegExpValidator, QTextCursor, QValidator)
        from PyQt5.uic import loadUi

        QStringList = list
        getQApp = QCoreApplication.instance
        qApp = QCoreApplication.instance

        qt_imported = True
        qt_variant = "PyQt5"
        qt_version_no = list(map(int, QT_VERSION_STR.split(".")))
        _ver = PYQT_VERSION_STR.split(".")
        ver = _ver + ["0"] * (3 - len(_ver))
        pyqt_version_no = list(map(int, ver))[:3]
    except ImportError:
        pass

    try:
        from PyQt5.QtWebKit import QWebPage
    except ImportError:
        pass

#
# PyQt4
#
if (qt_variant == "PyQt4") or (qt_variant is None and not qt_imported):
    #
Пример #18
0
from UM.Mesh.ReadMeshJob import ReadMeshJob

import UM.Qt.Bindings.Theme
from UM.PluginRegistry import PluginRegistry
MYPY = False
if MYPY:
    from PyQt5.QtCore import QObject


# Raised when we try to use an unsupported version of a dependency.
class UnsupportedVersionError(Exception):
    pass


# Check PyQt version, we only support 5.4 or higher.
major, minor = PYQT_VERSION_STR.split(".")[0:2]
if int(major) < 5 or int(minor) < 4:
    raise UnsupportedVersionError(
        "This application requires at least PyQt 5.4.0")


##  Application subclass that provides a Qt application object.
@signalemitter
class QtApplication(QApplication, Application):
    pluginsLoaded = Signal()
    applicationRunning = Signal()

    def __init__(self, tray_icon_name=None, **kwargs):
        plugin_path = ""
        if sys.platform == "win32":
            if hasattr(sys, "frozen"):
Пример #19
0
            sip.setapi('QDateTime', 2)
            sip.setapi('QTextStream', 2)
            sip.setapi('QTime', 2)
            sip.setapi('QUrl', 2)
        except AttributeError:
            # PyQt < v4.6. The actual check is done by requirements.check_qt()
            # call from spyder.py
            pass

        from PyQt4.QtCore import PYQT_VERSION_STR as __version__ # analysis:ignore
    except ImportError:
        # Switching to PySide
        API = os.environ['QT_API'] = 'pyside'
        API_NAME = 'PySide'
    else:
        is_old_pyqt = __version__.startswith(('4.4', '4.5', '4.6', '4.7'))
        is_pyqt46 = __version__.startswith('4.6')
        import sip
        try:
            API_NAME += (" (API v%d)" % sip.getapi('QString'))
        except AttributeError:
            pass

if API == 'pyside':
    try:
        from PySide import __version__  # analysis:ignore
    except ImportError:
        raise ImportError("Spyder requires PySide or PyQt to be installed")
    else:
        is_old_pyqt = is_pyqt46 = False
Пример #20
0
from UM.Qt.Bindings.Bindings import Bindings
from UM.Signal import Signal, signalemitter
from UM.Resources import Resources
from UM.Logger import Logger
from UM.Preferences import Preferences
from UM.i18n import i18nCatalog
import UM.Settings.InstanceContainer #For version upgrade to know the version number.
import UM.Settings.ContainerStack #For version upgrade to know the version number.
import UM.Preferences #For version upgrade to know the version number.

# Raised when we try to use an unsupported version of a dependency.
class UnsupportedVersionError(Exception):
    pass

# Check PyQt version, we only support 5.4 or higher.
major, minor = PYQT_VERSION_STR.split(".")[0:2]
if int(major) < 5 or int(minor) < 4:
    raise UnsupportedVersionError("This application requires at least PyQt 5.4.0")

##  Application subclass that provides a Qt application object.
@signalemitter
class QtApplication(QApplication, Application):
    def __init__(self, **kwargs):
        plugin_path = ""
        if sys.platform == "win32":
            if hasattr(sys, "frozen"):
                plugin_path = os.path.join(os.path.dirname(os.path.abspath(sys.executable)), "PyQt5", "plugins")
                Logger.log("i", "Adding QT5 plugin path: %s" % (plugin_path))
                QCoreApplication.addLibraryPath(plugin_path)
            else:
                import site
Пример #21
0
            QPen,
            QPixmap,
            QPolygon,
            QRegExpValidator,
            QValidator
        )
        from PyQt5.uic import loadUi

        QStringList = list
        getQApp = QCoreApplication.instance
        qApp = QCoreApplication.instance  

        qt_imported = True
        qt_variant = "PyQt5"
        qt_version_no = list(map(int, QT_VERSION_STR.split(".")))
        _ver = PYQT_VERSION_STR.split(".")
        ver = _ver + ["0"] * (3 - len(_ver))
        pyqt_version_no = list(map(int, ver))[:3]
    except ImportError:
        pass

    try:
        from PyQt5.QtWebKit import QWebPage
    except ImportError:
        pass

#
# PyQt4
#
if (qt_variant == "PyQt4") or (qt_variant is None and not qt_imported):
    #