예제 #1
0
 def _addRow(self, name, value):
     rc = self.frm.posTbl.rowCount()
     self.frm.posTbl.setRowCount(rc + 1)
     self.frm.posTbl.setItem(rc, 0, QTableWidgetItem(name))
     self.frm.posTbl.setItem(rc, 1, QTableWidgetItem(value))
     self.frm.posTbl.resizeColumnsToContents()
     self.frm.posTbl.resizeRowsToContents()
예제 #2
0
def configToFrame(frame, config):
    frame.nameBox.setText(config['name'])
    frame.commentBox.setText(config['comment'])
    frame.thickBox.setText(str(config['thickness']))
    frame.posTbl.setRowCount(len(config['position']))
    for i, (dev_name, position) in enumerate(config['position'].items()):
        frame.posTbl.setItem(i, 0, QTableWidgetItem(dev_name))
        frame.posTbl.setItem(i, 1, QTableWidgetItem(str(position)))
    frame.posTbl.resizeRowsToContents()
    frame.posTbl.resizeColumnsToContents()
예제 #3
0
def configToFrame(frame, config):
    frame.nameBox.setText(config['name'])
    frame.commentBox.setText(config['comment'])
    frame.offsetBox.setText(str(config['detoffset']))
    frame.thickBox.setText(str(config['thickness']))
    frame.factorBox.setText(str(config['timefactor']))
    frame.posTbl.setRowCount(len(config['position']))
    frame.apXBox.setText(str(config['aperture'][0]))
    frame.apYBox.setText(str(config['aperture'][1]))
    frame.apWBox.setText(str(config['aperture'][2]))
    frame.apHBox.setText(str(config['aperture'][3]))
    for i, (devname, position) in enumerate(iteritems(config['position'])):
        frame.posTbl.setItem(i, 0, QTableWidgetItem(devname))
        frame.posTbl.setItem(i, 1, QTableWidgetItem(str(position)))
    frame.posTbl.resizeRowsToContents()
    frame.posTbl.resizeColumnsToContents()
예제 #4
0
    def _set_first_positions(self, dialog):
        values = self._get_first_position_values(dialog)
        if not values:
            return

        _table = self.frame.firstPosTable
        for i in range(_table.rowCount()):
            for j in (0, 1):
                _item = QTableWidgetItem(values[i][j])
                _table.setItem(i, j, _item)
예제 #5
0
 def addRow(self, dic):
     if self._edit:
         self._stopEdit()
     self._rows.append(dic)
     last = self.table.rowCount()
     self.table.setRowCount(last + 1)
     for i, (eltype, _) in enumerate(self.measdef.getElements()):
         item = QTableWidgetItem(dic[eltype].getDispValue())
         self.table.setItem(last, i, item)
     self.table.resizeRowsToContents()
예제 #6
0
 def addRow(self, elements=None):
     if self._edit:
         self._stopEdit()
     last = self.table.rowCount()
     self.table.setRowCount(last + 1)
     if elements is None:
         elements = [Device(dev, self.client) for dev in self.devs]
     for (i, element) in enumerate(elements):
         self.table.setItem(last, i,
                            QTableWidgetItem(element.getDispValue()))
     self._rows.append(elements)
     self.table.resizeRowsToContents()
예제 #7
0
    def _update_device(self, devname):
        try:
            parlist = self.client.eval('session.getDevice(%r)._dev.'
                                       'ListParams()' % devname)
            cmdlist = self.client.eval('session.getDevice(%r)._dev.'
                                       'ListCmds()' % devname)
        except Exception:
            QMessageBox.warning(
                self, 'Error', 'Could not retrieve the param/'
                'command list from device.')
            return
        self.controlBox.setEnabled(True)

        self._par_values = {}
        self._changed_pars = {}
        self.paramTable.clear()
        self.paramTable.setColumnCount(2)
        self.paramTable.setRowCount(len(parlist))
        for (i, par) in enumerate(parlist):
            nameitem = QTableWidgetItem(par)
            nameitem.setFlags(nameitem.flags() & ~Qt.ItemIsEditable)
            self.paramTable.setItem(i, 0, nameitem)
            value = self.client.eval('session.getDevice(%r)._dev.'
                                     'GetParam(%r)' % (devname, par),
                                     default=None)
            valuestr = '<error>' if value is None else '%.6g' % value
            self._par_values[par] = valuestr
            self.paramTable.setItem(i, 1, QTableWidgetItem(valuestr))
        self.paramTable.resizeRowsToContents()
        self.paramTable.resizeColumnToContents(0)

        self.cmdList.clear()
        for cmd in cmdlist:
            QListWidgetItem(cmd, self.cmdList)
예제 #8
0
 def on_client_connected(self):
     self.clear()
     self.table.setRowCount(len(bit_description))
     for m in range(len(bit_description)):
         for n in [0, 1]:
             newitem = QTableWidgetItem()
             self.table.setItem(m, n, newitem)
         self.table.item(m, 1).setText(bit_description[m])
     params = self.client.getDeviceParams(self.devname)
     if params:
         value = params.get('value')
         if value:
             self._update_table(value)
