Python QMenu.setIcon方法代码示例

# 需要导入模块: from PyQt5.QtWidgets import QMenu [as 别名]
# 或者: from PyQt5.QtWidgets.QMenu import setIcon [as 别名]
 def createSubMenu(self, menu, view, hitTestResult):
     """
     Public method to create the personal information sub-menu.
     
     @param menu reference to the main menu (QMenu)
     @param view reference to the view (HelpBrowser)
     @param hitTestResult reference to the hit test result
         (QWebHitTestResult)
     """
     self.__view = view
     self.__element = hitTestResult.element()
     
     if not hitTestResult.isContentEditable():
         return
     
     if not self.__loaded:
         self.__loadSettings()
     
     submenu = QMenu(self.tr("Insert Personal Information"), menu)
     submenu.setIcon(UI.PixmapCache.getIcon("pim.png"))
     
     for key, info in sorted(self.__allInfo.items()):
         if info:
             act = submenu.addAction(
                 self.__translations[key], self.__insertData)
             act.setData(info)
     
     submenu.addSeparator()
     submenu.addAction(self.tr("Edit Personal Information"),
                       self.showConfigurationDialog)
     
     menu.addMenu(submenu)
     menu.addSeparator()

# 需要导入模块: from PyQt5.QtWidgets import QMenu [as 别名]
# 或者: from PyQt5.QtWidgets.QMenu import setIcon [as 别名]
def install_shortcuts(obj, actions, ide):
    short = resources.get_shortcut
    for action in actions:
        short_key = action.get("shortcut", None)
        action_data = action.get("action", None)
        connect = action.get("connect", None)
        if connect == "open_project_properties":
            print("\nregistrando ::open_project_properties;  obj:", obj)

        shortcut = None
        item_ui = None
        func = None
        if connect:
            func = getattr(obj, connect, None)

        if short_key and not action_data:
            if isinstance(short_key, QKeySequence):
                shortcut = QShortcut(short_key, ide)
            else:
                shortcut = QShortcut(short(short_key), ide)
            shortcut.setContext(Qt.ApplicationShortcut)
            if isinstance(func, collections.Callable):
                shortcut.activated.connect(func)
        if action_data:
            is_menu = action_data.get('is_menu', False)
            if is_menu:
                item_ui = QMenu(action_data['text'], ide)
            else:
                item_ui = QAction(action_data['text'], ide)
                object_name = "%s.%s" % (obj.__class__.__name__, connect)
                item_ui.setObjectName(object_name)
            image_name = action_data.get('image', None)
            section = action_data.get('section', None)
            weight = action_data.get('weight', None)
            keysequence = action_data.get('keysequence', None)
            if image_name:
                if isinstance(image_name, int):
                    icon = ide.style().standardIcon(image_name)
                    item_ui.setIcon(icon)
                elif isinstance(image_name, str):
                    icon = QIcon(":img/" + image_name)
                    item_ui.setIcon(icon)
            if short_key and not is_menu:
                item_ui.setShortcut(short(short_key))
                item_ui.setShortcutContext(Qt.ApplicationShortcut)
            elif keysequence and not is_menu:
                item_ui.setShortcut(short(keysequence))
                item_ui.setShortcutContext(Qt.ApplicationShortcut)
            if isinstance(func, collections.Callable) and not is_menu:
                item_ui.triggered['bool'].connect(lambda s, f=func: f())
            if section and section[0] is not None and weight:
                ide.register_menuitem(item_ui, section, weight)
                if image_name and not is_menu:
                    ide.register_toolbar(item_ui, section, weight)

        if short_key and shortcut:
            ide.register_shortcut(short_key, shortcut, item_ui)

# 需要导入模块: from PyQt5.QtWidgets import QMenu [as 别名]
# 或者: from PyQt5.QtWidgets.QMenu import setIcon [as 别名]
    def createStandardContextMenu(self):
        popup_menu = QTextEdit.createStandardContextMenu(self)

        if not self.spellcheck:
            return popup_menu

        # Select the word under the cursor.
        # But only if there is no selection (otherwise it's impossible to select more text to copy/cut)
        cursor = self.textCursor()
        if not cursor.hasSelection():
            cursor.select(QTextCursor.WordUnderCursor)
            self.setTextCursor(cursor)

        # Check if the selected word is misspelled and offer spelling
        # suggestions if it is.
        if self._dict and cursor.hasSelection():
            text = str(cursor.selectedText())
            valid = self._dict.check(text)
            selectedWord = cursor.selectedText()
            if not valid:
                spell_menu = QMenu(self.tr('Spelling Suggestions'), self)
                spell_menu.setIcon(F.themeIcon("spelling"))
                for word in self._dict.suggest(text):
                    action = self.SpellAction(word, spell_menu)
                    action.correct.connect(self.correctWord)
                    spell_menu.addAction(action)
                # Only add the spelling suggests to the menu if there are
                # suggestions.
                if len(spell_menu.actions()) != 0:
                    popup_menu.insertSeparator(popup_menu.actions()[0])
                    # Adds: add to dictionary
                    addAction = QAction(self.tr("&Add to dictionary"), popup_menu)
                    addAction.setIcon(QIcon.fromTheme("list-add"))
                    addAction.triggered.connect(self.addWordToDict)
                    addAction.setData(selectedWord)
                    popup_menu.insertAction(popup_menu.actions()[0], addAction)
                    # Adds: suggestions
                    popup_menu.insertMenu(popup_menu.actions()[0], spell_menu)
                    # popup_menu.insertSeparator(popup_menu.actions()[0])

            # If word was added to custom dict, give the possibility to remove it
            elif valid and self._dict.is_added(selectedWord):
                popup_menu.insertSeparator(popup_menu.actions()[0])
                # Adds: remove from dictionary
                rmAction = QAction(self.tr("&Remove from custom dictionary"), popup_menu)
                rmAction.setIcon(QIcon.fromTheme("list-remove"))
                rmAction.triggered.connect(self.rmWordFromDict)
                rmAction.setData(selectedWord)
                popup_menu.insertAction(popup_menu.actions()[0], rmAction)

        return popup_menu

