def __init__(self, line_style_set=STYLESET_DEFAULT): QWidget.__init__(self) self._style = PlotStyle("StyleChooser Internal Style") self._styles = STYLES[ 'default'] if not line_style_set in STYLES else STYLES[ line_style_set] self.setMinimumWidth(140) self.setMaximumHeight(25) layout = QHBoxLayout() layout.setMargin(0) layout.setSpacing(2) self.line_chooser = QComboBox() self.line_chooser.setToolTip("Select line style.") for style in self._styles: self.line_chooser.addItem(*style) self.marker_chooser = QComboBox() self.marker_chooser.setToolTip("Select marker style.") for marker in MARKERS: self.marker_chooser.addItem(*marker) self.thickness_spinner = QDoubleSpinBox() self.thickness_spinner.setToolTip("Line thickness") self.thickness_spinner.setMinimum(0.1) self.thickness_spinner.setDecimals(1) self.thickness_spinner.setSingleStep(0.1) self.size_spinner = QDoubleSpinBox() self.size_spinner.setToolTip("Marker Size") self.size_spinner.setMinimum(0.1) self.size_spinner.setDecimals(1) self.size_spinner.setSingleStep(0.1) # the text content of the spinner varies, but shouldn't push the control out of boundaries self.line_chooser.setMinimumWidth(110) layout.addWidget(self.line_chooser) layout.addWidget(self.thickness_spinner) layout.addWidget(self.marker_chooser) layout.addWidget(self.size_spinner) self.setLayout(layout) self.line_chooser.currentIndexChanged.connect(self._updateStyle) self.marker_chooser.currentIndexChanged.connect(self._updateStyle) self.thickness_spinner.valueChanged.connect(self._updateStyle) self.size_spinner.valueChanged.connect(self._updateStyle) self._updateLineStyleAndMarker(self._style.line_style, self._style.marker, self._style.width, self._style.size) self._layout = layout
def __init__(self, area_supported=False): QWidget.__init__(self) self._style = PlotStyle("StyleChooser Internal Style") self._styles = STYLES if area_supported else STYLES_LINE_ONLY self.setMinimumWidth(140) self.setMaximumHeight(25) layout = QHBoxLayout() layout.setMargin(0) layout.setSpacing(2) self.line_chooser = QComboBox() self.line_chooser.setToolTip("Select line style.") for style in self._styles: self.line_chooser.addItem(*style) self.marker_chooser = QComboBox() self.marker_chooser.setToolTip("Select marker style.") for marker in MARKERS: self.marker_chooser.addItem(*marker) self.thickness_spinner = QDoubleSpinBox() self.thickness_spinner.setToolTip("Line thickness") self.thickness_spinner.setMinimum(0.1) self.thickness_spinner.setDecimals(1) self.thickness_spinner.setSingleStep(0.1) self.size_spinner = QDoubleSpinBox() self.size_spinner.setToolTip("Marker Size") self.size_spinner.setMinimum(0.1) self.size_spinner.setDecimals(1) self.size_spinner.setSingleStep(0.1) layout.addWidget(self.line_chooser) layout.addWidget(self.thickness_spinner) layout.addWidget(self.marker_chooser) layout.addWidget(self.size_spinner) self.setLayout(layout) self.line_chooser.currentIndexChanged.connect(self._updateStyle) self.marker_chooser.currentIndexChanged.connect(self._updateStyle) self.thickness_spinner.valueChanged.connect(self._updateStyle) self.size_spinner.valueChanged.connect(self._updateStyle) self._updateLineStyleAndMarker(self._style.line_style, self._style.marker, self._style.width, self._style.size) self._layout = layout
def __init__(self, parent, slice_view_widget, context): super(PlotExportSettingsWidget, self).__init__(parent) self._slice_view_widget = slice_view_widget self._context = context self._dpi_units = ["in", "cm", "px"] if parent is None: w, h, dpi = 11.7, 8.3, 100 else: fig = self._slice_view_widget.layout_figure() w, h = fig.get_size_inches() dpi = fig.dpi self._label = QLabel() self._label.setDisabled(True) self._set_label_txt(w, h, self._dpi_units[0]) self._fix_size = QCheckBox() self._fix_width = QDoubleSpinBox() self._fix_width.setDisabled(True) self._fix_height = QDoubleSpinBox() self._fix_height.setDisabled(True) self._fix_dpi_units = QComboBox() self._fix_dpi_units.setDisabled(True) self._fix_width.setMinimum(1) self._fix_width.setMaximum(32000) self._fix_width.setValue(w) self._fix_height.setMinimum(1) self._fix_height.setMaximum(32000) self._fix_height.setValue(h) self._fix_width.valueChanged.connect(self._fixed_image) self._fix_height.valueChanged.connect(self._fixed_image) self._fix_dpi_units.addItems(self._dpi_units) self._fix_dpi_units.activated.connect(self._fixed_image) self._fix_size.toggled.connect(self._fixed_image) self._label_widget = self._label self._enable_widget = self._fix_size self._dpi_widget = self._fix_dpi_units self._height_widget = self._fix_height self._width_widget = self._fix_width
def _getSpinbox(self, minvalue, maxvalue, step, nullable=True, value=0): ''' Get a combobox filled with the given values :param values: The values as key = value, value = description or text :type values: Dict :returns: A combobox :rtype: QWidget ''' widget = QWidget() spinbox = QDoubleSpinBox() spinbox.setMinimum(minvalue) spinbox.setMaximum(maxvalue) spinbox.setSingleStep(step) spinbox.setDecimals( len(str(step).split('.')[1]) if len(str(step).split('.')) == 2 else 0) if nullable: spinbox.setMinimum(minvalue - step) spinbox.setValue(spinbox.minimum()) spinbox.setSpecialValueText( str(QSettings().value('qgis/nullValue', 'NULL'))) if value is not None: spinbox.setValue(value) layout = QHBoxLayout(widget) layout.addWidget(spinbox, 1) layout.setAlignment(Qt.AlignCenter) layout.setContentsMargins(5, 0, 5, 0) widget.setLayout(layout) return 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, page): super(LogTool, self).__init__(page) layout = QVBoxLayout() self.setLayout(layout) self.fontLabel = QLabel() self.fontChooser = QFontComboBox(currentFontChanged=self.changed) self.fontSize = QDoubleSpinBox(valueChanged=self.changed) self.fontSize.setRange(6.0, 32.0) self.fontSize.setSingleStep(0.5) self.fontSize.setDecimals(1) box = QHBoxLayout() box.addWidget(self.fontLabel) box.addWidget(self.fontChooser, 1) box.addWidget(self.fontSize) layout.addLayout(box) self.showlog = QCheckBox(toggled=self.changed) layout.addWidget(self.showlog) self.rawview = QCheckBox(toggled=self.changed) layout.addWidget(self.rawview) self.hideauto = QCheckBox(toggled=self.changed) layout.addWidget(self.hideauto) app.translateUI(self)
def _create(self, base_frame): self.sliders = [] self.spinboxes = [] for i in range(len(self.dim_labels)): self.sliders.append(QSlider(QtCore.Qt.Horizontal)) self.sliders[i].setRange(0, self.n_slider_steps[i]) self.sliders[i].valueChanged.connect( partial(self._on_slide, i)) spinbox = QDoubleSpinBox() spinbox.setRange(*self.limits[i]) spinbox.setDecimals(3) spinbox.setSingleStep(0.001) self.spinboxes.append(spinbox) self.spinboxes[i].valueChanged.connect( partial(self._on_pos_edited, i)) slider_group = QGridLayout() slider_group.addWidget(QLabel("Position"), 0, 0, 1, 3, QtCore.Qt.AlignCenter) slider_group.addWidget(QLabel("Orientation (Euler angles)"), 0, 3, 1, 3, QtCore.Qt.AlignCenter) for i, slider in enumerate(self.sliders): slider_group.addWidget(QLabel(self.dim_labels[i]), 1, i) slider_group.addWidget(slider, 2, i) slider_group.addWidget(self.spinboxes[i], 3, i) slider_groupbox = QGroupBox("Transformation in frame '%s'" % base_frame) slider_groupbox.setLayout(slider_group) layout = QHBoxLayout() layout.addWidget(slider_groupbox) layout.addStretch(1) return layout
def createEditor(self, parent, option, index): """ Creates the combobox inside a parent. :param parent: The container of the combobox :type parent: QWidget :param option: QStyleOptionViewItem class is used to describe the parameters used to draw an item in a view widget. :type option: Object :param index: The index where the combobox will be added. :type index: QModelIndex :return: The combobox :rtype: QComboBox """ if index.column() == 0: str_combo = QComboBox(parent) str_combo.insertItem(0, " ") for id, type in self.str_type_set_data().iteritems(): str_combo.addItem(type, id) if self.str_type_id is not None: str_combo.setCurrentIndex(self.str_type_id) return str_combo elif index.column() == 1: spinbox = QDoubleSpinBox(parent) spinbox.setObjectName(unicode(index.row())) spinbox.setMinimum(0.00) spinbox.setSuffix('%') spinbox.setMaximum(100.00) return spinbox
def __init__(self, parameter, parent=None): """Constructor .. versionadded:: 2.2 :param parameter: A FloatParameter object. :type parameter: FloatParameter """ super(FloatParameterWidget, self).__init__(parameter, parent) self._input = QDoubleSpinBox() self._input.setDecimals(self._parameter.precision) self._input.setValue(self._parameter.value) self._input.setMinimum(self._parameter.minimum_allowed_value) self._input.setMaximum(self._parameter.maximum_allowed_value) self._input.setSingleStep(10**-self._parameter.precision) # is it possible to use dynamic precision ? string_min_value = '%.*f' % (self._parameter.precision, self._parameter.minimum_allowed_value) string_max_value = '%.*f' % (self._parameter.precision, self._parameter.maximum_allowed_value) tool_tip = 'Choose a number between %s and %s' % (string_min_value, string_max_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 __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 __init__(self, showSampleRateSb=False, settings=None, parent=None): super(AnalogConfigLayout, self).__init__(parent) self.deviceCombo = QComboBox() self.deviceCombo.setObjectName('deviceCombo') self.addRow('&Device', self.deviceCombo) self.channelCombo = QComboBox() self.channelCombo.setObjectName('channelCombo') self.addRow('&Channel', self.channelCombo) self.rangeCombo = QComboBox() self.rangeCombo.setObjectName('rangeCombo') self.addRow('&Range', self.rangeCombo) if showSampleRateSb: self.sampleRateSb = QDoubleSpinBox() self.sampleRateSb.setSuffix(' kHz') self.sampleRateSb.setMinimum(0.001) self.sampleRateSb.setDecimals(3) self.sampleRateSb.setValue(1) self.sampleRateSb.setObjectName('sampleRateSb') self.addRow('&Sample rate', self.sampleRateSb) else: self.sampleRateSb = None self._ranges = [] self.deviceCombo.currentIndexChanged.connect(self.deviceChanged) self.populateDevices() self.rangeCombo.currentIndexChanged.connect(self.rangeChanged) self.deviceCombo.setContextMenuPolicy(Qt.CustomContextMenu) self.deviceCombo.customContextMenuRequested.connect(self.contextMenu)
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 __init__(self, previous_value=DEFAULT_CONF_LEVEL, parent=None): super(ChangeConfLevelDlg, self).__init__(parent) cl_label = QLabel("Global Confidence Level:") self.conf_level_spinbox = QDoubleSpinBox() self.conf_level_spinbox.setRange(50, 99.999) self.conf_level_spinbox.setSingleStep(0.1) self.conf_level_spinbox.setSuffix(QString("%")) self.conf_level_spinbox.setValue(previous_value) self.conf_level_spinbox.setDecimals(1) buttonBox = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel) hlayout = QHBoxLayout() hlayout.addWidget(cl_label) hlayout.addWidget(self.conf_level_spinbox) vlayout = QVBoxLayout() vlayout.addLayout(hlayout) vlayout.addWidget(buttonBox) self.setLayout(vlayout) self.connect(buttonBox, SIGNAL("accepted()"), self, SLOT("accept()")) self.connect(buttonBox, SIGNAL("rejected()"), self, SLOT("reject()")) self.setWindowTitle("Change Confidence Level")
def __init__(self, session, parent, creator): GenericTreeWidget.__init__(self, session, parent) self.creator = creator self.setTitle('Tuotteet') self.setButtons([ButtonType.add, ButtonType.open, ButtonType.remove]) self.setHeader(headertexts=['id', 'Nimi', 'Tyyppi', 'Hinta', 'Määrä'], hidecolumns=[0]) from mainwindowtabs.itemcreatordialog import ItemCreatorDialog self.setInputMethod(tabcreator=ItemCreatorDialog, autoAdd=True, function=SqlHandler.searchItem) self.countSpinBox = QDoubleSpinBox(parent=self) self.countSpinBox.setRange(0.01, 99999999) self.countSpinBox.setValue(1) if self.ui.topLayout.count() > 0 or self.ui.bottomLayout.count() == 0: self.ui.topLayout.insertWidget(self.ui.topLayout.count(), self.countSpinBox) else: self.ui.bottomLayout.incertWidget(self.ui.bottomLayout.count(), self.countSpinBox) self.setUpTreewidget() self.countSpinBox.valueChanged['double'].connect(self.updateItemCount) self.ui.treeWidget.currentItemChanged.connect(self.handleChange)
def create_widgets(self): # Min self.color = QLabel("Color:") self.color_edit = QPushButton() #self.color_edit.setFlat(True) qcolor = QtGui.QColor() qcolor.setRgb(*self.int_color) palette = QtGui.QPalette(self.color_edit.palette()) palette.setColor(QtGui.QPalette.Background, QtGui.QColor('blue')) self.color_edit.setPalette(palette) self.color_edit.setStyleSheet("QPushButton {" "background-color: rgb(%s, %s, %s);" % tuple(self.int_color) + #"border:1px solid rgb(255, 170, 255); " "}") # Size self.size = QLabel("Size:") self.size_edit = QDoubleSpinBox(self) self.size_edit.setRange(0.0, self.dim_max) log_dim = log10(self.dim_max) decimals = int(ceil(abs(log_dim))) decimals = max(6, decimals) self.size_edit.setDecimals(decimals) #self.size_edit.setSingleStep(self.dim_max / 100.) self.size_edit.setSingleStep(self.dim_max / 1000.) self.size_edit.setValue(self._size) # closing #self.apply_button = QPushButton("Apply") #self.ok_button = QPushButton("OK") self.cancel_button = QPushButton("Close")
def _refresh_widgets_from_axistags(self): axiskeys = [tag.key for tag in self.axistags] row_widgets = collections.OrderedDict() for key in axiskeys: tag_info = self.axistags[key] resolution_box = QDoubleSpinBox(parent=self) resolution_box.setRange(0.0, numpy.finfo(numpy.float32).max) resolution_box.setValue(tag_info.resolution) resolution_box.valueChanged.connect( self._update_axistags_from_widgets) resolution_box.installEventFilter(self) description_edit = QLineEdit(tag_info.description, parent=self) description_edit.textChanged.connect( self._update_axistags_from_widgets) description_edit.installEventFilter(self) row_widgets[key] = RowWidgets(resolution_box, description_edit) # Clean up old widgets (if any) for row in range(self.rowCount()): for col in range(self.columnCount()): w = self.cellWidget(row, col) if w: w.removeEventFilter(self) # Fill table with widgets self.setRowCount(len(row_widgets)) self.setVerticalHeaderLabels(row_widgets.keys()) for row, widgets in enumerate(row_widgets.values()): self.setCellWidget(row, 0, widgets.resolution_box) self.setCellWidget(row, 1, widgets.description_edit)
def createEditor(self, type, parent): if type != QVariant.Double: raise ValueError("This factory only creates editor for doubles") w = QDoubleSpinBox(parent) w.setDecimals(5) w.setMinimum(0.0001) w.setMaximum(10000) return w
def addTableRow(self, row=None, enabled=True, f=10, A=0.1, phase=0.0, bw=5, order=8): table = self.table if row == None: row = table.rowCount() if row < 1: row = 0 table.insertRow(row) cb = QCheckBox() cb.setChecked(enabled) self.setTableCellWidget(row, 'active', cb) frequencySb = QDoubleSpinBox() frequencySb.setMinimum(1.0) frequencySb.setMaximum(self.fMax) frequencySb.setSingleStep(0.01) frequencySb.setDecimals(2) frequencySb.setValue(f) self.setTableCellWidget(row, 'f', frequencySb) amplitudeSb = AmplitudeSpinBox() amplitudeSb.setValue(A) amplitudeSb.valueChanged.connect(lambda v: self.amplitudeChanged(row, v)) self.setTableCellWidget(row, 'A', amplitudeSb) phaseSb = PhaseSpinBox() phaseSb.setValue(phase) self.setTableCellWidget(row, 'phase', phaseSb) bwSb = QDoubleSpinBox() bwSb.setMinimum(0.1) bwSb.setMaximum(1000) bwSb.setValue(bw) bwSb.setSuffix(' Hz') self.setTableCellWidget(row, 'bw', bwSb) orderSb = QSpinBox() orderSb.setMinimum(1) orderSb.setMaximum(10) orderSb.setValue(order) self.setTableCellWidget(row, 'order', orderSb) self.setTableCellWidget(row, 'X', QFloatDisplay()) self.setTableCellWidget(row, 'Y', QFloatDisplay()) self.setTableCellWidget(row, 'R', QFloatDisplay()) self.setTableCellWidget(row, 'Theta', QFloatDisplay())
def _create_widget(cls, c, parent): dsb = QDoubleSpinBox(parent) dsb.setObjectName(u'{0}_{1}'.format(cls._TYPE_PREFIX, c.name)) #Set ranges dsb.setMinimum(float(c.minimum)) dsb.setMaximum(float(c.maximum)) return dsb
def createDoubleSpinBox(self, variable_name, variable_value, variable_type, analysis_module_variables_model): spinner = QDoubleSpinBox() spinner.setMinimumWidth(75) spinner.setMaximum(analysis_module_variables_model.getVariableMaximumValue(variable_name)) spinner.setMinimum(analysis_module_variables_model.getVariableMinimumValue(variable_name)) spinner.setSingleStep(analysis_module_variables_model.getVariableStepValue(variable_name)) spinner.setValue(variable_value) spinner.valueChanged.connect(partial(self.valueChanged, variable_name, variable_type, spinner)) return spinner;
def __init__(self, parent=None): super().__init__(parent) latitudeLabel = QLabel(self.tr("Latitude:")) self.latitudeSpinBox = QDoubleSpinBox() self.latitudeSpinBox.setRange(-90.0, 90.0) self.latitudeSpinBox.setDecimals(5) self.latitudeSpinBox.setSuffix(" degrees") self.latitudeSpinBox.setToolTip( "How far north or sourth you are from the equator. Must be between -90 and 90." ) longitudeLabel = QLabel(self.tr("Longitude:")) self.longitudeSpinBox = QDoubleSpinBox() self.longitudeSpinBox.setRange(-180.0, 180.0) self.longitudeSpinBox.setDecimals(5) self.longitudeSpinBox.setSuffix(" degrees") self.longitudeSpinBox.setToolTip( "How far west or east you are from the meridian. Must be between -180 and 180." ) elevationLabel = QLabel(self.tr("Elevation")) self.elevationSpinBox = QDoubleSpinBox() self.elevationSpinBox.setRange(-418.0, 8850.0) self.elevationSpinBox.setDecimals(5) self.elevationSpinBox.setSuffix(" m") self.elevationSpinBox.setToolTip( "The distance from sea level in meters. Must be between -418 and 8850." ) self.connect(self.latitudeSpinBox, SIGNAL("valueChanged(double)"), self, SIGNAL("latitudeChanged(double)")) self.connect(self.longitudeSpinBox, SIGNAL("valueChanged(double)"), self, SIGNAL("longitudeChanged(double)")) self.connect(self.elevationSpinBox, SIGNAL("valueChanged(double)"), self, SIGNAL("elevationChanged(double)")) layout = QGridLayout(self) layout.addWidget(latitudeLabel, 0, 0) layout.addWidget(self.latitudeSpinBox, 1, 0) layout.addWidget(longitudeLabel, 0, 1) layout.addWidget(self.longitudeSpinBox, 1, 1) layout.addWidget(elevationLabel, 0, 2) layout.addWidget(self.elevationSpinBox, 1, 2)
def createEditor(self, parent, option, index): col = index.column() if col == 1: editor = QDoubleSpinBox(parent) editor.setSuffix('%') else: editor = QSpinBox(parent) editor.setMaximum(100000000) return editor
def __init__(self, parent=None): super(Form, self).__init__(parent) self.label_amount = QLabel('Amount') self.spin_amount = QDoubleSpinBox() self.spin_amount.setRange(0, 10000000000) self.spin_amount.setPrefix('Rp. ') self.spin_amount.setSingleStep(100000) self.label_rate = QLabel('Rate') self.spin_rate = QDoubleSpinBox() self.spin_rate.setSuffix(' %') self.spin_rate.setSingleStep(0.1) self.spin_rate.setRange(0, 100) self.label_year = QLabel('Years') self.spin_year = QSpinBox() self.spin_year.setSuffix(' year') self.spin_year.setSingleStep(1) self.spin_year.setRange(0, 1000) self.spin_year.setValue(1) self.label_total_ = QLabel('Total') self.label_total = QLabel('Rp. 0.00') grid = QGridLayout() grid.addWidget(self.label_amount, 0, 0) grid.addWidget(self.spin_amount, 0, 1) grid.addWidget(self.label_rate, 1, 0) grid.addWidget(self.spin_rate, 1, 1) grid.addWidget(self.label_year, 2, 0) grid.addWidget(self.spin_year, 2, 1) grid.addWidget(self.label_total_, 3, 0) grid.addWidget(self.label_total, 3, 1) self.setLayout(grid) self.connect(self.spin_amount, SIGNAL('valueChanged(double)'), self.update_ui) self.connect(self.spin_rate, SIGNAL('valueChanged(double)'), self.update_ui) self.connect(self.spin_year, SIGNAL('valueChanged(int)'), self.update_ui) self.setWindowTitle('Interest')
def __init__(self, mapPoint): """ Constructor :param mapPoint: map point intersection """ QDialog.__init__(self) self.__mapPoint = mapPoint self.setWindowTitle( QCoreApplication.translate("VDLTools", "Choose diameter")) self.resize(275, 177) self.__gridLayout = QGridLayout() self.__label = QLabel( QCoreApplication.translate("VDLTools", "Diameter")) self.__gridLayout.addWidget(self.__label, 2, 1, 1, 1) self.__observation = QDoubleSpinBox() self.__observation.setDecimals(4) self.__observation.setMaximum(999999.99) self.__observation.setSingleStep(1.0) self.__gridLayout.addWidget(self.__observation, 2, 2, 1, 1) self.__label_3 = QLabel("m") self.__gridLayout.addWidget(self.__label_3, 2, 3, 1, 1) self.__okButton = QPushButton( QCoreApplication.translate("VDLTools", "OK")) self.__okButton.setMinimumHeight(20) self.__okButton.setMinimumWidth(100) self.__cancelButton = QPushButton( QCoreApplication.translate("VDLTools", "Cancel")) self.__cancelButton.setMinimumHeight(20) self.__cancelButton.setMinimumWidth(100) self.__gridLayout.addWidget(self.__okButton, 5, 1) self.__gridLayout.addWidget(self.__cancelButton, 5, 2) self.__label_5 = QLabel("y") self.__gridLayout.addWidget(self.__label_5, 1, 1, 1, 1) self.__label_6 = QLabel("x") self.__gridLayout.addWidget(self.__label_6, 0, 1, 1, 1) self.__x = QLineEdit("x") self.__x.setText(str(self.__mapPoint.x())) self.__x.setEnabled(False) self.__gridLayout.addWidget(self.__x, 0, 2, 1, 2) self.__y = QLineEdit("y") self.__y.setText(str(self.__mapPoint.y())) self.__y.setEnabled(False) self.__gridLayout.addWidget(self.__y, 1, 2, 1, 2) self.setLayout(self.__gridLayout)
def __init__(self, tool): super(Widget, self).__init__(tool) self.mainwindow = tool.mainwindow() self.define = None import panelmanager self.svgview = panelmanager.manager( tool.mainwindow()).svgview.widget().view layout = QVBoxLayout(spacing=1) self.setLayout(layout) self.elemLabel = QLabel() self.XOffsetBox = QDoubleSpinBox() self.XOffsetBox.setRange(-99, 99) self.XOffsetBox.setSingleStep(0.1) self.XOffsetLabel = l = QLabel() l.setBuddy(self.XOffsetBox) self.YOffsetBox = QDoubleSpinBox() self.YOffsetBox.setRange(-99, 99) self.YOffsetBox.setSingleStep(0.1) self.YOffsetLabel = l = QLabel() l.setBuddy(self.YOffsetBox) self.insertButton = QPushButton("insert offset in source", self) self.insertButton.clicked.connect(self.callInsert) layout.addWidget(self.elemLabel) layout.addWidget(self.XOffsetLabel) layout.addWidget(self.XOffsetBox) layout.addWidget(self.YOffsetLabel) layout.addWidget(self.YOffsetBox) layout.addWidget(self.insertButton) layout.addStretch(1) app.translateUI(self) self.loadSettings() self.connectSlots()
def _set_up_opt_spin_box(self): check_box = QCheckBox() spin_box = QDoubleSpinBox() spin_box.setDecimals(5) spin_box.setSingleStep(0.01) spin_box.setMinimum(-sys.float_info.max) spin_box.setMaximum(sys.float_info.max) spin_box.setDisabled(True) check_box.toggled.connect(spin_box.setEnabled) return check_box, spin_box
def __init__(self, parent, item): AddNewDialog.__init__(self, parent) self.setText('Lisää uusi punnitus', 'Uusi punnitus') self.ui.lineEdit.hide() self.item = item self.priceSelector = QDoubleSpinBox(parent=self) self.priceSelector.setMaximum(999999) self.priceSelector.setSizePolicy( QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)) self.ui.horizontalLayout.addWidget(self.priceSelector) self.hideComboBox()
def __init__(self, parent=None): super(Form, self).__init__(parent) principalLabel = QLabel("Principal:") self.principalSpinBox = QDoubleSpinBox() self.principalSpinBox.setRange(1, 1000000000) self.principalSpinBox.setValue(1000) self.principalSpinBox.setPrefix("$ ") rateLabel = QLabel("Rate:") self.rateSpinBox = QDoubleSpinBox() self.rateSpinBox.setRange(1, 100) self.rateSpinBox.setValue(5) self.rateSpinBox.setSuffix(" %") yearsLabel = QLabel("Years:") self.yearsComboBox = QComboBox() self.yearsComboBox.addItem("1 year") self.yearsComboBox.addItems( ["{0} years".format(x) for x in range(2, 26)]) amountLabel = QLabel("Amount") self.amountLabel = QLabel() grid = QGridLayout() grid.addWidget(principalLabel, 0, 0) grid.addWidget(self.principalSpinBox, 0, 1) grid.addWidget(rateLabel, 1, 0) grid.addWidget(self.rateSpinBox, 1, 1) grid.addWidget(yearsLabel, 2, 0) grid.addWidget(self.yearsComboBox, 2, 1) grid.addWidget(amountLabel, 3, 0) grid.addWidget(self.amountLabel, 3, 1) self.setLayout(grid) self.connect(self.principalSpinBox, SIGNAL("valueChanged(double)"), self.updateUi) self.connect(self.rateSpinBox, SIGNAL("valueChanged(double)"), self.updateUi) self.connect(self.yearsComboBox, SIGNAL("currentIndexChanged(int)"), self.updateUi) self.setWindowTitle("Interest") self.updateUi()
def createDoubleSpinner(self, minimum, maximum): spinner = QDoubleSpinBox() spinner.setSizePolicy(QSizePolicy.Ignored, QSizePolicy.Ignored) spinner.setMinimumWidth(105) spinner.setRange(minimum, maximum) spinner.setKeyboardTracking(False) spinner.setDecimals(8) spinner.editingFinished.connect(self.plotScaleChanged) spinner.valueChanged.connect(self.plotScaleChanged) return spinner
def _create_widget(cls, c, parent, host=None): dsb = QDoubleSpinBox(parent) dsb.setObjectName(u'{0}_{1}'.format(cls._TYPE_PREFIX, c.name)) # Set decimal places dsb.setDecimals(c.scale) # Set ranges dsb.setMinimum(float(c.minimum)) dsb.setMaximum(float(c.maximum)) return dsb