Пример #1
0
class DialogNodeBrowser(QDialog):
    def __init__(self, parent=None):
        QDialog.__init__(self, parent)
        self.title = QLabel("Select a node in the Virtual File System :")
        self.vfs = vfs.vfs()
        self.VFS = VFS.Get()
        self.createLayout()
        self.createModels()
        self.createViews()
        self.createButtons()


    def createLayout(self):
        self.navBar = NavigationBar(self)
        self.baseLayout = QVBoxLayout(self)
        self.baseLayout.setMargin(0)
        self.baseLayout.setSpacing(0)
        self.splitterLayout = QSplitter(self)
        self.splitterLayout.setMinimumWidth(640)
        self.baseLayout.addWidget(self.navBar, 1)
        self.baseLayout.addWidget(self.splitterLayout, 50)
        self.setLayout(self.baseLayout)


    def createModels(self):
        self.treeModel = TreeModel(self)
        # self.treeModel.coord = True
        self.tableModel = VFSItemModel(self)
        self.treeModel.setRootPath(self.vfs.getnode("/"))
        self.tableModel.setRootPath(self.vfs.getnode("/"))
        self.tableModel.connect(self.navBar, SIGNAL("pathChanged"), self.tableModel.setRootPath)


    def createViews(self):
        self.treeView = NodeLinkTreeView(self)
        self.treeView.setModel(self.treeModel)

        self.connect(self.treeView, SIGNAL("nodeTreeClicked"), self.nodeTreeClicked)
        self.splitterLayout.addWidget(self.treeView)

        self.tableView = NodeTableView(self)
        self.tableView.setModel(self.tableModel)
        self.connect(self.tableView, SIGNAL("nodeDoubleClicked"), self.nodeDoubleClicked)
        self.splitterLayout.addWidget(self.tableView)


    def nodeTreeClicked(self, mouseButton, node, index = None):
        self.treeView.model().setRootPath(node)
        self.tableView.model().setRootPath(node)
        

    def nodeDoubleClicked(self, mouseButton, node, index = None):
        if node == None:
            return
        if node.hasChildren() or node.isDir():
            self.tableView.model().setRootPath(node)
            self.navBar.updateCurrentPath(node)


    def createButtons(self):
        self.buttonBox = QDialogButtonBox()
        self.buttonBox.setStandardButtons(QDialogButtonBox.Cancel|QDialogButtonBox.Ok)
        self.connect(self.buttonBox, SIGNAL("accepted()"),self.accept)
        self.connect(self.buttonBox, SIGNAL("rejected()"),self.reject)
        self.baseLayout.addWidget(self.buttonBox)
        

    def getSelectedNodes(self):
        indexes = self.tableView.selectionModel().selectedRows()
        nodes = []
        for index in indexes:
            if index.isValid():
                nodes.append(self.VFS.getNodeFromPointer(index.internalId()))
        return nodes


    def getSelectedNode(self):
        index = self.tableView.selectionModel().currentIndex()
        node = None
        if index.isValid():
            node = self.VFS.getNodeFromPointer(index.internalId())
        return node


    def setSelectionMode(self, mode):
        self.tableView.setSelectionMode(mode)


    def changeEvent(self, event):
        """ Search for a language change event
        
        This event have to call retranslateUi to change interface language on
        the fly.
        """
        if event.type() == QEvent.LanguageChange:
            self.model.translation()
        else:
            QWidget.changeEvent(self, event)
