def createEditor(self, parent, option, index):
"""
Create the editor
@param parent:
@type parent:
@param option:
@type option:
@param index:
@type index:
@return:
@rtype:
"""
# get running probe from context
self.items_ = ServerProbes.instance().getRunningProbes()
self.items_ = sorted(self.items_) # sort agents list, new in v12.2
# load probs in combobox
value = self.getValue(index)
if index.column() == self.col_:
editor = QComboBox(parent)
editor.activated.connect(self.onItemActivated)
editor.addItem(value)
editor.insertSeparator(1)
editor.addItems(self.items_)
return editor
return QItemDelegate.createEditor(self, parent, option, index)
def createEditor(self, parent, option, index):
"""
Create the editor
@param parent:
@type parent:
@param option:
@type option:
@param index:
@type index:
@return:
@rtype:
"""
value = self.getValue(index)
if index.column() == COL_VALUE:
editor = QComboBox(parent)
editor.activated.connect(self.onItemActivated)
editor.addItem(value)
editor.insertSeparator(1)
# get running agents from context
runningAgents = ServerAgents.instance().getRunningAgents()
runningAgents = sorted(
runningAgents) # sort agents list, new in v12.2
for i in xrange(len(runningAgents)):
if len(runningAgents[i]) == 0:
editor.insertSeparator(i + 2)
else:
editor.addItem(runningAgents[i])
editor.insertSeparator(len(runningAgents) + 2)
# add alias
params = []
for pr in self.parent.model.getData():
params.append(pr['name'])
editor.addItems(params)
return editor
return QItemDelegate.createEditor(self, parent, option, index)
class OWFile(OWWidget):
settingsList = ["selected_file", "recent_files", "show_advanced",
"create_new_on"]
contextHandlers = {"": FileNameContextHandler()}
def __init__(self, parent=None, signalManager=None,
title="CSV File Import"):
OWWidget.__init__(self, parent, signalManager, title,
wantMainArea=False, noReport=True)
self.symbol_DC = ""
self.symbol_DK = ""
#: List of recent opened files.
self.recent_files = []
#: Current selected file name
self.selected_file = None
#: Variable reuse flag
self.create_new_on = 2
#: Display advanced var reuse options
self.show_advanced = False
self.loadSettings()
self.recent_files = filter(os.path.exists, self.recent_files)
self._loader = None
self._invalidated = False
self._datareport = None
layout = QHBoxLayout()
OWGUI.widgetBox(self.controlArea, "File", orientation=layout)
icons = standard_icons(self)
self.recent_combo = QComboBox(
self, objectName="recent_combo",
toolTip="Recent files.",
activated=self.activate_recent
)
cb_append_file_list(self.recent_combo, self.recent_files)
self.recent_combo.insertSeparator(self.recent_combo.count())
self.recent_combo.addItem(u"Browse documentation data sets…")
self.browse_button = QPushButton(
u"…",
icon=icons.dir_open_icon, toolTip="Browse filesystem",
clicked=self.browse
)
self.reload_button = QPushButton(
"Reload", icon=icons.reload_icon,
toolTip="Reload the selected file", clicked=self.reload,
default=True
)
layout.addWidget(self.recent_combo, 2)
layout.addWidget(self.browse_button)
layout.addWidget(self.reload_button)
###########
# Info text
###########
box = OWGUI.widgetBox(self.controlArea, "Info", addSpace=True)
self.infoa = OWGUI.widgetLabel(box, "No data loaded.")
self.infob = OWGUI.widgetLabel(box, " ")
self.warnings = OWGUI.widgetLabel(box, " ")
# Set word wrap so long warnings won't expand the widget
self.warnings.setWordWrap(True)
self.warnings.setSizePolicy(QSizePolicy.Ignored,
QSizePolicy.MinimumExpanding)
advanced = QGroupBox(
"Advanced Settings", checkable=True, checked=self.show_advanced
)
advanced.setLayout(QVBoxLayout())
def set_group_visible(groupbox, state):
layout = groupbox.layout()
for i in range(layout.count()):
item = layout.itemAt(i)
widget = item.widget()
if widget is not None:
widget.setVisible(state)
groupbox.setFlat(not state)
def toogle_advanced(state):
self.show_advanced = state
set_group_visible(advanced, state)
self.layout().activate()
QApplication.instance().processEvents()
QTimer.singleShot(0, self.adjustSize)
advanced.toggled.connect(toogle_advanced)
self.taboptions = QWidget()
self.taboptions.setLayout(QVBoxLayout())
box = QGroupBox("Missing Value Symbols", flat=True)
form = QFormLayout(fieldGrowthPolicy=QFormLayout.AllNonFixedFieldsGrow)
form.addRow(
"Don't care:",
OWGUI.lineEdit(None, self, "symbol_DC",
tooltip="Default values: '~' or '*'"))
form.addRow(
"Don't know:",
OWGUI.lineEdit(None, self, "symbol_DK",
tooltip="Default values: empty fields (space), "
"'?' or 'NA'"))
box.setLayout(form)
advanced.layout().addWidget(box)
rb = OWGUI.radioButtonsInBox(
advanced, self, "create_new_on",
box="New Attributes",
callback=self._invalidate,
label=u"Create a new attribute when existing attribute(s) …",
btnLabels=[u"Have mismatching order of values",
u"Have no common values with the new (recommended)",
u"Miss some values of the new attribute",
u"… Always create a new attribute"]
)
rb.setFlat(True)
self.controlArea.layout().addWidget(advanced)
button_box = QDialogButtonBox(orientation=Qt.Horizontal)
self.import_options_button = QPushButton(
u"Import Options…", enabled=False
)
self.import_options_button.pressed.connect(self._activate_import_dialog)
button_box.addButton(
self.import_options_button, QDialogButtonBox.ActionRole
)
button_box.addButton(
QPushButton("&Report", pressed=self.reportAndFinish),
QDialogButtonBox.ActionRole
)
self.controlArea.layout().addWidget(button_box)
OWGUI.rubber(self.controlArea)
set_group_visible(advanced, self.show_advanced)
if self.recent_files and self.recent_files[0] == self.selected_file:
QTimer.singleShot(
0, lambda: self.activate_recent(0)
)
else:
self.selected_file = None
self.recent_combo.setCurrentIndex(-1)
@Slot(int)
def activate_recent(self, index):
"""Activate an item from the recent list."""
if 0 <= index < len(self.recent_files):
recent = self.recent_files[index]
self.set_selected_file(recent)
elif index == len(self.recent_files) + 1:
status = self.browse(Orange.utils.environ.dataset_install_dir)
if status == QDialog.Rejected:
self.recent_combo.setCurrentIndex(
min(0, len(self.recent_files) - 1)
)
else:
self.recent_combo.setCurrentIndex(-1)
@Slot()
def browse(self, startdir=None):
"""
Open a file dialog and select a user specified file.
"""
if startdir is None:
if self.selected_file:
startdir = os.path.dirname(self.selected_file)
else:
startdir = unicode(
QDesktopServices.storageLocation(
QDesktopServices.DocumentsLocation)
)
def format_spec(format):
ext_pattern = ", ".join(map("*{}".format, format.extensions))
return "{} ({})".format(format.name, ext_pattern)
formats = [format_spec(format) for format in FILEFORMATS]
filters = ";;".join(formats + ["All files (*.*)"])
path, selected_filter = QFileDialog.getOpenFileNameAndFilter(
self, "Open Data File", startdir, filters
)
if path:
path = unicode(path)
if selected_filter in formats:
filter_idx = formats.index(str(selected_filter))
fformat = FILEFORMATS[filter_idx]
loader = DEFAULT_ACTIONS[filter_idx]
if fformat.extensions in ([".csv"], [".tsv"]):
loader = loader._replace(
params=loader_for_path(path).params)
else:
loader = None
self.set_selected_file(path, loader=loader)
return QDialog.Accepted
else:
return QDialog.Rejected
@Slot()
def reload(self):
"""Reload the current selected file."""
if self.selected_file:
self.send_data()
def _activate_import_dialog(self):
assert self.selected_file is not None
dlg = CSVImportDialog(
self, windowTitle="Import Options",
)
dlg.setAttribute(Qt.WA_DeleteOnClose)
dlg.setWindowFlags(Qt.Sheet)
loader = self._loader
dlg.set_options(loader.params)
dlg.set_path(self.selected_file)
def update():
self._loader = loader._replace(params=dlg.options())
self._invalidate()
dlg.accepted.connect(update)
dlg.open()
def set_selected_file(self, filename, loader=None):
"""Set the current filename path to be loaded."""
self.closeContext("")
self.selected_file = filename
self._loader = None
self._add_recent(filename)
self.warning(1)
self.openContext("", filename)
if loader is not None and self._loader is not None and \
self._loader.format == loader.format:
loader = self._loader
if loader is None:
loader = self._loader
if loader is None:
loader = loader_for_path(filename)
self.set_loader(loader)
def _add_recent(self, filename):
"""Add filename to the list of recent files."""
index_to_remove = None
if filename in self.recent_files:
index_to_remove = self.recent_files.index(filename)
elif len(self.recent_files) >= 20:
# keep maximum of 20 files in the list.
index_to_remove = len(self.recent_files) - 1
cb_insert_file_list(self.recent_combo, 0, [filename])
self.recent_files.insert(0, filename)
if index_to_remove is not None:
self.recent_combo.removeItem(index_to_remove + 1)
self.recent_files.pop(index_to_remove + 1)
self.recent_combo.setCurrentIndex(0)
def set_loader(self, loader):
if loader is None:
loader = DEFAULT_ACTIONS[0]
self._loader = loader
self.import_options_button.setEnabled(
isinstance(loader.params, CSV)
)
self._invalidate()
def _invalidate(self):
if not self._invalidated:
self._invalidated = True
QApplication.postEvent(self, QEvent(QEvent.User))
def customEvent(self, event):
if self._invalidated:
self._invalidated = False
self.send_data()
def send_data(self):
self.error(0)
loader = self._loader
if "DK" in loader.params._fields and self.symbol_DK:
loader = loader._replace(
params=loader.params._replace(
DK=str(self.symbol_DK),
DC=str(self.symbol_DC))
)
try:
data = load_table(self.selected_file, loader,
create_new_on=3 - self.create_new_on)
except Exception as err:
self.error(str(err))
self.infoa.setText('Data was not loaded due to an error.')
self.infob.setText('Error:')
self.warnings.setText(str(err))
data = None
else:
self._update_status_messages(data)
if data is not None:
add_origin(data, self.selected_file)
basename = os.path.basename(self.selected_file)
data.name, _ = os.path.splitext(basename)
self._datareport = self.prepareDataReport(data)
else:
self._datareport = None
self.send("Data", data)
def _update_status_messages(self, data):
if data is None:
self.infoa.setText("No data loaded.")
self.infob.setText("")
self.warnings.setText("")
return
def pluralize(seq):
return "s" if len(seq) != 1 else ""
summary = ("{n_instances} data instance{plural_1}, "
"{n_features} feature{plural_2}, "
"{n_meta} meta{plural_3}").format(
n_instances=len(data), plural_1=pluralize(data),
n_features=len(data.domain.attributes),
plural_2=pluralize(data.domain.attributes),
n_meta=len(data.domain.getmetas()),
plural_3=pluralize(data.domain.getmetas()))
self.infoa.setText(summary)
cl = data.domain.class_var
if cl is not None:
if isinstance(cl, Orange.feature.Continuous):
self.infob.setText('Regression; Numerical class.')
elif isinstance(cl, Orange.feature.Discrete):
self.infob.setText(
'Classification; Discrete class with %d value%s.' %
(len(cl.values), 's' if len(cl.values) > 1 else '')
)
else:
self.infob.setText("Class is neither discrete nor continuous.")
elif data.domain.class_vars:
self.infob.setText("Multiple class variables")
else:
self.infob.setText("Data has no dependent variable.")
self.warnings.setText(
feature_load_status_report(data, self.create_new_on))
def sendReport(self):
if self._datareport:
formatname = self._loader.format
self.reportSettings(
"File", [("File name", self.selected_file),
("Format", formatname)])
self.reportData(self._datareport)
def settingsFromWidgetCallback(self, handler, context):
context.filename = self.selected_file or ""
context.loader = self._loader
context.symbolDC, context.symbolDK = self.symbol_DC, self.symbol_DK
def settingsToWidgetCallback(self, handler, context):
self.symbol_DC, self.symbol_DK = context.symbolDC, context.symbolDK
self._loader = getattr(context, "loader", None)
def setSettings(self, settings):
if settings.get(_SETTINGS_VERSION_KEY, None) is None:
# import old File widget's settings
mapping = [
("recentFiles", "recent_files"),
("createNewOn", "create_new_on"),
("showAdvanced", "show_advanced")
]
if all(old in settings for old, _ in mapping) and \
not any(new in settings for _, new in mapping):
settings = settings.copy()
for old, new in mapping:
settings[new] = settings[old]
del settings[old]
# settings[_SETTINGS_VERSION_KEY] = self.settingsDataVersion
if len(settings["recent_files"]):
settings["selected_file"] = settings["recent_files"][0]
super(OWFile, self).setSettings(settings)
class CSVOptionsWidget(QWidget):
_PresetDelimiters = [
("Comma", ","),
("Tab", "\t"),
("Semicolon", ";"),
("Space", " "),
]
format_changed = Signal()
def __init__(self, parent=None, **kwargs):
self._delimiter_idx = 0
self._delimiter_custom = "|"
self._delimiter = ","
self._quotechar = "'"
self._escapechar = "\\"
self._doublequote = True
self._skipinitialspace = False
super(QWidget, self).__init__(parent, **kwargs)
# Dialect options
form = QFormLayout()
self.delimiter_cb = QComboBox()
self.delimiter_cb.addItems(
[name for name, _ in self._PresetDelimiters]
)
self.delimiter_cb.insertSeparator(self.delimiter_cb.count())
self.delimiter_cb.addItem("Other")
self.delimiter_cb.setCurrentIndex(self._delimiter_idx)
self.delimiter_cb.activated.connect(self._on_delimiter_idx_changed)
validator = QRegExpValidator(QRegExp("."))
self.delimiteredit = LineEdit(
self._delimiter_custom,
enabled=False,
minimumContentsLength=2
)
self.delimiteredit.setValidator(validator)
self.delimiteredit.editingFinished.connect(self._on_delimiter_changed)
delimlayout = QHBoxLayout()
delimlayout.setContentsMargins(0, 0, 0, 0)
delimlayout.addWidget(self.delimiter_cb)
delimlayout.addWidget(self.delimiteredit)
self.quoteedit = LineEdit(self._quotechar, minimumContentsLength=2)
self.quoteedit.setValidator(validator)
self.quoteedit.editingFinished.connect(self._on_quotechar_changed)
self.escapeedit = LineEdit(self._escapechar, minimumContentsLength=2)
self.escapeedit.setValidator(validator)
self.escapeedit.editingFinished.connect(self._on_escapechar_changed)
# self.skipinitialspace_cb = QCheckBox(
# checked=self._skipinitialspace
# )
form.addRow("Cell delimiter", delimlayout)
form.addRow("Quote character", self.quoteedit)
form.addRow("Escape character", self.escapeedit)
form.addRow(QFrame(self, frameShape=QFrame.HLine))
# File format option
self.missingedit = QLineEdit()
self.missingedit.editingFinished.connect(self.format_changed)
form.addRow("Missing values", self.missingedit)
self.header_format_cb = QComboBox()
self.header_format_cb.addItems(
["No header", "Plain header", "Orange header",
"Orange simplified header"]
)
self.header_format_cb.currentIndexChanged.connect(self.format_changed)
form.addRow("Header", self.header_format_cb)
self.setLayout(form)
self.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Minimum)
def dialect(self):
"""
Return the current state as a Dialect instance.
"""
if self._delimiter_idx >= len(self._PresetDelimiters):
delimiter = self._delimiter_custom
else:
_, delimiter = self._PresetDelimiters[self._delimiter_idx]
quotechar = str(self.quoteedit.text()) or ""
escapechar = str(self.escapeedit.text()) or None
skipinitialspace = True
return Dialect(delimiter, quotechar, escapechar,
doublequote=True, skipinitialspace=skipinitialspace)
def set_dialect(self, dialect):
"""
Set the current state to match dialect instance.
"""
delimiter = dialect.delimiter
try:
index = [d for _, d in self._PresetDelimiters].index(delimiter)
except ValueError:
index = len(self._PresetDelimiters) + 1
self._delimiter_idx = index
self._delimiter_custom = delimiter
self._quotechar = dialect.quotechar
self._escapechar = dialect.escapechar
self._skipinitialspace = dialect.skipinitialspace
self.delimiter_cb.setCurrentIndex(index)
self.delimiteredit.setText(delimiter)
self.quoteedit.setText(dialect.quotechar or '"')
self.escapeedit.setText(dialect.escapechar or "")
# self.skipinitialspace_cb.setChecked(dialect.skipinitialspace)
def set_header_format(self, header_format):
"""Set the current selected header format."""
self._header_format = header_format
self.header_format_cb.setCurrentIndex(header_format)
def header_format(self):
return self.header_format_cb.currentIndex()
def set_missing_values(self, missing):
self.missingedit.setText(missing)
def missing_values(self):
return str(self.missingedit.text())
def _on_delimiter_idx_changed(self, index):
if index < len(self._PresetDelimiters):
self.delimiteredit.setText(self._PresetDelimiters[index][1])
else:
self.delimiteredit.setText(self._delimiter_custom)
self.delimiteredit.setEnabled(index >= len(self._PresetDelimiters))
self._delimiter_idx = index
self.format_changed.emit()
def _on_delimiter_changed(self):
self._delimiter_custom = str(self.delimiteredit.text())
self.format_changed.emit()
def _on_quotechar_changed(self):
self._quotechar = str(self.quoteedit.text())
self.format_changed.emit()
def _on_escapechar_changed(self):
self._escapechar = str(self.escapeedit.text())
self.format_changed.emit()
def _on_skipspace_changed(self, skipinitialspace):
self._skipinitialspace = skipinitialspace
self.format_changed.emit()
class OWFile(OWWidget):
settingsList = [
"selected_file", "recent_files", "show_advanced", "create_new_on"
]
contextHandlers = {"": FileNameContextHandler()}
def __init__(self,
parent=None,
signalManager=None,
title="CSV File Import"):
OWWidget.__init__(self,
parent,
signalManager,
title,
wantMainArea=False,
noReport=True)
self.symbol_DC = ""
self.symbol_DK = ""
#: List of recent opened files.
self.recent_files = []
#: Current selected file name
self.selected_file = None
#: Variable reuse flag
self.create_new_on = 2
#: Display advanced var reuse options
self.show_advanced = False
self.loadSettings()
self.recent_files = filter(os.path.exists, self.recent_files)
self._loader = None
self._invalidated = False
self._datareport = None
layout = QHBoxLayout()
OWGUI.widgetBox(self.controlArea, "File", orientation=layout)
icons = standard_icons(self)
self.recent_combo = QComboBox(self,
objectName="recent_combo",
toolTip="Recent files.",
activated=self.activate_recent)
cb_append_file_list(self.recent_combo, self.recent_files)
self.recent_combo.insertSeparator(self.recent_combo.count())
self.recent_combo.addItem(u"Browse documentation data sets…")
self.browse_button = QPushButton(u"…",
icon=icons.dir_open_icon,
toolTip="Browse filesystem",
clicked=self.browse)
self.reload_button = QPushButton("Reload",
icon=icons.reload_icon,
toolTip="Reload the selected file",
clicked=self.reload,
default=True)
layout.addWidget(self.recent_combo, 2)
layout.addWidget(self.browse_button)
layout.addWidget(self.reload_button)
###########
# Info text
###########
box = OWGUI.widgetBox(self.controlArea, "Info", addSpace=True)
self.infoa = OWGUI.widgetLabel(box, "No data loaded.")
self.infob = OWGUI.widgetLabel(box, " ")
self.warnings = OWGUI.widgetLabel(box, " ")
# Set word wrap so long warnings won't expand the widget
self.warnings.setWordWrap(True)
self.warnings.setSizePolicy(QSizePolicy.Ignored,
QSizePolicy.MinimumExpanding)
advanced = QGroupBox("Advanced Settings",
checkable=True,
checked=self.show_advanced)
advanced.setLayout(QVBoxLayout())
def set_group_visible(groupbox, state):
layout = groupbox.layout()
for i in range(layout.count()):
item = layout.itemAt(i)
widget = item.widget()
if widget is not None:
widget.setVisible(state)
groupbox.setFlat(not state)
def toogle_advanced(state):
self.show_advanced = state
set_group_visible(advanced, state)
self.layout().activate()
QApplication.instance().processEvents()
QTimer.singleShot(0, self.adjustSize)
advanced.toggled.connect(toogle_advanced)
self.taboptions = QWidget()
self.taboptions.setLayout(QVBoxLayout())
box = QGroupBox("Missing Value Symbols", flat=True)
form = QFormLayout(fieldGrowthPolicy=QFormLayout.AllNonFixedFieldsGrow)
form.addRow(
"Don't care:",
OWGUI.lineEdit(None,
self,
"symbol_DC",
tooltip="Default values: '~' or '*'"))
form.addRow(
"Don't know:",
OWGUI.lineEdit(None,
self,
"symbol_DK",
tooltip="Default values: empty fields (space), "
"'?' or 'NA'"))
box.setLayout(form)
advanced.layout().addWidget(box)
rb = OWGUI.radioButtonsInBox(
advanced,
self,
"create_new_on",
box="New Attributes",
callback=self._invalidate,
label=u"Create a new attribute when existing attribute(s) …",
btnLabels=[
u"Have mismatching order of values",
u"Have no common values with the new (recommended)",
u"Miss some values of the new attribute",
u"… Always create a new attribute"
])
rb.setFlat(True)
self.controlArea.layout().addWidget(advanced)
button_box = QDialogButtonBox(orientation=Qt.Horizontal)
self.import_options_button = QPushButton(u"Import Options…",
enabled=False)
self.import_options_button.pressed.connect(
self._activate_import_dialog)
button_box.addButton(self.import_options_button,
QDialogButtonBox.ActionRole)
button_box.addButton(
QPushButton("&Report", pressed=self.reportAndFinish),
QDialogButtonBox.ActionRole)
self.controlArea.layout().addWidget(button_box)
OWGUI.rubber(self.controlArea)
set_group_visible(advanced, self.show_advanced)
if self.recent_files and self.recent_files[0] == self.selected_file:
QTimer.singleShot(0, lambda: self.activate_recent(0))
else:
self.selected_file = None
self.recent_combo.setCurrentIndex(-1)
@Slot(int)
def activate_recent(self, index):
"""Activate an item from the recent list."""
if 0 <= index < len(self.recent_files):
recent = self.recent_files[index]
self.set_selected_file(recent)
elif index == len(self.recent_files) + 1:
status = self.browse(Orange.utils.environ.dataset_install_dir)
if status == QDialog.Rejected:
self.recent_combo.setCurrentIndex(
min(0,
len(self.recent_files) - 1))
else:
self.recent_combo.setCurrentIndex(-1)
@Slot()
def browse(self, startdir=None):
"""
Open a file dialog and select a user specified file.
"""
if startdir is None:
if self.selected_file:
startdir = os.path.dirname(self.selected_file)
else:
startdir = unicode(
QDesktopServices.storageLocation(
QDesktopServices.DocumentsLocation))
def format_spec(format):
ext_pattern = ", ".join(map("*{}".format, format.extensions))
return "{} ({})".format(format.name, ext_pattern)
formats = [format_spec(format) for format in FILEFORMATS]
filters = ";;".join(formats + ["All files (*.*)"])
path, selected_filter = QFileDialog.getOpenFileNameAndFilter(
self, "Open Data File", startdir, filters)
if path:
path = unicode(path)
if selected_filter in formats:
filter_idx = formats.index(str(selected_filter))
fformat = FILEFORMATS[filter_idx]
loader = DEFAULT_ACTIONS[filter_idx]
if fformat.extensions in ([".csv"], [".tsv"]):
loader = loader._replace(
params=loader_for_path(path).params)
else:
loader = None
self.set_selected_file(path, loader=loader)
return QDialog.Accepted
else:
return QDialog.Rejected
@Slot()
def reload(self):
"""Reload the current selected file."""
if self.selected_file:
self.send_data()
def _activate_import_dialog(self):
assert self.selected_file is not None
dlg = CSVImportDialog(
self,
windowTitle="Import Options",
)
dlg.setAttribute(Qt.WA_DeleteOnClose)
dlg.setWindowFlags(Qt.Sheet)
loader = self._loader
dlg.set_options(loader.params)
dlg.set_path(self.selected_file)
def update():
self._loader = loader._replace(params=dlg.options())
self._invalidate()
dlg.accepted.connect(update)
dlg.open()
def set_selected_file(self, filename, loader=None):
"""Set the current filename path to be loaded."""
self.closeContext("")
self.selected_file = filename
self._loader = None
self._add_recent(filename)
self.warning(1)
self.openContext("", filename)
if loader is not None and self._loader is not None and \
self._loader.format == loader.format:
loader = self._loader
if loader is None:
loader = self._loader
if loader is None:
loader = loader_for_path(filename)
self.set_loader(loader)
def _add_recent(self, filename):
"""Add filename to the list of recent files."""
index_to_remove = None
if filename in self.recent_files:
index_to_remove = self.recent_files.index(filename)
elif len(self.recent_files) >= 20:
# keep maximum of 20 files in the list.
index_to_remove = len(self.recent_files) - 1
cb_insert_file_list(self.recent_combo, 0, [filename])
self.recent_files.insert(0, filename)
if index_to_remove is not None:
self.recent_combo.removeItem(index_to_remove + 1)
self.recent_files.pop(index_to_remove + 1)
self.recent_combo.setCurrentIndex(0)
def set_loader(self, loader):
if loader is None:
loader = DEFAULT_ACTIONS[0]
self._loader = loader
self.import_options_button.setEnabled(isinstance(loader.params, CSV))
self._invalidate()
def _invalidate(self):
if not self._invalidated:
self._invalidated = True
QApplication.postEvent(self, QEvent(QEvent.User))
def customEvent(self, event):
if self._invalidated:
self._invalidated = False
self.send_data()
def send_data(self):
self.error(0)
loader = self._loader
if "DK" in loader.params._fields and self.symbol_DK:
loader = loader._replace(params=loader.params._replace(
DK=str(self.symbol_DK), DC=str(self.symbol_DC)))
try:
data = load_table(self.selected_file,
loader,
create_new_on=3 - self.create_new_on)
except Exception as err:
self.error(str(err))
self.infoa.setText('Data was not loaded due to an error.')
self.infob.setText('Error:')
self.warnings.setText(str(err))
data = None
else:
self._update_status_messages(data)
if data is not None:
add_origin(data, self.selected_file)
basename = os.path.basename(self.selected_file)
data.name, _ = os.path.splitext(basename)
self._datareport = self.prepareDataReport(data)
else:
self._datareport = None
self.send("Data", data)
def _update_status_messages(self, data):
if data is None:
self.infoa.setText("No data loaded.")
self.infob.setText("")
self.warnings.setText("")
return
def pluralize(seq):
return "s" if len(seq) != 1 else ""
summary = ("{n_instances} data instance{plural_1}, "
"{n_features} feature{plural_2}, "
"{n_meta} meta{plural_3}").format(
n_instances=len(data),
plural_1=pluralize(data),
n_features=len(data.domain.attributes),
plural_2=pluralize(data.domain.attributes),
n_meta=len(data.domain.getmetas()),
plural_3=pluralize(data.domain.getmetas()))
self.infoa.setText(summary)
cl = data.domain.class_var
if cl is not None:
if isinstance(cl, Orange.feature.Continuous):
self.infob.setText('Regression; Numerical class.')
elif isinstance(cl, Orange.feature.Discrete):
self.infob.setText(
'Classification; Discrete class with %d value%s.' %
(len(cl.values), 's' if len(cl.values) > 1 else ''))
else:
self.infob.setText("Class is neither discrete nor continuous.")
elif data.domain.class_vars:
self.infob.setText("Multiple class variables")
else:
self.infob.setText("Data has no dependent variable.")
self.warnings.setText(
feature_load_status_report(data, self.create_new_on))
def sendReport(self):
if self._datareport:
formatname = self._loader.format
self.reportSettings("File", [("File name", self.selected_file),
("Format", formatname)])
self.reportData(self._datareport)
def settingsFromWidgetCallback(self, handler, context):
context.filename = self.selected_file or ""
context.loader = self._loader
context.symbolDC, context.symbolDK = self.symbol_DC, self.symbol_DK
def settingsToWidgetCallback(self, handler, context):
self.symbol_DC, self.symbol_DK = context.symbolDC, context.symbolDK
self._loader = getattr(context, "loader", None)
def setSettings(self, settings):
if settings.get(_SETTINGS_VERSION_KEY, None) is None:
# import old File widget's settings
mapping = [("recentFiles", "recent_files"),
("createNewOn", "create_new_on"),
("showAdvanced", "show_advanced")]
if all(old in settings for old, _ in mapping) and \
not any(new in settings for _, new in mapping):
settings = settings.copy()
for old, new in mapping:
settings[new] = settings[old]
del settings[old]
# settings[_SETTINGS_VERSION_KEY] = self.settingsDataVersion
if len(settings["recent_files"]):
settings["selected_file"] = settings["recent_files"][0]
super(OWFile, self).setSettings(settings)
class CSVOptionsWidget(QWidget):
_PresetDelimiters = [
("Comma", ","),
("Tab", "\t"),
("Semicolon", ";"),
("Space", " "),
]
format_changed = Signal()
def __init__(self, parent=None, **kwargs):
self._delimiter_idx = 0
self._delimiter_custom = "|"
self._delimiter = ","
self._quotechar = "'"
self._escapechar = "\\"
self._doublequote = True
self._skipinitialspace = False
super(QWidget, self).__init__(parent, **kwargs)
# Dialect options
form = QFormLayout()
self.delimiter_cb = QComboBox()
self.delimiter_cb.addItems(
[name for name, _ in self._PresetDelimiters])
self.delimiter_cb.insertSeparator(self.delimiter_cb.count())
self.delimiter_cb.addItem("Other")
self.delimiter_cb.setCurrentIndex(self._delimiter_idx)
self.delimiter_cb.activated.connect(self._on_delimiter_idx_changed)
validator = QRegExpValidator(QRegExp("."))
self.delimiteredit = LineEdit(self._delimiter_custom,
enabled=False,
minimumContentsLength=2)
self.delimiteredit.setValidator(validator)
self.delimiteredit.editingFinished.connect(self._on_delimiter_changed)
delimlayout = QHBoxLayout()
delimlayout.setContentsMargins(0, 0, 0, 0)
delimlayout.addWidget(self.delimiter_cb)
delimlayout.addWidget(self.delimiteredit)
self.quoteedit = LineEdit(self._quotechar, minimumContentsLength=2)
self.quoteedit.setValidator(validator)
self.quoteedit.editingFinished.connect(self._on_quotechar_changed)
self.escapeedit = LineEdit(self._escapechar, minimumContentsLength=2)
self.escapeedit.setValidator(validator)
self.escapeedit.editingFinished.connect(self._on_escapechar_changed)
# self.skipinitialspace_cb = QCheckBox(
# checked=self._skipinitialspace
# )
form.addRow("Cell delimiter", delimlayout)
form.addRow("Quote character", self.quoteedit)
form.addRow("Escape character", self.escapeedit)
form.addRow(QFrame(self, frameShape=QFrame.HLine))
# File format option
self.missingedit = QLineEdit()
self.missingedit.editingFinished.connect(self.format_changed)
form.addRow("Missing values", self.missingedit)
self.header_format_cb = QComboBox()
self.header_format_cb.addItems([
"No header", "Plain header", "Orange header",
"Orange simplified header"
])
self.header_format_cb.currentIndexChanged.connect(self.format_changed)
form.addRow("Header", self.header_format_cb)
self.setLayout(form)
self.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Minimum)
def dialect(self):
"""
Return the current state as a Dialect instance.
"""
if self._delimiter_idx >= len(self._PresetDelimiters):
delimiter = self._delimiter_custom
else:
_, delimiter = self._PresetDelimiters[self._delimiter_idx]
quotechar = str(self.quoteedit.text()) or ""
escapechar = str(self.escapeedit.text()) or None
skipinitialspace = True
return Dialect(delimiter,
quotechar,
escapechar,
doublequote=True,
skipinitialspace=skipinitialspace)
def set_dialect(self, dialect):
"""
Set the current state to match dialect instance.
"""
delimiter = dialect.delimiter
try:
index = [d for _, d in self._PresetDelimiters].index(delimiter)
except ValueError:
index = len(self._PresetDelimiters) + 1
self._delimiter_idx = index
self._delimiter_custom = delimiter
self._quotechar = dialect.quotechar
self._escapechar = dialect.escapechar
self._skipinitialspace = dialect.skipinitialspace
self.delimiter_cb.setCurrentIndex(index)
self.delimiteredit.setText(delimiter)
self.quoteedit.setText(dialect.quotechar or '"')
self.escapeedit.setText(dialect.escapechar or "")
# self.skipinitialspace_cb.setChecked(dialect.skipinitialspace)
def set_header_format(self, header_format):
"""Set the current selected header format."""
self._header_format = header_format
self.header_format_cb.setCurrentIndex(header_format)
def header_format(self):
return self.header_format_cb.currentIndex()
def set_missing_values(self, missing):
self.missingedit.setText(missing)
def missing_values(self):
return str(self.missingedit.text())
def _on_delimiter_idx_changed(self, index):
if index < len(self._PresetDelimiters):
self.delimiteredit.setText(self._PresetDelimiters[index][1])
else:
self.delimiteredit.setText(self._delimiter_custom)
self.delimiteredit.setEnabled(index >= len(self._PresetDelimiters))
self._delimiter_idx = index
self.format_changed.emit()
def _on_delimiter_changed(self):
self._delimiter_custom = str(self.delimiteredit.text())
self.format_changed.emit()
def _on_quotechar_changed(self):
self._quotechar = str(self.quoteedit.text())
self.format_changed.emit()
def _on_escapechar_changed(self):
self._escapechar = str(self.escapeedit.text())
self.format_changed.emit()
def _on_skipspace_changed(self, skipinitialspace):
self._skipinitialspace = skipinitialspace
self.format_changed.emit()
class AddAgentDialog(QtHelper.EnhancedQDialog, Logger.ClassLogger):
"""
Add agent dialog
"""
def __init__(self, parent, agentName='AGENT', datasetView=False):
"""
Constructor
@param parent: parent window
@type parent: instance
@param agentName:
@type agentName: string
@param datasetView:
@type datasetView: boolean
"""
super(AddAgentDialog, self).__init__(parent)
self.agentName=agentName
self.parent__ = parent
self.datasetView__ = datasetView
self.createDialog()
self.createConnections()
self.initComboType()
def createDialog (self):
"""
Create dialog
"""
self.labelName = QLabel("Agent Name:")
self.nameEdit = QLineEdit(self.agentName)
nameLayout = QHBoxLayout()
nameLayout.addWidget( self.labelName )
nameLayout.addWidget( self.nameEdit )
self.labelDescr = QLabel("Description:")
self.descrEdit = QTextEdit()
self.labelValue= QLabel("Value:")
self.comboValue = QComboBox()
typeLayout = QHBoxLayout()
typeLayout.addWidget( self.labelValue )
typeLayout.addWidget( self.comboValue )
self.labelType = QLabel("Type:")
self.typeEdit = QLineEdit()
self.typeEdit.setEnabled(False)
type2Layout = QHBoxLayout()
type2Layout.addWidget( self.labelType )
type2Layout.addWidget( self.typeEdit )
self.buttonBox = QDialogButtonBox(self)
self.buttonBox.setStyleSheet( """QDialogButtonBox {
dialogbuttonbox-buttons-have-icons: 1;
dialog-ok-icon: url(:/ok.png);
dialog-cancel-icon: url(:/test-close-black.png);
}""")
self.buttonBox.setStandardButtons(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
mainLayout = QVBoxLayout()
mainLayout.addLayout(nameLayout)
if not self.datasetView__:
mainLayout.addLayout(typeLayout)
mainLayout.addLayout(type2Layout)
mainLayout.addWidget(self.labelDescr)
mainLayout.addWidget(self.descrEdit)
mainLayout.addWidget(self.buttonBox)
self.setLayout(mainLayout)
self.setWindowTitle("Test Config > Add agent")
self.resize(350, 250)
self.center()
def initComboType(self):
"""
Initialize the combobox type with running agents
"""
TYPES_PARAM = ServerAgents.instance().getRunningAgentsComplete()
for i in xrange(len(TYPES_PARAM)):
if len(TYPES_PARAM[i]) == 0:
self.comboValue.insertSeparator(i + 2)
else:
self.comboValue.addItem (TYPES_PARAM[i]['name'])
#self.onAgentChanged(id=0)
def createConnections (self):
"""
Create qt connections
"""
self.buttonBox.accepted.connect(self.onAdd)
self.buttonBox.rejected.connect(self.reject)
self.comboValue.currentIndexChanged.connect(self.onAgentChanged)
def onAgentChanged(self, id):
"""
Called on agent changed on combobox
"""
currentAgent = self.comboValue.currentText()
currentAgent = unicode(currentAgent)
currentAgentType = ''
for agt in ServerAgents.instance().getRunningAgentsComplete():
if unicode(agt['name']) == currentAgent:
currentAgentType = unicode(agt['type'].lower())
break
self.typeEdit.setText(currentAgentType)
def onAdd(self):
"""
Called on add
"""
if sys.version_info > (3,): # python3 support
if unicode(self.nameEdit.text().upper()):
self.accept()
else:
if unicode(self.nameEdit.text().toUpper()):
self.accept()
def getParameterValue(self):
"""
Returns parameter value
"""
qvalue = self.comboValue.currentText()
if sys.version_info > (3,): # python3 support
nameUpper = unicode(self.nameEdit.text().upper())
else:
nameUpper = unicode(self.nameEdit.text().toUpper())
r = { 'name': nameUpper, 'description': unicode(self.descrEdit.toPlainText()),
'value': unicode(qvalue), 'type': unicode(self.typeEdit.text()) }
return r
class WFramework(QWidget, Logger.ClassLogger):
"""
Framework widget
"""
# action, description, misc, parameters
AddStep = pyqtSignal(str, str, str, dict)
UpdateStep = pyqtSignal(str, str, str, dict)
CancelEdit = pyqtSignal()
def __init__(self, parent):
"""
Constructor
"""
QWidget.__init__(self)
self.createActions()
self.createWidgets()
self.createToolbar()
self.createConnections()
def createActions(self):
"""
Create qt actions
"""
self.addAction = QPushButton(QIcon(":/add_black.png"), '&Add Action', self)
self.addAction.setMinimumHeight(40)
self.addAction.setMaximumWidth(200)
self.cancelAction = QtHelper.createAction(self, "&Cancel", self.cancelStep,
icon=QIcon(":/undo.png"), tip = 'Cancel update')
self.cancelAction.setEnabled(False)
self.optionsAction = QtHelper.createAction(self, "&", self.openOptions,
icon=QIcon(":/recorder-basic-small.png"), tip = 'Framework options')
def openOptions(self):
"""
Open options dialog
"""
if self.optionsDialog.exec_() == QDialog.Accepted:
pass
def createWidgets(self):
"""
Create all qt widgets
"""
self.optionsDialog = OptionsDialog(self)
self.validatorUpper = ValidatorUpper(self)
self.validatorAll = ValidatorAll(self)
self.validatorInt = QIntValidator(self)
font = QFont()
font.setBold(True)
self.actionsComboBox = QComboBox(self)
self.actionsComboBox.setMinimumHeight(40)
for i in xrange(len(GuiSteps.ACTION_FRAMEWORK_DESCR)):
if not len( GuiSteps.ACTION_FRAMEWORK_DESCR[i] ):
self.actionsComboBox.insertSeparator(i+1)
else:
el = GuiSteps.ACTION_FRAMEWORK_DESCR[i].keys()
self.actionsComboBox.addItem( list(el)[0] )
self.labelActionDescr = QLabel(self)
self.labelActionDescr.setText( "%s\n" % GuiSteps.ACTION_FRAMEWORK_DESCR[0][GuiSteps.FRAMEWORK_INFO])
self.labelActionDescr.setWordWrap(True)
self.labelActionDescr.hide()
self.descriptionLine = QLineEdit(self)
self.descriptionLine.hide()
actionLayout2 = QGridLayout()
self.createWidgetGetText()
self.createWidgetGetWait()
self.createWidgetCacheSet()
self.createWidgetCheckString()
self.createWidgetGetAsk()
actionLayout2.addWidget( self.setCacheGroup , 0, 0)
actionLayout2.addWidget( self.getCheckGroup , 1, 0)
actionLayout2.addWidget( self.getTextGroup , 2, 0)
actionLayout2.addWidget( self.getWaitGroup , 3, 0)
actionLayout2.addWidget( self.getAskGroup , 4, 0)
labelAct = QLabel( self.tr("Action: ") )
labelAct.setFont( font)
self.arrowLabel = QLabel("")
self.arrowLabel.setPixmap(QPixmap(":/arrow-right.png").scaledToWidth(32))
self.arrowLabel2 = QLabel("")
self.arrowLabel2.setPixmap(QPixmap(":/arrow-right.png").scaledToWidth(32))
layoutFinal = QHBoxLayout()
layoutFinal.addWidget( labelAct )
layoutFinal.addWidget(self.actionsComboBox)
layoutFinal.addWidget( self.arrowLabel )
layoutFinal.addLayout( actionLayout2 )
layoutFinal.addWidget( self.arrowLabel2 )
layoutFinal.addWidget(self.addAction)
layoutFinal.addStretch(1)
self.setLayout(layoutFinal)
def createToolbar(self):
"""
Create toolbar
"""
pass
def createWidgetCheckString(self):
"""
Create widget to check string
"""
self.getCheckGroup = QGroupBox(self.tr(""))
# check in ?
self.checkInTextLine = QLineEdit(self)
self.checkInTextLine.setMinimumWidth(300)
self.checkInTextCombo = QComboBox(self)
self.checkInTextCombo.addItems( [ "CACHE" ] )
# operator
self.checkComboBox = QComboBox(self)
self.checkComboBox.addItems( [ GuiSteps.OP_CONTAINS, GuiSteps.OP_NOTCONTAINS, GuiSteps.OP_REGEXP, GuiSteps.OP_NOTREGEXP,
GuiSteps.OP_STARTSWITH, GuiSteps.OP_NOTSTARTSWITH, GuiSteps.OP_ENDSWITH,
GuiSteps.OP_NOTENDSWITH ] )
# check what ?
self.checkOutTextLine = QLineEdit(self)
self.checkOutTextLine.setMinimumWidth(300)
self.checkOutTextCombo = QComboBox(self)
self.checkOutTextCombo.addItems( LIST_TYPES )
# final layout
mainChecklayout = QGridLayout()
mainChecklayout.addWidget( QLabel( self.tr("Checking from:") ), 0, 0 )
mainChecklayout.addWidget( self.checkInTextCombo, 0, 1 )
mainChecklayout.addWidget( self.checkInTextLine, 0, 2 )
mainChecklayout.addWidget( QLabel( self.tr("If:") ), 1, 0 )
mainChecklayout.addWidget( self.checkComboBox, 1, 1 )
mainChecklayout.addWidget( QLabel( self.tr("The Value:") ), 2, 0 )
mainChecklayout.addWidget( self.checkOutTextCombo, 2, 1 )
mainChecklayout.addWidget( self.checkOutTextLine, 2, 2 )
self.getCheckGroup.setLayout(mainChecklayout)
self.getCheckGroup.hide()
def createWidgetGetText(self):
"""
Create text widget
"""
self.getTextGroup = QGroupBox(self.tr(""))
self.basicTextLine = QLineEdit(self)
self.basicTextLine.setMinimumWidth(300)
self.basicTextCombo = QComboBox(self)
self.basicTextCombo.addItems( LIST_TYPES )
mainTextlayout = QGridLayout()
mainTextlayout.addWidget( QLabel( self.tr("Value:") ), 0, 0 )
mainTextlayout.addWidget( self.basicTextCombo, 0, 1 )
mainTextlayout.addWidget( self.basicTextLine, 0, 2 )
self.getTextGroup.setLayout(mainTextlayout)
def createWidgetGetAsk(self):
"""
Create ask widget
"""
# ask
self.getAskGroup = QGroupBox(self.tr(""))
self.askTextLine = QLineEdit(self)
self.askTextLine.setMinimumWidth(300)
self.askTextCombo = QComboBox(self)
self.askTextCombo.addItems( LIST_TYPES )
self.askTextCacheLine = QLineEdit(self)
self.askTextCacheLine.setMinimumWidth(300)
self.askTextCacheCombo = QComboBox(self)
self.askTextCacheCombo.addItems( [ "CACHE" ] )
mainAsklayout = QGridLayout()
mainAsklayout.addWidget( QLabel( self.tr("User input prompt:") ), 0, 0 )
mainAsklayout.addWidget( self.askTextCombo, 0, 1 )
mainAsklayout.addWidget( self.askTextLine, 0, 2 )
mainAsklayout.addWidget( QLabel( self.tr("And save response in:") ), 1, 0 )
mainAsklayout.addWidget( self.askTextCacheCombo, 1, 1 )
mainAsklayout.addWidget( self.askTextCacheLine, 1, 2 )
self.getAskGroup.setLayout(mainAsklayout)
self.getAskGroup.hide()
def createWidgetGetWait(self):
"""
Create wait text widget
"""
self.getWaitGroup = QGroupBox(self.tr(""))
self.valueWaitLine = QLineEdit(self)
self.valueWaitLine.setMinimumWidth(300)
self.valueWaitLine.setValidator(self.validatorInt)
self.valueWaitCombo = QComboBox(self)
self.valueWaitCombo.addItems( LIST_TYPES )
mainTextlayout = QGridLayout()
mainTextlayout.addWidget( QLabel( self.tr("Value (in seconds):") ), 0, 0 )
mainTextlayout.addWidget( self.valueWaitCombo, 0, 1 )
mainTextlayout.addWidget( self.valueWaitLine, 0, 2 )
self.getWaitGroup.setLayout(mainTextlayout)
self.getWaitGroup.hide()
def createWidgetCacheSet(self):
"""
Create cache widget
"""
self.setCacheGroup = QGroupBox(self.tr(""))
setCacheLayout = QGridLayout()
self.cacheKeyName = QLineEdit(self)
self.cacheKeyName.setMinimumWidth(300)
setCacheLayout.addWidget( QLabel( self.tr("Key name:") ) , 0, 1)
setCacheLayout.addWidget( self.cacheKeyName , 0, 2)
self.setCacheGroup.setLayout(setCacheLayout)
self.setCacheGroup.hide()
def createConnections(self):
"""
Createa qt connections
"""
self.actionsComboBox.currentIndexChanged.connect(self.onActionChanged)
self.addAction.clicked.connect(self.addStep)
self.basicTextCombo.currentIndexChanged.connect(self.onBasicTextTypeChanged)
self.valueWaitCombo.currentIndexChanged.connect(self.onValueWaitTypeChanged)
self.checkOutTextCombo.currentIndexChanged.connect(self.onCheckOutTextTypeChanged)
self.askTextCombo.currentIndexChanged.connect(self.onAskTextTypeChanged)
def onAskTextTypeChanged(self):
"""
On ask type changed
"""
if self.askTextCombo.currentText() in [ "TEXT", "CACHE" ]:
self.askTextLine.setValidator(self.validatorAll)
if self.askTextCombo.currentText() == "ALIAS":
self.askTextLine.setText( self.askTextLine.text().upper() )
self.askTextLine.setValidator(self.validatorUpper)
def onCheckOutTextTypeChanged(self):
"""
On check out type changed
"""
if self.checkOutTextCombo.currentText() in [ "TEXT", "CACHE" ]:
self.checkOutTextLine.setValidator(self.validatorAll)
if self.checkOutTextCombo.currentText() == "ALIAS":
self.checkOutTextLine.setText( self.checkOutTextLine.text().upper() )
self.checkOutTextLine.setValidator(self.validatorUpper)
def onValueWaitTypeChanged(self):
"""
On value wait changed
"""
if self.valueWaitCombo.currentText() in [ "TEXT" ]:
self.valueWaitLine.setText( "0" )
self.valueWaitLine.setValidator(self.validatorInt)
if self.valueWaitCombo.currentText() in [ "CACHE" ]:
self.valueWaitLine.setValidator(self.validatorAll)
if self.valueWaitCombo.currentText() == "ALIAS":
self.valueWaitLine.setText( self.valueWaitLine.text().upper() )
self.valueWaitLine.setValidator(self.validatorUpper)
def onBasicTextTypeChanged(self):
"""
On basic text changed
"""
if self.basicTextCombo.currentText() in [ "TEXT", "CACHE" ]:
self.basicTextLine.setValidator(self.validatorAll)
if self.basicTextCombo.currentText() == "ALIAS":
self.basicTextLine.setText( self.basicTextLine.text().upper() )
self.basicTextLine.setValidator(self.validatorUpper)
def pluginDataAccessor(self):
"""
Return data for plugins
"""
return { "data": "" }
def onPluginImport(self, dataJson):
"""
On call from plugin
"""
pass
def onRadioAskChanged(self, button):
"""
On radio ask changed
"""
if button.text() == 'From alias parameter':
self.askTextLine.setText( self.askTextLine.text().upper() )
self.askTextLine.setValidator(self.validAskUpper)
else:
self.askTextLine.setValidator(self.validAskAll)
def onActionChanged(self):
"""
On action changed
"""
descr = 'No description available!'
i = 0
for el in GuiSteps.ACTION_FRAMEWORK_DESCR:
if isinstance(el, dict):
if self.actionsComboBox.currentText() in el:
descr = GuiSteps.ACTION_FRAMEWORK_DESCR[i][self.actionsComboBox.currentText()]
break
i += 1
self.labelActionDescr.setText( "%s\n" % descr )
if self.actionsComboBox.currentText() in [ GuiSteps.FRAMEWORK_INFO, GuiSteps.FRAMEWORK_WARNING ]:
self.getTextGroup.show()
self.getWaitGroup.hide()
self.setCacheGroup.hide()
self.getCheckGroup.hide()
self.getAskGroup.hide()
self.arrowLabel.show()
self.arrowLabel2.show()
elif self.actionsComboBox.currentText() in [ GuiSteps.FRAMEWORK_WAIT ]:
self.getWaitGroup.show()
self.getTextGroup.hide()
self.setCacheGroup.hide()
self.getCheckGroup.hide()
self.getAskGroup.hide()
self.arrowLabel.show()
self.arrowLabel2.show()
elif self.actionsComboBox.currentText() in [ GuiSteps.FRAMEWORK_CACHE_SET ]:
self.getTextGroup.show()
self.getWaitGroup.hide()
self.setCacheGroup.show()
self.getCheckGroup.hide()
self.getAskGroup.hide()
self.arrowLabel.show()
self.arrowLabel2.show()
elif self.actionsComboBox.currentText() in [ GuiSteps.FRAMEWORK_CHECK_STRING ]:
self.getCheckGroup.show()
self.getTextGroup.hide()
self.getWaitGroup.hide()
self.setCacheGroup.hide()
self.getAskGroup.hide()
self.arrowLabel.show()
self.arrowLabel2.show()
elif self.actionsComboBox.currentText() in [ GuiSteps.FRAMEWORK_INTERACT ]:
self.getCheckGroup.hide()
self.getTextGroup.hide()
self.getWaitGroup.hide()
self.setCacheGroup.hide()
self.getAskGroup.show()
self.arrowLabel.show()
self.arrowLabel2.show()
elif self.actionsComboBox.currentText() in [ GuiSteps.FRAMEWORK_USERCODE, GuiSteps.FRAMEWORK_CACHE_RESET ]:
self.getCheckGroup.hide()
self.getTextGroup.hide()
self.getWaitGroup.hide()
self.setCacheGroup.hide()
self.getAskGroup.hide()
self.arrowLabel.hide()
self.arrowLabel2.show()
else:
self.getTextGroup.hide()
self.getWaitGroup.hide()
self.setCacheGroup.hide()
self.getCheckGroup.hide()
self.getAskGroup.hide()
self.arrowLabel.hide()
self.arrowLabel2.hide()
def addStep(self):
"""
Add step
"""
action = self.actionsComboBox.currentText()
descr = self.descriptionLine.text()
descr = unicode(descr).replace('"', '')
signal = self.AddStep
if self.cancelAction.isEnabled():
signal = self.UpdateStep
if action in [ GuiSteps.FRAMEWORK_INFO, GuiSteps.FRAMEWORK_WARNING ]:
fromCache = False
if self.basicTextCombo.currentText() == "CACHE": fromCache = True
fromAlias = False
if self.basicTextCombo.currentText() == "ALIAS": fromAlias = True
newText = self.basicTextLine.text()
if not len(newText):
QMessageBox.warning(self, "Assistant" , "Please to set a value!")
else:
parameters = { 'text': newText, 'from-cache': fromCache, 'from-alias': fromAlias }
signal.emit( str(action), unicode(descr), EMPTY_VALUE, parameters )
elif action in [ GuiSteps.FRAMEWORK_INTERACT ]:
# read text from cache, alias or not ?
fromCache = False
if self.askTextCombo.currentText() == "CACHE": fromCache = True
fromAlias = False
if self.askTextCombo.currentText() == "ALIAS": fromAlias = True
askText = self.askTextLine.text()
if not len(askText):
QMessageBox.warning(self, "Assistant" , "Please to set question to ask!")
else:
saveAskText = self.askTextCacheLine.text()
if not len(saveAskText):
QMessageBox.warning(self, "Assistant" , "Please to set key destination cache!")
else:
parameters = { 'key': saveAskText, 'value': askText, 'from-cache': fromCache, 'from-alias': fromAlias }
signal.emit( str(action), unicode(descr), EMPTY_VALUE, parameters )
elif action in [ GuiSteps.FRAMEWORK_CHECK_STRING ]:
fromCache = False
if self.checkOutTextCombo.currentText() == "CACHE": fromCache = True
fromAlias = False
if self.checkOutTextCombo.currentText() == "ALIAS": fromAlias = True
inText = self.checkInTextLine.text()
if not len(inText):
QMessageBox.warning(self, "Assistant" , "Please to set a cache key value!")
else:
outText = self.checkOutTextLine.text()
if not len(outText):
QMessageBox.warning(self, "Assistant" , "Please to set a value!")
else:
op = self.checkComboBox.currentText()
parameters = { 'key': inText, 'value': outText, 'from-cache': fromCache,
'from-alias': fromAlias, "operator": op }
signal.emit( str(action), unicode(descr), EMPTY_VALUE, parameters )
elif action in [ GuiSteps.FRAMEWORK_WAIT ]:
fromCache = False
if self.valueWaitCombo.currentText() == "CACHE": fromCache = True
fromAlias = False
if self.valueWaitCombo.currentText() == "ALIAS": fromAlias = True
miscStr = self.valueWaitLine.text()
if not len(miscStr):
QMessageBox.warning(self, "Assistant" , "Please to set a value!")
else:
parameters = {'from-cache': fromCache, 'from-alias': fromAlias}
signal.emit( str(action), unicode(descr), miscStr, parameters )
elif action in [ GuiSteps.FRAMEWORK_CACHE_SET ]:
fromCache = False
if self.basicTextCombo.currentText() == "CACHE": fromCache = True
fromAlias = False
if self.basicTextCombo.currentText() == "ALIAS": fromAlias = True
newText = self.basicTextLine.text()
if not len(newText):
QMessageBox.warning(self, "Assistant" , "Please to set a text value!")
else:
miscStr = self.cacheKeyName.text()
if not len(miscStr):
QMessageBox.warning(self, "Assistant" , "Please to set a key name!")
else:
parameters = { 'key': miscStr, 'value': newText, 'from-cache': fromCache, 'from-alias': fromAlias }
signal.emit( str(action), unicode(descr), EMPTY_VALUE, parameters )
else:
signal.emit( str(action), unicode(descr), EMPTY_VALUE, {} )
def cancelStep(self):
"""
Cancel step
"""
self.addAction.setText( "&Add" )
buttonFont = QFont()
buttonFont.setBold(False)
self.addAction.setFont(buttonFont)
self.cancelAction.setEnabled(False)
self.CancelEdit.emit()
def finalizeUpdate(self):
"""
Finalize update
"""
self.addAction.setText( "&Add Action" )
buttonFont = QFont()
buttonFont.setBold(False)
self.addAction.setFont(buttonFont)
self.cancelAction.setEnabled(False)
def editStep(self, stepData):
"""
Edit step
"""
self.addAction.setText( "&Update" )
buttonFont = QFont()
buttonFont.setBold(True)
self.addAction.setFont(buttonFont)
self.cancelAction.setEnabled(True)
# set the current value for actions combo
for i in xrange(self.actionsComboBox.count()):
item_text = self.actionsComboBox.itemText(i)
if unicode(stepData["action"]) == unicode(item_text):
self.actionsComboBox.setCurrentIndex(i)
break
# and then refresh options
self.onActionChanged()
# finally fill all fields
self.descriptionLine.setText( stepData["description"] )
if self.actionsComboBox.currentText() in [ GuiSteps.FRAMEWORK_INFO, GuiSteps.FRAMEWORK_WARNING ] :
self.basicTextLine.setText ( stepData["parameters"]["text"] )
if stepData["parameters"]["from-cache"]:
self.basicTextLine.setValidator(self.validatorAll)
self.basicTextCombo.setCurrentIndex(INDEX_CACHE)
elif stepData["parameters"]["from-alias"]:
self.basicTextLine.setValidator(self.validatorUpper)
self.basicTextCombo.setCurrentIndex(INDEX_ALIAS)
else:
self.basicTextLine.setValidator(self.validatorAll)
self.basicTextCombo.setCurrentIndex(INDEX_TEXT)
if self.actionsComboBox.currentText() in [ GuiSteps.FRAMEWORK_WAIT ]:
self.valueWaitLine.setText ( stepData["misc"] )
if stepData["parameters"]["from-cache"]:
self.valueWaitLine.setValidator(self.validatorAll)
self.valueWaitCombo.setCurrentIndex(INDEX_CACHE)
elif stepData["parameters"]["from-alias"]:
self.valueWaitLine.setValidator(self.validatorUpper)
self.valueWaitCombo.setCurrentIndex(INDEX_ALIAS)
else:
self.valueWaitLine.setValidator(self.validatorInt)
self.valueWaitCombo.setCurrentIndex(INDEX_TEXT)
if self.actionsComboBox.currentText() in [ GuiSteps.FRAMEWORK_CACHE_SET ]:
self.basicTextLine.setText ( stepData["parameters"]["value"] )
if stepData["parameters"]["from-cache"]:
self.basicTextLine.setValidator(self.validatorAll)
self.basicTextCombo.setCurrentIndex(INDEX_CACHE)
elif stepData["parameters"]["from-alias"]:
self.basicTextLine.setValidator(self.validatorUpper)
self.basicTextCombo.setCurrentIndex(INDEX_ALIAS)
else:
self.basicTextLine.setValidator(self.validatorAll)
self.basicTextCombo.setCurrentIndex(INDEX_TEXT)
self.cacheKeyName.setText( stepData["parameters"]["key"] )
if self.actionsComboBox.currentText() in [ GuiSteps.FRAMEWORK_CHECK_STRING ]:
self.checkOutTextLine.setText ( stepData["parameters"]["value"] )
if stepData["parameters"]["from-cache"]:
self.checkOutTextLine.setValidator(self.validatorAll)
self.checkOutTextCombo.setCurrentIndex(INDEX_CACHE)
elif stepData["parameters"]["from-alias"]:
self.checkOutTextLine.setValidator(self.validatorUpper)
self.checkOutTextCombo.setCurrentIndex(INDEX_ALIAS)
else:
self.checkOutTextLine.setValidator(self.validatorAll)
self.checkOutTextCombo.setCurrentIndex(INDEX_TEXT)
self.checkInTextLine.setText ( stepData["parameters"]["key"] )
for i in xrange(self.checkComboBox.count()):
item_text = self.checkComboBox.itemText(i)
if unicode(stepData["parameters"]["operator"]) == unicode(item_text):
self.checkComboBox.setCurrentIndex(i)
break
if self.actionsComboBox.currentText() in [ GuiSteps.FRAMEWORK_INTERACT ]:
self.askTextLine.setText ( stepData["parameters"]["value"] )
if stepData["parameters"]["from-cache"]:
self.askTextLine.setValidator(self.validatorAll)
self.askTextCombo.setCurrentIndex(INDEX_CACHE)
elif stepData["parameters"]["from-alias"]:
self.askTextLine.setValidator(self.validatorUpper)
self.askTextCombo.setCurrentIndex(INDEX_ALIAS)
else:
self.askTextLine.setValidator(self.validatorAll)
self.askTextCombo.setCurrentIndex(INDEX_TEXT)
self.askTextCacheLine.setText ( stepData["parameters"]["key"] )
def getTimeout(self):
"""
Return timeout
"""
return self.optionsDialog.timeoutLine.text()
def setTimeout(self, timeout):
"""
Set the timeout
"""
return self.optionsDialog.timeoutLine.setText(timeout)
class WAndroid(QWidget, Logger.ClassLogger):
"""
Android widget
"""
# action, description, misc, parameters
AddStep = pyqtSignal(str, str, str, dict)
UpdateStep = pyqtSignal(str, str, str, dict)
CancelEdit = pyqtSignal()
def __init__(self, parent):
"""
Constructor
"""
QWidget.__init__(self)
self.createActions()
self.createWidgets()
self.createToolbar()
self.createConnections()
def createActions(self):
"""
Create qt actions
"""
self.addAndroidAction = QPushButton(QIcon(":/add_black.png"), '&Add Action', self)
self.addAndroidAction.setMinimumHeight(40)
self.addAndroidAction.setMaximumWidth(150)
self.cancelAndroidAction = QtHelper.createAction(self, "&Cancel", self.cancelStep,
icon=None, tip = 'Cancel update')
self.cancelAndroidAction.setEnabled(False)
self.optionsAction = QtHelper.createAction(self, "&", self.openOptions,
icon=QIcon(":/recorder-mobile-small.png"), tip = 'Android options')
def createWidgets(self):
"""
Create qt widgets
"""
self.optionsDialog = OptionsDialog(self)
self.validatorUpper = ValidatorUpper(self)
self.validatorAll = ValidatorAll(self)
self.validatorInt = QIntValidator(self)
###################### android action #########################
self.actionsAndroidComboBox = QComboBox(self)
self.actionsAndroidComboBox.setMinimumHeight(40)
for i in xrange(len(GuiSteps.ACTION_ANDROID_DESCR)):
if not len( GuiSteps.ACTION_ANDROID_DESCR[i] ):
self.actionsAndroidComboBox.insertSeparator(i+1)
else:
el = GuiSteps.ACTION_ANDROID_DESCR[i].keys()
self.actionsAndroidComboBox.addItem( list(el)[0] )
self.descriptionAndroidLine = QLineEdit(self)
self.descriptionAndroidLine.setPlaceholderText("Step purpose description")
self.descriptionAndroidLine.hide()
self.labelActionAndroidDescr = QLabel( )
self.labelActionAndroidDescr.hide()
self.labelActionAndroidDescr.setText( "%s\n" % GuiSteps.ACTION_ANDROID_DESCR[0][GuiSteps.ANDROID_WAKEUP_UNLOCK])
self.labelActionAndroidDescr.setWordWrap(True)
actionsLayout = QHBoxLayout()
actionsLayout.addWidget(self.actionsAndroidComboBox)
actionLayoutAndroid = QGridLayout()
actionLayoutAndroid.addLayout(actionsLayout, 0, 1)
self.createWidgetShortcut()
self.createWidgetCode()
self.createWidgetStart()
self.createWidgetXY()
self.createWidgetEndXY()
self.createWidgetElement()
self.createWidgetTextTo()
self.createWidgetLine()
self.createWidgetLine2()
actionLayoutAndroid2 = QGridLayout()
actionLayoutAndroid2.addWidget( self.shortcutAndroidGroup , 0, 0)
actionLayoutAndroid2.addWidget( self.codeAndroidGroup , 0, 0)
actionLayoutAndroid2.addWidget( self.elemenAndroidGroup , 0, 0)
actionLayoutAndroid2.addWidget( self.xyAndroidGroup , 0, 0)
actionLayoutAndroid2.addWidget( self.startAndroidGroup , 0, 0)
actionLayoutAndroid2.addWidget( self.lineAndroidGroup , 1, 0)
actionLayoutAndroid2.addWidget( self.line2AndroidGroup , 0, 1)
actionLayoutAndroid2.addWidget( self.textToGlobalGroup , 0, 1)
actionLayoutAndroid2.addWidget( self.endXyAndroidGroup, 0, 1)
font = QFont()
font.setBold(True)
labelAct = QLabel( self.tr("Action: ") )
labelAct.setFont( font)
self.arrowLabel = QLabel("")
self.arrowLabel.setPixmap(QPixmap(":/arrow-right.png").scaledToWidth(32))
self.arrowLabel.hide()
self.arrowLabel2 = QLabel("")
self.arrowLabel2.setPixmap(QPixmap(":/arrow-right.png").scaledToWidth(32))
layoutAndroid = QHBoxLayout()
layoutAndroid.addWidget( labelAct )
layoutAndroid.addLayout( actionLayoutAndroid )
layoutAndroid.addWidget( self.arrowLabel )
layoutAndroid.addLayout( actionLayoutAndroid2 )
layoutAndroid.addWidget( self.arrowLabel2 )
layoutAndroid.addWidget(self.addAndroidAction)
layoutAndroid.addStretch(1)
self.setLayout(layoutAndroid)
def createToolbar(self):
"""
Create qt toolbar
"""
pass
def openOptions(self):
"""
Open options
"""
if self.optionsDialog.exec_() == QDialog.Accepted:
pass
def createWidgetLine2(self):
"""
Create line widget
"""
self.valueAndroidLine2 = QLineEdit(self)
self.valueAndroidLine2.setMinimumWidth(150)
self.valueAndroidCombo2 = QComboBox(self)
self.valueAndroidCombo2.addItems( LIST_TYPES )
self.line2AndroidGroup = QGroupBox(self.tr(""))
line2Androidlayout = QGridLayout()
line2Androidlayout.addWidget( QLabel( self.tr("Text to type:") ), 0, 0 )
line2Androidlayout.addWidget( self.valueAndroidCombo2, 0, 1 )
line2Androidlayout.addWidget( self.valueAndroidLine2, 0, 2 )
self.line2AndroidGroup.setLayout(line2Androidlayout)
self.line2AndroidGroup.hide()
def createWidgetLine(self):
"""
Create line widget
"""
self.lineAndroidGroup = QGroupBox(self.tr(""))
lineAndroidlayout = QGridLayout()
self.valueAndroidLine = QLineEdit(self)
self.valueAndroidLine.setMinimumWidth(300)
lineAndroidlayout.addWidget( QLabel( self.tr("Value:") ) , 0,1)
lineAndroidlayout.addWidget( self.valueAndroidLine , 0, 2)
self.lineAndroidGroup.setLayout(lineAndroidlayout)
self.lineAndroidGroup.hide()
def createWidgetTextTo(self):
"""
Create text widget
"""
self.valueTextCacheGlobalLine = QLineEdit(self)
self.valueTextCacheGlobalLine.setMinimumWidth(150)
self.valueTextCacheGlobalCombo = QComboBox(self)
self.valueTextCacheGlobalCombo.addItems( ["CACHE"] )
self.textToGlobalGroup = QGroupBox(self.tr(""))
textToGloballayout = QGridLayout()
textToGloballayout.addWidget( QLabel( self.tr("Save text in:") ) , 0, 0)
textToGloballayout.addWidget( self.valueTextCacheGlobalCombo , 0, 1)
textToGloballayout.addWidget( self.valueTextCacheGlobalLine , 0, 2)
self.textToGlobalGroup.setLayout(textToGloballayout)
self.textToGlobalGroup.hide()
def createWidgetElement(self):
"""
Create text widget
"""
self.elemenAndroidGroup = QGroupBox(self.tr(""))
self.elementTextAndroidLine = QLineEdit(self)
self.elementTextAndroidLine.setMinimumWidth(300)
self.elementTextCombo = QComboBox(self)
self.elementTextCombo.addItems( LIST_TYPES )
self.elementDescriptionAndroidLine = QLineEdit(self)
self.elementDescriptionAndroidLine.setMinimumWidth(300)
self.elementClassAndroidLine = QLineEdit(self)
self.elementClassAndroidLine.setMinimumWidth(300)
self.elementRessourceIdAndroidLine = QLineEdit(self)
self.elementRessourceIdAndroidLine.setMinimumWidth(300)
self.elementPackageAndroidLine = QLineEdit(self)
self.elementPackageAndroidLine.setMinimumWidth(300)
# get text end
elementAndroidlayout = QGridLayout()
elementAndroidlayout.addWidget( QLabel( self.tr("Text Element:") ) , 0,1)
elementAndroidlayout.addWidget( self.elementTextCombo , 0, 2)
elementAndroidlayout.addWidget( self.elementTextAndroidLine , 0, 3)
elementAndroidlayout.addWidget( QLabel( self.tr("Description Element:") ) , 1,1)
elementAndroidlayout.addWidget( self.elementDescriptionAndroidLine , 1, 3)
elementAndroidlayout.addWidget( QLabel( self.tr("Class Name:") ) , 2,1)
elementAndroidlayout.addWidget( self.elementClassAndroidLine , 2, 3)
elementAndroidlayout.addWidget( QLabel( self.tr("Resource ID:") ) , 3,1)
elementAndroidlayout.addWidget( self.elementRessourceIdAndroidLine , 3, 3)
elementAndroidlayout.addWidget( QLabel( self.tr("Package Name:") ) , 4,1)
elementAndroidlayout.addWidget( self.elementPackageAndroidLine , 4, 3)
self.elemenAndroidGroup.setLayout(elementAndroidlayout)
self.elemenAndroidGroup.hide()
def createWidgetEndXY(self):
"""
Create widget
"""
self.endXyAndroidGroup = QGroupBox(self.tr(""))
endXyAndroidlayout = QGridLayout()
self.endxAndroidLine = QLineEdit(self)
validatorEndXAndroid = QIntValidator (self)
self.endxAndroidLine.setValidator(validatorEndXAndroid)
self.endxAndroidLine.installEventFilter(self)
self.endyAndroidLine = QLineEdit(self)
validatorEndYAndroid = QIntValidator (self)
self.endyAndroidLine.setValidator(validatorEndYAndroid)
self.endyAndroidLine.installEventFilter(self)
endXyAndroidlayout.addWidget( QLabel( self.tr("Destination Coordinate X:") ) , 0, 0)
endXyAndroidlayout.addWidget( self.endxAndroidLine , 0, 1)
endXyAndroidlayout.addWidget( QLabel( self.tr("Destination Coordinate Y:") ) , 1,0)
endXyAndroidlayout.addWidget( self.endyAndroidLine , 1, 1)
self.endXyAndroidGroup.setLayout(endXyAndroidlayout)
self.endXyAndroidGroup.hide()
def createWidgetXY(self):
"""
Create text widget
"""
self.xyAndroidGroup = QGroupBox(self.tr(""))
xyAndroidlayout = QGridLayout()
self.xAndroidLine = QLineEdit(self)
validatorXAndroid = QIntValidator (self)
self.xAndroidLine.setValidator(validatorXAndroid)
self.xAndroidLine.installEventFilter(self)
self.yAndroidLine = QLineEdit(self)
validatorYAndroid = QIntValidator (self)
self.yAndroidLine.setValidator(validatorYAndroid)
self.yAndroidLine.installEventFilter(self)
xyAndroidlayout.addWidget( QLabel( self.tr("Coordinate X:") ) , 0,0)
xyAndroidlayout.addWidget( self.xAndroidLine , 0, 1)
xyAndroidlayout.addWidget( QLabel( self.tr("Coordinate Y:") ) , 1,0)
xyAndroidlayout.addWidget( self.yAndroidLine , 1, 1)
self.xyAndroidGroup.setLayout(xyAndroidlayout)
self.xyAndroidGroup.hide()
def createWidgetStart(self):
"""
Create text widget
"""
self.startAndroidGroup = QGroupBox(self.tr(""))
startAndroidlayout = QGridLayout()
self.startXAndroidLine = QLineEdit(self)
validatorStartXAndroid = QIntValidator (self)
self.startXAndroidLine.setValidator(validatorStartXAndroid)
self.startXAndroidLine.installEventFilter(self)
self.startYAndroidLine = QLineEdit(self)
validatorStartYAndroid = QIntValidator (self)
self.startYAndroidLine.setValidator(validatorStartYAndroid)
self.startYAndroidLine.installEventFilter(self)
self.stopXAndroidLine = QLineEdit(self)
validatorStopXAndroid = QIntValidator (self)
self.stopXAndroidLine.setValidator(validatorStopXAndroid)
self.stopXAndroidLine.installEventFilter(self)
self.stopYAndroidLine = QLineEdit(self)
validatorStopYAndroid = QIntValidator (self)
self.stopYAndroidLine.setValidator(validatorStopYAndroid)
self.stopYAndroidLine.installEventFilter(self)
startAndroidlayout.addWidget( QLabel( self.tr("From X:") ) , 0,1)
startAndroidlayout.addWidget( self.startXAndroidLine , 0, 2)
startAndroidlayout.addWidget( QLabel( self.tr("From Y:") ) , 0,3)
startAndroidlayout.addWidget( self.startYAndroidLine , 0, 4)
startAndroidlayout.addWidget( QLabel( self.tr("To X:") ) ,1,1)
startAndroidlayout.addWidget( self.stopXAndroidLine , 1, 2)
startAndroidlayout.addWidget( QLabel( self.tr("To Y:") ) , 1,3)
startAndroidlayout.addWidget( self.stopYAndroidLine , 1 , 4)
self.startAndroidGroup.setLayout(startAndroidlayout)
self.startAndroidGroup.hide()
def createWidgetShortcut(self):
"""
Create shortcut widget
"""
self.shortcutAndroidGroup = QGroupBox(self.tr(""))
shortcutAndroidlayout = QGridLayout()
self.shortcutAndroidComboBox = QComboBox(self)
for i in xrange(len(KEYS_SHORTCUT_ANDROID)):
if len(KEYS_SHORTCUT_ANDROID[i]) == 0:
self.shortcutAndroidComboBox.insertSeparator(i + 2)
else:
self.shortcutAndroidComboBox.addItem (KEYS_SHORTCUT_ANDROID[i])
shortcutAndroidlayout.addWidget( QLabel( self.tr("Button:") ) , 0,1)
shortcutAndroidlayout.addWidget(self.shortcutAndroidComboBox, 0, 2)
self.shortcutAndroidGroup.setLayout(shortcutAndroidlayout)
self.shortcutAndroidGroup.hide()
def createWidgetCode(self):
"""
Create code widget
"""
self.codeAndroidGroup = QGroupBox(self.tr(""))
self.codeAndroidLine = QLineEdit(self)
validatorCodeAndroid = QIntValidator (self)
self.codeAndroidLine.setValidator(validatorCodeAndroid)
self.codeAndroidLine.installEventFilter(self)
codeAndroidlayout = QGridLayout()
codeAndroidlayout.addWidget( QLabel( self.tr("Code:") ) , 0,1)
codeAndroidlayout.addWidget( self.codeAndroidLine , 0, 2)
self.codeAndroidGroup.setLayout(codeAndroidlayout)
self.codeAndroidGroup.hide()
def pluginDataAccessor(self):
"""
Return data for plugin
"""
return { "data": "" }
def onPluginImport(self, dataJson):
"""
Received data from plugin
"""
pass
def createConnections(self):
"""
Create qt connections
"""
self.actionsAndroidComboBox.currentIndexChanged.connect(self.onActionAndroidChanged)
self.addAndroidAction.clicked.connect(self.addStep)
self.valueAndroidCombo2.currentIndexChanged.connect(self.onValueAndroid2TypeChanged)
self.elementTextCombo.currentIndexChanged.connect(self.onElementTextTypeChanged)
def onElementTextTypeChanged(self):
"""
On element text changed
"""
if self.elementTextCombo.currentText() in [ "TEXT", "CACHE" ]:
self.elementTextAndroidLine.setValidator(self.validatorAll)
if self.elementTextCombo.currentText() == "ALIAS":
self.elementTextAndroidLine.setText( self.elementTextAndroidLine.text().upper() )
self.elementTextAndroidLine.setValidator(self.validatorUpper)
def onValueAndroid2TypeChanged(self):
"""
On value changed
"""
if self.valueAndroidCombo2.currentText() in [ "TEXT", "CACHE" ]:
self.valueAndroidLine2.setValidator(self.validatorAll)
if self.valueAndroidCombo2.currentText() == "ALIAS":
self.valueAndroidLine2.setText( self.valueAndroidLine2.text().upper() )
self.valueAndroidLine2.setValidator(self.validatorUpper)
def addStep(self):
"""
Add step
"""
action = self.actionsAndroidComboBox.currentText()
descr = self.descriptionAndroidLine.text()
descr = unicode(descr).replace('"', '')
signal = self.AddStep
if self.cancelAndroidAction.isEnabled():
signal = self.UpdateStep
if self.actionsAndroidComboBox.currentText() in [ GuiSteps.ANDROID_WAKUP, GuiSteps.ANDROID_UNLOCK, GuiSteps.ANDROID_REBOOT,
GuiSteps.ANDROID_SLEEP, GuiSteps.ANDROID_FREEZE_ROTATION, GuiSteps.ANDROID_UNFREEZE_ROTATION,
GuiSteps.ANDROID_BOOTLOADER, GuiSteps.ANDROID_RECOVERY, GuiSteps.ANDROID_NOTIFICATION,
GuiSteps.ANDROID_SETTINGS, GuiSteps.ANDROID_DEVICEINFO, GuiSteps.ANDROID_GET_LOGS,
GuiSteps.ANDROID_CLEAR_LOGS , GuiSteps.ANDROID_WAKEUP_UNLOCK, GuiSteps.ANDROID_LOCK,
GuiSteps.ANDROID_SLEEP_LOCK ]:
signal.emit( str(action), unicode(descr), EMPTY_VALUE, {} )
elif self.actionsAndroidComboBox.currentText() in [ GuiSteps.ANDROID_TYPE_SHORTCUT]:
shorcut = self.shortcutAndroidComboBox.currentText()
signal.emit( str(action), unicode(descr), shorcut, {} )
elif self.actionsAndroidComboBox.currentText() in [ GuiSteps.ANDROID_TYPE_KEYCODE ]:
code = self.codeAndroidLine.text()
if not len(code):
QMessageBox.warning(self, "Recording for Gui" , "Please to set a value!")
else:
signal.emit( str(action), unicode(descr), code, {} )
elif self.actionsAndroidComboBox.currentText() in [ GuiSteps.ANDROID_CLEAR_ELEMENT, GuiSteps.ANDROID_CLICK_ELEMENT, GuiSteps.ANDROID_LONG_CLICK_ELEMENT,
GuiSteps.ANDROID_EXIST_ELEMENT, GuiSteps.ANDROID_WAIT_ELEMENT, GuiSteps.ANDROID_TYPE_TEXT_ELEMENT,
GuiSteps.ANDROID_GET_TEXT_ELEMENT, GuiSteps.ANDROID_DRAG_ELEMENT, GuiSteps.ANDROID_WAIT_CLICK_ELEMENT ]:
textAndroid = self.elementTextAndroidLine.text()
descrAndroid = self.elementDescriptionAndroidLine.text()
classAndroid = self.elementClassAndroidLine.text()
ressourceAndroid = self.elementRessourceIdAndroidLine.text()
packageAndroid = self.elementPackageAndroidLine.text()
if not len(textAndroid) and not len(classAndroid) and not len(ressourceAndroid) and not len(packageAndroid) and not len(descrAndroid):
QMessageBox.warning(self, "Recording for Gui" , "Please to set one value!")
else:
# read text from cache or not ?
fromElCache = False
if self.elementTextCombo.currentText() == "CACHE": fromElCache = True
fromElAlias = False
if self.elementTextCombo.currentText() == "ALIAS": fromElAlias = True
if self.actionsAndroidComboBox.currentText() == GuiSteps.ANDROID_TYPE_TEXT_ELEMENT:
newTextAndroid = self.valueAndroidLine2.text()
if not len(newTextAndroid):
QMessageBox.warning(self, "Recording for Gui" , "Please to set a text value!")
else:
# read text from cache or not ?
fromCache = False
if self.valueAndroidCombo2.currentText() == "CACHE": fromCache = True
fromAlias = False
if self.valueAndroidCombo2.currentText() == "ALIAS": fromAlias = True
parameters = {'text': textAndroid, 'class': classAndroid, 'ressource': ressourceAndroid,
'package': packageAndroid, 'description': descrAndroid, 'new-text': newTextAndroid,
'from-cache': fromCache, 'from-alias': fromAlias,
'from-el-cache': fromElCache, 'from-el-alias': fromElAlias }
signal.emit( str(action), unicode(descr), EMPTY_VALUE, parameters )
elif self.actionsAndroidComboBox.currentText() == GuiSteps.ANDROID_GET_TEXT_ELEMENT:
# read text from cache or not ?
cacheKey = ''
toCache = True
cacheKey = self.valueTextCacheGlobalLine.text()
parameters = {'text': textAndroid, 'class': classAndroid, 'ressource': ressourceAndroid,
'package': packageAndroid, 'description': descrAndroid, 'cache-key': cacheKey,
'to-cache': toCache, 'from-el-cache': fromElCache, 'from-el-alias': fromElAlias }
signal.emit( str(action), unicode(descr), EMPTY_VALUE, parameters )
elif self.actionsAndroidComboBox.currentText() == GuiSteps.ANDROID_DRAG_ELEMENT:
xAndroid = self.endxAndroidLine.text()
yAndroid = self.endyAndroidLine.text()
if not len(xAndroid) and not len(yAndroid):
QMessageBox.warning(self, "Recording for Gui" , "Please to set values!")
else:
parameters = {'text': textAndroid, 'class': classAndroid, 'ressource': ressourceAndroid,
'package': packageAndroid, 'description': descrAndroid,
'from-el-cache': fromElCache, 'from-el-alias': fromElAlias,
'x': xAndroid, 'y': yAndroid }
signal.emit( str(action), unicode(descr), EMPTY_VALUE, parameters )
else:
parameters = {'text': textAndroid, 'class': classAndroid, 'ressource': ressourceAndroid,
'package': packageAndroid, 'description': descrAndroid,
'from-el-cache': fromElCache, 'from-el-alias': fromElAlias }
signal.emit( str(action), unicode(descr), EMPTY_VALUE, parameters )
elif self.actionsAndroidComboBox.currentText() in [ GuiSteps.ANDROID_CLICK_POSITION ]:
xAndroid = self.xAndroidLine.text()
yAndroid = self.yAndroidLine.text()
if not len(xAndroid) and not len(yAndroid):
QMessageBox.warning(self, "Recording for Gui" , "Please to set values!")
else:
parameters = { 'x': xAndroid, 'y': yAndroid }
signal.emit( str(action), unicode(descr), EMPTY_VALUE, parameters )
elif self.actionsAndroidComboBox.currentText() in [ GuiSteps.ANDROID_DRAG_ELEMENT, GuiSteps.ANDROID_DRAG_POSITION,
GuiSteps.ANDROID_SWIPE_POSITION]:
startXAndroid = self.startXAndroidLine.text()
startYAndroid = self.startYAndroidLine.text()
stopXAndroid = self.stopXAndroidLine.text()
stopYAndroid = self.stopYAndroidLine.text()
if not len(startXAndroid) and not len(startYAndroid) and not len(stopXAndroid) and not len(stopYAndroid):
QMessageBox.warning(self, "Recording for Gui" , "Please to set values!")
else:
parameters = { 'start-x': startXAndroid, 'start-y': startYAndroid, 'stop-x': stopXAndroid, 'stop-y': stopYAndroid }
signal.emit( str(action), unicode(descr), EMPTY_VALUE, parameters )
elif self.actionsAndroidComboBox.currentText() in [ GuiSteps.ANDROID_COMMAND, GuiSteps.ANDROID_SHELL, GuiSteps.ANDROID_RESET_APP,
GuiSteps.ANDROID_STOP_APP]:
miscStr = self.valueAndroidLine.text()
if not len(miscStr):
QMessageBox.warning(self, "Recording for Gui" , "Please to set a value!")
else:
if self.actionsAndroidComboBox.currentText() == GuiSteps.ANDROID_COMMAND:
parameters = { 'cmd': miscStr }
elif self.actionsAndroidComboBox.currentText() in [ GuiSteps.ANDROID_RESET_APP, GuiSteps.ANDROID_STOP_APP ]:
parameters = { 'pkg': miscStr }
else:
parameters = { 'sh': miscStr }
signal.emit( str(action), unicode(descr), EMPTY_VALUE, parameters )
else:
signal.emit( str(action), unicode(descr), EMPTY_VALUE, {} )
def cancelStep(self):
"""
Cancel step
"""
self.addAndroidAction.setText( "&Add" )
buttonFont = QFont()
buttonFont.setBold(False)
self.addAndroidAction.setFont(buttonFont)
self.cancelAndroidAction.setEnabled(False)
self.CancelEdit.emit()
def finalizeUpdate(self):
"""
Finalize the update of a step
"""
self.addAndroidAction.setText( "&Add Action" )
buttonFont = QFont()
buttonFont.setBold(False)
self.addAndroidAction.setFont(buttonFont)
self.cancelAndroidAction.setEnabled(False)
def onActionAndroidChanged(self):
"""
On action changed
"""
descr = 'No description available!'
i = 0
for el in GuiSteps.ACTION_ANDROID_DESCR:
if isinstance(el, dict):
if self.actionsAndroidComboBox.currentText() in el:
descr = GuiSteps.ACTION_ANDROID_DESCR[i][self.actionsAndroidComboBox.currentText()]
break
i += 1
self.labelActionAndroidDescr.setText( "%s\n" % descr )
if self.actionsAndroidComboBox.currentText() in [ GuiSteps.ANDROID_TYPE_SHORTCUT ]:
self.shortcutAndroidGroup.show()
self.codeAndroidGroup.hide()
self.elemenAndroidGroup.hide()
self.startAndroidGroup.hide()
self.xyAndroidGroup.hide()
self.lineAndroidGroup.hide()
self.line2AndroidGroup.hide()
self.textToGlobalGroup.hide()
self.endXyAndroidGroup.hide()
self.arrowLabel.show()
self.arrowLabel2.show()
elif self.actionsAndroidComboBox.currentText() in [ GuiSteps.ANDROID_TYPE_KEYCODE ]:
self.codeAndroidGroup.show()
self.shortcutAndroidGroup.hide()
self.elemenAndroidGroup.hide()
self.startAndroidGroup.hide()
self.xyAndroidGroup.hide()
self.lineAndroidGroup.hide()
self.line2AndroidGroup.hide()
self.textToGlobalGroup.hide()
self.endXyAndroidGroup.hide()
self.arrowLabel.show()
self.arrowLabel2.show()
elif self.actionsAndroidComboBox.currentText() in [ GuiSteps.ANDROID_CLEAR_ELEMENT, GuiSteps.ANDROID_CLICK_ELEMENT, GuiSteps.ANDROID_LONG_CLICK_ELEMENT,
GuiSteps.ANDROID_EXIST_ELEMENT, GuiSteps.ANDROID_WAIT_ELEMENT, GuiSteps.ANDROID_WAIT_CLICK_ELEMENT ]:
self.shortcutAndroidGroup.hide()
self.codeAndroidGroup.hide()
self.elemenAndroidGroup.show()
self.startAndroidGroup.hide()
self.xyAndroidGroup.hide()
self.lineAndroidGroup.hide()
self.line2AndroidGroup.hide()
self.textToGlobalGroup.hide()
self.endXyAndroidGroup.hide()
self.arrowLabel.show()
self.arrowLabel2.show()
elif self.actionsAndroidComboBox.currentText() in [ GuiSteps.ANDROID_DRAG_ELEMENT ]:
self.shortcutAndroidGroup.hide()
self.codeAndroidGroup.hide()
self.elemenAndroidGroup.show()
self.startAndroidGroup.hide()
self.xyAndroidGroup.hide()
self.lineAndroidGroup.hide()
self.line2AndroidGroup.hide()
self.textToGlobalGroup.hide()
self.endXyAndroidGroup.show()
self.arrowLabel.show()
self.arrowLabel2.show()
elif self.actionsAndroidComboBox.currentText() in [ GuiSteps.ANDROID_GET_TEXT_ELEMENT ]:
self.shortcutAndroidGroup.hide()
self.codeAndroidGroup.hide()
self.elemenAndroidGroup.show()
self.startAndroidGroup.hide()
self.xyAndroidGroup.hide()
self.lineAndroidGroup.hide()
self.line2AndroidGroup.hide()
self.textToGlobalGroup.show()
self.endXyAndroidGroup.hide()
self.arrowLabel.show()
self.arrowLabel2.show()
elif self.actionsAndroidComboBox.currentText() in [ GuiSteps.ANDROID_CLICK_POSITION ]:
self.shortcutAndroidGroup.hide()
self.codeAndroidGroup.hide()
self.elemenAndroidGroup.hide()
self.startAndroidGroup.hide()
self.xyAndroidGroup.show()
self.lineAndroidGroup.hide()
self.line2AndroidGroup.hide()
self.textToGlobalGroup.hide()
self.endXyAndroidGroup.hide()
self.arrowLabel.show()
self.arrowLabel2.show()
elif self.actionsAndroidComboBox.currentText() in [ GuiSteps.ANDROID_DRAG_POSITION, GuiSteps.ANDROID_SWIPE_POSITION ]:
self.shortcutAndroidGroup.hide()
self.codeAndroidGroup.hide()
self.elemenAndroidGroup.hide()
self.startAndroidGroup.show()
self.xyAndroidGroup.hide()
self.lineAndroidGroup.hide()
self.line2AndroidGroup.hide()
self.textToGlobalGroup.hide()
self.endXyAndroidGroup.hide()
self.arrowLabel.show()
self.arrowLabel2.show()
elif self.actionsAndroidComboBox.currentText() in [ GuiSteps.ANDROID_COMMAND, GuiSteps.ANDROID_SHELL, GuiSteps.ANDROID_RESET_APP,
GuiSteps.ANDROID_STOP_APP ]:
self.shortcutAndroidGroup.hide()
self.codeAndroidGroup.hide()
self.elemenAndroidGroup.hide()
self.startAndroidGroup.hide()
self.xyAndroidGroup.hide()
self.lineAndroidGroup.show()
self.line2AndroidGroup.hide()
self.textToGlobalGroup.hide()
self.endXyAndroidGroup.hide()
self.arrowLabel.show()
self.arrowLabel2.show()
elif self.actionsAndroidComboBox.currentText() in [ GuiSteps.ANDROID_TYPE_TEXT_ELEMENT ]:
self.shortcutAndroidGroup.hide()
self.codeAndroidGroup.hide()
self.elemenAndroidGroup.show()
self.startAndroidGroup.hide()
self.xyAndroidGroup.hide()
self.lineAndroidGroup.hide()
self.line2AndroidGroup.show()
self.textToGlobalGroup.hide()
self.endXyAndroidGroup.hide()
self.arrowLabel.show()
self.arrowLabel2.show()
else:
self.shortcutAndroidGroup.hide()
self.codeAndroidGroup.hide()
self.elemenAndroidGroup.hide()
self.startAndroidGroup.hide()
self.xyAndroidGroup.hide()
self.lineAndroidGroup.hide()
self.line2AndroidGroup.hide()
self.textToGlobalGroup.hide()
self.endXyAndroidGroup.hide()
self.arrowLabel.hide()
self.arrowLabel2.show()
def setTimeout(self, timeout):
"""
Set the timeout
"""
self.optionsDialog.timeoutAndroidLine.setText(timeout)
def getTimeout(self):
"""
Return the timeout
"""
return self.optionsDialog.timeoutAndroidLine.text()
def getAgentName(self):
"""
Get the agent name
"""
return self.optionsDialog.agentNameLineAndroid.text()
def getAgentList(self):
"""
Return the agent list
"""
return self.optionsDialog.agentsAndroidList
def editStep(self, stepData):
"""
Edit a step
"""
self.addAndroidAction.setText( "&Update" )
buttonFont = QFont()
buttonFont.setBold(True)
self.addAndroidAction.setFont(buttonFont)
self.cancelAndroidAction.setEnabled(True)
# set the current value for actions combo
for i in xrange(self.actionsAndroidComboBox.count()):
item_text = self.actionsAndroidComboBox.itemText(i)
if unicode(stepData["action"]) == unicode(item_text):
self.actionsAndroidComboBox.setCurrentIndex(i)
break
# and then refresh options
self.onActionAndroidChanged()
# finally fill all fields
self.descriptionAndroidLine.setText( stepData["description"] )
if self.actionsAndroidComboBox.currentText() == GuiSteps.ANDROID_COMMAND:
self.valueAndroidLine.setText( stepData["parameters"]["cmd"] )
if self.actionsAndroidComboBox.currentText() == GuiSteps.ANDROID_SHELL:
self.valueAndroidLine.setText( stepData["parameters"]["sh"] )
if self.actionsAndroidComboBox.currentText() in [ GuiSteps.ANDROID_RESET_APP, GuiSteps.ANDROID_STOP_APP ]:
self.valueAndroidLine.setText( stepData["parameters"]["pkg"] )
if self.actionsAndroidComboBox.currentText() in [ GuiSteps.ANDROID_CLEAR_ELEMENT, GuiSteps.ANDROID_TYPE_TEXT_ELEMENT,
GuiSteps.ANDROID_CLICK_ELEMENT, GuiSteps.ANDROID_LONG_CLICK_ELEMENT,
GuiSteps.ANDROID_EXIST_ELEMENT, GuiSteps.ANDROID_WAIT_ELEMENT,
GuiSteps.ANDROID_GET_TEXT_ELEMENT, GuiSteps.ANDROID_DRAG_ELEMENT,
GuiSteps.ANDROID_WAIT_CLICK_ELEMENT ]:
self.elementTextAndroidLine.setText( "" )
self.elementDescriptionAndroidLine.setText( "" )
self.elementClassAndroidLine.setText( "" )
self.elementRessourceIdAndroidLine.setText( "" )
self.elementPackageAndroidLine.setText( "" )
self.valueAndroidLine2.setText( "" )
if "text" in stepData["parameters"]:
if stepData["parameters"]["from-el-cache"]:
self.elementTextCombo.setCurrentIndex(INDEX_CACHE)
self.elementTextAndroidLine.setValidator(self.validatorAll)
elif stepData["parameters"]["from-el-alias"]:
self.elementTextCombo.setCurrentIndex(INDEX_ALIAS)
self.elementTextAndroidLine.setValidator(self.validatorUpper)
else:
self.elementTextCombo.setCurrentIndex(INDEX_TEXT)
self.elementTextAndroidLine.setValidator(self.validatorAll)
self.elementTextAndroidLine.setText ( stepData["parameters"]["text"] )
if "description" in stepData["parameters"]:
self.elementDescriptionAndroidLine.setText( stepData["parameters"]["description"] )
if "class" in stepData["parameters"]:
self.elementClassAndroidLine.setText( stepData["parameters"]["class"] )
if "ressource" in stepData["parameters"]:
self.elementRessourceIdAndroidLine.setText( stepData["parameters"]["ressource"] )
if "package" in stepData["parameters"]:
self.elementPackageAndroidLine.setText( stepData["parameters"]["package"] )
if "new-text" in stepData["parameters"]:
self.valueAndroidLine2.setText( stepData["parameters"]["new-text"] )
if self.actionsAndroidComboBox.currentText() == GuiSteps.ANDROID_DRAG_ELEMENT:
if "x" in stepData["parameters"]:
self.endxAndroidLine.setText( stepData["parameters"]["x"] )
if "y" in stepData["parameters"]:
self.endyAndroidLine.setText( stepData["parameters"]["y"] )
if self.actionsAndroidComboBox.currentText() == GuiSteps.ANDROID_TYPE_TEXT_ELEMENT:
if stepData["parameters"]["from-cache"]:
self.valueAndroidCombo2.setCurrentIndex(INDEX_CACHE)
self.valueAndroidLine2.setValidator(self.validatorAll)
elif stepData["parameters"]["from-alias"]:
self.valueAndroidCombo2.setCurrentIndex(INDEX_ALIAS)
self.valueAndroidLine2.setValidator(self.validatorUpper)
else:
self.valueAndroidCombo2.setCurrentIndex(INDEX_TEXT)
self.valueAndroidLine2.setValidator(self.validatorAll)
if self.actionsAndroidComboBox.currentText() == GuiSteps.ANDROID_GET_TEXT_ELEMENT:
self.valueTextCacheGlobalLine.setText ( stepData["parameters"]["cache-key"] )
if self.actionsAndroidComboBox.currentText() in [ GuiSteps.ANDROID_CLICK_POSITION]:
if "x" in stepData["parameters"]:
self.xAndroidLine.setText( stepData["parameters"]["x"] )
if "y" in stepData["parameters"]:
self.yAndroidLine.setText( stepData["parameters"]["y"] )
if self.actionsAndroidComboBox.currentText() in [ GuiSteps.ANDROID_DRAG_POSITION, GuiSteps.ANDROID_SWIPE_POSITION]:
if "start-x" in stepData["parameters"]:
self.startXAndroidLine.setText( stepData["parameters"]["start-x"] )
if "start-y" in stepData["parameters"]:
self.startYAndroidLine.setText( stepData["parameters"]["start-y"] )
if "stop-x" in stepData["parameters"]:
self.stopXAndroidLine.setText( stepData["parameters"]["stop-x"] )
if "stop-y" in stepData["parameters"]:
self.stopYAndroidLine.setText( stepData["parameters"]["stop-y"] )
if self.actionsAndroidComboBox.currentText() == GuiSteps.ANDROID_TYPE_KEYCODE:
self.codeAndroidLine.setText( stepData["misc"] )
if self.actionsAndroidComboBox.currentText() in [ GuiSteps.ANDROID_TYPE_SHORTCUT ]:
# set default
for i in xrange(self.shortcutAndroidComboBox.count()):
item_text = self.shortcutAndroidComboBox.itemText(i)
if unicode(stepData["misc"]) == unicode(item_text):
self.shortcutAndroidComboBox.setCurrentIndex(i)
break
class LDSControls(QFrame):
STATIC_IMG = ('error_static.png','linz_static.png','busy_static.png','clean_static.png')
ANIM_IMG = ('error.gif','linz.gif','layer.gif','clean.gif')
IMG_SPEED = 100
IMG_WIDTH = 64
IMG_HEIGHT = 64
MAX_WD = 450
GD_PATH = os.path.abspath(os.path.join(os.path.dirname(__file__), '../../../../bin/gdal/gdal-data'))
STATUS = LU.enum('ERROR','IDLE','BUSY','CLEAN')
def __init__(self,parent):
super(LDSControls, self).__init__()
self.parent = parent
self.initConf()
self.initEPSG()
self.initUI()
def initConf(self):
'''Read files in conf dir ending in conf'''
self.cflist = ConfigInitialiser.getConfFiles()
#self.imgset = self.STATIC_IMG if ConfigWrapper().readDSProperty('Misc','indicator')=='static' else self.ANIM_IMG
#self.imgset = self.STATIC_IMG if self.parent.confconn.tp.src.confwrap.readDSProperty('Misc','indicator')=='static' else self.ANIM_IMG
sep = self.parent.confconn.reg.openEndPoint(self.parent.confconn.SRCNAME,self.parent.confconn.uconf)
self.imgset = self.STATIC_IMG if sep.confwrap.readDSProperty('Misc','indicator')=='static' else self.ANIM_IMG
self.parent.confconn.reg.closeEndPoint(self.parent.confconn.SRCNAME)
def initEPSG(self):
'''Read GDAL EPSG files, splitting by NZ(RSR) and RestOfTheWorld'''
gcsf = gdal.FindFile('gdal','gcs.csv')
if not gcsf:
gcsf = os.path.join(self.GD_PATH,'gcs.csv')
pcsf = gdal.FindFile('gdal','pcs.csv')
if not pcsf:
pcsf = os.path.join(self.GD_PATH,'pcs.csv')
gcs = ConfigInitialiser.readCSV(gcsf)
pcs = ConfigInitialiser.readCSV(pcsf)
self.nzlsr = [(e[0],e[0]+' - '+e[3]) for e in gcs if 'NZGD' in e[1] or 'RSRGD' in e[1]] \
+ [(e[0],e[0]+' - '+e[1]) for e in pcs if 'NZGD' in e[1] or 'RSRGD' in e[1]]
self.rowsr = [(e[0],e[0]+' - '+e[3]) for e in gcs if 'NZGD' not in e[1] and 'RSRGD' not in e[1]] \
+ [(e[0],e[0]+' - '+e[1]) for e in pcs if 'NZGD' not in e[1] and 'RSRGD' not in e[1]]
def initUI(self):
# 0 1 2 3 4 5 6 7 8
#'destname','lgselect','layer','uconf','group','epsg','fd','td','int'
#self.rdest,rlgselect,self.rlayer,ruconf,self.rgroup,repsg,rfd,rtd,rint = readlist
QToolTip.setFont(QFont('SansSerif', 10))
#labels
destLabel = QLabel('Destination')
lgLabel = QLabel('Group/Layer')
epsgLabel = QLabel('EPSG')
fromDateLabel = QLabel('From Date')
toDateLabel = QLabel('To Date')
confLabel = QLabel('User Config')
self.view = QLabel()
self.view.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.view.setAlignment(Qt.AlignCenter)
self.confcombo = QComboBox(self)
self.confcombo.setToolTip('Enter your user config name (file) here')
self.confcombo.addItems(self.cflist)
self.confcombo.setEditable(False)
#self.confcombo.currentIndexChanged.connect(self.doLGEditUpdate)
#combos
self.lgcombo = QComboBox(self)
self.lgcombo.setMaximumWidth(self.MAX_WD)
self.lgcombo.setDuplicatesEnabled(False)
#self.lgcombo.setInsertPolicy(QComboBox.InsertAlphabetically)#?doesnt seem to work
self.lgcombo.setToolTip('Select either Layer or Group entry')
self.lgcombo.setEditable(False)
self.sepindex = None
#self.updateLGValues()
self.epsgcombo = QComboBox(self)
self.epsgcombo.setMaximumWidth(self.MAX_WD)
self.epsgcombo.setToolTip('Setting an EPSG number here determines the output SR of the layer')
self.epsgcombo.addItems([i[1] for i in self.nzlsr])
self.epsgcombo.insertSeparator(len(self.nzlsr))
self.epsgcombo.addItems([i[1] for i in self.rowsr])
self.epsgcombo.setEditable(True)
self.epsgcombo.setEnabled(False)
self.destlist = self.getConfiguredDestinations()
self.destcombo = QComboBox(self)
self.destcombo.setToolTip('Choose the desired output type')
self.destcombo.setEditable(False)
self.destcombo.addItems(self.destlist)
#date selection
self.fromdateedit = QDateEdit()
self.fromdateedit.setCalendarPopup(True)
self.fromdateedit.setEnabled(False)
self.todateedit = QDateEdit()
self.todateedit.setCalendarPopup(True)
self.todateedit.setEnabled(False)
#check boxes
self.epsgenable = QCheckBox()
self.epsgenable.setCheckState(False)
self.epsgenable.clicked.connect(self.doEPSGEnable)
self.fromdateenable = QCheckBox()
self.fromdateenable.setCheckState(False)
self.fromdateenable.clicked.connect(self.doFromDateEnable)
self.todateenable = QCheckBox()
self.todateenable.setCheckState(False)
self.todateenable.clicked.connect(self.doToDateEnable)
self.progressbar = QProgressBar()
self.progressbar.setRange(0,100)
self.progressbar.setVisible(True)
self.progressbar.setMinimumWidth(self.MAX_WD)
#buttons
self.initbutton = QPushButton("waiting")
self.initbutton.setToolTip('Initialise the Layer Configuration')
self.initbutton.clicked.connect(self.doInitClickAction)
self.cleanbutton = QPushButton("Clean")
self.cleanbutton.setToolTip('Clean the selected layer/group from local storage')
self.cleanbutton.clicked.connect(self.doCleanClickAction)
self.replicatebutton = QPushButton("Replicate")
self.replicatebutton.setToolTip('Execute selected replication')
self.replicatebutton.clicked.connect(self.doReplicateClickAction)
self.cancelbutton = QPushButton("Close")
self.cancelbutton.setToolTip('Close the LDS Replicate application')
self.cancelbutton.clicked.connect(self.parent.close)
#set dialog values using GPR
self.updateGUIValues(self.parent.gvs)
#set onchange here otherwise we get circular initialisation
self.destcombo.currentIndexChanged.connect(self.doDestChanged)
self.confcombo.currentIndexChanged.connect(self.doConfChanged)
self.lgcombo.currentIndexChanged.connect(self.doLGComboChanged)
self.setStatus(self.STATUS.IDLE)
#grid
grid = QGridLayout()
grid.setSpacing(10)
#placement section ------------------------------------
#---------+---------+--------+---------+--------
# dest LB | | dest DD
# grp LB | | grp DD
# conf LB | | conf DD
# epsg L | epsg CB | epsg DD
# f dt L | f dt CB | f dt DD
# t td L | t td CB | t td DD
# icon | <- progress ->
# layer B | <- . -> |repl B | clean B | close B
#---------+---------+--------+---------+--------
grid.addWidget(destLabel, 1, 0)
grid.addWidget(self.destcombo, 1, 2)
#grid.addWidget(layerLabel, 2, 0)
grid.addWidget(lgLabel, 2, 0)
grid.addWidget(self.lgcombo, 2, 2)
grid.addWidget(confLabel, 3, 0)
grid.addWidget(self.confcombo, 3, 2)
#grid.addWidget(groupLabel, 4, 0)
#grid.addWidget(self.groupEdit, 4, 2)
grid.addWidget(epsgLabel, 5, 0)
grid.addWidget(self.epsgenable, 5, 1)
grid.addWidget(self.epsgcombo, 5, 2)
grid.addWidget(fromDateLabel, 6, 0)
grid.addWidget(self.fromdateenable, 6, 1)
grid.addWidget(self.fromdateedit, 6, 2)
grid.addWidget(toDateLabel, 7, 0)
grid.addWidget(self.todateenable, 7, 1)
grid.addWidget(self.todateedit, 7, 2)
hbox3 = QHBoxLayout()
hbox3.addWidget(self.view)
hbox3.addStretch(1)
hbox3.addWidget(self.progressbar)
#hbox3.addLayout(vbox2)
#hbox3.addLayout(vbox3)
hbox4 = QHBoxLayout()
hbox4.addWidget(self.initbutton)
hbox4.addStretch(1)
hbox4.addWidget(self.replicatebutton)
hbox4.addWidget(self.cleanbutton)
hbox4.addWidget(self.cancelbutton)
vbox = QVBoxLayout()
#vbox.addStretch(1)
vbox.addLayout(grid)
vbox.addLayout(hbox3)
vbox.addLayout(hbox4)
self.setLayout(vbox)
#def setProgress(self,pct):
# self.progressbar.setValue(pct)
def setStatus(self,status,message='',tooltip=None):
'''Sets indicator icon and statusbar message'''
self.parent.statusbar.showMessage(message)
self.parent.statusbar.setToolTip(tooltip if tooltip else '')
#progress
loc = os.path.abspath(os.path.join(IMG_LOC,self.imgset[status]))
#loc = os.path.abspath(os.path.join(os.path.dirname(__file__),self.parent.IMG_LOC,self.imgset[status]))
self.progressbar.setVisible(status in (self.STATUS.BUSY, self.STATUS.CLEAN))
#icon
anim = QMovie(loc, QByteArray(), self)
anim.setScaledSize(QSize(self.IMG_WIDTH,self.IMG_HEIGHT))
anim.setCacheMode(QMovie.CacheAll)
anim.setSpeed(self.IMG_SPEED)
self.view.clear()
self.view.setMovie(anim)
anim.start()
self.view.repaint()
QApplication.processEvents(QEventLoop.AllEvents)
def mainWindowEnable(self,enable=True):
cons = (self.lgcombo, self.confcombo, self.destcombo,
self.initbutton, self.replicatebutton, self.cleanbutton, self.cancelbutton,
self.epsgenable,self.fromdateenable,self.todateenable,
self.parent.menubar)
for c in cons:
c.setEnabled(enable)
if enable:
self.epsgcombo.setEnabled(self.epsgenable.checkState())
self.fromdateedit.setEnabled(self.fromdateenable.checkState())
self.todateedit.setEnabled(self.todateenable.checkState())
else:
self.epsgcombo.setEnabled(False)
self.fromdateedit.setEnabled(False)
self.todateedit.setEnabled(False)
QApplication.restoreOverrideCursor() if enable else QApplication.setOverrideCursor(QCursor(Qt.WaitCursor))
def refreshLGCombo(self):
'''Re index LG combobox since a refreshLG call (new dest?) will usually mean new groups'''
self.lgcombo.clear()
self.lgcombo.addItems([i[2] for i in self.parent.confconn.lglist])
#NOTE the separator consumes an index, if not clearing the combobox selectively remove the old sepindex (assumes g preceeds l)
#if self.sepindex:
# self.lgcombo.removeItem(self.sepindex)
self.sepindex = [i[0] for i in self.parent.confconn.lglist].count(LORG.GROUP)
self.lgcombo.insertSeparator(self.sepindex)
def updateLGValues(self,uconf,lgval,dest):
'''Sets the values displayed in the Layer/Group combo'''
#because we cant seem to sort combobox entries and want groups at the top, clear and re-add
#TRACE#
#pdb.set_trace()
sf = None
try:
self.parent.confconn.initConnections(uconf,lgval,dest)
except Exception as e:
sf=1
ldslog.error('Error Updating UC Values. '+str(e))
if sf:
self.setStatus(self.STATUS.ERROR,'Error Updating UC Values', str(e))
else:
self.setStatus(self.STATUS.IDLE)
self.refreshLGCombo()
def centre(self):
qr = self.frameGeometry()
cp = QDesktopWidget().availableGeometry().center()
qr.moveCenter(cp)
self.move(qr.topLeft())
def gprParameters(self,rdest):
'''Zip default and GPR values'''
return [x if LU.assessNone(x) else y for x,y in zip(self.parent.gpr.readsec(rdest),self.parent.DEF_RVALS[1:])]
def getLCE(self,ln):
'''Read layer parameters'''
dep = self.parent.confconn.reg.openEndPoint(self.parent.confconn.destname,self.parent.confconn.uconf)
#sep = self.parent.confconn.reg.openEndPoint('WFS',self.parent.confconn.uconf)
self.parent.confconn.reg.setupLayerConfig(self.parent.confconn.tp,None,dep,initlc=False)
lce = dep.getLayerConf().readLayerParameters(ln)
#self.parent.confconn.reg.closeEndPoint('WFS')
self.parent.confconn.reg.closeEndPoint(self.parent.confconn.destname)
sep,dep = None,None
return lce
def doDestChanged(self):
'''Read the destname parameter and fill dialog with matching GPR values'''
rdest = str(self.destlist[self.destcombo.currentIndex()])
rvals = self.gprParameters(rdest)
self.updateGUIValues([rdest]+rvals)
def doConfChanged(self):
'''Read the user conf parameter and fill dialog with matching GPR values'''
rdest = str(self.destlist[self.destcombo.currentIndex()])
rlg,_,rep,rfd,rtd = self.gprParameters(rdest)
ruc = str(self.cflist[self.confcombo.currentIndex()])
self.updateGUIValues((rdest,rlg,ruc,rep,rfd,rtd))
def doLGComboChanged(self):
'''Read the layer/group value and change epsg to layer or gpr match'''
#get a matching LG entry and test whether its a layer or group
#lgi = self.parent.confconn.getLayerGroupIndex(self.lgcombo.currentText().toUtf8().data())
lgi = self.parent.confconn.getLayerGroupIndex(LQ.readWidgetText(self.lgcombo.currentText()))
#lgi can be none if we init a new group, in which case we use the GPR value
if lgi:
lge = self.parent.confconn.lglist[lgi]
lce = self.getLCE(lge[1]) if lge[0]==LORG.LAYER else None
else:
lce = None
#look for filled layer conf epsg OR use prefs stored in gpr
if lce and LU.assessNone(lce.epsg):
epsgval = lce.epsg
else:
rdest = str(self.destlist[self.destcombo.currentIndex()])
_,_,epsgval,_,_ = self.gprParameters(rdest)
epsgindex = [i[0] for i in self.nzlsr+[(0,0)]+self.rowsr].index(epsgval)
if self.epsgcombo.currentIndex() != epsgindex:
self.epsgcombo.setCurrentIndex(int(epsgindex))
def updateGUIValues(self,readlist):
'''Fill dialog values from provided list'''
#TODO. Remove circular references when setCurrentIndex() triggers do###Changed()
#Read user input
rdest,self.rlgval,ruconf,repsg,rfd,rtd = readlist
#--------------------------------------------------------------------
#Destination Menu
selecteddest = LU.standardiseDriverNames(rdest)
if selecteddest not in self.destlist:
self.destlist = self.getConfiguredDestinations()
self.destcombo.addItem(selecteddest)
destindex = self.destlist.index(selecteddest) if selecteddest else 0
if self.destcombo.currentIndex() != destindex:
self.destcombo.setCurrentIndex(destindex)
#InitButton
self.initbutton.setText('Layer Select')
#Config File
confindex = 0
if LU.assessNone(ruconf):
ruconf = ruconf.split('.')[0]
if ruconf not in self.cflist:
self.cflist += [ruconf,]
self.confcombo.addItem(ruconf)
confindex = self.cflist.index(ruconf)
if self.confcombo.currentIndex() != confindex:
self.confcombo.setCurrentIndex(confindex)
#self.confEdit.setText(ruconf if LU.assessNone(ruconf) else '')
#Layer/Group Selection
self.updateLGValues(ruconf,self.rlgval,rdest)
lgindex = None
if LU.assessNone(self.rlgval):
#index of list value
lgindex = self.parent.confconn.getLayerGroupIndex(self.rlgval,col=1)
if LU.assessNone(lgindex):
#advance by 1 for sep
lgindex += 1 if lgindex>self.sepindex else 0
else:
#using the separator index sets the combo to blank
lgindex = self.sepindex
if self.lgcombo.currentIndex() != lgindex:
self.lgcombo.setCurrentIndex(lgindex)
#self.doLGEditUpdate()
#EPSG
# user > layerconf
#useepsg = LU.precedence(repsg, lce.epsg if lce else None, None)
epsgindex = [i[0] for i in self.nzlsr+[(None,None)]+self.rowsr].index(repsg)
if self.epsgcombo.currentIndex() != epsgindex:
self.epsgcombo.setCurrentIndex(epsgindex)
#epsgedit = self.epsgcombo.lineEdit()
#epsgedit.setText([e[1] for e in self.nzlsr+self.rowsr if e[0]==repsg][0])
#epsgedit.setText([e for e in self.nzlsr+self.rowsr if re.match('^\s*(\d+).*',e).group(1)==repsg][0])
#To/From Dates
if LU.assessNone(rfd):
self.fromdateedit.setDate(QDate(int(rfd[0:4]),int(rfd[5:7]),int(rfd[8:10])))
else:
early = DataStore.EARLIEST_INIT_DATE
self.fromdateedit.setDate(QDate(int(early[0:4]),int(early[5:7]),int(early[8:10])))
if LU.assessNone(rtd):
self.todateedit.setDate(QDate(int(rtd[0:4]),int(rtd[5:7]),int(rtd[8:10])))
else:
today = DataStore.getCurrent()
self.todateedit.setDate(QDate(int(today[0:4]),int(today[5:7]),int(today[8:10])))
#Internal/External CheckBox
# if LU.assessNone(rint):
# self.internalTrigger.setChecked(rint.lower()==DataStore.CONF_INT)
# else:
# self.internalTrigger.setChecked(DataStore.DEFAULT_CONF==DataStore.CONF_INT)
def getConfiguredDestinations(self):
defml = ['',]+DataStore.DRIVER_NAMES.values()
return [d for d in self.parent.gpr.getDestinations() if d in defml]
def doEPSGEnable(self):
self.epsgcombo.setEnabled(self.epsgenable.isChecked())
def doFromDateEnable(self):
self.fromdateedit.setEnabled(self.fromdateenable.isChecked())
def doToDateEnable(self):
self.todateedit.setEnabled(self.todateenable.isChecked())
def readParameters(self):
'''Read values out of dialogs'''
destination = LU.assessNone(str(self.destlist[self.destcombo.currentIndex()]))
#lgindex = self.parent.confconn.getLayerGroupIndex(self.lgcombo.currentText().toUtf8().data())
lgindex = self.parent.confconn.getLayerGroupIndex(LQ.readWidgetText(self.lgcombo.currentText()))
#NB need to test for None explicitly since zero is a valid index
lgval = self.parent.confconn.lglist[lgindex][1] if LU.assessNone(lgindex) else None
#uconf = LU.standardiseUserConfigName(str(self.confcombo.lineEdit().text()))
#uconf = str(self.confcombo.lineEdit().text())
uconf = str(self.cflist[self.confcombo.currentIndex()])
ee = self.epsgenable.isChecked()
epsg = None if ee is False else re.match('^\s*(\d+).*',str(self.epsgcombo.lineEdit().text())).group(1)
fe = self.fromdateenable.isChecked()
te = self.todateenable.isChecked()
fd = None if fe is False else str(self.fromdateedit.date().toString('yyyy-MM-dd'))
td = None if te is False else str(self.todateedit.date().toString('yyyy-MM-dd'))
return destination,lgval,uconf,epsg,fe,te,fd,td
def doInitClickAction(self):
'''Initialise the LC on LC-button-click, action'''
try:
try:
self.setStatus(self.STATUS.BUSY,'Opening Layer-Config Editor')
self.progressbar.setValue(0)
self.parent.runLayerConfigAction()
finally:
self.setStatus(self.STATUS.IDLE,'Ready')
except Exception as e:
self.setStatus(self.STATUS.ERROR,'Error in Layer-Config',str(sys.exc_info()))#e))
def doCleanClickAction(self):
'''Set clean anim and run clean'''
#lgo = self.lgcombo.currentText().toUtf8().data()
lgo = LQ.readWidgetText(self.lgcombo.currentText())
try:
self.setStatus(self.STATUS.CLEAN,'Running Clean '+lgo)
self.progressbar.setValue(0)
self.runReplicationScript(True)
except Exception as e:
self.setStatus(self.STATUS.ERROR,'Failed Clean of '+lgo,str(sys.exc_info()))#e))
def doReplicateClickAction(self):
'''Set busy anim and run repl'''
lgo = self.lgcombo.currentText()#.toUtf8().data()#only used for error messages
try:
self.setStatus(self.STATUS.BUSY,'Running Replicate '+lgo)
self.progressbar.setValue(0)
self.runReplicationScript(False)
except Exception as e:
self.setStatus(self.STATUS.ERROR,'Failed Replication of '+lgo,str(sys.exc_info()))#e))
def runReplicationScript(self,clean=False):
'''Run the layer/group repliction script'''
destination,lgval,uconf,epsg,fe,te,fd,td = self.readParameters()
uconf_path = LU.standardiseUserConfigName(uconf)
destination_path = LU.standardiseLayerConfigName(destination)
destination_driver = LU.standardiseDriverNames(destination)
if not os.path.exists(uconf_path):
self.userConfMessage(uconf_path)
return
elif not MainFileReader(uconf_path).hasSection(destination_driver):
self.userConfMessage(uconf_path,destination_driver)
return
#-----------------------------------------------------
#'destname','layer','uconf','group','epsg','fd','td','int'
self.parent.gpr.write((destination_driver,lgval,uconf,epsg,fd,td))
ldslog.info(u'dest={0}, lg={1}, conf={2}, epsg={3}'.format(destination_driver,lgval,uconf,epsg))
ldslog.info('fd={0}, td={1}, fe={2}, te={3}'.format(fd,td,fe,te))
lgindex = self.parent.confconn.getLayerGroupIndex(lgval,col=1)
#lorg = self.parent.confconn.lglist[lgindex][0]
#----------don't need lorg in TP anymore but it is useful for sorting/counting groups
#self.parent.confconn.tp.setLayerOrGroup(lorg)
self.parent.confconn.tp.setLayerGroupValue(lgval)
if self.fromdateenable.isChecked(): self.parent.confconn.tp.setFromDate(fd)
if self.todateenable.isChecked(): self.parent.confconn.tp.setToDate(td)
self.parent.confconn.tp.setUserConf(uconf)
if self.epsgenable: self.parent.confconn.tp.setEPSG(epsg)
#because clean state persists in TP
if clean:
self.parent.confconn.tp.setCleanConfig()
else:
self.parent.confconn.tp.clearCleanConfig()
#(re)initialise the data source since uconf may have changed
#>>#self.parent.confconn.tp.src = self.parent.confconn.initSourceWrapper()
#--------------------------
###ep = self.parent.confconn.reg.openEndPoint(self.parent.confconn.destname,self.parent.confconn.uconf)
###self.parent.confconn.reg.closeEndPoint(self.parent.confconn.destname)
###ep = None
#Open ProcessRunner and run with TP(proc)/self(gui) instances
#HACK temp add of dest_drv to PR call
try:
#TODO. Test for valid LC first
self.tpr = ProcessRunner(self,destination_driver)
except Exception as e:
ldslog.error('Cannot create ProcessRunner {}. NB Possible missing Layer Config {}'.format(str(e),destination_path))
self.layerConfMessage(destination_path)
return
#If PR has been successfully created we must vave a valid dst
self.tpr.start()
def quitProcessRunner(self):
self.tpr.join()
self.tpr.quit()
self.trp = None
def userConfMessage(self,uconf,secname=None):
ucans = QMessageBox.warning(self, 'User Config Missing/Incomplete',
'Specified User-Config file, '+str(uconf)+' does not exist' if secname is None else 'User-Config file does not contain '+str(secname)+' section',
'Back','Initialise User Config')
if not ucans:
#Retry
ldslog.warn('Retry specifying UC')
#self.confcombo.setCurrentIndex(0)
return
#Init
ldslog.warn('Reset User Config Wizard')
self.parent.runWizardAction()
def layerConfMessage(self,dest):
lcans = QMessageBox.warning(self, 'Layer Config Missing',
'Required Layer-Config file, '+str(dest)+' does not exist',
'Back','Run Layer Select')
if not lcans:
#Retry
ldslog.warn('Retry specifying LC')
#self.destcombo.setCurrentIndex(0)
return
#Init
ldslog.warn('Reset Layer Config')
self.doInitClickAction()
class WSystem(QWidget, Logger.ClassLogger):
"""
System widget
"""
# action, description, misc, parameters
AddStep = pyqtSignal(str, str, str, dict)
UpdateStep = pyqtSignal(str, str, str, dict)
CancelEdit = pyqtSignal()
def __init__(self, parent):
"""
Constructor
"""
QWidget.__init__(self)
self.createActions()
self.createWidgets()
self.createToolbar()
self.createConnections()
def createActions(self):
"""
Create qt actions
"""
self.addAction = QPushButton(QIcon(":/add_black.png"), '&Add Action',
self)
self.addAction.setMinimumHeight(40)
self.addAction.setMaximumWidth(150)
self.cancelAction = QtHelper.createAction(self,
"&Cancel",
self.cancelStep,
icon=QIcon(":/undo.png"),
tip='Cancel update')
self.cancelAction.setEnabled(False)
self.optionsAction = QtHelper.createAction(
self,
"&",
self.openOptions,
icon=QIcon(":/system-small.png"),
tip='System options')
def openOptions(self):
"""
Open options dialog
"""
if self.optionsDialog.exec_() == QDialog.Accepted:
pass
def createWidgets(self):
"""
Create qt widgets
"""
self.optionsDialog = OptionsDialog(self)
self.validatorUpper = ValidatorUpper(self)
self.validatorAll = ValidatorAll(self)
self.validatorInt = QIntValidator(self)
self.actionsComboBox = QComboBox(self)
self.actionsComboBox.setMinimumHeight(40)
for i in xrange(len(GuiSteps.ACTION_SYSTEM_DESCR)):
if not len(GuiSteps.ACTION_SYSTEM_DESCR[i]):
self.actionsComboBox.insertSeparator(i + 1)
else:
el = GuiSteps.ACTION_SYSTEM_DESCR[i].keys()
self.actionsComboBox.addItem(list(el)[0])
self.labelActionDescr = QLabel(self)
self.labelActionDescr.hide()
self.descriptionLine = QLineEdit(self)
self.descriptionLine.setPlaceholderText("Step purpose description")
self.descriptionLine.hide()
actionsLayout = QHBoxLayout()
actionsLayout.addWidget(self.actionsComboBox)
actionLayout1 = QGridLayout()
actionLayout1.addLayout(actionsLayout, 0, 1)
self.createWidgetSession()
self.createWidgetText()
self.createWidgetShortcut()
self.createWidgetScreen()
actionLayout2 = QGridLayout()
actionLayout2.addWidget(self.sessionGroup, 1, 0)
actionLayout2.addWidget(self.textGroup, 1, 0)
actionLayout2.addWidget(self.shortcutGroup, 1, 0)
actionLayout2.addWidget(self.screenGroup, 1, 0)
font = QFont()
font.setBold(True)
labelAct = QLabel(self.tr("Action: "))
labelAct.setFont(font)
self.arrowLabel = QLabel("")
self.arrowLabel.setPixmap(
QPixmap(":/arrow-right.png").scaledToWidth(32))
self.arrowLabel2 = QLabel("")
self.arrowLabel2.setPixmap(
QPixmap(":/arrow-right.png").scaledToWidth(32))
layoutFinal = QHBoxLayout()
layoutFinal.addWidget(labelAct)
layoutFinal.addLayout(actionLayout1)
layoutFinal.addWidget(self.arrowLabel)
layoutFinal.addLayout(actionLayout2)
layoutFinal.addWidget(self.arrowLabel2)
layoutFinal.addWidget(self.addAction)
layoutFinal.addStretch(1)
self.setLayout(layoutFinal)
def createToolbar(self):
"""
Create toolbar
"""
pass
def createWidgetScreen(self):
"""
Create screen widget
"""
self.screenGroup = QGroupBox(self.tr(""))
# text
self.checkComboBox = QComboBox(self)
self.checkComboBox.addItems([
GuiSteps.OP_ANY, GuiSteps.OP_CONTAINS, GuiSteps.OP_NOTCONTAINS,
GuiSteps.OP_REGEXP, GuiSteps.OP_NOTREGEXP, GuiSteps.OP_STARTSWITH,
GuiSteps.OP_NOTSTARTSWITH, GuiSteps.OP_ENDSWITH,
GuiSteps.OP_NOTENDSWITH
])
self.screenLine = QLineEdit(self)
self.screenLine.setMinimumWidth(300)
self.screenLine.setEnabled(False)
self.screenLine.hide()
self.screenArea = QTextEdit(self)
self.screenArea.setMinimumWidth(300)
self.screenArea.setEnabled(False)
self.screenCombo = QComboBox(self)
self.screenCombo.addItems(LIST_TYPES)
self.screenCombo.setEnabled(False)
self.screenSaveCombo = QComboBox(self)
self.screenSaveCombo.addItems(["VARIABLE", "CACHE"])
self.screenSaveLine = QLineEdit(self)
self.screenSaveLine.setMinimumWidth(300)
self.screenSaveLine.setEnabled(False)
mainTextlayout = QGridLayout()
mainTextlayout.addWidget(QLabel(self.tr("Checking if the screen: ")),
0, 0)
mainTextlayout.addWidget(self.checkComboBox, 0, 1)
mainTextlayout.addWidget(QLabel(self.tr("The value:")), 1, 0)
mainTextlayout.addWidget(self.screenCombo, 1, 1)
mainTextlayout.addWidget(self.screenLine, 2, 1)
mainTextlayout.addWidget(self.screenArea, 2, 1)
mainTextlayout.addWidget(QLabel(self.tr("And save the screen in:")), 0,
2)
mainTextlayout.addWidget(self.screenSaveCombo, 1, 2)
mainTextlayout.addWidget(self.screenSaveLine, 2, 2)
self.screenGroup.setLayout(mainTextlayout)
self.screenGroup.hide()
def createWidgetText(self):
"""
Create text widget
"""
self.textGroup = QGroupBox(self.tr(""))
# text
self.textLine = QLineEdit(self)
self.textLine.setMinimumWidth(300)
self.textCombo = QComboBox(self)
self.textCombo.addItems(LIST_TYPES)
mainTextlayout = QGridLayout()
mainTextlayout.addWidget(QLabel(self.tr("Send the value:")), 0, 0)
mainTextlayout.addWidget(self.textCombo, 0, 1)
mainTextlayout.addWidget(self.textLine, 0, 2)
self.textGroup.setLayout(mainTextlayout)
self.textGroup.hide()
def createWidgetShortcut(self):
"""
Create shortcut widget
"""
self.shortcutGroup = QGroupBox(self.tr(""))
# text
self.shortcutComboBox = QComboBox()
self.shortcutComboBox.addItems([KEY_CTRLC, KEY_ENTER])
self.shortcutComboBox.setMinimumWidth(300)
mainTextlayout = QGridLayout()
mainTextlayout.addWidget(QLabel(self.tr("Shortcut:")), 0, 0)
mainTextlayout.addWidget(self.shortcutComboBox, 0, 1)
self.shortcutGroup.setLayout(mainTextlayout)
self.shortcutGroup.hide()
def createWidgetSession(self):
"""
Create session widget
"""
self.sessionGroup = QGroupBox(self.tr(""))
# login
self.loginLine = QLineEdit(self)
self.loginLine.setMinimumWidth(300)
self.loginCombo = QComboBox(self)
self.loginCombo.addItems(LIST_TYPES)
# password
self.pwdLine = QLineEdit(self)
self.pwdLine.setMinimumWidth(300)
self.pwdCombo = QComboBox(self)
self.pwdCombo.addItems(LIST_TYPES)
# ip
self.ipLine = QLineEdit(self)
self.ipLine.setMinimumWidth(300)
self.ipCombo = QComboBox(self)
self.ipCombo.addItems(LIST_TYPES)
# port
self.portLine = QLineEdit(self)
self.portLine.setMinimumWidth(300)
self.portLine.setText("22")
self.portLine.setValidator(self.validatorInt)
self.portCombo = QComboBox(self)
self.portCombo.addItems(LIST_TYPES)
# agent support
self.useAgent = QCheckBox("Use with agent mode")
mainTextlayout = QGridLayout()
mainTextlayout.addWidget(QLabel(self.tr("Host:")), 0, 0)
mainTextlayout.addWidget(self.ipCombo, 0, 1)
mainTextlayout.addWidget(self.ipLine, 0, 2)
mainTextlayout.addWidget(QLabel(self.tr("Port (optional):")), 1, 0)
mainTextlayout.addWidget(self.portCombo, 1, 1)
mainTextlayout.addWidget(self.portLine, 1, 2)
mainTextlayout.addWidget(QLabel(self.tr("Login:"******"Password:"******"""
Create qt connections
"""
self.actionsComboBox.currentIndexChanged.connect(self.onActionChanged)
self.addAction.clicked.connect(self.addStep)
self.ipCombo.currentIndexChanged.connect(self.onIpTypeChanged)
self.portCombo.currentIndexChanged.connect(self.onPortTypeChanged)
self.loginCombo.currentIndexChanged.connect(self.onLoginTypeChanged)
self.pwdCombo.currentIndexChanged.connect(self.onPwdTypeChanged)
self.textCombo.currentIndexChanged.connect(self.onTextTypeChanged)
self.screenCombo.currentIndexChanged.connect(self.onScreenTypeChanged)
self.checkComboBox.currentIndexChanged.connect(
self.onScreenOperatorChanged)
self.screenSaveCombo.currentIndexChanged.connect(
self.onScreenSaveChanged)
def pluginDataAccessor(self):
"""
Return data to plugin
"""
return {"data": ""}
def onPluginImport(self, dataJson):
"""
Received data from plugins
"""
if "steps" not in dataJson:
QMessageBox.warning(self, "Assistant Automation", "bad import")
return
if not isinstance(dataJson['steps'], list):
QMessageBox.warning(self, "Assistant Automation", "bad import")
return
if not ('ip' in dataJson and 'login' in dataJson
and 'password' in dataJson):
QMessageBox.warning(self, "Assistant Automation", "bad import")
return
# emit open session
parameters = {
'dest-ip': dataJson['ip'],
'dest-port': 22,
'login': dataJson['login'],
'password': dataJson['password'],
'from-cache-ip': False,
'from-alias-ip': False,
'from-cache-port': False,
'from-alias-port': False,
'from-cache-login': False,
'from-alias-login': False,
'from-cache-pwd': False,
'from-alias-pwd': False,
'agent-support': False
}
self.AddStep.emit(GuiSteps.SYSTEM_SESSION, EMPTY_VALUE, EMPTY_VALUE,
parameters)
for stp in dataJson['steps']:
if isinstance(stp, dict):
# new in v16
fromCache = False
fromAlias = False
if "type-value" in stp:
if stp["type-value"].lower() == "cache": fromCache = True
if stp["type-value"].lower() == "alias": fromAlias = True
# end of new
if stp["action-name"] == "SEND":
parameters = {
'text': stp["action-value"],
'from-cache': fromCache,
'from-alias': fromAlias
}
self.AddStep.emit(GuiSteps.SYSTEM_TEXT, EMPTY_VALUE,
EMPTY_VALUE, parameters)
elif stp["action-name"] == "EXPECT":
op = "Contains"
if stp["action-type"] == "REGEX":
op = "RegEx"
parameters = {
'value': stp["action-value"],
'from-cache': fromCache,
'from-alias': fromAlias,
'operator': op,
'to-cache': False,
'cache-key': ''
}
self.AddStep.emit(GuiSteps.SYSTEM_CHECK_SCREEN,
EMPTY_VALUE, EMPTY_VALUE, parameters)
else:
QMessageBox.warning(
self, "Assistant Automation",
"action not yet supported: %s" % stp["action-name"])
# close
self.AddStep.emit(GuiSteps.SYSTEM_CLOSE, EMPTY_VALUE, EMPTY_VALUE, {})
def onScreenOperatorChanged(self):
"""
On screen operator changed
"""
if self.checkComboBox.currentText() == GuiSteps.OP_ANY:
self.screenLine.setEnabled(False)
self.screenArea.setEnabled(False)
self.screenCombo.setEnabled(False)
else:
self.screenLine.setEnabled(True)
self.screenArea.setEnabled(True)
self.screenCombo.setEnabled(True)
def onScreenSaveChanged(self):
"""
On screen save changed
"""
if self.screenSaveCombo.currentText() == "VARIABLE":
self.screenSaveLine.setEnabled(False)
else:
self.screenSaveLine.setEnabled(True)
def onScreenTypeChanged(self):
"""
On screen type changed
"""
if self.screenCombo.currentText() in ["TEXT"]:
self.screenArea.show()
self.screenLine.hide()
else:
self.screenLine.show()
self.screenArea.hide()
if self.screenCombo.currentText() in ["CACHE"]:
self.screenLine.setValidator(self.validatorAll)
if self.screenCombo.currentText() == "ALIAS":
self.screenLine.setText(self.screenLine.text().upper())
self.screenLine.setValidator(self.validatorUpper)
def onTextTypeChanged(self):
"""
On text type changed
"""
if self.textCombo.currentText() in ["TEXT", "CACHE"]:
self.textLine.setValidator(self.validatorAll)
if self.textCombo.currentText() == "ALIAS":
self.textLine.setText(self.textLine.text().upper())
self.textLine.setValidator(self.validatorUpper)
def onLoginTypeChanged(self):
"""
On login type changed
"""
if self.loginCombo.currentText() in ["TEXT", "CACHE"]:
self.loginLine.setValidator(self.validatorAll)
if self.loginCombo.currentText() == "ALIAS":
self.loginLine.setText(self.loginLine.text().upper())
self.loginLine.setValidator(self.validatorUpper)
def onPwdTypeChanged(self):
"""
On password type changed
"""
if self.pwdCombo.currentText() in ["TEXT", "CACHE"]:
self.pwdLine.setValidator(self.validatorAll)
if self.pwdCombo.currentText() == "ALIAS":
self.pwdLine.setText(self.pwdLine.text().upper())
self.pwdLine.setValidator(self.validatorUpper)
def onIpTypeChanged(self):
"""
On ip type changed
"""
if self.ipCombo.currentText() in ["TEXT", "CACHE"]:
self.ipLine.setValidator(self.validatorAll)
if self.ipCombo.currentText() == "ALIAS":
self.ipLine.setText(self.ipLine.text().upper())
self.ipLine.setValidator(self.validatorUpper)
def onPortTypeChanged(self):
"""
On port type changed
"""
if self.portCombo.currentText() in ["TEXT"]:
self.portLine.setText("22")
self.portLine.setValidator(self.validatorInt)
if self.portCombo.currentText() in ["CACHE"]:
self.portLine.setValidator(self.validatorAll)
if self.portCombo.currentText() == "ALIAS":
self.portLine.setText(self.portLine.text().upper())
self.portLine.setValidator(self.validatorUpper)
def onActionChanged(self):
"""
On action changed
"""
descr = 'No description available!'
i = 0
for el in GuiSteps.ACTION_SYSTEM_DESCR:
if isinstance(el, dict):
if self.actionsComboBox.currentText() in el:
descr = GuiSteps.ACTION_SYSTEM_DESCR[i][
self.actionsComboBox.currentText()]
break
i += 1
self.labelActionDescr.setText("%s\n" % descr)
if self.actionsComboBox.currentText() in [GuiSteps.SYSTEM_SESSION]:
self.sessionGroup.show()
self.textGroup.hide()
self.shortcutGroup.hide()
self.screenGroup.hide()
self.arrowLabel.show()
self.arrowLabel2.show()
elif self.actionsComboBox.currentText() in [GuiSteps.SYSTEM_CLOSE]:
self.sessionGroup.hide()
self.textGroup.hide()
self.shortcutGroup.hide()
self.screenGroup.hide()
self.arrowLabel.hide()
self.arrowLabel2.show()
elif self.actionsComboBox.currentText() in [
GuiSteps.SYSTEM_CLEAR_SCREEN
]:
self.sessionGroup.hide()
self.textGroup.hide()
self.shortcutGroup.hide()
self.screenGroup.hide()
self.arrowLabel.hide()
self.arrowLabel2.show()
elif self.actionsComboBox.currentText() in [GuiSteps.SYSTEM_TEXT]:
self.sessionGroup.hide()
self.textGroup.show()
self.shortcutGroup.hide()
self.screenGroup.hide()
self.arrowLabel.show()
self.arrowLabel2.show()
elif self.actionsComboBox.currentText() in [GuiSteps.SYSTEM_SHORTCUT]:
self.sessionGroup.hide()
self.textGroup.hide()
self.shortcutGroup.show()
self.screenGroup.hide()
self.arrowLabel.show()
self.arrowLabel2.show()
elif self.actionsComboBox.currentText() in [
GuiSteps.SYSTEM_CHECK_SCREEN
]:
self.sessionGroup.hide()
self.textGroup.hide()
self.shortcutGroup.hide()
self.screenGroup.show()
self.arrowLabel.show()
self.arrowLabel2.show()
else:
self.sessionGroup.hide()
self.textGroup.hide()
self.shortcutGroup.hide()
self.screenGroup.hide()
self.arrowLabel.hide()
self.arrowLabel2.hide()
def addStep(self):
"""
Add step
"""
action = self.actionsComboBox.currentText()
descr = self.descriptionLine.text()
descr = unicode(descr).replace('"', '')
signal = self.AddStep
if self.cancelAction.isEnabled():
signal = self.UpdateStep
if action in [GuiSteps.SYSTEM_SESSION]:
fromCacheIp = False
if self.ipCombo.currentText() == "CACHE": fromCacheIp = True
fromAliasIp = False
if self.ipCombo.currentText() == "ALIAS": fromAliasIp = True
fromCachePort = False
if self.portCombo.currentText() == "CACHE": fromCachePort = True
fromAliasPort = False
if self.portCombo.currentText() == "ALIAS": fromAliasPort = True
fromCacheLogin = False
if self.loginCombo.currentText() == "CACHE": fromCacheLogin = True
fromAliasLogin = False
if self.loginCombo.currentText() == "ALIAS": fromAliasLogin = True
fromCachePwd = False
if self.pwdCombo.currentText() == "CACHE": fromCachePwd = True
fromAliasPwd = False
if self.pwdCombo.currentText() == "ALIAS": fromAliasPwd = True
newIp = self.ipLine.text()
if not len(newIp):
QMessageBox.warning(self, "Assistant",
"Please to provide a ip!")
return
newPort = self.portLine.text()
if not len(newPort):
QMessageBox.warning(self, "Assistant",
"Please to provide a port!")
return
newLogin = self.loginLine.text()
if not len(newLogin):
QMessageBox.warning(self, "Assistant",
"Please to provide a login!")
return
newPwd = self.pwdLine.text()
agentSupport = "False"
if self.useAgent.isChecked(): agentSupport = "True"
parameters = {
'dest-ip': newIp,
'dest-port': newPort,
'login': newLogin,
'password': newPwd,
'from-cache-ip': fromCacheIp,
'from-alias-ip': fromAliasIp,
'from-cache-port': fromCachePort,
'from-alias-port': fromAliasPort,
'from-cache-login': fromCacheLogin,
'from-alias-login': fromAliasLogin,
'from-cache-pwd': fromCachePwd,
'from-alias-pwd': fromAliasPwd,
'agent-support': agentSupport
}
signal.emit(str(action), unicode(descr), EMPTY_VALUE, parameters)
elif action in [GuiSteps.SYSTEM_CLOSE]:
signal.emit(str(action), unicode(descr), EMPTY_VALUE, {})
elif action in [GuiSteps.SYSTEM_CLEAR_SCREEN]:
signal.emit(str(action), unicode(descr), EMPTY_VALUE, {})
elif action in [GuiSteps.SYSTEM_TEXT]:
fromCache = False
if self.textCombo.currentText() == "CACHE": fromCache = True
fromAlias = False
if self.textCombo.currentText() == "ALIAS": fromAlias = True
newText = self.textLine.text()
if not len(newText):
QMessageBox.warning(self, "Assistant",
"Please to provide text!")
return
parameters = {
'text': newText,
'from-cache': fromCache,
'from-alias': fromAlias
}
signal.emit(str(action), unicode(descr), EMPTY_VALUE, parameters)
elif action in [GuiSteps.SYSTEM_SHORTCUT]:
newShortcut = self.shortcutComboBox.currentText()
parameters = {'shortcut': newShortcut}
signal.emit(str(action), unicode(descr), EMPTY_VALUE, parameters)
elif action in [GuiSteps.SYSTEM_CHECK_SCREEN]:
op = self.checkComboBox.currentText()
fromCache = False
if self.screenCombo.currentText() == "CACHE": fromCache = True
fromAlias = False
if self.screenCombo.currentText() == "ALIAS": fromAlias = True
toCache = False
if self.screenSaveCombo.currentText() == "CACHE": toCache = True
keyCache = self.screenSaveLine.text()
newText = ""
if op != GuiSteps.OP_ANY:
if fromCache or fromAlias:
newText = self.screenLine.text()
else:
newText = self.screenArea.toPlainText()
if not len(newText):
QMessageBox.warning(self, "Assistant",
"Please to provide value to search!")
return
parameters = {
'value': newText,
'from-cache': fromCache,
'from-alias': fromAlias,
'operator': op,
'to-cache': toCache,
'cache-key': keyCache
}
signal.emit(str(action), unicode(descr), EMPTY_VALUE, parameters)
else:
signal.emit(str(action), unicode(descr), EMPTY_VALUE, {})
def cancelStep(self):
"""
Cancel step
"""
self.addAction.setText("&Add")
buttonFont = QFont()
buttonFont.setBold(False)
self.addAction.setFont(buttonFont)
self.cancelAction.setEnabled(False)
self.CancelEdit.emit()
def finalizeUpdate(self):
"""
Finalize the update of the step
"""
self.addAction.setText("&Add Action")
buttonFont = QFont()
buttonFont.setBold(False)
self.addAction.setFont(buttonFont)
self.cancelAction.setEnabled(False)
def editStep(self, stepData):
"""
Edit step
"""
self.addAction.setText("&Update")
buttonFont = QFont()
buttonFont.setBold(True)
self.addAction.setFont(buttonFont)
self.cancelAction.setEnabled(True)
# set the current value for actions combo
for i in xrange(self.actionsComboBox.count()):
item_text = self.actionsComboBox.itemText(i)
if unicode(stepData["action"]) == unicode(item_text):
self.actionsComboBox.setCurrentIndex(i)
break
# and then refresh options
self.onActionChanged()
# finally fill all fields
self.descriptionLine.setText(stepData["description"])
if self.actionsComboBox.currentText() in [GuiSteps.SYSTEM_SESSION]:
self.ipLine.setText(stepData["parameters"]["dest-ip"])
self.portLine.setText("%s" % stepData["parameters"]["dest-port"])
self.loginLine.setText(stepData["parameters"]["login"])
self.pwdLine.setText(stepData["parameters"]["password"])
if stepData["parameters"]["from-cache-ip"]:
self.ipLine.setValidator(self.validatorAll)
self.ipCombo.setCurrentIndex(INDEX_CACHE)
elif stepData["parameters"]["from-alias-ip"]:
self.ipLine.setValidator(self.validatorUpper)
self.ipCombo.setCurrentIndex(INDEX_ALIAS)
else:
self.ipLine.setValidator(self.validatorAll)
self.ipCombo.setCurrentIndex(INDEX_TEXT)
if stepData["parameters"]["from-cache-port"]:
self.portLine.setValidator(self.validatorAll)
self.portCombo.setCurrentIndex(INDEX_CACHE)
elif stepData["parameters"]["from-alias-port"]:
self.portLine.setValidator(self.validatorUpper)
self.portCombo.setCurrentIndex(INDEX_ALIAS)
else:
self.portLine.setValidator(self.validatorInt)
self.portCombo.setCurrentIndex(INDEX_TEXT)
if stepData["parameters"]["from-cache-login"]:
self.loginLine.setValidator(self.validatorAll)
self.loginCombo.setCurrentIndex(INDEX_CACHE)
elif stepData["parameters"]["from-alias-login"]:
self.loginLine.setValidator(self.validatorUpper)
self.loginCombo.setCurrentIndex(INDEX_ALIAS)
else:
self.loginLine.setValidator(self.validatorAll)
self.loginCombo.setCurrentIndex(INDEX_TEXT)
if stepData["parameters"]["from-cache-pwd"]:
self.pwdLine.setValidator(self.validatorAll)
self.pwdCombo.setCurrentIndex(INDEX_CACHE)
elif stepData["parameters"]["from-alias-pwd"]:
self.pwdLine.setValidator(self.validatorUpper)
self.pwdCombo.setCurrentIndex(INDEX_ALIAS)
else:
self.pwdLine.setValidator(self.validatorAll)
self.pwdCombo.setCurrentIndex(INDEX_TEXT)
if self.actionsComboBox.currentText() in [GuiSteps.SYSTEM_CLOSE]:
pass
if self.actionsComboBox.currentText() in [
GuiSteps.SYSTEM_CLEAR_SCREEN
]:
pass
if self.actionsComboBox.currentText() in [GuiSteps.SYSTEM_TEXT]:
if stepData["parameters"]["from-cache"]:
self.textLine.setValidator(self.validatorAll)
self.textCombo.setCurrentIndex(INDEX_CACHE)
elif stepData["parameters"]["from-alias"]:
self.textLine.setValidator(self.validatorUpper)
self.textCombo.setCurrentIndex(INDEX_ALIAS)
else:
self.textLine.setValidator(self.validatorAll)
self.textCombo.setCurrentIndex(INDEX_TEXT)
self.textLine.setText(stepData["parameters"]["text"])
if self.actionsComboBox.currentText() in [GuiSteps.SYSTEM_SHORTCUT]:
for i in xrange(self.shortcutComboBox.count()):
item_text = self.shortcutComboBox.itemText(i)
if unicode(stepData["parameters"]["shortcut"]) == unicode(
item_text):
self.shortcutComboBox.setCurrentIndex(i)
break
if self.actionsComboBox.currentText() in [
GuiSteps.SYSTEM_CHECK_SCREEN
]:
if stepData["parameters"]["from-cache"]:
self.screenLine.setValidator(self.validatorAll)
self.screenCombo.setCurrentIndex(INDEX_CACHE)
self.screenLine.setText(stepData["parameters"]["value"])
elif stepData["parameters"]["from-alias"]:
self.screenLine.setValidator(self.validatorUpper)
self.screenCombo.setCurrentIndex(INDEX_ALIAS)
self.screenLine.setText(stepData["parameters"]["value"])
else:
self.screenCombo.setCurrentIndex(INDEX_TEXT)
self.screenArea.setPlainText(stepData["parameters"]["value"])
for i in xrange(self.checkComboBox.count()):
item_text = self.checkComboBox.itemText(i)
if unicode(stepData["parameters"]["operator"]) == unicode(
item_text):
self.checkComboBox.setCurrentIndex(i)
break
if stepData["parameters"]["to-cache"]:
self.screenSaveCombo.setCurrentIndex(1)
self.screenSaveLine.setText(
stepData["parameters"]["cache-key"])
else:
self.screenSaveCombo.setCurrentIndex(0)
def getTimeout(self):
"""
Return timeout value
"""
return self.optionsDialog.timeoutLine.text()
def setTimeout(self, timeout):
"""
Set the timeout
"""
return self.optionsDialog.timeoutLine.setText(timeout)
def getAgentName(self):
"""
Return the agent name
"""
return self.optionsDialog.agentNameLine.text()
def getAgentList(self):
"""
Return the agent list
"""
return self.optionsDialog.agentsList
def generateDataTypesField(dataType=None):
"""
@rtype: QComboBox
"""
dataTypes = QComboBox()
dataTypes.addItems(
helper_methods.buildQStringList(
['TINYINT', 'SMALLINT', 'MEDIUMINT', 'INT', 'BIGINT', 'BIT']))
dataTypes.insertSeparator(dataTypes.count())
dataTypes.addItems(
helper_methods.buildQStringList(['FLOAT', 'DOUBLE', 'DECIMAL']))
dataTypes.insertSeparator(dataTypes.count())
dataTypes.addItems(
helper_methods.buildQStringList([
'CHAR', 'VARCHAR', 'TINYTEXT', 'TEXT', 'MEDIUMTEXT', 'LONGTEXT'
]))
dataTypes.insertSeparator(dataTypes.count())
dataTypes.addItems(
helper_methods.buildQStringList([
'BINARY', 'VARBINARY', 'TINYBLOB', 'BLOB', 'MEDIUMBLOB',
'LONGBLOB'
]))
dataTypes.insertSeparator(dataTypes.count())
dataTypes.addItems(
helper_methods.buildQStringList(
['DATE', 'TIME', 'YEAR', 'DATETIME', 'TIMESTAMP']))
dataTypes.insertSeparator(dataTypes.count())
dataTypes.addItems(
helper_methods.buildQStringList([
'POINT', 'LINESTRING', 'POLYGON', 'GEOMETRY', 'MULTIPOINT',
'MULTILINESTRING', 'MULTIPOLYGON', 'GEOMETRYCOLLECTION'
]))
dataTypes.insertSeparator(dataTypes.count())
dataTypes.addItems(helper_methods.buildQStringList(['ENUM', 'SET']))
if dataType is not None:
dataTypes.setCurrentIndex(dataTypes.findText(dataType.upper()))
return dataTypes
class Settings(SymbolManager, QWidget):
"""
The widget where users can set other preferences.
"""
def __init__(self, parent):
QWidget.__init__(self, parent)
SymbolManager.__init__(self)
parent.addPage(self, i18n("Score settings"))
h = QHBoxLayout(self)
v = QVBoxLayout()
h.addLayout(v)
score = QGroupBox(i18n("Score settings"))
v.addWidget(score)
lily = QGroupBox(i18n("LilyPond"))
v.addWidget(lily)
v = QVBoxLayout()
h.addLayout(v)
prefs = QGroupBox(i18n("General preferences"))
v.addWidget(prefs)
instr = QGroupBox(i18n("Instrument names"))
v.addWidget(instr)
# Score settings:
v = QVBoxLayout(score)
h = KHBox()
v.addWidget(h)
l = QLabel(i18n("Key signature:"), h)
self.key = QComboBox(h) # the key names are filled in later
self.mode = QComboBox(h)
self.mode.addItems([title for name, title in ly.modes(i18n)])
l.setBuddy(self.key)
h = KHBox()
v.addWidget(h)
l = QLabel(i18n("Time signature:"), h)
self.time = QComboBox(h)
self.time.setEditable(True)
self.time.addItems([
'(4/4)', '(2/2)',
'2/4', '3/4', '4/4', '5/4', '6/4', '7/4',
'2/2', '3/2', '4/2',
'3/8', '5/8', '6/8', '7/8', '8/8', '9/8', '12/8',
'3/16', '6/16', '12/16'])
# palette sensitive icons for the first two items
self.addItemSymbol(self.time, 0, 'time_c44')
self.addItemSymbol(self.time, 1, 'time_c22')
l.setBuddy(self.time)
h = KHBox()
v.addWidget(h)
l = QLabel(i18n("Pickup measure:"), h)
self.pickup = QComboBox(h)
self.pickup.addItem(i18n("None"))
self.pickup.insertSeparator(1)
durs = [('note_' + d.replace('.', 'd'), d) for d in durations]
for icon, text in durs:
self.addItemSymbol(self.pickup, self.pickup.count(), icon)
self.pickup.addItem(text)
l.setBuddy(self.pickup)
h = KHBox()
v.addWidget(h)
l = QLabel(i18n("Metronome mark:"), h)
self.metroDur = QComboBox(h)
l.setBuddy(self.metroDur)
for icon, text in durs:
self.addItemSymbol(self.metroDur, self.metroDur.count(), icon)
self.metroDur.addItem('')
l = QLabel('=', h)
l.setAlignment(Qt.AlignCenter)
l.setMaximumWidth(20)
self.metroVal = QComboBox(h)
self.metroVal.setEditable(True)
metroValues, start = [], 40
for end, step in (60, 2), (72, 3), (120, 4), (144, 6), (210, 8):
metroValues.extend(range(start, end, step))
start = end
# reverse so mousewheeling is more intuitive
self.metroValues = metroValues[::-1]
self.metroVal.addItems(map(str, self.metroValues))
def tap(bpm):
""" Tap the tempo tap button """
l = [abs(t - bpm) for t in self.metroValues]
m = min(l)
if m < 6:
self.metroVal.setCurrentIndex(l.index(m))
TapButton(h, tap)
h = KHBox()
v.addWidget(h)
l = QLabel(i18n("Tempo indication:"), h)
self.tempoInd = KLineEdit(h)
parent.complete(self.tempoInd, "tempo")
l.setBuddy(self.tempoInd)
h.setToolTip(i18n("A tempo indication, e.g. \"Allegro.\""))
# LilyPond settings
v = QVBoxLayout(lily)
h = KHBox()
v.addWidget(h)
l = QLabel(i18n("Pitch name language:"), h)
self.languageNames = list(sorted(ly.keyNames))
self.lylang = QComboBox(h)
l.setBuddy(self.lylang)
self.lylang.addItem(i18n("Default"))
self.lylang.insertSeparator(1)
self.lylang.addItems([l.title() for l in self.languageNames])
h.setToolTip(i18n(
"The LilyPond language you want to use for the pitch names."))
self.lylang.currentIndexChanged.connect(self.slotLanguageChanged)
self.slotLanguageChanged(0) # init with default
h = KHBox()
v.addWidget(h)
l = QLabel(i18n("Version:"), h)
self.lyversion = QComboBox(h)
self.lyversion.setEditable(True)
l.setBuddy(self.lyversion)
version = defaultVersion()
if version:
self.lyversion.addItem(str(version))
self.lyversion.addItems(('2.12.0', '2.10.0'))
h.setToolTip(i18n(
"The LilyPond version you will be using for this document."))
# General preferences
v = QVBoxLayout(prefs)
self.typq = QCheckBox(i18n("Use typographical quotes"))
self.typq.setToolTip(i18n(
"Replace normal quotes in titles with nice typographical quotes."))
v.addWidget(self.typq)
self.tagl = QCheckBox(i18n("Remove default tagline"))
self.tagl.setToolTip(i18n(
"Suppress the default tagline output by LilyPond."))
v.addWidget(self.tagl)
self.barnum = QCheckBox(i18n("Remove bar numbers"))
self.barnum.setToolTip(i18n(
"Suppress the display of measure numbers at the beginning of "
"every system."))
v.addWidget(self.barnum)
self.midi = QCheckBox(i18n("Create MIDI output"))
self.midi.setToolTip(i18n(
"Create a MIDI file in addition to the PDF file."))
v.addWidget(self.midi)
self.metro = QCheckBox(i18n("Show metronome mark"))
self.metro.setToolTip(i18n(
"If checked, show the metronome mark at the beginning of the "
"score. The MIDI output also uses the metronome setting."))
v.addWidget(self.metro)
self.book = QCheckBox(i18n("Wrap score in \\book block"))
self.book.setToolTip(i18n(
"If checked, wraps the \\score block inside a \\book block."))
v.addWidget(self.book)
# paper size:
h = KHBox()
v.addWidget(h)
h.setSpacing(2)
l = QLabel(i18n("Paper size:"), h)
self.paper = QComboBox(h)
l.setBuddy(self.paper)
self.paperLandscape = QCheckBox(i18n("Landscape"), h)
self.paper.addItem(i18n("Default"))
self.paper.addItems(ly.paperSizes)
self.paper.activated.connect(lambda i: self.paperLandscape.setEnabled(bool(i)))
# Instrument names
instr.setCheckable(True)
self.instr = instr
v = QVBoxLayout(instr)
h = KHBox()
v.addWidget(h)
l = QLabel(i18n("First system:"), h)
self.instrFirst = QComboBox(h)
l.setBuddy(self.instrFirst)
self.instrFirst.addItems((i18n("Long"), i18n("Short")))
h.setToolTip(i18n(
"Use long or short instrument names before the first system."))
h = KHBox()
v.addWidget(h)
l = QLabel(i18n("Other systems:"), h)
self.instrOther = QComboBox(h)
l.setBuddy(self.instrOther)
self.instrOther.addItems((i18n("Long"), i18n("Short"), i18n("None")))
h.setToolTip(i18n(
"Use short, long or no instrument names before the next systems."))
h = KHBox()
v.addWidget(h)
l = QLabel(i18n("Language:"), h)
self.instrLang = QComboBox(h)
l.setBuddy(self.instrLang)
self.instrLang.addItems((i18n("Default"), KGlobal.locale().languageCodeToName("en")))
h.setToolTip(i18n("Which language to use for the instrument names."))
langs = KGlobal.dirs().findAllResources("locale", "*/LC_MESSAGES/frescobaldi.mo")
self.instrLanguages = list(sorted(set(lang.split('/')[-3] for lang in langs)))
self.instrLang.addItems(map(KGlobal.locale().languageCodeToName, self.instrLanguages))
self.default()
self.loadConfig()
def saveConfig(self):
conf = config()
conf.writeEntry('language', self.getLanguage() or 'default')
conf.writeEntry('typographical', self.typq.isChecked())
conf.writeEntry('remove tagline', self.tagl.isChecked())
conf.writeEntry('remove barnumbers', self.barnum.isChecked())
conf.writeEntry('midi', self.midi.isChecked())
conf.writeEntry('metronome mark', self.metro.isChecked())
conf.writeEntry('wrap in book', self.book.isChecked())
if self.paper.currentIndex() > 0:
conf.writeEntry('paper size', ly.paperSizes[self.paper.currentIndex() - 1])
conf.writeEntry('paper landscape', self.paperLandscape.isChecked())
g = config('instrument names')
g.writeEntry('show', self.instr.isChecked())
g.writeEntry('first', ['long', 'short'][self.instrFirst.currentIndex()])
g.writeEntry('other', ['long', 'short', 'none'][self.instrOther.currentIndex()])
g.writeEntry('lang', (['default', 'english'] + self.instrLanguages)[self.instrLang.currentIndex()])
def loadConfig(self):
conf = config()
self.setLanguage(conf.readEntry('language', 'default'))
self.typq.setChecked(conf.readEntry('typographical', True))
self.tagl.setChecked(conf.readEntry('remove tagline', False))
self.barnum.setChecked(conf.readEntry('remove barnumbers', False))
self.midi.setChecked(conf.readEntry('midi', True))
self.metro.setChecked(conf.readEntry('metronome mark', False))
self.book.setChecked(conf.readEntry('wrap in book', False))
psize = conf.readEntry('paper size', "")
if psize in ly.paperSizes:
self.paper.setCurrentIndex(ly.paperSizes.index(psize) + 1)
self.paperLandscape.setChecked(conf.readEntry('paper landscape', False))
self.paperLandscape.setEnabled(psize in ly.paperSizes)
g = config('instrument names')
def readconf(entry, itemlist, defaultIndex):
item = g.readEntry(entry, itemlist[defaultIndex])
if item in itemlist:
return itemlist.index(item)
else:
return defaultIndex
first = readconf('first', ['long', 'short'], 0)
other = readconf('other', ['long', 'short', 'none'], 2)
lang = readconf('lang', ['default', 'english'] + self.instrLanguages, 0)
self.instrFirst.setCurrentIndex(first)
self.instrOther.setCurrentIndex(other)
self.instrLang.setCurrentIndex(lang)
self.instr.setChecked(g.readEntry('show', True))
def default(self):
""" Set various items to their default state """
self.lylang.setCurrentIndex(0)
self.key.setCurrentIndex(0)
self.mode.setCurrentIndex(0)
self.time.setCurrentIndex(0)
self.pickup.setCurrentIndex(0)
self.metroVal.setCurrentIndex(self.metroValues.index(100))
self.metroDur.setCurrentIndex(durations.index('4'))
self.tempoInd.clear()
self.typq.setChecked(True)
self.tagl.setChecked(False)
self.barnum.setChecked(False)
self.midi.setChecked(True)
self.metro.setChecked(False)
self.book.setChecked(False)
self.paper.setCurrentIndex(0)
self.paperLandscape.setEnabled(False)
self.instrFirst.setCurrentIndex(0)
self.instrOther.setCurrentIndex(2)
self.instrLang.setCurrentIndex(0)
self.instr.setChecked(True)
def getLanguage(self):
""" Return the configured LilyPond pitch language, '' for default. """
if self.lylang.currentIndex() >= 2:
return self.languageNames[self.lylang.currentIndex() - 2]
else:
return ''
def setLanguage(self, lang):
""" Sets the language combobox to the specified language """
if lang not in self.languageNames:
self.lylang.setCurrentIndex(0)
else:
self.lylang.setCurrentIndex(self.languageNames.index(lang) + 2)
def slotLanguageChanged(self, index):
""" Change the LilyPond language, affects key names """
lang = index < 2 and "nederlands" or self.languageNames[index - 2]
key = self.key.currentIndex()
if key == -1:
key = 0
self.key.clear()
self.key.addItems(ly.keyNames[lang])
self.key.setCurrentIndex(key)
class LDSControls(QFrame):
STATIC_IMG = ('error_static.png','linz_static.png','busy_static.png','clean_static.png')
ANIM_IMG = ('error.gif','linz.gif','layer.gif','clean.gif')
IMG_SPEED = 100
IMG_WIDTH = 64
IMG_HEIGHT = 64
MAX_WD = 450
GD_PATH = os.path.abspath(os.path.join(os.path.dirname(__file__), '../../../../bin/gdal/gdal-data'))
STATUS = LU.enum('ERROR','IDLE','BUSY','CLEAN')
def __init__(self,parent):
super(LDSControls, self).__init__()
self.parent = parent
self.initConf()
self.initEPSG()
self.initUI()
def initConf(self):
'''Read files in conf dir ending in conf'''
self.cflist = ConfigInitialiser.getConfFiles()
#self.imgset = self.STATIC_IMG if ConfigWrapper().readDSProperty('Misc','indicator')=='static' else self.ANIM_IMG
#self.imgset = self.STATIC_IMG if self.parent.confconn.tp.src.confwrap.readDSProperty('Misc','indicator')=='static' else self.ANIM_IMG
sep = self.parent.confconn.reg.openEndPoint(self.parent.confconn.SRCNAME,self.parent.confconn.uconf)
self.imgset = self.STATIC_IMG if sep.confwrap.readDSProperty('Misc','indicator')=='static' else self.ANIM_IMG
self.parent.confconn.reg.closeEndPoint(self.parent.confconn.SRCNAME)
def initEPSG(self):
'''Read GDAL EPSG files, splitting by NZ(RSR) and RestOfTheWorld'''
gcsf = gdal.FindFile('gdal','gcs.csv')
if not gcsf:
gcsf = os.path.join(self.GD_PATH,'gcs.csv')
pcsf = gdal.FindFile('gdal','pcs.csv')
if not pcsf:
pcsf = os.path.join(self.GD_PATH,'pcs.csv')
gcs = ConfigInitialiser.readCSV(gcsf)
pcs = ConfigInitialiser.readCSV(pcsf)
self.nzlsr = [(e[0],e[0]+' - '+e[3]) for e in gcs if 'NZGD' in e[1] or 'RSRGD' in e[1]] \
+ [(e[0],e[0]+' - '+e[1]) for e in pcs if 'NZGD' in e[1] or 'RSRGD' in e[1]]
self.rowsr = [(e[0],e[0]+' - '+e[3]) for e in gcs if 'NZGD' not in e[1] and 'RSRGD' not in e[1]] \
+ [(e[0],e[0]+' - '+e[1]) for e in pcs if 'NZGD' not in e[1] and 'RSRGD' not in e[1]]
def initUI(self):
# 0 1 2 3 4 5 6 7 8
#'destname','lgselect','layer','uconf','group','epsg','fd','td','int'
#self.rdest,rlgselect,self.rlayer,ruconf,self.rgroup,repsg,rfd,rtd,rint = readlist
QToolTip.setFont(QFont('SansSerif', 10))
#labels
destLabel = QLabel('Destination')
lgLabel = QLabel('Group/Layer')
epsgLabel = QLabel('EPSG')
fromDateLabel = QLabel('From Date')
toDateLabel = QLabel('To Date')
confLabel = QLabel('User Config')
self.view = QLabel()
self.view.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.view.setAlignment(Qt.AlignCenter)
self.confcombo = QComboBox(self)
self.confcombo.setToolTip('Enter your user config name (file) here')
self.confcombo.addItems(self.cflist)
self.confcombo.setEditable(False)
#self.confcombo.currentIndexChanged.connect(self.doLGEditUpdate)
#combos
self.lgcombo = QComboBox(self)
self.lgcombo.setMaximumWidth(self.MAX_WD)
self.lgcombo.setDuplicatesEnabled(False)
#self.lgcombo.setInsertPolicy(QComboBox.InsertAlphabetically)#?doesnt seem to work
self.lgcombo.setToolTip('Select either Layer or Group entry')
self.lgcombo.setEditable(False)
self.sepindex = None
#self.updateLGValues()
self.epsgcombo = QComboBox(self)
self.epsgcombo.setMaximumWidth(self.MAX_WD)
self.epsgcombo.setToolTip('Setting an EPSG number here determines the output SR of the layer')
self.epsgcombo.addItems([i[1] for i in self.nzlsr])
self.epsgcombo.insertSeparator(len(self.nzlsr))
self.epsgcombo.addItems([i[1] for i in self.rowsr])
self.epsgcombo.setEditable(True)
self.epsgcombo.setEnabled(False)
self.destlist = self.getConfiguredDestinations()
self.destcombo = QComboBox(self)
self.destcombo.setToolTip('Choose the desired output type')
self.destcombo.setEditable(False)
self.destcombo.addItems(self.destlist)
#date selection
self.fromdateedit = QDateEdit()
self.fromdateedit.setCalendarPopup(True)
self.fromdateedit.setEnabled(False)
self.todateedit = QDateEdit()
self.todateedit.setCalendarPopup(True)
self.todateedit.setEnabled(False)
#check boxes
self.epsgenable = QCheckBox()
self.epsgenable.setCheckState(False)
self.epsgenable.clicked.connect(self.doEPSGEnable)
self.fromdateenable = QCheckBox()
self.fromdateenable.setCheckState(False)
self.fromdateenable.clicked.connect(self.doFromDateEnable)
self.todateenable = QCheckBox()
self.todateenable.setCheckState(False)
self.todateenable.clicked.connect(self.doToDateEnable)
self.progressbar = QProgressBar()
self.progressbar.setRange(0,100)
self.progressbar.setVisible(True)
self.progressbar.setMinimumWidth(self.MAX_WD)
#buttons
self.initbutton = QPushButton("waiting")
self.initbutton.setToolTip('Initialise the Layer Configuration')
self.initbutton.clicked.connect(self.doInitClickAction)
self.cleanbutton = QPushButton("Clean")
self.cleanbutton.setToolTip('Clean the selected layer/group from local storage')
self.cleanbutton.clicked.connect(self.doCleanClickAction)
self.replicatebutton = QPushButton("Replicate")
self.replicatebutton.setToolTip('Execute selected replication')
self.replicatebutton.clicked.connect(self.doReplicateClickAction)
self.cancelbutton = QPushButton("Close")
self.cancelbutton.setToolTip('Close the LDS Replicate application')
self.cancelbutton.clicked.connect(self.parent.close)
#set dialog values using GPR
self.updateGUIValues(self.parent.gvs)
#set onchange here otherwise we get circular initialisation
self.destcombo.currentIndexChanged.connect(self.doDestChanged)
self.confcombo.currentIndexChanged.connect(self.doConfChanged)
self.lgcombo.currentIndexChanged.connect(self.doLGComboChanged)
self.setStatus(self.STATUS.IDLE)
#grid
grid = QGridLayout()
grid.setSpacing(10)
#placement section ------------------------------------
#---------+---------+--------+---------+--------
# dest LB | | dest DD
# grp LB | | grp DD
# conf LB | | conf DD
# epsg L | epsg CB | epsg DD
# f dt L | f dt CB | f dt DD
# t td L | t td CB | t td DD
# icon | <- progress ->
# layer B | <- . -> |repl B | clean B | close B
#---------+---------+--------+---------+--------
grid.addWidget(destLabel, 1, 0)
grid.addWidget(self.destcombo, 1, 2)
#grid.addWidget(layerLabel, 2, 0)
grid.addWidget(lgLabel, 2, 0)
grid.addWidget(self.lgcombo, 2, 2)
grid.addWidget(confLabel, 3, 0)
grid.addWidget(self.confcombo, 3, 2)
#grid.addWidget(groupLabel, 4, 0)
#grid.addWidget(self.groupEdit, 4, 2)
grid.addWidget(epsgLabel, 5, 0)
grid.addWidget(self.epsgenable, 5, 1)
grid.addWidget(self.epsgcombo, 5, 2)
grid.addWidget(fromDateLabel, 6, 0)
grid.addWidget(self.fromdateenable, 6, 1)
grid.addWidget(self.fromdateedit, 6, 2)
grid.addWidget(toDateLabel, 7, 0)
grid.addWidget(self.todateenable, 7, 1)
grid.addWidget(self.todateedit, 7, 2)
hbox3 = QHBoxLayout()
hbox3.addWidget(self.view)
hbox3.addStretch(1)
hbox3.addWidget(self.progressbar)
#hbox3.addLayout(vbox2)
#hbox3.addLayout(vbox3)
hbox4 = QHBoxLayout()
hbox4.addWidget(self.initbutton)
hbox4.addStretch(1)
hbox4.addWidget(self.replicatebutton)
hbox4.addWidget(self.cleanbutton)
hbox4.addWidget(self.cancelbutton)
vbox = QVBoxLayout()
#vbox.addStretch(1)
vbox.addLayout(grid)
vbox.addLayout(hbox3)
vbox.addLayout(hbox4)
self.setLayout(vbox)
#def setProgress(self,pct):
# self.progressbar.setValue(pct)
def setStatus(self,status,message='',tooltip=None):
'''Sets indicator icon and statusbar message'''
self.parent.statusbar.showMessage(message)
self.parent.statusbar.setToolTip(tooltip if tooltip else '')
#progress
loc = os.path.abspath(os.path.join(IMG_LOC,self.imgset[status]))
#loc = os.path.abspath(os.path.join(os.path.dirname(__file__),self.parent.IMG_LOC,self.imgset[status]))
self.progressbar.setVisible(status in (self.STATUS.BUSY, self.STATUS.CLEAN))
#icon
anim = QMovie(loc, QByteArray(), self)
anim.setScaledSize(QSize(self.IMG_WIDTH,self.IMG_HEIGHT))
anim.setCacheMode(QMovie.CacheAll)
anim.setSpeed(self.IMG_SPEED)
self.view.clear()
self.view.setMovie(anim)
anim.start()
self.view.repaint()
QApplication.processEvents(QEventLoop.AllEvents)
def mainWindowEnable(self,enable=True):
cons = (self.lgcombo, self.confcombo, self.destcombo,
self.initbutton, self.replicatebutton, self.cleanbutton, self.cancelbutton,
self.epsgenable,self.fromdateenable,self.todateenable,
self.parent.menubar)
for c in cons:
c.setEnabled(enable)
if enable:
self.epsgcombo.setEnabled(self.epsgenable.checkState())
self.fromdateedit.setEnabled(self.fromdateenable.checkState())
self.todateedit.setEnabled(self.todateenable.checkState())
else:
self.epsgcombo.setEnabled(False)
self.fromdateedit.setEnabled(False)
self.todateedit.setEnabled(False)
QApplication.restoreOverrideCursor() if enable else QApplication.setOverrideCursor(QCursor(Qt.WaitCursor))
def refreshLGCombo(self):
'''Re index LG combobox since a refreshLG call (new dest?) will usually mean new groups'''
self.lgcombo.clear()
self.lgcombo.addItems([i[2] for i in self.parent.confconn.lglist])
#NOTE the separator consumes an index, if not clearing the combobox selectively remove the old sepindex (assumes g preceeds l)
#if self.sepindex:
# self.lgcombo.removeItem(self.sepindex)
self.sepindex = [i[0] for i in self.parent.confconn.lglist].count(LORG.GROUP)
self.lgcombo.insertSeparator(self.sepindex)
def updateLGValues(self,uconf,lgval,dest):
'''Sets the values displayed in the Layer/Group combo'''
#because we cant seem to sort combobox entries and want groups at the top, clear and re-add
#TRACE#
#pdb.set_trace()
sf = None
try:
self.parent.confconn.initConnections(uconf,lgval,dest)
except Exception as e:
sf=1
ldslog.error('Error Updating UC Values. '+str(e))
if sf:
self.setStatus(self.STATUS.ERROR,'Error Updating UC Values', str(e))
else:
self.setStatus(self.STATUS.IDLE)
self.refreshLGCombo()
def centre(self):
qr = self.frameGeometry()
cp = QDesktopWidget().availableGeometry().center()
qr.moveCenter(cp)
self.move(qr.topLeft())
def gprParameters(self,rdest):
'''Zip default and GPR values'''
return [x if LU.assessNone(x) else y for x,y in zip(self.parent.gpr.readsec(rdest),self.parent.DEF_RVALS[1:])]
def getLCE(self,ln):
'''Read layer parameters'''
dep = self.parent.confconn.reg.openEndPoint(self.parent.confconn.destname,self.parent.confconn.uconf)
#sep = self.parent.confconn.reg.openEndPoint('WFS',self.parent.confconn.uconf)
self.parent.confconn.reg.setupLayerConfig(self.parent.confconn.tp,None,dep,initlc=False)
lce = dep.getLayerConf().readLayerParameters(ln)
#self.parent.confconn.reg.closeEndPoint('WFS')
self.parent.confconn.reg.closeEndPoint(self.parent.confconn.destname)
sep,dep = None,None
return lce
def doDestChanged(self):
'''Read the destname parameter and fill dialog with matching GPR values'''
rdest = str(self.destlist[self.destcombo.currentIndex()])
rvals = self.gprParameters(rdest)
self.updateGUIValues([rdest]+rvals)
def doConfChanged(self):
'''Read the user conf parameter and fill dialog with matching GPR values'''
rdest = str(self.destlist[self.destcombo.currentIndex()])
rlg,_,rep,rfd,rtd = self.gprParameters(rdest)
ruc = str(self.cflist[self.confcombo.currentIndex()])
self.updateGUIValues((rdest,rlg,ruc,rep,rfd,rtd))
def doLGComboChanged(self):
'''Read the layer/group value and change epsg to layer or gpr match'''
#get a matching LG entry and test whether its a layer or group
#lgi = self.parent.confconn.getLayerGroupIndex(self.lgcombo.currentText().toUtf8().data())
lgi = self.parent.confconn.getLayerGroupIndex(LQ.readWidgetText(self.lgcombo.currentText()))
#lgi can be none if we init a new group, in which case we use the GPR value
if lgi:
lge = self.parent.confconn.lglist[lgi]
lce = self.getLCE(lge[1]) if lge[0]==LORG.LAYER else None
else:
lce = None
#look for filled layer conf epsg OR use prefs stored in gpr
if lce and LU.assessNone(lce.epsg):
epsgval = lce.epsg
else:
rdest = str(self.destlist[self.destcombo.currentIndex()])
_,_,epsgval,_,_ = self.gprParameters(rdest)
epsgindex = [i[0] for i in self.nzlsr+[(0,0)]+self.rowsr].index(epsgval)
if self.epsgcombo.currentIndex() != epsgindex:
self.epsgcombo.setCurrentIndex(int(epsgindex))
def updateGUIValues(self,readlist):
'''Fill dialog values from provided list'''
#TODO. Remove circular references when setCurrentIndex() triggers do###Changed()
#Read user input
rdest,self.rlgval,ruconf,repsg,rfd,rtd = readlist
#--------------------------------------------------------------------
#Destination Menu
selecteddest = LU.standardiseDriverNames(rdest)
if selecteddest not in self.destlist:
self.destlist = self.getConfiguredDestinations()
self.destcombo.addItem(selecteddest)
destindex = self.destlist.index(selecteddest) if selecteddest else 0
if self.destcombo.currentIndex() != destindex:
self.destcombo.setCurrentIndex(destindex)
#InitButton
self.initbutton.setText('Layer Select')
#Config File
confindex = 0
if LU.assessNone(ruconf):
ruconf = ruconf.split('.')[0]
if ruconf not in self.cflist:
self.cflist += [ruconf,]
self.confcombo.addItem(ruconf)
confindex = self.cflist.index(ruconf)
if self.confcombo.currentIndex() != confindex:
self.confcombo.setCurrentIndex(confindex)
#self.confEdit.setText(ruconf if LU.assessNone(ruconf) else '')
#Layer/Group Selection
self.updateLGValues(ruconf,self.rlgval,rdest)
lgindex = None
if LU.assessNone(self.rlgval):
#index of list value
lgindex = self.parent.confconn.getLayerGroupIndex(self.rlgval,col=1)
if LU.assessNone(lgindex):
#advance by 1 for sep
lgindex += 1 if lgindex>self.sepindex else 0
else:
#using the separator index sets the combo to blank
lgindex = self.sepindex
if self.lgcombo.currentIndex() != lgindex:
self.lgcombo.setCurrentIndex(lgindex)
#self.doLGEditUpdate()
#EPSG
# user > layerconf
#useepsg = LU.precedence(repsg, lce.epsg if lce else None, None)
epsgindex = [i[0] for i in self.nzlsr+[(None,None)]+self.rowsr].index(repsg)
if self.epsgcombo.currentIndex() != epsgindex:
self.epsgcombo.setCurrentIndex(epsgindex)
#epsgedit = self.epsgcombo.lineEdit()
#epsgedit.setText([e[1] for e in self.nzlsr+self.rowsr if e[0]==repsg][0])
#epsgedit.setText([e for e in self.nzlsr+self.rowsr if re.match('^\s*(\d+).*',e).group(1)==repsg][0])
#To/From Dates
if LU.assessNone(rfd):
self.fromdateedit.setDate(QDate(int(rfd[0:4]),int(rfd[5:7]),int(rfd[8:10])))
else:
early = DataStore.EARLIEST_INIT_DATE
self.fromdateedit.setDate(QDate(int(early[0:4]),int(early[5:7]),int(early[8:10])))
if LU.assessNone(rtd):
self.todateedit.setDate(QDate(int(rtd[0:4]),int(rtd[5:7]),int(rtd[8:10])))
else:
today = DataStore.getCurrent()
self.todateedit.setDate(QDate(int(today[0:4]),int(today[5:7]),int(today[8:10])))
#Internal/External CheckBox
# if LU.assessNone(rint):
# self.internalTrigger.setChecked(rint.lower()==DataStore.CONF_INT)
# else:
# self.internalTrigger.setChecked(DataStore.DEFAULT_CONF==DataStore.CONF_INT)
def getConfiguredDestinations(self):
defml = ['',]+DataStore.DRIVER_NAMES.values()
return [d for d in self.parent.gpr.getDestinations() if d in defml]
def doEPSGEnable(self):
self.epsgcombo.setEnabled(self.epsgenable.isChecked())
def doFromDateEnable(self):
self.fromdateedit.setEnabled(self.fromdateenable.isChecked())
def doToDateEnable(self):
self.todateedit.setEnabled(self.todateenable.isChecked())
def readParameters(self):
'''Read values out of dialogs'''
destination = LU.assessNone(str(self.destlist[self.destcombo.currentIndex()]))
#lgindex = self.parent.confconn.getLayerGroupIndex(self.lgcombo.currentText().toUtf8().data())
lgindex = self.parent.confconn.getLayerGroupIndex(LQ.readWidgetText(self.lgcombo.currentText()))
#NB need to test for None explicitly since zero is a valid index
lgval = self.parent.confconn.lglist[lgindex][1] if LU.assessNone(lgindex) else None
#uconf = LU.standardiseUserConfigName(str(self.confcombo.lineEdit().text()))
#uconf = str(self.confcombo.lineEdit().text())
uconf = str(self.cflist[self.confcombo.currentIndex()])
ee = self.epsgenable.isChecked()
epsg = None if ee is False else re.match('^\s*(\d+).*',str(self.epsgcombo.lineEdit().text())).group(1)
fe = self.fromdateenable.isChecked()
te = self.todateenable.isChecked()
fd = None if fe is False else str(self.fromdateedit.date().toString('yyyy-MM-dd'))
td = None if te is False else str(self.todateedit.date().toString('yyyy-MM-dd'))
return destination,lgval,uconf,epsg,fe,te,fd,td
def doInitClickAction(self):
'''Initialise the LC on LC-button-click, action'''
try:
try:
self.setStatus(self.STATUS.BUSY,'Opening Layer-Config Editor')
self.progressbar.setValue(0)
self.parent.runLayerConfigAction()
finally:
self.setStatus(self.STATUS.IDLE,'Ready')
except Exception as e:
self.setStatus(self.STATUS.ERROR,'Error in Layer-Config',str(sys.exc_info()))#e))
def doCleanClickAction(self):
'''Set clean anim and run clean'''
#lgo = self.lgcombo.currentText().toUtf8().data()
lgo = LQ.readWidgetText(self.lgcombo.currentText())
try:
self.setStatus(self.STATUS.CLEAN,'Running Clean '+lgo)
self.progressbar.setValue(0)
self.runReplicationScript(True)
except Exception as e:
self.setStatus(self.STATUS.ERROR,'Failed Clean of '+lgo,str(sys.exc_info()))#e))
def doReplicateClickAction(self):
'''Set busy anim and run repl'''
lgo = self.lgcombo.currentText()#.toUtf8().data()#only used for error messages
try:
self.setStatus(self.STATUS.BUSY,'Running Replicate '+lgo)
self.progressbar.setValue(0)
self.runReplicationScript(False)
ldslog.debug('TRPfinish')
except Exception as e:
self.setStatus(self.STATUS.ERROR,'Failed Replication of '+lgo,str(sys.exc_info()))#e))
def runReplicationScript(self,clean=False):
'''Run the layer/group repliction script'''
destination,lgval,uconf,epsg,fe,te,fd,td = self.readParameters()
uconf_path = LU.standardiseUserConfigName(uconf)
destination_path = LU.standardiseLayerConfigName(destination)
destination_driver = LU.standardiseDriverNames(destination)
if not os.path.exists(uconf_path):
self.userConfMessage(uconf_path)
return
elif not MainFileReader(uconf_path).hasSection(destination_driver):
self.userConfMessage(uconf_path,destination_driver)
return
#-----------------------------------------------------
#'destname','layer','uconf','group','epsg','fd','td','int'
self.parent.gpr.write((destination_driver,lgval,uconf,epsg,fd,td))
ldslog.info(u'dest={0}, lg={1}, conf={2}, epsg={3}'.format(destination_driver,lgval,uconf,epsg))
ldslog.info('fd={0}, td={1}, fe={2}, te={3}'.format(fd,td,fe,te))
lgindex = self.parent.confconn.getLayerGroupIndex(lgval,col=1)
#lorg = self.parent.confconn.lglist[lgindex][0]
#----------don't need lorg in TP anymore but it is useful for sorting/counting groups
#self.parent.confconn.tp.setLayerOrGroup(lorg)
self.parent.confconn.tp.setLayerGroupValue(lgval)
if self.fromdateenable.isChecked(): self.parent.confconn.tp.setFromDate(fd)
if self.todateenable.isChecked(): self.parent.confconn.tp.setToDate(td)
self.parent.confconn.tp.setUserConf(uconf)
if self.epsgenable: self.parent.confconn.tp.setEPSG(epsg)
#because clean state persists in TP
if clean:
self.parent.confconn.tp.setCleanConfig()
else:
self.parent.confconn.tp.clearCleanConfig()
#(re)initialise the data source since uconf may have changed
#>>#self.parent.confconn.tp.src = self.parent.confconn.initSourceWrapper()
#--------------------------
###ep = self.parent.confconn.reg.openEndPoint(self.parent.confconn.destname,self.parent.confconn.uconf)
###self.parent.confconn.reg.closeEndPoint(self.parent.confconn.destname)
###ep = None
#Open ProcessRunner and run with TP(proc)/self(gui) instances
#HACK temp add of dest_drv to PR call
try:
#TODO. Test for valid LC first
self.tpr = ProcessRunner(self,destination_driver)
except Exception as e:
ldslog.error('Cannot create ProcessRunner {}. NB Possible missing Layer Config {}'.format(str(e),destination_path))
self.layerConfMessage(destination_path)
return
#If PR has been successfully created we must vave a valid dst
ldslog.debug('TRPstart')
self.tpr.start()
# def quitProcessRunner(self):
# self.tpr.join()
# self.tpr.quit()
# self.trp = None
def userConfMessage(self,uconf,secname=None):
ucans = QMessageBox.warning(self, 'User Config Missing/Incomplete',
'Specified User-Config file, '+str(uconf)+' does not exist' if secname is None else 'User-Config file does not contain '+str(secname)+' section',
'Back','Initialise User Config')
if not ucans:
#Retry
ldslog.warn('Retry specifying UC')
#self.confcombo.setCurrentIndex(0)
return
#Init
ldslog.warn('Reset User Config Wizard')
self.parent.runWizardAction()
def layerConfMessage(self,dest):
lcans = QMessageBox.warning(self, 'Layer Config Missing',
'Required Layer-Config file, '+str(dest)+' does not exist',
'Back','Run Layer Select')
if not lcans:
#Retry
ldslog.warn('Retry specifying LC')
#self.destcombo.setCurrentIndex(0)
return
#Init
ldslog.warn('Reset Layer Config')
self.doInitClickAction()
def generateDataTypesField(dataType=None): """ @rtype: QComboBox """ dataTypes = QComboBox() dataTypes.addItems(helper_methods.buildQStringList(['TINYINT', 'SMALLINT', 'MEDIUMINT', 'INT', 'BIGINT', 'BIT'])) dataTypes.insertSeparator(dataTypes.count()) dataTypes.addItems(helper_methods.buildQStringList(['FLOAT', 'DOUBLE', 'DECIMAL'])) dataTypes.insertSeparator(dataTypes.count()) dataTypes.addItems(helper_methods.buildQStringList(['CHAR', 'VARCHAR', 'TINYTEXT', 'TEXT', 'MEDIUMTEXT', 'LONGTEXT'])) dataTypes.insertSeparator(dataTypes.count()) dataTypes.addItems(helper_methods.buildQStringList(['BINARY', 'VARBINARY', 'TINYBLOB', 'BLOB', 'MEDIUMBLOB', 'LONGBLOB'])) dataTypes.insertSeparator(dataTypes.count()) dataTypes.addItems(helper_methods.buildQStringList(['DATE', 'TIME', 'YEAR', 'DATETIME', 'TIMESTAMP'])) dataTypes.insertSeparator(dataTypes.count()) dataTypes.addItems(helper_methods.buildQStringList(['POINT', 'LINESTRING', 'POLYGON', 'GEOMETRY', 'MULTIPOINT', 'MULTILINESTRING', 'MULTIPOLYGON', 'GEOMETRYCOLLECTION'])) dataTypes.insertSeparator(dataTypes.count()) dataTypes.addItems(helper_methods.buildQStringList(['ENUM', 'SET'])) if dataType is not None: dataTypes.setCurrentIndex(dataTypes.findText(dataType.upper())) return dataTypes
