def copy_embedded_file(src_name, dst_name, macros={}):
""" Copy an embedded source file to a destination file. src_name is the
name of the source file. dst_name is the name of the destination file.
macros is an optional dictionary of key/value string macros and instances
of each key are replaced by the corresponding value. A UserException is
raised if there was an error.
"""
contents = read_embedded_file(src_name)
for key, value in macros.items():
contents.replace(bytes(key, encoding='ascii'),
bytes(value, encoding='ascii'))
dst_file = QFile(dst_name)
if not dst_file.open(QIODevice.WriteOnly | QIODevice.Text):
raise UserException(
"Unable to create file {0}.".format(dst_file.fileName()),
dst_file.errorString())
if dst_file.write(contents) < 0:
raise UserException(
"Unable to write to file {0}.".format(dst_file.fileName()),
dst_file.errorString())
dst_file.close()
def __saveImage(self, fileName):
"""
Private method to save the snapshot.
@param fileName name of the file to save to (string)
@return flag indicating success (boolean)
"""
if QFileInfo(fileName).exists():
res = E5MessageBox.yesNo(
self,
self.tr("Save Snapshot"),
self.tr("<p>The file <b>{0}</b> already exists."
" Overwrite it?</p>").format(fileName),
icon=E5MessageBox.Warning)
if not res:
return False
file = QFile(fileName)
if not file.open(QFile.WriteOnly):
E5MessageBox.warning(
self, self.tr("Save Snapshot"),
self.tr("Cannot write file '{0}:\n{1}.").format(
fileName, file.errorString()))
return False
ok = self.__snapshot.save(file)
file.close()
if not ok:
E5MessageBox.warning(
self, self.tr("Save Snapshot"),
self.tr("Cannot write file '{0}:\n{1}.").format(
fileName, file.errorString()))
return ok
def copy_embedded_file(src_name, dst_name, macros={}):
""" Copy an embedded source file to a destination file. src_name is the
name of the source file. dst_name is the name of the destination file.
macros is an optional dictionary of key/value string macros and instances
of each key are replaced by the corresponding value. A UserException is
raised if there was an error.
"""
contents = read_embedded_file(src_name)
for key, value in macros.items():
contents.replace(bytes(key, encoding='ascii'),
bytes(value, encoding='ascii'))
dst_file = QFile(dst_name)
if not dst_file.open(QIODevice.WriteOnly|QIODevice.Text):
raise UserException(
"Unable to create file {0}.".format(dst_file.fileName()),
dst_file.errorString())
if dst_file.write(contents) < 0:
raise UserException(
"Unable to write to file {0}.".format(dst_file.fileName()),
dst_file.errorString())
dst_file.close()
def __saveImage(self, fileName):
"""
Private method to save the snapshot.
@param fileName name of the file to save to (string)
@return flag indicating success (boolean)
"""
if QFileInfo(fileName).exists():
res = E5MessageBox.yesNo(
self,
self.tr("Save Snapshot"),
self.tr("<p>The file <b>{0}</b> already exists."
" Overwrite it?</p>").format(fileName),
icon=E5MessageBox.Warning)
if not res:
return False
file = QFile(fileName)
if not file.open(QFile.WriteOnly):
E5MessageBox.warning(
self, self.tr("Save Snapshot"),
self.tr("Cannot write file '{0}:\n{1}.")
.format(fileName, file.errorString()))
return False
ok = self.__snapshot.save(file)
file.close()
if not ok:
E5MessageBox.warning(
self, self.tr("Save Snapshot"),
self.tr("Cannot write file '{0}:\n{1}.")
.format(fileName, file.errorString()))
return ok
def loadFile(self, fileName):
"""
Open an existing project file
"""
file = QFile(fileName)
if not file.open(QFile.ReadOnly | QFile.Text):
flag = True
QApplication.setOverrideCursor(Qt.WaitCursor)
# read a project and create scenario
if self.project.read(fileName):
#self.outputs_refresh()
self.table_list_refresh('scenario')
self.table_list_refresh('event')
self.project_display()
self.protocol_display()
QApplication.restoreOverrideCursor()
self.setCurrentFile(fileName)
flag = False
else:
flag = True
if flag:
QMessageBox.warning(self, "Lekture Error 123",
"Cannot read file %s:\n%s." % (fileName, file.errorString()))
return False
#self.document().commandsChanged.connect(self.documentWasModified)
return True
def __importCertificate(self):
"""
Private method to read a certificate.
@return certificates read (list of QSslCertificate)
"""
fname = E5FileDialog.getOpenFileName(
self,
self.tr("Import Certificate"),
"",
self.tr("Certificate Files (*.pem *.crt *.der *.cer *.ca);;" "All Files (*)"),
)
if fname:
f = QFile(fname)
if not f.open(QIODevice.ReadOnly):
E5MessageBox.critical(
self,
self.tr("Export Certificate"),
self.tr(
"""<p>The certificate could not be read from file""" """ <b>{0}</b></p><p>Error: {1}</p>"""
).format(fname, f.errorString()),
)
return []
crt = f.readAll()
f.close()
cert = QSslCertificate.fromData(crt, QSsl.Pem)
if not cert:
cert = QSslCertificate.fromData(crt, QSsl.Der)
return cert
return []
def save(self, content, path=None):
"""
Write a temporary file with .tnj extension and copy it over the
original one.
.nsf = Ninja Swap File
# FIXME: Where to locate addExtension, does not fit here
"""
new_path = False
if path:
self.attach_to_path(path)
new_path = True
save_path = self._file_path
if not save_path:
raise NinjaNoFileNameException("I am asked to write a "
"file but no one told me where")
swap_save_path = "%s.nsp" % save_path
# If we have a file system watcher, remove the file path
# from its watch list until we are done making changes.
if self.__watcher is not None:
self.__watcher.removePath(save_path)
flags = QIODevice.WriteOnly | QIODevice.Truncate
f = QFile(swap_save_path)
if settings.use_platform_specific_eol():
flags |= QIODevice.Text
if not f.open(flags):
raise NinjaIOException(f.errorString())
stream = QTextStream(f)
encoding = get_file_encoding(content)
if encoding:
stream.setCodec(encoding)
encoded_stream = stream.codec().fromUnicode(content)
f.write(encoded_stream)
f.flush()
f.close()
# SIGNAL: Will save (temp, definitive) to warn folder to do something
self.willSave.emit(swap_save_path, save_path)
self.__mtime = os.path.getmtime(swap_save_path)
shutil.move(swap_save_path, save_path)
self.reset_state()
# If we have a file system watcher, add the saved path back
# to its watch list, otherwise create a watcher and start
# watching
if self.__watcher is not None:
if new_path:
# FIXME: what?
# self.__watcher.removePath(self.__watcher.files()[0])
self.__watcher.addPath(self._file_path)
else:
self.__watcher.addPath(save_path)
else:
self.start_watching()
return self
def saveQTextStream(self):
error = None
fh = None
try:
fh = QFile(self.__fname)
if not fh.open(QIODevice.WriteOnly):
raise IOError(unicode(fh.errorString()))
stream = QTextStream(fh)
stream.setCodec(CODEC)
for key, movie in self.__movies:
stream << "{{MOVIE}} " << movie.title << "\n" \
<< movie.year << " " << movie.minutes << " " \
<< movie.acquired.toString(Qt.ISODate) \
<< "\n{NOTES}"
if not movie.notes.isEmpty():
stream << "\n" << movie.notes
stream << "\n{{ENDMOVIE}}\n"
except (IOError, OSError) as e:
error = "Failed to save: {0}".format(e)
finally:
if fh is not None:
fh.close()
if error is not None:
return False, error
self.__dirty = False
return True, "Saved {0} movie records to {1}".format(
len(self.__movies),
QFileInfo(self.__fname).fileName())
def client_script():
""" Reads qtwebchannel.js from disk and creates QWebEngineScript to inject to QT window.
This allows for JavaScript code to call python methods marked by pyqtSlot in registered objects.
Args:
None.
Returns:
None.
Raises:
"""
qwebchannel_js = QFile(':/qtwebchannel/qwebchannel.js')
if not qwebchannel_js.open(QIODevice.ReadOnly):
raise SystemExit(
'Failed to load qwebchannel.js with error: %s' %
qwebchannel_js.errorString())
qwebchannel_js = bytes(qwebchannel_js.readAll()).decode('utf-8')
script = QWebEngineScript()
script.setSourceCode(qwebchannel_js)
script.setName('qWebChannelJS')
script.setWorldId(QWebEngineScript.MainWorld)
script.setInjectionPoint(QWebEngineScript.DocumentReady)
script.setRunsOnSubFrames(True)
return script
def exportXml(self, fname):
error = None
fh = None
try:
fh = QFile(fname)
if not fh.open(QIODevice.WriteOnly):
raise IOError(unicode(fh.errorString()))
stream = QTextStream(fh)
stream.setCodec(CODEC)
stream << ("<?xml version='1.0' encoding='{0}'?>\n"
"<!DOCTYPE MOVIES>\n"
"<MOVIES VERSION='1.0'>\n".format(CODEC))
for key, movie in self.__movies:
stream << ("<MOVIE YEAR='{0}' MINUTES='{1}' "
"ACQUIRED='{2}'>\n".format(movie.year,
movie.minutes,
movie.acquired.toString(Qt.ISODate))) \
<< "<TITLE>" << Qt.escape(movie.title) \
<< "</TITLE>\n<NOTES>"
if not movie.notes.isEmpty():
stream << "\n" << Qt.escape(encodedNewlines(movie.notes))
stream << "\n</NOTES>\n</MOVIE>\n"
stream << "</MOVIES>\n"
except (IOError, OSError) as e:
error = "Failed to export: {0}".format(e)
finally:
if fh is not None:
fh.close()
if error is not None:
return False, error
self.__dirty = False
return True, "Exported {0} movie records to {1}".format(
len(self.__movies),
QFileInfo(fname).fileName())
def load_datastream(self, fname):
error = None
fh = None
try:
fh = QFile(fname)
if not fh.open(QIODevice.ReadOnly):
raise IOError(str(fh.errorString()))
stream = QDataStream(fh)
while not stream.atEnd():
self.label = stream.readQString()
self.diameter = stream.readInt32()
self.top_elev = stream.readDouble()
self.design_load = stream.readDouble()
except EnvironmentError as e:
error = "Failed to load:{0}".format(e)
finally:
if fh is not None:
fh.close()
if error is not None:
print(error)
self.__dirty = False
print("load data from{0}".format(QFileInfo(fname).fileName()))
# 缺少计算参数的类
def save(self):
if "Unnamed" in self.filename:
filename = QFileDialog.getSaveFileName(
self, "G.R.O.M. Editor -- Save File As", self.filename,
"MD files (*.mdp *.itp *.top *.*)")
print('filename is ', filename)
if len(filename[0]) == 0:
return
self.filename = filename[0]
self.setWindowTitle(QFileInfo(self.filename).fileName())
exception = None
fh = None
try:
fh = QFile(self.filename)
if not fh.open(QIODevice.WriteOnly):
raise IOError(str(fh.errorString()))
stream = QTextStream(fh)
stream.setCodec("UTF-8")
stream << self.toPlainText()
self.document().setModified(False)
except EnvironmentError as e:
exception = e
finally:
if fh is not None:
fh.close()
if exception is not None:
raise exception
def load_file(self, fname, check_for_changes=True):
"""
load a file's content into the application.
Parameters
----------
fname : str
full file path and name of the file to load
check_for_changes : bool
flag to check for save prompt if file has unsaved changes
Returns
-------
None
"""
if check_for_changes:
changed = self.check_for_changes()
if changed == "Cancel":
return changed
self.file_watcher = QFileSystemWatcher([fname])
self.file_watcher.fileChanged.connect(self.file_updated)
self.last_updated = time.time()
self.clear_validation()
# check that we have read write access to the file
file = QFile(fname)
if not file.open(QFile.ReadOnly | QFile.Text):
msg = "Cannot read file %s:\n%s." % (fname, file.errorString())
QMessageBox.warning(self, "Recent Files", msg)
return
file.close()
self.load_file_content(fname)
def openFile(self, checked=True, path=None):
"""
Open a new file.
If current editor is associated with a file or its content is not null,
Then create a new editor tab
:return:
"""
path = QFileDialog.getOpenFileName()[0] if not path else path
if len(path) != 0:
qfile = QFile(path)
if not qfile.open(QFile.ReadOnly or QFile.Text):
QMessageBox.warning(self, 'Application',
'Cannot read file %s:\n%s.' % (path, qfile.errorString()))
return
with open(path, 'r') as _file:
content = _file.read()
if self.currentEditor.file or len(self.currentEditor.document().toPlainText()) > 0:
self.createEditorTab()
# associate file on disk with editor
self.currentEditor.file = path
# update tab name
index = self.ui.tabWidgetEditor.indexOf(self.currentEditorTab)
_translate = QCoreApplication.translate
self.ui.tabWidgetEditor.setTabText(
index, _translate("MainWindow", ntpath.basename(path)))
self.ui.tabWidgetEditor.setCurrentIndex(index)
self.currentEditor.setPlainText(content)
def writeTileset(self, *args):
l = len(args)
if l==3:
tileset, device, path = args
self.d.writeTileset(tileset, device, path)
elif l==2:
tp = type(args[1])
if tp==QIODevice:
tileset, device, path = args, QString()
self.d.writeTileset(tileset, device, path)
elif tp in [QString, str]:
##
# Writes a TSX tileset to the given \a fileName.
#
# Returns False and sets errorString() when reading failed.
# \overload
##
tileset, fileName = args
file = QFile(fileName)
if (not self.d.openFile(file)):
return False
self.writeTileset(tileset, file, QFileInfo(fileName).absolutePath())
if (file.error() != QFile.NoError):
self.d.mError = file.errorString()
return False
return True
def save(self):
if not self.filename:
path = "."
fname,filetype = QFileDialog.getSaveFileName(self,
"Page Designer - Save As", path,
"Page Designer Files (*.pgd)")
if not fname:
return
self.filename = fname
fh = None
try:
fh = QFile(self.filename)
if not fh.open(QIODevice.WriteOnly):
raise IOError(str(fh.errorString()))
self.scene.clearSelection()
stream = QDataStream(fh)
stream.setVersion(QDataStream.Qt_5_7)
stream.writeInt32(MagicNumber)
stream.writeInt16(FileVersion)
for item in self.scene.items():
self.writeItemToStream(stream, item)
except IOError as e:
QMessageBox.warning(self, "Page Designer -- Save Error",
"Failed to save {0}: {1}".format(self.filename, e))
finally:
if fh is not None:
fh.close()
global Dirty
Dirty = False
def writeObjectTypes(self, fileName, objectTypes):
self.mError = ''
file = QFile(fileName)
if (not file.open(QIODevice.WriteOnly | QIODevice.Text)):
self.mError = QCoreApplication.translate(
"ObjectTypes", "Could not open file for writing.")
return False
writer = QXmlStreamWriter(file)
writer.setAutoFormatting(True)
writer.setAutoFormattingIndent(1)
writer.writeStartDocument()
writer.writeStartElement("objecttypes")
for objectType in objectTypes:
writer.writeStartElement("objecttype")
writer.writeAttribute("name", objectType.name)
writer.writeAttribute("color", objectType.color.name())
writer.writeEndElement()
writer.writeEndElement()
writer.writeEndDocument()
if (file.error() != QFile.NoError):
self.mError = file.errorString()
return False
return True
def openJSONData(self, filePath):
self.msgBox = QMessageBox()
self.fly = QApplication.desktop().screen().rect().center(
) - self.msgBox.rect().center()
fileInfo = QFileInfo(filePath)
fileName = fileInfo.fileName()
openFile = QFile(filePath)
openFile.open(QIODevice.ReadOnly | QIODevice.Text)
if openFile.error() != openFile.NoError:
self.msgBox.information(
QDialog().move(self.fly), "{}".format(fileName),
self.translate("openV2rayJSONFile",
"Unable to open the file {}: {}.").format(
fileName, openFile.errorString()))
openFile = None
return
JSONData = str(openFile.readAll(), "utf-8")
try:
JSONData = json.loads(JSONData)
except ValueError as e:
self.msgBox.information(
QDialog().move(self.fly),
self.translate("openV2rayJSONFile", "Parse JSON Data Error"),
self.translate("openV2rayJSONFile",
"Unable to parse {}: error:{}.").format(
fileName, e))
openFile = None
JSONData = None
return
else:
return JSONData
openFile.close()
def __importCertificate(self):
"""
Private method to read a certificate.
@return certificates read (list of QSslCertificate)
"""
fname = E5FileDialog.getOpenFileName(
self,
self.tr("Import Certificate"),
"",
self.tr("Certificate Files (*.pem *.crt *.der *.cer *.ca);;"
"All Files (*)"))
if fname:
f = QFile(fname)
if not f.open(QIODevice.ReadOnly):
E5MessageBox.critical(
self,
self.tr("Export Certificate"),
self.tr(
"""<p>The certificate could not be read from file"""
""" <b>{0}</b></p><p>Error: {1}</p>""")
.format(fname, f.errorString()))
return []
crt = f.readAll()
f.close()
cert = QSslCertificate.fromData(crt, QSsl.Pem)
if not cert:
cert = QSslCertificate.fromData(crt, QSsl.Der)
return cert
return []
def _initPreviewToTextSync(self):
"""Initialize the system per items 1, 2, and 4 above."""
# When a web page finishes loading, reinsert our JavaScript.
page = self._dock._widget.webEngineView.page()
# Insert our scripts into every loaded page.
qwebchannel_js = QFile(':/qtwebchannel/qwebchannel.js')
if not qwebchannel_js.open(QIODevice.ReadOnly):
raise SystemExit('Failed to load qwebchannel.js with error: %s' %
qwebchannel_js.errorString())
qwebchannel_js = bytes(qwebchannel_js.readAll()).decode('utf-8')
# Set up the QWebChannel. See http://doc.qt.io/qt-5/qtwebchannel-javascript.html.
# Run the script containing QWebChannel.js first.
beforeScript = QWebEngineScript()
beforeScript.setSourceCode(qwebchannel_js + self._jsPreviewSync +
self._qtJsInit)
beforeScript.setName('qwebchannel.js, previewSync')
# Run this JavaScript separated from any JavaScript present in the loaded web page. This provides better security (rogue pages can't access the QWebChannel) and better isolation (handlers, etc. won't conflict, I hope).
beforeScript.setWorldId(QWebEngineScript.ApplicationWorld)
beforeScript.setInjectionPoint(QWebEngineScript.DocumentCreation)
# Per `setWebChannel <http://doc.qt.io/qt-5/qwebenginepage.html#setWebChannel>`_, only one channel is allowed per page. So, don't run this on sub-frames, since it will attempt the creation of more channels for each subframe.
beforeScript.setRunsOnSubFrames(False)
page.scripts().insert(beforeScript)
# Set up the web channel. See https://riverbankcomputing.com/pipermail/pyqt/2015-August/036346.html
# and http://stackoverflow.com/questions/28565254/how-to-use-qt-webengine-and-qwebchannel.
# For debug, ``set QTWEBENGINE_REMOTE_DEBUGGING=port`` then browse to
# http://127.0.0.1:port, where port=60000 works for me. See https://riverbankcomputing.com/pipermail/pyqt/2015-August/036346.html.
self.channel = QWebChannel(page)
self.channel.registerObject("previewSync", self)
# Expose the ``qt.webChannelTransport`` object in the world where these scripts live.
page.setWebChannel(self.channel, QWebEngineScript.ApplicationWorld)
def importDOM(self, fname):
dom = QDomDocument()
error = None
fh = None
try:
fh = QFile(fname)
if not fh.open(QIODevice.ReadOnly):
raise IOError(unicode(fh.errorString()))
if not dom.setContent(fh):
raise ValueError("could not parse XML")
except (IOError, OSError, ValueError) as e:
error = "Failed to import: {0}".format(e)
finally:
if fh is not None:
fh.close()
if error is not None:
return False, error
try:
self.populateFromDOM(dom)
except ValueError as e:
return False, "Failed to import: {0}".format(e)
self.__fname = QString()
self.__dirty = True
return True, "Imported {0} movie records from {1}".format(
len(self.__movies),
QFileInfo(fname).fileName())
def exportToTxt(self, fname):
error = None
fh = None
try:
fh = QFile(fname)
if not fh.open(QIODevice.WriteOnly):
raise IOError(fh.errorString())
htmlTags = re.compile(r"<[^>]+?>")
nonDigits = re.compile("[., ]")
stream = QTextStream(fh)
stream.setCodec(CODEC)
for row in range(self.rowCount()):
name = self.data(self.index(row, NAME))
owner = self.data(self.index(row, OWNER))
country = self.data(self.index(row, COUNTRY))
teu = self.data(self.index(row, TEU))
teu = int(nonDigits.sub("", teu))
description = self.data(self.index(row, DESCRIPTION))
description = htmlTags.sub("", description)
stream << name << "|" << owner << "|" << country \
<< "|" << teu << "|" << description << '\r\n'
except Exception as e:
error = "Failed to save: {}".format(e)
finally:
if fh is not None:
fh.close()
if error is not None:
return False, error
return True, "Saved {} ship records to {}".format(
len(self.ships),
QFileInfo(fname).fileName())
def _initPreviewToTextSync(self):
"""Initialize the system per items 1, 2, and 4 above."""
# When a web page finishes loading, reinsert our JavaScript.
page = self._dock._widget.webEngineView.page()
# Insert our scripts into every loaded page.
qwebchannel_js = QFile(':/qtwebchannel/qwebchannel.js')
if not qwebchannel_js.open(QIODevice.ReadOnly):
raise SystemExit(
'Failed to load qwebchannel.js with error: %s' %
qwebchannel_js.errorString())
qwebchannel_js = bytes(qwebchannel_js.readAll()).decode('utf-8')
# Set up the QWebChannel. See http://doc.qt.io/qt-5/qtwebchannel-javascript.html.
# Run the script containing QWebChannel.js first.
beforeScript = QWebEngineScript()
beforeScript.setSourceCode(qwebchannel_js + self._jsPreviewSync + self._qtJsInit)
beforeScript.setName('qwebchannel.js, previewSync')
# Run this JavaScript separated from any JavaScript present in the loaded web page. This provides better security (rogue pages can't access the QWebChannel) and better isolation (handlers, etc. won't conflict, I hope).
beforeScript.setWorldId(QWebEngineScript.ApplicationWorld)
beforeScript.setInjectionPoint(QWebEngineScript.DocumentCreation)
# Per `setWebChannel <http://doc.qt.io/qt-5/qwebenginepage.html#setWebChannel>`_, only one channel is allowed per page. So, don't run this on sub-frames, since it will attempt the creation of more channels for each subframe.
beforeScript.setRunsOnSubFrames(False)
page.scripts().insert(beforeScript)
# Set up the web channel. See https://riverbankcomputing.com/pipermail/pyqt/2015-August/036346.html
# and http://stackoverflow.com/questions/28565254/how-to-use-qt-webengine-and-qwebchannel.
# For debug, ``set QTWEBENGINE_REMOTE_DEBUGGING=port`` then browse to
# http://127.0.0.1:port, where port=60000 works for me. See https://riverbankcomputing.com/pipermail/pyqt/2015-August/036346.html.
self.channel = QWebChannel(page)
self.channel.registerObject("previewSync", self)
# Expose the ``qt.webChannelTransport`` object in the world where these scripts live.
page.setWebChannel(self.channel, QWebEngineScript.ApplicationWorld)
def load(self):
exception = None
fh = None
try:
if not self.filename:
raise IOError("no filename specified for loading")
fh = QFile(self.filename)
if not fh.open(QIODevice.ReadOnly):
raise IOError(fh.errorString())
stream = QDataStream(fh)
magic = stream.readInt32()
if magic != MAGIC_NUMBER:
raise IOError("unrecognized file type")
fileVersion = stream.readInt16()
if fileVersion != FILE_VERSION:
raise IOError("unrecognized file type version")
self.ships = {}
while not stream.atEnd():
name = stream.readQString()
owner = stream.readQString()
country = stream.readQString()
description = stream.readQString()
teu = stream.readInt32()
ship = Ship(name, owner, country, teu, description)
self.ships[id(ship)] = ship
self.owners.add(owner)
self.countries.add(country)
self.dirty = False
except IOError as e:
exception = e
finally:
if fh is not None:
fh.close()
if exception is not None:
raise exception
def on_btnExportTrace_clicked(self):
"""
Export the contents of the trace tab to .txt file
"""
# get filename to save as
dlg = QFileDialog()
dlg.setAcceptMode(QFileDialog.AcceptSave)
dlg.setDefaultSuffix("txt")
dlg.setNameFilters(["Trace File (*.txt)", "all files (*.*)"])
dlg.setDirectory(self.parent.settings.value("Default/ProjPath"))
if dlg.exec_():
fileNames = dlg.selectedFiles()
if fileNames:
self.fileName = fileNames[0]
# save the file
file = QFile(self.fileName)
if not file.open(QFile.WriteOnly | QFile.Text):
self.helper.displayErrMsg(
"Export Trace Error", "Cannot write file {} {}".format(
self.fileName, file.errorString()))
return
outstr = QTextStream(file)
QApplication.setOverrideCursor(Qt.WaitCursor)
outstr << self.textTrace.toPlainText()
QApplication.restoreOverrideCursor()
def save(self):
if self.filename.startswith("Unnamed"):
filename, filetype = QFileDialog.getSaveFileName(
self, "Text Editor -- Save File As", self.filename,
"Text files (*.txt *.*)")
if not filename:
return
self.filename = filename
self.setWindowTitle(QFileInfo(self.filename).fileName())
exception = None
fh = None
try:
fh = QFile(self.filename)
if not fh.open(QIODevice.WriteOnly):
raise IOError(str(fh.errorString()))
stream = QTextStream(fh)
stream.setCodec("UTF-8")
stream << self.toPlainText()
self.document().setModified(False)
except EnvironmentError as e:
exception = e
finally:
if fh is not None:
fh.close()
if exception is not None:
raise exception
def saveStyleSheet(self, fileName):
styleSheet = self.ui.styleTextEdit.toPlainText()
file = QFile(fileName)
if file.open(QFile.WriteOnly):
QTextStream(file) << styleSheet
else:
QMessageBox.information(self, "Unable to open file", file.errorString())
def load(self):
"""Load ?"""
exception = None
filehandle = None
try:
filehandle = QFile(self.filename)
if not filehandle.open( QIODevice.ReadOnly):
raise IOError(unicode(filehandle.errorString()))
stream = QTextStream(filehandle)
stream.setCodec("UTF-8")
QApplication.processEvents()
self.setPlainText(stream.readAll())
self.document().setModified(False)
self.setWindowTitle( QFileInfo(self.filename).fileName())
self.loadHighlighter(self.filename)
for plugin in filter_plugins_by_capability('afterFileOpen',self.enabled_plugins):
plugin.do_afterFileOpen(self)
except (IOError, OSError) as error:
exception = error
finally:
if filehandle is not None:
filehandle.close()
if exception is not None:
raise exception
def __exportStyles(self, lexers):
"""
Private method to export the styles of the given lexers.
@param lexers list of lexer objects for which to export the styles
"""
fn, selectedFilter = E5FileDialog.getSaveFileNameAndFilter(
self, self.tr("Export Highlighting Styles"), "",
self.tr("Highlighting styles file (*.e4h)"), "",
E5FileDialog.Options(E5FileDialog.DontConfirmOverwrite))
if not fn:
return
ext = QFileInfo(fn).suffix()
if not ext:
ex = selectedFilter.split("(*")[1].split(")")[0]
if ex:
fn += ex
f = QFile(fn)
if f.open(QIODevice.WriteOnly):
from E5XML.HighlightingStylesWriter import HighlightingStylesWriter
HighlightingStylesWriter(f, lexers).writeXML()
f.close()
else:
E5MessageBox.critical(
self, self.tr("Export Highlighting Styles"),
self.tr(
"""<p>The highlighting styles could not be exported"""
""" to file <b>{0}</b>.</p><p>Reason: {1}</p>""").format(
fn, f.errorString()))
def save(self):
exception = None
fh = None
try:
if not self.filename:
raise IOError("no filename specified for saving")
fh = QFile(self.filename)
if not fh.open(QIODevice.WriteOnly):
raise IOError(str(fh.errorString()))
stream = QDataStream(fh)
stream.writeInt32(MAGIC_NUMBER)
stream.writeInt16(FILE_VERSION)
stream.setVersion(QDataStream.Qt_5_7)
for ship in self.ships.values():
stream.writeQString(ship.name)
stream.writeQString(ship.owner)
stream.writeQString(ship.country)
stream.writeQString(ship.description)
stream.writeInt32(ship.teu)
self.dirty = False
except IOError as e:
exception = e
finally:
if fh is not None:
fh.close()
if exception is not None:
raise exception
def save(self):
"""Hum ... just save ..."""
if self.filename.startswith("Unnamed"):
filename = self.parent().parent().parent().saveAsFile()
if not (filename == ''):
return
self.filename = filename
self.setWindowTitle( QFileInfo(self.filename).fileName())
exception = None
filehandle = None
try:
#Before FileSave plugin hook
for plugin in filter_plugins_by_capability('beforeFileSave',self.enabled_plugins):
plugin.do_beforeFileSave(self)
filehandle = QFile(self.filename)
if not filehandle.open( QIODevice.WriteOnly):
raise IOError(unicode(filehandle.errorString()))
stream = QTextStream(filehandle)
stream.setCodec("UTF-8")
stream << self.toPlainText()
self.document().setModified(False)
RecentFiles().append(self.filename)
except (IOError, OSError) as ioError:
exception = ioError
finally:
if filehandle is not None:
filehandle.close()
for plugin in filter_plugins_by_capability('afterFileSave',self.enabled_plugins):
plugin.do_afterFileSave(self)
if exception is not None:
raise exception
def writeObjectTypes(self, fileName, objectTypes):
self.mError = ''
file = QFile(fileName)
if (not file.open(QIODevice.WriteOnly | QIODevice.Text)):
self.mError = QCoreApplication.translate(
"ObjectTypes", "Could not open file for writing.")
return False
writer = QXmlStreamWriter(file)
writer.setAutoFormatting(True)
writer.setAutoFormattingIndent(1)
writer.writeStartDocument()
writer.writeStartElement("objecttypes")
for objectType in objectTypes:
writer.writeStartElement("objecttype")
writer.writeAttribute("name", objectType.name)
writer.writeAttribute("color", objectType.color.name())
writer.writeEndElement()
writer.writeEndElement()
writer.writeEndDocument()
if (file.error() != QFile.NoError):
self.mError = file.errorString()
return False
return True
def save(self):
if "Unnamed" in self.filename:
filename = QFileDialog.getSaveFileName(self,
"G.R.O.M. Editor -- Save File As", self.filename,
"MD files (*.mdp *.itp *.top *.*)")
print('filename is ', filename)
if len(filename[0]) == 0:
return
self.filename = filename[0]
self.setWindowTitle(QFileInfo(self.filename).fileName())
exception = None
fh = None
try:
fh = QFile(self.filename)
if not fh.open(QIODevice.WriteOnly):
raise IOError(str(fh.errorString()))
stream = QTextStream(fh)
stream.setCodec("UTF-8")
stream << self.toPlainText()
self.document().setModified(False)
except EnvironmentError as e:
exception = e
finally:
if fh is not None:
fh.close()
if exception is not None:
raise exception
def saveQDataStream(self):
error = None
fh = None
try:
fh = QFile(self.__fname)
if not fh.open(QIODevice.WriteOnly):
raise IOError(unicode(fh.errorString()))
stream = QDataStream(fh)
stream.writeInt32(MovieContainer.MAGIC_NUMBER)
stream.writeInt32(MovieContainer.FILE_VERSION)
stream.setVersion(QDataStream.Qt_4_2)
for key, movie in self.__movies:
stream << movie.title
stream.writeInt16(movie.year)
stream.writeInt16(movie.minutes)
stream << movie.acquired << movie.notes
except (IOError, OSError) as e:
error = "Failed to save: {0}".format(e)
finally:
if fh is not None:
fh.close()
if error is not None:
return False, error
self.__dirty = False
return True, "Saved {0} movie records to {1}".format(
len(self.__movies),
QFileInfo(self.__fname).fileName())
def _copy_file(self, uid: str = "", source_path: str = "", dest_path: str = ""):
self._current_uid = uid
source_file = QFile(source_path)
dest_file = QFile(dest_path)
if not source_file.open(QFile.ReadOnly):
self.copy_error.emit(uid, FileCopier.CannotOpenSourceFile)
return
dest_file_info = QFileInfo(dest_file)
dest_dir = dest_file_info.absoluteDir()
if not dest_dir.exists():
if not dest_dir.mkpath(dest_dir.absolutePath()):
self.copy_error.emit(uid, FileCopier.CannotCreateDestinationDirectory)
return
if not dest_file.open(QFile.WriteOnly):
ic(dest_path, dest_file.errorString())
self.copy_error.emit(uid, FileCopier.CannotOpenDestinationFile)
return
progress: int = 0
total: int = source_file.size()
error: int = FileCopier.NoError
while True:
if self._cancel_current:
self._cancel_current = False
self.copy_cancelled.emit(uid)
break
data: Union[bytes, int] = source_file.read(_COPY_BLOCK_SIZE)
if isinstance(data, int):
assert data == -1
error = FileCopier.CannotReadSourceFile
break
data_len = len(data)
if data_len == 0:
self.copy_progress.emit(uid, progress, total)
break
if data_len != dest_file.write(data):
error = FileCopier.CannotWriteDestinationFile
break
progress += data_len
self.copy_progress.emit(uid, progress, total)
qApp.processEvents()
source_file.close()
dest_file.close()
if error != FileCopier.NoError:
dest_file.remove()
self.copy_error.emit(uid, error)
else:
dest_file.setPermissions(source_file.permissions())
self.copy_complete.emit(uid)
def save(self, content, path=None):
"""
Write a temporary file with .tnj extension and copy it over the
original one.
.nsf = Ninja Swap File
# FIXME: Where to locate addExtension, does not fit here
"""
new_path = False
if path:
self.attach_to_path(path)
new_path = True
save_path = self._file_path
if not save_path:
raise NinjaNoFileNameException("I am asked to write a "
"file but no one told me where")
swap_save_path = "%s.nsp" % save_path
# If we have a file system watcher, remove the file path
# from its watch list until we are done making changes.
if self.__watcher is not None:
self.__watcher.removePath(save_path)
flags = QIODevice.WriteOnly | QIODevice.Truncate
f = QFile(swap_save_path)
if settings.use_platform_specific_eol():
flags |= QIODevice.Text
if not f.open(flags):
raise NinjaIOException(f.errorString())
stream = QTextStream(f)
encoding = get_file_encoding(content)
if encoding:
stream.setCodec(encoding)
encoded_stream = stream.codec().fromUnicode(content)
f.write(encoded_stream)
f.flush()
f.close()
# SIGNAL: Will save (temp, definitive) to warn folder to do something
self.willSave.emit(swap_save_path, save_path)
self.__mtime = os.path.getmtime(swap_save_path)
shutil.move(swap_save_path, save_path)
self.reset_state()
# If we have a file system watcher, add the saved path back
# to its watch list, otherwise create a watcher and start
# watching
if self.__watcher is not None:
if new_path:
# self.__watcher.removePath(self.__watcher.files()[0])
self.__watcher.addPath(self._file_path)
else:
self.__watcher.addPath(save_path)
else:
self.start_watching()
return self
def openDatabase(self):
filename, _ = QFileDialog.getOpenFileName(self, "Choose a filename",
".", "PGN (*.pgn)")
if not filename:
return
file = QFile(filename)
if not file.open(QFile.ReadOnly | QFile.Text):
QMessageBox.warning(
self, "Chess Fighter Error",
"Can't open the file {}:\n{}.".format(filename,
file.errorString()))
return
self.statusBar().showMessage("Opened: {}".format(filename), 2000)
# Check to see if indexes are already build for DB:
fname, ext = os.path.splitext(filename)
if not os.path.exists(fname + '.scout') or not os.path.exists(
fname + '.bin') or not os.path.exists(fname + '.headers.json'):
# Add the UI components (here we use a QTextEdit to display the stdout from the process)
self.dialog = QTextEdit()
self.dialog.setWindowTitle("Opening Database...")
self.dialog.progress = QTextEdit()
self.dialog.show()
if not os.path.exists(fname + '.scout'):
print("Creating Scout DB")
command = "{0}/external/scoutfish".format(os.getcwd())
args = ["make", "{}".format(filename)]
# Add the process and start it
self.setupProcess(command, args, filename)
if not os.path.exists(fname + '.bin'):
print("Creating .bin DB")
command = "{0}/external/parser".format(os.getcwd())
args = ["book", "{}".format(filename), "full"]
self.setupProcess(command, args, filename)
else:
# Switch to this databse
for l in self.bidirectionalListeners:
event = {"DB_File": filename, "Origin": self.__class__}
# self.parent(event)
l()(event)
event = {"Book_File": filename, "Origin": self.__class__}
# self.parent(event)
l()(event)
if not os.path.exists(fname + '.headers.json'):
print("Creating JSON headers")
command = "{0}/external/pgnextractor".format(os.getcwd())
args = ["headers", "{}".format(filename), "full"]
self.setupProcess(command, args, filename)
def __savePageScreen(self):
"""
Private slot to save the page screen.
@return flag indicating success (boolean)
"""
fileName = E5FileDialog.getSaveFileName(
self,
self.tr("Save Page Screen"),
self.tr("screen.png"),
self.tr("Portable Network Graphics File (*.png)"),
E5FileDialog.Options(E5FileDialog.DontConfirmOverwrite))
if not fileName:
return False
if QFileInfo(fileName).exists():
res = E5MessageBox.yesNo(
self,
self.tr("Save Page Screen"),
self.tr("<p>The file <b>{0}</b> already exists."
" Overwrite it?</p>").format(fileName),
icon=E5MessageBox.Warning)
if not res:
return False
file = QFile(fileName)
if not file.open(QFile.WriteOnly):
E5MessageBox.warning(
self,
self.tr("Save Page Screen"),
self.tr("Cannot write file '{0}:\n{1}.")
.format(fileName, file.errorString()))
return False
res = self.__pagePixmap.save(file)
file.close()
if not res:
E5MessageBox.warning(
self,
self.tr("Save Page Screen"),
self.tr("Cannot write file '{0}:\n{1}.")
.format(fileName, file.errorString()))
return False
return True
def saveStyleSheet(self, fileName):
styleSheet = self.ui.styleTextEdit.toPlainText()
file = QFile(fileName)
if file.open(QFile.WriteOnly):
QTextStream(file) << styleSheet
else:
QMessageBox.information(self, "Unable to open file",
file.errorString())
def __savePageScreen(self):
"""
Private slot to save the page screen.
@return flag indicating success (boolean)
"""
fileName = E5FileDialog.getSaveFileName(
self,
self.tr("Save Page Screen"),
self.tr("screen.png"),
self.tr("Portable Network Graphics File (*.png)"),
E5FileDialog.Options(E5FileDialog.DontConfirmOverwrite))
if not fileName:
return False
if QFileInfo(fileName).exists():
res = E5MessageBox.yesNo(
self,
self.tr("Save Page Screen"),
self.tr("<p>The file <b>{0}</b> already exists."
" Overwrite it?</p>").format(fileName),
icon=E5MessageBox.Warning)
if not res:
return False
file = QFile(fileName)
if not file.open(QFile.WriteOnly):
E5MessageBox.warning(
self,
self.tr("Save Page Screen"),
self.tr("Cannot write file '{0}:\n{1}.")
.format(fileName, file.errorString()))
return False
res = self.__pagePixmap.save(file)
file.close()
if not res:
E5MessageBox.warning(
self,
self.tr("Save Page Screen"),
self.tr("Cannot write file '{0}:\n{1}.")
.format(fileName, file.errorString()))
return False
return True
def __load(self):
"""
Private method to load the saved history entries from disk.
"""
historyFile = QFile(self.getFileName())
if not historyFile.exists():
return
if not historyFile.open(QIODevice.ReadOnly):
E5MessageBox.warning(
None,
self.tr("Loading History"),
self.tr(
"""<p>Unable to open history file <b>{0}</b>.<br/>"""
"""Reason: {1}</p>""")
.format(historyFile.fileName, historyFile.errorString()))
return
history = []
# double check, that the history file is sorted as it is read
needToSort = False
lastInsertedItem = HistoryEntry()
data = QByteArray(historyFile.readAll())
stream = QDataStream(data, QIODevice.ReadOnly)
stream.setVersion(QDataStream.Qt_4_6)
while not stream.atEnd():
ver = stream.readUInt32()
if ver != HISTORY_VERSION:
continue
itm = HistoryEntry()
itm.url = Utilities.readStringFromStream(stream)
stream >> itm.dateTime
itm.title = Utilities.readStringFromStream(stream)
if not itm.dateTime.isValid():
continue
if itm == lastInsertedItem:
if not lastInsertedItem.title and len(history) > 0:
history[0].title = itm.title
continue
if not needToSort and history and lastInsertedItem < itm:
needToSort = True
history.insert(0, itm)
lastInsertedItem = itm
historyFile.close()
if needToSort:
history.sort()
self.setHistory(history, True)
# if the history had to be sorted, rewrite the history sorted
if needToSort:
self.__lastSavedUrl = ""
self.__saveTimer.changeOccurred()
def __load(self):
"""
Private method to load the saved history entries from disk.
"""
historyFile = QFile(self.getFileName())
if not historyFile.exists():
return
if not historyFile.open(QIODevice.ReadOnly):
E5MessageBox.warning(
None,
self.tr("Loading History"),
self.tr("""<p>Unable to open history file <b>{0}</b>.<br/>""" """Reason: {1}</p>""").format(
historyFile.fileName, historyFile.errorString()
),
)
return
history = []
# double check, that the history file is sorted as it is read
needToSort = False
lastInsertedItem = HistoryEntry()
data = QByteArray(historyFile.readAll())
stream = QDataStream(data, QIODevice.ReadOnly)
stream.setVersion(QDataStream.Qt_4_6)
while not stream.atEnd():
ver = stream.readUInt32()
if ver != HISTORY_VERSION:
continue
itm = HistoryEntry()
itm.url = Utilities.readStringFromStream(stream)
stream >> itm.dateTime
itm.title = Utilities.readStringFromStream(stream)
if not itm.dateTime.isValid():
continue
if itm == lastInsertedItem:
if not lastInsertedItem.title and len(history) > 0:
history[0].title = itm.title
continue
if not needToSort and history and lastInsertedItem < itm:
needToSort = True
history.insert(0, itm)
lastInsertedItem = itm
historyFile.close()
if needToSort:
history.sort()
self.setHistory(history, True)
# if the history had to be sorted, rewrite the history sorted
if needToSort:
self.__lastSavedUrl = ""
self.__saveTimer.changeOccurred()
def ouvrirtexte(self):
filename, _ = QFileDialog.getOpenFileName(self)
if filename:
file = QFile(filename)
if not file.open(QFile.ReadOnly | QFile.Text):
QMessageBox.critical(self, appname + version + "Open File",
"Reading Error %s:\n%s." % (filename, file.errorString()))
return
instr = QTextStream(file)
self.ui.plainTextEdit.setPlainText(instr.readAll())
def save(self):
content = self.centralWidget.plainTextEdit.toPlainText()
fileName, _ = QFileDialog.getSaveFileName(self)
if fileName:
fd = QFile(fileName)
if not fd.open(QIODevice.WriteOnly):
QMessageBox.information(self, "Unable to open file", fd.errorString())
return
QTextStream(fd) << content
def read_js(js_path):
js = None
stream = QFile(js_path)
if stream.open(QFile.ReadOnly):
js = QByteArray((stream.readAll()))
stream.close()
else:
print(stream.errorString())
return js
def loadFile(self):
fh = QFile(self.filename)
print("fh is ", fh)
if not fh.open(QIODevice.ReadOnly):
raise IOError(str(fh.errorString()))
stream = QTextStream(fh)
stream.setCodec("UTF-8")
# self.setPlainText("Hello World")
self.preParse = (stream.readAll()) # Here lies the problem how to fix it? PyQt 3.4.2 Works Fine
print(self.preParse)
self.parseOutputData(self.preParse)
def sauvertexte(self):
filename, _ = QFileDialog.getSaveFileName(self)
if filename:
file = QFile(filename)
if not file.open(QFile.WriteOnly | QFile.Text):
QMessageBox.critical(self, appname + version + "Save",
"Writing Error %s:\n%s." % (filename, file.errorString()))
return
outstr = QTextStream(file)
outstr << self.ui.plainTextEdit.toPlainText()
QMessageBox.information(self, appname + version + "Save file",
"The file is saved. \n%s" % (file.fileName()))
def _autosave(self):
if self._neditable.editor.is_modified:
flags = QIODevice.WriteOnly
f = QFile(self.filename())
if not f.open(flags):
raise IOError(f.errorString())
content = self._neditable.editor.text
stream = QTextStream(f)
encoded_stream = stream.codec().fromUnicode(content)
f.write(encoded_stream)
f.flush()
f.close()
def read(self):
""" Reads the file and returns the content """
_file = QFile(self.filename)
if not _file.open(QIODevice.ReadOnly | QIODevice.Text):
raise Exception(_file.errorString())
# Codec
codec = QTextCodec.codecForLocale()
stream = QTextStream(_file)
stream.setCodec(codec)
return stream.readAll()
def open(self):
fileName, _ = QFileDialog.getOpenFileName(self)
if fileName:
fd = QFile(fileName)
if not fd.open(QIODevice.ReadOnly):
QMessageBox.information(self, "Unable to open file", fd.errorString())
return
output = QTextStream(fd).readAll()
# Display contents.
self.centralWidget.plainTextEdit.setPlainText(output)
self.centralWidget.setBaseUrl(QUrl.fromLocalFile(fileName))
def saveFile(self, fileName):
file = QFile(fileName)
if not file.open( QFile.WriteOnly | QFile.Text):
QMessageBox.warning(self, "Recent Files",
"Cannot write file %s:\n%s." % (fileName, file.errorString()))
return
outstr = QTextStream(file)
QApplication.setOverrideCursor(Qt.WaitCursor)
outstr << self.textEdit.toPlainText()
QApplication.restoreOverrideCursor()
self.setCurrentFile(fileName)
self.statusBar().showMessage("File saved", 2000)
def __exportCertificate(self, name, cert):
"""
Private slot to export a certificate.
@param name default file name without extension (string)
@param cert certificate to be exported (QSslCertificate)
"""
if cert is not None:
fname, selectedFilter = E5FileDialog.getSaveFileNameAndFilter(
self,
self.tr("Export Certificate"),
name,
self.tr("Certificate File (PEM) (*.pem);;" "Certificate File (DER) (*.der)"),
None,
E5FileDialog.Options(E5FileDialog.DontConfirmOverwrite),
)
if fname:
ext = QFileInfo(fname).suffix()
if not ext or ext not in ["pem", "der"]:
ex = selectedFilter.split("(*")[1].split(")")[0]
if ex:
fname += ex
if QFileInfo(fname).exists():
res = E5MessageBox.yesNo(
self,
self.tr("Export Certificate"),
self.tr("<p>The file <b>{0}</b> already exists." " Overwrite it?</p>").format(fname),
icon=E5MessageBox.Warning,
)
if not res:
return
f = QFile(fname)
if not f.open(QIODevice.WriteOnly):
E5MessageBox.critical(
self,
self.tr("Export Certificate"),
self.tr(
"""<p>The certificate could not be written""" """ to file <b>{0}</b></p><p>Error: {1}</p>"""
).format(fname, f.errorString()),
)
return
if fname.endswith(".pem"):
crt = cert.toPem()
else:
crt = cert.toDer()
f.write(crt)
f.close()
def open(self):
fileName, _ = QFileDialog.getOpenFileName(self)
if fileName:
inFile = QFile(fileName)
if not inFile.open(QFile.ReadOnly):
QMessageBox.warning(self, "Codecs",
"Cannot read file %s:\n%s" % (fileName, inFile.errorString()))
return
data = inFile.readAll()
self.previewForm.setEncodedData(data)
if self.previewForm.exec_():
self.textEdit.setPlainText(self.previewForm.decodedString())
def loadFile(self, fileName):
file = QFile(fileName)
if not file.open(QFile.ReadOnly | QFile.Text):
QMessageBox.warning(self, "Application",
"Cannot read file %s:\n%s." % (fileName, file.errorString()))
return
inf = QTextStream(file)
QApplication.setOverrideCursor(Qt.WaitCursor)
self.textEdit.setPlainText(inf.readAll())
QApplication.restoreOverrideCursor()
self.setCurrentFile(fileName)
self.statusBar().showMessage("File loaded", 2000)
def read_embedded_file(src_name):
""" Return the contents of an embedded source file as a QByteArray.
src_name is the name of the source file. A UserException is raised if
there was an error.
"""
src_file = QFile(src_name)
if not src_file.open(QIODevice.ReadOnly | QIODevice.Text):
raise UserException("Unable to open file {0}.".format(src_file.fileName()), src_file.errorString())
contents = src_file.readAll()
src_file.close()
return contents
def save(self):
fileName, _ = QFileDialog.getSaveFileName(self)
if fileName:
outFile = QFile(fileName)
if not outFile.open(QFile.WriteOnly|QFile.Text):
QMessageBox.warning(self, "Codecs",
"Cannot write file %s:\n%s" % (fileName, outFile.errorString()))
return
action = self.sender()
codecName = action.data()
out = QTextStream(outFile)
out.setCodec(codecName)
out << self.textEdit.toPlainText()
def saveFile(self, fileName):
file = QFile(fileName)
if not file.open(QFile.WriteOnly | QFile.Text):
QMessageBox.warning(self, "MDI",
"Cannot write file %s:\n%s." % (fileName, file.errorString()))
return False
outstr = QTextStream(file)
QApplication.setOverrideCursor(Qt.WaitCursor)
outstr << self.toPlainText()
QApplication.restoreOverrideCursor()
self.setCurrentFile(fileName)
return True
def __importStyles(self, lexers):
"""
Private method to import the styles of the given lexers.
@param lexers dictionary of lexer objects for which to import the
styles
"""
fn = E5FileDialog.getOpenFileName(
self,
self.tr("Import Highlighting Styles"),
"",
self.tr("Highlighting styles file (*.e4h)"))
if not fn:
return
f = QFile(fn)
if f.open(QIODevice.ReadOnly):
from E5XML.HighlightingStylesReader import HighlightingStylesReader
reader = HighlightingStylesReader(f, lexers)
reader.readXML()
f.close()
else:
E5MessageBox.critical(
self,
self.tr("Import Highlighting Styles"),
self.tr(
"""<p>The highlighting styles could not be read"""
""" from file <b>{0}</b>.</p><p>Reason: {1}</p>""")
.format(fn, f.errorString())
)
return
if self.lexer:
colour = self.lexer.color(self.style)
paper = self.lexer.paper(self.style)
eolfill = self.lexer.eolFill(self.style)
font = self.lexer.font(self.style)
self.sampleText.setFont(font)
pl = self.sampleText.palette()
pl.setColor(QPalette.Text, colour)
pl.setColor(QPalette.Base, paper)
self.sampleText.setPalette(pl)
self.sampleText.repaint()
self.eolfillCheckBox.setChecked(eolfill)
self.__styleAllItems()
def save(self, data, path=None):
if path:
self.filename = path
self.is_new = False
_file = QFile(self.filename)
if not _file.open(QIODevice.WriteOnly | QIODevice.Truncate):
raise Exception(_file.errorString())
stream = QTextStream(_file)
stream.setCodec(QTextCodec.codecForLocale())
stream << data
stream.flush()
_file.close()
# Emit the signal
self.fileSaved.emit(self.filename)
