class EditToolbar(activity.EditToolbar): def __init__(self, _parent): activity.EditToolbar.__init__(self) self._parent = _parent self.undo.connect('clicked', self.__undo_cb) self.redo.connect('clicked', self.__redo_cb) self.copy.connect('clicked', self.__copy_cb) self.paste.connect('clicked', self.__paste_cb) menu_item = MenuItem(_('Cut')) menu_item.connect('activate', self.__cut_cb) menu_item.show() self.copy.get_palette().menu.append(menu_item) self.insert(gtk.SeparatorToolItem(), -1) self.erase_button = ToolButton('edit-delete') self.erase_button.set_tooltip(_('Erase selected thought(s)')) self.erase_button.connect('clicked', self.__delete_cb) self.insert(self.erase_button, -1) self.show_all() self.clipboard = gtk.Clipboard() self.copy.child.set_sensitive(False) self.paste.child.set_sensitive(False) self.erase_button.set_sensitive(False) def __undo_cb(self, button): self._parent._undo.undo_action(None) def __redo_cb(self, button): self._parent._undo.redo_action(None) def __cut_cb(self, event): self._parent._main_area.cut_clipboard(self.clipboard) def __copy_cb(self, event): self._parent._main_area.copy_clipboard(self.clipboard) def __paste_cb(self, event): self._parent._main_area.paste_clipboard(self.clipboard) def __delete_cb(self, widget): self._stop_moving() self.stop_dragging() self._parent._main_area.delete_selected_elements() def stop_dragging(self): if self._parent._main_area.is_dragging(): self._parent._main_area.drag_menu_cb(self._sw, False) def _stop_moving(self): self._parent._main_area.move_mode = False
class EditToolbar(activity.EditToolbar): def __init__(self, _parent): activity.EditToolbar.__init__(self) self._parent = _parent self.undo.connect('clicked', self.__undo_cb) self.redo.connect('clicked', self.__redo_cb) self.copy.connect('clicked', self.__copy_cb) self.paste.connect('clicked', self.__paste_cb) menu_item = MenuItem(_('Cut')) menu_item.connect('activate', self.__cut_cb) menu_item.show() self.copy.get_palette().menu.append(menu_item) self.insert(gtk.SeparatorToolItem(), -1) self.erase_button = ToolButton('edit-delete') self.erase_button.set_tooltip(_('Erase selected thought(s)')) self.erase_button.connect('clicked', self.__delete_cb) self.insert(self.erase_button, -1) self.show_all() self.clipboard = gtk.Clipboard() self.copy.child.set_sensitive(False) self.paste.child.set_sensitive(False) self.erase_button.set_sensitive(False) def __undo_cb(self, button): self._parent._undo.undo_action(None) def __redo_cb(self, button): self._parent._undo.redo_action(None) def __cut_cb(self, event): self._parent._main_area.cut_clipboard(self.clipboard) def __copy_cb(self, event): self._parent._main_area.copy_clipboard(self.clipboard) def __paste_cb(self, event): self._parent._main_area.paste_clipboard(self.clipboard) def __delete_cb(self, widget): self._stop_moving() self.stop_dragging() self._parent._main_area.delete_selected_elements() def stop_dragging(self): if self._parent._main_area.is_dragging(): self._parent._main_area.drag_menu_cb(self._sw, False) def _stop_moving(self): self._parent._main_area.move_mode = False
class Avatars(gtk.VBox): def __init__(self, btnfunction, loadfunction, win, path="none"): super(Avatars, self).__init__() win.set_title(_('Select a avatar')) win.set_decorated(False) win.set_position(gtk.WIN_POS_CENTER) y = gtk.gdk.screen_height() - 100 win.set_size_request(gtk.gdk.screen_width() - 100, y) self.win = win scroll = gtk.ScrolledWindow() scroll.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC) self.hbox = gtk.HBox() self.show_all() self.function = btnfunction self.a = 0 self.vbx = gtk.VBox() self.vbx.pack_start(self.hbox, False, False, 6) self.eventbox = gtk.EventBox() self.eventbox.modify_bg(gtk.STATE_NORMAL, gtk.gdk.color_parse('white')) self.eventbox.add(self.vbx) scroll.add_with_viewport(self.eventbox) #### # Sugar Style #### tl = gtk.Toolbar() tl.modify_bg(gtk.STATE_NORMAL, gtk.gdk.color_parse('black')) self.loadfromjournal = ToolButton('open-from-journal') self.loadfromjournal.set_tooltip(_('Load from journal')) self.loadfromjournal.connect('clicked', loadfunction, win) self.accept = ToolButton('dialog-ok') self.accept.set_tooltip(_('Accept')) self.cancel = ToolButton('gtk-cancel') self.cancel.set_tooltip(_('Cancel')) self.cancel.connect('clicked', lambda x: win.destroy()) sep = gtk.SeparatorToolItem() sep.set_expand(True) sep.props.draw = False tl.insert(self.loadfromjournal, 0) tl.insert(sep, 1) tl.insert(self.accept, 2) tl.insert(self.cancel, 3) tl.set_size_request(55, -1) self.pack_start(tl, False, False, 0) self.eventbox.add(scroll) self.pack_end(scroll, True, True, 0) #### self.path = None self.actual = None for x in os.listdir('avatars'): if path != "none": if path == os.path.join(os.getcwd(), 'avatars', x): sensitive = False else: sensitive = True else: sensitive = True self._gen_avatars(x, sensitive) gobject.timeout_add(10, self._check) def _check(self): a = str(type(self.path)).lower() if 'none' in a: self.accept.set_sensitive(False) else: self.accept.set_sensitive(True) return True def _gen_avatars(self, name, sensi): path = os.path.join(os.getcwd(), 'avatars', name) button = gtk.Button() if not sensi: self.actual = button button.set_sensitive(sensi) button.set_tooltip_text(path) image = gtk.Image() pix = gtk.gdk.pixbuf_new_from_file_at_size(path, 100, 100) image.set_from_pixbuf(pix) button.add(image) button.connect('clicked', self._set_path) if not self.a + 1 == 6: self.hbox.pack_start(button, False, False, 0) self.a += 1 else: self.hbox = gtk.HBox() self.vbx.pack_start(self.hbox, False, False, 6) self.hbox.pack_start(button, False, False, 0) self.a = 0 button.props.has_tooltip = False self.show_all() def _set_path(self, widget): try: self.actual.set_sensitive(True) except: pass self.path = widget.get_tooltip_text() self.accept.connect('clicked', self.function, self.path, self.win) widget.set_sensitive(False) self.actual = widget
class ViewToolbar(gtk.Toolbar): __gtype_name__ = 'ViewToolbar' __gsignals__ = { 'go-fullscreen': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE, ([])) } def __init__(self, view): gtk.Toolbar.__init__(self) self._view = view self._zoom_out = ToolButton('zoom-out') self._zoom_out.set_tooltip(_('Zoom out')) self._zoom_out.connect('clicked', self._zoom_out_cb) self.insert(self._zoom_out, -1) self._zoom_out.show() self._zoom_in = ToolButton('zoom-in') self._zoom_in.set_tooltip(_('Zoom in')) self._zoom_in.connect('clicked', self._zoom_in_cb) self.insert(self._zoom_in, -1) self._zoom_in.show() self._zoom_tofit = ToolButton('zoom-best-fit') self._zoom_tofit.set_tooltip(_('Fit to window')) self._zoom_tofit.connect('clicked', self._zoom_tofit_cb) self.insert(self._zoom_tofit, -1) self._zoom_tofit.show() self._zoom_original = ToolButton('zoom-original') self._zoom_original.set_tooltip(_('Original size')) self._zoom_original.connect('clicked', self._zoom_original_cb) self.insert(self._zoom_original, -1) self._zoom_original.show() spacer = gtk.SeparatorToolItem() spacer.props.draw = False self.insert(spacer, -1) spacer.show() self._rotate_anticlockwise = ToolButton('rotate_anticlockwise') self._rotate_anticlockwise.set_tooltip(_('Rotate anticlockwise')) self._rotate_anticlockwise.connect('clicked', self._rotate_anticlockwise_cb) self.insert(self._rotate_anticlockwise, -1) self._rotate_anticlockwise.show() self._rotate_clockwise = ToolButton('rotate_clockwise') self._rotate_clockwise.set_tooltip(_('Rotate clockwise')) self._rotate_clockwise.connect('clicked', self._rotate_clockwise_cb) self.insert(self._rotate_clockwise, -1) self._rotate_clockwise.show() spacer = gtk.SeparatorToolItem() spacer.props.draw = False self.insert(spacer, -1) spacer.show() self._fullscreen = ToolButton('view-fullscreen') self._fullscreen.set_tooltip(_('Fullscreen')) self._fullscreen.connect('clicked', self._fullscreen_cb) self.insert(self._fullscreen, -1) self._fullscreen.show() def _zoom_in_cb(self, button): self._zoom_in.set_sensitive(self._view.zoom_in()) self._zoom_out.set_sensitive(True) def _zoom_out_cb(self, button): self._zoom_out.set_sensitive(self._view.zoom_out()) self._zoom_in.set_sensitive(True) def _zoom_tofit_cb(self, button): zoom = self._view.calculate_optimal_zoom() self._view.set_zoom(zoom) def _zoom_original_cb(self, button): self._view.set_zoom(1) def _rotate_anticlockwise_cb(self, button): angle = self._view.get_property('angle') self._view.set_angle(angle + 90) def _rotate_clockwise_cb(self, button): angle = self._view.get_property('angle') if angle == 0: angle = 360 self._view.set_angle(angle - 90) def _fullscreen_cb(self, button): self.emit('go-fullscreen')
class EditToolbar(gtk.Toolbar): def __init__(self, pc, toolbar_box): gtk.Toolbar.__init__(self) self._abiword_canvas = pc.abiword_canvas copy = CopyButton() copy.props.accelerator = '<Ctrl>C' copy.connect('clicked', lambda button: pc.abiword_canvas.copy()) self.insert(copy, -1) copy.show() paste = PasteButton() paste.props.accelerator = '<Ctrl>V' paste.connect('clicked', lambda button: pc.abiword_canvas.paste()) self.insert(paste, -1) paste.show() separator = gtk.SeparatorToolItem() self.insert(separator, -1) separator.show() undo = UndoButton(sensitive=False) undo.connect('clicked', lambda button: pc.abiword_canvas.undo()) pc.abiword_canvas.connect("can-undo", lambda abi, can_undo: undo.set_sensitive(can_undo)) self.insert(undo, -1) undo.show() redo = RedoButton(sensitive=False) redo.connect('clicked', lambda button: pc.abiword_canvas.redo()) pc.abiword_canvas.connect("can-redo", lambda abi, can_redo: redo.set_sensitive(can_redo)) self.insert(redo, -1) redo.show() pc.abiword_canvas.connect('text-selected', lambda abi, b: copy.set_sensitive(True)) pc.abiword_canvas.connect('image-selected', lambda abi, b: copy.set_sensitive(True)) pc.abiword_canvas.connect('selection-cleared', lambda abi, b: copy.set_sensitive(False)) separator = gtk.SeparatorToolItem() self.insert(separator, -1) separator.show() search_label = gtk.Label(_("Search") + ": ") search_label.show() search_item_page_label = gtk.ToolItem() search_item_page_label.add(search_label) self.insert(search_item_page_label, -1) search_item_page_label.show() # setup the search options self._search_entry = iconentry.IconEntry() self._search_entry.set_icon_from_name(iconentry.ICON_ENTRY_PRIMARY, 'system-search') self._search_entry.connect('activate', self._search_entry_activated_cb) self._search_entry.connect('changed', self._search_entry_changed_cb) self._search_entry.add_clear_button() self._add_widget(self._search_entry, expand=True) self._findprev = ToolButton('go-previous-paired') self._findprev.set_tooltip(_('Find previous')) self.insert(self._findprev, -1) self._findprev.show() self._findprev.connect('clicked', self._findprev_cb) self._findnext = ToolButton('go-next-paired') self._findnext.set_tooltip(_('Find next')) self.insert(self._findnext, -1) self._findnext.show() self._findnext.connect('clicked', self._findnext_cb) # set the initial state of the search controls # note: we won't simple call self._search_entry_changed_cb # here, as that will call into the abiword_canvas, which # is not mapped on screen here, causing the set_find_string # call to fail self._findprev.set_sensitive(False) self._findnext.set_sensitive(False) def _search_entry_activated_cb(self, entry): logger.debug('_search_entry_activated_cb') if not self._search_entry.props.text: return # find the next entry self._abiword_canvas.find_next(False) def _search_entry_changed_cb(self, entry): logger.debug('_search_entry_changed_cb search for \'%s\'', self._search_entry.props.text) if not self._search_entry.props.text: self._search_entry.activate() # set the button contexts self._findprev.set_sensitive(False) self._findnext.set_sensitive(False) return self._abiword_canvas.set_find_string(self._search_entry.props.text) # set the button contexts self._findprev.set_sensitive(True) self._findnext.set_sensitive(True) # immediately start seaching self._abiword_canvas.find_next(True) def _findprev_cb(self, button): logger.debug('_findprev_cb') if self._search_entry.props.text: self._abiword_canvas.find_prev() else: logger.debug('nothing to search for!') def _findnext_cb(self, button): logger.debug('_findnext_cb') if self._search_entry.props.text: self._abiword_canvas.find_next(False) else: logger.debug('nothing to search for!') # bad foddex! this function was copied from sugar's activity.py def _add_widget(self, widget, expand=False): tool_item = gtk.ToolItem() tool_item.set_expand(expand) tool_item.add(widget) widget.show() self.insert(tool_item, -1) tool_item.show()
def __init__(self, handle): activity.Activity.__init__(self, handle, True) self.max_participants = 1 # CANVAS scroll = gtk.ScrolledWindow() scroll.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC) self.notes_area = NotesArea() scroll.add_with_viewport(self.notes_area) self.set_canvas(scroll) # TOOLBARS toolbarbox = ToolbarBox() activity_button = ActivityToolbarButton(self) toolbarbox.toolbar.insert(activity_button, 0) activity_button.show() separator = gtk.SeparatorToolItem() toolbarbox.toolbar.insert(separator, -1) note_add = ToolButton('gtk-add') note_add.set_tooltip(_('Add a note')) note_add.connect('clicked', self.__add_note_cb) toolbarbox.toolbar.insert(note_add, -1) note_remove = ToggleToolButton('gtk-remove') note_remove.set_tooltip(_('Remove notes')) note_remove.connect('clicked', self._active_remove) toolbarbox.toolbar.insert(note_remove, -1) separator = gtk.SeparatorToolItem() toolbarbox.toolbar.insert(separator, -1) back = ToolButton('go-left') back.set_tooltip(_('Select previous note')) back.set_sensitive(False) back.connect('clicked', lambda w: self.notes_area.select_note(-1)) toolbarbox.toolbar.insert(back, -1) _next = ToolButton('go-right') _next.set_tooltip(_('Select next note')) _next.connect('clicked', lambda w: self.notes_area.select_note(+1)) _next.set_sensitive(False) toolbarbox.toolbar.insert(_next, -1) separator = gtk.SeparatorToolItem() separator.set_draw(False) separator.set_expand(True) toolbarbox.toolbar.insert(separator, -1) stopbtn = StopButton(self) toolbarbox.toolbar.insert(stopbtn, -1) self.set_toolbar_box(toolbarbox) self.notes_area.connect('no-notes', self._no_notes, note_remove, back, _next) self.notes_area.connect('note-added', self._note_added, back, _next) self.show_all()
def __init__(self, handle): super(PeterActivity, self).__init__(handle) # Get user's Sugar colors sugarcolors = profile.get_color().to_string().split(",") colors = [ [int(sugarcolors[0][1:3], 16), int(sugarcolors[0][3:5], 16), int(sugarcolors[0][5:7], 16)], [int(sugarcolors[1][1:3], 16), int(sugarcolors[1][3:5], 16), int(sugarcolors[1][5:7], 16)], ] # No sharing self.max_participants = 1 self.datapath = os.path.join(activity.get_activity_root(), "instance") # Build the activity toolbar. toolbox = ToolbarBox() activity_button = ActivityToolbarButton(self) toolbox.toolbar.insert(activity_button, 0) activity_button.show() self._add_speed_slider(toolbox.toolbar) cyan = ToolButton("cyan") toolbox.toolbar.insert(cyan, -1) cyan.set_tooltip(_("Next pattern")) cyan.connect("clicked", self._button_cb, "cyan") cyan.set_sensitive(False) cyan.show() green = ToolButton("green") toolbox.toolbar.insert(green, -1) green.set_tooltip(_("Draw")) green.connect("clicked", self._button_cb, "green") green.show() red = ToolButton("red") toolbox.toolbar.insert(red, -1) red.set_tooltip(_("Stop")) red.connect("clicked", self._button_cb, "red") red.show() separator = gtk.SeparatorToolItem() separator.props.draw = True toolbox.toolbar.insert(separator, -1) separator.show() label = gtk.Label("") label.set_use_markup(True) label.show() labelitem = gtk.ToolItem() labelitem.add(label) toolbox.toolbar.insert(labelitem, -1) labelitem.show() export = ToolButton("export-turtleblocks") toolbox.toolbar.insert(export, -1) export.set_tooltip(_("Export to TurtleBlocks")) export.connect("clicked", self._export_turtleblocks_cb) export.show() separator = gtk.SeparatorToolItem() separator.props.draw = False separator.set_expand(True) toolbox.toolbar.insert(separator, -1) separator.show() stop_button = StopButton(self) stop_button.props.accelerator = _("<Ctrl>Q") toolbox.toolbar.insert(stop_button, -1) stop_button.show() toolbox.show() self.set_toolbox(toolbox) # Create the game instance. self.game = Spirolaterals.Spirolaterals(colors) # Build the Pygame canvas. self._pygamecanvas = sugargame.canvas.PygameCanvas(self) # Note that set_canvas implicitly calls # read_file when resuming from the Journal. self.set_canvas(self._pygamecanvas) self.game.canvas = self._pygamecanvas gtk.gdk.screen_get_default().connect("size-changed", self.__configure_cb) # Start the game running. self.game.set_cyan_button(cyan) self.game.set_label(label) self._speed_range.set_value(200) self._pygamecanvas.run_pygame(self.game.run)
class NavToolBar(gtk.Toolbar): __gsignals__ = { 'lock-button-clicked' : (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE, ()) } def __init__(self, arbiter): gtk.Toolbar.__init__(self) self.__arbiter = arbiter self.__logger = logging.getLogger('Navigation Toolbar') self.__logger.setLevel(logging.DEBUG) self.__prevbtn = ToolButton('go-previous') self.__prevbtn.set_tooltip(_("Previous slide")) self.__prevbtn.connect('clicked', self.previous_btn_clicked) self.__nextbtn = ToolButton('go-next') self.__nextbtn.set_tooltip(_("Next slide")) self.__nextbtn.connect('clicked', self.next_btn_clicked) # page number widget and navigation self.__num_page_item = gtk.ToolItem() self.__num_current_page = 1 self.__num_page_entry = gtk.Entry() self.__num_page_entry.set_text(str(self.__num_current_page)) self.__num_page_entry.set_alignment(1) self.__num_page_entry.connect('activate', self.num_page_activate) self.__num_page_entry.set_width_chars(4) self.__num_page_item.add(self.__num_page_entry) self.__num_page_entry.show() # total page number widget self.__total_page_item = gtk.ToolItem() self.__total_page_label = gtk.Label() label_attributes = pango.AttrList() label_attributes.insert(pango.AttrSize(14000, 0, -1)) label_attributes.insert(pango.AttrForeground(65535, 65535, 65535, 0, -1)) self.__total_page_label.set_attributes(label_attributes) self.__total_page_label.set_text(' / ' + str(self.__arbiter.get_slide_count())) self.__total_page_item.add(self.__total_page_label) self.__total_page_label.show() # Instructor/Student mode label self.__mode_item = gtk.ToolItem() self.__mode_label = gtk.Label() label_attributes = pango.AttrList() label_attributes.insert(pango.AttrSize(14000, 0, -1)) label_attributes.insert(pango.AttrForeground(65535, 65535, 65535, 0, -1)) self.__mode_label.set_attributes(label_attributes) self.__mode_label.set_text(_("Not Connected")) self.__mode_item.add(self.__mode_label) self.__mode_label.show() # separator between navigation buttons and mode label self.__separator1 = gtk.SeparatorToolItem() self.__separator1.set_draw(True) self.__separator1.set_expand(True) # separator between mode label and lock button self.__separator2 = gtk.SeparatorToolItem() self.__separator2.set_draw(True) self.__separator2.set_expand(True) # unlocked button self.__unlockBtn = ToolButton('unlocked') self.__unlockBtn.set_tooltip(_("Student Navigation Unlocked")) # navigation is unlocked by default, so insert the unlock button # locked button self.__lockBtn = ToolButton('locked') self.__lockBtn.set_tooltip(_("Student Navigation Locked")) self.__logger.debug("Connecting to navigation locking and activity sharing signals.") self.__arbiter.connect_shared(self.activity_shared_cb) self.__arbiter.connect_joined(self.activity_joined_cb) self.__arbiter.connect_navigation_lock_change(self.set_lock_button) # triggers for when slides are changed self.__arbiter.connect_slide_changed(self.slide_changed_cb) self.__arbiter.connect_deck_changed(self.slide_changed_cb) self.slide_changed_cb() self.insert(self.__prevbtn, -1) self.insert(self.__nextbtn, -1) self.insert(self.__num_page_item, -1) self.insert(self.__total_page_item, -1) self.insert(self.__separator1, -1) self.insert(self.__mode_item, -1) self.insert(self.__separator2, -1) self.insert(self.__unlockBtn, -1) self.__prevbtn.show() self.__nextbtn.show() self.__num_page_item.show() self.__total_page_item.show() self.__separator1.show() self.__mode_item.show() self.__separator2.show() self.__unlockBtn.show() self.show() # show the entire toolbar def activity_shared_cb(self, widget): #Callback for when the activity is shared # bind the lock button click with switching lock mode self.__lockBtn.connect('clicked', self.lock_btn_cb) self.__unlockBtn.connect('clicked', self.lock_btn_cb) self.__mode_label.set_text(_("Instructor")) def activity_joined_cb(self, widget): """ Callback for when the activity is joined """ self.__mode_label.set_text(_("Student")) self.__lockBtn.set_sensitive(False) self.__unlockBtn.set_sensitive(False) def lock_btn_cb(self, widget): """ The lock/unlock button has been clicked. """ self.emit('lock-button-clicked') def set_lock_button(self, widget, is_locked): sharing = self.__arbiter.get_is_instructor() self.__logger.debug("Changing lock button, lock mode %u, init %u", is_locked, sharing) if is_locked: new_button = self.__lockBtn if not sharing: self.__prevbtn.set_sensitive(False) self.__nextbtn.set_sensitive(False) else: new_button = self.__unlockBtn if not sharing: self.__prevbtn.set_sensitive(True) self.__nextbtn.set_sensitive(True) old = self.get_nth_item(7) self.remove(old) self.insert(new_button, 7) new_button.show() self.queue_draw() def next_btn_clicked(self, widget): self.__arbiter.do_next_slide() def previous_btn_clicked(self, widget): self.__arbiter.do_previous_slide() def slide_changed_cb(self, widget=None): self.__logger.debug("Changing slides!") if self.__arbiter.get_deck_is_at_beginning(): self.__prevbtn.set_sensitive(False) else: self.__prevbtn.set_sensitive(True) if self.__arbiter.get_deck_is_at_end(): self.__nextbtn.set_sensitive(False) else: self.__nextbtn.set_sensitive(True) self.__num_current_page = self.__arbiter.get_slide_index() self.__num_page_entry.set_text(str(self.__num_current_page + 1)) self.__total_page_label.set_text(' / ' + str(self.__arbiter.get_slide_count())) def num_page_activate(self, entry): page_entered = int(entry.get_text()) if page_entered < 1: page_entered = 1 elif self.__arbiter.get_slide_count() < page_entered: page_entered = self.__arbiter.get_slide_count() self.__arbiter.do_goto_slide(page_entered - 1, local_request=True)
class TableToolbar(gtk.Toolbar): def __init__(self, toolbox, abiword_canvas, parent): gtk.Toolbar.__init__(self) self._toolbox = toolbox self._abiword_canvas = abiword_canvas self._parent = parent self._table = abiword.TableCreator() self._table.set_labels(_('Table'), _('Cancel')) self._table_id = self._table.connect('selected', self._table_cb) self._table.show() tool_item = gtk.ToolItem() tool_item.add(self._table) self.insert(tool_item, -1) tool_item.show_all() self._table_rows_after = ToolButton('row-insert') self._table_rows_after.set_tooltip(_('Insert Row')) self._table_rows_after_id = self._table_rows_after.connect( 'clicked', self._table_rows_after_cb) self.insert(self._table_rows_after, -1) self._table_rows_after.show() self._table_delete_rows = ToolButton('row-remove') self._table_delete_rows.set_tooltip(_('Delete Row')) self._table_delete_rows_id = self._table_delete_rows.connect( 'clicked', self._table_delete_rows_cb) self.insert(self._table_delete_rows, -1) self._table_delete_rows.show() self._table_cols_after = ToolButton('column-insert') self._table_cols_after.set_tooltip(_('Insert Column')) self._table_cols_after_id = self._table_cols_after.connect( 'clicked', self._table_cols_after_cb) self.insert(self._table_cols_after, -1) self._table_cols_after.show() self._table_delete_cols = ToolButton('column-remove') self._table_delete_cols.set_tooltip(_('Delete Column')) self._table_delete_cols_id = self._table_delete_cols.connect( 'clicked', self._table_delete_cols_cb) self.insert(self._table_delete_cols, -1) self._table_delete_cols.show() self._abiword_canvas.connect('table-state', self._isTable_cb) ####btn salir del barrido del menu item self._btn_barrido_menu = ToolButton() self._btn_barrido_menu.set_tooltip(_('Salir \nMenú')) self._btn_barrido_menu_id = self._btn_barrido_menu.connect( 'clicked', self._btn_barrido_menu_cb) self.insert(self._btn_barrido_menu, -1) self._btn_barrido_menu.set_no_show_all(True) #self._btn_barrido_menu.show() # en realidad mostrar solo si esta barriendo def _btn_barrido_menu_cb(self, button): if (self._parent.BOTONESxBARRIDO_MENU_ITEM): self._parent.BOTONESxBARRIDO_MENU = False self._parent.BOTONESxBARRIDO_MENU_ITEM = False self._parent.BOTONESxBARRIDO = False # si le doy True va a ejectuar el escribir porque llama al metodo del eventbox #self._parent.chk_activarBarrido_botones_menu.emit("clicked") self._parent.chk_activarBarrido_botones.set_active(True) ####fin btn salir del barrido del menu item def _table_cb(self, abi, rows, cols): self._abiword_canvas.insert_table(rows, cols) def _table_rows_after_cb(self, button): self._abiword_canvas.invoke_cmd('insertRowsAfter', '', 0, 0) def _table_delete_rows_cb(self, button): self._abiword_canvas.invoke_cmd('deleteRows', '', 0, 0) def _table_cols_after_cb(self, button): self._abiword_canvas.invoke_cmd('insertColsAfter', '', 0, 0) def _table_delete_cols_cb(self, button): self._abiword_canvas.invoke_cmd('deleteColumns', '', 0, 0) def _isTable_cb(self, abi, b): self._table_rows_after.set_sensitive(b) self._table_delete_rows.set_sensitive(b) self._table_cols_after.set_sensitive(b) self._table_delete_cols.set_sensitive(b) if b: self._toolbox.set_current_toolbar(TOOLBAR_TABLE) self._abiword_canvas.grab_focus() # hack: bad toolbox, bad!
class WriteEditToolbar(EditToolbar): def __init__(self, toolbox, abiword_canvas, text_toolbar, parent): EditToolbar.__init__(self) self._toolbox = toolbox self._abiword_canvas = abiword_canvas self._text_toolbar = text_toolbar self._parent = parent # connect existing buttons self.undo.set_sensitive(False) self.redo.set_sensitive(False) self.undo.connect('clicked', self._undo_cb) self.redo.connect('clicked', self._redo_cb) self.copy.connect('clicked', self._copy_cb) self.paste.connect('clicked', self._paste_cb) self._abiword_canvas.connect("can-undo", self._can_undo_cb) self._abiword_canvas.connect("can-redo", self._can_redo_cb) # make expanded non-drawn visible separator to make the search stuff right-align separator = gtk.SeparatorToolItem() separator.props.draw = False separator.set_expand(True) self.insert(separator, -1) separator.show() # setup the search options self._search_entry = iconentry.IconEntry() self._search_entry.set_icon_from_name(iconentry.ICON_ENTRY_PRIMARY, 'system-search') self._search_entry.connect('activate', self._search_entry_activated_cb) self._search_entry.connect('changed', self._search_entry_changed_cb) self._search_entry.add_clear_button() self._add_widget(self._search_entry, expand=True) self._findprev = ToolButton('go-previous') self._findprev.set_tooltip(_('Find previous')) self.insert(self._findprev, -1) self._findprev.show() self._findprev.connect('clicked', self._findprev_cb) self._findnext = ToolButton('go-next') self._findnext.set_tooltip(_('Find next')) self.insert(self._findnext, -1) self._findnext.show() self._findnext.connect('clicked', self._findnext_cb) # set the initial state of the search controls # note: we won't simple call self._search_entry_changed_cb # here, as that will call into the abiword_canvas, which # is not mapped on screen here, causing the set_find_string # call to fail self._findprev.set_sensitive(False) self._findnext.set_sensitive(False) ####btn salir del barrido del menu item self._btn_barrido_menu = ToolButton() self._btn_barrido_menu.set_tooltip(_('Salir \nMenú')) self._btn_barrido_menu_id = self._btn_barrido_menu.connect( 'clicked', self._btn_barrido_menu_cb) self.insert(self._btn_barrido_menu, -1) self._btn_barrido_menu.set_no_show_all(True) #self._btn_barrido_menu.show() # en realidad mostrar solo si esta barriendo def _btn_barrido_menu_cb(self, button): if (self._parent.BOTONESxBARRIDO_MENU_ITEM): self._parent.BOTONESxBARRIDO_MENU = False self._parent.BOTONESxBARRIDO_MENU_ITEM = False self._parent.BOTONESxBARRIDO = False # si le doy True va a ejectuar el escribir porque llama al metodo del eventbox #self._parent.chk_activarBarrido_botones_menu.emit("clicked") self._parent.chk_activarBarrido_botones.set_active(True) ####fin btn salir del barrido del menu item def _undo_cb(self, button): self._abiword_canvas.undo() def _redo_cb(self, button): self._abiword_canvas.redo() def _copy_cb(self, button): self._abiword_canvas.copy() def _paste_cb(self, button): self._abiword_canvas.paste() def _can_undo_cb(self, canvas, can_undo): self.undo.set_sensitive(can_undo) def _can_redo_cb(self, canvas, can_redo): self.redo.set_sensitive(can_redo) def _search_entry_activated_cb(self, entry): logger.debug('_search_entry_activated_cb') if not self._search_entry.props.text: return # find the next entry id = self._text_toolbar.get_text_selected_handler() self._abiword_canvas.handler_block(id) self._abiword_canvas.find_next(False) self._abiword_canvas.handler_unblock(id) def _search_entry_changed_cb(self, entry): logger.debug('_search_entry_changed_cb search for \'%s\'', self._search_entry.props.text) if not self._search_entry.props.text: self._search_entry.activate() # set the button contexts self._findprev.set_sensitive(False) self._findnext.set_sensitive(False) return self._abiword_canvas.set_find_string(self._search_entry.props.text) # set the button contexts self._findprev.set_sensitive(True) self._findnext.set_sensitive(True) # immediately start seaching id = self._text_toolbar.get_text_selected_handler() self._abiword_canvas.handler_block(id) self._abiword_canvas.find_next(True) self._abiword_canvas.handler_unblock(id) def _findprev_cb(self, button): logger.debug('_findprev_cb') if self._search_entry.props.text: id = self._text_toolbar.get_text_selected_handler() self._abiword_canvas.handler_block(id) self._abiword_canvas.find_prev() self._abiword_canvas.handler_unblock(id) else: logger.debug('nothing to search for!') def _findnext_cb(self, button): logger.debug('_findnext_cb') if self._search_entry.props.text: id = self._text_toolbar.get_text_selected_handler() self._abiword_canvas.handler_block(id) self._abiword_canvas.find_next(False) self._abiword_canvas.handler_unblock(id) else: logger.debug('nothing to search for!') # bad foddex! this function was copied from sugar's activity.py def _add_widget(self, widget, expand=False): tool_item = gtk.ToolItem() tool_item.set_expand(expand) tool_item.add(widget) widget.show() self.insert(tool_item, -1) tool_item.show()
class TextAttributesToolbar(gtk.Toolbar): def __init__(self, main_area): gtk.Toolbar.__init__(self) self._main_area = main_area self._font_list = ['ABC123', 'Sans', 'Serif', 'Monospace', 'Symbol'] self._font_sizes = ['8', '9', '10', '11', '12', '14', '16', '20', '22', '24', '26', '28', '36', '48', '72'] self.font_button = ToolButton('font-text') self.font_button.set_tooltip(_('Select font')) self.font_button.connect('clicked', self.__font_selection_cb) self.insert(self.font_button, -1) self._setup_font_palette() self.insert(gtk.SeparatorToolItem(), -1) self.font_size_up = ToolButton('resize+') self.font_size_up.set_tooltip(_('Bigger')) self.font_size_up.connect('clicked', self.__font_sizes_cb, True) self.insert(self.font_size_up, -1) if len(self._main_area.selected) > 0: font_size = self._main_area.font_size else: font_size = utils.default_font_size self.size_label = gtk.Label(str(font_size)) self.size_label.show() toolitem = gtk.ToolItem() toolitem.add(self.size_label) toolitem.show() self.insert(toolitem, -1) self.font_size_down = ToolButton('resize-') self.font_size_down.set_tooltip(_('Smaller')) self.font_size_down.connect('clicked', self.__font_sizes_cb, False) self.insert(self.font_size_down, -1) self.insert(gtk.SeparatorToolItem(), -1) self.bold = ToolButton('bold-text') self.bold.set_tooltip(_('Bold')) self.bold.connect('clicked', self.__bold_cb) self.insert(self.bold, -1) self.italics = ToolButton('italics-text') self.italics.set_tooltip(_('Italics')) self.italics.connect('clicked', self.__italics_cb) self.insert(self.italics, -1) self.underline = ToolButton('underline-text') self.underline.set_tooltip(_('Underline')) self.underline.connect('clicked', self.__underline_cb) self.insert(self.underline, -1) foreground_color = ColorToolButton() foreground_color.set_title(_('Set font color')) foreground_color.connect('color-set', self.__foreground_color_cb) self.insert(foreground_color, -1) bakground_color = ColorToolButton() bakground_color.set_title(_('Set background color')) bakground_color.connect('color-set', self.__background_color_cb) bakground_color.set_color(gtk.gdk.Color(65535, 65535, 65535)) self.insert(bakground_color, -1) self.show_all() def __font_selection_cb(self, widget): if self._font_palette: if not self._font_palette.is_up(): self._font_palette.popup(immediate=True, state=self._font_palette.SECONDARY) else: self._font_palette.popdown(immediate=True) return def _init_font_list(self): self._font_white_list = [] self._font_white_list.extend(DEFAULT_FONTS) # check if there are a user configuration file if not os.path.exists(USER_FONTS_FILE_PATH): # verify if exists a file in /etc if os.path.exists(GLOBAL_FONTS_FILE_PATH): shutil.copy(GLOBAL_FONTS_FILE_PATH, USER_FONTS_FILE_PATH) if os.path.exists(USER_FONTS_FILE_PATH): # get the font names in the file to the white list fonts_file = open(USER_FONTS_FILE_PATH) # get the font names in the file to the white list for line in fonts_file: self._font_white_list.append(line.strip()) # monitor changes in the file gio_fonts_file = gio.File(USER_FONTS_FILE_PATH) self.monitor = gio_fonts_file.monitor_file() self.monitor.set_rate_limit(5000) self.monitor.connect('changed', self._reload_fonts) def _reload_fonts(self, monitor, gio_file, other_file, event): if event != gio.FILE_MONITOR_EVENT_CHANGES_DONE_HINT: return self._font_white_list = [] self._font_white_list.extend(DEFAULT_FONTS) fonts_file = open(USER_FONTS_FILE_PATH) for line in fonts_file: self._font_white_list.append(line.strip()) # update the menu for child in self._font_palette.menu.get_children(): self._font_palette.menu.remove(child) child = None context = self.get_pango_context() tmp_list = [] for family in context.list_families(): name = family.get_name() if name in self._font_white_list: tmp_list.append(name) for font in sorted(tmp_list): menu_item = MyMenuItem(image=FontImage(font.replace(' ', '-')), text_label=font) menu_item.connect('activate', self.__font_selected_cb, font) self._font_palette.menu.append(menu_item) menu_item.show() return False def _setup_font_palette(self): self._init_font_list() context = self._main_area.pango_context for family in context.list_families(): name = pango.FontDescription(family.get_name()).to_string() if name not in self._font_list and \ name in self._font_white_list: self._font_list.append(name) self._font_palette = self.font_button.get_palette() for font in sorted(self._font_list): menu_item = MyMenuItem(image=FontImage(font.replace(' ', '-')), text_label=font) menu_item.connect('activate', self.__font_selected_cb, font) self._font_palette.menu.append(menu_item) menu_item.show() def __font_selected_cb(self, widget, font_name): if not hasattr(self._main_area, 'font_name'): return if len(self._main_area.selected) > 0: font_size = self._main_area.font_size else: font_size = utils.default_font_size self._main_area.set_font(font_name, font_size) self._main_area.font_name = font_name self._main_area.font_size = font_size def __attribute_values(self): attributes = {"bold": True, "italics": True, "underline": True, "font": ""} it = self._main_area.selected[0].attributes.get_iterator() start_index = self._main_area.selected[0].index end_index = self._main_area.selected[0].end_index while(1): found = False r = it.range() if start_index == end_index: if r[0] <= start_index and r[1] > start_index: found = True elif start_index < end_index: if r[0] > end_index: break if start_index == end_index and \ r[0] < start_index and \ r[1] > start_index: found = True elif start_index != end_index and r[0] <= start_index and \ r[1] >= end_index: found = True else: if r[0] > start_index: break if start_index == end_index and \ r[0] < start_index and \ r[1] > start_index: found = True elif start_index != end_index and r[0] <= end_index and \ r[1] >= start_index: found = True if found: attr = it.get_attrs() for x in attr: if x.type == pango.ATTR_WEIGHT and \ x.value == pango.WEIGHT_BOLD: attributes["bold"] = False elif x.type == pango.ATTR_STYLE and \ x.value == pango.STYLE_ITALIC: attributes["italics"] = False elif x.type == pango.ATTR_UNDERLINE and \ x.value == pango.UNDERLINE_SINGLE: attributes["underline"] = False elif x.type == pango.ATTR_FONT_DESC: attributes["font"] = x.desc if not it.next(): break return attributes def __font_sizes_cb(self, button, increase): if not hasattr(self._main_area, 'font_size'): return if len(self._main_area.selected) < 1: return font_size = self._main_area.font_size if font_size in self._font_sizes: i = self._font_sizes.index(font_size) if increase: if i < len(self._font_sizes) - 2: i += 1 else: if i > 0: i -= 1 else: i = self._font_sizes.index(utils.default_font_size) font_size = self._font_sizes[i] self.size_label.set_text(str(font_size)) self.font_size_down.set_sensitive(i != 0) self.font_size_up.set_sensitive(i < len(self._font_sizes) - 2) self._main_area.set_font(self._main_area.font_name, font_size) def __bold_cb(self, button): if len(self._main_area.selected) < 1: return value = self.__attribute_values()["bold"] self._main_area.set_bold(value) def __italics_cb(self, button): if len(self._main_area.selected) < 1: return value = self.__attribute_values()["italics"] self._main_area.set_italics(value) def __underline_cb(self, button): if len(self._main_area.selected) < 1: return value = self.__attribute_values()["underline"] self._main_area.set_underline(value) def __foreground_color_cb(self, button): color = button.get_color() self._main_area.set_foreground_color(color) def __background_color_cb(self, button): color = button.get_color() self._parent._main_area.set_background_color(color) def change_active_font(self): # TODO: update the toolbar return
class EditToolbar(gtk.Toolbar): def __init__(self, pc, toolbar_box): gtk.Toolbar.__init__(self) self._abiword_canvas = pc.abiword_canvas copy = CopyButton() copy.props.accelerator = '<Ctrl>C' copy.connect('clicked', lambda button: pc.abiword_canvas.copy()) self.insert(copy, -1) copy.show() paste = PasteButton() paste.props.accelerator = '<Ctrl>V' paste.connect('clicked', lambda button: pc.abiword_canvas.paste()) self.insert(paste, -1) paste.show() separator = gtk.SeparatorToolItem() self.insert(separator, -1) separator.show() undo = UndoButton(sensitive=False) undo.connect('clicked', lambda button: pc.abiword_canvas.undo()) pc.abiword_canvas.connect( "can-undo", lambda abi, can_undo: undo.set_sensitive(can_undo)) self.insert(undo, -1) undo.show() redo = RedoButton(sensitive=False) redo.connect('clicked', lambda button: pc.abiword_canvas.redo()) pc.abiword_canvas.connect( "can-redo", lambda abi, can_redo: redo.set_sensitive(can_redo)) self.insert(redo, -1) redo.show() pc.abiword_canvas.connect('text-selected', lambda abi, b: copy.set_sensitive(True)) pc.abiword_canvas.connect('image-selected', lambda abi, b: copy.set_sensitive(True)) pc.abiword_canvas.connect('selection-cleared', lambda abi, b: copy.set_sensitive(False)) separator = gtk.SeparatorToolItem() self.insert(separator, -1) separator.show() search_label = gtk.Label(_("Search") + ": ") search_label.show() search_item_page_label = gtk.ToolItem() search_item_page_label.add(search_label) self.insert(search_item_page_label, -1) search_item_page_label.show() # setup the search options self._search_entry = iconentry.IconEntry() self._search_entry.set_icon_from_name(iconentry.ICON_ENTRY_PRIMARY, 'system-search') self._search_entry.connect('activate', self._search_entry_activated_cb) self._search_entry.connect('changed', self._search_entry_changed_cb) self._search_entry.add_clear_button() self._add_widget(self._search_entry, expand=True) self._findprev = ToolButton('go-previous-paired') self._findprev.set_tooltip(_('Find previous')) self.insert(self._findprev, -1) self._findprev.show() self._findprev.connect('clicked', self._findprev_cb) self._findnext = ToolButton('go-next-paired') self._findnext.set_tooltip(_('Find next')) self.insert(self._findnext, -1) self._findnext.show() self._findnext.connect('clicked', self._findnext_cb) # set the initial state of the search controls # note: we won't simple call self._search_entry_changed_cb # here, as that will call into the abiword_canvas, which # is not mapped on screen here, causing the set_find_string # call to fail self._findprev.set_sensitive(False) self._findnext.set_sensitive(False) def _search_entry_activated_cb(self, entry): logger.debug('_search_entry_activated_cb') if not self._search_entry.props.text: return # find the next entry self._abiword_canvas.find_next(False) def _search_entry_changed_cb(self, entry): logger.debug('_search_entry_changed_cb search for \'%s\'', self._search_entry.props.text) if not self._search_entry.props.text: self._search_entry.activate() # set the button contexts self._findprev.set_sensitive(False) self._findnext.set_sensitive(False) return self._abiword_canvas.set_find_string(self._search_entry.props.text) # set the button contexts self._findprev.set_sensitive(True) self._findnext.set_sensitive(True) # immediately start seaching self._abiword_canvas.find_next(True) def _findprev_cb(self, button): logger.debug('_findprev_cb') if self._search_entry.props.text: self._abiword_canvas.find_prev() else: logger.debug('nothing to search for!') def _findnext_cb(self, button): logger.debug('_findnext_cb') if self._search_entry.props.text: self._abiword_canvas.find_next(False) else: logger.debug('nothing to search for!') # bad foddex! this function was copied from sugar's activity.py def _add_widget(self, widget, expand=False): tool_item = gtk.ToolItem() tool_item.set_expand(expand) tool_item.add(widget) widget.show() self.insert(tool_item, -1) tool_item.show()
class InsertToolbar(gtk.Toolbar): def __init__(self, abiword_canvas): gtk.Toolbar.__init__(self) self._abiword_canvas = abiword_canvas self._table = abiword.TableCreator() self._table.set_labels(_('Table'), _('Cancel')) self._table_id = self._table.connect('selected', self._table_cb) image = gtk.Image() image.set_from_icon_name('insert-table', -1) self._table.set_image(image) self._table.set_relief(gtk.RELIEF_NONE) tool_item = gtk.ToolItem() tool_item.add(self._table) self.insert(tool_item, -1) tool_item.show_all() self._table_rows_after = ToolButton('row-insert') self._table_rows_after.set_tooltip(_('Insert Row')) self._table_rows_after_id = self._table_rows_after.connect( \ 'clicked', self._table_rows_after_cb) self.insert(self._table_rows_after, -1) self._table_delete_rows = ToolButton('row-remove') self._table_delete_rows.set_tooltip(_('Delete Row')) self._table_delete_rows_id = self._table_delete_rows.connect( \ 'clicked', self._table_delete_rows_cb) self.insert(self._table_delete_rows, -1) self._table_cols_after = ToolButton('column-insert') self._table_cols_after.set_tooltip(_('Insert Column')) self._table_cols_after_id = self._table_cols_after.connect( \ 'clicked', self._table_cols_after_cb) self.insert(self._table_cols_after, -1) self._table_delete_cols = ToolButton('column-remove') self._table_delete_cols.set_tooltip(_('Delete Column')) self._table_delete_cols_id = self._table_delete_cols.connect( \ 'clicked', self._table_delete_cols_cb) self.insert(self._table_delete_cols, -1) separator = gtk.SeparatorToolItem() self.insert(separator, -1) image = ToolButton('insert-picture') image.set_tooltip(_('Insert Image')) self._image_id = image.connect('clicked', self._image_cb) self.insert(image, -1) self.show_all() self._abiword_canvas.connect('table-state', self._isTable_cb) #self._abiword_canvas.connect('image-selected', self._image_selected_cb) def _image_cb(self, button): def cb(object): logging.debug('ObjectChooser: %r' % object) self._abiword_canvas.insert_image(object.file_path, True) chooser.pick(what=chooser.IMAGE, cb=cb) def _table_cb(self, abi, rows, cols): self._abiword_canvas.insert_table(rows, cols) def _table_rows_after_cb(self, button): self._abiword_canvas.invoke_cmd('insertRowsAfter', '', 0, 0) def _table_delete_rows_cb(self, button): self._abiword_canvas.invoke_cmd('deleteRows', '', 0, 0) def _table_cols_after_cb(self, button): self._abiword_canvas.invoke_cmd('insertColsAfter', '', 0, 0) def _table_delete_cols_cb(self, button): self._abiword_canvas.invoke_cmd('deleteColumns', '', 0, 0) def _isTable_cb(self, abi, b): self._table_rows_after.set_sensitive(b) self._table_delete_rows.set_sensitive(b) self._table_cols_after.set_sensitive(b) self._table_delete_cols.set_sensitive(b)
class HomeWorkViewer(activity.Activity): def __init__(self, handle): """Set up the HelloWorld activity.""" activity.Activity.__init__(self, handle) self._logger = logging.getLogger('home-work-viewer') self._logger.setLevel(logging.DEBUG) self._logger.debug("Inside to __init__ of HomeWorkViewer") ts = time.time() self._logger.debug(ts) #self._logger.debug( datetime.datetime.fromtimestamp(ts).strftime('%Y-%m-%d %H:%M:%S')) '''Obtenemos el JSON de la Actividad''' json_data=open('json.txt') self.activity = json.load(json_data, object_hook=lambda d: namedtuple('Activity', d.keys())(*d.values())) json_data.close() # we do not have collaboration features # make the share option insensitive self.max_participants = 1 # toolbar with the new toolbar redesign toolbar_box = ToolbarBox() activity_button = ActivityButton(self) toolbar_box.toolbar.insert(activity_button, 0) activity_button.show() title_entry = TitleEntry(self) toolbar_box.toolbar.insert(title_entry, 1) title_entry.show() separator = gtk.SeparatorToolItem() separator.props.draw = False separator.set_expand(True) toolbar_box.toolbar.insert(separator, -1) separator.show() self.buttonBefore = ToolButton('go-previous') self.buttonBefore.set_tooltip(_('Back')) self.buttonBefore.connect("clicked", self.backButtonCallBack) toolbar_box.toolbar.insert(self.buttonBefore, 2) self.buttonBefore.show() self.buttonNext = ToolButton('go-next') self.buttonNext.set_tooltip(_('Next')) self.buttonNext.connect("clicked", self.nextButtonCallBack) toolbar_box.toolbar.insert(self.buttonNext, 3) self.buttonNext.show() stop_button = StopButton(self) toolbar_box.toolbar.insert(stop_button, -1) stop_button.show() self.set_toolbar_box(toolbar_box) toolbar_box.show() self.vBoxMain = gtk.VBox(True, 2) self.vBoxMain.show() self.set_canvas(self.vBoxMain) self.jsonState = None self.createWindowExercises() """Leave this line always in the last""" #self.show_all() def exerciseCompletedCallBack(self): if self.amountExercises > self.exercisesMatches: self.exercisesMatches = self.exercisesMatches + 1 self.modalDoneWindow = ModalWindowDone(self) self.modalDoneWindow.show() self.freezeExerciseWindow() def manageBackNextButtons(self): self.getLogger().debug("Inside to manageBackNextButtons") self.getLogger().debug(self.currentIndexExercise) self.getLogger().debug(self.amountExercises) if self.currentIndexExercise == 0: self.buttonBefore.set_sensitive(False) if self.amountExercises != 1: self.buttonNext.set_sensitive(True) else: self.buttonNext.set_sensitive(False) elif self.currentIndexExercise > 0 and self.currentIndexExercise < (self.amountExercises-1): self.buttonBefore.set_sensitive(True) self.buttonNext.set_sensitive(True) else: self.buttonBefore.set_sensitive(True) self.buttonNext.set_sensitive(False) def nextButtonCallBack(self, button, *args): self.vBoxMain.get_children()[self.currentIndexExercise].hide() self.currentIndexExercise = self.currentIndexExercise + 1 self.vBoxMain.get_children()[self.currentIndexExercise].show_all() self.manageBackNextButtons() def backButtonCallBack(self, button, *args): self.vBoxMain.get_children()[self.currentIndexExercise].hide() self.currentIndexExercise = self.currentIndexExercise - 1 self.vBoxMain.get_children()[self.currentIndexExercise].show_all() self.manageBackNextButtons() def createWindowExercises(self): self._logger.debug("inside to createWindowExercises") ts = time.time() self._logger.debug(ts) self.amountExercises = len(self.activity.exercises) self.currentIndexExercise = 0 self.exercisesMatches = 0 self.clearBox() index = 0 while index < self.amountExercises: newExercise = None newWindowExercise = None stateExercise = None if self.jsonState is not None: stateExercise = self.jsonState['exercises'][index] if self.activity.exercises[index].codeType == 1: newExercise = SimpleAssociation() newWindowExercise = newExercise.getWindow(self.activity.exercises[index], self, stateExercise) elif self.activity.exercises[index].codeType == 2: newExercise = FindTheDifferent() newWindowExercise = newExercise.getWindow(self.activity.exercises[index] ,self, stateExercise) elif self.activity.exercises[index].codeType == 3: newExercise = SearchTheSame() newWindowExercise = newExercise.getWindow(self.activity.exercises[index] ,self, stateExercise) #newWindowExercise.hide() self.vBoxMain.pack_start(newWindowExercise, True, True, 0) index = index + 1 if self.jsonState is None: self.vBoxMain.get_children()[self.currentIndexExercise].show_all() self.getLogger().debug("Inside to if: self.jsonState is None") else: self.exercisesMatches = self.jsonState['exercisesMatches'] self.moveToExerciseIndex(self.jsonState['currentIndexExercise']) self.manageBackNextButtons() def clearBox(self): allExercisesWindows = self.vBoxMain.get_children() for exerciseWindow in allExercisesWindows: exerciseWindow.hide() self.vBoxMain.remove(exerciseWindow) def read_file(self, tmp_file): self.getLogger().debug("Inside to read_file()") ts = time.time() self._logger.debug(ts) with open(tmp_file, 'r') as stateFile: fileJsonState = json.load(stateFile) if fileJsonState is not None: self.jsonState = fileJsonState stateFile.close() self.createWindowExercises() def write_file(self, tmp_file): self.getLogger().debug("Inside to write_file") self.saveActivityState(tmp_file) def getLogger(self): return self._logger def saveActivityState(self, filePath): self.getLogger().debug("inside to saveActivityState") allExerciseWindows = self.vBoxMain.get_children() theJson = {} theJson["name"] = "JSON de prueba" theJson['currentIndexExercise'] = self.currentIndexExercise theJson['exercisesMatches'] = self.exercisesMatches theJson["exercises"] = [] itemsToCopy = [] activityName = self.metadata.get('title') metadataKeys = self.metadata.keys() #self.getLogger().debug(metadataKeys) #for key in metadataKeys: #self.getLogger().debug(key) #self.getLogger().debug(self.metadata.get(key)) for index, exerciseWindow in enumerate( allExerciseWindows ): exerciseJson = exerciseWindow.exerciseInstance.saveExerciseState() theJson['exercises'].append(exerciseJson) self.getLogger().debug(theJson) with open( filePath, 'w+') as stateFile: json.dump(theJson,stateFile ) stateFile.close() def freezeExerciseWindow(self): currentWindowsExercise = self.vBoxMain.get_children()[self.currentIndexExercise] currentWindowsExercise.exerciseInstance.disconnectEventBoxs() def moveToExerciseIndex(self, indexExercise): self.getLogger().debug("Inside to moveToExerciseIndex") vBoxMain = self.vBoxMain allWindowsExercises = vBoxMain.get_children() for index, windowExercise in enumerate(allWindowsExercises): self.getLogger().debug(index) self.getLogger().debug(indexExercise) if index != indexExercise: windowExercise.hide() else: windowExercise.show_all() self.currentIndexExercise = indexExercise self.manageBackNextButtons()
class CreateCardPanel(gtk.EventBox): __gsignals__ = { 'add-pair': (SIGNAL_RUN_FIRST, None, 8 * [TYPE_PYOBJECT]), 'update-pair': (SIGNAL_RUN_FIRST, None, 8 * [TYPE_PYOBJECT]), } def __init__(self): def make_label(icon_name, label): label_box = gtk.HBox() icon = Icon( icon_name=icon_name, icon_size=gtk.ICON_SIZE_LARGE_TOOLBAR) label_box.pack_start(icon, False) label = gtk.Label(label) label.modify_fg(gtk.STATE_NORMAL, style.COLOR_TOOLBAR_GREY.get_gdk_color()) label_box.pack_start(label) label_box.show_all() return label_box gtk.EventBox.__init__(self) self.equal_pairs = False self._updatebutton_sensitive = False self._card1_has_sound = False self._card2_has_sound = False # save buttons buttons_bar = gtk.HBox() buttons_bar.props.border_width = 10 self._addbutton = ToolButton( tooltip=_('Add as new pair'), sensitive=False) self._addbutton.set_icon_widget( make_label('pair-add', ' ' + _('Add'))) self._addbutton.connect('clicked', self.emit_add_pair) buttons_bar.pack_start(self._addbutton, False) self._updatebutton = ToolButton( tooltip=_('Update selected pair'), sensitive=False) self._updatebutton.set_icon_widget( make_label('pair-update', ' ' + _('Update'))) self._updatebutton.connect('clicked', self.emit_update_pair) buttons_bar.pack_start(self._updatebutton, False) # Set card editors self.cardeditor1 = CardEditor() self.cardeditor2 = CardEditor() self.clean(None) self.cardeditor1.connect('has-text', self.receive_text_signals) self.cardeditor2.connect('has-text', self.receive_text_signals) self.cardeditor1.connect('has-picture', self.receive_picture_signals) self.cardeditor2.connect('has-picture', self.receive_picture_signals) self.cardeditor1.connect('has-sound', self.receive_sound_signals) self.cardeditor2.connect('has-sound', self.receive_sound_signals) # edit panel self.card_box = gtk.HBox() self.card_box.pack_start(self.cardeditor1) self.card_box.pack_start(self.cardeditor2) box = gtk.VBox() box.pack_start(self.card_box, False) box.pack_start(buttons_bar, False) self.add(box) self.show_all() def emit_add_pair(self, widget): self._addbutton.set_sensitive(False) if self.equal_pairs: self.emit('add-pair', self.cardeditor1.get_text(), self.cardeditor1.get_text(), self.cardeditor1.get_pixbuf(), self.cardeditor1.get_pixbuf(), self.cardeditor1.get_snd(), self.cardeditor1.get_snd(), self.cardeditor1.get_speak(), self.cardeditor1.get_speak() ) else: self.emit('add-pair', self.cardeditor1.get_text(), self.cardeditor2.get_text(), self.cardeditor1.get_pixbuf(), self.cardeditor2.get_pixbuf(), self.cardeditor1.get_snd(), self.cardeditor2.get_snd(), self.cardeditor1.get_speak(), self.cardeditor2.get_speak() ) self.clean(None) def emit_update_pair(self, widget): self._addbutton.set_sensitive(False) if self.equal_pairs: self.emit('update-pair', self.cardeditor1.get_text(), self.cardeditor1.get_text(), self.cardeditor1.get_pixbuf(), self.cardeditor1.get_pixbuf(), self.cardeditor1.get_snd(), self.cardeditor1.get_snd(), self.cardeditor1.get_speak(), self.cardeditor1.get_speak() ) else: self.emit('update-pair', self.cardeditor1.get_text(), self.cardeditor2.get_text(), self.cardeditor1.get_pixbuf(), self.cardeditor2.get_pixbuf(), self.cardeditor1.get_snd(), self.cardeditor2.get_snd(), self.cardeditor1.get_speak(), self.cardeditor2.get_speak() ) self.clean(None) def pair_selected(self, widget, selected, newtext1, newtext2, aimg, bimg, asnd, bsnd, aspeak, bspeak): if selected: self.cardeditor1.set_text(newtext1) self.cardeditor2.set_text(newtext2) self.cardeditor1.set_pixbuf(aimg) self.cardeditor2.set_pixbuf(bimg) self.cardeditor1.set_snd(asnd) self.cardeditor2.set_snd(bsnd) self.cardeditor1.set_speak(aspeak) self.cardeditor2.set_speak(bspeak) self._addbutton.set_sensitive(True) self._updatebutton.set_sensitive(selected) self._updatebutton_sensitive = selected def change_equal_pairs(self, widget, state): self.equal_pairs = state self.clean(None) if self.equal_pairs: if self.cardeditor2.parent: self.card_box.remove(self.cardeditor2) else: if not self.cardeditor2.parent: self.card_box.pack_start(self.cardeditor2) def clean(self, widget): self.cardeditor1.clean() self.cardeditor2.clean() self._addbutton.set_sensitive(False) self._card1_has_text = False self._card2_has_text = False self._card1_has_picture = False self._card2_has_picture = False def receive_text_signals(self, widget, has_text): if widget == self.cardeditor1: self._card1_has_text = has_text if widget == self.cardeditor2: self._card2_has_text = has_text self._update_buttom_status() def receive_picture_signals(self, widget, has_picture): if widget == self.cardeditor1: self._card1_has_picture = has_picture if widget == self.cardeditor2: self._card2_has_picture = has_picture self._update_buttom_status() def receive_sound_signals(self, widget, has_sound): if widget == self.cardeditor1: self._card1_has_sound = has_sound if widget == self.cardeditor2: self._card2_has_sound = has_sound self._update_buttom_status() def _update_buttom_status(self): if not self.equal_pairs: if (self._card1_has_text or self._card1_has_picture \ or self._card1_has_sound) and (self._card2_has_text or self._card2_has_picture or self._card2_has_sound): self._addbutton.set_sensitive(True) self._updatebutton.set_sensitive(self._updatebutton_sensitive) else: self._addbutton.set_sensitive(False) self._updatebutton.set_sensitive(False) else: if (self._card1_has_text or self._card1_has_picture \ or self._card1_has_sound): self._addbutton.set_sensitive(True) self._updatebutton.set_sensitive(self._updatebutton_sensitive) else: self._addbutton.set_sensitive(False) self._updatebutton.set_sensitive(False)
class Activity(sugar.activity.activity.Activity): def __init__(self, handle): super(Activity, self).__init__(handle) self.paused = False watch = gtk.gdk.Cursor(gtk.gdk.WATCH) self.window.set_cursor(watch) self.p = gtk.VPaned() self.p.connect("notify::position", self.redraw) self.box = gtk.Notebook() self.p.pack2(self.box) self.p.show() self.box.set_show_tabs(False) self.splash = gtk.Image() pixbuf = gtk.gdk.pixbuf_new_from_file("images/splash-colgadito.png") screen = self.window.get_screen() width, height = screen.get_width(), screen.get_height() - style.GRID_CELL_SIZE pixbuf = pixbuf.scale_simple(width, height, gtk.gdk.INTERP_BILINEAR) self.splash.set_from_pixbuf(pixbuf) self.splash.show() eb = gtk.EventBox() eb.add(self.splash) eb.modify_bg(gtk.STATE_NORMAL, gtk.gdk.color_parse("white")) eb.show() self.box.append_page(eb, gtk.Label("Inicio")) self._pygamecanvas = sugargame2.canvas.PygameCanvas(self) self._pygamecanvas.set_flags(gtk.EXPAND) self._pygamecanvas.set_flags(gtk.FILL) self.connect("visibility-notify-event", self.redraw) self._pygamecanvas.set_events(gtk.gdk.BUTTON_PRESS_MASK) self._pygamecanvas.connect("button-press-event", self._pygamecanvas.grab_focus) self.box.append_page(self._pygamecanvas, gtk.Label("Juego")) self.box.show() self.set_canvas(self.p) gobject.timeout_add(300, self.pump) gobject.timeout_add(2000, self.init_interpreter) #gobject.timeout_add(1000, self.build_editor) gobject.timeout_add(1500, self.check_modified) self.build_toolbar() self.credits = None self.editor = None self._pygamecanvas.run_pygame(self.run_game) def redraw(self, widget=None, b=None, c=None): scene = spyral.director.get_scene() if scene: scene.redraw() def alert(self, title=None, text=None, delay=5): alert = NotifyAlert(delay) alert.props.title = title alert.props.msg = text print text self.add_alert(alert) alert.connect('response', self._alert_ok) alert.show() def _alert_ok(self, alert, *args): self.remove_alert(alert) def check_modified(self): if self.box.current_page()==2: if not self.save_button.get_sensitive(): if self.editor.modificado(): self.save_button.set_sensitive(True) return False return True def pump(self): # Esto es necesario porque sino pygame acumula demasiados eventos. pygame.event.pump() def focus_interpreter(self, widget, event): self._interpreter.text.grab_focus() return True def init_interpreter(self): # diferido unos segundos para evitar ver errores superfluos al iniciar self._interpreter = GTKInterpreterConsole(self.redraw) self._interpreter.text.connect('button-press-event', self.focus_interpreter) self.p.pack1(self._interpreter) return False def open_file(self, widget, path): if path: if not os.path.isdir(path): self.editor.open_file(widget, path) def save_file(self, widget): if self.editor.modificado(): self.save_button.set_sensitive(False) self.editor.save_file() filename = self.editor.current_file() self.alert(filename, "Archivo guardado.") gobject.timeout_add(1500, self.check_modified) def build_editor(self): dir_real = os.getcwd() f = os.path.realpath(JUEGO.__file__) f = "." + f.replace(dir_real ,"") # todo esto para obtener una ruta relativa f = f.rstrip("c") # en caso que sea .pyc compilado self.h = gtk.HPaned() self.tree = FileViewer(".", os.path.basename(f)) self.tree.connect("file-selected", self.open_file) self.tree.show() self.h.pack1(self.tree) self.box.append_page(self.h, gtk.Label("Editor")) if False: #os.path.isfile("/usr/bin/gvim"): # Si podemos, lo hacemos self.socket = gtk.Socket() self.socket.show() self.h.pack2(self.socket) sock_id = str(self.socket.get_id()) self.editor = VimSourceView(sock_id) if not self.editor.bufInfo.bufferList: f = JUEGO.__file__ if f.endswith("pyc"): f = f[:-1] self.open_file(None, f) else: self.editor = SourceView() scroller = gtk.ScrolledWindow() scroller.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC) scroller.add(self.editor) scroller.show() self.h.pack2(scroller) self.editor.show() self.h.show() self.open_file(None, f) def build_toolbar(self): toolbar_box = ToolbarBox() self.set_toolbar_box(toolbar_box) toolbar_box.show() activity_button = ActivityToolbarButton(self) toolbar_box.toolbar.insert(activity_button, -1) activity_button.show() tool_group = None self.game_button = RadioToolButton() self.game_button.props.icon_name = 'gamecanvas' self.game_button.set_tooltip(_('Juego')) self.game_button.accelerator = "<Ctrl>1" self.game_button.props.group = tool_group self.game_button.connect('clicked', self.show_game) toolbar_box.toolbar.insert(self.game_button, -1) self.game_button.show() tool_group = self.game_button button = RadioToolButton() button.props.icon_name = 'view-source' button.set_tooltip(_('Editor')) button.accelerator = "<Ctrl>2" button.props.group = tool_group button.connect('clicked', self.show_editor) toolbar_box.toolbar.insert(button, -1) button.show() self.save_button = ToolButton('dialog-ok') self.save_button.set_tooltip(_('Guardar')) self.save_button.accelerator = "<Ctrl>s" self.save_button.connect('clicked', self.save_file) self.save_button.set_sensitive(False) toolbar_box.toolbar.insert(self.save_button, -1) self.save_button.show() separator = gtk.SeparatorToolItem() toolbar_box.toolbar.insert(separator, -1) separator.show() button = ToolButton('system-restart') button.set_tooltip(_('Reiniciar juego')) button.accelerator = "<Alt><Shift>r" button.connect('clicked', self.restart_game) toolbar_box.toolbar.insert(button, -1) button.show() self.editor_button = ToolButton('sources') self.editor_button.set_tooltip(_('Consola')) self.editor_button.accelerator = "<Ctrl>grave" self.editor_button.connect('clicked', self.toggle_console) toolbar_box.toolbar.insert(self.editor_button, -1) self.editor_button.show() separator = gtk.SeparatorToolItem() toolbar_box.toolbar.insert(separator, -1) separator.show() button = helpbutton.HelpButton(self) toolbar_box.toolbar.insert(button, -1) button.show() button = ToolButton() button.props.icon_name = 'activity-about' button.set_tooltip(_('Acerca de')) button.accelerator = "<Ctrl>i" button.connect('clicked', self.run_credits) toolbar_box.toolbar.insert(button, -1) button.show() # Blank space (separator) and Stop button at the end: separator = gtk.SeparatorToolItem() separator.props.draw = False separator.set_expand(True) toolbar_box.toolbar.insert(separator, -1) separator.show() stop_button = StopButton(self) toolbar_box.toolbar.insert(stop_button, -1) stop_button.show() def run_game(self): spyral.director.init((0,0), fullscreen=False, max_fps=30) self.game = JUEGO.Game(activity=self) self.box.connect("switch-page", self.redraw) spyral.director.push(self.game) self.start() def run_credits(self, widget): if not (spyral.director.get_scene()==self.credits): self.credits = game.credits.Creditos(self.game.size) spyral.director.push(self.credits) def start(self): #try: spyral.director.run(sugar = True) #except AttributeError as detail: # detail2 = traceback.format_exc() # self.box.set_page(0) # self.alert( detail2, "Spyral se ha detenido abruptamente.", 60) def show_game(self, widget): self.box.set_page(1) self.redraw() def show_editor(self, widget): if not self.editor: self.build_editor() self.box.set_page(2) self.redraw() def restart_game(self, widget): global JUEGO import objetos try: objetos.reset() except AttributeError: pass self.show_game(None) watch = gtk.gdk.Cursor(gtk.gdk.WATCH) self.window.set_cursor(watch) JUEGO = reload(JUEGO) self.game = JUEGO.Game(activity=self) spyral.director.replace(self.game) self.start() def game_ready(self, widget = None): self.game_button.set_active(True) self.box.set_page(1) self._pygamecanvas.grab_focus() self.window.set_cursor(None) def read_file(self, file_path): pass def write_file(self, file_path): pass def can_close(self): if self.editor: self.editor.close() self.box.set_page(0) try: spyral.director.quit() except spyral.exceptions.GameEndException: pass finally: return True def toggle_console(self, e): if self._interpreter.props.visible: self._interpreter.hide() self._pygamecanvas.grab_focus() else: self.p.set_position(160) self._interpreter.show() self._interpreter.text.grab_focus() self.redraw() def animate_console(self): easing = spyral.easing.Linear(0,160) self.p.set_position(0)
class ShockTherapyActivity(activity.Activity): _MAIN_URL = "layout/main.html" _SCREENSAVER_URL = "layout/main.html#screensaver" _OPTIONS_URL = "layout/main.html#options" _ABOUT_URL = "layout/main.html#about" _URI_WHITELIST = ("http://electroshocktherapy.googlecode.com/", "https://electroshocktherapy.googlecode.com/", "http://wiki.electroshocktherapy.googlecode.com/", "https://wiki.electroshocktherapy.googlecode.com/", "http://code.google.com/p/electroshocktherapy/", "https://code.google.com/p/electroshocktherapy/") def __init__(self, handle): activity.Activity.__init__(self, handle) #logging.getLogger().setLevel(logging.DEBUG) self._http_dir = activity.get_bundle_path() + '/web/' self._base_uri = "file://" + self._http_dir # toolbar with the new toolbar redesign toolbar_box = ToolbarBox() self._back = ToolButton('go-previous') self._back.set_tooltip(_('Back')) self._back.connect('clicked', self._go_back_cb) toolbar_box.toolbar.insert(self._back, -1) separator = gtk.SeparatorToolItem() separator.props.draw = False separator.set_expand(True) toolbar_box.toolbar.insert(separator, -1) self._main_button = ToolButton() self._main_button.set_tooltip(_('Main')) self._main_button.set_icon_widget( Icon(file=os.path.join(activity.get_bundle_path(), 'activity', 'high-voltage-warning.svg'))) self._main_button.connect('clicked', self._main_cb) toolbar_box.toolbar.insert(self._main_button, -1) self._screensaver_button = ToolButton('player_play') self._screensaver_button.set_tooltip(_('Screen Saver')) self._screensaver_button.connect('clicked', self._screensaver_cb) toolbar_box.toolbar.insert(self._screensaver_button, -1) self._options_button = ToolButton('preferences-system') self._options_button.set_tooltip(_('Options')) self._options_button.connect('clicked', self._options_cb) toolbar_box.toolbar.insert(self._options_button, -1) self._about_button = ToolButton('emblem-question') self._about_button.set_tooltip(_('About')) self._about_button.connect('clicked', self._about_cb) toolbar_box.toolbar.insert(self._about_button, -1) separator = gtk.SeparatorToolItem() separator.props.draw = False separator.set_expand(True) toolbar_box.toolbar.insert(separator, -1) reload_button = ToolButton('view-refresh') reload_button.set_tooltip(_('Refresh')) reload_button.connect('clicked', self._reload_cb) toolbar_box.toolbar.insert(reload_button, -1) dev_tools_button = ToolButton('view-source') dev_tools_button.set_tooltip(_('Developer Tools')) toolbar_box.toolbar.insert(dev_tools_button, -1) separator = gtk.SeparatorToolItem() separator.props.draw = False separator.set_expand(True) toolbar_box.toolbar.insert(separator, -1) fullscreen_button = ToolButton('view-fullscreen') fullscreen_button.set_tooltip(_('Fullscreen')) fullscreen_button.connect('clicked', self._fullscreen_cb) toolbar_box.toolbar.insert(fullscreen_button, -1) zoom_in_button = ToolButton('zoom-in') zoom_in_button.set_tooltip(_('Zoom In')) zoom_in_button.connect('clicked', self._zoom_in_cb) toolbar_box.toolbar.insert(zoom_in_button, -1) zoom_out_button = ToolButton('zoom-out') zoom_out_button.set_tooltip(_('Zoom Out')) zoom_out_button.connect('clicked', self._zoom_out_cb) toolbar_box.toolbar.insert(zoom_out_button, -1) zoom_default_button = ToolButton('zoom-original') zoom_default_button.set_tooltip(_('Zoom Default')) zoom_default_button.connect('clicked', self._zoom_default_cb) toolbar_box.toolbar.insert(zoom_default_button, -1) separator = gtk.SeparatorToolItem() separator.props.draw = False separator.set_expand(True) toolbar_box.toolbar.insert(separator, -1) stop_button = StopButton(self) toolbar_box.toolbar.insert(stop_button, -1) self.set_toolbar_box(toolbar_box) self._webview = webkit.WebView() settings = self._webview.get_settings() settings.set_property( 'user-agent', settings.get_property('user-agent') + " sugar:com.googlecode.electroshocktherapy") self._title_req_ids = set() self._webview.connect_after('notify::title', self._dom_title_cb) self._webview.connect('navigation-policy-decision-requested', self._navigate_cb) self._webview.connect('notify::uri', self._webview_uri_cb) self._scrolled_window = gtk.ScrolledWindow() self._scrolled_window.props.hscrollbar_policy = gtk.POLICY_AUTOMATIC self._scrolled_window.props.vscrollbar_policy = gtk.POLICY_AUTOMATIC self._scrolled_window.add(self._webview) self._vpaned = gtk.VPaned() self.set_canvas(self._vpaned) self._vpaned.add1(self._scrolled_window) self.show_all() self._inspector_manager = WebKitWebInspectorManager( self._webview, self._vpaned) dev_tools_button.connect('clicked', self._inspector_manager.toggle) self._urls = {} self._urls["MAIN"] = self._base_uri + self._MAIN_URL self._urls["SCREENSAVER"] = self._base_uri + self._SCREENSAVER_URL self._urls["OPTIONS"] = self._base_uri + self._OPTIONS_URL self._urls["ABOUT"] = self._base_uri + self._ABOUT_URL self._url_button_map = {} self._url_button_map[self._urls["MAIN"]] = self._main_button self._url_button_map[ self._urls["SCREENSAVER"]] = self._screensaver_button self._url_button_map[self._urls["OPTIONS"]] = self._options_button self._url_button_map[self._urls["ABOUT"]] = self._about_button # Initialize button state without delay, so it's in the desired # initial state even before the first page finishes loading. self._uri_cb(self._urls["MAIN"]) self._webview.load_uri(self._urls["MAIN"]) def _navigate_cb(self, view, frame, request, nav_action, policy_decision): uri = request.get_uri() logging.debug("_navigate_cb: %s" % (uri, )) if uri.startswith("about:"): return False elif uri.startswith(self._base_uri) or \ uri.rstrip("/") == self._base_uri.rstrip("/"): return False for allowed_uri in self._URI_WHITELIST: if uri.startswith(allowed_uri) or \ uri.rstrip("/") == allowed_uri.rstrip("/"): return False logging.debug("_navigate_cb reject: %s" % (uri, )) return True def _dom_title_cb(self, view, gParamSpec): """ Use the document.title notify::title property change signal to call Python from JavaScript, as suggested here: http://code.google.com/p/pywebkitgtk/wiki/HowDoI """ title = self._webview.get_main_frame().get_title() #logging.debug("_dom_title_cb: %s" % (title,)) if title is None: self._title_req_ids.clear() else: if title.startswith("ShockTherapySugarRequest:"): parts = title.split(":", 2) if len(parts) != 3: raise ValueError(title) callback = parts[1] path = parts[2] req_id = int(callback[len("shockTherapySugarRequest"):]) if req_id in self._title_req_ids: # suppress event with duplicate req_id pass else: self._title_req_ids.add(req_id) if path.startswith("file:///ShockTherapy."): command = path[len("file:///ShockTherapy."):] status = 200 content = b'' if command.startswith("viewChanged:"): uri = unquote(command[len("viewChanged:"):]) self._uri_cb(uri) elif path.startswith("file:///ShockTherapyConfig."): command = path[len("file:///ShockTherapyConfig."):] status = 200 content = b'' if command == "load": content = self.metadata.get("options") if content is None: content = b"{}" else: content = content.decode(encoding="utf_8", errors="replace") elif command.startswith("persist:"): self.metadata['options'] = unquote( command[len("persist:"):]) elif command.startswith("export:"): options = unquote(command[len("export:"):]) self.metadata['options'] = options options.encode(encoding='utf_8', errors='replace') dsobject = self._save_dsobject( "ShockTherapyOptions.json", options) self._saved_dsobject_alert(dsobject) elif command == "import": chooser = ObjectChooser( parent=self, what_filter=mime.GENERIC_TYPE_TEXT) result = chooser.run() if result == gtk.RESPONSE_ACCEPT: f = open( chooser.get_selected_object(). get_file_path(), 'rb') try: options = f.read() finally: f.close() options = options.decode(encoding='utf_8', errors='replace') self.metadata['options'] = options self._webview.reload() else: path = path[len(self._base_uri):] path = os.path.join(self._http_dir, path) path = os.path.normpath(path) if not (path.startswith(self._http_dir)): # don't allow traversal above _http_dir via ../ status = 404 content = "" else: f = None try: f = open(path, 'rb') content = f.read() except IOError: status = 404 content = "" else: status = 200 finally: if f is not None: f.close() #logging.debug( # "ShockTherapySugarRequest: %s status: %s content: %s" % # (path, status, content)) self._webview.execute_script( "%s(%s, \"%s\")" % (callback, status, base64.b64encode(content))) def _save_dsobject(self, filename, content, mime_type=None, description=None): parent_dir = os.path.join(self.get_activity_root(), 'tmp') try: os.makedirs(parent_dir) except OSError: pass fd, tmp_filename = tempfile.mkstemp(dir=parent_dir, suffix=filename, prefix='tmp') try: os.write(fd, content) except: raise else: dsobject = datastore.create() dsobject.metadata['title'] = filename if mime_type is None: mime_type = mime.get_for_file(tmp_filename) dsobject.metadata['mime_type'] = mime_type if description is None: description = _('From: %s') % (self.metadata['title'], ) dsobject.metadata['description'] = description dsobject.set_file_path(tmp_filename) datastore.write(dsobject) finally: os.close(fd) os.unlink(tmp_filename) return dsobject def _saved_dsobject_alert(self, dsobject): saved_alert = Alert() saved_alert.props.title = _('Download completed') saved_alert.props.msg = dsobject.metadata['title'] saved_alert.add_button(gtk.RESPONSE_APPLY, _('Show in Journal'), Icon(icon_name='zoom-activity')) saved_alert.add_button(gtk.RESPONSE_OK, _('Ok'), Icon(icon_name='dialog-ok')) def response_cb(alert, response_id): if response_id is gtk.RESPONSE_APPLY: activity.show_object_in_journal(dsobject.object_id) self.remove_alert(alert) saved_alert.connect('response', response_cb) self.add_alert(saved_alert) saved_alert.show_all() def _webview_uri_cb(self, view, gParamSpec): self._uri_cb(view.get_property("uri")) def _uri_cb(self, uri): self._back.props.sensitive = self._webview.can_go_back() self._main_button.set_sensitive(True) self._screensaver_button.set_sensitive(True) self._options_button.set_sensitive(True) self._about_button.set_sensitive(True) uri = uri.rstrip("#") disabled_button = self._url_button_map.get(uri) if disabled_button is not None: disabled_button.set_sensitive(False) @staticmethod def _strip_fragment(uri): index = uri.find("#") if index != -1: uri = uri[:index] return uri def _load_uri(self, uri): previous = self._webview.get_property("uri") if self._strip_fragment(uri) == self._strip_fragment(previous): # avoid page reload index = uri.find("#") if index == -1: location_hash = "" else: location_hash = uri[index:] self._webview.execute_script("window.location.hash='%s'" % location_hash) else: self._webview.load_uri(uri) def _go_back_cb(self, button): if self._webview.get_property("uri").startswith(self._urls["MAIN"]): # avoid page reload self._webview.execute_script("ShockTherapy.goBack()") else: self._webview.go_back() def _main_cb(self, button): self._load_uri(self._urls["MAIN"]) def _screensaver_cb(self, button): self._load_uri(self._urls["SCREENSAVER"]) def _options_cb(self, button): self._load_uri(self._urls["OPTIONS"]) def _about_cb(self, button): self._load_uri(self._urls["ABOUT"]) def _reload_cb(self, button): self._webview.reload() def _fullscreen_cb(self, button): self.fullscreen() def _zoom_in_cb(self, button): self._webview.zoom_in() def _zoom_out_cb(self, button): self._webview.zoom_out() def _zoom_default_cb(self, button): if self._webview.get_zoom_level() != 1.0: self._webview.set_zoom_level(1.0)
class NavToolBar(gtk.Toolbar): def __init__(self, activity, shared, deck): gtk.Toolbar.__init__(self) self.__deck = deck self.__activity = activity self.__shared = shared self.__logger = logging.getLogger('Navigation Toolbar') self.__is_initiating = True self.__prevbtn = ToolButton('go-previous') self.__prevbtn.set_tooltip("Previous slide") self.__prevbtn.connect('clicked', self.previous) self.insert(self.__prevbtn, -1) self.__prevbtn.show() self.__nextbtn = ToolButton('go-next') self.__nextbtn.set_tooltip("Next slide") self.__nextbtn.connect('clicked', self.next) self.insert(self.__nextbtn, -1) self.__nextbtn.show() # page number widget and navigation self.__num_page_item = gtk.ToolItem() self.__num_current_page = 1 self.__num_page_entry = gtk.Entry() self.__num_page_entry.set_text(str(self.__num_current_page)) self.__num_page_entry.set_alignment(1) self.__num_page_entry.connect('activate', self.num_page_activate) self.__num_page_entry.set_width_chars(4) self.__num_page_item.add(self.__num_page_entry) self.__num_page_entry.show() self.insert(self.__num_page_item, -1) self.__num_page_item.show() # total page number widget self.__total_page_item = gtk.ToolItem() self.__total_page_label = gtk.Label() label_attributes = pango.AttrList() label_attributes.insert(pango.AttrSize(14000, 0, -1)) label_attributes.insert(pango.AttrForeground(65535, 65535, 65535, 0, -1)) self.__total_page_label.set_attributes(label_attributes) self.__total_page_label.set_text(' / ' + str(self.__deck.getSlideCount())) self.__total_page_item.add(self.__total_page_label) self.__total_page_label.show() self.insert(self.__total_page_item, -1) self.__total_page_item.show() # separator between navigation buttons and lock button separator = gtk.SeparatorToolItem() separator.set_draw(False) separator.set_expand(True) self.insert(separator, -1) separator.show() # unlocked button self.__unlockBtn = ToolButton('unlocked') self.__unlockBtn.set_tooltip("Student Navigation Unlocked") # navigation is unlocked by default, so insert the unlock button self.insert(self.__unlockBtn, 5) self.__unlockBtn.show() # locked button self.__lockBtn = ToolButton('locked') self.__lockBtn.set_tooltip("Student Navigation Locked") self.__logger.debug("Connecting to navigation locking and activity sharing signals.") self.__activity.connect('shared', self.activity_shared_cb) self.__activity.connect('joined', self.activity_joined_cb) self.__shared.connect('navigation-lock-change', self.set_lock_button) # triggers for when slides are changed self.__deck.connect("slide-changed", self.slide_changed) self.__deck.connect("deck-changed", self.slide_changed) self.slide_changed(self.__deck) self.show() def activity_shared_cb(self, widget): #Callback for when the activity is shared # bind the lock button click with switching lock mode self.__lockBtn.connect('clicked', self.__shared.lock_mode_switch) self.__unlockBtn.connect('clicked', self.__shared.lock_mode_switch) def activity_joined_cb(self, widget): """ Callback for when the activity is joined """ self.__is_initiating = False def set_lock_button(self, widget, is_locked): self.__logger.debug("Changing lock button, lock mode %u, init %u", is_locked, self.__is_initiating) if is_locked: new_button = self.__lockBtn if not self.__is_initiating: self.__prevbtn.set_sensitive(False) self.__nextbtn.set_sensitive(False) else: new_button = self.__unlockBtn if not self.__is_initiating: self.__prevbtn.set_sensitive(True) self.__nextbtn.set_sensitive(True) old = self.get_nth_item(5) self.remove(old) self.insert(new_button, 5) new_button.show() self.queue_draw() def next(self, widget): self.__deck.next() def previous(self, widget): self.__deck.previous() def slide_changed(self, widget): self.__logger.debug("Changing slides!") if self.__deck.isAtBeginning(): self.__prevbtn.set_sensitive(False) else: self.__prevbtn.set_sensitive(True) if self.__deck.isAtEnd(): self.__nextbtn.set_sensitive(False) else: self.__nextbtn.set_sensitive(True) self.__num_current_page = self.__deck.getIndex() self.__num_page_entry.set_text(str(self.__num_current_page + 1)) self.__total_page_label.set_text(' / ' + str(self.__deck.getSlideCount())) def num_page_activate(self, entry): page_entered = int(entry.get_text()) if page_entered < 1: page_entered = 1 elif self.__deck.getSlideCount() < page_entered: page_entered = self.__deck.getSlideCount() self.__deck.goToIndex(page_entered - 1, is_local=True)
class RecordControl(): def __init__(self, toolbar): self._timer_value = TIMER_VALUES[0] self._timer_button = ToolButton('timer-0') self._timer_button.set_tooltip(_('Select timer')) self._timer_button.connect('clicked', self._timer_selection_cb) toolbar.insert(self._timer_button, -1) self._setup_timer_palette() self._duration_value = DURATION_VALUES[0] self._duration_button = ToolButton('duration-2') self._duration_button.set_tooltip(_('Select duration')) self._duration_button.connect('clicked', self._duration_selection_cb) toolbar.insert(self._duration_button, -1) self._setup_duration_palette() self._quality_value = 0 self._quality_button = ToolButton('low-quality') self._quality_button.set_tooltip(_('Select quality')) self._quality_button.connect('clicked', self._quality_selection_cb) toolbar.insert(self._quality_button, -1) self._setup_quality_palette() def _timer_selection_cb(self, widget): if self._timer_palette: if not self._timer_palette.is_up(): self._timer_palette.popup(immediate=True, state=self._timer_palette.SECONDARY) else: self._timer_palette.popdown(immediate=True) return def _setup_timer_palette(self): self._timer_palette = self._timer_button.get_palette() for seconds in TIMER_VALUES: if seconds == 0: text = _('Immediate') else: text = ngettext('%s second', '%s seconds', seconds) % seconds menu_item = MenuItem(icon_name='timer-%d' % (seconds), text_label=text) menu_item.connect('activate', self._timer_selected_cb, seconds) self._timer_palette.menu.append(menu_item) menu_item.show() def _timer_selected_cb(self, button, seconds): self.set_timer_idx(TIMER_VALUES.index(seconds)) def _duration_selection_cb(self, widget): if self._duration_palette: if not self._duration_palette.is_up(): self._duration_palette.popup( immediate=True, state=self._duration_palette.SECONDARY) else: self._duration_palette.popdown(immediate=True) return def _setup_duration_palette(self): self._duration_palette = self._duration_button.get_palette() for minutes in DURATION_VALUES: if minutes == 0: text = gtk.Label(_('Immediate')) else: text = ngettext('%s minute', '%s minutes', minutes) % minutes menu_item = MenuItem(icon_name='duration-%d' % (minutes), text_label=text) menu_item.connect('activate', self._duration_selected_cb, minutes) self._duration_palette.menu.append(menu_item) menu_item.show() def _duration_selected_cb(self, button, minutes): self.set_duration_idx(DURATION_VALUES.index(minutes)) def _quality_selection_cb(self, widget): if self._quality_palette: if not self._quality_palette.is_up(): self._quality_palette.popup( immediate=True, state=self._quality_palette.SECONDARY) else: self._quality_palette.popdown(immediate=True) return def _setup_quality_palette(self): self._quality_palette = self._quality_button.get_palette() for quality in QUALITY_VALUES: text = _('%s quality') % (quality) menu_item = MenuItem(icon_name=quality + '-quality', text_label=text) menu_item.connect('activate', self._quality_selected_cb, quality) self._quality_palette.menu.append(menu_item) menu_item.show() def _quality_selected_cb(self, button, quality): self.set_quality(QUALITY_VALUES.index(quality)) def set_mode(self, mode): if mode == constants.MODE_PHOTO: self._quality_button.set_sensitive(False) self._timer_button.set_sensitive(True) self._duration_button.set_sensitive(False) if mode == constants.MODE_VIDEO: self._quality_button.set_sensitive(True) self._timer_button.set_sensitive(True) self._duration_button.set_sensitive(True) if mode == constants.MODE_AUDIO: self._quality_button.set_sensitive(False) self._timer_button.set_sensitive(True) self._duration_button.set_sensitive(True) def get_timer(self): return self._timer_value def get_timer_idx(self): if self._timer_value in TIMER_VALUES: return TIMER_VALUES.index(self._timer_value) else: return TIMER_VALUES[0] def set_timer_idx(self, idx): self._timer_value = TIMER_VALUES[idx] if hasattr(self, '_timer_button'): self._timer_button.set_icon('timer-%d' % (self._timer_value)) def get_duration(self): return self._duration_value def get_duration_idx(self): if self._duration_value in DURATION_VALUES: return DURATION_VALUES.index(self._duration_value) else: return DURATION_VALUES[0] def set_duration_idx(self, idx): self._duration_value = DURATION_VALUES[idx] if hasattr(self, '_duration_button'): self._duration_button.set_icon('duration-%d' % (self._duration_value)) def get_quality(self): return self._quality_value def set_quality(self, idx): self._quality_value = idx if hasattr(self, '_quality_button'): self._quality_button.set_icon('%s-quality' % (QUALITY_VALUES[idx]))
class SwiftFeetActivity(activity.Activity): def __init__(self, handle): activity.Activity.__init__(self, handle) self._current_video_idx = None self.max_participants = 1 # Set blackground as black self.modify_bg(gtk.STATE_NORMAL, gtk.gdk.color_parse("#000000")) if hasattr(self, '_event_box'): # for pre-0.96 self._event_box.modify_bg(gtk.STATE_NORMAL, gtk.gdk.color_parse("#000000")) toolbar_box = ToolbarBox() activity_button = ActivityToolbarButton(self) toolbar_box.toolbar.insert(activity_button, 0) activity_button.show() self._exercise_button = ToolButton('fitness') self._exercise_button.set_tooltip(_("Excercises")) self._exercise_button.connect('clicked', self._index_clicked) self._exercise_button.set_sensitive(False) self._exercise_button.show() toolbar_box.toolbar.insert(self._exercise_button, -1) self._dance_button = ToolButton('dancer') self._dance_button.set_tooltip(_("Dances")) self._dance_button.connect('clicked', self._index_clicked) self._dance_button.show() toolbar_box.toolbar.insert(self._dance_button, -1) separator = gtk.SeparatorToolItem() toolbar_box.toolbar.insert(separator, -1) separator.show() self._prev_button = ToolButton('go-left') self._prev_button.set_tooltip(_("Previous exercise")) self._prev_button.connect('clicked', self._prev_clicked) self._prev_button.set_sensitive(False) self._prev_button.show() toolbar_box.toolbar.insert(self._prev_button, -1) self._next_button = ToolButton('go-right') self._next_button.set_tooltip(_("Next exercise")) self._next_button.connect('clicked', self._next_clicked) self._next_button.set_sensitive(False) self._next_button.show() toolbar_box.toolbar.insert(self._next_button, -1) separator = gtk.SeparatorToolItem() separator.props.draw = False separator.set_expand(True) separator.show() toolbar_box.toolbar.insert(separator, -1) tool = StopButton(self) toolbar_box.toolbar.insert(tool, -1) tool.show() self.set_toolbox(toolbar_box) toolbar_box.show() vbox = PaddedVBox() vbox.show() self.set_canvas(vbox) self._menu = gtk.Table(4, 5, True) self._menu.set_row_spacings(10) self._menu.set_col_spacings(10) vbox.pack_start(self._menu, expand=True, fill=True) self._menu.show() self._videos = EXERCISES self._generate_menu() self._video_title = gtk.Label() self._video_title.modify_fg(gtk.STATE_NORMAL, gtk.gdk.color_parse("#FFFFFF")) vbox.pack_start(self._video_title, expand=False) self._video = VideoPlayer() vbox.pack_start(self._video, expand=True, fill=True, padding=10) self._video.realize() self._video_description = gtk.Label() self._video_description.set_line_wrap(True) self._video_description.modify_fg(gtk.STATE_NORMAL, gtk.gdk.color_parse("#FFFFFF")) vbox.pack_start(self._video_description, expand=False) # Try to fix description height to 3 lines so that it doesn't shift size while # changing videos. self._video_description.set_text("\n\n\n") size_req = self._video_description.size_request() self._video_description.set_size_request(-1, size_req[1]) def _generate_menu(self): for child in self._menu.get_children(): self._menu.remove(child) for (i, video) in enumerate(self._videos): path = os.path.join(activity.get_bundle_path(), "thumbnails", video[0] + ".png") button = VideoButton(video[1], path) button.connect('button_press_event', self.__menu_item_clicked, i) col = i % 5 row = i / 5 self._menu.attach(button, col, col + 1, row, row + 1) button.show_all() def _play_video(self, idx): video = self._videos[idx] self._menu.hide() self._video.show() self._video.stop() self._video_title.set_markup('<span size="x-large" weight="bold">' + glib.markup_escape_text(video[1]) + '</span>') self._video_title.show() if len(video) > 2: self._video_description.set_text(video[2].strip()) else: self._video_description.set_text('') self._video_description.show() if len(video) > 3: music_name = video[3] else: music_name = None self._video.play(video[0], music_name) self._current_video_idx = idx self._dance_button.set_sensitive(True) self._exercise_button.set_sensitive(True) self._prev_button.set_sensitive(idx != 0) self._next_button.set_sensitive(idx != (len(self._videos) - 1)) def _index_clicked(self, widget): self._video.stop() self._video.hide() self._next_button.set_sensitive(False) self._prev_button.set_sensitive(False) self._video_title.hide() self._video_description.hide() if widget == self._exercise_button: self._videos = EXERCISES else: self._videos = DANCES self._generate_menu() self._menu.show() self._exercise_button.set_sensitive(widget == self._dance_button) self._dance_button.set_sensitive(widget == self._exercise_button) def _next_clicked(self, widget): self._play_video(self._current_video_idx + 1) def _prev_clicked(self, widget): self._play_video(self._current_video_idx - 1) def __menu_item_clicked(self, widget, event, idx): logging.warning("CLICKED") self._play_video(idx)
class Item(gobject.GObject): __gsignals__ = { 'activate': (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE, tuple()) } toolitem = None def __init__(self, stock_id=gtk.STOCK_CLEAR, important=False): gobject.GObject.__init__(self) self._stock_id = stock_id self.accel_group = None self.important = important self.connection = None self.connection_data = None self.tooltip = None def set_stock_id(self, stock_id): self._stock_id = stock_id def get_stock_id(self): return self._stock_id stock_id = property(get_stock_id, set_stock_id) def get_menu_item(self): return None def activate_cb(self, widget): self.emit('activate') def setup_accelerator(self): accelerator = stock.get_accelerator(self._stock_id) logger.debug(str(accelerator)) try: if accelerator[1] > 0: self.toolitem.props.accelerator = gtk.accelerator_name( accelerator[1], accelerator[0]) except: logger.error( 'Could not set up accelerator; if toogletoolbutton, update your sugar version' ) def get_tool_item(self): if self._stock_id in stock.icons: icon_name = stock.icons[self._stock_id] else: icon_name = self._stock_id sensitive = self.sensitive self.toolitem = ToolButton(icon_name) self.toolitem.connect('clicked', self.activate_cb) self.setup_tooltip() self.toolitem.set_sensitive(sensitive) return self.toolitem def setup_tooltip(self): if self.tooltip: self.toolitem.set_tooltip(self.tooltip) else: text = gtk.stock_lookup(self._stock_id)[1] self.toolitem.set_tooltip(text.replace('_', '')) self.setup_accelerator() def set_sensitive(self, setting): if self.toolitem: self.toolitem.set_sensitive(setting) def get_sensitive(self): if self.toolitem: return self.toolitem.get_sensitive() else: return True sensitive = property(get_sensitive, set_sensitive)
class InsertToolbar(gtk.Toolbar): def __init__(self, abiword_canvas): gtk.Toolbar.__init__(self) self._abiword_canvas = abiword_canvas self._table = abiword.TableCreator() self._table.set_labels(_('Table'), _('Cancel')) self._table_id = self._table.connect('selected', self._table_cb) image = gtk.Image() image.set_from_icon_name('insert-table', -1) self._table.set_image(image) self._table.set_relief(gtk.RELIEF_NONE) tool_item = gtk.ToolItem() tool_item.add(self._table) self.insert(tool_item, -1) tool_item.show_all() self._table_rows_after = ToolButton('row-insert') self._table_rows_after.set_tooltip(_('Insert Row')) self._table_rows_after_id = self._table_rows_after.connect( \ 'clicked', self._table_rows_after_cb) self.insert(self._table_rows_after, -1) self._table_delete_rows = ToolButton('row-remove') self._table_delete_rows.set_tooltip(_('Delete Row')) self._table_delete_rows_id = self._table_delete_rows.connect( \ 'clicked', self._table_delete_rows_cb) self.insert(self._table_delete_rows, -1) self._table_cols_after = ToolButton('column-insert') self._table_cols_after.set_tooltip(_('Insert Column')) self._table_cols_after_id = self._table_cols_after.connect( \ 'clicked', self._table_cols_after_cb) self.insert(self._table_cols_after, -1) self._table_delete_cols = ToolButton('column-remove') self._table_delete_cols.set_tooltip(_('Delete Column')) self._table_delete_cols_id = self._table_delete_cols.connect( \ 'clicked', self._table_delete_cols_cb) self.insert(self._table_delete_cols, -1) separator = gtk.SeparatorToolItem() self.insert(separator, -1) image = ToolButton('insert-picture') image.set_tooltip(_('Insert Image')) self._image_id = image.connect('clicked', self._image_cb) self.insert(image, -1) self.show_all() self._abiword_canvas.connect('table-state', self._isTable_cb) #self._abiword_canvas.connect('image-selected', self._image_selected_cb) def _image_cb(self, button): def cb(object): logging.debug('ObjectChooser: %r' % object) self._abiword_canvas.insert_image(object.file_path, True) chooser.pick(what=chooser.IMAGE, cb=cb) def _table_cb(self, abi, rows, cols): self._abiword_canvas.insert_table(rows, cols) def _table_rows_after_cb(self, button): self._abiword_canvas.invoke_cmd('insertRowsAfter', '', 0, 0) def _table_delete_rows_cb(self, button): self._abiword_canvas.invoke_cmd('deleteRows', '', 0, 0) def _table_cols_after_cb(self, button): self._abiword_canvas.invoke_cmd('insertColsAfter', '', 0, 0) def _table_delete_cols_cb(self, button): self._abiword_canvas.invoke_cmd('deleteColumns', '', 0, 0) def _isTable_cb(self, abi, b): self._table_rows_after.set_sensitive(b) self._table_delete_rows.set_sensitive(b) self._table_cols_after.set_sensitive(b) self._table_delete_cols.set_sensitive(b)
def __init__(self, handle): super(PeterActivity, self).__init__(handle) # Get user's Sugar colors sugarcolors = profile.get_color().to_string().split(',') colors = [[int(sugarcolors[0][1:3], 16), int(sugarcolors[0][3:5], 16), int(sugarcolors[0][5:7], 16)], [int(sugarcolors[1][1:3], 16), int(sugarcolors[1][3:5], 16), int(sugarcolors[1][5:7], 16)]] # No sharing self.max_participants = 1 # Build the activity toolbar. toolbox = ToolbarBox() activity_button = ActivityToolbarButton(self) toolbox.toolbar.insert(activity_button, 0) activity_button.show() self._add_speed_slider(toolbox.toolbar) cyan = ToolButton('cyan') toolbox.toolbar.insert(cyan, -1) cyan.set_tooltip(_('Next pattern')) cyan.connect('clicked', self._button_cb, 'cyan') cyan.set_sensitive(False) cyan.show() green = ToolButton('green') toolbox.toolbar.insert(green, -1) green.set_tooltip(_('Draw')) green.connect('clicked', self._button_cb, 'green') green.show() red = ToolButton('red') toolbox.toolbar.insert(red, -1) red.set_tooltip(_('Stop')) red.connect('clicked', self._button_cb, 'red') red.show() separator = gtk.SeparatorToolItem() separator.props.draw = True toolbox.toolbar.insert(separator, -1) separator.show() label = gtk.Label('') label.set_use_markup(True) label.show() labelitem = gtk.ToolItem() labelitem.add(label) toolbox.toolbar.insert(labelitem, -1) labelitem.show() separator = gtk.SeparatorToolItem() separator.props.draw = False separator.set_expand(True) toolbox.toolbar.insert(separator, -1) separator.show() stop_button = StopButton(self) stop_button.props.accelerator = _('<Ctrl>Q') toolbox.toolbar.insert(stop_button, -1) stop_button.show() toolbox.show() self.set_toolbox(toolbox) # Create the game instance. self.game = Spirolaterals.Spirolaterals(colors) # Build the Pygame canvas. self._pygamecanvas = \ sugargame.canvas.PygameCanvas(self) # Note that set_canvas implicitly calls # read_file when resuming from the Journal. self.set_canvas(self._pygamecanvas) self.game.canvas = self._pygamecanvas gtk.gdk.screen_get_default().connect('size-changed', self.__configure_cb) # Start the game running. self.game.set_cyan_button(cyan) self.game.set_label(label) self._speed_range.set_value(200) self._pygamecanvas.run_pygame(self.game.run)
class CreateToolbar(gtk.Toolbar): __gtype_name__ = 'CreateToolbar' __gsignals__ = { 'create_new_game': (SIGNAL_RUN_FIRST, None, []), 'create_load_game': (SIGNAL_RUN_FIRST, None, [TYPE_PYOBJECT]), 'create_save_game': (SIGNAL_RUN_FIRST, None, 3 * [TYPE_PYOBJECT]), 'create_equal_pairs': (SIGNAL_RUN_FIRST, None, [TYPE_PYOBJECT]), } def __init__(self, activity): gtk.Toolbar.__init__(self) self.activity = activity self._lock = True # New Button new_icon = join(dirname(__file__), 'images', 'game-new.svg') new_image = gtk.Image() new_image.set_from_file(new_icon) self._new_button = ToolButton() self._new_button.set_icon_widget(new_image) self._new_button.set_tooltip(_('New game')) self._new_button.connect('clicked', self._new_game_bt) self._add_widget(self._new_button) # Load Button load_icon = join(dirname(__file__), 'images', 'game-load.svg') load_image = gtk.Image() load_image.set_from_file(load_icon) self._load_button = ToolButton() self._load_button.set_icon_widget(load_image) self._load_button.set_tooltip(_('Load game')) self._load_button.connect('clicked', self._load_game) self._add_widget(self._load_button) # Save Button save_icon = join(dirname(__file__), 'images', 'game-save.svg') save_image = gtk.Image() save_image.set_from_file(save_icon) self._save_button = ToolButton() self._save_button.set_icon_widget(save_image) self._save_button.set_tooltip(_('Save game')) self._save_button.connect('clicked', self._save_game_bt) self._save_button.set_sensitive(False) self._add_widget(self._save_button) # Separator separator2 = gtk.SeparatorToolItem() separator2.set_draw(True) self.insert(separator2, -1) self._add_widget(gtk.Label(_('Game name') + ': ')) self.game_name_entry = gtk.Entry() self._add_widget(self.game_name_entry) self._equal_pairs = gtk.CheckButton(_('Equal pairs')) self._add_widget(self._equal_pairs) self._equal_pairs.connect('toggled', self._emit_equal_pairs) self._grouped_icon1 = join(dirname(__file__), 'images', 'equal_pairs1.svg') self._grouped_icon2 = join(dirname(__file__), 'images', 'equal_pairs2.svg') self._grouped_image1 = gtk.Image() self._grouped_image2 = gtk.Image() self._grouped_image1.set_from_file(self._grouped_icon1) self._grouped_image2.set_from_file(self._grouped_icon2) self._grouped = ToggleToolButton() self._grouped.set_icon_widget(self._grouped_image1) self._grouped.set_tooltip(_('Click for grouped game')) self._grouped.connect('toggled', self._grouped_cb) self._add_widget(self._grouped) def _add_widget(self, widget, expand=False): tool_item = gtk.ToolItem() tool_item.set_expand(expand) tool_item.add(widget) widget.show() self.insert(tool_item, -1) tool_item.show() def _game_changed_cb(self, combobox, game_name): self.game_name_entry.set_text(game_name) self.emit('create_load_game', game_name) def _load_game(self, button): chooser = ObjectChooser(_('Choose memorize game'), parent=self.activity, flags=gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT) jobject = '' try: result = chooser.run() if result == gtk.RESPONSE_ACCEPT: logging.debug('ObjectChooser: %r' % chooser.get_selected_object()) jobject = chooser.get_selected_object() if not jobject or not jobject.file_path: return finally: chooser.destroy() del chooser if jobject and jobject.file_path: self.emit('create_load_game', jobject.file_path) self._save_button.set_sensitive(False) def _new_game_bt(self, button): self.game_name_entry.set_text('') self._equal_pairs.set_active(False) self._grouped.set_active(False) self.emit('create_new_game') self._new_button.set_sensitive(False) self._save_button.set_sensitive(False) def _save_game_bt(self, button): self.emit('create_save_game', self.game_name_entry.get_text(), self._equal_pairs.get_active(), self._grouped.get_active()) self._save_button.set_sensitive(False) def _emit_equal_pairs(self, checkbutton): self.emit('create_equal_pairs', checkbutton.get_active()) self._save_button.set_sensitive(True) def _grouped_cb(self, widget): self._save_button.set_sensitive(True) if self._grouped.get_active(): self._grouped.set_icon_widget(self._grouped_image2) self._grouped_image2.show() self._grouped.set_tooltip(_('Click for ungrouped game')) else: self._grouped.set_icon_widget(self._grouped_image1) self._grouped_image1.show() self._grouped.set_tooltip(_('Click for grouped game')) def update_create_toolbar(self, widget, game_name, equal_pairs, grouped): self.game_name_entry.set_text(game_name) self._equal_pairs.set_active(equal_pairs == 'True') self._grouped.set_active(grouped == '1') def update_buttons_status(self, widget, new, save): self._new_button.set_sensitive(new) self._save_button.set_sensitive(save)
def __init__(self, handle): activity.Activity.__init__(self, handle, True) self.max_participants = 1 # Calendar self._calendar = gtk.Calendar() self._calendar_size_ready = False self._calendar.connect('size_allocate', self._calendar_size_allocate) # TODO: Create a Help dialog like Implode #self._helpdialog = HelpDialog() # Canvas scroll = gtk.ScrolledWindow() scroll.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC) self.notes_area = NotesArea() scroll.add_with_viewport(self.notes_area) self.set_canvas(scroll) # Toolbars toolbarbox = ToolbarBox() activity_button = ActivityToolbarButton(self) toolbarbox.toolbar.insert(activity_button, 0) activity_button.show() separator = gtk.SeparatorToolItem() toolbarbox.toolbar.insert(separator, -1) note_add = ToolButton('gtk-add') note_add.set_tooltip(_('Add a note')) note_add.connect('clicked', self._show_add_button_pallete) toolbarbox.toolbar.insert(note_add, -1) self._calendar.connect('day-selected-double-click', self.__add_note_cb, note_add) note_remove = ToggleToolButton('gtk-remove') note_remove.set_tooltip(_('Remove notes')) note_remove.connect('clicked', self._active_remove) toolbarbox.toolbar.insert(note_remove, -1) separator = gtk.SeparatorToolItem() toolbarbox.toolbar.insert(separator, -1) back = ToolButton('go-left') back.set_tooltip(_('Select previous note')) back.set_sensitive(False) back.connect('clicked', lambda w: self.notes_area.select_note(-1)) toolbarbox.toolbar.insert(back, -1) _next = ToolButton('go-right') _next.set_tooltip(_('Select next note')) _next.connect('clicked', lambda w: self.notes_area.select_note(+1)) _next.set_sensitive(False) toolbarbox.toolbar.insert(_next, -1) #helpbtn = ToolButton('toolbar-help') #helpbtn.set_tooltip(_('Help')) #helpbtn.connect('clicked', self.help) #toolbarbox.toolbar.insert(helpbtn) separator = gtk.SeparatorToolItem() separator.set_draw(False) separator.set_expand(True) toolbarbox.toolbar.insert(separator, -1) stopbtn = StopButton(self) toolbarbox.toolbar.insert(stopbtn, -1) self.set_toolbar_box(toolbarbox) self.notes_area.connect('no-notes', self._no_notes, note_remove, back, _next) self.notes_area.connect('note-added', self._note_added, back, _next) self.show_all() self._create_add_button_pallete(note_add)
class TextAttributesToolbar(gtk.Toolbar): def __init__(self, main_area): gtk.Toolbar.__init__(self) self._main_area = main_area self._font_list = ['ABC123', 'Sans', 'Serif', 'Monospace', 'Symbol'] self._font_sizes = [ '8', '9', '10', '11', '12', '14', '16', '20', '22', '24', '26', '28', '36', '48', '72' ] self.font_button = ToolButton('font-text') self.font_button.set_tooltip(_('Select font')) self.font_button.connect('clicked', self.__font_selection_cb) self.insert(self.font_button, -1) self._setup_font_palette() self.insert(gtk.SeparatorToolItem(), -1) self.font_size_up = ToolButton('resize+') self.font_size_up.set_tooltip(_('Bigger')) self.font_size_up.connect('clicked', self.__font_sizes_cb, True) self.insert(self.font_size_up, -1) if len(self._main_area.selected) > 0: font_size = self._main_area.font_size else: font_size = utils.default_font_size self.size_label = gtk.Label(str(font_size)) self.size_label.show() toolitem = gtk.ToolItem() toolitem.add(self.size_label) toolitem.show() self.insert(toolitem, -1) self.font_size_down = ToolButton('resize-') self.font_size_down.set_tooltip(_('Smaller')) self.font_size_down.connect('clicked', self.__font_sizes_cb, False) self.insert(self.font_size_down, -1) self.insert(gtk.SeparatorToolItem(), -1) self.bold = ToolButton('bold-text') self.bold.set_tooltip(_('Bold')) self.bold.connect('clicked', self.__bold_cb) self.insert(self.bold, -1) self.italics = ToolButton('italics-text') self.italics.set_tooltip(_('Italics')) self.italics.connect('clicked', self.__italics_cb) self.insert(self.italics, -1) self.underline = ToolButton('underline-text') self.underline.set_tooltip(_('Underline')) self.underline.connect('clicked', self.__underline_cb) self.insert(self.underline, -1) foreground_color = ColorToolButton() foreground_color.set_title(_('Set font color')) foreground_color.connect('color-set', self.__foreground_color_cb) self.insert(foreground_color, -1) bakground_color = ColorToolButton() bakground_color.set_title(_('Set background color')) bakground_color.connect('color-set', self.__background_color_cb) bakground_color.set_color(gtk.gdk.Color(65535, 65535, 65535)) self.insert(bakground_color, -1) self.show_all() def __font_selection_cb(self, widget): if self._font_palette: if not self._font_palette.is_up(): self._font_palette.popup(immediate=True, state=self._font_palette.SECONDARY) else: self._font_palette.popdown(immediate=True) return def _init_font_list(self): self._font_white_list = [] self._font_white_list.extend(DEFAULT_FONTS) # check if there are a user configuration file if not os.path.exists(USER_FONTS_FILE_PATH): # verify if exists a file in /etc if os.path.exists(GLOBAL_FONTS_FILE_PATH): shutil.copy(GLOBAL_FONTS_FILE_PATH, USER_FONTS_FILE_PATH) if os.path.exists(USER_FONTS_FILE_PATH): # get the font names in the file to the white list fonts_file = open(USER_FONTS_FILE_PATH) # get the font names in the file to the white list for line in fonts_file: self._font_white_list.append(line.strip()) # monitor changes in the file gio_fonts_file = gio.File(USER_FONTS_FILE_PATH) self.monitor = gio_fonts_file.monitor_file() self.monitor.set_rate_limit(5000) self.monitor.connect('changed', self._reload_fonts) def _reload_fonts(self, monitor, gio_file, other_file, event): if event != gio.FILE_MONITOR_EVENT_CHANGES_DONE_HINT: return self._font_white_list = [] self._font_white_list.extend(DEFAULT_FONTS) fonts_file = open(USER_FONTS_FILE_PATH) for line in fonts_file: self._font_white_list.append(line.strip()) # update the menu for child in self._font_palette.menu.get_children(): self._font_palette.menu.remove(child) child = None context = self.get_pango_context() tmp_list = [] for family in context.list_families(): name = family.get_name() if name in self._font_white_list: tmp_list.append(name) for font in sorted(tmp_list): menu_item = MyMenuItem(image=FontImage(font.replace(' ', '-')), text_label=font) menu_item.connect('activate', self.__font_selected_cb, font) self._font_palette.menu.append(menu_item) menu_item.show() return False def _setup_font_palette(self): self._init_font_list() context = self._main_area.pango_context for family in context.list_families(): name = pango.FontDescription(family.get_name()).to_string() if name not in self._font_list and \ name in self._font_white_list: self._font_list.append(name) self._font_palette = self.font_button.get_palette() for font in sorted(self._font_list): menu_item = MyMenuItem(image=FontImage(font.replace(' ', '-')), text_label=font) menu_item.connect('activate', self.__font_selected_cb, font) self._font_palette.menu.append(menu_item) menu_item.show() def __font_selected_cb(self, widget, font_name): if not hasattr(self._main_area, 'font_name'): return if len(self._main_area.selected) > 0: font_size = self._main_area.font_size else: font_size = utils.default_font_size self._main_area.set_font(font_name, font_size) self._main_area.font_name = font_name self._main_area.font_size = font_size def __attribute_values(self): attributes = { "bold": True, "italics": True, "underline": True, "font": "" } it = self._main_area.selected[0].attributes.get_iterator() start_index = self._main_area.selected[0].index end_index = self._main_area.selected[0].end_index while (1): found = False r = it.range() if start_index == end_index: if r[0] <= start_index and r[1] > start_index: found = True elif start_index < end_index: if r[0] > end_index: break if start_index == end_index and \ r[0] < start_index and \ r[1] > start_index: found = True elif start_index != end_index and r[0] <= start_index and \ r[1] >= end_index: found = True else: if r[0] > start_index: break if start_index == end_index and \ r[0] < start_index and \ r[1] > start_index: found = True elif start_index != end_index and r[0] <= end_index and \ r[1] >= start_index: found = True if found: attr = it.get_attrs() for x in attr: if x.type == pango.ATTR_WEIGHT and \ x.value == pango.WEIGHT_BOLD: attributes["bold"] = False elif x.type == pango.ATTR_STYLE and \ x.value == pango.STYLE_ITALIC: attributes["italics"] = False elif x.type == pango.ATTR_UNDERLINE and \ x.value == pango.UNDERLINE_SINGLE: attributes["underline"] = False elif x.type == pango.ATTR_FONT_DESC: attributes["font"] = x.desc if it.next() == False: break return attributes def __font_sizes_cb(self, button, increase): if not hasattr(self._main_area, 'font_size'): return if len(self._main_area.selected) < 1: return font_size = self._main_area.font_size if font_size in self._font_sizes: i = self._font_sizes.index(font_size) if increase: if i < len(self._font_sizes) - 2: i += 1 else: if i > 0: i -= 1 else: i = self._font_sizes.index(utils.default_font_size) font_size = self._font_sizes[i] self.size_label.set_text(str(font_size)) self.font_size_down.set_sensitive(i != 0) self.font_size_up.set_sensitive(i < len(self._font_sizes) - 2) self._main_area.set_font(self._main_area.font_name, font_size) def __bold_cb(self, button): if len(self._main_area.selected) < 1: return value = self.__attribute_values()["bold"] self._main_area.set_bold(value) def __italics_cb(self, button): if len(self._main_area.selected) < 1: return value = self.__attribute_values()["italics"] self._main_area.set_italics(value) def __underline_cb(self, button): if len(self._main_area.selected) < 1: return value = self.__attribute_values()["underline"] self._main_area.set_underline(value) def __foreground_color_cb(self, button): color = button.get_color() self._main_area.set_foreground_color(color) def __background_color_cb(self, button): color = button.get_color() self._parent._main_area.set_background_color(color) def change_active_font(self): # TODO: update the toolbar return
class VideoPlayerActivity(activity.Activity): def __init__(self, handle): activity.Activity.__init__(self, handle) self._current_video_idx = 0 self._lesson_state = False self.max_participants = 1 # Set blackground as blue self.modify_bg(gtk.STATE_NORMAL, gtk.gdk.color_parse('#3FBDAC')) if hasattr(self, '_event_box'): # for pre-0.96 self._event_box.modify_bg(gtk.STATE_NORMAL, gtk.gdk.color_parse('#3FBDAC')) toolbar_box = ToolbarBox() activity_button = ActivityToolbarButton(self) toolbar_box.toolbar.insert(activity_button, 0) activity_button.show() self._play_button = ToolButton('media-playback-start') self._play_button.set_tooltip(_('Play video')) self._play_button.connect('clicked', self._play_clicked) self._play_button.set_sensitive(True) self._play_button.show() toolbar_box.toolbar.insert(self._play_button, -1) self._pause_button = ToolButton('media-playback-pause') self._pause_button.set_tooltip(_('Pause video')) self._pause_button.connect('clicked', self._pause_clicked) self._pause_button.set_sensitive(False) self._pause_button.show() toolbar_box.toolbar.insert(self._pause_button, -1) self._stop_button = ToolButton('media-playback-stop') self._stop_button.set_tooltip(_('Stop video')) self._stop_button.connect('clicked', self._stop_clicked) self._stop_button.set_sensitive(False) self._stop_button.show() toolbar_box.toolbar.insert(self._stop_button, -1) self._lesson_button = ToolButton('view-list') self._lesson_button.connect('clicked', self._toggle_lesson) self._lesson_button.set_tooltip(_('View lesson')) self._lesson_button.set_sensitive(False) self._lesson_button.show() toolbar_box.toolbar.insert(self._lesson_button, -1) separator = gtk.SeparatorToolItem() separator.props.draw = False separator.set_expand(True) separator.show() toolbar_box.toolbar.insert(separator, -1) tool = StopButton(self) toolbar_box.toolbar.insert(tool, -1) tool.show() self.set_toolbox(toolbar_box) toolbar_box.show() vbox = PaddedVBox() vbox.show() self.set_canvas(vbox) self._menu = gtk.Table(2, 3, True) self._menu.set_row_spacings(10) self._menu.set_col_spacings(10) vbox.pack_start(self._menu, expand=True, fill=True) self._menu.show() self._videos = VIDEOS self._lessons = LESSONS self._generate_menu() self._video_title = gtk.Label() # self._video_title.modify_fg( # gtk.STATE_NORMAL, gtk.gdk.color_parse('#FFFFFF')) vbox.pack_start(self._video_title, expand=False) self._video = VideoPlayer() vbox.pack_start(self._video, expand=True, fill=True, padding=10) self._video.realize() self._video_description = gtk.Label() self._video_description.set_text('\n\n\n\n') self._video_description.set_line_wrap(True) self._video_description.set_size_request( gtk.gdk.screen_width() - style.GRID_CELL_SIZE * 2, -1) # self._video_description.modify_fg( # gtk.STATE_NORMAL, gtk.gdk.color_parse('#FFFFFF')) vbox.pack_start(self._video_description, expand=False) self._lesson_text = gtk.Label() self._lesson_text.set_line_wrap(True) # self._lesson_text.modify_fg( # gtk.STATE_NORMAL, gtk.gdk.color_parse('#FFFFFF')) self._lesson_text.set_size_request( gtk.gdk.screen_width() - style.GRID_CELL_SIZE * 3, gtk.gdk.screen_height() - style.GRID_CELL_SIZE * 3) vbox.pack_start(self._lesson_text, expand=True, fill=True, padding=10) vbox.show() # Try to fix description height to 4 lines so that it doesn't # shift size while changing videos. # self._video_description.set_text('\n\n\n\n') # size_req = self._video_description.size_request() # self._video_description.set_size_request(-1, size_req[1]) def write_file(self, file_path): # Force video to stop self._stop_clicked(None) def _generate_menu(self): for child in self._menu.get_children(): self._menu.remove(child) for (i, video) in enumerate(self._videos): print video[0] path = os.path.join(activity.get_bundle_path(), 'thumbnails', video[0][0:-4] + '.png') # FIXME: make more robust button = VideoButton(video[1], path) button.connect('button_press_event', self.__menu_item_clicked, i) col = i % 4 row = i / 4 self._menu.attach(button, col, col + 1, row, row + 1) button.show_all() def _toggle_lesson(self, button): if not self._lesson_state: self._pause_clicked(None) self._show_lesson() else: self._hide_lesson() self._play_clicked(None) def _show_lesson(self): self._lesson_state = True self._video.hide() self._video_description.hide() self._lesson_text.show() self._lesson_button.set_sensitive(False) def _hide_lesson(self): self._lesson_state = False self._lesson_text.hide() self._video.show() self._video_description.show() self._lesson_button.set_sensitive(True) def _play_video(self, idx): video = self._videos[idx] self._menu.hide() self._hide_lesson() self._video.show() self._video.stop() self._video_title.set_markup('<span size="x-large" weight="bold">' + \ glib.markup_escape_text(video[1]) + \ '</span>') self._video_title.show() if len(video) > 2: self._video_description.set_text(video[2].strip()) else: self._video_description.set_text('') self._video_description.show() self._lesson_button.set_sensitive(True) self._lesson_text.set_markup(self._lessons[idx]) self._video.play(video[0]) self._current_video_idx = idx def __menu_item_clicked(self, widget, event, idx): self._pause_button.set_sensitive(True) self._stop_button.set_sensitive(True) self._lesson_button.set_sensitive(True) self._play_button.set_sensitive(False) self._play_video(idx) def _play_clicked(self, widget): if self._lesson_state: self._hide_lesson() if self._video.paused: self._video.unpause() else: self._play_video(self._current_video_idx) self._pause_button.set_sensitive(True) self._stop_button.set_sensitive(True) self._lesson_button.set_sensitive(True) self._play_button.set_sensitive(False) def _pause_clicked(self, widget): if not self._video.paused: self._video.pause() self._pause_button.set_sensitive(False) self._stop_button.set_sensitive(True) self._lesson_button.set_sensitive(True) self._play_button.set_sensitive(True) def _stop_clicked(self, widget): if self._video.playing: self._video.stop() self._pause_button.set_sensitive(False) self._stop_button.set_sensitive(False) self._lesson_button.set_sensitive(False) self._play_button.set_sensitive(True) self._video.hide() self._video_title.hide() self._video_description.hide() self._lesson_text.hide() self._menu.show()
def __init__(self, handle): super(PeterActivity, self).__init__(handle) # Get user's Sugar colors sugarcolors = profile.get_color().to_string().split(',') colors = [[ int(sugarcolors[0][1:3], 16), int(sugarcolors[0][3:5], 16), int(sugarcolors[0][5:7], 16) ], [ int(sugarcolors[1][1:3], 16), int(sugarcolors[1][3:5], 16), int(sugarcolors[1][5:7], 16) ]] # No sharing self.max_participants = 1 self.datapath = os.path.join(activity.get_activity_root(), 'instance') # Build the activity toolbar. toolbox = ToolbarBox() activity_button = ActivityToolbarButton(self) toolbox.toolbar.insert(activity_button, 0) activity_button.show() self._add_speed_slider(toolbox.toolbar) cyan = ToolButton('cyan') toolbox.toolbar.insert(cyan, -1) cyan.set_tooltip(_('Next pattern')) cyan.connect('clicked', self._button_cb, 'cyan') cyan.set_sensitive(False) cyan.show() green = ToolButton('green') toolbox.toolbar.insert(green, -1) green.set_tooltip(_('Draw')) green.connect('clicked', self._button_cb, 'green') green.show() red = ToolButton('red') toolbox.toolbar.insert(red, -1) red.set_tooltip(_('Stop')) red.connect('clicked', self._button_cb, 'red') red.show() separator = gtk.SeparatorToolItem() separator.props.draw = True toolbox.toolbar.insert(separator, -1) separator.show() label = gtk.Label('') label.set_use_markup(True) label.show() labelitem = gtk.ToolItem() labelitem.add(label) toolbox.toolbar.insert(labelitem, -1) labelitem.show() export = ToolButton('export-turtleblocks') toolbox.toolbar.insert(export, -1) export.set_tooltip(_('Export to TurtleBlocks')) export.connect('clicked', self._export_turtleblocks_cb) export.show() separator = gtk.SeparatorToolItem() separator.props.draw = False separator.set_expand(True) toolbox.toolbar.insert(separator, -1) separator.show() stop_button = StopButton(self) stop_button.props.accelerator = _('<Ctrl>Q') toolbox.toolbar.insert(stop_button, -1) stop_button.show() toolbox.show() self.set_toolbox(toolbox) # Create the game instance. self.game = Spirolaterals.Spirolaterals(colors) # Build the Pygame canvas. self._pygamecanvas = \ sugargame.canvas.PygameCanvas(self) # Note that set_canvas implicitly calls # read_file when resuming from the Journal. self.set_canvas(self._pygamecanvas) self.game.canvas = self._pygamecanvas gtk.gdk.screen_get_default().connect('size-changed', self.__configure_cb) # Start the game running. self.game.set_cyan_button(cyan) self.game.set_label(label) self._speed_range.set_value(200) self._pygamecanvas.run_pygame(self.game.run)
class GameToolbar(gtk.Toolbar): __gtype_name__ = 'GameToolbar' __gsignals__ = { 'game-restart': (SIGNAL_RUN_FIRST, TYPE_NONE, []), 'ai-activated': (SIGNAL_RUN_FIRST, TYPE_NONE, []), 'ai-deactivated': (SIGNAL_RUN_FIRST, TYPE_NONE, []), 'game-board-size': (SIGNAL_RUN_FIRST, TYPE_NONE, [TYPE_INT]), } def __init__(self, activity): gtk.Toolbar.__init__(self) self.activity = activity # Reset Button restart_icon = join(dirname(__file__), 'images', 'gtk-refresh.svg') restart_image = gtk.Image() restart_image.set_from_file(restart_icon) self._restart_button = ToolButton() self._restart_button.set_icon_widget(restart_image) self._restart_button.connect('clicked', self._game_restart_cb) self._restart_button.set_tooltip(_('Restart Game')) self.insert(self._restart_button, -1) self._restart_button.show() # Separator separator = gtk.SeparatorToolItem() separator.set_draw(True) self.insert(separator, -1) self._add_widget(gtk.Label(_('Board size') + ': ')) # Change size combobox self._size_combo = ToolComboBox() self._sizes = ['19 X 19', '13 X 13', '9 X 9'] for i, f in enumerate(self._sizes): self._size_combo.combo.append_item(i, f) self._size_combo.combo.connect('changed', self._game_size_cb) self._add_widget(self._size_combo) self._size_combo.combo.set_active(0) # Separator separator = gtk.SeparatorToolItem() separator.set_draw(True) self.insert(separator, -1) # Artificial Intelligence Button self._ai_button = gtk.ToggleToolButton() if search_for_gnugo(): self._ai_button.connect('toggled', self._ai_toggled_cb) self._ai_button.set_label(_('Play against PlayGo!')) else: self._ai_button.set_label( _('You need to install gnugo to play against PlayGo')) self._ai_button.set_sensitive(False) self.insert(self._ai_button, -1) self._ai_button.show() def _add_widget(self, widget, expand=False): tool_item = gtk.ToolItem() tool_item.set_expand(expand) tool_item.add(widget) widget.show() self.insert(tool_item, -1) tool_item.show() def _game_restart_cb(self, widget): self._size_combo.set_sensitive(True) self.emit('game-restart') def grey_out_restart(self): self._restart_button.set_sensitive(False) def _game_size_cb(self, widget): game_size = int(self._sizes[self._size_combo.combo.get_active()][:2]) self.emit('game-board-size', game_size) def grey_out_size_change(self): self._size_combo.set_sensitive(False) def update_toolbar(self, widget, data, grid): size = data.get('size') self._size_combo.combo.handler_block(self.size_handle_id) size_index = self._sizes.index(size + ' X ' + size) self._size_combo.combo.set_active(int(size_index)) self._size_combo.combo.handler_unblock(self.size_handle_id) def _ai_toggled_cb(self, widget): if widget.get_active(): self.emit('ai-activated') else: self.emit('ai-deactivated') def grey_out_ai(self): self._ai_button.set_sensitive(False) def set_ai_button_state(self, value): self._ai_button.set_active(value)
class GameToolbar(gtk.Toolbar): __gtype_name__ = 'GameToolbar' __gsignals__ = { 'game-restart': (SIGNAL_RUN_FIRST, TYPE_NONE, []), 'ai-activated': (SIGNAL_RUN_FIRST, TYPE_NONE, []), 'ai-deactivated': (SIGNAL_RUN_FIRST, TYPE_NONE, []), 'game-board-size': (SIGNAL_RUN_FIRST, TYPE_NONE, [TYPE_INT]), } def __init__(self, activity): gtk.Toolbar.__init__(self) self.activity = activity # Reset Button restart_icon = join(dirname(__file__), 'images', 'gtk-refresh.svg') restart_image = gtk.Image() restart_image.set_from_file(restart_icon) self._restart_button = ToolButton() self._restart_button.set_icon_widget(restart_image) self._restart_button.connect('clicked', self._game_restart_cb) self._restart_button.set_tooltip(_('Restart Game')) self.insert(self._restart_button, -1) self._restart_button.show() # Separator separator = gtk.SeparatorToolItem() separator.set_draw(True) self.insert(separator, -1) self._add_widget(gtk.Label(_('Board size') + ': ')) # Change size combobox self._size_combo = ToolComboBox() self._sizes = ['19 X 19', '13 X 13', '9 X 9'] for i, f in enumerate(self._sizes): self._size_combo.combo.append_item(i, f) self._size_combo.combo.connect('changed', self._game_size_cb) self._add_widget(self._size_combo) self._size_combo.combo.set_active(0) # Separator separator = gtk.SeparatorToolItem() separator.set_draw(True) self.insert(separator, -1) # Artificial Intelligence Button self._ai_button = gtk.ToggleToolButton() if search_for_gnugo(): self._ai_button.connect('toggled', self._ai_toggled_cb) self._ai_button.set_label(_('Play against PlayGo!')) else: self._ai_button.set_label(_('You need to install gnugo to play against PlayGo')) self._ai_button.set_sensitive(False) self.insert(self._ai_button, -1) self._ai_button.show() def _add_widget(self, widget, expand=False): tool_item = gtk.ToolItem() tool_item.set_expand(expand) tool_item.add(widget) widget.show() self.insert(tool_item, -1) tool_item.show() def _game_restart_cb(self, widget): self._size_combo.set_sensitive(True) self.emit('game-restart') def grey_out_restart(self): self._restart_button.set_sensitive(False) def _game_size_cb(self, widget): game_size = int(self._sizes[self._size_combo.combo.get_active()][:2]) self.emit('game-board-size', game_size) def grey_out_size_change(self): self._size_combo.set_sensitive(False) def update_toolbar(self, widget, data, grid): size = data.get('size') self._size_combo.combo.handler_block(self.size_handle_id) size_index = self._sizes.index(size+' X '+size) self._size_combo.combo.set_active(int(size_index)) self._size_combo.combo.handler_unblock(self.size_handle_id) def _ai_toggled_cb(self, widget): if widget.get_active(): self.emit('ai-activated') else: self.emit('ai-deactivated') def grey_out_ai(self): self._ai_button.set_sensitive(False) def set_ai_button_state(self, value): self._ai_button.set_active(value)
class FreeFromMalariaActivity(activity.Activity): def __init__(self, handle): activity.Activity.__init__(self, handle) self.activity_state = {} self._name = handle self.set_title(_("Free From Malaria")) restartTitle = _("End User Licence"); restartText = _("The materials in this game are in no way intended to replace or supersede professional medical care, advice, diagnosis or treatment of a doctor. The game only provides general advice on Malaria. This advice may not apply to everyone in every locality. If you notice medical symptoms or feel ill, you should consult your doctor. Please seek further advice from your local health authority for further information about Malaria.All information provided in this activity has been produced using peer reviewed scientific and health documentation. By clicking OK you agree that this game should be used for general educational and information purposes only and is not intended to replace medical advice or act as a diagnosis tool. For more details please visit http://worldclassproject.org.uk/."); dialog = self.create_dialog_ok(restartTitle, restartText) result = dialog.run() dialog.destroy() #init the controller #game controller if handle.object_id == None: print "Launched from home." else: print "Journal resume." # Set title for our Activity self.set_title('Free From Malaria') # Attach sugar toolbox (Share, ...) # Use old <= 0.84 toolbar design toolbox = activity.ActivityToolbox(self) view_tool_bar = toolbox.get_activity_toolbar();#gtk.Toolbar() #for debug only # self.previous_chapter = ToolButton('gtk-media-forward-rtl') # self.previous_chapter.set_tooltip("Previous Chapter") # self.previous_chapter_id = self.previous_chapter.connect('clicked', self.previous_chapter_clicked) # view_tool_bar.insert(self.previous_chapter, 0) # self.previous_chapter.show() ######################################## self.previous_scene_button = ToolButton('previous') self.previous_scene_button.set_tooltip("Previous Scene") self.previous_scene_id = self.previous_scene_button.connect('clicked', self.previous_scene_clicked) view_tool_bar.insert(self.previous_scene_button, 1) self.previous_scene_button.show() ###########print "CHANGING" self.next_scene = ToolButton('next') self.next_scene.set_tooltip("Next Scene") self.next_scene_id = self.next_scene.connect('clicked', self.next_scene_clicked) view_tool_bar.insert(self.next_scene, 2) self.next_scene.show() ########### #disable comic buttons in the main menu self.set_navigation(False) ###################### self.sound = ToolButton('audio-volume-high') homeString = _("Enable/Disable Sound"); self.sound.set_tooltip(homeString) self.sound_id = self.sound.connect('clicked', self.sound_clicked) view_tool_bar.insert(self.sound, 3) self.sound.show() ############################# ########### self.reload = ToolButton('reload') restart = _("Restart"); self.reload.set_tooltip(restart) self.reload_id = self.reload.connect('clicked', self.reload_clicked) view_tool_bar.insert(self.reload, 4) self.reload.show() ###################### ###################### self.home = ToolButton('go-home') homeString = _("Go to main menu"); self.home.set_tooltip(homeString) self.home_id = self.home.connect('clicked', self.home_clicked) view_tool_bar.insert(self.home, 5) self.home.show() ############################# view_tool_bar.show() # toolbox.add_toolbar('Game Control', view_tool_bar) self.set_toolbox(toolbox) toolbox.show() activity_toolbar = toolbox.get_activity_toolbar() activity_toolbar.share.props.visible = False #global game state ##restore previous session self.controller = controller.GameController.GlobalGameController(self) self.read_and_parse_prefs(os.environ['SUGAR_ACTIVITY_ROOT'] + '/data/defaults') #welcomeview = WelcomeScreen.GameWelcomeScreen(self.controller); #self.create_new_window(welcomeview) # self.mywindow = welcomeview.get_window() # self.w_child = self.mywindow.get_child() # self.widget = self.w_child # self.pack_and_show() def next_scene_clicked(self, event): self.controller.next_scene(); def previous_scene_clicked(self, event): self.controller.previous_scene(); def reload_clicked(self, event): restartTitle = _("Restart The Story?"); restartText = _("Are you sure you want to restart the story?"); dialog = self.create_dialog(restartTitle, restartText) result = dialog.run() dialog.destroy() if result == gtk.RESPONSE_YES: self.controller.reload(); def home_clicked(self, event): restartTitle = _("Restart The Main Menu?"); restartText = _("Are you sure you want to return to the main menu?"); dialog = self.create_dialog(restartTitle, restartText) result = dialog.run() dialog.destroy() if result == gtk.RESPONSE_YES: self.controller.play_game("Welcome", None); def sound_clicked(self, event): if(self.controller.get_sound() == True): self.sound.set_icon("audio-volume-muted") self.controller.set_sound(False); else: self.controller.set_sound(True); self.sound.set_icon("audio-volume-high") def create_dialog(self, title, message): dialog = gtk.MessageDialog(parent=None, buttons=gtk.BUTTONS_YES_NO, flags=gtk.DIALOG_DESTROY_WITH_PARENT, type=gtk.MESSAGE_QUESTION, message_format=message); dialog.set_title(title) return dialog; def create_dialog_ok(self, title, message): dialog = gtk.MessageDialog(parent=None, buttons=gtk.BUTTONS_OK, flags=gtk.DIALOG_DESTROY_WITH_PARENT, type=gtk.MESSAGE_QUESTION, message_format=message); dialog.set_title(title) return dialog; ##disables the nav buttons when comic is not being shown def set_navigation(self, switch): self.previous_scene_button.set_sensitive(switch); self.next_scene.set_sensitive(switch); def create_new_window(self, view): #self.view = view; self.mywindow = view.get_window() self.w_child = self.mywindow.get_child() self.widget = self.w_child # if(self.widget==None or self.w_child==None): # raise RuntimeError("No widget available") self.pack_and_show() def pack_and_show(self): # Create the main container self._main_view = gtk.VBox() # Import our class gtktest(): # Step 1: Load class, which creates gtktest.widget #self.gtktest = devtest2(self) # Step 2: Remove the widget's parent if self.widget.parent: self.widget.parent.remove(self.widget) # Step 3: We attach that widget to our window self._main_view.pack_start(self.widget) # Display everything self.widget.show() self._main_view.show() self.set_canvas(self._main_view) self.show_all() def read_and_parse_prefs(self, file_path): #Parse and set preference data from a given file. #file_path=os.environ['SUGAR_ACTIVITY_ROOT'] + '/data/defaults' #file_path=os.environ['SUGAR_ACTIVITY_ROOT'] + '/data/defaults'; print "Restoring ", file_path try: read_file = open(file_path, 'r') self.activity_state = json.loads(read_file.read()) if self.activity_state.has_key('comic_index'): comic_index = self.activity_state['comic_index'] # print "Restoring with index ",comic_index self.controller.set_comic_index(comic_index) print "Restored COMIC SCENE from ", file_path if self.activity_state.has_key('current_language_code'): current_language = self.activity_state['current_language_code'] self.controller.load_language_by_code(current_language) print "Restored LANGUAGE from ", file_path self.controller.update_scene(); read_file.close(); except IOError:# as (errno, strerror): print "Error: Preferences error" except AttributeError:# as (errno): print "Warning: controller not initialised and prefs called. {0}" except: raise; def read_file(self, file_path): #Read state from datastore. self.read_and_parse_prefs(file_path) def write_file(self, file_path): # #"""Write state to journal datastore and to persistent file system. # #""" #file_path=os.environ['SUGAR_ACTIVITY_ROOT'] + '/data/defaults'; # print "WRITING FILE TO JOURNAL : "+os.environ['SUGAR_ACTIVITY_ROOT'] + '/data/defaults' # BUG [ID: 3334629] try: print "WRITING FILE TO JOURNAL : " + file_path self.activity_state['comic_index'] = self.controller.get_comic_index(); self.activity_state['current_language_code'] = self.controller.get_current_language_code(); serialised_data = json.dumps(self.activity_state) to_journal = file(file_path, 'w') try: to_journal.write(serialised_data) except: raise finally: to_journal.close() to_persistent_fs = file(os.environ['SUGAR_ACTIVITY_ROOT'] + '/data/defaults', 'w') try: to_persistent_fs.write(serialised_data) except: raise; finally: to_persistent_fs.close() except AttributeError:# BUG [ID: 3334629] print "Warning: controller not initialised and trying to write. {0}"
class RecordControl: def __init__(self, toolbar): self._timer_value = TIMER_VALUES[0] self._timer_button = ToolButton("timer-0") self._timer_button.set_tooltip(_("Select timer")) self._timer_button.connect("clicked", self._timer_selection_cb) toolbar.insert(self._timer_button, -1) self._setup_timer_palette() self._duration_value = DURATION_VALUES[0] self._duration_button = ToolButton("duration-2") self._duration_button.set_tooltip(_("Select duration")) self._duration_button.connect("clicked", self._duration_selection_cb) toolbar.insert(self._duration_button, -1) self._setup_duration_palette() self._quality_value = 0 self._quality_button = ToolButton("low-quality") self._quality_button.set_tooltip(_("Select quality")) self._quality_button.connect("clicked", self._quality_selection_cb) toolbar.insert(self._quality_button, -1) self._setup_quality_palette() def _timer_selection_cb(self, widget): if self._timer_palette: if not self._timer_palette.is_up(): self._timer_palette.popup(immediate=True, state=self._timer_palette.SECONDARY) else: self._timer_palette.popdown(immediate=True) return def _setup_timer_palette(self): self._timer_palette = self._timer_button.get_palette() for seconds in TIMER_VALUES: if seconds == 0: text = _("Immediate") else: text = ngettext("%s second", "%s seconds", seconds) % seconds menu_item = MenuItem(icon_name="timer-%d" % (seconds), text_label=text) menu_item.connect("activate", self._timer_selected_cb, seconds) self._timer_palette.menu.append(menu_item) menu_item.show() def _timer_selected_cb(self, button, seconds): self.set_timer_idx(TIMER_VALUES.index(seconds)) def _duration_selection_cb(self, widget): if self._duration_palette: if not self._duration_palette.is_up(): self._duration_palette.popup(immediate=True, state=self._duration_palette.SECONDARY) else: self._duration_palette.popdown(immediate=True) return def _setup_duration_palette(self): self._duration_palette = self._duration_button.get_palette() for minutes in DURATION_VALUES: if minutes == 0: text = gtk.Label(_("Immediate")) else: text = ngettext("%s minute", "%s minutes", minutes) % minutes menu_item = MenuItem(icon_name="duration-%d" % (minutes), text_label=text) menu_item.connect("activate", self._duration_selected_cb, minutes) self._duration_palette.menu.append(menu_item) menu_item.show() def _duration_selected_cb(self, button, minutes): self.set_duration_idx(DURATION_VALUES.index(minutes)) def _quality_selection_cb(self, widget): if self._quality_palette: if not self._quality_palette.is_up(): self._quality_palette.popup(immediate=True, state=self._quality_palette.SECONDARY) else: self._quality_palette.popdown(immediate=True) return def _setup_quality_palette(self): self._quality_palette = self._quality_button.get_palette() for quality in QUALITY_VALUES: text = _("%s quality") % (quality) menu_item = MenuItem(icon_name=quality + "-quality", text_label=text) menu_item.connect("activate", self._quality_selected_cb, quality) self._quality_palette.menu.append(menu_item) menu_item.show() def _quality_selected_cb(self, button, quality): self.set_quality(QUALITY_VALUES.index(quality)) def set_mode(self, mode): if mode == constants.MODE_PHOTO: self._quality_button.set_sensitive(False) self._timer_button.set_sensitive(True) self._duration_button.set_sensitive(False) if mode == constants.MODE_VIDEO: self._quality_button.set_sensitive(True) self._timer_button.set_sensitive(True) self._duration_button.set_sensitive(True) if mode == constants.MODE_AUDIO: self._quality_button.set_sensitive(False) self._timer_button.set_sensitive(True) self._duration_button.set_sensitive(True) def get_timer(self): return self._timer_value def get_timer_idx(self): if self._timer_value in TIMER_VALUES: return TIMER_VALUES.index(self._timer_value) else: return TIMER_VALUES[0] def set_timer_idx(self, idx): self._timer_value = TIMER_VALUES[idx] if hasattr(self, "_timer_button"): self._timer_button.set_icon("timer-%d" % (self._timer_value)) def get_duration(self): return self._duration_value def get_duration_idx(self): if self._duration_value in DURATION_VALUES: return DURATION_VALUES.index(self._duration_value) else: return DURATION_VALUES[0] def set_duration_idx(self, idx): self._duration_value = DURATION_VALUES[idx] if hasattr(self, "_duration_button"): self._duration_button.set_icon("duration-%d" % (self._duration_value)) def get_quality(self): return self._quality_value def set_quality(self, idx): self._quality_value = idx if hasattr(self, "_quality_button"): self._quality_button.set_icon("%s-quality" % (QUALITY_VALUES[idx]))
class Explorer(activity.Activity): '''Es la clase que crea la actividad''' def __init__(self, handle): activity.Activity.__init__(self, handle, True) # ToolbarBox: toolbarbox = ToolbarBox() activitybutton = ActivityButton(self) toolbarbox.toolbar.insert(activitybutton, 0) separator = gtk.SeparatorToolItem() toolbarbox.toolbar.insert(separator, -1) explorer_btn = RadioToolButton() explorer_btn.set_tooltip('Explorador') explorer_btn.props.icon_name = 'activity-explorer' toolbarbox.toolbar.insert(explorer_btn, -1) self._goup = ToolButton('to-subjects') self._goup.connect('clicked', self._go_up_clicked) self._goup.set_tooltip('Ver Materias') self._goup.set_accelerator("<Shift><M>") self._goup.set_sensitive(False) toolbarbox.toolbar.insert(self._goup, -1) self._select_all = ToolButton('select-all') self._select_all.set_tooltip('Seleccionar todo') self._select_all.connect("clicked", self._select_all_clicked) self._select_all.set_sensitive(False) toolbarbox.toolbar.insert(self._select_all, -1) self._download = ToolButton('download') self._download.set_tooltip('Descargar') self._download.set_sensitive(False) toolbarbox.toolbar.insert(self._download, -1) separator = gtk.SeparatorToolItem() toolbarbox.toolbar.insert(separator, -1) homework_btn = RadioToolButton() homework_btn.set_tooltip('Tareas Domiciliarias') homework_btn.props.icon_name = 'homework' homework_btn.props.group = explorer_btn toolbarbox.toolbar.insert(homework_btn, -1) open_btn = ToolButton() open_btn.set_tooltip('Seleccionar tarea') open_btn.props.icon_name = 'open-from-journal' open_btn.set_sensitive(False) open_btn.connect("clicked", self._select_hw_from_journal) toolbarbox.toolbar.insert(open_btn, -1) self._send = ToolButton() self._send.set_tooltip('Enviar tarea') self._send.connect('clicked', self._send_hw_to_server) self._send.props.icon_name = 'document-send' self._send.set_sensitive(False) toolbarbox.toolbar.insert(self._send, -1) homework_btn.connect('clicked', self.homework_btn_cb, open_btn) explorer_btn.connect('clicked', self.explorer_btn_cb, open_btn) separator = gtk.SeparatorToolItem() separator.set_expand(True) separator.set_draw(False) toolbarbox.toolbar.insert(separator, -1) stopbtn = StopButton(self) toolbarbox.toolbar.insert(stopbtn, -1) self.set_toolbar_box(toolbarbox) self._one_alert = None # Canvas self._canvas = gtk.EventBox() self._name = '' self._last_name = '' self._hw_title = '' self._hw_description = '' self._hw_path = '' self._hw_mimetype = '' self.set_canvas(self._canvas) self.show_all() if not utils.get_group(): self.choose_group() else: self._do_canvas() def homework_btn_cb(self, button, open_btn): '''Se ejecuta cuando se hace click en el boton de tareas domiciliarias, se encarga de cambiar de pagina''' self._notebook.set_current_page(2) self._goup.set_sensitive(False) self._select_all.set_sensitive(False) self._download.set_sensitive(False) open_btn.set_sensitive(True) self._send.set_sensitive(False) def explorer_btn_cb(self, widget, open_btn): '''Se ejecuta cuando se hace click en el boton del explorador, se encarga de cambiar de pagina''' self._notebook.set_current_page(0) open_btn.set_sensitive(False) self._send.set_sensitive(False) def _select_hw_from_journal(self, widget): '''Abre un selector de objetos del diario''' chooser = ObjectChooser() response = chooser.run() if response == gtk.RESPONSE_ACCEPT: jobject = chooser.get_selected_object() self._hw_path = str(jobject.get_file_path()) self._notebook.set_current_page(-1) self._send.set_sensitive(True) self._hw_title.set_text(jobject.get_metadata()["title"]) self._hw_mimetype = mime.get_for_file(self._hw_path) def _send_hw_to_server(self, widget): '''Envia las tareas domiciliarias''' _buffer = self._hw_description.get_buffer() start = _buffer.get_start_iter() end = _buffer.get_end_iter() comments = _buffer.get_text(start, end) utils.send_homework(self._subjects._sftp, self._subjects_selector.\ get_active_text(), self._hw_path, self._hw_title.get_text(), comments, self._hw_mimetype) self._notebook.set_current_page(2) def _set_text(self, widget, name=True): if name: self._name = widget.get_text() else: self._last_name = widget.get_text() def _do_homework_canvas(self): '''Arma el canvas para la tareas domiciliarias ''' main_container = gtk.VBox() self._hw_title = widgets.Entry('Escriba el titulo aqui') main_container.pack_start(self._hw_title, False, True, 0) label = gtk.Label('Comentarios:') main_container.pack_start(label, False, True, 10) self._hw_description = gtk.TextView() self._hw_description.set_property('wrap-mode', gtk.WRAP_WORD_CHAR) main_container.pack_start(self._hw_description, True, True, 5) hbox = gtk.HBox() main_container.pack_start(hbox, False, True) self._subjects_selector = widgets.SubjectChooser() hbox.pack_start(self._subjects_selector, False, True, 0) return main_container def choose_group(self): '''Selector de los grupos''' vbox = gtk.VBox() vbox.set_border_width(20) title = gtk.Label('Registrate en Aula Virtual') title.modify_font(pango.FontDescription('bold 25')) vbox.pack_start(title, False, padding=40) note = gtk.Label('<span foreground="#FF0000"><i>\ * Por favor ingresa los datos correctamente.</i></span>') note.set_use_markup(True) vbox.pack_start(note, False, True, padding=5) hbox = gtk.HBox() vbox.pack_start(hbox, False, padding=10) label = gtk.Label("Nombre: ") hbox.pack_start(label, False, padding=10) entry = gtk.Entry() entry.connect('changed', self._set_text) hbox.pack_start(entry, True, padding=0) hbox1 = gtk.HBox() hbox1.set_border_width(20) label = gtk.Label("Apellido: ") hbox1.pack_start(label, False, padding=0) entry = gtk.Entry() entry.connect('changed', self._set_text, False) hbox1.pack_start(entry, True, padding=0) vbox.pack_start(hbox1, False, padding=10) hbox2 = gtk.HBox() vbox.pack_start(hbox2, False, padding=10) label_combo = gtk.Label("Elige tu grupo: ") hbox2.pack_start(label_combo, False, True, padding=10) combo = gtk.ComboBox() liststore = gtk.ListStore(str) combo.set_model(liststore) cell = gtk.CellRendererText() combo.pack_start(cell, True) combo.add_attribute(cell, 'text', 0) hbox2.pack_start(combo, False, True, padding=10) for group in GROUPS: liststore.append([group]) combo.set_active(0) accept = gtk.Button('Aceptar') accept.connect('clicked', self._accept_clicked, combo, entry, vbox) box = gtk.HBox() box.pack_end(accept, False) vbox.pack_start(box, False) self._canvas.add(vbox) self.show_all() def _accept_clicked(self, widget, combo, entry, vbox): '''Se encarga de guardar la informacion de la maquina en el sevidor''' group = GROUPS[combo.get_active()] utils.GROUP = group vbox.destroy() self._do_canvas() utils.save_me(self._subjects._sftp, group, '%s %s' % (self._name, self._last_name)) def _go_up_clicked(self, widget): '''Mustra la lista de materias''' self._notebook.set_current_page(0) self._goup.set_sensitive(False) self._select_all.set_sensitive(False) self._download.set_sensitive(False) def _select_all_clicked(self, widget): '''Selecciona todo''' self._documents.select_all() def _do_canvas(self): '''Crea el canvas principal''' scroll_documents = gtk.ScrolledWindow() scroll_documents.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC) self._documents = Documents(self) self._notebook = gtk.Notebook() self._subjects = Subjects(self._notebook, self._documents, self._go_up_clicked) self._subjects.connect('selected', lambda w: self._goup.set_sensitive(True)) scroll_documents.add_with_viewport(self._documents) scroll_subjects = gtk.ScrolledWindow() scroll_subjects.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC) scroll_subjects.add_with_viewport(self._subjects) self._notebook.append_page(scroll_subjects) self._notebook.append_page(scroll_documents) self._notebook.append_page(documents.HomeWorks(self._subjects._sftp)) self._notebook.append_page(self._do_homework_canvas()) self._notebook.set_property("show-tabs", False) self._canvas.add(self._notebook) self._canvas.show_all() self._notebook.set_current_page(0) def get_alert(self): '''Devuelve la alerta''' if not self._one_alert: self._one_alert = Alert() self.add_alert(self._one_alert) return self._one_alert
class InkToolBar(gtk.Toolbar): # Constructor def __init__(self, arbiter): gtk.Toolbar.__init__(self) self.__arbiter = arbiter self.__logger = logging.getLogger('InkToolBar') self.__logger.setLevel(logging.DEBUG) self.__cur_color = self.__arbiter.get_pen_color() self.__cur_color_str = "blue" self.__cur_pen = self.__arbiter.get_pen_size() self.__arbiter.connect_slide_redraw(self.update_buttons) self.__arbiter.connect_undo_redo_changed(self.update_buttons) # Red Ink self.__red = gtk.RadioToolButton() self.__red.set_icon_name('red-button') self.insert(self.__red, -1) self.__red.show() #self.__red.set_tooltip('Red Ink') self.__red.connect('clicked', self.set_ink_color, 1.0, 0.0, 0.0, "red") # Green Ink self.__green = gtk.RadioToolButton(group=self.__red) self.__green.set_icon_name('green-button') self.insert(self.__green, -1) self.__green.show() #self.__green.set_tooltip('Green Ink') self.__green.connect('clicked', self.set_ink_color, 0.0, 1.0, 0.0, "green") # Blue Ink self.__blue = gtk.RadioToolButton(group=self.__red) self.__blue.set_icon_name('blue-button') self.insert(self.__blue, -1) self.__blue.show() #self.__blue.set_tooltip('Blue Ink') self.__blue.connect('clicked', self.set_ink_color, 0.0, 0.0, 1.0, "blue") # Black Ink self.__black = gtk.RadioToolButton(group=self.__red) self.__black.set_icon_name('black-button') self.insert(self.__black, -1) self.__black.show() #self.__black.set_tooltip('Black Ink') self.__black.connect('clicked', self.set_ink_color, 0.0, 0.0, 0.0, "black") # Separate ink from untensils separator = gtk.SeparatorToolItem() separator.set_draw(False) self.insert(separator, -1) separator.show() # Pencil self.__pencil = gtk.RadioToolButton() self.__pencil.set_icon_name('tool-pencil') self.insert(self.__pencil, -1) self.__pencil.show() #self.__pencil.set_tooltip('Pencil') self.__pencil.connect('clicked', self.set_cur_pen, 4) # Brush self.__brush = gtk.RadioToolButton(self.__pencil) self.__brush.set_icon_name('tool-brush') self.insert(self.__brush, -1) self.__brush.show() #self.__brush.set_tooltip('Brush') self.__brush.connect('clicked', self.set_cur_pen, 8) # Erase self.__erase = ToolButton('tool-eraser') self.insert(self.__erase, -1) self.__erase.show() self.__erase.set_tooltip(_('Erase All Ink')) self.__erase.connect('clicked', self.erase_btn_clicked) """ # Text self.__text = ToolButton('text') self.insert(self.__text, -1) self.__text.show() self.__text.set_tooltip('Text') """ # Separate tools from text separator = gtk.SeparatorToolItem() separator.set_draw(False) self.insert(separator, -1) separator.show() # Undo self.__undo = ToolButton('edit-undo') self.insert(self.__undo, -1) self.__undo.show() self.__undo.set_tooltip(_('Undo')) self.__undo.connect('clicked', self.undo) # Redo self.__redo = ToolButton('edit-redo') self.insert(self.__redo, -1) self.__redo.show() self.__redo.set_tooltip(_('Redo')) self.__redo.connect('clicked', self.redo) separator = gtk.SeparatorToolItem() separator.set_draw(False) separator.set_expand(True) self.insert(separator, -1) separator.show() self.__submit = ToolButton('broadcast') self.insert(self.__submit, -1) self.__submit.show() self.__submit.set_tooltip(_('Broadcast Submission')) self.__submit.connect('clicked', self.submit_ink_cb) self.__arbiter.connect_joined(self.activity_joined_cb) self.set_tool_buttons() self.show() self.update_buttons() def activity_joined_cb(self, widget): self.__submit.set_tooltip(_('Submit Ink')) self.__submit.set_icon('dialog-ok') def set_cur_pen(self, widget, size): self.__arbiter.do_set_pen(size) def set_ink_color(self, widget, r, g, b, color): self.__arbiter.do_set_color(r, g, b) def erase_btn_clicked(self, widget): self.__arbiter.do_clear_ink() def set_tool_buttons(self): if self.__cur_color == (1.0, 0.0, 0.0): self.__red.set_active(True) elif self.__cur_color == (0.0, 1.0, 0.0): self.__green.set_active(True) elif self.__cur_color == (0.0, 0.0, 1.0): self.__blue.set_active(True) else: self.__black.set_active(True) if self.__cur_pen == 2: self.__pencil.set_active(True) elif self.__cur_pen == 5: self.__brush.set_active(True) def submit_ink_cb(self, widget): if self.__arbiter.get_is_instructor(): self.__logger.debug("Broadcast clicked") self.broadcast_ink() else: self.__logger.debug("Submit clicked") self.__submit.set_sensitive(False) self.__timer = threading.Timer(10.0, self.reenable_submissions) self.__timer.start() self.__arbiter.do_submit_ink() def broadcast_ink(self): self.__arbiter.do_broadcast_ink() def reenable_submissions(self): gtk.gdk.threads_enter() self.__submit.set_sensitive(True) self.__submit.queue_draw() gtk.gdk.threads_leave() def undo(self, widget): self.__arbiter.do_undo() def redo(self, widget): self.__arbiter.do_redo() def update_buttons(self, widget=None): can_undo, can_redo = self.__arbiter.get_can_undo_redo() self.__undo.set_sensitive(can_undo) self.__redo.set_sensitive(can_redo) if self.__arbiter.get_is_instructor(): if self.__arbiter.get_active_submission() == -1: self.__submit.set_sensitive(False) else: self.__submit.set_sensitive(True)
def __init__(self, handle): activity.Activity.__init__(self, handle, True) # ToolbarBox: toolbarbox = ToolbarBox() activitybutton = ActivityButton(self) toolbarbox.toolbar.insert(activitybutton, 0) separator = gtk.SeparatorToolItem() toolbarbox.toolbar.insert(separator, -1) explorer_btn = RadioToolButton() explorer_btn.set_tooltip('Explorador') explorer_btn.props.icon_name = 'activity-explorer' toolbarbox.toolbar.insert(explorer_btn, -1) self._goup = ToolButton('to-subjects') self._goup.connect('clicked', self._go_up_clicked) self._goup.set_tooltip('Ver Materias') self._goup.set_accelerator("<Shift><M>") self._goup.set_sensitive(False) toolbarbox.toolbar.insert(self._goup, -1) self._select_all = ToolButton('select-all') self._select_all.set_tooltip('Seleccionar todo') self._select_all.connect("clicked", self._select_all_clicked) self._select_all.set_sensitive(False) toolbarbox.toolbar.insert(self._select_all, -1) self._download = ToolButton('download') self._download.set_tooltip('Descargar') self._download.set_sensitive(False) toolbarbox.toolbar.insert(self._download, -1) separator = gtk.SeparatorToolItem() toolbarbox.toolbar.insert(separator, -1) homework_btn = RadioToolButton() homework_btn.set_tooltip('Tareas Domiciliarias') homework_btn.props.icon_name = 'homework' homework_btn.props.group = explorer_btn toolbarbox.toolbar.insert(homework_btn, -1) open_btn = ToolButton() open_btn.set_tooltip('Seleccionar tarea') open_btn.props.icon_name = 'open-from-journal' open_btn.set_sensitive(False) open_btn.connect("clicked", self._select_hw_from_journal) toolbarbox.toolbar.insert(open_btn, -1) self._send = ToolButton() self._send.set_tooltip('Enviar tarea') self._send.connect('clicked', self._send_hw_to_server) self._send.props.icon_name = 'document-send' self._send.set_sensitive(False) toolbarbox.toolbar.insert(self._send, -1) homework_btn.connect('clicked', self.homework_btn_cb, open_btn) explorer_btn.connect('clicked', self.explorer_btn_cb, open_btn) separator = gtk.SeparatorToolItem() separator.set_expand(True) separator.set_draw(False) toolbarbox.toolbar.insert(separator, -1) stopbtn = StopButton(self) toolbarbox.toolbar.insert(stopbtn, -1) self.set_toolbar_box(toolbarbox) self._one_alert = None # Canvas self._canvas = gtk.EventBox() self._name = '' self._last_name = '' self._hw_title = '' self._hw_description = '' self._hw_path = '' self._hw_mimetype = '' self.set_canvas(self._canvas) self.show_all() if not utils.get_group(): self.choose_group() else: self._do_canvas()
class Activity(sugar.activity.activity.Activity): def __init__(self, handle): super(Activity, self).__init__(handle) self.paused = False watch = gtk.gdk.Cursor(gtk.gdk.WATCH) self.window.set_cursor(watch) self.p = gtk.VPaned() self.p.connect("notify::position", self.redraw) self.box = gtk.Notebook() self.p.pack2(self.box) self.p.show() self.box.set_show_tabs(False) self.splash = gtk.Image() pixbuf = gtk.gdk.pixbuf_new_from_file("images/splash_comodo.png") screen = self.window.get_screen() width, height = screen.get_width(), screen.get_height() - style.GRID_CELL_SIZE pixbuf = pixbuf.scale_simple(width, height, gtk.gdk.INTERP_BILINEAR) self.splash.set_from_pixbuf(pixbuf) self.splash.show() eb = gtk.EventBox() eb.add(self.splash) eb.modify_bg(gtk.STATE_NORMAL, gtk.gdk.color_parse("white")) eb.show() self.box.append_page(eb, gtk.Label("Inicio")) self._pygamecanvas = sugargame2.canvas.PygameCanvas(self) self._pygamecanvas.set_flags(gtk.EXPAND) self._pygamecanvas.set_flags(gtk.FILL) self.connect("visibility-notify-event", self.redraw) self._pygamecanvas.set_events(gtk.gdk.BUTTON_PRESS_MASK) self._pygamecanvas.connect("button-press-event", self._pygamecanvas.grab_focus) self.box.append_page(self._pygamecanvas, gtk.Label("Juego")) self.box.show() self.set_canvas(self.p) gobject.timeout_add(300, self.pump) gobject.timeout_add(2000, self.init_interpreter) #gobject.timeout_add(1000, self.build_editor) gobject.timeout_add(1500, self.check_modified) self.build_toolbar() self.credits = None self.editor = None #self.reader = None self._pygamecanvas.run_pygame(self.run_game) def redraw(self, widget=None, b=None, c=None): scene = spyral.director.get_scene() if scene: scene.redraw() def alert(self, title=None, text=None, delay=5): alert = NotifyAlert(delay) alert.props.title = title alert.props.msg = text self.add_alert(alert) alert.connect('response', self._alert_ok) alert.show() def _alert_ok(self, alert, *args): self.remove_alert(alert) def check_modified(self): if self.box.current_page()==2: if not self.save_button.get_sensitive(): if self.editor.modificado(): self.save_button.set_sensitive(True) return False return True def pump(self): # Esto es necesario porque sino pygame acumula demasiados eventos. pygame.event.pump() def focus_interpreter(self, widget, event): self._interpreter.text.grab_focus() return True def init_interpreter(self): # diferido unos segundos para evitar ver errores superfluos al iniciar self._interpreter = GTKInterpreterConsole(self.redraw) self._interpreter.text.connect('button-press-event', self.focus_interpreter) self.p.pack1(self._interpreter) return False def open_file(self, widget, path): if path: if not os.path.isdir(path): self.editor.open_file(widget, path) def save_file(self, widget): if self.editor.modificado(): self.save_button.set_sensitive(False) self.editor.save_file() filename = self.editor.current_file() self.alert(filename, "Archivo guardado.") gobject.timeout_add(1500, self.check_modified) def build_editor(self): dir_real = os.getcwd() f = os.path.realpath(JUEGO.__file__) f = "." + f.replace(dir_real ,"") # todo esto para obtener una ruta relativa f = f.rstrip("c") # en caso que sea .pyc compilado self.h = gtk.HPaned() self.tree = FileViewer(".", os.path.basename(f)) self.tree.connect("file-selected", self.open_file) self.tree.show() self.h.pack1(self.tree) self.box.append_page(self.h, gtk.Label("Editor")) if False: #os.path.isfile("/usr/bin/gvim"): # Si podemos, lo hacemos self.socket = gtk.Socket() self.socket.show() self.h.pack2(self.socket) sock_id = str(self.socket.get_id()) self.editor = VimSourceView(sock_id) if not self.editor.bufInfo.bufferList: f = JUEGO.__file__ if f.endswith("pyc"): f = f[:-1] self.open_file(None, f) else: self.editor = SourceView() scroller = gtk.ScrolledWindow() scroller.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC) scroller.add(self.editor) scroller.show() self.h.pack2(scroller) self.editor.show() self.h.show() self.open_file(None, f) def build_reader(self): self.reader = webkit.WebView() curdir = os.getcwd() self.reader.load_uri("file://%s/docs/index.html" % curdir) self.box.append_page(self.reader, gtk.Label("Lector")) self.reader.show() def build_toolbar(self): toolbar_box = ToolbarBox() self.set_toolbar_box(toolbar_box) toolbar_box.show() activity_button = ActivityToolbarButton(self) toolbar_box.toolbar.insert(activity_button, -1) activity_button.show() tool_group = None self.game_button = RadioToolButton() self.game_button.props.icon_name = 'gamecanvas' self.game_button.set_tooltip(_('Juego')) self.game_button.accelerator = "<Ctrl>1" self.game_button.props.group = tool_group self.game_button.connect('clicked', self.show_game) toolbar_box.toolbar.insert(self.game_button, -1) self.game_button.show() tool_group = self.game_button button = RadioToolButton() button.props.icon_name = 'view-source' button.set_tooltip(_('Editor')) button.accelerator = "<Ctrl>2" button.props.group = tool_group button.connect('clicked', self.show_editor) toolbar_box.toolbar.insert(button, -1) button.show() self.save_button = ToolButton('dialog-ok') self.save_button.set_tooltip(_('Guardar')) self.save_button.accelerator = "<Ctrl>s" self.save_button.connect('clicked', self.save_file) self.save_button.set_sensitive(False) toolbar_box.toolbar.insert(self.save_button, -1) self.save_button.show() separator = gtk.SeparatorToolItem() toolbar_box.toolbar.insert(separator, -1) separator.show() button = ToolButton('system-restart') button.set_tooltip(_('Reiniciar juego')) button.accelerator = "<Alt><Shift>r" button.connect('clicked', self.restart_game) toolbar_box.toolbar.insert(button, -1) button.show() self.editor_button = ToolButton('sources') self.editor_button.set_tooltip(_('Consola')) self.editor_button.accelerator = "<Ctrl>grave" self.editor_button.connect('clicked', self.toggle_console) toolbar_box.toolbar.insert(self.editor_button, -1) self.editor_button.show() separator = gtk.SeparatorToolItem() toolbar_box.toolbar.insert(separator, -1) separator.show() button = helpbutton.HelpButton(self) toolbar_box.toolbar.insert(button, -1) button.show() button = ToolButton() button.props.icon_name = 'activity-about' button.set_tooltip(_('Acerca de')) button.accelerator = "<Ctrl>i" button.connect('clicked', self.run_credits) toolbar_box.toolbar.insert(button, -1) button.show() # Blank space (separator) and Stop button at the end: separator = gtk.SeparatorToolItem() separator.props.draw = False separator.set_expand(True) toolbar_box.toolbar.insert(separator, -1) separator.show() stop_button = StopButton(self) toolbar_box.toolbar.insert(stop_button, -1) stop_button.show() def run_game(self): spyral.director.init((0,0), fullscreen=False, max_fps=30) self.game = JUEGO.Juego(self, callback=self.game_ready) self.box.connect("switch-page", self.redraw) spyral.director.push(self.game) self.start() def run_credits(self, widget): if not (spyral.director.get_scene()==self.credits): self.credits = game.credits.Creditos(self.game.size) spyral.director.push(self.credits) def start(self): try: spyral.director.run(sugar = True) except AttributeError as detail: detail2 = traceback.format_exc() self.box.set_page(0) self.alert( detail2, "Spyral se ha detenido abruptamente.", 60) def show_game(self, widget): self.box.set_page(1) self.redraw() def show_editor(self, widget): if not self.editor: self.build_editor() self.box.set_page(2) self.redraw() def show_reader(self, widget): if not self.reader: self.build_reader() self.box.set_page(3) self.redraw() def restart_game(self, widget): global JUEGO import objetos try: objetos.reset() except AttributeError: pass self.box.set_page(0) watch = gtk.gdk.Cursor(gtk.gdk.WATCH) self.window.set_cursor(watch) JUEGO = reload(JUEGO) self.game = JUEGO.Juego(self, callback=self.game_ready) spyral.director.replace(self.game) self.start() def game_ready(self, widget = None): self.game_button.set_active(True) self.box.set_page(1) self._pygamecanvas.grab_focus() self.window.set_cursor(None) def read_file(self, file_path): pass def write_file(self, file_path): pass def can_close(self): if self.editor: self.editor.close() self.box.set_page(0) try: spyral.director.quit() except spyral.exceptions.GameEndException: pass finally: return True def toggle_console(self, e): if self._interpreter.props.visible: self._interpreter.hide() self._pygamecanvas.grab_focus() else: self.p.set_position(160) self._interpreter.show() self._interpreter.text.grab_focus() self.redraw() def animate_console(self): easing = spyral.easing.Linear(0,160) self.p.set_position(0)
class InkToolBar(gtk.Toolbar): # Constructor def __init__(self, slideviewer, deck): gtk.Toolbar.__init__(self) self.__slideviewer = slideviewer self.__cur_color = slideviewer.get_color() self.__cur_color_str = "blue" self.__cur_pen = slideviewer.get_pen() self.__deck = deck self.__deck.connect('slide-redraw', self.update_buttons) self.__slideviewer.connect('undo-redo-changed', self.update_buttons) self.__is_instr = False # Red Ink self.__red = gtk.RadioToolButton() self.__red.set_icon_name('red-button') self.insert(self.__red, -1) self.__red.show() #self.__red.set_tooltip('Red Ink') self.__red.connect('clicked', self.set_ink_color, 1.0, 0.0, 0.0, "red") # Green Ink self.__green = gtk.RadioToolButton(group=self.__red) self.__green.set_icon_name('green-button') self.insert(self.__green, -1) self.__green.show() #self.__green.set_tooltip('Green Ink') self.__green.connect('clicked', self.set_ink_color, 0.0, 1.0, 0.0, "green") # Blue Ink self.__blue = gtk.RadioToolButton(group=self.__red) self.__blue.set_icon_name('blue-button') self.insert(self.__blue, -1) self.__blue.show() #self.__blue.set_tooltip('Blue Ink') self.__blue.connect('clicked', self.set_ink_color, 0.0, 0.0, 1.0, "blue") # Black Ink self.__black = gtk.RadioToolButton(group=self.__red) self.__black.set_icon_name('black-button') self.insert(self.__black, -1) self.__black.show() #self.__black.set_tooltip('Black Ink') self.__black.connect('clicked', self.set_ink_color, 0.0, 0.0, 0.0, "black") # Separate ink from untensils separator = gtk.SeparatorToolItem() separator.set_draw(False) self.insert(separator, -1) separator.show() # Pencil self.__pencil = gtk.RadioToolButton() self.__pencil.set_icon_name('tool-pencil') self.insert(self.__pencil, -1) self.__pencil.show() #self.__pencil.set_tooltip('Pencil') self.__pencil.connect('clicked', self.set_cur_pen, 4) # Brush self.__brush = gtk.RadioToolButton(self.__pencil) self.__brush.set_icon_name('tool-brush') self.insert(self.__brush, -1) self.__brush.show() #self.__brush.set_tooltip('Brush') self.__brush.connect('clicked', self.set_cur_pen, 8) # Erase self.__erase = ToolButton('tool-eraser') self.insert(self.__erase, -1) self.__erase.show() self.__erase.set_tooltip('Erase All Ink') self.__erase.connect('clicked', self.set_erase) """ # Text self.__text = ToolButton('text') self.insert(self.__text, -1) self.__text.show() self.__text.set_tooltip('Text') """ # Separate tools from text separator = gtk.SeparatorToolItem() separator.set_draw(False) self.insert(separator, -1) separator.show() # Undo self.__undo = ToolButton('edit-undo') self.insert(self.__undo, -1) self.__undo.show() self.__undo.set_tooltip('Undo') self.__undo.connect('clicked', self.undo) # Redo self.__redo = ToolButton('edit-redo') self.insert(self.__redo, -1) self.__redo.show() self.__redo.set_tooltip('Redo') self.__redo.connect('clicked', self.redo) separator = gtk.SeparatorToolItem() separator.set_draw(False) separator.set_expand(True) self.insert(separator, -1) separator.show() self.__submit = ToolButton('dialog-ok') #FIXME (though actually not a terrible icon) self.insert(self.__submit, -1) self.__submit.show() self.__submit.set_tooltip('Broadcast Submission') self.__submit.connect('clicked', self.submit_ink) self.__deck.connect('instr_state_propagate', self.instructor_state_cb) self.set_tool_buttons() self.show() def instructor_state_cb(self, widget, is_instr): self.__is_instr = is_instr if is_instr: self.__submit.set_tooltip('Broadcast Submission') else: self.__submit.set_tooltip('Submit Ink') def set_cur_pen(self, widget, size): self.__slideviewer.set_pen(size) def set_ink_color(self, widget, r, g, b, color): self.__slideviewer.set_color(r, g, b) def set_erase(self, widget): self.__slideviewer.clear_ink() def set_tool_buttons(self): if self.__cur_color == (1.0, 0.0, 0.0): self.__red.set_active(True) elif self.__cur_color == (0.0, 1.0, 0.0): self.__green.set_active(True) elif self.__cur_color == (0.0, 0.0, 1.0): self.__blue.set_active(True) else: self.__black.set_active(True) if self.__cur_pen == 2: self.__pencil.set_active(True) elif self.__cur_pen == 5: self.__brush.set_active(True) def submit_ink(self, widget): if self.__is_instr: self.broadcast_ink() else: self.__submit.set_sensitive(False) self.__timer = threading.Timer(3.0, self.reenable_submissions) self.__timer.start() self.__slideviewer.submit_ink() def broadcast_ink(self): self.__slideviewer.broadcast_ink() def reenable_submissions(self): self.__submit.set_sensitive(True) self.__submit.queue_draw() def undo(self, widget): self.__slideviewer.undo() def redo(self, widget): self.__slideviewer.redo() def update_buttons(self, widget=None): can_undo, can_redo = self.__slideviewer.can_undo_redo() self.__undo.set_sensitive(can_undo) self.__redo.set_sensitive(can_redo) if self.__is_instr: if self.__deck.getActiveSubmission() == -1: self.__submit.set_sensitive(False) else: self.__submit.set_sensitive(True)