Python pysideuic.compileUi函数代码示例

def get_pyside_class( ui_file ):
   """
   Pablo Winant
   """

   parsed = xml.parse( ui_file )
   #print parsed
   widget_class = parsed.find( 'widget' ).get( 'class' )
   form_class = parsed.find( 'class' ).text
   #print widget_class, form_class
   with open( ui_file, 'r' ) as f:
      print f
      o = StringIO()
      frame = {}
      try:
         pysideuic.compileUi( f, o, indent = 0 )
      except:
         print 'errroorrrrr'

      pyc = compile( o.getvalue(), '<string>', 'exec' )
      exec pyc in frame
      
      # Fetch the base_class and form class based on their type in the xml from designer
      form_class = frame['Ui_{0}'.format( form_class )]
      base_class = eval( 'QtGui.{0}'.format( widget_class ) )
      
   return form_class, base_class

def loadUiType(ui_file):
    from wishlib.qt import active, QtGui
    if active == "PySide":
        import pysideuic
        parsed = xml.parse(ui_file)
        widget_class = parsed.find('widget').get('class')
        form_class = parsed.find('class').text

        with open(ui_file, 'r') as f:
            o = StringIO()
            frame = {}

            pysideuic.compileUi(f, o, indent=0)
            pyc = compile(o.getvalue(), '<string>', 'exec')
            exec pyc in frame

            # Fetch the base_class and form class based on their type in the
            # xml from designer
            form_class = frame['Ui_%s' % form_class]
            # base_class = eval('QtGui.%s' % widget_class)
            base_class = getattr(QtGui, widget_class)
        return form_class, base_class
    elif active == "PyQt4":
        from PyQt4 import uic
        return uic.loadUiType(ui_file)
    return None

def _load_ui_type(ui_file):
    """Load a ui file for PySide.

    PySide lacks the "_load_ui_type" command, so we have to convert
    the UI file to python code in-memory first and then execute it in a
    special frame to retrieve the form_class.
    Args:
        ui_file (str): The .ui file.
    Returns:
        The base and form class, derived from the .ui file.
    """
    parsed = xml.parse(ui_file)
    widget_class = parsed.find('widget').get('class')
    form_class = parsed.find('class').text
    with open(ui_file, 'r') as f:
        o = StringIO()
        frame = {}

        pysideuic.compileUi(f, o, indent=0)
        pyc = compile(o.getvalue(), '<string>', 'exec')
        exec pyc in frame

        # Fetch the base_class and form_class based on their type
        # in the xml from designer
        base_class = getattr(QtWidgets, widget_class)
        form_class = frame['Ui_%s' % form_class]
        return base_class, form_class

    def loadUiType(uiFile):
        """
        Pyside "loadUiType" command like PyQt4 has one, so we have to convert
        the ui file to py code in-memory first and then execute it in a
        special frame to retrieve the form_class.

        from stackoverflow: http://stackoverflow.com/a/14195313/3781327

        seems like this might also be a legitimate solution, but I'm not sure
        how to make PyQt4 and pyside look the same...
            http://stackoverflow.com/a/8717832
        """
        import pysideuic
        import xml.etree.ElementTree as xml

        # from io import StringIO

        parsed = xml.parse(uiFile)
        widget_class = parsed.find("widget").get("class")
        form_class = parsed.find("class").text

        with open(uiFile, "r") as f:
            o = StringIO()
            frame = {}

            pysideuic.compileUi(f, o, indent=0)
            pyc = compile(o.getvalue(), "<string>", "exec")
            exec(pyc, frame)

            # Fetch the base_class and form class based on their type in the xml from designer
            form_class = frame["Ui_%s" % form_class]
            base_class = eval("QtGui.%s" % widget_class)

        return form_class, base_class

def loadUiType(uiFile):
    """
	Pyside lacks the "loadUiType" command, so we have to convert the ui file to py code in-memory first
	and then execute it in a special frame to retrieve the form_class.
	"""
    parsed = xml.parse(uiFile)
    widget_class = parsed.find("widget").get("class")
    form_class = parsed.find("class").text

    with open(uiFile, "r") as f:
        o = StringIO()
        frame = {}

        if QtType == "PySide":
            pysideuic.compileUi(f, o, indent=0)
            pyc = compile(o.getvalue(), "<string>", "exec")
            exec pyc in frame

            # Fetch the base_class and form class based on their type in the xml from designer
            form_class = frame["Ui_%s" % form_class]
            base_class = eval("QtGui.%s" % widget_class)
        elif QtType == "PyQt":
            form_class = PyQtFixer
            base_class = QtGui.QMainWindow
    return form_class, base_class

    def loadUiType(cls, uifile, respath=None):
        """
        Pyside lacks the "loadUiType" command, so we have to convert the ui file to py code in-memory first
        and then execute it in a special frame to retrieve the form_class.
        """
        parsed = xml.parse(uifile)
        widget_class = parsed.find('widget').get('class')
        form_class = parsed.find('class').text

        with open(uifile, 'r') as f:
            o = StringIO()
            frame = {}

            pysideuic.compileUi(f, o, indent=0)
            pyc = compile(o.getvalue(), '<string>', 'exec')

            hasres = respath and respath not in sys.path
            if hasres:
                sys.path.append(respath)

            exec(pyc, frame)

            if hasres:
                sys.path.remove(respath)

            #Fetch the base_class and form class based on their type in the xml from designer
            form_class = frame['Ui_%s'%form_class]
            base_class = eval('PySide.QtGui.%s'%widget_class)
        return form_class, base_class

    def loadUiType(uiFile):
        """
        Pyside "loadUiType" command like PyQt4 has one, so we have to convert the ui file to py code in-memory first    and then execute it in a special frame to retrieve the form_class.
        """
        import pysideuic
        import xml.etree.ElementTree as xml
        #from io import StringIO
        
        parsed = xml.parse(uiFile)
        widget_class = parsed.find('widget').get('class')
        form_class = parsed.find('class').text
        
        with open(uiFile, 'r') as f:
            o = StringIO()
            frame = {}

            pysideuic.compileUi(f, o, indent=0)
            pyc = compile(o.getvalue(), '<string>', 'exec')
            exec(pyc, frame)

            #Fetch the base_class and form class based on their type in the xml from designer
            form_class = frame['Ui_%s'%form_class]
            base_class = eval('QtGui.%s'%widget_class)

        return form_class, base_class

    def compile_ui(self, ui_file, py_file=None):
        """Compile the .ui files to python modules."""
        self._wrapuic(i18n_module=self.i18n_module)
        if py_file is None:
            py_file = os.path.join(
                self.output_dir,
                os.path.basename(ui_file).replace(
                    '.ui', self.generated_extension
                ).lower()
            )

        fi = open(ui_file, 'r')
        fo = open(py_file, 'wt')
        try:
            from pysideuic import compileUi
            compileUi(fi, fo, execute=self.ui_execute, indent=self.indent,
                      from_imports=self.from_imports)
            log.info("Compiled %s into %s", ui_file, py_file)
        except ImportError:
            log.warn("You need to have pyside-tools installed in order to "
                     "compile .ui files.")
        except Exception, err:
            log.warn("Failed to generate %r from %r: %s", py_file, ui_file, err)
            if not os.path.exists(py_file) or not not file(py_file).read():
                raise SystemExit(1)
            return