# 需要导入模块: from PyQt5.QtWidgets import QMenu [as 别名]
# 或者: from PyQt5.QtWidgets.QMenu import setIcon [as 别名]
    def menu(self, target):
        """Return a submenu for use in an Extensions menu,
        or None if there should be no entry for the given target.
        target may be 'tools' for the main Tools=>Extensions menu,
        or a known keyword for one of the context menus (see
        actions.ExtensionActionCollection.__init__ for the available keys).

        If the target is 'tools' and the extension exports a Panel
        then this will be inserted at the top of the menu, otherwise
        only the action list will be used to create the menu.

        actions.ExtensionActionCollection.set_menu_action_list() is used
        to define the various menu structures that can include 'flat'
        actions and hierarchical submenus.
        """

        def add_action_or_submenu(m, entry):
            if isinstance(entry, QMenu):
                m.addMenu(entry)
            else:
                m.addAction(entry)

        m = self._menus.get(target, None)
        if not m:
            # Menu is not cached already, create it
            actions = self.action_collection().menu_actions(target)
            if target != 'tools' and not actions:
                # empty context menu
                return None
            panel = self.panel()
            # An extension without at least one action or panel is invalid
            if not (panel or actions):
                m = QMenu(_("Invalid extension menu: {}".format(
                    self.display_name())))
                return m

            # finally create the menu
            m = self._menus[target] = QMenu(
                self.display_name(), self.mainwindow())
            if self.has_icon():
                m.setIcon(self.icon())
            if panel and target == 'tools':
                panel.toggleViewAction().setText(_("&Tool Panel"))
                m.addAction(panel.toggleViewAction())
                if actions:
                    m.addSeparator()
            for entry in actions:
                add_action_or_submenu(m, entry)
        return m

# 需要导入模块: from PyQt5.QtWidgets import QMenu [as 别名]
# 或者: from PyQt5.QtWidgets.QMenu import setIcon [as 别名]
 def initMenu(self, mainMenu):
     """
     Public method to generate the extension menu.
     
     @param mainMenu reference to the main menu (QMenu)
     @return populated menu (QMenu)
     """
     menu = QMenu(self.menuTitle(), mainMenu)
     menu.setIcon(UI.PixmapCache.getIcon("changesetSign.png"))
     menu.setTearOffEnabled(True)
     
     menu.addAction(self.hgGpgListAct)
     menu.addAction(self.hgGpgVerifyAct)
     menu.addAction(self.hgGpgSignAct)
     
     return menu

# 需要导入模块: from PyQt5.QtWidgets import QMenu [as 别名]
# 或者: from PyQt5.QtWidgets.QMenu import setIcon [as 别名]
 def initMenu(self, mainMenu):
     """
     Public method to generate the extension menu.
     
     @param mainMenu reference to the main menu (QMenu)
     @return populated menu (QMenu)
     """
     menu = QMenu(self.menuTitle(), mainMenu)
     menu.setIcon(UI.PixmapCache.getIcon("vcsUpdate.png"))
     menu.setTearOffEnabled(True)
     
     menu.addAction(self.hgFetchAct)
     
     menu.aboutToShow.connect(self.__aboutToShowMenu)
     
     return menu

# 需要导入模块: from PyQt5.QtWidgets import QMenu [as 别名]
# 或者: from PyQt5.QtWidgets.QMenu import setIcon [as 别名]
    def customMenu(self, position):
        menu = QMenu('Menu')
        fav_menu = QMenu('Favourites')
        px = get16Pixmap('star.png')
        hasFavourites = False

        fav_menu.setIcon(QIcon(px))

        for action in self.actions():
            if isinstance(action, PaPIFavAction):
                fav_action = QAction(action.text(), self)
                px = get16Pixmap('delete.png')
                fav_action.setIcon(QIcon(px))
                fav_action.triggered.connect(lambda ignore, p=action: self.removeFavouritePlugin(p))

                fav_menu.addAction(fav_action)
                hasFavourites = True

        menu.addMenu(fav_menu)

        if hasFavourites:
            menu.exec_(self.mapToGlobal(position))

