Python PyQt4.QtGui 模块，QTreeWidgetItem() 实例源码

def setSdrRoot(self, sdrroot):
        self.nodeTreeWidget.clear()
        nodepath = os.path.join(sdrroot, 'dev/nodes/*/DeviceManager.dcd.xml')
        for dcdfile in glob.glob(nodepath):
            try:
                node = dcd.parse(dcdfile)
                name = node.get_name()
                domain = node.get_domainmanager().get_namingservice().get_name()
                domain = domain.split('/')[-1]
                dcdfile = dcdfile.replace(os.path.join(sdrroot,'dev'), '')
                # Add the node to the tree widget, including the default domain
                # as a hidden column
                QtGui.QTreeWidgetItem(self.nodeTreeWidget, [name, dcdfile, domain])
            except:
                pass
        # Readjust the column widths to ensure that the entire name is shown
        # and that the scollbar allows viewing the entire DCD filename
        self.nodeTreeWidget.resizeColumnToContents(0)
        self.nodeTreeWidget.resizeColumnToContents(1)

        # Sort alphabetically by name
        self.nodeTreeWidget.sortByColumn(0, 0)

def __updateTree(self, className, baseClass, methods, overloadMethItem):

        overloadMethItem.takeChildren()

        exec('import '+ className)
        classPtr = eval(className+'.'+className)

        for m in methods:
            isKnown = False
            i = 0
            while not isKnown and i < overloadMethItem.childCount():
                if m == overloadMethItem.child(i).text(0):
                    isKnown = True
                i += 1
            if not isKnown:
                if self.originalClassMethod(m, classPtr) == baseClass:
                    newItem = QtGui.QTreeWidgetItem(overloadMethItem)
                    newItem.setText(0, m)

def updateXSS(self,list):
        if not list:
            return
        for i in list:
            target=QtCore.QStringList()
            target.append(i[0])
            targetTree=QtGui.QTreeWidgetItem(target)
            self.treeXss.addTopLevelItem(targetTree)
            for j in i[1]:
                target2=QtCore.QStringList()
                target2.append("")
                target2.append(j[2])
                target2.append(j[1])
                str=""
                for l in j[3]:
                    str+=l+"\r\n"
                target2.append(str)

                targetTree2=QtGui.QTreeWidgetItem(target2)
                targetTree.addChild(targetTree2)

def updateSQLResults(self,list):
        if not list:
            return
        for i in list:
            target=QtCore.QStringList()
            target.append(i[0])
            targetTree=QtGui.QTreeWidgetItem(target)
            self.treeSql.addTopLevelItem(targetTree)
            for j in i[1]:
                target2=QtCore.QStringList()
                target2.append("")
                for k in j:
                    if k:
                        target2.append(k)
                    else:
                        target2.append("")
                targetTree2=QtGui.QTreeWidgetItem(target2)
                targetTree.addChild(targetTree2)
            pass

def _build_tree(self, tree_wdgt, tree_def, root):
        parent, children = tree_def.items()[0]

        # empty label /parent is a special case: either inline with the previous, or skip
        if parent == "":
            if isinstance(children, QWidget):
                item = root
                tree_wdgt.setItemWidget(item, 1, children)

            elif isinstance(children, list):
                for c in children:
                    self._build_tree(tree_wdgt, c, root)

        elif parent == "set_expanded":  # a configuration item for the current root
            root.setExpanded(children)
        else:
            item = QTreeWidgetItem(root)
            item.setText(0, parent)

            if isinstance(children, list):
                for c in children:
                    self._build_tree(tree_wdgt, c, item)
            else:
                tree_wdgt.setItemWidget(item, 1, children)

def removeItem(self):

        """Removes item from right list."""

        # Get selection
        self.getRightSelections()

        # Check selection
        if self.rightList.currentItem()==None or self.rightList.currentItem().parent()==None:
            QtGui.QMessageBox.critical(None, "Error","No fit selected.",QtGui.QMessageBox.Ok | QtGui.QMessageBox.Default)
            return
        else:

            # Remove
            ind=self.currEmbryoNode.indexOfChild(self.rightList.currentItem())
            self.currEmbryoNode.takeChild(ind)
            self.fitsInRightList.remove(self.currFit)

            # Add to left list
            self.getLeftInd(embryoName=self.currFit.embryo.name)
            QtGui.QTreeWidgetItem(self.currTargetEmbryoNode,[self.currFit.name])

def updateIncludedList(self):
        self.includedList.clear()
        for i,roi in enumerate(self.ROI.ROIsIncluded):

            if self.ROI.procedures[i]==1:
                op='+'
            elif self.ROI.procedures[i]==-1:
                op='-'
            else:
                op=' '
                printWarning('Unknown procedure ' + str(roi.procedures[i]))

            item=QtGui.QTreeWidgetItem(self.includedList,[roi.name,op])
            item.setBackgroundColor(0,self.getQColor(roi.color))
            item.setBackgroundColor(1,self.getQColor(roi.color))

        self.updateAxes()       

        return self.includedList

