Python QMenu.sizeHint方法代码示例

# 需要导入模块: from PyQt5.QtWidgets import QMenu [as 别名]
# 或者: from PyQt5.QtWidgets.QMenu import sizeHint [as 别名]

#.........这里部分代码省略.........
    def __loadRecentFiles(self):
        """
        Private method to load the recently opened filenames.
        """
        rf = self.rsettings.value(Globals.recentNameFiles)
        if rf is not None:
            for f in rf:
                if QFileInfo(f).exists():
                    self.recentFiles.append(f)
    
    def __activated(self, reason):
        """
        Private slot to handle the activated signal.
        
        @param reason reason code of the signal
            (QSystemTrayIcon.ActivationReason)
        """
        if reason == QSystemTrayIcon.Context or \
           reason == QSystemTrayIcon.MiddleClick:
            self.__showContextMenu()
        elif reason == QSystemTrayIcon.DoubleClick:
            self.__startEric()
    
    def __showContextMenu(self):
        """
        Private slot to show the context menu.
        """
        self.menuRecentProjectsAct.setEnabled(len(self.recentProjects) > 0)
        self.menuRecentMultiProjectsAct.setEnabled(
            len(self.recentMultiProjects) > 0)
        self.menuRecentFilesAct.setEnabled(len(self.recentFiles) > 0)
        
        pos = QCursor.pos()
        x = pos.x() - self.__menu.sizeHint().width()
        pos.setX(x > 0 and x or 0)
        y = pos.y() - self.__menu.sizeHint().height()
        pos.setY(y > 0 and y or 0)
        self.__menu.popup(pos)
    
    def __startProc(self, applName, *applArgs):
        """
        Private method to start an eric6 application.
        
        @param applName name of the eric6 application script (string)
        @param *applArgs variable list of application arguments
        """
        proc = QProcess()
        applPath = os.path.join(getConfig("ericDir"), applName)
        
        args = []
        args.append(applPath)
        for arg in applArgs:
            args.append(arg)
        
        if not os.path.isfile(applPath) or \
                not proc.startDetached(sys.executable, args):
            E5MessageBox.critical(
                self,
                self.tr('Process Generation Error'),
                self.tr(
                    '<p>Could not start the process.<br>'
                    'Ensure that it is available as <b>{0}</b>.</p>'
                ).format(applPath),
                self.tr('OK'))
    
    def __startMiniEditor(self):

