class ConfigWidget(QWidget):
def __init__(self, parent=None):
QWidget.__init__(self, parent)
layout = QFormLayout()
self.setLayout(layout)
self.label_ip = QLabel("IP")
self.lineedit_ip = QLineEdit()
layout.addRow(self.label_ip, self.lineedit_ip)
self.label_port = QLabel("Port")
self.spinbox_port = QSpinBox()
self.spinbox_port.setMinimum(0)
self.spinbox_port.setMaximum(65535)
layout.addRow(self.label_port, self.spinbox_port)
self.label_password = QLabel("Password")
self.lineedit_password = QLineEdit()
layout.addRow(self.label_password, self.lineedit_password)
self.label_mount = QLabel("Mount")
self.lineedit_mount = QLineEdit()
layout.addRow(self.label_mount, self.lineedit_mount)
#
# Audio Quality
#
self.label_audio_quality = QLabel("Audio Quality")
self.spinbox_audio_quality = QDoubleSpinBox()
self.spinbox_audio_quality.setMinimum(0.0)
self.spinbox_audio_quality.setMaximum(1.0)
self.spinbox_audio_quality.setSingleStep(0.1)
self.spinbox_audio_quality.setDecimals(1)
self.spinbox_audio_quality.setValue(0.3) # Default value 0.3
#
# Video Quality
#
self.label_video_quality = QLabel("Video Quality (kb/s)")
self.spinbox_video_quality = QSpinBox()
self.spinbox_video_quality.setMinimum(0)
self.spinbox_video_quality.setMaximum(16777215)
self.spinbox_video_quality.setValue(2400) # Default value 2400
def get_video_quality_layout(self):
layout_video_quality = QHBoxLayout()
layout_video_quality.addWidget(self.label_video_quality)
layout_video_quality.addWidget(self.spinbox_video_quality)
return layout_video_quality
def get_audio_quality_layout(self):
layout_audio_quality = QHBoxLayout()
layout_audio_quality.addWidget(self.label_audio_quality)
layout_audio_quality.addWidget(self.spinbox_audio_quality)
return layout_audio_quality
class IntegerParameterWidget(NumericParameterWidget):
"""Widget class for Integer parameter."""
def __init__(self, parameter, parent=None):
"""Constructor
.. versionadded:: 2.2
:param parameter: A IntegerParameter object.
:type parameter: IntegerParameter
"""
super(IntegerParameterWidget, self).__init__(parameter, parent)
self._input = QSpinBox()
self._input.setValue(self._parameter.value)
self._input.setMinimum(self._parameter.minimum_allowed_value)
self._input.setMaximum(self._parameter.maximum_allowed_value)
tool_tip = 'Choose a number between %d and %d' % (
self._parameter.minimum_allowed_value,
self._parameter.maximum_allowed_value)
self._input.setToolTip(tool_tip)
self._input.setSizePolicy(self._spin_box_size_policy)
self.inner_input_layout.addWidget(self._input)
self.inner_input_layout.addWidget(self._unit_widget)
def __init__(self, parent, prefix = None, suffix = None, option = None, min_ = None, max_ = None,
step = None, tip = None, value = None, changed =None):
super(MySpinBox, self).__init__(parent)
if prefix:
plabel = QLabel(prefix)
else:
plabel = None
if suffix:
slabel = QLabel(suffix)
else:
slabel = None
spinbox = QSpinBox(parent)
if min_ is not None:
spinbox.setMinimum(min_)
if max_ is not None:
spinbox.setMaximum(max_)
if step is not None:
spinbox.setSingleStep(step)
if tip is not None:
spinbox.setToolTip(tip)
layout = QHBoxLayout()
for subwidget in (plabel, spinbox, slabel):
if subwidget is not None:
layout.addWidget(subwidget)
if value is not None:
spinbox.setValue(value)
if changed is not None:
self.connect(spinbox, SIGNAL('valueChanged(int)'), changed)
layout.addStretch(1)
layout.setContentsMargins(0, 0, 0, 0)
self.setLayout(layout)
self.spin = spinbox
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 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()
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 ProjectData(QWidget):
def __init__(self, parent):
super(ProjectData, self).__init__()
self._parent = parent
grid = QGridLayout(self)
grid.addWidget(QLabel(self.tr("Name:")), 0, 0)
self.name = QLineEdit()
if self._parent._item.name == '':
self.name.setText(file_manager.get_basename(
self._parent._item.path))
else:
self.name.setText(self._parent._item.name)
grid.addWidget(self.name, 0, 1)
grid.addWidget(QLabel(self.tr("Project Type:")), 1, 0)
self.txtType = QLineEdit()
completer = QCompleter(sorted(settings.PROJECT_TYPES))
completer.setCompletionMode(QCompleter.UnfilteredPopupCompletion)
self.txtType.setCompleter(completer)
self.txtType.setText(self._parent._item.projectType)
grid.addWidget(self.txtType, 1, 1)
grid.addWidget(QLabel(self.tr("Description:")), 2, 0)
self.description = QPlainTextEdit()
self.description.setPlainText(self._parent._item.description)
grid.addWidget(self.description, 2, 1)
grid.addWidget(QLabel(self.tr("URL:")), 3, 0)
self.url = QLineEdit()
self.url.setText(self._parent._item.url)
grid.addWidget(self.url, 3, 1)
grid.addWidget(QLabel(self.tr("Licence:")), 4, 0)
self.cboLicense = QComboBox()
self.cboLicense.addItem('Apache License 2.0')
self.cboLicense.addItem('Artistic License/GPL')
self.cboLicense.addItem('Eclipse Public License 1.0')
self.cboLicense.addItem('GNU General Public License v2')
self.cboLicense.addItem('GNU General Public License v3')
self.cboLicense.addItem('GNU Lesser General Public License')
self.cboLicense.addItem('MIT License')
self.cboLicense.addItem('Mozilla Public License 1.1')
self.cboLicense.addItem('New BSD License')
self.cboLicense.addItem('Other Open Source')
self.cboLicense.addItem('Other')
self.cboLicense.setCurrentIndex(4)
index = self.cboLicense.findText(self._parent._item.license)
self.cboLicense.setCurrentIndex(index)
grid.addWidget(self.cboLicense, 4, 1)
self.txtExtensions = QLineEdit()
self.txtExtensions.setText(', '.join(self._parent._item.extensions))
grid.addWidget(QLabel(self.tr("Supported Extensions:")), 5, 0)
grid.addWidget(self.txtExtensions, 5, 1)
grid.addWidget(QLabel(self.tr("Indentation: ")), 6, 0)
self.spinIndentation = QSpinBox()
self.spinIndentation.setValue(self._parent._item.indentation)
self.spinIndentation.setMinimum(1)
grid.addWidget(self.spinIndentation, 6, 1)
self.checkUseTabs = QCheckBox(self.tr("Use Tabs."))
self.checkUseTabs.setChecked(self._parent._item.useTabs)
grid.addWidget(self.checkUseTabs, 6, 2)
class ProjectData(QWidget):
def __init__(self, parent):
super(ProjectData, self).__init__()
self._parent = parent
grid = QGridLayout(self)
grid.addWidget(QLabel(self.tr("Name:")), 0, 0)
self.name = QLineEdit()
if self._parent._item.name == '':
self.name.setText(
file_manager.get_basename(self._parent._item.path))
else:
self.name.setText(self._parent._item.name)
grid.addWidget(self.name, 0, 1)
grid.addWidget(QLabel(self.tr("Project Type:")), 1, 0)
self.txtType = QLineEdit()
completer = QCompleter(sorted(settings.PROJECT_TYPES))
completer.setCompletionMode(QCompleter.UnfilteredPopupCompletion)
self.txtType.setCompleter(completer)
self.txtType.setText(self._parent._item.projectType)
grid.addWidget(self.txtType, 1, 1)
grid.addWidget(QLabel(self.tr("Description:")), 2, 0)
self.description = QPlainTextEdit()
self.description.setPlainText(self._parent._item.description)
grid.addWidget(self.description, 2, 1)
grid.addWidget(QLabel(self.tr("URL:")), 3, 0)
self.url = QLineEdit()
self.url.setText(self._parent._item.url)
grid.addWidget(self.url, 3, 1)
grid.addWidget(QLabel(self.tr("Licence:")), 4, 0)
self.cboLicense = QComboBox()
self.cboLicense.addItem('Apache License 2.0')
self.cboLicense.addItem('Artistic License/GPL')
self.cboLicense.addItem('Eclipse Public License 1.0')
self.cboLicense.addItem('GNU General Public License v2')
self.cboLicense.addItem('GNU General Public License v3')
self.cboLicense.addItem('GNU Lesser General Public License')
self.cboLicense.addItem('MIT License')
self.cboLicense.addItem('Mozilla Public License 1.1')
self.cboLicense.addItem('New BSD License')
self.cboLicense.addItem('Other Open Source')
self.cboLicense.addItem('Other')
self.cboLicense.setCurrentIndex(4)
index = self.cboLicense.findText(self._parent._item.license)
self.cboLicense.setCurrentIndex(index)
grid.addWidget(self.cboLicense, 4, 1)
self.txtExtensions = QLineEdit()
self.txtExtensions.setText(', '.join(self._parent._item.extensions))
grid.addWidget(QLabel(self.tr("Supported Extensions:")), 5, 0)
grid.addWidget(self.txtExtensions, 5, 1)
grid.addWidget(QLabel(self.tr("Indentation: ")), 6, 0)
self.spinIndentation = QSpinBox()
self.spinIndentation.setValue(self._parent._item.indentation)
self.spinIndentation.setMinimum(1)
grid.addWidget(self.spinIndentation, 6, 1)
self.checkUseTabs = QCheckBox(self.tr("Use Tabs."))
self.checkUseTabs.setChecked(self._parent._item.useTabs)
grid.addWidget(self.checkUseTabs, 6, 2)
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))
def __init__(self, advanced_option=False):
SimulationConfigPanel.__init__(self, IteratedEnsembleSmoother(),
advanced_option)
layout = QFormLayout()
case_selector = CaseSelector()
layout.addRow("Current case:", case_selector)
run_path_label = QLabel("<b>%s</b>" % getRunPath())
addHelpToWidget(run_path_label, "config/simulation/runpath")
layout.addRow("Runpath:", run_path_label)
number_of_realizations_label = QLabel("<b>%d</b>" %
getRealizationCount())
addHelpToWidget(number_of_realizations_label,
"config/ensemble/num_realizations")
layout.addRow(QLabel("Number of realizations:"),
number_of_realizations_label)
# The num_iterations_spinner does not track any external changes (will that ever happen?)
num_iterations_spinner = QSpinBox()
num_iterations_spinner.setMinimum(1)
num_iterations_spinner.setMaximum(100)
num_iterations_spinner.setValue(getNumberOfIterations())
addHelpToWidget(num_iterations_spinner,
"config/simulation/number_of_iterations")
num_iterations_spinner.valueChanged[int].connect(setNumberOfIterations)
layout.addRow("Number of iterations:", num_iterations_spinner)
self._iterated_target_case_format_model = TargetCaseModel(
format_mode=True)
self._iterated_target_case_format_field = StringBox(
self._iterated_target_case_format_model,
"config/simulation/iterated_target_case_format")
self._iterated_target_case_format_field.setValidator(
ProperNameFormatArgument())
layout.addRow("Target case format:",
self._iterated_target_case_format_field)
self._analysis_module_selector = AnalysisModuleSelector(
iterable=True, help_link="config/analysis/analysis_module")
layout.addRow("Analysis Module:", self._analysis_module_selector)
self._active_realizations_model = ActiveRealizationsModel()
self._active_realizations_field = StringBox(
self._active_realizations_model,
"config/simulation/active_realizations")
self._active_realizations_field.setValidator(
RangeStringArgument(getRealizationCount()))
layout.addRow("Active realizations", self._active_realizations_field)
self._iterated_target_case_format_field.getValidationSupport(
).validationChanged.connect(self.simulationConfigurationChanged)
self._active_realizations_field.getValidationSupport(
).validationChanged.connect(self.simulationConfigurationChanged)
self.setLayout(layout)
def int_widget(self, start_val, min_val=-100, max_val=100, step=1):
""" Returns an int widget with the given values.
"""
box = QSpinBox()
box.setRange(min_val, max_val)
box.setValue(start_val)
box.setSingleStep(step)
return box
class ProjectData(QWidget):
def __init__(self, parent):
super(ProjectData, self).__init__()
self._parent = parent
grid = QGridLayout(self)
grid.addWidget(QLabel(translations.TR_PROJECT_NAME), 0, 0)
self.name = QLineEdit()
if not len(self._parent.project.name):
self.name.setText(file_manager.get_basename(
self._parent.project.path))
else:
self.name.setText(self._parent.project.name)
grid.addWidget(self.name, 0, 1)
grid.addWidget(QLabel(translations.TR_PROJECT_LOCATION), 1, 0)
self.txtPath = QLineEdit()
self.txtPath.setReadOnly(True)
self.txtPath.setText(self._parent.project.path)
grid.addWidget(self.txtPath, 1, 1)
grid.addWidget(QLabel(translations.TR_PROJECT_TYPE), 2, 0)
self.txtType = QLineEdit()
completer = QCompleter(sorted(settings.PROJECT_TYPES))
completer.setCompletionMode(QCompleter.UnfilteredPopupCompletion)
self.txtType.setCompleter(completer)
self.txtType.setText(self._parent.project.project_type)
grid.addWidget(self.txtType, 2, 1)
grid.addWidget(QLabel(translations.TR_PROJECT_DESCRIPTION), 3, 0)
self.description = QPlainTextEdit()
self.description.setPlainText(self._parent.project.description)
grid.addWidget(self.description, 3, 1)
grid.addWidget(QLabel(translations.TR_PROJECT_URL), 4, 0)
self.url = QLineEdit()
self.url.setText(self._parent.project.url)
self.url.setPlaceholderText('https://www.{}.com'.format(getuser()))
grid.addWidget(self.url, 4, 1)
grid.addWidget(QLabel(translations.TR_PROJECT_LICENSE), 5, 0)
self.cboLicense = QComboBox()
self.cboLicense.addItems(LICENCES)
self.cboLicense.setCurrentIndex(12)
index = self.cboLicense.findText(self._parent.project.license)
self.cboLicense.setCurrentIndex(index)
grid.addWidget(self.cboLicense, 5, 1)
self.txtExtensions = QLineEdit()
self.txtExtensions.setText(', '.join(self._parent.project.extensions))
grid.addWidget(QLabel(translations.TR_PROJECT_EXTENSIONS), 6, 0)
grid.addWidget(self.txtExtensions, 6, 1)
grid.addWidget(QLabel(translations.TR_PROJECT_INDENTATION), 7, 0)
self.spinIndentation = QSpinBox()
self.spinIndentation.setValue(self._parent.project.indentation)
self.spinIndentation.setRange(2, 10)
self.spinIndentation.setValue(4)
self.spinIndentation.setSingleStep(2)
grid.addWidget(self.spinIndentation, 7, 1)
self.checkUseTabs = QCheckBox(translations.TR_PROJECT_USE_TABS)
self.checkUseTabs.setChecked(self._parent.project.use_tabs)
grid.addWidget(self.checkUseTabs, 7, 2)
class ProjectData(QWidget):
def __init__(self, parent):
super(ProjectData, self).__init__()
self._parent = parent
grid = QGridLayout(self)
grid.addWidget(QLabel(translations.TR_PROJECT_NAME), 0, 0)
self.name = QLineEdit()
if not len(self._parent.project.name):
self.name.setText(
file_manager.get_basename(self._parent.project.path))
else:
self.name.setText(self._parent.project.name)
grid.addWidget(self.name, 0, 1)
grid.addWidget(QLabel(translations.TR_PROJECT_LOCATION), 1, 0)
self.txtPath = QLineEdit()
self.txtPath.setReadOnly(True)
self.txtPath.setText(self._parent.project.path)
grid.addWidget(self.txtPath, 1, 1)
grid.addWidget(QLabel(translations.TR_PROJECT_TYPE), 2, 0)
self.txtType = QLineEdit()
completer = QCompleter(sorted(settings.PROJECT_TYPES))
completer.setCompletionMode(QCompleter.UnfilteredPopupCompletion)
self.txtType.setCompleter(completer)
self.txtType.setText(self._parent.project.project_type)
grid.addWidget(self.txtType, 2, 1)
grid.addWidget(QLabel(translations.TR_PROJECT_DESCRIPTION), 3, 0)
self.description = QPlainTextEdit()
self.description.setPlainText(self._parent.project.description)
grid.addWidget(self.description, 3, 1)
grid.addWidget(QLabel(translations.TR_PROJECT_URL), 4, 0)
self.url = QLineEdit()
self.url.setText(self._parent.project.url)
self.url.setPlaceholderText('https://www.{}.com'.format(getuser()))
grid.addWidget(self.url, 4, 1)
grid.addWidget(QLabel(translations.TR_PROJECT_LICENSE), 5, 0)
self.cboLicense = QComboBox()
self.cboLicense.addItems(LICENCES)
self.cboLicense.setCurrentIndex(12)
index = self.cboLicense.findText(self._parent.project.license)
self.cboLicense.setCurrentIndex(index)
grid.addWidget(self.cboLicense, 5, 1)
self.txtExtensions = QLineEdit()
self.txtExtensions.setText(', '.join(self._parent.project.extensions))
grid.addWidget(QLabel(translations.TR_PROJECT_EXTENSIONS), 6, 0)
grid.addWidget(self.txtExtensions, 6, 1)
grid.addWidget(QLabel(translations.TR_PROJECT_INDENTATION), 7, 0)
self.spinIndentation = QSpinBox()
self.spinIndentation.setValue(self._parent.project.indentation)
self.spinIndentation.setRange(2, 10)
self.spinIndentation.setValue(4)
self.spinIndentation.setSingleStep(2)
grid.addWidget(self.spinIndentation, 7, 1)
self.checkUseTabs = QCheckBox(translations.TR_PROJECT_USE_TABS)
self.checkUseTabs.setChecked(self._parent.project.use_tabs)
grid.addWidget(self.checkUseTabs, 7, 2)
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))
def createSpinBox(self, variable_name, variable_value, variable_type, analysis_module_variables_model):
spinner = QSpinBox()
spinner.setMinimumWidth(75)
spinner.setMaximum(analysis_module_variables_model.getVariableMaximumValue(variable_name))
spinner.setMinimum(analysis_module_variables_model.getVariableMinimumValue(variable_name))
spinner.setSingleStep(analysis_module_variables_model.getVariableStepValue(variable_name))
if variable_value is not None:
spinner.setValue(variable_value)
spinner.valueChanged.connect(partial(self.valueChanged, variable_name, variable_type, spinner))
return spinner
def __init__(self, parent, connPlugin, logger):
super(statTimelineTab, self).__init__(parent)
lay = QGridLayout(self)
vw = statTimelineWidget(parent, connPlugin, logger)
lay.addWidget(vw, 0, 0, 1, 2)
lay.addWidget(QLabel("Scale:"), 1, 0, Qt.AlignRight)
spinbox = QSpinBox(self)
spinbox.setValue(vw.getScale())
spinbox.valueChanged.connect(vw.setScale)
lay.addWidget(spinbox, 1, 1)
def createSpinBox(self, variable_name, variable_value, variable_type, analysis_module_variables_model):
spinner = QSpinBox()
spinner.setMinimumWidth(75)
spinner.setMaximum(analysis_module_variables_model.getVariableMaximumValue(variable_name))
spinner.setMinimum(analysis_module_variables_model.getVariableMinimumValue(variable_name))
spinner.setSingleStep(analysis_module_variables_model.getVariableStepValue(variable_name))
if variable_value is not None:
spinner.setValue(variable_value)
spinner.valueChanged.connect(partial(self.valueChanged, variable_name, variable_type, spinner))
return spinner
class Updates(QWidget):
def __init__(self, pref):
QWidget.__init__(self)
vbox = QVBoxLayout(self)
vbox.addWidget(QLabel('Set the interval for updates:'))
self.spin = QSpinBox()
self.spin.setRange(1, 60)
self.spin.setSuffix(' minutes')
self.spin.setValue(pref.get('time', 10))
vbox.addWidget(self.spin)
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 ConfigWidget(QWidget):
def __init__(self, parent=None):
QWidget.__init__(self, parent)
layout = QFormLayout()
self.setLayout(layout)
#
# Audio Quality
#
self.label_audio_quality = QLabel("Audio Quality")
self.spinbox_audio_quality = QDoubleSpinBox()
self.spinbox_audio_quality.setMinimum(0.0)
self.spinbox_audio_quality.setMaximum(1.0)
self.spinbox_audio_quality.setSingleStep(0.1)
self.spinbox_audio_quality.setDecimals(1)
self.spinbox_audio_quality.setValue(0.3) # Default value 0.3
#
# Video Quality
#
self.label_video_quality = QLabel("Video Quality (kb/s)")
self.spinbox_video_quality = QSpinBox()
self.spinbox_video_quality.setMinimum(0)
self.spinbox_video_quality.setMaximum(16777215)
self.spinbox_video_quality.setValue(2400) # Default value 2400
#
# Misc.
#
self.label_matterhorn = QLabel("Matterhorn Metadata")
self.label_matterhorn.setToolTip("Generates Matterhorn Metadata in XML format")
self.checkbox_matterhorn = QCheckBox()
layout.addRow(self.label_matterhorn, self.checkbox_matterhorn)
def get_video_quality_layout(self):
layout_video_quality = QHBoxLayout()
layout_video_quality.addWidget(self.label_video_quality)
layout_video_quality.addWidget(self.spinbox_video_quality)
return layout_video_quality
def get_audio_quality_layout(self):
layout_audio_quality = QHBoxLayout()
layout_audio_quality.addWidget(self.label_audio_quality)
layout_audio_quality.addWidget(self.spinbox_audio_quality)
return layout_audio_quality
class ConfigWidget(QWidget):
def __init__(self, parent=None):
QWidget.__init__(self, parent)
layout = QFormLayout()
self.setLayout(layout)
#
# Audio Quality
#
self.label_audio_quality = QLabel("Audio Quality")
self.spinbox_audio_quality = QDoubleSpinBox()
self.spinbox_audio_quality.setMinimum(0.0)
self.spinbox_audio_quality.setMaximum(1.0)
self.spinbox_audio_quality.setSingleStep(0.1)
self.spinbox_audio_quality.setDecimals(1)
self.spinbox_audio_quality.setValue(0.3) # Default value 0.3
#
# Video Quality
#
self.label_video_quality = QLabel("Video Quality (kb/s)")
self.spinbox_video_quality = QSpinBox()
self.spinbox_video_quality.setMinimum(0)
self.spinbox_video_quality.setMaximum(16777215)
self.spinbox_video_quality.setValue(2400) # Default value 2400
#
# Misc.
#
self.label_matterhorn = QLabel("Matterhorn Metadata")
self.label_matterhorn.setToolTip(
"Generates Matterhorn Metadata in XML format")
self.checkbox_matterhorn = QCheckBox()
layout.addRow(self.label_matterhorn, self.checkbox_matterhorn)
def get_video_quality_layout(self):
layout_video_quality = QHBoxLayout()
layout_video_quality.addWidget(self.label_video_quality)
layout_video_quality.addWidget(self.spinbox_video_quality)
return layout_video_quality
def get_audio_quality_layout(self):
layout_audio_quality = QHBoxLayout()
layout_audio_quality.addWidget(self.label_audio_quality)
layout_audio_quality.addWidget(self.spinbox_audio_quality)
return layout_audio_quality
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)
def __init__(self):
super(TestWindow, self).__init__()
self.setWindowTitle("LivePlot Example Runner")
layout = QHBoxLayout(self)
button_layout = QVBoxLayout()
time_layout = QHBoxLayout()
time_spin = QSpinBox()
self.timer = QTimer()
time_spin.valueChanged.connect(self.timer.setInterval)
self.timer.timeout.connect(self.iterate)
self.progress_bar = QProgressBar()
time_spin.setValue(50)
time_spin.setRange(0, 1000)
time_layout.addWidget(QLabel("Sleep Time (ms)"))
time_layout.addWidget(time_spin)
button_layout.addLayout(time_layout)
tests = {
'plot y': test_plot_y,
'plot xy': test_plot_xy,
'plot parametric': test_plot_xy_parametric,
'plot z': test_plot_z,
'plot huge': test_plot_huge,
'append y': test_append_y,
'append xy': test_append_xy,
'append z': test_append_z,
'label': test_label,
}
fn_text_widget = QPlainTextEdit()
fn_text_widget.setMinimumWidth(500)
def make_set_iterator(iter):
def set_iterator():
fn_text_widget.setPlainText(inspect.getsource(iter))
QApplication.instance().processEvents()
self.iterator = iter()
self.timer.start()
return set_iterator
for name, iter in tests.items():
button = QPushButton(name)
button.clicked.connect(make_set_iterator(iter))
button_layout.addWidget(button)
layout.addLayout(button_layout)
text_layout = QVBoxLayout()
text_layout.addWidget(fn_text_widget)
text_layout.addWidget(self.progress_bar)
layout.addLayout(text_layout)
def __init__(self):
super(TestWindow, self).__init__()
self.setWindowTitle("LivePlot Example Runner")
layout = QHBoxLayout(self)
button_layout = QVBoxLayout()
time_layout = QHBoxLayout()
time_spin = QSpinBox()
self.timer = QTimer()
time_spin.valueChanged.connect(self.timer.setInterval)
self.timer.timeout.connect(self.iterate)
self.progress_bar = QProgressBar()
time_spin.setValue(50)
time_spin.setRange(0, 1000)
time_layout.addWidget(QLabel("Sleep Time (ms)"))
time_layout.addWidget(time_spin)
button_layout.addLayout(time_layout)
tests = {
'plot y': test_plot_y,
'plot xy': test_plot_xy,
'plot parametric': test_plot_xy_parametric,
'plot z': test_plot_z,
'plot huge': test_plot_huge,
'append y': test_append_y,
'append xy': test_append_xy,
'append z': test_append_z,
}
fn_text_widget = QPlainTextEdit()
fn_text_widget.setMinimumWidth(500)
def make_set_iterator(iter):
def set_iterator():
fn_text_widget.setPlainText(inspect.getsource(iter))
QApplication.instance().processEvents()
self.iterator = iter()
self.timer.start()
return set_iterator
for name, iter in tests.items():
button = QPushButton(name)
button.clicked.connect(make_set_iterator(iter))
button_layout.addWidget(button)
layout.addLayout(button_layout)
text_layout = QVBoxLayout()
text_layout.addWidget(fn_text_widget)
text_layout.addWidget(self.progress_bar)
layout.addLayout(text_layout)
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 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()
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 ConnectDialog(QDialog):
def __init__(self, parent = None):
QDialog.__init__(self, parent)
self.setWindowTitle("Connect To Game")
self.hostEdit = QLineEdit()
self.hostEdit.setText("127.0.0.1")
self.portEdit = QSpinBox()
self.portEdit.setRange(0, 2 ** 16)
self.portEdit.setValue(9002)
connect = QPushButton("Connect")
connect.released.connect(self.accept)
layout = QFormLayout()
layout.addRow("Host", self.hostEdit)
layout.addRow("Port", self.portEdit)
layout.addRow(connect)
self.setLayout(layout)
def __init__(self, parent, connPlugin, logger):
super(statSwarmTab, self).__init__(parent)
lay = QGridLayout(self)
vw = statSwarmWidget(parent, connPlugin, logger)
lay.addWidget(vw, 0, 0, 0, 4)
lay.addWidget(QLabel("Period:"), 1, 0, Qt.AlignRight)
spinbox = QSpinBox(self)
spinbox.setValue(vw.getPeriod())
spinbox.valueChanged.connect(vw.setPeriod)
lay.addWidget(spinbox, 1, 1)
lay.addWidget(QLabel("mType Filter:"), 1, 2, Qt.AlignRight)
tBox = QLineEdit(self)
tBox.setText(vw.getmType())
tBox.textChanged.connect(vw.setmType)
lay.addWidget(tBox, 1, 3)
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 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()
def _initInsertPositionTableWithExtents(self, axes, mx):
positionTbl = self.positionWidget
tblHeaders = ["insert at", "max"]
positionTbl.setColumnCount(len(tblHeaders))
positionTbl.setHorizontalHeaderLabels(tblHeaders)
positionTbl.resizeColumnsToContents()
tagged_insert = collections.OrderedDict(zip(axes, self.imageOffsets))
tagged_max = collections.OrderedDict(zip(axes, mx))
self._tagged_insert = tagged_insert
positionTbl.setRowCount(len(tagged_insert))
positionTbl.setVerticalHeaderLabels(tagged_insert.keys())
self._insert_position_boxes.clear()
for row, (axis_key, extent) in enumerate(tagged_max.items()):
# Init min/max spinboxes
default_insert = tagged_insert[axis_key] or 0
default_max = tagged_max[axis_key] or extent
insertBox = QSpinBox(self)
maxBox = QLabel(str(default_max), self)
insertBox.setValue(0)
insertBox.setMinimum(0)
insertBox.setMaximum(extent)
insertBox.setEnabled( tagged_insert[axis_key] is not None )
if insertBox.isEnabled():
insertBox.setValue( default_insert )
# TODO: maxBox shouldn't be in tab list (but it still is)
maxBox.setTextInteractionFlags(Qt.NoTextInteraction)
maxBox.setFocusPolicy(Qt.NoFocus)
maxBox.setEnabled(False)
insertBox.valueChanged.connect( self._updatePosition )
positionTbl.setCellWidget( row, 0, insertBox )
positionTbl.setCellWidget( row, 1, maxBox )
self._insert_position_boxes[axis_key] = (insertBox, maxBox)
positionTbl.resizeColumnsToContents()
def _initInsertPositionTableWithExtents(self, axes, mx):
positionTbl = self.positionWidget
tblHeaders = ["insert at", "max"]
positionTbl.setColumnCount(len(tblHeaders))
positionTbl.setHorizontalHeaderLabels(tblHeaders)
positionTbl.resizeColumnsToContents()
tagged_insert = collections.OrderedDict(zip(axes, self.imageOffsets))
tagged_max = collections.OrderedDict(zip(axes, mx))
self._tagged_insert = tagged_insert
positionTbl.setRowCount(len(tagged_insert))
positionTbl.setVerticalHeaderLabels(tagged_insert.keys())
self._insert_position_boxes.clear()
for row, (axis_key, extent) in enumerate(tagged_max.items()):
# Init min/max spinboxes
default_insert = tagged_insert[axis_key] or 0
default_max = tagged_max[axis_key] or extent
insertBox = QSpinBox(self)
maxBox = QLabel(str(default_max), self)
insertBox.setValue(0)
insertBox.setMinimum(0)
insertBox.setMaximum(extent)
insertBox.setEnabled(tagged_insert[axis_key] is not None)
if insertBox.isEnabled():
insertBox.setValue(default_insert)
# TODO: maxBox shouldn't be in tab list (but it still is)
maxBox.setTextInteractionFlags(Qt.NoTextInteraction)
maxBox.setFocusPolicy(Qt.NoFocus)
maxBox.setEnabled(False)
insertBox.valueChanged.connect(self._updatePosition)
positionTbl.setCellWidget(row, 0, insertBox)
positionTbl.setCellWidget(row, 1, maxBox)
self._insert_position_boxes[axis_key] = (insertBox, maxBox)
positionTbl.resizeColumnsToContents()
def _initLabelMappingTableWithExtents(self):
mappingTbl = self.mappingWidget
max_labels, read_labels_info = self._labelInfo
labels, label_counts = read_labels_info
label_mapping = self.labelMapping
mappings = zip(labels, [label_mapping[i] for i in labels],
label_counts)
tblHeaders = ["map", "to", "px count"]
mappingTbl.setColumnCount(len(tblHeaders))
mappingTbl.setHorizontalHeaderLabels(tblHeaders)
mappingTbl.resizeColumnsToContents()
mappingTbl.setRowCount(len(labels))
mappingTbl.setVerticalHeaderLabels(map(lambda x: str(x), labels))
self._insert_mapping_boxes.clear()
for row, (label_from, label_to, px_cnt) in enumerate(mappings):
enabledBox = QCheckBox(self)
mapToBox = QSpinBox(self)
pxCountBox = QLabel(str(px_cnt), self)
enabledBox.setChecked(label_to > 0)
mapToBox.setMinimum(1 if label_to else 0)
mapToBox.setMaximum(max_labels if label_to else 0)
mapToBox.setValue(label_to)
mapToBox.setEnabled(label_to > 0)
enabledBox.stateChanged.connect(self._updateMappingEnabled)
mapToBox.valueChanged.connect(self._updateMapping)
# TODO: pxCountBox shouldn't be in tab list (but it still is)
pxCountBox.setTextInteractionFlags(Qt.NoTextInteraction)
pxCountBox.setFocusPolicy(Qt.NoFocus)
pxCountBox.setEnabled(False)
mappingTbl.setCellWidget(row, 0, enabledBox)
mappingTbl.setCellWidget(row, 1, mapToBox)
mappingTbl.setCellWidget(row, 2, pxCountBox)
self._insert_mapping_boxes[label_from] = (enabledBox, mapToBox)
mappingTbl.resizeColumnsToContents()
def __init__(self, advanced_option=False):
SimulationConfigPanel.__init__(self, IteratedEnsembleSmoother(), advanced_option)
layout = QFormLayout()
case_selector = CaseSelector()
layout.addRow("Current case:", case_selector)
run_path_label = QLabel("<b>%s</b>" % getRunPath())
addHelpToWidget(run_path_label, "config/simulation/runpath")
layout.addRow("Runpath:", run_path_label)
number_of_realizations_label = QLabel("<b>%d</b>" % getRealizationCount())
addHelpToWidget(number_of_realizations_label, "config/ensemble/num_realizations")
layout.addRow(QLabel("Number of realizations:"), number_of_realizations_label)
# The num_iterations_spinner does not track any external changes (will that ever happen?)
num_iterations_spinner = QSpinBox()
num_iterations_spinner.setMinimum(1)
num_iterations_spinner.setMaximum(100)
num_iterations_spinner.setValue(getNumberOfIterations())
addHelpToWidget(num_iterations_spinner, "config/simulation/number_of_iterations")
num_iterations_spinner.valueChanged[int].connect(setNumberOfIterations)
layout.addRow("Number of iterations:", num_iterations_spinner)
self._iterated_target_case_format_model = TargetCaseModel(format_mode=True)
self._iterated_target_case_format_field = StringBox(self._iterated_target_case_format_model, "config/simulation/iterated_target_case_format")
self._iterated_target_case_format_field.setValidator(ProperNameFormatArgument())
layout.addRow("Target case format:", self._iterated_target_case_format_field)
self._analysis_module_selector = AnalysisModuleSelector(iterable=True, help_link="config/analysis/analysis_module")
layout.addRow("Analysis Module:", self._analysis_module_selector)
self._active_realizations_model = ActiveRealizationsModel()
self._active_realizations_field = StringBox(self._active_realizations_model, "config/simulation/active_realizations")
self._active_realizations_field.setValidator(RangeStringArgument(getRealizationCount()))
layout.addRow("Active realizations", self._active_realizations_field)
self._iterated_target_case_format_field.getValidationSupport().validationChanged.connect(self.simulationConfigurationChanged)
self._active_realizations_field.getValidationSupport().validationChanged.connect(self.simulationConfigurationChanged)
self.setLayout(layout)
def addTableRow(self, row=None, enabled=True, f=10, A=0.1, phase=0.0, bw=5, order=8):
table = self.table
if row == None:
row = table.rowCount()
if row < 1:
row = 0
table.insertRow(row)
cb = QCheckBox()
cb.setChecked(enabled)
self.setTableCellWidget(row, 'active', cb)
frequencySb = QDoubleSpinBox()
frequencySb.setMinimum(1.0)
frequencySb.setMaximum(self.fMax)
frequencySb.setSingleStep(0.01)
frequencySb.setDecimals(2)
frequencySb.setValue(f)
self.setTableCellWidget(row, 'f', frequencySb)
amplitudeSb = AmplitudeSpinBox()
amplitudeSb.setValue(A)
amplitudeSb.valueChanged.connect(lambda v: self.amplitudeChanged(row, v))
self.setTableCellWidget(row, 'A', amplitudeSb)
phaseSb = PhaseSpinBox()
phaseSb.setValue(phase)
self.setTableCellWidget(row, 'phase', phaseSb)
bwSb = QDoubleSpinBox()
bwSb.setMinimum(0.1)
bwSb.setMaximum(1000)
bwSb.setValue(bw)
bwSb.setSuffix(' Hz')
self.setTableCellWidget(row, 'bw', bwSb)
orderSb = QSpinBox()
orderSb.setMinimum(1)
orderSb.setMaximum(10)
orderSb.setValue(order)
self.setTableCellWidget(row, 'order', orderSb)
self.setTableCellWidget(row, 'X', QFloatDisplay())
self.setTableCellWidget(row, 'Y', QFloatDisplay())
self.setTableCellWidget(row, 'R', QFloatDisplay())
self.setTableCellWidget(row, 'Theta', QFloatDisplay())
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()
self.setWindowTitle(self.tr("Image Changer - Resize"))
def create_widgets(self, width, height):
self.widthLabel = QLabel(self.tr("&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(self.tr("&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)
def result(self):
return self.widthSpinBox.value(), self.heightSpinBox.value()
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 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()
def _initLabelMappingTableWithExtents(self):
mappingTbl = self.mappingWidget
max_labels, read_labels_info = self._labelInfo
labels, label_counts = read_labels_info
label_mapping = self.labelMapping
mappings = zip(labels, [label_mapping[i] for i in labels], label_counts)
tblHeaders = ["map", "to", "px count"]
mappingTbl.setColumnCount(len(tblHeaders))
mappingTbl.setHorizontalHeaderLabels(tblHeaders)
mappingTbl.resizeColumnsToContents()
mappingTbl.setRowCount( len(labels) )
mappingTbl.setVerticalHeaderLabels( map(lambda x: str(x), labels) )
self._insert_mapping_boxes.clear()
for row, (label_from, label_to, px_cnt) in enumerate(mappings):
enabledBox = QCheckBox(self)
mapToBox = QSpinBox(self)
pxCountBox = QLabel(str(px_cnt), self)
enabledBox.setChecked(label_to > 0)
mapToBox.setMinimum(1 if label_to else 0)
mapToBox.setMaximum(max_labels if label_to else 0)
mapToBox.setValue(label_to)
mapToBox.setEnabled(label_to > 0)
enabledBox.stateChanged.connect( self._updateMappingEnabled )
mapToBox.valueChanged.connect( self._updateMapping )
# TODO: pxCountBox shouldn't be in tab list (but it still is)
pxCountBox.setTextInteractionFlags(Qt.NoTextInteraction)
pxCountBox.setFocusPolicy(Qt.NoFocus)
pxCountBox.setEnabled(False)
mappingTbl.setCellWidget( row, 0, enabledBox )
mappingTbl.setCellWidget( row, 1, mapToBox )
mappingTbl.setCellWidget( row, 2, pxCountBox )
self._insert_mapping_boxes[label_from] = (enabledBox, mapToBox)
mappingTbl.resizeColumnsToContents()
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 EkdNumPropertie(EkdPropertie):
"""
Définition de la propriété correspondant à un conteur ou une valeur numérique
"""
def __init__(self, prop, name, value, minimum=0, maximum=100, section=None ):
super(EkdNumPropertie, self).__init__(prop, name, value, EkdPropertie.NUM, section)
self.label = QLabel(name)
self.widget = QSpinBox()
self.widget.setValue(int(value))
self.widget.setMaximum(maximum)
self.widget.setMinimum(minimum)
# Quand on change la valeur de la propriété, on met à jour EkdConfig
self.connect(self.widget, SIGNAL("valueChanged(int)"), self.updateNum)
def updateNum(self, val):
self.value = val
EkdConfig.set(self.section, self.id, self.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 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())
def __init__(self,
parent,
prefix=None,
suffix=None,
option=None,
min_=None,
max_=None,
step=None,
tip=None,
value=None,
changed=None):
super(MySpinBox, self).__init__(parent)
if prefix:
plabel = QLabel(prefix)
else:
plabel = None
if suffix:
slabel = QLabel(suffix)
else:
slabel = None
spinbox = QSpinBox(parent)
if min_ is not None:
spinbox.setMinimum(min_)
if max_ is not None:
spinbox.setMaximum(max_)
if step is not None:
spinbox.setSingleStep(step)
if tip is not None:
spinbox.setToolTip(tip)
layout = QHBoxLayout()
for subwidget in (plabel, spinbox, slabel):
if subwidget is not None:
layout.addWidget(subwidget)
if value is not None:
spinbox.setValue(value)
if changed is not None:
self.connect(spinbox, SIGNAL('valueChanged(int)'), changed)
layout.addStretch(1)
layout.setContentsMargins(0, 0, 0, 0)
self.setLayout(layout)
self.spin = spinbox
def add_spin_box(self, name='Number', n_min=1, n_max=99, init_val=1,
advance_n=True, fulldesc='Number of Engines',
text_align='right', text_font=ARIAL_10, col=0, width=120,
parent=None, layout=None):
# if parent is input, add widget to parent
if parent is None:
parent = self
if layout is None:
NRow = parent.get_next_row_number(advance_n)
lbl = QLabel(" %s "%fulldesc, parent)
lbl.setFont( text_font )
spin_box = QSpinBox(parent)
spin_box.setFont( text_font )
spin_box.setFixedWidth( width )
spin_box.setRange( n_min, n_max)
spin_box.setValue( init_val )
if layout is None:
parent.grid.addWidget(lbl, NRow, col)
else:
layout.addWidget( lbl )
hbox = QHBoxLayout()
hbox.addWidget(spin_box)
hbox.addStretch(1)
widget = QWidget()
widget.setLayout(hbox)
if layout is None:
parent.grid.addWidget(widget , NRow, col+1)
if text_align=='right':
parent.grid.setAlignment(lbl, Qt.AlignRight )
else:
layout.addWidget( widget )
self.objectD['%s_spin_box'%name] = spin_box
self.input_widget_by_nameD[name] = (spin_box , 'spin_box')
spin_box.valueChanged.connect( lambda: self.spin_box_changed( '%s_spin_box'%name ) )
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 CheckBoxEdit(QWidget):
def __init__(self, label='', value=0, parent=None):
super(CheckBoxEdit, self).__init__(parent)
self.check = QCheckBox(label)
self.columnSpin = QSpinBox()
self.columnSpin.setRange(0, 20)
self.columnSpin.setValue(value)
lay = QHBoxLayout()
lay.addWidget(self.check)
lay.addWidget(self.columnSpin)
self.setLayout(lay)
self.column = 0
self.columnSpin.setEnabled(False)
self.check.stateChanged.connect(self.columnSpin.setEnabled)
self.columnSpin.valueChanged[int].connect(self.setColumn)
def setColumn(self, column):
self.column = column
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 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 ConnectionDialog(QDialog):
def __init__(self, parent):
super(ConnectionDialog, self).__init__(parent)
layout = QVBoxLayout(self)
formLayout = QFormLayout()
self.filePath = QLineEdit("/home/vertrex/dump/registry/system")
formLayout.addRow(QLabel("server registry file path :"), self.filePath)
self.ipAddress = QLineEdit("127.0.0.1")
formLayout.addRow(QLabel("server ip address :"), self.ipAddress)
self.port = QSpinBox()
self.port.setMinimum(1)
self.port.setMaximum(65536)
self.port.setValue(0xdff)
formLayout.addRow(QLabel("port :"), self.port)
configurationGroupBox = QGroupBox("Configuration")
configurationGroupBox.setLayout(formLayout)
layout.addWidget(configurationGroupBox)
self.buttons = QDialogButtonBox(
QDialogButtonBox.Ok | QDialogButtonBox.Cancel, Qt.Horizontal, self)
layout.addWidget(self.buttons)
self.buttons.accepted.connect(self.accept)
self.buttons.rejected.connect(self.reject)
class QxtSpanSliderWidget(QWidget):
def __init__(self, low, upp, parent=None):
QWidget.__init__(self, parent)
self.layout = QHBoxLayout(self)
self._spin_start = QSpinBox(self)
self._spin_end = QSpinBox(self)
self.layout.addWidget(self._spin_start)
self._slider = QxtSpanSlider(self)
self._slider.setHandleMovementMode(QxtSpanSlider.NoOverlapping)
self._slider.lowerPositionChanged.connect(
lambda x: self._spin_start.setValue(x))
self._slider.upperPositionChanged.connect(
lambda x: self._spin_end.setValue(x))
self._spin_start.valueChanged.connect(
lambda x: self._slider.setLowerPosition(x)
if x < self._slider.upperValue else self._spin_start.setValue(
self._slider.upperValue - 1))
self._spin_end.valueChanged.connect(
lambda x: self._slider.setUpperPosition(x)
if x > self._slider.lowerValue else self._spin_end.setValue(
self._slider.lowerValue + 1))
self.layout.addWidget(self._slider)
self.layout.addWidget(self._spin_end)
self.setRange(low, upp)
self.setSpan(low, upp)
@property
def lowerValue(self):
return self._slider.lowerValue
@property
def upperValue(self):
return self._slider.upperValue
def setRange(self, low, upp):
self._slider.setRange(low, upp)
self._spin_start.setRange(low, upp)
self._spin_end.setRange(low, upp)
def setSpan(self, low, upp):
self._spin_start.setValue(low)
self._spin_end.setValue(upp)
self._slider.setSpan(low, upp)
class ObjectWidget(QWidget):
"""
Widget for editing OBJECT parameters
"""
signal_object_changed = pyqtSignal(name='objectChanged')
def __init__(self, parent=None):
super(ObjectWidget, self).__init__(parent)
l_nbr_steps = QLabel("Nbr Steps ")
self.nbr_steps = QSpinBox()
self.nbr_steps.setMinimum(3)
self.nbr_steps.setMaximum(100)
self.nbr_steps.setValue(6)
self.nbr_steps.valueChanged.connect(self.update_param)
l_cmap = QLabel("Cmap ")
self.cmap = sorted(get_colormaps().keys())
self.combo = QComboBox(self)
self.combo.addItems(self.cmap)
self.combo.currentIndexChanged.connect(self.update_param)
gbox = QGridLayout()
gbox.addWidget(l_cmap, 0, 0)
gbox.addWidget(self.combo, 0, 1)
gbox.addWidget(l_nbr_steps, 1, 0)
gbox.addWidget(self.nbr_steps, 1, 1)
vbox = QVBoxLayout()
vbox.addLayout(gbox)
vbox.addStretch(1.0)
self.setLayout(vbox)
def update_param(self, option):
self.signal_object_changed.emit()
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 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 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))
