Exemple #1
0
    def generateNodeSearchActions(self, txt, menu, mousemenu):

        # user query
        txt = txt.lower()

        # NODE SEARCH
        # search using txt string
        sortedMods = []
        if len(txt) > 2:  # match anywhere in name
            for node in list(self._known_GPI_nodes.values()):
                if node.name.lower().find(txt) > -1:
                    sortedMods.append(node)
        else:  # only match from start of name
            for node in list(self._known_GPI_nodes.values()):
                if node.name.lower().startswith(txt):
                    sortedMods.append(node)
        sortedMods = sorted(sortedMods, key=lambda x: x.name.lower())

        # create actions and add them to the menu
        for node in sortedMods:

            a = QtGui.QAction(node.name+" (" + node.thrd_sec + ")", self._parent, statusTip="Click to instantiate the \'"+str(node.name)+"\' node.")
            s = {'subsig': node}

            # Somehow this lambda or the way this signal is connected, the
            # s-dict is fully copied which is required to pass the correct
            # mod name.
            self._parent.connect(a, QtCore.SIGNAL("triggered()"),
                    lambda who=s: self.addNodeAndCloseMouseMenu(who, menu, mousemenu))
            menu.addAction(a)


        # NETWORK SEARCH
        # search using txt string
        if True:
            sortedMods= []
            if len(txt) > 2:
                for net in list(self._known_GPI_networks.values()):
                    if net.name.lower().find(txt) > -1:
                        sortedMods.append(net)

            else:
                for net in list(self._known_GPI_networks.values()):
                    if net.name.lower().startswith(txt):
                        sortedMods.append(net)
            sortedMods = sorted(sortedMods, key=lambda x: x.name.lower())

            if len(sortedMods):
                menu.addSeparator()

            # create actions and add them to the menu
            for net in sortedMods:
                a = QtGui.QAction(net.name+" (net) (" + net.thrd_sec + ")", self._parent, statusTip="Click to instantiate the \'"+str(net.name)+"\' network.")
                s = {'sig': 'load', 'subsig': 'net', 'path': net.fullpath}
                self._parent.connect(a, QtCore.SIGNAL("triggered()"),
                        lambda who=s: self.addNodeAndCloseMouseMenu(who, menu, mousemenu))
                menu.addAction(a)
Exemple #2
0
    def createActions(self):
        self.renderIntoPixmapAct = QtGui.QAction("&Render into Pixmap...",
                                                 self, shortcut="Ctrl+R", triggered=self.renderIntoPixmap)

        self.grabFrameBufferAct = QtGui.QAction("&Grab Frame Buffer", self,
                                                shortcut="Ctrl+G", triggered=self.grabFrameBuffer)

        self.clearPixmapAct = QtGui.QAction("&Clear Pixmap", self,
                                            shortcut="Ctrl+L", triggered=self.clearPixmap)

        self.exitAct = QtGui.QAction("E&xit", self, shortcut="Ctrl+Q",
                                     triggered=self.close)

        self.aboutAct = QtGui.QAction("&About", self, triggered=self.about)

        self.aboutQtAct = QtGui.QAction("About &Qt", self,
                                        triggered=QtGui.qApp.aboutQt)