# 需要导入模块: from PyQt5.QtWidgets import QMenu [as 别名]
# 或者: from PyQt5.QtWidgets.QMenu import sizeHint [as 别名]
class AceEditor(QWidget):
    """ Embbeded Ace javascript web editor """
    
    
    def __init__(self, file_info, parent=None):
        super(AceEditor, self).__init__(parent)
        self.parent = parent
        self.file_info = file_info
        self.editor_actions = {}
        self.language = EditorHelper.lang_from_file_info(file_info)
        
        self.editor = Ace(self.file_info, self)
        
        self.status_bar = StatusBar(self)
        
        self.editor.modificationChanged.connect(
            self.modification_changed)
        self.editor.cursorPositionChanged.connect(self.on_cursor_changed)
        
        self.v_box = QVBoxLayout(self)
        self.v_box.setSpacing(0)
        self.v_box.setContentsMargins(0, 0, 0, 0)
        
        self.v_box.addWidget(self.editor, 1)
        self.v_box.addWidget(self.status_bar, 0)
        
        self.setLayout(self.v_box)
        
        self.status_bar.menu_button.clicked.connect(
            self.on_menu_button_clicked)
        
        self.menu = QMenu(self)
        self.add_action('Save', 'ctrl+s', self.editor.save)
        self.add_separator()
        self.add_action(
            'Show hidden', 'ctrl+i', self.editor.toggle_hidden,checkable=True
        )
        self.add_action(
            'Use soft tabs', 'ctrl+shift+alt+s', self.editor.toggle_soft_tabs,
            checkable=True
        )
        self.setFocusPolicy(Qt.NoFocus)
        self.setFocusProxy(self.editor)
        
        Alter.invoke_all('editor_widget_init', self)
    
    @pyqtSlot(bool, name='modificationChanged')
    def modification_changed(self, b):
        if self.parent:
            self.parent.on_current_modified(b)
    
    @pyqtSlot(int, int, name='cursorPositionChanged')
    def on_cursor_changed(self, line, index):
        self.status_bar.showMessage(
            self.tr("Line {0}, column {1}".format(line + 1, index))
        )
    
    def on_menu_button_clicked(self):
        pos = self.status_bar.mapToGlobal(self.status_bar.menu_button.pos())
        menu_size = self.menu.sizeHint()
        menu_height = menu_size.height()
        menu_width = menu_size.width()
        pos.setY(pos.y() - menu_height)
        pos.setX(pos.x() - menu_width + self.status_bar.menu_button.width())
        if len(self.menu.actions()) > 0:
            self.menu.exec(pos)
    
    def add_action(self, name, shortcut, callback, **kwargs):
        """
        Ajoute une action au context menu et au widget navigation lui même.
        Créer une fonction à la volé pour fournir des arguments aux fonctions
        associé aux actions.
        """
        action = QAction(self.tr(name), self)
        if 'icon' in kwargs:
            action.setIcon(kwargs['icon'])
        if 'checkable' in kwargs and kwargs['checkable']:
            action.setCheckable(True)
            if 'checked' in kwargs:
                checked = True if kwargs['checked'] == 'true' else False
                action.setChecked(
                    checked
                )
        
        action.setShortcut(shortcut)
        action.setShortcutContext(Qt.WidgetWithChildrenShortcut)
        
        if 'wrapped' in kwargs and kwargs['wrapped'] is False:
            action.triggered.connect(callback)
        else:
            action.triggered.connect(self.__wrapper(callback))
        
        self.addAction(action)
        self.menu.addAction(action)
        self.editor_actions[name] = action
        
    def add_separator(self):
        """Simple abstraction of self.context_menu.addSeparator()"""
        self.menu.addSeparator()

#.........这里部分代码省略.........

# 需要导入模块: from PyQt5.QtWidgets import QMenu [as 别名]
# 或者: from PyQt5.QtWidgets.QMenu import sizeHint [as 别名]

#.........这里部分代码省略.........
        self.add_separator()
        self.add_action('Delete', QKeySequence.Delete, 
                        FileSystemHelper.delete)
        
        # @ToDo Alter.invoke_all('navigation_add_action', self)
        
        #restore previous session and data
        dirs = ModuleManager.core['settings'].Settings.value(
            self.SETTINGS_DIRECTORIES, None, True)
        for directory_path in dirs:
            name = os.path.basename(directory_path)
            self.menu_add_directory(name, directory_path)
        current_dir = ModuleManager.core['settings'].Settings.value(
            self.SETTINGS_CURRENT_DIR, '')
        if current_dir:
            for action in self.menu_directories.actions():
                if action.data() == current_dir:
                    action.trigger()
        
        self.menu_button.setFocusPolicy(Qt.NoFocus)
        self.menu_button.setFocusProxy(self.tree)
    
    def reset(self, file_info):
        self.model.beginResetModel()
        current_dir = ModuleManager.core['settings'].Settings.value(
            self.SETTINGS_CURRENT_DIR, '')
        if current_dir:
            for action in self.menu_directories.actions():
                if action.data() == current_dir:
                    action.trigger()
    
    def on_menu_button_clicked(self):
        pos = self.mapToGlobal(self.menu_button.pos())
        menu_width = self.menu.sizeHint().width()
        pos.setY(pos.y() + self.menu_button.height())
