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 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
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 MemorizeToolbar(gtk.Toolbar): __gtype_name__ = 'MemoryToolbar' standard_game_names = ['Load demo games', 'addition', 'letters', 'sounds' ] translated_game_names = [_('Load demo games'), _('addition'), _('letters'), _('sounds') ] __gsignals__ = { 'game_changed': (SIGNAL_RUN_FIRST, None, 5 * [TYPE_PYOBJECT]), } def __init__(self, activity): gtk.Toolbar.__init__(self) self.activity = activity self._lock = True self.jobject = None # Reset Button restart_icon = join(dirname(__file__), 'images', 'game-restart.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_reset_cb) self._restart_button.set_tooltip(_('Restart Game')) self.insert(self._restart_button, -1) self._restart_button.show() # 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) # Separator separator = gtk.SeparatorToolItem() separator.set_draw(True) self.insert(separator, -1) # Change size combobox self._size_combo = ToolComboBox() self._sizes = ['4 X 4', '5 X 5', '6 X 6'] for i, f in enumerate(self._sizes): self._size_combo.combo.append_item(i, f) self.size_handle_id = self._size_combo.combo.connect( \ 'changed', self._game_size_cb) self._add_widget(self._size_combo) self._size_combo.combo.set_active(0) separator = gtk.SeparatorToolItem() separator.set_draw(True) self.insert(separator, -1) self._lock = False # Change demo games combobox self._game_combo = ToolComboBox() for i, f in enumerate(self.standard_game_names): f = _(f) self._game_combo.combo.append_item(i, f) self._game_combo.combo.set_active(0) self._game_combo.combo.connect('changed', self._game_changed_cb) self._add_widget(self._game_combo) 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_reset_cb(self, widget): self.emit('game_changed', None, None, 'reset', None, None) 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: title = jobject.metadata['title'] if jobject.metadata.has_key('icon-color'): color = jobject.metadata['icon-color'] else: color = profile.get_color().to_string() self.emit('game_changed', jobject.file_path, 4, 'file', title, color) if self.jobject != None: self.jobject.destroy() self.jobject = jobject def _game_size_cb(self, widget): game_size = int(self._sizes[self._size_combo.combo.get_active()][0]) self.emit('game_changed', None, game_size, 'size', None, None) def _game_changed_cb(self, combobox): if combobox.get_active() == 0: return current_game = self._game_combo.combo.get_active() game_name = self.standard_game_names[current_game] title = game_name game_size = int(self._sizes[self._size_combo.combo.get_active()][0]) if game_name in self.translated_game_names: index = self.translated_game_names.index(game_name) game_name = self.standard_game_names[index] game_file = join(dirname(__file__), 'demos', game_name+'.zip') self.emit('game_changed', game_file, game_size, 'demo', title, None) self._game_combo.combo.set_active(0) 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 __init__(self, activity, top_level_toolbox): self._activity = activity self.toolbox = top_level_toolbox Terminal.__init__(self, self) #set up tool box/menu buttons activity_toolbar = self.toolbox.get_activity_toolbar() separator = gtk.SeparatorToolItem() separator.set_draw(True) separator.show() activity_toolbar.insert(separator, 0) activity_go = ToolButton() activity_go.set_stock_id('gtk-media-forward') activity_go.set_icon_widget(None) activity_go.set_tooltip(_('Start Debugging')) activity_go.connect('clicked', self.project_run_cb) activity_go.add_accelerator('clicked', self.get_accelerator(), ord('O'), gtk.gdk.CONTROL_MASK, gtk.ACCEL_VISIBLE) activity_go.show() activity_toolbar.insert(activity_go, 0) activity_copy_tb = ToolButton('edit-copy') activity_copy_tb.set_tooltip(_('Copy')) activity_copy_tb.connect('clicked', self._copy_cb) activity_toolbar.insert(activity_copy_tb, 3) activity_copy_tb.show() activity_paste_tb = ToolButton('edit-paste') activity_paste_tb.set_tooltip(_('Paste')) activity_paste_tb.connect('clicked', self._paste_cb) activity_paste_tb.add_accelerator('clicked', self.get_accelerator(), ord('V'), gtk.gdk.CONTROL_MASK, gtk.ACCEL_VISIBLE) activity_toolbar.insert(activity_paste_tb, 4) activity_paste_tb.show() activity_tab_tb = sugar.graphics.toolbutton.ToolButton('list-add') activity_tab_tb.set_tooltip(_("Open New Tab")) activity_tab_tb.add_accelerator('clicked', self.get_accelerator(), ord('T'), gtk.gdk.CONTROL_MASK, gtk.ACCEL_VISIBLE) activity_tab_tb.show() activity_tab_tb.connect('clicked', self._open_tab_cb) activity_toolbar.insert(activity_tab_tb, 5) activity_tab_delete_tv = sugar.graphics.toolbutton.ToolButton( 'list-remove') activity_tab_delete_tv.set_tooltip(_("Close Tab")) activity_tab_delete_tv.show() activity_tab_delete_tv.connect('clicked', self._close_tab_cb) activity_toolbar.insert(activity_tab_delete_tv, 6) activity_fullscreen_tb = sugar.graphics.toolbutton.ToolButton( 'view-fullscreen') activity_fullscreen_tb.set_tooltip(_("Fullscreen")) activity_fullscreen_tb.connect('clicked', self._activity._fullscreen_cb) activity_toolbar.insert(activity_fullscreen_tb, 7) activity_fullscreen_tb.hide()
class Jam2JamToolBar(gtk.Toolbar): def __init__(self, activity): gtk.Toolbar.__init__(self) self.activity = activity self.parameters = ['Density', 'Pitch', 'Length', 'Timbre', 'Volume'] # no tempo here. scene_stuff = readScenes(self.activity._ScenePath) self.scenes = scene_stuff.get_scene_list() #example of scene data. This gets read from file #self.scenes = [['City', 'A', 'minor pentatonic'], ['City', 'G#', 'major']] #this data needs to be obtained from directories self.play_pause_state = 'Playing' self.scene_init = True # Separator separator = gtk.SeparatorToolItem() separator.set_draw(True) self.insert(separator, -1) #Horizontal Parameter control combobox self._add_widget(gtk.Label(_('Horizontal:'))) self._Hparameter_combo = ToolComboBox() for i, f in enumerate(self.parameters): self._Hparameter_combo.combo.append_item(i, f) self._Hparameter_combo.combo.connect('changed', self._Hparameter_change_cb) self._add_widget(self._Hparameter_combo) self._Hparameter_combo.combo.set_active(0) # Separator separator = gtk.SeparatorToolItem() separator.set_draw(True) separator.show() self.insert(separator, -1) #Vertical Parameter control combobox self._add_widget(gtk.Label(_('Vertical:'))) self._Vparameter_combo = ToolComboBox() for j, k in enumerate(self.parameters): self._Vparameter_combo.combo.append_item(j, k) self._Vparameter_combo.combo.connect('changed', self._Vparameter_change_cb) self._add_widget(self._Vparameter_combo) self._Vparameter_combo.combo.set_active(1) # Separator separator = gtk.SeparatorToolItem() separator.set_draw(True) separator.show() self.insert(separator, -1) #Scene Selection control combobox self._add_widget(gtk.Label(_('Scene:'))) self._Scene_combo = ToolComboBox() for l, m in enumerate(self.scenes): self._Scene_combo.combo.append_item(l, m[0]) self._Scene_combo.combo.connect('changed', self._Scene_change_cb) self._add_widget(self._Scene_combo) #ought to do this safely somehow. self._Scene_combo.combo.set_active(0) self.scene_init = False # Separator separator = gtk.SeparatorToolItem() separator.set_draw(True) separator.show() self.insert(separator, -1) #Camera Button self.camera_ready = True camera_icon = ImagePath + "/camera-external.svg" camera_busy_icon = ImagePath + "/camera-busy.svg" self.camera_image, self.camera_busy_image = gtk.Image(), gtk.Image() self.camera_image.set_from_file(camera_icon) self.camera_busy_image.set_from_file(camera_busy_icon) self.camera_image.show() #camera_busy_image.show() self._cameraButton = ToolButton() self._cameraButton.set_icon_widget(self.camera_image) self._cameraButton.connect('clicked', self._cameraSnap_cb) self._cameraButton.set_tooltip(_('Snapshot')) self.insert(self._cameraButton, -1) self._cameraButton.show() # Separator separator = gtk.SeparatorToolItem() separator.set_draw(True) separator.show() self.insert(separator, -1) #Play/Pause Button pause_icon = ImagePath + "/media-playback-pause.svg" play_icon = ImagePath + "/media-playback-start.svg" self.pause_image = gtk.Image() self.pause_image.set_from_file(pause_icon) self.play_image = gtk.Image() self.play_image.set_from_file(play_icon) self._pauseButton = ToolButton() self._pauseButton.connect('clicked', self._pause_cb) self.pause_image.show() self._pauseButton.set_icon_widget(self.pause_image) self._pauseButton.set_tooltip(_('Pause')) #self._toggleplay_pause() self.insert(self._pauseButton, -1) self._pauseButton.show() # Separator separator = gtk.SeparatorToolItem() separator.set_draw(True) separator.show() self.insert(separator, -1) 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 _toggleplay_pause(self): if self.play_pause_state == "Playing": self.activity.jamScene.music_player.pause() self.play_image.show() self._pauseButton.set_icon_widget(self.play_image) self._pauseButton.set_tooltip(_('Play')) self.play_pause_state = "Paused" else: self.activity.jamScene.music_player.resume() self.pause_image.show() self._pauseButton.set_icon_widget(self.pause_image) self._pauseButton.set_tooltip(_('Pause')) self.play_pause_state = "Playing" try: self.activity._pgc.grab_focus() except AttributeError: pass def _show_busy_camera(self): self.camera_ready = False self.camera_busy_image.show() self._cameraButton.set_icon_widget(self.camera_busy_image) self._cameraButton.set_tooltip(_('Please wait...')) def _show_active_camera(self): self.camera_image.show() self._cameraButton.set_icon_widget(self.camera_image) self._cameraButton.set_tooltip(_('Snap')) self.camera_ready = True def _Hparameter_change_cb(self, widget): param = "Parameter|Horizontal|" + self.parameters[self._Hparameter_combo.combo.get_active()] olpcgames.eventwrap.post(olpcgames.eventwrap.Event(pygame.USEREVENT, action=param)) try: self.activity._pgc.grab_focus() except AttributeError: pass def _Vparameter_change_cb(self, widget): param = "Parameter|Vertical|" + self.parameters[self._Vparameter_combo.combo.get_active()] olpcgames.eventwrap.post(olpcgames.eventwrap.Event(pygame.USEREVENT, action=param)) try: self.activity._pgc.grab_focus() except AttributeError: pass def _Scene_change_cb(self, widget): if self.scene_init: pass else: selection = self.scenes[self._Scene_combo.combo.get_active()] scene = "Reload|" + '|'.join(map(lambda x: str(x), selection)) olpcgames.eventwrap.post(olpcgames.eventwrap.Event(pygame.USEREVENT, action=scene)) try: self.activity._pgc.grab_focus() except AttributeError: pass ### functions to assist calls from pygame def deactivate_scene_change(self): self._Scene_combo.set_sensitive(False) def reactivate_scene_change(self): self._Scene_combo.set_sensitive(True) def set_horizontal_parameter(self, param): ndx = self.parameters.index(param) self._Hparameter_combo.combo.set_active(ndx) def set_vertical_parameter(self, param): ndx = self.parameters.index(param) self._Vparameter_combo.combo.set_active(ndx) def _cameraSnap_cb(self, widget): "Here I could wrap a camera event..." def snaptime(): snap = CameraSnap() self.activity.cameras_loaded.append(snap) picpath = snap.Snap() self.activity.load_image(picpath) snap.Stop() self._show_active_camera() self.activity._pgc.grab_focus() if self.camera_ready: self._show_busy_camera() thread.start_new_thread(snaptime, ()) else: log.info('Ignoring request to use camera, as camera is currently busy') def _pause_cb(self, widget): self._toggleplay_pause() log.info("Play/Pause Button pressed")
class EntryToolbar(gtk.Toolbar): __gsignals__ = { 'volume-error': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE, ([str, str])), } 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() def set_metadata(self, metadata): self._metadata = metadata self._refresh_copy_palette() self._refresh_duplicate_palette() self._refresh_resume_palette() def _resume_clicked_cb(self, button): misc.resume(self._metadata) def _copy_clicked_cb(self, button): button.palette.popup(immediate=True, state=Palette.SECONDARY) def _duplicate_clicked_cb(self, button): file_path = model.get_file(self._metadata['uid']) try: model.copy(self._metadata, '/') except IOError, e: logging.exception('Error while copying the entry.') self.emit('volume-error', _('Error while copying the entry. %s') % (e.strerror, ), _('Error'))
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 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)
def __init__(self, activity): self._activity = activity GtkSourceview2Editor.__init__(self, activity) #set the default contents for edit,override fixed font size self.font_size = activity.debug_dict.get('font_size', 8) self.find_window = None self.editbar = gtk.Toolbar() self.last_folder = None editopen = ToolButton() editopen.set_stock_id('gtk-new') editopen.set_icon_widget(None) editopen.set_tooltip(_('New File')) editopen.connect('clicked', self._new_file_cb) editopen.add_accelerator('clicked', activity.accelerator, ord('N'), gtk.gdk.CONTROL_MASK, gtk.ACCEL_VISIBLE) #editopen.props.accelerator = '<Ctrl>O' editopen.show() self.editbar.insert(editopen, -1) editfile = ToolButton() editfile.set_stock_id('gtk-open') editfile.set_icon_widget(None) editfile.set_tooltip(_('Open File')) editfile.connect('clicked', self._read_file_cb) editfile.add_accelerator('clicked', activity.accelerator, ord('O'), gtk.gdk.CONTROL_MASK, gtk.ACCEL_VISIBLE) #editfile.props.accelerator = '<Ctrl>O' editfile.show() self.editbar.insert(editfile, -1) editsave = ToolButton() editsave.set_stock_id('gtk-save') editsave.set_icon_widget(None) editsave.set_tooltip(_('Save File')) editsave.add_accelerator('clicked', activity.accelerator, ord('S'), gtk.gdk.CONTROL_MASK, gtk.ACCEL_VISIBLE) #editsave.props.accelerator = '<Ctrl>S' editsave.connect('clicked', self.save_cb) editsave.show() self.editbar.insert(editsave, -1) editsaveas = ToolButton() editsaveas.set_stock_id('gtk-save-as') editsaveas.set_icon_widget(None) editsaveas.set_tooltip(_('Save As')) #editsaveas.props.accelerator = '<Ctrl>S' editsaveas.connect('clicked', self.save_file_cb) editsaveas.show() self.editbar.insert(editsaveas, -1) """ editjournal = ToolButton(tooltip=_('Open Journal')) client = gconf.client_get_default() color = XoColor(client.get_string('/desktop/sugar/user/color')) journal_icon = Icon(icon_name='document-save', xo_color=color) editjournal.set_icon_widget(journal_icon) editjournal.connect('clicked', self._show_journal_object_picker_cb) #editjournal.props.accelerator = '<Ctrl>J' editjournal.show() self.editbar.insert(editjournal, -1) """ separator = gtk.SeparatorToolItem() separator.set_draw(True) separator.show() self.editbar.insert(separator, -1) editundo = ToolButton('undo') editundo.set_tooltip(_('Undo')) editundo.connect('clicked', self.undo) editundo.add_accelerator('clicked', activity.accelerator, ord('Z'), gtk.gdk.CONTROL_MASK, gtk.ACCEL_VISIBLE) #editundo.props.accelerator = '<Ctrl>Z' editundo.show() self.editbar.insert(editundo, -1) editredo = ToolButton('redo') editredo.set_tooltip(_('Redo')) editredo.connect('clicked', self.redo) editredo.add_accelerator('clicked', activity.accelerator, ord('Y'), gtk.gdk.CONTROL_MASK, gtk.ACCEL_VISIBLE) #editredo.props.accelerator = '<Ctrl>Y' editredo.show() self.editbar.insert(editredo, -1) separator = gtk.SeparatorToolItem() separator.set_draw(True) separator.show() self.editbar.insert(separator, -1) editcut = ToolButton() editcut.set_stock_id('gtk-cut') editcut.set_icon_widget(None) editcut.set_tooltip(_('Cut')) self.edit_cut_handler_id = editcut.connect('clicked', self.cut) editcut.add_accelerator('clicked', activity.accelerator, ord('X'), gtk.gdk.CONTROL_MASK, gtk.ACCEL_VISIBLE) #editcut.props.accelerator = '<Ctrl>X' self.editbar.insert(editcut, -1) editcut.show() editcopy = ToolButton('edit-copy') editcopy.set_tooltip(_('Copy')) self.edit_copy_handler_id = editcopy.connect('clicked', self.copy_to_clipboard_cb) editcopy.add_accelerator('clicked', activity.accelerator, ord('C'), gtk.gdk.CONTROL_MASK, gtk.ACCEL_VISIBLE) #editcopy.props.accelerator = '<Ctrl>C' self.editbar.insert(editcopy, -1) editcopy.show() editpaste = ToolButton('edit-paste') editpaste.set_tooltip(_('Paste')) self.edit_paste_handler_id = editpaste.connect('clicked', self.paste) editpaste.add_accelerator('clicked', activity.accelerator, ord('V'), gtk.gdk.CONTROL_MASK, gtk.ACCEL_VISIBLE) #editpaste.props.accelerator = '<Ctrl>V' editpaste.show() self.editbar.insert(editpaste, -1) """ separator = gtk.SeparatorToolItem() separator.set_draw(True) separator.show() self.editbar.insert(separator, -1) """ editfind = ToolButton('viewmag1') editfind.set_tooltip(_('Find and Replace')) editfind.connect('clicked', self.show_find) editfind.add_accelerator('clicked', activity.accelerator, ord('F'), gtk.gdk.CONTROL_MASK, gtk.ACCEL_VISIBLE) #editfind.props.accelerator = '<Ctrl>F' editfind.show() self.editbar.insert(editfind, -1) """ separator = gtk.SeparatorToolItem() separator.set_draw(True) separator.show() self.editbar.insert(separator, -1) """ self.zoomout = ToolButton('zoom-out') self.zoomout.set_tooltip(_('Zoom out')) self.zoomout.connect('clicked', self.__zoomout_clicked_cb) self.editbar.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.editbar.insert(self.zoomin, -1) self.zoomin.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.editbar.insert(stop_button, -1) stop_button.show() self.editbar.show_all()
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()
def initialize_display(self): self._logger = logging.getLogger('butialo-activity') # Top toolbar with share and close buttons: if OLD_TOOLBAR: activity_toolbar = self.toolbox.get_activity_toolbar() else: activity_toolbar = self.activity_button.page # add 'make bundle' entry to 'keep' palette. palette = activity_toolbar.keep.get_palette() # XXX: should clear out old palette entries? from sugar.graphics.menuitem import MenuItem from sugar.graphics.icon import Icon menu_item = MenuItem(_('As Butialo Document')) menu_item.set_image(Icon(file=('%s/activity/activity-icon.svg' % get_bundle_path()), icon_size=gtk.ICON_SIZE_MENU)) menu_item.connect('activate', self.keepbutton_cb) palette.menu.append(menu_item) menu_item.show() #xop guardar como bundle #menu_item = MenuItem(_('As Activity Bundle')) #menu_item.set_image(Icon(file=('%s/activity/activity-default.svg' % # get_bundle_path()), # icon_size=gtk.ICON_SIZE_MENU)) #menu_item.connect('activate', self.makebutton_cb) #palette.menu.append(menu_item) #menu_item.show() self._edit_toolbar = activity.EditToolbar() if OLD_TOOLBAR: activity_toolbar = gtk.Toolbar() self.toolbox.add_toolbar(_('Actions'), activity_toolbar) self.toolbox.set_current_toolbar(1) self.toolbox.add_toolbar(_('Edit'), self._edit_toolbar) else: edit_toolbar_button = ToolbarButton() edit_toolbar_button.set_page(self._edit_toolbar) edit_toolbar_button.props.icon_name = 'toolbar-edit' edit_toolbar_button.props.label = _('Edit') self.get_toolbar_box().toolbar.insert(edit_toolbar_button, -1) self._edit_toolbar.show() self._edit_toolbar.undo.connect('clicked', self.__undobutton_cb) self._edit_toolbar.redo.connect('clicked', self.__redobutton_cb) self._edit_toolbar.copy.connect('clicked', self.__copybutton_cb) self._edit_toolbar.paste.connect('clicked', self.__pastebutton_cb) if OLD_TOOLBAR: actions_toolbar = activity_toolbar else: actions_toolbar = self.get_toolbar_box().toolbar # The "go" button goicon_bw = gtk.Image() goicon_bw.set_from_file("%s/icons/run_bw.svg" % os.getcwd()) goicon_color = gtk.Image() goicon_color.set_from_file("%s/icons/run_color.svg" % os.getcwd()) gobutton = ToolButton(label=_("_Run!")) gobutton.props.accelerator = _('<alt>r') gobutton.set_icon_widget(goicon_bw) gobutton.set_tooltip("Run") gobutton.connect('clicked', self.flash_cb, dict({'bw': goicon_bw, 'color': goicon_color})) gobutton.connect('clicked', self.gobutton_cb) actions_toolbar.insert(gobutton, -1) # The "stop" button stopicon_bw = gtk.Image() stopicon_bw.set_from_file("%s/icons/stopit_bw.svg" % os.getcwd()) stopicon_color = gtk.Image() stopicon_color.set_from_file("%s/icons/stopit_color.svg" % os.getcwd()) stopbutton = ToolButton(label=_("_Stop")) stopbutton.props.accelerator = _('<alt>s') stopbutton.set_icon_widget(stopicon_bw) stopbutton.connect('clicked', self.flash_cb, dict({'bw': stopicon_bw, 'color': stopicon_color})) stopbutton.connect('clicked', self.stopbutton_cb) stopbutton.set_tooltip("Stop Running") actions_toolbar.insert(stopbutton, -1) # The "refresh" button refreshicon_bw = gtk.Image() refreshicon_bw.set_from_file("%s/icons/butiaoff.svg" % os.getcwd()) refreshicon_color = gtk.Image() refreshicon_color.set_from_file("%s/icons/butiaon.svg" % os.getcwd()) refreshbutton = ToolButton(label=_("_Reload")) refreshbutton.props.accelerator = _('<alt>d') refreshbutton.set_icon_widget(refreshicon_bw) refreshbutton.connect('clicked', self.flash_cb, dict({'bw': refreshicon_bw, 'color': refreshicon_color})) refreshbutton.connect('clicked', self.initialize_snippets_cb) refreshbutton.set_tooltip("Reload devices") actions_toolbar.insert(refreshbutton, -1) # The "clear" button #clearicon_bw = gtk.Image() #clearicon_bw.set_from_file("%s/icons/eraser_bw.svg" % os.getcwd()) #clearicon_color = gtk.Image() #clearicon_color.set_from_file("%s/icons/eraser_color.svg" % # os.getcwd()) #clearbutton = ToolButton(label=_("_Clear")) #clearbutton.props.accelerator = _('<alt>c') #clearbutton.set_icon_widget(clearicon_bw) #clearbutton.connect('clicked', self.clearbutton_cb) #clearbutton.connect('clicked', self.flash_cb, dict({'bw': clearicon_bw, # 'color': clearicon_color})) #clearbutton.set_tooltip("Clear") #actions_toolbar.insert(clearbutton, -1) # The "beautify" button beautifyicon_bw = gtk.Image() beautifyicon_bw.set_from_file("%s/icons/beautifyicon_bw.svg" % os.getcwd()) beautifyicon_color = gtk.Image() beautifyicon_color.set_from_file("%s/icons/beautifyicon_color.svg" % os.getcwd()) beautifybutton = ToolButton(label=_("_Auto-format")) beautifybutton.props.accelerator = _('<alt>f') beautifybutton.set_icon_widget(beautifyicon_bw) beautifybutton.connect('clicked', self.beautifybutton_cb) beautifybutton.connect('clicked', self.flash_cb, dict({'bw': beautifyicon_bw, 'color': beautifyicon_color})) beautifybutton.set_tooltip("Auto-format") actions_toolbar.insert(beautifybutton, -1) activity_toolbar.show() if not OLD_TOOLBAR: separator = gtk.SeparatorToolItem() separator.props.draw = False separator.set_expand(True) self.get_toolbar_box().toolbar.insert(separator, -1) separator.show() stop = StopButton(self) self.get_toolbar_box().toolbar.insert(stop, -1) # Main layout. self.hpane = gtk.HPaned() self.vpane = gtk.VPaned() # The sidebar. self.sidebar = gtk.VBox() self.model = gtk.TreeStore(gobject.TYPE_PYOBJECT, gobject.TYPE_STRING) treeview = gtk.TreeView(self.model) cellrenderer = gtk.CellRendererText() treecolumn = gtk.TreeViewColumn(_("Available"), cellrenderer, text=1) treeview.get_selection().connect("changed", self.selection_cb) treeview.append_column(treecolumn) treeview.set_size_request(int(SIZE_X * 0.3), SIZE_Y) # Create scrollbars around the view. scrolled = gtk.ScrolledWindow() scrolled.add(treeview) self.sidebar.pack_start(scrolled) self.hpane.add1(self.sidebar) #root = os.path.join(get_bundle_path(), 'data') #initialize snippets self.initialize_snippets_cb(None) # Source buffer import gtksourceview2 global text_buffer lang_manager = gtksourceview2.language_manager_get_default() if hasattr(lang_manager, 'list_languages'): langs = lang_manager.list_languages() else: lang_ids = lang_manager.get_language_ids() langs = [lang_manager.get_language(lang_id) for lang_id in lang_ids] for lang in langs: for m in lang.get_mime_types(): if m == "text/x-lua": text_buffer.set_language(lang) if hasattr(text_buffer, 'set_highlight'): text_buffer.set_highlight(True) else: text_buffer.set_highlight_syntax(True) # The GTK source view window self.text_view = gtksourceview2.View(text_buffer) self.text_view.set_size_request(0, int(SIZE_Y * 0.5)) self.text_view.set_editable(True) self.text_view.set_cursor_visible(True) self.text_view.set_show_line_numbers(True) self.text_view.set_wrap_mode(gtk.WRAP_CHAR) self.text_view.set_insert_spaces_instead_of_tabs(True) self.text_view.set_tab_width(2) self.text_view.set_auto_indent(True) self.text_view.modify_font(pango.FontDescription("Monospace " + str(font_zoom(style.FONT_SIZE)))) # We could change the color theme here, if we want to. #mgr = gtksourceview2.style_manager_get_default() #style_scheme = mgr.get_scheme('kate') #self.text_buffer.set_style_scheme(style_scheme) codesw = gtk.ScrolledWindow() codesw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC) codesw.add(self.text_view) self.vpane.add1(codesw) # An hbox to hold the vte window and its scrollbar. outbox = gtk.HBox() # The vte python window self._vte = vte.Terminal() self._vte.set_encoding('utf-8') self._vte.set_size(30, 5) font = 'Monospace ' + str(font_zoom(style.FONT_SIZE)) self._vte.set_font(pango.FontDescription(font)) self._vte.set_colors(gtk.gdk.color_parse('#000000'), gtk.gdk.color_parse('#E7E7E7'), []) self._vte.connect('child_exited', self.child_exited_cb) self._child_exited_handler = None self._vte.drag_dest_set(gtk.DEST_DEFAULT_ALL, [("text/plain", 0, TARGET_TYPE_TEXT)], gtk.gdk.ACTION_COPY) self._vte.connect('drag_data_received', self.vte_drop_cb) outbox.pack_start(self._vte) outsb = gtk.VScrollbar(self._vte.get_adjustment()) outsb.show() outbox.pack_start(outsb, False, False, 0) self.vpane.add2(outbox) self.hpane.add2(self.vpane) return self.hpane
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 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 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)
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()