def newScreen(self):
        item = self.treeview_params.currentItem()

        if not item:
            self.logview.append("<font color=red>" + _("Please select a category before creating new screen") + "</font>")
            return

        if item.parent() is not None:
            item = item.parent()

        category = unicode(item.text(0).toUtf8(), encoding="UTF-8")
        nsn = gui.QInputDialog.getText(self, 'DDT4All', _('Enter screen name'))

        if not nsn[1]:
            return

        newscreenname = unicode(nsn[0].toUtf8(), encoding="UTF-8")
        if newscreenname:
            self.paramview.createScreen(newscreenname, category)

            item.addChild(gui.QTreeWidgetItem([newscreenname]))
            self.screennames.append(newscreenname)

def DataToTree(self, tree, cur_node, data, filter=''):
        node_info = data[0]
        node_info_child = data[1]
        [cur_node.setText(i, node_info[i]) for i in range(len(node_info))]
        target = re.compile(filter, re.IGNORECASE)
        for sub_data in node_info_child:
            if filter == '':
                new_node = QtWidgets.QTreeWidgetItem()
                cur_node.addChild(new_node)
                self.DataToTree(tree, new_node, sub_data)
            else:
                if not target.search(sub_data[0][0]) and not self.DataChildCheck(sub_data[1], filter):
                    pass
                else:
                    new_node = QtWidgets.QTreeWidgetItem()
                    cur_node.addChild(new_node)
                    new_node.setExpanded(1)
                    self.DataToTree(tree, new_node, sub_data, filter)

def DataToTree_old_2LevelSearch(self, tree, cur_node, data, filter=''):
        node_info = data[0]
        node_info_child = data[1]
        [cur_node.setText(i, node_info[i]) for i in range(len(node_info))]
        target = re.compile(filter, re.IGNORECASE)
        for sub_data in node_info_child:
            if filter == '':
                new_node = QtWidgets.QTreeWidgetItem()
                cur_node.addChild(new_node)
                self.DataToTree(tree, new_node, sub_data)
            else:
                if not target.search(sub_data[0][0]) and len(sub_data[1]) == 0:
                    #print(sub_data[0][0]) print(sub_data[1])
                    pass    
                else:
                    new_node = QtWidgets.QTreeWidgetItem()
                    cur_node.addChild(new_node)
                    new_node.setExpanded(1)
                    self.DataToTree(tree, new_node, sub_data, filter)

def DataToTree(self, tree, cur_node, data, filter=''):
        node_info = data[0]
        node_info_child = data[1]
        [cur_node.setText(i, node_info[i]) for i in range(len(node_info))]
        target = re.compile(filter, re.IGNORECASE)
        for sub_data in node_info_child:
            if filter == '':
                new_node = QtWidgets.QTreeWidgetItem()
                cur_node.addChild(new_node)
                self.DataToTree(tree, new_node, sub_data)
            else:
                if not target.search(sub_data[0][0]) and not self.DataChildCheck(sub_data[1], filter):
                    pass
                else:
                    new_node = QtWidgets.QTreeWidgetItem()
                    cur_node.addChild(new_node)
                    new_node.setExpanded(1)
                    self.DataToTree(tree, new_node, sub_data, filter)

def DataToTree_old_2LevelSearch(self, tree, cur_node, data, filter=''):
        node_info = data[0]
        node_info_child = data[1]
        [cur_node.setText(i, node_info[i]) for i in range(len(node_info))]
        target = re.compile(filter, re.IGNORECASE)
        for sub_data in node_info_child:
            if filter == '':
                new_node = QtWidgets.QTreeWidgetItem()
                cur_node.addChild(new_node)
                self.DataToTree(tree, new_node, sub_data)
            else:
                if not target.search(sub_data[0][0]) and len(sub_data[1]) == 0:
                    #print(sub_data[0][0]) print(sub_data[1])
                    pass    
                else:
                    new_node = QtWidgets.QTreeWidgetItem()
                    cur_node.addChild(new_node)
                    new_node.setExpanded(1)
                    self.DataToTree(tree, new_node, sub_data, filter)

def DataToTree(self, tree, cur_node, data, filter=''):
        node_info = data[0]
        node_info_child = data[1]
        [cur_node.setText(i, node_info[i]) for i in range(len(node_info))]
        target = re.compile(filter, re.IGNORECASE)
        for sub_data in node_info_child:
            if filter == '':
                new_node = QtWidgets.QTreeWidgetItem()
                cur_node.addChild(new_node)
                self.DataToTree(tree, new_node, sub_data)
            else:
                if not target.search(sub_data[0][0]) and not self.DataChildCheck(sub_data[1], filter):
                    pass
                else:
                    new_node = QtWidgets.QTreeWidgetItem()
                    cur_node.addChild(new_node)
                    new_node.setExpanded(1)
                    self.DataToTree(tree, new_node, sub_data, filter)