# 需要导入模块: from PyQt5.QtWidgets import QMenu [as 别名]
# 或者: from PyQt5.QtWidgets.QMenu import setIcon [as 别名]
class MainWindow(QSystemTrayIcon):

    """Main widget for UnicodEmoticons,not really a window since not needed."""

    def __init__(self, icon, parent=None):
        """Tray icon main widget."""
        super(MainWindow, self).__init__(icon, parent)
        log.debug("Iniciando {}.".format(__doc__))
        self.setIcon(icon)
        self.setToolTip(__doc__ + "\nPick 1 Emoticon, use CTRL+V to Paste it!")
        self.traymenu = QMenu("Emoticons")
        self.traymenu.addAction("Emoticons").setDisabled(True)
        self.traymenu.setIcon(icon)
        self.traymenu.addSeparator()
        self.activated.connect(self.click_trap)
        # menus
        list_of_labels = sorted(UNICODEMOTICONS.keys())
        menu0 = self.traymenu.addMenu(list_of_labels[0].title())
        menu1 = self.traymenu.addMenu(list_of_labels[1].title())
        menu2 = self.traymenu.addMenu(list_of_labels[2].title())
        menu3 = self.traymenu.addMenu(list_of_labels[3].title())
        menu4 = self.traymenu.addMenu(list_of_labels[4].title())
        menu5 = self.traymenu.addMenu(list_of_labels[5].title())
        menu6 = self.traymenu.addMenu(list_of_labels[6].title())
        menu7 = self.traymenu.addMenu(list_of_labels[7].title())
        menu8 = self.traymenu.addMenu(list_of_labels[8].title())
        menu9 = self.traymenu.addMenu(list_of_labels[9].title())
        menu10 = self.traymenu.addMenu(list_of_labels[10].title())
        menu11 = self.traymenu.addMenu(list_of_labels[11].title())
        menu12 = self.traymenu.addMenu(list_of_labels[12].title())
        menu13 = self.traymenu.addMenu(list_of_labels[13].title())
        menu14 = self.traymenu.addMenu(list_of_labels[14].title())
        menu15 = self.traymenu.addMenu(list_of_labels[15].title())
        menu16 = self.traymenu.addMenu(list_of_labels[16].title())
        menu17 = self.traymenu.addMenu(list_of_labels[17].title())
        menu18 = self.traymenu.addMenu(list_of_labels[18].title())
        menu19 = self.traymenu.addMenu(list_of_labels[19].title())
        menu20 = self.traymenu.addMenu(list_of_labels[20].title())
        menu21 = self.traymenu.addMenu(list_of_labels[21].title())
        menu22 = self.traymenu.addMenu(list_of_labels[22].title())
        menu23 = self.traymenu.addMenu(list_of_labels[23].title())
        menu24 = self.traymenu.addMenu(list_of_labels[24].title())
        menu25 = self.traymenu.addMenu(list_of_labels[25].title())
        menu26 = self.traymenu.addMenu(list_of_labels[26].title())
        menu27 = self.traymenu.addMenu(list_of_labels[27].title())
        menu28 = self.traymenu.addMenu(list_of_labels[28].title())
        menu29 = self.traymenu.addMenu(list_of_labels[29].title())
        menu30 = self.traymenu.addMenu(list_of_labels[30].title())
        menu31 = self.traymenu.addMenu(list_of_labels[31].title())
        menu32 = self.traymenu.addMenu(list_of_labels[32].title())
        self.traymenu.addSeparator()
        menuhtml0 = self.traymenu.addMenu("HTML5 Code")
        log.debug("Building Emoticons SubMenus.")
        for index, item in enumerate((
            menu0, menu1, menu2, menu3, menu4, menu5, menu6, menu7, menu8,
            menu9, menu10, menu11, menu12, menu13, menu14, menu15, menu16,
            menu17, menu18, menu19, menu20, menu21, menu22, menu23, menu24,
            menu25, menu26, menu27, menu28, menu29, menu30, menu31, menu32,
                )):
            item.setStyleSheet(("font-size:25px;padding:0;margin:0;border:0;"
                                "font-family:Oxygen;menu-scrollable:1;"))
            item.setFont(QFont('Oxygen', 25))
            self.build_submenu(UNICODEMOTICONS[list_of_labels[index]], item)
        # html entities
        added_html_entities = []
        menuhtml0.setStyleSheet("font-size:25px;padding:0;margin:0;border:0;")
        for html_char in tuple(sorted(entities.html5.items())):
            if html_char[1] in HTMLS.strip().replace("\n", ""):
                added_html_entities.append(
                    html_char[0].lower().replace(";", ""))
                if not html_char[0].lower() in added_html_entities:
                    action = menuhtml0.addAction(html_char[1])
                    action.hovered.connect(lambda ch=html_char: log.debug(ch))
                    action.triggered.connect(
                        lambda _, ch=html_char[0]:
                            QApplication.clipboard().setText(
                                "&{html_entity}".format(html_entity=ch)))
        self.traymenu.addSeparator()
        # help
        helpMenu = self.traymenu.addMenu("Options...")
        helpMenu.addAction("About Python 3",
                           lambda: open_new_tab('https://python.org'))
        helpMenu.addAction("About Qt 5", lambda: open_new_tab('http://qt.io'))
        helpMenu.addAction("About " + __doc__, lambda: open_new_tab(__url__))
        helpMenu.addSeparator()
        helpMenu.addAction("View Source Code", lambda: open_new_tab(__file__))
        helpMenu.addSeparator()
        helpMenu.addAction("Report Bugs", lambda:
                           open_new_tab(__url__ + '/issues?state=open'))
        helpMenu.addAction("Check for updates", lambda: Downloader())
        helpMenu.addSeparator()
        helpMenu.addAction("Set Icon", self.set_icon)
        helpMenu.addAction("Set UI Style", lambda: open_new_tab(path.join(
            self.get_or_set_config_folder("unicodemoticon"),
            "unicodemoticon.css")))
        self.traymenu.addSeparator()
        self.traymenu.addAction("Quit", lambda: self.close())
        self.setContextMenu(self.traymenu)
        self.show()
        self.add_desktop_files()
#.........这里部分代码省略.........

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

