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

def applyRegex (self):
        requests=self.controller.getRequests()
        if str(self.substSrcEdit.text()):
            indexes=[]

            n=self.tableWidget.rowCount()
            for i in range(n):
                if not self.tableWidget.isRowHidden(i):
                    indexes.append(i)

            for i in indexes:
                try:
                    requests[i].Substitute(str(self.substSrcEdit.text()),str(self.substDstEdit.text()))
                    self.tableWidget.setItem(i,1,QtGui.QTableWidgetItem(requests[i].urlWithoutPath))
                    self.tableWidget.setItem(i,2,QtGui.QTableWidgetItem(requests[i].pathWithVariables))
                    if requests[i]["Cookie"]:
                        self.tableWidget.setItem(i,3,QtGui.QTableWidgetItem(requests[i]["Cookie"]))
                except Exception,a:
                    mb = QtGui.QMessageBox ("Error in substitution","ERROR !",QtGui.QMessageBox.Warning,QtGui.QMessageBox.Ok,0,0)
                    mb.exec_()
                    return

            self.updateAllStats()

def addNewCreditEntry( self, row, role, name, primary_flag=False ):
        self.twCredits.insertRow(row)

        item_text = role
        item = QtGui.QTableWidgetItem(item_text)            
        item.setFlags(QtCore.Qt.ItemIsSelectable| QtCore.Qt.ItemIsEnabled)
        item.setData( QtCore.Qt.ToolTipRole, item_text )
        self.twCredits.setItem(row, 1, item)


        item_text = name
        item = QtGui.QTableWidgetItem(item_text)            
        item.setData( QtCore.Qt.ToolTipRole, item_text )
        item.setFlags(QtCore.Qt.ItemIsSelectable| QtCore.Qt.ItemIsEnabled)
        self.twCredits.setItem(row, 2, item)

        item = QtGui.QTableWidgetItem("")           
        item.setFlags(QtCore.Qt.ItemIsSelectable| QtCore.Qt.ItemIsEnabled)
        self.twCredits.setItem(row, 0, item)
        self.updateCreditPrimaryFlag( row, primary_flag )

def Seleccionar(self):
            self.table.setRowCount(0)
            self.table.setColumnCount(0)
            self.table.setColumnCount(3)
            self.table.setColumnWidth(0,700)
            self.table.setColumnWidth(1,200)
            self.table.setColumnWidth(2,200)
            self.table.setHorizontalHeaderLabels(["girilen siteler","tarih","browser"])
            row = 0
            query = Mysql.gecmisGetir()
            for q in query:
                self.table.insertRow(row)

                url = QTableWidgetItem(str(q[0]))
                ad=QTableWidgetItem(str(q[2]))
                tarih=QTableWidgetItem(str(q[1]))

                self.table.setItem(row, 0, url)
                self.table.setItem(row, 1, tarih)
                self.table.setItem(row, 2, ad)
                row = row + 1

def __init__(self, parent=None,**kwargs):
        super(AppWindow, self).__init__(parent)
        self.setupUi(self)
        self.data = kwargs.get('data',[])
        self.setWindowTitle('Data')
        self.table.setColumnWidth(0,200)
        self.table.setRowCount(len(self.data)+1)
        xpos=0;ypos=0
        for a in self.data:
            xpos=0
            for b in a:
                item = QtGui.QTableWidgetItem()
                self.table.setItem(ypos,xpos,item)
                item.setText('%s'%b)
                xpos+=1
            ypos+=1
        self.maxRows=ypos
        self.maxCols=xpos

def setColumn(self,col,data):
        ypos=0
        if col > self.maxCols:
            self.maxCols = col
            self.table.setColumnCount(col+1)

        if len(data) > self.maxRows:
            self.maxRows = len(data)
            self.table.setRowCount(self.maxRows+1)


        for a in data:
            item = QtGui.QTableWidgetItem()
            self.table.setItem(ypos,col,item)
            item.setText('%s'%a)
            ypos+=1

def setColumn(self,col,data):
        ypos=0
        if col > self.maxCols:
            self.maxCols = col
            self.table.setColumnCount(col+1)

        if len(data) > self.maxRows:
            self.maxRows = len(data)
            self.table.setRowCount(self.maxRows+1)


        for a in data:
            item = QtGui.QTableWidgetItem()
            self.table.setItem(ypos,col,item)
            item.setText('%.3e'%a)
            ypos+=1

def __init__(self, parent=None,**kwargs):
        super(AppWindow, self).__init__(parent)
        self.setupUi(self)
        self.I=kwargs.get('I',None)

        self.setWindowTitle('About Device : '+self.I.hexid)
        self.table.setColumnWidth(0,200)
        if self.I.connected :
            xpos=0;ypos=0
            for a in self.I.aboutArray:
                xpos=0
                for b in a:
                    item = QtGui.QTableWidgetItem()
                    self.table.setItem(ypos,xpos,item)
                    item.setText('%s'%b)
                    xpos+=1
                ypos+=1

def __init__(self,I):
            super(utilitiesClass.voltWidget, self).__init__()
            self.setupUi(self)

            self.I = I
            self.col1=['CH1','CH2','CH3']
            self.col2=['CAP','SEN','AN8']
            pos=0
            for a,b in zip(self.col1,self.col2):
                item = QtGui.QTableWidgetItem();self.table.setItem(pos,0,item); item.setText('%s'%a)
                item = QtGui.QTableWidgetItem();self.table.setItem(pos,2,item); item.setText('%s'%b)

                item = QtGui.QTableWidgetItem();self.table.setItem(pos,1,item); item.setText('')
                item = QtGui.QTableWidgetItem();self.table.setItem(pos,3,item); item.setText('')

                pos+=1

