class MainWindow(QMainWindow):
""" drag and drop graphics viewer """
def __init__(self):
super(MainWindow, self).__init__()
self.ui = Ui_mainWindow()
self.ui.setupUi(self)
self.setAcceptDrops(True)
# set up variables
self.f = QFileInfo()
self.scene = QGraphicsScene()
self.ui.graphicsView.setAcceptDrops(False)
self.ui.graphicsView.setScene(self.scene)
self.ui.graphicsView.setInteractive(True)
self.ui.graphicsView.setDragMode(QGraphicsView.RubberBandDrag)
self.ui.graphicsView.setRubberBandSelectionMode(Qt.ContainsItemShape)
# --------------------------------
# Drag / Drop code
# --------------------------------
def dragEnterEvent(self, event):
acceptedFileTypes = []
acceptedFileTypes.append("jpg")
acceptedFileTypes.append("png")
acceptedFileTypes.append("bmp")
print(acceptedFileTypes)
if (event.mimeData().hasUrls()) and \
(len(event.mimeData().urls()) == 1):
self.f = QFileInfo(event.mimeData().urls()[0].toLocalFile())
print(self.f.suffix().lower())
if self.f.suffix().lower() in acceptedFileTypes:
event.acceptProposedAction()
def dropEvent(self, event):
print('Drop Event happened')
# print(f.absoluteFilePath())
file = QFileInfo(event.mimeData().urls()[0].toLocalFile())
pixmap = QPixmap()
if pixmap.load(self.f.absoluteFilePath()):
item = QGraphicsPixmapItem(pixmap)
self.scene.addItem(item)
else:
QMessageBox.critical(self,
'Error',
'The image file cannot be read!')
print(self.scene.items().count(item))
print(self.scene.items().count(item))
print(self.scene.items().count(item))
print(self.scene)
class MainWindow(QMainWindow):
""" drag and drop image viewer """
def __init__(self):
super(MainWindow, self).__init__()
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
# set up variables
self.pixmap = QPixmap()
self.f = QFileInfo()
self.setAcceptDrops(True)
# ---------------------------------------
# Drag / Drop code
# ---------------------------------------
def dragEnterEvent(self, event):
acceptedFileTypes = []
acceptedFileTypes.append("jpg")
acceptedFileTypes.append("png")
acceptedFileTypes.append("bmp")
print(acceptedFileTypes)
if (event.mimeData().hasUrls())and \
(len(event.mimeData().urls()) == 1):
self.f = QFileInfo(event.mimeData().urls()[0].toLocalFile())
print(self.f.suffix().lower())
if self.f.suffix().lower() in acceptedFileTypes:
event.acceptProposedAction()
def dropEvent(self, event):
print('Drop Event happening')
print(self.f.absoluteFilePath())
if (self.pixmap.load(self.f.absoluteFilePath())):
self.ui.label.setPixmap(
self.pixmap.scaled(self.ui.label.size(), Qt.KeepAspectRatio,
Qt.SmoothTransformation))
else:
QMessageBox.critical(self, "Error",
"The image file cannot be read!")
def resizeEvent(self, event):
if not (self.pixmap.isNull()):
self.ui.label.setPixmap(
self.pixmap.scaled(self.ui.label.width() - 5,
self.ui.label.height() - 5,
Qt.KeepAspectRatio,
Qt.SmoothTransformation))
def generate_pj_info(self):
"""
triggered by button add
1. create new project info dict every time
2. extract project name and address from LineEdit; check if exist and if it is cas and msh file
3. when second step done, get journal path from get_journal function
:return: signal_add_pj(dict)
"""
self.pj_dict = {
"project_name": '',
"project_address": '',
"journal": ''
}
if self.checkbox_journal.isChecked():
case_path = QFileInfo(self.edit_journal_address.text())
else:
case_path = QFileInfo(self.edit_project_address.text()
) # QFileInfo can deeply analyze path info
accepted_file_type = ['cas', 'msh', 'h5', 'jou']
if (case_path.exists()) and (case_path.suffix() in accepted_file_type):
self.pj_dict["project_name"] = case_path.baseName()
self.pj_dict["project_address"] = case_path.absolutePath()
self.pj_dict['journal'] = self.get_journal(case_path,
case_path.fileName())
self.signal_add_pj.emit(self.pj_dict)
self.close()
print('generate new project:', self.pj_dict)
else:
QMessageBox.warning(self, self.make_trans('warning'),
self.make_trans('no_case_mesh'),
QMessageBox.Yes, QMessageBox.Yes)
print('file not exists')
def exportToPDF(self, document):
"""
this will download the formatted document to the file of the users choice
:param document: reference to the document
:param to_print: if the caller intends to print the document
:return: returns the qprinter object that is created
"""
logging.debug("")
# get the file name if exporting
file_name = QFileDialog.getSaveFileName(self.app, 'Save To PDF')
if file_name is not None:
file_name = file_name[0]
# if the file name is not given return none
if file_name == '':
return None
# if there is no pdf extension then add it
file_info = QFileInfo(file_name)
if file_info.suffix() != "pdf":
if file_name.find('.') != -1:
file_name = file_name[:file_name.rindex('.')] + ".pdf"
else:
file_name = file_name + ".pdf"
# create the qprinter object
printer = QPrinter(QPrinter.HighResolution)
printer.setPageSize(QPrinter.A4)
printer.setColorMode(QPrinter.Color)
printer.setOutputFormat(QPrinter.PdfFormat)
printer.setOutputFileName(file_name)
document.print_(printer)
return printer
def replaceImage(self, filepath, title):
self.title = title
self.filepath = filepath
# set custom properties
self.setCustomProperty("title", title)
self.setCustomProperty("filepath", self.filepath)
self.setName(title)
fileInfo = QFileInfo(filepath)
ext = fileInfo.suffix()
if ext == "pdf":
s = QSettings()
oldValidation = s.value("/Projections/defaultBehavior")
s.setValue(
"/Projections/defaultBehavior", "useGlobal"
) # for not asking about crs
path = fileInfo.filePath()
baseName = fileInfo.baseName()
layer = QgsRasterLayer(path, baseName)
self.image = layer.previewAsImage(QSize(layer.width(), layer.height()))
s.setValue("/Projections/defaultBehavior", oldValidation)
else:
reader = QImageReader(filepath)
self.image = reader.read()
self.repaint()
def pBtn_RunClicked(self):
self.pBtn_Run.setEnabled(False)
global pool,parent_pid
parent_pid = os.getpid()
fi=QFileInfo(self.lnEdit_Prog.text())
#runName=fi.baseName()
ns3path=os.path.dirname(fi.dir().path())
ns3path=os.path.dirname(ns3path)
self.exepath=os.path.dirname(ns3path)
routingName=self.cmBox_RoutingName.currentText()
simSpan=self.cmBox_SimulationSpan.currentText()
#global pool
#jobs=[]
Thread.daemon=True
pool = Pool(processes=self.spinBox_processes.value())
cmds={}
for traffic in range(string.atoi(self.lnEdit_loadStart.text()),string.atoi(self.lnEdit_loadEnd.text()),
string.atoi(self.lnEdit_loadStep.text())):
if fi.suffix()=="cpp":
cmds[traffic]="./waf --run='{1} --routingName={3} --simulationSpan={2} --InterestsPerSec={0}'".format(traffic,fi.baseName(),simSpan,routingName)
else:
cmds[traffic]="./waf --pyrun='{1} --routingName={3} --simulationSpan={2} --InterestsPerSec={0}'".format(traffic,'src/ndnSIM/examples/'+fi.fileName(),simSpan,routingName)
res=pool.apply_async(runJob,args=(cmds[traffic],traffic,self.exepath),callback=self.invokeRefresh)
jobs.append(res)
self.listWidget_activeProg.addItem(cmds[traffic])
#res.wait()
#print(res.get())
pool.close() #关闭线程池，不再接收新任务
class FileBasedTextStream(QTextStream):
def __init__(self, qfile):
super().__init__(qfile)
self.saved_file = qfile
self.qfi = None # may never need this
def rewind(self):
self.flush()
self.seek(0)
def writeLine(self, str):
self << str
self << '\n'
def open_mode(self):
return self.saved_file.openMode()
def fullpath(self):
if self.qfi is None:
self.qfi = QFileInfo(self.saved_file)
return self.qfi.canonicalFilePath()
def folderpath(self):
if self.qfi is None:
self.qfi = QFileInfo(self.saved_file)
return self.qfi.canonicalPath()
def filename(self):
if self.qfi is None:
self.qfi = QFileInfo(self.saved_file)
return self.qfi.fileName()
def basename(self):
if self.qfi is None:
self.qfi = QFileInfo(self.saved_file)
return self.qfi.completeBaseName()
def suffix(self):
if self.qfi is None:
self.qfi = QFileInfo(self.saved_file)
return self.qfi.suffix()
def __saveFileName(self, directory):
"""
Private method to calculate a name for the file to download.
@param directory name of the directory to store the file into (string)
@return proposed filename and original filename (string, string)
"""
path = parseContentDisposition(self.__reply)
info = QFileInfo(path)
baseName = info.completeBaseName()
endName = info.suffix()
origName = baseName
if endName:
origName += '.' + endName
name = directory + baseName
if endName:
name += '.' + endName
if not self.__requestFilename:
# do not overwrite, if the user is not being asked
i = 1
while QFile.exists(name):
# file exists already, don't overwrite
name = directory + baseName + ('-{0:d}'.format(i))
if endName:
name += '.' + endName
i += 1
return name, origName
def pBtn_RunClicked(self):
fi = QFileInfo(self.lnEdit_Prog.text())
#runName=fi.baseName()
ns3path = os.path.dirname(fi.dir().path())
ns3path = os.path.dirname(ns3path)
self.exepath = os.path.dirname(ns3path)
routingName = self.cmBox_RoutingName.currentText()
simSpan = self.cmBox_SimulationSpan.currentText()
pool = Pool(processes=self.spinBox_processes.value())
cmds = {}
for traffic in range(string.atoi(self.lnEdit_loadStart.text()),
string.atoi(self.lnEdit_loadEnd.text()),
string.atoi(self.lnEdit_loadStep.text())):
if fi.suffix() == "cpp":
cmds[
traffic] = "./waf --run='{1} --routingName={3} --simulationSpan={2} --InterestsPerSec={0}'".format(
traffic, fi.baseName(), simSpan, routingName)
else:
cmds[
traffic] = "./waf --pyrun='{1} --routingName={3} --simulationSpan={2} --InterestsPerSec={0}'".format(
traffic, 'src/ndnSIM/examples/' + fi.fileName(),
simSpan, routingName)
res = pool.apply_async(runJob,
args=(cmds[traffic], self.exepath),
callback=self.invokeRefresh)
self.listWidget_activeProg.addItem(cmds[traffic])
#res.wait()
#print(res.get())
pool.close() #关闭线程池，不再接收新任务
#proc=Process(target=ajob.runJob, args=("./waf --run='ndn-zhangyu-multipath --simulationSpan=50 --InterestsPerSec=50'", os.environ['HOME']+"/ndnSIM20170130/ns-3/"))
#proc.start()
#proc.join()
self.refreshGUI("")
def loadMap(self, fullpath):
print(fullpath)
info = QFileInfo(fullpath)
basename = info.baseName()
suffix = info.suffix()
print(basename)
print(suffix)
if suffix == 'shp':
print('vector')
# 打开矢量图层
self.layer = QgsVectorLayer(fullpath, basename, "ogr")
if not self.layer:
print("failed")
else:
print('raster')
#打开栅格图层
self.layer = QgsRasterLayer(fullpath, basename, "gdal")
if not self.layer:
print("failed")
# 注册图层
QgsProject.instance().addMapLayer(self.layer)
self.mapCanvas.setLayers([self.layer])
#设置图层范围
self.mapCanvas.setExtent(self.layer.extent())
self.mapCanvas.refresh()
def startSearch(self, query):
print("search started..", query)
filters = QDir.Files
nameFilters = ["*.cpp"]
iterator = QDirIterator("/home/alexanderb", nameFilters, filters,
QDirIterator.Subdirectories)
while (iterator.hasNext()):
filePath = iterator.next()
fileInfo = QFileInfo(filePath)
currentFile = QFile(filePath)
currentFile.open(QFile.ReadOnly | QFile.Text)
fileContents = currentFile.readAll().data().decode('utf8',
errors='ignore')
if (fileContents.find(query) != -1):
qtwItem = QTreeWidgetItem()
qtwItem.setText(0, fileInfo.fileName())
qtwItem.setText(1, fileInfo.suffix())
qtwItem.setText(2, str(fileInfo.size() / 1024))
qtwItem.setText(3,
fileInfo.lastModified().toString("MM/dd/yyyy"))
qtwItem.setText(4, fileInfo.created().toString("MM/dd/yyyy"))
qtwItem.setText(5, str("...here is the content..."))
qtwItem.setText(6, filePath)
self.qtwItems.append(qtwItem)
self.match_found.emit(qtwItem)
self.finished.emit()
def msg(self):
directory1 = QFileDialog.getExistingDirectory(self, "选择文件夹", "/")
print(directory1) # 打印文件夹路径
fileName, filetype = QFileDialog.getOpenFileName(
self, "选择文件", "/", "All Files (*);;Text Files (*.txt)")
print(fileName, filetype) # 打印文件全部路径（包括文件名和后缀名）和文件类型
print(fileName) # 打印文件全部路径（包括文件名和后缀名）
fileinfo = QFileInfo(fileName)
print(fileinfo) # 打印与系统相关的文件信息，包括文件的名字和在文件系统中位置，文件的访问权限，是否是目录或符合链接，等等。
file_name = fileinfo.fileName()
print(file_name) # 打印文件名和后缀名
file_suffix = fileinfo.suffix()
print(file_suffix) # 打印文件后缀名
file_path = fileinfo.absolutePath()
print(file_path) # 打印文件绝对路径（不包括文件名和后缀名）
files, ok1 = QFileDialog.getOpenFileNames(self, "多文件选择", "/",
"所有文件 (*);;文本文件 (*.txt)")
print(files, ok1) # 打印所选文件全部路径（包括文件名和后缀名）和文件类型
fileName2, ok2 = QFileDialog.getSaveFileName(self, "文件保存", "/",
"图片文件 (*.png);;(*.jpeg)")
print(fileName2) # 打印保存文件的全部路径（包括文件名和后缀名）
def set_mode_by_filename(self, filename):
file = QFile(filename)
fileinfo = QFileInfo(file)
suffix = fileinfo.suffix()
self.page().mainFrame().evaluateJavaScript("editor.getSession().setMode('%s');" % (
self.SUFIX_2_MODE[suffix] if suffix in self.SUFIX_2_MODE else self.SUFIX_2_MODE[None]
))
def GetFile(self, typeOfFile, suff):
options = QFileDialog.Options()
fileName, _ = QFileDialog.getOpenFileName(
self,
"Open {} File".format(typeOfFile),
"",
"{}".format(suff),
options=options)
if fileName:
if typeOfFile == "any":
myCipher.fileToBeSigned = fileName
f = QFileInfo(fileName)
n = f.fileName()
file_info = "Informations about the file:\n \n"
file_info += "Name: " + n + "\n"
p = f.filePath()
file_info += "Path: " + p + "\n"
suf = f.suffix()
file_info += "Suffix: " + suf + "\n"
size = f.size()
file_info += "Size (in bytes): " + str(size) + "\n"
lastModify = f.lastModified().toPyDateTime()
file_info += "Date of last change: " + str(lastModify)
self.fileInfo.setText(file_info)
elif typeOfFile == "Signed":
myCipher.userFile = fileName
elif typeOfFile == "Private key":
myCipher.privPath = fileName
with open(fileName, "r") as f:
f.seek(4)
base64Text = f.readline()
decodedBase64D = self.decodeFromBase64(base64Text)
myCipher.d = int(decodedBase64D, 10)
base64Text2 = f.readline()
decodedBase64N = self.decodeFromBase64(base64Text2)
myCipher.n = int(decodedBase64N, 10)
elif typeOfFile == "Public key":
myCipher.pubPath = fileName
with open(fileName, "r") as f:
f.seek(4)
base64Text = f.readline()
decodedBase64E = self.decodeFromBase64(base64Text)
myCipher.e = int(decodedBase64E, 10)
base64Text2 = f.readline()
decodedBase64N = self.decodeFromBase64(base64Text2)
myCipher.n = int(decodedBase64N, 10)
elif typeOfFile == "Zip":
myCipher.zipPath = fileName
with zipfile.ZipFile(fileName, "r") as z:
z.extractall("Extracted_files")
elif typeOfFile == "Sign":
myCipher.fileToBeVerified = fileName
with open(fileName, "r") as f:
f.seek(13)
base64Text = f.readline()
decodedBase64 = self.decodeFromBase64(base64Text)
myCipher.toVerifyMessage = list(decodedBase64)
def vector_load_file(self):
""" Open dialog to load vector layer."""
self.vector_filename, __ = QFileDialog.getOpenFileName(self, 'Vector Layer from File', QDir.homePath(),
"Vector Layer(*.shp *.kml *.osm *.gpx) ;; All files (*.*)")
if self.vector_filename:
file_info = QFileInfo(self.vector_filename)
self.vector_base_name = file_info.baseName()
self.vector_file_extension = file_info.suffix()
self.vector_file_lineEdit.setText(str(self.vector_filename))
self.vector_name_lineEdit.setText(str(self.vector_base_name))
def ClickedEvent(self, event):
validSuffix = ['jpg', 'png']
index = self.selectedIndexes()[0]
finfo = QFileInfo(self._model.filePath(index))
if finfo.suffix().lower() not in validSuffix:
return
if finfo.isFile() and finfo.isReadable():
self.fileSelected.emit(finfo.absoluteFilePath())
def add_song(self, song_path):
if song_path.split(".")[-1] not in ["mp3", "flac", "ogg"]:
raise AssertionError
song = self.path_to_song(song_path)
filepath = song.path
fileInfo = QFileInfo(filepath)
if fileInfo.exists():
url = QUrl.fromLocalFile(fileInfo.absoluteFilePath())
if fileInfo.suffix().lower() == "mp3" or "flac" or "ogg":
self.playlist.addMedia(QMediaContent(url))
self.songs.append(song)
def dragEnterEvent(self, e):
"""Qt event override for drag enter event"""
if len(e.mimeData().urls()) > 0 and e.mimeData().urls()[0].isLocalFile():
qi = QFileInfo(e.mimeData().urls()[0].toLocalFile())
ext = qi.suffix()
if ext == "jpg" or ext == "jpeg" or ext == "png" or ext == "JPG" or ext == "PNG":
e.accept()
else:
e.ignore()
else:
e.ignore()
def checkFiles(self, lst):
f = QFileInfo()
newLst = []
for url in lst:
_file = url.toLocalFile()
print("FILE::", url, _file)
f.setFile(_file)
if f.suffix() not in ("tar", "exe", "mp3", "mp4", "flv", "zip", "rar", "iso"):
newLst.append(_file)
if newLst:
self.openFiles.emit(newLst)
class FileBasedTextStream(QTextStream):
def __init__(self, qfile):
super().__init__(qfile)
self.saved_file = qfile
self.qfi = None # may never need this
def rewind(self):
self.flush()
self.seek(0)
def writeLine(self, str):
self << str
self << '\n'
def open_mode(self):
return self.saved_file.openMode()
def fullpath(self):
if self.qfi is None:
self.qfi = QFileInfo(self.saved_file)
return self.qfi.canonicalFilePath()
def folderpath(self):
if self.qfi is None:
self.qfi = QFileInfo(self.saved_file)
return self.qfi.canonicalPath()
def filename(self):
if self.qfi is None:
self.qfi = QFileInfo(self.saved_file)
return self.qfi.fileName()
def basename(self):
if self.qfi is None:
self.qfi = QFileInfo(self.saved_file)
return self.qfi.completeBaseName()
def suffix(self):
if self.qfi is None:
self.qfi = QFileInfo(self.saved_file)
return self.qfi.suffix()
def flush(self):
super().flush() # make sure text buffer goes to device
return self.device().flush() # do a real flush
def show_error(self, action, parent):
error_number = self.device().error()
if error_number: # is not 0, no error
error_string = self.device().errorString()
msg_string = 'Error {} ({}) on {}'.format(error_number,
error_string, action)
warning_msg(msg_string, self.fullpath(), parent)
def dragEnterEvent(self, e):
"""Drag files directly onto the widget"""
if len(e.mimeData().urls()) > 0 and e.mimeData().urls()[0].isLocalFile(
):
qi = QFileInfo(e.mimeData().urls()[0].toLocalFile())
ext = qi.suffix()
if ext == 'jpg' or ext == 'jpeg' or ext == 'png' or ext == 'JPG' or ext == 'PNG':
e.accept()
else:
e.ignore()
else:
e.ignore()
def show(self):
"""
Public slot to show this dialog.
This overloaded slot loads a UI file to be previewed after
the main window has been shown. This way, previewing a dialog
doesn't interfere with showing the main window.
"""
super(TRPreviewer, self).show()
if self.filesToLoad:
filenames, self.filesToLoad = (self.filesToLoad[:], [])
first = True
for fn in filenames:
fi = QFileInfo(fn)
if fi.suffix().lower() == 'ui':
self.preview.loadWidget(fn)
elif fi.suffix().lower() == 'qm':
self.translations.add(fn, first)
first = False
self.__updateActions()
def show(self):
"""
Public slot to show this dialog.
This overloaded slot loads a UI file to be previewed after
the main window has been shown. This way, previewing a dialog
doesn't interfere with showing the main window.
"""
super(TRPreviewer, self).show()
if self.filesToLoad:
filenames, self.filesToLoad = (self.filesToLoad[:], [])
first = True
for fn in filenames:
fi = QFileInfo(fn)
if fi.suffix().lower() == 'ui':
self.preview.loadWidget(fn)
elif fi.suffix().lower() == 'qm':
self.translations.add(fn, first)
first = False
self.__updateActions()
def saveAsDocument(self, document):
"""
prompts the user for a new filename or path and saves the document as that
:param document: Reference to the document
:return: Returns if the save as succeeded or not
"""
new_path = \
QFileDialog.getSaveFileName(self.app, 'Save File', self.app.left_menu.model.rootPath())[
0]
# if the new path is an empty string do nothing
if new_path == '':
logging.warning("No New File Path Given")
return False
# check if the document is formatted
if self.app.btn_mode_switch.isChecked():
f_info = QFileInfo(new_path)
if f_info.suffix() != "lef":
new_path = os.path.join(f_info.path(), f_info.baseName()) + '.lef'
data = document.toHtml()
else:
f_info = QFileInfo(new_path)
if f_info.suffix() == "lef":
new_path = os.path.join(f_info.path(), f_info.baseName()) + '.txt'
data = document.toPlainText()
# now write to the new_path
self.writeFileData(new_path, data)
# add the document to the dict of documents
self.open_documents[new_path] = QFileInfo(new_path)
self.current_document = self.open_documents[new_path]
self.file_opened_time = os.path.getatime(self.current_document.absoluteFilePath())
# open the document with its new text
self.openDocument(document, new_path)
logging.info("Saved File As - %s", new_path)
return True
def start_search(self, query, search_directory):
self.keep_searching = True
print("search started..", query)
filters = QDir.Files
nameFilters = [
"*.cpp", "*.txt", "*.pdf", "*.doc", "*.docx", "*.xlsx", "*.xls",
"*.ppt", "*.pptx"
]
iterator = QDirIterator(search_directory, nameFilters, filters,
QDirIterator.Subdirectories)
while (iterator.hasNext()):
QApplication.processEvents()
if (self.keep_searching):
file_path = iterator.next()
if (os.access(file_path, os.R_OK)):
try:
file_info = QFileInfo(file_path)
file_contents = parser.from_file(file_path)
except:
continue
if (file_contents['status'] == 200
and 'content' in file_contents.keys()
and file_contents['content'] is not None):
found_index = file_contents['content'].find(query)
if (found_index != -1):
snippet = file_contents['content'].strip().replace(
'\n', ' ').replace('\r', '')
snippet_index = snippet.find(query)
qtw_item = QTreeWidgetItem()
qtw_item.setText(0, file_info.fileName())
qtw_item.setText(1, file_info.suffix())
qtw_item.setText(2, str(file_info.size() / 1024))
qtw_item.setText(
3,
file_info.lastModified().toString(
"MM/dd/yyyy"))
qtw_item.setText(
4,
file_info.created().toString("MM/dd/yyyy"))
qtw_item.setText(
5,
str(snippet)[snippet_index - 5:snippet_index +
10])
qtw_item.setText(6, file_path)
self.qtw_items.append(qtw_item)
self.match_found.emit(qtw_item)
self.finished.emit()
def openOnStart(self, name):
fileInfo = QFileInfo(name)
if fileInfo.exists():
url = QUrl.fromLocalFile(fileInfo.absoluteFilePath())
if fileInfo.suffix().lower() == 'm3u':
self.playlist.load(url)
else:
self.playlist.addMedia(QMediaContent(url))
else:
url = QUrl(name)
if url.isValid():
self.playlist.addMedia(QMediaContent(url))
print("added Files to playlist")
def addToPlaylist(self, fileNames):
for name in fileNames:
fileInfo = QFileInfo(name)
if fileInfo.exists():
url = QUrl.fromLocalFile(fileInfo.absoluteFilePath())
if fileInfo.suffix().lower() == 'm3u':
self.playlist.load(url)
else:
self.playlist.addMedia(QMediaContent(url))
else:
url = QUrl(name)
if url.isValid():
self.playlist.addMedia(QMediaContent(url))
def _load_audio(self):
filename = os.path.join(self.audio_path, "{:03}.mp3".format(self._song_number))
self.playlist.clear()
fileInfo = QFileInfo(filename)
if fileInfo.exists():
url = QUrl.fromLocalFile(fileInfo.absoluteFilePath())
if fileInfo.suffix().lower() == 'm3u':
self.playlist.load(url)
else:
self.playlist.addMedia(QMediaContent(url))
self._loading_audio = True
self.player.play()
def checkFiles(self, lst):
f = QFileInfo()
newLst = []
for url in lst:
_file = url.toLocalFile()
print("FILE::", url, _file)
f.setFile(_file)
if f.suffix() not in ("tar", "exe", "mp3", "mp4", "flv", "zip",
"rar", "iso"):
newLst.append(_file)
if newLst:
self.openFiles.emit(newLst)
def addToPlaylist(self, fileNames):
for name in fileNames:
fileInfo = QFileInfo(name)
if fileInfo.exists():
url = QUrl.fromLocalFile(fileInfo.absoluteFilePath())
if fileInfo.suffix().lower() == 'm3u':
self.playlist.load(url)
else:
self.playlist.addMedia(QMediaContent(url))
else:
url = QUrl(name)
if url.isValid():
self.playlist.addMedia(QMediaContent(url))
def on_btnFile_copy_clicked(self):
self.__showBtnInfo(self.sender())
sous=self.ui.editFile.text().strip() #源文件
if sous=="":
self.ui.textEdit.appendPlainText("请先选择一个文件")
return
fileInfo=QFileInfo(sous)
newFile=fileInfo.path()+"/"+fileInfo.baseName()+"--副本."+fileInfo.suffix()
if QFile.copy(sous,newFile):
self.ui.textEdit.appendPlainText("源文件："+sous)
self.ui.textEdit.appendPlainText("复制为文件："+newFile+"\n")
else:
self.ui.textEdit.appendPlainText("复制文件失败")
def selectOutputFile(self):
settings = QSettings()
outputFilePath = QFileDialog.getSaveFileName(
None,
QCoreApplication.translate("ProfileExportDialog",
"Select profile output file"),
settings.value("/profileexport/outputdir", ""),
"XML files (*.xml *.XML)")[0]
if outputFilePath:
outputFileInfo = QFileInfo(outputFilePath)
if not outputFileInfo.suffix():
outputFilePath.append(".xml")
self.mOutputFileLineEdit.setText(outputFilePath)
settings.setValue("/profileexport/outputdir",
outputFileInfo.absolutePath())
def loadImages(self, fileNames):
for fileName in fileNames:
row = self.imagesTable.rowCount()
self.imagesTable.setRowCount(row + 1)
fileInfo = QFileInfo(fileName)
imageName = fileInfo.baseName()
fileImage2x = fileInfo.absolutePath(
) + '/' + imageName + "@2x." + fileInfo.suffix()
fileInfo2x = QFileInfo(fileImage2x)
image = QImage(fileName)
toolTip = "Directory: {}\nFile: {}\nFile@2x: {}\nSize: {}x{}".format(
QDir.toNativeSeparators(fileInfo.absolutePath()),
fileInfo.fileName(),
fileInfo2x.fileName() if fileInfo2x.exists else "<None>",
image.width(), image.height())
fileItem = QTableWidgetItem(imageName)
fileItem.setData(Qt.UserRole, fileName)
fileItem.setIcon(QIcon(QPixmap.fromImage(image)))
fileItem.setFlags((fileItem.flags() | Qt.ItemIsUserCheckable)
& ~Qt.ItemIsEditable)
fileItem.setToolTip(toolTip)
self.imagesTable.setItem(row, 0, fileItem)
mode = QIcon.Normal
state = QIcon.Off
if self.guessModeStateAct.isChecked():
if "_act" in imageName:
mode = QIcon.Active
elif "_dis" in imageName:
mode = QIcon.Disabled
elif "_sel" in imageName:
mode = QIcon.Selected
if "_on" in imageName:
mode = QIcon.On
modeItem = QTableWidgetItem(IconPreviewArea.iconModeNames()[
IconPreviewArea.iconModes().index(mode)])
modeItem.setToolTip(toolTip)
self.imagesTable.setItem(row, 1, modeItem)
stateItem = QTableWidgetItem(IconPreviewArea.iconStateNames()[
IconPreviewArea.iconStates().index(state)])
stateItem.setToolTip(toolTip)
self.imagesTable.setItem(row, 2, stateItem)
self.imagesTable.openPersistentEditor(modeItem)
self.imagesTable.openPersistentEditor(stateItem)
fileItem.setCheckState(Qt.Checked)
def on_load():
file = QFile(filename)
fileinfo = QFileInfo(file)
file.open(QFile.ReadOnly)
data = file.readAll()
codec = QTextCodec.codecForUtfText(data)
unistr = codec.toUnicode(data)
self.page().mainFrame().findFirstElement("#editor").setInnerXml(unistr)
self.page().mainFrame().evaluateJavaScript("init()")
suffix = fileinfo.suffix()
self.page().mainFrame().evaluateJavaScript("editor.getSession().setMode('%s');" % (
self.SUFIX_2_MODE[suffix] if suffix in self.SUFIX_2_MODE else self.SUFIX_2_MODE[None]
))
def get_journal(self, case_path, file_type):
"""
if checbox checked, it will use own journal which fill in the LineEdit_journal
if not checked, it will use default_journal func to get default journal
:param case_path:
:return: journal file path
"""
if self.checkbox_journal.isChecked():
jou_path = QFileInfo(self.edit_journal_address.text())
if (jou_path.exists()) and (jou_path.suffix() == "jou"):
return jou_path.filePath()
else:
QMessageBox.warning(self, self.make_trans('warning'),
self.make_trans('no_journal'),
QMessageBox.Yes, QMessageBox.Yes)
else:
jou_file = self.default_journal(case_path, file_type)
return jou_file
def insertFromMimeData(self, mime):
if mime.hasImage():
tag = datetime.datetime.now().time().strftime("%H%M%S")
url = QUrl("dropped_image_" + str(tag))
self.dropImage(url, mime.imageData())
mime.imageData().save("/tmp/" + url.toString(), "png")
elif mime.hasUrls():
for url in mime.urls():
info = QFileInfo(url.toLocalFile())
ext = info.suffix().lower().encode('latin-1')
if ext in QImageReader.supportedImageFormats():
print(str(info.filePath()))
self.dropImage(url, info.filePath())
else:
self.dropTextFile(url)
else:
super().insertFromMimeData(mime)
def __saveFileName(self, directory):
"""
Private method to calculate a name for the file to download.
@param directory name of the directory to store the file into (string)
@return proposed filename and original filename (string, string)
"""
path = ""
if self.__reply.hasRawHeader("Content-Disposition"):
header = bytes(self.__reply.rawHeader("Content-Disposition"))\
.decode()
if header:
pos = header.find("filename=")
if pos != -1:
path = header[pos + 9:]
if path.startswith('"') and path.endswith('"'):
path = path[1:-1]
if not path:
path = self.__url.path()
info = QFileInfo(path)
baseName = info.completeBaseName()
endName = info.suffix()
if not baseName:
baseName = "unnamed_download"
origName = baseName
if endName:
origName += '.' + endName
name = directory + baseName
if endName:
name += '.' + endName
if not self.__requestFilename:
# do not overwrite, if the user is not being asked
i = 1
while QFile.exists(name):
# file exists already, don't overwrite
name = directory + baseName + ('-{0:d}'.format(i))
if endName:
name += '.' + endName
i += 1
return name, origName
def __saveFileName(self, directory):
"""
Private method to calculate a name for the file to download.
@param directory name of the directory to store the file into (string)
@return proposed filename and original filename (string, string)
"""
path = ""
if self.__reply.hasRawHeader("Content-Disposition"):
header = bytes(self.__reply.rawHeader("Content-Disposition"))\
.decode()
if header:
pos = header.find("filename=")
if pos != -1:
path = header[pos + 9:]
if path.startswith('"') and path.endswith('"'):
path = path[1:-1]
if not path:
path = self.__url.path()
info = QFileInfo(path)
baseName = info.completeBaseName()
endName = info.suffix()
if not baseName:
baseName = "unnamed_download"
origName = baseName
if endName:
origName += '.' + endName
name = directory + baseName
if endName:
name += '.' + endName
if not self.__requestFilename:
# do not overwrite, if the user is not being asked
i = 1
while QFile.exists(name):
# file exists already, don't overwrite
name = directory + baseName + ('-{0:d}'.format(i))
if endName:
name += '.' + endName
i += 1
return name, origName
class FileBasedTextStream(QTextStream):
def __init__(self, qfile):
super().__init__(qfile)
self.saved_file = qfile
self.qfi = None # may never need this
def rewind(self):
self.flush()
self.seek(0)
def writeLine(self, str):
self << str
self << '\n'
def open_mode(self):
return self.saved_file.openMode()
def fullpath(self):
if self.qfi is None:
self.qfi = QFileInfo(self.saved_file)
return self.qfi.canonicalFilePath()
def folderpath(self):
if self.qfi is None:
self.qfi = QFileInfo(self.saved_file)
return self.qfi.canonicalPath()
def filename(self):
if self.qfi is None:
self.qfi = QFileInfo(self.saved_file)
return self.qfi.fileName()
def basename(self):
if self.qfi is None:
self.qfi = QFileInfo(self.saved_file)
return self.qfi.completeBaseName()
def suffix(self):
if self.qfi is None:
self.qfi = QFileInfo(self.saved_file)
return self.qfi.suffix()
def flush(self):
super().flush() # make sure text buffer goes to device
return self.device().flush() # do a real flush
def show_error( self, action, parent ):
error_number = self.device().error()
if error_number : # is not 0, no error
error_string = self.device().errorString()
msg_string = 'Error {} ({}) on {}'.format(
error_number, error_string, action )
warning_msg( msg_string, self.fullpath(), parent )
def getOneSongInfo(self, songPath: str):
""" 获取一首歌的信息 """
tag = TinyTag.get(songPath)
fileInfo = QFileInfo(songPath)
# 获取标签信息
suffix = "." + fileInfo.suffix()
songName = tag.title if tag.title and tag.title.strip(
) else fileInfo.baseName()
songer = tag.artist if tag.artist and tag.artist.strip() else "未知艺术家"
album = tag.album if tag.album and tag.album.strip() else "未知专辑"
tracknumber = str(tag.track) if tag.track else "0"
tcon = tag.genre if tag.genre else "未知流派"
duration = f"{int(tag.duration//60)}:{int(tag.duration%60):02}"
album_list = adjustAlbumName(album)
# 调整曲目序号
tracknumber = self.__adjustTrackNumber(tracknumber)
# 获取年份
if tag.year and tag.year[0] != "0":
year = tag.year[:4] + "年"
else:
tag = File(songPath)
key_dict = {".m4a": "©day", ".mp3": "TDRC", ".flac": "year"}
year = (str(tag.get(key_dict[suffix])[0])[:4] +
"年" if tag.get(key_dict[suffix]) else "未知年份")
# 获取时间戳
createTime = fileInfo.birthTime().toString(Qt.ISODate)
modifiedTime = fileInfo.lastModified().toString(Qt.ISODate)
songInfo = {
"songPath": songPath,
"songer": songer,
"songName": songName,
"album": album_list[0], # album为原专辑名
"modifiedAlbum": album_list[-1], # modifiedAlbum为修改后的专辑名
"tcon": tcon,
"year": year,
"tracknumber": tracknumber,
"duration": duration,
"suffix": suffix,
"createTime": createTime,
"modifiedTime": modifiedTime,
}
return songInfo
def __saveFileName(self, directory):
"""
Private method to calculate a name for the file to download.
@param directory name of the directory to store the file into (string)
@return proposed filename and original filename (string, string)
"""
path = self.__downloadItem.path()
info = QFileInfo(path)
baseName = info.completeBaseName()
endName = info.suffix()
origName = baseName
if endName:
origName += '.' + endName
name = os.path.join(directory, baseName)
if endName:
name += '.' + endName
return name, origName
def replaceImage(self, filepath, title):
self.title = title
self.filepath = filepath
# set custom properties
self.setCustomProperty("title", title)
self.setCustomProperty("filepath", self.filepath)
self.setName(title)
fileInfo = QFileInfo(filepath)
ext = fileInfo.suffix()
if ext == "pdf":
s = QSettings()
oldValidation = s.value("/Projections/defaultBehavior")
s.setValue("/Projections/defaultBehavior", "useGlobal") # for not asking about crs
path = fileInfo.filePath()
baseName = fileInfo.baseName()
layer = QgsRasterLayer(path, baseName)
self.image = layer.previewAsImage(QSize(layer.width(), layer.height()))
s.setValue("/Projections/defaultBehavior", oldValidation)
else:
reader = QImageReader(filepath)
self.image = reader.read()
self.repaint()
def main():
# Initialise.
defaultContext = "@default"
fetchedTor = MetaTranslator()
codecForTr = ''
codecForSource = ''
tsFileNames = []
uiFileNames = []
verbose = False
noObsolete = False
metSomething = False
numFiles = 0
standardSyntax = True
metTsFlag = False
tr_func = None
translate_func = None
# Parse the command line.
for arg in sys.argv[1:]:
if arg == "-ts":
standardSyntax = False
argc = len(sys.argv)
i = 1
while i < argc:
arg = sys.argv[i]
i += 1
if arg == "-help":
printUsage()
sys.exit(0)
if arg == "-version":
sys.stderr.write("pylupdate5 v%s\n" % PYQT_VERSION_STR)
sys.exit(0)
if arg == "-noobsolete":
noObsolete = True
continue
if arg == "-verbose":
verbose = True
continue
if arg == "-ts":
metTsFlag = True
continue
if arg == "-tr-function":
if i >= argc:
sys.stderr.write(
"pylupdate5 error: missing -tr-function name\n")
sys.exit(2)
tr_func = sys.argv[i]
i += 1
continue
if arg == "-translate-function":
if i >= argc:
sys.stderr.write(
"pylupdate5 error: missing -translate-function name\n")
sys.exit(2)
translate_func = sys.argv[i]
i += 1
continue
numFiles += 1
fullText = ""
if not metTsFlag:
f = QFile(arg)
if not f.open(QIODevice.ReadOnly):
sys.stderr.write(
"pylupdate5 error: Cannot open file '%s'\n" % arg)
sys.exit(1)
t = QTextStream(f)
fullText = t.readAll()
f.close()
if standardSyntax:
oldDir = QDir.currentPath()
QDir.setCurrent(QFileInfo(arg).path())
fetchedTor = MetaTranslator()
codecForTr = ''
codecForSource = ''
tsFileNames = []
uiFileNames = []
for key, value in proFileTagMap(fullText).items():
for t in value.split(' '):
if key == "SOURCES":
fetchtr_py(QDir.current().absoluteFilePath(t),
fetchedTor, defaultContext, True,
codecForSource, tr_func, translate_func)
metSomething = True
elif key == "TRANSLATIONS":
tsFileNames.append(QDir.current().absoluteFilePath(t))
metSomething = True
elif key in ("CODEC", "DEFAULTCODEC", "CODECFORTR"):
codecForTr = t
fetchedTor.setCodec(codecForTr)
elif key == "CODECFORSRC":
codecForSource = t
elif key == "FORMS":
fetchtr_ui(QDir.current().absoluteFilePath(t),
fetchedTor, defaultContext, True)
updateTsFiles(fetchedTor, tsFileNames, codecForTr, noObsolete,
verbose)
if not metSomething:
sys.stderr.write(
"pylupdate5 warning: File '%s' does not look like a "
"project file\n" % arg)
elif len(tsFileNames) == 0:
sys.stderr.write(
"pylupdate5 warning: Met no 'TRANSLATIONS' entry in "
"project file '%s'\n" % arg)
QDir.setCurrent(oldDir)
else:
if metTsFlag:
if arg.lower().endswith(".ts"):
fi = QFileInfo(arg)
if not fi.exists() or fi.isWritable():
tsFileNames.append(arg)
else:
sys.stderr.write(
"pylupdate5 warning: For some reason, I "
"cannot save '%s'\n" % arg)
else:
sys.stderr.write(
"pylupdate5 error: File '%s' lacks .ts extension\n" % arg)
else:
fi = QFileInfo(arg)
if fi.suffix() in ("py", "pyw"):
fetchtr_py(fi.absoluteFilePath(), fetchedTor,
defaultContext, True, codecForSource, tr_func,
translate_func)
else:
fetchtr_ui(fi.absoluteFilePath(), fetchedTor,
defaultContext, True)
if not standardSyntax:
updateTsFiles(fetchedTor, tsFileNames, codecForTr, noObsolete, verbose)
if numFiles == 0:
printUsage()
sys.exit(1)
def initializeLayer(self, screenExtent=None):
if self.error or self.initialized or self.initializing:
return
if self.filepath is not None:
# not safe...
self.initializing = True
filepath = self.getAbsoluteFilepath()
if not os.path.exists(filepath):
# TODO integrate with BadLayerHandler ?
loadErrorDialog = LoadErrorDialog(filepath)
result = loadErrorDialog.exec_()
if result == 1:
# absolute
filepath = loadErrorDialog.lineEditImagePath.text()
# to relative if needed
self.filepath = utils.toRelativeToQGS(filepath)
self.setCustomProperty("filepath", self.filepath)
QgsProject.instance().setDirty(True)
else:
self.error = True
del loadErrorDialog
fileInfo = QFileInfo(filepath)
ext = fileInfo.suffix()
if ext == "pdf":
s = QSettings()
oldValidation = s.value("/Projections/defaultBehavior")
s.setValue("/Projections/defaultBehavior", "useGlobal") # for not asking about crs
path = fileInfo.filePath()
baseName = fileInfo.baseName()
layer = QgsRasterLayer(path, baseName)
self.image = layer.previewAsImage(QSize(layer.width(),layer.height()))
s.setValue("/Projections/defaultBehavior", oldValidation)
else:
reader = QImageReader(filepath)
self.image = reader.read()
self.initialized = True
self.initializing = False
self.setupCrs()
if screenExtent:
# constructor called from AddLayer action
# if not, layer loaded from QGS project file
# check if image already has georef info
# use GDAL
dataset = gdal.Open(filepath, gdal.GA_ReadOnly)
georef = None
if dataset:
georef = dataset.GetGeoTransform()
if georef and not self.is_default_geotransform(georef):
self.initializeExistingGeoreferencing(dataset, georef)
else:
# init to default params
self.setCenter(screenExtent.center())
self.setRotation(0.0)
sw = screenExtent.width()
sh = screenExtent.height()
self.resetScale(sw, sh)
self.commitTransformParameters()
