Beispiel #1
0
    def add_file(self, filename):
        if filename not in self.filenames:
            # make filenames unicode-safe for Qt (#141)
            filename = filename.encode('utf-8').decode('utf-8', 'replace')

            self.filenames.append(filename)

            fileinfo = QtCore.QFileInfo(filename)
            basename = os.path.basename(filename.rstrip('/'))
            ip = QtGui.QFileIconProvider()
            icon = ip.icon(fileinfo)

            if os.path.isfile(filename):
                size = helpers.human_readable_filesize(fileinfo.size())
            else:
                size = helpers.human_readable_filesize(
                    helpers.dir_size(filename))
            item_name = unicode('{0:s} ({1:s})'.format(basename, size))
            item = QtGui.QListWidgetItem(item_name)
            item.setToolTip(QtCore.QString(size))

            item.setIcon(icon)
            self.addItem(item)

            self.files_updated.emit()
class DockWidget(QtGui.QDockWidget, FORM_CLASS):
    """The DockWidget class for the Qlr Panel.
    """
    iconProvider = QtGui.QFileIconProvider()

    closingPlugin = pyqtSignal()

    itemStateChanged = pyqtSignal(object, bool)

    def __init__(self, iface=None):
        """
        Constructor.
        Sets the parent, sets up the UI and fills the tree.
        """
        parent = None if iface is None else iface.mainWindow()
        super(DockWidget, self).__init__(parent)
        # Set up the user interface from Designer.
        # After setupUI you can access any designer object by doing
        # self.<objectname>, and you can use autoconnect slots - see
        # http://qt-project.org/doc/qt-4.8/designer-using-a-ui-file.html
        # #widgets-and-dialogs-with-auto-connect

        self.config = QSettings()
        self.readconfig()

        self.setupUi(self)

        self.iface = iface
Beispiel #3
0
    def handleDirectoryChangedSlot( self, _s_directory ):
        self.ui.directoryListWidget.clear()
        self.s_currentDirectory = os.path.normpath( os.path.abspath( str(_s_directory) ) )
        self.ui.urlLineEdit.setText( self.s_currentDirectory )
        o_qdir = QtCore.QDir( self.s_currentDirectory )

        # Mise a jour liste des repertoires
        #---------------------------------------------------------------
        o_qdir.setFilter( QtCore.QDir.Dirs )
        t_dirList = o_qdir.entryList()

        if not t_dirList.isEmpty():
            self.ui.directoryListWidget.setEnabled(True)
            self.ui.directoryListWidget.addItems( t_dirList )
            o_qFileIconProvider = QtGui.QFileIconProvider()

            for o_item in self.iterAllDirectories():
                o_item.setIcon( o_qFileIconProvider.icon( QtCore.QFileInfo(o_qdir, o_item.text()) ) )
        else:
            self.ui.directoryListWidget.setEnabled(False)

        # Mise a jour de la liste de tous les fichiers (hors filtre) contenu
        # dans le repertoire courant
        #---------------------------------------------------------------
        o_qdir.setFilter( QtCore.QDir.Files | QtCore.QDir.NoDotAndDotDot )
        self.t_allFilesInCurrentDirectory = o_qdir.entryList()
        self.updateFileListWidget()
Beispiel #4
0
	def qfileicon(self, path):

		"""
		desc:
			Gets an filetype icon for a file.

		arguments:
			path:	The full path to the file. The file must exist.

		returns:
			type:	QIcon
		"""

		return QtGui.QFileIconProvider().icon(QtCore.QFileInfo(path))
Beispiel #5
0
    def updateFileListWidget( self ):
        self.ui.fileListWidget.clear()
        o_rx = QtCore.QRegExp( self.s_currentFilter )
        o_rx.setPatternSyntax( QtCore.QRegExp.Wildcard )

        # On filtre avec exactMatch (la fonction filter de QStringList n'applique pas un exact match)
        #t_filteredFileList = self.t_allFilesInCurrentDirectory.filter( o_rx )
        t_filteredFileList = QtCore.QStringList( [ f for f in self.t_allFilesInCurrentDirectory
                                                     if o_rx.exactMatch(f)
                                                  ]
                                                )

        if not t_filteredFileList.isEmpty():
            self.ui.fileListWidget.setEnabled(True)
            self.ui.fileListWidget.addItems( t_filteredFileList )

            o_qdir = QtCore.QDir( self.s_currentDirectory )
            o_qFileIconProvider = QtGui.QFileIconProvider()

            for o_item in self.iterAllFiles():
                o_item.setIcon( o_qFileIconProvider.icon( QtCore.QFileInfo(o_qdir, o_item.text()) ) )
        else:
            self.ui.fileListWidget.setEnabled(False)
