class E4DirCompleter(QCompleter):
"""
Class implementing a completer for directory names.
"""
def __init__(self, parent = None,
completionMode = QCompleter.PopupCompletion,
showHidden = False):
"""
Constructor
@param parent parent widget of the completer (QWidget)
@keyparam completionMode completion mode of the
completer (QCompleter.CompletionMode)
@keyparam showHidden flag indicating to show hidden entries as well (boolean)
"""
QCompleter.__init__(self, parent)
self.__model = QFileSystemModel(self)
if showHidden:
self.__model.setFilter(\
QDir.Filters(QDir.Drives | QDir.AllDirs | QDir.Hidden))
else:
self.__model.setFilter(\
QDir.Filters(QDir.Drives | QDir.AllDirs))
self.setModel(self.__model)
self.setCompletionMode(completionMode)
if isWindowsPlatform():
self.setCaseSensitivity(Qt.CaseInsensitive)
if parent:
parent.setCompleter(self)
class OrLogsListView(QListView):
def __init__(self, parent=None):
super(OrLogsListView, self).__init__(parent)
self.model = QFileSystemModel()
self.model.sort(3, Qt.DescendingOrder)
self.model.setFilter(QDir.Files)
self.setModel(self.model)
def mouseDoubleClickEvent(self, event):
"""method override"""
QListView.mouseDoubleClickEvent(self, event)
self.clicked()
def getSelectedPath(self):
"""Return selected filename"""
index = self.currentIndex()
if index:
return os.path.normpath(self.model.filePath(index))
def clicked(self):
fname = self.getSelectedPath()
if fname:
self.open(fname)
def open(self, fname):
QDesktopServices.openUrl(QUrl('file:///' + fname))
def setup(self, wdir='.'):
os.makedirs(wdir, exist_ok=True)
self.model.setRootPath(wdir)
self.setRootIndex(self.model.index(wdir))
class AttachmentView(QListView):
""" A dockWidget displaying attachments of the current note.
"""
def __init__(self, parent=None):
super(AttachmentView, self).__init__(parent)
self.parent = parent
self.settings = parent.settings
self.model = QFileSystemModel()
self.model.setFilter(QDir.Files)
self.model.setRootPath(self.settings.attachmentPath)
self.setModel(self.model)
# self.setRootIndex(self.model.index(self.settings.attachmentPath))
self.setViewMode(QListView.IconMode)
self.setUniformItemSizes(True)
self.setResizeMode(QListView.Adjust)
self.setItemDelegate(AttachmentItemDelegate(self))
self.clicked.connect(self.click)
def contextMenuEvent(self, event):
menu = QMenu()
indice = self.selectedIndexes()
if len(indice):
menu.addAction("Insert into note", self.insert)
menu.addAction("Delete", self.delete)
else:
pass
menu.exec_(event.globalPos())
def mousePressEvent(self, event):
""" Trigger click() when an item is pressed.
"""
self.clearSelection()
QListView.mousePressEvent(self, event)
def mouseReleaseEvent(self, event):
""" Trigger click() when an item is pressed.
"""
self.clearSelection()
QListView.mouseReleaseEvent(self, event)
def insert(self):
indice = self.selectedIndexes()
for i in indice:
filePath = self.model.filePath(i)
filePath = filePath.replace(self.settings.notebookPath, "..")
fileName = os.path.basename(filePath)
text = "" % (fileName, filePath)
self.parent.notesEdit.insertPlainText(text)
def delete(self):
indice = self.selectedIndexes()
for i in indice:
filePath = self.model.filePath(i)
QFile(filePath).remove()
def click(self, index):
self.setCurrentIndex(index)
class AttachmentView(QListView):
""" A dockWidget displaying attachments of the current note.
"""
def __init__(self, parent=None):
super(AttachmentView, self).__init__(parent)
self.parent = parent
self.settings = parent.settings
self.model = QFileSystemModel()
self.model.setFilter(QDir.Files)
self.model.setRootPath(self.settings.attachmentPath)
self.setModel(self.model)
# self.setRootIndex(self.model.index(self.settings.attachmentPath))
self.setViewMode(QListView.IconMode)
self.setUniformItemSizes(True)
self.setResizeMode(QListView.Adjust)
self.setItemDelegate(AttachmentItemDelegate(self))
self.clicked.connect(self.click)
def contextMenuEvent(self, event):
menu = QMenu()
indice = self.selectedIndexes()
if len(indice):
menu.addAction(self.tr("Insert into note"), self.insert)
menu.addAction(self.tr("Delete"), self.delete)
else:
pass
menu.exec_(event.globalPos())
def mousePressEvent(self, event):
""" Trigger click() when an item is pressed.
"""
self.clearSelection()
QListView.mousePressEvent(self, event)
def mouseReleaseEvent(self, event):
""" Trigger click() when an item is pressed.
"""
self.clearSelection()
QListView.mouseReleaseEvent(self, event)
def insert(self):
indice = self.selectedIndexes()
for i in indice:
filePath = self.model.filePath(i)
filePath = filePath.replace(self.settings.notebookPath, "..")
fileName = os.path.basename(filePath)
text = "" % (fileName, filePath)
self.parent.notesEdit.insertPlainText(text)
def delete(self):
indice = self.selectedIndexes()
for i in indice:
filePath = self.model.filePath(i)
QFile(filePath).remove()
def click(self, index):
self.setCurrentIndex(index)
def update_dirmodel(self, path):
dirmodel = QFileSystemModel()
dirmodel.setFilter(QDir.NoDotAndDotDot | QDir.AllEntries)
filefilter = ["*.zip"]
dirmodel.setNameFilters(filefilter)
dirmodel.sort(0, Qt.AscendingOrder)
self.file_treeView.setModel(dirmodel)
self.file_treeView.header().setResizeMode(3)
self.file_treeView.model().setRootPath(path)
self.file_treeView.setRootIndex(self.file_treeView.model().index(path))
class FSLineEdit(QLineEdit):
"""
A line edit with auto completion for file system folders.
"""
def __init__(self, parent=None):
QLineEdit.__init__(self, parent)
self.fsmodel = QFileSystemModel()
self.fsmodel.setRootPath("")
self.completer = QCompleter()
self.completer.setModel(self.fsmodel)
self.setCompleter(self.completer)
self.fsmodel.setFilter(QDir.Drives | QDir.AllDirs | QDir.Hidden |
QDir.NoDotAndDotDot)
def setPath(self, path):
self.setText(path)
self.fsmodel.setRootPath(path)
class FSLineEdit(QLineEdit):
"""
A line edit with auto completion for file system folders.
"""
def __init__(self, parent=None):
QLineEdit.__init__(self, parent)
self.fsmodel = QFileSystemModel()
self.fsmodel.setRootPath("")
self.completer = QCompleter()
self.completer.setModel(self.fsmodel)
self.setCompleter(self.completer)
self.fsmodel.setFilter(QDir.Drives | QDir.AllDirs | QDir.Hidden
| QDir.NoDotAndDotDot)
def setPath(self, path):
self.setText(path)
self.fsmodel.setRootPath(path)
def open_project(self, project):
project_path = project.path
qfsm = None # Should end up having a QFileSystemModel
if project_path not in self.__projects:
qfsm = QFileSystemModel()
project.model = qfsm
qfsm.setRootPath(project_path)
qfsm.setFilter(QDir.AllDirs | QDir.Files | QDir.NoDotAndDotDot)
# If set to true items that dont match are displayed disabled
qfsm.setNameFilterDisables(False)
pext = ["*{0}".format(x) for x in project.extensions]
logger.debug(pext)
qfsm.setNameFilters(pext)
self.__projects[project_path] = project
self.__check_files_for(project_path)
self.emit(SIGNAL("projectOpened(PyQt_PyObject)"), project)
else:
qfsm = self.__projects[project_path]
return qfsm
def open_project(self, project):
project_path = project.path
qfsm = None # Should end up having a QFileSystemModel
if project_path not in self.__projects:
qfsm = QFileSystemModel()
project.model = qfsm
qfsm.setRootPath(project_path)
qfsm.setFilter(QDir.AllDirs | QDir.Files | QDir.NoDotAndDotDot)
# If set to true items that dont match are displayed disabled
qfsm.setNameFilterDisables(False)
pext = ["*{0}".format(x) for x in project.extensions]
logger.debug(pext)
qfsm.setNameFilters(pext)
self.__projects[project_path] = project
self.__check_files_for(project_path)
self.emit(SIGNAL("projectOpened(PyQt_PyObject)"), project)
else:
qfsm = self.__projects[project_path]
return qfsm
def load_tree(self, project):
"""Load the tree view on the right based on the project selected."""
qfsm = QFileSystemModel()
#FIXME it's not loading the proper folder, just the root /
qfsm.setRootPath(project.path)
qfsm.setFilter(QDir.AllDirs | QDir.NoDotAndDotDot)
qfsm.setNameFilterDisables(False)
pext = ["*{0}".format(x) for x in project.extensions]
qfsm.setNameFilters(pext)
self._tree.setModel(qfsm)
t_header = self._tree.header()
t_header.setHorizontalScrollMode(QAbstractItemView.ScrollPerPixel)
t_header.setResizeMode(0, QHeaderView.Stretch)
t_header.setStretchLastSection(False)
t_header.setClickable(True)
self._tree.hideColumn(1) # Size
self._tree.hideColumn(2) # Type
self._tree.hideColumn(3) # Modification date
def load_tree(self, project):
"""Load the tree view on the right based on the project selected."""
qfsm = QFileSystemModel()
qfsm.setRootPath(project.path)
load_index = qfsm.index(qfsm.rootPath())
qfsm.setFilter(QDir.AllDirs | QDir.NoDotAndDotDot)
qfsm.setNameFilterDisables(False)
pext = ["*{0}".format(x) for x in project.extensions]
qfsm.setNameFilters(pext)
self._tree.setModel(qfsm)
self._tree.setRootIndex(load_index)
t_header = self._tree.header()
t_header.setHorizontalScrollMode(QAbstractItemView.ScrollPerPixel)
t_header.setResizeMode(0, QHeaderView.Stretch)
t_header.setStretchLastSection(False)
t_header.setClickable(True)
self._tree.hideColumn(1) # Size
self._tree.hideColumn(2) # Type
self._tree.hideColumn(3) # Modification date
class DecryptDialog(QDialog):
def __init__(self):
self.techniquesClass = {
'caesar cipher': caesarCipher,
'mono alphabetic cipher': monoAlphabeticCipher,
'vigenere cipher': vigenereCipher,
'vernan cipher': vernanCipher,
'one time pad': oneTimePad
}
self.rowsview = []
self.filesview = []
#self.techniques = []
QDialog.__init__(self)
self.setWindowTitle("Desencriptador de Cryogenesis Systems.")
self.resize(1024, 600)
self.setMinimumSize(QSize(1024, 600))
self.setMaximumSize(QSize(1024, 600))
self.checkBox_2 = QCheckBox(self)
self.checkBox_2.setGeometry(QRect(620, 10, 130, 20))
self.checkBox_2.setText('seleccionar todos')
self.checkBox_2.clicked.connect(self.__selectAllFiles)
self.treeView = QTreeView(self)
self.treeView.setGeometry(QRect(10, 10, 230, 580))
self.treeView.setObjectName("treeView")
self.fileSystemModel = QFileSystemModel(self.treeView)
self.fileSystemModel.setReadOnly(False)
self.fileSystemModel.setFilter(QDir.AllDirs | QDir.NoDotAndDotDot)
root = self.fileSystemModel.setRootPath("/")
self.treeView.setModel(self.fileSystemModel)
self.treeView.setRootIndex(root)
self.treeView.hideColumn(1)
self.treeView.hideColumn(2)
self.treeView.hideColumn(3)
self.treeView.clicked.connect(self.__eventDirectoryChanged)
self.mygroupbox = QGroupBox(self)
self.mygroupbox.setGeometry(QRect(0, 0, 1000, 1000))
self.myform = QFormLayout()
for j in list(range(100)):
horizontalLayout = QHBoxLayout()
self.myform.addRow(horizontalLayout)
self.rowsview.append(horizontalLayout)
self.mygroupbox.setLayout(self.myform)
scroll = QScrollArea(self)
scroll.setWidget(self.mygroupbox)
scroll.setWidgetResizable(True)
scroll.setGeometry(QRect(250, 30, 500, 580))
scroll.setWidgetResizable(True)
self.label_4 = QLabel(self)
self.label_4.setGeometry(QRect(780, 30, 31, 16))
self.label_4.setPixmap(QPixmap("images/key.png"))
self.label_4.setScaledContents(True)
self.lineEdit = QLineEdit(self)
self.lineEdit.setGeometry(QRect(820, 30, 180, 20))
self.lineEdit.setObjectName("lineEdit")
self.lineEdit.setPlaceholderText(_fromUtf8('escriba su contraseña'))
self.lineEdit.setEchoMode(QLineEdit.Password)
self.okButton = QPushButton(self)
self.okButton.setGeometry(QRect(920, 560, 80, 20))
self.okButton.setText('Iniciar...')
self.connect(self.okButton, SIGNAL("clicked()"),
self.__eventInitDecryption)
def __eventDirectoryChanged(self):
index = self.treeView.currentIndex()
self.__changeDirectory(self.fileSystemModel.filePath(index))
def __changeDirectory(self, path):
for c in self.filesview:
c.setParent(None)
c.deleteLater()
self.filesview = []
self.checkBox_2.setChecked(False)
self.progressBars = {}
for f in self.__getFiles(path):
try:
group = QGroupBox(f, self)
group.setGeometry(QRect(20, 20, 100, 150))
group.setCheckable(True)
group.setChecked(False)
group.setFixedSize(100, 150)
group.setFlat(True)
group.setToolTip(f)
label = QLabel(group)
label.setScaledContents(True)
label.setGeometry(QRect(5, 25, 90, 90))
label.setToolTip(f)
progressBar = QProgressBar(group)
progressBar.setGeometry(QRect(0, 70, 111, 10))
progressBar.setProperty("value", 0)
progressBar.setTextVisible(False)
progressBar.setToolTip('0%')
progressBar.setVisible(False)
self.progressBars[f] = progressBar
self.filesview.append(group)
from os.path import isfile
if isfile(path + '/' + f):
ext = f.split('.')[-1]
if isfile('icons/' + ext.lower() + '.png'):
label.setPixmap(
QPixmap('icons/' + ext.lower() + '.png'))
else:
label.setPixmap(QPixmap('icons/default.png'))
else:
label.setPixmap(QPixmap('icons/folder.png'))
self.connect(group, SIGNAL("clicked()"), self.__deselectFile)
except ValueError:
pass
i = 0
for x in list(range(len(self.filesview))):
if (x % 4) == 0:
i = i + 1
self.rowsview[i].addWidget(self.filesview[x])
def __selectAllFiles(self):
for o in self.filesview:
o.setChecked(self.checkBox_2.isChecked())
def __deselectFile(self):
#print 'deselect'
self.checkBox_2.setChecked(False)
def __arrozconpollo(self):
self.__obtainSelectedFIles()
def __obtainSelectedFIles(self):
files = []
for o in self.filesview:
if o.isChecked():
files.append(str(o.title()))
self.progressBars[str(o.title())].setVisible(True)
return files
def __getFiles(self, path):
from os import listdir
from os.path import isfile
f = []
for base in listdir(path):
try:
if isfile(path + '/' + base) and base.split('.')[-1] == 'cry':
f.append(base)
except ValueError:
pass
f.sort()
return f
def __eventInitDecryption(self):
if len(self.__obtainSelectedFIles()) == 0:
msg = QMessageBox()
msg.setIcon(QMessageBox.Critical)
msg.setText(
"Debes especificar los archivos que quieres desencriptar")
msg.setWindowTitle("Cryosystems")
msg.setStandardButtons(QMessageBox.Ok)
msg.exec_()
return
if str(self.lineEdit.text()).strip() == '':
msg = QMessageBox()
msg.setIcon(QMessageBox.Critical)
msg.setText("Debes especificar una clave")
msg.setWindowTitle("Cryosystems")
msg.setStandardButtons(QMessageBox.Ok)
msg.exec_()
return
self.okButton.setEnabled(False)
self.lineEdit.setEnabled(False)
index = self.treeView.currentIndex()
path = self.fileSystemModel.filePath(index)
selectedFiles = self.__obtainSelectedFIles()
from hashlib import md5
Hash = md5()
Hash.update(str(self.lineEdit.text()))
key = Hash.hexdigest()
errors = 0
from os.path import getsize
blockSize = 4096
for f in selectedFiles:
f_in = open(path + '/' + f, 'rb')
print path + '/' + f
header = ''
if (f_in.read(20) == ('CRYOGENESIS' + unhexlify('00') + 'ARCHIVE' +
unhexlify('01'))):
while (True):
c = f_in.read(1)
if c == unhexlify('02'):
break
else:
header = header + c
else:
print 'esto no es un archivo cifradodo de Cryogenesis Systems'
#print key
aes = AES(key)
#print aes.decrypt(header)
header_sections = aes.decrypt(header).split('|')
if header_sections[0] != 'header':
msg = QMessageBox()
msg.setIcon(QMessageBox.Critical)
msg.setText("La clave no es correcta para el archivo:" + f)
msg.setWindowTitle("Cryosystems")
msg.setStandardButtons(QMessageBox.Ok)
msg.exec_()
errors = errors + 1
continue
f_out = open(path + '/' + header_sections[1], 'wb')
techniques = header_sections[2].split(':')[:-1]
techniquesObjects = []
for t in techniques:
techniquesObjects.append(self.techniquesClass[t](key))
techniquesObjects.reverse()
in_size = getsize(path + '/' + f)
in_progress = 0.0
block = f_in.read(blockSize)
while (block):
block_p = block
for t in techniquesObjects:
block_p = t.decrypt(block_p)
f_out.write(block_p)
in_progress = in_progress + blockSize
progress = (in_progress / in_size) * 100
self.progressBars[str(f)].setProperty("value", int(progress))
self.progressBars[str(f)].setToolTip(str(progress) + '%')
block = f_in.read(blockSize)
f_in.close()
f_out.close()
if (checksum(path + '/' + header_sections[1]) !=
header_sections[3]):
msg = QMessageBox()
msg.setIcon(QMessageBox.Critical)
msg.setText("El archivo" + f + 'se ha corrompido')
msg.setWindowTitle("Cryosystems")
msg.setStandardButtons(QMessageBox.Ok)
msg.exec_()
errors = errors + 1
from os import remove
remove(header_sections[1])
msg = QMessageBox()
msg.setWindowTitle("Cryosystems")
msg.setStandardButtons(QMessageBox.Ok)
if (errors == 0):
msg.setIcon(QMessageBox.Information)
msg.setText("La desencriptacion ha concluido exitosamente")
else:
msg.setIcon(QMessageBox.Warning)
msg.setText("La desencriptacion ha concluido con " + str(errors) +
' error(es)')
msg.exec_()
self.hide()
class ExampleApp(QtGui.QMainWindow, main_form.Ui_MainWindow):
def __init__(self):
super(self.__class__, self).__init__()
self.setupUi(
self) # This is defined in design.py file automatically
# self.listWidget_Xoutput_files.addItem("deneme")
cleaner_files_path = os.path.join(str(QDir.currentPath()),
"cleaner_files")
if not os.path.exists(cleaner_files_path):
os.mkdir(cleaner_files_path)
self.model = QFileSystemModel()
self.model.setRootPath(cleaner_files_path)
self.model.setNameFilters(QStringList(["Xoutput-n_analyses-*.txt"
]))
self.model.setNameFilterDisables(False)
self.model.setFilter(QDir.Dirs | QDir.Files)
self.treeView_Xoutput_files.setModel(self.model)
self.treeView_Xoutput_files.setRootIndex(
self.model.index(cleaner_files_path))
self.treeView_Xoutput_files.setColumnWidth(0, 500)
self.treeView_Xoutput_files.selectionModel(
).selectionChanged.connect(self.load_and_view_file_contents)
self.rules_dict = {}
self.special_button_for_level_01.setDisabled(True)
def load_and_view_file_contents(self, current, previous):
print current.indexes()
model_index = current.indexes()[0]
filename = self.model.data(model_index).toString()
import re
m = re.match(r"Xoutput-n_analyses-([0-9]+)", filename)
if m:
n_analyzes = int(m.group(1))
else:
n_analyzes = -1
if n_analyzes == 1:
self.special_button_for_level_01.setDisabled(False)
self.special_button_for_level_01.clicked.connect(
self.add_all_level_01_to_rule_dict)
else:
self.special_button_for_level_01.setDisabled(True)
with codecs.open(filename, "r", encoding="utf8") as f:
lines = f.readlines()
# print lines
self.listWidget_selected_file_contents.clear()
self.listWidget_selected_file_contents.addItems(
QStringList(lines))
self.listWidget_selected_file_contents.selectionModel(
).selectionChanged.connect(
self.load_and_view_samples_from_train_and_dev)
self.load_and_view_rule_file_contents(n_analyzes)
def load_and_view_rule_file_contents(self, n_analyzes):
# load rules file
self.rules_dict = {}
rules_filename = "Xoutput-n_analyses-%02d.txt.rules" % n_analyzes
try:
with codecs.open(rules_filename, "r") as rules_f:
self.output_file_load_status.setText("%s loaded." %
rules_filename)
self.output_file_load_status.setStyleSheet(
"QLabel { color : green; }")
rules = []
line = rules_f.readline().strip()
while line:
rules.append(line.split(" "))
self.rules_dict[int(
line.split(" ")[0])] = line.split(" ")
line = rules_f.readline().strip()
self.update_tableWidgetxxxx(
self.tableWidget_output_file_contents,
sorted(self.rules_dict.items(), key=lambda x: x[0]),
len(self.rules_dict.keys()), 1 + 1 + n_analyzes +
1) # id + golden + FST analyzes + selected
except IOError as e:
# print "File not found"
self.output_file_load_status.setText("File not found")
self.output_file_load_status.setStyleSheet(
"QLabel { color : red; }")
self.update_tableWidgetxxxx(
self.tableWidget_output_file_contents, [], 0,
1) # id + golden + FST analyzes + selected
def update_tableWidgetxxxx(self, table_widget, rules, row_count,
col_count):
table_widget.clear()
table_widget.setColumnCount(col_count)
table_widget.setRowCount(row_count)
if rules:
for row in range(table_widget.rowCount()):
row_items = rules[row]
print row_items
item = self.listWidget_selected_file_contents.item(
int(row_items[0]) - 1) # type: QListWidgetItem
item.setBackgroundColor(QtGui.QColor(255, 0, 0, 127))
for column in range(table_widget.columnCount()):
if column < len(row_items[1]):
table_widget.setItem(
row, column,
QTableWidgetItem(
row_items[1][column].decode("utf8")))
# self.tableWidget_samples_from_train_and_dev.resizeColumnToContents()
for column in range(table_widget.columnCount()):
table_widget.resizeColumnToContents(column)
def update_corrected_morph_analysis(self, current, previous):
model_index = current.indexes()[0]
self.textEdit_2.setPlainText(
self.listWidget_selected_row.model().data(
model_index).toString())
def add_all_level_01_to_rule_dict(self):
self.rules_dict = {}
for idx in range(self.listWidget_selected_file_contents.count()):
row_items = unicode(
self.listWidget_selected_file_contents.item(
idx).text()).strip().split(" ")
rules_item = [
x.encode("utf8") for x in
[row_items[0], row_items[4], row_items[-1], row_items[-1]]
]
self.rules_dict[int(row_items[0])] = rules_item
self.update_tableWidgetxxxx(
self.tableWidget_output_file_contents,
sorted(self.rules_dict.items(), key=lambda x: x[0]),
len(self.rules_dict.keys()),
1 + 1 + 1 + 1) # id + golden + FST analyzes + selected
def add_to_the_rule_dict(self, state):
n_analyzes, entry_id = [
int(x) for x in self.label_8.text().split(" ")
]
other_analyzes = [
self.listWidget_selected_row.item(i)
for i in range(self.listWidget_selected_row.count())
] # type: list[QListWidgetItem]
rules_item = [unicode(x).encode("utf8") for x in [entry_id,
self.textEdit_golden_morph_analysis.toPlainText()] + \
[x.text() for x in other_analyzes] + \
[self.textEdit_2.toPlainText()]]
self.rules_dict[entry_id] = rules_item
self.update_tableWidgetxxxx(
self.tableWidget_output_file_contents,
sorted(self.rules_dict.items(), key=lambda x: x[0]),
len(self.rules_dict.keys()), 1 + 1 + n_analyzes +
1) # id + golden + FST analyzes + selected
def load_and_view_samples_from_train_and_dev(self, current, previous):
print current.indexes()
model_index = current.indexes()[0]
morph_analyzes = unicode(
self.listWidget_selected_file_contents.model().data(
model_index).toString()).strip().split(" ")
# print morph_analyzes
golden_morph_analysis = morph_analyzes[4]
target = golden_morph_analysis[1:]
other_morph_analyzes = morph_analyzes[5:]
n_analyzes = len(other_morph_analyzes)
self.label_3.setText("selected row id: %d" %
int(morph_analyzes[0]))
self.label_8.setText("%d %d" %
(int(n_analyzes), int(morph_analyzes[0])))
self.listWidget_selected_row.clear()
self.listWidget_selected_row.addItems(
QStringList(other_morph_analyzes))
self.textEdit_golden_morph_analysis.setPlainText(
golden_morph_analysis)
# self.addRuleToTheListButton.clicked.connect(
# partial(self.save_to_file, n_analyzes=n_analyzes, entry_id=int(morph_analyzes[0])))
# from functools import partial
self.addRuleToTheListButton.clicked.connect(
self.add_to_the_rule_dict)
if len(other_morph_analyzes) == 1:
self.textEdit_2.setPlainText(other_morph_analyzes[0])
self.listWidget_selected_row.selectionModel(
).selectionChanged.connect(self.update_corrected_morph_analysis)
print type(target)
print target
print target.encode("utf8")
# target = target.replace("?", "\?")
lines = subprocess.check_output(
("grep -F -m 50 %s ./dataset/errors.gungor.ner.train_and_dev" %
target).split(" "),
shell=False)
# print lines
lines = [x.decode("utf8") for x in lines.split("\n")]
print type(lines[0])
print len(lines)
self.tableWidget_samples_from_train_and_dev.clear()
self.tableWidget_samples_from_train_and_dev.setColumnCount(
n_analyzes + 1)
self.tableWidget_samples_from_train_and_dev.setRowCount(
len(lines) - 1)
for row in range(
self.tableWidget_samples_from_train_and_dev.rowCount()):
row_items = lines[row].split(" ")[2:]
for column in range(
self.tableWidget_samples_from_train_and_dev.
columnCount()):
if column < len(row_items):
self.tableWidget_samples_from_train_and_dev.setItem(
row, column, QTableWidgetItem(row_items[column]))
# self.tableWidget_samples_from_train_and_dev.resizeColumnToContents()
for column in range(
self.tableWidget_samples_from_train_and_dev.columnCount()):
self.tableWidget_samples_from_train_and_dev.resizeColumnToContents(
column)
self.sort_and_save_button.clicked.connect(self.sort_and_save)
def sort_and_save(self):
indexes = self.treeView_Xoutput_files.selectedIndexes()
model_index = indexes[0]
filename = self.model.data(model_index).toString()
with open(filename + ".rules", "w") as f:
for row in range(
self.tableWidget_output_file_contents.rowCount()):
row_content = []
for column in range(self.tableWidget_output_file_contents.
columnCount()):
cell_content = self.tableWidget_output_file_contents.item(
row, column).text() # type: QString
if cell_content:
row_content.append(
unicode(cell_content).encode("utf8"))
if row != 0:
f.write("\n")
f.write(" ".join(row_content))
class EncryptDialog(QDialog):
def __init__(self):
self.techniquesClass = {
'caesar cipher': caesarCipher,
'mono alphabetic cipher': monoAlphabeticCipher,
'vigenere cipher': vigenereCipher,
'vernan cipher': vernanCipher,
'one time pad': oneTimePad
}
self.rowsview = []
self.filesview = []
self.techniques = []
QDialog.__init__(self)
self.setWindowTitle("CryptoSystems")
self.resize(1024, 600)
self.setMinimumSize(QSize(1024, 600))
self.setMaximumSize(QSize(1024, 600))
self.checkBox_2 = QCheckBox(self)
self.checkBox_2.setGeometry(QRect(620, 10, 130, 20))
self.checkBox_2.setText('Select All')
self.checkBox_2.clicked.connect(self.__selectAllFiles)
self.treeView = QTreeView(self)
self.treeView.setGeometry(QRect(10, 10, 230, 580))
self.treeView.setObjectName("treeView")
self.fileSystemModel = QFileSystemModel(self.treeView)
self.fileSystemModel.setReadOnly(False)
self.fileSystemModel.setFilter(QDir.AllDirs | QDir.NoDotAndDotDot)
root = self.fileSystemModel.setRootPath("/")
self.treeView.setModel(self.fileSystemModel)
self.treeView.setRootIndex(root)
self.treeView.hideColumn(1)
self.treeView.hideColumn(2)
self.treeView.hideColumn(3)
self.treeView.clicked.connect(self.__eventDirectoryChanged)
self.mygroupbox = QGroupBox(self)
self.mygroupbox.setGeometry(QRect(0, 0, 1000, 1000))
self.myform = QFormLayout()
for j in list(range(100)):
horizontalLayout = QHBoxLayout()
self.myform.addRow(horizontalLayout)
self.rowsview.append(horizontalLayout)
self.mygroupbox.setLayout(self.myform)
scroll = QScrollArea(self)
scroll.setWidget(self.mygroupbox)
scroll.setWidgetResizable(True)
scroll.setGeometry(QRect(250, 30, 500, 580))
scroll.setWidgetResizable(True)
self.label_4 = QLabel(self)
self.label_4.setGeometry(QRect(780, 30, 31, 16))
self.label_4.setPixmap(QPixmap("images/key.png"))
self.label_4.setScaledContents(True)
self.lineEdit = QLineEdit(self)
self.lineEdit.setGeometry(QRect(820, 30, 180, 20))
self.lineEdit.setObjectName("lineEdit")
self.lineEdit.setPlaceholderText(_fromUtf8('write your password'))
self.lineEdit.setEchoMode(QLineEdit.Password)
self.techniquesGroup = QGroupBox(self)
self.tecniquesform = QFormLayout()
self.techniquesGroup.setLayout(self.tecniquesform)
self.techniquesScroll = QScrollArea(self)
self.techniquesScroll.setGeometry(QRect(770, 100, 230, 300))
self.techniquesScroll.setWidget(self.techniquesGroup)
self.techniquesScroll.setWidgetResizable(True)
self.rowsTechiques = []
for i in list(range(8)):
horizontalLayout = QHBoxLayout()
self.tecniquesform.addRow(horizontalLayout)
self.rowsTechiques.append(horizontalLayout)
techniquesCombo = QComboBox()
techniquesCombo.setGeometry(QRect(10, 50, 171, 22))
techniquesCombo.addItems(self.techniquesClass.keys())
self.techniques.append(techniquesCombo)
self.rowsTechiques[0].addWidget(techniquesCombo)
self.techniquesNumber = 1
self.addTechnique = QPushButton()
self.addTechnique.setGeometry(QRect(90, 90, 31, 21))
self.addTechnique.setFixedSize(31, 21)
self.addTechnique.setText('+')
self.connect(self.addTechnique, SIGNAL("clicked()"),
self.__eventAddTechnique)
self.rowsTechiques[len(self.rowsTechiques) - 1].addWidget(
self.addTechnique)
self.okButton = QPushButton(self)
self.okButton.setGeometry(QRect(920, 560, 80, 20))
self.okButton.setText('Start...')
self.connect(self.okButton, SIGNAL("clicked()"),
self.__eventInitEncryption)
def __eventAddTechnique(self):
techniquesCombo = QComboBox()
techniquesCombo.setGeometry(QRect(10, 50, 171, 22))
techniquesCombo.addItems(self.techniquesClass.keys())
self.techniques.append(techniquesCombo)
self.rowsTechiques[self.techniquesNumber].addWidget(techniquesCombo)
self.techniquesNumber = self.techniquesNumber + 1
if ((len(self.rowsTechiques) - 1) == self.techniquesNumber):
self.addTechnique.setEnabled(False)
def __eventDirectoryChanged(self):
index = self.treeView.currentIndex()
self.__changeDirectory(self.fileSystemModel.filePath(index))
def __changeDirectory(self, path):
for c in self.filesview:
c.setParent(None)
c.deleteLater()
self.filesview = []
self.checkBox_2.setChecked(False)
self.progressBars = {}
for f in self.__getFiles(path):
try:
group = QGroupBox(f, self)
group.setGeometry(QRect(20, 20, 100, 150))
group.setCheckable(True)
group.setChecked(False)
group.setFixedSize(100, 150)
group.setFlat(True)
group.setToolTip(f)
label = QLabel(group)
label.setScaledContents(True)
label.setGeometry(QRect(5, 25, 90, 90))
label.setToolTip(f)
progressBar = QProgressBar(group)
progressBar.setGeometry(QRect(0, 70, 111, 10))
progressBar.setProperty("value", 0)
progressBar.setTextVisible(False)
progressBar.setToolTip('0%')
progressBar.setVisible(False)
self.progressBars[f] = progressBar
self.filesview.append(group)
from os.path import isfile
if isfile(path + '/' + f):
ext = f.split('.')[-1]
if isfile('icons/' + ext.lower() + '.png'):
label.setPixmap(
QPixmap('icons/' + ext.lower() + '.png'))
else:
label.setPixmap(QPixmap('icons/default.png'))
else:
label.setPixmap(QPixmap('icons/folder.png'))
self.connect(group, SIGNAL("clicked()"), self.__deselectFile)
except ValueError:
pass
i = 0
for x in list(range(len(self.filesview))):
if (x % 4) == 0:
i = i + 1
self.rowsview[i].addWidget(self.filesview[x])
def __selectAllFiles(self):
for o in self.filesview:
o.setChecked(self.checkBox_2.isChecked())
def __deselectFile(self):
#print 'deselect'
self.checkBox_2.setChecked(False)
def __arrozconpollo(self):
self.__obtainSelectedFIles()
def __obtainSelectedFIles(self):
files = []
for o in self.filesview:
if o.isChecked():
files.append(str(o.title()))
self.progressBars[str(o.title())].setVisible(True)
return files
def __getFiles(self, path):
from os import listdir
from os.path import isfile
f = []
for base in listdir(path):
try:
if isfile(path + '/' + base):
f.append(base)
except ValueError:
pass
f.sort()
return f
def __eventInitEncryption(self):
if len(self.__obtainSelectedFIles()) == 0:
msg = QMessageBox()
msg.setIcon(QMessageBox.Critical)
msg.setText("You must specify the files you want to encrypt")
msg.setWindowTitle("CryptoSystems")
msg.setStandardButtons(QMessageBox.Ok)
msg.exec_()
return
if str(self.lineEdit.text()).strip() == '':
msg = QMessageBox()
msg.setIcon(QMessageBox.Critical)
msg.setText("You must specify a key")
msg.setWindowTitle("CryptoSystems")
msg.setStandardButtons(QMessageBox.Ok)
msg.exec_()
return
self.okButton.setEnabled(False)
self.techniquesGroup.setEnabled(False)
self.lineEdit.setEnabled(False)
index = self.treeView.currentIndex()
path = self.fileSystemModel.filePath(index)
selectedFiles = self.__obtainSelectedFIles()
from os.path import getsize
blockSize = 4096
from hashlib import md5
Hash = md5()
Hash.update(str(self.lineEdit.text()))
key = Hash.hexdigest()
for f in selectedFiles:
f_in = open(path + '/' + f, 'rb')
f_out = open(
path + '/' + reduceMd5(checksum(path + '/' + f)) + '.cry',
'wb')
f_out.write('CRYOGENESIS' + unhexlify('00') + 'ARCHIVE' +
unhexlify('01'))
header_list = ''
techniquesObjects = []
for t in self.techniques:
header_list = header_list + t.currentText() + ':'
techniquesObjects.append(self.techniquesClass[str(
t.currentText())](key))
file_header = str('header|' + str(f_in.name.split('/')[-1]) + '|' +
str(header_list) + '|' +
str(checksum(path + '/' + f)))
aes = AES(key)
f_out.write(aes.encrypt(file_header))
f_out.write(unhexlify('02'))
in_size = getsize(path + '/' + f)
in_progress = 0.0
block = f_in.read(blockSize)
while (block):
block_c = block
for t in techniquesObjects:
block_c = t.encrypt(block_c)
f_out.write(block_c)
in_progress = in_progress + blockSize
progress = (in_progress / in_size) * 100
#print progress
self.progressBars[str(f)].setProperty("value", int(progress))
self.progressBars[str(f)].setToolTip(str(progress) + '%')
block = f_in.read(blockSize)
f_in.close()
f_out.close()
msg = QMessageBox()
msg.setIcon(QMessageBox.Information)
msg.setText("Encryption has successfully concluded")
msg.setWindowTitle("CryptoSystems")
msg.setStandardButtons(QMessageBox.Ok)
msg.exec_()
self.hide()
class DirView(QTreeView):
"""Base file/directory tree view"""
def __init__(self, parent=None):
super(DirView, self).__init__(parent)
self.name_filters = None
self.parent_widget = parent
self.valid_types = None
self.show_all = None
self.menu = None
self.common_actions = None
self.__expanded_state = None
self._to_be_loaded = None
self.fsmodel = None
self.setup_fs_model()
self._scrollbar_positions = None
#---- Model
def setup_fs_model(self):
"""Setup filesystem model"""
filters = QDir.AllDirs | QDir.Files | QDir.Drives | QDir.NoDotAndDotDot
self.fsmodel = QFileSystemModel(self)
self.fsmodel.setFilter(filters)
self.fsmodel.setNameFilterDisables(False)
def install_model(self):
"""Install filesystem model"""
self.setModel(self.fsmodel)
def setup_view(self):
"""Setup view"""
self.install_model()
self.connect(self.fsmodel, SIGNAL('directoryLoaded(QString)'),
lambda: self.resizeColumnToContents(0))
self.setAnimated(False)
self.setSortingEnabled(True)
self.sortByColumn(0, Qt.AscendingOrder)
def set_name_filters(self, name_filters):
"""Set name filters"""
self.name_filters = name_filters
self.fsmodel.setNameFilters(name_filters)
def set_show_all(self, state):
"""Toggle 'show all files' state"""
if state:
self.fsmodel.setNameFilters([])
else:
self.fsmodel.setNameFilters(self.name_filters)
def get_filename(self, index):
"""Return filename associated with *index*"""
if index:
return osp.normpath(unicode(self.fsmodel.filePath(index)))
def get_index(self, filename):
"""Return index associated with filename"""
return self.fsmodel.index(filename)
def get_selected_filenames(self):
"""Return selected filenames"""
if self.selectionMode() == self.ExtendedSelection:
return [self.get_filename(idx) for idx in self.selectedIndexes()]
else:
return [self.get_filename(self.currentIndex())]
def get_dirname(self, index):
"""Return dirname associated with *index*"""
fname = self.get_filename(index)
if fname:
if osp.isdir(fname):
return fname
else:
return osp.dirname(fname)
#---- Tree view widget
def setup(self,
name_filters=['*.py', '*.pyw'],
valid_types=('.py', '.pyw'),
show_all=False):
"""Setup tree widget"""
self.setup_view()
self.set_name_filters(name_filters)
self.valid_types = valid_types
self.show_all = show_all
# Setup context menu
self.menu = QMenu(self)
self.common_actions = self.setup_common_actions()
#---- Context menu
def setup_common_actions(self):
"""Setup context menu common actions"""
# Filters
filters_action = create_action(self,
_("Edit filename filters..."),
None,
get_icon('filter.png'),
triggered=self.edit_filter)
# Show all files
all_action = create_action(self,
_("Show all files"),
toggled=self.toggle_all)
all_action.setChecked(self.show_all)
self.toggle_all(self.show_all)
return [filters_action, all_action]
def edit_filter(self):
"""Edit name filters"""
filters, valid = QInputDialog.getText(self, _('Edit filename filters'),
_('Name filters:'),
QLineEdit.Normal,
", ".join(self.name_filters))
if valid:
filters = [f.strip() for f in unicode(filters).split(',')]
self.parent_widget.sig_option_changed.emit('name_filters', filters)
self.set_name_filters(filters)
def toggle_all(self, checked):
"""Toggle all files mode"""
self.parent_widget.sig_option_changed.emit('show_all', checked)
self.show_all = checked
self.set_show_all(checked)
def create_file_new_actions(self, fnames):
"""Return actions for submenu 'New...'"""
if not fnames:
return []
new_file_act = create_action(
self,
_("File..."),
icon='filenew.png',
triggered=lambda: self.new_file(fnames[-1]))
new_module_act = create_action(
self,
_("Module..."),
icon='py.png',
triggered=lambda: self.new_module(fnames[-1]))
new_folder_act = create_action(
self,
_("Folder..."),
icon='folder_new.png',
triggered=lambda: self.new_folder(fnames[-1]))
new_package_act = create_action(
self,
_("Package..."),
icon=get_icon('package_collapsed.png'),
triggered=lambda: self.new_package(fnames[-1]))
return [
new_file_act, new_folder_act, None, new_module_act, new_package_act
]
def create_file_import_actions(self, fnames):
"""Return actions for submenu 'Import...'"""
return []
def create_file_manage_actions(self, fnames):
"""Return file management actions"""
only_files = all([osp.isfile(_fn) for _fn in fnames])
only_modules = all([
osp.splitext(_fn)[1] in ('.py', '.pyw', '.ipy') for _fn in fnames
])
only_valid = all(
[osp.splitext(_fn)[1] in self.valid_types for _fn in fnames])
run_action = create_action(self,
_("Run"),
icon="run_small.png",
triggered=self.run)
edit_action = create_action(self,
_("Edit"),
icon="edit.png",
triggered=self.clicked)
move_action = create_action(self,
_("Move..."),
icon="move.png",
triggered=self.move)
delete_action = create_action(self,
_("Delete..."),
icon="delete.png",
triggered=self.delete)
rename_action = create_action(self,
_("Rename..."),
icon="rename.png",
triggered=self.rename)
open_action = create_action(self, _("Open"), triggered=self.open)
actions = []
if only_modules:
actions.append(run_action)
if only_valid and only_files:
actions.append(edit_action)
else:
actions.append(open_action)
actions += [delete_action, rename_action]
basedir = fixpath(osp.dirname(fnames[0]))
if all([fixpath(osp.dirname(_fn)) == basedir for _fn in fnames]):
actions.append(move_action)
actions += [None]
# VCS support is quite limited for now, so we are enabling the VCS
# related actions only when a single file/folder is selected:
dirname = fnames[0] if osp.isdir(fnames[0]) else osp.dirname(fnames[0])
if len(fnames) == 1 and vcs.is_vcs_repository(dirname):
vcs_ci = create_action(self,
_("Commit"),
icon="vcs_commit.png",
triggered=lambda fnames=[dirname]: self.
vcs_command(fnames, tool='commit'))
vcs_log = create_action(self,
_("Browse repository"),
icon="vcs_browse.png",
triggered=lambda fnames=[dirname]: self.
vcs_command(fnames, tool='browse'))
actions += [None, vcs_ci, vcs_log]
return actions
def create_folder_manage_actions(self, fnames):
"""Return folder management actions"""
actions = []
if os.name == 'nt':
_title = _("Open command prompt here")
else:
_title = _("Open terminal here")
action = create_action(
self,
_title,
icon="cmdprompt.png",
triggered=lambda fnames=fnames: self.open_terminal(fnames))
actions.append(action)
_title = _("Open Python interpreter here")
action = create_action(
self,
_title,
icon="python.png",
triggered=lambda fnames=fnames: self.open_interpreter(fnames))
actions.append(action)
return actions
def create_context_menu_actions(self):
"""Create context menu actions"""
actions = []
fnames = self.get_selected_filenames()
new_actions = self.create_file_new_actions(fnames)
if len(new_actions) > 1:
# Creating a submenu only if there is more than one entry
new_act_menu = QMenu(_('New'), self)
add_actions(new_act_menu, new_actions)
actions.append(new_act_menu)
else:
actions += new_actions
import_actions = self.create_file_import_actions(fnames)
if len(import_actions) > 1:
# Creating a submenu only if there is more than one entry
import_act_menu = QMenu(_('Import'), self)
add_actions(import_act_menu, import_actions)
actions.append(import_act_menu)
else:
actions += import_actions
if actions:
actions.append(None)
if fnames:
actions += self.create_file_manage_actions(fnames)
if actions:
actions.append(None)
if fnames and all([osp.isdir(_fn) for _fn in fnames]):
actions += self.create_folder_manage_actions(fnames)
if actions:
actions.append(None)
actions += self.common_actions
return actions
def update_menu(self):
"""Update context menu"""
self.menu.clear()
add_actions(self.menu, self.create_context_menu_actions())
#---- Events
def viewportEvent(self, event):
"""Reimplement Qt method"""
# Prevent Qt from crashing or showing warnings like:
# "QSortFilterProxyModel: index from wrong model passed to
# mapFromSource", probably due to the fact that the file system model
# is being built. See Issue 1250.
#
# This workaround was inspired by the following KDE bug:
# https://bugs.kde.org/show_bug.cgi?id=172198
#
# Apparently, this is a bug from Qt itself.
self.executeDelayedItemsLayout()
return QTreeView.viewportEvent(self, event)
def contextMenuEvent(self, event):
"""Override Qt method"""
self.update_menu()
self.menu.popup(event.globalPos())
def keyPressEvent(self, event):
"""Reimplement Qt method"""
if event.key() in (Qt.Key_Enter, Qt.Key_Return):
self.clicked()
elif event.key() == Qt.Key_F2:
self.rename()
elif event.key() == Qt.Key_Delete:
self.delete()
else:
QTreeView.keyPressEvent(self, event)
def mouseDoubleClickEvent(self, event):
"""Reimplement Qt method"""
QTreeView.mouseDoubleClickEvent(self, event)
self.clicked()
def clicked(self):
"""Selected item was double-clicked or enter/return was pressed"""
fnames = self.get_selected_filenames()
for fname in fnames:
if osp.isdir(fname):
self.directory_clicked(fname)
else:
self.open([fname])
def directory_clicked(self, dirname):
"""Directory was just clicked"""
pass
#---- Drag
def dragEnterEvent(self, event):
"""Drag and Drop - Enter event"""
event.setAccepted(event.mimeData().hasFormat("text/plain"))
def dragMoveEvent(self, event):
"""Drag and Drop - Move event"""
if (event.mimeData().hasFormat("text/plain")):
event.setDropAction(Qt.MoveAction)
event.accept()
else:
event.ignore()
def startDrag(self, dropActions):
"""Reimplement Qt Method - handle drag event"""
data = QMimeData()
data.setUrls([QUrl(fname) for fname in self.get_selected_filenames()])
drag = QDrag(self)
drag.setMimeData(data)
drag.exec_()
#---- File/Directory actions
def open(self, fnames=None):
"""Open files with the appropriate application"""
if fnames is None:
fnames = self.get_selected_filenames()
for fname in fnames:
ext = osp.splitext(fname)[1]
if osp.isfile(fname) and ext in self.valid_types:
self.parent_widget.sig_open_file.emit(fname)
else:
self.open_outside_spyder([fname])
def open_outside_spyder(self, fnames):
"""Open file outside Spyder with the appropriate application
If this does not work, opening unknown file in Spyder, as text file"""
for path in sorted(fnames):
path = file_uri(path)
ok = programs.start_file(path)
if not ok:
self.parent_widget.emit(SIGNAL("edit(QString)"), path)
def open_terminal(self, fnames):
"""Open terminal"""
for path in sorted(fnames):
self.parent_widget.emit(SIGNAL("open_terminal(QString)"), path)
def open_interpreter(self, fnames):
"""Open interpreter"""
for path in sorted(fnames):
self.parent_widget.emit(SIGNAL("open_interpreter(QString)"), path)
def run(self, fnames=None):
"""Run Python scripts"""
if fnames is None:
fnames = self.get_selected_filenames()
for fname in fnames:
self.parent_widget.emit(SIGNAL("run(QString)"), fname)
def remove_tree(self, dirname):
"""Remove whole directory tree
Reimplemented in project explorer widget"""
shutil.rmtree(dirname, onerror=misc.onerror)
def delete_file(self, fname, multiple, yes_to_all):
"""Delete file"""
if multiple:
buttons = QMessageBox.Yes|QMessageBox.YesAll| \
QMessageBox.No|QMessageBox.Cancel
else:
buttons = QMessageBox.Yes | QMessageBox.No
if yes_to_all is None:
answer = QMessageBox.warning(
self, _("Delete"),
_("Do you really want "
"to delete <b>%s</b>?") % osp.basename(fname), buttons)
if answer == QMessageBox.No:
return yes_to_all
elif answer == QMessageBox.Cancel:
return False
elif answer == QMessageBox.YesAll:
yes_to_all = True
try:
if osp.isfile(fname):
misc.remove_file(fname)
self.parent_widget.emit(SIGNAL("removed(QString)"), fname)
else:
self.remove_tree(fname)
self.parent_widget.emit(SIGNAL("removed_tree(QString)"), fname)
return yes_to_all
except EnvironmentError, error:
action_str = _('delete')
QMessageBox.critical(
self, _("Project Explorer"),
_("<b>Unable to %s <i>%s</i></b>"
"<br><br>Error message:<br>%s") %
(action_str, fname, unicode(error)))
return False
class DirectoryWidget(RWidget):
def __init__(self, parent, base="."):
RWidget.__init__(self, parent)
self.base = base
self.model = QFileSystemModel()
self.model.setRootPath(QDir.rootPath())
self.proxyModel = FileSystemProxyModel()
self.proxyModel.setDynamicSortFilter(True)
self.proxyModel.setFilterKeyColumn(0)
self.proxyModel.setSourceModel(self.model)
self.listView = QListView(self)
self.listView.setModel(self.proxyModel)
index = self.model.index(QDir.currentPath())
self.listView.setRootIndex(self.proxyModel.mapFromSource(index))
self.listView.setContextMenuPolicy(Qt.CustomContextMenu)
self.lineEdit = QLineEdit(self)
filterLineEdit = QLineEdit()
filterLabel = QLabel("Filter:")
self.connect(filterLineEdit, SIGNAL("textChanged(QString)"),
self.proxyModel.setFilterWildcard)
self.actions = []
self.upAction = QAction("&Up", self)
self.upAction.setStatusTip("Move to parent directory")
self.upAction.setToolTip("Move to parent directory")
self.upAction.setIcon(QIcon(":go-up"))
self.upAction.setEnabled(True)
self.actions.append(self.upAction)
self.newAction = QAction("&New Directory", self)
self.newAction.setStatusTip("Create new directory")
self.newAction.setToolTip("Create new directory")
self.newAction.setIcon(QIcon(":folder-new"))
self.newAction.setEnabled(True)
self.actions.append(self.newAction)
self.synchAction = QAction("&Synch", self)
self.synchAction.setStatusTip("Synch with current working directory")
self.synchAction.setToolTip("Synch with current working directory")
self.synchAction.setIcon(QIcon(":view-refresh"))
self.synchAction.setEnabled(True)
self.actions.append(self.synchAction)
self.rmAction = QAction("&Delete", self)
self.rmAction.setStatusTip("Delete selected item")
self.rmAction.setToolTip("delete selected item")
self.rmAction.setIcon(QIcon(":edit-delete"))
self.rmAction.setEnabled(True)
self.actions.append(self.rmAction)
self.openAction = QAction("&Open", self)
self.openAction.setStatusTip("Open selected R script")
self.openAction.setToolTip("Open selected R script")
self.openAction.setIcon(QIcon(":document-open"))
self.openAction.setEnabled(True)
self.actions.append(self.openAction)
self.loadAction = QAction("&Load", self)
self.loadAction.setStatusTip("Load selected R data")
self.loadAction.setToolTip("Load selected R data")
self.loadAction.setIcon(QIcon(":document-open"))
self.loadAction.setEnabled(True)
self.actions.append(self.loadAction)
self.setAction = QAction("Set as ¤t", self)
self.setAction.setStatusTip("Set folder as R working directory")
self.setAction.setToolTip("Set folder as R working directory")
self.setAction.setIcon(QIcon(":folder-home"))
self.setAction.setEnabled(True)
self.actions.append(self.setAction)
self.loadExternal = QAction("Open &Externally", self)
self.loadExternal.setStatusTip("Load file in external application")
self.loadExternal.setToolTip("Load file in external application")
self.loadExternal.setIcon(QIcon(":folder-system"))
self.loadExternal.setEnabled(True)
self.actions.append(self.loadExternal)
self.rootChanged()
hiddenAction = QAction("Toggle hidden files", self)
hiddenAction.setStatusTip("Show/hide hidden files and folders")
hiddenAction.setToolTip("Show/hide hidden files and folders")
hiddenAction.setIcon(QIcon(":stock_keyring"))
hiddenAction.setCheckable(True)
self.connect(self.newAction, SIGNAL("triggered()"), self.newFolder)
self.connect(self.upAction, SIGNAL("triggered()"), self.upFolder)
self.connect(self.synchAction, SIGNAL("triggered()"), self.synchFolder)
self.connect(self.rmAction, SIGNAL("triggered()"), self.rmItem)
self.connect(self.openAction, SIGNAL("triggered()"), self.openItem)
self.connect(self.loadAction, SIGNAL("triggered()"), self.loadItem)
self.connect(self.loadExternal, SIGNAL("triggered()"), self.externalItem)
self.connect(self.setAction, SIGNAL("triggered()"), self.setFolder)
self.connect(hiddenAction, SIGNAL("toggled(bool)"), self.toggleHidden)
self.connect(self.listView, SIGNAL("activated(QModelIndex)"), self.cdFolder)
self.connect(self.listView, SIGNAL("customContextMenuRequested(QPoint)"), self.customContext)
self.connect(self.lineEdit, SIGNAL("returnPressed()"), self.gotoFolder)
upButton = QToolButton()
upButton.setDefaultAction(self.upAction)
upButton.setAutoRaise(True)
newButton = QToolButton()
newButton.setDefaultAction(self.newAction)
newButton.setAutoRaise(True)
synchButton = QToolButton()
synchButton.setDefaultAction(self.synchAction)
synchButton.setAutoRaise(True)
setButton = QToolButton()
setButton.setDefaultAction(self.setAction)
setButton.setAutoRaise(True)
hiddenButton = QToolButton()
hiddenButton.setDefaultAction(hiddenAction)
hiddenButton.setAutoRaise(True)
hbox = QHBoxLayout()
hbox.addWidget(upButton)
hbox.addWidget(synchButton)
hbox.addWidget(newButton)
hbox.addWidget(setButton)
hbox.addWidget(hiddenButton)
vbox = QVBoxLayout(self)
vbox.addLayout(hbox)
vbox.addWidget(self.lineEdit)
vbox.addWidget(self.listView)
vbox.addWidget(filterLabel)
vbox.addWidget(filterLineEdit)
def toggleHidden(self, toggled):
base = QDir.AllDirs|QDir.AllEntries|QDir.NoDotAndDotDot
if toggled:
self.model.setFilter(base|QDir.Hidden)
else:
self.model.setFilter(base)
def gotoFolder(self):
text = self.lineEdit.text()
self.listView.setRootIndex(self.proxyModel.mapFromSource(self.model.index(text, 0)))
def rootChanged(self):
index1 = self.listView.rootIndex()
index2 = self.proxyModel.mapToSource(index1)
self.lineEdit.setText(self.model.filePath(index2))
self.listView.setCurrentIndex(index1)
def customContext(self, pos):
index = self.listView.indexAt(pos)
index = self.proxyModel.mapToSource(index)
if not index.isValid():
self.rmAction.setEnabled(False)
self.openAction.setEnabled(False)
self.loadAction.setEnabled(False)
elif not self.model.isDir(index):
info = self.model.fileInfo(index)
suffix = info.suffix()
if suffix in ("Rd","Rdata","RData"):
self.loadAction.setEnabled(True)
self.openAction.setEnabled(False)
self.loadExternal.setEnabled(False)
elif suffix in ("txt","csv","R","r"):
self.openAction.setEnabled(True)
self.loadAction.setEnabled(False)
self.loadExternal.setEnabled(True)
else:
self.loadAction.setEnabled(False)
self.openAction.setEnabled(False)
self.loadExternal.setEnabled(True)
menu = QMenu(self)
for action in self.actions:
menu.addAction(action)
menu.exec_(self.listView.mapToGlobal(pos))
def openItem(self):
index = self.listView.currentIndex()
index = self.proxyModel.mapToSource(index)
self.emit(SIGNAL("openFileRequest(QString)"),
self.model.filePath(index))
def loadItem(self):
index = self.listView.currentIndex()
index = self.proxyModel.mapToSource(index)
self.emit(SIGNAL("loadFileRequest(QString)"),
self.model.filePath(index))
def externalItem(self):
index = self.listView.currentIndex()
index = self.proxyModel.mapToSource(index)
QDesktopServices.openUrl(QUrl(self.model.filePath(index)))
def newFolder(self):
text, ok = QInputDialog.getText(self,
"New Folder", "Folder name:", QLineEdit.Normal,
"new_folder")
if ok:
index = self.listView.rootIndex()
index = self.proxyModel.mapToSource(index)
self.model.mkdir(index, text)
def setFolder(self):
index = self.listView.currentIndex()
index = self.proxyModel.mapToSource(index)
commands = "setwd('%s')" % self.model.filePath(index)
self.emitCommands(commands)
def rmItem(self):
index = self.listView.currentIndex()
if index == self.listView.rootIndex():
return
yes = QMessageBox.question(self, "manageR Warning",
"Are you sure you want to delete '%s'?" % self.model.fileName(index),
QMessageBox.Yes|QMessageBox.Cancel)
if not yes == QMessageBox.Yes:
return
index = self.proxyModel.mapToSource(index)
if self.model.isDir(index):
result = self.model.rmdir(index)
else:
result = self.model.remove(index)
if not result:
QMessageBox.warning(self, "manageR Error",
"Unable to delete %s!" % self.model.fileName(index))
def upFolder(self):
index = self.listView.rootIndex()
index = self.proxyModel.parent(index)
self.listView.setRootIndex(index)
self.rootChanged()
def cdFolder(self):
indexes = self.listView.selectedIndexes()
if len(indexes) < 1:
return
index = indexes[0]
if self.model.isDir(self.proxyModel.mapToSource(index)):
self.listView.setRootIndex(index)
self.rootChanged()
self.listView.clearSelection()
def synchFolder(self):
text = robjects.r.getwd()[0]
index = self.model.index(text, 0)
index = self.proxyModel.mapFromSource(index)
self.listView.setRootIndex(index)
self.rootChanged()
class MainWindow(QWidget):
'''
The initial method creates the window and connects the rename method.
'''
def __init__(self):
QWidget.__init__(self)
self.setWindowTitle("cuteRenamer")
#Set Data-Model for showing the directories
self.dirModel = QFileSystemModel()
self.dirModel.setRootPath('/')
self.dirModel.setFilter(QDir.AllDirs | QDir.NoDotAndDotDot)#Show only directories without '.' and '..'
#Set the view for the directories
self.dirView = QTreeView()
self.dirView.setModel(self.dirModel)
#Show only the directories in the view
self.dirView.setColumnHidden(1, True)
self.dirView.setColumnHidden(2, True)
self.dirView.setColumnHidden(3, True)
self.dirView.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
#Listedit for the optional listfile
listPathLabel = QLabel("Path to list:")
self.listPathEdit = QLineEdit()
#Start renaming with number...
startLabel = QLabel("Start (default is 1)")
self.startEdit = QLineEdit()
#LineEdit for the prefix
prefixLabel = QLabel("Prefix")
self.prefixEdit = QLineEdit()
#LineEdit for the postfix
postfixLabel = QLabel("Postfix")
self.postfixEdit = QLineEdit()
#Checkbox to conserve file extensions
self.checkboxConserve = QCheckBox("Conserve file extensions")
checkboxLayout = QHBoxLayout()
checkboxLayout.addStretch(1)
checkboxLayout.addWidget(self.checkboxConserve)
#The button to start renaming
renameButton = QPushButton('Rename!')
buttonsLayout = QHBoxLayout()
buttonsLayout.addStretch(1)
buttonsLayout.addWidget(renameButton)
vertical = QVBoxLayout()
vertical.addWidget(self.dirView)
vertical.addSpacing(10)
vertical.addWidget(listPathLabel)
vertical.addWidget(self.listPathEdit)
vertical.addSpacing(10)
vertical.addWidget(startLabel)
vertical.addWidget(self.startEdit)
vertical.addSpacing(10)
vertical.addWidget(prefixLabel)
vertical.addWidget(self.prefixEdit)
vertical.addSpacing(10)
vertical.addWidget(postfixLabel)
vertical.addWidget(self.postfixEdit)
vertical.addSpacing(10)
vertical.addLayout(checkboxLayout)
vertical.addSpacing(20)
vertical.addLayout(buttonsLayout)
self.setLayout(vertical)
#If the button is clicked start the renaming
self.connect(renameButton, SIGNAL('clicked()'), self.rename)
'''
This method prepares all options and starts the rename progress.
'''
def rename(self):
selectedIndex = self.dirView.selectedIndexes()
if self.listPathEdit.text() == "":
print "Read the whole directory"
files = os.listdir(self.dirModel.filePath(selectedIndex[0]))
elif (not self.listPathEdit.text() == "") and os.path.isfile(self.listPathEdit.text()):
print "Read filenames from %s" % self.listPathEdit.text()
files = [i.rstrip('\n') for i in open(self.listPathEdit.text(), "r")]
else:
print "Path to list doesn't exist or is not a file!"
if not self.startEdit.text() == "":
start = int(self.startEdit.text())
else:
start = 1
prefix = self.prefixEdit.text()
postfix = self.postfixEdit.text()
if self.checkboxConserve.isChecked():
conserve = True
else:
conserve = False
print "Start: %d\nPrefix: %s\nPostfix: %s\nConserve: %s" % (start, prefix, postfix, conserve)
print "Change directory"
os.chdir(self.dirModel.filePath(selectedIndex[0]))
rename_files(start, prefix, postfix, conserve, files)
'''
A simple close event.
'''
def closeEvent(self, event):
print "Quit application"
exit()
class DirView(QTreeView):
"""Base file/directory tree view"""
def __init__(self, parent=None):
super(DirView, self).__init__(parent)
self.name_filters = None
self.parent_widget = parent
self.valid_types = None
self.show_all = None
self.menu = None
self.common_actions = None
self.__expanded_state = None
self._to_be_loaded = None
self.fsmodel = None
self.setup_fs_model()
self._scrollbar_positions = None
# ---- Model
def setup_fs_model(self):
"""Setup filesystem model"""
filters = QDir.AllDirs | QDir.Files | QDir.Drives | QDir.NoDotAndDotDot
self.fsmodel = QFileSystemModel(self)
self.fsmodel.setFilter(filters)
self.fsmodel.setNameFilterDisables(False)
def install_model(self):
"""Install filesystem model"""
self.setModel(self.fsmodel)
def setup_view(self):
"""Setup view"""
self.install_model()
self.connect(self.fsmodel, SIGNAL("directoryLoaded(QString)"), lambda: self.resizeColumnToContents(0))
self.setAnimated(False)
self.setSortingEnabled(True)
self.sortByColumn(0, Qt.AscendingOrder)
def set_name_filters(self, name_filters):
"""Set name filters"""
self.name_filters = name_filters
self.fsmodel.setNameFilters(name_filters)
def set_show_all(self, state):
"""Toggle 'show all files' state"""
if state:
self.fsmodel.setNameFilters([])
else:
self.fsmodel.setNameFilters(self.name_filters)
def get_filename(self, index):
"""Return filename associated with *index*"""
if index:
return osp.normpath(unicode(self.fsmodel.filePath(index)))
def get_index(self, filename):
"""Return index associated with filename"""
return self.fsmodel.index(filename)
def get_selected_filenames(self):
"""Return selected filenames"""
if self.selectionMode() == self.ExtendedSelection:
return [self.get_filename(idx) for idx in self.selectedIndexes()]
else:
return [self.get_filename(self.currentIndex())]
def get_dirname(self, index):
"""Return dirname associated with *index*"""
fname = self.get_filename(index)
if fname:
if osp.isdir(fname):
return fname
else:
return osp.dirname(fname)
# ---- Tree view widget
def setup(self, name_filters=["*.py", "*.pyw"], valid_types=(".py", ".pyw"), show_all=False):
"""Setup tree widget"""
self.setup_view()
self.set_name_filters(name_filters)
self.valid_types = valid_types
self.show_all = show_all
# Setup context menu
self.menu = QMenu(self)
self.common_actions = self.setup_common_actions()
# ---- Context menu
def setup_common_actions(self):
"""Setup context menu common actions"""
# Filters
filters_action = create_action(
self, _("Edit filename filters..."), None, get_icon("filter.png"), triggered=self.edit_filter
)
# Show all files
all_action = create_action(self, _("Show all files"), toggled=self.toggle_all)
all_action.setChecked(self.show_all)
self.toggle_all(self.show_all)
return [filters_action, all_action]
def edit_filter(self):
"""Edit name filters"""
filters, valid = QInputDialog.getText(
self, _("Edit filename filters"), _("Name filters:"), QLineEdit.Normal, ", ".join(self.name_filters)
)
if valid:
filters = [f.strip() for f in unicode(filters).split(",")]
self.parent_widget.sig_option_changed.emit("name_filters", filters)
self.set_name_filters(filters)
def toggle_all(self, checked):
"""Toggle all files mode"""
self.parent_widget.sig_option_changed.emit("show_all", checked)
self.show_all = checked
self.set_show_all(checked)
def create_file_new_actions(self, fnames):
"""Return actions for submenu 'New...'"""
if not fnames:
return []
new_file_act = create_action(
self, _("File..."), icon="filenew.png", triggered=lambda: self.new_file(fnames[-1])
)
new_module_act = create_action(
self, _("Module..."), icon="py.png", triggered=lambda: self.new_module(fnames[-1])
)
new_folder_act = create_action(
self, _("Folder..."), icon="folder_new.png", triggered=lambda: self.new_folder(fnames[-1])
)
new_package_act = create_action(
self,
_("Package..."),
icon=get_icon("package_collapsed.png"),
triggered=lambda: self.new_package(fnames[-1]),
)
return [new_file_act, new_folder_act, None, new_module_act, new_package_act]
def create_file_import_actions(self, fnames):
"""Return actions for submenu 'Import...'"""
return []
def create_file_manage_actions(self, fnames):
"""Return file management actions"""
only_files = all([osp.isfile(_fn) for _fn in fnames])
only_modules = all([osp.splitext(_fn)[1] in (".py", ".pyw", ".ipy") for _fn in fnames])
only_valid = all([osp.splitext(_fn)[1] in self.valid_types for _fn in fnames])
run_action = create_action(self, _("Run"), icon="run_small.png", triggered=self.run)
edit_action = create_action(self, _("Edit"), icon="edit.png", triggered=self.clicked)
move_action = create_action(self, _("Move..."), icon="move.png", triggered=self.move)
delete_action = create_action(self, _("Delete..."), icon="delete.png", triggered=self.delete)
rename_action = create_action(self, _("Rename..."), icon="rename.png", triggered=self.rename)
open_action = create_action(self, _("Open"), triggered=self.open)
actions = []
if only_modules:
actions.append(run_action)
if only_valid and only_files:
actions.append(edit_action)
else:
actions.append(open_action)
actions += [delete_action, rename_action]
basedir = fixpath(osp.dirname(fnames[0]))
if all([fixpath(osp.dirname(_fn)) == basedir for _fn in fnames]):
actions.append(move_action)
actions += [None]
# VCS support is quite limited for now, so we are enabling the VCS
# related actions only when a single file/folder is selected:
dirname = fnames[0] if osp.isdir(fnames[0]) else osp.dirname(fnames[0])
if len(fnames) == 1 and vcs.is_vcs_repository(dirname):
vcs_ci = create_action(
self,
_("Commit"),
icon="vcs_commit.png",
triggered=lambda fnames=[dirname]: self.vcs_command(fnames, tool="commit"),
)
vcs_log = create_action(
self,
_("Browse repository"),
icon="vcs_browse.png",
triggered=lambda fnames=[dirname]: self.vcs_command(fnames, tool="browse"),
)
actions += [None, vcs_ci, vcs_log]
return actions
def create_folder_manage_actions(self, fnames):
"""Return folder management actions"""
actions = []
if os.name == "nt":
_title = _("Open command prompt here")
else:
_title = _("Open terminal here")
action = create_action(
self, _title, icon="cmdprompt.png", triggered=lambda fnames=fnames: self.open_terminal(fnames)
)
actions.append(action)
_title = _("Open Python interpreter here")
action = create_action(
self, _title, icon="python.png", triggered=lambda fnames=fnames: self.open_interpreter(fnames)
)
actions.append(action)
return actions
def create_context_menu_actions(self):
"""Create context menu actions"""
actions = []
fnames = self.get_selected_filenames()
new_actions = self.create_file_new_actions(fnames)
if len(new_actions) > 1:
# Creating a submenu only if there is more than one entry
new_act_menu = QMenu(_("New"), self)
add_actions(new_act_menu, new_actions)
actions.append(new_act_menu)
else:
actions += new_actions
import_actions = self.create_file_import_actions(fnames)
if len(import_actions) > 1:
# Creating a submenu only if there is more than one entry
import_act_menu = QMenu(_("Import"), self)
add_actions(import_act_menu, import_actions)
actions.append(import_act_menu)
else:
actions += import_actions
if actions:
actions.append(None)
if fnames:
actions += self.create_file_manage_actions(fnames)
if actions:
actions.append(None)
if fnames and all([osp.isdir(_fn) for _fn in fnames]):
actions += self.create_folder_manage_actions(fnames)
if actions:
actions.append(None)
actions += self.common_actions
return actions
def update_menu(self):
"""Update context menu"""
self.menu.clear()
add_actions(self.menu, self.create_context_menu_actions())
# ---- Events
def viewportEvent(self, event):
"""Reimplement Qt method"""
# Prevent Qt from crashing or showing warnings like:
# "QSortFilterProxyModel: index from wrong model passed to
# mapFromSource", probably due to the fact that the file system model
# is being built. See Issue 1250.
#
# This workaround was inspired by the following KDE bug:
# https://bugs.kde.org/show_bug.cgi?id=172198
#
# Apparently, this is a bug from Qt itself.
self.executeDelayedItemsLayout()
return QTreeView.viewportEvent(self, event)
def contextMenuEvent(self, event):
"""Override Qt method"""
self.update_menu()
self.menu.popup(event.globalPos())
def keyPressEvent(self, event):
"""Reimplement Qt method"""
if event.key() in (Qt.Key_Enter, Qt.Key_Return):
self.clicked()
elif event.key() == Qt.Key_F2:
self.rename()
elif event.key() == Qt.Key_Delete:
self.delete()
else:
QTreeView.keyPressEvent(self, event)
def mouseDoubleClickEvent(self, event):
"""Reimplement Qt method"""
QTreeView.mouseDoubleClickEvent(self, event)
self.clicked()
def clicked(self):
"""Selected item was double-clicked or enter/return was pressed"""
fnames = self.get_selected_filenames()
for fname in fnames:
if osp.isdir(fname):
self.directory_clicked(fname)
else:
self.open([fname])
def directory_clicked(self, dirname):
"""Directory was just clicked"""
pass
# ---- Drag
def dragEnterEvent(self, event):
"""Drag and Drop - Enter event"""
event.setAccepted(event.mimeData().hasFormat("text/plain"))
def dragMoveEvent(self, event):
"""Drag and Drop - Move event"""
if event.mimeData().hasFormat("text/plain"):
event.setDropAction(Qt.MoveAction)
event.accept()
else:
event.ignore()
def startDrag(self, dropActions):
"""Reimplement Qt Method - handle drag event"""
data = QMimeData()
data.setUrls([QUrl(fname) for fname in self.get_selected_filenames()])
drag = QDrag(self)
drag.setMimeData(data)
drag.exec_()
# ---- File/Directory actions
def open(self, fnames=None):
"""Open files with the appropriate application"""
if fnames is None:
fnames = self.get_selected_filenames()
for fname in fnames:
ext = osp.splitext(fname)[1]
if osp.isfile(fname) and ext in self.valid_types:
self.parent_widget.sig_open_file.emit(fname)
else:
self.open_outside_spyder([fname])
def open_outside_spyder(self, fnames):
"""Open file outside Spyder with the appropriate application
If this does not work, opening unknown file in Spyder, as text file"""
for path in sorted(fnames):
path = file_uri(path)
ok = programs.start_file(path)
if not ok:
self.parent_widget.emit(SIGNAL("edit(QString)"), path)
def open_terminal(self, fnames):
"""Open terminal"""
for path in sorted(fnames):
self.parent_widget.emit(SIGNAL("open_terminal(QString)"), path)
def open_interpreter(self, fnames):
"""Open interpreter"""
for path in sorted(fnames):
self.parent_widget.emit(SIGNAL("open_interpreter(QString)"), path)
def run(self, fnames=None):
"""Run Python scripts"""
if fnames is None:
fnames = self.get_selected_filenames()
for fname in fnames:
self.parent_widget.emit(SIGNAL("run(QString)"), fname)
def remove_tree(self, dirname):
"""Remove whole directory tree
Reimplemented in project explorer widget"""
shutil.rmtree(dirname, onerror=misc.onerror)
def delete_file(self, fname, multiple, yes_to_all):
"""Delete file"""
if multiple:
buttons = QMessageBox.Yes | QMessageBox.YesAll | QMessageBox.No | QMessageBox.Cancel
else:
buttons = QMessageBox.Yes | QMessageBox.No
if yes_to_all is None:
answer = QMessageBox.warning(
self, _("Delete"), _("Do you really want " "to delete <b>%s</b>?") % osp.basename(fname), buttons
)
if answer == QMessageBox.No:
return yes_to_all
elif answer == QMessageBox.Cancel:
return False
elif answer == QMessageBox.YesAll:
yes_to_all = True
try:
if osp.isfile(fname):
misc.remove_file(fname)
self.parent_widget.emit(SIGNAL("removed(QString)"), fname)
else:
self.remove_tree(fname)
self.parent_widget.emit(SIGNAL("removed_tree(QString)"), fname)
return yes_to_all
except EnvironmentError, error:
action_str = _("delete")
QMessageBox.critical(
self,
_("Project Explorer"),
_("<b>Unable to %s <i>%s</i></b>" "<br><br>Error message:<br>%s") % (action_str, fname, unicode(error)),
)
return False