def add_scan(self):
        mass = int(self.scan_table.item(0,0).text())
        discriminator_level = int(self.scan_table.item(0,1).text())
        current = int(self.scan_table.item(0,2).text())
        filament_state = int(self.scan_table.item(0,3).text())
        filament_voltage = int(self.scan_table.item(0,4).text())
        records_per_scan = int(self.scan_table.item(0,5).text())

        parameter_list = [mass, discriminator_level, current, filament_state, filament_voltage, records_per_scan]
        if len(self.experiment_tree.selectedItems())>0:
            selected_item = self.experiment_tree.selectedItems()[0]
            parent = selected_item.parent()
            item = QtGui.QTreeWidgetItem()
            item.setFlags(item.flags() | QtCore.Qt.ItemIsEditable)
            item.setText(0,str(parameter_list))
            if parent == None:
                selected_item.addChild(item)
                self.experiment_tree.expandItem(selected_item)
            else:
                index = parent.indexOfChild(selected_item)
                parent.insertChild(index, item)
                self.experiment_tree.expandItem(parent)
        else:
            print 'No datarun selected.'
        yield None

def addPropertyAndValueUnderInstanceToTreeWidgetSummary(instance_x, property_x, value_x, tree_owner):
    # Find parent instance widget
    parent_instance_level = tree_owner.ui.treeWidgetSummary.findItems(getPhraseWithPrefix(instance_x), QtCore.Qt.MatchExactly, 0)[0]

    # Create tree item
    property_level = QTreeWidgetItem()

    property_x = str(getPhraseWithPrefix(property_x))
    property_level.setText(0, property_x)
    property_level.setText(1, value_x)
    property_level.setToolTip(0, "<b>Property:</b><br> " + property_x + " <br><b>Value:</b><br> " + value_x)
    property_level.setToolTip(1, "<b>Property:</b><br> " + property_x + " <br><b>Value:</b><br> " + value_x)

    # Set icons
    property_level.setIcon(0, tree_owner.property_icon)
    property_level.setIcon(1, tree_owner.value_icon)

    # If an annotation property
    if property_x == getPhraseWithPrefix('http://www.w3.org/2002/07/owl#sameAs') or property_x == getPhraseWithPrefix('http://www.w3.org/2000/01/rdf-schema#seeAlso') or property_x == getPhraseWithPrefix('http://www.w3.org/2000/01/rdf-schema#label'):
        property_level.setIcon(0, tree_owner.annotation_icon)

    parent_instance_level.addChild(property_level)

def __init__(self,*args,**kwargs):
        super().__init__(*args,**kwargs)
        self.header().close()
        self.model = None
        self.texture_list = QtGui.QTreeWidgetItem(['Textures'])
        self.addTopLevelItem(self.texture_list)
        self.currentItemChanged.connect(self.on_currentItemChanged)

def __createCatTree(self, currentCat, currentParamTreeItem):
        for cat, subcats in currentCat.items():
            newCat = QtGui.QTreeWidgetItem(currentParamTreeItem)
            newCat.setText(0, cat)
            if type(subcats) == type({}):
                self.__createCatTree(subcats, newCat)
            else:
                newCat.setText(1, str(subcats))
                flags = newCat.flags()
                newCat.setFlags(flags|QtCore.Qt.ItemIsEditable)

def updateVarStatsTree(self):
        self.varStatsTreeWidget.clear()
        self.varStatsTreeWidget.headerItem().setText(0,QtGui.QApplication.translate("MainWindow", "Variable", None, QtGui.QApplication.UnicodeUTF8))
        self.varStatsTreeWidget.headerItem().setText(1,QtGui.QApplication.translate("MainWindow", "Values", None, QtGui.QApplication.UnicodeUTF8))

        variableStats=self.controller.getVariableStats()
        sort1=variableStats.keys()
        sort1.sort()
        for tg in sort1:
            target=QtCore.QStringList()
            target.append(tg)
            targetTree=QtGui.QTreeWidgetItem(target)
            self.varStatsTreeWidget.addTopLevelItem(targetTree)
            sort2=variableStats[tg].keys()
            sort2.sort()
            for pt in sort2:
                path=QtCore.QStringList()
                path.append(pt)
                pathTree=QtGui.QTreeWidgetItem(path)
                pathTree.setTextColor(0,QtGui.QColor(0,0,200))
                font=pathTree.font(0)
                font.setBold(True)
                pathTree.setFont(0,font)
                targetTree.addChild(pathTree)
                sort3=variableStats[tg][pt].keys()
                sort3.sort()
                for vr in sort3:
                    variable=QtCore.QStringList()
                    variable.append(vr)
                    values=""                   
                    for vls in variableStats[tg][pt][vr].keys():
                        values+=urllib.unquote(vls)+"\n"
                    variable.append(values)
                    variableTree=QtGui.QTreeWidgetItem(variable)
                    pathTree.addChild(variableTree)

