def build_toolbar(self): # Create the toolbar box toolbar_box = ToolbarBox() self.set_toolbar_box(toolbar_box) toolbar_box.show() # Create the activity button activity_button = ActivityToolbarButton(self) toolbar_box.toolbar.insert(activity_button, -1) activity_button.show() # Create the 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) # Create a blank separator and a Stop button 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 add_button(icon_name, tooltip, func): def callback(source): func() button = ToolButton(icon_name) toolbar.add(button) button.connect('clicked', callback) button.set_tooltip(tooltip)
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() separator = Gtk.SeparatorToolItem() separator.props.draw = False separator.set_expand(False) toolbar_box.toolbar.insert(separator, -1) separator.show() button = ToolButton('speaker-muted-100') button.set_tooltip(_('Sound')) button.connect('clicked', self.sound_control) toolbar_box.toolbar.insert(button, -1) 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()
def __init__(self, child, label, path, tabs): GObject.GObject.__init__(self) self.child = child self.label_text = label self._path = path # Hide the path in the label self.tabs = tabs self.label_box = Gtk.EventBox() self._label = Gtk.Label(label=self.label_text) self._label.set_alignment(0, 0.5) self._label.show() self.label_box.add(self._label) self.label_box.connect('button-press-event', self._label_clicked) self.label_box.show_all() self.pack_start(self.label_box, True, True, 5) self.label_entry = Gtk.Entry() self.label_entry.connect('activate', self._label_entry_cb) self.label_entry.connect('focus-out-event', self._label_entry_cb) self.pack_start(self.label_entry, True, True, 0) button = ToolButton('close-tab') button.connect('clicked', self.__button_clicked_cb) self.pack_start(button, False, True, 0) button.show() self._close_button = button tab_object.append(self)
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()
def __init__(self, calc): Gtk.Toolbar.__init__(self) copy_tool = ToolButton('edit-copy') copy_tool.set_tooltip(_('Copy')) copy_tool.set_accelerator(_('<ctrl>c')) copy_tool.connect('clicked', lambda x: calc.text_copy()) self.insert(copy_tool, -1) menu_item = MenuItem(_('Cut')) try: menu_item.set_accelerator(_('<ctrl>x')) except AttributeError: pass menu_item.connect('activate', lambda x: calc.text_cut()) menu_item.show() copy_tool.get_palette().menu.append(menu_item) self.insert(IconToolButton('edit-paste', _('Paste'), lambda x: calc.text_paste(), alt_html='Paste'), -1) self.show_all()
def __init__(self, comicbox): BaseWindow.__init__(self) self.toolbar = BasicToolbar('contract-coordinates') self.toolbar.stop.connect('clicked', self.__stop_clicked_cb) self.toolbar.confirm.connect('clicked', self.__ok_clicked_cb) reset_size = ToolButton(icon_name='box-size') reset_size.set_tooltip(_('Reset to box size')) self.toolbar.insert(reset_size, 3) reset_size.show() reset_size.connect('clicked', self.__reset_size_cb) self.comicbox = comicbox self.canvas = CanvasEditor( self.comicbox, self.comicbox.width, self.comicbox.height, self) label = Gtk.Label('') title = _('Drag to move or resize using the marked corners') label.set_markup('<span size="x-large">%s</span>' % title) self.vbox = Gtk.VBox() self.vbox.pack_start(self.toolbar, False, False, 0) self.vbox.pack_start(label, False, False, style.DEFAULT_SPACING) self.vbox.pack_start(self.canvas, True, True, 0) self.add(self.vbox) self.modify_bg(Gtk.StateType.NORMAL, style.COLOR_WHITE.get_gdk_color())
def makeToolbar(self, activity): self.activity = activity toolbar = ToolbarBox() activity_button = ActivityToolbarButton(activity) toolbar.toolbar.insert(activity_button, -1) activity_button.show() editmode = ToolButton('edit-description') editmode.set_tooltip(_("Enter Edit Mode")) editmode.set_accelerator(_('<ctrl>e')) editmode.connect('clicked', self.gotoCoding) toolbar.toolbar.insert(editmode, -1) editmode.show() separator = Gtk.SeparatorToolItem() separator.props.draw = False separator.set_expand(True) toolbar.toolbar.insert(separator, -1) separator.show() stop_button = StopButton(activity) toolbar.toolbar.insert(stop_button, -1) stop_button.show() return toolbar
def __init__(self, **kwargs): Gtk.ToolItem.__init__(self) help_button = ToolButton('toolbar-help') help_button.set_tooltip(_('Ayuda / ÑepYsyrõ')) self.add(help_button) self._palette = help_button.get_palette() sw = Gtk.ScrolledWindow() sw.set_size_request(int(Gdk.Screen.width() / 2.8), 100) sw.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC) self._max_text_width = int(Gdk.Screen.width() / 3) - 600 self._vbox = Gtk.Box() self._vbox.set_orientation(Gtk.Orientation.VERTICAL) self._vbox.set_homogeneous(False) self._vbox.set_border_width(10) hbox = Gtk.Box() hbox.pack_start(self._vbox, False, True, 0) sw.add_with_viewport(hbox) self._palette.set_content(sw) sw.show_all() help_button.connect('clicked', self.__help_button_clicked_cb)
class ViewToolbar(Gtk.Toolbar): __gtype_name__ = 'ViewToolbar' __gsignals__ = { 'go-fullscreen': (GObject.SignalFlags.RUN_FIRST, None, ([])), 'toggle-playlist': (GObject.SignalFlags.RUN_FIRST, None, ([])) } def __init__(self): Gtk.Toolbar.__init__(self) self._show_playlist = ToggleToolButton('view-list') self._show_playlist.set_active(True) # due to Activity.show_all() self._show_playlist.set_tooltip(_('Playlist')) self._show_playlist.set_accelerator('<ctrl>l') self._show_playlist.connect('toggled', self._playlist_toggled_cb) self.insert(self._show_playlist, -1) self._show_playlist.show() self._fullscreen = ToolButton('view-fullscreen') self._fullscreen.set_tooltip(_('Fullscreen')) self._fullscreen.set_accelerator('<ctrl>f') 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 _playlist_toggled_cb(self, button): self.emit('toggle-playlist')
def build_toolbar(self): toolbox = ToolbarBox() toolbar = toolbox.toolbar label = Gtk.Label(_('Open an example bundle')) label.modify_fg(Gtk.StateType.NORMAL, Gdk.color_parse('white')) item = Gtk.ToolItem() item.add(label) close = ToolButton('entry-cancel') close.connect('clicked', self._destroy) separator = Gtk.SeparatorToolItem() separator.props.draw = False separator.set_expand(True) toolbar.insert(item, -1) toolbar.insert(separator, -1) toolbar.insert(close, -1) toolbox.set_size_request(-1, 35) return toolbox
class WebToolbar(Gtk.Toolbar): def __init__(self,browser): 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): if self._browser.can_go_forward(): self._browser.go_forward() def _go_back_cb(self, button): if self._browser.can_go_back(): self._browser.go_back()
def make_toolbar(self): def make_separator(expand=False): separator = Gtk.SeparatorToolItem() if expand: separator.set_expand(True) separator.props.draw = False return separator toolbar_box = ToolbarBox() self.set_toolbar_box(toolbar_box) toolbar = toolbar_box.toolbar activity_button = ActivityToolbarButton(self) toolbar.insert(activity_button, -1) toolbar.insert(make_separator(), -1) button_add = ToolButton(Gtk.STOCK_ADD) button_add.set_tooltip(_("Add a channel")) button_add.connect("clicked", self._add_channel) toolbar.insert(button_add, -1) toolbar.insert(make_separator(True), -1) stop_button = ToolButton("activity-stop") stop_button.connect("clicked", self._exit) stop_button.props.accelerator = "<Ctrl>Q" toolbar.insert(stop_button, -1)
class MainToolbar(Gtk.Toolbar): """ Main toolbar of the control panel """ __gtype_name__ = 'MainToolbar' __gsignals__ = { 'stop-clicked': (GObject.SignalFlags.RUN_FIRST, None, ([])), 'search-changed': (GObject.SignalFlags.RUN_FIRST, 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, 'entry-search') self._search_entry.add_clear_button() self._search_entry.set_width_chars(25) text = _('Search in %s') % _('Settings') self._search_entry.set_placeholder_text(text) 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')
def __init__(self, **kwargs): GObject.GObject.__init__(self) help_button = ToolButton('toolbar-help') help_button.set_tooltip(_('Help')) self.add(help_button) self._palette = help_button.get_palette() sw = Gtk.ScrolledWindow() sw.set_size_request(int(Gdk.Screen.width() / 2.8), Gdk.Screen.height() - style.GRID_CELL_SIZE * 3) sw.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC) self._max_text_width = int(Gdk.Screen.width() / 3) - 600 self._vbox = Gtk.Box() self._vbox.set_orientation(Gtk.Orientation.VERTICAL) self._vbox.set_homogeneous(False) sw.add_with_viewport(self._vbox) self._palette.set_content(sw) sw.show_all() help_button.connect('clicked', self.__help_button_clicked_cb)
def __init__(self, activity_name, has_local_help): Gtk.Toolbar.__init__(self) self._add_separator(False) if has_local_help and get_social_help_server(): help_button = RadioToolButton() icon = Icon(icon_name='toolbar-help', pixel_size=style.STANDARD_ICON_SIZE, fill_color=style.COLOR_TRANSPARENT.get_svg(), stroke_color=style.COLOR_WHITE.get_svg()) help_button.set_icon_widget(icon) icon.show() help_button.props.tooltip = _('Help Manual') help_button.connect('toggled', self.__button_toggled_cb, _MODE_HELP) self.insert(help_button, -1) help_button.show() self._add_separator(False) social_help_button = RadioToolButton() icon = Icon(icon_name='toolbar-social-help', pixel_size=style.STANDARD_ICON_SIZE, fill_color=style.COLOR_TRANSPARENT.get_svg(), stroke_color=style.COLOR_WHITE.get_svg()) social_help_button.set_icon_widget(icon) icon.show() social_help_button.props.tooltip = _('Social Help') social_help_button.props.group = help_button social_help_button.connect( 'toggled', self.__button_toggled_cb, _MODE_SOCIAL_HELP) self.insert(social_help_button, -1) social_help_button.show() self._add_separator(False) self._back_button = ToolButton(icon_name='go-previous-paired') self._back_button.props.tooltip = _('Back') self._back_button.connect('clicked', self.__back_clicked_cb) self.insert(self._back_button, -1) self._back_button.show() self._forward_button = ToolButton(icon_name='go-next-paired') self._forward_button.props.tooltip = _('Forward') self._forward_button.connect('clicked', self.__forward_clicked_cb) self.insert(self._forward_button, -1) self._forward_button.show() title = _('Help: %s') % activity_name self._label = Gtk.Label() self._label.set_markup('<b>%s</b>' % title) self._label.set_alignment(0, 0.5) self._add_widget(self._label) self._add_separator(True) stop = ToolButton(icon_name='dialog-cancel') stop.set_tooltip(_('Close')) stop.connect('clicked', self.__stop_clicked_cb) self.insert(stop, -1) stop.show()
def __init__(self, handle): activity.Activity.__init__(self, handle) self.props.max_participants = 1 self._web_view = WebKit.WebView() toolbox = ToolbarBox() self.set_toolbar_box(toolbox) toolbox.show() toolbar = toolbox.toolbar toolbar.show() activity_button = ActivityButton(self) toolbar.insert(activity_button, -1) viewtoolbar = ViewToolbar(self) viewtoolbar_button = ToolbarButton( page=viewtoolbar, icon_name='toolbar-view') toolbar.insert(viewtoolbar_button, -1) toolbar.show_all() self._back = ToolButton('go-previous-paired') self._back.set_tooltip(_('Back')) self._back.props.sensitive = False self._back.connect('clicked', self._go_back_cb) toolbar.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) toolbar.insert(self._forward, -1) self._forward.show() home = ToolButton('go-home') home.set_tooltip(_('Home')) home.connect('clicked', self._go_home_cb) toolbar.insert(home, -1) home.show() separator = Gtk.SeparatorToolItem() separator.props.draw = False separator.set_expand(True) toolbar.insert(separator, -1) stopbtn = StopButton(self) toolbar.insert(stopbtn, -1) toolbar.show_all() self._web_view.connect('load-finished', self.update_navigation_buttons) self.set_canvas(self._web_view) self._web_view.show() self._web_view.load_uri(HOME)
class BooksToolbar(Gtk.Toolbar): __gtype_name__ = 'BooksToolbar' def __init__(self): Gtk.Toolbar.__init__(self) book_search_item = Gtk.ToolItem() self.search_entry = Gtk.Entry() self.search_entry.connect('activate', self.search_entry_activate_cb) self.search_entry.connect("key_press_event", self.keypress_cb) width = int(Gdk.Screen.width() / 2) self.search_entry.set_size_request(width, -1) book_search_item.add(self.search_entry) self.search_entry.show() self.search_entry.grab_focus() self.insert(book_search_item, -1) book_search_item.show() self.download = ToolButton('go-down') self.download.set_tooltip(_('Get Book')) self.download.props.sensitive = False self.download.connect('clicked', self.get_book_cb) self.insert(self.download, -1) self.download.show() self.hide_results = ToolButton('dialog-cancel') self.hide_results.set_tooltip(_('Remove Results List')) self.hide_results.props.sensitive = False self.hide_results.connect('clicked', self.hide_results_cb) self.insert(self.hide_results, -1) self.hide_results.show() def set_activity(self, activity): self.activity = activity def search_entry_activate_cb(self, entry): self.activity.find_books(entry.props.text) self.hide_results.props.sensitive = True def get_book_cb(self, button): self.activity.get_book() def enable_button(self, state): self.download.props.sensitive = state def hide_results_cb(self, button): self.activity.list_scroller.hide() self.hide_results.props.sensitive = False def keypress_cb(self, widget, event): keyname = Gdk.keyval_name(event.keyval) if keyname == 'Escape': self.activity.list_scroller.hide() self.hide_results.props.sensitive = False return True
def make_toolbar(self): # toolbar with the new toolbar redesign toolbar_box = ToolbarBox() activity_button = ActivityToolbarButton(self) toolbar_box.toolbar.insert(activity_button, 0) activity_button.show() toolbarview = Gtk.Toolbar() langtoolbar_button = ToolbarButton( label=_('View'), page=toolbarview, icon_name='settings') langtoolbar_button.show() toolbar_box.toolbar.insert(langtoolbar_button, -1) tool = ToolButton('en') tool.set_tooltip(_('English')) tool.connect('clicked', self.language_en) tool.show() toolbarview.insert(tool, -1) tool = ToolButton('es') tool.set_tooltip(_('Spanish')) tool.connect('clicked', self.language_es) tool.show() toolbarview.insert(tool, -1) tool = ToolButton('fr') tool.set_tooltip(_('French')) tool.connect('clicked', self.language_fr) tool.show() toolbarview.insert(tool, -1) tool = ToolButton('remote') tool.set_tooltip(_('Server settings')) tool.connect('clicked', self.settings) tool.show() toolbarview.insert(tool, -1) toolbarview.show() favorite_button = ToolButton(self.favorite_status) favorite_button.set_tooltip('Filter on favorite') favorite_button.connect('clicked', self.favorite) toolbar_box.toolbar.insert(favorite_button, -1) favorite_button.show() self.favorite_button = favorite_button 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.set_toolbar_box(toolbar_box) toolbar_box.show()
class BooksToolbar(Gtk.Toolbar): __gtype_name__ = 'BooksToolbar' def __init__(self): Gtk.Toolbar.__init__(self) book_search_item = Gtk.ToolItem() self.search_entry = Gtk.Entry() self.search_entry.connect('activate', self.search_entry_activate_cb) width = int(Gdk.Screen.width() / 2) self.search_entry.set_size_request(width, -1) book_search_item.add(self.search_entry) self.search_entry.show() self.insert(book_search_item, -1) book_search_item.show() self._download = ToolButton('go-down') self._download.set_tooltip(_('Get Book')) self._download.props.sensitive = False self._download.connect('clicked', self._get_book_cb) self.insert(self._download, -1) self._download.show() self.format_combo = ComboBox() self.format_combo.connect('changed', self.format_changed_cb) self.format_combo.append_item('.djvu', 'Deja Vu') self.format_combo.append_item('_bw.pdf', 'B/W PDF') self.format_combo.append_item('.pdf', 'Color PDF') self.format_combo.append_item('.epub', 'EPUB') self.format_combo.set_active(0) self.format_combo.props.sensitive = False combotool = ToolComboBox(self.format_combo) self.insert(combotool, -1) combotool.show() self.search_entry.grab_focus() def set_activity(self, activity): self.activity = activity def format_changed_cb(self, combo): if self.activity != None: self.activity.show_book_data() def search_entry_activate_cb(self, entry): self.activity.find_books(entry.props.text) def _get_book_cb(self, button): self.activity.get_book() def enable_button(self, state): self._download.props.sensitive = state self.format_combo.props.sensitive = state
class EditToolbar(SugarEditToolbar): def __init__(self, _parent): SugarEditToolbar.__init__(self) self._parent = _parent self.undo.connect('clicked', self.__undo_cb) self.redo.connect('clicked', self.__redo_cb) self.copy.connect('clicked', self.__copy_cb) self.paste.connect('clicked', self.__paste_cb) menu_item = MenuItem(_('Cut')) menu_item.connect('activate', self.__cut_cb) menu_item.show() self.copy.get_palette().menu.append(menu_item) self.insert(Gtk.SeparatorToolItem(), -1) self.erase_button = ToolButton('edit-delete') self.erase_button.set_tooltip(_('Erase selected thought(s)')) self.erase_button.connect('clicked', self.__delete_cb) self.insert(self.erase_button, -1) self.show_all() self.clipboard = Gtk.Clipboard() self.copy.set_sensitive(False) self.paste.set_sensitive(False) self.erase_button.set_sensitive(False) def __undo_cb(self, button): self._parent._undo.undo_action(None) def __redo_cb(self, button): self._parent._undo.redo_action(None) def __cut_cb(self, event): self._parent._main_area.cut_clipboard(self.clipboard) def __copy_cb(self, event): self._parent._main_area.copy_clipboard(self.clipboard) def __paste_cb(self, event): self._parent._main_area.paste_clipboard(self.clipboard) def __delete_cb(self, widget): self._stop_moving() self.stop_dragging() self._parent._main_area.delete_selected_elements() def stop_dragging(self): if self._parent._main_area.is_dragging(): self._parent._main_area.drag_menu_cb(self._sw, False) def _stop_moving(self): self._parent._main_area.move_mode = False
def __init__(self, game, editor_index): Gtk.EventBox.__init__(self) self._game = game self.snd = None self.editor_index = editor_index self.temp_folder = None box = Gtk.Grid() box.set_column_spacing(style.DEFAULT_SPACING) box.set_row_spacing(style.DEFAULT_SPACING) box.props.margin = style.DEFAULT_SPACING self.card = svgcard.SvgCard( -1, {'front_text': {'card_text': '', 'text_color': style.Color('#ffffff')}}, None, PAIR_SIZE, '#c0c0c0') self.card.flip() card_align = Gtk.Alignment.new(.5, .5, 0, 0) card_align.add(self.card) box.attach(card_align, 0, 0, 1, 1) self.textentry = Gtk.Entry() self.textentry.connect('changed', self.update_text) self.textentry.set_valign(Gtk.Align.START) box.attach(self.textentry, 0, 1, 1, 1) toolbar = Gtk.VBox() toolbar.set_valign(Gtk.Align.CENTER) browsepicture = ToolButton(icon_name='import_picture', tooltip=_('Insert picture')) toolbar.add(browsepicture) browsesound = ToolButton(icon_name='import_sound', tooltip=_('Insert sound')) toolbar.add(browsesound) browsepicture.connect('clicked', self._load_image) browsesound.connect('clicked', self._load_audio) if speak.espeak.supported: self.usespeak = ToggleToolButton(icon_name='speak') self.usespeak.set_palette(SpeakPalette(self)) toolbar.add(self.usespeak) self.usespeak.connect('toggled', self._usespeak_cb) else: self.usespeak = None self.fontbutton = FontButton() toolbar.add(self.fontbutton) self.id_font_changed = self.fontbutton.connect( 'changed', self.__font_changed_cb) box.attach(toolbar, 1, 0, 1, 2) self.add(box)
def __init__(self, activity, abi): toolbar = activity.activity_button.props.page for i in self._EXPORT_FORMATS: if abi.get_version() == '3.0' and i['title'].find('PDF') > -1: # pdf export crashes on abiword 3.0 continue button = ToolButton(i['icon']) button.set_tooltip(i['title']) button.connect('clicked', self.__clicked_cb, activity, abi, i) toolbar.insert(button, -1) button.show()
def build_toolbar(self): self.max_participants = 1 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() # toolbars self.build_size_toolbar(toolbar_box) self.build_colors_toolbar(toolbar_box) # new game button new_game = ToolButton('new-game') new_game.connect('clicked', self._new_game) new_game.set_tooltip(_('New game')) toolbar_box.toolbar.insert(new_game, -1) separator = Gtk.SeparatorToolItem() toolbar_box.toolbar.insert(separator, -1) separator.show() #current item = Gtk.ToolItem() label = Gtk.Label() label.set_text(' %s ' % _('Current player:')) item.add(label) toolbar_box.toolbar.insert(item, -1) #player item = Gtk.ToolItem() self.current_label = Gtk.Label() self.current_label.set_text(' %s ' % _('Player 1')) item.add(self.current_label) toolbar_box.toolbar.insert(item, -1) # end separator 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()
def __init__(self, parent_xid, dialog_title): Gtk.Window.__init__(self) self.connect('realize', self.__realize_cb) self.set_decorated(False) self.set_position(Gtk.WindowPosition.CENTER_ALWAYS) self.set_border_width(style.LINE_WIDTH) self.set_resizable(False) width = Gdk.Screen.width() - style.GRID_CELL_SIZE * 4 height = Gdk.Screen.height() - style.GRID_CELL_SIZE * 4 self.set_size_request(width, height) self._parent_window_xid = parent_xid _vbox = Gtk.VBox(spacing=2) self.add(_vbox) self.toolbar = Gtk.Toolbar() label = Gtk.Label() label.set_markup('<b> %s</b>' % dialog_title) label.set_alignment(0, 0.5) tool_item = Gtk.ToolItem() tool_item.add(label) label.show() self.toolbar.insert(tool_item, -1) tool_item.show() separator = Gtk.SeparatorToolItem() separator.props.draw = False separator.set_expand(True) self.toolbar.insert(separator, -1) separator.show() stop = ToolButton(icon_name='dialog-cancel') stop.set_tooltip(_('Cancel')) stop.connect('clicked', self.cancel_clicked_cb) self.toolbar.insert(stop, -1) stop.show() accept = ToolButton(icon_name='dialog-ok') accept.set_tooltip(_('Ok')) accept.connect('clicked', self.accept_clicked_cb) accept.show() self.toolbar.insert(accept, -1) _vbox.pack_start(self.toolbar, False, True, 0) self.toolbar.show() self._event_box = Gtk.EventBox() _vbox.pack_start(self._event_box, True, True, 0) self._canvas = None
def make_toolbar(self): # toolbar with the new toolbar redesign toolbar_box = ToolbarBox() activity_button = ActivityToolbarButton(self) toolbar_box.toolbar.insert(activity_button, 0) activity_button.show() self.toolbarview = Gtk.Toolbar() langtoolbar_button = ToolbarButton( label=_('Filter'), page=self.toolbarview, icon_name='filter') langtoolbar_button.show() toolbar_box.toolbar.insert(langtoolbar_button, -1) self.toolbarview.show() box_search_item = Gtk.ToolItem() self.search_entry = Gtk.Entry() self.search_entry.connect('changed', self.text_filter) self.search_entry.set_size_request(300, -1) box_search_item.add(self.search_entry) self.search_entry.show() box_search_item.show() toolbar_box.toolbar.insert(box_search_item, -1) favorite_button = ToolButton(self.favorite_status) favorite_button.set_tooltip('Filter on favorite') favorite_button.connect('clicked', self.favorite) toolbar_box.toolbar.insert(favorite_button, -1) favorite_button.show() self.favorite_button = favorite_button library_button = ToolButton('library') library_button.set_tooltip('Show libraries') library_button.connect('clicked', self.library_clicked) toolbar_box.toolbar.insert(library_button, -1) library_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) toolbar_box.toolbar.insert(stop_button, -1) stop_button.show() self.set_toolbar_box(toolbar_box) toolbar_box.show()
def __init__(self, main_area): Gtk.Toolbar.__init__(self) self._main_area = main_area tool = ToolButton('zoom-best-fit') tool.set_tooltip(_('Fit to window')) tool.set_accelerator(_('<ctrl>9')) tool.connect('clicked', self.__zoom_tofit_cb) self.insert(tool, -1) tool = ToolButton('zoom-original') tool.set_tooltip(_('Original size')) tool.set_accelerator(_('<ctrl>0')) tool.connect('clicked', self.__zoom_original_cb) self.insert(tool, -1) tool = ToolButton('zoom-out') tool.set_tooltip(_('Zoom out')) tool.set_accelerator(_('<ctrl>minus')) tool.connect('clicked', self.__zoom_out_cb) self.insert(tool, -1) tool = ToolButton('zoom-in') tool.set_tooltip(_('Zoom in')) tool.set_accelerator(_('<ctrl>equal')) tool.connect('clicked', self.__zoom_in_cb) self.insert(tool, -1) self.show_all()
def makeDelToolbar(self, activity): toolbar = self.makeGenericToolbar(activity) separator = Gtk.SeparatorToolItem() toolbar.toolbar.insert(separator, 5) separator.show() btn = ToolButton('block-delete') btn.set_tooltip(_('Delete Selected Block')) toolbar.toolbar.insert(btn, 6) btn.connect('clicked', self.menuRemove) btn.show() return toolbar
def add_button(self, button_label, callback, arg=None, button_icon=None): if button_icon is not None: button = ToolButton(button_icon) else: button = Gtk.Button() button.set_label(button_label) self._attach_center(button) if callback is not None: if arg is None: button.connect('clicked', callback) else: button.connect('clicked', callback, arg) button.show() return button
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)
def __init__(self, handle): super(PeterActivity, self).__init__(handle) # Get user's Sugar colors sugarcolors = profile.get_color().to_string().split(',') colors = [[ int(sugarcolors[0][1:3], 16), int(sugarcolors[0][3:5], 16), int(sugarcolors[0][5:7], 16) ], [ int(sugarcolors[1][1:3], 16), int(sugarcolors[1][3:5], 16), int(sugarcolors[1][5:7], 16) ]] # No sharing self.max_participants = 1 # Build the activity toolbar. toolbox = ToolbarBox() activity_button = ActivityToolbarButton(self) toolbox.toolbar.insert(activity_button, 0) activity_button.show() self._add_speed_slider(toolbox.toolbar) green = ToolButton('green') toolbox.toolbar.insert(green, -1) green.set_tooltip(_('Start')) green.connect('clicked', self._button_cb, 'green') green.show() back = ToolButton('back') toolbox.toolbar.insert(back, -1) back.set_tooltip(_('Repeat')) back.connect('clicked', self._button_cb, 'back') back.show() separator = Gtk.SeparatorToolItem() separator.props.draw = False separator.set_expand(True) toolbox.toolbar.insert(separator, -1) separator.show() stop = StopButton(self) toolbox.toolbar.insert(stop, -1) stop.show() toolbox.show() self.set_toolbar_box(toolbox) # Create the game instance. self.game = FollowMe.FollowMe(colors, sugar=True) # Build the Pygame canvas. self.game.canvas =\ sugargame.canvas.PygameCanvas(self, main=self.game.run, modules=[pygame.display, pygame.font]) # Note that set_canvas implicitly calls # read_file when resuming from the Journal. self.set_canvas(self.game.canvas) Gdk.Screen.get_default().connect('size-changed', self.__configure_cb) self.game.set_buttons(green, back)
def __init__(self, handle): activity.Activity.__init__(self, handle, True) self.basePath = activity.get_bundle_path() scroll = Gtk.ScrolledWindow() scroll.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.NEVER) #get container self.canvasHolder = TabbedCanvas() self.canvasHolder.basePath = self.basePath #add tabControl to scrolled window scroll.add_with_viewport(self.canvasHolder) self.set_canvas(scroll) #add toolbox toolbox = ToolbarBox(self) activity_button = ActivityButton(self) toolbox.toolbar.insert(activity_button, 0) activity_button.show() separator = Gtk.SeparatorToolItem() separator.show() toolbox.toolbar.insert(separator, 1) #new file button new_file = ToolButton('list-add') new_file.set_tooltip(_('New File')) new_file.props.accelerator = ('<ctrl><shift>n') new_file.connect('clicked', self.newFile) toolbox.toolbar.insert(new_file, 2) new_file.show() #close file button close_file = ToolButton('list-remove') close_file.set_tooltip(_('Close File')) close_file.props.accelerator = ('<ctrl><shift>x') close_file.connect('clicked', self.closeFile) toolbox.toolbar.insert(close_file, 3) #delete button delete_file = ToolButton('dialog-cancel') delete_file.set_tooltip('Delete File') delete_file.props.accelerator = ('del') delete_file.connect('clicked', self.deleteFile) toolbox.toolbar.insert(delete_file, 4) separator = Gtk.SeparatorToolItem() separator.show() toolbox.toolbar.insert(separator, 5) #save file button saveBtnImage = Gtk.Image() saveBtnImage.set_from_file("%s/icons/oopsy_save_as.svg" % os.getcwd()) save_file = ToolButton('gtk-save') save_file.set_icon_widget(saveBtnImage) save_file.set_tooltip(_('Save File')) save_file.props.accelerator = ('<ctrl>s') save_file.connect('clicked', self.saveFile, self.basePath) toolbox.toolbar.insert(save_file, 6) #compile button compile_button = ToolButton('view-source') compile_button.set_tooltip(_('Compile')) compile_button.props.accelerator = ('<ctrl>F6') compile_button.connect('clicked', self.compileFile, self.basePath) toolbox.toolbar.insert(compile_button, 7) #run button gobutton = ToolButton('media-playback-start') gobutton.props.accelerator = ('<ctrl>F5') #gobutton.set_icon_widget(goicon_bw) gobutton.set_tooltip(_("Run!")) gobutton.connect('clicked', self.executeFile, self.basePath) toolbox.toolbar.insert(gobutton, 8) separator = Gtk.SeparatorToolItem() separator.props.draw = False separator.set_expand(True) separator.show() toolbox.toolbar.insert(separator, 9) #stop button stop_button = StopButton(self) toolbox.toolbar.insert(stop_button, 10) stop_button.show() self.set_toolbar_box(toolbox) act_path = activity.get_bundle_path() print "BUNDLE_PAth:", act_path self.loadExplorer(self.basePath) self.show_all()
class SpeechToolbar(Gtk.Toolbar): def __init__(self, activity): GObject.GObject.__init__(self) self._activity = activity if not speech.supported: return self.is_paused = False self.load_speech_parameters() self.sorted_voices = [i for i in speech.voices()] self.sorted_voices.sort(self.compare_voices) default = 0 for voice in self.sorted_voices: if voice[0] == speech.voice[0]: break default = default + 1 # Play button self.play_btn = ToggleToolButton('media-playback-start') self.play_btn.show() self.play_toggled_handler = self.play_btn.connect( 'toggled', self.play_cb) self.insert(self.play_btn, -1) self.play_btn.set_tooltip(_('Play / Pause')) # Stop button self.stop_btn = ToolButton('media-playback-stop') self.stop_btn.show() self.stop_btn.connect('clicked', self.stop_cb) self.stop_btn.set_sensitive(False) self.insert(self.stop_btn, -1) self.stop_btn.set_tooltip(_('Stop')) self.voice_combo = ComboBox() for voice in self.sorted_voices: self.voice_combo.append_item(voice, voice[0]) self.voice_combo.set_active(default) self.voice_combo.connect('changed', self.voice_changed_cb) combotool = ToolComboBox(self.voice_combo) self.insert(combotool, -1) combotool.show() speech.reset_cb = self.reset_buttons_cb speech.end_text_cb = self.reset_buttons_cb def compare_voices(self, a, b): if a[0].lower() == b[0].lower(): return 0 if a[0].lower() < b[0].lower(): return -1 if a[0].lower() > b[0].lower(): return 1 def voice_changed_cb(self, combo): speech.voice = combo.props.value speech.say(speech.voice[0]) self.save_speech_parameters() def load_speech_parameters(self): speech_parameters = {} data_path = os.path.join(self._activity.get_activity_root(), 'data') data_file_name = os.path.join(data_path, 'speech_params.json') if os.path.exists(data_file_name): f = open(data_file_name, 'r') try: speech_parameters = json.load(f) speech.voice = speech_parameters['voice'] finally: f.close() def save_speech_parameters(self): speech_parameters = {} speech_parameters['voice'] = speech.voice data_path = os.path.join(self._activity.get_activity_root(), 'data') data_file_name = os.path.join(data_path, 'speech_params.json') f = open(data_file_name, 'w') try: json.dump(speech_parameters, f) finally: f.close() def reset_buttons_cb(self): logging.error('reset buttons') self.play_btn.set_icon_name('media-playback-start') self.stop_btn.set_sensitive(False) self.play_btn.handler_block(self.play_toggled_handler) self.play_btn.set_active(False) self.play_btn.handler_unblock(self.play_toggled_handler) self.is_paused = False def play_cb(self, widget): self.stop_btn.set_sensitive(True) if widget.get_active(): self.play_btn.set_icon_name('media-playback-pause') logging.error('Paused %s', self.is_paused) if not self.is_paused: # get the text to speech, if there are a selection, # play selected text, if not, play all abi = self._activity.abiword_canvas selection = abi.get_selection('text/plain') if not selection or selection[0] is None or selection[1] == 0: # nothing selected abi.select_all() text = abi.get_selection('text/plain')[0] abi.moveto_bod() else: text = selection[0] speech.play(text) else: logging.error('Continue play') speech.continue_play() else: self.play_btn.set_icon_name('media-playback-start') self.is_paused = True speech.pause() def stop_cb(self, widget): self.stop_btn.set_sensitive(False) self.play_btn.set_icon_name('media-playback-start') self.play_btn.set_active(False) self.is_paused = False speech.stop()
def build_toolbar(self): toolbar_box = ToolbarBox() activity_button = ActivityToolbarButton(self) toolbar_box.toolbar.insert(activity_button, -1) activity_button.show() separator = Gtk.SeparatorToolItem() separator.props.draw = False separator.set_expand(False) toolbar_box.toolbar.insert(separator, -1) separator.show() self._levels_buttons = [] def add_level_button(icon_name, tooltip, numeric_level): if self._levels_buttons: button = RadioToolButton(icon_name=icon_name, group=self._levels_buttons[0]) else: button = RadioToolButton(icon_name=icon_name) self._levels_buttons.append(button) def callback(source): if source.get_active(): self.game.set_level(numeric_level) self.game.run() button.connect('clicked', callback) button.set_tooltip(tooltip) add_level_button('male-7', _("Hard"), 3) add_level_button('male-4', _("Medium"), 2) add_level_button('male-1', _("Easy"), 1) for button in self._levels_buttons[::-1]: toolbar_box.toolbar.insert(button, -1) separator2 = Gtk.SeparatorToolItem() separator2.props.draw = True separator2.set_expand(False) toolbar_box.toolbar.insert(separator2, -1) separator2.show() button = ToolButton('speaker-muted-100') button.set_tooltip(_('Sound')) button.connect('clicked', self.sound_control) toolbar_box.toolbar.insert(button, -1) separator3 = Gtk.SeparatorToolItem() separator3.props.draw = False separator3.set_expand(True) toolbar_box.toolbar.insert(separator3, -1) separator3.show() stop_button = StopButton(self) toolbar_box.toolbar.insert(stop_button, -1) stop_button.show() self.set_toolbar_box(toolbar_box) toolbar_box.show() self.show_all()
class EvinceViewer(Gtk.VBox): """PDF viewer with a toolbar overlay for basic navigation and an option to save to Journal. """ __gsignals__ = { 'save-to-journal': (GObject.SignalFlags.RUN_FIRST, None, ([])), 'open-link': (GObject.SignalFlags.RUN_FIRST, None, ([str])), } def __init__(self, uri): GObject.GObject.__init__(self) self._uri = uri # delay Evince import until is needed to improve activity startup time from gi.repository import EvinceDocument from gi.repository import EvinceView # Create Evince objects to handle the PDF in the URI: EvinceDocument.init() self._doc = EvinceDocument.Document.factory_get_document(uri) self._view = EvinceView.View() self._model = EvinceView.DocumentModel() self._model.set_document(self._doc) self._view.set_model(self._model) self._EVINCE_MODE_FREE = EvinceView.SizingMode.FREE self._view.connect('external-link', self.__handle_link_cb) self._model.connect('page-changed', self.__page_changed_cb) self._back_page_button = None self._forward_page_button = None self._toolbar_box = self._create_toolbar() self._update_nav_buttons() self._toolbar_box.set_halign(Gtk.Align.FILL) self._toolbar_box.set_valign(Gtk.Align.END) self.pack_end(self._toolbar_box, False, True, 0) self._toolbar_box.show() scrolled_window = Gtk.ScrolledWindow() self.pack_start(scrolled_window, True, True, 0) scrolled_window.show() scrolled_window.add(self._view) self._view.show() def _create_toolbar(self): toolbar_box = ToolbarBox() 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_out_button.show() 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_in_button.show() zoom_original_button = ToolButton('zoom-original') zoom_original_button.set_tooltip(_('Actual size')) zoom_original_button.connect('clicked', self.__zoom_original_cb) toolbar_box.toolbar.insert(zoom_original_button, -1) zoom_original_button.show() separator = Gtk.SeparatorToolItem() separator.props.draw = True toolbar_box.toolbar.insert(separator, -1) separator.show() self._back_page_button = ToolButton('go-previous-paired') self._back_page_button.set_tooltip(_('Previous page')) self._back_page_button.props.sensitive = False self._back_page_button.connect('clicked', self.__go_back_page_cb) toolbar_box.toolbar.insert(self._back_page_button, -1) self._back_page_button.show() self._forward_page_button = ToolButton('go-next-paired') self._forward_page_button.set_tooltip(_('Next page')) self._forward_page_button.props.sensitive = False self._forward_page_button.connect('clicked', self.__go_forward_page_cb) toolbar_box.toolbar.insert(self._forward_page_button, -1) self._forward_page_button.show() separator = Gtk.SeparatorToolItem() separator.props.draw = True toolbar_box.toolbar.insert(separator, -1) separator.show() self._save_to_journal_button = ToolButton('save-to-journal') self._save_to_journal_button.set_tooltip(_('Save PDF to Journal')) self._save_to_journal_button.connect('clicked', self.__save_to_journal_button_cb) toolbar_box.toolbar.insert(self._save_to_journal_button, -1) self._save_to_journal_button.show() return toolbar_box def disable_journal_button(self): self._save_to_journal_button.props.sensitive = False def __handle_link_cb(self, widget, url): self.emit('open-link', url.get_uri()) def __page_changed_cb(self, model, page_from, page_to): self._update_nav_buttons() def __zoom_out_cb(self, widget): self.zoom_out() def __zoom_in_cb(self, widget): self.zoom_in() def __zoom_original_cb(self, widget): self.zoom_original() def __go_back_page_cb(self, widget): self._view.previous_page() def __go_forward_page_cb(self, widget): self._view.next_page() def __save_to_journal_button_cb(self, widget): self.emit('save-to-journal') self._save_to_journal_button.props.sensitive = False def _update_nav_buttons(self): current_page = self._model.props.page self._back_page_button.props.sensitive = current_page > 0 self._forward_page_button.props.sensitive = \ current_page < self._doc.get_n_pages() - 1 def zoom_original(self): self._model.props.sizing_mode = self._EVINCE_MODE_FREE self._model.props.scale = 1.0 def zoom_in(self): self._model.props.sizing_mode = self._EVINCE_MODE_FREE self._view.zoom_in() def zoom_out(self): self._model.props.sizing_mode = self._EVINCE_MODE_FREE self._view.zoom_out() def get_pdf_title(self): return self._doc.get_title()
class InsertToolbar(Gtk.Toolbar): def __init__(self, abiword_canvas): GObject.GObject.__init__(self) self._abiword_canvas = abiword_canvas self._table_btn = ToolButton('create-table') self._table_btn.set_tooltip(_('Create table')) self.insert(self._table_btn, -1) self._grid_create = GridCreateWidget() self._grid_create.show() self._grid_create.connect('create-table', self._create_table_cb) palette = self._table_btn.get_palette() palette.set_content(self._grid_create) self._table_btn.connect('clicked', self._table_btn_clicked_cb) self._table_rows_after = ToolButton('row-insert') self._table_rows_after.set_tooltip(_('Insert Row')) self._table_rows_after_id = self._table_rows_after.connect( 'clicked', self._table_rows_after_cb) self.insert(self._table_rows_after, -1) self._table_delete_rows = ToolButton('row-remove') self._table_delete_rows.set_tooltip(_('Delete Row')) self._table_delete_rows_id = self._table_delete_rows.connect( 'clicked', self._table_delete_rows_cb) self.insert(self._table_delete_rows, -1) self._table_cols_after = ToolButton('column-insert') self._table_cols_after.set_tooltip(_('Insert Column')) self._table_cols_after_id = self._table_cols_after.connect( 'clicked', self._table_cols_after_cb) self.insert(self._table_cols_after, -1) self._table_delete_cols = ToolButton('column-remove') self._table_delete_cols.set_tooltip(_('Delete Column')) self._table_delete_cols_id = self._table_delete_cols.connect( 'clicked', self._table_delete_cols_cb) self.insert(self._table_delete_cols, -1) self.show_all() self._abiword_canvas.connect('table-state', self._isTable_cb) #self._abiword_canvas.connect('image-selected', # self._image_selected_cb) def _table_btn_clicked_cb(self, button): button.get_palette().popup(True, button.get_palette().SECONDARY) def _create_table_cb(self, abi, rows, cols): self._abiword_canvas.insert_table(rows, cols) def _table_rows_after_cb(self, button): self._abiword_canvas.invoke_ex('insertRowsAfter', '', 0, 0) def _table_delete_rows_cb(self, button): self._abiword_canvas.invoke_ex('deleteRows', '', 0, 0) def _table_cols_after_cb(self, button): self._abiword_canvas.invoke_ex('insertColsAfter', '', 0, 0) def _table_delete_cols_cb(self, button): self._abiword_canvas.invoke_ex('deleteColumns', '', 0, 0) def _isTable_cb(self, abi, b): self._table_rows_after.set_sensitive(b) self._table_delete_rows.set_sensitive(b) self._table_cols_after.set_sensitive(b) self._table_delete_cols.set_sensitive(b)
class ViewToolbar(Gtk.Toolbar): def __init__(self, abiword_canvas): GObject.GObject.__init__(self) self._abiword_canvas = abiword_canvas self._zoom_percentage = 0 self._zoom_out = ToolButton('zoom-out') self._zoom_out.set_tooltip(_('Zoom Out')) self._zoom_out_id = 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_id = self._zoom_in.connect('clicked', self._zoom_in_cb) self.insert(self._zoom_in, -1) self._zoom_in.show() self._zoom_to_width = ToolButton('zoom-best-fit') self._zoom_to_width.set_tooltip(_('Zoom to width')) self._zoom_to_width.connect('clicked', self._zoom_to_width_cb) self.insert(self._zoom_to_width, -1) self._zoom_to_width.show() # TODO: fix the initial value self._zoom_spin_adj = Gtk.Adjustment(0, 25, 400, 25, 50, 0) self._zoom_spin = Gtk.SpinButton.new(self._zoom_spin_adj, 0, 0) self._zoom_spin_id = self._zoom_spin.connect('value-changed', self._zoom_spin_cb) self._zoom_spin.set_numeric(True) self._zoom_spin.show() tool_item_zoom = Gtk.ToolItem() tool_item_zoom.add(self._zoom_spin) self.insert(tool_item_zoom, -1) tool_item_zoom.show() zoom_perc_label = Gtk.Label(_("%")) zoom_perc_label.show() tool_item_zoom_perc_label = Gtk.ToolItem() tool_item_zoom_perc_label.add(zoom_perc_label) self.insert(tool_item_zoom_perc_label, -1) tool_item_zoom_perc_label.show() separator = Gtk.SeparatorToolItem() separator.set_draw(True) separator.show() self.insert(separator, -1) page_label = Gtk.Label(_("Page: ")) page_label.show() tool_item_page_label = Gtk.ToolItem() tool_item_page_label.add(page_label) self.insert(tool_item_page_label, -1) tool_item_page_label.show() self._page_spin_adj = Gtk.Adjustment(0, 1, 0, -1, -1, 0) self._page_spin = Gtk.SpinButton.new(self._page_spin_adj, 0, 0) self._page_spin_id = self._page_spin.connect('value-changed', self._page_spin_cb) self._page_spin.set_numeric(True) self._page_spin.show() tool_item_page = Gtk.ToolItem() tool_item_page.add(self._page_spin) self.insert(tool_item_page, -1) tool_item_page.show() self._total_page_label = Gtk.Label(label=" / 0") self._total_page_label.show() tool_item = Gtk.ToolItem() tool_item.add(self._total_page_label) self.insert(tool_item, -1) tool_item.show() self._abiword_canvas.connect("page-count", self._page_count_cb) self._abiword_canvas.connect("current-page", self._current_page_cb) self._abiword_canvas.connect("zoom", self._zoom_cb) def set_zoom_percentage(self, zoom): self._zoom_percentage = zoom self._abiword_canvas.set_zoom_percentage(self._zoom_percentage) def _zoom_cb(self, canvas, zoom): self._zoom_spin.handler_block(self._zoom_spin_id) try: self._zoom_spin.set_value(zoom) finally: self._zoom_spin.handler_unblock(self._zoom_spin_id) def _zoom_out_cb(self, button): if self._zoom_percentage == 0: self._zoom_percentage = self._abiword_canvas.get_zoom_percentage() if self._zoom_percentage >= 50: self.set_zoom_percentage(self._zoom_percentage - 25) def _zoom_in_cb(self, button): if self._zoom_percentage == 0: self._zoom_percentage = self._abiword_canvas.get_zoom_percentage() if self._zoom_percentage <= 375: self.set_zoom_percentage(self._zoom_percentage + 25) def _zoom_to_width_cb(self, button): self._abiword_canvas.zoom_width() self._zoom_percentage = self._abiword_canvas.get_zoom_percentage() def _zoom_spin_cb(self, button): self._zoom_percentage = self._zoom_spin.get_value_as_int() self._abiword_canvas.set_zoom_percentage(self._zoom_percentage) def _page_spin_cb(self, button): page_num = self._page_spin.get_value_as_int() self._abiword_canvas.set_current_page(page_num) def _page_count_cb(self, canvas, count): current_page = canvas.get_current_page_num() self._page_spin_adj.configure(current_page, 1, count, -1, -1, 0) self._total_page_label.props.label = \ ' / ' + str(count) def _current_page_cb(self, canvas, num): self._page_spin.handler_block(self._page_spin_id) try: self._page_spin.set_value(num) finally: self._page_spin.handler_unblock(self._page_spin_id)
class TextAttributesToolbar(Gtk.Toolbar): def __init__(self, main_area): Gtk.Toolbar.__init__(self) self._main_area = main_area self._font_list = ['ABC123', 'Sans', 'Serif', 'Monospace', 'Symbol'] self._font_sizes = [ '8', '9', '10', '11', '12', '14', '16', '20', '22', '24', '26', '28', '36', '48', '72' ] self.font_button = ToolButton('font-text') self.font_button.set_tooltip(_('Select font')) self.font_button.connect('clicked', self.__font_selection_cb) self.insert(self.font_button, -1) self._setup_font_palette() self.insert(Gtk.SeparatorToolItem(), -1) self.font_size_up = ToolButton('resize+') self.font_size_up.set_tooltip(_('Bigger')) self.font_size_up.connect('clicked', self.__font_sizes_cb, True) self.insert(self.font_size_up, -1) if len(self._main_area.selected) > 0: font_size = self._main_area.font_size else: font_size = utils.default_font_size self.size_label = Gtk.Label(str(font_size)) self.size_label.show() toolitem = Gtk.ToolItem() toolitem.add(self.size_label) toolitem.show() self.insert(toolitem, -1) self.font_size_down = ToolButton('resize-') self.font_size_down.set_tooltip(_('Smaller')) self.font_size_down.connect('clicked', self.__font_sizes_cb, False) self.insert(self.font_size_down, -1) self.insert(Gtk.SeparatorToolItem(), -1) self.bold = ToolButton('bold-text') self.bold.set_tooltip(_('Bold')) self.bold.connect('clicked', self.__bold_cb) self.insert(self.bold, -1) self.italics = ToolButton('italics-text') self.italics.set_tooltip(_('Italics')) self.italics.connect('clicked', self.__italics_cb) self.insert(self.italics, -1) self.underline = ToolButton('underline-text') self.underline.set_tooltip(_('Underline')) self.underline.connect('clicked', self.__underline_cb) self.insert(self.underline, -1) foreground_color = ColorToolButton() foreground_color.set_title(_('Set font color')) foreground_color.connect('color-set', self.__foreground_color_cb) self.insert(foreground_color, -1) bakground_color = ColorToolButton() bakground_color.set_title(_('Set background color')) bakground_color.connect('color-set', self.__background_color_cb) bakground_color.set_color(Gdk.Color(65535, 65535, 65535)) self.insert(bakground_color, -1) self.show_all() def __font_selection_cb(self, widget): if self._font_palette: if not self._font_palette.is_up(): self._font_palette.popup(immediate=True, state=self._font_palette.SECONDARY) else: self._font_palette.popdown(immediate=True) return def _init_font_list(self): self._font_white_list = [] self._font_white_list.extend(DEFAULT_FONTS) # check if there are a user configuration file if not os.path.exists(USER_FONTS_FILE_PATH): # verify if exists a file in /etc if os.path.exists(GLOBAL_FONTS_FILE_PATH): shutil.copy(GLOBAL_FONTS_FILE_PATH, USER_FONTS_FILE_PATH) if os.path.exists(USER_FONTS_FILE_PATH): # get the font names in the file to the white list fonts_file = open(USER_FONTS_FILE_PATH) # get the font names in the file to the white list for line in fonts_file: self._font_white_list.append(line.strip()) # monitor changes in the file gio_fonts_file = Gio.File.new_for_path(USER_FONTS_FILE_PATH) self.monitor = gio_fonts_file.monitor_file(0, None) self.monitor.set_rate_limit(5000) self.monitor.connect('changed', self._reload_fonts) def _reload_fonts(self, monitor, gio_file, other_file, event): if event != Gio.FileMonitorEvent.CHANGES_DONE_HINT: return self._font_white_list = [] self._font_white_list.extend(DEFAULT_FONTS) fonts_file = open(USER_FONTS_FILE_PATH) for line in fonts_file: self._font_white_list.append(line.strip()) # update the menu for child in self._font_palette.menu.get_children(): self._font_palette.menu.remove(child) child = None context = self.get_pango_context() tmp_list = [] for family in context.list_families(): name = family.get_name() if name in self._font_white_list: tmp_list.append(name) for font in sorted(tmp_list): menu_item = MyMenuItem(image=FontImage(font.replace(' ', '-')), text_label=font) menu_item.connect('activate', self.__font_selected_cb, font) self._font_palette.menu.append(menu_item) menu_item.show() return False def _setup_font_palette(self): self._init_font_list() context = self._main_area.pango_context for family in context.list_families(): name = Pango.FontDescription(family.get_name()).to_string() if name not in self._font_list and \ name in self._font_white_list: self._font_list.append(name) self._font_palette = self.font_button.get_palette() for font in sorted(self._font_list): menu_item = MyMenuItem(image=FontImage(font.replace(' ', '-')), text_label=font) menu_item.connect('activate', self.__font_selected_cb, font) self._font_palette.menu.append(menu_item) menu_item.show() def __font_selected_cb(self, widget, font_name): if not hasattr(self._main_area, 'font_name'): return if len(self._main_area.selected) > 0: font_size = self._main_area.font_size else: font_size = utils.default_font_size self._main_area.set_font(font_name, font_size) self._main_area.font_name = font_name self._main_area.font_size = font_size def __attribute_values(self): thought = self._main_area.selected[0] return thought.attributes.copy() def __font_sizes_cb(self, button, increase): if not hasattr(self._main_area, 'font_size'): return if len(self._main_area.selected) < 1: return font_size = self._main_area.font_size if font_size in self._font_sizes: i = self._font_sizes.index(font_size) if increase: if i < len(self._font_sizes) - 2: i += 1 else: if i > 0: i -= 1 else: i = self._font_sizes.index(utils.default_font_size) font_size = self._font_sizes[i] self.size_label.set_text(str(font_size)) self.font_size_down.set_sensitive(i != 0) self.font_size_up.set_sensitive(i < len(self._font_sizes) - 2) self._main_area.set_font(self._main_area.font_name, font_size) def __bold_cb(self, button): if len(self._main_area.selected) < 1: return value = not self.__attribute_values()["bold"] self._main_area.set_bold(value) def __italics_cb(self, button): if len(self._main_area.selected) < 1: return value = not self.__attribute_values()["italic"] self._main_area.set_italics(value) def __underline_cb(self, button): if len(self._main_area.selected) < 1: return value = not self.__attribute_values()["underline"] self._main_area.set_underline(value) def __foreground_color_cb(self, button): color = button.get_color() self._main_area.set_foreground_color(color) def __background_color_cb(self, button): color = button.get_color() self._parent._main_area.set_background_color(color) def change_active_font(self): # TODO: update the toolbar return
def __init__(self, handle): activity.Activity.__init__(self, handle) if HASTOOLBARBOX: self.max_participants = 1 toolbar_box = ToolbarBox() self.set_toolbar_box(toolbar_box) activity_button = ActivityToolbarButton(self) toolbar_box.toolbar.insert(activity_button, 0) separator = Gtk.SeparatorToolItem() separator.props.draw = True activity_button.props.page.insert(separator, -1) separator.show() tool = ToolButton('pdf-export') tool.set_tooltip(_('Portable Document Format (PDF)')) tool.connect('clicked', self.__export_pdf_cb) activity_button.props.page.insert(tool, -1) tool.show() tool = ToolButton('png-export') tool.set_tooltip(_('Portable Network Graphic (PNG)')) tool.connect('clicked', self.__export_png_cb) activity_button.props.page.insert(tool, -1) tool.show() tool = ToolbarButton() self.edit_toolbar = EditToolbar(self) tool.props.page = self.edit_toolbar tool.props.icon_name = 'toolbar-edit' ##tool.props.label = _('Edit'), toolbar_box.toolbar.insert(tool, -1) #self._undo = UndoManager.UndoManager(self, # self.edit_toolbar.undo.child, # self.edit_toolbar.redo.child) self._undo = UndoManager.UndoManager(self, self.edit_toolbar.undo, self.edit_toolbar.redo) self.__build_main_canvas_area() tool = ToolbarButton() tool.props.page = ViewToolbar(self._main_area) tool.props.icon_name = 'toolbar-view' tool.props.label = _('View') toolbar_box.toolbar.insert(tool, -1) tool = ToolbarButton() self.text_format_toolbar = TextAttributesToolbar(self._main_area) tool.props.page = self.text_format_toolbar tool.props.icon_name = 'toolbar-text' tool.props.label = _('Text') toolbar_box.toolbar.insert(tool, -1) # self._main_area.set_text_attributes(self.text_format_toolbar) self.thought_toolbar = ToolbarButton() self.thought_toolbar.props.page = ThoughtsToolbar(self) self.thought_toolbar.props.icon_name = 'thought' self.thought_toolbar.props.label = _('Thought Type') toolbar_box.toolbar.insert(self.thought_toolbar, -1) self.action_buttons = ActionButtons(self) toolbar_box.show_all() else: # Use old <= 0.84 toolbar design toolbox = activity.ActivityToolbox(self) self.set_toolbox(toolbox) activity_toolbar = toolbox.get_activity_toolbar() keep_palette = activity_toolbar.keep.get_palette() menu_item = MenuItem(_('Portable Document Format (PDF)')) menu_item.connect('activate', self.__export_pdf_cb) keep_palette.menu.append(menu_item) menu_item.show() menu_item = MenuItem(_('Portable Network Graphic (PNG)')) menu_item.connect('activate', self.__export_png_cb) keep_palette.menu.append(menu_item) menu_item.show() self.edit_toolbar = EditToolbar(self) toolbox.add_toolbar(_('Edit'), self.edit_toolbar) separator = Gtk.SeparatorToolItem() self.edit_toolbar.insert(separator, 0) self.edit_toolbar.show() self._undo = UndoManager.UndoManager(self, self.edit_toolbar.undo.child, self.edit_toolbar.redo.child) self.__build_main_canvas_area() view_toolbar = ViewToolbar(self._main_area) toolbox.add_toolbar(_('View'), view_toolbar) activity_toolbar = toolbox.get_activity_toolbar() activity_toolbar.share.props.visible = False toolbox.set_current_toolbar(1) self.show_all() self.__configure_cb(None) self._mode = MMapArea.MODE_TEXT self._main_area.set_mode(self._mode) self.set_focus_child(self._main_area)
class SpeechToolbar(Gtk.Toolbar): def __init__(self, activity): Gtk.Toolbar.__init__(self) self._activity = activity if not speech.supported: return self._cnf_client = GConf.Client.get_default() self.load_speech_parameters() self.sorted_voices = [i for i in speech.voices()] self.sorted_voices.sort(self.compare_voices) default = 0 for voice in self.sorted_voices: if voice[0] == speech.voice[0]: break default = default + 1 # Play button self.play_btn = ToggleToolButton('media-playback-start') self.play_btn.show() self.play_btn.connect('toggled', self.play_cb) self.insert(self.play_btn, -1) self.play_btn.set_tooltip(_('Play / Pause')) # Stop button self.stop_btn = ToolButton('media-playback-stop') self.stop_btn.show() self.stop_btn.connect('clicked', self.stop_cb) self.stop_btn.set_sensitive(False) self.insert(self.stop_btn, -1) self.stop_btn.set_tooltip(_('Stop')) self.voice_combo = ComboBox() for voice in self.sorted_voices: self.voice_combo.append_item(voice, voice[0]) self.voice_combo.set_active(default) self.voice_combo.connect('changed', self.voice_changed_cb) combotool = ToolComboBox(self.voice_combo) self.insert(combotool, -1) combotool.show() speech.reset_buttons_cb = self.reset_buttons_cb def compare_voices(self, a, b): if a[0].lower() == b[0].lower(): return 0 if a[0] .lower() < b[0].lower(): return -1 if a[0] .lower() > b[0].lower(): return 1 def voice_changed_cb(self, combo): speech.voice = combo.props.value speech.say(speech.voice[0]) self.save_speech_parameters() def load_speech_parameters(self): speech_parameters = {} data_path = os.path.join(self._activity.get_activity_root(), 'data') data_file_name = os.path.join(data_path, 'speech_params.json') if os.path.exists(data_file_name): f = open(data_file_name, 'r') try: speech_parameters = simplejson.load(f) speech.voice = speech_parameters['voice'] finally: f.close() self._cnf_client.add_dir('/desktop/sugar/speech', GConf.ClientPreloadType.PRELOAD_NONE) speech.pitch = self._cnf_client.get_int('/desktop/sugar/speech/pitch') speech.rate = self._cnf_client.get_int('/desktop/sugar/speech/rate') self._cnf_client.notify_add('/desktop/sugar/speech/pitch', \ self.__conf_changed_cb, None) self._cnf_client.notify_add('/desktop/sugar/speech/rate', \ self.__conf_changed_cb, None) def __conf_changed_cb(self, client, connection_id, entry, args): key = entry.get_key() value = client.get_int(key) if key == '/desktop/sugar/speech/pitch': speech.pitch = value if key == '/desktop/sugar/speech/rate': speech.rate = value def save_speech_parameters(self): speech_parameters = {} speech_parameters['voice'] = speech.voice data_path = os.path.join(self._activity.get_activity_root(), 'data') data_file_name = os.path.join(data_path, 'speech_params.json') f = open(data_file_name, 'w') try: simplejson.dump(speech_parameters, f) finally: f.close() def reset_buttons_cb(self): logging.error('reset buttons') self.play_btn.set_named_icon('media-playback-start') self.stop_btn.set_sensitive(False) def play_cb(self, widget): self.stop_btn.set_sensitive(True) if widget.get_active(): self.play_btn.set_named_icon('media-playback-pause') if speech.is_stopped(): speech.play(self._activity._view.get_marked_words()) else: self.play_btn.set_named_icon('media-playback-start') speech.pause() def stop_cb(self, widget): self.stop_btn.set_sensitive(False) self.play_btn.set_named_icon('media-playback-start') self.play_btn.set_active(False) speech.stop()
class SectionToolbar(Gtk.Toolbar): """ Toolbar of the sections of the control panel """ __gtype_name__ = 'SectionToolbar' __gsignals__ = { 'cancel-clicked': (GObject.SignalFlags.RUN_FIRST, None, ([])), 'accept-clicked': (GObject.SignalFlags.RUN_FIRST, 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')
def __init__(self, handle): super(PeterActivity, self).__init__(handle) # Get user's Sugar colors sugarcolors = profile.get_color().to_string().split(',') colors = [[ int(sugarcolors[0][1:3], 16), int(sugarcolors[0][3:5], 16), int(sugarcolors[0][5:7], 16) ], [ int(sugarcolors[1][1:3], 16), int(sugarcolors[1][3:5], 16), int(sugarcolors[1][5:7], 16) ]] # No sharing self.max_participants = 1 # Build the activity toolbar. toolbox = ToolbarBox() activity_button = ActivityToolbarButton(self) toolbox.toolbar.insert(activity_button, 0) activity_button.show() self._add_speed_slider(toolbox.toolbar) cyan = ToolButton('cyan') toolbox.toolbar.insert(cyan, -1) cyan.set_tooltip(_('Next pattern')) cyan.connect('clicked', self._button_cb, 'cyan') cyan.set_sensitive(False) cyan.show() green = ToolButton('green') toolbox.toolbar.insert(green, -1) green.set_tooltip(_('Draw')) green.connect('clicked', self._button_cb, 'green') green.show() red = ToolButton('red') toolbox.toolbar.insert(red, -1) red.set_tooltip(_('Stop')) red.connect('clicked', self._button_cb, 'red') red.show() separator = Gtk.SeparatorToolItem() separator.props.draw = True toolbox.toolbar.insert(separator, -1) separator.show() label = Gtk.Label('') label.set_use_markup(True) label.show() labelitem = Gtk.ToolItem() labelitem.add(label) toolbox.toolbar.insert(labelitem, -1) labelitem.show() separator = Gtk.SeparatorToolItem() separator.props.draw = False separator.set_expand(True) toolbox.toolbar.insert(separator, -1) separator.show() stop_button = StopButton(self) stop_button.props.accelerator = _('<Ctrl>Q') toolbox.toolbar.insert(stop_button, -1) stop_button.show() toolbox.show() self.set_toolbar_box(toolbox) # Create the game instance. self.game = Spirolaterals.Spirolaterals(colors) # Build the Pygame canvas. self._pygamecanvas = \ sugargame.canvas.PygameCanvas(self) # Note that set_canvas implicitly calls # read_file when resuming from the Journal. self.set_canvas(self._pygamecanvas) self.game.canvas = self._pygamecanvas Gdk.Screen.get_default().connect('size-changed', self.__configure_cb) # Start the game running. self.game.set_cyan_button(cyan) self.game.set_label(label) self._speed_range.set_value(200) self._pygamecanvas.run_pygame(self.game.run)
def __init__(self, handle): super(PeterActivity, self).__init__(handle) # Get user's Sugar colors sugarcolors = profile.get_color().to_string().split(',') colors = [[ int(sugarcolors[0][1:3], 16), int(sugarcolors[0][3:5], 16), int(sugarcolors[0][5:7], 16) ], [ int(sugarcolors[1][1:3], 16), int(sugarcolors[1][3:5], 16), int(sugarcolors[1][5:7], 16) ]] # No sharing self.max_participants = 1 # Build the activity toolbar. toolbox = ToolbarBox() activity_button = ActivityToolbarButton(self) toolbox.toolbar.insert(activity_button, 0) activity_button.show() self._add_level_slider(toolbox.toolbar) green = ToolButton('green') toolbox.toolbar.insert(green, -1) green.set_tooltip(_('Run')) green.connect('clicked', self._button_cb, 'green') green.show() separator = Gtk.SeparatorToolItem() separator.props.draw = True toolbox.toolbar.insert(separator, -1) separator.show() label = Gtk.Label('') label.set_use_markup(True) label.show() labelitem = Gtk.ToolItem() labelitem.add(label) toolbox.toolbar.insert(labelitem, -1) labelitem.show() separator = Gtk.SeparatorToolItem() separator.props.draw = False separator.set_expand(True) toolbox.toolbar.insert(separator, -1) separator.show() stop = StopButton(self) toolbox.toolbar.insert(stop, -1) stop.show() toolbox.show() self.set_toolbar_box(toolbox) # Create the game instance. self.game = Numbers.Numbers(colors, sugar=True) # Build the Pygame canvas. self._pygamecanvas = sugargame.canvas.PygameCanvas(self) # Note that set_canvas implicitly calls # read_file when resuming from the Journal. self.set_canvas(self._pygamecanvas) self.game.canvas = self._pygamecanvas self.game.set_buttons(green) self.game.set_label(label) Gdk.Screen.get_default().connect('size-changed', self.__configure_cb) # Start the game running. self._pygamecanvas.run_pygame(self.game.run)
class EditToolbar(Gtk.Toolbar): def __init__(self, pc, toolbar_box): GObject.GObject.__init__(self) self._abiword_canvas = pc.abiword_canvas copy = CopyButton() copy.props.accelerator = '<Ctrl>C' copy.connect('clicked', lambda button: pc.abiword_canvas.copy()) self.insert(copy, -1) copy.show() paste = PasteButton() paste.props.accelerator = '<Ctrl>V' paste.connect('clicked', self.__paste_button_cb) self.insert(paste, -1) paste.show() separator = Gtk.SeparatorToolItem() self.insert(separator, -1) separator.show() undo = UndoButton(sensitive=False) undo.connect('clicked', lambda button: pc.abiword_canvas.undo()) pc.abiword_canvas.connect("can-undo", lambda abi, can_undo: undo.set_sensitive(can_undo)) self.insert(undo, -1) undo.show() redo = RedoButton(sensitive=False) redo.connect('clicked', lambda button: pc.abiword_canvas.redo()) pc.abiword_canvas.connect("can-redo", lambda abi, can_redo: redo.set_sensitive(can_redo)) self.insert(redo, -1) redo.show() pc.abiword_canvas.connect('text-selected', lambda abi, b: copy.set_sensitive(True)) pc.abiword_canvas.connect('image-selected', lambda abi, b: copy.set_sensitive(True)) pc.abiword_canvas.connect('selection-cleared', lambda abi, b: copy.set_sensitive(False)) separator = Gtk.SeparatorToolItem() self.insert(separator, -1) separator.show() search_label = Gtk.Label(label=_("Search") + ": ") search_label.show() search_item_page_label = Gtk.ToolItem() search_item_page_label.add(search_label) self.insert(search_item_page_label, -1) search_item_page_label.show() # setup the search options self._search_entry = iconentry.IconEntry() self._search_entry.set_icon_from_name(iconentry.ICON_ENTRY_PRIMARY, 'system-search') self._search_entry.connect('activate', self._search_entry_activated_cb) self._search_entry.connect('changed', self._search_entry_changed_cb) self._search_entry.add_clear_button() self._add_widget(self._search_entry, expand=True) self._findprev = ToolButton('go-previous-paired') self._findprev.set_tooltip(_('Find previous')) self.insert(self._findprev, -1) self._findprev.show() self._findprev.connect('clicked', self._findprev_cb) self._findnext = ToolButton('go-next-paired') self._findnext.set_tooltip(_('Find next')) self.insert(self._findnext, -1) self._findnext.show() self._findnext.connect('clicked', self._findnext_cb) # set the initial state of the search controls # note: we won't simple call self._search_entry_changed_cb # here, as that will call into the abiword_canvas, which # is not mapped on screen here, causing the set_find_string # call to fail self._findprev.set_sensitive(False) self._findnext.set_sensitive(False) def __paste_button_cb(self, button): clipboard = Gtk.Clipboard.get(Gdk.SELECTION_CLIPBOARD) if clipboard.wait_is_image_available(): pixbuf_sel = clipboard.wait_for_image() activity = self._abiword_canvas.get_toplevel() temp_path = os.path.join(activity.get_activity_root(), 'instance') if not os.path.exists(temp_path): os.makedirs(temp_path) fd, file_path = tempfile.mkstemp(dir=temp_path, suffix='.png') os.close(fd) logging.error('tempfile is %s' % file_path) success, data = pixbuf_sel.save_to_bufferv('png', [], []) if success: px_file = open(file_path, 'w') px_file.write(data) px_file.close() self._abiword_canvas.insert_image(file_path, False) elif clipboard.wait_is_uris_available(): selection = clipboard.wait_for_uris() if selection is not None: for uri in selection: self._abiword_canvas.insert_image(urlparse(uri).path, False) else: self._abiword_canvas.paste() def _search_entry_activated_cb(self, entry): logger.debug('_search_entry_activated_cb') if not self._search_entry.props.text: return # find the next entry self._abiword_canvas.find_next(False) def _search_entry_changed_cb(self, entry): logger.debug('_search_entry_changed_cb search for \'%s\'', self._search_entry.props.text) if not self._search_entry.props.text: self._search_entry.activate() # set the button contexts self._findprev.set_sensitive(False) self._findnext.set_sensitive(False) return self._abiword_canvas.set_find_string(self._search_entry.props.text) # set the button contexts self._findprev.set_sensitive(True) self._findnext.set_sensitive(True) # immediately start seaching self._abiword_canvas.find_next(True) def _findprev_cb(self, button): logger.debug('_findprev_cb') if self._search_entry.props.text: self._abiword_canvas.find_prev() else: logger.debug('nothing to search for!') def _findnext_cb(self, button): logger.debug('_findnext_cb') if self._search_entry.props.text: self._abiword_canvas.find_next(False) else: logger.debug('nothing to search for!') # bad foddex! this function was copied from sugar's activity.py def _add_widget(self, widget, expand=False): tool_item = Gtk.ToolItem() tool_item.set_expand(expand) tool_item.add(widget) widget.show() self.insert(tool_item, -1) tool_item.show()
class PeterActivity(activity.Activity): LOWER = 1 UPPER = 10 def __init__(self, handle): super(PeterActivity, self).__init__(handle) # Get user's Sugar colors sugarcolors = profile.get_color().to_string().split(',') colors = [[ int(sugarcolors[0][1:3], 16), int(sugarcolors[0][3:5], 16), int(sugarcolors[0][5:7], 16) ], [ int(sugarcolors[1][1:3], 16), int(sugarcolors[1][3:5], 16), int(sugarcolors[1][5:7], 16) ]] # No sharing self.max_participants = 1 # Build the activity toolbar. toolbox = ToolbarBox() activity_button = ActivityToolbarButton(self) toolbox.toolbar.insert(activity_button, 0) activity_button.show() self._add_level_slider(toolbox.toolbar) green = ToolButton('green') toolbox.toolbar.insert(green, -1) green.set_tooltip(_('Run')) green.connect('clicked', self._button_cb, 'green') green.show() separator = Gtk.SeparatorToolItem() separator.props.draw = True toolbox.toolbar.insert(separator, -1) separator.show() label = Gtk.Label('') label.set_use_markup(True) label.show() labelitem = Gtk.ToolItem() labelitem.add(label) toolbox.toolbar.insert(labelitem, -1) labelitem.show() separator = Gtk.SeparatorToolItem() separator.props.draw = False separator.set_expand(True) toolbox.toolbar.insert(separator, -1) separator.show() stop = StopButton(self) toolbox.toolbar.insert(stop, -1) stop.show() toolbox.show() self.set_toolbar_box(toolbox) # Create the game instance. self.game = Numbers.Numbers(colors, sugar=True) # Build the Pygame canvas. self._pygamecanvas = sugargame.canvas.PygameCanvas(self) # Note that set_canvas implicitly calls # read_file when resuming from the Journal. self.set_canvas(self._pygamecanvas) self.game.canvas = self._pygamecanvas self.game.set_buttons(green) self.game.set_label(label) Gdk.Screen.get_default().connect('size-changed', self.__configure_cb) # Start the game running. self._pygamecanvas.run_pygame(self.game.run) def get_preview(self): return self._pygamecanvas.get_preview() def __configure_cb(self, event): ''' Screen size has changed ''' logging.debug(self._pygamecanvas.get_allocation()) pygame.display.set_mode( (Gdk.Screen.width(), Gdk.Screen.height() - GRID_CELL_SIZE), pygame.RESIZABLE) self.game.reload() self._level_range.set_value(1) self.game.run(restore=True) def read_file(self, file_path): try: f = open(file_path, 'r') except Exception as e: logging.error('Could not open %s: %s' % (file_path, e)) return load_save.load(f) f.close() def write_file(self, file_path): f = open(file_path, 'w') load_save.save(f) f.close() def _button_cb(self, button=None, color=None): self.game.do_button(color) def _add_level_slider(self, toolbar): self._level_stepper_down = ToolButton('easy') self._level_stepper_down.set_tooltip(_('Easier')) self._level_stepper_down.connect('clicked', self._level_stepper_down_cb) self._level_stepper_down.show() self._adjustment = Gtk.Adjustment.new(1, self.LOWER, self.UPPER, 1, 5, 0) self._adjustment.connect('value_changed', self._level_change_cb) self._level_range = Gtk.HScale.new(self._adjustment) self._level_range.set_draw_value(False) self._level_range.set_size_request(120, 15) self._level_range.show() self._level_stepper_up = ToolButton('hard') self._level_stepper_up.set_tooltip(_('Harder')) self._level_stepper_up.connect('clicked', self._level_stepper_up_cb) self._level_stepper_up.show() self._level_range_tool = Gtk.ToolItem() self._level_range_tool.add(self._level_range) self._level_range_tool.show() toolbar.insert(self._level_stepper_down, -1) toolbar.insert(self._level_range_tool, -1) toolbar.insert(self._level_stepper_up, -1) return def _level_stepper_down_cb(self, button=None): new_value = self._level_range.get_value() - 1 if new_value <= self.UPPER: self._level_range.set_value(new_value) else: self._level_range.set_value(self.UPPER) def _level_stepper_up_cb(self, button=None): new_value = self._level_range.get_value() + 1 if new_value >= self.LOWER: self._level_range.set_value(new_value) else: self._level_range.set_value(self.LOWER) def _level_change_cb(self, button=None): logging.debug(self._adjustment.get_value()) self.game.level1(level=self._adjustment.get_value()) return True
class ClipArtActivity(activity.Activity): def __init__(self, handle): activity.Activity.__init__(self, handle) self._selected_image = None self.max_participants = 1 toolbarbox = ToolbarBox() self.set_toolbar_box(toolbarbox) activity_button = ActivityToolbarButton(self) toolbarbox.toolbar.insert(activity_button, 0) activity_button.show() self.save_button = ToolButton('image-save') self.save_button.set_tooltip(_('Save to Journal')) self.save_button.connect('clicked', self._save_to_journal) self.save_button.set_sensitive(False) self.save_button.show() toolbarbox.toolbar.insert(self.save_button, -1) separator = Gtk.SeparatorToolItem() separator.props.draw = False separator.set_expand(True) toolbarbox.toolbar.insert(separator, -1) stop_button = StopButton(self) toolbarbox.toolbar.insert(stop_button, -1) stop_button.show() scrolled_window = Gtk.ScrolledWindow() scrolled_window.set_shadow_type(Gtk.ShadowType.ETCHED_IN) scrolled_window.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC) self.set_canvas(scrolled_window) scrolled_window.show() store = Gtk.ListStore(GdkPixbuf.Pixbuf, str) icon_view = Gtk.IconView.new_with_model(store) icon_view.set_selection_mode(Gtk.SelectionMode.SINGLE) icon_view.connect('selection-changed', self._clipart_selected, store) icon_view.set_pixbuf_column(0) rgba = Gdk.RGBA() rgba.red, rgba.green, rgba.blue, rgba.alpha = 0.67, 0.67, 0.67, 1.0 icon_view.override_background_color(Gtk.StateFlags.NORMAL, rgba) icon_view.grab_focus() scrolled_window.add(icon_view) icon_view.show() toolbarbox.show_all() self.show_all() self.get_window().set_cursor(Gdk.Cursor.new(Gdk.CursorType.WATCH)) self._notify() GObject.idle_add(_fill_clipart_list, store) def _save_to_journal(self, widget): if self._selected_image is None: return basename = os.path.basename(self._selected_image) dsobject = datastore.create() dsobject.metadata['title'] = basename[:-4] dsobject.metadata['icon-color'] = profile.get_color().to_string() dsobject.metadata['mime_type'] = MIME_TYPES[basename.split('.')[-1]] dsobject.set_file_path(self._selected_image) datastore.write(dsobject) dsobject.destroy() self.save_button.set_sensitive(False) def _get_selected_path(self, widget, store): try: iter_ = store.get_iter(widget.get_selected_items()[0]) image_path = store.get(iter_, 1)[0] return image_path, iter_ except: return None def _clipart_selected(self, widget, store): selected = self._get_selected_path(widget, store) if selected is None: self._selected_image = None self.save_button.set_sensitive(False) return image_path, _iter = selected iter_ = store.get_iter(widget.get_selected_items()[0]) image_path = store.get(iter_, 1)[0] self._selected_image = image_path self.save_button.set_sensitive(True) def _notify(self): alert = ErrorAlert() alert.props.title = _('Scanning for clipart') msg = _('Please wait.') alert.props.msg = msg def remove_alert(alert, response_id): self.get_window().set_cursor(None) self.remove_alert(alert) alert.connect('response', remove_alert) self.add_alert(alert)
class Chat(activity.Activity): def __init__(self, handle): pservice = presenceservice.get_instance() self.owner = pservice.get_owner() self._ebook_mode_detector = EbookModeDetector() self.chatbox = ChatBox(self.owner, self._ebook_mode_detector.get_ebook_mode()) self.chatbox.connect('open-on-journal', self.__open_on_journal) self.chatbox.connect('new-message', self._search_entry_on_new_message_cb) super(Chat, self).__init__(handle) self._entry = None self._has_alert = False self._has_osk = False self._setup_canvas() self._entry.grab_focus() toolbar_box = ToolbarBox() self.set_toolbar_box(toolbar_box) self._activity_toolbar_button = ActivityToolbarButton(self) self._activity_toolbar_button.connect('clicked', self._fixed_resize_cb) toolbar_box.toolbar.insert(self._activity_toolbar_button, 0) self._activity_toolbar_button.show() self.search_entry = iconentry.IconEntry() self.search_entry.set_size_request(Gdk.Screen.width() / 3, -1) self.search_entry.set_icon_from_name(iconentry.ICON_ENTRY_PRIMARY, 'entry-search') self.search_entry.add_clear_button() self.search_entry.connect('activate', self._search_entry_activate_cb) self.search_entry.connect('changed', self._search_entry_activate_cb) self.connect('key-press-event', self._search_entry_key_press_cb) self._search_item = Gtk.ToolItem() self._search_item.add(self.search_entry) toolbar_box.toolbar.insert(self._search_item, -1) self._search_prev = ToolButton('go-previous-paired') self._search_prev.set_tooltip(_('Previous')) self._search_prev.props.accelerator = "<Shift><Ctrl>g" self._search_prev.connect('clicked', self._search_prev_cb) self._search_prev.props.sensitive = False toolbar_box.toolbar.insert(self._search_prev, -1) self._search_next = ToolButton('go-next-paired') self._search_next.set_tooltip(_('Next')) self._search_next.props.accelerator = "<Ctrl>g" self._search_next.connect('clicked', self._search_next_cb) self._search_next.props.sensitive = False toolbar_box.toolbar.insert(self._search_next, -1) separator = Gtk.SeparatorToolItem() separator.props.draw = False separator.set_expand(True) toolbar_box.toolbar.insert(separator, -1) toolbar_box.toolbar.insert(StopButton(self), -1) toolbar_box.show_all() # Chat is room or one to one: self._chat_is_room = False self.text_channel = None if _HAS_SOUND: self.element = Gst.ElementFactory.make('playbin', 'Player') if self.shared_activity: # we are joining the activity following an invite self._alert(_('Off-line'), _('Joining the Chat.')) self._entry.props.placeholder_text = \ _('Please wait for a connection before starting to chat.') self.connect('joined', self._joined_cb) if self.get_shared(): # we have already joined self._joined_cb(self) elif handle.uri: # XMPP non-sugar3 incoming chat, not sharable self._activity_toolbar_button.props.page.share.props.visible = \ False self._one_to_one_connection(handle.uri) else: # we are creating the activity if not self.metadata or self.metadata.get( 'share-scope', activity.SCOPE_PRIVATE) == \ activity.SCOPE_PRIVATE: # if we are in private session self._alert(_('Off-line'), _('Share, or invite someone.')) else: # resume of shared activity from journal object without invite self._entry.props.placeholder_text = \ _('Please wait for a connection before starting to chat.') self.connect('shared', self._shared_cb) def _search_entry_key_press_cb(self, activity, event): keyname = Gdk.keyval_name(event.keyval).lower() if keyname == 'f': if Gdk.ModifierType.CONTROL_MASK & event.state: self.search_entry.grab_focus() elif keyname == 'escape': self.search_entry.props.text = '' self._entry.grab_focus() def _search_entry_on_new_message_cb(self, chatbox): self._search_entry_activate_cb(self.search_entry) def _search_entry_activate_cb(self, entry): for i in range(0, self.chatbox.number_of_textboxes()): textbox = self.chatbox.get_textbox(i) _buffer = textbox.get_buffer() start_mark = _buffer.get_mark('start') end_mark = _buffer.get_mark('end') if start_mark is None or end_mark is None: continue _buffer.delete_mark(start_mark) _buffer.delete_mark(end_mark) self.chatbox.highlight_text = (None, None, None) self.chatbox.set_search_text(entry.props.text) self._update_search_buttons() def _update_search_buttons(self, ): if len(self.chatbox.search_text) == 0: self._search_prev.props.sensitive = False self._search_next.props.sensitive = False else: # If next or previous result exists self._search_prev.props.sensitive = \ self.chatbox.check_next('backward') self._search_next.props.sensitive = \ self.chatbox.check_next('forward') def _search_prev_cb(self, button): if button.props.sensitive: self.chatbox.search('backward') self._update_search_buttons() def _search_next_cb(self, button): if button.props.sensitive: self.chatbox.search('forward') self._update_search_buttons() def _fixed_resize_cb(self, widget=None, rect=None): ''' If a toolbar opens or closes, we need to resize the vbox holding out scrolling window. ''' if self._has_alert: dy = style.GRID_CELL_SIZE else: dy = 0 if self._has_osk: if Gdk.Screen.width() > Gdk.Screen.height(): dy += OSK_HEIGHT[0] else: dy += OSK_HEIGHT[1] if self._toolbar_expanded(): self.chatbox.set_size_request( self._chat_width, self._chat_height - style.GRID_CELL_SIZE - dy) self._fixed.move(self._entry_grid, style.GRID_CELL_SIZE, self._chat_height - style.GRID_CELL_SIZE - dy) else: self.chatbox.set_size_request(self._chat_width, self._chat_height - dy) self._fixed.move(self._entry_grid, style.GRID_CELL_SIZE, self._chat_height - dy) self.chatbox.resize_conversation(dy) def _setup_canvas(self): ''' Create a canvas ''' self._fixed = Gtk.Fixed() self._fixed.set_size_request( Gdk.Screen.width(), Gdk.Screen.height() - style.GRID_CELL_SIZE) self._fixed.connect('size-allocate', self._fixed_resize_cb) self.set_canvas(self._fixed) self._fixed.show() self._entry_widgets = self._make_entry_widgets() self._fixed.put(self.chatbox, 0, 0) self.chatbox.show() self._fixed.put(self._entry_grid, style.GRID_CELL_SIZE, self._chat_height) self._entry_grid.show() Gdk.Screen.get_default().connect('size-changed', self._configure_cb) def _configure_cb(self, event): self._fixed.set_size_request( Gdk.Screen.width(), Gdk.Screen.height() - style.GRID_CELL_SIZE) if self._ebook_mode_detector.get_ebook_mode(): self._entry_height = int(style.GRID_CELL_SIZE * 1.5) else: self._entry_height = style.GRID_CELL_SIZE entry_width = Gdk.Screen.width() - \ 2 * (self._entry_height + style.GRID_CELL_SIZE) self._entry.set_size_request(entry_width, self._entry_height) self._entry_grid.set_size_request( Gdk.Screen.width() - 2 * style.GRID_CELL_SIZE, self._entry_height) self._chat_height = Gdk.Screen.height() - self._entry_height - \ style.GRID_CELL_SIZE self._chat_width = Gdk.Screen.width() self.chatbox.set_size_request(self._chat_width, self._chat_height) self.chatbox.resize_all() width = int(Gdk.Screen.width() - 2 * style.GRID_CELL_SIZE) if self._ebook_mode_detector.get_ebook_mode(): height = int(Gdk.Screen.height() - 8 * style.GRID_CELL_SIZE) else: height = int(Gdk.Screen.height() - 5 * style.GRID_CELL_SIZE) self._smiley_table.set_size_request(width, height) self._smiley_toolbar.set_size_request(width, -1) self._smiley_window.set_size_request(width, -1) self._fixed_resize_cb() def _create_smiley_table(self, width): pixel_size = (style.STANDARD_ICON_SIZE + style.LARGE_ICON_SIZE) / 2 spacing = style.DEFAULT_SPACING button_size = pixel_size + spacing smilies_columns = int(width / button_size) pad = (width - smilies_columns * button_size) / 2 table = Gtk.Grid() table.set_row_spacing(spacing) table.set_column_spacing(spacing) table.set_border_width(pad) queue = [] def _create_smiley_icon_idle_cb(): try: x, y, path, code = queue.pop() except IndexError: self.unbusy() return False pixbuf = GdkPixbuf.Pixbuf.new_from_file_at_size( path, pixel_size, pixel_size) image = Gtk.Image.new_from_pixbuf(pixbuf) box = Gtk.EventBox() box.add(image) box.connect('button-press-event', self._add_smiley_to_entry, code) table.attach(box, x, y, 1, 1) box.show_all() return True x = 0 y = 0 smilies.init() for i in range(len(smilies.THEME)): path, hint, codes = smilies.THEME[i] queue.append([x, y, path, codes[0]]) x += 1 if x == smilies_columns: y += 1 x = 0 queue.reverse() GLib.idle_add(_create_smiley_icon_idle_cb) return table def _add_smiley_to_entry(self, icon, event, text): pos = self._entry.props.cursor_position self._entry.insert_text(text, pos) self._entry.grab_focus() self._entry.set_position(pos + len(text)) self._hide_smiley_window() def _shared_cb(self, sender): self._setup() def _one_to_one_connection(self, tp_channel): '''Handle a private invite from a non-sugar3 XMPP client.''' if self.shared_activity or self.text_channel: return bus_name, connection, channel = json.loads(tp_channel) logger.debug('GOT XMPP: %s %s %s', bus_name, connection, channel) conn = {} conn_proxy = dbus.Bus().get_object(bus_name, connection) conn[TelepathyGLib.IFACE_CONNECTION_INTERFACE_ALIASING] = \ dbus.Interface( conn_proxy, TelepathyGLib.IFACE_CONNECTION_INTERFACE_ALIASING) self._one_to_one_connection_ready_cb(bus_name, channel, conn) def _one_to_one_connection_ready_cb(self, bus_name, channel, conn): '''Callback for Connection for one to one connection''' text_channel = {} text_proxy = dbus.Bus().get_object(bus_name, channel) text_channel[TelepathyGLib.IFACE_CHANNEL] = \ dbus.Interface(text_proxy, TelepathyGLib.IFACE_CHANNEL) text_channel[TelepathyGLib.IFACE_CHANNEL_TYPE_TEXT] = \ dbus.Interface(text_proxy, TelepathyGLib.IFACE_CHANNEL_TYPE_TEXT) text_channel[TelepathyGLib.IFACE_CHANNEL_INTERFACE_GROUP] = \ dbus.Interface( text_proxy, TelepathyGLib.IFACE_CHANNEL_INTERFACE_GROUP) self.text_channel = TextChannelWrapper(text_channel, conn) self.text_channel.set_received_callback(self._received_cb) self.text_channel.handle_pending_messages() self.text_channel.set_closed_callback( self._one_to_one_connection_closed_cb) self._chat_is_room = False self._alert(_('On-line'), _('Private chat.')) # XXX How do we detect the sender going offline? self._entry.set_sensitive(True) self._entry.props.placeholder_text = None self._entry.grab_focus() def _one_to_one_connection_closed_cb(self): '''Callback for when the text channel closes.''' self._alert(_('Off-line'), _('Left the chat.')) def _setup(self): self.text_channel = TextChannelWrapper( self.shared_activity.telepathy_text_chan, self.shared_activity.telepathy_conn) self.text_channel.set_received_callback(self._received_cb) self._alert(_('On-line'), _('Connected.')) self.shared_activity.connect('buddy-joined', self._buddy_joined_cb) self.shared_activity.connect('buddy-left', self._buddy_left_cb) self._chat_is_room = True self._entry.set_sensitive(True) self._entry.props.placeholder_text = None self._entry.grab_focus() def _joined_cb(self, sender): '''Joined a shared activity.''' if not self.shared_activity: return logger.debug('Joined a shared chat') for buddy in self.shared_activity.get_joined_buddies(): self._buddy_already_exists(buddy) self._setup() def _received_cb(self, buddy, text): '''Show message that was received.''' if buddy: if type(buddy) is dict: nick = buddy['nick'] else: nick = buddy.props.nick else: nick = '???' logger.debug('Received message from %s: %s', nick, text) self.chatbox.add_text(buddy, text) if self.owner.props.nick in text: self.play_sound('said_nick') ''' vscroll = self.chatbox.get_vadjustment() if vscroll.get_property('value') != vscroll.get_property('upper'): self._alert(_('New message'), _('New message from %s' % nick)) ''' if not self.has_focus: self.notify_user(_('Message from %s') % buddy, text) def _toolbar_expanded(self): if self._activity_toolbar_button.is_expanded(): return True return False def _alert(self, title, text=None): alert = NotifyAlert(timeout=5) alert.props.title = title alert.props.msg = text self.add_alert(alert) alert.connect('response', self._alert_cancel_cb) alert.show() self._has_alert = True self._fixed_resize_cb() def _alert_cancel_cb(self, alert, response_id): self.remove_alert(alert) self._has_alert = False self._fixed_resize_cb() def __open_on_journal(self, widget, url): '''Ask the journal to display a URL''' logger.debug('Create journal entry for URL: %s', url) jobject = datastore.create() metadata = { 'title': '%s: %s' % (_('URL from Chat'), url), 'title_set_by_user': '******', 'icon-color': profile.get_color().to_string(), 'mime_type': 'text/uri-list', } for k, v in list(metadata.items()): jobject.metadata[k] = v file_path = os.path.join(get_activity_root(), 'instance', '%i_' % time.time()) open(file_path, 'w').write(url + '\r\n') os.chmod(file_path, 0o755) jobject.set_file_path(file_path) datastore.write(jobject) show_object_in_journal(jobject.object_id) jobject.destroy() os.unlink(file_path) def _buddy_joined_cb(self, sender, buddy): '''Show a buddy who joined''' if buddy == self.owner: return self.chatbox.add_text(buddy, _('%s joined the chat') % buddy.props.nick, status_message=True) self.play_sound('login') def _buddy_left_cb(self, sender, buddy): '''Show a buddy who joined''' if buddy == self.owner: return self.chatbox.add_text(buddy, _('%s left the chat') % buddy.props.nick, status_message=True) self.play_sound('logout') def _buddy_already_exists(self, buddy): '''Show a buddy already in the chat.''' if buddy == self.owner: return self.chatbox.add_text(buddy, _('%s is here') % buddy.props.nick, status_message=True) def can_close(self): '''Perform cleanup before closing. Close text channel of a one to one XMPP chat. ''' if self._chat_is_room is False: if self.text_channel is not None: self.text_channel.close() return True def _make_entry_widgets(self): '''We need to create a button for the smiley, a text entry, and a send button. All of this, along with the chatbox, goes into a grid. --------------------------------------- | chat box | | smiley button | entry | send button | --------------------------------------- ''' if self._ebook_mode_detector.get_ebook_mode(): self._entry_height = int(style.GRID_CELL_SIZE * 1.5) else: self._entry_height = style.GRID_CELL_SIZE entry_width = Gdk.Screen.width() - \ 2 * (self._entry_height + style.GRID_CELL_SIZE) self._chat_height = Gdk.Screen.height() - self._entry_height - \ style.GRID_CELL_SIZE self._chat_width = Gdk.Screen.width() self.chatbox.set_size_request(self._chat_width, self._chat_height) self._entry_grid = Gtk.Grid() self._entry_grid.set_size_request( Gdk.Screen.width() - 2 * style.GRID_CELL_SIZE, self._entry_height) smiley_button = EventIcon(icon_name='smilies', pixel_size=self._entry_height) smiley_button.connect('button-press-event', self._smiley_button_cb) self._entry_grid.attach(smiley_button, 0, 0, 1, 1) smiley_button.show() self._entry = Gtk.Entry() self._entry.set_size_request(entry_width, self._entry_height) self._entry.modify_bg(Gtk.StateType.INSENSITIVE, style.COLOR_WHITE.get_gdk_color()) self._entry.modify_base(Gtk.StateType.INSENSITIVE, style.COLOR_WHITE.get_gdk_color()) self._entry.set_sensitive(False) self._entry.props.placeholder_text = \ _('You must be connected to a friend before starting to chat.') self._entry.connect('focus-in-event', self._entry_focus_in_cb) self._entry.connect('focus-out-event', self._entry_focus_out_cb) self._entry.connect('activate', self._entry_activate_cb) self._entry.connect('key-press-event', self._entry_key_press_cb) self._entry_grid.attach(self._entry, 1, 0, 1, 1) self._entry.show() send_button = EventIcon(icon_name='send', pixel_size=self._entry_height) send_button.connect('button-press-event', self._send_button_cb) self._entry_grid.attach(send_button, 2, 0, 1, 1) send_button.show() def _get_icon_pixbuf(self, name): icon_theme = Gtk.IconTheme.get_default() icon_info = icon_theme.lookup_icon(name, style.LARGE_ICON_SIZE, 0) pixbuf = GdkPixbuf.Pixbuf.new_from_file_at_size( icon_info.get_filename(), style.LARGE_ICON_SIZE, style.LARGE_ICON_SIZE) del icon_info return pixbuf def _entry_focus_in_cb(self, entry, event): self._hide_smiley_window() if self._ebook_mode_detector.get_ebook_mode(): self._has_osk = True self._fixed_resize_cb() def _entry_focus_out_cb(self, entry, event): if self._ebook_mode_detector.get_ebook_mode(): self._has_osk = False self._fixed_resize_cb() def _entry_key_press_cb(self, widget, event): '''Check for scrolling keys. Check if the user pressed Page Up, Page Down, Home or End and scroll the window according the pressed key. ''' vadj = self.chatbox.get_vadjustment() if event.keyval == Gdk.KEY_Page_Down: value = vadj.get_value() + vadj.page_size if value > vadj.upper - vadj.page_size: value = vadj.upper - vadj.page_size vadj.set_value(value) elif event.keyval == Gdk.KEY_Page_Up: vadj.set_value(vadj.get_value() - vadj.page_size) elif event.keyval == Gdk.KEY_Home and \ event.get_state() & Gdk.ModifierType.CONTROL_MASK: vadj.set_value(vadj.lower) elif event.keyval == Gdk.KEY_End and \ event.get_state() & Gdk.ModifierType.CONTROL_MASK: vadj.set_value(vadj.upper - vadj.page_size) def _smiley_button_cb(self, widget, event): self._show_smiley_window() def _send_button_cb(self, widget, event): self._entry_activate_cb(self._entry) def _entry_activate_cb(self, entry): self.chatbox._scroll_auto = True text = entry.props.text if text: logger.debug('Adding text to chatbox: %s: %s' % (self.owner, text)) self.chatbox.add_text(self.owner, text) entry.props.text = '' if self.text_channel: logger.debug('sending to text_channel: %s' % (text)) self.text_channel.send(text) else: logger.debug('Tried to send message but text channel ' 'not connected.') def write_file(self, file_path): '''Store chat log in Journal. Handling the Journal is provided by Activity - we only need to define this method. ''' logger.debug('write_file: writing %s' % file_path) self.chatbox.add_log_timestamp() f = open(file_path, 'w') try: f.write(self.chatbox.get_log()) finally: f.close() self.metadata['mime_type'] = 'text/plain' def read_file(self, file_path): '''Load a chat log from the Journal. Handling the Journal is provided by Activity - we only need to define this method. ''' logger.debug('read_file: reading %s' % file_path) log = open(file_path).readlines() last_line_was_timestamp = False for line in log: if line.endswith('\t\t\n'): if last_line_was_timestamp is False: timestamp = line.strip().split('\t')[0] self.chatbox.add_separator(timestamp) last_line_was_timestamp = True else: timestamp, nick, color, status, text = line.strip().split('\t') status_message = bool(int(status)) self.chatbox.add_text({ 'nick': nick, 'color': color }, text, status_message) last_line_was_timestamp = False def play_sound(self, event): if _HAS_SOUND: SOUNDS_PATH = os.path.join(get_bundle_path(), 'sounds') SOUNDS = { 'said_nick': os.path.join(SOUNDS_PATH, 'alert.wav'), 'login': os.path.join(SOUNDS_PATH, 'login.wav'), 'logout': os.path.join(SOUNDS_PATH, 'logout.wav') } self.element.set_state(Gst.State.NULL) self.element.set_property('uri', 'file://%s' % SOUNDS[event]) self.element.set_state(Gst.State.PLAYING) def _create_smiley_window(self): grid = Gtk.Grid() width = int(Gdk.Screen.width() - 2 * style.GRID_CELL_SIZE) self._smiley_toolbar = SmileyToolbar(self) height = style.GRID_CELL_SIZE self._smiley_toolbar.set_size_request(width, height) grid.attach(self._smiley_toolbar, 0, 0, 1, 1) self._smiley_toolbar.show() self._smiley_table = Gtk.ScrolledWindow() self._smiley_table.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC) self._smiley_table.modify_bg(Gtk.StateType.NORMAL, style.COLOR_BLACK.get_gdk_color()) if self._ebook_mode_detector.get_ebook_mode(): height = int(Gdk.Screen.height() - 8 * style.GRID_CELL_SIZE) else: height = int(Gdk.Screen.height() - 4 * style.GRID_CELL_SIZE) self._smiley_table.set_size_request(width, height) table = self._create_smiley_table(width) self._smiley_table.add_with_viewport(table) table.show_all() grid.attach(self._smiley_table, 0, 1, 1, 1) self._smiley_table.show() self._smiley_window = Gtk.ScrolledWindow() self._smiley_window.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.NEVER) self._smiley_window.set_shadow_type(Gtk.ShadowType.ETCHED_IN) self._smiley_window.set_size_request(width, -1) self._smiley_window.add_with_viewport(grid) def _key_press_event_cb(widget, event): if event.keyval == Gdk.KEY_Escape: self._hide_smiley_window() return True return False self.connect('key-press-event', _key_press_event_cb) grid.show() self._fixed.put(self._smiley_window, style.GRID_CELL_SIZE, 0) def _show_smiley_window(self): if not hasattr(self, '_smiley_window'): self.busy() self._create_smiley_window() self._smiley_window.show() def _hide_smiley_window(self): if hasattr(self, '_smiley_window'): self._smiley_window.hide()
class PeterActivity(activity.Activity): LOWER = 0 UPPER = 400 def __init__(self, handle): super(PeterActivity, self).__init__(handle) # Get user's Sugar colors sugarcolors = profile.get_color().to_string().split(',') colors = [[ int(sugarcolors[0][1:3], 16), int(sugarcolors[0][3:5], 16), int(sugarcolors[0][5:7], 16) ], [ int(sugarcolors[1][1:3], 16), int(sugarcolors[1][3:5], 16), int(sugarcolors[1][5:7], 16) ]] # No sharing self.max_participants = 1 # Build the activity toolbar. toolbox = ToolbarBox() activity_button = ActivityToolbarButton(self) toolbox.toolbar.insert(activity_button, 0) activity_button.show() self._add_speed_slider(toolbox.toolbar) cyan = ToolButton('cyan') toolbox.toolbar.insert(cyan, -1) cyan.set_tooltip(_('Next pattern')) cyan.connect('clicked', self._button_cb, 'cyan') cyan.set_sensitive(False) cyan.show() green = ToolButton('green') toolbox.toolbar.insert(green, -1) green.set_tooltip(_('Draw')) green.connect('clicked', self._button_cb, 'green') green.show() red = ToolButton('red') toolbox.toolbar.insert(red, -1) red.set_tooltip(_('Stop')) red.connect('clicked', self._button_cb, 'red') red.show() separator = Gtk.SeparatorToolItem() separator.props.draw = True toolbox.toolbar.insert(separator, -1) separator.show() label = Gtk.Label('') label.set_use_markup(True) label.show() labelitem = Gtk.ToolItem() labelitem.add(label) toolbox.toolbar.insert(labelitem, -1) labelitem.show() separator = Gtk.SeparatorToolItem() separator.props.draw = False separator.set_expand(True) toolbox.toolbar.insert(separator, -1) separator.show() stop_button = StopButton(self) stop_button.props.accelerator = _('<Ctrl>Q') toolbox.toolbar.insert(stop_button, -1) stop_button.show() toolbox.show() self.set_toolbar_box(toolbox) # Create the game instance. self.game = Spirolaterals.Spirolaterals(colors) # Build the Pygame canvas. self._pygamecanvas = \ sugargame.canvas.PygameCanvas(self) # Note that set_canvas implicitly calls # read_file when resuming from the Journal. self.set_canvas(self._pygamecanvas) self.game.canvas = self._pygamecanvas Gdk.Screen.get_default().connect('size-changed', self.__configure_cb) # Start the game running. self.game.set_cyan_button(cyan) self.game.set_label(label) self._speed_range.set_value(200) self._pygamecanvas.run_pygame(self.game.run) def get_preview(self): return self._pygamecanvas.get_preview() def __configure_cb(self, event): ''' Screen size has changed ''' logging.debug(self._pygamecanvas.get_allocation()) pygame.display.set_mode( (Gdk.Screen.width(), Gdk.Screen.height() - GRID_CELL_SIZE), pygame.RESIZABLE) self.game.save_pattern() self.game.g_init() self._speed_range.set_value(200) self.game.run(restore=True) def read_file(self, file_path): try: f = open(file_path, 'r') except Exception as e: logging.debug('Error opening %s: %s' % (file_path, e)) return load_save.load(f) f.close() def write_file(self, file_path): f = open(file_path, 'w') load_save.save(f) f.close() def _button_cb(self, button=None, color=None): self.game.do_button(color) def _add_speed_slider(self, toolbar): self._speed_stepper_down = ToolButton('speed-down') self._speed_stepper_down.set_tooltip(_('Slow down')) self._speed_stepper_down.connect('clicked', self._speed_stepper_down_cb) self._speed_stepper_down.show() self._adjustment = Gtk.Adjustment.new(200, self.LOWER, self.UPPER, 25, 100, 0) self._adjustment.connect('value_changed', self._speed_change_cb) self._speed_range = Gtk.HScale.new(self._adjustment) self._speed_range.set_inverted(True) self._speed_range.set_draw_value(False) self._speed_range.set_size_request(120, 15) self._speed_range.show() self._speed_stepper_up = ToolButton('speed-up') self._speed_stepper_up.set_tooltip(_('Speed up')) self._speed_stepper_up.connect('clicked', self._speed_stepper_up_cb) self._speed_stepper_up.show() self._speed_range_tool = Gtk.ToolItem() self._speed_range_tool.add(self._speed_range) self._speed_range_tool.show() toolbar.insert(self._speed_stepper_down, -1) toolbar.insert(self._speed_range_tool, -1) toolbar.insert(self._speed_stepper_up, -1) return def _speed_stepper_down_cb(self, button=None): new_value = self._speed_range.get_value() + 25 if new_value <= self.UPPER: self._speed_range.set_value(new_value) else: self._speed_range.set_value(self.UPPER) def _speed_stepper_up_cb(self, button=None): new_value = self._speed_range.get_value() - 25 if new_value >= self.LOWER: self._speed_range.set_value(new_value) else: self._speed_range.set_value(self.LOWER) def _speed_change_cb(self, button=None): logging.debug(self._adjustment.get_value()) self.game.do_slider(self._adjustment.get_value()) return True
def ui_init(self): self._fullscreen = False self._showing_info = False # FIXME: if _thumb_tray becomes some kind of button group, we wouldn't # have to track which recd is active self._active_recd = None self.connect('key-press-event', self._key_pressed) self._active_toolbar_idx = 0 toolbar_box = ToolbarBox() self._activity_toolbar_button = ActivityToolbarButton(self) toolbar_box.toolbar.insert(self._activity_toolbar_button, 0) self.set_toolbar_box(toolbar_box) self._toolbar = self.get_toolbar_box().toolbar tool_group = None if self.model.get_cameras(): self._photo_button = RadioToolButton() self._photo_button.props.group = tool_group tool_group = self._photo_button self._photo_button.props.icon_name = 'camera-external' self._photo_button.props.label = _('Photo') self._photo_button.props.accelerator = '<ctrl>1' self._photo_button.props.tooltip = _( 'Picture camera mode\n\n' 'When the record button is pressed,\n' 'take one picture from the camera.') self._photo_button.mode = constants.MODE_PHOTO self._photo_button.connect('clicked', self._mode_button_clicked) self._toolbar.insert(self._photo_button, -1) self._video_button = RadioToolButton() self._video_button.props.group = tool_group self._video_button.props.icon_name = 'media-video' self._video_button.props.accelerator = '<ctrl>2' self._video_button.props.label = _('Video') self._video_button.props.tooltip = _( 'Video camera mode\n\n' 'When the record button is pressed,\n' 'take photographs many times a second,\n' 'and record sound using the microphone,\n' 'until the button is pressed again.') self._video_button.mode = constants.MODE_VIDEO self._video_button.connect('clicked', self._mode_button_clicked) self._toolbar.insert(self._video_button, -1) else: self._photo_button = None self._video_button = None self._audio_button = RadioToolButton() self._audio_button.props.group = tool_group self._audio_button.props.icon_name = 'media-audio' self._audio_button.props.accelerator = '<ctrl>3' self._audio_button.props.label = _('Audio') self._audio_button.props.tooltip = _( 'Audio recording mode\n\n' 'When the record button is pressed,\n' 'take one photograph,\n' 'and record sound using the microphone,\n' 'until the button is pressed again.') self._audio_button.mode = constants.MODE_AUDIO self._audio_button.connect('clicked', self._mode_button_clicked) self._toolbar.insert(self._audio_button, -1) self._toolbar.insert(Gtk.SeparatorToolItem(), -1) self._mirror_btn = ToggleToolButton('mirror-horizontal') self._mirror_btn.set_tooltip(_( 'Mirror view\n\n' 'Swap left for right, as if looking at a mirror.\n' 'Does not affect recording.')) self._mirror_btn.props.accelerator = '<ctrl>m' self._mirror_btn.show() self._mirror_btn.connect('toggled', self.__mirror_toggled_cb) self._toolbar.insert(self._mirror_btn, -1) self._toolbar_controls = RecordControl(self._toolbar) if self.model.get_cameras() and len(self.model.get_cameras()) > 1: switch_camera_btn = ToolButton('switch-camera') switch_camera_btn.set_tooltip(_('Switch camera')) switch_camera_btn.show() switch_camera_btn.connect('clicked', self.__switch_camera_click_cb) self._toolbar.insert(switch_camera_btn, -1) separator = Gtk.SeparatorToolItem() separator.props.draw = False separator.set_expand(True) self._toolbar.insert(separator, -1) self._toolbar.insert(StopButton(self), -1) self.get_toolbar_box().show_all() self._media_view = MediaView() self._media_view.connect('media-clicked', self._media_view_media_clicked) self._media_view.connect('pip-clicked', self._media_view_pip_clicked) self._media_view.connect('info-clicked', self._media_view_info_clicked) self._media_view.connect('fullscreen-clicked', self._media_view_fullscreen_clicked) self._media_view.connect('tags-changed', self._media_view_tags_changed) self._media_view.show() self._controls_hbox = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL) trim_height_shutter_button = 7 self._controls_hbox.set_size_request(-1, style.GRID_CELL_SIZE + trim_height_shutter_button) self._shutter_button = ShutterButton() self._shutter_button.connect("clicked", self._shutter_clicked) self._shutter_button.modify_bg(Gtk.StateType.NORMAL, COLOR_BLACK) self._controls_hbox.pack_start(self._shutter_button, True, False, 0) self._countdown_image = CountdownImage() self._controls_hbox.pack_start(self._countdown_image, True, False, 0) self._play_button = PlayButton() self._play_button.connect('clicked', self._play_pause_clicked) self._controls_hbox.pack_start(self._play_button, False, True, 0) self._playback_scale = PlaybackScale(self.model) self._controls_hbox.pack_start(self._playback_scale, True, True, 0) self._progress = ProgressInfo() self._controls_hbox.pack_start(self._progress, True, True, 0) self._title_label = Gtk.Label() self._title_label.set_markup("<b><span foreground='white'>" + _('Title:') + '</span></b>') self._controls_hbox.pack_start(self._title_label, False, True, 0) self._title_entry = Gtk.Entry() self._title_entry.modify_bg(Gtk.StateType.INSENSITIVE, COLOR_BLACK) self._title_entry.connect('changed', self._title_changed) self._controls_hbox.pack_start(self._title_entry, expand=True, fill=True, padding=10) self._controls_hbox.show() height_tray = 150 # height of tray self._thumb_tray = HTray(hexpand=True, height_request=height_tray) self._thumb_tray.show() height = Gdk.Screen.height() - style.GRID_CELL_SIZE * 2 - \ height_tray - trim_height_shutter_button self._media_view.set_size_request(-1, height) self._grid = Gtk.Grid(orientation=Gtk.Orientation.VERTICAL) self._media_view.props.hexpand = True self._media_view.props.vexpand = True for row in [self._media_view, self._controls_hbox, self._thumb_tray]: self._grid.add(row) self._grid.modify_bg(Gtk.StateType.NORMAL, COLOR_BLACK) self._grid.show() self.set_canvas(self._grid)
class ToolbarSpeed(Gtk.Toolbar): __gsignals__ = { "speed-changed": (GObject.SIGNAL_RUN_FIRST, None, [float]), } def __init__(self): Gtk.Toolbar.__init__(self) self.button = ToolbarButton(page=self, icon_name="media-playback-stop") self.playing = True self.speed = None self.stop_play = ToolButton("media-playback-stop") self.stop_play.set_tooltip(_("Stop")) self.stop_play.connect("clicked", self._stop_play) self.insert(self.stop_play, -1) self.slow_button = RadioToolButton(group=None, icon_name="slow-walk-milton-raposo") self.slow_button.set_tooltip(_("Run slow")) self.slow_button.connect("clicked", self._speed_changed_cb, Speed.SLOW) self.insert(self.slow_button, -1) self.normal_button = RadioToolButton(group=self.slow_button, icon_name="walking") self.normal_button.set_tooltip(_("Run Normal")) self.normal_button.connect("clicked", self._speed_changed_cb, Speed.NORMAL) self.insert(self.normal_button, -1) self.fast_button = RadioToolButton(group=self.slow_button, icon_name="running") self.fast_button.set_tooltip(_("Run fast")) self.fast_button.connect("clicked", self._speed_changed_cb, Speed.FAST) self.insert(self.fast_button, -1) self.slow_button.set_active(True) self.show_all() def _stop_play(self, button=None): self.playing = not self.playing if self.playing: self.stop_play.set_icon_name("media-playback-stop") self.stop_play.set_tooltip(_("Stop")) self.button.set_icon_name("media-playback-stop") if self.speed is None: self.speed = Speed.SLOW self.emit("speed-changed", self.speed) else: self.stop_play.set_icon_name("media-playback-start") self.stop_play.set_tooltip(_("Start")) self.button.set_icon_name("media-playback-start") self.emit("speed-changed", Speed.STOPPED) def _speed_changed_cb(self, button, speed): if not self.playing: self.speed = speed self._stop_play() else: self.emit("speed-changed", speed) self.speed = speed def enable(self): self.set_sensitive_buttons(True) def disable(self): self.set_sensitive_buttons(False) def set_sensitive_buttons(self, sensitive): self.stop_play.set_sensitive(sensitive) self.slow_button.set_sensitive(sensitive) self.normal_button.set_sensitive(sensitive) self.fast_button.set_sensitive(sensitive)
class ToolbarBox(SugarToolbarBox): __gsignals__ = { "show-simulation": (GObject.SIGNAL_RUN_FIRST, None, []), "show-info": (GObject.SIGNAL_RUN_FIRST, None, []), "go-back": (GObject.SIGNAL_RUN_FIRST, None, []), "go-forward": (GObject.SIGNAL_RUN_FIRST, None, []), "show-orbits": (GObject.SIGNAL_RUN_FIRST, None, [bool]), "show-body": (GObject.SIGNAL_RUN_FIRST, None, [int, bool]), "speed-changed": (GObject.SIGNAL_RUN_FIRST, None, [float]), "zoom-changed": (GObject.SIGNAL_RUN_FIRST, None, [float]), } def __init__(self, activity): SugarToolbarBox.__init__(self) activity_button = ActivityToolbarButton(activity) self.toolbar.insert(activity_button, -1) self.toolbar.insert(make_separator(False), -1) self.toolbar_info = ToolbarInfo() self.toolbar_info.connect("show-simulation", self._show_simulation_cb) self.toolbar_info.connect("show-info", self._show_info_cb) self.toolbar_info.connect("go-back", self._go_back_cb) self.toolbar_info.connect("go-forward", self._go_forward_cb) self.toolbar.insert(self.toolbar_info.button, -1) self.toolbar_view = ToolbarView() self.toolbar_view.connect("show-orbits", self._show_orbits_cb) self.toolbar_view.connect("show-body", self._show_body_cb) self.toolbar.insert(self.toolbar_view.button, -1) self.toolbar_speed = ToolbarSpeed() self.toolbar_speed.connect("speed-changed", self._speed_changed_cb) self.toolbar.insert(self.toolbar_speed.button, -1) self.toolbar.insert(make_separator(False), -1) adj = Gtk.Adjustment(16.5, 0.8, 75, 0.5, 1) self.zoom_scale = Gtk.HScale() self.zoom_scale.set_draw_value(False) self.zoom_scale.set_adjustment(adj) self.zoom_scale.set_size_request(200, 1) self.zoom_scale.connect("value-changed", self._zoom_changed_cb) self.zoom_out = ToolButton("zoom-out") self.zoom_out.set_tooltip(_("Zoom out")) self.zoom_out.connect("clicked", self._zoom_out_cb) self.toolbar.insert(self.zoom_out, -1) item = Gtk.ToolItem() item.add(self.zoom_scale) self.toolbar.insert(item, -1) self.zoom_in = ToolButton("zoom-in") self.zoom_in.set_tooltip(_("Zoom in")) self.zoom_in.connect("clicked", self._zoom_in_cb) self.toolbar.insert(self.zoom_in, -1) self.toolbar.insert(make_separator(True), -1) help_button = HelpButton() self.toolbar.insert(help_button, -1) stop_button = StopButton(activity) self.toolbar.insert(stop_button, -1) self.make_help(help_button) def make_help(self, button): button.add_section(_("What is the Solar System activity?")) button.add_paragraph(_("The Solar System activity is a tool to encourage children\n") +\ _("to learn more about the planets and their moons (natural satellites).\n") +\ _("It is my hope that this tool serves as a practical and interactve\n") +\ _("way to explore astronomy.\n")) button.add_section(_("About scales")) button.add_paragraph(_("The planets radius are on a scale with each other,\n") +\ _("but not with respect to distances (which in turn,\n") +\ _("are on scale with each other), and the Sun radius\n") +\ _("does not respect either of the two scales.\n")) button.add_section(_("Why did I make that decision?")) button.add_paragraph(_("Just because if I kept all the distances to the\n") +\ _("same scale, you could not see anything (due to the\n") +\ _("immense size of the space).")) def set_can_back_back(self, can): self.toolbar_info.button_back.set_sensitive(can) def set_can_go_forward(self, can): self.toolbar_info.forward_button.set_sensitive(can) def disable_simulation_widgets(self): self.zoom_scale.set_sensitive(False) self.zoom_out.set_sensitive(False) self.zoom_in.set_sensitive(False) self.toolbar_view.disable_simulation_widgets() self.toolbar_speed.disable() def enable_simulation_widgets(self): self.zoom_scale.set_sensitive(True) self.zoom_out.set_sensitive(True) self.zoom_in.set_sensitive(True) self.toolbar_view.enable_simulation_widgets() self.toolbar_speed.enable() def _zoom_out_cb(self, widget): new_value = self.zoom_scale.get_value() - 2.5 lower_value = self.zoom_scale.get_adjustment().get_lower() if new_value < lower_value: self.zoom_scale.set_value(lower_value) else: self.zoom_scale.set_value(new_value) def _zoom_in_cb(self, widget): new_value = self.zoom_scale.get_value() + 2.5 upper = self.zoom_scale.get_adjustment().get_upper() if new_value > upper: self.zoom_scale.set_value(upper) else: self.zoom_scale.set_value(new_value) def _show_simulation_cb(self, widget): self.emit("show-simulation") def _show_info_cb(self, widget): self.emit("show-info") def _go_back_cb(self, widget): self.emit("go-back") def _go_forward_cb(self, widget): self.emit("go-forward") def _speed_changed_cb(self, toolbar, speed): self.emit("speed-changed", speed) def _show_orbits_cb(self, toolbar, show): self.emit("show-orbits", show) def _show_body_cb(self, toolbar, body, show): self.emit("show-body", body, show) def _zoom_changed_cb(self, scale): self.emit("zoom-changed", self.zoom_scale.get_value()) def select_screen(self, screen): self.toolbar_info.select_screen(screen) def set_can_go_forward(self, can): self.toolbar_info.forward_button.set_sensitive(can) def set_can_go_back(self, can): self.toolbar_info.back_button.set_sensitive(can)
def build_toolbar(self): toolbar_box = ToolbarBox() activity_button = ActivityToolbarButton(self) toolbar_box.toolbar.insert(activity_button, -1) activity_button.show() barra = toolbar_box.toolbar separador1 = Gtk.SeparatorToolItem() separador1.props.draw = True barra.insert(separador1, 1) item1 = Gtk.ToolItem() self.label_radio1 = Gtk.Label() self.label_radio1.set_text(_('Circles between') + ' ') item1.add(self.label_radio1) barra.insert(item1, 2) grayed = Gdk.Color(20000.0, 20000.0, 20000.0) item2 = Gtk.ToolItem() self.cradio1 = Gtk.SpinButton() self.cradio1.modify_bg(Gtk.StateType.NORMAL, grayed) self.cradio1.set_range(1, 20) self.cradio1.set_increments(1, 2) self.cradio1.props.value = self.radio_uno self.cradio1_handler = self.cradio1.connect('notify::value', self.cradio1_valor) item2.add(self.cradio1) barra.insert(item2, 3) item3 = Gtk.ToolItem() self.label_and = Gtk.Label() self.label_and.set_text(' ' + _('and') + ' ') item3.add(self.label_and) barra.insert(item3, 4) item4 = Gtk.ToolItem() self.cradio2 = Gtk.SpinButton() self.cradio2.modify_bg(Gtk.StateType.NORMAL, grayed) self.cradio2.set_range(1, 20) self.cradio2.set_increments(1, 2) self.cradio2.props.value = self.radio_dos self.cradio2_handler = self.cradio2.connect('notify::value', self.cradio2_valor) item4.add(self.cradio2) barra.insert(item4, 5) separator1 = Gtk.SeparatorToolItem() separator1.props.draw = True separator1.set_expand(False) barra.insert(separator1, 6) save_button = ToolButton('filesave') save_button.set_tooltip(_('Save Image')) save_button.connect('clicked', self._savebutton_cb) barra.insert(save_button, 7) save_button.show() separator2 = Gtk.SeparatorToolItem() separator2.props.draw = False separator2.set_expand(True) barra.insert(separator2, 8) stop_button = StopButton(self) stop_button.props.accelerator = '<Ctrl>q' barra.insert(stop_button, 9) stop_button.show() self.set_toolbar_box(toolbar_box) toolbar_box.show_all()
class WeatherActivity(activity.Activity): """WeatherActivity class as specified in activity.info""" def __init__(self, handle): """Set up the Weather activity.""" activity.Activity.__init__(self, handle) # we do not have collaboration features # make the share option insensitive self.max_participants = 1 self.wind_scale = 'm/s' self.pressure_scale = 'hPa' self.humidity_scale = '%' self.cloud_scale = '%' self.temp_scale = 'K' self.input = '' self.selected_city = None self.temp_scales = { 'Kelvin': 'K', 'Celcius': u'\u00b0C'.encode('utf-8'), 'Farenheit': u'\u00b0F'.encode('utf-8') } # view toolbar view_toolbar = Gtk.Toolbar() toolbar_box = ToolbarBox() activity_button = ActivityToolbarButton(self) toolbar_box.toolbar.insert(activity_button, 0) activity_button.show() temp_label = Gtk.Label(_('Temperature:')) temp_label.show() temp_label_item = Gtk.ToolItem() temp_label_item.add(temp_label) temp_label_item.show() temp_scale_store = Gtk.ListStore(str) for key in self.temp_scales.keys(): temp_scale_store.append([key]) self.temp_scale_combo = Gtk.ComboBox.new_with_model(temp_scale_store) renderer_text = Gtk.CellRendererText() self.temp_scale_combo.pack_start(renderer_text, True) self.temp_scale_combo.add_attribute(renderer_text, 'text', 0) self.temp_scale_combo.connect('changed', self.temp_scale_combo_toggled) self.temp_scale_combo.show() temp_scale_combo_item = ToolComboBox(self.temp_scale_combo) temp_scale_combo_item.show() view_toolbar.insert(temp_label_item, -1) view_toolbar.insert(temp_scale_combo_item, -1) view_toolbar.show() view_toolbar_button = ToolbarButton(icon_name='toolbar-view', page=view_toolbar) toolbar_box.toolbar.insert(view_toolbar_button, -1) view_toolbar_button.show() # toolbar separator = Gtk.SeparatorToolItem() toolbar_box.toolbar.insert(separator, -1) separator.set_draw(False) separator.set_expand(True) separator.show() self.search_entry = iconentry.IconEntry() self.search_entry.connect('key-press-event', self.entry_key_press_cb) self.search_entry.connect('icon-press', self.refresh) self.search_entry.show() self.search_entry_item = Gtk.ToolItem() self.search_entry_item.set_size_request(SCREEN_WIDTH / 3, -1) self.search_entry_item.add(self.search_entry) toolbar_box.toolbar.insert(self.search_entry_item, -1) self.search_entry_item.show() self.back_button = ToolButton('go-previous-paired') self.back_button.connect('clicked', self.back_button_clicked) self.back_button.set_sensitive(False) self.back_button.set_tooltip(_('Back')) toolbar_box.toolbar.insert(self.back_button, -1) self.back_button.show() self.forecast_button = ToolButton('go-next-paired') self.forecast_button.connect('clicked', self.forecast_button_clicked) self.forecast_button.set_sensitive(False) self.forecast_button.set_tooltip(_('Forecast')) toolbar_box.toolbar.insert(self.forecast_button, -1) self.forecast_button.show() separator = Gtk.SeparatorToolItem() toolbar_box.toolbar.insert(separator, -1) separator.set_draw(False) separator.set_expand(True) separator.show() stop_button = StopButton(self) toolbar_box.toolbar.insert(stop_button, -1) stop_button.show() self.set_toolbar_box(toolbar_box) toolbar_box.show() # set up screen self.search_screen = searchscreen.SearchScreen(self) self.forecast_screen = forecastscreen.ForecastScreen(self) self.screen = self.search_screen howto_label = Gtk.Label() howto_label.set_justify(Gtk.Justification.CENTER) howto_label.set_markup(howto) howto_label.show() world_image = Gtk.Image() world_image.modify_bg(Gtk.StateType.NORMAL, Gdk.Color.parse(GREY)[1]) pixbuf = GdkPixbuf.Pixbuf.new_from_file('world.svg') scaled_pixbuf = pixbuf.scale_simple(SCREEN_WIDTH, SCREEN_HEIGHT - 170, GdkPixbuf.InterpType.BILINEAR) world_image.set_from_pixbuf(scaled_pixbuf) world_image.show() box = Gtk.Box() box.set_orientation(Gtk.Orientation.VERTICAL) box.pack_start(howto_label, expand=True, fill=False, padding=0) box.pack_start(world_image, expand=True, fill=True, padding=0) box.show() self.set_canvas(box) self.temp_scale_combo.set_active(1) self.search_entry.grab_focus() def _alert_confirmation(self): alert = ConfirmationAlert() alert.remove_button(Gtk.ResponseType.CANCEL) alert.props.title = (_('Download Error')) alert.props.msg = (_('There was a problem with the download')) alert.connect('response', self._alert_response) self.add_alert(alert) def _alert_response(self, alert, response_id): self.remove_alert(alert) def entry_key_press_cb(self, widget, event): keyname = Gdk.keyval_name(event.keyval) if keyname == 'Return': self.set_focus(None) self.input = widget.get_text() self.search_screen.search() self.screen = self.search_screen def read_file(self, file): data = open(file, 'r') try: text = data.read() dict = json.loads(text) return dict finally: data.close() def add_download(self, source, dest): self.search_entry.set_progress_fraction(0.2) gobject.idle_add(self.download, source, dest) def download(self, source, dest): id = '43ae262450afb936759b9e905323c7e5' url = 'http://api.openweathermap.org/data/2.5/%s&APPID=%s' % (source, id) _logger.debug(url) downloader = ReadURLDownloader(url) downloader.connect("error", self._alert_confirmation) downloader.connect("progress", self.get_download_progress) downloader.connect("finished", self.download_complete) try: downloader.start(dest) except: _logger.debug('download error') self._alert_confirmation() self.download_size = downloader.get_content_length() self.download_type = downloader.get_content_type() _logger.debug('size ' + str(self.download_size)) _logger.debug('type ' + str(self.download_type) + '\n') def download_complete(self, downloader, file_path, file_name): self.search_entry.set_progress_fraction(0) file_type = self.download_type if file_type.startswith('text/html') or self.download_size < 1: _logger.debug('corrupt download') self._alert_confirmation() else: if self.read_file(file_path)['cod'] == '200': self.screen.download_complete(downloader, file_path, file_name) self.screen.display_results() self.show_refresh_button() def get_download_progress(self, downloader, bytes_downloaded): if self.download_size: self.update_progressbar(bytes_downloaded, self.download_size) while Gtk.events_pending(): Gtk.main_iteration() def update_progressbar(self, bytes, total): fraction = self.search_entry.get_progress_fraction() + \ (float(bytes) / float(total)) self.search_entry.set_progress_fraction(fraction) def back_button_clicked(self, widget): self.search_screen.display_results() widget.set_sensitive(False) self.forecast_button.set_sensitive(False) self.screen = self.search_screen self.set_canvas(self.screen) def forecast_button_clicked(self, widget): self.forecast_screen.get_daily_forecast() widget.set_sensitive(False) self.back_button.set_sensitive(True) self.screen = self.forecast_screen def show_refresh_button(self): self.search_entry.set_icon_from_name(iconentry.ICON_ENTRY_SECONDARY, 'refresh') def refresh(self, entry, icon_pos, button): self.set_focus(None) screen = self.get_canvas() screen.refresh() def temp_scale_combo_toggled(self, combo): tree_iter = combo.get_active_iter() if tree_iter != None: model = combo.get_model() scale = model[tree_iter][0] self.temp_scale = self.temp_scales[scale] self.screen.display_results() def convert(self, kelvin): if self.temp_scale == self.temp_scales['Celcius']: temp = kelvin - 273.15 elif self.temp_scale == self.temp_scales['Farenheit']: temp = (kelvin * Fraction(9, 5)) - 459.67 else: temp = kelvin return round(temp, 1) def select_city(self, city): self.selected_city = city self.forecast_button.set_sensitive(True)
class PeterActivity(activity.Activity): LOWER = 0 UPPER = 800 def __init__(self, handle): super(PeterActivity, self).__init__(handle) # Get user's Sugar colors sugarcolors = profile.get_color().to_string().split(',') colors = [[ int(sugarcolors[0][1:3], 16), int(sugarcolors[0][3:5], 16), int(sugarcolors[0][5:7], 16) ], [ int(sugarcolors[1][1:3], 16), int(sugarcolors[1][3:5], 16), int(sugarcolors[1][5:7], 16) ]] # No sharing self.max_participants = 1 # Build the activity toolbar. toolbox = ToolbarBox() activity_button = ActivityToolbarButton(self) toolbox.toolbar.insert(activity_button, 0) activity_button.show() self._add_speed_slider(toolbox.toolbar) green = ToolButton('green') toolbox.toolbar.insert(green, -1) green.set_tooltip(_('Start')) green.connect('clicked', self._button_cb, 'green') green.show() back = ToolButton('back') toolbox.toolbar.insert(back, -1) back.set_tooltip(_('Repeat')) back.connect('clicked', self._button_cb, 'back') back.show() separator = Gtk.SeparatorToolItem() separator.props.draw = False separator.set_expand(True) toolbox.toolbar.insert(separator, -1) separator.show() stop = StopButton(self) toolbox.toolbar.insert(stop, -1) stop.show() toolbox.show() self.set_toolbar_box(toolbox) # Create the game instance. self.game = FollowMe.FollowMe(colors, sugar=True) # Build the Pygame canvas. self.game.canvas =\ sugargame.canvas.PygameCanvas(self, main=self.game.run, modules=[pygame.display, pygame.font]) # Note that set_canvas implicitly calls # read_file when resuming from the Journal. self.set_canvas(self.game.canvas) Gdk.Screen.get_default().connect('size-changed', self.__configure_cb) self.game.set_buttons(green, back) # Start the game running. def get_preview(self): return self.game.canvas.get_preview() def __configure_cb(self, event): ''' Screen size has changed ''' logging.debug(self.game.canvas.get_allocation()) pygame.display.set_mode( (Gdk.Screen.width(), Gdk.Screen.height() - GRID_CELL_SIZE), pygame.RESIZABLE) self.game.save_pattern() self.game.g_init() self._speed_range.set_value(800) def read_file(self, file_path): try: f = open(file_path, 'r') except Exception as e: logging.error('Could not open %s: %s' % (file_path, e)) return load_save.load(f) f.close() def write_file(self, file_path): f = open(file_path, 'w') load_save.save(f) f.close() def _button_cb(self, button=None, color=None): self.game.do_button(color) def _add_speed_slider(self, toolbar): self._speed_stepper_down = ToolButton('speed-down') self._speed_stepper_down.set_tooltip(_('Slow down')) self._speed_stepper_down.connect('clicked', self._speed_stepper_down_cb) self._speed_stepper_down.show() self._adjustment = Gtk.Adjustment.new(800, self.LOWER, self.UPPER, 50, 200, 0) self._adjustment.connect('value_changed', self._speed_change_cb) self._speed_range = Gtk.HScale.new(self._adjustment) self._speed_range.set_inverted(True) self._speed_range.set_draw_value(False) self._speed_range.set_size_request(120, 15) self._speed_range.show() self._speed_stepper_up = ToolButton('speed-up') self._speed_stepper_up.set_tooltip(_('Speed up')) self._speed_stepper_up.connect('clicked', self._speed_stepper_up_cb) self._speed_stepper_up.show() self._speed_range_tool = Gtk.ToolItem() self._speed_range_tool.add(self._speed_range) self._speed_range_tool.show() toolbar.insert(self._speed_stepper_down, -1) toolbar.insert(self._speed_range_tool, -1) toolbar.insert(self._speed_stepper_up, -1) return def _speed_stepper_down_cb(self, button=None): new_value = self._speed_range.get_value() + 25 if new_value <= self.UPPER: self._speed_range.set_value(new_value) else: self._speed_range.set_value(self.UPPER) def _speed_stepper_up_cb(self, button=None): new_value = self._speed_range.get_value() - 25 if new_value >= self.LOWER: self._speed_range.set_value(new_value) else: self._speed_range.set_value(self.LOWER) def _speed_change_cb(self, button=None): logging.debug(self._adjustment.get_value()) self.game.set_delay(self._adjustment.get_value()) return True
def _setup_toolbars(self): ''' Setup the toolbars. ''' self._toolbox = ToolbarBox() self.activity_button = ActivityToolbarButton(self) self.activity_button.connect('clicked', self._resize_canvas) self._toolbox.toolbar.insert(self.activity_button, 0) self.activity_button.show() self.set_toolbar_box(self._toolbox) self._toolbox.show() self.toolbar = self._toolbox.toolbar view_toolbar = Gtk.Toolbar() self.view_toolbar_button = ToolbarButton(page=view_toolbar, label=_('View'), icon_name='toolbar-view') self.view_toolbar_button.connect('clicked', self._resize_canvas) self._toolbox.toolbar.insert(self.view_toolbar_button, 1) view_toolbar.show() self.view_toolbar_button.show() button = ToolButton('view-fullscreen') button.set_tooltip(_('Fullscreen')) button.props.accelerator = '<Alt>Return' view_toolbar.insert(button, -1) button.show() button.connect('clicked', self._fullscreen_cb) edit_toolbar = Gtk.Toolbar() self.edit_toolbar_button = ToolbarButton(page=edit_toolbar, label=_('Edit'), icon_name='toolbar-edit') self.edit_toolbar_button.connect('clicked', self._resize_canvas) self._toolbox.toolbar.insert(self.edit_toolbar_button, 1) edit_toolbar.show() self.edit_toolbar_button.show() self._copy_button = ToolButton('edit-copy') self._copy_button.set_tooltip(_('Copy')) self._copy_button.props.accelerator = '<Ctrl>C' edit_toolbar.insert(self._copy_button, -1) self._copy_button.show() self._copy_button.connect('clicked', self._copy_cb) self._copy_button.set_sensitive(False) self._paste_button = ToolButton('edit-paste') self._paste_button.set_tooltip(_('Paste')) self._paste_button.props.accelerator = '<Ctrl>V' edit_toolbar.insert(self._paste_button, -1) self._paste_button.show() self._paste_button.connect('clicked', self._paste_cb) self._paste_button.set_sensitive(False) button = ToolButton('list-add') button.set_tooltip(_('Add Item')) button.props.accelerator = '<Ctrl>+' self._toolbox.toolbar.insert(button, -1) button.show() button.connect('clicked', self.__add_item_cb) self._date_button = RadioToolButton('date-sort', group=None) self._date_button.set_tooltip(_('Sort by Date')) self._date_button.connect('clicked', self._date_button_cb) self._toolbox.toolbar.insert(self._date_button, -1) self._date_button.show() self._title_button = RadioToolButton('title-sort', group=self._date_button) self._title_button.set_tooltip(_('Sort by Title')) self._title_button.connect('clicked', self._title_button_cb) self._toolbox.toolbar.insert(self._title_button, -1) self._title_button.show() self._stars_button = RadioToolButton('stars-sort', group=self._date_button) self._stars_button.set_tooltip(_('Sort by Favourite')) self._stars_button.connect('clicked', self._stars_button_cb) self._toolbox.toolbar.insert(self._stars_button, -1) self._stars_button.show() # setup the search options self._search_entry = iconentry.IconEntry() self._search_entry.set_icon_from_name(iconentry.ICON_ENTRY_PRIMARY, 'system-search') self._search_entry.connect('activate', self._search_entry_activated_cb) self._search_entry.connect('changed', self._search_entry_changed_cb) self._search_entry.add_clear_button() tool_item = Gtk.ToolItem() tool_item.set_expand(True) tool_item.add(self._search_entry) self._search_entry.show() self._toolbox.toolbar.insert(tool_item, -1) tool_item.show() self._search_button = ToolButton('dialog-ok') self._search_button.set_tooltip(_('Search by Tags')) self._search_button.connect('clicked', self._search_button_cb) self._toolbox.toolbar.insert(self._search_button, -1) self._search_button.show() separator = Gtk.SeparatorToolItem() separator.props.draw = False separator.set_expand(True) self._toolbox.toolbar.insert(separator, -1) separator.show() stop_button = StopButton(self) stop_button.props.accelerator = '<Ctrl>q' self._toolbox.toolbar.insert(stop_button, -1) stop_button.show()
class Toolbar(Gtk.Toolbar): __gsignals__ = { 'stop-clicked': (GObject.SignalFlags.RUN_FIRST, None, ([])), 'mode-changed': (GObject.SignalFlags.RUN_FIRST, None, ([int])), } def __init__(self, activity_name, has_local_help): Gtk.Toolbar.__init__(self) self._webview = None self._add_separator(False) if has_local_help and get_social_help_server(): help_button = RadioToolButton() icon = Icon(icon_name='toolbar-help', pixel_size=style.STANDARD_ICON_SIZE, fill_color=style.COLOR_TRANSPARENT.get_svg(), stroke_color=style.COLOR_WHITE.get_svg()) help_button.set_icon_widget(icon) icon.show() help_button.props.tooltip = _('Help Manual') help_button.connect('toggled', self.__button_toggled_cb, _MODE_HELP) self.insert(help_button, -1) help_button.show() self._add_separator(False) social_help_button = RadioToolButton() icon = Icon(icon_name='toolbar-social-help', pixel_size=style.STANDARD_ICON_SIZE, fill_color=style.COLOR_TRANSPARENT.get_svg(), stroke_color=style.COLOR_WHITE.get_svg()) social_help_button.set_icon_widget(icon) icon.show() social_help_button.props.tooltip = _('Social Help') social_help_button.props.group = help_button social_help_button.connect( 'toggled', self.__button_toggled_cb, _MODE_SOCIAL_HELP) self.insert(social_help_button, -1) social_help_button.show() self._add_separator(False) self._back_button = ToolButton(icon_name='go-previous-paired') self._back_button.props.tooltip = _('Back') self._back_button.connect('clicked', self.__back_clicked_cb) self.insert(self._back_button, -1) self._back_button.show() self._forward_button = ToolButton(icon_name='go-next-paired') self._forward_button.props.tooltip = _('Forward') self._forward_button.connect('clicked', self.__forward_clicked_cb) self.insert(self._forward_button, -1) self._forward_button.show() title = _('Help: %s') % activity_name self._label = Gtk.Label() self._label.set_markup('<b>%s</b>' % title) self._label.set_alignment(0, 0.5) self._add_widget(self._label) self._add_separator(True) stop = ToolButton(icon_name='dialog-cancel') stop.set_tooltip(_('Close')) stop.connect('clicked', self.__stop_clicked_cb) self.insert(stop, -1) stop.show() def __stop_clicked_cb(self, widget): self.emit('stop-clicked') def __button_toggled_cb(self, button, mode): if button.props.active: self.emit('mode-changed', mode) def _add_widget(self, widget): tool_item = Gtk.ToolItem() tool_item.add(widget) widget.show() self.insert(tool_item, -1) tool_item.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 bind_webview(self, webview): self._webview = webview self._webview.connect('load-changed', self.__load_changed_cb) self.update_back_forward() def __load_changed_cb(self, widget, event): self.update_back_forward() def update_back_forward(self): self._back_button.props.sensitive = self._webview.can_go_back() self._forward_button.props.sensitive = self._webview.can_go_forward() def __back_clicked_cb(self, button): self._webview.go_back() def __forward_clicked_cb(self, button): self._webview.go_forward()
class ReflectActivity(activity.Activity): ''' An activity for reflecting on one's work ''' def __init__(self, handle): ''' Initialize the toolbar ''' try: super(ReflectActivity, self).__init__(handle) except dbus.exceptions.DBusException as e: _logger.error(str(e)) logging.error('setting reflection data to []') self.reflection_data = [] self.connect('realize', self.__realize_cb) self.font_size = 8 self.max_participants = 4 self._setup_toolbars() color = profile.get_color() color_stroke = color.get_stroke_color() color_fill = color.get_fill_color() lighter = utils.lighter_color([color_stroke, color_fill]) darker = 1 - lighter if lighter == 0: self.bg_color = style.Color(color_stroke) self.fg_color = style.Color(color_fill) else: self.bg_color = style.Color(color_fill) self.fg_color = style.Color(color_stroke) self.modify_bg(Gtk.StateType.NORMAL, self.bg_color.get_gdk_color()) self.bundle_path = activity.get_bundle_path() self.tmp_path = os.path.join(activity.get_activity_root(), 'instance') self.sharing = False self._copy_entry = None self._paste_entry = None self._webkit = None self._clipboard_text = '' self._fixed = None self.initiating = True if self.shared_activity: # We're joining if not self.get_shared(): self.initiating = False self.busy_cursor() share_icon = Icon(icon_name='zoom-neighborhood') self._joined_alert = Alert() self._joined_alert.props.icon = share_icon self._joined_alert.props.title = _('Please wait') self._joined_alert.props.msg = _('Starting connection...') self.add_alert(self._joined_alert) # Wait for joined signal self.connect("joined", self._joined_cb) self._open_reflect_windows() self._setup_presence_service() # Joiners wait to receive data from sharer # Otherwise, load reflections from local store if not self.shared_activity: self.busy_cursor() GObject.idle_add(self._load_reflections) def read_file(self, file_path): fd = open(file_path, 'r') data = fd.read() fd.close() self.reflection_data = json.loads(data) def write_file(self, file_path): data = json.dumps(self.reflection_data) fd = open(file_path, 'w') fd.write(data) fd.close() self.metadata['font_size'] = str(self.font_size) def _load_reflections(self): self._find_starred() self._reflect_window.load(self.reflection_data) self.reset_cursor() def _found_obj_id(self, obj_id): for item in self.reflection_data: if 'obj_id' in item and item['obj_id'] == obj_id: return True return False def reload_data(self, data): ''' Reload data after sorting or searching ''' self._reflection_data = data[:] self._reflect_window.reload(self._reflection_data) self.reset_scrolled_window_adjustments() def _find_starred(self): ''' Find all the _stars in the Journal. ''' self.dsobjects, self._nobjects = datastore.find({'keep': '1'}) for dsobj in self.dsobjects: if self._found_obj_id(dsobj.object_id): continue # Already have this object -- TODO: update it self._add_new_from_journal(dsobj) def _add_new_from_journal(self, dsobj): self.reflection_data.append({ 'title': _('Untitled'), 'obj_id': dsobj.object_id }) if hasattr(dsobj, 'metadata'): if 'creation_time' in dsobj.metadata: self.reflection_data[-1]['creation_time'] = \ dsobj.metadata['creation_time'] else: self.reflection_data[-1]['creation_time'] = \ int(time.time()) if 'timestamp' in dsobj.metadata: self.reflection_data[-1]['modification_time'] = \ dsobj.metadata['timestamp'] else: self.reflection_data[-1]['modification_time'] = \ self.reflection_data[-1]['creation_time'] if 'activity' in dsobj.metadata: self.reflection_data[-1]['activities'] = \ [utils.bundle_id_to_icon(dsobj.metadata['activity'])] if 'title' in dsobj.metadata: self.reflection_data[-1]['title'] = \ dsobj.metadata['title'] if 'description' in dsobj.metadata: self.reflection_data[-1]['content'] = \ [{'text': dsobj.metadata['description']}] else: self.reflection_data[-1]['content'] = [] if 'tags' in dsobj.metadata: self.reflection_data[-1]['tags'] = [] tags = dsobj.metadata['tags'].split() for tag in tags: if tag[0] != '#': self.reflection_data[-1]['tags'].append('#' + tag) else: self.reflection_data[-1]['tags'].append(tag) if 'comments' in dsobj.metadata: try: comments = json.loads(dsobj.metadata['comments']) except: comments = [] self.reflection_data[-1]['comments'] = [] for comment in comments: try: data = { 'nick': comment['from'], 'comment': comment['message'] } if 'icon-color' in comment: colors = comment['icon-color'].split(',') darker = 1 - utils.lighter_color(colors) data['color'] = colors[darker] else: data['color'] = '#000000' self.reflection_data[-1]['comments'].append(data) except: _logger.debug('could not parse comment %s' % comment) if 'mime_type' in dsobj.metadata and \ dsobj.metadata['mime_type'][0:5] == 'image': new_path = os.path.join(self.tmp_path, dsobj.object_id) try: shutil.copy(dsobj.file_path, new_path) except Exception as e: logging.error("Couldn't copy %s to %s: %s" % (dsobj.file_path, new_path, e)) self.reflection_data[-1]['content'].append({'image': new_path}) elif 'preview' in dsobj.metadata: pixbuf = utils.get_pixbuf_from_journal(dsobj, 300, 225) if pixbuf is not None: path = os.path.join(self.tmp_path, dsobj.object_id + '.png') utils.save_pixbuf_to_file(pixbuf, path) self.reflection_data[-1]['content'].append({'image': path}) self.reflection_data[-1]['stars'] = 0 def delete_item(self, obj_id): for i, obj in enumerate(self.reflection_data): if obj['obj_id'] == obj_id: self.reflection_data.remove(self.reflection_data[i]) return def busy_cursor(self): self.get_window().set_cursor(Gdk.Cursor.new(Gdk.CursorType.WATCH)) def reset_cursor(self): self.get_window().set_cursor(Gdk.Cursor.new(Gdk.CursorType.LEFT_PTR)) def _open_reflect_windows(self): # Most things need only be done once if self._fixed is None: self._fixed = Gtk.Fixed() self._fixed.set_size_request(Gdk.Screen.width(), Gdk.Screen.height()) # Offsets from the bottom of the screen dy1 = 2 * style.GRID_CELL_SIZE dy2 = 1 * style.GRID_CELL_SIZE self._button_area = Gtk.Alignment.new(0.5, 0, 0, 0) self._button_area.set_size_request(Gdk.Screen.width(), style.GRID_CELL_SIZE) self._fixed.put(self._button_area, 0, 0) self._button_area.show() self._scrolled_window = Gtk.ScrolledWindow() self._scrolled_window.set_size_request(Gdk.Screen.width(), Gdk.Screen.height() - dy1) self._set_scroll_policy() self._graphics_area = Gtk.Alignment.new(0.5, 0, 0, 0) self._scrolled_window.add_with_viewport(self._graphics_area) self._graphics_area.show() self._fixed.put(self._scrolled_window, 0, dy2) self._scrolled_window.show() self._overlay_window = Gtk.ScrolledWindow() self._overlay_window.set_size_request(style.GRID_CELL_SIZE * 10, style.GRID_CELL_SIZE * 6) self._overlay_window.modify_bg(Gtk.StateType.NORMAL, style.COLOR_WHITE.get_gdk_color()) self._overlay_window.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC) self._overlay_area = Gtk.Alignment.new(0.5, 0, 0, 0) self._overlay_window.add_with_viewport(self._overlay_area) self._overlay_area.show() x = int((Gdk.Screen.width() - style.GRID_CELL_SIZE * 10) / 2) self._fixed.put(self._overlay_window, 0, Gdk.Screen.height()) self._overlay_window.show() self._old_overlay_widget = None self._reflect_window = ReflectWindow(self) self._reflect_window.show() Gdk.Screen.get_default().connect('size-changed', self._configure_cb) self._toolbox.connect('hide', self._resize_hide_cb) self._toolbox.connect('show', self._resize_show_cb) self._reflect_window.set_events(Gdk.EventMask.KEY_PRESS_MASK) self._reflect_window.connect('key_press_event', self._reflect_window.keypress_cb) self._reflect_window.set_can_focus(True) self._reflect_window.grab_focus() self.set_canvas(self._fixed) self._fixed.show() def reset_scrolled_window_adjustments(self): adj = self._scrolled_window.get_hadjustment() if adj is not None: adj.set_value(0) adj = self._scrolled_window.get_vadjustment() if adj is not None: adj.set_value(0) def load_graphics_area(self, widget): self._graphics_area.add(widget) def load_button_area(self, widget): self._button_area.add(widget) def load_overlay_area(self, widget): if self._old_overlay_widget is not None: self._overlay_area.remove(self._old_overlay_widget) self._overlay_area.add(widget) self._old_overlay_widget = widget def show_overlay_area(self): x = int((Gdk.Screen.width() - style.GRID_CELL_SIZE * 10) / 2) self._fixed.move(self._overlay_window, x, style.GRID_CELL_SIZE) def hide_overlay_area(self): self._fixed.move(self._overlay_window, 0, Gdk.Screen.height()) def _resize_hide_cb(self, widget): self._resize_canvas(widget, True) def _resize_show_cb(self, widget): self._resize_canvas(widget, False) def _configure_cb(self, event): self._fixed.set_size_request(Gdk.Screen.width(), Gdk.Screen.height()) self._set_scroll_policy() self._resize_canvas(None) self._reflect_window.reload_graphics() def _resize_canvas(self, widget, fullscreen=False): # When a toolbar is expanded or collapsed, resize the canvas if hasattr(self, '_reflect_window'): if self.toolbar_expanded(): dy1 = 3 * style.GRID_CELL_SIZE dy2 = 2 * style.GRID_CELL_SIZE else: dy1 = 2 * style.GRID_CELL_SIZE dy2 = 1 * style.GRID_CELL_SIZE if fullscreen: dy1 -= 2 * style.GRID_CELL_SIZE dy2 -= 2 * style.GRID_CELL_SIZE self._scrolled_window.set_size_request(Gdk.Screen.width(), Gdk.Screen.height() - dy2) self._fixed.move(self._button_area, 0, 0) self._about_panel_visible = False def toolbar_expanded(self): if self.activity_button.is_expanded(): return True elif self.edit_toolbar_button.is_expanded(): return True elif self.view_toolbar_button.is_expanded(): return True return False def get_activity_version(self): info_path = os.path.join(self.bundle_path, 'activity', 'activity.info') try: info_file = open(info_path, 'r') except Exception as e: _logger.error('Could not open %s: %s' % (info_path, e)) return 'unknown' cp = ConfigParser() cp.readfp(info_file) section = 'Activity' if cp.has_option(section, 'activity_version'): activity_version = cp.get(section, 'activity_version') else: activity_version = 'unknown' return activity_version def get_uid(self): if len(self.volume_data) == 1: return self.volume_data[0]['uid'] else: return 'unknown' def _setup_toolbars(self): ''' Setup the toolbars. ''' self._toolbox = ToolbarBox() self.activity_button = ActivityToolbarButton(self) self.activity_button.connect('clicked', self._resize_canvas) self._toolbox.toolbar.insert(self.activity_button, 0) self.activity_button.show() self.set_toolbar_box(self._toolbox) self._toolbox.show() self.toolbar = self._toolbox.toolbar view_toolbar = Gtk.Toolbar() self.view_toolbar_button = ToolbarButton(page=view_toolbar, label=_('View'), icon_name='toolbar-view') self.view_toolbar_button.connect('clicked', self._resize_canvas) self._toolbox.toolbar.insert(self.view_toolbar_button, 1) view_toolbar.show() self.view_toolbar_button.show() button = ToolButton('view-fullscreen') button.set_tooltip(_('Fullscreen')) button.props.accelerator = '<Alt>Return' view_toolbar.insert(button, -1) button.show() button.connect('clicked', self._fullscreen_cb) edit_toolbar = Gtk.Toolbar() self.edit_toolbar_button = ToolbarButton(page=edit_toolbar, label=_('Edit'), icon_name='toolbar-edit') self.edit_toolbar_button.connect('clicked', self._resize_canvas) self._toolbox.toolbar.insert(self.edit_toolbar_button, 1) edit_toolbar.show() self.edit_toolbar_button.show() self._copy_button = ToolButton('edit-copy') self._copy_button.set_tooltip(_('Copy')) self._copy_button.props.accelerator = '<Ctrl>C' edit_toolbar.insert(self._copy_button, -1) self._copy_button.show() self._copy_button.connect('clicked', self._copy_cb) self._copy_button.set_sensitive(False) self._paste_button = ToolButton('edit-paste') self._paste_button.set_tooltip(_('Paste')) self._paste_button.props.accelerator = '<Ctrl>V' edit_toolbar.insert(self._paste_button, -1) self._paste_button.show() self._paste_button.connect('clicked', self._paste_cb) self._paste_button.set_sensitive(False) button = ToolButton('list-add') button.set_tooltip(_('Add Item')) button.props.accelerator = '<Ctrl>+' self._toolbox.toolbar.insert(button, -1) button.show() button.connect('clicked', self.__add_item_cb) self._date_button = RadioToolButton('date-sort', group=None) self._date_button.set_tooltip(_('Sort by Date')) self._date_button.connect('clicked', self._date_button_cb) self._toolbox.toolbar.insert(self._date_button, -1) self._date_button.show() self._title_button = RadioToolButton('title-sort', group=self._date_button) self._title_button.set_tooltip(_('Sort by Title')) self._title_button.connect('clicked', self._title_button_cb) self._toolbox.toolbar.insert(self._title_button, -1) self._title_button.show() self._stars_button = RadioToolButton('stars-sort', group=self._date_button) self._stars_button.set_tooltip(_('Sort by Favourite')) self._stars_button.connect('clicked', self._stars_button_cb) self._toolbox.toolbar.insert(self._stars_button, -1) self._stars_button.show() # setup the search options self._search_entry = iconentry.IconEntry() self._search_entry.set_icon_from_name(iconentry.ICON_ENTRY_PRIMARY, 'system-search') self._search_entry.connect('activate', self._search_entry_activated_cb) self._search_entry.connect('changed', self._search_entry_changed_cb) self._search_entry.add_clear_button() tool_item = Gtk.ToolItem() tool_item.set_expand(True) tool_item.add(self._search_entry) self._search_entry.show() self._toolbox.toolbar.insert(tool_item, -1) tool_item.show() self._search_button = ToolButton('dialog-ok') self._search_button.set_tooltip(_('Search by Tags')) self._search_button.connect('clicked', self._search_button_cb) self._toolbox.toolbar.insert(self._search_button, -1) self._search_button.show() separator = Gtk.SeparatorToolItem() separator.props.draw = False separator.set_expand(True) self._toolbox.toolbar.insert(separator, -1) separator.show() stop_button = StopButton(self) stop_button.props.accelerator = '<Ctrl>q' self._toolbox.toolbar.insert(stop_button, -1) stop_button.show() def _search_button_cb(self, button): self.busy_cursor() self._do_search() def _search_entry_activated_cb(self, entry): self.busy_cursor() self._do_search() def _do_search(self): logging.debug('_search_entry_activated_cb') if self._search_entry.props.text == '': logging.debug('clearing search') for item in self.reflection_data: item['hidden'] = False else: tags = self._search_entry.props.text.split() for i, tag in enumerate(tags): if not tag[0] == '#': tags[i] = '#%s' % tag logging.error(tags) for item in self.reflection_data: hidden = True if 'tags' in item: for tag in tags: if tag in item['tags']: hidden = False item['hidden'] = hidden self.reload_data(self.reflection_data) self.reset_cursor() def _search_entry_changed_cb(self, entry): logging.debug('_search_entry_changed_cb search for \'%s\'', self._search_entry.props.text) self.busy_cursor() self._do_search_changed() def _do_search_changed(self): if self._search_entry.props.text == '': logging.debug('clearing search') for item in self.reflection_data: item['hidden'] = False self.reload_data(self.reflection_data) self.reset_cursor() def _title_button_cb(self, button): ''' sort by title ''' self.busy_cursor() GObject.idle_add(self._title_sort) def _title_sort(self): sorted_data = sorted(self.reflection_data, key=lambda item: item['title'].lower()) self.reload_data(sorted_data) self.reset_cursor() def _date_button_cb(self, button): ''' sort by modification date ''' self.busy_cursor() GObject.idle_add(self._date_sort) def _date_sort(self): sorted_data = sorted(self.reflection_data, key=lambda item: int(item['modification_time']), reverse=True) self.reload_data(sorted_data) self.reset_cursor() def _stars_button_cb(self, button): ''' sort by number of stars ''' self.busy_cursor() GObject.idle_add(self._stars_sort) def _stars_sort(self): sorted_data = sorted(self.reflection_data, key=lambda item: item['stars'], reverse=True) self.reload_data(sorted_data) self.reset_cursor() def __realize_cb(self, window): self.window_xid = window.get_window().get_xid() def set_copy_widget(self, webkit=None, text_entry=None): # Each task is responsible for setting a widget for copy if webkit is not None: self._webkit = webkit else: self._webkit = None if text_entry is not None: self._copy_entry = text_entry else: self._copy_entry = None self._copy_button.set_sensitive(webkit is not None or text_entry is not None) def _copy_cb(self, button): if self._copy_entry is not None: self._copy_entry.copy_clipboard() elif self._webkit is not None: self._webkit.copy_clipboard() else: _logger.debug('No widget set for copy.') def set_paste_widget(self, text_entry=None): # Each task is responsible for setting a widget for paste if text_entry is not None: self._paste_entry = text_entry self._paste_button.set_sensitive(text_entry is not None) def _paste_cb(self, button): clipboard = Gtk.Clipboard.get(Gdk.SELECTION_CLIPBOARD) self.clipboard_text = clipboard.wait_for_text() if self._paste_entry is not None: self._paste_entry.paste_clipboard() else: _logger.debug('No widget set for paste (%s).' % self.clipboard_text) def _fullscreen_cb(self, button): ''' Hide the Sugar toolbars. ''' self.fullscreen() def __add_item_cb(self, button): try: chooser = ObjectChooser(parent=self, what_filter=None) except TypeError: chooser = ObjectChooser( None, self._reflection.activity, Gtk.DialogFlags.MODAL | Gtk.DialogFlags.DESTROY_WITH_PARENT) try: result = chooser.run() if result == Gtk.ResponseType.ACCEPT: jobject = chooser.get_selected_object() if jobject: self._add_new_from_journal(jobject) self.reload_data(self.reflection_data) finally: chooser.destroy() del chooser def _set_scroll_policy(self): if Gdk.Screen.width() < Gdk.Screen.height(): self._scrolled_window.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC) else: self._scrolled_window.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC) def _remove_alert_cb(self, alert, response_id): self.remove_alert(alert) def _close_alert_cb(self, alert, response_id): self.remove_alert(alert) if response_id is Gtk.ResponseType.OK: self.close() def _setup_presence_service(self): ''' Setup the Presence Service. ''' self.pservice = presenceservice.get_instance() owner = self.pservice.get_owner() self.owner = owner self._share = '' self.connect('shared', self._shared_cb) self.connect('joined', self._joined_cb) def _shared_cb(self, activity): ''' Either set up initial share...''' if self.shared_activity is None: _logger.error('Failed to share or join activity ... \ shared_activity is null in _shared_cb()') return self.initiating = True self._waiting_for_reflections = False _logger.debug('I am sharing...') self.conn = self.shared_activity.telepathy_conn self.tubes_chan = self.shared_activity.telepathy_tubes_chan self.text_chan = self.shared_activity.telepathy_text_chan self.tubes_chan[telepathy.CHANNEL_TYPE_TUBES].connect_to_signal( 'NewTube', self._new_tube_cb) _logger.debug('This is my activity: making a tube...') self.tubes_chan[telepathy.CHANNEL_TYPE_TUBES].OfferDBusTube( SERVICE, {}) self.sharing = True def _joined_cb(self, activity): ''' ...or join an exisiting share. ''' if self.shared_activity is None: _logger.error('Failed to share or join activity ... \ shared_activity is null in _shared_cb()') return if self._joined_alert is not None: self.remove_alert(self._joined_alert) self._joined_alert = None self.initiating = False self._waiting_for_reflections = True _logger.debug('I joined a shared activity.') self.conn = self.shared_activity.telepathy_conn self.tubes_chan = self.shared_activity.telepathy_tubes_chan self.text_chan = self.shared_activity.telepathy_text_chan self.tubes_chan[telepathy.CHANNEL_TYPE_TUBES].connect_to_signal( 'NewTube', self._new_tube_cb) _logger.debug('I am joining an activity: waiting for a tube...') self.tubes_chan[telepathy.CHANNEL_TYPE_TUBES].ListTubes( reply_handler=self._list_tubes_reply_cb, error_handler=self._list_tubes_error_cb) self.sharing = True def _list_tubes_reply_cb(self, tubes): ''' Reply to a list request. ''' for tube_info in tubes: self._new_tube_cb(*tube_info) def _list_tubes_error_cb(self, e): ''' Log errors. ''' _logger.error('ListTubes() failed: %s', e) def _new_tube_cb(self, id, initiator, type, service, params, state): ''' Create a new tube. ''' _logger.debug( 'New tube: ID=%d initator=%d type=%d service=%s ' 'params=%r state=%d', id, initiator, type, service, params, state) if (type == telepathy.TUBE_TYPE_DBUS and service == SERVICE): if state == telepathy.TUBE_STATE_LOCAL_PENDING: self.tubes_chan[telepathy.CHANNEL_TYPE_TUBES].AcceptDBusTube( id) self.collab = CollabWrapper(self) self.collab.message.connect(self.event_received_cb) self.collab.setup() if self._waiting_for_reflections: self.send_event(JOIN_CMD, {}) self._joined_alert = Alert() self._joined_alert.props.title = _('Please wait') self._joined_alert.props.msg = _('Requesting reflections...') self.add_alert(self._joined_alert) def event_received_cb(self, collab, buddy, msg): ''' Data is passed as tuples: cmd:text ''' command = msg.get("command") payload = msg.get("payload") logging.debug(command) if command == JOIN_CMD: # Sharer needs to send reflections database to joiners. if self.initiating: # Send pictures first. for item in self.reflection_data: if 'content' in item: for content in item['content']: if 'image' in content: pixbuf = GdkPixbuf.Pixbuf.new_from_file_at_size( content['image'], 120, 90) if pixbuf is not None: data = utils.pixbuf_to_base64(pixbuf) self.send_event( PICTURE_CMD, { "image": os.path.basename( content['image']), "data": data }) data = json.dumps(self.reflection_data) self.send_event(SHARE_CMD, {"data": data}) elif command == NEW_REFLECTION_CMD: self._reflect_window.add_new_reflection(payload) elif command == TITLE_CMD: obj_id = payload.get("obj_id") title = payload.get("title") for item in self.reflection_data: if item['obj_id'] == obj_id: found_the_object = True self._reflect_window.update_title(obj_id, title) break if not found_the_object: logging.error('Could not find obj_id %s' % obj_id) elif command == TAG_CMD: obj_id = payload.get("obj_id") data = payload.get("data") for item in self.reflection_data: if item['obj_id'] == obj_id: found_the_object = True self._reflect_window.update_tags(obj_id, data) break if not found_the_object: logging.error('Could not find obj_id %s' % obj_id) elif command == ACTIVITY_CMD: obj_id = payload.get("obj_id") bundle_id = payload.get("bundle_id") for item in self.reflection_data: if item['obj_id'] == obj_id: found_the_object = True self._reflect_window.insert_activity(obj_id, bundle_id) break if not found_the_object: logging.error('Could not find obj_id %s' % obj_id) elif command == STAR_CMD: obj_id = payload.get("obj_id") stars = payload.get("stars") for item in self.reflection_data: if item['obj_id'] == obj_id: found_the_object = True self._reflect_window.update_stars(obj_id, int(stars)) break if not found_the_object: logging.error('Could not find obj_id %s' % obj_id) elif command == COMMENT_CMD: found_the_object = False # Receive a comment and associated reflection ID obj_id = payload.get("obj_id") nick = payload.get("nick") color = payload.get("color") comment = payload.get("comment") for item in self.reflection_data: if item['obj_id'] == obj_id: found_the_object = True if not 'comments' in item: item['comments'] = [] data = {'nick': nick, 'comment': comment, 'color': color} item['comments'].append(data) self._reflect_window.insert_comment(obj_id, data) break if not found_the_object: logging.error('Could not find obj_id %s' % obj_id) elif command == REFLECTION_CMD: found_the_object = False # Receive a reflection and associated reflection ID obj_id = payload.get("obj_id") reflection = payload.get("reflection") for item in self.reflection_data: if item['obj_id'] == obj_id: found_the_object = True if not '' in item: item['content'] = [] item['content'].append({'text': reflection}) self._reflect_window.insert_reflection(obj_id, reflection) break if not found_the_object: logging.error('Could not find obj_id %s' % obj_id) elif command == IMAGE_REFLECTION_CMD: found_the_object = False # Receive a picture reflection and associated reflection ID obj_id = payload.get("obj_id") basename = payload.get("basename") for item in self.reflection_data: if item['obj_id'] == obj_id: found_the_object = True if not '' in item: item['content'] = [] item['content'].append( {'image': os.path.join(self.tmp_path, basename)}) self._reflect_window.insert_picture( obj_id, os.path.join(self.tmp_path, basename)) break if not found_the_object: logging.error('Could not find obj_id %s' % obj_id) elif command == PICTURE_CMD: # Receive a picture (MAYBE DISPLAY IT AS IT ARRIVES?) basename = payload.get("basename") data = payload.get("data") utils.base64_to_file(data, os.path.join(self.tmp_path, basename)) elif command == SHARE_CMD: # Joiner needs to load reflection database. if not self.initiating: # Note that pictures should be received. self.reflection_data = payload self._reflect_window.load(self.reflection_data) self._waiting_for_reflections = False self.reset_cursor() if self._joined_alert is not None: self.remove_alert(self._joined_alert) self._joined_alert = None def send_event(self, command, data): ''' Send event through the tube. ''' if hasattr(self, 'collab') and self.collab is not None: data["command"] = command self.collab.post(data)
def __init__(self, title, bundle_path, document_path, sugar_toolkit_path): Gtk.Toolbar.__init__(self) document_button = None self.bundle_path = bundle_path self.sugar_toolkit_path = sugar_toolkit_path 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 = DocumentButton(file_name, bundle_path, title, bundle=True) icon = Icon(file=file_name, pixel_size=style.STANDARD_ICON_SIZE, fill_color=style.COLOR_TRANSPARENT.get_svg(), stroke_color=style.COLOR_WHITE.get_svg()) activity_button.set_icon_widget(icon) icon.show() if document_button 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() if sugar_toolkit_path is not None: sugar_button = RadioToolButton() icon = Icon(icon_name='computer-xo', pixel_size=style.STANDARD_ICON_SIZE, fill_color=style.COLOR_TRANSPARENT.get_svg(), stroke_color=style.COLOR_WHITE.get_svg()) sugar_button.set_icon_widget(icon) icon.show() if document_button is not None: sugar_button.props.group = document_button else: sugar_button.props.group = activity_button sugar_button.props.tooltip = _('Sugar Toolkit Source') sugar_button.connect('toggled', self.__button_toggled_cb, sugar_toolkit_path) self.insert(sugar_button, -1) sugar_button.show() self._add_separator() self.activity_title_text = _('View source: %s') % title self.sugar_toolkit_title_text = _('View source: %r') % 'Sugar Toolkit' self.label = Gtk.Label() self.label.set_markup('<b>%s</b>' % self.activity_title_text) self.label.set_alignment(0, 0.5) self._add_widget(self.label) self._add_separator(True) stop = ToolButton(icon_name='dialog-cancel') stop.set_tooltip(_('Close')) stop.connect('clicked', self.__stop_clicked_cb) self.insert(stop, -1) stop.show()
def build_colors_toolbar(self, toolbox): barra_colors = Gtk.Toolbar() item1 = Gtk.ToolItem() label1 = Gtk.Label() label1.set_text(_('Color mode') + ' ') item1.add(label1) barra_colors.insert(item1, -1) item2 = Gtk.ToolItem() modes = ('RGB', 'YUV', 'HSV') combo = Combo(modes) item2.add(combo) combo.connect('changed', self.change_combo) barra_colors.insert(item2, -1) separator1 = Gtk.SeparatorToolItem() separator1.props.draw = True barra_colors.insert(separator1, -1) item_l = Gtk.ToolItem() label4 = Gtk.Label() label4.set_text(_('Brightness') + ' ') item_l.add(label4) barra_colors.insert(item_l, -1) item = Gtk.ToolItem() brightness_spin = Gtk.SpinButton() brightness_spin.set_range(-1, 255) brightness_spin.set_increments(1, 10) brightness_spin.props.value = int(self.brightness) brightness_spin.connect('notify::value', self.brightness_spin_change) item.add(brightness_spin) barra_colors.insert(item, -1) separator2 = Gtk.SeparatorToolItem() separator2.props.draw = True barra_colors.insert(separator2, -1) item3 = Gtk.ToolItem() label3 = Gtk.Label() label3.set_text(_('Threshold view')) item3.add(label3) barra_colors.insert(item3, -1) threshold_view = ToolButton('media-playback-stop') threshold_view.connect('clicked', self.threshold_view) threshold_view.set_tooltip(_('Yes')) barra_colors.insert(threshold_view, -1) separator3 = Gtk.SeparatorToolItem() separator3.props.draw = True barra_colors.insert(separator3, -1) item4 = Gtk.ToolItem() label4 = Gtk.Label() label4.set_text(_('Outline')) item4.add(label4) barra_colors.insert(item4, -1) outline_view = ToolButton('media-playback-stop') outline_view.connect('clicked', self.outline_view) outline_view.set_tooltip(_('Yes')) barra_colors.insert(outline_view, -1) separator4 = Gtk.SeparatorToolItem() separator4.props.draw = True barra_colors.insert(separator4, -1) item5 = Gtk.ToolItem() label5 = Gtk.Label() label5.set_text(_('Rects')) item5.add(label5) barra_colors.insert(item5, -1) rects_view = ToolButton('media-playback-stop') rects_view.connect('clicked', self.rects_view) rects_view.set_tooltip(_('Yes')) barra_colors.insert(rects_view, -1) barra_colors.show_all() colors_button = ToolbarButton(label=_('Colors'), page=barra_colors, icon_name='toolbar-colors') toolbox.toolbar.insert(colors_button, -1) colors_button.show()
def build_calibrate_toolbar(self, toolbox): calibrate_bar = Gtk.Toolbar() item1 = Gtk.ToolItem() label1 = Gtk.Label() label1.set_text(' ' + _('Calibrate/Follow') + ' ') item1.add(label1) calibrate_bar.insert(item1, -1) stop_calibrate = ToolButton('media-playback-stop') stop_calibrate.set_tooltip(_('Stop')) stop_calibrate.set_accelerator('<ctrl>space') stop_calibrate.connect('clicked', self.stop_execute) calibrate_bar.insert(stop_calibrate, -1) separator1 = Gtk.SeparatorToolItem() separator1.props.draw = True calibrate_bar.insert(separator1, -1) item3 = Gtk.ToolItem() self.label_color_red = Gtk.Label() self.label_color_red.set_text(' ' + _('Calibrated color:') + ' ' + _('Red') + ' ') item3.add(self.label_color_red) calibrate_bar.insert(item3, -1) item4 = Gtk.ToolItem() self.red_spin = Gtk.SpinButton() self.red_spin.set_range(0, 255) self.red_spin.set_increments(1, 10) self.red_spin.props.value = self.colorC[0] self.red_spin.connect('notify::value', self.red_spin_color) item4.add(self.red_spin) calibrate_bar.insert(item4, -1) item5 = Gtk.ToolItem() self.label_color_green = Gtk.Label() self.label_color_green.set_text(' ' + _('Green') + ' ') item5.add(self.label_color_green) calibrate_bar.insert(item5, -1) item6 = Gtk.ToolItem() self.green_spin = Gtk.SpinButton() self.green_spin.set_range(0, 255) self.green_spin.set_increments(1, 10) self.green_spin.props.value = self.colorC[1] self.green_spin.connect('notify::value', self.green_spin_color) item6.add(self.green_spin) calibrate_bar.insert(item6, -1) item7 = Gtk.ToolItem() self.label_color_blue = Gtk.Label() self.label_color_blue.set_text(' ' + _('Blue') + ' ') item7.add(self.label_color_blue) calibrate_bar.insert(item7, -1) item8 = Gtk.ToolItem() self.blue_spin = Gtk.SpinButton() self.blue_spin.set_range(0, 255) self.blue_spin.set_increments(1, 10) self.blue_spin.props.value = self.colorC[2] self.blue_spin.connect('notify::value', self.blue_spin_color) item8.add(self.blue_spin) calibrate_bar.insert(item8, -1) calibrate_bar.show_all() calibrate_button = ToolbarButton(label=_('Calibrate'), page=calibrate_bar, icon_name='preferences-system') toolbox.toolbar.insert(calibrate_button, -1) calibrate_button.show()