def load_ui_type(UI_FILE):
	'''
	Pyside lacks the "load_ui_type" command, so we have to convert the ui file
	to py code in-memory first and then execute it in a special frame to
	retrieve the form_class.
	'''
	parsed = xml.parse(UI_FILE)
	widget_class = parsed.find('widget').get('class')
	form_class = parsed.find('class').text

	with open(UI_FILE, 'r') as f:
		o = StringIO()
		frame = {}

		if QT_BINDINGS == 'PySide':
			pysideuic.compileUi(f, o, indent=0)
			pyc = compile(o.getvalue(), '<string>', 'exec')
			exec pyc in frame

			# Fetch the base_class and form class based on their type in the xml
			# from designer
			form_class = frame['Ui_%s'%form_class]
			base_class = eval('QtGui.%s'%widget_class)
		elif QT_BINDINGS == 'PyQt':
			form_class = PyQtFixer
			base_class = QtGui.QMainWindow
	return form_class, base_class

def loadUiType(ui_file):
        """
        Pyside lacks the "loadUiType" command, so we have to convert the ui file
        to py code in-memory first and then execute it in a special frame to
        retrieve the form_class.

        Usage:

            >>> class SomeDialog(loadUiType('some_dialog.ui')):
            >>>     def __init__(self, *args, **kwargs):
            >>>         super(SomeDialog, self).__init__(*args, **kwargs)

        """
        parsed = xml.parse(ui_file)
        widget_class = parsed.find('widget').get('class')
        form_class = parsed.find('class').text

        with open(ui_file, 'r') as f:
            o = StringIO()
            frame = {}

            pysideuic.compileUi(f, o, indent=0)
            pyc = compile(o.getvalue(), '<string>', 'exec')
            exec pyc in frame

            # Fetch the base_class and form class based on their type in the xml
            # from designer
            form_class = frame['Ui_%s' % form_class]
            base_class = eval('QtGui.%s' % widget_class)
        return type('PySideUI', (form_class, base_class), {})

def loadUiType(ui_file):
    """
    Pyside lacks the "loadUiType" command, so we have to convert
    the ui file to py code in-memory first and then execute it in
    a special frame to retrieve the form_class.
    """
    
    parsed = xml.parse(ui_file)
    widget_class = parsed.find('widget').get('class')
    form_class = parsed.find('class').text
    
    with open(ui_file, 'r') as f:
        o = StringIO()
        frame = {}
    
        pysideuic.compileUi(f, o, indent=0)
        pyc = compile(o.getvalue(), '<string>', 'exec')
        exec pyc in frame
        
        # Fetch the base_class and form_class based on their type
        # in the xml from designer
        form_class = frame['Ui_%s' % form_class]
        base_class = eval('QtGui.%s' % widget_class)
    
    return form_class, base_class    

def convert(input_file):
    if not input_file.endswith(".ui"):
        return False
    output_file = os.path.join(os.path.dirname(input_file),
                               os.path.basename(input_file).replace(".ui", ".py"))
    with open(output_file, 'w') as fp:
        compileUi(input_file, fp, False, 4, False)
    return output_file

def generateUi(uifname, pyfname, execute, indent):
    if pyfname == "-":
        pyfile = sys.stdout
    else:
        pyfile = file(pyfname, "w")

    pysideuic.compileUi(uifname, pyfile, execute, indent)
    return 0

def compileUI():
	from pysideuic import compileUi
	
	moduleName = __name__.split('.')[0]
	modulePath = os.path.abspath(imp.find_module(moduleName)[1])
	pyfile = open(modulePath+'\\mainWindow.py', 'w')
	compileUi(modulePath+"\\mainWindow.ui", pyfile, False, 4,False)
	pyfile.close()

def compileUIFiles(uiDir):
    for name in os.listdir(uiDir):
        uiFilePath = os.path.join(uiDir, name)

        if os.path.isfile(uiFilePath):
            if name.endswith(".ui"):
                uiResultPath = (name[:-3] + ".py").lower()

                with open(os.path.join(uiDir, uiResultPath), "w") as f:
                    compileUi(uiFilePath, f)