def updateReqStatsTree(self):
        self.reqStatsTreeWidget.clear()
        self.reqStatsTreeWidget.headerItem().setText(0,QtGui.QApplication.translate("MainWindow", "Request", None, QtGui.QApplication.UnicodeUTF8))
        self.reqStatsTreeWidget.headerItem().setText(1,QtGui.QApplication.translate("MainWindow", "Variable set", None, QtGui.QApplication.UnicodeUTF8))

        reqStats=self.controller.getReqStats()
        sort1=reqStats.keys()
        sort1.sort()
        for tg in sort1:
            target=QtCore.QStringList()
            target.append(tg)
            targetTree=QtGui.QTreeWidgetItem(target)
            self.reqStatsTreeWidget.addTopLevelItem(targetTree)
            sort2=reqStats[tg].items()
            sort2.sort()
            for k,l in sort2:
                path=QtCore.QStringList()
                path.append(k)
                sets=""
                for set in l:
                    sets+=join(set[0],',')+'\n'
                path.append(sets)
                pathTree=QtGui.QTreeWidgetItem(path)
                pathTree.setTextColor(0,QtGui.QColor(0,0,200))
                font=pathTree.font(0)
                font.setBold(True)
                pathTree.setFont(0,font)
                targetTree.addChild(pathTree)

def updateFitsNodeChildren(self):

        currEmbryo=self.getCurrentEmbryo()
        currEmbryoNode=self.getCurrentEmbryoNode()
        if currEmbryoNode!=None:
            fitsNode=self.getChildByName(currEmbryoNode,'Fits')
            self.removeAllNodeChildren(fitsNode)
            for fit in currEmbryo.fits:
                newFitNode=QtGui.QTreeWidgetItem(fitsNode,[fit.name,'','',str(int(fit.isFitted()))])
        self.getCurrentObjNode()
        return newFitNode

def updateROIsNodeChildren(self):

        currEmbryo=self.getCurrentEmbryo()
        currEmbryoNode=self.getCurrentEmbryoNode()
        if currEmbryoNode!=None:
            roisNode=self.getChildByName(currEmbryoNode,'ROIs')
            self.removeAllNodeChildren(roisNode)
            for roi in currEmbryo.ROIs:
                newROINode=QtGui.QTreeWidgetItem(roisNode,[roi.name,str(int(roi.isAnalyzed())),str(int(roi.isSimulated())),str(int(roi.isFitted()))])
        self.getCurrentObjNode()

def newMolecule(self):

        #Generate name
        moleculeNames=pyfrp_misc_module.objAttrToList(self.molecules,"name")
        newName=pyfrp_misc_module.enumeratedName("newMolecule",moleculeNames,sep="_")

        #Create new molecule object
        mol=pyfrp_molecule.molecule(newName)
        pyfrp_gui_molecule_dialogs.moleculeDialog(mol,self).exec_()

        #Make current molecule
        self.currMolecule=mol

        #Add new molecule to list of embryos
        self.molecules.append(mol)

        #Add to objectBar
        self.currNode=QtGui.QTreeWidgetItem(self.objectBar,[self.currMolecule.name])

        #Memorize molecule node
        self.currMoleculeNode=self.currNode

        #Highligth new node
        self.highlightCurrentObjectNode()

        #Show molecule properties
        self.updatePropBar()

        #Check if names are alright
        self.checkObjNames()

        return self.currMolecule

    #---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
    #Edit Molecule

def openMolecule(self,fnLoad):

        #Memorize last path and append to recently opened
        self.lastopen=os.path.dirname(str(fnLoad))
        self.appendRecent(fnLoad)

        #Load molecule object
        self.currMolecule=pyfrp_IO_module.loadFromPickle(fnLoad)

        #Update Version
        self.currMolecule.updateVersion()

        #Add molecule to list of molecules
        self.molecules.append(self.currMolecule)

        #Adding molecule to sidebar
        self.currNode=QtGui.QTreeWidgetItem(self.objectBar,[self.currMolecule.name,"","",""])
        self.currMoleculeNode=self.currNode

        for embryo in self.currMolecule.embryos:
            self.embryo2ObjectBar(embryo,self.currMoleculeNode)

        self.objectBar.expandItem(self.currNode)

        self.checkObjNames()

        return self.currMolecule

    #---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
    #Embryo handling
    #---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

def initLeftList(self):

        self.getListDifference()

        for item in self.itemsLeft:
            QtGui.QTreeWidgetItem(self.leftList,[item])

def initRightList(self):

        for item in self.itemsRight:
            QtGui.QTreeWidgetItem(self.rightList,[item])

def addItem(self):

        #Determine selected item
        self.currentItem=str(self.leftList.currentItem().data(0,0).toString())

        #Insert new node in right list
        newNode=QtGui.QTreeWidgetItem(self.rightList,[self.currentItem])

        #Remove node in left list
        self.currLeftInd=self.leftList.indexFromItem(self.leftList.currentItem()).row()
        self.leftList.takeTopLevelItem(self.currLeftInd)

        self.itemsRight.append(self.currentItem)
        self.itemsLeft.remove(self.currentItem)