Пример #2
0
class ModifIndex(QDialog, Ui_ModifIndex):
    """
    This class is used to graphically configures indexation :
    * its content
    * its behaviour and the type of data which musts be indexed
    
    It is composed of three tabs : Index, Advanced and Attributes.

    The `Index` tab us composed of two main widgets :
    * a NodeLinkTreeView, called `selectIndexItems`, connected to an instance
    of a TreeModel (see api.gui.model.vfsitemmodel, class TreeModel
    and api.gui.widget.nodeview, class NodeLinkTreeView).

    It displays the tree view of the VFS' nodes, with checkboxes used to select
    nodes the user wants to add in the index.

    * a QTableWidget, called `indexedItems`,  used to summarize the list of
    already indexed nodes.

    By checking / unchecking a nodes in the NodeLinkTreeView, it adds / removes
    elements in the `indexedItems` view. If an element is unchecked and the `OK`
    button clicked, the element will be removed from the index. On the contrary,
    if an element is checked in the NodeLinkTreeView and the `OK` button clicked,
    it will add it in the index ONLY if it was not already indexed.

    Changed are applied when the `OK` button is clicked.
    """
    def __init__(self, parent, model):
        """
        Constructor.

        Initialize parent, gui and translation. Connect signals.
        """
        super(QDialog, self).__init__()
        self.parent = parent
        self.setupUi(self)
        self.translation()

        self.initTableWidget()
        self.initMimeTypes()

        self.indexed_items = {}
        self.tmp_indexed_items = {}
        self.un_index = {}

        self.indexedItems.setColumnCount(2)
        self.indexedItems.setRowCount(self.load_items())
        self.model = TreeModel(self)
        self.model.root_item = model.root_item
        self.model.setCh(True)

        self.selectIndexItems = NodeLinkTreeView(None, True)
        self.selectIndexItems.setModel(self.model)
        vbox = QVBoxLayout()
        vbox.addWidget(self.selectIndexItems)
        self.groupBox_5.setLayout(vbox)
        self.connect(self.selectIndexItems, SIGNAL("nodeTreeClicked"), self.nodeTreeClicked)
        self.connect(self.selectIndexItems.model(), SIGNAL("stateChanged"), self.selectNodeChanged)
        self.connect(self.indexedItems, SIGNAL("itemChanged(QTableWidgetItem *)"), \
                         self.IAmBabarTheElephantKing)
        self.connect(self.indexedItems, SIGNAL("itemClicked"), self.IAmBabarTheElephantKing)

    def initTableWidget(self):
        """
        Initialize the QTableWidget `indexedItems`. Set the headers.
        """
        self.indexedItems.setColumnCount(2)

        # set the headers' titles and stretch the last section
        head1 = QTableWidgetItem(self.headIndexedItemTr)
        head2 = QTableWidgetItem(self.headRecursivelyTr)
        self.indexedItems.setHorizontalHeaderItem(0, head1)
        self.indexedItems.setHorizontalHeaderItem(1, head2)
        self.indexedItems.horizontalHeader().setStretchLastSection(True)

        # hide vertical header and grid, remove editable mode
        self.indexedItems.verticalHeader().hide()
        self.indexedItems.setEditTriggers(QAbstractItemView.NoEditTriggers)
        self.indexedItems.setShowGrid(False)
        self.indexedItems.setAlternatingRowColors(True)
        self.indexedItems.setSelectionBehavior(QAbstractItemView.SelectRows)

    def load_items(self):
        """
        Load items from the indexed_items list and add them in the
        self.indexedItems QTableWidget.
        """
        count = 0

        # get the list of already indexed stuff and add them in the qtablewidget
        # with a not-editable check box indicating if it has been indexed
        # recursively or not
        for i in self.indexed_items:
            node = VFS.Get().getNodeFromPointer(long(i))
            if node == None:
                continue
            recurse = self.indexed_items[i]

            new_item = QTableWidgetItem(QIcon(":/folder.png"), node.name())
            self.indexedItems.setRowCount(count + 1)
            new_item.setData(Qt.UserRole + 1, QVariant(long(node.this)))

            self.indexedItems.setItem(count, 0, new_item)

            new_item2 = QTableWidgetItem()
            new_item2.setFlags(Qt.ItemIsUserCheckable)
            if recurse:
                new_item2.setCheckState(Qt.Checked)
            else:
                new_item2.setCheckState(Qt.Unchecked)
            self.indexedItems.setItem(count, 1, new_item2)
            count += 1
        return count

    def initMimeTypes(self):
        self.typesTree = MimeTypesTree(self.mimeTypeList)
        self.mimeTypeList.setHeaderLabels([self.mimeTypeTr])

    def selectNodeChanged(self, index):
        """
        This slot is called when a node is checked / unchecked. Then, the method
        `addNodeInIndexList` or `removeNodeFromIndexList` is called (of course 
        depending if it was checked of unchcked).
        """
        if not index.isValid():
            return
        d = self.selectIndexItems.model().data(index, Qt.CheckStateRole)
        if d == Qt.Checked:
            self.addNodeInIndexList(index)
        else:
            self.removeNodeFromIndexList(index)

    def addNodeInIndexList(self, index):
        """
        Add the node wich pointer is index.data(QT.UserRole + 1) in the
        indexedItems list.
        """
        # get the node from the index
        node_ptr = self.selectIndexItems.model().data(index, Qt.UserRole + 1)
        if not node_ptr.isValid():
            return
        added_node = VFS.Get().getNodeFromPointer(node_ptr.toULongLong()[0])

        # add the node.this into the selected items list
        new_item = QTableWidgetItem(QIcon(":/folder.png"), added_node.name())
        new_item.setData(Qt.UserRole + 1, QVariant(long(added_node.this)))
        self.tmp_indexed_items[long(added_node.this)] = False

        new_checkbox = QTableWidgetItem(1);
        new_checkbox.data(Qt.CheckStateRole);
        new_checkbox.setCheckState(Qt.Unchecked);

        self.indexedItems.insertRow(0)
        self.indexedItems.setItem(0, 0, new_item)
        self.indexedItems.setItem(0, 1, new_checkbox)

    def IAmBabarTheElephantKing(self, item):
        if item.column() == 0:
            return
        row = item.row()
        item_check = self.indexedItems.itemAt(row, 0)
        data = item_check.data(Qt.UserRole + 1)
        if not data.isValid():
            return
        ptr = data.toULongLong()[0]
        try:
            self.tmp_indexed_items[long(ptr)] = not self.tmp_indexed_items[long(ptr)]
        except KeyError:
            pass

    def removeNodeFromIndexList(self, index):
        """
        Remove the node wich pointer is index.data(QT.UserRole + 1) from the
        indexedItems list.
        """
        # get the node from the index (if one of them is invalid, returns)
        if not index.isValid():
            return
        node_ptr = self.selectIndexItems.model().data(index, Qt.UserRole + 1)
        if not node_ptr.isValid():
            return

        # get the ptr of the node and search for the it in the indexedItems list
        ptr = node_ptr.toULongLong()[0]

        # for each items in the indexed_list, check if the value is equal to
        # `ptr`. If yes, remove the item from the QTableWidget self.indexedItems.
        found = False
        for i in range(0, len(self.indexed_items)):
            item = self.indexedItems.item(i, 0)
            if item != None:
                value = item.data(Qt.UserRole + 1)
                if value.isValid():
                    if value.toULongLong()[0] == ptr:
                        self.indexedItems.removeRow(i)
                        self.un_index[ptr] = self.indexed_items[ptr]
                        found = True
                        break

        if not found:
            for i in range(0, len(self.tmp_indexed_items)):
                item = self.indexedItems.item(i, 0)
                if item != None:
                    value = item.data(Qt.UserRole + 1)
                    if value.isValid():
                        if value.toULongLong()[0] == ptr:
                            self.indexedItems.removeRow(i)
                            break

        # finally pop the item from the indexed_items or tmp_indexed_items map
        try:
            if not found:
                self.tmp_indexed_items.pop(ptr)                
        except KeyError:
            pass

    def nodeTreeClicked(self, mouseButton, node, index = None):
        """
        This slot is called when a node from the NodeLinkTreeView is clicked.
        """
        self.selectIndexItems.model().setRootPath(node)

    def translation(self):
        """
        Used for the dynamic translations.
        """
        self.headIndexedItemTr = self.tr("Indexed items")
        self.headRecursivelyTr = self.tr("Recursively")
        self.mimeTypeTr = self.tr("Mime types")