def add_new_sync_directory(self):
        self.selected_sync_sirectory = QtGui.QFileDialog.getExistingDirectory(
            None,
            'Select a sync directory: ',
            "",
            QtGui.QFileDialog.ShowDirsOnly)

        if self.selected_sync_sirectory != "":
            self.current_time = time.ctime()
            total_files_count = self.tools.count_files_in_dir(directory=self.selected_sync_sirectory)
            total_files_size = self.tools.human_size(self.tools.count_directory_size(self.selected_sync_sirectory, True))

            table_row_count = self.sync_menu_ui.sync_directories_tableWidget.rowCount()
            self.sync_menu_ui.sync_directories_tableWidget.setRowCount(table_row_count + 1)
            self.sync_menu_ui.sync_directories_tableWidget.setItem(
               table_row_count, 0, QtGui.QTableWidgetItem(str(self.selected_sync_sirectory)))
            self.sync_menu_ui.sync_directories_tableWidget.setItem(
                table_row_count, 1, QtGui.QTableWidgetItem(str(self.current_time)))
            self.sync_menu_ui.sync_directories_tableWidget.setItem(
                table_row_count, 2, QtGui.QTableWidgetItem(str(total_files_count)))
            self.sync_menu_ui.sync_directories_tableWidget.setItem(
                table_row_count, 3, QtGui.QTableWidgetItem(str(total_files_size)))


        return True

def add_row_files_queue_table(self, row_data):


        self.files_queue_progressbar_list.append(QtGui.QProgressBar())

        self.files_queue_table_row_count = self.ui_single_file_upload.files_queue_table_widget.rowCount()

        self.ui_single_file_upload.files_queue_table_widget.setRowCount(
            self.files_queue_table_row_count + 1)

        self.ui_single_file_upload.files_queue_table_widget.setItem(
            self.files_queue_table_row_count, 0, QtGui.QTableWidgetItem(os.path.split(str(row_data['file_path']))[1]))
        self.ui_single_file_upload.files_queue_table_widget.setItem(
            self.files_queue_table_row_count, 1, QtGui.QTableWidgetItem(row_data['file_path']))

        self.ui_single_file_upload.files_queue_table_widget.setItem(
            self.files_queue_table_row_count, 2, QtGui.QTableWidgetItem(str(self.tools.human_size(os.path.getsize(str(row_data['file_path']))))))

        self.ui_single_file_upload.files_queue_table_widget.setCellWidget(
            self.files_queue_table_row_count, 3, self.files_queue_progressbar_list[self.files_queue_table_row_count])

def list_hosts(self, ip):
        live_hosts = []
        if self._isProtected:
            print "protected"
            arping = sp.Popen(['arp-scan','--interface',self._iface,ip],stdout = sp.PIPE,shell=False)
        else:
            print "Not Protected"
            arping = sp.Popen(['arp-scan','--interface',self._iface,ip+'/24'],stdout = sp.PIPE,shell=False)
        i=1
        for line in arping.stdout:
            if line.startswith(ip.split('.')[0]):
                ip = line.split()[0]
                mac= line.split()[1]
                self.table_hosts.setRowCount(i)
                self.table_hosts.setItem(i-1,0,QtGui.QTableWidgetItem(ip))
                self.table_hosts.item(i-1,0).setIcon(QtGui.QIcon(':pix/pix/online.png'))
                self.table_hosts.setItem(i-1,1,QtGui.QTableWidgetItem(mac))
                live_hosts.append(ip)
                i=i+1
        self.myThread = Thread(target=self.list_hostnames,args=(live_hosts,))
        self.myThread.start()

def updateCMapBox(self, q_tname):
        self.colorMapTabel.clearContents()
        tname = str(q_tname)
        self.colorMapTabel.setRowCount(len(self.tasks[tname]))
        self.cmap = get_colors(len(self.tasks[tname]))  # 0-1 range
        self.frameView.cmap = self.cmap
        self.frameView.penwidth = self._penwidth

        for i in sorted(self.tasks[tname]):
            idx = QtGui.QTableWidgetItem(str(i))
            idx.setTextAlignment(QtCore.Qt.AlignCenter)
            idx.setFlags(QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEnabled)
            self.colorMapTabel.setItem(i, 0, idx)

            col = QColorCellWidget(tuple(int(255*c) for c in self.cmap[i]))
            self.colorMapTabel.setCellWidget(i, 1, col)

            lab = QtGui.QTableWidgetItem(self.tasks[tname][i])
            lab.setTextAlignment(QtCore.Qt.AlignCenter)
            lab.setFlags(QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEnabled)
            self.colorMapTabel.setItem(i, 2, lab)

def __lt__ (self, other):
        """Check order of two values.

        Tries to convert the value to a float. If successful it will return 
        the order of those two values. 

        If value is not numeric or is not a QCustomTableWidgetItem type it
        will return the standard string compare output.

        Args:
            other(QTableWidgetItem): value to compare with that stored by this.

        Return:
            Bool - True if given value is less than this.
        """
        if (isinstance(other, QNumericSortTableWidgetItem)):
            try:
                self_data_value  = float(self.data(QtCore.Qt.EditRole).toString())
                other_data_value = float(other.data(QtCore.Qt.EditRole).toString())
            except:
                return QtGui.QTableWidgetItem.__lt__(self, other)
            return self_data_value < other_data_value
        else:
            return QtGui.QTableWidgetItem.__lt__(self, other)