Exemple #3
0
    def generateLibMenus(self):
        # default menu if no libraries are found
        numnodes = len(list(self._known_GPI_nodes.keys()))
        if numnodes == 0:
            self._lib_menus['No Nodes Found'] = QtGui.QMenu('No Nodes Found')
            buf = 'Check your ~/.gpirc for the correct LIB_DIRS.'
            act = QtGui.QAction(buf, self._parent, triggered = self.openLIBDIRSHelp)
            self._lib_menus['No Nodes Found'].addAction(act)

            for m in sorted(list(self._lib_menus.keys()), key=lambda x: x.lower()):
                mm = self._lib_menus[m]
                mm.setTearOffEnabled(False)
                self._lib_menu.append(mm)

            return

        # NODE MENU
        # setup libs using node id. ex: core.mathematics.sum
        # the ids of
        for k in sorted(self._known_GPI_nodes.keys(), key=lambda x: x.lower()):
            node = self._known_GPI_nodes.get(k)
            if node.third not in self._lib_menus:
                #self._lib_menus[node.third] = QtGui.QMenu(node.third.capitalize())
                self._lib_menus[node.third] = QtGui.QMenu(node.third)
                self._lib_menus[node.third].setTearOffEnabled(True)

            if node.thrd_sec not in self._lib_second:
                self._lib_second[node.thrd_sec] = QtGui.QMenu(node.second)
                self._lib_second[node.thrd_sec].setTearOffEnabled(True)
                ma = self._lib_menus[node.third].addMenu(self._lib_second[node.thrd_sec])

            sm = self._lib_second[node.thrd_sec]

            # TODO: try setting up hotkeys/shortcuts for specific nodes
            a = QtGui.QAction(node.name, self._parent, statusTip="Click to instantiate the \'"+str(node.name)+"\' node.")
            s = {'subsig': node}
            self._parent.connect(a, QtCore.SIGNAL("triggered()"),
                        lambda who=s: self._parent.addNodeRun(who))
            sm.addAction(a)

        # NETWORK MENU
        for sm in list(self._lib_second.values()):
            sm.addSeparator()

        for k in sorted(list(self._known_GPI_networks.keys()), key=lambda x: x.lower()):
            net = self._known_GPI_networks.get(k)
            if net.third not in self._lib_menus:
                #self._lib_menus[net.third] = QtGui.QMenu(net.third.capitalize())
                self._lib_menus[net.third] = QtGui.QMenu(net.third)
                self._lib_menus[net.third].setTearOffEnabled(True)

            if net.thrd_sec not in self._lib_second:
                self._lib_second[net.thrd_sec] = QtGui.QMenu(net.second)
                self._lib_second[net.thrd_sec].setTearOffEnabled(True)
                self._lib_menus[net.third].addMenu(self._lib_second[node.thrd_sec])

            sm = self._lib_second[net.thrd_sec]
            a = QtGui.QAction(net.name + ' (net)', self._parent, statusTip="Click to instantiate the \'"+str(net.name)+"\' network.")
            s = {'sig': 'load', 'subsig': 'net', 'path': net.fullpath}
            self._parent.connect(a, QtCore.SIGNAL("triggered()"),
                        lambda who=s: self._parent.addNodeRun(who))
            sm.addAction(a)

        for m in sorted(list(self._lib_menus.keys()), key=lambda x: x.lower()):
            mm = self._lib_menus[m]
            mm.setTearOffEnabled(True)
            self._lib_menu.append(mm)
