class Progress(QDialog):
file_converted_signal = pyqtSignal()
update_text_edit_signal = pyqtSignal(str)
def __init__(self, files, tab, delete, parent, test=False):
"""
Keyword arguments:
files -- list with dicts containing file names
tab -- instanseof AudioVideoTab, ImageTab or DocumentTab
indicating currently active tab
delete -- boolean that shows if files must removed after conversion
parent -- parent widget
files:
Each dict have only one key and one corresponding value.
Key is a file to be converted and it's value is the name of the new
file that will be converted.
Example list:
[{"/foo/bar.png" : "/foo/bar.bmp"}, {"/f/bar2.png" : "/f/bar2.bmp"}]
"""
super(Progress, self).__init__(parent)
self.parent = parent
self.files = files
self.num_total_files = len(self.files)
self.tab = tab
self.delete = delete
if not test:
self._type = tab.name
self.ok = 0
self.error = 0
self.running = True
self.nowQL = QLabel(self.tr('In progress: '))
self.nowQPBar = QProgressBar()
self.nowQPBar.setValue(0)
self.shutdownQCB = QCheckBox(self.tr('Shutdown after conversion'))
self.cancelQPB = QPushButton(self.tr('Cancel'))
detailsQPB = QCommandLinkButton(self.tr('Details'))
detailsQPB.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
detailsQPB.setCheckable(True)
detailsQPB.setMaximumWidth(113)
line = QFrame()
line.setFrameShape(QFrame.HLine)
line.setFrameShadow(QFrame.Sunken)
self.outputQTE = QTextEdit()
self.outputQTE.setReadOnly(True)
self.frame = QFrame()
frame_layout = utils.add_to_layout('h', self.outputQTE)
self.frame.setLayout(frame_layout)
self.frame.hide()
hlayout1 = utils.add_to_layout('h', None, self.nowQL, None)
hlayout2 = utils.add_to_layout('h', detailsQPB, line)
hlayout3 = utils.add_to_layout('h', self.frame)
hlayout4 = utils.add_to_layout('h', None, self.cancelQPB)
vlayout = utils.add_to_layout(
'v', hlayout1, self.nowQPBar, hlayout2, hlayout3,
self.shutdownQCB, hlayout4
)
self.setLayout(vlayout)
detailsQPB.toggled.connect(self.resize_dialog)
detailsQPB.toggled.connect(self.frame.setVisible)
self.cancelQPB.clicked.connect(self.reject)
self.file_converted_signal.connect(self.next_file)
self.update_text_edit_signal.connect(self.update_text_edit)
self.resize(484, 190)
self.setWindowTitle('FF Multi Converter - ' + self.tr('Conversion'))
if not test:
self.get_data() # should be first and not in QTimer.singleShot()
QTimer.singleShot(0, self.manage_conversions)
def get_data(self):
"""Collect conversion data from parents' widgets."""
if self._type == 'AudioVideo':
self.cmd = self.tab.commandQLE.text()
elif self._type == 'Images':
width = self.tab.widthQLE.text()
self.size = ''
self.mntaspect = False
if width:
height = self.tab.heightQLE.text()
self.size = '{0}x{1}'.format(width, height)
self.mntaspect = self.tab.imgaspectQChB.isChecked()
self.imgcmd = self.tab.commandQLE.text()
if self.tab.autocropQChB.isChecked():
self.imgcmd += ' -trim +repage'
rotate = self.tab.rotateQLE.text().strip()
if rotate:
self.imgcmd += ' -rotate {0}'.format(rotate)
if self.tab.vflipQChB.isChecked():
self.imgcmd += ' -flip'
if self.tab.hflipQChB.isChecked():
self.imgcmd += ' -flop'
def resize_dialog(self):
"""Resize dialog"""
height = 190 if self.frame.isVisible() else 450
self.setMinimumSize(484, height)
self.resize(484, height)
def update_text_edit(self, txt):
"""Append txt to the end of current self.outputQTE's text."""
current = self.outputQTE.toPlainText()
self.outputQTE.setText(current+txt)
self.outputQTE.moveCursor(QTextCursor.End)
def manage_conversions(self):
"""
Check whether all files have been converted.
If not, it will allow convert_a_file() to convert the next file.
"""
if not self.running:
return
if not self.files:
sum_files = self.ok + self.error
msg = QMessageBox(self)
msg.setStandardButtons(QMessageBox.Ok)
msg.setWindowTitle(self.tr("Report"))
msg.setText(self.tr("Converted: {0}/{1}".format(self.ok,sum_files)))
msg.setModal(False)
msg.show()
self.cancelQPB.setText(self.tr("Close"))
if self.shutdownQCB.isChecked():
if utils.is_installed('systemctl'):
subprocess.call(shlex.split('systemctl poweroff'))
else:
subprocess.call(shlex.split('shutdown -h now'))
else:
self.convert_a_file()
def next_file(self):
"""
Update progress bar value, remove converted file from self.files
and call manage_conversions() to continue the process.
"""
self.nowQPBar.setValue(100)
QApplication.processEvents()
self.files.pop(0)
self.manage_conversions()
def reject(self):
"""
Use standard dialog to ask whether procedure must stop or not.
Use the SIGSTOP to stop the conversion process while waiting for user
to respond and SIGCONT or kill depending on user's answer.
"""
if not self.files:
QDialog.accept(self)
return
if self._type == 'AudioVideo':
self.process.send_signal(signal.SIGSTOP)
self.running = False
reply = QMessageBox.question(
self,
'FF Multi Converter - ' + self.tr('Cancel Conversion'),
self.tr('Are you sure you want to cancel conversion?'),
QMessageBox.Yes|QMessageBox.Cancel
)
if reply == QMessageBox.Yes:
if self._type == 'AudioVideo':
self.process.kill()
self.running = False
self.thread.join()
QDialog.reject(self)
if reply == QMessageBox.Cancel:
self.running = True
if self._type == 'AudioVideo':
self.process.send_signal(signal.SIGCONT)
else:
self.manage_conversions()
def convert_a_file(self):
"""
Update self.nowQL's text with current file's name, set self.nowQPBar
value to zero and start the conversion procedure in a second thread
using threading module.
"""
if not self.files:
return
from_file = list(self.files[0].keys())[0]
to_file = list(self.files[0].values())[0]
text = os.path.basename(from_file[1:-1])
num_file = self.num_total_files - len(self.files) + 1
text += ' ({0}/{1})'.format(num_file, self.num_total_files)
self.nowQL.setText(self.tr('In progress:') + ' ' + text)
self.nowQPBar.setValue(0)
if not os.path.exists(from_file[1:-1]):
self.error += 1
self.file_converted_signal.emit()
return
def convert():
if self._type == 'AudioVideo':
conv_func = self.convert_video
params = (from_file, to_file, self.cmd)
elif self._type == 'Images':
conv_func = self.convert_image
params = (from_file, to_file, self.size, self.mntaspect,
self.imgcmd)
else:
conv_func = self.convert_document
params = (from_file, to_file)
if conv_func(*params):
self.ok += 1
if self.delete and not from_file == to_file:
try:
os.remove(from_file[1:-1])
except OSError:
pass
else:
self.error += 1
self.file_converted_signal.emit()
self.thread = threading.Thread(target=convert)
self.thread.start()
def convert_video(self, from_file, to_file, command):
"""
Create the ffmpeg command and execute it in a new process using the
subprocess module. While the process is alive, parse ffmpeg output,
estimate conversion progress using video's duration.
With the result, emit the corresponding signal in order progress bar
to be updated. Also emit regularly the corresponding signal in order
an outputQTE to be updated with ffmpeg's output. Finally, save log
information.
Return True if conversion succeed, else False.
"""
# note: from_file and to_file names are inside quotation marks
convert_cmd = '{0} -y -i {1} {2} {3}'.format(
self.parent.ffmpeg_path, from_file, command, to_file)
self.update_text_edit_signal.emit(convert_cmd + '\n')
self.process = subprocess.Popen(
shlex.split(convert_cmd),
stderr=subprocess.STDOUT,
stdout=subprocess.PIPE
)
final_output = myline = ''
reader = io.TextIOWrapper(self.process.stdout, encoding='utf8')
while True:
out = reader.read(1)
if out == '' and self.process.poll() is not None:
break
myline += out
if out in ('\r', '\n'):
m = re.search("Duration: ([0-9:.]+)", myline)
if m:
total = utils.duration_in_seconds(m.group(1))
n = re.search("time=([0-9:]+)", myline)
# time can be of format 'time=hh:mm:ss.ts' or 'time=ss.ts'
# depending on ffmpeg version
if n:
time = n.group(1)
if ':' in time:
time = utils.duration_in_seconds(time)
now_sec = int(float(time))
try:
self.nowQPBar.setValue(100 * now_sec / total)
except (UnboundLocalError, ZeroDivisionError):
pass
self.update_text_edit_signal.emit(myline)
final_output += myline
myline = ''
self.update_text_edit_signal.emit('\n\n')
return_code = self.process.poll()
log_data = {
'command' : convert_cmd,
'returncode' : return_code,
'type' : 'VIDEO'
}
log_lvl = logging.info if return_code == 0 else logging.error
log_lvl(final_output, extra=log_data)
return return_code == 0
def convert_image(self, from_file, to_file, size, mntaspect, imgcmd):
"""
Convert an image using ImageMagick.
Create conversion info ("cmd") and emit the corresponding signal
in order an outputQTE to be updated with that info.
Finally, save log information.
Return True if conversion succeed, else False.
"""
# note: from_file and to_file names are inside quotation marks
resize = ''
if size:
resize = '-resize {0}'.format(size)
if not mntaspect:
resize += '\!'
imgcmd = ' ' + imgcmd.strip() + ' '
cmd = 'convert {0} {1}{2}{3}'.format(from_file, resize, imgcmd, to_file)
self.update_text_edit_signal.emit(cmd + '\n')
child = subprocess.Popen(
shlex.split(cmd),
stderr=subprocess.STDOUT,
stdout=subprocess.PIPE
)
child.wait()
reader = io.TextIOWrapper(child.stdout, encoding='utf8')
final_output = reader.read()
self.update_text_edit_signal.emit(final_output+'\n\n')
return_code = child.poll()
log_data = {
'command' : cmd,
'returncode' : return_code,
'type' : 'IMAGE'
}
log_lvl = logging.info if return_code == 0 else logging.error
log_lvl(final_output, extra=log_data)
return return_code == 0
def convert_document(self, from_file, to_file):
"""
Create the unoconv command and execute it using the subprocess module.
Emit the corresponding signal in order an outputQTE to be updated
with unoconv's output. Finally, save log information.
Return True if conversion succeed, else False.
"""
# note: from_file and to_file names are inside quotation marks
to_base, to_ext = os.path.splitext(to_file[1:-1])
cmd = 'unoconv -f {0} -o {1} {2}'.format(to_ext[1:], to_file, from_file)
self.update_text_edit_signal.emit(cmd + '\n')
child = subprocess.Popen(
shlex.split(cmd),
stderr=subprocess.STDOUT,
stdout=subprocess.PIPE
)
child.wait()
reader = io.TextIOWrapper(child.stdout, encoding='utf8')
final_output = reader.read()
self.update_text_edit_signal.emit(final_output+'\n\n')
return_code = child.poll()
log_data = {
'command' : cmd,
'returncode' : return_code,
'type' : 'DOCUMENT'
}
log_lvl = logging.info if return_code == 0 else logging.error
log_lvl(final_output, extra=log_data)
return return_code == 0
class GuiMain(QMainWindow):
def __init__(self):
QMainWindow.__init__(self)
logger.info("Starting %s" % nw.__package__)
logger.debug("Initialising GUI ...")
self.mainConf = nw.CONFIG
self.theTheme = GuiTheme(self)
self.theProject = NWProject(self)
self.theIndex = NWIndex(self.theProject, self)
self.hasProject = False
self.isZenMode = False
logger.info("OS: %s" % (
self.mainConf.osType)
)
logger.info("Qt5 Version: %s (%d)" % (
self.mainConf.verQtString, self.mainConf.verQtValue)
)
logger.info("PyQt5 Version: %s (%d)" % (
self.mainConf.verPyQtString, self.mainConf.verPyQtValue)
)
logger.info("Python Version: %s (0x%x)" % (
self.mainConf.verPyString, self.mainConf.verPyHexVal)
)
self.resize(*self.mainConf.winGeometry)
self._setWindowTitle()
self.setWindowIcon(QIcon(path.join(self.mainConf.appIcon)))
# Main GUI Elements
self.statusBar = GuiMainStatus(self)
self.noticeBar = GuiNoticeBar(self)
self.docEditor = GuiDocEditor(self, self.theProject)
self.docViewer = GuiDocViewer(self, self.theProject)
self.viewMeta = GuiDocViewDetails(self, self.theProject)
self.searchBar = GuiSearchBar(self)
self.treeMeta = GuiDocDetails(self, self.theProject)
self.treeView = GuiDocTree(self, self.theProject)
self.mainMenu = GuiMainMenu(self, self.theProject)
# Minor Gui Elements
self.statusIcons = []
self.importIcons = []
# Assemble Main Window
self.treePane = QFrame()
self.treeBox = QVBoxLayout()
self.treeBox.setContentsMargins(0,0,0,0)
self.treeBox.addWidget(self.treeView)
self.treeBox.addWidget(self.treeMeta)
self.treePane.setLayout(self.treeBox)
self.editPane = QFrame()
self.docEdit = QVBoxLayout()
self.docEdit.setContentsMargins(0,0,0,0)
self.docEdit.addWidget(self.searchBar)
self.docEdit.addWidget(self.noticeBar)
self.docEdit.addWidget(self.docEditor)
self.editPane.setLayout(self.docEdit)
self.viewPane = QFrame()
self.docView = QVBoxLayout()
self.docView.setContentsMargins(0,0,0,0)
self.docView.addWidget(self.docViewer)
self.docView.addWidget(self.viewMeta)
self.docView.setStretch(0, 1)
self.viewPane.setLayout(self.docView)
self.splitView = QSplitter(Qt.Horizontal)
self.splitView.setOpaqueResize(False)
self.splitView.addWidget(self.editPane)
self.splitView.addWidget(self.viewPane)
self.splitMain = QSplitter(Qt.Horizontal)
self.splitMain.setContentsMargins(4,4,4,4)
self.splitMain.setOpaqueResize(False)
self.splitMain.addWidget(self.treePane)
self.splitMain.addWidget(self.splitView)
self.splitMain.setSizes(self.mainConf.mainPanePos)
self.setCentralWidget(self.splitMain)
self.idxTree = self.splitMain.indexOf(self.treePane)
self.idxMain = self.splitMain.indexOf(self.splitView)
self.idxEditor = self.splitView.indexOf(self.editPane)
self.idxViewer = self.splitView.indexOf(self.viewPane)
self.splitMain.setCollapsible(self.idxTree, False)
self.splitMain.setCollapsible(self.idxMain, False)
self.splitView.setCollapsible(self.idxEditor, False)
self.splitView.setCollapsible(self.idxViewer, True)
self.viewPane.setVisible(False)
self.searchBar.setVisible(False)
# Build The Tree View
self.treeView.itemSelectionChanged.connect(self._treeSingleClick)
self.treeView.itemDoubleClicked.connect(self._treeDoubleClick)
self.rebuildTree()
# Set Main Window Elements
self.setMenuBar(self.mainMenu)
self.setStatusBar(self.statusBar)
self.statusBar.setStatus("Ready")
# Set Up Autosaving Project Timer
self.asProjTimer = QTimer()
self.asProjTimer.timeout.connect(self._autoSaveProject)
# Set Up Autosaving Document Timer
self.asDocTimer = QTimer()
self.asDocTimer.timeout.connect(self._autoSaveDocument)
# Shortcuts and Actions
self._connectMenuActions()
keyReturn = QShortcut(self.treeView)
keyReturn.setKey(QKeySequence(Qt.Key_Return))
keyReturn.activated.connect(self._treeKeyPressReturn)
keyEscape = QShortcut(self)
keyEscape.setKey(QKeySequence(Qt.Key_Escape))
keyEscape.activated.connect(self._keyPressEscape)
# Forward Functions
self.setStatus = self.statusBar.setStatus
self.setProjectStatus = self.statusBar.setProjectStatus
if self.mainConf.showGUI:
self.show()
self.initMain()
self.asProjTimer.start()
self.asDocTimer.start()
self.statusBar.clearStatus()
self.showNormal()
if self.mainConf.isFullScreen:
self.toggleFullScreenMode()
logger.debug("GUI initialisation complete")
if self.mainConf.cmdOpen is not None:
logger.debug("Opening project from additional command line option")
self.openProject(self.mainConf.cmdOpen)
return
def clearGUI(self):
"""Wrapper function to clear all sub-elements of the main GUI.
"""
self.treeView.clearTree()
self.docEditor.clearEditor()
self.closeDocViewer()
self.statusBar.clearStatus()
return True
def initMain(self):
self.asProjTimer.setInterval(int(self.mainConf.autoSaveProj*1000))
self.asDocTimer.setInterval(int(self.mainConf.autoSaveDoc*1000))
return True
##
# Project Actions
##
def newProject(self, projPath=None, forceNew=False):
if self.hasProject:
msgBox = QMessageBox()
msgRes = msgBox.warning(
self, "New Project",
"Please close the current project<br>before making a new one."
)
return False
if projPath is None:
projPath = self.newProjectDialog()
if projPath is None:
return False
if path.isfile(path.join(projPath,self.theProject.projFile)) and not forceNew:
msgBox = QMessageBox()
msgRes = msgBox.critical(
self, "New Project",
"A project already exists in that location.<br>Please choose another folder."
)
return False
logger.info("Creating new project")
self.theProject.newProject()
self.theProject.setProjectPath(projPath)
self.rebuildTree()
self.saveProject()
self.hasProject = True
self.statusBar.setRefTime(self.theProject.projOpened)
return True
def closeProject(self, isYes=False):
"""Closes the project if one is open.
isYes is passed on from the close application event so the user
doesn't get prompted twice.
"""
if not self.hasProject:
# There is no project loaded, everything OK
return True
if self.mainConf.showGUI and not isYes:
msgBox = QMessageBox()
msgRes = msgBox.question(
self, "Close Project", "Save changes and close current project?"
)
if msgRes != QMessageBox.Yes:
return False
if self.docEditor.docChanged:
self.saveDocument()
if self.theProject.projAltered:
saveOK = self.saveProject()
doBackup = False
if self.theProject.doBackup and self.mainConf.backupOnClose:
doBackup = True
if self.mainConf.showGUI and self.mainConf.askBeforeBackup:
msgBox = QMessageBox()
msgRes = msgBox.question(
self, "Backup Project", "Backup current project?"
)
if msgRes != QMessageBox.Yes:
doBackup = False
if doBackup:
self.backupProject()
else:
saveOK = True
if saveOK:
self.closeDocument()
self.theProject.closeProject()
self.theIndex.clearIndex()
self.clearGUI()
self.hasProject = False
return saveOK
def openProject(self, projFile=None):
"""Open a project. The parameter projFile is passed from the
open recent projects menu, so it can be set. If not, we pop the
dialog.
"""
if projFile is None:
projFile = self.openProjectDialog()
if projFile is None:
return False
# Make sure any open project is cleared out first before we load
# another one
if not self.closeProject():
return False
# Try to open the project
if not self.theProject.openProject(projFile):
return False
# project is loaded
self.hasProject = True
# Load the tag index
self.theIndex.loadIndex()
# Update GUI
self._setWindowTitle(self.theProject.projName)
self.rebuildTree()
self.docEditor.setDictionaries()
self.docEditor.setSpellCheck(self.theProject.spellCheck)
self.statusBar.setRefTime(self.theProject.projOpened)
self.mainMenu.updateMenu()
# Restore previously open documents, if any
if self.theProject.lastEdited is not None:
self.openDocument(self.theProject.lastEdited)
if self.theProject.lastViewed is not None:
self.viewDocument(self.theProject.lastViewed)
# Check if we need to rebuild the index
if self.theIndex.indexBroken:
self.rebuildIndex()
return True
def saveProject(self):
"""Save the current project.
"""
if not self.hasProject:
return False
# If the project is new, it may not have a path, so we need one
if self.theProject.projPath is None:
projPath = self.saveProjectDialog()
self.theProject.setProjectPath(projPath)
if self.theProject.projPath is None:
return False
self.treeView.saveTreeOrder()
self.theProject.saveProject()
self.theIndex.saveIndex()
self.mainMenu.updateRecentProjects()
return True
def backupProject(self):
theBackup = NWBackup(self, self.theProject)
theBackup.zipIt()
return True
##
# Document Actions
##
def closeDocument(self):
if self.hasProject:
if self.docEditor.docChanged:
self.saveDocument()
self.docEditor.clearEditor()
return True
def openDocument(self, tHandle):
if self.hasProject:
self.closeDocument()
if self.docEditor.loadText(tHandle):
self.docEditor.setFocus()
self.theProject.setLastEdited(tHandle)
else:
return False
return True
def saveDocument(self):
if self.hasProject:
self.docEditor.saveText()
return True
def viewDocument(self, tHandle=None):
if tHandle is None:
tHandle = self.treeView.getSelectedHandle()
if tHandle is None:
logger.debug("No document selected, trying editor document")
tHandle = self.docEditor.theHandle
if tHandle is None:
logger.debug("No document selected, trying last viewed")
tHandle = self.theProject.lastViewed
if tHandle is None:
logger.debug("No document selected, giving up")
return False
if self.docViewer.loadText(tHandle) and not self.viewPane.isVisible():
bPos = self.splitMain.sizes()
self.viewPane.setVisible(True)
vPos = [0,0]
vPos[0] = int(bPos[1]/2)
vPos[1] = bPos[1]-vPos[0]
self.splitView.setSizes(vPos)
return True
def importDocument(self):
lastPath = self.mainConf.lastPath
extFilter = [
"Text files (*.txt)",
"Markdown files (*.md)",
"All files (*.*)",
]
dlgOpt = QFileDialog.Options()
dlgOpt |= QFileDialog.DontUseNativeDialog
inPath = QFileDialog.getOpenFileName(
self,"Import File",lastPath,options=dlgOpt,filter=";;".join(extFilter)
)
if inPath:
loadFile = inPath[0]
else:
return False
if loadFile.strip() == "":
return False
theText = None
try:
with open(loadFile,mode="rt",encoding="utf8") as inFile:
theText = inFile.read()
self.mainConf.setLastPath(loadFile)
except Exception as e:
self.makeAlert(
["Could not read file. The file must be an existing text file.",str(e)],
nwAlert.ERROR
)
return False
if self.docEditor.theHandle is None:
self.makeAlert(
["Please open a document to import the text file into."],
nwAlert.ERROR
)
return False
if not self.docEditor.isEmpty():
if self.mainConf.showGUI:
msgBox = QMessageBox()
msgRes = msgBox.question(self, "Import Document",(
"Importing the file will overwrite the current content of the document. "
"Do you want to proceed?"
))
if msgRes != QMessageBox.Yes:
return False
else:
return False
self.docEditor.replaceText(theText)
return True
def mergeDocuments(self):
"""Merge multiple documents to one single new document.
"""
if self.mainConf.showGUI:
dlgMerge = GuiDocMerge(self, self.theProject)
dlgMerge.exec_()
return True
def splitDocument(self):
"""Split a single document into multiple documents.
"""
if self.mainConf.showGUI:
dlgSplit = GuiDocSplit(self, self.theProject)
dlgSplit.exec_()
return True
def passDocumentAction(self, theAction):
"""Pass on document action theAction to whatever document has
the focus. If no document has focus, the action is discarded.
"""
if self.docEditor.hasFocus():
self.docEditor.docAction(theAction)
elif self.docViewer.hasFocus():
self.docViewer.docAction(theAction)
else:
logger.debug("Document action requested, but no document has focus")
return True
##
# Tree Item Actions
##
def openSelectedItem(self):
tHandle = self.treeView.getSelectedHandle()
if tHandle is None:
logger.warning("No item selected")
return False
logger.verbose("Opening item %s" % tHandle)
nwItem = self.theProject.getItem(tHandle)
if nwItem.itemType == nwItemType.FILE:
logger.verbose("Requested item %s is a file" % tHandle)
self.openDocument(tHandle)
else:
logger.verbose("Requested item %s is not a file" % tHandle)
return True
def editItem(self):
tHandle = self.treeView.getSelectedHandle()
if tHandle is None:
logger.warning("No item selected")
return
logger.verbose("Requesting change to item %s" % tHandle)
if self.mainConf.showGUI:
dlgProj = GuiItemEditor(self, self.theProject, tHandle)
if dlgProj.exec_():
self.treeView.setTreeItemValues(tHandle)
return
def rebuildTree(self):
self._makeStatusIcons()
self._makeImportIcons()
self.treeView.clearTree()
self.treeView.buildTree()
return
def rebuildIndex(self):
if not self.hasProject:
return False
logger.debug("Rebuilding indices ...")
self.treeView.saveTreeOrder()
self.theIndex.clearIndex()
nItems = len(self.theProject.treeOrder)
dlgProg = QProgressDialog("Scanning files ...", "Cancel", 0, nItems, self)
dlgProg.setWindowModality(Qt.WindowModal)
dlgProg.setMinimumDuration(0)
dlgProg.setFixedWidth(480)
dlgProg.setLabelText("Starting file scan ...")
dlgProg.setValue(0)
dlgProg.show()
time.sleep(0.5)
nDone = 0
for tHandle in self.theProject.treeOrder:
tItem = self.theProject.getItem(tHandle)
dlgProg.setValue(nDone)
dlgProg.setLabelText("Scanning: %s" % tItem.itemName)
logger.verbose("Scanning: %s" % tItem.itemName)
if tItem is not None and tItem.itemType == nwItemType.FILE:
theDoc = NWDoc(self.theProject, self)
theText = theDoc.openDocument(tHandle, False)
# Run Word Count
cC, wC, pC = countWords(theText)
tItem.setCharCount(cC)
tItem.setWordCount(wC)
tItem.setParaCount(pC)
self.treeView.propagateCount(tHandle, wC)
self.treeView.projectWordCount()
# Build tag index
self.theIndex.scanText(tHandle, theText)
nDone += 1
if dlgProg.wasCanceled():
break
dlgProg.setValue(nItems)
return True
##
# Main Dialogs
##
def openProjectDialog(self):
dlgOpt = QFileDialog.Options()
dlgOpt |= QFileDialog.DontUseNativeDialog
projFile, _ = QFileDialog.getOpenFileName(
self, "Open novelWriter Project", "",
"novelWriter Project File (%s);;All Files (*)" % nwFiles.PROJ_FILE,
options=dlgOpt
)
if projFile:
return projFile
return None
def saveProjectDialog(self):
dlgOpt = QFileDialog.Options()
dlgOpt |= QFileDialog.ShowDirsOnly
dlgOpt |= QFileDialog.DontUseNativeDialog
projPath = QFileDialog.getExistingDirectory(
self, "Save novelWriter Project", "", options=dlgOpt
)
if projPath:
return projPath
return None
def newProjectDialog(self):
dlgOpt = QFileDialog.Options()
dlgOpt |= QFileDialog.ShowDirsOnly
dlgOpt |= QFileDialog.DontUseNativeDialog
projPath = QFileDialog.getExistingDirectory(
self, "Select Location for New novelWriter Project", "", options=dlgOpt
)
if projPath:
return projPath
return None
def editConfigDialog(self):
dlgConf = GuiConfigEditor(self, self.theProject)
if dlgConf.exec_() == QDialog.Accepted:
logger.debug("Applying new preferences")
self.initMain()
self.theTheme.updateTheme()
self.saveDocument()
self.docEditor.initEditor()
self.docViewer.initViewer()
return True
def editProjectDialog(self):
if self.hasProject:
dlgProj = GuiProjectEditor(self, self.theProject)
dlgProj.exec_()
self._setWindowTitle(self.theProject.projName)
return True
def exportProjectDialog(self):
if self.hasProject:
dlgExport = GuiExport(self, self.theProject)
dlgExport.exec_()
return True
def showTimeLineDialog(self):
if self.hasProject:
dlgTLine = GuiTimeLineView(self, self.theProject, self.theIndex)
dlgTLine.exec_()
return True
def showSessionLogDialog(self):
if self.hasProject:
dlgTLine = GuiSessionLogView(self, self.theProject)
dlgTLine.exec_()
return True
def makeAlert(self, theMessage, theLevel=nwAlert.INFO):
"""Alert both the user and the logger at the same time. Message
can be either a string or an array of strings. Severity level is
0 = info, 1 = warning, and 2 = error.
"""
if isinstance(theMessage, list):
popMsg = " ".join(theMessage)
logMsg = theMessage
else:
popMsg = theMessage
logMsg = [theMessage]
msgBox = QMessageBox()
if theLevel == nwAlert.INFO:
for msgLine in logMsg:
logger.info(msgLine)
msgBox.information(self, "Information", popMsg)
elif theLevel == nwAlert.WARN:
for msgLine in logMsg:
logger.warning(msgLine)
msgBox.warning(self, "Warning", popMsg)
elif theLevel == nwAlert.ERROR:
for msgLine in logMsg:
logger.error(msgLine)
msgBox.critical(self, "Error", popMsg)
elif theLevel == nwAlert.BUG:
for msgLine in logMsg:
logger.error(msgLine)
popMsg += "<br>This is a bug!"
msgBox.critical(self, "Internal Error", popMsg)
return
##
# Main Window Actions
##
def closeMain(self):
if self.mainConf.showGUI and self.hasProject:
msgBox = QMessageBox()
msgRes = msgBox.question(
self, "Exit", "Do you want to save changes and exit?"
)
if msgRes != QMessageBox.Yes:
return False
logger.info("Exiting %s" % nw.__package__)
self.closeProject(True)
self.mainConf.setTreeColWidths(self.treeView.getColumnSizes())
if not self.mainConf.isFullScreen:
self.mainConf.setWinSize(self.width(), self.height())
if not self.isZenMode:
self.mainConf.setMainPanePos(self.splitMain.sizes())
self.mainConf.setDocPanePos(self.splitView.sizes())
self.mainConf.saveConfig()
qApp.quit()
return True
def setFocus(self, paneNo):
if paneNo == 1:
self.treeView.setFocus()
elif paneNo == 2:
self.docEditor.setFocus()
elif paneNo == 3:
self.docViewer.setFocus()
return
def closeDocEditor(self):
self.closeDocument()
self.theProject.setLastEdited(None)
return
def closeDocViewer(self):
self.docViewer.clearViewer()
self.theProject.setLastViewed(None)
bPos = self.splitMain.sizes()
self.viewPane.setVisible(False)
vPos = [bPos[1],0]
self.splitView.setSizes(vPos)
return not self.viewPane.isVisible()
def toggleZenMode(self):
"""Main GUI Zen Mode hides tree, view pane and optionally also
statusbar and menu.
"""
if self.docEditor.theHandle is None:
logger.error("No document open, so not activating Zen Mode")
return False
self.isZenMode = not self.isZenMode
if self.isZenMode:
logger.debug("Activating Zen mode")
else:
logger.debug("Deactivating Zen mode")
isVisible = not self.isZenMode
self.treePane.setVisible(isVisible)
self.statusBar.setVisible(isVisible)
self.mainMenu.setVisible(isVisible)
if self.viewPane.isVisible():
self.viewPane.setVisible(False)
elif self.docViewer.theHandle is not None:
self.viewPane.setVisible(True)
return True
def toggleFullScreenMode(self):
"""Main GUI full screen mode. The mode is tracked by the flag
in config. This only tracks whether the window has been
maximised using the internal commands, and may not be correct
if the user uses the system window manager. Currently, Qt
doesn't have access to the exact state of the window.
"""
self.setWindowState(self.windowState() ^ Qt.WindowFullScreen)
winState = self.windowState() & Qt.WindowFullScreen == Qt.WindowFullScreen
if winState:
logger.debug("Activated full screen mode")
else:
logger.debug("Deactivated full screen mode")
self.mainConf.isFullScreen = winState
return
##
# Internal Functions
##
def _connectMenuActions(self):
"""Connect to the main window all menu actions that need to be
available also when the main menu is hidden.
"""
self.addAction(self.mainMenu.aSaveProject)
self.addAction(self.mainMenu.aExitNW)
self.addAction(self.mainMenu.aSaveDoc)
self.addAction(self.mainMenu.aFileDetails)
self.addAction(self.mainMenu.aZenMode)
self.addAction(self.mainMenu.aFullScreen)
self.addAction(self.mainMenu.aViewTimeLine)
self.addAction(self.mainMenu.aEditUndo)
self.addAction(self.mainMenu.aEditRedo)
self.addAction(self.mainMenu.aEditCut)
self.addAction(self.mainMenu.aEditCopy)
self.addAction(self.mainMenu.aEditPaste)
self.addAction(self.mainMenu.aSelectAll)
self.addAction(self.mainMenu.aSelectPar)
self.addAction(self.mainMenu.aFmtBold)
self.addAction(self.mainMenu.aFmtItalic)
self.addAction(self.mainMenu.aFmtULine)
self.addAction(self.mainMenu.aFmtDQuote)
self.addAction(self.mainMenu.aFmtSQuote)
self.addAction(self.mainMenu.aFmtHead1)
self.addAction(self.mainMenu.aFmtHead2)
self.addAction(self.mainMenu.aFmtHead3)
self.addAction(self.mainMenu.aFmtHead4)
self.addAction(self.mainMenu.aFmtComment)
self.addAction(self.mainMenu.aFmtNoFormat)
self.addAction(self.mainMenu.aSpellCheck)
self.addAction(self.mainMenu.aReRunSpell)
self.addAction(self.mainMenu.aPreferences)
self.addAction(self.mainMenu.aHelp)
return True
def _setWindowTitle(self, projName=None):
winTitle = "%s" % nw.__package__
if projName is not None:
winTitle += " - %s" % projName
self.setWindowTitle(winTitle)
return True
def _autoSaveProject(self):
if (self.hasProject and self.theProject.projChanged and
self.theProject.projPath is not None):
logger.debug("Autosaving project")
self.saveProject()
return
def _autoSaveDocument(self):
if self.hasProject and self.docEditor.docChanged:
logger.debug("Autosaving document")
self.saveDocument()
return
def _makeStatusIcons(self):
self.statusIcons = {}
for sLabel, sCol, _ in self.theProject.statusItems:
theIcon = QPixmap(32,32)
theIcon.fill(QColor(*sCol))
self.statusIcons[sLabel] = QIcon(theIcon)
return
def _makeImportIcons(self):
self.importIcons = {}
for sLabel, sCol, _ in self.theProject.importItems:
theIcon = QPixmap(32,32)
theIcon.fill(QColor(*sCol))
self.importIcons[sLabel] = QIcon(theIcon)
return
##
# Events
##
def closeEvent(self, theEvent):
if self.closeMain():
theEvent.accept()
else:
theEvent.ignore()
return
##
# Signal Handlers
##
def _treeSingleClick(self):
sHandle = self.treeView.getSelectedHandle()
if sHandle is not None:
self.treeMeta.buildViewBox(sHandle)
return
def _treeDoubleClick(self, tItem, colNo):
tHandle = tItem.text(3)
logger.verbose("User double clicked tree item with handle %s" % tHandle)
nwItem = self.theProject.getItem(tHandle)
if nwItem.itemType == nwItemType.FILE:
logger.verbose("Requested item %s is a file" % tHandle)
self.openDocument(tHandle)
else:
logger.verbose("Requested item %s is a folder" % tHandle)
return
def _treeKeyPressReturn(self):
tHandle = self.treeView.getSelectedHandle()
logger.verbose("User pressed return on tree item with handle %s" % tHandle)
nwItem = self.theProject.getItem(tHandle)
if nwItem.itemType == nwItemType.FILE:
logger.verbose("Requested item %s is a file" % tHandle)
self.openDocument(tHandle)
else:
logger.verbose("Requested item %s is a folder" % tHandle)
return
def _keyPressEscape(self):
"""When the escape key is pressed somewhere in the main window,
do the following, in order.
"""
if self.searchBar.isVisible():
self.searchBar.setVisible(False)
return
elif self.isZenMode:
self.toggleZenMode()
return
class Window(QMainWindow):
'''This class instantiates the main gui window'''
def __init__(self, parent=None):
super().__init__(parent)
self.setWindowTitle("ManagerCraft")
self.setCentralWidget(QWidget())
self.styleFrame = QFrame(self.centralWidget())
self.styleFrame.setFixedSize(1024, 500)
self.styleFrame.setStyleSheet(
"border-image: url(./graphics/WindowFrame.png);\
background-image: url(./graphics/Frame_R.png); background-repeat: no-repeat;")
self.setGeometry(100, 100, 1024, 540)
self.setFixedSize(1024, 540)
self._createMenu()
self.ss = QLabel(
"<b>Be sure you're under the same network as your server or connected via VPN!</b>"
)
self.ss.setFixedSize(1024, 20)
self._createStatusBar()
font = QFont("Minecrafter", 22)
self.host = QLineEdit()
self.path = QLineEdit()
self.user = QLineEdit()
self.pas = QLineEdit()
self.host.setFont(font)
#self.path.setFont(font)
self.user.setFont(font)
self.pas.setFont(font)
self.pas.setEchoMode(QLineEdit.Password)
self.host.setFixedSize(250, 50)
self.path.setFixedSize(350, 35)
self.user.setFixedSize(250, 50)
self.pas.setFixedSize(250, 50)
self.dialog = QDialog(self.centralWidget(),
Qt.WindowTitleHint | Qt.WindowSystemMenuHint)
self.dialog.setModal(True)
self.dui = UI_Dialog()
self.dui.setupUi(self.dialog)
self.frameR = QFrame(self.centralWidget())
self.frameR.setFixedSize(1024, 540)
self.frameL = QFrame(self.centralWidget())
self.frameL.hide()
self.frameL.setFixedSize(1024, 540)
self.frameC = QFrame(self.centralWidget())
self.frameC.hide()
self.frameC.setFixedSize(1024, 540)
self.frameS = QFrame(self.centralWidget())
self.frameS.hide()
self.frameS.setFixedSize(1024, 540)
self.err = QLabel(
"<h2><font color='red'>Error: Invalid Input! Try again!</font></h2>",
parent=self.frameR)
self.err.hide()
self.cui = UI2()
self.cui.setupUi(self.frameC)
self._createFirstScreen()
self.mainMenu = True
self.tools = None
self.pwd = None
self.client = None
def __return_to(self, prev, frame):
prev.hide()
frame.show()
def __DC(self):
try:
self.client.close()
except AttributeError:
pass
self.ss.setStyleSheet("background-color: white")
self.ss.setText(
"<b>Server Status: N/A | Be sure you're under the same network as your server or connected via VPN!</b>"
)
self.styleFrame.setStyleSheet(
"border-image: url(./graphics/WindowFrame.png);\
background-image: url(./graphics/Frame_R.png); background-repeat: no-repeat;")
self.err.hide()
self.close_dialog()
self.setWindowTitle("ManagerCraft")
self.removeToolBar(self.tools)
self.frameL.close()
self.frameC.close()
self.frameS.close()
self.frameR.show()
def __check_status(self):
stdin, stdout, stderr = self.client.exec_command(
"systemctl status minecraft")
stat = [i for i in stdout if True][2]
if "Active: active" in stat:
self.ss.setStyleSheet("background-color: green")
self.ss.setText("<b>Server Status: Online</b>")
stdin, stdout, stderr = self.client.exec_command(
'systemctl status ngrok')
grabIP = [
re.search(r"(?<=url=tcp://).+\d+$", i).group() for i in stdout
if re.search(r"(?<=url=tcp://).+\d+$", i)
][0]
self.cui.serverIP.setText(grabIP)
else:
self.cui.serverIP.setText("N/A")
self.ss.setStyleSheet("background-color: red")
self.ss.setText(
"<b><font color='white'>Server Status: Offline</font></b>")
def __startServer(self):
stdin, stdout, stderr = self.client.exec_command(
'sudo systemctl start minecraft ngrok', get_pty=True)
stdin.write(f'{self.pas.text()}\n')
stdin.flush()
self.status.showMessage("Server Is Starting", 20000)
stdin, stdout, stderr = self.client.exec_command(
'systemctl status ngrok')
grabIP = [
re.search(r"(?<=url=tcp://).+\d+$", i).group() for i in stdout
if re.search(r"(?<=url=tcp://).+\d+$", i)
][0]
self.cui.serverIP.setText(grabIP)
QTimer.singleShot(20000, self.__check_status)
def __stopServer(self):
stdin, stdout, stderr = self.client.exec_command(
'sudo systemctl stop minecraft ngrok', get_pty=True)
stdin.write(f'{self.pas.text()}\n')
stdin.flush()
self.status.showMessage("Server Is Stopping", 10000)
self.cui.serverIP.setText("N/A")
QTimer.singleShot(10000, self.__check_status)
def __restartServer(self):
stdin, stdout, stderr = self.client.exec_command(
'sudo systemctl restart minecraft', get_pty=True)
stdin.write(f'{self.pas.text()}\n')
stdin.flush()
self.status.showMessage("Server Is Restarting", 10000)
QTimer.singleShot(10000, self.__check_status)
def _createMenu(self):
self.menu = self.menuBar().addMenu("Menu")
self.menu.addAction("Disconnect", self.__DC)
self.menu.addAction("Exit", self.close)
def _createToolBar(self):
self.tools = QToolBar()
self.tools.setMovable(False)
self.addToolBar(Qt.LeftToolBarArea, self.tools)
self.tools.addAction("CONFIGURATION", self.close)
self.tools.addAction("STATUS", self.close)
def _createStatusBar(self):
self.status = QStatusBar()
self.status.addWidget(self.ss)
self.setStatusBar(self.status)
def _createSecondScreen(self):
vLayout = QVBoxLayout(self.centralWidget())
vLayout.setAlignment(Qt.AlignTop)
vLayout.addWidget(QLabel())
hLayout = QHBoxLayout()
hLayout.setSpacing(0)
hLayout.setAlignment(Qt.AlignHCenter)
formLayout = QFormLayout(self.centralWidget())
formLayout.setFormAlignment(Qt.AlignHCenter)
formLayout.setLabelAlignment(Qt.AlignRight)
btnGroup = QButtonGroup()
btnGroup.setExclusive(True)
title = QLabel()
tPng = QPixmap("./graphics/ManageCraft.png")
title.setPixmap(tPng)
btn1 = QPushButton()
btn1.setFixedSize(130, 40)
btn1.setCheckable(True)
btn1.setChecked(False)
rcPng = QIcon("./graphics/RemoteBtn.png")
btn1.setIcon(rcPng)
btn1.setIconSize(QSize(170, 40))
btn2 = QPushButton()
btn2.setFixedSize(130, 40)
btn2.setCheckable(True)
btn2.setChecked(True)
lcPng = QIcon("./graphics/LocalBtnChecked.png")
btn2.setIcon(lcPng)
btn2.setIconSize(QSize(170, 40))
btn3 = QPushButton()
btn3.setFixedSize(130, 40)
bPng = QIcon("./graphics/BrowseBtn.png")
btn3.setIcon(bPng)
btn3.setIconSize(QSize(200, 40))
btn1.toggled.connect(self.remote)
btnGroup.addButton(btn1)
btn2.toggled.connect(self.local)
btnGroup.addButton(btn2)
btn3.clicked.connect(self.browseL)
btn1.pressed.connect(
partial(self.btnPressToggle, btn1, "RemoteBtnChecked.png"))
btn1.released.connect(
partial(self.btnPressToggle, btn1, "RemoteBtn.png"))
btn3.pressed.connect(
partial(self.btnPressToggle, btn3, "BrowseBtnChecked.png"))
btn3.released.connect(
partial(self.btnPressToggle, btn3, "BrowseBtn.png"))
vLayout.addWidget(title, alignment=Qt.AlignCenter)
hLayout.addWidget(btn1, alignment=Qt.AlignHCenter)
hLayout.addWidget(btn2, alignment=Qt.AlignHCenter)
vLayout.addLayout(hLayout)
vLayout.addWidget(self.path, alignment=Qt.AlignHCenter)
vLayout.addWidget(btn3, alignment=Qt.AlignCenter)
self.frameL.setLayout(vLayout)
self.mainMenu = False
self.frameL.hide()
def _createFirstScreen(self):
vLayout = QVBoxLayout(self.centralWidget())
vLayout.setAlignment(Qt.AlignTop)
vLayout.addWidget(QLabel())
hLayout = QHBoxLayout()
hLayout.setSpacing(0)
hLayout.setAlignment(Qt.AlignHCenter)
formLayout = QFormLayout(self.centralWidget())
formLayout.setFormAlignment(Qt.AlignHCenter)
formLayout.setLabelAlignment(Qt.AlignRight)
btnGroup = QButtonGroup()
btnGroup.setExclusive(True)
title = QLabel()
tPng = QPixmap("./graphics/ManageCraft.png")
title.setPixmap(tPng)
btn1 = QPushButton()
btn1.setFixedSize(130, 40)
btn1.setCheckable(True)
btn1.setChecked(True)
rcPng = QIcon("./graphics/RemoteBtnChecked.png")
btn1.setIcon(rcPng)
btn1.setIconSize(QSize(170, 40))
btn2 = QPushButton()
btn2.setFixedSize(130, 40)
btn2.setCheckable(True)
btn2.setChecked(False)
lcPng = QIcon("./graphics/LocalBtn.png")
btn2.setIcon(lcPng)
btn2.setIconSize(QSize(170, 40))
btn3 = QPushButton()
btn3.setFixedSize(155, 45)
cPng = QIcon("./graphics/ConnectBtn.png")
btn3.setIcon(cPng)
btn3.setIconSize(QSize(200, 40))
btn1.toggled.connect(self.remote)
btnGroup.addButton(btn1)
btn2.toggled.connect(self.local)
btnGroup.addButton(btn2)
btn3.clicked.connect(partial(self.browseR))
btn2.pressed.connect(
partial(self.btnPressToggle, btn2, "LocalBtnChecked.png"))
btn2.released.connect(
partial(self.btnPressToggle, btn2, "LocalBtn.png"))
btn3.pressed.connect(
partial(self.btnPressToggle, btn3, "ConnectBtnChecked.png"))
btn3.released.connect(
partial(self.btnPressToggle, btn3, "ConnectBtn.png"))
host = QLabel()
hPng = QPixmap("./graphics/Host.png")
host.setPixmap(hPng)
user = QLabel()
uPng = QPixmap("./graphics/Username.png")
user.setPixmap(uPng)
pas = QLabel()
pPng = QPixmap("./graphics/Password.png")
pas.setPixmap(pPng)
formLayout.addRow(host, self.host)
formLayout.addRow(user, self.user)
formLayout.addRow(pas, self.pas)
vLayout.addWidget(title, alignment=Qt.AlignCenter)
hLayout.addWidget(btn1, alignment=Qt.AlignHCenter)
hLayout.addWidget(btn2, alignment=Qt.AlignHCenter)
vLayout.addLayout(hLayout)
vLayout.addLayout(formLayout)
vLayout.addWidget(btn3, alignment=Qt.AlignCenter)
vLayout.addWidget(self.err, alignment=Qt.AlignHCenter)
self.frameR.setLayout(vLayout)
self.mainMenu = False
self._createSecondScreen()
def remote(self):
if self.frameR.isVisible():
pass
else:
self.styleFrame.setStyleSheet(
"border-image: url(./graphics/WindowFrame.png);\
background-image: url(./graphics/Frame_R.png); background-repeat: no-repeat;")
self.frameL.hide()
self.frameR.show()
def local(self):
if self.frameL.isVisible():
pass
else:
self.styleFrame.setStyleSheet(
"border-image: url(./graphics/WindowFrame.png);\
background-image: url(./graphics/Frame_L.png); background-repeat: no-repeat;")
self.frameR.hide()
self.frameL.show()
def connect(self): # Pack to config window
self.path.setText(self.dui.path.text())
if self.path.text() != '':
stdin, stdout, stderr = self.client.exec_command(
f"cd {self.path.text()}")
try:
err = [i for i in stderr if True][0]
self.err.setText(
"<h2><font color='red'>Error: No such file or directory!</font></h2>"
)
self.err.show()
except IndexError:
self.styleFrame.setStyleSheet(
"border-image: url(./graphics/WindowFrame.png);\
background-image: url(./graphics/Frame_2.png); background-repeat: no-repeat;")
self.cui.startBtn.clicked.connect(self.__startServer)
self.cui.stopBtn.clicked.connect(self.__stopServer)
self.cui.restartBtn.clicked.connect(self.__restartServer)
self.cui.startBtn.pressed.connect(
partial(self.btnStyleToggle, self.cui.startBtn,
"StartChecked.png"))
self.cui.startBtn.released.connect(
partial(self.btnStyleToggle, self.cui.startBtn,
"Start.png"))
self.cui.stopBtn.pressed.connect(
partial(self.btnStyleToggle, self.cui.stopBtn,
"StopChecked.png"))
self.cui.stopBtn.released.connect(
partial(self.btnStyleToggle, self.cui.stopBtn, "Stop.png"))
self.cui.restartBtn.pressed.connect(
partial(self.btnStyleToggle, self.cui.restartBtn,
"RestartChecked.png"))
self.cui.restartBtn.released.connect(
partial(self.btnStyleToggle, self.cui.restartBtn,
"Restart.png"))
self.err.hide()
self.setWindowTitle(f"{self.path.text()} - ManageCraft")
self._createToolBar()
self.frameR.hide()
self.frameC.show()
self.__check_status()
self.close_dialog()
def browseL(self):
getPath = QFileDialog().getExistingDirectory()
self.path.setText(getPath)
if self.path.text() != '':
self.styleFrame.setStyleSheet(
"border-image: url(./graphics/WindowFrame.png);\
background-image: url(./graphics/Frame_2.png); background-repeat: no-repeat;")
self.setWindowTitle(f"{self.path.text()} - ManageCraft")
self._createToolBar()
self.frameL.hide()
self.frameC.show()
def browseR(self):
if self.host.text() == '' or self.user.text() == '' or self.pas.text(
) == '':
self.err.setText(
"<h2><font color='red'>Error: Invalid Input! Try again!</font></h2>"
)
self.err.show()
else:
try:
self.err.hide()
client = paramiko.SSHClient()
client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
client.connect(self.host.text(),
port=22,
username=self.user.text(),
password=self.pas.text())
self.client = client
self.dui.btnBox.accepted.connect(self.connect)
self.dui.btnBox.rejected.connect(self.close_dialog)
self.plant_tree(self.client)
self.dialog.show()
#Don't proceed until connected
except (socket.gaierror,
paramiko.ssh_exception.AuthenticationException):
self.err.setText(
"<h2><font color='red'>Error: Invalid Input! Try again!</font></h2>"
)
self.err.show()
#Don't proceed unless path given
def next_layer(self,
lst): #Loops through folders and returns dict of subfolders
d = {}
for i in lst:
stdin, stdout, stderr = self.client.exec_command(
f"cd {i} && ls -d */ && cd ..")
dirs = [fold.strip('/\n') for fold in stdout if True]
if len(dirs) > 0:
d[i] = dirs
else:
d[i] = 0
return d
def plant_tree(self, client):
self.dui.treeW.setColumnCount(1)
self.dui.treeW.setAlternatingRowColors(True)
self.dui.treeW.itemExpanded.connect(
partial(self.water_tree, self.dui.treeW))
self.dui.treeW.itemClicked.connect(
partial(self.get_path, self.dui.treeW))
stdin, stdout, stderr = client.exec_command('ls -d */')
top = [i.strip('/\n') for i in stdout if True]
folders = self.next_layer(top)
self.cache = []
stdin, stdout, stderr = client.exec_command('pwd')
self.pwd = [i for i in stdout if True][0].strip('\n')
self.grow_tree(folders)
def grow_tree(self, folders):
items = []
folderIcon = QIcon("./graphics/folder.jpeg")
for folder in folders:
item = QTreeWidgetItem([folder])
item.setIcon(0, folderIcon)
if folders[folder] != 0:
childs = []
for sub in folders[folder]:
s = QTreeWidgetItem([sub])
s.setIcon(0, folderIcon)
childs.append(s)
item.addChildren(childs)
items.append(item)
self.dui.treeW.addTopLevelItems(items)
def bloom_tree(self, branchItem, folders):
folderIcon = QIcon("./graphics/folder.jpeg")
it = QTreeWidgetItemIterator(branchItem,
flags=QTreeWidgetItemIterator.NoChildren)
while it.value():
item = it.value()
for folder in folders:
if folder == self.get_roots(item) and folder not in self.cache:
self.cache.append(folder)
childs = []
if folders[folder] != 0:
for sub in folders[folder]:
s = QTreeWidgetItem([sub])
s.setIcon(0, folderIcon)
childs.append(s)
item.addChildren(childs)
it += 1
def water_tree(self, tree):
it = QTreeWidgetItemIterator(tree,
flags=QTreeWidgetItemIterator.HasChildren)
while it.value():
item = it.value()
tempath = self.get_roots(item)
if item.isExpanded():
cs = item.childCount()
childs = [
f"{tempath}/{item.child(idx).text(0)}" for idx in range(cs)
if True
]
folders = self.next_layer(childs)
self.bloom_tree(item, folders)
it += 1
def get_roots(self, item): # Trace back parents of selected item
it = QTreeWidgetItemIterator(self.dui.treeW,
flags=QTreeWidgetItemIterator.All)
while it.value():
if it.value() == item:
if item.parent() != None:
return self.get_roots(item.parent()) + '/' + item.text(0)
else:
return item.text(0)
it += 1
def get_path(self, tree):
path = self.get_roots(tree.selectedItems()[0])
self.dui.path.setText(f"{self.pwd}/{path}")
def close_dialog(self):
self.dui.path.setText('')
self.dui.treeW.clear()
def btnPressToggle(self, btn, png):
Png = QIcon(f"./graphics/{png}")
btn.setIcon(Png)
btn.setIconSize(QSize(200, 40))
def btnStyleToggle(self, btn, png):
btn.setStyleSheet(f"border-image: url(./graphics/{png})")