def removeItem(self):

        #Determine selected item
        self.currentItem=str(self.rightList.currentItem().data(0,0).toString())

        #Insert new node in left list
        newNode=QtGui.QTreeWidgetItem(self.leftList,[self.currentItem])

        #Remove node in right list
        self.currRightInd=self.rightList.indexFromItem(self.rightList.currentItem()).row()
        self.rightList.takeTopLevelItem(self.currRightInd)

        self.itemsRight.remove(self.currentItem)
        self.itemsLeft.append(self.currentItem)

def initLeftList(self):

        """Sets up left list of selector."""

        for emb in self.molecule.embryos:   

            self.currEmbryoNode=QtGui.QTreeWidgetItem(self.leftList,[emb.name])

            for fit in emb.fits:
                if fit.isFitted():
                    if fit not in self.molecule.selFits:
                        QtGui.QTreeWidgetItem(self.currEmbryoNode,[fit.name])

            self.leftList.expandItem(self.currEmbryoNode)

def updateROIList(self):

        self.ROIList.clear()
        for r in self.fit.ROIsFitted:
            QtGui.QTreeWidgetItem(self.ROIList,[r.name])
        return self.ROIList

def updateROIList(self):

        self.ROIList.clear()
        for r in self.embryo.ROIs:
            QtGui.QTreeWidgetItem(self.ROIList,[r.name,r.getType()])
        return self.ROIList

def updateCornerList(self):
        self.cornerList.clear()
        for corner in self.ROI.corners:
            QtGui.QTreeWidgetItem(self.cornerList,[str(corner[0]),str(corner[1])])
        return self.cornerList

def makeTreeView(self):
        file_list = self.sync_object.ListFolder('root')
        print(file_list)
        self.root = QtGui.QTreeWidgetItem(self.ui.treeWidget, ["root"])
        # self.treeWidget.
        self.populateTreeWidget(file_list,self.root)

def populateTreeWidget(self,file_list,parent):
        for element in file_list:
            if type(element) is dict:
                a = QtGui.QTreeWidgetItem(parent,[str(element["title"])])
                if len(element["list"]) > 0 :
                    self.populateTreeWidget(element["list"],a)
            else :
                a = QtGui.QTreeWidgetItem(parent,[str(element)])

def rebuild(self):
        self.clear()
        for i in xrange(len(Mainframe.model.entries)):
            newItem = QtGui.QTreeWidgetItem()
            for j, text in enumerate(self.createItem(i)):
                newItem.setText(j, text)
            self.addTopLevelItem(newItem)
        self.skip_model_changed = True
        self.setCurrentItem(self.topLevelItem(Mainframe.model.current))

def insertItem(self, idx):
        newItem = QtGui.QTreeWidgetItem()
        for j, text in enumerate(self.createItem(idx)):
            newItem.setText(j, text)
        self.insertTopLevelItem(idx, newItem)

        for j in xrange(idx + 1, len(Mainframe.model.entries)):
            self.topLevelItem(j).setText(
                0, str(j + 1) + ['', '*'][Mainframe.model.dirty_flags[j]])
        self.skip_model_changed = True
        self.setCurrentItem(self.topLevelItem(Mainframe.model.current))

def setExploits(self, exploits):
        self.treeWidget.clear()
        for exploit in exploits:
            widget = self.__stackedWidgetController.getWidget(exploit.category)
            if widget:
                # Create a dict like {name:exploit}
                self.__exploits[exploit.name] = exploit
                item = QTreeWidgetItem(self.treeWidget.invisibleRootItem())
                item.setText(0, exploit.name)

                widget.setExploit(exploit)
                # join an exploit with her widget
                self.__stackedWidgetController.setExploitWidget(exploit.name, widget)
                self.stackedWidget.addWidget(widget)
                self.stackedWidget.setCurrentWidget(widget)

def newCategory(self):
        ncn = gui.QInputDialog.getText(self, 'DDT4All', _('Enter category name'))
        necatname = unicode(ncn[0].toUtf8(), encoding="UTF-8")
        if necatname:
            self.paramview.createCategory(necatname)
            self.treeview_params.addTopLevelItem(gui.QTreeWidgetItem([necatname]))

def init_tree_transcripts(self) :
        header = QtGui.QTreeWidgetItem(["Type", "Start", "End", "Size", "#SNPs", "Sequence"])
        self.tree_transcripts.setHeaderItem(header)
        self.recursive_item_setter(self.tree_transcripts, self.annotation)

def recursive_item_setter(self, parent, annotation) :
        button = QtGui.QPushButton("View")
        button.clicked.connect(partial(self.update_sequence_viewer, annotation))
        item = QtGui.QTreeWidgetItem(parent, [annotation["feature"], str(annotation["start"]), str(annotation["end"]), str(annotation.size()), str(annotation.get_nbr_snps())])
        self.tree_transcripts.setItemWidget(item, 5, button)
        item.setExpanded(True)
        for child in annotation.get_children() :
            self.recursive_item_setter(item, child)

