def run(self): self.dialog = gtk.MessageDialog(None, 0, gtk.MESSAGE_INFO, gtk.BUTTONS_CANCEL, _("Starting daemon...")) child_pid = os.fork() if child_pid == 0: # child os.execv(self.cmd, self.args) # If we get here, the exec failed. return 0 # parent self.service_pid = child_pid gtk.timeout_add(500, self.wait_for_daemon_cb) response = self.dialog.run() self.dialog.destroy() if response == gtk.RESPONSE_CANCEL or \ response == gtk.RESPONSE_DELETE_EVENT: if self.service_pid != -1: os.kill(self.service_pid, signal.SIGKILL) if self.rcd_pid != -1: try: os.kill(self.rcd_pid, signal.SIGKILL) except OSError, e: # Couldn't kill it, probably already dead pass
def start(self): self.bind_signals() self.toggle_mute() gtk.timeout_add(self.update_interval, self.update) log.info("Blockify started.") gtk.main()
def refresh(self): if (bool(self.c.getStatus())): self.ind.set_label("CO: " + str(self.c.getTempCO()) + u"\u2103, Wew: " + str(self.c.getTempWew()) + u"\u2103, Zew: " + str(self.c.getTempZew()) + u"\u2103") else: self.ind.set_label("B³¹d"); gtk.timeout_add(5000, self.refresh)
def __init__(self, light_theme=False, debug=False, show_quit=False, start_enabled=False): # create and setup the indicator self.ind = appindicator.Indicator( "trusty-caffeine", "caffeine-cup-empty", appindicator.CATEGORY_SYSTEM_SERVICES) self.ind.set_status(appindicator.STATUS_ACTIVE) self.ind.set_attention_icon("caffeine-cup-full") found_theme = False # use the appropriate icon if (light_theme): self.ind.set_icon_theme_path( "/usr/share/icons/matefaenza/status/22/") else: # matefaenzagray was renamed to matefaenzadark in Xenial. # In Bionic it is called Faenza-Dark, install the faenza-icon-theme # package to make it available. dark_themes = ["matefaenzagray", "matefaenzadark", "Faenza-Dark"] for t in dark_themes: d = os.path.join("/usr", "share", "icons", t, "status", "22") if (os.path.isdir(d)): self.ind.set_icon_theme_path(d) found_theme = True break if (not found_theme): print("Ubuntu 18.04 doesn't have the icon installed by default.") print("Use 'apt-get install faenza-icon-theme' to install the icon") # create the menu self.menu = gtk.Menu() self.activate_item = gtk.MenuItem("Activate") self.activate_item.connect("activate", self.toggle) self.activate_item.show() self.menu.append(self.activate_item) # add the quit option if need be. if (show_quit): self.quit_item = gtk.MenuItem("Quit") self.quit_item.connect("activate", self.quit) self.quit_item.show() self.menu.append(self.quit_item) # add the menu self.ind.set_menu(self.menu) # set default state self.activated = False self.proc = None # if enabled, activate it. if (start_enabled): self.activate() # if we run in debug mode, call the debug method every 100ms if (debug): gtk.timeout_add(100, self.debug)
def start_main(): # Init. DBusGMainLoop(set_as_default=True) gtk.gdk.threads_init() session_bus = dbus.SessionBus() options, arguments = get_parser() # Send hello message if updater has running. if is_dbus_name_exists(DSC_FRONTEND_NAME, True): bus_object = session_bus.get_object(DSC_FRONTEND_NAME, DSC_FRONTEND_PATH) bus_interface = dbus.Interface(bus_object, DSC_FRONTEND_NAME) bus_interface.raise_to_top() if options.show_page: bus_interface.show_page(options.show_page) else: # Init dbus. bus_name = dbus.service.BusName(DSC_FRONTEND_NAME, session_bus) software_center = DeepinSoftwareCenter(session_bus, arguments) if options.show_page: gtk.timeout_add(500, lambda:software_center.show_page(options.show_page)) if options.show_recommend: software_center.recommend_status = options.show_recommend if options.start_quiet: software_center.init_hide = True try: software_center.run() except KeyboardInterrupt: software_center.bus_interface.request_quit()
def main(self): parser = SafeConfigParser() try: parser.read(self.base_folder + '/' + self.CONFIG_FILENAME) self.server = parser.get(self.CONFIG_SECTION, 'server') self.port = parser.getint(self.CONFIG_SECTION, 'port') self.user = parser.get(self.CONFIG_SECTION, 'user') self.password = parser.get(self.CONFIG_SECTION, 'password') self.timeout = parser.getint(self.CONFIG_SECTION, 'timeout') rpc_interval = parser.getint(self.CONFIG_SECTION, 'rpc_interval') except Exception as e : print( e ); self.displayErrorAndExit( "Could not read configuration '"+self.CONFIG_FILENAME+"'\nError is: "+e.message) if parser.has_option(self.CONFIG_SECTION, "rpc_logger_level"): transmissionrpc.utils.add_stdout_logger(parser.get(self.CONFIG_SECTION, 'rpc_logger_level')); self.check_alt_speed_enabled() # The callback function is called repeatedly until it returns False, # at which point the timeout is automatically destroyed and the function will not be called again # http://www.pygtk.org/pygtk2reference/gobject-functions.html#function-gobject--timeout-add gtk.timeout_add( rpc_interval * 1000, self.check_alt_speed_enabled) gtk.main()
def on_step_run(self): # `get_step_options` is provided by the `StepOptionsController` mixin. options = self.get_step_options() if options.run_pstrace and options.script: app_values = self.get_app_values() exe_path = path(app_values['pstrace_exe']) script = path(options.script) if not exe_path.isfile(): logger.error('[PSTraceLauncher] invalid exe-path: %s' % exe_path.abspath()) elif not script.isfile(): logger.error('[PSTraceLauncher] invalid script-path: %s' % script.abspath()) elif os.name != 'nt': logger.error('[PSTraceLauncher] This plugin is only supported ' 'on Windows') else: pstrace_processes = [p for p in psutil.process_iter() if safe_psutil_attr(p, 'exe') == exe_path.abspath()] if not pstrace_processes: if options.delay_ms > 0: logger.info('[PSTraceLauncher] delay: %s ms', options.delay_ms) gtk.timeout_add(options.delay_ms, self._execute, exe_path, script) else: self._execute(exe_path, script) else: logger.info('[PSTraceLauncher] skipping, since PSTrace is ' 'already running as process %s', [p.pid for p in pstrace_processes]) self.complete_step()
def update_feed(self): gh_feed = feedparser.parse(self.gh_feed_url) if gh_feed['entries'][0]['id'] == self.latest_entry_id: gtk.timeout_add(GH_FEED_UPDATE_INTERVAL, self.update_feed) return # nothing to update # Clear old entries cur_menu_items = self.menu.get_children() for i in range(3,len(cur_menu_items)): self.menu.remove(cur_menu_items[i]) self.latest_entry_id = gh_feed['entries'][0]['id'] self.ind.set_status (appindicator.STATUS_ATTENTION) # Repopulate menu items i = 0 for entry in gh_feed['entries']: i = i + 1 if i > GH_FEED_ITEMS: break t = entry['title_detail']['value'] menu_item = gtk.MenuItem(t) self.menu.append(menu_item) menu_item.connect("activate", self.feeditem_click,entry) menu_item.show() gtk.timeout_add(GH_FEED_UPDATE_INTERVAL, self.update_feed)
def __init__(self, pkg_name, alias_name, data_manager): ''' Initialize ItemIcon class. @param pixbuf: Icon pixbuf. ''' IconItem.__init__(self) self.pkg_name = pkg_name self.alias_name = alias_name self.data_manager = data_manager self.star_level = get_star_level(5.0) self.star_buffer = DscStarBuffer(pkg_name) self.grade_star = 0 self.icon_padding_y = 10 self.name_padding_y = 20 self.star_padding_y = 5 self.width = 132 self.height = 150 self.icon_pixbuf = None self.hover_flag = False self.highlight_flag = False self.button_status = BUTTON_NORMAL # TODO: fetch install_status self.install_status = "uninstalled" self.desktops = [] gtk.timeout_add(2000, self.data_manager.get_pkg_installed, self.pkg_name, self.handle_pkg_status)
def __init__(self): TrayIconWin.__init__(self) if is_exists(APP_DBUS_NAME, APP_OBJECT_NAME): sys.exit() app_bus_name = dbus.service.BusName(APP_DBUS_NAME, bus=dbus.SessionBus()) UniqueService(app_bus_name, APP_DBUS_NAME, APP_OBJECT_NAME) self.__save_trayicon = None self.__found_dock = False self.metry = None self.__save_width = 0 self.tray_icon_to_screen_width=10 root = self.get_root_window() self.menu_screen = root.get_screen() self.plugin_manage = PluginManage() self.display = display.Display() self.screen = self.display.screen() self.opcode_atom = self.display.intern_atom("_NET_SYSTEM_TRAY_OPCODE") self.visual_atom = self.display.intern_atom("_NET_SYSTEM_TRAY_VISUAL") self.dock_atom = self.display.intern_atom("_NET_SYSTEM_TRAY_S%d" % (self.display.get_default_screen())) self.tray_window = None self.__tray_find_dock() gtk.timeout_add(2000, self.__tray_find_dock)
def make_window(self) : # Create the main window. self.win.fullscreen() # Handle events. self.win.connect("key-press-event", self.key_press_event) self.win.connect("destroy", gtk.main_quit) # Center widget. vbox = gtk.VBox() hbox = gtk.HBox() vbox.add(hbox) # Create welcome-message. self.text = " (◣_◢) " self.label = gtk.Label() self.label_color = '#ffffff' self.label.set_use_markup(True) self.set_label(self.label_color, self.text) hbox.add(self.label) # Create window self.win.add(vbox) self.win.show_all() gtk.timeout_add(7000, do_quit_application, self) gtk.timeout_add(500, do_label_glow_darker, self) gtk.main()
def refresh(self, widget=None, no_timer=False, chrome_data_directory=None, firefox_data_directory=None): """Refreshes the menu """ try: # Create an array of 20 false to denote matches in History searchResults = [False] * 20 data = list(reversed(HackerNews.getHomePage()[0:20])) urls = [item['url'] for item in data] if chrome_data_directory: searchResults = self.mergeBoolArray(searchResults, Chrome.search(urls, chrome_data_directory)) if firefox_data_directory: searchResults = self.mergeBoolArray(searchResults, Firefox.search(urls, firefox_data_directory)) # Remove all the current stories for i in self.menu.get_children(): if hasattr(i, 'url'): self.menu.remove(i) # Add back all the refreshed news for index, item in enumerate(data): item['history'] = searchResults[index] if item['url'].startswith('item?id='): item['url'] = "https://news.ycombinator.com/" + item['url'] self.addItem(item) # Catch network errors except requests.exceptions.RequestException as e: print "[+] There was an error in fetching news items" finally: # Call every 10 minutes if not no_timer: gtk.timeout_add(10 * 30 * 1000, self.refresh, widget, no_timer, chrome_data_directory)
def __init__(self): self.config = Config() self.indicator = WeatherIndicator() self.weather = None gtk.timeout_add(self.config.get_update_interval(), self.update_weather) self.update_weather()
def on_symbols_found_i(scanner, np_img, symbols, row_i): from .proxy import proxy_for # Stop listening for `symbols-found` signal. scanner.disconnect(row_i['callback_ids']['symbol']) del row_i['callback_ids']['symbol'] # Concatenate symbols text as comma-separated list. symbol_data = ', '.join([symbol_j['data'] for symbol_j in symbols]) # Fill widget with scanned value (if possible). proxy = proxy_for(row_i['widget']) try: proxy.set_widget_value(symbol_data) except TypeError: logger.error('Could not set value for "%s"', row_i['label'].get_label(), exc_info=True) else: # Make system bell sound to indicate a scan has # completed. print '\a\a', # Re-enable the scan button. row_i['button'].set_sensitive(True) # Close scan dialog after a short delay (let user see the # scanned match). gtk.timeout_add(1000, lambda *args: self.scanner_window.hide()) return True
def refresh(self, widget=None, no_timer=False): """Refreshes the menu """ old_hunts = self.posts_to_set(ProductHunt.posts) data = list(reversed(ProductHunt.getPosts())) #Remove all the current stories for i in self.menu.get_children(): if hasattr(i, 'url'): self.menu.remove(i) #Add back all the refreshed news for index, item in enumerate(data): self.addItem(item) # Send notifications if needed if pynotify: new_hunts = self.posts_to_set(ProductHunt.posts) difference = new_hunts - old_hunts if len(difference) > 0: pynotify.Notification("Product Hunt", str(len(difference))+" new hunts", PHreak.icon_filename).show() if not no_timer: gtk.timeout_add(10 * 30 * 1000, self.refresh, widget, no_timer)
def __init__(self, padding_x=0, padding_y=0, mask_bound_height=24, ): ''' Initialize IconView class. @param padding_x: Horizontal padding value. @param padding_y: Vertical padding value. ''' # Init. gtk.DrawingArea.__init__(self) self.padding_x = padding_x self.padding_y = padding_y self.mask_bound_height = mask_bound_height self.add_events(gtk.gdk.ALL_EVENTS_MASK) self.set_can_focus(True) # can focus to response key-press signal self.items = [] self.focus_index = None self.highlight_item = None self.double_click_item = None self.single_click_item = None # Signal. self.connect("realize", self.realize_icon_view) self.connect("realize", lambda w: self.grab_focus()) # focus key after realize self.connect("expose-event", self.expose_icon_view) self.connect("motion-notify-event", self.motion_icon_view) self.connect("button-press-event", self.button_press_icon_view) self.connect("button-release-event", self.button_release_icon_view) self.connect("leave-notify-event", self.leave_icon_view) self.connect("key-press-event", self.key_press_icon_view) # Add item singal. self.connect("lost-focus-item", lambda view, item: item.icon_item_lost_focus()) self.connect("motion-notify-item", lambda view, item, x, y: item.icon_item_motion_notify(x, y)) self.connect("highlight-item", lambda view, item: item.icon_item_highlight()) self.connect("normal-item", lambda view, item: item.icon_item_normal()) self.connect("button-press-item", lambda view, item, x, y: item.icon_item_button_press(x, y)) self.connect("button-release-item", lambda view, item, x, y: item.icon_item_button_release(x, y)) self.connect("single-click-item", lambda view, item, x, y: item.icon_item_single_click(x, y)) self.connect("double-click-item", lambda view, item, x, y: item.icon_item_double_click(x, y)) # Redraw. self.redraw_request_list = [] self.redraw_delay = 100 # 100 milliseconds should be enough for redraw gtk.timeout_add(self.redraw_delay, self.update_redraw_request_list) self.keymap = { "Home" : self.select_first_item, "End" : self.select_last_item, "Return" : self.return_item, "Up" : self.select_up_item, "Down" : self.select_down_item, "Left" : self.select_left_item, "Right" : self.select_right_item, "Page_Up" : self.scroll_page_up, "Page_Down" : self.scroll_page_down, }
def show_analog_clock(self, widget=None): self.analog = True gtk.timeout_add(200, self.update_analog_clock) self.press_before = time.time() self.clear_screen() self.add(self.clock_button) self.show_all()
def __init__(self, applet, iid): print "Initializing the applet" # this is referenced many times afterwards self.applet = applet # load icons self.icon_unknown = gtk.Image() self.icon_unknown.set_from_file( STUFF_ROOT_DIR + "/icon_unknown.png") self.icon_running = gtk.Image() self.icon_running.set_from_file( STUFF_ROOT_DIR + "/icon_running.png") self.icon_stopped = gtk.Image() self.icon_stopped.set_from_file( STUFF_ROOT_DIR + "/icon_stopped.png") self.icon_pending = gtk.Image() self.icon_pending.set_from_file( STUFF_ROOT_DIR + "/icon_pending.png") self.icon_stopping = gtk.Image() self.icon_stopping.set_from_file( STUFF_ROOT_DIR + "/icon_stopping.png") # initial state and view self.state = "unknown" # set directly only this one time in initialization self.icon = self.icon_unknown self.replace_icon("unknown", "Initializing") # list of instance names or id's for tooltip self.names = "" # public dns(s) self.public_dns = "" # init conifg self.read_gconf() # timeout for ec2 queries socket.setdefaulttimeout(3) # this flag is set then instances are started # when they reach started state the elastic ips are set self.ip_pending = False # create right-click-menu menu = open(STUFF_ROOT_DIR + "/menu.xml").read() verbs = [("Start", self.menu_start), ("Shutdown", self.menu_shutdown), ("Configuration", self.menu_configuration), ("Refresh", self.menu_refresh), ("PublicDNS", self.menu_public_dns)] applet.setup_menu(menu, verbs, None) applet.set_background_widget(applet) # /* enable transparency hack */ # update now and in future self.fast_poll_baseline = time.time() self.fast_poll_timeout = 5 self.slow_poll_timeout = 300 self.last_poll_timestamp = 0 # 3 mins of fast polling after any user action or state change self.fast_poll_timeframe = 180 self.update() gtk.timeout_add(1000, self.timer) self.applet.show_all()
def __init__(self): gtk.timeout_add(500, self.my_timer) # call every half a sec self.commonFolders = gtk.ListStore(str) # Pre load a list of used folders here self.wTree = gtk.glade.XML("gwget3.glade") # Load the glade file # Show the main window self.wTree.get_widget("main_window").show() # Connect all signals self.wTree.signal_autoconnect(self)
def on_interlude_audio_changed (self, player): "Audio source for interlude music has changed." log.info("Interlude track changed to {}.".format(self.b.player.get_current_uri())) gtk.timeout_add(self.slider_update_interval, self.update_slider) uri = self.b.player.get_current_uri() if uri.startswith("file://"): uri = os.path.basename(uri) self.interlude_label.set_text(uri)
def connect_to_device(self): con = self.crobot.connect() if con: if self.timeout_active == False: print("(re)connected") self.update_servoinfo() self.timeout_active = True gtk.timeout_add(Screen.TIMEOUT, self.timeout)
def CreateNotificationAt(self, at, msg): nid = self._GetNextId() delta = at - datetime.datetime.now() if delta.total_seconds() <= 0: self._ShowNotification('NOTIFICATION IN THE PAST!!!!', msg) else: self.pending_notifications[nid] = (at, msg) gtk.timeout_add(int(delta.total_seconds()) * 1000, self._ShowPendingNotification, nid)
def shutdown(self, reaction="stop"): """This function will shutdown the device or restart in case the argument reboot is True :param reboot: Indicates if the device should reboot or shutdown """ gtk.timeout_add(1, self.controller.shutdown, reaction) return
def check_time(self): now = time.gmtime() hour = now.tm_hour mn = now.tm_min sec = now.tm_sec update = "%d" % (((sec + (60 * mn) + ((hour + 1) * 3600)) / 86.4) % 1000) self.ind.set_label(update) gtk.timeout_add(PING_FREQUENCY * 1000, self.check_time)
def run (self): gtk.timeout_add (self.TIMEOUT, self.code_exec) try: if gtk.gtk_version[0] == 2: gtk.gdk.threads_init() except: pass gtk.main ()
def close_prog(self, prog_id): """This function closes a prog. After closing the PBase will be showed. :param prog_id: id of the prog which should be closed """ gtk.timeout_add(1, self.controller.stop_prog, prog_id) return
def start(self): self.bind_signals() # Force unmute to properly initialize unmuted state self.toggle_mute() gtk.timeout_add(self.update_interval, self.update) log.info("Blockify started.") gtk.main()
def __init__(self): self.button = {} self.move = [0,0,0] self.dirskeys = ( ( ['w'] , ['s'] ) , ( ['a'] , ['d'] ) , ( ['e'] , ['q'] ) ) for d in self.dirskeys : for e in d : for i in range(len(e)) : e[i] = ( gtk.gdk.unicode_to_keyval(ord(e[i])) , False ) self.near = 1 self.far = 1000 self.fov = 60 builder = gtk.Builder() builder.add_from_file(ui_file) glconfig = self.init_glext() self.drawing_area = GLDrawingArea(glconfig) self.drawing_area.set_events( gtk.gdk.BUTTON_PRESS_MASK | gtk.gdk.BUTTON_RELEASE_MASK | gtk.gdk.BUTTON1_MOTION_MASK | gtk.gdk.BUTTON2_MOTION_MASK |gtk.gdk.BUTTON3_MOTION_MASK ) self.drawing_area.set_size_request(320,240) builder.get_object("vbox1").pack_start(self.drawing_area) win_main = builder.get_object("win_main") win_main.set_events( gtk.gdk.KEY_PRESS_MASK | gtk.gdk.KEY_RELEASE_MASK ) win_main.connect('key-press-event' , self._on_key_pressed ) win_main.connect('key-release-event', self._on_key_released ) self.scene = Scene( self.fov , .01 , self.near , self.far ) self.drawing_area.add( self.scene , ( 0,0,.5,1) ) self.drawing_area.add( self.scene , (.5,0,.5,1) ) print 'Scene added' win_main.show_all() width = self.drawing_area.allocation.width / 2.0 height = self.drawing_area.allocation.height ratio = float(width)/float(height) self.scene.set_ratio( ratio ) builder.connect_signals(self) # self.statbar = builder.get_object('statbar') self.drawing_area.connect('motion_notify_event',self._on_mouse_motion) self.drawing_area.connect('button_press_event',self._on_button_pressed) self.drawing_area.connect('button_release_event',self._on_button_released) self.drawing_area.connect('configure_event',self._on_reshape) self.drawing_area.connect_after('expose_event',self._after_draw) gtk.timeout_add( 1 , self._refresh )
def __init__(self, conn): self.conn = conn self.grfp = None parmbox = gtk.HBox() self.adjs = {} def add_parm(key, name, lb, ub, incr=None, page=None): if incr is None: incr = (ub - lb) / 100 if page is None: page = incr * 10 adj = gtk.Adjustment(0.0, lb, ub, incr, page, 0.0) self.adjs[key] = adj scale = gtk.VScale(adj) scale.set_digits(2) scale.set_size_request(25, 170) adj.connect("value_changed", self.parm_changed, key) parmbox.add(add_gtk_frame(name, scale)) add_parm("p_gain", "P Gain", 0.0, 20.0) add_parm("d_gain", "D Gain", 0.0, 10.0) add_parm("i_gain", "I Gain", 0.0, 20.0) add_parm("hard_speed_lim", "Hard Speed Lim", 0.0, 1.0) add_parm("fwd_speed_lim", "Fwd Speed Lim", 0.01, 1.2) add_parm("rev_speed_lim", "Rev Speed Lim", 0.01, 1.2) add_parm("pitch_bias", "Pitch Bias", -0.4, 0.4) drivebox = gtk.HBox() def add_drive(key, name, lb, ub, incr=None, page=None): if incr is None: incr = (ub - lb) / 100 if page is None: page = incr * 10 adj = gtk.Adjustment(0.0, lb, ub, incr, page, 0.0) self.adjs[key] = adj scale = gtk.VScale(adj) scale.set_digits(2) scale.set_size_request(25, 170) adj.connect("value_changed", self.drive_changed, key) drivebox.add(add_gtk_frame(name, scale)) add_drive("speed_targ", "Speed", -0.2, 0.2) add_drive("steering_targ", "Steering", -0.8, 0.8) self.read_parms = None gtk.timeout_add(50, self.periodic) BasicApp.__init__(self, gtkvb(parmbox, drivebox))
def __init__(self, data_manager): # Init. gtk.VBox.__init__(self) self.data_manager = data_manager self.tab_box = gtk.HBox() self.tab_box.set_size_request(-1, RANK_TAB_HEIGHT) self.tab_box.set_spacing(1) self.tab_box_align = gtk.Alignment() self.tab_box_align.set(1, 0, 0, 0) self.tab_box_align.set_padding(3, 9, 25, 48) for (tab_index, tab_name) in enumerate([_("Top 25 weekly"), _("Top 25 monthly"), _("Top 25 totally")]): self.tab_box.pack_start(RankTab(tab_index, tab_name, tab_index == 0), False, False) self.page_box = gtk.VBox() self.page_align = gtk.Alignment() self.page_align.set(0.5, 0.5, 1, 1) self.page_align.set_padding(0, 0, 15, 15) self.week_rank_icon_view = IconView() self.week_rank_icon_view_scrlledwindow = ScrolledWindow() self.week_rank_icon_view.draw_mask = self.draw_mask self.month_rank_icon_view = IconView() self.month_rank_icon_view_scrlledwindow = ScrolledWindow() self.month_rank_icon_view.draw_mask = self.draw_mask self.all_rank_icon_view = IconView() self.all_rank_icon_view_scrlledwindow = ScrolledWindow() self.all_rank_icon_view.draw_mask = self.draw_mask self.week_rank_icon_view_scrlledwindow.add_child(self.week_rank_icon_view) self.month_rank_icon_view_scrlledwindow.add_child(self.month_rank_icon_view) self.all_rank_icon_view_scrlledwindow.add_child(self.all_rank_icon_view) self.tab_box_align.add(self.tab_box) self.page_box.pack_start(self.page_align) self.pack_start(self.tab_box_align, False, False) self.pack_start(self.page_box, True, True) self.loading = LoadingBox() self.view_list = [ ('week', self.week_rank_icon_view, self.week_rank_icon_view_scrlledwindow), ('month', self.month_rank_icon_view, self.month_rank_icon_view_scrlledwindow), ('all', self.all_rank_icon_view, self.all_rank_icon_view_scrlledwindow)] self.pkg_names = [] self.show_flag = None self.all_show_flag = ['week', 'month', 'all'] global_event.register_event("update-rank-page", self.update_rank_page) gtk.timeout_add(300, self.get_pkgs_status) global_event.emit("update-rank-page", 0)