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() self.blocklist = [] self.radioList = {} for c in tools.allTools: button = ToolButton(c.icon) button.set_tooltip(_(c.toolTip)) button.connect('clicked',self.radioClicked) toolbar_box.toolbar.insert(button, -1) button.show() self.radioList[button] = c.name 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() self.show_all()
class TitleBox(VolumesToolbar): __gtype_name__ = 'TitleBox' def __init__(self): VolumesToolbar.__init__(self) label = gtk.Label() label.set_markup('<b>%s</b>' % _('Choose an object')) label.set_alignment(0, 0.5) self._add_widget(label, expand=True) self.close_button = ToolButton(icon_name='dialog-cancel') self.close_button.set_tooltip(_('Close')) self.insert(self.close_button, -1) self.close_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()
class ViewToolbar(gtk.Toolbar): __gtype_name__ = 'ViewToolbar' def __init__(self): gtk.Toolbar.__init__(self) 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() def _zoom_in_cb(self, button): self.activity.font_increase() def _zoom_out_cb(self, button): self.activity.font_decrease() def set_activity(self, activity): self.activity = activity
def __init__(self, activity, **kwargs): gtk.ToolItem.__init__(self) description_button = ToolButton('edit-description') description_button.show() description_button.set_tooltip(_('Description')) self._palette = description_button.get_palette() description_box = gtk.HBox() sw = gtk.ScrolledWindow() sw.set_size_request(int(gtk.gdk.screen_width() / 2), 2 * style.GRID_CELL_SIZE) sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC) self._text_view = gtk.TextView() self._text_view.set_left_margin(style.DEFAULT_PADDING) self._text_view.set_right_margin(style.DEFAULT_PADDING) self._text_view.set_wrap_mode(gtk.WRAP_WORD_CHAR) text_buffer = gtk.TextBuffer() if 'description' in activity.metadata: text_buffer.set_text(activity.metadata['description']) self._text_view.set_buffer(text_buffer) self._text_view.connect('focus-out-event', self.__description_changed_cb, activity) sw.add(self._text_view) description_box.pack_start(sw, False, True, 0) self._palette.set_content(description_box) description_box.show_all() self.add(description_button) description_button.connect('clicked', self.__description_button_clicked_cb) activity.metadata.connect('updated', self.__jobject_updated_cb)
def __init__(self, web_view): gobject.GObject.__init__(self) self._web_view = web_view self._back = ToolButton('go-previous-paired') self._back.set_tooltip(_('Back')) self._back.props.sensitive = False self._back.connect('clicked', self._go_back_cb) self.insert(self._back, -1) self._back.show() self._forward = ToolButton('go-next-paired') self._forward.set_tooltip(_('Forward')) self._forward.props.sensitive = False self._forward.connect('clicked', self._go_forward_cb) self.insert(self._forward, -1) self._forward.show() home = ToolButton('zoom-home') home.set_tooltip(_('Home')) home.connect('clicked', self._go_home_cb) self.insert(home, -1) home.show() self._listener = xpcom.server.WrapObject( ProgressListener(self), interfaces.nsIWebProgressListener) weak_ref = xpcom.client.WeakReference(self._listener) mask = interfaces.nsIWebProgress.NOTIFY_STATE_NETWORK | \ interfaces.nsIWebProgress.NOTIFY_LOCATION self._web_view.web_progress.addProgressListener(self._listener, mask)
def __init__(self, activity, **kwargs): gtk.ToolItem.__init__(self) description_button = ToolButton('edit-description') description_button.show() description_button.set_tooltip(_('Description')) self._palette = description_button.get_palette() description_box = gtk.HBox() sw = gtk.ScrolledWindow() sw.set_size_request(int(gtk.gdk.screen_width() / 2), 2 * style.GRID_CELL_SIZE) sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC) self._text_view = gtk.TextView() self._text_view.set_left_margin(style.DEFAULT_PADDING) self._text_view.set_right_margin(style.DEFAULT_PADDING) text_buffer = gtk.TextBuffer() if 'description' in activity.metadata: text_buffer.set_text(activity.metadata['description']) self._text_view.set_buffer(text_buffer) self._text_view.connect('focus-out-event', self.__description_changed_cb, activity) sw.add(self._text_view) description_box.pack_start(sw, False, True, 0) self._palette.set_content(description_box) description_box.show_all() self.add(description_button) description_button.connect('clicked', self.__description_button_clicked_cb) activity.metadata.connect('updated', self.__jobject_updated_cb)
def __init__(self, handle): activity.Activity.__init__(self, handle) self.toolbox = activity.ActivityToolbox(self) activity_toolbar = self.toolbox.get_activity_toolbar() activity_toolbar.share.props.visible = False activity_toolbar.keep.props.visible = False go_up = ToolButton("gtk-go-up") go_up.props.tooltip = _("Go Up") go_up.show() activity_toolbar.insert(go_up, 2) refresh = ToolButton("gtk-refresh") refresh.props.tooltip = _("Refresh") refresh.show() activity_toolbar.insert(refresh, 2) self.set_toolbox(self.toolbox) self.toolbox.show() widget = filemanager.Widget() go_up.connect("clicked", self.go_up_callback, widget) refresh.connect("clicked", self.refresh_callback, widget) widget.show() current_directory = gio.File(path=os.environ["HOME"]) widget.set_current_directory(current_directory.get_uri()) widget.connect("file-menu", self.file_menu) widget.connect('current-directory-menu', self.current_directory_menu) self.set_canvas(widget) self.show()
class ActivityToolbarXO2XO(gtk.Toolbar): def __init__(self, activity, orientation_left=False): gtk.Toolbar.__init__(self) self._activity = activity if orientation_left == False: separator = gtk.SeparatorToolItem() separator.props.draw = False separator.set_expand(True) self.insert(separator,-1) separator.show() self._object_insert = ToolButton('object-insert') self.insert(self._object_insert, -1) self._object_insert.show() self.stop = StopButton(activity) self.insert(self.stop, -1) self.stop.show() self._object_insert.connect('clicked', self.insertImage, activity) def insertImage(self, widget, activity): self._activity = activity chooser = ObjectChooser('Choose image', self._activity, gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT) try: result = chooser.run() if result == gtk.RESPONSE_ACCEPT: jobject = chooser.get_selected_object() if jobject and jobject.file_path: self._activity.toUploadChosen(jobject.file_path) finally: chooser.destroy() del chooser
def __init__(self, handle): activity.Activity.__init__(self, handle) self.toolbox = activity.ActivityToolbox(self) activity_toolbar = self.toolbox.get_activity_toolbar() activity_toolbar.share.props.visible = False activity_toolbar.keep.props.visible = False connect = ToolButton("gtk-refresh") connect.props.tooltip = "Conectar" connect.connect("clicked", self.connect_vnc) connect.show() activity_toolbar.insert(connect, 2) fullscreen = ToolButton("view-fullscreen") fullscreen.props.tooltip = "Pantalla Completa" fullscreen.connect("clicked", self.fullscreen_cb) fullscreen.show() activity_toolbar.insert(fullscreen, 2) self.set_toolbox(self.toolbox) self.toolbox.show() area = gtk.ScrolledWindow() area.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC) area.show() self.vnc = GRFBWidget() area.add_with_viewport(self.vnc) self.vnc.show() self.set_canvas(area) self.present() self.maximize() self.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() # Pause/Play button: stop_play = ToolButton('media-playback-stop') stop_play.set_tooltip(_("Stop")) stop_play.set_accelerator(_('<ctrl>space')) stop_play.connect('clicked', self._stop_play_cb) stop_play.show() toolbar_box.toolbar.insert(stop_play, -1) # 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()
class InstrumentToolbar(gtk.Toolbar): ''' The toolbar for adding new instruments ''' def __init__(self, activity): gtk.Toolbar.__init__(self) self.activity = activity self.new_instruments = [] self._name_entry = gtk.Entry() self._name_entry.set_text(_('my instrument')) self._name_entry_changed_id = self._name_entry.connect( 'changed', self.update_name_entry) if hasattr(self._name_entry, 'set_tooltip_text'): self._name_entry.set_tooltip_text(_('Enter instrument name.')) self._name_entry.set_width_chars(24) self._name_entry.show() toolitem = gtk.ToolItem() toolitem.add(self._name_entry) self.insert(toolitem, -1) toolitem.show() self._notes_combo = ComboBox() n = 0 for octave in range(9): for i in range(len(NOTES)): if octave == 0 and i < 9: # Start with A0 continue self._notes_combo.append_item(n, note_octave(i, octave), None) n += 1 self._notes_combo.set_active(48) # A4 if hasattr(self._notes_combo, 'set_tooltip_text'): self._notes_combo.set_tooltip_text(_('Notes')) self._notes_tool = ToolComboBox(self._notes_combo) self.insert(self._notes_tool, -1) self._notes_tool.show() self._new_note = ToolButton('list-add') self._new_note.show() self.insert(self._new_note, -1) self._new_note.set_tooltip(_('Add a new note.')) self._new_note.connect('clicked', self.new_note_cb) def update_name_entry(self, *args): ''' Add name to INSTRUMENT_DICT and combo box ''' # Wait until a note has been added... return def new_note_cb(self, *args): ''' Add a new note to instrument tuning list ''' name = self._name_entry.get_text() if name not in INSTRUMENT_DICT: INSTRUMENT_DICT[name] = [] self.activity.tuning_toolbar.instrument.append(name) i = len(self.activity.tuning_toolbar.instrument) self.activity.tuning_toolbar.instrument_combo.append_item( i, name, None) self.new_instruments.append(name) i = self._notes_combo.get_active() freq = A0 * pow(TWELTHROOT2, i) if freq not in INSTRUMENT_DICT[name]: INSTRUMENT_DICT[name].append(freq)
def __init__(self, web_view): gobject.GObject.__init__(self) self._web_view = web_view self._back = ToolButton('go-previous-paired') self._back.set_tooltip(_('Back')) self._back.props.sensitive = False self._back.connect('clicked', self._go_back_cb) self.insert(self._back, -1) self._back.show() self._forward = ToolButton('go-next-paired') self._forward.set_tooltip(_('Forward')) self._forward.props.sensitive = False self._forward.connect('clicked', self._go_forward_cb) self.insert(self._forward, -1) self._forward.show() home = ToolButton('zoom-home') home.set_tooltip(_('Home')) home.connect('clicked', self._go_home_cb) self.insert(home, -1) home.show() progress_listener = self._web_view.progress progress_listener.connect('location-changed', self._location_changed_cb) progress_listener.connect('loading-stop', self._loading_stop_cb)
class T2Activity(activity.Activity): def xois_clicked(self, widget, data=None): self.webview.load_uri('http://teach-teacher.ep.io/slides/1') def guide_clicked(self, widget, data=None): self.webview.load_uri('http://teach-teacher.ep.io/slides/17') def back_clicked(self, widget, data=None): if self.webview.get_web_navigation().canGoBack: self.webview.get_web_navigation().goBack() def home_clicked(self, widget, data=None): self.webview.load_uri('http://147.47.120.20/~tsquare/menu.php') def __init__(self, handle): print "running activity init", handle activity.Activity.__init__(self, handle) print "activity running" self.set_title('Teach Teacher') toolbox = activity.ActivityToolbox(self) self.set_toolbox(toolbox) toolbar = gtk.Toolbar() self.goBack = ToolButton('go-left') self.goBack.set_tooltip("Go Back") self.goBack.connect('clicked', self.back_clicked) toolbar.insert(self.goBack, -1) self.goBack.show() self.home = ToolButton('go-home') self.home.set_tooltip("Home") self.home.connect('clicked', self.home_clicked) toolbar.insert(self.home, -1) self.home.show() self.xois = ToolButton('computer-xo') self.xois.set_tooltip("T's XO") self.xois.connect('clicked', self.xois_clicked) # toolbar.insert(self.xois, -1) # self.xois.show() self.guide = ToolButton('go-next') self.guide.set_tooltip("T's Guide") self.guide.connect('clicked', self.guide_clicked) # toolbar.insert(self.guide, -1) # self.guide.show() toolbar.show() toolbox.add_toolbar("Menu", toolbar) toolbox.show() self.webview = WebView() self.set_canvas(self.webview) self.webview.show() self.webview.load_uri('http://147.47.120.20/~tsquare/menu.php') print "AT END OF THE CLASS"
class EditToolbar(activity.EditToolbar): __gtype_name__ = 'EditToolbar' def __init__(self): activity.EditToolbar.__init__(self) separator = gtk.SeparatorToolItem() separator.set_draw(False) separator.set_expand(True) self.insert(separator, -1) separator.show() search_item = gtk.ToolItem() self._search_entry = gtk.Entry() self._search_entry.connect('activate', self._search_entry_activate_cb) width = int(gtk.gdk.screen_width() / 3) self._search_entry.set_size_request(width, -1) search_item.add(self._search_entry) self._search_entry.show() self.insert(search_item, -1) search_item.show() self._prev = ToolButton('go-previous-paired') self._prev.set_tooltip(_('Previous')) self._prev.props.sensitive = False self._prev.connect('clicked', self._find_prev_cb) self.insert(self._prev, -1) self._prev.show() self._next = ToolButton('go-next-paired') self._next.set_tooltip(_('Next')) self._next.props.sensitive = False self._next.connect('clicked', self._find_next_cb) self.insert(self._next, -1) self._next.show() def set_activity(self, activity): self.activity = activity def _search_entry_activate_cb(self, entry): current_page = self.activity.get_current_page() self.activity.find_begin(entry.props.text) self._update_find_buttons() def _find_changed_cb(self, page, spec): self._update_find_buttons() def _find_prev_cb(self, button): self.activity.find_previous() def _find_next_cb(self, button): self.activity.find_next() def _update_find_buttons(self): self._prev.props.sensitive = self.activity.can_find_previous() self._next.props.sensitive = self.activity.can_find_next()
class MainToolbar(gtk.Toolbar): """ Main toolbar of the control panel """ __gtype_name__ = 'MainToolbar' __gsignals__ = { 'stop-clicked': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE, ([])), 'search-changed': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE, ([str])), } def __init__(self): gtk.Toolbar.__init__(self) self._add_separator() tool_item = gtk.ToolItem() self.insert(tool_item, -1) tool_item.show() self._search_entry = iconentry.IconEntry() self._search_entry.set_icon_from_name(iconentry.ICON_ENTRY_PRIMARY, 'system-search') self._search_entry.add_clear_button() self._search_entry.set_width_chars(25) self._search_entry.connect('changed', self.__search_entry_changed_cb) tool_item.add(self._search_entry) self._search_entry.show() self._add_separator(True) self.stop = ToolButton(icon_name='dialog-cancel') self.stop.set_tooltip(_('Done')) self.stop.connect('clicked', self.__stop_clicked_cb) self.stop.show() self.insert(self.stop, -1) self.stop.show() def get_entry(self): return self._search_entry def _add_separator(self, expand=False): separator = gtk.SeparatorToolItem() separator.props.draw = False if expand: separator.set_expand(True) else: separator.set_size_request(style.DEFAULT_SPACING, -1) self.insert(separator, -1) separator.show() def __search_entry_changed_cb(self, search_entry): self.emit('search-changed', search_entry.props.text) def __stop_clicked_cb(self, button): self.emit('stop-clicked')
class NamingToolbar(gtk.Toolbar): """ Toolbar of the naming alert """ __gtype_name__ = 'SugarNamingToolbar' __gsignals__ = { 'keep-clicked': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE, ([])) } def __init__(self): gtk.Toolbar.__init__(self) client = gconf.client_get_default() color = XoColor(client.get_string('/desktop/sugar/user/color')) icon = Icon() icon.set_from_icon_name('activity-journal', gtk.ICON_SIZE_LARGE_TOOLBAR) icon.props.xo_color = color self._add_widget(icon) self._add_separator() self._title = gtk.Label(_('Name this entry')) self._add_widget(self._title) self._add_separator(True) self._keep_button = ToolButton('dialog-ok', tooltip=_('Keep')) self._keep_button.props.accelerator = 'Return' self._keep_button.connect('clicked', self.__keep_button_clicked_cb) self.insert(self._keep_button, -1) self._keep_button.show() def _add_separator(self, expand=False): separator = gtk.SeparatorToolItem() separator.props.draw = False if expand: separator.set_expand(True) else: separator.set_size_request(style.DEFAULT_SPACING, -1) self.insert(separator, -1) separator.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 __keep_button_clicked_cb(self, widget, data=None): self.emit('keep-clicked')
def __init__(self, handle): activity.Activity.__init__(self, handle) toolbar_box = ToolbarBox() activity_button = ActivityToolbarButton(self) toolbar_box.toolbar.insert(activity_button, 0) activity_button.show() separator = gtk.SeparatorToolItem() separator.props.draw = False separator.set_expand(True) toolbar_box.toolbar.insert(separator, -1) separator.show() change_color_button = ToolButton('toolbar-colors') change_color_button.set_tooltip(_('Click here to change the background color')) change_color_button.connect('clicked', self.on_change_color_clicked) toolbar_box.toolbar.insert(change_color_button, -1) change_color_button.show() separator = gtk.SeparatorToolItem() separator.props.draw = False separator.set_expand(True) toolbar_box.toolbar.insert(separator, -1) separator.show() stop_button = StopButton(self) stop_button.props.accelerator = '<Ctrl><Shift>Q' toolbar_box.toolbar.insert(stop_button, -1) stop_button.show() button = gtk.Button("Click here to change the background color") button.connect('clicked', self.on_change_color_clicked) button.set_flags(gtk.CAN_DEFAULT) button.grab_default() toolbar_box.add(button) button.show() self.set_toolbar_box(toolbar_box) toolbar_box.show() canvas = gtk.HBox(False, 0) color = gtk.gdk.color_parse("skyblue") self.d_area = gtk.DrawingArea() self.d_area.connect("expose-event", self.expose) self.d_area.modify_bg(gtk.STATE_NORMAL, color) canvas.add(self.d_area) self.set_canvas(canvas) self.show_all()
class NamingToolbar(gtk.Toolbar): """ Toolbar of the naming alert """ __gtype_name__ = 'MyNamingToolbar' __gsignals__ = { 'keep-clicked': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE, ([])), } def __init__(self): gtk.Toolbar.__init__(self) client = gconf.client_get_default() color = XoColor(client.get_string('/desktop/sugar/user/color')) icon = Icon() icon.set_from_icon_name('activity-journal', gtk.ICON_SIZE_LARGE_TOOLBAR) icon.props.xo_color = color self._add_widget(icon) self._add_separator() self._title = gtk.Label(_('Describe your activity')) self._add_widget(self._title) self._add_separator(True) self._keep_button = ToolButton('dialog-ok', tooltip=_('Keep')) self._keep_button.props.accelerator = '<Ctrl>s' self._keep_button.connect('clicked', self.__keep_button_clicked_cb) self.insert(self._keep_button, -1) self._keep_button.show() def _add_separator(self, expand=False): separator = gtk.SeparatorToolItem() separator.props.draw = False if expand: separator.set_expand(True) else: separator.set_size_request(style.DEFAULT_SPACING, -1) self.insert(separator, -1) separator.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 __keep_button_clicked_cb(self, widget, data=None): self.emit('keep-clicked')
class ImageToolbar(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._image = ToolButton('insert-image') self._image.set_tooltip(_('Insert Image')) self._image_id = self._image.connect('clicked', self._image_cb) self.insert(self._image, -1) self._image.show() self._abiword_canvas.connect('image-selected', self._image_selected_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 _image_cb(self, button): chooser = ObjectChooser( _('Choose image'), self._parent, gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT) try: result = chooser.run() if result == gtk.RESPONSE_ACCEPT: logging.debug('ObjectChooser: %r' % chooser.get_selected_object()) jobject = chooser.get_selected_object() if jobject and jobject.file_path: self._abiword_canvas.insert_image(jobject.file_path, True) finally: chooser.destroy() del chooser def _image_selected_cb(self, abi, b): if b: self._toolbox.set_current_toolbar(TOOLBAR_IMAGE) self._abiword_canvas.grab_focus() # hack: bad toolbox, bad!
def _load_toolbar(self): toolbar = gtk.Toolbar() # Remove Feed Palette remove_button = ToolButton(icon_name='list-remove') vbox = gtk.VBox() label = gtk.Label(_('Really delete feed?')) vbox.pack_start(label) hbox = gtk.HBox() expander_label = gtk.Label(' ') hbox.pack_start(expander_label) #b = gtk.Button(icon_name='stock-remove') b = ToolButton(icon_name='list-remove') #b.set_use_stock(True) b.connect('clicked', self._on_remove_feed_activate) hbox.pack_start(b, False) vbox.pack_start(hbox) palette = Palette(_('Remove Feed?')) palette.set_content(vbox) vbox.show_all() remove_button.set_palette(palette) toolbar.insert(remove_button, -1) remove_button.show() # Add Feed Palette button = ToolButton(icon_name='list-add') toolbar.insert(button, -1) button.show() self._add_feed_dialog = AddFeedDialog.AddFeedDialog( gtk.glade.XML(os.path.join(self.glade_prefix, 'penguintv.glade'), "window_add_feed", 'penguintv'), self) #MAGIC content = self._add_feed_dialog.extract_content() content.show_all() #button.connect('clicked', self._add_feed_dialog.show) palette = Palette(_('Subscribe to Feed')) palette.set_content(content) button.set_palette(palette) self._feedlist = gtk.ListStore(int, str, str) self._combo = gtk.ComboBox(self._feedlist) cell = gtk.CellRendererText() self._combo.pack_start(cell, True) self._combo.add_attribute(cell, 'text', 1) self._combo.connect("changed", self._on_combo_select) toolcombo = ToolComboBox(self._combo) toolbar.insert(toolcombo, -1) toolcombo.show_all() toolbar.show() return toolbar
def __init__(self, parent, web_view): gobject.GObject.__init__(self) self._help = parent self._web_view = web_view self._back = ToolButton('go-previous-paired') self._back.set_tooltip(_('Back')) self._back.props.sensitive = False self._back.connect('clicked', self._go_back_cb) self.insert(self._back, -1) self._back.show() self._forward = ToolButton('go-next-paired') self._forward.set_tooltip(_('Forward')) self._forward.props.sensitive = False self._forward.connect('clicked', self._go_forward_cb) self.insert(self._forward, -1) self._forward.show() home = ToolButton('zoom-home') home.set_tooltip(_('Home')) home.connect('clicked', self._go_home_cb) self.insert(home, -1) home.show() separator = gtk.SeparatorToolItem() separator.set_draw(False) separator.set_expand(True) self.insert(separator, -1) separator.show() stop_button = ToolButton('activity-stop') stop_button.set_tooltip(_('Stop')) #stop_button.props.accelerator = '<Ctrl>Q' stop_button.connect('clicked', self.__stop_clicked_cb) self.insert(stop_button, -1) stop_button.show() if version < 0.838: self._listener = xpcom.server.WrapObject( EarlyListener(self), interfaces.nsIWebProgressListener) weak_ref = xpcom.client.WeakReference(self._listener) mask = interfaces.nsIWebProgress.NOTIFY_STATE_NETWORK | \ interfaces.nsIWebProgress.NOTIFY_LOCATION self._web_view.web_progress.addProgressListener( self._listener, mask) else: progress_listener = self._web_view.progress progress_listener.connect('location-changed', self._location_changed_cb) progress_listener.connect('loading-stop', self._loading_stop_cb)
def enable_zoom_bestfit(self, on_zoom_bestfit): """ Enables zoom-to-best-fit support on this toolbar. @param on_zoom_bestfit: The callback function to be called when user wants to zoom to best extent. """ zoom_best_fit_btn = ToolButton('zoom-best-fit') zoom_best_fit_btn.set_tooltip(_('Zoom best fitting extent.')) zoom_best_fit_btn.connect('clicked', on_zoom_bestfit) zoom_best_fit_btn.show() self.insert(zoom_best_fit_btn, -1)
class Toolbar(gtk.Toolbar): def __init__(self, web_view): gobject.GObject.__init__(self) self._web_view = web_view self._back = ToolButton('go-previous-paired') self._back.set_tooltip(_('Back')) self._back.props.sensitive = False self._back.connect('clicked', self._go_back_cb) self.insert(self._back, -1) self._back.show() self._forward = ToolButton('go-next-paired') self._forward.set_tooltip(_('Forward')) self._forward.props.sensitive = False self._forward.connect('clicked', self._go_forward_cb) self.insert(self._forward, -1) self._forward.show() home = ToolButton('zoom-home') home.set_tooltip(_('Home')) home.connect('clicked', self._go_home_cb) self.insert(home, -1) home.show() progress_listener = self._web_view.progress progress_listener.connect('location-changed', self._location_changed_cb) progress_listener.connect('loading-stop', self._loading_stop_cb) def _location_changed_cb(self, progress_listener, uri): self.update_navigation_buttons() def _loading_stop_cb(self, progress_listener): self.update_navigation_buttons() def update_navigation_buttons(self): can_go_back = self._web_view.web_navigation.canGoBack self._back.props.sensitive = can_go_back can_go_forward = self._web_view.web_navigation.canGoForward self._forward.props.sensitive = can_go_forward def _go_back_cb(self, button): self._web_view.web_navigation.goBack() def _go_forward_cb(self, button): self._web_view.web_navigation.goForward() def _go_home_cb(self, button): self._web_view.load_uri(HOME)
def _load_toolbar(self): toolbar = gtk.Toolbar() # Remove Feed Palette remove_button = ToolButton(icon_name='list-remove') vbox = gtk.VBox() label = gtk.Label(_('Really delete feed?')) vbox.pack_start(label) hbox = gtk.HBox() expander_label = gtk.Label(' ') hbox.pack_start(expander_label) #b = gtk.Button(icon_name='stock-remove') b = ToolButton(icon_name='list-remove') #b.set_use_stock(True) b.connect('clicked', self._on_remove_feed_activate) hbox.pack_start(b, False) vbox.pack_start(hbox) palette = Palette(_('Remove Feed?')) palette.set_content(vbox) vbox.show_all() remove_button.set_palette(palette) toolbar.insert(remove_button, -1) remove_button.show() # Add Feed Palette button = ToolButton(icon_name='list-add') toolbar.insert(button, -1) button.show() self._add_feed_dialog = AddFeedDialog.AddFeedDialog(gtk.glade.XML(os.path.join(self.glade_prefix, 'penguintv.glade'), "window_add_feed",'penguintv'), self) #MAGIC content = self._add_feed_dialog.extract_content() content.show_all() #button.connect('clicked', self._add_feed_dialog.show) palette = Palette(_('Subscribe to Feed')) palette.set_content(content) button.set_palette(palette) self._feedlist = gtk.ListStore(int, str, str) self._combo = gtk.ComboBox(self._feedlist) cell = gtk.CellRendererText() self._combo.pack_start(cell, True) self._combo.add_attribute(cell, 'text', 1) self._combo.connect("changed", self._on_combo_select) toolcombo = ToolComboBox(self._combo) toolbar.insert(toolcombo, -1) toolcombo.show_all() toolbar.show() return toolbar
def __init__(self, activity): self._activity = activity gtk.ToolItem.__init__(self) help_button = ToolButton('toolbar-help') help_button.set_tooltip(_('Ayuda')) self.add(help_button) help_button.show() self._palette = help_button.get_palette() help_button.connect('clicked', self.__help_button_clicked_cb)
def __init__(self, activity): self._activity = activity self._current_palette = 'turtle' gtk.ToolItem.__init__(self) help_button = ToolButton('help-toolbar') help_button.set_tooltip(_('Help')) self.add(help_button) help_button.show() self._palette = help_button.get_palette() help_button.connect('clicked', self.__help_button_clicked_cb)
class T2Activity(activity.Activity): def xois_clicked(self, widget, data=None): self.webview.load_uri('http://teach-teacher.ep.io/slides/1') def guide_clicked(self, widget, data=None): self.webview.load_uri('http://teach-teacher.ep.io/slides/17') def diary_clicked(self, widget, data=None): self.webview.load_uri('http://laptop.org/') def society_clicked(self, widget, data=None): self.webview.load_uri('http://147.47.120.20/~olpc_community/') def __init__(self, handle): print "running activity init", handle activity.Activity.__init__(self, handle) print "activity running" self.set_title('Teach Teacher') toolbox = activity.ActivityToolbox(self) self.set_toolbox(toolbox) toolbar = gtk.Toolbar() self.xois = ToolButton('computer-xo') self.xois.set_tooltip("T's XO") self.xois.connect('clicked', self.xois_clicked) toolbar.insert(self.xois, -1) self.xois.show() self.guide = ToolButton('go-next') self.guide.set_tooltip("T's Guide") self.guide.connect('clicked', self.guide_clicked) toolbar.insert(self.guide, -1) self.guide.show() self.diary = ToolButton('activity-journal') self.diary.set_tooltip("T's Diary") self.diary.connect('clicked', self.diary_clicked) toolbar.insert(self.diary, -1) self.diary.show() self.society = ToolButton('zoom-neighborhood') self.society.set_tooltip("T's Society") self.society.connect('clicked', self.society_clicked) toolbar.insert(self.society, -1) self.society.show() toolbar.show() toolbox.add_toolbar("Menu", toolbar) toolbox.show() self.webview = WebView() self.set_canvas(self.webview) self.webview.show() self.webview.load_uri('http://teach-teacher.ep.io/') print "AT END OF THE CLASS"
class EditToolbar(gtk.Toolbar): """Provides the standard edit toolbar for Activities. Members: undo -- the undo button redo -- the redo button copy -- the copy button paste -- the paste button separator -- A separator between undo/redo and copy/paste This class only provides the 'edit' buttons in a standard layout, your activity will need to either hide buttons which make no sense for your Activity, or you need to connect the button events to your own callbacks: ## Example from Read.activity: # Create the edit toolbar: self._edit_toolbar = EditToolbar(self._view) # Hide undo and redo, they're not needed self._edit_toolbar.undo.props.visible = False self._edit_toolbar.redo.props.visible = False # Hide the separator too: self._edit_toolbar.separator.props.visible = False # As long as nothing is selected, copy needs to be insensitive: self._edit_toolbar.copy.set_sensitive(False) # When the user clicks the button, call _edit_toolbar_copy_cb() self._edit_toolbar.copy.connect('clicked', self._edit_toolbar_copy_cb) # Add the edit toolbar: toolbox.add_toolbar(_('Edit'), self._edit_toolbar) # And make it visible: self._edit_toolbar.show() """ def __init__(self): gtk.Toolbar.__init__(self) self.undo = ToolButton('edit-undo') self.undo.set_tooltip(_('Undo')) self.insert(self.undo, -1) self.undo.show() self.redo = ToolButton('edit-redo') self.redo.set_tooltip(_('Redo')) self.insert(self.redo, -1) self.redo.show() self.separator = gtk.SeparatorToolItem() self.separator.set_draw(True) self.insert(self.separator, -1) self.separator.show() self.copy = ToolButton('edit-copy') self.copy.set_tooltip(_('Copy')) self.insert(self.copy, -1) self.copy.show() self.paste = ToolButton('edit-paste') self.paste.set_tooltip(_('Paste')) self.insert(self.paste, -1) self.paste.show()
class TestPalette(Test): def __init__(self): Test.__init__(self) toolbar = gtk.Toolbar() self._invoker = ToolButton('go-previous') toolbar.insert(self._invoker, -1) self._invoker.show() self.pack_start(toolbar, False) toolbar.show() def set_palette(self, palette): self._invoker.set_palette(palette)
def addButton(self, nameID, image1path, image2path, tooltip1, tooltip2, cb): button = ToolButton() button.image1 = gtk.Image() button.image1.set_from_file(image1path) button.image2 = gtk.Image() button.image2.set_from_file(image2path) button.image1.show() button.nameID = nameID button.tooltip1, button.tooltip2 = tooltip1, tooltip2 button.set_icon_widget(button.image1) button.connect('clicked', cb) button.set_tooltip(_(button.tooltip1)) button.active = False self.insert(button, -1) button.show() return button
def addButton(self, nameID, image1path, image2path, tooltip1, tooltip2, cb): button = ToolButton() log.info("addButtonIMAGE PATH ____ " + image1path ) button.image1 = gtk.Image() button.image1.set_from_file(image1path) button.image2 = gtk.Image() button.image2.set_from_file(image2path) button.image1.show() button.tooltip1, button.tooltip2 = tooltip1, tooltip2 button.set_icon_widget(button.image1) button.connect('clicked', cb) button.set_tooltip(_(button.tooltip1)) button.nameID = nameID self.toolbar_box.toolbar.insert(button, -1) button.show() self.nameID.update({nameID:button})
def __init__(self, title, bundle_path, document_path): gtk.Toolbar.__init__(self) self._add_separator() activity_bundle = ActivityBundle(bundle_path) file_name = activity_bundle.get_icon() if document_path is not None and os.path.exists(document_path): document_button = DocumentButton(file_name, document_path, title) document_button.connect('toggled', self.__button_toggled_cb, document_path) self.insert(document_button, -1) document_button.show() self._add_separator() if bundle_path is not None and os.path.exists(bundle_path): activity_button = RadioToolButton() icon = Icon(file=file_name, icon_size=gtk.ICON_SIZE_LARGE_TOOLBAR, fill_color=style.COLOR_TRANSPARENT.get_svg(), stroke_color=style.COLOR_WHITE.get_svg()) activity_button.set_icon_widget(icon) icon.show() if document_path is not None: activity_button.props.group = document_button activity_button.props.tooltip = _('Activity Bundle Source') activity_button.connect('toggled', self.__button_toggled_cb, bundle_path) self.insert(activity_button, -1) activity_button.show() self._add_separator() text = _('View source: %r') % title label = gtk.Label() label.set_markup('<b>%s</b>' % text) label.set_alignment(0, 0.5) self._add_widget(label) self._add_separator(True) stop = ToolButton(icon_name='dialog-cancel') stop.set_tooltip(_('Close')) stop.connect('clicked', self.__stop_clicked_cb) stop.show() self.insert(stop, -1) stop.show()
def __init__(self): gtk.HBox.__init__(self) self.toolbar = VTray() copy = ToolButton("edit-copy") copy.set_tooltip('Copy') copy.connect("clicked", self.__copy_cb) copy.show() self.toolbar.add_item(copy, -1) paste = ToolButton("edit-paste") paste.set_tooltip("Paste") paste.connect("clicked", self.__paste_cb) paste.show() self.toolbar.add_item(paste, -1) fgcolor = ColorToolButton() fgcolor.get_child()._title = "Font Color" self.toolbar.add_item(fgcolor, -1) fgcolor.connect('notify::color', self._fgcolor_cb) fgcolor.show_all() bgcolor = ColorToolButton() bgcolor.get_child()._title = "Background Color" bgcolor.connect('notify::color', self._bgcolor_cb) self.toolbar.add_item(bgcolor, -1) bgcolor.show_all() self.console = Console() self.console.set_bgcolor(gtk.gdk.color_parse("#FFFFFF")) self.console.set_fgcolor(gtk.gdk.color_parse("#000000")) bgcolor.set_color(gtk.gdk.color_parse("#FFFFFF")) fgcolor.set_color(gtk.gdk.color_parse("#000000")) self.console.show() font = ToolButton("format-text") font.set_tooltip("Console Font") fontselection = gtk.FontSelection() fontselection.get_family_list().get_selection().connect("changed", self.update_font, fontselection) fontselection.get_face_list().get_selection().connect("changed", self.update_font, fontselection) fontselection.get_size_entry().connect("changed", self.update_font, fontselection) fontselection.get_size_entry().connect("activate", self.update_font, fontselection) fontselection.show() font.props.palette.set_content(fontselection) fontselection.set_font_name("Monospace Regular 10") font.show() self.toolbar.add_item(font, -1) reset = ToolButton("view-refresh") reset.set_tooltip("Reset Console") reset.connect("clicked", self.reset) reset.show() self.toolbar.add_item(reset, -1) self.toolbar.show() self.pack_start(self.toolbar, False, True, 0) self.console.run_command("python") self.pack_start(self.console)
def button_factory(icon_name, tooltip, callback, toolbar, cb_arg=None, accelerator=None): '''Factory for making toolbar buttons''' my_button = ToolButton(icon_name) my_button.set_tooltip(tooltip) my_button.props.sensitive = True if accelerator is not None: my_button.props.accelerator = accelerator if cb_arg is not None: my_button.connect('clicked', callback, cb_arg) else: my_button.connect('clicked', callback) if hasattr(toolbar, 'insert'): # the main toolbar toolbar.insert(my_button, -1) else: # or a secondary toolbar toolbar.props.page.insert(my_button, -1) my_button.show() return my_button
def build_toolbar(self): self.max_participants = 1 toolbox = ToolbarBox() activity_button = ActivityToolbarButton(self) toolbox.toolbar.insert(activity_button, -1) activity_button.show() pano_toolbar = toolbox.toolbar new_button = ToolButton('stock_refresh') new_button.set_tooltip(_('New Panorama')) new_button.connect('clicked', self.new_event) pano_toolbar.insert(new_button, -1) new_button.show() capture_button = ToolButton('add_capture') capture_button.set_tooltip(_('Add a capture to the Panorama')) capture_button.connect('clicked', self.capture_event) pano_toolbar.insert(capture_button, -1) capture_button.show() stitch_button = ToolButton('format-columns-triple') stitch_button.set_tooltip(_('Stitch Panorama')) stitch_button.connect('clicked', self.stitch_event) pano_toolbar.insert(stitch_button, -1) stitch_button.show() stiching_auto = ToolButton('media-playback-start') stiching_auto.set_tooltip(_('Enable auto-stitch')) stiching_auto.connect('clicked', self.change_stich) pano_toolbar.insert(stiching_auto, -1) save_button = ToolButton('filesave') save_button.set_tooltip(_('Save Panorama')) save_button.connect('clicked', self.save_event) pano_toolbar.insert(save_button, -1) save_button.show() separator = gtk.SeparatorToolItem() separator.props.draw = False separator.set_expand(True) pano_toolbar.insert(separator,-1) stop_button = StopButton(self) stop_button.props.accelerator = '<Ctrl>q' pano_toolbar.insert(stop_button, -1) stop_button.show() self.set_toolbar_box(toolbox) toolbox.show_all()
def button_factory(icon_name, toolbar, callback, cb_arg=None, tooltip=None, accelerator=None): '''Factory for making toolbar buttons''' button = ToolButton(icon_name) if tooltip is not None: button.set_tooltip(tooltip) button.props.sensitive = True if accelerator is not None: button.props.accelerator = accelerator if cb_arg is not None: button.connect('clicked', callback, cb_arg) else: button.connect('clicked', callback) if hasattr(toolbar, 'insert'): # the main toolbar toolbar.insert(button, -1) else: # or a secondary toolbar toolbar.props.page.insert(button, -1) button.show() return button
class ViewToolbar(gtk.Toolbar): __gtype_name__ = 'ViewToolbar' __gsignals__ = { 'needs-update-size': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE, ([])), 'go-fullscreen': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE, ([])) } def __init__(self): gtk.Toolbar.__init__(self) 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 fullscreen_cb(self, button): self.emit('go-fullscreen')
class RecordToolbar(gtk.Toolbar): def __init__(self, jam): gtk.Toolbar.__init__(self) def _insertSeparator(x=1): for i in range(x): self.separator = gtk.SeparatorToolItem() self.separator.set_draw(True) self.insert(self.separator, -1) self.separator.show() #self.toolbox = toolbox self.jam = jam if Config.FEATURES_MIC: self.micRec1Button = ToolButton('rec1') self.micRec1Button.connect('clicked', self.jam.micRec, 'mic1') self.insert(self.micRec1Button, -1) self.micRec1Button.show() self.micRec1Button.set_tooltip(_('Record microphone into slot 1')) self.micRec2Button = ToolButton('rec2') self.micRec2Button.connect('clicked', self.jam.micRec, 'mic2') self.insert(self.micRec2Button, -1) self.micRec2Button.show() self.micRec2Button.set_tooltip(_('Record microphone into slot 2')) self.micRec3Button = ToolButton('rec3') self.micRec3Button.connect('clicked', self.jam.micRec, 'mic3') self.insert(self.micRec3Button, -1) self.micRec3Button.show() self.micRec3Button.set_tooltip(_('Record microphone into slot 3')) self.micRec4Button = ToolButton('rec4') self.micRec4Button.connect('clicked', self.jam.micRec, 'mic4') self.insert(self.micRec4Button, -1) self.micRec4Button.show() self.micRec4Button.set_tooltip(('Record microphone into slot 4')) _insertSeparator() if Config.FEATURES_NEWSOUNDS: self._loopSettingsPalette = LoopSettingsPalette( _('Add new Sound'), self.jam) self.loopSetButton = ToggleToolButton('loop') self.loopSetButton.set_palette(self._loopSettingsPalette) self.insert(self.loopSetButton, -1) self.loopSetButton.show() self.show_all()
class ViewToolbar(gtk.Toolbar): __gtype_name__ = 'ViewToolbar' __gsignals__ = { 'needs-update-size': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE, ([])), 'go-fullscreen': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE, ([])) } def __init__(self): gtk.Toolbar.__init__(self) self.zoom_out = ToolButton('zoom-out') self.zoom_out.set_tooltip(_('Zoom out')) self.insert(self.zoom_out, -1) self.zoom_out.show() self.zoom_in = ToolButton('zoom-in') self.zoom_in.set_tooltip(_('Zoom in')) self.insert(self.zoom_in, -1) self.zoom_in.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 fullscreen_cb(self, button): self.emit('go-fullscreen')
def __init__(self): gtk.Toolbar.__init__(self) self._metadata = None self._temp_file_path = None self._resume = ToolButton('activity-start') self._resume.connect('clicked', self._resume_clicked_cb) self.add(self._resume) self._resume.show() client = gconf.client_get_default() color = XoColor(client.get_string('/desktop/sugar/user/color')) self._copy = ToolButton() icon = Icon(icon_name='edit-copy', xo_color=color) self._copy.set_icon_widget(icon) icon.show() self._copy.set_tooltip(_('Copy to')) self._copy.connect('clicked', self._copy_clicked_cb) self.add(self._copy) self._copy.show() self._duplicate = ToolButton() icon = Icon(icon_name='edit-duplicate', xo_color=color) self._duplicate.set_icon_widget(icon) self._duplicate.set_tooltip(_('Duplicate')) self._duplicate.connect('clicked', self._duplicate_clicked_cb) self.add(self._duplicate) separator = gtk.SeparatorToolItem() self.add(separator) separator.show() erase_button = ToolButton('list-remove') erase_button.set_tooltip(_('Erase')) erase_button.connect('clicked', self._erase_button_clicked_cb) self.add(erase_button) erase_button.show()
class ViewToolbar(gtk.Toolbar): __gsignals__ = { 'go-fullscreen': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE, ([])) } def __init__(self): gtk.Toolbar.__init__(self) 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.props.sensitive = False 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.props.sensitive = True self._zoom_in.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.props.sensitive = False self._zoom_out.props.sensitive = True self.activity.zoom_to_width() def _zoom_out_cb(self, button): self._zoom_in.props.sensitive = True self._zoom_out.props.sensitive = False self.activity.zoom_to_fit() def enable_zoom_in(self): self._zoom_in.props.sensitive = True self._zoom_out.props.sensitive = False def enable_zoom_out(self): self._zoom_in.props.sensitive = False self._zoom_out.props.sensitive = True def set_activity(self, activity): self.activity = activity def _fullscreen_cb(self, button): self.emit('go-fullscreen')
class WebToolbar(gtk.Toolbar): def __init__(self,browser): from sugar.graphics.toolbutton import ToolButton self.logger = logging.getLogger("gvr.Widgets.WebToolbar") gtk.Toolbar.__init__(self) self._browser = browser self._back = ToolButton('go-previous') self._back.set_tooltip(_('Go back one page')) self._back.connect('clicked', self._go_back_cb) self.insert(self._back, -1) self._back.show() self._forw = ToolButton('go-next') self._forw.set_tooltip(_('Go one page forward')) self._forw.connect('clicked', self._go_forward_cb) self.insert(self._forw, -1) self._forw.show() def _go_forward_cb(self,button): self._browser.web_navigation.goForward() def _go_back_cb(self,button): self._browser.web_navigation.goBack()
class Toolbar(gtk.Toolbar): def __init__(self, web_view): gobject.GObject.__init__(self) self._web_view = web_view self._back = ToolButton("go-previous-paired") self._back.set_tooltip(_("Back")) self._back.props.sensitive = False self._back.connect("clicked", self._go_back_cb) self.insert(self._back, -1) self._back.show() self._forward = ToolButton("go-next-paired") self._forward.set_tooltip(_("Forward")) self._forward.props.sensitive = False self._forward.connect("clicked", self._go_forward_cb) self.insert(self._forward, -1) self._forward.show() self._home = ToolButton("go-home") self._home.set_tooltip(_("Home")) self._home.connect("clicked", self._go_home_cb) self.insert(self._home, -1) self._home.show() progress_listener = self._web_view.progress progress_listener.connect("location-changed", self._location_changed_cb) progress_listener.connect("loading-stop", self._loading_stop_cb) def _location_changed_cb(self, progress_listener, uri): self.update_navigation_buttons() def _loading_stop_cb(self, progress_listener): self.update_navigation_buttons() def update_navigation_buttons(self): can_go_back = self._web_view.web_navigation.canGoBack self._back.props.sensitive = can_go_back can_go_forward = self._web_view.web_navigation.canGoForward self._forward.props.sensitive = can_go_forward def _go_back_cb(self, button): self._web_view.web_navigation.goBack() def _go_forward_cb(self, button): self._web_view.web_navigation.goForward() def _go_home_cb(self, button): self._web_view.load_uri(HOME)
class ViewToolbar(gtk.Toolbar): def __init__(self, activity): gtk.Toolbar.__init__(self) self._activity = activity self._browser = self._activity._web_view self.zoomout = ToolButton('zoom-out') self.zoomout.set_tooltip(_('Zoom out')) self.zoomout.connect('clicked', self.__zoomout_clicked_cb) self.insert(self.zoomout, -1) self.zoomout.show() self.zoomin = ToolButton('zoom-in') self.zoomin.set_tooltip(_('Zoom in')) self.zoomin.connect('clicked', self.__zoomin_clicked_cb) self.insert(self.zoomin, -1) self.zoomin.show() self.separator = gtk.SeparatorToolItem() self.separator.set_draw(True) self.insert(self.separator, -1) self.separator.show() self.fullscreen = ToolButton('view-fullscreen') self.fullscreen.set_tooltip(_('Fullscreen')) self.fullscreen.connect('clicked', self.__fullscreen_clicked_cb) self.insert(self.fullscreen, -1) self.fullscreen.show() def __zoomin_clicked_cb(self, button): self._browser.zoom_in() def __zoomout_clicked_cb(self, button): self._browser.zoom_out() def __fullscreen_clicked_cb(self, button): self._activity.fullscreen()
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 ActivityToolbar(gtk.Toolbar): """The Activity toolbar with the Journal entry title, sharing, Keep and Stop buttons All activities should have this toolbar. It is easiest to add it to your Activity by using the ActivityToolbox. """ def __init__(self, activity): gtk.Toolbar.__init__(self) self._activity = activity self._updating_share = False """ activity.connect('shared', self.__activity_shared_cb) activity.connect('joined', self.__activity_shared_cb) activity.connect('notify::max_participants', self.__max_participants_changed_cb) """ #if activity.metadata: if True: self.label = gtk.Label(display.menu_journal_label) self.label.show() self._add_widget(self.label) self.title = gtk.Entry() self.title.set_size_request(int(gtk.gdk.screen_width() / 6), -1) if activity.metadata: self.title.set_text(activity.metadata['title']) #activity.metadata.connect('updated', self.__jobject_updated_cb) self.title.connect('changed', self.__title_changed_cb) self.title.connect('activate', self.__update_title_cb) self._add_widget(self.title) fn = os.path.join(os.getcwd(),'assets','stack_new.png') button = ImageButton() tooltip = _("Add Album Stack") button.set_image(fn,tip=tooltip) self.add_album = button self.add_album.show() self.add_album.connect('clicked', self.__add_album_clicked_cb) self.insert(self.add_album,-1) fn = os.path.join(os.getcwd(),'assets','stack_del.png') button = ImageButton() tooltip = _("Delete Album Stack") button.set_image(fn,tip=tooltip) button.connect('clicked', self.__delete_album_clicked_cb) self.insert(button,-1) fn = os.path.join(os.getcwd(),'assets','trash_del.png') button = ImageButton() tooltip = _("Remove Trash Images from XO") button.set_image(fn,tip=tooltip) self.empty_journal_button = button self.empty_journal_button.hide() self.empty_journal_button.connect('clicked',self.__empty_trash_clicked_cb) self.insert(self.empty_journal_button,-1) """ separator = gtk.SeparatorToolItem() separator.props.draw = False separator.set_expand(True) self.insert(separator, -1) separator.show() self.share = ToolComboBox(label_text=_('Traceback:')) self.share.combo.connect('changed', self.__traceback_changed_cb) self.share.combo.append_item("traceback_plain", _('Plain')) self.share.combo.append_item('traceback_context', _('Context')) self.share.combo.append_item('traceback_verbose', _('Verbose')) self.insert(self.share, -1) self.share.show() self._update_share() """ separator = gtk.SeparatorToolItem() separator.props.draw = False separator.set_expand(True) self.insert(separator, -1) separator.show() self.keep = ToolButton() self.keep.set_tooltip(_('Save and Start New')) #client = gconf.client_get_default() #color = XoColor(client.get_string('/desktop/sugar/user/color')) #keep_icon = Icon(icon_name='document-save', xo_color=color) keep_icon = Icon(icon_name='document-save') keep_icon.show() self.keep.set_icon_widget(keep_icon) #self.keep.props.accelerator = '<Ctrl>S' self.keep.connect('clicked', self.__keep_clicked_cb) self.insert(self.keep, -1) self.keep.show() self.stop = ToolButton('activity-stop') self.stop.set_tooltip(_('Stop')) #self.stop.props.accelerator = '<Ctrl>Q' self.stop.connect('clicked', self.__stop_clicked_cb) self.insert(self.stop, -1) self.stop.show() self._update_title_sid = None def set_label(self,text,visible=True): self.label.set_text(text) if not visible: self.title.set_sensitive(False) else: self.title.set_sensitive(True) def _update_share(self): self._updating_share = True if self._activity.props.max_participants == 1: self.share.hide() if self._activity.get_shared(): self.share.set_sensitive(False) self.share.combo.set_active(1) else: self.share.set_sensitive(True) self.share.combo.set_active(0) self._updating_share = False def __add_album_clicked_cb (self,button): title = self.title.get_text() self._activity.activity_toolbar_add_album_cb(title) def __delete_album_clicked_cb (self,button): self._activity.activity_toolbar_delete_album_cb() def __empty_trash_clicked_cb(self,button): self._activity.activity_toolbar_empty_trash_cb() def __traceback_changed_cb(self, combo): model = self.share.combo.get_model() it = self.share.combo.get_active_iter() (scope, ) = model.get(it, 0) if scope == 'traceback_plain': self._activity.traceback = 'Plain' self._activity.debug_dict['traceback'] = 'plain' elif scope == 'traceback_context': self._activity.traceback = 'Context' self._activity.debug_dict['traceback'] = 'context' elif scope == 'traceback_verbose': self._activity.traceback = 'Verbose' self._activity.debug_dict['traceback'] = 'verbose' self._activity.set_ipython_traceback() def __keep_clicked_cb(self, button): self._activity.save_icon_clicked = True self._activity.copy() def __stop_clicked_cb(self, button): self._activity.stop() def __jobject_updated_cb(self, jobject): self.title.set_text(jobject['title']) def __title_changed_cb(self, entry): if not self._update_title_sid: self._update_title_sid = gobject.timeout_add( 1000, self.__update_title_cb) def __update_title_cb(self, entry=None): title = self.title.get_text() if self._activity.game.is_journal(): self._activity.metadata['title'] = title self._activity.metadata['title_set_by_user'] = '******' else: self._activity.game.change_album_name(title) title_set_by_user = self._activity.metadata.get('title_set_by_user') if not title_set_by_user: #let the journal title reflect the most recent stack self._activity.metadata['title'] = title self._update_title_sid = None return False 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 __activity_shared_cb(self, activity): self._update_share() def __max_participants_changed_cb(self, activity, pspec): self._update_share()
class SectionToolbar(gtk.Toolbar): """ Toolbar of the sections of the control panel """ __gtype_name__ = 'SectionToolbar' __gsignals__ = { 'cancel-clicked': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE, ([])), 'accept-clicked': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE, ([])), } def __init__(self): gtk.Toolbar.__init__(self) self._add_separator() self._icon = Icon() self._add_widget(self._icon) self._add_separator() self._title = gtk.Label() self._add_widget(self._title) self._add_separator(True) self.cancel_button = ToolButton('dialog-cancel') self.cancel_button.set_tooltip(_('Cancel')) self.cancel_button.connect('clicked', self.__cancel_button_clicked_cb) self.insert(self.cancel_button, -1) self.cancel_button.show() self.accept_button = ToolButton('dialog-ok') self.accept_button.set_tooltip(_('Ok')) self.accept_button.connect('clicked', self.__accept_button_clicked_cb) self.insert(self.accept_button, -1) self.accept_button.show() def get_icon(self): return self._icon def get_title(self): return self._title def _add_separator(self, expand=False): separator = gtk.SeparatorToolItem() separator.props.draw = False if expand: separator.set_expand(True) else: separator.set_size_request(style.DEFAULT_SPACING, -1) self.insert(separator, -1) separator.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 __cancel_button_clicked_cb(self, widget, data=None): self.emit('cancel-clicked') def __accept_button_clicked_cb(self, widget, data=None): self.emit('accept-clicked')
class ActivityToolbar(gtk.Toolbar): """The Activity toolbar with the Journal entry title, sharing, Keep and Stop buttons All activities should have this toolbar. It is easiest to add it to your Activity by using the ActivityToolbox. """ def __init__(self, activity): gtk.Toolbar.__init__(self) self._activity = activity self._updating_share = False self._focus_out_hid = None activity.connect('shared', self.__activity_shared_cb) activity.connect('joined', self.__activity_shared_cb) activity.connect('notify::max_participants', self.__max_participants_changed_cb) if activity.metadata: self.title = gtk.Entry() self.title.set_size_request(int(gtk.gdk.screen_width() / 3), -1) self.title.set_text(activity.metadata['title']) self._focus_out_hid = self.title.connect('focus-out-event', self.__title_changed_cb) self._add_widget(self.title) activity.metadata.connect('updated', self.__jobject_updated_cb) separator = gtk.SeparatorToolItem() separator.props.draw = False separator.set_expand(True) self.insert(separator, -1) separator.show() self.share = ToolComboBox(label_text=_('Share with:')) self.share.combo.connect('changed', self.__share_changed_cb) self.share.combo.append_item(SCOPE_PRIVATE, _('Private'), 'zoom-home') self.share.combo.append_item(SCOPE_NEIGHBORHOOD, _('My Neighborhood'), 'zoom-neighborhood') self.insert(self.share, -1) self.share.show() self._update_share() self.keep = ToolButton(tooltip=_('Keep')) client = gconf.client_get_default() color = XoColor(client.get_string('/desktop/sugar/user/color')) keep_icon = Icon(icon_name='document-save', xo_color=color) self.keep.set_icon_widget(keep_icon) keep_icon.show() self.keep.props.accelerator = '<Ctrl>S' self.keep.connect('clicked', self.__keep_clicked_cb) self.insert(self.keep, -1) self.keep.show() self.stop = ToolButton('activity-stop', tooltip=_('Stop')) self.stop.props.accelerator = '<Ctrl>Q' self.stop.connect('clicked', self.__stop_clicked_cb) self.insert(self.stop, -1) self.stop.show() def _update_share(self): self._updating_share = True if self._activity.props.max_participants == 1: self.share.hide() if self._activity.get_shared(): self.share.set_sensitive(False) self.share.combo.set_active(1) else: self.share.set_sensitive(True) self.share.combo.set_active(0) self._updating_share = False def __share_changed_cb(self, combo): if self._updating_share: return model = self.share.combo.get_model() it = self.share.combo.get_active_iter() (scope, ) = model.get(it, 0) if scope == SCOPE_NEIGHBORHOOD: self._activity.share() def __keep_clicked_cb(self, button): self._activity.copy() def __stop_clicked_cb(self, button): if self._focus_out_hid is not None: self.title.disconnect(self._focus_out_hid) self._update_title(self.title.get_text()) self._activity.close() def __jobject_updated_cb(self, jobject): self.title.set_text(jobject['title']) def __title_changed_cb(self, editable, event): title = editable.get_text() self._update_title(title) def _update_title(self, title): # Title really changed? if title == self._activity.metadata['title']: return False self._activity.metadata['title'] = title self._activity.metadata['title_set_by_user'] = '******' self._activity.save() shared_activity = self._activity.get_shared_activity() if shared_activity: shared_activity.props.name = title return False 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 __activity_shared_cb(self, activity): self._update_share() def __max_participants_changed_cb(self, activity, pspec): self._update_share()
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)