def add_repeat(self):
        item = QtGui.QTreeWidgetItem()
        repetitions = self.repetitions_spinbox.value()
        item.setText(0,"Repeat Last Datarun ["+str(repetitions)+"]")
        if len(self.experiment_tree.selectedItems())>0:
            index = self.experiment_tree.indexOfTopLevelItem(self.experiment_tree.selectedItems()[0])
        else:
            index = 0
        self.experiment_tree.insertTopLevelItem(index, item)
        yield None

def add_new_datarun(self):
        item = QtGui.QTreeWidgetItem()
        if len(self.experiment_tree.selectedItems())>0:
            selected_item = self.experiment_tree.selectedItems()[0]
            parent = selected_item.parent()
            if parent == None:
                index = self.experiment_tree.indexOfTopLevelItem(self.experiment_tree.selectedItems()[0])
            else:
                index = self.experiment_tree.indexOfTopLevelItem(parent)
        else:
            index = 0
        item.setText(0,"Datarun [ml, dl, c, fl, hv, rps]")
        self.experiment_tree.insertTopLevelItem(index, item)
        yield None

def __init__(self, parent, type, title, id):
         QtGui.QTreeWidgetItem.__init__(self, parent, type)
         self.type = type
         self.id = id
         self.title = title


         if type == TRACE_TYPE:
             text, flags = 'Trace', ~QtCore.Qt.ItemIsDropEnabled
         else:
             self.setChildIndicatorPolicy(self.ShowIndicator)
             self.setExpanded(True)
             if type == PLAN_TYPE:
                 text, flags = 'Plan', ~QtCore.Qt.ItemIsDropEnabled
             elif type == PLOT_TYPE:
                 text, flags = 'Plot', ~QtCore.Qt.ItemIsDropEnabled
             elif type == ROUTINE_TYPE:
                 text, flags = 'Routine', ~QtCore.Qt.ItemIsDropEnabled
             elif type == ROUTINE_TYPE:
                 text, flags = 'Routine', ~QtCore.Qt.ItemIsDropEnabled
             elif type == LIMIT_TYPE:
                 text, flags = 'Limit', ~QtCore.Qt.ItemIsDropEnabled
             elif type == SETTING_TYPE:
                 text, flags = 'Setting', ~QtCore.Qt.ItemIsDropEnabled
             elif type == ROUTE_TYPE:
                 text, flags = 'Route', ~QtCore.Qt.ItemIsDropEnabled
             else:
                 text,flags = 'test',None

         if isinstance(title,tuple):
             self.setText(0, title[0]+','+title[1])
         else:
             self.setText(0, title)

         self.setFlags(self.flags() & flags)

def QTreeWidgetItem(*args):
    if qt_ver == 4:
        for i in range(len(args)):
            if type(args[i]) == str:
                args[i] = self.QStringList(args[i])

    return QTreeWidgetItem_class(*args)

def loadClassesFromEMToTree(self, classes):
        # Clear tree
        self.ui.treeWidgetSelectInstancesToImport.clear()

        if len(classes) == 0:
            self.ui.lineEditSearchTreePage2.setEnabled(False)
            return

        else:
            self.ui.lineEditSearchTreePage2.setEnabled(True)

            # Sort classes list
            classes.sort()

            # For each class
            for clas in classes:

                # Initialize new parent for QTree
                class_level = QTreeWidgetItem()
                clas_x = Functions.getPhraseWithPrefix(clas)
                class_level.setText(0, clas_x)
                class_level.setToolTip(0, "<b>Class:</b><br> " + clas_x)
                # Set icon
                class_level.setIcon(0, self.class_icon)

                # Insert class to tree
                self.ui.treeWidgetSelectClasses.insertTopLevelItem(0, class_level)

            self.ui.treeWidgetSelectClasses.sortItems(0, 0)

def loadSelectedPropertiesToSummaryTree(self, enriched_instance, inserted_properties):

        # Clear tree
        self.ui.treeWidgetSummary.clear()

        instance_level = QTreeWidgetItem()
        instance_level.setText(0, enriched_instance)
        instance_level.setIcon(0, self.instance_icon)

        # Add items
        for property in inserted_properties:

            property_level = QTreeWidgetItem()
            property_x = Functions.getPhraseWithPrefix(property[0])
            value_x = property[1]
            property_level.setText(0, property_x)
            property_level.setText(1, value_x)
            property_level.setToolTip(0, "<b>Property:</b><br> " + property_x + " <br><b>Value:</b><br> " + value_x)
            property_level.setToolTip(1, "<b>Property:</b><br> " + property_x + " <br><b>Value:</b><br> " + value_x)

            # Set icons
            property_level.setIcon(0, self.property_icon)
            property_level.setIcon(1, self.value_icon)

            # If it is an annotation property owl:sameAs
            if property_x == 'owl:sameAs' or property_x == Functions.getPhraseWithPrefix('owl:sameAs'):
                property_level.setIcon(0, self.annotation_icon)

            instance_level.addChild(property_level)

        self.ui.treeWidgetSummary.insertTopLevelItem(0, instance_level)
        self.ui.treeWidgetSummary.expandAll()

        # Make column 0 wide enough to fit contents
        self.ui.treeWidgetSummary.resizeColumnToContents(0)