#.........这里部分代码省略.........
                (0.000, 0.000, 0.580, 1.000, _("Ease Out")),
                (0.420, 0.000, 0.580, 1.000, _("Ease In/Out")),

                (0.550, 0.085, 0.680, 0.530, _("Ease In (Quad)")),
                (0.550, 0.055, 0.675, 0.190, _("Ease In (Cubic)")),
                (0.895, 0.030, 0.685, 0.220, _("Ease In (Quart)")),
                (0.755, 0.050, 0.855, 0.060, _("Ease In (Quint)")),
                (0.470, 0.000, 0.745, 0.715, _("Ease In (Sine)")),
                (0.950, 0.050, 0.795, 0.035, _("Ease In (Expo)")),
                (0.600, 0.040, 0.980, 0.335, _("Ease In (Circ)")),
                (0.600, -0.280, 0.735, 0.045, _("Ease In (Back)")),

                (0.250, 0.460, 0.450, 0.940, _("Ease Out (Quad)")),
                (0.215, 0.610, 0.355, 1.000, _("Ease Out (Cubic)")),
                (0.165, 0.840, 0.440, 1.000, _("Ease Out (Quart)")),
                (0.230, 1.000, 0.320, 1.000, _("Ease Out (Quint)")),
                (0.390, 0.575, 0.565, 1.000, _("Ease Out (Sine)")),
                (0.190, 1.000, 0.220, 1.000, _("Ease Out (Expo)")),
                (0.075, 0.820, 0.165, 1.000, _("Ease Out (Circ)")),
                (0.175, 0.885, 0.320, 1.275, _("Ease Out (Back)")),

                (0.455, 0.030, 0.515, 0.955, _("Ease In/Out (Quad)")),
                (0.645, 0.045, 0.355, 1.000, _("Ease In/Out (Cubic)")),
                (0.770, 0.000, 0.175, 1.000, _("Ease In/Out (Quart)")),
                (0.860, 0.000, 0.070, 1.000, _("Ease In/Out (Quint)")),
                (0.445, 0.050, 0.550, 0.950, _("Ease In/Out (Sine)")),
                (1.000, 0.000, 0.000, 1.000, _("Ease In/Out (Expo)")),
                (0.785, 0.135, 0.150, 0.860, _("Ease In/Out (Circ)")),
                (0.680, -0.550, 0.265, 1.550, _("Ease In/Out (Back)"))
            ]

            bezier_icon = QIcon(QPixmap(os.path.join(info.IMAGES_PATH, "keyframe-%s.png" % openshot.BEZIER)))
            linear_icon = QIcon(QPixmap(os.path.join(info.IMAGES_PATH, "keyframe-%s.png" % openshot.LINEAR)))
            constant_icon = QIcon(QPixmap(os.path.join(info.IMAGES_PATH, "keyframe-%s.png" % openshot.CONSTANT)))

            # Add menu options for keyframes
            menu = QMenu(self)
            if points > 1:
                # Menu for more than 1 point
                Bezier_Menu = QMenu(_("Bezier"), self)
                Bezier_Menu.setIcon(bezier_icon)
                for bezier_preset in bezier_presets:
                    preset_action = Bezier_Menu.addAction(bezier_preset[4])
                    preset_action.triggered.connect(partial(self.Bezier_Action_Triggered, bezier_preset))
                menu.addMenu(Bezier_Menu)
                Linear_Action = menu.addAction(_("Linear"))
                Linear_Action.setIcon(linear_icon)
                Linear_Action.triggered.connect(self.Linear_Action_Triggered)
                Constant_Action = menu.addAction(_("Constant"))
                Constant_Action.setIcon(constant_icon)
                Constant_Action.triggered.connect(self.Constant_Action_Triggered)
                menu.addSeparator()
                Insert_Action = menu.addAction(_("Insert Keyframe"))
                Insert_Action.triggered.connect(self.Insert_Action_Triggered)
                Remove_Action = menu.addAction(_("Remove Keyframe"))
                Remove_Action.triggered.connect(self.Remove_Action_Triggered)
                menu.popup(QCursor.pos())
            elif points == 1:
                # Menu for a single point
                Insert_Action = menu.addAction(_("Insert Keyframe"))
                Insert_Action.triggered.connect(self.Insert_Action_Triggered)
                Remove_Action = menu.addAction(_("Remove Keyframe"))
                Remove_Action.triggered.connect(self.Remove_Action_Triggered)
                menu.popup(QCursor.pos())

            if self.choices:
                # Menu for choices
                for choice in self.choices:
                    if type(choice["value"]) != list:
                        # Add root choice items
                        Choice_Action = menu.addAction(_(choice["name"]))
                        Choice_Action.setData(choice["value"])
                        Choice_Action.triggered.connect(self.Choice_Action_Triggered)
                    else:
                        # Add sub-choice items (for nested choice lists)
                        # Divide into smaller QMenus (since large lists cover the entire screen)
                        # For example: Transitions -> 1 -> sub items
                        SubMenu = None
                        SubMenuRoot = QMenu(_(choice["name"]), self)
                        SubMenuSize = 24
                        SubMenuNumber = 0
                        for sub_choice in choice["value"]:
                            if len(choice["value"]) > SubMenuSize:
                                if not SubMenu or len(SubMenu.children()) == SubMenuSize or sub_choice == choice["value"][-1]:
                                    SubMenuNumber += 1
                                    if SubMenu:
                                        SubMenuRoot.addMenu(SubMenu)
                                    SubMenu = QMenu(str(SubMenuNumber), self)
                                Choice_Action = SubMenu.addAction(_(sub_choice["name"]))
                            else:
                                Choice_Action = SubMenuRoot.addAction(_(sub_choice["name"]))
                            Choice_Action.setData(sub_choice["value"])
                            subChoiceIcon = sub_choice.get("icon")
                            if subChoiceIcon:
                                Choice_Action.setIcon(subChoiceIcon)
                            Choice_Action.triggered.connect(self.Choice_Action_Triggered)
                        menu.addMenu(SubMenuRoot)

                # Show choice menu
                menu.popup(QCursor.pos())

