class SpinBoxPySignal(UsesQApplication): """Tests the connection of python signals to QSpinBox qt slots.""" def setUp(self): super(SpinBoxPySignal, self).setUp() self.obj = Dummy() self.spin = QSpinBox() self.spin.setValue(0) def tearDown(self): super(SpinBoxPySignal, self).tearDown() del self.obj del self.spin def testValueChanged(self): """Emission of a python signal to QSpinBox setValue(int)""" QObject.connect(self.obj, SIGNAL('dummy(int)'), self.spin, SLOT('setValue(int)')) self.assertEqual(self.spin.value(), 0) self.obj.emit(SIGNAL('dummy(int)'), 4) self.assertEqual(self.spin.value(), 4) def testValueChangedMultiple(self): """Multiple emissions of a python signal to QSpinBox setValue(int)""" QObject.connect(self.obj, SIGNAL('dummy(int)'), self.spin, SLOT('setValue(int)')) self.assertEqual(self.spin.value(), 0) self.obj.emit(SIGNAL('dummy(int)'), 4) self.assertEqual(self.spin.value(), 4) self.obj.emit(SIGNAL('dummy(int)'), 77) self.assertEqual(self.spin.value(), 77)
def testSetValueIndirect(self): """Indirect signal emission: QSpinBox using valueChanged(int)/setValue(int)""" spinSend = QSpinBox() spinRec = QSpinBox() spinRec.setValue(5) QObject.connect(spinSend, SIGNAL('valueChanged(int)'), spinRec, SLOT('setValue(int)')) self.assertEqual(spinRec.value(), 5) spinSend.setValue(3) self.assertEqual(spinRec.value(), 3) self.assertEqual(spinSend.value(), 3)
def testSetValueIndirect(self): """Indirect signal emission: QSpinBox using valueChanged(int)/setValue(int)""" spinSend = QSpinBox() spinRec = QSpinBox() spinRec.setValue(5) QObject.connect(spinSend, SIGNAL('valueChanged(int)'), spinRec, SLOT('setValue(int)')) self.assertEqual(spinRec.value(), 5) spinSend.setValue(3) self.assertEqual(spinRec.value(), 3) self.assertEqual(spinSend.value(), 3)
class CreateSamplesRow(): def __init__(self): self.plate = QLineEdit() self.parents = QSpinBox() self.samples = QSpinBox() self.loadedBy = QComboBox() self.parents.setMaximum(8) self.parents.setValue(2) self.samples.setMaximum(96) self.samples.setValue(94) self.loadedBy.addItems(['Column','Row']) def getPlate(self): return self.plate.text() def getParents(self): return self.parents.value() def getSamples(self): return self.samples.value() def getLoadedBy(self): return self.loadedBy.currentText()
class AddWindow(QDialog): def __init__(self, parent=None): super(AddWindow, self).__init__(parent) self.setGeometry(QtCore.QRect(110, 40, 171, 160)) def initUi(self): self.grid = QGridLayout() self.grid.addWidget(QLabel("Connection name"), 0, 0) self.grid.addWidget(QLabel("Username"), 2, 0) self.grid.addWidget(QLabel("Password"), 4, 0) self.grid.addWidget(QLabel("Hostname"), 6, 0) self.grid.addWidget(QLabel("Port"), 8, 0) self.connectionNameInput = QLineEdit(self) self.grid.addWidget(self.connectionNameInput, 1, 0) self.userNameInput = QLineEdit(self) self.grid.addWidget(self.userNameInput, 3, 0) self.passwordInput = QLineEdit(self) self.grid.addWidget(self.passwordInput, 5, 0) self.hostnameInput = QLineEdit(self) self.grid.addWidget(self.hostnameInput, 7, 0) self.portSpinBox = QSpinBox(self) self.portSpinBox.setMinimum(1) self.portSpinBox.setMaximum(65535) self.portSpinBox.setValue(22) self.grid.addWidget(self.portSpinBox, 9, 0) self.addButton = QPushButton("Accept") self.grid.addWidget(self.addButton, 10, 0) self.setLayout(self.grid) self.addButton.clicked.connect(self.clickedAddButton) self.show() @Slot() def clickedAddButton(self): dataRep = DataRepository() host = self.hostnameInput.text() port = self.portSpinBox.value() pwd = self.passwordInput.text() login = self.userNameInput.text() name = self.connectionNameInput.text() dataRep.addConnection({ 'host':host, 'port':port, 'pwd':pwd, 'login':login, 'name':name }) self.accept() self.close() def closeEvent(self, event): event.accept()
class NewMarkerDialog(QDialog): def __init__(self): super(NewMarkerDialog, self).__init__() self.setWindowTitle('Add new marker...') newMarkerLabel = QLabel('Marker:') self.newMarker = QLineEdit() includeLabel = QLabel('Include all samples:') self.includeAll = QCheckBox() controlsLabel = QLabel('Control wells:') self.controls = QSpinBox() self.controls.setRange(0,8) self.controls.setValue(2) layout = QGridLayout() layout.addWidget(newMarkerLabel,0,0) layout.addWidget(self.newMarker,0,1) layout.addWidget(includeLabel,1,0) layout.addWidget(self.includeAll,1,1) layout.addWidget(controlsLabel,2,0) layout.addWidget(self.controls,2,1) self.buttons = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel) self.buttons.accepted.connect(self.accept) self.buttons.rejected.connect(self.reject) layout.addWidget(self.buttons,100,0,1,2) self.setLayout(layout) def getMarker(self): return self.newMarker.text() def getIncludeAll(self): return self.includeAll.isChecked() def getControls(self): return self.controls.value() @staticmethod def run(parent = None): dialog = NewMarkerDialog() result = dialog.exec_() newMarker = dialog.getMarker() includeAll = dialog.getIncludeAll() controls = dialog.getControls() return (newMarker,includeAll,controls,result == QDialog.Accepted)
def testSetValue(self): """Direct signal emission: QSpinBox using valueChanged(int)/setValue(int)""" spinSend = QSpinBox() spinRec = QSpinBox() spinRec.setValue(5) spinSend.setValue(42) QObject.connect(spinSend, SIGNAL('valueChanged(int)'), spinRec, SLOT('setValue(int)')) self.assertEqual(spinRec.value(), 5) self.assertEqual(spinSend.value(), 42) spinSend.emit(SIGNAL('valueChanged(int)'), 3) self.assertEqual(spinRec.value(), 3) #Direct emission shouldn't change the value of the emitter self.assertEqual(spinSend.value(), 42) spinSend.emit(SIGNAL('valueChanged(int)'), 66) self.assertEqual(spinRec.value(), 66) self.assertEqual(spinSend.value(), 42)
def testSetValue(self): """Direct signal emission: QSpinBox using valueChanged(int)/setValue(int)""" spinSend = QSpinBox() spinRec = QSpinBox() spinRec.setValue(5) spinSend.setValue(42) QObject.connect(spinSend, SIGNAL('valueChanged(int)'), spinRec, SLOT('setValue(int)')) self.assertEqual(spinRec.value(), 5) self.assertEqual(spinSend.value(), 42) spinSend.emit(SIGNAL('valueChanged(int)'), 3) self.assertEqual(spinRec.value(), 3) #Direct emission shouldn't change the value of the emitter self.assertEqual(spinSend.value(), 42) spinSend.emit(SIGNAL('valueChanged(int)'), 66) self.assertEqual(spinRec.value(), 66) self.assertEqual(spinSend.value(), 42)
class Form(QDialog): def __init__(self, state, parent=None): super().__init__(parent) Lib.prepareModalDialog(self) self.state = state self.setWindowTitle("Renumber Pages — {}".format( QApplication.applicationName())) self.createWidgets() self.layoutWidgets() self.createConnections() self.romanStartSpinBox.setFocus() self.updateUi() settings = QSettings() self.updateToolTips( bool( int( settings.value(Gopt.Key.ShowDialogToolTips, Gopt.Default.ShowDialogToolTips)))) def createWidgets(self): self.romanStartLabel = QLabel("&Roman from") self.romanStartSpinBox = Widgets.RomanSpinBox.SpinBox() self.tooltips.append((self.romanStartSpinBox, """\ <p><b>Roman from</b></p> <p>The first roman page number to change.</p>""")) self.romanStartLabel.setBuddy(self.romanStartSpinBox) self.romanEndLabel = QLabel("to") self.romanEndSpinBox = Widgets.RomanSpinBox.SpinBox() self.romanEndSpinBox.setValue(200) self.tooltips.append((self.romanEndSpinBox, """\ <p><b>Roman, to</b></p> <p>The last roman page number to change.</p>""")) self.romanChangeLabel = QLabel("change") self.romanChangeSpinBox = Widgets.ChangeSpinBox.SpinBox() self.romanChangeSpinBox.setRange(-100, 100) self.romanChangeSpinBox.setValue(0) self.romanChangeSpinBox.setMinimumWidth( self.romanChangeSpinBox.fontMetrics().width("W(no change)W")) self.tooltips.append((self.romanChangeSpinBox, """\ <p><b>Roman, change</b></p> <p>The amount to change the roman page numbers in the Roman from–to range.</p>""")) self.decimalStartLabel = QLabel("&Decimal from") self.decimalStartSpinBox = QSpinBox() self.decimalStartSpinBox.setAlignment(Qt.AlignRight) self.decimalStartLabel.setBuddy(self.decimalStartSpinBox) self.decimalStartSpinBox.setRange(1, 10000) self.tooltips.append((self.decimalStartSpinBox, """\ <p><b>Decimal from</b></p> <p>The first decimal page number to change.</p>""")) self.decimalEndLabel = QLabel("to") self.decimalEndSpinBox = QSpinBox() self.decimalEndSpinBox.setAlignment(Qt.AlignRight) self.decimalEndSpinBox.setRange(1, 10000) self.decimalEndSpinBox.setValue(2000) self.tooltips.append((self.decimalEndSpinBox, """\ <p><b>Decimal, to</b></p> <p>The last decimal page number to change.</p>""")) self.decimalChangeLabel = QLabel("change") self.decimalChangeSpinBox = Widgets.ChangeSpinBox.SpinBox() self.decimalChangeSpinBox.setRange(-100, 100) self.decimalChangeSpinBox.setValue(0) self.tooltips.append((self.decimalChangeSpinBox, """\ <p><b>Decimal, change</b></p> <p>The amount to change the decimal page numbers in the Decimal from–to range.</p>""")) self.buttonBox = QDialogButtonBox() self.renumberButton = QPushButton(QIcon(":/renumberpages.svg"), "Re&number") self.tooltips.append((self.renumberButton, """\ <p><b>Renumber</b></p> <p>Renumber roman and decimal page numbers within the given ranges by the specified amounts of change throughout the entire index.</p>""")) self.buttonBox.addButton(self.renumberButton, QDialogButtonBox.ActionRole) self.closeButton = QPushButton(QIcon(":/dialog-close.svg"), "&Cancel") self.tooltips.append((self.closeButton, """<p><b>Cancel</b></p> <p>Close the dialog without making any changes to the index.</p>""")) self.buttonBox.addButton(self.closeButton, QDialogButtonBox.RejectRole) self.helpButton = QPushButton(QIcon(":/help.svg"), "Help") self.tooltips.append( (self.helpButton, "Help on the Renumber Pages dialog")) self.buttonBox.addButton(self.helpButton, QDialogButtonBox.HelpRole) def layoutWidgets(self): grid = QGridLayout() grid.addWidget(self.romanStartLabel, 0, 0) grid.addWidget(self.romanStartSpinBox, 0, 1) grid.addWidget(self.romanEndLabel, 0, 2) grid.addWidget(self.romanEndSpinBox, 0, 3) grid.addWidget(self.romanChangeLabel, 0, 4) grid.addWidget(self.romanChangeSpinBox, 0, 5) grid.addWidget(self.decimalStartLabel, 1, 0) grid.addWidget(self.decimalStartSpinBox, 1, 1) grid.addWidget(self.decimalEndLabel, 1, 2) grid.addWidget(self.decimalEndSpinBox, 1, 3) grid.addWidget(self.decimalChangeLabel, 1, 4) grid.addWidget(self.decimalChangeSpinBox, 1, 5) hbox = QHBoxLayout() hbox.addLayout(grid) hbox.addStretch() layout = QVBoxLayout() layout.addLayout(hbox) layout.addStretch() layout.addWidget(self.buttonBox) self.setLayout(layout) def createConnections(self): self.buttonBox.rejected.connect(self.reject) self.renumberButton.clicked.connect(self.renumber) for spinbox in (self.romanStartSpinBox, self.romanEndSpinBox, self.romanChangeSpinBox, self.decimalStartSpinBox, self.decimalEndSpinBox, self.decimalChangeSpinBox): spinbox.valueChanged.connect(self.updateUi) self.helpButton.clicked.connect(self.help) def updateUi(self): self._synchronize(self.romanStartSpinBox, self.romanEndSpinBox) self._synchronize(self.decimalStartSpinBox, self.decimalEndSpinBox) changeRoman = ( (self.romanStartSpinBox.value() != self.romanEndSpinBox.value()) and self.romanChangeSpinBox.value() != 0) changeDecimal = ((self.decimalStartSpinBox.value() != self.decimalEndSpinBox.value()) and self.decimalChangeSpinBox.value() != 0) self.renumberButton.setEnabled(changeRoman or changeDecimal) self._setPrefix(self.romanChangeSpinBox) self._setPrefix(self.decimalChangeSpinBox) def _synchronize(self, startSpinBox, endSpinBox): value = startSpinBox.value() if endSpinBox.value() < value: endSpinBox.setValue(value) def _setPrefix(self, spinbox): spinbox.setPrefix("+" if spinbox.value() > 0 else "") def help(self): self.state.help("xix_ref_dlg_renumpages.html") def renumber(self): # No need to restore focus widget options = RenumberOptions(self.romanStartSpinBox.value(), self.romanEndSpinBox.value(), self.romanChangeSpinBox.value(), self.decimalStartSpinBox.value(), self.decimalEndSpinBox.value(), self.decimalChangeSpinBox.value()) with Lib.DisableUI(self): self.state.model.renumber(options, self.state.window.reportProgress) message = "Renumber pages" if self.state.model.canUndo: self.state.model.can_undo.emit(True, message) if self.state.model.canRedo: self.state.model.can_redo.emit(True, message) self.state.updateUi() say("Renumbered pages", SAY_TIMEOUT) self.accept()
class PushupForm(QDialog): ''' classdocs ''' pushupCreated = Signal(Pushup_Model) def __init__(self, athlete): ''' Constructor ''' QDialog.__init__(self) self.setWindowTitle("Pushup form") self.athlete = athlete self.pushupForm = QFormLayout() self.createGUI() def createGUI(self): self.series = QSpinBox() self.series.setMinimum(1) self.repetitions = QSpinBox() self.repetitions.setMaximum(512) self.avgHeartRateToggle = QCheckBox() self.avgHeartRateToggle.toggled.connect(self._toggleHeartRateSpinBox) self.avgHeartRate = QSpinBox() self.avgHeartRate.setMinimum(30) self.avgHeartRate.setMaximum(250) self.avgHeartRate.setValue(120) self.avgHeartRate.setDisabled(True) self.dateSelector_widget = QCalendarWidget() self.dateSelector_widget.setMaximumDate(QDate.currentDate()) self.addButton = QPushButton("Add pushup") self.addButton.setMaximumWidth(90) self.addButton.clicked.connect(self._createPushup) self.cancelButton = QPushButton("Cancel") self.cancelButton.setMaximumWidth(90) self.cancelButton.clicked.connect(self.reject) self.pushupForm.addRow("Series", self.series) self.pushupForm.addRow("Repetitions", self.repetitions) self.pushupForm.addRow("Store average heart rate ? ", self.avgHeartRateToggle) self.pushupForm.addRow("Average Heart Rate", self.avgHeartRate) self.pushupForm.addRow("Exercise Date", self.dateSelector_widget) btnsLayout = QVBoxLayout() btnsLayout.addWidget(self.addButton) btnsLayout.addWidget(self.cancelButton) btnsLayout.setAlignment(Qt.AlignRight) layoutWrapper = QVBoxLayout() layoutWrapper.addLayout(self.pushupForm) layoutWrapper.addLayout(btnsLayout) self.setLayout(layoutWrapper) def _createPushup(self): exerciseDate = self.dateSelector_widget.selectedDate() exerciseDate = self.qDate_to_date(exerciseDate) if self.avgHeartRateToggle.isChecked(): heartRate = self.avgHeartRate.value() else: heartRate = None pushup = Pushup_Model(self.athlete._name, exerciseDate, heartRate, self.series.value(), self.repetitions.value()) self.pushupCreated.emit(pushup) self.accept() def _toggleHeartRateSpinBox(self): if self.avgHeartRateToggle.isChecked(): self.avgHeartRate.setDisabled(False) else: self.avgHeartRate.setDisabled(True) def qDate_to_date(self, qDate): return date(qDate.year(), qDate.month(), qDate.day())
class Panel(QWidget): def __init__(self, state, config, parent): super().__init__(parent) self.state = state self.config = config self.form = parent self.createWidgets() self.layoutWidgets() self.createConnections() def createWidgets(self): settings = QSettings() self.sortRulesGroupBox = QGroupBox("Calculate &Sort As Rules") defaultSortAsRules = settings.value(Gconf.Key.SortAsRules, Gopt.Default.SortAsRules) self.thisSortAsRules = self.config.get(Gopt.Key.SortAsRules, defaultSortAsRules) self.defaultSortAsRulesBox = QComboBox() self.form.tooltips.append((self.defaultSortAsRulesBox, """\ <p><b>Calculate Sort As Rules, Default</b></p> <p>The default setting for the <b>Calculate Sort As Rules, For This Index</b> combobox for new indexes.</p>""")) self.thisSortAsRulesBox = QComboBox() self.form.tooltips.append((self.thisSortAsRulesBox, """\ <p><b>Calculate Sort As Rules, For This Index</b></p> <p>The rules to use for calculating each entry's sort as text for this index.</p> <p>If the rules are changed, when the dialog is closed, the new rules will be applied to every entry in the index.</p>""")) self.populateSortAsRulesBox(self.defaultSortAsRulesBox, defaultSortAsRules) self.populateSortAsRulesBox(self.thisSortAsRulesBox, self.thisSortAsRules) self.pageRangeRulesBox = QGroupBox("&Page Range Rules") defaultPageRangeRules = settings.value(Gconf.Key.PageRangeRules, Gopt.Default.PageRangeRules) self.thisPageRangeRules = self.config.get(Gopt.Key.PageRangeRules, defaultPageRangeRules) self.defaultPageRangeRulesBox = QComboBox() self.form.tooltips.append((self.defaultPageRangeRulesBox, """\ <p><b>Page Range Rules, Default</b></p> <p>The default setting for the <b>Page Range Rules, For This Index</b> combobox for new indexes.</p>""")) self.thisPageRangeRulesBox = QComboBox() self.form.tooltips.append((self.thisPageRangeRulesBox, """\ <p><b>Page Range Rules, For This Index</b></p> <p>The rules to use for handling page ranges, e.g., whether in full such as 120–124, or somehow compressed, e.g., 120–4, for this index.</p> <p>If the rules are changed, when the dialog is closed, the new rules will be applied to every entry in the index.</p>""")) self.populatePageRangeRulesBox(self.defaultPageRangeRulesBox, defaultPageRangeRules) self.populatePageRangeRulesBox(self.thisPageRangeRulesBox, self.thisPageRangeRules) self.padDigitsGroupBox = QGroupBox("Pad &Digits") defaultPadDigits = int( settings.value(Gconf.Key.PadDigits, Gopt.Default.PadDigits)) self.thisPadDigits = int( self.config.get(Gopt.Key.PadDigits, defaultPadDigits)) self.thisPadDigitsLabel = QLabel("For This Index") self.thisPadDigitsSpinBox = QSpinBox() self.thisPadDigitsSpinBox.setAlignment(Qt.AlignRight) self.thisPadDigitsSpinBox.setRange(0, 12) self.thisPadDigitsSpinBox.setValue(self.thisPadDigits) self.form.tooltips.append((self.thisPadDigitsSpinBox, """\ <p><b>Pad Digits, For This Index</b></p> <p>Sort as texts are compared textually, so if a term contains a number (or text which is converted to a number), the number must be padded by leading zeros to ensure correct ordering. This is the number of digits to pad for, for this index. For example, if set to 4, the numbers 1, 23, and 400 would be set to 0001, 0023, and 0400, in the sort as text.</p>""")) self.defaultPadDigitsLabel = QLabel("Default") self.defaultPadDigitsSpinBox = QSpinBox() self.defaultPadDigitsSpinBox.setAlignment(Qt.AlignRight) self.defaultPadDigitsSpinBox.setRange(0, 12) self.defaultPadDigitsSpinBox.setValue(defaultPadDigits) self.form.tooltips.append((self.defaultPadDigitsSpinBox, """\ <p><b>Pad Digits, Default</b></p> <p>The default setting for the <b>Pad Digits, For This Index</b> spinbox for new indexes.</p>""")) self.ignoreSubFirstsGroupBox = QGroupBox( "&Ignore Subentry Function Words") defaultIgnoreSubFirsts = bool( int( settings.value(Gconf.Key.IgnoreSubFirsts, Gopt.Default.IgnoreSubFirsts))) thisIgnoreSubFirsts = bool( int( self.config.get(Gopt.Key.IgnoreSubFirsts, defaultIgnoreSubFirsts))) self.thisIgnoreSubFirstsCheckBox = QCheckBox("For This Index") self.thisIgnoreSubFirstsCheckBox.setChecked(thisIgnoreSubFirsts) self.form.tooltips.append((self.thisIgnoreSubFirstsCheckBox, """\ <p><b>Ignore Subentry Function Words, For This Index</b></p> <p>This setting applies to this index.</p> <p>If checked, words listed in the <b>Index→Ignore Subentry Function Words</b> list are ignored for sorting purposes when the first word of a subentry, i.e., ignored when the first word of an entry's sort as text.</p> <p>This should normally be checked for Chicago Manual of Style Sort As Rules, and unchecked for NISO Rules.</p>""")) self.defaultIgnoreSubFirstsCheckBox = QCheckBox("Default") self.defaultIgnoreSubFirstsCheckBox.setChecked(defaultIgnoreSubFirsts) self.form.tooltips.append((self.defaultIgnoreSubFirstsCheckBox, """\ <p><b>Ignore Subentry Function Words, Default</b></p> <p>The default setting for the <b>Ignore Subentry Function Words, For This Index</b> checkbox for new indexes</p>""")) self.suggestSpelledGroupBox = QGroupBox( "&Suggest Spelled Out Numbers when Appropriate") defaultSuggestSpelled = bool( int( settings.value(Gconf.Key.SuggestSpelled, Gopt.Default.SuggestSpelled))) thisSuggestSpelled = bool( int(self.config.get(Gopt.Key.SuggestSpelled, defaultSuggestSpelled))) self.thisSuggestSpelledCheckBox = QCheckBox("For This Index") self.thisSuggestSpelledCheckBox.setChecked(thisSuggestSpelled) self.form.tooltips.append((self.thisSuggestSpelledCheckBox, """\ <p><b>Suggest Spelled Out Numbers when Appropriate, For This Index</b></p> <p>When checked (and providing the Sort As rules in force are not NISO rules), when adding or editing a term when the <b>Automatically Calculate Sort As</b> checkbox is checked, and when the term contains a number, the choice of sort as texts will include the number spelled out.</p>""")) self.defaultSuggestSpelledCheckBox = QCheckBox("Default") self.defaultSuggestSpelledCheckBox.setChecked(defaultSuggestSpelled) self.form.tooltips.append((self.defaultSuggestSpelledCheckBox, """\ <p><b>Suggest Spelled Out Numbers when Appropriate, Default</b></p> <p>The default setting for the <b>Suggest Spelled Out Numbers when Appropriate, For This Index</b> checkbox for new indexes.</p>""")) def layoutWidgets(self): layout = QVBoxLayout() form = QFormLayout() form.addRow("For This Index", self.thisSortAsRulesBox) form.addRow("Default", self.defaultSortAsRulesBox) self.sortRulesGroupBox.setLayout(form) layout.addWidget(self.sortRulesGroupBox) form = QFormLayout() form.addRow("For This Index", self.thisPageRangeRulesBox) form.addRow("Default", self.defaultPageRangeRulesBox) self.pageRangeRulesBox.setLayout(form) layout.addWidget(self.pageRangeRulesBox) hbox = QHBoxLayout() hbox.addWidget(self.thisPadDigitsLabel) hbox.addWidget(self.thisPadDigitsSpinBox) hbox.addStretch(1) hbox.addWidget(self.defaultPadDigitsLabel) hbox.addWidget(self.defaultPadDigitsSpinBox) hbox.addStretch(3) self.padDigitsGroupBox.setLayout(hbox) layout.addWidget(self.padDigitsGroupBox) hbox = QHBoxLayout() hbox.addWidget(self.thisIgnoreSubFirstsCheckBox) hbox.addWidget(self.defaultIgnoreSubFirstsCheckBox) hbox.addStretch() self.ignoreSubFirstsGroupBox.setLayout(hbox) layout.addWidget(self.ignoreSubFirstsGroupBox) hbox = QHBoxLayout() hbox.addWidget(self.thisSuggestSpelledCheckBox) hbox.addWidget(self.defaultSuggestSpelledCheckBox) hbox.addStretch() self.suggestSpelledGroupBox.setLayout(hbox) layout.addWidget(self.suggestSpelledGroupBox) layout.addStretch() self.setLayout(layout) def createConnections(self): self.defaultSortAsRulesBox.currentIndexChanged.connect( self.setDefaultSortAsRules) self.defaultPageRangeRulesBox.currentIndexChanged.connect( self.setDefaultPageRangeRules) self.defaultPadDigitsSpinBox.valueChanged.connect( self.setDefaultPadDigits) self.defaultIgnoreSubFirstsCheckBox.toggled.connect( self.setDefaultIgnoreSubFirsts) self.defaultSuggestSpelledCheckBox.toggled.connect( self.setDefaultSuggestSpelled) def populateSortAsRulesBox(self, combobox, rules): index = -1 for i, name in enumerate(SortAs.RulesForName): displayName = SortAs.RulesForName[name].name combobox.addItem(displayName, name) if name == rules: index = i combobox.setCurrentIndex(index) def setDefaultSortAsRules(self, index): index = self.defaultSortAsRulesBox.currentIndex() name = self.defaultSortAsRulesBox.itemData(index) settings = QSettings() settings.setValue(Gopt.Key.SortAsRules, name) def populatePageRangeRulesBox(self, combobox, rules): index = -1 for i, name in enumerate(Pages.RulesForName): displayName = Pages.RulesForName[name].name combobox.addItem(displayName, name) if name == rules: index = i combobox.setCurrentIndex(index) def setDefaultPageRangeRules(self, index): index = self.defaultPageRangeRulesBox.currentIndex() name = self.defaultPageRangeRulesBox.itemData(index) settings = QSettings() settings.setValue(Gopt.Key.PageRangeRules, name) def setDefaultPadDigits(self): value = self.defaultPadDigitsSpinBox.value() settings = QSettings() settings.setValue(Gopt.Key.PadDigits, value) def setDefaultIgnoreSubFirsts(self): value = int(self.defaultIgnoreSubFirstsCheckBox.isChecked()) settings = QSettings() settings.setValue(Gopt.Key.IgnoreSubFirsts, value) def setDefaultSuggestSpelled(self): value = int(self.defaultSuggestSpelledCheckBox.isChecked()) settings = QSettings() settings.setValue(Gopt.Key.SuggestSpelled, value)
class _PenepmaConfigurePanelWidget(_ConfigurePanelWidget): def _initUI(self): # Widgets self._brw_pendbase = DirBrowseWidget() self._brw_exe = FileBrowseWidget() if os.name == 'nt': self._brw_exe.setNameFilter('Application files (*.exe)') else: self._brw_exe.setNameFilter('Application files (*)') self._spn_dumpp = QSpinBox() self._spn_dumpp.setMinimum(30) self._spn_dumpp.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed) # Layouts layout = _ConfigurePanelWidget._initUI(self) layout.addRow("Path to pendbase directory", self._brw_pendbase) layout.addRow('Path to PENEPMA executable', self._brw_exe) layout.addRow('Interval between dump (s)', self._spn_dumpp) # Signals self._brw_pendbase.pathChanged.connect(self._onPathChanged) self._brw_exe.pathChanged.connect(self._onPathChanged) return layout def _onPathChanged(self, path): if not path: return if not self._brw_pendbase.baseDir(): self._brw_pendbase.setBaseDir(path) if not self._brw_exe.baseDir(): self._brw_exe.setBaseDir(path) def hasAcceptableInput(self): if not self._brw_pendbase.path(): return False if not self._brw_exe.path(): return False if not os.access(self._brw_exe.path(), os.X_OK): return False return True def setSettings(self, settings): if 'penepma' in settings: path = getattr(settings.penepma, 'pendbase', None) try: self._brw_pendbase.setPath(path) except ValueError: pass path = getattr(settings.penepma, 'exe', None) try: self._brw_exe.setPath(path) except ValueError: pass try: dumpp = int(getattr(settings.penepma, 'dumpp', 30)) self._spn_dumpp.setValue(dumpp) except (TypeError, ValueError): pass def updateSettings(self, settings): section = _ConfigurePanelWidget.updateSettings(self, settings) section.pendbase = self._brw_pendbase.path() section.exe = self._brw_exe.path() section.dumpp = int(self._spn_dumpp.value()) return section
class OptionsContainer(QWidget): def __init__(self,main_window): QWidget.__init__(self) self.main_window = main_window self.layout = QGridLayout() self.setLayout(self.layout) self.lr = numpy.zeros(2) self.fps = QSpinBox() self.fps.setValue(25) self.fps.setMinimum(1) self.fps.setMaximum(1000) self.layout.addWidget(QLabel("FPS:"),10,10) self.layout.addWidget(self.fps,10,11) self.capture_area_group = QButtonGroup() self.capture_area_fs = QRadioButton("Full Screen") self.connect(self.capture_area_fs, SIGNAL("clicked()"),self.capture_area_change) self.capture_area_fs.setChecked(True) self.capture_area_sa = QRadioButton("Selected Area") self.connect(self.capture_area_sa, SIGNAL("clicked()"),self.capture_area_change) self.capture_area_group.addButton(self.capture_area_fs) self.capture_area_group.addButton(self.capture_area_sa) self.capture_area_group.setExclusive(True) self.layout.addWidget(self.capture_area_fs,12,10) self.layout.addWidget(self.capture_area_sa,12,11) self.sa_group = QGroupBox() self.sa_grid = QGridLayout() self.sa_group.setLayout(self.sa_grid) self.sa_ul_bt = QPushButton("Select Upper Left") self.connect(self.sa_ul_bt, SIGNAL("clicked()"), self.select_ul) self.sa_lr_bt = QPushButton("Select Lower Right") self.connect(self.sa_lr_bt, SIGNAL("clicked()"), self.select_lr) self.sa_x = QSpinBox() self.sa_y = QSpinBox() self.sa_w = QSpinBox() self.sa_h = QSpinBox() for sb in [self.sa_h,self.sa_w,self.sa_x,self.sa_y]: sb.setMaximum(999999) sb.setMinimum(0) self.sa_grid.addWidget(self.sa_ul_bt,14,10,1,1) self.sa_grid.addWidget(self.sa_lr_bt,15,10,1,1) self.sa_grid.addWidget(QLabel("x"),14,11,1,1) self.sa_grid.addWidget(self.sa_x,14,12,1,1) self.sa_grid.addWidget(QLabel("y"),15,11,1,1) self.sa_grid.addWidget(self.sa_y,15,12,1,1) self.sa_grid.addWidget(QLabel("w"),16,11,1,1) self.sa_grid.addWidget(self.sa_w,16,12,1,1) self.sa_grid.addWidget(QLabel("h"),17,11,1,1) self.sa_grid.addWidget(self.sa_h,17,12,1,1) self.sa_show_bt = QPushButton("Show Area") self.sa_show_bt.setCheckable(True) self.connect(self.sa_show_bt, SIGNAL("clicked()"), self.show_selected_area) self.sa_grid.addWidget(self.sa_show_bt,18,10,1,10) self.sa_group.hide() self.layout.addWidget(self.sa_group,14,10,1,10) self.capture_delay = QSpinBox() self.capture_delay.setMinimum(0) self.capture_delay.setMaximum(10000) self.layout.addWidget(QLabel("Capture Delay"),18,10,1,1) self.layout.addWidget(self.capture_delay,18,11,1,1) self.capture_bt = QPushButton("Capture") self.stop_capture_bt = QPushButton("Stop") self.stop_capture_bt.hide() self.layout.addWidget(self.capture_bt,20,10,1,10) self.layout.addWidget(self.stop_capture_bt,30,10,1,10) self.ffmpeg_flags = QLineEdit() self.ffmpeg_flags.setText("-qscale 0 -vcodec mpeg4") self.layout.addWidget(QLabel("FFMPEG Flags:"),40,10) self.layout.addWidget(self.ffmpeg_flags,50,10,1,10) self.encode_bt = QPushButton("Encode Video") self.layout.addWidget(self.encode_bt,60,10,1,10) self.open_dir_bt = QPushButton("Open Directory") self.layout.addWidget(self.open_dir_bt,80,10,1,10) self.connect(self.open_dir_bt, SIGNAL("clicked()"),self.open_cwd) self.selected_area = SelectedArea() def show_selected_area(self): x = self.sa_x.value() y = self.sa_y.value() w = self.sa_w.value() h = self.sa_h.value() self.selected_area.setGeometry(x,y,w,h) self.selected_area.activateWindow() self.selected_area.raise_() if(self.sa_show_bt.isChecked()): self.selected_area.show() else:self.selected_area.hide() def select_ul(self): print "select_ul" self.clicked = False self.tw = TransWindow() self.tw.mouse_press = False self.tw.show() self.connect(self.tw, SIGNAL("mouse_press()"),self.set_ul) def select_lr(self): print "select_lr" self.clicked = False self.tw = TransWindow() self.tw.mouse_press = False self.tw.show() self.connect(self.tw, SIGNAL("mouse_press()"),self.set_lr) def set_ul(self): self.sa_x.setValue( self.tw.pos[0]) self.sa_y.setValue( self.tw.pos[1]) self.sa_w.setValue( self.lr[0] - self.sa_x.value()) self.sa_h.setValue( self.lr[1] - self.sa_y.value()) self.show_selected_area() def set_lr(self): self.lr = numpy.array([self.tw.pos[0],self.tw.pos[1]]) self.sa_w.setValue( self.tw.pos[0] - self.sa_x.value()) self.sa_h.setValue( self.tw.pos[1] - self.sa_y.value()) self.show_selected_area() def capture_area_change(self): print "capture_area_change" if(self.capture_area_fs.isChecked()): self.sa_group.hide() else: self.sa_group.show() self.adjustSize() self.main_window.adjustSize() def open_cwd(self): #will need to detect os and change accordingly os.system("open {}".format(os.getcwd()))
class PushupForm(QDialog): ''' classdocs ''' pushupCreated = Signal(Pushup_Model) def __init__(self, athlete): ''' Constructor ''' QDialog.__init__(self) self.setWindowTitle("Pushup form") self.athlete = athlete self.pushupForm = QFormLayout() self.createGUI() def createGUI(self): self.series = QSpinBox() self.series.setMinimum(1) self.repetitions = QSpinBox() self.repetitions.setMaximum(512) self.avgHeartRateToggle = QCheckBox() self.avgHeartRateToggle.toggled.connect(self._toggleHeartRateSpinBox) self.avgHeartRate = QSpinBox() self.avgHeartRate.setMinimum(30) self.avgHeartRate.setMaximum(250) self.avgHeartRate.setValue(120) self.avgHeartRate.setDisabled(True) self.dateSelector_widget = QCalendarWidget() self.dateSelector_widget.setMaximumDate(QDate.currentDate()) self.addButton = QPushButton("Add pushup") self.addButton.setMaximumWidth(90) self.addButton.clicked.connect(self._createPushup) self.cancelButton = QPushButton("Cancel") self.cancelButton.setMaximumWidth(90) self.cancelButton.clicked.connect(self.reject) self.pushupForm.addRow("Series", self.series) self.pushupForm.addRow("Repetitions", self.repetitions) self.pushupForm.addRow("Store average heart rate ? ", self.avgHeartRateToggle) self.pushupForm.addRow("Average Heart Rate", self.avgHeartRate) self.pushupForm.addRow("Exercise Date", self.dateSelector_widget) btnsLayout = QVBoxLayout() btnsLayout.addWidget(self.addButton) btnsLayout.addWidget(self.cancelButton) btnsLayout.setAlignment(Qt.AlignRight) layoutWrapper = QVBoxLayout() layoutWrapper.addLayout(self.pushupForm) layoutWrapper.addLayout(btnsLayout) self.setLayout(layoutWrapper) def _createPushup(self): exerciseDate = self.dateSelector_widget.selectedDate() exerciseDate = self.qDate_to_date(exerciseDate) if self.avgHeartRateToggle.isChecked(): heartRate = self.avgHeartRate.value() else: heartRate = None pushup = Pushup_Model(self.athlete._name, exerciseDate, heartRate, self.series.value(), self.repetitions.value()) self.pushupCreated.emit(pushup) self.accept() def _toggleHeartRateSpinBox(self): if self.avgHeartRateToggle.isChecked(): self.avgHeartRate.setDisabled(False) else: self.avgHeartRate.setDisabled(True) def qDate_to_date(self, qDate): return date(qDate.year(), qDate.month(),qDate.day())
class MainWindow(QWidget): def __init__(self, fixtures_folder, parent=None): QWidget.__init__(self, parent) self.current_fixture = None self.fixtures_folder = fixtures_folder self.setWindowTitle("Frangitron DMX program editor") self.text = QPlainTextEdit() font = QFont("Monospace") font.setStyleHint(QFont.TypeWriter) font.setPixelSize(16) self.text.setFont(font) self.text.setStyleSheet( "color: white; background-color: rgb(30, 30, 30)") self.combo_fixture = QComboBox() self.frame_programs = QWidget() self.checkboxes_programs = list() self.layout_programs = QGridLayout(self.frame_programs) self.spinner_offset = QSpinBox() self.spinner_offset.setMinimum(1) self.spinner_offset.setMaximum(512) self.spinner_offset.setValue(1) self.spinner_offset.valueChanged.connect(self.address_changed) self.doc = QPlainTextEdit() self.doc.setReadOnly(True) self.doc.setFont(font) self.status = QLabel() layout = QGridLayout(self) layout.addWidget(self.combo_fixture, 0, 1) layout.addWidget(self.spinner_offset, 0, 2) layout.addWidget(self.frame_programs, 1, 1) layout.addWidget(self.text, 0, 0, 3, 1) layout.addWidget(self.doc, 2, 1, 1, 2) layout.addWidget(self.status, 3, 0, 1, 3) layout.setColumnStretch(0, 60) layout.setColumnStretch(1, 40) self.resize(1280, 800) self.streamer = Streamer(self.fixtures_folder) self.combo_fixture.addItems(sorted(self.streamer.fixtures)) self.combo_fixture.currentIndexChanged.connect(self.fixture_changed) self.timer = QTimer() self.timer.timeout.connect(self.tick) self.timer.start(500.0 / FRAMERATE) self.should_reload = True self.fixture_changed() def selected_programs(self): return [ chk.text() for chk in self.checkboxes_programs if chk.isChecked() ] def update_programs(self): selected_programs = self.selected_programs() for checkbox_program in self.checkboxes_programs: self.layout_programs.removeWidget(checkbox_program) checkbox_program.deleteLater() self.checkboxes_programs = list() for i, program_name in enumerate( sorted(self.current_fixture.programs.keys())): column = i // 4 row = i % 4 new_checkbox = QCheckBox(program_name) new_checkbox.setChecked(program_name in selected_programs) self.layout_programs.addWidget(new_checkbox, row, column) self.checkboxes_programs.append(new_checkbox) def address_changed(self): self.current_fixture.address = self.spinner_offset.value() self.doc.setPlainText(self.current_fixture.doc()) self.update_programs() def fixture_changed(self): self.current_fixture = self.streamer.fixtures[ self.combo_fixture.currentText()] self.address_changed() self.streamer.reset_expressions() with open(self.current_fixture.programs_filepath, 'r') as f_programs: self.text.setPlainText(f_programs.read()) def tick(self): if self.should_reload: self.current_fixture.reload_programs() self.update_programs() self.streamer.reset_state() program = PROGRAM.replace('__fixture__', self.current_fixture.name) program = program.replace('__address__', str(self.current_fixture.address)) program = program.replace( '__programs__', ", ".join([ '"{}"'.format(prog) for prog in self.selected_programs() ])) self.streamer.load(programs_source=program) self.streamer.program_clicked("1") else: state = self.streamer.state if state: self.status.setStyleSheet( "background-color: green; color: white; padding: 5px") self.status.setText(state.context) else: self.status.setStyleSheet( "background-color: red; color: white; padding: 5px") self.status.setText("{} : {}".format(state.context, state.exception)) if self.current_fixture is None: return with open(self.current_fixture.programs_filepath, 'w') as f_programs: f_programs.write(self.text.toPlainText()) self.should_reload = not self.should_reload def closeEvent(self, event): self.timer.stop() self.streamer.load(programs_source="") self.streamer.program_clicked("1") sleep(2.0 / float(FRAMERATE)) self.streamer.stop() event.accept()
class RunnerDialog(QDialog): options_added = Signal(Options) options_running = Signal(Options) options_simulated = Signal(Options) options_error = Signal(Options, Exception) results_saved = Signal(Results, str) results_error = Signal(Results, Exception) def __init__(self, parent=None): QDialog.__init__(self, parent) self.setWindowTitle('Runner') self.setMinimumWidth(750) # Runner self._runner = None self._running_timer = QTimer() self._running_timer.setInterval(500) # Widgets self._dlg_progress = QProgressDialog() self._dlg_progress.setRange(0, 100) self._dlg_progress.setModal(True) self._dlg_progress.hide() lbl_outputdir = QLabel("Output directory") self._txt_outputdir = DirBrowseWidget() max_workers = cpu_count() #@UndefinedVariable lbl_workers = QLabel('Number of workers') self._spn_workers = QSpinBox() self._spn_workers.setRange(1, max_workers) self._spn_workers.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed) lbl_max_workers = QLabel('(max: %i)' % max_workers) self._chk_overwrite = QCheckBox("Overwrite existing results in output directory") self._chk_overwrite.setChecked(True) self._lbl_available = QLabel('Available') self._lst_available = QListView() self._lst_available.setModel(_AvailableOptionsListModel()) self._lst_available.setSelectionMode(QListView.SelectionMode.MultiSelection) tlb_available = QToolBar() spacer = QWidget() spacer.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding) tlb_available.addWidget(spacer) act_open = tlb_available.addAction(getIcon("document-open"), "Open") act_open.setShortcut(QKeySequence.Open) tlb_available.addSeparator() act_remove = tlb_available.addAction(getIcon("list-remove"), "Remove") act_clear = tlb_available.addAction(getIcon("edit-clear"), "Clear") self._btn_addtoqueue = QPushButton(getIcon("go-next"), "") self._btn_addtoqueue.setToolTip("Add to queue") self._btn_addtoqueue.setEnabled(False) self._btn_addalltoqueue = QPushButton(getIcon("go-last"), "") self._btn_addalltoqueue.setToolTip("Add all to queue") self._btn_addalltoqueue.setEnabled(False) self._lbl_options = QLabel('Queued/Running/Completed') self._tbl_options = QTableView() self._tbl_options.setModel(_StateOptionsTableModel()) self._tbl_options.setItemDelegate(_StateOptionsItemDelegate()) self._tbl_options.setSelectionMode(QListView.SelectionMode.NoSelection) self._tbl_options.setColumnWidth(1, 60) self._tbl_options.setColumnWidth(2, 80) header = self._tbl_options.horizontalHeader() header.setResizeMode(0, QHeaderView.Interactive) header.setResizeMode(1, QHeaderView.Fixed) header.setResizeMode(2, QHeaderView.Fixed) header.setResizeMode(3, QHeaderView.Stretch) self._btn_start = QPushButton(getIcon("media-playback-start"), "Start") self._btn_cancel = QPushButton("Cancel") self._btn_cancel.setEnabled(False) self._btn_close = QPushButton("Close") self._btn_import = QPushButton("Import") self._btn_import.setEnabled(False) # Layouts layout = QVBoxLayout() sublayout = QGridLayout() sublayout.addWidget(lbl_outputdir, 0, 0) sublayout.addWidget(self._txt_outputdir, 0, 1) sublayout.addWidget(lbl_workers, 1, 0) subsublayout = QHBoxLayout() subsublayout.addWidget(self._spn_workers) subsublayout.addWidget(lbl_max_workers) sublayout.addLayout(subsublayout, 1, 1) layout.addLayout(sublayout) sublayout.addWidget(self._chk_overwrite, 2, 0, 1, 3) sublayout = QGridLayout() sublayout.setColumnStretch(0, 1) sublayout.setColumnStretch(2, 3) sublayout.addWidget(self._lbl_available, 0, 0) sublayout.addWidget(self._lst_available, 1, 0) sublayout.addWidget(tlb_available, 2, 0) subsublayout = QVBoxLayout() subsublayout.addStretch() subsublayout.addWidget(self._btn_addtoqueue) subsublayout.addWidget(self._btn_addalltoqueue) subsublayout.addStretch() sublayout.addLayout(subsublayout, 1, 1) sublayout.addWidget(self._lbl_options, 0, 2) sublayout.addWidget(self._tbl_options, 1, 2) layout.addLayout(sublayout) sublayout = QHBoxLayout() sublayout.addStretch() sublayout.addWidget(self._btn_import) sublayout.addWidget(self._btn_start) sublayout.addWidget(self._btn_cancel) sublayout.addWidget(self._btn_close) layout.addLayout(sublayout) self.setLayout(layout) # Signal self._running_timer.timeout.connect(self._onRunningTimer) act_open.triggered.connect(self._onOpen) act_remove.triggered.connect(self._onRemove) act_clear.triggered.connect(self._onClear) self._btn_addtoqueue.released.connect(self._onAddToQueue) self._btn_addalltoqueue.released.connect(self._onAddAllToQueue) self._btn_start.released.connect(self._onStart) self._btn_cancel.released.connect(self._onCancel) self._btn_close.released.connect(self._onClose) self._btn_import.released.connect(self._onImport) self.options_added.connect(self._onOptionsAdded) self.options_running.connect(self._onOptionsRunning) self.options_simulated.connect(self._onOptionsSimulated) self.options_error.connect(self._onOptionsError) self.results_error.connect(self._onResultsError) # Defaults settings = get_settings() section = settings.add_section('gui') if hasattr(section, 'outputdir'): self._txt_outputdir.setPath(section.outputdir) if hasattr(section, 'maxworkers'): self._spn_workers.setValue(int(section.maxworkers)) if hasattr(section, 'overwrite'): state = True if section.overwrite.lower() == 'true' else False self._chk_overwrite.setChecked(state) def _onDialogProgressProgress(self, progress, status): self._dlg_progress.setValue(progress * 100) self._dlg_progress.setLabelText(status) def _onDialogProgressCancel(self): self._dlg_progress.hide() if self._options_reader_thread is None: return self._options_reader_thread.cancel() self._options_reader_thread.quit() self._options_reader_thread.wait() def _onDialogProgressException(self, ex): self._dlg_progress.hide() self._options_reader_thread.quit() self._options_reader_thread.wait() messagebox.exception(self, ex) def _onRunningTimer(self): self._tbl_options.model().reset() def _onOpen(self): settings = get_settings() curdir = getattr(settings.gui, 'opendir', os.getcwd()) filepath, namefilter = \ QFileDialog.getOpenFileName(self, "Open", curdir, 'Options [*.xml] (*.xml)') if not filepath or not namefilter: return settings.gui.opendir = os.path.dirname(filepath) if not filepath.endswith('.xml'): filepath += '.xml' self._options_reader_thread = _OptionsReaderWrapperThread(filepath) self._dlg_progress.canceled.connect(self._onDialogProgressCancel) self._options_reader_thread.resultReady.connect(self._onOpened) self._options_reader_thread.progressUpdated.connect(self._onDialogProgressProgress) self._options_reader_thread.exceptionRaised.connect(self._onDialogProgressException) self._options_reader_thread.start() self._dlg_progress.reset() self._dlg_progress.show() def _onOpened(self, options): self._dlg_progress.hide() self._options_reader_thread.quit() self._options_reader_thread.wait() self._options_reader_thread = None try: self._lst_available.model().addOptions(options) except Exception as ex: messagebox.exception(self, ex) def _onRemove(self): selection = self._lst_available.selectionModel().selection().indexes() if len(selection) == 0: QMessageBox.warning(self, "Queue", "Select an options") return model = self._lst_available.model() for row in sorted(map(methodcaller('row'), selection), reverse=True): model.popOptions(row) def _onClear(self): self._lst_available.model().clearOptions() def _onAddToQueue(self): selection = self._lst_available.selectionModel().selection().indexes() if len(selection) == 0: QMessageBox.warning(self, "Queue", "Select an options") return model = self._lst_available.model() for row in sorted(map(methodcaller('row'), selection), reverse=True): options = model.options(row) try: self._runner.put(options) except Exception as ex: messagebox.exception(self, ex) return def _onAddAllToQueue(self): model = self._lst_available.model() for row in reversed(range(0, model.rowCount())): options = model.options(row) try: self._runner.put(options) except Exception as ex: messagebox.exception(self, ex) return def _onStart(self): outputdir = self._txt_outputdir.path() if not outputdir: QMessageBox.critical(self, 'Start', 'Missing output directory') return max_workers = self._spn_workers.value() overwrite = self._chk_overwrite.isChecked() self.start(outputdir, overwrite, max_workers) def _onCancel(self): self.cancel() def _onClose(self): if self._runner is not None: self._runner.close() self._running_timer.stop() self.close() def _onImport(self): list_options = self._lst_available.model().listOptions() if not list_options: return # Select options dialog = _OptionsSelector(list_options) if not dialog.exec_(): return options = dialog.options() # Start importer outputdir = self._runner.outputdir max_workers = self._runner.max_workers importer = LocalImporter(outputdir, max_workers) importer.start() importer.put(options) self._dlg_progress.show() try: while importer.is_alive(): if self._dlg_progress.wasCanceled(): importer.cancel() break self._dlg_progress.setValue(importer.progress * 100) finally: self._dlg_progress.hide() def _onOptionsAdded(self, options): logging.debug('runner: optionsAdded') self._tbl_options.model().addOptions(options) def _onOptionsRunning(self, options): logging.debug('runner: optionsRunning') self._tbl_options.model().resetOptions(options) def _onOptionsSimulated(self, options): logging.debug('runner: optionsSimulated') self._tbl_options.model().resetOptions(options) def _onOptionsError(self, options, ex): logging.debug('runner: optionsError') self._tbl_options.model().resetOptions(options) def _onResultsError(self, results, ex): logging.debug('runner: resultsError') self._tbl_options.model().reset() def closeEvent(self, event): if self.is_running(): message = 'Runner is running. Do you want to continue?' answer = QMessageBox.question(self, 'Runner', message, QMessageBox.Yes | QMessageBox.No) if answer == QMessageBox.No: event.ignore() return self.cancel() self._dlg_progress.close() settings = get_settings() section = settings.add_section('gui') path = self._txt_outputdir.path() if path: section.outputdir = path section.maxworkers = str(self._spn_workers.value()) section.overwrite = str(self._chk_overwrite.isChecked()) settings.write() event.accept() def addAvailableOptions(self, options): self._lst_available.model().addOptions(options) def removeAvailableOptions(self, options): self._lst_available.model().removeOptions(options) def clearAvailableOptions(self): self._lbl_available.model().clearOptions() def start(self, outputdir, overwrite, max_workers): self._runner = LocalRunner(outputdir=outputdir, overwrite=overwrite, max_workers=max_workers) self._tbl_options.setModel(_StateOptionsTableModel(self._runner)) self._spn_workers.setEnabled(False) self._txt_outputdir.setEnabled(False) self._chk_overwrite.setEnabled(False) self._btn_addtoqueue.setEnabled(True) self._btn_addalltoqueue.setEnabled(True) self._btn_start.setEnabled(False) self._btn_cancel.setEnabled(True) self._btn_close.setEnabled(False) self._btn_import.setEnabled(True) self._runner.options_added.connect(self.options_added.emit) self._runner.options_running.connect(self.options_running.emit) self._runner.options_simulated.connect(self.options_simulated.emit) self._runner.options_error.connect(self.options_error.emit) self._runner.results_saved.connect(self.results_saved.emit) self._runner.results_error.connect(self.results_error.emit) self._running_timer.start() self._runner.start() def cancel(self): if self._runner is None: return self._runner.cancel() self._running_timer.stop() self._runner.options_added.disconnect(self.options_added.emit) self._runner.options_running.disconnect(self.options_running.emit) self._runner.options_simulated.disconnect(self.options_simulated.emit) self._runner.options_error.disconnect(self.options_error.emit) self._runner.results_saved.disconnect(self.results_saved.emit) self._runner.results_error.disconnect(self.results_error.emit) self._runner = None self._spn_workers.setEnabled(True) self._txt_outputdir.setEnabled(True) self._chk_overwrite.setEnabled(True) self._btn_addtoqueue.setEnabled(False) self._btn_addalltoqueue.setEnabled(False) self._btn_start.setEnabled(True) self._btn_cancel.setEnabled(False) self._btn_close.setEnabled(True) self._btn_import.setEnabled(False) def is_running(self): return self._runner is not None and self._runner.is_alive()
class DoFPParametersDialog(QDialog): AFTER_CONSTRUCTION_ALLFRAC = 1 AFTER_CONSTRUCTION_RANGESTRING = 2 AFTER_CONSTRUCTION_TOTOP = 3 def __init__(self, rangeConstructor=1.0, boardCombo=None, title="Enter first range arguments", parent=None): super(DoFPParametersDialog, self).__init__(parent) self._after_method = 2 self._board_combo = boardCombo label_constructor = QLabel("Constructor argument <b>(initFrac)</b>") self._spinbox_constructor = QSpinBox() self._spinbox_constructor.setMaximum(9999) self._spinbox_constructor.setValue(rangeConstructor) label_after_construction = QLabel("After construction method") self._radiogroup_methods = HorizontalRadioGroup(["setRangeString()", "setAllFracs()", "setToTop()"]) self._radiogroup_methods.radio_checked.connect(self._updateLayout) self._radiogroup_methods._radios[0].setChecked(True) # dunno why it's not checked by default label_method_args = QLabel("Method arguments") self._widget_method_args = SetRangeStringCompound() button_ok = QPushButton("Ok") button_ok.clicked.connect(self.accept) button_cancel = QPushButton("Cancel") button_cancel.clicked.connect(self.reject) layout = QGridLayout() row = 0; col = 0; layout.addWidget(label_constructor, row, col) col += 1 layout.addWidget(self._spinbox_constructor, row, col) row += 1; col = 0; layout.addWidget(label_after_construction, row, col) col += 1 layout.addWidget(self._radiogroup_methods) row += 1; col = 0; layout.addWidget(label_method_args, row, col) col += 1 self._update_pos = (row, col) layout.addWidget(self._widget_method_args, row, col) row += 1; col = 0 layout.addWidget(button_ok, row, col) col += 1 layout.addWidget(button_cancel, row, col) self.setLayout(layout) self.setWindowTitle(title) def _updateLayout(self, radioString): self._widget_method_args.setParent(None) self.layout().removeWidget(self._widget_method_args) if radioString == "setRangeString()": self._after_method = self.AFTER_CONSTRUCTION_RANGESTRING self._widget_method_args = SetRangeStringCompound() elif radioString == "setAllFracs()": self._after_method = self.AFTER_CONSTRUCTION_ALLFRAC self._widget_method_args = SetAllFracsSpinBox() elif radioString == "setToTop()": self._after_method = self.AFTER_CONSTRUCTION_TOTOP self._widget_method_args = SetToTopCompound(self._board_combo) self.layout().update() self.layout().addWidget(self._widget_method_args, self._update_pos[0], self._update_pos[1]) def getRange(self): # construct a range object and return it r = Range(self._spinbox_constructor.value()) if self._after_method == self.AFTER_CONSTRUCTION_ALLFRAC: r.setAllFracs(self._widget_method_args.value()) elif self._after_method == self.AFTER_CONSTRUCTION_RANGESTRING: r.setRangeString(self._widget_method_args.lineedit_string.text(), self._widget_method_args.spinbox_value.value()) elif self._after_method == self.AFTER_CONSTRUCTION_TOTOP: r.setToTop(self._widget_method_args.spinbox_fraction.value(), self._board_combo.boards()[self._widget_method_args.combobox_board.currentIndex()]) return r
class MainWindow(QMainWindow): # Sets up the main window def resize_window(self): # Function for resizing the window self.resize(self.minimumSizeHint()) def __init__(self, parent=None): super(MainWindow, self).__init__(parent) # Set window Icon self.setWindowTitle(__appname__) iconImage = QImage(iconByteArray) iconPixmap = QPixmap(iconImage) self.setWindowIcon(QIcon(iconPixmap)) # Set up private key format widgets privateKeyFormatLayout = QHBoxLayout() privateKeyFormatLabel = QLabel('Select Key Format: ') self.privateKeyTypeCombobox = QComboBox() self.privateKeyTypeCombobox.addItems(privateKeyFormats) self.privateKeyLengthLabel = QLabel('0') privateKeyFormatLayout.addWidget(privateKeyFormatLabel) privateKeyFormatLayout.addWidget(self.privateKeyTypeCombobox) privateKeyFormatLayout.addWidget(self.privateKeyLengthLabel) # Set up private key text widgets privateKeyLayout = QVBoxLayout() privateKeyButtonsLayout = QHBoxLayout() generatePrivateKeyButton = QPushButton('Generate Key') generatePrivateKeyButton.clicked.connect(self.get_private_key) self.copyPrivateKeyButton = QPushButton('Copy Key') self.copyPrivateKeyButton.setDisabled(True) self.copyPrivateKeyButton.clicked.connect(self.copy_private_key) privateKeyButtonsLayout.addWidget(generatePrivateKeyButton) privateKeyButtonsLayout.addWidget(self.copyPrivateKeyButton) self.privateKeyEdit = GrowingTextEdit() self.privateKeyEdit.setFont(QFont('Courier')) self.privateKeyEdit.textChanged.connect( self.private_key_or_code_changed) privateKeyLayout.addLayout(privateKeyButtonsLayout) privateKeyLayout.addWidget(self.privateKeyEdit) # Set up cypher code widgets codeLayout = QHBoxLayout() codeLabel = QLabel('Select Cypher Code: ') self.codeSelect = QSpinBox() self.codeSelect.setValue(10) self.codeSelect.setMinimum(2) self.codeSelect.setDisabled(True) self.codeSelect.valueChanged.connect(self.private_key_or_code_changed) codeLayout.addWidget(codeLabel) codeLayout.addWidget(self.codeSelect) # Set up cypher text widgets cypherLayout = QVBoxLayout() cypherButtonsLayout = QHBoxLayout() cardButtonsLayout = QHBoxLayout() self.generateCypherButton = QPushButton('Generate Cypher') self.generateCypherButton.clicked.connect(self.get_cypher) self.generateCypherButton.setDisabled(True) self.copyCypherButton = QPushButton('Copy Cypher') self.copyCypherButton.setDisabled(True) self.copyCypherButton.clicked.connect(self.copy_cypher) cypherButtonsLayout.addWidget(self.generateCypherButton) cypherButtonsLayout.addWidget(self.copyCypherButton) self.cypherEdit = GrowingTextEdit() self.cypherEdit.setFont(QFont('Courier')) self.cypherEdit.setReadOnly(True) self.cypherEdit.setVisible(False) self.cypherEdit.textChanged.connect(self.resize_window) self.cypherPreviewLabel = QLabel('-CYPHER PREVIEW-') self.cypherPreviewLabel.setAlignment(Qt.AlignCenter) self.cypherPreviewLabel.setVisible(False) self.cypherPreview = GrowingTextEdit() self.cypherPreview.setFont(QFont('Courier')) self.cypherPreview.setAlignment(Qt.AlignHCenter) self.cypherPreview.setWordWrapMode(QTextOption.NoWrap) self.cypherPreview.setReadOnly(True) self.cypherPreview.setVisible(False) self.cypherCardsPrintButton = QPushButton('Print Cypher Cards') self.cypherCardsPrintButton.setVisible(False) self.cypherCardsPrintButton.clicked.connect(partial(self.cards, True)) self.cypherCardsCopyButton = QPushButton('Copy Cypher Cards') self.cypherCardsCopyButton.setVisible(False) self.cypherCardsCopyButton.clicked.connect(partial(self.cards, False)) cardButtonsLayout.addWidget(self.cypherCardsPrintButton) cardButtonsLayout.addWidget(self.cypherCardsCopyButton) cypherLayout.addLayout(cypherButtonsLayout) cypherLayout.addWidget(self.cypherEdit) cypherLayout.addWidget(self.cypherPreviewLabel) cypherLayout.addWidget(self.cypherPreview) cypherLayout.addLayout(cardButtonsLayout) # Set up donation widgets donationsLayout = QVBoxLayout() separater = QFrame() separater.setFrameShape(QFrame.HLine) self.donationButton = QPushButton('Donate') self.donationButton.setVisible(False) self.donationButton.clicked.connect(self.donate) self.copyEthAddressButton = QPushButton('ETH: Copy Address') self.copyEthAddressButton.clicked.connect( self.copy_eth_donation_address) self.copyEthAddressButton.setVisible(False) self.copyBtcAddressButton = QPushButton('BTC: Copy Address') self.copyBtcAddressButton.clicked.connect( self.copy_btc_donation_address) self.copyBtcAddressButton.setVisible(False) donationsLayout.addWidget(separater) donationsLayout.addWidget(self.donationButton) donationsLayout.addWidget(self.copyEthAddressButton) donationsLayout.addWidget(self.copyBtcAddressButton) # Add all widgets and sub-layouts to the master layout self.master_layout = QVBoxLayout() self.master_layout.addLayout(privateKeyFormatLayout) self.master_layout.addLayout(privateKeyLayout) self.master_layout.addLayout(codeLayout) self.master_layout.addLayout(cypherLayout) self.master_layout.addLayout(donationsLayout) self.master_widget = QWidget() self.master_widget.setLayout(self.master_layout) self.setCentralWidget(self.master_widget) # Start and connect the window resizing thread self.worker = Worker() self.worker.updateWindowSize.connect(self.resize_window) def copy_private_key( self): # Copies the private key text to the system clipboard clip.setText(self.privateKeyEdit.toPlainText()) self.copyPrivateKeyButton.setText('Key Copied') app.processEvents() sleep(2) self.copyPrivateKeyButton.setText('Copy Key') def copy_cypher(self): # Copies the cypher text to the system clipboard clip.setText(self.cypherEdit.toPlainText()) self.copyCypherButton.setText('Cypher Copied') app.processEvents() sleep(2) self.copyCypherButton.setText('Copy Cypher') def copy_eth_donation_address( self): # Copies the ETH donation address to the system clipboard clip.setText(ethDonationAddress) self.copyEthAddressButton.setText('ETH: Address Copied\nThanks!') app.processEvents() sleep(2) self.copyEthAddressButton.setText('ETH: Copy Address') def copy_btc_donation_address( self): # Copies the BTC donation address to the system clipboard clip.setText(btcDonationAddress) self.copyBtcAddressButton.setText('BTC: Address Copied\nThanks!') app.processEvents() sleep(2) self.copyBtcAddressButton.setText('BTC: Copy Address') def get_private_key( self ): # Generates a key of the desired format using two instances of the SystemRandom function privateKey = generate_private_key.start( self.privateKeyTypeCombobox.currentText()) self.privateKeyEdit.setText(privateKey) self.private_key_or_code_changed() self.copyPrivateKeyButton.setDisabled(False) def private_key_or_code_changed( self ): # Changes visibility and ability of some widgets based on user input self.privateKeyLengthLabel.setText( str(len(self.privateKeyEdit.toPlainText()))) self.copyCypherButton.setDisabled(True) self.cypherEdit.setText('') self.cypherPreview.setText('') self.cypherEdit.setVisible(False) self.cypherPreviewLabel.setVisible(False) self.cypherPreview.setVisible(False) if len(self.privateKeyEdit.toPlainText()) <= 2: self.copyPrivateKeyButton.setDisabled(True) self.generateCypherButton.setDisabled(True) self.codeSelect.setDisabled(True) else: self.codeSelect.setMaximum( len(self.privateKeyEdit.toPlainText()) - 1) self.copyPrivateKeyButton.setDisabled(False) self.generateCypherButton.setDisabled(False) self.codeSelect.setDisabled(False) self.cypherCardsPrintButton.setDisabled(True) self.cypherCardsPrintButton.setVisible(False) self.cypherCardsCopyButton.setDisabled(True) self.cypherCardsCopyButton.setVisible(False) self.worker.start() def get_cypher( self ): # Converts the raw key into a cypher based on the codeSelect value if not 1 >= len(self.privateKeyEdit.toPlainText()) >= int( self.privateKeyLengthLabel.text()): self.generateCypherButton.setDisabled(False) cypherRows, cypherSeed = create_cypher.start( self.privateKeyEdit.toPlainText(), self.codeSelect.value()) self.copyCypherButton.setDisabled(False) self.cypherEdit.setVisible(True) self.cypherEdit.setText(cypherSeed) self.cypherPreviewLabel.setVisible(True) self.cypherPreview.setVisible(True) previewText = '' for i in cypherRows: previewText += i + '\n' self.cypherPreview.setText(previewText) self.worker.start() self.cypherCardsPrintButton.setDisabled(False) self.cypherCardsPrintButton.setVisible(True) self.cypherCardsCopyButton.setDisabled(False) self.cypherCardsCopyButton.setVisible(True) self.donationButton.setVisible(True) else: self.generateCypherButton.setDisabled(True) def cards(self, print): # Creates and prints the output.txt file cardList = split_cypher_into_pairs.start(self.cypherEdit.toPlainText()) printString = format_cards.start(cardList) if print: self.cypherCardsPrintButton.setText('Printing') app.processEvents() cards_output.start(printString) self.cypherCardsPrintButton.setText('Print Cypher Cards') else: clip.setText(printString) self.cypherCardsCopyButton.setText('Cards Copied') app.processEvents() sleep(2) self.cypherCardsCopyButton.setText('Copy Cypher Cards') def donate(self): # Adjusts the visibility of the donation buttons if self.donationButton.text() == 'Donate': self.copyEthAddressButton.setVisible(True) self.copyBtcAddressButton.setVisible(True) self.donationButton.setText('Hide') elif self.donationButton.text() == 'Hide': self.copyEthAddressButton.setVisible(False) self.copyBtcAddressButton.setVisible(False) self.donationButton.setText('Donate') self.worker.start() def cleanup(self): # Clears the clipboard of any copied text clip.setText('')
class MainWindow(QMainWindow): def __init__(self): super(MainWindow, self).__init__() self.debug = debug self.progset = QSettings("ADLMIDI-pyGUI", "ADLMIDI-pyGUI") self.about_window = None self.settings_window = None self.paused = False self.MaxRecentFiles = int(self.progset.value("file/MaxRecentFiles", 5)) self.recentList = self.progset.value("file/recent", []) if type(self.recentList) is unicode: self.recentList = [self.recentList] self.banks = [ " 0 = AIL (Star Control 3, Albion, Empire 2, Sensible Soccer, Settlers 2, many others)", "01 = Bisqwit (selection of 4op and 2op)", "02 = HMI (Descent, Asterix)", "03 = HMI (Descent:: Int)", "04 = HMI (Descent:: Ham)", "05 = HMI (Descent:: Rick)", "06 = HMI (Descent 2)", "07 = HMI (Normality)", "08 = HMI (Shattered Steel)", "09 = HMI (Theme Park)", "10 = HMI (3d Table Sports, Battle Arena Toshinden)", "11 = HMI (Aces of the Deep)", "12 = HMI (Earthsiege)", "13 = HMI (Anvil of Dawn)", "14 = DMX (Doom :: partially pseudo 4op)", "15 = DMX (Hexen, Heretic :: partially pseudo 4op)", "16 = DMX (MUS Play :: partially pseudo 4op)", "17 = AIL (Discworld, Grandest Fleet, Pocahontas, Slob Zone 3d, Ultima 4, Zorro)", "18 = AIL (Warcraft 2)", "19 = AIL (Syndicate)", "20 = AIL (Guilty, Orion Conspiracy, Terra Nova Strike Force Centauri :: 4op)", "21 = AIL (Magic Carpet 2)", "22 = AIL (Nemesis)", "23 = AIL (Jagged Alliance)", "24 = AIL (When Two Worlds War :: 4op, MISSING INSTRUMENTS)", "25 = AIL (Bards Tale Construction :: MISSING INSTRUMENTS)", "26 = AIL (Return to Zork)", "27 = AIL (Theme Hospital)", "28 = AIL (National Hockey League PA)", "29 = AIL (Inherit The Earth)", "30 = AIL (Inherit The Earth, file two)", "31 = AIL (Little Big Adventure :: 4op)", "32 = AIL (Wreckin Crew)", "33 = AIL (Death Gate)", "34 = AIL (FIFA International Soccer)", "35 = AIL (Starship Invasion)", "36 = AIL (Super Street Fighter 2 :: 4op)", "37 = AIL (Lords of the Realm :: MISSING INSTRUMENTS)", "38 = AIL (SimFarm, SimHealth :: 4op)", "39 = AIL (SimFarm, Settlers, Serf City)", "40 = AIL (Caesar 2 :: partially 4op, MISSING INSTRUMENTS)", "41 = AIL (Syndicate Wars)", "42 = AIL (Bubble Bobble Feat. Rainbow Islands, Z)", "43 = AIL (Warcraft)", "44 = AIL (Terra Nova Strike Force Centuri :: partially 4op)", "45 = AIL (System Shock :: partially 4op)", "46 = AIL (Advanced Civilization)", "47 = AIL (Battle Chess 4000 :: partially 4op, melodic only)", "48 = AIL (Ultimate Soccer Manager :: partially 4op)", "49 = AIL (Air Bucks, Blue And The Gray, America Invades, Terminator 2029)", "50 = AIL (Ultima Underworld 2)", "51 = AIL (Kasparov's Gambit)", "52 = AIL (High Seas Trader :: MISSING INSTRUMENTS)", "53 = AIL (Master of Magic, Master of Orion 2 :: 4op, std percussion)", "54 = AIL (Master of Magic, Master of Orion 2 :: 4op, orchestral percussion)", "55 = SB (Action Soccer)", "56 = SB (3d Cyberpuck :: melodic only)", "57 = SB (Simon the Sorcerer :: melodic only)", "58 = OP3 (The Fat Man 2op set)", "59 = OP3 (The Fat Man 4op set)", "60 = OP3 (JungleVision 2op set :: melodic only)", "61 = OP3 (Wallace 2op set, Nitemare 3D :: melodic only)", "62 = TMB (Duke Nukem 3D)", "63 = TMB (Shadow Warrior)", "64 = DMX (Raptor)" ] self.openicon = QIcon.fromTheme('document-open', QIcon('img/load.png')) self.saveicon = QIcon.fromTheme('document-save', QIcon('img/save.png')) self.playicon = QIcon.fromTheme('media-playback-start', QIcon('img/play.png')) self.pauseicon = QIcon.fromTheme('media-playback-pause', QIcon('img/pause.png')) self.stopicon = QIcon.fromTheme('media-playback-stop', QIcon('img/stop.png')) self.quiticon = QIcon.fromTheme('application-exit', QIcon('img/quit.png')) self.abouticon = QIcon.fromTheme('help-about', QIcon('img/about.png')) self.setticon = QIcon.fromTheme('preferences-desktop', QIcon('img/settings.png')) self.winsetup() def addWorker(self, worker): worker.message.connect(self.update) worker.finished.connect(self.workerFinished) self.threads.append(worker) def workerFinished(self): pass #barf('MSG', 'Thread completed the task!') def killWorkers(self): pass #for worker in self.threads: # worker.terminate() def winsetup(self): self.setWindowIcon(QIcon('img/note.png')) openFile = QAction(self.openicon, 'Open', self) openFile.setShortcut('Ctrl+O') openFile.triggered.connect(self.load) saveFile = QAction(self.saveicon, 'Save', self) saveFile.setShortcut('Ctrl+S') saveFile.triggered.connect(self.save) playFile = QAction(self.playicon, 'Play', self) playFile.setShortcut('Ctrl+P') playFile.triggered.connect(self.play) pausePlayb = QAction(self.pauseicon, 'Pause', self) pausePlayb.setShortcut('Ctrl+R') pausePlayb.triggered.connect(self.pause) stopPlay = QAction(self.stopicon, 'Stop', self) stopPlay.setShortcut('Ctrl+Z') stopPlay.triggered.connect(self.stop) exitAction = QAction(self.quiticon, 'Quit', self) exitAction.setShortcut('Ctrl+X') exitAction.triggered.connect(self.quit) aboutdlg = QAction(self.abouticon, 'About', self) aboutdlg.setShortcut('Ctrl+A') aboutdlg.triggered.connect(self.about) showSett = QAction(self.setticon, 'Settings', self) showSett.triggered.connect(self.settings) menubar = self.menuBar() fileMenu = menubar.addMenu('&File') configMenu = menubar.addMenu('&Options') configMenu.setStyleSheet("border: 1px solid black;") self.setLooped = QAction('Loop', configMenu, checkable=True) if self.progset.value("sound/Looped") == 'true': self.setLooped.setChecked(True) else: self.setLooped.setChecked(False) self.setLooped.setShortcut('Ctrl+L') self.setAutoplay = QAction('Autoplay', configMenu, checkable=True) if self.progset.value("sound/Autoplay") == 'true': self.setAutoplay.setChecked(True) else: self.setAutoplay.setChecked(False) self.setAutoplay.setShortcut('Ctrl+K') configMenu.addAction(self.setAutoplay) configMenu.addAction(self.setLooped) fileMenu.setStyleSheet("border: 1px solid black;") fileMenu.addAction(openFile) fileMenu.addAction(saveFile) fileMenu.addSeparator() self.recentMenu = fileMenu.addMenu('Recent') self.rfUpdate() fileMenu.addSeparator() fileMenu.addAction(showSett) fileMenu.addSeparator() fileMenu.addAction(exitAction) helpMenu = menubar.addMenu('&Help') helpMenu.setStyleSheet("border: 1px solid black;") helpMenu.addAction(aboutdlg) self.numCards = QSpinBox() numCards_text = QLabel(" OPL : ") self.numCards.setRange(1, 100) self.numCards.setValue(int(self.progset.value("sound/numCards", 3))) self.numCards.valueChanged.connect(self.updateMax4ops) self.fourOps = QSpinBox() fourOps_text = QLabel(" 4op Ch : ") self.fourOps.setRange(0, self.numCards.value()*6) self.fourOps.setValue(int(self.progset.value("sound/fourOps", self.numCards.value()*6))) self.twoOps = QSpinBox() twoOps_text = QLabel(" 2op Ch : ") self.twoOps.setValue((self.numCards.value()*12 - self.fourOps.value())) self.twoOps.setRange(self.twoOps.value(), self.twoOps.value()) toolbar = self.addToolBar('Media') toolbar.addAction(playFile) toolbar.addAction(pausePlayb) toolbar.addAction(stopPlay) toolbar.setMovable(False) toolbar.addSeparator() toolbar.addWidget(numCards_text) toolbar.addWidget(self.numCards) toolbar.addSeparator() toolbar.addWidget(fourOps_text) toolbar.addWidget(self.fourOps) #toolbar.addSeparator() #toolbar.addWidget(twoOps_text) #toolbar.addWidget(self.twoOps) self.statusBar() self.setFixedSize(380, 90) self.center() self.setWindowTitle('ADLMIDI pyGUI') self.show() if self.debug: barf("MSG", "Loaded Main Window", True, False) self.update("ready") self.threads = [] self.addWorker(AdlMidi(1)) self.addWorker(AdlMidiSave(2)) def rfUpdate(self): self.recentMenu.clear() def recentfile(f2l): return lambda: self.load2(f2l) self.recentFileActs = [] recentLength = len(self.recentList) for i in range(self.MaxRecentFiles): try: if i >= recentLength: break rev = (recentLength-1)-i filetoload = self.recentList[rev] filename = path.split(filetoload)[1] self.fileact = QAction(filename, self.recentMenu) self.fileact.triggered.connect(recentfile(filetoload)) self.recentFileActs.append(self.fileact) except Exception: pass for i in range(self.MaxRecentFiles): try: self.recentMenu.addAction(self.recentFileActs[i]) except Exception: pass def get_bank(self): try: selection = self.settings_window.combo.currentText() selection = str(selection[0])+str(selection[1]) return int(selection) except Exception: return 1 def center(self): qr = self.frameGeometry() cp = QDesktopWidget().availableGeometry().center() qr.moveCenter(cp) self.move(qr.topLeft()) def about(self): if self.about_window is None: window = QMessageBox(self) self.about_window = window else: window = self.about_window window = self.about_window window.setWindowIcon(QIcon(self.abouticon)) window.setWindowTitle('About ADLMIDI pyGUI') credits = "<center><b>ADLMIDI pyGUI v%s (%s)</b><br>Developed by Tristy H. \"KittyTristy\"<br>[<a href=\"https://github.com/KittyTristy/ADLMIDI-pyGUI\">Website</a>] [<a href=\"mailto:[email protected]\">Email</a>] <br><br><br>" % (__version__, system()) title = "<b>ADLMIDI pyGUI</b> is a GUI wrapper<br>written in Python for use with..<br><br><b>ADLMIDI: MIDI Player<br>for Linux and Windows with OPL3 emulation</b><br>" cw = "(C) -- <a href=\"http://iki.fi/bisqwit/source/adlmidi.html\">http://iki.fi/bisqwit/source/adlmidi.html</a></center>" credits = credits + title + cw window.setText(credits) window.show() window.activateWindow() window.raise_() def settings(self): if self.settings_window is None: window = QDialog(self) self.settings_window = window else: window = self.settings_window window = self.settings_window window.setWindowTitle('Settings') window.notelabel = QLabel("Currently these settings are only guaranteed to work prior to loading the first MIDI!\nYou'll have to restart ADLMIDI pyGui to change them again if they stop working. \n\nSorry! This will be fixed soon!") window.notelabel.setWordWrap(True) window.notelabel.setStyleSheet("font-size: 8pt; border-style: dotted; border-width: 1px; padding: 12px;") window.banklabel = QLabel("<B>Choose Instrument Bank</B>") window.space = QLabel("") window.optlabel = QLabel("<B>Options</B>") window.combo = QComboBox() window.combo.addItems(self.banks) #window.combo.setMaximumWidth(350) window.combo.setMaxVisibleItems(12) window.combo.setStyleSheet("combobox-popup: 0;") window.combo.setCurrentIndex(int(self.progset.value("sound/bank", 1))) window.combo.currentIndexChanged.connect(self.saveSettings) window.perc = QCheckBox("Adlib Percussion Instrument Mode") #window.perc.stateChanged.connect(self.checkOpts) window.tremamp = QCheckBox("Tremolo Amplification Mode") #window.tremamp.stateChanged.connect(self.checkOpts) window.vibamp = QCheckBox("Vibrato Amplification Mode") #window.vibamp.stateChanged.connect(self.checkOpts) window.modscale = QCheckBox("Scaling of Modulator Volume") #window.modscale.stateChanged.connect(self.checkOpts) window.okButton = QPushButton('OK') window.okButton.clicked.connect(window.hide) vbox = QVBoxLayout() vbox.addWidget(window.space) vbox.addWidget(window.banklabel) vbox.addWidget(window.combo) vbox.addWidget(window.space) vbox.addWidget(window.optlabel) vbox.addWidget(window.perc) vbox.addWidget(window.tremamp) vbox.addWidget(window.vibamp) vbox.addWidget(window.modscale) vbox.addWidget(window.notelabel) hbox = QHBoxLayout() hbox.addStretch(1) hbox.addWidget(window.okButton) vbox.addLayout(hbox) window.setLayout(vbox) window.setFixedSize(530, 369) window.show() window.activateWindow() window.raise_() def updateMax4ops(self): self.fourOps.setMaximum(self.numCards.value()*6) self.fourOps.setValue(self.numCards.value()*6) barf("DBG", "Updating Maximum of 4ops Chs to %s" % (self.numCards.value()*6), True, False) #self.twoOps.setValue(self.numCards.value()*12 - self.fourOps.value()) #self.twoOps.setRange(self.twoOps.value(), self.twoOps.value()) def checkOpts(self): global arglist #barf("ACT", "Checking if Options have changed..", True, False) arglist = [] try: if QAbstractButton.isChecked(self.settings_window.perc) and not ('-p' in arglist): arglist.append('-p') elif not QAbstractButton.isChecked(self.settings_window.perc) and ('-p' in arglist): arglist.remove('-p') except Exception: pass try: if QAbstractButton.isChecked(self.settings_window.tremamp) and not ('-t' in arglist): arglist.append('-t') elif not QAbstractButton.isChecked(self.settings_window.tremamp) and ('-t' in arglist): arglist.remove('-t') except Exception: pass try: if QAbstractButton.isChecked(self.settings_window.vibamp) and not ('-v' in arglist): arglist.append('-v') elif not QAbstractButton.isChecked(self.settings_window.vibamp) and ('-v' in arglist): arglist.remove('-v') except Exception: pass try: if QAbstractButton.isChecked(self.settings_window.modscale) and not ('-s' in arglist): arglist.append('-s') elif not QAbstractButton.isChecked(self.settings_window.modscale) and ('-s' in arglist): arglist.remove('-s') except Exception: pass self.sel_bank = self.get_bank() def saveSettings(self): self.progset.setValue("sound/Autoplay", self.setAutoplay.isChecked()) self.progset.setValue("sound/Looped", self.setLooped.isChecked()) self.progset.setValue("sound/numCards", self.numCards.value()) self.progset.setValue("sound/fourOps", self.fourOps.value()) try: self.progset.setValue("sound/bank", self.settings_window.combo.currentIndex()) except Exception: pass if len(self.recentList) >= 1: self.progset.setValue("file/recent", self.recentList[-self.MaxRecentFiles:]) self.progset.setValue("file/MaxRecentFiles", self.MaxRecentFiles) #allkeys = self.progset.allKeys() #for key in allkeys: # barf('DBG', str(key) + " " + str(self.progset.value(key))) def closeEvent(self, event): self.stop() #self.pkill() self.saveSettings() barf("DBG", "Quitting", True, False) def quit(self): self.stop() #self.pkill() self.saveSettings() barf("DBG", "Quitting", True, False) exit(0) def pkill(self): try: p.kill() except Exception: pass ############################################################## ##### Statusbar Functions #################################### ############################################################## def clear(self): try: self.statusBar().removeWidget(self.playStatus) except Exception: pass @Slot(str) def update(self, status=''): self.clear() if status == "ready": text = " <B>Ready</b>" elif status == "play": text = " <B>Now Playing: </B>" + path.split(f.name)[1] elif status == "loop": text = " <B>Looping: </B>" + path.split(f.name)[1] elif status == "stop": text = " <B>Stopped: </B>" + path.split(f.name)[1] elif status == "pause": text = " <B>Paused: </B>" + path.split(f.name)[1] elif status == "loading": text = " <B>Loading.. </B>" elif status == "load": text = " <B>Loaded: </B>" + path.split(f.name)[1] elif status == "saving": text = " <B>Saving.. </B>" elif status == "saved": text = " <B>Saved as: </B>" + "saved/" + path.splitext(path.split(f.name)[1])[0] + ".wav" self.playStatus = QLabel(text) self.statusBar().addPermanentWidget(self.playStatus, 1) ############################################################## ####### Sound Functions ###################################### ############################################################## def play(self): global Paused, arglist if f != None and Paused == False: Paused = False self.stop() self.checkOpts() if not self.setLooped.isChecked(): arglist.append('-nl') arglist.append(str(self.progset.value("sound/bank", 1))) arglist.append(str(self.numCards.value())) arglist.append(str(self.fourOps.value())) for worker in self.threads: if worker.id == 1: worker.start() elif f != None and Paused == True: os.kill(p.pid, signal.SIGCONT) self.update("play") Paused = False def pause(self): global p, Paused if f != None: try: if Paused == False: os.kill(p.pid, signal.SIGSTOP) self.update("pause") Paused = True elif Paused == True: os.kill(p.pid, signal.SIGCONT) self.update("play") Paused = False except Exception: pass def stop(self): global Paused if f != None: Paused = False self.pkill() self.killWorkers() self.update("stop") ############################################################## ##### Load/Save Functions #################################### ############################################################## def load(self): global f lastdir = str(self.progset.value("file/lastdir", "")) fname, _ = QFileDialog.getOpenFileName(None, 'Open File', lastdir, "MIDI Audio File (*.mid *.MID)") if fname != "": f = file(fname, 'r') if not f.name in self.recentList: self.recentList.append(f.name) else: self.recentList.remove(f.name) self.recentList.append(f.name) self.progset.setValue("file/lastdir", path.split(f.name)[0]) self.rfUpdate() self.update("load") self.pkill() if self.debug: barf("SAV", "Loaded %s" % path.split(f.name)[1], True, False) if self.setAutoplay.isChecked(): self.play() else: self.update("load") def load2(self, r_file=None): global f f = file(r_file, 'r') self.recentList.remove(f.name) self.recentList.append(f.name) self.rfUpdate() self.update("load") self.pkill() if self.debug: barf("SAV", "Loaded %s" % path.split(f.name)[1], True, False) if self.setAutoplay.isChecked(): self.play() else: self.update("load") def save(self): if f != None: self.stop() for worker in self.threads: if worker.id == 2: worker.start()