def contextMenuEvent(self, event): menu = QMenu(self) dc = QAction('Disconnect', None) rc = QAction('Reconnect', None) connectivity = QAction('Connection Test', None) menu.addAction(connectivity) about = QAction('About', None) if self.state != ClientState.DISCONNECTED: menu.addAction(dc) if self.state != ClientState.ONLINE\ and self.state != ClientState.RECONNECTING: menu.addAction(rc) menu.addAction(about) action = menu.exec_(self.mapToGlobal(event.pos())) if action == dc: self.disconnect_requested.emit() elif action == rc: self.reconnect_requested.emit() elif action == connectivity: self.connectivity_dialog_requested.emit() elif action == about: self.about_dialog_requested.emit()
def customContext(self, pos): index = self.listView.indexAt(pos) index = self.proxyModel.mapToSource(index) if not index.isValid(): self.rmAction.setEnabled(False) self.openAction.setEnabled(False) self.loadAction.setEnabled(False) elif not self.model.isDir(index): info = self.model.fileInfo(index) suffix = info.suffix() if suffix in ("Rd","Rdata","RData"): self.loadAction.setEnabled(True) self.openAction.setEnabled(False) self.loadExternal.setEnabled(False) elif suffix in ("txt","csv","R","r"): self.openAction.setEnabled(True) self.loadAction.setEnabled(False) self.loadExternal.setEnabled(True) else: self.loadAction.setEnabled(False) self.openAction.setEnabled(False) self.loadExternal.setEnabled(True) menu = QMenu(self) for action in self.actions: menu.addAction(action) menu.exec_(self.listView.mapToGlobal(pos))
def prepareContextMenu(self): context_menu = QMenu(self) var = self.selectionModel().currentIndex().internalPointer() if isinstance(var, TreeStdVariable): filters.add_actions_for_all_filters(context_menu.addMenu( "Set Filter for %s..." % var.exp), var) return context_menu
def contextMenuRequested(point): " quick and dirty custom context menu " menu = QMenu() menu.addActions( ( qaqq, qamin, qanor, qamax, qasrc, qakb, qacol, qati, qasb, qatb, qatim, qatit, qafnt, qapic, qadoc, qali, qaslf, qaqt, qapy, qabug, ) ) menu.exec_(self.mapToGlobal(point))
def create_contextmenu(self): self.setContextMenuPolicy(Qt.CustomContextMenu) self.listMenu = QMenu() self.listMenu1 = QMenu("下载控制") self.playAction = QAction("播放", self) self.pauseDownloadAction = QAction("暂停", self) self.stopDownloadAction = QAction("取消下载", self) self.startDownloadAction = QAction("开始", self) self.pauseAllAction = QAction("暂停全部", self) self.startAllAction = QAction("开始全部", self) self.stopAllAction = QAction("取消全部", self) self.removeRowsAction = QAction("移除选中项", self) self.clearTableAction = QAction("清空列表", self) self.listMenu1.addAction(self.startDownloadAction) self.listMenu1.addAction(self.startAllAction) self.listMenu1.addSeparator() self.listMenu1.addAction(self.pauseDownloadAction) self.listMenu1.addAction(self.pauseAllAction) self.listMenu1.addSeparator() self.listMenu1.addAction(self.stopDownloadAction) # self.listMenu.addAction(self.stopAllAction) self.listMenu.addAction(self.playAction) self.listMenu.addSeparator() self.listMenu.addMenu(self.listMenu1) self.listMenu.addSeparator() self.listMenu.addAction(self.removeRowsAction) self.listMenu.addAction(self.clearTableAction)
def showSnippets(self, evt): popupmenu = QMenu() for name, snippet in self.snippets.iteritems(): action = QAction(self.tr(name), self.btnSnippets) action.triggered[()].connect(lambda snippet=snippet: self.editor.insert(snippet)) popupmenu.addAction(action) popupmenu.exec_(QCursor.pos())
def slot_transportViewMenu(self_): menu = QMenu(self_) act_t_hms = menu.addAction("Hours:Minutes:Seconds") act_t_bbt = menu.addAction("Beat:Bar:Tick") act_t_fr = menu.addAction("Frames") act_t_hms.setCheckable(True) act_t_bbt.setCheckable(True) act_t_fr.setCheckable(True) if self_.m_selected_transport_view == TRANSPORT_VIEW_HMS: act_t_hms.setChecked(True) elif self_.m_selected_transport_view == TRANSPORT_VIEW_BBT: act_t_bbt.setChecked(True) elif self_.m_selected_transport_view == TRANSPORT_VIEW_FRAMES: act_t_fr.setChecked(True) act_selected = menu.exec_(QCursor().pos()) if act_selected == act_t_hms: setTransportView(self_, TRANSPORT_VIEW_HMS) elif act_selected == act_t_bbt: setTransportView(self_, TRANSPORT_VIEW_BBT) elif act_selected == act_t_fr: setTransportView(self_, TRANSPORT_VIEW_FRAMES)
def __init__(self): QWidget.__init__(self) self._line_edit = ClearableLineEdit() self._calendar_button = QToolButton() self._calendar_button.setPopupMode(QToolButton.InstantPopup) self._calendar_button.setFixedSize(26, 26) self._calendar_button.setAutoRaise(True) self._calendar_button.setIcon(resourceIcon("calendar.png")) self._calendar_button.setStyleSheet("QToolButton::menu-indicator { image: none; }") tool_menu = QMenu(self._calendar_button) self._calendar_widget = QCalendarWidget(tool_menu) action = QWidgetAction(tool_menu) action.setDefaultWidget(self._calendar_widget) tool_menu.addAction(action) self._calendar_button.setMenu(tool_menu) layout = QHBoxLayout() layout.setMargin(0) layout.addWidget(self._line_edit) layout.addWidget(self._calendar_button) self.setLayout(layout) self._calendar_widget.activated.connect(self.setDate)
class centro(QGraphicsPixmapItem): def __init__(self, *args): QGraphicsPixmapItem.__init__(self, *args) self.setPixmap(QPixmap("sprites/calle/centro.png")) self.setTransformOriginPoint(self.boundingRect().width()/2.0,self.boundingRect().height()/2.0) self.setZValue(1) self.menu = QMenu() self.Actions =[] #arreglo de acciones self.Actions.append( self.menu.addAction("girar clockwise") ) self.Actions.append( self.menu.addAction("girar anti-clockwise") ) self.Actions.append( self.menu.addAction("Duplicar") ) self.Actions.append( self.menu.addAction("Eliminar") ) self.menu.triggered[QAction].connect(self.test) self.offset=QPointF(0,0) def test(self,act): print act.text() if act.text()=="girar clockwise": self.setRotation(self.rotation()-45) if act.text()=="girar anti-clockwise": self.setRotation(self.rotation()+45) if act.text()=="Duplicar": self.scene().addItem(centro()) if act.text()=="Eliminar": self.scene().removeItem(self) def contextMenuEvent(self,event): self.menu.popup(event.screenPos()) def mousePressEvent(self, event): p = event.pos() self.offset= QPointF(p.x()*1.0,p.y()*1.0) def mouseMoveEvent(self, event): #print self.offset,event.scenePos() self.setPos(event.scenePos()-self.offset)
class BaseTabs(QTabWidget): def __init__(self, parent, actions=None, menu=None): QTabWidget.__init__(self, parent) if menu is None: self.menu = QMenu(self) if actions: add_actions(self.menu, actions) else: self.menu = menu def contextMenuEvent(self, event): """Override Qt method""" if self.menu: self.menu.popup(event.globalPos()) def mousePressEvent(self, event): """Override Qt method""" if event.button() == Qt.MidButton: index = self.tabBar().tabAt(event.pos()) if index >= 0: self.emit(SIGNAL("close_tab(int)"), index) event.accept() return QTabWidget.mousePressEvent(self, event) def keyPressEvent(self, event): """Override Qt method""" ctrl = event.modifiers() & Qt.ControlModifier key = event.key() handled = False if ctrl and self.count() > 0: index = self.currentIndex() if key == Qt.Key_PageUp and index > 0: self.setCurrentIndex(index-1) handled = True elif key == Qt.Key_PageDown and index < self.count()-1: self.setCurrentIndex(index+1) handled = True if handled: event.accept() else: QTabWidget.keyPressEvent(self, event) def set_close_function(self, func): """Setting Tabs close function None -> tabs are not closable""" state = func is not None if state: self.connect(self, SIGNAL("close_tab(int)"), func) try: # Assuming Qt >= 4.5 QTabWidget.setTabsClosable(self, state) self.connect(self, SIGNAL("tabCloseRequested(int)"), func) except AttributeError: # Workaround for Qt < 4.5 close_button = create_toolbutton(self, triggered=func, icon=get_icon("fileclose.png"), tip=translate("Tabs", "Close current tab")) self.setCornerWidget(close_button if state else None)
def __init__(self, parent, mainWindow, tags, selectItem = None): QMenu.__init__(self, tags, parent) self.tags = tags self.__mainWindow = mainWindow self.callbackSelected = selectItem self.loader = loader.loader() self.Load()
class FilterSetWidget(QWidget, Ui_FilterSetWidget): def __init__(self, parent=None): super(FilterSetWidget, self).__init__(parent) self.setupUi(self) self._filterSetActionGroup = QActionGroup(self) self._filterSetActionGroup.addAction(self.saveFilterSetAction) self._filterSetActionGroup.addAction(self.reloadFilterSetAction) self._filterSetActionGroup.addAction(self.deleteFilterSetAction) self._filterSetActionGroup.addAction(self.exportFilterSetAction) self._filterSetMenu = QMenu(self) self._filterSetMenu.addActions(self._filterSetActionGroup.actions()) self.filterSetTool.setMenu(self._filterSetMenu) self.filterSetTool.setDefaultAction(self.saveFilterSetAction) def setFilterSet(self, filterSet): self.setFilterSetKey(filterSet.key) if filterSet.source == 'ark': self.saveFilterSetAction.setEnabled(False) self.deleteFilterSetAction.setEnabled(False) self.filterSetTool.setDefaultAction(self.reloadFilterSetAction) else: self.saveFilterSetAction.setEnabled(True) self.deleteFilterSetAction.setEnabled(True) self.filterSetTool.setDefaultAction(self.saveFilterSetAction) def setFilterSetKey(self, key): self.filterSetCombo.setCurrentIndex(self.filterSetCombo.findData(key)) def currentFilterSetKey(self): return self.filterSetCombo.itemData(self.filterSetCombo.currentIndex()) def currentFilterSetName(self): return self.filterSetCombo.currentText()
def __showPyflakesContextMenu( self, pos ): " Triggered when the icon context menu is requested " if self.__currentUUID is None: return if self.__currentUUID not in self.__flakesResults: return messages = self.__flakesResults[ self.__currentUUID ].messages if not messages: return # Check that there is at least one non -1 lineno message foundLinedMessage = False for item in messages: if item[ 1 ] != -1: foundLinedMessage = True break if not foundLinedMessage: return # OK, we have something to show contextMenu = QMenu( self.__uiLabel ) for item in messages: act = contextMenu.addAction( PixmapCache().getIcon( 'pyflakesmsgmarker.png' ), "Line " + str( item[ 1 ] ) + ": " + item[ 0 ] ) act.setData( QVariant( item[ 1 ] ) ) self.connect( contextMenu, SIGNAL( "triggered(QAction*)" ), self.__onContextMenu ) contextMenu.popup( self.__uiLabel.mapToGlobal( pos ) ) return
def create_menubar(self): # Create File Menu self.fileMenu = QMenu("&File") self.fileMenu.addAction(self.mbNew) self.fileMenu.addAction(self.mbOpen) self.fileMenu.addSeparator() self.fileMenu.addAction(self.mbSave) self.fileMenu.addAction(self.mbSaveAs) self.fileMenu.addSeparator() self.fileMenu.addAction(self.mbClose) self.fileMenu.addAction(self.mbExit) # Create Script Menu self.scriptMenu = QMenu("&Script") self.scriptMenu.addAction(self.mbRun) self.scriptMenu.addAction(self.mbStop) self.scriptMenu.addAction(self.mbDebug) # Create Help Menu self.helpMenu = QMenu("&Help") self.helpMenu.addAction(self.mbHelp) self.helpMenu.addAction(self.mbAbout) # Add menus to menubar menubar = self.menuBar() menubar.addMenu(self.fileMenu) menubar.addMenu(self.scriptMenu) menubar.addMenu(self.helpMenu)
def set_menu_registry(self, menu_registry): self.menu_registry = menu_registry for menu_instance in self.menu_registry.menus(): try: menu_instance.setCanvasMainWindow(self) custom_menu = QMenu(menu_instance.name, self) sub_menus = menu_instance.getSubMenuNamesList() for index in range(0, len(sub_menus)): if menu_instance.isSeparator(sub_menus[index]): custom_menu.addSeparator() else: custom_action = \ QAction(sub_menus[index], self, objectName=sub_menus[index].lower() + "-action", toolTip=self.tr(sub_menus[index]), ) custom_action.triggered.connect(getattr(menu_instance, 'executeAction_' + str(index+1))) custom_menu.addAction(custom_action) self.menuBar().addMenu(custom_menu) except Exception as exception: print("Error in creating Customized Menu: " + str(menu_instance)) print(str(exception.args[0])) continue
class TabNavigator(QWidget): def __init__(self): QWidget.__init__(self) self.setContextMenuPolicy(Qt.DefaultContextMenu) self.setMinimumHeight(38) hbox = QHBoxLayout(self) self.btnPrevious = QPushButton(QIcon(resources.IMAGES["nav-code-left"]), "") self.btnPrevious.setToolTip(self.tr("Right click to change navigation options")) styles.set_style(self.btnPrevious, "tab-navigator") self.btnNext = QPushButton(QIcon(resources.IMAGES["nav-code-right"]), "") self.btnNext.setToolTip(self.tr("Right click to change navigation options")) styles.set_style(self.btnNext, "tab-navigator") hbox.addWidget(self.btnPrevious) hbox.addWidget(self.btnNext) self.setContentsMargins(0, 0, 0, 0) self.menuNavigate = QMenu(self.tr("Navigate")) self.codeAction = self.menuNavigate.addAction(self.tr("Code Jumps")) self.codeAction.setCheckable(True) self.codeAction.setChecked(True) self.bookmarksAction = self.menuNavigate.addAction(self.tr("Bookmarks")) self.bookmarksAction.setCheckable(True) self.breakpointsAction = self.menuNavigate.addAction(self.tr("Breakpoints")) self.breakpointsAction.setCheckable(True) # 0 = Code Jumps # 1 = Bookmarks # 2 = Breakpoints self.operation = 0 self.connect(self.codeAction, SIGNAL("triggered()"), self._show_code_nav) self.connect(self.breakpointsAction, SIGNAL("triggered()"), self._show_breakpoints) self.connect(self.bookmarksAction, SIGNAL("triggered()"), self._show_bookmarks) def contextMenuEvent(self, event): self.menuNavigate.exec_(event.globalPos()) def _show_bookmarks(self): self.btnPrevious.setIcon(QIcon(resources.IMAGES["book-left"])) self.btnNext.setIcon(QIcon(resources.IMAGES["book-right"])) self.bookmarksAction.setChecked(True) self.breakpointsAction.setChecked(False) self.codeAction.setChecked(False) self.operation = 1 def _show_breakpoints(self): self.btnPrevious.setIcon(QIcon(resources.IMAGES["break-left"])) self.btnNext.setIcon(QIcon(resources.IMAGES["break-right"])) self.bookmarksAction.setChecked(False) self.breakpointsAction.setChecked(True) self.codeAction.setChecked(False) self.operation = 2 def _show_code_nav(self): self.btnPrevious.setIcon(QIcon(resources.IMAGES["nav-code-left"])) self.btnNext.setIcon(QIcon(resources.IMAGES["nav-code-right"])) self.bookmarksAction.setChecked(False) self.breakpointsAction.setChecked(False) self.codeAction.setChecked(True) self.operation = 0
def menu_button(self, main_action_id, ids, widget): ''' Creates an :obj:`.OWButton` with a popup-menu and adds it to the parent ``widget``. ''' id, name, attr_name, attr_value, callback, icon_name = self._expand_id(main_action_id) b = OWButton(parent=widget) m = QMenu(b) b.setMenu(m) b._actions = {} QObject.connect(m, SIGNAL("triggered(QAction*)"), b, SLOT("setDefaultAction(QAction*)")) if main_action_id: main_action = OWAction(self._plot, icon_name, attr_name, attr_value, callback, parent=b) QObject.connect(m, SIGNAL("triggered(QAction*)"), main_action, SLOT("trigger()")) for id in ids: id, name, attr_name, attr_value, callback, icon_name = self._expand_id(id) a = OWAction(self._plot, icon_name, attr_name, attr_value, callback, parent=m) m.addAction(a) b._actions[id] = a if m.actions(): b.setDefaultAction(m.actions()[0]) elif main_action_id: b.setDefaultAction(main_action) b.setPopupMode(QToolButton.MenuButtonPopup) b.setMinimumSize(40, 30) return b
def contextMenuEvent(self, event): popup_menu = self.createStandardContextMenu() menu_lint = QMenu(self.tr("Ignore Lint")) ignoreLineAction = menu_lint.addAction( self.tr("Ignore This Line")) ignoreSelectedAction = menu_lint.addAction( self.tr("Ignore Selected Area")) self.connect(ignoreLineAction, SIGNAL("triggered()"), lambda: helpers.lint_ignore_line(self)) self.connect(ignoreSelectedAction, SIGNAL("triggered()"), lambda: helpers.lint_ignore_selection(self)) popup_menu.insertSeparator(popup_menu.actions()[0]) popup_menu.insertMenu(popup_menu.actions()[0], menu_lint) popup_menu.insertAction(popup_menu.actions()[0], self.__actionFindOccurrences) #add extra menus (from Plugins) lang = file_manager.get_file_extension(self.ID) extra_menus = self.EXTRA_MENU.get(lang, None) if extra_menus: popup_menu.addSeparator() for menu in extra_menus: popup_menu.addMenu(menu) #show menu popup_menu.exec_(event.globalPos())
def __init__(self, main_window): self.main_window = main_window QMenu.__init__(self, '&Tracks', main_window) self.addAction('&Add', self.add_track) self.addAction('&Remove', self.remove_track) self.addAction('&Merge', self.merge_tracks) self.addAction('&Set Index', self.set_index)
def __init__(self, titre='', liste=None, fonction=None, aide=''): QMenu.__init__(self, titre) # self.parent = parent self.fonction = None # self.titre = titre # self.setTitle(titre) self.update(liste, fonction, aide)
def contextMenuEvent(self, event): menu = QMenu(self) Action = menu.addAction("print selected rows") Action.triggered.connect(self.printName) menu.exec_(event.globalPos())
def create_menu_switch_sink(self): sink_menu = QMenu(i18n("Move To"), self.popup_menu) sinks = self.veromix.get_sink_widgets() for sink in sinks: action = QAction(sink.name(), self.popup_menu) sink_menu.addAction(action) self.popup_menu.addMenu(sink_menu)
def right_click(self, type, champ): u"Retourne une fonction qui sera executée lors d'un clic avec le bouton du milieu sur le champ 'champ'." champ.setFocus() plusieurs = isinstance(type, list) if plusieurs: type = type[0] liste_objets = self.onglet_actuel.feuille_actuelle.objets.lister(False, type = type) liste_objets.sort(key = attrgetter('nom')) # ordre alphabétique if not liste_objets: return menu = QMenu() for obj in liste_objets: action = menu.addAction(obj.nom_complet) action.nom = obj.nom action = menu.exec_() if action: if plusieurs: # le champ doit contenir non pas un objet, mais une liste d'objets val = champ.text().strip() if val: if not val.endswith(","): val += "," val += " " champ.setText(val + action.nom) else: # le champ contient un seul objet champ.setText(action.nom)
def setup_context_menu(self): self.menuFilter = QMenu(self) self.hide_action = QAction('Hide selected values', self) self.show_only_action = QAction('Show only selected values', self) self.clear_all_filters_action = QAction('Clear all filters', self) self.copy_selection_action = QAction('Copy selection', self) self.unhide_menu = QMenu('Unhide item from selected column', self.menuFilter) self.hide_action.triggered.connect(self.hide_rows_based_on_selected_cells) self.show_only_action.triggered.connect(self.show_rows_based_on_selected_cells) self.clear_all_filters_action.triggered.connect(self.clear_all_filters) self.copy_selection_action.triggered.connect(self.prepare_clipboard_text) self.menuFilter.addAction(self.hide_action) self.menuFilter.addMenu(self.unhide_menu) self.menuFilter.addAction(self.show_only_action) self.menuFilter.addAction(self.clear_all_filters_action) self.menuFilter.addSeparator() self.menuFilter.addAction(self.copy_selection_action) self.hide_action.setShortcut('Ctrl+H') self.show_only_action.setShortcut('Ctrl+O') self.clear_all_filters_action.setShortcut('Ctrl+Del') self.copy_selection_action.setShortcut("Ctrl+C")
def contextMenuEvent(self, event): menu = QMenu(self) Action = menu.addAction("delete row") Action.triggered.connect(self.deleteRow) menu.exec_(event.globalPos())
def contextMenuEvent(self, event): if event.reason() == event.Mouse: pos = event.globalPos() item = self.itemAt(event.pos()) else: pos = None selection = self.selectedItems() if selection: item = selection[0] else: item = self.currentItem() if item is None: item = self.invisibleRootItem().child(0) if item is not None: parent = item.parent() while parent is not None: parent.setExpanded(True) parent = parent.parent() itemrect = self.visualItemRect(item) portrect = self.viewport().rect() if not portrect.contains(itemrect.topLeft()): self.scrollToItem( item, QTreeWidget.PositionAtCenter) itemrect = self.visualItemRect(item) itemrect.setLeft(portrect.left()) itemrect.setWidth(portrect.width()) pos = self.mapToGlobal(itemrect.center()) if pos is not None: menu = QMenu(self) menu.addAction(item.text(0)) menu.popup(pos) event.accept()
def slot_transportViewMenu(self): menu = QMenu(self) actHMS = menu.addAction("Hours:Minutes:Seconds") actBBT = menu.addAction("Beat:Bar:Tick") actFrames = menu.addAction("Frames") actHMS.setCheckable(True) actBBT.setCheckable(True) actFrames.setCheckable(True) if self.fCurTransportView == TRANSPORT_VIEW_HMS: actHMS.setChecked(True) elif self.fCurTransportView == TRANSPORT_VIEW_BBT: actBBT.setChecked(True) elif self.fCurTransportView == TRANSPORT_VIEW_FRAMES: actFrames.setChecked(True) actSelected = menu.exec_(QCursor().pos()) if actSelected == actHMS: self.setTransportView(TRANSPORT_VIEW_HMS) elif actSelected == actBBT: self.setTransportView(TRANSPORT_VIEW_BBT) elif actSelected == actFrames: self.setTransportView(TRANSPORT_VIEW_FRAMES)
def __init__(self, parent, plot): QMenu.__init__(self, plot.name(), parent) color_menu = CurveColorMenu(self,plot) marker_menu = CurveMarkerMenu(self,plot) self.addMenu(color_menu) self.addMenu(marker_menu) self.addAction('&Remove', lambda: parent.track.remove_plot(plot))
def __createContextMenu( self ): " Creates context menu for the table raws " self.__contextMenu = QMenu( self ) self.__callersMenu = QMenu( "Callers", self ) self.__outsideCallersMenu = QMenu( "Outside callers", self ) self.__calleesMenu = QMenu( "Callees", self ) self.__outsideCalleesMenu = QMenu( "Outside callees", self ) self.__contextMenu.addMenu( self.__callersMenu ) self.__contextMenu.addMenu( self.__outsideCallersMenu ) self.__contextMenu.addSeparator() self.__contextMenu.addMenu( self.__calleesMenu ) self.__contextMenu.addMenu( self.__outsideCalleesMenu ) self.__contextMenu.addSeparator() self.__disasmAct = self.__contextMenu.addAction( PixmapCache().getIcon( 'disasmmenu.png' ), "Disassemble", self.__onDisassemble ) self.__callersMenu.triggered.connect( self.__onCallContextMenu ) self.__outsideCallersMenu.triggered.connect( self.__onCallContextMenu ) self.__calleesMenu.triggered.connect( self.__onCallContextMenu ) self.__outsideCalleesMenu.triggered.connect( self.__onCallContextMenu ) self.__table.setContextMenuPolicy( Qt.CustomContextMenu ) self.__table.customContextMenuRequested.connect( self.__showContextMenu ) return
class ScripterMenu(QObject): """ Scripter menu item in mainWindow menubar """ def __init__(self, parent): QObject.__init__(self, parent) self.setObjectName("Menu") self.popup = QMenu(i18n("Scripter")) MenuHooks().insertMenuAfter("E&xtras", self.popup) self._load_entries() def _load_entries(self): for path in [scripter_path, os.path.expanduser("~/.scribus/scripter/")]: autoload_path = os.path.join(path, "autoload") if not os.path.exists(autoload_path): continue sys.path.insert(0, autoload_path) from scribusscript import load_scripts self.autoload_scripts = scripts = load_scripts(autoload_path) for sd in scripts: try: sd.install() except: excepthook.show_current_error(i18n("Error installing %r") % sd.name) def addAction(self, title, callback, *args): self.popup.addAction(title, callback, *args) def addSeparator(self): self.popup.addSeparator()
def onPopupMenu(self, pos): """ Display menu on right click @param pos: @type pos: """ self.menu = QMenu(self) # index = self.currentIndex() # get defaults adapters or extra adapters_default = self.getHelpAdapters() # get generic adapters adapters_generic = self.getHelpAdapters(generic=True) # main menu menu_adps = QMenu("Add Adapters", self) # adapters default menu_adps_generic = QMenu("Generic", self) menu_adps.addMenu(menu_adps_generic) if adapters_generic is not None: for adp in adapters_generic: adp_menu_generic = QMenu(adp['name'], self) menu_adps_generic.addMenu(adp_menu_generic) for cls in adp['classes']: # extract __init__ function only fct = None for fct in cls['functions']: if fct['name'] == '__init__': break if fct is not None: argsFct = self.parseDocString(docstring=fct['desc']) argsFct['function'] = "%s::%s" % (adp['name'],cls['name']) argsFct['main-name'] = "%s" % adp['name'] argsFct['sub-name'] = "%s" % cls['name'] argsFct['is-default'] = "False" argsFct['is-generic'] = "True" if 'default-args' in fct: self.addDefaultValues(defaultValues=fct['default-args'], currentFunction=argsFct) adp_menu_generic.addAction(QtHelper.createAction(self, cls['name'], self.addAdapter, cb_arg=argsFct )) # adapters default menu_adps_default = QMenu("Extra", self) menu_adps.addMenu(menu_adps_default) if adapters_default is not None: for adp in adapters_default: adp_menu_default = QMenu(adp['name'], self) menu_adps_default.addMenu(adp_menu_default) for cls in adp['classes']: # extract __init__ function only fct = None for fct in cls['functions']: if fct['name'] == '__init__': break if fct is not None: argsFct = self.parseDocString(docstring=fct['desc']) argsFct['function'] = "%s::%s" % (adp['name'],cls['name']) argsFct['main-name'] = "%s" % adp['name'] argsFct['sub-name'] = "%s" % cls['name'] argsFct['is-default'] = "True" argsFct['is-generic'] = "False" if 'default-args' in fct: self.addDefaultValues(defaultValues=fct['default-args'], currentFunction=argsFct) adp_menu_default.addAction(QtHelper.createAction(self, cls['name'], self.addAdapter, cb_arg=argsFct )) indexes = self.selectedIndexes() if not indexes: self.delAction.setEnabled(False) self.menu.addAction( self.delAction ) self.menu.addSeparator() self.menu.addMenu( menu_adps ) self.menu.addSeparator() else: self.delAction.setEnabled(True) self.menu.addAction( self.delAction ) self.menu.addSeparator() self.menu.addMenu( menu_adps ) self.menu.addSeparator() self.menu.popup( self.mapToGlobal(pos) )
class Qgis2threejsDialog(QDialog): def __init__(self, iface, objectTypeManager, pluginManager, exportSettings=None, lastTreeItemData=None): QDialog.__init__(self, iface.mainWindow()) self.iface = iface self.objectTypeManager = objectTypeManager self.pluginManager = pluginManager self._settings = exportSettings or {} self.lastTreeItemData = lastTreeItemData self.localBrowsingMode = True self.rb_quads = self.rb_point = None self.templateType = None self.currentItem = None self.currentPage = None # Set up the user interface from Designer. self.ui = ui = Ui_Qgis2threejsDialog() ui.setupUi(self) self.setWindowFlags(self.windowFlags() | Qt.WindowMinimizeButtonHint) # output html filename ui.lineEdit_OutputFilename.setText( self._settings.get("OutputFilename", "")) ui.lineEdit_OutputFilename.setPlaceholderText("[Temporary file]") # settings button icon = QIcon(os.path.join(tools.pluginDir(), "icons", "settings.png")) ui.toolButton_Settings.setIcon(icon) # popup menu displayed when settings button is pressed items = [["Load Settings...", self.loadSettings], ["Save Settings As...", self.saveSettings], [None, None], ["Clear Settings", self.clearSettings], [None, None], ["Plugin Settings...", self.pluginSettings]] self.menu = QMenu() self.menu_actions = [] for text, slot in items: if text: action = QAction(text, iface.mainWindow()) action.triggered.connect(slot) self.menu.addAction(action) self.menu_actions.append(action) else: self.menu.addSeparator() ui.toolButton_Settings.setMenu(self.menu) ui.toolButton_Settings.setPopupMode(QToolButton.InstantPopup) # progress bar and message label ui.progressBar.setVisible(False) ui.label_MessageIcon.setVisible(False) # buttons ui.pushButton_Run.clicked.connect(self.run) ui.pushButton_Close.clicked.connect(self.reject) ui.pushButton_Help.clicked.connect(self.help) # set up map tool self.previousMapTool = None self.mapTool = RectangleMapTool(iface.mapCanvas()) #self.mapTool = PointMapTool(iface.mapCanvas()) # set up the template combo box self.initTemplateList() self.ui.comboBox_Template.currentIndexChanged.connect( self.currentTemplateChanged) # set up the properties pages self.pages = {} self.pages[ppages.PAGE_WORLD] = ppages.WorldPropertyPage(self) self.pages[ppages.PAGE_CONTROLS] = ppages.ControlsPropertyPage(self) self.pages[ppages.PAGE_DEM] = ppages.DEMPropertyPage(self) self.pages[ppages.PAGE_VECTOR] = ppages.VectorPropertyPage(self) container = ui.propertyPagesContainer for page in self.pages.itervalues(): page.hide() container.addWidget(page) # build object tree self.topItemPages = { ObjectTreeItem.ITEM_WORLD: ppages.PAGE_WORLD, ObjectTreeItem.ITEM_CONTROLS: ppages.PAGE_CONTROLS, ObjectTreeItem.ITEM_DEM: ppages.PAGE_DEM } self.initObjectTree() self.ui.treeWidget.currentItemChanged.connect( self.currentObjectChanged) self.ui.treeWidget.itemChanged.connect(self.objectItemChanged) self.currentTemplateChanged() # update item visibility ui.toolButton_Browse.clicked.connect(self.browseClicked) #iface.mapCanvas().mapToolSet.connect(self.mapToolSet) # to show button to enable own map tool def settings(self, clean=False): # save settings of current panel item = self.ui.treeWidget.currentItem() if item and self.currentPage: self.saveProperties(item, self.currentPage) # plugin version self._settings["PluginVersion"] = plugin_version # template and output html file path self._settings["Template"] = self.ui.comboBox_Template.currentText() self._settings[ "OutputFilename"] = self.ui.lineEdit_OutputFilename.text() if not clean: return self._settings # clean up settings - remove layers that don't exist in the layer registry registry = QgsMapLayerRegistry.instance() for itemId in [ ObjectTreeItem.ITEM_OPTDEM, ObjectTreeItem.ITEM_POINT, ObjectTreeItem.ITEM_LINE, ObjectTreeItem.ITEM_POLYGON ]: parent = self._settings.get(itemId, {}) for layerId in parent.keys(): if registry.mapLayer(layerId) is None: del parent[layerId] return self._settings def setSettings(self, settings): self._settings = settings # template and output html file path templateName = settings.get("Template") if templateName: cbox = self.ui.comboBox_Template index = cbox.findText(templateName) if index != -1: cbox.setCurrentIndex(index) filename = settings.get("OutputFilename") if filename: self.ui.lineEdit_OutputFilename.setText(filename) # update object tree self.ui.treeWidget.blockSignals(True) self.initObjectTree() self.ui.treeWidget.blockSignals(False) # update tree item visibility self.templateType = None self.currentTemplateChanged() def loadSettings(self): # file open dialog directory = QgsProject.instance().homePath() if not directory: directory = os.path.split( self.ui.lineEdit_OutputFilename.text())[0] if not directory: directory = QDir.homePath() filterString = "Settings files (*.qto3settings);;All files (*.*)" filename = QFileDialog.getOpenFileName(self, "Load Export Settings", directory, filterString) if not filename: return # load settings from file (.qto3settings) import json with open(filename) as f: settings = json.load(f) self.setSettings(settings) def saveSettings(self, filename=None): if not filename: # file save dialog directory = QgsProject.instance().homePath() if not directory: directory = os.path.split( self.ui.lineEdit_OutputFilename.text())[0] if not directory: directory = QDir.homePath() filename = QFileDialog.getSaveFileName( self, "Save Export Settings", directory, "Settings files (*.qto3settings)") if not filename: return # append .qto3settings extension if filename doesn't have if os.path.splitext(filename)[1].lower() != ".qto3settings": filename += ".qto3settings" # save settings to file (.qto3settings) import codecs import json with codecs.open(filename, "w", "UTF-8") as f: json.dump(self.settings(True), f, ensure_ascii=False, indent=2, sort_keys=True) logMessage(u"Settings saved: {0}".format(filename)) def clearSettings(self): if QMessageBox.question(self, "Qgis2threejs", "Are you sure to clear all export settings?", QMessageBox.Ok | QMessageBox.Cancel) == QMessageBox.Ok: self.setSettings({}) def pluginSettings(self): from settingsdialog import SettingsDialog dialog = SettingsDialog(self) if dialog.exec_(): self.pluginManager.reloadPlugins() self.pages[ppages.PAGE_DEM].initLayerComboBox() def showMessageBar(self, text, level=QgsMessageBar.INFO): # from src/gui/qgsmessagebaritem.cpp if level == QgsMessageBar.CRITICAL: msgIcon = "/mIconCritical.png" bgColor = "#d65253" elif level == QgsMessageBar.WARNING: msgIcon = "/mIconWarn.png" bgColor = "#ffc800" else: msgIcon = "/mIconInfo.png" bgColor = "#e7f5fe" stylesheet = "QLabel {{ background-color:{0}; }}".format(bgColor) label = self.ui.label_MessageIcon label.setPixmap(QgsApplication.getThemeIcon(msgIcon).pixmap(24)) label.setStyleSheet(stylesheet) label.setVisible(True) label = self.ui.label_Status label.setText(text) label.setStyleSheet(stylesheet) def clearMessageBar(self): self.ui.label_MessageIcon.setVisible(False) self.ui.label_Status.setText("") self.ui.label_Status.setStyleSheet( "QLabel { background-color: rgba(0, 0, 0, 0); }") def initTemplateList(self): cbox = self.ui.comboBox_Template cbox.clear() templateDir = QDir(tools.templateDir()) for i, entry in enumerate(templateDir.entryList(["*.html", "*.htm"])): cbox.addItem(entry) config = tools.getTemplateConfig(entry) # get template type templateType = config.get("type", "plain") cbox.setItemData(i, templateType, Qt.UserRole) # set tool tip text desc = config.get("description", "") if desc: cbox.setItemData(i, desc, Qt.ToolTipRole) # select the template of the settings templatePath = self._settings.get("Template") # if no template setting, select the last used template if not templatePath: templatePath = QSettings().value("/Qgis2threejs/lastTemplate", def_vals.template, type=unicode) if templatePath: index = cbox.findText(templatePath) if index != -1: cbox.setCurrentIndex(index) return index return -1 def initObjectTree(self): tree = self.ui.treeWidget tree.clear() # add vector and raster layers into tree widget topItems = {} for id, name in zip(ObjectTreeItem.topItemIds, ObjectTreeItem.topItemNames): item = QTreeWidgetItem(tree, [name]) item.setData(0, Qt.UserRole, id) topItems[id] = item optDEMChecked = False for layer in self.iface.legendInterface().layers(): parentId = ObjectTreeItem.parentIdByLayer(layer) if parentId is None: continue item = QTreeWidgetItem(topItems[parentId], [layer.name()]) isVisible = self._settings.get(parentId, {}).get( layer.id(), {}).get( "visible", False) #self.iface.legendInterface().isLayerVisible(layer) check_state = Qt.Checked if isVisible else Qt.Unchecked item.setData(0, Qt.CheckStateRole, check_state) item.setData(0, Qt.UserRole, layer.id()) if parentId == ObjectTreeItem.ITEM_OPTDEM and isVisible: optDEMChecked = True for id, item in topItems.iteritems(): if id != ObjectTreeItem.ITEM_OPTDEM or optDEMChecked: tree.expandItem(item) # disable additional DEM item which is selected as main DEM layerId = self._settings.get(ObjectTreeItem.ITEM_DEM, {}).get("comboBox_DEMLayer") if layerId: self.primaryDEMChanged(layerId) def saveProperties(self, item, page): properties = page.properties() parent = item.parent() if parent is None: # top level item self._settings[item.data(0, Qt.UserRole)] = properties else: # layer item parentId = parent.data(0, Qt.UserRole) if parentId not in self._settings: self._settings[parentId] = {} self._settings[parentId][item.data(0, Qt.UserRole)] = properties def setCurrentTreeItemByData(self, data): it = QTreeWidgetItemIterator(self.ui.treeWidget) while it.value(): if it.value().data(0, Qt.UserRole) == data: self.ui.treeWidget.setCurrentItem(it.value()) return True it += 1 return False def currentTemplateChanged(self, index=None): cbox = self.ui.comboBox_Template templateType = cbox.itemData(cbox.currentIndex(), Qt.UserRole) if templateType == self.templateType: return # hide items unsupported by template tree = self.ui.treeWidget for i, id in enumerate(ObjectTreeItem.topItemIds): hidden = (templateType == "sphere" and id != ObjectTreeItem.ITEM_CONTROLS) tree.topLevelItem(i).setHidden(hidden) # set current tree item if templateType == "sphere": tree.setCurrentItem( tree.topLevelItem( ObjectTreeItem.topItemIndex(ObjectTreeItem.ITEM_CONTROLS))) elif self.lastTreeItemData is None or not self.setCurrentTreeItemByData( self.lastTreeItemData): # restore selection tree.setCurrentItem( tree.topLevelItem( ObjectTreeItem.topItemIndex(ObjectTreeItem.ITEM_DEM)) ) # default selection for plain is DEM # display messages self.clearMessageBar() if templateType != "sphere": # show message if crs unit is degrees mapSettings = self.iface.mapCanvas().mapSettings( ) if QGis.QGIS_VERSION_INT >= 20300 else self.iface.mapCanvas( ).mapRenderer() if mapSettings.destinationCrs().mapUnits() in [QGis.Degrees]: self.showMessageBar( "The unit of current CRS is degrees, so terrain may not appear well.", QgsMessageBar.WARNING) self.templateType = templateType def currentObjectChanged(self, currentItem, previousItem): # save properties of previous item if previousItem and self.currentPage: self.saveProperties(previousItem, self.currentPage) self.currentItem = currentItem self.currentPage = None # hide text browser and all pages self.ui.textBrowser.hide() for page in self.pages.itervalues(): page.hide() parent = currentItem.parent() if parent is None: topItemIndex = currentItem.data(0, Qt.UserRole) pageType = self.topItemPages.get(topItemIndex, ppages.PAGE_NONE) page = self.pages.get(pageType, None) if page is None: self.showDescription(topItemIndex) return page.setup(self._settings.get(topItemIndex)) page.show() else: parentId = parent.data(0, Qt.UserRole) layerId = currentItem.data(0, Qt.UserRole) layer = QgsMapLayerRegistry.instance().mapLayer(unicode(layerId)) if layer is None: return layerType = layer.type() if layerType == QgsMapLayer.RasterLayer: page = self.pages[ppages.PAGE_DEM] page.setup( self._settings.get(parentId, {}).get(layerId, None), layer, False) elif layerType == QgsMapLayer.VectorLayer: page = self.pages[ppages.PAGE_VECTOR] page.setup( self._settings.get(parentId, {}).get(layerId, None), layer) else: return page.show() self.currentPage = page def objectItemChanged(self, item, column): parent = item.parent() if parent is None: return # checkbox of optional layer checked/unchecked if item == self.currentItem: if self.currentPage: # update enablement of property widgets self.currentPage.itemChanged(item) else: # select changed item self.ui.treeWidget.setCurrentItem(item) # set visible property #visible = item.data(0, Qt.CheckStateRole) == Qt.Checked #parentId = parent.data(0, Qt.UserRole) #layerId = item.data(0, Qt.UserRole) #self._settings.get(parentId, {}).get(layerId, {})["visible"] = visible def primaryDEMChanged(self, layerId): tree = self.ui.treeWidget parent = tree.topLevelItem( ObjectTreeItem.topItemIndex(ObjectTreeItem.ITEM_OPTDEM)) tree.blockSignals(True) for i in range(parent.childCount()): item = parent.child(i) isPrimary = item.data(0, Qt.UserRole) == layerId item.setDisabled(isPrimary) tree.blockSignals(False) def showDescription(self, topItemIndex): fragment = { ObjectTreeItem.ITEM_OPTDEM: "additional-dem", ObjectTreeItem.ITEM_POINT: "point", ObjectTreeItem.ITEM_LINE: "line", ObjectTreeItem.ITEM_POLYGON: "polygon" }.get(topItemIndex) url = "http://qgis2threejs.readthedocs.org/en/docs-release/ExportSettings.html" if fragment: url += "#" + fragment html = '<a href="{0}">Online Help</a> about this item'.format(url) self.ui.textBrowser.setHtml(html) self.ui.textBrowser.show() def numericFields(self, layer): # get attributes of a sample feature and create numeric field name list numeric_fields = [] f = QgsFeature() layer.getFeatures().nextFeature(f) for field in f.fields(): isNumeric = False try: float(f.attribute(field.name())) isNumeric = True except ValueError: pass if isNumeric: numeric_fields.append(field.name()) return numeric_fields def mapTo3d(self): canvas = self.iface.mapCanvas() mapSettings = canvas.mapSettings( ) if QGis.QGIS_VERSION_INT >= 20300 else canvas.mapRenderer() world = self._settings.get(ObjectTreeItem.ITEM_WORLD, {}) bs = float(world.get("lineEdit_BaseSize", def_vals.baseSize)) ve = float(world.get("lineEdit_zFactor", def_vals.zExaggeration)) vs = float(world.get("lineEdit_zShift", def_vals.zShift)) return MapTo3D(mapSettings, bs, ve, vs) def progress(self, percentage=None, statusMsg=None): ui = self.ui if percentage is not None: ui.progressBar.setValue(percentage) if percentage == 100: ui.progressBar.setVisible(False) ui.label_Status.setText("") else: ui.progressBar.setVisible(True) if statusMsg is not None: ui.label_Status.setText(statusMsg) ui.label_Status.repaint() QgsApplication.processEvents(QEventLoop.ExcludeUserInputEvents) def run(self): self.endPointSelection() ui = self.ui filename = ui.lineEdit_OutputFilename.text() # ""=Temporary file if filename and os.path.exists(filename): if QMessageBox.question( self, "Qgis2threejs", "Output file already exists. Overwrite it?", QMessageBox.Ok | QMessageBox.Cancel) != QMessageBox.Ok: return # export to web (three.js) export_settings = ExportSettings(self.pluginManager, self.localBrowsingMode) export_settings.loadSettings(self.settings()) export_settings.setMapCanvas(self.iface.mapCanvas()) err_msg = export_settings.checkValidity() if err_msg is not None: QMessageBox.warning(self, "Qgis2threejs", err_msg or "Invalid settings") return ui.pushButton_Run.setEnabled(False) ui.toolButton_Settings.setVisible(False) self.clearMessageBar() self.progress(0) if export_settings.exportMode == ExportSettings.PLAIN_MULTI_RES: # update quads and point on map canvas self.createRubberBands(export_settings.baseExtent, export_settings.quadtree()) # export ret = exportToThreeJS(export_settings, self.iface.legendInterface(), self.objectTypeManager, self.progress) self.progress(100) ui.pushButton_Run.setEnabled(True) if not ret: ui.toolButton_Settings.setVisible(True) return self.clearRubberBands() # store last selections settings = QSettings() settings.setValue("/Qgis2threejs/lastTemplate", export_settings.templatePath) settings.setValue("/Qgis2threejs/lastControls", export_settings.controls) # open web browser if not tools.openHTMLFile(export_settings.htmlfilename): ui.toolButton_Settings.setVisible(True) return # close dialog QDialog.accept(self) def reject(self): # save properties of current object item = self.ui.treeWidget.currentItem() if item and self.currentPage: self.saveProperties(item, self.currentPage) self.endPointSelection() self.clearRubberBands() QDialog.reject(self) def help(self): url = "http://qgis2threejs.readthedocs.org/" import webbrowser webbrowser.open(url, new=2) # new=2: new tab if possible def startPointSelection(self): canvas = self.iface.mapCanvas() if self.previousMapTool != self.mapTool: self.previousMapTool = canvas.mapTool() canvas.setMapTool(self.mapTool) self.pages[ppages.PAGE_DEM].toolButton_PointTool.setVisible(False) def endPointSelection(self): self.mapTool.reset() if self.previousMapTool is not None: self.iface.mapCanvas().setMapTool(self.previousMapTool) def mapToolSet(self, mapTool): return #TODO: unstable if mapTool != self.mapTool and self.currentPage is not None: if self.currentPage.pageType == ppages.PAGE_DEM and self.currentPage.isPrimary: self.currentPage.toolButton_PointTool.setVisible(True) def createRubberBands(self, baseExtent, quadtree): self.clearRubberBands() # create quads with rubber band self.rb_quads = QgsRubberBand(self.iface.mapCanvas(), QGis.Line) self.rb_quads.setColor(Qt.blue) self.rb_quads.setWidth(1) quads = quadtree.quads() for quad in quads: geom = baseExtent.subrectangle(quad.rect).geometry() self.rb_quads.addGeometry(geom, None) self.log("Quad count: %d" % len(quads)) if not quadtree.focusRect: return # create a point with rubber band if quadtree.focusRect.width() == 0 or quadtree.focusRect.height() == 0: npt = quadtree.focusRect.center() self.rb_point = QgsRubberBand(self.iface.mapCanvas(), QGis.Point) self.rb_point.setColor(Qt.red) self.rb_point.addPoint(baseExtent.point(npt)) def clearRubberBands(self): # clear quads and point if self.rb_quads: self.iface.mapCanvas().scene().removeItem(self.rb_quads) self.rb_quads = None if self.rb_point: self.iface.mapCanvas().scene().removeItem(self.rb_point) self.rb_point = None def browseClicked(self): directory = os.path.split(self.ui.lineEdit_OutputFilename.text())[0] if not directory: directory = QDir.homePath() filename = QFileDialog.getSaveFileName( self, self.tr("Output filename"), directory, "HTML file (*.html *.htm)", options=QFileDialog.DontConfirmOverwrite) if not filename: return # append .html extension if filename doesn't have either .html or .htm if filename[-5:].lower() != ".html" and filename[-4:].lower( ) != ".htm": filename += ".html" self.ui.lineEdit_OutputFilename.setText(filename) def log(self, msg): if debug_mode: qDebug(msg)
def load_menus(self, profile=None, schema=None): """ Load menus in the main windows qgis bar """ if not schema: schema = self.combo_schema.currentText() if not profile: profile = self.combo_profile.currentText() # remove previous menus for menu in self.uiparent.menus: self.uiparent.iface.mainWindow().menuBar().removeAction( menu.menuAction()) with self.transaction(): cur = self.connection.cursor() select = """ select name, profile, model_index, datasource_uri from {}.{} where profile = '{}' """.format(schema, self.table, profile) cur.execute(select) rows = cur.fetchall() # item accessor ex: '0-menu/0-submenu/1-item/' menudict = {} # reference to parent item parent = '' # reference to qgis main menu bar menubar = self.uiparent.iface.mainWindow().menuBar() for name, profile, model_index, datasource_uri in self.sortby_modelindex( rows): uri_struct = QgsMimeDataUtils.Uri(datasource_uri) indexes = json.loads(model_index) # root menu parent = '{}-{}/'.format(indexes[0][0], indexes[0][1]) if parent not in menudict: menu = QMenu(self.uiparent.iface.mainWindow()) self.uiparent.menus.append(menu) menu.setObjectName(indexes[0][1]) menu.setTitle(indexes[0][1]) menubar.insertMenu( self.uiparent.iface.firstRightStandardMenu().menuAction(), menu) menudict[parent] = menu else: # menu already there menu = menudict[parent] for idx, subname in indexes[1:-1]: # intermediate submenus parent += '{}-{}/'.format(idx, subname) if parent not in menudict: submenu = menu.addMenu(subname) submenu.setObjectName(subname) submenu.setTitle(subname) menu = submenu # store it for later use menudict[parent] = menu continue # already treated menu = menudict[parent] # last item = layer layer = QAction(name, self.uiparent.iface.mainWindow()) if uri_struct.providerKey in ICON_MAPPER: layer.setIcon(QIcon(ICON_MAPPER[uri_struct.providerKey])) if uri_struct.providerKey == 'postgres': # set tooltip to postgres comment comment = self.get_table_comment(uri_struct.uri) layer.setStatusTip(comment) layer.setToolTip(comment) layer.setData(uri_struct.uri) layer.setWhatsThis(uri_struct.providerKey) layer.triggered.connect(self.layer_handler[uri_struct.layerType]) menu.addAction(layer)
class Tabs(QTabWidget): """TabWidget with a context-menu""" def __init__(self, parent, actions=None): QTabWidget.__init__(self, parent) tab_bar = TabsBase(self, parent) self.connect(tab_bar, SIGNAL('move_tab(int,int)'), self.move_tab) self.connect(tab_bar, SIGNAL('move_tab(long,int,int)'), self.move_tab_from_another_tabwidget) self.setTabBar(tab_bar) self.menu = QMenu(self) if actions: add_actions(self.menu, actions) self.index_history = [] self.connect(self, SIGNAL('currentChanged(int)'), self.__current_changed) tabsc = QShortcut(QKeySequence("Ctrl+Tab"), parent, self.tab_navigate) tabsc.setContext(Qt.WidgetWithChildrenShortcut) def __current_changed(self, index): for i, ind in [(i, ind) for i, ind in enumerate(self.index_history)]: if ind > self.count() - 1: self.index_history.pop(i) while index in self.index_history: self.index_history.pop(self.index_history.index(index)) self.index_history.append(index) def tab_navigate(self): """Ctrl+Tab""" if len(self.index_history) > 1: last = len(self.index_history) - 1 index = self.index_history.pop(last) self.index_history.insert(0, index) self.setCurrentIndex(self.index_history[last]) elif len(self.index_history) == 0 and self.count(): self.index_history = [self.currentIndex()] def contextMenuEvent(self, event): """Override Qt method""" if self.menu: self.menu.popup(event.globalPos()) def mousePressEvent(self, event): """Override Qt method""" if event.button() == Qt.MidButton: index = self.tabBar().tabAt(event.pos()) if index >= 0: self.emit(SIGNAL("close_tab(int)"), index) event.accept() return QTabWidget.mousePressEvent(self, event) def keyPressEvent(self, event): """Override Qt method""" ctrl = event.modifiers() & Qt.ControlModifier key = event.key() handled = False if ctrl and self.count() > 0: index = self.currentIndex() if key == Qt.Key_PageUp and index > 0: self.setCurrentIndex(index - 1) handled = True elif key == Qt.Key_PageDown and index < self.count() - 1: self.setCurrentIndex(index + 1) handled = True if handled: event.accept() else: QTabWidget.keyPressEvent(self, event) def move_tab(self, index_from, index_to): """Move tab inside a tabwidget""" self.emit(SIGNAL('move_data(int,int)'), index_from, index_to) tip, text = self.tabToolTip(index_from), self.tabText(index_from) icon, widget = self.tabIcon(index_from), self.widget(index_from) current_widget = self.currentWidget() self.removeTab(index_from) self.insertTab(index_to, widget, icon, text) self.setTabToolTip(index_to, tip) self.setCurrentWidget(current_widget) self.emit(SIGNAL('move_tab_finished()')) def move_tab_from_another_tabwidget(self, tabwidget_from, index_from, index_to): """Move tab from a tabwidget to another""" self.emit(SIGNAL('move_tab(long,long,int,int)'), tabwidget_from, id(self), index_from, index_to)
def setupUi(self, port): self.setObjectName("MainWindow") self.resize(600, 600) self.centralwidget = QWidget(self) p = self.centralwidget.palette() self.centralwidget.setAutoFillBackground(True) p.setColor(self.centralwidget.backgroundRole(), QColor(126, 135, 152)) self.centralwidget.setPalette(p) self.centralwidget.setObjectName("centralwidget") self.gridLayout = QGridLayout(self.centralwidget) self.gridLayout.setObjectName("gridLayout") self.setCentralWidget(self.centralwidget) self.menubar = QMenuBar(self) self.menubar.setGeometry(QRect(0, 0, 808, 25)) self.menubar.setObjectName("menubar") self.menuFile = QMenu(self.menubar) self.menuFile.setObjectName("menuFile") self.setMenuBar(self.menubar) self.statusbar = QStatusBar(self) self.statusbar.setObjectName("statusbar") self.setStatusBar(self.statusbar) self.actionQuit = QAction(self) self.actionQuit.setObjectName("actionQuit") self.menuFile.addSeparator() self.menuFile.addAction(self.actionQuit) self.menubar.addAction(self.menuFile.menuAction()) self.actionReset = QAction(self) self.actionReset.setObjectName("reset") self.menuFile.addSeparator() self.menuFile.addAction(self.actionReset) self.menubar.addAction(self.menuFile.menuAction()) # add other GUI objects self.graph_widget = GraphWidget(self.statusbar) self.gridLayout.addWidget(self.graph_widget, 1, 11, 10, 10) pixmap = QPixmap(':/images/cta-logo-mini.png') lbl = QLabel() lbl.setPixmap(pixmap) self.gridLayout.addWidget(lbl, 0, 0) p = self.graph_widget.palette() self.graph_widget.setAutoFillBackground(True) p.setColor( self.graph_widget.backgroundRole(), QColor(255, 255, 255)) # QColor(226, 235, 252)) self.graph_widget.setPalette(p) self.quitButton = QPushButton() # self.centralwidget) self.quitButton.setObjectName("quitButton") self.quitButton.setText(QApplication.translate ("MainWindow", "Quit", None, QApplication.UnicodeUTF8)) self.gridLayout.addWidget(self.quitButton, 12, 0, 1, 1) self.info_label = InfoLabel(0, 4) self.info_label.setAutoFillBackground(True) self.gridLayout.addWidget(self.info_label, 1, 0, 1, 5) # self.info_label.setAlignment(PyQt4.Qt.AlignCenter); palette = QPalette() palette.setColor(self.info_label.backgroundRole(), Qt.lightGray) self.info_label.setPalette(palette) QObject.connect( self.quitButton, SIGNAL("clicked()"), self.stop) QObject.connect( self.actionQuit, SIGNAL("triggered()"), self.stop) QMetaObject.connectSlotsByName(self) self.retranslateUi() QObject.connect( self.actionQuit, SIGNAL("triggered()"), self.close) QMetaObject.connectSlotsByName(self) # Create GuiConnexion for ZMQ comminucation with pipeline self.guiconnection = GuiConnexion(gui_port=port, statusBar=self.statusbar) self.guiconnection.message.connect(self.graph_widget.pipechange) self.guiconnection.message.connect(self.info_label.pipechange) self.guiconnection.reset_message.connect(self.graph_widget.reset) self.guiconnection.reset_message.connect(self.info_label.reset) self.guiconnection.mode_message.connect(self.info_label.mode_receive) QObject.connect( self.actionReset, SIGNAL("triggered()"), self.guiconnection.reset) QMetaObject.connectSlotsByName(self) # start the process self.guiconnection.start()
def __init__(self, config): super(FreeseerApp, self).__init__() self.config = config self.icon = QIcon() self.icon.addPixmap(QPixmap(_fromUtf8(":/freeseer/logo.png")), QIcon.Normal, QIcon.Off) self.setWindowIcon(self.icon) self.aboutDialog = AboutDialog() self.aboutDialog.setModal(True) self.logDialog = LogDialog() # # Translator # self.app = QApplication.instance() self.current_language = None self.uiTranslator = QTranslator() self.uiTranslator.load(":/languages/tr_en_US.qm") self.app.installTranslator(self.uiTranslator) self.langActionGroup = QActionGroup(self) self.langActionGroup.setExclusive(True) QTextCodec.setCodecForTr(QTextCodec.codecForName('utf-8')) self.connect(self.langActionGroup, SIGNAL('triggered(QAction *)'), self.translate) # --- Translator # # Setup Menubar # self.menubar = self.menuBar() self.menubar.setGeometry(QRect(0, 0, 500, 50)) self.menubar.setObjectName(_fromUtf8("menubar")) self.menuFile = QMenu(self.menubar) self.menuFile.setObjectName(_fromUtf8("menuFile")) self.menuLanguage = QMenu(self.menubar) self.menuLanguage.setObjectName(_fromUtf8("menuLanguage")) self.menuHelp = QMenu(self.menubar) self.menuHelp.setObjectName(_fromUtf8("menuHelp")) exitIcon = QIcon.fromTheme("application-exit") self.actionExit = QAction(self) self.actionExit.setShortcut("Ctrl+Q") self.actionExit.setObjectName(_fromUtf8("actionExit")) self.actionExit.setIcon(exitIcon) helpIcon = QIcon.fromTheme("help-contents") self.actionOnlineHelp = QAction(self) self.actionOnlineHelp.setObjectName(_fromUtf8("actionOnlineHelp")) self.actionOnlineHelp.setIcon(helpIcon) self.actionAbout = QAction(self) self.actionAbout.setObjectName(_fromUtf8("actionAbout")) self.actionAbout.setIcon(self.icon) self.actionLog = QAction(self) self.actionLog.setObjectName(_fromUtf8("actionLog")) self.actionLog.setShortcut("Ctrl+L") # Actions self.menuFile.addAction(self.actionExit) self.menuHelp.addAction(self.actionAbout) self.menuHelp.addAction(self.actionLog) self.menuHelp.addAction(self.actionOnlineHelp) self.menubar.addAction(self.menuFile.menuAction()) self.menubar.addAction(self.menuLanguage.menuAction()) self.menubar.addAction(self.menuHelp.menuAction()) self.setupLanguageMenu() # --- End Menubar self.connect(self.actionExit, SIGNAL('triggered()'), self.close) self.connect(self.actionAbout, SIGNAL('triggered()'), self.aboutDialog.show) self.connect(self.actionLog, SIGNAL('triggered()'), self.logDialog.show) self.connect(self.actionOnlineHelp, SIGNAL('triggered()'), self.openOnlineHelp) self.retranslateFreeseerApp() self.aboutDialog.aboutWidget.retranslate("en_US")
class FreeseerApp(QMainWindow): def __init__(self, config): super(FreeseerApp, self).__init__() self.config = config self.icon = QIcon() self.icon.addPixmap(QPixmap(_fromUtf8(":/freeseer/logo.png")), QIcon.Normal, QIcon.Off) self.setWindowIcon(self.icon) self.aboutDialog = AboutDialog() self.aboutDialog.setModal(True) self.logDialog = LogDialog() # # Translator # self.app = QApplication.instance() self.current_language = None self.uiTranslator = QTranslator() self.uiTranslator.load(":/languages/tr_en_US.qm") self.app.installTranslator(self.uiTranslator) self.langActionGroup = QActionGroup(self) self.langActionGroup.setExclusive(True) QTextCodec.setCodecForTr(QTextCodec.codecForName('utf-8')) self.connect(self.langActionGroup, SIGNAL('triggered(QAction *)'), self.translate) # --- Translator # # Setup Menubar # self.menubar = self.menuBar() self.menubar.setGeometry(QRect(0, 0, 500, 50)) self.menubar.setObjectName(_fromUtf8("menubar")) self.menuFile = QMenu(self.menubar) self.menuFile.setObjectName(_fromUtf8("menuFile")) self.menuLanguage = QMenu(self.menubar) self.menuLanguage.setObjectName(_fromUtf8("menuLanguage")) self.menuHelp = QMenu(self.menubar) self.menuHelp.setObjectName(_fromUtf8("menuHelp")) exitIcon = QIcon.fromTheme("application-exit") self.actionExit = QAction(self) self.actionExit.setShortcut("Ctrl+Q") self.actionExit.setObjectName(_fromUtf8("actionExit")) self.actionExit.setIcon(exitIcon) helpIcon = QIcon.fromTheme("help-contents") self.actionOnlineHelp = QAction(self) self.actionOnlineHelp.setObjectName(_fromUtf8("actionOnlineHelp")) self.actionOnlineHelp.setIcon(helpIcon) self.actionAbout = QAction(self) self.actionAbout.setObjectName(_fromUtf8("actionAbout")) self.actionAbout.setIcon(self.icon) self.actionLog = QAction(self) self.actionLog.setObjectName(_fromUtf8("actionLog")) self.actionLog.setShortcut("Ctrl+L") # Actions self.menuFile.addAction(self.actionExit) self.menuHelp.addAction(self.actionAbout) self.menuHelp.addAction(self.actionLog) self.menuHelp.addAction(self.actionOnlineHelp) self.menubar.addAction(self.menuFile.menuAction()) self.menubar.addAction(self.menuLanguage.menuAction()) self.menubar.addAction(self.menuHelp.menuAction()) self.setupLanguageMenu() # --- End Menubar self.connect(self.actionExit, SIGNAL('triggered()'), self.close) self.connect(self.actionAbout, SIGNAL('triggered()'), self.aboutDialog.show) self.connect(self.actionLog, SIGNAL('triggered()'), self.logDialog.show) self.connect(self.actionOnlineHelp, SIGNAL('triggered()'), self.openOnlineHelp) self.retranslateFreeseerApp() self.aboutDialog.aboutWidget.retranslate("en_US") def openOnlineHelp(self): """Opens a link to the Freeseer Online Help""" url = QUrl("http://freeseer.readthedocs.org") QDesktopServices.openUrl(url) def translate(self, action): """Translates the GUI via menu action. When a language is selected from the language menu, this function is called and the language to be changed to is retrieved. """ self.current_language = str( action.data().toString()).strip("tr_").rstrip(".qm") log.info("Switching language to: %s" % action.text()) self.uiTranslator.load(":/languages/tr_%s.qm" % self.current_language) self.app.installTranslator(self.uiTranslator) self.retranslateFreeseerApp() self.aboutDialog.aboutWidget.retranslate(self.current_language) self.retranslate() self.logDialog.retranslate() def retranslate(self): """ Reimplement this function to provide translations to your app. """ pass def retranslateFreeseerApp(self): # # Menubar # self.menuFile.setTitle(self.app.translate("FreeseerApp", "&File")) self.menuLanguage.setTitle( self.app.translate("FreeseerApp", "&Language")) self.menuHelp.setTitle(self.app.translate("FreeseerApp", "&Help")) self.actionExit.setText(self.app.translate("FreeseerApp", "&Quit")) self.actionAbout.setText(self.app.translate("FreeseerApp", "&About")) self.actionLog.setText(self.app.translate("FreeseerApp", "View &Log")) self.actionOnlineHelp.setText( self.app.translate("FreeseerApp", "Online Documentation")) # --- Menubar def setupLanguageMenu(self): self.languages = QDir(":/languages").entryList() if self.current_language is None: self.current_language = QLocale.system().name( ) # Retrieve Current Locale from the operating system. log.debug("Detected user's locale as %s" % self.current_language) for language in self.languages: translator = QTranslator( ) # Create a translator to translate Language Display Text. translator.load(":/languages/%s" % language) language_display_text = translator.translate( "Translation", "Language Display Text") languageAction = QAction(self) languageAction.setCheckable(True) languageAction.setText(language_display_text) languageAction.setData(language) self.menuLanguage.addAction(languageAction) self.langActionGroup.addAction(languageAction)
class FlashDlg(QWidget): def __init__(self, parent=None): QWidget.__init__(self, parent) self.ui = dlg.Ui_Form() self.ui.setupUi(self) self.ui_init() self.init_comports() self.init_romlist() # menu self.ctx_menu_init() # or ABORT self.init_btn() # flasher thread self.init_flasher_thread() def ctx_menu_init(self): self.pop_menu = QMenu() self.pop_menu.addAction(self.ui.action_clear_console) def init_btn(self): self.change_btn_to_flash() def change_btn_to_flash(self): self.btn_state = 'FLASH' self.ui.gobtn.setText(u'开始') # 已写入字节数 self.written = 0 # 时间消耗 self.elapse = time.time() def change_btn_to_abort(self): self.btn_state = 'ABORT' self.ui.gobtn.setText(u'终止') def action_state(self): return self.btn_state def closeEvent(self, evt): """ :type evt: QCloseEvent :param evt: """ self.flash_thread.exit() evt.accept() def init_flasher_thread(self): self.flasher = ESP8266Flasher() self.flash_thread = QThread() self.flasher.moveToThread(self.flash_thread) self.flash_thread.start() ''' begin_flash_sig = pyqtSignal(str, dict) abort_flash_sig = pyqtSignal() conn_result_sig = pyqtSignal(int) flash_progress_sig = pyqtSignal(int) flash_result_sig = pyqtSignal(int) console_sig = pyqtSignal(str) ''' self.flasher.begin_flash_sig.connect(self.flasher.begin_flash) self.flasher.abort_flash_sig.connect(self.flasher.abort_flash) self.flasher.conn_result_sig.connect(self.conn_result) self.flasher.flash_progress_sig.connect(self.flash_progress) self.flasher.flash_result_sig.connect(self.flash_result) self.flasher.console_sig.connect(self.consolelog) def conn_result(self, res): print('connect result is %r' % res) if res == 0: self.consolelog(u'串口同步成功,烧录即将进行') if res == 1: self.consolelog(u'同步串口失败,请检查所选串口并重试') self.change_btn_to_flash() def flash_result(self, res, desc): print('flash result is %r' % res) elapse = time.time() - self.elapse if res == 1: self.consolelog(u'烧录失败 %s 耗时 %d 秒' % (desc, elapse)) if res == 0: self.consolelog(u'固件烧录成功, 耗时 %d 秒' % elapse) self.change_btn_to_flash() def flash_progress(self, res, total): print('flash progress is %d, total %d, writed %d' % (res, total, self.written)) self.written += res self.ui.progbar.setValue((float(self.written) / total) * 100) def ui_init(self): self.setFixedSize(self.size()) self.consolelog(u'ESPUSH一键烧录工具 v2.0') url = u'https://espush.cn/api/portal/qqgroup' self.consolelog(u'加入 <a href="%s">ESPush IoT QQ群</a> 进行讨论。' % url) self.consolelog(u"\n") self.ui.textOut.setOpenLinks(True) self.ui.textOut.setOpenExternalLinks(True) def init_romlist(self): url = 'https://espush.cn/api/portal/admin/flasher/firmwares' rsp = requests.get(url) data = rsp.json() for firm in data: v = QVariant((firm, )) self.ui.firm_box.addItem(firm['description'], userData=v) def init_comports(self): ports = comports() self.ui.com_box.clear() ports = [el.device for el in ports] for port in ports: self.ui.com_box.addItem(port) def consolelog(self, msg): self.ui.textOut.append(msg) def console_clear(self): self.ui.textOut.clear() def down_firmfile(self, firm): url = 'https://espush.cn/api/portal/admin/down/firmwares/%d' % firm[ 'id'] rsp = requests.get(url) if rsp.status_code != 200: self.consolelog(u'下载失败') return if not self.checksum(rsp.content, firm['checksum']): self.consolelog('checksum failed!') return # write to file. self.write_local_firm_file(firm['id'], rsp.content) return rsp.content def write_local_firm_file(self, fid, content): # 文件夹是否存在,不存在则新增 if not os.path.exists(ROMS_DIR): try: os.mkdir(ROMS_DIR) except IOError: self.consolelog(u'创建下载 ROM 临时文件夹失败') return # 写入文件 self.consolelog(u'下载完毕,写入本地缓存文件') with open('%s/%d' % (ROMS_DIR, fid), 'wb') as fout: fout.write(content) def checksum(self, content, csum): md5 = lambda x: hashlib.md5(x).hexdigest() return md5(content) == csum def local_firm_exist(self, firm): firmname = '%s/%d' % (ROMS_DIR, firm['id']) if not os.path.exists(firmname): return with open(firmname, 'rb') as fin: return fin.read() def get_firmware(self, firm): rsp = self.local_firm_exist(firm) if rsp: return rsp self.consolelog(u'本地不存在,网上下载') rsp = self.down_firmfile(firm) if not rsp: self.consolelog(u'下载失败') return return rsp def get_embed_firms(self, fileName): # ":/resources/blank.bin" baseName = ':/resources/' bFile = QFile(baseName + fileName) if not bFile.open(QIODevice.ReadOnly): self.consolelog(u'读取内嵌资源 %s 出错!' % fileName) return content = bFile.readAll() return bytearray(content) def get_all_embed_firms(self): blank = self.get_embed_firms('blank.bin') if not blank: return boot = self.get_embed_firms('boot_v1.7.bin') if not boot: return esp_init_data = self.get_embed_firms('esp_init_data_default.bin') if not esp_init_data: return return { 'blank': blank, 'boot': boot, 'init': esp_init_data, } def go(self): if self.action_state() == 'FLASH': self.change_btn_to_abort() self.go_flash() elif self.action_state() == 'ABORT': self.change_btn_to_flash() self.go_abort() def go_abort(self): self.consolelog(u'准备终止烧录过程') self.flasher.abort_flash_sig.emit() def go_flash(self): firmwares = self.get_all_embed_firms() device = self.ui.com_box.currentText() firmware = self.ui.firm_box.itemData(self.ui.firm_box.currentIndex()) firmobj = firmware.toPyObject()[0] firmfile = self.get_firmware(firmobj) firmwares['app1'] = firmfile self.consolelog(u'固件准备完毕,准备烧录到 %s' % device) self.flasher.begin_flash_sig.emit(device, firmwares) def show_ctx_menu(self): self.pop_menu.exec_(QCursor.pos()) def clear_console(self): self.console_clear()
class ProfileTableViewer( QWidget ): " Profiling results table viewer " escapePressed = pyqtSignal() def __init__( self, scriptName, params, reportTime, dataFile, stats, parent = None ): QWidget.__init__( self, parent ) self.__table = ProfilerTreeWidget( self ) self.__table.escapePressed.connect( self.__onEsc ) self.__script = scriptName self.__stats = stats project = GlobalData().project if project.isLoaded(): self.__projectPrefix = os.path.dirname( project.fileName ) else: self.__projectPrefix = os.path.dirname( scriptName ) if not self.__projectPrefix.endswith( os.path.sep ): self.__projectPrefix += os.path.sep self.__table.setAlternatingRowColors( True ) self.__table.setRootIsDecorated( False ) self.__table.setItemsExpandable( False ) self.__table.setSortingEnabled( True ) self.__table.setItemDelegate( NoOutlineHeightDelegate( 4 ) ) self.__table.setUniformRowHeights( True ) self.__table.setSelectionMode( QAbstractItemView.SingleSelection ) self.__table.setSelectionBehavior( QAbstractItemView.SelectRows ) headerLabels = [ "", "Calls", "Total time", "Per call", "Cum. time", "Per call", "File name:line", "Function", "Callers", "Callees" ] self.__table.setHeaderLabels( headerLabels ) headerItem = self.__table.headerItem() headerItem.setToolTip( 0, "Indication if it is an outside function" ) headerItem.setToolTip( 1, "Actual number of calls/primitive calls " "(not induced via recursion)" ) headerItem.setToolTip( 2, "Total time spent in function " "(excluding time made in calls " "to sub-functions)" ) headerItem.setToolTip( 3, "Total time divided by number " "of actual calls" ) headerItem.setToolTip( 4, "Total time spent in function and all " "subfunctions (from invocation till exit)" ) headerItem.setToolTip( 5, "Cumulative time divided by number " "of primitive calls" ) headerItem.setToolTip( 6, "Function location" ) headerItem.setToolTip( 7, "Function name" ) headerItem.setToolTip( 8, "Function callers" ) headerItem.setToolTip( 9, "Function callees" ) self.__table.itemActivated.connect( self.__activated ) totalCalls = self.__stats.total_calls totalPrimitiveCalls = self.__stats.prim_calls # The calls were not induced via recursion totalTime = self.__stats.total_tt txt = "<b>Script:</b> " + self.__script + " " + params.arguments + "<br>" \ "<b>Run at:</b> " + reportTime + "<br>" + \ str( totalCalls ) + " function calls (" + \ str( totalPrimitiveCalls ) + " primitive calls) in " + \ FLOAT_FORMAT % totalTime + " CPU seconds" summary = QLabel( txt ) summary.setToolTip( txt ) summary.setSizePolicy( QSizePolicy.Ignored, QSizePolicy.Fixed ) summary.setFrameStyle( QFrame.StyledPanel ) summary.setAutoFillBackground( True ) summaryPalette = summary.palette() summaryBackground = summaryPalette.color( QPalette.Background ) summaryBackground.setRgb( min( summaryBackground.red() + 30, 255 ), min( summaryBackground.green() + 30, 255 ), min( summaryBackground.blue() + 30, 255 ) ) summaryPalette.setColor( QPalette.Background, summaryBackground ) summary.setPalette( summaryPalette ) vLayout = QVBoxLayout() vLayout.setContentsMargins( 0, 0, 0, 0 ) vLayout.setSpacing( 0 ) vLayout.addWidget( summary ) vLayout.addWidget( self.__table ) self.setLayout( vLayout ) self.__createContextMenu() self.__populate( totalTime ) return def __onEsc( self ): " Triggered when Esc is pressed " self.escapePressed.emit() return def __createContextMenu( self ): " Creates context menu for the table raws " self.__contextMenu = QMenu( self ) self.__callersMenu = QMenu( "Callers", self ) self.__outsideCallersMenu = QMenu( "Outside callers", self ) self.__calleesMenu = QMenu( "Callees", self ) self.__outsideCalleesMenu = QMenu( "Outside callees", self ) self.__contextMenu.addMenu( self.__callersMenu ) self.__contextMenu.addMenu( self.__outsideCallersMenu ) self.__contextMenu.addSeparator() self.__contextMenu.addMenu( self.__calleesMenu ) self.__contextMenu.addMenu( self.__outsideCalleesMenu ) self.__contextMenu.addSeparator() self.__disasmAct = self.__contextMenu.addAction( PixmapCache().getIcon( 'disasmmenu.png' ), "Disassemble", self.__onDisassemble ) self.__callersMenu.triggered.connect( self.__onCallContextMenu ) self.__outsideCallersMenu.triggered.connect( self.__onCallContextMenu ) self.__calleesMenu.triggered.connect( self.__onCallContextMenu ) self.__outsideCalleesMenu.triggered.connect( self.__onCallContextMenu ) self.__table.setContextMenuPolicy( Qt.CustomContextMenu ) self.__table.customContextMenuRequested.connect( self.__showContextMenu ) return def __showContextMenu( self, point ): " Context menu " self.__callersMenu.clear() self.__outsideCallersMenu.clear() self.__calleesMenu.clear() self.__outsideCalleesMenu.clear() # Detect what the item was clicked item = self.__table.itemAt( point ) funcName = item.getFunctionName() self.__disasmAct.setEnabled( item.getFileName() != "" and \ not funcName.startswith( "<" ) ) # Build the context menu if item.callersCount() == 0: self.__callersMenu.setEnabled( False ) self.__outsideCallersMenu.setEnabled( False ) else: callers = self.__stats.stats[ item.getFuncIDs() ][ 4 ] callersList = callers.keys() callersList.sort() for callerFunc in callersList: menuText = self.__getCallLine( callerFunc, callers[ callerFunc ] ) if self.__isOutsideItem( callerFunc[ 0 ] ): act = self.__outsideCallersMenu.addAction( menuText ) else: act = self.__callersMenu.addAction( menuText ) funcFileName, funcLine, funcName = self.__getLocationAndName( callerFunc ) act.setData( QVariant( funcFileName + ":" + \ str( funcLine ) + ":" + \ funcName ) ) self.__callersMenu.setEnabled( not self.__callersMenu.isEmpty() ) self.__outsideCallersMenu.setEnabled( not self.__outsideCallersMenu.isEmpty() ) if item.calleesCount() == 0: self.__calleesMenu.setEnabled( False ) self.__outsideCalleesMenu.setEnabled( False ) else: callees = self.__stats.all_callees[ item.getFuncIDs() ] calleesList = callees.keys() calleesList.sort() for calleeFunc in calleesList: menuText = self.__getCallLine( calleeFunc, callees[ calleeFunc ] ) if self.__isOutsideItem( calleeFunc[ 0 ] ): act = self.__outsideCalleesMenu.addAction( menuText ) else: act = self.__calleesMenu.addAction( menuText ) funcFileName, funcLine, funcName = self.__getLocationAndName( calleeFunc ) act.setData( QVariant( funcFileName + ":" + \ str( funcLine ) + ":" + \ funcName ) ) self.__calleesMenu.setEnabled( not self.__calleesMenu.isEmpty() ) self.__outsideCalleesMenu.setEnabled( not self.__outsideCalleesMenu.isEmpty() ) self.__contextMenu.popup( QCursor.pos() ) return def __onDisassemble( self ): " On disassemble something " item = self.__table.selectedItems()[ 0 ] GlobalData().mainWindow.showDisassembler( item.getFileName(), item.getFunctionName() ) return def __resize( self ): " Resizes columns to the content " self.__table.header().resizeSections( QHeaderView.ResizeToContents ) self.__table.header().setStretchLastSection( True ) self.__table.header().resizeSection( OUTSIDE_COL_INDEX, 28 ) self.__table.header().setResizeMode( OUTSIDE_COL_INDEX, QHeaderView.Fixed ) return def setFocus( self ): " Set focus to the proper widget " self.__table.setFocus() return def __isOutsideItem( self, fileName ): " Detects if the record should be shown as an outside one " return not fileName.startswith( self.__projectPrefix ) def __activated( self, item, column ): " Triggered when the item is activated " try: line = item.getLineNumber() fileName = item.getFileName() if line == 0 or not os.path.isabs( fileName ): return GlobalData().mainWindow.openFile( fileName, line ) except: logging.error( "Could not jump to function location" ) return @staticmethod def __getFuncShortLocation( funcFileName, funcLine ): " Provides unified shortened function location " if funcFileName == "": return "" return os.path.basename( funcFileName ) + ":" + str( funcLine ) def __getCallLine( self, func, props ): " Provides the formatted call line " funcFileName, funcLine, funcName = self.__getLocationAndName( func ) if isinstance( props, tuple ): actualCalls, primitiveCalls, totalTime, cumulativeTime = props if primitiveCalls != actualCalls: callsString = str( actualCalls ) + "/" + str( primitiveCalls ) else: callsString = str( actualCalls ) return callsString + "\t" + FLOAT_FORMAT % totalTime + "\t" + \ FLOAT_FORMAT % cumulativeTime + "\t" + \ self.__getFuncShortLocation( funcFileName, funcLine ) + \ "(" + funcName + ")" # I've never seen this branch working so it is just in case. # There was something like this in the pstats module return self.__getFuncShortLocation( funcFileName, funcLine ) + \ "(" + funcName + ")" @staticmethod def __getLocationAndName( func ): " Provides standardized function file name, line and its name " if func[ : 2 ] == ( '~', 0 ): # special case for built-in functions name = func[ 2 ] if name.startswith( '<' ) and name.endswith( '>' ): return "", 0, "{%s}" % name[ 1 : -1 ] return "", 0, name return func[ 0 ], func[ 1 ], func[ 2 ] def __createItem( self, func, totalCPUTime, primitiveCalls, actualCalls, totalTime, cumulativeTime, timePerCall, cumulativeTimePerCall, callers ): " Creates an item to display " values = [] values.append( "" ) if primitiveCalls == actualCalls: values.append( str( actualCalls ) ) else: values.append( str( actualCalls ) + "/" + str( primitiveCalls ) ) if totalCPUTime == 0.0: values.append( FLOAT_FORMAT % totalTime ) else: values.append( FLOAT_FORMAT % totalTime + " \t(%3.2f%%)" % (totalTime / totalCPUTime * 100) ) values.append( FLOAT_FORMAT % timePerCall ) values.append( FLOAT_FORMAT % cumulativeTime ) values.append( FLOAT_FORMAT % cumulativeTimePerCall ) # Location and name will be filled in the item constructor values.append( "" ) values.append( "" ) # Callers callersCount = len( callers ) values.append( str( callersCount ) ) # Callees if func in self.__stats.all_callees: calleesCount = len( self.__stats.all_callees[ func ] ) else: calleesCount = 0 values.append( str( calleesCount ) ) item = ProfilingTableItem( values, self.__isOutsideItem( func[ 0 ] ), func ) if callersCount != 0: tooltip = "" callersList = callers.keys() callersList.sort() for callerFunc in callersList[ : MAX_CALLS_IN_TOOLTIP ]: if tooltip != "": tooltip += "\n" tooltip += self.__getCallLine( callerFunc, callers[ callerFunc ] ) if callersCount > MAX_CALLS_IN_TOOLTIP: tooltip += "\n. . ." item.setToolTip( 8, tooltip ) if calleesCount != 0: callees = self.__stats.all_callees[ func ] tooltip = "" calleesList = callees.keys() calleesList.sort() for calleeFunc in calleesList[ : MAX_CALLS_IN_TOOLTIP ]: if tooltip != "": tooltip += "\n" tooltip += self.__getCallLine( calleeFunc, callees[ calleeFunc ] ) if calleesCount > MAX_CALLS_IN_TOOLTIP: tooltip += "\n. . ." item.setToolTip( 9, tooltip ) self.__table.addTopLevelItem( item ) return def __populate( self, totalCPUTime ): " Populates the data " for func, ( primitiveCalls, actualCalls, totalTime, cumulativeTime, callers ) in self.__stats.stats.items(): # Calc time per call if actualCalls == 0: timePerCall = 0.0 else: timePerCall = totalTime / actualCalls # Calc time per cummulative call if primitiveCalls == 0: cumulativeTimePerCall = 0.0 else: cumulativeTimePerCall = cumulativeTime / primitiveCalls self.__createItem( func, totalCPUTime, primitiveCalls, actualCalls, totalTime, cumulativeTime, timePerCall, cumulativeTimePerCall, callers ) self.__resize() self.__table.header().setSortIndicator( 2, Qt.DescendingOrder ) self.__table.sortItems( 2, self.__table.header().sortIndicatorOrder() ) return def togglePath( self, state ): " Switches between showing full paths or file names in locations " for index in xrange( 0, self.__table.topLevelItemCount() ): self.__table.topLevelItem( index ).updateLocation( state ) self.__resize() return def __onCallContextMenu( self, act ): " Triggered when a context menu action is requested " name = str( act.data().toString() ) for index in xrange( 0, self.__table.topLevelItemCount() ): item = self.__table.topLevelItem( index ) if item.match( name ): self.__table.clearSelection() self.__table.scrollToItem( item ) self.__table.setCurrentItem( item ) return def onSaveAs( self, fileName ): " Saves the table to a file in CSV format " try: f = open( fileName, "wt" ) headerItem = self.__table.headerItem() outsideIndex = -1 for index in xrange( 0, headerItem.columnCount() ): title = str( headerItem.text( index ) ) if title == "": outsideIndex = index title = "Outside" if index != 0: f.write( ',' + title ) else: f.write( title ) for index in xrange( 0, self.__table.topLevelItemCount() ): item = self.__table.topLevelItem( index ) f.write( "\n" ) for column in xrange( 0, item.columnCount() ): if column != 0: f.write( ',' ) if column == outsideIndex: if item.isOutside(): f.write( "Y" ) else: f.write( "N" ) else: text = str( item.text( column ) ) f.write( text.replace( '\t', '' ) ) f.close() except Exception, ex: logging.error( ex ) return
def __init__(self): super().__init__() self.in_data = None self.in_distance = None self.in_learner = None self.in_classifier = None self.in_object = None self.auto_execute = False for s in self.libraryListSource: s.flags = 0 self._cachedDocuments = { } self.infoBox = gui.widgetBox(self.controlArea, 'Info') gui.label( self.infoBox, self, "<p>Execute python script.</p><p>Input variables:<ul><li> " + \ "<li>".join(t.name for t in self.inputs) + \ "</ul></p><p>Output variables:<ul><li>" + \ "<li>".join(t.name for t in self.outputs) + \ "</ul></p>" ) self.libraryList = itemmodels.PyListModel( [], self, flags = Qt.ItemIsSelectable | Qt.ItemIsEnabled | Qt.ItemIsEditable) self.libraryList.wrap(self.libraryListSource) self.controlBox = gui.widgetBox(self.controlArea, 'Library') self.controlBox.layout().setSpacing(1) self.libraryView = QListView( editTriggers = QListView.DoubleClicked | QListView.EditKeyPressed, sizePolicy = QSizePolicy(QSizePolicy.Ignored, QSizePolicy.Preferred) ) self.libraryView.setItemDelegate(ScriptItemDelegate(self)) self.libraryView.setModel(self.libraryList) self.libraryView.selectionModel().selectionChanged.connect( self.onSelectedScriptChanged ) self.controlBox.layout().addWidget(self.libraryView) w = itemmodels.ModelActionsWidget() self.addNewScriptAction = action = QAction("+", self) action.setToolTip("Add a new script to the library") action.triggered.connect(self.onAddScript) w.addAction(action) action = QAction(unicodedata.lookup("MINUS SIGN"), self) action.setToolTip("Remove script from library") action.triggered.connect(self.onRemoveScript) w.addAction(action) action = QAction("Update", self) action.setToolTip("Save changes in the editor to library") action.setShortcut(QKeySequence(QKeySequence.Save)) action.triggered.connect(self.commitChangesToLibrary) w.addAction(action) action = QAction("More", self, toolTip = "More actions") new_from_file = QAction("Import a script from a file", self) save_to_file = QAction("Save selected script to a file", self) save_to_file.setShortcut(QKeySequence(QKeySequence.SaveAs)) new_from_file.triggered.connect(self.onAddScriptFromFile) save_to_file.triggered.connect(self.saveScript) menu = QMenu(w) menu.addAction(new_from_file) menu.addAction(save_to_file) action.setMenu(menu) button = w.addAction(action) button.setPopupMode(QToolButton.InstantPopup) w.layout().setSpacing(1) self.controlBox.layout().addWidget(w) gui.auto_commit(self.controlArea, self, "auto_execute", "Execute") self.splitCanvas = QSplitter(Qt.Vertical, self.mainArea) self.mainArea.layout().addWidget(self.splitCanvas) self.defaultFont = defaultFont = \ "Monaco" if sys.platform == "darwin" else "Courier" self.textBox = gui.widgetBox(self, 'Python script') self.splitCanvas.addWidget(self.textBox) self.text = PythonScriptEditor(self) self.textBox.layout().addWidget(self.text) self.textBox.setAlignment(Qt.AlignVCenter) self.text.setTabStopWidth(4) self.text.modificationChanged[bool].connect(self.onModificationChanged) self.saveAction = action = QAction("&Save", self.text) action.setToolTip("Save script to file") action.setShortcut(QKeySequence(QKeySequence.Save)) action.setShortcutContext(Qt.WidgetWithChildrenShortcut) action.triggered.connect(self.saveScript) self.consoleBox = gui.widgetBox(self, 'Console') self.splitCanvas.addWidget(self.consoleBox) self.__dict__['sc'] = self._sc self.__dict__['hc'] = self._hc self.console = PySparkConsole(self.__dict__, self, sc = self.sc) self.consoleBox.layout().addWidget(self.console) self.console.document().setDefaultFont(QFont(defaultFont)) self.consoleBox.setAlignment(Qt.AlignBottom) self.console.setTabStopWidth(4) select_row(self.libraryView, self.currentScriptIndex) self.splitCanvas.setSizes([2, 1]) if self.splitterState is not None: self.splitCanvas.restoreState(QByteArray(self.splitterState)) self.splitCanvas.splitterMoved[int, int].connect(self.onSpliterMoved) self.controlArea.layout().addStretch(1) self.resize(800, 600)
class MainWindow(QMainWindow, object): """ QMainWindow displays pipeline Parameters ---------- port : str used port to communicate with pipeline Note: The firewall must be configure to accept input/output on this port """ def __init__(self, port): super(MainWindow, self).__init__() self.setupUi(port) def setupUi(self, port): self.setObjectName("MainWindow") self.resize(600, 600) self.centralwidget = QWidget(self) p = self.centralwidget.palette() self.centralwidget.setAutoFillBackground(True) p.setColor(self.centralwidget.backgroundRole(), QColor(126, 135, 152)) self.centralwidget.setPalette(p) self.centralwidget.setObjectName("centralwidget") self.gridLayout = QGridLayout(self.centralwidget) self.gridLayout.setObjectName("gridLayout") self.setCentralWidget(self.centralwidget) self.menubar = QMenuBar(self) self.menubar.setGeometry(QRect(0, 0, 808, 25)) self.menubar.setObjectName("menubar") self.menuFile = QMenu(self.menubar) self.menuFile.setObjectName("menuFile") self.setMenuBar(self.menubar) self.statusbar = QStatusBar(self) self.statusbar.setObjectName("statusbar") self.setStatusBar(self.statusbar) self.actionQuit = QAction(self) self.actionQuit.setObjectName("actionQuit") self.menuFile.addSeparator() self.menuFile.addAction(self.actionQuit) self.menubar.addAction(self.menuFile.menuAction()) self.actionReset = QAction(self) self.actionReset.setObjectName("reset") self.menuFile.addSeparator() self.menuFile.addAction(self.actionReset) self.menubar.addAction(self.menuFile.menuAction()) # add other GUI objects self.graph_widget = GraphWidget(self.statusbar) self.gridLayout.addWidget(self.graph_widget, 1, 11, 10, 10) pixmap = QPixmap(':/images/cta-logo-mini.png') lbl = QLabel() lbl.setPixmap(pixmap) self.gridLayout.addWidget(lbl, 0, 0) p = self.graph_widget.palette() self.graph_widget.setAutoFillBackground(True) p.setColor( self.graph_widget.backgroundRole(), QColor(255, 255, 255)) # QColor(226, 235, 252)) self.graph_widget.setPalette(p) self.quitButton = QPushButton() # self.centralwidget) self.quitButton.setObjectName("quitButton") self.quitButton.setText(QApplication.translate ("MainWindow", "Quit", None, QApplication.UnicodeUTF8)) self.gridLayout.addWidget(self.quitButton, 12, 0, 1, 1) self.info_label = InfoLabel(0, 4) self.info_label.setAutoFillBackground(True) self.gridLayout.addWidget(self.info_label, 1, 0, 1, 5) # self.info_label.setAlignment(PyQt4.Qt.AlignCenter); palette = QPalette() palette.setColor(self.info_label.backgroundRole(), Qt.lightGray) self.info_label.setPalette(palette) QObject.connect( self.quitButton, SIGNAL("clicked()"), self.stop) QObject.connect( self.actionQuit, SIGNAL("triggered()"), self.stop) QMetaObject.connectSlotsByName(self) self.retranslateUi() QObject.connect( self.actionQuit, SIGNAL("triggered()"), self.close) QMetaObject.connectSlotsByName(self) # Create GuiConnexion for ZMQ comminucation with pipeline self.guiconnection = GuiConnexion(gui_port=port, statusBar=self.statusbar) self.guiconnection.message.connect(self.graph_widget.pipechange) self.guiconnection.message.connect(self.info_label.pipechange) self.guiconnection.reset_message.connect(self.graph_widget.reset) self.guiconnection.reset_message.connect(self.info_label.reset) self.guiconnection.mode_message.connect(self.info_label.mode_receive) QObject.connect( self.actionReset, SIGNAL("triggered()"), self.guiconnection.reset) QMetaObject.connectSlotsByName(self) # start the process self.guiconnection.start() def retranslateUi(self): self.setWindowTitle(QApplication.translate( "ctapipe-flow based GUI", "ctapipe-flow based GUI", None, QApplication.UnicodeUTF8)) self.menuFile.setTitle(QApplication.translate( "MainWindow", "File", None, QApplication.UnicodeUTF8)) self.actionQuit.setText(QApplication.translate( "MainWindow", "Quit", None, QApplication.UnicodeUTF8)) self.actionReset.setText(QApplication.translate( "MainWindow", "Reset", None, QApplication.UnicodeUTF8)) def stop(self): """Method connect (via Qt slot) to exit button Stops self.guiconnection (for ZMQ communication) process. Close main_windows """ self.guiconnection.finish() self.guiconnection.join() self.close() def closeEvent(self, event): self.guiconnection.finish() self.guiconnection.join() event.accept() # let the window close
class ProcessingPlugin: def __init__(self, iface): self.iface = iface def initGui(self): Processing.initialize() self.commander = None self.toolbox = ProcessingToolbox() self.iface.addDockWidget(Qt.RightDockWidgetArea, self.toolbox) self.toolbox.hide() Processing.addAlgListListener(self.toolbox) self.menu = QMenu(self.iface.mainWindow().menuBar()) self.menu.setObjectName('processing') self.menu.setTitle(self.tr('Pro&cessing')) self.toolboxAction = self.toolbox.toggleViewAction() self.toolboxAction.setObjectName('toolboxAction') self.toolboxAction.setIcon( QIcon(os.path.join(cmd_folder, 'images', 'alg.png'))) self.toolboxAction.setText(self.tr('&Toolbox')) self.iface.registerMainWindowAction(self.toolboxAction, 'Ctrl+Alt+T') self.menu.addAction(self.toolboxAction) self.modelerAction = QAction( QIcon(os.path.join(cmd_folder, 'images', 'model.png')), self.tr('Graphical &Modeler...'), self.iface.mainWindow()) self.modelerAction.setObjectName('modelerAction') self.modelerAction.triggered.connect(self.openModeler) self.iface.registerMainWindowAction(self.modelerAction, 'Ctrl+Alt+M') self.menu.addAction(self.modelerAction) self.historyAction = QAction( QIcon(os.path.join(cmd_folder, 'images', 'history.gif')), self.tr('&History...'), self.iface.mainWindow()) self.historyAction.setObjectName('historyAction') self.historyAction.triggered.connect(self.openHistory) self.iface.registerMainWindowAction(self.historyAction, 'Ctrl+Alt+H') self.menu.addAction(self.historyAction) self.configAction = QAction( QIcon(os.path.join(cmd_folder, 'images', 'config.png')), self.tr('&Options...'), self.iface.mainWindow()) self.configAction.setObjectName('configAction') self.configAction.triggered.connect(self.openConfig) self.iface.registerMainWindowAction(self.configAction, 'Ctrl+Alt+C') self.menu.addAction(self.configAction) self.resultsAction = QAction( QIcon(os.path.join(cmd_folder, 'images', 'results.png')), self.tr('&Results Viewer...'), self.iface.mainWindow()) self.resultsAction.setObjectName('resultsAction') self.resultsAction.triggered.connect(self.openResults) self.iface.registerMainWindowAction(self.resultsAction, 'Ctrl+Alt+R') self.menu.addAction(self.resultsAction) menuBar = self.iface.mainWindow().menuBar() menuBar.insertMenu(self.iface.firstRightStandardMenu().menuAction(), self.menu) self.commanderAction = QAction( QIcon(os.path.join(cmd_folder, 'images', 'commander.png')), self.tr('&Commander'), self.iface.mainWindow()) self.commanderAction.setObjectName('commanderAction') self.commanderAction.triggered.connect(self.openCommander) self.menu.addAction(self.commanderAction) self.iface.registerMainWindowAction(self.commanderAction, self.tr('Ctrl+Alt+M')) def unload(self): self.toolbox.setVisible(False) self.menu.deleteLater() # delete temporary output files folder = tempFolder() if QDir(folder).exists(): shutil.rmtree(folder, True) self.iface.unregisterMainWindowAction(self.commanderAction) def openCommander(self): if self.commander is None: self.commander = CommanderWindow(self.iface.mainWindow(), self.iface.mapCanvas()) Processing.addAlgListListener(self.commander) self.commander.prepareGui() self.commander.show() def openToolbox(self): if self.toolbox.isVisible(): self.toolbox.hide() else: self.toolbox.show() def openModeler(self): dlg = ModelerDialog() dlg.show() dlg.exec_() if dlg.update: self.toolbox.updateProvider('model') def openResults(self): dlg = ResultsDialog() dlg.show() dlg.exec_() def openHistory(self): dlg = HistoryDialog() dlg.exec_() def openConfig(self): dlg = ConfigDialog(self.toolbox) dlg.exec_() def tr(self, message): return QCoreApplication.translate('ProcessingPlugin', message)
def _menu_context_tree(self, point): index = self.indexAt(point) if not index.isValid(): return item = self.itemAt(point) handler = None menu = QMenu(self) if item.isFolder or item.parent() is None: self._add_context_menu_for_folders(menu, item) elif not item.isFolder: self._add_context_menu_for_files(menu, item) if item.parent() is None: #get the extra context menu for this projectType if isinstance(item, ProjectItem): return handler = settings.get_project_type_handler(item.projectType) self._add_context_menu_for_root(menu, item) menu.addMenu(self._folding_menu) #menu for all items (legacy API)! extra_menus = self.extra_menus.get('all', ()) #menu for all items! for m in extra_menus: if isinstance(m, QMenu): menu.addSeparator() menu.addMenu(m) #menu for the Project Type(if present) if handler: for m in handler.get_context_menus(): if isinstance(m, QMenu): menu.addSeparator() menu.addMenu(m) #show the menu! menu.exec_(QCursor.pos())
class BasicMonitor(QTableWidget): """ 基础监控 headerDict中的值对应的字典格式如下 {'chinese': u'中文名', 'cellType': BasicCell} """ signal = QtCore.pyqtSignal(type(Event())) signal_clear = QtCore.pyqtSignal(type(Event())) # ---------------------------------------------------------------------- def __init__(self, mainEngine=None, eventEngine=None, parent=None): """Constructor""" super(BasicMonitor, self).__init__(parent) self.mainEngine = mainEngine self.eventEngine = eventEngine self.signalemit = None self.signalclearemit = None # 保存表头标签用 self.headerDict = OrderedDict() # 有序字典,key是英文名,value是对应的配置字典 self.headerList = [] # 对应self.headerDict.keys() # 保存相关数据用 self.dataDict = {} # 字典,key是字段对应的数据,value是保存相关单元格的字典 self.dataKey = '' # 字典键对应的数据字段 # 监控的事件类型 self.eventType = '' self.eventTypeClear = '' # 字体 self.font = None # 保存数据对象到单元格 self.saveData = False # 默认不允许根据表头进行排序,需要的组件可以开启 self.sorting = False # 初始化右键菜单 self.initMenu() # ---------------------------------------------------------------------- def setHeaderDict(self, headerDict): """设置表头有序字典""" self.headerDict = headerDict self.headerList = list(headerDict.keys()) # ---------------------------------------------------------------------- def setDataKey(self, dataKey): """设置数据字典的键""" self.dataKey = dataKey # ---------------------------------------------------------------------- def setEventType(self, eventType1, eventType2=''): """设置监控的事件类型""" self.eventType = eventType1 self.eventTypeClear = eventType2 # ---------------------------------------------------------------------- def setFont(self, font): """设置字体""" self.font = font # ---------------------------------------------------------------------- def setSaveData(self, saveData): """设置是否要保存数据到单元格""" self.saveData = saveData # ---------------------------------------------------------------------- def initTable(self): """初始化表格""" # 设置表格的列数 col = len(self.headerDict) self.setColumnCount(col) # 设置列表头 labels = [d['chinese'] for d in list(self.headerDict.values())] self.setHorizontalHeaderLabels(labels) # 关闭左边的垂直表头 self.verticalHeader().setVisible(False) # 设为不可编辑 self.setEditTriggers(self.NoEditTriggers) # 设为行交替颜色 self.setAlternatingRowColors(True) # 设置允许排序 self.setSortingEnabled(self.sorting) # set stretch # self.horizontalHeader().setResizeMode(QHeaderView.Stretch) # ---------------------------------------------------------------------- def registerEvent(self): """注册GUI更新相关的事件监听""" self.signal.connect(self.updateEvent) self.signalemit = self.signal.emit self.eventEngine.register(self.eventType, self.signalemit) if len(self.eventTypeClear) > 0: self.signal_clear.connect(self.clearEvent) self.signalclearemit = self.signal_clear.emit self.eventEngine.register(self.eventTypeClear, self.signalclearemit) def unRegister(self): self.eventEngine.unregister(self.eventType, self.signalemit) if len(self.eventTypeClear) > 0: self.eventEngine.unregister(self.eventTypeClear, self.signalclearemit) # ---------------------------------------------------------------------- def updateEvent(self, event): """收到事件更新""" data = event.dict_['data'] self.updateData(data) def clearEvent(self, event): """收到事件更新""" self.dataDict.clear() self.setRowCount(0) # ---------------------------------------------------------------------- def updateData(self, data): """将数据更新到表格中""" # 如果允许了排序功能,则插入数据前必须关闭,否则插入新的数据会变乱 if self.sorting: self.setSortingEnabled(False) # 如果设置了dataKey,则采用存量更新模式 if self.dataKey: #key = data.__getattribute__(self.dataKey) key = getattr(data, self.dataKey, None) # 如果键在数据字典中不存在,则先插入新的一行,并创建对应单元格 if key not in self.dataDict: self.insertRow(0) d = {} for n, header in enumerate(self.headerList): content = safeUnicode(data.__getattribute__(header)) # content = safeUnicode(getattr(data, header, None)) cellType = self.headerDict[header]['cellType'] try: cell = cellType(content, self.mainEngine) except Exception as e: print(cellType) print(data) print(content) raise (e) if self.font: cell.setFont(self.font) # 如果设置了特殊字体,则进行单元格设置 if self.saveData: # 如果设置了保存数据对象,则进行对象保存 cell.data = data self.setItem(0, n, cell) d[header] = cell self.dataDict[key] = d # 否则如果已经存在,则直接更新相关单元格 else: d = self.dataDict[key] for header in self.headerList: content = safeUnicode(getattr(data, header, None)) cell = d[header] cell.setContent(content) if self.saveData: # 如果设置了保存数据对象,则进行对象保存 cell.data = data # 否则采用增量更新模式 else: self.insertRow(0) for n, header in enumerate(self.headerList): content = safeUnicode(data.__getattribute__(header)) cellType = self.headerDict[header]['cellType'] cell = cellType(content, self.mainEngine) if self.font: cell.setFont(self.font) if self.saveData: cell.data = data self.setItem(0, n, cell) # 调整列宽 self.resizeColumns() # 重新打开排序 if self.sorting: self.setSortingEnabled(True) # ---------------------------------------------------------------------- def resizeColumns(self): """调整各列的大小""" self.horizontalHeader().resizeSections(QHeaderView.ResizeToContents) # ---------------------------------------------------------------------- def setSorting(self, sorting): """设置是否允许根据表头排序""" self.sorting = sorting # ---------------------------------------------------------------------- def saveToCsv(self): """保存表格内容到CSV文件""" # 先隐藏右键菜单 self.menu.close() # 获取想要保存的文件名 path = QtGui.QFileDialog.getSaveFileName(self, '保存数据', '', 'CSV(*.csv)') try: if not path.isEmpty(): with open(safeUnicode(path), 'wb') as f: writer = csv.writer(f) # 保存标签 headers = [ header.encode('gbk') for header in self.headerList ] writer.writerow(headers) # 保存每行内容 for row in range(self.rowCount()): rowdata = [] for column in range(self.columnCount()): item = self.item(row, column) if item is not None: rowdata.append( safeUnicode(item.text()).encode('gbk')) else: rowdata.append('') writer.writerow(rowdata) except IOError: pass # ---------------------------------------------------------------------- def initMenu(self): """初始化右键菜单""" self.menu = QMenu(self) ''' saveAction = QAction(u'保存内容', self) saveAction.triggered.connect(self.saveToCsv) resizeAction = QAction(u'调整列宽', self) resizeAction.triggered.connect(self.resizeColumns) self.menu.addAction(resizeAction) self.menu.addAction(saveAction) ''' # ---------------------------------------------------------------------- def contextMenuEvent(self, event): """右键点击事件""" self.menu.popup(QtGui.QCursor.pos())
def createCtxMenu(self, value, isLink, evt): 'Creates and configures the menu itself' m = QMenu(self) sub = QMenu(Label.BROWSER_ASSIGN_TO, m) m.setTitle(Label.BROWSER_ASSIGN_TO) for index, label in self._fields.items(): act = QAction(label, m, triggered=self._makeMenuAction(index, value, isLink)) sub.addAction(act) m.addMenu(sub) action = m.exec_(self.mapToGlobal(evt.pos()))
def loadpopup(self, pos): lmenu = QMenu() loadAction = lmenu.addAction("Video laden") action = lmenu.exec_(self.mapToGlobal(pos)) if action == loadAction: self.handleButton()
def initGui(self): Processing.initialize() self.commander = None self.toolbox = ProcessingToolbox() self.iface.addDockWidget(Qt.RightDockWidgetArea, self.toolbox) self.toolbox.hide() Processing.addAlgListListener(self.toolbox) self.menu = QMenu(self.iface.mainWindow().menuBar()) self.menu.setObjectName('processing') self.menu.setTitle(self.tr('Pro&cessing')) self.toolboxAction = self.toolbox.toggleViewAction() self.toolboxAction.setObjectName('toolboxAction') self.toolboxAction.setIcon( QIcon(os.path.join(cmd_folder, 'images', 'alg.png'))) self.toolboxAction.setText(self.tr('&Toolbox')) self.iface.registerMainWindowAction(self.toolboxAction, 'Ctrl+Alt+T') self.menu.addAction(self.toolboxAction) self.modelerAction = QAction( QIcon(os.path.join(cmd_folder, 'images', 'model.png')), self.tr('Graphical &Modeler...'), self.iface.mainWindow()) self.modelerAction.setObjectName('modelerAction') self.modelerAction.triggered.connect(self.openModeler) self.iface.registerMainWindowAction(self.modelerAction, 'Ctrl+Alt+M') self.menu.addAction(self.modelerAction) self.historyAction = QAction( QIcon(os.path.join(cmd_folder, 'images', 'history.gif')), self.tr('&History...'), self.iface.mainWindow()) self.historyAction.setObjectName('historyAction') self.historyAction.triggered.connect(self.openHistory) self.iface.registerMainWindowAction(self.historyAction, 'Ctrl+Alt+H') self.menu.addAction(self.historyAction) self.configAction = QAction( QIcon(os.path.join(cmd_folder, 'images', 'config.png')), self.tr('&Options...'), self.iface.mainWindow()) self.configAction.setObjectName('configAction') self.configAction.triggered.connect(self.openConfig) self.iface.registerMainWindowAction(self.configAction, 'Ctrl+Alt+C') self.menu.addAction(self.configAction) self.resultsAction = QAction( QIcon(os.path.join(cmd_folder, 'images', 'results.png')), self.tr('&Results Viewer...'), self.iface.mainWindow()) self.resultsAction.setObjectName('resultsAction') self.resultsAction.triggered.connect(self.openResults) self.iface.registerMainWindowAction(self.resultsAction, 'Ctrl+Alt+R') self.menu.addAction(self.resultsAction) menuBar = self.iface.mainWindow().menuBar() menuBar.insertMenu(self.iface.firstRightStandardMenu().menuAction(), self.menu) self.commanderAction = QAction( QIcon(os.path.join(cmd_folder, 'images', 'commander.png')), self.tr('&Commander'), self.iface.mainWindow()) self.commanderAction.setObjectName('commanderAction') self.commanderAction.triggered.connect(self.openCommander) self.menu.addAction(self.commanderAction) self.iface.registerMainWindowAction(self.commanderAction, self.tr('Ctrl+Alt+M'))
class ShellBaseWidget(ConsoleBaseWidget): """ Shell base widget """ INITHISTORY = None SEPARATOR = None def __init__(self, parent, history_filename, debug=False, profile=False): """ parent : specifies the parent widget """ ConsoleBaseWidget.__init__(self, parent) # Prompt position: tuple (line, index) self.current_prompt_pos = None self.new_input_line = True # History self.histidx = None self.hist_wholeline = False assert isinstance(history_filename, (str, unicode)) self.history_filename = history_filename self.history = self.load_history() # Session self.historylog_filename = CONF.get('main', 'historylog_filename', get_conf_path('history.log')) # Context menu self.menu = None self.setup_context_menu() # Debug mode self.debug = debug # Simple profiling test self.profile = profile # write/flush self.__buffer = [] self.__timestamp = 0.0 # Give focus to widget self.setFocus() def setup(self): """Reimplement ConsoleBaseWidget method""" ConsoleBaseWidget.setup(self) self.set_caret(color=Qt.darkGray, width=2) self.remove_margins() # Suppressing Scintilla margins def toggle_wrap_mode(self, enable): """Reimplement ConsoleBaseWidget method: 'word' -> 'character'""" self.set_wrap_mode('character' if enable else None) def set_font(self, font): """Set shell styles font""" self.set_pythonshell_font(font) #------ Context menu def setup_context_menu(self): """Setup shell context menu""" self.menu = QMenu(self) self.cut_action = create_action(self, translate("ShellBaseWidget", "Cut"), shortcut=keybinding('Cut'), icon=get_icon('editcut.png'), triggered=self.cut) self.copy_action = create_action(self, translate("ShellBaseWidget", "Copy"), shortcut=keybinding('Copy'), icon=get_icon('editcopy.png'), triggered=self.copy) paste_action = create_action(self, translate("ShellBaseWidget", "Paste"), shortcut=keybinding('Paste'), icon=get_icon('editpaste.png'), triggered=self.paste) save_action = create_action(self, translate("ShellBaseWidget", "Save history log..."), icon=get_icon('filesave.png'), tip=translate( "ShellBaseWidget", "Save current history log (i.e. all " "inputs and outputs) in a text file"), triggered=self.save_historylog) add_actions(self.menu, (self.cut_action, self.copy_action, paste_action, None, save_action)) def contextMenuEvent(self, event): """Reimplement Qt method""" state = self.hasSelectedText() self.copy_action.setEnabled(state) self.cut_action.setEnabled(state) self.menu.popup(event.globalPos()) event.accept() #------ Input buffer def get_current_line_to_cursor(self): return self.get_text(self.current_prompt_pos, 'cursor') def get_current_line_from_cursor(self): return self.get_text('cursor', 'eof') def _select_input(self): """Select current line (without selecting console prompt)""" line, index = self.get_position('eof') if self.current_prompt_pos is None: pline, pindex = line, index else: pline, pindex = self.current_prompt_pos self.setSelection(pline, pindex, line, index) def clear_line(self): """Clear current line (without clearing console prompt)""" if self.current_prompt_pos is not None: self.remove_text(self.current_prompt_pos, 'eof') def clear_terminal(self): """ Clear terminal window Child classes reimplement this method to write prompt """ self.clear() # The buffer being edited def _set_input_buffer(self, text): """Set input buffer""" if self.current_prompt_pos is not None: self.replace_text(self.current_prompt_pos, 'eol', text) else: self.insert(text) self.set_cursor_position('eof') def _get_input_buffer(self): """Return input buffer""" input_buffer = '' if self.current_prompt_pos is not None: input_buffer = self.get_text(self.current_prompt_pos, 'eol') input_buffer = input_buffer.replace(os.linesep, '\n') return input_buffer input_buffer = pyqtProperty("QString", _get_input_buffer, _set_input_buffer) #------ Prompt def new_prompt(self, prompt): """ Print a new prompt and save its (line, index) position """ self.write(prompt, prompt=True) # now we update our cursor giving end of prompt self.current_prompt_pos = self.get_position('cursor') self.ensureCursorVisible() self.new_input_line = False def check_selection(self): """ Check if selected text is r/w, otherwise remove read-only parts of selection """ if self.current_prompt_pos is None: self.set_cursor_position('eof') else: self.truncate_selection(self.current_prompt_pos) #------ Copy / Keyboard interrupt def copy(self): """Copy text to clipboard... or keyboard interrupt""" if self.hasSelectedText(): text = unicode(self.selectedText()).replace(u"\u2029", os.linesep) QApplication.clipboard().setText(text) else: self.emit(SIGNAL("keyboard_interrupt()")) def cut(self): """Cut text""" self.check_selection() if self.hasSelectedText(): ConsoleBaseWidget.cut(self) def delete(self): """Remove selected text""" self.check_selection() if self.hasSelectedText(): ConsoleBaseWidget.removeSelectedText(self) def save_historylog(self): """Save current history log (all text in console)""" title = translate("ShellBaseWidget", "Save history log") self.emit(SIGNAL('redirect_stdio(bool)'), False) filename = QFileDialog.getSaveFileName(self, title, self.historylog_filename, "History logs (*.log)") self.emit(SIGNAL('redirect_stdio(bool)'), True) if filename: filename = osp.normpath(unicode(filename)) try: encoding.write(unicode(self.text()), filename) self.historylog_filename = filename CONF.set('main', 'historylog_filename', filename) except EnvironmentError, error: QMessageBox.critical(self, title, translate("ShellBaseWidget", "<b>Unable to save file '%1'</b>" "<br><br>Error message:<br>%2") \ .arg(osp.basename(filename)).arg(str(error)))
def initMenu(self): """初始化右键菜单""" self.menu = QMenu(self) '''
def createContextMenu(self): menu = QMenu() actionAddGroup = QgisHelper.createAction(menu, "&Add GroupLayer", self.addGroup) actionAddVectorLayer = QgisHelper.createAction(menu, "&Add VectorLayer", self.addVectorLayer) actionZoomToGroup = QgisHelper.createAction(menu, "&Zoom To Group", self.zoomToGroup) actionRenameGroupOrLayer = QgisHelper.createAction( menu, "&Rename", self.rename) actionRemoveLayer = QgisHelper.createAction(menu, "&Remove", self.removeLayer) actionGroupSelected = QgisHelper.createAction(menu, "&Group Selected", self.groupSelected) actionZoomToLayer = QgisHelper.createAction(menu, "&Zoom To Layer", self.zoomToLayer) actionOpenAttributetable = QgisHelper.createAction( menu, "&Open Attribute Table", self.openAttriTable) actionSaveAs = QgisHelper.createAction(menu, "&Save as...", self.saveAs) actionLayerProperty = QgisHelper.createAction(menu, "&Property", self.layerProperty) self.actionShowOverview = QgisHelper.createAction( menu, "&Show in overview...", self.showOverview, None, None, None, True) idx = self.mView.currentIndex() node = self.mView.layerTreeModel().index2node(idx) if not idx.isValid(): #global menu menu.addAction(actionAddGroup) menu.addAction(actionAddVectorLayer) # menu.addAction( QgsApplication.getThemeIcon( "/mActionExpandTree.png" ), "&Expand All" , self.mView, "expandAll()" ) # menu.addAction( QgsApplication.getThemeIcon( "/mActionCollapseTree.png" ), "&Collapse All" , self.mView, "collapseAll()" ) elif (node != None): if (QgsLayerTree.isGroup(node)): menu.addAction(actionZoomToGroup) menu.addAction(actionRemoveLayer) # menu.addAction( QgsApplication.getThemeIcon( "/mActionSetCRS.png" ), # tr( "&Set Group CRS" ), QgisApp.instance(), SLOT( legendGroupSetCRS() ) ); menu.addAction(actionRenameGroupOrLayer) if (str(self.mView.selectedNodes(True)) >= 2): menu.addAction(actionGroupSelected) menu.addAction(actionAddGroup) menu.addAction(actionAddVectorLayer) elif (QgsLayerTree.isLayer(node)): menu.addAction(actionZoomToLayer) menu.addAction(actionRemoveLayer) menu.addAction(self.actionShowOverview) if self.mView.currentLayer().type() == QgsMapLayer.VectorLayer: menu.addAction(actionOpenAttributetable) menu.addAction(actionLayerProperty) menu.addAction(actionSaveAs) # menu.addAction( actions.actionShowInOverview( menu ) ) # if layer.type() == QgsMapLayer.RasterLayer : # menu.addAction( "&Zoom to Best Scale (100%)" , QgisApp.instance(), " legendLayerZoomNative() " ) # rasterLayer = qobject_cast<QgsRasterLayer *>( layer ); # if ( rasterLayer && rasterLayer.rastertype() != QgsRasterLayer.Palette ) # menu.addAction( tr( "&Stretch Using Current Extent" ), QgisApp.instance(), SLOT( legendLayerStretchUsingCurrentExtent() ) ); # } # menu.addAction( QgsApplication.getThemeIcon( "/mActionRemoveLayer.svg" ), tr( "&Remove" ), QgisApp.instance(), " removeLayer() "); # // duplicate layer # QAction* duplicateLayersAction = menu.addAction( QgsApplication.getThemeIcon( "/mActionDuplicateLayer.svg" ), tr( "&Duplicate" ), QgisApp.instance(), SLOT( duplicateLayers() ) ); # # // set layer scale visibility # menu.addAction( tr( "&Set Layer Scale Visibility" ), QgisApp.instance(), SLOT( setLayerScaleVisibility() ) ); # # // set layer crs # menu.addAction( QgsApplication.getThemeIcon( "/mActionSetCRS.png" ), tr( "&Set Layer CRS" ), QgisApp.instance(), SLOT( setLayerCRS() ) ); # # // assign layer crs to project # menu.addAction( QgsApplication.getThemeIcon( "/mActionSetProjectCRS.png" ), tr( "Set &Project CRS from Layer" ), QgisApp.instance(), SLOT( setProjectCRSFromLayer() ) ); # # menu.addSeparator(); # # if ( layer && layer.type() == QgsMapLayer.VectorLayer ) # { # QgsVectorLayer* vlayer = qobject_cast<QgsVectorLayer *>( layer ); # # QAction *toggleEditingAction = QgisApp.instance().actionToggleEditing(); # QAction *saveLayerEditsAction = QgisApp.instance().actionSaveActiveLayerEdits(); # QAction *allEditsAction = QgisApp.instance().actionAllEdits(); # # // attribute table # menu.addAction( QgsApplication.getThemeIcon( "/mActionOpenTable.png" ), tr( "&Open Attribute Table" ), # QgisApp.instance(), SLOT( attributeTable() ) ); # # // allow editing # int cap = vlayer.dataProvider().capabilities(); # if ( cap & QgsVectorDataProvider.EditingCapabilities ) # { # if ( toggleEditingAction ) # { # menu.addAction( toggleEditingAction ); # toggleEditingAction.setChecked( vlayer.isEditable() ); # } # if ( saveLayerEditsAction && vlayer.isModified() ) # { # menu.addAction( saveLayerEditsAction ); # } # } # # if ( allEditsAction.isEnabled() ) # menu.addAction( allEditsAction ); # # // disable duplication of memory layers # if ( vlayer.storageType() == "Memory storage" && self.mView.selectedLayerNodes().count() == 1 ) # duplicateLayersAction.setEnabled( false ); # # // save as vector file # menu.addAction( tr( "Save As..." ), QgisApp.instance(), SLOT( saveAsFile() ) ); # menu.addAction( tr( "Save As Layer Definition File..." ), QgisApp.instance(), SLOT( saveAsLayerDefinition() ) ); # # if ( !vlayer.isEditable() && vlayer.dataProvider().supportsSubsetString() && vlayer.vectorJoins().isEmpty() ) # menu.addAction( tr( "&Filter..." ), QgisApp.instance(), SLOT( layerSubsetString() ) ); # # menu.addAction( actions.actionShowFeatureCount( menu ) ); # # menu.addSeparator(); # } # else if ( layer && layer.type() == QgsMapLayer.RasterLayer ) # { # menu.addAction( tr( "Save As..." ), QgisApp.instance(), SLOT( saveAsRasterFile() ) ); # menu.addAction( tr( "Save As Layer Definition File..." ), QgisApp.instance(), SLOT( saveAsLayerDefinition() ) ); # } # else if ( layer && layer.type() == QgsMapLayer.PluginLayer && self.mView.selectedLayerNodes().count() == 1 ) # { # // disable duplication of plugin layers # duplicateLayersAction.setEnabled( false ); # } # addCustomLayerActions( menu, layer ); # # if ( layer && QgsProject.instance().layerIsEmbedded( layer.id() ).isEmpty() ) # menu.addAction( tr( "&Properties" ), QgisApp.instance(), SLOT( layerProperties() ) ); # if ( node.parent() != self.mView.layerTreeModel().rootGroup() ): # menu.addAction( actions.actionMakeTopLevel( menu ) ) menu.addAction(actionRenameGroupOrLayer) if (len(self.mView.selectedNodes(True)) >= 2): menu.addAction(actionGroupSelected) # if ( self.mView.selectedLayerNodes().count() == 1 ) # { # QgisApp* app = QgisApp.instance(); # menu.addAction( tr( "Copy Style" ), app, SLOT( copyStyle() ) ); # if ( app.clipboard().hasFormat( QGSCLIPBOARD_STYLE_MIME ) ) # { # menu.addAction( tr( "Paste Style" ), app, SLOT( pasteStyle() ) ); # } # } return menu
def popup2(self, pos): contextmenu = QMenu() contextmenu.addAction("Play / Pause (SPACE)", self.handlePlayButton) contextmenu.addSeparator() contextmenu.addAction("Load Video (o)", self.handleButton) contextmenu.addAction("Toggle Slider (s)", self.toggleSlider) contextmenu.addSeparator() contextmenu.addAction("Information (i)", self.handleInfo) contextmenu.addSeparator() contextmenu.addAction("Exit (q)", self.handleQuit) contextmenu.exec_(QCursor.pos())
class DirectoriesDialog(QMainWindow): def __init__(self, parent, app): QMainWindow.__init__(self, None) self.app = app self.lastAddedFolder = platform.INITIAL_FOLDER_IN_DIALOGS self.recentFolders = Recent(self.app, 'recentFolders') self._setupUi() self.directoriesModel = DirectoriesModel(self.app.model.directory_tree, view=self.treeView) self.directoriesDelegate = DirectoriesDelegate() self.treeView.setItemDelegate(self.directoriesDelegate) self._setupColumns() self.app.recentResults.addMenu(self.menuLoadRecent) self.app.recentResults.addMenu(self.menuRecentResults) self.recentFolders.addMenu(self.menuRecentFolders) self._updateAddButton() self._updateRemoveButton() self._updateLoadResultsButton() self._setupBindings() def _setupBindings(self): self.scanButton.clicked.connect(self.scanButtonClicked) self.loadResultsButton.clicked.connect(self.actionLoadResults.trigger) self.addFolderButton.clicked.connect(self.actionAddFolder.trigger) self.removeFolderButton.clicked.connect(self.removeFolderButtonClicked) self.treeView.selectionModel().selectionChanged.connect( self.selectionChanged) self.app.recentResults.itemsChanged.connect( self._updateLoadResultsButton) self.recentFolders.itemsChanged.connect(self._updateAddButton) self.recentFolders.mustOpenItem.connect(self.app.model.add_directory) self.directoriesModel.foldersAdded.connect( self.directoriesModelAddedFolders) self.app.willSavePrefs.connect(self.appWillSavePrefs) def _setupActions(self): # (name, shortcut, icon, desc, func) ACTIONS = [ ('actionLoadResults', 'Ctrl+L', '', tr("Load Results..."), self.loadResultsTriggered), ('actionShowResultsWindow', '', '', tr("Results Window"), self.app.showResultsWindow), ('actionAddFolder', '', '', tr("Add Folder..."), self.addFolderTriggered), ] createActions(ACTIONS, self) def _setupMenu(self): self.menubar = QMenuBar(self) self.menubar.setGeometry(QRect(0, 0, 42, 22)) self.menuFile = QMenu(self.menubar) self.menuFile.setTitle(tr("File")) self.menuView = QMenu(self.menubar) self.menuView.setTitle(tr("View")) self.menuHelp = QMenu(self.menubar) self.menuHelp.setTitle(tr("Help")) self.menuLoadRecent = QMenu(self.menuFile) self.menuLoadRecent.setTitle(tr("Load Recent Results")) self.setMenuBar(self.menubar) self.menuFile.addAction(self.actionLoadResults) self.menuFile.addAction(self.menuLoadRecent.menuAction()) self.menuFile.addSeparator() self.menuFile.addAction(self.app.actionQuit) self.menuView.addAction(self.app.actionPreferences) self.menuView.addAction(self.actionShowResultsWindow) self.menuView.addAction(self.app.actionIgnoreList) self.menuHelp.addAction(self.app.actionShowHelp) self.menuHelp.addAction(self.app.actionRegister) self.menuHelp.addAction(self.app.actionCheckForUpdate) self.menuHelp.addAction(self.app.actionOpenDebugLog) self.menuHelp.addAction(self.app.actionAbout) self.menubar.addAction(self.menuFile.menuAction()) self.menubar.addAction(self.menuView.menuAction()) self.menubar.addAction(self.menuHelp.menuAction()) # Recent folders menu self.menuRecentFolders = QMenu() self.menuRecentFolders.addAction(self.actionAddFolder) self.menuRecentFolders.addSeparator() # Recent results menu self.menuRecentResults = QMenu() self.menuRecentResults.addAction(self.actionLoadResults) self.menuRecentResults.addSeparator() def _setupUi(self): self.setWindowTitle(self.app.NAME) self.resize(420, 338) self.centralwidget = QWidget(self) self.verticalLayout = QVBoxLayout(self.centralwidget) self.promptLabel = QLabel( tr("Select folders to scan and press \"Scan\"."), self.centralwidget) self.verticalLayout.addWidget(self.promptLabel) self.treeView = QTreeView(self.centralwidget) self.treeView.setSelectionMode(QAbstractItemView.ExtendedSelection) self.treeView.setSelectionBehavior(QAbstractItemView.SelectRows) self.treeView.setAcceptDrops(True) triggers = QAbstractItemView.DoubleClicked|QAbstractItemView.EditKeyPressed\ |QAbstractItemView.SelectedClicked self.treeView.setEditTriggers(triggers) self.treeView.setDragDropOverwriteMode(True) self.treeView.setDragDropMode(QAbstractItemView.DropOnly) self.treeView.setUniformRowHeights(True) self.verticalLayout.addWidget(self.treeView) self.horizontalLayout = QHBoxLayout() self.removeFolderButton = QPushButton(self.centralwidget) self.removeFolderButton.setIcon(QIcon(QPixmap(":/minus"))) self.removeFolderButton.setShortcut("Del") self.horizontalLayout.addWidget(self.removeFolderButton) self.addFolderButton = QPushButton(self.centralwidget) self.addFolderButton.setIcon(QIcon(QPixmap(":/plus"))) self.horizontalLayout.addWidget(self.addFolderButton) spacerItem1 = QSpacerItem(40, 20, QSizePolicy.Expanding, QSizePolicy.Minimum) self.horizontalLayout.addItem(spacerItem1) self.loadResultsButton = QPushButton(self.centralwidget) self.loadResultsButton.setText(tr("Load Results")) self.horizontalLayout.addWidget(self.loadResultsButton) self.scanButton = QPushButton(self.centralwidget) self.scanButton.setText(tr("Scan")) self.scanButton.setDefault(True) self.horizontalLayout.addWidget(self.scanButton) self.verticalLayout.addLayout(self.horizontalLayout) self.setCentralWidget(self.centralwidget) self._setupActions() self._setupMenu() if self.app.prefs.directoriesWindowRect is not None: self.setGeometry(self.app.prefs.directoriesWindowRect) else: moveToScreenCenter(self) def _setupColumns(self): header = self.treeView.header() header.setStretchLastSection(False) header.setResizeMode(0, QHeaderView.Stretch) header.setResizeMode(1, QHeaderView.Fixed) header.resizeSection(1, 100) def _updateAddButton(self): if self.recentFolders.isEmpty(): self.addFolderButton.setMenu(None) else: self.addFolderButton.setMenu(self.menuRecentFolders) def _updateRemoveButton(self): indexes = self.treeView.selectedIndexes() if not indexes: self.removeFolderButton.setEnabled(False) return self.removeFolderButton.setEnabled(True) def _updateLoadResultsButton(self): if self.app.recentResults.isEmpty(): self.loadResultsButton.setMenu(None) else: self.loadResultsButton.setMenu(self.menuRecentResults) #--- QWidget overrides def closeEvent(self, event): event.accept() if self.app.model.results.is_modified: title = tr("Unsaved results") msg = tr("You have unsaved results, do you really want to quit?") if not self.app.confirm(title, msg): event.ignore() if event.isAccepted(): QApplication.quit() #--- Events def addFolderTriggered(self): title = tr("Select a folder to add to the scanning list") flags = QFileDialog.ShowDirsOnly dirpath = str( QFileDialog.getExistingDirectory(self, title, self.lastAddedFolder, flags)) if not dirpath: return self.lastAddedFolder = dirpath self.app.model.add_directory(dirpath) self.recentFolders.insertItem(dirpath) def appWillSavePrefs(self): self.app.prefs.directoriesWindowRect = self.geometry() def directoriesModelAddedFolders(self, folders): for folder in folders: self.recentFolders.insertItem(folder) def loadResultsTriggered(self): title = tr("Select a results file to load") files = ';;'.join( [tr("dupeGuru Results (*.dupeguru)"), tr("All Files (*.*)")]) destination = QFileDialog.getOpenFileName(self, title, '', files) if destination: self.app.model.load_from(destination) self.app.recentResults.insertItem(destination) def removeFolderButtonClicked(self): self.directoriesModel.model.remove_selected() def scanButtonClicked(self): if self.app.model.results.is_modified: title = tr("Start a new scan") msg = tr( "You have unsaved results, do you really want to continue?") if not self.app.confirm(title, msg): return self.app.model.start_scanning() def selectionChanged(self, selected, deselected): self._updateRemoveButton()
def __init__(self, iface, objectTypeManager, pluginManager, exportSettings=None, lastTreeItemData=None): QDialog.__init__(self, iface.mainWindow()) self.iface = iface self.objectTypeManager = objectTypeManager self.pluginManager = pluginManager self._settings = exportSettings or {} self.lastTreeItemData = lastTreeItemData self.localBrowsingMode = True self.rb_quads = self.rb_point = None self.templateType = None self.currentItem = None self.currentPage = None # Set up the user interface from Designer. self.ui = ui = Ui_Qgis2threejsDialog() ui.setupUi(self) self.setWindowFlags(self.windowFlags() | Qt.WindowMinimizeButtonHint) # output html filename ui.lineEdit_OutputFilename.setText( self._settings.get("OutputFilename", "")) ui.lineEdit_OutputFilename.setPlaceholderText("[Temporary file]") # settings button icon = QIcon(os.path.join(tools.pluginDir(), "icons", "settings.png")) ui.toolButton_Settings.setIcon(icon) # popup menu displayed when settings button is pressed items = [["Load Settings...", self.loadSettings], ["Save Settings As...", self.saveSettings], [None, None], ["Clear Settings", self.clearSettings], [None, None], ["Plugin Settings...", self.pluginSettings]] self.menu = QMenu() self.menu_actions = [] for text, slot in items: if text: action = QAction(text, iface.mainWindow()) action.triggered.connect(slot) self.menu.addAction(action) self.menu_actions.append(action) else: self.menu.addSeparator() ui.toolButton_Settings.setMenu(self.menu) ui.toolButton_Settings.setPopupMode(QToolButton.InstantPopup) # progress bar and message label ui.progressBar.setVisible(False) ui.label_MessageIcon.setVisible(False) # buttons ui.pushButton_Run.clicked.connect(self.run) ui.pushButton_Close.clicked.connect(self.reject) ui.pushButton_Help.clicked.connect(self.help) # set up map tool self.previousMapTool = None self.mapTool = RectangleMapTool(iface.mapCanvas()) #self.mapTool = PointMapTool(iface.mapCanvas()) # set up the template combo box self.initTemplateList() self.ui.comboBox_Template.currentIndexChanged.connect( self.currentTemplateChanged) # set up the properties pages self.pages = {} self.pages[ppages.PAGE_WORLD] = ppages.WorldPropertyPage(self) self.pages[ppages.PAGE_CONTROLS] = ppages.ControlsPropertyPage(self) self.pages[ppages.PAGE_DEM] = ppages.DEMPropertyPage(self) self.pages[ppages.PAGE_VECTOR] = ppages.VectorPropertyPage(self) container = ui.propertyPagesContainer for page in self.pages.itervalues(): page.hide() container.addWidget(page) # build object tree self.topItemPages = { ObjectTreeItem.ITEM_WORLD: ppages.PAGE_WORLD, ObjectTreeItem.ITEM_CONTROLS: ppages.PAGE_CONTROLS, ObjectTreeItem.ITEM_DEM: ppages.PAGE_DEM } self.initObjectTree() self.ui.treeWidget.currentItemChanged.connect( self.currentObjectChanged) self.ui.treeWidget.itemChanged.connect(self.objectItemChanged) self.currentTemplateChanged() # update item visibility ui.toolButton_Browse.clicked.connect(self.browseClicked)
class myMainWindow(QMainWindow, Ui_MainWindow): askusersig = pyqtSignal(str, str, str, str, str, str) #connected to askUserOUT refreshmodelsig = pyqtSignal(str) update_bytestatssig = pyqtSignal(str) refreshconnectionssig = pyqtSignal() refreshrulessig = pyqtSignal() prevstats = '' model = None sourcemodel = None menu = None #index = None out_rules_num = 0 def __init__(self): QMainWindow.__init__(self) self.setupUi(self) #title2 = '我的个人防火墙' #print title2 #title = QString(u'我的个人防火墙') self.setWindowTitle(u'我的个人防火墙') #self.setWindowTitle(title) #self.setWindowIcon(QIcon(":/pics/pic.jpg")) self.tableView.setShowGrid(False) self.actionDisplay.triggered.connect(self.displayconnections) self.actionList_Rules.triggered.connect(self.listrules) self.actionAdd_Rules.triggered.connect(self.addrules) self.actionDisconnect.triggered.connect(self.disconnection) self.actionReconnect.triggered.connect(self.reconnection) self.actionMessage.triggered.connect(self.message) #self.menuRules.aboutToShow.connect(self.rulesMenuTriggered) #self.menuRules.actions()[0].triggered.connect(self.deleteMenuTriggered) #self.actionShow_active_only.triggered.connect(self.showActiveOnly) #self.actionShow_all.triggered.connect(self.showAll) self.actionExit.triggered.connect(self.realQuit) self.askusersig.connect(self.askUser) self.update_bytestatssig.connect(self.update_bytestats) self.refreshmodelsig.connect(self.refreshmodel) self.refreshconnectionssig.connect(self.refreshconnections) self.refreshrulessig.connect(self.refreshrules) #msgQueue.put('LIST') def message(self): dialog = msgdialog dialog.show() def disconnection(self): sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) sock.connect( ('127.0.0.1', 9999) ) sock.send("--disconnect") data = sock.recv(1024) print data sock.close() def reconnection(self): sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) sock.connect( ('127.0.0.1', 9999) ) sock.send("--reconnect") data = sock.recv(1024) print data sock.close() def addrules(self): dialog = addruledialog dialog.show() def contextMenuEvent(self, event): current_layout_lock.acquire() if(self.sourcemodel.current_layout == "conn"): current_layout_lock.release() return current_layout_lock.release() #self.index = self.sourcemodel.indexAt(event.pos()) self.menu = QMenu(self) delete_ruleAction = QAction(u"删除", self) delete_ruleAction.triggered.connect(self.deleterule) self.menu.addAction(delete_ruleAction) self.menu.popup(QtGui.QCursor.pos()) def deleterule(self): #index = self.tableView.selectedIndexes() #print(index[0].row()) row_num = (self.tableView.selectedIndexes())[0].row() if(row_num < self.out_rules_num): #print ("-d OUT " + str(row_num + 1)) cmd_del = "-d OUT " + str(row_num + 1) else: #print ("-d IN " + str(row_num - self.out_rules_num + 1)) cmd_del = "-d IN " + str(row_num - self.out_rules_num + 1) sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) sock.connect(('127.0.0.1', 9999)) sock.send(cmd_del) result = sock.recv(1024) print(result) sock.close() self.refreshrules() def listrules(self): self.sourcemodel.layout_change_to_rule_sig.emit() self.refreshrules() def refreshrules(self): #self.sourcemodel.layout_change_to_rule_sig.emit() current_layout_lock.acquire() if(self.sourcemodel.current_layout != "rule"): print ("refreshrules error") current_layout_lock.release() return self.sourcemodel.layoutAboutToBeChanged.emit() self.sourcemodel.removeRows(0, self.sourcemodel.rowCount()) sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) sock.connect(('127.0.0.1', 9999)) sock.send("--list") ruleslist = '' while(True): data = sock.recv(1024) if not data: break ruleslist = ruleslist + data sock.close() #print (ruleslist) if ruleslist: self.out_rules_num = 0 for ruleline in ruleslist[0:-1].split('\n'): #print ( 'line: ' + line) items = ruleline.split() print (items) if(items[0] == 'direction:OUT'): self.out_rules_num += 1 direction = QStandardItem((items[0].split(':'))[1]) lport = QStandardItem((items[1].split(':'))[1]) raddr = QStandardItem((items[3].split(':'))[1]) rport = QStandardItem((items[5].split(':'))[1]) proto = QStandardItem((items[6].split(':'))[1]) target = QStandardItem((items[7].split(':'))[1]) #print (direction + ':' + lport + ':' + raddr + ':' + rport + ':' + proto + ':' + target) self.sourcemodel.appendRow( (direction, lport, raddr, rport, proto, target) ) self.sourcemodel.layoutChanged.emit() current_layout_lock.release() def displayconnections(self): ''' if(self.sourcemodel.current_layout == "conn"): self.refreshconnectionssig.emit() else: self.sourcemode.layout_change_to_conn_sig.emit() self.refreshconnections() ''' self.sourcemodel.layout_change_to_conn_sig.emit() self.refreshconnections() def refreshconnections(self): current_layout_lock.acquire() if(self.sourcemodel.current_layout != "conn"): print ("refreshconnections error") current_layout_lock.release() return self.sourcemodel.layoutAboutToBeChanged.emit() self.sourcemodel.removeRows(0, self.sourcemodel.rowCount()) for conn in psutil.net_connections("inet4"): if(conn.type == socket.SOCK_STREAM): proto = QStandardItem("tcp") else: proto = QStandardItem("udp") laddr = QStandardItem(conn.laddr[0]) lport = QStandardItem(str(conn.laddr[1])) if(len(conn.raddr) == 0): continue raddr = QStandardItem(conn.raddr[0]) rport = QStandardItem(str(conn.raddr[1])) status = QStandardItem(conn.status) pid = QStandardItem(str(conn.pid)) if(conn.pid != None): p = psutil.Process(conn.pid) name = QStandardItem(p.name()) else: name = QStandardItem("None") family = QStandardItem("ipv4") self.sourcemodel.appendRow( (family, proto, laddr, lport, raddr, rport, status, pid, name)) self.sourcemodel.layoutChanged.emit() current_layout_lock.release() def showActiveOnly(self): self.model.toggle_mode_sig.emit('SHOW ACTIVE ONLY') self.actionShow_active_only.setEnabled(False) self.actionShow_all.setEnabled(True) self.actionShow_all.setChecked(False) def showAll(self): self.model.toggle_mode_sig.emit('SHOW ALL') self.actionShow_active_only.setEnabled(True) self.actionShow_all.setEnabled(False) self.actionShow_active_only.setChecked(False) @pyqtSlot(str, str, str, str, str, str) def askUser(self, req_str_in, path_in, pid_in, addr_in, dport_in, sport_in): #print "In askUser" #Convert all incoming QString into normal python strings req_str = str(req_str_in) path = unicode(QString.fromUtf8(path_in)) pid = str(pid_in) addr = str(addr_in) dport = str(dport_in) sport = str(sport_in) if (req_str == 'REQUEST_OUT'): dialog = dialogOut rport = sport lport = dport elif (req_str == 'REQUEST_IN'): dialog = dialogOut rport = dport lport = sport name = string.rsplit(path,"/",1) dialog.path = path dialog.pid = pid dialog.label_name.setText(name[1]) dialog.label_ip.setText(addr) dialog.label_domain.setText("Looking up DNS...") fullpath = QTableWidgetItem(unicode(QString.fromUtf8(path))) dialog.tableWidget_details.setItem(0,1,fullpath) pid_item = QTableWidgetItem(pid) dialog.tableWidget_details.setItem(1,1,pid_item) remoteip = QTableWidgetItem(addr) dialog.tableWidget_details.setItem(2,1,remoteip) dns = QTableWidgetItem("Looking up DNS...") dialog.tableWidget_details.setItem(3,1,dns) rport_item = QTableWidgetItem(rport) dialog.tableWidget_details.setItem(4,1,rport_item) lport_item = QTableWidgetItem(lport) dialog.tableWidget_details.setItem(5,1,lport_item) QHostInfo.lookupHost(addr, dialog.dnsLookupFinished) #we don't want the user to accidentally trigger ALLOW dialog.pushButton_deny.setFocus() dialog.show() def rulesMenuTriggered(self): "If no rules are selected in the view, grey out the Delete... item" if (len(self.tableView.selectedIndexes()) == 0): self.menuRules.actions()[0].setEnabled(False) else: self.menuRules.actions()[0].setEnabled(True) def deleteMenuTriggered(self): "send delete request to backend" selected_indexes = self.tableView.selectedIndexes() bFound = False for index in selected_indexes: if index.column() != 3: continue path = unicode(index.data().toPyObject()) bFound = True break if not bFound: #print 'Could not find the path to delete' return msgQueue.put('DELETE ' + b64encode(bytearray(path, encoding='utf-8'))) def closeEvent(self, event): event.ignore() self.hide() def realQuit(self): #print "see you later..." #msgQueue.put('UNREGISTER') time.sleep(1) #allow queue to be processed exit(1) @pyqtSlot(unicode) def refreshmodel(self, data_in): "Fill the frontend with rules data" rawstr = unicode(QString.fromUtf8(data_in)) export_list = [] rules = rawstr[len('RULES_LIST'):].split('CRLF') for one_rule in rules: split_rule = one_rule.split() if len(split_rule) != 5: continue export_list.append(split_rule) export_list.append("EOF") ruleslist = export_list #empty the model, we're filling it anew, we can't use clear() cause it flushes headers too: modellock.acquire() self.sourcemodel.layoutAboutToBeChanged.emit() self.sourcemodel.removeRows(0, self.sourcemodel.rowCount()) #if there's only one element, it's EOF; dont go through iterations,just leave the model empty if (len(ruleslist) == 1): self.sourcemodel.layoutChanged.emit() modellock.release() return for item in ruleslist[0:-1]:#leave out the last EOF from iteration path_u = b64decode(item[0]).decode('utf-8') fullpath = QStandardItem(path_u) #item[4] contains nfmark fullpath.setData(item[4]) if (item[1] == "0"): pid_string = "N/A" else: pid_string = item[1] pid = QStandardItem(pid_string) perms = QStandardItem(item[2]) #only the name of the executable after the last / m_list = string.rsplit(path_u,"/",1) m_name = m_list[1] name = QStandardItem(m_name) in_allow_traf = QStandardItem() out_allow_traf = QStandardItem() in_deny_traf = QStandardItem() out_deny_traf = QStandardItem() self.sourcemodel.appendRow( (name, pid, perms, fullpath, in_allow_traf, out_allow_traf, in_deny_traf, out_deny_traf) ) #print "Received: %s" %(item[0]) self.sourcemodel.layoutChanged.emit() modellock.release() self.update_bytestats() #Update and remember the stats. The stats may be restored from #a previous save when model refreshes @pyqtSlot(str) def update_bytestats(self, data_in = ''): data = str(data_in) items = [] if (data): message = data.split('EOL')[-2] #discard the last empty one and take the one before it #take the last message with 5 elements as it is the most recent one items = message.split('CRLF')[:-1] #discard the last empty one if (items): self.prevstats = items else: items = self.prevstats #one item looks like '1212 3232 3243 4343 43434' modellock.acquire() self.sourcemodel.layoutAboutToBeChanged.emit() for one_item in items: fields = one_item.split() for j in range(self.sourcemodel.rowCount()): #4th element of each line has nfmark in its data field if (self.sourcemodel.item(j,3).data().toString() != fields[0]): continue #else self.sourcemodel.item(j,4).setText(fields[1]) self.sourcemodel.item(j,5).setText(fields[2]) self.sourcemodel.item(j,6).setText(fields[3]) self.sourcemodel.item(j,7).setText(fields[4]) break self.sourcemodel.layoutChanged.emit() modellock.release()
def initializeOperationActions(self): actionGroup = QtGui.QActionGroup(self) self.showAllAction = KToggleAction(KIcon("applications-other"), i18n("All Packages"), self) self.actionCollection().addAction("showAllAction", self.showAllAction) self.connect(self.showAllAction, SIGNAL("triggered()"), lambda: self.cw.switchState(StateManager.ALL)) self.cw.stateTab.addTab(QWidget(), KIcon("applications-other"), i18n("All Packages")) actionGroup.addAction(self.showAllAction) self.showInstallAction = KToggleAction(KIcon("list-add"), i18n("Installable Packages"), self) self.actionCollection().addAction("showInstallAction", self.showInstallAction) self.connect(self.showInstallAction, SIGNAL("triggered()"), lambda: self.cw.switchState(StateManager.INSTALL)) self.cw.stateTab.addTab(QWidget(), KIcon("list-add"), i18n("Installable Packages")) actionGroup.addAction(self.showInstallAction) self.showRemoveAction = KToggleAction(KIcon("list-remove"), i18n("Installed Packages"), self) self.actionCollection().addAction("showRemoveAction", self.showRemoveAction) self.connect(self.showRemoveAction, SIGNAL("triggered()"), lambda: self.cw.switchState(StateManager.REMOVE)) self.cw.stateTab.addTab(QWidget(), KIcon("list-remove"), i18n("Installed Packages")) actionGroup.addAction(self.showRemoveAction) self.showUpgradeAction = KToggleAction(KIcon("system-software-update"), i18n("Updates"), self) self.actionCollection().addAction("showUpgradeAction", self.showUpgradeAction) self.connect(self.showUpgradeAction, SIGNAL("triggered()"), lambda: self.cw.switchState(StateManager.UPGRADE)) self.cw.stateTab.addTab(QWidget(), KIcon("system-software-update"), i18n("Updates")) actionGroup.addAction(self.showUpgradeAction) # self.showHistoryAction = KToggleAction(KIcon("view-refresh"), i18n("History"), self) # self.actionCollection().addAction("showHistoryAction", self.showHistoryAction) # self.connect(self.showHistoryAction, SIGNAL("triggered()"), lambda:self.cw.switchState(StateManager.HISTORY)) # self.cw.stateTab.addTab(QWidget(), KIcon("view-refresh"), i18n("History")) # actionGroup.addAction(self.showHistoryAction) self.cw.menuButton.setMenu(QMenu('MainMenu', self.cw.menuButton)) self.cw.menuButton.setIcon(KIcon('preferences-other')) self.cw.menuButton.menu().clear() self.cw.contentHistory.hide() # self.cw.menuButton.menu().addAction(self.showAllAction) # self.cw.menuButton.menu().addAction(self.showInstallAction) # self.cw.menuButton.menu().addAction(self.showRemoveAction) # self.cw.menuButton.menu().addAction(self.showUpgradeAction) # self.cw.menuButton.menu().addSeparator() self.cw.menuButton.menu().addAction(self.actionCollection().action( KStandardAction.name(KStandardAction.Preferences))) self.cw.menuButton.menu().addAction(self.actionCollection().action( KStandardAction.name(KStandardAction.Help))) self.cw.menuButton.menu().addSeparator() self.cw.menuButton.menu().addAction(self.actionCollection().action( KStandardAction.name(KStandardAction.AboutApp))) self.cw.menuButton.menu().addAction(self.actionCollection().action( KStandardAction.name(KStandardAction.AboutKDE))) self.cw.menuButton.menu().addSeparator() self.cw.menuButton.menu().addAction(self.actionCollection().action( KStandardAction.name(KStandardAction.Quit))) self.cw._states = { self.cw.state.ALL: (0, self.showAllAction), self.cw.state.INSTALL: (1, self.showInstallAction), self.cw.state.REMOVE: (2, self.showRemoveAction), self.cw.state.UPGRADE: (3, self.showUpgradeAction) } # self.cw.state.HISTORY:(4, self.showHistoryAction)} self.showAllAction.setChecked(True) self.cw.checkUpdatesButton.hide() self.cw.checkUpdatesButton.setIcon(KIcon('view-refresh')) self.cw.showBasketButton.clicked.connect(self.cw.showBasket) # Little time left for the new ui self.menuBar().setVisible(False) self.cw.switchState(self.cw.state.ALL)
class AdaptersTableView(QTableView): """ Adapters table view """ DataChanged = pyqtSignal() def __init__(self, parent, helper, testParams, testDescrs): """ Description table view constructor """ QTableView.__init__(self, parent) self.__parent = parent self.helper = helper self.testParams = testParams self.testDescrs = testDescrs self.createWidgets() self.createConnections() self.createActions() def getAgents(self): """ Get test agents """ return self.testParams.agents.table().model.getData() def getInputs(self): """ Get test inputs """ return self.testParams.parameters.table().model.getData() def getOutputs(self): """ Get test outputs """ return self.testParams.parametersOutput.table().model.getData() def createWidgets (self): """ Create qt widgets """ self.proxyModel = QSortFilterProxyModel(self) self.proxyModel.setDynamicSortFilter(True) self.model = DescriptionTableModel(self) self.setModel(self.proxyModel) self.proxyModel.setSourceModel(self.model) self.setFrameShape(QFrame.StyledPanel) self.setShowGrid(True) self.setGridStyle (Qt.DotLine) self.setSelectionMode(QAbstractItemView.SingleSelection) self.setSelectionBehavior(QAbstractItemView.SelectRows) self.setContextMenuPolicy(Qt.CustomContextMenu) self.verticalHeader().setVisible(False) self.horizontalHeader().setHighlightSections(False) self.setHorizontalScrollMode(QAbstractItemView.ScrollPerPixel) self.horizontalHeader().setStretchLastSection(True) self.setItemDelegateForColumn( COL_SUMMARY_ACTION, AdapterDelegate(self) ) self.setColumnWidth(COL_ID_ACTION, 45) def createConnections (self): """ Create qt connections """ self.customContextMenuRequested.connect(self.onPopupMenu) self.clicked.connect( self.onAbstractItemClicked) def createActions (self): """ Qt actions """ self.delAction = QtHelper.createAction(self, self.tr("&Delete"), self.deleteAction, icon = QIcon(":/adapters-del.png"), tip = self.tr('Delete the selected adapter')) self.delAllAction = QtHelper.createAction(self, self.tr("&Delete All"), self.clearItems, icon = QIcon(":/test-parameter-clear.png"), tip = self.tr('Delete all adapters')) # set default actions self.delAction.setEnabled(False) self.delAllAction.setEnabled(False) def onAbstractItemClicked(self): """ Called on item clicked """ indexes = self.selectedIndexes() if not indexes: self.delAction.setEnabled(False) else: self.delAction.setEnabled(True) def deleteAction(self): """ Delete action """ indexes = self.selectedIndexes() if not indexes: return # map proxy indexes to source sourceIndexes = [] for proxyIndex in indexes: if not proxyIndex.isValid(): return else: sourceIndexes.append( self.proxyModel.mapToSource( proxyIndex ) ) if sourceIndexes: answer = QMessageBox.question(self, self.tr("Remove"), self.tr("Do you want to remove the selection?"), QMessageBox.Yes | QMessageBox.No) if answer == QMessageBox.Yes: self.removeValues(sourceIndexes) def removeValues(self, indexes): """ Remove values from data @param indexes: @type indexes: """ if not indexes: return # data from model datas = self.model.getData() # remove duplicate index cleanIndexes = {} for index in indexes: if index.row() not in cleanIndexes: cleanIndexes[index.row()] = index for cleanIndex in list(cleanIndexes.keys()): # for python3 support datas.pop(cleanIndex) self.model.beginResetModel() self.model.endResetModel() self.setData( signal = True ) def getHelpAdapters(self, generic=False): """ Return the help of all adapters according to the current version of the test """ if generic: return Helper.instance().helpAdapters(generic=generic) else: testDescrs = self.testDescrs.table().model.getData() currentAdpVersion = None for descr in testDescrs: if descr['key'] == 'adapters': currentAdpVersion = descr['value'] break return Helper.instance().helpAdapters(name=currentAdpVersion) def onPopupMenu(self, pos): """ Display menu on right click @param pos: @type pos: """ self.menu = QMenu(self) # index = self.currentIndex() # get defaults adapters or extra adapters_default = self.getHelpAdapters() # get generic adapters adapters_generic = self.getHelpAdapters(generic=True) # main menu menu_adps = QMenu("Add Adapters", self) # adapters default menu_adps_generic = QMenu("Generic", self) menu_adps.addMenu(menu_adps_generic) if adapters_generic is not None: for adp in adapters_generic: adp_menu_generic = QMenu(adp['name'], self) menu_adps_generic.addMenu(adp_menu_generic) for cls in adp['classes']: # extract __init__ function only fct = None for fct in cls['functions']: if fct['name'] == '__init__': break if fct is not None: argsFct = self.parseDocString(docstring=fct['desc']) argsFct['function'] = "%s::%s" % (adp['name'],cls['name']) argsFct['main-name'] = "%s" % adp['name'] argsFct['sub-name'] = "%s" % cls['name'] argsFct['is-default'] = "False" argsFct['is-generic'] = "True" if 'default-args' in fct: self.addDefaultValues(defaultValues=fct['default-args'], currentFunction=argsFct) adp_menu_generic.addAction(QtHelper.createAction(self, cls['name'], self.addAdapter, cb_arg=argsFct )) # adapters default menu_adps_default = QMenu("Extra", self) menu_adps.addMenu(menu_adps_default) if adapters_default is not None: for adp in adapters_default: adp_menu_default = QMenu(adp['name'], self) menu_adps_default.addMenu(adp_menu_default) for cls in adp['classes']: # extract __init__ function only fct = None for fct in cls['functions']: if fct['name'] == '__init__': break if fct is not None: argsFct = self.parseDocString(docstring=fct['desc']) argsFct['function'] = "%s::%s" % (adp['name'],cls['name']) argsFct['main-name'] = "%s" % adp['name'] argsFct['sub-name'] = "%s" % cls['name'] argsFct['is-default'] = "True" argsFct['is-generic'] = "False" if 'default-args' in fct: self.addDefaultValues(defaultValues=fct['default-args'], currentFunction=argsFct) adp_menu_default.addAction(QtHelper.createAction(self, cls['name'], self.addAdapter, cb_arg=argsFct )) indexes = self.selectedIndexes() if not indexes: self.delAction.setEnabled(False) self.menu.addAction( self.delAction ) self.menu.addSeparator() self.menu.addMenu( menu_adps ) self.menu.addSeparator() else: self.delAction.setEnabled(True) self.menu.addAction( self.delAction ) self.menu.addSeparator() self.menu.addMenu( menu_adps ) self.menu.addSeparator() self.menu.popup( self.mapToGlobal(pos) ) def addDefaultValues(self, defaultValues, currentFunction): """ Add default values """ for curArg in currentFunction['obj']: for k,v in defaultValues: # ignore bad documentation if "name" not in curArg: continue if k == curArg['name']: curArg['advanced'] = "True" if curArg['type'] in ['strconstant', 'intconstant']: curArg['default-value'] = self.parseConstant(descr=curArg['descr']) else: curArg['default-value'] = unicode(v) def parseDocString(self, docstring): """ Parse doc string """ val = {} desc = docstring.strip() desc_splitted = desc.splitlines() val['return-value'] = "False" params = [] param = { } for line in desc_splitted: line = line.strip() if line.startswith('@param '): paramName = line.split(':', 1)[0].split('@param ')[1].strip() paramDescr = line.split(':', 1)[1].strip() param['name'] = paramName param['value'] = '' param['descr'] = paramDescr param['selected-type'] = '' param['advanced'] = "False" elif line.startswith('@type '): paramType = line.split(':', 1)[1].strip() param['type'] = paramType params.append( param ) param = {} elif line.startswith('@return'): val['return-value'] = "True" val['return-descr'] = line.split(':', 1)[1].strip() else: pass val['obj'] = params return val def parseConstant(self, descr): """ Parse constant """ tmpvals = descr.split("|") nameConstant = '' for zz in xrange(len(tmpvals)): if '(default)' in tmpvals[zz]: nameConstant = tmpvals[zz].split('(default)')[0].strip() return nameConstant def addAdapter(self, fctParams): """ Add testcase function """ actionId = self.getActionId() tpl = { 'action': ACTION_ADAPTER, 'data': fctParams } self.insertItem(actionParams=tpl) def getActionId(self): """ Return action Id """ data = self.model.getData() actionId = len(data) + 1 return actionId def insertItem(self, actionParams): """ Insert item """ indexes = self.selectedIndexes() if not len(indexes): row = self.model.rowCount() else: index = self.currentIndex() row = index.row() data = self.model.getData() # add data to model data.insert(row + 1, actionParams) # self.model.reset() self.model.beginResetModel() self.model.endResetModel() # open properties on adding, workaround to fix an error (bad agent type) actionDialog = GenericConfigDialog.ActionDialog(self, self.helper, actionParams, owner=self, variables=[], adapterMode=True,testParams=self.testParams, noCancel=True) actionDialog.exec_() newActionParams = actionDialog.getValues() data[row]['data']['obj'] = newActionParams self.delAllAction.setEnabled(True) self.setData() def setAdapters(self, adapters): """ Set adapters """ self.model.setDataModel( adapters ) self.setData( signal = False ) def clearItems(self): """ Clear all items """ reply = QMessageBox.question(self, self.tr("Clear all adapters"), self.tr("Are you sure ?"), QMessageBox.Yes | QMessageBox.No ) if reply == QMessageBox.Yes: data = self.model.getData() try: for i in xrange(len(data)): data.pop() except Exception as e: pass # self.model.reset() self.model.beginResetModel() self.model.endResetModel() self.setData() self.delAllAction.setEnabled(False) self.delAction.setEnabled(False) def clear (self): """ clear contents """ self.model.setDataModel( [] ) def setData(self, signal = True): """ Set table data @param signal: @type signal: boolean """ if signal: self.DataChanged.emit()
def _setupMenu(self): self.menubar = QMenuBar(self) self.menubar.setGeometry(QRect(0, 0, 42, 22)) self.menuFile = QMenu(self.menubar) self.menuFile.setTitle(tr("File")) self.menuView = QMenu(self.menubar) self.menuView.setTitle(tr("View")) self.menuHelp = QMenu(self.menubar) self.menuHelp.setTitle(tr("Help")) self.menuLoadRecent = QMenu(self.menuFile) self.menuLoadRecent.setTitle(tr("Load Recent Results")) self.setMenuBar(self.menubar) self.menuFile.addAction(self.actionLoadResults) self.menuFile.addAction(self.menuLoadRecent.menuAction()) self.menuFile.addSeparator() self.menuFile.addAction(self.app.actionQuit) self.menuView.addAction(self.app.actionPreferences) self.menuView.addAction(self.actionShowResultsWindow) self.menuView.addAction(self.app.actionIgnoreList) self.menuHelp.addAction(self.app.actionShowHelp) self.menuHelp.addAction(self.app.actionRegister) self.menuHelp.addAction(self.app.actionCheckForUpdate) self.menuHelp.addAction(self.app.actionOpenDebugLog) self.menuHelp.addAction(self.app.actionAbout) self.menubar.addAction(self.menuFile.menuAction()) self.menubar.addAction(self.menuView.menuAction()) self.menubar.addAction(self.menuHelp.menuAction()) # Recent folders menu self.menuRecentFolders = QMenu() self.menuRecentFolders.addAction(self.actionAddFolder) self.menuRecentFolders.addSeparator() # Recent results menu self.menuRecentResults = QMenu() self.menuRecentResults.addAction(self.actionLoadResults) self.menuRecentResults.addSeparator()
#don't clutter console with debuginfo if (len(sys.argv) <= 1 or sys.argv[1] != "debug"): #I don't know how to redirect output to /dev/null so just make a tmp file until I figure out #logfile = open("/dev/null", "w") #sys.stdout = logfile pass elif (sys.argv[1] != "debug"): import wingdbstub ''' app=QApplication(sys.argv) app.setQuitOnLastWindowClosed(False) window = myMainWindow() #tray = QSystemTrayIcon(QIcon(":/pics/pic24.png")) menu = QMenu() actionShow = QAction("PF",menu) actionExit = QAction("Exit",menu) menu.addAction(actionShow) menu.addAction(actionExit) #tray.setContextMenu(menu) #tray.show() actionShow.triggered.connect(window.show) actionExit.triggered.connect(window.realQuit) sourcemodel = myModel() model = mySortFilterProxyModel() model.setSourceModel(sourcemodel) model.setDynamicSortFilter(True) window.tableView.setSortingEnabled(True)
def ctx_menu_init(self): self.pop_menu = QMenu() self.pop_menu.addAction(self.ui.action_clear_console)
def __init__(self, parent=None): """ initialize the widget """ QDialog.__init__(self, parent) Ui_FileDialog.__init__(self) self.setupUi(self) #flags = 0 #flags = Qt.Window | Qt.WindowMinimizeButtonHint; #self.setWindowFlags( flags ) self.hideTckFilter() self.__controler = ControlerFileDialog(self, parent.getControler()) self.connect(self.closeButton, SIGNAL("clicked()"), self.__controler.close) self.connect(self.saveButton, SIGNAL("clicked()"), self.__controler.save) self.connect(self.advancedSave, SIGNAL("clicked()"), self.__controler.advancedSave) self.connect(self.nextButton, SIGNAL("clicked()"), self.__controler.next) self.__model = {} self.__path = None self.__fileExtension = None self.__popUp = QMenu(self.tableView) self.__jobAction = QAction(self.tr("Job Info"), self.tableView) self.connect(self.__jobAction, SIGNAL("triggered()"), self.__controler.jobinfo) self.__popUp.addAction(self.__jobAction) self.__ancesstorsAction = QAction(self.tr("Get Anccestors"), self.tableView) self.connect(self.__ancesstorsAction, SIGNAL("triggered()"), self.__controler.getancesstots) self.__popUp.addAction(self.__ancesstorsAction) self.__loginfoAction = QAction(self.tr("Logginig informations"), self.tableView) self.connect(self.__loginfoAction, SIGNAL("triggered()"), self.__controler.loggininginfo) self.__popUp.addAction(self.__loginfoAction) self.__copyAction = QAction(self.tr("Copy data"), self.tableView) self.connect(self.__copyAction, SIGNAL("triggered()"), self.__controler.copy) self.__popUp.addAction(self.__copyAction) self.tableView.setContextMenuPolicy(Qt.CustomContextMenu) self.connect(self.tableView, SIGNAL('customContextMenuRequested(QPoint)'), self.popUpMenu) self.__advancedSave = AdvancedSave(self) self.__advancedSave.setFocus() self.__controler.addChild('AdvancedSave', self.__advancedSave.getControler()) self.__historyDialog = HistoryDialog(self) self.__controler.addChild('HistoryDialog', self.__historyDialog.getControler()) self.connect(self.tckcombo, SIGNAL('currentIndexChanged(QString)'), self.getControler().tckChanged) self.__proxy = QSortFilterProxyModel() self.connect(self.tckButton, SIGNAL("clicked()"), self.__controler.tckButtonPressed) self.connect(self.tckcloseButton, SIGNAL("clicked()"), self.__controler.hideFilterWidget) self.filterWidget.setupControler(self) self.__controler.addChild('TckFilterWidget', self.filterWidget.getControler())