예제 #9
0
 def __init__(self,
              parent,
              validator,
              curvalue,
              fmtstr,
              client,
              allow_enter=False):
     self._rows, self._cols = curvalue.shape
     self.validator = validator
     QTableWidget.__init__(self, self._rows, self._cols, parent)
     for i in range(self._rows):
         for j in range(self._cols):
             self.setItem(i, j, QTableWidgetItem(fmtstr % curvalue[i, j]))
     self.cellChanged.connect(lambda i, j: self.valueModified.emit())
예제 #10
0
파일: cmdlets.py 프로젝트: ess-dmsc/nicos
 def updateTable(self):
     self.table.setRowCount(0)
     table = self.measdef.getTable()
     if not table:
         return
     first = table[0]
     self.table.setRowCount(len(table))
     self.table.setColumnCount(len(first))
     self.table.setHorizontalHeaderLabels(first.keys())
     total_time = 0
     for i, entry in enumerate(table):
         for j, element in enumerate(entry.values()):
             item = QTableWidgetItem(element.getDispValue())
             self.table.setItem(i, j, item)
             if element.eltype == 'time':
                 total_time += element.getValue()
     self.table.resizeRowsToContents()
     self.totalTime.setText(formatDuration(total_time))
     self.changed()
예제 #11
0
 def __init__(self, value):
     QTableWidgetItem.__init__(self, str(value))
     self.value = value
예제 #12
0
파일: pgaa.py 프로젝트: umithardal/nicos
 def setColumnHeaders(self, column_headers):
     self.setColumnCount(len(column_headers))
     for i, text in enumerate(column_headers):
         self.setHorizontalHeaderItem(i, QTableWidgetItem(text))
예제 #13
0
    def setCurrentDataset(self, plot):
        if self.currentPlot:
            self.plotLayout.removeWidget(self.currentPlot)
            self.currentPlot.hide()
            self.metaTable.clearContents()
        self.currentPlot = plot
        if plot is None:
            self.enablePlotActions(False)
        else:
            try:
                self.setUidStack.remove(plot.dataset.uid)
            except ValueError:
                pass
            self.setUidStack.append(plot.dataset.uid)

            num_items = 0
            for catname in INTERESTING_CATS:
                if catname in plot.dataset.headerinfo:
                    num_items += 2 + len(plot.dataset.headerinfo[catname])
            num_items -= 1  # remove last empty row
            self.metaTable.setRowCount(num_items)

            i = 0
            for catname in INTERESTING_CATS:
                if catname in plot.dataset.headerinfo:
                    values = plot.dataset.headerinfo[catname]
                    catdesc = catname
                    for name_desc in INFO_CATEGORIES:
                        if name_desc[0] == catname:
                            catdesc = name_desc[1]
                    catitem = QTableWidgetItem(catdesc)
                    font = catitem.font()
                    font.setBold(True)
                    catitem.setFont(font)
                    self.metaTable.setItem(i, 0, catitem)
                    self.metaTable.setSpan(i, 0, 1, 2)
                    i += 1
                    for dev, name, value in sorted(values):
                        key = '%s_%s' % (dev, name) if name != 'value' else dev
                        self.metaTable.setItem(i, 0, QTableWidgetItem(key))
                        self.metaTable.setItem(i, 1, QTableWidgetItem(value))
                        if self.metaTable.columnSpan(i, 0) == 2:
                            self.metaTable.setSpan(i, 0, 1, 1)
                        i += 1
                    i += 1
            self.metaTable.resizeRowsToContents()

            self.enablePlotActions(True)
            self.enableAutoScaleActions(self.currentPlot.HAS_AUTOSCALE)
            self.datasetList.setCurrentItem(self.setitems[plot.dataset.uid])

            self.actionXAxis.setText('X axis: %s' % plot.current_xname)
            self.actionNormalized.setChecked(bool(plot.normalized))

            self.actionLogScale.setChecked(plot.isLogScaling())
            self.actionLogXScale.setChecked(plot.isLogXScaling())
            self.actionLegend.setChecked(plot.isLegendEnabled())
            self.actionErrors.setChecked(plot.isErrorBarEnabled())
            if plot.HAS_AUTOSCALE:
                from gr.pygr import PlotAxes
                mask = plot.plot.autoscale
                self._autoscale(x=mask & PlotAxes.SCALE_X,
                                y=mask & PlotAxes.SCALE_Y)
                plot.logYinDomain.connect(self.on_logYinDomain)
                plot.logXinDomain.connect(self.on_logXinDomain)
            self.plotLayout.addWidget(plot)
            plot.show()
예제 #14
0
 def _configure_item():
     item = QTableWidgetItem(str(0.0))
     item.setFlags(Qt.ItemIsEnabled)
     item.setBackground(Qt.lightGray)
     return item
예제 #15
0
 def _create_table_widget(self, value):
     return QTableWidgetItem('%s' % value)