def create_ui_components(self):
self.layout = QGridLayout()
self.statPlot = MplWidget()
(self.refreshPlot, self.runTest, self.clearStats,
self.switchFreqDom, self.statInfo, self.testNumber,
self.targetMaxPicked, self.beginTest, self.testProgress) = \
(QPushButton('&Refresh'), QPushButton('&Test'), QPushButton('&Clear'),
QPushButton('&Switch'), QLabel(''), QSpinBox(), QSpinBox(), QPushButton('Go!'),
QProgressBar())
def __init__(self):
QWidget.__init__(self)
self.main_layout = QGridLayout()
self.steps_spin = QSpinBox()
self.steps_spin.setRange(1, 12)
self.steps_label = QLabel("steps:")
self.steps_slider = QSlider(1) #horizontal
self.steps_slider.setRange(1, 12)
self.smooth_spin = QSpinBox()
self.smooth_spin.setRange(1, 100)
self.smooth_label = QLabel("smoothness:")
self.smooth_slider = QSlider(1) #horizontal
self.smooth_slider.setRange(0, 100)
self.smooth_slider.setSingleStep(1)
self.dampen_spin = QSpinBox()
self.dampen_spin.setRange(1, 100)
self.dampen_label = QLabel("dampening:")
self.dampen_slider = QSlider(1) #horizontal
self.dampen_slider.setRange(0, 100)
self.dampen_slider.setSingleStep(1)
self.update_button = QPushButton("update")
self.view = QGraphicsView()
self.main_layout.addWidget(self.steps_spin, 0, 0)
self.main_layout.addWidget(self.steps_label, 0, 1)
self.main_layout.addWidget(self.steps_slider, 0, 2)
self.main_layout.addWidget(self.smooth_spin, 1, 0)
self.main_layout.addWidget(self.smooth_label, 1, 1)
self.main_layout.addWidget(self.smooth_slider, 1, 2)
self.main_layout.addWidget(self.dampen_spin, 2, 0)
self.main_layout.addWidget(self.dampen_label, 2, 1)
self.main_layout.addWidget(self.dampen_slider, 2, 2)
self.main_layout.addWidget(self.update_button, 3, 0, 1, 3)
self.main_layout.addWidget(
self.view,
4,
0,
1, #rowSpan
3) #columnSpan
self.setLayout(self.main_layout)
def __init__(self, page):
super(MusicView, self).__init__(page)
layout = QGridLayout()
self.setLayout(layout)
self.newerFilesOnly = QCheckBox(toggled=self.changed)
layout.addWidget(self.newerFilesOnly, 0, 0, 1, 3)
self.magnifierSizeLabel = QLabel()
self.magnifierSizeSlider = QSlider(Qt.Horizontal,
valueChanged=self.changed)
self.magnifierSizeSlider.setSingleStep(50)
self.magnifierSizeSlider.setRange(
*popplerview.MagnifierSettings.sizeRange)
self.magnifierSizeSpinBox = QSpinBox()
self.magnifierSizeSpinBox.setRange(
*popplerview.MagnifierSettings.sizeRange)
self.magnifierSizeSpinBox.valueChanged.connect(
self.magnifierSizeSlider.setValue)
self.magnifierSizeSlider.valueChanged.connect(
self.magnifierSizeSpinBox.setValue)
layout.addWidget(self.magnifierSizeLabel, 1, 0)
layout.addWidget(self.magnifierSizeSlider, 1, 1)
layout.addWidget(self.magnifierSizeSpinBox, 1, 2)
self.magnifierScaleLabel = QLabel()
self.magnifierScaleSlider = QSlider(Qt.Horizontal,
valueChanged=self.changed)
self.magnifierScaleSlider.setSingleStep(50)
self.magnifierScaleSlider.setRange(
*popplerview.MagnifierSettings.scaleRange)
self.magnifierScaleSpinBox = QSpinBox()
self.magnifierScaleSpinBox.setRange(
*popplerview.MagnifierSettings.scaleRange)
self.magnifierScaleSpinBox.valueChanged.connect(
self.magnifierScaleSlider.setValue)
self.magnifierScaleSlider.valueChanged.connect(
self.magnifierScaleSpinBox.setValue)
layout.addWidget(self.magnifierScaleLabel, 2, 0)
layout.addWidget(self.magnifierScaleSlider, 2, 1)
layout.addWidget(self.magnifierScaleSpinBox, 2, 2)
self.enableKineticScrolling = QCheckBox(toggled=self.changed)
layout.addWidget(self.enableKineticScrolling)
self.showScrollbars = QCheckBox(toggled=self.changed)
layout.addWidget(self.showScrollbars)
app.translateUI(self)
def __init__(self, parent=None):
super(ObjectWidget, self).__init__(parent)
l_nbr_steps = QLabel("Nbr Steps ")
self.nbr_steps = QSpinBox()
self.nbr_steps.setMinimum(3)
self.nbr_steps.setMaximum(100)
self.nbr_steps.setValue(6)
self.nbr_steps.valueChanged.connect(self.update_param)
l_cmap = QLabel("Cmap ")
self.cmap = sorted(get_colormaps().keys())
self.combo = QComboBox(self)
self.combo.addItems(self.cmap)
self.combo.currentIndexChanged.connect(self.update_param)
gbox = QGridLayout()
gbox.addWidget(l_cmap, 0, 0)
gbox.addWidget(self.combo, 0, 1)
gbox.addWidget(l_nbr_steps, 1, 0)
gbox.addWidget(self.nbr_steps, 1, 1)
vbox = QVBoxLayout()
vbox.addLayout(gbox)
vbox.addStretch(1.0)
self.setLayout(vbox)
def __get_widget_for_primitive_types(self, key, value):
"""
return right widget and connect the value with config_manager
:param key:
:param value:
:return:
"""
if key in self.dropdownboxes.keys():
atomic_widget = self._create_dropdownbox(key,value)
self.config.add_handler(key, atomic_widget)
elif key in self.radiobuttons.keys():
atomic_widget = self._create_radiobutton(key,value)
self.config.add_handler(key, atomic_widget)
elif type(value) is int:
atomic_widget = QSpinBox()
atomic_widget.setRange(-100000, 100000)
self.config.add_handler(key, atomic_widget)
elif type(value) is float:
atomic_widget = QDoubleSpinBox()
atomic_widget.setDecimals(6)
atomic_widget.setMaximum(1000000000)
self.config.add_handler(key, atomic_widget)
elif type(value) is str:
atomic_widget = QLineEdit()
self.config.add_handler(key, atomic_widget)
elif type(value) is bool:
atomic_widget = QCheckBox()
self.config.add_handler(key, atomic_widget)
else:
return None
return atomic_widget
def createEditor( self, parent, option, index ):
if index.column() == CANTIDAD:
max_items = index.model().lines[index.row()].existencia
if max_items < 1 :
return None
spinbox = QSpinBox( parent )
spinbox.setRange( 0, max_items )
spinbox.setSingleStep( 1 )
spinbox.setAlignment( Qt.AlignRight | Qt.AlignVCenter )
return spinbox
elif index.column() == DESCRIPCION :
if self.articles.rowCount() > 0:
self.proxymodel.setSourceModel( self.articles )
model = index.model()
current = model.index( index.row(), IDARTICULOEX ).data()
self.proxymodel.setFilterRegExp( self.filter( model , current ) )
sp = super( FacturaDelegate, self ).createEditor( parent, option, index )
#sp.setColumnHidden( IDBODEGAEX )
#sp.setColumnHidden( IDARTICULOEX )
return sp
elif index.column() == TOTALPROD:
return None
elif index.column() == PRECIO:
spinbox = QDoubleSpinBox( parent )
spinbox.setRange( 0.0001, 10000 )
spinbox.setDecimals( 4 )
spinbox.setSingleStep( 1 )
spinbox.setAlignment( Qt.AlignRight | Qt.AlignVCenter )
return spinbox
else:
super( FacturaDelegate, self ).createEditor( parent, option, index )
def __init__(self, parent=None):
super(Options, self).__init__(parent)
self.setWindowIcon(QIcon('res/opciones4.png'))
self.setWindowTitle('Opciones')
self.options = load_data()['options']
self.chk_mask = QCheckBox(u'Máscara por defecto.')
self.line_mask = LineEdit(u'máscara', ['required', 'ms'])
self.line_mask.focusInEvent = lambda _: self.block_focus_event()
if self.options[0]:
self.chk_mask.setChecked(True)
self.line_mask.setText(self.options[1])
self.chk_dns = QCheckBox('Servidor dns por defecto.')
self.line_dns = LineEdit('Servidor dns', ['required', 'ip'])
self.line_dns.focusInEvent = lambda _: self.block_focus_event()
self.line_mask.setCursor(QCursor(Qt.ForbiddenCursor))
if self.options[2]:
self.chk_dns.setChecked(True)
self.line_dns.setText(self.options[3])
self.status(self.chk_mask.isChecked(), self.line_mask)
self.status(self.chk_dns.isChecked(), self.line_dns)
lbl = QLabel('Cantidad de Configuraciones permitidas.')
spin = QSpinBox()
spin.setRange(1, 8)
spin.setValue(self.options[4])
spin.setMaximumWidth(50)
lbl.setBuddy(spin)
btn_ok = QPushButton('OK')
btn_ok.setMaximumWidth(200)
btn_ok.setObjectName('btn_ok')
btn_cancel = QPushButton('Cancel')
btn_cancel.setMaximumWidth(200)
btn_cancel.setObjectName('btn_cancel')
layout = QGridLayout()
layout.addWidget(self.chk_mask, 0, 0, 1, 3)
layout.addWidget(self.line_mask, 1, 0, 1, 3)
layout.addWidget(self.chk_dns, 2, 0, 1, 3)
layout.addWidget(self.line_dns, 3, 0, 1, 3)
layout.addWidget(lbl, 4, 0)
layout.addWidget(spin, 4, 1)
layout.addWidget(QLabel(''), 5, 0)
layout.addWidget(btn_cancel, 6, 1)
layout.addWidget(btn_ok, 6, 2)
self.setLayout(layout)
self.connect(self.chk_mask, SIGNAL('clicked(bool)'), self.set_disable_mask)
self.connect(self.chk_dns, SIGNAL('clicked(bool)'), self.set_disable_dns)
self.connect(btn_ok, SIGNAL('clicked()'), self.save_and_exit)
self.connect(btn_ok, SIGNAL('returnPressed()'), self.save_and_exit)
self.connect(spin, SIGNAL('valueChanged(int)'), self.spin_value)
self.connect(btn_cancel, SIGNAL("clicked()"), self.reject)
def _populateFormCB(self, config):
cfg = json.loads(config)
cfg = Helpers.makeDictKeysInt(cfg)
if 'Inputsignals' not in cfg:
pass
else:
signalsin = cfg['Inputsignals']
it = {}
for k, item in signalsin.iteritems():
it[item['name']] = k
self.addComboBox('InputSignal', 'input signal', it)
self.addLineEdit('Duration', 'Duration of one run in milliseconds')
self.settings['Duration'].setText(str(100))
spin = QSpinBox()
spin.setRange(2**8, 2**16)
spin.setSingleStep(2**8)
spin.setValue(2**11)
self.addSetting('Samples', 'Number of bytes to be read.', spin)
sampling = QLabel()
sampling.setText(str(2**11 / 100.0) + ' kS/s')
self.addSetting('Sampling', 'Resulting sampling rate', sampling)
self.addCheckBox('Loop', 'Run infinitely')
self.settings['Loop'].setChecked(True)
spin.valueChanged.connect(self.spinValueChangedCB)
self.settings['Duration'].textChanged.connect(
self.durationValueChangedCB)
def createQuadViewStatusBar(self, xbackgroundColor, xforegroundColor,
ybackgroundColor, yforegroundColor,
zbackgroundColor, zforegroundColor):
self.xLabel, self.xSpinBox = _get_pos_widget('X', xbackgroundColor,
xforegroundColor)
self.yLabel, self.ySpinBox = _get_pos_widget('Y', ybackgroundColor,
yforegroundColor)
self.zLabel, self.zSpinBox = _get_pos_widget('Z', zbackgroundColor,
zforegroundColor)
self.addWidget(self.xLabel)
self.addWidget(self.xSpinBox)
self.addWidget(self.yLabel)
self.addWidget(self.ySpinBox)
self.addWidget(self.zLabel)
self.addWidget(self.zSpinBox)
self.addStretch()
self.positionCheckBox = QCheckBox()
self.positionCheckBox.setChecked(True)
self.positionCheckBox.setCheckable(True)
self.positionCheckBox.setText("Position")
self.addWidget(self.positionCheckBox)
self.addSpacing(20)
self.timeLabel = QLabel("Time:")
self.addWidget(self.timeLabel)
self.timeSpinBox = QSpinBox()
self.addWidget(self.timeSpinBox)
def __init__(self, capture_context, parent):
"""Initializes the dialog.
`capture_context` is the detection.ExamCaptureContext object
to be used.
"""
super(DialogCameraSelection, self).__init__(parent)
self.capture_context = capture_context
self.setWindowTitle(_('Select a camera'))
layout = QVBoxLayout(self)
self.setLayout(layout)
self.camview = widgets.CamView((320, 240), self, border=True)
self.label = QLabel(self)
self.button = QPushButton(_('Try this camera'))
self.camera_selector = QSpinBox(self)
container = widgets.LineContainer(self, self.camera_selector,
self.button)
self.button.clicked.connect(self._select_camera)
buttons = QDialogButtonBox(QDialogButtonBox.Ok)
buttons.accepted.connect(self.accept)
layout.addWidget(self.camview)
layout.addWidget(self.label)
layout.addWidget(container)
layout.addWidget(buttons)
self.camera_error.connect(self._show_camera_error,
type=Qt.QueuedConnection)
self.timer = None
def create_widgets(self):
punctuationRe = QRegExp(r"[ ,;:.]")
self.thousandsLabel = QLabel("&Thousands separator")
self.thousandsEdit = QLineEdit(self.format["thousandsseparator"])
self.thousandsLabel.setBuddy(self.thousandsEdit)
self.thousandsEdit.setMaxLength(1)
self.thousandsEdit.setValidator(QRegExpValidator(punctuationRe, self))
self.decimalMarkerLabel = QLabel("Decimal &marker")
self.decimalMarkerEdit = QLineEdit(self.format["decimalmarker"])
self.decimalMarkerLabel.setBuddy(self.decimalMarkerEdit)
self.decimalMarkerEdit.setMaxLength(1)
self.decimalMarkerEdit.setValidator(
QRegExpValidator(punctuationRe, self))
self.decimalMarkerEdit.setInputMask("X")
self.decimalPlacesLabel = QLabel("&Decimal places")
self.decimalPlacesSpinBox = QSpinBox()
self.decimalPlacesLabel.setBuddy(self.decimalPlacesSpinBox)
self.decimalPlacesSpinBox.setRange(0, 6)
self.decimalPlacesSpinBox.setValue(self.format["decimalplaces"])
self.redNegativesCheckBox = QCheckBox("&Red negative numbers")
self.redNegativesCheckBox.setChecked(self.format["rednegatives"])
self.buttonBox = QDialogButtonBox(QDialogButtonBox.Apply
| QDialogButtonBox.Close)
def __init__(self, *args):
PluginBase.__init__(self, BrickletOzone, *args)
self.ozone = self.device
self.cbe_ozone_concentration = CallbackEmulator(
self.ozone.get_ozone_concentration, self.cb_ozone_concentration,
self.increase_error_count)
self.current_ozone_concentration = None
plots = [('Ozone Concentration', Qt.red,
lambda: self.current_ozone_concentration, '{} ppb'.format)]
self.plot_widget = PlotWidget('Ozone Concentration [ppb]', plots)
self.spin_average = QSpinBox()
self.spin_average.setMinimum(1)
self.spin_average.setMaximum(50)
self.spin_average.setSingleStep(1)
self.spin_average.setValue(50)
self.spin_average.editingFinished.connect(self.spin_average_finished)
hlayout = QHBoxLayout()
hlayout.addWidget(QLabel('Moving Average Length:'))
hlayout.addWidget(self.spin_average)
hlayout.addStretch()
line = QFrame()
line.setFrameShape(QFrame.HLine)
line.setFrameShadow(QFrame.Sunken)
layout = QVBoxLayout(self)
layout.addWidget(self.plot_widget)
layout.addWidget(line)
layout.addLayout(hlayout)
def __init__(self, page):
super(Browser, self).__init__(page)
layout = QGridLayout()
self.setLayout(layout)
self.languagesLabel = QLabel()
self.languages = QComboBox(currentIndexChanged=self.changed)
layout.addWidget(self.languagesLabel, 0, 0)
layout.addWidget(self.languages, 0, 1)
items = ['', '']
items.extend(
language_names.languageName(l, l) for l in lilydoc.translations)
self.languages.addItems(items)
self.fontLabel = QLabel()
self.fontChooser = QFontComboBox(currentFontChanged=self.changed)
self.fontSize = QSpinBox(valueChanged=self.changed)
self.fontSize.setRange(6, 32)
self.fontSize.setSingleStep(1)
layout.addWidget(self.fontLabel, 1, 0)
layout.addWidget(self.fontChooser, 1, 1)
layout.addWidget(self.fontSize, 1, 2)
app.translateUI(self)
def create_spinbox(self, prefix, suffix, option, default=NoDefault,
min_=None, max_=None, step=None, tip=None):
if prefix:
plabel = QLabel(prefix)
else:
plabel = None
if suffix:
slabel = QLabel(suffix)
else:
slabel = None
spinbox = QSpinBox()
if min_ is not None:
spinbox.setMinimum(min_)
if max_ is not None:
spinbox.setMaximum(max_)
if step is not None:
spinbox.setSingleStep(step)
if tip is not None:
spinbox.setToolTip(tip)
self.spinboxes[spinbox] = (option, default)
layout = QHBoxLayout()
for subwidget in (plabel, spinbox, slabel):
if subwidget is not None:
layout.addWidget(subwidget)
layout.addStretch(1)
layout.setContentsMargins(0, 0, 0, 0)
widget = QWidget(self)
widget.setLayout(layout)
return widget
def createEditor(
self,
parent,
options,
index,
):
setting = index.model().data(index, Qt.UserRole)
if setting.valuetype == Setting.FOLDER:
return FileDirectorySelector(parent)
elif setting.valuetype == Setting.FILE:
return FileDirectorySelector(parent, True)
elif setting.valuetype == Setting.SELECTION:
combo = QComboBox(parent)
combo.addItems(setting.options)
return combo
else:
value = self.convertValue(index.model().data(index, Qt.EditRole))
if isinstance(value, (int, long)):
spnBox = QSpinBox(parent)
spnBox.setRange(-999999999, 999999999)
return spnBox
elif isinstance(value, float):
spnBox = QDoubleSpinBox(parent)
spnBox.setRange(-999999999.999999, 999999999.999999)
spnBox.setDecimals(6)
return spnBox
elif isinstance(value, (str, unicode)):
return QLineEdit(parent)
def changeTileWidth():
'''Change tile width (tile block size) and reset image-scene'''
dlg = QDialog(self)
layout = QHBoxLayout()
layout.addWidget(QLabel("Tile Width:"))
spinBox = QSpinBox(parent=dlg)
spinBox.setRange(128, 10 * 1024)
spinBox.setValue(512)
if self.editor.imageScenes[0].tileWidth:
spinBox.setValue(self.editor.imageScenes[0].tileWidth)
layout.addWidget(spinBox)
okButton = QPushButton("OK", parent=dlg)
okButton.clicked.connect(dlg.accept)
layout.addWidget(okButton)
dlg.setLayout(layout)
dlg.setModal(True)
if dlg.exec_() == QDialog.Accepted:
for s in self.editor.imageScenes:
if s.tileWidth != spinBox.value():
s.tileWidth = spinBox.value()
s.reset()
def addSpinBox(self,
attribute_name,
title,
tool_tip=None,
min_value=1,
max_value=10,
single_step=1):
sb = QSpinBox()
self[attribute_name] = sb
sb.setMaximumHeight(25)
sb_layout = QHBoxLayout()
sb_layout.addWidget(sb)
sb_layout.addStretch()
self.addRow(title, sb_layout)
if tool_tip is not None:
sb.setToolTip(tool_tip)
sb.setMinimum(min_value)
sb.setMaximum(max_value)
sb.setSingleStep(single_step)
def getter(self):
return self[attribute_name].value()
def setter(self, value):
self[attribute_name].setValue(value)
self.updateProperty(attribute_name, getter, setter)
return sb
def __init__(self, *args):
PluginBase.__init__(self, BrickletAnalogOutV2, *args)
self.ao = self.device
self.input_voltage_label = VoltageLabel()
self.output_voltage_label = QLabel('Output Voltage [mV]:')
self.output_voltage_box = QSpinBox()
self.output_voltage_box.setMinimum(0)
self.output_voltage_box.setMaximum(12000)
self.output_voltage_box.setSingleStep(1)
layout_h1 = QHBoxLayout()
layout_h1.addStretch()
layout_h1.addWidget(self.output_voltage_label)
layout_h1.addWidget(self.output_voltage_box)
layout_h1.addStretch()
layout_h2 = QHBoxLayout()
layout_h2.addStretch()
layout_h2.addWidget(self.input_voltage_label)
layout_h2.addStretch()
layout = QVBoxLayout(self)
layout.addLayout(layout_h2)
layout.addLayout(layout_h1)
layout.addStretch()
self.output_voltage_box.editingFinished.connect(self.voltage_finished)
self.cbe_input_voltage = CallbackEmulator(self.ao.get_input_voltage,
self.cb_get_input_voltage,
self.increase_error_count)
def create_widgets(self, width, height):
self.widthLabel = QLabel("&Width:")
self.widthSpinBox = QSpinBox()
self.widthLabel.setBuddy(self.widthSpinBox)
self.widthSpinBox.setAlignment(Qt.AlignRight | Qt.AlignVCenter)
self.widthSpinBox.setRange(4, width * 4)
self.widthSpinBox.setValue(width)
self.heightLabel = QLabel("&Height:")
self.heightSpinBox = QSpinBox()
self.heightLabel.setBuddy(self.heightSpinBox)
self.heightSpinBox.setAlignment(Qt.AlignRight | Qt.AlignVCenter)
self.heightSpinBox.setRange(4, height * 4)
self.heightSpinBox.setValue(height)
self.buttonBox = QDialogButtonBox(QDialogButtonBox.Ok
| QDialogButtonBox.Cancel)
def __init__(self, parent=None):
QWidget.__init__(self, parent)
layout = QFormLayout()
self.setLayout(layout)
self.desktopLabel = QLabel("Record Desktop")
self.desktopButton = QRadioButton()
layout.addRow(self.desktopLabel, self.desktopButton)
# Record Area of Desktop
areaGroup = QHBoxLayout()
self.areaLabel = QLabel("Record Region")
self.areaButton = QRadioButton()
self.setAreaButton = QPushButton("Select Region")
areaGroup.addWidget(self.areaButton)
areaGroup.addWidget(self.setAreaButton)
layout.addRow(self.areaLabel, areaGroup)
self.regionLabel = QLabel("")
self.regionLabel.setStyleSheet(
"QLabel { background-color: #ADADAD; border: 1px solid gray }")
layout.addRow(QLabel(""), self.regionLabel)
# Select screen to record
self.screenLabel = QLabel("Screen")
self.screenSpinBox = QSpinBox()
layout.addRow(self.screenLabel, self.screenSpinBox)
def setup(self):
for label, value in self.data:
if DEBUG:
print "value:", value
if label is None and value is None:
# Separator: (None, None)
self.formlayout.addRow(QLabel(" "), QLabel(" "))
self.widgets.append(None)
continue
elif label is None:
# Comment
self.formlayout.addRow(QLabel(value))
self.widgets.append(None)
continue
elif tuple_to_qfont(value) is not None:
field = FontLayout(value, self)
elif text_to_qcolor(value).isValid():
field = ColorLayout(QColor(value), self)
elif isinstance(value, (str, unicode)):
field = QLineEdit(value, self)
elif isinstance(value, (list, tuple)):
selindex = value.pop(0)
field = QComboBox(self)
if isinstance(value[0], (list, tuple)):
keys = [key for key, _val in value]
value = [val for _key, val in value]
else:
keys = value
field.addItems(value)
if selindex in value:
selindex = value.index(selindex)
elif selindex in keys:
selindex = keys.index(selindex)
elif not isinstance(selindex, int):
print >>STDERR, "Warning: '%s' index is invalid (label: " \
"%s, value: %s)" % (selindex, label, value)
selindex = 0
field.setCurrentIndex(selindex)
elif isinstance(value, bool):
field = QCheckBox(self)
if value:
field.setCheckState(Qt.Checked)
else:
field.setCheckState(Qt.Unchecked)
elif isinstance(value, float):
field = QLineEdit(repr(value), self)
elif isinstance(value, int):
field = QSpinBox(self)
field.setRange(-1e9, 1e9)
field.setValue(value)
elif isinstance(value, datetime.datetime):
field = QDateTimeEdit(self)
field.setDateTime(value)
elif isinstance(value, datetime.date):
field = QDateEdit(self)
field.setDate(value)
else:
field = QLineEdit(repr(value), self)
self.formlayout.addRow(label, field)
self.widgets.append(field)
def createEditor(self, parent, option, index):
if index.column() == TEU:
spinbox = QSpinBox(parent)
spinbox.setRange(0, 200000)
spinbox.setSingleStep(1000)
spinbox.setAlignment(Qt.AlignRight|Qt.AlignVCenter)
return spinbox
elif index.column() == OWNER:
combobox = QComboBox(parent)
combobox.addItems(sorted(index.model().owners))
combobox.setEditable(True)
return combobox
elif index.column() == COUNTRY:
combobox = QComboBox(parent)
combobox.addItems(sorted(index.model().countries))
combobox.setEditable(True)
return combobox
elif index.column() == NAME:
editor = QLineEdit(parent)
editor.returnPressed.connect(self.commitAndCloseEditor)
return editor
elif index.column() == DESCRIPTION:
editor = richtextlineedit.RichTextLineEdit(parent)
editor.returnPressed.connect(self.commitAndCloseEditor)
return editor
else:
return QStyledItemDelegate.createEditor(self, parent, option,
index)
def __init__(self, parent):
super(ProjectData, self).__init__()
self._parent = parent
grid = QGridLayout(self)
grid.addWidget(QLabel(translations.TR_PROJECT_NAME), 0, 0)
self.name = QLineEdit()
if not len(self._parent.project.name):
self.name.setText(file_manager.get_basename(
self._parent.project.path))
else:
self.name.setText(self._parent.project.name)
grid.addWidget(self.name, 0, 1)
grid.addWidget(QLabel(translations.TR_PROJECT_LOCATION), 1, 0)
self.txtPath = QLineEdit()
self.txtPath.setReadOnly(True)
self.txtPath.setText(self._parent.project.path)
grid.addWidget(self.txtPath, 1, 1)
grid.addWidget(QLabel(translations.TR_PROJECT_TYPE), 2, 0)
self.txtType = QLineEdit()
completer = QCompleter(sorted(settings.PROJECT_TYPES))
completer.setCompletionMode(QCompleter.UnfilteredPopupCompletion)
self.txtType.setCompleter(completer)
self.txtType.setPlaceholderText("python")
self.txtType.setText(self._parent.project.project_type)
grid.addWidget(self.txtType, 2, 1)
grid.addWidget(QLabel(translations.TR_PROJECT_DESCRIPTION), 3, 0)
self.description = QPlainTextEdit()
self.description.setPlainText(self._parent.project.description)
grid.addWidget(self.description, 3, 1)
grid.addWidget(QLabel(translations.TR_PROJECT_URL), 4, 0)
self.url = QLineEdit()
self.url.setText(self._parent.project.url)
self.url.setPlaceholderText('https://www.{}.com'.format(getuser()))
grid.addWidget(self.url, 4, 1)
grid.addWidget(QLabel(translations.TR_PROJECT_LICENSE), 5, 0)
self.cboLicense = QComboBox()
self.cboLicense.addItems(LICENCES)
self.cboLicense.setCurrentIndex(12)
index = self.cboLicense.findText(self._parent.project.license)
self.cboLicense.setCurrentIndex(index)
grid.addWidget(self.cboLicense, 5, 1)
self.txtExtensions = QLineEdit()
self.txtExtensions.setText(', '.join(self._parent.project.extensions))
grid.addWidget(QLabel(translations.TR_PROJECT_EXTENSIONS), 6, 0)
grid.addWidget(self.txtExtensions, 6, 1)
grid.addWidget(QLabel(translations.TR_PROJECT_INDENTATION), 7, 0)
self.spinIndentation = QSpinBox()
self.spinIndentation.setValue(self._parent.project.indentation)
self.spinIndentation.setRange(2, 10)
self.spinIndentation.setValue(4)
self.spinIndentation.setSingleStep(2)
grid.addWidget(self.spinIndentation, 7, 1)
self.checkUseTabs = QComboBox()
self.checkUseTabs.addItems([
translations.TR_PREFERENCES_EDITOR_CONFIG_SPACES.capitalize(),
translations.TR_PREFERENCES_EDITOR_CONFIG_TABS.capitalize()])
self.checkUseTabs.setCurrentIndex(int(self._parent.project.use_tabs))
grid.addWidget(self.checkUseTabs, 7, 2)
def __init__(self, name, value, categoryName=None):
""" Constructor
"""
Property.__init__(self, name, categoryName)
QWidget.__init__(self)
self.setLayout(QHBoxLayout())
self.layout().setSpacing(0)
self.layout().setContentsMargins(0, 0, 0, 0)
self._spinbox = QSpinBox()
#self.maxint = sys.maxint # does not work on Mac OS X (Snow Leopard 10.6.2), confusion between 32 and 64 bit limits
self.maxint = 2**31
self._spinbox.setRange(-self.maxint + 1, self.maxint - 1)
self._spinbox.setFrame(False)
self.layout().addWidget(self._spinbox)
self.setFocusProxy(self._spinbox)
self._lineedit = QLineEdit()
self._lineedit.setReadOnly(True)
self._lineedit.setFrame(False)
self._lineedit.setContentsMargins(0, 0, 0, 0)
self.layout().addWidget(self._lineedit)
self._lineedit.hide()
self.setValue(value)
self.connect(self._spinbox, SIGNAL('valueChanged(int)'),
self.valueChanged)
def createTimeStepRow(self):
history_length_spinner = QSpinBox()
addHelpToWidget(history_length_spinner, "config/init/history_length")
history_length_spinner.setMinimum(0)
history_length_spinner.setMaximum(getHistoryLength())
initial = QToolButton()
initial.setText("Initial")
addHelpToWidget(initial, "config/init/history_length")
def setToMin():
history_length_spinner.setValue(0)
initial.clicked.connect(setToMin)
end_of_time = QToolButton()
end_of_time.setText("End of time")
addHelpToWidget(end_of_time, "config/init/history_length")
def setToMax():
history_length_spinner.setValue(getHistoryLength())
end_of_time.clicked.connect(setToMax)
row = createRow(QLabel("Timestep:"), history_length_spinner, initial,
end_of_time)
return row, history_length_spinner
def __init__(self, parameter, parent=None):
"""Constructor
.. versionadded:: 2.2
:param parameter: A IntegerParameter object.
:type parameter: IntegerParameter
"""
super(IntegerParameterWidget, self).__init__(parameter, parent)
self._input = QSpinBox()
self._input.setValue(self._parameter.value)
self._input.setMinimum(
self._parameter.minimum_allowed_value)
self._input.setMaximum(
self._parameter.maximum_allowed_value)
tool_tip = 'Choose a number between %d and %d' % (
self._parameter.minimum_allowed_value,
self._parameter.maximum_allowed_value)
self._input.setToolTip(tool_tip)
self._input.setSizePolicy(self._spin_box_size_policy)
self._inner_input_layout.addWidget(self._input)
self._inner_input_layout.addWidget(self._unit_widget)
def __init__(self, parentView, backgroundColor, foregroundColor,
value, height, fontSize):
QHBoxLayout.__init__(self)
self.backgroundColor = backgroundColor
self.foregroundColor = foregroundColor
self.labelLayout = QVBoxLayout()
self.upLabel = LabelButtons('spin-up', parentView,
backgroundColor, foregroundColor,
height/2, height/2)
self.labelLayout.addWidget(self.upLabel)
self.upLabel.clicked.connect(self.on_upLabel)
self.downLabel = LabelButtons('spin-down', parentView,
backgroundColor,
foregroundColor, height/2,
height/2)
self.labelLayout.addWidget(self.downLabel)
self.downLabel.clicked.connect(self.on_downLabel)
self.addLayout(self.labelLayout)
self.spinBox = QSpinBox()
self.spinBox.valueChanged.connect(self.spinBoxValueChanged)
self.addWidget(self.spinBox)
self.spinBox.setToolTip("Spinbox")
self.spinBox.setButtonSymbols(QAbstractSpinBox.NoButtons)
self.spinBox.setAlignment(Qt.AlignRight)
self.spinBox.setMaximum(value)
self.spinBox.setMaximumHeight(height)
self.spinBox.setSuffix("/" + str(value))
font = self.spinBox.font()
font.setPixelSize(fontSize)
self.spinBox.setFont(font)
self.do_draw()
def create_widget(self):
""" Create the underlying QSpinBox widget.
"""
widget = QSpinBox(self.parent_widget())
widget.setKeyboardTracking(False)
self.widget = widget
def __init__(self, *args):
PluginBase.__init__(self, BrickletAnalogInV2, *args)
self.ai = self.device
self.cbe_voltage = CallbackEmulator(self.ai.get_voltage,
self.cb_voltage,
self.increase_error_count)
self.current_voltage = None # float, V
plots = [('Voltage', Qt.red, lambda: self.current_voltage,
format_voltage)]
self.plot_widget = PlotWidget('Voltage [V]', plots)
self.spin_average = QSpinBox()
self.spin_average.setMinimum(1)
self.spin_average.setMaximum(50)
self.spin_average.setSingleStep(1)
self.spin_average.setValue(50)
self.spin_average.editingFinished.connect(self.spin_average_finished)
layout_h1 = QHBoxLayout()
layout_h1.addWidget(QLabel('Moving Average Length:'))
layout_h1.addWidget(self.spin_average)
layout_h1.addStretch()
line = QFrame()
line.setFrameShape(QFrame.HLine)
line.setFrameShadow(QFrame.Sunken)
layout = QVBoxLayout(self)
layout.addWidget(self.plot_widget)
layout.addWidget(line)
layout.addLayout(layout_h1)
def createEditor(self, parent, option, index):
editor = QSpinBox(parent)
editor.setMinimum(0)
editor.setMaximum(100)
return editor