def open_FileDialog_tl(self):
        filename = QtGui.QFileDialog.getOpenFileName(self, 'File Open', './')
        self.tl_label.setText(filename)

        # check dimension and size
        with open(filename, 'rb') as f:
            global n_class
            labels = pickle.load(f)        
            label_set = labels['train'].astype(np.int8)
            max_idx = np.max(label_set) + 1 # includes '0' label
            print("[INFO] #CLASSES: %d" % max_idx)

            n_class = max_idx

            item3 = QtGui.QTableWidgetItem(str(n_class))
            self.table.setItem(self.table.rowCount()-1,2,item3)

    # -----------------------------------------------------------------------
    # Load PreDefined CNN
    # -----------------------------------------------------------------------

def btnAddRule_clicked(self):
        formrule = FormRule()
        if QtGui.QDialog.Rejected == formrule.exec_(): return
        ind = self.tblRule.rowCount()
        self.tblRule.insertRow(ind)
        self.tblRule.setItem(ind, 0, QtGui.QTableWidgetItem(str(formrule.chkEnabled.isChecked())))
        if formrule.optReplace.isChecked():
            self.tblRule.setItem(ind, 1, QtGui.QTableWidgetItem("Replace"))
            self.tblRule.setItem(ind, 3, QtGui.QTableWidgetItem(formrule.txtReplace.text()))
        else:
            self.tblRule.setItem(ind, 1, QtGui.QTableWidgetItem("Ignore"))
            self.tblRule.setItem(ind, 3, QtGui.QTableWidgetItem(""))
        self.tblRule.setItem(ind, 2, QtGui.QTableWidgetItem(formrule.txtMatch.text()))
        parseRule()


    #Widgets events - Capturing tab

def addItem(self, row, data):
        """
        This function add a item on a row
        :param row: the row's number
        :param data: the information
        :return: None
        """

        # state can be filtered, closed or open
        # data[3] is state
        if data[3] in ["open"]:
            self.tableWidget.setVerticalHeaderItem(row, QTableWidgetItem(QIcon().fromTheme('list-add'), ''))
        else:
            self.tableWidget.setVerticalHeaderItem(row, QTableWidgetItem(QIcon().fromTheme('dialog-error'), ''))

        for i, d in enumerate(data):
            item = QTableWidgetItem(d)
            item.setFlags(Qt.ItemIsEnabled)
            self.tableWidget.setItem(row, i, item)

def addAttr(self):
        """Add selected attribute and time to time/attribute list"""
        # current attr name
        aname=self.attrList.currentText()
        if (aname==""):
            return
        time=self.dteTime.dateTime().toString(1)+"Z" # ISO datetime
        # add new row
        row=self.twTimesAttrs.rowCount()+1
        self.twTimesAttrs.setRowCount(row)
        # put datetime and attribute name to table
        self.twTimesAttrs.setItem(row-1,0,QTableWidgetItem(time,0))
        self.twTimesAttrs.setItem(row-1,1,QTableWidgetItem(aname,0))
        self.twTimesAttrs.sortItems(0);
        # update min/max information
        self.showMinMax()

def addAttr(self):
        """Add selected attribute and time to time/attribute list"""
        # current attr name
        aname=self.attrList.currentText()
        if (aname==""):
            return
        time=self.dteTime.dateTime().toString(1)+"Z" # ISO datetime
        # add new row
        row=self.twTimesAttrs.rowCount()+1
        self.twTimesAttrs.setRowCount(row)
        # put datetime and attribute name to table
        self.twTimesAttrs.setItem(row-1,0,QTableWidgetItem(time,0))
        self.twTimesAttrs.setItem(row-1,1,QTableWidgetItem(aname,0))
        self.twTimesAttrs.sortItems(0);
        # update min/max information
        self.showMinMax()

def addAttr(self):
        """Add selected attribute and time to time/attribute list"""
        # current attr name
        aname=self.attrList.currentText()
        if (aname==""):
            return
        time=self.dteTime.dateTime().toString(1)+"Z" # ISO datetime
        # add new row
        row=self.twTimesAttrs.rowCount()+1
        self.twTimesAttrs.setRowCount(row)
        # put datetime and attribute name to table
        self.twTimesAttrs.setItem(row-1,0,QTableWidgetItem(time,0))
        self.twTimesAttrs.setItem(row-1,1,QTableWidgetItem(aname,0))
        self.twTimesAttrs.sortItems(0);
        # update min/max information
        self.showMinMax()

def tableArea(self, Form):
        self.tableResult = QtGui.QTableWidget(Form)
        self.tableResult.setGeometry(QtCore.QRect(15, 400, 571, 192))
        self.tableResult.setObjectName(_fromUtf8("tableResult"))
        self.tableResult.setColumnCount(7)
        item = QtGui.QTableWidgetItem()
        self.tableResult.setHorizontalHeaderItem(0, item)
        item = QtGui.QTableWidgetItem()
        self.tableResult.setHorizontalHeaderItem(1, item)
        item = QtGui.QTableWidgetItem()
        self.tableResult.setHorizontalHeaderItem(2, item)
        item = QtGui.QTableWidgetItem()
        self.tableResult.setHorizontalHeaderItem(3, item)
        item = QtGui.QTableWidgetItem()
        self.tableResult.setHorizontalHeaderItem(4, item)
        item = QtGui.QTableWidgetItem()
        self.tableResult.setHorizontalHeaderItem(5, item)
        item = QtGui.QTableWidgetItem()
        self.tableResult.setHorizontalHeaderItem(6, item)

