def setupUi(self):
self.setLayout(QVBoxLayout())
self.layout().setContentsMargins(0, 0, 0, 0)
self.layout().setSpacing(0)
self.__mainLayout = QVBoxLayout()
self.__mainLayout.setContentsMargins(0, 40, 0, 40)
self.__mainLayout.setSpacing(65)
self.layout().addLayout(self.__mainLayout)
self.setStyleSheet(WELCOME_WIDGET_BUTTON_STYLE)
bottom_bar = QWidget(objectName="bottom-bar")
bottom_bar_layout = QHBoxLayout()
bottom_bar_layout.setContentsMargins(20, 10, 20, 10)
bottom_bar.setLayout(bottom_bar_layout)
bottom_bar.setSizePolicy(QSizePolicy.MinimumExpanding,
QSizePolicy.Maximum)
check = QCheckBox(self.tr("Show at startup"), bottom_bar)
check.setChecked(False)
self.__showAtStartupCheck = check
bottom_bar_layout.addWidget(check, alignment=Qt.AlignVCenter | \
Qt.AlignLeft)
self.layout().addWidget(bottom_bar,
alignment=Qt.AlignBottom,
stretch=1)
self.setSizeGripEnabled(False)
self.setFixedSize(620, 390)
class BooleanParameterWidget(GenericParameterWidget):
"""Widget class for boolean parameter."""
def __init__(self, parameter, parent=None):
"""Constructor
.. versionadded:: 2.2
:param parameter: A BooleanParameter object.
:type parameter: BooleanParameter
"""
super(BooleanParameterWidget, self).__init__(parameter, parent)
# Get the parameter label and use its value as the checkbox text
label_item = self._input_layout.itemAt(0)
label_widget = label_item.widget()
text = label_widget.text()
self._check_box_input = QCheckBox(text)
# Tooltips
self.setToolTip('Tick here to enable ' + self._parameter.name)
self._check_box_input.setChecked(self._parameter.value)
self._inner_input_layout.insertWidget(0, self._check_box_input)
self._input_layout.removeItem(label_item)
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._check_box_input.isChecked()
return self._parameter
class ExperimentalFeatures(preferences.Group):
def __init__(self, page):
super(ExperimentalFeatures, self).__init__(page)
layout = QVBoxLayout()
self.setLayout(layout)
self.experimentalFeatures = QCheckBox(toggled=self.changed)
layout.addWidget(self.experimentalFeatures)
app.translateUI(self)
def translateUI(self):
self.setTitle(_("Experimental Features"))
self.experimentalFeatures.setText(_("Enable Experimental Features"))
self.experimentalFeatures.setToolTip('<qt>' + _(
"If checked, features that are not yet finished are enabled.\n"
"You need to restart Frescobaldi to see the changes."))
def loadSettings(self):
s = QSettings()
self.experimentalFeatures.setChecked(s.value("experimental-features", False, bool))
def saveSettings(self):
s = QSettings()
s.setValue("experimental-features", self.experimentalFeatures.isChecked())
def __init__(self, values=None):
RangeDialog.__init__(self, 'Darkening law range')
self.setFixedHeight(102)
grid = QGridLayout()
grid.setAlignment(Qt.AlignTop)
grid.setColumnStretch(1, 1)
self.checkboxes = []
row = 1
cell = 1
for item in DarkeningLaw.items:
checkbox = QCheckBox(item[0])
checkbox.setObjectName(item[1])
checkbox.stateChanged.connect(self._on_checkbox_state_changed)
grid.addWidget(checkbox, row, cell)
self.checkboxes.append(checkbox)
if values and item[1] in values:
checkbox.setChecked(True)
cell += 1
if cell > 2:
cell = 1
row += 1
self.layout().insertLayout(0, grid)
if not len(self.values()):
self.ok_button.setDisabled(True)
class ViewSettings(preferences.Group):
def __init__(self, page):
super(ViewSettings, self).__init__(page)
layout = QVBoxLayout()
self.setLayout(layout)
self.wrapLines = QCheckBox(toggled=self.changed)
layout.addWidget(self.wrapLines)
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."))
def loadSettings(self):
s = QSettings()
s.beginGroup("view_preferences")
self.wrapLines.setChecked(s.value("wrap_lines", False, bool))
def saveSettings(self):
s = QSettings()
s.beginGroup("view_preferences")
s.setValue("wrap_lines", self.wrapLines.isChecked())
def __init__(self, zeros):
"""
Constructor
"""
QDialog.__init__(self)
self.__zeros = zeros
self.setWindowTitle(QCoreApplication.translate("VDLTools", "Zeros"))
self.__layout = QGridLayout()
self.__zeroLabels = []
self.__zeroChecks = []
displayButton = False
self.__scrollLayout = QGridLayout()
for i in range(len(self.__zeros)):
msg = "- vertex " + str(self.__zeros[i][0])
msg += QCoreApplication.translate("VDLTools", ", elevation : '0', ")
if self.__zeros[i][1] is not None:
msg += QCoreApplication.translate("VDLTools", "interpolated elevation : ")
msg += str(self.__zeros[i][1]) + "m"
if self.__zeros[i][2] > 1:
msg += QCoreApplication.translate("VDLTools", " (and apply to point)")
msgCheck = QCheckBox()
msgCheck.setChecked(True)
self.__zeroChecks.append(msgCheck)
self.__scrollLayout.addWidget(self.__zeroChecks[i], i+1, 2)
displayButton = True
else:
msg += QCoreApplication.translate("VDLTools", "no interpolated elevation")
self.__zeroChecks.append(None)
zeroLabel = QLabel(msg)
self.__zeroLabels.append(zeroLabel)
self.__scrollLayout.addWidget(self.__zeroLabels[i], i+1, 0, 1, 2)
widget = QWidget()
widget.setLayout(self.__scrollLayout)
scroll = QScrollArea()
scroll.setWidgetResizable(True)
scroll.setWidget(widget)
self.__layout.addWidget(scroll, 1, 0, 1, 2)
self.__passButton = QPushButton(QCoreApplication.translate("VDLTools", "Pass"))
self.__passButton.setMinimumHeight(20)
self.__passButton.setMinimumWidth(100)
pos = len(self.__zeros) + 1
self.__layout.addWidget(self.__passButton, pos, 0)
self.__applyButton = QPushButton(QCoreApplication.translate("VDLTools", "Apply interpolation"))
self.__applyButton.setMinimumHeight(20)
self.__applyButton.setMinimumWidth(100)
if displayButton:
self.__layout.addWidget(self.__applyButton, pos, 1)
self.setLayout(self.__layout)
def _add_subset(self, message):
""" Add a new subset to the panel """
s = message.sender
width = 50
height = 50
pm = QPixmap(width, height)
color = mpl_to_qt4_color(s.style.color)
pm.fill(color)
icon = QIcon(pm)
layer = QHBoxLayout()
check = QCheckBox("")
check.setChecked(False)
self.connect(check, SIGNAL('stateChanged(int)'), self.on_check)
widget = QPushButton(icon, "")
self.connect(widget, SIGNAL('clicked()'), self.on_push)
layer.addWidget(check)
layer.addWidget(widget)
self.layout.addLayout(layer)
self.subset_widgets[s] = {'layer':layer, 'widget':widget,
'check':check, 'pixmap':pm}
# make sure buttons are exclusive
self.check_group.addButton(check)
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())
def setupUi(self):
self.setLayout(QVBoxLayout())
self.layout().setContentsMargins(0, 0, 0, 0)
self.layout().setSpacing(0)
self.__mainLayout = QVBoxLayout()
self.__mainLayout.setContentsMargins(0, 40, 0, 40)
self.__mainLayout.setSpacing(65)
self.layout().addLayout(self.__mainLayout)
self.setStyleSheet(WELCOME_WIDGET_BUTTON_STYLE)
bottom_bar = QWidget(objectName="bottom-bar")
bottom_bar_layout = QHBoxLayout()
bottom_bar_layout.setContentsMargins(20, 10, 20, 10)
bottom_bar.setLayout(bottom_bar_layout)
bottom_bar.setSizePolicy(QSizePolicy.MinimumExpanding,
QSizePolicy.Maximum)
check = QCheckBox(self.tr("Show at startup"), bottom_bar)
check.setChecked(False)
self.__showAtStartupCheck = check
bottom_bar_layout.addWidget(check, alignment=Qt.AlignVCenter | \
Qt.AlignLeft)
self.layout().addWidget(bottom_bar, alignment=Qt.AlignBottom,
stretch=1)
self.setSizeGripEnabled(False)
self.setFixedSize(620, 390)
class PianoStaff(StaffBase):
def __init__(self, dialog):
StaffBase.__init__(self, dialog)
l = QLabel(i18n("Systems per page:"))
l.setBuddy(self.systems)
self.layout().addWidget(l, 0, 1, Qt.AlignRight)
self.layout().addWidget(self.systems, 0, 2)
self.clefs = QCheckBox(i18n("Clefs"))
self.layout().addWidget(self.clefs, 1, 2)
def name(self):
return i18n("Piano Staff")
def default(self):
self.systems.setValue(6)
self.clefs.setChecked(True)
def music(self, layout):
layout.setSpanBarContexts(['PianoStaff'])
if not self.clefs.isChecked():
layout.add('Staff', "\\override Clef #'transparent = ##t")
if lilyPondVersion() < (2, 13, 4):
spacing = "#'minimum-Y-extent = #'(-6 . 3)"
elif lilyPondVersion() < (2, 14, 0):
spacing = "#'next-staff-spacing = #'((space . 10))"
else:
spacing = "#'next-staff-spacing = #'((basic-distance . 10))"
return ['\\new PianoStaff <<',
'\\new Staff \\with {',
'\\override VerticalAxisGroup ' + spacing,
'} { \\clef treble \\music }',
'\\new Staff { \\clef bass \\music }',
'>>']
def populateConfigTable(self):
self.clearConfigTable()
list_keys = self.list_keys
list_values = self.list_values
search_string = str(self.ui.searchLineEdit.text()).lower()
_metadata_table = self.list_metadata_selected
_index = 0
for _key in list_keys:
_name = _key
if (search_string.strip() != '') and \
(not(search_string in _name.lower())):
continue
self.ui.configureTable.insertRow(_index)
_nameItem = QTableWidgetItem(_name)
self.ui.configureTable.setItem(_index, 1, _nameItem)
_yesNo = QCheckBox()
_id = list_keys.index(_name)
_value = list_values[_id]
_yesNo.setChecked(_value)
_yesNo.setText('')
_yesNo.stateChanged.connect(self.configTableEdited)
self.ui.configureTable.setCellWidget(_index, 0, _yesNo)
[value, units] = self.retrieveValueUnits(_name)
_valueItem = QTableWidgetItem(value)
self.ui.configureTable.setItem(_index, 2, _valueItem)
_unitsItem = QTableWidgetItem(units)
self.ui.configureTable.setItem(_index, 3, _unitsItem)
_index += 1
class CheckBox(QWidget):
status_changed = pyqtSignal(bool)
def __init__(self, caption, checked=False, tooltip=""):
QWidget.__init__(self)
self.value = checked
self.checkbox = QCheckBox(caption)
self.checkbox.stateChanged.connect(self.__on_change)
self.checkbox.setToolTip(tooltip)
hbox = QHBoxLayout()
hbox.addWidget(self.checkbox)
hbox.setMargin(0)
self.setLayout(hbox)
# self.setContentsMargins(5, 0, 5, 0)
self.setContentsMargins(0, 0, 0, 0)
self.checkbox.setChecked(self.value)
def __on_change(self, value):
self.value = value
if value == Qt.Unchecked:
self.status_changed.emit(False)
else:
self.status_changed.emit(True)
def get_value(self):
return self.checkbox.isChecked()
class ExperimentalFeatures(preferences.Group):
def __init__(self, page):
super(ExperimentalFeatures, self).__init__(page)
layout = QVBoxLayout()
self.setLayout(layout)
self.experimentalFeatures = QCheckBox(toggled=self.changed)
layout.addWidget(self.experimentalFeatures)
app.translateUI(self)
def translateUI(self):
self.setTitle(_("Experimental Features"))
self.experimentalFeatures.setText(_("Enable Experimental Features"))
self.experimentalFeatures.setToolTip(
'<qt>' +
_("If checked, features that are not yet finished are enabled.\n"
"You need to restart Frescobaldi to see the changes."))
def loadSettings(self):
s = QSettings()
self.experimentalFeatures.setChecked(
s.value("experimental-features", False, bool))
def saveSettings(self):
s = QSettings()
s.setValue("experimental-features",
self.experimentalFeatures.isChecked())
def Set(self, widget : QtGui.QCheckBox, val : str):
self.__CheckLen(widget)
if not val in self.enum:
raise GuiFieldUnknownMetaErr(val, widget, True)
state = QtCore.Qt.Checked if (val == self.enum[0]) else QtCore.Qt.Unchecked
widget.setChecked(state)
class ViewSettings(preferences.Group):
def __init__(self, page):
super(ViewSettings, self).__init__(page)
layout = QVBoxLayout()
self.setLayout(layout)
self.wrapLines = QCheckBox(toggled=self.changed)
layout.addWidget(self.wrapLines)
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."))
def loadSettings(self):
s = QSettings()
s.beginGroup("view_preferences")
self.wrapLines.setChecked(s.value("wrap_lines", False, bool))
def saveSettings(self):
s = QSettings()
s.beginGroup("view_preferences")
s.setValue("wrap_lines", self.wrapLines.isChecked())
def setChecked(self, check, report=True):
if not report:
self.disconnect(self, SIGNAL('stateChanged(int)'),
self.valueChanged)
QCheckBox.setChecked(self, check)
if not report:
self.connect(self, SIGNAL('stateChanged(int)'), self.valueChanged)
class DummyConfigWidget(QWidget, config.ConfigurationWidgetMixin):
NAME_PREFIX = 'dummy'
PROPERTY_MAP = dict(QCheckBox='checked', QLineEdit='text')
CHANGED_SIGNAL_MAP = dict(QCheckBox='toggled', QLineEdit='textChanged')
configurationChanged = pyqtSignal(bool)
def __init__(self, config, parent=None):
QWidget.__init__(self, parent)
layout = QHBoxLayout(self)
self.setLayout(layout)
self.checkbox = QCheckBox(self)
self.checkbox.setObjectName('dummy_checkbox')
layout.addWidget(self.checkbox)
self.lineedit = QLineEdit(self)
self.lineedit.setObjectName('dummy_lineedit')
layout.addWidget(self.lineedit)
self._setup(config)
def change(self, text, check_state):
self.lineedit.setText(text)
self.checkbox.setChecked(check_state)
def check(self, text, check_state):
__tracebackhide__ = True
assert unicode(self.lineedit.text()) == text
assert self.checkbox.isChecked() == check_state
def populateConfigTable(self):
self.clearConfigTable()
list_keys = self.list_keys
list_values = self.list_values
search_string = str(self.ui.searchLineEdit.text()).lower()
_metadata_table = self.list_metadata_selected
_index = 0
for _key in list_keys:
_name = _key
if (search_string.strip() != '') and \
(not(search_string in _name.lower())):
continue
self.ui.configureTable.insertRow(_index)
_nameItem = QTableWidgetItem(_name)
self.ui.configureTable.setItem(_index, 1, _nameItem)
_yesNo = QCheckBox()
_id = list_keys.index(_name)
_value = list_values[_id]
_yesNo.setChecked(_value)
_yesNo.setText('')
_yesNo.stateChanged.connect(self.configTableEdited)
self.ui.configureTable.setCellWidget(_index, 0, _yesNo)
[value, units] = self.retrieveValueUnits(_name)
_valueItem = QTableWidgetItem(value)
self.ui.configureTable.setItem(_index, 2, _valueItem)
_unitsItem = QTableWidgetItem(units)
self.ui.configureTable.setItem(_index, 3, _unitsItem)
_index += 1
class PreviewWidget(QWidget):
"""Import wizard preview widget"""
def __init__(self, parent):
QWidget.__init__(self, parent)
vert_layout = QVBoxLayout()
hor_layout = QHBoxLayout()
self.array_box = QCheckBox(_("Import as array"))
self.array_box.setEnabled(ndarray is not FakeObject)
self.array_box.setChecked(ndarray is not FakeObject)
hor_layout.addWidget(self.array_box)
h_spacer = QSpacerItem(40, 20,
QSizePolicy.Expanding, QSizePolicy.Minimum)
hor_layout.addItem(h_spacer)
self._table_view = PreviewTable(self)
vert_layout.addLayout(hor_layout)
vert_layout.addWidget(self._table_view)
self.setLayout(vert_layout)
def open_data(self, text, colsep=u"\t", rowsep=u"\n",
transpose=False, skiprows=0, comments='#'):
"""Open clipboard text as table"""
self._table_view.process_data(text, colsep, rowsep, transpose,
skiprows, comments)
def get_data(self):
"""Return table data"""
return self._table_view.get_data()
class externQWidget(QWidget):
def __init__(self, parent):
QWidget.__init__(self, parent)
self.checkBoxExtern = QCheckBox('undock', self)
self.checkBoxExtern.setGeometry(5, 5, 70, 20)
self.checkBoxExtern.setChecked(False)
self.checkBoxExtern.toggled[bool].connect(self.onExtern)
self.__v_pos = QPoint(100, 100)
# end __init__
def closeEvent(self, event):
event.ignore()
self.checkBoxExtern.setChecked(False)
#self.__onExtern(False)
#QWidget.closeEvent(self, event)
# end closeEvent
def onExtern(self, b):
if (b):
self.setWindowFlags(Qt.Dialog)
self.move(self.__v_pos)
else:
self.__v_pos = self.pos()
self.setWindowFlags(Qt.Widget)
self.move(0, 0)
# end if
self.show()
class DummyConfigWidget(QWidget, config.ConfigurationWidgetMixin):
NAME_PREFIX = 'dummy'
PROPERTY_MAP = dict(QCheckBox='checked', QLineEdit='text')
CHANGED_SIGNAL_MAP = dict(QCheckBox='toggled', QLineEdit='textChanged')
configurationChanged = pyqtSignal(bool)
def __init__(self, config, parent=None):
QWidget.__init__(self, parent)
layout = QHBoxLayout(self)
self.setLayout(layout)
self.checkbox = QCheckBox(self)
self.checkbox.setObjectName('dummy_checkbox')
layout.addWidget(self.checkbox)
self.lineedit = QLineEdit(self)
self.lineedit.setObjectName('dummy_lineedit')
layout.addWidget(self.lineedit)
self._setup(config)
def change(self, text, check_state):
self.lineedit.setText(text)
self.checkbox.setChecked(check_state)
def check(self, text, check_state):
__tracebackhide__ = True
assert unicode(self.lineedit.text()) == text
assert self.checkbox.isChecked() == check_state
class PreviewWidget(QWidget):
"""Import wizard preview widget"""
def __init__(self, parent):
QWidget.__init__(self, parent)
vert_layout = QVBoxLayout()
hor_layout = QHBoxLayout()
self.array_box = QCheckBox(_("Import as array"))
self.array_box.setEnabled(ndarray is not FakeObject)
self.array_box.setChecked(ndarray is not FakeObject)
hor_layout.addWidget(self.array_box)
h_spacer = QSpacerItem(40, 20, QSizePolicy.Expanding,
QSizePolicy.Minimum)
hor_layout.addItem(h_spacer)
self._table_view = PreviewTable(self)
vert_layout.addLayout(hor_layout)
vert_layout.addWidget(self._table_view)
self.setLayout(vert_layout)
def open_data(self,
text,
colsep=u"\t",
rowsep=u"\n",
transpose=False,
skiprows=0,
comments='#'):
"""Open clipboard text as table"""
self._table_view.process_data(text, colsep, rowsep, transpose,
skiprows, comments)
def get_data(self):
"""Return table data"""
return self._table_view.get_data()
def init(self, job):
qc = QCheckBox()
for i in self.checklist:
qc = self.checkbox_list[i]
print self.checklist[i]
qc.setChecked(self.checklist[i])
return
class CheckBox(QWidget):
status_changed = pyqtSignal(bool)
def __init__(self, caption, checked=False, tooltip=''):
QWidget.__init__(self)
self.value = checked
self.checkbox = QCheckBox(caption)
self.checkbox.stateChanged.connect(self.__on_change)
self.checkbox.setToolTip(tooltip)
hbox = QHBoxLayout()
hbox.addWidget(self.checkbox)
hbox.setMargin(0)
self.setLayout(hbox)
#self.setContentsMargins(5, 0, 5, 0)
self.setContentsMargins(0, 0, 0, 0)
self.checkbox.setChecked(self.value)
def __on_change(self, value):
self.value = value
if value == Qt.Unchecked:
self.status_changed.emit(False)
else:
self.status_changed.emit(True)
def get_value(self):
return self.checkbox.isChecked()
class Articulations(tool.Tool):
"""Articulations tool in the quick insert panel toolbox.
"""
def __init__(self, panel):
super(Articulations, self).__init__(panel)
self.shorthands = QCheckBox(self)
self.shorthands.setChecked(True)
self.layout().addWidget(self.shorthands)
for cls in (
ArticulationsGroup,
OrnamentsGroup,
SignsGroup,
OtherGroup,
):
self.layout().addWidget(cls(self))
self.layout().addStretch(1)
app.translateUI(self)
def translateUI(self):
self.shorthands.setText(_("Allow shorthands"))
self.shorthands.setToolTip(_(
"Use short notation for some articulations like staccato."))
def icon(self):
"""Should return an icon for our tab."""
return symbols.icon("articulation_prall")
def title(self):
"""Should return a title for our tab."""
return _("Articulations")
def tooltip(self):
"""Returns a tooltip"""
return _("Different kinds of articulations and other signs.")
def init(self,job):
qc=QCheckBox()
for i in self.checklist:
qc=self.checkbox_list[i]
print self.checklist[i]
qc.setChecked(self.checklist[i])
return
class BooleanParameterWidget(GenericParameterWidget):
"""Widget class for boolean parameter."""
def __init__(self, parameter, parent=None):
"""Constructor
.. versionadded:: 2.2
:param parameter: A BooleanParameter object.
:type parameter: BooleanParameter
"""
super(BooleanParameterWidget, self).__init__(parameter, parent)
self._check_box_input = QCheckBox()
# Tooltips
self.setToolTip('Tick here to enable ' + self._parameter.name)
self._check_box_input.setChecked(self._parameter.value)
self._inner_input_layout.addWidget(self._check_box_input)
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._check_box_input.isChecked()
return self._parameter
class BooleanParameterWidget(GenericParameterWidget):
"""Widget class for boolean parameter."""
def __init__(self, parameter, parent=None):
"""Constructor
.. versionadded:: 2.2
:param parameter: A BooleanParameter object.
:type parameter: BooleanParameter
"""
super(BooleanParameterWidget, self).__init__(parameter, parent)
self._check_box_input = QCheckBox()
# Tooltips
self.setToolTip('Tick here to enable ' + self._parameter.name)
self._check_box_input.setChecked(self._parameter.value)
self._inner_input_layout.addWidget(self._check_box_input)
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._check_box_input.isChecked()
return self._parameter
class BooleanParameterWidget(GenericParameterWidget):
"""Widget class for boolean parameter."""
def __init__(self, parameter, parent=None):
"""Constructor
.. versionadded:: 2.2
:param parameter: A BooleanParameter object.
:type parameter: BooleanParameter
"""
super(BooleanParameterWidget, self).__init__(parameter, parent)
# Get the parameter label and use its value as the checkbox text
label_item = self.input_layout.itemAt(0)
label_widget = label_item.widget()
text = label_widget.text()
self._check_box_input = QCheckBox(text)
# Tooltips
self.setToolTip('Tick here to enable ' + self._parameter.name)
self._check_box_input.setChecked(self._parameter.value)
self.inner_input_layout.insertWidget(0, self._check_box_input)
self.input_layout.removeItem(label_item)
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._check_box_input.isChecked()
return self._parameter
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)
def __init__(self, values=None):
RangeDialog.__init__(self, 'Darkening law range')
self.setFixedHeight(102)
grid = QGridLayout()
grid.setAlignment(Qt.AlignTop)
grid.setColumnStretch(1,1)
self.checkboxes = []
row = 1
cell = 1
for item in DarkeningLaw.items:
checkbox = QCheckBox(item[0])
checkbox.setObjectName(item[1])
checkbox.stateChanged.connect(self._on_checkbox_state_changed)
grid.addWidget(checkbox, row, cell)
self.checkboxes.append(checkbox)
if values and item[1] in values:
checkbox.setChecked(True)
cell += 1
if cell > 2:
cell = 1
row += 1
self.layout().insertLayout(0, grid)
if not len(self.values()):
self.ok_button.setDisabled(True)
def test_should_set_config_uncheckedvalue_on_false():
checkbox = QCheckBox()
checkbox.setChecked(True)
assert checkbox.isChecked()
widget = CheckboxWidget(widget=checkbox)
widget.config = config
widget.setvalue('MyFalse')
assert not checkbox.isChecked()
def test_should_set_config_uncheckedvalue_on_false():
checkbox = QCheckBox()
checkbox.setChecked(True)
assert checkbox.isChecked()
widget = CheckboxWidget(widget=checkbox)
widget.config = config
widget.setvalue('MyFalse')
assert not checkbox.isChecked()
class LilyPondInfoDialog(KDialog):
"""
A dialog to edit attributes of a LilyPondInfo instance.
"""
def __init__(self, parent):
KDialog.__init__(self, parent)
self.setButtons(KDialog.ButtonCode(KDialog.Ok | KDialog.Cancel | KDialog.Help | KDialog.User1))
self.setCaption(i18n("LilyPond"))
self.setHelp("settings-paths-lilypond")
self.setButtonText(KDialog.User1, i18n("Download..."))
self.setButtonIcon(KDialog.User1, KIcon("download"))
self.setButtonToolTip(KDialog.User1, i18n("Download new binary LilyPond releases."))
self.user1Clicked.connect(self.downloadLilyPond)
layout = QGridLayout(self.mainWidget())
l = QLabel(i18n("LilyPond Command:"))
self.lilypond = KUrlRequester()
l.setBuddy(self.lilypond)
self.lilypond.lineEdit().setToolTip(i18n("Name or full path of the LilyPond program."))
self.lilypond.fileDialog().setCaption(i18n("LilyPond Command"))
layout.addWidget(l, 0, 0, 1, 2)
layout.addWidget(self.lilypond, 1, 0, 1, 2)
self.commands = {}
row = 2
for name, description in LilyPondInfo.commandNames():
l = QLabel(description)
e = self.commands[name] = QLineEdit()
l.setBuddy(e)
layout.addWidget(l, row, 0, Qt.AlignRight)
layout.addWidget(e, row, 1)
row += 1
self.default = QCheckBox(i18n("Set as default"))
layout.addWidget(self.default, row, 1)
self.auto = QCheckBox(i18n("Include in automatic version selection"))
layout.addWidget(self.auto, row + 1, 1)
def loadInfo(self, info):
""" Display the settings in the LilyPondInfo object in our dialog. """
self.lilypond.setText(info.lilypond)
for name, value in info.commands.items():
self.commands[name].setText(value)
self.default.setChecked(info.default)
self.auto.setChecked(info.auto)
def saveInfo(self, info):
""" Write the settings in our dialog to the LilyPondInfo object. """
info.lilypond = self.lilypond.text()
for name, widget in self.commands.items():
info.commands[name] = widget.text()
info.default = self.default.isChecked()
info.auto = self.auto.isChecked()
def downloadLilyPond(self):
from frescobaldi_app.download import LilyPondDownloadDialog
LilyPondDownloadDialog(self).exec_()
class GeneralPreferences(QWidget):
"""The general preferences input."""
def __init__(self):
super(GeneralPreferences, self).__init__()
grid = QGridLayout(self)
grid.setSpacing(20)
grid.setColumnStretch(1, 10)
# directory auto completer
completer = QCompleter(self)
dirs = QDirModel(self)
dirs.setFilter(QDir.AllDirs | QDir.NoDotAndDotDot)
completer.setModel(dirs)
completer.setCaseSensitivity(Qt.CaseInsensitive)
completer.setCompletionMode(QCompleter.PopupCompletion)
l = QLabel(
u"<b>Ingresá el directorio donde descargar los videos...</b>")
l.setTextFormat(Qt.RichText)
grid.addWidget(l, 0, 0, 1, 2)
grid.addWidget(QLabel(u"Descargar en:"), 1, 0, 2, 1)
prv = config.get('downloaddir', '')
self.downloaddir_entry = QLineEdit(prv)
self.downloaddir_entry.setCompleter(completer)
self.downloaddir_entry.setPlaceholderText(u'Ingresá un directorio')
grid.addWidget(self.downloaddir_entry, 1, 1, 2, 2)
self.downloaddir_buttn = QPushButton(u"Elegir un directorio")
self.downloaddir_buttn.clicked.connect(self._choose_dir)
grid.addWidget(self.downloaddir_buttn, 2, 1, 3, 2)
self.autoreload_checkbox = QCheckBox(
u"Recargar automáticamente la lista de episodios al iniciar")
prv = config.get('autorefresh', False)
self.autoreload_checkbox.setChecked(prv)
grid.addWidget(self.autoreload_checkbox, 3, 0, 4, 2)
self.shownotifs_checkbox = QCheckBox(
u"Mostrar una notificación cuando termina cada descarga")
prv = config.get('notification', True)
self.shownotifs_checkbox.setChecked(prv)
grid.addWidget(self.shownotifs_checkbox, 4, 0, 5, 2)
def _choose_dir(self):
"""Choose a directory using a dialog."""
resp = QFileDialog.getExistingDirectory(self, '',
os.path.expanduser("~"))
if resp:
self.downloaddir_entry.setText(resp)
def get_config(self):
"""Return the config for this tab."""
d = {}
d['downloaddir'] = self.downloaddir_entry.text()
d['autorefresh'] = self.autoreload_checkbox.isChecked()
d['notification'] = self.shownotifs_checkbox.isChecked()
return d
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 GeneralPreferences(QWidget):
"""The general preferences input."""
def __init__(self):
super(GeneralPreferences, self).__init__()
grid = QGridLayout(self)
grid.setSpacing(20)
grid.setColumnStretch(1, 10)
# directory auto completer
completer = QCompleter(self)
dirs = QDirModel(self)
dirs.setFilter(QDir.AllDirs | QDir.NoDotAndDotDot)
completer.setModel(dirs)
completer.setCaseSensitivity(Qt.CaseInsensitive)
completer.setCompletionMode(QCompleter.PopupCompletion)
l = QLabel(
u"<b>Ingresá el directorio donde descargar los videos...</b>")
l.setTextFormat(Qt.RichText)
grid.addWidget(l, 0, 0, 1, 2)
grid.addWidget(QLabel(u"Descargar en:"), 1, 0, 2, 1)
prv = config.get('downloaddir', '')
self.downloaddir_entry = QLineEdit(prv)
self.downloaddir_entry.setCompleter(completer)
self.downloaddir_entry.setPlaceholderText(u'Ingresá un directorio')
grid.addWidget(self.downloaddir_entry, 1, 1, 2, 2)
self.downloaddir_buttn = QPushButton(u"Elegir un directorio")
self.downloaddir_buttn.clicked.connect(self._choose_dir)
grid.addWidget(self.downloaddir_buttn, 2, 1, 3, 2)
self.autoreload_checkbox = QCheckBox(
u"Recargar automáticamente la lista de episodios al iniciar")
prv = config.get('autorefresh', False)
self.autoreload_checkbox.setChecked(prv)
grid.addWidget(self.autoreload_checkbox, 3, 0, 4, 2)
self.shownotifs_checkbox = QCheckBox(
u"Mostrar una notificación cuando termina cada descarga")
prv = config.get('notification', True)
self.shownotifs_checkbox.setChecked(prv)
grid.addWidget(self.shownotifs_checkbox, 4, 0, 5, 2)
def _choose_dir(self):
"""Choose a directory using a dialog."""
resp = QFileDialog.getExistingDirectory(self, '',
os.path.expanduser("~"))
if resp:
self.downloaddir_entry.setText(resp)
def get_config(self):
"""Return the config for this tab."""
d = {}
d['downloaddir'] = self.downloaddir_entry.text()
d['autorefresh'] = self.autoreload_checkbox.isChecked()
d['notification'] = self.shownotifs_checkbox.isChecked()
return d
def add_buttons_to_layout(self, layout):
"""Add tool buttons to layout"""
# Show crop rectangle checkbox
show_crop = QCheckBox(_("Show cropping rectangle"), self)
show_crop.setChecked(True)
self.connect(show_crop, SIGNAL("toggled(bool)"), self.show_crop_rect)
layout.addWidget(show_crop)
layout.addSpacing(15)
base.BaseTransformMixin.add_buttons_to_layout(self, layout)
def getArguments(self, parent=None):
description = "The CSV export requires some information before it starts:"
dialog = CustomDialog("CSV Export", description, parent)
default_csv_output_path = self.getDataKWValue("CSV_OUTPUT_PATH",
default="output.csv")
output_path_model = PathModel(default_csv_output_path)
output_path_chooser = PathChooser(output_path_model)
design_matrix_default = self.getDataKWValue("DESIGN_MATRIX_PATH",
default="")
design_matrix_path_model = PathModel(design_matrix_default,
is_required=False,
must_exist=True)
design_matrix_path_chooser = PathChooser(design_matrix_path_model)
list_edit = ListEditBox(self.getAllCaseList())
infer_iteration_check = QCheckBox()
infer_iteration_check.setChecked(True)
infer_iteration_check.setToolTip(CSVExportJob.INFER_HELP)
drop_const_columns_check = QCheckBox()
drop_const_columns_check.setChecked(False)
drop_const_columns_check.setToolTip(
"If checked, exclude columns whose value is the same for every entry"
)
dialog.addLabeledOption("Output file path", output_path_chooser)
dialog.addLabeledOption("Design matrix path",
design_matrix_path_chooser)
dialog.addLabeledOption("List of cases to export", list_edit)
dialog.addLabeledOption("Infer iteration number",
infer_iteration_check)
dialog.addLabeledOption("Drop constant columns",
drop_const_columns_check)
dialog.addButtons()
success = dialog.showAndTell()
if success:
design_matrix_path = design_matrix_path_model.getPath()
if design_matrix_path.strip() == "":
design_matrix_path = None
case_list = ",".join(list_edit.getItems())
return [
output_path_model.getPath(),
case_list,
design_matrix_path,
infer_iteration_check.isChecked(),
drop_const_columns_check.isChecked(),
]
raise CancelPluginException("User cancelled!")
def __init__(self, names):
"""
Constructor
"""
QDialog.__init__(self)
self.__names = names
self.setWindowTitle(
QCoreApplication.translate("VDLTools", "Choose Controls"))
self.__layout = QGridLayout()
self.__confirmLabel = QLabel(
QCoreApplication.translate(
"VDLTools", "Choose which controls you want to process :"))
self.__layout.addWidget(self.__confirmLabel, 0, 0, 1, 2)
self.__group = QButtonGroup()
self.__controlsLabels = []
self.__controlsChecks = []
self.__scrollLayout = QGridLayout()
for i in range(len(self.__names)):
label = QLabel(self.__names[i])
label.setMinimumHeight(20)
label.setMinimumWidth(50)
self.__controlsLabels.append(label)
self.__scrollLayout.addWidget(self.__controlsLabels[i], i + 1, 0)
check = QCheckBox()
check.setChecked(False)
self.__controlsChecks.append(check)
self.__scrollLayout.addWidget(self.__controlsChecks[i], i + 1, 1)
widget = QWidget()
widget.setLayout(self.__scrollLayout)
scroll = QScrollArea()
scroll.setWidgetResizable(True)
scroll.setWidget(widget)
self.__layout.addWidget(scroll, 1, 0, 1, 2)
self.__okButton = QPushButton(
QCoreApplication.translate("VDLTools", "Ok"))
self.__okButton.setMinimumHeight(20)
self.__okButton.setMinimumWidth(100)
self.__cancelButton = QPushButton(
QCoreApplication.translate("VDLTools", "Cancel"))
self.__cancelButton.setMinimumHeight(20)
self.__cancelButton.setMinimumWidth(100)
self.__layout.addWidget(self.__okButton, 100, 0)
self.__layout.addWidget(self.__cancelButton, 100, 1)
self.setLayout(self.__layout)
def add_buttons_to_layout(self, layout):
"""Add tool buttons to layout"""
# Show crop rectangle checkbox
show_crop = QCheckBox(_("Show cropping rectangle"), self)
show_crop.setChecked(True)
self.connect(show_crop, SIGNAL("toggled(bool)"), self.show_crop_rect)
layout.addWidget(show_crop)
layout.addSpacing(15)
base.BaseTransformMixin.add_buttons_to_layout(self, layout)
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 Articulations(tool.Tool):
"""Articulations tool in the quick insert panel toolbox.
"""
def __init__(self, panel):
super(Articulations, self).__init__(panel)
self.shorthands = QCheckBox(self)
self.shorthands.setChecked(True)
self.removemenu = QToolButton(self,
autoRaise=True,
popupMode=QToolButton.InstantPopup,
icon=icons.get('edit-clear'))
mainwindow = panel.parent().mainwindow()
mainwindow.selectionStateChanged.connect(self.removemenu.setEnabled)
self.removemenu.setEnabled(mainwindow.hasSelection())
ac = documentactions.DocumentActions.instance(mainwindow).actionCollection
self.removemenu.addAction(ac.tools_quick_remove_articulations)
self.removemenu.addAction(ac.tools_quick_remove_ornaments)
self.removemenu.addAction(ac.tools_quick_remove_instrument_scripts)
layout = QHBoxLayout()
layout.addWidget(self.shorthands)
layout.addWidget(self.removemenu)
layout.addStretch(1)
self.layout().addLayout(layout)
for cls in (
ArticulationsGroup,
OrnamentsGroup,
SignsGroup,
OtherGroup,
):
self.layout().addWidget(cls(self))
self.layout().addStretch(1)
app.translateUI(self)
def translateUI(self):
self.shorthands.setText(_("Allow shorthands"))
self.shorthands.setToolTip(_(
"Use short notation for some articulations like staccato."))
self.removemenu.setToolTip(_(
"Remove articulations etc."))
def icon(self):
"""Should return an icon for our tab."""
return symbols.icon("articulation_prall")
def title(self):
"""Should return a title for our tab."""
return _("Articulations")
def tooltip(self):
"""Returns a tooltip"""
return _("Different kinds of articulations and other signs.")
class AppForm(QDialog):
def __init__(self, parent=None):
QDialog.__init__(self, parent)
self.setWindowTitle('manualGUI')
self.resize(600, 400)
self.create_main_frame()
print('Start!!!\r\n')
def closeEvent(self, event):
print('Stop!!!\r\n')
def on_chkLED(self):
if self.chkLED.checkState():
print('On\r\n')
else:
print('On\r\n')
def timer_tick(self):
print('Tick!!!\r\n')
def create_main_frame(self):
self.timer = QTimer()
self.timer.timeout.connect(self.timer_tick)
self.horizontalLayout = QHBoxLayout(self)
self.tabs = QTabWidget(self)
self.tab1 = QWidget()
self.tabs.addTab(self.tab1, "t1")
self.tab2 = QWidget()
self.tabs.addTab(self.tab2, "t2")
self.horizontalLayout.addWidget(self.tabs)
self.chkLED = QCheckBox("LED", self.tab1)
self.chkLED.setChecked(False)
self.connect(self.chkLED, SIGNAL('stateChanged(int)'), self.on_chkLED)
self.labButton = QLabel("Button OFF", self.tab1)
self.memo = QTextBrowser(self.tab1)
vbox = QVBoxLayout()
vbox.addWidget(self.chkLED)
vbox.addWidget(self.labButton)
vbox.addWidget(self.memo)
self.tab1.setLayout(vbox)
self.fig = Figure()
self.canvas = FigureCanvas(self.fig)
self.canvas.setParent(self)
self.axes = self.fig.add_subplot(111)
hbox = QVBoxLayout()
hbox.addWidget(self.canvas)
self.tab2.setLayout(hbox)
self.tabs.setCurrentIndex(1)
def buildPostProcessorForm(self, theParams):
"""Build Post Processor Tab
Args:
* theParams - dictionary containing element of form
Returns:
not applicable
"""
# create postprocessors tab
myTab = QWidget()
myFormLayout = QFormLayout(myTab)
myFormLayout.setLabelAlignment(Qt.AlignLeft)
self.tabWidget.addTab(myTab, self.tr('Postprocessors'))
self.tabWidget.tabBar().setVisible(True)
# create element for the tab
myValues = {}
for myLabel, myOptions in theParams.items():
myInputValues = {}
# NOTE (gigih) : 'params' is assumed as dictionary
if 'params' in myOptions:
myGroupBox = QGroupBox()
myGroupBox.setCheckable(True)
myGroupBox.setTitle(get_postprocessor_human_name(myLabel))
# NOTE (gigih): is 'on' always exist??
myGroupBox.setChecked(myOptions.get('on'))
myInputValues['on'] = self.bind(myGroupBox, 'checked', bool)
myLayout = QFormLayout(myGroupBox)
myGroupBox.setLayout(myLayout)
# create widget element from 'params'
myInputValues['params'] = {}
for myKey, myValue in myOptions['params'].items():
myHumanName = get_postprocessor_human_name(myKey)
myInputValues['params'][myKey] = self.buildWidget(
myLayout, myHumanName, myValue)
myFormLayout.addRow(myGroupBox, None)
elif 'on' in myOptions:
myCheckBox = QCheckBox()
myCheckBox.setText(get_postprocessor_human_name(myLabel))
myCheckBox.setChecked(myOptions['on'])
myInputValues['on'] = self.bind(myCheckBox, 'checked', bool)
myFormLayout.addRow(myCheckBox, None)
else:
raise NotImplementedError('This case is not handled for now')
myValues[myLabel] = myInputValues
self.values['postprocessors'] = myValues
def buildPostProcessorForm(self, theParams):
"""Build Post Processor Tab
Args:
* theParams - dictionary containing element of form
Returns:
not applicable
"""
# create postprocessors tab
myTab = QWidget()
myFormLayout = QFormLayout(myTab)
myFormLayout.setLabelAlignment(Qt.AlignLeft)
self.tabWidget.addTab(myTab, self.tr('Postprocessors'))
self.tabWidget.tabBar().setVisible(True)
# create element for the tab
myValues = {}
for myLabel, myOptions in theParams.items():
myInputValues = {}
# NOTE (gigih) : 'params' is assumed as dictionary
if 'params' in myOptions:
myGroupBox = QGroupBox()
myGroupBox.setCheckable(True)
myGroupBox.setTitle(get_postprocessor_human_name(myLabel))
# NOTE (gigih): is 'on' always exist??
myGroupBox.setChecked(myOptions.get('on'))
myInputValues['on'] = self.bind(myGroupBox, 'checked', bool)
myLayout = QFormLayout(myGroupBox)
myGroupBox.setLayout(myLayout)
# create widget element from 'params'
myInputValues['params'] = {}
for myKey, myValue in myOptions['params'].items():
myHumanName = get_postprocessor_human_name(myKey)
myInputValues['params'][myKey] = self.buildWidget(
myLayout, myHumanName, myValue)
myFormLayout.addRow(myGroupBox, None)
elif 'on' in myOptions:
myCheckBox = QCheckBox()
myCheckBox.setText(get_postprocessor_human_name(myLabel))
myCheckBox.setChecked(myOptions['on'])
myInputValues['on'] = self.bind(myCheckBox, 'checked', bool)
myFormLayout.addRow(myCheckBox, None)
else:
raise NotImplementedError('This case is not handled for now')
myValues[myLabel] = myInputValues
self.values['postprocessors'] = myValues
class LilyPondVersions(SettingsGroup):
"""Manage multiple versions of LilyPond."""
def __init__(self, page):
super(LilyPondVersions, self).__init__(i18n("LilyPond versions to use:"), page)
layout = QVBoxLayout(self)
self.instances = LilyPondInfoList(self)
self.instances.changed.connect(page.changed)
layout.addWidget(self.instances)
self.auto = QCheckBox(
i18n("Enable automatic version selection " "(choose LilyPond version from document)"), clicked=page.changed
)
layout.addWidget(self.auto)
def defaults(self):
""" Reset ourselves to default state. """
self.instances.clear()
info = self.instances.createItem()
self.instances.addItem(info)
self.instances.setCurrentItem(info)
self.auto.setChecked(False)
def loadSettings(self):
self.instances.clear()
conf = config("lilypond")
self.auto.setChecked(conf.readEntry("automatic version", False))
paths = conf.readEntry("paths", ["lilypond"])
default = conf.readEntry("default", "lilypond")
# sort on version and move erratic entries to the end
paths.sort(key=lambda path: ly.version.LilyPondInstance(path).version() or (999,))
for path in paths:
info = LilyPondInfoItem(path)
info.loadSettings(conf.group(path))
info.default = path == default
self.instances.addItem(info)
if info.default:
self.instances.setCurrentItem(info)
def saveSettings(self):
paths = []
default = ""
conf = config("lilypond")
conf.deleteGroup()
for info in self.instances.items():
paths.append(info.lilypond)
if info.default:
default = info.lilypond
info.saveSettings(conf.group(info.lilypond))
if not paths:
paths = ["lilypond"]
if not default:
default = paths[0]
conf.writeEntry("paths", paths)
conf.writeEntry("default", default)
conf.writeEntry("automatic version", self.auto.isChecked())
class Articulations(tool.Tool):
"""Articulations tool in the quick insert panel toolbox.
"""
def __init__(self, panel):
super(Articulations, self).__init__(panel)
self.shorthands = QCheckBox(self)
self.shorthands.setChecked(True)
self.removemenu = QToolButton(self,
autoRaise=True,
popupMode=QToolButton.InstantPopup,
icon=icons.get('edit-clear'))
mainwindow = panel.parent().mainwindow()
mainwindow.selectionStateChanged.connect(self.removemenu.setEnabled)
self.removemenu.setEnabled(mainwindow.hasSelection())
ac = documentactions.DocumentActions.instance(
mainwindow).actionCollection
self.removemenu.addAction(ac.tools_quick_remove_articulations)
self.removemenu.addAction(ac.tools_quick_remove_ornaments)
self.removemenu.addAction(ac.tools_quick_remove_instrument_scripts)
layout = QHBoxLayout()
layout.addWidget(self.shorthands)
layout.addWidget(self.removemenu)
layout.addStretch(1)
self.layout().addLayout(layout)
for cls in (
ArticulationsGroup,
OrnamentsGroup,
SignsGroup,
OtherGroup,
):
self.layout().addWidget(cls(self))
self.layout().addStretch(1)
app.translateUI(self)
def translateUI(self):
self.shorthands.setText(_("Allow shorthands"))
self.shorthands.setToolTip(
_("Use short notation for some articulations like staccato."))
self.removemenu.setToolTip(_("Remove articulations etc."))
def icon(self):
"""Should return an icon for our tab."""
return symbols.icon("articulation_prall")
def title(self):
"""Should return a title for our tab."""
return _("Articulations")
def tooltip(self):
"""Returns a tooltip"""
return _("Different kinds of articulations and other signs.")
class QuadStatusBar(QHBoxLayout):
def __init__(self, parent=None ):
QHBoxLayout.__init__(self, parent)
self.setContentsMargins(0,4,0,0)
self.setSpacing(0)
def showXYCoordinates(self):
self.zLabel.setHidden(True)
self.zSpinBox.setHidden(True)
def showXYZCoordinates(self):
self.zLabel.setHidden(False)
self.zSpinBox.setHidden(False)
def createQuadViewStatusBar(self,
xbackgroundColor, xforegroundColor,
ybackgroundColor, yforegroundColor,
zbackgroundColor, zforegroundColor):
self.xLabel, self.xSpinBox = _get_pos_widget('X',
xbackgroundColor,
xforegroundColor)
self.yLabel, self.ySpinBox = _get_pos_widget('Y',
ybackgroundColor,
yforegroundColor)
self.zLabel, self.zSpinBox = _get_pos_widget('Z',
zbackgroundColor,
zforegroundColor)
self.addWidget(self.xLabel)
self.addWidget(self.xSpinBox)
self.addWidget(self.yLabel)
self.addWidget(self.ySpinBox)
self.addWidget(self.zLabel)
self.addWidget(self.zSpinBox)
self.addStretch()
self.positionCheckBox = QCheckBox()
self.positionCheckBox.setChecked(True)
self.positionCheckBox.setCheckable(True)
self.positionCheckBox.setText("Position")
self.addWidget(self.positionCheckBox)
self.addSpacing(20)
self.timeLabel = QLabel("Time:")
self.addWidget(self.timeLabel)
self.timeSpinBox = QSpinBox()
self.addWidget(self.timeSpinBox)
def setMouseCoords(self, x, y, z):
self.xSpinBox.setValue(x)
self.ySpinBox.setValue(y)
self.zSpinBox.setValue(z)
class QuadStatusBar(QHBoxLayout):
def __init__(self, parent=None ):
QHBoxLayout.__init__(self, parent)
self.setContentsMargins(0,4,0,0)
self.setSpacing(0)
def showXYCoordinates(self):
self.zLabel.setHidden(True)
self.zSpinBox.setHidden(True)
def showXYZCoordinates(self):
self.zLabel.setHidden(False)
self.zSpinBox.setHidden(False)
def createQuadViewStatusBar(self,
xbackgroundColor, xforegroundColor,
ybackgroundColor, yforegroundColor,
zbackgroundColor, zforegroundColor):
self.xLabel, self.xSpinBox = _get_pos_widget('X',
xbackgroundColor,
xforegroundColor)
self.yLabel, self.ySpinBox = _get_pos_widget('Y',
ybackgroundColor,
yforegroundColor)
self.zLabel, self.zSpinBox = _get_pos_widget('Z',
zbackgroundColor,
zforegroundColor)
self.addWidget(self.xLabel)
self.addWidget(self.xSpinBox)
self.addWidget(self.yLabel)
self.addWidget(self.ySpinBox)
self.addWidget(self.zLabel)
self.addWidget(self.zSpinBox)
self.addStretch()
self.positionCheckBox = QCheckBox()
self.positionCheckBox.setChecked(True)
self.positionCheckBox.setCheckable(True)
self.positionCheckBox.setText("Position")
self.addWidget(self.positionCheckBox)
self.addSpacing(20)
self.timeLabel = QLabel("Time:")
self.addWidget(self.timeLabel)
self.timeSpinBox = QSpinBox()
self.addWidget(self.timeSpinBox)
def setMouseCoords(self, x, y, z):
self.xSpinBox.setValue(x)
self.ySpinBox.setValue(y)
self.zSpinBox.setValue(z)
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 DeletionOptions(QDialog):
def __init__(self, parent, model):
flags = Qt.CustomizeWindowHint | Qt.WindowTitleHint | Qt.WindowSystemMenuHint
QDialog.__init__(self, parent, flags)
self.model = model
self._setupUi()
self.model.view = self
self.buttonBox.accepted.connect(self.accept)
self.buttonBox.rejected.connect(self.reject)
def _setupUi(self):
self.setWindowTitle(tr("Deletion Options"))
self.resize(400, 270)
self.verticalLayout = QVBoxLayout(self)
self.msgLabel = QLabel()
self.verticalLayout.addWidget(self.msgLabel)
self.linkCheckbox = QCheckBox(tr("Link deleted files"))
self.verticalLayout.addWidget(self.linkCheckbox)
text = tr("After having deleted a duplicate, place a link targeting the reference file "
"to replace the deleted file.")
self.linkMessageLabel = QLabel(text)
self.linkMessageLabel.setWordWrap(True)
self.verticalLayout.addWidget(self.linkMessageLabel)
self.linkTypeRadio = RadioBox(items=[tr("Symlink"), tr("Hardlink")], spread=False)
self.verticalLayout.addWidget(self.linkTypeRadio)
if not self.model.supports_links():
self.linkCheckbox.setEnabled(False)
self.linkTypeRadio.setEnabled(False)
self.linkCheckbox.setText(self.linkCheckbox.text() + tr(" (unsupported)"))
self.directCheckbox = QCheckBox(tr("Directly delete files"))
self.verticalLayout.addWidget(self.directCheckbox)
text = tr("Instead of sending files to trash, delete them directly. This option is usually "
"used as a workaround when the normal deletion method doesn't work.")
self.directMessageLabel = QLabel(text)
self.directMessageLabel.setWordWrap(True)
self.verticalLayout.addWidget(self.directMessageLabel)
self.buttonBox = QDialogButtonBox()
self.buttonBox.addButton(tr("Proceed"), QDialogButtonBox.AcceptRole)
self.buttonBox.addButton(tr("Cancel"), QDialogButtonBox.RejectRole)
self.verticalLayout.addWidget(self.buttonBox)
#--- model --> view
def update_msg(self, msg):
self.msgLabel.setText(msg)
def show(self):
self.linkCheckbox.setChecked(self.model.link_deleted)
self.linkTypeRadio.selected_index = 1 if self.model.use_hardlinks else 0
self.directCheckbox.setChecked(self.model.direct)
result = self.exec()
self.model.link_deleted = self.linkCheckbox.isChecked()
self.model.use_hardlinks = self.linkTypeRadio.selected_index == 1
self.model.direct = self.directCheckbox.isChecked()
return result == QDialog.Accepted
def checkTrueImportedMetadataFromConfigFile(self):
list_metadata_selected = self.list_metadata_selected
_config_table = self.ui.configureTable
nbr_row = _config_table.rowCount()
for r in range(nbr_row):
_name = self.ui.configureTable.item(r, 1).text()
_yesNo = QCheckBox()
if _name in list_metadata_selected:
_yesNo.setChecked(True)
_yesNo.setText('')
self.ui.configureTable.setCellWidget(r, 0, _yesNo)
def build_post_processor_form(self, parameters):
"""Build Post Processor Tab.
:param parameters: A Dictionary containing element of form
:type parameters: dict
"""
# create postprocessors tab
tab = QWidget()
form_layout = QFormLayout(tab)
form_layout.setLabelAlignment(Qt.AlignLeft)
self.tabWidget.addTab(tab, self.tr('Postprocessors'))
self.tabWidget.tabBar().setVisible(True)
# create element for the tab
values = OrderedDict()
for label, options in parameters.items():
input_values = OrderedDict()
# NOTE (gigih) : 'params' is assumed as dictionary
if 'params' in options:
group_box = QGroupBox()
group_box.setCheckable(True)
group_box.setTitle(get_postprocessor_human_name(label))
# NOTE (gigih): is 'on' always exist??
# (MB) should always be there
group_box.setChecked(options.get('on'))
input_values['on'] = self.bind(group_box, 'checked', bool)
layout = QFormLayout(group_box)
group_box.setLayout(layout)
# create widget element from 'params'
input_values['params'] = OrderedDict()
for key, value in options['params'].items():
input_values['params'][key] = self.build_widget(
layout, key, value)
form_layout.addRow(group_box, None)
elif 'on' in options:
checkbox = QCheckBox()
checkbox.setText(get_postprocessor_human_name(label))
checkbox.setChecked(options['on'])
input_values['on'] = self.bind(checkbox, 'checked', bool)
form_layout.addRow(checkbox, None)
else:
raise NotImplementedError('This case is not handled for now')
values[label] = input_values
self.values['postprocessors'] = values
def addCheckBox(self, name, description, default_value):
checkbox = QCheckBox(description)
checkbox.setChecked(default_value)
self.__custom[name] = default_value
def toggle(checked):
self.__custom[name] = checked
self.emitChange()
checkbox.toggled.connect(toggle)
self.__layout.addWidget(checkbox)
def extra_keywords_to_widgets(extra_keyword_definition):
"""Create widgets for extra keyword.
:param extra_keyword_definition: An extra keyword definition.
:type extra_keyword_definition: dict
:return: QCheckBox and The input widget
:rtype: (QCheckBox, QWidget)
"""
# Check box
check_box = QCheckBox(extra_keyword_definition['name'])
check_box.setToolTip(extra_keyword_definition['description'])
check_box.setChecked(True)
# Input widget
if extra_keyword_definition['type'] == float:
input_widget = QDoubleSpinBox()
input_widget.setMinimum(extra_keyword_definition['minimum'])
input_widget.setMaximum(extra_keyword_definition['maximum'])
input_widget.setSuffix(extra_keyword_definition['unit_string'])
elif extra_keyword_definition['type'] == int:
input_widget = QSpinBox()
input_widget.setMinimum(extra_keyword_definition['minimum'])
input_widget.setMaximum(extra_keyword_definition['maximum'])
input_widget.setSuffix(extra_keyword_definition['unit_string'])
elif extra_keyword_definition['type'] == unicode:
if extra_keyword_definition.get('options'):
input_widget = QComboBox()
options = extra_keyword_definition['options']
for option in options:
input_widget.addItem(
option['name'],
option['key'],
)
default_option_index = input_widget.findData(
extra_keyword_definition['default_option'])
input_widget.setCurrentIndex(default_option_index)
else:
input_widget = QLineEdit()
elif extra_keyword_definition['type'] == datetime:
input_widget = QDateTimeEdit()
input_widget.setCalendarPopup(True)
input_widget.setDisplayFormat('hh:mm:ss, d MMM yyyy')
input_widget.setDateTime(datetime.now())
else:
raise Exception
input_widget.setToolTip(extra_keyword_definition['description'])
# Signal
# noinspection PyUnresolvedReferences
check_box.stateChanged.connect(input_widget.setEnabled)
return check_box, input_widget
def __init__(self, parent=None):
super(Settings, self).__init__(parent)
layout = QVBoxLayout()
load()
self._controls = {}
for name in _registered:
control = QCheckBox(translate('Confirmations',
_confirmations[name][1]))
control.setChecked(_confirmations[name][0])
layout.addWidget(control)
self._controls[name] = control
layout.addStretch()
self.setLayout(layout)
def _addSwitch(self, v, cnt):
control = QCheckBox(v.name)
control.setChecked(v.value)
control.setFocusPolicy(Qt.StrongFocus)
f = control.font()
f.setPointSizeF(11)
control.setFont(f)
control.tag = cnt
if self.styleName == "mac":
control.setAttribute(Qt.WA_MacSmallSize, True)
self.layout.addWidget(control, cnt, 1)
self.connect(control, SIGNAL("stateChanged(int)"),
self.booleanChanged_)