class SpinBoxImageView(QHBoxLayout): valueChanged = pyqtSignal(int) 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 do_draw(self): r, g, b, a = self.foregroundColor.getRgb() rgb = "rgb({0},{1},{2})".format(r, g, b) sheet = TEMPLATE.format(rgb, self.backgroundColor.name()) self.spinBox.setStyleSheet(sheet) def spinBoxValueChanged(self, value): self.valueChanged.emit(value) def setValue(self, value): self.spinBox.setValue(value) def setNewValue(self, value): self.spinBox.setMaximum(value) self.spinBox.setSuffix("/" + str(value)) def on_upLabel(self): self.spinBox.setValue(self.spinBox.value() + 1) def on_downLabel(self): self.spinBox.setValue(self.spinBox.value() - 1)
class ResizeDlg(QDialog): def __init__(self, width, height, parent=None): super(ResizeDlg, self).__init__(parent) widthLabel = QLabel(self.tr("&Width:")) self.widthSpinBox = QSpinBox() widthLabel.setBuddy(self.widthSpinBox) self.widthSpinBox.setAlignment(Qt.AlignRight | Qt.AlignVCenter) self.widthSpinBox.setRange(4, width * 4) self.widthSpinBox.setValue(width) heightLabel = QLabel(self.tr("&Height:")) self.heightSpinBox = QSpinBox() heightLabel.setBuddy(self.heightSpinBox) self.heightSpinBox.setAlignment(Qt.AlignRight | Qt.AlignVCenter) self.heightSpinBox.setRange(4, height * 4) self.heightSpinBox.setValue(height) buttonBox = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel) layout = QGridLayout() layout.addWidget(widthLabel, 0, 0) layout.addWidget(self.widthSpinBox, 0, 1) layout.addWidget(heightLabel, 1, 0) layout.addWidget(self.heightSpinBox, 1, 1) layout.addWidget(buttonBox, 2, 0, 1, 2) self.setLayout(layout) self.connect(buttonBox, SIGNAL("accepted()"), self.accept) self.connect(buttonBox, SIGNAL("rejected()"), self.reject) self.setWindowTitle(self.tr("Image Changer - Resize")) def result(self): return self.widthSpinBox.value(), self.heightSpinBox.value()
class Organ(KeyboardPart): @staticmethod def title(_=_base.translate): return _("Organ") @staticmethod def short(_=_base.translate): return _("abbreviation for Organ", "Org.") midiInstrument = 'church organ' def createWidgets(self, layout): super(Organ, self).createWidgets(layout) grid = layout.itemAt(layout.count() - 1).layout() self.pedalVoices = QSpinBox(minimum=0, maximum=4, value=1) self.pedalVoicesLabel = QLabel() self.pedalVoicesLabel.setBuddy(self.pedalVoices) grid.addWidget(self.pedalVoicesLabel, 2, 0) grid.addWidget(self.pedalVoices) def translateWidgets(self): super(Organ, self).translateWidgets() self.pedalVoicesLabel.setText(_("Pedal:")) self.pedalVoices.setToolTip(_( "Set to 0 to disable the pedal altogether.")) def build(self, data, builder): super(Organ, self).build(data, builder) if self.pedalVoices.value(): data.nodes.append(self.buildStaff(data, builder, 'pedal', -1, self.pedalVoices.value(), clef="bass"))
class Organ(KeyboardPart): @staticmethod def title(_=__builtin__._): return _("Organ") @staticmethod def short(_=__builtin__._): return _("abbreviation for Organ", "Org.") midiInstrument = 'church organ' def createWidgets(self, layout): super(Organ, self).createWidgets(layout) grid = layout.itemAt(layout.count() - 1).layout() self.pedalVoices = QSpinBox(minimum=0, maximum=4, value=1) self.pedalVoicesLabel = QLabel() self.pedalVoicesLabel.setBuddy(self.pedalVoices) grid.addWidget(self.pedalVoicesLabel, 2, 0) grid.addWidget(self.pedalVoices) def translateWidgets(self): super(Organ, self).translateWidgets() self.pedalVoicesLabel.setText(_("Pedal:")) self.pedalVoices.setToolTip(_( "Set to 0 to disable the pedal altogether.")) def build(self, data, builder): super(Organ, self).build(data, builder) if self.pedalVoices.value(): data.nodes.append(self.buildStaff(data, builder, 'pedal', -1, self.pedalVoices.value(), clef="bass"))
def changeTileWidth(): '''Change tile width (tile block size) and reset image-scene''' dlg = QDialog(self) dlg.setWindowTitle("Viewer Tile Width") dlg.setModal(True) spinBox = QSpinBox( parent=dlg ) spinBox.setRange( 128, 10*1024 ) spinBox.setValue( self.editor.imageScenes[0].tileWidth() ) ctrl_layout = QHBoxLayout() ctrl_layout.addSpacerItem(QSpacerItem(10, 0, QSizePolicy.Expanding)) ctrl_layout.addWidget( QLabel("Tile Width:") ) ctrl_layout.addWidget( spinBox ) button_box = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel, parent=dlg) button_box.accepted.connect( dlg.accept ) button_box.rejected.connect( dlg.reject ) dlg_layout = QVBoxLayout() dlg_layout.addLayout( ctrl_layout ) dlg_layout.addWidget( QLabel("Setting will apply current view immediately,\n" "and all other views upon restart.") ) dlg_layout.addWidget( button_box ) dlg.setLayout( dlg_layout ) if dlg.exec_() == QDialog.Accepted: for s in self.editor.imageScenes: if s.tileWidth != spinBox.value(): s.setTileWidth( spinBox.value() ) s.reset()
class SpinBoxImageView(QHBoxLayout): valueChanged = pyqtSignal(int) def __init__(self, backgroundColor, foregroundColor, value, height, fontSize): QHBoxLayout.__init__(self) self.backgroundColor = backgroundColor self.foregroundColor = foregroundColor self.labelLayout = QVBoxLayout() self.upLabel = LabelButtons(backgroundColor, foregroundColor, height/2, height/2) self.labelLayout.addWidget(self.upLabel) self.upLabel.setSpinBoxUpIcon() self.upLabel.clicked.connect(self.on_upLabel) self.downLabel = LabelButtons(backgroundColor, foregroundColor, height/2, height/2) self.labelLayout.addWidget(self.downLabel) self.downLabel.setSpinBoxDownIcon() 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) rgb = foregroundColor.getRgb() rgba_string = "rgba("+str(rgb[0])+","+str(rgb[1])+","+str(rgb[2])+","+str(0.6*100)+"%)" self.spinBox.setStyleSheet("QSpinBox { color: " + rgba_string + "; font: bold; background-color: " + str(backgroundColor.name()) + "; border:0;}") def changeOpacity(self, opacity): rgb = self.foregroundColor.getRgb() rgba_string = "rgba("+str(rgb[0])+","+str(rgb[1])+","+str(rgb[2])+","+str(opacity*100)+"%)" self.spinBox.setStyleSheet("QSpinBox { color: " + rgba_string + "; font: bold; background-color: " + str(self.backgroundColor.name()) + "; border:0;}") self.upLabel.changeOpacity(opacity) self.downLabel.changeOpacity(opacity) def spinBoxValueChanged(self, value): self.valueChanged.emit(value) def setValue(self, value): self.spinBox.setValue(value) def setNewValue(self, value): self.spinBox.setMaximum(value) self.spinBox.setSuffix("/" + str(value)) def on_upLabel(self): self.spinBox.setValue(self.spinBox.value() + 1) def on_downLabel(self): self.spinBox.setValue(self.spinBox.value() - 1)
class FloatColumnConfigurationWidget(QWidget, columnproviders.AbstractColumnConfigurationWidget): def __init__(self, parent, hex_widget, column): QWidget.__init__(self, parent) columnproviders.AbstractColumnConfigurationWidget.__init__(self) self.hexWidget = hex_widget self.column = column self.cmbBinaryFormat = QComboBox(self) self.cmbBinaryFormat.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Preferred) for fmt in (valuecodecs.FloatCodec.FormatFloat, valuecodecs.FloatCodec.FormatDouble): self.cmbBinaryFormat.addItem(valuecodecs.FloatCodec.formatName(fmt), fmt) if column is not None and column.valuecodec.binaryFormat == fmt: self.cmbBinaryFormat.setCurrentIndex(self.cmbBinaryFormat.count() - 1) self.spnPrecision = QSpinBox(self) self.spnPrecision.setMinimum(0) self.spnPrecision.setMaximum(12) if column is not None: self.spnPrecision.setValue(column.formatter.precision) else: self.spnPrecision.setValue(6) self.spnColumnsOnRow = QSpinBox(self) self.spnColumnsOnRow.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Preferred) self.spnColumnsOnRow.setMinimum(1) self.spnColumnsOnRow.setMaximum(32) if column is not None: self.spnColumnsOnRow.setValue(column.columnsOnRow) else: self.spnColumnsOnRow.setValue(4) self.setLayout(QFormLayout()) self.layout().setContentsMargins(0, 0, 0, 0) self.layout().addRow(utils.tr('Binary format:'), self.cmbBinaryFormat) self.layout().addRow(utils.tr('Digits after point:'), self.spnPrecision) self.layout().addRow(utils.tr('Columns on row:'), self.spnColumnsOnRow) @property def _valueCodec(self): c = valuecodecs.FloatCodec() c.binaryFormat = self.cmbBinaryFormat.itemData(self.cmbBinaryFormat.currentIndex()) return c @property def _formatter(self): f = formatters.FloatFormatter() f.precision = self.spnPrecision.value() return f def createColumnModel(self, hex_widget): return FloatColumnModel(hex_widget.document, self._valueCodec, self._formatter, self.spnColumnsOnRow.value()) def saveToColumn(self, column): column.valuecodec = self._valueCodec column.formatter = self._formatter column.columnsOnRow = self.spnColumnsOnRow.value() column.reset()
class PianoStaffPart(Part): """Base class for parts creating a piano staff.""" def createWidgets(self, layout): self.label = QLabel(wordWrap=True) self.upperVoicesLabel = QLabel() self.lowerVoicesLabel = QLabel() self.upperVoices = QSpinBox(minimum=1, maximum=4, value=1) self.lowerVoices = QSpinBox(minimum=1, maximum=4, value=1) self.upperVoicesLabel.setBuddy(self.upperVoices) self.lowerVoicesLabel.setBuddy(self.lowerVoices) layout.addWidget(self.label) grid = QGridLayout() grid.addWidget(self.upperVoicesLabel, 0, 0) grid.addWidget(self.upperVoices, 0, 1) grid.addWidget(self.lowerVoicesLabel, 1, 0) grid.addWidget(self.lowerVoices, 1, 1) layout.addLayout(grid) def translateWidgets(self): self.label.setText('{0} <i>({1})</i>'.format( _("Adjust how many separate voices you want on each staff."), _("This is primarily useful when you write polyphonic music " "like a fuge."))) self.upperVoicesLabel.setText(_("Right hand:")) self.lowerVoicesLabel.setText(_("Left hand:")) def buildStaff(self, data, builder, name, octave, numVoices=1, node=None, clef=None): """Build a staff with the given number of voices and name.""" staff = ly.dom.Staff(name, parent=node) builder.setMidiInstrument(staff, self.midiInstrument) c = ly.dom.Seqr(staff) if clef: ly.dom.Clef(clef, c) if numVoices == 1: a = data.assignMusic(name, octave) ly.dom.Identifier(a.name, c) else: c = ly.dom.Sim(c) for i in range(1, numVoices): a = data.assignMusic(name + ly.util.int2text(i), octave) ly.dom.Identifier(a.name, c) ly.dom.VoiceSeparator(c) a = data.assignMusic(name + ly.util.int2text(numVoices), octave) ly.dom.Identifier(a.name, c) return staff def build(self, data, builder): """ Setup structure for a 2-staff PianoStaff. """ p = ly.dom.PianoStaff() builder.setInstrumentNamesFromPart(p, self, data) s = ly.dom.Sim(p) # add two staves, with a respective number of voices. self.buildStaff(data, builder, 'right', 1, self.upperVoices.value(), s) self.buildStaff(data, builder, 'left', 0, self.lowerVoices.value(), s, "bass") data.nodes.append(p)
class AutoNumbering(QWidget): def __init__(self, parent=None): QWidget.__init__(self, parent) def hbox(*widgets): box = QHBoxLayout() [box.addWidget(z) for z in widgets] box.addStretch() return box vbox = QVBoxLayout() startlabel = QLabel(translate('Autonumbering Wizard', "&Start: ")) self._start = QSpinBox() startlabel.setBuddy(self._start) self._start.setValue(1) self._start.setMaximum(65536) vbox.addLayout(hbox(startlabel, self._start)) label = QLabel( translate('Autonumbering Wizard', 'Max length after padding with zeroes: ')) self._padlength = QSpinBox() label.setBuddy(self._padlength) self._padlength.setValue(1) self._padlength.setMaximum(65535) self._padlength.setMinimum(1) vbox.addLayout(hbox(label, self._padlength)) self._restart_numbering = QCheckBox( translate('Autonumbering Wizard', "&Restart numbering at each directory.")) vbox.addWidget(self._restart_numbering) vbox.addStretch() self.setLayout(vbox) def setArguments(self, *args): minimum = sanitize(int, args[0], 0) restart = sanitize(bool, args[1], True) padding = sanitize(int, args[2], 1) self._start.setValue(minimum) self._restart_numbering.setChecked(restart) self._padlength.setValue(padding) def arguments(self): x = [ self._start.value(), self._restart_numbering.isChecked(), self._padlength.value() ] return x
class AutoNumbering(QWidget): def __init__(self, parent = None): QWidget.__init__(self, parent) def hbox(*widgets): box = QHBoxLayout() [box.addWidget(z) for z in widgets] box.addStretch() return box vbox = QVBoxLayout() startlabel = QLabel(translate('Autonumbering Wizard', "&Start: ")) self._start = QSpinBox() startlabel.setBuddy(self._start) self._start.setValue(1) self._start.setMaximum(65536) vbox.addLayout(hbox(startlabel, self._start)) label = QLabel(translate('Autonumbering Wizard', 'Max length after padding with zeroes: ')) self._padlength = QSpinBox() label.setBuddy(self._padlength) self._padlength.setValue(1) self._padlength.setMaximum(65535) self._padlength.setMinimum(1) vbox.addLayout(hbox(label, self._padlength)) self._restart_numbering = QCheckBox(translate('Autonumbering Wizard', "&Restart numbering at each directory.")) vbox.addWidget(self._restart_numbering) vbox.addStretch() self.setLayout(vbox) def setArguments(self, *args): minimum = sanitize(int, args[0], 0) restart = sanitize(bool, args[1], True) padding = sanitize(int, args[2], 1) self._start.setValue(minimum) self._restart_numbering.setChecked(restart) self._padlength.setValue(padding) def arguments(self): x = [ self._start.value(), self._restart_numbering.isChecked(), self._padlength.value()] return x
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()
class Prefs(preferences.Group): def __init__(self, page): super(Prefs, self).__init__(page) self._closeOutputs = QCheckBox(clicked=self.changed) self._pollingLabel = QLabel() self._pollingTime = QSpinBox() self._pollingTime.setRange(0, 1000) self._pollingTime.setSuffix(" ms") self._pollingTime.valueChanged.connect(self.changed) layout = QVBoxLayout() self.setLayout(layout) layout.addWidget(self._closeOutputs) app.translateUI(self) hbox = QHBoxLayout() layout.addLayout(hbox) hbox.addWidget(self._pollingLabel) hbox.addWidget(self._pollingTime) def translateUI(self): self.setTitle(_("Preferences")) self._closeOutputs.setText(_("Close unused MIDI output")) self._closeOutputs.setToolTip( _("Closes unused MIDI ports after one minute. " 'See "What\'s This" for more information.') ) self._closeOutputs.setWhatsThis( _( "<p>If checked, Frescobaldi will close MIDI output ports that are not " "used for one minute.</p>\n" "<p>This could free up system resources that a software MIDI synthesizer " "might be using, thus saving battery power.</p>\n" "<p>A side effect is that if you pause a MIDI file for a long time " "the instruments are reset to the default piano (instrument 0). " "In that case, playing the file from the beginning sets up the " "instruments again.</p>\n" ) ) self._pollingLabel.setText(_("Polling time for input:")) self._pollingTime.setToolTip(_("Polling time for MIDI input. " 'See "What\'s This" for more information.')) self._pollingTime.setWhatsThis( _( "Sets the time between the polling of the MIDI input port in milliseconds. " "Small values lead to faster recognition of incoming MIDI events, but stress " "the CPU. 10 ms should be a good value." ) ) def loadSettings(self): s = QSettings() self._closeOutputs.setChecked(s.value("midi/close_outputs", False, bool)) self._pollingTime.setValue(s.value("midi/polling_time", 10, int)) def saveSettings(self): s = QSettings() s.setValue("midi/close_outputs", self._closeOutputs.isChecked()) s.setValue("midi/polling_time", self._pollingTime.value())
class Dial(QDialog): choices =['flat', 'hanning', 'hamming', 'bartlett', 'blackman'] def __init__(self, parent): QDialog.__init__(self, parent) f =QFormLayout(self) self.a =QSpinBox(self) self.a.setValue(30) self.b = QComboBox(self) self.b.addItems(self.choices) self.c= QDialogButtonBox(self) self.c.setStandardButtons(QDialogButtonBox.Cancel|QDialogButtonBox.Ok) f.addRow("window:" ,self.a) f.addRow("method:", self.b) f.addRow("", self.c) self.connect(self.c, SIGNAL("accepted()"), self.sendData) self.connect(self.c, SIGNAL("rejected()"), self.reinitialize) def sendData(self): self.parent().window = self.a.value() self.parent().method = self.b.currentText() self.close() def reinitialize(self): self.parent().window = None self.parent().method = None self.close()
class ClassicalGuitar(TablaturePart): @staticmethod def title(_=__builtin__._): return _("Classical guitar") @staticmethod def short(_=__builtin__._): return _("abbreviation for Classical guitar", "Gt.") midiInstrument = "acoustic guitar (nylon)" clef = "treble_8" tunings = (("guitar-tuning", lambda: _("Guitar tuning")), ("guitar-open-g-tuning", lambda: _("Open G-tuning"))) def createWidgets(self, layout): super(ClassicalGuitar, self).createWidgets(layout) self.voicesLabel = QLabel() self.voices = QSpinBox(minimum=1, maximum=4, value=1) box = QHBoxLayout() box.addWidget(self.voicesLabel) box.addWidget(self.voices) layout.addLayout(box) def translateWidgets(self): super(ClassicalGuitar, self).translateWidgets() self.voicesLabel.setText(_("Voices:")) def voiceCount(self): return self.voices.value()
class MikidownCfgDialog(QDialog): def __init__(self, parent=None): super(MikidownCfgDialog, self).__init__(parent) #tab = QWidget() #tab2 = QWidget() self.recentNotesCount = QSpinBox() recent_notes_n = Mikibook.settings.value('recentNotesNumber',type=int, defaultValue=20) self.recentNotesCount.setValue(recent_notes_n) self.buttonBox = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel) self.hltCfg = MikidownHighlightCfgWidget(parent=self) layout = QGridLayout(self) layout.addWidget(QLabel("# of recently viewed notes to keep"),0,0,1,1) layout.addWidget(self.recentNotesCount,0,1,1,1) qs = QScrollArea(self) qs.setWidget(self.hltCfg) layout.addWidget(qs,1,0,1,2) layout.addWidget(self.buttonBox,2,0,1,2) self.buttonBox.accepted.connect(self.accept) self.buttonBox.rejected.connect(self.reject) def accept(self): Mikibook.settings.setValue('recentNotesNumber', self.recentNotesCount.value()) Mikibook.setHighlighterColors(self.hltCfg.configToList()) #then make mikidown use these settings NOW self.parent().loadHighlighter() QDialog.accept(self)
class MikidownCfgDialog(QDialog): def __init__(self, parent=None): super(MikidownCfgDialog, self).__init__(parent) #tab = QWidget() #tab2 = QWidget() self.recentNotesCount = QSpinBox() recent_notes_n = Mikibook.settings.value('recentNotesNumber', type=int, defaultValue=20) self.recentNotesCount.setValue(recent_notes_n) self.buttonBox = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel) self.hltCfg = MikidownHighlightCfgWidget(parent=self) layout = QGridLayout(self) layout.addWidget(QLabel("# of recently viewed notes to keep"), 0, 0, 1, 1) layout.addWidget(self.recentNotesCount, 0, 1, 1, 1) qs = QScrollArea(self) qs.setWidget(self.hltCfg) layout.addWidget(qs, 1, 0, 1, 2) layout.addWidget(self.buttonBox, 2, 0, 1, 2) self.buttonBox.accepted.connect(self.accept) self.buttonBox.rejected.connect(self.reject) def accept(self): Mikibook.settings.setValue('recentNotesNumber', self.recentNotesCount.value()) Mikibook.setHighlighterColors(self.hltCfg.configToList()) #then make mikidown use these settings NOW self.parent().loadHighlighter() QDialog.accept(self)
class Dial(QDialog): choices = ['flat', 'hanning', 'hamming', 'bartlett', 'blackman'] def __init__(self, parent): QDialog.__init__(self, parent) f = QFormLayout(self) self.a = QSpinBox(self) self.a.setValue(30) self.b = QComboBox(self) self.b.addItems(self.choices) self.c = QDialogButtonBox(self) self.c.setStandardButtons(QDialogButtonBox.Cancel | QDialogButtonBox.Ok) f.addRow("window:", self.a) f.addRow("method:", self.b) f.addRow("", self.c) self.connect(self.c, SIGNAL("accepted()"), self.sendData) self.connect(self.c, SIGNAL("rejected()"), self.reinitialize) def sendData(self): self.parent().window = self.a.value() self.parent().method = self.b.currentText() self.close() def reinitialize(self): self.parent().window = None self.parent().method = None self.close()
class DataConfigurationWidget(ConfigurationWidget): def __init__(self): ConfigurationWidget.__init__(self) self.keyIndex = QSpinBox() self.keyIndex.setMinimum(0) self.addRow("index:", self.keyIndex) self.setIndexBounds(0) self.connect(self.keyIndex, SIGNAL("valueChanged(int)"), self.applyConfiguration) def setIndexBounds(self, i): self.keyIndex.setMaximum(i) def getIndex(self): return self.keyIndex.value() def setParameter(self, parameter): self.parameter = parameter self.applyConfiguration(False) def applyConfiguration(self, emit=True): user_data = {"state": self.getState(), "data_index": self.getIndex()} self.parameter.setUserData(user_data) self.emitConfigurationChanged(emit)
class ResizeDlg(QDialog): def __init__(self, width, height, parent=None): super(ResizeDlg, self).__init__(parent) self.create_widgets(width, height) self.layout_widgets() self.create_connections() 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 layout_widgets(self): layout = QGridLayout() layout.addWidget(self.widthLabel, 0, 0) layout.addWidget(self.widthSpinBox, 0, 1) layout.addWidget(self.heightLabel, 1, 0) layout.addWidget(self.heightSpinBox, 1, 1) layout.addWidget(self.buttonBox, 2, 0, 1, 2) self.setLayout(layout) def create_connections(self): self.buttonBox.accepted.connect(self.accept) self.buttonBox.rejected.connect(self.reject) self.setWindowTitle("Image Changer - Resize") def result(self): return self.widthSpinBox.value(), self.heightSpinBox.value()
class IntegerProperty(Property, QWidget): """ Property which hold editable integer numbers. A Spinbox is provided when the property is editable. """ USER_INFO = "Integer field" 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 setReadOnly(self, readOnly): """ Switches between lineedit and spinbox. """ if readOnly: self._spinbox.hide() self._lineedit.show() self.setFocusProxy(self._lineedit) else: self._spinbox.show() self._lineedit.hide() self.setFocusProxy(self._spinbox) def value(self): """ Returns integer value. """ return self._spinbox.value() def setValue(self, value): self.disconnect(self._spinbox, SIGNAL('valueChanged(int)'), self.valueChanged) self._spinbox.setValue(value % self.maxint) self.connect(self._spinbox, SIGNAL('valueChanged(int)'), self.valueChanged) self._lineedit.setText(str(value))
class DurationEditor(QWidget): """ Speaks in seconds to programs, and Hours/Minutes/Seconds to human beings """ def __init__(self, parent=None): QWidget.__init__(self, parent) box = QHBoxLayout(self) self.hours = QSpinBox() self.minutes = QSpinBox() self.seconds = QSpinBox() for spinbox in (self.hours, self.minutes, self.seconds): spinbox.setMinimum(0) box.addWidget(self.hours) box.addWidget(QLabel(tr('h'))) box.addWidget(self.minutes) box.addWidget(QLabel(tr('m'))) box.addWidget(self.seconds) box.addWidget(QLabel(tr('s'))) self.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Minimum) def _seconds2hms(self, value): #integer division hours = value[0] / 3600 remainder = value[0] % 3600 minutes = remainder / 60 seconds = remainder % 60 return hours, minutes, seconds def setMaximum(self, maximum): hours, minutes, seconds = self._seconds2hms(maximum) self.hours.setMaximum(hours) self.minutes.setMaximum(minutes) self.seconds.setMaximum(seconds) def setValue(self, value): hours, minutes, seconds = self._seconds2hms(value) self.hours.setValue(hours) self.minutes.setValue(minutes) self.seconds.setValue(seconds) def value(self): return self.hours.value()*3600 + self.minutes.value()*3600 + self.seconds.value()[0]
class Prefs(preferences.Group): def __init__(self, page): super(Prefs, self).__init__(page) self._closeOutputs = QCheckBox(clicked=self.changed) self._pollingLabel = QLabel() self._pollingTime = QSpinBox() self._pollingTime.setRange(0, 1000) self._pollingTime.setSuffix(" ms") self._pollingTime.valueChanged.connect(self.changed) layout = QVBoxLayout() self.setLayout(layout) layout.addWidget(self._closeOutputs) app.translateUI(self) hbox = QHBoxLayout() layout.addLayout(hbox) hbox.addWidget(self._pollingLabel) hbox.addWidget(self._pollingTime) def translateUI(self): self.setTitle(_("Preferences")) self._closeOutputs.setText(_("Close unused MIDI output")) self._closeOutputs.setToolTip( _("Closes unused MIDI ports after one minute. " "See \"What's This\" for more information.")) self._closeOutputs.setWhatsThis( _("<p>If checked, Frescobaldi will close MIDI output ports that are not " "used for one minute.</p>\n" "<p>This could free up system resources that a software MIDI synthesizer " "might be using, thus saving battery power.</p>\n" "<p>A side effect is that if you pause a MIDI file for a long time " "the instruments are reset to the default piano (instrument 0). " "In that case, playing the file from the beginning sets up the " "instruments again.</p>\n")) self._pollingLabel.setText(_("Polling time for input:")) self._pollingTime.setToolTip( _("Polling time for MIDI input. " "See \"What's This\" for more information.")) self._pollingTime.setWhatsThis( _("Sets the time between the polling of the MIDI input port in milliseconds. " "Small values lead to faster recognition of incoming MIDI events, but stress " "the CPU. 10 ms should be a good value.")) def loadSettings(self): s = QSettings() self._closeOutputs.setChecked( s.value("midi/close_outputs", False, bool)) self._pollingTime.setValue(s.value("midi/polling_time", 10, int)) def saveSettings(self): s = QSettings() s.setValue("midi/close_outputs", self._closeOutputs.isChecked()) s.setValue("midi/polling_time", self._pollingTime.value())
class IntegerProperty(Property,QWidget): """ Property which hold editable integer numbers. A Spinbox is provided when the property is editable. """ USER_INFO = "Integer field" 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 setReadOnly(self, readOnly): """ Switches between lineedit and spinbox. """ if readOnly: self._spinbox.hide() self._lineedit.show() self.setFocusProxy(self._lineedit) else: self._spinbox.show() self._lineedit.hide() self.setFocusProxy(self._spinbox) def value(self): """ Returns integer value. """ return self._spinbox.value() def setValue(self,value): self.disconnect(self._spinbox, SIGNAL('valueChanged(int)'), self.valueChanged) self._spinbox.setValue(value % self.maxint) self.connect(self._spinbox, SIGNAL('valueChanged(int)'), self.valueChanged) self._lineedit.setText(str(value))
class SpinSlider(QWidget): "Boite de spin + curseur avec sauvegarde de la dernière valeur sélectionnée" def __init__(self, debut, fin, defaut, optionConfig=None, parent=None): QWidget.__init__(self) self.spin = QSpinBox() self.slider = QSlider(Qt.Horizontal) self.spin.setRange(debut, fin) self.slider.setRange(debut, fin) valeur = None if optionConfig: self.config = parent.config self.idSection = parent.idSection self.optionConfig = optionConfig try : valeur = self.config.get(self.idSection, self.optionConfig) except: valeur = defaut self.config.set(self.idSection, self.optionConfig, valeur) erreur = False if valeur: try: valeur = int(valeur) except ValueError: erreur = True if not erreur and debut <= valeur <= fin: self.spin.setValue(valeur) self.slider.setValue(valeur) else: self.spin.setValue(defaut) self.slider.setValue(defaut) if optionConfig: self.connect(self.spin, SIGNAL("valueChanged(int)"), self.sauveConfig) self.connect(self.spin, SIGNAL("valueChanged(int)"), self.slider, SLOT("setValue(int)")) self.connect(self.slider, SIGNAL("valueChanged(int)"), self.spin, SLOT("setValue(int)")) self.connect(self.spin, SIGNAL("valueChanged(int)"), self.changed) hbox = QHBoxLayout(self) hbox.addWidget(self.spin) hbox.addWidget(self.slider) hbox.setMargin(0) # pour un meilleur alignement dans un grid def changed(self, i): self.emit(SIGNAL("valueChanged(int)"), i) def sauveConfig(self, i): self.config.set(self.idSection, self.optionConfig, str(i)) def value(self): return self.spin.value() def setValue(self, i): self.spin.setValue(i) self.slider.setValue(i)
class PointParameterWidget(GenericParameterWidget): """Widget class for Integer parameter.""" def __init__(self, parameter, parent=None): """Constructor .. versionadded:: 2.2 :param parameter: A IntegerParameter object. :type parameter: IntegerParameter """ # Size policy self._spin_box_size_policy = QSizePolicy( QSizePolicy.Fixed, QSizePolicy.Fixed) super(PointParameterWidget, self).__init__(parameter, parent) self._input_x = QSpinBox() self._input_x.setValue(self._parameter.value[0]) tool_tip = 'X' self._input_x.setToolTip(tool_tip) self._input_x.setSizePolicy(self._spin_box_size_policy) self._input_y = QSpinBox() self._input_y.setValue(self._parameter.value[1]) tool_tip = 'Y' self._input_y.setToolTip(tool_tip) self._input_y.setSizePolicy(self._spin_box_size_policy) self._inner_input_layout.addWidget(self._input_x) self._inner_input_layout.addWidget(self._input_y) def get_parameter(self): """Obtain boolean parameter object from the current widget state. :returns: A BooleanParameter from the current state of widget """ self._parameter.value = (self._input_x.value(), self._input_y.value()) return self._parameter
class Form(QDialog): 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 update_ui(self): amount = self.spin_amount.value() rate = self.spin_rate.value() year = self.spin_year.value() total = amount * (1 + rate / 100.0)**year self.label_total.setText('Rp. %.2f' % total)
class FieldConfigurationWidget(ConfigurationWidget): def __init__(self): ConfigurationWidget.__init__(self) self.keyIndexI = QSpinBox() self.keyIndexI.setMinimum(1) self.addRow("i:", self.keyIndexI) self.keyIndexJ = QSpinBox() self.keyIndexJ.setMinimum(1) self.addRow("j:", self.keyIndexJ) self.keyIndexK = QSpinBox() self.keyIndexK.setMinimum(1) self.addRow("k:", self.keyIndexK) self.setFieldBounds(1, 1, 1) self.connect(self.keyIndexI, SIGNAL("valueChanged(int)"), self.applyConfiguration) self.connect(self.keyIndexJ, SIGNAL("valueChanged(int)"), self.applyConfiguration) self.connect(self.keyIndexK, SIGNAL("valueChanged(int)"), self.applyConfiguration) def setFieldBounds(self, i, j, k): self.keyIndexI.setMaximum(i) self.keyIndexJ.setMaximum(j) self.keyIndexK.setMaximum(k) def getFieldPosition(self): return (self.keyIndexI.value(), self.keyIndexJ.value(), self.keyIndexK.value()) def setParameter(self, parameter): self.parameter = parameter self.applyConfiguration(False) def applyConfiguration(self, emit=True): user_data = {"state": self.getState(), "field_position": self.getFieldPosition()} self.parameter.setUserData(user_data) self.emitConfigurationChanged(emit)
def multisig_choice(self): vbox = QVBoxLayout() self.set_layout(vbox) vbox.addWidget(QLabel(_("Multi Signature Wallet"))) cw = CosignWidget(2, 2) vbox.addWidget(cw, 1) vbox.addWidget(QLabel(_("Please choose the number of signatures needed to unlock funds in your wallet") + ':')) m_edit = QSpinBox() n_edit = QSpinBox() m_edit.setValue(2) n_edit.setValue(2) n_edit.setMinimum(2) n_edit.setMaximum(15) m_edit.setMinimum(1) m_edit.setMaximum(2) n_edit.valueChanged.connect(m_edit.setMaximum) n_edit.valueChanged.connect(cw.set_n) m_edit.valueChanged.connect(cw.set_m) hbox = QHBoxLayout() hbox.addWidget(QLabel(_('Require'))) hbox.addWidget(m_edit) hbox.addWidget(QLabel(_('of'))) hbox.addWidget(n_edit) hbox.addWidget(QLabel(_('signatures'))) hbox.addStretch(1) vbox.addLayout(hbox) vbox.addStretch(1) vbox.addLayout(Buttons(CancelButton(self), OkButton(self, _('Next')))) if not self.exec_(): return m = int(m_edit.value()) n = int(n_edit.value()) wallet_type = '%dof%d' % (m, n) return wallet_type
class SpinBox(QWidget): def __init__(self, id, text, **kwargs): QWidget.__init__(self) self.id = id self.widget = QSpinBox(**kwargs) label = QLabel(text) hbox = HBoxLayout() hbox.addWidget(label) hbox.addWidget(self.widget) self.setLayout(hbox) def parameterValues(self): return {self.id:self.widget.value()}
class CharColumnConfigurationWidget(QWidget, columnproviders.AbstractColumnConfigurationWidget): def __init__(self, parent, hex_widget, column): QWidget.__init__(self, parent) columnproviders.AbstractColumnConfigurationWidget.__init__(self) self.hexWidget = hex_widget self.columnModel = column self.setLayout(QFormLayout()) self.layout().setContentsMargins(0, 0, 0, 0) self.cmbEncoding = QComboBox(self) self.cmbEncoding.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Preferred) self.layout().addRow(utils.tr('Encoding:'), self.cmbEncoding) for encoding in sorted(encodings.encodings.keys()): self.cmbEncoding.addItem(encoding) if column is not None and column.codec.name.lower() == encoding.lower(): self.cmbEncoding.setCurrentIndex(self.cmbEncoding.count() - 1) if column is None: self.cmbEncoding.setCurrentIndex(self.cmbEncoding.findText('Windows-1251')) self.spnBytesOnRow = QSpinBox(self) self.spnBytesOnRow.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Preferred) self.spnBytesOnRow.setMinimum(1) self.spnBytesOnRow.setMaximum(32) self.layout().addRow(utils.tr('Bytes on row:'), self.spnBytesOnRow) if column is not None: self.spnBytesOnRow.setValue(column.bytesOnRow) else: self.spnBytesOnRow.setValue(16) def createColumnModel(self, hex_widget): model = CharColumnModel(self.hexWidget.document, encodings.getCodec(self.cmbEncoding.currentText()), self.hexWidget.font(), self.spnBytesOnRow.value()) return model def saveToColumn(self, column): column.codec = encodings.getCodec(self.cmbEncoding.currentText()) column._bytesOnRow = self.spnBytesOnRow.value() column.reset()
class Form(QDialog): 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 update_ui(self): amount = self.spin_amount.value() rate = self.spin_rate.value() year = self.spin_year.value() total = amount * (1 + rate / 100.0) ** year self.label_total.setText('Rp. %.2f' % total)
class IntervalWidget(QWidget): def __init__(self, parent=None): QWidget.__init__(self, parent) layout = QHBoxLayout(self) layout.setContentsMargins(0,0,0,0) self.spinbox = QSpinBox(self) self.combo = QComboBox(self) sp = self.spinbox.sizePolicy() sp.setHorizontalStretch(1) self.spinbox.setSizePolicy(sp) self.spinbox.setRange(0, (1 << 31) - 1) self.spinbox.setSingleStep(1) self.combo.addItem('Seconds') self.combo.addItem('Milliseconds') layout.addWidget(self.spinbox) layout.addWidget(self.combo) def set_interval(self, interval): if ('%.03f' % interval).endswith('.000'): self.spinbox.setValue(int(interval)) self.combo.setCurrentIndex(0) else: self.spinbox.setValue(round(interval * 1000.0)) self.combo.setCurrentIndex(1) def get_interval(self): if self.combo.currentIndex() == 0: return self.spinbox.value() else: return self.spinbox.value() / 1000.0
class IntegerSpinner(HelpedWidget): """A spinner widget for integers. The data structure expected and sent to the getter and setter is an integer.""" def __init__(self, model, spinner_label="Integer Number", help_link=""): HelpedWidget.__init__(self, spinner_label, help_link) assert isinstance(model, SpinnerModelMixin) self.model = model model.observable().attach( SpinnerModelMixin.SPINNER_VALUE_CHANGED_EVENT, self.getValueFromModel) model.observable().attach(SpinnerModelMixin.RANGE_VALUE_CHANGED_EVENT, self.getRangeFromModel) self.spinner = QSpinBox(self) self.addWidget(self.spinner) self.info_label = QLabel() self.info_label.setHidden(True) self.addWidget(self.info_label) self.addStretch() # self.connect(self.spinner, SIGNAL('editingFinished()'), self.updateModel) self.__initialized = False self.connect(self.spinner, SIGNAL('valueChanged(int)'), self.updateModel) self.getRangeFromModel() self.getValueFromModel() def updateModel(self): """Called whenever the contents of the spinner changes.""" if self.__initialized: self.model.setSpinnerValue(self.spinner.value()) def getRangeFromModel(self): self.spinner.setMinimum(self.model.getMinValue()) self.spinner.setMaximum(self.model.getMaxValue()) def getValueFromModel(self): """Retrieves data from the model and inserts it into the spinner""" if not self.__initialized: self.__initialized = True self.spinner.setValue(self.model.getSpinnerValue()) def setInfo(self, info): self.info_label.setText(info) self.info_label.setHidden(False)
class StaffBase(QWidget): def __init__(self, dialog): QWidget.__init__(self, dialog) self.dialog = dialog self.setLayout(QGridLayout()) self.systems = QSpinBox() self.systems.setRange(1, 64) self.layout().setColumnStretch(0, 1) self.layout().setColumnStretch(3, 1) def systemCount(self): return self.systems.value() def music(self, layout): """ add lines to layout contexts and returns the music, also in lines """ return []
def setCacheSize( cache_size ): dlg = QDialog(self) layout = QHBoxLayout() layout.addWidget( QLabel("Cached Slices Per View:") ) spinBox = QSpinBox( parent=dlg ) spinBox.setRange( 0, 1000 ) spinBox.setValue( self.editor.cacheSize ) 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: self.editor.cacheSize = spinBox.value()
def setCacheSize(cache_size): dlg = QDialog(self) layout = QHBoxLayout() layout.addWidget(QLabel("Cached Slices Per View:")) spinBox = QSpinBox(parent=dlg) spinBox.setRange(0, 1000) spinBox.setValue(self.editor.cacheSize) 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: self.editor.cacheSize = spinBox.value()
class NewProjectDialog(QDialog): def __init__(self, parent=None): super(NewProjectDialog,self).__init__(parent) self.setSizeGripEnabled(True) self.create_layout() def create_layout(self): # select directory containing images # configure the skip-frames # cancel or create project self.project_name_ = QLineEdit() self.filefield_ = QFileField(msg="Select Image Directory...", select_dir=True) self.skip_ = QSpinBox() self.skip_.setRange(0,50) self.skip_.setValue(5) layout = QFormLayout(self) layout.setLabelAlignment(Qt.AlignVCenter) layout.addRow("Project Name:", self.project_name_) layout.addRow("Image Directory:", self.filefield_) layout.addRow("Skip images:", self.skip_) dbb = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel) dbb.accepted.connect(self.on_accept) dbb.rejected.connect(self.on_reject) layout.addRow(dbb) self.setLayout(layout) @property def name(self): return self.project_name_.text() @property def path(self): return self.filefield_.path @property def skip(self): return self.skip_.value() def on_accept(self): # todo: check file validity self.accept() def on_reject(self): self.reject()
class IntegerSpinner(HelpedWidget): """A spinner widget for integers. The data structure expected and sent to the getter and setter is an integer.""" def __init__(self, model, spinner_label="Integer Number", help_link=""): HelpedWidget.__init__(self, spinner_label, help_link) assert isinstance(model, SpinnerModelMixin) self.model = model model.observable().attach(SpinnerModelMixin.SPINNER_VALUE_CHANGED_EVENT, self.getValueFromModel) model.observable().attach(SpinnerModelMixin.RANGE_VALUE_CHANGED_EVENT, self.getRangeFromModel) self.spinner = QSpinBox(self) self.addWidget(self.spinner) self.info_label = QLabel() self.info_label.setHidden(True) self.addWidget(self.info_label) self.addStretch() # self.connect(self.spinner, SIGNAL('editingFinished()'), self.updateModel) self.__initialized = False self.connect(self.spinner, SIGNAL("valueChanged(int)"), self.updateModel) self.getRangeFromModel() self.getValueFromModel() def updateModel(self): """Called whenever the contents of the spinner changes.""" if self.__initialized: self.model.setSpinnerValue(self.spinner.value()) def getRangeFromModel(self): self.spinner.setMinimum(self.model.getMinValue()) self.spinner.setMaximum(self.model.getMaxValue()) def getValueFromModel(self): """Retrieves data from the model and inserts it into the spinner""" if not self.__initialized: self.__initialized = True self.spinner.setValue(self.model.getSpinnerValue()) def setInfo(self, info): self.info_label.setText(info) self.info_label.setHidden(False)
class ViewSettings(preferences.Group): def __init__(self, page): super(ViewSettings, self).__init__(page) layout = QGridLayout(spacing=1) self.setLayout(layout) self.wrapLines = QCheckBox(toggled=self.changed) self.numContextLines = QSpinBox(minimum=0, maximum=20, valueChanged=self.changed) self.numContextLinesLabel = l = QLabel() l.setBuddy(self.numContextLines) layout.addWidget(self.wrapLines, 0, 0, 1, 1) layout.addWidget(self.numContextLinesLabel, 1, 0) layout.addWidget(self.numContextLines, 1, 1) app.translateUI(self) def translateUI(self): self.setTitle(_("View Preferences")) self.wrapLines.setText(_("Wrap long lines by default")) self.wrapLines.setToolTip('<qt>' + _( "If enabled, lines that don't fit in the editor width are wrapped " "by default. " "Note: when the document is displayed by multiple views, they all " "share the same line wrapping width, which might look strange.")) self.numContextLinesLabel.setText(_("Number of surrounding lines:")) self.numContextLines.setToolTip('<qt>' + _( "When jumping between search results or clicking on a link, the " "text view tries to scroll as few lines as possible. " "Here you can speficy how many surrounding lines at least should " "be visible.")) self.numContextLinesLabel.setToolTip(self.numContextLines.toolTip()) def loadSettings(self): s = QSettings() s.beginGroup("view_preferences") self.wrapLines.setChecked(s.value("wrap_lines", False, bool)) self.numContextLines.setValue(s.value("context_lines", 3, int)) def saveSettings(self): s = QSettings() s.beginGroup("view_preferences") s.setValue("wrap_lines", self.wrapLines.isChecked()) s.setValue("context_lines", self.numContextLines.value())
class ViewSettings(preferences.Group): def __init__(self, page): super(ViewSettings, self).__init__(page) layout = QGridLayout(spacing=1) self.setLayout(layout) self.wrapLines = QCheckBox(toggled=self.changed) self.numContextLines = QSpinBox(minimum=0, maximum=20, valueChanged=self.changed) self.numContextLinesLabel = l = QLabel() l.setBuddy(self.numContextLines) layout.addWidget(self.wrapLines, 0, 0, 1, 1) layout.addWidget(self.numContextLinesLabel, 1, 0) layout.addWidget(self.numContextLines, 1, 1) app.translateUI(self) def translateUI(self): self.setTitle(_("View Preferences")) self.wrapLines.setText(_("Wrap long lines by default")) self.wrapLines.setToolTip('<qt>' + _( "If enabled, lines that don't fit in the editor width are wrapped " "by default. " "Note: when the document is displayed by multiple views, they all " "share the same line wrapping width, which might look strange.")) self.numContextLinesLabel.setText(_("Number of surrounding lines:")) self.numContextLines.setToolTip('<qt>' + _( "When jumping between search results or clicking on a link, the " "text view tries to scroll as few lines as possible. " "Here you can specify how many surrounding lines at least should " "be visible.")) self.numContextLinesLabel.setToolTip(self.numContextLines.toolTip()) def loadSettings(self): s = QSettings() s.beginGroup("view_preferences") self.wrapLines.setChecked(s.value("wrap_lines", False, bool)) self.numContextLines.setValue(s.value("context_lines", 3, int)) def saveSettings(self): s = QSettings() s.beginGroup("view_preferences") s.setValue("wrap_lines", self.wrapLines.isChecked()) s.setValue("context_lines", self.numContextLines.value())
class MikidownCfgDialog(QDialog): def __init__(self, parent=None): super(MikidownCfgDialog, self).__init__(parent) #tab = QWidget() #tab2 = QWidget() self.recentNotesCount = QSpinBox() recent_notes_n = Mikibook.settings.value('recentNotesNumber',type=int, defaultValue=20) self.recentNotesCount.setValue(recent_notes_n) self.buttonBox = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel) layout = QGridLayout(self) layout.addWidget(QLabel("# of recently viewed notes to keep"),0,0,1,1) layout.addWidget(self.recentNotesCount,0,1,1,1) layout.addWidget(self.buttonBox,1,0,1,2) self.buttonBox.accepted.connect(self.accept) self.buttonBox.rejected.connect(self.reject) def accept(self): Mikibook.settings.setValue('recentNotesNumber', self.recentNotesCount.value()) QDialog.accept(self)
class ClassicalGuitar(TablaturePart): @staticmethod def title(_=_base.translate): return _("Classical guitar") @staticmethod def short(_=_base.translate): return _("abbreviation for Classical guitar", "Gt.") midiInstrument = 'acoustic guitar (nylon)' clef = "treble_8" tunings = ( ('guitar-tuning', lambda: _("Guitar tuning")), ('guitar-seven-string-tuning', lambda: _("Guitar seven-string tuning")), ('guitar-drop-d-tuning', lambda: _("Guitar drop-D tuning")), ('guitar-drop-c-tuning', lambda: _("Guitar drop-C tuning")), ('guitar-open-g-tuning', lambda: _("Open G-tuning")), ('guitar-open-d-tuning', lambda: _("Guitar open D tuning")), ('guitar-dadgad-tuning', lambda: _("Guitar d-a-d-g-a-d tuning")), ('guitar-lute-tuning', lambda: _("Lute tuning")), ('guitar-asus4-tuning', lambda: _("Guitar A-sus4 tuning")), ) def createWidgets(self, layout): super(ClassicalGuitar, self).createWidgets(layout) self.voicesLabel = QLabel() self.voices = QSpinBox(minimum=1, maximum=4, value=1) box = QHBoxLayout() box.addWidget(self.voicesLabel) box.addWidget(self.voices) layout.addLayout(box) def translateWidgets(self): super(ClassicalGuitar, self).translateWidgets() self.voicesLabel.setText(_("Voices:")) def voiceCount(self): return self.voices.value()
class CADOptionsToolbar_Ellipse(CADOptionsToolbar): def __init__(self): super(CADOptionsToolbar_Ellipse, self).__init__() self.settings = QSettings() self.spinBox = QSpinBox(self.optionsToolBar) self.spinBox.setMinimum(3) self.spinBox.setMaximum(3600) segvalue = self.settings.value("/CADDigitize/ellipse/segments", 36, type=int) if not segvalue: self.settings.setValue("/CADDigitize/ellipse/segments", 36) self.spinBox.setValue(segvalue) self.spinBox.setSingleStep(1) self.spinBoxAction = self.optionsToolBar.addWidget(self.spinBox) self.spinBox.setToolTip(tr(u"Number of points")) self.spinBoxAction.setEnabled(True) self.spinBox.valueChanged["int"].connect(self.segmentsettingsEllipse) def segmentsettingsEllipse(self): self.settings.setValue("/CADDigitize/ellipse/segments", self.spinBox.value())
class CADOptionsToolbar_RPolygon(CADOptionsToolbar): def __init__(self): super(CADOptionsToolbar_RPolygon, self).__init__() self.settings = QSettings() self.spinBox = QSpinBox(self.optionsToolBar) self.spinBox.setMinimum(3) self.spinBox.setMaximum(3600) segvalue = self.settings.value("/CADDigitize/rpolygon/nbedges", 5, type=int) if not segvalue: self.settings.setValue("/CADDigitize/rpolygon/nbedges", 5) self.spinBox.setValue(segvalue) self.spinBox.setSingleStep(1) self.spinBoxAction = self.optionsToolBar.addWidget(self.spinBox) self.spinBox.setToolTip(tr(u"Number of edges")) self.spinBoxAction.setEnabled(True) self.spinBox.valueChanged["int"].connect(self.edgesSettingsRPolygon) def edgesSettingsRPolygon(self): self.settings.setValue("/CADDigitize/rpolygon/nbedges", self.spinBox.value())
class Window(QMainWindow): def __init__(self, parent=None): super(Window, self).__init__(parent) self.image = QImage() self.dirty = False self.filename = None self.mirroredvertically = False self.mirroredhorizontally = False self.printer = None self.create_widgets() self.create_actions() self.load_settings() self.setWindowTitle("Image Changer") self.updateFileMenu() QTimer.singleShot(0, self.loadInitialFile) def create_widgets(self): self.imageLabel = QLabel() self.imageLabel.setMinimumSize(200, 200) self.imageLabel.setAlignment(Qt.AlignCenter) self.imageLabel.setContextMenuPolicy(Qt.ActionsContextMenu) self.setCentralWidget(self.imageLabel) logDockWidget = QDockWidget("Log", self) logDockWidget.setObjectName("LogDockWidget") logDockWidget.setAllowedAreas(Qt.LeftDockWidgetArea | Qt.RightDockWidgetArea) self.listWidget = QListWidget() logDockWidget.setWidget(self.listWidget) self.addDockWidget(Qt.RightDockWidgetArea, logDockWidget) self.sizeLabel = QLabel() self.sizeLabel.setFrameStyle(QFrame.StyledPanel | QFrame.Sunken) status = self.statusBar() status.setSizeGripEnabled(False) status.addPermanentWidget(self.sizeLabel) status.showMessage("Ready", 5000) def create_actions(self): fileNewAction = self.createAction("&New...", self.fileNew, QKeySequence.New, "filenew", "Create an image file") fileOpenAction = self.createAction("&Open...", self.fileOpen, QKeySequence.Open, "fileopen", "Open an existing image file") fileSaveAction = self.createAction("&Save", self.fileSave, QKeySequence.Save, "filesave", "Save the image") fileSaveAsAction = self.createAction( "Save &As...", self.fileSaveAs, icon="filesaveas", tip="Save the image using a new name") filePrintAction = self.createAction("&Print", self.filePrint, QKeySequence.Print, "fileprint", "Print the image") fileQuitAction = self.createAction("&Quit", self.close, "Ctrl+Q", "filequit", "Close the application") editInvertAction = self.createAction("&Invert", None, "Ctrl+I", "editinvert", "Invert the image's colors", True) editInvertAction.toggled.connect(self.editInvert) editSwapRedAndBlueAction = self.createAction( "Sw&ap Red and Blue", None, "Ctrl+A", "editswap", "Swap the image's red and blue color components", True) editSwapRedAndBlueAction.toggled.connect(self.editSwapRedAndBlue) editZoomAction = self.createAction("&Zoom...", self.editZoom, "Alt+Z", "editzoom", "Zoom the image") mirrorGroup = QActionGroup(self) editUnMirrorAction = self.createAction("&Unmirror", None, "Ctrl+U", "editunmirror", "Unmirror the image", True) editUnMirrorAction.toggled.connect(self.editUnMirror) mirrorGroup.addAction(editUnMirrorAction) editMirrorHorizontalAction = self.createAction( "Mirror &Horizontally", None, "Ctrl+H", "editmirrorhoriz", "Horizontally mirror the image", True) editMirrorHorizontalAction.toggled.connect(self.editMirrorHorizontal) mirrorGroup.addAction(editMirrorHorizontalAction) editMirrorVerticalAction = self.createAction( "Mirror &Vertically", None, "Ctrl+V", "editmirrorvert", "Vertically mirror the image", True) editMirrorVerticalAction.toggled.connect(self.editMirrorVertical) mirrorGroup.addAction(editMirrorVerticalAction) editUnMirrorAction.setChecked(True) helpAboutAction = self.createAction("&About Image Changer", self.helpAbout) helpHelpAction = self.createAction("&Help", self.helpHelp, QKeySequence.HelpContents) self.fileMenu = self.menuBar().addMenu("&File") self.fileMenuActions = (fileNewAction, fileOpenAction, fileSaveAction, fileSaveAsAction, None, filePrintAction, fileQuitAction) self.fileMenu.aboutToShow.connect(self.updateFileMenu) editMenu = self.menuBar().addMenu("&Edit") self.addActions( editMenu, (editInvertAction, editSwapRedAndBlueAction, editZoomAction)) mirrorMenu = editMenu.addMenu(QIcon(":/editmirror.png"), "&Mirror") self.addActions(mirrorMenu, (editUnMirrorAction, editMirrorHorizontalAction, editMirrorVerticalAction)) helpMenu = self.menuBar().addMenu("&Help") self.addActions(helpMenu, (helpAboutAction, helpHelpAction)) fileToolbar = self.addToolBar("File") fileToolbar.setObjectName("FileToolBar") self.addActions(fileToolbar, (fileNewAction, fileOpenAction, fileSaveAsAction)) editToolbar = self.addToolBar("Edit") editToolbar.setObjectName("EditToolBar") self.addActions( editToolbar, (editInvertAction, editSwapRedAndBlueAction, editUnMirrorAction, editMirrorVerticalAction, editMirrorHorizontalAction)) self.zoomSpinBox = QSpinBox() self.zoomSpinBox.setRange(1, 400) self.zoomSpinBox.setSuffix(" %") self.zoomSpinBox.setValue(100) self.zoomSpinBox.setToolTip("Zoom the image") self.zoomSpinBox.setStatusTip(self.zoomSpinBox.toolTip()) self.zoomSpinBox.setFocusPolicy(Qt.NoFocus) self.zoomSpinBox.valueChanged.connect(self.showImage) editToolbar.addWidget(self.zoomSpinBox) self.addActions( self.imageLabel, (editInvertAction, editSwapRedAndBlueAction, editUnMirrorAction, editMirrorVerticalAction, editMirrorHorizontalAction)) self.resetableActions = ((editInvertAction, False), (editSwapRedAndBlueAction, False), (editUnMirrorAction, True)) def load_settings(self): settings = QSettings() self.recentFiles = settings.value("RecentFiles").toStringList() self.restoreGeometry( settings.value("MainWindow/Geometry").toByteArray()) self.restoreState(settings.value("MainWindow/State").toByteArray()) def createAction(self, text, slot=None, shortcut=None, icon=None, tip=None, checkable=False): action = QAction(text, self) if icon is not None: action.setIcon(QIcon(":/{0}.png".format(icon))) if shortcut is not None: action.setShortcut(shortcut) if tip is not None: action.setToolTip(tip) action.setStatusTip(tip) if slot is not None: action.triggered.connect(slot) if checkable: action.setCheckable(True) return action def addActions(self, target, actions): for action in actions: if action is None: target.addSeparator() else: target.addAction(action) def closeEvent(self, event): if self.okToContinue(): settings = QSettings() filename = (QVariant(QString(self.filename)) if self.filename is not None else QVariant()) settings.setValue("LastFile", filename) recentFiles = (QVariant(self.recentFiles) if self.recentFiles else QVariant()) settings.setValue("RecentFiles", recentFiles) settings.setValue("MainWindow/Geometry", QVariant(self.saveGeometry())) settings.setValue("MainWindow/State", QVariant(self.saveState())) else: event.ignore() def okToContinue(self): if self.dirty: reply = QMessageBox.question( self, "Image Changer - Unsaved Changes", "Save unsaved changes?", QMessageBox.Yes | QMessageBox.No | QMessageBox.Cancel) if reply == QMessageBox.Cancel: return False elif reply == QMessageBox.Yes: return self.fileSave() return True def loadInitialFile(self): settings = QSettings() fname = unicode(settings.value("LastFile").toString()) if fname and QFile.exists(fname): self.loadFile(fname) def updateStatus(self, message): self.statusBar().showMessage(message, 5000) self.listWidget.addItem(message) if self.filename is not None: self.setWindowTitle("Image Changer - {0}[*]".format( os.path.basename(self.filename))) elif not self.image.isNull(): self.setWindowTitle("Image Changer - Unnamed[*]") else: self.setWindowTitle("Image Changer[*]") self.setWindowModified(self.dirty) def updateFileMenu(self): self.fileMenu.clear() self.addActions(self.fileMenu, self.fileMenuActions[:-1]) current = (QString(self.filename) if self.filename is not None else None) recentFiles = [] for fname in self.recentFiles: if fname != current and QFile.exists(fname): recentFiles.append(fname) if recentFiles: self.fileMenu.addSeparator() for i, fname in enumerate(recentFiles): action = QAction( QIcon(":/icon.png"), "&{0} {1}".format(i + 1, QFileInfo(fname).fileName()), self) action.setData(QVariant(fname)) action.triggered.connect(self.loadFile) self.fileMenu.addAction(action) self.fileMenu.addSeparator() self.fileMenu.addAction(self.fileMenuActions[-1]) def fileNew(self): if not self.okToContinue(): return dialog = newimagedlg.NewImageDlg(self) if dialog.exec_(): self.addRecentFile(self.filename) self.image = QImage() for action, check in self.resetableActions: action.setChecked(check) self.image = dialog.image() self.filename = None self.dirty = True self.showImage() self.sizeLabel.setText("{0} x {1}".format(self.image.width(), self.image.height())) self.updateStatus("Created new image") def fileOpen(self): if not self.okToContinue(): return dir = (os.path.dirname(self.filename) if self.filename is not None else ".") formats = ([ "*.{0}".format(unicode(format).lower()) for format in QImageReader.supportedImageFormats() ]) fname = unicode( QFileDialog.getOpenFileName( self, "Image Changer - Choose Image", dir, "Image files ({0})".format(" ".join(formats)))) if fname: self.loadFile(fname) def loadFile(self, fname=None): if fname is None: action = self.sender() if isinstance(action, QAction): fname = unicode(action.data().toString()) if not self.okToContinue(): return else: return if fname: self.filename = None image = QImage(fname) if image.isNull(): message = "Failed to read {0}".format(fname) else: self.addRecentFile(fname) self.image = QImage() for action, check in self.resetableActions: action.setChecked(check) self.image = image self.filename = fname self.showImage() self.dirty = False self.sizeLabel.setText("{0} x {1}".format( image.width(), image.height())) message = "Loaded {0}".format(os.path.basename(fname)) self.updateStatus(message) def addRecentFile(self, fname): if fname is None: return if not self.recentFiles.contains(fname): self.recentFiles.prepend(QString(fname)) while self.recentFiles.count() > 9: self.recentFiles.takeLast() def fileSave(self): if self.image.isNull(): return True if self.filename is None: return self.fileSaveAs() else: if self.image.save(self.filename, None): self.updateStatus("Saved as {0}".format(self.filename)) self.dirty = False return True else: self.updateStatus("Failed to save {0}".format(self.filename)) return False def fileSaveAs(self): if self.image.isNull(): return True fname = self.filename if self.filename is not None else "." formats = ([ "*.{0}".format(unicode(format).lower()) for format in QImageWriter.supportedImageFormats() ]) fname = unicode( QFileDialog.getSaveFileName( self, "Image Changer - Save Image", fname, "Image files ({0})".format(" ".join(formats)))) if fname: if "." not in fname: fname += ".png" self.addRecentFile(fname) self.filename = fname return self.fileSave() return False def filePrint(self): if self.image.isNull(): return if self.printer is None: self.printer = QPrinter(QPrinter.HighResolution) self.printer.setPageSize(QPrinter.Letter) form = QPrintDialog(self.printer, self) if form.exec_(): painter = QPainter(self.printer) rect = painter.viewport() size = self.image.size() size.scale(rect.size(), Qt.KeepAspectRatio) painter.setViewport(rect.x(), rect.y(), size.width(), size.height()) painter.drawImage(0, 0, self.image) def editInvert(self, on): if self.image.isNull(): return self.image.invertPixels() self.showImage() self.dirty = True self.updateStatus("Inverted" if on else "Uninverted") def editSwapRedAndBlue(self, on): if self.image.isNull(): return self.image = self.image.rgbSwapped() self.showImage() self.dirty = True self.updateStatus( ("Swapped Red and Blue" if on else "Unswapped Red and Blue")) def editUnMirror(self, on): if self.image.isNull(): return if self.mirroredhorizontally: self.editMirrorHorizontal(False) if self.mirroredvertically: self.editMirrorVertical(False) def editMirrorHorizontal(self, on): if self.image.isNull(): return self.image = self.image.mirrored(True, False) self.showImage() self.mirroredhorizontally = not self.mirroredhorizontally self.dirty = True self.updateStatus( ("Mirrored Horizontally" if on else "Unmirrored Horizontally")) def editMirrorVertical(self, on): if self.image.isNull(): return self.image = self.image.mirrored(False, True) self.showImage() self.mirroredvertically = not self.mirroredvertically self.dirty = True self.updateStatus( ("Mirrored Vertically" if on else "Unmirrored Vertically")) def editZoom(self): if self.image.isNull(): return percent, ok = QInputDialog.getInteger(self, "Image Changer - Zoom", "Percent:", self.zoomSpinBox.value(), 1, 400) if ok: self.zoomSpinBox.setValue(percent) def showImage(self, percent=None): if self.image.isNull(): return if percent is None: percent = self.zoomSpinBox.value() factor = percent / 100.0 width = self.image.width() * factor height = self.image.height() * factor image = self.image.scaled(width, height, Qt.KeepAspectRatio) self.imageLabel.setPixmap(QPixmap.fromImage(image)) def helpAbout(self): QMessageBox.about( self, "About Image Changer", """<b>Image Changer</b> v {0} <p>Copyright © 2008-14 Qtrac Ltd. All rights reserved. <p>This application can be used to perform simple image manipulations. <p>Python {1} - Qt {2} - PyQt {3} on {4}""".format( __version__, platform.python_version(), QT_VERSION_STR, PYQT_VERSION_STR, platform.system())) def helpHelp(self): form = helpform.HelpForm("index.html", self) form.show()
class ScreenShot(QWidget): def __init__(self): super(ScreenShot, self).__init__() self.initUI() def initUI(self): self.originalPixmap = QPixmap() self.screenshotLabel = QLabel("screenshotlabel", self) self.screenshotLabel.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding) self.screenshotLabel.setAlignment(Qt.AlignCenter) self.screenGeometry = QApplication.desktop().screenGeometry( ) # Qrect() print self.screenGeometry, self.screenGeometry.width() self.screenshotLabel.setMinimumSize(self.screenGeometry.width() / 8, self.screenGeometry.height() / 8) mainlayout = QVBoxLayout(self) mainlayout.addWidget(self.screenshotLabel) self.optionsGroupBox = QGroupBox(u"选项", self) self.hideThisWindowCheckBox = QCheckBox(u"隐藏这个窗口", self.optionsGroupBox) self.optionsGroupBoxLayout = QGridLayout(self.optionsGroupBox) mainlayout.addWidget(self.optionsGroupBox) self.delaySpinBox = QSpinBox(self.optionsGroupBox) self.delaySpinBox.setSuffix(u"s") self.delaySpinBox.setMaximum(60) self.optionsGroupBoxLayout.addWidget(QLabel(u"截屏延时:", self), 0, 0) self.optionsGroupBoxLayout.addWidget(self.delaySpinBox, 0, 1) self.optionsGroupBoxLayout.addWidget(self.hideThisWindowCheckBox, 1, 0) buttonLayout = QHBoxLayout() self.newScreenshotButton = QPushButton(u"新截图", self) self.newScreenshotButton.clicked.connect(self.__newScreenshot) buttonLayout.addWidget(self.newScreenshotButton) saveScreenshotButton = QPushButton(u"保存截图", self) buttonLayout.addWidget(saveScreenshotButton) quitScreenshotButton = QPushButton(u"退出截图", self) quitScreenshotButton.setShortcut("Ctrl+Q") buttonLayout.addWidget(saveScreenshotButton) buttonLayout.addStretch() mainlayout.addLayout(buttonLayout) quitScreenshotButton.clicked.connect(self.close) saveScreenshotButton.clicked.connect(self.__saveScreenshot) self.delaySpinBox.valueChanged.connect(self.__updateCheckBox) self.delaySpinBox.setValue(5) self.setWindowTitle(u"截图") self.resize(300, 200) def resizeEvent(self, QResizeEvent): scaledSize = self.originalPixmap.size() scaledSize.scale(self.screenshotLabel.size(), Qt.KeepAspectRatio) if (not self.screenshotLabel.pixmap()) or ( scaledSize != self.screenshotLabel.pixmap().size()): self.__updateScreenshotLabel() def __newScreenshot(self): if self.hideThisWindowCheckBox.isChecked(): self.hide() self.newScreenshotButton.setDisabled(True) QTimer.singleShot(self.delaySpinBox.value() * 1000, self.__shootScreen) def __saveScreenshot(self): format = "png" initialPath = QDesktopServices.storageLocation( QDesktopServices.PicturesLocation) # initialPath = QStandardPaths::writableLocation(QStandardPaths::PicturesLocation); if initialPath.isEmpty(): initialPath = QDir.currentPath() initialPath += "/untitled." + format fileDialog = QtGui.QFileDialog(self, u"存储为", initialPath) fileDialog.setAcceptMode(QtGui.QFileDialog.AcceptSave) fileDialog.setFileMode(QtGui.QFileDialog.AnyFile) fileDialog.setDirectory(initialPath) mimeTypes = QStringList() for bf in QImageWriter.supportedImageFormats(): mimeTypes.append(QLatin1String(bf)) # fileDialog.setMin setMimeTypeFilters(mimeTypes) # fileDialog.selectMimeTypeFilter("image/" + format); fileDialog.setDefaultSuffix(format) if fileDialog.accept(): return fileName = fileDialog.selectedFiles().first() if not self.originalPixmap.save(fileName): QtGui.QMessageBox.Warning( self, u"保存错误", u"图像无法存储到 \"%s\"." % str(QDir.toNativeSeparators(fileName))) def __shootScreen(self): if self.delaySpinBox.value() != 0: QApplication.beep() self.originalPixmap = QPixmap.grabWindow( QApplication.desktop().winId()) self.__updateScreenshotLabel() self.newScreenshotButton.setDisabled(False) if self.hideThisWindowCheckBox.isChecked(): self.show() def __updateCheckBox(self): print "sssss" if self.delaySpinBox.value() == 0: self.hideThisWindowCheckBox.setDisabled(True) self.hideThisWindowCheckBox.setChecked(False) else: self.hideThisWindowCheckBox.setDisabled(False) def __updateScreenshotLabel(self): self.screenshotLabel.setPixmap( self.originalPixmap.scaled(self.screenshotLabel.size(), Qt.KeepAspectRatio, Qt.SmoothTransformation))
class Main(plugin.Plugin): ' main class for plugin ' def initialize(self, *args, **kwargs): ' class init ' super(Main, self).initialize(*args, **kwargs) self.group0 = QGroupBox() self.group0.setTitle(' Options ') self.group0.setCheckable(True) self.group0.toggled.connect(lambda: self.group0.hide()) self.spin1, self.spin2, self.spin3 = QSpinBox(), QSpinBox(), QSpinBox() self.spin4, self.spin5, self.spin6 = QSpinBox(), QSpinBox(), QSpinBox() self.spin7, self.spin8, self.spin9 = QSpinBox(), QSpinBox(), QSpinBox() self.spin10, self.output = QSpinBox(), QTextEdit() self.reset = QPushButton(QIcon.fromTheme("face-smile"), 'Reset Options') self.reset.clicked.connect(self.reset_options) self.reset_options() self.output.setReadOnly(True) vboxg3 = QVBoxLayout(self.group0) for each_widget in (QLabel('<b>Max Attributes Per Class:'), self.spin1, QLabel('<b>Max Methods Per Class:'), self.spin2, QLabel('<b>Max Functions Per File:'), self.spin3, QLabel('<b>Max Classes Per File:'), self.spin4, QLabel('<b>Max Parameters Per Function:'), self.spin5, QLabel('<b>Max Lines Per Function:'), self.spin6, QLabel('<b>Max ControlStatements Per Function:'), self.spin7, QLabel('<b>Max Lines Per File:'), self.spin8, QLabel('<b>Max Indentation Levels:'), self.spin9, QLabel('<b>Max Tabs:'), self.spin10, self.reset): vboxg3.addWidget(each_widget) self.group1, self.auto = QGroupBox(), QComboBox() self.group1.setTitle(' Automation ') self.group1.setCheckable(True) self.group1.setToolTip('<font color="red"><b>WARNING:Advanced Setting!') self.group1.toggled.connect(lambda: self.group1.hide()) self.auto.addItems(['Never run automatically', 'Run when File Saved', 'Run when File Executed', 'Run when Tab Changed', 'Run when File Opened', 'Run before File Saved']) self.auto.currentIndexChanged.connect(self.on_auto_changed) QVBoxLayout(self.group1).addWidget(self.auto) self.button = QPushButton(' Analyze for Best Practice ') self.button.setMinimumSize(75, 50) self.button.clicked.connect(self.run) glow = QGraphicsDropShadowEffect(self) glow.setOffset(0) glow.setBlurRadius(99) glow.setColor(QColor(99, 255, 255)) self.button.setGraphicsEffect(glow) class TransientWidget(QWidget): ' persistant widget thingy ' def __init__(self, widget_list): ' init sub class ' super(TransientWidget, self).__init__() vbox = QVBoxLayout(self) for each_widget in widget_list: vbox.addWidget(each_widget) tw = TransientWidget((QLabel('<i>Best Practice analyzer'), self.group0, self.group1, QLabel('<b>Best Practice Errors:'), self.output, self.button)) self.scrollable, self.dock = QScrollArea(), QDockWidget() self.scrollable.setWidgetResizable(True) self.scrollable.setWidget(tw) self.dock.setWindowTitle(__doc__) self.dock.setStyleSheet('QDockWidget::title{text-align: center;}') self.dock.setWidget(self.scrollable) ExplorerContainer().addTab(self.dock, "Check") QPushButton(QIcon.fromTheme("help-about"), 'About', self.dock ).clicked.connect(lambda: QMessageBox.information(self.dock, __doc__, HELPMSG)) def run(self): ' run the actions ' global MAXVAL self.output.clear() self.button.setDisabled(True) maxvalues = {'maxAttributesPerClass': int(self.spin1.value()), 'maxFunctionsPerClass': int(self.spin2.value()), 'maxFunctionsPerFile': int(self.spin3.value()), 'maxClassesPerFile': int(self.spin4.value()), 'maxParametersPerFunction': int(self.spin5.value()), 'maxLinesPerFunction': int(self.spin6.value()), 'maxControlStatementsPerFunction': int(self.spin7.value()), 'maxLinesPerFile': int(self.spin8.value()), 'maxIndentationLevel': int(self.spin9.value()), 'maxTabs': int(self.spin10.value())} MAXVAL = maxvalues self.output.append(SimplePythonChecker().analyze(str( self.locator.get_service("editor").get_opened_documents()[ self.locator.get_service("editor").get_tab_manager().currentIndex() ]), maxvalues)) self.output.setFocus() self.button.setEnabled(True) def on_auto_changed(self): ' automation connects ' if self.auto.currentIndex() is 1: self.locator.get_service('editor').fileSaved.connect(lambda: self.run()) QMessageBox.information(self.dock, __doc__, '<b>Now Actions will Run Automatically when any File is Saved !') elif self.auto.currentIndex() is 2: self.locator.get_service('editor').fileExecuted.connect(lambda: self.run()) QMessageBox.information(self.dock, __doc__, '<b>Now Actions will Run Automatically when any File is Executed !') elif self.auto.currentIndex() is 3: self.locator.get_service('editor').currentTabChanged.connect(lambda: self.run()) QMessageBox.information(self.dock, __doc__, '<b>Now Actions will Run Automatically when current Tab is Changed') elif self.auto.currentIndex() is 4: self.locator.get_service('editor').fileOpened.connect(lambda: self.run()) QMessageBox.information(self.dock, __doc__, '<b>Now Actions will Run Automatically when any File is Opened !') elif self.auto.currentIndex() is 5: self.locator.get_service('editor').beforeFileSaved.connect(lambda: self.run()) QMessageBox.information(self.dock, __doc__, '<b>Now Actions will Run Automatically before any File is Saved !') self.group1.setDisabled(True) def reset_options(self): ' reset the options ' self.spin1.setRange(1, 99) self.spin2.setRange(1, 99) self.spin3.setRange(1, 99) self.spin4.setRange(1, 99) self.spin5.setRange(1, 9) self.spin6.setRange(1, 999) self.spin7.setRange(1, 99) self.spin8.setRange(1, 9999) self.spin9.setRange(1, 9) self.spin10.setRange(1, 9) self.spin1.setValue(20) self.spin2.setValue(20) self.spin3.setValue(20) self.spin4.setValue(5) self.spin5.setValue(5) self.spin6.setValue(100) self.spin7.setValue(20) self.spin8.setValue(999) self.spin9.setValue(5) self.spin10.setValue(5)
class NewConfigurationDialog(QDialog): """A dialog for selecting defaults for a new configuration.""" def __init__(self, configuration_path, parent=None): QDialog.__init__(self, parent) self.setModal(True) self.setWindowTitle("New configuration file") self.setMinimumWidth(250) self.setMinimumHeight(150) layout = QFormLayout() directory, filename = os.path.split(configuration_path) if directory.strip() == "": directory = os.path.abspath(os.curdir) self.configuration_path = "%s/%s" % (directory, filename) else: self.configuration_path = configuration_path configuration_location = QLabel() configuration_location.setText(directory) configuration_name = QLabel() configuration_name.setText(filename) self.db_type = QComboBox() self.db_type.addItem("BLOCK_FS") self.db_type.addItem("PLAIN") self.first_case_name = QLineEdit() self.first_case_name.setText("default") self.connect(self.first_case_name, SIGNAL('textChanged(QString)'), self._validateName) self.num_realizations = QSpinBox() self.num_realizations.setMinimum(1) self.num_realizations.setMaximum(1000) self.num_realizations.setValue(10) self.storage_path = QLineEdit() self.storage_path.setText("Storage") self.connect(self.storage_path, SIGNAL('textChanged(QString)'), self._validateName) layout.addRow(createSpace(10)) layout.addRow("Configuration name:", configuration_name) layout.addRow("Configuration location:", configuration_location) layout.addRow("Path to store DBase:", self.storage_path) layout.addRow("DBase type:", self.db_type) layout.addRow("Name of first case:", self.first_case_name) layout.addRow("Number of realizations", self.num_realizations) layout.addRow(createSpace(10)) buttons = QDialogButtonBox( QDialogButtonBox.Ok | QDialogButtonBox.Cancel, Qt.Horizontal, self) self.ok_button = buttons.button(QDialogButtonBox.Ok) layout.addRow(buttons) self.connect(buttons, SIGNAL('accepted()'), self.accept) self.connect(buttons, SIGNAL('rejected()'), self.reject) self.setLayout(layout) def getNumberOfRealizations(self): return self.num_realizations.value() def getConfigurationPath(self): return self.configuration_path def getCaseName(self): """Return the name of the first case.""" return str(self.first_case_name.text()).strip() def getDBaseType(self): """Return the DBase type""" return str(self.db_type.currentText()) def getStoragePath(self): """Return the DBase storage path""" return str(self.storage_path.text()).strip() def _validateName(self, name): name = str(name) enabled = len(name) > 0 and name.find(" ") == -1 self.ok_button.setEnabled(enabled)
class Pressure(PluginBase): def __init__(self, *args): PluginBase.__init__(self, BrickletPressure, *args) self.p = self.device self.cbe_pressure = CallbackEmulator(self.p.get_pressure, self.cb_pressure, self.increase_error_count) self.current_pressure = None # float, kPa plots = [('Pressure', Qt.red, lambda: self.current_pressure, '{:.3f} kPa'.format)] self.plot_widget = PlotWidget('Pressure [kPa]', plots) self.combo_sensor = QComboBox() self.combo_sensor.addItem('MPX5500') self.combo_sensor.addItem('MPXV5004') self.combo_sensor.addItem('MPX4115A') self.combo_sensor.currentIndexChanged.connect( self.combo_sensor_changed) 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('Sensor Type:')) hlayout.addWidget(self.combo_sensor) hlayout.addStretch() hlayout.addWidget(QLabel('Moving Average Length:')) hlayout.addWidget(self.spin_average) 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 get_sensor_type_async(self, sensor): self.combo_sensor.setCurrentIndex(sensor) def get_moving_average_async(self, average): self.spin_average.setValue(average) def start(self): async_call(self.p.get_sensor_type, None, self.get_sensor_type_async, self.increase_error_count) async_call(self.p.get_moving_average, None, self.get_moving_average_async, self.increase_error_count) async_call(self.p.get_pressure, None, self.cb_pressure, self.increase_error_count) self.cbe_pressure.set_period(100) self.plot_widget.stop = False def stop(self): self.cbe_pressure.set_period(0) self.plot_widget.stop = True def destroy(self): pass @staticmethod def has_device_identifier(device_identifier): return device_identifier == BrickletPressure.DEVICE_IDENTIFIER def cb_pressure(self, pressure): self.current_pressure = pressure / 1000.0 def combo_sensor_changed(self): self.p.set_sensor_type(self.combo_sensor.currentIndex()) def spin_average_finished(self): self.p.set_moving_average(self.spin_average.value())
class previewDlg(QMainWindow): ''' classdocs ''' def __init__(self, parent, comp, basePMCheck, model): ''' Constructor ''' QMainWindow.__init__(self, parent) self.basePMCheck = basePMCheck # self.ui = Ui_Previewself.grbPageProperty() # self.ui.setupUi(self) self.resize(1000, 700) self.setWindowTitle("Preview Dialog") self.view = QgsComposerView(self) viewLayout = QGridLayout() viewLayout.setSpacing(0) viewLayout.setMargin(0) mHorizontalRuler = QgsComposerRuler(QgsComposerRuler.Horizontal) mVerticalRuler = QgsComposerRuler(QgsComposerRuler.Vertical) mRulerLayoutFix = QWidget() mRulerLayoutFix.setAttribute(Qt.WA_NoMousePropagation) mRulerLayoutFix.setBackgroundRole(QPalette.Window) mRulerLayoutFix.setFixedSize(mVerticalRuler.rulerSize(), mHorizontalRuler.rulerSize()) viewLayout.addWidget(mRulerLayoutFix, 0, 0) viewLayout.addWidget(mHorizontalRuler, 0, 1) viewLayout.addWidget(mVerticalRuler, 1, 0) self.view.setContentsMargins(0, 0, 0, 0) self.view.setHorizontalRuler(mHorizontalRuler) self.view.setVerticalRuler(mVerticalRuler) viewLayout.addWidget(self.view, 1, 1) # self.scene = comp self.view.setZoomLevel(1.0) self.view.setComposition(comp) self.scene = self.view.composition() layout = QVBoxLayout() hLayout = QHBoxLayout() hLayout.addLayout(viewLayout) self.mapItem = self.scene.getComposerMapById(0) self.view.scale(2.8, 2.8) self.view.setPreviewModeEnabled(True) self.toolBarAction = self.addToolBar("composer action") self.actionMapRefresh = QAction(self) self.actionMapRefresh.setObjectName("actionMapRefresh") icon3 = QIcon("Resource/Refresh.png") self.actionMapRefresh.setIcon(icon3) self.actionMapRefresh.setToolTip("Refresh") # self.textItemAction.setCheckable(True) self.connect(self.actionMapRefresh, SIGNAL("triggered()"), self.actionMapRefresh_triggered) self.toolBarAction.addAction(self.actionMapRefresh) # # self.templeteCreateAction = QAction(self) # # self.templeteCreateAction.setObjectName("createTempleteAction") # # icon4 = QIcon("Resource\\templetepointer.png") # # self.templeteCreateAction.setIcon(icon4) # # self.templeteCreateAction.setToolTip("Create Templete") # # self.templeteCreateAction.setCheckable(True) # # self.connect(self.templeteCreateAction, SIGNAL("triggered()"), self.createTempleteAction) # # self.toolBar.addAction(self.templeteCreateAction) # layout.insertWidget(0, self.toolBar) # self.scene.selectedItemChanged.connect(self.selectedItemDisplay) self.view.selectedItemChanged.connect(self.selectedItemDisplay) self.view.cursorPosChanged.connect(self.cursorPosChangedEvent) # self.connect(self.view, SIGNAL("selectedItemChanged(QgsComposerItem)"),self, SLOT("selectedItemDisplay(QgsComposerItem)")) # self.scene.composerLabelAdded.connect(self.composerLabelAddedEvent) self.view.itemRemoved.connect(self.deleteItem) # self.connect( self.view, SIGNAL( "actionFinished()" ), self.setSelectionTool) #listen out for position updates from the QgsComposerView self.propertyWidget = QWidget(self) hLayout.addWidget(self.propertyWidget) self.propertyWidget.setObjectName("propertyWidget") self.propertyWidget.resize(222, 302) self.vLayout_3 = QVBoxLayout(self.propertyWidget) self.vLayout_3.setObjectName("vLayout_3") self.groupBox = QGroupBox(self.propertyWidget) self.groupBox.setObjectName("groupBox") self.horizontalLayout_2 = QHBoxLayout(self.groupBox) self.horizontalLayout_2.setObjectName("horizontalLayout_2") self.frame = QFrame(self.groupBox) self.frame.setFrameShape(QFrame.StyledPanel) self.frame.setFrameShadow(QFrame.Raised) self.frame.setObjectName("frame") self.verticalLayout = QVBoxLayout(self.frame) self.verticalLayout.setObjectName("verticalLayout") self.label = QLabel(self.frame) self.label.setObjectName("label") self.verticalLayout.addWidget(self.label) self.labelText = QPlainTextEdit(self.frame) self.labelText.setObjectName("labelText") self.verticalLayout.addWidget(self.labelText) self.btnLabelFont = QPushButton(self.frame) self.btnLabelFont.setObjectName("btnLabelFont") self.verticalLayout.addWidget(self.btnLabelFont) self.btnLabelColor = QPushButton(self.frame) self.btnLabelColor.setObjectName("btnLabelColor") self.verticalLayout.addWidget(self.btnLabelColor) self.frame_2 = QFrame(self.frame) self.frame_2.setFrameShape(QFrame.StyledPanel) self.frame_2.setFrameShadow(QFrame.Raised) self.frame_2.setObjectName("frame_2") self.horizontalLayout = QHBoxLayout(self.frame_2) self.horizontalLayout.setObjectName("horizontalLayout") self.label_2 = QLabel(self.frame_2) self.label_2.setObjectName("label_2") self.horizontalLayout.addWidget(self.label_2) self.spinLabelRotation = QSpinBox(self.frame_2) self.spinLabelRotation.setObjectName("spinLabelRotation") self.spinLabelRotation.setMinimum(-360) self.spinLabelRotation.setMaximum(360) self.horizontalLayout.addWidget(self.spinLabelRotation) self.verticalLayout.addWidget(self.frame_2) self.chbBackgroundEnable = QCheckBox(self.frame) self.chbBackgroundEnable.setChecked(True) self.chbBackgroundEnable.setObjectName("chbBackgroundEnable") self.verticalLayout.addWidget(self.chbBackgroundEnable) self.horizontalLayout_2.addWidget(self.frame) self.vLayout_3.addWidget(self.groupBox) self.resolutionFrame = QFrame(self.frame) self.resolutionFrame.setFrameShape(QFrame.StyledPanel) self.resolutionFrame.setFrameShadow(QFrame.Raised) self.resolutionFrame.setObjectName("resolutionFrame") self.horizontalLayout4 = QHBoxLayout(self.resolutionFrame) self.horizontalLayout4.setObjectName("horizontalLayout4") self.label_resolution = QLabel(self.resolutionFrame) self.label_resolution.setObjectName("label_resolution") self.label_resolution.setText("Print Resolution (dpi):") self.horizontalLayout4.addWidget(self.label_resolution) self.spinResolution = QSpinBox(self.resolutionFrame) self.spinResolution.setObjectName("spinResolution") self.spinResolution.setMinimum(0) self.spinResolution.setMaximum(1000) self.spinResolution.setValue(300) self.horizontalLayout4.addWidget(self.spinResolution) # self.verticalLayout.addWidget(self.frame_2) self.vLayout_3.addWidget(self.resolutionFrame) self.gbTable = GroupBox(self.propertyWidget) self.gbTable.Caption = "Table" self.vLayout_3.addWidget(self.gbTable) self.mTableView = QTableView(self.gbTable) self.gbTable.Add = self.mTableView hHeder = self.mTableView.horizontalHeader() hHeder.setVisible(False) vHeder = self.mTableView.verticalHeader() vHeder.setVisible(False) # self.mTableView.setFixedHeight(70) # self.mTableView.setFixedWidth(comp.paperWidth() - 40) # self.stdItemModel = QStandardItemModel() # self. self.spaceItem = QSpacerItem(20, 40, QSizePolicy.Minimum, QSizePolicy.Expanding) self.vLayout_3.addItem(self.spaceItem) self.groupBox.setTitle("Label Property") self.label.setText("Label Text:") self.btnLabelFont.setText("Label Font") self.btnLabelColor.setText("Label Color") self.label_2.setText("Label Rotation:") self.chbBackgroundEnable.setText("Background Enable") self.groupBox.setEnabled(False) self.connect(self.btnLabelFont, SIGNAL("clicked()"), self.btnLabelFontClick) self.connect(self.btnLabelColor, SIGNAL("clicked()"), self.btnLabelColorClick) self.connect(self.chbBackgroundEnable, SIGNAL("clicked()"), self.chbBackgroundEnableClick) self.labelText.textChanged.connect(self.labelTextChanged) self.spinLabelRotation.valueChanged.connect( self.spinLabelRotationValueChanged) layout.addLayout(hLayout) # self.btnBack = QPushButton() self.btnBack.setText("back") footerLayout = QHBoxLayout() footerLayout.addWidget(self.btnBack) self.buttonBox = QDialogButtonBox(self) self.buttonBox.setOrientation(Qt.Horizontal) self.buttonBox.setStandardButtons(QDialogButtonBox.Cancel | QDialogButtonBox.Ok) self.buttonBox.setObjectName("buttonBox") footerLayout.addWidget(self.buttonBox) layout.addLayout(footerLayout) self.setLayout(layout) deleteItemKey = QShortcut(QKeySequence(Qt.Key_Delete), self) deleteItemKey.activated.connect(self.deleteItem) # self.btnBack.clicked.connect(self.back) self.connect(self.buttonBox, SIGNAL("accepted()"), self.acceptMethod) self.connect(self.buttonBox, SIGNAL("rejected()"), self.reject) self.btnCancel = self.buttonBox.button(QDialogButtonBox.Cancel) self.view.setCurrentTool(QgsComposerView.Select) self.btnLabelColor.setVisible(False) # self.btnBack.setVisible(False) self.chbBackgroundEnable.setVisible(False) # self.view.emit(SIGNAL("actionFinished")) # if self.scene.plotStyle() != QgsComposition.Preview: # self.scene.setPlotStyle(QgsComposition.Preview) # self.mapItem.setPreviewMode(QgsComposerMap.Render) # self.mapItem.updateCachedImage() # self.mapItem.setSelected(True) self.mComposition = comp self.composerMapItem = self.mComposition.composerMapItems()[0] self.composerMapItem.setUpdatesEnabled(True) self.mStdModel = model self.mTableView.setModel(self.mStdModel) self.mTableView.setSpan(0, 0, 1, 6) self.mTableView.setSpan(1, 0, 1, 2) self.mTableView.setSpan(2, 0, 2, 1) self.mTableView.setSpan(4, 0, 1, 2) self.mTableView.setSpan(5, 0, 1, 2) self.mTableView.setSpan(6, 0, 1, 2) self.mTableView.setSpan(0, 6, 1, 8) self.mTableView.setSpan(1, 7, 1, 4) self.mTableView.setSpan(1, 11, 1, 3) self.mTableView.setSpan(2, 7, 1, 4) self.mTableView.setSpan(2, 11, 1, 3) def acceptMethod(self): # self.mStdModel.setItem(0, QStandardItem("nnnnnnnn")) filePath = QFileDialog.getSaveFileName( self, "Save PDF File", QCoreApplication.applicationDirPath(), "pdf files(*.pdf )") if filePath == "": return self.mComposition.clearSelection() self.mComposition.setPrintResolution(self.spinResolution.value()) resultPdf = self.mComposition.exportAsPDF(filePath) if resultPdf: message = QMessageBox.information(self, "Result", "Successful export PDF") else: message = QMessageBox.information(self, "Result", "Don't export PDF") def rePresent(self, comp, model): self.mComposition = comp self.mStdModel = model self.view.setComposition(comp) self.scene = self.view.composition() def back(self): self.done(2) def spinLabelRotationValueChanged(self, rotationValue): self.selectedLabelItem.setItemRotation(rotationValue) def cursorPosChangedEvent(self, scenePointF): self.scenePoint = scenePointF # i = 100 def labelTextChanged(self): self.selectedLabelItem.beginCommand( "Label text changed", QgsComposerMergeCommand.ComposerLabelSetText) self.selectedLabelItem.blockSignals(True) self.selectedLabelItem.setText(self.labelText.toPlainText()) self.selectedLabelItem.update() self.selectedLabelItem.blockSignals(False) self.selectedLabelItem.endCommand() def chbBackgroundEnableClick(self): if self.chbBackgroundEnable.isChecked(): self.selectedLabelItem.setBackgroundEnabled(True) self.mapItem.updateCachedImage() else: self.selectedLabelItem.setBackgroundEnabled(False) self.mapItem.updateCachedImage() def btnLabelFontClick(self): dlgFont = QFontDialog(self) dlgFont.setCurrentFont(self.selectedLabelItem.font()) result = dlgFont.exec_() if result == 1: self.labelFont = dlgFont.selectedFont() else: self.labelFont = QFont() self.selectedLabelItem.setFont(self.labelFont) def btnLabelColorClick(self): dlgColor = QColorDialog(self) dlgColor.setCurrentColor(self.selectedLabelItem.fontColor()) result = dlgColor.exec_() if result == 1: self.labelColor = dlgColor.selectedColor() self.selectedLabelItem.setFontColor(self.labelColor) def createTempleteAction(self): if self.templeteCreateAction.isChecked() and self.basePMCheck: font = QFont("Arial", 13) font.setItalic(True) self.compLabel1 = QgsComposerLabel(self.scene) self.compLabel1.setFont(font) self.compLabel1.setText("South China Sea") self.compLabel1.setBackgroundEnabled(False) self.compLabel1.setItemPosition(156, 100) self.compLabel1.adjustSizeToText() self.compLabel1.setItemRotation(60) # mapitem = self.scene.composerMapItems() # mapitem[0].addItem(self.compLabel1) self.scene.addItem(self.compLabel1) self.compLabel2 = QgsComposerLabel(self.scene) self.compLabel2.setFont(font) self.compLabel2.setText("Straits Of Malacca") self.compLabel2.setBackgroundEnabled(False) self.compLabel2.setItemPosition(35, 100) self.compLabel2.adjustSizeToText() self.compLabel2.setItemRotation(60) self.scene.addItem(self.compLabel2) font.setItalic(False) self.compLabel3 = QgsComposerLabel(self.scene) self.compLabel3.setFont(font) self.compLabel3.setBackgroundEnabled(False) self.compLabel3.setText("THAILAND") self.compLabel3.setItemPosition(68, 60) self.compLabel3.adjustSizeToText() # self.compLabel3.setItemRotation(0.5) self.scene.addItem(self.compLabel3) # self.templeteCreateAction.setChecked(False) self.compLabel4 = QgsComposerLabel(self.scene) self.compLabel4.setFont(font) self.compLabel4.setBackgroundEnabled(False) self.compLabel4.setText("SINGAPORE") self.compLabel4.setItemPosition(141, 218) self.compLabel4.adjustSizeToText() # self.compLabel3.setItemRotation(0.5) self.scene.addItem(self.compLabel4) self.templeteCreateAction.setChecked(False) self.compLabel4.setSelected(True) elif self.templeteCreateAction.isChecked( ) and self.basePMCheck == False: font = QFont("Arial", 14) font.setItalic(True) self.compLabel5 = QgsComposerLabel(self.scene) self.compLabel5.setFont(font) self.compLabel5.setText("South China Sea") self.compLabel5.setBackgroundEnabled(False) self.compLabel5.setItemPosition(108, 86) self.compLabel5.adjustSizeToText() self.compLabel5.setItemRotation(-45) # mapitem = self.scene.composerMapItems() # mapitem[0].addItem(self.compLabel1) self.scene.addItem(self.compLabel5) self.compLabel6 = QgsComposerLabel(self.scene) self.compLabel6.setFont(font) self.compLabel6.setText("Sulu Sea") self.compLabel6.setBackgroundEnabled(False) self.compLabel6.setItemPosition(236, 38) self.compLabel6.adjustSizeToText() self.compLabel6.setItemRotation(45) self.scene.addItem(self.compLabel6) font.setItalic(False) self.compLabel7 = QgsComposerLabel(self.scene) self.compLabel7.setFont(font) self.compLabel7.setBackgroundEnabled(False) self.compLabel7.setText("Celebes Sea") self.compLabel7.setItemPosition(242, 112) self.compLabel7.adjustSizeToText() self.compLabel7.setItemRotation(-45) # self.compLabel3.setItemRotation(0.5) self.scene.addItem(self.compLabel7) # self.templeteCreateAction.setChecked(False) self.compLabel8 = QgsComposerLabel(self.scene) self.compLabel8.setFont(font) self.compLabel8.setBackgroundEnabled(False) self.compLabel8.setText("INDONESIA\n(Kalimantan)") self.compLabel8.setItemPosition(172, 148, 32, 16) # self.compLabel8.setHAlign(Qt.AlignHCenter) # self.compLabel8.setVAlign(Qt.AlignVCenter) # self.compLabel8.setFrameEnabled(False) # self.compLabel8.setItemPosition() # self.compLabel8.adjustSizeToText() # self.compLabl3.setItemRotation(0.5) self.scene.addItem(self.compLabel8) self.compLabel9 = QgsComposerLabel(self.scene) self.compLabel9.setFont(font) self.compLabel9.setBackgroundEnabled(False) self.compLabel9.setText("BRUNEI") self.compLabel9.setItemPosition(136, 83) self.compLabel9.adjustSizeToText() # self.compLabl3.setItemRotation(0.5) self.scene.addItem(self.compLabel9) self.templeteCreateAction.setChecked(False) pass def actionMapRefresh_triggered(self): self.view.setCurrentTool(QgsComposerView.AddRectangle) def setSelectionTool(self): self.view.deleteSelectedItems() font = QFont("Arial", 14) newLabelItem = QgsComposerLabel(self.scene) newLabelItem.setText("QGIS") newLabelItem.setFont(font) newLabelItem.setItemPosition(self.scenePoint.x(), self.scenePoint.y()) newLabelItem.adjustSizeToText() self.scene.addItem(newLabelItem) # selectItemPoint = self.scene.composerItemAt(self.scenePoint) newLabelItem.setSelected(True) self.groupBox.setEnabled(True) self.selectedLabelItem = newLabelItem # txt = self.selectedLabelItem.text() # textDoc = QTextDocument(txt) self.labelText.setPlainText(self.selectedLabelItem.text()) # self.scene.setSelectedItem(self.newLabelItem) self.view.setCurrentTool(QgsComposerView.Select) # self.selectedLabelItem = self.view.currentTool() self.textItemAction.setChecked(False) def selectedItemDisplay(self, item): if self.scene.plotStyle() != QgsComposition.Preview: self.scene.setPlotStyle(QgsComposition.Preview) self.mapItem.setPreviewMode(QgsComposerMap.Render) self.mapItem.updateCachedImage() item._class_ = QgsComposerLabel # selectedItems = self.scene.selectedComposerItems(True) # if isinstance(item, QgsComposerItem): # self.selectedLabelItem = item # if isinstance(item, QGraphicsRectItem): # self.selectedLabelItem = item if isinstance(item, QgsComposerLabel): self.selectedLabelItem = item self.groupBox.setEnabled(True) self.labelText.setPlainText(self.selectedLabelItem.text()) self.spinLabelRotation.setValue(self.selectedLabelItem.rotation()) else: self.groupBox.setEnabled(False) # print "debug" itemName = self.view.currentTool() if itemName == 5: item.setText("label") pass def deleteItem(self): self.view.deleteSelectedItems()
class EditorConfiguration(QWidget): """EditorConfiguration widget class""" def __init__(self, parent): super(EditorConfiguration, self).__init__() self._preferences, vbox = parent, QVBoxLayout(self) # groups group1 = QGroupBox(translations.TR_PREFERENCES_EDITOR_CONFIG_INDENT) group2 = QGroupBox(translations.TR_PREFERENCES_EDITOR_CONFIG_MARGIN) group3 = QGroupBox(translations.TR_LINT_DIRTY_TEXT) group4 = QGroupBox(translations.TR_PEP8_DIRTY_TEXT) group5 = QGroupBox(translations.TR_HIGHLIGHTER_EXTRAS) group6 = QGroupBox(translations.TR_TYPING_ASSISTANCE) group7 = QGroupBox(translations.TR_DISPLAY_ERRORS) # groups container container_widget_with_all_preferences = QWidget() formFeatures = QGridLayout(container_widget_with_all_preferences) # Indentation hboxg1 = QHBoxLayout(group1) hboxg1.setContentsMargins(5, 15, 5, 5) self._spin, self._checkUseTabs = QSpinBox(), QComboBox() self._spin.setRange(1, 10) self._spin.setValue(settings.INDENT) hboxg1.addWidget(self._spin) self._checkUseTabs.addItems([ translations.TR_PREFERENCES_EDITOR_CONFIG_SPACES.capitalize(), translations.TR_PREFERENCES_EDITOR_CONFIG_TABS.capitalize()]) self._checkUseTabs.setCurrentIndex(int(settings.USE_TABS)) hboxg1.addWidget(self._checkUseTabs) formFeatures.addWidget(group1, 0, 0) # Margin Line hboxg2 = QHBoxLayout(group2) hboxg2.setContentsMargins(5, 15, 5, 5) self._checkShowMargin = QCheckBox( translations.TR_PREFERENCES_EDITOR_CONFIG_SHOW_MARGIN_LINE) self._checkShowMargin.setChecked(settings.SHOW_MARGIN_LINE) hboxg2.addWidget(self._checkShowMargin) self._spinMargin = QSpinBox() self._spinMargin.setRange(50, 100) self._spinMargin.setSingleStep(2) self._spinMargin.setValue(settings.MARGIN_LINE) hboxg2.addWidget(self._spinMargin) hboxg2.addWidget(QLabel(translations.TR_CHARACTERS)) formFeatures.addWidget(group2, 0, 1) # Display Errors hboxDisplay = QHBoxLayout(group7) hboxDisplay.setContentsMargins(5, 15, 5, 5) self._checkHighlightLine = QComboBox() self._checkHighlightLine.addItems([ translations.TR_PREFERENCES_EDITOR_CONFIG_ERROR_USE_BACKGROUND, translations.TR_PREFERENCES_EDITOR_CONFIG_ERROR_USE_UNDERLINE]) self._checkHighlightLine.setCurrentIndex( int(settings.UNDERLINE_NOT_BACKGROUND)) hboxDisplay.addWidget(self._checkHighlightLine) formFeatures.addWidget(group7, 1, 0, 1, 0) # Find Lint Errors (highlighter) vboxg3 = QVBoxLayout(group3) self._checkErrors = QCheckBox( translations.TR_PREFERENCES_EDITOR_CONFIG_FIND_ERRORS) self._checkErrors.setChecked(settings.FIND_ERRORS) self.connect(self._checkErrors, SIGNAL("stateChanged(int)"), self._disable_show_errors) self._showErrorsOnLine = QCheckBox( translations.TR_PREFERENCES_EDITOR_CONFIG_SHOW_TOOLTIP_ERRORS) self._showErrorsOnLine.setChecked(settings.ERRORS_HIGHLIGHT_LINE) self.connect(self._showErrorsOnLine, SIGNAL("stateChanged(int)"), self._enable_errors_inline) vboxg3.addWidget(self._checkErrors) vboxg3.addWidget(self._showErrorsOnLine) formFeatures.addWidget(group3, 2, 0) # Find PEP8 Errors (highlighter) vboxg4 = QVBoxLayout(group4) vboxg4.setContentsMargins(5, 15, 5, 5) self._checkStyle = QCheckBox( translations.TR_PREFERENCES_EDITOR_CONFIG_SHOW_PEP8) self._checkStyle.setChecked(settings.CHECK_STYLE) self.connect(self._checkStyle, SIGNAL("stateChanged(int)"), self._disable_check_style) vboxg4.addWidget(self._checkStyle) self._checkStyleOnLine = QCheckBox( translations.TR_PREFERENCES_EDITOR_CONFIG_SHOW_TOOLTIP_PEP8) self._checkStyleOnLine.setChecked(settings.CHECK_HIGHLIGHT_LINE) self.connect(self._checkStyleOnLine, SIGNAL("stateChanged(int)"), self._enable_check_inline) vboxg4.addWidget(self._checkStyleOnLine) formFeatures.addWidget(group4, 2, 1) # Show Python3 Migration, DocStrings and Spaces (highlighter) vboxg5 = QVBoxLayout(group5) vboxg5.setContentsMargins(5, 15, 5, 5) self._showMigrationTips = QCheckBox( translations.TR_PREFERENCES_EDITOR_CONFIG_SHOW_MIGRATION) self._showMigrationTips.setChecked(settings.SHOW_MIGRATION_TIPS) vboxg5.addWidget(self._showMigrationTips) self._checkForDocstrings = QCheckBox( translations.TR_PREFERENCES_EDITOR_CONFIG_CHECK_FOR_DOCSTRINGS) self._checkForDocstrings.setChecked(settings.CHECK_FOR_DOCSTRINGS) vboxg5.addWidget(self._checkForDocstrings) self._checkShowSpaces = QCheckBox( translations.TR_PREFERENCES_EDITOR_CONFIG_SHOW_TABS_AND_SPACES) self._checkShowSpaces.setChecked(settings.SHOW_TABS_AND_SPACES) vboxg5.addWidget(self._checkShowSpaces) self._checkIndentationGuide = QCheckBox( translations.TR_SHOW_INDENTATION_GUIDE) self._checkIndentationGuide.setChecked(settings.SHOW_INDENTATION_GUIDE) vboxg5.addWidget(self._checkIndentationGuide) formFeatures.addWidget(group5, 3, 0) # End of line, Center On Scroll, Trailing space, Word wrap vboxg6 = QVBoxLayout(group6) vboxg6.setContentsMargins(5, 15, 5, 5) self._checkEndOfLine = QCheckBox( translations.TR_PREFERENCES_EDITOR_CONFIG_END_OF_LINE) self._checkEndOfLine.setChecked(settings.USE_PLATFORM_END_OF_LINE) vboxg6.addWidget(self._checkEndOfLine) self._checkCenterScroll = QCheckBox( translations.TR_PREFERENCES_EDITOR_CONFIG_CENTER_SCROLL) self._checkCenterScroll.setChecked(settings.CENTER_ON_SCROLL) vboxg6.addWidget(self._checkCenterScroll) self._checkTrailing = QCheckBox( translations.TR_PREFERENCES_EDITOR_CONFIG_REMOVE_TRAILING) self._checkTrailing.setChecked(settings.REMOVE_TRAILING_SPACES) vboxg6.addWidget(self._checkTrailing) self._allowWordWrap = QCheckBox( translations.TR_PREFERENCES_EDITOR_CONFIG_WORD_WRAP) self._allowWordWrap.setChecked(settings.ALLOW_WORD_WRAP) vboxg6.addWidget(self._allowWordWrap) formFeatures.addWidget(group6, 3, 1) # pack all the groups vbox.addWidget(container_widget_with_all_preferences) vbox.addItem(QSpacerItem(0, 10, QSizePolicy.Expanding, QSizePolicy.Expanding)) self.connect(self._preferences, SIGNAL("savePreferences()"), self.save) def _enable_check_inline(self, val): """Method that takes a value to enable the inline style checking""" if val == Qt.Checked: self._checkStyle.setChecked(True) def _enable_errors_inline(self, val): """Method that takes a value to enable the inline errors checking""" if val == Qt.Checked: self._checkErrors.setChecked(True) def _disable_check_style(self, val): """Method that takes a value to disable the inline style checking""" if val == Qt.Unchecked: self._checkStyleOnLine.setChecked(False) def _disable_show_errors(self, val): """Method that takes a value to disable the inline errors checking""" if val == Qt.Unchecked: self._showErrorsOnLine.setChecked(False) def save(self): """Method to save settings""" qsettings = IDE.ninja_settings() settings.USE_TABS = bool(self._checkUseTabs.currentIndex()) qsettings.setValue('preferences/editor/useTabs', settings.USE_TABS) margin_line = self._spinMargin.value() settings.MARGIN_LINE = margin_line settings.pep8mod_update_margin_line_length(margin_line) qsettings.setValue('preferences/editor/marginLine', margin_line) settings.SHOW_MARGIN_LINE = self._checkShowMargin.isChecked() qsettings.setValue('preferences/editor/showMarginLine', settings.SHOW_MARGIN_LINE) settings.INDENT = self._spin.value() qsettings.setValue('preferences/editor/indent', settings.INDENT) endOfLine = self._checkEndOfLine.isChecked() settings.USE_PLATFORM_END_OF_LINE = endOfLine qsettings.setValue('preferences/editor/platformEndOfLine', endOfLine) settings.UNDERLINE_NOT_BACKGROUND = \ bool(self._checkHighlightLine.currentIndex()) qsettings.setValue('preferences/editor/errorsUnderlineBackground', settings.UNDERLINE_NOT_BACKGROUND) settings.FIND_ERRORS = self._checkErrors.isChecked() qsettings.setValue('preferences/editor/errors', settings.FIND_ERRORS) settings.ERRORS_HIGHLIGHT_LINE = self._showErrorsOnLine.isChecked() qsettings.setValue('preferences/editor/errorsInLine', settings.ERRORS_HIGHLIGHT_LINE) settings.CHECK_STYLE = self._checkStyle.isChecked() qsettings.setValue('preferences/editor/checkStyle', settings.CHECK_STYLE) settings.SHOW_MIGRATION_TIPS = self._showMigrationTips.isChecked() qsettings.setValue('preferences/editor/showMigrationTips', settings.SHOW_MIGRATION_TIPS) settings.CHECK_HIGHLIGHT_LINE = self._checkStyleOnLine.isChecked() qsettings.setValue('preferences/editor/checkStyleInline', settings.CHECK_HIGHLIGHT_LINE) settings.CENTER_ON_SCROLL = self._checkCenterScroll.isChecked() qsettings.setValue('preferences/editor/centerOnScroll', settings.CENTER_ON_SCROLL) settings.REMOVE_TRAILING_SPACES = self._checkTrailing.isChecked() qsettings.setValue('preferences/editor/removeTrailingSpaces', settings.REMOVE_TRAILING_SPACES) settings.ALLOW_WORD_WRAP = self._allowWordWrap.isChecked() qsettings.setValue('preferences/editor/allowWordWrap', settings.ALLOW_WORD_WRAP) settings.SHOW_TABS_AND_SPACES = self._checkShowSpaces.isChecked() qsettings.setValue('preferences/editor/showTabsAndSpaces', settings.SHOW_TABS_AND_SPACES) settings.SHOW_INDENTATION_GUIDE = ( self._checkIndentationGuide.isChecked()) qsettings.setValue('preferences/editor/showIndentationGuide', settings.SHOW_INDENTATION_GUIDE) settings.CHECK_FOR_DOCSTRINGS = self._checkForDocstrings.isChecked() qsettings.setValue('preferences/editor/checkForDocstrings', settings.CHECK_FOR_DOCSTRINGS) if settings.USE_TABS: settings.pep8mod_add_ignore("W191") else: settings.pep8mod_remove_ignore("W191") settings.pep8mod_refresh_checks()
class TradingWidget(QFrame): """简单交易组件""" signal = QtCore.pyqtSignal(type(Event())) directionList = [DIRECTION_LONG, DIRECTION_SHORT] offsetList = [OFFSET_OPEN, OFFSET_CLOSE, OFFSET_CLOSEYESTERDAY, OFFSET_CLOSETODAY] priceTypeList = [PRICETYPE_LIMITPRICE, PRICETYPE_VWAP, PRICETYPE_TWAP] exchangeList = [EXCHANGE_NONE, EXCHANGE_CFFEX, EXCHANGE_SHFE, EXCHANGE_DCE, EXCHANGE_CZCE, EXCHANGE_SSE, EXCHANGE_SZSE, EXCHANGE_SGE, EXCHANGE_HKEX, EXCHANGE_CSI, EXCHANGE_HKH, EXCHANGE_HKS, EXCHANGE_JZ, EXCHANGE_SPOT, EXCHANGE_IB, EXCHANGE_FX, EXCHANGE_INE, EXCHANGE_SMART, EXCHANGE_ICE, EXCHANGE_CME, EXCHANGE_NYMEX, EXCHANGE_GLOBEX, EXCHANGE_IDEALPRO] currencyList = [CURRENCY_NONE, CURRENCY_CNY, CURRENCY_USD] productClassList = [PRODUCT_NONE, PRODUCT_EQUITY, PRODUCT_FUTURES, PRODUCT_OPTION, PRODUCT_BOND, PRODUCT_FOREX] # ---------------------------------------------------------------------- def __init__(self, mainEngine, eventEngine, parent=None): """Constructor""" super(TradingWidget, self).__init__(parent) self.mainEngine = mainEngine self.eventEngine = eventEngine self.symbol = '' self.signalemit = None self.initUi() self.connectSignal() # ---------------------------------------------------------------------- def initUi(self): """初始化界面""" self.setWindowTitle(u'交易') self.setMaximumWidth(500) self.setFrameShape(self.Box) # 设置边框 self.setLineWidth(1) # 左边部分 labelSymbol = QLabel(u'代码') labelName = QLabel(u'名称') labelDirection = QLabel(u'方向类型') labelOffset = QLabel(u'开平') labelPrice = QLabel(u'价格') labelVolume = QLabel(u'数量') labelPriceType = QLabel(u'价格类型') labelExchange = QLabel(u'交易所') labelCurrency = QLabel(u'货币') labelProductClass = QLabel(u'产品类型') labelUrgency = QLabel(u'紧急度') self.lineSymbol = QLineEdit() self.lineName = QLineEdit() self.comboDirection = QComboBox() self.comboDirection.addItems(self.directionList) self.comboOffset = QComboBox() self.comboOffset.addItem('') self.comboOffset.addItems(self.offsetList) self.comboOffset.setEnabled(False) self.tickOffset = QCheckBox(u'指定') self.spinPrice = QDoubleSpinBox() self.spinPrice.setDecimals(4) self.spinPrice.setMinimum(0) self.spinPrice.setMaximum(100000) self.spinVolume = QSpinBox() self.spinVolume.setMinimum(0) self.spinVolume.setMaximum(1000000) self.comboPriceType = QComboBox() self.comboPriceType.addItems(self.priceTypeList) self.comboExchange = QComboBox() self.comboExchange.addItems(self.exchangeList) self.comboExchange.setEnabled(False) self.comboCurrency = QComboBox() self.comboCurrency.addItems(self.currencyList) self.comboCurrency.setEnabled(False) self.comboProductClass = QComboBox() self.comboProductClass.addItems(self.productClassList) self.comboProductClass.setEnabled(False) self.spinUrgency = QSpinBox() self.spinUrgency.setMinimum(1) self.spinUrgency.setMaximum(9) self.spinUrgency.setSingleStep(1) self.spinUrgency.setValue(5) gridleft = QGridLayout() gridleft.addWidget(labelSymbol, 0, 0) gridleft.addWidget(labelName, 1, 0) gridleft.addWidget(labelDirection, 2, 0) gridleft.addWidget(labelOffset, 3, 0) gridleft.addWidget(labelPrice, 4, 0) gridleft.addWidget(labelVolume, 5, 0) gridleft.addWidget(labelPriceType, 6, 0) gridleft.addWidget(labelUrgency, 7, 0) gridleft.addWidget(labelExchange, 8, 0) gridleft.addWidget(labelProductClass, 9, 0) gridleft.addWidget(labelCurrency, 10, 0) gridleft.addWidget(self.lineSymbol, 0, 1) gridleft.addWidget(self.lineName, 1, 1) gridleft.addWidget(self.comboDirection, 2, 1) hbox1 = QHBoxLayout() hbox1.addWidget(self.comboOffset) lable1 = QLabel() hbox1.addWidget(lable1) hbox1.addWidget(self.tickOffset) hbox1.setStretchFactor(self.comboOffset, 4) hbox1.setStretchFactor(lable1, 1) hbox1.setStretchFactor(self.tickOffset, 3) gridleft.addItem(hbox1, 3, 1) gridleft.addWidget(self.spinPrice, 4, 1) gridleft.addWidget(self.spinVolume, 5, 1) gridleft.addWidget(self.comboPriceType, 6, 1) gridleft.addWidget(self.spinUrgency, 7, 1) gridleft.addWidget(self.comboExchange, 8, 1) gridleft.addWidget(self.comboProductClass, 9, 1) gridleft.addWidget(self.comboCurrency, 10, 1) # 右边部分 labelBid1 = QLabel(u'买一') labelBid2 = QLabel(u'买二') labelBid3 = QLabel(u'买三') labelBid4 = QLabel(u'买四') labelBid5 = QLabel(u'买五') labelAsk1 = QLabel(u'卖一') labelAsk2 = QLabel(u'卖二') labelAsk3 = QLabel(u'卖三') labelAsk4 = QLabel(u'卖四') labelAsk5 = QLabel(u'卖五') self.labelBidPrice1 = QLabel() self.labelBidPrice2 = QLabel() self.labelBidPrice3 = QLabel() self.labelBidPrice4 = QLabel() self.labelBidPrice5 = QLabel() self.labelBidVolume1 = QLabel() self.labelBidVolume2 = QLabel() self.labelBidVolume3 = QLabel() self.labelBidVolume4 = QLabel() self.labelBidVolume5 = QLabel() self.labelAskPrice1 = QLabel() self.labelAskPrice2 = QLabel() self.labelAskPrice3 = QLabel() self.labelAskPrice4 = QLabel() self.labelAskPrice5 = QLabel() self.labelAskVolume1 = QLabel() self.labelAskVolume2 = QLabel() self.labelAskVolume3 = QLabel() self.labelAskVolume4 = QLabel() self.labelAskVolume5 = QLabel() labelLast = QLabel(u'最新') self.labelLastPrice = QLabel() self.labelReturn = QLabel() self.labelLastPrice.setMinimumWidth(60) self.labelReturn.setMinimumWidth(60) gridRight = QGridLayout() gridRight.addWidget(labelAsk5, 0, 0) gridRight.addWidget(labelAsk4, 1, 0) gridRight.addWidget(labelAsk3, 2, 0) gridRight.addWidget(labelAsk2, 3, 0) gridRight.addWidget(labelAsk1, 4, 0) gridRight.addWidget(labelLast, 5, 0) gridRight.addWidget(labelBid1, 6, 0) gridRight.addWidget(labelBid2, 7, 0) gridRight.addWidget(labelBid3, 8, 0) gridRight.addWidget(labelBid4, 9, 0) gridRight.addWidget(labelBid5, 10, 0) gridRight.addWidget(self.labelAskPrice5, 0, 1) gridRight.addWidget(self.labelAskPrice4, 1, 1) gridRight.addWidget(self.labelAskPrice3, 2, 1) gridRight.addWidget(self.labelAskPrice2, 3, 1) gridRight.addWidget(self.labelAskPrice1, 4, 1) gridRight.addWidget(self.labelLastPrice, 5, 1) gridRight.addWidget(self.labelBidPrice1, 6, 1) gridRight.addWidget(self.labelBidPrice2, 7, 1) gridRight.addWidget(self.labelBidPrice3, 8, 1) gridRight.addWidget(self.labelBidPrice4, 9, 1) gridRight.addWidget(self.labelBidPrice5, 10, 1) gridRight.addWidget(self.labelAskVolume5, 0, 2) gridRight.addWidget(self.labelAskVolume4, 1, 2) gridRight.addWidget(self.labelAskVolume3, 2, 2) gridRight.addWidget(self.labelAskVolume2, 3, 2) gridRight.addWidget(self.labelAskVolume1, 4, 2) gridRight.addWidget(self.labelReturn, 5, 2) gridRight.addWidget(self.labelBidVolume1, 6, 2) gridRight.addWidget(self.labelBidVolume2, 7, 2) gridRight.addWidget(self.labelBidVolume3, 8, 2) gridRight.addWidget(self.labelBidVolume4, 9, 2) gridRight.addWidget(self.labelBidVolume5, 10, 2) # 发单按钮 buttonSendOrder = QPushButton(u'发单') buttonCancelAll = QPushButton(u'全撤') size = buttonSendOrder.sizeHint() buttonSendOrder.setMinimumHeight(size.height() * 2) # 把按钮高度设为默认两倍 buttonCancelAll.setMinimumHeight(size.height() * 2) # 整合布局 hbox = QHBoxLayout() hbox.addLayout(gridleft) hbox.addLayout(gridRight) vbox = QVBoxLayout() vbox.addLayout(hbox) vbox.addWidget(buttonSendOrder) vbox.addWidget(buttonCancelAll) vbox.addStretch() self.setLayout(vbox) # 关联更新 buttonSendOrder.clicked.connect(self.sendOrder) buttonCancelAll.clicked.connect(self.cancelAll) self.lineSymbol.returnPressed.connect(self.updateSymbol) self.comboDirection.currentIndexChanged.connect(self.updateOffset) self.tickOffset.stateChanged.connect(self.updateOffset) self.labelAskPrice1.mouseDoubleClickEvent = self.ask1clicked self.labelAskPrice2.mouseDoubleClickEvent = self.ask2clicked self.labelAskPrice3.mouseDoubleClickEvent = self.ask3clicked self.labelAskPrice4.mouseDoubleClickEvent = self.ask4clicked self.labelAskPrice5.mouseDoubleClickEvent = self.ask5clicked self.labelBidPrice1.mouseDoubleClickEvent = self.bid1clicked self.labelBidPrice2.mouseDoubleClickEvent = self.bid2clicked self.labelBidPrice3.mouseDoubleClickEvent = self.bid3clicked self.labelBidPrice4.mouseDoubleClickEvent = self.bid4clicked self.labelBidPrice5.mouseDoubleClickEvent = self.bid5clicked self.labelLastPrice.mouseDoubleClickEvent = self.lastclicked def ask1clicked(self, a): self.askclicked(self.labelAskPrice1.text()) def ask2clicked(self, a): self.askclicked(self.labelAskPrice2.text()) def ask3clicked(self, a): self.askclicked(self.labelAskPrice3.text()) def ask4clicked(self, a): self.askclicked(self.labelAskPrice4.text()) def ask5clicked(self, a): self.askclicked(self.labelAskPrice5.text()) def bid1clicked(self, a): self.bidclicked(self.labelBidPrice1.text()) def bid2clicked(self, a): self.bidclicked(self.labelBidPrice2.text()) def bid3clicked(self, a): self.bidclicked(self.labelBidPrice3.text()) def bid4clicked(self, a): self.bidclicked(self.labelBidPrice4.text()) def bid5clicked(self, a): self.bidclicked(self.labelBidPrice5.text()) def lastclicked(self, a): self.setPrice(self.labelLastPrice.text()) def setPrice(self, text): result = False if text is not None and len(text) > 0: price = float(str(text)) if price > 0: self.spinPrice.setValue(price) result = True return result def askclicked(self, text): if self.setPrice(text): self.comboDirection.setCurrentIndex(self.directionList.index(DIRECTION_LONG)) self.updateOffset() def bidclicked(self, text): if self.setPrice(text): self.comboDirection.setCurrentIndex(self.directionList.index(DIRECTION_SHORT)) self.updateOffset() def updateOffset(self): if self.tickOffset.checkState(): self.comboOffset.setEnabled(True) if self.comboProductClass.currentText() in (PRODUCT_EQUITY, PRODUCT_BOND): dir = self.comboDirection.currentText() if dir == DIRECTION_LONG: self.comboOffset.setCurrentIndex(self.offsetList.index(OFFSET_OPEN) + 1) elif dir == DIRECTION_SHORT: self.comboOffset.setCurrentIndex(self.offsetList.index(OFFSET_CLOSE) + 1) elif self.comboOffset.currentIndex() == 0: self.comboOffset.setCurrentIndex(1) else: self.comboOffset.setEnabled(False) self.comboOffset.setCurrentIndex(0) # ---------------------------------------------------------------------- def updateSymbol(self): """合约变化""" # 读取组件数据 symbol = str(self.lineSymbol.text()) self.comboCurrency.setCurrentIndex(1) currency = safeUnicode(self.comboCurrency.currentText()) gatewayName = safeUnicode('quantos') # 查询合约 contract = self.mainEngine.getContract(symbol) # 清空价格数量 self.spinPrice.setValue(0) self.spinVolume.setValue(0) if contract: gatewayName = contract.gatewayName self.lineName.setText(contract.name) p = self.lineName.palette() p.setColor(self.lineName.foregroundRole(), QtGui.QColor('black')) self.lineName.setPalette(p) exchange = contract.exchange productClass = contract.productClass self.comboExchange.setCurrentIndex(self.exchangeList.index(exchange)) self.comboProductClass.setCurrentIndex(self.productClassList.index(productClass)) self.spinPrice.setSingleStep(contract.priceTick) self.spinVolume.setSingleStep(contract.lotsize) self.updateOffset() else: self.comboExchange.setCurrentIndex(0) self.comboProductClass.setCurrentIndex(0) productClass = safeUnicode(self.comboProductClass.currentText()) exchange = safeUnicode(self.comboExchange.currentText()) self.lineName.setText(u'不存在') p = self.lineName.palette() p.setColor(self.lineName.foregroundRole(), QtGui.QColor('red')) self.lineName.setPalette(p) # 清空行情显示 self.labelBidPrice1.setText('') self.labelBidPrice2.setText('') self.labelBidPrice3.setText('') self.labelBidPrice4.setText('') self.labelBidPrice5.setText('') self.labelBidVolume1.setText('') self.labelBidVolume2.setText('') self.labelBidVolume3.setText('') self.labelBidVolume4.setText('') self.labelBidVolume5.setText('') self.labelAskPrice1.setText('') self.labelAskPrice2.setText('') self.labelAskPrice3.setText('') self.labelAskPrice4.setText('') self.labelAskPrice5.setText('') self.labelAskVolume1.setText('') self.labelAskVolume2.setText('') self.labelAskVolume3.setText('') self.labelAskVolume4.setText('') self.labelAskVolume5.setText('') self.labelLastPrice.setText('') self.labelReturn.setText('') if contract: # 重新注册事件监听 if self.signalemit != None: self.eventEngine.unregister(EVENT_TICK + self.symbol, self.signalemit) self.signalemit = self.signal.emit self.eventEngine.register(EVENT_TICK + symbol, self.signalemit) # 订阅合约 self.mainEngine.subscribe(contract.symbol, gatewayName) # 更新组件当前交易的合约 self.symbol = symbol # ---------------------------------------------------------------------- def format_price(self, price): return int(price * 1000) / 1000 # ---------------------------------------------------------------------- def updateTick(self, event): """更新行情""" tick = event.dict_['data'] if tick.symbol == self.symbol: contract = self.mainEngine.getContract(tick.symbol) price_tick = contract.priceTick self.labelBidPrice1.setText(str(self.format_price(tick.bidPrice1))) self.labelAskPrice1.setText(str(self.format_price(tick.askPrice1))) self.labelBidVolume1.setText(str(tick.bidVolume1)) self.labelAskVolume1.setText(str(tick.askVolume1)) if tick.bidPrice2: self.labelBidPrice2.setText(str(self.format_price(tick.bidPrice2))) self.labelBidPrice3.setText(str(self.format_price(tick.bidPrice3))) self.labelBidPrice4.setText(str(self.format_price(tick.bidPrice4))) self.labelBidPrice5.setText(str(self.format_price(tick.bidPrice5))) self.labelAskPrice2.setText(str(self.format_price(tick.askPrice2))) self.labelAskPrice3.setText(str(self.format_price(tick.askPrice3))) self.labelAskPrice4.setText(str(self.format_price(tick.askPrice4))) self.labelAskPrice5.setText(str(self.format_price(tick.askPrice5))) self.labelBidVolume2.setText(str(tick.bidVolume2)) self.labelBidVolume3.setText(str(tick.bidVolume3)) self.labelBidVolume4.setText(str(tick.bidVolume4)) self.labelBidVolume5.setText(str(tick.bidVolume5)) self.labelAskVolume2.setText(str(tick.askVolume2)) self.labelAskVolume3.setText(str(tick.askVolume3)) self.labelAskVolume4.setText(str(tick.askVolume4)) self.labelAskVolume5.setText(str(tick.askVolume5)) self.labelLastPrice.setText(str(self.format_price(tick.lastPrice))) if self.spinPrice.value() < 0.000001 and tick.lastPrice > 0.000001: self.spinPrice.setValue(tick.lastPrice) if tick.preClosePrice: rt = (old_div(tick.lastPrice, tick.preClosePrice)) - 1 self.labelReturn.setText(('%.2f' % (rt * 100)) + '%') else: self.labelReturn.setText('') # ---------------------------------------------------------------------- def connectSignal(self): """连接Signal""" self.signal.connect(self.updateTick) # ---------------------------------------------------------------------- def sendOrder(self): """发单""" symbol = str(self.lineSymbol.text()).strip() exchange = safeUnicode(self.comboExchange.currentText()) price = self.spinPrice.value() volume = self.spinVolume.value() gatewayName = safeUnicode('quantos') if len(symbol) <= 0 or len(exchange) <= 0 or price <= 0 or volume <= 0: return # 查询合约 contract = self.mainEngine.getContract(symbol) if contract: gatewayName = contract.gatewayName exchange = contract.exchange # 保证有交易所代码 req = VtOrderReq() idx = symbol.find(".") if idx != -1: req.symbol = symbol[0:idx] else: req.symbol = symbol req.exchange = exchange req.price = price req.volume = volume req.direction = safeUnicode(self.comboDirection.currentText()) req.priceType = safeUnicode(self.comboPriceType.currentText()) req.offset = safeUnicode(self.comboOffset.currentText()) req.urgency = self.spinUrgency.value() req.productClass = safeUnicode(self.comboProductClass.currentText()) self.mainEngine.sendOrder(req, gatewayName) # ---------------------------------------------------------------------- def cancelAll(self): """一键撤销所有委托""" l = self.mainEngine.getAllWorkingOrders() for order in l: req = VtCancelOrderReq() req.symbol = order.symbol req.exchange = order.exchange req.frontID = order.frontID req.sessionID = order.sessionID req.orderID = order.taskID self.mainEngine.cancelOrder(req, order.gatewayName) # ---------------------------------------------------------------------- def closePosition(self, cell): """根据持仓信息自动填写交易组件""" # 读取持仓数据,cell是一个表格中的单元格对象 pos = cell.data symbol = pos.symbol # 更新交易组件的显示合约 self.lineSymbol.setText(symbol) self.updateSymbol() # 自动填写信息 self.comboPriceType.setCurrentIndex(self.priceTypeList.index(PRICETYPE_LIMITPRICE)) self.spinVolume.setValue(pos.enable) if pos.direction == DIRECTION_LONG or pos.direction == DIRECTION_NET: self.comboDirection.setCurrentIndex(self.directionList.index(DIRECTION_SHORT)) else: self.comboDirection.setCurrentIndex(self.directionList.index(DIRECTION_LONG)) if self.comboProductClass.currentText() not in (PRODUCT_EQUITY, PRODUCT_BOND): self.tickOffset.setChecked(True) self.comboOffset.setCurrentIndex(self.offsetList.index(OFFSET_CLOSE) + 1) elif self.tickOffset.checkState(): self.comboOffset.setCurrentIndex(self.offsetList.index(OFFSET_CLOSE) + 1) # 价格留待更新后由用户输入,防止有误操作 def fillSymbol(self, cell): tick = cell.data self.lineSymbol.setText(tick.symbol) self.updateSymbol() if type(cell) in (BidCell, AskCell): price = str(cell.text()) if len(price) > 0: price = float(price) if price > 0: self.spinPrice.setValue(price) direction = DIRECTION_LONG if type(cell) is AskCell else DIRECTION_SHORT self.comboDirection.setCurrentIndex(self.directionList.index(direction)) self.updateOffset()
class AnalogInV2(PluginBase): 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 get_moving_average_async(self, average): self.spin_average.setValue(average) def start(self): async_call(self.ai.get_moving_average, None, self.get_moving_average_async, self.increase_error_count) async_call(self.ai.get_voltage, None, self.cb_voltage, self.increase_error_count) self.cbe_voltage.set_period(100) self.plot_widget.stop = False def stop(self): self.cbe_voltage.set_period(0) self.plot_widget.stop = True def destroy(self): pass @staticmethod def has_device_identifier(device_identifier): return device_identifier == BrickletAnalogInV2.DEVICE_IDENTIFIER def cb_voltage(self, voltage): self.current_voltage = voltage / 1000.0 def spin_average_finished(self): self.ai.set_moving_average(self.spin_average.value())
class EditorGeneral(QWidget): """EditorGeneral widget class.""" def __init__(self, parent): super(EditorGeneral, self).__init__() self._preferences, vbox = parent, QVBoxLayout(self) self.original_style = copy.copy(resources.CUSTOM_SCHEME) self.current_scheme, self._modified_editors = 'default', [] self._font = settings.FONT groupBoxMini = QGroupBox( translations.TR_PREFERENCES_EDITOR_GENERAL_MINIMAP) groupBoxTypo = QGroupBox( translations.TR_PREFERENCES_EDITOR_GENERAL_TYPOGRAPHY) groupBoxScheme = QGroupBox( translations.TR_PREFERENCES_EDITOR_GENERAL_SCHEME) #Minimap formMini = QGridLayout(groupBoxMini) formMini.setContentsMargins(5, 15, 5, 5) self._checkShowMinimap = QCheckBox( translations.TR_PREFERENCES_EDITOR_GENERAL_ENABLE_MINIMAP) self._spinMaxOpacity = QSpinBox() self._spinMaxOpacity.setRange(0, 100) self._spinMaxOpacity.setSuffix("% Max.") self._spinMinOpacity = QSpinBox() self._spinMinOpacity.setRange(0, 100) self._spinMinOpacity.setSuffix("% Min.") self._spinSize = QSpinBox() self._spinSize.setMaximum(100) self._spinSize.setMinimum(0) self._spinSize.setSuffix( translations.TR_PREFERENCES_EDITOR_GENERAL_AREA_MINIMAP) formMini.addWidget(self._checkShowMinimap, 0, 1) formMini.addWidget(QLabel( translations.TR_PREFERENCES_EDITOR_GENERAL_SIZE_MINIMAP), 1, 0, Qt.AlignRight) formMini.addWidget(self._spinSize, 1, 1) formMini.addWidget(QLabel( translations.TR_PREFERENCES_EDITOR_GENERAL_OPACITY), 2, 0, Qt.AlignRight) formMini.addWidget(self._spinMinOpacity, 2, 1) formMini.addWidget(self._spinMaxOpacity, 2, 2) #Typo gridTypo = QGridLayout(groupBoxTypo) gridTypo.setContentsMargins(5, 15, 5, 5) self._btnEditorFont = QPushButton('') gridTypo.addWidget(QLabel( translations.TR_PREFERENCES_EDITOR_GENERAL_EDITOR_FONT), 0, 0, Qt.AlignRight) gridTypo.addWidget(self._btnEditorFont, 0, 1) #Scheme vboxScheme = QVBoxLayout(groupBoxScheme) vboxScheme.setContentsMargins(5, 15, 5, 5) self._listScheme = QListWidget() vboxScheme.addWidget(self._listScheme) hbox = QHBoxLayout() btnDownload = QPushButton( translations.TR_PREFERENCES_EDITOR_DOWNLOAD_SCHEME) btnDownload.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed) self.connect(btnDownload, SIGNAL("clicked()"), self._open_schemes_manager) hbox.addWidget(btnDownload) btnAdd = QPushButton(QIcon(":img/add"), translations.TR_EDITOR_CREATE_SCHEME) btnAdd.setIconSize(QSize(16, 16)) btnAdd.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed) self.connect(btnAdd, SIGNAL("clicked()"), self._open_schemes_designer) btnRemove = QPushButton(QIcon(":img/delete"), translations.TR_EDITOR_REMOVE_SCHEME) btnRemove.setIconSize(QSize(16, 16)) btnRemove.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed) self.connect(btnRemove, SIGNAL("clicked()"), self._remove_scheme) hbox.addSpacerItem(QSpacerItem(1, 0, QSizePolicy.Expanding)) hbox.addWidget(btnAdd) hbox.addWidget(btnRemove) vboxScheme.addLayout(hbox) vbox.addWidget(groupBoxMini) vbox.addWidget(groupBoxTypo) vbox.addWidget(groupBoxScheme) #Settings qsettings = IDE.ninja_settings() qsettings.beginGroup('preferences') qsettings.beginGroup('editor') self._checkShowMinimap.setChecked(settings.SHOW_MINIMAP) if settings.IS_MAC_OS: self._spinMinOpacity.setValue(100) self._spinMaxOpacity.setValue(100) self._spinMinOpacity.setDisabled(True) self._spinMaxOpacity.setDisabled(True) else: self._spinMinOpacity.setValue(settings.MINIMAP_MIN_OPACITY * 100) self._spinMaxOpacity.setValue(settings.MINIMAP_MAX_OPACITY * 100) self._spinSize.setValue(settings.SIZE_PROPORTION * 100) btnText = ', '.join(self._font.toString().split(',')[0:2]) self._btnEditorFont.setText(btnText) self._listScheme.clear() self._listScheme.addItem('default') self._schemes = json_manager.load_editor_skins() for item in self._schemes: self._listScheme.addItem(item) items = self._listScheme.findItems( qsettings.value('scheme', defaultValue='', type='QString'), Qt.MatchExactly) if items: self._listScheme.setCurrentItem(items[0]) else: self._listScheme.setCurrentRow(0) qsettings.endGroup() qsettings.endGroup() #Signals self.connect(self._btnEditorFont, SIGNAL("clicked()"), self._load_editor_font) self.connect(self._listScheme, SIGNAL("itemSelectionChanged()"), self._preview_style) self.connect(self._preferences, SIGNAL("savePreferences()"), self.save) def _open_schemes_manager(self): ninjaide = IDE.get_service("ide") ninjaide.show_schemes() # refresh schemes def _open_schemes_designer(self): name = self._listScheme.currentItem().text() scheme = self._schemes.get(name, resources.COLOR_SCHEME) designer = preferences_editor_scheme_designer.EditorSchemeDesigner( scheme, self) designer.exec_() if designer.saved: scheme_name = designer.line_name.text() scheme = designer.original_style self._schemes[scheme_name] = scheme result = self._listScheme.findItems(scheme_name, Qt.MatchExactly) if not result: self._listScheme.addItem(scheme_name) def _remove_scheme(self): name = self._listScheme.currentItem().text() fileName = ('{0}.color'.format( file_manager.create_path(resources.EDITOR_SKINS, name))) file_manager.delete_file(fileName) item = self._listScheme.takeItem(self._listScheme.currentRow()) del item def hideEvent(self, event): super(EditorGeneral, self).hideEvent(event) resources.CUSTOM_SCHEME = self.original_style for editorWidget in self._modified_editors: try: editorWidget.restyle(editorWidget.lang) except RuntimeError: print('the editor has been removed') def _preview_style(self): scheme = self._listScheme.currentItem().text() if scheme == self.current_scheme: return main_container = IDE.get_service('main_container') if not main_container: return editorWidget = main_container.get_current_editor() if editorWidget is not None: resources.CUSTOM_SCHEME = self._schemes.get( scheme, resources.COLOR_SCHEME) editorWidget.restyle(editorWidget.lang) self._modified_editors.append(editorWidget) self.current_scheme = scheme def _load_editor_font(self): try: font, ok = QFontDialog.getFont(self._font, self) if ok: self._font = font btnText = ', '.join(self._font.toString().split(',')[0:2]) self._btnEditorFont.setText(btnText) except: QMessageBox.warning( self, translations.TR_PREFERENCES_EDITOR_GENERAL_FONT_MESSAGE_TITLE, translations.TR_PREFERENCES_EDITOR_GENERAL_FONT_MESSAGE_BODY) def save(self): qsettings = IDE.ninja_settings() settings.FONT = self._font qsettings.setValue('preferences/editor/font', settings.FONT) settings.SHOW_MINIMAP = self._checkShowMinimap.isChecked() settings.MINIMAP_MAX_OPACITY = self._spinMaxOpacity.value() / 100.0 settings.MINIMAP_MIN_OPACITY = self._spinMinOpacity.value() / 100.0 settings.SIZE_PROPORTION = self._spinSize.value() / 100.0 qsettings.setValue('preferences/editor/minimapMaxOpacity', settings.MINIMAP_MAX_OPACITY) qsettings.setValue('preferences/editor/minimapMinOpacity', settings.MINIMAP_MIN_OPACITY) qsettings.setValue('preferences/editor/minimapSizeProportion', settings.SIZE_PROPORTION) qsettings.setValue('preferences/editor/minimapShow', settings.SHOW_MINIMAP) scheme = self._listScheme.currentItem().text() resources.CUSTOM_SCHEME = self._schemes.get(scheme, resources.COLOR_SCHEME) qsettings.setValue('preferences/editor/scheme', scheme)
class LoadCell(PluginBase): def __init__(self, *args): PluginBase.__init__(self, BrickletLoadCell, *args) self.lc = self.device self.cbe_weight = CallbackEmulator(self.lc.get_weight, self.cb_weight, self.increase_error_count) self.gain = 0 # 128x self.current_weight = None # int, g self.calibration = None plots = [('Weight', Qt.red, lambda: self.current_weight, format_weight) ] self.plot_widget = PlotWidget('Weight [g]', plots) self.button_calibration = QPushButton("Calibration...") self.button_calibration.clicked.connect( self.button_calibration_clicked) self.button_tare = QPushButton("Tare") self.button_tare.clicked.connect(self.button_tare_clicked) self.enable_led = QCheckBox("Enable LED") self.enable_led.stateChanged.connect(self.enable_led_changed) self.spin_average = QSpinBox() self.spin_average.setMinimum(0) self.spin_average.setMaximum(40) self.spin_average.setSingleStep(1) self.spin_average.setValue(5) self.spin_average.editingFinished.connect(self.spin_average_finished) self.label_average = QLabel('Moving Average Length:') self.rate_label = QLabel('Rate:') self.rate_combo = QComboBox() self.rate_combo.addItem("10 Hz") self.rate_combo.addItem("80 Hz") self.rate_combo.currentIndexChanged.connect(self.new_config) hlayout = QHBoxLayout() hlayout.addWidget(self.label_average) hlayout.addWidget(self.spin_average) hlayout.addWidget(self.rate_label) hlayout.addWidget(self.rate_combo) hlayout.addStretch() hlayout.addWidget(self.button_calibration) hlayout.addWidget(self.button_tare) hlayout.addWidget(self.enable_led) 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 start(self): async_call(self.lc.is_led_on, None, self.is_led_on_async, self.increase_error_count) async_call(self.lc.get_configuration, None, self.get_configuration_async, self.increase_error_count) async_call(self.lc.get_moving_average, None, self.get_moving_average_async, self.increase_error_count) async_call(self.lc.get_weight, None, self.cb_weight, self.increase_error_count) self.cbe_weight.set_period(100) self.plot_widget.stop = False def stop(self): self.cbe_weight.set_period(0) self.plot_widget.stop = True def destroy(self): if self.calibration: self.calibration.close() @staticmethod def has_device_identifier(device_identifier): return device_identifier == BrickletLoadCell.DEVICE_IDENTIFIER def get_moving_average_async(self, avg): self.spin_average.setValue(avg) def get_configuration_async(self, conf): self.gain = conf.gain self.rate_combo.setCurrentIndex(conf.rate) def is_led_on_async(self, value): if value: self.enable_led.setChecked(True) else: self.enable_led.setChecked(False) def button_calibration_clicked(self): if self.calibration is None: self.calibration = Calibration(self) self.button_calibration.setEnabled(False) self.calibration.show() def button_tare_clicked(self): self.lc.tare() def enable_led_changed(self, state): if state == Qt.Checked: self.lc.led_on() else: self.lc.led_off() def new_config(self, value): rate = self.rate_combo.currentIndex() self.lc.set_configuration(rate, self.gain) def spin_average_finished(self): self.lc.set_moving_average(self.spin_average.value()) def cb_weight(self, weight): self.current_weight = weight
class YPipeWidget(QWidget): def __init__(self, leftFlow=0, rightFlow=0, maxFlow=100, parent=None): super(YPipeWidget, self).__init__(parent) self.leftSpinBox = QSpinBox(self) self.leftSpinBox.setRange(0, maxFlow) self.leftSpinBox.setValue(leftFlow) self.leftSpinBox.setSuffix(" l/s") self.leftSpinBox.setAlignment(Qt.AlignRight | Qt.AlignVCenter) self.connect(self.leftSpinBox, SIGNAL("valueChanged(int)"), self.valueChanged) self.rightSpinBox = QSpinBox(self) self.rightSpinBox.setRange(0, maxFlow) self.rightSpinBox.setValue(rightFlow) self.rightSpinBox.setSuffix(" l/s") self.rightSpinBox.setAlignment(Qt.AlignRight | Qt.AlignVCenter) self.connect(self.rightSpinBox, SIGNAL("valueChanged(int)"), self.valueChanged) self.label = QLabel(self) self.label.setFrameStyle(QFrame.StyledPanel | QFrame.Sunken) self.label.setAlignment(Qt.AlignCenter) fm = QFontMetricsF(self.font()) self.label.setMinimumWidth(fm.width(" 999 l/s ")) self.setSizePolicy( QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)) self.setMinimumSize(self.minimumSizeHint()) self.valueChanged() def valueChanged(self): a = self.leftSpinBox.value() b = self.rightSpinBox.value() self.label.setText("{0} l/s".format(a + b)) self.emit(SIGNAL("valueChanged"), a, b) self.update() def values(self): return self.leftSpinBox.value(), self.rightSpinBox.value() def minimumSizeHint(self): return QSize(self.leftSpinBox.width() * 3, self.leftSpinBox.height() * 5) def resizeEvent(self, event=None): fm = QFontMetricsF(self.font()) x = (self.width() - self.label.width()) / 2 y = self.height() - (fm.height() * 1.5) self.label.move(x, y) y = self.height() / 60.0 x = (self.width() / 4.0) - self.leftSpinBox.width() self.leftSpinBox.move(x, y) x = self.width() - (self.width() / 4.0) self.rightSpinBox.move(x, y) def paintEvent(self, event=None): LogicalSize = 100.0 def logicalFromPhysical(length, side): return (length / side) * LogicalSize fm = QFontMetricsF(self.font()) ymargin = ( (LogicalSize / 30.0) + logicalFromPhysical(self.leftSpinBox.height(), self.height())) ymax = (LogicalSize - logicalFromPhysical(fm.height() * 2, self.height())) width = LogicalSize / 4.0 cx, cy = LogicalSize / 2.0, LogicalSize / 3.0 ax, ay = cx - (2 * width), ymargin bx, by = cx - width, ay dx, dy = cx + width, ay ex, ey = cx + (2 * width), ymargin fx, fy = cx + (width / 2), cx + (LogicalSize / 24.0) gx, gy = fx, ymax hx, hy = cx - (width / 2), ymax ix, iy = hx, fy painter = QPainter(self) painter.setRenderHint(QPainter.Antialiasing) side = min(self.width(), self.height()) painter.setViewport((self.width() - side) / 2, (self.height() - side) / 2, side, side) painter.setWindow(0, 0, LogicalSize, LogicalSize) painter.setPen(Qt.NoPen) gradient = QLinearGradient(QPointF(0, 0), QPointF(0, 100)) gradient.setColorAt(0, Qt.white) a = self.leftSpinBox.value() gradient.setColorAt(1, (Qt.red if a != 0 else Qt.white)) painter.setBrush(QBrush(gradient)) painter.drawPolygon(QPolygon([ax, ay, bx, by, cx, cy, ix, iy])) gradient = QLinearGradient(QPointF(0, 0), QPointF(0, 100)) gradient.setColorAt(0, Qt.white) b = self.rightSpinBox.value() gradient.setColorAt(1, (Qt.blue if b != 0 else Qt.white)) painter.setBrush(QBrush(gradient)) painter.drawPolygon(QPolygon([cx, cy, dx, dy, ex, ey, fx, fy])) if (a + b) == 0: color = QColor(Qt.white) else: ashare = (a / (a + b)) * 255.0 bshare = 255.0 - ashare color = QColor(ashare, 0, bshare) gradient = QLinearGradient(QPointF(0, 0), QPointF(0, 100)) gradient.setColorAt(0, Qt.white) gradient.setColorAt(1, color) painter.setBrush(QBrush(gradient)) painter.drawPolygon(QPolygon([cx, cy, fx, fy, gx, gy, hx, hy, ix, iy])) painter.setPen(Qt.black) painter.drawPolyline(QPolygon([ax, ay, ix, iy, hx, hy])) painter.drawPolyline(QPolygon([gx, gy, fx, fy, ex, ey])) painter.drawPolyline(QPolygon([bx, by, cx, cy, dx, dy]))