class BookView(QSplitter):
def __init__(self, parent=None):
super(BookView, self).__init__(parent=parent)
self.create_layout()
self.create_connections()
def create_layout(self):
self.web_view = QWebView()
self.chapter_list = QListWidget()
self.next_button = QPushButton("Next chapter")
self.previous_button = QPushButton("Previous chapter")
hbox = QHBoxLayout()
hbox.addStretch()
hbox.addWidget(self.previous_button)
hbox.addWidget(self.next_button)
vbox = QVBoxLayout()
vbox.addWidget(QLabel("Chapters"))
vbox.addWidget(self.chapter_list)
vbox.addLayout(hbox)
widget = QWidget()
widget.setLayout(vbox)
self.addWidget(self.web_view)
self.addWidget(widget)
def create_connections(self):
chlist = self.chapter_list
self.connect(
self.next_button, SIGNAL("clicked()"),
lambda: chlist.setCurrentRow(0 if chlist.currentRow(
) == chlist.count() - 1 else chlist.currentRow() + 1))
self.connect(
self.previous_button, SIGNAL("clicked()"),
lambda: chlist.setCurrentRow(chlist.count(
) - 1 if chlist.currentRow() == 0 else chlist.currentRow() - 1))
self.connect(self.chapter_list, SIGNAL("currentRowChanged(int)"),
self.set_chapter)
page = self.web_view.page()
page.setLinkDelegationPolicy(QWebPage.DelegateAllLinks)
def set_chapter(self, num=None):
if num is None:
num = self.chapter_list.currentRow()
if num < 0:
num = len(self.book.chapters) - 1
elif num >= len(self.book.chapters):
num = 0
self.web_view.setHtml(
self.book.get_chapter(num).decode(encoding="utf-8"))
def load_book(self, book_id):
self.book = Book(book_id)
self.chapter_list.clear()
for chapter in self.book.chapters:
self.chapter_list.addItem(chapter[0])
self.chapter_list.setCurrentRow(0)
class CardListWidged(QWidget):
def __init__(self):
super(CardListWidged, self).__init__()
self.layout = QVBoxLayout()
self.setLayout(self.layout)
self.word_list = QListWidget(self)
self.word_list.currentItemChanged.connect(self.on_item_changed)
self.layout.addWidget(self.word_list)
#making control panel
self.control_panel = ControlPanel(self)
self.layout.addWidget(self.control_panel)
#create word edit widget
self.card_edit_widget = CardEditWidget(self)
self.layout.addWidget(self.card_edit_widget)
self.cards = []
self.cards = load_cards()
self._update_word_list()
def _update_word_list(self):
self.word_list.clear()
words = []
for card in self.cards:
words.append(card.word)
self.word_list.addItems(words)
def on_item_changed(self, curr, prev):
word = curr.text()
card = find_card_by_word(self.cards, word)
self.card_edit_widget.show_card(card)
class ErrorsWidget(QWidget):
def __init__(self):
QWidget.__init__(self)
self.pep8 = None
self._outRefresh = True
vbox = QVBoxLayout(self)
self.listErrors = QListWidget()
self.listPep8 = QListWidget()
self.errorsLabel = QLabel(self.tr(ERRORS_TEXT).arg(0))
vbox.addWidget(self.errorsLabel)
vbox.addWidget(self.listErrors)
self.pep8Label = QLabel(self.tr(PEP8_TEXT).arg(0))
vbox.addWidget(self.pep8Label)
vbox.addWidget(self.listPep8)
self.connect(self.listErrors, SIGNAL("itemSelectionChanged()"),
self.errors_selected)
self.connect(self.listPep8, SIGNAL("itemSelectionChanged()"),
self.pep8_selected)
def errors_selected(self):
editorWidget = main_container.MainContainer().get_actual_editor()
if editorWidget and self._outRefresh:
lineno = self.listErrors.currentItem().data(Qt.UserRole).toInt()[0]
editorWidget.jump_to_line(lineno)
editorWidget.setFocus()
def pep8_selected(self):
editorWidget = main_container.MainContainer().get_actual_editor()
if editorWidget and self._outRefresh:
lineno = self.listPep8.currentItem().data(Qt.UserRole).toInt()[0]
editorWidget.jump_to_line(lineno)
editorWidget.setFocus()
def refresh_lists(self, errors, pep8):
self._outRefresh = False
self.listErrors.clear()
self.listPep8.clear()
for lineno in errors.errorsSummary:
linenostr = 'L%s\t' % str(lineno + 1)
for data in errors.errorsSummary[lineno]:
item = QListWidgetItem(linenostr + data)
item.setToolTip(linenostr + data)
item.setData(Qt.UserRole, lineno)
self.listErrors.addItem(item)
self.errorsLabel.setText(self.tr(ERRORS_TEXT).arg(
len(errors.errorsSummary)))
for lineno in pep8.pep8checks:
linenostr = 'L%s\t' % str(lineno + 1)
for data in pep8.pep8checks[lineno]:
item = QListWidgetItem(linenostr + data.split('\n')[0])
item.setToolTip(linenostr + data.split('\n')[0])
item.setData(Qt.UserRole, lineno)
self.listPep8.addItem(item)
self.pep8Label.setText(self.tr(PEP8_TEXT).arg(
len(pep8.pep8checks)))
self._outRefresh = True
class SnappingDock(DockWidget):
def __init__(self, iface, parent=None):
super(SnappingDock, self).__init__(parent)
self._iface = iface
self.setWindowTitle(u'Snapping Panel')
self.setObjectName(u'snappingDock')
self._listWidget = QListWidget(self)
self._listWidget.setSelectionMode(QAbstractItemView.NoSelection)
self._listWidget.setDropIndicatorShown(False)
self._dockLayout = QVBoxLayout(self)
self._dockLayout.setObjectName(u'dockLayout')
self._dockLayout.addWidget(self._listWidget)
self._dockContents = QWidget(self)
self._dockContents.setObjectName(u'dockContents')
self._dockContents.setLayout(self._dockLayout)
self.setWidget(self._dockContents)
# Keep up-to-date with layers added and removed
QgsMapLayerRegistry.instance().layersAdded.connect(self._layersAdded)
QgsMapLayerRegistry.instance().layersRemoved.connect(
self._layersRemoved)
def refresh(self):
self._listWidget.clear()
layers = QgsMapLayerRegistry.instance().mapLayers()
layerIds = layers.keys()
sorted(layerIds)
for layerId in layerIds:
self.addLayer(layers[layerId])
def addLayer(self, layer):
if (layer is None or not layer.isValid()
or layer.type() != QgsMapLayer.VectorLayer):
return
newItem = QListWidgetItem()
newItem.setData(Qt.UserRole, layer.id())
# newItem.setSizeHint(layerWidget.minimumSizeHint())
self._listWidget.addItem(newItem)
self._listWidget.setItemWidget(newItem,
LayerSnappingWidget(layer, self))
def removeLayer(self, layerId):
for idx in range(0, self._listWidget.count() - 1):
if self._listWidget.item(idx).data() == layerId:
self._listWidget.takeItem(idx)
return
def _layersAdded(self, layers):
for layer in layers:
self.addLayer(layer)
def _layersRemoved(self, layerIds):
for idx in range(self._listWidget.count() - 1, 0):
if self._listWidget.item(idx).data() in layerIds:
self._listWidget.takeItem(idx)
class BookView(QSplitter):
def __init__(self, parent=None):
super(BookView, self).__init__(parent=parent)
self.create_layout()
self.create_connections()
def create_layout(self):
self.web_view = QWebView()
self.chapter_list = QListWidget()
self.next_button = QPushButton("Next chapter")
self.previous_button = QPushButton("Previous chapter")
hbox = QHBoxLayout()
hbox.addStretch()
hbox.addWidget(self.previous_button)
hbox.addWidget(self.next_button)
vbox = QVBoxLayout()
vbox.addWidget(QLabel("Chapters"))
vbox.addWidget(self.chapter_list)
vbox.addLayout(hbox)
widget = QWidget()
widget.setLayout(vbox)
self.addWidget(self.web_view)
self.addWidget(widget)
def create_connections(self):
chlist = self.chapter_list
self.connect(self.next_button, SIGNAL("clicked()"), lambda:
chlist.setCurrentRow(0
if chlist.currentRow() == chlist.count() - 1
else chlist.currentRow() + 1))
self.connect(self.previous_button, SIGNAL("clicked()"), lambda:
chlist.setCurrentRow(chlist.count() - 1
if chlist.currentRow() == 0
else chlist.currentRow() - 1))
self.connect(self.chapter_list, SIGNAL("currentRowChanged(int)"),
self.set_chapter)
page = self.web_view.page()
page.setLinkDelegationPolicy(QWebPage.DelegateAllLinks)
def set_chapter(self, num=None):
if num is None:
num = self.chapter_list.currentRow()
if num < 0:
num = len(self.book.chapters) - 1
elif num >= len(self.book.chapters):
num = 0
self.web_view.setHtml(self.book.get_chapter(num).decode(encoding="utf-8"))
def load_book(self, book_id):
self.book = Book(book_id)
self.chapter_list.clear()
for chapter in self.book.chapters:
self.chapter_list.addItem(chapter[0])
self.chapter_list.setCurrentRow(0)
class ErrorsWidget(QWidget):
def __init__(self):
QWidget.__init__(self)
self.pep8 = None
self._outRefresh = True
vbox = QVBoxLayout(self)
self.listErrors = QListWidget()
self.listPep8 = QListWidget()
self.errorsLabel = QLabel(self.tr(ERRORS_TEXT).arg(0))
vbox.addWidget(self.errorsLabel)
vbox.addWidget(self.listErrors)
self.pep8Label = QLabel(self.tr(PEP8_TEXT).arg(0))
vbox.addWidget(self.pep8Label)
vbox.addWidget(self.listPep8)
self.connect(self.listErrors, SIGNAL("itemSelectionChanged()"),
self.errors_selected)
self.connect(self.listPep8, SIGNAL("itemSelectionChanged()"),
self.pep8_selected)
def errors_selected(self):
editorWidget = main_container.MainContainer().get_actual_editor()
if editorWidget and self._outRefresh:
lineno = self.listErrors.currentItem().data(Qt.UserRole).toInt()[0]
editorWidget.jump_to_line(lineno)
editorWidget.setFocus()
def pep8_selected(self):
editorWidget = main_container.MainContainer().get_actual_editor()
if editorWidget and self._outRefresh:
lineno = self.listPep8.currentItem().data(Qt.UserRole).toInt()[0]
editorWidget.jump_to_line(lineno)
editorWidget.setFocus()
def refresh_lists(self, errors, pep8):
self._outRefresh = False
self.listErrors.clear()
self.listPep8.clear()
for lineno in errors.errorsSummary:
linenostr = 'L%s\t' % str(lineno + 1)
for data in errors.errorsSummary[lineno]:
item = QListWidgetItem(linenostr + data)
item.setToolTip(linenostr + data)
item.setData(Qt.UserRole, lineno)
self.listErrors.addItem(item)
self.errorsLabel.setText(self.tr(ERRORS_TEXT).arg(
len(errors.errorsSummary)))
for lineno in pep8.pep8checks:
linenostr = 'L%s\t' % str(lineno + 1)
for data in pep8.pep8checks[lineno]:
item = QListWidgetItem(linenostr + data.split('\n')[0])
item.setToolTip(linenostr + data.split('\n')[0])
item.setData(Qt.UserRole, lineno)
self.listPep8.addItem(item)
self.pep8Label.setText(self.tr(PEP8_TEXT).arg(
len(pep8.pep8checks)))
self._outRefresh = True
class SnappingDock(DockWidget):
def __init__(self, iface, parent=None):
super(SnappingDock, self).__init__(parent)
self._iface = iface
self.setWindowTitle(u'Snapping Panel')
self.setObjectName(u'snappingDock')
self._listWidget = QListWidget(self)
self._listWidget.setSelectionMode(QAbstractItemView.NoSelection)
self._listWidget.setDropIndicatorShown(False)
self._dockLayout = QVBoxLayout(self)
self._dockLayout.setObjectName(u'dockLayout')
self._dockLayout.addWidget(self._listWidget)
self._dockContents = QWidget(self)
self._dockContents.setObjectName(u'dockContents')
self._dockContents.setLayout(self._dockLayout)
self.setWidget(self._dockContents)
# Keep up-to-date with layers added and removed
QgsMapLayerRegistry.instance().layersAdded.connect(self._layersAdded)
QgsMapLayerRegistry.instance().layersRemoved.connect(self._layersRemoved)
def refresh(self):
self._listWidget.clear()
layers = QgsMapLayerRegistry.instance().mapLayers()
layerIds = layers.keys()
sorted(layerIds)
for layerId in layerIds:
self.addLayer(layers[layerId])
def addLayer(self, layer):
if (layer is None or not layer.isValid() or layer.type() != QgsMapLayer.VectorLayer):
return
newItem = QListWidgetItem()
newItem.setData(Qt.UserRole, layer.id())
# newItem.setSizeHint(layerWidget.minimumSizeHint())
self._listWidget.addItem(newItem)
self._listWidget.setItemWidget(newItem, LayerSnappingWidget(layer, self))
def removeLayer(self, layerId):
for idx in range(0, self._listWidget.count() - 1):
if self._listWidget.item(idx).data() == layerId:
self._listWidget.takeItem(idx)
return
def _layersAdded(self, layers):
for layer in layers:
self.addLayer(layer)
def _layersRemoved(self, layerIds):
for idx in range(self._listWidget.count() - 1, 0):
if self._listWidget.item(idx).data() in layerIds:
self._listWidget.takeItem(idx)
class CaseList(QWidget):
def __init__(self):
QWidget.__init__(self)
addHelpToWidget(self, "init/case_list")
layout = QVBoxLayout()
self._list = QListWidget(self)
self._list.setMinimumHeight(100)
self._list.setMaximumHeight(250)
self._default_selection_mode = self._list.selectionMode()
self.setSelectable(False)
layout.addWidget(QLabel("Available Cases:"))
layout.addWidget(self._list)
self._addRemoveWidget = AddRemoveWidget(self.addItem, self.removeItem, horizontal=True)
self._addRemoveWidget.enableRemoveButton(False)
layout.addWidget(self._addRemoveWidget)
self._title = "New keyword"
self._description = "Enter name of keyword:"
self.setLayout(layout)
ERT.ertChanged.connect(self.updateList)
self.updateList()
def setSelectable(self, selectable):
if selectable:
self._list.setSelectionMode(self._default_selection_mode)
else:
self._list.setSelectionMode(QAbstractItemView.NoSelection)
def addItem(self):
dialog = ValidatedDialog("New case", "Enter name of new case:", getAllCases())
new_case_name = dialog.showAndTell()
if not new_case_name == "":
selectOrCreateNewCase(new_case_name)
def removeItem(self):
message = "Support for removal of items has not been implemented!"
QMessageBox.information(self, "Not implemented!", message)
def updateList(self):
"""Retrieves data from the model and inserts it into the list"""
case_list = getAllCases()
self._list.clear()
for case in case_list:
self._list.addItem(case)
class DetailWindow(myWindow):
listToParaAndRdnr = {}
def __init__(self, parent = None):
super(DetailWindow, self).__init__(parent, layoutCls = QHBoxLayout, fixed = False)
self._listWidget = QListWidget(self)
self._paraAndRdnr = QTableView(self)
self.layout().addWidget(self._listWidget)
self.layout().addWidget(self._paraAndRdnr)
self._listWidget.clicked.connect(self.showParaAndRdnr)
def showParaAndRdnr(self, listItem):
paraAndRdnr = self.listToParaAndRdnr.get(listItem.row())
model = QStandardItemModel(self)
c = 0
for para, rdnrs in paraAndRdnr.iteritems():
l = self._createListItem(para, rdnrs)
model.insertRow(c, l)
c += 1
model.setHeaderData(0, Qt.Horizontal, "Paragraph")
model.setHeaderData(1, Qt.Horizontal, "Randnummern")
self._paraAndRdnr.setModel(model)
def _createListItem(self, para, rdnrs):
rdnrsAsStr = toStr(collect([item for sublist in rdnrs for item in sublist]))
item1 = QStandardItem(para.decode("utf-8"))
item1.setToolTip(para.decode("utf-8"))
item2 = QStandardItem(rdnrsAsStr)
item2.setToolTip(rdnrsAsStr)
return [item1, item2]
def showDetails(self, content, windowTitle = None):
if windowTitle: self.setWindowTitle(windowTitle)
details = self._map_details(content)
self._listWidget.clear()
i = 0
for fileName, paraAndRdnrs in details.iteritems():
self._listWidget.addItem(fileName)
self.listToParaAndRdnr[i] = paraAndRdnrs
i += 1
def _map_details(self, data):
def nestedMap(data):
res = {}
idx = len(data[0])-1
for d in data:
old = res.get(d[idx], [])
old.append(d[:idx])
res[d[idx]] = old
return res
res = nestedMap(data)
for k, v in res.iteritems():
res[k] = nestedMap(v)
return res
class Completer(QCompleter):
def __init__(self, editor, project):
QCompleter.__init__(self)
self.icons = {
'function': QIcon(resources.images['function']),
'instance': QIcon(resources.images['attribute']),
'module': QIcon(resources.images['module']),
'class': QIcon(resources.images['class'])
}
self._editor = editor
self._fromProject = False
if project is not None:
self._project = project
self._fromProject = True
else:
self._project = rope.base.project.Project(self._editor.path, None,
None)
self.setWidget(self._editor)
self.popupView = QListWidget()
self.popupView.setAlternatingRowColors(True)
self.popupView.setWordWrap(False)
self.setPopup(self.popupView)
self.setCompletionMode(QCompleter.PopupCompletion)
self.setCaseSensitivity(Qt.CaseInsensitive)
self.connect(self, SIGNAL("activated(QString)"),
self.insert_completion)
def insert_completion(self, insert):
extra = insert.length() - self.completionPrefix().length()
self._editor.textCursor().insertText(insert.right(extra))
def complete(self, cr):
if self._project:
try:
self.popupView.clear()
code = str(self._editor.toPlainText())
start = self._editor.textCursor().position()
end = code.find('\n', start)
code = code[:start] + code[end:]
if self._fromProject:
self._project.validate()
proposals = codeassist.code_assist(self._project, code, start)
proposals = codeassist.sorted_proposals(proposals)
model = self.obtain_model_items(proposals)
self.setModel(model)
self.popup().setCurrentIndex(model.index(0, 0))
cr.setWidth(self.popup().sizeHintForColumn(0) \
+ self.popup().verticalScrollBar().sizeHint().width() + 10)
self.popupView.updateGeometries()
super(Completer, self).complete(cr)
except Exception, reason:
print reason
class ArrayWidget(QWidget, NodeWidget):
data_type = "Array"
two_rows = True
data_class = ArrayNode
def __init__(self, name, data, scheme, parent=None):
QWidget.__init__(self, parent)
NodeWidget.__init__(self, name, data, scheme)
self.layout = QVBoxLayout(self)
self.layout.setMargin(0)
self.layout.setContentsMargins(0,0,0,0)
self._listwidget = QListWidget(self)
self.layout.addWidget(self._listwidget)
hlayout = QHBoxLayout()
self.layout.addLayout(hlayout)
self._plus_minus_widget = PlusMinusWidget(self.create_item, self.delete_item, self)
hlayout.addWidget(self._plus_minus_widget)
self.element_scheme = self.scheme["ElementScheme"]
self.new_data = NodeWidget.get_default_data(self.element_scheme, self.data)
hlayout.addStretch(1)
self.add_widget = NodeWidget.create_node_widget("__not_exist", self.new_data, self.element_scheme)
hlayout.addWidget(self.add_widget)
def delete_item(self):
row = self._listwidget.row(self._listwidget.currentItem())
new_data = list(self.data.get())
del new_data[row]
self.data.set(tuple(new_data))
def create_item(self):
self.data.set(list(self.data.get())+[Node.create_node(self.new_data.get()),])
def __createItem(self, itemname):
item = QListWidgetItem(itemname)
# item.setFlags (Qt.ItemIsSelectable | Qt.ItemIsEditable | Qt.ItemIsEnabled )
self._listwidget.addItem(item)
def dump(self):
pass
def load(self):
self._listwidget.clear()
for item in self.data.get():
self.__createItem(unicode(item))
@classmethod
def _get_default_data(cls, scheme, data):
return ArrayNode([])
class Completer(QCompleter):
def __init__(self, editor, project):
QCompleter.__init__(self)
self.icons = {'function':QIcon(resources.images['function']),
'instance':QIcon(resources.images['attribute']),
'module':QIcon(resources.images['module']),
'class':QIcon(resources.images['class'])}
self._editor = editor
self._fromProject = False
if project is not None:
self._project = project
self._fromProject = True
else:
self._project = rope.base.project.Project(self._editor.path, None, None)
self.setWidget(self._editor)
self.popupView = QListWidget()
self.popupView.setAlternatingRowColors(True)
self.popupView.setWordWrap(False)
self.setPopup(self.popupView)
self.setCompletionMode(QCompleter.PopupCompletion)
self.setCaseSensitivity(Qt.CaseInsensitive)
self.connect(self, SIGNAL("activated(QString)"), self.insert_completion)
def insert_completion(self, insert):
extra = insert.length() - self.completionPrefix().length()
self._editor.textCursor().insertText(insert.right(extra))
def complete(self, cr):
if self._project:
try:
self.popupView.clear()
code = str(self._editor.toPlainText())
start = self._editor.textCursor().position()
end = code.find('\n', start)
code = code[:start] + code[end:]
if self._fromProject:
self._project.validate()
proposals = codeassist.code_assist(self._project, code, start)
proposals = codeassist.sorted_proposals(proposals)
model = self.obtain_model_items(proposals)
self.setModel(model)
self.popup().setCurrentIndex(model.index(0, 0))
cr.setWidth(self.popup().sizeHintForColumn(0) \
+ self.popup().verticalScrollBar().sizeHint().width() + 10)
self.popupView.updateGeometries()
super(Completer, self).complete(cr)
except Exception, reason:
print reason
class ProfilesLoader(QDialog):
def __init__(self, load_func, profiles, parent=None):
QDialog.__init__(self, parent, Qt.Dialog)
self.setMinimumWidth(400)
self._profiles = profiles
self.load_function = load_func
vbox = QVBoxLayout(self)
self.profileList = QListWidget()
self.profileList.addItems([key for key in profiles])
self.contentList = QListWidget()
self.contentList.setSortingEnabled(True)
self.btnDelete = QPushButton(self.tr("Delete Profile"))
self.btnDelete.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.btnOpen = QPushButton(self.tr("Open Profile"))
self.btnOpen.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.btnOpen.setDefault(True)
hbox = QHBoxLayout()
hbox.addWidget(self.btnDelete)
hbox.addWidget(self.btnOpen)
vbox.addWidget(self.profileList)
vbox.addWidget(self.contentList)
vbox.addLayout(hbox)
self.connect(self.profileList, SIGNAL("itemSelectionChanged()"),
self.load_profile_content)
self.connect(self.btnOpen, SIGNAL("clicked()"), self.open_profile)
self.connect(self.btnDelete, SIGNAL("clicked()"), self.delete_profile)
def load_profile_content(self):
item = self.profileList.currentItem()
self.contentList.clear()
key = unicode(item.text())
content = self._profiles[key]
self.contentList.addItems(content)
def open_profile(self):
if self.profileList.currentItem():
key = unicode(self.profileList.currentItem().text())
self.load_function(key)
self.close()
def delete_profile(self):
if self.profileList.currentItem():
key = unicode(self.profileList.currentItem().text())
self._profiles.pop(key)
self.profileList.takeItem(self.profileList.currentRow())
self.contentList.clear()
class ErrorsWidget(QWidget):
def __init__(self):
QWidget.__init__(self)
self.pep8 = None
self._outRefresh = True
vbox = QVBoxLayout(self)
self.listErrors = QListWidget()
self.listPep8 = QListWidget()
self.errorsLabel = QLabel(self.tr(ERRORS_TEXT).arg(0))
vbox.addWidget(self.errorsLabel)
vbox.addWidget(self.listErrors)
self.pep8Label = QLabel(self.tr(PEP8_TEXT).arg(0))
vbox.addWidget(self.pep8Label)
vbox.addWidget(self.listPep8)
self.connect(self.listErrors, SIGNAL("itemSelectionChanged()"), self.errors_selected)
self.connect(self.listPep8, SIGNAL("itemSelectionChanged()"), self.pep8_selected)
def errors_selected(self):
editorWidget = main_container.MainContainer().get_actual_editor()
if editorWidget and self._outRefresh:
index = self.listErrors.currentItem().data(Qt.UserRole).toInt()[0]
editorWidget.jump_to_line(editorWidget.errors.errorsLines[index] - 1)
editorWidget.setFocus()
def pep8_selected(self):
editorWidget = main_container.MainContainer().get_actual_editor()
if editorWidget and self._outRefresh:
index = self.listPep8.currentItem().data(Qt.UserRole).toInt()[0]
editorWidget.jump_to_line(editorWidget.pep8.pep8lines[index] - 1)
editorWidget.setFocus()
def refresh_lists(self, errors, pep8):
self._outRefresh = False
self.listErrors.clear()
self.listPep8.clear()
for index, data in enumerate(errors.errorsLines):
item = QListWidgetItem(errors.errorsSummary[data])
item.setData(Qt.UserRole, index)
self.listErrors.addItem(item)
self.errorsLabel.setText(self.tr(ERRORS_TEXT).arg(len(errors.errorsLines)))
for index, data in enumerate(pep8.pep8checks):
item = QListWidgetItem(data.split("\n")[0])
item.setData(Qt.UserRole, index)
self.listPep8.addItem(item)
self.pep8Label.setText(self.tr(PEP8_TEXT).arg(len(pep8.pep8checks)))
self._outRefresh = True
def __init__(self, guiList : QtGui.QListWidget, filterFn,
formatFn = CoreLogRecordProcessor.CreateFormatFn(),
dropSize : int = 500):
"""
'formatFn' - fn(record) -> str, create it using CoreLogger.CreateFormatFn(),
'filterFn' - fn(record) -> bool, create it using one of the CoreLogger
create filter methods,
'guiList' - widget to display log,
'dropSize' - log will be dropped when it size reach this value
(0 and -1 - infinity).
"""
assert guiList != None
CheckFnArgs(filterFn, (CoreLogRecord,), bool)
CheckFnArgs(formatFn, (CoreLogRecord,), str)
self.gui = guiList
self.dontDisplayInGuiIfHidden = True
OnDrop = lambda: guiList.clear()
self.storage = CoreLogStore(OnDrop, dropSize)
self.filterFn = filterFn
self.formatFn = formatFn
RP = CoreLogRecordProcessor
self.outputFn = RP.CreateOutputFn(self.gui.addItem,
RP.OutputFormat.SplitLinesSkipEmpty)
self.threadId = threading.current_thread()
self.closed = False
class TabGroup(QWidget, itab_item.ITabItem):
def __init__(self, project, name, actions):
QWidget.__init__(self)
itab_item.ITabItem.__init__(self)
vbox = QVBoxLayout(self)
self.actions = actions
self.project = project
self.ID = self.project
self.name = name
self.tabs = []
self.listWidget = QListWidget()
hbox = QHBoxLayout()
btnExpand = QPushButton(self.tr("Expand this Files"))
btnExpandAll = QPushButton(self.tr("Expand all Groups"))
hbox.addWidget(btnExpandAll)
hbox.addSpacerItem(QSpacerItem(20, 20, QSizePolicy.Expanding))
hbox.addWidget(btnExpand)
vbox.addLayout(hbox)
vbox.addWidget(self.listWidget)
self.connect(btnExpand, SIGNAL("clicked()"), self.expand_this)
self.connect(btnExpandAll, SIGNAL("clicked()"),
self.actions.deactivate_tabs_groups)
def add_widget(self, widget):
self.tabs.append(widget)
self.listWidget.addItem(widget.ID)
def expand_this(self):
self.actions.group_tabs_together()
for tab in self.tabs:
tabName = file_manager.get_basename(tab.ID)
self.actions.ide.mainContainer.add_tab(tab, tabName)
index = self.actions.ide.mainContainer._tabMain.indexOf(self)
self.actions.ide.mainContainer._tabMain.removeTab(index)
self.tabs = []
self.listWidget.clear()
def only_expand(self):
for tab in self.tabs:
tabName = file_manager.get_basename(tab.ID)
self.actions.ide.mainContainer.add_tab(tab, tabName)
index = self.actions.ide.mainContainer._tabMain.indexOf(self)
self.actions.ide.mainContainer._tabMain.removeTab(index)
self.tabs = []
self.listWidget.clear()
class TabGroup(QWidget, itab_item.ITabItem):
def __init__(self, project, name, actions):
QWidget.__init__(self)
itab_item.ITabItem.__init__(self)
vbox = QVBoxLayout(self)
self.actions = actions
self.project = project
self.ID = self.project
self.name = name
self.tabs = []
self.listWidget = QListWidget()
hbox = QHBoxLayout()
btnExpand = QPushButton(self.tr("Expand this Files"))
btnExpandAll = QPushButton(self.tr("Expand all Groups"))
hbox.addWidget(btnExpandAll)
hbox.addSpacerItem(QSpacerItem(20, 20, QSizePolicy.Expanding))
hbox.addWidget(btnExpand)
vbox.addLayout(hbox)
vbox.addWidget(self.listWidget)
self.connect(btnExpand, SIGNAL("clicked()"), self.expand_this)
self.connect(btnExpandAll, SIGNAL("clicked()"),
self.actions.deactivate_tabs_groups)
def add_widget(self, widget):
self.tabs.append(widget)
self.listWidget.addItem(widget.ID)
def expand_this(self):
self.actions.group_tabs_together()
for tab in self.tabs:
tabName = file_manager.get_basename(tab.ID)
self.actions.ide.mainContainer.add_tab(tab, tabName)
index = self.actions.ide.mainContainer._tabMain.indexOf(self)
self.actions.ide.mainContainer._tabMain.removeTab(index)
self.tabs = []
self.listWidget.clear()
def only_expand(self):
for tab in self.tabs:
tabName = file_manager.get_basename(tab.ID)
self.actions.ide.mainContainer.add_tab(tab, tabName)
index = self.actions.ide.mainContainer._tabMain.indexOf(self)
self.actions.ide.mainContainer._tabMain.removeTab(index)
self.tabs = []
self.listWidget.clear()
class PopupCompleter(QFrame):
def __init__(self, model):
QFrame.__init__(self, None, Qt.FramelessWindowHint | Qt.ToolTip)
vbox = QVBoxLayout(self)
vbox.setContentsMargins(0, 0, 0, 0)
vbox.setSpacing(0)
self.listWidget = QListWidget()
for i, item in enumerate(model):
self.listWidget.addItem(item)
self.listWidget.setCurrentRow(0)
vbox.addWidget(self.listWidget)
def refresh(self, model):
self.listWidget.clear()
for i, item in enumerate(model):
self.listWidget.addItem(item)
self.listWidget.setCurrentRow(0)
class PopupCompleter(QFrame):
def __init__(self, model):
QFrame.__init__(self, None, Qt.FramelessWindowHint | Qt.ToolTip)
vbox = QVBoxLayout(self)
vbox.setContentsMargins(0, 0, 0, 0)
vbox.setSpacing(0)
self.listWidget = QListWidget()
for i, item in enumerate(model):
self.listWidget.addItem(item)
self.listWidget.setCurrentRow(0)
vbox.addWidget(self.listWidget)
def refresh(self, model):
self.listWidget.clear()
for i, item in enumerate(model):
self.listWidget.addItem(item)
self.listWidget.setCurrentRow(0)
class TabGroup(QWidget, itab_item.ITabItem):
"""Group tabs from the same project.
SIGNALS:
@expandAll()
"""
def __init__(self, project, name, parent):
super(TabGroup, self).__init__(parent)
vbox = QVBoxLayout(self)
self.ID = project
self.name = name
self.tabs = []
self.listWidget = QListWidget()
hbox = QHBoxLayout()
btnExpand = QPushButton(self.tr("Expand this Files"))
btnExpandAll = QPushButton(self.tr("Expand all Groups"))
hbox.addWidget(btnExpandAll)
hbox.addSpacerItem(QSpacerItem(20, 20, QSizePolicy.Expanding))
hbox.addWidget(btnExpand)
vbox.addLayout(hbox)
vbox.addWidget(self.listWidget)
self.connect(btnExpand, SIGNAL("clicked()"), self.expand)
self.connect(btnExpandAll, SIGNAL("clicked()"),
lambda: self.emit(SIGNAL("expandAll()")))
def add_widget(self, widget):
self.tabs.append(widget)
self.listWidget.addItem(widget.ID)
def expand(self):
main_container = IDE.get_service('main_container')
if main_container:
for tab in self.tabs:
main_container.add_tab(tab, tab.display_name)
index = main_container.tabs.indexOf(self)
main_container.tabs.removeTab(index)
self.tabs = []
self.listWidget.clear()
class DelCategoriesDlg(QDialog):
def __init__(self, categories, parent=None):
super(DelCategoriesDlg, self).__init__(parent)
self.setWindowTitle('Address Book - Delete Categories')
self.resize(302, 307)
self.parent = parent
self.db = self.parent.db
self.categories = categories
self.ListWidget = QListWidget()
self.delButton = QPushButton('Delete')
vlayout = pyqttools.add_to_layout(QVBoxLayout(),(self.delButton, None))
f_layout = pyqttools.add_to_layout(QHBoxLayout(),
(self.ListWidget, vlayout))
self.setLayout(f_layout)
self.delButton.clicked.connect(self.delete)
self.fill_ListWidget()
def fill_ListWidget(self):
self.ListWidget.clear()
self.ListWidget.addItems(self.categories)
self.set_enable()
def set_enable(self):
self.delButton.setEnabled(bool(self.ListWidget))
def delete(self):
categ = self.ListWidget.currentItem().text()
categ_id = self.db.get_category_id(categ, self.parent.user)
reply = QMessageBox.question(self, 'Address Book - Delete User',
'Are sou sure that you want to delete {0} and all its contacts?'\
.format(categ), QMessageBox.Yes|QMessageBox.Cancel)
if reply == QMessageBox.Yes:
self.db.delete_category(categ_id)
self.categories.remove(categ)
self.fill_ListWidget()
class TabGroup(QWidget, itab_item.ITabItem):
"""Group tabs from the same project.
SIGNALS:
@expandAll()
"""
def __init__(self, project, name, parent):
super(TabGroup, self).__init__(parent)
vbox = QVBoxLayout(self)
self.ID = project
self.name = name
self.tabs = []
self.listWidget = QListWidget()
hbox = QHBoxLayout()
btnExpand = QPushButton(self.tr("Expand this Files"))
btnExpandAll = QPushButton(self.tr("Expand all Groups"))
hbox.addWidget(btnExpandAll)
hbox.addSpacerItem(QSpacerItem(20, 20, QSizePolicy.Expanding))
hbox.addWidget(btnExpand)
vbox.addLayout(hbox)
vbox.addWidget(self.listWidget)
self.connect(btnExpand, SIGNAL("clicked()"), self.expand)
self.connect(btnExpandAll, SIGNAL("clicked()"),
lambda: self.emit(SIGNAL("expandAll()")))
def add_widget(self, widget):
self.tabs.append(widget)
self.listWidget.addItem(widget.ID)
def expand(self):
main_container = IDE.get_service('main_container')
if main_container:
for tab in self.tabs:
main_container.add_tab(tab, tab.display_name)
index = main_container.tabs.indexOf(self)
main_container.tabs.removeTab(index)
self.tabs = []
self.listWidget.clear()
class CompleterWidget(QCompleter):
def __init__(self, editor):
QCompleter.__init__(self)
self.setWidget(editor)
self.popupView = QListWidget()
self.popupView.setAlternatingRowColors(True)
self.popupView.setWordWrap(False)
self.setPopup(self.popupView)
self.setCompletionMode(QCompleter.PopupCompletion)
self.setCaseSensitivity(Qt.CaseInsensitive)
self.connect(self.popupView, SIGNAL("itemClicked(QListWidgetItem*)"),
self.insert_completion)
def insert_completion(self):
insert = self.popupView.currentItem().text()
extra = insert.length() - self.completionPrefix().length()
self.widget().textCursor().insertText(insert.right(extra))
self.popup().hide()
def complete(self, cr, results):
self.popupView.clear()
model = self.obtain_model_items(results)
self.setModel(model)
self.popup().setCurrentIndex(model.index(0, 0))
cr.setWidth(self.popup().sizeHintForColumn(0) \
+ self.popup().verticalScrollBar().sizeHint().width() + 10)
self.popupView.updateGeometries()
QCompleter.complete(self, cr)
def obtain_model_items(self, proposals):
proposals.sort()
for p in proposals:
self.popupView.addItem(QListWidgetItem(p))
return self.popupView.model()
class HDFWidget(QWidget):
def __init__(self, parent=None):
super(HDFWidget, self).__init__(parent=parent)
self.parent = parent
self.main_layout = QVBoxLayout()
### Select Dataset and properties ###
self.layout = QHBoxLayout()
self.list = QListWidget()
self.textBox = QTextEdit()
self.textBox.resize(200, 200)
### Add button ###
self.button = QPushButton("Apply")
self.main_layout.addLayout(self.layout)
self.main_layout.addWidget(self.button)
self.setLayout(self.main_layout)
self.layout.addWidget(self.list)
self.layout.addWidget(self.textBox)
### Variables ###
self.settings = None
self.list.itemClicked.connect(self.item_clicked)
self.connect(self.button, QtCore.SIGNAL("clicked()"),
self.apply_settings)
def item_clicked(self, item):
"""Action triggered when an item is clicked. The content of the metadata is retrieved from its index and not from the file itself, avoiding clashes with the main program. """
i = self.list.currentRow()
self.settings = self.all_settings[i]
self.textBox.clear()
self.textBox.setText(self.settings)
# mdd = self.settings.split('\n')
# for t in mdd:
# self.textBox.append(t)
def add_items(self, name):
""" Adds the group items to the display.
The file is closed after extracting the metadata, to avoid conflicts with the main program.
:param name: Name of the HDF file to be opened.
:return: Null
"""
f = h5py.File(name, 'r')
self.settings = None
self.all_settings = []
self.list.clear()
for g in f:
self.all_settings.append(f[g + '/metadata'][()].decode('ascii'))
self.list.addItem(g)
f.close()
def apply_settings(self):
""" Triggered when the apply button is pressed. The settings are broadcasted as coming from the parent.
"""
if self.settings is not None:
self.parent.emit(QtCore.SIGNAL('settings'), self.settings)
class RunsDialog(QtHelper.EnhancedQDialog):
"""
Runs several dialog
"""
RefreshRepository = pyqtSignal(str)
def __init__(self, dialogName, parent = None, iRepo=None, lRepo=None, rRepo=None):
"""
Constructor
"""
QtHelper.EnhancedQDialog.__init__(self, parent)
self.name = self.tr("Prepare a group of runs")
self.projectReady = False
self.iRepo = iRepo
self.lRepo = lRepo
self.rRepo = rRepo
self.createDialog()
self.createConnections()
def createDialog(self):
"""
Create qt dialog
"""
self.setWindowTitle( self.name )
mainLayout = QHBoxLayout()
layoutTests = QHBoxLayout()
layoutRepoTest = QVBoxLayout()
self.prjCombo = QComboBox(self)
self.prjCombo.setEnabled(False)
self.repoTests = QTreeWidget(self)
self.repoTests.setFrameShape(QFrame.NoFrame)
if USE_PYQT5:
self.repoTests.header().setSectionResizeMode(QHeaderView.Stretch)
else:
self.repoTests.header().setResizeMode(QHeaderView.Stretch)
self.repoTests.setHeaderHidden(True)
self.repoTests.setContextMenuPolicy(Qt.CustomContextMenu)
self.repoTests.setIndentation(10)
layoutRepoTest.addWidget(self.prjCombo)
layoutRepoTest.addWidget(self.repoTests)
self.testsList = QListWidget(self)
layoutTests.addLayout( layoutRepoTest )
layoutTests.addWidget( self.testsList )
mainLayout.addLayout( layoutTests )
buttonLayout = QVBoxLayout()
self.okButton = QPushButton(self.tr("Execute All"), self)
self.okButton.setEnabled(False)
self.cancelButton = QPushButton(self.tr("Cancel"), self)
self.upButton = QPushButton(self.tr("UP"), self)
self.upButton.setEnabled(False)
self.downButton = QPushButton(self.tr("DOWN"), self)
self.downButton.setEnabled(False)
self.clearButton = QPushButton(self.tr("Remove All"), self)
self.delButton = QPushButton(self.tr("Remove"), self)
self.delButton.setEnabled(False)
self.runSimultaneous = QCheckBox(self.tr("Simultaneous Run"))
self.schedImmed = QRadioButton(self.tr("Run Immediately"))
self.schedImmed.setChecked(True)
self.schedAt = QRadioButton(self.tr("Run At:"))
self.schedAtDateTimeEdit = QDateTimeEdit(QDateTime.currentDateTime())
self.schedAtDateTimeEdit.setEnabled(False)
buttonLayout.addWidget(self.okButton)
buttonLayout.addWidget(self.runSimultaneous)
buttonLayout.addWidget(self.schedImmed)
buttonLayout.addWidget(self.schedAt)
buttonLayout.addWidget(self.schedAtDateTimeEdit)
buttonLayout.addWidget( self.upButton )
buttonLayout.addWidget( self.downButton )
buttonLayout.addWidget( self.delButton )
buttonLayout.addWidget( self.clearButton )
buttonLayout.addWidget(self.cancelButton)
mainLayout.addLayout(buttonLayout)
self.setMinimumHeight(400)
self.setMinimumWidth(750)
self.setLayout(mainLayout)
def initProjects(self, projects=[], defaultProject=1):
"""
Initialize projects
"""
# init date and time
self.schedAtDateTimeEdit.setDateTime(QDateTime.currentDateTime())
self.projectReady = False
self.repoTests.clear()
self.prjCombo.clear()
self.testsList.clear()
self.prjCombo.setEnabled(True)
# insert data
pname = ''
for p in projects:
self.prjCombo.addItem ( p['name'] )
if defaultProject == p['project_id']:
pname = p['name']
for i in xrange(self.prjCombo.count()):
item_text = self.prjCombo.itemText(i)
if str(pname) == str(item_text):
self.prjCombo.setCurrentIndex(i)
self.projectReady = True
self.RefreshRepository.emit(pname)
def initializeTests(self, listing):
"""
Initialize tests
"""
self.repoTests.clear()
self.testRoot = self.rRepo.Item(repo = self.iRepo.remote(),
parent = self.repoTests, txt = "Root",
type = QTreeWidgetItem.UserType+10,
isRoot = True )
self.testRoot.setSelected(True)
self.createRepository(listing=listing, parent=self.testRoot,fileincluded=True)
self.repoTests.sortItems(0, Qt.AscendingOrder)
self.hideItems(hideTsx=False, hideTpx=False, hideTcx=True, hideTdx=True, hideTxt=True, hidePy=True,
hideTux=False, hidePng=True, hideTgx=False, hideTax=False)
def createRepository(self, listing, parent, fileincluded=True):
"""
Create repository
@param listing:
@type listing: list
@param parent:
@type parent:
@param fileincluded:
@type fileincluded: boolean
"""
try:
for dct in listing:
if dct["type"] == "folder":
item = self.rRepo.Item(repo = self.iRepo.remote(), parent = parent,
txt = dct["name"], propertiesFile=dct )
self.createRepository( dct["content"] , item, fileincluded )
else:
if fileincluded:
if dct["type"] == "file":
pname = self.iRepo.remote().getProjectName(dct["project"])
# {'modification': 1342259500, 'type': 'file', 'name': '__init__.py', 'size': '562 }
item = self.rRepo.Item(repo = self.iRepo.remote(), parent = parent, txt = dct["name"] ,
propertiesFile=dct, type = QTreeWidgetItem.UserType+0,
projectId=dct["project"], projectName=pname )
except Exception as e:
self.error( "unable to create tree for runs: %s" % e )
def onProjectChanged(self, projectItem):
"""
Called when the project changed on the combo box
"""
if self.projectReady:
item_text = self.prjCombo.itemText(projectItem)
self.RefreshRepository.emit(item_text)
def createConnections (self):
"""
create qt connections
* ok
* cancel
"""
self.prjCombo.currentIndexChanged.connect(self.onProjectChanged)
self.okButton.clicked.connect( self.acceptClicked )
self.cancelButton.clicked.connect( self.reject )
self.upButton.clicked.connect(self.upTest)
self.downButton.clicked.connect(self.downTest)
self.clearButton.clicked.connect(self.clearList)
self.delButton.clicked.connect(self.delTest)
self.testsList.itemClicked.connect(self.onItemSelected)
self.testsList.itemSelectionChanged.connect(self.onItemSelectionChanged)
self.schedAt.toggled.connect(self.onSchedAtActivated)
self.repoTests.itemDoubleClicked.connect( self.onTestDoucleClicked )
def onSchedAtActivated(self, toggled):
"""
On sched at button activated
"""
if toggled:
self.schedAtDateTimeEdit.setEnabled(True)
else:
self.schedAtDateTimeEdit.setEnabled(False)
def onItemSelectionChanged(self):
"""
Called on item selection changed
"""
self.onItemSelected(itm=None)
def onItemSelected(self, itm):
"""
Call on item selected
"""
selectedItems = self.testsList.selectedItems()
if len(selectedItems):
self.delButton.setEnabled(True)
self.upButton.setEnabled(True)
self.downButton.setEnabled(True)
else:
self.delButton.setEnabled(False)
self.upButton.setEnabled(False)
self.downButton.setEnabled(False)
if not self.testsList.count():
self.okButton.setEnabled(False)
def upTest(self):
"""
Up test
"""
currentRow = self.testsList.currentRow()
currentItem = self.testsList.takeItem(currentRow)
self.testsList.insertItem(currentRow - 1, currentItem)
def downTest(self):
"""
Down test
"""
currentRow = self.testsList.currentRow()
currentItem = self.testsList.takeItem(currentRow)
self.testsList.insertItem(currentRow + 1, currentItem)
def delTest(self):
"""
Del test
"""
currentRow = self.testsList.currentRow()
currentItem = self.testsList.takeItem(currentRow)
def clearList(self):
"""
Clear test
"""
self.testsList.clear()
self.delButton.setEnabled(False)
self.upButton.setEnabled(False)
self.downButton.setEnabled(False)
self.okButton.setEnabled(False)
def iterateTree(self, item, hideTsx, hideTpx, hideTcx, hideTdx, hideTxt,
hidePy, hideTux, hidePng, hideTgx, hideTax):
"""
Iterate tree
"""
child_count = item.childCount()
for i in range(child_count):
subitem = item.child(i)
subchild_count = subitem.childCount()
if subchild_count > 0:
self.iterateTree(item=subitem, hideTsx=hideTsx,
hideTpx=hideTpx, hideTcx=hideTcx,
hideTdx=hideTdx, hideTxt=hideTxt,
hidePy=hidePy, hideTux=hideTux,
hidePng=hidePng, hideTgx=hideTgx, hideTax=hideTax)
else:
if hideTux and subitem.getExtension() == self.rRepo.EXTENSION_TUX:
subitem.setHidden (True)
elif hideTpx and subitem.getExtension() == self.rRepo.EXTENSION_TPX:
subitem.setHidden (True)
elif hideTgx and subitem.getExtension() == self.rRepo.EXTENSION_TGX:
subitem.setHidden (True)
elif hideTcx and subitem.getExtension() == self.rRepo.EXTENSION_TCX:
subitem.setHidden (True)
elif hideTsx and subitem.getExtension() == self.rRepo.EXTENSION_TSX:
subitem.setHidden (True)
elif hideTdx and subitem.getExtension() == self.rRepo.EXTENSION_TDX:
subitem.setHidden (True)
elif hideTxt and subitem.getExtension() == self.rRepo.EXTENSION_TXT:
subitem.setHidden (True)
elif hidePy and subitem.getExtension() == self.rRepo.EXTENSION_PY:
subitem.setHidden (True)
elif hidePng and subitem.getExtension() == self.rRepo.EXTENSION_PNG:
subitem.setHidden (True)
elif hideTax and subitem.getExtension() == self.rRepo.EXTENSION_TAx:
subitem.setHidden (True)
else:
subitem.setHidden(False)
def hideItems(self, hideTsx=False, hideTpx=False, hideTcx=False, hideTdx=False, hideTxt=False, hidePy=False,
hideTux=False, hidePng=False, hideTgx=False, hideTax=False):
"""
Hide items
"""
root = self.repoTests.invisibleRootItem()
self.iterateTree(item=root, hideTsx=hideTsx, hideTpx=hideTpx, hideTcx=hideTcx,
hideTdx=hideTdx, hideTxt=hideTxt, hidePy=hidePy,
hideTux=hideTux, hidePng=hidePng, hideTgx=hideTgx, hideTax=hideTax)
def onTestDoucleClicked(self, testItem):
"""
On tests double clicked
"""
if testItem.type() != QTreeWidgetItem.UserType+0:
return
self.okButton.setEnabled(True)
currentProject = self.prjCombo.currentText()
testName = "%s:%s" % (str(currentProject),testItem.getPath(withFileName = True))
testItem = QListWidgetItem(testName )
if testName.endswith(self.rRepo.EXTENSION_TUX):
testItem.setIcon(QIcon(":/tux.png"))
if testName.endswith(self.rRepo.EXTENSION_TSX):
testItem.setIcon(QIcon(":/tsx.png"))
if testName.endswith(self.rRepo.EXTENSION_TPX):
testItem.setIcon(QIcon(":/tpx.png"))
if testName.endswith(self.rRepo.EXTENSION_TGX):
testItem.setIcon(QIcon(":/tgx.png"))
if testName.endswith(self.rRepo.EXTENSION_TAX):
testItem.setIcon(QIcon(":/tax.png"))
self.testsList.addItem( testItem )
def acceptClicked (self):
"""
Called on accept button
"""
self.accept()
def getTests(self):
"""
Returns all tests in the list
"""
tests = []
for i in xrange(self.testsList.count()):
testItem = self.testsList.item(i)
tests.append( str(testItem.text()) )
runSimultaneous = False
if self.runSimultaneous.isChecked(): runSimultaneous = True
if self.schedImmed.isChecked():
runAt = (0,0,0,0,0,0)
return (tests, False, runAt, runSimultaneous)
else:
pydt = self.schedAtDateTimeEdit.dateTime().toPyDateTime()
runAt = (pydt.year, pydt.month, pydt.day, pydt.hour, pydt.minute, pydt.second)
return (tests, True, runAt, runSimultaneous)
class ProfilesLoader(QDialog):
def __init__(self,
load_func,
create_func,
save_func,
profiles,
parent=None):
QDialog.__init__(self, parent, Qt.Dialog)
self.setWindowTitle(self.tr("Profile Manager"))
self.setMinimumWidth(400)
self._profiles = profiles
self.load_function = load_func
self.create_function = create_func
self.save_function = save_func
self.ide = parent
vbox = QVBoxLayout(self)
vbox.addWidget(
QLabel(
self.tr("Save your opened files and projects "
"into a profile and change really quick\n"
"between projects and files sessions.\n"
"This allows you to save your working environment, "
"keep working in another\nproject and then go back "
"exactly where you left.")))
self.profileList = QListWidget()
self.profileList.addItems([key for key in profiles])
self.profileList.setCurrentRow(0)
self.contentList = QListWidget()
self.btnDelete = QPushButton(self.tr("Delete Profile"))
self.btnDelete.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.btnUpdate = QPushButton(self.tr("Update Profile"))
self.btnUpdate.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.btnCreate = QPushButton(self.tr("Create New Profile"))
self.btnCreate.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.btnOpen = QPushButton(self.tr("Open Profile"))
self.btnOpen.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.btnOpen.setDefault(True)
hbox = QHBoxLayout()
hbox.addWidget(self.btnDelete)
hbox.addWidget(self.btnUpdate)
hbox.addWidget(self.btnCreate)
hbox.addWidget(self.btnOpen)
vbox.addWidget(self.profileList)
vbox.addWidget(self.contentList)
vbox.addLayout(hbox)
self.connect(self.profileList, SIGNAL("itemSelectionChanged()"),
self.load_profile_content)
self.connect(self.btnOpen, SIGNAL("clicked()"), self.open_profile)
self.connect(self.btnUpdate, SIGNAL("clicked()"), self.save_profile)
self.connect(self.btnCreate, SIGNAL("clicked()"), self.create_profile)
self.connect(self.btnDelete, SIGNAL("clicked()"), self.delete_profile)
def load_profile_content(self):
item = self.profileList.currentItem()
self.contentList.clear()
if item is not None:
key = item.text()
files = [self.tr('Files:')] + \
[file[0] for file in self._profiles[key][0]]
projects = [self.tr('Projects:')] + self._profiles[key][1]
content = files + projects
self.contentList.addItems(content)
def create_profile(self):
profileName = self.create_function()
self.ide.Profile = profileName
self.close()
def save_profile(self):
if self.profileList.currentItem():
profileName = self.profileList.currentItem().text()
self.save_function(profileName)
self.ide.show_status_message(
self.tr("Profile %s Updated!" % profileName))
self.load_profile_content()
def open_profile(self):
if self.profileList.currentItem():
key = self.profileList.currentItem().text()
self.load_function(key)
self.ide.Profile = key
self.close()
def delete_profile(self):
if self.profileList.currentItem():
key = self.profileList.currentItem().text()
self._profiles.pop(key)
self.profileList.takeItem(self.profileList.currentRow())
self.contentList.clear()
class PopupCompleter(QFrame):
def __init__(self):
QFrame.__init__(self, None, Qt.FramelessWindowHint | Qt.ToolTip)
vbox = QVBoxLayout(self)
vbox.setContentsMargins(0, 0, 0, 0)
vbox.setSpacing(0)
self.listWidget = QListWidget()
self.listWidget.setMinimumHeight(350)
vbox.addWidget(self.listWidget)
self.listWidget.currentItemChanged.connect(self._repaint_items)
def _repaint_items(self, current, previous):
if current is not None:
widget = self.listWidget.itemWidget(current)
if widget is not None:
widget.set_selected()
if previous is not None:
widget = self.listWidget.itemWidget(previous)
if widget is not None:
widget.set_not_selected()
def reload(self, model):
"""Reload the data of the Popup Completer, and restart the state."""
self.listWidget.clear()
self.add_help()
for item in model:
self.listWidget.addItem(item[0])
self.listWidget.setItemWidget(item[0], item[1])
self.listWidget.setCurrentRow(8)
def clear(self):
"""Remove all the items of the list (deleted), and reload the help."""
self.listWidget.clear()
def refresh(self, model, has_text=True):
"""Refresh the list when the user search for some word."""
self.listWidget.clear()
if not has_text:
self.add_help()
for item in model:
self.listWidget.addItem(item[0])
self.listWidget.setItemWidget(item[0], item[1])
if model:
self.listWidget.setCurrentItem(model[0][0])
else:
self.add_no_found()
def fetch_more(self, model):
"""Add more items to the list on user scroll."""
for item in model:
self.listWidget.addItem(item[0])
self.listWidget.setItemWidget(item[0], item[1])
def add_no_found(self):
"""Load no results found message"""
noFoundItem = self._create_help_item(resources.IMAGES['delete'],
translations.TR_NO_RESULTS)
self.listWidget.addItem(noFoundItem)
def add_help(self):
#Load help
fileItem = self._create_help_item(resources.IMAGES['locate-file'],
translations.TR_ONLY_FILES)
self.listWidget.addItem(fileItem)
classItem = self._create_help_item(resources.IMAGES['locate-class'],
translations.TR_ONLY_CLASSES)
self.listWidget.addItem(classItem)
methodItem = self._create_help_item(
resources.IMAGES['locate-function'], translations.TR_ONLY_METHODS)
self.listWidget.addItem(methodItem)
attributeItem = self._create_help_item(
resources.IMAGES['locate-attributes'],
translations.TR_ONLY_ATRIBUTES)
self.listWidget.addItem(attributeItem)
thisFileItem = self._create_help_item(
resources.IMAGES['locate-on-this-file'],
translations.TR_ONLY_CLASSES_METHODS)
self.listWidget.addItem(thisFileItem)
tabsItem = self._create_help_item(resources.IMAGES['locate-tab'],
translations.TR_ONLY_CURRENT_TABS)
self.listWidget.addItem(tabsItem)
lineItem = self._create_help_item(resources.IMAGES['locate-line'],
translations.TR_GO_TO_LINE)
self.listWidget.addItem(lineItem)
nonPythonItem = self._create_help_item(
resources.IMAGES['locate-nonpython'],
translations.TR_ONLY_NON_PYTHON)
self.listWidget.addItem(nonPythonItem)
def _create_help_item(self, image, text):
Item = QListWidgetItem(QIcon(image), text)
font = Item.font()
font.setBold(True)
Item.setSizeHint(QSize(20, 30))
Item.setBackground(QBrush(Qt.lightGray))
Item.setForeground(QBrush(Qt.black))
Item.setFont(font)
return Item
class NotebookListDialog(QDialog):
""" Functions to display, create, remove, modify notebookList """
def __init__(self, parent=None):
super(NotebookListDialog, self).__init__(parent)
self.notebookList = QListWidget()
self.moveUp = QPushButton('<<')
self.moveDown = QPushButton('>>')
self.add = QPushButton('Add')
self.remove = QPushButton('Remove')
self.buttonBox = QDialogButtonBox(QDialogButtonBox.Ok
| QDialogButtonBox.Cancel)
self.buttonBox.button(QDialogButtonBox.Ok).setEnabled(False)
layout = QGridLayout()
layout.addWidget(self.notebookList, 0, 0, 4, 6)
layout.addWidget(self.moveUp, 1, 6)
layout.addWidget(self.moveDown, 2, 6)
layout.addWidget(self.add, 4, 0)
layout.addWidget(self.remove, 4, 1)
layout.addWidget(self.buttonBox, 4, 5, 1, 2)
self.setLayout(layout)
self.notebookList.setItemDelegate(ListDelegate(self.notebookList))
self.notebookList.currentRowChanged.connect(self.updateUi)
self.add.clicked.connect(self.actionAdd)
self.remove.clicked.connect(self.actionRemove)
self.moveUp.clicked.connect(self.moveItemUp)
self.moveDown.clicked.connect(self.moveItemDown)
self.buttonBox.accepted.connect(self.accept)
self.buttonBox.rejected.connect(self.reject)
self.initList()
def initList(self):
self.notebookList.clear()
notebooks = Mikibook.read()
for nb in notebooks:
item = QListWidgetItem()
item.setData(Qt.DisplayRole, nb[0])
item.setData(Qt.UserRole, nb[1])
self.notebookList.addItem(item)
self.updateUi(len(notebooks) != 0)
self.notebookList.setCurrentRow(0)
# QListWidgetItem(nb, self.notebookList)
def updateUi(self, row):
flag = (row != -1)
self.buttonBox.button(QDialogButtonBox.Ok).setEnabled(flag)
self.remove.setEnabled(flag)
self.moveUp.setEnabled(flag)
self.moveDown.setEnabled(flag)
def actionAdd(self):
Mikibook.create()
self.initList()
count = self.notebookList.count()
self.notebookList.setCurrentRow(count - 1)
def actionRemove(self):
item = self.notebookList.currentItem()
row = self.notebookList.currentRow()
name = item.data(Qt.DisplayRole)
path = item.data(Qt.UserRole)
self.notebookList.takeItem(row)
Mikibook.remove(name, path)
def moveItemUp(self):
item = self.notebookList.currentItem()
row = self.notebookList.currentRow()
if row != 0:
# self.notebookList.removeItemWidget(item)
self.notebookList.takeItem(row)
self.notebookList.insertItem(row - 1, item)
self.notebookList.setCurrentRow(row - 1)
def moveItemDown(self):
item = self.notebookList.currentItem()
row = self.notebookList.currentRow()
count = self.notebookList.count()
if row != count - 1:
self.notebookList.takeItem(row)
self.notebookList.insertItem(row + 1, item)
self.notebookList.setCurrentRow(row + 1)
def accept(self):
notebookPath = self.notebookList.currentItem().data(Qt.UserRole)
notebookName = self.notebookList.currentItem().data(Qt.DisplayRole)
settings = Setting([[notebookName, notebookPath]])
window = mikidown.MikiWindow(settings)
window.show()
count = self.notebookList.count()
notebooks = []
for i in range(count):
name = self.notebookList.item(i).data(Qt.DisplayRole)
path = self.notebookList.item(i).data(Qt.UserRole)
notebooks.append([name, path])
Mikibook.write(notebooks)
QDialog.accept(self)
class CheckList(HelpedWidget):
def __init__(self, model, label="", help_link=""):
HelpedWidget.__init__(self, "", help_link)
layout = QVBoxLayout()
widget = QWidget()
widget.setLayout(layout)
self.checkAllButton = QToolButton()
self.checkAllButton.setIcon(resourceIcon("checked"))
self.checkAllButton.setIconSize(QSize(16, 16))
self.checkAllButton.setToolButtonStyle(Qt.ToolButtonIconOnly)
self.checkAllButton.setAutoRaise(True)
self.checkAllButton.setToolTip("Select all")
self.uncheckAllButton = QToolButton()
self.uncheckAllButton.setIcon(resourceIcon("notchecked"))
self.uncheckAllButton.setIconSize(QSize(16, 16))
self.uncheckAllButton.setToolButtonStyle(Qt.ToolButtonIconOnly)
self.uncheckAllButton.setAutoRaise(True)
self.uncheckAllButton.setToolTip("Unselect all")
self.list = QListWidget()
self.list.setContextMenuPolicy(Qt.CustomContextMenu)
self.list.setSelectionMode(QAbstractItemView.ExtendedSelection)
self.search_box = SearchBox()
check_button_layout = QHBoxLayout()
check_button_layout.setMargin(0)
check_button_layout.setSpacing(0)
check_button_layout.addWidget(QLabel(label))
check_button_layout.addStretch(1)
check_button_layout.addWidget(self.checkAllButton)
check_button_layout.addWidget(self.uncheckAllButton)
layout.addLayout(check_button_layout)
layout.addWidget(self.list)
layout.addWidget(self.search_box)
self.addWidget(widget)
self.connect(self.checkAllButton, SIGNAL('clicked()'), self.checkAll)
self.connect(self.uncheckAllButton, SIGNAL('clicked()'),
self.uncheckAll)
self.connect(self.list, SIGNAL('itemChanged(QListWidgetItem*)'),
self.itemChanged)
self.search_box.filterChanged.connect(self.filterList)
# self.connect(self.search_box, SIGNAL('filterChanged(str)'), self.filterList)
self.connect(self.list, SIGNAL('customContextMenuRequested(QPoint)'),
self.showContextMenu)
assert isinstance(model, (SelectableModelMixin, ListModelMixin))
self.model = model
self.model.observable().attach(
SelectableModelMixin.SELECTION_CHANGED_EVENT, self.modelChanged)
self.model.observable().attach(ListModelMixin.LIST_CHANGED_EVENT,
self.modelChanged)
self.modelChanged()
def itemChanged(self, item):
"""@type item: QListWidgetItem"""
if item.checkState() == Qt.Checked:
self.model.selectValue(str(item.text()))
elif item.checkState() == Qt.Unchecked:
self.model.unselectValue(str(item.text()))
else:
raise AssertionError("Unhandled checkstate!")
def modelChanged(self):
self.list.clear()
items = self.model.getList()
for item in items:
list_item = QListWidgetItem(item)
list_item.setFlags(list_item.flags() | Qt.ItemIsUserCheckable)
if self.model.isValueSelected(item):
list_item.setCheckState(Qt.Checked)
else:
list_item.setCheckState(Qt.Unchecked)
self.list.addItem(list_item)
self.filterList(self.search_box.filter())
def setSelectionEnabled(self, enabled):
self.setEnabled(enabled)
self.checkAllButton.setEnabled(enabled)
self.uncheckAllButton.setEnabled(enabled)
def filterList(self, filter):
filter = filter.lower()
for index in range(0, self.list.count()):
item = self.list.item(index)
text = str(item.text()).lower()
if filter == "":
item.setHidden(False)
elif filter in text:
item.setHidden(False)
else:
item.setHidden(True)
def checkAll(self):
self.model.selectAll()
def uncheckAll(self):
self.model.unselectAll()
def checkSelected(self):
items = []
for item in self.list.selectedItems():
items.append(str(item.text()))
for item in items:
self.model.selectValue(item)
def uncheckSelected(self):
items = []
for item in self.list.selectedItems():
items.append(str(item.text()))
for item in items:
self.model.unselectValue(item)
def showContextMenu(self, point):
p = self.list.mapToGlobal(point)
menu = QMenu()
check_selected = menu.addAction("Check selected")
uncheck_selected = menu.addAction("Uncheck selected")
menu.addSeparator()
clear_selection = menu.addAction("Clear selection")
selected_item = menu.exec_(p)
if selected_item == check_selected:
self.checkSelected()
elif selected_item == uncheck_selected:
self.uncheckSelected()
elif selected_item == clear_selection:
self.list.clearSelection()
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 ErrorsWidget(QDialog):
###############################################################################
# ERRORS WIDGET SIGNALS
###############################################################################
"""
pep8Activated(bool)
lintActivated(bool)
"""
###############################################################################
def __init__(self, parent=None):
super(ErrorsWidget, self).__init__(parent, Qt.WindowStaysOnTopHint)
self.pep8 = None
self._outRefresh = True
vbox = QVBoxLayout(self)
self.listErrors = QListWidget()
self.listErrors.setSortingEnabled(True)
self.listPep8 = QListWidget()
self.listPep8.setSortingEnabled(True)
hbox_lint = QHBoxLayout()
if settings.FIND_ERRORS:
self.btn_lint_activate = QPushButton(self.tr("Lint: ON"))
else:
self.btn_lint_activate = QPushButton(self.tr("Lint: OFF"))
self.errorsLabel = QLabel(self.tr("Static Errors: %s") % 0)
hbox_lint.addWidget(self.errorsLabel)
hbox_lint.addSpacerItem(QSpacerItem(1, 0, QSizePolicy.Expanding))
hbox_lint.addWidget(self.btn_lint_activate)
vbox.addLayout(hbox_lint)
vbox.addWidget(self.listErrors)
hbox_pep8 = QHBoxLayout()
if settings.CHECK_STYLE:
self.btn_pep8_activate = QPushButton(self.tr("PEP8: ON"))
else:
self.btn_pep8_activate = QPushButton(self.tr("PEP8: OFF"))
self.pep8Label = QLabel(self.tr("PEP8 Errors: %s") % 0)
hbox_pep8.addWidget(self.pep8Label)
hbox_pep8.addSpacerItem(QSpacerItem(1, 0, QSizePolicy.Expanding))
hbox_pep8.addWidget(self.btn_pep8_activate)
vbox.addLayout(hbox_pep8)
vbox.addWidget(self.listPep8)
self.connect(self.listErrors, SIGNAL("itemSelectionChanged()"),
self.errors_selected)
self.connect(self.listPep8, SIGNAL("itemSelectionChanged()"),
self.pep8_selected)
self.connect(self.btn_lint_activate, SIGNAL("clicked()"),
self._turn_on_off_lint)
self.connect(self.btn_pep8_activate, SIGNAL("clicked()"),
self._turn_on_off_pep8)
IDE.register_service('tab_errors', self)
ExplorerContainer.register_tab(translations.TR_TAB_ERRORS, self)
def install_tab(self):
ide = IDE.get_service('ide')
self.connect(ide, SIGNAL("goingDown()"), self.close)
def _turn_on_off_lint(self):
"""Change the status of the lint checker state."""
settings.FIND_ERRORS = not settings.FIND_ERRORS
if settings.FIND_ERRORS:
self.btn_lint_activate.setText(self.tr("Lint: ON"))
self.listErrors.show()
else:
self.btn_lint_activate.setText(self.tr("Lint: OFF"))
self.listErrors.hide()
self.emit(SIGNAL("lintActivated(bool)"), settings.FIND_ERRORS)
def _turn_on_off_pep8(self):
"""Change the status of the lint checker state."""
settings.CHECK_STYLE = not settings.CHECK_STYLE
if settings.CHECK_STYLE:
self.btn_pep8_activate.setText(self.tr("PEP8: ON"))
self.listPep8.show()
else:
self.btn_pep8_activate.setText(self.tr("PEP8: OFF"))
self.listPep8.hide()
self.emit(SIGNAL("pep8Activated(bool)"), settings.CHECK_STYLE)
def errors_selected(self):
main_container = IDE.get_service('main_container')
if main_container:
editorWidget = main_container.get_current_editor()
if editorWidget and self._outRefresh:
lineno = int(self.listErrors.currentItem().data(Qt.UserRole))
editorWidget.jump_to_line(lineno)
editorWidget.setFocus()
def pep8_selected(self):
main_container = IDE.get_service('main_container')
if main_container:
editorWidget = main_container.get_current_editor()
if editorWidget and self._outRefresh:
lineno = int(self.listPep8.currentItem().data(Qt.UserRole))
editorWidget.jump_to_line(lineno)
editorWidget.setFocus()
def refresh_pep8_list(self, pep8):
self._outRefresh = False
self.listPep8.clear()
for lineno in pep8:
linenostr = 'L%s\t' % str(lineno + 1)
for data in pep8[lineno]:
item = QListWidgetItem(linenostr + data.split('\n')[0])
item.setToolTip(linenostr + data.split('\n')[0])
item.setData(Qt.UserRole, lineno)
self.listPep8.addItem(item)
self.pep8Label.setText(self.tr("PEP8 Errors: %s") % len(pep8))
self._outRefresh = True
def refresh_error_list(self, errors):
self._outRefresh = False
self.listErrors.clear()
for lineno in errors:
linenostr = 'L%s\t' % str(lineno + 1)
for data in errors[lineno]:
item = QListWidgetItem(linenostr + data)
item.setToolTip(linenostr + data)
item.setData(Qt.UserRole, lineno)
self.listErrors.addItem(item)
self.errorsLabel.setText(self.tr("Static Errors: %s") % len(errors))
self._outRefresh = True
def clear(self):
"""
Clear the widget
"""
self.listErrors.clear()
self.listPep8.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 SessionsManager(QDialog):
"""Session Manager, to load different configurations of ninja."""
def __init__(self, parent=None):
super(SessionsManager, self).__init__(parent, Qt.Dialog)
self._ide = parent
self.setWindowTitle(translations.TR_SESSIONS_TITLE)
self.setMinimumWidth(400)
vbox = QVBoxLayout(self)
vbox.addWidget(QLabel(translations.TR_SESSIONS_DIALOG_BODY))
self.sessionList = QListWidget()
self.sessionList.addItems([key for key in settings.SESSIONS])
self.sessionList.setCurrentRow(0)
self.contentList = QListWidget()
self.btnDelete = QPushButton(translations.TR_SESSIONS_BTN_DELETE)
self.btnDelete.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.btnUpdate = QPushButton(translations.TR_SESSIONS_BTN_UPDATE)
self.btnUpdate.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.btnCreate = QPushButton(translations.TR_SESSIONS_BTN_CREATE)
self.btnCreate.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.btnOpen = QPushButton(translations.TR_SESSIONS_BTN_ACTIVATE)
self.btnOpen.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.btnOpen.setDefault(True)
hbox = QHBoxLayout()
hbox.addWidget(self.btnDelete)
hbox.addWidget(self.btnUpdate)
hbox.addWidget(self.btnCreate)
hbox.addWidget(self.btnOpen)
vbox.addWidget(self.sessionList)
vbox.addWidget(self.contentList)
vbox.addLayout(hbox)
self.connect(self.sessionList, SIGNAL("itemSelectionChanged()"),
self.load_session_content)
self.connect(self.btnOpen, SIGNAL("clicked()"), self.open_session)
self.connect(self.btnUpdate, SIGNAL("clicked()"), self.save_session)
self.connect(self.btnCreate, SIGNAL("clicked()"), self.create_session)
self.connect(self.btnDelete, SIGNAL("clicked()"), self.delete_session)
self.load_session_content()
def load_session_content(self):
"""Load the selected session, replacing the current session."""
item = self.sessionList.currentItem()
self.contentList.clear()
if item is not None:
key = item.text()
files = [self.tr('Files:')] + \
[file[0] for file in settings.SESSIONS[key][0]]
projects = [self.tr('Projects:')] + settings.SESSIONS[key][1]
content = files + projects
self.contentList.addItems(content)
def create_session(self):
"""Create a new Session."""
sessionInfo = QInputDialog.getText(
None, translations.TR_SESSIONS_CREATE_TITLE,
translations.TR_SESSIONS_CREATE_BODY)
if sessionInfo[1]:
sessionName = sessionInfo[0]
if not sessionName or sessionName in settings.SESSIONS:
QMessageBox.information(self,
translations.TR_SESSIONS_MESSAGE_TITLE,
translations.TR_SESSIONS_MESSAGE_BODY)
return
SessionsManager.save_session_data(sessionName, self._ide)
self._ide.Session = sessionName
self.close()
@classmethod
def save_session_data(cls, sessionName, ide):
"""Save the updates from a session."""
openedFiles = ide.filesystem.get_files()
files_info = []
for path in openedFiles:
editable = ide.get_or_create_editable(path)
if editable.is_dirty:
stat_value = 0
else:
stat_value = os.stat(path).st_mtime
files_info.append(
[path, editable.editor.get_cursor_position(), stat_value])
projects_obj = ide.filesystem.get_projects()
projects = [projects_obj[proj].path for proj in projects_obj]
settings.SESSIONS[sessionName] = [files_info, projects]
qsettings = ide.data_settings()
qsettings.setValue('ide/sessions', settings.SESSIONS)
def save_session(self):
if self.sessionList.currentItem():
sessionName = self.sessionList.currentItem().text()
SessionsManager.save_session_data(sessionName, self._ide)
self._ide.show_message(
translations.TR_SESSIONS_UPDATED_NOTIF %
{'session': sessionName}, 2000)
self.load_session_content()
def open_session(self):
if self.sessionList.currentItem():
key = self.sessionList.currentItem().text()
self._load_session_data(key)
self._ide.Session = key
self.close()
def delete_session(self):
if self.sessionList.currentItem():
key = self.sessionList.currentItem().text()
settings.SESSIONS.pop(key)
self.sessionList.takeItem(self.sessionList.currentRow())
self.contentList.clear()
qsettings = self._ide.data_settings()
qsettings.setValue('ide/sessions', settings.SESSIONS)
def _load_session_data(self, key):
"""Activate the selected session, closing the current files/projects"""
main_container = self._ide.get_service('main_container')
projects_explorer = self._ide.get_service('projects_explorer')
if projects_explorer and main_container:
projects_explorer.close_opened_projects()
for fileData in settings.SESSIONS[key][0]:
path, line, stat_value = fileData
if file_manager.file_exists(path):
mtime = os.stat(path).st_mtime
ignore_checkers = (mtime == stat_value)
main_container.open_file(path,
line,
ignore_checkers=ignore_checkers)
if projects_explorer:
projects_explorer.load_session_projects(
settings.SESSIONS[key][1])
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 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 GroupsModify(PyDialog):
"""
+--------------------------+
| Groups : Modify |
+--------------------------+
| |
| Name xxx Default |
| Coords xxx Default |
| Elements xxx Default |
| Color xxx Default |
| Add xxx Add |
| Remove xxx Remove |
| |
| Set OK Cancel |
+--------------------------+
"""
def __init__(self, data, win_parent=None, group_active='main'):
PyDialog.__init__(self, data, win_parent)
self.set_font_size(data['font_size'])
self._updated_groups = False
#self.out_data = data
#print(data)
keys = []
self.keys = [
group.name for key, group in sorted(iteritems(data))
if isinstance(key, int)
]
self.active_key = self.keys.index(group_active)
group_obj = data[self.active_key]
name = group_obj.name
self.imain = 0
self.nrows = len(self.keys)
self._default_name = group_obj.name
self._default_elements = group_obj.element_str
self.elements_pound = group_obj.elements_pound
self.table = QListWidget(parent=None)
self.table.clear()
self.table.addItems(self.keys)
self.setWindowTitle('Groups: Modify')
self.create_widgets()
self.create_layout()
self.set_connections()
self.on_set_as_main()
def create_widgets(self):
"""creates the menu objects"""
# Name
self.name = QLabel("Name:")
self.name_set = QPushButton("Set")
self.name_edit = QLineEdit(str(self._default_name).strip())
self.name_button = QPushButton("Default")
# elements
self.elements = QLabel("Element IDs:")
self.elements_edit = QLineEdit(str(self._default_elements).strip())
self.elements_button = QPushButton("Default")
# add
self.add = QLabel("Add Elements:")
self.add_edit = QElementEdit(self, str(''))
self.add_button = QPushButton("Add")
# remove
self.remove = QLabel("Remove Elements:")
self.remove_edit = QElementEdit(self, str(''))
self.remove_button = QPushButton("Remove")
# applies a unique implicitly
self.eids = parse_patran_syntax(str(self._default_elements),
pound=self.elements_pound)
# closing
#self.apply_button = QPushButton("Apply")
self.ok_button = QPushButton("Close")
#self.cancel_button = QPushButton("Cancel")
self.set_as_main_button = QPushButton("Set As Main")
self.create_group_button = QPushButton('Create New Group')
self.delete_group_button = QPushButton('Delete Group')
self.name.setEnabled(False)
self.name_set.setEnabled(False)
self.name_edit.setEnabled(False)
self.name_button.setEnabled(False)
self.elements.setEnabled(False)
self.elements_button.setEnabled(False)
self.elements_edit.setEnabled(False)
self.add.setEnabled(False)
self.add_button.setEnabled(False)
self.add_edit.setEnabled(False)
self.remove.setEnabled(False)
self.remove_button.setEnabled(False)
self.remove_edit.setEnabled(False)
self.delete_group_button.setEnabled(False)
#self.apply_button.setEnabled(False)
#self.ok_button.setEnabled(False)
def create_layout(self):
"""displays the menu objects"""
grid = QGridLayout()
grid.addWidget(self.name, 0, 0)
grid.addWidget(self.name_edit, 0, 1)
grid.addWidget(self.name_set, 0, 2)
grid.addWidget(self.name_button, 0, 3)
grid.addWidget(self.elements, 2, 0)
grid.addWidget(self.elements_edit, 2, 1)
grid.addWidget(self.elements_button, 2, 2)
grid.addWidget(self.add, 4, 0)
grid.addWidget(self.add_edit, 4, 1)
grid.addWidget(self.add_button, 4, 2)
grid.addWidget(self.remove, 5, 0)
grid.addWidget(self.remove_edit, 5, 1)
grid.addWidget(self.remove_button, 5, 2)
ok_cancel_box = QHBoxLayout()
#ok_cancel_box.addWidget(self.apply_button)
ok_cancel_box.addWidget(self.ok_button)
#ok_cancel_box.addWidget(self.cancel_button)
main_create_delete = QHBoxLayout()
main_create_delete.addWidget(self.set_as_main_button)
main_create_delete.addWidget(self.create_group_button)
main_create_delete.addWidget(self.delete_group_button)
vbox = QVBoxLayout()
vbox.addWidget(self.table)
vbox.addLayout(grid)
vbox.addLayout(main_create_delete)
vbox.addStretch()
vbox.addLayout(ok_cancel_box)
self.setLayout(vbox)
def on_set_name(self):
name = str(self.name_edit.text()).strip()
if name not in self.keys:
self.name_edit.setStyleSheet("QLineEdit{background: white;}")
group = self.out_data[self.active_key]
group.name = name
self.keys[self.active_key] = name
self.recreate_table()
elif name != self.keys[self.active_key]:
self.name_edit.setStyleSheet("QLineEdit{background: red;}")
elif name == self.keys[self.active_key]:
self.name_edit.setStyleSheet("QLineEdit{background: white;}")
def set_connections(self):
self.name_set.clicked.connect(self.on_set_name)
self.name_button.clicked.connect(self.on_default_name)
self.elements_button.clicked.connect(self.on_default_elements)
self.add_button.clicked.connect(self.on_add)
self.remove_button.clicked.connect(self.on_remove)
self.table.itemClicked.connect(self.on_update_active_key)
self.ok_button.clicked.connect(self.on_ok)
self.set_as_main_button.clicked.connect(self.on_set_as_main)
self.create_group_button.clicked.connect(self.on_create_group)
self.delete_group_button.clicked.connect(self.on_delete_group)
def on_create_group(self):
irow = self.nrows
new_key = 'Group %s' % irow
while new_key in self.keys:
irow += 1
new_key = 'Group %s' % irow
irow = self.nrows
self.keys.append(new_key)
group = Group(new_key,
element_str='',
elements_pound=self.elements_pound,
editable=True)
self.out_data[irow] = group
self.table.reset()
self.table.addItems(self.keys)
self.nrows += 1
#----------------------------------
# update internal parameters
#self.out_data = items
if self.imain > self.active_key:
self.imain += 1
#make the new group the default
self.active_key = self.nrows - 1
self.keys = [
group.name for key, group in sorted(iteritems(self.out_data))
if isinstance(key, int)
]
self.recreate_table()
def recreate_table(self):
# update gui
self.table.clear()
self.table.addItems(self.keys)
item = self.table.item(self.imain)
bold = QtGui.QFont()
bold.setBold(True)
bold.setItalic(True)
item.setFont(bold)
self.table.update()
# update key
name = self.keys[self.active_key]
self._update_active_key_by_name(name)
def on_delete_group(self):
if self.active_key == 0:
return
#self.deleted_groups.add(self.imain)
items = {}
j = 0
for i, key in sorted(iteritems(self.out_data)):
if isinstance(i, int):
continue
if i != self.active_key:
items[j] = key
j += 1
# update internal parameters
self.out_data = items
if self.imain >= self.active_key:
self.imain = max(0, self.imain - 1)
self.active_key = max(0, self.active_key - 1)
self.nrows -= 1
self.keys = [group.name for key, group in sorted(iteritems(items))]
self.recreate_table()
# update key
name = self.keys[self.active_key]
self._update_active_key_by_name(name)
def on_set_as_main(self):
bold = QtGui.QFont()
bold.setBold(True)
bold.setItalic(True)
normal = QtGui.QFont()
normal.setBold(False)
normal.setItalic(False)
obj = self.table.item(self.imain)
obj.setFont(normal)
self.imain = self.active_key
obj = self.table.item(self.imain)
obj.setFont(bold)
group = self.out_data[self.imain]
self._default_elements = group.element_str
self._default_name = group.name
self.on_update_main()
def on_update_main(self):
"""adds/removes the elements to the main actor when add/remove is pressed"""
group = self.out_data[self.imain]
if self._default_name == group.name and self.win_parent is not None:
# we're not testing the menu
self.win_parent.post_group(group)
def closeEvent(self, event):
self.out_data['close'] = True
event.accept()
def on_add(self):
eids, is_valid = self.check_patran_syntax(self.add_edit,
pound=self.elements_pound)
#adict, is_valid = self.check_patran_syntax_dict(self.add_edit)
if not is_valid:
#self.add_edit.setStyleSheet("QLineEdit{background: red;}")
return
self.eids = unique(hstack([self.eids, eids]))
#self.eids = _add(adict, ['e', 'elem', 'element'], self.eids)
#self.cids = _add(adict, ['c', 'cid', 'coord'], self.cids)
self._apply_cids_eids()
self.add_edit.clear()
self.add_edit.setStyleSheet("QLineEdit{background: white;}")
self.on_update_main()
def _apply_cids_eids(self):
#ctext = _get_collapsed_text(self.cids)
etext = _get_collapsed_text(self.eids)
#self.coords_edit.setText(str(ctext.lstrip()))
self.elements_edit.setText(str(etext.lstrip()))
self.out_data[self.active_key].element_ids = self.eids
def on_remove(self):
eids, is_valid = self.check_patran_syntax(self.remove_edit)
#adict, is_valid = self.check_patran_syntax_dict(self.remove_edit)
if not is_valid:
#self.remove_edit.setStyleSheet("QLineEdit{background: red;}")
return
#self.eids = _remove(adict, ['e', 'elem', 'element'], self.eids)
#self.cids = _remove(adict, ['c', 'cid', 'coord'], self.cids)
self.eids = setdiff1d(self.eids, eids)
self._apply_cids_eids()
self.remove_edit.clear()
self.remove_edit.setStyleSheet("QLineEdit{background: white;}")
self.on_update_main()
def on_default_name(self):
name = str(self._default_name)
self.name_edit.setText(name)
self.name_edit.setStyleSheet("QLineEdit{background: white;}")
def on_default_elements(self):
element_str = str(self._default_elements)
self.elements_edit.setText(element_str)
self.elements_edit.setStyleSheet("QLineEdit{background: white;}")
group = self.out_data[self.active_key]
group.element_str = element_str
def check_name(self, cell):
cell_value = cell.text()
try:
text = str(cell_value).strip()
except UnicodeEncodeError:
cell.setStyleSheet("QLineEdit{background: red;}")
return None, False
if len(text):
cell.setStyleSheet("QLineEdit{background: white;}")
return text, True
else:
cell.setStyleSheet("QLineEdit{background: red;}")
return None, False
if self._default_name != text:
if self._default_name in self.out_data:
cell.setStyleSheet("QLineEdit{background: white;}")
return text, True
else:
cell.setStyleSheet("QLineEdit{background: red;}")
return None, False
def on_validate(self):
name, flag0 = self.check_name(self.name_edit)
elements, flag1 = self.check_patran_syntax(self.elements_edit,
pound=self.elements_pound)
#coords_value, flag2 = self.check_patran_syntax(self.coords_edit,
#pound=self.coords_pound)
if all([flag0, flag1]):
self._default_name = name
self._default_elements = self.eids
self.out_data['clicked_ok'] = True
self.out_data['close'] = True
return True
return False
def on_apply(self, force=False):
passed = self.on_validate()
if passed or force:
self.win_parent._apply_modify_groups(self.out_data)
return passed
def on_ok(self):
passed = self.on_apply()
if passed:
self.close()
#self.destroy()
def on_cancel(self):
self.out_data['close'] = True
self.close()
def on_update_active_key(self, index):
self.update_active_key(index)
#str(index.text())
def update_active_key(self, index):
#old_obj = self.out_data[self.imain]
name = str(index.text())
self._update_active_key_by_name(name)
def _update_active_key_by_name(self, name):
if name in self.keys:
self.active_key = self.keys.index(name)
else:
# we (hopefully) just removed a row
#self.active_key = self.keys[self.active_key]
pass
self.name_edit.setText(name)
obj = self.out_data[self.active_key]
self.eids = parse_patran_syntax(obj.element_str,
pound=obj.elements_pound)
self._default_elements = obj.element_str
self._default_name = name
self._apply_cids_eids()
self.set_as_main_button.setEnabled(True)
if name in ['main', 'anti-main']:
self.name.setEnabled(False)
self.name_set.setEnabled(False)
self.name_edit.setEnabled(False)
self.name_button.setEnabled(False)
self.elements.setEnabled(False)
self.elements_button.setEnabled(False)
self.elements_edit.setEnabled(False)
self.add.setEnabled(False)
self.add_button.setEnabled(False)
self.add_edit.setEnabled(False)
self.remove.setEnabled(False)
self.remove_button.setEnabled(False)
self.remove_edit.setEnabled(False)
self.delete_group_button.setEnabled(False)
if name == 'anti-main':
self.set_as_main_button.setEnabled(False)
#self.apply_button.setEnabled(False)
#self.ok_button.setEnabled(False)
else:
self.name.setEnabled(True)
self.name_set.setEnabled(True)
self.name_edit.setEnabled(True)
self.name_button.setEnabled(True)
self.elements.setEnabled(True)
self.elements_button.setEnabled(True)
self.add.setEnabled(True)
self.add_button.setEnabled(True)
self.add_edit.setEnabled(True)
self.remove.setEnabled(True)
self.remove_button.setEnabled(True)
self.remove_edit.setEnabled(True)
self.delete_group_button.setEnabled(True)
class ProfilesLoader(QDialog):
def __init__(self, load_func, create_func, save_func,
profiles, parent=None):
QDialog.__init__(self, parent, Qt.Dialog)
self.setWindowTitle(self.tr("Profile Manager"))
self.setMinimumWidth(400)
self._profiles = profiles
self.load_function = load_func
self.create_function = create_func
self.save_function = save_func
self.ide = parent
vbox = QVBoxLayout(self)
vbox.addWidget(QLabel(self.tr("Save your opened files and projects "
"into a profile and change really quick\n"
"between projects and files sessions.\n"
"This allows you to save your working environment, "
"keep working in another\nproject and then go back "
"exactly where you left.")))
self.profileList = QListWidget()
self.profileList.addItems([key for key in profiles])
self.profileList.setCurrentRow(0)
self.contentList = QListWidget()
self.btnDelete = QPushButton(self.tr("Delete Profile"))
self.btnDelete.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.btnUpdate = QPushButton(self.tr("Update Profile"))
self.btnUpdate.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.btnCreate = QPushButton(self.tr("Create New Profile"))
self.btnCreate.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.btnOpen = QPushButton(self.tr("Open Profile"))
self.btnOpen.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.btnOpen.setDefault(True)
hbox = QHBoxLayout()
hbox.addWidget(self.btnDelete)
hbox.addWidget(self.btnUpdate)
hbox.addWidget(self.btnCreate)
hbox.addWidget(self.btnOpen)
vbox.addWidget(self.profileList)
vbox.addWidget(self.contentList)
vbox.addLayout(hbox)
self.connect(self.profileList, SIGNAL("itemSelectionChanged()"),
self.load_profile_content)
self.connect(self.btnOpen, SIGNAL("clicked()"), self.open_profile)
self.connect(self.btnUpdate, SIGNAL("clicked()"), self.save_profile)
self.connect(self.btnCreate, SIGNAL("clicked()"), self.create_profile)
self.connect(self.btnDelete, SIGNAL("clicked()"), self.delete_profile)
def load_profile_content(self):
item = self.profileList.currentItem()
self.contentList.clear()
if item is not None:
key = unicode(item.text())
files = [self.tr('Files:')] + \
[file[0] for file in self._profiles[key][0]]
projects = [self.tr('Projects:')] + self._profiles[key][1]
content = files + projects
self.contentList.addItems(content)
def create_profile(self):
profileName = self.create_function()
self.ide.Profile = profileName
self.close()
def save_profile(self):
if self.profileList.currentItem():
profileName = unicode(self.profileList.currentItem().text())
self.save_function(profileName)
self.ide.show_status_message(self.tr("Profile %1 Updated!").arg(
profileName))
self.load_profile_content()
def open_profile(self):
if self.profileList.currentItem():
key = unicode(self.profileList.currentItem().text())
self.load_function(key)
self.ide.Profile = key
self.close()
def delete_profile(self):
if self.profileList.currentItem():
key = unicode(self.profileList.currentItem().text())
self._profiles.pop(key)
self.profileList.takeItem(self.profileList.currentRow())
self.contentList.clear()
class ShowPresets(QDialog):
def __init__(self, parent=None):
super(ShowPresets, self).__init__(parent)
self.original_presets_file = '/usr/share/ffmulticonverter/presets.xml'
self.config_folder = os.getenv('HOME') + '/.config/ffmulticonverter/'
self.current_presets_file = self.config_folder + 'presets.xml'
self.presListWidget = QListWidget()
labelLabel = QLabel(self.tr('Preset label'))
self.labelLineEdit = QLineEdit()
self.labelLineEdit.setReadOnly(True)
commandLabel = QLabel(self.tr('Preset command line parameters'))
self.commandLineEdit = QLineEdit()
self.commandLineEdit.setReadOnly(True)
extLabel = QLabel(self.tr('Output file extension'))
self.extLineEdit = QLineEdit()
self.extLineEdit.setReadOnly(True)
addButton = QPushButton(self.tr('Add'))
self.deleteButton = QPushButton(self.tr('Delete'))
self.delete_allButton = QPushButton(self.tr('Delete all'))
self.editButton = QPushButton(self.tr('Edit'))
okButton = QPushButton(self.tr('OK'))
okButton.setDefault(True)
spc1 = QSpacerItem(40, 20, QSizePolicy.Expanding, QSizePolicy.Minimum)
spc2 = QSpacerItem(40, 20, QSizePolicy.Expanding, QSizePolicy.Minimum)
grid = pyqttools.add_to_grid(QGridLayout(),
[self.delete_allButton, addButton, spc1, None],
[self.deleteButton, self.editButton, spc2, okButton])
final_layout = pyqttools.add_to_layout(QVBoxLayout(),
self.presListWidget, labelLabel,
self.labelLineEdit, commandLabel,
self.commandLineEdit, extLabel,
self.extLineEdit, grid)
self.setLayout(final_layout)
okButton.clicked.connect(self.accept)
self.presListWidget.currentRowChanged.connect(self.show_preset)
addButton.clicked.connect(self.add_preset)
self.deleteButton.clicked.connect(self.delete_preset)
self.delete_allButton.clicked.connect(self.delete_all_presets)
self.editButton.clicked.connect(self.edit_preset)
self.resize(410, 410)
self.setWindowTitle(self.tr('Edit Presets'))
QTimer.singleShot(0, self.load_xml)
QTimer.singleShot(0, self.fill_presListWidget)
def load_xml(self):
"""Load xml tree and set xml root."""
try:
self.tree = etree.parse(self.current_presets_file)
except (etree.ParseError, IOError):
try:
self.tree = etree.parse(self.original_presets_file)
except IOError:
# when program is not installed
self.tree = etree.parse('../share/presets.xml')
if not os.path.exists(self.config_folder):
os.makedirs(self.config_folder)
self.root = self.tree.getroot()
def set_buttons_clear_lineEdits(self):
"""Enable or disable button's and clear lineEdits."""
enable = bool(self.presListWidget)
self.editButton.setEnabled(enable)
self.deleteButton.setEnabled(enable)
self.delete_allButton.setEnabled(enable)
if not enable:
self.labelLineEdit.clear()
self.commandLineEdit.clear()
self.extLineEdit.clear()
def fill_presListWidget(self):
"""Clear self.presListWidget and to it presets' tags."""
self.presListWidget.clear()
for i in sorted([y.tag for y in self.root]):
elem = self.root.find(i)
self.presListWidget.addItem(MyListItem(i, elem))
self.presListWidget.setCurrentRow(0)
self.set_buttons_clear_lineEdits()
def show_preset(self):
"""Fill LineEdits with current xml element's values."""
try:
xml_elem = self.presListWidget.currentItem().xml_element
except AttributeError:
return
self.labelLineEdit.setText(xml_elem[0].text)
self.commandLineEdit.setText(xml_elem[1].text)
self.commandLineEdit.home(False)
self.extLineEdit.setText(xml_elem[2].text)
def add_preset(self):
"""Open AddorEditPreset() dialog and add a preset xml root."""
dialog = AddorEditPreset(None, False, self)
if dialog.exec_():
element = etree.Element(dialog.name_text)
label = etree.Element('label')
label.text = dialog.label_text
command = etree.Element('params')
command.text = dialog.command_text
ext = etree.Element('extension')
ext.text = dialog.ext_text
category = etree.Element('category')
category.text = 'Scattered'
for num, elem in enumerate([label, command, ext, category]):
element.insert(num, elem)
index = sorted([i.tag for i in self.root] + [dialog.name_text])\
.index(dialog.name_text)
self.root.insert(index, element)
self.save_tree()
self.fill_presListWidget()
def delete_preset(self):
"""
Ask user wether he wants to delete the selected preset.
If so, delete the preset from xml root.
"""
try:
xml_elem = self.presListWidget.currentItem().xml_element
except AttributeError:
return
reply = QMessageBox.question(self, 'FF Multi Converter - ' + self.tr(
'Delete Preset'), self.tr('Are you sure that you want to delete '
'the %1 preset?').arg(xml_elem.tag),
QMessageBox.Yes|QMessageBox.Cancel)
if reply == QMessageBox.Yes:
self.root.remove(xml_elem)
self.save_tree()
self.fill_presListWidget()
def delete_all_presets(self):
"""
Ask user if he wants to delete all presets.
If so, clear xml root.
"""
reply = QMessageBox.question(self, 'FF Multi Converter - ' + self.tr(
'Delete Preset'), self.tr('Are you sure that you want to delete '
'all presets?'), QMessageBox.Yes|QMessageBox.Cancel)
if reply == QMessageBox.Yes:
self.root.clear()
self.save_tree()
self.fill_presListWidget()
def edit_preset(self):
"""Call the AddorEditPreset() dialog and update xml element's values."""
elem = self.presListWidget.currentItem().xml_element
dialog = AddorEditPreset(elem, True)
if dialog.exec_():
elem.tag = dialog.name_text
elem[0].text = dialog.label_text
elem[1].text = dialog.command_text
elem[2].text = dialog.ext_text
self.save_tree()
self.fill_presListWidget()
def save_tree(self):
"""Save xml tree."""
with open(self.current_presets_file, 'w') as _file:
try:
etree.ElementTree(self.root).write(_file)
except:
pass
def import_presets(self):
"""Import an xml tree."""
title = 'FF Multi Converter - Import'
reply = QMessageBox.question(self, title, self.tr('All current '
'presets will be deleted.\nAre you sure that you want to '
'continue?'), QMessageBox.Yes|QMessageBox.Cancel)
if reply == QMessageBox.Yes:
fname = QFileDialog.getOpenFileName(self, title)
if fname:
msg = 'Succesful import!'
try:
self.tree = etree.parse(fname)
except:
msg = 'Import failed!'
else:
self.root = self.tree.getroot()
self.save_tree()
QMessageBox.information(self, title, msg)
def export_presets(self):
"""Export the xml tree."""
fname = QFileDialog.getSaveFileName(self,
'FF Multi Converter - Export presets','.xml')
if fname:
self.load_xml()
with open(fname, 'w') as _file:
try:
etree.ElementTree(self.root).write(_file)
except:
pass
def reset(self):
"""Import the default xml tree."""
reply = QMessageBox.question(self, 'FF Multi Converter - ' + self.tr(
'Delete Preset'), self.tr('Are you sure that you want to restore '
'the default presets?'), QMessageBox.Yes|QMessageBox.Cancel)
if reply == QMessageBox.Yes:
if os.path.exists(self.current_presets_file):
os.remove(self.current_presets_file)
def accept(self):
"""
Save current xml element's values in order to be used from
main program and close (accept) dialog.
"""
self.the_command = None
if self.presListWidget:
self.the_command = self.presListWidget.currentItem()\
.xml_element[1].text
self.the_extension = self.presListWidget.currentItem()\
.xml_element[2].text
QDialog.accept(self)
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()
class BookKeeping(QFrame):
# =======================================================================
def __init__(self, parent=None, _PARENT=None):
# -------------------------------------------------------------------
QFrame.__init__(self, parent);
# -------------------------------------------------------------------
self.PARENT = _PARENT;
self.CONF = _PARENT.CONF;
#self.SHA256 = hashlib.sha256;
#UID_SHA256 = self.SHA256( str(time.time()) ).hexdigest();
self.SELECTED_BKKPG_UID = None;
# -------------------------------------------------------------------
self.setGeometry( 3, 5, 975, 555 );
self.setStyleSheet( "QFrame{ font: 12px 'monospace'; color: #000; background-color: transparent; background-image: url('./data/imgs/TAB_BookKeeping.png'); }" );
self.PAIR_COMBO = QComboBox( self);
self.PAIR_COMBO.setGeometry( 86, 20, 108, 44 );
self.connect( self.PAIR_COMBO, SIGNAL('currentIndexChanged(int)'), self.CREATE_LISTS );
#self.PAIR_COMBO.setStyleSheet( "QComboBox{ font: 16px 'monospace'; background-color: #333; color: #FFF; border-style: solid; border-width: 1px; border-color: #000; border-radius: none; }" );
self.PAIR_COMBO.setEditable(False);
"""
#self.PAIR_COMBO.setItemIcon( 0, QIcon("./data/imgs/500.png") );
print(self.PAIR_COMBO.__len__());
#set at tooltip
combo.setItemData(0,"a tooltip",Qt.ToolTipRole)
# set the Font Color
combo.setItemData(0,QColor("#FF333D"), Qt.BackgroundColorRole)
#set the font
combo.setItemData(0, QtGui.QFont('Verdana', bold=True), Qt.FontRole)
"""
# -------------------------------------------------------------------
list_style = "QListWidget{ font: 10px 'monospace'; color: #fff; background-color: #000; border-style: none; background-image: url('./data/imgs/TAB_BookKeeping_line.png'); }"; # ./data/imgs/BookKeeping_line.png
lable_style = "QLabel{ font: 10px 'monospace'; color: #fff; background-color: transparent; border-style: none; background-image: url(''); }";
# -------------------------------------------------------------------
self.DATA_TO_SEND = None;
self._i_ = "|"; # List delimiter
self.CALCULATE_ONLY_COMPLETED = True;
self.DATA_TO_SEND_SELECTED = False;
# -------------------------------------------------------------------
self.BOOKKEEPING_WIDGET = QListWidget( self );
self.BOOKKEEPING_WIDGET.setGeometry( 13, 144, 949, 259 );
self.BOOKKEEPING_WIDGET.setStyleSheet( list_style );
self.connect( self.BOOKKEEPING_WIDGET, SIGNAL('itemSelectionChanged()'), lambda: self.SEND_VALUES_TO_TRADE_TERMINAL("SOLD_WIDGET") );
self.BOOKKEEPING_WIDGET.itemClicked.connect( lambda: self.SEND_VALUES_TO_TRADE_TERMINAL("SELECT_VALUES") );
self.BOUGHT_TTL_LABLE = QLabel("0.0", self);
self.BOUGHT_TTL_LABLE.setGeometry( 304, 406, 85, 17 );
#self.BOUGHT_TTL_LABLE.setEditable( False );
self.BOUGHT_TTL_LABLE.setStyleSheet( lable_style );
self.BOUGHT_TTL = 0;
self.BOUGHT_TTL_PLUS_FEE_LABLE = QLabel("0.0", self);
self.BOUGHT_TTL_PLUS_FEE_LABLE.setGeometry( 396, 406, 85, 17 );
#self.BOUGHT_TTL_PLUS_FEE_LABLE.setEditable( False );
self.BOUGHT_TTL_PLUS_FEE_LABLE.setStyleSheet( lable_style );
self.BOUGHT_TTL_PLUS_FEE = 0;
self.SOLD_TTL_LABLE = QLabel("0.0", self);
self.SOLD_TTL_LABLE.setGeometry( 694, 406, 85, 17 );
#self.SOLD_TTL_LABLE.setEditable( False );
self.SOLD_TTL_LABLE.setStyleSheet( lable_style );
self.SOLD_TTL = 0;
self.SOLD_TTL_PLUS_FEE_LABLE = QLabel("0.0", self);
self.SOLD_TTL_PLUS_FEE_LABLE.setGeometry( 784, 406, 85, 17 );
#self.SOLD_TTL_PLUS_FEE_LABLE.setEditable( False );
self.SOLD_TTL_PLUS_FEE_LABLE.setStyleSheet( lable_style );
self.SOLD_TTL_PLUS_FEE = 0;
self.PROFIT_TTL_LABLE = QLabel("0.0", self);
self.PROFIT_TTL_LABLE.setGeometry( 874, 406, 88, 17 );
#self.PROFIT_TTL_LABLE.setEditable( False );
self.PROFIT_TTL_LABLE.setStyleSheet( lable_style );
self.PROFIT_TTL = 0;
# -------------------------------------------------------------------
self.SEND_ID_LABLE = QLabel("n/a", self);
self.SEND_ID_LABLE.setGeometry( 18, 467, 43, 17 );
self.SEND_ID_LABLE.setStyleSheet( lable_style );
self.SEND_AMOUNT_LABLE = QLabel("n/a", self);
self.SEND_AMOUNT_LABLE.setGeometry( 66, 467, 85, 17 );
self.SEND_AMOUNT_LABLE.setStyleSheet( lable_style );
self.SEND_AT_PRICE_LABLE = QLabel("n/a", self);
self.SEND_AT_PRICE_LABLE.setGeometry( 156, 467, 43, 17 );
self.SEND_AT_PRICE_LABLE.setStyleSheet( lable_style );
self.SEND_VALUES_BTN = QPushButton("", self);
self.SEND_VALUES_BTN.setGeometry( 60, 502, 131, 33 );
self.SEND_VALUES_BTN.setStyleSheet( "QPushButton{ background-color: transparent; border-style: none; }" );
self.connect( self.SEND_VALUES_BTN, SIGNAL('clicked()'), lambda: self.SEND_VALUES_TO_TRADE_TERMINAL("SEND_VALUES") );
# -------------------------------------------------------------------
self.ONLY_COMPLETED_CHECKBOX = QCheckBox("", self);
self.ONLY_COMPLETED_CHECKBOX.setGeometry( 665, 444, 17, 17 );
self.ONLY_COMPLETED_CHECKBOX.setCheckState(Qt.Checked);
#self.ONLY_COMPLETED_CHECKBOX.setEnabled(False);
self.connect(self.ONLY_COMPLETED_CHECKBOX, SIGNAL('stateChanged(int)'), lambda: self.CHANGE_VALUES("only_completed") );
# -------------------------------------------------------------------
self.INIT();
# -------------------------------------------------------------------
# =======================================================================
def INIT(self):
# -------------------------------------------------------------------
try:
self.CREATE_PAIRS_SELECTOR();
self.CREATE_LISTS();
except Exception as _exception:
print("-----------------------------------------------------");
print("[INIT]"+str(_exception));
# -------------------------------------------------------------------
# =======================================================================
def BKKPG_UID_ACTION(self, _ACTION, BKKPG_UID, _D):
# -------------------------------------------------------------------
#print("_ACTION: ", _ACTION, "BKKPG_UID: ", BKKPG_UID)
# -------------------------------------------------------------------
try:
CURR_PAIR = str(self.PAIR_COMBO.currentText()).lower().strip();
order_id = _D[0];
unix_time = _D[1];
filled = _D[2];
amount = _D[3];
at_price = _D[4];
if _ACTION == "buy":
# For CRYPTO
ttl = amount;
fee = ( ttl/100*self.PARENT.FEE );
elif _ACTION == "sell":
# For USD
ttl = amount*at_price;
fee = ( ttl/100*self.PARENT.FEE );
grand_ttl = ttl-fee;
# -------------------------------------------------------------------
if BKKPG_UID == "": # Is New Record
TPL = "buy_order_id, buy_unix_time, buy_filled, buy_amount, buy_at_price, buy_fee, buy_ttl, buy_grand_ttl, sell_order_id, sell_unix_time, sell_filled, sell_amount, sell_at_price, sell_fee, sell_ttl, sell_grand_ttl ";
_SQL = "INSERT INTO "+CURR_PAIR+"( BKKPG_UID, completed, started, "+TPL+", profit_ttl ) ";
if _ACTION == "buy":
_SQL += "VALUES( NULL,0,1,{0},{1},{2},{3},{4},{5},{6},{7},{8},{9},{10},{11},{12},{13},{14},{15}, 0 )".format( _D[0],_D[1],_D[2],_D[3],_D[4],fee, ttl, grand_ttl, 0, 0, 0, 0, 0, 0, 0, 0 );
else:
_SQL += "VALUES( NULL,0,1,{0},{1},{2},{3},{4},{5},{6},{7},{8},{9},{10},{11},{12},{13},{14},{15}, 0 )".format( 0, 0, 0, 0, 0, 0, 0, 0, _D[0], _D[1],_D[2],_D[3],_D[4],fee, ttl, grand_ttl );
self.PARENT.DB.EXEC("BOOK_DB", _SQL);
else: # Existing Record
# ------------------------------------------------
if filled == 1:
completed = 1;
_SQL = "SELECT ACT_grand_ttl from "+CURR_PAIR+" WHERE BKKPG_UID="+BKKPG_UID;
if _ACTION == "buy":
DATA = self.PARENT.DB.FETCH("BOOK_DB", _SQL.replace("ACT","sell"), ALL=False);
profit_ttl = DATA - grand_ttl;
else:
DATA = self.PARENT.DB.FETCH("BOOK_DB", _SQL.replace("ACT","buy"), ALL=False);
profit_ttl = grand_ttl - DATA;
else:
profit_ttl = 0;
completed = 0;
# ------------------------------------------------
A = _ACTION;
_SQL = "UPDATE "+CURR_PAIR+" SET completed={0}, "+A+"_order_id={1}, "+A+"_unix_time={2}, "+A+"_filled={3}, ";
_SQL += A+"_amount={4}, "+A+"_at_price={5}, "+A+"_fee={6}, "+A+"_ttl={7}, "+A+"_grand_ttl={8}";
_SQL += " WHERE BKKPG_UID="+BKKPG_UID;
_SQL = _SQL.format( completed, order_id, unix_time, filled, amount, at_price, fee, ttl, grand_ttl );
self.PARENT.DB.EXEC("BOOK_DB", _SQL);
except Exception as _exception:
print(" BOOKKEEPING[0:0]");
print(_exception);
# -------------------------------------------------------------------
"""
BKKPG_UID, completed, started,
buy_order_id, buy_unix_time, buy_filled, buy_amount, buy_at_price, buy_fee, buy_ttl, buy_grand_ttl,
sell_order_id, sell_unix_time, sell_filled, sell_amount, sell_at_price, sell_fee, sell_ttl, sell_grand_ttl,
profit_ttl
"""
# -------------------------------------------------------------------
# =======================================================================
def DELETE_ORDER(self, _order_id, _pair, _type):
# -------------------------------------------------------------------
_SQL = "SELECT buy_order_id, sell_order_id FROM "+_pair;
_SQL += " WHERE buy_order_id="+str(_order_id)+" OR sell_order_id="+str(_order_id);
DATA = self.PARENT.DB.FETCH("BOOK_DB", _SQL, ALL=False);
if DATA is None:
pass;
if _type == "buy" and DATA[1] == 0:
_SQL = "DELETE FROM "+_pair+" WHERE buy_order_id="+str(_order_id)+" OR sell_order_id="+str(_order_id);
self.PARENT.DB.EXEC("BOOK_DB", _SQL);
self.CREATE_LISTS();
elif _type == "sell" and DATA[0] == 0:
_SQL = "DELETE FROM "+_pair+" WHERE buy_order_id="+str(_order_id)+" OR sell_order_id="+str(_order_id);
self.PARENT.DB.EXEC("BOOK_DB", _SQL);
self.CREATE_LISTS();
else:
A = _type;
_SQL = "UPDATE "+self.PARENT.CURR_PAIR+" SET ";
_SQL += " completed=0, "+A+"_order_id=0, "+A+"_unix_time=0, "+A+"_filled=0, ";
_SQL += A+"_amount=0, "+A+"_at_price=0, "+A+"_fee=0, "+A+"_ttl=0, "+A+"_grand_ttl=0 ";
_SQL += "WHERE "+A+"_order_id="+str(_order_id);
self.PARENT.DB.EXEC("BOOK_DB", _SQL);
# -------------------------------------------------------------------
# =======================================================================
def CREATE_LISTS(self):
# -------------------------------------------------------------------
try:
CURR_PAIR = str(self.PAIR_COMBO.currentText()).lower();
# -------------------------------------------------------------------
self.BOOK = { "bought" : [], "sold" : [] };
self.BOUGHT_TTL = 0;
self.BOUGHT_TTL_PLUS_FEE = 0;
self.SOLD_TTL = 0;
self.SOLD_TTL_PLUS_FEE = 0;
# -------------------------------------------------------------------
#self.PARENT.DB.EXEC( "BOOK_DB", "DELETE FROM "+CURR_PAIR+" WHERE BKKPG_UID>7" );
DATA = self.PARENT.DB.FETCH("BOOK_DB", "SELECT * FROM "+CURR_PAIR+" ORDER BY BKKPG_UID DESC", ALL=True);
self.BOOKKEEPING_WIDGET.clear();
for data in DATA:
# ---------------------------------------------------------------
""" " ""
print( data )
for d in data:
print( d )
exit();
"" " """
# ---------------------------------------------------------------
# In-Memory DATA
BKKPG_UID = data[0]
completed = data[1]
started = data[2]
buy_order_id = data[3]
buy_unix_time = data[4]
buy_filled = data[5]
buy_amount = data[6]
buy_at_price = data[7]
#buy_fee = data[8]
buy_ttl = data[9]
buy_grand_ttl = data[10]
sell_order_id = data[11]
sell_unix_time = data[12]
sell_filled = data[13]
sell_amount = data[14]
sell_at_price = data[15]
#sell_fee = data[16]
sell_ttl = data[17]
sell_grand_ttl = data[18]
profit_ttl = data[19]
# ---------------------------------------------------------------
# ---------------------------------------------------------------
"""
self.BOOK[ data[3] ].append( {
BKKPG_UID,
completed,
started,
buy_order_id,
buy_unix_time,
buy_filled,
buy_amount,
buy_at_price,
buy_fee,
buy_ttl,
buy_grand_ttl,
sell_order_id,
sell_unix_time,
sell_filled,
sell_amount,
sell_at_price,
sell_fee,
sell_ttl,
sell_grand_ttl,
profit_ttl
} );
"""
# ---------------------------------------------------------------
if self.CALCULATE_ONLY_COMPLETED:
if buy_filled == 1 and sell_filled == 1:
self.BOUGHT_TTL += buy_ttl;
self.BOUGHT_TTL_PLUS_FEE += buy_grand_ttl*buy_at_price;
self.SOLD_TTL += sell_ttl;
self.SOLD_TTL_PLUS_FEE += sell_grand_ttl;
else:
self.BOUGHT_TTL += buy_ttl;
self.BOUGHT_TTL_PLUS_FEE += buy_grand_ttl*buy_at_price;
self.SOLD_TTL += sell_ttl;
self.SOLD_TTL_PLUS_FEE += sell_grand_ttl;
self.PROFIT_TTL_LABLE.setText( "{:10,.6f}".format(self.SOLD_TTL_PLUS_FEE - self.BOUGHT_TTL_PLUS_FEE) );
# ---------------------------------------------------------------
# Formating data to Display in BookKeeping Wodget
item = "";
item += "DEL{:7} ".format(str( BKKPG_UID )); # id
# BUY / BOUGHT
item += "#{:11} DEL".format( str(buy_order_id) ); # order_id
item += "{:4} DEL".format( str(buy_filled) ); # filed
item += "{:13} DEL".format( str("{:10,.6f}".format( float(buy_amount) )).strip() ); # Amount
item += "{:13} DEL".format( str("{:10,.6f}".format( buy_at_price )).strip() ); # at_price
#item += "{:13} DEL".format( str("{:10,.6f}".format( data[7] )).strip() ); # fee
#item += "{:13} DEL".format( str("{:10,.6f}".format( buy_ttl )).strip() ); # ttl
item += "{:14} ".format( str("{:10,.6f}".format( buy_grand_ttl )).strip() ); # grand_ttl
# SELL / SOLD
item += "#{:11} DEL".format( str(sell_order_id) ); # order_id
item += "{:4} DEL".format( str(sell_filled) ); # filed
item += "{:13} DEL".format( str("{:10,.6f}".format( sell_amount )).strip() ); # Amount
item += "{:13} DEL".format( str("{:10,.6f}".format( sell_at_price )).strip() ); # at_price
#item += "{:13} DEL".format( str("{:10,.6f}".format( data[7] )).strip() ); # fee
#item += "{:13} DEL".format( str("{:10,.6f}".format( sell_ttl )).strip() ); # ttl
item += "{:14} ".format( str("{:10,.6f}".format( sell_grand_ttl )).strip() ); # grand_ttl
# PROFIT
item += "{:13}".format( str("{:10,.6f}".format( profit_ttl )).strip() ); # grand_ttl
newItem = QListWidgetItem( QIcon("./data/imgs/icon_filled_status_0.png"), item.replace("DEL", self._i_), self.BOOKKEEPING_WIDGET, 0);
#newItemToolTip = "Order ID: #"+str()+" Created: "+time.ctime(int(data[2]));
#newItem.setToolTip(newItemToolTip);
# ---------------------------------------------------------------
# / for
# -------------------------------------------------------------------
try:
self.BOUGHT_TTL_LABLE.setText( str("{:10,.6f}".format( self.BOUGHT_TTL ).strip()) );
self.BOUGHT_TTL_PLUS_FEE_LABLE.setText( str("{:10,.6f}".format( self.BOUGHT_TTL_PLUS_FEE ).strip()) );
self.SOLD_TTL_LABLE.setText( str("{:10,.6f}".format( self.SOLD_TTL ).strip()) );
self.SOLD_TTL_PLUS_FEE_LABLE.setText( str("{:10,.6f}".format( self.SOLD_TTL_PLUS_FEE ).strip()) );
except Exception as e:
print("BOOKKEEPING[3:0]"+str(e))
except Exception as _exception:
print(" BOOKKEEPING[1:0]");
print(_exception);
# -------------------------------------------------------------------
# =======================================================================
def RESET_BKKPG_UID(self):
# -------------------------------------------------------------------
#CURR_PAIR = str(self.PAIR_COMBO.currentText()).lower();
self.PARENT.GUI.BKKPG_UID_VALUE.setText("");
self.PARENT.GUI.CONTROL_TRADINGS_BTNS("buy", "show");
self.PARENT.GUI.CONTROL_TRADINGS_BTNS("sell", "show");
# -------------------------------------------------------------------
# =======================================================================
def CHANGE_VALUES(self, _this):
# -------------------------------------------------------------------
if _this == "only_completed":
if self.ONLY_COMPLETED_CHECKBOX.isChecked():
self.CALCULATE_ONLY_COMPLETED = True;
else:
self.CALCULATE_ONLY_COMPLETED = False;
# -------------------------------------------------------------------
self.CREATE_LISTS();
# -------------------------------------------------------------------
# =======================================================================
def CREATE_PAIRS_SELECTOR(self, ALL=False):
# -------------------------------------------------------------------
if not ALL:
for PAIR in self.CONF["API"]["PAIRS"]:
self.PAIR_COMBO.addItem(PAIR.upper());
else:
for PAIR in self.CONF["API"]["ALL_PAIRS"]:
self.PAIR_COMBO.addItem(PAIR.upper());
for i in xrange(0, self.PAIR_COMBO.__len__()):
self.PAIR_COMBO.setItemData( i, QColor("#333"),Qt.BackgroundRole );
self.PAIR_COMBO.setItemData( i, QColor("#fff"),Qt.ForegroundRole );
#self.PAIR_COMBO.setItemData( i, QFont('monospace', 16, -1, False), Qt.FontRole);
# -------------------------------------------------------------------
# =======================================================================
def SEND_VALUES_TO_TRADE_TERMINAL(self, _action):
# -------------------------------------------------------------------
if _action == "SELECT_VALUES":
self.DATA_TO_SEND_SELECTED = True;
#self.DATA_TO_SEND = [ str(item).stip() for iten in str(self.BOOKKEEPING_WIDGET.currentItem().text()).strip().split("|")];
self.DATA_TO_SEND = str(self.BOOKKEEPING_WIDGET.currentItem().text()).strip().split("|")[1].split("#")[0].strip();
elif _action == "SEND_VALUES":
if self.DATA_TO_SEND_SELECTED:
_SQL = "SELECT buy_order_id, sell_order_id FROM "+self.PARENT.CURR_PAIR;
_SQL += " WHERE BKKPG_UID="+self.DATA_TO_SEND;
DATA = self.PARENT.DB.FETCH("BOOK_DB", _SQL, ALL=False);
if DATA[0] != 0 and DATA[1] != 0:
self.PARENT.GUI.SHOW_QMESSAGE("info", "This UID is Full!<br> You can't add data to it enymore.<br>Bud You can delete sell and/or buy part<br/> and add new part.");
return;
self.PARENT.GUI.BKKPG_UID_VALUE.setText( self.DATA_TO_SEND );
self.PARENT.GUI.CONTROL_TRADINGS_BTNS("buy", "show");
self.PARENT.GUI.CONTROL_TRADINGS_BTNS("sell", "show");
self.DATA_TO_SEND_SELECTED = False;
self.DATA_TO_SEND = None;
# Clear Lables
self.SEND_ID_LABLE.setText( "n/a" );
self.SEND_AMOUNT_LABLE.setText( "n/a" );
self.SEND_AT_PRICE_LABLE.setText( "n/a" );
if DATA[0] == 0:
self.PARENT.GUI.CONTROL_TRADINGS_BTNS("sell", "hide");
else:
self.PARENT.GUI.CONTROL_TRADINGS_BTNS("buy", "hide");
# Switch to Trader-Tab
self.PARENT.GUI.MAIN_TABS.setCurrentIndex(0);
else:
self.PARENT.GUI.SHOW_QMESSAGE("info", " Select first item which one you would like<br/> send to the Trade-Terminal !");
return;
# -------------------------------------------------------------------
if self.DATA_TO_SEND is not None:
self.SEND_ID_LABLE.setText( self.DATA_TO_SEND );
class Consultas(QFrame):
def __init__(self, func):
super().__init__()
self.consulta_actual = 0
self.funciones = [f for f in func]
self.initUI()
def initUI(self):
#self.setFixedSize(830, 120)
self.setStyleSheet("""
QWidget{ background-color: #FFFFFF; border:0px; }
QLineEdit{ border: 1px solid #000099;}
QListWidget{ border: 1px solid #000099;}
QPushButton{ border: 1px solid #000099;}
QPushButton{background-color: #FFCC33; color: #000099; }
QPushButton:pressed { background-color: #FFFF00; }
""")
self.grid = QGridLayout()
self.setLayout(self.grid)
self.grid.setSpacing(5)
# Botones
self.boton = QPushButton("¡Click y descubre!")
self.atras = QPushButton("◄")
self.adelante = QPushButton("►")
# Conexiones
self.boton.clicked.connect(self.clicked)
self.atras.clicked.connect(self.retroceder)
self.adelante.clicked.connect(self.avanzar)
# Lista de consultas
self.args = [
("1.Cantidad de ubicaciones por región:", "Ubicación", "Región"),
("2.Regiones sin ubicaciones:", "Ubicaciones:", "Región:"),
("3.Ruta de ubicacion1 a ubicacion2", "Ubicación 1:",
"Ubicación 2:"),
("4.Cantidad de un tipo de ubicación a una distancia", "Ubicación",
"Cantidad de sub-grillas:"),
("5.Distancia hasta n ubicaciones de un tipo:", "Ubicación",
"Cantidad")
]
self.consulta(*self.args[self.consulta_actual])
def consulta(self, titulo, label1, label2):
label_consulta = QLabel(titulo)
label1 = QLabel(label1)
label2 = QLabel(label2)
label3 = QLabel("Respuesta:")
self.arg1 = QLineEdit()
self.arg2 = QLineEdit()
self.respuesta = QListWidget(self)
self.limpiar_grid(self.grid)
self.grid.addWidget(label_consulta, 0, 0)
self.grid.addWidget(self.boton, 1, 0)
self.grid.addWidget(self.atras, 2, 0)
self.grid.addWidget(self.adelante, 3, 0)
self.grid.addWidget(label1, 0, 1)
self.grid.addWidget(self.arg1, 1, 1)
self.grid.addWidget(label2, 2, 1)
self.grid.addWidget(self.arg2, 3, 1)
self.grid.addWidget(label3, 0, 3)
self.grid.addWidget(self.respuesta, 1, 3, 3, 1)
def clicked(self):
tupla = (self.arg1.text(), self.arg2.text())
valor1 = tupla[0].split(sep=",")
valor2 = tupla[1].split(sep=",")
tupla = (valor1, valor2)
if tupla[0] and tupla[1]:
lista = (self.funciones[self.consulta_actual])(tupla)
self.respuesta.clear()
if isinstance(lista, list):
for x in lista:
item = QListWidgetItem(str(x))
self.respuesta.addItem(item)
else:
item = QListWidgetItem(str(lista))
self.respuesta.addItem(item)
def avanzar(self):
self.consulta_actual = (self.consulta_actual + 1) % 5
self.consulta(*self.args[self.consulta_actual])
def retroceder(self):
valor = self.consulta_actual - 1
self.consulta_actual = 4 if valor < 0 else valor
self.consulta(*self.args[self.consulta_actual])
def limpiar_grid(self, grid):
for i in reversed(range(grid.count())):
grid.itemAt(i).widget().setParent(None)
class ErrorsWidget(QWidget):
###############################################################################
# ERRORS WIDGET SIGNALS
###############################################################################
"""
pep8Activated(bool)
lintActivated(bool)
"""
###############################################################################
def __init__(self):
super(ErrorsWidget, self).__init__()
self.pep8 = None
self._outRefresh = True
vbox = QVBoxLayout(self)
self.listErrors = QListWidget()
self.listErrors.setSortingEnabled(True)
self.listPep8 = QListWidget()
self.listPep8.setSortingEnabled(True)
hbox_lint = QHBoxLayout()
if settings.FIND_ERRORS:
self.btn_lint_activate = QPushButton(self.tr("Lint: ON"))
else:
self.btn_lint_activate = QPushButton(self.tr("Lint: OFF"))
self.errorsLabel = QLabel(self.tr("Static Errors: %s") % 0)
hbox_lint.addWidget(self.errorsLabel)
hbox_lint.addSpacerItem(QSpacerItem(1, 0, QSizePolicy.Expanding))
hbox_lint.addWidget(self.btn_lint_activate)
vbox.addLayout(hbox_lint)
vbox.addWidget(self.listErrors)
hbox_pep8 = QHBoxLayout()
if settings.CHECK_STYLE:
self.btn_pep8_activate = QPushButton(self.tr("PEP8: ON"))
else:
self.btn_pep8_activate = QPushButton(self.tr("PEP8: OFF"))
self.pep8Label = QLabel(self.tr("PEP8 Errors: %s") % 0)
hbox_pep8.addWidget(self.pep8Label)
hbox_pep8.addSpacerItem(QSpacerItem(1, 0, QSizePolicy.Expanding))
hbox_pep8.addWidget(self.btn_pep8_activate)
vbox.addLayout(hbox_pep8)
vbox.addWidget(self.listPep8)
self.connect(self.listErrors, SIGNAL("itemSelectionChanged()"),
self.errors_selected)
self.connect(self.listPep8, SIGNAL("itemSelectionChanged()"),
self.pep8_selected)
self.connect(self.btn_lint_activate, SIGNAL("clicked()"),
self._turn_on_off_lint)
self.connect(self.btn_pep8_activate, SIGNAL("clicked()"),
self._turn_on_off_pep8)
IDE.register_service('tab_errors', self)
ExplorerContainer.register_tab(translations.TR_TAB_ERRORS, self)
def _turn_on_off_lint(self):
"""Change the status of the lint checker state."""
settings.FIND_ERRORS = not settings.FIND_ERRORS
if settings.FIND_ERRORS:
self.btn_lint_activate.setText(self.tr("Lint: ON"))
else:
self.btn_lint_activate.setText(self.tr("Lint: OFF"))
self.emit(SIGNAL("lintActivated(bool)"), settings.FIND_ERRORS)
def _turn_on_off_pep8(self):
"""Change the status of the lint checker state."""
settings.CHECK_STYLE = not settings.CHECK_STYLE
if settings.CHECK_STYLE:
self.btn_pep8_activate.setText(self.tr("PEP8: ON"))
else:
self.btn_pep8_activate.setText(self.tr("PEP8: OFF"))
self.emit(SIGNAL("pep8Activated(bool)"), settings.CHECK_STYLE)
def errors_selected(self):
main_container = IDE.get_service('main_container')
if main_container:
editorWidget = main_container.get_current_editor()
if editorWidget and self._outRefresh:
lineno = int(self.listErrors.currentItem().data(Qt.UserRole))
editorWidget.jump_to_line(lineno)
editorWidget.setFocus()
def pep8_selected(self):
main_container = IDE.get_service('main_container')
if main_container:
editorWidget = main_container.get_current_editor()
if editorWidget and self._outRefresh:
lineno = int(self.listPep8.currentItem().data(Qt.UserRole))
editorWidget.jump_to_line(lineno)
editorWidget.setFocus()
def refresh_pep8_list(self, pep8):
self._outRefresh = False
self.listPep8.clear()
for lineno in pep8:
linenostr = 'L%s\t' % str(lineno + 1)
for data in pep8[lineno]:
item = QListWidgetItem(linenostr + data.split('\n')[0])
item.setToolTip(linenostr + data.split('\n')[0])
item.setData(Qt.UserRole, lineno)
self.listPep8.addItem(item)
self.pep8Label.setText(self.tr("PEP8 Errors: %s") %
len(pep8))
self._outRefresh = True
def refresh_error_list(self, errors):
self._outRefresh = False
self.listErrors.clear()
for lineno in errors:
linenostr = 'L%s\t' % str(lineno + 1)
for data in errors[lineno]:
item = QListWidgetItem(linenostr + data)
item.setToolTip(linenostr + data)
item.setData(Qt.UserRole, lineno)
self.listErrors.addItem(item)
self.errorsLabel.setText(self.tr("Static Errors: %s") %
len(errors))
self._outRefresh = True
def clear(self):
"""
Clear the widget
"""
self.listErrors.clear()
self.listPep8.clear()
class getFontDialog(QDialog):
def __init__(self, parent, currFont):
QDialog.__init__(self, parent)
#---------------------
self.currFont = currFont
if self.currFont.get_file() == None:
self.currFontFile = fm.findfont(self.currFont)
self.currFontSize = self.currFont.get_size()
self.currFontStyle = self.currFont.get_style()
self.currFontWeight = self.currFont.get_weight()
self.currFont = fm.FontProperties(fname=self.currFontFile, style=self.currFontStyle, weight=self.currFontWeight, size=self.currFontSize)
self.currFontFamily = self.currFont.get_name()
else:
self.currFontFile = self.currFont.get_file()
self.currFontSize = self.currFont.get_size()
self.currFontStyle = self.currFont.get_style()
self.currFontWeight = self.currFont.get_weight()
self.currFontFamily = self.currFont.get_name()
self.fontsCacheFile = os.path.expanduser("~") +'/.config/pysoundanalyser/fontsCache'
if os.path.exists(self.fontsCacheFile):
fIn = open(self.fontsCacheFile, 'rb')
self.fontsDic = pickle.load(fIn)
fIn.close()
else:
x = fm.FontManager()
weight_lookup = {
'100': 'ultralight',
'200': 'light',
'400': 'normal',
'500': 'medium',
'600': 'demibold',
'700': 'bold',
'800': 'extra bold',
'900': 'black'}
fontList = x.ttflist
fontNamesAll = []
for i in range(len(x.ttflist)):
fontNamesAll.append(x.ttflist[i].name)
fontNames = unique(fontNamesAll)
self.fontsDic = {}
for i in range(len(fontNames)):
self.fontsDic[fontNames[i]] = {}
self.fontsDic[fontNames[i]]['style'] = []
self.fontsDic[fontNames[i]]['styleAbb'] = []
for font in fontList:
style = font.style
weight = font.weight
self.fontsDic[font.name]['style'].append(style + ':' + str(weight) + ':' + font.fname)
weightName = weight_lookup[str(weight)]
styleName = style + ' ' + weightName
self.fontsDic[font.name]['styleAbb'].append(styleName)
f = open(self.fontsCacheFile, 'wb')
pickle.dump(self.fontsDic, f)
f.close()
#---------------------
self.currLocale = self.parent().prm['data']['currentLocale']
self.currLocale.setNumberOptions(self.currLocale.OmitGroupSeparator | self.currLocale.RejectGroupSeparator)
grid = QGridLayout()
fontNameLabel = QLabel(self.tr('Font Name'))
grid.addWidget(fontNameLabel, 0, 0)
fontStyleLabel = QLabel(self.tr('Font Style'))
grid.addWidget(fontStyleLabel, 0, 1)
fontSizeLabel = QLabel(self.tr('Font Size'))
grid.addWidget(fontSizeLabel, 0, 2)
ind = sorted(self.fontsDic.keys()).index(self.currFontFamily)
self.fontListWidget = QListWidget(self)
self.fontListWidget.insertItems(0, sorted(self.fontsDic.keys()))
self.fontListWidget.setCurrentRow(ind)
self.fontListWidget.itemClicked.connect(self.onChangeFontName)
grid.addWidget(self.fontListWidget, 1, 0)
self.fontStylesWidget = QListWidget(self)
self.fontStylesWidget.insertItems(0, self.fontsDic[sorted(self.fontsDic.keys())[ind]]['styleAbb'])
indStyle = self.fontsDic[sorted(self.fontsDic.keys())[ind]]['styleAbb'].index(self.currFontStyle + ' ' + self.currFontWeight)
self.fontStylesWidget.setCurrentRow(indStyle)
grid.addWidget(self.fontStylesWidget, 1, 1)
self.fontSizeWidget = QListWidget(self)
self.pointSizeList = ['4', '5', '6', '7', '8', '9', '10', '11', '12', '13', '14', '15', '16', '17', '18', '19', '20', '22', '24', '26', '28', '32', '48', '64', '72', '80', '96', '128']
self.fontSizeWidget.insertItems(0, self.pointSizeList)
self.fontSizeWidget.setCurrentRow(self.pointSizeList.index(str(int(self.currFontSize))))
grid.addWidget(self.fontSizeWidget, 1, 2)
buttonBox = QDialogButtonBox(QDialogButtonBox.Ok|
QDialogButtonBox.Cancel)
buttonBox.accepted.connect(self.accept)
buttonBox.rejected.connect(self.reject)
grid.addWidget(buttonBox, 3, 2)
self.setLayout(grid)
self.setWindowTitle(self.tr("Choose Font"))
def onChangeFontName(self):
currFontName = str(self.fontListWidget.currentItem().text())
self.fontStylesWidget.clear()
self.fontStylesWidget.insertItems(0, self.fontsDic[currFontName]['styleAbb'])
self.fontStylesWidget.setCurrentRow(0)
class NewSessionPagePermutations(QWizardPage):
def __init__(self):
super(NewSessionPagePermutations, self).__init__()
self.setTitle(_('Configuration of permutations'))
self.setSubTitle(
_('Select the position of each question'
' and its choices in every model of the exam.'))
layout = QGridLayout()
self.question_list = QListWidget()
self.permutation_grid = QGridLayout()
self.alternatives_rows = {}
layout.addWidget(QLabel(_('Questions of model A')), 0, 0, 1, 1)
layout.addWidget(self.question_list, 1, 0, 1, 1)
layout.addWidget(QLabel(_('Model equivalence')), 0, 1, 1, 5)
self.permutation_grid.setVerticalSpacing(20)
layout.addLayout(self.permutation_grid, 1, 1, 1, 5)
layout.setColumnStretch(0, 1)
layout.setColumnStretch(1, 5)
self.setLayout(layout)
def initializePage(self):
paramNAlts = int(self.field("paramNAlts").toString())
paramNPerm = int(self.field("paramNPerm").toString())
self.question_list.clear()
# Creation of the list section
paramNCols_array = self.field("paramNCols").toString().split(',')
total_questions = 1 + (int(paramNCols_array[0]) \
if len(paramNCols_array) == 1 \
else reduce(lambda x, y: int(x) + int(y),
paramNCols_array))
for i in range(1, total_questions):
questions_list = QListWidgetItem(_('Question ') + str(i))
questions_list.setData(Qt.UserRole,
widgets.ItemList(
optionName=_('Question ') + str(i),
optionNumber=i)) # Custom item list
self.question_list.addItem(questions_list)
self.question_list.setCurrentRow(0)
self.question_list.itemClicked.connect(self._on_item_changed)
# Creation of the grid section
add_header = True # Header of the columns (Name of alternatives)
for j in range(0, paramNPerm):
self.permutation_grid.addWidget( \
QLabel(_('Model ') + chr(97 + j).upper()), j, 1)
self.alternatives_rows[j] = {}
for k in range(0, paramNAlts):
if add_header:
if k == 0:
self.permutation_grid.addWidget(QLabel(''), 0, 1)
self.permutation_grid.addWidget( \
QLabel(chr(97 + k).upper()), 0, k + 2)
self.alternatives_rows[j][k] = \
widgets.InputComboBox(self, c_type='alternative',
form=j, alternative=k)
self.alternatives_rows[j][k].addItems( \
[chr(97+x).upper() for x in range(0,paramNAlts)])
self.alternatives_rows[j][k].setCurrentIndex(0)
self.permutation_grid.addWidget(self.alternatives_rows[j][k],
j, k + 2)
add_header = False
self.alternatives_rows[j][k + 1] = \
widgets.InputComboBox(self, c_type='question', form=j,
alternative=self.question_list.\
currentItem().\
data(Qt.UserRole).toPyObject().\
get_question_number())
self.alternatives_rows[j][k + 1].addItems( \
[str(x) for x in range(1,total_questions)])
self.alternatives_rows[j][k + 1].setCurrentIndex(0)
self.permutation_grid.addWidget(QLabel(_('Question Number')), j,
k + 3)
self.permutation_grid.addWidget(self.alternatives_rows[j][k + 1],
j, k + 4)
button_save = QPushButton(_('Save values'))
self.permutation_grid.addWidget(button_save, j + 1, 1, 1, k + 4)
button_save.clicked.connect(self._save_values)
def _on_item_changed(self, arg=None):
permutation = arg.data(Qt.UserRole).toPyObject().get_permutation()
for k, v in self.alternatives_rows.iteritems():
for sk, sv in v.iteritems():
if not permutation:
sv.setCurrentIndex(0)
else:
sv.setCurrentIndex( \
[x for x in permutation \
if (x['altr'] == sv.alternative
and x['form'] == sv.form
and x['c_type'] == sv.c_type)][0]['perm'] - 1)
return True
def _save_values(self):
localItem = self.question_list.currentItem()
formatted_grid = self._get_formatted_permutation_grid()
if self._validate_grid(formatted_grid):
localItem.setBackgroundColor(QColor(0, 255, 68))
localItem.data(Qt.UserRole).toPyObject()\
.set_permutation(formatted_grid)
self._reset_permutation_grid()
QMessageBox.information(
self, _('Information status'),
_('The values for the question have been successfully saved'))
return True
else:
QMessageBox.critical(self, _('Error in grid'),
_('There is an inconsistence in the options'))
return False
def _get_formatted_permutation_grid(self):
local_alternatives_rows = []
for k, v in self.alternatives_rows.iteritems():
for sk, sv in v.iteritems():
alternative = {
'c_type': sv.c_type,
'form': sv.form,
'altr': sv.alternative,
'perm': sv.currentIndex() + 1
}
local_alternatives_rows.append(alternative)
return local_alternatives_rows
def _validate_grid(self, grid):
#validate current grid and questions number
forms = {}
for row in grid:
if row['c_type'] == 'alternative':
if row['form'] not in forms:
forms[row['form']] = []
if row['perm'] in forms[row['form']]:
return False
else:
forms[row['form']].append(row['perm'])
if row['c_type'] == 'question':
for i in xrange(self.question_list.count()):
if i == self.question_list.currentRow():
continue
perm = self.question_list.item(i).data(Qt.UserRole)\
.toPyObject().get_permutation()
for perm_row in perm:
if (perm_row['c_type'] == 'question'
and perm_row['form'] == row['form']
and perm_row['perm'] == row['perm']):
return False
return True
def _reset_permutation_grid(self):
for k, v in self.alternatives_rows.iteritems():
for sk, sv in v.iteritems():
sv.setCurrentIndex(0)
def _get_values(self):
formated_permutation = {}
formated_permutation_m = {}
for i in xrange(self.question_list.count()):
permutations = self.question_list.item(i).data(Qt.UserRole)\
.toPyObject().get_permutation()
a = {}
for p in permutations:
if p['form'] not in formated_permutation:
formated_permutation[p['form']] = []
if p['form'] not in a:
a[p['form']] = []
if p['c_type'] == 'alternative':
a[p['form']].append(p['perm'])
if p['c_type'] == 'question':
formated_permutation[p['form']].append( \
"%s{%s}" % (p['perm'], ','.join(str(x) \
for x in a[p['form']])))
for k, v in formated_permutation.iteritems():
formated_permutation_m[chr(97 + k).upper()] = '/'.join(v)
return formated_permutation_m
def validatePage(self):
valid = True
msg = ''
for i in xrange(self.question_list.count()):
if not self.question_list.item(i).data(Qt.UserRole)\
.toPyObject().get_permutation():
valid = False
msg = _('You must select all permutations for all questions')
break
if not valid:
QMessageBox.critical(self, _('Error'), msg)
else:
current_permutations = self._get_values()
for k, v in current_permutations.iteritems():
self.wizard().exam_config.set_permutations(k, v)
return valid
def nextId(self):
return WizardNewSession.PageIdFiles
class EditorGeneral(QWidget):
"""EditorGeneral widget class."""
def __init__(self, parent):
super(EditorGeneral, self).__init__()
self._preferences, vbox = parent, QVBoxLayout(self)
self.original_style = copy.copy(resources.CUSTOM_SCHEME)
self.current_scheme, self._modified_editors = 'default', []
self._font = settings.FONT
groupBoxMini = QGroupBox(
translations.TR_PREFERENCES_EDITOR_GENERAL_MINIMAP)
groupBoxTypo = QGroupBox(
translations.TR_PREFERENCES_EDITOR_GENERAL_TYPOGRAPHY)
groupBoxScheme = QGroupBox(
translations.TR_PREFERENCES_EDITOR_GENERAL_SCHEME)
#Minimap
formMini = QGridLayout(groupBoxMini)
formMini.setContentsMargins(5, 15, 5, 5)
self._checkShowMinimap = QCheckBox(
translations.TR_PREFERENCES_EDITOR_GENERAL_ENABLE_MINIMAP)
self._spinMaxOpacity = QSpinBox()
self._spinMaxOpacity.setRange(0, 100)
self._spinMaxOpacity.setSuffix("% Max.")
self._spinMinOpacity = QSpinBox()
self._spinMinOpacity.setRange(0, 100)
self._spinMinOpacity.setSuffix("% Min.")
self._spinSize = QSpinBox()
self._spinSize.setMaximum(100)
self._spinSize.setMinimum(0)
self._spinSize.setSuffix(
translations.TR_PREFERENCES_EDITOR_GENERAL_AREA_MINIMAP)
formMini.addWidget(self._checkShowMinimap, 0, 1)
formMini.addWidget(QLabel(
translations.TR_PREFERENCES_EDITOR_GENERAL_SIZE_MINIMAP), 1, 0,
Qt.AlignRight)
formMini.addWidget(self._spinSize, 1, 1)
formMini.addWidget(QLabel(
translations.TR_PREFERENCES_EDITOR_GENERAL_OPACITY), 2, 0,
Qt.AlignRight)
formMini.addWidget(self._spinMinOpacity, 2, 1)
formMini.addWidget(self._spinMaxOpacity, 2, 2)
#Typo
gridTypo = QGridLayout(groupBoxTypo)
gridTypo.setContentsMargins(5, 15, 5, 5)
self._btnEditorFont = QPushButton('')
gridTypo.addWidget(QLabel(
translations.TR_PREFERENCES_EDITOR_GENERAL_EDITOR_FONT), 0, 0,
Qt.AlignRight)
gridTypo.addWidget(self._btnEditorFont, 0, 1)
#Scheme
vboxScheme = QVBoxLayout(groupBoxScheme)
vboxScheme.setContentsMargins(5, 15, 5, 5)
self._listScheme = QListWidget()
vboxScheme.addWidget(self._listScheme)
hbox = QHBoxLayout()
btnDownload = QPushButton(
translations.TR_PREFERENCES_EDITOR_DOWNLOAD_SCHEME)
btnDownload.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.connect(btnDownload, SIGNAL("clicked()"),
self._open_schemes_manager)
hbox.addWidget(btnDownload)
btnAdd = QPushButton(QIcon(":img/add"),
translations.TR_EDITOR_CREATE_SCHEME)
btnAdd.setIconSize(QSize(16, 16))
btnAdd.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.connect(btnAdd, SIGNAL("clicked()"), self._open_schemes_designer)
btnRemove = QPushButton(QIcon(":img/delete"),
translations.TR_EDITOR_REMOVE_SCHEME)
btnRemove.setIconSize(QSize(16, 16))
btnRemove.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.connect(btnRemove, SIGNAL("clicked()"), self._remove_scheme)
hbox.addSpacerItem(QSpacerItem(1, 0, QSizePolicy.Expanding))
hbox.addWidget(btnAdd)
hbox.addWidget(btnRemove)
vboxScheme.addLayout(hbox)
vbox.addWidget(groupBoxMini)
vbox.addWidget(groupBoxTypo)
vbox.addWidget(groupBoxScheme)
#Settings
qsettings = IDE.ninja_settings()
qsettings.beginGroup('preferences')
qsettings.beginGroup('editor')
self._checkShowMinimap.setChecked(settings.SHOW_MINIMAP)
if settings.IS_MAC_OS:
self._spinMinOpacity.setValue(100)
self._spinMaxOpacity.setValue(100)
self._spinMinOpacity.setDisabled(True)
self._spinMaxOpacity.setDisabled(True)
else:
self._spinMinOpacity.setValue(settings.MINIMAP_MIN_OPACITY * 100)
self._spinMaxOpacity.setValue(settings.MINIMAP_MAX_OPACITY * 100)
self._spinSize.setValue(settings.SIZE_PROPORTION * 100)
btnText = ', '.join(self._font.toString().split(',')[0:2])
self._btnEditorFont.setText(btnText)
self._listScheme.clear()
self._listScheme.addItem('default')
self._schemes = json_manager.load_editor_skins()
for item in self._schemes:
self._listScheme.addItem(item)
items = self._listScheme.findItems(
qsettings.value('scheme', defaultValue='',
type='QString'), Qt.MatchExactly)
if items:
self._listScheme.setCurrentItem(items[0])
else:
self._listScheme.setCurrentRow(0)
qsettings.endGroup()
qsettings.endGroup()
#Signals
self.connect(self._btnEditorFont,
SIGNAL("clicked()"), self._load_editor_font)
self.connect(self._listScheme, SIGNAL("itemSelectionChanged()"),
self._preview_style)
self.connect(self._preferences, SIGNAL("savePreferences()"), self.save)
def _open_schemes_manager(self):
ninjaide = IDE.get_service("ide")
ninjaide.show_schemes()
# refresh schemes
def _open_schemes_designer(self):
name = self._listScheme.currentItem().text()
scheme = self._schemes.get(name, resources.COLOR_SCHEME)
designer = preferences_editor_scheme_designer.EditorSchemeDesigner(
scheme, self)
designer.exec_()
if designer.saved:
scheme_name = designer.line_name.text()
scheme = designer.original_style
self._schemes[scheme_name] = scheme
result = self._listScheme.findItems(scheme_name, Qt.MatchExactly)
if not result:
self._listScheme.addItem(scheme_name)
def _remove_scheme(self):
name = self._listScheme.currentItem().text()
fileName = ('{0}.color'.format(
file_manager.create_path(resources.EDITOR_SKINS, name)))
file_manager.delete_file(fileName)
item = self._listScheme.takeItem(self._listScheme.currentRow())
del item
def hideEvent(self, event):
super(EditorGeneral, self).hideEvent(event)
resources.CUSTOM_SCHEME = self.original_style
for editorWidget in self._modified_editors:
try:
editorWidget.restyle(editorWidget.lang)
except RuntimeError:
print('the editor has been removed')
def _preview_style(self):
scheme = self._listScheme.currentItem().text()
if scheme == self.current_scheme:
return
main_container = IDE.get_service('main_container')
if not main_container:
return
editorWidget = main_container.get_current_editor()
if editorWidget is not None:
resources.CUSTOM_SCHEME = self._schemes.get(
scheme,
resources.COLOR_SCHEME)
editorWidget.restyle(editorWidget.lang)
self._modified_editors.append(editorWidget)
self.current_scheme = scheme
def _load_editor_font(self):
try:
font, ok = QFontDialog.getFont(self._font, self)
if ok:
self._font = font
btnText = ', '.join(self._font.toString().split(',')[0:2])
self._btnEditorFont.setText(btnText)
except:
QMessageBox.warning(
self,
translations.TR_PREFERENCES_EDITOR_GENERAL_FONT_MESSAGE_TITLE,
translations.TR_PREFERENCES_EDITOR_GENERAL_FONT_MESSAGE_BODY)
def save(self):
qsettings = IDE.ninja_settings()
settings.FONT = self._font
qsettings.setValue('preferences/editor/font', settings.FONT)
settings.SHOW_MINIMAP = self._checkShowMinimap.isChecked()
settings.MINIMAP_MAX_OPACITY = self._spinMaxOpacity.value() / 100.0
settings.MINIMAP_MIN_OPACITY = self._spinMinOpacity.value() / 100.0
settings.SIZE_PROPORTION = self._spinSize.value() / 100.0
qsettings.setValue('preferences/editor/minimapMaxOpacity',
settings.MINIMAP_MAX_OPACITY)
qsettings.setValue('preferences/editor/minimapMinOpacity',
settings.MINIMAP_MIN_OPACITY)
qsettings.setValue('preferences/editor/minimapSizeProportion',
settings.SIZE_PROPORTION)
qsettings.setValue('preferences/editor/minimapShow',
settings.SHOW_MINIMAP)
scheme = self._listScheme.currentItem().text()
resources.CUSTOM_SCHEME = self._schemes.get(scheme,
resources.COLOR_SCHEME)
qsettings.setValue('preferences/editor/scheme', scheme)
class OrdersWidget(QFrame):
# =======================================================================
def __init__(self, parent=None, _PARENT=None):
# -------------------------------------------------------------------
QFrame.__init__(self, parent)
# -------------------------------------------------------------------
self.setGeometry(3, 5, 968, 555)
self.setStyleSheet(
"QFrame{ color: #fff; background-image: url('./data/imgs/TAB_Orders.png'); }"
)
# -------------------------------------------------------------------
self.PARENT = _PARENT
self.CONF = _PARENT.CONF
self.ORDER_ID_TO_CANCEL = False
self.ORDER_TYPE_TO_CANCEL = False
# buy/sell to be able delete records from bookkeeping separatly
self.ORDERS_FROM_DB = {}
# -------------------------------------------------------------------
WIDGETS_W = 469
WIDGETS_H = 325
WIDGETS_ML = 13
WIDGETS_MT = 144
list_style = "QListWidget{ font: 10px 'monospace'; color: #fff; background-color: #000; border-style: none; background-image: url('./data/imgs/TAB_Orders_line.png'); }"
# BUY
self.ORDERS_LIST_BUY = QListWidget(self)
self.ORDERS_LIST_BUY.setGeometry(WIDGETS_ML, WIDGETS_MT, WIDGETS_W,
WIDGETS_H)
self.ORDERS_LIST_BUY.setStyleSheet(list_style)
self.ORDERS_LIST_BUY.setViewMode(QListView.ListMode)
self.connect(self.ORDERS_LIST_BUY, SIGNAL('itemSelectionChanged()'),
lambda: self.SELECT_ORDER_ID("buy"))
self.ORDERS_LIST_BUY.itemClicked.connect(
lambda: self.SELECT_ORDER_ID("buy"))
# SELL
self.ORDERS_LIST_SELL = QListWidget(self)
self.ORDERS_LIST_SELL.setGeometry(WIDGETS_W + (WIDGETS_ML * 2) - 1,
WIDGETS_MT, WIDGETS_W - 1, WIDGETS_H)
self.ORDERS_LIST_SELL.setStyleSheet(list_style)
self.connect(self.ORDERS_LIST_SELL, SIGNAL('itemSelectionChanged()'),
lambda: self.SELECT_ORDER_ID("sell"))
self.ORDERS_LIST_SELL.itemClicked.connect(
lambda: self.SELECT_ORDER_ID("sell"))
# -------------------------------------------------------------------
self.CANCEL_ORDER_BTN = QPushButton("Apply", self)
self.CANCEL_ORDER_BTN.setGeometry(555, 506, 80, 30)
self._i_ = "|"
# List delimiter
# -------------------------------------------------------------------
self.INIT()
# -------------------------------------------------------------------
# =======================================================================
def INIT(self):
# -------------------------------------------------------------------
self.GET_ORDERS_FROM_DB()
# -------------------------------------------------------------------
# =======================================================================
def SELECT_ORDER_ID(self, _type):
# -------------------------------------------------------------------
try:
self.ORDER_TYPE_TO_CANCEL = _type
if _type == "sell":
self.ORDER_ID_TO_CANCEL = str(
self.ORDERS_LIST_SELL.currentItem().text()).split(
"|")[0].strip()[1:]
elif _type == "buy":
self.ORDER_ID_TO_CANCEL = str(
self.ORDERS_LIST_BUY.currentItem().text()).split(
"|")[0].strip()[1:]
except Exception as _exception:
print(_exception)
# -------------------------------------------------------------------
# =======================================================================
def CREATE_LISTS(self):
# -------------------------------------------------------------------
try:
self.ORDERS_LIST_SELL.clear()
self.ORDERS_LIST_BUY.clear()
for ID in self.ORDERS_FROM_DB:
item = ""
item += "#{:11} DEL".format(str(ID))
# order_id
item += "{:7} DEL".format(self.ORDERS_FROM_DB[ID]["pair"])
# type
item += "{:13} DEL".format(
str("{:10,.6f}".format(
self.ORDERS_FROM_DB[ID]["amount"])).strip())
# Amount
item += "{:13} DEL".format(
str("{:10,.6f}".format(
self.ORDERS_FROM_DB[ID]["at_price"])).strip())
# at_price
newItemToolTip = "Order ID: #" + str(
ID) + " Created: " + time.ctime(
self.ORDERS_FROM_DB[ID]["unix_time"])
if self.ORDERS_FROM_DB[ID]["type"] == "buy":
ttl = self.ORDERS_FROM_DB[ID]["amount"] - (
self.ORDERS_FROM_DB[ID]["amount"] / 100 *
self.PARENT.FEE)
item += "{:13}".format(
str("{:10,.6f}".format(ttl)).strip())
# ttl_usd
newItem = QListWidgetItem(
QIcon("./data/imgs/icon_filled_status_0.png"),
item.replace("DEL", self._i_), self.ORDERS_LIST_BUY, 0)
newItem.setToolTip(newItemToolTip)
elif self.ORDERS_FROM_DB[ID]["type"] == "sell":
ttl = self.ORDERS_FROM_DB[ID][
"at_price"] * self.ORDERS_FROM_DB[ID]["amount"]
ttl -= (ttl / 100 * self.PARENT.FEE)
item += "{:13}".format(
str("{:10,.6f}".format(ttl)).strip())
# ttl_usd
newItem = QListWidgetItem(
QIcon("./data/imgs/icon_filled_status_0.png"),
item.replace("DEL", self._i_), self.ORDERS_LIST_SELL,
0)
newItem.setToolTip(newItemToolTip)
except Exception as _exception:
print("FRAME_ORDER.CREATE_LISTS: " + str(_exception))
# -------------------------------------------------------------------
# =======================================================================
def DELETE_ORDER(self, _order_id, _pair, _type):
# ------------------------------------------------------------------
_SQL = "DELETE FROM " + _pair + " WHERE order_id=" + str(_order_id)
self.PARENT.DB.EXEC("ORDERS_DB", _SQL)
# ------------------------------------------------------------------
# =======================================================================
def UPDATE_ACTIVE_ORDERS(self):
# ------------------------------------------------------------------
pass
# ------------------------------------------------------------------
# =======================================================================
def GET_ORDERS_FROM_DB(self):
# ------------------------------------------------------------------
#del self.ORDERS_FROM_DB;
#self.ORDERS_FROM_DB = {};
# ------------------------------------------------------------------
for PAIR in self.CONF["API"]["ALL_PAIRS"]:
THIS_FIELDS = "order_id, unix_time, filled, at_price, amount, pair, type"
DATA = self.PARENT.DB.FETCH("ORDERS_DB",
"SELECT " + THIS_FIELDS + " FROM " +
PAIR + " WHERE filled=0",
ALL=True)
_len = len(DATA)
for order_id, unix_time, filled, at_price, amount, pair, _type in DATA:
self.ORDERS_FROM_DB[order_id] = {
"order_id": order_id,
"unix_time": unix_time,
"filled": filled,
"at_price": at_price,
"amount": amount,
"pair": pair,
"type": _type
}
"""
if _len > 0:
#print(order_id, "->", self.ORDERS_FROM_DB[ order_id ])
print(self.ORDERS_FROM_DB)
exit();
"""
# ------------------------------------------------------------------
# =======================================================================
###################################################################################################
class PopupCompleter(QFrame):
def __init__(self):
QFrame.__init__(self, None, Qt.FramelessWindowHint | Qt.ToolTip)
vbox = QVBoxLayout(self)
vbox.setContentsMargins(0, 0, 0, 0)
vbox.setSpacing(0)
self.listWidget = QListWidget()
self.listWidget.setMinimumHeight(300)
vbox.addWidget(self.listWidget)
def reload(self, model):
"""Reload the data of the Popup Completer, and restart the state."""
self.listWidget.clear()
self.add_help()
for item in model:
self.listWidget.addItem(item[0])
self.listWidget.setItemWidget(item[0], item[1])
self.listWidget.setCurrentRow(6)
def clear(self):
"""Remove all the items of the list (deleted), and reload the help."""
self.listWidget.clear()
def refresh(self, model):
"""Refresh the list when the user search for some word."""
self.listWidget.clear()
for item in model:
self.listWidget.addItem(item[0])
self.listWidget.setItemWidget(item[0], item[1])
if model:
self.listWidget.setCurrentItem(model[0][0])
def fetch_more(self, model):
"""Add more items to the list on user scroll."""
for item in model:
self.listWidget.addItem(item[0])
self.listWidget.setItemWidget(item[0], item[1])
def add_help(self):
#Load help
fileItem = QListWidgetItem(
QIcon(resources.IMAGES['locate-file']),
'@\t(Filter only by Files)')
font = fileItem.font()
font.setBold(True)
fileItem.setSizeHint(QSize(20, 30))
fileItem.setBackground(QBrush(Qt.lightGray))
fileItem.setForeground(QBrush(Qt.black))
fileItem.setFont(font)
self.listWidget.addItem(fileItem)
classItem = QListWidgetItem(
QIcon(resources.IMAGES['locate-class']),
'<\t(Filter only by Classes)')
self.listWidget.addItem(classItem)
classItem.setSizeHint(QSize(20, 30))
classItem.setBackground(QBrush(Qt.lightGray))
classItem.setForeground(QBrush(Qt.black))
classItem.setFont(font)
methodItem = QListWidgetItem(
QIcon(resources.IMAGES['locate-function']),
'>\t(Filter only by Methods)')
self.listWidget.addItem(methodItem)
methodItem.setSizeHint(QSize(20, 30))
methodItem.setBackground(QBrush(Qt.lightGray))
methodItem.setForeground(QBrush(Qt.black))
methodItem.setFont(font)
attributeItem = QListWidgetItem(
QIcon(resources.IMAGES['locate-attributes']),
'-\t(Filter only by Attributes)')
self.listWidget.addItem(attributeItem)
attributeItem.setSizeHint(QSize(20, 30))
attributeItem.setBackground(QBrush(Qt.lightGray))
attributeItem.setForeground(QBrush(Qt.black))
attributeItem.setFont(font)
thisFileItem = QListWidgetItem(
QIcon(resources.IMAGES['locate-on-this-file']),
'.\t(Filter only by Classes and Methods in this File)')
font = thisFileItem.font()
font.setBold(True)
thisFileItem.setSizeHint(QSize(20, 30))
thisFileItem.setBackground(QBrush(Qt.lightGray))
thisFileItem.setForeground(QBrush(Qt.black))
thisFileItem.setFont(font)
self.listWidget.addItem(thisFileItem)
nonPythonItem = QListWidgetItem(
QIcon(resources.IMAGES['locate-nonpython']),
'!\t(Filter only by Non Python Files)')
self.listWidget.addItem(nonPythonItem)
nonPythonItem.setSizeHint(QSize(20, 30))
nonPythonItem.setBackground(QBrush(Qt.lightGray))
nonPythonItem.setForeground(QBrush(Qt.black))
nonPythonItem.setFont(font)
class Window(QtGui.QWidget):
def __init__(self):
QtGui.QWidget.__init__(self)
self.media = Phonon.MediaObject(self)
### video widget ####
self.video = Phonon.VideoWidget(self)
self.video.setMinimumSize(320,200)
self.videoCuts = []
self.myfilename = ""
self.extension = ""
self.t1 = ""
self.t2 = ""
self.t3 = ""
self.t4 = ""
self.t5 = ""
self.t6 = ""
### open button ###
self.button = QtGui.QPushButton('Choose Video', self)
self.button.setFixedWidth(90)
self.button.clicked.connect(self.handleButton)
self.button.setStyleSheet(stylesheet(self))
### context menu ####
self.setContextMenuPolicy(Qt.CustomContextMenu)
self.customContextMenuRequested.connect(self.popup2)
### play / pause button ###
self.playbutton = QtGui.QPushButton('Play', self)
self.playbutton.setFixedWidth(70)
self.playbutton.clicked.connect(self.handlePlayButton)
self.playbutton.setStyleSheet(stylesheet(self))
self.connect(QtGui.QShortcut(QtGui.QKeySequence(QtCore.Qt.Key_Space), self), QtCore.SIGNAL('activated()'), self.handlePlayButton)
self.connect(QtGui.QShortcut(QtGui.QKeySequence("Ctrl+o"), self), QtCore.SIGNAL('activated()'), self.handleButton)
self.connect(QtGui.QShortcut(QtGui.QKeySequence("Ctrl+s"), self), QtCore.SIGNAL('activated()'), self.handleSaveVideo)
self.connect(QtGui.QShortcut(QtGui.QKeySequence("Ctrl+q"), self), QtCore.SIGNAL('activated()'), self.handleQuit)
### save button ###
self.savebutton = QtGui.QPushButton('Save Video', self)
self.savebutton.setFixedWidth(90)
self.savebutton.clicked.connect(self.handleSaveVideo)
self.savebutton.setStyleSheet(stylesheet(self))
### seek slider ###
self.slider = Phonon.SeekSlider(self.media)
self.slider.setStyleSheet(stylesheet(self))
isize = QSize(16,16)
self.slider.setIconSize(isize)
self.slider.setFocus()
# self.slider.connect(self.handleLabel)
### connection position to label ###
self.media.isSeekable()
self.media.tick.connect(self.handleLabel)
self.media.seekableChanged.connect(self.handleLabel)
#self.slider.wheel.connect(self.handleLabel)
### table view ###
self.iconList = QListWidget()
self.iconList.setAlternatingRowColors(True)
self.iconList.setFixedWidth(200)
self.iconList.setContextMenuPolicy(Qt.CustomContextMenu)
self.iconList.setStyleSheet("QListWidget::item:selected:active { background: #7D8ED9; color:#FFFFFF; } ")
self.iconList.setViewMode(0)
self.iconList.setSelectionBehavior(1)
self.iconList.setIconSize(QSize(80, 80/1.78))
self._hookListActions()
self.iconList.customContextMenuRequested.connect(self._openListMenu)
### set start button ###
self.startbutton = QtGui.QPushButton('set Start', self)
self.startbutton.setFixedWidth(70)
self.startbutton.clicked.connect(self.handleStartButton)
self.startbutton.setStyleSheet(stylesheet(self))
self.connect(QtGui.QShortcut(QtGui.QKeySequence("s"), self), QtCore.SIGNAL('activated()'), self.handleStartButton)
### set end button ###
self.endbutton = QtGui.QPushButton('set End', self)
self.endbutton.setFixedWidth(70)
self.endbutton.clicked.connect(self.handleEndButton)
self.endbutton.setStyleSheet(stylesheet(self))
self.connect(QtGui.QShortcut(QtGui.QKeySequence("e"), self), QtCore.SIGNAL('activated()'), self.handleEndButton)
### label ###
self.mlabel = QtGui.QLabel('Frame', self)
self.mlabel.setStyleSheet('QLabel \
{background-color: transparent; color: white;}\nQLabel{color: darkcyan; font-size: 12px; background-color: transparent; border-radius: 5px; padding: 6px; text-align: center;}\n QLabel:hover{color: red;}')
#self.mlabel.setFixedWidth(80)
### layout ###
layout = QtGui.QGridLayout(self)
layout.addWidget(self.iconList, 0, 0, 1, 1)
layout.addWidget(self.video, 0, 1, 1, 6)
layout.addWidget(self.slider, 1, 1, 1, 6)
layout.addWidget(self.button, 2, 0, 1, 1)
layout.addWidget(self.savebutton, 2, 1, 1, 1)
layout.addWidget(self.playbutton, 2, 3, 1, 1)
layout.addWidget(self.startbutton, 2, 5, 1, 1)
layout.addWidget(self.endbutton, 2, 6, 1, 1)
layout.addWidget(self.mlabel, 2, 4, 1, 1)
def popup2(self, pos):
contextmenu = QMenu()
contextmenu.addAction("Play / Pause (SPACE)", self.handlePlayButton)
contextmenu.addSeparator()
contextmenu.addAction("Load Video (Ctrl-O)", self.handleButton)
contextmenu.addAction("Save Video (Ctrl-S)", self.handleSaveVideo)
contextmenu.addSeparator()
contextmenu.addAction("Info", self.handleInfo)
contextmenu.addSeparator()
contextmenu.addAction("Exit (q)", self.handleQuit)
contextmenu.exec_(QCursor.pos())
def handleInfo(self):
msg = QMessageBox()
#msg.setFixedSize(500, 300)
#msg.setGeometry(100,100, 400, 200)
msg.setIcon(QMessageBox.Information)
msg.setText("Axel Schneider")
msg.setInformativeText(unicode(u"©2016"))
msg.setWindowTitle("Cut Video")
msg.setDetailedText("Python Qt4")
msg.setStandardButtons(QMessageBox.Ok)
retval = msg.exec_()
print "value of pressed message box button:", retval
def handleQuit(self):
app.quit()
def handleButton(self):
if self.media.state() == Phonon.PlayingState:
self.media.stop()
else:
path = QtGui.QFileDialog.getOpenFileName(self, ("Video laden"),
'/Axel_1/Filme',
"Videos (*.ts *.mp4)")
if path:
self.myfilename = unicode(path) #.encode("utf-8")
window.setWindowTitle(self.myfilename.split("/")[-1])
self.extension = path.split(".")[1]
print(self.extension)
self.media.setCurrentSource(Phonon.MediaSource(path))
self.video.setScaleMode(1)
self.video.setAspectRatio(1)
self.audio = Phonon.AudioOutput(Phonon.VideoCategory, self)
Phonon.createPath(self.media, self.audio)
Phonon.createPath(self.media, self.video)
self.media.play()
self.playbutton.setText('Pause')
def handleSaveVideo(self):
result = QFileDialog.getSaveFileName(self, ("Video speichern"),
'/tmp/film.' + str(self.extension),
"Videos (*.ts *.mp4)")
if result:
target = unicode(result)
self.t1 = float(self.videoCuts[0])
self.t2 = float(self.videoCuts[1])
ffmpeg_extract_subclip(self.myfilename, self.t1, self.t2, targetname=target)
window.setWindowTitle("Film gespeichert")
self.purgeMarker()
def handlePlayButton(self):
if self.media.state() == Phonon.PlayingState:
self.media.pause()
self.playbutton.setText('Play')
else:
#print(self.iconList.count())
self.media.play()
self.playbutton.setText('Pause')
def handleStartButton(self):
if self.iconList.count() < 2:
rm = str(self.media.currentTime() / 100.00 / 10.00)
item = QListWidgetItem()
img = QImage(self.video.snapshot())
pix = QtGui.QPixmap.fromImage(img)
item.setIcon(QIcon(pix))
item.setText("Start: " + rm)
self.iconList.addItem(item)
self.videoCuts.append(rm)
else:
return
def handleEndButton(self):
if self.iconList.count() < 2:
rm = str(self.media.currentTime() / 100.00 / 10.00)
item = QListWidgetItem()
#item.setSizeHint(QSize(150, 40))
img = QImage(self.video.snapshot())
pix = QtGui.QPixmap.fromImage(img)
item.setIcon(QIcon(pix))
item.setText("End: " + rm)
self.iconList.addItem(item)
self.videoCuts.append(rm)
self.t3 = float(str(self.media.remainingTime()))
print(self.t3)
self.media.stop()
self.playbutton.setText('Play')
else:
return
def handleLabel(self):
ms = self.media.currentTime()
seconds=str((ms/1000)%60)
minutes=str((ms/(1000*60))%60)
hours=str((ms/(1000*60*60))%24)
if int(seconds) < 10:
seconds = "0" + seconds
if int(minutes) < 10:
minutes = "0" + minutes
if int(hours) < 10:
hours = "0" + hours
s = hours + ":" + minutes + ":" + seconds
self.mlabel.setText(s)
def _hookListActions(self):
#TOO bad-the list model -should be here...
rmAction = QtGui.QAction(QtGui.QIcon('icons/close-x.png'), 'entfernen', self)
rmAction.triggered.connect(self._removeMarker)
rmAllAction = QtGui.QAction(QtGui.QIcon('icons/clear-all.png'), 'alle entfernen', self)
rmAllAction.triggered.connect(self.purgeMarker)
self.gotoAction = QtGui.QAction(QtGui.QIcon('icons/go-next.png'), 'zu dieser Position springen', self)
self.gotoAction.triggered.connect(self._gotoFromMarker)
#menus
self._listMenu = QMenu()
self._listMenu.addAction(self.gotoAction)
self._listMenu.addSeparator()
self._listMenu.addAction(rmAction)
self._listMenu.addAction(rmAllAction)
#---List widget context menu
def _removeMarker(self,whatis):
selectionList = self.iconList.selectedIndexes()
if len(selectionList)==0:
return
item = selectionList[0]
self.iconList.takeItem(item.row())
#self.videoCuts.remove[1])
def clearMarkerList(self):
self.iconList.clear()
#remove contents, remove file
def purgeMarker(self):
self.iconList.clear()
self.videoCuts = []
def _gotoFromMarker(self,whatis):
selectionList = self.iconList.selectedIndexes()
if len(selectionList)==0:
return
item = selectionList[0]
pos = item.data().toString().replace("Start: ", "").replace("End: ", "")
#frame = pos.ToInt()
#self.video.currentTime = 1589
self.setWindowTitle(pos)
def _openListMenu(self,position):
selectionList = self.iconList.selectedIndexes()
if len(selectionList)==0:
return
self._listMenu.exec_(self.iconList.viewport().mapToGlobal(position))
class AnalyzerTab(myWidget):
def __init__(self, parent = None, *args):
super(AnalyzerTab, self).__init__(parent, *args)
self.currentFolder = QDir.currentPath()
self.addFileRow()
self.addListWidget()
self.addReadRow()
self.addProgressBars()
def addFileRow(self):
self._openBtn = QPushButton(QString.fromUtf8("Ordner auswählen"), self)
self._openTextField = QLineEdit(self)
self._openBtn.clicked.connect(self.openFolder)
self.myLayout.addRow(self._openTextField, self._openBtn)
def addListWidget(self):
self._listWidget = QListWidget(self)
self.myLayout.addRow(self._listWidget)
def addReadRow(self):
self._readBtn = QPushButton(QString.fromUtf8("Inhalt speichern"), self)
self.myLayout.addRow(self._readBtn)
self._readBtn.clicked.connect(self.saveFilesToDB)
def addProgressBars(self):
self._progresses = myWidget(self)
self._progressFiles = QProgressBar(self._progresses)
self._progressParagraphs = QProgressBar(self._progresses)
self._progresses.myLayout.addRow("Dateien", self._progressFiles)
self._progresses.myLayout.addRow("Paragraphen", self._progressParagraphs)
self._progresses.setEnabled(False)
self.myLayout.addRow(self._progresses)
def openFolder(self):
newFolder = str(QFileDialog.getExistingDirectory(parent=self, caption=QString.fromUtf8("Ordner auswählen"), directory = self.currentFolder))
if not newFolder:
print "HIER: ", newFolder
return
self._openTextField.setText(newFolder)
self.listFolderFiles(newFolder)
self.currentFolder = newFolder
def listFolderFiles(self, folderPath):
if not os.path.isdir(folderPath):
print "%s is not a folder!" %folderPath
return
self._listWidget.clear()
for fName in os.listdir(folderPath):
if fName.endswith(".doc") and not fName.startswith("~"): self._listWidget.addItem(fName)
def saveFilesToDB(self):
selWindow = DBSelectorWindow(self)
if not selWindow.exec_(): return
dbName = selWindow.getDBName()
if not dbName:
messageBox(QMessageBox.Critical, "Fehler", "Der Name darf nicht leer sein!", self, QMessageBox.Ok)
return
self.currentReader = Reader()
self._progresses.setEnabled(True)
self.currentReader.ready.connect(self.readerReady)
self.currentReader.folderStatusUpdated.connect(self.updateFolderStatus)
self.currentReader.fileStatusUpdated.connect(self.updateFileStatus)
self.currentReader.save_folder(str(self.currentFolder), "%s.sqlite" %str(dbName))
def readerReady(self):
self._progresses.setEnabled(False)
def updateFolderStatus(self, ready, fileCount):
self._progressFiles.setMaximum(100)
self._progressFiles.setValue(self._calc_status(ready, fileCount))
def updateFileStatus(self, ready, paragraphCount):
self._progressParagraphs.setMaximum(100)
self._progressParagraphs.setValue(self._calc_status(ready, paragraphCount))
def _calc_status(self, done, toDo):
r = done * 100 / toDo
if r == 99:
return 100
else:
return r
class OWMoleculeVisualizer(OWWidget):
settingsList = ["colorFragmets", "showFragments"]
contextHandlers = {
"":
DomainContextHandler("", [
ContextField("selected_title_indices"),
ContextField("moleculeTitleAttributeList",
(DomainContextHandler.List +
DomainContextHandler.SelectedRequired +
DomainContextHandler.IncludeMetaAttributes),
selected="selectedMoleculeTitleAttrs"),
ContextField(
"smiles_var", DomainContextHandler.Required +
DomainContextHandler.IncludeMetaAttributes)
],
maxAttributesToPickle=1000)
}
def __init__(self,
parent=None,
signalManager=None,
title="Molecule visualizer"):
super(OWMoleculeVisualizer, self).__init__(parent, signalManager,
title)
self.colorFragments = 1
self.showFragments = 0
self.selectedFragment = ""
self.moleculeSmiles = []
self.fragmentSmiles = []
self.defFragmentSmiles = []
self.smiles_var = 0
self.moleculeTitleAttr = 0
self.moleculeTitleAttributeList = []
self.selectedMoleculeTitleAttrs = []
self.fragmentSmilesAttr = 0
self.imageSize = 200
self.numColumns = 4
self.commitOnChange = 0
## GUI
box = OWGUI.widgetBox(self.controlArea, "Info", addSpace=True)
self.infoLabel = OWGUI.label(box, self, "Chemicals:")
box = OWGUI.radioButtonsInBox(self.controlArea,
self,
"showFragments",
["Show molecules", "Show fragments"],
"Show",
callback=self.updateitems)
self.showFragmentsRadioButton = box.buttons[-1]
self.markFragmentsCheckBox = OWGUI.checkBox(box,
self,
"colorFragments",
"Mark fragments",
callback=self._update)
box.setSizePolicy(QSizePolicy(QSizePolicy.Minimum,
QSizePolicy.Maximum))
OWGUI.separator(self.controlArea)
self.moleculeSmilesCombo = OWGUI.comboBox(self.controlArea,
self,
"smiles_var",
"Molecule SMILES Attribute",
callback=self.updateitems)
self.moleculeSmilesCombo.box.setSizePolicy(
QSizePolicy(QSizePolicy.Minimum, QSizePolicy.Maximum))
self.smiles_var_model = VariableListModel(parent=self)
self.moleculeSmilesCombo.setModel(self.smiles_var_model)
OWGUI.separator(self.controlArea)
box = OWGUI.widgetBox(self.controlArea,
"Molecule Title Attributes",
addSpace=True)
self.title_var_view = QListView(
selectionMode=QListView.ExtendedSelection)
self.title_var_model = VariableListModel(parent=self)
self.title_var_view.setModel(self.title_var_model)
self.title_var_view.selectionModel().selectionChanged.connect(
self._title_selection_changed)
box.layout().addWidget(self.title_var_view)
OWGUI.separator(self.controlArea)
self.fragmentSmilesCombo = OWGUI.comboBox(
self.controlArea,
self,
"fragmentSmilesAttr",
"Fragment SMILES Attribute",
callback=self.updateFragmentsListBox)
self.fragmentSmilesCombo.setModel(VariableListModel(parent=self))
self.fragmentSmilesCombo.box.setSizePolicy(
QSizePolicy(QSizePolicy.Minimum, QSizePolicy.Maximum))
OWGUI.separator(self.controlArea)
box = OWGUI.spin(self.controlArea,
self,
"imageSize",
50,
500,
10,
box="Image Size",
callback=self._image_size_changed)
box.setSizePolicy(QSizePolicy(QSizePolicy.Minimum,
QSizePolicy.Maximum))
OWGUI.separator(self.controlArea)
box = OWGUI.widgetBox(self.controlArea, "Selection", addSpace=True)
OWGUI.checkBox(box, self, "commitOnChange", "Commit on change")
self.selectMarkedMoleculesButton = OWGUI.button(
box, self, "Select &matched molecules", self.select_marked)
OWGUI.button(box, self, "&Commit", callback=self.commit, default=True)
OWGUI.separator(self.controlArea)
OWGUI.rubber(self.controlArea)
spliter = QSplitter(Qt.Vertical)
self.scrollArea = ScrollArea(spliter)
self.grid = GridWidget()
self.grid.selectionChanged.connect(self._on_selection_changed)
self.scrollArea.setWidget(self.grid)
self.scrollArea.setWidgetResizable(True)
self.mainArea.layout().addWidget(spliter)
if pybel:
self.listBox = QListWidget(spliter)
else:
self.listBox = QListWidget(None)
self.listBox.setHidden(True)
self.listBox.itemClicked.connect(self.fragmentSelection)
self.fragmentSmilesCombo.box.setDisabled(not pybel)
self.data = None
self.data_subset = []
self.fragment_data = None
self.resize(800, 600)
self.listBox.setMaximumHeight(150)
self.fragmentSmilesCombo.setDisabled(True)
self.selectMarkedMoleculesButton.setDisabled(True)
self.markFragmentsCheckBox.setDisabled(True)
self.showFragmentsRadioButton.setDisabled(True)
self.loadSettings()
if not pybel:
self.showFragments = 0
self.warning(
10, "Pybel module not installed. To view molecule fragments\n"
"please install openbabel python extension.")
self.__loop = None
def setMoleculeTable(self, data):
self.closeContext()
self.clear()
self.data = data
if data is not None:
all_vars = data.domain.variables + data.domain.get_metas().values()
text_vars = filter(
lambda v: isinstance(v, (Orange.feature.Discrete, Orange.
feature.String)), all_vars)
var_scored = score_smiles_variables(data, text_vars)
self.smiles_var_model[:] = [var for var, _ in var_scored]
self.smiles_var = max(range(len(var_scored)),
key=lambda i: var_scored[i][1])
self.title_var_model[:] = all_vars
self.setFragmentSmilesCombo()
self.updateFragmentsListBox()
if self.data_subset:
try:
self.data_subset = self.data_subset.select(
self.data.domain)
except Exception:
self.data_subset = []
self.openContext("", data)
else:
self.defFragmentSmiles = []
if not self.fragmentSmilesAttr:
self.listBox.clear()
self.openContext("", data)
self.send("Selected Molecules", None)
def setMoleculeSubset(self, data):
self.data_subset = data
try:
self.data_subset = self.data_subset.select(self.data.domain)
except Exception:
self.data_subset = []
def setFragmentTable(self, data):
self.fragment_data = data
if data is not None:
self.setFragmentSmilesCombo()
self.updateFragmentsListBox()
self.selectedFragment = ""
else:
self.setFragmentSmilesCombo()
self.updateFragmentsListBox()
self.fragmentSmilesCombo.setEnabled(data is not None)
def handleNewSignals(self):
self.updateitems()
def clear(self):
self.smiles_var_model[:] = []
self.title_var_model[:] = []
self.fragmentSmilesCombo.clear()
self.grid.clear()
self._widgets = []
self._items = []
if self.__loop is not None:
self.__loop.close()
self.__loop = None
def cleargrid(self):
self.grid.clear()
self._widgets = []
def _update_titles(self):
if self.data is None:
return
title_vars = [
self.title_var_model[ind.row()]
for ind in self.title_var_view.selectedIndexes()
]
for item, widget in zip(self._items, self._widgets):
inst = self.data[item.index]
text = " / ".join(map(str, (inst[var] for var in title_vars)))
widget.label.setText(text)
def setFragmentSmilesCombo(self):
if self.fragment_data:
candidates = score_smiles_variables(self.fragment_data)
else:
candidates = []
self.fragmentSmilesCombo.model()[:] = [v for v, _ in candidates]
if self.fragmentSmilesAttr > len(candidates):
self.fragmentSmilesAttr = 0
def updateFragmentsListBox(self):
if pybel is None:
return
fragvars = self.fragmentSmilesCombo.model()
if 0 <= self.fragmentSmilesAttr < len(fragvars):
fvar = fragvars[self.fragmentSmilesAttr]
else:
fvar = None
if fvar:
frags = [
str(e[fvar]) for e in self.fragment_data
if not e[fvar].is_special()
]
self.fragmentSmiles = [""] + frags
else:
self.fragmentSmiles = [""] + self.defFragmentSmiles
self.listBox.clear()
self.listBox.addItems(self.fragmentSmiles)
self.showFragmentsRadioButton.setDisabled(
len(self.fragmentSmiles) == 1)
self.markFragmentsCheckBox.setDisabled(len(self.fragmentSmiles) == 1)
self.selectMarkedMoleculesButton.setDisabled(True)
def fragmentSelection(self, item):
if pybel is None:
return
index = self.listBox.indexFromItem(item).row()
if index == -1:
index = 0
self.selectedFragment = self.fragmentSmiles[index]
self.selectMarkedMoleculesButton.setEnabled(bool(
self.selectedFragment))
self.markFragmentsCheckBox.setEnabled(bool(self.selectedFragment))
if not self.showFragments and self.colorFragments:
self._update()
def _title_text(self, index):
title_vars = [
self.title_var_model[ind.row()]
for ind in self.title_var_view.selectedIndexes()
]
inst = self.data[index]
return " / ".join(map(str, (inst[var] for var in title_vars)))
def _items_from_var(self, var):
if self.data is None:
return None
values = [(i, str(inst[var])) for i, inst in enumerate(self.data)
if not inst[var].is_special()]
return [
Item(i, smiles, *self._parse_smiles(smiles))
for i, smiles in values
]
def _parse_smiles(self, smiles):
try:
return (OK, molecule_from_smiles(smiles))
except Exception:
return (ParseError, None)
def updateitems(self):
if self.showFragments and self.fragmentSmiles:
values = [(None, frag) for frag in self.fragmentSmiles[1:]]
items = [
Item(i, smiles, *self._parse_smiles(smiles))
for i, smiles in values
]
else:
smilesvar = self.smiles_var_model[self.smiles_var]
items = self._items_from_var(smilesvar)
self._items = items
self.setupgrid()
def setupgrid(self):
self.cleargrid()
layout = self.grid
widgets = []
for item in self._items:
thumb = ThumbnailWidget(self.grid)
thumb.setImageSize(self.imageSize, self.imageSize)
if item.index is not None:
text = self._title_text(item.index)
else:
text = ""
thumb.label.setText(text)
widgets.append(thumb)
layout.appendWidget(thumb)
self._widgets = widgets
self.infoLabel.setText("Chemicals %i" % len(self._items))
self._update()
def __update_items(self, items, widgets, pattern=None):
for i, item, widget in zip(range(len(items)), items, widgets):
if item.status != ParseError:
if pattern is not None:
emb = substructure_embedding(item.molecule, pattern)
emb = reduce(list.__iadd__, emb, [])
svg = molecule_to_svg_with_substructure(item.molecule, emb)
else:
svg = molecule_to_svg(item.molecule)
else:
svg = ""
widget.setData(svg)
widget.setEnabled(True)
yield i * 100.0 / len(items)
def _update(self):
if self.showFragments and self.fragmentSmiles:
loop = self.__update_items(self._items, self._widgets)
elif self.colorFragments and self.selectedFragment:
pattern = pybel.Smarts(self.selectedFragment)
loop = self.__update_items(self._items, self._widgets, pattern)
else:
loop = self.__update_items(self._items, self._widgets)
self.__schedule(loop)
def __schedule(self, coroutine):
if self.__loop is not None:
self.progressBarFinished()
self.__loop.close()
self.__loop = None
self.__loop = coroutine
self.progressBarInit()
QTimer.singleShot(0, self.__loop_update)
@Slot()
def __loop_update(self):
if self.__loop is None:
return
try:
progress = next(self.__loop)
except StopIteration:
self.__loop = None
self.progressBarFinished()
else:
self.progressBarSet(progress)
QTimer.singleShot(0, self.__loop_update)
def _title_selection_changed(self):
self._update_titles()
def _image_size_changed(self):
for widget in self._widgets:
widget.setImageSize(self.imageSize, self.imageSize)
self.grid.layout().invalidate()
def select_marked(self):
if not pybel:
return
if not self.showFragments:
pattern = pybel.Smarts(self.selectedFragment)
for item, widget in zip(self._items, self._widgets):
if item.status != ParseError:
emb = substructure_embedding(item.molecule, pattern)
widget.setSelected(bool(emb))
else:
widget.setSelected(False)
if self.commitOnChange:
self.commit()
def _on_selection_changed(self):
if self.commitOnChange:
self.commit()
def commit(self):
if self.showFragments:
svar = self.smiles_var_model[self.smiles_var]
items = self._items_from_var(svar)
frags = [
item for item, w in zip(self._items, self._widgets)
if w.selected
]
patterns = [pybel.Smarts(item.smiles) for item in frags]
def test(molecule, patterns):
return any(
bool(substructure_embedding(molecule, patt))
for patt in patterns)
matched = filter(
lambda item: item.status != ParseError and test(
item.molecule, patterns), items)
instances = [self.data[item.index] for item in matched]
if instances:
table = Orange.data.Table(instances)
self.send("Selected Molecules", table)
else:
self.send("Selected Molecules", None)
else:
items = [
item for item, w in zip(self._items, self._widgets)
if w.selected
]
instances = [self.data[item.index] for item in items]
if instances:
table = Orange.data.Table(instances)
self.send("Selected Molecules", table)
else:
self.send("Selected Molecules", None)
def onDeleteWidget(self):
OWWidget.onDeleteWidget(self)
if self.__loop is not None:
self.__loop.close()
self.__loop = None
class Completer(QCompleter):
def __init__(self, editor, project):
QCompleter.__init__(self)
self.icons = {
'function': QIcon(resources.images['function']),
'instance': QIcon(resources.images['attribute']),
'module': QIcon(resources.images['module']),
'class': QIcon(resources.images['class'])
}
self._editor = editor
self._fromProject = False
if project is not None:
if type(project) is str:
project = rope.base.project.Project(project, None,
'.ninjaproject')
self._project = project
self._fromProject = True
else:
self._project = rope.base.project.get_no_project()
self.setWidget(self._editor)
self.popupView = QListWidget()
self.popupView.setAlternatingRowColors(True)
self.popupView.setWordWrap(False)
self.setPopup(self.popupView)
self.setCompletionMode(QCompleter.PopupCompletion)
self.setCaseSensitivity(Qt.CaseInsensitive)
self.connect(self, SIGNAL("activated(QString)"),
self.insert_completion)
def insert_completion(self, insert):
extra = insert.length() - self.completionPrefix().length()
self._editor.textCursor().insertText(insert.right(extra))
def complete(self, cr):
if self._project:
try:
self.popupView.clear()
code = str(self._editor.toPlainText())
start = self._editor.textCursor().position()
if self._fromProject:
self._project.validate()
proposals = codeassist.code_assist(self._project, code, start)
proposals = codeassist.sorted_proposals(proposals)
model = self.obtain_model_items(proposals)
self.setModel(model)
self.popup().setCurrentIndex(model.index(0, 0))
cr.setWidth(self.popup().sizeHintForColumn(0) \
+ self.popup().verticalScrollBar().sizeHint().width() + 10)
self.popupView.updateGeometries()
super(Completer, self).complete(cr)
except:
return
def obtain_model_items(self, proposals):
for p in proposals:
if p.type == 'function':
self.popupView.addItem(
QListWidgetItem(
self.icons[p.type], '%s(%s)' % (p.name, ', '.join([
n for n in p.pyname.get_object().get_param_names()
if n != 'self'
]))))
else:
self.popupView.addItem(
QListWidgetItem(
self.icons.get(p.type, self.icons['class']), p.name))
return self.popupView.model()
def get_path_from_project(self):
if self._fromProject:
return self._project.root.real_path
else:
return None
class CodeCompletionWidget(QFrame):
def __init__(self, editor):
super(CodeCompletionWidget, self).__init__(
None, Qt.FramelessWindowHint | Qt.ToolTip)
self._editor = editor
self._revision = 0
self._block = 0
self.stack_layout = QStackedLayout(self)
self.stack_layout.setContentsMargins(0, 0, 0, 0)
self.stack_layout.setSpacing(0)
self.completion_list = QListWidget()
self.completion_list.setMinimumHeight(200)
self.completion_list.setAlternatingRowColors(True)
self._list_index = self.stack_layout.addWidget(self.completion_list)
self._icons = {'a': resources.IMAGES['attribute'],
'f': resources.IMAGES['function'],
'c': resources.IMAGES['class'],
'm': resources.IMAGES['module']}
self.cc = code_completion.CodeCompletion()
self._completion_results = {}
self._prefix = u''
self.setVisible(False)
self.source = ''
self._key_operations = {
Qt.Key_Up: self._select_previous_row,
Qt.Key_Down: self._select_next_row,
Qt.Key_PageUp: (lambda: self._select_previous_row(6)),
Qt.Key_PageDown: (lambda: self._select_next_row(6)),
Qt.Key_Right: lambda: None,
Qt.Key_Left: lambda: None,
Qt.Key_Enter: self.pre_key_insert_completion,
Qt.Key_Return: self.pre_key_insert_completion,
Qt.Key_Tab: self.pre_key_insert_completion,
Qt.Key_Space: self.hide_completer,
Qt.Key_Escape: self.hide_completer,
Qt.Key_Backtab: self.hide_completer,
Qt.NoModifier: self.hide_completer,
Qt.ShiftModifier: self.hide_completer,
}
self.desktop = QApplication.instance().desktop()
self.connect(self.completion_list,
SIGNAL("itemClicked(QListWidgetItem*)"),
self.pre_key_insert_completion)
self.connect(self._editor.document(),
SIGNAL("cursorPositionChanged(QTextCursor)"),
self.update_metadata)
def _select_next_row(self, move=1):
new_row = self.completion_list.currentRow() + move
if new_row < self.completion_list.count():
self.completion_list.setCurrentRow(new_row)
else:
self.completion_list.setCurrentRow(0)
return True
def _select_previous_row(self, move=1):
new_row = self.completion_list.currentRow() - move
if new_row >= 0:
self.completion_list.setCurrentRow(new_row)
else:
self.completion_list.setCurrentRow(
self.completion_list.count() - move)
return True
def update_metadata(self, cursor):
if settings.CODE_COMPLETION:
if self._editor.document().revision() != self._revision and \
cursor.block().blockNumber() != self._block:
source = self._editor.get_text()
source = source.encode(self._editor.encoding)
self.cc.analyze_file(self._editor.ID, source)
self._revision = self._editor.document().revision()
self._block = cursor.block().blockNumber()
def insert_completion(self, insert, type_=ord('a')):
if insert != self._prefix:
closing = ''
if type_ in (ord('f'), ord('c')):
closing = '()'
extra = len(self._prefix) - len(insert)
insertion = '%s%s' % (insert[extra:], closing)
self._editor.textCursor().insertText(insertion)
self.hide_completer()
def _get_geometry(self):
cr = self._editor.cursorRect()
desktop_geometry = self.desktop.availableGeometry(self._editor)
point = self._editor.mapToGlobal(cr.topLeft())
cr.moveTopLeft(point)
#Check new position according desktop geometry
width = (self.completion_list.sizeHintForColumn(0) +
self.completion_list.verticalScrollBar().sizeHint().width() + 10)
height = 200
orientation = (point.y() + height) < desktop_geometry.height()
if orientation:
cr.moveTop(cr.bottom())
cr.setWidth(width)
cr.setHeight(height)
if not orientation:
cr.moveBottom(cr.top())
xpos = desktop_geometry.width() - (point.x() + width)
if xpos < 0:
cr.moveLeft(cr.left() + xpos)
return cr
def complete(self, results):
self.add_list_items(results)
self.completion_list.setCurrentRow(0)
cr = self._get_geometry()
self.setGeometry(cr)
self.completion_list.updateGeometries()
self.show()
def add_list_items(self, proposals):
self.completion_list.clear()
for p in proposals:
self.completion_list.addItem(
QListWidgetItem(
QIcon(self._icons.get(p[0], resources.IMAGES['attribute'])),
p[1], type=ord(p[0])))
def set_completion_prefix(self, prefix, valid=True):
self._prefix = prefix
proposals = []
proposals += [('m', item)
for item in self._completion_results.get('modules', [])
if item.startswith(prefix)]
proposals += [('c', item)
for item in self._completion_results.get('classes', [])
if item.startswith(prefix)]
proposals += [('a', item)
for item in self._completion_results.get('attributes', [])
if item.startswith(prefix)]
proposals += [('f', item)
for item in self._completion_results.get('functions', [])
if item.startswith(prefix)]
if proposals and valid:
self.complete(proposals)
else:
self.hide_completer()
def _invalid_completion_position(self):
result = False
cursor = self._editor.textCursor()
cursor.movePosition(QTextCursor.StartOfLine,
QTextCursor.KeepAnchor)
selection = unicode(cursor.selectedText())[:-1].split(' ')
if len(selection) == 0 or selection[-1] == '' or \
selection[-1].isdigit():
result = True
return result
def fill_completer(self, force_completion=False):
if not force_completion and (self._editor.cursor_inside_string() or
self._editor.cursor_inside_comment() or
self._invalid_completion_position()):
return
source = self._editor.get_text()
source = source.encode(self._editor.encoding)
offset = self._editor.textCursor().position()
results = self.cc.get_completion(source, offset)
self._completion_results = results
if force_completion:
cursor = self._editor.textCursor()
cursor.movePosition(QTextCursor.StartOfWord,
QTextCursor.KeepAnchor)
prefix = cursor.selectedText()
else:
prefix = self._editor._text_under_cursor()
self.set_completion_prefix(prefix)
def hide_completer(self):
self._prefix = ''
self.hide()
def pre_key_insert_completion(self):
type_ = ord('a')
current = self.completion_list.currentItem()
insert = unicode(current.text())
if not insert.endswith(')'):
type_ = current.type()
self.insert_completion(insert, type_)
self.hide_completer()
return True
def process_pre_key_event(self, event):
if not self.isVisible() or self._editor.lang != "python":
return False
skip = self._key_operations.get(event.key(), lambda: False)()
self._key_operations.get(event.modifiers(), lambda: False)()
if skip is None:
skip = False
return skip
def process_post_key_event(self, event):
if not settings.CODE_COMPLETION or self._editor.lang != "python":
return
if self.isVisible():
source = self._editor.get_text()
source = source.encode(self._editor.encoding)
offset = self._editor.textCursor().position()
prefix, valid = self.cc.get_prefix(source, offset)
self.set_completion_prefix(prefix, valid)
self.completion_list.setCurrentRow(0)
force_completion = (event.key() == Qt.Key_Space and
event.modifiers() == Qt.ControlModifier)
if event.key() == Qt.Key_Period or force_completion:
self.fill_completer(force_completion)
class PopupCompleter(QFrame):
def __init__(self):
QFrame.__init__(self, None, Qt.FramelessWindowHint | Qt.ToolTip)
vbox = QVBoxLayout(self)
vbox.setContentsMargins(0, 0, 0, 0)
vbox.setSpacing(0)
self.listWidget = QListWidget()
self.listWidget.setMinimumHeight(300)
vbox.addWidget(self.listWidget)
def reload(self, model):
"""Reload the data of the Popup Completer, and restart the state."""
self.listWidget.clear()
self.add_help()
for item in model:
self.listWidget.addItem(item[0])
self.listWidget.setItemWidget(item[0], item[1])
self.listWidget.setCurrentRow(6)
def clear(self):
"""Remove all the items of the list (deleted), and reload the help."""
self.listWidget.clear()
def refresh(self, model):
"""Refresh the list when the user search for some word."""
self.listWidget.clear()
for item in model:
self.listWidget.addItem(item[0])
self.listWidget.setItemWidget(item[0], item[1])
if model:
self.listWidget.setCurrentItem(model[0][0])
def fetch_more(self, model):
"""Add more items to the list on user scroll."""
for item in model:
self.listWidget.addItem(item[0])
self.listWidget.setItemWidget(item[0], item[1])
def add_help(self):
#Load help
fileItem = QListWidgetItem(QIcon(resources.IMAGES['locate-file']),
'@\t(Filter only by Files)')
font = fileItem.font()
font.setBold(True)
fileItem.setSizeHint(QSize(20, 30))
fileItem.setBackground(QBrush(Qt.lightGray))
fileItem.setForeground(QBrush(Qt.black))
fileItem.setFont(font)
self.listWidget.addItem(fileItem)
classItem = QListWidgetItem(QIcon(resources.IMAGES['locate-class']),
'<\t(Filter only by Classes)')
self.listWidget.addItem(classItem)
classItem.setSizeHint(QSize(20, 30))
classItem.setBackground(QBrush(Qt.lightGray))
classItem.setForeground(QBrush(Qt.black))
classItem.setFont(font)
methodItem = QListWidgetItem(
QIcon(resources.IMAGES['locate-function']),
'>\t(Filter only by Methods)')
self.listWidget.addItem(methodItem)
methodItem.setSizeHint(QSize(20, 30))
methodItem.setBackground(QBrush(Qt.lightGray))
methodItem.setForeground(QBrush(Qt.black))
methodItem.setFont(font)
attributeItem = QListWidgetItem(
QIcon(resources.IMAGES['locate-attributes']),
'-\t(Filter only by Attributes)')
self.listWidget.addItem(attributeItem)
attributeItem.setSizeHint(QSize(20, 30))
attributeItem.setBackground(QBrush(Qt.lightGray))
attributeItem.setForeground(QBrush(Qt.black))
attributeItem.setFont(font)
thisFileItem = QListWidgetItem(
QIcon(resources.IMAGES['locate-on-this-file']),
'.\t(Filter only by Classes and Methods in this File)')
font = thisFileItem.font()
font.setBold(True)
thisFileItem.setSizeHint(QSize(20, 30))
thisFileItem.setBackground(QBrush(Qt.lightGray))
thisFileItem.setForeground(QBrush(Qt.black))
thisFileItem.setFont(font)
self.listWidget.addItem(thisFileItem)
nonPythonItem = QListWidgetItem(
QIcon(resources.IMAGES['locate-nonpython']),
'!\t(Filter only by Non Python Files)')
self.listWidget.addItem(nonPythonItem)
nonPythonItem.setSizeHint(QSize(20, 30))
nonPythonItem.setBackground(QBrush(Qt.lightGray))
nonPythonItem.setForeground(QBrush(Qt.black))
nonPythonItem.setFont(font)
class CodeCompletionWidget(QFrame):
def __init__(self, editor):
super(CodeCompletionWidget,
self).__init__(None, Qt.FramelessWindowHint | Qt.ToolTip)
self._editor = editor
self._revision = 0
self._block = 0
self.stack_layout = QStackedLayout(self)
self.stack_layout.setContentsMargins(0, 0, 0, 0)
self.stack_layout.setSpacing(0)
self.completion_list = QListWidget()
self.completion_list.setMinimumHeight(200)
self.completion_list.setAlternatingRowColors(True)
self._list_index = self.stack_layout.addWidget(self.completion_list)
self._icons = {
'a': resources.IMAGES['attribute'],
'f': resources.IMAGES['function'],
'c': resources.IMAGES['class'],
'm': resources.IMAGES['module']
}
self.cc = code_completion.CodeCompletion()
self._completion_results = {}
self._prefix = ''
self.setVisible(False)
self.source = ''
self._key_operations = {
Qt.Key_Up: self._select_previous_row,
Qt.Key_Down: self._select_next_row,
Qt.Key_PageUp: (lambda: self._select_previous_row(6)),
Qt.Key_PageDown: (lambda: self._select_next_row(6)),
Qt.Key_Right: lambda: None,
Qt.Key_Left: lambda: None,
Qt.Key_Enter: self.pre_key_insert_completion,
Qt.Key_Return: self.pre_key_insert_completion,
Qt.Key_Tab: self.pre_key_insert_completion,
Qt.Key_Space: self.hide_completer,
Qt.Key_Escape: self.hide_completer,
Qt.Key_Backtab: self.hide_completer,
Qt.NoModifier: self.hide_completer,
Qt.ShiftModifier: self.hide_completer,
}
self.desktop = QApplication.instance().desktop()
self.connect(self.completion_list,
SIGNAL("itemClicked(QListWidgetItem*)"),
self.pre_key_insert_completion)
self.connect(self._editor.document(),
SIGNAL("cursorPositionChanged(QTextCursor)"),
self.update_metadata)
def _select_next_row(self, move=1):
new_row = self.completion_list.currentRow() + move
if new_row < self.completion_list.count():
self.completion_list.setCurrentRow(new_row)
else:
self.completion_list.setCurrentRow(0)
return True
def _select_previous_row(self, move=1):
new_row = self.completion_list.currentRow() - move
if new_row >= 0:
self.completion_list.setCurrentRow(new_row)
else:
self.completion_list.setCurrentRow(self.completion_list.count() -
move)
return True
def update_metadata(self, cursor):
if settings.CODE_COMPLETION:
if self._editor.document().revision() != self._revision and \
cursor.block().blockNumber() != self._block:
source = self._editor.get_text()
source = source.encode(self._editor.encoding)
self.cc.analyze_file(self._editor.ID, source,
self._editor.indent, self._editor.useTabs)
self._revision = self._editor.document().revision()
self._block = cursor.block().blockNumber()
def insert_completion(self, insert, type_=ord('a')):
if insert != self._prefix:
closing = ''
if type_ in (ord('f'), ord('c')):
closing = '()'
extra = len(self._prefix) - len(insert)
insertion = '%s%s' % (insert[extra:], closing)
self._editor.textCursor().insertText(insertion)
self.hide_completer()
def _get_geometry(self):
cr = self._editor.cursorRect()
desktop_geometry = self.desktop.availableGeometry(self._editor)
point = self._editor.mapToGlobal(cr.topLeft())
cr.moveTopLeft(point)
#Check new position according desktop geometry
width = (self.completion_list.sizeHintForColumn(0) +
self.completion_list.verticalScrollBar().sizeHint().width() +
10)
height = 200
orientation = (point.y() + height) < desktop_geometry.height()
if orientation:
cr.moveTop(cr.bottom())
cr.setWidth(width)
cr.setHeight(height)
if not orientation:
cr.moveBottom(cr.top())
xpos = desktop_geometry.width() - (point.x() + width)
if xpos < 0:
cr.moveLeft(cr.left() + xpos)
return cr
def complete(self, results):
self.add_list_items(results)
self.completion_list.setCurrentRow(0)
cr = self._get_geometry()
self.setGeometry(cr)
self.completion_list.updateGeometries()
self.show()
def add_list_items(self, proposals):
self.completion_list.clear()
for p in proposals:
self.completion_list.addItem(
QListWidgetItem(QIcon(
self._icons.get(p[0], resources.IMAGES['attribute'])),
p[1],
type=ord(p[0])))
def set_completion_prefix(self, prefix, valid=True):
self._prefix = prefix
proposals = []
proposals += [('m', item)
for item in self._completion_results.get('modules', [])
if item.startswith(prefix)]
proposals += [('c', item)
for item in self._completion_results.get('classes', [])
if item.startswith(prefix)]
proposals += [
('a', item)
for item in self._completion_results.get('attributes', [])
if item.startswith(prefix)
]
proposals += [
('f', item)
for item in self._completion_results.get('functions', [])
if item.startswith(prefix)
]
if proposals and valid:
self.complete(proposals)
else:
self.hide_completer()
def _invalid_completion_position(self):
result = False
cursor = self._editor.textCursor()
cursor.movePosition(QTextCursor.StartOfLine, QTextCursor.KeepAnchor)
selection = cursor.selectedText()[:-1].split(' ')
if len(selection) == 0 or selection[-1] == '' or \
selection[-1].isdigit():
result = True
return result
def fill_completer(self, force_completion=False):
if not force_completion and (self._editor.cursor_inside_string()
or self._editor.cursor_inside_comment()
or self._invalid_completion_position()):
return
source = self._editor.get_text()
source = source.encode(self._editor.encoding)
offset = self._editor.textCursor().position()
results = self.cc.get_completion(source, offset)
self._completion_results = results
if force_completion:
cursor = self._editor.textCursor()
cursor.movePosition(QTextCursor.StartOfWord,
QTextCursor.KeepAnchor)
prefix = cursor.selectedText()
else:
prefix = self._editor._text_under_cursor()
self.set_completion_prefix(prefix)
def hide_completer(self):
self._prefix = ''
self.hide()
def pre_key_insert_completion(self):
type_ = ord('a')
current = self.completion_list.currentItem()
insert = current.text()
if not insert.endswith(')'):
type_ = current.type()
self.insert_completion(insert, type_)
self.hide_completer()
return True
def process_pre_key_event(self, event):
if not self.isVisible() or self._editor.lang != "python":
return False
skip = self._key_operations.get(event.key(), lambda: False)()
self._key_operations.get(event.modifiers(), lambda: False)()
if skip is None:
skip = False
return skip
def process_post_key_event(self, event):
if not settings.CODE_COMPLETION or self._editor.lang != "python":
return
if self.isVisible():
source = self._editor.get_text()
source = source.encode(self._editor.encoding)
offset = self._editor.textCursor().position()
prefix, valid = self.cc.get_prefix(source, offset)
self.set_completion_prefix(prefix, valid)
self.completion_list.setCurrentRow(0)
force_completion = (event.key() == Qt.Key_Space
and event.modifiers() == Qt.ControlModifier)
if event.key() == Qt.Key_Period or force_completion:
self.fill_completer(force_completion)
class CheckList(QWidget):
def __init__(self, model, label="", help_link="", custom_filter_button=None):
"""
:param custom_filter_button: if needed, add a button that opens a custom filter menu. Useful when search alone
isn't enough to filter the list.
:type custom_filter_button: QToolButton
"""
QWidget.__init__(self)
self._model = model
if help_link != "":
addHelpToWidget(self, help_link)
layout = QVBoxLayout()
self._createCheckButtons()
self._list = QListWidget()
self._list.setContextMenuPolicy(Qt.CustomContextMenu)
self._list.setSelectionMode(QAbstractItemView.ExtendedSelection)
self._search_box = SearchBox()
check_button_layout = QHBoxLayout()
check_button_layout.setMargin(0)
check_button_layout.setSpacing(0)
check_button_layout.addWidget(QLabel(label))
check_button_layout.addStretch(1)
check_button_layout.addWidget(self._checkAllButton)
check_button_layout.addWidget(self._uncheckAllButton)
layout.addLayout(check_button_layout)
layout.addWidget(self._list)
"""
Inserts the custom filter button, if provided. The caller is responsible for all related actions.
"""
if custom_filter_button is not None:
search_bar_layout = QHBoxLayout()
search_bar_layout.addWidget(self._search_box)
search_bar_layout.addWidget(custom_filter_button)
layout.addLayout(search_bar_layout)
else:
layout.addWidget(self._search_box)
self.setLayout(layout)
self._checkAllButton.clicked.connect(self.checkAll)
self._uncheckAllButton.clicked.connect(self.uncheckAll)
self._list.itemChanged.connect(self.itemChanged)
self._search_box.filterChanged.connect(self.filterList)
self._list.customContextMenuRequested.connect(self.showContextMenu)
self._model.selectionChanged.connect(self.modelChanged)
self._model.modelChanged.connect(self.modelChanged)
self.modelChanged()
def _createCheckButtons(self):
self._checkAllButton = QToolButton()
self._checkAllButton.setIcon(resourceIcon("checked"))
self._checkAllButton.setIconSize(QSize(16, 16))
self._checkAllButton.setToolButtonStyle(Qt.ToolButtonIconOnly)
self._checkAllButton.setAutoRaise(True)
self._checkAllButton.setToolTip("Select all")
self._uncheckAllButton = QToolButton()
self._uncheckAllButton.setIcon(resourceIcon("notchecked"))
self._uncheckAllButton.setIconSize(QSize(16, 16))
self._uncheckAllButton.setToolButtonStyle(Qt.ToolButtonIconOnly)
self._uncheckAllButton.setAutoRaise(True)
self._uncheckAllButton.setToolTip("Unselect all")
def itemChanged(self, item):
"""@type item: QListWidgetItem"""
if item.checkState() == Qt.Checked:
self._model.selectValue(str(item.text()))
elif item.checkState() == Qt.Unchecked:
self._model.unselectValue(str(item.text()))
else:
raise AssertionError("Unhandled checkstate!")
def modelChanged(self):
self._list.clear()
items = self._model.getList()
for item in items:
list_item = QListWidgetItem(item)
list_item.setFlags(list_item.flags() | Qt.ItemIsUserCheckable)
if self._model.isValueSelected(item):
list_item.setCheckState(Qt.Checked)
else:
list_item.setCheckState(Qt.Unchecked)
self._list.addItem(list_item)
self.filterList(self._search_box.filter())
def setSelectionEnabled(self, enabled):
self.setEnabled(enabled)
self._checkAllButton.setEnabled(enabled)
self._uncheckAllButton.setEnabled(enabled)
def filterList(self, filter):
filter = filter.lower()
for index in range(0, self._list.count()):
item = self._list.item(index)
text = str(item.text()).lower()
if filter == "":
item.setHidden(False)
elif filter in text:
item.setHidden(False)
else:
item.setHidden(True)
def checkAll(self):
"""
Checks all visible items in the list.
"""
for index in range(0, self._list.count()):
item = self._list.item(index)
if not item.isHidden():
self._model.selectValue(str(item.text()))
def uncheckAll(self):
"""
Unchecks all items in the list, visible or not
"""
self._model.unselectAll()
def checkSelected(self):
items = []
for item in self._list.selectedItems():
items.append(str(item.text()))
for item in items:
self._model.selectValue(item)
def uncheckSelected(self):
items = []
for item in self._list.selectedItems():
items.append(str(item.text()))
for item in items:
self._model.unselectValue(item)
def showContextMenu(self, point):
p = self._list.mapToGlobal(point)
menu = QMenu()
check_selected = menu.addAction("Check selected")
uncheck_selected = menu.addAction("Uncheck selected")
menu.addSeparator()
clear_selection = menu.addAction("Clear selection")
selected_item = menu.exec_(p)
if selected_item == check_selected:
self.checkSelected()
elif selected_item == uncheck_selected:
self.uncheckSelected()
elif selected_item == clear_selection:
self._list.clearSelection()
class MainWindow(QMainWindow):
def __init__(self, parent=None):
super(MainWindow, self).__init__(parent)
self.setWindowTitle('Address Book')
self.resize(704, 459)
self.db_file = self.database_file()
self.db = database.Database(self.db_file)
dialog = dialogs.UserPanelDlg(self)
if dialog.exec_():
self.user = dialog.user
else:
self.close()
self.categComboBox = QComboBox()
self.cont_numLabel = QLabel()
self.contactsListWidget = QListWidget()
self.searchLineEdit = QLineEdit()
widgets = ((QLabel('Category:'), self.categComboBox),
(self.cont_numLabel, None),
(self.contactsListWidget,),
(QLabel('Search:'), self.searchLineEdit))
vlayout1 = QVBoxLayout()
for i in widgets:
hlayout = pyqttools.add_to_layout(QHBoxLayout(), i)
vlayout1.addLayout(hlayout)
addToolButton = QToolButton()
addToolButton.setIcon(QIcon(':addcontact.jpeg'))
addToolButton.setIconSize(QSize(45, 45))
self.showLabel = QLabel()
self.showLabel.setFrameShape(QFrame.StyledPanel)
self.showLabel.setAlignment(Qt.AlignLeading|Qt.AlignLeft|Qt.AlignTop)
self.editButton = QPushButton('Edit')
self.delButton = QPushButton('Delete')
widgets = ((None, addToolButton, None),
(self.showLabel,),
(None, self.editButton, self.delButton))
vlayout2 = QVBoxLayout()
for i in widgets:
hlayout = pyqttools.add_to_layout(QHBoxLayout(), i)
vlayout2.addLayout(hlayout)
f_layout = pyqttools.add_to_layout(QHBoxLayout(), (vlayout1, vlayout2))
Widget = QWidget()
Widget.setLayout(f_layout)
self.setCentralWidget(Widget)
self.statusBar = self.statusBar()
self.userLabel = QLabel()
self.statusBar.addPermanentWidget(self.userLabel)
c_action = pyqttools.create_action
panelAction = c_action(self, 'User panel', triggered=self.user_panel)
quitAction = c_action(self, 'Quit', 'Ctrl+Q',triggered=self.close)
add_contactAction = c_action(self, 'Add contact', 'Ctrl+N',
triggered=self.add_contact)
delete_allAction = c_action(self, 'Delete all contacts',
triggered=self.delete_all)
delete_categAction = c_action(self, 'Delete categories',
triggered=self.delete_categories)
backupAction = c_action(self, 'Backup', triggered=self.backup)
restoreAction = c_action(self, 'Restore', triggered=self.restore)
aboutAction = c_action(self, 'About', 'Ctrl+?', triggered=self.about)
fileMenu = self.menuBar().addMenu('File')
contactsMenu = self.menuBar().addMenu('Contacts')
deleteMenu = self.menuBar().addMenu(self.tr('Delete'))
backupMenu = self.menuBar().addMenu(self.tr('Backup'))
helpMenu = self.menuBar().addMenu('Help')
pyqttools.add_actions(fileMenu, [panelAction, None, quitAction])
pyqttools.add_actions(contactsMenu, [add_contactAction])
pyqttools.add_actions(deleteMenu,[delete_allAction,delete_categAction])
pyqttools.add_actions(backupMenu, [backupAction, restoreAction])
pyqttools.add_actions(helpMenu, [aboutAction])
addToolButton.clicked.connect(self.add_contact)
self.editButton.clicked.connect(self.edit_contact)
self.delButton.clicked.connect(self.delete_contact)
self.categComboBox.currentIndexChanged.connect(self.fill_ListWidget)
self.contactsListWidget.currentRowChanged.connect(self.show_contact)
self.searchLineEdit.textEdited.connect(self.search)
self.fill_categComboBox()
self.refresh_userLabel()
def fill_categComboBox(self):
categories = ['All']
categories.extend([i[1] for i in self.db.get_categories(self.user)])
self.categComboBox.currentIndexChanged.disconnect(self.fill_ListWidget)
self.categComboBox.clear()
self.categComboBox.addItems(categories)
self.categComboBox.currentIndexChanged.connect(self.fill_ListWidget)
self.fill_ListWidget()
def fill_ListWidget(self):
self.showLabel.clear()
self.contactsListWidget.clear()
if self.categComboBox.currentIndex() != 0: self.searchLineEdit.clear()
category = self.categComboBox.currentText()
if category == 'All':
contacts = self.db.get_all_contacts(self.user)
else:
categ_id = self.db.get_category_id(category, self.user)
if categ_id is None: return
contacts = self.db.get_contacts(categ_id)
for i in contacts:
self.contactsListWidget.addItem(MyListItem(i[1]+' '+i[2], i[0]))
self.contactsListWidget.setCurrentRow(0)
self.refresh_contacts_number()
self.set_buttons_enabled()
def refresh_userLabel(self):
self.userLabel.setText('User: '******'Contacts Numer: {0}'.format(self.contactsListWidget.count())
self.cont_numLabel.setText(text)
def set_buttons_enabled(self):
enable = bool(self.contactsListWidget)
self.editButton.setEnabled(enable)
self.delButton.setEnabled(enable)
def user_panel(self):
dialog = dialogs.UserPanelDlg(self)
if dialog.exec_():
self.user = dialog.user
self.fill_categComboBox()
self.refresh_userLabel()
def show_contact(self):
try:
_id = self.contactsListWidget.currentItem()._id
except AttributeError:
return
_id, name, surname, mail, address, tel, categ_id = \
self.db.get_contact_from_id(_id)[0]
category = self.db.get_category_from_id(categ_id)
text = ''
data = (name, surname, mail, address, tel, category)
labs = ('Name', 'Surname', 'e-mail', 'Address', 'Telephone', 'Category')
for i, y in zip(labs, data):
text += '''<p style=\' margin-top:0px; margin-bottom:0px; \'>
<span style=\' font-weight:600;\'>{0}:</span> {1} </p>\n'''\
.format(i, y)
self.showLabel.setText(text)
def add_contact(self):
categories = [i[1] for i in self.db.get_categories(self.user)]
dialog = dialogs.AddorEditContactDlg(categories)
if dialog.exec_():
data = dialog.values
if data[-1] not in categories:
self.db.addto_categories(data[-1], self.user)
categ_id = self.db.get_category_id(data[-1], self.user)
data[-1] = categ_id
self.db.addto_contacts(data)
self.fill_categComboBox()
def edit_contact(self):
_id = self.contactsListWidget.currentItem()._id
data = list(self.db.get_contact_from_id(_id)[0])
categ = self.db.get_category_from_id(data[-1])
data[-1] = categ
categories = [i[1] for i in self.db.get_categories(self.user)]
dialog = dialogs.AddorEditContactDlg(categories, True, data)
if dialog.exec_():
new_data = dialog.values
if new_data[-1] not in categories:
self.db.addto_categories(new_data[-1], self.user)
categ_id = self.db.get_category_id(new_data[-1], self.user)
new_data[-1] = categ_id
self.db.edit_contact(new_data, _id)
self.fill_categComboBox()
def delete_contact(self):
reply = QMessageBox.question(self, 'Address Book - Delete Contact',
'Are you sure that you want to delete this contact?',
QMessageBox.Yes|QMessageBox.Cancel)
if reply == QMessageBox.Yes:
_id = self.contactsListWidget.currentItem()._id
self.db.delete_contact(_id)
self.fill_ListWidget()
def delete_all(self):
reply = QMessageBox.question(self, 'Address Book - Delete Contact',
'Are you sure that you want to delete all contacts?',
QMessageBox.Yes|QMessageBox.Cancel)
if reply == QMessageBox.Yes:
self.db.delete_all_contacts()
self.fill_ListWidget()
def delete_categories(self):
categories = [i[1] for i in self.db.get_categories(self.user)]
dialogs.DelCategoriesDlg(categories, self).exec_()
self.fill_categComboBox()
def search(self):
self.categComboBox.setCurrentIndex(0)
self.showLabel.clear()
self.contactsListWidget.clear()
txt = self.searchLineEdit.text()
if all(i == ' ' for i in txt):
self.fill_ListWidget()
return
must_appear = []
contacts = self.db.get_all_contacts(self.user)
if not ' ' in txt:
for i in contacts:
if txt.lower() in i[1].lower() or txt.lower() in i[2].lower():
must_appear.append(i)
else:
try:
first, last = txt.split()
except ValueError:
return
for i in contacts:
_bool = bool(first.lower() in i[1].lower() or first.lower() in
i[2].lower() or last.lower() in i[1].lower() or
last.lower() in i[2].lower())
if _bool: must_appear.append(i)
for i in must_appear:
item = MyListItem(i[1] + ' ' + i[2], i[0])
self.contactsListWidget.addItem(item)
self.contactsListWidget.setCurrentRow(0)
self.refresh_contacts_number()
self.set_buttons_enabled()
def backup(self):
fname = QFileDialog.getSaveFileName(self,'Address Book - Backup','.db')
if fname:
try:
shutil.copy(self.db_file, fname)
except IOError:
pass
def restore(self):
reply = QMessageBox.question(self, 'Address Book - Restore',
'All current contacts will be deleted.\nAre you sure that you want'
' to continue?', QMessageBox.Yes|QMessageBox.Cancel)
if reply == QMessageBox.Yes:
fname = QFileDialog.getOpenFileName(self, 'Address Book - Restore')
if fname:
msg = 'Succesful restore!'
try:
os.remove(self.db_file)
shutil.copy(fname, self.db_file)
except (OSError, IOError):
msg = 'Restore failed!'
QMessageBox.information(self, 'Addess Book - Restore', msg)
self.db = database.Database(self.db_file)
self.fill_categComboBox()
def database_file(self):
_file = 'addressbook.db'
if not platform.platform().startswith('Windows'):
folder = os.getenv('HOME') + os.sep + '.addressbook'
if not os.path.exists(folder): os.mkdir(folder)
_file = folder + os.sep + _file
return _file
def about(self):
link = 'http://wiki.ubuntu-gr.org/Address%20Book'
QMessageBox.about(self, self.tr('About') + ' FF Multi Converter',
'''<b> Address Book {0} </b>
<p>Gui application to organize your contacts!
<p>Copyright © 2012 Ilias Stamatis
<br>License: GNU GPL3
<p><a href='{1}'>http://wiki.ubuntu-gr.org/Address Book</a>
<p>Python {2} - Qt {3} - PyQt {4} on {5}'''
.format(__version__, link, platform.python_version()[:5],
QT_VERSION_STR, PYQT_VERSION_STR, platform.system()))
def close(self):
self.db.close()
sys.exit()
class InputListParameterWidget(GenericParameterWidget):
"""Widget class for List parameter."""
def __init__(self, parameter, parent=None):
"""Constructor
.. versionadded:: 2.2
:param parameter: A ListParameter object.
:type parameter: InputListParameter
"""
super(InputListParameterWidget, self).__init__(parameter, parent)
# value cache for self._parameter.value
# copy the list so the original is unaffected
self._value_cache = list(self._parameter.value)
self._input = QListWidget()
self._input.setSelectionMode(QAbstractItemView.SingleSelection)
if self._parameter.maximum_item_count != \
self._parameter.minimum_item_count:
tool_tip = 'Select between %d and %d items' % (
self._parameter.minimum_item_count,
self._parameter.maximum_item_count)
else:
tool_tip = 'Select exactly %d items' % (
self._parameter.maximum_item_count)
self._input.setToolTip(tool_tip)
# arrange widget
self._insert_item_input = QLineEdit()
vbox_layout = QVBoxLayout()
hbox_layout = QHBoxLayout()
self._input_add_button = QPushButton('Add')
self._input_remove_button = QPushButton('Remove')
# arrange line edit, add button, remove button in horizontal layout
hbox_layout.addWidget(self._insert_item_input)
hbox_layout.addWidget(self._input_add_button)
hbox_layout.addWidget(self._input_remove_button)
# arrange vertical layout
vbox_layout.addLayout(hbox_layout)
vbox_layout.addWidget(self._input)
self._inner_input_layout.addLayout(vbox_layout)
# override self._input_layout arrangement to make the label at the top
# reset the layout
self._input_layout.setParent(None)
self._help_layout.setParent(None)
self._label.setParent(None)
self._inner_input_layout.setParent(None)
self._input_layout = QVBoxLayout()
self._input_layout.setSpacing(0)
# put element into layout
self._input_layout.addWidget(self._label)
self._input_layout.addLayout(self._inner_input_layout)
self._main_layout.addLayout(self._input_layout)
self._main_layout.addLayout(self._help_layout)
# connect handler
# noinspection PyUnresolvedReferences
self._input_add_button.clicked.connect(self.on_add_button_click)
# noinspection PyUnresolvedReferences
self._input_remove_button.clicked.connect(self.on_remove_button_click)
# noinspection PyUnresolvedReferences
self._insert_item_input.returnPressed.connect(
self._input_add_button.click)
# noinspection PyUnresolvedReferences
self._input.itemChanged.connect(self.on_row_changed)
self.refresh_list()
# init row add error handler
self._add_row_error_handler = None
@property
def add_row_error_handler(self):
"""return error handler if user mistakenly add row of unexpected type
:return: a function handler
:rtype: () -> None
"""
return self._add_row_error_handler
@add_row_error_handler.setter
def add_row_error_handler(self, value):
"""Set error handler to handle user mistakenly add row of unexpected
type
"""
self._add_row_error_handler = value
def refresh_list(self):
self._input.clear()
if not self._parameter.ordering == InputListParameter.NotOrdered:
self._value_cache.sort()
if self._parameter.ordering == InputListParameter.DescendingOrder:
self._value_cache.reverse()
for opt in self._value_cache:
item = QListWidgetItem()
item.setText(str(opt))
item.setFlags(item.flags() | Qt.ItemIsEditable)
self._input.addItem(item)
def on_add_button_click(self):
try:
value = self._parameter.element_type(
self._insert_item_input.text())
self._value_cache.append(value)
self.refresh_list()
except ValueError:
err = self.raise_invalid_type_exception()
if self.add_row_error_handler is not None:
self.add_row_error_handler(err)
else:
raise err
def on_remove_button_click(self):
for opt in self._input.selectedItems():
index = self._input.indexFromItem(opt)
del self._value_cache[index.row()]
self.refresh_list()
def on_row_changed(self, item):
try:
index = self._input.indexFromItem(item).row()
prev_value = self._value_cache[index]
self._value_cache[index] = self._parameter.element_type(
item.text())
self.refresh_list()
except ValueError:
item.setText(str(prev_value))
self.raise_invalid_type_exception()
def raise_invalid_type_exception(self):
message = 'Expecting element type of %s' % (
self._parameter.element_type.__name__)
err = ValueError(message)
return err
def get_parameter(self):
"""Obtain list parameter object from the current widget state.
:returns: A ListParameter from the current state of widget
"""
try:
self._parameter.value = self._value_cache
except ValueError:
err = self.raise_invalid_type_exception()
raise err
return self._parameter
