def __init__(self, icon): self.indicator = appindicator.Indicator( app.config.get(prefs.SHORT_APP_NAME), icon, appindicator.CATEGORY_APPLICATION_STATUS) self.indicator.set_status(appindicator.STATUS_PASSIVE) self.menu_items = [] self.indicator.set_icon_theme_path(resources.share_path('icons')) self.calculate_popup_menu() #FIXME: this is a bit of a hack since the signal probably # wasn't meant to be used this way. However, it is emitted # every time app.menu_manager.update_menus() is called # and therefore it covers all situations where we want to # update the app indicator menu. The signal is also emitted # sometimes when no update to the app indicator menu is needed # (espcecially during downloads). Therefore we later only set # a new app indicator menu if there actually is a change in # the menu text. This avoids a flickering menu. app.menu_manager.connect('enabled-changed', self._on_menu_update)
def start(self): """ Function used to show an icon in notification area.""" if APPINDICATOR: self.indicator = appindicator.Indicator( "billreminder", "ApplicationStatus", appindicator.CATEGORY_APPLICATION_STATUS) self.indicator.set_status(appindicator.STATUS_ACTIVE) self.indicator.set_attention_icon(common.PANEL_ATTENTION_ICON) self.indicator.set_icon(common.PANEL_ICON) self.menu = self.show_menu(None, None, None) self.indicator.set_menu(self.menu) self.menu.show() else: self.tray = gtk.StatusIcon() self.tray.set_from_file(common.TRAY_ICON) self.tray.set_tooltip(_("BillReminder")) self.tray.connect("popup-menu", self.show_menu, None) self.tray.connect("activate", self.show_hide, None)
def __init__(self): # Setup some callbacks to update the status of the buttons self.monitor.daemon_status_callback=self.serviceCheck; ind = appindicator.Indicator ("autorotate-client", "gsd-xrandr", appindicator.CATEGORY_APPLICATION_STATUS) ind.set_status (appindicator.STATUS_ACTIVE) ind.set_attention_icon ("indicator-messages-new") # create a menu menu = gtk.Menu() rotate_submenu = gtk.Menu(); rotate_item=gtk.MenuItem("Rotate Screen") rotate_item.show() menu.append(rotate_item); # create some labels for the normal rotations directions=["Normal","Left","Inverted","Right"]; for direction in directions: menu_item = gtk.MenuItem(" "+direction) menu.append(menu_item) menu_item.connect("activate",self.setRotation,direction) # show the items menu_item.show() # Add button to enable automatic rotation menu.append(self.auto_menu_item) self.auto_menu_item.connect("activate",self.setRotation,direction) self.auto_menu_item.show() # Autorotate configuration menu separator_item1=gtk.SeparatorMenuItem(); separator_item1.show(); menu.append(separator_item1); self.daemon_menu_item.connect("activate",self.startStopDaemon); menu.append(self.daemon_menu_item); self.daemon_menu_item.show(); # Run the indicator! ind.set_menu(menu) gtk.main()
def __init__(self, window, terminal): self.window = window self.window.set_size_request(652, 447) self.window.set_position(gtk.WIN_POS_CENTER) self.window.connect('delete-event', self.delete_event) self.terminal = terminal self.window.add(terminal) self.childpid = self.terminal.fork_command(self.command[0], self.command, os.getcwd()) if self.childpid > 0: self.childexited = self.terminal.connect('child-exited', self.on_child_exited) self.window.connect('delete-event', lambda w, e: gtk.main_quit()) else: self.childexited = None spawn_later(0.5, self.show_startup_notify) self.window.show_all() logo_filename = os.path.join( os.path.abspath(os.path.dirname(__file__)), 'goproxy-gtk.png') self.window.set_icon_from_file(logo_filename) if appindicator: self.trayicon = appindicator.Indicator( 'GoProxy', 'indicator-messages', appindicator.CATEGORY_APPLICATION_STATUS) self.trayicon.set_status(appindicator.STATUS_ACTIVE) self.trayicon.set_attention_icon('indicator-messages-new') self.trayicon.set_icon(logo_filename) self.trayicon.set_menu(self.make_menu()) else: self.trayicon = gtk.StatusIcon() self.trayicon.set_from_file(logo_filename) self.trayicon.connect( 'popup-menu', lambda i, b, t: self.make_menu().popup( None, None, gtk.status_icon_position_menu, b, t, self. trayicon)) self.trayicon.connect('activate', self.show_hide_toggle) self.trayicon.set_tooltip('GoProxy') self.trayicon.set_visible(True)
def main(): ind = appi.Indicator("OneDIR", "Notify message", appi.CATEGORY_APPLICATION_STATUS) ind.set_status(appi.STATUS_ACTIVE) ind.set_icon("/home/justin/tiny_strip.png") ind.set_attention_icon("indicator-messages-new") menu = gtk.Menu() title = gtk.MenuItem("OneDir Notification: (click below)") notif = gtk.MenuItem("A friend invited you to share a folder") q = gtk.MenuItem("quit") notif.connect("activate", wp_launcher) q.connect("activate", quit) menu.append(title) menu.append(notif) menu.append(q) title.show() notif.show() q.show() ind.set_menu(menu) gtk.main()
def init_systray(self): # Build the systray icon if self.systray_icon: return if self.systray_indicator: self.systray_icon = appindicator.Indicator( "virt-manager", "virt-manager-icon", appindicator.CATEGORY_OTHER) self.systray_icon.set_status(appindicator.STATUS_ACTIVE) self.systray_icon.set_menu(self.systray_menu) else: self.systray_icon = gtk.StatusIcon() self.systray_icon.set_visible(True) self.systray_icon.set_property("icon-name", "virt-manager") self.systray_icon.connect("activate", self.systray_activate) self.systray_icon.connect("popup-menu", self.systray_popup) self.systray_icon.set_tooltip(_("Virtual Machine Manager"))
def __init__(self, indicator_hdl): if not isinstance(indicator_hdl, SBackupdIndicatorHandler): raise TypeError( "Parameter of type `SBackupdIndicatorHandler` expected.") SBackupdIndicatorBase.__init__(self, indicator_hdl) self.logger = LogFactory.getLogger() self._indicator = appindicator.Indicator( constants.INDICATORAPP_NAME, constants.INDICATOR_ACTIVE_ICON, appindicator.CATEGORY_APPLICATION_STATUS) PyNotifyMixin.__init__(self, logger=self.logger, iconfile=util.get_resource_file( constants.NOTIFICATION_ICON_FILENAME), trayicon=None) self.__init_ctrls()
def __init__(self, window, terminal): self.window = window self.window.set_size_request(652, 447) self.window.set_position(gtk.WIN_POS_CENTER) self.window.connect('delete-event',self.delete_event) self.terminal = terminal if os.system('which python3') == 0: self.command[1] = 'python3' self.window.add(terminal) self.childpid = self.terminal.fork_command(self.command[0], self.command, os.getcwd()) if self.childpid > 0: self.childexited = self.terminal.connect('child-exited', self.on_child_exited) self.window.connect('delete-event', lambda w, e: gtk.main_quit()) else: self.childexited = None spawn_later(0.5, self.show_startup_notify) if should_visible(): self.window.show_all() logo_filename = os.path.join(os.path.abspath(os.path.dirname(__file__)), 'goagent-logo.png') if not os.path.isfile(logo_filename): with open(logo_filename, 'wb') as fp: fp.write(base64.b64decode(GOAGENT_LOGO_DATA)) self.window.set_icon_from_file(logo_filename) if appindicator: self.trayicon = appindicator.Indicator('GoAgent', 'indicator-messages', appindicator.CATEGORY_APPLICATION_STATUS) self.trayicon.set_status(appindicator.STATUS_ACTIVE) self.trayicon.set_attention_icon('indicator-messages-new') self.trayicon.set_icon(logo_filename) self.trayicon.set_menu(self.make_menu()) else: self.trayicon = gtk.StatusIcon() self.trayicon.set_from_file(logo_filename) self.trayicon.connect('popup-menu', lambda i, b, t: self.make_menu().popup(None, None, gtk.status_icon_position_menu, b, t, self.trayicon)) self.trayicon.connect('activate', self.show_hide_toggle) self.trayicon.set_tooltip('GoAgent') self.trayicon.set_visible(True)
def __init__(self, dbus_client): self.ind = appindicator.Indicator( "curator", "curator-tray", appindicator.CATEGORY_APPLICATION_STATUS) self.ind.set_status(appindicator.STATUS_ACTIVE) self.dbus_client = dbus_client self.menu = gtk.Menu() next = gtk.MenuItem("Next wallpaper") self.menu.append(next) next.connect_object("activate", lambda w: self.dbus_client.next_wallpaper(), "Next Wallpaper") next.show() hide = gtk.MenuItem("Hide wallpaper") self.menu.append(hide) hide.connect_object("activate", lambda w: self.dbus_client.hide_current(), "Hide wallpaper") hide.show() pref = gtk.MenuItem("Preferences") self.menu.append(pref) pref.connect_object("activate", lambda w: self.preferences(), "Preferences") pref.show() about = gtk.MenuItem("About") self.menu.append(about) about.connect_object("activate", lambda w: self.about(), "About") about.show() quit = gtk.MenuItem("Quit") self.menu.append(quit) quit.connect_object("activate", lambda w: self.quit(), "Quit") quit.show() self.ind.set_menu(self.menu)
def __init__(self): """Setup notifications, and gtk""" # Initialize Ubuntu notifications self.notificationsAvailable = pynotify.init("ubuntu-timer") self.indicator = appindicator.Indicator( "example-simple-client", "", appindicator.CATEGORY_APPLICATION_STATUS) self.indicator.set_status(appindicator.STATUS_ACTIVE) self.indicator.set_attention_icon("indicator-messages-new") self.indicator.set_label("00:00") self.createMenu() self.notify("Hello toast") # Start gtk gtk.main()
def __init__(self): self.folder=os.path.dirname(os.path.realpath(__file__)) #Get the aplication's folder. n=self.get_interfaces() #Get the interfaces (that also fills the interfaces list #This is our indicator object! (name, icon,type) self.ind = appindicator.Indicator ("indicator-netspeed", "zero", appindicator.CATEGORY_SYSTEM_SERVICES) self.ind.set_icon_theme_path("%s/icons"%self.folder) #Set the icon theme folder! self.ind.set_status (appindicator.STATUS_ACTIVE) self.ind.set_label("⇧ 0.0 B/s ⇩ 0.0 B/s",'⬆8888 MB/s ⬇8888 MB/s') #Initially set the label to ⇧ 0.0 B/s ⇩ 0.0 B/s self.build_menu() #Build the menu self.alive = threading.Event() self.alive.set() self.fetch = NetspeedFetcher(self) self.fetch.start() # Start fetcher thread self.nethogs_thread=threading.Thread(target=self._tail_forever, args=("",)) #set the bandwidth/process monitor thread if self.bandwidthPerProcess_active: #If the functionality is active self.nethogs_thread.start() #Start the thread!
def build_menu(self, current_git_username): self.ind = appindicator.Indicator("git-indicator", "krb-valid-ticket", appindicator.CATEGORY_OTHER) self.ind.set_status(appindicator.STATUS_ACTIVE) self.ind.set_label(current_git_username) menu = gtk.Menu() for name in sorted(self.devs): self._add_name_item(menu, name) separator = SeparatorMenuItem() menu.append(separator) self._add_action_item(menu, 'Restart', self.restart) self._add_action_item(menu, 'Quit', self.quit) menu.show_all() self.ind.set_menu(menu) return menu
def __init__(self): self.ind = appindicator.Indicator( "Ubuntu Mouse Gestures", "system-file-manager-panel", appindicator.CATEGORY_APPLICATION_STATUS) self.ind.set_status(appindicator.STATUS_ACTIVE) # self.ind.set_attention_icon ("indicator-messages-new") # create a menu self.menu = gtk.Menu() # create items for the menu - labels, checkboxes, radio buttons and images are supported: title = gtk.MenuItem("Linux Mouse Gestures") title.set_sensitive(False) self.menu.append(title) self.menu.append(gtk.SeparatorMenuItem()) settings = gtk.ImageMenuItem(gtk.STOCK_PREFERENCES) settings.connect("activate", self.settings) self.menu.append(settings) about = gtk.ImageMenuItem(gtk.STOCK_ABOUT) about.connect("activate", self.about) self.menu.append(about) self.menu.append(gtk.SeparatorMenuItem()) quit = gtk.ImageMenuItem(gtk.STOCK_QUIT) quit.connect("activate", self.quit) quit.show() self.menu.append(quit) self.ind.set_menu(self.menu) self.menu.show_all() self.bg = Thread(target=self.start_log) self.bg.start()
def __init__(self, persist, icon, label): # parameters self.persist = persist #True self.icon = icon #'terminal' self.status = appindicator.STATUS_ATTENTION #ACTIVE self.label = label # indicator self.ind = appindicator.Indicator ("c-indicator", self.icon, appindicator.CATEGORY_OTHER) self.ind.set_label(self.label) self.ind.set_attention_icon (self.icon) self.ind.set_status(self.status) # menu self.menu = gtk.Menu() self.submenus = dict() for line in sys.stdin: line = line[0:len(line)-1] # removing last '\n' self.add_menu(self.menu, line, line) if self.persist: self.add_quit() self.menu.show() self.ind.set_menu(self.menu)
def __init__(self): self.pings = [] self.lastRate = [-1, -1, True] menu = gtk.Menu() quit = gtk.MenuItem("Quit") about = gtk.MenuItem("Packet Drop Indicator") ind = appindicator.Indicator( "pingmon-indicator", "emblem-OK", appindicator.CATEGORY_OTHER, ) ind.set_menu(menu) ind.set_attention_icon("emblem-ohno") self.updateIcon(ind) quit.connect("activate", self.destroy) about.connect("activate", self.about) menu.append(about) menu.append(quit) menu.show_all() gobject.timeout_add(PING_FREQUENCY, self.ping, ind)
def __init__(self, application, mainWnd): import gtk import appindicator self._application = application self._mainWnd = mainWnd self._icon = os.path.abspath( os.path.join(getImagesDir(), "outwiker_64x64.png")) assert os.path.exists(self._icon) self._indicator = appindicator.Indicator( "OutWiker", self._icon, appindicator.CATEGORY_APPLICATION_STATUS) menu = gtk.Menu() self.restoreMenuItem = gtk.MenuItem(_('Restore')) self.restoreMenuItem.show() self.exitMenuItem = gtk.MenuItem(_('Exit')) self.exitMenuItem.show() menu.append(self.restoreMenuItem) menu.append(self.exitMenuItem) self._indicator.set_menu(menu)
def __init__(self, btconf): """ Initialise the indicator, load the config file, intialise some properties and set up the basic menu """ self.ind = appindicator.Indicator( "btsync-indicator", "btsync", appindicator.CATEGORY_APPLICATION_STATUS, args.iconpath) self.ind.set_status(appindicator.STATUS_ACTIVE) self.ind.set_attention_icon("btsync-attention") self.config = btconf.config self.detect_btsync_user() if 'login' in self.config['webui']: login = self.config['webui']['login'] password = self.config['webui']['password'] self.webui = 'http://' + login + ':' + password + '@' + self.config[ 'webui'][ 'listen'] if self.btsync_user else 'http://' + self.config[ 'webui']['listen'] self.auth = (login, password) else: self.webui = 'http://' + self.config['webui']['listen'] self.auth = None self.urlroot = 'http://' + self.config['webui']['listen'] + '/gui/' self.folderitems = {} self.info = {} self.clipboard = gtk.Clipboard() self.animate = None self.error_item = None self.frame = 0 self.status = None self.count = 0 self.menu_setup() self.ind.set_menu(self.menu)
def build_indicator(self): self.ind = appindicator.Indicator( "example-simple-client", "indicator-messages", appindicator.CATEGORY_APPLICATION_STATUS) self.ind.set_status(appindicator.STATUS_ACTIVE) self.ind.set_attention_icon("indicator-messages-new") self.ind.set_icon("distributor-logo") self.menu = gtk.Menu() self.ind.set_menu(self.menu) ask_now_menuitem = gtk.MenuItem("Ask now") ask_now_menuitem.connect( "activate", self.new_question_window, True) #The callback data means it will launch in "perpetual mode" set_timer_menuitem = gtk.MenuItem("Set timer") timer_submenu = gtk.Menu() set_timer_menuitem.set_submenu(timer_submenu) self.current_timer_menu_item = None for minute in [5, 10, 15, 30, 45, 60]: timer_menuitem = gtk.CheckMenuItem("{0} minutes".format(minute)) timer_menuitem.connect("toggled", self.on_timer_changed, minute) timer_submenu.append(timer_menuitem) edit_menu_item = gtk.MenuItem("Edit notecards") edit_menu_item.connect("activate", self.on_edit_clicked) # Why would anyone want to quit? Anyways, quit_menu_item = gtk.MenuItem("Exit") quit_menu_item.connect("activate", self.quit) for item in [ ask_now_menuitem, set_timer_menuitem, edit_menu_item, quit_menu_item ]: self.menu.append(item) self.menu.show_all()
def __init__(self, icon, menu): if sys.platform == "linux2": self.menu = menu.gtk_menu import appindicator self.icon_directory = os.path.sep + 'usr' + os.path.sep + 'share' + os.path.sep + 'icons' + os.path.sep + 'zik' + os.path.sep if not os.path.isdir(self.icon_directory): self.icon_directory = os.path.dirname( sys.argv[0] ) + os.path.sep + 'share' + os.path.sep + 'icons' + os.path.sep + 'zik' + os.path.sep self.statusicon = appindicator.Indicator( "new-parrotzik-indicator", "indicator-messages", appindicator.CATEGORY_APPLICATION_STATUS) self.statusicon.set_status(appindicator.STATUS_ACTIVE) self.statusicon.set_icon_theme_path(self.icon_directory) self.statusicon.set_menu(self.menu) elif sys.platform == "win32": self.menu = menu.gtk_menu self.icon_directory = os.path.dirname( os.path.realpath(sys.argv[0]) ) + os.path.sep + 'share' + os.path.sep + 'icons' + os.path.sep + 'zik' + os.path.sep self.statusicon = gtk.StatusIcon() self.statusicon.connect("popup-menu", self.gtk_right_click_event) self.statusicon.set_tooltip("Parrot Zik") self.menu_shown = False sys.stdout = open( tempfile.gettempdir() + os.path.sep + "zik_tray_stdout.log", "w") sys.stderr = open( tempfile.gettempdir() + os.path.sep + "zik_tray_stderr.log", "w") elif sys.platform == "darwin": self.icon_directory = os.path.dirname( os.path.realpath(sys.argv[0]) ) + os.path.sep + 'share' + os.path.sep + 'icons' + os.path.sep + 'zik' + os.path.sep self.statusicon = StatusApp.sharedApplication() self.statusicon.initMenu(menu) self.setIcon(icon)
def __init__(self): """Init creation of the gtk.Menu and binding to the appindicator""" self.colormap = { "White": "FFFFFF", "Yellow": "FFFF00", "Purple": "FF00FF", "Cyan": "00FFFF", "Red": "FF0000", "Green": "00FF00", "Blue": "0000FF" } self.ind = appindicator.Indicator( "pyAlienFX", "/home/xqua/Documents/Work/Coding/Python/pyalienfx/images/indicator_off.png", appindicator.CATEGORY_APPLICATION_STATUS) self.ind.set_status(appindicator.STATUS_ACTIVE) self.ind.set_attention_icon( "/home/xqua/Documents/Work/Coding/Python/pyalienfx/images/indicator_on.png" ) self.gui = pyAlienFX.pyAlienFX_GUI() self.menu_setup() self.ind.set_menu(self.menu)
def __init__(self): # create systray interface self.systray = appindicator.Indicator( "testname", iconpath, appindicator.CATEGORY_APPLICATION_STATUS) self.systray.set_status(appindicator.STATUS_ACTIVE) # construct menu menu = gtk.Menu() mitem = gtk.MenuItem("configure") menu.append(mitem) mitem.connect("activate", self.createConfigWindow) mitem.show() mitem = gtk.MenuItem("exit") menu.append(mitem) mitem.connect("activate", self.exit_program) mitem.show() # attach menu to out system tray self.systray.set_menu(menu) # instantiate confcontroller self.myConf = ConfController()
def buildMenu(self): try: import appindicator self.app_indicator = appindicator.Indicator( APPNAME, APP_INDICATOR_ICON_OFF, appindicator.CATEGORY_APPLICATION_STATUS) self.app_indicator.set_status(appindicator.STATUS_ACTIVE) except Exception as e: self.log.debug(e) self.log.warn("Failed to create an Application Indicator!") self.app_indicator = None self.app_indicator.set_icon_theme_path(IMAGE_PATH) self.turnOnOff = None self.metadata_menu_item = None self.perferences_submenu = None self.preferences_menu = None self.radioMenu = Gtk.Menu() self.build_app_indicator_menu(self.radioMenu) self.app_indicator.set_menu(self.radioMenu) self.handler.updateTooltip()
def _create_tray(self): self.tray_menu_logged_in = gtk.Menu() self.tray_menu_logged_out = gtk.Menu() if appindicator is not None: g_logger.info("APP INDICATOR!") # This means we're running on unity and we need a different tray self.tray_indicator = appindicator.Indicator( "open-monitor", # APP ID "internet-feed-reader", # ICON NAME appindicator.CATEGORY_APPLICATION_STATUS) # APP CATEGORY self.tray_indicator.set_status(appindicator.STATUS_ACTIVE) self.tray_indicator.set_attention_icon("indicator-messages-new") self.tray_indicator.set_menu(self.tray_menu_logged_out) else: self.tray_icon = gtk.StatusIcon() self.tray_icon.connect('popup-menu', self.show_menu) self.tray_icon.set_tooltip("Open Monitor") self.tray_icon.set_from_file( os.path.join(ICONS_DIR, "tray_icon_gray_32.ico"))
def __init__(self): self.indicator = appindicator.Indicator( "Lookit", "lookit-panel", appindicator.CATEGORY_APPLICATION_STATUS) self.indicator.set_status(appindicator.STATUS_ACTIVE) self.menu = gtk.Menu() self.add_menu_item('Capture Area', cmd.CAPTURE_AREA) self.add_menu_item('Capture Entire Screen', cmd.CAPTURE_SCREEN) self.add_menu_item('Capture Active Window', cmd.CAPTURE_ACTIVE_WINDOW) self.add_menu_separator() delaymenu = gtk.Menu() self.add_menu_item('0 seconds', cmd.DELAY_0, delaymenu) self.add_menu_item('3 seconds', cmd.DELAY_3, delaymenu) self.add_menu_item('5 seconds', cmd.DELAY_5, delaymenu) self.add_menu_item('10 seconds', cmd.DELAY_10, delaymenu) sub = gtk.MenuItem('Set Delay:') sub.set_submenu(delaymenu) self.menu.append(sub) config = lookitconfig.LookitConfig() enableupload = config.getboolean('Upload', 'enableupload') self.add_check_menu_item('Upload to server', cmd.TOGGLE_UPLOAD, value=enableupload) self.add_menu_separator() self.add_menu_item('Preferences', cmd.SHOW_PREFERENCES) self.add_menu_item('About', cmd.SHOW_ABOUT) self.image_position = len(self.menu) self.image_list = [] self.add_menu_separator() self.add_menu_item('Exit', cmd.EXIT) self.menu.show_all() self.indicator.set_menu(self.menu)
def __init__(self, args): # create an indicator applet self.ind = appindicator.Indicator( "PHreak", "phreak", appindicator.CATEGORY_APPLICATION_STATUS) self.ind.set_status(appindicator.STATUS_ACTIVE) self.ind.set_icon(PHreak.icon_filename) self.db = set() # create a menu self.menu = gtk.Menu() # create items for the menu - refresh, quit and a separator menuSeparator = gtk.SeparatorMenuItem() menuSeparator.show() self.menu.append(menuSeparator) btnAbout = gtk.MenuItem("About") btnAbout.show() btnAbout.connect("activate", self.showAbout) self.menu.append(btnAbout) btnRefresh = gtk.MenuItem("Refresh") btnRefresh.show() #the last parameter is for not running the timer btnRefresh.connect("activate", self.refresh, True) self.menu.append(btnRefresh) btnQuit = gtk.MenuItem("Quit") btnQuit.show() btnQuit.connect("activate", self.quit) self.menu.append(btnQuit) self.menu.show() if pynotify: pynotify.init("phreak") self.refresh() self.ind.set_menu(self.menu)
def init_tray_icon(): global resdir, indicator, status_icon # Default image image = resdir + "/tray/tray.png" # Display manager detection display_manager = get_display_manager() use_indicator = display_manager == "unity" or display_manager == "gnome2" do_print("Detected display manager '{0}'.".format(display_manager)) # Try loading "appindicator" package; if not existant, # fall back to status icons if use_indicator: try: import appindicator except: do_print( "Couldn't load 'appindicator' package. Using status icons.") use_indicator = 0 # Go! if use_indicator: do_print("Initializing indicator...") indicator = appindicator.Indicator( "Stacksync", image, appindicator.CATEGORY_APPLICATION_STATUS) indicator.set_status(appindicator.STATUS_ACTIVE) indicator.set_attention_icon("indicator-messages-new") else: do_print("Initializing status icon...") status_icon = gtk.StatusIcon() status_icon.set_from_file(image) status_icon.connect('popup-menu', status_icon_popup_menu_cb) status_icon.set_visible(True) status_icon.set_tooltip("Stacksync")
def main(): DBusGMainLoop(set_as_default=True) global HAS_INDICATOR gtk.gdk.threads_init() config.loads(); try: import ctypes libc = ctypes.CDLL('libc.so.6') libc.prctl(15, 'hotot', 0, 0, 0) except: import dl libc = dl.open('/lib/libc.so.6') libc.call('prctl', 15, 'hotot', 0, 0, 0) agent.init_notify() app = Hotot() agent.app = app if HAS_INDICATOR: indicator = appindicator.Indicator('hotot', 'hotot', appindicator.CATEGORY_COMMUNICATIONS, utils.get_ui_object('image')) indicator.set_status(appindicator.STATUS_ACTIVE) indicator.set_icon('ic24_hotot_mono_light') indicator.set_attention_icon('ic24_hotot_mono_light_blink') indicator.set_menu(app.menu_tray) app.indicator = indicator # Set display functions (MeMenu) if HAS_MEMENU: global ind_server, indicator_unread ind_server.connect("server-display", app.on_mitem_resume_activate) indicator_unread.connect("user-display", app.on_mitem_resume_activate) gtk.gdk.threads_enter() gtk.main() gtk.gdk.threads_leave()
def __init__(self): if version_at_least_2_6_27: #from Janitha #contents are just "(123,456)" for x,y position. self._hdaps_position = "/sys/devices/platform/hdaps/position" else: #I have no idea if this works. self._hdaps_position = "/sys/devices/platform/hdaps/position" self.ind = appindicator.Indicator("hdaps-theft-alarm-indicator", "purse-thief", appindicator.CATEGORY_HARDWARE) self.ind.set_status(appindicator.STATUS_ACTIVE) self.ind.set_icon("purse-thief") #TODO: persist this. self.__quiet_mode = False self.menu_setup() self.ind.set_menu(self.menu) ####### self.ind.set_status(appindicator.STATUS_ACTIVE)
def __init__(self, settings): self.__log.debug('Initializing %s', self.__class__) dummy_icon = os.path.join(os.path.dirname(os.path.realpath(__file__)), 'images', 'icon.png') self.__log.debug('Loading dummy icon from %s', dummy_icon) self.ind = appindicator.Indicator( "ip-indicator", dummy_icon, appindicator.CATEGORY_APPLICATION_STATUS) self.ind.set_status(appindicator.STATUS_ACTIVE) self.settings = settings self.__log.debug('Settings: %s', vars(settings)) self.settings.sanitize_url() self.selected_interface = None self.refresh() if self.interfaces.has_interface(self.settings.interface): self.__log.debug('Using interface %s from settings', self.settings.interface) self._menu_items[self.settings.interface].select() else: self.__log.debug('Cannot use interface %s from settings', self.settings.interface) self._connect_dbus()
def __init__(self): # create an indicator applet self.ind = appindicator.Indicator( 'JVPN Tray', 'jvpn-status', appindicator.CATEGORY_APPLICATION_STATUS) self.ind.set_status(appindicator.STATUS_ACTIVE) self.ind.set_attention_icon(jvpn_icon) self.ind.set_icon(jvpn_icon_bw) self.keyring = Keyring() self.invalid_cred = False # create a menu self.menu = gtk.Menu() # create items for the menu self.status = gtk.MenuItem('Not connected') self.status.show() self.menu.append(self.status) # A separator separator = gtk.SeparatorMenuItem() separator.show() self.menu.append(separator) # jvpn connect menu self.btnconnect = gtk.MenuItem("Connect") self.btnconnect.connect("activate", self.connect) self.btnconnect.show() # jvpn disconnect menu self.btndisconnect = gtk.MenuItem("Disconnect") self.btndisconnect.connect("activate", self.disconect) # quit menu btnquit = gtk.ImageMenuItem(gtk.STOCK_QUIT) btnquit.connect("activate", self.quit) btnquit.show() self.menu.append(self.btnconnect) self.menu.append(self.btndisconnect) self.menu.append(btnquit) self.menu.show() self.ind.set_menu(self.menu) self.t_jvpn = JVPN(None, None)