def run(self): # Initiate pipemenu self.menu = struct.PipeMenu(use_cache=self.cfg.printv("use_cache","Alan"), cache="appearance", cache_trigger=(self.cfg.path,"/usr/bin/paranoid")) if self.menu.cache_check(): self.menu.cache_read() else: self.menu.start() # add initial tag # Alias menu.insert() to i() i = self.menu.insert ### Begin! wallpaperadd = core.item(_("Add"), ga.execute("nitrogen-add-wallpaper"), icon="gtk-add") # Item that opens nitrogen-add-wallpaper wallpapermanage = core.item(_("Manage"), ga.execute("nitrogen"), icon="preferences-desktop-wallpaper") # Item that opens nitrogen wallpapermenu = core.menu("wallmenu", _("Wallpaper"), "\n".join((wallpaperadd, wallpapermanage)), icon="preferences-desktop-wallpaper") # Menu that has on it wallpaperadd and wallpapermanage themeselector = core.item(_("Appearance settings"), ga.execute("lxappearance"), icon="preferences-desktop-theme") # Theme selector if os.path.exists("/usr/bin/paranoid"): paranoid = core.item(_("Visual effects"), ga.execute("paranoid"), icon="preferences-system-windows") # paranoid i(wallpapermenu) i(core.separator) i(themeselector) if os.path.exists("/usr/bin/paranoid"): i(paranoid) # End self.menu.end()
def walk_menu(entry, is_system=False): if entry.get_type() == gmenu.TYPE_DIRECTORY and split and ids or entry.get_type() == gmenu.TYPE_DIRECTORY and not split: if not entry.menu_id in to_skip: obj = "\n".join(map(walk_menu, entry.get_contents())) elif is_system: obj = "\n".join(map(walk_menu_system, entry.get_contents())) else: return "" return core.menu(escape(entry.menu_id), escape(entry.name.replace("&","and")), obj, icon=entry.icon) elif entry.get_type() == gmenu.TYPE_DIRECTORY and split: if not entry.menu_id in to_skip: return core.pipemenu(escape(entry.menu_id), escape(entry.name.replace("&","and")), "alan-show-extension %s %s" % (sys.argv[1], entry.menu_id), icon=entry.icon) elif entry.get_type() == gmenu.TYPE_ENTRY and not entry.is_excluded: command = re.sub(' [^ ]*%[fFuUdDnNickvm]', '', entry.get_exec()) if "oneslip" in command and not ONESLIP: # oneslip not installed, link to bricks command = "pkexec /usr/bin/bricks \"%s\" oneslip" % escape(entry.name.replace("&","and")) if entry.launch_in_terminal: command = 'x-terminal-emulator --title "%s" -e %s' % \ (entry.name.replace("&","and"), command) # New action act = ga.execute(escape(command)) # Incorporate action in item item = core.item(escape(entry.name.replace("&","and")), act, icon=entry.icon) return item
def return_author_albums(self, artist): """ Returns a list of submenus that uses return_album_songs """ albums = [] num = 0 for song in self.client.listallinfo(): try: if song["artist"] == artist: # Yay! num += 1 if not song["album"] in albums: albums.append(song["album"]) except: pass albums_all = [] num = 0 for album in albums: num += 1 try: albums_all.append(core.menu("albumsub%s" % num, album, "\n".join(self.return_album_songs(album)))) except: pass return albums_all
def run(self): # Initiate pipemenu self.menu = struct.PipeMenu( use_cache=self.cfg.printv("use_cache", "Alan"), cache="logout", cache_trigger=(self.cfg.path, cfile, "/etc/passwd"), ) if self.menu.cache_check(): self.menu.cache_read() else: self.menu.start() # add initial tag # Alias menu.insert() to i() i = self.menu.insert ### Begin! sort = ( "lock", "logout", "switch", "suspend", "hibernate", "shutdown", "reboot", ) # Workaround that has to be made after switching from numbers to words. actions = { "lock": _("Lock Screen"), "logout": _("Logout"), "switch": _("Switch User"), "switch_guest": _("Guest session"), "suspend": _("Suspend"), "hibernate": _("Hibernate"), "shutdown": _("Shutdown"), "reboot": _("Reboot"), } ections = { "lock": "semplice-logout --lock", "logout": "semplice-logout --logout", "switch": "semplice-logout --switch-user", "switch_guest": "semplice-logout --switch-to-guest", "suspend": "semplice-logout --suspend", "hibernate": "semplice-logout --hibernate", "shutdown": "semplice-logout --shutdown", "reboot": "semplice-logout --reboot", } ictions = { "lock": "system-lock-screen", "logout": "system-log-out", "switch": "system-users", "switch_guest": "system-users", "suspend": "gnome-session-suspend", "hibernate": "gnome-session-hibernate", "shutdown": "gnome-session-halt", "reboot": "gnome-session-reboot", } # After <robo>, add a separator. sep = ("switch", "hibernate") # Read configuration file if os.path.exists(cfile): cfg = cp.SafeConfigParser() cfg.read(cfile) # Get last choice last = cfg.get("Last", "last_action") if last.lower() == "none": last = False else: last = False # Add that choice! if last: choice = actions[last] + " " + _("(CTRL+ALT+SPACE)") i(core.item(choice, ga.execute(ections[last]), icon=ictions[last])) i(core.separator) # Add normal choices # Lock screen i(core.item(_("Lock Screen"), ga.execute("semplice-logout --lock"), icon="system-lock-screen")) # Logout i(core.item(_("Logout"), ga.execute("semplice-logout --logout"), icon="system-log-out")) # Switch User # create menu: switch_items = [] # open passwd and populate switch_items with open("/etc/passwd", "r") as passwd: for line in passwd.readlines(): line = line.split(":") _uid = int(line[2]) if _uid < userbegin or _uid == 65534: continue # Skip users < userbegin and 65534 (nobody) _uname = line[0] _udesc = line[4].split(",")[0] if not _udesc: _udesc = _uname if not _uname == USER: _uhome = line[5] if os.path.exists(os.path.join(_uhome, ".face")): _uface = os.path.join(_uhome, ".face") else: _uface = "system-users" switch_items.append( core.item(_udesc, ga.execute("semplice-logout --switch-to %s" % _uname), icon=_uface) ) else: _uface = "gnome-settings-default-applications" # create another menu on which put the "change profile image" item... change_image = core.item( _("Change profile image"), ga.execute("semplice-change-face"), icon="eog" ) switch_items.append(core.menu("usermenu", _udesc, change_image, icon=_uface)) # add guest session switch_items.append(core.separator) # switch_items.append(core.item(_("Guest session"), ga.execute("semplice-logout --switch-to-guest"), icon="system-users")) # add Other... switch_items.append(core.item(_("Other..."), ga.execute("semplice-logout --switch-user"), icon="gdm")) # then create the menu... i(core.menu("switchmenu", _("Switch User"), "\n".join(switch_items), icon="system-users")) # Separator i(core.separator) # Suspend i(core.item(_("Suspend"), ga.execute("semplice-logout --suspend"), icon="gnome-session-suspend")) # Hibernate i(core.item(_("Hibernate"), ga.execute("semplice-logout --hibernate"), icon="gnome-session-hibernate")) # Separator i(core.separator) # Shutdown i(core.item(_("Shutdown"), ga.execute("semplice-logout --shutdown"), icon="gnome-session-halt")) # Reboot i(core.item(_("Reboot"), ga.execute("semplice-logout --reboot"), icon="gnome-session-reboot")) # for num in sort: # robo = actions[num] # i(core.item(robo, ga.execute(ections[num]), icon=ictions[num])) # if num in sep: # # We should add a separator! # i(core.separator) # Add Settings... item i(core.separator) i(core.item(_("Settings..."), ga.execute("semplice-logout --settings"), icon="preferences-desktop")) # End self.menu.end()
items.append(core.header(_name)) count = int(conf.printv("count")) done = 0 while done != count: # Create items done += 1 # Get object icon _icon = conf.printv("icon%s" % done) if not icons or not _icon: _icon = "" items.append(core.item(parsename(conf.printv("item%s" % done)), ga.execute(conf.printv("item%s_ex" % done)), icon=_icon)) elif _ext == "__menu__": # Internal menu id items.append(core.menu(conf.printv("id"), icon=_icon)) elif _ext == "__item__": # Normal menu item items.append(core.item(parsename(conf.printv("name")), ga.execute(conf.printv("executable")), icon=_icon)) else: # An external extension items.append(core.pipemenu(ext, _name, "%s %s" % (execu,ext), icon=_icon)) if IS_MAIN: # We are main? The items should not be in submenu. i("\n".join(items)) else: # Generate a submenu and then add the items. i(core.menu(cat, name, "\n".join(items), icon=icon))
def run(self): ids = "" # Get split_menu split = self.cfg.printv("split_menu") # Get hide_settings_menus hide_settings_menus = self.cfg.printv("hide_settings_menus") if split: # Should edit menu? if len(sys.argv) > 2: ids = " ".join(sys.argv[2:]) if hide_settings_menus: # Should hide menus? to_skip = () else: to_skip = ("Administration", "Preferences") # Lookup menu file if os.path.exists("/etc/xdg/menus/semplice-applications.menu"): applications_menu = "semplice-applications.menu" elif os.path.exists("/etc/xdg/menus/gnome-applications.menu"): applications_menu = "gnome-applications.menu" else: applications_menu = "applications.menu" # Force to applications.menu, may fail if not existent, of course. def walk_menu_system(entry): return walk_menu(entry, is_system=True) def walk_menu(entry, is_system=False): if entry.get_type() == gmenu.TYPE_DIRECTORY and split and ids or entry.get_type() == gmenu.TYPE_DIRECTORY and not split: if not entry.menu_id in to_skip: obj = "\n".join(map(walk_menu, entry.get_contents())) elif is_system: obj = "\n".join(map(walk_menu_system, entry.get_contents())) else: return "" return core.menu(escape(entry.menu_id), escape(entry.name.replace("&","and")), obj, icon=entry.icon) elif entry.get_type() == gmenu.TYPE_DIRECTORY and split: if not entry.menu_id in to_skip: return core.pipemenu(escape(entry.menu_id), escape(entry.name.replace("&","and")), "alan-show-extension %s %s" % (sys.argv[1], entry.menu_id), icon=entry.icon) elif entry.get_type() == gmenu.TYPE_ENTRY and not entry.is_excluded: command = re.sub(' [^ ]*%[fFuUdDnNickvm]', '', entry.get_exec()) if "oneslip" in command and not ONESLIP: # oneslip not installed, link to bricks command = "pkexec /usr/bin/bricks \"%s\" oneslip" % escape(entry.name.replace("&","and")) if entry.launch_in_terminal: command = 'x-terminal-emulator --title "%s" -e %s' % \ (entry.name.replace("&","and"), command) # New action act = ga.execute(escape(command)) # Incorporate action in item item = core.item(escape(entry.name.replace("&","and")), act, icon=entry.icon) return item # Initiate pipemenu #self.menu = struct.PipeMenu(use_cache=self.cfg.printv("use_cache","Alan"), cache="xdgmenu", cache_trigger=(self.cfg.path, glob.glob("/usr/share/applications/desktop.*.cache")[0])) self.menu = struct.PipeMenu() if self.menu.cache_check(): # Read cache self.menu.cache_read() else: self.menu.start() # add initial tag # Alias menu.insert() to i() i = self.menu.insert ### Begin! if split: path = "/" + ids else: path = "/" i("\n".join(map(walk_menu, gmenu.lookup_tree(applications_menu).get_directory_from_path(path).get_contents()))) #### SYSTEM SETTINGS if not ids and not hide_settings_menus: i(core.separator) # Prefs prefs = gmenu.lookup_tree(applications_menu).get_directory_from_path("/System/Preferences") if not split: prefs_items = "\n".join(map(walk_menu_system, prefs.get_contents())) i(core.menu(escape(prefs.menu_id), escape(prefs.name.replace("&","and")), prefs_items, icon=prefs.icon)) else: i(core.pipemenu(escape(prefs.menu_id), escape(prefs.name.replace("&","and")), "alan-show-extension %s %s" % (sys.argv[1], "System/Preferences"), icon=prefs.icon)) # Admin admin = gmenu.lookup_tree(applications_menu).get_directory_from_path("/System/Administration") if not split: admin_items = "\n".join(map(walk_menu_system, admin.get_contents())) i(core.menu(escape(admin.menu_id), escape(admin.name.replace("&","and")), admin_items, icon=admin.icon)) else: i(core.pipemenu(escape(admin.menu_id), escape(admin.name.replace("&","and")), "alan-show-extension %s %s" % (sys.argv[1], "System/Administration"), icon=admin.icon)) # Display info object #i(core.info(infos)) # End self.menu.end()
def run(self): # Initiate pipemenu self.menu = struct.PipeMenu() self.menu.start() # add initial tag # Alias menu.insert() to i() i = self.menu.insert ### Begin! # We should determine which player use, but hey, currently only MPD is supported :) PLAYERS = (MPD,) # Process player for player in PLAYERS: # Declare class clas = player() if len(sys.argv) > 3: # Called from an already made pipe menu if clas.NAME == sys.argv[2]: if sys.argv[3] == "play": clas.play() if sys.argv[3] == "pause": clas.pause() if sys.argv[3] == "stop": clas.stop() if sys.argv[3] == "restartsong": clas.restartsong() if sys.argv[3] == "prev": clas.prev() if sys.argv[3] == "next": clas.next() sys.exit(0) ####### # A simple ASCII mockup :D # # Play (If we are paused or stopped) - If we are playing, show Pause instead of Play. # Stop (If we are playing or pausing) # ---- # <Song Name> -> Click -> Restarts song # <Album> -> Submenu that shows all songs in the album # <Author> -> Submenu that shows all albums and then songs in them # ---- # Previous # Next # ---- # Info ####### # Begin creating all needed objects play = core.item(_("Play"), ga.execute(executable + " %s play" % clas.NAME)) pause = core.item(_("Pause"), ga.execute(executable + " %s pause" % clas.NAME)) stop = core.item(_("Stop"), ga.execute(executable + " %s stop" % clas.NAME)) if clas.status["state"] == "stop" or not clas.song["title"]: song = _("Play a random song") album = False author = False else: song = clas.song["title"] # album = core.menu() # print clas.song["album"] try: album = core.menu( "albumsub", clas.song["album"], "\n".join(clas.return_album_songs(clas.song["album"])) ) except: album = False try: author = core.menu( "artistsub", clas.song["artist"], "\n".join(clas.return_author_albums(clas.song["artist"])) ) except: author = False song = core.item(_(song), ga.execute(executable + " %s restartsong" % clas.NAME)) prev = core.item(_("Previous"), ga.execute(executable + " %s prev" % clas.NAME)) next = core.item(_("Next"), ga.execute(executable + " %s next" % clas.NAME)) # Begin adding to menu i(core.header(clas.NAME)) if clas.status["state"] == "stop" or clas.status["state"] == "pause": i(play) if clas.status["state"] == "play": i(pause) if clas.status["state"] == "play" or clas.status["state"] == "pause": i(stop) # Separator i(core.separator) # Song name i(song) if album: i(album) if author: i(author) # Previus/Next if clas.status["state"] in ("play", "pause"): # Separator i(core.separator) i(prev) i(next) # Display info object i(core.info(infos)) # End self.menu.end()