def getResultsAndAddToTable(self):
        scrap = scrapper.Scrapper(self.kt, self.ktu, self.v, self.f, self.s)
        for i in scrap.getTable():
            for c, j in enumerate(range(0, len(i))):
                self.gbSonuclar.setVisible(True)
                self.lblTaksit.setText(_translate("Form", "Taksit Tutar? : {}".format(i[j]['Taksit']), None))
                self.lblFaiz.setText(_translate("Form", "Faiz Oran?      : {}".format(str(self.txtFaiz.text())), None))

                self.tableResult.setRowCount(len(i))
                self.tableResult.setItem(c, 0, QtGui.QTableWidgetItem(str(i[j]['Sira'])))
                self.tableResult.setItem(c, 1, QtGui.QTableWidgetItem(str(i[j]['Taksit'])))
                self.tableResult.setItem(c, 2, QtGui.QTableWidgetItem(str(i[j]['Anapara'])))
                self.tableResult.setItem(c, 3, QtGui.QTableWidgetItem(str(i[j]['Faiz'])))
                self.tableResult.setItem(c, 4, QtGui.QTableWidgetItem(str(i[j]['Bakiye'])))
                self.tableResult.setItem(c, 5, QtGui.QTableWidgetItem(str(i[j]['KKDF'])))
                self.tableResult.setItem(c, 6, QtGui.QTableWidgetItem(str(i[j]['BSMV'])))

def buildTable(self, snap):
        self.tableWidget.clear()
        self.tableWidget.setColumnCount(3)
        self.tableWidget.setRowCount(len(snap))
        self.tableWidget.setHorizontalHeaderLabels(["Attribute Name", "Read Value", "Write Value"])
        i=0
        for value in sorted(snap):
            item=QtGui.QTableWidgetItem("%s" % value[0])
            self.tableWidget.setItem(i, 0, item)
            if (type(value[1]) is not tuple):
                item1=QtGui.QTableWidgetItem("%s" % value[1])
                self.tableWidget.setItem(i, 1, item1)
                item2=QtGui.QTableWidgetItem("%s" %'None')
            else:
                item1=QtGui.QTableWidgetItem("%s" % value[1][0])
                self.tableWidget.setItem(i, 1, item1)
                item2=QtGui.QTableWidgetItem("%s" % value[1][1])
            self.tableWidget.setItem(i, 2, item2)
            if i%2==0:
                item.setBackgroundColor(QtGui.QColor(225,225,225))
                item1.setBackgroundColor(QtGui.QColor(225,225,225))
                item2.setBackgroundColor(QtGui.QColor(225,225,225))
            i=i+1
        self.tableWidget.resizeColumnsToContents()

def table_organize(self,found_servos):
        """Organizes the Found servos table with the search result"""
        #sets the number of rows
        self.table_found.setRowCount(len(found_servos))
        #Loop through the list and set the itens
        for i in found_servos:
            current_row = found_servos.index(i)
            #Creates the items
            id_item = QtGui.QTableWidgetItem(str(i.id))
            baudrate_item = QtGui.QTableWidgetItem(str(i.baudrate))
            model = mixcell.model_num[i.model]
            model_item =  QtGui.QTableWidgetItem(model)
            #Sets cells items
            self.table_found.setItem(current_row,0,id_item)
            self.table_found.setItem(current_row,1,model_item)
            self.table_found.setItem(current_row,2,baudrate_item)

def addItem(self,row,text1,text2,text3,text4):
        _item1 = QtGui.QTableWidgetItem(text1)
        _item2 = QtGui.QTableWidgetItem(text2)
        _item3 = QtGui.QTableWidgetItem(text3)
        _item4 = QtGui.QTableWidgetItem(text4)

        assert isinstance(self.ui.tableWidget,QtGui.QTableWidget)
        self.ui.tableWidget.insertRow(row)
        self.ui.tableWidget.setItem(row,0,_item1)
        self.ui.tableWidget.setItem(row,1,_item2)
        self.ui.tableWidget.setItem(row,2,_item3)
        self.ui.tableWidget.setItem(row,3,_item4)

#        _itemC = QtGui.QComboBox()
#        if text1 == 'Antenna':
#            _itemC.addItems(self.AntennaList)
#        if text1 == 'Cable':
#            _itemC.addItems(self.CableList)
#        self.ui.tableWidget.setCellWidget(row,2,_itemC)

  #      _itemD = QtGui.QDateEdit()
  #      self.ui.tableWidget.setCellWidget(row,4,_itemD)

def addItem(self,row,text2,text3):
        _item2 = QtGui.QTableWidgetItem(text2)
        _item3 = QtGui.QTableWidgetItem('?')
        _item5 = QtGui.QTableWidgetItem(text3)

        assert isinstance(self.ui.tableWidget,QtGui.QTableWidget)
        self.ui.tableWidget.insertRow(row)
        self.ui.tableWidget.setItem(row,0,_item2)
        self.ui.tableWidget.setItem(row,2,_item3)
        self.ui.tableWidget.setItem(row,4,_item5)

        _itemC = QtGui.QComboBox()
        _itemC.addItem(text2)
        _itemC.addItems(self.LimitList)
        self.ui.tableWidget.setCellWidget(row,1,_itemC)

        _itemD = QtGui.QDateEdit()
        self.ui.tableWidget.setCellWidget(row,3,_itemD)

