def plugin_widget(self):
self.__get_devices()
plugin_box = gtk.VBox()
adapter_box = gtk.HBox(spacing=5)
adapter_image = ImageBox(
app_theme.get_pixbuf("bluetooth/enable_open.png"))
adapter_label = self.__setup_label(_("Adapter"))
adapter_toggle = self.__setup_toggle()
if self.my_bluetooth.adapter:
adapter_toggle.set_active(self.my_bluetooth.adapter.get_powered())
if self.my_bluetooth.adapter.get_powered():
self.tray_icon.set_icon_theme("enable")
else:
self.tray_icon.set_icon_theme("enable_disconnect")
adapter_toggle.connect("toggled", self.__adapter_toggled)
separator_align = self.__setup_align(padding_bottom=0)
separator = self.__setup_separator()
separator_align.add(separator)
'''
devices treeview
'''
device_treeview = TreeView()
device_separator_align = self.__setup_align()
device_separator = self.__setup_separator()
device_separator_align.add(device_separator)
device_count = len(self.device_items)
if device_count:
device_treeview.delete_all_items()
device_treeview.add_items(self.device_items)
device_treeview.set_size_request(
self.width, device_count * DeviceItem.ITEM_HEIGHT)
else:
device_treeview.set_child_visible(False)
device_separator_align.set_size_request(-1, 0)
device_separator_align.set_child_visible(False)
'''
select button
'''
select_button_align = self.__setup_align()
select_button = SelectButton(_("Advanced options..."),
font_size=10,
ali_padding=5)
select_button.set_size_request(self.width, 25)
select_button.connect(
"clicked", self.__bluetooth_selected
) # I don't know why, but replacing "button-press-event" with
select_button_align.add(select_button) # clicked really works...
adapter_box.pack_start(adapter_image, False, False)
adapter_box.pack_start(adapter_label, False, False)
adapter_box.pack_start(adapter_toggle, False, False)
plugin_box.pack_start(adapter_box, False, False)
plugin_box.pack_start(separator_align, False, False)
plugin_box.pack_start(device_treeview, False, False)
plugin_box.pack_start(device_separator_align, False, False)
plugin_box.pack_start(select_button_align, False, False)
return plugin_box
def plugin_widget(self):
self.__get_devices()
plugin_box = gtk.VBox()
adapter_box = gtk.HBox(spacing = 5)
adapter_image = ImageBox(app_theme.get_pixbuf("bluetooth/enable_open.png"))
adapter_label = self.__setup_label(_("Adapter"))
adapter_toggle = self.__setup_toggle()
if self.my_bluetooth.adapter:
adapter_toggle.set_active(self.my_bluetooth.adapter.get_powered())
if self.my_bluetooth.adapter.get_powered():
self.tray_icon.set_icon_theme("enable")
else:
self.tray_icon.set_icon_theme("enable_disconnect")
adapter_toggle.connect("toggled", self.__adapter_toggled)
separator_align = self.__setup_align(padding_bottom = 0)
separator = self.__setup_separator()
separator_align.add(separator)
'''
devices treeview
'''
device_treeview = TreeView()
device_separator_align = self.__setup_align()
device_separator = self.__setup_separator()
device_separator_align.add(device_separator)
device_count = len(self.device_items)
if device_count:
device_treeview.delete_all_items()
device_treeview.add_items(self.device_items)
device_treeview.set_size_request(self.width, device_count * DeviceItem.ITEM_HEIGHT)
else:
device_treeview.set_child_visible(False)
device_separator_align.set_size_request(-1, 0)
device_separator_align.set_child_visible(False)
'''
select button
'''
select_button_align = self.__setup_align()
select_button = SelectButton(_("Advanced options..."),
font_size = 10,
ali_padding = 5)
select_button.set_size_request(self.width, 25)
select_button.connect("clicked", self.__bluetooth_selected) # I don't know why, but replacing "button-press-event" with
select_button_align.add(select_button) # clicked really works...
adapter_box.pack_start(adapter_image, False, False)
adapter_box.pack_start(adapter_label, False, False)
adapter_box.pack_start(adapter_toggle, False, False)
plugin_box.pack_start(adapter_box, False, False)
plugin_box.pack_start(separator_align, False, False)
plugin_box.pack_start(device_treeview, False, False)
plugin_box.pack_start(device_separator_align, False, False)
plugin_box.pack_start(select_button_align, False, False)
return plugin_box
class PluginsManager(gtk.VBox):
def __init__(self):
gtk.VBox.__init__(self)
self.set_spacing(5)
self.plugins = utils.get_main_window().plugins
self.plugins_view = TreeView()
self.plugins_view.set_expand_column(0)
self.plugins_view.draw_mask = self.plugins_view_draw_mask
self.plugins_view.set_size_request(420, 330)
self.plugins_view.connect("single-click-item", self.on_plugins_view_single_click)
self.plugins_view.set_column_titles([_("Add-on"), _("Version"), _("Enable"), ""],
(self.sort_by_title, self.sort_by_title,
self.sort_by_title, self.sort_by_title))
plugins_view_align = set_widget_gravity(self.plugins_view, gravity=(1, 1, 1, 1),
paddings=(10, 0, 0, 0))
self.plugin_infos = PluginInfos()
self.plugin_infos.set_size_request(420, 90)
# plugin info
self.pack_start(plugins_view_align, False, True)
self.pack_start(self.plugin_infos, False, True)
def sort_by_title(self, items, reverse):
return sorted(items, key=lambda item: item.plugin, reverse=reverse)
def plugins_view_draw_mask(self, cr, x, y, width, height):
draw_alpha_mask(cr, x, y, width, height, "layoutLeft")
def flush_plugins(self):
self.__load_plugin_list()
def __load_plugin_list(self):
# clear plugins_view items.
self.plugins_view.clear()
plugins = self.plugins.list_installed_plugins()
plugins_list = []
failed_list = []
for plugin in plugins:
try:
info = self.plugins.get_plugin_info(plugin)
except Exception:
failed_list.append(plugin)
continue
enabled = plugin in self.plugins.enabled_plugins
plugins_list.append((plugin, info, enabled))
plugins_list.sort(key=lambda x: locale.strxfrm(x[1]["Name"]))
plugins_items = [PluginItem(*args) for args in plugins_list]
self.plugins_view.add_items(plugins_items)
def on_plugins_view_single_click(self, widget, item, column, x, y):
if column == 2:
plugin = item.plugin
will_enable = not item.enabled
if will_enable:
try:
self.plugins.enable_plugin(plugin)
except Exception, e:
print e
return
else:
try:
self.plugins.disable_plugin(plugin)
except Exception, e:
print e
return
item.toggle_enabled()
class PlaylistUI(gtk.VBox):
'''Playlist UI.'''
def __init__(self):
'''Init.'''
gtk.VBox.__init__(self)
# Init catagory list.
self.category_list = TreeView()
self.category_list.draw_mask = self.draw_category_list_mask
self.category_list.connect("single-click-item", self.on_category_single_click)
self.category_list.connect("right-press-items", self.on_category_right_press)
self.category_list.set_size_request(CATEGROYLIST_WIDTH, -1)
# Init SearchEntry.
self.entry_box = SearchEntry("")
self.entry_box.entry.connect("changed", self.search_cb)
self.entry_box.set_no_show_all(True)
entry_align = gtk.Alignment()
entry_align.set(0, 0, 1, 1)
entry_align.set_padding(2, 0, 10, 10)
entry_align.add(self.entry_box)
entry_align.connect("expose-event", self.expose_entry_mask)
# Init toolbar.
self.toolbar_box = gtk.HBox(spacing=45)
self.search_button = self.__create_simple_toggle_button("search", self.show_text_entry,
_("Search in Current Playlist"))
self.__create_simple_button("list", self.popup_list_menu, _("Playlist Operations"))
self.__create_simple_button("add", self.popup_add_menu, _("Add"))
self.playmode_button = PlaymodeButton(config.get("setting", "loop_mode", "list_mode").split("_")[0])
Tooltip.text(self.playmode_button, _("Playback Order"))
self.playmode_button.connect("button-press-event", self.popup_sort_menu)
self.toolbar_box.pack_start(self.playmode_button, False, False)
self.__create_simple_button("delete", self.popup_delete_menu, _("Delete"))
toolbar_align = gtk.Alignment()
toolbar_align.set_padding(6, 6, 28, 0)
toolbar_align.add(self.toolbar_box)
toolbar_align.connect("expose-event", self.expose_toolbar_mask)
self.right_box = gtk.VBox()
self.right_box.connect("size-allocate", self.on_right_box_size_allocate)
self.list_paned = HPaned(handle_color=app_theme.get_color("panedHandler"), enable_drag=True)
self.list_paned.pack1(self.category_list, True, True)
self.list_paned.pack2(self.right_box, True, False)
bottom_box = gtk.VBox()
bottom_box.set_size_request(-1, 22)
self.pack_start(self.list_paned, True, True)
self.pack_start(entry_align, False, False)
self.pack_start(toolbar_align, False, True)
# Current
self.current_playlist = None
self.search_time_source = 0
self.current_item = None
self.search_flag = False
self.cache_items = None
self.delete_source_id = None
self.drag_source_id = None
self.menu_source_id = None
self.song_notify_id = None
self.detail_menu = None
if MediaDB.isloaded():
self.__on_db_loaded(MediaDB)
else:
MediaDB.connect("loaded", self.__on_db_loaded)
Player.connect("loaded", self.__on_player_loaded)
Dispatcher.connect("play-song", self.__play_and_add)
Dispatcher.connect("add-songs", self.__add_songs_to_list)
Dispatcher.connect("new-cd-playlist", self.__new_audiocd_playlist)
Dispatcher.connect("del-cd-playlist", self.delete_audiocd_list)
Dispatcher.connect("save-current-list", self.save_current_playlist)
config.connect("config-changed", self.on_config_changed)
def on_config_changed(self, config, section, option, value):
if section == "setting" and option == "loop_mode":
icon_name = value.split("_")[0]
self.playmode_button.update_dpixbufs(icon_name, True)
def on_right_box_size_allocate(self, widget, rect):
if self.current_item:
if rect.width > HIDE_PLAYLIST_WIDTH:
self.current_item.song_view.set_hide_columns(None)
else:
self.current_item.song_view.set_hide_columns([1])
def expose_toolbar_mask(self, widget, event):
cr = widget.window.cairo_create()
rect = widget.allocation
cr.set_source_rgba(1, 1, 1, 0.95)
cr.rectangle(rect.x, rect.y, rect.width, rect.height)
cr.fill()
draw_line(cr, (rect.x, rect.y + 1),
(rect.x + rect.width, rect.y + 1), "#b0b0b0")
return False
def expose_entry_mask(self, widget, event):
cr = widget.window.cairo_create()
rect = widget.allocation
draw_alpha_mask(cr, rect.x , rect.y, rect.width, rect.height, "toolbarEntry")
def draw_category_list_mask(self, cr, x, y, width, height):
draw_alpha_mask(cr, x, y, width, height, "layoutLeft")
def draw_item_mask(self, cr, x, y, width, height):
draw_vlinear(cr, x, y, width, height,
app_theme.get_shadow_color("editlistItemPress").get_color_info())
def __on_db_loaded(self, db):
if not MediaDB.get_playlists():
MediaDB.create_playlist("local", _("Default List"))
# From MediaDB loaded playlists.
init_items = [ListTreeItem(pl) for pl in MediaDB.get_playlists()]
self.category_list.add_items(init_items)
# Init Category_list.
self.category_list.set_highlight_item(self.get_categroy_item_by_index(self.get_save_item_index()))
self.current_item = self.category_list.get_highlight_item()
self.delete_source_id = self.current_item.song_view.connect("delete-select-items", self.parser_delete_items)
self.drag_source_id = self.current_item.song_view.connect("drag-data-received", self.parser_drag_event)
self.menu_source_id = self.current_item.song_view.connect("right-press-items", self.popup_detail_menu)
Player.set_source(self.current_item.song_view)
self.right_box.add(self.current_item.get_list_widget())
self.list_paned.show_all()
def __on_player_loaded(self, player):
if self.current_item:
self.current_item.song_view.reset_error_items()
self.current_item.song_view.set_highlight_song(Player.song)
def __play_and_add(self, widget, song):
self.current_item.song_view.add_songs(song, play=True)
def __add_songs_to_list(self, widget, songs):
if songs and self.current_item.song_view:
self.current_item.song_view.add_songs(songs)
def get_selected_song_view(self):
if self.current_item:
return self.current_item.song_view
def search_cb(self, widget, text):
if not self.search_flag:
self.cache_items = self.current_item.song_view.get_items()
# Clear song_view select status
self.current_item.song_view.clear_highlight()
self.current_item.song_view.select_rows = []
if text != "":
self.search_flag = True
results = filter(lambda item: text.lower().replace(" ", "") in item.get_song().get("search", ""), self.cache_items)
self.current_item.song_view.set_song_items(results)
else:
self.search_flag = False
self.current_item.song_view.set_song_items(self.cache_items)
if Player.song:
self.current_item.song_view.set_highlight_song(Player.song)
def parser_delete_items(self, widget, items):
if self.search_flag:
if self.cache_items != None:
[self.cache_items.remove(item) for item in items if item in self.cache_items]
def parser_drag_event(self, widget, context, x, y, selection, info, timestamp):
if self.search_flag:
self.reset_search_entry()
def reset_search_entry(self):
self.search_button.set_active(False)
def __create_simple_toggle_button(self, name, callback, tip_msg=""):
toggle_button = ToggleButton(
app_theme.get_pixbuf("toolbar/%s_normal.png" % name),
app_theme.get_pixbuf("toolbar/%s_press.png" % name),
)
toggle_button.connect("toggled", callback)
if tip_msg:
Tooltip.text(toggle_button, tip_msg)
self.toolbar_box.pack_start(toggle_button, False, False)
return toggle_button
def __create_simple_button(self, name, callback, tip_msg=""):
button = ImageButton(
app_theme.get_pixbuf("toolbar/%s_normal.png" % name),
app_theme.get_pixbuf("toolbar/%s_hover.png" % name),
app_theme.get_pixbuf("toolbar/%s_press.png" % name),
)
button.connect("button-press-event", callback)
if tip_msg:
Tooltip.text(button, tip_msg)
self.toolbar_box.pack_start(button, False, False)
return button
def popup_add_menu(self, widget, event):
self.current_item.song_view.popup_add_menu(int(event.x_root), int(event.y_root))
def popup_list_menu(self, widget, event):
menu_items = [(None, _("New List"), self.new_list),
(None, _("Import List"), self.leading_in_list),
(None, _("Open List"), self.add_to_list),
(None, _("Export List"), self.leading_out_list),
(None, _("Remove List"), self.delete_item_list),
None,
(None, _("Save all Lists"), self.save_all_list)]
Menu(menu_items, True).show((int(event.x_root), int(event.y_root)))
def new_list(self, items=[], name=None):
index = len(self.category_list.get_items())
if name is None:
name = "%s%d" % (_("New List"), index)
input_dialog = InputDialog(_("New List"), name, 300, 100, lambda name : self.create_new_playlist(name, items))
input_dialog.show_all()
def create_new_playlist(self, name, items):
self.category_list.add_items([ListTreeItem(Playlist("local", name, items))])
def __new_audiocd_playlist(self, obj, name, songs, udi):
self.category_list.add_items([ListTreeItem(CDPlaylist("audiocd", name, songs), udi=udi)])
def get_categroy_other_items(self):
other_items = []
highlight_item = self.category_list.get_highlight_item()
for item in self.category_list.get_items():
if highlight_item == item:
continue
other_items.append(item)
return other_items
def get_categroy_index_by_item(self, item):
index = -1
for each_index, each_item in enumerate(self.category_list.get_items()):
if item == each_item:
index = each_index
break
return index
def get_categroy_item_by_index(self, index):
try:
return self.category_list.get_items()[index]
except:
return None
def get_edit_sub_menu(self, select_items, move=False):
sub_menu_items = []
if len(self.category_list.get_items()) > 1:
other_category_items = self.get_categroy_other_items()
sub_menu_items = [(None, category_item.get_title(),
self.edit_list_item, category_item, select_items ,move) for category_item in other_category_items]
if sub_menu_items:
sub_menu_items.extend([None, ((app_theme.get_pixbuf("toolbar/add_normal.png"), None, None),
_("New List"), self.edit_new_list_item, select_items, move)])
else:
sub_menu_items.extend([((app_theme.get_pixbuf("toolbar/add_normal.png"), None, None),
_("New List"), self.edit_new_list_item, select_items, move)])
return Menu(sub_menu_items)
def edit_list_item(self, category_item, select_items, move):
try:
category_item.song_view.add_items(select_items)
category_item.song_view.update_item_index()
category_item.song_view.update_vadjustment()
if move:
self.current_item.song_view.remove_select_items()
except:
pass
else:
self.current_item.song_view.update_item_index()
self.current_item.song_view.update_vadjustment()
def edit_new_list_item(self, select_items, move):
self.new_list([item.get_song().get("uri") for item in select_items])
if move:
self.current_item.song_view.remove_select_items()
self.current_item.song_view.update_item_index()
self.current_item.song_view.update_vadjustment()
def leading_in_list(self):
uri = WindowLoadPlaylist().run()
try:
p_name = utils.get_filename(uri)
pl = MediaDB.create_playlist("local", p_name, [])
new_item = ListTreeItem(pl)
self.category_list.add_items([new_item])
new_item.song_view.async_add_uris(uri)
except:
pass
def leading_out_list(self, item):
if not item:
item = self.current_item
WindowExportPlaylist(item.get_songs()).run()
def add_to_list(self, item=None):
uri = WindowLoadPlaylist().run()
if uri:
try:
if not item:
item = self.current_item
item.song_view.async_add_uris(uri)
except: pass
def delete_audiocd_list(self, obj, udi):
reset = False
for item in self.category_list.get_items():
if item.udi == udi:
reset = True
self.category_list.delete_items([item])
if reset:
self.reset_highlight_item(self.category_list.get_items()[-1])
def delete_item_list(self, item):
if len(self.category_list.get_items()) == 1:
return
index = self.get_categroy_index_by_item(item)
self.category_list.delete_items([item])
max_index = len(self.category_list.get_items()) - 1
if index <= max_index:
new_index = index
else:
new_index = index- 1
self.reset_highlight_item(self.category_list.get_items()[new_index])
def save_all_list(self):
uri = WinDir().run()
if uri:
try:
save_name_dict = {}
dir_name = utils.get_path_from_uri(uri)
for item in self.category_list.get_items():
item_name = item.get_title()
save_name_dict[item_name] = save_name_dict.get(item_name, -1) + 1
if save_name_dict.get(item_name) > 0:
filename = "%s%d.%s" % (os.path.join(dir_name, item_name), save_name_dict.get(item_name), "m3u")
else:
filename = "%s.%s" % (os.path.join(dir_name, item_name), "m3u")
utils.export_playlist(item.get_songs(), filename, "m3u")
except:
pass
def reset_highlight_item(self, item):
self.category_list.set_highlight_item(item)
self.on_category_single_click(None, item, None, None, None)
def get_current_item_index(self):
item = self.category_list.get_highlight_item()
index = self.get_categroy_index_by_item(item)
if index is None:
return 0
else:
return index
def popup_sort_menu(self, widget, event):
self.current_item.song_view.get_playmode_menu([int(event.x_root), int(event.y_root)])
def popup_delete_menu(self, widget, event):
self.current_item.song_view.popup_delete_menu(int(event.x_root), int(event.y_root))
def get_save_item_index(self):
index = config.getint("playlist", "current_index")
if index <= len(self.category_list.get_items()) - 1:
return index
return 0
def on_category_right_press(self, widget, x, y, item, column):
if not item:
menu_items = [
(None, _("New List"), self.new_list),
(None, _("Import List"), self.leading_in_list),
None,
(None, _("Save all Lists"), self.save_all_list)
]
else:
menu_items = [
(None, _("Rename"), lambda : self.rename_item_list(item)),
(None, _("Remove List"), lambda : self.delete_item_list(item)),
(None, _("Open List"), lambda : self.add_to_list(item)),
None,
(None, _("Save all Lists"), self.save_all_list)
]
Menu(menu_items, True).show((x, y))
def rename_item_list(self, item):
input_dialog = InputDialog(_("Rename"), item.get_title(), 300, 100,
lambda name: item.set_title(name))
input_dialog.show_all()
def on_category_button_press(self, widget, event):
if event.button == 3:
self.popup_list_menu(widget, event)
def on_category_single_click(self, widget, item, column, x, y):
self.reset_search_entry()
if self.drag_source_id != None or self.delete_source_id != None or self.menu_source_id !=None:
gobject.source_remove(self.drag_source_id)
gobject.source_remove(self.delete_source_id)
gobject.source_remove(self.menu_source_id)
self.current_item = item
self.category_list.set_highlight_item(item)
self.delete_source_id = self.current_item.song_view.connect("delete-select-items", self.parser_delete_items)
self.drag_source_id = self.current_item.song_view.connect("drag-data-received", self.parser_drag_event)
self.menu_source_id = self.current_item.song_view.connect("right-press-items", self.popup_detail_menu)
container_remove_all(self.right_box)
self.right_box.add(item.get_list_widget())
self.list_paned.show_all()
def show_text_entry(self, widget):
if widget.get_active():
self.entry_box.set_no_show_all(False)
self.entry_box.show_all()
self.entry_box.focus_input()
else:
self.entry_box.hide_all()
self.entry_box.set_no_show_all(True)
self.entry_box.entry.set_text("")
def popup_detail_menu(self, widget, x, y, item, select_items):
if self.detail_menu != None:
self.detail_menu.destroy()
play_mode_menu = self.current_item.song_view.get_playmode_menu(align=True)
sort_dict = OrderedDict()
sort_dict["file"] = _("By Filename")
sort_dict["title"] = _("By Title")
sort_dict["artist"] = _("By Artist")
sort_dict["album"] = _("By Album")
sort_dict["genre"] = _("By Genre")
sort_dict["#track"] = _("By Track")
sort_dict["#playcount"] = _("By Play Count")
sort_dict["#added"] = _("By Date Added")
sort_items = [(None, value, self.current_item.song_view.set_sort_keyword, key) for key, value in sort_dict.iteritems()]
sort_items.append(None)
sort_items.append((None, _("Randomize"), self.current_item.song_view.random_reorder))
sub_sort_menu = Menu(sort_items)
add_to_list_menu = self.get_edit_sub_menu(select_items)
move_to_list_menu = self.get_edit_sub_menu(select_items, True)
self.detail_menu = Menu([(None, _("Play"), self.current_item.song_view.play_select_item),
(None, _("Add to List"), add_to_list_menu),
(None, _("move to List"), move_to_list_menu),
None,
(None, _("Remove Track"), self.current_item.song_view.remove_select_items),
(None, _("Move to Trash"), self.current_item.song_view.try_move_trash),
(None, _("Clear List"), self.current_item.song_view.erase_items),
None,
(None, _("Playback Order"), play_mode_menu),
(None, _("Sort"), sub_sort_menu),
(None, _("Convert"), self.current_item.song_view.songs_convert),
(None, _("Open directory"), self.current_item.song_view.open_song_dir),
(None, _("Properties"), self.current_item.song_view.open_song_editor),
], True)
if item and item.song.get_type() == "cue":
self.detail_menu.set_menu_item_sensitive_by_index(5, False)
self.detail_menu.set_menu_item_sensitive_by_index(10, False)
self.detail_menu.show((int(x), int(y)))
def save_current_playlist(self, *args):
index = self.get_current_item_index()
config.set("playlist","current_index", str(index))
def save_to_library(self):
if self.search_flag:
self.reset_search_entry()
MediaDB.full_erase_playlists()
for item in self.category_list.get_items():
if item.udi is not None:
continue
songs = item.get_songs()
name = item.get_title()
MediaDB.create_playlist("local", name, songs)
class RadioBrowser(gtk.VBox):
def __init__(self):
gtk.VBox.__init__(self)
# Init radiobar.
self.__init_radiobar()
# is loaded.
self.homepage_load_flag = False
self.home_page = HomePage()
self.hot_page_view, self.hot_page_sw = self.get_radio_icon_view(TAG_HOT, 20)
self.fast_page_view, self.fast_page_sw = self.get_radio_icon_view(TAG_FAST, 20)
# Genres page
self.genre_page = GenrePage()
self.page_box = gtk.VBox()
self.page_box.add(self.home_page)
self.body_paned = HPaned(handle_color=app_theme.get_color("panedHandler"))
self.body_paned.add1(self.radiobar)
self.body_paned.add2(self.page_box)
self.network_failed_box = NetworkConnectFailed(self.check_network_connection)
self.check_network_connection(auto=True)
def check_network_connection(self, auto=False):
if is_network_connected():
switch_tab(self, self.body_paned)
if not auto:
self.start_fetch_channels()
else:
switch_tab(self, self.network_failed_box)
def __init_radiobar(self):
self.radiobar = TreeView(enable_drag_drop=False, enable_multiple_select=False)
items = []
items.append(CategroyTreeItem(_("Home"), "home", lambda : switch_tab(self.page_box, self.home_page)))
items.append(CategroyTreeItem(_("Hot MHz"), "hot", lambda : switch_tab(self.page_box, self.hot_page_sw)))
items.append(CategroyTreeItem(_("Genres MHz"), "genre", lambda : switch_tab(self.page_box, self.genre_page)))
items.append(CategroyTreeItem(_("Pop MHz"), "up", lambda : switch_tab(self.page_box, self.fast_page_sw)))
self.radiobar.add_items(items)
self.radiobar.select_items([self.radiobar.visible_items[0]])
self.radiobar.set_size_request(121, -1)
self.radiobar.draw_mask = self.on_radiobar_draw_mask
def on_radiobar_draw_mask(self, cr, x, y, w, h):
draw_alpha_mask(cr, x, y, w, h ,"layoutRight")
def get_radio_icon_view(self, tag, limit=10, padding_x=0, padding_y=10):
icon_view = RadioIconView(tag=tag, limit=limit, padding_x=padding_x, padding_y=padding_y)
scrolled_window = icon_view.get_scrolled_window()
return icon_view, scrolled_window
def start_fetch_channels(self):
self.fast_page_view.clear_items()
self.hot_page_view.clear_items()
self.home_page.start_fetch_channels()
self.hot_page_view.start_fetch_channels()
self.fast_page_view.start_fetch_channels()
self.genre_page.start_fetch_channels()
class Region(gtk.Alignment):
def __init__(self, connection=None):
gtk.Alignment.__init__(self, 0, 0, 0, 0)
#################
self.provider_select = None
self.connect('expose-event', self.expose_event)
self.prop_dict = {}
main_table = gtk.Table(2, 2, False)
main_table.set_row_spacing(1, 10)
main_table.set_col_spacings(4)
self.add(main_table)
self.country_tree = TreeView(
enable_multiple_select=False,
enable_drag_drop=False,
)
self.country_tree.set_expand_column(1)
self.country_tree.set_size_request(365, 380)
self.country_tree.draw_mask = self.draw_mask
self.country_tree.connect("button-press-item", self.country_selected)
left_box_align = gtk.Alignment(0, 0, 0, 0)
left_box_align.set_padding(1, 1, 1, 1)
left_box_align.add(self.country_tree)
left_box_align.show_all()
left_box = gtk.VBox()
# wrap title
country_title = TitleBar(
app_theme.get_pixbuf("network/globe-green.png"),
_("Country or Region:"),
has_separator=False)
left_box.pack_start(country_title, False, False)
left_box.pack_start(left_box_align, False, False)
self.provider_tree = TreeView(
enable_multiple_select=False,
enable_drag_drop=False,
)
self.provider_tree.set_expand_column(0)
self.provider_tree.set_size_request(365, 380)
self.provider_tree.draw_mask = self.draw_mask
self.provider_tree.connect("button-press-item", self.provider_selected)
right_box_align = gtk.Alignment(0, 0, 0, 0)
right_box_align.set_padding(1, 1, 1, 1)
right_box_align.add(self.provider_tree)
right_box = gtk.VBox()
# wrap title
provider_title = TitleBar(app_theme.get_pixbuf("network/building.png"),
_("Provider:"),
has_separator=False)
right_box.pack_start(provider_title, False, False)
right_box.pack_start(right_box_align, False, False)
main_left_align = gtk.Alignment(0, 0, 0, 0)
main_left_align.set_padding(15, 0, 20, 0)
main_left_align.add(left_box)
main_table.attach(main_left_align, 0, 1, 0, 1)
main_right_align = gtk.Alignment(0, 0, 0, 0)
main_right_align.set_padding(15, 0, 0, 20)
main_right_align.add(right_box)
main_table.attach(main_right_align, 1, 2, 0, 1)
hints = _(
"Tips:This assistant helps you easily set up a mobile broadband connection to a cellular network."
)
left_box_align.connect("expose-event", self.expose_outline)
right_box_align.connect("expose-event", self.expose_outline)
next_button = Button("Next")
next_button.connect("clicked", self.next_button_clicked)
self.foot_box = FootBox()
self.foot_box.set_buttons([next_button])
self.foot_box.set_tip(hints)
main_table.attach(self.foot_box, 0, 2, 1, 2)
self.show_all()
#self.init()
def expose_outline(self, widget, event):
cr = widget.window.cairo_create()
rect = widget.allocation
with cairo_disable_antialias(cr):
cr.set_line_width(1)
cr.set_source_rgb(*BORDER_COLOR)
cr.rectangle(rect.x, rect.y, rect.width, rect.height)
cr.stroke()
def draw_mask(self, cr, x, y, w, h):
cr.set_source_rgb(1, 1, 1)
cr.rectangle(x, y, w, h)
cr.fill()
def expose_event(self, widget, event):
cr = widget.window.cairo_create()
rect = widget.allocation
cr.set_source_rgb(1, 1, 1)
cr.rectangle(rect.x, rect.y, rect.width, rect.height)
cr.fill()
def expose_hint_background(self, widget, event):
bg_color = color_hex_to_cairo(TREEVIEW_BG_COLOR)
cr = widget.window.cairo_create()
rect = widget.allocation
cr.set_source_rgb(*bg_color)
cr.rectangle(rect.x, rect.y, rect.width, rect.height)
cr.fill()
with cairo_disable_antialias(cr):
cr.set_source_rgb(*BORDER_COLOR)
cr.set_line_width(1)
cr.rectangle(rect.x, rect.y, rect.width, rect.height - 1)
cr.stroke()
def next_button_clicked(self, widget):
# 检查是否选择了运营商
if not self.provider_select:
print "provider has not selected"
return
try:
self.plan_select
except:
self.plan_select = None
def add_keys(settings):
self.prop_dict = settings
username = self.__sp.get_provider_username(self.code,
self.provider_select)
password = self.__sp.get_provider_password(self.code,
self.provider_select)
add_keys({
"cdma": {
"number": "#777",
"username": username,
"password": password
}
})
provider_type = "cdma"
if self.plan_select:
self.prop_dict.pop("cdma")
apn = self.plan_select
index = self.__sp.get_provider_apns_name(
self.code, self.provider_select).index(apn)
(network_id, network_type) = self.__sp.get_provider_networks(
self.code, self.provider_select)[index]
add_keys({
"gsm": {
"number": "*99#",
"username": username,
"password": password,
"apn": apn,
#"network_id": network_id,
"network_type": network_type
}
})
provider_type = "gsm"
#setting_page = nm_module.slider.get_page_by_name("setting")
#broadband = setting_page.setting_group.get_broadband()
if self.connection_type == None:
new_connection = getattr(nm_module.nm_remote_settings,
"new_%s_connection" % provider_type)()
Dispatcher.emit("region-back", new_connection, self.prop_dict,
provider_type)
#setting_page.sidebar.new_connection_list[provider_type].append(new_connection)
#setting_page.init(setting_page.sidebar.new_connection_list)
#setting_page.sidebar.set_active(new_connection)
#broadband.set_new_values(self.prop_dict, provider_type)
else:
Dispatcher.emit("region-back", self.connection, self.prop_dict,
provider_type)
#broadband.set_new_values(self.prop_dict, provider_type)
nm_module.slider._slide_to_page("setting", "none")
def init(self, connection):
if connection == None:
self.connection_type = None
else:
self.connection = connection
mobile_type = connection.get_setting("connection").type
self.connection_type = mobile_type
Dispatcher.send_submodule_crumb(_("Region"), 2)
from mm.provider import ServiceProviders
self.__sp = ServiceProviders()
self.country_list = self.__sp.get_country_name_list()
self.country_tree.delete_all_items()
self.country_tree.add_items(
[CountryItem(_(country)) for country in self.country_list])
# add a bottom line for last item
code = self.__sp.get_country_from_timezone()
self.country_codes = self.__sp.get_country_list()
try:
selected_country = self.country_tree.visible_items[
self.country_codes.index(code)]
self.country_tree.select_items([selected_country])
self.auto_scroll_to()
self.country_tree.emit("button-press-item", selected_country, 0, 1,
1)
except:
pass
def country_selected(self, widget, w, a, b, c):
self.provider_tree.delete_all_items()
self.code = self.country_codes[widget.select_rows[0]]
if self.connection_type:
self.provider_names = getattr(
self.__sp, "get_country_%s_providers_name" %
self.connection_type)(self.code)
else:
self.provider_names = self.__sp.get_country_providers_name(
self.code)
self.provider_select = None
self.provider_tree.add_items(
[Item(p, self.__sp, self.code) for p in self.provider_names])
self.provider_tree.show_all()
def provider_selected(self, widget, item, column, offset_x, offset_y):
if type(item) is Item:
self.provider_select = item.content
self.plan_select = None
else:
self.plan_select = item.content
def auto_scroll_to(self):
vadjust = self.country_tree.scrolled_window.get_vadjustment()
upper = vadjust.upper
page_size = vadjust.page_size
vadjust.set_value(
min(upper - page_size,
(self.country_tree.select_rows[0] - 4) * 30))
class WebcastsBrowser(gtk.VBox, SignalContainer):
def __init__(self):
gtk.VBox.__init__(self)
SignalContainer.__init__(self)
# Init categorys.
self.get_categorys()
# load data.
self.__load_webcast_query()
# Init webcastbar.
self.__init_webcastbar()
# Init iconview.
self.metro_view = self.get_icon_view()
self.metro_view_sw = self.metro_view.get_scrolled_window()
self.page_box = gtk.VBox()
self.page_box.add(self.metro_view_sw)
# webcasts view
self.webcast_view = self.get_webcast_view()
self.webcast_view_sw = self.webcast_view.get_scrolled_window()
# collect view
self.collected_db_file = get_config_file("favorite_webcasts.db")
self.collected_view = self.get_webcast_view()
self.collected_view_sw = self.collected_view.get_scrolled_window()
# Init collect view.
# init listview page.
self.init_listview_page()
Dispatcher.connect("change-webcast", self.on_dispatcher_change_webcast)
WebcastDB.connect("changed", self.on_db_update_songs)
body_paned = HPaned(handle_color=app_theme.get_color("panedHandler"), enable_drag=True)
body_paned.add1(self.webcastbar)
body_paned.add2(self.page_box)
self.add(body_paned)
def get_categorys(self):
lang = utils.get_system_lang()
if lang.startswith("zh"):
self.__categorys = ["region", "genre", "composite"]
self.current_category = "region"
else:
self.__categorys = ["region_en", "genre_en"]
self.current_category = "region_en"
self.__category_gettexts = {
"region" : "地域分类",
"genre" : "流派分类",
"region_en" : _("Region"),
"genre_en" : _("Genre"),
"composite" : "综合分类",
"finance" : "财经",
"sports" : "体育",
"music" : "音乐",
"news" : "新闻",
"network" : "网络",
}
def __load_webcast_query(self):
self.__db_query = WebcastQuery()
if WebcastDB.isloaded():
self.__on_db_loaded()
else:
WebcastDB.connect("loaded", lambda obj: self.__on_db_loaded())
def __on_db_loaded(self):
self.autoconnect(self.__db_query, "added", self.__on_added_songs)
self.autoconnect(self.__db_query, "removed", self.__on_removed_songs)
self.autoconnect(self.__db_query, "update-songs", self.__on_update_songs)
self.autoconnect(self.__db_query, "full-update", self.__on_full_update)
self.__db_query.set_query()
def __on_added_songs(self, db_query, songs):
self.reload_flag = True
def __on_removed_songs(self, db_query, songs):
self.reload_flag = True
def __on_update_songs(self, db_query, songs):
self.reload_flag = True
def __on_full_update(self, db_query):
self.load_view_data()
self.load_collect_data()
def __init_webcastbar(self):
self.webcastbar = TreeView(enable_drag_drop=False, enable_multiple_select=False)
self.webcastbar.connect("single-click-item", self.on_webcastbar_single_click_item)
items = []
for category in self.__categorys:
items.append(CategoryTreeItem(self.__category_gettexts[category], category=category))
items.append(CollectTreeItem(_("Favorites")))
self.webcastbar.add_items(items)
self.webcastbar.select_items([self.webcastbar.visible_items[0]])
self.webcastbar.set_size_request(121, -1)
self.webcastbar.draw_mask = self.on_webcastbar_draw_mask
def on_webcastbar_draw_mask(self, cr, x, y, w, h):
draw_alpha_mask(cr, x, y, w, h ,"layoutRight")
def on_webcastbar_single_click_item(self, widget, item, column, x, y):
if hasattr(item, "collect_flag"):
switch_tab(self.page_box, self.collected_view_sw)
else:
widget = self.page_box.get_children()[0]
if widget != self.metro_view_sw:
switch_tab(self.page_box, self.metro_view_sw)
if self.current_category != item.category:
self.current_category = item.category
self.load_view_data()
def init_listview_page(self):
self.listview_page = gtk.VBox()
self.text_prompt = TextPrompt("Default")
prompt_align = set_widget_gravity(self.text_prompt,
paddings=(10, 10, 0, 0))
prompt_box = gtk.HBox()
back_button = BackButton()
back_button.connect("clicked", self.on_backbutton_clicked)
back_button_align = set_widget_gravity(back_button, gravity=(0.5, 0.5, 0, 0),
paddings=(0, 0, 10, 5))
prompt_box.pack_start(back_button_align, False, True)
prompt_box.pack_start(prompt_align, False, False)
self.listview_page.pack_start(prompt_box, False, True)
self.listview_page.pack_start(self.webcast_view_sw, True, True)
def on_backbutton_clicked(self, widget):
switch_tab(self.page_box, self.metro_view_sw)
def switch_to_listview(self, category, title):
self.text_prompt.set_text(title)
self.webcast_view.clear()
songs = self.__db_query.get_songs(category, title)
self.webcast_view.add_webcasts(songs)
switch_tab(self.page_box, self.listview_page)
def load_view_data(self):
self.metro_view.clear()
if self.current_category == "composite":
child_datas = self.__db_query.get_composite_categorys()
gettext_datas = []
for child in child_datas:
gettext_datas.append((self.__category_gettexts[child], child))
self.metro_view.add_composite_items(gettext_datas)
else:
child_datas = self.__db_query.get_info(self.current_category)[0]
child_datas.sort(key=lambda x: locale.strxfrm(x))
self.metro_view.add_webcast_items(child_datas)
def load_collect_data(self):
try:
collected_objs = utils.load_db(self.collected_db_file)
except:
collected_objs = None
if collected_objs:
songs = [ WebcastDB.get_song(uri) for uri in collected_objs]
else:
songs = None
if songs:
songs = [ song for song in songs if song.get("collected", False)]
if songs:
self.collected_view.add_webcasts(songs)
def get_icon_view(self):
icon_view = WebcastIconView()
icon_view.connect("single-click-item", self.on_iconview_single_click_item)
icon_view.connect("double-click-item", self.on_iconview_single_click_item)
return icon_view
def on_iconview_single_click_item(self, widget, item, x, y):
if item.is_composited:
category = item.category
else:
category = self.current_category
title = item.title
if item.is_composited:
self.switch_to_listview(category, title)
else:
self.switch_to_listview(category, title)
def get_webcast_view(self):
webcast_view = MultiDragWebcastView()
webcast_view.keymap.update({"BackSpace" : lambda : self.on_backbutton_clicked(None)})
return webcast_view
def on_dispatcher_change_webcast(self, widget, song):
item = self.collected_view.get_webcast_item(song)
if item and not song.get("collected", False):
self.collected_view.delete_items([item])
elif song.get("collected", False):
self.collected_view.add_webcasts([song])
def on_db_update_songs(self, db, infos):
for song, tags, new_tags in infos:
if new_tags.has_key("collected"):
item = self.collected_view.get_webcast_item(song)
if item:
if not new_tags.get("collected", False):
self.collected_view.delete_items([item])
else:
if new_tags.get("collected", False):
self.collected_view.add_webcasts([song])
def save(self):
songs = self.collected_view.get_webcasts()
uris = [ song.get("uri") for song in songs if song.get("uri")]
utils.save_db(uris, self.collected_db_file)
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 SessionView(gtk.VBox):
def __init__(self):
gtk.VBox.__init__(self)
self.open_dialog = False
self.tmp_editing_session = None
# UI style
style.draw_background_color(self)
self.tree = TreeView(
[],
enable_drag_drop=False,
enable_hover=True,
enable_multiple_select=False,
)
self.tree.set_expand_column(3)
self.tree.set_column_titles(
(_("Active"), _("Application"), _("Description"), _("Exec")), )
self.tree.set_size_request(800, -1)
self.tree.connect("right-press-items", self.right_press_item)
self.tree.draw_mask = self.draw_mask
self.tree.add_items(self.get_list())
align = gtk.Alignment(0, 0, 0, 1)
align.set_padding(15, 0, 20, 20)
align.add(self.tree)
align.connect("expose-event", self.expose_line)
add_button = Button(_("New"))
self.delete_button = Button(_("Delete"))
add_button.connect("clicked", self.add_autostart)
self.delete_button.connect("clicked", self.delete_autostart)
self.delete_button.set_sensitive(False)
foot_box = FootBox(adjustment=15)
foot_box.set_buttons([add_button, self.delete_button])
self.pack_start(align, True, True)
self.pack_end(foot_box, False, False)
#self.pack_end(self.new_box, False, False)
self.show_all()
self._init_monitor()
def disable_delete_button(self, value):
self.delete_button.set_sensitive(not value)
def _init_monitor(self):
self.library_monitor = LibraryMonitor(get_user_config_dir())
self.library_monitor.set_property("monitored", True)
self.library_monitor.connect("file-added", self.refresh_list)
self.library_monitor.connect("location-removed", self.refresh_list)
def right_press_item(self, widget, x_root, y_root, current_item,
select_items):
self.tmp_editing_session = current_item.item
for item in select_items:
item.unselect()
if current_item != None:
current_item.select()
if self.open_dialog == False:
dialog = NewSessionDialog(confirm_callback=self.edit_done,
cancel_callback=self.cancel_callback)
dialog.name_entry.set_text(current_item.item.name)
dialog.exec_entry.set_text(current_item.item.exec_)
dialog.desc_entry.set_text(current_item.item.comment)
dialog.place_center()
dialog.show_all()
self.open_dialog = True
def create_session_item(self, dialog):
name = dialog.name_entry.get_text()
exec_ = dialog.exec_entry.get_text()
comment = dialog.desc_entry.get_text()
session_manager.add(name, exec_, comment)
self.open_dialog = False
def expose_line(self, widget, event):
cr = widget.window.cairo_create()
rect = widget.allocation
style.draw_out_line(cr, rect, exclude=["left", "right", "top"])
def sort_method(self):
pass
def add_autostart(self, widget):
if self.open_dialog == False:
dialog = NewSessionDialog(
confirm_callback=self.create_session_item,
cancel_callback=self.cancel_callback)
dialog.show_all()
self.open_dialog = True
def delete_autostart(self, widget):
items = map(lambda row: self.tree.visible_items[row],
self.tree.select_rows)
item = items[0].item
item.delete()
self.tree.delete_select_items()
if self.tree.visible_items == []:
self.tree.add_items([NothingItem()])
def edit_done(self, dialog):
self.tmp_editing_session.set_name(dialog.name_entry.get_text())
self.tmp_editing_session.set_exec(dialog.exec_entry.get_text())
self.tmp_editing_session.set_comment(dialog.desc_entry.get_text())
self.tmp_editing_session.save()
self.tmp_editing_session = None
items = map(lambda row: self.tree.visible_items[row],
self.tree.select_rows)
self.tree.redraw_request(items, True)
self.open_dialog = False
def cancel_callback(self):
self.tmp_editing_session = None
self.open_dialog = False
def pack(self, parent, widget_list, expand=False, fill=False):
for w in widget_list:
parent.pack_start(w, expand, fill)
def draw_mask(self, cr, x, y, w, h):
cr.set_source_rgb(1, 1, 1)
cr.rectangle(x, y, w, h)
cr.fill()
def get_list(self):
usr_list = session_manager.list_autostart_items()
if usr_list:
return map(lambda w: SessionItem(self, w), usr_list)
else:
return [NothingItem()]
def refresh_list(self, widget, gfile):
self.tree.clear()
self.tree.add_items(self.get_list())
self.tree.show()
class PluginsManager(gtk.VBox):
def __init__(self):
gtk.VBox.__init__(self)
self.set_spacing(5)
self.plugins = utils.get_main_window().plugins
self.plugins_view = TreeView()
self.plugins_view.add_items = self.plugins_view_add_items
self.plugins_view.set_expand_column(0)
self.plugins_view.draw_mask = self.plugins_view_draw_mask
self.plugins_view.set_size_request(420, 330)
self.plugins_view.connect("single-click-item", self.on_plugins_view_single_click)
self.plugins_view.connect("press-return", self.on_plugins_view_press_return)
self.plugins_view.set_column_titles([_("Name"), _("Version"), _("Enable"), ""],
(self.sort_by_title, self.sort_by_title,
self.sort_by_title, self.sort_by_title))
plugins_view_align = set_widget_gravity(self.plugins_view, gravity=(1, 1, 1, 1),
paddings=(10, 0, 0, 0))
self.plugin_infos = PluginInfos()
self.plugin_infos.set_size_request(420, 90)
# plugin info
self.pack_start(plugins_view_align, False, True)
self.pack_start(self.plugin_infos, False, True)
def plugins_view_add_items(self, items, insert_pos=None, clear_first=False):
for item in items:
item.plugins_view = self
TreeView.add_items(self.plugins_view, items, insert_pos, clear_first)
def sort_by_title(self, items, reverse):
return sorted(items, key=lambda item: item.plugin, reverse=reverse)
def plugins_view_draw_mask(self, cr, x, y, width, height):
draw_alpha_mask(cr, x, y, width, height, "layoutLeft")
def flush_plugins(self):
self.__load_plugin_list()
def __load_plugin_list(self):
# clear plugins_view items.
self.plugins_view.clear()
plugins = self.plugins.list_installed_plugins()
plugins_list = []
failed_list = []
for plugin in plugins:
try:
info = self.plugins.get_plugin_info(plugin)
except Exception:
failed_list.append(plugin)
continue
enabled = plugin in self.plugins.enabled_plugins
plugins_list.append((plugin, info, enabled))
plugins_list.sort(key=lambda x: locale.strxfrm(x[1]["Name"]))
plugins_items = [PluginItem(*args) for args in plugins_list]
self.plugins_view.add_items(plugins_items)
def on_plugins_view_press_return(self, widget, items):
if len(items) > 0:
item = items[0]
self.toggle_plugin_status(item)
def on_plugins_view_single_click(self, widget, item, column, x, y):
if column == 2:
self.toggle_plugin_status(item)
def toggle_plugin_status(self, item):
plugin = item.plugin
will_enable = not item.enabled
if will_enable:
try:
self.plugins.enable_plugin(plugin)
except Exception, e:
print e
return
else:
class MainBox(gtk.HBox):
def __init__(self):
gtk.HBox.__init__(self)
self.connect("expose-event", self.on_page_expose_event)
self.aibizhi_cache_page = CachePage(Aibizhi())
self.bizhi360_cache_page = CachePage(Bizhi360())
self.aibizhi_cache_page.cache_view.try_to_fetch()
self.bizhi360_cache_page.cache_view.try_to_fetch()
self.favorites_page = FavoritePage(get_favorite_dir())
self.pictures_page = LocalPicturePage(get_download_wallpaper_dir())
self.add_item = AddItem()
self.pictures_page.select_view.add_items([self.add_item])
self.task_page = TaskPage()
self.switch_page = gtk.VBox()
self.__init_navigatebar()
self.pack_start(self.navigatebar, False, True)
self.pack_start(self.switch_page, True, True)
event_manager.add_callback("switch-to-local-pictures",
self.switch_to_local_pictures)
def switch_to_local_pictures(self, name, obj, data=None):
item = self.navigatebar.get_items()[2]
self.on_navigatebar_single_click(self.navigatebar, item, 0, 0, 0)
def __init_navigatebar(self):
self.navigatebar = TreeView(enable_drag_drop=False,
enable_multiple_select=False)
self.navigatebar.connect("single-click-item",
self.on_navigatebar_single_click)
self.navigatebar.set_size_request(132, -1)
self.navigatebar.draw_mask = self.on_navigatebar_draw_mask
local_expand_item = ExpandItem(_("Library"))
network_expand_item = ExpandItem(_("Internet"))
self.navigatebar.add_items([
local_expand_item,
network_expand_item,
])
local_expand_item.add_childs([
(FavoritesTitle, self.favorites_page),
(LocalWallpapersTitle, self.pictures_page),
],
expand=True)
network_expand_item.add_childs([
(_("360 Wallpaper"), self.bizhi360_cache_page),
(_("LoveWallpaper"), self.aibizhi_cache_page),
],
expand=True)
if get_favorite_number() == 0:
self.navigatebar.set_highlight_item(
self.navigatebar.get_items()[2])
self.switch_page.add(self.pictures_page)
else:
self.navigatebar.set_highlight_item(
self.navigatebar.get_items()[1])
self.switch_page.add(self.favorites_page)
def draw_mask(self, cr, x, y, w, h):
cr.set_source_rgb(1, 1, 1)
cr.rectangle(x, y, w, h)
cr.fill()
def on_page_expose_event(self, widget, event):
cr = widget.window.cairo_create()
width, height = widget.size_request()
self.draw_mask(cr, 0, 0, width, height)
def on_navigatebar_draw_mask(self, cr, x, y, w, h):
self.draw_mask(cr, x, y, w, h)
draw_line(cr, (x + w, y), (0, h), "#d6d6d6")
def on_navigatebar_single_click(self, widget, item, column, x, y):
if item.widget:
widget.set_highlight_item(item)
switch_box(self.switch_page, item.widget)
class TrayUI(gtk.VBox):
def __init__(self):
gtk.VBox.__init__(self, spacing=0)
self.init_ui()
self.active_ap_index = []
self.all_showed = False
def init_ui(self):
self.wire = Section(app_theme.get_pixbuf("network/cable.png"),
_("Wired"))
self.wireless = Section(app_theme.get_pixbuf("network/wifi.png"),
_("Wireless"))
self.mobile = Section(app_theme.get_pixbuf("network/3g.png"),
_("Mobile Network"))
# vpn
self.vpn = Section(app_theme.get_pixbuf("network/vpn.png"),
_("VPN Network"))
self.dsl = Section(app_theme.get_pixbuf("network/dsl.png"), _("DSL"))
self.ssid_list = []
self.tree_box = gtk.VBox(spacing=0)
self.button_more = SelectButton(_("Advanced..."),
font_size=10,
ali_padding=5)
self.button_more.set_size_request(-1, 25)
#self.pack_start(self.button_more, False, False)
self.ap_tree = TreeView(mask_bound_height=0)
self.ap_tree.set_expand_column(0)
self.vpn_list = ConList()
self.dsl_list = DSLConList()
self.wire_box = self.section_box([self.wire])
self.wireless_box = self.section_box([self.wireless, self.tree_box])
self.mobile_box = self.section_box([self.mobile])
self.vpn_box = self.section_box([self.vpn, self.vpn_list])
self.dsl_box = self.section_box([self.dsl, self.dsl_list])
self.wire_state = False
self.wireless_state = False
self.mobile_state = False
self.vpn_state = False
self.dsl_state = False
self.device_tree = None
self.pack_start(self.wire_box, False, False)
self.pack_start(self.wireless_box, False, False)
self.pack_start(self.mobile_box, False, False)
self.pack_start(self.vpn_box, False, False)
self.pack_start(self.dsl_box, False, False)
self.pack_start(self.button_more, False, False)
def get_widget_height(self):
height = 0
if self.wire_state:
height += 35
if self.wireless_state:
height += 35
if self.ap_tree.visible_items and self.wireless.get_active():
height += self.ap_tree.get_size_request()[1]
if self.device_tree:
height += 22
if self.mobile_state:
height += 35
if self.vpn_state:
height += 35 + len(self.vpn_list.get_children()) * 22
if self.dsl_state:
height += 35 + len(self.dsl_list.get_children()) * 22
height += 5
height += 25
return height
def section_box(self, widgets):
box = gtk.VBox(spacing=0)
for w in widgets:
box.pack_start(w, False, False)
style.add_separator(box, 10)
return box
def remove_net(self, net_type):
#print net_type
getattr(self, net_type + "_box").set_no_show_all(True)
#getattr(self, net_type).set_active((True, False))
getattr(self, net_type + "_box").hide()
setattr(self, net_type + "_state", False)
def show_net(self, net_type):
getattr(self, net_type + "_box").set_no_show_all(False)
getattr(self, net_type + "_box").show()
setattr(self, net_type + "_state", True)
def set_wired_state(self, widget, new_state, reason):
if new_state is 20:
self.wire.set_active(0)
else:
tray_log.debug(__name__, new_state, reason)
def set_visible_aps(self, show_all=False):
if not self.__ap_list:
self.visible_aps = []
return
tray_log.debug(len(self.__ap_list))
if show_all:
if len(self.__ap_list) <= 10:
self.visible_aps = self.__ap_list[:]
else:
self.visible_aps = self.__ap_list[:10]
self.more_button.set_ap_list([])
self.show_all = True
else:
if len(self.__ap_list) <= 5:
self.visible_aps = self.__ap_list[:]
self.show_all = True
else:
self.visible_aps = self.__ap_list[:5]
self.more_button.set_ap_list(self.__ap_list[5:])
self.show_all = False
def set_ap(self, ap_list, redraw=True):
if not ap_list:
return
self.__set_ap_list(ap_list)
#print "DEBUG", len(self.visible_aps), self.show_all
self.ap_tree.delete_all_items()
container_remove_all(self.tree_box)
self.ap_tree.add_items(map(lambda ap: SsidItem(ap), self.__ap_list))
length = len(self.ap_tree.visible_items)
if length <= 10:
self.ap_tree.set_size_request(-1, WIDGET_HEIGHT * length)
else:
self.ap_tree.set_size_request(-1, WIDGET_HEIGHT * 10)
for item in self.ap_tree.visible_items:
item.set_padding(10)
self.tree_box.pack_start(self.ap_tree, False, False)
self.show_all()
if redraw:
Dispatcher.request_resize()
def __set_ap_list(self, ap_list):
self.__ap_list = ap_list
def move_active(self, index):
if index != [] and self.__ap_list:
for i in index:
if i < len(self.ap_tree.visible_items):
self.ap_tree.delete_item_by_index(i)
self.ap_tree.add_items([SsidItem(self.__ap_list[i])],
insert_pos=0)
else:
self.ap_tree.delete_item_by_index(-1)
self.ap_tree.add_items([SsidItem(self.__ap_list[i])],
insert_pos=0)
self.ap_tree.visible_items[0].set_active(True)
def set_active_ap(self, index, state):
self.active_ap_index = index
self.set_ap(self.__ap_list, redraw=False)
if index:
self.move_active(index)
def get_active_ap(self):
return self.active_ap_index
def add_switcher(self):
if not hasattr(self, "device_tree") or not self.device_tree:
self.device_tree = TreeView([DeviceItem()], mask_bound_height=0)
self.device_tree.set_expand_column(1)
self.wireless_box.pack_start(self.device_tree, False, False)
self.wireless_box.reorder_child(
self.wireless_box.get_children()[-2],
len(self.wireless_box.get_children()))
tray_log.debug(self.wireless_box.get_children())
net_manager.emit_wifi_switch(0)
def remove_switcher(self):
if self.device_tree:
self.wireless_box.remove(self.device_tree)
self.device_tree = None
def get_active_in_ui(self):
return filter(lambda i: i.get_active() == True,
self.ap_tree.visible_items)
def reset_tree(self):
if len(self.ap_tree.visible_items) >= 5 and self.all_showed:
remove_items = self.ap_tree.visible_items[5:]
self.ap_tree.delete_items(remove_items)
self.ap_tree.set_size_request(-1, WIDGET_HEIGHT * 5)
self.tree_box.pack_start(self.more_button, False, False)
self.all_showed = False
class SessionView(gtk.VBox):
def __init__(self):
gtk.VBox.__init__(self)
self.open_dialog = False
self.tmp_editing_session = None
# UI style
style.draw_background_color(self)
self.tree = TreeView([],enable_drag_drop=False,
enable_hover=True,
enable_multiple_select=False,
)
self.tree.set_expand_column(3)
self.tree.set_column_titles((_("Active"), _("Application"), _("Description"), _("Exec")),)
self.tree.set_size_request(800, -1)
self.tree.connect("right-press-items", self.right_press_item)
self.tree.draw_mask = self.draw_mask
self.tree.add_items(self.get_list())
align = gtk.Alignment(0, 0, 0, 1)
align.set_padding(15, 0, 20, 20)
align.add(self.tree)
align.connect("expose-event", self.expose_line)
add_button = Button(_("New"))
self.delete_button = Button(_("Delete"))
add_button.connect("clicked", self.add_autostart)
self.delete_button.connect("clicked", self.delete_autostart)
self.delete_button.set_sensitive(False)
foot_box = FootBox(adjustment=15)
foot_box.set_buttons([add_button, self.delete_button])
self.pack_start(align, True, True)
self.pack_end(foot_box, False, False)
#self.pack_end(self.new_box, False, False)
self.show_all()
self._init_monitor()
def disable_delete_button(self, value):
self.delete_button.set_sensitive(not value)
def _init_monitor(self):
self.library_monitor = LibraryMonitor(get_user_config_dir())
self.library_monitor.set_property("monitored", True)
self.library_monitor.connect("file-added", self.refresh_list)
self.library_monitor.connect("location-removed", self.refresh_list)
def right_press_item(self, widget, x_root, y_root, current_item, select_items):
self.tmp_editing_session = current_item.item
for item in select_items:
item.unselect()
if current_item != None:
current_item.select()
if self.open_dialog == False:
dialog = NewSessionDialog(confirm_callback = self.edit_done, cancel_callback = self.cancel_callback)
dialog.name_entry.set_text(current_item.item.name)
dialog.exec_entry.set_text(current_item.item.exec_)
dialog.desc_entry.set_text(current_item.item.comment)
dialog.place_center()
dialog.show_all()
self.open_dialog = True
def create_session_item(self, dialog):
name = dialog.name_entry.get_text()
exec_ = dialog.exec_entry.get_text()
comment = dialog.desc_entry.get_text()
session_manager.add(name, exec_, comment)
self.open_dialog = False
def expose_line(self, widget, event):
cr = widget.window.cairo_create()
rect = widget.allocation
style.draw_out_line(cr, rect, exclude=["left", "right", "top"])
def sort_method(self):
pass
def add_autostart(self, widget):
if self.open_dialog == False:
dialog = NewSessionDialog(confirm_callback= self.create_session_item, cancel_callback = self.cancel_callback)
dialog.show_all()
self.open_dialog = True
def delete_autostart(self, widget):
items = map(lambda row: self.tree.visible_items[row], self.tree.select_rows)
item = items[0].item
item.delete()
self.tree.delete_select_items()
if self.tree.visible_items == []:
self.tree.add_items([NothingItem()])
def edit_done(self, dialog):
self.tmp_editing_session.set_name(dialog.name_entry.get_text())
self.tmp_editing_session.set_exec(dialog.exec_entry.get_text())
self.tmp_editing_session.set_comment(dialog.desc_entry.get_text())
self.tmp_editing_session.save()
self.tmp_editing_session = None
items = map(lambda row: self.tree.visible_items[row], self.tree.select_rows)
self.tree.redraw_request(items, True)
self.open_dialog = False
def cancel_callback(self):
self.tmp_editing_session = None
self.open_dialog = False
def pack(self, parent, widget_list, expand=False, fill=False):
for w in widget_list:
parent.pack_start(w, expand, fill)
def draw_mask(self, cr, x, y, w, h):
cr.set_source_rgb(1, 1, 1)
cr.rectangle(x, y, w, h)
cr.fill()
def get_list(self):
usr_list = session_manager.list_autostart_items()
if usr_list:
return map(lambda w: SessionItem(self, w), usr_list)
else:
return [NothingItem()]
def refresh_list(self, widget, gfile):
self.tree.clear()
self.tree.add_items(self.get_list())
self.tree.show()
class AddPage(gtk.HBox):
def __init__(self):
gtk.HBox.__init__(self)
self.aibizhi_cache_page = CachePage(Aibizhi())
self.bizhi360_cache_page = CachePage(Bizhi360())
self.aibizhi_cache_page.cache_view.try_to_fetch()
self.bizhi360_cache_page.cache_view.try_to_fetch()
self.system_wallpapers_page = SystemPage(get_system_wallpaper_dirs()[0])
self.picture_wallpapers_page = PicturePage(get_images_dir())
self.download_wallpapaers_page = UserPage(get_download_wallpaper_dir())
self.task_page = TaskPage()
self.__init_navigatebar()
self.switch_page = gtk.VBox()
self.pack_start(self.navigatebar, False, True)
self.pack_start(self.switch_page, True, True)
self.switch_page.add(self.system_wallpapers_page)
event_manager.add_callback("downloading-tasks-number", self.on_download_item_changed)
self.connect("expose-event", self.on_addpage_expose_event)
def set_theme(self, theme):
self.system_wallpapers_page.set_theme(theme)
self.picture_wallpapers_page.set_theme(theme)
self.download_wallpapaers_page.set_theme(theme)
self.aibizhi_cache_page.set_theme(theme)
self.bizhi360_cache_page.set_theme(theme)
def on_download_item_changed(self, name, obj, data):
pass
def __init_navigatebar(self):
self.navigatebar = TreeView(enable_drag_drop=False, enable_multiple_select=False)
self.navigatebar.connect("single-click-item", self.on_navigatebar_single_click)
self.navigatebar.set_size_request(132, -1)
self.navigatebar.draw_mask = self.on_navigatebar_draw_mask
local_expand_item = ExpandItem(_("Library"))
network_expand_item = ExpandItem(_("Internet"))
self.navigatebar.add_items([local_expand_item,
network_expand_item,
])
local_expand_item.add_childs([(_("System"), self.system_wallpapers_page),
(_("Pictures"), self.picture_wallpapers_page),
(_("Favorites"), self.download_wallpapaers_page)], expand=True)
network_expand_item.add_childs([(_("360 Wallpaper"), self.bizhi360_cache_page),
(_("LoveWallpaper"), self.aibizhi_cache_page),
], expand=True)
self.navigatebar.set_highlight_item(self.navigatebar.get_items()[1])
def on_addpage_expose_event(self, widget, event):
cr = widget.window.cairo_create()
rect = widget.allocation
self.draw_mask(cr, *rect)
def on_navigatebar_draw_mask(self, cr, x, y, w, h):
self.draw_mask(cr, x, y, w, h)
draw_line(cr, (x + w, y), (0, h), "#d6d6d6")
def draw_mask(self, cr, x, y, w, h):
'''
Draw mask interface.
@param cr: Cairo context.
@param x: X coordiante of draw area.
@param y: Y coordiante of draw area.
@param w: Width of draw area.
@param h: Height of draw area.
'''
cr.set_source_rgb(1, 1, 1)
cr.rectangle(x, y, w, h)
cr.fill()
def on_navigatebar_single_click(self, widget, item, column, x, y):
if item.widget:
widget.set_highlight_item(item)
switch_box(self.switch_page, item.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 DetailWindow(Window):
'''
class docs
'''
def __init__(self):
'''
init docs
'''
Window.__init__(self, enable_resize=True)
self.set_size_request(WINDOW_WIDTH, WINDOW_HEIGHT)
self.set_position(gtk.WIN_POS_CENTER)
self.set_skip_taskbar_hint(True)
self.set_skip_pager_hint(True)
self.resizable = True
self.classified_items = None
self.__init_pixbuf()
self.main_box = gtk.VBox()
self.titlebar_box = gtk.HBox()
self.toolbar_box = gtk.HBox()
self.toolbar_box.set_size_request(-1, TOOLBAR_HEIGHT)
self.main_view_box = gtk.HBox()
self.main_view_box.set_size_request(WINDOW_WIDTH,
WINDOW_HEIGHT - TITLEBAR_HEIGHT - TOOLBAR_HEIGHT - 23)
self.add_titlebar()
self.treeview_box = gtk.VBox()
self.main_view_box.pack_start(self.treeview_box, False, False)
self.listview_box = gtk.VBox()
self.main_view_box.pack_start(self.listview_box, True, True)
self.refresh_view() #add treeview and listview
self.main_box.pack_start(self.toolbar_box, False, False)
# self.main_box.pack_start(self.main_view_box, False, False)
self.main_box.pack_start(self.main_view_box, True, True)
# self.main_box.connect("expose-event", self.on_main_box_expose_event)
main_box_align = gtk.Alignment(0.5, 0.5, 1, 1)
main_box_align.set_padding(2, 2, 2, 2)
main_box_align.add(self.main_box)
self.window_frame.pack_start(self.titlebar_box, False, False)
self.window_frame.pack_start(main_box_align)
@property
def is_empty(self):
return not bool(len(self.classified_items))
def __init_pixbuf(self):
self.import_btn_pixbuf = gtk.gdk.pixbuf_new_from_file(app_theme.get_theme_file_path("image/toolbar_import.png"))
self.export_btn_pixbuf = gtk.gdk.pixbuf_new_from_file(app_theme.get_theme_file_path("image/toolbar_export.png"))
self.delete_btn_pixbuf = gtk.gdk.pixbuf_new_from_file(app_theme.get_theme_file_path("image/toolbar_delete.png"))
self.refresh_btn_pixbuf = gtk.gdk.pixbuf_new_from_file(app_theme.get_theme_file_path("image/toolbar_refresh.png"))
self.skin_preview_pixbuf = app_theme.get_pixbuf("frame.png")
def _init_data(self):
self.__init_data()
def __init_data(self):
self.classified_items = {}
rows = db.get_all()
for row in rows:
app_name = row[MESSAGE].app_name
self.classified_items.setdefault(app_name, []).append(row)
def add_to_view(self):
row = db.get_last()
# add to data
app_name = row[MESSAGE].app_name
if app_name in self.classified_items.keys():
self.classified_items[app_name].insert(0, row)
else:
self.classified_items.setdefault(app_name, []).insert(0, row)
self.treeview_add_item(app_name)
# add to view
if app_name == self.treeview.get_highlight_item().get_title():
self.factory.prepend_item(row)
def refresh_view(self):
self.__init_data()
if len(self.classified_items):
self.add_treeview()
self.current_showed_items = self.get_items_from_treeview_highlight()
self.add_listview(self.current_showed_items)
else:
align = gtk.Alignment(0.5, 0.5, 0, 0)
align.add(Label(_("(Empty)")))
container_remove_all(self.treeview_box)
container_remove_all(self.listview_box)
self.listview_box.pack_start(align, True, True)
self.main_view_box.show_all()
container_remove_all(self.toolbar_box)
self.add_toolbar()
self.toolbar_box.show_all()
def on_main_box_expose_event(self, widget, event):
cr = widget.window.cairo_create()
rect = widget.allocation
cr.rectangle(*rect)
cr.set_source_rgb(*STROKE_LINE_COLOR)
cr.stroke_preserve()
cr.set_source_rgb(1, 1, 1)
cr.fill()
def on_treeview_draw_mask(self, cr, x, y, w, h):
cr.set_source_rgb(1, 1, 1)
cr.rectangle(x, y, w, h)
cr.fill()
cr.move_to(x, y)
cr.line_to(x + w, y)
cr.set_source_rgb(*STROKE_LINE_COLOR)
cr.stroke()
draw_line(cr, (x+w-1, y), (x+w-1, y+h), "#b2b2b2")
def on_treeview_click_item(self, widget, item, column, x, y):
if not item.is_parent:
widget.set_highlight_item(item)
self.current_showed_items = self.get_items_from_treeview_highlight()
self.add_listview(self.current_showed_items)
for comb_item in self.category_comb.items:
if comb_item.title == item.title:
self.category_comb.set_select_index(comb_item_value_to_index(comb_item.item_value))
def on_treeview_double_click_item(self, widget, item, column, x, y):
if item.is_parent:
if item.is_expand:
item.unexpand()
else:
item.expand()
def on_treeview_right_press_items(self, widget, root_x, root_y, current_item, select_items):
'''
docs
'''
self.treeview.set_highlight_item(current_item)
if not current_item.is_parent:
def on_add_to_bl():
blacklist.add(current_item.title)
current_item.is_in_blacklist = True
current_item.emit_redraw_request()
def on_remove_from_bl():
blacklist.remove(current_item.title)
current_item.is_in_blacklist = False
current_item.emit_redraw_request()
menu_items = []
if current_item.title in blacklist.bl:
menu_items.append((None, _("Remove from Blacklist"), on_remove_from_bl))
else:
menu_items.append((None, _("Add to Blacklist"), on_add_to_bl))
Menu(menu_items, True).show((int(root_x), int(root_y)))
def add_treeview(self):
categories = self.classified_items.keys()
# root eles
self.root_ele_software = TreeViewItem(_("Software Messages"), True)
self.root_ele_system = TreeViewItem(_("System Messages"), True)
self.treeview = TreeView([self.root_ele_software, self.root_ele_system], expand_column=0)
# add child items , CAN'T add_child_items before treeview constructed
software_children = []
system_children = []
for category in categories:
treeview_item = TreeViewItem(category)
if category in blacklist.bl:
treeview_item.is_in_blacklist = True
if category in SYSTEM_SOFTWARE_LIST:
system_children.append(treeview_item)
else:
software_children.append(treeview_item)
self.root_ele_software.add_child_items(software_children)
self.root_ele_system.add_child_items(system_children)
self.treeview.draw_mask = self.on_treeview_draw_mask
if len(software_children):
self.treeview.set_highlight_item(software_children[0])
elif len(system_children):
self.treeview.set_highlight_item(system_children[0])
self.treeview.set_size_request(220, -1)
self.treeview.connect("single-click-item", self.on_treeview_click_item)
self.treeview.connect("right-press-items", self.on_treeview_right_press_items)
self.treeview.connect("double-click-item", self.on_treeview_double_click_item)
container_remove_all(self.treeview_box)
self.treeview_box.pack_start(self.treeview, True, True)
self.treeview_box.show_all()
def treeview_add_item(self, item):
if item in SYSTEM_SOFTWARE_LIST:
self.root_ele_system.add_child_items([TreeViewItem(item)])
else:
self.root_ele_software.add_child_items([TreeViewItem(item)])
self.treeview_box.show_all()
def add_listview(self, items):
container_remove_all(self.listview_box)
if len(items) != 0:
self.factory = ListviewFactory(items, "detail")
self.listview = self.factory.listview
self.listview_box.pack_start(self.listview)
else:
empty_box_align = gtk.Alignment(0.5, 0.5, 0, 0)
empty_box_align.add(Label("(Empty)"))
self.listview_box.pack_start(empty_box_align)
self.listview_box.show_all()
def get_items_from_treeview_highlight(self):
'''
docs
'''
app_name = self.treeview.get_highlight_item().get_title()
return self.classified_items[app_name]
def add_titlebar(self,
button_mask=["min", "max", "close"],
icon_path=app_theme.get_theme_file_path("image/icon_little.png"),
app_name=_("Message Manager"),
title=None,
add_separator=False,
show_title=True,
enable_gaussian=True,
):
# Init titlebar.
self.titlebar = Titlebar(button_mask,
icon_path,
app_name,
title,
add_separator,
show_title=show_title,
enable_gaussian=enable_gaussian,
)
self.titlebar.max_button.connect("clicked", lambda w: self.toggle_max_window())
self.titlebar.min_button.connect("clicked", self.close_callback)
self.titlebar.close_button.connect("clicked", self.close_callback)
if self.resizable:
self.add_toggle_event(self.titlebar)
self.add_move_event(self.titlebar)
self.titlebar_box.add(self.titlebar)
def add_toolbar(self):
toolbar_btn_box = gtk.HBox()
toolbar_btn_box_align = gtk.Alignment(0.5, 0.5, 0, 0)
import_btn = ToolbarItem(self.import_btn_pixbuf, _("Import"))
import_btn.connect("clicked", self.on_toolbar_import_clicked)
export_btn = ToolbarItem(self.export_btn_pixbuf, _("Export"))
export_btn.connect("clicked", self.on_toolbar_export_clicked)
delete_btn = ToolbarItem(self.delete_btn_pixbuf, _("Delete"))
delete_btn.connect("clicked", self.on_toolbar_delete_clicked)
refresh_btn = ToolbarItem(self.refresh_btn_pixbuf, _("Refresh"))
refresh_btn.connect("clicked", self.on_toolbar_refresh_clicked)
toolbar_btn_box.pack_start(import_btn, False, False, 2)
toolbar_btn_box.pack_start(export_btn, False, False, 2)
toolbar_btn_box.pack_start(delete_btn, False, False, 2)
toolbar_btn_box.pack_start(refresh_btn, False, False, 2)
toolbar_btn_box_align.add(toolbar_btn_box)
look_in_Label = Label(
_("Look up in"),
text_color=ui_theme.get_color("title_text"),
)
self.category_comb = ComboBox([(_("All"), 0)])
self.category_comb.add_items([(item, index) for index, item in enumerate(self.classified_items)], clear_first=False)
self.time_comb = ComboBox([(_("Today"), 0),
(_("Last week"), 1),
(_("Last month"), 2),
(_("Last three months"), 3),
(_("Last year"), 4),
(_("All"), 5)
])
self.category_comb.set_size_request(-1, TOOLBAR_ENTRY_HEIGHT)
self.category_comb.connect("item-selected", self.on_category_comb_item_selected)
self.time_comb.set_size_request(-1, TOOLBAR_ENTRY_HEIGHT)
self.time_comb.connect("item-selected", self.on_time_comb_item_selected)
combos_box = gtk.HBox()
combos_box.pack_start(self.category_comb, False, False, 5)
combos_box.pack_start(self.time_comb, False, False)
combos_box_align = gtk.Alignment(0.5, 0.5, 1, 1)
padding_height = (TOOLBAR_HEIGHT - TOOLBAR_ENTRY_HEIGHT) / 2
combos_box_align.set_padding(padding_height, padding_height, 5, 5)
combos_box_align.add(combos_box)
find_content_Label = Label(
_("Find in content"),
text_color=ui_theme.get_color("title_text"),
)
search_entry = SearchEntry()
search_entry.connect("action-active", self.on_search_entry_action_active)
search_entry_align = gtk.Alignment(0.5, 0.5, 1, 1)
search_entry_align.set_padding(padding_height, padding_height, 5, 5)
search_entry_align.add(search_entry)
#Align left
self.toolbar_box.pack_start(toolbar_btn_box_align, False, False, 5)
#Align right
self.toolbar_box.pack_end(search_entry_align, False, True, 5)
self.toolbar_box.pack_end(find_content_Label, False, False, 5)
self.toolbar_box.pack_end(combos_box_align, False, False, 0)
self.toolbar_box.pack_end(look_in_Label, False, False, 5)
self.toolbar_box.pack_end(ToolbarSep(), False, False, 5)
def on_category_comb_item_selected(self, widget, item_title, item_value, item_index):
if item_title != "All":
for item in self.treeview.get_items():
if item.title == item_title:
self.treeview.set_highlight_item(item)
self.current_showed_items = self.get_items_from_treeview_highlight()
self.add_listview(self.current_showed_items)
break
def on_time_comb_item_selected(self, widget, item_title, item_value, item_index):
if item_value != 5:
filtrated_result = []
for item in self.current_showed_items:
item_datetime = datetime.strptime(item[TIME], "%Y/%m/%d-%H:%M:%S")
if datetime.today() - item_datetime < timedelta_dict[item_value]:
filtrated_result.append(item)
self.current_showed_items = filtrated_result
self.add_listview(filtrated_result)
def get_search_result_iter(self, search_str):
filter_keywords = search_str.split()
for item in self.current_showed_items:
item_message = item[MESSAGE]
for keyword in filter_keywords:
# print "from %s search %s result %s:" % (item_message.body, keyword, item_message.body.find(keyword) != -1)
if item_message.body.find(keyword) != -1:
yield item
continue
def on_search_entry_action_active(self, widget, text):
search_result_iter = self.get_search_result_iter(text)
self.add_listview(list(search_result_iter))
def on_toolbar_import_clicked(self, widget):
self.filename_to_import = ""
def ok_clicked(filename):
self.filename_to_import = filename
OpenFileDialog(_("Select File to Import"), self, ok_clicked, None)
if len(self.filename_to_import) != 0:
try:
def import_db_func():
db.import_db(self.filename_to_import)
self.refresh_view()
threading.Thread(target=import_db_func).start()
except Exception, e:
pass
class Region(gtk.Alignment):
def __init__(self, connection=None):
gtk.Alignment.__init__(self, 0, 0, 0, 0)
#################
self.provider_select = None
self.connect('expose-event', self.expose_event)
self.prop_dict = {}
main_table = gtk.Table(2, 2, False)
main_table.set_row_spacing(1, 10)
main_table.set_col_spacings(4)
self.add(main_table)
self.country_tree = TreeView(enable_multiple_select=False,
enable_drag_drop=False,
)
self.country_tree.set_expand_column(1)
self.country_tree.set_size_request(365, 380)
self.country_tree.draw_mask = self.draw_mask
self.country_tree.connect("button-press-item", self.country_selected)
left_box_align = gtk.Alignment(0, 0, 0, 0)
left_box_align.set_padding(1,1,1,1)
left_box_align.add(self.country_tree)
left_box_align.show_all()
left_box = gtk.VBox()
# wrap title
country_title = TitleBar(app_theme.get_pixbuf("network/globe-green.png"),
_("Country or Region:"),
has_separator=False)
left_box.pack_start(country_title, False, False)
left_box.pack_start(left_box_align, False, False)
self.provider_tree = TreeView(enable_multiple_select=False,
enable_drag_drop=False,
)
self.provider_tree.set_expand_column(0)
self.provider_tree.set_size_request(365, 380)
self.provider_tree.draw_mask = self.draw_mask
self.provider_tree.connect("button-press-item", self.provider_selected)
right_box_align = gtk.Alignment(0, 0, 0, 0)
right_box_align.set_padding(1,1,1,1)
right_box_align.add(self.provider_tree)
right_box = gtk.VBox()
# wrap title
provider_title = TitleBar(app_theme.get_pixbuf("network/building.png"),
_("Provider:"),
has_separator=False)
right_box.pack_start(provider_title, False, False)
right_box.pack_start(right_box_align, False, False)
main_left_align = gtk.Alignment(0, 0, 0, 0)
main_left_align.set_padding(15, 0, 20, 0)
main_left_align.add(left_box)
main_table.attach(main_left_align, 0, 1, 0, 1)
main_right_align = gtk.Alignment(0, 0, 0, 0)
main_right_align.set_padding(15, 0, 0, 20)
main_right_align.add(right_box)
main_table.attach(main_right_align, 1, 2, 0, 1)
hints = _("Tips:This assistant helps you easily set up a mobile broadband connection to a cellular network.")
left_box_align.connect("expose-event", self.expose_outline)
right_box_align.connect("expose-event", self.expose_outline)
next_button = Button("Next")
next_button.connect("clicked", self.next_button_clicked)
self.foot_box = FootBox()
self.foot_box.set_buttons([next_button])
self.foot_box.set_tip(hints)
main_table.attach(self.foot_box, 0, 2, 1, 2)
self.show_all()
#self.init()
def expose_outline(self, widget, event):
cr = widget.window.cairo_create()
rect = widget.allocation
with cairo_disable_antialias(cr):
cr.set_line_width(1)
cr.set_source_rgb(*BORDER_COLOR)
cr.rectangle(rect.x, rect.y, rect.width , rect.height )
cr.stroke()
def draw_mask(self, cr, x, y, w, h):
cr.set_source_rgb(1, 1, 1)
cr.rectangle(x, y, w, h)
cr.fill()
def expose_event(self, widget, event):
cr = widget.window.cairo_create()
rect = widget.allocation
cr.set_source_rgb( 1, 1, 1)
cr.rectangle(rect.x, rect.y, rect.width, rect.height)
cr.fill()
def expose_hint_background(self, widget, event):
bg_color = color_hex_to_cairo(TREEVIEW_BG_COLOR)
cr = widget.window.cairo_create()
rect = widget.allocation
cr.set_source_rgb(*bg_color)
cr.rectangle(rect.x, rect.y, rect.width, rect.height)
cr.fill()
with cairo_disable_antialias(cr):
cr.set_source_rgb(*BORDER_COLOR)
cr.set_line_width(1)
cr.rectangle(rect.x , rect.y, rect.width , rect.height -1)
cr.stroke()
def next_button_clicked(self, widget):
# 检查是否选择了运营商
if not self.provider_select:
print "provider has not selected"
return
try:
self.plan_select
except:
self.plan_select = None
def add_keys(settings):
self.prop_dict = settings
username = self.__sp.get_provider_username(self.code, self.provider_select)
password = self.__sp.get_provider_password(self.code, self.provider_select)
add_keys({"cdma": {
"number": "#777",
"username": username,
"password": password}})
provider_type = "cdma"
if self.plan_select:
self.prop_dict.pop("cdma")
apn = self.plan_select
index = self.__sp.get_provider_apns_name(self.code, self.provider_select).index(apn)
(network_id, network_type) = self.__sp.get_provider_networks(self.code, self.provider_select)[index]
add_keys({"gsm":{
"number": "*99#",
"username": username,
"password": password,
"apn": apn,
#"network_id": network_id,
"network_type": network_type}})
provider_type = "gsm"
#setting_page = nm_module.slider.get_page_by_name("setting")
#broadband = setting_page.setting_group.get_broadband()
if self.connection_type == None:
new_connection = getattr(nm_module.nm_remote_settings, "new_%s_connection"%provider_type)()
Dispatcher.emit("region-back", new_connection, self.prop_dict, provider_type)
#setting_page.sidebar.new_connection_list[provider_type].append(new_connection)
#setting_page.init(setting_page.sidebar.new_connection_list)
#setting_page.sidebar.set_active(new_connection)
#broadband.set_new_values(self.prop_dict, provider_type)
else:
Dispatcher.emit("region-back", self.connection, self.prop_dict, provider_type)
#broadband.set_new_values(self.prop_dict, provider_type)
nm_module.slider._slide_to_page("setting", "none")
def init(self, connection):
if connection == None:
self.connection_type = None
else:
self.connection = connection
mobile_type = connection.get_setting("connection").type
self.connection_type = mobile_type
Dispatcher.send_submodule_crumb(_("Region"), 2)
from mm.provider import ServiceProviders
self.__sp = ServiceProviders()
self.country_list = self.__sp.get_country_name_list()
self.country_tree.delete_all_items()
self.country_tree.add_items([CountryItem(_(country)) for country in self.country_list])
# add a bottom line for last item
code = self.__sp.get_country_from_timezone()
self.country_codes = self.__sp.get_country_list()
try:
selected_country = self.country_tree.visible_items[self.country_codes.index(code)]
self.country_tree.select_items([selected_country])
self.auto_scroll_to()
self.country_tree.emit("button-press-item", selected_country, 0, 1, 1)
except:
pass
def country_selected(self, widget, w, a, b, c):
self.provider_tree.delete_all_items()
self.code = self.country_codes[widget.select_rows[0]]
if self.connection_type:
self.provider_names = getattr(self.__sp, "get_country_%s_providers_name"%self.connection_type)(self.code)
else:
self.provider_names = self.__sp.get_country_providers_name(self.code)
self.provider_select = None
self.provider_tree.add_items([Item(p, self.__sp, self.code) for p in self.provider_names])
self.provider_tree.show_all()
def provider_selected(self, widget, item, column, offset_x, offset_y):
if type(item) is Item:
self.provider_select = item.content
self.plan_select = None
else:
self.plan_select = item.content
def auto_scroll_to(self):
vadjust = self.country_tree.scrolled_window.get_vadjustment()
upper = vadjust.upper
page_size = vadjust.page_size
vadjust.set_value(min(upper - page_size, (self.country_tree.select_rows[0]- 4)*30))
class HomePage(gtk.HBox):
'''
class docs
'''
def __init__(self, data_manager, recommend_status):
'''
init docs
'''
# Init.
gtk.HBox.__init__(self)
self.data_manager = data_manager
self.recommend_status = recommend_status
self.background_box = BackgroundBox()
self.background_box.draw_mask = self.draw_mask
self.sidebar_box = gtk.VBox()
self.page_box = gtk.VBox()
self.sidebar_box.set_size_request(CATEGORY_VIEW_WIDTH, -1)
self.canopy = gtk.VBox()
self.canopy.set_size_request(-1, 19)
self.search_align = gtk.Alignment()
self.search_align.set(0.5, 0.5, 0, 0)
self.search_align.set_padding(15, 5, 13, 13)
self.search_align.add(search_entry)
self.in_press = False
self.press_return = False
self.press_id = 0
self.show_timeout_id = None
self.entry_changed = False
search_entry.entry.connect("changed", self.search_entry_changed)
search_entry.entry.connect("key-press-event", self.search_entry_key_press)
search_entry.entry.connect("key-release-event", self.search_entry_key_release)
search_entry.connect("action-active", lambda entry, search_string: self.show_search_page(search_string))
search_entry.entry.connect("press-return", lambda entry: self.show_search_page(entry.get_text(), True))
self.recommend_item = RecommendItem(data_manager, self.recommend_status)
category_items = []
for (index, first_category_name) in enumerate(data_manager.get_first_category()):
category_items.append(CategoryItem(index+1, first_category_name, data_manager))
self.category_view = TreeView(
[self.recommend_item] + category_items,
enable_drag_drop=False,
enable_multiple_select=False,
expand_column=0,
)
self.category_view.draw_mask = self.draw_mask
self.category_view.set_size_request(-1, 470)
self.category_view_align = gtk.Alignment()
self.category_view_align.set(0.5, 0.5, 1, 1)
self.category_view_align.set_padding(10, 10, 0, 0)
self.category_view_align.add(self.category_view)
self.background_box.pack_start(self.canopy, False, False)
self.background_box.pack_start(self.search_align, True, True)
self.background_box.pack_end(self.category_view_align, False, False)
self.sidebar_box.pack_start(self.background_box, False, False)
self.split_line = gtk.VBox()
self.split_line.set_size_request(1, -1)
self.pack_start(self.sidebar_box, False, False)
self.pack_start(self.split_line, False, False)
self.pack_start(self.page_box, True, True)
self.canopy.connect("expose-event", self.expose_canopy)
self.split_line.connect("expose-event", self.expose_split_line)
global_event.register_event("show-pkg-view", self.show_pkg_view)
global_event.register_event("category-expand", self.category_expand_handler)
def category_expand_handler(self, item):
self.category_view.visible_item(item.child_items[-1])
def jump_to_category(self, first_category_name, second_category_name):
for item in self.category_view.visible_items:
if isinstance(item, CategoryItem) and item.is_expand:
item.unexpand()
for item in self.category_view.visible_items:
if isinstance(item, CategoryItem) and item.first_category_name == first_category_name:
item.expand()
break
for item in self.category_view.visible_items:
if isinstance(item, SecondCategoryItem) and item.second_category_name == second_category_name:
self.category_view.select_items([item])
self.category_view.visible_item(item)
item.button_press(0, 0, 0)
break
def draw_mask(self, cr, x, y, w, h):
'''
Draw mask interface.
@param cr: Cairo context.
@param x: X coordiante of draw area.
@param y: Y coordiante of draw area.
@param w: Width of draw area.
@param h: Height of draw area.
'''
sidebar_color = app_theme.get_color("sidebar_background").get_color()
draw_vlinear(cr, x, y, w, h,
[(0, (sidebar_color, 0.9)),
(1, (sidebar_color, 0.9)),]
)
def expose_canopy(self, widget, event):
# Init.
cr = widget.window.cairo_create()
rect = widget.allocation
canopy_color = app_theme.get_color("sidebar_select").get_color()
canopy_img_blue_path = os.path.join(get_parent_dir(__file__, 2), "image", "canopy", "canopy-blue.png")
canopy_img_yellow_path = os.path.join(get_parent_dir(__file__, 2), "image", "canopy", "canopy-yellow.png")
draw_pixbuf(
cr,
gtk.gdk.pixbuf_new_from_file(canopy_img_yellow_path),
rect.x,
rect.y)
surface = cairo.ImageSurface.create_from_png(canopy_img_blue_path)
cr.set_source_rgb(*color_hex_to_cairo(canopy_color))
cr.mask_surface(surface, rect.x, rect.y)
def expose_split_line(self, widget, event):
# Init.
cr = widget.window.cairo_create()
rect = widget.allocation
cr.set_source_rgb(*color_hex_to_cairo("#e5e5e5"))
cr.rectangle(rect.x, rect.y, 1, rect.height)
cr.fill()
return True
def search_entry_changed(self, entry, entry_string):
self.press_id += 1
self.press_return = False
self.entry_changed = True
def search_entry_key_press(self, widget, event):
self.in_press = True
self.press_id += 1
remove_timeout_id(self.show_timeout_id)
def search_entry_key_release(self, widget, event):
self.in_press = False
press_id = copy.deepcopy(self.press_id)
remove_timeout_id(self.show_timeout_id)
self.show_timeout_id = gobject.timeout_add(200, lambda : self.popup_completion(press_id))
def popup_completion(self, press_id):
if (not self.in_press) and (not self.press_return) and press_id == self.press_id and self.entry_changed:
search_string = search_entry.get_text()
if len(search_string.strip()) >= 3:
match_pkgs = self.data_manager.get_pkgs_match_input(search_string)
if len(match_pkgs) > 0:
completion_window.show(search_string, match_pkgs)
else:
completion_grab_window.popup_grab_window_focus_out()
else:
completion_grab_window.popup_grab_window_focus_out()
self.entry_changed = False
def show_search_page(self, search_string, press_return=False):
if search_string.strip() != "":
self.category_view.unselect_all()
self.press_return = press_return
if self.press_return:
completion_grab_window.popup_grab_window_focus_out()
search_page = SearchPage(self.data_manager)
self.show_pkg_view(search_page)
search_page.update(map(lambda word: word.encode("utf8"), search_string.split(" ")))
else:
logger.warning("empty string in search text input")
def show_pkg_view(self, widget):
container_remove_all(self.page_box)
self.page_box.pack_start(widget, True, True)
self.page_box.show_all()
class MainBox(gtk.HBox):
def __init__(self):
gtk.HBox.__init__(self)
self.connect("expose-event", self.on_page_expose_event)
self.aibizhi_cache_page = CachePage(Aibizhi())
self.bizhi360_cache_page = CachePage(Bizhi360())
self.aibizhi_cache_page.cache_view.try_to_fetch()
self.bizhi360_cache_page.cache_view.try_to_fetch()
self.favorites_page = FavoritePage(get_favorite_dir())
self.pictures_page = LocalPicturePage(get_download_wallpaper_dir())
self.add_item = AddItem()
self.pictures_page.select_view.add_items([self.add_item])
self.task_page = TaskPage()
self.switch_page = gtk.VBox()
self.__init_navigatebar()
self.pack_start(self.navigatebar, False, True)
self.pack_start(self.switch_page, True, True)
event_manager.add_callback("switch-to-local-pictures", self.switch_to_local_pictures)
def switch_to_local_pictures(self, name, obj, data=None):
item = self.navigatebar.get_items()[2]
self.on_navigatebar_single_click(self.navigatebar, item, 0, 0, 0)
def __init_navigatebar(self):
self.navigatebar = TreeView(enable_drag_drop=False, enable_multiple_select=False)
self.navigatebar.connect("single-click-item", self.on_navigatebar_single_click)
self.navigatebar.set_size_request(132, -1)
self.navigatebar.draw_mask = self.on_navigatebar_draw_mask
local_expand_item = ExpandItem(_("Library"))
network_expand_item = ExpandItem(_("Internet"))
self.navigatebar.add_items([local_expand_item,
network_expand_item,
])
local_expand_item.add_childs([
(FavoritesTitle, self.favorites_page),
(LocalWallpapersTitle, self.pictures_page),
],
expand=True)
network_expand_item.add_childs([(_("360 Wallpaper"), self.bizhi360_cache_page),
(_("LoveWallpaper"), self.aibizhi_cache_page),
], expand=True)
if get_favorite_number() == 0:
self.navigatebar.set_highlight_item(self.navigatebar.get_items()[2])
self.switch_page.add(self.pictures_page)
else:
self.navigatebar.set_highlight_item(self.navigatebar.get_items()[1])
self.switch_page.add(self.favorites_page)
def draw_mask(self, cr, x, y, w, h):
cr.set_source_rgb(1, 1, 1)
cr.rectangle(x, y, w, h)
cr.fill()
def on_page_expose_event(self, widget, event):
cr = widget.window.cairo_create()
width, height= widget.size_request()
self.draw_mask(cr, 0, 0, width, height)
def on_navigatebar_draw_mask(self, cr, x, y, w, h):
self.draw_mask(cr, x, y, w, h)
draw_line(cr, (x + w, y), (0, h), "#d6d6d6")
def on_navigatebar_single_click(self, widget, item, column, x, y):
if item.widget:
widget.set_highlight_item(item)
switch_box(self.switch_page, item.widget)
class PreferenceDialog(DialogBox):
def __init__(self):
super(PreferenceDialog, self).__init__(_("Preferences"), 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()
self.plugins_manager = PluginsManager()
# Category bar
self.category_bar = TreeView(enable_drag_drop=False, enable_multiple_select=False)
self.category_bar.set_expand_column(0)
self.category_bar.draw_mask = self.draw_treeview_mask
self.category_bar.set_size_request(132, 516)
self.category_bar.connect("single-click-item", self.on_categorybar_single_click)
# Init catagory bar.
self.__init_category_bar()
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_bar_align = gtk.Alignment()
category_bar_align.set(0, 0, 1, 1,)
category_bar_align.set_padding(0, 1, 0, 0)
category_bar_align.add(self.category_bar)
category_box.pack_start(category_bar_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_setting)
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 __init_category_bar(self):
general_normal_item = NormalItem(_("General"), self.general_setting)
hotkey_normal_item = NormalItem(_("Hotkeys"), self.hotkey_setting)
self.lyrics_expand_item = ExpandItem(_("Lyrics"), None)
self.lyrics_expand_item.add_childs([(_("Desktop"), self.desktop_lyrics_setting),
(_("Window"), self.scroll_lyrics_setting)])
self.plugins_expand_item = NormalItem(_("Plugins"), self.plugins_manager)
about_normal_item = NormalItem(_("About"), AboutBox())
items = [general_normal_item,
hotkey_normal_item,
self.lyrics_expand_item,
self.plugins_expand_item,
about_normal_item]
self.category_bar.add_items(items)
self.category_bar.select_items([general_normal_item])
def switch_lyrics_page(self, index=3):
self.lyrics_expand_item.try_to_expand()
show_item = self.category_bar.visible_items[index]
self.category_bar.select_items([show_item])
self.on_categorybar_single_click(self.category_bar, show_item, None, None, None)
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 on_categorybar_single_click(self, widget, item, column, x, y):
if item.allocate_widget:
switch_tab(self.right_box, item.allocate_widget)
def load_plugins(self):
self.plugins_manager.flush_plugins()
class WebcastsBrowser(gtk.VBox):
def __init__(self):
gtk.VBox.__init__(self)
# Init data.
self.source_data = OrderedDict()
self.source_data["internal"] = "国内广播"
self.source_data["foreign"] = "国外广播"
self.source_data["network"] = "网络广播"
self.source_data["genres"] = "流派广播"
self.source_data["music"] = "音乐广播"
self.source_data["finance"] = "财经广播"
self.source_data["sports"] = "体育广播"
# Init sourcebar
self.__init_sourcebar()
# Init webcasts view.
self.source_view, self.source_sw = self.get_webcasts_view()
self.collect_view, self.collect_sw = self.get_webcasts_view()
# self.custom_view, custom_view_sw = self.get_webcasts_view()
self.source_view.connect("single-click-item",
self.on_source_view_single_click_item)
if WebcastsDB.isloaded():
self.on_webcastsdb_loaded()
else:
self.connect_to_webcastsdb()
# Dispatcher
Dispatcher.connect("webcast-info", self.on_dispatcher_webcast_info)
Dispatcher.connect("clear-sourcebar-status",
lambda obj: self.clear_sourcebar_status())
# Used to switch categroy view.
self.switch_view_box = gtk.VBox()
self.switch_view_box.add(self.source_sw)
body_paned = HPaned(handle_color=app_theme.get_color("panedHandler"),
enable_drag=True)
body_paned.add1(self.sourcebar)
body_paned.add2(self.switch_view_box)
self.add(body_paned)
self.show_all()
def on_dispatcher_webcast_info(self, obj, parent, key):
items = WebcastsDB.get_items(parent, key)
self.source_view.clear()
if items:
self.source_view.add_items([WebcastListItem(tag) for tag in items])
switch_tab(self.switch_view_box, self.source_sw)
def connect_to_webcastsdb(self):
WebcastsDB.connect("loaded", self.on_webcastsdb_loaded)
def on_webcastsdb_loaded(self, *args):
items = WebcastsDB.get_items("internal", "中央电台")
self.source_view.add_items([WebcastListItem(tag) for tag in items])
# load collect webcasts.
collect_taglist = WebcastsDB.get_favorite_items()
if collect_taglist:
self.collect_view.add_items(
[WebcastListItem(tag) for tag in collect_taglist])
def __init_sourcebar(self):
self.sourcebar = TreeView(enable_drag_drop=False,
enable_multiple_select=False)
items = []
for index, (key, value) in enumerate(self.source_data.items()):
if index == 0: show_icon = True
else: show_icon = False
items.append(
CategroyItem(value, key, self.sourcebar, index, show_icon))
items.append(
CustomItem(
"我的收藏",
lambda: switch_tab(self.switch_view_box, self.collect_sw)))
self.sourcebar.add_items(items)
self.sourcebar.set_size_request(121, -1)
self.sourcebar.draw_mask = self.on_sourcebar_draw_mask
self.sourcebar.draw_area.tag_by_poup_panel_grab_window = True
popup_grab_window.focus_out_callback = self.handle_focus_out
def handle_focus_out(self):
self.sourcebar.unhover_row()
self.sourcebar.left_button_press = False
def get_webcasts_view(self):
webcast_view = MultiDragWebcastView()
scrolled_window = ScrolledWindow(0, 0)
scrolled_window.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
scrolled_window.add_child(webcast_view)
return webcast_view, scrolled_window
def on_sourcebar_draw_mask(self, cr, x, y, w, h):
draw_alpha_mask(cr, x, y, w, h, "layoutRight")
return False
def on_source_view_single_click_item(self, widget, item, column, x, y):
if column == 2:
item.toggle_is_collected()
if item.is_collected:
tags = item.webcast.get_dict()
self.collect_view.add_items([WebcastListItem(tags, True)])
else:
for c_item in self.collect_view.items:
if c_item == item:
self.collect_view.delete_items([c_item])
del c_item
def save(self):
if not self.collect_view.items:
return
items = []
for item in self.collect_view.items:
items.append(item.get_tags())
utils.save_db(items, get_config_file("favorite_webcasts.db"))
def clear_sourcebar_status(self):
items = self.sourcebar.visible_items
if items:
[item.unselect() for item in items]
class HomePage(gtk.HBox):
'''
class docs
'''
def __init__(self, data_manager, recommend_status):
'''
init docs
'''
# Init.
gtk.HBox.__init__(self)
self.data_manager = data_manager
self.recommend_status = recommend_status
self.background_box = BackgroundBox()
self.background_box.draw_mask = self.draw_mask
self.sidebar_box = gtk.VBox()
self.page_box = gtk.VBox()
self.sidebar_box.set_size_request(CATEGORY_VIEW_WIDTH, -1)
self.canopy = gtk.VBox()
self.canopy.set_size_request(-1, 19)
self.search_align = gtk.Alignment()
self.search_align.set(0.5, 0.5, 0, 0)
self.search_align.set_padding(15, 5, 13, 13)
self.search_align.add(search_entry)
self.in_press = False
self.press_return = False
self.press_id = 0
self.show_timeout_id = None
self.entry_changed = False
search_entry.entry.connect("changed", self.search_entry_changed)
search_entry.entry.connect("key-press-event",
self.search_entry_key_press)
search_entry.entry.connect("key-release-event",
self.search_entry_key_release)
search_entry.connect(
"action-active",
lambda entry, search_string: self.show_search_page(search_string))
search_entry.entry.connect(
"press-return",
lambda entry: self.show_search_page(entry.get_text(), True))
self.recommend_item = RecommendItem(data_manager,
self.recommend_status)
category_items = []
for (index, first_category_name) in enumerate(
data_manager.get_first_category()):
category_items.append(
CategoryItem(index + 1, first_category_name, data_manager))
self.category_view = TreeView(
[self.recommend_item] + category_items,
enable_drag_drop=False,
enable_multiple_select=False,
expand_column=0,
)
self.category_view.draw_mask = self.draw_mask
self.category_view.set_size_request(-1, 470)
self.category_view_align = gtk.Alignment()
self.category_view_align.set(0.5, 0.5, 1, 1)
self.category_view_align.set_padding(10, 10, 0, 0)
self.category_view_align.add(self.category_view)
self.background_box.pack_start(self.canopy, False, False)
self.background_box.pack_start(self.search_align, True, True)
self.background_box.pack_end(self.category_view_align, False, False)
self.sidebar_box.pack_start(self.background_box, False, False)
self.split_line = gtk.VBox()
self.split_line.set_size_request(1, -1)
self.pack_start(self.sidebar_box, False, False)
self.pack_start(self.split_line, False, False)
self.pack_start(self.page_box, True, True)
self.canopy.connect("expose-event", self.expose_canopy)
self.split_line.connect("expose-event", self.expose_split_line)
global_event.register_event("show-pkg-view", self.show_pkg_view)
global_event.register_event("category-expand",
self.category_expand_handler)
def category_expand_handler(self, item):
self.category_view.visible_item(item.child_items[-1])
def jump_to_category(self, first_category_name, second_category_name):
for item in self.category_view.visible_items:
if isinstance(item, CategoryItem) and item.is_expand:
item.unexpand()
for item in self.category_view.visible_items:
if isinstance(
item, CategoryItem
) and item.first_category_name == first_category_name:
item.expand()
break
for item in self.category_view.visible_items:
if isinstance(
item, SecondCategoryItem
) and item.second_category_name == second_category_name:
self.category_view.select_items([item])
self.category_view.visible_item(item)
item.button_press(0, 0, 0)
break
def draw_mask(self, cr, x, y, w, h):
'''
Draw mask interface.
@param cr: Cairo context.
@param x: X coordiante of draw area.
@param y: Y coordiante of draw area.
@param w: Width of draw area.
@param h: Height of draw area.
'''
sidebar_color = app_theme.get_color("sidebar_background").get_color()
draw_vlinear(cr, x, y, w, h, [
(0, (sidebar_color, 0.9)),
(1, (sidebar_color, 0.9)),
])
def expose_canopy(self, widget, event):
# Init.
cr = widget.window.cairo_create()
rect = widget.allocation
canopy_color = app_theme.get_color("sidebar_select").get_color()
canopy_img_blue_path = os.path.join(get_parent_dir(__file__,
2), "image",
"canopy", "canopy-blue.png")
canopy_img_yellow_path = os.path.join(get_parent_dir(__file__,
2), "image",
"canopy", "canopy-yellow.png")
draw_pixbuf(cr, gtk.gdk.pixbuf_new_from_file(canopy_img_yellow_path),
rect.x, rect.y)
surface = cairo.ImageSurface.create_from_png(canopy_img_blue_path)
cr.set_source_rgb(*color_hex_to_cairo(canopy_color))
cr.mask_surface(surface, rect.x, rect.y)
def expose_split_line(self, widget, event):
# Init.
cr = widget.window.cairo_create()
rect = widget.allocation
cr.set_source_rgb(*color_hex_to_cairo("#e5e5e5"))
cr.rectangle(rect.x, rect.y, 1, rect.height)
cr.fill()
return True
def search_entry_changed(self, entry, entry_string):
self.press_id += 1
self.press_return = False
self.entry_changed = True
def search_entry_key_press(self, widget, event):
self.in_press = True
self.press_id += 1
remove_timeout_id(self.show_timeout_id)
def search_entry_key_release(self, widget, event):
self.in_press = False
press_id = copy.deepcopy(self.press_id)
remove_timeout_id(self.show_timeout_id)
self.show_timeout_id = gobject.timeout_add(
200, lambda: self.popup_completion(press_id))
def popup_completion(self, press_id):
if (not self.in_press) and (
not self.press_return
) and press_id == self.press_id and self.entry_changed:
search_string = search_entry.get_text()
if len(search_string.strip()) >= 3:
match_pkgs = self.data_manager.get_pkgs_match_input(
search_string)
if len(match_pkgs) > 0:
completion_window.show(search_string, match_pkgs)
else:
completion_grab_window.popup_grab_window_focus_out()
else:
completion_grab_window.popup_grab_window_focus_out()
self.entry_changed = False
def show_search_page(self, search_string, press_return=False):
if search_string.strip() != "":
self.category_view.unselect_all()
self.press_return = press_return
if self.press_return:
completion_grab_window.popup_grab_window_focus_out()
search_page = SearchPage(self.data_manager)
self.show_pkg_view(search_page)
search_page.update(
map(lambda word: word.encode("utf8"),
search_string.split(" ")))
else:
global_logger.warn("empty string in search text input")
def show_pkg_view(self, widget):
container_remove_all(self.page_box)
self.page_box.pack_start(widget, True, True)
self.page_box.show_all()
class WebcastsBrowser(gtk.VBox):
def __init__(self):
gtk.VBox.__init__(self)
# Init data.
self.source_data = OrderedDict()
self.source_data["internal"] = "国内广播"
self.source_data["foreign"] = "国外广播"
self.source_data["network"] = "网络广播"
self.source_data["genres"] = "流派广播"
self.source_data["music"] = "音乐广播"
self.source_data["finance"] = "财经广播"
self.source_data["sports"] = "体育广播"
# Init sourcebar
self.__init_sourcebar()
# Init webcasts view.
self.source_view, self.source_sw = self.get_webcasts_view()
self.collect_view, self.collect_sw = self.get_webcasts_view()
# self.custom_view, custom_view_sw = self.get_webcasts_view()
self.source_view.connect("single-click-item", self.on_source_view_single_click_item)
if WebcastsDB.isloaded():
self.on_webcastsdb_loaded()
else:
self.connect_to_webcastsdb()
# Dispatcher
Dispatcher.connect("webcast-info", self.on_dispatcher_webcast_info)
Dispatcher.connect("clear-sourcebar-status", lambda obj: self.clear_sourcebar_status())
# Used to switch categroy view.
self.switch_view_box = gtk.VBox()
self.switch_view_box.add(self.source_sw)
body_paned = HPaned(handle_color=app_theme.get_color("panedHandler"), enable_drag=True)
body_paned.add1(self.sourcebar)
body_paned.add2(self.switch_view_box)
self.add(body_paned)
self.show_all()
def on_dispatcher_webcast_info(self, obj, parent, key):
items = WebcastsDB.get_items(parent, key)
self.source_view.clear()
if items:
self.source_view.add_items([WebcastListItem(tag) for tag in items])
switch_tab(self.switch_view_box, self.source_sw)
def connect_to_webcastsdb(self):
WebcastsDB.connect("loaded", self.on_webcastsdb_loaded)
def on_webcastsdb_loaded(self, *args):
items = WebcastsDB.get_items("internal", "中央电台")
self.source_view.add_items([WebcastListItem(tag) for tag in items])
# load collect webcasts.
collect_taglist = WebcastsDB.get_favorite_items()
if collect_taglist:
self.collect_view.add_items([WebcastListItem(tag) for tag in collect_taglist])
def __init_sourcebar(self):
self.sourcebar = TreeView(enable_drag_drop=False, enable_multiple_select=False)
items = []
for index, (key, value) in enumerate(self.source_data.items()):
if index == 0: show_icon = True
else: show_icon = False
items.append(CategroyItem(value, key, self.sourcebar, index, show_icon))
items.append(CustomItem("我的收藏", lambda : switch_tab(self.switch_view_box, self.collect_sw)))
self.sourcebar.add_items(items)
self.sourcebar.set_size_request(121, -1)
self.sourcebar.draw_mask = self.on_sourcebar_draw_mask
self.sourcebar.draw_area.tag_by_poup_panel_grab_window = True
popup_grab_window.focus_out_callback = self.handle_focus_out
def handle_focus_out(self):
self.sourcebar.unhover_row()
self.sourcebar.left_button_press = False
def get_webcasts_view(self):
webcast_view = MultiDragWebcastView()
scrolled_window = ScrolledWindow(0, 0)
scrolled_window.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
scrolled_window.add_child(webcast_view)
return webcast_view, scrolled_window
def on_sourcebar_draw_mask(self, cr, x, y, w, h):
draw_alpha_mask(cr, x, y, w, h ,"layoutRight")
return False
def on_source_view_single_click_item(self, widget, item, column, x, y):
if column == 2:
item.toggle_is_collected()
if item.is_collected:
tags = item.webcast.get_dict()
self.collect_view.add_items([WebcastListItem(tags, True)])
else:
for c_item in self.collect_view.items:
if c_item == item:
self.collect_view.delete_items([c_item])
del c_item
def save(self):
if not self.collect_view.items:
return
items = []
for item in self.collect_view.items:
items.append(item.get_tags())
utils.save_db(items, get_config_file("favorite_webcasts.db"))
def clear_sourcebar_status(self):
items = self.sourcebar.visible_items
if items:
[item.unselect() for item in items]
class RadioBrowser(gtk.VBox):
def __init__(self):
gtk.VBox.__init__(self)
# Init radiobar.
self.__init_radiobar()
# is loaded.
self.homepage_load_flag = False
self.home_page = HomePage()
self.hot_page_view, self.hot_page_sw = self.get_radio_icon_view(
TAG_HOT, 20)
self.fast_page_view, self.fast_page_sw = self.get_radio_icon_view(
TAG_FAST, 20)
# Genres page
self.genre_page = GenrePage()
self.page_box = gtk.VBox()
self.page_box.add(self.home_page)
self.body_paned = HPaned(
handle_color=app_theme.get_color("panedHandler"))
self.body_paned.add1(self.radiobar)
self.body_paned.add2(self.page_box)
self.network_failed_box = NetworkConnectFailed(
self.check_network_connection)
self.check_network_connection(auto=True)
def check_network_connection(self, auto=False):
if is_network_connected():
switch_tab(self, self.body_paned)
if not auto:
self.start_fetch_channels()
else:
switch_tab(self, self.network_failed_box)
def __init_radiobar(self):
self.radiobar = TreeView(enable_drag_drop=False,
enable_multiple_select=False)
items = []
items.append(
CategroyTreeItem(
_("Home"), "home",
lambda: switch_tab(self.page_box, self.home_page)))
items.append(
CategroyTreeItem(
_("Hot MHz"), "hot",
lambda: switch_tab(self.page_box, self.hot_page_sw)))
items.append(
CategroyTreeItem(
_("Genres"), "genre",
lambda: switch_tab(self.page_box, self.genre_page)))
items.append(
CategroyTreeItem(
_("Pop MHz"), "up",
lambda: switch_tab(self.page_box, self.fast_page_sw)))
self.radiobar.add_items(items)
self.radiobar.select_items([self.radiobar.visible_items[0]])
self.radiobar.set_size_request(121, -1)
self.radiobar.draw_mask = self.on_radiobar_draw_mask
def on_radiobar_draw_mask(self, cr, x, y, w, h):
draw_alpha_mask(cr, x, y, w, h, "layoutRight")
def get_radio_icon_view(self, tag, limit=10, padding_x=0, padding_y=10):
icon_view = RadioIconView(tag=tag,
limit=limit,
padding_x=padding_x,
padding_y=padding_y)
scrolled_window = icon_view.get_scrolled_window()
return icon_view, scrolled_window
def start_fetch_channels(self):
self.fast_page_view.clear_items()
self.hot_page_view.clear_items()
self.home_page.start_fetch_channels()
self.hot_page_view.start_fetch_channels()
self.fast_page_view.start_fetch_channels()
self.genre_page.start_fetch_channels()
class AddPage(gtk.HBox):
def __init__(self):
gtk.HBox.__init__(self)
self.aibizhi_cache_page = CachePage(Aibizhi())
self.bizhi360_cache_page = CachePage(Bizhi360())
self.aibizhi_cache_page.cache_view.try_to_fetch()
self.bizhi360_cache_page.cache_view.try_to_fetch()
self.system_wallpapers_page = SystemPage(
get_system_wallpaper_dirs()[0])
self.picture_wallpapers_page = PicturePage(get_images_dir())
self.download_wallpapaers_page = UserPage(get_download_wallpaper_dir())
self.task_page = TaskPage()
self.__init_navigatebar()
self.switch_page = gtk.VBox()
self.pack_start(self.navigatebar, False, True)
self.pack_start(self.switch_page, True, True)
self.switch_page.add(self.system_wallpapers_page)
event_manager.add_callback("downloading-tasks-number",
self.on_download_item_changed)
self.connect("expose-event", self.on_addpage_expose_event)
def set_theme(self, theme):
self.system_wallpapers_page.set_theme(theme)
self.picture_wallpapers_page.set_theme(theme)
self.download_wallpapaers_page.set_theme(theme)
self.aibizhi_cache_page.set_theme(theme)
self.bizhi360_cache_page.set_theme(theme)
def on_download_item_changed(self, name, obj, data):
pass
def __init_navigatebar(self):
self.navigatebar = TreeView(enable_drag_drop=False,
enable_multiple_select=False)
self.navigatebar.connect("single-click-item",
self.on_navigatebar_single_click)
self.navigatebar.set_size_request(132, -1)
self.navigatebar.draw_mask = self.on_navigatebar_draw_mask
local_expand_item = ExpandItem(_("Library"))
network_expand_item = ExpandItem(_("Internet"))
self.navigatebar.add_items([
local_expand_item,
network_expand_item,
])
local_expand_item.add_childs(
[(_("System"), self.system_wallpapers_page),
(_("Pictures"), self.picture_wallpapers_page),
(_("Favorites"), self.download_wallpapaers_page)],
expand=True)
network_expand_item.add_childs([
(_("360 Wallpaper"), self.bizhi360_cache_page),
(_("LoveWallpaper"), self.aibizhi_cache_page),
],
expand=True)
self.navigatebar.set_highlight_item(self.navigatebar.get_items()[1])
def on_addpage_expose_event(self, widget, event):
cr = widget.window.cairo_create()
rect = widget.allocation
self.draw_mask(cr, *rect)
def on_navigatebar_draw_mask(self, cr, x, y, w, h):
self.draw_mask(cr, x, y, w, h)
draw_line(cr, (x + w, y), (0, h), "#d6d6d6")
def draw_mask(self, cr, x, y, w, h):
'''
Draw mask interface.
@param cr: Cairo context.
@param x: X coordiante of draw area.
@param y: Y coordiante of draw area.
@param w: Width of draw area.
@param h: Height of draw area.
'''
cr.set_source_rgb(1, 1, 1)
cr.rectangle(x, y, w, h)
cr.fill()
def on_navigatebar_single_click(self, widget, item, column, x, y):
if item.widget:
widget.set_highlight_item(item)
switch_box(self.switch_page, item.widget)
class WebcastsBrowser(gtk.VBox, SignalContainer):
def __init__(self):
gtk.VBox.__init__(self)
SignalContainer.__init__(self)
# Init categorys.
self.get_categorys()
# load data.
self.__load_webcast_query()
# Init webcastbar.
self.__init_webcastbar()
# Init iconview.
self.metro_view = self.get_icon_view()
self.metro_view_sw = self.metro_view.get_scrolled_window()
self.page_box = gtk.VBox()
self.page_box.add(self.metro_view_sw)
# webcasts view
self.webcast_view = self.get_webcast_view()
self.webcast_view_sw = self.webcast_view.get_scrolled_window()
# collect view
self.collected_db_file = get_config_file("favorite_webcasts.db")
self.collected_view = self.get_webcast_view()
self.collected_view_sw = self.collected_view.get_scrolled_window()
# Init collect view.
# init listview page.
self.init_listview_page()
Dispatcher.connect("change-webcast", self.on_dispatcher_change_webcast)
WebcastDB.connect("changed", self.on_db_update_songs)
body_paned = HPaned(handle_color=app_theme.get_color("panedHandler"),
enable_drag=True)
body_paned.add1(self.webcastbar)
body_paned.add2(self.page_box)
self.add(body_paned)
def get_categorys(self):
lang = utils.get_system_lang()
if lang.startswith("zh"):
self.__categorys = ["region", "genre", "composite"]
self.current_category = "region"
else:
self.__categorys = ["region_en", "genre_en"]
self.current_category = "region_en"
self.__category_gettexts = {
"region": "地域分类",
"genre": "流派分类",
"region_en": _("Region"),
"genre_en": _("Genre"),
"composite": "综合分类",
"finance": "财经",
"sports": "体育",
"music": "音乐",
"news": "新闻",
"network": "网络",
}
def __load_webcast_query(self):
self.__db_query = WebcastQuery()
if WebcastDB.isloaded():
self.__on_db_loaded()
else:
WebcastDB.connect("loaded", lambda obj: self.__on_db_loaded())
def __on_db_loaded(self):
self.autoconnect(self.__db_query, "added", self.__on_added_songs)
self.autoconnect(self.__db_query, "removed", self.__on_removed_songs)
self.autoconnect(self.__db_query, "update-songs",
self.__on_update_songs)
self.autoconnect(self.__db_query, "full-update", self.__on_full_update)
self.__db_query.set_query()
def __on_added_songs(self, db_query, songs):
self.reload_flag = True
def __on_removed_songs(self, db_query, songs):
self.reload_flag = True
def __on_update_songs(self, db_query, songs):
self.reload_flag = True
def __on_full_update(self, db_query):
self.load_view_data()
self.load_collect_data()
def __init_webcastbar(self):
self.webcastbar = TreeView(enable_drag_drop=False,
enable_multiple_select=False)
self.webcastbar.connect("single-click-item",
self.on_webcastbar_single_click_item)
items = []
for category in self.__categorys:
items.append(
CategoryTreeItem(self.__category_gettexts[category],
category=category))
items.append(CollectTreeItem(_("Favorites")))
self.webcastbar.add_items(items)
self.webcastbar.select_items([self.webcastbar.visible_items[0]])
self.webcastbar.set_size_request(121, -1)
self.webcastbar.draw_mask = self.on_webcastbar_draw_mask
def on_webcastbar_draw_mask(self, cr, x, y, w, h):
draw_alpha_mask(cr, x, y, w, h, "layoutRight")
def on_webcastbar_single_click_item(self, widget, item, column, x, y):
if hasattr(item, "collect_flag"):
switch_tab(self.page_box, self.collected_view_sw)
else:
widget = self.page_box.get_children()[0]
if widget != self.metro_view_sw:
switch_tab(self.page_box, self.metro_view_sw)
if self.current_category != item.category:
self.current_category = item.category
self.load_view_data()
def init_listview_page(self):
self.listview_page = gtk.VBox()
self.text_prompt = TextPrompt("Default")
prompt_align = set_widget_gravity(self.text_prompt,
paddings=(10, 10, 0, 0))
prompt_box = gtk.HBox()
back_button = BackButton()
back_button.connect("clicked", self.on_backbutton_clicked)
back_button_align = set_widget_gravity(back_button,
gravity=(0.5, 0.5, 0, 0),
paddings=(0, 0, 10, 5))
prompt_box.pack_start(back_button_align, False, True)
prompt_box.pack_start(prompt_align, False, False)
self.listview_page.pack_start(prompt_box, False, True)
self.listview_page.pack_start(self.webcast_view_sw, True, True)
def on_backbutton_clicked(self, widget):
switch_tab(self.page_box, self.metro_view_sw)
def switch_to_listview(self, category, title):
self.text_prompt.set_text(title)
self.webcast_view.clear()
songs = self.__db_query.get_songs(category, title)
self.webcast_view.add_webcasts(songs)
switch_tab(self.page_box, self.listview_page)
def load_view_data(self):
self.metro_view.clear()
if self.current_category == "composite":
child_datas = self.__db_query.get_composite_categorys()
gettext_datas = []
for child in child_datas:
gettext_datas.append((self.__category_gettexts[child], child))
self.metro_view.add_composite_items(gettext_datas)
else:
child_datas = self.__db_query.get_info(self.current_category)[0]
child_datas.sort(key=lambda x: locale.strxfrm(x))
self.metro_view.add_webcast_items(child_datas)
def load_collect_data(self):
try:
collected_objs = utils.load_db(self.collected_db_file)
except:
collected_objs = None
if collected_objs:
songs = [WebcastDB.get_song(uri) for uri in collected_objs]
else:
songs = None
if songs:
songs = [song for song in songs if song.get("collected", False)]
if songs:
self.collected_view.add_webcasts(songs)
def get_icon_view(self):
icon_view = WebcastIconView()
icon_view.connect("single-click-item",
self.on_iconview_single_click_item)
icon_view.connect("double-click-item",
self.on_iconview_single_click_item)
return icon_view
def on_iconview_single_click_item(self, widget, item, x, y):
if item.is_composited:
category = item.category
else:
category = self.current_category
title = item.title
if item.is_composited:
self.switch_to_listview(category, title)
else:
self.switch_to_listview(category, title)
def get_webcast_view(self):
webcast_view = MultiDragWebcastView()
webcast_view.keymap.update(
{"BackSpace": lambda: self.on_backbutton_clicked(None)})
return webcast_view
def on_dispatcher_change_webcast(self, widget, song):
item = self.collected_view.get_webcast_item(song)
if item and not song.get("collected", False):
self.collected_view.delete_items([item])
elif song.get("collected", False):
self.collected_view.add_webcasts([song])
def on_db_update_songs(self, db, infos):
for song, tags, new_tags in infos:
if new_tags.has_key("collected"):
item = self.collected_view.get_webcast_item(song)
if item:
if not new_tags.get("collected", False):
self.collected_view.delete_items([item])
else:
if new_tags.get("collected", False):
self.collected_view.add_webcasts([song])
def save(self):
songs = self.collected_view.get_webcasts()
uris = [song.get("uri") for song in songs if song.get("uri")]
utils.save_db(uris, self.collected_db_file)
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)