# 需要导入模块: from PyQt5.QtWidgets import QMenu [as 别名]
# 或者: from PyQt5.QtWidgets.QMenu import setIcon [as 别名]
class MainWindow(QSystemTrayIcon):

    """Main widget for Vacap, not really a window since not needed."""

    def __init__(self, icon, parent=None):
        """Tray icon main widget."""
        super(MainWindow, self).__init__(icon, parent)
        log.info("Iniciando el programa Vacap...")
        global config
        get_or_set_config()
        self.origins = config["MAKE_BACKUP_FROM"]
        self.destination = config["SAVE_BACKUP_TO"]
        self.setToolTip(__doc__ + "\n1 Click y 'Hacer Backup'!")
        self.traymenu = QMenu("Backup")
        self.traymenu.setIcon(icon)
        self.traymenu.addAction(icon, "Hacer Backup", lambda: self.backup())
        self.traymenu.setFont(QFont("Verdana", 10, QFont.Bold))
        self.setContextMenu(self.traymenu)
        self.activated.connect(self.click_trap)
        self.contextMenu().setStyleSheet(CSS_STYLE)
        add_to_startup()
        log.info("Inicio el programa Vacap.")
        self.show()
        self.showMessage("Vacap", "Copia de Seguridad Backup funcionando.")
        if config["MAKE_BACKUP_ON_STARTUP"]:
            log.info("Running Backup on Start-Up.")
            self.backup()
        if config["MAKE_BACKUP_AT_THIS_HOUR"]:
            log.info("Running Automatic Backup by Scheduled Hours.")
            self.timer = QTimer(self)
            self.timer.timeout.connect(self.run_backup_by_hour)
            self.timer.start(3600000)  # 1 Hour on Milliseconds

    def click_trap(self, value):
        """Trap the mouse tight click."""
        if value == self.Trigger:  # left click
            self.traymenu.exec_(QCursor.pos())

    def run_backup_by_hour(self):
        """Run Automatic Backup if the actual Hour equals Scheduled Hour."""
        if int(datetime.now().hour) == int(config["MAKE_BACKUP_AT_THIS_HOUR"]):
            log.info("Running Automatic Backup by Scheduled Hour.")
            _day = day_name[datetime.today().weekday()].lower()
            if config["MAKE_BACKUP_ON_WEEK_DAY"] != _day:
                log.info("Skipping Automatic Backup by Scheduled Week Day.")
                return  # if backup on weeke day not equals today, then return
            self.backup()

    def check_destination_folder(self):
        """Check destination folder."""
        log.info("Checking destination folder {}.".format(self.destination))
        # What if destination folder been removed.
        if not os.path.isdir(self.destination):
            log.critical("Folder {} does not exist, saving to {}!.".format(
                self.destination, gettempdir()))
            self.destination = gettempdir()
        # What if destination folder is not Writable by the user.
        if not os.access(self.destination, os.W_OK):
            log.critical("Folder {} permission denied (Not Writable).".format(
                self.destination))
            self.destination = gettempdir()
        # get date and time for folder name
        t = datetime.now().isoformat().lower().split(".")[0].replace(":", "_")
        # prepare a new folder with date-time inside destination folder
        log.info("Folder {} is OK for BackUp.".format(self.destination))
        self.destination = os.path.join(self.destination, t)
        if not os.path.isdir(self.destination):
            os.mkdir(self.destination)
            log.info("Created New Folder {}.".format(self.destination))

    def check_origins_folders(self):
        """Check origin folders."""
        log.info("Checking origins folders {}.".format(self.origins))
        # remove repeated items if any
        self.origins = list(set(self.origins))
        for folder_to_check in self.origins:
            # if folder is not a folder
            if not os.path.isdir(folder_to_check):
                log.critical("Folder {} dont exist.".format(folder_to_check))
                self.origins.remove(folder_to_check)
            # if folder is not readable
            elif not os.access(folder_to_check, os.R_OK):
                log.critical("Folder {} not Readable.".format(folder_to_check))
                self.origins.remove(folder_to_check)
            else:  # folder is ok
                log.info("Folder {} is OK to BackUp.".format(folder_to_check))
        return bool(len(self.origins))

    def backup(self):
        """Backup desde MAKE_BACKUP_FROM hacia SAVE_BACKUP_TO."""
        if not config["MAKE_BACKUP_WHEN_RUNNING_ON_BATTERY"]:
            if windows_is_running_on_battery():  # if is windows on battery ?
                return  # if on battery and should not make backup, then return
        self.contextMenu().setDisabled(True)
        self.check_destination_folder()
        if self.check_origins_folders():
            log.info("Starting to BackUp folders...")
            Backuper(destination=self.destination, origins=self.origins)
            self.contextMenu().setDisabled(False)
            self.showMessage("Vacap", "Copia de Seguridad Backup Termino bien")
#.........这里部分代码省略.........

# 需要导入模块: from PyQt5.QtWidgets import QMenu [as 别名]
# 或者: from PyQt5.QtWidgets.QMenu import setIcon [as 别名]
class DictionariesWidget(QWidget, Ui_DictionariesWidget):

    add_translation = pyqtSignal(QVariant)

    def __init__(self, *args, **kwargs):
        super(DictionariesWidget, self).__init__(*args, **kwargs)
        self.setupUi(self)
        engine = QApplication.instance().engine
        self._engine = engine
        self._states = []
        self._updating = False
        self._config_dictionaries = {}
        self._loaded_dictionaries = {}
        self._reverse_order = False
        for action in (
            self.action_Undo,
            self.action_EditDictionaries,
            self.action_RemoveDictionaries,
            self.action_MoveDictionariesUp,
            self.action_MoveDictionariesDown,
        ):
            action.setEnabled(False)
        # Toolbar.
        self.layout().addWidget(ToolBar(
            self.action_Undo,
            None,
            self.action_EditDictionaries,
            self.action_RemoveDictionaries,
            self.action_AddDictionaries,
            self.action_AddTranslation,
            None,
            self.action_MoveDictionariesUp,
            self.action_MoveDictionariesDown,
        ))
        # Add menu.
        self.menu_AddDictionaries = QMenu(self.action_AddDictionaries.text())
        self.menu_AddDictionaries.setIcon(self.action_AddDictionaries.icon())
        self.menu_AddDictionaries.addAction(_(
            _('Open dictionaries'),
        )).triggered.connect(self._add_existing_dictionaries)
        self.menu_AddDictionaries.addAction(_(
            _('New dictionary'),
        )).triggered.connect(self._create_new_dictionary)
        self.table.supportedDropActions = self._supported_drop_actions
        self.table.dragEnterEvent = self._drag_enter_event
        self.table.dragMoveEvent = self._drag_move_event
        self.table.dropEvent = self._drop_event
        engine.signal_connect('config_changed', self.on_config_changed)
        engine.signal_connect('dictionaries_loaded', self.on_dictionaries_loaded)

    def setFocus(self):
        self.table.setFocus()

    def on_dictionaries_loaded(self, loaded_dictionaries):
        self._update_dictionaries(loaded_dictionaries=loaded_dictionaries,
                                  record=False, save=False)

    def on_config_changed(self, config_update):
        update_kwargs = {}
        if 'dictionaries' in config_update:
            update_kwargs.update(
                config_dictionaries=config_update['dictionaries'],
                record=False, save=False, reset_undo=True
            )
        if 'classic_dictionaries_display_order' in config_update:
            update_kwargs.update(
                reverse_order=config_update['classic_dictionaries_display_order'],
                record=False, save=False,
            )
        if update_kwargs:
            self._update_dictionaries(**update_kwargs)

    def _update_dictionaries(self, config_dictionaries=None, loaded_dictionaries=None,
                             reverse_order=None, record=True, save=True,
                             reset_undo=False, keep_selection=True):
        if reverse_order is None:
            reverse_order = self._reverse_order
        if config_dictionaries is None:
            config_dictionaries = self._config_dictionaries
        if config_dictionaries == self._config_dictionaries and \
           reverse_order == self._reverse_order and \
           loaded_dictionaries is None:
            return
        if save:
            self._engine.config = { 'dictionaries': config_dictionaries }
        if record:
            self._states.append(self._config_dictionaries)
            self.action_Undo.setEnabled(True)
        if keep_selection:
            selected = [
                self._config_dictionaries[row].path
                for row in self._get_selection()
            ]
        self._config_dictionaries = config_dictionaries
        if loaded_dictionaries is None:
            loaded_dictionaries = self._loaded_dictionaries
        else:
            self._loaded_dictionaries = loaded_dictionaries
        self._reverse_order = reverse_order
        self._updating = True