#        pos.setX(pos.x() + self.menu_button.width() - menu_width)
        if len(self.menu.actions()) > 0:
            self.menu.exec(pos)
    
    def menu_add_action(self, name, callback, data=None, shortcut=None, icon=None):
        action = QAction(name, self)
        if icon:
            action.setIcon(icon)
        if shortcut:
            action.setShortcut(shortcut)
            action.setShortcutContext(Qt.WidgetWithChildrenShortcut)
        if data:
            action.setData(data)
        action.triggered.connect(callback)
        self.addAction(action)
        self.menu.addAction(action)
    
    def menu_add_directory(self, name, data):
        action = QAction(name, self)
        action.setData(data)
        action.triggered.connect(self.on_menu_action_triggered)
        self.menu_directories.addAction(action)
        return action
    
    def menu_add_separator(self):
        self.menu.addSeparator()
    
    def add_action(self, name, shortcut, callback, icon = None):
        """
        Ajoute une action au context menu et au widget navigation lui même.
        Créer une fonction à la volé pour fournir des arguments aux fonctions

# 需要导入模块: from PyQt5.QtWidgets import QMenu [as 别名]
# 或者: from PyQt5.QtWidgets.QMenu import sizeHint [as 别名]
class TabWidget(QTabWidget):
    """
    TabWidget class definition
    """
    
    currentChangedFileInfo = pyqtSignal(QFileInfo)
    
    def __init__(self, parent=None):
        super(TabWidget, self).__init__(parent)
        self.tabBar().installEventFilter(self)
        self.setTabsClosable(True)
        self.setMovable(True)
        self.setFocusPolicy(Qt.NoFocus)
        
        self.icon_modified = QIcon('images/is-modified.png')
        self.icon_not_modified = QIcon('images/is-not-modified.png')
        
        self.tabCloseRequested.connect(self.on_tab_closed)
        
        nav_icon = QIcon('images/navigation-menu.png')
        self.menu_button = QPushButton('', self)
        self.menu_button.setIcon(nav_icon)
        self.menu_button.setFlat(True)
        self.menu_button.clicked.connect(self.on_menu_button_clicked)
        self.menu_button.setObjectName('TabWidgetMenuButton')
        self.menu_button.setToolTip('Menu with useful actions')
        self.setCornerWidget(self.menu_button, Qt.TopRightCorner)
        self.menu = QMenu(self)
        self.add_action('Remove current tab', 'ctrl+w', TabWidgetHelper.remove)
        self.add_action(
            'Remove all tab', 'ctrl+shift+w', TabWidgetHelper.remove_all)
        self.add_separator()
        self.add_action('Next Tab', QKeySequence.NextChild, 
                        TabWidgetHelper.next_tab)
        self.add_action('Previous Tab', QKeySequence.PreviousChild, 
                        TabWidgetHelper.previous_tab)
        self.add_separator()
        self.add_action('Open file', QKeySequence.Open,
                        TabWidgetHelper.open_file)
        Alter.invoke_all('tab_widget_add_action', self)
        self.currentChanged[int].connect(self.on_current_changed)
    
    def eventFilter(self, o, event):
        if o == self.tabBar() and event.type() == QEvent.MouseButtonPress:
            if event.button() == Qt.MidButton:
                index = self.tabBar().tabAt(event.pos())
                if index != -1:
                    self.on_tab_closed(index)
                    return True
        return super(TabWidget, self).eventFilter(o, event)
    
    def on_current_changed(self, index):
        if index != -1:
            widget = self.widget(index)
            self.setFocusProxy(widget)
            self.setFocus(Qt.TabFocusReason)
            self.currentChangedFileInfo.emit(widget.file_info)
    
    # the function name must be equal to signal name.
    # decorator because reduce the amount of memory used and is slightly faster
    @pyqtSlot(QFileInfo)
    def onFileItemActivated(self, file_info):
        Alter.invoke_all('tab_widget_add_tab', self, file_info)
    
    def add_tab(self, cls, file_info, force_open=False):
        #if file is already open
        index, i = -1, 0
        while not force_open and i < self.count() and index == -1:
            if self.widget(i).file_info == file_info:
                index = i
            i += 1
        if index == -1:
            index = self.addTab(
                cls(file_info, self),
                self.icon_not_modified,
                file_info.fileName()
            )
        self.setCurrentIndex(index)
        self.setFocus(True)
    
    def on_menu_button_clicked(self):
        pos = self.mapToGlobal(self.menu_button.pos())
        menu_width = self.menu.sizeHint().width()
        pos.setY(pos.y() + self.menu_button.height())
        pos.setX(pos.x() + self.menu_button.width() - menu_width)
        if len(self.menu.actions()) > 0:
            self.menu.exec(pos)
    
    def on_tab_closed(self, index):
        widget = self.widget(index)
        self.removeTab(index)
        # remove the widget for real
        widget.deleteLater()
        del widget
    
    def add_action(self, name, shortcut, callback, icon = None):
        """
        Ajoute une action au context menu et au widget lui même.
        Créer une fonction à la volé pour fournir des arguments aux fonctions
        associé aux actions.
