class ProjectData(QWidget):
def __init__(self, parent):
super(ProjectData, self).__init__()
self._parent = parent
grid = QGridLayout(self)
grid.addWidget(QLabel(self.tr("Name:")), 0, 0)
self.name = QLineEdit()
if self._parent._item.name == '':
self.name.setText(file_manager.get_basename(
self._parent._item.path))
else:
self.name.setText(self._parent._item.name)
grid.addWidget(self.name, 0, 1)
grid.addWidget(QLabel(self.tr("Project Type:")), 1, 0)
self.txtType = QLineEdit()
completer = QCompleter(sorted(settings.PROJECT_TYPES))
completer.setCompletionMode(QCompleter.UnfilteredPopupCompletion)
self.txtType.setCompleter(completer)
self.txtType.setText(self._parent._item.projectType)
grid.addWidget(self.txtType, 1, 1)
grid.addWidget(QLabel(self.tr("Description:")), 2, 0)
self.description = QPlainTextEdit()
self.description.setPlainText(self._parent._item.description)
grid.addWidget(self.description, 2, 1)
grid.addWidget(QLabel(self.tr("URL:")), 3, 0)
self.url = QLineEdit()
self.url.setText(self._parent._item.url)
grid.addWidget(self.url, 3, 1)
grid.addWidget(QLabel(self.tr("Licence:")), 4, 0)
self.cboLicense = QComboBox()
self.cboLicense.addItem('Apache License 2.0')
self.cboLicense.addItem('Artistic License/GPL')
self.cboLicense.addItem('Eclipse Public License 1.0')
self.cboLicense.addItem('GNU General Public License v2')
self.cboLicense.addItem('GNU General Public License v3')
self.cboLicense.addItem('GNU Lesser General Public License')
self.cboLicense.addItem('MIT License')
self.cboLicense.addItem('Mozilla Public License 1.1')
self.cboLicense.addItem('New BSD License')
self.cboLicense.addItem('Other Open Source')
self.cboLicense.addItem('Other')
self.cboLicense.setCurrentIndex(4)
index = self.cboLicense.findText(self._parent._item.license)
self.cboLicense.setCurrentIndex(index)
grid.addWidget(self.cboLicense, 4, 1)
self.txtExtensions = QLineEdit()
self.txtExtensions.setText(', '.join(self._parent._item.extensions))
grid.addWidget(QLabel(self.tr("Supported Extensions:")), 5, 0)
grid.addWidget(self.txtExtensions, 5, 1)
grid.addWidget(QLabel(self.tr("Indentation: ")), 6, 0)
self.spinIndentation = QSpinBox()
self.spinIndentation.setValue(self._parent._item.indentation)
self.spinIndentation.setMinimum(1)
grid.addWidget(self.spinIndentation, 6, 1)
self.checkUseTabs = QCheckBox(self.tr("Use Tabs."))
self.checkUseTabs.setChecked(self._parent._item.useTabs)
grid.addWidget(self.checkUseTabs, 6, 2)
def on_actionShow_logfiles_triggered(self):
self._item.setText(3, '')
try:
loglines = self._client.getServiceLogs(self._service,
self._instance)
except ClientError as err:
self._item.setText(3, str(err))
return
if not loglines:
self._item.setText(3, 'Service does not return logs')
return
dlg = QDialog(self)
loadUi(dlg, 'details.ui')
dlg.tabber.clear()
logs = []
for logline in loglines:
filename, content = logline.split(':', 1)
if not logs or filename != logs[-1][0]:
logs.append((filename, []))
logs[-1][1].append(content)
for filename, content in logs:
widget = QPlainTextEdit(dlg)
font = widget.font()
font.setFamily('Monospace')
widget.setFont(font)
widget.setPlainText(''.join(content))
dlg.tabber.addTab(widget, filename)
dlg.exec_()
class RecipeEditionDialog(QDialog):
def __init__(self, recipe = None, parent = None):
super(RecipeEditionDialog, self).__init__(parent)
self.setWindowTitle('Recipe edition')
self.name = QLineEdit()
self.description = QPlainTextEdit()
self.tags = QLineEdit()
buttons = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
buttons.accepted.connect(self.accept)
buttons.rejected.connect(self.reject)
l = QFormLayout(self)
l.addRow('Name', self.name)
l.addRow('Description', self.description)
l.addRow('Tags', self.tags)
l.addWidget(buttons)
if recipe:
self.recipe = recipe
self.name.setText(recipe.name)
self.description.setPlainText(recipe.description)
self.tags.setText(';'.join(t.name for t in recipe.tags))
else:
self.recipe = Recipe('')
self.accepted.connect(self.save_recipe)
def save_recipe(self):
self.recipe.name = self.name.text()
self.recipe.description = self.description.toPlainText()
self.recipe.tags = [Tag.get(t) for t in self.tags.text().split(';')] if self.tags.text() else []
Session.add(self.recipe)
class IdListFilter(QWidget, Control):
""" Multiple ids filter
"""
def __init__(self, tree, dataset, master, parent=None):
QWidget.__init__(self, parent)
Control.__init__(self, tree, dataset, master)
self.tree = tree
self.dataset = dataset
self.master = master
self.setObjectName(tree.internalName)
self.setLayout(QGridLayout())
self.textWidget = QPlainTextEdit() # TODO: Subclass to receive drop events from item model views
self.layout().addWidget(self.textWidget, 0, 0, 1, 1)
def value(self):
""" Return filter value for use in a query
"""
return str(self.textWidget.toPlainText()).split()
def get_filter(self):
return self.tree.internalName, self.value()
def query(self):
return [("Filter", self.tree, self.value())]
def setControlValue(self, name, value):
if type(value) == list:
value = "\n".join(value)
self.textWidget.setPlainText(value)
class IdListFilter(QWidget, Control):
""" Multiple ids filter
"""
def __init__(self, tree, dataset, master, parent=None):
QWidget.__init__(self, parent)
Control.__init__(self, tree, dataset, master)
self.tree = tree
self.dataset = dataset
self.master = master
self.setObjectName(tree.internalName)
self.setLayout(QGridLayout())
self.textWidget = QPlainTextEdit() # TODO: Subclass to receive drop events from item model views
self.layout().addWidget(self.textWidget, 0, 0, 1, 1)
def value(self):
""" Return filter value for use in a query
"""
return str(self.textWidget.toPlainText()).split()
def get_filter(self):
return self.tree.internalName, self.value()
def query(self):
return [("Filter", self.tree, self.value())]
def setControlValue(self, name, value):
if type(value) == list:
value = "\n".join(value)
self.textWidget.setPlainText(value)
class ProjectData(QWidget):
def __init__(self, parent):
super(ProjectData, self).__init__()
self._parent = parent
grid = QGridLayout(self)
grid.addWidget(QLabel(translations.TR_PROJECT_NAME), 0, 0)
self.name = QLineEdit()
if not len(self._parent.project.name):
self.name.setText(file_manager.get_basename(
self._parent.project.path))
else:
self.name.setText(self._parent.project.name)
grid.addWidget(self.name, 0, 1)
grid.addWidget(QLabel(translations.TR_PROJECT_LOCATION), 1, 0)
self.txtPath = QLineEdit()
self.txtPath.setReadOnly(True)
self.txtPath.setText(self._parent.project.path)
grid.addWidget(self.txtPath, 1, 1)
grid.addWidget(QLabel(translations.TR_PROJECT_TYPE), 2, 0)
self.txtType = QLineEdit()
completer = QCompleter(sorted(settings.PROJECT_TYPES))
completer.setCompletionMode(QCompleter.UnfilteredPopupCompletion)
self.txtType.setCompleter(completer)
self.txtType.setText(self._parent.project.project_type)
grid.addWidget(self.txtType, 2, 1)
grid.addWidget(QLabel(translations.TR_PROJECT_DESCRIPTION), 3, 0)
self.description = QPlainTextEdit()
self.description.setPlainText(self._parent.project.description)
grid.addWidget(self.description, 3, 1)
grid.addWidget(QLabel(translations.TR_PROJECT_URL), 4, 0)
self.url = QLineEdit()
self.url.setText(self._parent.project.url)
self.url.setPlaceholderText('https://www.{}.com'.format(getuser()))
grid.addWidget(self.url, 4, 1)
grid.addWidget(QLabel(translations.TR_PROJECT_LICENSE), 5, 0)
self.cboLicense = QComboBox()
self.cboLicense.addItems(LICENCES)
self.cboLicense.setCurrentIndex(12)
index = self.cboLicense.findText(self._parent.project.license)
self.cboLicense.setCurrentIndex(index)
grid.addWidget(self.cboLicense, 5, 1)
self.txtExtensions = QLineEdit()
self.txtExtensions.setText(', '.join(self._parent.project.extensions))
grid.addWidget(QLabel(translations.TR_PROJECT_EXTENSIONS), 6, 0)
grid.addWidget(self.txtExtensions, 6, 1)
grid.addWidget(QLabel(translations.TR_PROJECT_INDENTATION), 7, 0)
self.spinIndentation = QSpinBox()
self.spinIndentation.setValue(self._parent.project.indentation)
self.spinIndentation.setRange(2, 10)
self.spinIndentation.setValue(4)
self.spinIndentation.setSingleStep(2)
grid.addWidget(self.spinIndentation, 7, 1)
self.checkUseTabs = QCheckBox(translations.TR_PROJECT_USE_TABS)
self.checkUseTabs.setChecked(self._parent.project.use_tabs)
grid.addWidget(self.checkUseTabs, 7, 2)
class ProjectData(QWidget):
def __init__(self, parent):
super(ProjectData, self).__init__()
self._parent = parent
grid = QGridLayout(self)
grid.addWidget(QLabel(translations.TR_PROJECT_NAME), 0, 0)
self.name = QLineEdit()
if not len(self._parent.project.name):
self.name.setText(
file_manager.get_basename(self._parent.project.path))
else:
self.name.setText(self._parent.project.name)
grid.addWidget(self.name, 0, 1)
grid.addWidget(QLabel(translations.TR_PROJECT_LOCATION), 1, 0)
self.txtPath = QLineEdit()
self.txtPath.setReadOnly(True)
self.txtPath.setText(self._parent.project.path)
grid.addWidget(self.txtPath, 1, 1)
grid.addWidget(QLabel(translations.TR_PROJECT_TYPE), 2, 0)
self.txtType = QLineEdit()
completer = QCompleter(sorted(settings.PROJECT_TYPES))
completer.setCompletionMode(QCompleter.UnfilteredPopupCompletion)
self.txtType.setCompleter(completer)
self.txtType.setText(self._parent.project.project_type)
grid.addWidget(self.txtType, 2, 1)
grid.addWidget(QLabel(translations.TR_PROJECT_DESCRIPTION), 3, 0)
self.description = QPlainTextEdit()
self.description.setPlainText(self._parent.project.description)
grid.addWidget(self.description, 3, 1)
grid.addWidget(QLabel(translations.TR_PROJECT_URL), 4, 0)
self.url = QLineEdit()
self.url.setText(self._parent.project.url)
self.url.setPlaceholderText('https://www.{}.com'.format(getuser()))
grid.addWidget(self.url, 4, 1)
grid.addWidget(QLabel(translations.TR_PROJECT_LICENSE), 5, 0)
self.cboLicense = QComboBox()
self.cboLicense.addItems(LICENCES)
self.cboLicense.setCurrentIndex(12)
index = self.cboLicense.findText(self._parent.project.license)
self.cboLicense.setCurrentIndex(index)
grid.addWidget(self.cboLicense, 5, 1)
self.txtExtensions = QLineEdit()
self.txtExtensions.setText(', '.join(self._parent.project.extensions))
grid.addWidget(QLabel(translations.TR_PROJECT_EXTENSIONS), 6, 0)
grid.addWidget(self.txtExtensions, 6, 1)
grid.addWidget(QLabel(translations.TR_PROJECT_INDENTATION), 7, 0)
self.spinIndentation = QSpinBox()
self.spinIndentation.setValue(self._parent.project.indentation)
self.spinIndentation.setRange(2, 10)
self.spinIndentation.setValue(4)
self.spinIndentation.setSingleStep(2)
grid.addWidget(self.spinIndentation, 7, 1)
self.checkUseTabs = QCheckBox(translations.TR_PROJECT_USE_TABS)
self.checkUseTabs.setChecked(self._parent.project.use_tabs)
grid.addWidget(self.checkUseTabs, 7, 2)
class ConfigFile(object):
def __init__(self, display_name, absolute_name, tab, deletable=True):
self.display_name = display_name # is unique
self.absolute_name = absolute_name # is also unique
self.tab = tab
self.deletable = deletable
self.index = -1
self.modified = False
self.content = None
self.edit = QPlainTextEdit()
font = QFont('monospace')
font.setStyleHint(QFont.TypeWriter)
self.edit.setWordWrapMode(QTextOption.NoWrap)
self.edit.setFont(font)
self.edit.textChanged.connect(self.check_content)
def check_content(self):
self.set_modified(self.content != self.edit.toPlainText())
def set_modified(self, modified):
if self.modified == modified:
return
self.modified = modified
self.tab.combo_config.setItemText(self.index, self.get_combo_item())
self.tab.update_ui_state()
def set_content(self, content):
# FIXME: QPlainTextEdit does not preserve the original line endings, but
# converts all line endings to \n. this results in a difference
# between self.content and the content stored in the QPlainTextEdit
# even if the user did not edit the content. avoid this problem
# by converting all line endings to \n before setting the content
# of the QPlainTextEdit
content = content.replace('\r\n', '\n')
if self.content == None:
self.edit.setPlainText(content)
self.content = content
self.check_content()
def get_combo_item(self):
if self.modified:
return self.display_name + ' (modified)'
else:
return self.display_name
def discard_changes(self):
self.edit.setPlainText(self.content)
self.set_modified(False)
class ConfigFile(object):
def __init__(self, display_name, absolute_name, tab, deletable=True):
self.display_name = display_name # is unique
self.absolute_name = absolute_name # is also unique
self.tab = tab
self.deletable = deletable
self.index = -1
self.modified = False
self.content = None
self.edit = QPlainTextEdit()
font = QFont('monospace')
font.setStyleHint(QFont.TypeWriter)
self.edit.setWordWrapMode(QTextOption.NoWrap)
self.edit.setFont(font)
self.edit.textChanged.connect(self.check_content)
def check_content(self):
self.set_modified(self.content != self.edit.toPlainText())
def set_modified(self, modified):
if self.modified == modified:
return
self.modified = modified
self.tab.combo_config.setItemText(self.index, self.get_combo_item())
self.tab.update_ui_state()
def set_content(self, content):
# FIXME: QPlainTextEdit does not preserve the original line endings, but
# converts all line endings to \n. this results in a difference
# between self.content and the content stored in the QPlainTextEdit
# even if the user did not edit the content. avoid this problem
# by converting all line endings to \n before setting the content
# of the QPlainTextEdit
content = content.replace('\r\n', '\n')
if self.content == None:
self.edit.setPlainText(content)
self.content = content
self.check_content()
def get_combo_item(self):
if self.modified:
return self.display_name + ' (modified)'
else:
return self.display_name
def discard_changes(self):
self.edit.setPlainText(self.content)
self.set_modified(False)
def __init__(self, settings, name, filename, plain_text=False, parent=None):
super().__init__(parent=parent)
splitty = QSplitter(self)
self.setWidget(splitty)
self.setWindowTitle(os.path.basename(name))
self.setFloating(True)
self.setAttribute(Qt.WA_DeleteOnClose)
self.plain_text = plain_text
self.notePath = settings.notePath
fh = QFile(filename)
try:
if not fh.open(QIODevice.ReadOnly):
raise IOError(fh.errorString())
except IOError as e:
QMessageBox.warning(self, self.tr("Read Error"),
self.tr("Failed to open %s: %s") % (filename, e))
finally:
if fh is not None:
noteBody = QTextStream(fh).readAll()
fh.close()
self.tocw = TocTree(self)
splitty.addWidget(self.tocw)
strip_math_for_header_parsing = False
strip_fence_for_header_parsing = False
self.tocw.itemClicked.connect(self.tocNavigate)
if 'asciimathml' in settings.extensions:
stuff=JSCRIPT_TPL.format(settings.mathjax)
strip_math_for_header_parsing = True
else:
stuff=''
if 'fenced_code' in settings.extensions or 'extra' in settings.extensions:
strip_fence_for_header_parsing = True
if plain_text:
note_view = QPlainTextEdit(self)
qfnt = QFont()
qfnt.setFamily('monospace')
note_view.setFont(qfnt)
note_view.setPlainText(noteBody)
else:
note_view = QWebView(self)
note_view.setHtml(settings.md.reset().convert(noteBody)+stuff)
note_view.page().setLinkDelegationPolicy(QWebPage.DelegateAllLinks)
note_view.linkClicked.connect(self.linkClicked)
note_view.settings().setUserStyleSheetUrl(
QUrl('file://'+self.parent().settings.cssfile))
self.note_view = note_view
splitty.addWidget(note_view)
self.tocw.updateToc(os.path.basename(name),
parseHeaders(noteBody, strip_fenced_block=strip_fence_for_header_parsing,
strip_ascii_math=strip_math_for_header_parsing))
class Skin(QWidget):
def __init__(self, pref):
QWidget.__init__(self)
vbox = QVBoxLayout(self)
vbox.addWidget(QLabel('Configure the CSS (Skin) for this Application'))
self.checkDefault = QCheckBox('Default')
self.checkCustom = QCheckBox('Custom')
self.checkNoSkin = QCheckBox('No Skin')
hbox = QHBoxLayout()
hbox.addWidget(self.checkDefault)
hbox.addWidget(self.checkCustom)
hbox.addWidget(self.checkNoSkin)
vbox.addLayout(hbox)
self.text = QPlainTextEdit()
self.text.setEnabled(False)
self.text.setPlainText(styles.css_styles)
vbox.addWidget(self.text)
if pref.get('noSkin', False):
self.checkNoSkin.setCheckState(Qt.Checked)
elif pref.get('custom', False):
self.checkCustom.setCheckState(Qt.Checked)
self.text.setEnabled(True)
self.text.setPlainText(pref.get('skin', ''))
else:
self.checkDefault.setCheckState(Qt.Checked)
self.connect(self.checkDefault, SIGNAL("stateChanged(int)"), self.use_default)
self.connect(self.checkCustom, SIGNAL("stateChanged(int)"), self.use_custom)
self.connect(self.checkNoSkin, SIGNAL("stateChanged(int)"), self.use_no_skin)
def use_default(self, val):
if val == 2:
self.checkDefault.setCheckState(Qt.Checked)
self.checkCustom.setCheckState(Qt.Unchecked)
self.checkNoSkin.setCheckState(Qt.Unchecked)
self.text.setEnabled(False)
def use_custom(self, val):
if val == 2:
self.checkDefault.setCheckState(Qt.Unchecked)
self.checkCustom.setCheckState(Qt.Checked)
self.checkNoSkin.setCheckState(Qt.Unchecked)
self.text.setEnabled(True)
def use_no_skin(self, val):
if val == 2:
self.checkDefault.setCheckState(Qt.Unchecked)
self.checkCustom.setCheckState(Qt.Unchecked)
self.checkNoSkin.setCheckState(Qt.Checked)
self.text.setEnabled(False)
class ProjectMetadata(QWidget):
def __init__(self, parent):
super(ProjectMetadata, self).__init__()
self._parent = parent
vbox = QVBoxLayout(self)
vbox.addWidget(QLabel(translations.TR_PROJECT_METADATA_RELATED))
self.txt_projects = QPlainTextEdit()
vbox.addWidget(self.txt_projects)
vbox.addWidget(QLabel(translations.TR_PROJECT_METADATA_TIP))
paths = '\n'.join(self._parent.project.related_projects)
self.txt_projects.setPlainText(paths)
class ProjectMetadata(QWidget):
def __init__(self, parent):
super(ProjectMetadata, self).__init__()
self._parent = parent
vbox = QVBoxLayout(self)
vbox.addWidget(QLabel(translations.TR_PROJECT_METADATA_RELATED))
self.txt_projects = QPlainTextEdit()
vbox.addWidget(self.txt_projects)
vbox.addWidget(QLabel(translations.TR_PROJECT_METADATA_TIP))
paths = '\n'.join(self._parent.project.related_projects)
self.txt_projects.setPlainText(paths)
class ProjectMetadata(QWidget):
def __init__(self, parent):
super(ProjectMetadata, self).__init__()
self._parent = parent
vbox = QVBoxLayout(self)
vbox.addWidget(
QLabel(
self.tr("Insert the path of Python Projects related"
"to this one in order\nto improve Code Completion.")))
self.txt_projects = QPlainTextEdit()
vbox.addWidget(self.txt_projects)
vbox.addWidget(
QLabel(self.tr("Split your paths using newlines [ENTER].")))
paths = '\n'.join(self._parent._item.related_projects)
self.txt_projects.setPlainText(paths)
class ProjectMetadata(QWidget):
def __init__(self, parent):
super(ProjectMetadata, self).__init__()
self._parent = parent
vbox = QVBoxLayout(self)
vbox.addWidget(QLabel(self.tr(
"Insert the path of Python Projects related"
"to this one in order\nto improve Code Completion.")))
self.txt_projects = QPlainTextEdit()
vbox.addWidget(self.txt_projects)
vbox.addWidget(QLabel(
self.tr("Split your paths using newlines [ENTER].")))
paths = '\n'.join(self._parent._item.related_projects)
self.txt_projects.setPlainText(paths)
class DropDownIdListFilter(QWidget, Control):
"""Container for multiple id list filters
"""
def __init__(self, tree, dataset, master, parent=None):
QWidget.__init__(self, parent)
Control.__init__(self, tree, dataset, master)
self.setLayout(QVBoxLayout())
self.setContentsMargins(0, 0, 0, 0)
self.cb = QComboBox()
self.idsEdit = QPlainTextEdit()
self.layout().addWidget(self.cb)
self.layout().addWidget(self.idsEdit)
self.options = []
self.setOptions(tree.subelements_top("Option"))
def setOptions(self, options):
self.cb.clear()
self.options = []
for option in options:
self.cb.addItem(option.displayName)
self.options.append(option)
def value(self):
return str(self.idsEdit.toPlainText()).split()
def query(self):
filter = self.options[self.cb.currentIndex()]
filter = biomart.FilterDescription(
self.tree.registry, "FilterDescription",
filter.attributes, filter.children)
return [("Filter", filter, self.value())]
def setControlValue(self, name, value):
if isinstance(value, list):
value = "\n".join(value)
for i, op in enumerate(self.options):
if name == op.internalName:
self.cb.setCurrentIndex(i)
self.idsEdit.setPlainText(value)
class TextpadWidget(QFrame):
def __init__(self, parent):
QFrame.__init__(self, parent)
self.textpad = QPlainTextEdit(self)
self.setLayout(QHBoxLayout())
self.layout().setContentsMargins(0, 0, 0, 0)
self.layout().addWidget(self.textpad)
self.setFrameStyle(QFrame.Box | QFrame.Sunken)
self.setStyleSheet("QPlainTextEdit{background:transparent;}")
settings = self.window().platform.getSettings()
text = settings.value("textpad", "")
self.textpad.setPlainText(text)
def finalize(self):
settings = self.window().platform.getSettings()
settings.setValue("textpad", self.textpad.toPlainText())
class TextpadWidget(QFrame):
def __init__(self, parent):
QFrame.__init__(self, parent)
self.textpad = QPlainTextEdit(self)
self.setLayout(QHBoxLayout())
self.layout().setContentsMargins(0, 0, 0, 0)
self.layout().addWidget(self.textpad)
self.setFrameStyle(QFrame.Box | QFrame.Sunken)
self.setStyleSheet("QPlainTextEdit{background:transparent;}")
settings = self.window().platform.getSettings()
text = settings.value("textpad", "")
self.textpad.setPlainText(text)
def finalize(self):
settings = self.window().platform.getSettings()
settings.setValue("textpad", self.textpad.toPlainText())
class mainWidget(QWidget):
def __init__(self, parent=None):
QWidget.__init__(self, parent)
self.create_layout()
self.update_buttons_state()
self.connect_slots()
def create_layout(self):
self.facadeserver_button = QPushButton(self)
self.elindevices_button = QPushButton(self)
self.devlist_edit = QPlainTextEdit(self)
self.elindevices_button.setText("Get list of devices and 'current' attribute values")
self.layout = QVBoxLayout(self)
self.layout.addWidget(self.facadeserver_button, 0)
self.layout.addWidget(self.elindevices_button, 1)
self.layout.addWidget(self.devlist_edit, 2)
def update_buttons_state(self):
self.facadeController = FacadeDeviceServerController()
if self.facadeController.server_exists():
self.facadeserver_button.setText("Update Facadedevice Server")
self.elindevices_button.setEnabled(True)
else:
self.facadeserver_button.setText("Create Facadedevice Server")
self.elindevices_button.setEnabled(False)
def connect_slots(self):
self.connect(self.facadeserver_button, QtCore.SIGNAL("clicked()"), self.create_server)
self.connect(self.elindevices_button, QtCore.SIGNAL("clicked()"), self.get_devs_and_attr_list)
def create_server(self):
print("Creating/Updating Facadedevice server...")
self.facadeController.create_server()
self.update_buttons_state()
print("...done")
def get_devs_and_attr_list(self):
facades = self.facadeController.get_facadedevice_names()
devs_and_attrs = CurrentAttributeHelper.get_devs_and_attributes(facades)
self.devlist_edit.clear()
self.devlist_edit.setPlainText(devs_and_attrs)
class RecipeEditionDialog(QDialog):
def __init__(self, recipe=None, parent=None):
super(RecipeEditionDialog, self).__init__(parent)
self.setWindowTitle('Recipe edition')
self.name = QLineEdit()
self.description = QPlainTextEdit()
self.tags = QLineEdit()
buttons = QDialogButtonBox(QDialogButtonBox.Ok
| QDialogButtonBox.Cancel)
buttons.accepted.connect(self.accept)
buttons.rejected.connect(self.reject)
l = QFormLayout(self)
l.addRow('Name', self.name)
l.addRow('Description', self.description)
l.addRow('Tags', self.tags)
l.addWidget(buttons)
if recipe:
self.recipe = recipe
self.name.setText(recipe.name)
self.description.setPlainText(recipe.description)
self.tags.setText(';'.join(t.name for t in recipe.tags))
else:
self.recipe = Recipe('')
self.accepted.connect(self.save_recipe)
def save_recipe(self):
self.recipe.name = self.name.text()
self.recipe.description = self.description.toPlainText()
self.recipe.tags = [Tag.get(t) for t in self.tags.text().split(';')
] if self.tags.text() else []
Session.add(self.recipe)
class SystemLog(object):
def __init__(self, display_name, source_name):
self.display_name = display_name
self.source_name = source_name # FIXME: need to handle rotated logs
self.last_filename = os.path.join(get_home_path(), display_name)
self.content = ''
self.edit = QPlainTextEdit()
self.normal_font = self.edit.font()
self.monospace_font = QFont('monospace')
self.edit.setUndoRedoEnabled(False)
self.edit.setReadOnly(True)
self.edit.setWordWrapMode(QTextOption.NoWrap)
self.edit.setPlainText(
'Click "Refresh" to download {0}.'.format(display_name))
self.monospace_font.setStyleHint(QFont.TypeWriter)
def log(self, message, bold=False, pre=False):
if bold:
self.edit.appendHtml(u'<b>{0}</b>'.format(Qt.escape(message)))
elif pre:
self.edit.appendHtml(u'<pre>{0}</pre>'.format(message))
else:
self.edit.appendPlainText(message)
def reset(self):
self.content = None
self.edit.setPlainText('')
self.edit.setFont(self.normal_font)
def set_content(self, content):
self.content = content
self.edit.setPlainText('')
self.edit.setFont(self.monospace_font)
self.edit.setPlainText(content)
class SystemLog(object):
def __init__(self, display_name, source_name):
self.display_name = display_name
self.source_name = source_name # FIXME: need to handle rotated logs
self.last_filename = os.path.join(get_home_path(), display_name)
self.content = ''
self.edit = QPlainTextEdit()
self.normal_font = self.edit.font()
self.monospace_font = QFont('monospace')
self.edit.setUndoRedoEnabled(False)
self.edit.setReadOnly(True)
self.edit.setWordWrapMode(QTextOption.NoWrap)
self.edit.setPlainText('Click "Refresh" to download {0}.'.format(display_name))
self.monospace_font.setStyleHint(QFont.TypeWriter)
def log(self, message, bold=False, pre=False):
if bold:
self.edit.appendHtml(u'<b>{0}</b>'.format(Qt.escape(message)))
elif pre:
self.edit.appendHtml(u'<pre>{0}</pre>'.format(message))
else:
self.edit.appendPlainText(message)
def reset(self):
self.content = None
self.edit.setPlainText('')
self.edit.setFont(self.normal_font)
def set_content(self, content):
self.content = content
self.edit.setPlainText('')
self.edit.setFont(self.monospace_font)
self.edit.setPlainText(content)
class GdalParametersPanel(ParametersPanel):
def __init__(self, parent, alg):
ParametersPanel.__init__(self, parent, alg)
w = QWidget()
layout = QVBoxLayout()
layout.setMargin(0)
layout.setSpacing(6)
label = QLabel()
label.setText(self.tr("GDAL/OGR console call"))
layout.addWidget(label)
self.text = QPlainTextEdit()
self.text.setReadOnly(True)
layout.addWidget(self.text)
w.setLayout(layout)
self.layoutMain.addWidget(w)
self.connectParameterSignals()
self.parametersHaveChanged()
def connectParameterSignals(self):
for w in self.widgets.values():
if isinstance(w, QLineEdit):
w.textChanged.connect(self.parametersHaveChanged)
elif isinstance(w, QComboBox):
w.currentIndexChanged.connect(self.parametersHaveChanged)
elif isinstance(w, QCheckBox):
w.stateChanged.connect(self.parametersHaveChanged)
elif isinstance(w, MultipleInputPanel):
w.selectionChanged.connect(self.parametersHaveChanged)
elif isinstance(w, NumberInputPanel):
w.hasChanged.connect(self.parametersHaveChanged)
def parametersHaveChanged(self):
try:
self.parent.setParamValues()
for output in self.alg.outputs:
if output.value is None:
output.value = self.tr("[temporary file]")
commands = self.alg.getConsoleCommands()
commands = [c for c in commands if c not in ['cmd.exe', '/C ']]
self.text.setPlainText(" ".join(commands))
except AlgorithmDialogBase.InvalidParameterValue as e:
self.text.setPlainText(self.tr("Invalid value for parameter '%s'") % e.parameter.description)
except:
self.text.setPlainText("")
class ProjectExecution(QWidget):
def __init__(self, parent):
super(ProjectExecution, self).__init__()
self._parent = parent
grid = QGridLayout(self)
grid.addWidget(QLabel(self.tr("Main File:")), 0, 0)
self.path = QLineEdit()
ui_tools.LineEditButton(self.path, self.path.clear,
self.style().standardPixmap(self.style().SP_TrashIcon))
self.path.setText(self._parent._item.mainFile)
self.path.setReadOnly(True)
self.btnBrowse = QPushButton(QIcon(
self.style().standardPixmap(self.style().SP_FileIcon)), '')
grid.addWidget(self.path, 0, 1)
grid.addWidget(self.btnBrowse, 0, 2)
# this should be changed, and ALL pythonPath names to
# python_custom_interpreter or something like that. this is NOT the
# PYTHONPATH
self.txtPythonPath = QLineEdit()
self.txtPythonPath.setText(self._parent._item.pythonPath)
self.btnPythonPath = QPushButton(QIcon(resources.IMAGES['open']), '')
grid.addWidget(QLabel(self.tr("Python Custom Interpreter:")), 1, 0)
grid.addWidget(self.txtPythonPath, 1, 1)
grid.addWidget(self.btnPythonPath, 1, 2)
# THIS IS THE MODAFUCKA REAL PYTHONPATH BRO, YEAH !!!
grid.addWidget(QLabel(self.tr("Custom PYTHONPATH:")), 2, 0)
self.PYTHONPATH = QPlainTextEdit() # TODO : better widget
self.PYTHONPATH.setPlainText(self._parent._item.PYTHONPATH)
self.PYTHONPATH.setToolTip(self.tr("One path per line"))
grid.addWidget(self.PYTHONPATH, 2, 1)
# Additional builtins/globals for pyflakes
grid.addWidget(QLabel(self.tr("Additional builtins/globals:")), 3, 0)
self.additional_builtins = QLineEdit()
self.additional_builtins.setText(
' '.join(self._parent._item.additional_builtins))
self.additional_builtins.setToolTip(self.tr(
"Space-separated list of symbols that will be considered as "
"builtin in every file"))
grid.addWidget(self.additional_builtins, 3, 1)
self.txtPreExec = QLineEdit()
ui_tools.LineEditButton(self.txtPreExec, self.txtPreExec.clear,
self.style().standardPixmap(self.style().SP_TrashIcon))
self.txtPreExec.setReadOnly(True)
self.txtPreExec.setText(self._parent._item.preExecScript)
self.btnPreExec = QPushButton(QIcon(resources.IMAGES['open']), '')
grid.addWidget(QLabel(self.tr("Pre-exec Script:")), 4, 0)
grid.addWidget(self.txtPreExec, 4, 1)
grid.addWidget(self.btnPreExec, 4, 2)
self.txtPostExec = QLineEdit()
ui_tools.LineEditButton(self.txtPostExec, self.txtPostExec.clear,
self.style().standardPixmap(self.style().SP_TrashIcon))
self.txtPostExec.setReadOnly(True)
self.txtPostExec.setText(self._parent._item.postExecScript)
self.btnPostExec = QPushButton(QIcon(resources.IMAGES['open']), '')
grid.addWidget(QLabel(self.tr("Post-exec Script:")), 5, 0)
grid.addWidget(self.txtPostExec, 5, 1)
grid.addWidget(self.btnPostExec, 5, 2)
grid.addItem(QSpacerItem(5, 10, QSizePolicy.Expanding,
QSizePolicy.Expanding), 6, 0)
# Properties
grid.addWidget(QLabel(self.tr("Properties:")), 7, 0)
self.txtParams = QLineEdit()
self.txtParams.setToolTip(
self.tr("Separate the params with commas (ie: help, verbose)"))
self.txtParams.setText(self._parent._item.programParams)
grid.addWidget(QLabel(self.tr("Params (comma separated):")), 8, 0)
grid.addWidget(self.txtParams, 8, 1)
#Widgets for virtualenv properties
self.txtVenvPath = QLineEdit()
ui_tools.LineEditButton(self.txtVenvPath, self.txtVenvPath.clear,
self.style().standardPixmap(self.style().SP_TrashIcon))
self.txtVenvPath.setText(self._parent._item.venv)
self._dir_completer = QCompleter()
self._dir_completer.setModel(QDirModel(self._dir_completer))
self.txtVenvPath.setCompleter(self._dir_completer)
self.btnVenvPath = QPushButton(QIcon(resources.IMAGES['open']), '')
grid.addWidget(QLabel(self.tr("Virtualenv Folder:")), 9, 0)
grid.addWidget(self.txtVenvPath, 9, 1)
grid.addWidget(self.btnVenvPath, 9, 2)
self.connect(self.btnBrowse, SIGNAL("clicked()"), self.select_file)
self.connect(self.btnPythonPath, SIGNAL("clicked()"),
self._load_python_path)
self.connect(self.btnVenvPath, SIGNAL("clicked()"),
self._load_python_venv)
self.connect(self.btnPreExec, SIGNAL("clicked()"),
self.select_pre_exec_script)
self.connect(self.btnPostExec, SIGNAL("clicked()"),
self.select_post_exec_script)
def _load_python_path(self):
path = QFileDialog.getOpenFileName(
self, self.tr("Select Python Path"))
self.txtPythonPath.setText(path)
def _load_python_venv(self):
venv = QFileDialog.getExistingDirectory(
self, self.tr("Select Virtualenv Folder"))
if sys.platform == 'win32':
venv = os.path.join(venv, 'Scripts', 'python.exe')
else:
venv = os.path.join(venv, 'bin', 'python')
#check if venv folder exists
if not os.path.exists(venv):
QMessageBox.information(self,
self.tr("Virtualenv Folder"),
self.tr("This is not a valid Virtualenv Folder"))
self.txtVenvPath.setText("")
else:
self.txtVenvPath.setText(venv)
def select_file(self):
fileName = QFileDialog.getOpenFileName(
self, self.tr("Select Main File"),
self._parent._item.path, '(*.py);;(*.*)')
if fileName != '':
fileName = file_manager.convert_to_relative(
self._parent._item.path, fileName)
self.path.setText(fileName)
def select_pre_exec_script(self):
fileName = QFileDialog.getOpenFileName(
self, self.tr("Select Pre Execution Script File"),
self._parent._item.path, '(*.*)')
if fileName != '':
fileName = file_manager.convert_to_relative(
self._parent._item.path, fileName)
self.txtPreExec.setText(fileName)
def select_post_exec_script(self):
fileName = QFileDialog.getOpenFileName(
self, self.tr("Select Post Execution Script File"),
self._parent._item.path, '(*.*)')
if fileName != '':
fileName = file_manager.convert_to_relative(
self._parent._item.path, fileName)
self.txtPostExec.setText(fileName)
class OWodbcTable(OWWidget):
priority = 3
allSQLSelectWidgets = []
settingsList = ["recentConnections", "lastQuery"]
name = "ODBC"
description = "Create a Table from an ODBC datasource"
icon = "../icons/sql.png"
inputs = []
outputs = [
("Data", Orange.data.Table, widget.Default),
("Feature Definitions", Orange.data.Domain, widget.Default),
("Pandas", pd.DataFrame, widget.Default),
]
settingsHandler = settings.DomainContextHandler()
def __init__(self):
super().__init__()
gui.label(self.controlArea, self, "from pandas:")
self.setSizePolicy(QSizePolicy.Maximum, QSizePolicy.Maximum)
self.allSQLSelectWidgets.append(self) # set default settings
self.domain = None
self.recentConnections = list()
self.recentConnections.append("(none)")
self.queryFile = None
self.query = ""
self.lastQuery = None
if self.lastQuery is not None:
self.query = self.lastQuery
sources = pyodbc.dataSources()
dsns = list(sources.keys())
dsns.sort()
for dsn in dsns:
self.recentConnections.append("DSN={dsn}".format(dsn=dsn))
self.connectString = self.recentConnections[0]
self.connectBox = gui.widgetBox(self.controlArea, "Database")
self.connectLineEdit = gui.lineEdit(self.connectBox, self, "connectString", callback=None)
self.connectCombo = gui.comboBox(
self.connectBox, self, "connectString", items=self.recentConnections, valueType=str, sendSelectedValue=True
)
self.button = gui.button(self.connectBox, self, "connect", callback=self.connectDB, disabled=0)
# query
self.splitCanvas = QSplitter(QtCore.Qt.Vertical, self.mainArea)
self.mainArea.layout().addWidget(self.splitCanvas)
self.textBox = gui.widgetBox(self, "HiveQL")
self.splitCanvas.addWidget(self.textBox)
self.queryTextEdit = QPlainTextEdit(self.query, self)
self.textBox.layout().addWidget(self.queryTextEdit)
self.selectBox = gui.widgetBox(self.controlArea, "Select statement")
# self.selectSubmitBox = QHGroupBox("", self.selectBox)
# self.queryTextEdit.setSizePolicy(QSizePolicy(QSizePolicy.Preferred, QSizePolicy.Preferred))
# self.queryTextEdit.setMinimumWidth(300)
# self.connect(self.queryTextEdit, SIGNAL('returnPressed()'), self.executeQuery)
gui.button(self.selectBox, self, "Open...", callback=self.openScript)
gui.button(self.selectBox, self, "Save...", callback=self.saveScript)
self.selectBox.setSizePolicy(QSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.MinimumExpanding))
gui.button(self.selectBox, self, "format SQL!", callback=self.format_sql, disabled=0)
gui.button(self.selectBox, self, "execute!", callback=self.executeQuery, disabled=0)
self.domainBox = gui.widgetBox(self.controlArea, "Domain")
self.domainLabel = gui.label(self.domainBox, self, "")
# info
self.infoBox = gui.widgetBox(self.controlArea, "Info")
self.info = []
self.info.append(gui.label(self.infoBox, self, "No data loaded."))
self.info.append(gui.label(self.infoBox, self, ""))
self.resize(300, 300)
self.cnxn = None
def destroy(self, destroyWindow, destroySubWindows):
self.allSQLSelectWidgets.remove(self)
self.destroy(self, destroyWindow, destroySubWindows)
def activateLoadedSettings(self):
# print "activating", self.recentQueries, ", ",self.recentConnections
self.query = self.lastQuery
self.setConnectionList()
def selectConnection(self, n):
if n < len(self.recentConnections):
name = self.recentConnections[n]
self.recentConnections.remove(name)
self.recentConnections.insert(0, name)
if len(self.recentConnections) > 0:
self.setConnectionList()
self.connectDB(self.recentConnections[0])
def setInfo(self, info):
for (i, s) in enumerate(info):
self.info[i].setText(s)
def setMeta(self):
domain = self.data.domain
# s = "Attrs:\n " + "\n ".join([str(i) for i in domain.attributes]) + "\n" + "Class:" + str(domain.classVar)
# self.domainLabel.setText(s)
# for i in domain.getmetas():
# self.propertyCheckBoxes[i].set()
# checks whether any file widget knows of any variable from the current domain
def attributesOverlap(self, domain):
for fw in self.allFileWidgets:
if fw != self and getattr(fw, "dataDomain", None):
for var in domain:
if var in fw.dataDomain:
return True
return False
# Execute a query, create data from it and send it over the data channel
def executeQuery(self, query=None, throughReload=0, DK=None, DC=None):
self.connectDB()
query = self.queryTextEdit.toPlainText()
if query is None:
query = str(self.queryTextEdit.toPlainText())
# try:
self.pandas = psql.read_sql_query(query, self.cnxn)
# except Exception:
# self.setInfo(('Query failed:', str('')))
# df = pd.DataFrame()
self.data = convert_dataframe_to_orange(self.pandas)
self.send("Data", self.data)
self.send("Pandas", self.pandas)
self.setInfo(("Query returned", "Read " + str(len(self.data)) + " examples!"))
self.send("Feature Definitions", self.data.domain)
self.setMeta()
self.lastQuery = query
def format_sql(self):
query = str(self.queryTextEdit.toPlainText())
str_sql = str(format_sql(query))
self.queryTextEdit.clear()
self.queryTextEdit.insertPlainText(str_sql)
def connectDB(self):
if self.connectString is None:
self.connectString = str(self.connectString)
if self.connectString in self.recentConnections:
self.recentConnections.remove(self.connectString)
self.recentConnections.insert(0, self.connectString)
print(self.connectString)
self.cnxn = pyodbc.connect(self.connectString, autocommit=True)
# set the query combo box
def setConnectionList(self):
self.connectCombo.clear()
if not self.recentConnections:
self.connectCombo.insertItem("(none)")
else:
self.connectLineEdit.setText(self.recentConnections[0])
for connection in self.recentConnections:
self.connectCombo.insertItem(connection)
self.connectCombo.updateGeometry()
def openScript(self, filename=None):
if self.queryFile is None:
self.queryFile = ""
if filename == None:
self.queryFile = QFileDialog.getOpenFileName(
self, "Open SQL file", self.queryFile, "SQL files (*.sql)\nAll files(*.*)"
)
else:
self.queryFile = filename
if self.queryFile == "":
return
f = open(self.queryFile, "r")
self.queryTextEdit.setPlainText(f.read())
f.close()
def saveScript(self):
if self.queryFile is None:
self.queryFile = ""
self.queryFile = QFileDialog.getSaveFileName(
self, "Save SQL file", self.queryFile, "SQL files (*.sql)\nAll files(*.*)"
)
if self.queryFile:
fn = ""
head, tail = os.path.splitext(self.queryFile)
if not tail:
fn = head + ".sql"
else:
fn = self.queryFile
f = open(fn, "w")
f.write(self.queryTextEdit.toPlainText())
f.close()
class MigrationWidget(QWidget):
def __init__(self):
super(MigrationWidget, self).__init__()
self._migration = {}
vbox = QVBoxLayout(self)
lbl_title = QLabel(self.tr("Current code:"))
self.current_list = QListWidget()
lbl_suggestion = QLabel(self.tr("Suggested changes:"))
self.suggestion = QPlainTextEdit()
self.suggestion.setReadOnly(True)
self.btn_apply = QPushButton(self.tr("Apply change!"))
hbox = QHBoxLayout()
hbox.addSpacerItem(QSpacerItem(1, 0, QSizePolicy.Expanding))
hbox.addWidget(self.btn_apply)
vbox.addWidget(lbl_title)
vbox.addWidget(self.current_list)
vbox.addWidget(lbl_suggestion)
vbox.addWidget(self.suggestion)
vbox.addLayout(hbox)
self.connect(self.current_list,
SIGNAL("itemClicked(QListWidgetItem*)"),
self.load_suggestion)
self.connect(self.btn_apply, SIGNAL("clicked()"), self.apply_changes)
def apply_changes(self):
lineno = int(self.current_list.currentItem().data(Qt.UserRole))
lines = self._migration.migration_data[lineno][0].split('\n')
remove = -1
code = ''
for line in lines:
if line.startswith('-'):
remove += 1
elif line.startswith('+'):
code += '%s\n' % line[1:]
editorWidget = main_container.MainContainer().get_actual_editor()
block_start = editorWidget.document().findBlockByLineNumber(lineno)
block_end = editorWidget.document().findBlockByLineNumber(lineno +
remove)
cursor = editorWidget.textCursor()
cursor.setPosition(block_start.position())
cursor.setPosition(block_end.position(), QTextCursor.KeepAnchor)
cursor.movePosition(QTextCursor.EndOfLine, QTextCursor.KeepAnchor)
cursor.insertText(code[:-1])
def load_suggestion(self, item):
lineno = int(item.data(Qt.UserRole))
lines = self._migration.migration_data[lineno][0].split('\n')
code = ''
for line in lines:
if line.startswith('+'):
code += '%s\n' % line[1:]
self.suggestion.setPlainText(code)
editorWidget = main_container.MainContainer().get_actual_editor()
if editorWidget:
editorWidget.jump_to_line(lineno)
editorWidget.setFocus()
def refresh_lists(self, migration):
self._migration = migration
self.current_list.clear()
base_lineno = -1
for lineno in sorted(migration.migration_data.keys()):
linenostr = 'L%s\n' % str(lineno + 1)
data = migration.migration_data[lineno]
lines = data[0].split('\n')
if base_lineno == data[1]:
continue
base_lineno = data[1]
message = ''
for line in lines:
if line.startswith('-'):
message += '%s\n' % line
item = QListWidgetItem(linenostr + message)
item.setToolTip(linenostr + message)
item.setData(Qt.UserRole, lineno)
self.current_list.addItem(item)
def clear(self):
"""
Clear the widget
"""
self.current_list.clear()
self.suggestion.clear()
class ProjectExecution(QWidget):
def __init__(self, parent):
super(ProjectExecution, self).__init__()
self._parent = parent
grid = QGridLayout(self)
grid.addWidget(QLabel(self.tr("Main File:")), 0, 0)
self.path = QLineEdit()
ui_tools.LineEditButton(
self.path, self.path.clear,
self.style().standardPixmap(self.style().SP_TrashIcon))
self.path.setText(self._parent._item.mainFile)
self.path.setReadOnly(True)
self.btnBrowse = QPushButton(
QIcon(self.style().standardPixmap(self.style().SP_FileIcon)), '')
grid.addWidget(self.path, 0, 1)
grid.addWidget(self.btnBrowse, 0, 2)
# this should be changed, and ALL pythonPath names to
# python_custom_interpreter or something like that. this is NOT the
# PYTHONPATH
self.txtPythonPath = QLineEdit()
self.txtPythonPath.setText(self._parent._item.pythonPath)
self.btnPythonPath = QPushButton(QIcon(resources.IMAGES['open']), '')
grid.addWidget(QLabel(self.tr("Python Custom Interpreter:")), 1, 0)
grid.addWidget(self.txtPythonPath, 1, 1)
grid.addWidget(self.btnPythonPath, 1, 2)
# THIS IS THE MODAFUCKA REAL PYTHONPATH BRO, YEAH !!!
grid.addWidget(QLabel(self.tr("Custom PYTHONPATH:")), 2, 0)
self.PYTHONPATH = QPlainTextEdit() # TODO : better widget
self.PYTHONPATH.setPlainText(self._parent._item.PYTHONPATH)
self.PYTHONPATH.setToolTip(self.tr("One path per line"))
grid.addWidget(self.PYTHONPATH, 2, 1)
self.txtPreExec = QLineEdit()
ui_tools.LineEditButton(
self.txtPreExec, self.txtPreExec.clear,
self.style().standardPixmap(self.style().SP_TrashIcon))
self.txtPreExec.setReadOnly(True)
self.txtPreExec.setText(self._parent._item.preExecScript)
self.btnPreExec = QPushButton(QIcon(resources.IMAGES['open']), '')
grid.addWidget(QLabel(self.tr("Pre-exec Script:")), 3, 0)
grid.addWidget(self.txtPreExec, 3, 1)
grid.addWidget(self.btnPreExec, 3, 2)
self.txtPostExec = QLineEdit()
ui_tools.LineEditButton(
self.txtPostExec, self.txtPostExec.clear,
self.style().standardPixmap(self.style().SP_TrashIcon))
self.txtPostExec.setReadOnly(True)
self.txtPostExec.setText(self._parent._item.postExecScript)
self.btnPostExec = QPushButton(QIcon(resources.IMAGES['open']), '')
grid.addWidget(QLabel(self.tr("Post-exec Script:")), 4, 0)
grid.addWidget(self.txtPostExec, 4, 1)
grid.addWidget(self.btnPostExec, 4, 2)
grid.addItem(
QSpacerItem(5, 10, QSizePolicy.Expanding, QSizePolicy.Expanding),
5, 0)
# Properties
grid.addWidget(QLabel(self.tr("Properties:")), 6, 0)
self.txtParams = QLineEdit()
self.txtParams.setToolTip(
self.tr("Separate the params with commas (ie: help, verbose)"))
self.txtParams.setText(self._parent._item.programParams)
grid.addWidget(QLabel(self.tr("Params (comma separated):")), 7, 0)
grid.addWidget(self.txtParams, 7, 1)
#Widgets for virtualenv properties
self.txtVenvPath = QLineEdit()
ui_tools.LineEditButton(
self.txtVenvPath, self.txtVenvPath.clear,
self.style().standardPixmap(self.style().SP_TrashIcon))
self.txtVenvPath.setText(self._parent._item.venv)
self.txtVenvPath.setReadOnly(True)
self.btnVenvPath = QPushButton(QIcon(resources.IMAGES['open']), '')
grid.addWidget(QLabel(self.tr("Virtualenv Folder:")), 8, 0)
grid.addWidget(self.txtVenvPath, 8, 1)
grid.addWidget(self.btnVenvPath, 8, 2)
self.connect(self.btnBrowse, SIGNAL("clicked()"), self.select_file)
self.connect(self.btnPythonPath, SIGNAL("clicked()"),
self._load_python_path)
self.connect(self.btnVenvPath, SIGNAL("clicked()"),
self._load_python_venv)
self.connect(self.btnPreExec, SIGNAL("clicked()"),
self.select_pre_exec_script)
self.connect(self.btnPostExec, SIGNAL("clicked()"),
self.select_post_exec_script)
def _load_python_path(self):
path = QFileDialog.getOpenFileName(self, self.tr("Select Python Path"))
self.txtPythonPath.setText(path)
def _load_python_venv(self):
venv = QFileDialog.getExistingDirectory(
self, self.tr("Select Virtualenv Folder"))
if sys.platform == 'win32':
venv = os.path.join(venv, 'Scripts', 'python.exe')
else:
venv = os.path.join(venv, 'bin', 'python')
#check if venv folder exists
if not os.path.exists(venv):
QMessageBox.information(
self, self.tr("Virtualenv Folder"),
self.tr("This is not a valid Virtualenv Folder"))
self.txtVenvPath.setText("")
else:
self.txtVenvPath.setText(venv)
def select_file(self):
fileName = QFileDialog.getOpenFileName(self,
self.tr("Select Main File"),
self._parent._item.path,
'(*.py);;(*.*)')
if fileName != '':
fileName = file_manager.convert_to_relative(
self._parent._item.path, fileName)
self.path.setText(fileName)
def select_pre_exec_script(self):
fileName = QFileDialog.getOpenFileName(
self, self.tr("Select Pre Execution Script File"),
self._parent._item.path, '(*.*)')
if fileName != '':
fileName = file_manager.convert_to_relative(
self._parent._item.path, fileName)
self.txtPreExec.setText(fileName)
def select_post_exec_script(self):
fileName = QFileDialog.getOpenFileName(
self, self.tr("Select Post Execution Script File"),
self._parent._item.path, '(*.*)')
if fileName != '':
fileName = file_manager.convert_to_relative(
self._parent._item.path, fileName)
self.txtPostExec.setText(fileName)
class MigrationWidget(QDialog):
def __init__(self, parent=None):
super(MigrationWidget, self).__init__(parent, Qt.WindowStaysOnTopHint)
self._migration = {}
vbox = QVBoxLayout(self)
lbl_title = QLabel(self.tr("Current code:"))
self.current_list = QListWidget()
lbl_suggestion = QLabel(self.tr("Suggested changes:"))
self.suggestion = QPlainTextEdit()
self.suggestion.setReadOnly(True)
self.btn_apply = QPushButton(self.tr("Apply change!"))
hbox = QHBoxLayout()
hbox.addSpacerItem(QSpacerItem(1, 0, QSizePolicy.Expanding))
hbox.addWidget(self.btn_apply)
vbox.addWidget(lbl_title)
vbox.addWidget(self.current_list)
vbox.addWidget(lbl_suggestion)
vbox.addWidget(self.suggestion)
vbox.addLayout(hbox)
self.connect(self.current_list,
SIGNAL("itemClicked(QListWidgetItem*)"),
self.load_suggestion)
self.connect(self.btn_apply, SIGNAL("clicked()"), self.apply_changes)
IDE.register_service('tab_migration', self)
ExplorerContainer.register_tab(translations.TR_TAB_MIGRATION, self)
def install_tab(self):
ide = IDE.get_service('ide')
self.connect(ide, SIGNAL("goingDown()"), self.close)
def apply_changes(self):
lineno = int(self.current_list.currentItem().data(Qt.UserRole))
lines = self._migration[lineno][0].split('\n')
remove = -1
code = ''
for line in lines:
if line.startswith('-'):
remove += 1
elif line.startswith('+'):
code += '%s\n' % line[1:]
main_container = IDE.get_service('main_container')
if main_container:
editorWidget = main_container.get_current_editor()
block_start = editorWidget.document().findBlockByLineNumber(lineno)
block_end = editorWidget.document().findBlockByLineNumber(lineno +
remove)
cursor = editorWidget.textCursor()
cursor.setPosition(block_start.position())
cursor.setPosition(block_end.position(), QTextCursor.KeepAnchor)
cursor.movePosition(QTextCursor.EndOfLine, QTextCursor.KeepAnchor)
cursor.insertText(code[:-1])
def load_suggestion(self, item):
lineno = int(item.data(Qt.UserRole))
lines = self._migration[lineno][0].split('\n')
code = ''
for line in lines:
if line.startswith('+'):
code += '%s\n' % line[1:]
self.suggestion.setPlainText(code)
main_container = IDE.get_service('main_container')
if main_container:
editorWidget = main_container.get_current_editor()
if editorWidget:
editorWidget.jump_to_line(lineno)
editorWidget.setFocus()
def refresh_lists(self, migration):
self._migration = migration
self.current_list.clear()
base_lineno = -1
for lineno in sorted(migration.keys()):
linenostr = 'L%s\n' % str(lineno + 1)
data = migration[lineno]
lines = data[0].split('\n')
if base_lineno == data[1]:
continue
base_lineno = data[1]
message = ''
for line in lines:
if line.startswith('-'):
message += '%s\n' % line
item = QListWidgetItem(linenostr + message)
item.setToolTip(linenostr + message)
item.setData(Qt.UserRole, lineno)
self.current_list.addItem(item)
def clear(self):
"""
Clear the widget
"""
self.current_list.clear()
self.suggestion.clear()
def reject(self):
if self.parent() is None:
self.emit(SIGNAL("dockWidget(PyQt_PyObject)"), self)
def closeEvent(self, event):
self.emit(SIGNAL("dockWidget(PyQt_PyObject)"), self)
event.ignore()
class Preferences(QDialog):
def __init__(self, parent=None, test = False):
super(Preferences, self).__init__(parent)
self.parent = parent
self.test = test
self.default_videocodecs = [
'flv', 'h263', 'libvpx', 'libx264', 'libxvid', 'mpeg2video',
'mpeg4', 'msmpeg4', 'wmv2'
]
self.default_audiocodecs = [
'aac', 'ac3', 'copy', 'libfaac', 'libmp3lame', 'libvo_aacenc',
'libvorbis', 'mp2', 'wmav2'
]
saveQL = QLabel('<html><b>' + self.tr('Save files') + '</b></html>')
existQL = QLabel(self.tr('Existing files:'))
self.exst_prefixQRB = QRadioButton(self.tr("Add '~' prefix"))
self.exst_overwriteQRB = QRadioButton(self.tr('Overwrite'))
exist_layout = utils.add_to_layout(
'h', self.exst_prefixQRB, self.exst_overwriteQRB)
defaultQL = QLabel(self.tr('Default output destination:'))
self.defaultQLE = QLineEdit()
self.defaultQTB = QToolButton()
self.defaultQTB.setText('...')
deafult_fol_layout = utils.add_to_layout(
'h', self.defaultQLE, self.defaultQTB)
nameQL = QLabel('<html><b>' + self.tr('Name files') +'</b></html>')
prefixQL = QLabel(self.tr('Prefix:'))
suffixQL = QLabel(self.tr('Suffix:'))
self.prefixQLE = QLineEdit()
self.suffixQLE = QLineEdit()
grid = utils.add_to_grid(
[prefixQL, self.prefixQLE], [suffixQL, self.suffixQLE])
prefix_layout = utils.add_to_layout('h', grid, None)
tabwidget1_layout = utils.add_to_layout(
'v', saveQL,
QSpacerItem(14, 13), existQL, exist_layout,
QSpacerItem(14, 13), defaultQL, deafult_fol_layout,
QSpacerItem(13, 13), nameQL, QSpacerItem(14, 13),
prefix_layout, None
)
ffmpegQL = QLabel('<html><b>' + self.tr('FFmpeg') +'</b></html>')
default_cmdQL = QLabel(self.tr('Default command:'))
self.cmdQLE = QLineEdit()
useQL = QLabel(self.tr('Use:'))
self.ffmpegQRB = QRadioButton(self.tr('FFmpeg'))
self.avconvQRB = QRadioButton(self.tr('avconv'))
hlayout = utils.add_to_layout('h', self.ffmpegQRB, self.avconvQRB)
vidcodecsQL = QLabel(
'<html><b>' + self.tr('Video codecs') +'</b></html>')
self.vidcodecsQPTE = QPlainTextEdit()
audcodecsQL = QLabel(
'<html><b>' + self.tr('Audio codecs') +'</b></html>')
self.audcodecsQPTE = QPlainTextEdit()
extraformatsQL = QLabel(
'<html><b>' + self.tr('Extra formats') +'</b></html>')
self.extraformatsQPTE = QPlainTextEdit()
gridlayout = utils.add_to_grid(
[vidcodecsQL, audcodecsQL, extraformatsQL],
[self.vidcodecsQPTE, self.audcodecsQPTE, self.extraformatsQPTE])
defvidcodecsQPB = QPushButton(self.tr("Default video codecs"))
defaudcodecsQPB = QPushButton(self.tr("Default audio codecs"))
hlayout2 = utils.add_to_layout(
'h', None, defvidcodecsQPB, defaudcodecsQPB)
tabwidget2_layout = utils.add_to_layout(
'v', ffmpegQL, QSpacerItem(14, 13), useQL,
hlayout, QSpacerItem(14, 13), default_cmdQL,
self.cmdQLE, QSpacerItem(20, 20), gridlayout, hlayout2,
None
)
widget1 = QWidget()
widget1.setLayout(tabwidget1_layout)
widget2 = QWidget()
widget2.setLayout(tabwidget2_layout)
tabWidget = QTabWidget()
tabWidget.addTab(widget1, self.tr('General'))
tabWidget.addTab(widget2, self.tr('Audio/Video'))
buttonBox = QDialogButtonBox(
QDialogButtonBox.Ok|QDialogButtonBox.Cancel)
final_layout = utils.add_to_layout('v', tabWidget, None, buttonBox)
self.setLayout(final_layout)
self.defaultQTB.clicked.connect(self.open_dir)
buttonBox.accepted.connect(self.save_settings)
buttonBox.rejected.connect(self.reject)
defvidcodecsQPB.clicked.connect(self.set_default_videocodecs)
defaudcodecsQPB.clicked.connect(self.set_default_audiocodecs)
self.resize(400, 480)
self.setWindowTitle(self.tr('Preferences'))
QTimer.singleShot(0, self.load_settings)
def load_settings(self):
"""Load settings and update graphical widgets with loaded values."""
settings = QSettings()
overwrite_existing = utils.str_to_bool(
settings.value('overwrite_existing'))
default_output = settings.value('default_output')
prefix = settings.value('prefix')
suffix = settings.value('suffix')
avconv_prefered = utils.str_to_bool(settings.value('avconv_prefered'))
default_command = settings.value('default_command')
videocodecs = settings.value('videocodecs')
audiocodecs = settings.value('audiocodecs')
extraformats = settings.value('extraformats')
# QSettings.value() returns str() in python3, not QVariant() as in p2
if overwrite_existing:
self.exst_overwriteQRB.setChecked(True)
else:
self.exst_prefixQRB.setChecked(True)
if default_output:
self.defaultQLE.setText(default_output)
if prefix:
self.prefixQLE.setText(prefix)
if suffix:
self.suffixQLE.setText(suffix)
if avconv_prefered:
self.avconvQRB.setChecked(True)
else:
self.ffmpegQRB.setChecked(True)
if default_command:
self.cmdQLE.setText(default_command)
else:
self.cmdQLE.setText(config.default_ffmpeg_cmd)
if not self.test and not self.parent.ffmpeg:
self.avconvQRB.setChecked(True)
self.ffmpegQRB.setEnabled(False)
if not self.test and not self.parent.avconv:
self.ffmpegQRB.setChecked(True)
self.avconvQRB.setEnabled(False)
if not videocodecs:
self.set_default_videocodecs()
else:
self.vidcodecsQPTE.setPlainText(videocodecs)
if not audiocodecs:
self.set_default_audiocodecs
else:
self.audcodecsQPTE.setPlainText(audiocodecs)
self.extraformatsQPTE.setPlainText(extraformats)
def set_default_videocodecs(self):
self.vidcodecsQPTE.setPlainText("\n".join(self.default_videocodecs))
def set_default_audiocodecs(self):
self.audcodecsQPTE.setPlainText("\n".join(self.default_audiocodecs))
def open_dir(self):
"""Get a directory name using a standard Qt dialog and update
self.defaultQLE with dir's name."""
if self.defaultQLE.isEnabled():
_dir = QFileDialog.getExistingDirectory(
self, 'FF Multi Converter - ' +
self.tr('Choose default output destination'), config.home
)
if _dir:
self.defaultQLE.setText(_dir)
def save_settings(self):
"""Set settings values, extracting the appropriate information from
the graphical widgets."""
# remove empty codecs
videocodecs = []
audiocodecs = []
extraformats = []
for i in self.vidcodecsQPTE.toPlainText().split("\n"):
i = i.strip()
if len(i.split()) == 1: # single word
videocodecs.append(i)
for i in self.audcodecsQPTE.toPlainText().split("\n"):
i = i.strip()
if len(i.split()) == 1:
audiocodecs.append(i)
for i in self.extraformatsQPTE.toPlainText().split("\n"):
i = i.strip()
if len(i.split()) == 1:
extraformats.append(i)
videocodecs = "\n".join(sorted(videocodecs))
audiocodecs = "\n".join(sorted(audiocodecs))
extraformats = "\n".join(sorted(extraformats))
settings = QSettings()
settings.setValue(
'overwrite_existing', self.exst_overwriteQRB.isChecked())
settings.setValue(
'default_output', self.defaultQLE.text())
settings.setValue(
'prefix', self.prefixQLE.text())
settings.setValue(
'suffix', self.suffixQLE.text())
settings.setValue(
'avconv_prefered', self.avconvQRB.isChecked())
settings.setValue(
'default_command', self.cmdQLE.text())
settings.setValue(
'videocodecs', videocodecs)
settings.setValue(
'audiocodecs', audiocodecs)
settings.setValue(
'extraformats', extraformats)
self.accept()
class MigrationWidget(QDialog):
def __init__(self, parent=None):
super(MigrationWidget, self).__init__(parent, Qt.WindowStaysOnTopHint)
self._migration = {}
vbox = QVBoxLayout(self)
lbl_title = QLabel(self.tr("Current code:"))
self.current_list = QListWidget()
lbl_suggestion = QLabel(self.tr("Suggested changes:"))
self.suggestion = QPlainTextEdit()
self.suggestion.setReadOnly(True)
self.btn_apply = QPushButton(self.tr("Apply change!"))
hbox = QHBoxLayout()
hbox.addSpacerItem(QSpacerItem(1, 0, QSizePolicy.Expanding))
hbox.addWidget(self.btn_apply)
vbox.addWidget(lbl_title)
vbox.addWidget(self.current_list)
vbox.addWidget(lbl_suggestion)
vbox.addWidget(self.suggestion)
vbox.addLayout(hbox)
self.connect(self.current_list,
SIGNAL("itemClicked(QListWidgetItem*)"), self.load_suggestion)
self.connect(self.btn_apply, SIGNAL("clicked()"), self.apply_changes)
IDE.register_service('tab_migration', self)
ExplorerContainer.register_tab(translations.TR_TAB_MIGRATION, self)
def install_tab(self):
ide = IDE.get_service('ide')
self.connect(ide, SIGNAL("goingDown()"), self.close)
def apply_changes(self):
lineno = int(self.current_list.currentItem().data(Qt.UserRole))
lines = self._migration[lineno][0].split('\n')
remove = -1
code = ''
for line in lines:
if line.startswith('-'):
remove += 1
elif line.startswith('+'):
code += '%s\n' % line[1:]
main_container = IDE.get_service('main_container')
if main_container:
editorWidget = main_container.get_current_editor()
block_start = editorWidget.document().findBlockByLineNumber(lineno)
block_end = editorWidget.document().findBlockByLineNumber(
lineno + remove)
cursor = editorWidget.textCursor()
cursor.setPosition(block_start.position())
cursor.setPosition(block_end.position(), QTextCursor.KeepAnchor)
cursor.movePosition(QTextCursor.EndOfLine, QTextCursor.KeepAnchor)
cursor.insertText(code[:-1])
def load_suggestion(self, item):
lineno = int(item.data(Qt.UserRole))
lines = self._migration[lineno][0].split('\n')
code = ''
for line in lines:
if line.startswith('+'):
code += '%s\n' % line[1:]
self.suggestion.setPlainText(code)
main_container = IDE.get_service('main_container')
if main_container:
editorWidget = main_container.get_current_editor()
if editorWidget:
editorWidget.jump_to_line(lineno)
editorWidget.setFocus()
def refresh_lists(self, migration):
self._migration = migration
self.current_list.clear()
base_lineno = -1
for lineno in sorted(migration.keys()):
linenostr = 'L%s\n' % str(lineno + 1)
data = migration[lineno]
lines = data[0].split('\n')
if base_lineno == data[1]:
continue
base_lineno = data[1]
message = ''
for line in lines:
if line.startswith('-'):
message += '%s\n' % line
item = QListWidgetItem(linenostr + message)
item.setToolTip(linenostr + message)
item.setData(Qt.UserRole, lineno)
self.current_list.addItem(item)
def clear(self):
"""
Clear the widget
"""
self.current_list.clear()
self.suggestion.clear()
def reject(self):
if self.parent() is None:
self.emit(SIGNAL("dockWidget(PyQt_PyObject)"), self)
def closeEvent(self, event):
self.emit(SIGNAL("dockWidget(PyQt_PyObject)"), self)
event.ignore()
def make_text_edit(txt='', length=None, min_height=None):
text_edit = QPlainTextEdit()
text_edit.setPlainText(txt)
do(text_edit.setMaximumWidth, length)
do(text_edit.setMinimumHeight, min_height)
return text_edit
class ProjectProperties(QDialog):
def __init__(self, item, parent=None):
QDialog.__init__(self, parent, Qt.Dialog)
self.setModal(True)
self._item = item
self.setWindowTitle(self.tr("Project Properties"))
grid = QGridLayout(self)
grid.addWidget(QLabel(self.tr("Name:")), 0, 0)
self.name = QLineEdit()
if self._item.name == '':
self.name.setText(file_manager.get_basename(self._item.path))
else:
self.name.setText(self._item.name)
grid.addWidget(self.name, 0, 1)
grid.addWidget(QLabel(self.tr("Project Type:")), 1, 0)
self.txtType = QLineEdit()
completer = QCompleter(sorted(settings.PROJECT_TYPES))
completer.setCompletionMode(QCompleter.UnfilteredPopupCompletion)
self.txtType.setCompleter(completer)
self.txtType.setText(self._item.projectType)
grid.addWidget(self.txtType, 1, 1)
grid.addWidget(QLabel(self.tr("Description:")), 2, 0)
self.description = QPlainTextEdit()
self.description.setPlainText(self._item.description)
grid.addWidget(self.description, 2, 1)
grid.addWidget(QLabel(self.tr("URL:")), 3, 0)
self.url = QLineEdit()
self.url.setText(self._item.url)
grid.addWidget(self.url, 3, 1)
grid.addWidget(QLabel(self.tr("Licence:")), 4, 0)
self.cboLicense = QComboBox()
self.cboLicense.addItem('Apache License 2.0')
self.cboLicense.addItem('Artistic License/GPL')
self.cboLicense.addItem('Eclipse Public License 1.0')
self.cboLicense.addItem('GNU General Public License v2')
self.cboLicense.addItem('GNU General Public License v3')
self.cboLicense.addItem('GNU Lesser General Public License')
self.cboLicense.addItem('MIT License')
self.cboLicense.addItem('Mozilla Public License 1.1')
self.cboLicense.addItem('New BSD License')
self.cboLicense.addItem('Other Open Source')
self.cboLicense.addItem('Other')
self.cboLicense.setCurrentIndex(4)
index = self.cboLicense.findText(self._item.license)
self.cboLicense.setCurrentIndex(index)
grid.addWidget(self.cboLicense, 4, 1)
grid.addWidget(QLabel(self.tr("Main File:")), 5, 0)
self.path = QLineEdit()
ui_tools.LineEditButton(
self.path, self.path.clear,
self.style().standardPixmap(self.style().SP_TrashIcon))
self.path.setText(self._item.mainFile)
self.path.setReadOnly(True)
self.btnBrowse = QPushButton(
QIcon(self.style().standardPixmap(self.style().SP_FileIcon)), '')
hbox = QHBoxLayout()
hbox.addWidget(self.path)
hbox.addWidget(self.btnBrowse)
grid.addLayout(hbox, 5, 1)
self.txtExtensions = QLineEdit()
self.txtExtensions.setText(str(', '.join(self._item.extensions)))
grid.addWidget(QLabel(self.tr("Supported Extensions:")), 6, 0)
grid.addWidget(self.txtExtensions, 6, 1)
self.txtPythonPath = QLineEdit()
self.txtPythonPath.setText(self._item.pythonPath)
self.btnPythonPath = QPushButton(QIcon(resources.IMAGES['open']), '')
grid.addWidget(QLabel(self.tr("Python Path:")), 7, 0)
grid.addWidget(self.txtPythonPath, 7, 1)
grid.addWidget(self.btnPythonPath, 7, 2)
self.txtParams = QLineEdit()
self.txtParams.setToolTip(
self.tr("Separate the params with commas (ie: help, verbose)"))
self.txtParams.setText(self._item.programParams)
grid.addWidget(QLabel(self.tr("Params (comma separated):")), 8, 0)
grid.addWidget(self.txtParams, 8, 1)
#Widgets for virtualenv properties
self.txtVenvPath = QLineEdit()
ui_tools.LineEditButton(
self.txtVenvPath, self.txtVenvPath.clear,
self.style().standardPixmap(self.style().SP_TrashIcon))
self.txtVenvPath.setText(self._item.venv)
self.txtVenvPath.setReadOnly(True)
self.btnVenvPath = QPushButton(QIcon(resources.IMAGES['open']), '')
grid.addWidget(QLabel(self.tr("Virtualenv Folder:")), 9, 0)
grid.addWidget(self.txtVenvPath, 9, 1)
grid.addWidget(self.btnVenvPath, 9, 2)
self.btnSave = QPushButton(self.tr("Save"))
self.btnCancel = QPushButton(self.tr("Cancel"))
hbox3 = QHBoxLayout()
hbox3.addWidget(self.btnCancel)
hbox3.addWidget(self.btnSave)
grid.addLayout(hbox3, 10, 1)
self.connect(self.btnBrowse, SIGNAL("clicked()"), self.select_file)
self.connect(self.btnCancel, SIGNAL("clicked()"), self.close)
self.connect(self.btnSave, SIGNAL("clicked()"), self.save_properties)
self.connect(self.btnPythonPath, SIGNAL("clicked()"),
self._load_python_path)
self.connect(self.btnVenvPath, SIGNAL("clicked()"),
self._load_python_venv)
def _load_python_path(self):
path = unicode(
QFileDialog.getOpenFileName(self, self.tr("Select Python Path")))
self.txtPythonPath.setText(path)
def _load_python_venv(self):
venv = unicode(
QFileDialog.getExistingDirectory(
self, self.tr("Select Virtualenv Folder")))
if sys.platform == 'win32':
venv = os.path.join(venv, 'Scripts', 'python')
else:
venv = os.path.join(venv, 'bin', 'python')
#check if venv folder exists
if not os.path.exists(venv):
QMessageBox.information(
self, self.tr("Virtualenv Folder"),
self.tr("This is not a valid Virtualenv Folder"))
self.txtVenvPath.setText("")
else:
self.txtVenvPath.setText(venv)
def select_file(self):
fileName = unicode(
QFileDialog.getOpenFileName(self, self.tr("Select Main File"),
self._item.path, '(*.py);;(*.*)'))
if fileName != '':
fileName = file_manager.convert_to_relative(
self._item.path, fileName)
self.path.setText(fileName)
def save_properties(self):
if str(self.name.text()).strip() == '':
QMessageBox.critical(self, self.tr("Properties Invalid"),
self.tr("The Project must have a name."))
return
tempName = self._item.name
self._item.name = unicode(self.name.text())
self._item.description = unicode(self.description.toPlainText())
self._item.license = unicode(self.cboLicense.currentText())
self._item.mainFile = unicode(self.path.text())
self._item.url = unicode(self.url.text())
self._item.projectType = unicode(self.txtType.text())
self._item.pythonPath = unicode(self.txtPythonPath.text())
self._item.programParams = unicode(self.txtParams.text())
self._item.venv = unicode(self.txtVenvPath.text())
extensions = unicode(self.txtExtensions.text()).split(', ')
self._item.extensions = tuple(extensions)
#save project properties
project = {}
project['name'] = self._item.name
project['description'] = self._item.description
project['url'] = self._item.url
project['license'] = self._item.license
project['mainFile'] = self._item.mainFile
project['project-type'] = self._item.projectType
project['supported-extensions'] = self._item.extensions
project['pythonPath'] = self._item.pythonPath
project['venv'] = self._item.venv
project['programParams'] = self._item.programParams
if tempName != self._item.name and \
file_manager.file_exists(self._item.path, tempName + '.nja'):
file_manager.delete_file(self._item.path, tempName + '.nja')
json_manager.create_ninja_project(self._item.path, self._item.name,
project)
self._item.setText(0, self._item.name)
self._item.setToolTip(0, self._item.name)
if self._item.extensions != settings.SUPPORTED_EXTENSIONS:
self._item._parent._refresh_project(self._item)
self.close()
class WidgetEditList(OWTextableBaseWidget):
"""Textable widget for modifing the lexical content of the list
"""
#----------------------------------------------------------------------
# Widget's metadata...
name = "Edit Lexical List"
description = "Edit words contained in lists (lexical fields)"
icon = "icons/lexical_hunter.svg"
#----------------------------------------------------------------------
# Channel definitions...
inputs = [("Word segmentation", Segmentation, "inputData")]
outputs = [("Segmentation with annotations", Segmentation)]
#----------------------------------------------------------------------
# Layout parameters...
want_main_area = True
#----------------------------------------------------------------------
# Settings...
settingsHandler = VersionedSettingsHandler(
version=__version__.rsplit(".", 1)[0])
textFieldContent = settings.Setting(u''.encode('utf-8'))
encoding = settings.Setting(u'utf-8')
selectedFields = []
listTitle = ""
listWord = ""
titleList = settings.Setting([])
baseLocation = settings.Setting('.')
def __init__(self, caller):
"""Widget creator."""
super().__init__()
# Variable to communicate with the base widjet by calling
# self.creator.vriable_name
self.caller = caller
# Other attributes...
self.inputSeg = None
self.outputSeg = None
# Next two instructions are helpers from TextableUtils. Corresponding
# interface elements are declared here and actually drawn below (at
# their position in the UI)...
self.infoBox = InfoBox(widget=self.controlArea)
# Temporary dictionary so that the user can cancel changes
self.tempDict = defaultDict.copy()
# User interface...
# CONTROL AREA #
# Options box for the structure
titleListBox = gui.widgetBox(
widget=self.controlArea,
box="Lists",
orientation="horizontal",
)
# SAVE AREA
# (After the control one but need to be first for the savechange button)
SaveBox = gui.widgetBox(
widget=self.controlArea,
box=None,
orientation="horizontal",
)
self.SaveChanges = gui.button(
widget=SaveBox,
master=self,
label="Save changes",
callback=self.saveChanges,
width=130,
)
self.CancelChanges = gui.button(
widget=SaveBox,
master=self,
label="Cancel",
callback=self.closeWindow,
width=130,
)
# END OF SAVE AREA
# List of Lexical list that the user can select
self.titleLabelsList = gui.listBox(
widget=titleListBox,
master=self,
value="selectedFields", # setting (list)
labels="titleList", # setting (list)
tooltip=
"The list of lexical list that you want to use for annotation",
callback=self.updateGUI,
)
self.titleLabelsList.setMinimumHeight(300)
self.titleLabelsList.setMinimumWidth(150)
self.titleLabelsList.setSelectionMode(1)
# a box for vertical align of the button
controlBox = gui.widgetBox(
widget=titleListBox,
box=None,
orientation="vertical",
)
# Actions on list
self.EditList = gui.button(
widget=controlBox,
master=self,
label="Edit",
callback=self.setEditContent,
width=130,
autoDefault=False,
)
self.ImportList = gui.button(
widget=controlBox,
master=self,
label="Import",
callback=self.importLexic,
width=130,
autoDefault=False,
)
self.ExportList = gui.button(
widget=controlBox,
master=self,
label="Export All",
callback=self.exportAllLexics,
width=130,
)
self.ExportSelectedList = gui.button(
widget=controlBox,
master=self,
label="Export Selected",
callback=self.exportOneLexic,
width=130,
)
self.NewList = gui.button(
widget=controlBox,
master=self,
label="New",
callback=self.newLexicalField,
width=130,
)
self.ClearList = gui.button(
widget=controlBox,
master=self,
label="Clear all",
callback=self.clearList,
width=130,
)
self.RemoveSelectedList = gui.button(
widget=controlBox,
master=self,
label="Remove Selected",
callback=self.deleteSelectedList,
width=130,
)
# MAIN AREA (edit list) #
# structure ...
listEditBox = gui.widgetBox(
widget=self.mainArea,
box="Edit",
orientation="vertical",
)
listEditBox.setMinimumWidth(300)
# Edit the titile of the list
self.titleEdit = gui.lineEdit(
widget=listEditBox,
master=self,
value="listTitle",
label="List name",
orientation="vertical",
)
# Editable text Field. Each line gonna be a enter of
# the lexical list selected
self.ContentLabel = gui.label(
widget=listEditBox,
master=self,
label="List content",
)
self.editor = QPlainTextEdit()
listEditBox.layout().addWidget(self.editor)
self.editor.setMinimumHeight(300)
buttonEditBox = gui.widgetBox(widget=listEditBox,
box=None,
orientation="horizontal")
# For saving the chang on the list edit
self.CommitList = gui.button(
widget=buttonEditBox,
master=self,
label="Commit",
callback=self.saveEdit,
width=100,
)
self.CancelList = gui.button(widget=buttonEditBox,
master=self,
label="Cancel list changes",
callback=self.cancelListChanges,
width=100)
gui.rubber(self.controlArea)
self.setTitleList()
self.updateGUI()
# Now Info box and Send button must be drawn...
self.infoBox.draw()
# Set the window as modal
self.exec()
def setEditContent(self):
"""Sets the lexical field informations when the user wants to edit it"""
# Getting selected list title
self.listTitle = list(self.titleList)[self.selectedFields[0]]
# Converting words list to string
self.editContent = '\n'.join(self.tempDict[self.listTitle])
# Setting editor content with words list (converted to string)
self.editor.setPlainText(self.editContent)
# Getting old title (to delete it later if the users wants to)
self.oldTitle = self.listTitle
self.updateGUI()
def setTitleList(self):
"""Displays the lexical fields titles in the edit widget view"""
self.titleList = sorted(self.tempDict.keys())
def clearList(self):
"""Clears the list of lexical fields"""
confBox = QMessageBox(
QMessageBox.Question, "Textable",
"Do you really want to delete all the lexical lists?",
QMessageBox.Yes | QMessageBox.No)
# Getting the answer of the user
result = confBox.exec_()
if result == QMessageBox.Yes:
# Reset textfields values
self.titleEdit.setText("")
self.editor.setPlainText("")
# Deleting all lexical fields
self.tempDict.clear()
self.setTitleList()
else:
pass
def deleteSelectedList(self):
"""Deletes selected lexical field"""
confBox = QMessageBox(QMessageBox.Question, "Textable",
"Do you really want to delete this list?",
QMessageBox.Yes | QMessageBox.No)
# Getting the answer of the user
result = confBox.exec_()
if result == QMessageBox.Yes:
# Getting selected list title
self.listToDelete = list(self.titleList)[self.selectedFields[0]]
# Reset textfields values
self.titleEdit.setText("")
self.editor.setPlainText("")
# Deleting selected list
self.tempDict.pop(self.listToDelete, None)
self.titleList = sorted(self.tempDict.keys())
else:
pass
def newLexicalField(self):
"""Sets a new entry in the lexical fields dictionnary"""
newDict = "New lexical field"
i = 1
while newDict in self.tempDict.keys():
newDict = "New lexical field %i" % i
i += 1
self.tempDict[newDict] = ""
self.setTitleList()
def saveEdit(self):
"""Saves the modifications made by the user on the list"""
# Getting textfields values
self.val = self.editor.toPlainText()
self.newTitle = self.titleEdit.text()
# Reset textfields values
self.titleEdit.setText("")
self.editor.setPlainText("")
wordList = self.val.split("\n")
self.tempDict[self.newTitle] = wordList
# Deleting old key and value
if self.newTitle != self.oldTitle:
del self.tempDict[self.oldTitle]
self.titleList = sorted(self.tempDict.keys())
self.updateGUI()
def cancelListChanges(self):
# Reset textfields values
self.titleEdit.setText("")
self.editor.setPlainText("")
self.updateGUI()
def saveChanges(self):
"""Saves changes made by the user"""
defaultDict.clear()
defaultDict.update(self.tempDict)
self.hide()
self.caller.setTitleList()
def closeWindow(self):
"""Cancels changes made by the user"""
self.hide()
def importLexic(self):
"""Lets the user import a lexical field from a text file"""
# Opening a file browser
filePath = QFileDialog.getOpenFileName(self,
u'Import lexical field file',
self.baseLocation,
u'Text files (*)')
if not filePath:
return
self.file = os.path.normpath(filePath)
self.baseLocation = os.path.dirname(filePath)
# Gets txt file name and substracts .txt extension
fileName = os.path.join(self.baseLocation, self.file)
# Cutting the path to get the name
if platform.system() == "Windows":
listLexicName = fileName.split('\\')
else:
listLexicName = fileName.split('/')
# Getting file name
lexicName = listLexicName[-1]
lexicName = re.sub('\.txt$', '', lexicName)
# Trying to open the files and store their content in a dictionnary
# then store all of theses in a list
try:
fileHandle = open(fileName, encoding='utf-8')
content = fileHandle.readlines()
# Deleting spaces
self.tempDict[lexicName] = [re.sub(r'\s', "", i) for i in content]
fileHandle.close()
self.setTitleList()
except IOError:
QMessageBox.warning(None, 'Textable', "Couldn't open file.",
QMessageBox.Ok)
return
def exportOneLexic(self):
"""Lets the user export the selected list to a text file"""
# Opening file browser
filePath = QFileDialog.getSaveFileName(
self,
u'Export Selected Lexical List',
self.baseLocation,
)
# Setting content to save
exportTitle = list(self.titleList)[self.selectedFields[0]]
exportContent = self.tempDict[exportTitle]
# Saving lexic content
if filePath:
outputFile = open(
filePath,
encoding='utf8',
mode='w+',
errors='xmlcharrefreplace',
)
outputFile.write('\n'.join(exportContent))
outputFile.close()
QMessageBox.information(None, 'Textable',
'Lexical file correctly exported',
QMessageBox.Ok)
def exportAllLexics(self):
"""Lets the user export all the lexics"""
# Opening file browser
filePath = QFileDialog.getExistingDirectory(self,
u'Export Selected List',
self.baseLocation)
if filePath:
for name in self.tempDict:
exportName = name.replace(" ", "_")
if platform.system() == "Windows":
fullName = r"{}\{}.txt".format(filePath, exportName)
else:
fullName = r"{}/{}.txt".format(filePath, exportName)
outputFile = open(
fullName,
encoding='utf8',
mode='w+',
errors='xmlcharrefreplace',
)
outputFile.write('\n'.join(self.tempDict[name]))
outputFile.close()
QMessageBox.information(None, 'Textable',
'Lexical files correctly exported',
QMessageBox.Ok)
def inputData(self, newInput):
"""Process incoming data."""
pass
def updateGUI(self):
if self.titleEdit.text() != "":
# Disabled elements
self.SaveChanges.setDisabled(True)
self.CancelChanges.setDisabled(True)
self.EditList.setDisabled(True)
self.ImportList.setDisabled(True)
self.ExportList.setDisabled(True)
self.ExportSelectedList.setDisabled(True)
self.NewList.setDisabled(True)
self.ClearList.setDisabled(True)
self.RemoveSelectedList.setDisabled(True)
# Enabled elements
self.CommitList.setDisabled(False)
self.CancelList.setDisabled(False)
self.editor.setDisabled(False)
self.titleEdit.setDisabled(False)
if self.titleEdit.text() == "":
# Enabled elements
self.SaveChanges.setDisabled(False)
self.CancelChanges.setDisabled(False)
self.EditList.setDisabled(False)
self.ImportList.setDisabled(False)
self.ExportList.setDisabled(False)
self.ExportSelectedList.setDisabled(False)
self.NewList.setDisabled(False)
self.ClearList.setDisabled(False)
self.RemoveSelectedList.setDisabled(False)
# Disabled elements
self.CommitList.setDisabled(True)
self.CancelList.setDisabled(True)
self.editor.setDisabled(True)
self.titleEdit.setDisabled(True)
if not self.selectedFields:
# Disabled elements if a list isn't selected
self.RemoveSelectedList.setDisabled(True)
self.ExportSelectedList.setDisabled(True)
self.EditList.setDisabled(True)
# The following method needs to be copied verbatim in
# every Textable widget that sends a segmentation...
def setCaption(self, title):
if 'captionTitle' in dir(self):
changed = title != self.captionTitle
super().setCaption(title)
if changed:
self.sendButton.settingsChanged()
else:
super().setCaption(title)
class SkinsTab(QWidget):
def __init__(self):
QWidget.__init__(self)
vbox = QVBoxLayout(self)
#Top Bar
hbox = QHBoxLayout()
self.radioDefault = QRadioButton("Default Skin")
self.radioCustom = QRadioButton("Custom")
self.comboSkins = QComboBox()
self.skins = loader.load_gui_skins()
for item in self.skins:
self.comboSkins.addItem(item)
hbox.addWidget(self.radioDefault)
hbox.addWidget(self.radioCustom)
hbox.addWidget(self.comboSkins)
#Text Area
self.txtStyle = QPlainTextEdit()
self.txtStyle.setReadOnly(True)
#Settings
settings = QSettings()
settings.beginGroup('preferences')
settings.beginGroup('skins')
if settings.value('default', True).toBool():
self.radioDefault.setChecked(True)
self.comboSkins.setEnabled(False)
else:
self.radioCustom.setChecked(True)
index = self.comboSkins.findText(
settings.value('selectedSkin', '').toString())
self.comboSkins.setCurrentIndex(index)
content = self.skins[str(self.comboSkins.currentText())]
self.txtStyle.setPlainText(content)
settings.endGroup()
settings.endGroup()
vbox.addLayout(hbox)
vbox.addWidget(self.txtStyle)
vbox.addWidget(QLabel('Requires restart the IDE'))
#Signals
self.connect(self.radioDefault, SIGNAL("clicked()"),
self._default_clicked)
self.connect(self.radioCustom, SIGNAL("clicked()"),
self._custom_clicked)
def _default_clicked(self):
self.comboSkins.setEnabled(False)
self.txtStyle.setPlainText('')
def _custom_clicked(self):
self.comboSkins.setEnabled(True)
content = self.skins[str(self.comboSkins.currentText())]
self.txtStyle.setPlainText(content)
def save(self):
settings = QSettings()
settings.beginGroup('preferences')
settings.beginGroup('skins')
settings.setValue('default', self.radioDefault.isChecked())
settings.setValue('selectedSkin', self.comboSkins.currentText())
settings.endGroup()
settings.endGroup()
class ProjectExecution(QWidget):
"""Project Execution widget class"""
def __init__(self, parent):
super(ProjectExecution, self).__init__()
self._parent = parent
grid = QGridLayout(self)
grid.addWidget(QLabel(translations.TR_PROJECT_MAIN_FILE), 0, 0)
self.path = QLineEdit()
self.path.setPlaceholderText(
os.path.join(os.path.expanduser("~"), 'path', 'to', 'main.py'))
ui_tools.LineEditButton(
self.path, self.path.clear,
self.style().standardPixmap(self.style().SP_TrashIcon))
self.path.setText(self._parent.project.main_file)
self.path.setReadOnly(True)
self.btnBrowse = QPushButton(
QIcon(self.style().standardPixmap(self.style().SP_FileIcon)), '')
grid.addWidget(self.path, 0, 1)
grid.addWidget(self.btnBrowse, 0, 2)
# this should be changed, and ALL pythonPath names to
# python_custom_interpreter or something like that. this is NOT the
# PYTHONPATH
self.txtPythonInterpreter = QLineEdit()
self.txtPythonInterpreter.setText(self._parent.project.python_exec)
self.txtPythonInterpreter.setCompleter(
QCompleter(
('python', 'python2', 'python3', 'python.exe', 'pythonw.exe')))
self.txtPythonInterpreter.setPlaceholderText("python")
self.btnPythonPath = QPushButton(QIcon(":img/open"), '')
grid.addWidget(QLabel(translations.TR_PROJECT_PYTHON_INTERPRETER), 1,
0)
grid.addWidget(self.txtPythonInterpreter, 1, 1)
grid.addWidget(self.btnPythonPath, 1, 2)
grid.addWidget(QLabel(translations.TR_PROJECT_PYTHON_PATH), 2, 0)
self.txtPythonPath = QPlainTextEdit() # TODO : better widget
self.txtPythonPath.setPlainText(self._parent.project.python_path)
self.txtPythonPath.setToolTip(translations.TR_PROJECT_PATH_PER_LINE)
grid.addWidget(self.txtPythonPath, 2, 1)
# Additional builtins/globals for pyflakes
grid.addWidget(QLabel(translations.TR_PROJECT_BUILTINS), 3, 0)
self.additional_builtins = QLineEdit()
self.additional_builtins.setText(' '.join(
self._parent.project.additional_builtins))
self.additional_builtins.setToolTip(
translations.TR_PROJECT_BUILTINS_TOOLTIP)
grid.addWidget(self.additional_builtins, 3, 1)
self.txtPreExec = QLineEdit()
ui_tools.LineEditButton(
self.txtPreExec, self.txtPreExec.clear,
self.style().standardPixmap(self.style().SP_TrashIcon))
self.txtPreExec.setReadOnly(True)
self.txtPreExec.setText(self._parent.project.pre_exec_script)
self.txtPreExec.setPlaceholderText(
os.path.join(os.path.expanduser("~"), 'path', 'to', 'script.sh'))
self.btnPreExec = QPushButton(QIcon(":img/open"), '')
grid.addWidget(QLabel(translations.TR_PROJECT_PRE_EXEC), 4, 0)
grid.addWidget(self.txtPreExec, 4, 1)
grid.addWidget(self.btnPreExec, 4, 2)
self.txtPostExec = QLineEdit()
ui_tools.LineEditButton(
self.txtPostExec, self.txtPostExec.clear,
self.style().standardPixmap(self.style().SP_TrashIcon))
self.txtPostExec.setReadOnly(True)
self.txtPostExec.setText(self._parent.project.post_exec_script)
self.txtPostExec.setPlaceholderText(
os.path.join(os.path.expanduser("~"), 'path', 'to', 'script.sh'))
self.btnPostExec = QPushButton(QIcon(":img/open"), '')
grid.addWidget(QLabel(translations.TR_PROJECT_POST_EXEC), 5, 0)
grid.addWidget(self.txtPostExec, 5, 1)
grid.addWidget(self.btnPostExec, 5, 2)
grid.addItem(
QSpacerItem(5, 10, QSizePolicy.Expanding, QSizePolicy.Expanding),
6, 0)
# Properties
grid.addWidget(QLabel(translations.TR_PROJECT_PROPERTIES), 7, 0)
self.txtParams = QLineEdit()
self.txtParams.setToolTip(translations.TR_PROJECT_PARAMS_TOOLTIP)
self.txtParams.setText(self._parent.project.program_params)
self.txtParams.setPlaceholderText('verbose, debug, force')
grid.addWidget(QLabel(translations.TR_PROJECT_PARAMS), 8, 0)
grid.addWidget(self.txtParams, 8, 1)
#Widgets for virtualenv properties
self.txtVenvPath = QLineEdit()
ui_tools.LineEditButton(
self.txtVenvPath, self.txtVenvPath.clear,
self.style().standardPixmap(self.style().SP_TrashIcon))
self.txtVenvPath.setText(self._parent.project.venv)
self._dir_completer = QCompleter()
self._dir_completer.setModel(QDirModel(self._dir_completer))
self.txtVenvPath.setCompleter(self._dir_completer)
self.txtVenvPath.setPlaceholderText(
os.path.join(os.path.expanduser("~"), 'path', 'to', 'virtualenv'))
self.btnVenvPath = QPushButton(QIcon(":img/open"), '')
grid.addWidget(QLabel(translations.TR_PROJECT_VIRTUALENV), 9, 0)
grid.addWidget(self.txtVenvPath, 9, 1)
grid.addWidget(self.btnVenvPath, 9, 2)
self.connect(self.btnBrowse, SIGNAL("clicked()"), self.select_file)
self.connect(self.btnPythonPath, SIGNAL("clicked()"),
self._load_python_path)
self.connect(self.btnVenvPath, SIGNAL("clicked()"),
self._load_python_venv)
self.connect(self.btnPreExec, SIGNAL("clicked()"),
self.select_pre_exec_script)
self.connect(self.btnPostExec, SIGNAL("clicked()"),
self.select_post_exec_script)
def _load_python_path(self):
"""Ask the user a python path and set its value"""
path = QFileDialog.getOpenFileName(
self, translations.TR_PROJECT_SELECT_PYTHON_PATH)
self.txtPythonInterpreter.setText(path)
def _load_python_venv(self):
"""Ask the user a python venv and set its value"""
venv = QFileDialog.getExistingDirectory(
self, translations.TR_PROJECT_SELECT_VIRTUALENV)
if sys.platform == 'win32':
venv = os.path.join(venv, 'Scripts', 'python.exe')
else:
venv = os.path.join(venv, 'bin', 'python')
#check if venv folder exists
if not os.path.exists(venv):
QMessageBox.information(
self, translations.TR_PROJECT_SELECT_VIRTUALENV_MESSAGE_TITLE,
translations.TR_PROJECT_SELECT_VIRTUALENV_MESSAGE_BODY)
self.txtVenvPath.setText("")
else:
self.txtVenvPath.setText(venv)
def select_file(self):
"""Ask the user a python main file and set its value"""
fileName = QFileDialog.getOpenFileName(
self, translations.TR_PROJECT_SELECT_MAIN_FILE,
self._parent.project.path,
'Python PY(*.py);;Python Bytecode(*.py[codw]);;*(*.*)')
if fileName != '':
fileName = file_manager.convert_to_relative(
self._parent.project.path, fileName)
self.path.setText(fileName)
def select_pre_exec_script(self):
"""Ask the user a python pre-exec script and set its value"""
fileName = QFileDialog.getOpenFileName(
self, translations.TR_PROJECT_SELECT_PRE_SCRIPT,
self._parent.project.path,
'*(*.*);;Bash(*.sh);;Python PY(*.py);;Python Bytecode(*.py[codw]);;'
'Bat(*.bat);;Cmd(*.cmd);;Exe(*.exe);;Bin(*.bin);;App(*.app)')
if fileName != '':
fileName = file_manager.convert_to_relative(
self._parent.project.path, fileName)
self.txtPreExec.setText(fileName)
def select_post_exec_script(self):
"""Ask the user a python post-exec script and set its value"""
fileName = QFileDialog.getOpenFileName(
self, translations.TR_PROJECT_SELECT_POST_SCRIPT,
self._parent.project.path,
'*(*.*);;Bash(*.sh);;Python PY(*.py);;Python Bytecode(*.py[codw]);;'
'Bat(*.bat);;Cmd(*.cmd);;Exe(*.exe);;Bin(*.bin);;App(*.app)')
if fileName != '':
fileName = file_manager.convert_to_relative(
self._parent.project.path, fileName)
self.txtPostExec.setText(fileName)
class CodePastingDialog(QDialog):
def __init__(self, parent=None, code=''):
super(CodePastingDialog, self).__init__(parent)
self.setWindowTitle(self.tr("Enviar a Pastebin"))
self.setMinimumSize(700, 500)
self._parent = parent
container = QVBoxLayout(self)
# Thread
self.thread = code_pasting.Thread()
self.connect(self.thread, SIGNAL("finished()"), self._paste_result)
# Campos
fields_box = QGridLayout()
fields_box.addWidget(QLabel(self.tr("Expirar después de:")), 0, 0)
self._spin_expire = QSpinBox()
self._spin_expire.setSuffix(self.tr(" Días"))
self._spin_expire.setMinimum(1)
fields_box.addWidget(self._spin_expire, 0, 1)
fields_box.addWidget(QLabel(self.tr("Acceso:")), 1, 0)
self._combo_access = QComboBox()
self._combo_access.addItems([self.tr("Público"), self.tr("Privado")])
fields_box.addWidget(self._combo_access, 1, 1)
fields_box.addWidget(QLabel(self.tr("Nombre:")), 2, 0)
self._line_filename = QLineEdit()
place_holder_text = parent.get_active_editor().filename
self._line_filename.setPlaceholderText(place_holder_text)
fields_box.addWidget(self._line_filename, 2, 1)
fields_box.addWidget(QLabel(self.tr("Descripción:")), 3, 0)
# Editor
self._code_editor = QPlainTextEdit()
self._set_editor_style(self._code_editor)
self._code_editor.setPlainText(code)
hbox = QHBoxLayout()
hbox.addItem(QSpacerItem(0, 1, QSizePolicy.Expanding))
btn_paste = QPushButton(self.tr("Enviar"))
hbox.addWidget(btn_paste)
btn_cancel = QPushButton(self.tr("Cancelar"))
hbox.addWidget(btn_cancel)
container.addLayout(fields_box)
container.addWidget(self._code_editor)
container.addLayout(hbox)
# Loading widget
self.loading_widget = loading_widget.LoadingWidget(self)
self.loading_widget.hide()
# Conexiones
self.connect(btn_cancel, SIGNAL("clicked()"), self.close)
self.connect(btn_paste, SIGNAL("clicked()"), self._emit_data)
def _emit_data(self):
code = self._code_editor.toPlainText()
expire = str(self._spin_expire.value()) + 'D'
paste_name = self._line_filename.text()
if not paste_name:
paste_name = self._parent.get_active_editor().filename
self.loading_widget.show()
self.thread.paste(code, paste_name, expire)
def _paste_result(self):
self.loading_widget.hide()
result = self.thread.result
if result is None:
QMessageBox.critical(self, self.tr("Error!"),
self.tr("No hay código"))
return
QMessageBox.information(self, self.tr("URL"), str(result))
self.close()
def _set_editor_style(self, editor):
style = 'QPlainTextEdit {color: #E2E2E5; background-color: #0E0F12; }'
editor.setStyleSheet(style)
def resizeEvent(self, event):
super(CodePastingDialog, self).resizeEvent(event)
self.loading_widget.resize(event.size())
class Preferences(QDialog):
def __init__(self, parent=None, test=False):
super(Preferences, self).__init__(parent)
self.parent = parent
self.test = test
saveQL = QLabel('<html><b>' + self.tr('Save files') + '</b></html>')
existQL = QLabel(self.tr('Existing files:'))
self.exst_prefixQRB = QRadioButton(self.tr("Add '~' prefix"))
self.exst_overwriteQRB = QRadioButton(self.tr('Overwrite'))
exist_layout = utils.add_to_layout('h', self.exst_prefixQRB,
self.exst_overwriteQRB)
defaultQL = QLabel(self.tr('Default output destination:'))
self.defaultQLE = QLineEdit()
self.defaultQTB = QToolButton()
self.defaultQTB.setText('...')
deafult_fol_layout = utils.add_to_layout('h', self.defaultQLE,
self.defaultQTB)
nameQL = QLabel('<html><b>' + self.tr('Name files') + '</b></html>')
prefixQL = QLabel(self.tr('Prefix:'))
suffixQL = QLabel(self.tr('Suffix:'))
self.prefixQLE = QLineEdit()
self.suffixQLE = QLineEdit()
grid = utils.add_to_grid([prefixQL, self.prefixQLE],
[suffixQL, self.suffixQLE])
prefix_layout = utils.add_to_layout('h', grid, None)
tabwidget1_layout = utils.add_to_layout('v', saveQL,
QSpacerItem(14, 13), existQL,
exist_layout,
QSpacerItem(14, 13), defaultQL,
deafult_fol_layout,
QSpacerItem(13, 13), nameQL,
QSpacerItem(14, 13),
prefix_layout, None)
ffmpegQL = QLabel('<html><b>FFmpeg</b></html>')
default_cmd_ffmpegQL = QLabel(self.tr('Default command:'))
self.ffmpegcmdQLE = QLineEdit()
vidcodecsQL = QLabel('<html><b>' + self.tr('Video codecs') +
'</b></html>')
self.vidcodecsQPTE = QPlainTextEdit()
audcodecsQL = QLabel('<html><b>' + self.tr('Audio codecs') +
'</b></html>')
self.audcodecsQPTE = QPlainTextEdit()
extraformatsffmpegQL = QLabel('<html><b>' + self.tr('Extra formats') +
'</b></html>')
self.extraformatsffmpegQPTE = QPlainTextEdit()
gridlayout = utils.add_to_grid(
[vidcodecsQL, audcodecsQL, extraformatsffmpegQL], [
self.vidcodecsQPTE, self.audcodecsQPTE,
self.extraformatsffmpegQPTE
])
defvidcodecsQPB = QPushButton(self.tr("Default video codecs"))
defaudcodecsQPB = QPushButton(self.tr("Default audio codecs"))
hlayout1 = utils.add_to_layout('h', None, defvidcodecsQPB,
defaudcodecsQPB)
tabwidget2_layout = utils.add_to_layout('v', ffmpegQL,
QSpacerItem(14, 13),
default_cmd_ffmpegQL,
self.ffmpegcmdQLE,
QSpacerItem(20, 20),
gridlayout, hlayout1, None)
imagemagickQL = QLabel('<html><b>ImageMagick (convert)</b></html>')
default_cmd_imageQL = QLabel(self.tr('Default options:'))
self.imagecmdQLE = QLineEdit()
extraformatsimageQL = QLabel('<html><b>' + self.tr('Extra formats') +
'</b></html>')
self.extraformatsimageQPTE = QPlainTextEdit()
hlayout2 = utils.add_to_layout('h', self.extraformatsimageQPTE,
QSpacerItem(220, 20))
tabwidget3_layout = utils.add_to_layout('v', imagemagickQL,
QSpacerItem(14, 13),
default_cmd_imageQL,
self.imagecmdQLE,
QSpacerItem(20, 20),
extraformatsimageQL, hlayout2,
None)
widget1 = QWidget()
widget1.setLayout(tabwidget1_layout)
widget2 = QWidget()
widget2.setLayout(tabwidget2_layout)
widget3 = QWidget()
widget3.setLayout(tabwidget3_layout)
tabWidget = QTabWidget()
tabWidget.addTab(widget1, self.tr('General'))
tabWidget.addTab(widget2, self.tr('Audio/Video'))
tabWidget.addTab(widget3, self.tr('Images'))
buttonBox = QDialogButtonBox(QDialogButtonBox.Ok
| QDialogButtonBox.Cancel)
final_layout = utils.add_to_layout('v', tabWidget, None, buttonBox)
self.setLayout(final_layout)
self.defaultQTB.clicked.connect(self.open_dir)
buttonBox.accepted.connect(self.save_settings)
buttonBox.rejected.connect(self.reject)
defvidcodecsQPB.clicked.connect(self.set_default_videocodecs)
defaudcodecsQPB.clicked.connect(self.set_default_audiocodecs)
self.resize(400, 450)
self.setWindowTitle(self.tr('Preferences'))
QTimer.singleShot(0, self.load_settings)
def load_settings(self):
"""Load settings and update graphical widgets with loaded values."""
settings = QSettings()
overwrite_existing = utils.str_to_bool(
settings.value('overwrite_existing'))
default_output = settings.value('default_output')
prefix = settings.value('prefix')
suffix = settings.value('suffix')
default_command = settings.value('default_command')
videocodecs = settings.value('videocodecs')
audiocodecs = settings.value('audiocodecs')
extraformats_video = settings.value('extraformats')
default_command_image = settings.value('default_command_image')
extraformats_image = settings.value('extraformats_image')
# QSettings.value() returns str() in python3, not QVariant() as in p2
if overwrite_existing:
self.exst_overwriteQRB.setChecked(True)
else:
self.exst_prefixQRB.setChecked(True)
if default_output:
self.defaultQLE.setText(default_output)
if prefix:
self.prefixQLE.setText(prefix)
if suffix:
self.suffixQLE.setText(suffix)
if default_command:
self.ffmpegcmdQLE.setText(default_command)
else:
self.ffmpegcmdQLE.setText(config.default_ffmpeg_cmd)
if not videocodecs:
self.set_default_videocodecs()
else:
self.vidcodecsQPTE.setPlainText(videocodecs)
if not audiocodecs:
self.set_default_audiocodecs
else:
self.audcodecsQPTE.setPlainText(audiocodecs)
self.extraformatsffmpegQPTE.setPlainText(extraformats_video)
if default_command_image:
self.imagecmdQLE.setText(default_command_image)
else:
self.imagecmdQLE.setText(config.default_imagemagick_cmd)
self.extraformatsimageQPTE.setPlainText(extraformats_image)
def set_default_videocodecs(self):
self.vidcodecsQPTE.setPlainText("\n".join(config.video_codecs))
def set_default_audiocodecs(self):
self.audcodecsQPTE.setPlainText("\n".join(config.audio_codecs))
def open_dir(self):
"""Get a directory name using a standard Qt dialog and update
self.defaultQLE with dir's name."""
if self.defaultQLE.isEnabled():
_dir = QFileDialog.getExistingDirectory(
self, 'FF Multi Converter - ' +
self.tr('Choose default output destination'), config.home)
if _dir:
self.defaultQLE.setText(_dir)
def save_settings(self):
"""Set settings values, extracting the appropriate information from
the graphical widgets."""
# remove empty codecs
videocodecs = []
audiocodecs = []
extraformats_video = []
extraformats_image = []
for i in self.vidcodecsQPTE.toPlainText().split("\n"):
i = i.strip()
if len(i.split()) == 1 and i not in videocodecs: # i single word
videocodecs.append(i)
for i in self.audcodecsQPTE.toPlainText().split("\n"):
i = i.strip()
if len(i.split()) == 1 and i not in audiocodecs:
audiocodecs.append(i)
for i in self.extraformatsffmpegQPTE.toPlainText().split("\n"):
i = i.strip()
if len(i.split()) == 1 and i not in extraformats_video \
and i not in config.video_formats:
extraformats_video.append(i)
for i in self.extraformatsimageQPTE.toPlainText().split("\n"):
i = i.strip()
if len(i.split()) == 1 and i not in extraformats_image \
and i not in config.image_formats:
extraformats_image.append(i)
videocodecs = "\n".join(sorted(videocodecs))
audiocodecs = "\n".join(sorted(audiocodecs))
extraformats_video = "\n".join(sorted(extraformats_video))
extraformats_image = "\n".join(sorted(extraformats_image))
settings = QSettings()
settings.setValue('overwrite_existing',
self.exst_overwriteQRB.isChecked())
settings.setValue('default_output', self.defaultQLE.text())
settings.setValue('prefix', self.prefixQLE.text())
settings.setValue('suffix', self.suffixQLE.text())
settings.setValue('default_command', self.ffmpegcmdQLE.text())
settings.setValue('videocodecs', videocodecs)
settings.setValue('audiocodecs', audiocodecs)
settings.setValue('extraformats', extraformats_video)
settings.setValue('default_command_image', self.imagecmdQLE.text())
settings.setValue('extraformats_image', extraformats_image)
self.accept()
class ProjectData(QWidget):
def __init__(self, parent):
super(ProjectData, self).__init__()
self._parent = parent
grid = QGridLayout(self)
grid.addWidget(QLabel(translations.TR_PROJECT_NAME), 0, 0)
self.name = QLineEdit()
if self._parent.project.name == '':
self.name.setText(file_manager.get_basename(
self._parent.project.path))
else:
self.name.setText(self._parent.project.name)
grid.addWidget(self.name, 0, 1)
grid.addWidget(QLabel(translations.TR_PROJECT_LOCATION), 1, 0)
self.txtPath = QLineEdit()
self.txtPath.setReadOnly(True)
self.txtPath.setText(self._parent.project.path)
grid.addWidget(self.txtPath, 1, 1)
grid.addWidget(QLabel(translations.TR_PROJECT_TYPE), 2, 0)
self.txtType = QLineEdit()
completer = QCompleter(sorted(settings.PROJECT_TYPES))
completer.setCompletionMode(QCompleter.UnfilteredPopupCompletion)
self.txtType.setCompleter(completer)
self.txtType.setText(self._parent.project.project_type)
grid.addWidget(self.txtType, 2, 1)
grid.addWidget(QLabel(translations.TR_PROJECT_DESCRIPTION), 3, 0)
self.description = QPlainTextEdit()
self.description.setPlainText(self._parent.project.description)
grid.addWidget(self.description, 3, 1)
grid.addWidget(QLabel(translations.TR_PROJECT_URL), 4, 0)
self.url = QLineEdit()
self.url.setText(self._parent.project.url)
grid.addWidget(self.url, 4, 1)
grid.addWidget(QLabel(translations.TR_PROJECT_LICENSE), 5, 0)
self.cboLicense = QComboBox()
self.cboLicense.addItem('Apache License 2.0')
self.cboLicense.addItem('Artistic License/GPL')
self.cboLicense.addItem('Eclipse Public License 1.0')
self.cboLicense.addItem('GNU General Public License v2')
self.cboLicense.addItem('GNU General Public License v3')
self.cboLicense.addItem('GNU Lesser General Public License')
self.cboLicense.addItem('MIT License')
self.cboLicense.addItem('Mozilla Public License 1.1')
self.cboLicense.addItem('Mozilla Public License 2.0')
self.cboLicense.addItem('New BSD License')
self.cboLicense.addItem('Other Open Source')
self.cboLicense.addItem('Other')
self.cboLicense.setCurrentIndex(4)
index = self.cboLicense.findText(self._parent.project.license)
self.cboLicense.setCurrentIndex(index)
grid.addWidget(self.cboLicense, 5, 1)
self.txtExtensions = QLineEdit()
self.txtExtensions.setText(', '.join(self._parent.project.extensions))
grid.addWidget(QLabel(translations.TR_PROJECT_EXTENSIONS), 6, 0)
grid.addWidget(self.txtExtensions, 6, 1)
grid.addWidget(QLabel(translations.TR_PROJECT_INDENTATION), 7, 0)
self.spinIndentation = QSpinBox()
self.spinIndentation.setValue(self._parent.project.indentation)
self.spinIndentation.setMinimum(1)
grid.addWidget(self.spinIndentation, 7, 1)
self.checkUseTabs = QCheckBox(translations.TR_PROJECT_USE_TABS)
self.checkUseTabs.setChecked(self._parent.project.use_tabs)
grid.addWidget(self.checkUseTabs, 7, 2)
class ProjectProperties(QDialog):
def __init__(self, parent, item):
QDialog.__init__(self, parent)
self.setModal(True)
self._item = item
self.setWindowTitle('Project Properties')
grid = QGridLayout(self)
grid.addWidget(QLabel('Name:'), 0, 0)
self.name = QLineEdit()
if self._item.name == '':
self.name.setText(manage_files.get_basename(self._item.path))
else:
self.name.setText(self._item.name)
grid.addWidget(self.name, 0, 1)
grid.addWidget(QLabel('Project Type:'), 1, 0)
self.txtType = TextProjectType()
self.txtType.setText(self._item.projectType)
grid.addWidget(self.txtType, 1, 1)
grid.addWidget(QLabel('Description:'), 2, 0)
self.description = QPlainTextEdit()
self.description.setPlainText(self._item.description)
grid.addWidget(self.description, 2, 1)
grid.addWidget(QLabel('URL:'), 3, 0)
self.url = QLineEdit()
self.url.setText(self._item.url)
grid.addWidget(self.url, 3, 1)
grid.addWidget(QLabel('Licence:'), 4, 0)
self.cboLicense = QComboBox()
self.cboLicense.addItem('Apache License 2.0')
self.cboLicense.addItem('Artistic License/GPL')
self.cboLicense.addItem('Eclipse Public License 1.0')
self.cboLicense.addItem('GNU General Public License v2')
self.cboLicense.addItem('GNU General Public License v3')
self.cboLicense.addItem('GNU Lesser General Public License')
self.cboLicense.addItem('MIT License')
self.cboLicense.addItem('Mozilla Public License 1.1')
self.cboLicense.addItem('New BSD License')
self.cboLicense.addItem('Other Open Source')
self.cboLicense.addItem('Other')
self.cboLicense.setCurrentIndex(4)
index = self.cboLicense.findText(self._item.license)
self.cboLicense.setCurrentIndex(index)
grid.addWidget(self.cboLicense, 4, 1)
grid.addWidget(QLabel('Main File:'), 5, 0)
self.path = QLineEdit()
self.path.setText(self._item.mainFile)
self.path.setReadOnly(True)
self.btnBrowse = QPushButton('Browse')
hbox = QHBoxLayout()
hbox.addWidget(self.path)
hbox.addWidget(self.btnBrowse)
grid.addLayout(hbox, 5, 1)
self.txtExtensions = QLineEdit()
self.txtExtensions.setText(str(', '.join(self._item.extensions)))
grid.addWidget(QLabel('Supported Extensions:'), 6, 0)
grid.addWidget(self.txtExtensions, 6, 1)
self.btnSave = QPushButton('Save')
self.btnCancel = QPushButton('Cancel')
hbox3 = QHBoxLayout()
hbox3.addWidget(self.btnCancel)
hbox3.addWidget(self.btnSave)
grid.addLayout(hbox3, 7, 1)
self.connect(self.btnBrowse, SIGNAL("clicked()"), self.select_file)
self.connect(self.btnCancel, SIGNAL("clicked()"), self.close)
self.connect(self.btnSave, SIGNAL("clicked()"), self.save_properties)
def select_file(self):
fileName = str(QFileDialog.getOpenFileName(self, 'Select Main File', self._item.path, '(*.py);;(*.*)'))
if fileName != '':
fileName = manage_files.convert_to_relative(self._item.path, fileName)[1:]
self.path.setText(fileName)
def save_properties(self):
if str(self.name.text()).strip() == '':
QMessageBox.critical(self, 'Properties Invalid', 'The Project must have a name.')
return
tempName = self._item.name
self._item.name = str(self.name.text())
self._item.description = str(self.description.toPlainText())
self._item.license = str(self.cboLicense.currentText())
self._item.mainFile = str(self.path.text())
self._item.url = str(self.url.text())
self._item.projectType = str(self.txtType.text())
extensions = str(self.txtExtensions.text()).split(', ')
self._item.extensions = tuple(extensions)
#save project properties
project = {}
project['name'] = self._item.name
project['description'] = self._item.description
project['url'] = self._item.url
project['license'] = self._item.license
project['mainFile'] = self._item.mainFile
project['project-type'] = self._item.projectType
project['supported-extensions'] = self._item.extensions
if tempName != self._item.name and \
manage_files.file_exists(self._item.path, tempName + '.nja'):
manage_files.delete_file(self._item.path, tempName + '.nja')
loader.create_ninja_project(self._item.path, self._item.name, project)
self._item.setText(0, self._item.name)
self._item.setToolTip(0, self._item.name)
if self._item.extensions != manage_files.supported_extensions:
self._item._parent._refresh_project(self._item)
self.close()
def getWidgetFromParameter(self, param):
# TODO Create Parameter widget class that holds the logic
# for creating a widget that belongs to the parameter.
if isinstance(param, ParameterRaster):
layers = dataobjects.getRasterLayers()
items = []
if param.optional:
items.append((self.NOT_SELECTED, None))
for layer in layers:
items.append((self.getExtendedLayerName(layer), layer))
item = InputLayerSelectorPanel(items, param)
elif isinstance(param, ParameterVector):
if self.somethingDependsOnThisParameter(param) or self.alg.allowOnlyOpenedLayers:
item = QComboBox()
layers = dataobjects.getVectorLayers(param.shapetype)
layers.sort(key=lambda lay: lay.name())
if param.optional:
item.addItem(self.NOT_SELECTED, None)
for layer in layers:
item.addItem(self.getExtendedLayerName(layer), layer)
item.currentIndexChanged.connect(self.updateDependentFields)
item.name = param.name
else:
layers = dataobjects.getVectorLayers(param.shapetype)
items = []
if param.optional:
items.append((self.NOT_SELECTED, None))
for layer in layers:
items.append((self.getExtendedLayerName(layer), layer))
# if already set, put first in list
for i,(name,layer) in enumerate(items):
if layer and layer.source() == param.value:
items.insert(0, items.pop(i))
item = InputLayerSelectorPanel(items, param)
elif isinstance(param, ParameterTable):
if self.somethingDependsOnThisParameter(param):
item = QComboBox()
layers = dataobjects.getTables()
if param.optional:
item.addItem(self.NOT_SELECTED, None)
for layer in layers:
item.addItem(layer.name(), layer)
item.currentIndexChanged.connect(self.updateDependentFields)
item.name = param.name
else:
layers = dataobjects.getTables()
items = []
if param.optional:
items.append((self.NOT_SELECTED, None))
for layer in layers:
items.append((layer.name(), layer))
# if already set, put first in list
for i,(name,layer) in enumerate(items):
if layer and layer.source() == param.value:
items.insert(0, items.pop(i))
item = InputLayerSelectorPanel(items, param)
elif isinstance(param, ParameterBoolean):
item = QCheckBox()
if param.default:
item.setChecked(True)
else:
item.setChecked(False)
elif isinstance(param, ParameterTableField):
item = QComboBox()
if param.parent in self.dependentItems:
items = self.dependentItems[param.parent]
else:
items = []
self.dependentItems[param.parent] = items
items.append(param.name)
parent = self.alg.getParameterFromName(param.parent)
if isinstance(parent, ParameterVector):
layers = dataobjects.getVectorLayers(parent.shapetype)
else:
layers = dataobjects.getTables()
if len(layers) > 0:
if param.optional:
item.addItem(self.tr('[not set]'))
item.addItems(self.getFields(layers[0], param.datatype))
elif isinstance(param, ParameterSelection):
item = QComboBox()
item.addItems(param.options)
item.setCurrentIndex(param.default)
elif isinstance(param, ParameterFixedTable):
item = FixedTablePanel(param)
elif isinstance(param, ParameterRange):
item = RangePanel(param)
elif isinstance(param, ParameterFile):
item = FileSelectionPanel(param.isFolder, param.ext)
elif isinstance(param, ParameterMultipleInput):
if param.datatype == ParameterMultipleInput.TYPE_FILE:
item = MultipleInputPanel(datatype=ParameterMultipleInput.TYPE_FILE)
else:
if param.datatype == ParameterMultipleInput.TYPE_RASTER:
options = dataobjects.getRasterLayers(sorting=False)
elif param.datatype == ParameterMultipleInput.TYPE_VECTOR_ANY:
options = dataobjects.getVectorLayers(sorting=False)
else:
options = dataobjects.getVectorLayers([param.datatype], sorting=False)
opts = []
for opt in options:
opts.append(self.getExtendedLayerName(opt))
item = MultipleInputPanel(opts)
elif isinstance(param, ParameterNumber):
item = NumberInputPanel(param.default, param.min, param.max,
param.isInteger)
elif isinstance(param, ParameterExtent):
item = ExtentSelectionPanel(self.parent, self.alg, param.default)
elif isinstance(param, ParameterCrs):
item = CrsSelectionPanel(param.default)
elif isinstance(param, ParameterString):
if param.multiline:
verticalLayout = QVBoxLayout()
verticalLayout.setSizeConstraint(
QLayout.SetDefaultConstraint)
textEdit = QPlainTextEdit()
textEdit.setPlainText(param.default)
verticalLayout.addWidget(textEdit)
item = textEdit
else:
item = QLineEdit()
item.setText(str(param.default))
elif isinstance(param, ParameterGeometryPredicate):
item = GeometryPredicateSelectionPanel(param.enabledPredicates)
if param.left:
widget = self.valueItems[param.left]
if isinstance(widget, InputLayerSelectorPanel):
widget = widget.cmbText
widget.currentIndexChanged.connect(item.onLeftLayerChange)
item.leftLayer = widget.itemData(widget.currentIndex())
if param.right:
widget = self.valueItems[param.right]
if isinstance(widget, InputLayerSelectorPanel):
widget = widget.cmbText
widget.currentIndexChanged.connect(item.onRightLayerChange)
item.rightLayer = widget.itemData(widget.currentIndex())
item.updatePredicates()
item.setValue(param.default)
else:
item = QLineEdit()
item.setText(str(param.default))
return item
class OWodbcTable(OWWidget):
priority = 3
allSQLSelectWidgets = []
settingsList = ["recentConnections", "lastQuery"]
name = "ODBC"
description = "Create a Table from an ODBC datasource"
icon = "../icons/sql.png"
inputs = []
outputs = [("Data", Orange.data.Table, widget.Default),
("Feature Definitions", Orange.data.Domain, widget.Default),
("Pandas", pd.DataFrame, widget.Default)]
settingsHandler = settings.DomainContextHandler()
def __init__(self):
super().__init__()
gui.label(self.controlArea, self, "from pandas:")
self.setSizePolicy(QSizePolicy.Maximum, QSizePolicy.Maximum)
self.allSQLSelectWidgets.append(self) # set default settings
self.domain = None
self.recentConnections = list()
self.recentConnections.append("(none)")
self.queryFile = None
self.query = ''
self.lastQuery = None
if self.lastQuery is not None:
self.query = self.lastQuery
sources = pyodbc.dataSources()
dsns = list(sources.keys())
dsns.sort()
for dsn in dsns:
self.recentConnections.append("DSN={dsn}".format(dsn=dsn))
self.connectString = self.recentConnections[0]
self.connectBox = gui.widgetBox(self.controlArea, "Database")
self.connectLineEdit = gui.lineEdit(self.connectBox,
self,
'connectString',
callback=None)
self.connectCombo = gui.comboBox(self.connectBox,
self,
'connectString',
items=self.recentConnections,
valueType=str,
sendSelectedValue=True)
self.button = gui.button(self.connectBox,
self,
'connect',
callback=self.connectDB,
disabled=0)
# query
self.splitCanvas = QSplitter(QtCore.Qt.Vertical, self.mainArea)
self.mainArea.layout().addWidget(self.splitCanvas)
self.textBox = gui.widgetBox(self, 'HiveQL')
self.splitCanvas.addWidget(self.textBox)
self.queryTextEdit = QPlainTextEdit(self.query, self)
self.textBox.layout().addWidget(self.queryTextEdit)
self.selectBox = gui.widgetBox(self.controlArea, "Select statement")
# self.selectSubmitBox = QHGroupBox("", self.selectBox)
# self.queryTextEdit.setSizePolicy(QSizePolicy(QSizePolicy.Preferred, QSizePolicy.Preferred))
# self.queryTextEdit.setMinimumWidth(300)
# self.connect(self.queryTextEdit, SIGNAL('returnPressed()'), self.executeQuery)
gui.button(self.selectBox, self, "Open...", callback=self.openScript)
gui.button(self.selectBox, self, "Save...", callback=self.saveScript)
self.selectBox.setSizePolicy(
QSizePolicy(QSizePolicy.MinimumExpanding,
QSizePolicy.MinimumExpanding))
gui.button(self.selectBox,
self,
'format SQL!',
callback=self.format_sql,
disabled=0)
gui.button(self.selectBox,
self,
'execute!',
callback=self.executeQuery,
disabled=0)
self.domainBox = gui.widgetBox(self.controlArea, "Domain")
self.domainLabel = gui.label(self.domainBox, self, '')
# info
self.infoBox = gui.widgetBox(self.controlArea, "Info")
self.info = []
self.info.append(gui.label(self.infoBox, self, 'No data loaded.'))
self.info.append(gui.label(self.infoBox, self, ''))
self.resize(300, 300)
self.cnxn = None
def destroy(self, destroyWindow, destroySubWindows):
self.allSQLSelectWidgets.remove(self)
self.destroy(self, destroyWindow, destroySubWindows)
def activateLoadedSettings(self):
# print "activating", self.recentQueries, ", ",self.recentConnections
self.query = self.lastQuery
self.setConnectionList()
def selectConnection(self, n):
if n < len(self.recentConnections):
name = self.recentConnections[n]
self.recentConnections.remove(name)
self.recentConnections.insert(0, name)
if len(self.recentConnections) > 0:
self.setConnectionList()
self.connectDB(self.recentConnections[0])
def setInfo(self, info):
for (i, s) in enumerate(info):
self.info[i].setText(s)
def setMeta(self):
domain = self.data.domain
# s = "Attrs:\n " + "\n ".join([str(i) for i in domain.attributes]) + "\n" + "Class:" + str(domain.classVar)
# self.domainLabel.setText(s)
# for i in domain.getmetas():
# self.propertyCheckBoxes[i].set()
# checks whether any file widget knows of any variable from the current domain
def attributesOverlap(self, domain):
for fw in self.allFileWidgets:
if fw != self and getattr(fw, "dataDomain", None):
for var in domain:
if var in fw.dataDomain:
return True
return False
# Execute a query, create data from it and send it over the data channel
def executeQuery(self, query=None, throughReload=0, DK=None, DC=None):
self.connectDB()
query = self.queryTextEdit.toPlainText()
if query is None:
query = str(self.queryTextEdit.toPlainText())
# try:
self.pandas = psql.read_sql_query(query, self.cnxn)
# except Exception:
# self.setInfo(('Query failed:', str('')))
# df = pd.DataFrame()
self.data = convert_dataframe_to_orange(self.pandas)
self.send("Data", self.data)
self.send("Pandas", self.pandas)
self.setInfo(
('Query returned', 'Read ' + str(len(self.data)) + ' examples!'))
self.send("Feature Definitions", self.data.domain)
self.setMeta()
self.lastQuery = query
def format_sql(self):
query = str(self.queryTextEdit.toPlainText())
str_sql = str(format_sql(query))
self.queryTextEdit.clear()
self.queryTextEdit.insertPlainText(str_sql)
def connectDB(self):
if self.connectString is None:
self.connectString = str(self.connectString)
if self.connectString in self.recentConnections:
self.recentConnections.remove(self.connectString)
self.recentConnections.insert(0, self.connectString)
print(self.connectString)
self.cnxn = pyodbc.connect(self.connectString, autocommit=True)
# set the query combo box
def setConnectionList(self):
self.connectCombo.clear()
if not self.recentConnections:
self.connectCombo.insertItem("(none)")
else:
self.connectLineEdit.setText(self.recentConnections[0])
for connection in self.recentConnections:
self.connectCombo.insertItem(connection)
self.connectCombo.updateGeometry()
def openScript(self, filename=None):
if self.queryFile is None:
self.queryFile = ''
if filename == None:
self.queryFile = QFileDialog.getOpenFileName(
self, 'Open SQL file', self.queryFile,
'SQL files (*.sql)\nAll files(*.*)')
else:
self.queryFile = filename
if self.queryFile == "": return
f = open(self.queryFile, 'r')
self.queryTextEdit.setPlainText(f.read())
f.close()
def saveScript(self):
if self.queryFile is None:
self.queryFile = ''
self.queryFile = QFileDialog.getSaveFileName(
self, 'Save SQL file', self.queryFile,
'SQL files (*.sql)\nAll files(*.*)')
if self.queryFile:
fn = ""
head, tail = os.path.splitext(self.queryFile)
if not tail:
fn = head + ".sql"
else:
fn = self.queryFile
f = open(fn, 'w')
f.write(self.queryTextEdit.toPlainText())
f.close()
class CodePastingDialog(QDialog):
def __init__(self, parent=None, code=''):
super(CodePastingDialog, self).__init__(parent)
self.setWindowTitle(self.tr("Enviar a Pastebin"))
self.setMinimumSize(700, 500)
self._parent = parent
container = QVBoxLayout(self)
# Thread
self.thread = code_pasting.Thread()
self.connect(self.thread, SIGNAL("finished()"),
self._paste_result)
# Campos
fields_box = QGridLayout()
fields_box.addWidget(QLabel(self.tr("Expirar después de:")), 0, 0)
self._spin_expire = QSpinBox()
self._spin_expire.setSuffix(self.tr(" Días"))
self._spin_expire.setMinimum(1)
fields_box.addWidget(self._spin_expire, 0, 1)
fields_box.addWidget(QLabel(self.tr("Acceso:")), 1, 0)
self._combo_access = QComboBox()
self._combo_access.addItems([self.tr("Público"), self.tr("Privado")])
fields_box.addWidget(self._combo_access, 1, 1)
fields_box.addWidget(QLabel(self.tr("Nombre:")), 2, 0)
self._line_filename = QLineEdit()
place_holder_text = parent.get_active_editor().filename
self._line_filename.setPlaceholderText(place_holder_text)
fields_box.addWidget(self._line_filename, 2, 1)
fields_box.addWidget(QLabel(self.tr("Descripción:")), 3, 0)
# Editor
self._code_editor = QPlainTextEdit()
self._set_editor_style(self._code_editor)
self._code_editor.setPlainText(code)
hbox = QHBoxLayout()
hbox.addItem(QSpacerItem(0, 1, QSizePolicy.Expanding))
btn_paste = QPushButton(self.tr("Enviar"))
hbox.addWidget(btn_paste)
btn_cancel = QPushButton(self.tr("Cancelar"))
hbox.addWidget(btn_cancel)
container.addLayout(fields_box)
container.addWidget(self._code_editor)
container.addLayout(hbox)
# Loading widget
self.loading_widget = loading_widget.LoadingWidget(self)
self.loading_widget.hide()
# Conexiones
self.connect(btn_cancel, SIGNAL("clicked()"), self.close)
self.connect(btn_paste, SIGNAL("clicked()"), self._emit_data)
def _emit_data(self):
code = self._code_editor.toPlainText()
expire = str(self._spin_expire.value()) + 'D'
paste_name = self._line_filename.text()
if not paste_name:
paste_name = self._parent.get_active_editor().filename
self.loading_widget.show()
self.thread.paste(code, paste_name, expire)
def _paste_result(self):
self.loading_widget.hide()
result = self.thread.result
if result is None:
QMessageBox.critical(self, self.tr("Error!"),
self.tr("No hay código"))
return
QMessageBox.information(self, self.tr("URL"),
str(result))
self.close()
def _set_editor_style(self, editor):
style = 'QPlainTextEdit {color: #E2E2E5; background-color: #0E0F12; }'
editor.setStyleSheet(style)
def resizeEvent(self, event):
super(CodePastingDialog, self).resizeEvent(event)
self.loading_widget.resize(event.size())
def __init__(self,
settings,
name,
filename,
plain_text=False,
parent=None):
super().__init__(parent=parent)
splitty = QSplitter(self)
self.setWidget(splitty)
self.setWindowTitle(os.path.basename(name))
self.setFloating(True)
self.setAttribute(Qt.WA_DeleteOnClose)
self.plain_text = plain_text
self.notePath = settings.notePath
fh = QFile(filename)
try:
if not fh.open(QIODevice.ReadOnly):
raise IOError(fh.errorString())
except IOError as e:
QMessageBox.warning(
self, self.tr("Read Error"),
self.tr("Failed to open %s: %s") % (filename, e))
finally:
if fh is not None:
noteBody = QTextStream(fh).readAll()
fh.close()
self.tocw = TocTree(self)
splitty.addWidget(self.tocw)
strip_math_for_header_parsing = False
strip_fence_for_header_parsing = False
self.tocw.itemClicked.connect(self.tocNavigate)
if 'asciimathml' in settings.extensions:
stuff = JSCRIPT_TPL.format(settings.mathjax)
strip_math_for_header_parsing = True
else:
stuff = ''
if 'fenced_code' in settings.extensions or 'extra' in settings.extensions:
strip_fence_for_header_parsing = True
if plain_text:
note_view = QPlainTextEdit(self)
qfnt = QFont()
qfnt.setFamily('monospace')
note_view.setFont(qfnt)
note_view.setPlainText(noteBody)
else:
note_view = QWebView(self)
note_view.setHtml(settings.md.reset().convert(noteBody) +
stuff)
note_view.page().setLinkDelegationPolicy(
QWebPage.DelegateAllLinks)
note_view.linkClicked.connect(self.linkClicked)
note_view.settings().setUserStyleSheetUrl(
QUrl('file://' + self.parent().settings.cssfile))
self.note_view = note_view
splitty.addWidget(note_view)
self.tocw.updateToc(
os.path.basename(name),
parseHeaders(
noteBody,
strip_fenced_block=strip_fence_for_header_parsing,
strip_ascii_math=strip_math_for_header_parsing))
class ProjectProperties(QDialog):
def __init__(self, item, parent=None):
QDialog.__init__(self, parent, Qt.Dialog)
self.setModal(True)
self._item = item
self.setWindowTitle(self.tr("Project Properties"))
grid = QGridLayout(self)
grid.addWidget(QLabel(self.tr("Name:")), 0, 0)
self.name = QLineEdit()
if self._item.name == '':
self.name.setText(file_manager.get_basename(self._item.path))
else:
self.name.setText(self._item.name)
grid.addWidget(self.name, 0, 1)
grid.addWidget(QLabel(self.tr("Project Type:")), 1, 0)
self.txtType = QLineEdit()
completer = QCompleter(sorted(settings.PROJECT_TYPES))
completer.setCompletionMode(QCompleter.UnfilteredPopupCompletion)
self.txtType.setCompleter(completer)
self.txtType.setText(self._item.projectType)
grid.addWidget(self.txtType, 1, 1)
grid.addWidget(QLabel(self.tr("Description:")), 2, 0)
self.description = QPlainTextEdit()
self.description.setPlainText(self._item.description)
grid.addWidget(self.description, 2, 1)
grid.addWidget(QLabel(self.tr("URL:")), 3, 0)
self.url = QLineEdit()
self.url.setText(self._item.url)
grid.addWidget(self.url, 3, 1)
grid.addWidget(QLabel(self.tr("Licence:")), 4, 0)
self.cboLicense = QComboBox()
self.cboLicense.addItem('Apache License 2.0')
self.cboLicense.addItem('Artistic License/GPL')
self.cboLicense.addItem('Eclipse Public License 1.0')
self.cboLicense.addItem('GNU General Public License v2')
self.cboLicense.addItem('GNU General Public License v3')
self.cboLicense.addItem('GNU Lesser General Public License')
self.cboLicense.addItem('MIT License')
self.cboLicense.addItem('Mozilla Public License 1.1')
self.cboLicense.addItem('New BSD License')
self.cboLicense.addItem('Other Open Source')
self.cboLicense.addItem('Other')
self.cboLicense.setCurrentIndex(4)
index = self.cboLicense.findText(self._item.license)
self.cboLicense.setCurrentIndex(index)
grid.addWidget(self.cboLicense, 4, 1)
grid.addWidget(QLabel(self.tr("Main File:")), 5, 0)
self.path = QLineEdit()
ui_tools.LineEditButton(self.path, self.path.clear,
self.style().standardPixmap(self.style().SP_TrashIcon))
self.path.setText(self._item.mainFile)
self.path.setReadOnly(True)
self.btnBrowse = QPushButton(QIcon(
self.style().standardPixmap(self.style().SP_FileIcon)), '')
hbox = QHBoxLayout()
hbox.addWidget(self.path)
hbox.addWidget(self.btnBrowse)
grid.addLayout(hbox, 5, 1)
self.txtExtensions = QLineEdit()
self.txtExtensions.setText(str(', '.join(self._item.extensions)))
grid.addWidget(QLabel(self.tr("Supported Extensions:")), 6, 0)
grid.addWidget(self.txtExtensions, 6, 1)
self.txtPythonPath = QLineEdit()
self.txtPythonPath.setText(self._item.pythonPath)
self.btnPythonPath = QPushButton(QIcon(resources.IMAGES['open']), '')
grid.addWidget(QLabel(self.tr("Python Path:")), 7, 0)
grid.addWidget(self.txtPythonPath, 7, 1)
grid.addWidget(self.btnPythonPath, 7, 2)
self.txtParams = QLineEdit()
self.txtParams.setToolTip(
self.tr("Separate the params with commas (ie: help, verbose)"))
self.txtParams.setText(self._item.programParams)
grid.addWidget(QLabel(self.tr("Params (comma separated):")), 8, 0)
grid.addWidget(self.txtParams, 8, 1)
#Widgets for virtualenv properties
self.txtVenvPath = QLineEdit()
ui_tools.LineEditButton(self.txtVenvPath, self.txtVenvPath.clear,
self.style().standardPixmap(self.style().SP_TrashIcon))
self.txtVenvPath.setText(self._item.venv)
self.txtVenvPath.setReadOnly(True)
self.btnVenvPath = QPushButton(QIcon(resources.IMAGES['open']), '')
grid.addWidget(QLabel(self.tr("Virtualenv Folder:")), 9, 0)
grid.addWidget(self.txtVenvPath, 9, 1)
grid.addWidget(self.btnVenvPath, 9, 2)
self.btnSave = QPushButton(self.tr("Save"))
self.btnCancel = QPushButton(self.tr("Cancel"))
hbox3 = QHBoxLayout()
hbox3.addWidget(self.btnCancel)
hbox3.addWidget(self.btnSave)
grid.addLayout(hbox3, 10, 1)
self.connect(self.btnBrowse, SIGNAL("clicked()"), self.select_file)
self.connect(self.btnCancel, SIGNAL("clicked()"), self.close)
self.connect(self.btnSave, SIGNAL("clicked()"), self.save_properties)
self.connect(self.btnPythonPath, SIGNAL("clicked()"),
self._load_python_path)
self.connect(self.btnVenvPath, SIGNAL("clicked()"),
self._load_python_venv)
def _load_python_path(self):
path = unicode(QFileDialog.getOpenFileName(
self, self.tr("Select Python Path")))
self.txtPythonPath.setText(path)
def _load_python_venv(self):
venv = unicode(QFileDialog.getExistingDirectory(
self, self.tr("Select Virtualenv Folder")))
if sys.platform == 'win32':
venv = os.path.join(venv, 'Scripts', 'python')
else:
venv = os.path.join(venv, 'bin', 'python')
#check if venv folder exists
if not os.path.exists(venv):
QMessageBox.information(self,
self.tr("Virtualenv Folder"),
self.tr("This is not a valid Virtualenv Folder"))
self.txtVenvPath.setText("")
else:
self.txtVenvPath.setText(venv)
def select_file(self):
fileName = unicode(QFileDialog.getOpenFileName(
self, self.tr("Select Main File"),
self._item.path, '(*.py);;(*.*)'))
if fileName != '':
fileName = file_manager.convert_to_relative(
self._item.path, fileName)
self.path.setText(fileName)
def save_properties(self):
if str(self.name.text()).strip() == '':
QMessageBox.critical(self, self.tr("Properties Invalid"),
self.tr("The Project must have a name."))
return
tempName = self._item.name
self._item.name = unicode(self.name.text())
self._item.description = unicode(self.description.toPlainText())
self._item.license = unicode(self.cboLicense.currentText())
self._item.mainFile = unicode(self.path.text())
self._item.url = unicode(self.url.text())
self._item.projectType = unicode(self.txtType.text())
self._item.pythonPath = unicode(self.txtPythonPath.text())
self._item.programParams = unicode(self.txtParams.text())
self._item.venv = unicode(self.txtVenvPath.text())
extensions = unicode(self.txtExtensions.text()).split(', ')
self._item.extensions = tuple(extensions)
#save project properties
project = {}
project['name'] = self._item.name
project['description'] = self._item.description
project['url'] = self._item.url
project['license'] = self._item.license
project['mainFile'] = self._item.mainFile
project['project-type'] = self._item.projectType
project['supported-extensions'] = self._item.extensions
project['pythonPath'] = self._item.pythonPath
project['venv'] = self._item.venv
project['programParams'] = self._item.programParams
if tempName != self._item.name and \
file_manager.file_exists(self._item.path, tempName + '.nja'):
file_manager.delete_file(self._item.path, tempName + '.nja')
json_manager.create_ninja_project(
self._item.path, self._item.name, project)
self._item.setText(0, self._item.name)
self._item.setToolTip(0, self._item.name)
if self._item.extensions != settings.SUPPORTED_EXTENSIONS:
self._item._parent._refresh_project(self._item)
self.close()
class MigrationWidget(QWidget):
def __init__(self):
super(MigrationWidget, self).__init__()
self._migration = {}
vbox = QVBoxLayout(self)
lbl_title = QLabel(self.tr("Current code:"))
self.current_list = QListWidget()
lbl_suggestion = QLabel(self.tr("Suggested changes:"))
self.suggestion = QPlainTextEdit()
self.suggestion.setReadOnly(True)
self.btn_apply = QPushButton(self.tr("Apply change!"))
hbox = QHBoxLayout()
hbox.addSpacerItem(QSpacerItem(1, 0, QSizePolicy.Expanding))
hbox.addWidget(self.btn_apply)
vbox.addWidget(lbl_title)
vbox.addWidget(self.current_list)
vbox.addWidget(lbl_suggestion)
vbox.addWidget(self.suggestion)
vbox.addLayout(hbox)
self.connect(self.current_list,
SIGNAL("itemClicked(QListWidgetItem*)"), self.load_suggestion)
self.connect(self.btn_apply, SIGNAL("clicked()"), self.apply_changes)
def apply_changes(self):
lineno = int(self.current_list.currentItem().data(Qt.UserRole))
lines = self._migration.migration_data[lineno][0].split('\n')
remove = -1
code = ''
for line in lines:
if line.startswith('-'):
remove += 1
elif line.startswith('+'):
code += '%s\n' % line[1:]
main_container = IDE.get_service('main_container')
if main_container:
editorWidget = main_container.get_actual_editor()
block_start = editorWidget.document().findBlockByLineNumber(lineno)
block_end = editorWidget.document().findBlockByLineNumber(
lineno + remove)
cursor = editorWidget.textCursor()
cursor.setPosition(block_start.position())
cursor.setPosition(block_end.position(), QTextCursor.KeepAnchor)
cursor.movePosition(QTextCursor.EndOfLine, QTextCursor.KeepAnchor)
cursor.insertText(code[:-1])
def load_suggestion(self, item):
lineno = int(item.data(Qt.UserRole))
lines = self._migration.migration_data[lineno][0].split('\n')
code = ''
for line in lines:
if line.startswith('+'):
code += '%s\n' % line[1:]
self.suggestion.setPlainText(code)
main_container = IDE.get_service('main_container')
if main_container:
editorWidget = main_container.get_actual_editor()
if editorWidget:
editorWidget.jump_to_line(lineno)
editorWidget.setFocus()
def refresh_lists(self, migration):
self._migration = migration
self.current_list.clear()
base_lineno = -1
for lineno in sorted(migration.migration_data.keys()):
linenostr = 'L%s\n' % str(lineno + 1)
data = migration.migration_data[lineno]
lines = data[0].split('\n')
if base_lineno == data[1]:
continue
base_lineno = data[1]
message = ''
for line in lines:
if line.startswith('-'):
message += '%s\n' % line
item = QListWidgetItem(linenostr + message)
item.setToolTip(linenostr + message)
item.setData(Qt.UserRole, lineno)
self.current_list.addItem(item)
def clear(self):
"""
Clear the widget
"""
self.current_list.clear()
self.suggestion.clear()
def getWidgetFromParameter(self, param):
# TODO Create Parameter widget class that holds the logic
# for creating a widget that belongs to the parameter.
if isinstance(param, ParameterRaster):
layers = dataobjects.getRasterLayers()
items = []
if param.optional:
items.append((self.NOT_SELECTED, None))
for layer in layers:
items.append((self.getExtendedLayerName(layer), layer))
item = InputLayerSelectorPanel(items, param)
elif isinstance(param, ParameterVector):
if self.somethingDependsOnThisParameter(
param) or self.alg.allowOnlyOpenedLayers:
item = QComboBox()
layers = dataobjects.getVectorLayers(param.shapetype)
layers.sort(key=lambda lay: lay.name())
if param.optional:
item.addItem(self.NOT_SELECTED, None)
for layer in layers:
item.addItem(self.getExtendedLayerName(layer), layer)
item.currentIndexChanged.connect(self.updateDependentFields)
item.name = param.name
else:
layers = dataobjects.getVectorLayers(param.shapetype)
items = []
if param.optional:
items.append((self.NOT_SELECTED, None))
for layer in layers:
items.append((self.getExtendedLayerName(layer), layer))
# if already set, put first in list
for i, (name, layer) in enumerate(items):
if layer and layer.source() == param.value:
items.insert(0, items.pop(i))
item = InputLayerSelectorPanel(items, param)
elif isinstance(param, ParameterTable):
if self.somethingDependsOnThisParameter(param):
item = QComboBox()
layers = dataobjects.getTables()
if param.optional:
item.addItem(self.NOT_SELECTED, None)
for layer in layers:
item.addItem(layer.name(), layer)
item.currentIndexChanged.connect(self.updateDependentFields)
item.name = param.name
else:
layers = dataobjects.getTables()
items = []
if param.optional:
items.append((self.NOT_SELECTED, None))
for layer in layers:
items.append((layer.name(), layer))
# if already set, put first in list
for i, (name, layer) in enumerate(items):
if layer and layer.source() == param.value:
items.insert(0, items.pop(i))
item = InputLayerSelectorPanel(items, param)
elif isinstance(param, ParameterBoolean):
item = QCheckBox()
if param.default:
item.setChecked(True)
else:
item.setChecked(False)
elif isinstance(param, ParameterTableField):
item = QComboBox()
if param.parent in self.dependentItems:
items = self.dependentItems[param.parent]
else:
items = []
self.dependentItems[param.parent] = items
items.append(param.name)
parent = self.alg.getParameterFromName(param.parent)
if isinstance(parent, ParameterVector):
layers = dataobjects.getVectorLayers(parent.shapetype)
else:
layers = dataobjects.getTables()
if len(layers) > 0:
if param.optional:
item.addItem(self.tr('[not set]'))
item.addItems(self.getFields(layers[0], param.datatype))
elif isinstance(param, ParameterSelection):
item = QComboBox()
item.addItems(param.options)
if param.default:
item.setCurrentIndex(param.default)
elif isinstance(param, ParameterFixedTable):
item = FixedTablePanel(param)
elif isinstance(param, ParameterRange):
item = RangePanel(param)
elif isinstance(param, ParameterFile):
item = FileSelectionPanel(param.isFolder, param.ext)
elif isinstance(param, ParameterMultipleInput):
if param.datatype == ParameterMultipleInput.TYPE_FILE:
item = MultipleInputPanel(
datatype=ParameterMultipleInput.TYPE_FILE)
else:
if param.datatype == ParameterMultipleInput.TYPE_RASTER:
options = dataobjects.getRasterLayers(sorting=False)
elif param.datatype == ParameterMultipleInput.TYPE_VECTOR_ANY:
options = dataobjects.getVectorLayers(sorting=False)
else:
options = dataobjects.getVectorLayers([param.datatype],
sorting=False)
opts = [self.getExtendedLayerName(opt) for opt in options]
item = MultipleInputPanel(opts)
elif isinstance(param, ParameterNumber):
item = NumberInputPanel(param.default, param.min, param.max,
param.isInteger)
elif isinstance(param, ParameterExtent):
item = ExtentSelectionPanel(self.parent, self.alg, param.default)
elif isinstance(param, ParameterCrs):
item = CrsSelectionPanel(param.default)
elif isinstance(param, ParameterString):
if param.multiline:
verticalLayout = QVBoxLayout()
verticalLayout.setSizeConstraint(QLayout.SetDefaultConstraint)
textEdit = QPlainTextEdit()
if param.default:
textEdit.setPlainText(param.default)
verticalLayout.addWidget(textEdit)
item = textEdit
else:
item = QLineEdit()
if param.default:
item.setText(unicode(param.default))
elif isinstance(param, ParameterGeometryPredicate):
item = GeometryPredicateSelectionPanel(param.enabledPredicates)
if param.left:
widget = self.valueItems[param.left]
if isinstance(widget, InputLayerSelectorPanel):
widget = widget.cmbText
widget.currentIndexChanged.connect(item.onLeftLayerChange)
item.leftLayer = widget.itemData(widget.currentIndex())
if param.right:
widget = self.valueItems[param.right]
if isinstance(widget, InputLayerSelectorPanel):
widget = widget.cmbText
widget.currentIndexChanged.connect(item.onRightLayerChange)
item.rightLayer = widget.itemData(widget.currentIndex())
item.updatePredicates()
if param.default:
item.setValue(param.default)
else:
item = QLineEdit()
if param.default:
item.setText(unicode(param.default))
return item
def create_account_dialog(self):
def coinapult_signup():
try:
self.client.createAccount(createLocalKeys=True, changeAuthMethod=True, tag="electrum-gfk36")
self.client.activateAccount(agree=True)
except (CoinapultError, CoinapultErrorECC) as ce:
QMessageBox.warning(None, _("Unable to create Coinapult account because %s" % str(ce),
QString(_("OK"))))
def signup_done(result):
self.ca_ok_button.setDisabled(False)
self.wallet.storage.put("coinapult_ecc_public", str(self.client.ecc_pub_pem))
self.ecc_pub_key_edit.setText(self.client.ecc_pub_pem)
self.wallet.storage.put("coinapult_ecc_private", str(self.client.ecc['privkey'].to_pem()))
self.ecc_priv_key_edit.setText(str(self.client.ecc['privkey'].to_pem()))
self.config.set_key('coinapult_auth_method', 'ECC', True)
ecc_pub = self.wallet.storage.get("coinapult_ecc_public", '')
ecc_priv = self.wallet.storage.get("coinapult_ecc_private", '')
try:
self.client = CoinapultClient(ecc={'pubkey': ecc_pub, 'privkey': ecc_priv}, authmethod='ecc')
except (CoinapultError, CoinapultErrorECC):
self.client = None
QMessageBox.warning(None, _('Coinapult Connection failed'),
_('Failed to connect to Coinapult. Locks disabled for this session.'), _('OK'))
d.accept()
def on_change_tos(checked):
if checked:
self.config.set_key('plugin_coinapult_locks_tos', 'checked')
else:
self.config.set_key('plugin_coinapult_locks_tos', 'unchecked')
def ok_clicked():
if self.agreed_tos():
self.ca_ok_button.setDisabled(True)
self.waiting_dialog = WaitingDialog(d, 'Creating your Coinapult account. One moment please...',
coinapult_signup, signup_done)
self.waiting_dialog.start()
d = QDialog()
d.setWindowTitle("Create Coinapult Account")
layout = QGridLayout(d)
# lable = None
text_edit = QPlainTextEdit()
text = open(os.path.dirname(__file__) + '/lib/TERMS.txt').read()
text_edit.setPlainText(text)
layout.addWidget(text_edit, 0, 0)
layout.setRowStretch(0, 8)
layout.addWidget(QLabel(_("Do you agree to Coinapult's Terms of Service (https://coinapult.com/terms)?: ")),
3, 0)
tos_checkbox = QCheckBox()
tos_checkbox.setEnabled(True)
tos_checkbox.setChecked(self.config.get('plugin_coinapult_locks_tos', 'unchecked') != 'unchecked')
tos_checkbox.stateChanged.connect(on_change_tos)
layout.addWidget(tos_checkbox, 3, 1)
layout.addWidget(
QLabel(_("<font color='red'>This will overwrite any Coinapult API keys in your wallet.<br>"
"If you do not have backups of your API keys, this will lock you out of your " # TODO This isn't actually stored in the wallet yet...
"account!</font>")), 4, 0)
self.ca_ok_button = QPushButton(_("OK"))
self.ca_ok_button.clicked.connect(ok_clicked)
layout.addWidget(self.ca_ok_button, 5, 1)
if d.exec_():
return True
else:
return False
class CommandWindow(QFrame):
"""Miow main window
"""
def __init__(self, parent=None):
super(CommandWindow, self).__init__(parent)
self.parent = parent
self.setWindowFlags(QtCore.Qt.Popup)
self.setFont(QFont("Monospace", 14))
self.setMinimumWidth(400)
self.setMinimumHeight(300)
self.setGeometry(0, 0, 600, 300)
# create widgets
layout = QVBoxLayout(self)
self.line_edit = QLineEdit(self)
layout.addWidget(self.line_edit)
self.list_widget = QListWidget(self)
self.list_widget.currentItemChanged.connect(self.on_current_item_changed)
layout.addWidget(self.list_widget)
layout.setStretchFactor(self.list_widget, 15)
layout.setMargin(0)
layout.setSpacing(0)
layout.setContentsMargins(0,0,0,0)
self.setLayout(layout)
self.line_edit.setFocus()
self.full_command = QPlainTextEdit(self)
self.full_command.setFont(QFont("Monospace", 8))
size_policy = self.full_command.sizePolicy()
size_policy.setVerticalPolicy(QSizePolicy.Ignored)
self.full_command.setSizePolicy(size_policy)
layout.addWidget(self.full_command)
layout.setStretchFactor(self.full_command, 3)
layout2 = QHBoxLayout(self)
self.weight = QLabel(self)
self.weight.setFont(QFont("Monospace", 8))
size_policy = self.weight.sizePolicy()
size_policy.setVerticalPolicy(QSizePolicy.Ignored)
self.weight.setSizePolicy(size_policy)
layout2.addWidget(self.weight)
layout2.setStretchFactor(self.weight, 1)
self.labels = QLabel(self)
self.labels.setFont(QFont("Monospace", 8))
size_policy = self.labels.sizePolicy()
size_policy.setVerticalPolicy(QSizePolicy.Ignored)
self.labels.setSizePolicy(size_policy)
layout2.addWidget(self.labels)
layout2.setStretchFactor(self.labels, 8)
layout.addLayout(layout2)
layout.setStretchFactor(layout2, 1)
self.line_edit.textChanged.connect(self.on_text_changed)
self.list_widget.itemDoubleClicked.connect(self.on_item_double_clicked)
self.event_selected_command = Event()
def show_hide(self, context):
if self.isVisible() == False or context is not None:
self.command_list = self.parent.get_command_list(context)
self.filter_commands("")
self.show()
else:
self.hide()
def showEvent(self, event):
geom = self.frameGeometry()
self.line_edit.setFocus()
self.line_edit.clear()
#parent_widget = self.parentWidget()
if self.parent:
geom.moveCenter(QtCore.QPoint(self.parent.pos().x()+self.parent.width()/2,
self.parent.pos().y()+self.parent.height()/3))
self.setGeometry(geom)
super(QFrame, self).showEvent(event)
def _get_command_from_text(self, text):
for command_text, tags, weight, command in self.command_list:
if command_text == text:
return command
return None
def _get_full_command_from_text(self, text):
for command_text, tags, weight, command in self.command_list:
if command_text == text:
return (command_text, tags, weight, command)
return None
def keyPressEvent(self, event):
if event.type() == QEvent.KeyPress:
key_event = QKeyEvent(event)
if(key_event.key() == Qt.Key_Down
or key_event.key() == Qt.Key_Up):
return self.list_widget.keyPressEvent(event)
elif((event.key() == Qt.Key_Enter or event.key() == Qt.Key_Return)
and self.list_widget.currentItem()>=0):
self.hide()
self.event_selected_command(str(self.full_command.toPlainText()))
return super(CommandWindow, self).keyPressEvent(event)
def on_item_double_clicked(self, item):
self.hide()
self.event_selected_command(str(self.full_command.toPlainText()))
def on_current_item_changed(self, prev, current):
if(self.list_widget.currentItem()):
command_text, tags, weight, command = self._get_full_command_from_text(
self.list_widget.currentItem().text())
self.full_command.setPlainText(command)
self.labels.setText(tags)
self.weight.setText(str(weight))
else:
self.full_command.setPlainText("")
self.labels.setText("")
self.weight.setText("")
def filter_commands(self, text):
self.list_widget.clear()
text = str(text).upper()
def get_item_map_def0(_map, key):
if(key in _map):
return _map[key]
else:
return 0.
def get_command_matches(command_list, words):
result_map = {}
for command, tags, _, _ in command_list:
for word in words:
located_command_weight = 1
located_tag_weight = 0.3
if word == '':
located_command_weight = 0.
located_tag_weight = 0.
if command.upper().find(word) != -1:
result_map[command] = (get_item_map_def0(result_map,
command)
- located_command_weight)
for tag in tags.split(" "):
if tag.upper().find(word) != -1:
result_map[command] = (get_item_map_def0(result_map,
command)
- located_tag_weight)
for command, _, current_weight, _ in command_list:
if command in result_map:
result_map[command] -= current_weight
return sorted(result_map, key=result_map.get)
words = str(text).strip().split(" ")
matches_map = get_command_matches(self.command_list, words)
for command in matches_map:
self.list_widget.addItem(command)
self.list_widget.setCurrentRow(0)
def on_text_changed(self, text):
self.filter_commands(text)
class previewDlg(QMainWindow):
'''
classdocs
'''
def __init__(self, parent, comp, basePMCheck, model):
'''
Constructor
'''
QMainWindow.__init__(self, parent)
self.basePMCheck = basePMCheck
# self.ui = Ui_Previewself.grbPageProperty()
# self.ui.setupUi(self)
self.resize(1000, 700)
self.setWindowTitle("Preview Dialog")
self.view = QgsComposerView(self)
viewLayout = QGridLayout()
viewLayout.setSpacing(0)
viewLayout.setMargin(0)
mHorizontalRuler = QgsComposerRuler(QgsComposerRuler.Horizontal)
mVerticalRuler = QgsComposerRuler(QgsComposerRuler.Vertical)
mRulerLayoutFix = QWidget()
mRulerLayoutFix.setAttribute(Qt.WA_NoMousePropagation)
mRulerLayoutFix.setBackgroundRole(QPalette.Window)
mRulerLayoutFix.setFixedSize(mVerticalRuler.rulerSize(),
mHorizontalRuler.rulerSize())
viewLayout.addWidget(mRulerLayoutFix, 0, 0)
viewLayout.addWidget(mHorizontalRuler, 0, 1)
viewLayout.addWidget(mVerticalRuler, 1, 0)
self.view.setContentsMargins(0, 0, 0, 0)
self.view.setHorizontalRuler(mHorizontalRuler)
self.view.setVerticalRuler(mVerticalRuler)
viewLayout.addWidget(self.view, 1, 1)
# self.scene = comp
self.view.setZoomLevel(1.0)
self.view.setComposition(comp)
self.scene = self.view.composition()
layout = QVBoxLayout()
hLayout = QHBoxLayout()
hLayout.addLayout(viewLayout)
self.mapItem = self.scene.getComposerMapById(0)
self.view.scale(2.8, 2.8)
self.view.setPreviewModeEnabled(True)
self.toolBarAction = self.addToolBar("composer action")
self.actionMapRefresh = QAction(self)
self.actionMapRefresh.setObjectName("actionMapRefresh")
icon3 = QIcon("Resource/Refresh.png")
self.actionMapRefresh.setIcon(icon3)
self.actionMapRefresh.setToolTip("Refresh")
# self.textItemAction.setCheckable(True)
self.connect(self.actionMapRefresh, SIGNAL("triggered()"),
self.actionMapRefresh_triggered)
self.toolBarAction.addAction(self.actionMapRefresh)
# # self.templeteCreateAction = QAction(self)
# # self.templeteCreateAction.setObjectName("createTempleteAction")
# # icon4 = QIcon("Resource\\templetepointer.png")
# # self.templeteCreateAction.setIcon(icon4)
# # self.templeteCreateAction.setToolTip("Create Templete")
# # self.templeteCreateAction.setCheckable(True)
# # self.connect(self.templeteCreateAction, SIGNAL("triggered()"), self.createTempleteAction)
# # self.toolBar.addAction(self.templeteCreateAction)
# layout.insertWidget(0, self.toolBar)
# self.scene.selectedItemChanged.connect(self.selectedItemDisplay)
self.view.selectedItemChanged.connect(self.selectedItemDisplay)
self.view.cursorPosChanged.connect(self.cursorPosChangedEvent)
# self.connect(self.view, SIGNAL("selectedItemChanged(QgsComposerItem)"),self, SLOT("selectedItemDisplay(QgsComposerItem)"))
# self.scene.composerLabelAdded.connect(self.composerLabelAddedEvent)
self.view.itemRemoved.connect(self.deleteItem)
# self.connect( self.view, SIGNAL( "actionFinished()" ), self.setSelectionTool)
#listen out for position updates from the QgsComposerView
self.propertyWidget = QWidget(self)
hLayout.addWidget(self.propertyWidget)
self.propertyWidget.setObjectName("propertyWidget")
self.propertyWidget.resize(222, 302)
self.vLayout_3 = QVBoxLayout(self.propertyWidget)
self.vLayout_3.setObjectName("vLayout_3")
self.groupBox = QGroupBox(self.propertyWidget)
self.groupBox.setObjectName("groupBox")
self.horizontalLayout_2 = QHBoxLayout(self.groupBox)
self.horizontalLayout_2.setObjectName("horizontalLayout_2")
self.frame = QFrame(self.groupBox)
self.frame.setFrameShape(QFrame.StyledPanel)
self.frame.setFrameShadow(QFrame.Raised)
self.frame.setObjectName("frame")
self.verticalLayout = QVBoxLayout(self.frame)
self.verticalLayout.setObjectName("verticalLayout")
self.label = QLabel(self.frame)
self.label.setObjectName("label")
self.verticalLayout.addWidget(self.label)
self.labelText = QPlainTextEdit(self.frame)
self.labelText.setObjectName("labelText")
self.verticalLayout.addWidget(self.labelText)
self.btnLabelFont = QPushButton(self.frame)
self.btnLabelFont.setObjectName("btnLabelFont")
self.verticalLayout.addWidget(self.btnLabelFont)
self.btnLabelColor = QPushButton(self.frame)
self.btnLabelColor.setObjectName("btnLabelColor")
self.verticalLayout.addWidget(self.btnLabelColor)
self.frame_2 = QFrame(self.frame)
self.frame_2.setFrameShape(QFrame.StyledPanel)
self.frame_2.setFrameShadow(QFrame.Raised)
self.frame_2.setObjectName("frame_2")
self.horizontalLayout = QHBoxLayout(self.frame_2)
self.horizontalLayout.setObjectName("horizontalLayout")
self.label_2 = QLabel(self.frame_2)
self.label_2.setObjectName("label_2")
self.horizontalLayout.addWidget(self.label_2)
self.spinLabelRotation = QSpinBox(self.frame_2)
self.spinLabelRotation.setObjectName("spinLabelRotation")
self.spinLabelRotation.setMinimum(-360)
self.spinLabelRotation.setMaximum(360)
self.horizontalLayout.addWidget(self.spinLabelRotation)
self.verticalLayout.addWidget(self.frame_2)
self.chbBackgroundEnable = QCheckBox(self.frame)
self.chbBackgroundEnable.setChecked(True)
self.chbBackgroundEnable.setObjectName("chbBackgroundEnable")
self.verticalLayout.addWidget(self.chbBackgroundEnable)
self.horizontalLayout_2.addWidget(self.frame)
self.vLayout_3.addWidget(self.groupBox)
self.resolutionFrame = QFrame(self.frame)
self.resolutionFrame.setFrameShape(QFrame.StyledPanel)
self.resolutionFrame.setFrameShadow(QFrame.Raised)
self.resolutionFrame.setObjectName("resolutionFrame")
self.horizontalLayout4 = QHBoxLayout(self.resolutionFrame)
self.horizontalLayout4.setObjectName("horizontalLayout4")
self.label_resolution = QLabel(self.resolutionFrame)
self.label_resolution.setObjectName("label_resolution")
self.label_resolution.setText("Print Resolution (dpi):")
self.horizontalLayout4.addWidget(self.label_resolution)
self.spinResolution = QSpinBox(self.resolutionFrame)
self.spinResolution.setObjectName("spinResolution")
self.spinResolution.setMinimum(0)
self.spinResolution.setMaximum(1000)
self.spinResolution.setValue(300)
self.horizontalLayout4.addWidget(self.spinResolution)
# self.verticalLayout.addWidget(self.frame_2)
self.vLayout_3.addWidget(self.resolutionFrame)
self.gbTable = GroupBox(self.propertyWidget)
self.gbTable.Caption = "Table"
self.vLayout_3.addWidget(self.gbTable)
self.mTableView = QTableView(self.gbTable)
self.gbTable.Add = self.mTableView
hHeder = self.mTableView.horizontalHeader()
hHeder.setVisible(False)
vHeder = self.mTableView.verticalHeader()
vHeder.setVisible(False)
# self.mTableView.setFixedHeight(70)
# self.mTableView.setFixedWidth(comp.paperWidth() - 40)
# self.stdItemModel = QStandardItemModel()
# self.
self.spaceItem = QSpacerItem(20, 40, QSizePolicy.Minimum,
QSizePolicy.Expanding)
self.vLayout_3.addItem(self.spaceItem)
self.groupBox.setTitle("Label Property")
self.label.setText("Label Text:")
self.btnLabelFont.setText("Label Font")
self.btnLabelColor.setText("Label Color")
self.label_2.setText("Label Rotation:")
self.chbBackgroundEnable.setText("Background Enable")
self.groupBox.setEnabled(False)
self.connect(self.btnLabelFont, SIGNAL("clicked()"),
self.btnLabelFontClick)
self.connect(self.btnLabelColor, SIGNAL("clicked()"),
self.btnLabelColorClick)
self.connect(self.chbBackgroundEnable, SIGNAL("clicked()"),
self.chbBackgroundEnableClick)
self.labelText.textChanged.connect(self.labelTextChanged)
self.spinLabelRotation.valueChanged.connect(
self.spinLabelRotationValueChanged)
layout.addLayout(hLayout)
#
self.btnBack = QPushButton()
self.btnBack.setText("back")
footerLayout = QHBoxLayout()
footerLayout.addWidget(self.btnBack)
self.buttonBox = QDialogButtonBox(self)
self.buttonBox.setOrientation(Qt.Horizontal)
self.buttonBox.setStandardButtons(QDialogButtonBox.Cancel
| QDialogButtonBox.Ok)
self.buttonBox.setObjectName("buttonBox")
footerLayout.addWidget(self.buttonBox)
layout.addLayout(footerLayout)
self.setLayout(layout)
deleteItemKey = QShortcut(QKeySequence(Qt.Key_Delete), self)
deleteItemKey.activated.connect(self.deleteItem)
# self.btnBack.clicked.connect(self.back)
self.connect(self.buttonBox, SIGNAL("accepted()"), self.acceptMethod)
self.connect(self.buttonBox, SIGNAL("rejected()"), self.reject)
self.btnCancel = self.buttonBox.button(QDialogButtonBox.Cancel)
self.view.setCurrentTool(QgsComposerView.Select)
self.btnLabelColor.setVisible(False)
# self.btnBack.setVisible(False)
self.chbBackgroundEnable.setVisible(False)
# self.view.emit(SIGNAL("actionFinished"))
# if self.scene.plotStyle() != QgsComposition.Preview:
# self.scene.setPlotStyle(QgsComposition.Preview)
# self.mapItem.setPreviewMode(QgsComposerMap.Render)
# self.mapItem.updateCachedImage()
# self.mapItem.setSelected(True)
self.mComposition = comp
self.composerMapItem = self.mComposition.composerMapItems()[0]
self.composerMapItem.setUpdatesEnabled(True)
self.mStdModel = model
self.mTableView.setModel(self.mStdModel)
self.mTableView.setSpan(0, 0, 1, 6)
self.mTableView.setSpan(1, 0, 1, 2)
self.mTableView.setSpan(2, 0, 2, 1)
self.mTableView.setSpan(4, 0, 1, 2)
self.mTableView.setSpan(5, 0, 1, 2)
self.mTableView.setSpan(6, 0, 1, 2)
self.mTableView.setSpan(0, 6, 1, 8)
self.mTableView.setSpan(1, 7, 1, 4)
self.mTableView.setSpan(1, 11, 1, 3)
self.mTableView.setSpan(2, 7, 1, 4)
self.mTableView.setSpan(2, 11, 1, 3)
def acceptMethod(self):
# self.mStdModel.setItem(0, QStandardItem("nnnnnnnn"))
filePath = QFileDialog.getSaveFileName(
self, "Save PDF File", QCoreApplication.applicationDirPath(),
"pdf files(*.pdf )")
if filePath == "":
return
self.mComposition.clearSelection()
self.mComposition.setPrintResolution(self.spinResolution.value())
resultPdf = self.mComposition.exportAsPDF(filePath)
if resultPdf:
message = QMessageBox.information(self, "Result",
"Successful export PDF")
else:
message = QMessageBox.information(self, "Result",
"Don't export PDF")
def rePresent(self, comp, model):
self.mComposition = comp
self.mStdModel = model
self.view.setComposition(comp)
self.scene = self.view.composition()
def back(self):
self.done(2)
def spinLabelRotationValueChanged(self, rotationValue):
self.selectedLabelItem.setItemRotation(rotationValue)
def cursorPosChangedEvent(self, scenePointF):
self.scenePoint = scenePointF
# i = 100
def labelTextChanged(self):
self.selectedLabelItem.beginCommand(
"Label text changed", QgsComposerMergeCommand.ComposerLabelSetText)
self.selectedLabelItem.blockSignals(True)
self.selectedLabelItem.setText(self.labelText.toPlainText())
self.selectedLabelItem.update()
self.selectedLabelItem.blockSignals(False)
self.selectedLabelItem.endCommand()
def chbBackgroundEnableClick(self):
if self.chbBackgroundEnable.isChecked():
self.selectedLabelItem.setBackgroundEnabled(True)
self.mapItem.updateCachedImage()
else:
self.selectedLabelItem.setBackgroundEnabled(False)
self.mapItem.updateCachedImage()
def btnLabelFontClick(self):
dlgFont = QFontDialog(self)
dlgFont.setCurrentFont(self.selectedLabelItem.font())
result = dlgFont.exec_()
if result == 1:
self.labelFont = dlgFont.selectedFont()
else:
self.labelFont = QFont()
self.selectedLabelItem.setFont(self.labelFont)
def btnLabelColorClick(self):
dlgColor = QColorDialog(self)
dlgColor.setCurrentColor(self.selectedLabelItem.fontColor())
result = dlgColor.exec_()
if result == 1:
self.labelColor = dlgColor.selectedColor()
self.selectedLabelItem.setFontColor(self.labelColor)
def createTempleteAction(self):
if self.templeteCreateAction.isChecked() and self.basePMCheck:
font = QFont("Arial", 13)
font.setItalic(True)
self.compLabel1 = QgsComposerLabel(self.scene)
self.compLabel1.setFont(font)
self.compLabel1.setText("South China Sea")
self.compLabel1.setBackgroundEnabled(False)
self.compLabel1.setItemPosition(156, 100)
self.compLabel1.adjustSizeToText()
self.compLabel1.setItemRotation(60)
# mapitem = self.scene.composerMapItems()
# mapitem[0].addItem(self.compLabel1)
self.scene.addItem(self.compLabel1)
self.compLabel2 = QgsComposerLabel(self.scene)
self.compLabel2.setFont(font)
self.compLabel2.setText("Straits Of Malacca")
self.compLabel2.setBackgroundEnabled(False)
self.compLabel2.setItemPosition(35, 100)
self.compLabel2.adjustSizeToText()
self.compLabel2.setItemRotation(60)
self.scene.addItem(self.compLabel2)
font.setItalic(False)
self.compLabel3 = QgsComposerLabel(self.scene)
self.compLabel3.setFont(font)
self.compLabel3.setBackgroundEnabled(False)
self.compLabel3.setText("THAILAND")
self.compLabel3.setItemPosition(68, 60)
self.compLabel3.adjustSizeToText()
# self.compLabel3.setItemRotation(0.5)
self.scene.addItem(self.compLabel3)
# self.templeteCreateAction.setChecked(False)
self.compLabel4 = QgsComposerLabel(self.scene)
self.compLabel4.setFont(font)
self.compLabel4.setBackgroundEnabled(False)
self.compLabel4.setText("SINGAPORE")
self.compLabel4.setItemPosition(141, 218)
self.compLabel4.adjustSizeToText()
# self.compLabel3.setItemRotation(0.5)
self.scene.addItem(self.compLabel4)
self.templeteCreateAction.setChecked(False)
self.compLabel4.setSelected(True)
elif self.templeteCreateAction.isChecked(
) and self.basePMCheck == False:
font = QFont("Arial", 14)
font.setItalic(True)
self.compLabel5 = QgsComposerLabel(self.scene)
self.compLabel5.setFont(font)
self.compLabel5.setText("South China Sea")
self.compLabel5.setBackgroundEnabled(False)
self.compLabel5.setItemPosition(108, 86)
self.compLabel5.adjustSizeToText()
self.compLabel5.setItemRotation(-45)
# mapitem = self.scene.composerMapItems()
# mapitem[0].addItem(self.compLabel1)
self.scene.addItem(self.compLabel5)
self.compLabel6 = QgsComposerLabel(self.scene)
self.compLabel6.setFont(font)
self.compLabel6.setText("Sulu Sea")
self.compLabel6.setBackgroundEnabled(False)
self.compLabel6.setItemPosition(236, 38)
self.compLabel6.adjustSizeToText()
self.compLabel6.setItemRotation(45)
self.scene.addItem(self.compLabel6)
font.setItalic(False)
self.compLabel7 = QgsComposerLabel(self.scene)
self.compLabel7.setFont(font)
self.compLabel7.setBackgroundEnabled(False)
self.compLabel7.setText("Celebes Sea")
self.compLabel7.setItemPosition(242, 112)
self.compLabel7.adjustSizeToText()
self.compLabel7.setItemRotation(-45)
# self.compLabel3.setItemRotation(0.5)
self.scene.addItem(self.compLabel7)
# self.templeteCreateAction.setChecked(False)
self.compLabel8 = QgsComposerLabel(self.scene)
self.compLabel8.setFont(font)
self.compLabel8.setBackgroundEnabled(False)
self.compLabel8.setText("INDONESIA\n(Kalimantan)")
self.compLabel8.setItemPosition(172, 148, 32, 16)
# self.compLabel8.setHAlign(Qt.AlignHCenter)
# self.compLabel8.setVAlign(Qt.AlignVCenter)
# self.compLabel8.setFrameEnabled(False)
# self.compLabel8.setItemPosition()
# self.compLabel8.adjustSizeToText()
# self.compLabl3.setItemRotation(0.5)
self.scene.addItem(self.compLabel8)
self.compLabel9 = QgsComposerLabel(self.scene)
self.compLabel9.setFont(font)
self.compLabel9.setBackgroundEnabled(False)
self.compLabel9.setText("BRUNEI")
self.compLabel9.setItemPosition(136, 83)
self.compLabel9.adjustSizeToText()
# self.compLabl3.setItemRotation(0.5)
self.scene.addItem(self.compLabel9)
self.templeteCreateAction.setChecked(False)
pass
def actionMapRefresh_triggered(self):
self.view.setCurrentTool(QgsComposerView.AddRectangle)
def setSelectionTool(self):
self.view.deleteSelectedItems()
font = QFont("Arial", 14)
newLabelItem = QgsComposerLabel(self.scene)
newLabelItem.setText("QGIS")
newLabelItem.setFont(font)
newLabelItem.setItemPosition(self.scenePoint.x(), self.scenePoint.y())
newLabelItem.adjustSizeToText()
self.scene.addItem(newLabelItem)
# selectItemPoint = self.scene.composerItemAt(self.scenePoint)
newLabelItem.setSelected(True)
self.groupBox.setEnabled(True)
self.selectedLabelItem = newLabelItem
# txt = self.selectedLabelItem.text()
# textDoc = QTextDocument(txt)
self.labelText.setPlainText(self.selectedLabelItem.text())
# self.scene.setSelectedItem(self.newLabelItem)
self.view.setCurrentTool(QgsComposerView.Select)
# self.selectedLabelItem = self.view.currentTool()
self.textItemAction.setChecked(False)
def selectedItemDisplay(self, item):
if self.scene.plotStyle() != QgsComposition.Preview:
self.scene.setPlotStyle(QgsComposition.Preview)
self.mapItem.setPreviewMode(QgsComposerMap.Render)
self.mapItem.updateCachedImage()
item._class_ = QgsComposerLabel
# selectedItems = self.scene.selectedComposerItems(True)
# if isinstance(item, QgsComposerItem):
# self.selectedLabelItem = item
# if isinstance(item, QGraphicsRectItem):
# self.selectedLabelItem = item
if isinstance(item, QgsComposerLabel):
self.selectedLabelItem = item
self.groupBox.setEnabled(True)
self.labelText.setPlainText(self.selectedLabelItem.text())
self.spinLabelRotation.setValue(self.selectedLabelItem.rotation())
else:
self.groupBox.setEnabled(False)
# print "debug"
itemName = self.view.currentTool()
if itemName == 5:
item.setText("label")
pass
def deleteItem(self):
self.view.deleteSelectedItems()
class SkinsTab(QWidget):
def __init__(self):
QWidget.__init__(self)
vbox = QVBoxLayout(self)
#Top Bar
hbox = QHBoxLayout()
self.radioDefault = QRadioButton("Default Skin")
self.radioCustom = QRadioButton("Custom")
self.comboSkins = QComboBox()
self.skins = loader.load_gui_skins()
for item in self.skins:
self.comboSkins.addItem(item)
hbox.addWidget(self.radioDefault)
hbox.addWidget(self.radioCustom)
hbox.addWidget(self.comboSkins)
#Text Area
self.txtStyle = QPlainTextEdit()
self.txtStyle.setReadOnly(True)
#Settings
settings = QSettings()
settings.beginGroup('preferences')
settings.beginGroup('skins')
if settings.value('default', True).toBool():
self.radioDefault.setChecked(True)
self.comboSkins.setEnabled(False)
else:
self.radioCustom.setChecked(True)
index = self.comboSkins.findText(settings.value('selectedSkin', '').toString())
self.comboSkins.setCurrentIndex(index)
content = self.skins[str(self.comboSkins.currentText())]
self.txtStyle.setPlainText(content)
settings.endGroup()
settings.endGroup()
vbox.addLayout(hbox)
vbox.addWidget(self.txtStyle)
vbox.addWidget(QLabel('Requires restart the IDE'))
#Signals
self.connect(self.radioDefault, SIGNAL("clicked()"), self._default_clicked)
self.connect(self.radioCustom, SIGNAL("clicked()"), self._custom_clicked)
def _default_clicked(self):
self.comboSkins.setEnabled(False)
self.txtStyle.setPlainText('')
def _custom_clicked(self):
self.comboSkins.setEnabled(True)
content = self.skins[str(self.comboSkins.currentText())]
self.txtStyle.setPlainText(content)
def save(self):
settings = QSettings()
settings.beginGroup('preferences')
settings.beginGroup('skins')
settings.setValue('default', self.radioDefault.isChecked())
settings.setValue('selectedSkin', self.comboSkins.currentText())
settings.endGroup()
settings.endGroup()
class ProjectExecution(QWidget):
def __init__(self, parent):
super(ProjectExecution, self).__init__()
self._parent = parent
grid = QGridLayout(self)
grid.addWidget(QLabel(translations.TR_PROJECT_MAIN_FILE), 0, 0)
self.path = QLineEdit()
self.path.setPlaceholderText(
os.path.join(os.path.expanduser("~"), 'path', 'to', 'main.py'))
ui_tools.LineEditButton(self.path, self.path.clear,
self.style().standardPixmap(self.style().SP_TrashIcon))
self.path.setText(self._parent.project.main_file)
self.path.setReadOnly(True)
self.btnBrowse = QPushButton(QIcon(
self.style().standardPixmap(self.style().SP_FileIcon)), '')
grid.addWidget(self.path, 0, 1)
grid.addWidget(self.btnBrowse, 0, 2)
# this should be changed, and ALL pythonPath names to
# python_custom_interpreter or something like that. this is NOT the
# PYTHONPATH
self.txtPythonInterpreter = QLineEdit()
self.txtPythonInterpreter.setText(self._parent.project.python_exec)
self.txtPythonInterpreter.setCompleter(QCompleter(('python', 'python2',
'python3', 'python.exe', 'pythonw.exe')))
self.btnPythonPath = QPushButton(QIcon(":img/open"), '')
grid.addWidget(QLabel(
translations.TR_PROJECT_PYTHON_INTERPRETER), 1, 0)
grid.addWidget(self.txtPythonInterpreter, 1, 1)
grid.addWidget(self.btnPythonPath, 1, 2)
grid.addWidget(QLabel(translations.TR_PROJECT_PYTHON_PATH), 2, 0)
self.txtPythonPath = QPlainTextEdit() # TODO : better widget
self.txtPythonPath.setPlainText(self._parent.project.python_path)
self.txtPythonPath.setToolTip(translations.TR_PROJECT_PATH_PER_LINE)
grid.addWidget(self.txtPythonPath, 2, 1)
# Additional builtins/globals for pyflakes
grid.addWidget(QLabel(translations.TR_PROJECT_BUILTINS), 3, 0)
self.additional_builtins = QLineEdit()
self.additional_builtins.setText(
' '.join(self._parent.project.additional_builtins))
self.additional_builtins.setToolTip(
translations.TR_PROJECT_BUILTINS_TOOLTIP)
grid.addWidget(self.additional_builtins, 3, 1)
self.txtPreExec = QLineEdit()
ui_tools.LineEditButton(self.txtPreExec, self.txtPreExec.clear,
self.style().standardPixmap(self.style().SP_TrashIcon))
self.txtPreExec.setReadOnly(True)
self.txtPreExec.setText(self._parent.project.pre_exec_script)
self.txtPreExec.setPlaceholderText(
os.path.join(os.path.expanduser("~"), 'path', 'to', 'script.sh'))
self.btnPreExec = QPushButton(QIcon(":img/open"), '')
grid.addWidget(QLabel(translations.TR_PROJECT_PRE_EXEC), 4, 0)
grid.addWidget(self.txtPreExec, 4, 1)
grid.addWidget(self.btnPreExec, 4, 2)
self.txtPostExec = QLineEdit()
ui_tools.LineEditButton(self.txtPostExec, self.txtPostExec.clear,
self.style().standardPixmap(self.style().SP_TrashIcon))
self.txtPostExec.setReadOnly(True)
self.txtPostExec.setText(self._parent.project.post_exec_script)
self.txtPostExec.setPlaceholderText(
os.path.join(os.path.expanduser("~"), 'path', 'to', 'script.sh'))
self.btnPostExec = QPushButton(QIcon(":img/open"), '')
grid.addWidget(QLabel(translations.TR_PROJECT_POST_EXEC), 5, 0)
grid.addWidget(self.txtPostExec, 5, 1)
grid.addWidget(self.btnPostExec, 5, 2)
grid.addItem(QSpacerItem(5, 10, QSizePolicy.Expanding,
QSizePolicy.Expanding), 6, 0)
# Properties
grid.addWidget(QLabel(translations.TR_PROJECT_PROPERTIES), 7, 0)
self.txtParams = QLineEdit()
self.txtParams.setToolTip(translations.TR_PROJECT_PARAMS_TOOLTIP)
self.txtParams.setText(self._parent.project.program_params)
self.txtParams.setPlaceholderText('verbose, debug, force')
grid.addWidget(QLabel(translations.TR_PROJECT_PARAMS), 8, 0)
grid.addWidget(self.txtParams, 8, 1)
#Widgets for virtualenv properties
self.txtVenvPath = QLineEdit()
ui_tools.LineEditButton(self.txtVenvPath, self.txtVenvPath.clear,
self.style().standardPixmap(self.style().SP_TrashIcon))
self.txtVenvPath.setText(self._parent.project.venv)
self._dir_completer = QCompleter()
self._dir_completer.setModel(QDirModel(self._dir_completer))
self.txtVenvPath.setCompleter(self._dir_completer)
self.txtVenvPath.setPlaceholderText(
os.path.join(os.path.expanduser("~"), 'path', 'to', 'virtualenv'))
self.btnVenvPath = QPushButton(QIcon(":img/open"), '')
grid.addWidget(QLabel(translations.TR_PROJECT_VIRTUALENV), 9, 0)
grid.addWidget(self.txtVenvPath, 9, 1)
grid.addWidget(self.btnVenvPath, 9, 2)
self.connect(self.btnBrowse, SIGNAL("clicked()"), self.select_file)
self.connect(self.btnPythonPath, SIGNAL("clicked()"),
self._load_python_path)
self.connect(self.btnVenvPath, SIGNAL("clicked()"),
self._load_python_venv)
self.connect(self.btnPreExec, SIGNAL("clicked()"),
self.select_pre_exec_script)
self.connect(self.btnPostExec, SIGNAL("clicked()"),
self.select_post_exec_script)
def _load_python_path(self):
path = QFileDialog.getOpenFileName(
translations.TR_PROJECT_SELECT_PYTHON_PATH)
self.txtPythonInterpreter.setText(path)
def _load_python_venv(self):
venv = QFileDialog.getExistingDirectory(
translations.TR_PROJECT_SELECT_VIRTUALENV)
if sys.platform == 'win32':
venv = os.path.join(venv, 'Scripts', 'python.exe')
else:
venv = os.path.join(venv, 'bin', 'python')
#check if venv folder exists
if not os.path.exists(venv):
QMessageBox.information(self,
translations.TR_PROJECT_SELECT_VIRTUALENV_MESSAGE_TITLE,
translations.TR_PROJECT_SELECT_VIRTUALENV_MESSAGE_BODY)
self.txtVenvPath.setText("")
else:
self.txtVenvPath.setText(venv)
def select_file(self):
fileName = QFileDialog.getOpenFileName(
self, translations.TR_PROJECT_SELECT_MAIN_FILE,
self._parent.project.path, 'PY(*.py);;*(*.*)')
if fileName != '':
fileName = file_manager.convert_to_relative(
self._parent.project.path, fileName)
self.path.setText(fileName)
def select_pre_exec_script(self):
fileName = QFileDialog.getOpenFileName(
self, translations.TR_PROJECT_SELECT_PRE_SCRIPT,
self._parent.project.path, '(*.*)')
if fileName != '':
fileName = file_manager.convert_to_relative(
self._parent.project.path, fileName)
self.txtPreExec.setText(fileName)
def select_post_exec_script(self):
fileName = QFileDialog.getOpenFileName(
self, translations.TR_PROJECT_SELECT_POST_SCRIPT,
self._parent.project.path, '(*.*)')
if fileName != '':
fileName = file_manager.convert_to_relative(
self._parent.project.path, fileName)
self.txtPostExec.setText(fileName)
class MainPage(QWidget):
"""
"""
def __init__(self, parent):
"""
"""
super(MainPage, self).__init__()
self.__core = parent
if DEBUGMODE: self.core().debug().addLogWarning("Debug mode activated")
self.createWidget()
def core(self):
"""
"""
return self.__core
def createWidget(self):
"""
"""
self.inDataEdit = QPlainTextEdit()
exportButton = QPushButton("&Import")
exportButton.clicked.connect(self.onImport)
createTsLayout = QHBoxLayout()
createTsLayout.addWidget(exportButton)
mainLayout = QVBoxLayout()
mainLayout.addWidget(QLabel("Imported/Exported json data: "))
mainLayout.addWidget(self.inDataEdit)
mainLayout.addLayout(createTsLayout)
self.setLayout(mainLayout)
def onReloadSettings(self):
"""
Called by the core when settings are updated
"""
pass
def insertData(self, data):
"""
Called by the core when new data are received
"""
self.core().debug().addLogSuccess( "new data received: %s" % data)
self.inDataEdit.setPlainText( "%s" % data)
def onImport(self):
"""
Export data
"""
self.core().debug().addLogSuccess( "exporting data" )
# import selenium example
# {
# "steps": [
# { "action-name": "OPEN BROWSER", "action-description": "", "action-params": "", "action-value": "https://www.google.fr"},
# { "action-name": "CLICK ELEMENT", "action-description": "", "action-params": "id=test", "action-value": ""}
# ]
# }
# import sikuli example
# {
# "steps": [
# { "action-name": "CLICK ON", "action-description": "", "image-base64": "iVBORw0KGgoAAAANSUhEUgAAAEgAAAAYCAIAAADWASznAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAASdEVYdFNvZnR3YXJlAEdyZWVuc2hvdF5VCAUAAAK9SURBVFhH3Zhda9NQGMdPk9565Y1XCvsOBkREEEEZCjIYjslATFDxZggKo+CFnyAbG2MX+hn2wpbdbrdt19LKKoTaObRpN0JWF/uWtjk+T3LSppkbZVCxefhdPOd/npfzH11hI1TdpZ+m6dwN+jo62oAFMKLu5vP5XC5HaGwsWDHSxMZs285mMsR+FQ0Z9POMruuk8zIaNmavWpZF2lI0fFBKifUiGj7QWPM5Hz7QWH2G/2c0t1VYaW8LAd1B6sAdVaygfhnQWPUZ/38gtR1jzaB+GdCYOcX3WFFwuBsludpVSqrz4/TEmIxHyPFWafy1cYpvpJngRnvFK0tLgdvOltBfrDQGWXG2xgNkUpnkGXNY19kUMF/GKZg7CdVkc5KvpTBtLbNKqrluldoFjSkJxF6jJ5qb+JlkLQyphXdKzT0OsiJQw+YgcCbGBOfyawOX9cWeaCw5T4FkgqvuYWotccZ7ZyJVquc39or9jd40f0tnQ3AeIFp4YjMHWRGo8QMq0Z9wLpV1bG6vC10FWXSekhQhN5OYNhc5/Z2Mvw+aXDm/sVfsz33TWO4GKmITM8V0JwywIlDjB2Ry/JhjLLiblNOu0hUTIuSnCUybC9zxW2diUTb8Nf2NxprzlDWhr9E3jeGOQoUZY0MGWBGs8QEyKY1zPWadUi/aq0Jp3pkYF+G2Ese0Me+VFWX9gsZx4XeRHd3ARm+avur7aHlzfKJSGWTF2RoPkEnxQWTI3DR/wqKtk6A+RNDYj/uR4SDWYTwL1XwTuB0usJIc3ouEDzR2cDcSMg4fXmm1WuTbnUjIOPo4jX9ofp+4nr9NQgPYsW07k8mQWmqn9OFp4dE19RYZacACGAE77J85X7LZcrlcr/u+w0YzwAIYATtfczlN08hBoZDb30+nUslEIhEfyYBnw+PBAhgBO0fl8olh/AEFAxxb9lhHWwAAAABJRU5ErkJggg==", "opt-c": "0.6" }
# ]
# }
# import remote-tests
# supported file PY_EXT, PNG_EXT, TXT_EXT, TEST_UNIT_EXT, TEST_SUITE_EXT, TEST_PLAN_EXT, TEST_GLOBAL_EXT, TEST_CONFIG_EXT, TEST_DATA_EXT
# content must be encoded in base 64
# {
# "files": [
# { "file-path": "/A/B/test.tux", "content-file": "SGVsbG8gd29ybGQuIEJvbmpvdXIgw6Agdm91cyE="}
# ]
# }
jsonStr = self.inDataEdit.toPlainText()
try:
jsonObj = json.loads(jsonStr)
except Exception as e:
QMessageBox.warning(self, "Plugin %s" % Settings.instance().readValue( key = 'Plugin/name' ), "Bad json message!" )
if not DEBUGMODE:
self.core().sendMessage( cmd='import', data = jsonObj )
self.core().hide()
class OWTextableTextField(OWTextableBaseWidget):
"""Orange widget for typing text data"""
name = "Text Field"
description = "Import text data from keyboard input"
icon = "icons/TextField.png"
priority = 1
# Input and output channels...
inputs = [('Text data', Segmentation, "inputTextData", widget.Single)]
outputs = [('Text data', Segmentation)]
settingsHandler = VersionedSettingsHandler(
version=__version__.rsplit(".", 1)[0])
# Settings ...
textFieldContent = settings.Setting(u''.encode('utf-8'))
encoding = settings.Setting(u'utf-8')
want_main_area = False
def __init__(self):
"""Initialize a Text File widget"""
super().__init__()
# Other attributes...
self.infoBox = InfoBox(widget=self.controlArea)
self.sendButton = SendButton(
widget=self.controlArea,
master=self,
callback=self.sendData,
infoBoxAttribute='infoBox',
)
# LTTL.Input object (token that will be sent).
self.segmentation = Input(text=u'')
# GUI...
# Text Field...
gui.separator(
widget=self.controlArea,
height=3,
)
self.editor = QPlainTextEdit()
self.editor.setPlainText(self.textFieldContent.decode('utf-8'))
self.controlArea.layout().addWidget(self.editor)
self.editor.textChanged.connect(self.sendButton.settingsChanged)
gui.separator(
widget=self.controlArea,
height=3,
)
self.setMinimumWidth(250)
# Send button...
self.sendButton.draw()
# Info box...
self.infoBox.draw()
self.sendButton.sendIf()
def inputTextData(self, segmentation):
"""Handle text data on input connection"""
if not segmentation:
return
self.editor.setPlainText(''.join(
[s.get_content() for s in segmentation]))
self.sendButton.settingsChanged()
def sendData(self):
"""Normalize content, then create and send segmentation"""
textFieldContent = self.editor.toPlainText()
self.textFieldContent = textFieldContent.encode('utf-8')
textFieldContent \
= textFieldContent.replace('\r\n', '\n').replace('\r', '\n')
textFieldContent = normalize('NFC', textFieldContent)
# Check that text field is not empty...
if not self.textFieldContent:
self.infoBox.setText(
message=u'Please type or paste some text above.',
state='warning',
)
self.send('Text data', None, self)
return
# TODO: remove message 'No label was provided.' from docs
# Set status to OK...
message = u'1 segment (%i character@p) sent to output.' % \
len(textFieldContent)
message = pluralize(message, len(textFieldContent))
self.infoBox.setText(message)
# Update segmentation.
self.segmentation.update(textFieldContent, label=self.captionTitle)
# Send token...
self.send('Text data', self.segmentation, self)
self.sendButton.resetSettingsChangedFlag()
def setCaption(self, title):
if 'captionTitle' in dir(self):
changed = title != self.captionTitle
super().setCaption(title)
if changed:
self.sendButton.settingsChanged()
else:
super().setCaption(title)
def onDeleteWidget(self):
self.segmentation.clear()
self.segmentation.__del__()
class OWBioMart(widget.OWWidget):
name = "BioMart"
description = "Query BioMart service"
icon = "../widgets/icons/BioMart.svg"
priority = 2010
inputs = [("Input ids", Orange.data.Table, "setData")]
outputs = [("Data", Orange.data.Table)]
SHOW_FILTERS = True
selectedDataset = settings.Setting(0)
def __init__(self, parent=None):
super().__init__(parent)
self.selectedDatabase = 0
self.idAttr = 0
self.useAttrNames = False
self.uniqueRows = True
gui.button(
gui.widgetBox(self.controlArea, "Cache", addSpace=True),
self,
"Clear cache",
tooltip="Clear saved query results",
callback=self.clearCache,
)
self.martsCombo = gui.comboBox(
self.controlArea, self, "selectedDatabase", "Database", callback=self.setSelectedMart, addSpace=True
)
self.martsCombo.setMaximumWidth(250)
self.datasetsCombo = gui.comboBox(
self.controlArea, self, "selectedDataset", "Dataset", callback=self.setSelectedDataset, addSpace=True
)
self.datasetsCombo.setMaximumWidth(250)
box = gui.widgetBox(self.controlArea, "Input Ids")
cb = gui.checkBox(
box,
self,
"useAttrNames",
"Use attribute names",
tooltip="Use attribute names for ids",
callback=self.updateInputIds,
)
self.idAttrCB = gui.comboBox(
box, self, "idAttr", tooltip="Use attribute values from ...", callback=self.updateInputIds
)
cb.disables = [(-1, self.idAttrCB)]
cb.makeConsistent()
self.idText = QPlainTextEdit()
self.idText.setReadOnly(True)
box.layout().addWidget(self.idText)
gui.rubber(self.controlArea)
box = gui.widgetBox(self.controlArea, "Results")
gui.checkBox(box, self, "uniqueRows", "Unique results only", tooltip="Return unique results only.")
self.commitButton = gui.button(
box,
self,
"Get Results",
callback=self.commit,
tooltip="Query the BioMart server and output the results",
autoDefault=True,
)
self.commitButton.setEnabled(False)
self.mainWidget = gui.widgetBox(self.mainArea, orientation=QStackedLayout())
self.mainTab = QTabWidget()
self.mainWidget.layout().addWidget(self.mainTab)
self.attributesConfigurationBox = gui.createTabPage(self.mainTab, "Attributes")
if self.SHOW_FILTERS: # ??
self.filtersConfigurationBox = gui.createTabPage(self.mainTab, "Filters")
self.error(0)
self.setEnabled(False)
self._executor = concurrent.ThreadExecutor(threadPool=QThreadPool(maxThreadCount=2))
self._task = task = concurrent.Task(function=self._get_registry)
task.resultReady.connect(self.setBioMartRegistry)
task.exceptionReady.connect(self._handleException)
self._executor.submit(task)
self.candidateIdAttrs = []
self._afterInitQueue = []
self.data = None
try:
from Bio import SeqIO
self.hasBiopython = True
except ImportError:
self.warning(
100, "Biopython package not found.\nTo retrieve FASTA sequence data from BioMart install Biopython."
)
self.hasBiopython = False
def sizeHint(self):
return QSize(800, 600)
@staticmethod
def _get_registry(url=None, precache=True):
con = biomart.BioMartConnection(url)
reg = biomart.BioMartRegistry(con)
if precache:
_ = reg.marts()
return reg
@Slot(Exception)
def _handleException(self, exception):
assert QThread.currentThread() is self.thread()
print("Task failed with:", exception, file=sys.stderr)
self.error(0, str(exception))
self.setEnabled(True)
@Slot(object)
def setBioMartRegistry(self, registry):
assert QThread.currentThread() is self.thread()
self.setEnabled(True)
self.registry = registry
self.marts = [mart for mart in self.registry.marts() if getattr(mart, "visible", "0") != "0"]
for mart in self.marts:
self.martsCombo.addItem(mart.displayName)
def setSelectedMart(self):
self.mart = self.marts[self.selectedDatabase]
self.error(0)
self.setEnabled(False)
self._task = task = concurrent.Task(function=self.mart.datasets)
task.resultReady.connect(self.setBioMartDatasets)
task.exceptionReady.connect(self._handleException)
self._executor.submit(task)
@Slot(object)
def setBioMartDatasets(self, datasets):
assert QThread.currentThread() is self.thread()
self.setEnabled(True)
self.datasets = [data for data in datasets if getattr(data, "visible", "0") != "0"]
self.datasetsCombo.clear()
self.datasetsCombo.addItems([data.displayName for data in self.datasets])
def setSelectedDataset(self):
self.dataset = self.datasets[self.selectedDataset]
self.error(0)
self.setEnabled(False)
def get_configuration(dataset):
connection = dataset.connection
stream = connection.configuration(dataset=dataset.internalName, virtualSchema=dataset.virtualSchema)
response = stream.read()
return response
self._task = task = concurrent.Task(function=partial(get_configuration, self.dataset))
task.resultReady.connect(self.setBioMartConfiguration)
task.exceptionReady.connect(self._handleException)
self._executor.submit(task)
@Slot(object)
def setBioMartConfiguration(self, configuration):
assert QThread.currentThread() is self.thread()
self.setEnabled(True)
# parse the xml in the main thread (a long time ago this step was
# done in a thread but would frequently cause `expat` to segfault.
doc = biomart.parseXML(io.BytesIO(configuration))
config = list(doc.elements("DatasetConfig"))[0]
configuration = biomart.DatasetConfig(self.registry, config.tag, config.attributes, config.children)
self.clearConfiguration()
self.configuration = configuration
def hidden(tree):
return getattr(tree, "hidden", "false") != "false" or getattr(tree, "hideDisplay", "false") != "false"
self.attributePagesTabWidget = tabs = gui.tabWidget(self.attributesConfigurationBox)
for page in configuration.elements("AttributePage"):
if not hidden(page):
page_widget = PageWidget(page, self.dataset, self)
gui.createTabPage(tabs, getattr(page, "displayName", ""), widgetToAdd=page_widget, canScroll=True)
if self.SHOW_FILTERS:
self.filterPagesTabWidget = tabs = gui.tabWidget(self.filtersConfigurationBox)
for page in configuration.elements("FilterPage"):
if not hidden(page):
page_widget = PageWidget(page, self.dataset, self)
gui.createTabPage(tabs, getattr(page, "displayName", ""), widgetToAdd=page_widget, canScroll=True)
self.afterInit()
self.commitButton.setEnabled(True)
def clearConfiguration(self):
self.mainTab.deleteLater()
self.mainTab = QTabWidget()
self.mainWidget.layout().addWidget(self.mainTab)
self.mainWidget.layout().setCurrentWidget(self.mainTab)
self.attributesConfigurationBox = gui.createTabPage(self.mainTab, "Attributes")
if self.SHOW_FILTERS:
self.filtersConfigurationBox = gui.createTabPage(self.mainTab, "Filters")
def commit(self):
pageconf = self.attributePagesTabWidget.currentWidget().widget()
format = pageconf.outFormats
self.error(100)
if not self.hasBiopython and format.lower() == "fasta":
self.error(100, "Cannot parse FASTA format")
return
query = pageconf.query()
bydatasets = defaultdict(lambda: ([], []))
for conftype, tree, val in query:
dataset = self.dataset
if conftype == "Attribute":
bydatasets[dataset][0].append(tree.internalName)
elif conftype == "Filter":
bydatasets[dataset][1].append((tree.internalName, val))
if self.SHOW_FILTERS:
pageconf = self.filterPagesTabWidget.currentWidget().widget()
query = pageconf.query()
for conftype, tree, val in query:
dataset = self.dataset
if conftype == "Attribute":
bydatasets[dataset][0].append(tree.internalName)
elif conftype == "Filter":
bydatasets[dataset][1].append((tree.internalName, val))
query = self.registry.query(
format="TSV" if "tsv" in format.lower() else format.upper(), uniqueRows=self.uniqueRows
)
for dataset, (attributes, filters) in bydatasets.items():
query.set_dataset(dataset if dataset else self.dataset)
for attr in attributes:
query.add_attribute(attr)
for filter, value in filters:
query.add_filter(filter, value)
self.error(0)
self.setEnabled(False)
self._task = task = concurrent.Task(function=query.get_table)
task.resultReady.connect(self.dataReady)
task.exceptionReady.connect(self._handleException)
self._executor.submit(task)
def dataReady(self, data):
self.setEnabled(True)
self.send("Data", data)
def pushAction(self, action):
ref = action.ref
ref_widget = self.findChild(QWidget, ref)
if hasattr(ref_widget, "setOptions"):
ref_widget.setOptions(action.subelements_top("Option"))
def registerDelayedCall(self, call):
self._afterInitQueue.append(call)
def afterInit(self):
while self._afterInitQueue:
call = self._afterInitQueue.pop(0)
call()
def setData(self, data=None):
self.candidateIdAttrs = []
self.data = data
self.idAttrCB.clear()
if data is not None:
attrs = data.domain.variables + data.domain.metas
attrs = [attr for attr in attrs if isinstance(attr, Orange.data.StringVariable)]
self.candidateIdAttrs = attrs
self.idAttrCB.addItems([attr.name for attr in attrs])
self.idAttr = min(self.idAttr, len(self.candidateIdAttrs) - 1)
self.updateInputIds()
def updateInputIds(self):
if self.data is not None:
if self.useAttrNames:
names = [attr.name for attr in self.data.domain.attributes]
elif self.candidateIdAttrs:
attr = self.candidateIdAttrs[self.idAttr]
names = [str(ex[attr]) for ex in self.data if not numpy.isnan(ex[attr])]
else:
names = []
else:
names = []
self.idText.setPlainText("\n".join(names))
def clearCache(self):
self.registry.connection.clear_cache()