#.........这里部分代码省略.........

# 需要导入模块: from PyQt5.QtWidgets import QMenu [as 别名]
# 或者: from PyQt5.QtWidgets.QMenu import setIcon [as 别名]
def install_shortcuts(obj, actions, ide):
    short = resources.get_shortcut
    for action in actions:
        short_key = action.get("shortcut", None)
        action_data = action.get("action", None)
        connect = action.get("connect", None)
        shortcut = None
        item_ui = None
        func = None
        if connect is not None:
            func = getattr(obj, connect, None)

        if short_key and not action_data:
            if isinstance(short_key, QKeySequence):
                shortcut = QShortcut(short_key, ide)
            else:
                if short(short_key) is None:
                    logger.warning("Not shorcut for %s" % short_key)
                    continue
                shortcut = QShortcut(short(short_key), ide)
            shortcut.setContext(Qt.ApplicationShortcut)
            if isinstance(func, collections.Callable):
                shortcut.activated.connect(func)
        if action_data:
            is_menu = action_data.get('is_menu', False)
            if is_menu:
                item_ui = QMenu(action_data['text'], ide)
            else:
                item_ui = QAction(action_data['text'], ide)
                object_name = "%s.%s" % (obj.__class__.__name__, connect)
                item_ui.setObjectName(object_name)
                # FIXME: Configurable
                item_ui.setIconVisibleInMenu(False)
            image_name = action_data.get('image', None)
            section = action_data.get('section', None)
            weight = action_data.get('weight', None)
            keysequence = action_data.get('keysequence', None)
            if image_name:
                if isinstance(image_name, int):
                    icon = ide.style().standardIcon(image_name)
                    item_ui.setIcon(icon)
                elif isinstance(image_name, str):
                    if image_name.startswith("/home"):
                        icon = QIcon(image_name)
                    else:
                        icon = QIcon(":img/" + image_name)
                    item_ui.setIcon(icon)
            if short_key and not is_menu:
                if short(short_key) is None:
                    logger.warning("Not shortcut for %s" % short_key)
                    continue
                item_ui.setShortcut(short(short_key))
                # Add tooltip with append shortcut
                item_ui.setToolTip(
                    tooltip_with_shortcut(item_ui.text(), short(short_key)))
                item_ui.setShortcutContext(Qt.ApplicationShortcut)
            elif keysequence and not is_menu:
                item_ui.setShortcut(short(keysequence))
                item_ui.setShortcutContext(Qt.ApplicationShortcut)
            if isinstance(func, collections.Callable) and not is_menu:
                item_ui.triggered.connect(lambda _, func=func: func())
            if section and section[0] is not None and weight:
                ide.register_menuitem(item_ui, section, weight)
                if image_name and not is_menu:
                    ide.register_toolbar(item_ui, section, weight)

        if short_key and shortcut:
            ide.register_shortcut(short_key, shortcut, item_ui)

