def createMenus(self): self.saveAsMenu = QtGui.QMenu("&Save As", self) for action in self.saveAsActs: self.saveAsMenu.addAction(action) fileMenu = QtGui.QMenu("&File", self) #fileMenu.addAction(self.openAct) #fileMenu.addMenu(self.saveAsMenu) #fileMenu.addAction(self.printAct) fileMenu.addAction(self.saveOverAct) fileMenu.addSeparator() fileMenu.addAction(self.exitAct) optionMenu = QtGui.QMenu("&Options", self) optionMenu.addAction(self.penColorAct) optionMenu.addAction(self.penWidthAct) # optionMenu.addSeparator() #optionMenu.addAction(self.clearScreenAct) helpMenu = QtGui.QMenu("&Help", self) helpMenu.addAction(self.aboutAct) #helpMenu.addAction(self.aboutQtAct) self.menuBar().addMenu(fileMenu) self.menuBar().addMenu(optionMenu) self.menuBar().addMenu(helpMenu)
def __init__(self, parent=None): """ Construction :param parent: The parent widget """ QtGui.QWidget.__init__(self, parent) self._thumbnail = True self._sg_fields = [] # compute hilight colors p = QtGui.QPalette() highlight_col = p.color(QtGui.QPalette.Active, QtGui.QPalette.Highlight) self._highlight_str = "rgb(%s, %s, %s)" % ( highlight_col.red(), highlight_col.green(), highlight_col.blue(), ) self._transp_highlight_str = "rgba(%s, %s, %s, 25%%)" % ( highlight_col.red(), highlight_col.green(), highlight_col.blue(), ) self._menu = QtGui.QMenu() self._actions = []
def _show_filters(self, UI_filters_action): """ Initialized filter menu and selected default action or previous action :param UI_filters_action: previous selected filter """ filters_menu = QtGui.QMenu() filters_group = QtGui.QActionGroup(self) project_filter = QtGui.QAction('Current Project Tasks', filters_menu, checkable=True) project_filter.setData([['project', 'is', '{context.project}']]) filters_group.addAction(project_filter) filters_menu.addAction(project_filter) all_filter = QtGui.QAction('All Tasks', filters_menu, checkable=True) all_filter.setData([]) filters_group.addAction(all_filter) filters_menu.addAction(all_filter) facility_filter = QtGui.QAction('Facility Tasks', filters_menu, checkable=True) facility_filter.setData([['project.Project.name', 'is', 'Facility']]) filters_group.addAction(facility_filter) filters_menu.addAction(facility_filter) if UI_filters_action: for filter_action in filters_menu.findChildren(QtGui.QAction): if filter_action.text() == UI_filters_action.text(): filter_action.setChecked(True) else: project_filter.setChecked(True) self._ui.filter_btn.setMenu(filters_menu) filters_group.triggered.connect(self._on_filter_changed)
def create_sgtk_disabled_menu(menu_name): """ Render a special "shotgun is disabled" menu """ win = Krita.instance().window().qwindow() # Find the shotgun menu menuBar = win.menuBar() sg_menu = None for action in menuBar.actions(): if action.objectName == "shotgun": sg_menu = action.menu() break if sg_menu: # Clear all the actions before adding our item sg_menu.clear() else: # we need to create a new shotgun menu sg_menu = QtGui.QMenu("Shotgun", menuBar) sg_menu.setObjectName("shotgun") menu_action = menuBar.addMenu(sg_menu) menu_action.setObjectName("shotgun") # add the disabled action to our menu disabled_action = QtGui.QAction("Sgtk is disabled.") disabled_action.triggered.connect(sgtk_disabled_message) disabled_action.setObjectName("shotgun_disabled")
def __init__(self, parent): """ Constructor :param parent: QT parent object """ QtGui.QWidget.__init__(self, parent) # make sure this widget isn't shown self.setVisible(False) # set up the UI self.ui = Ui_PublishHistoryWidget() self.ui.setupUi(self) # set up action menu self._menu = QtGui.QMenu() self._actions = [] self.ui.button.setMenu(self._menu) self.ui.button.setVisible(False) # compute hilight colors p = QtGui.QPalette() highlight_col = p.color(QtGui.QPalette.Active, QtGui.QPalette.Highlight) self._highlight_str = "rgb(%s, %s, %s)" % (highlight_col.red(), highlight_col.green(), highlight_col.blue()) self._transp_highlight_str = "rgba(%s, %s, %s, 25%%)" % (highlight_col.red(), highlight_col.green(), highlight_col.blue())
def _on_selected_file_changed(self, file, env): """ """ # get the available actions for this file: file_actions = self._get_available_file_actions(file, env) if not file_actions: # disable both the open and open options buttons: self._ui.open_btn.setEnabled(False) self._ui.open_options_btn.setEnabled(False) self._default_open_action = None return # update the open button: self._ui.open_btn.setEnabled(True) self._ui.open_btn.setText(file_actions[0].label) self._default_open_action = file_actions[0] # if we have more than one action then update the open options button: if len(file_actions) > 1: # enable the button: self._ui.open_options_btn.setEnabled(True) # build the menu and add the actions to it: menu = self._ui.open_options_btn.menu() if not menu: menu = QtGui.QMenu(self._ui.open_options_btn) self._ui.open_options_btn.setMenu(menu) menu.clear() self._populate_open_menu(menu, file_actions[1:]) else: # just disable the button: self._ui.open_options_btn.setEnabled(False)
def create_shotgun_menu(self): """ Creates the main shotgun menu in Krita. Note that this only creates the menu, not the child actions. :return: bool """ window = self._kritaInstance.window().qwindow() menuBar = window.menuBar() # only create the shotgun menu if not in batch mode and menu doesn't already exist if self.has_ui and not self._has_menu(): menu = QtGui.QMenu("Shotgun", window.menuBar()) menu.setObjectName("shotgun") menu_action = menuBar.addMenu(menu) menu_action.setObjectName("shotgun") #tk_krita = self.import_module("tk_krita") #self._menu_generator = tk_maya.MenuGenerator(self, self._menu_handle) ## hook things up so that the menu is created every time it is clicked #self._menu_handle.postMenuCommand(self._menu_generator.create_menu) ## Restore the persisted Shotgun app panels. #tk_maya.panel_generation.restore_panels(self) return True return False
def __init__(self, widget_factory, parent): """ :param widget_factory: Qt Designer-generated widget factory. :param parent: Parent widget """ QtGui.QWidget.__init__(self, parent) # make sure this widget isn't shown self.setVisible(False) # set up the UI self.ui = widget_factory() self.ui.setupUi(self) # set up action menu self._menu = QtGui.QMenu() self._actions = [] self.ui.button.setMenu(self._menu) self.ui.button.setVisible(False) # compute highlight colors highlight_col = self.palette().highlight().color() self._highlight_str = "rgb(%s, %s, %s)" % ( highlight_col.red(), highlight_col.green(), highlight_col.blue(), ) self._transp_highlight_str = "rgba(%s, %s, %s, 25%%)" % ( highlight_col.red(), highlight_col.green(), highlight_col.blue(), )
def _parse_options_x_app(self, groups, favourites, sort_options=True): parsed_options = [] for (app_name, app_display_name), options in groups.items(): first_option = options[0] caption = first_option[0] callback = first_option[1] options_number = len(options) if options_number <= 0: continue if options_number == 1 and (app_name, caption) not in favourites: is_submenu = False data = caption, callback label = caption elif options_number > 1: is_submenu = True label = app_display_name data = QtGui.QMenu() data.setTitle(app_display_name) for caption, callback in options: data.addAction(caption, callback) parsed_options.append((label, is_submenu, data)) if sort_options: parsed_options.sort(key=lambda option: option[0]) return parsed_options
def __init__(self, parent): """ Constructor :param parent: QT parent object """ QtGui.QWidget.__init__(self, parent) # make sure this widget isn't shown self.setVisible(False) # set up the UI self.ui = Ui_ListItemWidget() self.ui.setupUi(self) # the property stylesheet syntax seems brittle and hacky so # keeping the style sheet modifications local here rather # than in global css # todo: figure out a better way to do this! self._css_decorated = """ #box { border-width: 2px; border-radius: 4px; border-color: rgb(48, 167, 227); border-style: solid; } """ self._css_selected = """ #box { border-width: 2px; border-radius: 4px; border-color: rgb(48, 167, 227); border-style: solid; background-color: rgba(48, 167, 227, 25%); } """ self._no_style = """ #box { border-width: 2px; border-radius: 4px; border-color: rgba(0, 0, 0, 0%); border-style: solid; } """ # set up action menu. parent it to the button to prevent cases where it # shows up elsewhere on screen (as in Houdini) self._menu = QtGui.QMenu(self.ui.button) self._actions = [] self.ui.button.setMenu(self._menu) self.ui.button.setVisible(False) # this forces the menu to be right aligned with the button. This is # preferable since many DCCs show the embed panel on the far right. In # houdini at least, before forcing this layout direction, the menu was # showing up partially offscreen. self.ui.button.setLayoutDirection(QtCore.Qt.RightToLeft)
def mousePressEvent (self, event ): if event.button() == QtCore.Qt.LeftButton: if QtGui.QApplication.keyboardModifiers() == QtCore.Qt.ShiftModifier : print "add to selection", self.notification elif QtGui.QApplication.keyboardModifiers() == QtCore.Qt.ControlModifier : print "next" self.myfinished() else : print "select", self.notification if event.button() == QtCore.Qt.RightButton: globalPos = self.mapToGlobal(event.pos()); menu = QtGui.QMenu() ag = QtGui.QActionGroup(menu, exclusive=True) docAction = QtGui.QAction("Show news", menu , triggered=lambda: self.radioButtonClicked(0)) docAction.setCheckable( True ) if self.radioChecked == 0 : docAction.setChecked( True ) a = ag.addAction(docAction) menu.addAction(a) notiAction = QtGui.QAction("Show notification", menu , triggered=lambda: self.radioButtonClicked(1)) notiAction.setCheckable( True ) if self.radioChecked == 1 : notiAction.setChecked( True ) a = ag.addAction(notiAction) menu.addAction(a) muteAction = QtGui.QAction("Mute", menu , triggered = lambda: self.radioButtonClicked(2) ) muteAction.setCheckable( True ) if self.radioChecked == 2 : muteAction.setChecked( True ) a = ag.addAction(muteAction) menu.addAction(a) """ notificationMenu = menu.addAction(QtGui.QIcon(getRessources("notification.png")),"Notify somebody", self.writeNotification ) menu.addAction(notificationMenu) """ #menu.addAction( QtGui.QAction("Remove", menu) ) #menu.addAction( QtGui.QAction("Answer", menu) ) #menu.addAction( QtGui.QAction("Status", menu) ) self.animate.pause() menu.exec_(globalPos) if self.notificationList : print "resume !" self.animate.resume() else : print self.animate.state() self.menu = menu
def create_qt_menu(name): """ Helper function to create a Qt menu with the given name. :param name: The menu name. :returns: The menu created. :rtype: QtGui.QMenu """ menu = QtGui.QMenu() menu.setTitle(name) return menu
def _configure_widget(self, widget, item, style_options): # defaults if no children menu = None popup_mode = widget.DelayedPopup button_icon = item.data(QtCore.Qt.DecorationRole) button_tooltip = item.toolTip() # gather list of actions if the button has multiple commands children = ProjectCommandModel.get_item_children_in_order(item) first_child = True if children: # create the menu when we have children menu = QtGui.QMenu() for child in children: icon = child.data(QtCore.Qt.DecorationRole) menu_name = child.data(ProjectCommandModel.MENU_NAME_ROLE) if first_child: button_icon = icon button_tooltip = child.toolTip() if len(children) > 1: menu_name = "%s*" % menu_name action = menu.addAction(menu_name) action.setData({ "command": child.data(ProjectCommandModel.COMMAND_ROLE), "button": child.data(ProjectCommandModel.BUTTON_NAME_ROLE), }) action.setToolTip(child.toolTip()) action.setIconVisibleInMenu(False) if icon is not None: action.setIcon(icon) first_child = False widget.setMenu(menu) # setup the widget to handle the menu click popup_mode = widget.MenuButtonPopup menu.triggered.connect(self._handle_clicked) # update button widget.setMenu(menu) widget.setPopupMode(popup_mode) if button_icon is None: widget.setIcon(QtGui.QIcon()) else: widget.setIcon(button_icon) widget.setToolTip(button_tooltip) widget.setText(" %s" % item.data(ProjectCommandModel.BUTTON_NAME_ROLE)) widget.setIconSize(self.ICON_SIZE) widget.setToolButtonStyle(QtCore.Qt.ToolButtonTextBesideIcon)
def createMenus(self): self.fileMenu = QtGui.QMenu("&File", self) self.fileMenu.addAction(self.openAct) self.fileMenu.addAction(self.printAct) self.fileMenu.addSeparator() self.fileMenu.addAction(self.exitAct) self.viewMenu = QtGui.QMenu("&View", self) self.viewMenu.addAction(self.zoomInAct) self.viewMenu.addAction(self.zoomOutAct) self.viewMenu.addAction(self.normalSizeAct) self.viewMenu.addSeparator() self.viewMenu.addAction(self.fitToWindowAct) self.helpMenu = QtGui.QMenu("&Help", self) self.helpMenu.addAction(self.aboutAct) self.helpMenu.addAction(self.aboutQtAct) self.menuBar().addMenu(self.fileMenu) self.menuBar().addMenu(self.viewMenu) self.menuBar().addMenu(self.helpMenu)
def __init__(self, parent): """ Constructor :param parent: QT parent object """ QtGui.QWidget.__init__(self, parent) # make sure this widget isn't shown self.setVisible(False) # set up the UI self.ui = Ui_ListItemWidget() self.ui.setupUi(self) # the property stylesheet syntax seems brittle and hacky so # keeping the style sheet modifications local here rather # than in global css # todo: figure out a better way to do this! self._css_decorated = """ #box { border-width: 2px; border-radius: 4px; border-color: rgb(48, 167, 227); border-style: solid; } """ self._css_selected = """ #box { border-width: 2px; border-radius: 4px; border-color: rgb(48, 167, 227); border-style: solid; background-color: rgba(48, 167, 227, 25%); } """ self._no_style = """ #box { border-width: 2px; border-radius: 4px; border-color: rgba(0, 0, 0, 0%); border-style: solid; } """ # set up action menu self._menu = QtGui.QMenu() self._actions = [] self.ui.button.setMenu(self._menu) self.ui.button.setVisible(False)
def _show_menu(self, view, index, pos): """ Callback triggered from the ViewItemDelegate when Menu Button action is triggered. Create and show the actions menu. """ menu = QtGui.QMenu(self) if isinstance(index.model(), BasicListItemModel): # NOTE: ShotgunDemoModel is not set up to handle setting loading state and separator data per item, # but it could be extended to achieve this functionality # Toggle showing loading indicator for this index toggle_loading_action = QtGui.QAction("Toggle Loading", self) toggle_loading_action.triggered.connect( lambda: index.model().toggle_data( index, index.model().VIEW_ITEM_LOADING_ROLE ) ) # Toggle showing separator for this index toggle_separator_action = QtGui.QAction("Toggle Separator", self) toggle_separator_action.triggered.connect( lambda: index.model().toggle_data( index, index.model().VIEW_ITEM_SEPARATOR_ROLE ) ) menu.addActions([toggle_loading_action, toggle_separator_action]) # Non-index specific actions # Toggle showing loading indactors for all items toggle_all_loading_action = QtGui.QAction("Toggle All Loading", self) toggle_all_loading_action.triggered.connect( lambda: index.model().toggle_data( None, index.model().VIEW_ITEM_LOADING_ROLE ) ) # Toggle showing separators for all items toggle_all_separator_action = QtGui.QAction("Toggle All Separators", self) toggle_all_separator_action.triggered.connect( lambda: index.model().toggle_data( None, index.model().VIEW_ITEM_SEPARATOR_ROLE ) ) menu.addActions([toggle_all_loading_action, toggle_all_separator_action]) # Show the menu at the given position relative to the view widget menu_pos = view.mapToGlobal(pos) menu.exec_(menu_pos)
def addAction(self, action): """ Override the addAction method to create a QMenu object here, that will hold any button menu actions. Normally, the QMenu object would be created on show, in the C++ source QToolButton::popupTimerDone(), but since we've monkey patched the QMenu object, we need to create it on the Python side to make sure we use our QMenuPatch object instead of QMenu. :param action: The QAction object to add to our QToolButton menu. """ if self.menu() is None: self._patch_menu = QtGui.QMenu() self.setMenu(self._patch_menu) self.menu().addAction(action)
def __init__(self, parent, command_name, button_name, icon, tooltip): """ :param parent: Parent widget. :param str command_name: Name of the default command to execute. :param str button_name: Name of the button. :param str icon: Path to the icon. :param str tooltip: Tooltip for the button. """ super(CommandButton, self).__init__(parent) self.setSizePolicy(QtGui.QSizePolicy.MinimumExpanding, QtGui.QSizePolicy.MinimumExpanding) self.setFocusPolicy(QtCore.Qt.NoFocus) self.setIconSize(ICON_SIZE) self.setToolButtonStyle(QtCore.Qt.ToolButtonTextBesideIcon) self.setStyleSheet(BUTTON_STYLE) self.setText(" %s" % button_name) self._set_default(tooltip, icon) self._commands = [] # This menu will implement the drop down behaviour of the tool button. self._menu = QtGui.QMenu(self) self._button_name = button_name # The data of an action contains the command name. self._menu.triggered.connect( # The .data method returns a unicode string in Python 2, so force it to a utf8 str. lambda action: self.command_triggered.emit( six.ensure_str(action.data()))) # This is a workaround for a PySide2 issue where the hover state of the button # is not properly cleared when the menu is dismissed or an action clicked. # # Inspired by this workaround: # https://forum.qt.io/topic/36348/solved-how-do-i-clear-hover-state-on-a-qgraphicswidget-wrapped-qtoolbutton def cleanup(): self.setAttribute( QtCore.Qt.WA_UnderMouse, # Check if the cursor is still over the widget and set the under mouse # property appropriately. self.rect().contains(self.mapFromGlobal(QtGui.QCursor.pos())), ) self._menu.aboutToHide.connect(cleanup) # Clicking on the button triggers the first action. self.clicked.connect(lambda: self._menu.actions()[0].trigger())
def _show_filters(self, UI_filters_action): """ Initialized filter menu and selected default action or previous action :param UI_filters_action: previous selected filter """ filters_menu = QtGui.QMenu() filters_group = QtGui.QActionGroup(self) project_filter = QtGui.QAction('Current Project Tasks', filters_menu, checkable=True) project_filter.setData([['project', 'is', '{context.project}']]) filters_group.addAction(project_filter) filters_menu.addAction(project_filter) #all_filter = QtGui.QAction('All Tasks', filters_menu, # checkable=True) #all_filter.setData([]) #filters_group.addAction(all_filter) #filters_menu.addAction(all_filter) #facility_filter = QtGui.QAction('Facility Tasks', filters_menu, # checkable=True) #facility_filter.setData([['project.Project.name', 'is', 'Facility']]) #filters_group.addAction(facility_filter) #filters_menu.addAction(facility_filter) self._app = sgtk.platform.current_bundle() sg = self._app.context.tank.shotgun project_list = sg.find("Project", [ ['name', 'not_contains', '_'], ['sg_status', 'is', 'Active'], ['id', 'is_not', self._app.context.project['id']], ], ['name']) for project_ent in project_list: temp_filter = QtGui.QAction(project_ent['name'], filters_menu, checkable=True) temp_filter.setData([['project', 'is', project_ent]]) filters_group.addAction(temp_filter) filters_menu.addAction(temp_filter) if UI_filters_action: for filter_action in filters_menu.findChildren(QtGui.QAction): if filter_action.text() == UI_filters_action.text(): filter_action.setChecked(True) else: project_filter.setChecked(True) self._ui.filter_btn.setMenu(filters_menu) filters_group.triggered.connect(self._on_filter_changed)
def open_menu(self, position): """ Context menu in my task tree :param position: where the time event is dropped """ menu = QtGui.QMenu() addTimeAction = menu.addAction("New Time Log") action = menu.exec_(self.task_tree.viewport().mapToGlobal(position)) if action == addTimeAction: task = self._get_selected_task() time = timelogEvent("Custom Time", date.today(), timedelta(-1)) if task: timelog_dl = NewTimeLogForm(time, task, parent=self.parent) timelog_dl.exec_() logger.debug("New timelog submitted to Shotgun")
def create(self): """ Render the entire Shotgun menu. """ self._engine.logger.debug("Creating Shotgun Menu") # Destroy root menu if exists if self.exists: self.destroy() # Create root menu window = self._engine.get_vred_main_window() menubar = window.menuBar() root_menu = QtGui.QMenu() root_menu.setTitle(self.ROOT_MENU_TEXT) # Get all options and sort them options = [(caption, data) for caption, data in self._engine.commands.items()] if options: options.sort(key=lambda option: option[0]) # Context submenu root_menu.addMenu(self._create_context_submenu(options)) root_menu.addSeparator() # Favourites favourites = self._create_favourites(options) [ root_menu.addAction(caption, callback) for caption, callback in favourites ] if favourites: root_menu.addSeparator() # Apps apps = self._create_apps(options) for label, is_submenu, data in apps: if is_submenu: root_menu.addMenu(data) else: caption, callback = data root_menu.addAction(caption, callback) actions = menubar.actions() menubar.insertMenu(actions[-1], root_menu)
def createMenu(self): fileMenu = QtGui.QMenu() for a in self.values["files"][0]: fct = lambda a=a: self.launchFromPath(a) fileMenu.addAction(os.path.basename(a), fct) for m, files in self.values["files"][1].iteritems(): fileNameMenu = fileMenu.addMenu(m) for path in files: fct = lambda path=path: self.launchFromPath(path) fileNameMenu.addAction(os.path.basename(path), fct) path = self.values["files"][2] fct = lambda path=path: self.launchFromContext(path) fileMenu.addAction("Empty Scene", fct) return fileMenu
def _create_context_submenu(self, options): submenu = QtGui.QMenu() submenu.setTitle(self.context_name) submenu.addAction(self.JUMP_TO_SG_TEXT, self.jump_to_sg) submenu.addAction(self.JUMP_TO_FS_TEXT, self.jump_to_fs) submenu.addSeparator() filtered_options = [ (caption, data) for caption, data in options if data.get("properties").get("type") == "context_menu" ] for caption, data in filtered_options: callback = data.get("callback") submenu.addAction(caption, callback) return submenu
def _show_context_menu(self, pos): item = self.itemAt(pos) row = self.row(item) if row >= self.count() - 1: return menu = QtGui.QMenu() menu.addAction( QtGui.QIcon(res.get_path('preview.png')), 'preview', partial(self._preview_item_at, pos), ) menu.addAction( QtGui.QIcon(res.get_path('clear.png')), 'remove', partial(self._remove_item_at, pos), ) menu.exec_(self.mapToGlobal(pos))
def _get_gists_action(self, parent): """ Returns a ``QtGui.QAction`` for loading gists. The returned action is a menu action showing actions for each gist for the users defined in ``GITHUB_GIST_USERS``. :param parent: The ``QtGui.QObject`` to use as the action's parent """ app = self.parent gists_menu = QtGui.QMenu("Gists", parent) icon = QtGui.QIcon(":/tk_multi_pythonconsole/github.png") gists_menu.setIcon(icon) for gist_user in GITHUB_GIST_USERS: if not gist_user in QUERIED_GISTS: # query gists for this user QUERIED_GISTS[gist_user] = get_gists(gist_user, app) gists = QUERIED_GISTS[gist_user] # no gists for this user, don't create a submenu if not gists: continue # construct a menu for this user gist_user_menu = gists_menu.addMenu(gist_user) for gist in gists: gist_action = QtGui.QAction(gist["file_name"], gist_user_menu) # PySide2 seems to pass the checked state through as an args instead of a kwarg # so we need to provide a kwarg for it to pass the check state without overriding the gist value. add_gist = lambda checked=False, g=gist: self._add_gist_tab(g) gist_action.triggered.connect(add_gist) gist_user_menu.addAction(gist_action) return gists_menu.menuAction()
def _on_browser_context_menu_requested(self, file, env, pnt): """ """ if not file: return # get the file actions: file_actions = self._get_available_file_actions(file, env) if not file_actions: return # build the context menu: context_menu = QtGui.QMenu(self.sender()) self._populate_open_menu(context_menu, file_actions[1:]) # map the point to a global position: pnt = self.sender().mapToGlobal(pnt) # finally, show the context menu: context_menu.exec_(pnt)
def _get_gists_action(self, parent): """ Returns a ``QtGui.QAction`` for loading gists. The returned action is a menu action showing actions for each gist for the users defined in ``GITHUB_GIST_USERS``. :param parent: The ``QtGui.QObject`` to use as the action's parent """ app = self.parent gists_menu = QtGui.QMenu("Gists", parent) icon = QtGui.QIcon(":/tk_multi_pythonconsole/github.png") gists_menu.setIcon(icon) for gist_user in GITHUB_GIST_USERS: if not gist_user in QUERIED_GISTS: # query gists for this user QUERIED_GISTS[gist_user] = get_gists(gist_user, app) gists = QUERIED_GISTS[gist_user] # no gists for this user, don't create a submenu if not gists: continue # construct a menu for this user gist_user_menu = gists_menu.addMenu(gist_user) for gist in gists: gist_action = QtGui.QAction(gist["file_name"], gist_user_menu) gist_action.triggered.connect(lambda g=gist: self._add_gist_tab(g)) gist_user_menu.addAction(gist_action) return gists_menu.menuAction()
def _on_popup_btn_click(self): """ Display a context menu based on the current field value. """ popup_menu = QtGui.QMenu() if self._value: link_type = self._value["link_type"] else: link_type = None if not link_type: # no link type, display options for each type popup_menu.addAction(self._upload_file_action) popup_menu.addAction(self._web_page_link_action) popup_menu.addAction(self._local_path_action) elif link_type == "upload": popup_menu.addAction(self._edit_upload_file_action) popup_menu.addAction(self._replace_with_web_page_link_action) popup_menu.addAction(self._replace_with_local_path_action) popup_menu.addAction(self._remove_link_action) elif link_type == "web": popup_menu.addAction(self._replace_with_upload_file_action) popup_menu.addAction(self._edit_web_page_link_action) popup_menu.addAction(self._replace_with_local_path_action) popup_menu.addAction(self._remove_link_action) elif link_type == "local": popup_menu.addAction(self._replace_with_upload_file_action) popup_menu.addAction(self._replace_with_web_page_link_action) popup_menu.addAction(self._edit_local_path_action) popup_menu.addAction(self._remove_link_action) # show the menu below the button popup_menu.exec_( self._popup_btn.mapToGlobal( QtCore.QPoint(0, self._popup_btn.height()) ) )
def setup_widget(self): """ Prepare the widget for display. Called by the metaclass during initialization. """ self._pixmap = None self._image_path = None self._editable = False self._scaled_width = self.width() self.setAlignment(QtCore.Qt.AlignLeft | QtCore.Qt.AlignTop) if self._delegate: # in delegate mode. that means this widget is being used to display # multiple entity's image fields. so setting up a data retriever to # download for a specific entity is pointless. self._needs_download = False else: self._needs_download = True # start up a data retriever to fetch the thumbnail in the background self._data_retriever = shotgun_data.ShotgunDataRetriever( bg_task_manager=self._bg_task_manager) self._data_retriever.start() self._data_retriever.work_completed.connect(self._on_worker_signal) self._data_retriever.work_failure.connect(self._on_worker_failure) self.setSizePolicy(QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Expanding) # menu display button for showing the popup menu self._popup_btn = QtGui.QPushButton(self) self._popup_btn.setIcon( QtGui.QIcon(":/qtwidgets-shotgun-fields/image_menu.png")) self._popup_btn.setFixedSize(QtCore.QSize(18, 12)) self._popup_btn.hide() if not self._delegate: # not sure why, but when the widget is being used in a delegate, # this causes editor to close immediately when clicked. self._popup_btn.setFocusPolicy(QtCore.Qt.NoFocus) # make sure there's never a bg color or border self._popup_btn.setStyleSheet("background-color: none; border: none;") # actions self._clear_action = QtGui.QAction("Clear Thumbnail", self) self._clear_action.triggered.connect(self._clear_image) self._replace_action = QtGui.QAction("Replace Thumbnail", self) self._replace_action.triggered.connect(self._upload_image) self._view_action = QtGui.QAction("View Image", self) self._view_action.triggered.connect(self._show_image) self._upload_action = QtGui.QAction("Upload Thumbnail", self) self._upload_action.triggered.connect(self._upload_image) self._popup_edit_menu = QtGui.QMenu() self._popup_edit_menu.addAction(self._clear_action) self._popup_edit_menu.addAction(self._replace_action) self._popup_edit_menu.addAction(self._view_action) self._popup_display_menu = QtGui.QMenu() self._popup_display_menu.addAction(self._view_action) self._popup_upload_menu = QtGui.QMenu() self._popup_upload_menu.addAction(self._upload_action) self.installEventFilter(self) self._display_default() self._update_btn_position() # ---- connect signals self._popup_btn.clicked.connect(self._on_popup_btn_click) self.linkActivated.connect(self._on_link_activated)
def __init__(self, parent=None): """ Initialize the console. :param parent: The console's parent widget. """ super(PythonConsoleWidget, self).__init__(parent) self.tabs = PythonTabWidget(self) # ---- output related buttons # clear output out_clear_btn = QtGui.QToolButton(self) out_clear_btn.setMinimumSize(QtCore.QSize(30, 30)) out_clear_btn.setMaximumSize(QtCore.QSize(30, 30)) out_clear_btn.setObjectName("out_clear_btn") out_clear_btn.setToolTip("Clear all output.") # echo output self._out_echo_btn = QtGui.QToolButton() self._out_echo_btn.setCheckable(True) self._out_echo_btn.setChecked(True) self._out_echo_btn.setDown(True) self._out_echo_btn.setMinimumSize(QtCore.QSize(30, 30)) self._out_echo_btn.setMaximumSize(QtCore.QSize(30, 30)) self._out_echo_btn.setObjectName("out_echo_btn") self._out_echo_btn.setToolTip("Echo python commands in output.") # output buttons layout out_btn_box = QtGui.QVBoxLayout() out_btn_box.setContentsMargins(0, 0, 0, 0) out_btn_box.addWidget(out_clear_btn) out_btn_box.addSpacing(10) out_btn_box.addWidget(self._out_echo_btn) out_btn_box.addSpacing(10) out_btn_box.addStretch() # ---- input # clear input in_clear_btn = QtGui.QToolButton() in_clear_btn.setMinimumSize(QtCore.QSize(30, 30)) in_clear_btn.setMaximumSize(QtCore.QSize(30, 30)) in_clear_btn.setObjectName("in_clear_btn") in_clear_btn.setToolTip("Clear all input.") # show/hide line numbers self._line_num_btn = QtGui.QToolButton() self._line_num_btn.setCheckable(True) self._line_num_btn.setChecked(True) self._line_num_btn.setDown(True) self._line_num_btn.setMinimumSize(QtCore.QSize(30, 30)) self._line_num_btn.setMaximumSize(QtCore.QSize(30, 30)) self._line_num_btn.setObjectName("line_num_btn") self._line_num_btn.setToolTip("Show/hide line numbers.") # open file self._open_file_menu = QtGui.QMenu(self) self._open_file_menu.aboutToShow.connect(self._build_open_file_menu) self._cached_static_actions = {} in_open_btn = QtGui.QToolButton() in_open_btn.setMinimumSize(QtCore.QSize(30, 30)) in_open_btn.setMaximumSize(QtCore.QSize(30, 30)) in_open_btn.setObjectName("in_open_btn") in_open_btn.setToolTip("Load python script from a file.") in_open_btn.setMenu(self._open_file_menu) in_open_btn.setPopupMode(QtGui.QToolButton.DelayedPopup) # reusable action for opening from disk open_file_icon = QtGui.QIcon(":/tk_multi_pythonconsole/open.png") self._open_file_action = QtGui.QAction(open_file_icon, "Load from disk...", self) self._open_file_action.triggered.connect(self.open) # save file self._in_save_btn = QtGui.QToolButton() self._in_save_btn.setMinimumSize(QtCore.QSize(30, 30)) self._in_save_btn.setMaximumSize(QtCore.QSize(30, 30)) self._in_save_btn.setObjectName("in_save_btn") self._in_save_btn.setToolTip("Save current python script to a file.") # execute self._in_exec_btn = QtGui.QToolButton() self._in_exec_btn.setMinimumSize(QtCore.QSize(30, 30)) self._in_exec_btn.setMaximumSize(QtCore.QSize(30, 30)) self._in_exec_btn.setObjectName("in_exec_btn") self._in_exec_btn.setToolTip( "Execute the current python script. Shortcut: Ctrl+Enter") # add tab add_tab_btn = QtGui.QToolButton(self) add_tab_btn.setMinimumSize(QtCore.QSize(12, 12)) add_tab_btn.setMaximumSize(QtCore.QSize(12, 12)) add_tab_btn.setObjectName("add_tab_btn") add_tab_btn.setToolTip("Add a new tab") # input buttons layout in_btn_box = QtGui.QVBoxLayout() in_btn_box.setContentsMargins(0, 0, 0, 0) in_btn_box.addStretch() in_btn_box.addWidget(self._in_exec_btn) in_btn_box.addSpacing(10) in_btn_box.addWidget(self._in_save_btn) in_btn_box.addSpacing(10) in_btn_box.addWidget(in_open_btn) in_btn_box.addSpacing(10) in_btn_box.addWidget(in_clear_btn) in_btn_box.addSpacing(10) in_btn_box.addWidget(self._line_num_btn) in_btn_box.addSpacing(20) in_btn_box.addWidget(add_tab_btn) in_btn_box.addSpacing(4) in_btn_box.setAlignment(add_tab_btn, QtCore.Qt.AlignVCenter | QtCore.Qt.AlignCenter) button_layout = QtGui.QVBoxLayout() button_layout.setContentsMargins(0, 0, 0, 0) button_layout.setSpacing(0) button_layout.addLayout(out_btn_box) button_layout.addStretch() button_layout.addLayout(in_btn_box) # main layout layout = QtGui.QHBoxLayout(self) layout.setContentsMargins(4, 4, 4, 4) layout.setSpacing(4) layout.addWidget(self.tabs) layout.addLayout(button_layout) layout.setStretchFactor(self.tabs, 100) # ---- connect singals and slots self._cur_tab_widget = lambda: self.tabs.currentWidget() # buttons clicked out_clear_btn.clicked.connect( lambda: self._cur_tab_widget().output_widget.clear()) self._in_save_btn.clicked.connect( lambda: self._cur_tab_widget().input_widget.save()) in_open_btn.clicked.connect(self.open) in_clear_btn.clicked.connect( lambda: self._cur_tab_widget().input_widget.clear()) self._in_exec_btn.clicked.connect( lambda: self._cur_tab_widget().input_widget.execute()) add_tab_btn.clicked.connect(self.tabs.add_tab) # toggles self._out_echo_btn.toggled.connect( lambda t: self._cur_tab_widget().input_widget.toggle_echo(t)) self._line_num_btn.toggled.connect(lambda t: self._cur_tab_widget(). input_widget.toggle_line_numbers(t)) self.tabs.input_text_changed.connect(self._check_button_state) self.tabs.currentChanged.connect(self._check_button_state) # ---- set the default state # no point in saving until there are contents self._in_save_btn.setEnabled(False)