def main(argv=None): if argv is None: argv = sys.argv app = QApplication(argv) engine = QScriptEngine() if HAS_DEBUGGER: debugger = QScriptEngineDebugger() debugger.attachTo(engine) debugWindow = debugger.standardWindow() debugWindow.resize(1024, 640) scriptFileName = './calculator.js' scriptFile = QFile(scriptFileName) scriptFile.open(QIODevice.ReadOnly) engine.evaluate(unicode(scriptFile.readAll()), scriptFileName) scriptFile.close() loader = QUiLoader() ui = loader.load(':/calculator.ui') ctor = engine.evaluate('Calculator') scriptUi = engine.newQObject(ui, QScriptEngine.ScriptOwnership) calc = ctor.construct([scriptUi]) if HAS_DEBUGGER: display = ui.findChild(QLineEdit, 'display') display.connect(display, SIGNAL('returnPressed()'), debugWindow, SLOT('show()')) ui.show() return app.exec_()
def findOrSaveConfig(self): infile = QFile('ui/config_path.ui') infile.open(QFile.ReadOnly) loader = QUiLoader() dialog = loader.load(infile, self.window) infile.close() def browse(): path = QFileDialog.getSaveFileName(dialog, u"Choose or create a configuration file", dialog.pathBox.text())[0] if path != '': dialog.pathBox.setText(path) def cancel(): dialog.hide() def ok(): autodetectPort = dialog.autodetect.checkState() == Qt.Checked configPath = os.path.expanduser(dialog.pathBox.text()) dialog.hide() self.start(configPath, autodetectPort) dialog.show() dialog.pathBox.setText(os.path.expanduser('~/.config/tangelo/tangelo.conf')) dialog.browseButton.clicked.connect(browse) dialog.cancelButton.clicked.connect(cancel) dialog.okButton.clicked.connect(ok)
def loadDialog(file_name): loader = QUiLoader() the_file = QFile(file_name) the_file.open(QFile.ReadOnly) ret_val = loader.load(the_file) the_file.close() return ret_val
class TestQFileSignalBlocking(unittest.TestCase): '''Test case for blocking the signal QIODevice.aboutToClose()''' def setUp(self): #Set up the needed resources - A temp file and a QFile self.called = False handle, self.filename = mkstemp() os.close(handle) self.qfile = QFile(self.filename) def tearDown(self): #Release acquired resources os.remove(self.filename) del self.qfile def callback(self): #Default callback self.called = True def testAboutToCloseBlocking(self): #QIODevice.aboutToClose() blocking QObject.connect(self.qfile, SIGNAL('aboutToClose()'), self.callback) self.assert_(self.qfile.open(QFile.ReadOnly)) self.qfile.close() self.assert_(self.called) self.called = False self.qfile.blockSignals(True) self.assert_(self.qfile.open(QFile.ReadOnly)) self.qfile.close() self.assert_(not self.called)
def convertTextureSize(texturePath): if int(cmds.about(v=1)) < 2017: from PySide import QtCore from PySide.QtGui import QPixmap, QImage from PySide.QtCore import QFile, QIODevice else: from PySide2 import QtCore from PySide2.QtGui import QPixmap, QImage from PySide2.QtCore import QFile, QIODevice folder, fileName = ntpath.split(texturePath) origFileName = fileName if fileName[: 8] != 'resized_' else fileName[ 8:] origPath = folder + '/' + origFileName if not os.path.exists(origPath): cmds.warning("original is not exists : %s" % texturePath) return convertedFileName = 'resized_%d_' % ( int(resolusion)) + origFileName renamedPath = folder + "/" + convertedFileName ext = os.path.splitext(fileName)[-1] img = QImage(origPath) pixmap = QPixmap() pixmap = pixmap.fromImage( img.scaled(int(resolusion), int(resolusion), QtCore.Qt.IgnoreAspectRatio, QtCore.Qt.FastTransformation)) qfile = QFile(renamedPath) qfile.open(QIODevice.WriteOnly) pixmap.save(qfile, ext[1:], 100) qfile.close() return renamedPath
def testBug721(self): obj = QFile(self.filename) obj.open(QIODevice.ReadOnly) memory = obj.map(0, 1) self.assertEqual(len(memory), 1) self.assertEqual(memory[0], py3k.b('a')) obj.unmap(memory)
def testBasic(self): '''QFile.getChar''' obj = QFile(self.filename) obj.open(QIODevice.ReadOnly) self.assertEqual(obj.getChar(), (True, 'a')) self.assertFalse(obj.getChar()[0]) obj.close()
def __init__(self): self.loader = QUiLoader() infile = QFile("resources/loading.ui") infile.open(QFile.ReadOnly) self.window = self.loader.load(infile, None) infile.close() self.overrides = {'personID':self.window.personID, 'paID':self.window.paID, 'maID':self.window.maID, 'sex':self.window.sex, 'affected':self.window.affected, 'n_local_aff':self.window.n_local_aff, 'n_local_desc':self.window.n_local_desc, 'nicki_d':self.window.nicki_d, 'is_root':self.window.is_root, 'is_leaf':self.window.is_leaf, 'generation':self.window.generation} self.requiredForCalculateD = set(['personID','paID','maID','sex','affected']) self.header = [] self.lowerHeader = [] self.window.browseInputButton.clicked.connect(self.browseInput) self.window.inputField.textChanged.connect(self.switchPrograms) self.window.browseOutputButton.clicked.connect(self.browseOutput) self.window.outputField.textChanged.connect(self.switchPrograms) self.window.programBox.currentIndexChanged.connect(self.switchPrograms) self.window.runButton.clicked.connect(self.go) self.switchPrograms() self.window.buttonBox.setEnabled(False) self.window.show()
def loadWindowFromFile(file_name): '''Load the window definition from the resource ui file''' loader = QUiLoader() ui_file = QFile(file_name) ui_file.open(QFile.ReadOnly) the_window = loader.load(ui_file) ui_file.close() return the_window
def loadHyperlinkDialog(self): ''' Load dialog from ui file for defining hyperlink ''' loader = QUiLoader() ui_file = QFile(':/hyperlink.ui') # UI_DIALOG_FILE) ui_file.open(QFile.ReadOnly) self.hyperlink_dialog = loader.load(ui_file) ui_file.close() self.hyperlink_dialog.accepted.connect(self.hyperlinkChanged) self.hlink_field = self.hyperlink_dialog.findChild(QLineEdit, 'hlink')
def createWidget(self): # Override the existing widget # TODO: Do I need to delete anything explicitly? infile = QFile('ui/process_widget.ui') infile.open(QFile.ReadOnly) loader = QUiLoader() self.widget = loader.load(infile, Globals.mainWindow.window) infile.close() self.updateWidget(True)
def __load_ui(self): ui_path = os.path.dirname(__file__) ui_path = os.path.join(ui_path, "MainWindow.ui") ui_file = QFile(ui_path) ui_file.open(QFile.ReadOnly) ui_loader = QtUiTools.QUiLoader() self.__ui = ui_loader.load(ui_file, None) ui_file.close() self.__ui.answerTableWidget.setHorizontalHeaderLabels([self.tr("Question"), self.tr("Answer")])
def main(): pid_file = 'av-control.pid' fp = open(pid_file, 'w') try: fcntl.lockf(fp, fcntl.LOCK_EX | fcntl.LOCK_NB) except IOError: # another instance is running print "av-control is already running." sys.exit(1) logging.basicConfig(format='%(asctime)s %(levelname)s: %(message)s', level=logging.INFO) app = QApplication(sys.argv) parser = argparse.ArgumentParser() parser.add_argument("-f", "--fullscreen", help="Run in fullscreen mode and hide the mouse cursor", action="store_true") parser.add_argument("-c", help="Specify the controller ID to connect to", metavar="CONTROLLERID", default="") args = parser.parse_args() try: ssf = QFile(":/stylesheet") ssf.open(QFile.ReadOnly) styleSheet = str(ssf.readAll()) app.setStyleSheet(styleSheet) except IOError: # never mind logging.warn("Cannot find stylesheet, using default system styles.") try: controller = Controller.fromPyro(args.c) myapp = MainWindow(controller) client = AvControlClient(myapp) client.setDaemon(True) client.start() client.started.wait() atexit.register(lambda: controller.unregisterClient(client.uri)) controller.registerClient(client.uri) if args.fullscreen: QApplication.setOverrideCursor(Qt.BlankCursor) myapp.showFullScreen() else: myapp.show() sys.exit(app.exec_()) except VersionMismatchError as e: Dialogs.errorBox(str(e))
def testPhrase(self): #Test loading of quote.txt resource f = open(adjust_filename('quoteEnUS.txt', __file__), "r") orig = f.read() f.close() f = QFile(':/quote.txt') f.open(QIODevice.ReadOnly) #|QIODevice.Text) print("Error:", f.errorString()) copy = f.readAll() f.close() self.assertEqual(orig, copy)
def testImage(self): #Test loading of sample.png resource f = open(adjust_filename('sample.png', __file__), "rb") orig = f.read() f.close() f = QFile(':/sample.png') f.open(QIODevice.ReadOnly) copy = f.readAll() f.close() self.assertEqual(len(orig), len(copy)) self.assertEqual(orig, copy)
def findTangelo(): infile = QFile('ui/find_tangelo.ui') infile.open(QFile.ReadOnly) loader = QUiLoader() dialog = loader.load(infile, None) infile.close() if sys.platform.startswith('win'): Globals.pythonPath = subprocess.Popen(['where', 'python'], stdout=subprocess.PIPE).communicate()[0].strip() Globals.tangeloPath = subprocess.Popen(['where', 'tangelo'], stdout=subprocess.PIPE).communicate()[0].strip() else: Globals.pythonPath = subprocess.Popen(['which', 'python'], stdout=subprocess.PIPE).communicate()[0].strip() Globals.tangeloPath = subprocess.Popen(['which', 'tangelo'], stdout=subprocess.PIPE).communicate()[0].strip() if os.path.exists(Globals.pythonPath): dialog.pythonPathBox.setText(Globals.pythonPath) if os.path.exists(Globals.tangeloPath): dialog.tangeloPathBox.setText(Globals.tangeloPath) def pythonBrowse(): path = QFileDialog.getOpenFileName(dialog, u"Find python", dialog.pythonPathBox.text())[0] if path != '': dialog.pythonPathBox.setText(path) def tangeloBrowse(): path = QFileDialog.getOpenFileName(dialog, u"Find tangelo", dialog.tangeloPathBox.text())[0] if path != '': dialog.tangeloPathBox.setText(path) def cancel(): dialog.hide() sys.exit() def ok(): Globals.pythonPath = os.path.expanduser(dialog.pythonPathBox.text()) Globals.tangeloPath = os.path.expanduser(dialog.tangeloPathBox.text()) if not os.path.exists(Globals.pythonPath): Globals.criticalError("Sorry, that python interpreter doesn't exist.") return if not os.path.exists(Globals.tangeloPath): Globals.criticalError("Sorry, that tangelo executable doesn't exist.") return Globals.mainWindow = Overview() Globals.mainWindow.refresh() dialog.hide() dialog.show() dialog.tangeloBrowse.clicked.connect(tangeloBrowse) dialog.pythonBrowse.clicked.connect(pythonBrowse) dialog.cancelButton.clicked.connect(cancel) dialog.okButton.clicked.connect(ok)
def getPanel(): global fcpdWBpath # read UI file ui_file = QFile(os.path.join(fcpdWBpath, "FCPDwb_taskpanel.ui")) ui_file.open(QFile.ReadOnly) widget = QUiLoader().load(ui_file) ui_file.close() # connection widget.btnLaunch.clicked.connect(lambda: launchPureData(widget)) widget.btnRunStop.clicked.connect(lambda: runStopServer(widget)) return widget
def widgetFromUIFile(filePath): """ Reads an ``.ui`` file and creates a new widget object from it. :param filePath: Where to find the ``.ui`` file :return: The new created widget """ loader = QUiLoader() UIFile = QFile(filePath) UIFile.open(QFile.ReadOnly) widget = loader.load(UIFile) UIFile.close() return widget
def loadWindow(self, uiFile, mainWindowAsParent=True, connectSlots=True): ''' Load a Window from UI file. ''' path = join(UI_PATH, uiFile) windowFile = QFile(path) windowFile.open(QIODevice.ReadOnly | QIODevice.Text) # Make all loaded windows children of mainWindow, except mainWindow itself window = self.uiLoader.load( windowFile, self.__mainWindow if mainWindowAsParent else None) windowFile.close() if connectSlots: QMetaObject.connectSlotsByName(window) return window
def read(self, fileName): self.state = PluginState.Invalid self.hasError = False self.dependencies = [] specFile = QFile(fileName) if not specFile.exists(): msg = QCoreApplication.translate(None, "File does not exist: {name}") return self.__reportError(msg.format(name=specFile.fileName())) if not specFile.open(QIODevice.ReadOnly): msg = QCoreApplication.translate(None, "Could not open file for read: {name}") return self.__reportError(msg.format(name=specFile.fileName())) fileInfo = QFileInfo(specFile) self.location = fileInfo.absolutePath() self.filePath = fileInfo.absoluteFilePath() reader = QXmlStreamReader(specFile) while not reader.atEnd(): reader.readNext() tokenType = reader.tokenType() if tokenType is QXmlStreamReader.StartElement: self.__readPluginSpec(reader) else: pass if reader.hasError(): msg = QCoreApplication.translate(None, "Error parsing file {0}: {1}, at line {2}, column {3}") return self.__reportError(msg.format(specFile.fileName(), reader.errorString(), reader.lineNumber(), reader.columnNumber())) self.state = PluginState.Read return True
def install_certificates(): ssl_config = QSslConfiguration.defaultConfiguration() ssl_config.setProtocol(QSsl.SecureProtocols) certs = ssl_config.caCertificates() for cert_filename in os.listdir(make_abs_path('certs')): if os.path.splitext(cert_filename)[1] == '.pem': cert_filepath = make_abs_path('certs', cert_filename) cert_file = QFile(cert_filepath) cert_file.open(QIODevice.ReadOnly) cert = QSslCertificate(cert_file) certs.append(cert) ssl_config.setCaCertificates(certs) QSslConfiguration.setDefaultConfiguration(ssl_config)
def createManager(self): if self.manager != None: self.updateManager() self.manager.show() else: # Create the window infile = QFile('ui/process_manager.ui') infile.open(QFile.ReadOnly) loader = QUiLoader() #TODO: This isn't working: loader.registerCustomWidget(ManagerHelper) self.manager = loader.load(infile, Globals.mainWindow.window) infile.close() self.updateManager(True) self.manager.show()
def __init__(self, notifyRun): loader = QUiLoader() infile = QFile("gui/ui/compreheNGSive_setup.ui") infile.open(QFile.ReadOnly) self.window = loader.load(infile, None) self.notifyRun = notifyRun self.cvfFile = None self.window.quitButton.clicked.connect(self.closeApp) self.window.runButton.clicked.connect(self.run) self.window.browseButton.clicked.connect(self.browseCvf) self.window.addButton.clicked.connect(self.browseFeature) self.window.removeButton.clicked.connect(self.removeFeature) self.window.show()
def __init__(self, vData, fData, intMan, startingXattribute, startingYattribute): loader = QUiLoader() infile = QFile("gui/ui/compreheNGSive.ui") infile.open(QFile.ReadOnly) self.window = loader.load(infile, None) self.resolution_threshold = 1000 self.vData = vData self.fData = fData self.intMan = intMan self.currentXattribute = startingXattribute self.currentYattribute = startingYattribute self.window.resolutionSpinBox.setMinimum(10) self.window.resolutionSpinBox.setMaximum(len(self.vData.data)) self.window.resolutionSpinBox.setValue(self.resolution_threshold) self.window.resolutionSpinBox.valueChanged.connect(self.changeResolution) self.window.refreshButton.clicked.connect(self.refreshResolution) self.window.actionQuit.triggered.connect(self.window.close) self.window.actionExport_History.triggered.connect(self.exportHistory) self.window.actionExport.triggered.connect(self.exportActivePoints) self.window.actionUndo.triggered.connect(self.intMan.undo) self.window.actionRedo.triggered.connect(self.intMan.redo) # TODO #self.window.actionNew.triggered.connect(self.startNewSelection) #self.window.actionDuplicate.triggered.connect(self.duplicateActiveSelection) #self.window.actionDelete.triggered.connect(self.deleteActiveSelection) #self.window.actionUnion.triggered.connect(self.intMan.newOperation(operation.SELECTION_UNION,)) #self.window.actionIntersection.triggered.connect(self.intMan.newOperation(operation.SELECTION_UNION,)) #self.window.actionDifference.triggered.connect(self.intMan.newOperation(operation.SELECTION_UNION,)) #self.window.actionComplement.triggered.connect(self.intMan.newOperation(operation.SELECTION_UNION,)) self.pc = parallelCoordinateWidget(vData=vData,app=self,parent=self.window.pcScrollArea) self.window.pcScrollArea.setWidget(self.pc) self.scatter = scatterplotWidget(vData=vData,app=self,parent=self.window.scatterWidget) #self.window.showMaximized() self.window.show()
def _write_doc_to_path(doc, path): # write QDomDocument to path as HROX hrox_file = QFile(path) if not hrox_file.open(QFile.WriteOnly): raise RuntimeError("Failed to open file for writing") stream = QTextStream(hrox_file) doc.save(stream, 1) hrox_file.close()
def save_to_disk(self, filename, data): f = QFile(filename) if not f.open(QIODevice.WriteOnly): print "could not open %s for writing" % filename return False f.write(data.readAll()) f.close() return True
def getContent(path): file = QFile(path) if not file.open(QIODevice.ReadOnly | QIODevice.Text): return ts = QTextStream(file) ts.setCodec("UTF-8") res = ts.readAll() return res
def __init__(self): # Load UI files infile = QFile("ui/overview.ui") infile.open(QFile.ReadOnly) loader = QUiLoader() #TODO: this isn't working: loader.registerCustomWidget(MainHelper) self.window = loader.load(infile, None) infile.close() self.processes = {} self.deadProcesses = {} # Events self.window.refreshButton.clicked.connect(self.refresh) self.window.startButton.clicked.connect(self.findOrSaveConfig) self.window.show()
def readRcTextFile(path): """Read whole text file from qt resources system.""" assert path.startswith(':/') f = QFile(path) if not f.open(QFile.ReadOnly | QFile.Text): raise FileNotFoundError('failed to read rc text %s' % path) text = str(f.readAll()) f.close() return text
def _read_doc_from_path(path): # reading QDomDocument from HROX path hrox_file = QFile(path) if not hrox_file.open(QFile.ReadOnly): raise RuntimeError("Failed to open file for reading") doc = QDomDocument() doc.setContent(hrox_file) hrox_file.close() return doc
class LogFilePositionSource(QGeoPositionInfoSource): def __init__(self, parent): QGeoPositionInfoSource.__init__(self, parent) self.logFile = QFile(self) self.timer = QTimer(self) self.timer.timeout.connect(self.readNextPosition) self.logFile.setFileName(translate_filename('simplelog.txt')) assert self.logFile.open(QIODevice.ReadOnly) self.lastPosition = QGeoPositionInfo() def lastKnownPosition(self, fromSatellitePositioningMethodsOnly): return self.lastPosition def minimumUpdateInterval(self): return 100 def startUpdates(self): interval = self.updateInterval() if interval < self.minimumUpdateInterval(): interval = self.minimumUpdateInterval() self.timer.start(interval) def stopUpdates(self): self.timer.stop() def requestUpdate(self, timeout): # For simplicity, ignore timeout - assume that if data is not available # now, no data will be added to the file later if (self.logFile.canReadLine()): self.readNextPosition() else: self.updateTimeout.emit() def readNextPosition(self): line = self.logFile.readLine().trimmed() if not line.isEmpty(): data = line.split(' ') hasLatitude = True hasLongitude = True timestamp = QDateTime.fromString(str(data[0]), Qt.ISODate) latitude = float(data[1]) longitude = float(data[2]) if timestamp.isValid(): coordinate = QGeoCoordinate(latitude, longitude) info = QGeoPositionInfo(coordinate, timestamp) if info.isValid(): self.lastPosition = info # Currently segfaulting. See Bug 657 # http://bugs.openbossa.org/show_bug.cgi?id=657 self.positionUpdated.emit(info)
def save(self,fileName): file = QFile(fileName) file.open(QIODevice.WriteOnly | QIODevice.Text) xmlWriter = QXmlStreamWriter(file) xmlWriter.setAutoFormatting(1) xmlWriter.writeStartDocument() xmlWriter.writeStartElement("rws") for i in range(self.rowCount()): c = self.data(self.index(i,0),QtReduceModel.RawDataRole) xmlWriter.writeStartElement("group") l = c.toDict().items() l.sort() for x in l: xmlWriter.writeStartElement(x[0]) xmlWriter.writeCharacters(x[1]) xmlWriter.writeEndElement() xmlWriter.writeEndElement() xmlWriter.writeEndElement() xmlWriter.writeEndDocument()
def __init__(self): super(MainWindow, self).__init__() self.setWindowTitle("Diablo Meter") size = QSize(530, 470) self.resize(size) # Load ui from gui definition file try: loader = QUiLoader() file = QFile("widgets/widgets.ui") file.open(QFile.ReadOnly) mainWindow = loader.load(file, self) file.close() except: self.warning_message("Error", "Can't find widgets definition file.\nIs the widgets folder in the same path as the executable?") sys.exit() #Reference to the components self.left_click_lcd = mainWindow.findChild(QLCDNumber, "left_click_lcd") self.right_click_lcd = mainWindow.findChild(QLCDNumber, "right_click_lcd") self.action_keys_lcds = [mainWindow.findChild(QLCDNumber, "action_1_lcd"), mainWindow.findChild(QLCDNumber, "action_2_lcd"), mainWindow.findChild(QLCDNumber, "action_3_lcd"), mainWindow.findChild(QLCDNumber, "action_4_lcd")] options_menu = self.menuBar().addMenu("&Options") options_menu.addAction(QtGui.QAction("&Restart Counters", self, triggered=self.restart_counters)) #Queue to share messsages to the message pupm on EventListener q = Queue() self.event_listener = EventListener(q) self.event_listener.start() self.thread = EventProcessor(q) self.thread.dataReady.connect(self.on_hook_event) self.thread.start() #Key Names we are interested in. The order in the tuple #determines to which action key it's mapped self.key_maps = ("1", "2", "3", "4")
def readModel(self,fileName): file = QFile(fileName) if (file.open(QIODevice.ReadOnly | QIODevice.Text)): xmlReader = QXmlSimpleReader() xmlReader.setContentHandler(self) xmlReader.setErrorHandler(self) xmlSource = QXmlInputSource(file) xmlReader.parse(xmlSource) return self.modelData else: return None
def __init__(self, params): loader = QUiLoader() infile = QFile("gui/ui/Setup.ui") infile.open(QFile.ReadOnly) self.window = loader.load(infile, None) self.loadPrefs() self.window.quitButton.clicked.connect(self.closeApp) self.window.saveButton.clicked.connect(self.savePrefs) self.window.runButton.clicked.connect(self.runSV) self.splash = QProgressDialog("Loading", "Cancel", 0, 100, parent=None) self.splash.setWindowModality(Qt.WindowModal) self.splash.setAutoReset(False) self.splash.setAutoClose(False) self.splash.hide() self.canceled = False self.window.show() self.runningApp = None
def __init__(self, ped): self.state = AppState(ped) self.loader = QUiLoader() infile = QFile("resources/vis.ui") infile.open(QFile.ReadOnly) self.window = self.loader.load(infile, None) infile.close() # Add our custom table self.tableWidget = TableComponent(self.state) self.window.historyDataSplitter.insertWidget(0,self.tableWidget) self.window.historyDataSplitter.update() # Add our pedigree view with its settings widgets settingsWidgets = {'canvasWidth':self.window.canvasWidth, 'canvasHeight':self.window.canvasHeight} self.pedigreeView = PedigreeComponent(settingsWidgets, self.state) self.window.pedigreeSplitter.insertWidget(0,self.pedigreeView) self.window.pedigreeSplitter.update() self.window.showMaximized()
def load_stylesheet(pyside=True): f = QFile(":petfactoryStyle/style.qss") if not f.exists(): pass else: f.open(QFile.ReadOnly | QFile.Text) ts = QTextStream(f) stylesheet = ts.readAll() if platform.system().lower() == 'darwin': # see issue #12 on github mac_fix = ''' QDockWidget::title { background-color: #353434; text-align: center; height: 12px; } ''' stylesheet += mac_fix return stylesheet
def load_stylesheet(theme, pyside=True): """ Loads the stylesheet. Takes care of importing the rc module. :param pyside: True to load the pyside rc file, False to load the PyQt rc file :return the stylesheet string """ if theme == 'darkstyle': import themes.darkstyle.pyside_style_rc elif theme == 'robotstyle': import themes.robotstyle.pyside_style_rc from PySide.QtCore import QFile, QTextStream basedir = os.path.abspath(os.path.dirname(__file__)) localPath = "%s/style.qss" % theme f = QFile( os.path.join(basedir, localPath)) if not f.exists(): _logger().error("Unable to load stylesheet, file not found in " "resources") return "" else: f.open(QFile.ReadOnly | QFile.Text) ts = QTextStream(f) stylesheet = ts.readAll() # if platform.system().lower() == 'darwin': # see issue #12 on github # mac_fix = ''' # QDockWidget::title # { # background-color: #353434; # text-align: center; # height: 10px; # } # ''' # stylesheet += mac_fix return stylesheet
def __init__(self, *args, **kwargs): super(MainWindowController, self).__init__(*args, **kwargs) # vars self._address_valid = False # define ui members for type hinting self._ip_line_edit = self._window.IpAddressLineEdit # type: QLineEdit self._status_label = self._window.Statuslabel # type: QLabel self._update_button = self._window.UpdateButton # type: QPushButton self._update_button = self._window.UpdateButton # type: QPushButton self._progress_bar = self._window.progressBar # type: QProgressBar self._combobox = self._window.comboBox # type: QComboBox # load ui loader = QUiLoader() ui = QFile("ui/main_window.ui") ui.open(QFile.ReadOnly) self._window = loader.load(ui) # type: QWidget ui.close() self._window.show() # init other elements self._init_ip_line_edit()
def __init__(self): self.loadedPaths = set() self.dataSources = [] self.genes = set() self.loader = QUiLoader() infile = QFile("expressionTopology.ui") infile.open(QFile.ReadOnly) self.window = self.loader.load(infile, None) infile.close() self.updateTimeSliders() # Main view self.multiPanel = multiViewPanel(self.window.graphicsView,self) # Events self.window.categoryTable.cellClicked.connect(self.changeColor) self.window.loadButton.clicked.connect(self.loadData) self.window.quitButton.clicked.connect(self.window.close) self.window.addButton.clicked.connect(self.addGene) self.window.geneBox.editTextChanged.connect(self.editGene) self.window.speedSlider.valueChanged.connect(self.changeSpeed) self.window.timeSlider.valueChanged.connect(self.changeTime) self.window.addButton.setEnabled(False) self.window.showFullScreen() #self.window.show() # Start timer # Update timer self.timer = QTimer(self.window) self.timer.timeout.connect(self.nextFrame) self.timer.start(Viz.FRAME_DURATION)
def javaInclude(context, engine): fileName = context.argument(0).toString() scriptFile = QFile("commands/" + fileName) if not scriptFile.open(QIODevice.ReadOnly): return -1 stream = QTextStream(scriptFile) s = stream.readAll() # QString scriptFile.close() parent = context.parentContext() # QScriptContext* if parent != 0: context.setActivationObject(context.parentContext().activationObject()) context.setThisObject(context.parentContext().thisObject()) result = engine.evaluate(s) #TODO/PORT/FIXME# what's this for? return 0
def saveHistory(self, fileName, html): #TODO """ TOWRITE :param `fileName`: TOWRITE :type `fileName`: QString :param `html`: TOWRITE :type `html`: bool """ qDebug("CmdPrompt saveHistory") file = QFile(fileName) if (not file.open(QIODevice.WriteOnly | QIODevice.Text)): return # TODO: save during input in case of crash output = QTextStream(file) if html: output << promptHistory.toHtml() else: output << promptHistory.toPlainText()
def OnSaveFilePath(self, filePath): """""" file = QFile(filePath) if not file.open(QFile.WriteOnly | QFile.Text): QMessageBox.warning(self, self.tr('Warning'), self.tr('Cannot write file') + ' %s:\n%s.' % (filePath, file.errorString())) return False outf = QTextStream(file) QApplication.setOverrideCursor(Qt.WaitCursor) outf << self.toPlainText() QApplication.restoreOverrideCursor() self.DoSetCurrentFilePath(filePath) # Clear the Modified Flag. self.document().setModified(False) self.setWindowModified(False) self.setWindowTitle('%s[*]' % self.fileName) return True
class MainWindow(QtGui.QWidget, CommandBase): def update_nw_versions(self, button): self.get_versions_in_background() def __init__(self, width, height, parent=None): super(MainWindow, self).__init__(parent) CommandBase.__init__(self) self.output_package_json = True self.setWindowIcon( QtGui.QIcon(os.path.join(CWD, 'files', 'images', 'icon.png'))) self.update_json = False self.setup_nw_versions() self.thread = None self.original_packagejson = {} self.resize(width, height) self.extract_error = None self.create_application_layout() self.option_settings_enabled(False) self.setWindowTitle("Web2Executable {}".format(__gui_version__)) self.update_nw_versions(None) def setup_nw_versions(self): nw_version = self.get_setting('nw_version') try: f = open(os.path.join(CWD, 'files', 'nw-versions.txt')) for line in f: nw_version.values.append(line.strip()) except IOError: nw_version.values.append(nw_version.default_value) def create_application_layout(self): self.main_layout = QtGui.QVBoxLayout() self.main_layout.setContentsMargins(10, 5, 10, 5) self.create_layout_widgets() self.addWidgets_to_main_layout() self.setLayout(self.main_layout) def create_layout_widgets(self): self.download_bar_widget = self.create_download_bar() self.app_settings_widget = self.create_application_settings() self.win_settings_widget = self.create_window_settings() self.ex_settings_widget = self.create_export_settings() self.dl_settings_widget = self.create_download_settings() self.directory_chooser_widget = self.create_directory_choose() def addWidgets_to_main_layout(self): self.main_layout.addWidget(self.directory_chooser_widget) self.main_layout.addWidget(self.app_settings_widget) self.main_layout.addWidget(self.win_settings_widget) self.main_layout.addWidget(self.ex_settings_widget) self.main_layout.addWidget(self.dl_settings_widget) self.main_layout.addLayout(self.download_bar_widget) def option_settings_enabled(self, is_enabled): self.ex_button.setEnabled(is_enabled) self.app_settings_widget.setEnabled(is_enabled) self.win_settings_widget.setEnabled(is_enabled) self.ex_settings_widget.setEnabled(is_enabled) self.dl_settings_widget.setEnabled(is_enabled) def export(self, export_button, cancel_button): self.get_files_to_download() self.try_to_download_files() def open_export(self, open_export_button): open_folder_in_explorer(self.output_dir()) def try_to_download_files(self): if self.files_to_download: self.progress_bar.setVisible(True) self.cancel_button.setEnabled(True) self.disable_ui_while_working() self.download_file_with_error_handling() else: # This shouldn't happen since we disable the UI if there are no # options selected # But in the weird event that this does happen, we are prepared! QtGui.QMessageBox.information(self, 'Export Options Empty!', ('Please choose one of ' 'the export options!')) def selected_version(self): return self.get_setting('nw_version').value def enable_ui_after_error(self): self.enable_ui() self.progress_text = '' self.progress_bar.setVisible(False) self.cancel_button.setEnabled(False) def show_error(self, exception): QtGui.QMessageBox.information(self, 'Error!', str(exception)) def disable_ui_while_working(self): self.option_settings_enabled(False) self.directory_chooser_widget.setEnabled(False) def enable_ui(self): self.option_settings_enabled(True) self.directory_chooser_widget.setEnabled(True) def required_settings_filled(self): proj_dir = self.project_dir() out_dir = self.output_dir() if proj_dir and out_dir: if os.path.exists(proj_dir): valid_proj_dirs = True settings_valid = True for sgroup in self.settings['setting_groups']: for sname, setting in sgroup.items(): setting_path = os.path.join(self.project_dir(), str(setting.value)) if setting.required and not setting.value: return False if (setting.type == 'file' and setting.value and not os.path.exists(setting_path)): log(setting.value, "does not exist") settings_valid = False if (setting.type == 'folder' and setting.value and not os.path.exists(setting_path)): settings_valid = False export_chosen = False for setting_name, setting in self.settings['export_settings'].items(): if setting.value: export_chosen = True return export_chosen and valid_proj_dirs and settings_valid def project_dir(self): if hasattr(self, 'input_line'): return self.input_line.text() return '' def output_dir(self): if hasattr(self, 'output_line'): return self.output_line.text() return '' def create_download_bar(self): hlayout = QtGui.QHBoxLayout() vlayout = QtGui.QVBoxLayout() vlayout.setContentsMargins(5, 5, 5, 5) vlayout.setSpacing(5) hlayout.setSpacing(5) hlayout.setContentsMargins(5, 5, 5, 5) progress_label = QtGui.QLabel('') progress_bar = QtGui.QProgressBar() progress_bar.setVisible(False) progress_bar.setContentsMargins(5, 5, 5, 5) vlayout.addWidget(progress_label) vlayout.addWidget(progress_bar) vlayout.addWidget(QtGui.QLabel('')) ex_button = QtGui.QPushButton('Export') ex_button.setEnabled(False) cancel_button = QtGui.QPushButton('Cancel Download') cancel_button.setEnabled(False) open_export_button = QtGui.QPushButton() open_export_button.setEnabled(False) open_export_button.setIcon( QtGui.QIcon(os.path.join('files', 'images', 'folder_open.png'))) open_export_button.setToolTip('Open Export Folder') open_export_button.setMaximumWidth(30) open_export_button.setMaximumHeight(30) ex_button.clicked.connect( self.call_with_object('export', ex_button, cancel_button)) cancel_button.clicked.connect(self.cancel_download) open_export_button.clicked.connect( self.call_with_object('open_export', open_export_button)) button_box = QtGui.QDialogButtonBox() button_box.addButton(open_export_button, QtGui.QDialogButtonBox.NoRole) button_box.addButton(cancel_button, QtGui.QDialogButtonBox.RejectRole) button_box.addButton(ex_button, QtGui.QDialogButtonBox.AcceptRole) hlayout.addLayout(vlayout) hlayout.addWidget(button_box) self.progress_label = progress_label self.progress_bar = progress_bar self.cancel_button = cancel_button self.open_export_button = open_export_button http = QHttp(self) http.requestFinished.connect(self.http_request_finished) http.dataReadProgress.connect(self.update_progress_bar) http.responseHeaderReceived.connect(self.read_response_header) self.http = http self.ex_button = ex_button return hlayout def read_response_header(self, response_header): # Check for genuine error conditions. if response_header.statusCode() not in (200, 300, 301, 302, 303, 307): self.show_error('Download failed: {}.'.format( response_header.reasonPhrase())) self.http_request_aborted = True self.http.abort() self.enable_ui_after_error() def http_request_finished(self, request_id, error): if request_id != self.http_get_id: return if self.http_request_aborted: if self.out_file is not None: self.out_file.close() self.out_file.remove() self.out_file = None return self.out_file.close() self.http.abort() if error: self.out_file.remove() self.show_error('Download failed: {}.'.format( self.http.errorString())) self.enable_ui_after_error() else: self.continue_downloading_or_extract() def continue_downloading_or_extract(self): if self.files_to_download: self.progress_bar.setVisible(True) self.cancel_button.setEnabled(True) self.disable_ui_while_working() self.download_file_with_error_handling() else: self.progress_text = 'Done.' self.cancel_button.setEnabled(False) self.progress_bar.setVisible(False) self.extract_files_in_background() @property def progress_text(self): return self.progress_label.text() @progress_text.setter def progress_text(self, value): self.progress_label.setText(str(value)) def run_in_background(self, method_name, callback): self.thread = BackgroundThread(self, method_name) self.thread.finished.connect(callback) self.thread.start() def get_versions_in_background(self): self.ex_button.setEnabled(False) self.run_in_background('get_versions', self.done_getting_versions) def done_getting_versions(self): self.ex_button.setEnabled(self.required_settings_filled()) self.progress_text = 'Done retrieving versions.' nw_version = self.get_setting('nw_version') combo = self.find_child_by_name(nw_version.name) combo.clear() combo.addItems(nw_version.values) def make_output_files_in_background(self): self.ex_button.setEnabled(False) self.run_in_background('make_output_dirs', self.done_making_files) def done_making_files(self): self.ex_button.setEnabled(self.required_settings_filled()) self.progress_text = 'Done Exporting.' self.enable_ui() self.delete_files() if self.output_err: self.show_error(self.output_err) self.enable_ui_after_error() def extract_files_in_background(self): self.progress_text = 'Extracting.' self.ex_button.setEnabled(False) self.run_in_background('extract_files', self.done_extracting) def done_extracting(self): self.ex_button.setEnabled(self.required_settings_filled()) if self.extract_error: self.progress_text = 'Error extracting.' self.show_error('There were one or more errors with your ' 'zip/tar files. They were deleted. Please ' 'try to export again.') self.enable_ui_after_error() else: self.progress_text = 'Done extracting.' self.make_output_files_in_background() def cancel_download(self): self.progress_text = 'Download cancelled.' self.cancel_button.setEnabled(False) self.http_request_aborted = True self.http.abort() self.enable_ui() self.progress_bar.setValue(0) self.progress_bar.setVisible(False) def update_progress_bar(self, bytes_read, total_bytes): if self.http_request_aborted: self.progress_bar.setValue(0) self.progress_bar.setVisible(False) return self.progress_bar.setMaximum(total_bytes) self.progress_bar.setValue(bytes_read) def download_file(self, path, setting): version_file = self.settings['base_url'].format( self.selected_version()) location = self.get_setting('download_dir').value versions = re.findall('v(\d+)\.(\d+)\.(\d+)', path)[0] minor = int(versions[1]) if minor >= 12: path = path.replace('node-webkit', 'nwjs') self.progress_text = 'Downloading {}'.format( path.replace(version_file, '')) url = QUrl(path) file_name = setting.save_file_path(self.selected_version(), location) archive_exists = QFile.exists(file_name) #dest_files_exist = False # for dest_file in setting.dest_files: # dest_file_path = os.path.join('files', setting.name, dest_file) # dest_files_exist &= QFile.exists(dest_file_path) forced = self.get_setting('force_download').value if archive_exists and not forced: self.continue_downloading_or_extract() return self.out_file = QFile(file_name) if not self.out_file.open(QIODevice.WriteOnly): error = self.out_file.error().name self.show_error('Unable to save the file {}: {}.'.format( file_name, error)) self.out_file = None self.enable_ui() return mode = QHttp.ConnectionModeHttp port = url.port() if port == -1: port = 0 self.http.setHost(url.host(), mode, port) self.http_request_aborted = False path = QUrl.toPercentEncoding(url.path(), "!$&'()*+,;=:@/") if path: path = str(path) else: path = '/' # Download the file. self.http_get_id = self.http.get(path, self.out_file) def create_directory_choose(self): group_box = QtGui.QGroupBox("Choose Your Web Project") input_layout = QtGui.QHBoxLayout() input_label = QtGui.QLabel('Project Directory:') self.input_line = QtGui.QLineEdit() self.input_line.textChanged.connect(self.project_path_changed) input_button = QtGui.QPushButton('...') input_button.clicked.connect(self.browse_dir) input_layout.addWidget(input_label) input_layout.addWidget(self.input_line) input_layout.addWidget(input_button) output_layout = QtGui.QHBoxLayout() output_label = QtGui.QLabel('Output Directory:') self.output_line = QtGui.QLineEdit() self.output_line.textChanged.connect(self.project_path_changed) output_button = QtGui.QPushButton('...') output_button.clicked.connect(self.browse_out_dir) output_layout.addWidget(output_label) output_layout.addWidget(self.output_line) output_layout.addWidget(output_button) vlayout = QtGui.QVBoxLayout() vlayout.setSpacing(5) vlayout.setContentsMargins(10, 5, 10, 5) vlayout.addLayout(input_layout) vlayout.addLayout(output_layout) group_box.setLayout(vlayout) return group_box def call_with_object(self, name, obj, *args, **kwargs): """Allows arguments to be passed to click events""" def call(*cargs, **ckwargs): if hasattr(self, name): func = getattr(self, name) kwargs.update(ckwargs) func(obj, *(args + cargs), **kwargs) return call def find_child_by_name(self, name): return self.findChild(QtCore.QObject, name) def find_all_children(self, names): children = [] for child in self.find_children(QtCore.QObject): if child.object_name() in names: children.append(child) return children def project_name(self): return self.find_child_by_name('app_name').text() def browse_dir(self): self.update_json = False directory = QtGui.QFileDialog.getExistingDirectory( self, "Find Project Directory", self.project_dir() or QtCore.QDir.currentPath()) if directory: self.reset_settings() self.input_line.setText(directory) self.output_line.setText(os.path.join(directory, 'output')) proj_name = os.path.basename(directory) setting_input = self.find_child_by_name('main') files = (glob.glob(os.path.join(directory, 'index.html')) + glob.glob(os.path.join(directory, 'index.php')) + glob.glob(os.path.join(directory, 'index.htm'))) if not setting_input.text(): if files: setting_input.setText(files[0].replace( self.project_dir() + os.path.sep, '')) app_name_input = self.find_child_by_name('app_name') name_input = self.find_child_by_name('name') name_setting = self.get_setting('name') title_input = self.find_child_by_name('title') if not name_input.text(): name_input.setText(name_setting.filter_name(proj_name)) if not app_name_input.text(): app_name_input.setText(proj_name) if not title_input.text(): title_input.setText(proj_name) self.load_package_json() self.open_export_button.setEnabled(True) self.update_json = True def browse_out_dir(self): self.update_json = False directory = QtGui.QFileDialog.getExistingDirectory( self, "Choose Output Directory", (self.output_line.text() or self.project_dir() or QtCore.QDir.currentPath())) if directory: self.output_line.setText(directory) self.update_json = True def get_file(self, obj, text_obj, setting, *args, **kwargs): file_path, _ = QtGui.QFileDialog.getOpenFileName( self, 'Choose File', (setting.last_value or self.project_dir() or QtCore.QDir.currentPath()), setting.file_types) if file_path: file_path = os.path.abspath( file_path) # fixes an issue with windows paths file_path = file_path.replace(self.project_dir() + os.path.sep, '') text_obj.setText(file_path) setting.last_value = file_path def get_folder(self, obj, text_obj, setting, *args, **kwargs): folder = QtGui.QFileDialog.getExistingDirectory( self, 'Choose Folder', (setting.last_value or QtCore.QDir.currentPath())) if folder: folder = folder.replace(self.project_dir() + os.path.sep, '') text_obj.setText(folder) setting.last_value = folder def create_application_settings(self): group_box = QtGui.QGroupBox("Application Settings") vlayout = self.create_layout( self.settings['order']['application_setting_order'], cols=4) group_box.setLayout(vlayout) return group_box def create_setting(self, name): setting = self.get_setting(name) if setting.type == 'string': return self.create_text_input_setting(name) elif setting.type == 'file': return self.create_text_input_with_file_setting(name) elif setting.type == 'folder': return self.create_text_input_with_folder_setting(name) elif setting.type == 'check': return self.create_check_setting(name) elif setting.type == 'list': return self.create_list_setting(name) elif setting.type == 'range': return self.create_range_setting(name) def create_window_settings(self): group_box = QtGui.QGroupBox("Window Settings") vlayout = self.create_layout( self.settings['order']['window_setting_order'], cols=4) group_box.setLayout(vlayout) return group_box def create_export_settings(self): group_box = QtGui.QGroupBox("Export Settings") vlayout = self.create_layout( self.settings['order']['export_setting_order'], cols=4) group_box.setLayout(vlayout) return group_box def create_download_settings(self): group_box = QtGui.QGroupBox("Download Settings") vlayout = self.create_layout( self.settings['order']['download_setting_order'], 2) group_box.setLayout(vlayout) return group_box def create_layout(self, settings, cols=3): glayout = QtGui.QGridLayout() glayout.setContentsMargins(10, 5, 10, 5) glayout.setSpacing(10) col = 0 row = 0 for setting_name in settings: setting = self.get_setting(setting_name) if col >= cols * 2: row += 1 col = 0 display_name = setting.display_name + ':' if setting.required: display_name += '*' setting_label = QtGui.QLabel(display_name) setting_label.setToolTip(setting.description) glayout.addWidget(setting_label, row, col) glayout.addLayout(self.create_setting(setting_name), row, col + 1) col += 2 return glayout def create_text_input_setting(self, name): hlayout = QtGui.QHBoxLayout() setting = self.get_setting(name) text = QtGui.QLineEdit() text.setValidator(Validator(setting.filter, setting.filter_action)) text.setObjectName(setting.name) text.textChanged.connect( self.call_with_object('setting_changed', text, setting)) if setting.value: text.setText(str(setting.value)) hlayout.addWidget(text) return hlayout def create_text_input_with_file_setting(self, name): hlayout = QtGui.QHBoxLayout() setting = self.get_setting(name) text = QtGui.QLineEdit() text.setObjectName(setting.name) button = QtGui.QPushButton('...') button.setMaximumWidth(30) button.setMaximumHeight(26) button.clicked.connect( self.call_with_object('get_file', button, text, setting)) if setting.value: text.setText(str(setting.value)) text.textChanged.connect( self.call_with_object('setting_changed', text, setting)) hlayout.addWidget(text) hlayout.addWidget(button) return hlayout def create_text_input_with_folder_setting(self, name): hlayout = QtGui.QHBoxLayout() setting = self.get_setting(name) text = QtGui.QLineEdit() text.setObjectName(setting.name) button = QtGui.QPushButton('...') button.setMaximumWidth(30) button.setMaximumHeight(26) button.clicked.connect( self.call_with_object('get_folder', button, text, setting)) if setting.value: text.setText(str(setting.value)) text.textChanged.connect( self.call_with_object('setting_changed', text, setting)) hlayout.addWidget(text) hlayout.addWidget(button) return hlayout def reset_settings(self): for sgroup in self.settings['setting_groups']: for setting in sgroup.values(): widget = self.find_child_by_name(setting.name) if (setting.type == 'string' or setting.type == 'file' or setting.type == 'folder'): old_val = '' if setting.default_value is not None: old_val = setting.default_value setting.value = old_val.replace('\\', '\\\\') widget.setText(str(old_val)) elif setting.type == 'check': old_val = False if setting.default_value is not None: old_val = setting.default_value setting.value = old_val widget.setChecked(old_val) elif setting.type == 'range': old_val = 0 if setting.default_value is not None: old_val = setting.default_value setting.value = old_val widget.setValue(old_val) def setting_changed(self, obj, setting, *args, **kwargs): if (setting.type == 'string' or setting.type == 'file' or setting.type == 'folder'): setting.value = obj.text() elif setting.type == 'check': setting.value = obj.isChecked() elif setting.type == 'list': setting.value = obj.currentText() elif setting.type == 'range': setting.value = obj.value() if self.update_json: json_file = os.path.join(self.project_dir(), 'package.json') with open(json_file, 'w+') as f: f.write(self.generate_json()) self.ex_button.setEnabled(self.required_settings_filled()) def project_path_changed(self): self.ex_button.setEnabled(self.required_settings_filled()) dirs_filled_out = False if self.project_dir() and self.output_dir(): if os.path.exists(self.project_dir()): dirs_filled_out = True self.option_settings_enabled(dirs_filled_out) def create_check_setting(self, name): hlayout = QtGui.QHBoxLayout() setting = self.get_setting(name) check = QtGui.QCheckBox() check.setObjectName(setting.name) check.clicked.connect( self.call_with_object('setting_changed', check, setting)) check.setChecked(setting.value) hlayout.addWidget(check) return hlayout def create_list_setting(self, name): hlayout = QtGui.QHBoxLayout() setting = self.get_setting(name) button = None if setting.button: button = QtGui.QPushButton(setting.button) button.clicked.connect(lambda: setting.button_callback(button)) combo = QtGui.QComboBox() combo.setObjectName(setting.name) combo.currentIndexChanged.connect( self.call_with_object('setting_changed', combo, setting)) combo.editTextChanged.connect( self.call_with_object('setting_changed', combo, setting)) for val in setting.values: combo.addItem(val) default_index = combo.findText(setting.default_value) if default_index != -1: combo.setCurrentIndex(default_index) hlayout.addWidget(combo) if button: hlayout.addWidget(button) return hlayout def create_range_setting(self, name): hlayout = QtGui.QHBoxLayout() setting = self.get_setting(name) button = None if setting.button: button = QtGui.QPushButton(setting.button) button.clicked.connect(lambda: setting.button_callback(button)) slider = QtGui.QSlider(QtCore.Qt.Orientation.Horizontal) slider.setRange(0, 9) slider.valueChanged.connect( self.call_with_object('setting_changed', slider, setting)) slider.setObjectName(setting.name) slider.setValue(setting.default_value) range_label = QtGui.QLabel(str(setting.default_value)) range_label.setMaximumWidth(30) slider.valueChanged.connect( self.call_with_object('_update_range_label', range_label)) w = QtGui.QWidget() whlayout = QtGui.QHBoxLayout() whlayout.addWidget(slider) whlayout.addWidget(range_label) w.setLayout(whlayout) hlayout.addWidget(w) return hlayout def _update_range_label(self, label, value): label.setText(str(value)) def load_package_json(self): setting_list = super(MainWindow, self).load_package_json() for setting in setting_list: setting_field = self.find_child_by_name(setting.name) if setting_field: if (setting.type == 'file' or setting.type == 'string' or setting.type == 'folder'): val_str = self.convert_val_to_str(setting.value) setting_field.setText(setting.filter_name(val_str)) if setting.type == 'check': setting_field.setChecked(setting.value) if setting.type == 'list': val_str = self.convert_val_to_str(setting.value) index = setting_field.findText(val_str) if index != -1: setting_field.setCurrentIndex(index) if setting.type == 'range': setting_field.setValue(setting.value) self.ex_button.setEnabled(self.required_settings_filled()) def show_and_raise(self): self.show() self.raise_()
class MainWindow(QtGui.QWidget): base_url = get_base_url() app_settings = {'main': Setting(name='main', display_name='Main file', required=True, type='file', file_types='*.html *.php *.htm'), 'name': Setting(name='name', display_name='App Name', required=True, type='string'), 'description': Setting(name='description', default_default_value='', type='string'), 'version': Setting(name='version', default_value='0.1.0', type='string'), 'keywords':Setting(name='keywords', default_value='', type='string'), 'nodejs': Setting('nodejs', 'Include Nodejs', default_value=True, type='check'), 'node-main': Setting('node-main', 'Alt. Nodejs', default_value='', type='file', file_types='*.js'), 'single-instance': Setting('single-instance', 'Single Instance', default_value=True, type='check')} webkit_settings = {'plugin': Setting('plugin', 'Load plugins', default_value=False, type='check'), 'java': Setting('java', 'Load Java', default_value=False, type='check'), 'page-cache': Setting('page-cache', 'Page Cache', default_value=False, type='check')} window_settings = {'title': Setting(name='title', default_value='', type='string'), 'icon': Setting('icon', 'Window Icon', default_value='', type='file', file_types='*.png *.jpg *.jpeg'), 'width': Setting('width', default_value=640, type='string'), 'height': Setting('height', default_value=480, type='string'), 'min_width': Setting('min_width', default_value=None, type='string'), 'min_height': Setting('min_height', default_value=None, type='string'), 'max_width': Setting('max_width', default_value=None, type='string'), 'max_height': Setting('max_height', default_value=None, type='string'), 'toolbar': Setting('toolbar', 'Show Toolbar', default_value=False, type='check'), 'always-on-top': Setting('always-on-top', 'Keep on top', default_value=False, type='check'), 'frame': Setting('frame', 'Window Frame', default_value=True, type='check'), 'show_in_taskbar': Setting('show_in_taskbar', 'Taskbar', default_value=True, type='check'), 'visible': Setting('visible', default_value=True, type='check'), 'resizable': Setting('resizable', default_value=False, type='check'), 'fullscreen': Setting('fullscreen', default_value=False, type='check'), 'position': Setting('position','Position by', default_value=None, values=[None, 'mouse', 'center'], type='list'), 'as_desktop': Setting('as_desktop', default_value=False, type='check'), } export_settings = {'windows': Setting('windows', default_value=False, type='check', url=base_url+'node-webkit-v{}-win-ia32.zip', extract_files=['nw.exe', 'nw.pak', 'icudt.dll', 'libEGL.dll', 'libGLESv2.dll'], dest_files=['nw.exe', 'nw.pak', 'icudt.dll', 'libEGL.dll', 'libGLESv2.dll']), 'mac': Setting('mac', default_value=False, type='check', url=base_url+'node-webkit-v{}-osx-ia32.zip', extract_file='node-webkit.app/Contents/Frameworks/node-webkit Framework.framework/node-webkit Framework', extract_files=['node-webkit.app/Contents/Frameworks/node-webkit Framework.framework/node-webkit Framework', 'node-webkit.app/Contents/Frameworks/node-webkit Framework.framework/Resources/nw.pak'], dest_files=[os.path.join('node-webkit.app','Contents', 'Frameworks','node-webkit Framework.framework', 'node-webkit Framework'), os.path.join('node-webkit.app','Contents', 'Frameworks','node-webkit Framework.framework', 'Resources', 'nw.pak')]), 'linux-x64': Setting('linux-x64', default_value=False, type='check', url=base_url+'node-webkit-v{}-linux-x64.tar.gz', extract_file='node-webkit-v{}-linux-x64/nw', extract_files=['node-webkit-v{}-linux-x64/nw', 'node-webkit-v{}-linux-x64/nw.pak'], dest_files=['nw', 'nw.pak']), 'linux-x32': Setting('linux-x32', default_value=False, type='check', url=base_url+'node-webkit-v{}-linux-ia32.tar.gz', extract_file='node-webkit-v{}-linux-ia32/nw', extract_files=['node-webkit-v{}-linux-ia32/nw', 'node-webkit-v{}-linux-ia32/nw.pak'], dest_files=['nw', 'nw.pak'])} download_settings = {'nw_version':Setting('nw_version', 'Node-webkit version', default_value='0.9.2', values=[], type='list'), 'force_download': Setting('force_download', default_value=False, type='check')} _setting_groups = [app_settings, webkit_settings, window_settings, export_settings, download_settings] application_setting_order = ['main', 'name', 'node-main', 'description', 'version', 'keywords', 'nodejs', 'single-instance', 'plugin', 'java', 'page-cache'] window_setting_order = ['title', 'icon', 'position', 'width', 'height', 'min_width', 'min_height', 'max_width', 'max_height', 'toolbar', 'always-on-top', 'frame', 'show_in_taskbar', 'visible', 'resizable', 'fullscreen', 'as_desktop'] export_setting_order = ['windows', 'linux-x64', 'mac', 'linux-x32'] download_setting_order = ['nw_version', 'force_download'] def __init__(self, width, height, parent=None): super(MainWindow, self).__init__(parent) self.setup_nw_versions() self.httpGetId = 0 self.httpRequestAborted = False self.thread = None self.original_packagejson = {} self.resize(width,height) self.extract_error = None self.create_application_layout() self.option_settings_enabled(False) self.setWindowTitle("Web2Executable") def setup_nw_versions(self): nw_version = self.getSetting('nw_version') try: f = open(os.path.join(CWD, 'files','nw-versions.txt')) for line in f: nw_version.values.append(line.strip()) except IOError: nw_version.values.append(nw_version.default_value) def create_application_layout(self): self.main_layout = QtGui.QVBoxLayout() self.create_layout_widgets() self.add_widgets_to_main_layout() self.setLayout(self.main_layout) def create_layout_widgets(self): self.download_bar_widget = self.createDownloadBar() self.app_settings_widget = self.createApplicationSettings() self.win_settings_widget = self.createWindowSettings() self.ex_settings_widget = self.createExportSettings() self.dl_settings_widget = self.createDownloadSettings() self.directory_chooser_widget = self.createDirectoryChoose() def add_widgets_to_main_layout(self): self.main_layout.addWidget(self.directory_chooser_widget) self.main_layout.addWidget(self.app_settings_widget) self.main_layout.addWidget(self.win_settings_widget) self.main_layout.addWidget(self.ex_settings_widget) self.main_layout.addWidget(self.dl_settings_widget) self.main_layout.addLayout(self.download_bar_widget) def option_settings_enabled(self, is_enabled): self.ex_button.setEnabled(is_enabled) self.app_settings_widget.setEnabled(is_enabled) self.win_settings_widget.setEnabled(is_enabled) self.ex_settings_widget.setEnabled(is_enabled) self.dl_settings_widget.setEnabled(is_enabled) def export(self, export_button, cancel_button): #self.delete_files_if_forced() self.get_files_to_download() self.try_to_download_files() def delete_files_if_forced(self): forced = self.getSetting('force_download').value if forced: for ex_setting in self.export_settings.values(): for dest_file in ex_setting.dest_files: f_path = os.path.join('files', ex_setting.name, dest_file) if os.path.exists(f_path): os.remove(f_path) def get_files_to_download(self): self.files_to_download = [] for setting_name, setting in self.export_settings.items(): if setting.value == True: self.files_to_download.append(setting) def try_to_download_files(self): if self.files_to_download: self.progress_bar.setVisible(True) self.cancel_button.setEnabled(True) self.disableUIWhileWorking() self.download_file_with_error_handling() else: #This shouldn't happen since we disable the UI if there are no options selected #But in the weird event that this does happen, we are prepared! QtGui.QMessageBox.information(self, 'Export Options Empty!', 'Please choose one of the export options!') def selected_version(self): return self.getSetting('nw_version').value def download_file_with_error_handling(self): setting = self.files_to_download.pop() try: self.downloadFile(setting.url.format(self.selected_version(), self.selected_version()), setting) except Exception as e: if os.path.exists(setting.save_file_path(self.selected_version())): os.remove(setting.save_file_path(self.selected_version())) error = ''.join(traceback.format_exception(sys.exc_info()[0], sys.exc_info()[1], sys.exc_info()[2])) self.show_error(error) self.enable_ui_after_error() def enable_ui_after_error(self): self.enableUI() self.progress_text = '' self.progress_bar.setVisible(False) self.cancel_button.setEnabled(False) def show_error(self, exception): QtGui.QMessageBox.information(self, 'Error!', str(exception)) def disableUIWhileWorking(self): self.option_settings_enabled(False) self.directory_chooser_widget.setEnabled(False) def enableUI(self): self.option_settings_enabled(True) self.directory_chooser_widget.setEnabled(True) def requiredSettingsFilled(self): proj_dir = self.projectDir() out_dir = self.outputDir() valid_proj_dir = False if proj_dir and out_dir: if os.path.exists(proj_dir): valid_proj_dirs = True settings_valid = True for sgroup in self._setting_groups: for sname, setting in sgroup.items(): if setting.required and not setting.value: return False if setting.type == 'file' and setting.value and not os.path.exists(os.path.join(self.projectDir(),setting.value)): log(setting.value, "does not exist") settings_valid = False export_chosen = False for setting_name, setting in self.export_settings.items(): if setting.value: export_chosen = True return export_chosen and valid_proj_dirs and settings_valid def projectDir(self): if hasattr(self, 'input_line'): return self.input_line.text() return '' def outputDir(self): if hasattr(self, 'output_line'): return self.output_line.text() return '' def createDownloadBar(self): hlayout = QtGui.QHBoxLayout() vlayout = QtGui.QVBoxLayout() progress_label = QtGui.QLabel('') progress_bar = QtGui.QProgressBar() progress_bar.setVisible(False) vlayout.addWidget(progress_label) vlayout.addWidget(progress_bar) vlayout.addWidget(QtGui.QLabel('')) ex_button = QtGui.QPushButton('Export') ex_button.setEnabled(False) cancel_button = QtGui.QPushButton('Cancel Download') cancel_button.setEnabled(False) ex_button.clicked.connect(self.callWithObject('export', ex_button, cancel_button)) cancel_button.clicked.connect(self.cancelDownload) buttonBox = QtGui.QDialogButtonBox() buttonBox.addButton(cancel_button, QtGui.QDialogButtonBox.RejectRole) buttonBox.addButton(ex_button, QtGui.QDialogButtonBox.AcceptRole) hlayout.addLayout(vlayout) hlayout.addWidget(buttonBox) self.progress_label = progress_label self.progress_bar = progress_bar self.cancel_button = cancel_button http = QHttp(self) http.requestFinished.connect(self.httpRequestFinished) http.dataReadProgress.connect(self.updateProgressBar) http.responseHeaderReceived.connect(self.readResponseHeader) self.http = http self.ex_button = ex_button return hlayout def readResponseHeader(self, response_header): # Check for genuine error conditions. if response_header.statusCode() not in (200, 300, 301, 302, 303, 307): self.show_error('Download failed: {}.'.format(response_header.reasonPhrase())) self.httpRequestAborted = True self.http.abort() self.enable_ui_after_error() def httpRequestFinished(self, requestId, error): if requestId != self.httpGetId: return if self.httpRequestAborted: if self.outFile is not None: self.outFile.close() self.outFile.remove() self.outFile = None return self.outFile.close() if error: self.outFile.remove() self.show_error('Download failed: {}.'.format(self.http.errorString())) self.enable_ui_after_error() self.continueDownloadingOrExtract() def continueDownloadingOrExtract(self): if self.files_to_download: self.progress_bar.setVisible(True) self.cancel_button.setEnabled(True) self.disableUIWhileWorking() self.download_file_with_error_handling() else: self.progress_text = 'Done.' self.cancel_button.setEnabled(False) self.progress_bar.setVisible(False) self.extractFilesInBackground() @property def progress_text(self): return self.progress_label.text() @progress_text.setter def progress_text(self, value): self.progress_label.setText(str(value)) def runInBackground(self, method_name, callback): self.thread = BackgroundThread(self, method_name) self.thread.finished.connect(callback) self.thread.start() def makeOutputFilesInBackground(self): self.ex_button.setEnabled(False) self.runInBackground('makeOutputDirs', self.doneMakingFiles) def doneMakingFiles(self): self.ex_button.setEnabled(self.requiredSettingsFilled()) self.progress_text = 'Done Exporting.' self.enableUI() if self.output_err: self.show_error(self.output_err) self.enable_ui_after_error() def extractFilesInBackground(self): self.progress_text = 'Extracting.' self.ex_button.setEnabled(False) self.runInBackground('extractFiles', self.doneExtracting) def extractFiles(self): self.extract_error = None for setting_name, setting in self.export_settings.items(): save_file_path = setting.save_file_path(self.selected_version()) try: if setting.value: extract_path = os.path.join('files', setting.name) if os.path.exists(save_file_path): for dest_file, fbytes in setting.get_file_bytes(self.selected_version()): with open(os.path.join(extract_path, dest_file), 'wb+') as d: d.write(fbytes) self.progress_text += '.' if os.path.exists(save_file_path): os.remove(save_file_path) #remove the zip/tar since we don't need it anymore self.progress_text += '.' except (tarfile.ReadError, zipfile.BadZipfile) as e: if os.path.exists(save_file_path): os.remove(save_file_path) self.extract_error = e #cannot use GUI in thread to notify user. Save it for later def doneExtracting(self): self.ex_button.setEnabled(self.requiredSettingsFilled()) if self.extract_error: self.progress_text = 'Error extracting.' self.show_error('There were one or more errors with your zip/tar files. They were deleted. Please try to export again.') self.enable_ui_after_error() else: self.progress_text = 'Done extracting.' self.makeOutputFilesInBackground() def cancelDownload(self): self.progress_text = 'Download cancelled.' self.cancel_button.setEnabled(False) self.httpRequestAborted = True self.http.abort() self.enableUI() def updateProgressBar(self, bytesRead, totalBytes): if self.httpRequestAborted: return self.progress_bar.setMaximum(totalBytes) self.progress_bar.setValue(bytesRead) def downloadFile(self, path, setting): self.progress_text = 'Downloading {}'.format(path.replace(self.base_url.format(self.selected_version()),'')) url = QUrl(path) fileInfo = QFileInfo(url.path()) fileName = setting.save_file_path(self.selected_version()) archive_exists = QFile.exists(fileName) dest_files_exist = True for dest_file in setting.dest_files: dest_file_path = os.path.join('files', setting.name, dest_file) dest_files_exist &= QFile.exists(dest_file_path) forced = self.getSetting('force_download').value if (archive_exists or dest_files_exist) and not forced: self.continueDownloadingOrExtract() return #QFile.remove(fileName) self.outFile = QFile(fileName) if not self.outFile.open(QIODevice.WriteOnly): self.show_error('Unable to save the file {}: {}.'.format(fileName, self.outFile.errorString())) self.outFile = None self.enableUI() return mode = QHttp.ConnectionModeHttp port = url.port() if port == -1: port = 0 self.http.setHost(url.host(), mode, port) self.httpRequestAborted = False path = QUrl.toPercentEncoding(url.path(), "!$&'()*+,;=:@/") if path: path = str(path) else: path = '/' # Download the file. self.httpGetId = self.http.get(path, self.outFile) def createDirectoryChoose(self): groupBox = QtGui.QGroupBox("Choose Your Web Project") input_layout = QtGui.QHBoxLayout() input_label = QtGui.QLabel('Project Directory:') self.input_line = QtGui.QLineEdit() self.input_line.textChanged.connect(self.projectPathChanged) input_button = QtGui.QPushButton('...') input_button.clicked.connect(self.browseDir) input_layout.addWidget(input_label) input_layout.addWidget(self.input_line) input_layout.addWidget(input_button) output_layout = QtGui.QHBoxLayout() output_label = QtGui.QLabel('Output Directory:') self.output_line = QtGui.QLineEdit() self.output_line.textChanged.connect(self.projectPathChanged) output_button = QtGui.QPushButton('...') output_button.clicked.connect(self.browseOutDir) output_layout.addWidget(output_label) output_layout.addWidget(self.output_line) output_layout.addWidget(output_button) vlayout = QtGui.QVBoxLayout() vlayout.addLayout(input_layout) vlayout.addLayout(output_layout) groupBox.setLayout(vlayout) return groupBox def callWithObject(self, name, obj, *args, **kwargs): """Allows arguments to be passed to click events""" def call(): if hasattr(self, name): func = getattr(self, name) func(obj, *args, **kwargs) return call def findChildByName(self, name): return self.findChild(QtCore.QObject, name) def findAllChildren(self, names): children = [] for child in self.findChildren(QtCore.QObject): if child.objectName() in names: children.append(child) return children def projectName(self): return self.findChildByName('name').text() def browseDir(self): directory = QtGui.QFileDialog.getExistingDirectory(self, "Find Project Directory", self.projectDir() or QtCore.QDir.currentPath()) if directory: self.resetSettings() self.input_line.setText(directory) self.output_line.setText(os.path.join(directory,'output')) proj_name = os.path.basename(directory) setting_input = self.findChildByName('main') files = glob.glob(os.path.join(directory,'index.html')) + glob.glob(os.path.join(directory,'index.php')) + glob.glob(os.path.join(directory,'index.htm')) if not setting_input.text(): if files: setting_input.setText(files[0].replace(self.projectDir()+os.path.sep,'')) app_name_input = self.findChildByName('name') title_input = self.findChildByName('title') if not app_name_input.text(): app_name_input.setText(proj_name) if not title_input.text(): title_input.setText(proj_name) self.loadPackageJson() def browseOutDir(self): directory = QtGui.QFileDialog.getExistingDirectory(self, "Choose Output Directory", self.projectDir() or QtCore.QDir.currentPath()) if directory: self.output_line.setText(directory) def getFile(self, obj, text_obj, setting, *args, **kwargs): file, junk = QtGui.QFileDialog.getOpenFileName(self, 'Choose File', self.projectDir() or QtCore.QDir.currentPath(), setting.file_types) if file: file = file.replace(self.projectDir()+os.path.sep,'') text_obj.setText(file) def createApplicationSettings(self): groupBox = QtGui.QGroupBox("Application Settings") vlayout = self.createLayout(self.application_setting_order) groupBox.setLayout(vlayout) return groupBox def createSetting(self, name): setting = self.getSetting(name) if setting.type == 'string': return self.createTextInputSetting(name) elif setting.type == 'file': return self.createTextInputWithFileSetting(name) elif setting.type == 'check': return self.createCheckSetting(name) elif setting.type == 'list': return self.createListSetting(name) def createWindowSettings(self): groupBox = QtGui.QGroupBox("Window Settings") vlayout = self.createLayout(self.window_setting_order) groupBox.setLayout(vlayout) return groupBox def createExportSettings(self): groupBox = QtGui.QGroupBox("Export to") vlayout = self.createLayout(self.export_setting_order) groupBox.setLayout(vlayout) return groupBox def createDownloadSettings(self): groupBox = QtGui.QGroupBox("Download Settings") vlayout = self.createLayout(self.download_setting_order) groupBox.setLayout(vlayout) return groupBox def createLayout(self, settings, cols=3): glayout = QtGui.QGridLayout() col = 0 row = 0 for setting_name in settings: setting = self.getSetting(setting_name) if col >= cols*2: row += 1 col = 0 display_name = setting.display_name+':' if setting.required: display_name += '*' glayout.addWidget(QtGui.QLabel(display_name),row,col) glayout.addLayout(self.createSetting(setting_name),row,col+1) col += 2 return glayout def createTextInputSetting(self, name): hlayout = QtGui.QHBoxLayout() setting = self.getSetting(name) text = QtGui.QLineEdit() text.setObjectName(setting.name) text.textChanged.connect(self.callWithObject('settingChanged', text, setting)) if setting.value: text.setText(str(setting.value)) hlayout.addWidget(text) return hlayout def createTextInputWithFileSetting(self, name): hlayout = QtGui.QHBoxLayout() setting = self.getSetting(name) text = QtGui.QLineEdit() text.setObjectName(setting.name) button = QtGui.QPushButton('...') button.setMaximumWidth(30) button.setMaximumHeight(26) button.clicked.connect(self.callWithObject('getFile', button, text, setting)) if setting.value: text.setText(str(setting.value)) text.textChanged.connect(self.callWithObject('settingChanged', text, setting)) hlayout.addWidget(text) hlayout.addWidget(button) return hlayout def resetSettings(self): for sgroup in self._setting_groups: for setting in sgroup.values(): widget = self.findChildByName(setting.name) if setting.type == 'string' or setting.type == 'file': old_val = '' if setting.default_value is not None: old_val = setting.default_value setting.value = old_val widget.setText(str(old_val)) elif setting.type == 'check': old_val = False if setting.default_value is not None: old_val = setting.default_value setting.value = old_val widget.setChecked(old_val) def settingChanged(self, obj, setting, *args, **kwargs): if setting.type == 'string' or setting.type == 'file': setting.value = obj.text() elif setting.type == 'check': setting.value = obj.isChecked() elif setting.type == 'list': setting.value = obj.currentText() self.ex_button.setEnabled(self.requiredSettingsFilled()) def projectPathChanged(self): self.ex_button.setEnabled(self.requiredSettingsFilled()) dirs_filled_out = False if self.projectDir() and self.outputDir(): if os.path.exists(self.projectDir()): dirs_filled_out = True self.option_settings_enabled(dirs_filled_out) def getSetting(self, name): for setting_group in self._setting_groups: if name in setting_group: setting = setting_group[name] return setting def createCheckSetting(self, name): hlayout = QtGui.QHBoxLayout() setting = self.getSetting(name) check = QtGui.QCheckBox() check.setObjectName(setting.name) check.clicked.connect(self.callWithObject('settingChanged', check, setting)) check.setChecked(setting.value) hlayout.addWidget(check) return hlayout def createListSetting(self, name): hlayout = QtGui.QHBoxLayout() setting = self.getSetting(name) combo = QtGui.QComboBox() combo.setObjectName(setting.name) combo.currentIndexChanged.connect(self.callWithObject('settingChanged', combo, setting)) combo.editTextChanged.connect(self.callWithObject('settingChanged', combo, setting)) for val in setting.values: combo.addItem(val) default_index = combo.findData(setting.default_value) if default_index != -1: combo.setCurrentIndex(default_index) hlayout.addWidget(combo) return hlayout def generate_json(self): if 'webkit' not in self.original_packagejson: self.original_packagejson['webkit'] = {} if 'window' not in self.original_packagejson: self.original_packagejson['window'] = {} dic = self.original_packagejson for setting_name, setting in self.app_settings.items(): if setting.value is not None: dic[setting_name] = setting.value if setting_name == 'keywords': dic[setting_name] = re.findall("\w+", setting.value) for setting_name, setting in self.window_settings.items(): if setting.value is not None: if 'height' in setting.name or 'width' in setting.name: try: dic['window'][setting_name] = int(setting.value) except ValueError: pass else: dic['window'][setting_name] = setting.value for setting_name, setting in self.webkit_settings.items(): if setting.value is not None: dic['webkit'][setting_name] = setting.value s = json.dumps(dic, indent=4) return s def loadPackageJson(self): p_json = glob.glob(os.path.join(self.projectDir(), 'package.json')) if p_json: json_str = '' with open(p_json[0], 'r') as f: json_str = f.read() try: self.load_from_json(json_str) except ValueError: #Json file is invalid log( 'Warning: Json file invalid.') def load_from_json(self, json_str): dic = json.loads(json_str) self.original_packagejson = dic stack = [('root',dic)] while stack: parent, new_dic = stack.pop() for item in new_dic: setting_field = self.findChildByName(item) setting = self.getSetting(item) if setting_field: if setting.type == 'file' or setting.type == 'string': val_str = self.convert_val_to_str(new_dic[item]) setting_field.setText(val_str) setting.value = val_str if setting.type == 'check': setting_field.setChecked(new_dic[item]) setting.value = new_dic[item] if isinstance(new_dic[item], dict): stack.append((item,new_dic[item])) def convert_val_to_str(self, val): if isinstance(val, (list,tuple)): return ', '.join(val) return str(val).replace(self.projectDir()+os.path.sep,'') def copyFilesToProjectFolder(self): old_dir = CWD os.chdir(self.projectDir()) for sgroup in self._setting_groups: for setting in sgroup.values(): if setting.type == 'file' and setting.value: try: shutil.copy(setting.value, self.projectDir()) setting.value = os.path.basename(setting.value) except shutil.Error as e:#same file warning log( 'Warning: {}'.format(e)) os.chdir(old_dir) def makeOutputDirs(self): self.output_err = '' try: self.progress_text = 'Removing old output directory...' outputDir = os.path.join(self.outputDir(), self.projectName()) tempDir = os.path.join(TEMP_DIR, 'webexectemp') if os.path.exists(tempDir): shutil.rmtree(tempDir) self.progress_text = 'Making new directories...' if not os.path.exists(outputDir): os.makedirs(outputDir) os.makedirs(tempDir) self.copyFilesToProjectFolder() json_file = os.path.join(self.projectDir(), 'package.json') with open(json_file, 'w+') as f: f.write(self.generate_json()) zip_file = os.path.join(tempDir, self.projectName()+'.nw') zip_files(zip_file, self.projectDir(), exclude_paths=[outputDir]) for ex_setting in self.export_settings.values(): if ex_setting.value: self.progress_text = 'Making files for {}'.format(ex_setting.display_name) export_dest = os.path.join(outputDir, ex_setting.name) if os.path.exists(export_dest): shutil.rmtree(export_dest) #shutil will make the directory for us shutil.copytree(os.path.join('files', ex_setting.name), export_dest) self.progress_text += '.' if ex_setting.name == 'mac': app_path = os.path.join(export_dest, self.projectName()+'.app') shutil.move(os.path.join(export_dest, 'node-webkit.app'), app_path) self.progress_text += '.' shutil.copy(zip_file, os.path.join(app_path, 'Contents', 'Resources', 'app.nw')) self.progress_text += '.' else: ext = '' if ex_setting.name == 'windows': ext = '.exe' nw_path = os.path.join(export_dest, ex_setting.dest_files[0]) dest_binary_path = os.path.join(export_dest, self.projectName()+ext) join_files(os.path.join(export_dest, self.projectName()+ext), nw_path, zip_file) sevenfivefive = stat.S_IRWXU | stat.S_IRGRP | stat.S_IXGRP | stat.S_IROTH | stat.S_IXOTH os.chmod(dest_binary_path, sevenfivefive) self.progress_text += '.' if os.path.exists(nw_path): os.remove(nw_path) except Exception as e: self.output_err += ''.join(traceback.format_exception(sys.exc_info()[0], sys.exc_info()[1], sys.exc_info()[2])) finally: shutil.rmtree(tempDir) def show_and_raise(self): self.show() self.raise_()
def parse_asn1(*files, **options): ''' Call the ASN.1 parser on a number of files, and return the module containing the AST This function uses QProcess to launch the ASN.1 compiler because the subprocess module from Python has issues on the Windows platform ''' ast_version = options.get('ast_version', ASN1.UniqueEnumeratedNames) rename_policy = options.get('rename_policy', ASN1.NoRename) flags = options.get('flags', [ASN1.AstOnly]) pprint = options.get('pretty_print', False) assert isinstance(ast_version, ASN1) assert isinstance(rename_policy, ASN1) assert isinstance(flags, list) path_to_asn1scc = spawn.find_executable('asn1.exe') if not path_to_asn1scc: raise TypeError('ASN.1 Compiler not found in path') if os.name == 'posix': path_to_mono = spawn.find_executable('mono') if not path_to_mono: raise TypeErorr('"mono" not found in path. Please install it.') binary = path_to_mono arg0 = path_to_asn1scc else: binary = path_to_asn1scc arg0 = '' asn1scc_root = os.path.abspath(os.path.dirname(path_to_asn1scc)) # Create a temporary directory to store dataview.py and import it tempdir = tempfile.mkdtemp() sys.path.append(tempdir) if os.name == 'nt': # On windows, remove the drive letter, workaround to ASN1SCC bug tempdir = tempdir[2:] asn1scc_root = asn1scc_root[2:] filename = str(uuid.uuid4()).replace('-', '_') filepath = tempdir + os.sep + filename + '.py' stg = asn1scc_root + os.sep + 'python.stg' if pprint: # Generate an html file with pretty-printed ASN.1 types stg_qrc = QFile(':misc/pretty_print_asn1.stg') stg_qrc.open(1) content = stg_qrc.readAll() stgfile = tempdir + os.sep + 'pretty_print_asn1.stg' with open(stgfile, 'w') as tmpfile: tmpfile.write(content.data()) out_html = tempdir + os.sep + 'dataview.html' html = ['-customIcdUper', stgfile + '::' + out_html] else: html = [] args = [ arg0, '-customStgAstVerion', str(ast_version.value), '-customStg', stg + '::' + filepath, '-renamePolicy', str(rename_policy.value) ] + html + list(*files) asn1scc = QProcess() LOG.debug(os.getcwd()) LOG.debug(binary + ' ' + ' '.join(args)) asn1scc.start(binary, args) _ = waitfor_qprocess(asn1scc, "ASN.1 Compiler") if filename in AST.viewkeys(): # Re-import module if it was already loaded ast = AST[filename] reload(ast) else: ast = importlib.import_module(filename) AST[filename] = ast if pprint: # add the path to the optionally-gernated pretty-printed HTML file ast.html = out_html return ast
def parse_asn1(*files, **options): ''' Call the ASN.1 parser on a number of files, and return the module containing the AST This function uses QProcess to launch the ASN.1 compiler because the subprocess module from Python has issues on the Windows platform ''' # use basic caching to avoid re-parsing when loading the model project_cache = os.getenv ("PROJECT_CACHE") if project_cache is not None and not os.path.isdir(project_cache): raise TypeError ( "The configured cache folder \"" + project_cache + "\" is not there!\n") # make sure the same files are not parsed more than once if not modified filehash = hashlib.md5() file_list = sorted(list(*files)) try: for each in file_list: filehash.update(open(each).read()) # also hash the file path: it is used in the AST, so it is # not enough to hash the content of the ASN.1 files, as two sets # of input files may have the same hash filehash.update(each) except IOError as err: raise TypeError (str(err)) new_hash = filehash.hexdigest() # names of the files that will be generated by asn1scc and then parsed out_py_name = new_hash + ".py" out_html_name = new_hash + ".html" if new_hash in AST.viewkeys(): return AST[new_hash] elif project_cache is not None: outdir = project_cache elif project_cache is None: outdir = tempfile.mkdtemp() # to allow the import sys.path.append(outdir) ast_version = options.get('ast_version', ASN1.UniqueEnumeratedNames) rename_policy = options.get('rename_policy', ASN1.NoRename) flags = options.get('flags', [ASN1.AstOnly]) pprint = options.get('pretty_print', False) assert isinstance(ast_version, ASN1) assert isinstance(rename_policy, ASN1) assert isinstance(flags, list) path_to_asn1scc = spawn.find_executable('asn1.exe') if not path_to_asn1scc: raise TypeError('ASN.1 Compiler not found in path') if os.name == 'posix': path_to_mono = spawn.find_executable('mono') if not path_to_mono: raise TypeError('"mono" not found in path. Please install it.') binary = path_to_mono arg0 = path_to_asn1scc else: binary = path_to_asn1scc arg0 = '' asn1scc_root = os.path.abspath(os.path.dirname(path_to_asn1scc)) if os.name == 'nt': # On windows, remove the drive letter, workaround to ASN1SCC bug outdir = outdir[2:] asn1scc_root = asn1scc_root[2:] # The two possible files that can be generated with complete path: py_filepath = outdir + os.sep + out_py_name html_filepath = outdir + os.sep + out_html_name # call the ASN.1 compiler only if there is no existing cached file if project_cache is None or not os.path.exists(py_filepath): stg = asn1scc_root + os.sep + 'python.stg' if pprint: # Generate an html file with pretty-printed ASN.1 types stg_qrc = QFile(':misc/pretty_print_asn1.stg') stg_qrc.open(1) content = stg_qrc.readAll() stgfile = outdir + os.sep + 'pretty_print_asn1.stg' with open(stgfile, 'w') as tmpfile: tmpfile.write(content.data()) html = ['-customIcdUper', stgfile + '::' + html_filepath] else: html = [] args = [arg0, '-customStgAstVersion', str(ast_version.value), '-customStg', stg + '::' + py_filepath, '-renamePolicy', str(rename_policy.value)] + html + file_list asn1scc = QProcess() LOG.debug(os.getcwd()) LOG.debug(binary + ' ' + ' '.join(args)) asn1scc.start(binary, args) _ = waitfor_qprocess(asn1scc, "ASN.1 Compiler") ast = importlib.import_module(new_hash) AST[new_hash] = ast if pprint: # add the path to the optionally-generated pretty-printed HTML file ast.html = html_filepath return ast
def loadStyleSheet(sheetName): file = QFile(sheetName) file.open(QFile.ReadOnly) styleSheet = file.readAll() return str(styleSheet)