# 需要导入模块: from PyQt5.QtWidgets import QMenu [as 别名]
# 或者: from PyQt5.QtWidgets.QMenu import setIcon [as 别名]
 def initmenus (self):
     menubar = self.menuBar()
     
     filemenu = menubar.addMenu("&File")
     filemenu.addAction(self.globactions["openfile"])
     filemenu.addAction(self.globactions["newproj"])
     filemenu.addAction(self.globactions["newconv"])
     filemenu.addSeparator()
     filemenu.addAction(self.globactions["save"])
     filemenu.addAction(self.globactions["saveas"])
     filemenu.addSeparator()
     filemenu.addAction(self.globactions["playconv"])
     filemenu.addSeparator()
     filemenu.addAction(self.globactions["close"])
     
     addmenu = QMenu("Add &link...")
     addmenu.addAction(self.actions["pasteclone"])
     addmenu.addAction(self.actions["pastelink"])
     addmenu.addSeparator()
     addmenu.addAction(self.actions["newtalk"])
     addmenu.addAction(self.actions["newresponse"])
     addmenu.addAction(self.actions["newbank"])
     addmenu.addAction(self.actions["newtrigger"])
     addmenu.setIcon(QIcon.fromTheme("insert-object"))
     self.addmenu = addmenu
     
     subnodemenu = QMenu("Add &subnode...")
     subnodemenu.addAction(self.actions["pastesubnode"])
     subnodemenu.addSeparator()
     subnodemenu.addAction(self.actions["newtalksub"])
     subnodemenu.addAction(self.actions["newresponsesub"])
     subnodemenu.addAction(self.actions["newbanksub"])
     subnodemenu.addAction(self.actions["newtriggersub"])
     subnodemenu.setIcon(QIcon.fromTheme("insert-object"))
     self.subnodemenu = subnodemenu
     
     transformmenu = QMenu("Trans&form...")
     transformmenu.addAction(self.actions["nodetobank"])
     transformmenu.addAction(self.actions["banktonode"])
     transformmenu.addAction(self.actions["splitnode"])
     self.transformmenu = transformmenu
     
     undomenu = QMenu("Undo")
     undomenu.setIcon(QIcon.fromTheme("edit-undo"))
     def generateundo ():
         undomenu.clear()
         undo = self.activeview.undohistory
         for i in range(len(undo)):
             action = undo[i]
             item = QAction("%s: %s" % (i+1, action.descr), self)
             item.triggered.connect(self.undofactory(i+1))
             undomenu.addAction(item)
     undomenu.aboutToShow.connect(generateundo)
     self.actions["undo"].setMenu(undomenu)
     
     redomenu = QMenu("Redo")
     redomenu.setIcon(QIcon.fromTheme("edit-redo"))
     def generateredo ():
         redomenu.clear()
         redo = self.activeview.redohistory
         for i in range(len(redo)):
             action = redo[i]
             item = QAction("%s: %s" % (i+1, action.descr), self)
             item.triggered.connect(self.redofactory(i+1))
             redomenu.addAction(item)
     redomenu.aboutToShow.connect(generateredo)
     self.actions["redo"].setMenu(redomenu)
     
     editmenu = menubar.addMenu("&Edit")
     editmenu.addAction(self.actions["undo"])
     editmenu.addAction(self.actions["redo"])
     editmenu.addMenu(addmenu)
     editmenu.addMenu(subnodemenu)
     editmenu.addAction(self.actions["copynode"])
     editmenu.addAction(self.actions["moveup"])
     editmenu.addAction(self.actions["movedown"])
     editmenu.addAction(self.actions["parentswap"])
     editmenu.addAction(self.actions["settemplate"])
     editmenu.addMenu(transformmenu)
     editmenu.addSeparator()
     editmenu.addAction(self.actions["unlinknode"])
     editmenu.addAction(self.actions["unlinkstree"])
     self.editmenu = editmenu
     
     viewmenu = menubar.addMenu("&View")
     viewmenu.addAction(self.globactions["zoomin"])
     viewmenu.addAction(self.globactions["zoomout"])
     viewmenu.addAction(self.globactions["zoomorig"])
     viewmenu.addAction(self.actions["gotoactive"])
     viewmenu.addAction(self.actions["selectreal"])
     viewmenu.addAction(self.actions["collapse"])
     viewmenu.addAction(self.globactions["refresh"])
     
     windowmenu = menubar.addMenu("&Window")
     def generatemenu ():
         windowmenu.clear()
         menu = self.createPopupMenu()
         menu.setTitle("Tools")
         windowmenu.addMenu(menu)
     windowmenu.aboutToShow.connect(generatemenu)

# 需要导入模块: from PyQt5.QtWidgets import QMenu [as 别名]
# 或者: from PyQt5.QtWidgets.QMenu import setIcon [as 别名]
class SystemTrayIcon(QMainWindow):
    def __init__(self, parent=None):
        super(SystemTrayIcon, self).__init__(parent)
        self.setAttribute(Qt.WA_DeleteOnClose)
        self.settings = QSettings()
        self.language = self.settings.value('Language') or ''
        self.temp_decimal_bool = self.settings.value('Decimal') or False
        # initialize the tray icon type in case of first run: issue#42
        self.tray_type = self.settings.value('TrayType') or 'icon&temp'
        cond = conditions.WeatherConditions()
        self.temporary_city_status = False
        self.conditions = cond.trans
        self.clouds = cond.clouds
        self.wind = cond.wind
        self.wind_dir = cond.wind_direction
        self.wind_codes = cond.wind_codes
        self.inerror = False
        self.tentatives = 0
        self.baseurl = 'http://api.openweathermap.org/data/2.5/weather?id='
        self.accurate_url = 'http://api.openweathermap.org/data/2.5/find?q='
        self.forecast_url = ('http://api.openweathermap.org/data/2.5/forecast/'
                             'daily?id=')
        self.day_forecast_url = ('http://api.openweathermap.org/data/2.5/'
                                 'forecast?id=')
        self.wIconUrl = 'http://openweathermap.org/img/w/'
        apikey = self.settings.value('APPID') or ''
        self.appid = '&APPID=' + apikey
        self.forecast_icon_url = self.wIconUrl
        self.timer = QTimer(self)
        self.timer.timeout.connect(self.refresh)
        self.menu = QMenu()
        self.citiesMenu = QMenu(self.tr('Cities'))
        self.tempCityAction = QAction(self.tr('&Temporary city'), self)
        self.refreshAction = QAction(self.tr('&Update'), self)
        self.settingsAction = QAction(self.tr('&Settings'), self)
        self.aboutAction = QAction(self.tr('&About'), self)
        self.exitAction = QAction(self.tr('Exit'), self)
        self.exitAction.setIcon(QIcon(':/exit'))
        self.aboutAction.setIcon(QIcon(':/info'))
        self.refreshAction.setIcon(QIcon(':/refresh'))
        self.settingsAction.setIcon(QIcon(':/configure'))
        self.tempCityAction.setIcon(QIcon(':/tempcity'))
        self.citiesMenu.setIcon(QIcon(':/bookmarks'))
        self.menu.addAction(self.settingsAction)
        self.menu.addAction(self.refreshAction)
        self.menu.addMenu(self.citiesMenu)
        self.menu.addAction(self.tempCityAction)
        self.menu.addAction(self.aboutAction)
        self.menu.addAction(self.exitAction)
        self.settingsAction.triggered.connect(self.config)
        self.exitAction.triggered.connect(qApp.quit)
        self.refreshAction.triggered.connect(self.manual_refresh)
        self.aboutAction.triggered.connect(self.about)
        self.tempCityAction.triggered.connect(self.tempcity)
        self.systray = QSystemTrayIcon()
        self.systray.setContextMenu(self.menu)
        self.systray.activated.connect(self.activate)
        self.systray.setIcon(QIcon(':/noicon'))
        self.systray.setToolTip(self.tr('Searching weather data...'))
        self.notification = ''
        self.notification_temp = 0
        self.notifications_id = ''
        self.systray.show()
        # The dictionnary has to be intialized here. If there is an error
        # the program couldn't become functionnal if the dictionnary is
        # reinitialized in the weatherdata method
        self.weatherDataDico = {}
        # The traycolor has to be initialized here for the case when we cannot
        # reach the tray method (case: set the color at first time usage)
        self.traycolor = ''
        self.refresh()

    def icon_loading(self):
        self.gif_loading = QMovie(":/loading")
        self.gif_loading.frameChanged.connect(self.update_gif)
        self.gif_loading.start()

    def update_gif(self):
        gif_frame = self.gif_loading.currentPixmap()
        self.systray.setIcon(QIcon(gif_frame))

    def manual_refresh(self):
        self.tentatives = 0
        self.refresh()

    def cities_menu(self):
        # Don't add the temporary city in the list
        if self.temporary_city_status:
            return
        self.citiesMenu.clear()
        cities = self.settings.value('CityList') or []
        if type(cities) is str:
            cities = eval(cities)
        try:
            current_city = (self.settings.value('City') + '_' +
                        self.settings.value('Country') + '_' +
                        self.settings.value('ID'))
        except:
            # firsttime run,if clic cancel in setings without any city configured
            pass