def addItem(self,row,text1,text2,text3):
        _item1 = QtGui.QTableWidgetItem(text1)
        _item2 = QtGui.QTableWidgetItem(text2)
        _item3 = QtGui.QTableWidgetItem('?')
        _item5 = QtGui.QTableWidgetItem(text3)

        assert isinstance(self.ui.tableWidget,QtGui.QTableWidget)
        self.ui.tableWidget.insertRow(row)
        self.ui.tableWidget.setItem(row,0,_item1)
        self.ui.tableWidget.setItem(row,1,_item2)
        self.ui.tableWidget.setItem(row,3,_item3)
        self.ui.tableWidget.setItem(row,5,_item5)

        _itemC = QtGui.QComboBox()
        if text1 == 'Antenna':
            _itemC.addItems(self.AntennaList)
        if text1 == 'Cable':
            _itemC.addItems(self.CableList)
        self.ui.tableWidget.setCellWidget(row,2,_itemC)

        _itemD = QtGui.QDateEdit()
        self.ui.tableWidget.setCellWidget(row,4,_itemD)

def addItem(self, setting, route, alias, antenna, cable, probe, matrix):

        _item1 = QtGui.QTableWidgetItem(setting)
        _item2 = QtGui.QTableWidgetItem(route)
        _item3 = QtGui.QTableWidgetItem(alias)
        _item4 = QtGui.QTableWidgetItem(antenna)
        _item5 = QtGui.QTableWidgetItem(cable)
        _item6 = QtGui.QTableWidgetItem(probe)
        _item7 = QtGui.QTableWidgetItem(matrix)

        _ret = self.ui.tableWidget.rowCount()
        _ret += 1
        self.ui.tableWidget.setRowCount(_ret)

        self.ui.tableWidget.setItem(_ret-1, 0, _item1)
        self.ui.tableWidget.setItem(_ret-1, 1, _item2)
        self.ui.tableWidget.setItem(_ret-1, 2, _item3)
        self.ui.tableWidget.setItem(_ret-1, 3, _item4)
        self.ui.tableWidget.setItem(_ret-1, 4, _item5)
        self.ui.tableWidget.setItem(_ret-1, 5, _item6)
        self.ui.tableWidget.setItem(_ret-1, 6, _item7)

def search(self):
        search_term = str(self.search_bar.text())
        if len(search_term) > 0:
            spot_results = spotify_tools.keyword_search(search_term)
            self.results.setRowCount(len(spot_results.tracks))

            for x in range(0, len(spot_results.tracks)):
                track = spot_results.tracks[x]
                uri = str(track)[8
                                 :-2]
                self.results.setItem(x, 0, QtGui.QTableWidgetItem(uri))
                self.results.setItem(x, 1, QtGui.QTableWidgetItem(track.name))
                self.results.setItem(x, 2, QtGui.QTableWidgetItem(track.artists[0].name))
                self.results.setItem(x, 3, QtGui.QTableWidgetItem(track.album.name))
                self.results.setItem(x, 4, QtGui.QTableWidgetItem(spotify_tools.duration_string(track.duration)))
                download_btn = QtGui.QPushButton(self.results)
                download_btn.setText('Download')
                download_btn.clicked.connect(self.download_song)
                self.results.setCellWidget(x, 5, download_btn)

def addRace(self, race, old_ratings):

        self.race = race
        self.old_ratings = old_ratings

        self.setRowCount(len(self.old_ratings))
        for i, result in enumerate(self.race.results):

            runner_id = QtGui.QTableWidgetItem(str(result.runner_id))
            time = QtGui.QTableWidgetItem(str(result.time)) # may have to format

            if self.old_ratings[i] is not None:
                oldrating = QtGui.QTableWidgetItem(str(self.old_ratings[i]))
            else:
                oldrating = QtGui.QTableWidgetItem(str('None'))

            self.setItem(i, 0, runner_id)
            self.setItem(i, 1, time)
            self.setItem(i, 2, oldrating)

        self.resizeColumnsToContents()

def calculate_ratings(self, r200):

        self.race.calculate_ratings(r200)

        error = 0
        for i, result in enumerate(self.race.results):

            newrating = QtGui.QTableWidgetItem(str(result.rating))
            self.setItem(i, 3, newrating)

            if self.old_ratings[i] is None:
                error += 0
            else:
                diff = float(self.old_ratings[i])-result.rating
                if abs(diff) <= 20.0:
                    error += diff**2.

        return error

def dropEvent (self, event) :
        #print ("drop...")
        fmts = event.mimeData ().formats ()
        n = fmts.count ()
        #for i in range (n) :
        #print (n, fmts.takeAt (0))
        #if event.mimeData ().hasFormat ("text/plain") :
        #data = event.mimeData ().data ()

        item = self.itemAt (event.pos ())
        if item != None :
            col = item.column ()
            if item.row () == 0 :
                #data = event.mimeData ().data ("text/plain")
                #stream = QtCore.QDataStream (data, QtCore.QIODevice.ReadOnly)
                text = event.mimeData ().text ()
                #stream >> text
                #print (text, item.row (), item.column ())
                cell = QtGui.QTableWidgetItem (text)
                self.setItem (item.row (), item.column (), cell)
                #self.dropMimeData (0, item.column (), event.mimeData (), 1)
                #event.setDropAction (Qt.CopyAction)
                #event.accept ()
                self.colheaders ()
                self.resizeColumnToContents (col)

def btnSelectEndpoint_clicked(self):
        # If no selection has been made
        if self.ui.tableWidgetKnownEndpoints.currentRow() == -1:
            # Show message box with error
            QtGui.QMessageBox.critical(self, 'Error', "Please select an endpoint from the list.", QtGui.QMessageBox.Close)

            return

        # TODO: Log if this is True
        self.setSelectedEndpointURLAsSetting()

        # Update table of stats in main window
        itemEndpoint = QtGui.QTableWidgetItem(Functions.getEndpointName())
        itemEndpoint.setTextAlignment(QtCore.Qt.AlignHCenter)
        itemEndpoint.setTextColor(QtGui.QColor(55, 122, 151)) #rgb numbers of hex #377a97 color
        boldFont = QFont(); boldFont.setBold(True)
        itemEndpoint.setFont(boldFont)
        window.ui.tableWidgetMyModelStats.setItem(0, 0, itemEndpoint)

        # Reload all tables in preferences
        self.loadAllTablesInPreferences()