def addAnInstanceToTreeWidgetSummary(instance_x, tree_owner):
    # Initialize new parent for QTree
    instance_level = QTreeWidgetItem()
    instance_level.setText(0, instance_x)
    instance_level.setToolTip(0, "<b>Instance:</b><br> " + instance_x)

    # Set icon
    instance_level.setIcon(0, tree_owner.instance_icon)

    tree_owner.ui.treeWidgetSummary.insertTopLevelItem(0, instance_level)

def setupUi(self, MainWindow):
        mainGUI.setupUi(self,MainWindow)

        self.retranslateUi(MainWindow)

#       QtCore.QObject.connect(self.actionOpen_2, QtCore.SIGNAL("triggered()"), self.funcion_Open)
#       QtCore.QObject.connect(self.actionSave_session, QtCore.SIGNAL("triggered()"), self.funcion_Save)
        QtCore.QObject.connect(self.actionExit_2, QtCore.SIGNAL("triggered()"), self.salir)
        QtCore.QObject.connect(self.radioButton, QtCore.SIGNAL("clicked(bool)"), self.updateTable)
        QtCore.QObject.connect(self.radioButton_2, QtCore.SIGNAL("clicked(bool)"), self.updateTable)
        QtCore.QObject.connect(self.radioButton_3, QtCore.SIGNAL("clicked(bool)"), self.updateTable)
        QtCore.QObject.connect(self.comboBox, QtCore.SIGNAL("activated(QString)"), self.targetSelected)
        QtCore.QObject.connect(self.comboBox_2, QtCore.SIGNAL("activated(QString)"), self.pathSelected)
        QtCore.QObject.connect(self.comboBox_3, QtCore.SIGNAL("activated(QString)"), self.variableSelected)
        QtCore.QObject.connect(self.tableWidget, QtCore.SIGNAL("currentCellChanged(int,int,int,int)"), self.cambiaPeticion)
        QtCore.QObject.connect(self.varStatsTreeWidget, QtCore.SIGNAL("itemDoubleClicked(QTreeWidgetItem *,int)"), self.slotTree)
        QtCore.QObject.connect(self.updateVarStatsButton, QtCore.SIGNAL("clicked()"), self.updateVarStatsTree)
        QtCore.QObject.connect(self.updateReqStatsButton, QtCore.SIGNAL("clicked()"), self.updateReqStatsTree)
        QtCore.QObject.connect(self.deleteInViewButton, QtCore.SIGNAL("clicked()"), self.deleteInView)
        QtCore.QObject.connect(self.deleteSelectedButton, QtCore.SIGNAL("clicked()"), self.deleteSelected)
        QtCore.QObject.connect(self.editRequestsButton, QtCore.SIGNAL("clicked()"), self.toogleEditor)
        QtCore.QObject.connect(self.doneButton, QtCore.SIGNAL("clicked()"), self.toogleEditor)
        QtCore.QObject.connect(self.setCookieButton, QtCore.SIGNAL("clicked()"), self.setNewCookie)
        QtCore.QObject.connect(self.substButton, QtCore.SIGNAL("clicked()"), self.applyRegex)
        QtCore.QObject.connect(self.enableXSSCheck, QtCore.SIGNAL("stateChanged(int)"), self.xssToogled)
        QtCore.QObject.connect(self.enableSQLCheck, QtCore.SIGNAL("stateChanged(int)"), self.sqlToogled)
        QtCore.QObject.connect(self.sqlToXMLButton, QtCore.SIGNAL("clicked()"), self.exportSqlToXML)
        QtCore.QObject.connect(self.xssToXMLButton, QtCore.SIGNAL("clicked()"), self.exportXssToXML)
        QtCore.QObject.connect(self.sqlToHTMLButton, QtCore.SIGNAL("clicked()"), self.exportSqlToHTML)
        QtCore.QObject.connect(self.xssToHTMLButton, QtCore.SIGNAL("clicked()"), self.exportXssToHTML)
        QtCore.QObject.connect(self.resetAttackButton, QtCore.SIGNAL("clicked()"), self.controller.clearAttackerCache)
        QtCore.QObject.connect(self.attackRequestThreadsSpin, QtCore.SIGNAL("valueChanged(int)"), self.changeReqThreads)
        QtCore.QObject.connect(self.configApplyButton, QtCore.SIGNAL("clicked()"), self.applyConfig)
        QtCore.QObject.connect(self.actionAbout, QtCore.SIGNAL("triggered()"), self.funcion_About)

        QtCore.QMetaObject.connectSlotsByName(MainWindow)


####################################################################################################################################
####################################################################################################################################
####################################################################################################################################
####################################################################################################################################
####################################################################################################################################