#.........这里部分代码省略.........

# 需要导入模块: from PyQt5.QtWidgets import QMenu [as 别名]
# 或者: from PyQt5.QtWidgets.QMenu import setIcon [as 别名]
class MainWindow(QMainWindow):

    """Voice Changer main window."""

    def __init__(self, parent=None):
        super(MainWindow, self).__init__()
        self.statusBar().showMessage("Move Dial to Deform Microphone Voice !.")
        self.setWindowTitle(__doc__)
        self.setMinimumSize(240, 240)
        self.setMaximumSize(480, 480)
        self.resize(self.minimumSize())
        self.setWindowIcon(QIcon.fromTheme("audio-input-microphone"))
        self.tray = QSystemTrayIcon(self)
        self.center()
        QShortcut("Ctrl+q", self, activated=lambda: self.close())
        self.menuBar().addMenu("&File").addAction("Quit", lambda: exit())
        self.menuBar().addMenu("Sound").addAction(
            "STOP !", lambda: call('killall rec', shell=True))
        windowMenu = self.menuBar().addMenu("&Window")
        windowMenu.addAction("Hide", lambda: self.hide())
        windowMenu.addAction("Minimize", lambda: self.showMinimized())
        windowMenu.addAction("Maximize", lambda: self.showMaximized())
        windowMenu.addAction("Restore", lambda: self.showNormal())
        windowMenu.addAction("FullScreen", lambda: self.showFullScreen())
        windowMenu.addAction("Center", lambda: self.center())
        windowMenu.addAction("Top-Left", lambda: self.move(0, 0))
        windowMenu.addAction("To Mouse", lambda: self.move_to_mouse_position())
        # widgets
        group0 = QGroupBox("Voice Deformation")
        self.setCentralWidget(group0)
        self.process = QProcess(self)
        self.process.error.connect(
            lambda: self.statusBar().showMessage("Info: Process Killed", 5000))
        self.control = QDial()
        self.control.setRange(-10, 20)
        self.control.setSingleStep(5)
        self.control.setValue(0)
        self.control.setCursor(QCursor(Qt.OpenHandCursor))
        self.control.sliderPressed.connect(
            lambda: self.control.setCursor(QCursor(Qt.ClosedHandCursor)))
        self.control.sliderReleased.connect(
            lambda: self.control.setCursor(QCursor(Qt.OpenHandCursor)))
        self.control.valueChanged.connect(
            lambda: self.control.setToolTip(f"<b>{self.control.value()}"))
        self.control.valueChanged.connect(
            lambda: self.statusBar().showMessage(
                f"Voice deformation: {self.control.value()}", 5000))
        self.control.valueChanged.connect(self.run)
        self.control.valueChanged.connect(lambda: self.process.kill())
        # Graphic effect
        self.glow = QGraphicsDropShadowEffect(self)
        self.glow.setOffset(0)
        self.glow.setBlurRadius(99)
        self.glow.setColor(QColor(99, 255, 255))
        self.control.setGraphicsEffect(self.glow)
        self.glow.setEnabled(False)
        # Timer to start
        self.slider_timer = QTimer(self)
        self.slider_timer.setSingleShot(True)
        self.slider_timer.timeout.connect(self.on_slider_timer_timeout)
        # an icon and set focus
        QLabel(self.control).setPixmap(
            QIcon.fromTheme("audio-input-microphone").pixmap(32))
        self.control.setFocus()
        QVBoxLayout(group0).addWidget(self.control)
        self.menu = QMenu(__doc__)
        self.menu.addAction(__doc__).setDisabled(True)
        self.menu.setIcon(self.windowIcon())
        self.menu.addSeparator()
        self.menu.addAction(
            "Show / Hide",
            lambda: self.hide() if self.isVisible() else self.showNormal())
        self.menu.addAction("STOP !", lambda: call('killall rec', shell=True))
        self.menu.addSeparator()
        self.menu.addAction("Quit", lambda: exit())
        self.tray.setContextMenu(self.menu)
        self.make_trayicon()

    def run(self):
        """Run/Stop the QTimer."""
        if self.slider_timer.isActive():
            self.slider_timer.stop()
        self.glow.setEnabled(True)
        call('killall rec ; killall play', shell=True)
        self.slider_timer.start(3000)

    def on_slider_timer_timeout(self):
        """Run subprocess to deform voice."""
        self.glow.setEnabled(False)
        value = int(self.control.value()) * 100
        command = f'play -q -V0 "|rec -q -V0 -n -d -R riaa bend pitch {value} "'
        print(f"Voice Deformation Value: {value}")
        print(f"Voice Deformation Command: {command}")
        self.process.start(command)
        if self.isVisible():
            self.statusBar().showMessage("Minimizing to System TrayIcon", 3000)
            print("Minimizing Main Window to System TrayIcon now...")
            sleep(3)
            self.hide()

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