def loadLogEntriesToTable(self):
        # Clear table
        self.ui.tableWidgetLogEntries.setRowCount(0)

        # Load log entries from DB
        entries = Functions.getListOfLogEntries()

        # Put the entry to table
        for entry in entries:
            # Add an empty row to the table
            rowPosition = self.ui.tableWidgetLogEntries.rowCount()
            self.ui.tableWidgetLogEntries.insertRow(rowPosition)

            # Insert the endpoint
            self.ui.tableWidgetLogEntries.setItem(rowPosition, 0, QtGui.QTableWidgetItem(entry[0]))
            self.ui.tableWidgetLogEntries.setItem(rowPosition, 1, QtGui.QTableWidgetItem(entry[1]))

        # Highlight the first entry
        self.ui.tableWidgetLogEntries.selectRow(self.ui.tableWidgetLogEntries.rowCount() - 1)

         # Sort table
        self.ui.tableWidgetLogEntries.sortItems(0, QtCore.Qt.DescendingOrder) # latest entry will appear as first

def loadNamespacesToTable(self):
        # Clear table
        self.ui.tableWidgetKnownNamespaces.setRowCount(0)

        # Load known namespaces from DB
        namespaces = Functions.getListOfNamespaces()

        # Put the to table
        for namespace in namespaces:
            # Add an empty row to the table
            rowPosition = self.ui.tableWidgetKnownNamespaces.rowCount()
            self.ui.tableWidgetKnownNamespaces.insertRow(rowPosition)

            # Insert the namespace
            self.ui.tableWidgetKnownNamespaces.setItem(rowPosition, 0, QtGui.QTableWidgetItem(str(namespace[0])))
            self.ui.tableWidgetKnownNamespaces.setItem(rowPosition, 1, QtGui.QTableWidgetItem(str(namespace[1])))

def loadMappingsToTable(self):
        # Clear table
        self.ui.tableWidgetKnownMappings.setRowCount(0)

        # Load mappings from DB
        mappings = Functions.getListOfMappingsFromDB()

        # Put the mappings to table
        for mapping in mappings:
            # Add an empty row to the table
            rowPosition = self.ui.tableWidgetKnownMappings.rowCount()
            self.ui.tableWidgetKnownMappings.insertRow(rowPosition)

            # Insert the mapping
            self.ui.tableWidgetKnownMappings.setItem(rowPosition, 0, QtGui.QTableWidgetItem(mapping[0]))
            self.ui.tableWidgetKnownMappings.item(rowPosition, 0).setToolTip(mapping[0])

            self.ui.tableWidgetKnownMappings.setItem(rowPosition, 1, QtGui.QTableWidgetItem(mapping[1]))
            self.ui.tableWidgetKnownMappings.item(rowPosition, 1).setToolTip(mapping[1])

            self.ui.tableWidgetKnownMappings.setItem(rowPosition, 2, QtGui.QTableWidgetItem(mapping[2]))
            self.ui.tableWidgetKnownMappings.item(rowPosition, 2).setToolTip(mapping[2])

            self.ui.tableWidgetKnownMappings.setItem(rowPosition, 3, QtGui.QTableWidgetItem(mapping[3]))
            self.ui.tableWidgetKnownMappings.item(rowPosition, 3).setToolTip(mapping[3])

def add_key_to_database(self):
        aircrack_log = config_dir + 'aircrack-log.txt'

        # read cracked key
        key = commands.getoutput("cat " + aircrack_log + " | grep 'KEY FOUND' | tr '[]' '\n' | egrep '([a-fA-F0-9]:)+' | tr -d ' \t'")

        # insert a row in the database
        self.table_database.insertRow(0)
        item=QtGui.QTableWidgetItem()
        item.setText(essid)
        self.table_database.setItem(0, 0, item)

        item=QtGui.QTableWidgetItem()
        item.setText(self.ac)
        self.table_database.setItem(0, 1, item)

        item=QtGui.QTableWidgetItem()
        item.setText(self.canale)
        self.table_database.setItem(0, 2, item)

        item=QtGui.QTableWidgetItem()
        item.setText(key)
        self.table_database.setItem(0, 3, item)

        item=QtGui.QTableWidgetItem()
        item.setText((key_to_ascii(key)))
        self.table_database.setItem(0, 4, item)


    #
    # Database changed
    #

def slot_database_changed(self):
        selrow = self.table_database.currentRow()
        if selrow == -1:
            return

        key = str(self.table_database.item(selrow, 3))

        item=QtGui.QTableWidgetItem()
        item.setText((key_to_ascii(key)))
        self.table_database.setItem(selrow, 4, item)

    #
    # Add an entry to the database table
    #

def slot_database_changed(self):
        selrow = self.table_database.currentRow()
        if selrow == -1:
            return

        key = str(self.table_database.item(selrow, 3))

        item=QtGui.QTableWidgetItem()
        item.setText((key_to_ascii(key)))
        self.table_database.setItem(selrow, 4, item)

    #
    # Add an entry to the database table
    #

