def __init__(self, default_width=300, default_height=160, cancel_cb=None):
DialogBox.__init__(self, "", default_width, default_height, self.DIALOG_MASK_SINGLE_PAGE)
self.cancel_cb = cancel_cb
self.message_align = gtk.Alignment()
self.message_align.set(0, 0, 0, 0)
self.message_align.set_padding(0, 0, 10, 0)
self.message_label = Label("", label_width=300)
self.message_align.add(self.message_label)
self.progress_align = gtk.Alignment()
self.progress_align.set(0, 0, 0, 0)
self.progress_align.set_padding(20, 0, 10, 10)
self.progress_bar = ProgressBar()
self.progress_bar.set_size_request(default_width, -1)
self.progress_align.add(self.progress_bar)
self.percentage_align = gtk.Alignment()
self.percentage_align.set(0, 0, 0, 0)
self.percentage_align.set_padding(10, 0, 140, 0)
self.percentage_label = Label("0%", label_width=300)
self.percentage_label.set_size_request(default_width, -1)
self.percentage_align.add(self.percentage_label)
self.cancel_align = gtk.Alignment()
self.cancel_align.set(0, 0, 0, 0)
self.cancel_align.set_padding(20, 0, 200, 0)
self.cancel_button = Button(_("Cancel"))
self.cancel_button.set_size_request(70, WIDGET_HEIGHT)
self.cancel_button.connect("clicked", self.__on_cancel_button_clicked)
self.cancel_align.add(self.cancel_button)
self.body_box.pack_start(self.message_align, False, False)
self.body_box.pack_start(self.progress_align, False, False)
self.body_box.pack_start(self.percentage_align, False, False)
self.body_box.pack_start(self.cancel_align)
def __init_widgets(self):
self.start_record_button = Button(_("Start"))
self.start_record_button.set_size_request(CAMERA_BOX_SIZE, 25)
self.start_record_button.connect("clicked",
self.__start_record_clicked)
self.no_device_warning = Label(
_("Please plug in or enable your camera"),
label_width=300,
text_x_align=pango.ALIGN_CENTER)
self.keep_few_minutes = Label(_("Please keep still for 5 seconds"),
label_width=300,
text_x_align=pango.ALIGN_CENTER)
# self.success = Label(_("Your face has been successfully recorded"), label_width=300, text_x_align=pango.ALIGN_CENTER)
self.fail = Label(_("Failed to record your face"),
label_width=300,
text_x_align=pango.ALIGN_CENTER)
self.success = gtk.Alignment(0.5, 0.5, 0, 0)
self.success.set_size_request(300, -1)
self.success_img = gtk.Image()
self.success_img.set_from_pixbuf(self.success_pixbuf)
self.success_box = gtk.HBox()
self.success_box.pack_start(self.success_img, False, False, 5)
self.success_box.pack_start(
Label(_("Your face has been successfully recorded")))
self.success.add(self.success_box)
def resolve_accel_entry_conflict(origin_entry, conflict_entry, tmp_accel_buf):
dialog = DialogBox(" ", 620, 150)
dialog.window_frame.connect("expose-event", draw_widget_background)
dialog.set_keep_above(True)
dialog.set_modal(True)
dialog.body_align.set_padding(15, 10, 10, 10)
label1 = Label(
_("The shortcut \"%s\" is already used for \"%s\"") %
(tmp_accel_buf.get_accel_label(), conflict_entry.settings_description),
enable_select=False,
enable_double_click=False)
label2 = Label(_(
"If you reassign the shortcut to \"%s\", the \"%s\" shortcut will be disabled."
) % (origin_entry.settings_description,
conflict_entry.settings_description),
enable_select=False,
enable_double_click=False)
dialog.body_box.pack_start(label1)
dialog.body_box.pack_start(label2)
button_reassign = Button(_("Reassign"))
button_cancel = Button(_("Cancel"))
button_cancel.connect("clicked",
lambda b: origin_entry.reassign_cancel(dialog))
button_reassign.connect(
"clicked",
lambda b: origin_entry.reassign(tmp_accel_buf, conflict_entry, dialog))
dialog.right_button_box.set_buttons([button_cancel, button_reassign])
dialog.show_all()
def __init__(self,
title,
message,
default_width=400,
default_height=220,
confirm_callback=None,
cancel_callback=None,
confirm_button_text="Yes",
cancel_button_text="No"):
DialogBox.__init__(self, "", default_width, default_height, DIALOG_MASK_SINGLE_PAGE)
self.confirm_callback = confirm_callback
self.cancel_callback = cancel_callback
self.title_align = gtk.Alignment()
self.title_align.set(0, 0, 0, 0)
self.title_align.set_padding(0, 0, FRAME_LEFT_PADDING, 8)
self.title_label = Label(title, wrap_width=300)
self.label_align = gtk.Alignment()
self.label_align.set(0.5, 0.5, 0, 0)
self.label_align.set_padding(0, 0, 8, 8)
self.label = Label(message, text_x_align=ALIGN_MIDDLE, text_size=55)
self.confirm_button = Button(confirm_button_text)
self.cancel_button = Button(cancel_button_text)
self.confirm_button.connect("clicked", lambda w: self.click_confirm_button())
self.cancel_button.connect("clicked", lambda w: self.click_cancel_button())
self.body_box.pack_start(self.title_align, False, False)
self.title_align.add(self.title_label)
self.body_box.pack_start(self.label_align, True, True)
self.label_align.add(self.label)
self.right_button_box.set_buttons([self.cancel_button, self.confirm_button])
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 create_combo_label(self, title, content=""):
hbox = gtk.HBox(spacing=5)
title_label = Label("%s:" % title)
content_label = Label(content)
content_label.set_size_request(200, -1)
hbox.pack_start(title_label, False, False)
hbox.pack_start(content_label, False, False)
return hbox, content_label
def __init__(self, monitor_dir):
gtk.VBox.__init__(self)
self.set_spacing(10)
self.select_view = SelectView(monitor_dir,
filter_dir=["deepin-wallpapers"],
add_system=False)
self.select_view.connect("items-change", self.select_view_item_changed)
self.select_view.connect("double-click-item",
self.select_view_double_clicked)
self.select_view_sw = self.select_view.get_scrolled_window()
label_box = gtk.VBox()
no_favorites_label = Label(_("Your Favorites folder is empty."))
align_up = get_align(align=(0.5, 0.5, 0, 0))
align_up.add(no_favorites_label)
go_to_local_action = ActionButton(
_("Add from Local Pictures"),
lambda: event_manager.emit("switch-to-local-pictures", self))
align_down = get_align(align=(0.5, 0.5, 0, 0))
align_down.add(go_to_local_action)
label_box.pack_start(align_up, False, False)
label_box.pack_start(align_down, False, False)
self.no_favorites_align = gtk.Alignment(0.5, 0.5, 0, 0)
self.no_favorites_align.add(label_box)
self.notice_label = Label("")
set_wallpapper_button = Button(_("Set as wallpaper"))
set_wallpapper_button.connect("clicked", self.__on_set_as_wallpapper)
delete_button = Button(_("Delete"))
delete_button.connect("clicked", self.__on_delete)
self.button_box = gtk.HBox(spacing=10)
self.button_box.pack_start(set_wallpapper_button, False, False)
self.button_box.pack_start(delete_button, False, False)
self.control_box = gtk.HBox()
self.control_box.set_size_request(-1, 20)
self.control_box.pack_start(self.notice_label, False, False)
self.control_align = gtk.Alignment()
self.control_align.set(0.5, 0.5, 1, 1)
self.control_align.set_padding(0, 5, 20, 10)
self.control_align.add(self.control_box)
if len(self.select_view.items) == 0:
self.pack_start(self.no_favorites_align, True, True)
else:
self.pack_start(self.select_view_sw, True, True)
self.pack_end(self.control_align, False, True)
event_manager.add_callback("select-select-wallpaper",
self.__on_select_select_wallpaper)
self.timeout_notice_hide_id = None
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 __init__(self):
'''
init docs
'''
gtk.VBox.__init__(self)
self.status_box = StatusBox()
self.scroll = ScrolledWindow()
self.scroll.set_size_request(800, 432)
self.scroll.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
self.label_padding_x = 10
self.label_padding_y = 10
self.theme_box = gtk.VBox()
self.user_theme_label = Label(
_("My Themes"),
text_size=TITLE_FONT_SIZE,
text_color=app_theme.get_color("globalTitleForeground"))
self.user_theme_view = UserThemeView(status_box=self.status_box)
self.user_theme_scrolledwindow = self.user_theme_view.get_scrolled_window(
)
self.system_theme_label = Label(
_("System Themes"),
text_size=TITLE_FONT_SIZE,
text_color=app_theme.get_color("globalTitleForeground"))
self.system_theme_view = SystemThemeView(status_box=self.status_box)
self.system_theme_scrolledwindow = self.system_theme_view.get_scrolled_window(
)
self.theme_box.pack_start(self.user_theme_label, False, False)
self.theme_box.pack_start(get_separator(), False, False)
self.theme_box.pack_start(self.user_theme_scrolledwindow, False, False)
self.theme_box.pack_start(self.system_theme_label, False, False)
self.theme_box.pack_start(get_separator(), False, False)
self.theme_box.pack_start(self.system_theme_scrolledwindow, True, True)
main_align = gtk.Alignment()
main_align.set_padding(15, 0, 20, 20)
main_align.set(1, 1, 1, 1)
main_align.add(self.theme_box)
self.scroll.add_child(main_align)
main_align.connect("expose-event", self.expose_label_align)
self.pack_start(self.scroll, False, False)
self.pack_start(self.status_box)
def __init__(self):
super(GuideBox, self).__init__()
self.scrolled_window = ScrolledWindow()
self.backgroundbox = BackgroundBox()
self.backgroundbox.draw_mask = self.draw_mask
self.guide_pixbuf = utils.get_common_image_pixbuf('guide.png')
self.top_title = gtk.HBox()
self.top_left_icon = gtk.VBox()
self.top_left_icon.set_size_request(self.guide_pixbuf.get_width(),
self.guide_pixbuf.get_height())
self.top_left_icon.connect('expose-event', self.expose_top_left_icon)
top_left_icon_align = gtk.Alignment(0.5, 0.5, 0, 0)
top_left_icon_align.set_padding(15, 3, 13, 3)
top_left_icon_align.add(self.top_left_icon)
self.top_right_text = Label(
_("Introduction"), ui_theme.get_color('label_select_background'),
14)
top_right_text_align = gtk.Alignment(0.5, 0.5, 0, 0)
top_right_text_align.set_padding(18, 3, 3, 3)
top_right_text_align.add(self.top_right_text)
self.top_title.pack_start(top_left_icon_align, False, False)
self.top_title.pack_start(top_right_text_align, False, False)
self.content_box = gtk.VBox()
self.guide_label = Label('',
enable_select=False,
wrap_width=200,
text_size=9,
text_color=DynamicColor('#808080'))
guide_label_align = gtk.Alignment(0.5, 0.5, 1, 1)
guide_label_align.set_padding(5, 5, 10, 10)
guide_label_align.add(self.guide_label)
self.content_box.pack_start(guide_label_align, False, False)
self.backgroundbox.pack_start(self.top_title, False, False)
self.backgroundbox.pack_start(self.content_box)
self.scrolled_window.add_child(self.backgroundbox)
self.add(self.scrolled_window)
global_event.register_event('download-app-info-finish',
self.update_content)
def __init__(self, title_name):
BaseBar.__init__(self, init_index=-1)
self.set_spacing(3)
self.child_box = gtk.VBox()
self.child_item_height = 22
self.current_page = 1
self.page_items_num = 0
self.items = []
title_item = StaticLabel(
app_theme.get_pixbuf("filter/local_normal.png"), title_name, 10,
25, 15, 10, 25, ALIGN_START)
self.pack_start(title_item, False, False)
self.pack_start(self.child_box, True, True)
self.child_box.connect("size-allocate", self.size_change_cb)
self.control_box = gtk.HBox()
self.control_box.set_spacing(15)
previous_align = self.create_simple_button("previous",
self.update_current_page,
"previous")
next_align = self.create_simple_button("next",
self.update_current_page,
"next")
self.info_label = Label("0/0",
app_theme.get_color("labelText"),
text_x_align=ALIGN_MIDDLE)
self.control_box.pack_start(previous_align, False, False)
self.control_box.pack_start(self.info_label, False, False)
self.control_box.pack_start(next_align, False, False)
self.control_box.set_no_show_all(True)
control_align = gtk.Alignment()
control_align.set(1, 1, 0.5, 0.5)
control_align.add(self.control_box)
self.pack_start(control_align, False, False)
def fetch_comment(self):
if is_network_connected():
container_remove_all(self.right_comment_box)
loading_label = Label(_("Loading comments..."))
loading_label_align = gtk.Alignment(0.5, 0, 0, 0)
loading_label_align.add(loading_label)
loading_label_align.set_padding(10, 0, 0, 0)
self.right_comment_box.pack_start(loading_label_align, False,
False)
web_view = WebView(os.path.join(CONFIG_DIR, "cookie.txt"))
web_view.connect("new-window-policy-decision-requested",
self.open_url)
web_view.connect('console-message',
self.webview_console_message_handler)
web_view_align = gtk.Alignment()
web_view_align.set(0.5, 0, 0, 0)
web_view_align.set_padding(33, 33, 33, 33)
web_view_align.add(web_view)
web_settings = web_view.get_settings()
web_settings.set_property("enable-plugins", False)
web_settings.set_property("enable-scripts", True)
web_view.open("%s/softcenter/v1/comment?n=%s&hl=%s" % (
SERVER_ADDRESS,
self.pkg_name,
LANGUAGE,
))
web_view.connect("load-finished", self.comment_load_finished_cb,
web_view_align)
create_thread(self.fetch_screenshot).start()
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 __init__(self,
name,
text_size=TITLE_FONT_SIZE,
always_show=False,
toggle_callback=None,
label_right=False):
gtk.HBox.__init__(self)
self.set_size_request(-1, 30)
self.label = Label(
name,
text_size=text_size,
text_color=app_theme.get_color("globalTitleForeground"),
enable_select=False,
enable_double_click=False)
if label_right:
self.label_box = style.wrap_with_align(self.label, width=210)
else:
self.label_box = style.wrap_with_align(self.label,
align="left",
width=210)
self.label_box.set_size_request(210, 30)
self.pack_start(self.label_box, False, False)
if not always_show:
self.switch = SwitchButton(
False,
inactive_disable_dpixbuf=app_theme.get_pixbuf(
"toggle_button/inactive_normal.png"),
active_disable_dpixbuf=app_theme.get_pixbuf(
"toggle_button/active_disable.png"))
align = style.wrap_with_align(self.switch, align="left")
self.pack_start(align, False, False)
self.switch.connect("toggled", toggle_callback)
align.set_padding(0, 0, 15, 0)
def __init__(
self,
padding_left=0,
):
CycleStrip.__init__(self, app_theme.get_pixbuf("strip/background.png"))
self.label = Label()
self.label_align = gtk.Alignment()
self.label_align.set(0.0, 0.5, 0, 0)
self.label_align.set_padding(0, 0, padding_left, 0)
self.label_align.add(self.label)
self.search_button = ImageButton(
app_theme.get_pixbuf("entry/search_normal.png"),
app_theme.get_pixbuf("entry/search_hover.png"),
app_theme.get_pixbuf("entry/search_press.png"),
)
self.search_entry = InputEntry(action_button=self.search_button)
self.search_entry.set_size(220, 24)
entry_align = gtk.Alignment(0.5, 0.5, 0, 0)
entry_align.set_padding(0, 0, 5, 5)
entry_align.add(self.search_entry)
self.pack_start(self.label_align, True, True)
self.pack_start(entry_align, False, False)
def __init__(self, message, default_width=300, default_height=140, is_succeed=True):
DialogBox.__init__(self, "", default_width, default_height, self.DIALOG_MASK_SINGLE_PAGE)
self.hbox = gtk.HBox()
self.image_align = gtk.Alignment()
self.image_align.set(0, 0, 0, 0)
self.image_align.set_padding(0, 0, 20, 0)
self.image_box = ImageBox(app_theme.get_pixbuf("bluetooth/succeed.png"))
if not is_succeed:
self.image_box = ImageBox(app_theme.get_pixbuf("bluetooth/failed.png"))
self.image_align.add(self.image_box)
self.message_align = gtk.Alignment()
self.message_align.set(0, 0, 0, 0)
self.message_align.set_padding(20, 0, 10, 0)
if not is_succeed:
self.message_align.set_padding(0, 0, 10, 0)
self.message_label = Label(message, wrap_width = 200)
self.message_align.add(self.message_label)
self.hbox.pack_start(self.image_align)
self.hbox.pack_start(self.message_align)
self.confirm_align = gtk.Alignment()
self.confirm_align.set(0, 0, 0, 0)
self.confirm_align.set_padding(20, 0, 200, 0)
self.confirm_button = Button(_("Ok"))
self.confirm_button.set_size_request(70, WIDGET_HEIGHT)
self.confirm_button.connect("clicked", lambda widget : self.destroy())
self.confirm_align.add(self.confirm_button)
self.body_box.pack_start(self.hbox, False, False)
self.body_box.pack_start(self.confirm_align, False, False)
def __init__(self, icon, text, switch_callback=None, font_size=10):
gtk.Alignment.__init__(self, 0, 0.5, 0, 0)
self.set_size_request(-1, CONTAINNER_HEIGHT)
#self.icon = icon
self.text = text
self.show()
self.active_cb = switch_callback
self.hbox = gtk.HBox()
self.font_size = font_size
if icon:
self.image = ImageBox(icon)
#self.height = app_theme.get_pixbuf("/inactive_normal.png").get_pixbuf().get_height()
#self.width = app_theme.get_pixbuf("/inactive_normal.png").get_pixbuf().get_width()
#self.image.set_from_pixbuf(icon.get_pixbuf())
self.hbox.pack_start(self.image, False, False, ICON_PADDING)
self.label = Label(text,
text_size=TITLE_FONT_SIZE,
label_width=100,
enable_select=False,
enable_double_click=False)
self.hbox.pack_start(self.label, False, False, TEXT_PADDING)
self.switch = MyToggleButton()
#from style import wrap_with_align
#align = wrap_with_align(self.switch)
self.hbox.pack_start(self.switch, False, False, BUTTON_PADDING)
self.add(self.hbox)
self.switch.connect("toggled", self.active_cb)
self.hbox.connect("expose-event", self.expose_callback)
def __init__(self,
pixbuf,
title,
has_separator=True,
text_size=TITLE_FONT_SIZE,
text_color=app_theme.get_color("globalTitleForeground"),
width=222,
left_padding=0,
spacing=10):
gtk.VBox.__init__(self)
self.set_size_request(width, -1)
hbox = gtk.HBox(spacing=spacing)
label = Label(title,
text_color,
text_size,
enable_select=False,
enable_double_click=False)
if pixbuf == None:
self.__box_pack_start(hbox, [label])
else:
image_box = ImageBox(pixbuf)
self.__box_pack_start(hbox, [image_box, label])
align = style.wrap_with_align(hbox, align="left")
self.__box_pack_start(self, [align])
if has_separator:
separator = HSeparator(
app_theme.get_shadow_color("hSeparator").get_color_info(), 0,
0)
separator.set_size_request(-1, 10)
self.__box_pack_start(self, [separator])
def __init__(self, detail_page, pkg_name, alias_name, star):
'''
init docs
'''
gtk.HBox.__init__(self)
self.star = star
self.pkg_name = pkg_name
v_box = gtk.VBox()
pkg_icon_image = gtk.image_new_from_pixbuf(
gtk.gdk.pixbuf_new_from_file_at_size(
get_icon_pixbuf_path(pkg_name), 32, 32))
pkg_alias_label = Label(
alias_name, hover_color=app_theme.get_color("homepage_hover"))
pkg_alias_label.set_clickable()
pkg_alias_label.connect(
"button-press-event",
lambda w, e: detail_page.update_pkg_info(pkg_name))
self.pkg_star_box = gtk.HBox()
self.pkg_star_view = StarView()
self.pkg_star_view.star_buffer.star_level = int(star)
self.pkg_star_view.connect("clicked", lambda w: self.grade_pkg())
self.pkg_star_mark = StarMark(self.star, self.MARK_SIZE,
self.MARK_PADDING_X, self.MARK_PADDING_Y)
self.pack_start(pkg_icon_image, False, False)
self.pack_start(v_box, True, True, 8)
v_box.pack_start(pkg_alias_label, False, False, 2)
v_box.pack_start(self.pkg_star_box, False, False, 2)
self.pkg_star_box.pack_start(self.pkg_star_view, False, False)
self.pkg_star_box.pack_start(self.pkg_star_mark, False, False)
def create_combo_widget(self, label_content, items, select_index=0):
label = Label(label_content)
combo_box = ComboBox(items, select_index=select_index)
hbox = gtk.HBox(spacing=5)
hbox.pack_start(label, False, False)
hbox.pack_start(combo_box, False, False)
return hbox, combo_box
def create_combo_entry(self,
top_attach,
bottom_attach,
label_text,
content_text=""):
title_label_box = gtk.HBox()
title_label = Label("%s:" % label_text)
title_label_box.pack_start(create_right_align(), False, True)
title_label_box.pack_start(title_label, False, True)
content_entry = InputEntry(content_text)
content_entry.set_size(260, 25)
self.main_table.attach(title_label_box,
0,
1,
top_attach,
bottom_attach,
xoptions=gtk.FILL)
self.main_table.attach(content_entry,
1,
2,
top_attach,
bottom_attach,
xoptions=gtk.FILL)
return content_entry
def __init__(self, draw_time_callback=None):
super(SongTimer, self).__init__()
self.label_time = Label("00:00", app_theme.get_color("labelText"), 8, enable_gaussian=True)
self.draw_time_callback = draw_time_callback
if draw_time_callback:
draw_time_callback(self.label_time.get_text())
self.bar = ProgressBar()
bar_align = gtk.Alignment()
bar_align.set_padding(0, 0, 2, 2)
bar_align.set(1, 1, 1, 1)
bar_align.add(self.bar)
self.bar.connect("button-press-event", self.on_bar_press)
self.bar.connect("button-release-event", self.on_bar_release)
self.__value_changed_id = self.bar.connect("value-changed", self.on_bar_value_changed)
self.pack_start(bar_align, True, True)
self.update_bar = 1
self.duration = 0
self.__idle_release_id = None
self.delete = False
self.__need_report = False
self.press_flag = False
Player.connect("instant-new-song", self.set_duration)
Player.connect("init-status", self.on_player_init_status)
Player.bin.connect("queue-running", self.on_queue_running)
Player.bin.connect("tick", self.on_tick)
Player.connect("seeked", self.on_seek)
Player.connect("stopped", self.set_duration)
if not Player.song:
self.bar.set_sensitive(False)
def __setup_label(self,
text="",
text_size=CONTENT_FONT_SIZE,
align=ALIGN_END,
text_color=None):
label = Label(text, text_color, text_size, align, 240, False, False,
False)
return label
def __init_ui(self):
#self.check_bar = Imag\cceBox(app_theme.get_pixbuf("network/check_box-2.png"))
self.ssid_label = Label(_("SSID:"))
self.ssid_entry = InputEntry("Deepin.org")
self.ssid_entry.entry.set_size_request(200 ,22)
self.password_label = Label(_("Password:"******"")
self.password_entry.entry.set_size_request(200 ,22)
self.active_btn = Button(_("Active"))
self.jump_bar = ImageButton(app_theme.get_pixbuf("network/jump_to.png"),
app_theme.get_pixbuf("network/jump_to.png"),
app_theme.get_pixbuf("network/jump_to.png"))
self.check_bar_align = gtk.Alignment(0, 0, 0, 0)
self.check_bar_align.set_size_request(36, 30)
self.check_bar_align.connect("expose-event", self.expose_state)
#check_bar_align = self.__wrap_align(self.check_bar, (0, 0, 10, 10))
ssid_label_align = self.__wrap_align(self.ssid_label, (0, 0, 0, 10))
self.ssid_entry_align = self.__wrap_align(self.ssid_entry)
password_label_align = self.__wrap_align(self.password_label, (0, 0, 20, 10))
self.password_entry_align = self.__wrap_align(self.password_entry)
self.active_align = gtk.Alignment(1, 0.5, 0, 0)
self.active_align.set_padding(0, 0, 0, 10)
self.active_align.add(self.active_btn)
self.__pack_begin(self, [self.check_bar_align, ssid_label_align,
self.ssid_entry_align, password_label_align,
self.password_entry_align
])
self.ssid_entry_align.set_size_request(200, 30)
self.password_entry_align.set_size_request(200, 30)
self.pack_end(self.active_align, False, True)
self.show_all()
self.active_btn.connect("clicked", self.active_btn_callback)
#self.password_entry.expose_input_entry = self.expose_input_entry
self.check_out_pixbuf = app_theme.get_pixbuf('network/check_box_out.png')
self.loading_pixbuf = app_theme.get_pixbuf('network/loading.png')
self.check_pixbuf = app_theme.get_pixbuf('network/check_box-2.png')
#self.check_bar = ImageBox(app_theme.get_pixbuf("network/"+pixbufs[state]))
self.position = 1
self.net_state = 0
def __init__(self):
gtk.VBox.__init__(self)
label_align = gtk.Alignment(0.5, 0.5, 0, 0)
label = Label("No active connection")
label_align.add(label)
self.add(label_align)
def __active_action(self, state):
container_remove_all(self.ssid_entry_align)
container_remove_all(self.password_entry_align)
container_remove_all(self.active_align)
if state == False:
label1 = Label(self.ssid_entry.get_text())
label2 = Label(self.password_entry.get_text())
label1.connect("button-press-event", lambda w, e: self.__active_action(True))
label2.connect("button-press-event", lambda w, e: self.__active_action(True))
self.ssid_entry_align.add(label1)
self.password_entry_align.add(label2)
self.show_all()
else:
self.ssid_entry_align.add(self.ssid_entry)
self.password_entry_align.add(self.password_entry)
self.active_align.add(self.active_btn)
def __init__(
self,
title,
message,
default_width=330,
default_height=145,
confirm_callback=None,
cancel_callback=None,
cancel_first=True,
message_text_size=9,
):
'''
Initialize ConfirmDialog class.
@param title: Title for confirm dialog.
@param message: Confirm message.
@param default_width: Dialog width, default is 330 pixel.
@param default_height: Dialog height, default is 145 pixel.
@param confirm_callback: Callback when user click confirm button.
@param cancel_callback: Callback when user click cancel button.
@param cancel_first: Set as True if to make cancel button before confirm button, default is True.
@param message_text_size: Text size of message, default is 11.
'''
# Init.
DialogBox.__init__(self,
title,
default_width,
default_height,
DIALOG_MASK_SINGLE_PAGE,
close_callback=self.hide)
self.confirm_callback = confirm_callback
self.cancel_callback = cancel_callback
self.label_align = gtk.Alignment()
self.label_align.set(0.5, 0.5, 0, 0)
self.label_align.set_padding(0, 0, 8, 8)
self.label = Label(message,
text_x_align=ALIGN_MIDDLE,
text_size=message_text_size)
self.confirm_button = Button(_("OK"))
self.cancel_button = Button(_("Cancel"))
self.confirm_button.connect("clicked",
lambda w: self.click_confirm_button())
self.cancel_button.connect("clicked",
lambda w: self.click_cancel_button())
# Connect widgets.
self.body_box.pack_start(self.label_align, True, True)
self.label_align.add(self.label)
if cancel_first:
self.right_button_box.set_buttons(
[self.cancel_button, self.confirm_button])
else:
self.right_button_box.set_buttons(
[self.confirm_button, self.cancel_button])
def __label(self, label_name):
label = Label(label_name,
text_x_align=ALIGN_END,
text_size=CONTENT_FONT_SIZE,
enable_select=False,
enable_double_click=False,
fixed_width=STANDARD_LINE)
label.set_can_focus(False)
return label
def get_combo_group(name, items, callback=None):
box = gtk.HBox(spacing=8)
label = Label(name)
combo_box = ComboBox(items)
box.pack_start(label, False, False)
box.pack_start(combo_box, False, False)
if callback:
combo_box.connect("item-selected", callback)
return box, combo_box
def create_combo_entry(self, label_content, entry_content=""):
vbox = gtk.VBox()
vbox.set_spacing(5)
label = Label(label_content)
text_entry = TextEntry(entry_content)
text_entry.set_size(198, 26)
entry_box = set_widget_center(text_entry)
vbox.pack_start(label, False, False)
vbox.pack_start(entry_box, False, False)
return vbox, text_entry
