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 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)
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 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 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 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
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 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 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)
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)