Exemple #4
0
    def createMenus(self):

        # STYLE
        #self.styleMenu = QtGui.QMenu("&Style", self)
        #ag = QtGui.QActionGroup(self.styleMenu, exclusive=True)
        #for s in QtGui.QStyleFactory.keys():  # get menu items based on keys
        #    a = ag.addAction(QtGui.QAction(s, self.styleMenu, checkable=True))
        #    self.styleMenu.addAction(a)
        #ag.selected.connect(self.changeStyle)
        #self.menuBar().addMenu(self.styleMenu)

        # FILE
        self.fileMenu = QtGui.QMenu("&File", self)
        fileMenu_newTab = QtGui.QAction("New Tab", self, shortcut="Ctrl+T", triggered=self.addNewCanvasTab)
        self.fileMenu.addAction(fileMenu_newTab)
        self.fileMenu.addAction("Create New Node", self.createNewNode)
        self.menuBar().addMenu(self.fileMenu)

        # CONFIG
        self.configMenu = QtGui.QMenu("&Config", self)
        self.configMenu.addAction("Generate Config File (" +
                                  str(Config.configFilePath()) + ")",
                                  self.generateConfigFile)
        self.configMenu.addAction("Generate User Library (" +
                                  str(Config.userLibPath()) + ")",
                                  self.generateUserLib)
        self.configMenu.addAction("Scan For New Nodes",
                                  self.rescanKnownLibs)

        #self.configMenu.addAction("Rescan Config File (" +
        #                          str(Config.configFilePath()) + ")",
        #                          Config.loadConfigFile)
        self.menuBar().addMenu(self.configMenu)

        # DEBUG
        self.debugMenu = QtGui.QMenu("&Debug")
        ag = QtGui.QActionGroup(self.debugMenu, exclusive=False)

        ## logger output sub-menu
        self.loggerMenu = self.debugMenu.addMenu("Logger Level")
        self._loglevel_debug_act = QtGui.QAction("Debug", self, checkable=True,
                triggered=lambda: self.setLoggerLevel(logging.DEBUG))
        self._loglevel_info_act = QtGui.QAction("Info", self, checkable=True,
                triggered=lambda: self.setLoggerLevel(logging.INFO))

        self._loglevel_node_act = QtGui.QAction("Node", self, checkable=True,
                triggered=lambda: self.setLoggerLevel(logger.GPINODE))

        self._loglevel_warn_act = QtGui.QAction("Warn", self, checkable=True,
                triggered=lambda: self.setLoggerLevel(logging.WARNING))
        self._loglevel_error_act = QtGui.QAction("Error", self, checkable=True,
                triggered=lambda: self.setLoggerLevel(logging.ERROR))
        self._loglevel_critical_act = QtGui.QAction("Critical", self, checkable=True,
                triggered=lambda: self.setLoggerLevel(logging.CRITICAL))
        self.loggerMenuGroup = QtGui.QActionGroup(self)
        self.loggerMenuGroup.addAction(self._loglevel_debug_act)
        self.loggerMenuGroup.addAction(self._loglevel_info_act)
        self.loggerMenuGroup.addAction(self._loglevel_node_act)
        self.loggerMenuGroup.addAction(self._loglevel_warn_act)
        self.loggerMenuGroup.addAction(self._loglevel_error_act)
        self.loggerMenuGroup.addAction(self._loglevel_critical_act)
        self.loggerMenu.addAction(self._loglevel_debug_act)
        self.loggerMenu.addAction(self._loglevel_info_act)
        self.loggerMenu.addAction(self._loglevel_node_act)
        self.loggerMenu.addAction(self._loglevel_warn_act)
        self.loggerMenu.addAction(self._loglevel_error_act)
        self.loggerMenu.addAction(self._loglevel_critical_act)

        # initialize the log level -default
        if Commands.logLevel():
            #self._loglevel_warn_act.setChecked(True)
            self.setLoggerLevel(Commands.logLevel())
            self.setLoggerLevelMenuCheckbox(Commands.logLevel())
        else:
            self._loglevel_warn_act.setChecked(True)
            self.setLoggerLevel(logging.WARNING)

        # console submenu
        #a = ag.addAction(QtGui.QAction("Console", self.debugMenu,
        #        checkable=False))
        #self.connect(a, QtCore.SIGNAL("triggered()"), self.console)
        #self.debugMenu.addAction(a)

        #a = ag.addAction(QtGui.QAction("Debug Info", self.debugMenu, checkable=True))
        #self.debugMenu.addAction(a)
        #ag.selected.connect(self.debugOptions)

        # DEBUG
        self.debugMenu.addAction("Print sys.paths", self.printSysPath)
        self.debugMenu.addAction("Print sys.modules", self.printSysModules)
        self.menuBar().addMenu(self.debugMenu)

        # WINDOW
        self.windowMenu = QtGui.QMenu("Window", self)
        self.windowMenu_closeAct = QtGui.QAction("Close Node Menus (Current Tab)", self, shortcut="Ctrl+X", triggered=self.closeAllNodeMenus)
        self.windowMenu.addAction(self.windowMenu_closeAct)
        self.menuBar().addMenu(self.windowMenu)

        # HELP
        self.helpMenu = QtGui.QMenu("&Help", self)
        aboutAction = self.helpMenu.addAction("&About")
        self.connect(aboutAction, QtCore.SIGNAL("triggered()"), self.about)
        self.checkForUpdate = QtGui.QAction("Check For Updates...", self, triggered=self.openUpdater)
        self.checkForUpdate.setMenuRole(QtGui.QAction.ApplicationSpecificRole)
        self.helpMenu.addAction(self.checkForUpdate)
        self.helpMenu_openDocs = QtGui.QAction("Documentation", self, triggered=self.openWebsite)
        self.helpMenu.addAction(self.helpMenu_openDocs)
        self.helpMenu_openDocs = QtGui.QAction("Examples", self, triggered=self.openExamplesFolder)
        self.helpMenu.addAction(self.helpMenu_openDocs)
        self.menuBar().addMenu(self.helpMenu)