def __init_widget(self):
self.buttonbox = gtk.VBox()
self.pack_start(self.buttonbox, False, False)
style.add_separator(self)
#self.connection_tree = EntryTreeView()
self.add_button = AddSettingItem(_("New Connection") ,self.add_new_connection)
add_setting_tree = TreeView([self.add_button])
add_setting_tree.set_expand_column(1)
self.pack_start(add_setting_tree, False, False)
self.set_size_request(160, -1)
self.show_all()
self.__init_signals()
def __init_widget(self):
self.buttonbox = gtk.VBox()
self.pack_start(self.buttonbox, False, False)
style.add_separator(self)
#self.connection_tree = EntryTreeView()
self.add_button = AddSettingItem(_("New Connection"),
self.add_new_connection)
add_setting_tree = TreeView([self.add_button])
add_setting_tree.set_expand_column(1)
self.pack_start(add_setting_tree, False, False)
self.set_size_request(160, -1)
self.show_all()
self.__init_signals()
class ListviewFactory(object):
'''
class docs
'''
def __init__(self, items, owner):
'''
init docs
'''
self.items = [ListViewItem(x, owner) for x in items]
self.owner = owner
self.count_per_page = 10 if self.owner == "brief" else 20
self.listview = None
self.page_count = 0
self.page_index = 0
self.paged_items = self.get_paged_items()
self.init_listview()
def prepend_item(self, item):
if self.listview:
self.listview.add_items([ListViewItem(item, self.owner)], insert_pos=0)
def append_item(self, item):
if self.listview:
self.listview.add_items([ListViewItem(item, self.owner)])
def on_listview_button_pressed(self, widget, event, listview):
x = event.x
y = event.y
if event.button == 1:
for item in listview.get_items():
for index, rect in enumerate(item.pointer_hand_rectangles):
if is_in_rect((x, y), rect):
action = item.message["hints"]["x-deepin-hyperlinks"][index]
if action.has_key("href"):
webbrowser.open_new_tab(action.get("href"))
return
def on_listview_motion_notify(self, widget, event, listview):
x = event.x
y = event.y
flag = False
for item in listview.get_items():
if flag:
break
for rect in item.pointer_hand_rectangles:
if is_in_rect((x, y), rect):
flag = True
break
if flag:
widget.window.set_cursor(gtk.gdk.Cursor(gtk.gdk.HAND1))
else:
widget.window.set_cursor(None)
def init_listview(self):
'''
docs
'''
items = self.paged_items[self.page_index]
self.listview = TreeView(items)
self.listview.draw_mask = self.on_listview_draw_mask
self.listview.set_expand_column(0)
if self.owner == "detail":
self.listview.set_column_titles([_("Content of messages"), _("Time")],
[self.sort_by_content, self.sort_by_time])
self.listview.draw_area.connect_after("button-press-event", self.on_listview_button_pressed, self.listview)
self.listview.draw_area.connect_after("motion-notify-event", self.on_listview_motion_notify, self.listview)
self.listview.connect("right-press-items", self.on_listview_right_press_items)
self.listview.scrolled_window.connect("vscrollbar-state-changed", self.update_listview)
event_manager.emit("listview-items-added", items)
def update_listview(self, widget, state):
if state == "bottom":
if self.page_index < self.page_count - 1:
self.page_index = self.page_index + 1
items = self.paged_items[self.page_index]
self.listview.add_items(items)
event_manager.emit("listview-items-added", items)
def on_listview_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_listview_right_press_items(self, widget, root_x, root_y, current_item, select_items):
if self.owner == "detail":
def on_delete_selected_record():
def on_ok_clicked():
def _remove_selected():
for item in select_items:
db.remove(item.id)
db.commit()
widget.delete_items(select_items)
widget.get_toplevel()._init_data()
Thread(target=_remove_selected).run()
dialog = ConfirmDialog(
_("Delete Item(s)"),
_("Are you sure you want to delete the selected item(s)?"),
confirm_callback = on_ok_clicked)
dialog.show_all()
def on_delete_all_record():
def on_ok_clicked():
def _remove_all():
for item in self.items:
db.remove(item.id)
db.commit()
widget.get_toplevel().refresh_view()
Thread(target=_remove_all).run()
dialog = ConfirmDialog(
_("Delete Item(s)"),
_("Are you sure delete all items?"),
confirm_callback = on_ok_clicked)
dialog.show_all()
Menu([(None, _("Delete selected item(s)"), on_delete_selected_record),
(None, _("Delete all items"), on_delete_all_record)], True).show((root_x, root_y))
def get_paged_items(self):
paged_items = {}
index = 0
for item in self.items:
paged_items.setdefault(index / self.count_per_page, []).append(item)
index += 1
self.page_count = len(paged_items)
return paged_items
def sort_by_content(self, items, reverse):
'''
docs
'''
return sorted(items, key=lambda item : item.content, reverse=reverse)
def sort_by_time(self, items, reverse):
'''
docs
'''
return sorted(items, key=lambda item : item.time, reverse=reverse)
class SearchUI(DialogBox):
def __init__(self):
DialogBox.__init__(
self, _("Lyrics search"), 460, 300, DIALOG_MASK_MULTIPLE_PAGE, close_callback=self.hide_all,
modal=False, window_hint=None, skip_taskbar_hint=False, window_pos=gtk.WIN_POS_CENTER)
self.artist_entry = InputEntry()
self.artist_entry.set_size(130, 23)
self.title_entry = InputEntry()
self.title_entry.set_size(130, 23)
artist_label = Label(_("Artist:"))
title_label = Label(_("Title:"))
right_align = gtk.Alignment()
right_align.set(0, 0, 0, 1)
self.search_button = Button(_("Search"))
self.search_button.connect("clicked", self.search_lyric_cb)
self.process_id = 0
info_box = gtk.HBox(spacing=25)
control_box = gtk.HBox(spacing=5)
title_box = gtk.HBox(spacing=5)
title_box.pack_start(title_label, False, False)
title_box.pack_start(self.title_entry)
artist_box = gtk.HBox(spacing=5)
artist_box.pack_start(artist_label, False, False)
artist_box.pack_start(self.artist_entry)
control_box.pack_start(title_box, False, False)
control_box.pack_start(artist_box, False, False)
info_box.pack_start(control_box, False, False)
info_box.pack_start(self.search_button, False, False)
sort_items = [ lambda items, reverse : self.sort_by_key(items, reverse, "title"),
lambda items, reverse : self.sort_by_key(items, reverse, "artist")]
self.result_view = TreeView()
self.result_view.set_expand_column(0)
self.result_view.connect("double-click-item", self.double_click_cb)
self.result_view.set_column_titles([_("Title"), _("Artist")], sort_items)
self.result_view.draw_mask = self.draw_view_mask
self.prompt_label = Label("")
download_button = Button(_("Download"))
download_button.connect("clicked", self.download_lyric_cb)
cancel_button = Button(_("Close"))
cancel_button.connect("clicked", lambda w: self.hide_all())
info_box_align = gtk.Alignment()
info_box_align.set_padding(5, 0, 5, 0)
info_box_align.add(info_box)
self.body_box.set_spacing(5)
self.body_box.pack_start(info_box_align, False, False)
self.body_box.pack_start(self.result_view, True, True)
self.left_button_box.set_buttons([self.prompt_label])
self.right_button_box.set_buttons([download_button, cancel_button])
self.lrc_manager = LrcManager()
def show_window(self):
DialogBox.show_window(self)
self.present()
def draw_view_mask(self, cr, x, y, width, height):
draw_alpha_mask(cr, x, y, width, height, "layoutMiddle")
def sort_by_key(self, items, sort_reverse, sort_key):
return sorted(items, reverse=sort_reverse, key=lambda item: getattr(item, sort_key))
def double_click_cb(self, widget, item, colume, x, y):
self.download_lyric_cb(widget)
def search_engine(self, artist, title, pid):
ting_result = poster.query_lrc_info(artist, title)
self.render_lyrics(ting_result, pid=pid)
ttplayer_result = TTPlayer().request(artist, title)
self.render_lyrics(ttplayer_result, pid=pid)
ttpod_result = TTPod().request(artist, title)
self.render_lyrics(ttpod_result, pid=pid)
duomi_result = DUOMI().request(artist, title)
self.render_lyrics(duomi_result, pid=pid, last=True)
def search_lyric_cb(self, widget):
self.result_view.clear()
artist = self.artist_entry.entry.get_text()
title = self.title_entry.entry.get_text()
# widget.set_sensitive(False)
self.prompt_label.set_text(_("Now searching..."))
if artist == "" and title == "":
self.prompt_label.set_text(_("Not found!"))
return
self.process_id += 1
utils.ThreadLoad(self.search_engine, artist, title, self.process_id).start()
@post_gui
def render_lyrics(self, result, last=False, pid=1):
'''docs'''
if pid != self.process_id:
return
if result != None:
try:
items = [SearchItem(each_info) for each_info in result]
except:
pass
else:
self.result_view.add_items(items)
self.prompt_label.set_text(_("%d lyrics found") % len(self.result_view.get_items()))
else:
if last:
if len(self.result_view.get_items()) > 0:
self.prompt_label.set_text(_("%d lyrics found") % len(self.result_view.get_items()))
else:
self.prompt_label.set_text(_("Not found!"))
def download_lyric_cb(self, widget):
select_items = self.result_view.select_rows
save_filepath = self.lrc_manager.get_lrc_filepath(Player.song)
if len(select_items) > 0:
self.prompt_label.set_text(_("Downloading lyrics..."))
item = self.result_view.get_items()[select_items[0]]
url = item.get_url()
net_encode = item.get_netcode()
utils.ThreadRun(utils.download, self.render_download, [url, save_filepath, net_encode]).start()
@post_gui
def render_download(self, result):
if result:
Dispatcher.reload_lrc(Player.song)
self.prompt_label.set_text("%s %s" % (_("File save to"), config.get("lyrics", "save_lrc_path")))
else:
self.prompt_label.set_text(_("Download failed."))
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 InstallPage(gtk.VBox):
'''
class docs
'''
def __init__(self, bus_interface, data_manager):
'''
init docs
'''
# Init.
gtk.VBox.__init__(self)
self.bus_interface = bus_interface
self.data_manager = data_manager
self.message_bar = MessageBar(32)
self.message_box = gtk.HBox()
self.treeview = TreeView(enable_drag_drop=False)
self.treeview.set_expand_column(0)
self.cute_message_image = gtk.VBox()
self.content_box = gtk.VBox()
self.pack_start(self.message_box, False, False)
self.pack_start(self.content_box, True, True)
self.cute_message_pixbuf = utils.get_common_locale_image_pixbuf("info", "no_download.png")
self.content_box.pack_start(self.cute_message_image, True, True)
self.treeview.draw_mask = self.draw_mask
self.cute_message_image.connect("expose-event", self.expose_cute_message_image)
self.treeview.connect("items-change", self.update_message_bar)
self.treeview.connect("items-change", lambda treeview: global_event.emit("update-install-notify-number", self.get_installing_pkgs_number()))
#self.get_action_item("deepin-webapps-baidu-map")
#self.download_failed("deepin-webapps-baidu-map")
def expose_cute_message_image(self, widget, event):
if self.cute_message_pixbuf:
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()
draw_pixbuf(
cr,
self.cute_message_pixbuf,
rect.x + (rect.width - self.cute_message_pixbuf.get_width()) / 2,
rect.y + (rect.height - self.cute_message_pixbuf.get_height()) / 2,
)
def update_install_status(self):
global_event.emit("update-install-notify-number", self.get_installing_pkgs_number())
self.update_message_bar(self.treeview)
def get_installing_pkgs_number(self):
items = []
for item in self.treeview.visible_items:
if not (item.status == item.STATUS_INSTALL_FINISH or \
item.status == item.STATUS_DOWNLOAD_FAILED):
items.append(item)
return len(items)
def get_installed_pkgs_number(self):
items = []
for item in self.treeview.visible_items:
if item.status == item.STATUS_INSTALL_FINISH:
items.append(item)
return len(items)
def delete_item_match_pkgname(self, pkg_name):
for install_item in self.treeview.visible_items:
if install_item.pkg_name == pkg_name:
self.treeview.delete_items([install_item])
break
def update_message_bar(self, treeview):
if self.get_installing_pkgs_number() == 0:
if self.get_installed_pkgs_number() == 0:
container_remove_all(self.message_box)
children = self.content_box.get_children()
if len(children) == 0 or children[0] == self.treeview:
if self.cute_message_pixbuf == None:
self.cute_message_pixbuf = utils.get_common_locale_image_pixbuf("info", "no_download.png")
container_remove_all(self.content_box)
self.content_box.pack_start(self.cute_message_image, True, True)
self.show_all()
else:
self.message_bar.set_message("")
else:
container_remove_all(self.message_box)
self.message_box.pack_start(self.message_bar, True, True)
self.message_bar.set_message(_("%s applications are being installed") % self.get_installing_pkgs_number())
children = self.content_box.get_children()
if len(children) == 0 or children[0] == self.cute_message_image:
if self.cute_message_pixbuf:
del self.cute_message_pixbuf
self.cute_message_pixbuf = None
container_remove_all(self.content_box)
self.content_box.pack_start(self.treeview, True, True)
self.show_all()
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.
'''
draw_vlinear(cr, x, y, w, h,
[(0, ("#FFFFFF", 0.9)),
(1, ("#FFFFFF", 0.9)),]
)
def update_download_status(self, pkg_infos):
pkg_items = []
for (pkg_name, download_status) in pkg_infos:
pkg_item = None
for item in self.treeview.visible_items:
if item.pkg_name == pkg_name:
pkg_item = item
break
if pkg_item == None:
pkg_item = InstallItem(pkg_name, self.bus_interface.request_pkgs_install_version([pkg_name])[0], self.data_manager)
if download_status == "wait":
pkg_item.download_wait()
elif download_status == "start":
pkg_item.download_start()
elif download_status == "update":
pkg_item.download_update(0, 0)
pkg_items.append(pkg_item)
pkg_items = filter(lambda item: item not in self.treeview.visible_items, pkg_items)
self.treeview.add_items(pkg_items)
def update_action_status(self, pkg_infos):
pkg_items = []
for (pkg_name, action_status) in pkg_infos:
pkg_item = None
for item in self.treeview.visible_items:
if item.pkg_name == pkg_name:
pkg_item = item
break
if pkg_item == None:
pkg_item = InstallItem(pkg_name, self.bus_interface.request_pkgs_install_version([pkg_name])[0], self.data_manager)
if action_status == "wait":
pkg_item.download_finish()
elif action_status == "start":
pkg_item.action_start()
elif action_status == "update":
pkg_item.action_update(0)
pkg_items.append(pkg_item)
pkg_items = filter(lambda item: item not in self.treeview.visible_items, pkg_items)
self.treeview.add_items(pkg_items)
def add_install_actions(self, pkg_names):
for pkg_name in pkg_names:
self.get_action_item(pkg_name)
def get_action_item(self, pkg_name):
action_item = None
for item in self.treeview.visible_items:
if item.pkg_name == pkg_name:
action_item = item
break
if action_item == None:
action_item = InstallItem(pkg_name, self.bus_interface.request_pkgs_install_version([pkg_name])[0], self.data_manager)
self.treeview.add_items([action_item])
return action_item
def download_ready(self, pkg_name):
self.get_action_item(pkg_name).download_ready()
def download_wait(self, pkg_name):
self.get_action_item(pkg_name).download_wait()
def download_start(self, pkg_name):
self.get_action_item(pkg_name).download_start()
def download_update(self, pkg_name, percent, speed):
self.get_action_item(pkg_name).download_update(percent, speed)
def download_finish(self, pkg_name):
self.get_action_item(pkg_name).download_finish()
def download_stop(self, pkg_name):
self.get_action_item(pkg_name).download_stop()
def download_parse_failed(self, pkg_name):
self.get_action_item(pkg_name).download_parse_failed()
def download_failed(self, pkg_name):
self.get_action_item(pkg_name).download_failed()
def action_start(self, pkg_name):
self.get_action_item(pkg_name).action_start()
def action_update(self, pkg_name, percent):
self.get_action_item(pkg_name).action_update(percent)
def action_finish(self, pkg_name, pkg_info_list):
self.get_action_item(pkg_name).action_finish()
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 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 UninstallPage(gtk.VBox):
'''
class docs
'''
def __init__(self, bus_interface, data_manager):
'''
init docs
'''
# Init.
gtk.VBox.__init__(self)
self.bus_interface = bus_interface
self.data_manager = data_manager
self.search_flag = False
self.uninstall_change_items = {"add": [], "delete": []}
self.message_bar = MessageBar(32)
self.message_bar.search_entry.entry.connect("changed", self.search_cb)
self.message_bar.search_button.connect("clicked", self.search_cb)
self.treeview = TreeView(enable_drag_drop=False)
self.treeview.set_expand_column(0)
top_hbox = gtk.HBox()
top_hbox.pack_start(self.message_bar)
self.pack_start(top_hbox, False, False)
self.pack_start(self.treeview, True, True)
self.treeview.connect("items-change", self.update_message_bar)
self.white_kernel_pkg_names = self.get_white_kernel_pkg_names()
self.fetch_uninstall_info()
self.treeview.draw_mask = self.draw_mask
def search_cb(self, widget, event=None):
if not self.search_flag:
self.cache_items = [item for item in self.treeview.visible_items]
results = []
keywords = self.message_bar.search_entry.get_text().strip()
if keywords != "":
self.search_flag = True
# TODO: comment this search_query api, there are many problems for this api
'''
pkg_names = self.data_manager.search_query(map(lambda word: word.encode("utf8"), keywords.split(" ")))
for item in self.cache_items:
if item.pkg_name in pkg_names:
results.append(item)
'''
for item in self.cache_items:
if keywords in item.pkg_name:
results.append(item)
self.treeview.clear()
self.treeview.add_items(results)
else:
self.treeview.clear()
self.search_flag = False
# for add items
if self.uninstall_change_items["add"] != []:
for item in self.uninstall_change_items["add"]:
self.cache_items.append(item)
self.uninstall_change_items["add"] = []
# for delete items
if self.uninstall_change_items["delete"] != []:
for item in self.uninstall_change_items["delete"]:
if item in self.cache_items:
self.cache_items.remove(item)
self.uninstall_change_items["delete"] = []
self.treeview.add_items(self.cache_items)
def normal_search_cb(self, keywords):
pass
def update_message_bar(self, treeview):
self.message_bar.set_message(_("%s applications can be uninstalled") % len(treeview.visible_items))
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.
'''
draw_vlinear(cr, x, y, w, h,
[(0, ("#FFFFFF", 0.9)),
(1, ("#FFFFFF", 0.9)),]
)
def update_action_status(self, pkg_infos):
pkg_items = []
for (pkg_name, action_status) in pkg_infos:
pkg_item = None
for item in self.treeview.visible_items:
if item.pkg_name == pkg_name:
pkg_item = item
break
if pkg_item == None:
pkg_item = UninstallItem(pkg_name, self.bus_interface.request_pkgs_uninstall_version([pkg_name])[0], self.data_manager)
if action_status == "wait":
pkg_item.action_wait()
elif action_status == "start":
pkg_item.action_start()
elif action_status == "update":
pkg_item.action_update(0)
pkg_items.append(pkg_item)
pkg_items = filter(lambda item: item not in self.treeview.visible_items, pkg_items)
self.treeview.add_items(pkg_items)
def fetch_uninstall_info(self):
self.bus_interface.request_uninstall_pkgs(
reply_handler=lambda r:self.add_uninstall_items(r, True),
error_handler=lambda e:self.add_uninstall_items(e, False)
)
def get_white_kernel_pkg_names(self):
version = commands.getoutput("uname -r").split("-generic")[0]
white_pkg_names = ["linux-image-generic", "linux-headers-generic"]
white_pkg_names.append("linux-image-%s-generic" % version)
white_pkg_names.append("linux-image-extra-%s-generic" % version)
white_pkg_names.append("linux-headers-%s-generic" % version)
white_pkg_names.append("linux-headers-%s" % version)
return white_pkg_names
def is_uninstallable_kernel(self, pkg_name):
if pkg_name.startswith("linux-image") or pkg_name.startswith("linux-headers"):
return pkg_name not in self.white_kernel_pkg_names
def add_uninstall_items(self, data, success):
if not success:
global_logger.logerror("request_uninstall_pkgs failed: %s" % data)
return
pkg_infos = str(data)
items = []
try:
uninstall_pkg_infos = json.loads(pkg_infos)
for pkg_info in uninstall_pkg_infos:
pkg_name, pkg_version = pkg_info
if self.is_uninstallable_kernel(pkg_name) or \
self.data_manager.is_pkg_display_in_uninstall_page(pkg_name):
items.append(UninstallItem(pkg_name, pkg_version, self.data_manager))
except Exception, e:
global_logger.logerror("Parse uninstall package information failed: %s" % pkg_infos)
global_logger.logerror("Error: %s" % str(e))
if self.search_flag:
self.uninstall_change_items["add"] += items
else:
self.treeview.add_items(items)
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 Section(gtk.VBox):
# Section prototype
def __init__(self):
gtk.VBox.__init__(self)
self.timer = Timer(200, self.action_after_toggle)
def load(self, toggle, content=[]):
self.toggle = toggle
self.content_box = gtk.VBox(spacing=0)
self.pack_start(self.toggle, False, False)
self.toggle.switch.connect("toggled", self.toggle_callback)
self.tree = TreeView([])
self.tree.set_expand_column(1)
self.tree.draw_mask = self.draw_mask
content.insert(0, self.tree)
for c in content:
self.content_box.pack_start(c, False, False)
self.align = self._set_align()
self.pack_start(self.align, False, False)
self.show_all()
def init_state(self):
pass
def set_active(self, state):
self.toggle.set_active(state)
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 _set_align(self):
align = gtk.Alignment(0,0,1,0)
align.set_padding(0, 0, PADDING, 11 + 11)
return align
def toggle_callback(self, widget):
if self.timer.alive():
self.timer.restart()
else:
self.timer.start()
def action_after_toggle(self):
is_active = self.toggle.get_active()
if is_active:
if self.content_box not in self.align.get_children():
self.align.add(self.content_box)
self.show_all()
self.td = ToggleThread(self.get_list, self.tree, self.toggle_on_after)
self.td.start()
else:
self.align.remove(self.content_box)
self.td.stop_run()
self.toggle_off()
def toggle_on(self):
'''
method cb when toggle on
'''
pass
def toggle_on_after(self):
pass
def toggle_off(self):
pass
def get_list(self):
pass
def section_show(self):
self.set_no_show_all(False)
self.show_all()
def section_hide(self):
self.set_no_show_all(True)
self.hide()
def space_box(self):
space = gtk.VBox()
space.set_size_request(-1, 15)
return space
class WirelessSection(Section, WirelessDevice):
def __init__(self):
Section.__init__(self)
WirelessDevice.__init__(self)
self.wireless = Contain(app_theme.get_pixbuf("network/wifi.png"), _("Wireless"), lambda w:w)
self.label = Label(_("Set up a hidden wireless connection"),
LABEL_COLOR,
underline=True,
enable_select=False,
enable_double_click=False)
space = gtk.VBox()
space.set_size_request(-1, 15)
self.load(self.wireless, [space, self.label])
self.content_box.set_spacing(0)
self.selected_item = None
self.device_tree = None
self.focused_device = None
self.wireless_devices = None
def add_switcher(self):
if self.device_tree == None:
self.device_tree = TreeView([DeviceToggleItem(self.wireless_devices, 0)])
self.device_tree.set_expand_column(1)
self.content_box.pack_start(self.device_tree, False, True)
self.content_box.reorder_child(self.device_tree, 0)
net_manager.emit_wifi_switch(0)
def remove_switcher(self):
if self.device_tree\
and self.device_tree in self.content_box.get_children():
self.content_box.remove(self.device_tree)
self.device_tree = None
try:
self.focused_device = self.wireless_devices[0]
except:
log.error("get no wireless devices but try to index")
self.focused_device = None
self.wireless_redraw(None)
@classmethod
def show_or_hide(self):
if net_manager.device_manager.get_wireless_devices():
self.wireless_devices = net_manager.device_manager.get_wireless_devices()
return True
else:
self.wireless_devices = []
return False
def init_state(self):
self.ap_list = []
self.wireless_devices = net_manager.device_manager.get_wireless_devices()
if self.wireless_devices:
#self.device_dict = dict()
self.focused_device = self.wireless_devices[0]
if len(self.wireless_devices) > 1:
self.add_switcher()
self.tree.connect("single-click-item", self.set_selected_item)
## check state
if self.get_state(self.wireless_devices):
self.wireless.set_active(True)
else:
pass
self.init_signals()
def init_signals(self):
self._init_signals()
Dispatcher.connect("switch-device", self.switch_devices)
Dispatcher.connect("wireless-device-add", self.device_added)
Dispatcher.connect("ap-added", self.ap_added_callback)
Dispatcher.connect("ap-removed", self.ap_removed_callback)
Dispatcher.connect("wireless-redraw", self.wireless_redraw)
self.label.connect("button-release-event", self.create_a_hidden_network)
event_manager.add_callback('hidden-connection-removed', self.on_delete_redraw)
def switch_devices(self, widget, device):
self.focused_device = device
if self.device_tree:
self.device_tree.visible_items[0].set_index(device)
self.wireless_redraw(None)
def on_delete_redraw(self, name, event, data):
self.wireless_redraw(None)
def wireless_redraw(self, widget):
log.debug()
if self.wireless.get_active():
self.wireless.set_active(True, emit=True)
self.show_all()
def device_added(self, widget, device):
self.wireless_devices = net_manager.device_manager.get_wireless_devices()
self._init_signals()
if len(self.wireless_devices) > 1:
self.add_switcher()
else:
self.remove_switcher()
if self.wireless.get_active():
self.wireless.set_active(True, emit=True)
def create_a_hidden_network(self, widget, c):
from wlan_config import HiddenSetting
Dispatcher.to_setting_page(HiddenSetting(None), False)
def ap_added_callback(self, widget):
if self.wireless.get_active():
self.wireless.set_active(True, emit=True)
def ap_removed_callback(self, widget):
if self.wireless.get_active():
self.wireless.set_active(True, emit=True)
def set_selected_item(self, widget, item, column, x, y):
log.debug(item)
self.selected_item = item
def get_actives(self, ap_list):
def to_item_state(device):
if device.get_state() <= 30:
return 0
elif device.get_state() < 100:
return 1
elif device.get_state() == 100:
return 2
if not ap_list:
return []
index = []
active_connection = self.focused_device.get_active_connection()
if active_connection:
try:
ssid = active_connection.get_connection().get_setting("802-11-wireless").ssid
index.append([[ap.get_ssid() for ap in ap_list].index(ssid), to_item_state(self.focused_device)])
except ValueError:
print "not found in ap list"
return index
def _get_active_item(self):
return filter(lambda i: i.get_net_state() > 0, self.tree.visible_items)
def toggle_on_after(self):
log.debug()
indexs = self.get_actives(self.ap_list)
if indexs:
map(lambda (i, s): self.tree.visible_items[i].set_net_state(s), indexs)
else:
for d in self.wireless_devices:
log.debug("try auto start")
wifi = nm_module.cache.get_spec_object(d.object_path)
wifi.auto_connect()
def toggle_off(self):
log.debug()
self.ap_list = []
self.selected_item = None
for wireless_device in self.wireless_devices:
wireless_device.nm_device_disconnect()
def get_list(self):
self.ap_list = list()
if not self.wireless_devices:
return []
device_wifi = nm_module.cache.get_spec_object(self.focused_device.object_path)
self.ap_list += device_wifi.order_ap_list()
aps = map(lambda i:WirelessItem(i, self.focused_device), self.ap_list)
hidden_list = self.get_hidden_connection()
hiddens = map(lambda c: HidenItem(c), hidden_list)
return aps + hiddens
def __ap_list_merge(self):
ap_ssid = set(map(lambda ap: ap.get_ssid(), self.ap_list))
merged_ap = []
for ap in self.ap_list:
if ap.get_ssid() in ap_ssid:
merged_ap.append(ap)
ap_ssid.remove(ap.get_ssid())
return merged_ap
def get_hidden_connection(self):
from shared_methods import net_manager
return net_manager.get_hiddens()
## need to filter all aps
def get_state(self, devices):
for d in devices:
if d.get_state() == 100:
return True
return False
def device_stop(self, device):
device.nm_device_disconnect()
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:
application.set_skin_preview(os.path.join(get_current_dir(__file__), "frame.png"))
# Add titlebar.
application.add_titlebar(
["theme", "max", "min", "close"],
os.path.join(get_current_dir(__file__), "logo.png"),
"TreeView demo",
"TreeView demo",
)
# Add TreeView.
print os.path.expanduser("~")
treeview = TreeView(get_dir_items(os.path.expanduser("~")))
# expand column.
treeview.set_expand_column(3)
# hide column
treeview.set_hide_columns([1, 2])
#treeview.set_highlight_item(treeview.get_items()[35])
treeview.connect("delete-select-items", m_delete_select_items)
treeview.connect("button-press-item", m_button_press_item)
treeview.connect("double-click-item", m_double_click_item)
treeview.connect("right-press-items", m_right_press_items)
treeview.connect("single-click-item", m_single_click_item)
# treeview = TreeView(get_dir_items("/"))
treeview_align = gtk.Alignment()
treeview_align.set(0.5, 0.5, 1, 1)
treeview_align.set_padding(0, 2, 2, 2)
os.path.join(get_current_dir(__file__), "frame.png"))
# Add titlebar.
application.add_titlebar(
["theme", "max", "min", "close"],
os.path.join(get_current_dir(__file__), "logo.png"),
"TreeView demo",
"TreeView demo",
)
# Add TreeView.
print os.path.expanduser("~")
treeview = TreeView(get_dir_items(os.path.expanduser("~")))
# expand column.
treeview.set_expand_column(3)
# hide column
treeview.set_hide_columns([1, 2])
#treeview.set_highlight_item(treeview.get_items()[35])
treeview.connect("delete-select-items", m_delete_select_items)
treeview.connect("button-press-item", m_button_press_item)
treeview.connect("double-click-item", m_double_click_item)
treeview.connect("right-press-items", m_right_press_items)
treeview.connect("single-click-item", m_single_click_item)
# treeview = TreeView(get_dir_items("/"))
treeview_align = gtk.Alignment()
treeview_align.set(0.5, 0.5, 1, 1)
treeview_align.set_padding(0, 2, 2, 2)
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 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 UninstallPage(gtk.VBox):
'''
class docs
'''
def __init__(self, bus_interface, data_manager):
'''
init docs
'''
# Init.
gtk.VBox.__init__(self)
self.bus_interface = bus_interface
self.data_manager = data_manager
self.search_flag = False
self.uninstall_change_items = {"add": [], "delete": []}
### init UI widgets
self.message_bar = MessageBar(32)
self.message_bar.search_entry.entry.connect("changed", self.search_cb)
self.message_bar.search_button.connect("clicked", self.search_cb)
self.top_hbox = gtk.HBox()
self.top_hbox.pack_start(self.message_bar)
self.treeview = TreeView(enable_drag_drop=False)
self.treeview.set_expand_column(0)
self.treeview.connect("items-change", self.update_message_bar)
self.loading_box = LoadingBox()
self.loading_box_align = create_align((0.5, 0.5, 1, 1),
(10, 10, 10, 10))
self.loading_box_align.add(self.loading_box)
### init UI widgets
self.white_kernel_pkg_names = self.get_white_kernel_pkg_names()
global_event.register_event("uninstall-items-filtered",
self.load_uninstall_items)
self.show_loading_page()
self.fetch_uninstall_info()
self.treeview.draw_mask = self.draw_mask
def show_loading_page(self):
container_remove_all(self)
self.pack_start(self.loading_box_align, True, True)
def show_uninstall_page(self):
container_remove_all(self)
self.pack_start(self.top_hbox, False, False)
self.pack_start(self.treeview, True, True)
def search_cb(self, widget, event=None):
if not self.search_flag:
self.cache_items = [item for item in self.treeview.visible_items]
results = []
keywords = self.message_bar.search_entry.get_text().strip()
if keywords != "":
self.search_flag = True
# TODO: comment this search_query api, there are many problems for this api
'''
pkg_names = self.data_manager.search_query(map(lambda word: word.encode("utf8"), keywords.split(" ")))
for item in self.cache_items:
if item.pkg_name in pkg_names:
results.append(item)
'''
for item in self.cache_items:
if keywords in item.pkg_name:
results.append(item)
self.treeview.clear()
self.treeview.add_items(results)
else:
self.treeview.clear()
self.search_flag = False
# for add items
if self.uninstall_change_items["add"] != []:
for item in self.uninstall_change_items["add"]:
self.cache_items.append(item)
self.uninstall_change_items["add"] = []
# for delete items
if self.uninstall_change_items["delete"] != []:
for item in self.uninstall_change_items["delete"]:
if item in self.cache_items:
self.cache_items.remove(item)
self.uninstall_change_items["delete"] = []
self.treeview.add_items(self.cache_items)
def normal_search_cb(self, keywords):
pass
def update_message_bar(self, treeview):
self.message_bar.set_message(
_("%s applications can be uninstalled") %
len(treeview.visible_items))
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.
'''
draw_vlinear(cr, x, y, w, h, [
(0, ("#FFFFFF", 0.9)),
(1, ("#FFFFFF", 0.9)),
])
def update_action_status(self, pkg_infos):
pkg_items = []
for (pkg_name, action_status) in pkg_infos:
pkg_item = None
for item in self.treeview.visible_items:
if item.pkg_name == pkg_name:
pkg_item = item
break
if pkg_item == None:
pkg_item = UninstallItem(
pkg_name,
self.bus_interface.request_pkgs_uninstall_version(
[pkg_name])[0], self.data_manager)
if action_status == "wait":
pkg_item.action_wait()
elif action_status == "start":
pkg_item.action_start()
elif action_status == "update":
pkg_item.action_update(0)
pkg_items.append(pkg_item)
pkg_items = filter(
lambda item: item not in self.treeview.visible_items, pkg_items)
self.treeview.add_items(pkg_items)
def fetch_uninstall_info(self):
self.bus_interface.request_uninstall_pkgs(
reply_handler=lambda r: self.add_uninstall_items(r, True),
error_handler=lambda e: self.add_uninstall_items(e, False))
def get_white_kernel_pkg_names(self):
version = commands.getoutput("uname -r").split("-generic")[0]
white_pkg_names = ["linux-image-generic", "linux-headers-generic"]
white_pkg_names.append("linux-image-%s-generic" % version)
white_pkg_names.append("linux-image-extra-%s-generic" % version)
white_pkg_names.append("linux-headers-%s-generic" % version)
white_pkg_names.append("linux-headers-%s" % version)
return white_pkg_names
def is_uninstallable_kernel(self, pkg_name):
if pkg_name.startswith("linux-image") or pkg_name.startswith(
"linux-headers"):
return pkg_name not in self.white_kernel_pkg_names
def add_uninstall_items(self, data, success):
if not success:
global_logger.error("request_uninstall_pkgs failed: %s" % data)
return
pkg_infos = str(data)
try:
uninstall_pkg_infos = json.loads(pkg_infos)
except Exception, e:
global_logger.error(
"Parse uninstall package information failed: %s" % pkg_infos)
global_logger.error("Error: %s" % str(e))
uninstall_pkg_infos = []
ThreadMethod(self.filter_uninstall_pkg_infos,
(uninstall_pkg_infos, )).start()
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 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 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 WirelessSection(Section, WirelessDevice):
def __init__(self):
Section.__init__(self)
WirelessDevice.__init__(self)
self.wireless = Contain(app_theme.get_pixbuf("network/wifi.png"),
_("Wireless"), lambda w: w)
self.label = Label(_("Set up a hidden wireless connection"),
LABEL_COLOR,
underline=True,
enable_select=False,
enable_double_click=False)
space = gtk.VBox()
space.set_size_request(-1, 15)
self.load(self.wireless, [space, self.label])
self.content_box.set_spacing(0)
self.selected_item = None
self.device_tree = None
self.focused_device = None
self.wireless_devices = None
def add_switcher(self):
if self.device_tree == None:
self.device_tree = TreeView(
[DeviceToggleItem(self.wireless_devices, 0)])
self.device_tree.set_expand_column(1)
self.content_box.pack_start(self.device_tree, False, True)
self.content_box.reorder_child(self.device_tree, 0)
net_manager.emit_wifi_switch(0)
def remove_switcher(self):
if self.device_tree\
and self.device_tree in self.content_box.get_children():
self.content_box.remove(self.device_tree)
self.device_tree = None
try:
self.focused_device = self.wireless_devices[0]
except:
log.error("get no wireless devices but try to index")
self.focused_device = None
self.wireless_redraw(None)
@classmethod
def show_or_hide(self):
if net_manager.device_manager.get_wireless_devices():
self.wireless_devices = net_manager.device_manager.get_wireless_devices(
)
return True
else:
self.wireless_devices = []
return False
def init_state(self):
self.ap_list = []
self.wireless_devices = net_manager.device_manager.get_wireless_devices(
)
if self.wireless_devices:
#self.device_dict = dict()
self.focused_device = self.wireless_devices[0]
if len(self.wireless_devices) > 1:
self.add_switcher()
self.tree.connect("single-click-item", self.set_selected_item)
## check state
if self.get_state(self.wireless_devices):
self.wireless.set_active(True)
else:
pass
self.init_signals()
def init_signals(self):
self._init_signals()
Dispatcher.connect("switch-device", self.switch_devices)
Dispatcher.connect("wireless-device-add", self.device_added)
Dispatcher.connect("ap-added", self.ap_added_callback)
Dispatcher.connect("ap-removed", self.ap_removed_callback)
Dispatcher.connect("wireless-redraw", self.wireless_redraw)
self.label.connect("button-release-event",
self.create_a_hidden_network)
event_manager.add_callback('hidden-connection-removed',
self.on_delete_redraw)
def switch_devices(self, widget, device):
self.focused_device = device
if self.device_tree:
self.device_tree.visible_items[0].set_index(device)
self.wireless_redraw(None)
def on_delete_redraw(self, name, event, data):
self.wireless_redraw(None)
def wireless_redraw(self, widget):
log.debug()
if self.wireless.get_active():
self.wireless.set_active(True, emit=True)
self.show_all()
def device_added(self, widget, device):
self.wireless_devices = net_manager.device_manager.get_wireless_devices(
)
self._init_signals()
if len(self.wireless_devices) > 1:
self.add_switcher()
else:
self.remove_switcher()
if self.wireless.get_active():
self.wireless.set_active(True, emit=True)
def create_a_hidden_network(self, widget, c):
from wlan_config import HiddenSetting
Dispatcher.to_setting_page(HiddenSetting(None), False)
def ap_added_callback(self, widget):
if self.wireless.get_active():
self.wireless.set_active(True, emit=True)
def ap_removed_callback(self, widget):
if self.wireless.get_active():
self.wireless.set_active(True, emit=True)
def set_selected_item(self, widget, item, column, x, y):
log.debug(item)
self.selected_item = item
def get_actives(self, ap_list):
def to_item_state(device):
if device.get_state() <= 30:
return 0
elif device.get_state() < 100:
return 1
elif device.get_state() == 100:
return 2
if not ap_list:
return []
index = []
active_connection = self.focused_device.get_active_connection()
if active_connection:
try:
ssid = active_connection.get_connection().get_setting(
"802-11-wireless").ssid
index.append([[ap.get_ssid() for ap in ap_list].index(ssid),
to_item_state(self.focused_device)])
except ValueError:
print "not found in ap list"
return index
def _get_active_item(self):
return filter(lambda i: i.get_net_state() > 0, self.tree.visible_items)
def toggle_on_after(self):
log.debug()
indexs = self.get_actives(self.ap_list)
if indexs:
map(lambda (i, s): self.tree.visible_items[i].set_net_state(s),
indexs)
else:
for d in self.wireless_devices:
log.debug("try auto start")
wifi = nm_module.cache.get_spec_object(d.object_path)
wifi.auto_connect()
def toggle_off(self):
log.debug()
self.ap_list = []
self.selected_item = None
for wireless_device in self.wireless_devices:
wireless_device.nm_device_disconnect()
def get_list(self):
self.ap_list = list()
if not self.wireless_devices:
return []
device_wifi = nm_module.cache.get_spec_object(
self.focused_device.object_path)
self.ap_list += device_wifi.order_ap_list()
aps = map(lambda i: WirelessItem(i, self.focused_device), self.ap_list)
hidden_list = self.get_hidden_connection()
hiddens = map(lambda c: HidenItem(c), hidden_list)
return aps + hiddens
def __ap_list_merge(self):
ap_ssid = set(map(lambda ap: ap.get_ssid(), self.ap_list))
merged_ap = []
for ap in self.ap_list:
if ap.get_ssid() in ap_ssid:
merged_ap.append(ap)
ap_ssid.remove(ap.get_ssid())
return merged_ap
def get_hidden_connection(self):
from shared_methods import net_manager
return net_manager.get_hiddens()
## need to filter all aps
def get_state(self, devices):
for d in devices:
if d.get_state() == 100:
return True
return False
def device_stop(self, device):
device.nm_device_disconnect()
class InstallPage(gtk.VBox):
'''
class docs
'''
def __init__(self, bus_interface, data_manager):
'''
init docs
'''
# Init.
gtk.VBox.__init__(self)
self.bus_interface = bus_interface
self.data_manager = data_manager
self.message_bar = MessageBar(32)
self.message_box = gtk.HBox()
self.treeview = TreeView(enable_drag_drop=False)
self.treeview.set_expand_column(0)
self.cute_message_image = gtk.VBox()
self.content_box = gtk.VBox()
self.pack_start(self.message_box, False, False)
self.pack_start(self.content_box, True, True)
self.cute_message_pixbuf = utils.get_common_locale_image_pixbuf(
"info", "no_download.png")
self.content_box.pack_start(self.cute_message_image, True, True)
self.treeview.draw_mask = self.draw_mask
self.cute_message_image.connect("expose-event",
self.expose_cute_message_image)
self.treeview.connect("items-change", self.update_message_bar)
self.treeview.connect(
"items-change", lambda treeview: global_event.emit(
"update-install-notify-number",
self.get_installing_pkgs_number()))
#self.get_action_item("deepin-webapps-baidu-map")
#self.download_failed("deepin-webapps-baidu-map")
def expose_cute_message_image(self, widget, event):
if self.cute_message_pixbuf:
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()
draw_pixbuf(
cr,
self.cute_message_pixbuf,
rect.x +
(rect.width - self.cute_message_pixbuf.get_width()) / 2,
rect.y +
(rect.height - self.cute_message_pixbuf.get_height()) / 2,
)
def update_install_status(self):
global_event.emit("update-install-notify-number",
self.get_installing_pkgs_number())
self.update_message_bar(self.treeview)
def get_installing_pkgs_number(self):
items = []
for item in self.treeview.visible_items:
if not (item.status == item.STATUS_INSTALL_FINISH or \
item.status == item.STATUS_DOWNLOAD_FAILED):
items.append(item)
return len(items)
def get_installed_pkgs_number(self):
items = []
for item in self.treeview.visible_items:
if item.status == item.STATUS_INSTALL_FINISH:
items.append(item)
return len(items)
def delete_item_match_pkgname(self, pkg_name):
for install_item in self.treeview.visible_items:
if install_item.pkg_name == pkg_name:
self.treeview.delete_items([install_item])
break
def update_message_bar(self, treeview):
if self.get_installing_pkgs_number() == 0:
if self.get_installed_pkgs_number() == 0:
container_remove_all(self.message_box)
children = self.content_box.get_children()
if len(children) == 0 or children[0] == self.treeview:
if self.cute_message_pixbuf == None:
self.cute_message_pixbuf = utils.get_common_locale_image_pixbuf(
"info", "no_download.png")
container_remove_all(self.content_box)
self.content_box.pack_start(self.cute_message_image, True,
True)
self.show_all()
else:
self.message_bar.set_message("")
else:
container_remove_all(self.message_box)
self.message_box.pack_start(self.message_bar, True, True)
self.message_bar.set_message(
_("%s applications are being installed") %
self.get_installing_pkgs_number())
children = self.content_box.get_children()
if len(children) == 0 or children[0] == self.cute_message_image:
if self.cute_message_pixbuf:
del self.cute_message_pixbuf
self.cute_message_pixbuf = None
container_remove_all(self.content_box)
self.content_box.pack_start(self.treeview, True, True)
self.show_all()
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.
'''
draw_vlinear(cr, x, y, w, h, [
(0, ("#FFFFFF", 0.9)),
(1, ("#FFFFFF", 0.9)),
])
def update_download_status(self, pkg_infos):
pkg_items = []
for (pkg_name, download_status) in pkg_infos:
pkg_item = None
for item in self.treeview.visible_items:
if item.pkg_name == pkg_name:
pkg_item = item
break
if pkg_item == None:
pkg_item = InstallItem(
pkg_name,
self.bus_interface.request_pkgs_install_version([pkg_name
])[0],
self.data_manager)
if download_status == "wait":
pkg_item.download_wait()
elif download_status == "start":
pkg_item.download_start()
elif download_status == "update":
pkg_item.download_update(0, 0)
pkg_items.append(pkg_item)
pkg_items = filter(
lambda item: item not in self.treeview.visible_items, pkg_items)
self.treeview.add_items(pkg_items)
def update_action_status(self, pkg_infos):
pkg_items = []
for (pkg_name, action_status) in pkg_infos:
pkg_item = None
for item in self.treeview.visible_items:
if item.pkg_name == pkg_name:
pkg_item = item
break
if pkg_item == None:
pkg_item = InstallItem(
pkg_name,
self.bus_interface.request_pkgs_install_version([pkg_name
])[0],
self.data_manager)
if action_status == "wait":
pkg_item.download_finish()
elif action_status == "start":
pkg_item.action_start()
elif action_status == "update":
pkg_item.action_update(0)
pkg_items.append(pkg_item)
pkg_items = filter(
lambda item: item not in self.treeview.visible_items, pkg_items)
self.treeview.add_items(pkg_items)
def add_install_actions(self, pkg_names):
for pkg_name in pkg_names:
self.get_action_item(pkg_name)
def get_action_item(self, pkg_name):
action_item = None
for item in self.treeview.visible_items:
if item.pkg_name == pkg_name:
action_item = item
break
if action_item == None:
action_item = InstallItem(
pkg_name,
self.bus_interface.request_pkgs_install_version([pkg_name])[0],
self.data_manager)
self.treeview.add_items([action_item])
return action_item
def download_ready(self, pkg_name):
self.get_action_item(pkg_name).download_ready()
def download_wait(self, pkg_name):
self.get_action_item(pkg_name).download_wait()
def download_start(self, pkg_name):
self.get_action_item(pkg_name).download_start()
def download_update(self, pkg_name, percent, speed):
self.get_action_item(pkg_name).download_update(percent, speed)
def download_finish(self, pkg_name):
self.get_action_item(pkg_name).download_finish()
def download_stop(self, pkg_name):
self.get_action_item(pkg_name).download_stop()
def download_parse_failed(self, pkg_name):
self.get_action_item(pkg_name).download_parse_failed()
def download_failed(self, pkg_name):
self.get_action_item(pkg_name).download_failed()
def action_start(self, pkg_name):
self.get_action_item(pkg_name).action_start()
def action_update(self, pkg_name, percent):
self.get_action_item(pkg_name).action_update(percent)
def action_finish(self, pkg_name, pkg_info_list):
self.get_action_item(pkg_name).action_finish()
class Section(gtk.VBox):
# Section prototype
def __init__(self):
gtk.VBox.__init__(self)
self.timer = Timer(200, self.action_after_toggle)
def load(self, toggle, content=[]):
self.toggle = toggle
self.content_box = gtk.VBox(spacing=0)
self.pack_start(self.toggle, False, False)
self.toggle.switch.connect("toggled", self.toggle_callback)
self.tree = TreeView([])
self.tree.set_expand_column(1)
self.tree.draw_mask = self.draw_mask
content.insert(0, self.tree)
for c in content:
self.content_box.pack_start(c, False, False)
self.align = self._set_align()
self.pack_start(self.align, False, False)
self.show_all()
def init_state(self):
pass
def set_active(self, state):
self.toggle.set_active(state)
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 _set_align(self):
align = gtk.Alignment(0, 0, 1, 0)
align.set_padding(0, 0, PADDING, 11 + 11)
return align
def toggle_callback(self, widget):
if self.timer.alive():
self.timer.restart()
else:
self.timer.start()
def action_after_toggle(self):
is_active = self.toggle.get_active()
if is_active:
if self.content_box not in self.align.get_children():
self.align.add(self.content_box)
self.show_all()
self.td = ToggleThread(self.get_list, self.tree,
self.toggle_on_after)
self.td.start()
else:
self.align.remove(self.content_box)
self.td.stop_run()
self.toggle_off()
def toggle_on(self):
'''
method cb when toggle on
'''
pass
def toggle_on_after(self):
pass
def toggle_off(self):
pass
def get_list(self):
pass
def section_show(self):
self.set_no_show_all(False)
self.show_all()
def section_hide(self):
self.set_no_show_all(True)
self.hide()
def space_box(self):
space = gtk.VBox()
space.set_size_request(-1, 15)
return space
class UninstallPage(gtk.VBox):
'''
class docs
'''
def __init__(self, bus_interface, data_manager):
'''
init docs
'''
# Init.
gtk.VBox.__init__(self)
self.bus_interface = bus_interface
self.data_manager = data_manager
self.search_flag = False
self.uninstall_change_items = {"add": [], "delete": []}
self.message_bar = MessageBar(32)
self.message_bar.search_entry.entry.connect("changed", self.search_cb)
self.message_bar.search_button.connect("clicked", self.search_cb)
self.treeview = TreeView(enable_drag_drop=False)
self.treeview.set_expand_column(0)
top_hbox = gtk.HBox()
top_hbox.pack_start(self.message_bar)
self.pack_start(top_hbox, False, False)
self.pack_start(self.treeview, True, True)
self.treeview.connect("items-change", self.update_message_bar)
self.fetch_uninstall_info()
self.treeview.draw_mask = self.draw_mask
def search_cb(self, widget, event=None):
if not self.search_flag:
self.cache_items = [item for item in self.treeview.visible_items]
results = []
keywords = self.message_bar.search_entry.get_text().strip()
if keywords != "":
self.search_flag = True
# TODO: comment this search_query api, there are many problems for this api
'''
pkg_names = self.data_manager.search_query(map(lambda word: word.encode("utf8"), keywords.split(" ")))
for item in self.cache_items:
if item.pkg_name in pkg_names:
results.append(item)
'''
for item in self.cache_items:
if keywords in item.pkg_name:
results.append(item)
self.treeview.clear()
self.treeview.add_items(results)
else:
self.treeview.clear()
self.search_flag = False
# for add items
if self.uninstall_change_items["add"] != []:
for item in self.uninstall_change_items["add"]:
self.cache_items.append(item)
self.uninstall_change_items["add"] = []
# for delete items
if self.uninstall_change_items["delete"] != []:
for item in self.uninstall_change_items["delete"]:
if item in self.cache_items:
self.cache_items.remove(item)
self.uninstall_change_items["delete"] = []
self.treeview.add_items(self.cache_items)
def normal_search_cb(self, keywords):
pass
def update_message_bar(self, treeview):
self.message_bar.set_message(_("%s applications can be uninstalled") % len(treeview.visible_items))
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.
'''
draw_vlinear(cr, x, y, w, h,
[(0, ("#FFFFFF", 0.9)),
(1, ("#FFFFFF", 0.9)),]
)
def update_action_status(self, pkg_infos):
pkg_items = []
for (pkg_name, action_status) in pkg_infos:
pkg_item = None
for item in self.treeview.visible_items:
if item.pkg_name == pkg_name:
pkg_item = item
break
if pkg_item == None:
pkg_item = UninstallItem(pkg_name, self.bus_interface.request_pkgs_uninstall_version([pkg_name])[0], self.data_manager)
if action_status == "wait":
pkg_item.action_wait()
elif action_status == "start":
pkg_item.action_start()
elif action_status == "update":
pkg_item.action_update(0)
pkg_items.append(pkg_item)
pkg_items = filter(lambda item: item not in self.treeview.visible_items, pkg_items)
self.treeview.add_items(pkg_items)
def fetch_uninstall_info(self):
self.bus_interface.request_uninstall_pkgs(
reply_handler=self.render_uninstall_info,
error_handler=lambda e:handle_dbus_error("request_uninstall_pkgs", e))
def render_uninstall_info(self, pkg_infos):
self.add_uninstall_items(pkg_infos)
def add_uninstall_items(self, pkg_infos):
items = []
for pkg_info in pkg_infos:
(pkg_name, pkg_version) = eval(pkg_info)
if self.data_manager.is_pkg_have_desktop_file(pkg_name) != None \
and self.data_manager.is_pkg_display_in_uninstall_page(pkg_name)[0] == '1':
items.append(UninstallItem(pkg_name, pkg_version, self.data_manager))
if self.search_flag:
self.uninstall_change_items["add"] += items
else:
self.treeview.add_items(items)
def delete_uninstall_items(self, items):
if self.search_flag:
self.uninstall_change_items["delete"] += items
for item in items:
if item in self.treeview.visible_items:
self.treeview.delete_items([item])
else:
self.treeview.delete_items(items)
def action_start(self, pkg_name):
for item in self.treeview.visible_items:
if item.pkg_name == pkg_name:
item.action_start()
break
def action_update(self, pkg_name, percent):
for item in self.treeview.visible_items:
if item.pkg_name == pkg_name:
item.action_update(percent)
break
def action_finish(self, pkg_name, pkg_info_list):
for item in self.treeview.visible_items:
if item.pkg_name == pkg_name:
item.action_finish()
break
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)