def config_row(self, row_number):
        """ Configure a row of the table """
        # Init all fields, this is needed to make all slots work when we fill everything out
        comboBoxPatchport = QComboBox(self.tableWidget)
        self.tableWidget.setCellWidget(row_number, 0, comboBoxPatchport)

        if row_number > 0:
            for i in range(1, 6):
                originalItem = self.tableWidget.item(row_number - 1, i)
                newItem = QTableWidgetItem(originalItem)
                self.tableWidget.setItem(row_number, i, newItem)

        comboBoxVlans = QComboBox(self.tableWidget)
        self.tableWidget.setCellWidget(row_number, 2, comboBoxVlans)

        buttonSubmit = QPushButton("Submit", self.tableWidget)
        buttonSubmit.setEnabled(False)
        self.tableWidget.setCellWidget(row_number, 6, buttonSubmit)

        # Connect selection signals
        comboBoxPatchport.currentIndexChanged.connect(
            lambda i, row_number=row_number: self._patchport_selected(row_number))
        comboBoxVlans.currentIndexChanged.connect(
            lambda i, row_number=row_number: self._vlanname_selected(row_number))
        buttonSubmit.clicked.connect(
            lambda i, row_number=row_number: self._submit_pressed(row_number))

        self.fillPatchports(comboBoxPatchport)
        self.fillVlans(comboBoxVlans)

        # Connect slots to add a row
        comboBoxVlans.currentIndexChanged.connect(
            lambda i, row_number=row_number: self._row_edited(row_number))
        comboBoxPatchport.currentIndexChanged.connect(
            lambda i, row_number=row_number: self._row_edited(row_number))

        # Resize
        self.tableWidget.resizeColumnsToContents()

def unitsChanged(self):
        label = "Distance [{}]".format(UNITS[self.unitsComboBox.currentIndex()])
        item = QTableWidgetItem(label)
        self.tableWidget.setHorizontalHeaderItem(2, item)
        ptcnt = len(self.capturedPoints)
        if ptcnt >= 2:
            i = 0
            while i < ptcnt-1:
                item = QTableWidgetItem('{:.4f}'.format(self.unitDistance(self.distances[i])))
                self.tableWidget.setItem(i, 2, item)
                i += 1
            self.formatTotal()

def insertParams(self, position, distance, startAngle, endAngle):
        if position > self.tableWidget.rowCount():
            self.tableWidget.insertRow(position-1)
        item = QTableWidgetItem('{:.4f}'.format(self.unitDistance(distance)))
        item.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
        self.tableWidget.setItem(position-1, 2, item)
        item = QTableWidgetItem('{:.4f}'.format(startAngle))
        item.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
        self.tableWidget.setItem(position-1, 0, item)
        item = QTableWidgetItem('{:.4f}'.format(endAngle))
        item.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
        self.tableWidget.setItem(position-1, 1, item)

def setMyData(self):
        for row, item in enumerate (self.data):
            title_item = QtGui.QTableWidgetItem(item[0])
            font = title_item.font()
            font.setBold(True)
            title_item.setFont(font)
            if self.use_icons:
                icon = QtGui.QIcon(icon_dir + item[1].split('/')[2] + '.png')
                if icon.pixmap(16, 16).isNull(): icon = QtGui.QIcon.fromTheme('applications-internet')
                title_item.setIcon(icon)
            self.setItem(row, 0, title_item)

def limpiatablas(self):
        self.tableWidget.clear()
        self.tableWidget.setColumnCount(4)
        self.tableWidget.setRowCount(0)
        headerItem = QtGui.QTableWidgetItem()
        headerItem.setText(QtGui.QApplication.translate("MainWindow", "Method", None, QtGui.QApplication.UnicodeUTF8))
        self.tableWidget.setHorizontalHeaderItem(0,headerItem)

        headerItem1 = QtGui.QTableWidgetItem()
        headerItem1.setText(QtGui.QApplication.translate("MainWindow", "Target", None, QtGui.QApplication.UnicodeUTF8))
        self.tableWidget.setHorizontalHeaderItem(1,headerItem1)

        headerItem2 = QtGui.QTableWidgetItem()
        headerItem2.setText(QtGui.QApplication.translate("MainWindow", "Url", None, QtGui.QApplication.UnicodeUTF8))
        self.tableWidget.setHorizontalHeaderItem(2,headerItem2)

        headerItem3 = QtGui.QTableWidgetItem()
        headerItem3.setText(QtGui.QApplication.translate("MainWindow", "Cookies", None, QtGui.QApplication.UnicodeUTF8))
        self.tableWidget.setHorizontalHeaderItem(3,headerItem3)

        self.tableWidget_2.clear()
        self.tableWidget_2.setColumnCount(2)
        self.tableWidget_2.setRowCount(0)

        headerItem4 = QtGui.QTableWidgetItem()
        headerItem4.setText(QtGui.QApplication.translate("MainWindow", "Variable", None, QtGui.QApplication.UnicodeUTF8))
        self.tableWidget_2.setHorizontalHeaderItem(0,headerItem4)

        headerItem5 = QtGui.QTableWidgetItem()
        headerItem5.setText(QtGui.QApplication.translate("MainWindow", "Value", None, QtGui.QApplication.UnicodeUTF8))
        self.tableWidget_2.setHorizontalHeaderItem(1,headerItem5)

