class MirrorsBox(BaseBox):
def __init__(self):
BaseBox.__init__(self)
self.current_mirror_item = None
self.select_best_mirror_button_texts = {
"normal": _("Select the best mirror"),
"wait": _("Waiting"),
"success": _("Successfully")
}
self.main_box.pack_start(self.create_mirror_select_table(), True, True)
self.main_box.pack_start(self.create_source_update_frequency_table(), False, True)
self.mirror_test_obj = None
global_event.register_event("mirror-test-finished", self.finish_mirror_test)
global_event.register_event("cancel-mirror-test", self.cancel_mirror_test)
global_event.register_event("mirror-backend-changed", self.mirror_changed_handler)
def create_source_update_frequency_table(self):
main_table = gtk.Table(3, 2)
main_table.set_row_spacings(CONTENT_ROW_SPACING)
dir_title_label = Label(_("Refresh package lists"))
# auto update check button
self.is_auto_update_button = CheckButton(label_text=_('Upgrade automatically'))
self.is_auto_update_button.connect('released', self.change_auto_update)
self.is_auto_update_button.set_active(utils.is_auto_update())
self.update_label = Label(_("Time interval: "))
self.update_spin = SpinBox(int(get_update_interval()), 0, 168, 1)
self.update_spin.connect("value-changed", lambda w, v: set_update_interval(v))
self.hour_lablel = Label(_(" hour"))
self.hour_lablel.set_size_request(50, 12)
spin_hbox = gtk.HBox(spacing=3)
spin_hbox.pack_start(self.update_label, False, False)
spin_hbox.pack_start(self.update_spin, False, False)
spin_hbox.pack_start(self.hour_lablel, False, False)
main_table.attach(dir_title_label, 0, 2, 0, 1, yoptions=gtk.FILL)
main_table.attach(create_separator_box(), 0, 2, 1, 2, yoptions=gtk.FILL)
main_table.attach(self.is_auto_update_button, 0, 1, 2, 3, xoptions=gtk.FILL)
main_table.attach(spin_hbox, 1, 2, 2, 3, xpadding=10, xoptions=gtk.FILL)
return main_table
def change_auto_update(self, widget, data=None):
widget_active = widget.get_active()
self.update_spin.set_sensitive(widget_active)
self.update_label.set_sensitive(widget_active)
self.hour_lablel.set_sensitive(widget_active)
utils.set_auto_update(widget_active)
daemon_running = is_dbus_name_exists(DSC_UPDATE_DAEMON_NAME)
if widget_active and not daemon_running:
dsc_daemon_path = os.path.join(get_parent_dir(__file__, 2), 'update_data/apt/dsc-daemon.py')
subprocess.Popen(['python', dsc_daemon_path], stderr=subprocess.STDOUT, shell=False)
elif not widget_active and daemon_running:
session = dbus.SessionBus()
dbus_obj = session.get_object(DSC_UPDATE_DAEMON_NAME, DSC_UPDATE_DAEMON_PATH)
iface = dbus.Interface(dbus_obj, DSC_UPDATE_DAEMON_NAME)
iface.quit()
def select_best_mirror(self, widget):
widget.set_label(self.select_best_mirror_button_texts["wait"])
widget.set_sensitive(False)
global_event.emit("toggle-waiting-dialog", True)
utils.ThreadMethod(self.change_to_nearest_mirror_thread, (widget, )).start()
def cancel_mirror_test(self):
if self.mirror_test_obj:
self.mirror_test_obj.cancel()
self.mirror_test_obj = None
self.finish_mirror_test("")
def change_to_nearest_mirror_thread(self, widget):
from mirror_speed.ip_detect import get_nearest_mirrors
hostnames = get_nearest_mirrors()
self.mirror_test_obj = MirrorTest(hostnames)
hostname = self.mirror_test_obj.run()
for mirror in self.mirrors_list:
if mirror.hostname == hostname:
global_event.emit("mirror-test-finished", mirror)
break
def finish_mirror_test(self, mirror):
for item in self.mirror_view.visible_items:
if item.mirror == mirror:
self.mirror_view.visible_item(item)
self.select_best_mirror_button.set_sensitive(True)
self.select_best_mirror_button.set_label(self.select_best_mirror_button_texts["normal"])
def create_mirror_select_table(self):
main_table = gtk.Table(3, 2)
main_table.set_row_spacings(CONTENT_ROW_SPACING)
mirror_select_title = Label(_("Select mirror"))
self.select_best_mirror_button = Button(self.select_best_mirror_button_texts["normal"])
self.select_best_mirror_button.connect("clicked", self.select_best_mirror)
self.mirrors_dir = os.path.join(get_parent_dir(__file__, 2), 'mirrors')
self.current_mirror_hostname = utils.get_current_mirror_hostname()
self.mirror_items = self.get_mirror_items()
self.mirror_view = TreeView(self.mirror_items,
enable_drag_drop=False,
enable_multiple_select=False,
mask_bound_height=0,
)
self.mirror_view.set_expand_column(1)
self.mirror_view.set_size_request(-1, 280)
self.mirror_view.draw_mask = self.mirror_treeview_draw_mask
main_table.attach(mirror_select_title, 0, 1, 0, 1, yoptions=gtk.FILL)
main_table.attach(self.select_best_mirror_button, 1, 2, 0, 1, xoptions=gtk.FILL)
main_table.attach(create_separator_box(), 0, 2, 1, 2, xoptions=gtk.FILL)
main_table.attach(self.mirror_view, 0, 2, 2, 3, xoptions=gtk.FILL)
return main_table
def mirror_changed_handler(self, mirror):
item = None
for i in self.mirror_view.visible_items:
if i.mirror == mirror:
item = i
break
if item:
self.current_mirror_item = item
for i in self.mirror_items:
if i != item and i.radio_button.active == True:
i.radio_button.active = False
elif i == item:
i.radio_button.active = True
self.mirror_view.queue_draw()
self.mirror_view.visible_item(item)
def mirror_treeview_draw_mask(self, cr, x, y, w, h):
cr.set_source_rgba(1, 1, 1, 0.5)
cr.rectangle(x, y, w, h)
cr.fill()
def get_mirror_items(self):
items = []
self.mirrors_list = get_mirrors()
for m in self.mirrors_list:
item = MirrorItem(m, self.mirror_clicked_callback)
if m.hostname == self.current_mirror_hostname:
item.radio_button.active = True
self.current_mirror_item = item
items.append(item)
items.sort(key=lambda item:item.mirror.priority)
return items
def mirror_clicked_callback(self, item):
if item != self.current_mirror_item:
global_event.emit('start-change-mirror', item.mirror)
class PreferenceDialog(DialogBox):
def __init__(self):
super(PreferenceDialog, self).__init__(_("Preference"), 575, 495,
mask_type=DIALOG_MASK_MULTIPLE_PAGE,
close_callback=self.hide_all)
self.set_position(gtk.WIN_POS_CENTER)
self.main_box = gtk.VBox()
close_button = Button(_("Close"))
close_button.connect("clicked", lambda w: self.hide_all())
# Init widget.
self.general_setting = GeneralSetting()
self.hotkey_setting = HotKeySetting()
self.desktop_lyrics_setting = DesktopLyricsSetting()
self.scroll_lyrics_setting = ScrollLyricsSetting()
# Category bar
self.category_bar = TreeView(font_x_padding=20)
self.category_bar.draw_mask = self.draw_treeview_mask
self.general_category_item = CategoryItem(_("General"), self.general_setting)
self.category_bar.add_item(None, self.general_category_item)
self.category_bar.add_item(None, CategoryItem(_("Hotkeys"), self.hotkey_setting))
lyrics_node = self.category_bar.add_item(None, CategoryItem(_("Lyrics")))
self.category_bar.add_item(lyrics_node, CategoryItem(_("Desktop"), self.desktop_lyrics_setting))
self.category_bar.add_item(lyrics_node, CategoryItem(_("Window"), self.scroll_lyrics_setting))
self.category_bar.add_item(None, CategoryItem(_("About us"), AboutBox()))
self.category_bar.connect("single-click-item", self.category_single_click_cb)
self.category_bar.set_highlight_index(0)
category_box = gtk.VBox()
background_box = BackgroundBox()
background_box.set_size_request(132, 11)
background_box.draw_mask = self.draw_treeview_mask
category_box.pack_start(background_box, False, False)
category_scrolled_window = ScrolledWindow()
category_scrolled_window.add_child(self.category_bar)
category_scrolled_window.set_policy(gtk.POLICY_NEVER, gtk.POLICY_NEVER)
category_scrolled_window.set_size_request(132, 516)
category_scrolled_window_align = gtk.Alignment()
category_scrolled_window_align.set(0, 0, 1, 1,)
category_scrolled_window_align.set_padding(0, 1, 0, 0)
category_scrolled_window_align.add(category_scrolled_window)
category_box.pack_start(category_scrolled_window_align, True, True)
# Pack widget.
left_box = gtk.VBox()
self.right_box = gtk.VBox()
left_box.add(category_box)
self.right_box.add(self.general_category_item.get_allocated_widget())
right_align = gtk.Alignment()
right_align.set_padding(0, 0, 10, 0)
right_align.add(self.right_box)
body_box = gtk.HBox()
body_box.pack_start(left_box, False, False)
body_box.pack_start(right_align, False, False)
self.main_box.add(body_box)
# DialogBox code.
self.body_box.pack_start(self.main_box, True, True)
self.right_button_box.set_buttons([close_button])
def switch_lyrics_page(self, index=3):
self.category_bar.tree_list[2].show_child_items_bool = True
self.category_bar.sort()
self.category_bar.queue_draw()
self.category_bar.set_highlight_index(index)
highlight_item = self.category_bar.get_highlight_item()
self.category_single_click_cb(None, highlight_item)
def show_scroll_lyrics_page(self):
self.switch_lyrics_page(4)
self.show_all()
def show_desktop_lyrics_page(self):
self.switch_lyrics_page(3)
self.show_all()
def draw_treeview_mask(self, cr, x, y, width, height):
draw_alpha_mask(cr, x, y, width, height, ("#FFFFFF", 0.9))
def category_single_click_cb(self, widget, item):
if item.get_allocated_widget():
switch_tab(self.right_box, item.get_allocated_widget())
class DscPreferenceDialog(PreferenceDialog):
def __init__(self):
PreferenceDialog.__init__(self, 566, 488)
self.current_mirror_item = None
self.normal_settings = gtk.VBox()
self.normal_settings.set_spacing(TABLE_ROW_SPACING)
self.normal_settings.pack_start(self.create_uninstall_box(), False, True)
self.normal_settings.pack_start(self.create_download_dir_table(), False, True)
self.normal_settings_align = gtk.Alignment(0, 0, 1, 1)
self.normal_settings_align.set_padding(padding_left=5, padding_right=5, padding_top=25, padding_bottom=10)
self.normal_settings_align.add(self.normal_settings)
self.mirror_settings = gtk.VBox()
self.mirror_settings.set_app_paintable(True)
self.mirror_settings.connect("expose-event", self.mirror_settings_align_expose)
self.mirror_settings.set_spacing(TABLE_ROW_SPACING)
self.mirror_settings.pack_start(self.create_mirror_select_table(), False, True)
self.mirror_settings.pack_start(self.create_source_update_frequency_table(), False, True)
self.mirror_settings_inner_align = gtk.Alignment(0.5, 0.5, 1, 1)
self.mirror_settings_inner_align.set_padding(padding_top=25, padding_bottom=10, padding_left=0, padding_right=0)
self.mirror_settings_inner_align.add(self.mirror_settings)
self.mirror_settings_scrolled_win = ScrolledWindow()
self.mirror_settings_scrolled_win.add_child(self.mirror_settings_inner_align)
self.mirror_settings_align = gtk.Alignment(0, 0, 1, 1)
self.mirror_settings_align.set_padding(padding_left=0, padding_right=0, padding_top=0, padding_bottom=3)
self.mirror_settings_align.add(self.mirror_settings_scrolled_win)
self.set_preference_items([
(_("General"), self.normal_settings_align),
(_("Mirrors"), self.mirror_settings_align),
(_("About"), AboutBox()),
])
def mirror_settings_align_expose(self, widget, event=None):
cr = widget.window.cairo_create()
rect = widget.allocation
# draw backgound
cr.rectangle(*rect)
#cr.set_source_rgb(*color_hex_to_cairo("#ff0000"))
cr.set_source_rgba(1, 1, 1, 0)
cr.fill()
def mirror_select_action(self, repo_urls):
self.data_manager.change_source_list(repo_urls, reply_handler=handle_dbus_reply, error_handler=handle_dbus_error)
def create_mirror_select_table(self):
vbox = gtk.VBox()
vbox.set_size_request(423, -1)
main_table = gtk.Table(2, 2)
main_table.set_row_spacings(CONTENT_ROW_SPACING)
dir_title_label = Label(_("Select mirror"))
dir_title_label.set_size_request(423, 12)
label_align = gtk.Alignment()
label_align.set_padding(0, 0, 10, 0)
label_align.add(dir_title_label)
self.mirrors_dir = os.path.join(get_parent_dir(__file__, 2), 'mirrors')
self.current_mirror_hostname = utils.get_current_mirror_hostname()
self.mirror_items = self.get_mirror_items()
self.mirror_view = TreeView(self.mirror_items,
enable_drag_drop=False,
enable_multiple_select=False,
#mask_bound_height=0,
)
self.mirror_view.set_expand_column(1)
self.mirror_view.set_size_request(-1, len(self.mirror_view.visible_items) * self.mirror_view.visible_items[0].get_height())
self.mirror_view.draw_mask = self.mirror_treeview_draw_mask
#self.display_current_mirror()
self.mirror_test_progressbar = ProgressBar()
main_table.attach(label_align, 0, 2, 0, 1, yoptions=gtk.FILL, xpadding=8)
main_table.attach(create_separator_box(), 0, 2, 1, 2, yoptions=gtk.FILL)
title = _("Select best mirror")
info_message = _("Please wait. The process will take 30 seconds or more depending on your network connection")
self.select_best_mirror_dialog = WaitingDialog(title, info_message, self.cancel_mirror_test)
global_event.register_event("mirror-changed", self.mirror_changed_handler)
global_event.register_event("update-list-finish", self.update_list_finish_handler)
vbox.pack_start(main_table, False, False)
vbox.pack_start(self.mirror_view, False, False)
return vbox
def cancel_mirror_test(self, widget):
try:
self.mirror_test.terminated = True
gobject.source_remove(self.update_status_id)
except:
pass
self.select_best_mirror_dialog.hide_all()
def update_list_finish_handler(self):
self.select_best_mirror_dialog.hide_all()
def mirror_changed_handler(self, item):
for i in self.mirror_items:
if i != item and i.radio_button.active == True:
i.radio_button.active = False
elif i == item:
i.radio_button.active = True
self.mirror_view.queue_draw()
def test_mirror_action(self, widget):
self.select_best_mirror_dialog.set_transient_for(self)
self.select_best_mirror_dialog.set_position(gtk.WIN_POS_CENTER_ON_PARENT)
self.select_best_mirror_dialog.show_all()
distro = aptsources.distro.get_distro()
#distro.get_sources(SourcesList())
pipe = os.popen("dpkg --print-architecture")
arch = pipe.read().strip()
test_file = "dists/%s/Contents-%s.gz" % \
(
distro.codename,
#"quantal",
arch,
)
self.mirror_test = MirrorTest(self.mirrors_list, test_file)
self.mirror_test.start()
# now run the tests in a background thread, and update the UI on each event
self.update_status_id = gtk.timeout_add(100, self.update_progress)
def update_progress(self):
if self.mirror_test.running:
return True
else:
time.sleep(1)
if self.mirror_test.best != None:
for item in self.mirror_items:
if item.mirror == self.mirror_test.best[1]:
print item.mirror.get_repo_urls()
self.mirror_clicked_callback(item)
else:
self.select_best_mirror_dialog.loading_widget.hide_all()
self.select_best_mirror_dialog.info_message_label.set_text(_("Test for downloading mirror failed. Please check your network connection."))
self.select_best_mirror_dialog.close_button.set_label(_("Close"))
return False
def mirror_treeview_draw_mask(self, cr, x, y, w, h):
cr.set_source_rgba(1, 1, 1, 0.9)
cr.rectangle(x, y, w, h)
cr.fill()
def get_mirror_items(self):
items = []
self.mirrors_list = []
for ini_file in os.listdir(self.mirrors_dir):
m = Mirror(os.path.join(self.mirrors_dir, ini_file))
item = MirrorItem(m, self.mirror_clicked_callback)
if m.hostname == self.current_mirror_hostname:
item.radio_button.active = True
self.current_mirror_item = item
self.mirrors_list.append(m)
items.append(item)
items.sort(key=lambda x:x.mirror.priority)
return items
def mirror_clicked_callback(self, item):
if item != self.current_mirror_item:
self.current_mirror_item = item
global_event.emit('change-mirror', item)
self.hide_all()
def create_source_update_frequency_table(self):
main_table = gtk.Table(3, 2)
main_table.set_row_spacings(CONTENT_ROW_SPACING)
dir_title_label = Label(_("Update applications lists"))
dir_title_label.set_size_request(200, 12)
label_align = gtk.Alignment()
label_align.set_padding(0, 0, 0, 0)
label_align.add(dir_title_label)
self.is_auto_update_button = CheckButton(label_text=_('Update automatically'))
self.is_auto_update_button.connect('toggled', self.change_auto_update)
self.update_label = Label(_("Time interval: "))
self.update_spin = SpinBox(int(get_update_interval()), 0, 168, 1)
self.update_spin.connect("value-changed", lambda w, v: set_update_interval(v))
self.hour_lablel = Label(_(" hour"))
self.hour_lablel.set_size_request(50, 12)
spin_hbox = gtk.HBox(spacing=3)
spin_hbox.pack_start(self.update_label, False, False)
spin_hbox.pack_start(self.update_spin, False, False)
spin_hbox.pack_start(self.hour_lablel, False, False)
main_table.attach(label_align, 0, 2, 0, 1, yoptions=gtk.FILL, xpadding=8)
main_table.attach(create_separator_box(), 0, 2, 1, 2, yoptions=gtk.FILL)
main_table.attach(self.is_auto_update_button, 0, 1, 2, 3, xpadding=10, xoptions=gtk.FILL)
main_table.attach(spin_hbox, 1, 2, 2, 3, xpadding=10, xoptions=gtk.FILL)
if is_auto_update():
self.is_auto_update_button.set_active(True)
else:
self.is_auto_update_button.toggled()
return main_table
def create_download_dir_table(self):
main_table = gtk.Table(4, 2)
main_table.set_row_spacings(CONTENT_ROW_SPACING)
dir_title_label = Label(_("Download settings"))
dir_title_label.set_size_request(200, 12)
label_align = gtk.Alignment()
label_align.set_padding(0, 0, 0, 0)
label_align.add(dir_title_label)
download_number_label = Label(_('Max download task number: '))
self.download_number_comobox = ComboBox(
items = [(str(i+1), i+1) for i in range(10)],
select_index = int(get_download_number())-1,
)
self.download_number_comobox.connect("item-selected", self.download_number_comobox_changed)
download_number_hbox = gtk.HBox(spacing=5)
download_number_hbox.pack_start(download_number_label, False, False)
download_number_hbox.pack_start(self.download_number_comobox, False, False)
change_download_dir_label = Label(_("Download directory: "))
self.dir_entry = InputEntry()
self.dir_entry.set_text(get_software_download_dir())
self.dir_entry.set_editable(False)
self.dir_entry.set_size(200, 25)
modify_button = Button(_("Change"))
modify_button.connect("clicked", self.change_download_save_dir)
download_dir_hbox = gtk.HBox(spacing=5)
download_dir_hbox.pack_start(change_download_dir_label, False, False)
download_dir_hbox.pack_start(self.dir_entry, False, False)
download_dir_hbox.pack_start(modify_button, False, False)
main_table.attach(label_align, 0, 2, 0, 1, yoptions=gtk.FILL, xpadding=8)
main_table.attach(create_separator_box(), 0, 2, 1, 2, yoptions=gtk.FILL)
main_table.attach(download_number_hbox, 0, 2, 2, 3, xpadding=10, xoptions=gtk.FILL)
main_table.attach(download_dir_hbox, 0, 2, 3, 4, xpadding=10, xoptions=gtk.FILL)
return main_table
def create_uninstall_box(self):
main_table = gtk.Table(2, 2)
main_table.set_row_spacings(CONTENT_ROW_SPACING)
uninstall_title_label = Label(_("On uninstall software"))
uninstall_title_label.set_size_request(350, 12)
# mini_check_button
self.delete_check_button = CheckButton(_("Delete configuration files"))
self.delete_check_button.set_active(get_purg_flag())
self.delete_check_button.connect("toggled", lambda w: set_purge_flag(self.delete_check_button.get_active()))
main_table.attach(uninstall_title_label, 0, 2, 0, 1, yoptions=gtk.FILL, xpadding=8)
main_table.attach(create_separator_box(), 0, 2, 1, 2, yoptions=gtk.FILL)
main_table.attach(self.delete_check_button, 0, 1, 2, 3, yoptions=gtk.FILL)
return main_table
def change_download_save_dir(self, widget):
local_dir = WinDir(False).run()
if local_dir:
local_dir = os.path.expanduser(local_dir)
if local_dir != get_software_download_dir():
self.dir_entry.set_editable(True)
self.dir_entry.set_text(local_dir)
self.dir_entry.set_editable(False)
set_software_download_dir(local_dir)
global_event.emit('download-directory-changed')
def download_number_comobox_changed(self, widget, name, value, index):
set_download_number(value)
global_event.emit('max-download-number-changed', value)
def change_auto_update(self, widget, data=None):
self.update_spin.set_sensitive(widget.get_active())
set_auto_update(widget.get_active())
self.update_label.set_sensitive(widget.get_active())
self.hour_lablel.set_sensitive(widget.get_active())
dsc_daemon_path = os.path.join(get_parent_dir(__file__, 2), 'update_data/apt/dsc-daemon.py')
if widget.get_active():
subprocess.Popen(['python', dsc_daemon_path], stderr=subprocess.STDOUT, shell=False)
class MirrorsBox(BaseBox):
def __init__(self):
BaseBox.__init__(self)
self.current_mirror_item = None
self.select_best_mirror_button_texts = {
"normal": _("Select the best mirror"),
"wait": _("Waiting"),
"success": _("Successfully")
}
self.main_box.pack_start(self.create_mirror_select_table(), True, True)
self.main_box.pack_start(self.create_source_update_frequency_table(), False, True)
self.mirror_test_obj = None
global_event.register_event("mirror-test-finished", self.finish_mirror_test)
global_event.register_event("cancel-mirror-test", self.cancel_mirror_test)
global_event.register_event("mirror-backend-changed", self.mirror_changed_handler)
def create_source_update_frequency_table(self):
main_table = gtk.Table(3, 2)
main_table.set_row_spacings(CONTENT_ROW_SPACING)
dir_title_label = Label(_("Refresh package lists"))
# auto update check button
self.is_auto_update_button = CheckButton(label_text=_('Upgrade automatically'))
self.is_auto_update_button.connect('released', self.change_auto_update)
self.is_auto_update_button.set_active(utils.is_auto_update())
self.update_label = Label(_("Time interval: "))
self.update_spin = SpinBox(int(get_update_interval()), 0, 168, 1)
self.update_spin.connect("value-changed", lambda w, v: set_update_interval(v))
self.hour_lablel = Label(_(" hour"))
self.hour_lablel.set_size_request(50, 12)
spin_hbox = gtk.HBox(spacing=3)
spin_hbox.pack_start(self.update_label, False, False)
spin_hbox.pack_start(self.update_spin, False, False)
spin_hbox.pack_start(self.hour_lablel, False, False)
main_table.attach(dir_title_label, 0, 2, 0, 1, yoptions=gtk.FILL)
main_table.attach(create_separator_box(), 0, 2, 1, 2, yoptions=gtk.FILL)
main_table.attach(self.is_auto_update_button, 0, 1, 2, 3, xoptions=gtk.FILL)
main_table.attach(spin_hbox, 1, 2, 2, 3, xpadding=10, xoptions=gtk.FILL)
return main_table
def change_auto_update(self, widget, data=None):
widget_active = widget.get_active()
self.update_spin.set_sensitive(widget_active)
self.update_label.set_sensitive(widget_active)
self.hour_lablel.set_sensitive(widget_active)
utils.set_auto_update(widget_active)
daemon_running = is_dbus_name_exists(DSC_UPDATE_DAEMON_NAME)
if widget_active and not daemon_running:
dsc_daemon_path = os.path.join(get_parent_dir(__file__, 2), 'update_data/apt/dsc-daemon.py')
subprocess.Popen(['python', dsc_daemon_path], stderr=subprocess.STDOUT, shell=False)
elif not widget_active and daemon_running:
session = dbus.SessionBus()
dbus_obj = session.get_object(DSC_UPDATE_DAEMON_NAME, DSC_UPDATE_DAEMON_PATH)
iface = dbus.Interface(dbus_obj, DSC_UPDATE_DAEMON_NAME)
iface.quit()
def select_best_mirror(self, widget):
widget.set_label(self.select_best_mirror_button_texts["wait"])
widget.set_sensitive(False)
global_event.emit("toggle-waiting-dialog", True)
utils.ThreadMethod(self.change_to_nearest_mirror_thread, (widget, )).start()
def cancel_mirror_test(self):
if self.mirror_test_obj:
self.mirror_test_obj.cancel()
self.mirror_test_obj = None
self.finish_mirror_test("")
def change_to_nearest_mirror_thread(self, widget):
best_mirror = get_best_mirror()
global_event.emit("mirror-test-finished", best_mirror)
def finish_mirror_test(self, mirror):
for item in self.mirror_view.visible_items:
if item.mirror == mirror:
self.mirror_view.visible_item(item)
self.select_best_mirror_button.set_sensitive(True)
self.select_best_mirror_button.set_label(self.select_best_mirror_button_texts["normal"])
def create_mirror_select_table(self):
main_table = gtk.Table(3, 2)
main_table.set_row_spacings(CONTENT_ROW_SPACING)
mirror_select_title = Label(_("Select mirror"))
self.select_best_mirror_button = Button(self.select_best_mirror_button_texts["normal"])
self.select_best_mirror_button.connect("clicked", self.select_best_mirror)
self.mirrors_dir = os.path.join(get_parent_dir(__file__, 2), 'mirrors')
self.current_mirror_hostname = utils.get_current_mirror_hostname()
self.mirror_items = self.get_mirror_items()
self.mirror_view = TreeView(self.mirror_items,
enable_drag_drop=False,
enable_multiple_select=False,
mask_bound_height=0,
)
self.mirror_view.set_expand_column(1)
self.mirror_view.set_size_request(-1, 280)
self.mirror_view.draw_mask = self.mirror_treeview_draw_mask
main_table.attach(mirror_select_title, 0, 1, 0, 1, yoptions=gtk.FILL)
main_table.attach(self.select_best_mirror_button, 1, 2, 0, 1, xoptions=gtk.FILL)
main_table.attach(create_separator_box(), 0, 2, 1, 2, xoptions=gtk.FILL)
main_table.attach(self.mirror_view, 0, 2, 2, 3, xoptions=gtk.FILL)
return main_table
def mirror_changed_handler(self, mirror):
item = None
for i in self.mirror_view.visible_items:
if i.mirror == mirror:
item = i
break
if item:
self.current_mirror_item = item
for i in self.mirror_items:
if i != item and i.radio_button.active == True:
i.radio_button.active = False
elif i == item:
i.radio_button.active = True
self.mirror_view.queue_draw()
self.mirror_view.visible_item(item)
def mirror_treeview_draw_mask(self, cr, x, y, w, h):
cr.set_source_rgba(1, 1, 1, 0.5)
cr.rectangle(x, y, w, h)
cr.fill()
def get_mirror_items(self):
items = []
for m in all_mirrors:
item = MirrorItem(m, self.mirror_clicked_callback)
if m.hostname == self.current_mirror_hostname:
item.radio_button.active = True
self.current_mirror_item = item
items.append(item)
return items
def mirror_clicked_callback(self, item):
if item != self.current_mirror_item:
global_event.emit('start-change-mirror', item.mirror)
