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)

def load_ui_type(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.
    This function return the form and base classes for the given qtdesigner ui file.
    """

    # add path for pysideuic
    import sys
    sys.path.append(THIRD_PARTY_PATH)

    # lazy import

    try:
        # python
        import os
        import logging
        import re
        import shutil
        from cStringIO import StringIO
        import xml.etree.ElementTree as xml
        import types
        # PySide
        from PySide import QtGui
        from PySide import QtCore
        from PySide import QtUiTools
        import pysideuic

    except Exception as exception_instance:
        # log
        logger.debug('Import failed: {0}'.format(exception_instance))
        # return None
        return None

    # compile ui

    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 rebuild_pyui_file(filename):
    uifile_patch = LTK_PATCH + LGT_UI_PATCH + filename
    pyfile_patch = LTK_PATCH + LGT_PYUI_PATCH + filename.split(".")[0] + ".py"
    uifile_time = os.path.getmtime(uifile_patch)
    pyfile_time = os.path.isfile(pyfile_patch) == True and os.path.getmtime(pyfile_patch) or 0
    if pyfile_time < uifile_time:
        uifile = open(uifile_patch, "r")
        pyfile = open(pyfile_patch, "w")
        uic.compileUi(uifile, pyfile)
        print "RECOMPILE: " + LTK_PATCH + LGT_UI_PATCH + filename
        uifile.close()
        pyfile.close()

def compile_if_necessary(input_ui_file,output_py_file):
    #prepare the file names
    input_path = module_folder+input_ui_file
    output_path = module_folder+output_py_file
    #recompile the .ui Qt file if this script is launched directly
    #or if the compiled .py GUI file does not exist
    #or if it is more recent than the compiled .py GUI file,
    #if __name__=='__main__' or not(os.path.isfile(output_path)) or os.path.getmtime(input_path)>os.path.getmtime(output_path):
    if not(os.path.isfile(output_path)) or os.path.getmtime(input_path)>os.path.getmtime(output_path):
        print "update detected: recompiling "+input_ui_file
        f=open(output_path,"w")
        pysideuic.compileUi(input_path,f)
        f.close()    

def main():
    for root, dirs, files in os.walk(os.path.abspath(CURRENT_DIR)):
        for f in files:
            print f
            if f.lower().endswith(".qrc"):
                name = os.path.basename(f).split(".")[0] + ".py"
                subprocess.call([PYSIDE_RCC_EXE, os.path.join(root, f), "-o", os.path.join(OUTPUT_DIR, name)])

            if f.lower().endswith(".ui"):
                name = os.path.basename(f).split(".")[0] + ".py"
                ui_path = os.path.join(root, f)
                pyfile = open(os.path.join(OUTPUT_DIR, name), 'w')
                compileUi(ui_path, pyfile, False, 4, False)
                pyfile.close()

def load_ui_type(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
		
		form_class = frame ['Ui_{0}'.format (form_class)]
		base_class = eval( 'QtGui.{0}'.format(widget_class))
	return form_class, base_class