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())
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 initializePage(self):
super(FrameworkLibraryPage, self).initializePage()
exsits = []
for moudel in app.g_configurations.modules:
exsits.append(moudel['name'])
self.checkboxs = []
index = 0
ret_json = app.render(app.g_configurations.config_content,
config=app.g_configurations)
app.g_configurations.config = json.loads(ret_json)
for moudel in app.g_configurations.config['moudels']:
checkBox = QCheckBox(moudel['name'])
checkBox.setToolTip(moudel['description'])
if moudel['buildin']:
checkBox.setCheckState(Qt.Checked)
checkBox.setEnabled(False)
elif moudel['name'] in exsits:
checkBox.setCheckState(Qt.Checked)
else:
checkBox.setCheckState(Qt.Unchecked)
row = index / 3
offset = index % 3
self.gLayout.addWidget(checkBox, row, offset)
self.checkboxs.append(checkBox)
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 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())
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())
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())
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 create_scedit(self, text, option, default=NoDefault, tip=None,
without_layout=False):
label = QLabel(text)
clayout = ColorLayout(QColor(Qt.black), self)
clayout.lineedit.setMaximumWidth(80)
if tip is not None:
clayout.setToolTip(tip)
cb_bold = QCheckBox()
cb_bold.setIcon(get_icon("bold.png"))
cb_bold.setToolTip(_("Bold"))
cb_italic = QCheckBox()
cb_italic.setIcon(get_icon("italic.png"))
cb_italic.setToolTip(_("Italic"))
self.scedits[(clayout, cb_bold, cb_italic)] = (option, default)
if without_layout:
return label, clayout, cb_bold, cb_italic
layout = QHBoxLayout()
layout.addWidget(label)
layout.addLayout(clayout)
layout.addSpacing(10)
layout.addWidget(cb_bold)
layout.addWidget(cb_italic)
layout.addStretch(1)
layout.setContentsMargins(0, 0, 0, 0)
widget = QWidget(self)
widget.setLayout(layout)
return widget
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!")
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 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 StaffGroup(_base.Container):
@staticmethod
def title(_=_base.translate):
return _("Staff Group")
def accepts(self):
return (StaffGroup, _base.Part)
def createWidgets(self, layout):
self.systemStartLabel = QLabel()
self.systemStart = QComboBox()
self.systemStartLabel.setBuddy(self.systemStart)
self.systemStart.setModel(
listmodel.ListModel(
(
# L10N: Brace like a piano staff
(lambda: _("Brace"), 'system_start_brace'),
# L10N: Bracket like a choir staff
(lambda: _("Bracket"), 'system_start_bracket'),
# L10N: Square bracket like a sub-group
(lambda: _("Square"), 'system_start_square'),
),
self.systemStart,
display=listmodel.translate_index(0),
icon=lambda item: symbols.icon(item[1])))
self.systemStart.setIconSize(QSize(64, 64))
self.connectBarLines = QCheckBox(checked=True)
box = QHBoxLayout()
box.addWidget(self.systemStartLabel)
box.addWidget(self.systemStart)
layout.addLayout(box)
layout.addWidget(self.connectBarLines)
def translateWidgets(self):
self.systemStartLabel.setText(_("Type:"))
self.connectBarLines.setText(_("Connect Barlines"))
self.connectBarLines.setToolTip(
_("If checked, barlines are connected between the staves."))
self.systemStart.model().update()
def build(self, data, builder):
s = self.systemStart.currentIndex()
b = self.connectBarLines.isChecked()
if s == 0:
node = ly.dom.GrandStaff()
if not b:
ly.dom.Line("\\remove Span_bar_engraver", node.getWith())
else:
node = ly.dom.StaffGroup() if b else ly.dom.ChoirStaff()
if s == 2:
node.getWith()['systemStartDelimiter'] = ly.dom.Scheme(
"'SystemStartSquare")
data.nodes.append(node)
data.music = ly.dom.Simr(node)
class SavingDocument(preferences.Group):
def __init__(self, page):
super(SavingDocument, self).__init__(page)
layout = QVBoxLayout()
self.setLayout(layout)
self.stripwsp = QCheckBox(toggled=self.changed)
self.backup = QCheckBox(toggled=self.changed)
self.metainfo = QCheckBox(toggled=self.changed)
layout.addWidget(self.stripwsp)
layout.addWidget(self.backup)
layout.addWidget(self.metainfo)
hbox = QHBoxLayout()
layout.addLayout(hbox)
self.basedirLabel = l = QLabel()
self.basedir = UrlRequester()
hbox.addWidget(self.basedirLabel)
hbox.addWidget(self.basedir)
self.basedir.changed.connect(self.changed)
app.translateUI(self)
def translateUI(self):
self.setTitle(_("When saving documents"))
self.stripwsp.setText(_("Strip trailing whitespace"))
self.stripwsp.setToolTip(
_("If checked, Frescobaldi will remove unnecessary whitespace at the "
"end of lines (but not inside multi-line strings)."))
self.backup.setText(_("Keep backup copy"))
self.backup.setToolTip(
_("Frescobaldi always backups a file before overwriting it "
"with a new version.\n"
"If checked those backup copies are retained."))
self.metainfo.setText(_("Remember cursor position, bookmarks, etc."))
self.basedirLabel.setText(_("Default directory:"))
self.basedirLabel.setToolTip(
_("The default folder for your LilyPond documents (optional)."))
def loadSettings(self):
s = QSettings()
self.stripwsp.setChecked(
s.value("strip_trailing_whitespace", False, bool))
self.backup.setChecked(s.value("backup_keep", False, bool))
self.metainfo.setChecked(s.value("metainfo", True, bool))
self.basedir.setPath(s.value("basedir", "", type("")))
def saveSettings(self):
s = QSettings()
s.setValue("strip_trailing_whitespace", self.stripwsp.isChecked())
s.setValue("backup_keep", self.backup.isChecked())
s.setValue("metainfo", self.metainfo.isChecked())
s.setValue("basedir", self.basedir.path())
class LogTool(preferences.Group):
def __init__(self, page):
super(LogTool, self).__init__(page)
layout = QVBoxLayout()
self.setLayout(layout)
self.fontLabel = QLabel()
self.fontChooser = QFontComboBox(currentFontChanged=self.changed)
self.fontSize = QDoubleSpinBox(valueChanged=self.changed)
self.fontSize.setRange(6.0, 32.0)
self.fontSize.setSingleStep(0.5)
self.fontSize.setDecimals(1)
box = QHBoxLayout()
box.addWidget(self.fontLabel)
box.addWidget(self.fontChooser, 1)
box.addWidget(self.fontSize)
layout.addLayout(box)
self.showlog = QCheckBox(toggled=self.changed)
layout.addWidget(self.showlog)
self.rawview = QCheckBox(toggled=self.changed)
layout.addWidget(self.rawview)
app.translateUI(self)
def translateUI(self):
self.setTitle(_("LilyPond Log"))
self.fontLabel.setText(_("Font:"))
self.showlog.setText(_("Show log when a job is started"))
self.rawview.setText(_("Display plain log output"))
self.rawview.setToolTip(_(
"If checked, Frescobaldi will not shorten filenames in the log output."""))
def loadSettings(self):
s = QSettings()
s.beginGroup("log")
font = QFont(s.value("fontfamily", "monospace"))
font.setPointSizeF(float(s.value("fontsize", 9.0)))
with qutil.signalsBlocked(self.fontChooser, self.fontSize):
self.fontChooser.setCurrentFont(font)
self.fontSize.setValue(font.pointSizeF())
self.showlog.setChecked(s.value("show_on_start", True) not in (False, "false"))
self.rawview.setChecked(s.value("rawview", True) not in (False, "false"))
def saveSettings(self):
s = QSettings()
s.beginGroup("log")
s.setValue("fontfamily", self.fontChooser.currentFont().family())
s.setValue("fontsize", self.fontSize.value())
s.setValue("show_on_start", self.showlog.isChecked())
s.setValue("rawview", self.rawview.isChecked())
def setup_method_layout(self):
self.methods = [method() for method in self.methods]
self.buttons = []
for i, method in enumerate(self.methods):
cb = QCheckBox(self.textify(method.name))
cb.setChecked(i in self.checked)
cb.stateChanged.connect(self.update_value)
cb.setToolTip(self.get_tooltip(method))
self.method_layout.addWidget(cb)
self.buttons.append(cb)
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
class SavingDocument(preferences.Group):
def __init__(self, page):
super(SavingDocument, self).__init__(page)
layout = QVBoxLayout()
self.setLayout(layout)
self.stripwsp = QCheckBox(toggled=self.changed)
self.backup = QCheckBox(toggled=self.changed)
self.metainfo = QCheckBox(toggled=self.changed)
layout.addWidget(self.stripwsp)
layout.addWidget(self.backup)
layout.addWidget(self.metainfo)
hbox = QHBoxLayout()
layout.addLayout(hbox)
self.basedirLabel = l = QLabel()
self.basedir = UrlRequester()
hbox.addWidget(self.basedirLabel)
hbox.addWidget(self.basedir)
self.basedir.changed.connect(self.changed)
app.translateUI(self)
def translateUI(self):
self.setTitle(_("When saving documents"))
self.stripwsp.setText(_("Strip trailing whitespace"))
self.stripwsp.setToolTip(_(
"If checked, Frescobaldi will remove unnecessary whitespace at the "
"end of lines (but not inside multi-line strings)."))
self.backup.setText(_("Keep backup copy"))
self.backup.setToolTip(_(
"Frescobaldi always backups a file before overwriting it "
"with a new version.\n"
"If checked those backup copies are retained."))
self.metainfo.setText(_("Remember cursor position, bookmarks, etc."))
self.basedirLabel.setText(_("Default directory:"))
self.basedirLabel.setToolTip(_("The default folder for your LilyPond documents (optional)."))
def loadSettings(self):
s = QSettings()
self.stripwsp.setChecked(s.value("strip_trailing_whitespace", False, bool))
self.backup.setChecked(s.value("backup_keep", False, bool))
self.metainfo.setChecked(s.value("metainfo", True, bool))
self.basedir.setPath(s.value("basedir", "", type("")))
def saveSettings(self):
s = QSettings()
s.setValue("strip_trailing_whitespace", self.stripwsp.isChecked())
s.setValue("backup_keep", self.backup.isChecked())
s.setValue("metainfo", self.metainfo.isChecked())
s.setValue("basedir", self.basedir.path())
class Target(preferences.Group):
def __init__(self, page):
super(Target, self).__init__(page)
layout = QGridLayout()
self.setLayout(layout)
self.targetPDF = QRadioButton(toggled=page.changed)
self.targetSVG = QRadioButton(toggled=page.changed)
self.openDefaultView = QCheckBox(clicked=page.changed)
layout.addWidget(self.targetPDF, 0, 0)
layout.addWidget(self.targetSVG, 0, 1)
layout.addWidget(self.openDefaultView, 1, 0, 1, 5)
app.translateUI(self)
def translateUI(self):
self.setTitle(_("Default output format"))
self.targetPDF.setText(_("PDF"))
self.targetPDF.setToolTip(
_("Create PDF (Portable Document Format) documents by default."))
self.targetSVG.setText(_("SVG"))
self.targetSVG.setToolTip(
_("Create SVG (Scalable Vector Graphics) documents by default."))
self.openDefaultView.setText(
_("Open default viewer after successful compile"))
self.openDefaultView.setToolTip(
_("Shows the PDF or SVG music view when a compile job finishes "
"successfully."))
def loadSettings(self):
s = settings()
target = s.value("default_output_target", "pdf", type(""))
if target == "svg":
self.targetSVG.setChecked(True)
self.targetPDF.setChecked(False)
else:
self.targetSVG.setChecked(False)
self.targetPDF.setChecked(True)
self.openDefaultView.setChecked(
s.value("open_default_view", True, bool))
def saveSettings(self):
s = settings()
if self.targetSVG.isChecked():
target = "svg"
else:
target = "pdf"
s.setValue("default_output_target", target)
s.setValue("open_default_view", self.openDefaultView.isChecked())
class Running(preferences.Group):
def __init__(self, page):
super(Running, self).__init__(page)
layout = QVBoxLayout()
self.setLayout(layout)
self.saveDocument = QCheckBox(clicked=self.changed)
self.deleteFiles = QCheckBox(clicked=self.changed)
self.embedSourceCode = QCheckBox(clicked=self.changed)
self.noTranslation = QCheckBox(clicked=self.changed)
self.includeLabel = QLabel()
self.include = widgets.listedit.FilePathEdit()
self.include.listBox.setDragDropMode(QAbstractItemView.InternalMove)
self.include.changed.connect(self.changed)
layout.addWidget(self.saveDocument)
layout.addWidget(self.deleteFiles)
layout.addWidget(self.embedSourceCode)
layout.addWidget(self.noTranslation)
layout.addWidget(self.includeLabel)
layout.addWidget(self.include)
app.translateUI(self)
def translateUI(self):
self.setTitle(_("Running LilyPond"))
self.saveDocument.setText(_("Save document if possible"))
self.saveDocument.setToolTip(_(
"If checked, the document is saved when it is local and modified.\n"
"Otherwise a temporary file is used to run LilyPond."))
self.deleteFiles.setText(_("Delete intermediate output files"))
self.deleteFiles.setToolTip(_(
"If checked, LilyPond will delete intermediate PostScript files."))
self.embedSourceCode.setText(_("Embed Source Code files in publish mode"))
self.embedSourceCode.setToolTip(_(
"If checked, the LilyPond source files will be embedded in the PDF\n"
"when LilyPond is started in publish mode.\n"
"This feature is available since LilyPond 2.19.39."))
self.noTranslation.setText(_("Run LilyPond with English messages"))
self.noTranslation.setToolTip(_(
"If checked, LilyPond's output messages will be in English.\n"
"This can be useful for bug reports."))
self.includeLabel.setText(_("LilyPond include path:"))
def loadSettings(self):
s = settings()
self.saveDocument.setChecked(s.value("save_on_run", False, bool))
self.deleteFiles.setChecked(s.value("delete_intermediate_files", True, bool))
self.embedSourceCode.setChecked(s.value("embed_source_code", False, bool))
self.noTranslation.setChecked(s.value("no_translation", False, bool))
include_path = qsettings.get_string_list(s, "include_path")
self.include.setValue(include_path)
def saveSettings(self):
s = settings()
s.setValue("save_on_run", self.saveDocument.isChecked())
s.setValue("delete_intermediate_files", self.deleteFiles.isChecked())
s.setValue("embed_source_code", self.embedSourceCode.isChecked())
s.setValue("no_translation", self.noTranslation.isChecked())
s.setValue("include_path", self.include.value())
class StaffGroup(_base.Container):
@staticmethod
def title(_=_base.translate):
return _("Staff Group")
def accepts(self):
return (StaffGroup, _base.Part)
def createWidgets(self, layout):
self.systemStartLabel = QLabel()
self.systemStart = QComboBox()
self.systemStartLabel.setBuddy(self.systemStart)
self.systemStart.setModel(listmodel.ListModel((
# L10N: Brace like a piano staff
(lambda: _("Brace"), 'system_start_brace'),
# L10N: Bracket like a choir staff
(lambda: _("Bracket"), 'system_start_bracket'),
# L10N: Square bracket like a sub-group
(lambda: _("Square"), 'system_start_square'),
), self.systemStart, display=listmodel.translate_index(0),
icon=lambda item: symbols.icon(item[1])))
self.systemStart.setIconSize(QSize(64, 64))
self.connectBarLines = QCheckBox(checked=True)
box = QHBoxLayout()
box.addWidget(self.systemStartLabel)
box.addWidget(self.systemStart)
layout.addLayout(box)
layout.addWidget(self.connectBarLines)
def translateWidgets(self):
self.systemStartLabel.setText(_("Type:"))
self.connectBarLines.setText(_("Connect Barlines"))
self.connectBarLines.setToolTip(_("If checked, barlines are connected between the staves."))
self.systemStart.model().update()
def build(self, data, builder):
s = self.systemStart.currentIndex()
b = self.connectBarLines.isChecked()
if s == 0:
node = ly.dom.GrandStaff()
if not b:
ly.dom.Line("\\remove Span_bar_engraver", node.getWith())
else:
node = ly.dom.StaffGroup() if b else ly.dom.ChoirStaff()
if s == 2:
node.getWith()['systemStartDelimiter'] = ly.dom.Scheme("'SystemStartSquare")
data.nodes.append(node)
data.music = ly.dom.Simr(node)
class Target(preferences.Group):
def __init__(self, page):
super(Target, self).__init__(page)
layout = QGridLayout()
self.setLayout(layout)
self.targetPDF = QRadioButton(toggled=page.changed)
self.targetSVG = QRadioButton(toggled=page.changed)
self.openDefaultView = QCheckBox(clicked=page.changed)
layout.addWidget(self.targetPDF, 0, 0)
layout.addWidget(self.targetSVG, 0, 1)
layout.addWidget(self.openDefaultView, 1, 0, 1, 5)
app.translateUI(self)
def translateUI(self):
self.setTitle(_("Default output format"))
self.targetPDF.setText(_("PDF"))
self.targetPDF.setToolTip(_(
"Create PDF (Portable Document Format) documents by default."))
self.targetSVG.setText(_("SVG"))
self.targetSVG.setToolTip(_(
"Create SVG (Scalable Vector Graphics) documents by default."))
self.openDefaultView.setText(_("Open default viewer after successful compile"))
self.openDefaultView.setToolTip(_(
"Shows the PDF or SVG music view when a compile job finishes "
"successfully."))
def loadSettings(self):
s = settings()
target = s.value("default_output_target", "pdf", type(""))
if target == "svg":
self.targetSVG.setChecked(True)
self.targetPDF.setChecked(False)
else:
self.targetSVG.setChecked(False)
self.targetPDF.setChecked(True)
self.openDefaultView.setChecked(s.value("open_default_view", True, bool))
def saveSettings(self):
s = settings()
if self.targetSVG.isChecked():
target = "svg"
else:
target = "pdf"
s.setValue("default_output_target", target)
s.setValue("open_default_view", self.openDefaultView.isChecked())
class SourceExport(preferences.Group):
def __init__(self, page):
super(SourceExport, self).__init__(page)
layout = QVBoxLayout()
self.setLayout(layout)
self.numberLines = QCheckBox(toggled=self.changed)
self.inlineStyleCopy = QCheckBox(toggled=self.changed)
self.copyHtmlAsPlainText = QCheckBox(toggled=self.changed)
self.inlineStyleExport = QCheckBox(toggled=self.changed)
layout.addWidget(self.numberLines)
layout.addWidget(self.inlineStyleCopy)
layout.addWidget(self.inlineStyleExport)
layout.addWidget(self.copyHtmlAsPlainText)
app.translateUI(self)
def translateUI(self):
self.setTitle(_("Source Export Preferences"))
self.numberLines.setText(_("Show line numbers"))
self.numberLines.setToolTip('<qt>' + _(
"If enabled, line numbers are shown in exported HTML or printed "
"source."))
self.inlineStyleCopy.setText(_("Use inline style when copying colored HTML"))
self.inlineStyleCopy.setToolTip('<qt>' + _(
"If enabled, inline style attributes are used when copying "
"colored HTML to the clipboard. "
"Otherwise, a CSS stylesheet is embedded."))
self.inlineStyleExport.setText(_("Use inline style when exporting colored HTML"))
self.inlineStyleExport.setToolTip('<qt>' + _(
"If enabled, inline style attributes are used when exporing "
"colored HTML to a file. "
"Otherwise, a CSS stylesheet is embedded."))
self.copyHtmlAsPlainText.setText(_("Copy HTML as plain text"))
self.copyHtmlAsPlainText.setToolTip('<qt>' + _(
"If enabled, HTML is copied to the clipboard as plain text. "
"Use this when you want to type HTML formatted code in a "
"plain text editing environment."))
def loadSettings(self):
s = QSettings()
s.beginGroup("source_export")
self.numberLines.setChecked(s.value("number_lines", False, bool))
self.inlineStyleCopy.setChecked(s.value("inline_copy", True, bool))
self.inlineStyleExport.setChecked(s.value("inline_export", False, bool))
self.copyHtmlAsPlainText.setChecked(s.value("copy_html_as_plain_text", False, bool))
def saveSettings(self):
s = QSettings()
s.beginGroup("source_export")
s.setValue("number_lines", self.numberLines.isChecked())
s.setValue("inline_copy", self.inlineStyleCopy.isChecked())
s.setValue("inline_export", self.inlineStyleExport.isChecked())
s.setValue("copy_html_as_plain_text", self.copyHtmlAsPlainText.isChecked())
def create_checkbox(self, text, option, default=NoDefault,
tip=None, msg_warning=None, msg_info=None,
msg_if_enabled=False):
checkbox = QCheckBox(text)
if tip is not None:
checkbox.setToolTip(tip)
self.checkboxes[checkbox] = (option, default)
if msg_warning is not None or msg_info is not None:
def show_message(is_checked):
if is_checked or not msg_if_enabled:
if msg_warning is not None:
QMessageBox.warning(self, self.get_name(),
msg_warning, QMessageBox.Ok)
if msg_info is not None:
QMessageBox.information(self, self.get_name(),
msg_info, QMessageBox.Ok)
self.connect(checkbox, SIGNAL("clicked(bool)"), show_message)
return checkbox
class ViewSettings(preferences.Group):
def __init__(self, page):
super(ViewSettings, self).__init__(page)
layout = QGridLayout(spacing=1)
self.setLayout(layout)
self.wrapLines = QCheckBox(toggled=self.changed)
self.numContextLines = QSpinBox(minimum=0, maximum=20, valueChanged=self.changed)
self.numContextLinesLabel = l = QLabel()
l.setBuddy(self.numContextLines)
layout.addWidget(self.wrapLines, 0, 0, 1, 1)
layout.addWidget(self.numContextLinesLabel, 1, 0)
layout.addWidget(self.numContextLines, 1, 1)
app.translateUI(self)
def translateUI(self):
self.setTitle(_("View Preferences"))
self.wrapLines.setText(_("Wrap long lines by default"))
self.wrapLines.setToolTip('<qt>' + _(
"If enabled, lines that don't fit in the editor width are wrapped "
"by default. "
"Note: when the document is displayed by multiple views, they all "
"share the same line wrapping width, which might look strange."))
self.numContextLinesLabel.setText(_("Number of surrounding lines:"))
self.numContextLines.setToolTip('<qt>' + _(
"When jumping between search results or clicking on a link, the "
"text view tries to scroll as few lines as possible. "
"Here you can speficy how many surrounding lines at least should "
"be visible."))
self.numContextLinesLabel.setToolTip(self.numContextLines.toolTip())
def loadSettings(self):
s = QSettings()
s.beginGroup("view_preferences")
self.wrapLines.setChecked(s.value("wrap_lines", False, bool))
self.numContextLines.setValue(s.value("context_lines", 3, int))
def saveSettings(self):
s = QSettings()
s.beginGroup("view_preferences")
s.setValue("wrap_lines", self.wrapLines.isChecked())
s.setValue("context_lines", self.numContextLines.value())
class ViewSettings(preferences.Group):
def __init__(self, page):
super(ViewSettings, self).__init__(page)
layout = QGridLayout(spacing=1)
self.setLayout(layout)
self.wrapLines = QCheckBox(toggled=self.changed)
self.numContextLines = QSpinBox(minimum=0, maximum=20, valueChanged=self.changed)
self.numContextLinesLabel = l = QLabel()
l.setBuddy(self.numContextLines)
layout.addWidget(self.wrapLines, 0, 0, 1, 1)
layout.addWidget(self.numContextLinesLabel, 1, 0)
layout.addWidget(self.numContextLines, 1, 1)
app.translateUI(self)
def translateUI(self):
self.setTitle(_("View Preferences"))
self.wrapLines.setText(_("Wrap long lines by default"))
self.wrapLines.setToolTip('<qt>' + _(
"If enabled, lines that don't fit in the editor width are wrapped "
"by default. "
"Note: when the document is displayed by multiple views, they all "
"share the same line wrapping width, which might look strange."))
self.numContextLinesLabel.setText(_("Number of surrounding lines:"))
self.numContextLines.setToolTip('<qt>' + _(
"When jumping between search results or clicking on a link, the "
"text view tries to scroll as few lines as possible. "
"Here you can specify how many surrounding lines at least should "
"be visible."))
self.numContextLinesLabel.setToolTip(self.numContextLines.toolTip())
def loadSettings(self):
s = QSettings()
s.beginGroup("view_preferences")
self.wrapLines.setChecked(s.value("wrap_lines", False, bool))
self.numContextLines.setValue(s.value("context_lines", 3, int))
def saveSettings(self):
s = QSettings()
s.beginGroup("view_preferences")
s.setValue("wrap_lines", self.wrapLines.isChecked())
s.setValue("context_lines", self.numContextLines.value())
class ChordNames(object):
def createWidgets(self, layout):
self.chordStyleLabel = QLabel()
self.chordStyle = QComboBox()
self.chordStyleLabel.setBuddy(self.chordStyle)
self.chordStyle.setModel(listmodel.ListModel(chordNameStyles, self.chordStyle,
display=listmodel.translate))
self.guitarFrets = QCheckBox()
box = QHBoxLayout()
box.addWidget(self.chordStyleLabel)
box.addWidget(self.chordStyle)
layout.addLayout(box)
layout.addWidget(self.guitarFrets)
def translateWidgets(self):
self.chordStyleLabel.setText(_("Chord style:"))
self.guitarFrets.setText(_("Guitar fret diagrams"))
self.guitarFrets.setToolTip(_(
"Show predefined guitar fret diagrams below the chord names "
"(LilyPond 2.12 and above)."))
self.chordStyle.model().update()
def build(self, data, builder):
p = ly.dom.ChordNames()
a = data.assign('chordNames')
ly.dom.Identifier(a.name, p)
s = ly.dom.ChordMode(a)
ly.dom.Identifier(data.globalName, s).after = 1
i = self.chordStyle.currentIndex()
if i > 0:
ly.dom.Line('\\{0}Chords'.format(
('german', 'semiGerman', 'italian', 'french')[i-1]), s)
ly.dom.LineComment(_("Chords follow here."), s)
ly.dom.BlankLine(s)
data.nodes.append(p)
if self.guitarFrets.isChecked():
f = ly.dom.FretBoards()
ly.dom.Identifier(a.name, f)
data.nodes.append(f)
data.includes.append("predefined-guitar-fretboards.ly")
class ConfigWidget(QWidget):
def __init__(self, parent=None):
QWidget.__init__(self, parent)
layout = QVBoxLayout()
self.setLayout(layout)
self.liveCheckBox = QCheckBox("Live Source")
self.liveCheckBox.setToolTip('Act as a live video source')
layout.addWidget(self.liveCheckBox)
formWidget = QWidget()
formLayout = QFormLayout()
formWidget.setLayout(formLayout)
layout.addWidget(formWidget)
self.patternLabel = QLabel("Pattern")
self.patternComboBox = QComboBox()
formLayout.addRow(self.patternLabel, self.patternComboBox)
class ConfigWidget(QWidget):
def __init__(self, parent=None):
QWidget.__init__(self, parent)
layout = QVBoxLayout()
self.setLayout(layout)
self.liveCheckBox = QCheckBox("Live Source")
self.liveCheckBox.setToolTip('Act as a live video source')
layout.addWidget(self.liveCheckBox)
formWidget = QWidget()
formLayout = QFormLayout()
formWidget.setLayout(formLayout)
layout.addWidget(formWidget)
self.patternLabel = QLabel("Pattern")
self.patternComboBox = QComboBox()
formLayout.addRow(self.patternLabel, self.patternComboBox)
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)
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.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()]
raise CancelPluginException("User cancelled!")
def getArguments(self, parent=None):
description = "The GEN_DATA RFT CSV export requires some information before it starts:"
dialog = CustomDialog("Robust CSV Export", description, parent)
output_path_model = PathModel("output.csv")
output_path_chooser = PathChooser(output_path_model)
trajectory_model = PathModel("wellpath", must_be_a_directory=True, must_be_a_file=False, must_exist=True)
trajectory_chooser = PathChooser(trajectory_model)
fs_manager = self.ert().getEnkfFsManager()
all_case_list = fs_manager.getCaseList()
all_case_list = [case for case in all_case_list if fs_manager.caseHasData(case)]
list_edit = ListEditBox(all_case_list)
infer_iteration_check = QCheckBox()
infer_iteration_check.setChecked(True)
infer_iteration_check.setToolTip(GenDataRFTCSVExportJob.INFER_HELP)
dialog.addLabeledOption("Output file path", output_path_chooser)
dialog.addLabeledOption("Trajectory file", trajectory_chooser)
dialog.addLabeledOption("List of cases to export", list_edit)
dialog.addLabeledOption("Infer iteration number", infer_iteration_check)
dialog.addButtons()
success = dialog.showAndTell()
if success:
case_list = ",".join(list_edit.getItems())
try:
return [output_path_model.getPath(), trajectory_model.getPath(), case_list, infer_iteration_check.isChecked()]
except ValueError:
pass
raise CancelPluginException("User cancelled!")
class Running(preferences.Group):
def __init__(self, page):
super(Running, self).__init__(page)
layout = QVBoxLayout()
self.setLayout(layout)
self.saveDocument = QCheckBox(clicked=self.changed)
self.deleteFiles = QCheckBox(clicked=self.changed)
self.noTranslation = QCheckBox(clicked=self.changed)
self.includeLabel = QLabel()
self.include = widgets.listedit.FilePathEdit()
self.include.listBox.setDragDropMode(QAbstractItemView.InternalMove)
self.include.changed.connect(self.changed)
layout.addWidget(self.saveDocument)
layout.addWidget(self.deleteFiles)
layout.addWidget(self.noTranslation)
layout.addWidget(self.includeLabel)
layout.addWidget(self.include)
app.translateUI(self)
def translateUI(self):
self.setTitle(_("Running LilyPond"))
self.saveDocument.setText(_("Save document if possible"))
self.saveDocument.setToolTip(
_("If checked, the document is saved when it is local and modified.\n"
"Otherwise a temporary file is used to run LilyPond."))
self.deleteFiles.setText(_("Delete intermediate output files"))
self.deleteFiles.setToolTip(
_("If checked, LilyPond will delete intermediate PostScript files."
))
self.noTranslation.setText(_("Run LilyPond with English messages"))
self.noTranslation.setToolTip(
_("If checked, LilyPond's output messages will be in English.\n"
"This can be useful for bug reports."))
self.includeLabel.setText(_("LilyPond include path:"))
def loadSettings(self):
s = settings()
self.saveDocument.setChecked(s.value("save_on_run", False, bool))
self.deleteFiles.setChecked(
s.value("delete_intermediate_files", True, bool))
self.noTranslation.setChecked(s.value("no_translation", False, bool))
include_path = qsettings.get_string_list(s, "include_path")
self.include.setValue(include_path)
def saveSettings(self):
s = settings()
s.setValue("save_on_run", self.saveDocument.isChecked())
s.setValue("delete_intermediate_files", self.deleteFiles.isChecked())
s.setValue("no_translation", self.noTranslation.isChecked())
s.setValue("include_path", self.include.value())
class MusicView(preferences.Group):
def __init__(self, page):
super(MusicView, self).__init__(page)
layout = QGridLayout()
self.setLayout(layout)
self.newerFilesOnly = QCheckBox(toggled=self.changed)
layout.addWidget(self.newerFilesOnly, 0, 0, 1, 3)
self.magnifierSizeLabel = QLabel()
self.magnifierSizeSlider = QSlider(Qt.Horizontal,
valueChanged=self.changed)
self.magnifierSizeSlider.setSingleStep(50)
self.magnifierSizeSlider.setRange(
*popplerview.MagnifierSettings.sizeRange)
self.magnifierSizeSpinBox = QSpinBox()
self.magnifierSizeSpinBox.setRange(
*popplerview.MagnifierSettings.sizeRange)
self.magnifierSizeSpinBox.valueChanged.connect(
self.magnifierSizeSlider.setValue)
self.magnifierSizeSlider.valueChanged.connect(
self.magnifierSizeSpinBox.setValue)
layout.addWidget(self.magnifierSizeLabel, 1, 0)
layout.addWidget(self.magnifierSizeSlider, 1, 1)
layout.addWidget(self.magnifierSizeSpinBox, 1, 2)
self.magnifierScaleLabel = QLabel()
self.magnifierScaleSlider = QSlider(Qt.Horizontal,
valueChanged=self.changed)
self.magnifierScaleSlider.setSingleStep(50)
self.magnifierScaleSlider.setRange(
*popplerview.MagnifierSettings.scaleRange)
self.magnifierScaleSpinBox = QSpinBox()
self.magnifierScaleSpinBox.setRange(
*popplerview.MagnifierSettings.scaleRange)
self.magnifierScaleSpinBox.valueChanged.connect(
self.magnifierScaleSlider.setValue)
self.magnifierScaleSlider.valueChanged.connect(
self.magnifierScaleSpinBox.setValue)
layout.addWidget(self.magnifierScaleLabel, 2, 0)
layout.addWidget(self.magnifierScaleSlider, 2, 1)
layout.addWidget(self.magnifierScaleSpinBox, 2, 2)
self.enableKineticScrolling = QCheckBox(toggled=self.changed)
layout.addWidget(self.enableKineticScrolling)
self.showScrollbars = QCheckBox(toggled=self.changed)
layout.addWidget(self.showScrollbars)
app.translateUI(self)
def translateUI(self):
self.setTitle(_("Music View"))
self.newerFilesOnly.setText(_("Only load updated PDF documents"))
self.newerFilesOnly.setToolTip(
_("If checked, Frescobaldi will not open PDF documents that are not\n"
"up-to-date (i.e. the source file has been modified later)."))
self.magnifierSizeLabel.setText(_("Magnifier Size:"))
self.magnifierSizeLabel.setToolTip(
_("Size of the magnifier glass (Ctrl+Click in the Music View)."))
# L10N: as in "400 pixels", appended after number in spinbox, note the leading space
self.magnifierSizeSpinBox.setSuffix(_(" pixels"))
self.magnifierScaleLabel.setText(_("Magnifier Scale:"))
self.magnifierScaleLabel.setToolTip(
_("Magnification of the magnifier."))
self.magnifierScaleSpinBox.setSuffix(_("percent unit sign", "%"))
# L10N: "Kinetic Scrolling" is a checkbox label, as in "Enable Kinetic Scrolling"
self.enableKineticScrolling.setText(_("Kinetic Scrolling"))
self.showScrollbars.setText(_("Show Scrollbars"))
def loadSettings(self):
s = popplerview.MagnifierSettings.load()
self.magnifierSizeSlider.setValue(s.size)
self.magnifierScaleSlider.setValue(s.scale)
s = QSettings()
s.beginGroup("musicview")
newerFilesOnly = s.value("newer_files_only", True, bool)
self.newerFilesOnly.setChecked(newerFilesOnly)
kineticScrollingActive = s.value("kinetic_scrolling", True, bool)
self.enableKineticScrolling.setChecked(kineticScrollingActive)
showScrollbars = s.value("show_scrollbars", True, bool)
self.showScrollbars.setChecked(showScrollbars)
def saveSettings(self):
s = popplerview.MagnifierSettings()
s.size = self.magnifierSizeSlider.value()
s.scale = self.magnifierScaleSlider.value()
s.save()
s = QSettings()
s.beginGroup("musicview")
s.setValue("newer_files_only", self.newerFilesOnly.isChecked())
s.setValue("kinetic_scrolling",
self.enableKineticScrolling.isChecked())
s.setValue("show_scrollbars", self.showScrollbars.isChecked())
class LogTool(preferences.Group):
def __init__(self, page):
super(LogTool, self).__init__(page)
layout = QVBoxLayout()
self.setLayout(layout)
self.fontLabel = QLabel()
self.fontChooser = QFontComboBox(currentFontChanged=self.changed)
self.fontSize = QDoubleSpinBox(valueChanged=self.changed)
self.fontSize.setRange(6.0, 32.0)
self.fontSize.setSingleStep(0.5)
self.fontSize.setDecimals(1)
box = QHBoxLayout()
box.addWidget(self.fontLabel)
box.addWidget(self.fontChooser, 1)
box.addWidget(self.fontSize)
layout.addLayout(box)
self.showlog = QCheckBox(toggled=self.changed)
layout.addWidget(self.showlog)
self.rawview = QCheckBox(toggled=self.changed)
layout.addWidget(self.rawview)
self.hideauto = QCheckBox(toggled=self.changed)
layout.addWidget(self.hideauto)
app.translateUI(self)
def translateUI(self):
self.setTitle(_("LilyPond Log"))
self.fontLabel.setText(_("Font:"))
self.showlog.setText(_("Show log when a job is started"))
self.rawview.setText(_("Display plain log output"))
self.rawview.setToolTip(
_("If checked, Frescobaldi will not shorten filenames in the log output."
""))
self.hideauto.setText(_("Hide automatic engraving jobs"))
self.hideauto.setToolTip(
_("If checked, Frescobaldi will not show the log for automatically\n"
"started engraving jobs (LilyPond->Auto-engrave)."))
def loadSettings(self):
s = QSettings()
s.beginGroup("log")
font = QFont(s.value("fontfamily", "monospace", type("")))
font.setPointSizeF(s.value("fontsize", 9.0, float))
with qutil.signalsBlocked(self.fontChooser, self.fontSize):
self.fontChooser.setCurrentFont(font)
self.fontSize.setValue(font.pointSizeF())
self.showlog.setChecked(s.value("show_on_start", True, bool))
self.rawview.setChecked(s.value("rawview", True, bool))
self.hideauto.setChecked(s.value("hide_auto_engrave", False, bool))
def saveSettings(self):
s = QSettings()
s.beginGroup("log")
s.setValue("fontfamily", self.fontChooser.currentFont().family())
s.setValue("fontsize", self.fontSize.value())
s.setValue("show_on_start", self.showlog.isChecked())
s.setValue("rawview", self.rawview.isChecked())
s.setValue("hide_auto_engrave", self.hideauto.isChecked())
class SourceExport(preferences.Group):
def __init__(self, page):
super(SourceExport, self).__init__(page)
layout = QVBoxLayout()
self.setLayout(layout)
self.numberLines = QCheckBox(toggled=self.changed)
self.inlineStyleCopy = QCheckBox(toggled=self.changed)
self.copyHtmlAsPlainText = QCheckBox(toggled=self.changed)
self.inlineStyleExport = QCheckBox(toggled=self.changed)
self.copyDocumentBodyOnly = QCheckBox(toggled=self.changed)
layout.addWidget(self.numberLines)
layout.addWidget(self.inlineStyleCopy)
layout.addWidget(self.inlineStyleExport)
layout.addWidget(self.copyHtmlAsPlainText)
layout.addWidget(self.copyDocumentBodyOnly)
app.translateUI(self)
def translateUI(self):
self.setTitle(_("Source Export Preferences"))
self.numberLines.setText(_("Show line numbers"))
self.numberLines.setToolTip('<qt>' + _(
"If enabled, line numbers are shown in exported HTML or printed "
"source."))
self.inlineStyleCopy.setText(_("Use inline style when copying colored HTML"))
self.inlineStyleCopy.setToolTip('<qt>' + _(
"If enabled, inline style attributes are used when copying "
"colored HTML to the clipboard. "
"Otherwise, a CSS stylesheet is embedded."))
self.inlineStyleExport.setText(_("Use inline style when exporting colored HTML"))
self.inlineStyleExport.setToolTip('<qt>' + _(
"If enabled, inline style attributes are used when exporing "
"colored HTML to a file. "
"Otherwise, a CSS stylesheet is embedded."))
self.copyHtmlAsPlainText.setText(_("Copy HTML as plain text"))
self.copyHtmlAsPlainText.setToolTip('<qt>' + _(
"If enabled, HTML is copied to the clipboard as plain text. "
"Use this when you want to type HTML formatted code in a "
"plain text editing environment."))
self.copyDocumentBodyOnly.setText(_("Copy <pre> element only"))
self.copyDocumentBodyOnly.setToolTip('<qt>' + _(
"If enabled, only the HTML contents, wrapped in a PRE tag, will be "
"copied to the clipboard instead of a full HTML document with a "
"header section. "
"May be used in conjunction with the plain text option, with the "
"inline style option turned off, to copy highlighted code in a "
"text editor when an external style sheet is already available."))
def loadSettings(self):
s = QSettings()
s.beginGroup("source_export")
self.numberLines.setChecked(s.value("number_lines", False, bool))
self.inlineStyleCopy.setChecked(s.value("inline_copy", True, bool))
self.inlineStyleExport.setChecked(s.value("inline_export", False, bool))
self.copyHtmlAsPlainText.setChecked(s.value("copy_html_as_plain_text", False, bool))
self.copyDocumentBodyOnly.setChecked(s.value("copy_document_body_only", False, bool))
def saveSettings(self):
s = QSettings()
s.beginGroup("source_export")
s.setValue("number_lines", self.numberLines.isChecked())
s.setValue("inline_copy", self.inlineStyleCopy.isChecked())
s.setValue("inline_export", self.inlineStyleExport.isChecked())
s.setValue("copy_html_as_plain_text", self.copyHtmlAsPlainText.isChecked())
s.setValue("copy_document_body_only", self.copyDocumentBodyOnly.isChecked())
class Search(QWidget, plugin.MainWindowPlugin):
def __init__(self, mainwindow):
super(Search, self).__init__(mainwindow)
self._currentView = None
self._positions = None
self._replace = False # are we in replace mode?
mainwindow.currentViewChanged.connect(self.viewChanged)
mainwindow.actionCollection.edit_find_next.triggered.connect(self.findNext)
mainwindow.actionCollection.edit_find_previous.triggered.connect(self.findPrevious)
# dont inherit looks from view
self.setFont(QApplication.font())
self.setPalette(QApplication.palette())
grid = QGridLayout()
grid.setContentsMargins(4, 0, 4, 0)
grid.setVerticalSpacing(0)
self.setLayout(grid)
self.searchEntry = QLineEdit(textChanged=self.slotSearchChanged)
self.searchLabel = QLabel()
self.caseCheck = QCheckBox(checked=True, focusPolicy=Qt.NoFocus)
self.regexCheck = QCheckBox(focusPolicy=Qt.NoFocus)
self.countLabel = QLabel(alignment=Qt.AlignRight | Qt.AlignVCenter)
self.countLabel.setMinimumWidth(QApplication.fontMetrics().width("9999"))
self.closeButton = QToolButton(autoRaise=True, focusPolicy=Qt.NoFocus)
self.hideAction = QAction(self, triggered=self.slotHide)
self.hideAction.setShortcut(QKeySequence(Qt.Key_Escape))
self.hideAction.setIcon(self.style().standardIcon(QStyle.SP_DialogCloseButton))
self.closeButton.setDefaultAction(self.hideAction)
grid.addWidget(self.searchLabel, 0, 0)
grid.addWidget(self.searchEntry, 0, 1)
grid.addWidget(self.caseCheck, 0, 2)
grid.addWidget(self.regexCheck, 0, 3)
grid.addWidget(self.countLabel, 0, 4)
grid.addWidget(self.closeButton, 0, 5)
self.caseCheck.toggled.connect(self.slotSearchChanged)
self.regexCheck.toggled.connect(self.slotSearchChanged)
self.replaceEntry = QLineEdit()
self.replaceLabel = QLabel()
self.replaceButton = QPushButton(clicked=self.slotReplace)
self.replaceAllButton = QPushButton(clicked=self.slotReplaceAll)
grid.addWidget(self.replaceLabel, 1, 0)
grid.addWidget(self.replaceEntry, 1, 1)
grid.addWidget(self.replaceButton, 1, 2)
grid.addWidget(self.replaceAllButton, 1, 3)
app.settingsChanged.connect(self.readSettings)
self.readSettings()
app.translateUI(self)
def translateUI(self):
self.searchLabel.setText(_("Search:"))
self.caseCheck.setText(_("&Case"))
self.caseCheck.setToolTip(_("Case Sensitive"))
self.regexCheck.setText(_("&Regex"))
self.regexCheck.setToolTip(_("Regular Expression"))
self.countLabel.setToolTip(_("The total number of matches"))
self.hideAction.setToolTip(_("Close"))
self.replaceLabel.setText(_("Replace:"))
self.replaceButton.setText(_("Re&place"))
self.replaceButton.setToolTip(_("Replaces the next occurrence of the search term."))
self.replaceAllButton.setText(_("&All"))
self.replaceAllButton.setToolTip(_("Replaces all occurrences of the search term in the document or selection."))
def readSettings(self):
data = textformats.formatData('editor')
self.searchEntry.setFont(data.font)
self.replaceEntry.setFont(data.font)
p = data.palette()
self.searchEntry.setPalette(p)
self.replaceEntry.setPalette(p)
def currentView(self):
return self._currentView and self._currentView()
def setCurrentView(self, view):
self._currentView = weakref.ref(view) if view else None
def showWidget(self):
if self.isVisible():
self.hideWidget()
view = self.window().currentView()
self.setCurrentView(view)
layout = widgets.borderlayout.BorderLayout.get(view)
layout.addWidget(self, widgets.borderlayout.BOTTOM)
self.show()
def hideWidget(self):
view = self.currentView()
if view:
viewhighlighter.highlighter(view).clear("search")
self.hide()
layout = widgets.borderlayout.BorderLayout.get(view)
layout.removeWidget(self)
def viewChanged(self, new):
self.setParent(None)
self.hideWidget()
self.setCurrentView(new)
self.updatePositions()
def slotHide(self):
view = self.currentView()
if view:
self.hideWidget()
view.setFocus()
def find(self):
# hide replace stuff
self.replaceLabel.hide()
self.replaceEntry.hide()
self.replaceButton.hide()
self.replaceAllButton.hide()
self._replace = False # we are not in replace mode
visible = self.isVisible()
if not visible:
with qutil.signalsBlocked(self.searchEntry):
self.searchEntry.clear()
self.showWidget()
if not visible and self.currentView():
# pick current word
cursor = self.currentView().textCursor()
cursor.movePosition(QTextCursor.StartOfWord)
cursor.movePosition(QTextCursor.EndOfWord, QTextCursor.KeepAnchor)
word = cursor.selection().toPlainText()
if not re.search(r'\w', word):
word = ""
self.searchEntry.setText(word)
self.searchEntry.selectAll()
else:
self.slotSearchChanged()
self.searchEntry.setFocus()
def replace(self):
# show replace stuff
self.replaceLabel.show()
self.replaceEntry.show()
self.replaceButton.show()
self.replaceAllButton.show()
focus = self.replaceEntry if self.isVisible() and self.searchEntry.text() else self.searchEntry
self._replace = True # we are in replace mode
self.showWidget()
self.slotSearchChanged()
focus.setFocus()
def slotSearchChanged(self):
self.updatePositions()
viewhighlighter.highlighter(self.currentView()).highlight("search", self._positions, 1)
def updatePositions(self):
search = self.searchEntry.text()
view = self.currentView()
document = view.document()
self._positions = []
if search:
text = document.toPlainText()
flags = re.MULTILINE | re.DOTALL
if not self.caseCheck.isChecked():
flags |= re.IGNORECASE
if not self.regexCheck.isChecked():
search = re.escape(search)
try:
matches = re.finditer(search, text, flags)
except re.error:
pass
else:
for m in matches:
c = QTextCursor(document)
c.setPosition(m.end())
c.setPosition(m.start(), QTextCursor.KeepAnchor)
self._positions.append(c)
self.countLabel.setText(unicode(len(self._positions)))
def findNext(self):
view = self.currentView()
if view and self._positions:
positions = [c.position() for c in self._positions]
index = bisect.bisect_right(positions, view.textCursor().position())
if index < len(positions):
view.setTextCursor(self._positions[index])
else:
view.setTextCursor(self._positions[0])
view.ensureCursorVisible()
def findPrevious(self):
view = self.currentView()
positions = [c.position() for c in self._positions]
if view and positions:
index = bisect.bisect_left(positions, view.textCursor().position()) - 1
view.setTextCursor(self._positions[index])
view.ensureCursorVisible()
def keyPressEvent(self, ev):
if ev.key() == Qt.Key_Tab:
# prevent Tab from reaching the View widget
self.window().focusNextChild()
return
# if in search mode, Up and Down jump between search results
if not self._replace and self._positions and self.searchEntry.text() and not ev.modifiers():
if ev.key() == Qt.Key_Up:
self.findPrevious()
return
elif ev.key() == Qt.Key_Down:
self.findNext()
return
# use enter or return for search next
if ev.key() in (Qt.Key_Enter, Qt.Key_Return):
self.findNext()
return
super(Search, self).keyPressEvent(ev)
def doReplace(self, cursor):
text = cursor.selection().toPlainText()
search = self.searchEntry.text()
replace = self.replaceEntry.text()
ok = text == self.searchEntry.text()
if self.regexCheck.isChecked():
m = re.match(search, text)
ok = False
if m:
try:
replace = m.expand(replace)
ok = True
except re.error:
pass
if ok:
pos = cursor.position()
cursor.insertText(replace)
cursor.setPosition(pos, QTextCursor.KeepAnchor)
return ok
def slotReplace(self):
view = self.currentView()
if view and self._positions:
positions = [c.position() for c in self._positions]
index = bisect.bisect_left(positions, view.textCursor().position())
if index >= len(positions):
index = 0
if self.doReplace(self._positions[index]):
viewhighlighter.highlighter(view).highlight("search", self._positions, 1)
if index < len(positions) - 1:
view.setTextCursor(self._positions[index+1])
else:
view.setTextCursor(self._positions[0])
view.ensureCursorVisible()
def slotReplaceAll(self):
view = self.currentView()
if view:
replaced = False
cursors = self._positions
if view.textCursor().hasSelection():
cursors = [cursor for cursor in cursors if cursortools.contains(view.textCursor(), cursor)]
view.textCursor().beginEditBlock()
for cursor in cursors:
if self.doReplace(cursor):
replaced = True
view.textCursor().endEditBlock()
if replaced:
viewhighlighter.highlighter(view).highlight("search", self._positions, 1)
class GeneralPreferences(QGroupBox):
def __init__(self, parent):
super(GeneralPreferences, self).__init__(parent)
layout = QVBoxLayout()
self.setLayout(layout)
self.typq = QCheckBox()
self.tagl = QCheckBox()
self.barnum = QCheckBox()
self.neutdir = QCheckBox()
self.midi = QCheckBox()
self.metro = QCheckBox()
self.paperSizeLabel = QLabel()
self.paper = QComboBox()
self.paper.addItems(paperSizes)
self.paperLandscape = QCheckBox(enabled=False)
self.paper.activated.connect(self.slotPaperChanged)
layout.addWidget(self.typq)
layout.addWidget(self.tagl)
layout.addWidget(self.barnum)
layout.addWidget(self.neutdir)
layout.addWidget(self.midi)
layout.addWidget(self.metro)
box = QHBoxLayout(spacing=2)
box.addWidget(self.paperSizeLabel)
box.addWidget(self.paper)
box.addWidget(self.paperLandscape)
layout.addLayout(box)
app.translateUI(self)
self.loadSettings()
self.window().finished.connect(self.saveSettings)
def translateUI(self):
self.setTitle(_("General preferences"))
self.typq.setText(_("Use typographical quotes"))
self.typq.setToolTip(
_("Replace normal quotes in titles with nice typographical quotes."
))
self.tagl.setText(_("Remove default tagline"))
self.tagl.setToolTip(
_("Suppress the default tagline output by LilyPond."))
self.barnum.setText(_("Remove bar numbers"))
self.barnum.setToolTip(
_("Suppress the display of measure numbers at the beginning of "
"every system."))
self.neutdir.setText(_("Smart neutral stem direction"))
self.neutdir.setToolTip(
_("Use a logical direction (up or down) for stems on the middle "
"line of a staff."))
self.midi.setText(_("Create MIDI output"))
self.midi.setToolTip(
_("Create a MIDI file in addition to the PDF file."))
self.metro.setText(_("Show metronome mark"))
self.metro.setToolTip(
_("If checked, show the metronome mark at the beginning of the "
"score. The MIDI output also uses the metronome setting."))
# paper size:
self.paperSizeLabel.setText(_("Paper size:"))
self.paper.setItemText(0, _("Default"))
self.paperLandscape.setText(_("Landscape"))
def slotPaperChanged(self, index):
self.paperLandscape.setEnabled(bool(index))
def getPaperSize(self):
"""Returns the configured papersize or the empty string for default."""
return paperSizes[self.paper.currentIndex()]
def loadSettings(self):
s = QSettings()
s.beginGroup('scorewiz/preferences')
self.typq.setChecked(s.value('typographical_quotes', True, bool))
self.tagl.setChecked(s.value('remove_tagline', False, bool))
self.barnum.setChecked(s.value('remove_barnumbers', False, bool))
self.neutdir.setChecked(s.value('smart_neutral_direction', False,
bool))
self.midi.setChecked(s.value('midi', True, bool))
self.metro.setChecked(s.value('metronome_mark', False, bool))
psize = s.value('paper_size', '', type(""))
enable = bool(psize and psize in paperSizes)
self.paper.setCurrentIndex(paperSizes.index(psize) if enable else 0)
self.paperLandscape.setChecked(s.value('paper_landscape', False, bool))
self.paperLandscape.setEnabled(enable)
def saveSettings(self):
s = QSettings()
s.beginGroup('scorewiz/preferences')
s.setValue('typographical_quotes', self.typq.isChecked())
s.setValue('remove_tagline', self.tagl.isChecked())
s.setValue('remove_barnumbers', self.barnum.isChecked())
s.setValue('smart_neutral_direction', self.neutdir.isChecked())
s.setValue('midi', self.midi.isChecked())
s.setValue('metronome_mark', self.metro.isChecked())
s.setValue('paper_size', paperSizes[self.paper.currentIndex()])
s.setValue('paper_landscape', self.paperLandscape.isChecked())
class Dialog(QDialog):
def __init__(self, parent=None):
super(Dialog, self).__init__(parent)
self._info = None
self._text = ''
self._convertedtext = ''
self._encoding = None
self.fromVersionLabel = QLabel()
self.fromVersion = QLineEdit()
self.reason = QLabel()
self.toVersionLabel = QLabel()
self.toVersion = QLineEdit()
self.messages = QTextBrowser()
self.diff = QTextBrowser(lineWrapMode=QTextBrowser.NoWrap)
self.copyCheck = QCheckBox(checked=
QSettings().value('convert_ly/copy_messages', True, bool))
self.tabw = QTabWidget()
self.tabw.addTab(self.messages, '')
self.tabw.addTab(self.diff, '')
self.buttons = QDialogButtonBox(
QDialogButtonBox.Reset |
QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
self.buttons.accepted.connect(self.accept)
self.buttons.rejected.connect(self.reject)
self.buttons.button(QDialogButtonBox.Reset).clicked.connect(self.run)
layout = QVBoxLayout()
self.setLayout(layout)
top = QHBoxLayout()
top.addWidget(self.fromVersionLabel)
top.addWidget(self.fromVersion)
top.addWidget(self.reason)
top.addStretch()
top.addWidget(self.toVersionLabel)
top.addWidget(self.toVersion)
layout.addLayout(top)
layout.addWidget(self.tabw)
layout.addWidget(self.copyCheck)
layout.addWidget(widgets.Separator())
layout.addWidget(self.buttons)
app.translateUI(self)
qutil.saveDialogSize(self, 'convert_ly/dialog/size', QSize(600, 300))
app.settingsChanged.connect(self.readSettings)
self.readSettings()
self.finished.connect(self.saveCopyCheckSetting)
def translateUI(self):
self.fromVersionLabel.setText(_("From version:"))
self.toVersionLabel.setText(_("To version:"))
self.copyCheck.setText(_("Save convert-ly messages in document"))
self.copyCheck.setToolTip(_(
"If checked, the messages of convert-ly are appended as a "
"comment to the end of the document."))
self.tabw.setTabText(0, _("&Messages"))
self.tabw.setTabText(1, _("&Changes"))
self.buttons.button(QDialogButtonBox.Reset).setText(_("Run Again"))
self.setCaption()
def saveCopyCheckSetting(self):
QSettings().setValue('convert_ly/copy_messages', self.copyCheck.isChecked())
def readSettings(self):
font = textformats.formatData('editor').font
self.diff.setFont(font)
def setCaption(self):
version = self._info and self._info.versionString() or _("<unknown>")
title = _("Convert-ly from LilyPond {version}").format(version=version)
self.setWindowTitle(app.caption(title))
def setLilyPondInfo(self, info):
self._info = info
self.setCaption()
self.toVersion.setText(info.versionString())
self.setConvertedText()
def setConvertedText(self, text=''):
self._convertedtext = text
self.buttons.button(QDialogButtonBox.Ok).setEnabled(bool(text))
if text:
self.diff.setHtml(htmldiff.htmldiff(
self._text, text,
_("Current Document"), _("Converted Document"),
wrapcolumn=100))
else:
self.diff.clear()
def convertedText(self):
return self._convertedtext or ''
def setDocument(self, doc):
v = documentinfo.docinfo(doc).version_string()
if v:
self.fromVersion.setText(v)
self.reason.setText(_("(set in document)"))
else:
self.reason.clear()
self._text = doc.toPlainText()
self._encoding = doc.encoding() or 'UTF-8'
self.setConvertedText()
def run(self):
"""Runs convert-ly (again)."""
fromVersion = self.fromVersion.text()
toVersion = self.toVersion.text()
if not fromVersion or not toVersion:
self.messages.setPlainText(_(
"Both 'from' and 'to' versions need to be set."))
return
info = self._info
command = info.toolcommand(info.convert_ly)
command += ['-f', fromVersion, '-t', toVersion, '-']
# if the user wants english messages, do it also here: LANGUAGE=C
env = None
if QSettings().value("lilypond_settings/no_translation", False, bool):
if os.name == "nt":
# Python 2.7 subprocess on Windows chokes on unicode in env
env = util.bytes_environ()
env[b'LANGUAGE'] = b'C'
else:
env = dict(os.environ)
env['LANGUAGE'] = 'C'
with qutil.busyCursor():
try:
proc = subprocess.Popen(command,
universal_newlines = True,
env = env,
stdin = subprocess.PIPE,
stdout = subprocess.PIPE,
stderr = subprocess.PIPE)
out, err = proc.communicate(self._text.encode(self._encoding))
except OSError as e:
self.messages.setPlainText(_(
"Could not start {convert_ly}:\n\n"
"{message}\n").format(convert_ly = convert_ly, message = e))
return
self.messages.setPlainText(err.decode('UTF-8'))
self.setConvertedText(out.decode('UTF-8'))
if not out or self._convertedtext == self._text:
self.messages.append('\n' + _("The document has not been changed."))
class Printing(preferences.Group):
def __init__(self, page):
super(Printing, self).__init__(page)
layout = QGridLayout(spacing=1)
self.setLayout(layout)
self.messageLabel = QLabel(wordWrap=True)
self.printCommandLabel = QLabel()
self.printCommand = widgets.urlrequester.UrlRequester()
self.printCommand.setFileMode(QFileDialog.ExistingFile)
self.printCommand.changed.connect(page.changed)
self.printDialogCheck = QCheckBox(toggled=page.changed)
self.resolutionLabel = QLabel()
self.resolution = QComboBox(editable=True, editTextChanged=page.changed)
self.resolution.addItems("300 600 1200".split())
self.resolution.lineEdit().setInputMask("9000")
layout.addWidget(self.messageLabel, 0, 0, 1, 2)
layout.addWidget(self.printCommandLabel, 1, 0)
layout.addWidget(self.printCommand, 1, 1)
layout.addWidget(self.printDialogCheck, 2, 0, 1, 2)
layout.addWidget(self.resolutionLabel, 3, 0)
layout.addWidget(self.resolution, 3, 1)
app.translateUI(self)
def translateUI(self):
self.setTitle(_("Printing Music"))
self.messageLabel.setText(_(
"Here you can enter a command to print a PDF or PostScript file. "
"See the Help page for more information about printing music."))
self.printCommandLabel.setText(_("Printing command:"))
self.printCommand.setToolTip('<qt>' + _(
"The printing command is used to print a PostScript or PDF file. "
"On Linux you don't need this, but on Windows and Mac OS X you can "
"provide a command to avoid that PDF documents are being printed "
"using raster images, which is less optimal.\n"
"<code>$pdf</code> gets replaced with the PDF filename, or alternatively, "
"<code>$ps</code> is replaced with the PostScript filename. "
"<code>$printer</code> is replaced with the printer's name to use."))
self.printDialogCheck.setText(_("Use Frescobaldi's print dialog"))
self.printDialogCheck.setToolTip('<qt>' + _(
"If enabled, Frescobaldi will show the print dialog and create a "
"PDF or PostScript document containing only the selected pages "
"to print. Otherwise, the command is called directly and is expected "
"to show a print dialog itself."))
self.resolutionLabel.setText(_("Resolution:"))
self.resolution.setToolTip(_(
"Set the resolution if Frescobaldi prints using raster images."))
def loadSettings(self):
s = QSettings()
s.beginGroup("helper_applications")
self.printCommand.setPath(s.value("printcommand", "", type("")))
self.printDialogCheck.setChecked(s.value("printcommand/dialog", False, bool))
with qutil.signalsBlocked(self.resolution):
self.resolution.setEditText(format(s.value("printcommand/dpi", 300, int)))
def saveSettings(self):
s= QSettings()
s.beginGroup("helper_applications")
s.setValue("printcommand", self.printCommand.path())
s.setValue("printcommand/dialog", self.printDialogCheck.isChecked())
s.setValue("printcommand/dpi", int(self.resolution.currentText()))
class MSSQLSpatialConfigPage(QWizardPage):
def __init__(self,parent=None,key=None):
super(MSSQLSpatialConfigPage, self).__init__(parent)
self.parent = parent
self.key = key
try:
(msodbc,msserver,msdsn,mstrust,msdbname,msschema,msusr,mspwd,msconfig,msepsg,mscql) = self.parent.mfr.readMSSQLConfig()
except:
(msodbc,msserver,msdsn,mstrust,msdbname,msschema,msusr,mspwd,msconfig,msepsg,mscql) = (None,)*11
self.setTitle('MSSQL Spatial Server Configuration Options')
self.setSubTitle('Enter the server string (host\instance) name and schema of your MSSQL server. Select "Trust" if using trusted authentication')
QToolTip.setFont(QFont('SansSerif', 10))
#labels
serverLabel = QLabel('MSSQLSpatial Server')
dbnameLabel = QLabel('MSSQLSpatial DB Name')
schemaLabel = QLabel('MSSQLSpatial DB Schema')
trustLabel = QLabel('Trust')
usrLabel = QLabel('Username')
pwdLabel = QLabel('Password')
#edit boxes
self.serverEdit = QLineEdit(msserver)
self.serverEdit.setToolTip('Enter MSSQL Server string. Format typically <host-name>\<db-instance>')
self.dbnameEdit = QLineEdit(msdbname)
self.dbnameEdit.setToolTip('Enter the name of the MSSQL database')
self.schemaEdit = QLineEdit(msschema)
self.schemaEdit.setToolTip('Enter schema name (this is not mandatory but a common default in MSSQL is "dbo")')
self.trustCheckBox = QCheckBox('YES')
self.trustCheckBox.setChecked(True if mstrust and mstrust.lower()=='yes' else False)
self.trustCheckBox.setToolTip('Use MSSQL trusted client authentication')
self.usrEdit = QLineEdit(msusr)
self.usrEdit.setToolTip('Enter MSSQL Username')
self.pwdEdit = QLineEdit('')#mspwd
self.pwdEdit.setToolTip('Enter MSSQL Password')
self.pwdEdit.setEchoMode(QLineEdit.Password)
#self.trustEdit.setValidator(QRegExpValidator(QRegExp("yes|no", re.IGNORECASE), self))
self.registerField(self.key+"server",self.serverEdit)
self.registerField(self.key+"dbname",self.dbnameEdit)
self.registerField(self.key+"schema",self.schemaEdit)
self.registerField(self.key+"trust",self.trustCheckBox)
self.registerField(self.key+"usr",self.usrEdit)
self.registerField(self.key+"pwd",self.pwdEdit)
#grid
grid = QGridLayout()
grid.setSpacing(10)
#layout
grid.addWidget(serverLabel, 1, 0)
grid.addWidget(self.serverEdit, 1, 2)
grid.addWidget(dbnameLabel, 2, 0)
grid.addWidget(self.dbnameEdit, 2, 2)
grid.addWidget(schemaLabel, 3, 0)
grid.addWidget(self.schemaEdit, 3, 2)
grid.addWidget(trustLabel, 4, 0)
grid.addWidget(self.trustCheckBox, 4, 2)
grid.addWidget(usrLabel, 5, 0)
grid.addWidget(self.usrEdit, 5, 2)
grid.addWidget(pwdLabel, 6, 0)
grid.addWidget(self.pwdEdit, 6, 2)
self.setLayout(grid)
def nextId(self):
if self.testConnection():
return self.parent.plist.get('final')[0]
return self.parent.plist.get('ms')[0]
def testConnection(self):
if not any(f for f in (self.serverEdit.isModified(),self.dbnameEdit.isModified(),self.schemaEdit.isModified(),
self.usrEdit.isModified(),self.pwdEdit.isModified())):
return False
cs = MSSQLSpatialDataStore.buildConnStr(self.serverEdit.text(),self.dbnameEdit.text(),self.schemaEdit.text(),
'yes' if self.trustCheckBox.isChecked() else 'no',self.usrEdit.text(),self.pwdEdit.text())
ms = MSSQLSpatialDataStore(cs,None)
ms.applyConfigOptions()
try:
ms.initDS(ms.destinationURI(None),False)
#ms.checkGeoPrivileges(self.usrEdit.text())
except DSReaderException as dse:
QMessageBox.warning(self, 'Connection Error', 'Cannot connect to MS data base using parameters provided: '+str(dse), 'OK')
return False
return True
trajectory_model = PathModel("wellpath",
must_be_a_directory=True,
must_be_a_file=False,
must_exist=True)
trajectory_chooser = PathChooser(trajectory_model)
fs_manager = self.ert().getEnkfFsManager()
all_case_list = fs_manager.getCaseList()
all_case_list = [
case for case in all_case_list if fs_manager.caseHasData(case)
]
list_edit = ListEditBox(all_case_list)
infer_iteration_check = QCheckBox()
infer_iteration_check.setChecked(True)
infer_iteration_check.setToolTip(GenDataRFTCSVExportJob.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("Trajectory file", trajectory_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)
class Viewer(ViewerBase, ViewerClass):
trackingChanged = pyqtSignal(bool)
setLocationTriggered = pyqtSignal()
updateFeatures = pyqtSignal(bool)
layerChanged = pyqtSignal(QgsMapLayer)
clearLine = pyqtSignal()
closed = pyqtSignal()
def __init__(self, callbackobject, parent=None):
"""Constructor."""
super(Viewer, self).__init__(parent)
self.setupUi(self)
self.callbackobject = callbackobject
self.frame = self.webview.page().mainFrame()
self.actiongroup = QActionGroup(self)
self.actiongroup.setExclusive(True)
self.actiongroup.triggered.connect(self.action_triggered)
self.measuredialog = MeasureDialog(self)
self.toolbar = QToolBar()
self.qgisTrackButton = self.toolbar.addAction("QGIS Track")
self.qgisTrackButton.setIcon(QIcon(":/icons/track"))
self.qgisTrackButton.setCheckable(True)
self.qgisTrackButton.setChecked(True)
self.qgisTrackButton.toggled.connect(self.trackingChanged.emit)
self.setlocationaction = self.toolbar.addAction("Set location")
self.setlocationaction.setIcon(QIcon(":/icons/location"))
self.setlocationaction.triggered.connect(
self.setLocationTriggered.emit)
self.setlocationaction.setCheckable(True)
self.viewfeatures = self.toolbar.addAction("Load QGIS Features")
self.viewfeatures.setIcon(QIcon(":/icons/features"))
self.viewfeatures.setCheckable(True)
self.viewfeatures.setChecked(True)
self.viewfeatures.toggled.connect(self.updateFeatures.emit)
spacer = QWidget()
spacer.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self.toolbar.addWidget(spacer)
self.measureaction = self.toolbar.addAction("measure")
self.measureaction.setObjectName("Measure")
self.measureaction.setIcon(QIcon(":/icons/measure"))
self.measureaction.setCheckable(True)
self.infoaction = self.toolbar.addAction("Info")
self.infoaction.setObjectName("Info")
self.infoaction.setIcon(QIcon(":/icons/info"))
self.infoaction.setCheckable(True)
self.selectaction = self.toolbar.addAction("Select")
self.selectaction.setObjectName("Select")
self.selectaction.setIcon(QIcon(":/icons/select"))
self.selectaction.setCheckable(True)
self.toolbar.addSeparator()
self.deleteaction = self.toolbar.addAction("Delete")
self.deleteaction.setIcon(QIcon(":/icons/delete"))
self.deleteaction.triggered.connect(self.delete_selected)
self.deleteaction.setEnabled(False)
self.addaction = self.toolbar.addAction("Add")
self.addaction.setObjectName("Add")
self.addaction.setIcon(QIcon(":/icons/add"))
self.addaction.setCheckable(True)
self.moveaction = self.toolbar.addAction("Move")
self.moveaction.setObjectName("Move")
self.moveaction.setIcon(QIcon(":/icons/move"))
self.moveaction.setCheckable(True)
self.actiongroup.addAction(self.moveaction)
self.actiongroup.addAction(self.addaction)
self.actiongroup.addAction(self.infoaction)
self.actiongroup.addAction(self.measureaction)
self.actiongroup.addAction(self.selectaction)
self.activelayercombo = QgsMapLayerComboBox()
self.activelayercombo.layerChanged.connect(self.layer_changed)
self.activelayeraction = self.toolbar.addWidget(self.activelayercombo)
self.activelayercombo.setSizeAdjustPolicy(QComboBox.AdjustToContents)
self.activelayercombo.currentIndexChanged.connect(self.index_changed)
self.zvaluecheck = QCheckBox()
self.zvaluecheck.setChecked(True)
self.zvaluecheck.setText("Copy Z value")
self.zvaluecheck.setToolTip(
"Copy Z value from viewer to new features in QGIS. Must have a field named Z to enable"
)
self.zvalueaction = self.toolbar.addWidget(self.zvaluecheck)
self.dockWidgetContents.layout().insertWidget(0, self.toolbar)
self.webview.settings().setAttribute(QWebSettings.PluginsEnabled, True)
self.webview.settings().setAttribute(QWebSettings.JavascriptEnabled,
True)
self.webview.settings().setAttribute(
QWebSettings.DeveloperExtrasEnabled, True)
self.frame.setScrollBarPolicy(Qt.Horizontal, Qt.ScrollBarAlwaysOff)
self.frame.setScrollBarPolicy(Qt.Vertical, Qt.ScrollBarAlwaysOff)
self.frame.javaScriptWindowObjectCleared.connect(
self.addcallbackobject)
self.measuredialog.modeCombo.currentIndexChanged.connect(
self.action_triggered)
self.measuredialog.clearButton.clicked.connect(self.clear_line)
self.earthmine = EarthmineAPI(self.frame)
def closeEvent(self, event):
self.closed.emit()
super(Viewer, self).closeEvent(event)
def index_changed(self, index):
if index == -1:
self.set_button_states(False, False, False, False)
def clear_line(self):
self.clearLine.emit()
self.earthmine.clearLine()
@property
def copyZvalue(self):
layer = self.active_layer
if not layer:
return False
if layer.type() == QgsMapLayer.VectorLayer and layer.geometryType(
) == QGis.Point:
return self.zvaluecheck.isChecked()
else:
return False
@property
def geom(self):
return self.measuredialog.geom
@geom.setter
def geom(self, value):
self.measuredialog.geom = value
self.measuredialog.update_geom_labels()
@property
def tracking(self):
return self.qgisTrackButton.isChecked()
@property
def mode(self):
return self.measuredialog.mode
@property
def active_layer(self):
return self.activelayercombo.currentLayer()
def layer_changed(self, layer):
if not layer:
self.set_button_states(False, False, False, False)
return
if layer.type() == QgsMapLayer.VectorLayer:
enabledselecttools = layer.geometryType() in [
QGis.Line, QGis.Point
]
enableedittools = layer.isEditable()
enabledelete = layer.isEditable() and layer.selectedFeatureCount()
enablemove = layer.geometryType(
) == QGis.Point and layer.isEditable()
else:
enabledselecttools = False
enableedittools = False
enabledelete = False
enablemove = False
self.set_button_states(enabledselecttools, enableedittools,
enabledelete, enablemove)
self.action_triggered()
self.layerChanged.emit(layer)
def selection_changed(self, layer):
if layer == self.active_layer:
enabledelete = layer.isEditable() and layer.selectedFeatureCount()
self.deleteaction.setEnabled(enabledelete)
def set_button_states(self, selecttools, edittools, deleteenabled,
moveenabled):
actions = [self.selectaction, self.infoaction]
for action in actions:
action.setEnabled(selecttools)
editactions = [self.deleteaction, self.moveaction, self.addaction]
for action in editactions:
action.setEnabled(edittools)
if edittools:
self.deleteaction.setEnabled(deleteenabled)
self.moveaction.setEnabled(moveenabled)
for action in editactions:
if action is self.actiongroup.checkedAction(
) and not action.isEnabled():
self.infoaction.toggle()
break
layer = self.active_layer
if not layer:
enablez = False
else:
enablez = layer.type(
) == QgsMapLayer.VectorLayer and layer.geometryType() == QGis.Point
self.zvalueaction.setEnabled(enablez)
@property
def current_action_color(self):
action = self.actiongroup.checkedAction()
color = int("0x00ff00", 16)
if action == self.measureaction:
if self.mode == "Vertical":
color = int("0x0000ff", 16)
return color
def action_triggered(self, *args):
action = self.actiongroup.checkedAction()
layer = self.activelayercombo.currentLayer()
self.clear_line()
if not action:
return
if not action == self.measureaction and (
not layer or not layer.type() == QgsMapLayer.VectorLayer):
return
color = self.current_action_color
actiondata = {}
if action == self.measureaction:
self.measuredialog.show()
actiondata['mode'] = self.mode
geomtype = None
layerid = None
else:
self.measuredialog.hide()
geomtype = QGis.vectorGeometryType(layer.geometryType())
layerid = layer.id()
data = dict(action=action.objectName(),
layer=layerid,
geom=geomtype,
actiondata=actiondata,
color=color)
self.earthmine.updateAction(data)
def active_tool(self):
action = self.actiongroup.checkedAction()
if not action:
return None
return action.objectName()
def update_current_layer(self, layer):
self.activelayercombo.setLayer(layer)
def addcallbackobject(self):
self.frame.addToJavaScriptWindowObject("qgis", self.callbackobject)
def loadviewer(self, url):
self.webview.load(url)
self.frame.addToJavaScriptWindowObject("qgis", self.callbackobject)
def startViewer(self, settings):
self.earthmine.startViewer(settings)
def set_location(self, point):
# # NOTE Set location takes WGS84 make sure you have transformed it first before sending
self.earthmine.setLocation(point.x(), point.y())
def clear_features(self):
self.earthmine.clearFeatures()
def clear_layer_features(self, layerid):
self.earthmine.clearLayerObjects(layerid)
def remove_feature(self, layerid, featureid):
"""
:param features: A dict of layerid, id, lat, lng
:return:
"""
self.earthmine.removeFeature(layerid, featureid)
def load_features(self, layerdata, features):
"""
:param features: A dict of layerid, id, lat, lng
:return:
"""
self.earthmine.loadFeatures(layerdata, features)
def layer_loaded(self, layerid):
return self.earthmine.layerLoaded(layerid)
def clear_selection(self, layerid):
self.earthmine.clearSelection(layerid)
def set_selection(self, layerid, featureids, clearlast=True):
self.earthmine.setSelection(layerid, featureids, clearlast)
def edit_feature(self, layerid, featureid, nodes):
self.earthmine.editFeature(layerid, featureid, nodes)
def delete_selected(self):
layer = self.active_layer
layer.deleteSelectedFeatures()
def populateStatusBar():
statusBar = self.statusBar()
w = QCheckBox("Render", self)
w.setObjectName('renderCheck')
w.setToolTip("Toggle map rendering")
w.setChecked(True)
statusBar.addPermanentWidget(w)
w = QCheckBox("Marker", self)
w.setObjectName('markerCheck')
w.setToolTip("Toggle marker with cursor position from main map")
w.setChecked(False)
statusBar.addPermanentWidget(w, 1)
w = QCheckBox("Extent", self)
w.setObjectName('extentCheck')
w.setToolTip("Show extent of main map")
w.setChecked(False)
statusBar.addPermanentWidget(w, 1)
w = QToolButton(self)
w.setObjectName('highlightBtn')
w.setToolTip("Highlight extent in main map")
w.setText("Highlight")
statusBar.addPermanentWidget(w, 1)
w = QLabel("Scale factor:", self)
w.setObjectName('scaleFactorLabel')
w.setAlignment(Qt.AlignRight | Qt.AlignVCenter)
statusBar.addPermanentWidget(w, 1)
w = QDoubleSpinBox(self)
w.setObjectName('scaleFactorSpin')
w.setToolTip("Current scale factor of main map")
w.setMinimum(0.0)
w.setMaximum(1000.0)
w.setDecimals(3)
w.setValue(1)
w.setSingleStep(.05)
statusBar.addPermanentWidget(w, 1)
w = QToolButton(self)
w.setObjectName('scaleBtn')
w.setToolTip("Set scale for main map")
w.setText("Scale: ")
statusBar.addPermanentWidget(w, 1)
class RecordingWidget(QWidget):
"""Widget containing main recording UI for Freeseer"""
def __init__(self, parent=None):
QWidget.__init__(self, parent)
icon = QIcon()
icon.addPixmap(QPixmap(":/freeseer/logo.png"), QIcon.Normal, QIcon.Off)
self.setWindowIcon(icon)
self.resize(400, 400)
self.mainLayout = QVBoxLayout()
self.setLayout(self.mainLayout)
boldFont = QFont()
boldFont.setBold(True)
# Control bar
self.controlRow = QHBoxLayout()
self.mainLayout.addLayout(self.controlRow)
self.standbyIcon = QIcon.fromTheme("system-shutdown")
recordFallbackIcon = QIcon(":/multimedia/record.png")
self.recordIcon = QIcon.fromTheme("media-record", recordFallbackIcon)
stopFallbackIcon = QIcon(":/multimedia/stop.png")
self.stopIcon = QIcon.fromTheme("media-playback-stop", stopFallbackIcon)
self.pauseIcon = QIcon.fromTheme("media-playback-pause")
self.resumeIcon = QIcon.fromTheme("media-playback-start")
self.headphoneIcon = QIcon()
self.headphoneIcon.addPixmap(QPixmap(":/multimedia/headphones.png"), QIcon.Normal, QIcon.Off)
self.standbyPushButton = QPushButton("Standby")
self.standbyPushButton.setToolTip("Standby")
self.standbyPushButton.setMinimumSize(QSize(0, 40))
self.standbyPushButton.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Fixed)
self.standbyPushButton.setIcon(self.standbyIcon)
self.standbyPushButton.setCheckable(True)
self.standbyPushButton.setObjectName("standbyButton")
self.controlRow.addWidget(self.standbyPushButton)
self.recordPushButton = QPushButton("Record")
self.recordPushButton.setToolTip("Record")
self.recordPushButton.setMinimumSize(QSize(0, 40))
self.recordPushButton.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Fixed)
self.recordPushButton.setIcon(self.recordIcon)
self.recordPushButton.setHidden(True)
self.recordPushButton.setEnabled(False)
self.recordPushButton.setCheckable(True)
self.recordPushButton.setObjectName("recordButton")
self.controlRow.addWidget(self.recordPushButton)
self.connect(self.recordPushButton, SIGNAL("toggled(bool)"), self.setRecordIcon)
self.pauseToolButton = QToolButton()
self.pauseToolButton.setText("Pause")
self.pauseToolButton.setToolTip("Pause")
self.pauseToolButton.setIcon(self.pauseIcon)
self.pauseToolButton.setMinimumSize(QSize(40, 40))
self.pauseToolButton.setSizePolicy(QSizePolicy.Maximum, QSizePolicy.Fixed)
self.pauseToolButton.setHidden(True)
self.pauseToolButton.setEnabled(False)
self.pauseToolButton.setCheckable(True)
self.controlRow.addWidget(self.pauseToolButton)
self.connect(self.pauseToolButton, SIGNAL("toggled(bool)"), self.setPauseIcon)
playbackIcon = QIcon.fromTheme("video-x-generic")
self.playPushButton = QPushButton()
self.playPushButton.setText("Play Video")
self.playPushButton.setToolTip("Play last recorded Video")
self.playPushButton.setIcon(playbackIcon)
self.playPushButton.setMinimumSize(QSize(40, 40))
self.playPushButton.setMaximumSize(QSize(120, 40))
self.playPushButton.setHidden(True)
self.playPushButton.setEnabled(False)
self.playPushButton.setCheckable(True)
self.controlRow.addWidget(self.playPushButton)
# Filter bar
self.filterBarLayout = QVBoxLayout()
self.mainLayout.addLayout(self.filterBarLayout)
self.filterBarLayoutRow_1 = QHBoxLayout()
self.filterBarLayout.addLayout(self.filterBarLayoutRow_1)
self.eventLabel = QLabel("Event")
self.eventLabel.setSizePolicy(QSizePolicy.Maximum, QSizePolicy.Fixed)
self.eventComboBox = QComboBox()
self.eventLabel.setBuddy(self.eventComboBox)
self.roomLabel = QLabel("Room")
self.roomLabel.setSizePolicy(QSizePolicy.Maximum, QSizePolicy.Fixed)
self.roomComboBox = QComboBox()
self.roomLabel.setBuddy(self.roomComboBox)
self.dateLabel = QLabel("Date")
self.dateLabel.setSizePolicy(QSizePolicy.Maximum, QSizePolicy.Fixed)
self.dateComboBox = QComboBox()
self.dateLabel.setBuddy(self.dateComboBox)
self.filterBarLayoutRow_1.addWidget(self.eventLabel)
self.filterBarLayoutRow_1.addWidget(self.eventComboBox)
self.filterBarLayoutRow_1.addWidget(self.roomLabel)
self.filterBarLayoutRow_1.addWidget(self.roomComboBox)
self.filterBarLayoutRow_1.addWidget(self.dateLabel)
self.filterBarLayoutRow_1.addWidget(self.dateComboBox)
self.filterBarLayoutRow_2 = QHBoxLayout()
self.filterBarLayout.addLayout(self.filterBarLayoutRow_2)
self.talkLabel = QLabel("Talk ")
self.talkLabel.setSizePolicy(QSizePolicy.Maximum, QSizePolicy.Fixed)
self.talkComboBox = QComboBox()
self.talkComboBox.setFont(boldFont)
self.talkComboBox.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Maximum)
self.talkComboBox.setSizeAdjustPolicy(QComboBox.AdjustToMinimumContentsLength)
self.filterBarLayoutRow_2.addWidget(self.talkLabel)
self.filterBarLayoutRow_2.addWidget(self.talkComboBox)
# Preview Layout
self.previewLayout = QHBoxLayout()
self.mainLayout.addLayout(self.previewLayout)
self.previewWidget = QWidget()
self.audioSlider = QSlider()
self.audioSlider.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Expanding)
self.audioSlider.setEnabled(False)
self.previewLayout.addWidget(self.previewWidget)
self.previewLayout.addWidget(self.audioSlider)
self.statusLabel = QLabel()
self.mainLayout.addWidget(self.statusLabel)
# Audio Feedback Checkbox
self.audioFeedbackCheckbox = QCheckBox()
self.audioFeedbackCheckbox.setLayoutDirection(Qt.RightToLeft)
self.audioFeedbackCheckbox.setIcon(self.headphoneIcon)
self.audioFeedbackCheckbox.setToolTip("Enable Audio Feedback")
self.mainLayout.addWidget(self.audioFeedbackCheckbox)
def setRecordIcon(self, state):
if state:
self.recordPushButton.setIcon(self.stopIcon)
else:
self.recordPushButton.setIcon(self.recordIcon)
def setPauseIcon(self, state):
if state:
self.pauseToolButton.setIcon(self.resumeIcon)
else:
self.pauseToolButton.setIcon(self.pauseIcon)
class Dialog(QDialog):
def __init__(self, parent=None):
super(Dialog, self).__init__(parent)
self._info = None
self._text = ''
self._convertedtext = ''
self._encoding = None
self.fromVersionLabel = QLabel()
self.fromVersion = QLineEdit()
self.reason = QLabel()
self.toVersionLabel = QLabel()
self.toVersion = QLineEdit()
self.lilyChooser = lilychooser.LilyChooser()
self.messages = QTextBrowser()
self.diff = QTextBrowser(lineWrapMode=QTextBrowser.NoWrap)
self.copyCheck = QCheckBox(
checked=QSettings().value('convert_ly/copy_messages', True, bool))
self.tabw = QTabWidget()
self.tabw.addTab(self.messages, '')
self.tabw.addTab(self.diff, '')
self.buttons = QDialogButtonBox(QDialogButtonBox.Reset
| QDialogButtonBox.Ok
| QDialogButtonBox.Cancel)
self.buttons.accepted.connect(self.accept)
self.buttons.rejected.connect(self.reject)
self.buttons.button(QDialogButtonBox.Reset).clicked.connect(self.run)
layout = QVBoxLayout()
self.setLayout(layout)
grid = QGridLayout()
grid.addWidget(self.fromVersionLabel, 0, 0)
grid.addWidget(self.fromVersion, 0, 1)
grid.addWidget(self.reason, 0, 2, 1, 3)
grid.addWidget(self.toVersionLabel, 1, 0)
grid.addWidget(self.toVersion, 1, 1)
grid.addWidget(self.lilyChooser, 1, 3, 1, 2)
layout.addLayout(grid)
layout.addWidget(self.tabw)
layout.addWidget(self.copyCheck)
layout.addWidget(widgets.Separator())
layout.addWidget(self.buttons)
app.translateUI(self)
qutil.saveDialogSize(self, 'convert_ly/dialog/size', QSize(600, 300))
app.settingsChanged.connect(self.readSettings)
self.readSettings()
self.finished.connect(self.saveCopyCheckSetting)
self.lilyChooser.currentIndexChanged.connect(
self.slotLilyPondVersionChanged)
self.slotLilyPondVersionChanged()
def translateUI(self):
self.fromVersionLabel.setText(_("From version:"))
self.toVersionLabel.setText(_("To version:"))
self.copyCheck.setText(_("Save convert-ly messages in document"))
self.copyCheck.setToolTip(
_("If checked, the messages of convert-ly are appended as a "
"comment to the end of the document."))
self.tabw.setTabText(0, _("&Messages"))
self.tabw.setTabText(1, _("&Changes"))
self.buttons.button(QDialogButtonBox.Reset).setText(_("Run Again"))
self.setCaption()
def saveCopyCheckSetting(self):
QSettings().setValue('convert_ly/copy_messages',
self.copyCheck.isChecked())
def readSettings(self):
font = textformats.formatData('editor').font
self.diff.setFont(font)
def slotLilyPondVersionChanged(self):
self.setLilyPondInfo(self.lilyChooser.lilyPondInfo())
def setCaption(self):
version = self._info and self._info.versionString() or _("<unknown>")
title = _("Convert-ly from LilyPond {version}").format(version=version)
self.setWindowTitle(app.caption(title))
def setLilyPondInfo(self, info):
self._info = info
self.setCaption()
self.toVersion.setText(info.versionString())
self.setConvertedText()
self.messages.clear()
def setConvertedText(self, text=''):
self._convertedtext = text
self.buttons.button(QDialogButtonBox.Ok).setEnabled(bool(text))
if text:
self.diff.setHtml(
htmldiff.htmldiff(self._text,
text,
_("Current Document"),
_("Converted Document"),
wrapcolumn=100))
else:
self.diff.clear()
def convertedText(self):
return self._convertedtext or ''
def setDocument(self, doc):
v = documentinfo.docinfo(doc).version_string()
if v:
self.fromVersion.setText(v)
self.reason.setText(_("(set in document)"))
else:
self.reason.clear()
self._text = doc.toPlainText()
self._encoding = doc.encoding() or 'UTF-8'
self.setConvertedText()
def run(self):
"""Runs convert-ly (again)."""
fromVersion = self.fromVersion.text()
toVersion = self.toVersion.text()
if not fromVersion or not toVersion:
self.messages.setPlainText(
_("Both 'from' and 'to' versions need to be set."))
return
info = self._info
command = info.toolcommand(info.convert_ly)
command += ['-f', fromVersion, '-t', toVersion, '-']
# if the user wants english messages, do it also here: LANGUAGE=C
env = None
if QSettings().value("lilypond_settings/no_translation", False, bool):
if os.name == "nt":
# Python 2.7 subprocess on Windows chokes on unicode in env
env = util.bytes_environ()
env[b'LANGUAGE'] = b'C'
else:
env = dict(os.environ)
env['LANGUAGE'] = 'C'
with qutil.busyCursor():
try:
proc = subprocess.Popen(command,
universal_newlines=True,
env=env,
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
out, err = proc.communicate(self._text.encode(self._encoding))
except OSError as e:
self.messages.setPlainText(
_("Could not start {convert_ly}:\n\n"
"{message}\n").format(convert_ly=convert_ly, message=e))
return
self.messages.setPlainText(err.decode('UTF-8'))
self.setConvertedText(out.decode('UTF-8'))
if not out or self._convertedtext == self._text:
self.messages.append('\n' +
_("The document has not been changed."))
class DockWidgetTitleBar(QWidget):
def __init__(self, dockWidget, hasCheckState=False, hasReport=False):
super(DockWidgetTitleBar, self).__init__(dockWidget)
q = dockWidget
self.floatButton = DockWidgetTitleBarButton(self)
self.floatButton.setIcon(q.style().standardIcon(
QStyle.SP_TitleBarNormalButton, None, q))
self.floatButton.clicked.connect(self.toggleFloating)
self.floatButton.setVisible(True)
self.floatButton.setToolTip(self.tr("Undock"))
self.closeButton = DockWidgetTitleBarButton(self)
self.closeButton.setIcon(q.style().standardIcon(
QStyle.SP_TitleBarCloseButton, None, q))
self.closeButton.clicked.connect(dockWidget.close)
self.closeButton.setVisible(True)
self.closeButton.setToolTip(self.tr("Close"))
if hasCheckState:
self.checkStateButton = QCheckBox(self)
self.checkStateButton.setCheckState(2)
self.checkStateButton.setToolTip(self.tr("Disable this window"))
self.connect(self.checkStateButton, SIGNAL("stateChanged(int)"),
self.toggleCheckState)
else:
self.checkStateButton = False
dockWidget.featuresChanged.connect(self.featuresChanged)
self.featuresChanged(0)
self.reportIcon = QIcon(":report")
if hasReport:
self.reportButton = DockWidgetTitleBarButton(self)
self.reportButton.setIcon(self.reportIcon)
self.reportButton.clicked.connect(self.toggleReport)
self.reportButton.setVisible(True)
self.reportButton.setToolTip(self.tr("Add content to report"))
else:
self.reportButton = None
def hasFeature(self, dockwidget, feature):
return dockwidget.features() & feature == feature
def minimumSizeHint(self):
return self.sizeHint()
def sizeHint(self):
q = self.parentWidget()
mw = q.style().pixelMetric(QStyle.PM_DockWidgetTitleMargin, None, q)
fw = q.style().pixelMetric(QStyle.PM_DockWidgetFrameWidth, None, q)
closeSize = QSize(0, 0)
if self.closeButton:
closeSize = self.closeButton.sizeHint()
floatSize = QSize(0, 0)
if self.floatButton:
floatSize = self.floatButton.sizeHint()
hideSize = self.hideSizeHint()
buttonHeight = max(max(closeSize.height(), floatSize.height()),
hideSize.height()) + 2
buttonWidth = closeSize.width() + floatSize.width() + hideSize.width()
titleFontMetrics = q.fontMetrics()
fontHeight = titleFontMetrics.lineSpacing() + 2 * mw
height = max(buttonHeight, fontHeight)
return QSize(buttonWidth + height + 4 * mw + 2 * fw, height)
def hideSizeHint(self):
if self.reportButton and self.checkStateButton:
return self.reportButton.sizeHint(
) + self.checkStateButton.sizeHint()
elif self.reportButton:
return self.reportButton.sizeHint()
elif self.checkStateButton:
return self.checkStateButton.sizeHint()
else:
return QSize(0, 0)
def paintEvent(self, _event):
p = QStylePainter(self)
q = self.parentWidget()
fw = q.isFloating() and q.style().pixelMetric(
QStyle.PM_DockWidgetFrameWidth, None, q) or 0
mw = q.style().pixelMetric(QStyle.PM_DockWidgetTitleMargin, None, q)
titleOpt = QStyleOptionDockWidgetV2()
titleOpt.initFrom(q)
titleOpt.rect = self.titleOptionRect(fw, mw)
titleOpt.title = q.windowTitle()
titleOpt.closable = self.hasFeature(q, QDockWidget.DockWidgetClosable)
titleOpt.floatable = self.hasFeature(q,
QDockWidget.DockWidgetFloatable)
p.drawControl(QStyle.CE_DockWidgetTitle, titleOpt)
def titleOptionRect(self, fw, mw):
if self.reportButton and self.checkStateButton:
return QRect(
QPoint(
fw + mw + self.reportButton.size().width() +
self.checkStateButton.size().width(), fw),
QSize(
self.geometry().width() - (fw * 2) - mw -
self.reportButton.size().width() -
self.checkStateButton.size().width(),
self.geometry().height() - (fw * 2)))
elif self.reportButton:
return QRect(
QPoint(fw + mw + self.reportButton.size().width(), fw),
QSize(
self.geometry().width() - (fw * 2) - mw -
self.reportButton.size().width(),
self.geometry().height() - (fw * 2)))
elif self.checkStateButton:
return QRect(
QPoint(fw + mw + self.checkStateButton.size().width(), fw),
QSize(
self.geometry().width() - (fw * 2) - mw -
self.checkStateButton.size().width(),
self.geometry().height() - (fw * 2)))
else:
return QRect(
QPoint(fw + mw, fw),
QSize(self.geometry().width() - (fw * 2) - mw,
self.geometry().height() - (fw * 2)))
def resizeEvent(self, _event):
q = self.parentWidget()
fw = q.isFloating() and q.style().pixelMetric(
QStyle.PM_DockWidgetFrameWidth, None, q) or 0
opt = QStyleOptionDockWidgetV2()
opt.initFrom(q)
opt.rect = QRect(
QPoint(fw, fw),
QSize(self.geometry().width() - (fw * 2),
self.geometry().height() - (fw * 2)))
opt.title = q.windowTitle()
opt.closable = self.hasFeature(q, QDockWidget.DockWidgetClosable)
opt.floatable = self.hasFeature(q, QDockWidget.DockWidgetFloatable)
floatRect = q.style().subElementRect(QStyle.SE_DockWidgetFloatButton,
opt, q)
if not floatRect.isNull():
self.floatButton.setGeometry(floatRect)
closeRect = q.style().subElementRect(QStyle.SE_DockWidgetCloseButton,
opt, q)
if not closeRect.isNull():
self.closeButton.setGeometry(closeRect)
top = fw
if not floatRect.isNull():
top = floatRect.y()
elif not closeRect.isNull():
top = closeRect.y()
if self.checkStateButton:
size = self.checkStateButton.size()
if not closeRect.isNull():
size = self.closeButton.size()
elif not floatRect.isNull():
size = self.floatButton.size()
checkStateRect = QRect(QPoint(fw, top), size)
self.checkStateButton.setGeometry(checkStateRect)
if self.reportButton:
size = self.reportButton.size()
if not closeRect.isNull():
size = self.closeButton.size()
elif not floatRect.isNull():
size = self.floatButton.size()
reportRect = QRect(QPoint(fw, top), size)
self.reportButton.setGeometry(reportRect)
def toggleFloating(self):
parent = self.parentWidget()
parent.setFloating(not parent.isFloating())
def toggleCheckState(self, state):
parent = self.parentWidget()
if parent:
if state != 0:
parent.updateCheckState(True)
else:
parent.updateCheckState(False)
def toggleReport(self):
parent = self.parentWidget()
if parent:
parent.report()
def featuresChanged(self, _features):
parent = self.parentWidget()
self.closeButton.setVisible(
self.hasFeature(parent, QDockWidget.DockWidgetClosable))
self.floatButton.setVisible(
self.hasFeature(parent, QDockWidget.DockWidgetFloatable))
class General(preferences.Group):
def __init__(self, page):
super(General, self).__init__(page)
grid = QGridLayout()
self.setLayout(grid)
self.langLabel = QLabel()
self.lang = QComboBox(currentIndexChanged=self.changed)
grid.addWidget(self.langLabel, 0, 0)
grid.addWidget(self.lang, 0, 1)
self.styleLabel = QLabel()
self.styleCombo = QComboBox(currentIndexChanged=self.changed)
grid.addWidget(self.styleLabel, 1, 0)
grid.addWidget(self.styleCombo, 1, 1)
self.systemIcons = QCheckBox(toggled=self.changed)
grid.addWidget(self.systemIcons, 2, 0, 1, 3)
self.tabsClosable = QCheckBox(toggled=self.changed)
grid.addWidget(self.tabsClosable, 3, 0, 1, 3)
self.splashScreen = QCheckBox(toggled=self.changed)
grid.addWidget(self.splashScreen, 4, 0, 1, 3)
self.allowRemote = QCheckBox(toggled=self.changed)
grid.addWidget(self.allowRemote, 5, 0, 1, 3)
grid.setColumnStretch(2, 1)
# fill in the language combo
self._langs = ["C", ""]
self.lang.addItems(('', ''))
langnames = [(language_names.languageName(lang, lang), lang) for lang in po.available()]
langnames.sort()
for name, lang in langnames:
self._langs.append(lang)
self.lang.addItem(name)
# fill in style combo
self.styleCombo.addItem('')
self.styleCombo.addItems(QStyleFactory.keys())
app.translateUI(self)
def loadSettings(self):
s = QSettings()
lang = s.value("language", "", type(""))
try:
index = self._langs.index(lang)
except ValueError:
index = 1
self.lang.setCurrentIndex(index)
style = s.value("guistyle", "", type("")).lower()
styles = [name.lower() for name in QStyleFactory.keys()]
try:
index = styles.index(style) + 1
except ValueError:
index = 0
self.styleCombo.setCurrentIndex(index)
self.systemIcons.setChecked(s.value("system_icons", True, bool))
self.tabsClosable.setChecked(s.value("tabs_closable", True, bool))
self.splashScreen.setChecked(s.value("splash_screen", True, bool))
self.allowRemote.setChecked(remote.enabled())
def saveSettings(self):
s = QSettings()
s.setValue("language", self._langs[self.lang.currentIndex()])
s.setValue("system_icons", self.systemIcons.isChecked())
s.setValue("tabs_closable", self.tabsClosable.isChecked())
s.setValue("splash_screen", self.splashScreen.isChecked())
s.setValue("allow_remote", self.allowRemote.isChecked())
if self.styleCombo.currentIndex() == 0:
s.remove("guistyle")
else:
s.setValue("guistyle", self.styleCombo.currentText())
def translateUI(self):
self.setTitle(_("General Preferences"))
self.langLabel.setText(_("Language:"))
self.lang.setItemText(0, _("No Translation"))
self.lang.setItemText(1, _("System Default Language (if available)"))
self.styleLabel.setText(_("Style:"))
self.styleCombo.setItemText(0, _("Default"))
self.systemIcons.setText(_("Use System Icons"))
self.systemIcons.setToolTip(_(
"If checked, icons of the desktop icon theme "
"will be used instead of the bundled icons.\n"
"This setting takes effect on the next start of {appname}.").format(appname=appinfo.appname))
self.splashScreen.setText(_("Show Splash Screen on Startup"))
self.tabsClosable.setText(_("Show Close Button on Document tabs"))
self.allowRemote.setText(_("Open Files in Running Instance"))
self.allowRemote.setToolTip(_(
"If checked, files will be opened in a running Frescobaldi "
"application if available, instead of starting a new instance."))
class LDSConfigPage(QWizardPage):
def __init__(self, parent=None,key=None):
super(LDSConfigPage, self).__init__(parent)
self.parent = parent
self.key = key#'lds'
try:
(ldsurl,ldskey,ldssvc,ldsver,ldsfmt,ldscql) = self.parent.mfr.readLDSConfig()
except:
(ldsurl,ldskey,ldssvc,ldsver,ldsfmt,ldscql) = (None,)*6
self.setTitle(self.parent.plist.get(self.key)[1]+' Configuration Options')
self.setSubTitle('Here you can enter a name for your custom configuration file, your LDS API key and required output. Also select whether you want to configure a proxy or enable password encryption')
QToolTip.setFont(QFont('SansSerif', 10))
#labels
fileLabel = QLabel('User Config File')
keyLabel = QLabel('LDS API Key')
destLabel = QLabel('Output Type')
internalLabel = QLabel('Save Layer-Config in DB')
self.warnLabel = QLabel('!!!')
encryptionLabel = QLabel('Enable Password Protection')
serviceLabel = QLabel('Service Type')
versionLabel = QLabel('Service Version')
infoLinkLabel = QLabel('<a href="http://www.linz.govt.nz/about-linz/linz-data-service/features/how-to-use-web-services">LDS API Information Page</a>')
infoLinkLabel.setOpenExternalLinks(True);
keyLinkLabel = QLabel('<a href="http://data.linz.govt.nz/my/api/">LDS API Key</a>')
keyLinkLabel.setOpenExternalLinks(True);
#edit boxes
self.fileEdit = QLineEdit(self.parent.uchint)
self.fileEdit.setToolTip('Name of user config file (without .conf suffix)')
self.keyEdit = QLineEdit(ldskey)
self.keyEdit.setToolTip('This is your LDS API key. If you have an account you can copy your key from here <a href="http://data.linz.govt.nz/my/api/">http://data.linz.govt.nz/my/api/</a>')
#dropdown
self.destSelect = QComboBox()
self.destSelect.setToolTip('Choose from one of four possible output destinations')
self.destSelect.addItem('')
for itemkey in ('pg','ms','fg','sl'):
itemindex = self.parent.plist.get(itemkey)[0]
itemdata = self.parent.plist.get(itemkey)[1]
self.destSelect.addItem(itemdata, itemindex)
if itemdata == self.parent.sechint:
self.destSelect.setCurrentIndex(itemindex)
self.serviceSelect = QComboBox()
self.serviceSelect.setToolTip('Choose from WFS (or one day, WMS)')
for itemkey in ('','WFS','WMS','WMTS'):
self.serviceSelect.addItem(itemkey)
self.serviceSelect.setCurrentIndex(0)
self.versionSelect = QComboBox()
self.versionSelect.setToolTip('Choose service Version')
for itemkey in ('','1.0.0','1.1.0','2.0.0'):
self.versionSelect.addItem(itemkey)
self.versionSelect.setCurrentIndex(0)
self.keyEdit.setValidator(QRegExpValidator(QRegExp("[a-fA-F0-9]{32}", re.IGNORECASE), self))
#checkbox
self.internalEnable = QCheckBox()
self.internalEnable.setToolTip('Enable saving layer-config (per layer config and progress settings) internally')
self.internalEnable.toggle()
self.internalEnable.setChecked(True)
self.internalEnable.stateChanged.connect(self.setWarn)
self.encryptionEnable = QCheckBox()
self.encryptionEnable.setToolTip('Encrypt any passwords saved to user config file')
self.registerField(self.key+"file",self.fileEdit)
self.registerField(self.key+"apikey",self.keyEdit)
self.registerField(self.key+"dest",self.destSelect,"currentIndex")
self.registerField(self.key+"internal",self.internalEnable)
self.registerField(self.key+"encryption",self.encryptionEnable)
#grid
grid = QGridLayout()
grid.setSpacing(10)
grid.addWidget(fileLabel, 1, 0)
grid.addWidget(self.fileEdit, 1, 2)
#grid.addWidget(cfileButton, 1, 3)
grid.addWidget(keyLabel, 2, 0)
grid.addWidget(self.keyEdit, 2, 2)
grid.addWidget(destLabel, 3, 0)
grid.addWidget(self.destSelect, 3, 2)
grid.addWidget(internalLabel, 4, 0)
grid.addWidget(self.internalEnable, 4, 2)
#if self.internalEnable.checkState(): grid.addWidget(intwarnLabel, 4, 4)
grid.addWidget(encryptionLabel, 5, 0)
grid.addWidget(self.encryptionEnable, 5, 2)
svgrid = QGridLayout()
svgrid.addWidget(serviceLabel, 0, 0)
svgrid.addWidget(self.serviceSelect, 0, 2)
svgrid.addWidget(versionLabel, 1, 0)
svgrid.addWidget(self.versionSelect, 1, 2)
hbox = QHBoxLayout()
hbox.addStretch(1)
hbox.addLayout(svgrid)
#layout
vbox = QVBoxLayout()
vbox.addLayout(grid)
#vbox.addLayout(hbox)
vbox.addStretch(1)
vbox.addWidget(self.warnLabel)
vbox.addWidget(keyLinkLabel)
vbox.addWidget(infoLinkLabel)
self.setLayout(vbox)
#def selectConfFile(self):
# self.fileEdit.setText(QFileDialog.getOpenFileName())
def nextId(self):
#if self.field(self.key+"proxy").toBool():
return self.parent.plist.get('proxy')[0]
#return int(self.field(self.key+"dest").toString())
def setWarn(self):
if self.internalEnable.checkState():
ldslog.warn('Warning, Internal config selected')
self.warnLabel.setText('!!!')
QApplication.processEvents()
else:
ldslog.warn('External config selected')
self.warnLabel.setText('^_^')
QApplication.processEvents()
dialog = CustomDialog("Robust CSV Export", description, parent)
output_path_model = PathModel("output.csv")
output_path_chooser = PathChooser(output_path_model)
trajectory_model = PathModel("wellpath", must_be_a_directory=True, must_be_a_file=False, must_exist=True)
trajectory_chooser = PathChooser(trajectory_model)
fs_manager = self.ert().getEnkfFsManager()
all_case_list = fs_manager.getCaseList()
all_case_list = [case for case in all_case_list if fs_manager.caseHasData(case)]
list_edit = ListEditBox(all_case_list)
infer_iteration_check = QCheckBox()
infer_iteration_check.setChecked(True)
infer_iteration_check.setToolTip(GenDataRFTCSVExportJob.INFER_HELP)
dialog.addLabeledOption("Output file path", output_path_chooser)
dialog.addLabeledOption("Trajectory file", trajectory_chooser)
dialog.addLabeledOption("List of cases to export", list_edit)
dialog.addLabeledOption("Infer iteration number", infer_iteration_check)
dialog.addButtons()
success = dialog.showAndTell()
if success:
case_list = ",".join(list_edit.getItems())
try:
return [output_path_model.getPath(), trajectory_model.getPath(), case_list, infer_iteration_check.isChecked()]
except ValueError:
class Dialog(QDialog):
def __init__(self, parent=None):
super(Dialog, self).__init__(parent)
self._info = None
self._text = ""
self._convertedtext = ""
self._encoding = None
self.fromVersionLabel = QLabel()
self.fromVersion = QLineEdit()
self.reason = QLabel()
self.toVersionLabel = QLabel()
self.toVersion = QLineEdit()
self.messages = QTextBrowser()
self.diff = QTextBrowser(lineWrapMode=QTextBrowser.NoWrap)
self.copyCheck = QCheckBox(checked=QSettings().value("convert_ly/copy_messages", True) not in (False, "false"))
self.tabw = QTabWidget()
self.tabw.addTab(self.messages, "")
self.tabw.addTab(self.diff, "")
self.buttons = QDialogButtonBox(QDialogButtonBox.Reset | QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
self.buttons.accepted.connect(self.accept)
self.buttons.rejected.connect(self.reject)
self.buttons.button(QDialogButtonBox.Reset).clicked.connect(self.run)
layout = QVBoxLayout()
self.setLayout(layout)
top = QHBoxLayout()
top.addWidget(self.fromVersionLabel)
top.addWidget(self.fromVersion)
top.addWidget(self.reason)
top.addStretch()
top.addWidget(self.toVersionLabel)
top.addWidget(self.toVersion)
layout.addLayout(top)
layout.addWidget(self.tabw)
layout.addWidget(self.copyCheck)
layout.addWidget(widgets.Separator())
layout.addWidget(self.buttons)
app.translateUI(self)
util.saveDialogSize(self, "convert_ly/dialog/size", QSize(600, 300))
app.settingsChanged.connect(self.readSettings)
self.readSettings()
self.finished.connect(self.saveCopyCheckSetting)
def translateUI(self):
self.fromVersionLabel.setText(_("From version:"))
self.toVersionLabel.setText(_("To version:"))
self.copyCheck.setText(_("Save convert-ly messages in document"))
self.copyCheck.setToolTip(
_("If checked, the messages of convert-ly are appended as a " "comment to the end of the document.")
)
self.tabw.setTabText(0, _("&Messages"))
self.tabw.setTabText(1, _("&Changes"))
self.buttons.button(QDialogButtonBox.Reset).setText(_("Run Again"))
self.setCaption()
def saveCopyCheckSetting(self):
QSettings().setValue("convert_ly/copy_messages", self.copyCheck.isChecked())
def readSettings(self):
font = textformats.formatData("editor").font
self.diff.setFont(font)
def setCaption(self):
version = self._info and self._info.versionString() or _("<unknown>")
title = _("Convert-ly from LilyPond {version}").format(version=version)
self.setWindowTitle(app.caption(title))
def setLilyPondInfo(self, info):
self._info = info
self.setCaption()
self.toVersion.setText(info.versionString())
self.setConvertedText()
def setConvertedText(self, text=""):
self._convertedtext = text
self.buttons.button(QDialogButtonBox.Ok).setEnabled(bool(text))
if text:
self.diff.setHtml(makeHtmlDiff(self._text, text))
else:
self.diff.clear()
def convertedText(self):
return self._convertedtext or ""
def setDocument(self, doc):
v = documentinfo.info(doc).versionString()
if v:
self.fromVersion.setText(v)
self.reason.setText(_("(set in document)"))
else:
self.reason.clear()
self._text = doc.toPlainText()
self._encoding = doc.encoding() or "UTF-8"
self.setConvertedText()
def run(self):
"""Runs convert-ly (again)."""
fromVersion = self.fromVersion.text()
toVersion = self.toVersion.text()
if not fromVersion or not toVersion:
self.messages.setPlainText(_("Both 'from' and 'to' versions need to be set."))
return
info = self._info
convert_ly = os.path.join(info.bindir(), info.convert_ly)
# on Windows the convert-ly command is not directly executable, but
# must be started using the LilyPond-provided Python interpreter
if os.name == "nt":
if not os.access(convert_ly, os.R_OK) and not convert_ly.endswith(".py"):
convert_ly += ".py"
command = [info.python(), convert_ly]
else:
command = [convert_ly]
command += ["-f", fromVersion, "-t", toVersion, "-"]
# if the user wants english messages, do it also here
env = None
if QSettings().value("lilypond_settings/no_translation", False) in (True, "true"):
env = dict(os.environ)
env["LANGUAGE"] = "C"
with util.busyCursor():
try:
proc = subprocess.Popen(
command, env=env, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE
)
out, err = proc.communicate(self._text.encode(self._encoding))
except OSError as e:
self.messages.setPlainText(
_("Could not start {convert_ly}:\n\n" "{message}\n").format(convert_ly=convert_ly, message=e)
)
return
self.messages.setPlainText(err.decode("UTF-8"))
self.setConvertedText(out.decode("UTF-8"))
if not out or self._convertedtext == self._text:
self.messages.append("\n" + _("The document has not been changed."))
class RecordingWidget(QWidget):
"""Widget containing main recording UI for Freeseer"""
def __init__(self, parent=None):
QWidget.__init__(self, parent)
icon = QIcon()
icon.addPixmap(QPixmap(":/freeseer/logo.png"), QIcon.Normal, QIcon.Off)
self.setWindowIcon(icon)
self.resize(400, 400)
self.mainLayout = QVBoxLayout()
self.setLayout(self.mainLayout)
boldFont = QFont()
boldFont.setBold(True)
# Control bar
self.controlRow = QHBoxLayout()
self.mainLayout.addLayout(self.controlRow)
self.standbyIcon = QIcon.fromTheme("system-shutdown")
recordFallbackIcon = QIcon(":/multimedia/record.png")
self.recordIcon = QIcon.fromTheme("media-record", recordFallbackIcon)
stopFallbackIcon = QIcon(":/multimedia/stop.png")
self.stopIcon = QIcon.fromTheme("media-playback-stop",
stopFallbackIcon)
self.pauseIcon = QIcon.fromTheme("media-playback-pause")
self.resumeIcon = QIcon.fromTheme("media-playback-start")
self.headphoneIcon = QIcon()
self.headphoneIcon.addPixmap(QPixmap(":/multimedia/headphones.png"),
QIcon.Normal, QIcon.Off)
self.standbyPushButton = QPushButton("Standby")
self.standbyPushButton.setToolTip("Standby")
self.standbyPushButton.setMinimumSize(QSize(0, 40))
self.standbyPushButton.setSizePolicy(QSizePolicy.Minimum,
QSizePolicy.Fixed)
self.standbyPushButton.setIcon(self.standbyIcon)
self.standbyPushButton.setCheckable(True)
self.standbyPushButton.setObjectName("standbyButton")
self.controlRow.addWidget(self.standbyPushButton)
self.autoRecordPushButton = QPushButton("Auto Record")
self.autoRecordPushButton.setToolTip("Automated Recording")
self.autoRecordPushButton.setMinimumSize(QSize(40, 40))
self.autoRecordPushButton.setMaximumSize(QSize(120, 40))
self.autoRecordPushButton.setCheckable(True)
self.autoRecordPushButton.setObjectName("autoRecordButton")
self.controlRow.addWidget(self.autoRecordPushButton)
self.recordPushButton = QPushButton("Record")
self.recordPushButton.setToolTip("Record")
self.recordPushButton.setMinimumSize(QSize(0, 40))
self.recordPushButton.setSizePolicy(QSizePolicy.Minimum,
QSizePolicy.Fixed)
self.recordPushButton.setIcon(self.recordIcon)
self.recordPushButton.setHidden(True)
self.recordPushButton.setEnabled(False)
self.recordPushButton.setCheckable(True)
self.recordPushButton.setObjectName("recordButton")
self.controlRow.addWidget(self.recordPushButton)
self.connect(self.recordPushButton, SIGNAL("toggled(bool)"),
self.setRecordIcon)
self.pauseToolButton = QToolButton()
self.pauseToolButton.setText("Pause")
self.pauseToolButton.setToolTip("Pause")
self.pauseToolButton.setIcon(self.pauseIcon)
self.pauseToolButton.setMinimumSize(QSize(40, 40))
self.pauseToolButton.setSizePolicy(QSizePolicy.Maximum,
QSizePolicy.Fixed)
self.pauseToolButton.setHidden(True)
self.pauseToolButton.setEnabled(False)
self.pauseToolButton.setCheckable(True)
self.controlRow.addWidget(self.pauseToolButton)
self.connect(self.pauseToolButton, SIGNAL("toggled(bool)"),
self.setPauseIcon)
playbackIcon = QIcon.fromTheme("video-x-generic")
self.playPushButton = QPushButton()
self.playPushButton.setText("Play Video")
self.playPushButton.setToolTip("Play last recorded Video")
self.playPushButton.setIcon(playbackIcon)
self.playPushButton.setMinimumSize(QSize(40, 40))
self.playPushButton.setMaximumSize(QSize(120, 40))
self.playPushButton.setHidden(True)
self.playPushButton.setEnabled(False)
self.playPushButton.setCheckable(True)
self.controlRow.addWidget(self.playPushButton)
# Filter bar
self.filterBarLayout = QVBoxLayout()
self.mainLayout.addLayout(self.filterBarLayout)
self.filterBarLayoutRow_1 = QHBoxLayout()
self.filterBarLayout.addLayout(self.filterBarLayoutRow_1)
self.eventLabel = QLabel("Event")
self.eventLabel.setSizePolicy(QSizePolicy.Maximum, QSizePolicy.Fixed)
self.eventComboBox = QComboBox()
self.eventLabel.setBuddy(self.eventComboBox)
self.roomLabel = QLabel("Room")
self.roomLabel.setSizePolicy(QSizePolicy.Maximum, QSizePolicy.Fixed)
self.roomComboBox = QComboBox()
self.roomLabel.setBuddy(self.roomComboBox)
self.dateLabel = QLabel("Date")
self.dateLabel.setSizePolicy(QSizePolicy.Maximum, QSizePolicy.Fixed)
self.dateComboBox = QComboBox()
self.dateLabel.setBuddy(self.dateComboBox)
self.filterBarLayoutRow_1.addWidget(self.eventLabel)
self.filterBarLayoutRow_1.addWidget(self.eventComboBox)
self.filterBarLayoutRow_1.addWidget(self.roomLabel)
self.filterBarLayoutRow_1.addWidget(self.roomComboBox)
self.filterBarLayoutRow_1.addWidget(self.dateLabel)
self.filterBarLayoutRow_1.addWidget(self.dateComboBox)
self.filterBarLayoutRow_2 = QHBoxLayout()
self.filterBarLayout.addLayout(self.filterBarLayoutRow_2)
self.talkLabel = QLabel("Talk ")
self.talkLabel.setSizePolicy(QSizePolicy.Maximum, QSizePolicy.Fixed)
self.talkComboBox = QComboBox()
self.talkComboBox.setFont(boldFont)
self.talkComboBox.setSizePolicy(QSizePolicy.Minimum,
QSizePolicy.Maximum)
self.talkComboBox.setSizeAdjustPolicy(
QComboBox.AdjustToMinimumContentsLength)
self.filterBarLayoutRow_2.addWidget(self.talkLabel)
self.filterBarLayoutRow_2.addWidget(self.talkComboBox)
# Preview Layout
self.previewLayout = QHBoxLayout()
self.mainLayout.addLayout(self.previewLayout)
self.previewWidget = QWidget()
self.audioSlider = QSlider()
self.audioSlider.setSizePolicy(QSizePolicy.Fixed,
QSizePolicy.Expanding)
self.audioSlider.setEnabled(False)
self.previewLayout.addWidget(self.previewWidget)
self.previewLayout.addWidget(self.audioSlider)
self.statusLabel = QLabel()
self.mainLayout.addWidget(self.statusLabel)
# Audio Feedback Checkbox
self.audioFeedbackCheckbox = QCheckBox()
self.audioFeedbackCheckbox.setLayoutDirection(Qt.RightToLeft)
self.audioFeedbackCheckbox.setIcon(self.headphoneIcon)
self.audioFeedbackCheckbox.setToolTip("Enable Audio Feedback")
self.mainLayout.addWidget(self.audioFeedbackCheckbox)
def setRecordIcon(self, state):
if state:
self.recordPushButton.setIcon(self.stopIcon)
else:
self.recordPushButton.setIcon(self.recordIcon)
def setPauseIcon(self, state):
if state:
self.pauseToolButton.setIcon(self.resumeIcon)
else:
self.pauseToolButton.setIcon(self.pauseIcon)
class SessionEditor(QDialog):
def __init__(self, parent=None):
super(SessionEditor, self).__init__(parent)
self.setWindowModality(Qt.WindowModal)
layout = QVBoxLayout()
self.setLayout(layout)
grid = QGridLayout()
layout.addLayout(grid)
self.name = QLineEdit()
self.nameLabel = l = QLabel()
l.setBuddy(self.name)
grid.addWidget(l, 0, 0)
grid.addWidget(self.name, 0, 1)
self.autosave = QCheckBox()
grid.addWidget(self.autosave, 1, 1)
self.basedir = widgets.urlrequester.UrlRequester()
self.basedirLabel = l = QLabel()
l.setBuddy(self.basedir)
grid.addWidget(l, 2, 0)
grid.addWidget(self.basedir, 2, 1)
self.inclPaths = ip = QGroupBox(self, checkable=True, checked=False)
ipLayout = QVBoxLayout()
ip.setLayout(ipLayout)
self.replPaths = QCheckBox()
ipLayout.addWidget(self.replPaths)
self.replPaths.toggled.connect(self.toggleReplace)
self.include = widgets.listedit.FilePathEdit()
self.include.listBox.setDragDropMode(QAbstractItemView.InternalMove)
ipLayout.addWidget(self.include)
grid.addWidget(ip, 3, 1)
self.revt = QPushButton(self)
self.clear = QPushButton(self)
self.revt.clicked.connect(self.revertPaths)
self.clear.clicked.connect(self.clearPaths)
self.include.layout().addWidget(self.revt, 5, 1)
self.include.layout().addWidget(self.clear, 6, 1)
layout.addWidget(widgets.Separator())
self.buttons = b = QDialogButtonBox(self)
layout.addWidget(b)
b.setStandardButtons(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
b.accepted.connect(self.accept)
b.rejected.connect(self.reject)
userguide.addButton(b, "sessions")
app.translateUI(self)
def translateUI(self):
self.nameLabel.setText(_("Name:"))
self.autosave.setText(_("Always save the list of documents in this session"))
self.basedirLabel.setText(_("Base directory:"))
self.inclPaths.setTitle(_("Use session specific include path"))
self.replPaths.setText(_("Replace global path"))
self.replPaths.setToolTip(_("When checked, paths in LilyPond preferences are not included."))
self.revt.setText(_("Copy global path"))
self.revt.setToolTip(_("Add and edit the path from LilyPond preferences."))
self.clear.setText(_("Clear"))
self.clear.setToolTip(_("Remove all paths."))
def load(self, name):
settings = sessions.sessionGroup(name)
self.autosave.setChecked(settings.value("autosave", True, bool))
self.basedir.setPath(settings.value("basedir", "", type("")))
try:
paths = settings.value("include-path", [], type(""))
except TypeError:
paths = []
self.include.setValue(paths)
self.inclPaths.setChecked(settings.value("set-paths", False, bool))
self.replPaths.setChecked(settings.value("repl-paths", False, bool))
if not self.replPaths.isChecked():
self.addDisabledGenPaths()
self.revt.setEnabled(False)
# more settings here
def fetchGenPaths(self):
"""Fetch paths from general preferences."""
s = QSettings()
s.beginGroup("lilypond_settings")
try:
return s.value("include_path", [], type(""))
except TypeError:
return []
def addDisabledGenPaths(self):
"""Add global paths, but set as disabled."""
genPaths = self.fetchGenPaths()
for p in genPaths:
i = QListWidgetItem(p, self.include.listBox)
i.setFlags(Qt.NoItemFlags)
def toggleReplace(self):
"""Called when user changes setting for replace of global paths."""
if self.replPaths.isChecked():
items = self.include.items()
for i in items:
if not (i.flags() & Qt.ItemIsEnabled): #is not enabled
self.include.listBox.takeItem(self.include.listBox.row(i))
self.revt.setEnabled(True)
else:
self.addDisabledGenPaths()
self.revt.setEnabled(False)
def revertPaths(self):
"""Add global paths (for edit)."""
genPaths = self.fetchGenPaths()
for p in genPaths:
i = QListWidgetItem(p, self.include.listBox)
def clearPaths(self):
"""Remove all active paths."""
items = self.include.items()
for i in items:
if i.flags() & Qt.ItemIsEnabled:
self.include.listBox.takeItem(self.include.listBox.row(i))
def save(self, name):
settings = sessions.sessionGroup(name)
settings.setValue("autosave", self.autosave.isChecked())
settings.setValue("basedir", self.basedir.path())
settings.setValue("set-paths", self.inclPaths.isChecked())
settings.setValue("repl-paths", self.replPaths.isChecked())
path = [i.text() for i in self.include.items() if i.flags() & Qt.ItemIsEnabled]
settings.setValue("include-path", path)
# more settings here
def defaults(self):
self.autosave.setChecked(True)
self.basedir.setPath('')
self.inclPaths.setChecked(False)
self.replPaths.setChecked(False)
self.addDisabledGenPaths()
self.revt.setEnabled(False)
# more defaults here
def edit(self, name=None):
self._originalName = name
if name:
caption = _("Edit session: {name}").format(name=name)
self.name.setText(name)
self.load(name)
else:
caption = _("Edit new session")
self.name.clear()
self.name.setFocus()
self.defaults()
self.setWindowTitle(app.caption(caption))
if self.exec_():
# name changed?
name = self.name.text()
if self._originalName and name != self._originalName:
sessions.renameSession(self._originalName, name)
self.save(name)
return name
def done(self, result):
if not result or self.validate():
super(SessionEditor, self).done(result)
def validate(self):
"""Checks if the input is acceptable.
If this method returns True, the dialog is accepted when OK is clicked.
Otherwise a messagebox could be displayed, and the dialog will remain
visible.
"""
name = self.name.text().strip()
self.name.setText(name)
if not name:
self.name.setFocus()
QMessageBox.warning(self, app.caption(_("Warning")),
_("Please enter a session name."))
if self._originalName:
self.name.setText(self._originalName)
return False
elif name == '-':
self.name.setFocus()
QMessageBox.warning(self, app.caption(_("Warning")),
_("Please do not use the name '{name}'.".format(name="-")))
return False
elif self._originalName != name and name in sessions.sessionNames():
self.name.setFocus()
box = QMessageBox(QMessageBox.Warning, app.caption(_("Warning")),
_("Another session with the name {name} already exists.\n\n"
"Do you want to overwrite it?").format(name=name),
QMessageBox.Discard | QMessageBox.Cancel, self)
box.button(QMessageBox.Discard).setText(_("Overwrite"))
result = box.exec_()
if result != QMessageBox.Discard:
return False
return True
class TidySettingsDialog(QDialog):
" PythonTidy.py script settings dialog "
def __init__(self, settings, path, parent=None):
QDialog.__init__(self, parent)
self.__settings = settings
self.__path = path
self.__createLayout()
self.setWindowTitle("PythonTidy settings")
return
def __createLayout(self):
""" Creates the dialog layout """
self.resize(700, 300)
self.setSizeGripEnabled(True)
layout = QVBoxLayout(self)
gridLayout = QGridLayout()
# Columns
colsLabel = QLabel("Columns")
self.__colsEdit = QLineEdit()
self.__colsEdit.setText(str(self.__settings.settings["COL_LIMIT"]))
self.__colsEdit.setToolTip(self.__settings.getDescription("COL_LIMIT"))
self.__colsEdit.textChanged.connect(self.__validate)
gridLayout.addWidget(colsLabel, 0, 0, 1, 1)
gridLayout.addWidget(self.__colsEdit, 0, 1, 1, 1)
font = self.__colsEdit.font()
font.setFamily(GlobalData().skin.baseMonoFontFace)
self.__colsEdit.setFont(font)
# Assignment
assignmentLabel = QLabel("Assignment")
self.__assignmentEdit = QLineEdit()
self.__assignmentEdit.setText(self.__settings.settings["ASSIGNMENT"])
self.__assignmentEdit.setToolTip(
self.__settings.getDescription("ASSIGNMENT"))
self.__assignmentEdit.textChanged.connect(self.__validate)
gridLayout.addWidget(assignmentLabel, 0, 3, 1, 1)
gridLayout.addWidget(self.__assignmentEdit, 0, 4, 1, 1)
self.__assignmentEdit.setFont(font)
# Function parameters assignment
funcAssignLabel = QLabel("Function params\nassignment")
self.__funcAssignEdit = QLineEdit()
self.__funcAssignEdit.setText(
self.__settings.settings["FUNCTION_PARAM_ASSIGNMENT"])
self.__funcAssignEdit.setToolTip(
self.__settings.getDescription("FUNCTION_PARAM_ASSIGNMENT"))
self.__funcAssignEdit.textChanged.connect(self.__validate)
gridLayout.addWidget(funcAssignLabel, 1, 0, 1, 1)
gridLayout.addWidget(self.__funcAssignEdit, 1, 1, 1, 1)
self.__funcAssignEdit.setFont(font)
# Dictionary separator
dictSepLabel = QLabel("Dictionary separator")
self.__dictSepEdit = QLineEdit()
self.__dictSepEdit.setText(self.__settings.settings["DICT_COLON"])
self.__dictSepEdit.setToolTip(
self.__settings.getDescription("DICT_COLON"))
self.__dictSepEdit.textChanged.connect(self.__validate)
gridLayout.addWidget(dictSepLabel, 1, 3, 1, 1)
gridLayout.addWidget(self.__dictSepEdit, 1, 4, 1, 1)
self.__dictSepEdit.setFont(font)
# Slice separator
sliceSepLabel = QLabel("Slice separator")
self.__sliceSepEdit = QLineEdit()
self.__sliceSepEdit.setText(self.__settings.settings["SLICE_COLON"])
self.__sliceSepEdit.setToolTip(
self.__settings.getDescription("SLICE_COLON"))
self.__sliceSepEdit.textChanged.connect(self.__validate)
gridLayout.addWidget(sliceSepLabel, 2, 0, 1, 1)
gridLayout.addWidget(self.__sliceSepEdit, 2, 1, 1, 1)
self.__sliceSepEdit.setFont(font)
# Interpreter
inLabel = QLabel("Interpreter")
self.__inEdit = QLineEdit()
self.__inEdit.setText(self.__settings.settings["SHEBANG"])
self.__inEdit.setToolTip(self.__settings.getDescription("SHEBANG"))
self.__inEdit.textChanged.connect(self.__validate)
gridLayout.addWidget(inLabel, 2, 3, 1, 1)
gridLayout.addWidget(self.__inEdit, 2, 4, 1, 1)
self.__inEdit.setFont(font)
# Coding spec
codingLabel = QLabel("Output encoding")
self.__outCodingEdit = QLineEdit()
self.__outCodingEdit.setText(self.__settings.settings["CODING"])
self.__outCodingEdit.setToolTip(
self.__settings.getDescription("CODING"))
self.__outCodingEdit.textChanged.connect(self.__validate)
gridLayout.addWidget(codingLabel, 3, 0, 1, 1)
gridLayout.addWidget(self.__outCodingEdit, 3, 1, 1, 1)
self.__outCodingEdit.setFont(font)
# Src coding comment
srcCodingLabel = QLabel("File encoding\ncomment")
self.__srcCodingEdit = QLineEdit()
self.__srcCodingEdit.setText(self.__settings.settings["CODING_SPEC"])
self.__srcCodingEdit.setToolTip(
self.__settings.getDescription("CODING_SPEC"))
self.__srcCodingEdit.textChanged.connect(self.__validate)
gridLayout.addWidget(srcCodingLabel, 3, 3, 1, 1)
gridLayout.addWidget(self.__srcCodingEdit, 3, 4, 1, 1)
self.__srcCodingEdit.setFont(font)
layout.addLayout(gridLayout)
# Boilerplate
boilLabel = QLabel("Boilerplate ")
boilLabel.setAlignment(Qt.AlignTop)
self.__boilEdit = QTextEdit()
self.__boilEdit.setPlainText(self.__settings.settings["BOILERPLATE"])
self.__boilEdit.setToolTip(
self.__settings.getDescription("BOILERPLATE"))
self.__boilEdit.setTabChangesFocus(True)
self.__boilEdit.setAcceptRichText(False)
self.__boilEdit.setFont(font)
self.__boilEdit.textChanged.connect(self.__validate)
boilLayout = QHBoxLayout()
boilLayout.addWidget(boilLabel)
boilLayout.addWidget(self.__boilEdit)
layout.addLayout(boilLayout)
# Now check boxes and radio buttons
cbGridLayout = QGridLayout()
self.__keepBlanks = QCheckBox("Keep blank lines")
self.__keepBlanks.setChecked(
self.__settings.settings["KEEP_BLANK_LINES"])
self.__keepBlanks.setToolTip(
self.__settings.getDescription("KEEP_BLANK_LINES"))
cbGridLayout.addWidget(self.__keepBlanks, 0, 0, 1, 1)
self.__addBlanks = QCheckBox("Add blank lines around comments")
self.__addBlanks.setChecked(
self.__settings.settings["ADD_BLANK_LINES_AROUND_COMMENTS"])
self.__addBlanks.setToolTip(
self.__settings.getDescription("ADD_BLANK_LINES_AROUND_COMMENTS"))
cbGridLayout.addWidget(self.__addBlanks, 0, 2, 1, 1)
self.__justifyDoc = QCheckBox("Left justify doc strings")
self.__justifyDoc.setChecked(
self.__settings.settings["LEFTJUST_DOC_STRINGS"])
self.__justifyDoc.setToolTip(
self.__settings.getDescription("LEFTJUST_DOC_STRINGS"))
cbGridLayout.addWidget(self.__justifyDoc, 1, 0, 1, 1)
self.__wrapDoc = QCheckBox("Wrap long doc strings")
self.__wrapDoc.setChecked(self.__settings.settings["WRAP_DOC_STRINGS"])
self.__wrapDoc.setToolTip(
self.__settings.getDescription("WRAP_DOC_STRINGS"))
cbGridLayout.addWidget(self.__wrapDoc, 1, 2, 1, 1)
self.__recodeStrings = QCheckBox("Try to decode strings")
self.__recodeStrings.setChecked(
self.__settings.settings["RECODE_STRINGS"])
self.__recodeStrings.setToolTip(
self.__settings.getDescription("RECODE_STRINGS"))
cbGridLayout.addWidget(self.__recodeStrings, 2, 0, 1, 1)
self.__splitStrings = QCheckBox("Split long strings")
self.__splitStrings.setChecked(
self.__settings.settings["CAN_SPLIT_STRINGS"])
self.__splitStrings.setToolTip(
self.__settings.getDescription("CAN_SPLIT_STRINGS"))
cbGridLayout.addWidget(self.__splitStrings, 2, 2, 1, 1)
self.__keepUnassignedConst = QCheckBox("Keep unassigned constants")
self.__keepUnassignedConst.setChecked(
self.__settings.settings["KEEP_UNASSIGNED_CONSTANTS"])
self.__keepUnassignedConst.setToolTip(
self.__settings.getDescription("KEEP_UNASSIGNED_CONSTANTS"))
cbGridLayout.addWidget(self.__keepUnassignedConst, 3, 0, 1, 1)
self.__parenTuple = QCheckBox("Parenthesize tuple display")
self.__parenTuple.setChecked(
self.__settings.settings["PARENTHESIZE_TUPLE_DISPLAY"])
self.__parenTuple.setToolTip(
self.__settings.getDescription("PARENTHESIZE_TUPLE_DISPLAY"))
cbGridLayout.addWidget(self.__parenTuple, 3, 2, 1, 1)
self.__javaListDedent = QCheckBox("Java style list dedent")
self.__javaListDedent.setChecked(
self.__settings.settings["JAVA_STYLE_LIST_DEDENT"])
self.__javaListDedent.setToolTip(
self.__settings.getDescription("JAVA_STYLE_LIST_DEDENT"))
cbGridLayout.addWidget(self.__javaListDedent, 4, 0, 1, 1)
layout.addLayout(cbGridLayout)
# Quotes radio buttons
quotesGroupbox = QGroupBox("Quotes")
sizePolicy = QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Preferred)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth( \
quotesGroupbox.sizePolicy().hasHeightForWidth() )
quotesGroupbox.setSizePolicy(sizePolicy)
layoutQG = QVBoxLayout(quotesGroupbox)
self.__use1RButton = QRadioButton(
"Use apostrophes instead of quotes for string literals",
quotesGroupbox)
layoutQG.addWidget(self.__use1RButton)
self.__use2RButton = QRadioButton(
"Use quotes instead of apostrophes for string literals",
quotesGroupbox)
layoutQG.addWidget(self.__use2RButton)
self.__useAsIsRButton = QRadioButton("Do not make changes",
quotesGroupbox)
layoutQG.addWidget(self.__useAsIsRButton)
use1 = self.__settings.settings["SINGLE_QUOTED_STRINGS"]
use2 = self.__settings.settings["DOUBLE_QUOTED_STRINGS"]
if use1:
self.__use1RButton.setChecked(True)
elif use2:
self.__use2RButton.setChecked(True)
else:
self.__useAsIsRButton.setChecked(True)
layout.addWidget(quotesGroupbox)
fontMetrics = QFontMetrics(font)
editWidth = fontMetrics.width("iso8859-10 ") + 20
self.__colsEdit.setFixedWidth(editWidth)
self.__funcAssignEdit.setFixedWidth(editWidth)
self.__sliceSepEdit.setFixedWidth(editWidth)
self.__outCodingEdit.setFixedWidth(editWidth)
# Buttons at the bottom
buttonBox = QDialogButtonBox(self)
buttonBox.setOrientation(Qt.Horizontal)
buttonBox.setStandardButtons(QDialogButtonBox.Cancel)
self.__resetButton = buttonBox.addButton("Reset to Default",
QDialogButtonBox.ActionRole)
self.__resetButton.setToolTip(
"Mostly as recommended by PEP 8 / PEP 308")
self.__resetButton.clicked.connect(self.__reset)
self.__tidyButton = buttonBox.addButton("Tidy",
QDialogButtonBox.ActionRole)
self.__tidyButton.setToolTip("Save settings and run PythonTidy")
self.__tidyButton.setDefault(True)
self.__tidyButton.clicked.connect(self.__saveAndAccept)
layout.addWidget(buttonBox)
buttonBox.rejected.connect(self.close)
return
def __reset(self):
" Resets the values to default "
self.__colsEdit.setText(
str(self.__settings.getDefaultValue("COL_LIMIT")))
self.__assignmentEdit.setText(
self.__settings.getDefaultValue("ASSIGNMENT"))
self.__funcAssignEdit.setText(
self.__settings.getDefaultValue("FUNCTION_PARAM_ASSIGNMENT"))
self.__dictSepEdit.setText(
self.__settings.getDefaultValue("DICT_COLON"))
self.__sliceSepEdit.setText(
self.__settings.getDefaultValue("SLICE_COLON"))
self.__inEdit.setText(self.__settings.getDefaultValue("SHEBANG"))
self.__outCodingEdit.setText(self.__settings.getDefaultValue("CODING"))
self.__srcCodingEdit.setText(
self.__settings.getDefaultValue("CODING_SPEC"))
self.__boilEdit.setPlainText(
self.__settings.getDefaultValue("BOILERPLATE"))
self.__keepBlanks.setChecked(
self.__settings.getDefaultValue("KEEP_BLANK_LINES"))
self.__addBlanks.setChecked(
self.__settings.getDefaultValue("ADD_BLANK_LINES_AROUND_COMMENTS"))
self.__justifyDoc.setChecked(
self.__settings.getDefaultValue("LEFTJUST_DOC_STRINGS"))
self.__wrapDoc.setChecked(
self.__settings.getDefaultValue("WRAP_DOC_STRINGS"))
self.__recodeStrings.setChecked(
self.__settings.getDefaultValue("RECODE_STRINGS"))
self.__splitStrings.setChecked(
self.__settings.getDefaultValue("CAN_SPLIT_STRINGS"))
self.__keepUnassignedConst.setChecked(
self.__settings.getDefaultValue("KEEP_UNASSIGNED_CONSTANTS"))
self.__parenTuple.setChecked(
self.__settings.getDefaultValue("PARENTHESIZE_TUPLE_DISPLAY"))
self.__javaListDedent.setChecked(
self.__settings.getDefaultValue("JAVA_STYLE_LIST_DEDENT"))
use1 = self.__settings.getDefaultValue("SINGLE_QUOTED_STRINGS")
use2 = self.__settings.getDefaultValue("DOUBLE_QUOTED_STRINGS")
if use1:
self.__use1RButton.setChecked(True)
self.__use2RButton.setChecked(False)
self.__useAsIsRButton.setChecked(False)
elif use2:
self.__use1RButton.setChecked(False)
self.__use2RButton.setChecked(True)
self.__useAsIsRButton.setChecked(False)
else:
self.__use1RButton.setChecked(False)
self.__use2RButton.setChecked(False)
self.__useAsIsRButton.setChecked(True)
self.__validate()
return
@staticmethod
def __setValid(field, value):
" Changes the field background depending on the validity "
if value:
field.setStyleSheet("")
else:
if isinstance(field, QLineEdit):
typeName = "QLineEdit"
else:
typeName = "QTextEdit"
field.setStyleSheet(typeName + "{ background: #ffa07a; }")
return
def __saveAndAccept(self):
" Saves the changes and accepts the values "
self.__validate()
if self.__tidyButton.isEnabled() == False:
return
self.__settings.settings["COL_LIMIT"] = int(self.__colsEdit.text())
self.__settings.settings["ASSIGNMENT"] = self.__assignmentEdit.text()
self.__settings.settings[
"FUNCTION_PARAM_ASSIGNMENT"] = self.__funcAssignEdit.text()
self.__settings.settings["DICT_COLON"] = self.__dictSepEdit.text()
self.__settings.settings["SLICE_COLON"] = self.__sliceSepEdit.text()
self.__settings.settings["SHEBANG"] = self.__inEdit.text()
self.__settings.settings["CODING"] = self.__outCodingEdit.text()
self.__settings.settings["CODING_SPEC"] = self.__srcCodingEdit.text()
self.__settings.settings["BOILERPLATE"] = self.__boilEdit.toPlainText()
self.__settings.settings["KEEP_BLANK_LINES"] = bool(
self.__keepBlanks.isChecked())
self.__settings.settings["ADD_BLANK_LINES_AROUND_COMMENTS"] = bool(
self.__addBlanks.isChecked())
self.__settings.settings["LEFTJUST_DOC_STRINGS"] = bool(
self.__justifyDoc.isChecked())
self.__settings.settings["WRAP_DOC_STRINGS"] = bool(
self.__wrapDoc.isChecked())
self.__settings.settings["RECODE_STRINGS"] = bool(
self.__recodeStrings.isChecked())
self.__settings.settings["CAN_SPLIT_STRINGS"] = bool(
self.__splitStrings.isChecked())
self.__settings.settings["KEEP_UNASSIGNED_CONSTANTS"] = bool(
self.__keepUnassignedConst.isChecked())
self.__settings.settings["PARENTHESIZE_TUPLE_DISPLAY"] = bool(
self.__parenTuple.isChecked())
self.__settings.settings["JAVA_STYLE_LIST_DEDENT"] = bool(
self.__javaListDedent.isChecked())
if self.__use1RButton.isChecked():
self.__settings.settings["SINGLE_QUOTED_STRINGS"] = True
self.__settings.settings["DOUBLE_QUOTED_STRINGS"] = False
elif self.__use2RButton.isChecked():
self.__settings.settings["SINGLE_QUOTED_STRINGS"] = False
self.__settings.settings["DOUBLE_QUOTED_STRINGS"] = True
else:
self.__settings.settings["SINGLE_QUOTED_STRINGS"] = False
self.__settings.settings["DOUBLE_QUOTED_STRINGS"] = False
try:
self.__settings.saveToFile(self.__path)
except:
logging.error( "Error saving PythonTidy settings into " + \
self.__path + ". Ignor and continue." )
self.accept()
return
def __validate(self, text=None):
" Validates input "
allValid = True
val = self.__colsEdit.text()
try:
intVal = int(val)
if intVal <= 0:
allValid = False
self.__setValid(self.__colsEdit, False)
else:
self.__setValid(self.__colsEdit, True)
except:
allValid = False
self.__setValid(self.__colsEdit, False)
if '=' not in self.__assignmentEdit.text():
allValid = False
self.__setValid(self.__assignmentEdit, False)
else:
self.__setValid(self.__assignmentEdit, True)
if '=' not in self.__funcAssignEdit.text():
allValid = False
self.__setValid(self.__funcAssignEdit, False)
else:
self.__setValid(self.__funcAssignEdit, True)
if ':' not in self.__dictSepEdit.text():
allValid = False
self.__setValid(self.__dictSepEdit, False)
else:
self.__setValid(self.__dictSepEdit, True)
if ':' not in self.__sliceSepEdit.text():
allValid = False
self.__setValid(self.__sliceSepEdit, False)
else:
self.__setValid(self.__sliceSepEdit, True)
val = self.__inEdit.text()
if val.strip() != "" and not val.strip().startswith('#!'):
allValid = False
self.__setValid(self.__inEdit, False)
else:
self.__setValid(self.__inEdit, True)
val = self.__srcCodingEdit.text()
if val.strip() != "" and not val.strip().startswith('#'):
allValid = False
self.__setValid(self.__srcCodingEdit, False)
else:
self.__setValid(self.__srcCodingEdit, True)
self.__tidyButton.setEnabled(allValid)
return
class Window(QWidget):
'''
This is the GUI object. Any gui-related operations happen here
'''
def __init__(self):
self.internal_net = ''
self.external_net = ''
self.unconfigured = True
self.searchfound = False
self.foundunenc = False
self.foundunprot = False
self.foundprot = False
if os.path.exists('tapioca.cfg'):
with open('tapioca.cfg') as f:
configlines = f.readlines()
for line in configlines:
if line.startswith('external_net'):
line = line.rstrip()
self.external_net = line.split('=')[1]
if line.startswith('internal_net'):
line = line.rstrip()
self.internal_net = line.split('=')[1]
if self.external_net != 'WAN_DEVICE' and self.internal_net != 'LAN_DEVICE':
self.unconfigured = False
QWidget.__init__(self)
self.setWindowTitle('Tapioca')
app_icon = QIcon()
app_icon.addFile('cert.ico', QtCore.QSize(32, 32))
self.setWindowIcon(app_icon)
self.lblupstream = QLabel('<b>Upstream-network device:</b>')
self.lblupstreamval = QLabel(self.external_net)
self.lblupstreamval.setToolTip(
'Ethernet device used for internet connectivity')
self.lbllocal = QLabel('<b>Locally-provided-network device:</b>')
self.lbllocalval = QLabel(self.internal_net)
self.lbllocalval.setToolTip(
'Ethernet device used for connectivity to device under test')
self.spacer = QLabel()
self.net_status = QLabel()
self.appname = ''
self.lblapp = QLabel('<b>Capture session:</b>')
self.cboapp = QComboBox()
self.cboapp.setEditable(True)
self.cboapp.setToolTip(
'Select an existing session from the dropdown or type a new one')
#self.leapp = QLineEdit()
self.btntcpdump = QPushButton('Capture - All traffic with tcpdump')
self.btntcpdump.setToolTip(
'Launch tcpdump to capture all traffic without interception')
self.lbltcpdump = QLabel()
self.chkrewrite = QCheckBox('Modify mitmproxy traffic')
self.chkrewrite.setToolTip(
'Edit mitmproxy rules for traffic modification.\nOnly affects "Verify SSL Validation" and "Full HTTPS inspection" tests'
)
self.btnrewrite = QPushButton('Edit modification rules')
self.btnrewrite.setToolTip('Modify mitmproxy traffic rewriting rules')
self.btnrewrite.setEnabled(False)
self.btnssl = QPushButton('Capture - Verify SSL validation')
self.btnssl.setToolTip(
'Launch mitmproxy to capture HTTP(S) traffic with an invalid certificate'
)
self.lblssltest = QLabel()
self.btnfull = QPushButton('Capture - Full HTTPS inspection')
self.btnfull.setToolTip(
'Launch mitmproxy to capture HTTP(S) traffic with an installed certificate'
)
self.lblfull = QLabel()
self.btnstop = QPushButton('Stop current capture')
self.allreports = QPushButton('Generate reports')
self.allreports.setToolTip(
'Generate reports for all tests performed for this capture')
self.lblsslresults = QLabel('<b>SSL test results:</b>')
self.lblsslresultsval = QLabel()
self.lblcryptoresults = QLabel('<b>Crypto test results:</b>')
self.lblcryptoresultsval = QLabel()
self.lblnetresults = QLabel(
'<b>Network connectivity test results:</b>')
self.lblnetresultsval = QLabel()
self.lblsearch = QLabel('<b>Search term:</b>')
self.searchbox = QLineEdit()
self.searchbox.setToolTip(
'Case-insensitive perl-compatible regex pattern')
self.chksearch = QCheckBox('Search multiple encodings')
self.chksearch.setToolTip(
'Search for base64, md5, and sha1 encodings as well - INCOMPATIBLE with Regex'
)
self.btnsearch = QPushButton('Search')
self.btnsearch.setToolTip(
'Search for term (perl-compatible regex) in all captures')
self.lblsearchresults = QLabel()
self.lblsearchfound = QLabel()
self.lblsearchunprotfound = QLabel()
self.lblsearchprotfound = QLabel()
#layout = QVBoxLayout(self)
layout = QFormLayout(self)
layout.addRow(self.lblupstream, self.lblupstreamval)
layout.addRow(self.lbllocal, self.lbllocalval)
layout.addRow(self.net_status)
#layout.addRow(self.lblapp, self.leapp)
layout.addRow(self.lblapp, self.cboapp)
layout.addRow(self.btntcpdump, self.lbltcpdump)
layout.addRow(self.btnssl, self.lblssltest)
layout.addRow(self.btnfull, self.lblfull)
layout.addRow(self.chkrewrite, self.btnrewrite)
layout.addRow(self.btnstop)
layout.addRow(self.spacer)
layout.addRow(self.spacer)
layout.addRow(self.lblsearch, self.searchbox)
layout.addRow(self.chksearch, self.btnsearch)
layout.addRow(self.lblsearchresults, self.lblsearchfound)
layout.addRow(self.spacer, self.lblsearchunprotfound)
layout.addRow(self.spacer, self.lblsearchprotfound)
layout.addRow(self.allreports)
layout.addRow(self.lblsslresults, self.lblsslresultsval)
layout.addRow(self.lblcryptoresults, self.lblcryptoresultsval)
layout.addRow(self.lblnetresults, self.lblnetresultsval)
self.setFixedSize(480, 420)
self.center()
if self.unconfigured:
self.net_status.setText(
'<font color="red"><b>Please enable soft AP or configure networks</b></font>'
)
self.disabletests()
self.disablestop()
if not self.checklan():
self.net_status.setText(
'<font color="red"><b>LAN device %s not found</b></font>' %
self.internal_net)
self.disabletests()
self.disablestop()
def checklan(self):
landevice = subprocess.check_output([
"nmcli device status | grep %s | awk '{print $1}'" %
self.internal_net
],
shell=True)
if not landevice:
return False
else:
return True
@QtCore.pyqtSlot()
def clearsearchresults(self):
#print('Clearing search results...')
self.lblsearchresults.setText('')
self.lblsearchfound.setText('')
self.lblsearchfound.setCursor(QCursor())
self.lblsearchfound.setToolTip('')
self.lblsearchunprotfound.setText('')
self.lblsearchunprotfound.setCursor(QCursor())
self.lblsearchunprotfound.setToolTip('')
self.lblsearchprotfound.setText('')
self.lblsearchprotfound.setCursor(QCursor())
self.lblsearchprotfound.setToolTip('')
@QtCore.pyqtSlot()
def updatesearchresults(self):
#print('Updating GUI search results...')
#print('searchfound: %s' % self.searchfound)
searchresults = ''
if self.searchfound:
self.lblsearchresults.setText('<b>Matches:</b>')
if self.foundunenc:
searchresults = 'Unencrypted traffic'
self.lblsearchfound.setText(searchresults)
self.lblsearchfound.setCursor(
QCursor(QtCore.Qt.PointingHandCursor))
self.lblsearchfound.setToolTip('Open raw tcpdump capture')
else:
self.lblsearchfound.setText('')
self.lblsearchfound.setCursor(QCursor())
self.lblsearchfound.setToolTip('')
if self.foundunprot:
if searchresults != '':
searchresults = searchresults + ', '
searchresults = 'Unprotected HTTPS traffic'
self.lblsearchunprotfound.setText(searchresults)
self.lblsearchunprotfound.setCursor(
QCursor(QtCore.Qt.PointingHandCursor))
self.lblsearchunprotfound.setToolTip(
'Open SSL test mitmproxy capture')
else:
self.lblsearchunprotfound.setText('')
self.lblsearchunprotfound.setCursor(QCursor())
self.lblsearchunprotfound.setToolTip('')
if self.foundprot:
if searchresults != '':
searchresults = searchresults + ', '
searchresults = 'Protected HTTPS traffic'
self.lblsearchprotfound.setText(searchresults)
self.lblsearchprotfound.setCursor(
QCursor(QtCore.Qt.PointingHandCursor))
self.lblsearchprotfound.setToolTip(
'Open full HTTPS inspection mitmproxy capture')
else:
self.lblsearchprotfound.setText('')
self.lblsearchprotfound.setCursor(QCursor())
self.lblsearchprotfound.setToolTip('')
else:
self.lblsearchresults.setText('<b>No match</b>')
self._clearsearchresult()
# self.lblsearchfound.setText(searchresults)
def _clearsearchresult(self):
self.lblsearchprotfound.setText('')
self.lblsearchprotfound.setCursor(QCursor())
self.lblsearchprotfound.setToolTip('')
self.lblsearchunprotfound.setText('')
self.lblsearchunprotfound.setCursor(QCursor())
self.lblsearchunprotfound.setToolTip('')
self.lblsearchfound.setText('')
self.lblsearchfound.setCursor(QCursor())
self.lblsearchfound.setToolTip('')
@QtCore.pyqtSlot(str)
def check_addapp(self, appname):
#print('Checking if %s is already there...') % appname
appindex = self.cboapp.findText(appname)
if appindex == -1:
# Current app hasn't been added to combobox
#print('Adding app %s' % appname)
self.cboapp.addItem(appname)
@QtCore.pyqtSlot()
def disabletests(self):
#print('Disabling test buttons')
self.btntcpdump.setEnabled(False)
self.btnssl.setEnabled(False)
self.btnfull.setEnabled(False)
@QtCore.pyqtSlot()
def disablestop(self):
#print('Disabling test buttons')
self.btnstop.setEnabled(False)
@QtCore.pyqtSlot()
def enabletests(self):
#print('Enabling test buttons again!')
self.btntcpdump.setEnabled(True)
self.btnssl.setEnabled(True)
self.btnfull.setEnabled(True)
@QtCore.pyqtSlot()
def center(self):
frameGm = self.frameGeometry()
screen = QApplication.desktop().screenNumber(
QApplication.desktop().cursor().pos())
centerPoint = QApplication.desktop().screenGeometry(screen).center()
frameGm.moveCenter(centerPoint)
self.move(frameGm.topLeft())
@QtCore.pyqtSlot(str)
def getapp(self, appname):
text, ok = QInputDialog.getText(self, 'Tapioca',
'Enter capture session name:',
QLineEdit.Normal, appname)
appname = re.sub(r'\W+', '', str(text)).lower()
if ok:
appindex = self.cboapp.findText(appname)
if appindex == -1:
# New app
# Create and select item in combobox
self.cboapp.addItem(appname)
self.cboapp.setCurrentIndex(self.cboapp.findText(appname))
else:
# existing app
# Just select item in combobox
self.cboapp.setCurrentIndex(self.cboapp.findText(appname))
return appname
def _reset_resultslinks(self):
self.lblsslresultsval.setText('')
self.lblsslresultsval.setToolTip('')
self.lblsslresultsval.setCursor(QCursor())
self.lblcryptoresultsval.setText('')
self.lblcryptoresultsval.setToolTip('')
self.lblcryptoresultsval.setCursor(QCursor())
self.lblnetresultsval.setText('')
self.lblnetresultsval.setToolTip('')
self.lblnetresultsval.setCursor(QCursor())
@QtCore.pyqtSlot(str)
def updateStatus(self, test):
'''
GUI module updateStatus
'''
failures = {}
#print('--- gui object updateStatus. test: %s' % test)
test = str(test)
if test.endswith('COMPLETE') or test.endswith('ERROR'):
testname, status = str(test).split()
#print('testname: %s' % testname)
if testname == 'report':
#print('*** %s Report done ***' % self.appname)
failures = allreports.getfailures(self.appname)
self._reset_resultslinks()
#print('=== failures: %s ===' % failures)
for test in failures:
#print('- Checking %s' % test)
if test == 'ssltest':
self.lblsslresultsval.setToolTip(
'Open SSL test report')
self.lblsslresultsval.setCursor(
QCursor(QtCore.Qt.PointingHandCursor))
if failures[test] is True:
#print('failed ssl!')
self.lblsslresultsval.setText(
'<font color="red">FAILED</font>')
elif failures[test] is False:
#print('passed ssl')
self.lblsslresultsval.setText(
'<font color="green">PASSED</font>')
elif test == 'crypto':
self.lblcryptoresultsval.setToolTip(
'Open SSL test report')
self.lblcryptoresultsval.setCursor(
QCursor(QtCore.Qt.PointingHandCursor))
if failures[test] is True:
self.lblcryptoresultsval.setText(
'<font color="red">FAILED</font>')
elif failures[test] is False:
self.lblcryptoresultsval.setText(
'<font color="green">PASSED</font>')
elif test == 'net':
self.lblnetresultsval.setToolTip(
'Open SSL test report')
self.lblnetresultsval.setCursor(
QCursor(QtCore.Qt.PointingHandCursor))
if test in failures:
self.lblnetresultsval.setText('VIEW')
else:
self.lblnetresultsval.setText('')
elif testname == 'search':
# Let main app object handle this to allow for value passing
pass
# self.lblsearchfound.setText(status)
#print('*** Search complete! ***')
elif testname == 'openssltest' or testname == 'openfulltest' \
or testname == 'opentcpdump' or testname == 'opensslreport' \
or testname == 'opencryptoreport' or testname == \
'opennetreport':
# NO need to enable test buttons or so anything else
pass
else:
# Test capture complete
# Updating individual test status
#print('gui.updatestatus() re-enabling test buttons')
self.enabletests()
#print('*** GUI updateStatus : %s' % test)
if status == 'COMPLETE':
# A test has completed. Add appname to combobox
#print('Finished a test... adding to combobox')
self.check_addapp(self.appname)
if testname == 'tcpdump':
self.lbltcpdump.setText(status)
if status == 'COMPLETE':
self.lbltcpdump.setToolTip(
'Open tcpdump capture for %s' % self.appname)
self.lbltcpdump.setCursor(
QCursor(QtCore.Qt.PointingHandCursor))
else:
self.lbltcpdump.setToolTip('')
self.lbltcpdump.setCursor(QCursor())
elif testname == 'ssltest':
self.lblssltest.setText(status)
if status == 'COMPLETE':
self.lblssltest.setToolTip(
'Open mitmproxy SSL test capture for %s' %
self.appname)
self.lblssltest.setCursor(
QCursor(QtCore.Qt.PointingHandCursor))
else:
self.lblssltest.setToolTip('')
self.lblssltest.setCursor(QCursor())
elif testname == 'full':
self.lblfull.setText(status)
if status == 'COMPLETE':
self.lblfull.setToolTip(
'Open mitmproxy full inspection capture for %s' %
self.appname)
self.lblfull.setCursor(
QCursor(QtCore.Qt.PointingHandCursor))
else:
self.lblfull.setToolTip('')
self.lblfull.setCursor(QCursor())
