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 Explorer(QTreeView):
def __init__(self, parent=None):
QTreeView.__init__(self)
self.header().setHidden(True)
self.setAnimated(True)
# Modelo
self.model = QFileSystemModel(self)
path = QDir.toNativeSeparators(QDir.homePath())
self.model.setRootPath(path)
self.setModel(self.model)
self.model.setNameFilters(["*.c", "*.h", "*.s"])
self.setRootIndex(QModelIndex(self.model.index(path)))
self.model.setNameFilterDisables(False)
# Se ocultan algunas columnas
self.hideColumn(1)
self.hideColumn(2)
self.hideColumn(3)
# Conexion
self.doubleClicked.connect(self._open_file)
Edis.load_lateral("explorer", self)
def _open_file(self, i):
if not self.model.isDir(i):
indice = self.model.index(i.row(), 0, i.parent())
archivo = self.model.filePath(indice)
principal = Edis.get_component("principal")
principal.open_file(archivo)
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)
class Explorador(custom_dock.CustomDock):
def __init__(self, parent=None):
custom_dock.CustomDock.__init__(self)
self.explorador = QTreeView()
self.setWidget(self.explorador)
self.explorador.header().setHidden(True)
self.explorador.setAnimated(True)
# Modelo
self.modelo = QFileSystemModel(self.explorador)
path = QDir.toNativeSeparators(QDir.homePath())
self.modelo.setRootPath(path)
self.explorador.setModel(self.modelo)
self.modelo.setNameFilters(["*.c", "*.h", "*.s"])
self.explorador.setRootIndex(QModelIndex(self.modelo.index(path)))
self.modelo.setNameFilterDisables(False)
# Se ocultan algunas columnas
self.explorador.hideColumn(1)
self.explorador.hideColumn(2)
self.explorador.hideColumn(3)
# Conexion
self.explorador.doubleClicked.connect(self._abrir_archivo)
EDIS.cargar_lateral("explorador", self)
def _abrir_archivo(self, i):
if not self.modelo.isDir(i):
indice = self.modelo.index(i.row(), 0, i.parent())
archivo = self.modelo.filePath(indice)
principal = EDIS.componente("principal")
principal.abrir_archivo(archivo)
def _iconForPath(self, path):
"""Get icon for file or directory path. Uses QFileSystemModel
"""
if self._model is None:
self._model = QFileSystemModel()
index = self._model.index(path)
return self._model.data(index, Qt.DecorationRole)
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)
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 DockFileSystem(QDockWidget):
left = Qt.LeftDockWidgetArea
right = Qt.RightDockWidgetArea
def __init__(self, parent = None):
QDockWidget.__init__(self, "File System Tree View", parent)
self.setObjectName("FileNavigatorDock")
self.fsm = QFileSystemModel(self)
tv = QTreeView(self)
tv.showColumn(1)
self.fsm.setRootPath(self.parent().workdir)
tv.setModel(self.fsm)
self.setAllowedAreas( self.left | self.right )
self.setGeometry(0,0,400,1000)
pb = QPushButton("...",self)
pb.clicked.connect(self.changeWorkdir)
self.le = QLineEdit(self)
self.le.setText(self.parent().workdir)
dockbox = QWidget(self)
hl = QHBoxLayout(dockbox)
hl.addWidget(self.le)
hl.addWidget(pb)
hll=QWidget(self)
hll.setLayout(hl)
vl = QVBoxLayout(dockbox)
dockbox.setLayout(vl)
vl.addWidget(hll)
vl.addWidget(tv)
self.setWidget(dockbox)
self.adjustSize()
self.parent().say("Vista del sistema de ficheros creada")
@pyqtSlot()
def changeWorkdir(self):
dialog=QFileDialog(self,"Elige directorio de trabajo",self.parent().workdir)
dialog.setFileMode(QFileDialog.Directory)
dialog.setAcceptMode(QFileDialog.AcceptOpen)
if dialog.exec_():
fichero = dialog.selectedFiles().first().toLocal8Bit().data()
self.parent().workdir = fichero
self.le.setText(fichero)
self.fsm.setRootPath(self.parent().workdir)
def __init__(self, parent=None):
custom_dock.CustomDock.__init__(self)
self.explorador = QTreeView()
self.setWidget(self.explorador)
self.explorador.header().setHidden(True)
self.explorador.setAnimated(True)
# Modelo
self.modelo = QFileSystemModel(self.explorador)
path = QDir.toNativeSeparators(QDir.homePath())
self.modelo.setRootPath(path)
self.explorador.setModel(self.modelo)
self.modelo.setNameFilters(["*.c", "*.h", "*.s"])
self.explorador.setRootIndex(QModelIndex(self.modelo.index(path)))
self.modelo.setNameFilterDisables(False)
# Se ocultan algunas columnas
self.explorador.hideColumn(1)
self.explorador.hideColumn(2)
self.explorador.hideColumn(3)
# Conexion
self.explorador.doubleClicked.connect(self._abrir_archivo)
EDIS.cargar_lateral("explorador", self)
def __init__(self, parent = None):
QDockWidget.__init__(self, "File System Tree View", parent)
self.setObjectName("FileNavigatorDock")
self.fsm = QFileSystemModel(self)
tv = QTreeView(self)
tv.showColumn(1)
self.fsm.setRootPath(self.parent().workdir)
tv.setModel(self.fsm)
self.setAllowedAreas( self.left | self.right )
self.setGeometry(0,0,400,1000)
pb = QPushButton("...",self)
pb.clicked.connect(self.changeWorkdir)
self.le = QLineEdit(self)
self.le.setText(self.parent().workdir)
dockbox = QWidget(self)
hl = QHBoxLayout(dockbox)
hl.addWidget(self.le)
hl.addWidget(pb)
hll=QWidget(self)
hll.setLayout(hl)
vl = QVBoxLayout(dockbox)
dockbox.setLayout(vl)
vl.addWidget(hll)
vl.addWidget(tv)
self.setWidget(dockbox)
self.adjustSize()
self.parent().say("Vista del sistema de ficheros creada")
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 _iconForPath(self, path):
"""Get icon for file or directory path. Uses QFileSystemModel
"""
if self._model is None:
self._model = QFileSystemModel()
index = self._model.index(path)
return self._model.data(index, Qt.DecorationRole)
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 paintEvent(self, event):
self.splitter = QSplitter()
model = QFileSystemModel()
model.setRootPath(QDir.rootPath())
# model.setRootPath(idahome)
# using ida home instead
views = []
for ViewType in (QColumnView, QTreeView):
view = ViewType(self.splitter)
view.setModel(model)
view.setRootIndex(model.index(idahome))
view.setDragEnabled(True)
view.setAcceptDrops(True)
view.setDragDropMode(QtGui.QAbstractItemView.InternalMove)
# splitter.show()
# Create layout
layout = QtGui.QVBoxLayout(self)
# layout.addWidget(self.comboList)
layout.addWidget(self.splitter)
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 __init__(self):
QWidget.__init__(self)
hbox = QHBoxLayout(self)
hbox.setContentsMargins(0, 0, 0, 0)
self.btnClose = QPushButton(self.style().standardIcon(QStyle.SP_DialogCloseButton), "")
self.completer = QCompleter(self)
self.pathLine = ui_tools.LineEditTabCompleter(self.completer)
fileModel = QFileSystemModel(self.completer)
fileModel.setRootPath("")
self.completer.setModel(fileModel)
self.pathLine.setCompleter(self.completer)
self.btnOpen = QPushButton(self.style().standardIcon(QStyle.SP_ArrowRight), "Open!")
hbox.addWidget(self.btnClose)
hbox.addWidget(QLabel(self.tr("Path:")))
hbox.addWidget(self.pathLine)
hbox.addWidget(self.btnOpen)
self.connect(self.pathLine, SIGNAL("returnPressed()"), self._open_file)
self.connect(self.btnOpen, SIGNAL("clicked()"), self._open_file)
class DataWidget(ui_datawidget.Ui_widget, WidgetBase):
def __init__(self, parent=None):
super(DataWidget, self).__init__(parent)
self.setupUi(self)
self.model = QFileSystemModel()
self.settings = None
allfilters = []
filters = re.findall(
r"\((.*?)\)",
QgsProviderRegistry.instance().fileVectorFilters())[1:]
for filter in filters:
allfilters = allfilters + filter.split(" ")
filters += re.findall(
r"\((.*?)\)",
QgsProviderRegistry.instance().fileRasterFilters())[1:]
for filter in filters:
allfilters = allfilters + filter.split(" ")
self.model.setNameFilters(allfilters)
self.model.setNameFilterDisables(False)
self.listDataList.setModel(self.model)
self.btnAddData.pressed.connect(self.open_data_folder)
for col in range(self.model.columnCount())[1:]:
self.listDataList.hideColumn(col)
self.service = None
def open_data_folder(self):
"""
Open the data folder of the project using the OS
"""
path = os.path.join(self.data['data_root'])
openfolder(path)
def set_data(self, data):
super(DataWidget, self).set_data(data)
self.service = DataService(self.config)
root = data['data_root']
if not os.path.exists(root):
os.mkdir(root)
self.model.setRootPath(root)
self.listDataList.setRootIndex(self.model.index(root))
self.refresh()
def write_config(self):
self.logger.info("Data write config")
DataService(self.config).update_date_to_latest()
super(DataWidget, self).write_config()
def refresh(self):
self.lastSaveLabel.setText("Last save date: {}".format(
self.service.last_save_date))
def __init__(self, parent=None): """Constructor.""" super(LayerLoaderDialog, self).__init__(parent) self.setupUi(self) self.completer = QCompleter(self) self.fsmodel = QFileSystemModel(self.completer) self.fsmodel.setNameFilters(['*.qlf']) self.completer.setModel(self.fsmodel) self.filename.setCompleter(self.completer) self.searchdir.clicked.connect(self.opensearchform)
def setData(self, index, value, role):
if role == Qt.CheckStateRole and index.column() == 0:
self.layoutAboutToBeChanged.emit()
for i, v in self.checks.items():
if are_parent_and_child(index, i):
self.checks.pop(i)
self.checks[index] = value
#self.childCount(index)
self.layoutChanged.emit()
return True
return QFileSystemModel.setData(self, index, value, role)
def __init__(self):
QWidget.__init__(self)
hbox = QHBoxLayout(self)
hbox.setContentsMargins(0, 0, 0, 0)
self.btnClose = QPushButton(
self.style().standardIcon(QStyle.SP_DialogCloseButton), '')
self.completer = QCompleter(self)
self.pathLine = ui_tools.LineEditTabCompleter(self.completer)
fileModel = QFileSystemModel(self.completer)
fileModel.setRootPath("")
self.completer.setModel(fileModel)
self.pathLine.setCompleter(self.completer)
self.btnOpen = QPushButton(
self.style().standardIcon(QStyle.SP_ArrowRight), 'Open!')
hbox.addWidget(self.btnClose)
hbox.addWidget(QLabel(self.trUtf8("Path:")))
hbox.addWidget(self.pathLine)
hbox.addWidget(self.btnOpen)
self.connect(self.pathLine, SIGNAL("returnPressed()"), self._open_file)
self.connect(self.btnOpen, SIGNAL("clicked()"), self._open_file)
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 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 LayerLoaderDialog(QDialog, FORM_CLASS):
def __init__(self, parent=None):
"""Constructor."""
super(LayerLoaderDialog, self).__init__(parent)
self.setupUi(self)
self.completer = QCompleter(self)
self.fsmodel = QFileSystemModel(self.completer)
self.fsmodel.setNameFilters(['*.qlf'])
self.completer.setModel(self.fsmodel)
self.filename.setCompleter(self.completer)
self.searchdir.clicked.connect(self.opensearchform)
def opensearchform(self):
dn = QFileDialog.getOpenFileName(self, self.tr('Choose target directory for layers'), self.filename.text(), '*.qlf' )
if dn:
self.filename.setText(dn)
def set_target_directory(self, dn):
self.filename.setText(dn)
def layer(self):
return self.filename.text()
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 __init__(self, *args):
super(FileBrowser, self).__init__(*args)
layout = QVBoxLayout()
model = QFileSystemModel()
filters = ["*.jpg", "*.JPG", "*.jpeg", "*.JPEG", "*.png", "*.PNG"]
model.setNameFilters(filters)
self.directoryTree = QTreeView()
self.directoryTree.setModel(model)
self.directoryTree.currentChanged = self.currentChanged
self.directoryTree.setSortingEnabled(True)
self.directoryTree.sortByColumn(0, Qt.AscendingOrder)
self.fileList = QListWidget()
layout.addWidget(self.directoryTree)
self.setLayout(layout)
root = model.setRootPath(QDir.homePath())
self.directoryTree.setRootIndex(root)
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 __init__(self, parent=None):
QTreeView.__init__(self)
self.header().setHidden(True)
self.setAnimated(True)
# Modelo
self.model = QFileSystemModel(self)
path = QDir.toNativeSeparators(QDir.homePath())
self.model.setRootPath(path)
self.setModel(self.model)
self.model.setNameFilters(["*.c", "*.h", "*.s"])
self.setRootIndex(QModelIndex(self.model.index(path)))
self.model.setNameFilterDisables(False)
# Se ocultan algunas columnas
self.hideColumn(1)
self.hideColumn(2)
self.hideColumn(3)
# Conexion
self.doubleClicked.connect(self._open_file)
Edis.load_lateral("explorer", self)
def __init__(self, *args):
super(FileBrowser, self).__init__(*args)
layout = QVBoxLayout()
model = QFileSystemModel()
filters = ["*.jpg", "*.JPG", "*.jpeg", "*.JPEG","*.png","*.PNG"]
model.setNameFilters(filters)
self.directoryTree = QTreeView()
self.directoryTree.setModel(model)
self.directoryTree.currentChanged = self.currentChanged
self.directoryTree.setSortingEnabled(True)
self.directoryTree.sortByColumn(0, Qt.AscendingOrder)
self.fileList = QListWidget()
layout.addWidget(self.directoryTree)
self.setLayout(layout)
root = model.setRootPath(QDir.homePath())
self.directoryTree.setRootIndex(root)
def __init__(self, root, parent=None):
super(MFileTree, self).__init__(parent)
self.setStyleSheet("color:rgb(189, 195, 199);")
# model = QFileSystemModel()
# model.setRootPath(QDir.rootPath())
# view = QTreeView(parent)
# self.show()
#app = QApplication(sys.argv)
# Splitter to show 2 views in same widget easily.
splitter = QSplitter()
# The model.
model = QFileSystemModel()
# You can setRootPath to any path.
model.setRootPath(root)
# List of views.
self.views = []
#self.view = QTreeView(self)
# self.itemPressed.connect(self.itemClicked)
self.setModel(model)
self.setRootIndex(model.index(root))
self.header().setStyleSheet("background:rgb(70, 80, 88);")
# for ViewType in (QColumnView, QTreeView):
# # Create the view in the splitter.
# view = ViewType(splitter)
# # Set the model of the view.
# view.setModel(model)
# # Set the root index of the view as the user's home directory.
# view.setRootIndex(model.index(QDir.homePath()))
# # Show the splitter.
# splitter.show()
self.layout = QtGui.QHBoxLayout()
# self.layout.addWidget(self)
self.setLayout(self.layout)
# Maximize the splitter.
splitter.setWindowState(Qt.WindowMaximized)
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 __init__(self, parent=None):
super(DataWidget, self).__init__(parent)
self.setupUi(self)
self.model = QFileSystemModel()
self.settings = None
allfilters = []
filters = re.findall(
r"\((.*?)\)",
QgsProviderRegistry.instance().fileVectorFilters())[1:]
for filter in filters:
allfilters = allfilters + filter.split(" ")
filters += re.findall(
r"\((.*?)\)",
QgsProviderRegistry.instance().fileRasterFilters())[1:]
for filter in filters:
allfilters = allfilters + filter.split(" ")
self.model.setNameFilters(allfilters)
self.model.setNameFilterDisables(False)
self.listDataList.setModel(self.model)
self.btnAddData.pressed.connect(self.open_data_folder)
for col in range(self.model.columnCount())[1:]:
self.listDataList.hideColumn(col)
self.service = None
def __init__(self, parent=None):
QtGui.QWidget.__init__(self, parent)
self.ui = Ui_MainWindow() #treeview UI
self.ui.setupUi(self)
self.showMaximized()
self.home=os.getcwd()
self.fileSystemModel = QFileSystemModel()
#self.home=self.home + "/connections"
#print (self.home)
self.fillGrid2(self.home)
#self.ui.treeWidget.isSortingEnabled()
#self.ui.treeWidget.setSortingEnabled(True)
self.ui.treeView.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
self.connect(self.ui.treeView, QtCore.SIGNAL("customContextMenuRequested(const QPoint &)"), self.onclick)
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 __init__(self):
super(Window, self).__init__()
central_widget = QWidget()
self._current_path = None
self._use_suffix = False
self._file_model = QFileSystemModel()
self._file_model.setNameFilters(['*.jpg', '*.png'])
self._file_model.setNameFilterDisables(False)
self._file_model.setRootPath(QDir.rootPath())
self._file_selection_model = QItemSelectionModel(self._file_model)
self._file_selection_model.currentChanged.connect(self._on_current_file_changed)
self._file_tree = QTreeView(parent=self)
self._file_tree.collapsed.connect(self._on_tree_expanded_collapsed)
self._file_tree.expanded.connect(self._on_tree_expanded_collapsed)
self._file_tree.setModel(self._file_model)
self._file_tree.setSelectionModel(self._file_selection_model)
self._file_tree.setColumnHidden(1, True)
self._file_tree.setColumnHidden(2, True)
self._file_tree.setColumnHidden(3, True)
self._file_tree.header().hide()
self._viewer = Viewer(Loader(24))
self._splitter = QSplitter();
self._splitter.addWidget(self._file_tree)
self._splitter.addWidget(self._viewer)
self._splitter.setStretchFactor(0, 0)
self._splitter.setStretchFactor(1, 1)
self._splitter.setCollapsible(0, False)
self._layout = QGridLayout()
self._layout.addWidget(self._splitter)
self._switch_to_normal()
central_widget.setLayout(self._layout)
self._file_tree.installEventFilter(self);
self.resize(800, 600)
self.setWindowTitle('pyQtures')
self.setCentralWidget(central_widget)
self.show()
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()
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 __init__(self, parent):
super(SourceFileTreeWidget, self).__init__(parent)
self.ui = Ui_SourceFileTreeWidget()
self.ui.setupUi(self)
self.file_model = QFileSystemModel()
#self.file_model.setFilter(QDir.AllEntries | QDir.NoDot)
self.set_filter()
self.ui.tree.setModel(self.file_model)
self.ui.tree.resizeColumnToContents(0)
self.ui.custom_root.setText(QDir.currentPath())
self.set_root()
header = self.ui.tree.header()
header.setResizeMode(QHeaderView.ResizeToContents)
#header.setStretchLastSection(True)
#header.setSortIndicator(0, Qt.AscendingOrder)
#header.setSortIndicatorShown(True)
#header.setClickable(True)
self.connect(self.ui.tree, QtCore.SIGNAL('doubleClicked(QModelIndex)'), self.open_file)
self.connect(self.ui.ok_filter, QtCore.SIGNAL('clicked()'), self.set_filter)
self.connect(self.ui.custom_filter, QtCore.SIGNAL('returnPressed()'), self.set_filter)
self.connect(self.ui.ok_root, QtCore.SIGNAL('clicked()'), self.set_root)
self.connect(self.ui.custom_root, QtCore.SIGNAL('returnPressed()'), self.set_root)
self.open_file_signal = None
def __init__(self, *args):
QFileSystemModel.__init__(self, *args)
class AbstractPathCompleter(AbstractCompleter):
"""Base class for PathCompleter and GlobCompleter
"""
# global object. Reused by all completers
_fsModel = QFileSystemModel()
_ERROR = 'error'
_HEADER = 'currentDir'
_STATUS = 'status'
_DIRECTORY = 'directory'
_FILE = 'file'
def __init__(self, text):
self._originalText = text
self._dirs = []
self._files = []
self._error = None
self._status = None
"""hlamer: my first approach is making self._model static member of class. But, sometimes it
returns incorrect icons. I really can't understand when and why.
When it is private member of instance, it seems it works
"""
self._model = None # can't construct in the construtor, must be constructed in GUI thread
@staticmethod
def _filterHidden(paths):
"""Remove hidden and ignored files from the list
"""
return [path for path in paths \
if not os.path.basename(path).startswith('.') and \
not core.fileFilter().regExp().match(path)]
def _classifyRowIndex(self, row):
"""Get list item type and index by it's row
"""
if self._error:
assert row == 0
return (self._ERROR, 0)
if row == 0:
return (self._HEADER, 0)
row -= 1
if self._status:
if row == 0:
return (self._STATUS, 0)
row -= 1
if row in range(len(self._dirs)):
return (self._DIRECTORY, row)
row -= len(self._dirs)
if row in range(len(self._files)):
return (self._FILE, row)
assert False
def _formatHeader(self, text):
"""Format current directory for show it in the list of completions
"""
return '<font style="background-color: %s; color: %s">%s</font>' % \
(QApplication.instance().palette().color(QPalette.Window).name(),
QApplication.instance().palette().color(QPalette.WindowText).name(),
htmlEscape(text))
def rowCount(self):
"""Row count in the list of completions
"""
if self._error:
return 1
else:
count = 1 # current directory
if self._status:
count += 1
count += len(self._dirs)
count += len(self._files)
return count
def _iconForPath(self, path):
"""Get icon for file or directory path. Uses QFileSystemModel
"""
if self._model is None:
self._model = QFileSystemModel()
index = self._model.index(path)
return self._model.data(index, Qt.DecorationRole)
def text(self, row, column):
"""Item text in the list of completions
"""
rowType, index = self._classifyRowIndex(row)
if rowType == self._ERROR:
return '<font color=red>%s</font>' % htmlEscape(self._error)
elif rowType == self._HEADER:
return self._formatHeader(self._headerText())
elif rowType == self._STATUS:
return '<i>%s</i>' % htmlEscape(self._status)
elif rowType == self._DIRECTORY:
return self._formatPath(self._dirs[index], True)
elif rowType == self._FILE:
return self._formatPath(self._files[index], False)
def icon(self, row, column):
"""Item icon in the list of completions
"""
rowType, index = self._classifyRowIndex(row)
if rowType == self._ERROR:
return QApplication.instance().style().standardIcon(QStyle.SP_MessageBoxCritical)
elif rowType == self._HEADER:
return None
elif rowType == self._STATUS:
return None
elif rowType == self._DIRECTORY:
return self._iconForPath(self._dirs[index])
elif rowType == self._FILE:
return self._iconForPath(self._files[index])
def getFullText(self, row):
"""User clicked a row. Get inline completion for this row
"""
row -= 1 # skip current directory
path = None
if row in range(len(self._dirs)):
return self._dirs[row] + '/'
else:
row -= len(self._dirs) # skip dirs
if row in range(len(self._files)):
return self._files[row]
return None
def flags(self, QModelIndex):
return Qt.ItemIsUserCheckable | QFileSystemModel.flags(
self, QModelIndex)
return False
return QTreeView.edit(self, index, trigger, event)
def buttonClicked(self):
sender = self.sender()
self.statusBar().showMessage(sender.text() + " was pressed")
if __name__ == "__main__":
app = QApplication(sys.argv)
# Splitter to show 2 views in same widget easily.
splitter = QSplitter()
# The model.
model = QFileSystemModel()
# You can setRootPath to any path.
model.setReadOnly(True)
# model.setRootPath("/Users/legal/Developpement/pc-sim/src/reports")
model.setRootPath(QDir.currentPath())
model.setNameFilters(["*.perf", "*.dat", "*.txt", "*.data"])
model.setNameFilterDisables(False)
# setDir.setNameFilters(filter)
# tree.setRootIndex(model.index(QtCore.QDir.path(setDir), 0 ))
# List of views.
views = []
# for ViewType in (QColumnView, QTreeView):
# for ViewType in (QTreeView):
def data(self, index, role):
if role == Qt.ToolTipRole:
return self.filePath(index)
else:
return QFileSystemModel.data(self, index, role)
def fetchMore(self, QModelIndex):
#self.emit(SIGNAL("loading"))
self.directoryLoading.emit()
return QFileSystemModel.fetchMore(self, QModelIndex)
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))
def __init__(self, parent=None):
QFileSystemModel.__init__(self, parent)
self.setNameFilterDisables(False)
self.isReady = True
self.directoryLoading.connect(self.__busy)
self.directoryLoaded.connect(self.__ready)
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)
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
@license :
@contact : ****@massclouds.com
@site : http://blog.csdn.net/***
@software: PyCharm
@time : 17-1-5 下午5:19
"""
from PyQt4.QtGui import QApplication,QTreeView,QFileSystemModel, QListView
from PyQt4.QtCore import QDir
import sys
if __name__ == '__main__':
app = QApplication(sys.argv)
# 1. 创建 模型 model */
model = QFileSystemModel() # 创建文件系统模型
model.setRootPath(QDir.currentPath()) # 指定要监视的目录
# 2. 创建 视图 view */
tree = QTreeView() # 创建树型视图
tree.setModel(model) # 为视图指定模型
tree.setRootIndex(model.index(QDir.currentPath() ))# 指定根索引
listw = QListView() # 创建列表视图
listw.setModel(model) # 为视图指定模型
listw.setRootIndex(model.index(QDir.currentPath()))# 指定根索引
tree.setWindowTitle("QTreeView")
tree.show()
listw.setWindowTitle("QListView")
listw.show()
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()
def __init__(self, parent=None):
QFileSystemModel.__init__(self, parent)
self.setNameFilterDisables(False)
self.isReady = True
self.directoryLoading.connect(self.__busy)
self.directoryLoaded.connect(self.__ready)
def __init__(self, *args):
QFileSystemModel.__init__(self, *args)
import sys
from PyQt4.QtGui import (QApplication, QColumnView, QFileSystemModel,
QSplitter, QTreeView)
from PyQt4.QtCore import QDir, Qt
if __name__ == '__main__':
app = QApplication(sys.argv)
# Splitter to show 2 views in same widget easily.
splitter = QSplitter()
# The model.
model = QFileSystemModel()
# You can setRootPath to any path.
model.setRootPath(QDir.rootPath())
# List of views.
views = []
for ViewType in (QColumnView, QTreeView):
# Create the view in the splitter.
view = ViewType(splitter)
# Set the model of the view.
view.setModel(model)
# Set the root index of the view as the user's home directory.
view.setRootIndex(model.index(QDir.homePath()))
# Show the splitter.
splitter.show()
# Maximize the splitter.
splitter.setWindowState(Qt.WindowMaximized)
# Start the main loop.
sys.exit(app.exec_())
def data(self, index, role):
if role == Qt.ToolTipRole:
return self.filePath(index)
else:
return QFileSystemModel.data(self, index, role)
class AbstractPathCompleter(AbstractCompleter):
"""Base class for PathCompleter and GlobCompleter
"""
# global object. Reused by all completers
_fsModel = QFileSystemModel()
_ERROR = 'error'
_HEADER = 'currentDir'
_STATUS = 'status'
_DIRECTORY = 'directory'
_FILE = 'file'
def __init__(self, text):
self._originalText = text
self._dirs = []
self._files = []
self._error = None
self._status = None
"""hlamer: my first approach is making self._model static member of class. But, sometimes it
returns incorrect icons. I really can't understand when and why.
When it is private member of instance, it seems it works
"""
self._model = None # can't construct in the construtor, must be constructed in GUI thread
@staticmethod
def _filterHidden(paths):
"""Remove hidden and ignored files from the list
"""
return [path for path in paths \
if not os.path.basename(path).startswith('.') and \
not core.fileFilter().regExp().match(path)]
def _classifyRowIndex(self, row):
"""Get list item type and index by it's row
"""
if self._error:
assert row == 0
return (self._ERROR, 0)
if row == 0:
return (self._HEADER, 0)
row -= 1
if self._status:
if row == 0:
return (self._STATUS, 0)
row -= 1
if row in range(len(self._dirs)):
return (self._DIRECTORY, row)
row -= len(self._dirs)
if row in range(len(self._files)):
return (self._FILE, row)
assert False
def _formatHeader(self, text):
"""Format current directory for show it in the list of completions
"""
return '<font style="background-color: %s; color: %s">%s</font>' % \
(QApplication.instance().palette().color(QPalette.Window).name(),
QApplication.instance().palette().color(QPalette.WindowText).name(),
htmlEscape(text))
def rowCount(self):
"""Row count in the list of completions
"""
if self._error:
return 1
else:
count = 1 # current directory
if self._status:
count += 1
count += len(self._dirs)
count += len(self._files)
return count
def _iconForPath(self, path):
"""Get icon for file or directory path. Uses QFileSystemModel
"""
if self._model is None:
self._model = QFileSystemModel()
index = self._model.index(path)
return self._model.data(index, Qt.DecorationRole)
def text(self, row, column):
"""Item text in the list of completions
"""
rowType, index = self._classifyRowIndex(row)
if rowType == self._ERROR:
return '<font color=red>%s</font>' % htmlEscape(self._error)
elif rowType == self._HEADER:
return self._formatHeader(self._headerText())
elif rowType == self._STATUS:
return '<i>%s</i>' % htmlEscape(self._status)
elif rowType == self._DIRECTORY:
return self._formatPath(self._dirs[index], True)
elif rowType == self._FILE:
return self._formatPath(self._files[index], False)
def icon(self, row, column):
"""Item icon in the list of completions
"""
rowType, index = self._classifyRowIndex(row)
if rowType == self._ERROR:
return QApplication.instance().style().standardIcon(
QStyle.SP_MessageBoxCritical)
elif rowType == self._HEADER:
return None
elif rowType == self._STATUS:
return None
elif rowType == self._DIRECTORY:
return self._iconForPath(self._dirs[index])
elif rowType == self._FILE:
return self._iconForPath(self._files[index])
def getFullText(self, row):
"""User clicked a row. Get inline completion for this row
"""
row -= 1 # skip current directory
path = None
if row in range(len(self._dirs)):
return self._dirs[row] + '/'
else:
row -= len(self._dirs) # skip dirs
if row in range(len(self._files)):
return self._files[row]
return None
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 fetchMore(self, QModelIndex):
#self.emit(SIGNAL("loading"))
self.directoryLoading.emit()
return QFileSystemModel.fetchMore(self, QModelIndex)
def data(self, index, role=None):
if role == Qt.CheckStateRole and index.column() == 0:
return self.checkState(index)
return QFileSystemModel.data(self, index, role)