def cambiaPeticion(self,row,col,row2,col2):
        "Cada vez que se aprieta una peticion de la tabla. row2 y col 2 no se utilizan"
        requests=self.controller.getRequests()

        if self.numRequests:    
            self.requestEdit.clear()
            self.requestEdit.append(requests[row].getAll())
            self.responseEdit.clear()
            self.responseEdit.setPlainText(requests[row].response.getAll())

            self.tableWidget_2.clear()
            self.tableWidget_2.setColumnCount(2)
            self.tableWidget_2.setRowCount(0)

            headerItem4 = QtGui.QTableWidgetItem()
            headerItem4.setText(QtGui.QApplication.translate("MainWindow", "Variable", None, QtGui.QApplication.UnicodeUTF8))
            self.tableWidget_2.setHorizontalHeaderItem(0,headerItem4)

            headerItem5 = QtGui.QTableWidgetItem()
            headerItem5.setText(QtGui.QApplication.translate("MainWindow", "Value", None, QtGui.QApplication.UnicodeUTF8))
            self.tableWidget_2.setHorizontalHeaderItem(1,headerItem5)

            a=0
            for i in requests[row].variablesGET():
                self.tableWidget_2.insertRow(a)
                self.tableWidget_2.setItem(a,0,QtGui.QTableWidgetItem(i))
                self.tableWidget_2.setItem(a,1,QtGui.QTableWidgetItem(requests[row].getVariableGET(i)))
                a+=1

            for i in requests[row].variablesPOST():
                self.tableWidget_2.insertRow(a)
                self.tableWidget_2.setItem(a,0,QtGui.QTableWidgetItem(i))
                self.tableWidget_2.setItem(a,1,QtGui.QTableWidgetItem(requests[row].getVariablePOST(i)))
                a+=1

            self.tableWidget_2.resizeColumnToContents(0)
            self.tableWidget_2.resizeColumnToContents(1)
            self.tableWidget_2.resizeRowsToContents()

def setNewCookie(self):
        requests=self.controller.getRequests()
        indexes=[]

        n=self.tableWidget.rowCount()
        for i in range(n):
            if not self.tableWidget.isRowHidden(i):
                indexes.append(i)

        for i in indexes:
            requests[i].addHeader("Cookie",str(self.cookieEdit.text()))
            self.tableWidget.setItem(i,3,QtGui.QTableWidgetItem(str(self.cookieEdit.text())))

def loadData(self, data):       
        table = self.main.tableWidget
        #item = QtGui.QTableWidgetItem(binascii.hexlify(self.getBinaryData(1)))
        self.bdata  = self.getBinaryData(1024)
        print len(self.bdata)
        rows = (len(self.bdata)/BYTES_PER_ROW)+1
        table.setRowCount(rows)
        numcols = table.columnCount()

        datacnt = 0
        datalen = len(self.bdata)
        rowstr = ""

        for row in range(0, rows):            
            for column in range(0, BYTES_PER_ROW):
                if datacnt == datalen:
                    colsleft = BYTES_PER_ROW-column
                    for colleft in range(0, colsleft):
                        disabled = QtGui.QTableWidgetItem("")
                        disabled.setFlags(QtCore.Qt.ItemIsEnabled)
                        table.setItem(row, colleft+column, disabled)
                        #.setFlags(QtCore.Qt.ItemIsEnabled)
                    break                            
                rowstr += self.bdata[datacnt]
                colItem = QtGui.QTableWidgetItem(binascii.hexlify(self.bdata[datacnt]))            
                colItem.setFont(self.fixedWidthFont())
                table.setItem(row, column, colItem)


                datacnt += 1
            rowItem = QtGui.QTableWidgetItem(self.prettyPrint(rowstr))
            rowItem.setFont(self.fixedWidthFont())
            rowItem.setFlags(QtCore.Qt.ItemIsEnabled)
            table.setItem(row, table.columnCount()-1, rowItem)
            rowstr = ""

def doStuff(self):
        table = self.main.tableWidget
        headerItem = QtGui.QTableWidgetItem()
        headerItem.setText("Yay")
        self.getBinaryData(128)

def addField(self):
        fieldName = self.ui.fieldsComboBox.currentText()
        if not fieldName:
            QtGui.QMessageBox.critical(None, "Error", 'No field specified!')
            return

        if not self.checkFieldInTable(fieldName):
            self.ui.fieldsTable.setRowCount(self.ui.fieldsTable.rowCount()+1)
            self.ui.fieldsTable.setItem(self.ui.fieldsTable.rowCount()-1, 0, QtGui.QTableWidgetItem(fieldName))
            self.ui.fieldsTable.setItem(self.ui.fieldsTable.rowCount()-1, 1, QtGui.QTableWidgetItem('1.0'))

def __init__(self,parent=None):
        QtGui.QTableWidget.__init__(self,parent)
        # initially construct the visible table
        self.setRowCount(512)
        self.setColumnCount(3)
        self.setHorizontalHeaderLabels(['Actual','Read','scale factor'])
        self.setVerticalHeaderLabels(['socket','330pF','680pF','2220pF','PCS','','550uA','.55uA','5.5uA','55uA',''])

        self.setTextElideMode(QtCore.Qt.ElideRight)
        self.setGridStyle(QtCore.Qt.DashLine)
        self.setRowCount(11)
        self.horizontalHeader().setDefaultSectionSize(90)
        self.horizontalHeader().setMinimumSectionSize(90)
        self.horizontalHeader().setSortIndicatorShown(False)
        self.horizontalHeader().setStretchLastSection(True)
        self.verticalHeader().setStretchLastSection(True)

        num = 0
        for a in ['0','329.5e-12','698e-12','2168e-12','1e-3']:
                item = QtGui.QTableWidgetItem()
                self.setItem(num,0,item)
                item.setText(a)

                item = QtGui.QTableWidgetItem()
                self.setItem(num,1,item)
                item.setText(a)

                item = QtGui.QTableWidgetItem()
                self.setItem(num+5,2,item)
                item.setText('1')

                num+=1
        item = QtGui.QTableWidgetItem()
        self.setItem(num-1,2,item)
        item.setText('1')

        item = QtGui.QTableWidgetItem()
        self.setItem(num,2,item)
        item.setText('0')