#.........这里部分代码省略.........

# 需要导入模块: from PyQt5.QtWidgets import QMenu [as 别名]
# 或者: from PyQt5.QtWidgets.QMenu import sizeHint [as 别名]

#.........这里部分代码省略.........
            self.editor.indent_current_line
        )
        self.add_action(
            self.tr('Unindent current line'),
            'ctrl+shift+i',
            self.editor.unindent_current_line
        )
        self.add_separator()
        self.add_action(
            self.tr('Auto close brackets and quotes'),
            'ctrl+alt+a',
            EditorHelper.auto_close_brackets_quotes,
            checkable=True,
            checked=ModuleManager.core['settings'].Settings.value(
                EditorHelper.SETTINGS_AUTO_CLOSE_BRACKETS,
                'true'
            )
        )
        self.add_action(
            self.tr('Use tabs to indent/unindent'),
            'ctrl+shift+alt+&',
            EditorHelper.use_tabs_to_indent,
            checkable=True,
            checked=ModuleManager.core['settings'].Settings.value(
                EditorHelper.SETTINGS_USE_TABS_TO_INDENT,
                'true'
            )
        )
        self.add_action(
            self.tr('Comment/Uncomment line(s)'),
            'ctrl+e',
            self.editor.comment_lines
        )
        
        self.setFocusPolicy(Qt.NoFocus)
        self.setFocusProxy(self.editor)
        
        Alter.invoke_all('editor_widget_init', self)
    
    def on_modification_changed(self, modified):
        if self.parent:
            self.parent.on_current_modified(modified)
    
    def on_cursor_changed(self, line, index):
        self.status_bar.showMessage(
            self.tr("Line {0}, column {1}".format(line + 1, index))
        )
    
    def on_menu_button_clicked(self):
        pos = self.status_bar.mapToGlobal(self.status_bar.menu_button.pos())
        menu_size = self.menu.sizeHint()
        menu_height = menu_size.height()
        menu_width = menu_size.width()
        pos.setY(pos.y() - menu_height)
        pos.setX(pos.x() - menu_width + self.status_bar.menu_button.width())
        if len(self.menu.actions()) > 0:
            self.menu.exec(pos)
    
    def add_action(self, name, shortcut, callback, **kwargs):
        """
        Ajoute une action au context menu et au widget navigation lui même.
        Créer une fonction à la volé pour fournir des arguments aux fonctions
        associé aux actions.
        """
        action = QAction(name, self)
        if 'icon' in kwargs:
            action.setIcon(kwargs['icon'])
        if 'checkable' in kwargs and kwargs['checkable']:
            action.setCheckable(True)
            if 'checked' in kwargs:
                checked = True if kwargs['checked'] == 'true' else False
                action.setChecked(
                    checked
                )
        
        action.setShortcut(shortcut)
        action.setShortcutContext(Qt.WidgetWithChildrenShortcut)
        
        if 'wrapped' in kwargs and kwargs['wrapped'] is False:
            action.triggered.connect(callback)
        else:
            action.triggered.connect(self.__wrapper(callback))
        
        self.addAction(action)
        self.menu.addAction(action)
        
    def add_separator(self):
        """Simple abstraction of self.context_menu.addSeparator()"""
        self.menu.addSeparator()

    def __wrapper(self, callback):
        def __new_function():
            """
            __new_function représente la forme de tous les callbacks connecté
            à une action pour pouvoir utiliser les raccourcis en même temps que
            le menu contextuel.
            """
            action = self.sender()
            callback(self, action)
        return __new_function