Beispiel #6
0
import os
class DockWidget(QtGui.QDockWidget, FORM_CLASS):
    """The DockWidget class for the Qlr Panel.
    """
    iconProvider = QtGui.QFileIconProvider()

    closingPlugin = pyqtSignal()

    itemStateChanged = pyqtSignal(object, bool)

    refreshButtonClicked = pyqtSignal()

    def __init__(self, iface=None):
        """
        Constructor.
        Sets the parent, sets up the UI and fills the tree.
        """
        parent = None if iface is None else iface.mainWindow()
        super(DockWidget, self).__init__(parent)
        # Set up the user interface from Designer.
        # After setupUI you can access any designer object by doing
        # self.<objectname>, and you can use autoconnect slots - see
        # http://qt-project.org/doc/qt-4.8/designer-using-a-ui-file.html
        # #widgets-and-dialogs-with-auto-connect

        self.setupUi(self)

        self.iface = iface

        # UI
        self.filterLineEdit.setPlaceholderText(self.trUtf8(u'Filter'))
        self.treeWidget.setColumnCount(1)
        self.treeWidget.header().hide()

        # Properties
        self.root_paths = set()
        self.file_system = {}
        self.checked_paths = set()

        # Signals
        self.treeWidget.itemDoubleClicked.connect(self._treeitem_doubleclicked)
        self.treeWidget.itemChanged.connect(self._treeitem_changed)
        self.refreshButton.clicked.connect(self.refreshClicked)

        # Search
        self.timer = QTimer(self)
        self.timer.setSingleShot(True)
        self.timer.setInterval(500)
        self.timer.timeout.connect(self._fillTree)
        #self.filterLineEdit.textChanged.connect(self._fillTree)
        self.filterLineEdit.textChanged.connect(self.timer.start)

        # Default fill
        self._fillTree()

    def addRootPath(self, path):
        """Adds the root path and sets up the File System Model and connects it to the _fillTree method.
        """
        if os.path.exists(path):
            self.root_paths.add(path)
            fs = FileSystemModel()
            self.file_system[path] = fs
            fs.updated.connect(self._fillTree)
            try:
                fs.setRootPath(path)
            except FileSystemRecursionException as e:
                message = self.trUtf8(
                    "Configured base path has too many files (> {})").format(
                        e.maxcount)
                self._setRootPathMessage(message)

    def removeRootPath(self, path):
        """
        Removes the Root Path and disconnects the fillTree() method.
        """
        self.root_paths.remove(path)
        fs = self.file_system.pop(path, None)
        fs.updated.disconnect(self._fillTree)

    def setPathCheckState(self, path, newState):
        """Sets the check state of a path.
        """
        oldState = path in self.checked_paths
        if newState:
            self.checked_paths.add(path)
        elif path in self.checked_paths:
            self.checked_paths.remove(path)
        self._updateTree(path)

    def getIsPathChecked(self, path):
        """
        Returns true whth the path is checked.
        :param path: string
        """
        return path in self.checked_paths

    def getNumCheckedSubPaths(self, path):
        """
        Returns the number of checked items in all subpaths of this element
        :param path: string
        :return: integer, number of checked paths
        """
        count = sum((1 for x in self.checked_paths
                     if self.is_child_directory(x, path)))

        return count

    def reloadFileSystemInfo(self):
        """Updates the file system info for each element.
        """
        for fs in self.file_system.values():
            try:
                fs.update()
            except FileSystemRecursionException as e:
                self._setRootPathMessage(
                    self.trUtf8(
                        "Configured base path has too many files (> {})".
                        format(self.config.get('max_file_system_objects',
                                               1000))))

    def refreshClicked(self):
        self.reloadFileSystemInfo()
        self.refreshButtonClicked.emit()

    @pyqtSlot(QtGui.QTreeWidgetItem, int)
    def _treeitem_doubleclicked(self, item, column):
        """
        Triggered on a doubleclick event of a Tree Widget.
        """
        if item.fileitem.isdir:
            return
        newState = Qt.Checked if item.checkState(
            column) == Qt.Unchecked else Qt.Unchecked
        item.setCheckState(column, newState)

    @pyqtSlot(QtGui.QTreeWidgetItem, int)
    def _treeitem_changed(self, item, column):
        """
        Triggered on a change event of a Tree Widget.
        """
        checked = item.checkState(column) == Qt.Checked
        path = item.fullpath
        if checked:
            # Dont try to turn on a non-existing qlr
            if not self._checkFileItemExists(path):
                # Path no longer exists. Reload filesystem
                self.reloadFileSystemInfo()
                return
        self.setPathCheckState(path, checked)
        self.itemStateChanged.emit(item.fileitem, checked)

    def _updateTree(self, filter_path=None):
        """
        Updates tree display
        :filter_path , string, Optionally only the branch which includes filter_path
        """
        iterator = QtGui.QTreeWidgetItemIterator(self.treeWidget)
        item = iterator.value()
        while item:
            # Skip if we only need to update part of tree
            if not filter_path or filter_path.startswith(item.fullpath):
                # checked sub paths
                if item.fileitem.isdir:
                    num = self.getNumCheckedSubPaths(item.fullpath)
                    item.setSubChecked(num)
                # checked
                checked = self.getIsPathChecked(item.fullpath)
                item.setCheckState(0,
                                   Qt.Unchecked if not checked else Qt.Checked)
            iterator += 1
            item = iterator.value()

    def _fillTree(self):
        """
        Fills the tree with items.
        """
        if len(self.root_paths) < 1:
            self._setRootPathMessage(
                self.trUtf8("No base directory configured..."))
            return

        self.treeWidget.clear()

        for basepath in self.root_paths:
            fileitem = self._filteredFileItems(basepath)
            if fileitem:
                baseTreeItem = self._createWidgetItem(fileitem)
                self._fillTreeRecursively(baseTreeItem, fileitem)
                self.treeWidget.addTopLevelItem(baseTreeItem)
                baseTreeItem.setExpanded(True)
        if self.filterLineEdit.text().strip():
            self._expandTree()

    def _expandTree(self):
        """
        Expands the tree.
        """
        iterator = QtGui.QTreeWidgetItemIterator(self.treeWidget)
        item = iterator.value()
        while item:
            if item.fileitem.matches(self.filterLineEdit.text().strip()):
                tmpitem = item
                while tmpitem:
                    tmpitem.setExpanded(True)
                    tmpitem = tmpitem.parent()
            else:
                item.setExpanded(False)
            iterator += 1
            item = iterator.value()

    def _filteredFileItems(self, basepath):
        """
        Returns the filtered items of the basepath.
        :basepath: string
        """
        # For now just return unfiltered
        fs = self.file_system[basepath]
        filterText = self.filterLineEdit.text().strip()
        if filterText:
            return fs.rootitem.filtered(filterText)
        else:
            return fs.rootitem

    def _fillTreeRecursively(self, baseWidgetItem, baseFileItem):
        """
        Fills a baseWidgetItem into the baseFileItem
        """
        if not baseFileItem.isdir:
            return
        for child in baseFileItem.children:
            childTreeItem = self._createWidgetItem(child)
            if child.isdir:
                self._fillTreeRecursively(childTreeItem, child)
            baseWidgetItem.addChild(childTreeItem)

    def _createWidgetItem(self, fileitem):
        """
        Creates a widget item from a file item.
        """
        checked = self.getIsPathChecked(fileitem.fullpath)
        num_checked_sub_paths = 0
        if fileitem.isdir:
            num_checked_sub_paths = self.getNumCheckedSubPaths(
                fileitem.fullpath)
        return TreeWidgetItem(fileitem, checked, num_checked_sub_paths)

    def _checkFileItemExists(self, path):
        """
        Returns true if a path exists.
        :path string
        :returns boolean
        """
        if os.path.exists(path):
            return True
        else:
            self.iface.messageBar().pushMessage(
                self.trUtf8("Qlr Browser Error"),
                self.trUtf8("The selected path does not exist anymore"),
                level=QgsMessageBar.CRITICAL)
            return False

    def _setRootPathMessage(self, message):
        self.treeWidget.clear()
        baseTreeItem = QtGui.QTreeWidgetItem([message])
        font = baseTreeItem.font(0)
        font.setItalic(True)
        baseTreeItem.setFont(0, font)
        self.treeWidget.addTopLevelItem(baseTreeItem)

    #
    # Events
    #
    def closeEvent(self, event):
        self.closingPlugin.emit()
        event.accept()

    def is_child_directory(self, child_dir, parent_dir):
        """
        Returns true if child_dir is inside parent_dir.
        :param child_dir
        :param parent_dir
        :return: boolean
        """
        parent_dir = os.path.join(os.path.realpath(parent_dir), '')
        child_dir = os.path.realpath(child_dir)
        return os.path.commonprefix([child_dir, parent_dir]) == parent_dir
Beispiel #8
0
def iconFromPath(path):
    fileInfo = QtCore.QFileInfo(path)
    iconProvider = QtGui.QFileIconProvider()
    icon = iconProvider.icon(fileInfo)

    return icon
Beispiel #9
0
 def icon(self):
     provider = QtGui.QFileIconProvider()
     return provider.icon(QtGui.QFileIconProvider.Drive)
Beispiel #10
0
 def icon(self):
     provider = QtGui.QFileIconProvider()
     if self.prefix == "url-datasets":
         return provider.icon(QtGui.QFileIconProvider.Network)
     return provider.icon(QtGui.QFileIconProvider.Drive)