def create_formatted_tree(root, data, template_data=None):
    """Helper function to add items to QTreeWidget

    Args:
        root: tree root item
        data: text item to be added (list/dict for multiple items or string for single item)
        format_format_data: function to format data
        format_data: data dictionary for formatting
    """
    def format_template_data(data):
        iterator = data.iteritems() if type(data) == dict else enumerate(data)
        for key, value in iterator:
            if type(value) in (list, tuple):
                if value and isinstance(value[0], Decimal):
                    value = [u'{0:.5f}'.format(v) for v in value]
                data[key] = u', '.join(map(unicode, value))
        return data

    def add_item(root, text, template_data):
        item = QTreeWidgetItem(root)
        if template_data:
            if type(template_data) == dict:
                item.setText(0, unicode(text).format(**template_data))
            else:
                item.setText(0, unicode(text).format(*template_data))
        else:
            item.setText(0, unicode(text))

        return item

    item = root

    formatted_data = None
    if template_data:
        formatted_data = format_template_data(template_data)

    if isinstance(data, list) or isinstance(data, set):
        for data_item in data:
            if isinstance(data_item, list):
                create_formatted_tree(item, data_item, formatted_data)
            else:
                item = add_item(root, data_item, formatted_data)
    elif isinstance(data, dict):
        for key, key_data in data.iteritems():
            item = add_item(root, key, formatted_data)
            create_formatted_tree(item, key_data, formatted_data)
    else:
        item = add_item(item, data, formatted_data)

    return item

def embryo2ObjectBar(self,embryo,parentNode):

        """Adds Embryo to ObjectBar. 



        """

        #Embryo Status
        analyzed=str(int(embryo.isAnalyzed()))
        simulated=str(int(embryo.isSimulated()))
        fitted=str(int(embryo.isFitted()))

        #Create new node
        newEmbryoNode=QtGui.QTreeWidgetItem(parentNode,[embryo.name,analyzed,simulated,fitted])

        #Geometry node
        newGeometryNode=QtGui.QTreeWidgetItem(newEmbryoNode,['Geometry','','',''])

        #ROIs node
        newROIsNode=QtGui.QTreeWidgetItem(newEmbryoNode,['ROIs','','',''])

        #Add ROIs
        for roi in embryo.ROIs:
            newROINode=QtGui.QTreeWidgetItem(newROIsNode,[roi.name,str(int(roi.isAnalyzed())),str(int(roi.isSimulated())),str(int(roi.isFitted()))])

        #Analysis node
        newAnalysisNode=QtGui.QTreeWidgetItem(newEmbryoNode,['Analysis',analyzed,'',''])

        #Simulation node
        newSimulationNode=QtGui.QTreeWidgetItem(newEmbryoNode,['Simulation','',simulated,''])

        #if embryo.simulation!=None:
        newMeshNode=QtGui.QTreeWidgetItem(newSimulationNode,['Mesh','','',''])

        #Fits node
        newFitsNode=QtGui.QTreeWidgetItem(newEmbryoNode,['Fits','','',''])

        #Add Fits
        for fit in embryo.fits:
            newFitNode=QtGui.QTreeWidgetItem(newFitsNode,[fit.name,'','',str(int(fit.isFitted()))])

        #Expand Fits node
        self.objectBar.expandItem(newFitsNode)  

        return newEmbryoNode        

    #---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
    #Update ObjectBar Properties of embryo Node

def addItem(self):

        self.getLeftSelections()

        if self.leftList.currentItem()==None or self.leftList.currentItem().parent()==None:
            QtGui.QMessageBox.critical(None, "Error","No fit selected.",QtGui.QMessageBox.Ok | QtGui.QMessageBox.Default)
            return

        else:

            #Check if current embryo is already in right list
            if self.currEmbryo in self.embryosInRightList:

                #Check if fit is already in right list
                if self.currFit in self.fitsInRightList:
                    pass
                else:

                    self.getRightInd(embryoName=self.currEmbryo.name)

                    if self.singleFit:
                        #Check if target embr already has a fit, if so, remove it
                        if self.currTargetEmbryoNode.childCount()>0:
                            self.getRightInd(fitName=self.currTargetEmbryoNode.child(0).data(0,0).toString())
                            self.currTargetEmbryoNode.takeChild(0)
                            self.fitsInRightList.remove(self.currTargetFit)

                    #Add to list of fits on right side  
                    self.fitsInRightList.append(self.currFit)
                    newNode=QtGui.QTreeWidgetItem(self.currTargetEmbryoNode,[self.currFit.name])
                    self.rightList.expandItem(self.currTargetEmbryoNode)

                    # Remove in left list
                    #self.leftList.removeItemWidget(self.currFitNode,0)
                    ind=self.currEmbryoNode.indexOfChild(self.leftList.currentItem())
                    self.currEmbryoNode.takeChild(ind)
                    #self.currEmbryoNode.takeChild()

            else:

                #Add currEmbryo to list
                self.embryosInRightList.append(self.currEmbryo)
                newNode=QtGui.QTreeWidgetItem(self.rightList,[self.currEmbryo.name])

                #Add to list of fits on right side  
                self.fitsInRightList.append(self.currFit)
                QtGui.QTreeWidgetItem(newNode,[self.currFit.name])
                self.rightList.expandItem(newNode)