def __init__(self): Gtk.Grid.__init__(self) self.get_style_context().add_class('password') self.set_row_spacing(10) title = Heading(_('Select Account'), _('Log in to which account?')) self.attach(title.container, 0, 0, 2, 1) self.scrolled_window = ScrolledWindow() self.scrolled_window.set_size_request(self.WIDTH, self.HEIGHT) self.box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL) self.box.set_spacing(10) self.box.set_margin_left(10) self.box.set_margin_right(10) self.scrolled_window.add(self.box) self.attach(self.scrolled_window, 0, 1, 2, 1) self.last_username = get_last_user() self._populate() self.add_account_btn = OrangeButton(_('Add Account')) self.add_account_btn.connect('clicked', self._btn_add_account_pressed) self.attach(self.add_account_btn, 0, 2, 1, 1) self.shutdown_btn = OrangeButton(_('Shutdown')) self.shutdown_btn.connect('clicked', self._btn_shutdown_pressed) self.attach(self.shutdown_btn, 1, 2, 1, 1)
def __init__(self, win): Gtk.Box.__init__(self, orientation=Gtk.Orientation.VERTICAL) self.win = win self.win.set_main_widget(self) # Main image image = Gtk.Image.new_from_file(media + "/Graphics/no-internet-screen.png") # Orange button later_button = OrangeButton(_("Later")) later_button.connect('button-release-event', self.win.close_window) # Green button self.kano_button = KanoButton(_("CONNECT NOW")) self.kano_button.pack_and_align() self.kano_button.connect('button-release-event', self.go_to_wifi) self.kano_button.connect('key-release-event', self.go_to_wifi) # Text label text_align = self.create_text_align() # Place elements image.set_margin_top(50) image.set_margin_bottom(30) self.pack_start(image, False, False, 0) self.pack_start(text_align, False, False, 2) self.pack_start(self.kano_button.align, False, False, 10) self.pack_start(later_button, False, False, 3) # Refresh window self.win.show_all()
def __init__(self): Gtk.Box.__init__(self, orientation=Gtk.Orientation.VERTICAL) kano_button_text = _("CREATE") skip_button_text = _("Skip") login_button_text = _("I have a profile") header = _('Keep your creations safe') subheader = _( 'Create a Kano World account so you never lose your progress...\n' 'and to get inspired by creations from the community') img_width = 590 img_height = 270 self.skip_button = OrangeButton(skip_button_text) self.login_button = OrangeButton(login_button_text) image_filename = get_image('login', "", 'first-screen', str(img_width) + 'x' + str(img_height)) self.image = Gtk.Image.new_from_file(image_filename) self.pack_start(self.image, False, False, 0) self.heading = Heading(header, subheader) self.kano_button = KanoButton(kano_button_text) self.pack_start(self.heading.container, False, False, 0) self.button_box = Gtk.ButtonBox(spacing=10) self.button_box.set_layout(Gtk.ButtonBoxStyle.SPREAD) self.pack_start(self.button_box, False, False, 0) self.button_box.pack_start(self.login_button, False, False, 0) self.button_box.pack_start(self.kano_button, False, False, 0) self.button_box.pack_start(self.skip_button, False, False, 0)
def __init__(self, win, char_creator): Gtk.EventBox.__init__(self) self._win = win # Should this be inherited, passed as a variable, or global? # Could be a member variable in window. # self.char_creator = self._win.get_char_creator() self.char_creator = char_creator self._win.pack_in_main_content(self.char_creator) self.char_creator.reset_selected_menu_items() save_changes_button = KanoButton(_("Save changes").upper()) save_changes_button.connect("clicked", self.save_changes) discard_changes_button = OrangeButton(_("Discard").upper()) discard_changes_button.connect("clicked", self.discard) discard_changes_button.set_margin_left(100) empty_label = Gtk.Label("") button_box = Gtk.ButtonBox() button_box.pack_start(discard_changes_button, False, False, 0) button_box.pack_start(save_changes_button, False, False, 0) button_box.pack_start(empty_label, False, False, 0) self._win.pack_in_bottom_bar(button_box) self._win.show_all() # Hide all the pop ups self.char_creator._hide_pop_ups()
def __init__(self, win): Template.__init__( self, _("Keyboard"), _("Kano keyboard detected"), _("APPLY CHANGES") ) self.win = win self.win.set_main_widget(self) self.win.top_bar.enable_prev() # height is 106px img = Gtk.Image() img.set_from_file(common.media + "/Graphics/keyboard.png") # Link to advance options self.to_advance_button = OrangeButton(_("Layout options")) self.to_advance_button.connect('button_press_event', self.to_advance) self.kano_button.connect('button-release-event', self.win.go_to_home) self.win.change_prev_callback(self.win.go_to_home) self.box.pack_start(img, False, False, 0) self.box.pack_start(self.to_advance_button, False, False, 0) # Refresh window self.win.show_all()
def create_parental_button(self): desc = ( _("Use different levels to:\n" \ "- Block mature content in browser and YouTube\n" \ "- Or restrict internet access to only Kano World activity") ).split('\n') self.parental_button = Gtk.CheckButton() box = LabelledListTemplate.label_button( self.parental_button, _("Parental lock"), desc[0]) grid = Gtk.Grid() grid.attach(box, 0, 0, 1, 1) i = 1 for text in desc[1:]: label = Gtk.Label(text) label.set_alignment(xalign=0, yalign=0.5) label.set_padding(xpad=25, ypad=0) label.get_style_context().add_class('normal_label') grid.attach(label, 0, i, 1, 1) i = i + 1 if get_parental_enabled(): parental_config_button = OrangeButton(_("Configure")) parental_config_button.connect('button-press-event', self.go_to_parental_config) grid.attach(parental_config_button, 0, i, 1, 1) return grid
def __init__(self, win, title, description, original_overscan=None): Gtk.Box.__init__(self, orientation=Gtk.Orientation.VERTICAL) self.kano_button = KanoButton(_("APPLY CHANGES")) self.kano_button.connect('button-release-event', self.apply_changes) self.kano_button.pack_and_align() self.heading = Heading(title, description) self.pack_start(self.heading.container, False, False, 0) self.win = win self.win.set_main_widget(self) self.win.top_bar.enable_prev() # Launch pipe for the overscan c code launch_pipe() self.overscan_values = get_overscan_status() self.original_overscan = original_overscan # Pass original overscan values between the classes # If original_overscan hasn't been generated yet, get it from current # overscan status. Alternatively, maybe read this from a file in future if original_overscan is None: self.original_overscan = get_overscan_status() # Reset button self.reset_button = OrangeButton() reset_icon_path = os.path.join(common.media, '/Icons/reset.png') reset_image = Gtk.Image().new_from_file(reset_icon_path) self.reset_button.set_image(reset_image) self.reset_button.connect('button_press_event', self.reset)
class SetKanoKeyboard(Template): def __init__(self, win): Template.__init__( self, _("Keyboard"), _("Kano keyboard detected"), _("APPLY CHANGES") ) self.win = win self.win.set_main_widget(self) self.win.top_bar.enable_prev() # height is 106px img = Gtk.Image() img.set_from_file(common.media + "/Graphics/keyboard.png") # Link to advance options self.to_advance_button = OrangeButton(_("Layout options")) self.to_advance_button.connect('button_press_event', self.to_advance) self.kano_button.connect('button-release-event', self.win.go_to_home) self.win.change_prev_callback(self.win.go_to_home) self.box.pack_start(img, False, False, 0) self.box.pack_start(self.to_advance_button, False, False, 0) # Refresh window self.win.show_all() def to_advance(self, widget, event): self.win.clear_win() SetKeyboard(self.win)
def __init__(self, kano_button_text, orange_text="", orange_text_2="", orange_text_3=""): Gtk.Box.__init__(self) self.kano_button = KanoButton(kano_button_text) if orange_text != "": self.orange_button = OrangeButton(orange_text) self.pack_start(self.orange_button, False, False, 0) self.pack_start(self.kano_button, False, False, 0) if orange_text_2 == "": # The empty label is to centre the kano_button label = Gtk.Label(" ") self.pack_start(label, False, False, 0) else: self.orange_button2 = OrangeButton(orange_text_2) if orange_text_3 == "": self.pack_start(self.orange_button2, False, False, 0) else: # If two orange button texts, we align them vertically self.vertbox=Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=6) self.add(self.vertbox) self.orange_button3 = OrangeButton(orange_text_3) self.vertbox.pack_start(self.orange_button2, False, False, 0) self.vertbox.pack_start(self.orange_button3, False, False, 0) else: self.pack_start(self.kano_button, False, False, 0)
def __init__(self, user, greeter): Gtk.Grid.__init__(self) self.get_style_context().add_class('password') self.set_row_spacing(10) self.greeter = greeter self.user = user self.title = self._set_title() self.attach(self.title.container, 0, 0, 1, 1) self.label = Gtk.Label(user) self.label.get_style_context().add_class('login') self.attach(self.label, 0, 1, 1, 1) self.password = Gtk.Entry() self.password.set_visibility(False) self.password.set_alignment(0.5) self.password.connect('activate', self._login_cb) self.attach(self.password, 0, 2, 1, 1) self.login_btn = KanoButton(_('Login').upper()) self.login_btn.connect('clicked', self._login_cb) self.attach(self.login_btn, 0, 3, 1, 1) # Protect against removing the last Kano user # so you do not get locked out from logging into the Kit system_users = KanoUserList().get_users() if len(system_users) > 1: delete_account_btn = OrangeButton(_('Remove Account')) delete_account_btn.connect('clicked', self.delete_user) self.attach(delete_account_btn, 0, 4, 1, 1)
class KanoButtonBox(Gtk.Box): def __init__(self, kano_button_text, orange_text="", orange_text_2=""): Gtk.Box.__init__(self) self.kano_button = KanoButton(kano_button_text) if not orange_text == "": self.orange_button = OrangeButton(orange_text) self.pack_start(self.orange_button, False, False, 0) self.pack_start(self.kano_button, False, False, 0) if orange_text_2 == "": # The empty label is to centre the kano_button label = Gtk.Label(" ") self.pack_start(label, False, False, 0) else: self.orange_button2 = OrangeButton(orange_text_2) self.pack_start(self.orange_button2, False, False, 0) else: self.pack_start(self.kano_button, False, False, 0) def get_kano_button(self): return self.kano_button def set_kano_button_cb(self, cb, args=[]): self.kano_button.connect('button-release-event', cb, args) def set_orange_button_cb(self, cb, args=[]): self.orange_button.connect('button-release-event', cb, args) def set_orange_button2_cb(self, cb, args=None): self.orange_button2.connect('button-release-event', cb, args)
def __init__(self, win): Template.__init__(self, _("Parental lock"), _("Configure your parental lock settings"), _("APPLY CHANGES"), win.is_plug(), True) self.parental_level = Gtk.VScale(adjustment=Gtk.Adjustment( value=0, lower=0, upper=3, step_incr=1, page_incr=0, page_size=0)) self.parental_level.get_style_context().add_class('parental_slider') self.parental_level.set_draw_value(False) self.parental_level.set_round_digits(0) self.parental_level.set_inverted(True) self.parental_level.set_value(get_setting('Parental-level')) self.parental_level.connect('value-changed', self._value_change_handler) self._parental_labels = [ (Gtk.Label(_("Low Settings")), Gtk.Label( _("Block predefined blacklisted websites and\nactivates SafeSearch on Google and Youtube" ))), (Gtk.Label(_("Medium Settings")), Gtk.Label(_("Use safe DNS servers to filter all traffic"))), (Gtk.Label(_("High Settings")), Gtk.Label( _("Enable all filters and restrict search engine access"))), (Gtk.Label(_("Ultimate Settings")), Gtk.Label(_("Only allow access to Kano World activities"))) ] self.blacklist_button = OrangeButton(_("Configure allowed/blocked")) self.blacklist_button.connect('button-press-event', self.go_to_blacklist) self._value_change_handler(self.parental_level) parental_level_grid = Gtk.Grid() parental_level_grid.attach(self.parental_level, 0, 0, 1, 7) parental_level_grid.attach(self._parental_labels[3][0], 1, 0, 1, 1) parental_level_grid.attach(self._parental_labels[3][1], 1, 1, 1, 1) parental_level_grid.attach(self._parental_labels[2][0], 1, 2, 1, 1) parental_level_grid.attach(self._parental_labels[2][1], 1, 3, 1, 1) parental_level_grid.attach(self._parental_labels[1][0], 1, 4, 1, 1) parental_level_grid.attach(self._parental_labels[1][1], 1, 5, 1, 1) parental_level_grid.attach(self._parental_labels[0][0], 1, 6, 1, 1) parental_level_grid.attach(self._parental_labels[0][1], 1, 7, 1, 1) self.box.set_spacing(20) self.box.pack_start(parental_level_grid, False, False, 0) self.box.pack_start(self.blacklist_button, False, False, 0) self.win = win self.win.set_main_widget(self) self.set_prev_callback(self.go_to_advanced) self.win.change_prev_callback(self.win.go_to_home) self.win.top_bar.enable_prev() self.kano_button.connect('button-release-event', self.apply_changes) self.kano_button.connect('key-release-event', self.apply_changes) self.win.show_all()
def __init__(self, num_of_pages=3, selected_page=1, back_text=_("BACK"), next_text=_("NEXT")): Gtk.Alignment.__init__(self, xalign=0.5, xscale=0) self.num_of_pages = num_of_pages self.selected = selected_page self._box = Gtk.Box() self.add(self._box) # The back button has subtly different styling to the next button # When the back button is disabled, it goes invisible, while # the NEXT button goes grey. self._back_button = OrangeButton(back_text) self._back_button.connect('clicked', self.back_button_clicked) attach_cursor_events(self._back_button) self._next_button = OrangeButton(next_text) self._next_button.connect('clicked', self.next_button_clicked) attach_cursor_events(self._next_button) self.dot_box = Gtk.Box() self._create_progress_dots(self.selected) self._box.pack_start(self._back_button, False, False, 40) self._box.pack_start(self.dot_box, False, False, 0) self._box.pack_start(self._next_button, False, False, 40) if self.selected == 1: self._back_button.set_sensitive(False) if self.selected == self.num_of_pages: self._next_button.set_sensitive(False)
def __init__(self): Gtk.Box.__init__(self) self.checkbutton = Gtk.CheckButton() self.checkbutton.get_style_context().add_class('get_data_checkbutton') self.checkbutton.set_margin_left(30) self.tc_button = OrangeButton(_("I agree to the terms and conditions")) self.tc_button.connect('clicked', self._emit_t_and_c_signal) self.pack_start(self.checkbutton, False, False, 0) self.pack_start(self.tc_button, False, False, 0)
def add_button(self, label, callback=None): if not self._button_box: self._button_box = Gtk.Box() self._content.pack_start(self._button_box, False, False, 15) button = OrangeButton(label) if callback: button.connect('button_release_event', callback) button.connect('key_release_event', callback) self._button_box.pack_start(button, False, False, 10) self._button_box.set_halign(Gtk.Align.CENTER) self._button_box.set_valign(Gtk.Align.CENTER) return button
def __init__(self, win, original_overscan=None): OverscanTemplate.__init__( self, win, _("Overscan"), _("This setting lets you adjust your screen's size."), original_overscan ) self.win.change_prev_callback(self.go_to_display) # Listen for key events self.key_press_handler = self.win.connect('key-press-event', self.on_key_press) # slider self.t_value = Gtk.Label() self.t_value.get_style_context().add_class('slider_label') self.t_scale = Gtk.HScale.new_with_range(0, get_overscan_limit(), 1) self.t_scale.set_value(self.overscan_values['top']) self.t_scale.set_size_request(400, 30) self.t_scale.connect('value_changed', self.adjust_all) self.t_scale.connect('value_changed', self.update_all_values) self.t_scale.set_draw_value(False) self.update_all_values(self.t_scale) box = Gtk.Box() box.pack_start(self.t_scale, False, False, 5) box.pack_start(self.t_value, False, False, 5) box.pack_start(self.reset_button, False, False, 25) align = Gtk.Alignment(xalign=0.6, xscale=0, yscale=0, yalign=0.5) align.add(box) # Advance button self.advanced_button = OrangeButton() self.advanced_button.connect('button_press_event', self.go_to_advanced) self.advanced_button.set_label(_("Advanced")) button_box = Gtk.ButtonBox() button_box.set_layout(Gtk.ButtonBoxStyle.SPREAD) button_box.pack_start(self.advanced_button, False, False, 15) button_box.pack_start(self.kano_button.align, False, False, 15) empty_label = Gtk.Label(" ") button_box.pack_start(empty_label, False, False, 0) self.pack_start(align, True, True, 0) self.pack_end(button_box, False, False, 30) self.win.show_all()
def __init__(self, title, description, button_text, orange_button_text=None): Gtk.Box.__init__(self, orientation=Gtk.Orientation.VERTICAL) self.sw = ScrolledWindow() self.sw.apply_styling_to_widget(wide=False) self.title = Heading(title, description) self.kano_button = KanoButton(button_text) self.kano_button.pack_and_align() self.pack_start(self.title.container, False, False, 0) self.pack_start(self.sw, True, True, 0) if orange_button_text: box_align = Gtk.Alignment(xscale=0, xalign=0.5) button_box = Gtk.ButtonBox(orientation=Gtk.Orientation.HORIZONTAL, spacing=40) label = Gtk.Label("") self.orange_button = OrangeButton(orange_button_text) button_box.pack_start(label, False, False, 0) button_box.pack_start(self.kano_button.align, False, False, 0) button_box.pack_start(self.orange_button, False, False, 0) box_align.add(button_box) self.pack_start(box_align, False, False, 0) else: self.pack_start(self.kano_button.align, False, False, 0)
def __init__(self, img_filename, title, description, kano_button_text, orange_button_text): Gtk.Box.__init__(self, orientation=Gtk.Orientation.VERTICAL) if img_filename: self.image = Gtk.Image.new_from_file(img_filename) self.pack_start(self.image, False, False, 0) self.heading = Heading(title, description) self.kano_button = KanoButton(kano_button_text) self.pack_start(self.heading.container, False, False, 0) self.button_box = Gtk.ButtonBox(spacing=10) self.button_box.set_layout(Gtk.ButtonBoxStyle.SPREAD) self.button_box.set_margin_bottom(30) self.pack_start(self.button_box, False, False, 0) if not orange_button_text == "": self.orange_button = OrangeButton(orange_button_text) self.button_box.pack_start(self.orange_button, False, False, 0) self.button_box.pack_start(self.kano_button, False, False, 0) # The empty label is to centre the kano_button label = Gtk.Label(" ") self.button_box.pack_start(label, False, False, 0) else: self.button_box.pack_start(self.kano_button, False, False, 0)
def __init__(self, win, title, description, original_overscan=None): Gtk.Box.__init__(self, orientation=Gtk.Orientation.VERTICAL) self.kano_button = KanoButton("APPLY CHANGES") self.kano_button.connect("button-release-event", self.apply_changes) self.kano_button.pack_and_align() self.heading = Heading(title, description) self.pack_start(self.heading.container, False, False, 0) self.win = win self.win.set_main_widget(self) self.win.top_bar.enable_prev() # Launch pipe for the overscan c code launch_pipe() self.overscan_values = get_overscan_status() self.original_overscan = original_overscan # Pass original overscan values between the classes # If original_overscan hasn't been generated yet, get it from current overscan status # Alternatively, maybe read this from a file in future if original_overscan is None: self.original_overscan = get_overscan_status() # Reset button self.reset_button = OrangeButton() reset_image = Gtk.Image().new_from_file(common.media + "/Icons/reset.png") self.reset_button.set_image(reset_image) self.reset_button.connect("button_press_event", self.reset)
def __add_orange_button(self, orange_info, kano_button_box): orange_text = orange_info['name'] orange_return_value = orange_info['return_value'] button_container = Gtk.ButtonBox(spacing=10) button_container.set_layout(Gtk.ButtonBoxStyle.SPREAD) self.orange_button = OrangeButton(orange_text) self.orange_button.connect('button-release-event', self.exit_dialog, orange_return_value) button_container.pack_start(self.orange_button, False, False, 0) button_container.pack_start(kano_button_box, False, False, 0) # The empty label is to centre the kano_button label = Gtk.Label(" ") button_container.pack_start(label, False, False, 0) return button_container
def __init__(self, kano_button_text, orange_text="", orange_text_2=""): Gtk.Box.__init__(self) self.kano_button = KanoButton(kano_button_text) if not orange_text == "": self.orange_button = OrangeButton(orange_text) self.pack_start(self.orange_button, False, False, 0) self.pack_start(self.kano_button, False, False, 0) if orange_text_2 == "": # The empty label is to centre the kano_button label = Gtk.Label(" ") self.pack_start(label, False, False, 0) else: self.orange_button2 = OrangeButton(orange_text_2) self.pack_start(self.orange_button2, False, False, 0) else: self.pack_start(self.kano_button, False, False, 0)
def create_parental_button(self): desc = (_(" Use different levels to:\n" "- Block mature content in browser and YouTube\n" "- Or restrict internet access to only Kano World activity") ).split('\n') self.parental_button = Gtk.CheckButton() box = LabelledListTemplate.label_button(self.parental_button, _("Parental lock"), desc[0]) grid = self._labelled_list_helper(desc, box) if get_parental_enabled(): parental_config_button = OrangeButton(_("Configure")) parental_config_button.connect('button-press-event', self.go_to_parental_config) grid.attach(parental_config_button, 0, len(desc), 1, 1) return grid
def __init__(self, title, description, buttons, is_plug=False, img_path=None): super(Template, self).__init__(orientation=Gtk.Orientation.VERTICAL) self._focus_widget = None heading = Heading(title, description, is_plug, back_btn=False) bbox = Gtk.ButtonBox() bbox.set_spacing(20) bbox.set_layout(Gtk.ButtonBoxStyle.CENTER) bbox.set_margin_right(10) bbox.set_margin_left(10) for b in buttons: label = b["label"] if not label: gtk_button = Gtk.Label() else: button_type = b["type"] callback = b["callback"] if button_type == "KanoButton": color = b["color"] gtk_button = KanoButton(label, color=color) elif button_type == "OrangeButton": gtk_button = OrangeButton(label) gtk_button.connect("clicked", callback) bbox.pack_start(gtk_button, False, False, 0) if "focus" in b: self._focus_widget = gtk_button self.pack_start(heading.container, False, False, 0) heading.container.set_margin_right(15) heading.container.set_margin_left(15) if img_path: image = Gtk.Image.new_from_file(img_path) if is_plug: self.pack_start(image, False, False, 10) self.pack_start(bbox, False, False, 30) else: self.pack_start(image, False, False, 20) self.pack_end(bbox, False, False, 30) self.show_all()
def __init__(self, win, char_creator): Gtk.EventBox.__init__(self) self._win = win # Should this be inherited, passed as a variable, or global? # Could be a member variable in window. # self.char_creator = self._win.get_char_creator() self.char_creator = char_creator self._win.pack_in_main_content(self.char_creator) self.char_creator.reset_selected_menu_items() self._save_changes_button = KanoButton(_("Save changes").upper()) self._save_changes_button.connect('clicked', self.save_changes) self._save_changes_button.set_sensitive(False) self.char_creator.connect('character_changed', self._make_button_sensitive) discard_changes_button = OrangeButton(_("Discard").upper()) discard_changes_button.connect('clicked', self.discard) discard_changes_button.set_margin_left(100) empty_label = Gtk.Label("") button_box = Gtk.ButtonBox() button_box.pack_start(discard_changes_button, False, False, 0) button_box.pack_start(self._save_changes_button, False, False, 0) button_box.pack_start(empty_label, False, False, 0) self._win.pack_in_bottom_bar(button_box) self._win.show_all() # Hide all the pop ups self.char_creator._hide_pop_ups()
class TermsAndConditions(Gtk.Box): __gsignals__ = {'t-and-cs-clicked': (GObject.SIGNAL_RUN_FIRST, None, ())} def __init__(self): Gtk.Box.__init__(self) self.checkbutton = Gtk.CheckButton() self.checkbutton.get_style_context().add_class('get_data_checkbutton') self.checkbutton.set_margin_left(30) self.tc_button = OrangeButton(_("I agree to the terms and conditions")) self.tc_button.connect('clicked', self._emit_t_and_c_signal) self.pack_start(self.checkbutton, False, False, 0) self.pack_start(self.tc_button, False, False, 0) def is_checked(self): return self.checkbutton.get_active() def _emit_t_and_c_signal(self, widget): self.emit('t-and-cs-clicked') def disable_all(self): self.checkbutton.set_sensitive(False) self.tc_button.set_sensitive(False) def enable_all(self): self.checkbutton.set_sensitive(True) self.tc_button.set_sensitive(True)
def __init__(self): Gtk.Window.__init__(self, title=self._TITLE) apply_common_to_screen() window_height = self._IMAGE_HEIGHT + 220 self.set_size_request(self._IMAGE_WIDTH, window_height) self.set_decorated(False) self.set_resizable(False) self.set_position(Gtk.WindowPosition.CENTER) self.set_icon_name('kano-updater') # Put the window above all the existing ones when it starts # FIXME: this needs to happen within a 'realized' signal handler # disabled for now #self.get_window().raise_() image = Gtk.Image() image.set_from_file(self._HEADER_IMAGE) background = Gtk.EventBox() background.set_size_request(self._IMAGE_WIDTH, self._IMAGE_HEIGHT) background.add(image) # Header heading = Heading(self._HEADING, self._BYLINE) heading.description.set_line_wrap(True) action = KanoButton(self._ACTION.upper()) action.connect('clicked', self._do_action) action.set_halign(Gtk.Align.CENTER) later = OrangeButton(_("Later")) later.connect('clicked', self._do_later) later.set_halign(Gtk.Align.START) later.set_margin_left(40) buttons = Gtk.Overlay() buttons.add(action) buttons.add_overlay(later) box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=0) box.pack_start(background, False, False, 0) box.pack_start(heading.container, False, False, 10) box.pack_start(buttons, False, False, 0) self.add(box) self.show_all()
class TermsAndConditions(Gtk.Box): __gsignals__ = { 't-and-cs-clicked': (GObject.SIGNAL_RUN_FIRST, None, ()) } def __init__(self): Gtk.Box.__init__(self) self.checkbutton = Gtk.CheckButton() self.checkbutton.get_style_context().add_class('get_data_checkbutton') self.checkbutton.set_margin_left(30) self.tc_button = OrangeButton(_("I agree to the terms and conditions")) self.tc_button.connect('clicked', self._emit_t_and_c_signal) self.pack_start(self.checkbutton, False, False, 0) self.pack_start(self.tc_button, False, False, 0) def is_checked(self): return self.checkbutton.get_active() def _emit_t_and_c_signal(self, widget): self.emit('t-and-cs-clicked') def disable_all(self): self.checkbutton.set_sensitive(False) self.tc_button.set_sensitive(False) def enable_all(self): self.checkbutton.set_sensitive(True) self.tc_button.set_sensitive(True)
def __init__(self, kano_button_text, orange_text="", orange_text_2="", orange_text_3=""): Gtk.Box.__init__(self) self.kano_button = KanoButton(kano_button_text) if orange_text != "": self.orange_button = OrangeButton(orange_text) self.pack_start(self.orange_button, False, False, 0) self.pack_start(self.kano_button, False, False, 0) if orange_text_2 == "": # The empty label is to centre the kano_button label = Gtk.Label(" ") self.pack_start(label, False, False, 0) else: self.orange_button2 = OrangeButton(orange_text_2) if orange_text_3 == "": self.pack_start(self.orange_button2, False, False, 0) else: # If two orange button texts, we align them vertically self.vertbox = Gtk.Box( orientation=Gtk.Orientation.VERTICAL, spacing=6) self.add(self.vertbox) self.orange_button3 = OrangeButton(orange_text_3) self.vertbox.pack_start(self.orange_button2, False, False, 0) self.vertbox.pack_start(self.orange_button3, False, False, 0) else: self.pack_start(self.kano_button, False, False, 0)
def __init__(self, stage, now_cb, later_cb): super(ParentalScreen, self).__init__(False, 0) self.set_hexpand(False) self.set_vexpand(False) self.set_margin_left(40) self.set_margin_right(40) heading = Gtk.Label('For parents...') add_class(heading, 'console-screen-heading') copy = 'You can put a safety filter on Kano\'s internet. ' + \ 'You can set it now or later.' desc = Gtk.Label(copy) desc.set_line_wrap(True) add_class(desc, 'console-screen-desc') padlock = Gtk.Image.new_from_file(stage.media_path('padlock.png')) later = KanoButton('GOT IT') later.connect('clicked', self._cb_wrapper, later_cb, 'init-flow-parental-skipped') later.set_size_request(200, 50) now = OrangeButton('SET NOW') now.connect('clicked', self._cb_wrapper, now_cb, 'init-flow-parental-set') emptylabel = Gtk.Label(" ") buttons = Gtk.ButtonBox() buttons.set_layout(Gtk.ButtonBoxStyle.SPREAD) buttons.pack_start(emptylabel, True, True, 0) buttons.pack_start(later, True, True, 20) buttons.pack_start(now, True, True, 20) self.pack_start(heading, False, False, 30) self.pack_start(desc, False, False, 20) self.pack_start(padlock, False, False, 10) self.pack_start(buttons, True, True, 30)
def create_parental_button(self): desc = ( _(" Use different levels to:\n" "- Block mature content in browser and YouTube\n" "- Or restrict internet access to only Kano World activity") ).split('\n') self.parental_button = Gtk.CheckButton() box = LabelledListTemplate.label_button( self.parental_button, _("Parental lock"), desc[0]) grid = self._labelled_list_helper(desc, box) if get_parental_enabled(): parental_config_button = OrangeButton(_("Configure")) parental_config_button.connect('button-press-event', self.go_to_parental_config) grid.attach(parental_config_button, 0, len(desc), 1, 1) return grid
def __init__(self): Gtk.Window.__init__(self, title=self._TITLE) apply_common_to_screen() window_height = self._IMAGE_HEIGHT + 220 self.set_size_request(self._IMAGE_WIDTH, window_height) self.set_decorated(False) self.set_resizable(False) self.set_position(Gtk.WindowPosition.CENTER) self.set_icon_name('kano-updater') # Make sure this window is always above self.set_keep_above(True) image = Gtk.Image() image.set_from_file(self._HEADER_IMAGE) background = Gtk.EventBox() background.set_size_request(self._IMAGE_WIDTH, self._IMAGE_HEIGHT) background.add(image) # Header heading = Heading(self._HEADING, self._BYLINE) heading.description.set_line_wrap(True) action = KanoButton(self._ACTION.upper()) action.connect('clicked', self._do_action) action.set_halign(Gtk.Align.CENTER) later = OrangeButton(_('Later')) later.connect('clicked', Gtk.main_quit) later.set_halign(Gtk.Align.START) later.set_margin_left(40) buttons = Gtk.Overlay() buttons.add(action) buttons.add_overlay(later) box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=0) box.pack_start(background, False, False, 0) box.pack_start(heading.container, False, False, 10) box.pack_start(buttons, False, False, 0) self.add(box) self.show_all()
def __init__(self, win, original_overscan=None): OverscanTemplate.__init__( self, win, "Overscan", "This setting lets you adjust your screen's size.", original_overscan ) self.win.change_prev_callback(self.go_to_display) # Listen for key events self.key_press_handler = self.win.connect("key-press-event", self.on_key_press) ## slider self.t_value = Gtk.Label() self.t_value.get_style_context().add_class("slider_label") self.t_scale = Gtk.HScale.new_with_range(0, 100, 1) self.t_scale.set_value(self.overscan_values['top']) self.t_scale.set_size_request(400, 30) self.t_scale.connect('value_changed', self.adjust_all) self.t_scale.connect('value_changed', self.update_all_values) self.t_scale.set_draw_value(False) self.update_all_values(self.t_scale) box = Gtk.Box() box.pack_start(self.t_scale, False, False, 5) box.pack_start(self.t_value, False, False, 5) box.pack_start(self.reset_button, False, False, 25) align = Gtk.Alignment(xalign=0.6, xscale=0, yscale=0, yalign=0.5) align.add(box) # Advance button self.advanced_button = OrangeButton() self.advanced_button.connect("button_press_event", self.go_to_advanced) self.advanced_button.set_label("Advanced") button_box = Gtk.ButtonBox() button_box.set_layout(Gtk.ButtonBoxStyle.SPREAD) button_box.pack_start(self.advanced_button, False, False, 15) button_box.pack_start(self.kano_button.align, False, False, 15) empty_label = Gtk.Label(" ") button_box.pack_start(empty_label, False, False, 0) self.pack_start(align, True, True, 0) self.pack_end(button_box, False, False, 30) self.win.show_all()
def __add_orange_button(self, orange_info, kano_button_box): orange_text = orange_info["name"] orange_return_value = orange_info["return_value"] button_container = Gtk.ButtonBox(spacing=10) button_container.set_layout(Gtk.ButtonBoxStyle.SPREAD) self.orange_button = OrangeButton(orange_text) self.orange_button.connect("button-release-event", self.exit_dialog, orange_return_value) button_container.pack_start(self.orange_button, False, False, 0) button_container.pack_start(kano_button_box, False, False, 0) # The empty label is to centre the kano_button label = Gtk.Label(" ") button_container.pack_start(label, False, False, 0) return button_container
def __init__(self): Gtk.Box.__init__(self) self.checkbutton = Gtk.CheckButton() self.checkbutton.get_style_context().add_class("get_data_checkbutton") self.checkbutton.set_size_request(50, 50) self.checkbutton.set_margin_left(30) self.tc_button = OrangeButton(_("I agree to the terms and conditions")) self.tc_button.connect("clicked", self._emit_t_and_c_signal) tc_label = self.tc_button.label tc_label.set_max_width_chars(20) tc_label.set_line_wrap(True) self.pack_start(self.checkbutton, False, False, 0) self.pack_start(self.tc_button, False, False, 0)
class KanoButtonBox(Gtk.Box): def __init__(self, kano_button_text, orange_text="", orange_text_2="", orange_text_3=""): Gtk.Box.__init__(self) self.kano_button = KanoButton(kano_button_text) if orange_text != "": self.orange_button = OrangeButton(orange_text) self.pack_start(self.orange_button, False, False, 0) self.pack_start(self.kano_button, False, False, 0) if orange_text_2 == "": # The empty label is to centre the kano_button label = Gtk.Label(" ") self.pack_start(label, False, False, 0) else: self.orange_button2 = OrangeButton(orange_text_2) if orange_text_3 == "": self.pack_start(self.orange_button2, False, False, 0) else: # If two orange button texts, we align them vertically self.vertbox = Gtk.Box( orientation=Gtk.Orientation.VERTICAL, spacing=6) self.add(self.vertbox) self.orange_button3 = OrangeButton(orange_text_3) self.vertbox.pack_start(self.orange_button2, False, False, 0) self.vertbox.pack_start(self.orange_button3, False, False, 0) else: self.pack_start(self.kano_button, False, False, 0) def get_kano_button(self): return self.kano_button def set_kano_button_cb(self, cb, args=[]): self.kano_button.connect('button-release-event', cb, args) def set_orange_button_cb(self, cb, args=[]): self.orange_button.connect('button-release-event', cb, args) def set_orange_button2_cb(self, cb, args=None): self.orange_button2.connect('button-release-event', cb, args) def set_orange_button3_cb(self, cb, args=None): self.orange_button3.connect('button-release-event', cb, args)
class KanoButtonBox(Gtk.Box): def __init__(self, kano_button_text, orange_text="", orange_text_2="", orange_text_3=""): Gtk.Box.__init__(self) self.kano_button = KanoButton(kano_button_text) if orange_text != "": self.orange_button = OrangeButton(orange_text) self.pack_start(self.orange_button, False, False, 0) self.pack_start(self.kano_button, False, False, 0) if orange_text_2 == "": # The empty label is to centre the kano_button label = Gtk.Label(" ") self.pack_start(label, False, False, 0) else: self.orange_button2 = OrangeButton(orange_text_2) if orange_text_3 == "": self.pack_start(self.orange_button2, False, False, 0) else: # If two orange button texts, we align them vertically self.vertbox=Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=6) self.add(self.vertbox) self.orange_button3 = OrangeButton(orange_text_3) self.vertbox.pack_start(self.orange_button2, False, False, 0) self.vertbox.pack_start(self.orange_button3, False, False, 0) else: self.pack_start(self.kano_button, False, False, 0) def get_kano_button(self): return self.kano_button def set_kano_button_cb(self, cb, args=[]): self.kano_button.connect('button-release-event', cb, args) def set_orange_button_cb(self, cb, args=[]): self.orange_button.connect('button-release-event', cb, args) def set_orange_button2_cb(self, cb, args=None): self.orange_button2.connect('button-release-event', cb, args) def set_orange_button3_cb(self, cb, args=None): self.orange_button3.connect('button-release-event', cb, args)
class TermsAndConditions(Gtk.Box): __gsignals__ = { 't-and-cs-clicked': (GObject.SIGNAL_RUN_FIRST, None, ()) } def __init__(self): Gtk.Box.__init__(self) self.checkbutton = Gtk.CheckButton() self.checkbutton.get_style_context().add_class("get_data_checkbutton") self.checkbutton.set_size_request(50, 50) self.checkbutton.set_margin_left(30) self.tc_button = OrangeButton(_("I agree to the terms and conditions")) self.tc_button.connect("clicked", self._emit_t_and_c_signal) tc_label = self.tc_button.label tc_label.set_max_width_chars(20) tc_label.set_line_wrap(True) self.pack_start(self.checkbutton, False, False, 0) self.pack_start(self.tc_button, False, False, 0) def is_checked(self): return self.checkbutton.get_active() def _emit_t_and_c_signal(self, widget): self.emit("t-and-cs-clicked") def disable_all(self): self.checkbutton.set_sensitive(False) self.tc_button.set_sensitive(False) def enable_all(self): self.checkbutton.set_sensitive(True) self.tc_button.set_sensitive(True)
def __init__(self, win): Template.__init__(self, "", _("to be set"), _("COMPLETE")) self.win = win self.win.set_main_widget(self) self.kano_button.connect('button-release-event', self.win.go_to_home) internet_img = Gtk.Image() # Very hacky way to centre the Proxy button - put spaces in the label self.proxy_button = OrangeButton(_("Proxy ")) self.proxy_button.connect('button-release-event', self.go_to_proxy) self.disable_proxy = OrangeButton(_("Disable proxy")) self.win.change_prev_callback(self.win.go_to_home) self.win.top_bar.enable_prev() internet_status = Gtk.Label() internet_status_style = internet_status.get_style_context() internet_status.set_alignment(xalign=1, yalign=0.5) internet_action = Gtk.Label() internet_action_style = internet_action.get_style_context() internet_status_style.add_class('internet_status_top') internet_action_style.add_class('internet_status_bottom') internet_action.set_alignment(xalign=1, yalign=0.5) status_box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=0) status_box.props.valign = Gtk.Align.CENTER configure_container = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=0) container = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=0) container.pack_start(status_box, False, False, 2) container.pack_start(internet_img, False, False, 2) self.box.pack_start(container, False, False, 0) network_info_dict = network_info() common.has_internet = is_internet() if not common.has_internet or not network_info_dict: if network_info_dict: description = _("Use the browser to log in or configure proxy") else: description = _("Configure wireless") title = _("Get connected") self.add_connection = KanoButton(_("WIFI")) self.add_connection.connect('button_release_event', self.configure_wifi) # We removed the ability to use keyboard to click, so we also remove ability # to get keyboard focus self.add_connection.set_can_focus(False) # For now, this is removed as the event listener is interefering with the # kano-connect #self.add_connection.connect("key_release_event", self.configure_wifi) status_box.pack_start(self.add_connection, False, False, 0) internet_img.set_from_file(common.media + "/Graphics/Internet-noConnection.png") internet_status.set_text(_("No network found")) self.kano_button.set_label(_("BACK")) status_box.pack_start(configure_container, False, False, 3) go_to_portal_button = OrangeButton(_("Browser Login")) go_to_portal_button.connect('button-press-event', self.cb_launch_browser) configure_container.pack_start(go_to_portal_button, False, False, 0) divider_label = Gtk.Label("|") configure_container.pack_start(divider_label, False, False, 3) configure_container.pack_end(self.proxy_button, False, False, 0) else: self.kano_button.set_label(_("COMPLETE")) status_box.pack_start(internet_status, False, False, 3) status_box.pack_start(internet_action, False, False, 3) status_box.pack_start(configure_container, False, False, 3) network = network_info_dict.keys()[0] ip = network_info_dict[network]['address'] network_text = network_info_dict[network]['nice_name'] internet_img.set_from_file(common.media + "/Graphics/Internet-Connection.png") internet_status.set_text(network_text) internet_action.set_text(ip) go_to_portal_button = OrangeButton(_("Browser Login")) go_to_portal_button.connect('button-press-event', self.cb_launch_browser) configure_container.pack_start(go_to_portal_button, False, False, 0) if network_text == 'Ethernet': title = _("Connection found!") description = _("You're on a wired network") # Change to ethernet image here internet_img.set_from_file(common.media + "/Graphics/Internet-ethernetConnection.png") else: title = _("Connection found!") description = _("You're on a wireless network") divider_label = Gtk.Label("|") configure_container.pack_start(divider_label, False, False, 3) configure_button = OrangeButton(_("Configure")) configure_button.connect('button_press_event', self.configure_wifi) configure_container.pack_start(configure_button, False, False, 0) divider_label = Gtk.Label("|") configure_container.pack_start(divider_label, False, False, 3) configure_container.pack_end(self.proxy_button, False, False, 0) self.title.title.set_text(title) self.title.description.set_text(description) self.win.show_all()
class SetWifi(Template): wifi_connection_attempted = False def __init__(self, win): Template.__init__(self, "", _("to be set"), _("COMPLETE")) self.win = win self.win.set_main_widget(self) self.kano_button.connect('button-release-event', self.win.go_to_home) internet_img = Gtk.Image() # Very hacky way to centre the Proxy button - put spaces in the label self.proxy_button = OrangeButton(_("Proxy ")) self.proxy_button.connect('button-release-event', self.go_to_proxy) self.disable_proxy = OrangeButton(_("Disable proxy")) self.win.change_prev_callback(self.win.go_to_home) self.win.top_bar.enable_prev() internet_status = Gtk.Label() internet_status_style = internet_status.get_style_context() internet_status.set_alignment(xalign=1, yalign=0.5) internet_action = Gtk.Label() internet_action_style = internet_action.get_style_context() internet_status_style.add_class('internet_status_top') internet_action_style.add_class('internet_status_bottom') internet_action.set_alignment(xalign=1, yalign=0.5) status_box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=0) status_box.props.valign = Gtk.Align.CENTER configure_container = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=0) container = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=0) container.pack_start(status_box, False, False, 2) container.pack_start(internet_img, False, False, 2) self.box.pack_start(container, False, False, 0) network_info_dict = network_info() common.has_internet = is_internet() if not common.has_internet or not network_info_dict: if network_info_dict: description = _("Use the browser to log in or configure proxy") else: description = _("Configure wireless") title = _("Get connected") self.add_connection = KanoButton(_("WIFI")) self.add_connection.connect('button_release_event', self.configure_wifi) # We removed the ability to use keyboard to click, so we also remove ability # to get keyboard focus self.add_connection.set_can_focus(False) # For now, this is removed as the event listener is interefering with the # kano-connect #self.add_connection.connect("key_release_event", self.configure_wifi) status_box.pack_start(self.add_connection, False, False, 0) internet_img.set_from_file(common.media + "/Graphics/Internet-noConnection.png") internet_status.set_text(_("No network found")) self.kano_button.set_label(_("BACK")) status_box.pack_start(configure_container, False, False, 3) go_to_portal_button = OrangeButton(_("Browser Login")) go_to_portal_button.connect('button-press-event', self.cb_launch_browser) configure_container.pack_start(go_to_portal_button, False, False, 0) divider_label = Gtk.Label("|") configure_container.pack_start(divider_label, False, False, 3) configure_container.pack_end(self.proxy_button, False, False, 0) else: self.kano_button.set_label(_("COMPLETE")) status_box.pack_start(internet_status, False, False, 3) status_box.pack_start(internet_action, False, False, 3) status_box.pack_start(configure_container, False, False, 3) network = network_info_dict.keys()[0] ip = network_info_dict[network]['address'] network_text = network_info_dict[network]['nice_name'] internet_img.set_from_file(common.media + "/Graphics/Internet-Connection.png") internet_status.set_text(network_text) internet_action.set_text(ip) go_to_portal_button = OrangeButton(_("Browser Login")) go_to_portal_button.connect('button-press-event', self.cb_launch_browser) configure_container.pack_start(go_to_portal_button, False, False, 0) if network_text == 'Ethernet': title = _("Connection found!") description = _("You're on a wired network") # Change to ethernet image here internet_img.set_from_file(common.media + "/Graphics/Internet-ethernetConnection.png") else: title = _("Connection found!") description = _("You're on a wireless network") divider_label = Gtk.Label("|") configure_container.pack_start(divider_label, False, False, 3) configure_button = OrangeButton(_("Configure")) configure_button.connect('button_press_event', self.configure_wifi) configure_container.pack_start(configure_button, False, False, 0) divider_label = Gtk.Label("|") configure_container.pack_start(divider_label, False, False, 3) configure_container.pack_end(self.proxy_button, False, False, 0) self.title.title.set_text(title) self.title.description.set_text(description) self.win.show_all() def cb_launch_browser(self, control, signal): # start the default browser to visit the default page launch_browser() def go_to_proxy(self, widget, event): self.win.clear_win() SetProxy(self.win) def configure_wifi(self, widget=None, event=None): # If is a mouse click event or key pressed is ENTER if not hasattr(event, 'keyval') or event.keyval == Gdk.KEY_Return: self.kano_button.set_sensitive(True) self.wifi_connection_attempted = True # Blur window self.win.blur() self.win.show_all() # Force blur to be shown while Gtk.events_pending(): Gtk.main_iteration() # Call WiFi config os.system('/usr/bin/kano-wifi-gui') # Refresh window after WiFi Setup self.win.unblur() self.win.clear_win() SetWifi(self.win)
def __init__(self, win): # Show the Display brand and model self.model = get_edid_name() info_message = _("\nScreen Model: {}".format(self.model)) # And the current display resolution try: current_resolution = get_status()['resolution'] info_message += _("\nCurrent Resolution: {}").format(_(current_resolution)) except: pass Template.__init__( self, _("Display"), info_message, _("APPLY CHANGES") ) self.win = win self.win.set_main_widget(self) self.win.top_bar.enable_prev() self.win.change_prev_callback(self.win.go_to_home) self.kano_button.connect('button-release-event', self.apply_changes) self.kano_button.connect('key-release-event', self.apply_changes) horizontal_container = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=40) horizontal_container.set_valign(Gtk.Align.CENTER) # HDMI mode combo box self.mode_combo = KanoComboBox(max_display_items=7) self.mode_combo.connect('changed', self.on_mode_changed) # Fill list of modes modes = list_supported_modes() self.mode_combo.append('auto') mode_string = '{hdmi_group}:{hdmi_mode} {width}x{height} {refresh_rate}Hz {aspect_ratio}' if modes: for mode in modes: self.mode_combo.append(mode_string.format( hdmi_group=mode['group'], hdmi_mode=mode['mode'], width=mode['width'], height=mode['height'], refresh_rate=mode['rate'], aspect_ratio=mode['aspect_ratio'] )) horizontal_container.pack_start(self.mode_combo, False, False, 0) self.mode_combo.props.valign = Gtk.Align.CENTER # Select the current setting in the dropdown list saved_group, saved_mode = read_hdmi_mode() active_item = find_matching_mode(modes, saved_group, saved_mode) self.mode_combo.set_selected_item_index(active_item) self.init_item = active_item self.mode_index = active_item # Overscan button overscan_button = OrangeButton(_("Overscan")) horizontal_container.pack_end(overscan_button, False, False, 0) overscan_button.connect('button-release-event', self.go_to_overscan) self.box.pack_start(horizontal_container, False, False, 0) # Create Flip 180 checkbox flip_button = Gtk.CheckButton(_("Flip Screen")) flip_button.set_can_focus(False) flip_button.props.valign = Gtk.Align.CENTER flip_button.set_active(get_screen_value('display_rotate') == 2) flip_button.connect('clicked', self.flip) self.box.pack_start(flip_button, False, False, 0) self.kano_button.set_sensitive(False) # Add apply changes button under the main settings content self.win.show_all()
def __init__(self, win): # Show the Display brand and model self.model = get_model() info_message = ' (Changing this requires a reboot)' # And the current display resolution try: current_resolution = get_status()['resolution'] info_message += '\n\nCurrent resolution: {}'.format(current_resolution) except: pass Template.__init__( self, "Display", self.model + info_message, "APPLY CHANGES" ) self.win = win self.win.set_main_widget(self) self.win.top_bar.enable_prev() self.win.change_prev_callback(self.win.go_to_home) self.kano_button.connect("button-release-event", self.apply_changes) self.kano_button.connect("key-release-event", self.apply_changes) horizontal_container = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=40) horizontal_container.set_valign(Gtk.Align.CENTER) # HDMI mode combo box self.mode_combo = KanoComboBox(max_display_items=7) self.mode_combo.connect("changed", self.on_mode_changed) # Fill list of modes modes = list_supported_modes() self.mode_combo.append("auto") if modes: for v in modes: self.mode_combo.append(v) horizontal_container.pack_start(self.mode_combo, False, False, 0) self.mode_combo.props.valign = Gtk.Align.CENTER # Select the current setting in the dropdown list saved_group, saved_mode = read_hdmi_mode() active_item = find_matching_mode(modes, saved_group, saved_mode) self.mode_combo.set_selected_item_index(active_item) self.init_item = active_item self.mode_index = active_item # Overscan button overscan_button = OrangeButton("Overscan") horizontal_container.pack_end(overscan_button, False, False, 0) overscan_button.connect("button-release-event", self.go_to_overscan) self.box.pack_start(horizontal_container, False, False, 0) # Create Flip 180 checkbox flip_button = Gtk.CheckButton("Flip Screen") flip_button.set_can_focus(False) flip_button.props.valign = Gtk.Align.CENTER flip_button.set_active(get_config_value("display_rotate") == 2) flip_button.connect("clicked", self.flip) self.box.pack_start(flip_button, False, False, 0) self.kano_button.set_sensitive(False) # Add apply changes button under the main settings content self.win.show_all()
class SetSimpleOverscan(OverscanTemplate): def __init__(self, win, original_overscan=None): OverscanTemplate.__init__( self, win, _("Overscan"), _("This setting lets you adjust your screen's size."), original_overscan ) self.win.change_prev_callback(self.go_to_display) # Listen for key events self.key_press_handler = self.win.connect('key-press-event', self.on_key_press) # slider self.t_value = Gtk.Label() self.t_value.get_style_context().add_class('slider_label') self.t_scale = Gtk.HScale.new_with_range(0, get_overscan_limit(), 1) self.t_scale.set_value(self.overscan_values['top']) self.t_scale.set_size_request(400, 30) self.t_scale.connect('value_changed', self.adjust_all) self.t_scale.connect('value_changed', self.update_all_values) self.t_scale.set_draw_value(False) self.update_all_values(self.t_scale) box = Gtk.Box() box.pack_start(self.t_scale, False, False, 5) box.pack_start(self.t_value, False, False, 5) box.pack_start(self.reset_button, False, False, 25) align = Gtk.Alignment(xalign=0.6, xscale=0, yscale=0, yalign=0.5) align.add(box) # Advance button self.advanced_button = OrangeButton() self.advanced_button.connect('button_press_event', self.go_to_advanced) self.advanced_button.set_label(_("Advanced")) button_box = Gtk.ButtonBox() button_box.set_layout(Gtk.ButtonBoxStyle.SPREAD) button_box.pack_start(self.advanced_button, False, False, 15) button_box.pack_start(self.kano_button.align, False, False, 15) empty_label = Gtk.Label(" ") button_box.pack_start(empty_label, False, False, 0) self.pack_start(align, True, True, 0) self.pack_end(button_box, False, False, 30) self.win.show_all() def reset(self, widget=None, event=None): # Restore overscan if any if self.original_overscan != self.overscan_values: set_overscan_status(self.original_overscan) self.t_scale.set_value(self.original_overscan['top']) def go_to_advanced(self, event=None, arg=None): # Remove key press handler from screen self.win.disconnect(self.key_press_handler) self.win.clear_win() SetAdvancedOverscan(self.win, self.original_overscan) def on_key_press(self, widget, event): # Right arrow (65363) if not hasattr(event, 'keyval') or event.keyval == Gdk.KEY_Right: self.overscan_values['top'] += 1 self.overscan_values['bottom'] += 1 self.overscan_values['left'] += 1 self.overscan_values['right'] += 1 set_overscan_status(self.overscan_values) self.t_scale.set_value(self.overscan_values['top']) return # Left arrow (65361) if not hasattr(event, 'keyval') or event.keyval == Gdk.KEY_Left: self.overscan_values['top'] -= 1 self.overscan_values['bottom'] -= 1 self.overscan_values['left'] -= 1 self.overscan_values['right'] -= 1 set_overscan_status(self.overscan_values) self.t_scale.set_value(self.overscan_values['top']) return def update_all_values(self, widget): new_value = str(int(widget.get_value())) self.t_value.set_text(new_value)
def __init__(self, win): Gtk.Box.__init__(self, orientation=Gtk.Orientation.VERTICAL) self.win = win self.win.set_main_widget(self) self.win.top_bar.enable_prev() self.win.change_prev_callback(self.win.go_to_home) image = Gtk.Image.new_from_file(media + "/Graphics/about-screen.png") version_number, os_name = get_current_version() os_variant = read_file_contents('/etc/kanux_version_variant') version_align = self.create_align( "Kano OS: {name} v{version}".format(name=os_name, version=version_number), 'about_version' ) if os_variant: variant_align = self.create_align( "{variant}".format(variant=os_variant), 'about_version' ) space_align = self.create_align( _("Disk space used: {used}B / {total}B").format(**get_space_available()) ) try: celsius = u"{:.1f}\N{DEGREE SIGN}C".format(get_temperature()) except ValueError: celsius = "?" temperature_align = self.create_align( _(u"Temperature: {celsius}").format(celsius=celsius) ) model_align = self.create_align( _("Model: {model}").format(model=get_model_name()) ) terms_and_conditions = OrangeButton(_("Terms and conditions")) terms_and_conditions.connect( 'button_release_event', self.show_terms_and_conditions ) credits_button = OrangeButton(_("Meet the team")) credits_button.connect( 'button_release_event', self.show_credits ) self.kano_button = KanoButton(_("BACK")) self.kano_button.pack_and_align() hbox = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=0) hbox.pack_start(terms_and_conditions, False, False, 4) hbox.pack_start(credits_button, False, False, 4) hbutton_container = Gtk.Alignment( xalign=0.5, xscale=0, yalign=0, yscale=0 ) hbutton_container.add(hbox) image.set_margin_top(10) self.pack_start(image, False, False, 10) self.pack_start(version_align, False, False, 2) if os_variant: self.pack_start(variant_align, False, False, 2) self.pack_start(space_align, False, False, 1) self.pack_start(temperature_align, False, False, 1) self.pack_start(model_align, False, False, 1) self.pack_start(hbutton_container, False, False, 3) self.pack_start(self.kano_button.align, False, False, 10) self.kano_button.connect('button-release-event', self.win.go_to_home) self.kano_button.connect('key-release-event', self.win.go_to_home) # Refresh window self.win.show_all()
class OverscanTemplate(Gtk.Box): def __init__(self, win, title, description, original_overscan=None): Gtk.Box.__init__(self, orientation=Gtk.Orientation.VERTICAL) self.kano_button = KanoButton(_("APPLY CHANGES")) self.kano_button.connect('button-release-event', self.apply_changes) self.kano_button.pack_and_align() self.heading = Heading(title, description) self.pack_start(self.heading.container, False, False, 0) self.win = win self.win.set_main_widget(self) self.win.top_bar.enable_prev() # Launch pipe for the overscan c code launch_pipe() self.overscan_values = get_overscan_status() self.original_overscan = original_overscan # Pass original overscan values between the classes # If original_overscan hasn't been generated yet, get it from current # overscan status. Alternatively, maybe read this from a file in future if original_overscan is None: self.original_overscan = get_overscan_status() # Reset button self.reset_button = OrangeButton() reset_icon_path = os.path.join(common.media, '/Icons/reset.png') reset_image = Gtk.Image().new_from_file(reset_icon_path) self.reset_button.set_image(reset_image) self.reset_button.connect('button_press_event', self.reset) def apply_changes(self, button, event): # NB, write_overscan_values ends the transaction write_overscan_values(self.overscan_values) self.original_overscan = self.overscan_values # Tell user to reboot to see changes common.need_reboot = True self.go_to_display() def adjust(self, adj, varname): self.overscan_values[varname] = int(adj.get_value()) set_overscan_status(self.overscan_values) def adjust_all(self, adj): self.overscan_values['top'] = int(adj.get_value()) self.overscan_values['bottom'] = int(adj.get_value()) self.overscan_values['left'] = int(adj.get_value()) self.overscan_values['right'] = int(adj.get_value()) set_overscan_status(self.overscan_values) def go_to_display(self, widget=None, button=None): self.reset() self.win.clear_win() SetDisplay(self.win) def reset(self, widget=None, event=None): pass
class UserListView(Gtk.Grid): HEIGHT = 250 WIDTH = 1 # not important def __init__(self): Gtk.Grid.__init__(self) self.get_style_context().add_class('password') self.set_row_spacing(10) title = Heading(_('Select Account'), _('Log in to which account?')) self.attach(title.container, 0, 0, 2, 1) self.scrolled_window = ScrolledWindow() self.scrolled_window.set_size_request(self.WIDTH, self.HEIGHT) self.box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL) self.box.set_spacing(10) self.box.set_margin_left(10) self.box.set_margin_right(10) self.scrolled_window.add(self.box) self.attach(self.scrolled_window, 0, 1, 2, 1) self.last_username = get_last_user() self._populate() self.add_account_btn = OrangeButton(_('Add Account')) self.add_account_btn.connect('clicked', self._btn_add_account_pressed) self.attach(self.add_account_btn, 0, 2, 1, 1) self.shutdown_btn = OrangeButton(_('Shutdown')) self.shutdown_btn.connect('clicked', self._btn_shutdown_pressed) self.attach(self.shutdown_btn, 1, 2, 1, 1) def _populate(self): # Populate list user_list = KanoUserList() for user_name in user_list.get_users(): logger.debug('adding user {}'.format(user_name)) self.add_item(user_name) def add_item(self, username): user = User(username) self.box.pack_start(user, False, False, 0) if username == self.last_username: user.grab_focus() def _btn_add_account_pressed(self, event=None, button=None): logger.debug('opening new user dialog') win = self.get_toplevel() win.go_to_newuser() def _btn_shutdown_pressed(self, event=None, button=None): shutdown_dialog = KanoDialog( title_text=_('Shutting down..'), description_text=_( 'Are you sure you want to shutdown your Kano now?'), button_dict=[{ 'label': _('Cancel').upper(), 'color': 'green', 'return_value': False }, { 'label': _('SHUTDOWN').upper(), 'color': 'orange', 'return_value': True }]) shutdown_dialog.dialog.set_position(Gtk.WindowPosition.CENTER_ALWAYS) poweroff = shutdown_dialog.run() if poweroff: LightDM.shutdown()
class ParentalConfig(Template): def __init__(self, win): Template.__init__( self, "Parental lock", "Configure your parental lock settings", "APPLY CHANGES", win.is_plug(), True ) self.parental_level = Gtk.VScale( adjustment=Gtk.Adjustment(value=0, lower=0, upper=3, step_incr=1, page_incr=0, page_size=0)) self.parental_level.get_style_context().add_class('parental_slider') self.parental_level.set_draw_value(False) self.parental_level.set_round_digits(0) self.parental_level.set_inverted(True) self.parental_level.set_value(get_setting('Parental-level')) self.parental_level.connect('value-changed', self._value_change_handler) self._parental_labels = [ ( Gtk.Label("Low Settings"), Gtk.Label("Block predefined blacklisted websites and\nactivates SafeSearch on Google and Youtube") ), ( Gtk.Label("Medium Settings"), Gtk.Label("Use safe DNS servers to filter all traffic") ), ( Gtk.Label("High Settings"), Gtk.Label("Enable all filters and restrict search engine access") ), ( Gtk.Label("Ultimate Settings"), Gtk.Label("Only allow access to Kano World activities") ) ] self.blacklist_button = OrangeButton("Configure allowed/blocked") self.blacklist_button.connect("button-press-event", self.go_to_blacklist) self._value_change_handler(self.parental_level) parental_level_grid = Gtk.Grid() parental_level_grid.attach(self.parental_level, 0, 0, 1, 7) parental_level_grid.attach(self._parental_labels[3][0], 1, 0, 1, 1) parental_level_grid.attach(self._parental_labels[3][1], 1, 1, 1, 1) parental_level_grid.attach(self._parental_labels[2][0], 1, 2, 1, 1) parental_level_grid.attach(self._parental_labels[2][1], 1, 3, 1, 1) parental_level_grid.attach(self._parental_labels[1][0], 1, 4, 1, 1) parental_level_grid.attach(self._parental_labels[1][1], 1, 5, 1, 1) parental_level_grid.attach(self._parental_labels[0][0], 1, 6, 1, 1) parental_level_grid.attach(self._parental_labels[0][1], 1, 7, 1, 1) self.box.set_spacing(20) self.box.pack_start(parental_level_grid, False, False, 0) self.box.pack_start(self.blacklist_button, False, False, 0) self.win = win self.win.set_main_widget(self) self.set_prev_callback(self.go_to_advanced) self.win.change_prev_callback(self.win.go_to_home) self.win.top_bar.enable_prev() self.kano_button.connect('button-release-event', self.apply_changes) self.kano_button.connect('key-release-event', self.apply_changes) self.win.show_all() def go_to_advanced(self, widget): from kano_settings.set_advanced import SetAdvanced self.win.clear_win() SetAdvanced(self.win) def apply_changes(self, button, event): pw_dialog = ParentalPasswordDialog(self.win) if not pw_dialog.verify(): return level = self.parental_level.get_value() set_parental_level(level) set_setting('Parental-level', level) # track which parental control level people use track_data("parental-control-level-changed", { "level": level }) if level == 3.0: # If on the highest parental control, prompt user to relaunch # the browser kdialog = KanoDialog( title_text='Settings', description_text=("If any browsers are open, please relaunch " "them for this setting to take effect"), parent_window=self.win ) kdialog.run() else: # Only reboot for the lower parental controls common.need_reboot = True self.win.go_to_home() def go_to_blacklist(self, button, event): self.win.clear_win() AllowedSites(self.win) def _value_change_handler(self, gtk_range): for level, (title, desc) in enumerate(self._parental_labels): style_title = title.get_style_context() style_desc = desc.get_style_context() if gtk_range.get_value() == level: style_title.add_class('parental_activated') style_desc.add_class('parental_desc_activated') self.blacklist_button.set_sensitive(not level == 3.0) else: style_title.remove_class('parental_activated') style_title.add_class('normal_label') style_desc.remove_class('parental_desc_activated') style_desc.add_class('normal_label')
class UserListView(Gtk.Grid): HEIGHT = 250 WIDTH = 1 # not important def __init__(self): Gtk.Grid.__init__(self) self.get_style_context().add_class('password') self.set_row_spacing(10) title = Heading(_('Select Account'), _('Log in to which account?')) self.attach(title.container, 0, 0, 2, 1) self.scrolled_window = ScrolledWindow() self.scrolled_window.set_size_request(self.WIDTH, self.HEIGHT) self.box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL) self.box.set_spacing(10) self.box.set_margin_left(10) self.box.set_margin_right(10) self.scrolled_window.add(self.box) self.attach(self.scrolled_window, 0, 1, 2, 1) self.last_username = get_last_user() self._populate() self.add_account_btn = OrangeButton(_('Add Account')) self.add_account_btn.connect('clicked', self._btn_add_account_pressed) self.attach(self.add_account_btn, 0, 2, 1, 1) self.shutdown_btn = OrangeButton(_('Shutdown')) self.shutdown_btn.connect('clicked', self._btn_shutdown_pressed) self.attach(self.shutdown_btn, 1, 2, 1, 1) def _populate(self): # Populate list user_list = KanoUserList() for user_name in user_list.get_users(): logger.debug('adding user {}'.format(user_name)) self.add_item(user_name) def add_item(self, username): user = User(username) self.box.pack_start(user, False, False, 0) if username == self.last_username: user.grab_focus() def _btn_add_account_pressed(self, event=None, button=None): logger.debug('opening new user dialog') win = self.get_toplevel() win.go_to_newuser() def _btn_shutdown_pressed(self, event=None, button=None): shutdown_dialog = KanoDialog(title_text='Shutting down..', description_text='Are you sure you want to shutdown your Kano now?', button_dict=[ { 'label': _('Cancel').upper(), 'color': 'green', 'return_value': False }, { 'label': _('SHUTDOWN').upper(), 'color': 'orange', 'return_value': True } ]) shutdown_dialog.dialog.set_position(Gtk.WindowPosition.CENTER_ALWAYS) poweroff = shutdown_dialog.run() if poweroff: LightDM.shutdown()
class PageControl(Gtk.Alignment): __gsignals__ = { 'back-button-clicked': (GObject.SIGNAL_RUN_FIRST, None, ()), 'next-button-clicked': (GObject.SIGNAL_RUN_FIRST, None, ()) } def __init__(self, num_of_pages=3, selected_page=1, back_text=_("BACK"), next_text=_("NEXT")): Gtk.Alignment.__init__(self, xalign=0.5, xscale=0) self.num_of_pages = num_of_pages self.selected = selected_page self._box = Gtk.Box() self.add(self._box) # The back button has subtly different styling to the next button # When the back button is disabled, it goes invisible, while # the NEXT button goes grey. self._back_button = OrangeButton(back_text) self._back_button.connect('clicked', self.back_button_clicked) attach_cursor_events(self._back_button) self._next_button = OrangeButton(next_text) self._next_button.connect('clicked', self.next_button_clicked) attach_cursor_events(self._next_button) self.dot_box = Gtk.Box() self._create_progress_dots(self.selected) self._box.pack_start(self._back_button, False, False, 40) self._box.pack_start(self.dot_box, False, False, 0) self._box.pack_start(self._next_button, False, False, 40) if self.selected == 1: self._back_button.set_sensitive(False) if self.selected == self.num_of_pages: self._next_button.set_sensitive(False) # self.connect('next-button-clicked', self.select_dot) # self.connect('back-button-clicked', self.select_dot) @property def back_button(self): return self._back_button @property def next_button(self): return self._next_button def disable_buttons(self): self._next_button.set_sensitive(False) self._back_button.set_sensitive(False) def enable_buttons(self): self._next_button.set_sensitive(True) self._back_button.set_sensitive(True) def enable_next(self): self._next_button.set_sensitive(True) def enable_back(self): self._back_button.set_sensitive(True) def disable_next(self): self._next_button.set_sensitive(False) def disable_back(self): self._back_button.set_sensitive(False) def set_back_button_text(self, text): self._back_button.set_label(text) def set_next_button_text(self, text): self._next_button.set_label(text) def get_back_button(self): return self._back_button def get_next_button(self): return self._next_button # TODO: these are expanding to fill the parent container. def _create_progress_dots(self, index): '''Index is a number from1 to 3, and represents which is the selected dot (i.e selected page number) ''' logger.debug("Creating dots") for child in self.dot_box.get_children(): self.dot_box.remove(child) for i in range(self.num_of_pages): if i + 1 == index: dot = self.selected_dot() dot.set_margin_left(3) dot.set_margin_right(3) dot.set_margin_top(9) dot.set_margin_bottom(9) else: dot = self.unselected_dot() dot.set_margin_left(5) dot.set_margin_right(5) dot.set_margin_top(11) dot.set_margin_bottom(11) self.dot_box.pack_start(dot, False, False, 0) self.dot_box.show_all() def unselected_dot(self): '''Produce an unselected grey spot ''' grey_dot = Gtk.EventBox() grey_dot.get_style_context().add_class('grey_dot') grey_dot.set_size_request(6, 6) return grey_dot def selected_dot(self): '''Produce a selected orange dot ''' orange_dot = Gtk.EventBox() orange_dot.get_style_context().add_class('orange_dot') orange_dot.set_size_request(10, 10) return orange_dot # these functions may not be needed def select_dot(self, widget, index): '''index is the integers 1 - 3, to represent the page numbers ''' if index not in range(self.num_of_pages): return self._create_progress_dots(index) if index == 1: self._back_button.set_sensitive(False) self._next_button.set_sensitive(True) elif index == self.num_of_pages: self._next_button.set_sensitive(False) self._back_button.set_sensitive(True) else: self._next_button.set_sensitive(True) self._back_button.set_sensitive(True) self.show_all() # These give external windows a way of knowing when these buttons have been # clicked, without mixing up the classes def back_button_clicked(self, widget): # Are these needed? # self.selected -= 1 self.emit('back-button-clicked') # , self.selected) def next_button_clicked(self, widget): # self.selected += 1 self.emit('next-button-clicked') # , self.selected)
def __init__(self, win): Template.__init__( self, "Parental lock", "Configure your parental lock settings", "APPLY CHANGES", win.is_plug(), True ) self.parental_level = Gtk.VScale( adjustment=Gtk.Adjustment(value=0, lower=0, upper=3, step_incr=1, page_incr=0, page_size=0)) self.parental_level.get_style_context().add_class('parental_slider') self.parental_level.set_draw_value(False) self.parental_level.set_round_digits(0) self.parental_level.set_inverted(True) self.parental_level.set_value(get_setting('Parental-level')) self.parental_level.connect('value-changed', self._value_change_handler) self._parental_labels = [ ( Gtk.Label("Low Settings"), Gtk.Label("Block predefined blacklisted websites and\nactivates SafeSearch on Google and Youtube") ), ( Gtk.Label("Medium Settings"), Gtk.Label("Use safe DNS servers to filter all traffic") ), ( Gtk.Label("High Settings"), Gtk.Label("Enable all filters and restrict search engine access") ), ( Gtk.Label("Ultimate Settings"), Gtk.Label("Only allow access to Kano World activities") ) ] self.blacklist_button = OrangeButton("Configure allowed/blocked") self.blacklist_button.connect("button-press-event", self.go_to_blacklist) self._value_change_handler(self.parental_level) parental_level_grid = Gtk.Grid() parental_level_grid.attach(self.parental_level, 0, 0, 1, 7) parental_level_grid.attach(self._parental_labels[3][0], 1, 0, 1, 1) parental_level_grid.attach(self._parental_labels[3][1], 1, 1, 1, 1) parental_level_grid.attach(self._parental_labels[2][0], 1, 2, 1, 1) parental_level_grid.attach(self._parental_labels[2][1], 1, 3, 1, 1) parental_level_grid.attach(self._parental_labels[1][0], 1, 4, 1, 1) parental_level_grid.attach(self._parental_labels[1][1], 1, 5, 1, 1) parental_level_grid.attach(self._parental_labels[0][0], 1, 6, 1, 1) parental_level_grid.attach(self._parental_labels[0][1], 1, 7, 1, 1) self.box.set_spacing(20) self.box.pack_start(parental_level_grid, False, False, 0) self.box.pack_start(self.blacklist_button, False, False, 0) self.win = win self.win.set_main_widget(self) self.set_prev_callback(self.go_to_advanced) self.win.change_prev_callback(self.win.go_to_home) self.win.top_bar.enable_prev() self.kano_button.connect('button-release-event', self.apply_changes) self.kano_button.connect('key-release-event', self.apply_changes) self.win.show_all()
class KanoDialog: CSS_PATH = os.path.join(common_css_dir, "dialog.css") # button_dict includes the button text, color and button return values # It can either be a dictionary for backwards compatibility, or a list def __init__( self, title_text="", description_text="", button_dict=None, widget=None, has_entry=False, has_list=False, scrolled_text="", global_style="", parent_window=None, orange_info=None, hide_from_taskbar=False, ): self.title_text = title_text self.description_text = description_text self.widget = widget self.button_info = button_dict self.returnvalue = 0 self.has_entry = has_entry self.has_list = has_list self.scrolled_text = scrolled_text self.global_style = global_style self.parent_window = parent_window self.orange_info = orange_info self.dialog = Gtk.Dialog() self.dialog.set_decorated(False) self.dialog.set_resizable(False) # TODO: review this - should this always be set? # self.dialog.set_keep_above(True) self.dialog.set_skip_taskbar_hint(hide_from_taskbar) self.dialog.set_border_width(5) apply_styling_to_widget(self.dialog, self.CSS_PATH) apply_colours_to_widget(self.dialog) # if widget or an orange button is added, to get styling correct # the global_styling property should be on. # TODO: is this needed any more? if global_style or (widget is not None or orange_info is not None): apply_common_to_screen() content_area, action_area = self.__colour_dialog_background() self.title = Heading(self.title_text, self.description_text) content_area.pack_start(self.title.container, False, False, 0) # If button_info is None, or an empty dictionary or list, default to an OK button if not self.button_info: button_defaults["label"] = _("OK") self.button_info = [button_defaults] # convert button dictionary to list if isinstance(self.button_info, dict): self.__convert_dict_to_list() kano_button_box = self.__generate_buttons() if orange_info is not None: button_container = self.__add_orange_button(orange_info, kano_button_box) else: button_container = Gtk.Alignment() button_container.add(kano_button_box) # annoying uneven alignment - cannot seem to centre y position button_container.set_padding(6, 3, 0, 0) action_area.pack_start(button_container, False, False, 0) # Add scrolled window if self.scrolled_text: scrolledwindow = self.__add_scrolled_window() content_area.pack_start(scrolledwindow, False, False, 0) # or add widget elif self.widget is not None: content_area.pack_start(self.widget, False, False, 0) # Set keyboard focus on first button if no entry if not has_entry: self.buttons[0].grab_focus() def __add_scrolled_window(self): text = Gtk.TextView() text.get_buffer().set_text(self.scrolled_text) text.set_wrap_mode(Gtk.WrapMode.WORD) text.set_editable(False) scrolledwindow = ScrolledWindow() scrolledwindow.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC) scrolledwindow.add_with_viewport(text) scrolledwindow.set_size_request(400, 200) scrolledwindow.apply_styling_to_widget(wide=False) return scrolledwindow def __add_orange_button(self, orange_info, kano_button_box): orange_text = orange_info["name"] orange_return_value = orange_info["return_value"] button_container = Gtk.ButtonBox(spacing=10) button_container.set_layout(Gtk.ButtonBoxStyle.SPREAD) self.orange_button = OrangeButton(orange_text) self.orange_button.connect("button-release-event", self.exit_dialog, orange_return_value) button_container.pack_start(self.orange_button, False, False, 0) button_container.pack_start(kano_button_box, False, False, 0) # The empty label is to centre the kano_button label = Gtk.Label(" ") button_container.pack_start(label, False, False, 0) return button_container def __colour_dialog_background(self): content_area = self.dialog.get_content_area() self.content_background = Gtk.EventBox() self.add_style(self.content_background, "white") self.content_background.set_size_request(140, 140) content_area.reparent(self.content_background) action_area = self.dialog.get_action_area() self.action_background = Gtk.EventBox() self.add_style(self.action_background, "white") action_area.reparent(self.action_background) action_area.set_layout(Gtk.ButtonBoxStyle.CENTER) # Set area around the buttons grey by default self.set_action_background("grey") container = Gtk.Box(orientation=Gtk.Orientation.VERTICAL) container.add(self.content_background) container.add(self.action_background) self.dialog.add(container) return content_area, action_area def __convert_dict_to_list(self): button_list = [] for button_name, button_arguments in self.button_info.iteritems(): button_arguments["label"] = button_name button_list.append(button_arguments) self.button_info = button_list def __generate_buttons(self): self.buttons = [] kano_button_box = Gtk.Box() for button in self.button_info: for argument, value in button_defaults.iteritems(): # Use default info if not provided if argument not in button: button[argument] = value # Create default return values for OK and CANCEL buttons if argument == "return_value": if hasattr(button, "label"): if button["label"] == _("OK"): button["return_value"] = 0 elif button["label"] == _("CANCEL"): button["return_value"] = 1 if argument == "color": if button["label"] == _("CANCEL"): button["color"] = "red" color = button["color"] return_value = button["return_value"] button_name = button["label"] button = KanoButton(button_name) button.set_color(color) button.connect("button-release-event", self.exit_dialog, return_value) button.connect("key-release-event", self.exit_dialog, return_value) self.buttons.append(button) kano_button_box.pack_start(button, False, False, 6) return kano_button_box def add_style(self, widget, app_class): apply_styling_to_widget(widget, self.CSS_PATH) style = widget.get_style_context() style.add_class(app_class) def exit_dialog(self, button, event, return_value): # 65293 is the ENTER keycode if not hasattr(event, "keyval") or event.keyval == 65293: self.returnvalue = return_value # If we have an entry if self.has_entry: # We have to click an OK button to get entry value # May want to change this logic later to be more flexible if unicode(button.get_label().decode("utf8")) == _("OK"): self.returnvalue = self.widget.get_text() elif self.has_list: # get selected radio button only if press the OK button if unicode(button.get_label().decode("utf8")) == _("OK"): self.returnvalue = radio_returnvalue # TODO: change the structure so we emit different signals depending on the button clicked self.dialog.response(Gtk.ResponseType.OK) # Indicate that the signal has been handled return True def run(self): if self.parent_window is not None: # Make the dialog always above the parent window self.dialog.set_transient_for(self.parent_window) if self.parent_window is not None and hasattr(self.parent_window, "blur") and callable(self.parent_window.blur): self.parent_window.blur() self.dialog.show_all() self.dialog.set_icon_name("kano-dialog") self.dialog.run() self.dialog.destroy() if ( self.parent_window is not None and hasattr(self.parent_window, "unblur") and callable(self.parent_window.unblur) ): self.parent_window.unblur() return self.returnvalue def close(self): """ Use this method if your app is nesting several Kano Dialogs, and you need to step through without stacking them up. """ self.dialog.destroy() # Dispatch events so Gtk has a chance to close the dialog while Gtk.events_pending(): Gtk.main_iteration() def set_text(self, title_text, description_text): self.title_text = title_text self.description_text = description_text self.title.set_text(title_text, description_text) def set_action_background(self, color): for c in background_colors: self.action_background.get_style_context().add_class(c) self.action_background.get_style_context().add_class(color)
def __init__(self, win): Gtk.Box.__init__(self, orientation=Gtk.Orientation.VERTICAL) self.win = win self.win.set_main_widget(self) self.win.top_bar.enable_prev() self.win.change_prev_callback(self.win.go_to_home) image = Gtk.Image.new_from_file(media + "/Graphics/about-screen.png") version_align = self.create_align( "Kano OS v.{version}".format(version=get_current_version()), 'about_version' ) space_align = self.create_align( _("Disk space used: {used}B / {total}B").format(**get_space_available()) ) try: celsius = u"{:.1f}\N{DEGREE SIGN}C".format(get_temperature()) except ValueError: celsius = "?" temperature_align = self.create_align( _(u"Temperature: {celsius}").format(celsius=celsius) ) model_align = self.create_align( _("Model: {model}").format(model=get_model_name()) ) terms_and_conditions = OrangeButton(_("Terms and conditions")) terms_and_conditions.connect( 'button_release_event', self.show_terms_and_conditions ) credits_button = OrangeButton(_("Meet the team")) credits_button.connect( 'button_release_event', self.show_credits ) changelog_button = OrangeButton(_("Changelog")) changelog_button.connect( 'button_release_event', self.show_changelog ) self.kano_button = KanoButton(_("BACK")) self.kano_button.pack_and_align() hbox = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=0) hbox.pack_start(terms_and_conditions, False, False, 4) hbox.pack_start(credits_button, False, False, 4) hbox.pack_start(changelog_button, False, False, 4) hbutton_container = Gtk.Alignment( xalign=0.5, xscale=0, yalign=0, yscale=0 ) hbutton_container.add(hbox) image.set_margin_top(10) self.pack_start(image, False, False, 10) self.pack_start(version_align, False, False, 2) self.pack_start(space_align, False, False, 1) self.pack_start(temperature_align, False, False, 1) self.pack_start(model_align, False, False, 1) self.pack_start(hbutton_container, False, False, 3) self.pack_start(self.kano_button.align, False, False, 10) self.kano_button.connect('button-release-event', self.win.go_to_home) self.kano_button.connect('key-release-event', self.win.go_to_home) # Refresh window self.win.show_all()
def _initialise_window(self): ''' Inititlaises the gtk window ''' self.last_click = 0 self.app_name_opened = 'feedback-widget-opened' self.typeahead = None self.help_tip_message = _("Type your feedback here!") self.rotating_mode = True self.in_submit = False apply_styling_to_screen(media_dir() + 'css/widget.css') ScrolledWindow.apply_styling_to_screen(wide=False) self.visible = False self.set_hexpand(False) self.set_decorated(False) self.set_resizable(False) self.set_keep_above(False) self.set_property('skip-taskbar-hint', True) self._grid = grid = Gtk.Grid(hexpand=True, vexpand=True) qmark = Gtk.Label('?') qmark.get_style_context().add_class('qmark') qmark_centering = Gtk.Alignment(xalign=0.5, yalign=0.5) qmark_centering.add(qmark) qmark_box = Gtk.EventBox() qmark_box.get_style_context().add_class('qmark_box') qmark_box.add(qmark_centering) qmark_box.set_size_request(self.HEIGHT_COMPACT, self.HEIGHT_COMPACT) grid.attach(qmark_box, 0, 0, 1, 1) self._prompt = prompt = Gtk.Label(self.wprompts.get_current_prompt(), hexpand=False) prompt.get_style_context().add_class('prompt') prompt.set_justify(Gtk.Justification.LEFT) prompt.set_size_request(410, -1) prompt.set_line_wrap(True) prompt_align = Gtk.Alignment(xalign=0.5, yalign=0.5) prompt_align.add(prompt) prompt_ebox = Gtk.EventBox() prompt_ebox.add(prompt_align) grid.attach(prompt_ebox, 1, 0, 2, 1) self._x_button = x_button = Gtk.Button('x') x_button.set_size_request(20, 20) x_button.connect('clicked', self._shrink) x_button.get_style_context().add_class('x_button') x_button.set_margin_right(20) x_button_ebox = Gtk.EventBox() x_button_ebox.add(x_button) x_button_ebox.connect("realize", self._set_cursor_to_hand_cb) x_button_align = Gtk.Alignment(xalign=1, yalign=0.5, xscale=0, yscale=0) x_button_align.add(x_button_ebox) grid.attach(x_button_align, 3, 0, 1, 1) self._gray_box = gray_box = Gtk.EventBox() gray_box.get_style_context().add_class('gray_box') gray_box.set_size_request(-1, self.HEIGHT_EXPANDED - self.HEIGHT_COMPACT) gray_box_centering = Gtk.Alignment(xalign=0, yalign=0, xscale=1.0, yscale=1.0) gray_box_centering.add(gray_box) grid.attach(gray_box_centering, 0, 1, 1, 2) self._ebox = Gtk.EventBox() self._ebox.get_style_context().add_class('scrolled_win') grid.attach(self._ebox, 1, 1, 2, 1) self._pack_input_widget() self._send = send = OrangeButton('SEND') apply_styling_to_widget(send.label, media_dir() + 'css/widget.css') send.set_sensitive(False) send.connect('clicked', self._send_clicked) send.set_margin_left(10) send.set_margin_right(20) send.set_margin_top(10) send.set_margin_bottom(15) send_align = Gtk.Alignment(xalign=1, yalign=0.5, xscale=0, yscale=0) send_align.add(send) grid.attach(send_align, 3, 2, 1, 1) self.set_main_widget(grid) self.show_all() self._dont_shrink = False self._shrink() self.connect("focus-out-event", self._shrink) self.connect("button-press-event", self._toggle)