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 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 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 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