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)
