def loadFile(self, fileName):
file = QFile(fileName)
if not file.open(QFile.ReadOnly | QFile.Text):
QMessageBox.warning(
self, "Pablo",
"Cannot read file %s:\n%s." % (fileName, file.errorString()))
return
inFile = QTextStream(file)
QApplication.setOverrideCursor(Qt.WaitCursor)
if (QFileInfo(fileName).suffix() in ("pbl")):
self.paged_text_edit.setHtml(inFile.readAll())
elif (QFileInfo(fileName).suffix() in ("html")):
# FIXME: Prevent double setting of the paged_text_edit where necessary
# FIXME: Double setting may cause bad UX with large files
self.paged_text_edit.setHtml(inFile.readAll())
cleanHtml = HTMLCleaner.clean(
self.paged_text_edit.toHtml()).decode("utf-8")
self.paged_text_edit.setHtml(cleanHtml)
else:
self.paged_text_edit.setPlainText(inFile.readAll())
QApplication.restoreOverrideCursor()
self.setCurrentFile(fileName)
self.statusBar.writeMessageOnStatus("File loaded", 2000)
def selectFile(self, new, old):
if (self.resetting):
self.resetting = False
return
if len(new.indexes()) == 0:
self.clearSelection()
self.currentFile = ""
self.readOnly(True)
return
newSelection = self.files.filePath(new.indexes()[0])
self.settings.setValue("ui/snippeteditor/selected", newSelection)
if QFileInfo(newSelection).isDir():
self.readOnly(True)
self.clearSelection()
self.currentFile = ""
return
if old and old.length() > 0:
oldSelection = self.files.filePath(old.indexes()[0])
if not QFileInfo(oldSelection).isDir() and self.snippetChanged():
question = QMessageBox.question(self, self.tr("Discard"), self.tr("Snippet changed. Discard changes?"))
if question != QMessageBox.StandardButton.Yes:
self.resetting = True
self.tree.selectionModel().select(old, QItemSelectionModel.ClearAndSelect | QItemSelectionModel.Rows)
return False
self.currentFile = newSelection
self.loadSnippet()
def populate_template_model(self, populate):
"""Add all tool template specs to a single QTreeView.
If items is None or an empty list, model is cleared.
Args:
populate (bool): False to clear model, True to populate.
"""
self.template_model.clear()
self.template_model.setHorizontalHeaderItem(
0, QStandardItem("Template specification")) # Add header
# Add category items
source_file_category_item = QStandardItem("Source files")
input_category_item = QStandardItem("Input files")
opt_input_category_item = QStandardItem("Optional input files")
output_category_item = QStandardItem("Output files")
self.template_model.appendRow(source_file_category_item)
self.template_model.appendRow(input_category_item)
self.template_model.appendRow(opt_input_category_item)
self.template_model.appendRow(output_category_item)
if populate:
if self.source_file_model.rowCount() > 0:
for row in range(self.source_file_model.rowCount()):
text = self.source_file_model.item(row).data(
Qt.DisplayRole)
qitem = QStandardItem(text)
qitem.setFlags(~Qt.ItemIsEditable)
qitem.setData(QFileIconProvider().icon(QFileInfo(text)),
Qt.DecorationRole)
source_file_category_item.appendRow(qitem)
if self.input_file_model.rowCount() > 0:
for row in range(self.input_file_model.rowCount()):
text = self.input_file_model.item(row).data(Qt.DisplayRole)
qitem = QStandardItem(text)
qitem.setFlags(~Qt.ItemIsEditable)
qitem.setData(QFileIconProvider().icon(QFileInfo(text)),
Qt.DecorationRole)
input_category_item.appendRow(qitem)
if self.opt_input_file_model.rowCount() > 0:
for row in range(self.opt_input_file_model.rowCount()):
text = self.opt_input_file_model.item(row).data(
Qt.DisplayRole)
qitem = QStandardItem(text)
qitem.setFlags(~Qt.ItemIsEditable)
qitem.setData(QFileIconProvider().icon(QFileInfo(text)),
Qt.DecorationRole)
opt_input_category_item.appendRow(qitem)
if self.output_file_model.rowCount() > 0:
for row in range(self.output_file_model.rowCount()):
text = self.output_file_model.item(row).data(
Qt.DisplayRole)
qitem = QStandardItem(text)
qitem.setFlags(~Qt.ItemIsEditable)
qitem.setData(QFileIconProvider().icon(QFileInfo(text)),
Qt.DecorationRole)
output_category_item.appendRow(qitem)
def _createDocumentIndex(self, canonicalName):
fileName = QFileInfo(canonicalName).fileName()
canonicalIndex = 0
for subWindow in self._documentArea.subWindowList():
if QFileInfo(subWindow.widget().canonicalName()).fileName() == fileName:
if subWindow.widget().canonicalIndex() > canonicalIndex:
canonicalIndex = subWindow.widget().canonicalIndex()
return canonicalIndex + 1
def saveExcelAs(self, graph: list):
curPath = self.dir.currentPath()
title = self._tr("OperatorFile", "保存文件")
filt = self._tr("OperatorFile", "*.xlsx;;*.graph")
fileName, flt = QFileDialog.getSaveFileName(
self,
title,
curPath,
filt,
options=QFileDialog.DontConfirmOverwrite)
if fileName == "":
return
file_full = QFileInfo(fileName)
while file_full.exists():
fileName = f'{file_full.baseName()}_副本.xlsx'
file_full = QFileInfo(fileName)
nodeColumns = ['顶点ID', '权重', 'x坐标', 'y坐标']
edgeColumns = [
'边ID', '始点', '终点', '权重', '1点x坐标', '1点y坐标', '2点x坐标', '2点y坐标',
'3点x坐标', '3点y坐标', '4点x坐标', '4点y坐标', '中心点x坐标', '中心点y坐标'
]
textColumns = ['文本ID', '文本内容', 'x坐标', 'y坐标']
graphName = file_full.baseName()
nodeName = "V" + f'({graphName})'
edgeName = "E" + f'({graphName})'
textName = "T" + f'({graphName})'
dataDict = ["图名称", "顶点集", "边集", "文本集", "图类型"]
graphList = [graphName, nodeName, edgeName, textName, graph[0]]
graphFrame = DataFrame(graphList, index=dataDict)
graphFrame = graphFrame.T
nodeFrame = DataFrame(graph[1], columns=nodeColumns)
edgeFrame = DataFrame(graph[2], columns=edgeColumns)
textFrame = DataFrame(graph[3], columns=textColumns)
try:
with ExcelWriter(fileName) as writer:
graphFrame.to_excel(writer, sheet_name=graphName, index=None)
nodeFrame.to_excel(writer, sheet_name=nodeName, index=None)
edgeFrame.to_excel(writer, sheet_name=edgeName, index=None)
textFrame.to_excel(writer, sheet_name=textName, index=None)
writer.save()
writer.close()
except Exception as e:
text = self._tr("OperatorFile", '权限不足')
QMessageBox.warning(self, text, str(e))
return
return file_full
def _get_icons_info(self, file_list, added, removed):
icons_info = []
try:
for path, is_dir, created_time, was_updated in file_list:
if path not in added:
icons_info.append((None, None, None))
continue
elif path in self._files:
icons_info.append(self._files[path])
continue
abs_path = op.join(self._config.sync_directory, path)
abs_path = ensure_unicode(abs_path)
abs_path = FilePath(abs_path) # .longpath doesn't work
mime, _ = mimetypes.guess_type(path)
image = QImage(abs_path)
if image.isNull():
image = None
icons_info.append((image, mime, QFileInfo(abs_path)))
except Exception as e:
logger.error("Icons info error: %s", e)
self._icons_info_ready.emit(
icons_info, file_list, added, removed)
def _qt_stort_files(indexes: List[QModelIndex],
reverse: bool) -> List[QModelIndex]:
"""
Sorts the indexes according to the order provided by :py:class:`~PySide2.QtCore.QDir`.
Parameters
----------
indexes
The indexes to sort.
reverse
Set to `True` to reverse the sort order.
Returns
-------
`indexes`, sorted using the order defined in :py:class:`~PySide2.QtCore.QDir`.
"""
first_child_path = _get_file_path_from_model_index(indexes[0])
dir_path = Path(first_child_path).parent
qt_file_name_order = QFileInfo(first_child_path).dir().entryList(
QDir.Filter.NoFilter,
QDir.SortFlag.DirsFirst | QDir.SortFlag.LocaleAware)
file_name_order_lookup = {(dir_path / file).absolute(): i
for i, file in enumerate(qt_file_name_order)}
children = sorted(indexes,
key=lambda x: file_name_order_lookup[Path(
_get_file_path_from_model_index(x)).absolute()],
reverse=reverse)
return children
def _loadSettings(self):
settings = QSettings()
# Recent documents
size = settings.beginReadArray("RecentDocuments")
for idx in range(size-1, -1, -1):
settings.setArrayIndex(idx)
canonicalName = QFileInfo(settings.value("Document")).canonicalFilePath()
self._updateRecentDocuments(canonicalName)
settings.endArray()
# Application properties: Geometry
geometry = settings.value("Application/Geometry", QByteArray()) if self._preferences.restoreApplicationGeometry() else QByteArray()
if not geometry.isEmpty():
self.restoreGeometry(geometry)
else:
availableGeometry = self.screen().availableGeometry()
self.resize(availableGeometry.width() * 2/3, availableGeometry.height() * 2/3)
self.move((availableGeometry.width() - self.width()) / 2, (availableGeometry.height() - self.height()) / 2)
# Application properties: State
state = settings.value("Application/State", QByteArray()) if self._preferences.restoreApplicationState() else QByteArray()
if not state.isEmpty():
self.restoreState(state)
else:
self._toolbarApplication.setVisible(True)
self._toolbarDocument.setVisible(True)
self._toolbarEdit.setVisible(True)
self._toolbarTools.setVisible(True)
self._toolbarView.setVisible(False)
self._toolbarHelp.setVisible(False)
def export(self):
settings = QSettings()
filename = QFileDialog.getSaveFileName(self,
self.tr('Export metadata'),
settings.value('save_folder'),
self.tr('CSV files (*.csv)'))[0]
if not filename:
return
if not filename.endswith('.csv'):
filename += '.csv'
settings.setValue('save_folder', QFileInfo(filename).absolutePath())
rows = self.table_widget.rowCount()
cols = self.table_widget.columnCount()
table = [[None for _ in range(cols)] for __ in range(rows)]
for i in range(rows):
for j in range(cols):
item = self.table_widget.item(i, j)
if item is not None:
table[i][j] = item.text()
with open(filename, 'w') as file:
writer = csv.writer(file)
writer.writerow(self.table_headers)
writer.writerows(table)
self.info_message.emit(self.tr('Table contents exported to disk'))
def downloadPlotPngRequested(self, download_item):
old_path = download_item.path()
suffix = QFileInfo(old_path).suffix()
path, _ = QFileDialog.getSaveFileName(self, "Save File", old_path, "*."+suffix)
if path:
download_item.setPath(path)
download_item.accept()
def save(self, ) -> None:
"""Engage the saving process."""
entry = self._entry
save_invalid = self._prompt_save_invalid_entry(entry=entry, )
if not save_invalid:
return
path_format = self._prompt_save_path_format(entry=entry, )
if not path_format:
return
file_path, file_format = path_format
if entry.configuration is None:
entry.configuration = RootConfiguration()
saved = self._save_to_file(
entry=entry,
file_path=file_path,
file_format=file_format,
)
if not saved:
return
self._setup_entry_from_saved_file(
file_info=QFileInfo(file_path),
file_format=file_format,
)
self._log(
log_type=LogType.success,
message=f'{self._entry.name} saved',
)
def scaleImage(self, pixels, path):
dircache = QDir(self.mDir + QDir.separator() + "imagecache")
if dircache.exists() == False:
s = QDir(self.mDir)
s.mkdir("imagecache")
ima = QImage(path)
wids = ima.width()
heis = ima.height()
if (wids > pixels or heis > pixels):
imarescale = ima.scaledToWidth(
pixels, Qt.SmoothTransformation) if (
wids > heis) else ima.scaledToHeight(
pixels, Qt.SmoothTransformation)
newImagePath = dircache.path() + QDir.separator(
) + "_temp_scaled_" + QFileInfo(path).fileName()
imawriter = QImageWriter()
imawriter.setFileName(newImagePath)
# imawriter.setFormat("png");
if (imawriter.write(imarescale)):
#qDebug()<<"si path"<<newImagePath
return newImagePath
else:
#qDebug()<<"no path"<<newImagePath;
return path
return path
def isRunnableFile(self, fileName):
result = False
if (fileName is not None) and (fileName != ""):
fInfo = QFileInfo(fileName)
if (fInfo.exists()) and (fInfo.isExecutable()):
result = True
return result
def reload(self, path):
self.beginResetModel()
iterator = QDirIterator(path,
filter=QDir.Files | QDir.Dirs | QDir.Hidden
| QDir.NoDotAndDotDot,
flags=QDirIterator.Subdirectories)
stats = {}
while iterator.hasNext():
file = iterator.next()
if '.' == file[-1] or '..' == file[-2]:
continue
fileInfo = QFileInfo(file)
if fileInfo.isDir():
name = fileInfo.fileName()
key = name + '$d'
incrementCount(stats, key, ResultItem(name, 'folder', 1))
else:
name = fileInfo.fileName()
key = name + '$f'
incrementCount(stats, key, ResultItem(name, 'file', 1))
if fileInfo.suffix():
name = '*.' + fileInfo.suffix()
key = name + '$s'
incrementCount(stats, key, ResultItem(name, 'suffix', 1))
self.list = list(stats.values())
self.endResetModel()
def collectSelectedFolderFiles(self):
folders, files, suffixes = [], [], []
for index in self.resultView.selectedIndexes():
if index.column() != 0:
# 忽略第二列的selection
continue
item = self.sortFilterModel.data(index, Qt.UserRole)
if 'folder' == item.type:
folders.append(item.name)
elif 'file' == item.type:
files.append(item.name)
elif 'suffix' == item.type:
suffixes.append(item.name[2:])
# 将后缀符合选中条件的文件添加到files中
path = self.pathInputBox.text()
iterator = QDirIterator(path,
filter=QDir.Files | QDir.Dirs | QDir.Hidden
| QDir.NoDotAndDotDot,
flags=QDirIterator.Subdirectories)
folderPaths, filePaths = set(), set()
while iterator.hasNext():
file = iterator.next()
if '.' == file[-1] or '..' == file[-2]:
continue
fileInfo = QFileInfo(file)
if fileInfo.isDir():
if fileInfo.fileName() in folders:
folderPaths.add(fileInfo.absoluteFilePath())
if fileInfo.isFile():
if fileInfo.fileName() in files:
filePaths.add(fileInfo.absoluteFilePath())
if fileInfo.suffix() in suffixes:
filePaths.add(fileInfo.absoluteFilePath())
return sorted(folderPaths), filePaths
def _updateActionRecentDocuments(self):
# Add items to the list, if necessary
for idx in range(len(self._actionRecentDocuments)+1, self._preferences.maximumRecentDocuments()+1):
actionRecentDocument = QAction(self)
actionRecentDocument.setObjectName(f"actionRecentDocument_{idx}")
actionRecentDocument.triggered.connect(lambda data=actionRecentDocument.data(): self._onActionOpenRecentDocumentTriggered(data))
self._actionRecentDocuments.append(actionRecentDocument)
# Remove items from the list, if necessary
while len(self._actionRecentDocuments) > self._preferences.maximumRecentDocuments():
self._actionRecentDocuments.pop()
# Update items
for idx in range(len(self._actionRecentDocuments)):
text = None
data = None
show = False
if idx < len(self._recentDocuments):
text = self.tr("{0} [{1}]").format(QFileInfo(self._recentDocuments[idx]).fileName(), self._recentDocuments[idx])
data = self._recentDocuments[idx]
show = True
self._actionRecentDocuments[idx].setText(text)
self._actionRecentDocuments[idx].setData(data)
self._actionRecentDocuments[idx].setVisible(show)
def select_file(self):
self.file_name = QFileDialog.getOpenFileName(self, "Select file",
self.directory,
"Images (*.png *.jpg)")[0]
self.ui.lineEdit.setText(self.file_name)
f = QFileInfo(self.file_name)
self.directory = f.absolutePath()
def addModel(self, modelFilePath: QUrl) -> Model:
qDebug('ProcessingEngine::addModel()')
modelFilePathExtension = QFileInfo(
modelFilePath).suffix().lower() # returns QString
objReader = vtk.vtkOBJReader()
stlReader = vtk.vtkSTLReader()
inputData = None # vtkPolyData
if modelFilePathExtension == 'obj':
#* Read OBJ file
objReader.SetFileName(modelFilePath)
objReader.Update()
inputData = objReader.GetOutput()
else:
#* Read STL file
stlReader.SetFileName(modelFilePath)
stlReader.Update()
inputData = stlReader.GetOutput()
#* Preprocess the polydata
preprocessedPolydata = self.preprocessPolydata(
inputData) # vtkPolyData
#* Create Model instance and insert it into the vector
model = Model(preprocessedPolydata)
self.__m_models.append(model)
return self.__m_models[-1]
def loadSnippet(self):
self.currentFileLabel.setText(QFileInfo(self.currentFile).baseName())
log_debug("Loading %s as a snippet." % self.currentFile)
(snippetDescription, snippetKey, snippetCode) = loadSnippetFromFile(self.currentFile)
self.snippetDescription.setText(snippetDescription) if snippetDescription else self.snippetDescription.setText("")
self.keySequenceEdit.setKeySequence(snippetKey[0]) if len(snippetKey) != 0 else self.keySequenceEdit.setKeySequence(QKeySequence(""))
self.edit.setPlainText(snippetCode) if snippetCode else self.edit.setPlainText("")
def contextMenuEvent(self, event):
state = self.state()
contextMenu = QMenu()
launchAction = contextMenu.addAction("Launch")
launchAction.setEnabled(
state == QWebEngineDownloadItem.DownloadCompleted)
showInFolderAction = contextMenu.addAction("Show in Folder")
showInFolderAction.setEnabled(
state == QWebEngineDownloadItem.DownloadCompleted)
cancelAction = contextMenu.addAction("Cancel")
cancelAction.setEnabled(
state == QWebEngineDownloadItem.DownloadInProgress)
removeAction = contextMenu.addAction("Remove")
removeAction.setEnabled(
state != QWebEngineDownloadItem.DownloadInProgress)
chosenAction = contextMenu.exec_(event.globalPos())
if chosenAction == launchAction:
self._launch()
elif chosenAction == showInFolderAction:
DownloadWidget.openFile(
QFileInfo(self._downloadItem.path()).absolutePath())
elif chosenAction == cancelAction:
self._downloadItem.cancel()
elif chosenAction == removeAction:
self.removeRequested.emit()
def _load(filePath):
# type: (pathlib.Path) -> NoReturn
with itemsLock:
icon = self.__iconsCache.get(filePath)
if icon is None:
iconProvider = QFileIconProvider()
posixPath = filePath.as_posix()
file = QFileInfo(posixPath)
icon = iconProvider.icon(file)
if icon.isNull():
mimeDb = QMimeDatabase()
for mime in mimeDb.mimeTypesForFileName(posixPath):
icon = QIcon.fromTheme(mime.iconName())
if not icon.isNull():
break
result = QFileIconLoader.LoadResult(filePath, icon)
with itemsLock:
loadedItems[filePath] = result
self.__iconsCache.set(filePath, icon)
self.loaded.emit(result)
if len(loadedItems) == len(targetPaths):
self.completed.emit(loadedItems)
def loadSnippet(self):
self.currentFileLabel.setText(QFileInfo(self.currentFile).baseName())
(snippetDescription, snippetKeys, snippetCode) = loadSnippetFromFile(self.currentFile)
self.snippetDescription.setText(snippetDescription) if snippetDescription else self.snippetDescription.setText("")
self.keySequenceEdit.setKeySequence(snippetKeys) if snippetKeys else self.keySequenceEdit.setKeySequence(QKeySequence(""))
self.edit.setPlainText(snippetCode) if snippetCode else self.edit.setPlainText("")
self.readOnly(False)
def add_single_include(self, path):
"""Add file path to Source files list."""
dirname, file_pattern = os.path.split(path)
# logging.debug("program path:{0}".format(self.program_path))
# logging.debug("{0}, {1}".format(dirname, file_pattern))
if not self.program_path:
self.program_path = dirname
self.ui.label_mainpath.setText(self.program_path)
path_to_add = file_pattern
else:
# check if path is a descendant of main dir.
common_prefix = os.path.commonprefix([os.path.abspath(self.program_path), os.path.abspath(path)])
# logging.debug("common_prefix:{0}".format(common_prefix))
if common_prefix != self.program_path:
self.statusbar.showMessage(
"Source file {0}'s location is invalid " "(should be in main directory)".format(file_pattern), 5000
)
return False
path_to_add = os.path.relpath(path, self.program_path)
if self.sourcefiles_model.findItems(path_to_add):
self.statusbar.showMessage("Source file {0} already included".format(path_to_add), 5000)
return False
qitem = QStandardItem(path_to_add)
qitem.setFlags(~Qt.ItemIsEditable)
qitem.setData(QFileIconProvider().icon(QFileInfo(path_to_add)), Qt.DecorationRole)
self.sourcefiles_model.appendRow(qitem)
return True
def findMdiChild(self, fileName):
canonicalFilePath = QFileInfo(fileName).canonicalFilePath()
for window in self.mdiArea.subWindowList():
if window.widget().currentFile() == canonicalFilePath:
return window
return None
def __init__(self):
super(ManualWindow, self).__init__()
self.setWindowTitle('QAX Manual')
icon_info = QFileInfo(app_info.app_icon_path)
self.setWindowIcon(QIcon(icon_info.absoluteFilePath()))
self.toolbar = QToolBar()
self.addToolBar(self.toolbar)
self.back_button = QPushButton()
self.back_button.setIcon(qta.icon('fa.arrow-left'))
self.back_button.clicked.connect(self.back)
self.toolbar.addWidget(self.back_button)
self.forward_button = QPushButton()
self.forward_button.setIcon(qta.icon('fa.arrow-right'))
self.forward_button.clicked.connect(self.forward)
self.toolbar.addWidget(self.forward_button)
self.address_line_edit = QLineEdit()
self.address_line_edit.returnPressed.connect(self.load)
self.address_line_edit.setVisible(False)
self.toolbar.addWidget(self.address_line_edit)
self.web_engine_view = QWebEngineView()
self.web_engine_view.setZoomFactor(2.0)
self.setCentralWidget(self.web_engine_view)
initialUrl = self.docs_url()
self.address_line_edit.setText(str(initialUrl))
self.web_engine_view.load(QUrl(initialUrl))
self.web_engine_view.page().urlChanged.connect(self.urlChanged)
def savePushed(self):
"""
Let the user select a TCX file to save to. Store the data.
"""
self.saveButton.setEnabled(False)
tcx_dir_key = "file/tcx_dir"
tcx_dir = self.settings.value(tcx_dir_key, ".")
use_file_date = self.useFileDate.isChecked()
if use_file_date:
local_time = self.in_file_info.created().toPython()
else:
local_time = self.workoutTime.dateTime().toPython()
utc_zone = tz.tzutc()
local_zone = tz.tzlocal()
local_time = local_time.replace(tzinfo=local_zone)
start_time = local_time.astimezone(utc_zone)
dialog = QFileDialog(self)
dialog.selectFile(self.in_file_info.baseName() + ".tcx")
dialog.setDirectory(tcx_dir)
dialog.setFileMode(QFileDialog.AnyFile)
dialog.setAcceptMode(QFileDialog.AcceptSave)
filename = None
if dialog.exec_():
filenames = dialog.selectedFiles()
if len(filenames):
filename = filenames[0]
if not filename:
# User cancel
return
power_adjust = self.powerAdjustment.value()
self.mpower.set_power_adjust(power_adjust)
self.mpower.set_interpolation(self.checkBoxInterpolate.isChecked())
mass = self.doubleSpinBoxRiderWeight.value(
) + self.doubleSpinBoxBikeWeight.value()
if self.comboBoxUnits.currentText() == "lbs":
mass *= self.lbs_to_kg
self.mpower.set_physics(self.checkBoxPhysics.isChecked(), mass)
thread_result = {'message': None, 'status': False}
t = threading.Thread(target=self.saveThread,
args=(filename, start_time, thread_result))
t.start()
t.join()
self.alert(thread_result['message'])
info = QFileInfo(filename)
tcx_dir = info.absoluteDir().path()
self.settings.setValue(tcx_dir_key, tcx_dir)
def updateDocumentTitle(self):
fileName = QFileInfo(self._canonicalName).fileName() if self._canonicalName else self.tr("Untitled")
if self._canonicalIndex > 1:
self.setWindowTitle(self.tr("{0} ({1})").format(fileName, self._canonicalIndex))
else:
self.setWindowTitle(fileName)
def ajout_cv_sortie(self, fileNames):
self.ui.listW_cv_sortie.clear()
for file in fileNames:
fInfo = QFileInfo(file)
fShortName = fInfo.baseName()
item = QListWidgetItem(fShortName)
self.ui.listW_cv_sortie.addItem(item)
item.setToolTip(file)
def showEvent(self, event) -> None:
if sys.platform in ['linux', 'darwin']:
media_content = QMediaContent(
QUrl.fromLocalFile(
QFileInfo(
'./../example_data/sample.mp4').absoluteFilePath()))
else:
media_content = QMediaContent(
QUrl.fromLocalFile(
QFileInfo(
'./../example_data/pusheen.gif').absoluteFilePath()))
self.media_player.setMedia(media_content)
self.media_player.setVideoOutput(self.video_widget)
self.video_widget.show()
self.video_widget.update()
self.media_player.setPosition(0)
self.media_player.play()
def newFolder(self):
(folderName, ok) = QInputDialog.getText(self, self.tr("Folder Name"), self.tr("Folder Name: "))
if ok and folderName:
index = self.tree.selectionModel().currentIndex()
selection = self.files.filePath(index)
if QFileInfo(selection).isDir():
QDir(selection).mkdir(folderName)
else:
QDir(snippetPath).mkdir(folderName)
