def __init__(self, **kwargs): gtk.ToolItem.__init__(self) help_button = ToolButton('help-icon') help_button.set_tooltip(_('Help')) self.add(help_button) self._palette = help_button.get_palette() sw = gtk.ScrolledWindow() sw.set_size_request(int(gtk.gdk.screen_width() / 2.8), gtk.gdk.screen_height() - style.GRID_CELL_SIZE * 3) sw.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC) self._max_text_width = int(gtk.gdk.screen_width() / 3) - 20 self._vbox = gtk.VBox() self._vbox.set_homogeneous(False) hbox = gtk.HBox() 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 WriteToolbar(gtk.Toolbar): canvas = WriteCanvas def __init__(self, activity): gtk.Toolbar.__init__(self) self._activity = activity self._send_button = ToolButton('send-email', tooltip=_('Send email')) self._send_button.connect('clicked', self.__send_email_cb) self.insert(self._send_button, -1) self._attach_button = ToolButton('add-attachment', tooltip=_('Add attachment')) self._attach_button.connect('clicked', self.__add_attachment_cb) self.insert(self._attach_button, -1) self.show_all() def __send_email_cb(self, *args): msg = self._activity.canvas.make_msg() if utility.check_online(): func = self._activity.config.transport_account.send args = ([msg], OutboundTracker(self._activity)) thread.start_new_thread(func, args) else: self._keep_as_outbound(msg) self._activity.toolbox.current_toolbar = 1 # egh def __add_attachment_cb(self, *args): pass
def __init__(self, activity, **kwargs): gtk.ToolItem.__init__(self) description_button = ToolButton('edit-description') description_button.show() description_button.set_tooltip(_('Description')) self._palette = description_button.get_palette() description_box = gtk.HBox() sw = gtk.ScrolledWindow() sw.set_size_request(int(gtk.gdk.screen_width() / 2), 2 * style.GRID_CELL_SIZE) sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC) self._text_view = gtk.TextView() self._text_view.set_left_margin(style.DEFAULT_PADDING) self._text_view.set_right_margin(style.DEFAULT_PADDING) self._text_view.set_wrap_mode(gtk.WRAP_WORD_CHAR) text_buffer = gtk.TextBuffer() if 'description' in activity.metadata: text_buffer.set_text(activity.metadata['description']) self._text_view.set_buffer(text_buffer) self._text_view.connect('focus-out-event', self.__description_changed_cb, activity) sw.add(self._text_view) description_box.pack_start(sw, False, True, 0) self._palette.set_content(description_box) description_box.show_all() self.add(description_button) description_button.connect('clicked', self.__description_button_clicked_cb) activity.metadata.connect('updated', self.__jobject_updated_cb)
class ActivityToolbarXO2XO(gtk.Toolbar): def __init__(self, activity, orientation_left=False): gtk.Toolbar.__init__(self) self._activity = activity if orientation_left == False: separator = gtk.SeparatorToolItem() separator.props.draw = False separator.set_expand(True) self.insert(separator,-1) separator.show() self._object_insert = ToolButton('object-insert') self.insert(self._object_insert, -1) self._object_insert.show() self.stop = StopButton(activity) self.insert(self.stop, -1) self.stop.show() self._object_insert.connect('clicked', self.insertImage, activity) def insertImage(self, widget, activity): self._activity = activity chooser = ObjectChooser('Choose image', self._activity, gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT) try: result = chooser.run() if result == gtk.RESPONSE_ACCEPT: jobject = chooser.get_selected_object() if jobject and jobject.file_path: self._activity.toUploadChosen(jobject.file_path) finally: chooser.destroy() del chooser
def __init__(self, handle): activity.Activity.__init__(self, handle) self.toolbox = activity.ActivityToolbox(self) activity_toolbar = self.toolbox.get_activity_toolbar() activity_toolbar.share.props.visible = False activity_toolbar.keep.props.visible = False go_up = ToolButton("gtk-go-up") go_up.props.tooltip = _("Go Up") go_up.show() activity_toolbar.insert(go_up, 2) refresh = ToolButton("gtk-refresh") refresh.props.tooltip = _("Refresh") refresh.show() activity_toolbar.insert(refresh, 2) self.set_toolbox(self.toolbox) self.toolbox.show() widget = filemanager.Widget() go_up.connect("clicked", self.go_up_callback, widget) refresh.connect("clicked", self.refresh_callback, widget) widget.show() current_directory = gio.File(path=os.environ["HOME"]) widget.set_current_directory(current_directory.get_uri()) widget.connect("file-menu", self.file_menu) widget.connect('current-directory-menu', self.current_directory_menu) self.set_canvas(widget) self.show()
class ReadToolbar(gtk.Toolbar): ''' TODO: * the toolbutton's sensitivity depends on context ''' canvas = ReadCanvas def __init__(self, activity): gtk.Toolbar.__init__(self) self._activity = activity self._sendreceive_button = ToolButton('send-and-receive', tooltip=_('Send/receive email')) self._sendreceive_button.connect('clicked', self._sendreceive_cb) self.insert(self._sendreceive_button, -1) self.show_all() ''' self._reply_button = ToolButton('reply', tooltip=_('Write a reply')) self._reply_button.connect('clicked', self._reply_msg_cb) self.insert(self._reply_button, -1) self._forward_button = ToolButton('forward', tooltip=_('Forward this message')) self._forward_button.connect('clicked', self._forward_msg_cb) self.insert(self._forward_button, -1) ''' def _sendreceive_cb(self, *args): sweetmail.mailactivity.run_bgsrt_once(self._activity) def _reply_msg_cb(self, *args): pass def _forward_msg_cb(self, *args): pass
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, handle): gtk.Toolbar.__init__(self) self.handle = handle #Tytuł pola tekstowego self.add_widget(gtk.Label("Id testu: ")) #Pole tekstowe self.test_entry = gtk.Entry() self.test_entry.set_size_request(200,25) self.test_entry.set_text('709rqd') self.add_widget(self.test_entry) #Separator separator = gtk.SeparatorToolItem() separator.set_draw(True) separator.set_size_request(50,25) self.add_widget(separator) #Tytuł pola tekstowego self.add_widget(gtk.Label("Hasło: ")) #Pole tekstowe self.pass_entry = gtk.Entry() self.pass_entry.set_size_request(300,25) # self.pass_entry.set_text('123123') self.add_widget(self.pass_entry) #Przycisk pobierania download_button = ToolButton("download") download_button.set_tooltip("Pobierz test") download_button.connect("clicked", handle.get_test_bt) self.add_widget(download_button)
def build_toolbar(self): toolbar_box = ToolbarBox() self.set_toolbar_box(toolbar_box) toolbar_box.show() activity_button = ActivityToolbarButton(self) toolbar_box.toolbar.insert(activity_button, -1) activity_button.show() self.blocklist = [] self.radioList = {} for c in tools.allTools: button = ToolButton(c.icon) button.set_tooltip(_(c.toolTip)) button.connect('clicked',self.radioClicked) toolbar_box.toolbar.insert(button, -1) button.show() self.radioList[button] = c.name separator = gtk.SeparatorToolItem() separator.props.draw = False separator.set_expand(True) toolbar_box.toolbar.insert(separator, -1) separator.show() stop_button = StopButton(self) toolbar_box.toolbar.insert(stop_button, -1) stop_button.show() self.show_all()
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() separator1 = gtk.SeparatorToolItem() separator1.props.draw = True separator1.set_expand(False) toolbar_box.toolbar.insert(separator1, -1) separator1.show() item1 = gtk.ToolItem() label1 = gtk.Label() label1.set_text(_('Levels') + ' ') item1.add(label1) toolbar_box.toolbar.insert(item1, -1) item2 = gtk.ToolItem() levels = (_('Cross'), _('Cross 2'), #TRANS:'chimney' - the place where you make fire _('Hearth'), _('Arrow'), _('Pyramid'), _('Diamond'), _('Solitaire')) combo = Combo(levels) item2.add(combo) combo.connect('changed', self.change_combo) toolbar_box.toolbar.insert(item2, -1) separator2 = gtk.SeparatorToolItem() separator2.props.draw = True separator2.set_expand(False) toolbar_box.toolbar.insert(separator2, -1) separator2.show() sound_button = ToolButton('speaker-muted-100') sound_button.set_tooltip(_('Sound')) sound_button.connect('clicked', self.sound_control) toolbar_box.toolbar.insert(sound_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.show_all()
class MainToolbar(gtk.Toolbar): """ Main toolbar of the control panel """ __gtype_name__ = 'MainToolbar' __gsignals__ = { 'stop-clicked': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE, ([])), 'search-changed': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE, ([str])), } def __init__(self): gtk.Toolbar.__init__(self) self._add_separator() tool_item = gtk.ToolItem() self.insert(tool_item, -1) tool_item.show() self._search_entry = iconentry.IconEntry() self._search_entry.set_icon_from_name(iconentry.ICON_ENTRY_PRIMARY, 'system-search') self._search_entry.add_clear_button() self._search_entry.set_width_chars(25) self._search_entry.connect('changed', self.__search_entry_changed_cb) tool_item.add(self._search_entry) self._search_entry.show() self._add_separator(True) self.stop = ToolButton(icon_name='dialog-cancel') self.stop.set_tooltip(_('Done')) self.stop.connect('clicked', self.__stop_clicked_cb) self.stop.show() self.insert(self.stop, -1) self.stop.show() def get_entry(self): return self._search_entry def _add_separator(self, expand=False): separator = gtk.SeparatorToolItem() separator.props.draw = False if expand: separator.set_expand(True) else: separator.set_size_request(style.DEFAULT_SPACING, -1) self.insert(separator, -1) separator.show() def __search_entry_changed_cb(self, search_entry): self.emit('search-changed', search_entry.props.text) def __stop_clicked_cb(self, button): self.emit('stop-clicked')
class EditToolbar(activity.EditToolbar): def __init__(self, _parent): activity.EditToolbar.__init__(self) self._parent = _parent self.undo.connect('clicked', self.__undo_cb) self.redo.connect('clicked', self.__redo_cb) self.copy.connect('clicked', self.__copy_cb) self.paste.connect('clicked', self.__paste_cb) menu_item = MenuItem(_('Cut')) menu_item.connect('activate', self.__cut_cb) menu_item.show() self.copy.get_palette().menu.append(menu_item) self.insert(gtk.SeparatorToolItem(), -1) self.erase_button = ToolButton('edit-delete') self.erase_button.set_tooltip(_('Erase selected thought(s)')) self.erase_button.connect('clicked', self.__delete_cb) self.insert(self.erase_button, -1) self.show_all() self.clipboard = gtk.Clipboard() self.copy.child.set_sensitive(False) self.paste.child.set_sensitive(False) self.erase_button.set_sensitive(False) def __undo_cb(self, button): self._parent._undo.undo_action(None) def __redo_cb(self, button): self._parent._undo.redo_action(None) def __cut_cb(self, event): self._parent._main_area.cut_clipboard(self.clipboard) def __copy_cb(self, event): self._parent._main_area.copy_clipboard(self.clipboard) def __paste_cb(self, event): self._parent._main_area.paste_clipboard(self.clipboard) def __delete_cb(self, widget): self._stop_moving() self.stop_dragging() self._parent._main_area.delete_selected_elements() def stop_dragging(self): if self._parent._main_area.is_dragging(): self._parent._main_area.drag_menu_cb(self._sw, False) def _stop_moving(self): self._parent._main_area.move_mode = False
class NamingToolbar(gtk.Toolbar): """ Toolbar of the naming alert """ __gtype_name__ = 'SugarNamingToolbar' __gsignals__ = { 'keep-clicked': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE, ([])) } def __init__(self): gtk.Toolbar.__init__(self) client = gconf.client_get_default() color = XoColor(client.get_string('/desktop/sugar/user/color')) icon = Icon() icon.set_from_icon_name('activity-journal', gtk.ICON_SIZE_LARGE_TOOLBAR) icon.props.xo_color = color self._add_widget(icon) self._add_separator() self._title = gtk.Label(_('Name this entry')) self._add_widget(self._title) self._add_separator(True) self._keep_button = ToolButton('dialog-ok', tooltip=_('Keep')) self._keep_button.props.accelerator = 'Return' self._keep_button.connect('clicked', self.__keep_button_clicked_cb) self.insert(self._keep_button, -1) self._keep_button.show() def _add_separator(self, expand=False): separator = gtk.SeparatorToolItem() separator.props.draw = False if expand: separator.set_expand(True) else: separator.set_size_request(style.DEFAULT_SPACING, -1) self.insert(separator, -1) separator.show() def _add_widget(self, widget, expand=False): tool_item = gtk.ToolItem() tool_item.set_expand(expand) tool_item.add(widget) widget.show() self.insert(tool_item, -1) tool_item.show() def __keep_button_clicked_cb(self, widget, data=None): self.emit('keep-clicked')
def build_resolution_toolbar(self, toolbox): resolution_bar = gtk.Toolbar() item1 = gtk.ToolItem() label1 = gtk.Label() label1.set_text(' ' + _('Show size') + ' ') item1.add(label1) resolution_bar.insert(item1, -1) item2 = gtk.ToolItem() x_size_spin = gtk.SpinButton() x_size_spin.set_range(160, 1200) x_size_spin.set_increments(1, 10) x_size_spin.props.value = int(self.show_size[0]) x_size_spin.connect('notify::value', self.x_size_spin_change) item2.add(x_size_spin) resolution_bar.insert(item2, -1) item3 = gtk.ToolItem() label3 = gtk.Label() label3.set_text(' X ') item3.add(label3) resolution_bar.insert(item3, -1) item4 = gtk.ToolItem() y_size_spin = gtk.SpinButton() y_size_spin.set_range(120, 900) y_size_spin.set_increments(1, 10) y_size_spin.props.value = int(self.show_size[1]) y_size_spin.connect('notify::value', self.y_size_spin_change) item4.add(y_size_spin) resolution_bar.insert(item4, -1) separator1 = gtk.SeparatorToolItem() separator1.props.draw = True resolution_bar.insert(separator1, -1) item5 = gtk.ToolItem() label5 = gtk.Label() label5.set_text(' ' + _('Show grid')) item5.add(label5) resolution_bar.insert(item5, -1) grid = ToolButton('grid-icon') grid.connect('clicked', self.grid_click) resolution_bar.insert(grid, -1) resolution_bar.show_all() resolution_button = ToolbarButton(label=_('Resolution'), page=resolution_bar, icon_name='camera') toolbox.toolbar.insert(resolution_button, -1) resolution_button.show()
def __init__(self, handle): gtk.Toolbar.__init__(self) self.handle = handle self._logger = logging.getLogger("activity-knut") self._logger.setLevel(logging.DEBUG) # First log handler: outputs to a file file_handler = logging.FileHandler("/home/wiktor/code/knut.log") file_formatter = logging.Formatter("%(message)s") file_handler.setFormatter(file_formatter) self._logger.addHandler(file_handler) # Tytuł pola tekstowego self.add_widget(gtk.Label("Kategoria: ")) # Pole tekstowe self.test_type = ComboBox() for id, name in BrowseToolbar.TEST_CATEGORIES.items(): self.test_type.append_item(id, name) self.test_type.set_active(0) self.add_widget(self.test_type) # Separator # separator = gtk.SeparatorToolItem() # separator.set_draw(True) # separator.set_size_request(50,25) # self.add_widget(separator) # Tytuł pola tekstowego self.add_widget(gtk.Label(" Szukaj w tytule: ")) # Pole tekstowe self.search_entry = gtk.Entry() self.search_entry.set_size_request(100, 25) # self.pass_entry.set_text('123123') self.add_widget(self.search_entry) # Przycisk pobierania download_button = ToolButton("download") download_button.set_tooltip("Przeglądaj testy") download_button.connect("clicked", self.list_download) self.add_widget(download_button) separator2 = gtk.SeparatorToolItem() separator2.set_draw(True) separator2.set_size_request(50, 25) self.add_widget(separator2) self.add_widget(gtk.Label("Hasło: ")) self.pass_entry = gtk.Entry() self.pass_entry.set_size_request(100, 25) # self.pass_entry.set_text('123123') self.add_widget(self.pass_entry)
def enable_zoom_bestfit(self, on_zoom_bestfit): """ Enables zoom-to-best-fit support on this toolbar. @param on_zoom_bestfit: The callback function to be called when user wants to zoom to best extent. """ zoom_best_fit_btn = ToolButton('zoom-best-fit') zoom_best_fit_btn.set_tooltip(_('Zoom best fitting extent.')) zoom_best_fit_btn.connect('clicked', on_zoom_bestfit) zoom_best_fit_btn.show() self.insert(zoom_best_fit_btn, -1)
def _load_toolbar(self): toolbar = gtk.Toolbar() # Remove Feed Palette remove_button = ToolButton(icon_name='list-remove') vbox = gtk.VBox() label = gtk.Label(_('Really delete feed?')) vbox.pack_start(label) hbox = gtk.HBox() expander_label = gtk.Label(' ') hbox.pack_start(expander_label) #b = gtk.Button(icon_name='stock-remove') b = ToolButton(icon_name='list-remove') #b.set_use_stock(True) b.connect('clicked', self._on_remove_feed_activate) hbox.pack_start(b, False) vbox.pack_start(hbox) palette = Palette(_('Remove Feed?')) palette.set_content(vbox) vbox.show_all() remove_button.set_palette(palette) toolbar.insert(remove_button, -1) remove_button.show() # Add Feed Palette button = ToolButton(icon_name='list-add') toolbar.insert(button, -1) button.show() self._add_feed_dialog = AddFeedDialog.AddFeedDialog(gtk.glade.XML(os.path.join(self.glade_prefix, 'penguintv.glade'), "window_add_feed",'penguintv'), self) #MAGIC content = self._add_feed_dialog.extract_content() content.show_all() #button.connect('clicked', self._add_feed_dialog.show) palette = Palette(_('Subscribe to Feed')) palette.set_content(content) button.set_palette(palette) self._feedlist = gtk.ListStore(int, str, str) self._combo = gtk.ComboBox(self._feedlist) cell = gtk.CellRendererText() self._combo.pack_start(cell, True) self._combo.add_attribute(cell, 'text', 1) self._combo.connect("changed", self._on_combo_select) toolcombo = ToolComboBox(self._combo) toolbar.insert(toolcombo, -1) toolcombo.show_all() toolbar.show() return toolbar
def __init__(self, activity): self._activity = activity gtk.ToolItem.__init__(self) help_button = ToolButton('toolbar-help') help_button.set_tooltip(_('Ayuda')) self.add(help_button) help_button.show() self._palette = help_button.get_palette() help_button.connect('clicked', self.__help_button_clicked_cb)
def __init__(self, activity): self._activity = activity self._current_palette = 'turtle' gtk.ToolItem.__init__(self) help_button = ToolButton('help-toolbar') help_button.set_tooltip(_('Help')) self.add(help_button) help_button.show() self._palette = help_button.get_palette() help_button.connect('clicked', self.__help_button_clicked_cb)
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 __init__(self, title, bundle_path, document_path): gtk.Toolbar.__init__(self) self._add_separator() activity_bundle = ActivityBundle(bundle_path) file_name = activity_bundle.get_icon() if document_path is not None and os.path.exists(document_path): document_button = DocumentButton(file_name, document_path, title) document_button.connect('toggled', self.__button_toggled_cb, document_path) self.insert(document_button, -1) document_button.show() self._add_separator() if bundle_path is not None and os.path.exists(bundle_path): activity_button = RadioToolButton() icon = Icon(file=file_name, icon_size=gtk.ICON_SIZE_LARGE_TOOLBAR, fill_color=style.COLOR_TRANSPARENT.get_svg(), stroke_color=style.COLOR_WHITE.get_svg()) activity_button.set_icon_widget(icon) icon.show() if document_path is not None: activity_button.props.group = document_button activity_button.props.tooltip = _('Activity Bundle Source') activity_button.connect('toggled', self.__button_toggled_cb, bundle_path) self.insert(activity_button, -1) activity_button.show() self._add_separator() text = _('View source: %r') % title label = gtk.Label() label.set_markup('<b>%s</b>' % text) label.set_alignment(0, 0.5) self._add_widget(label) self._add_separator(True) stop = ToolButton(icon_name='dialog-cancel') stop.set_tooltip(_('Close')) stop.connect('clicked', self.__stop_clicked_cb) stop.show() self.insert(stop, -1) stop.show()
def __init__(self, icon_name, title): super(_DialogToolbar, self).__init__() if icon_name is not None: sep = gtk.SeparatorToolItem() sep.set_draw(False) self._add_widget(sep) icon = Icon() icon.set_from_icon_name(icon_name, gtk.ICON_SIZE_LARGE_TOOLBAR) self._add_widget(icon) label = gtk.Label(' ' + title) self._add_widget(label) self._add_separator(expand=True) stop = ToolButton(icon_name='dialog-cancel') stop.set_tooltip('Salir') stop.connect('clicked', self._stop_clicked_cb) self.add(stop)
def __init__(self, editor): Palette.__init__(self, _('Pronounce text during tile flip')) self.face = speak.face.View() toolbar = gtk.HBox() toolbar.modify_bg(gtk.STATE_NORMAL, style.COLOR_BLACK.get_gdk_color()) usespeak_play = ToolButton(icon_name='media-playback-start') usespeak_play.connect('clicked', lambda button: self.face.say(editor.get_text())) toolbar.pack_start(usespeak_play, False) self.voices = speak.widgets.Voices(self.face) toolbar.pack_start(ToolComboBox(self.voices)) toolbar.show_all() self.set_content(toolbar)
def button_factory(icon_name, toolbar, callback, cb_arg=None, tooltip=None, accelerator=None): '''Factory for making toolbar buttons''' button = ToolButton(icon_name) if tooltip is not None: button.set_tooltip(tooltip) button.props.sensitive = True if accelerator is not None: button.props.accelerator = accelerator if cb_arg is not None: button.connect('clicked', callback, cb_arg) else: button.connect('clicked', callback) if hasattr(toolbar, 'insert'): # the main toolbar toolbar.insert(button, -1) else: # or a secondary toolbar toolbar.props.page.insert(button, -1) button.show() return button
def __init__(self, handle): activity.Activity.__init__(self, handle) # we do not have collaboration features # make the share option insensitive self.max_participants = 1 # toolbar with the new toolbar redesign toolbar_box = ToolbarBox() activity_button = ActivityToolbarButton(self) toolbar_box.toolbar.insert(activity_button, 0) toolbar_box.toolbar.insert(gtk.SeparatorToolItem(), -1) self.image_viewer = ImageCollectionViewer(False) prev_bt = ToolButton("go-previous-paired") prev_bt.connect("clicked", self.image_viewer.prev_anim_clicked_cb, None) toolbar_box.toolbar.insert(prev_bt, -1) next_bt = ToolButton("go-next-paired") next_bt.connect("clicked", self.image_viewer.next_anim_clicked_cb, None) toolbar_box.toolbar.insert(next_bt, -1) separator = gtk.SeparatorToolItem() separator.props.draw = False separator.set_expand(True) toolbar_box.toolbar.insert(separator, -1) stop_button = StopButton(self) toolbar_box.toolbar.insert(stop_button, -1) self.set_toolbar_box(toolbar_box) toolbar_box.show_all() self.modify_bg(gtk.STATE_NORMAL, style.COLOR_WHITE.get_gdk_color()) self.set_canvas(self.image_viewer)
class RecordToolbar(gtk.Toolbar): def __init__(self, jam): gtk.Toolbar.__init__(self) def _insertSeparator(x=1): for i in range(x): self.separator = gtk.SeparatorToolItem() self.separator.set_draw(True) self.insert(self.separator, -1) self.separator.show() #self.toolbox = toolbox self.jam = jam if Config.FEATURES_MIC: self.micRec1Button = ToolButton('rec1') self.micRec1Button.connect('clicked', self.jam.micRec, 'mic1') self.insert(self.micRec1Button, -1) self.micRec1Button.show() self.micRec1Button.set_tooltip(_('Record microphone into slot 1')) self.micRec2Button = ToolButton('rec2') self.micRec2Button.connect('clicked', self.jam.micRec, 'mic2') self.insert(self.micRec2Button, -1) self.micRec2Button.show() self.micRec2Button.set_tooltip(_('Record microphone into slot 2')) self.micRec3Button = ToolButton('rec3') self.micRec3Button.connect('clicked', self.jam.micRec, 'mic3') self.insert(self.micRec3Button, -1) self.micRec3Button.show() self.micRec3Button.set_tooltip(_('Record microphone into slot 3')) self.micRec4Button = ToolButton('rec4') self.micRec4Button.connect('clicked', self.jam.micRec, 'mic4') self.insert(self.micRec4Button, -1) self.micRec4Button.show() self.micRec4Button.set_tooltip(('Record microphone into slot 4')) _insertSeparator() if Config.FEATURES_NEWSOUNDS: self._loopSettingsPalette = LoopSettingsPalette( _('Add new Sound'), self.jam) self.loopSetButton = ToggleToolButton('loop') self.loopSetButton.set_palette(self._loopSettingsPalette) self.insert(self.loopSetButton, -1) self.loopSetButton.show() self.show_all()
def __init__(self, abiword_canvas): gtk.Toolbar.__init__(self) self._abiword_canvas = abiword_canvas self._table = abiword.TableCreator() self._table.set_labels(_('Table'), _('Cancel')) self._table_id = self._table.connect('selected', self._table_cb) image = gtk.Image() image.set_from_icon_name('insert-table', -1) self._table.set_image(image) self._table.set_relief(gtk.RELIEF_NONE) tool_item = gtk.ToolItem() tool_item.add(self._table) self.insert(tool_item, -1) tool_item.show_all() self._table_rows_after = ToolButton('row-insert') self._table_rows_after.set_tooltip(_('Insert Row')) self._table_rows_after_id = self._table_rows_after.connect( \ 'clicked', self._table_rows_after_cb) self.insert(self._table_rows_after, -1) self._table_delete_rows = ToolButton('row-remove') self._table_delete_rows.set_tooltip(_('Delete Row')) self._table_delete_rows_id = self._table_delete_rows.connect( \ 'clicked', self._table_delete_rows_cb) self.insert(self._table_delete_rows, -1) self._table_cols_after = ToolButton('column-insert') self._table_cols_after.set_tooltip(_('Insert Column')) self._table_cols_after_id = self._table_cols_after.connect( \ 'clicked', self._table_cols_after_cb) self.insert(self._table_cols_after, -1) self._table_delete_cols = ToolButton('column-remove') self._table_delete_cols.set_tooltip(_('Delete Column')) self._table_delete_cols_id = self._table_delete_cols.connect( \ 'clicked', self._table_delete_cols_cb) self.insert(self._table_delete_cols, -1) separator = gtk.SeparatorToolItem() self.insert(separator, -1) image = ToolButton('insert-picture') image.set_tooltip(_('Insert Image')) self._image_id = image.connect('clicked', self._image_cb) self.insert(image, -1) self.show_all() self._abiword_canvas.connect('table-state', self._isTable_cb)
class ViewToolbar(gtk.Toolbar): __gtype_name__ = 'ViewToolbar' __gsignals__ = { 'needs-update-size': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE, ([])), 'go-fullscreen': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE, ([])) } def __init__(self): gtk.Toolbar.__init__(self) self.fullscreen = ToolButton('view-fullscreen') self.fullscreen.set_tooltip(_('Fullscreen')) self.fullscreen.connect('clicked', self.fullscreen_cb) self.insert(self.fullscreen, -1) self.fullscreen.show() def fullscreen_cb(self, button): self.emit('go-fullscreen')
def build_toolbar(self): """Build our Activity toolbar for the Sugar system.""" toolbar_box = ToolbarBox() activity_button = ActivityToolbarButton(self) toolbar_box.toolbar.insert(activity_button, 0) activity_button.show() separator = gtk.SeparatorToolItem() toolbar_box.toolbar.insert(separator, -1) separator.show() easier_button = ToolButton('create-easier') easier_button.set_tooltip(_('Easier level')) easier_button.connect('clicked', self._easier_button_cb) toolbar_box.toolbar.insert(easier_button, -1) harder_button = ToolButton('create-harder') harder_button.set_tooltip(_('Harder level')) harder_button.connect('clicked', self._harder_button_cb) toolbar_box.toolbar.insert(harder_button, -1) separator = gtk.SeparatorToolItem() separator.props.draw = False separator.set_size_request(0, -1) 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_all() self.connect("destroy", self.__stop_pygame) return toolbar_box
def __init__(self): gtk.Toolbar.__init__(self) self._metadata = None self._temp_file_path = None self._resume = ToolButton('activity-start') self._resume.connect('clicked', self._resume_clicked_cb) self.add(self._resume) self._resume.show() client = gconf.client_get_default() color = XoColor(client.get_string('/desktop/sugar/user/color')) self._copy = ToolButton() icon = Icon(icon_name='edit-copy', xo_color=color) self._copy.set_icon_widget(icon) icon.show() self._copy.set_tooltip(_('Copy to')) self._copy.connect('clicked', self._copy_clicked_cb) self.add(self._copy) self._copy.show() self._duplicate = ToolButton() icon = Icon(icon_name='edit-duplicate', xo_color=color) self._duplicate.set_icon_widget(icon) self._duplicate.set_tooltip(_('Duplicate')) self._duplicate.connect('clicked', self._duplicate_clicked_cb) self.add(self._duplicate) separator = gtk.SeparatorToolItem() self.add(separator) separator.show() erase_button = ToolButton('list-remove') erase_button.set_tooltip(_('Erase')) erase_button.connect('clicked', self._erase_button_clicked_cb) self.add(erase_button) erase_button.show()
def __init__(self, activity, top_level_toolbox): self._activity = activity self.toolbox = top_level_toolbox Terminal.__init__(self, self) #set up tool box/menu buttons activity_toolbar = self.toolbox.get_activity_toolbar() separator = gtk.SeparatorToolItem() separator.set_draw(True) separator.show() activity_toolbar.insert(separator, 0) activity_go = ToolButton() activity_go.set_stock_id('gtk-media-forward') activity_go.set_icon_widget(None) activity_go.set_tooltip(_('Start Debugging')) activity_go.connect('clicked', self.project_run_cb) activity_go.add_accelerator('clicked', self.get_accelerator(), ord('O'), gtk.gdk.CONTROL_MASK, gtk.ACCEL_VISIBLE) activity_go.show() activity_toolbar.insert(activity_go, 0) activity_copy_tb = ToolButton('edit-copy') activity_copy_tb.set_tooltip(_('Copy')) activity_copy_tb.connect('clicked', self._copy_cb) activity_toolbar.insert(activity_copy_tb, 3) activity_copy_tb.show() activity_paste_tb = ToolButton('edit-paste') activity_paste_tb.set_tooltip(_('Paste')) activity_paste_tb.connect('clicked', self._paste_cb) activity_paste_tb.add_accelerator('clicked', self.get_accelerator(), ord('V'), gtk.gdk.CONTROL_MASK, gtk.ACCEL_VISIBLE) activity_toolbar.insert(activity_paste_tb, 4) activity_paste_tb.show() activity_tab_tb = sugar.graphics.toolbutton.ToolButton('list-add') activity_tab_tb.set_tooltip(_("Open New Tab")) activity_tab_tb.add_accelerator('clicked', self.get_accelerator(), ord('T'), gtk.gdk.CONTROL_MASK, gtk.ACCEL_VISIBLE) activity_tab_tb.show() activity_tab_tb.connect('clicked', self._open_tab_cb) activity_toolbar.insert(activity_tab_tb, 5) activity_tab_delete_tv = sugar.graphics.toolbutton.ToolButton( 'list-remove') activity_tab_delete_tv.set_tooltip(_("Close Tab")) activity_tab_delete_tv.show() activity_tab_delete_tv.connect('clicked', self._close_tab_cb) activity_toolbar.insert(activity_tab_delete_tv, 6) activity_fullscreen_tb = sugar.graphics.toolbutton.ToolButton( 'view-fullscreen') activity_fullscreen_tb.set_tooltip(_("Fullscreen")) activity_fullscreen_tb.connect('clicked', self._activity._fullscreen_cb) activity_toolbar.insert(activity_fullscreen_tb, 7) activity_fullscreen_tb.hide()
class canvas(gtk.HPaned): def __init__(self): super(canvas, self).__init__() #### self.toolbar = gtk.Toolbar() self.remove = ToolButton('remove') self.remove.set_tooltip(_('Remove this contact')) self.addbtn = ToolButton('add') self.addbtn.connect('clicked', self._show_palette_add_button) self.sep = gtk.SeparatorToolItem() self.toolarea = AddTelephoneArea(self.addbtn, self) self.sep.props.draw = False self.sep.set_expand(True) self.toolbar.insert(self.sep, -1) self.toolbar.insert(self.remove, -1) ### self.ficha = Ficha() self.set1 = Telefonos(self.remove, self.ficha) self.scroll = gtk.ScrolledWindow() self.scroll.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC) self.scroll.add_with_viewport(self.set1) self.vbx = gtk.VBox() self.vbx.pack_start(self.scroll, True, True, 0) self.vbx.pack_end(self.toolbar, False, True, 0) self.vbx.set_size_request(gtk.gdk.screen_width() / 3, -1) self.add1(self.vbx) self.add2(self.ficha) self.show_all() self.addbtn.set_tooltip(_('Add a new contact')) if __name__ == "__main__": self.toolbar.insert(self.addbtn, -1) if os.path.isfile("users"): self.read_file('users') self._create_palette_add_button(self.addbtn) def read_file(self, file_path): fd = open(file_path, 'r') text = fd.read() data = simplejson.loads(text) fd.close() current = 0 for x in data['names']: numero = data['telephones'][current] edad = data['ages'][current] email = data['emails'][current] direction = data['directions'][current] avatar = data['avatars'][current] self._add(x, numero, edad, email, direction, avatar) current += 1 def _show_palette_add_button(self, button): button.props.palette.popup(immediate=True, state=1) def _create_palette_add_button(self, button): pallete = button.get_palette() pallete.set_content(self.toolarea) txt = _("Unknown") pt = os.path.join(os.getcwd(), 'avatars', 'none.svg') td = _("None") def _add(self, name, number=txt, age=1, email=td, direct=txt, av=pt): self.set1._add_telephone(name, number, age, email, direct, av) self.show_all()
class ViewToolbar(gtk.Toolbar): __gtype_name__ = 'ViewToolbar' __gsignals__ = { 'go-fullscreen': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE, ([])), } def __init__(self): gtk.Toolbar.__init__(self) self._view = None self._zoom_out = ToolButton('zoom-out') self._zoom_out.set_tooltip(_('Zoom out')) self._zoom_out.connect('clicked', self._zoom_out_cb) self.insert(self._zoom_out, -1) self._zoom_out.show() self._zoom_in = ToolButton('zoom-in') self._zoom_in.set_tooltip(_('Zoom in')) self._zoom_in.connect('clicked', self._zoom_in_cb) self.insert(self._zoom_in, -1) self._zoom_in.show() self._zoom_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() palette = self._zoom_to_width.get_palette() menu_item = MenuItem(_('Zoom to fit')) menu_item.connect('activate', self._zoom_to_fit_menu_item_activate_cb) palette.menu.append(menu_item) menu_item.show() menu_item = MenuItem(_('Actual size')) menu_item.connect('activate', self._actual_size_menu_item_activate_cb) palette.menu.append(menu_item) menu_item.show() tool_item = gtk.ToolItem() self.insert(tool_item, -1) tool_item.show() self._zoom_spin = gtk.SpinButton() self._zoom_spin.set_range(5.409, 400) self._zoom_spin.set_increments(1, 10) self._zoom_spin_notify_value_handler = self._zoom_spin.connect( 'notify::value', self._zoom_spin_notify_value_cb) tool_item.add(self._zoom_spin) self._zoom_spin.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() spacer = gtk.SeparatorToolItem() spacer.props.draw = False self.insert(spacer, -1) spacer.show() self._fullscreen = ToolButton('view-fullscreen') self._fullscreen.set_tooltip(_('Fullscreen')) self._fullscreen.connect('clicked', self._fullscreen_cb) self.insert(self._fullscreen, -1) self._fullscreen.show() self._view_notify_zoom_handler = None def set_view(self, view): self._view = view self._zoom_spin.props.value = self._view.get_zoom() self._view_notify_zoom_handler = \ self._view.connect_zoom_handler(self._view_notify_zoom_cb) self._update_zoom_buttons() def _zoom_spin_notify_value_cb(self, zoom_spin, pspec): self._view.set_zoom(zoom_spin.props.value) def _view_notify_zoom_cb(self, model, pspec): self._zoom_spin.disconnect(self._zoom_spin_notify_value_handler) try: self._zoom_spin.props.value = round(self._view.get_zoom()) finally: self._zoom_spin_notify_value_handler = self._zoom_spin.connect( 'notify::value', self._zoom_spin_notify_value_cb) def zoom_in(self): self._view.zoom_in() self._update_zoom_buttons() def _zoom_in_cb(self, button): self.zoom_in() def zoom_out(self): self._view.zoom_out() self._update_zoom_buttons() def _zoom_out_cb(self, button): self.zoom_out() def zoom_to_width(self): self._view.zoom_to_width() self._update_zoom_buttons() def _zoom_to_width_cb(self, button): self.zoom_to_width() def _update_zoom_buttons(self): self._zoom_in.props.sensitive = self._view.can_zoom_in() self._zoom_out.props.sensitive = self._view.can_zoom_out() self._zoom_to_width.props.sensitive = self._view.can_zoom_to_width() def _zoom_to_fit_menu_item_activate_cb(self, menu_item): self._view.zoom_to_best_fit() self._update_zoom_buttons() def _actual_size_menu_item_activate_cb(self, menu_item): self._view.zoom_to_actual_size() self._update_zoom_buttons() def _fullscreen_cb(self, button): self.emit('go-fullscreen')
def __init__(self, book, name, tooltip, custom): gtk.VBox.__init__(self) self.book = book self._changing = None self._check = None title = gtk.Toolbar() # title checkbox if custom: self._check = gtk.CheckButton() self._check.props.can_focus = False self._check.props.tooltip_text = \ _('Articles are ready to be published') self._check.connect('toggled', self._check_toggled_cb) check_box = gtk.HBox() check_box.set_size_request(50, -1) check_box.pack_start(self._check, True, False) title.insert(ToolWidget(check_box), -1) else: title.insert(ToolWidget(gtk.Label(' ')), -1) # title caption caption_label = gtk.Label(name) caption_label.props.tooltip_text = tooltip caption_label.modify_fg(gtk.STATE_NORMAL, COLOR_WHITE.get_gdk_color()) caption_box = gtk.HBox() caption_box.pack_start(caption_label, False) caption = gtk.EventBox() caption.add(caption_box) caption.modify_bg(gtk.STATE_NORMAL, COLOR_TOOLBAR_GREY.get_gdk_color()) title.insert(ToolWidget(caption), -1) separator = gtk.SeparatorToolItem() separator.props.draw = False separator.set_expand(True) title.insert(separator, -1) # create article button if custom: create = ToolButton('add', padding=0, tooltip=_('Create new article')) create.connect('clicked', self._create_cb) title.insert(create, -1) else: logger.debug('BookView(%s): listen for new articles' % name) self.book.connect('article-added', self._article_added_cb) # delete article button delete = ToolButton('edit-delete', padding=0, tooltip=_('Delete current article')) delete.connect('clicked', self._delete_cb) title.insert(delete, -1) # move buttons downward = ToolButton('down', padding=0, tooltip=_('Move article downward')) downward.connect('clicked', self._swap_cb, +1) title.insert(downward, -1) upward = ToolButton('up', padding=0, tooltip=_('Move article upward')) upward.connect('clicked', self._swap_cb, -1) title.insert(upward, -1) # tree self.store = gtk.ListStore(bool, str) self.tree = gtk.TreeView(self.store) self.tree.props.headers_visible = False self.tree.connect('cursor-changed', self._cursor_changed_cb) cell = gtk.CellRendererToggle() cell.connect('toggled', self._cell_toggled_cb) cell.props.activatable = True column = self.tree.insert_column_with_attributes(0, '', cell, active=0) column.props.sizing = gtk.TREE_VIEW_COLUMN_FIXED column.props.fixed_width = 50 column.props.visible = custom cell = gtk.CellRendererText() cell.connect('edited', self._cell_edited_cb) cell.props.editable = True self.tree.insert_column_with_attributes(1, '', cell, text=1) for i in self.book.index: self.store.append((i['ready'], i['title'])) # scrolled tree tree_scroll = gtk.ScrolledWindow() tree_scroll.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC) tree_scroll.add(self.tree) self.pack_start(title, False) self.pack_start(tree_scroll) if len(self.store): self.tree.set_cursor(0, self.tree.get_column(1), False) if custom: self._update_check(self.store[0][PUBLISH]) self.show_all()
def __init__(self, handle): activity.Activity.__init__(self, handle, True) self.max_participants = 1 # CHART_OPTIONS self.x_label = "" self.y_label = "" self.chart_color = utils.get_user_fill_color('str') self.chart_line_color = utils.get_user_stroke_color('str') self.current_chart = None self.charts_area = None self.chart_data = [] # TOOLBARS toolbarbox = ToolbarBox() activity_button = ActivityToolbarButton(self) activity_btn_toolbar = activity_button.page activity_btn_toolbar.title.connect('changed', self._set_chart_title) save_as_image = ToolButton("save-as-image") save_as_image.connect("clicked", self._save_as_image) save_as_image.set_tooltip(_("Save as image")) activity_btn_toolbar.insert(save_as_image, -1) save_as_image.show() toolbarbox.toolbar.insert(activity_button, 0) import_freespace = ToolButton("import-freespace") import_freespace.connect("clicked", self.__import_freespace_cb) import_freespace.set_tooltip(_("Read Freespace data")) toolbarbox.toolbar.insert(import_freespace, -1) import_freespace.show() import_journal = ToolButton('import-journal') import_journal.connect('clicked', self.__import_journal_cb) import_journal.set_tooltip(_('Read Journal data')) toolbarbox.toolbar.insert(import_journal, -1) import_journal.show() import_turtle = ToolButton('import-turtle') import_turtle.connect('clicked', self.__import_turtle_cb) import_turtle.set_tooltip(_('Read Turtle data')) toolbarbox.toolbar.insert(import_turtle, -1) import_turtle.show() separator = gtk.SeparatorToolItem() separator.set_draw(True) separator.set_expand(False) toolbarbox.toolbar.insert(separator, -1) add_vbar_chart = RadioToolButton() add_vbar_chart.connect("clicked", self._add_chart_cb, "vbar") add_vbar_chart.set_tooltip(_("Vertical Bar Chart")) add_vbar_chart.props.icon_name = "vbar" charts_group = add_vbar_chart toolbarbox.toolbar.insert(add_vbar_chart, -1) add_hbar_chart = RadioToolButton() add_hbar_chart.connect("clicked", self._add_chart_cb, "hbar") add_hbar_chart.set_tooltip(_("Horizontal Bar Chart")) add_hbar_chart.props.icon_name = "hbar" add_hbar_chart.props.group = charts_group toolbarbox.toolbar.insert(add_hbar_chart, -1) add_pie_chart = RadioToolButton() add_pie_chart.connect("clicked", self._add_chart_cb, "pie") add_pie_chart.set_tooltip(_("Pie Chart")) add_pie_chart.props.icon_name = "pie" add_pie_chart.props.group = charts_group add_pie_chart.set_active(True) toolbarbox.toolbar.insert(add_pie_chart, -1) self.chart_type_buttons = [ add_vbar_chart, add_hbar_chart, add_pie_chart ] separator = gtk.SeparatorToolItem() separator.set_draw(True) separator.set_expand(False) toolbarbox.toolbar.insert(separator, -1) fullscreen_btn = ToolButton('view-fullscreen') fullscreen_btn.set_tooltip(_('Fullscreen')) fullscreen_btn.connect("clicked", self.__fullscreen_cb) toolbarbox.toolbar.insert(fullscreen_btn, -1) charthelp.create_help(toolbarbox.toolbar) separator = gtk.SeparatorToolItem() separator.set_draw(False) separator.set_expand(True) toolbarbox.toolbar.insert(separator, -1) stopbtn = StopButton(self) toolbarbox.toolbar.insert(stopbtn, -1) self.set_toolbar_box(toolbarbox) # CANVAS paned = gtk.HPaned() box = gtk.VBox() self.box = box # Set the info box width to 1/3 of the screen: def size_allocate_cb(widget, allocation): paned.disconnect(self._setup_handle) box_width = allocation.width / 3 box.set_size_request(box_width, -1) self._setup_handle = paned.connect('size_allocate', size_allocate_cb) scroll = gtk.ScrolledWindow() scroll.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC) self.labels_and_values = ChartData(self) scroll.add(self.labels_and_values) self.labels_and_values.connect("label-changed", self._label_changed) self.labels_and_values.connect("value-changed", self._value_changed) box.pack_start(scroll, True, True, 0) paned.add1(box) # CHARTS AREA eventbox = gtk.EventBox() self.charts_area = ChartArea(self) self.charts_area.connect('size_allocate', self._chart_size_allocate) eventbox.modify_bg(gtk.STATE_NORMAL, _WHITE) eventbox.add(self.charts_area) paned.add2(eventbox) self.set_canvas(paned) self.show_all()
class EntryToolbar(gtk.Toolbar): __gsignals__ = { 'volume-error': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE, ([str, str])), } def __init__(self): gtk.Toolbar.__init__(self) self._metadata = None self._temp_file_path = None self._resume = ToolButton('activity-start') self._resume.connect('clicked', self._resume_clicked_cb) self.add(self._resume) self._resume.show() client = gconf.client_get_default() color = XoColor(client.get_string('/desktop/sugar/user/color')) self._copy = ToolButton() icon = Icon(icon_name='edit-copy', xo_color=color) self._copy.set_icon_widget(icon) icon.show() self._copy.set_tooltip(_('Copy to')) self._copy.connect('clicked', self._copy_clicked_cb) self.add(self._copy) self._copy.show() self._duplicate = ToolButton() icon = Icon(icon_name='edit-duplicate', xo_color=color) self._duplicate.set_icon_widget(icon) self._duplicate.set_tooltip(_('Duplicate')) self._duplicate.connect('clicked', self._duplicate_clicked_cb) self.add(self._duplicate) separator = gtk.SeparatorToolItem() self.add(separator) separator.show() erase_button = ToolButton('list-remove') erase_button.set_tooltip(_('Erase')) erase_button.connect('clicked', self._erase_button_clicked_cb) self.add(erase_button) erase_button.show() def set_metadata(self, metadata): self._metadata = metadata self._refresh_copy_palette() self._refresh_duplicate_palette() self._refresh_resume_palette() def _resume_clicked_cb(self, button): misc.resume(self._metadata) def _copy_clicked_cb(self, button): button.palette.popup(immediate=True, state=Palette.SECONDARY) def _duplicate_clicked_cb(self, button): file_path = model.get_file(self._metadata['uid']) try: model.copy(self._metadata, '/') except IOError, e: logging.exception('Error while copying the entry.') self.emit('volume-error', _('Error while copying the entry. %s') % (e.strerror, ), _('Error'))
def __init__(self, handle): Activity.__init__(self, handle) logger.debug('Starting Slider Puzzle activity... %s' % str(get_bundle_path())) os.chdir(get_bundle_path()) self.connect('destroy', self._destroy_cb) self._sample_window = None self.fixed = gtk.Fixed() self.ui = SliderPuzzleUI(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() btn_9 = ToolButton() btn_9.set_tooltip(_('9 blocks')) toolbar_box.toolbar.insert(btn_9, -1) #btn_9.set_active(True) btn_9.connect('clicked', self.ui.set_nr_pieces, 9) btn_9.show() btn_12 = ToolButton() btn_12.set_tooltip(_('12 blocks')) toolbar_box.toolbar.insert(btn_12, -1) #btn_9.set_active(True) btn_12.connect('clicked', self.ui.set_nr_pieces, 12) btn_12.show() btn_16 = ToolButton() btn_16.set_tooltip(_('16 blocks')) toolbar_box.toolbar.insert(btn_16, -1) #btn_9.set_active(True) btn_16.connect('clicked', self.ui.set_nr_pieces, 16) btn_16.show() btn_solve = ToolButton() btn_solve.set_tooltip(_('Solve')) toolbar_box.toolbar.insert(btn_solve, -1) #btn_9.set_active(True) btn_solve.connect('clicked', self.ui.do_solve) btn_solve.show() btn_shuffle = ToolButton() btn_shuffle.set_tooltip(_('Shuffle')) toolbar_box.toolbar.insert(btn_shuffle, -1) #btn_9.set_active(True) btn_shuffle.connect('clicked', self.ui.do_shuffle) btn_shuffle.show() btn_add = ToolButton() btn_add.set_tooltip(_('Add Picture')) toolbar_box.toolbar.insert(btn_add, -1) #btn_9.set_active(True) btn_add.connect('clicked', self.ui.do_add_image) btn_add.show() btn_select = ToolButton() btn_select.set_tooltip(_('Add Picture')) toolbar_box.toolbar.insert(btn_select, -1) #btn_9.set_active(True) btn_select.connect('clicked', self.do_samples_cb) btn_select.show() self.set_canvas(self.ui) self.show_all() self.frozen = FrozenState(self.ui) self.ui.game.connect('shuffled', self.frozen.sync) TubeHelper.__init__(self, tube_class=GameTube, service=SERVICE)
class ViewToolbar(gtk.Toolbar): __gtype_name__ = 'ViewToolbar' __gsignals__ = { 'go-fullscreen': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE, ([])) } def __init__(self, view): gtk.Toolbar.__init__(self) self._view = view self._zoom_out = ToolButton('zoom-out') self._zoom_out.set_tooltip(_('Zoom out')) self._zoom_out.connect('clicked', self._zoom_out_cb) self.insert(self._zoom_out, -1) self._zoom_out.show() self._zoom_in = ToolButton('zoom-in') self._zoom_in.set_tooltip(_('Zoom in')) self._zoom_in.connect('clicked', self._zoom_in_cb) self.insert(self._zoom_in, -1) self._zoom_in.show() self._zoom_tofit = ToolButton('zoom-best-fit') self._zoom_tofit.set_tooltip(_('Fit to window')) self._zoom_tofit.connect('clicked', self._zoom_tofit_cb) self.insert(self._zoom_tofit, -1) self._zoom_tofit.show() self._zoom_original = ToolButton('zoom-original') self._zoom_original.set_tooltip(_('Original size')) self._zoom_original.connect('clicked', self._zoom_original_cb) self.insert(self._zoom_original, -1) self._zoom_original.show() spacer = gtk.SeparatorToolItem() spacer.props.draw = False self.insert(spacer, -1) spacer.show() self._rotate_anticlockwise = ToolButton('rotate_anticlockwise') self._rotate_anticlockwise.set_tooltip(_('Rotate anticlockwise')) self._rotate_anticlockwise.connect('clicked', self._rotate_anticlockwise_cb) self.insert(self._rotate_anticlockwise, -1) self._rotate_anticlockwise.show() self._rotate_clockwise = ToolButton('rotate_clockwise') self._rotate_clockwise.set_tooltip(_('Rotate clockwise')) self._rotate_clockwise.connect('clicked', self._rotate_clockwise_cb) self.insert(self._rotate_clockwise, -1) self._rotate_clockwise.show() spacer = gtk.SeparatorToolItem() spacer.props.draw = False self.insert(spacer, -1) spacer.show() self._fullscreen = ToolButton('view-fullscreen') self._fullscreen.set_tooltip(_('Fullscreen')) self._fullscreen.connect('clicked', self._fullscreen_cb) self.insert(self._fullscreen, -1) self._fullscreen.show() def _zoom_in_cb(self, button): self._zoom_in.set_sensitive(self._view.zoom_in()) self._zoom_out.set_sensitive(True) def _zoom_out_cb(self, button): self._zoom_out.set_sensitive(self._view.zoom_out()) self._zoom_in.set_sensitive(True) def _zoom_tofit_cb(self, button): zoom = self._view.calculate_optimal_zoom() self._view.set_zoom(zoom) def _zoom_original_cb(self, button): self._view.set_zoom(1) def _rotate_anticlockwise_cb(self, button): angle = self._view.get_property('angle') self._view.set_angle(angle + 90) def _rotate_clockwise_cb(self, button): angle = self._view.get_property('angle') if angle == 0: angle = 360 self._view.set_angle(angle - 90) def _fullscreen_cb(self, button): self.emit('go-fullscreen')
class SensorToolbar(gtk.Toolbar): """ The toolbar for resitance and voltage sensors """ __gsignals__ = { 'add-media': (gobject.SIGNAL_RUN_FIRST, None, [object]), 'add-opened': (gobject.SIGNAL_RUN_FIRST, None, [object]) } def __init__(self, activity): """ By default, start with resistance mode """ gtk.Toolbar.__init__(self) self.mode = 'resistance' self._STR_BASIC = \ _("Sensors, DC (connect sensor to pink 'Mic In' on left side of XO)") \ + ' ' self._STR_R = _('Bias/Offset Enabled') + ' ' + _('Ohms') + ' ' self._STR_V = _('Bias/Offset Disabled') + ' ' + _('Volts') + ' ' self._STR_I = ' ' + _('Invert') + ' ' self.string_for_textbox = "" self.activity = activity self.activity.audiograb.set_sensor(self) # Set up Resistance Button if self.activity.has_toolbarbox: self.resistance = ToolButton('bias-on') else: self.resistance = ToolButton('bias-on2') self.insert(self.resistance, -1) self.resistance.show() self.resistance.set_tooltip(_('Resistance Sensor')) self.resistance.connect('clicked', self.set_resistance_voltage_mode, 'resistance') # Set up Voltage Button self.voltage = ToolButton('bias-off') self.insert(self.voltage, -1) self.voltage.set_tooltip(_('Voltage Sensor')) self.voltage.connect('clicked', self.set_resistance_voltage_mode, 'voltage') # Set up Invert Button self._invert = ToolButton('invert') self.insert(self._invert, -1) self._invert.set_tooltip(_('Invert')) self._invert.connect('clicked', self._invert_control_cb) self.activity.wave.set_invert_state(False) separator = gtk.SeparatorToolItem() separator.props.draw = True self.insert(separator, -1) self.audiobutton = ToolButton('add-icon') self.insert(self.audiobutton, -1) self.audiobutton.show() self.audiobutton.set_tooltip('Close Sound') self.audiobutton.connect('clicked', self.addAudio) self.connect('add-media', self.addThisAudio) self.insert(separator, -1) self.insert(separator, -1) self.openedbutton = ToolButton('delete-icon') self.insert(self.openedbutton, -1) self.openedbutton.show() self.openedbutton.set_tooltip('Open Sound') self.openedbutton.connect('clicked', self.addOpenedAudio) self.connect('add-opened', self.addThisOpenedAudio) self.insert(separator, -1) self.insert(separator, -1) # Set up Logging Interval combo box self.loginterval_img = gtk.Image() self.loginterval_img.set_from_file(ICONS_DIR + '/sample_rate.svg') self.loginterval_img_tool = gtk.ToolItem() self.loginterval_img_tool.add(self.loginterval_img) self.insert(self.loginterval_img_tool, -1) self._loginterval_combo = ComboBox() self.interval = [ _('1/10 second'), _('1 second'), _('30 seconds'), _('5 minutes'), _('30 minutes') ] if hasattr(self._loginterval_combo, 'set_tooltip_text'): self._loginterval_combo.set_tooltip_text(_('Sampling interval')) self._interval_changed_id = self._loginterval_combo.connect( "changed", self.loginterval_control) for i, s in enumerate(self.interval): self._loginterval_combo.append_item(i, s, None) if s == _('1 second'): self._loginterval_combo.set_active(i) self._loginterval_tool = ToolComboBox(self._loginterval_combo) self.insert(self._loginterval_tool, -1) self.logginginterval_status = '1 second' # Set up Logging/Stop Logging Button self._record = ToolButton('media-record') self.insert(self._record, -1) self._record.set_tooltip(_('Start Recording')) self._record.connect('clicked', self.record_control) self.show_all() def addAudio(self, button): #self.activity.showFileLoadBlocker(True) fp = FilePicker() dOb = fp.show() if (dOb != None): if (dOb.file_path != None): self.emit('add-media', dOb) #self.activity.showFileLoadBlocker(False) def addOpenedAudio(self, button): fp = FilePicker() dOb = fp.show() if (dOb != None): if (dOb.file_path != None): self.emit('add-opened', dOb) def addThisAudio(self, ot, datastoreOb): self.activity.closedSound = datastoreOb #self.activity.playsound.setLocation("file://"+datastoreOb.file_path) #self.activity.playsound.play() def addThisOpenedAudio(self, ot, datastoreOb): self.activity.openedSound = datastoreOb def set_sample_value(self, label=None): """ Write a sample value to the textbox """ gtk.threads_enter() self._update_string_for_textbox(label) gtk.threads_leave() return def record_control(self, data=None): """Depending upon the selected interval, does either a logging session, or just logs the current buffer""" if not self.activity.LOGGING_IN_SESSION: Xscale = (1.00 / self.activity.audiograb.get_sampling_rate()) Yscale = 0.0 interval = self.interval_convert() username = self.activity.nick print "calling start new session" self.activity.ji.start_new_session(username, Xscale, Yscale, _(self.logginginterval_status)) self.activity.audiograb.set_logging_params(True, interval, False) self.activity.LOGGING_IN_SESSION = True self._record.set_icon('record-stop') self._record.show() self._record.set_tooltip(_('Stop Recording')) else: self.activity.audiograb.set_logging_params(False) self.activity.LOGGING_IN_SESSION = False self._record.set_icon('media-record') self._record.show() self._record.set_tooltip(_('Start Recording')) def interval_convert(self): """Converts interval string to an integer that denotes the number of times the audiograb buffer must be called before a value is written. When set to 0, the whole of current buffer will be written""" interval_dictionary = { '1/10 second': 0.1, '1 second': 1, '30 seconds': 30, '5 minutes': 300, '30 minutes': 1800 } try: return interval_dictionary[self.logginginterval_status] except ValueError: logging.error('logging interval status = %s' %\ (str(self.logginginterval_status))) return 0 def loginterval_control(self, combobox): """ Callback from the Logging Interval Combo box: sets status """ if self._loginterval_combo.get_active() != -1: intervals = [ '1/10 second', '1 second', '30 seconds', '5 minutes', '30 minutes' ] self.logginginterval_status = \ intervals[self._loginterval_combo.get_active()] def set_resistance_voltage_mode(self, data=None, mode_to_set='resistance'): """ Callback for Resistance/Voltage Buttons """ # Make sure the current context is for sensor capture. if self.activity.CONTEXT != 'sensor': self.activity.set_sensor_context() self.set_mode(mode_to_set) if mode_to_set == 'resistance': self.resistance.set_icon('bias-on2') self.voltage.set_icon('bias-off') self.resistance.show() self.voltage.show() self._update_string_for_textbox() if self.activity.has_toolbarbox: self.activity.label_button.set_icon('bias-on2') self.activity.label_button.set_tooltip(_('Resistance Sensor')) elif mode_to_set == 'voltage': self.resistance.set_icon('bias-on') self.voltage.set_icon('bias-off2') self.resistance.show() self.voltage.show() self._update_string_for_textbox() if self.activity.has_toolbarbox: self.activity.label_button.set_icon('bias-off2') self.activity.label_button.set_tooltip(_('Voltage Sensor')) else: logging.error('unknown mode %s' % (mode_to_set)) if self.activity.has_toolbarbox: self.activity.sound_toolbar.time.set_icon('domain-time') self.activity.sound_toolbar.freq.set_icon('domain-freq') return False def _invert_control_cb(self, data=None): """ Callback for Invert Button """ if self.activity.wave.get_invert_state(): self.activity.wave.set_invert_state(False) self._invert.set_icon('invert') self._invert.show() else: self.activity.wave.set_invert_state(True) self._invert.set_icon('invert2') self._invert.show() self._update_string_for_textbox() return False def set_mode(self, mode='resistance'): """ Set the mixer settings to match the current mode. """ self.mode = mode self.activity.audiograb.set_sensor_type(self.mode) return def context_off(self): """ Called when sensor toolbar is no longer selected. """ self.activity.audiograb.pause_grabbing() def context_on(self): """ Called when sensor toolbar is selected. """ self.activity.audiograb.resume_grabbing() self.activity.audiograb.set_sensor_type(self.mode) self._update_string_for_textbox() self.activity.wave.set_trigger(self.activity.wave.TRIGGER_NONE) return False def _update_string_for_textbox(self, value=None): """ Update the status field at the bottom of the canvas. """ self.string_for_textbox = "" self.string_for_textbox += (self._STR_BASIC + "\n") if self.mode == 'resistance': self.string_for_textbox += self._STR_R else: self.string_for_textbox += self._STR_V if self.activity.wave.get_invert_state(): self.string_for_textbox += self._STR_I if value is not None: self.string_for_textbox += '\t(%s)' % (str(value)) self.activity.text_box.set_data_params(0, self.string_for_textbox)
def __init__(self, client, event): gtk.Window.__init__(self) self._client = client self._event = event self.set_decorated(False) self.set_position(gtk.WIN_POS_CENTER_ALWAYS) self.set_border_width(style.LINE_WIDTH) window = gtk.VBox() self.add(window) toolbar = gtk.Toolbar() window.pack_start(toolbar, False) icon = Icon() icon.set_from_icon_name('emblem-warning', gtk.ICON_SIZE_LARGE_TOOLBAR) icon.props.xo_color = profile.get_color() tool_item = gtk.ToolItem() tool_item.add(icon) toolbar.insert(tool_item, -1) separator = gtk.SeparatorToolItem() separator.props.draw = False separator.set_size_request(style.DEFAULT_SPACING, -1) toolbar.insert(separator, -1) title = gtk.Label(_('Submit failure report')) tool_item = gtk.ToolItem() tool_item.add(title) toolbar.insert(tool_item, -1) separator = gtk.SeparatorToolItem() separator.props.draw = False separator.set_expand(True) toolbar.insert(separator, -1) submit = ToolButton('dialog-ok', tooltip=_('Submit')) submit.connect('clicked', lambda button: self._submit()) toolbar.insert(submit, -1) cancel = ToolButton('dialog-cancel', tooltip=_('Cancel')) cancel.connect('clicked', lambda button: self.destroy()) toolbar.insert(cancel, -1) bg = gtk.EventBox() bg.modify_bg(gtk.STATE_NORMAL, style.COLOR_WHITE.get_gdk_color()) window.pack_start(bg) canvas = gtk.VBox() canvas.set_border_width(style.DEFAULT_SPACING) canvas.props.spacing = style.DEFAULT_SPACING bg.add(canvas) box = gtk.HBox() box.props.spacing = style.DEFAULT_SPACING canvas.pack_start(box, False) if 'icon' in event: icon = Icon(file=event['icon'], pixel_size=style.XLARGE_ICON_SIZE) else: icon = Icon() icon.set_from_icon_name('emblem-warning', gtk.ICON_SIZE_LARGE_TOOLBAR) box.pack_start(icon, False) label = gtk.Label() label.props.use_markup = True if 'solution' in event: activity_name = '%(name)s-%(version)s' % event['solution'][0] else: activity_name = event['context'] label.props.label = '<b>%s</b>\n%s' % (activity_name, event['error']) label.props.wrap = True box.pack_start(label, False) frame = gtk.Frame( _('Optionally, describe the problem in common sentences')) canvas.pack_start(frame) self._message = gtk.TextView() scrolled = gtk.ScrolledWindow() scrolled.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC) scrolled.set_border_width(style.DEFAULT_PADDING) scrolled.add(self._message) frame.add(scrolled) frame = gtk.Frame(_('Log')) canvas.pack_start(frame) text = gtk.TextView() text.props.editable = False if 'trace' in event: text.props.buffer.props.text = '\n'.join(event['trace']) scrolled = gtk.ScrolledWindow() scrolled.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC) scrolled.set_border_width(style.DEFAULT_PADDING) scrolled.add(text) frame.add(scrolled) self.show_all() self.set_focus(self._message) self.connect('realize', self.__realize_cb) gap = style.GRID_CELL_SIZE width = gtk.gdk.screen_width() - gap * 2 height = gtk.gdk.screen_height() - gap * 2 self.set_size_request(width, height) self.move(gap, gap)
class EcomundoActivity(activity.Activity): def __init__(self, handle): activity.Activity.__init__(self, handle) self.set_title("Ecomundo") print "Init activity Ecomundo" #print os.path.abspath(__file__) toolbox = activity.ActivityToolbox(self) self.toolbar = gtk.Toolbar() toolbox.add_toolbar(_('Ecomundo'), self.toolbar) self.toolbar.show() self.set_toolbox(toolbox) toolbox.show() self.btnNew = ToolButton('reload') self.btnNew.connect('clicked', self.onBtNewClicked) self.toolbar.insert(self.btnNew, -1) self.btnNew.show() self.btPlay = ToolButton('next') self.btPlay.connect('clicked', self.onBtPlayClicked) self.toolbar.insert(self.btPlay, -1) self.btPlay.show() self.btStop = ToolButton('process-stop') self.btStop.connect('clicked', self.onBtStopClicked) self.toolbar.insert(self.btStop, -1) self.btStop.show() self.btStop.props.sensitive = False self.btPlay.props.sensitive = True toolbox.set_current_toolbar(1) hBox = gtk.HBox(False, 0) self.set_canvas(hBox) self.drawingarea1 = gtk.DrawingArea() self.drawingarea1.set_size_request( World.SIZE_WORLD + (2 * World.MARGEN), World.SIZE_WORLD + (2 * World.MARGEN)) self.drawingarea1.show() hBox.pack_start(self.drawingarea1, False, True, 5) table = gtk.Table(rows=4, columns=2, homogeneous=False) hBox.pack_start(table, False, False, 5) label_attributes = pango.AttrList() label_attributes.insert(pango.AttrSize(14000, 0, -1)) label_attributes.insert( pango.AttrForeground(65535, 65535, 65535, 0, -1)) lbTitle = gtk.Label() lbTitle.set_attributes(label_attributes) lbTitle.set_text(_('Initial Values')) #table.attach(lbTitle, 0, 1, 0, 1,yoptions=gtk.SHRINK,xpadding=5) table.attach(lbTitle, 0, 2, 0, 1, yoptions=gtk.SHRINK, xpadding=10) lbGreen = gtk.Label() lbGreen.set_attributes(label_attributes) lbGreen.set_text(_('Green')) table.attach(lbGreen, 0, 1, 1, 2, yoptions=gtk.SHRINK, xoptions=gtk.SHRINK, xpadding=10) adjGreen = gtk.Adjustment(10, 1, 400, 1, 1, 0) self.spbGreen = gtk.SpinButton(adjustment=adjGreen, climb_rate=1.0, digits=2) table.attach(self.spbGreen, 1, 2, 1, 2, yoptions=gtk.SHRINK, xoptions=gtk.SHRINK, ypadding=10) lbRabbit = gtk.Label() lbRabbit.set_attributes(label_attributes) lbRabbit.set_text(_('Rabbits')) table.attach(lbRabbit, 0, 1, 2, 3, yoptions=gtk.SHRINK, xoptions=gtk.SHRINK, xpadding=10) adjRabbit = gtk.Adjustment(10, 1, 400, 1, 1, 0) self.spbRabbit = gtk.SpinButton(adjustment=adjRabbit, climb_rate=1.0, digits=2) table.attach(self.spbRabbit, 1, 2, 2, 3, yoptions=gtk.SHRINK, xoptions=gtk.SHRINK, ypadding=10) lbFox = gtk.Label() lbFox.set_attributes(label_attributes) lbFox.set_text(_('Foxs')) table.attach(lbFox, 0, 1, 3, 4, yoptions=gtk.SHRINK, xoptions=gtk.SHRINK, xpadding=10) adjFox = gtk.Adjustment(10, 1, 400, 1, 1, 0) self.spbFox = gtk.SpinButton(adjustment=adjFox, climb_rate=1.0, digits=2) table.attach(self.spbFox, 1, 2, 3, 4, yoptions=gtk.SHRINK, xoptions=gtk.SHRINK, ypadding=10) print "test resize" print "antes de initWorld" initWorld() print "antes de init Green" initGreen() print "antes de init Animals" initAnimals() hBox.resize_children() hBox.show_all() self.drawingarea1.connect('expose-event', self.onDrawingAreaExposed) def onDrawingAreaExposed(self, da, event): #print "drawingarea exposed" x, y, width, height = da.allocation ctx = da.window.cairo_create() drawStateWorld(ctx) drawGrid(ctx) def onBtPlayClicked(self, widget): self.btStop.props.sensitive = True self.btPlay.props.sensitive = False world.playState = True source_id = gobject.timeout_add(2000, updateState, self.drawingarea1) # http://www.pygtk.org/pygtk2tutorial-es/ch-TimeoutsIOAndIdleFunctions.html#sec-Timeouts def onBtStopClicked(self, widget): self.btStop.props.sensitive = False self.btPlay.props.sensitive = True world.playState = False def onBtNewClicked(self, widget): initWorld() world.initialGreen = self.spbGreen.get_value_as_int() world.initialRabbits = self.spbRabbit.get_value_as_int() world.initialFoxs = self.spbFox.get_value_as_int() initGreen() initAnimals() # Despues de esto hay que recargar la pantalla drawingarea1 = self.drawingarea1 ctx = drawingarea1.window.cairo_create() drawStateWorld(ctx) drawGrid(ctx)
def __init__(self, activity): self._activity = activity GtkSourceview2Editor.__init__(self, activity) #set the default contents for edit,override fixed font size self.font_size = activity.debug_dict.get('font_size', 8) self.find_window = None self.editbar = gtk.Toolbar() self.last_folder = None editopen = ToolButton() editopen.set_stock_id('gtk-new') editopen.set_icon_widget(None) editopen.set_tooltip(_('New File')) editopen.connect('clicked', self._new_file_cb) editopen.add_accelerator('clicked', activity.accelerator, ord('N'), gtk.gdk.CONTROL_MASK, gtk.ACCEL_VISIBLE) #editopen.props.accelerator = '<Ctrl>O' editopen.show() self.editbar.insert(editopen, -1) editfile = ToolButton() editfile.set_stock_id('gtk-open') editfile.set_icon_widget(None) editfile.set_tooltip(_('Open File')) editfile.connect('clicked', self._read_file_cb) editfile.add_accelerator('clicked', activity.accelerator, ord('O'), gtk.gdk.CONTROL_MASK, gtk.ACCEL_VISIBLE) #editfile.props.accelerator = '<Ctrl>O' editfile.show() self.editbar.insert(editfile, -1) editsave = ToolButton() editsave.set_stock_id('gtk-save') editsave.set_icon_widget(None) editsave.set_tooltip(_('Save File')) editsave.add_accelerator('clicked', activity.accelerator, ord('S'), gtk.gdk.CONTROL_MASK, gtk.ACCEL_VISIBLE) #editsave.props.accelerator = '<Ctrl>S' editsave.connect('clicked', self.save_cb) editsave.show() self.editbar.insert(editsave, -1) editsaveas = ToolButton() editsaveas.set_stock_id('gtk-save-as') editsaveas.set_icon_widget(None) editsaveas.set_tooltip(_('Save As')) #editsaveas.props.accelerator = '<Ctrl>S' editsaveas.connect('clicked', self.save_file_cb) editsaveas.show() self.editbar.insert(editsaveas, -1) """ editjournal = ToolButton(tooltip=_('Open Journal')) client = gconf.client_get_default() color = XoColor(client.get_string('/desktop/sugar/user/color')) journal_icon = Icon(icon_name='document-save', xo_color=color) editjournal.set_icon_widget(journal_icon) editjournal.connect('clicked', self._show_journal_object_picker_cb) #editjournal.props.accelerator = '<Ctrl>J' editjournal.show() self.editbar.insert(editjournal, -1) """ separator = gtk.SeparatorToolItem() separator.set_draw(True) separator.show() self.editbar.insert(separator, -1) editundo = ToolButton('undo') editundo.set_tooltip(_('Undo')) editundo.connect('clicked', self.undo) editundo.add_accelerator('clicked', activity.accelerator, ord('Z'), gtk.gdk.CONTROL_MASK, gtk.ACCEL_VISIBLE) #editundo.props.accelerator = '<Ctrl>Z' editundo.show() self.editbar.insert(editundo, -1) editredo = ToolButton('redo') editredo.set_tooltip(_('Redo')) editredo.connect('clicked', self.redo) editredo.add_accelerator('clicked', activity.accelerator, ord('Y'), gtk.gdk.CONTROL_MASK, gtk.ACCEL_VISIBLE) #editredo.props.accelerator = '<Ctrl>Y' editredo.show() self.editbar.insert(editredo, -1) separator = gtk.SeparatorToolItem() separator.set_draw(True) separator.show() self.editbar.insert(separator, -1) editcut = ToolButton() editcut.set_stock_id('gtk-cut') editcut.set_icon_widget(None) editcut.set_tooltip(_('Cut')) self.edit_cut_handler_id = editcut.connect('clicked', self.cut) editcut.add_accelerator('clicked', activity.accelerator, ord('X'), gtk.gdk.CONTROL_MASK, gtk.ACCEL_VISIBLE) #editcut.props.accelerator = '<Ctrl>X' self.editbar.insert(editcut, -1) editcut.show() editcopy = ToolButton('edit-copy') editcopy.set_tooltip(_('Copy')) self.edit_copy_handler_id = editcopy.connect('clicked', self.copy_to_clipboard_cb) editcopy.add_accelerator('clicked', activity.accelerator, ord('C'), gtk.gdk.CONTROL_MASK, gtk.ACCEL_VISIBLE) #editcopy.props.accelerator = '<Ctrl>C' self.editbar.insert(editcopy, -1) editcopy.show() editpaste = ToolButton('edit-paste') editpaste.set_tooltip(_('Paste')) self.edit_paste_handler_id = editpaste.connect('clicked', self.paste) editpaste.add_accelerator('clicked', activity.accelerator, ord('V'), gtk.gdk.CONTROL_MASK, gtk.ACCEL_VISIBLE) #editpaste.props.accelerator = '<Ctrl>V' editpaste.show() self.editbar.insert(editpaste, -1) """ separator = gtk.SeparatorToolItem() separator.set_draw(True) separator.show() self.editbar.insert(separator, -1) """ editfind = ToolButton('viewmag1') editfind.set_tooltip(_('Find and Replace')) editfind.connect('clicked', self.show_find) editfind.add_accelerator('clicked', activity.accelerator, ord('F'), gtk.gdk.CONTROL_MASK, gtk.ACCEL_VISIBLE) #editfind.props.accelerator = '<Ctrl>F' editfind.show() self.editbar.insert(editfind, -1) """ separator = gtk.SeparatorToolItem() separator.set_draw(True) separator.show() self.editbar.insert(separator, -1) """ self.zoomout = ToolButton('zoom-out') self.zoomout.set_tooltip(_('Zoom out')) self.zoomout.connect('clicked', self.__zoomout_clicked_cb) self.editbar.insert(self.zoomout, -1) self.zoomout.show() self.zoomin = ToolButton('zoom-in') self.zoomin.set_tooltip(_('Zoom in')) self.zoomin.connect('clicked', self.__zoomin_clicked_cb) self.editbar.insert(self.zoomin, -1) self.zoomin.show() stop_button = ToolButton('activity-stop') stop_button.set_tooltip(_('Stop')) #stop_button.props.accelerator = '<Ctrl>Q' stop_button.connect('clicked', self.__stop_clicked_cb) self.editbar.insert(stop_button, -1) stop_button.show() self.editbar.show_all()
class Jam2JamToolBar(gtk.Toolbar): def __init__(self, activity): gtk.Toolbar.__init__(self) self.activity = activity self.parameters = ['Density', 'Pitch', 'Length', 'Timbre', 'Volume'] # no tempo here. scene_stuff = readScenes(self.activity._ScenePath) self.scenes = scene_stuff.get_scene_list() #example of scene data. This gets read from file #self.scenes = [['City', 'A', 'minor pentatonic'], ['City', 'G#', 'major']] #this data needs to be obtained from directories self.play_pause_state = 'Playing' self.scene_init = True # Separator separator = gtk.SeparatorToolItem() separator.set_draw(True) self.insert(separator, -1) #Horizontal Parameter control combobox self._add_widget(gtk.Label(_('Horizontal:'))) self._Hparameter_combo = ToolComboBox() for i, f in enumerate(self.parameters): self._Hparameter_combo.combo.append_item(i, f) self._Hparameter_combo.combo.connect('changed', self._Hparameter_change_cb) self._add_widget(self._Hparameter_combo) self._Hparameter_combo.combo.set_active(0) # Separator separator = gtk.SeparatorToolItem() separator.set_draw(True) separator.show() self.insert(separator, -1) #Vertical Parameter control combobox self._add_widget(gtk.Label(_('Vertical:'))) self._Vparameter_combo = ToolComboBox() for j, k in enumerate(self.parameters): self._Vparameter_combo.combo.append_item(j, k) self._Vparameter_combo.combo.connect('changed', self._Vparameter_change_cb) self._add_widget(self._Vparameter_combo) self._Vparameter_combo.combo.set_active(1) # Separator separator = gtk.SeparatorToolItem() separator.set_draw(True) separator.show() self.insert(separator, -1) #Scene Selection control combobox self._add_widget(gtk.Label(_('Scene:'))) self._Scene_combo = ToolComboBox() for l, m in enumerate(self.scenes): self._Scene_combo.combo.append_item(l, m[0]) self._Scene_combo.combo.connect('changed', self._Scene_change_cb) self._add_widget(self._Scene_combo) #ought to do this safely somehow. self._Scene_combo.combo.set_active(0) self.scene_init = False # Separator separator = gtk.SeparatorToolItem() separator.set_draw(True) separator.show() self.insert(separator, -1) #Camera Button self.camera_ready = True camera_icon = ImagePath + "/camera-external.svg" camera_busy_icon = ImagePath + "/camera-busy.svg" self.camera_image, self.camera_busy_image = gtk.Image(), gtk.Image() self.camera_image.set_from_file(camera_icon) self.camera_busy_image.set_from_file(camera_busy_icon) self.camera_image.show() #camera_busy_image.show() self._cameraButton = ToolButton() self._cameraButton.set_icon_widget(self.camera_image) self._cameraButton.connect('clicked', self._cameraSnap_cb) self._cameraButton.set_tooltip(_('Snapshot')) self.insert(self._cameraButton, -1) self._cameraButton.show() # Separator separator = gtk.SeparatorToolItem() separator.set_draw(True) separator.show() self.insert(separator, -1) #Play/Pause Button pause_icon = ImagePath + "/media-playback-pause.svg" play_icon = ImagePath + "/media-playback-start.svg" self.pause_image = gtk.Image() self.pause_image.set_from_file(pause_icon) self.play_image = gtk.Image() self.play_image.set_from_file(play_icon) self._pauseButton = ToolButton() self._pauseButton.connect('clicked', self._pause_cb) self.pause_image.show() self._pauseButton.set_icon_widget(self.pause_image) self._pauseButton.set_tooltip(_('Pause')) #self._toggleplay_pause() self.insert(self._pauseButton, -1) self._pauseButton.show() # Separator separator = gtk.SeparatorToolItem() separator.set_draw(True) separator.show() self.insert(separator, -1) def _add_widget(self, widget, expand=False): tool_item = gtk.ToolItem() tool_item.set_expand(expand) tool_item.add(widget) widget.show() self.insert(tool_item, -1) tool_item.show() def _toggleplay_pause(self): if self.play_pause_state == "Playing": self.activity.jamScene.music_player.pause() self.play_image.show() self._pauseButton.set_icon_widget(self.play_image) self._pauseButton.set_tooltip(_('Play')) self.play_pause_state = "Paused" else: self.activity.jamScene.music_player.resume() self.pause_image.show() self._pauseButton.set_icon_widget(self.pause_image) self._pauseButton.set_tooltip(_('Pause')) self.play_pause_state = "Playing" try: self.activity._pgc.grab_focus() except AttributeError: pass def _show_busy_camera(self): self.camera_ready = False self.camera_busy_image.show() self._cameraButton.set_icon_widget(self.camera_busy_image) self._cameraButton.set_tooltip(_('Please wait...')) def _show_active_camera(self): self.camera_image.show() self._cameraButton.set_icon_widget(self.camera_image) self._cameraButton.set_tooltip(_('Snap')) self.camera_ready = True def _Hparameter_change_cb(self, widget): param = "Parameter|Horizontal|" + self.parameters[self._Hparameter_combo.combo.get_active()] olpcgames.eventwrap.post(olpcgames.eventwrap.Event(pygame.USEREVENT, action=param)) try: self.activity._pgc.grab_focus() except AttributeError: pass def _Vparameter_change_cb(self, widget): param = "Parameter|Vertical|" + self.parameters[self._Vparameter_combo.combo.get_active()] olpcgames.eventwrap.post(olpcgames.eventwrap.Event(pygame.USEREVENT, action=param)) try: self.activity._pgc.grab_focus() except AttributeError: pass def _Scene_change_cb(self, widget): if self.scene_init: pass else: selection = self.scenes[self._Scene_combo.combo.get_active()] scene = "Reload|" + '|'.join(map(lambda x: str(x), selection)) olpcgames.eventwrap.post(olpcgames.eventwrap.Event(pygame.USEREVENT, action=scene)) try: self.activity._pgc.grab_focus() except AttributeError: pass ### functions to assist calls from pygame def deactivate_scene_change(self): self._Scene_combo.set_sensitive(False) def reactivate_scene_change(self): self._Scene_combo.set_sensitive(True) def set_horizontal_parameter(self, param): ndx = self.parameters.index(param) self._Hparameter_combo.combo.set_active(ndx) def set_vertical_parameter(self, param): ndx = self.parameters.index(param) self._Vparameter_combo.combo.set_active(ndx) def _cameraSnap_cb(self, widget): "Here I could wrap a camera event..." def snaptime(): snap = CameraSnap() self.activity.cameras_loaded.append(snap) picpath = snap.Snap() self.activity.load_image(picpath) snap.Stop() self._show_active_camera() self.activity._pgc.grab_focus() if self.camera_ready: self._show_busy_camera() thread.start_new_thread(snaptime, ()) else: log.info('Ignoring request to use camera, as camera is currently busy') def _pause_cb(self, widget): self._toggleplay_pause() log.info("Play/Pause Button pressed")
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.__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 AboutMeActivity(activity.Activity): def colour_changed_callback(self, widget, type): colour = widget.get_current_color() red = "%x" % int(colour.red / 65535.0 * 255) if len(red) == 1: red = "0%s" % red green = "%x" % int(colour.green / 65535.0 * 255) if len(green) == 1: green = "0%s" % green blue = "%x" % int(colour.blue / 65535.0 * 255) if len(blue) == 1: blue = "0%s" % blue new_colour = "#%s%s%s" % (red, green, blue) if type == "out": in_colour = self.in_colour_selector.get_current_color() red = "%x" % int(in_colour.red / 65535.0 * 255) if len(red) == 1: red = "0%s" % red green = "%x" % int(in_colour.green / 65535.0 * 255) if len(green) == 1: green = "0%s" % green blue = "%x" % int(in_colour.blue / 65535.0 * 255) if len(blue) == 1: blue = "0%s" % blue in_colour = "#%s%s%s" % (red, green, blue) self.icon.props.xo_color = XoColor("%s,%s" % (new_colour, in_colour)) if type == "in": out_colour = self.out_colour_selector.get_current_color() red = "%x" % int(out_colour.red / 65535.0 * 255) if len(red) == 1: red = "0%s" % red green = "%x" % int(out_colour.green / 65535.0 * 255) if len(green) == 1: green = "0%s" % green blue = "%x" % int(out_colour.blue / 65535.0 * 255) if len(blue) == 1: blue = "0%s" % blue out_colour = "#%s%s%s" % (red, green, blue) self.icon.props.xo_color = XoColor("%s,%s" % (out_colour, new_colour)) def apply(self, widget): nick = unicode(self.name_entry.get_text(), 'utf-8') if nick != self.current_nick: self.client.set_string("/desktop/sugar/user/nick", nick) colour = self.icon._buffer.xo_color.to_string() if colour != self.current_colour: self.client.set_string("/desktop/sugar/user/color", colour) def __init__(self, handle): activity.Activity.__init__(self, handle) self.client = gconf.client_get_default() self.current_nick = self.client.get_string("/desktop/sugar/user/nick") self.current_colour = self.client.get_string( "/desktop/sugar/user/color") self.current_colours = _parse_string(self.current_colour) self.toolbox = activity.ActivityToolbox(self) activity_toolbar = self.toolbox.get_activity_toolbar() activity_toolbar.share.props.visible = False activity_toolbar.keep.props.visible = False self.ok_button = ToolButton(icon) self.ok_button.props.tooltip = "Aplicar" self.ok_button.connect("clicked", self.apply) self.ok_button.show() activity_toolbar.insert(self.ok_button, 2) self.set_toolbox(self.toolbox) self.toolbox.show() self.canvas = gtk.VBox() name_box = gtk.HBox() self.canvas.pack_start(name_box, True, True, 5) name_label = gtk.Label("Nombre:") self.name_entry = gtk.Entry() self.name_entry.set_text(self.current_nick) name_label.show() self.name_entry.show() name_box.pack_start(name_label, False, True, 0) name_box.pack_start(self.name_entry, True, True, 0) name_box.show() self.colour_picker = gtk.HBox() selectors = gtk.VBox() self.out_colour_selector = gtk.ColorSelection() self.out_colour_selector.set_current_color( gtk.gdk.color_parse(self.current_colours[0])) self.out_colour_selector.connect("color-changed", self.colour_changed_callback, "out") self.out_colour_selector.show() selectors.pack_start(self.out_colour_selector, True, True, 0) self.in_colour_selector = gtk.ColorSelection() self.in_colour_selector.set_current_color( gtk.gdk.color_parse(self.current_colours[1])) self.in_colour_selector.connect("color-changed", self.colour_changed_callback, "in") self.in_colour_selector.show() selectors.pack_start(self.in_colour_selector, True, True, 0) selectors.show() self.colour_picker.pack_start(selectors, True, True, 0) self.xo_icon = gtk.EventBox() self.icon = Icon(pixel_size=style.XLARGE_ICON_SIZE) self.icon.props.xo_color = XoColor(self.current_colour) self.icon.props.icon_name = 'computer-xo' self.icon.props.pixel_size = style.XLARGE_ICON_SIZE self.icon.show() self.xo_icon.add(self.icon) self.xo_icon.show() self.colour_picker.pack_start(self.xo_icon) self.canvas.pack_start(self.colour_picker, True, True, 5) self.colour_picker.show() self.canvas.show() self.set_canvas(self.canvas) self.show() def write_file(self, file_path): raise NotImplementedError def read_file(self, file_path): raise NotImplementedError
class TextAttributesToolbar(gtk.Toolbar): def __init__(self, main_area): gtk.Toolbar.__init__(self) self._main_area = main_area self._font_list = ['ABC123', 'Sans', 'Serif', 'Monospace', 'Symbol'] self._font_sizes = [ '8', '9', '10', '11', '12', '14', '16', '20', '22', '24', '26', '28', '36', '48', '72' ] self.font_button = ToolButton('font-text') self.font_button.set_tooltip(_('Select font')) self.font_button.connect('clicked', self.__font_selection_cb) self.insert(self.font_button, -1) self._setup_font_palette() self.insert(gtk.SeparatorToolItem(), -1) self.font_size_up = ToolButton('resize+') self.font_size_up.set_tooltip(_('Bigger')) self.font_size_up.connect('clicked', self.__font_sizes_cb, True) self.insert(self.font_size_up, -1) if len(self._main_area.selected) > 0: font_size = self._main_area.font_size else: font_size = utils.default_font_size self.size_label = gtk.Label(str(font_size)) self.size_label.show() toolitem = gtk.ToolItem() toolitem.add(self.size_label) toolitem.show() self.insert(toolitem, -1) self.font_size_down = ToolButton('resize-') self.font_size_down.set_tooltip(_('Smaller')) self.font_size_down.connect('clicked', self.__font_sizes_cb, False) self.insert(self.font_size_down, -1) self.insert(gtk.SeparatorToolItem(), -1) self.bold = ToolButton('bold-text') self.bold.set_tooltip(_('Bold')) self.bold.connect('clicked', self.__bold_cb) self.insert(self.bold, -1) self.italics = ToolButton('italics-text') self.italics.set_tooltip(_('Italics')) self.italics.connect('clicked', self.__italics_cb) self.insert(self.italics, -1) self.underline = ToolButton('underline-text') self.underline.set_tooltip(_('Underline')) self.underline.connect('clicked', self.__underline_cb) self.insert(self.underline, -1) foreground_color = ColorToolButton() foreground_color.set_title(_('Set font color')) foreground_color.connect('color-set', self.__foreground_color_cb) self.insert(foreground_color, -1) bakground_color = ColorToolButton() bakground_color.set_title(_('Set background color')) bakground_color.connect('color-set', self.__background_color_cb) bakground_color.set_color(gtk.gdk.Color(65535, 65535, 65535)) self.insert(bakground_color, -1) self.show_all() def __font_selection_cb(self, widget): if self._font_palette: if not self._font_palette.is_up(): self._font_palette.popup(immediate=True, state=self._font_palette.SECONDARY) else: self._font_palette.popdown(immediate=True) return def _init_font_list(self): self._font_white_list = [] self._font_white_list.extend(DEFAULT_FONTS) # check if there are a user configuration file if not os.path.exists(USER_FONTS_FILE_PATH): # verify if exists a file in /etc if os.path.exists(GLOBAL_FONTS_FILE_PATH): shutil.copy(GLOBAL_FONTS_FILE_PATH, USER_FONTS_FILE_PATH) if os.path.exists(USER_FONTS_FILE_PATH): # get the font names in the file to the white list fonts_file = open(USER_FONTS_FILE_PATH) # get the font names in the file to the white list for line in fonts_file: self._font_white_list.append(line.strip()) # monitor changes in the file gio_fonts_file = gio.File(USER_FONTS_FILE_PATH) self.monitor = gio_fonts_file.monitor_file() self.monitor.set_rate_limit(5000) self.monitor.connect('changed', self._reload_fonts) def _reload_fonts(self, monitor, gio_file, other_file, event): if event != gio.FILE_MONITOR_EVENT_CHANGES_DONE_HINT: return self._font_white_list = [] self._font_white_list.extend(DEFAULT_FONTS) fonts_file = open(USER_FONTS_FILE_PATH) for line in fonts_file: self._font_white_list.append(line.strip()) # update the menu for child in self._font_palette.menu.get_children(): self._font_palette.menu.remove(child) child = None context = self.get_pango_context() tmp_list = [] for family in context.list_families(): name = family.get_name() if name in self._font_white_list: tmp_list.append(name) for font in sorted(tmp_list): menu_item = MyMenuItem(image=FontImage(font.replace(' ', '-')), text_label=font) menu_item.connect('activate', self.__font_selected_cb, font) self._font_palette.menu.append(menu_item) menu_item.show() return False def _setup_font_palette(self): self._init_font_list() context = self._main_area.pango_context for family in context.list_families(): name = pango.FontDescription(family.get_name()).to_string() if name not in self._font_list and \ name in self._font_white_list: self._font_list.append(name) self._font_palette = self.font_button.get_palette() for font in sorted(self._font_list): menu_item = MyMenuItem(image=FontImage(font.replace(' ', '-')), text_label=font) menu_item.connect('activate', self.__font_selected_cb, font) self._font_palette.menu.append(menu_item) menu_item.show() def __font_selected_cb(self, widget, font_name): if not hasattr(self._main_area, 'font_name'): return if len(self._main_area.selected) > 0: font_size = self._main_area.font_size else: font_size = utils.default_font_size self._main_area.set_font(font_name, font_size) self._main_area.font_name = font_name self._main_area.font_size = font_size def __attribute_values(self): attributes = { "bold": True, "italics": True, "underline": True, "font": "" } it = self._main_area.selected[0].attributes.get_iterator() start_index = self._main_area.selected[0].index end_index = self._main_area.selected[0].end_index while (1): found = False r = it.range() if start_index == end_index: if r[0] <= start_index and r[1] > start_index: found = True elif start_index < end_index: if r[0] > end_index: break if start_index == end_index and \ r[0] < start_index and \ r[1] > start_index: found = True elif start_index != end_index and r[0] <= start_index and \ r[1] >= end_index: found = True else: if r[0] > start_index: break if start_index == end_index and \ r[0] < start_index and \ r[1] > start_index: found = True elif start_index != end_index and r[0] <= end_index and \ r[1] >= start_index: found = True if found: attr = it.get_attrs() for x in attr: if x.type == pango.ATTR_WEIGHT and \ x.value == pango.WEIGHT_BOLD: attributes["bold"] = False elif x.type == pango.ATTR_STYLE and \ x.value == pango.STYLE_ITALIC: attributes["italics"] = False elif x.type == pango.ATTR_UNDERLINE and \ x.value == pango.UNDERLINE_SINGLE: attributes["underline"] = False elif x.type == pango.ATTR_FONT_DESC: attributes["font"] = x.desc if it.next() == False: break return attributes def __font_sizes_cb(self, button, increase): if not hasattr(self._main_area, 'font_size'): return if len(self._main_area.selected) < 1: return font_size = self._main_area.font_size if font_size in self._font_sizes: i = self._font_sizes.index(font_size) if increase: if i < len(self._font_sizes) - 2: i += 1 else: if i > 0: i -= 1 else: i = self._font_sizes.index(utils.default_font_size) font_size = self._font_sizes[i] self.size_label.set_text(str(font_size)) self.font_size_down.set_sensitive(i != 0) self.font_size_up.set_sensitive(i < len(self._font_sizes) - 2) self._main_area.set_font(self._main_area.font_name, font_size) def __bold_cb(self, button): if len(self._main_area.selected) < 1: return value = self.__attribute_values()["bold"] self._main_area.set_bold(value) def __italics_cb(self, button): if len(self._main_area.selected) < 1: return value = self.__attribute_values()["italics"] self._main_area.set_italics(value) def __underline_cb(self, button): if len(self._main_area.selected) < 1: return value = self.__attribute_values()["underline"] self._main_area.set_underline(value) def __foreground_color_cb(self, button): color = button.get_color() self._main_area.set_foreground_color(color) def __background_color_cb(self, button): color = button.get_color() self._parent._main_area.set_background_color(color) def change_active_font(self): # TODO: update the toolbar return
class recordToolbar(gtk.Toolbar): def __init__(self, miniTamTam): gtk.Toolbar.__init__(self) def _insertSeparator(x = 1): for i in range(x): self.separator = gtk.SeparatorToolItem() self.separator.set_draw(True) self.insert(self.separator,-1) self.separator.show() self.miniTamTam = miniTamTam self.micRec1Button = ToolButton('rec1') self.micRec1Button.connect('clicked',self.miniTamTam.micRec,'mic1') self.insert(self.micRec1Button, -1) self.micRec1Button.show() self.micRec1Button.set_tooltip(_('Record microphone into slot 1')) self.micRec2Button = ToolButton('rec2') self.micRec2Button.connect('clicked',self.miniTamTam.micRec,'mic2') self.insert(self.micRec2Button, -1) self.micRec2Button.show() self.micRec2Button.set_tooltip(_('Record microphone into slot 2')) self.micRec3Button = ToolButton('rec3') self.micRec3Button.connect('clicked',self.miniTamTam.micRec,'mic3') self.insert(self.micRec3Button, -1) self.micRec3Button.show() self.micRec3Button.set_tooltip(_('Record microphone into slot 3')) self.micRec4Button = ToolButton('rec4') self.micRec4Button.connect('clicked',self.miniTamTam.micRec,'mic4') self.insert(self.micRec4Button, -1) self.micRec4Button.show() self.micRec4Button.set_tooltip(('Record microphone into slot 4')) _insertSeparator() self.keyboardRecButton = ToggleToolButton('keyrec') self.keyboardRecButton.connect('clicked', self.miniTamTam.sequencer.handleRecordButton ) self.insert(self.keyboardRecButton, -1) self.keyboardRecButton.show() self.keyboardRecButton.set_tooltip(_('Click to record a loop')) self.keyboardRecOverButton = ToggleToolButton('overrec') self.keyboardRecOverButton.connect('clicked', self.miniTamTam.sequencer.handleOverButton ) self.insert(self.keyboardRecOverButton, -1) self.keyboardRecOverButton.show() self.keyboardRecOverButton.set_tooltip(_('Click to add a loop')) #self.keyboardRecOverButton.set_sensitive(False) self.keyboardRecMinusButton = ToolButton('minusrec') self.keyboardRecMinusButton.connect('clicked', self.miniTamTam.sequencer.clearSequencer ) self.insert(self.keyboardRecMinusButton, -1) self.keyboardRecMinusButton.show() self.keyboardRecMinusButton.set_tooltip(_('Click to clear all loops')) _insertSeparator() self._loopSettingsPalette = LoopSettingsPalette(_('Add new Sound'), self.miniTamTam) self.loopSetButton = ToggleToolButton('loop') self.loopSetButton.set_palette(self._loopSettingsPalette) self.insert(self.loopSetButton, -1) self.loopSetButton.show()
class ReadToolbar(gtk.Toolbar): __gtype_name__ = 'ReadToolbar' def __init__(self): gtk.Toolbar.__init__(self) self._back = ToolButton('go-previous') self._back.set_tooltip(_('Back')) self._back.props.sensitive = False self._back.connect('clicked', self._go_back_cb) self.insert(self._back, -1) self._back.show() self._forward = ToolButton('go-next') self._forward.set_tooltip(_('Forward')) self._forward.props.sensitive = False self._forward.connect('clicked', self._go_forward_cb) self.insert(self._forward, -1) self._forward.show() num_page_item = gtk.ToolItem() self._num_page_entry = gtk.Entry() self._num_page_entry.set_text('0') self._num_page_entry.set_alignment(1) self._num_page_entry.connect('insert-text', self._num_page_entry_insert_text_cb) self._num_page_entry.connect('activate', self._num_page_entry_activate_cb) self._num_page_entry.set_width_chars(4) num_page_item.add(self._num_page_entry) self._num_page_entry.show() self.insert(num_page_item, -1) num_page_item.show() total_page_item = gtk.ToolItem() self._total_page_label = gtk.Label() label_attributes = pango.AttrList() label_attributes.insert(pango.AttrSize(14000, 0, -1)) label_attributes.insert(pango.AttrForeground(65535, 65535, 65535, 0, -1)) self._total_page_label.set_attributes(label_attributes) self._total_page_label.set_text(' / 0') total_page_item.add(self._total_page_label) self._total_page_label.show() self.insert(total_page_item, -1) total_page_item.show() downloaded_item = gtk.ToolItem() self._downloaded_label = gtk.Label() self._downloaded_label.set_attributes(label_attributes) self._downloaded_label.set_text('') downloaded_item.add(self._downloaded_label) self._downloaded_label.show() self.insert(downloaded_item, -1) downloaded_item.show() def set_downloaded_bytes(self, bytes, total): self._downloaded_label.props.label = ' ' + str(bytes) + ' of ' + str(total) + ' received' def _num_page_entry_insert_text_cb(self, entry, text, length, position): if not re.match('[0-9]', text): entry.emit_stop_by_name('insert-text') return True return False def _num_page_entry_activate_cb(self, entry): if entry.props.text: page = int(entry.props.text) - 1 else: page = 0 if page >= self.total_pages: page = self.total_pages - 1 elif page < 0: page = 0 self.current_page = page self.activity.set_current_page(page) self.activity.show_page(page) entry.props.text = str(page + 1) self._update_nav_buttons() def _go_back_cb(self, button): self.activity.page_previous() def _go_forward_cb(self, button): self.activity.page_next() def _update_nav_buttons(self): current_page = self.current_page self._back.props.sensitive = current_page > 0 self._forward.props.sensitive = \ current_page < self.total_pages - 1 self._num_page_entry.props.text = str(current_page + 1) self._total_page_label.props.label = \ ' / ' + str(self.total_pages) def set_total_pages(self, pages): self.total_pages = pages def set_current_page(self, page): self.current_page = page self._update_nav_buttons() def set_activity(self, activity): self.activity = activity
def build_toolbar(self): toolbox = ToolbarBox() activity_button = ActivityToolbarButton(self) toolbox.toolbar.insert(activity_button, -1) activity_button.show() barra = toolbox.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) item2 = gtk.ToolItem() self.cradio1 = gtk.SpinButton() 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.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(toolbox) toolbox.show_all()
class Avatars(gtk.VBox): def __init__(self, btnfunction, loadfunction, win, path="none"): super(Avatars, self).__init__() win.set_title(_('Select a avatar')) win.set_decorated(False) win.set_position(gtk.WIN_POS_CENTER) y = gtk.gdk.screen_height() - 100 win.set_size_request(gtk.gdk.screen_width() - 100, y) self.win = win scroll = gtk.ScrolledWindow() scroll.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC) self.hbox = gtk.HBox() self.show_all() self.function = btnfunction self.a = 0 self.vbx = gtk.VBox() self.vbx.pack_start(self.hbox, False, False, 6) self.eventbox = gtk.EventBox() self.eventbox.modify_bg(gtk.STATE_NORMAL, gtk.gdk.color_parse('white')) self.eventbox.add(self.vbx) scroll.add_with_viewport(self.eventbox) #### # Sugar Style #### tl = gtk.Toolbar() tl.modify_bg(gtk.STATE_NORMAL, gtk.gdk.color_parse('black')) self.loadfromjournal = ToolButton('open-from-journal') self.loadfromjournal.set_tooltip(_('Load from journal')) self.loadfromjournal.connect('clicked', loadfunction, win) self.accept = ToolButton('dialog-ok') self.accept.set_tooltip(_('Accept')) self.cancel = ToolButton('gtk-cancel') self.cancel.set_tooltip(_('Cancel')) self.cancel.connect('clicked', lambda x: win.destroy()) sep = gtk.SeparatorToolItem() sep.set_expand(True) sep.props.draw = False tl.insert(self.loadfromjournal, 0) tl.insert(sep, 1) tl.insert(self.accept, 2) tl.insert(self.cancel, 3) tl.set_size_request(55, -1) self.pack_start(tl, False, False, 0) self.eventbox.add(scroll) self.pack_end(scroll, True, True, 0) #### self.path = None self.actual = None for x in os.listdir('avatars'): if path != "none": if path == os.path.join(os.getcwd(), 'avatars', x): sensitive = False else: sensitive = True else: sensitive = True self._gen_avatars(x, sensitive) gobject.timeout_add(10, self._check) def _check(self): a = str(type(self.path)).lower() if 'none' in a: self.accept.set_sensitive(False) else: self.accept.set_sensitive(True) return True def _gen_avatars(self, name, sensi): path = os.path.join(os.getcwd(), 'avatars', name) button = gtk.Button() if not sensi: self.actual = button button.set_sensitive(sensi) button.set_tooltip_text(path) image = gtk.Image() pix = gtk.gdk.pixbuf_new_from_file_at_size(path, 100, 100) image.set_from_pixbuf(pix) button.add(image) button.connect('clicked', self._set_path) if not self.a + 1 == 6: self.hbox.pack_start(button, False, False, 0) self.a += 1 else: self.hbox = gtk.HBox() self.vbx.pack_start(self.hbox, False, False, 6) self.hbox.pack_start(button, False, False, 0) self.a = 0 button.props.has_tooltip = False self.show_all() def _set_path(self, widget): try: self.actual.set_sensitive(True) except: pass self.path = widget.get_tooltip_text() self.accept.connect('clicked', self.function, self.path, self.win) widget.set_sensitive(False) self.actual = widget
class MeasureActivity(activity.Activity): ''' Oscilloscope Sugar activity ''' def __init__(self, handle): ''' Init canvas, toolbars, etc. The toolbars are in sensor_toolbar.py and toolbar_side.py The audio controls are in audiograb.py The rendering happens in drawwaveform.py Logging is in journal.py ''' activity.Activity.__init__(self, handle) self.mode_images = {} self.mode_images['sound'] = gtk.gdk.pixbuf_new_from_file_at_size( os.path.join(ICONS_DIR, 'media-audio.svg'), 45, 45) self.mode_images['resistance'] = gtk.gdk.pixbuf_new_from_file_at_size( os.path.join(ICONS_DIR, 'resistance.svg'), 45, 45) self.mode_images['voltage'] = gtk.gdk.pixbuf_new_from_file_at_size( os.path.join(ICONS_DIR, 'voltage.svg'), 45, 45) self.icon_colors = self.get_icon_colors_from_sugar() self.stroke_color, self.fill_color = self.icon_colors.split(',') self.nick = self.get_nick_from_sugar() self.CONTEXT = '' self.adjustmentf = None # Freq. slider control self.new_recording = False self.session_id = 0 self.read_metadata() self._active = True self._dsobject = None self.connect('notify::active', self._notify_active_cb) self.connect('destroy', self.on_quit) self.data_logger = DataLogger(self) self.hw = _get_hardware() log.debug('running on %s hardware' % (self.hw)) self.wave = DrawWaveform(self) if self.hw == XO15: self.audiograb = AudioGrab_XO15(self.wave.new_buffer, self) elif self.hw == XO175: self.audiograb = AudioGrab_XO175(self.wave.new_buffer, self) elif self.hw == XO4: self.audiograb = AudioGrab_XO4(self.wave.new_buffer, self) elif self.hw == XO1: self.audiograb = AudioGrab_XO1(self.wave.new_buffer, self) else: self.audiograb = AudioGrab_Unknown(self.wave.new_buffer, self) # no sharing self.max_participants = 1 box3 = gtk.HBox(False, 0) box3.pack_start(self.wave, True, True, 0) # We need event boxes in order to set the background color. side_eventboxes = [] self.side_toolbars = [] for i in range(self.audiograb.channels): side_eventboxes.append(gtk.EventBox()) side_eventboxes[i].modify_bg( gtk.STATE_NORMAL, style.COLOR_TOOLBAR_GREY.get_gdk_color()) self.side_toolbars.append(SideToolbar(self, channel=i)) side_eventboxes[i].add(self.side_toolbars[i].box1) box3.pack_start(side_eventboxes[i], False, True, 0) event_box = gtk.EventBox() self.text_box = gtk.Label() self.text_box.set_justify(gtk.JUSTIFY_LEFT) alist = pango.AttrList() alist.insert(pango.AttrForeground(65535, 65535, 65535, 0, -1)) self.text_box.set_attributes(alist) event_box.add(self.text_box) event_box.modify_bg(gtk.STATE_NORMAL, style.COLOR_TOOLBAR_GREY.get_gdk_color()) box1 = gtk.VBox(False, 0) box1.pack_start(box3, True, True, 0) box1.pack_start(event_box, False, True, 0) self.set_canvas(box1) toolbox = ToolbarBox() activity_button = ActivityToolbarButton(self) toolbox.toolbar.insert(activity_button, 0) activity_button.show() self.sensor_toolbar = SensorToolbar(self, self.audiograb.channels) #Added by Lego # Turn on bobot Server log.debug('Starting Server...') self.bobot = subprocess.Popen(['python', 'pybot_server.py'], cwd='./pybot') log.debug("Start : %s" % time.ctime()) time.sleep(bobot_delay_start) log.debug("Started : %s" % time.ctime()) self.lego_toolbar = LegoToolbar(self, self.audiograb.channels) #Lego end # Added by Butia self.butia_toolbar = ButiaToolbar(self, self.audiograb.channels) #Butia end #Added by Arduino self.arduino_toolbar = ArduinoToolbar(self, self.audiograb.channels) #Arduino end self.tuning_toolbar = TuningToolbar(self) self.new_instrument_toolbar = InstrumentToolbar(self) self._extras_toolbar = gtk.Toolbar() self.control_toolbar = gtk.Toolbar() sensor_button = ToolbarButton(label=_('Sensors'), page=self.sensor_toolbar, icon_name='sensor-tools') toolbox.toolbar.insert(sensor_button, -1) #Added by Lego sensor_button.connect('clicked', self._sensor_toolbar_cb) #Lego end sensor_button.show() lego_button = ToolbarButton(label=_('Lego'), page=self.lego_toolbar, icon_name='LEGO-tools') toolbox.toolbar.insert(lego_button, -1) lego_button.connect('clicked', self._lego_toolbar_cb) lego_button.show() #Lego end #Added by Butia sensor_button.connect('clicked', self._sensor_toolbar_cb) #Butia end sensor_button.show() #Added by Butia butia_button = ToolbarButton(label=_('Butia'), page=self.butia_toolbar, icon_name='butia-tools') toolbox.toolbar.insert(butia_button, -1) butia_button.connect('clicked', self._butia_toolbar_cb) butia_button.show() #Butia end #Added by Arduino sensor_button.connect('clicked', self._sensor_toolbar_cb) #Arduino end sensor_button.show() #Added by Arduino arduino_button = ToolbarButton(label=_('Arduino'), page=self.arduino_toolbar, icon_name='arduino-tools') toolbox.toolbar.insert(arduino_button, -1) arduino_button.connect('clicked', self._arduino_toolbar_cb) arduino_button.show() #Arduino end tuning_button = ToolbarButton( # TRANS: Tuning insruments label=_('Tuning'), page=self.tuning_toolbar, icon_name='tuning-tools') toolbox.toolbar.insert(tuning_button, -1) tuning_button.show() new_instrument_button = ToolbarButton(label=_('Add instrument'), page=self.new_instrument_toolbar, icon_name='view-source') toolbox.toolbar.insert(new_instrument_button, -1) new_instrument_button.show() #Added by butia self.butia_toolbar.show() #Butia end self._extras_button = ToolbarButton(page=self._extras_toolbar, icon_name='domain-time') toolbox.toolbar.insert(self._extras_button, -1) self._extras_toolbar_item = gtk.ToolItem() self._extras_toolbar.insert(self._extras_toolbar_item, -1) self._extras_button.hide() self.sensor_toolbar.show() self._extra_tools = gtk.HBox() # Set up Frequency-domain Button self.freq = ToolButton('domain-time') self.freq.set_tooltip(_('Time Base')) self.freq.connect('clicked', self.timefreq_control) self.freq.show() self._extra_tools.add(self.freq) self.sensor_toolbar.add_frequency_slider(self._extra_tools) self._extra_item = gtk.ToolItem() self._extra_item.add(self._extra_tools) self._extra_tools.show() toolbox.toolbar.insert(self._extra_item, -1) self._extra_item.show() self._pause = ToolButton('media-playback-pause') self._pause.set_tooltip(_('Freeze the display')) self._pause.connect('clicked', self._pause_play_cb) self._pause.show() toolbox.toolbar.insert(self._pause, -1) self._capture = ToolButton('image-saveoff') self._capture.set_tooltip(_('Capture sample now')) self._capture.connect('clicked', self._capture_cb) self._capture.show() toolbox.toolbar.insert(self._capture, -1) 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() self.set_toolbox(toolbox) sensor_button.set_expanded(True) toolbox.show() self.sensor_toolbar.update_page_size() self.show_all() self._first = True # Always start in 'sound' mode. self.sensor_toolbar.set_mode('sound') self.sensor_toolbar.set_sound_context() self.sensor_toolbar.set_show_hide_windows() self.wave.set_active(True) self.wave.set_context_on() gtk.gdk.screen_get_default().connect('size-changed', self._configure_cb) self._configure_cb(None) def _configure_cb(self, event): ''' Screen size has changed, so check to see if the toolbar elements still fit.''' self.width = gtk.gdk.screen_width() if self.width < style.GRID_CELL_SIZE * 14: self._extras_button.show() if self._extra_tools in self._extra_item: self._extra_item.remove(self._extra_tools) if not self._extra_tools in self._extras_toolbar_item: self._extras_toolbar_item.add(self._extra_tools) self._extras_toolbar_item.show() self.sensor_toolbar.log_label.hide() self.sensor_toolbar.trigger_label.hide() else: self._extras_button.hide() if self._extra_tools in self._extras_toolbar_item: self._extras_toolbar_item.remove(self._extra_tools) if not self._extra_tools in self._extra_item: self._extra_item.add(self._extra_tools) if self._extras_button.is_expanded(): self._extras_button.set_expanded(False) self._extras_toolbar_item.hide() self.sensor_toolbar.log_label.show() self.sensor_toolbar.trigger_label.show() self._extra_tools.show() #Added by Lego def _sensor_toolbar_cb(self, button=None): '''Callback al hacer clic en sensor toolbar''' log.debug('Click en sensor toolbar') self.sensor_toolbar.set_mode('sound') self.sensor_toolbar.set_sound_context() self.sensor_toolbar.set_show_hide_windows() self.limpiar_canales() self.CONTEXT = 'sound' #Added by Lego def _lego_toolbar_cb(self, button=None): '''Callback al hacer clic en lego toolbar''' log.debug('Click en lego toolbar') self.audiograb.stop_grabbing() self.limpiar_canales() log.debug('CONTEXTO ANTERIOR: %s' % self.CONTEXT) self.CONTEXT = 'lego' self.sensor_toolbar.update_string_for_textbox() #Added by Butia def _butia_toolbar_cb(self, button=None): '''Callback al hacer clic en butia toolbar''' log.debug('Click en butia toolbar') self.audiograb.stop_grabbing() self.limpiar_canales() log.debug('CONTEXTO ANTERIOR: %s' % self.CONTEXT) self.CONTEXT = 'butia' self.sensor_toolbar.update_string_for_textbox() #Added by Arduino def _arduino_toolbar_cb(self, button=None): '''Callback al hacer clic en arduino toolbar''' log.debug('Click en arduino toolbar') self.audiograb.stop_grabbing() self.limpiar_canales() log.debug('CONTEXTO ANTERIOR: %s' % self.CONTEXT) log.debug('***** ARDUINO CONTEXT ******') self.CONTEXT = 'arduino' self.sensor_toolbar.update_string_for_textbox() #Added by lego def limpiar_canales(self): for i in range(self.audiograb.channels): self.wave.ringbuffer[i] = RingBuffer1d(self.wave.max_samples, dtype='int16') self.wave.new_buffer([0], i) def on_quit(self, data=None): '''Clean up, close journal on quit''' self.audiograb.on_activity_quit() def _notify_active_cb(self, widget, pspec): ''' Callback to handle starting/pausing capture when active/idle ''' if self._first: log.debug('_notify_active_cb: start grabbing') self.audiograb.start_grabbing() self._first = False elif not self.props.active: log.debug('_notify_active_cb: pause grabbing') self.audiograb.pause_grabbing() elif self.props.active: log.debug('_notify_active_cb: resume grabbing') self.audiograb.resume_grabbing() self._active = self.props.active self.wave.set_active(self._active) def read_metadata(self): ''' Any saved instruments? ''' for data in self.metadata.keys(): if data[0] == PREFIX: # instrument log.debug('found an instrument: %s' % (data[1:])) instrument = data[1:] log.debug(self.metadata[data]) INSTRUMENT_DICT[instrument] = [] for note in self.metadata[data].split(' '): INSTRUMENT_DICT[instrument].append(float(note)) def write_file(self, file_path): ''' Write data to journal, if there is any data to write ''' # Check to see if there are any new instruments to save if hasattr(self, 'new_instrument_toolbar'): for i, instrument in enumerate( self.new_instrument_toolbar.new_instruments): log.debug('saving %s' % (instrument)) notes = '' for i, note in enumerate(INSTRUMENT_DICT[instrument]): notes += '%0.3f' % note if i < len(INSTRUMENT_DICT[instrument]) - 1: notes += ' ' self.metadata['%s%s' % (PREFIX, instrument)] = notes # FIXME: Don't use ""s around data if hasattr(self, 'data_logger') and \ self.new_recording and \ len(self.data_logger.data_buffer) > 0: # Append new data to Journal entry fd = open(file_path, 'ab') writer = csv.writer(fd) # Also output to a separate file as a workaround to Ticket 2127 # (the assumption being that this file will be opened by the user) tmp_data_file = os.path.join(os.environ['SUGAR_ACTIVITY_ROOT'], 'instance', 'sensor_data' + '.csv') log.debug('saving sensor data to %s' % (tmp_data_file)) if self._dsobject is None: # first time, so create fd2 = open(tmp_data_file, 'wb') else: # we've been here before, so append fd2 = open(tmp_data_file, 'ab') writer2 = csv.writer(fd2) # Pop data off start of buffer until it is empty for i in range(len(self.data_logger.data_buffer)): datum = self.data_logger.data_buffer.pop(0) writer.writerow([datum]) writer2.writerow([datum]) fd.close() fd2.close() # Set the proper mimetype self.metadata['mime_type'] = 'text/csv' if os.path.exists(tmp_data_file): if self._dsobject is None: self._dsobject = datastore.create() self._dsobject.metadata['title'] = _('Measure Log') self._dsobject.metadata['icon-color'] = self.icon_colors self._dsobject.metadata['mime_type'] = 'text/csv' self._dsobject.set_file_path(tmp_data_file) datastore.write(self._dsobject) # remove(tmp_data_file) def read_file(self, file_path): ''' Read csv data from journal on start ''' reader = csv.reader(open(file_path, "rb")) # Count the number of sessions. for row in reader: if len(row) > 0: if row[0].find(_('Session')) != -1: # log.debug('found a previously recorded session') self.session_id += 1 elif row[0].find('abiword') != -1: # File has been opened by Write cannot be read by Measure # See Ticket 2127 log.error('File was opened by Write: Measure cannot read') self.data_logger.data_buffer = [] return self.data_logger.data_buffer.append(row[0]) if self.session_id == 0: # log.debug('setting data_logger buffer to []') self.data_logger.data_buffer = [] def _pause_play_cb(self, button=None): ''' Callback for Pause Button ''' if self.audiograb.get_freeze_the_display(): self.audiograb.set_freeze_the_display(False) self._pause.set_icon('media-playback-start') self._pause.set_tooltip(_('Unfreeze the display')) self._pause.show() else: self.audiograb.set_freeze_the_display(True) self._pause.set_icon('media-playback-pause') self._pause.set_tooltip(_('Freeze the display')) self._pause.show() return False def _capture_cb(self, button=None): ''' Callback for screen capture ''' if self.CONTEXT == 'butia': self.butia_toolbar.take_screenshot() self.audiograb.take_screenshot() def timefreq_control(self, button=None): ''' Callback for Freq. Button ''' # Turn off logging when switching modes if self.audiograb.we_are_logging: self.sensor_toolbar.record_control_cb() #Added by Lego self.lego_toolbar.set_sound_context() #Lego end #Added by Butia self.butia_toolbar.set_sound_context() #Butia end #Added by Arduino self.arduino_toolbar.set_sound_context() #Arduino end if self.wave.get_fft_mode(): self.wave.set_fft_mode(False) self.freq.set_icon('domain-time') self.freq.set_tooltip(_('Time Base')) else: self.wave.set_fft_mode(True) self.freq.set_icon('domain-freq') self.freq.set_tooltip(_('Frequency Base')) # Turn off triggering in Frequencey Base self.sensor_toolbar.trigger_none.set_active(True) self.wave.set_trigger(self.wave.TRIGGER_NONE) # Turn off invert in Frequencey Base for i in range(self.audiograb.channels): if self.wave.get_invert_state(channel=i): self.side_toolbars[i].invert_control_cb() self.sensor_toolbar.update_string_for_textbox() return False def get_icon_colors_from_sugar(self): ''' Returns the icon colors from the Sugar profile ''' return profile.get_color().to_string() def get_nick_from_sugar(self): ''' Returns nick from Sugar ''' return profile.get_nick_name()
class VncLauncherActivity(activity.Activity): def __init__(self, handle): activity.Activity.__init__(self, handle) self.max_participants = 1 self.toolbarbox = ToolbarBox() self.toolbar = self.toolbarbox.toolbar self.start_vnc = RadioToolButton(icon_name="start_vnc", tooltip=_("Start VNC Server")) self.stop_vnc = RadioToolButton(icon_name="stop_vnc", tooltip=_("Stop VNC Server"), group=self.start_vnc) self.stop_vnc.set_active(True) self.get_ipbutton = ToolButton(icon_name="get_ip", tooltip=_("Get the current IP")) ## self.messages = gtk.TreeView() self.messages.set_rules_hint(True) modelo = gtk.ListStore(str, str, gtk.gdk.Color) self.messages.set_model(modelo) render = gtk.CellRendererText() render1 = gtk.CellRendererText() column1 = gtk.TreeViewColumn(_("Hour"), render, markup=0) column2 = gtk.TreeViewColumn(_("Message"), render1, markup=1) column1.add_attribute(render, 'foreground-gdk', 2) column2.add_attribute(render1, 'foreground-gdk', 2) self.messages.append_column(column1) self.messages.append_column(column2) color = gtk.gdk.color_parse("dark blue") modelo.insert(0, [ time.strftime("\n<b>%H:%M:%S</b>\n"), _("\n<b>Start of activity.</b>\n"), color ]) self.showed_message_stop = True self.showed_message_start = False self.isrunning = True self.stop_vnc.connect("clicked", self.__stop_vnc) self.start_vnc.connect("clicked", self.__start_vnc) self.clear_model = ToolButton(icon_name="clear_console", tooltip=_("Delete messages")) self.clear_model.connect("clicked", lambda x: modelo.clear()) self.get_ipbutton.connect("clicked", self.__get_ip) self.last_message = 1 self.__get_x11vnc_path() ## separator = gtk.SeparatorToolItem() separator.props.draw = False separator.set_expand(True) self.stop_activity = StopButton(self) self.toolbar.insert(ActivityToolbarButton(self), -1) self.toolbar.insert(gtk.SeparatorToolItem(), -1) self.toolbar.insert(self.start_vnc, -1) self.toolbar.insert(self.stop_vnc, -1) self.toolbar.insert(gtk.SeparatorToolItem(), -1) self.toolbar.insert(self.get_ipbutton, -1) self.toolbar.insert(self.clear_model, -1) self.toolbar.insert(separator, -1) self.toolbar.insert(self.stop_activity, -1) self.messages_scroll = gtk.ScrolledWindow() self.messages_scroll.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC) self.messages_scroll.add_with_viewport(self.messages) self.set_toolbar_box(self.toolbarbox) self.set_canvas(self.messages_scroll) self.show_all() gobject.timeout_add(100, self.__check_is_on) def __check_is_on(self): pid = commands.getoutput("pidof x11vnc") if self.start_vnc.get_active() and pid == "" and self.isrunning: self.showed_message_stop = True self.stop_vnc.set_active(True) self.start_vnc.set_active(False) self.showed_message_start = False color = gtk.gdk.color_parse("dark red") self.messages.get_model().insert(self.last_message, [ time.strftime("\n<b>%H:%M:%S</b>\n"), ("\n<b>It has stopped unexpectedly the server..</b>\n"), color ]) self.last_message += 1 return True def __get_x11vnc_path(self): system = platform.machine() color = gtk.gdk.color_parse("dark red") if os.path.exists("/usr/bin/x11vnc"): self.path = "/usr/bin/x11vnc" message = _("PATH: %s") % self.path else: if "arm" in system: self.path = os.path.join(activity.get_bundle_path(), "bin", "arm", "x11vnc") elif "64" in system: self.path = os.path.join(activity.get_bundle_path(), "bin", "x64", "x11vnc") else: self.path = os.path.join(activity.get_bundle_path(), "bin", "i586", "x11vnc") os.environ["LD_LIBRARY_PATH"] = self.path.replace("x11vnc", "lib/") message = _("PATH: %s") % self.path self.messages.get_model().insert(self.last_message, [ time.strftime("\n<b>%H:%M:%S</b>\n"), "<b>" + message + "</b>", color ]) self.last_message += 1 def __start_vnc(self, widget): def servidor(): commands.getoutput(self.path) Thread(target=servidor).start() if not self.showed_message_start: self.showed_message_start = True pass else: return self.showed_message_stop = False self.isrunning = True color = gtk.gdk.color_parse("green") self.messages.get_model().insert(self.last_message, [ time.strftime("\n<b>%H:%M:%S</b>\n"), ("\n<b>VNC server is started</b>\n"), color ]) self.last_message += 1 def __stop_vnc(self, widget): if not self.showed_message_stop: self.showed_message_stop = True pass else: return self.showed_message_start = False self.pid_nuevo = commands.getoutput("pidof x11vnc") color = gtk.gdk.color_parse('red') os.system("kill " + self.pid_nuevo) self.messages.get_model().insert(self.last_message, [ time.strftime("\n<b>%H:%M:%S</b>\n"), ("\n<b>The VNC server is now stopped.</b>\n"), color ]) self.last_message += 1 def close(self): self.isrunning = False pid = commands.getoutput("pidof x11vnc") os.system("kill " + pid) self.destroy() def __get_ip(self, widget): system = platform.platform() if "olpc" in system: target = "eth0" else: target = "wlan0" ifconfig = "/sbin/ifconfig" cmd = "%s %s" % (ifconfig, target) output = commands.getoutput(cmd) error = _("No wireless connection.") ip = error inet = output.find('inet') if inet >= 0: start = inet + len('inet') end = output.find(" ", start + 1) ip = output[start:end] else: ip = error if ip == _("No wireless connection."): mensaje = error else: ip = ip.replace(":", "") ip = ip.replace("addr", "") ip = ip.replace(" ", "") mensaje = "IP: " + ip color = gtk.gdk.color_parse("dark blue") self.messages.get_model().insert(self.last_message, [ time.strftime("\n<b>%H:%M:%S</b>\n"), "\n<b>" + mensaje + "</b>\n", color ]) self.last_message += 1
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_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() toolbar_box.toolbar.insert(separator, -1) separator.show() self.build_colors_toolbar(toolbar_box) separator = gtk.SeparatorToolItem() toolbar_box.toolbar.insert(separator, -1) separator.show() # 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' % 1) item.add(self.current_label) toolbar_box.toolbar.insert(item, -1) separator = gtk.SeparatorToolItem() toolbar_box.toolbar.insert(separator, -1) separator.show() sound_button = ToolButton('speaker-muted-100') sound_button.set_tooltip(_('Sound')) sound_button.connect('clicked', self.sound_control) toolbar_box.toolbar.insert(sound_button, -1) # separator and stop separator = gtk.SeparatorToolItem() separator.props.draw = False separator.set_expand(True) toolbar_box.toolbar.insert(separator, -1) separator.show() stop_button = StopButton(self) toolbar_box.toolbar.insert(stop_button, -1) stop_button.show() self.show_all()
class SideToolbar(gtk.Toolbar): ''' A toolbar on the side of the canvas for adjusting gain/bias ''' def __init__(self, activity, channel=0): ''' Set up initial toolbars ''' gtk.Toolbar.__init__(self) self.activity = activity self._channel = channel if self._channel == 0: self.show_toolbar = True else: # Don't show second channel until we need it self.show_toolbar = False self.mode = 'sound' self.mode_values = {'sound': 3, 'sensor': 2} self._toggle = gtk.CheckButton() self._toggle.set_active(True) self._toggle.connect('clicked', self.toggle_cb) self._toggle.show() self._toggle_box = gtk.HBox() self._toggle_box.pack_start(self._toggle, False, True, 18) self._invert = ToolButton('invert') self._invert.set_tooltip(_('Invert')) self._invert.connect('clicked', self.invert_control_cb) self._invert.show() self.activity.wave.set_invert_state(False, channel=self._channel) self.button_up = ToolButton('amp-high') self.button_up.set_tooltip(_('Increase amplitude')) self.button_up.connect('clicked', self._button_up_cb) self.button_up.show() self.adjustmenty = gtk.Adjustment(self.mode_values[self.mode], LOWER, UPPER, 0.1, 0.1, 0.0) self.adjustmenty.connect('value_changed', self._yscrollbar_cb, self.adjustmenty) self.yscrollbar = gtk.VScale(self.adjustmenty) self.yscrollbar.set_draw_value(False) self.yscrollbar.set_inverted(True) self.yscrollbar.set_update_policy(gtk.UPDATE_CONTINUOUS) self.button_down = ToolButton('amp-low') self.button_down.set_tooltip(_('Decrease amplitude')) self.button_down.connect('clicked', self._button_down_cb) self.button_down.show() self.box1 = gtk.VBox(False, 0) if self._channel == 0: self.box1.pack_start(self._color_wave(self.activity.stroke_color), False, True, 0) elif self._channel == 1: self.box1.pack_start(self._color_wave(self.activity.fill_color), False, True, 0) else: self.box1.pack_start(self._color_wave('#FFFFFF'), False, True, 0) self.box1.pack_start(self._toggle_box, False, True, 0) self.box1.pack_start(self._invert, False, True, 0) self.box1.pack_start(self.button_up, False, True, 0) self.box1.pack_start(self.yscrollbar, True, True, 0) self.box1.pack_start(self.button_down, False, True, 0) self.set_show_hide(False) def _yscrollbar_cb(self, adjy, data=None): ''' Callback for scrollbar ''' if self.mode == 'sound': self.activity.wave.set_mag_params(1.0, adjy.value, channel=self._channel) self.activity.wave.set_bias_param(0, channel=self._channel) elif self.mode == 'sensor': self.activity.wave.set_bias_param(int( 300 * (adjy.value - (UPPER - LOWER) / 2.)), channel=self._channel) self.mode_values[self.mode] = adjy.value return True def _button_up_cb(self, data=None): '''Moves slider up''' new_value = self.yscrollbar.get_value() + (UPPER - LOWER) \ / 100. if new_value <= UPPER: self.yscrollbar.set_value(new_value) else: self.yscrollbar.set_value(UPPER) return True def _button_down_cb(self, data=None): '''Moves slider down''' new_value = self.yscrollbar.get_value() - (UPPER - LOWER) \ / 100. if new_value >= LOWER: self.yscrollbar.set_value(new_value) else: self.yscrollbar.set_value(LOWER) return True def set_show_hide(self, show=True, mode='sound'): ''' Show or hide the toolbar ''' self.show_toolbar = show self.set_side_mode(mode) def set_side_mode(self, mode='sound'): ''' Set the toolbar to either 'sound' or 'sensor' ''' self.mode = mode if self.mode == 'sound': self.button_up.set_icon('amp-high') self.button_up.set_tooltip(_('Increase amplitude')) self.button_down.set_icon('amp-low') self.button_down.set_tooltip(_('Decrease amplitude')) elif self.mode == 'sensor': self.button_up.set_icon('bias-high') self.button_up.set_tooltip(_('Increase bias')) self.button_down.set_icon('bias-low') self.button_down.set_tooltip(_('Decrease bias')) self._invert.show() self.yscrollbar.set_value(self.mode_values[self.mode]) return def toggle_cb(self, data=None): self.activity.wave.set_visibility(self._toggle.get_active(), channel=self._channel) return True def invert_control_cb(self, data=None): ''' Callback for Invert Button ''' if self.activity.wave.get_invert_state(channel=self._channel): self.activity.wave.set_invert_state(False, self._channel) self._invert.set_icon('invert') self._invert.show() elif not self.activity.wave.get_fft_mode(): self.activity.wave.set_invert_state(True, self._channel) self._invert.set_icon('invert2') self._invert.show() self.activity.sensor_toolbar.update_string_for_textbox() return False def _color_wave(self, color): ''' Generate a wave graphic in color to label each side toolbar ''' svg = '<?xml version="1.0" ?>\n\ <!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN"\n\ "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">\n\ <svg enable-background="new 0 0 55.125 55" height="55px" version="1.1"\n\ viewBox="0 0 55.125 55" width="55.125px" x="0px" xml:space="preserve"\n\ xmlns="http://www.w3.org/2000/svg"\n\ xmlns:xlink="http://www.w3.org/1999/xlink" y="0px">\n\ <path d="M9.066,27.5 c2.32-6.917,4.666-13.834,9.255-13.834\n\ c9.179,0,9.179,27.668,18.358,27.668c4.59,0,6.986-6.917,9.332-13.834"\n\ fill="none" stroke="%s" stroke-linecap="round" stroke-width="3.5"/>\n\ </svg>' % (color) pixbuf = svg_str_to_pixbuf(svg) img = gtk.Image() img.set_from_pixbuf(pixbuf) img_tool = gtk.ToolItem() img_tool.add(img) return img_tool
def __init__(self, montage): gtk.Toolbar.__init__(self) self.montage = montage # edit buttons setframe = ToolButton('dialog-ok') setframe.connect('clicked', self._setframe_cb) setframe.set_tooltip(_('Set frame')) self.insert(setframe, -1) clearframe = ToolButton('gtk-delete') clearframe.connect('clicked', self._clearframe_cb) clearframe.set_tooltip(_('Clear frame')) self.insert(clearframe, -1) resetframe = ToolButton('gtk-cancel') resetframe.connect('clicked', self._resetframe_cb) resetframe.set_tooltip(_('Reset')) self.insert(resetframe, -1) separator = gtk.SeparatorToolItem() self.insert(separator, -1) # play/pause buttons play_img_1 = gtk.Image() play_img_1.set_from_icon_name('media-playback-start-back', gtk.ICON_SIZE_LARGE_TOOLBAR) pause_img_1 = gtk.Image() pause_img_1.set_from_icon_name('media-playback-pause', gtk.ICON_SIZE_LARGE_TOOLBAR) play_img_2 = gtk.Image() play_img_2.set_from_icon_name('media-playback-start', gtk.ICON_SIZE_LARGE_TOOLBAR) pause_img_2 = gtk.Image() pause_img_2.set_from_icon_name('media-playback-pause', gtk.ICON_SIZE_LARGE_TOOLBAR) paly_1 = ToggleToolButton('media-playback-start-back') play_2 = ToggleToolButton('media-playback-start') paly_1.connect('toggled', self._play_cb, (paly_1, play_2), (play_img_1, pause_img_1), self.montage.playbackwards) self.insert(paly_1, -1) paly_1.set_tooltip(_('Play backward / Pause')) play_2.connect('toggled', self._play_cb, (play_2, paly_1), (play_img_2, pause_img_2), self.montage.playforwards) self.insert(play_2, -1) play_2.set_tooltip(_('Play forward / Pause')) # tempo button tempo = TempoSlider(0, 99) tempo.adjustment.connect("value-changed", self._tempo_cb) tempo.set_size_request(250, -1) tempo.set_value(50) tempo_item = gtk.ToolItem() tempo_item.add(tempo) self.insert(tempo_item, -1) separator = gtk.SeparatorToolItem() self.insert(separator, -1) # export buttons exportframe = ToolButton('image') exportframe.connect('clicked', self._exportframe_cb) exportframe.set_tooltip(_('Snapshot')) self.insert(exportframe, -1) self.show_all()
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 self.datapath = os.path.join(activity.get_activity_root(), 'instance') # Build the activity toolbar. toolbox = ToolbarBox() activity_button = ActivityToolbarButton(self) toolbox.toolbar.insert(activity_button, 0) activity_button.show() self._add_speed_slider(toolbox.toolbar) cyan = ToolButton('cyan') toolbox.toolbar.insert(cyan, -1) cyan.set_tooltip(_('Next pattern')) cyan.connect('clicked', self._button_cb, 'cyan') cyan.set_sensitive(False) cyan.show() green = ToolButton('green') toolbox.toolbar.insert(green, -1) green.set_tooltip(_('Draw')) green.connect('clicked', self._button_cb, 'green') green.show() red = ToolButton('red') toolbox.toolbar.insert(red, -1) red.set_tooltip(_('Stop')) red.connect('clicked', self._button_cb, 'red') red.show() separator = gtk.SeparatorToolItem() separator.props.draw = True toolbox.toolbar.insert(separator, -1) separator.show() label = gtk.Label('') label.set_use_markup(True) label.show() labelitem = gtk.ToolItem() labelitem.add(label) toolbox.toolbar.insert(labelitem, -1) labelitem.show() export = ToolButton('export-turtleblocks') toolbox.toolbar.insert(export, -1) export.set_tooltip(_('Export to TurtleBlocks')) export.connect('clicked', self._export_turtleblocks_cb) export.show() separator = gtk.SeparatorToolItem() separator.props.draw = False separator.set_expand(True) toolbox.toolbar.insert(separator, -1) separator.show() stop_button = StopButton(self) stop_button.props.accelerator = _('<Ctrl>Q') toolbox.toolbar.insert(stop_button, -1) stop_button.show() toolbox.show() self.set_toolbox(toolbox) # Create the game instance. self.game = Spirolaterals.Spirolaterals(colors) # Build the Pygame canvas. self._pygamecanvas = \ sugargame.canvas.PygameCanvas(self) # Note that set_canvas implicitly calls # read_file when resuming from the Journal. self.set_canvas(self._pygamecanvas) self.game.canvas = self._pygamecanvas gtk.gdk.screen_get_default().connect('size-changed', self.__configure_cb) # Start the game running. self.game.set_cyan_button(cyan) self.game.set_label(label) self._speed_range.set_value(200) self._pygamecanvas.run_pygame(self.game.run) def __configure_cb(self, event): ''' Screen size has changed ''' logging.debug(self._pygamecanvas.get_allocation()) pygame.display.set_mode( (gtk.gdk.screen_width(), gtk.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(200, self.LOWER, self.UPPER, 25, 100, 0) self._adjustment.connect('value_changed', self._speed_change_cb) self._speed_range = gtk.HScale(self._adjustment) self._speed_range.set_inverted(True) self._speed_range.set_draw_value(False) self._speed_range.set_update_policy(gtk.UPDATE_CONTINUOUS) 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.value) self.game.do_slider(self._adjustment.value) return True def _export_turtleblocks_cb(self, button=None): alert = Alert() alert.props.title = _('Save as TurtleBlocks project') self.add_alert(alert) alert.show() gobject.idle_add(self._export_turtleblocks, alert) def _export_turtleblocks(self, alert): data = self.game.tu.current step = 75 first = data[0] * step second = data[1] * step third = data[2] * step fourth = data[3] * step fifth = data[4] * step turtle_data = '[[0, ["start", 219], 248, 92, [null, 1]],' +\ '[1, ["repeat", 189], 266, 138, [0, 2, 3, null]],' +\ '[2, ["number", 4], 322, 138, [1, null]],' +\ '[3, "forward", 284, 180, [1, 4, 5]],' +\ ('[4, ["number", %s], 348, 180, [3, null]],' % first) +\ '[5, "right", 284, 222, [3, 6, 7]],' +\ '[6, ["number", 90], 342, 222, [5, null]],' +\ '[7, "forward", 284, 264, [5, 8, 9]],' +\ ('[8, ["number", %s], 348, 264, [7, null]],' % second) +\ '[9, "right", 284, 306, [7, 10, 11]],' +\ '[10, ["number", 90], 342, 306, [9, null]],' +\ '[11, "forward", 284, 348, [9, 12, 13]],' +\ ('[12, ["number", %s], 348, 348, [11, null]],'% third) +\ '[13, "right", 284, 390, [11, 14, 15]],' +\ '[14, ["number", 90], 342, 390, [13, null]],' +\ '[15, "forward", 284, 432, [13, 16, 17]],' +\ ('[16, ["number", %s], 348, 432, [15, null]],'% fourth) +\ '[17, "right", 284, 474, [15, 18, 19]],' +\ '[18, ["number", 90], 342, 474, [17, null]],' +\ '[19, "forward", 284, 516, [17, 20, 21]],' +\ ('[20, ["number", %s], 348, 516, [19, null]],'% fifth) +\ '[21, "right", 284, 558, [19, 22, null]],' +\ '[22, ["number", 90], 342, 558, [21, null]]]' file_path = os.path.join(self.datapath, 'output.tb') with open(file_path, "w") as file: file.write(turtle_data) dsobject = datastore.create() dsobject.metadata['title'] = '%s %s' % (self.metadata['title'], _('TurtleBlocks')) dsobject.metadata['icon-color'] = profile.get_color().to_string() dsobject.metadata['mime_type'] = 'application/x-turtle-art' dsobject.metadata['activity'] = 'org.laptop.TurtleArtActivity' dsobject.set_file_path(file_path) datastore.write(dsobject) dsobject.destroy() os.remove(file_path) gobject.timeout_add(1000, self._remove_alert, alert) def _remove_alert(self, alert): self.remove_alert(alert)
class ErikosActivity(activity.Activity): def __init__(self, handle): super(ErikosActivity, self).__init__(handle) try: # Use 0.86 toolbar design toolbar_box = ToolbarBox() # Buttons added to the Activity toolbar activity_button = ActivityToolbarButton(self) toolbar_box.toolbar.insert(activity_button, 0) activity_button.show() # Play Button self.play = ToolButton("media-playback-start") self.play.set_tooltip(_('Play')) self.play.props.sensitive = True self.play.connect('clicked', self._play_cb) toolbar_box.toolbar.insert(self.play, -1) self.play.show() # Sound Toggle Button self.sound = ToolButton("speaker-muted-100") self.sound.set_tooltip(_('Mute')) self.sound.props.sensitive = True self.sound.connect('clicked', self._sound_cb) toolbar_box.toolbar.insert(self.sound, -1) self.sound.show() separator = gtk.SeparatorToolItem() separator.show() toolbar_box.toolbar.insert(separator, -1) # Label for showing level self.level_label = gtk.Label("%s %d" % (_("Level"), 1)) self.level_label.show() level_toolitem = gtk.ToolItem() level_toolitem.add(self.level_label) toolbar_box.toolbar.insert(level_toolitem, -1) separator = gtk.SeparatorToolItem() separator.props.draw = False separator.set_expand(True) separator.show() toolbar_box.toolbar.insert(separator, -1) # The ever-present Stop Button stop_button = StopButton(self) stop_button.props.accelerator = '<Ctrl>Q' toolbar_box.toolbar.insert(stop_button, -1) stop_button.show() self.set_toolbar_box(toolbar_box) toolbar_box.show() except NameError: # Use pre-0.86 toolbar design self.toolbox = activity.ActivityToolbox(self) self.set_toolbox(self.toolbox) self.projectToolbar = ProjectToolbar(self) self.toolbox.add_toolbar(_('Project'), self.projectToolbar) self.toolbox.show() # Create a canvas canvas = gtk.DrawingArea() canvas.set_size_request(gtk.gdk.screen_width(), \ gtk.gdk.screen_height()) self.set_canvas(canvas) canvas.show() self.show_all() # Initialize the canvas self.sw = window.new_window(canvas, \ os.path.join(activity.get_bundle_path(), \ 'images/'), \ self) self.sw.activity = self # Read the level from the Journal try: sw.level = int(self.metadata['level']) except: pass def _play_cb(self, button): window.play_the_game(self.sw) return True def _sound_cb(self, button): if self.sw.sound is True: self.sound.set_icon("speaker-muted-000") self.sound.set_tooltip(_('Unmute')) self.sw.sound = False else: self.sound.set_icon("speaker-muted-100") self.sound.set_tooltip(_('Mute')) self.sw.sound = True return True """ Write the slider positions to the Journal """ def write_file(self, file_path): _logger.debug("Write level: " + str(self.sw.level)) self.metadata['level'] = self.sw.level
class EditToolbar(activity.EditToolbar): __gtype_name__ = 'EditToolbar' def __init__(self): activity.EditToolbar.__init__(self) self._view = None self._find_job = None search_item = gtk.ToolItem() self._search_entry = iconentry.IconEntry() self._search_entry.set_icon_from_name(iconentry.ICON_ENTRY_PRIMARY, 'system-search') self._search_entry.add_clear_button() self._search_entry.connect('activate', self._search_entry_activate_cb) self._search_entry.connect('changed', self._search_entry_changed_cb) self._search_entry_changed = True width = int(gtk.gdk.screen_width() / 3) self._search_entry.set_size_request(width, -1) search_item.add(self._search_entry) self._search_entry.show() self.insert(search_item, -1) search_item.show() self._prev = ToolButton('go-previous-paired') self._prev.set_tooltip(_('Previous')) self._prev.props.sensitive = False self._prev.connect('clicked', self._find_prev_cb) self.insert(self._prev, -1) self._prev.show() self._next = ToolButton('go-next-paired') self._next.set_tooltip(_('Next')) self._next.props.sensitive = False self._next.connect('clicked', self._find_next_cb) self.insert(self._next, -1) self._next.show() def set_view(self, view): self._view = view self._view.find_set_highlight_search(True) def _clear_find_job(self): if self._find_job is None: return if not self._find_job.is_finished(): self._find_job.cancel() self._find_job.disconnect(self._find_updated_handler) self._find_job = None def _search_find_first(self): self._clear_find_job() text = self._search_entry.props.text if text != "": self._find_job, self._find_updated_handler = \ self._view.setup_find_job(text, self._find_updated_cb) else: # FIXME: highlight nothing pass self._search_entry_changed = False self._update_find_buttons() def _search_find_next(self): self._view.find_next() def _search_find_last(self): # FIXME: does Evince support find last? return def _search_find_prev(self): self._view.find_previous() def _search_entry_activate_cb(self, entry): if self._search_entry_changed: self._search_find_first() else: self._search_find_next() def _search_entry_changed_cb(self, entry): logging.debug('Search entry: %s' % (entry.props.text)) self._search_entry_changed = True self._update_find_buttons() # gobject.timeout_add(500, self._search_entry_timeout_cb) # #def _search_entry_timeout_cb(self): # self._clear_find_job() # self._search_find_first() # return False def _find_changed_cb(self, page, spec): self._update_find_buttons() def _find_updated_cb(self, job, page=None): self._view.find_changed(job, page) def _find_prev_cb(self, button): if self._search_entry_changed: self._search_find_last() else: self._search_find_prev() def _find_next_cb(self, button): if self._search_entry_changed: self._search_find_first() else: self._search_find_next() def _update_find_buttons(self): if self._search_entry_changed: if self._search_entry.props.text != "": self._prev.props.sensitive = False # self._prev.set_tooltip(_('Find last')) self._next.props.sensitive = True self._next.set_tooltip(_('Find first')) else: self._prev.props.sensitive = False self._next.props.sensitive = False else: self._prev.props.sensitive = True self._prev.set_tooltip(_('Find previous')) self._next.props.sensitive = True self._next.set_tooltip(_('Find next'))
def __init__(self, handle): super(PeterActivity, self).__init__(handle) # Get user's Sugar colors sugarcolors = profile.get_color().to_string().split(',') colors = [[ int(sugarcolors[0][1:3], 16), int(sugarcolors[0][3:5], 16), int(sugarcolors[0][5:7], 16) ], [ int(sugarcolors[1][1:3], 16), int(sugarcolors[1][3:5], 16), int(sugarcolors[1][5:7], 16) ]] # No sharing self.max_participants = 1 self.datapath = os.path.join(activity.get_activity_root(), 'instance') # Build the activity toolbar. toolbox = ToolbarBox() activity_button = ActivityToolbarButton(self) toolbox.toolbar.insert(activity_button, 0) activity_button.show() self._add_speed_slider(toolbox.toolbar) cyan = ToolButton('cyan') toolbox.toolbar.insert(cyan, -1) cyan.set_tooltip(_('Next pattern')) cyan.connect('clicked', self._button_cb, 'cyan') cyan.set_sensitive(False) cyan.show() green = ToolButton('green') toolbox.toolbar.insert(green, -1) green.set_tooltip(_('Draw')) green.connect('clicked', self._button_cb, 'green') green.show() red = ToolButton('red') toolbox.toolbar.insert(red, -1) red.set_tooltip(_('Stop')) red.connect('clicked', self._button_cb, 'red') red.show() separator = gtk.SeparatorToolItem() separator.props.draw = True toolbox.toolbar.insert(separator, -1) separator.show() label = gtk.Label('') label.set_use_markup(True) label.show() labelitem = gtk.ToolItem() labelitem.add(label) toolbox.toolbar.insert(labelitem, -1) labelitem.show() export = ToolButton('export-turtleblocks') toolbox.toolbar.insert(export, -1) export.set_tooltip(_('Export to TurtleBlocks')) export.connect('clicked', self._export_turtleblocks_cb) export.show() separator = gtk.SeparatorToolItem() separator.props.draw = False separator.set_expand(True) toolbox.toolbar.insert(separator, -1) separator.show() stop_button = StopButton(self) stop_button.props.accelerator = _('<Ctrl>Q') toolbox.toolbar.insert(stop_button, -1) stop_button.show() toolbox.show() self.set_toolbox(toolbox) # Create the game instance. self.game = Spirolaterals.Spirolaterals(colors) # Build the Pygame canvas. self._pygamecanvas = \ sugargame.canvas.PygameCanvas(self) # Note that set_canvas implicitly calls # read_file when resuming from the Journal. self.set_canvas(self._pygamecanvas) self.game.canvas = self._pygamecanvas gtk.gdk.screen_get_default().connect('size-changed', self.__configure_cb) # Start the game running. self.game.set_cyan_button(cyan) self.game.set_label(label) self._speed_range.set_value(200) self._pygamecanvas.run_pygame(self.game.run)