def setup_toolbar(self): '''Setup the top toolbar. Groupthink needs some work here.''' toolbar_box = ToolbarBox() activity_button = ActivityToolbarButton(self) toolbar_box.toolbar.insert(activity_button, 0) activity_button.show() self.edit_toolbar = EditToolbar() edit_toolbar_button = ToolbarButton(page=self.edit_toolbar, icon_name='toolbar-edit') self.edit_toolbar.show() toolbar_box.toolbar.insert(edit_toolbar_button, -1) edit_toolbar_button.show() self.edit_toolbar.undo.connect('clicked', self.undobutton_cb) self.edit_toolbar.redo.connect('clicked', self.redobutton_cb) self.edit_toolbar.copy.connect('clicked', self.copybutton_cb) self.edit_toolbar.paste.connect('clicked', self.pastebutton_cb) separator = gtk.SeparatorToolItem() separator.props.draw = False separator.set_expand(True) toolbar_box.toolbar.insert(separator, -1) separator.show() stop_button = StopButton(self) stop_button.props.accelerator = '<Ctrl><Shift>Q' toolbar_box.toolbar.insert(stop_button, -1) stop_button.show() self.set_toolbar_box(toolbar_box) toolbar_box.show()
def addToolBarButton(self, nameID, icon_name, toolbar=None): "I wonder if this can be merged with the ad button below?" button = ToolbarButton( page=toolbar, icon_name=icon_name) self.toolbar_box.toolbar.insert(button, -1) button.show() toolbar.show() self.nameID.update({nameID:button})
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(_('Show 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) 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_birth_toolbar(self, toolbox): birth_bar = gtk.Toolbar() item1 = gtk.ToolItem() self.label_birth = gtk.Label() self.label_birth.set_text(_('Birth:') + ' ' + _('Day') + ' ') item1.add(self.label_birth) birth_bar.insert(item1, -1) item2 = gtk.ToolItem() self.day_birth_spin = gtk.SpinButton() self.day_birth_spin.set_range(1, 31) self.day_birth_spin.set_increments(1, 5) self.day_birth_spin.props.value = 10 self.day_birth_spin.connect('notify::value', self.day_birth_change) item2.add(self.day_birth_spin) birth_bar.insert(item2, -1) item3 = gtk.ToolItem() self.label_birth_month = gtk.Label() self.label_birth_month.set_text(' ' + _('Month') + ' ') item3.add(self.label_birth_month) birth_bar.insert(item3, -1) item4 = gtk.ToolItem() self.month_birth_spin = gtk.SpinButton() self.month_birth_spin.set_range(1, 12) self.month_birth_spin.set_increments(1, 4) self.month_birth_spin.props.value = 2 self.month_birth_spin.connect('notify::value', self.month_birth_change) item4.add(self.month_birth_spin) birth_bar.insert(item4, -1) item5 = gtk.ToolItem() self.label_birth_year = gtk.Label() self.label_birth_year.set_text(' ' + _('Year') + ' ') item5.add(self.label_birth_year) birth_bar.insert(item5, -1) item6 = gtk.ToolItem() self.year_birth_spin = gtk.SpinButton() self.year_birth_spin.set_range(1900, self._now.year) self.year_birth_spin.set_increments(1, 10) self.year_birth_spin.props.value = 1990 self.year_birth_spin.connect('notify::value', self.year_birth_change) item6.add(self.year_birth_spin) birth_bar.insert(item6, -1) birth_bar.show_all() birth_button = ToolbarButton(label=_('Birth'), page=birth_bar, icon_name='write-date') toolbox.toolbar.insert(birth_button, -1) birth_button.show()
def build_today_toolbar(self, toolbox): today_bar = gtk.Toolbar() item1 = gtk.ToolItem() self.label_today = gtk.Label() self.label_today.set_text(_('Today:') + ' ' + _('Day') + ' ') item1.add(self.label_today) today_bar.insert(item1, -1) item2 = gtk.ToolItem() self.day_today_spin = gtk.SpinButton() self.day_today_spin.set_range(1, 31) self.day_today_spin.set_increments(1, 5) self.day_today_spin.props.value = self._today[0] self.day_today_spin.connect('notify::value', self.day_today_change) item2.add(self.day_today_spin) today_bar.insert(item2, -1) item3 = gtk.ToolItem() self.label_today_month = gtk.Label() self.label_today_month.set_text(' ' + _('Month') + ' ') item3.add(self.label_today_month) today_bar.insert(item3, -1) item4 = gtk.ToolItem() self.month_today_spin = gtk.SpinButton() self.month_today_spin.set_range(1, 12) self.month_today_spin.set_increments(1, 4) self.month_today_spin.props.value = self._today[1] self.month_today_spin.connect('notify::value', self.month_today_change) item4.add(self.month_today_spin) today_bar.insert(item4, -1) item5 = gtk.ToolItem() self.label_today_year = gtk.Label() self.label_today_year.set_text(' ' + _('Year') + ' ') item5.add(self.label_today_year) today_bar.insert(item5, -1) item6 = gtk.ToolItem() self.year_today_spin = gtk.SpinButton() self.year_today_spin.set_range(1900, self._now.year + 1) self.year_today_spin.set_increments(1, 10) self.year_today_spin.props.value = self._today[2] self.year_today_spin.connect('notify::value', self.year_today_change) item6.add(self.year_today_spin) today_bar.insert(item6, -1) today_bar.show_all() today_button = ToolbarButton(label=_('Today'), page=today_bar, icon_name='write-time') toolbox.toolbar.insert(today_button, -1) today_button.show()
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 build_size_toolbar(self, toolbox): size_bar = gtk.Toolbar() #Horizontal item1 = gtk.ToolItem() label1 = gtk.Label() label1.set_text(' %s ' % _('H')) item1.add(label1) size_bar.insert(item1, -1) item2 = gtk.ToolItem() self.h_spin = gtk.SpinButton() self.h_spin.set_range(2, 30) self.h_spin.set_increments(1, 2) self.h_spin.props.value = self.game_size[0] self.h_spin.connect('notify::value', self.h_spin_change) item2.add(self.h_spin) size_bar.insert(item2, -1) #Vertical item3 = gtk.ToolItem() label2 = gtk.Label() label2.set_text(' %s ' % _('V')) item3.add(label2) size_bar.insert(item3, -1) item4 = gtk.ToolItem() self.v_spin = gtk.SpinButton() self.v_spin.set_range(2, 20) self.v_spin.set_increments(1, 2) self.v_spin.props.value = self.game_size[1] self.v_spin.connect('notify::value', self.v_spin_change) item4.add(self.v_spin) size_bar.insert(item4, -1) size_bar.show_all() size_button = ToolbarButton(label=_('Board size'), page=size_bar, icon_name='preferences-system') toolbox.toolbar.insert(size_button, -1) size_button.show()
def _setup_toolbars(self): ''' Add buttons to toolbars ''' custom_toolbar = gtk.Toolbar() if HAS_TOOLBARBOX: toolbox = ToolbarBox() self.toolbar = toolbox.toolbar activity_button = ActivityToolbarButton(self) self.toolbar.insert(activity_button, 0) activity_button.show() custom_toolbar_button = ToolbarButton( label=_('Custom'), page=custom_toolbar, icon_name='view-source') custom_toolbar.show() self.toolbar.insert(custom_toolbar_button, -1) custom_toolbar_button.show() self._load_standard_buttons(self.toolbar) separator_factory(self.toolbar, expand=True, visible=False) stop_button = StopButton(self) stop_button.props.accelerator = _('<Ctrl>Q') self.toolbar.insert(stop_button, -1) stop_button.show() self.set_toolbox(toolbox) toolbox.show() else: toolbox = activity.ActivityToolbox(self) self.set_toolbox(toolbox) self.toolbar = gtk.Toolbar() toolbox.add_toolbar(_('Project'), self.toolbar) toolbox.add_toolbar(_('Custom'), custom_toolbar) self._load_standard_buttons(self.toolbar) self._load_custom_buttons(custom_toolbar)
def __init__(self, toolbar): self._timer_combo = TimerCombo() toolbar.insert(self._timer_combo, -1) self._duration_combo = DurationCombo() toolbar.insert(self._duration_combo, -1) preferences_toolbar = gtk.Toolbar() combo = gtk.combo_box_new_text() self.quality = ToolComboBox(combo=combo, label_text=_('Quality:')) self.quality.combo.append_text(_('Low')) if hw.get_xo_version() != 1: # Disable High quality on XO-1. The system simply isn't beefy # enough for recording to work well. self.quality.combo.append_text(_('High')) self.quality.combo.set_active(0) self.quality.show_all() preferences_toolbar.insert(self.quality, -1) preferences_button = ToolbarButton() preferences_button.set_page(preferences_toolbar) preferences_button.props.icon_name = 'preferences-system' preferences_button.props.label = _('Preferences') toolbar.insert(preferences_button, -1)
def initialize_display(self): self._logger = logging.getLogger('butialo-activity') # Top toolbar with share and close buttons: if OLD_TOOLBAR: activity_toolbar = self.toolbox.get_activity_toolbar() else: activity_toolbar = self.activity_button.page # add 'make bundle' entry to 'keep' palette. palette = activity_toolbar.keep.get_palette() # XXX: should clear out old palette entries? from sugar.graphics.menuitem import MenuItem from sugar.graphics.icon import Icon menu_item = MenuItem(_('As Butialo Document')) menu_item.set_image(Icon(file=('%s/activity/activity-icon.svg' % get_bundle_path()), icon_size=gtk.ICON_SIZE_MENU)) menu_item.connect('activate', self.keepbutton_cb) palette.menu.append(menu_item) menu_item.show() #xop guardar como bundle #menu_item = MenuItem(_('As Activity Bundle')) #menu_item.set_image(Icon(file=('%s/activity/activity-default.svg' % # get_bundle_path()), # icon_size=gtk.ICON_SIZE_MENU)) #menu_item.connect('activate', self.makebutton_cb) #palette.menu.append(menu_item) #menu_item.show() self._edit_toolbar = activity.EditToolbar() if OLD_TOOLBAR: activity_toolbar = gtk.Toolbar() self.toolbox.add_toolbar(_('Actions'), activity_toolbar) self.toolbox.set_current_toolbar(1) self.toolbox.add_toolbar(_('Edit'), self._edit_toolbar) else: edit_toolbar_button = ToolbarButton() edit_toolbar_button.set_page(self._edit_toolbar) edit_toolbar_button.props.icon_name = 'toolbar-edit' edit_toolbar_button.props.label = _('Edit') self.get_toolbar_box().toolbar.insert(edit_toolbar_button, -1) self._edit_toolbar.show() self._edit_toolbar.undo.connect('clicked', self.__undobutton_cb) self._edit_toolbar.redo.connect('clicked', self.__redobutton_cb) self._edit_toolbar.copy.connect('clicked', self.__copybutton_cb) self._edit_toolbar.paste.connect('clicked', self.__pastebutton_cb) if OLD_TOOLBAR: actions_toolbar = activity_toolbar else: actions_toolbar = self.get_toolbar_box().toolbar # The "go" button goicon_bw = gtk.Image() goicon_bw.set_from_file("%s/icons/run_bw.svg" % os.getcwd()) goicon_color = gtk.Image() goicon_color.set_from_file("%s/icons/run_color.svg" % os.getcwd()) gobutton = ToolButton(label=_("_Run!")) gobutton.props.accelerator = _('<alt>r') gobutton.set_icon_widget(goicon_bw) gobutton.set_tooltip("Run") gobutton.connect('clicked', self.flash_cb, dict({'bw': goicon_bw, 'color': goicon_color})) gobutton.connect('clicked', self.gobutton_cb) actions_toolbar.insert(gobutton, -1) # The "stop" button stopicon_bw = gtk.Image() stopicon_bw.set_from_file("%s/icons/stopit_bw.svg" % os.getcwd()) stopicon_color = gtk.Image() stopicon_color.set_from_file("%s/icons/stopit_color.svg" % os.getcwd()) stopbutton = ToolButton(label=_("_Stop")) stopbutton.props.accelerator = _('<alt>s') stopbutton.set_icon_widget(stopicon_bw) stopbutton.connect('clicked', self.flash_cb, dict({'bw': stopicon_bw, 'color': stopicon_color})) stopbutton.connect('clicked', self.stopbutton_cb) stopbutton.set_tooltip("Stop Running") actions_toolbar.insert(stopbutton, -1) # The "refresh" button refreshicon_bw = gtk.Image() refreshicon_bw.set_from_file("%s/icons/butiaoff.svg" % os.getcwd()) refreshicon_color = gtk.Image() refreshicon_color.set_from_file("%s/icons/butiaon.svg" % os.getcwd()) refreshbutton = ToolButton(label=_("_Reload")) refreshbutton.props.accelerator = _('<alt>d') refreshbutton.set_icon_widget(refreshicon_bw) refreshbutton.connect('clicked', self.flash_cb, dict({'bw': refreshicon_bw, 'color': refreshicon_color})) refreshbutton.connect('clicked', self.initialize_snippets_cb) refreshbutton.set_tooltip("Reload devices") actions_toolbar.insert(refreshbutton, -1) # The "clear" button #clearicon_bw = gtk.Image() #clearicon_bw.set_from_file("%s/icons/eraser_bw.svg" % os.getcwd()) #clearicon_color = gtk.Image() #clearicon_color.set_from_file("%s/icons/eraser_color.svg" % # os.getcwd()) #clearbutton = ToolButton(label=_("_Clear")) #clearbutton.props.accelerator = _('<alt>c') #clearbutton.set_icon_widget(clearicon_bw) #clearbutton.connect('clicked', self.clearbutton_cb) #clearbutton.connect('clicked', self.flash_cb, dict({'bw': clearicon_bw, # 'color': clearicon_color})) #clearbutton.set_tooltip("Clear") #actions_toolbar.insert(clearbutton, -1) # The "beautify" button beautifyicon_bw = gtk.Image() beautifyicon_bw.set_from_file("%s/icons/beautifyicon_bw.svg" % os.getcwd()) beautifyicon_color = gtk.Image() beautifyicon_color.set_from_file("%s/icons/beautifyicon_color.svg" % os.getcwd()) beautifybutton = ToolButton(label=_("_Auto-format")) beautifybutton.props.accelerator = _('<alt>f') beautifybutton.set_icon_widget(beautifyicon_bw) beautifybutton.connect('clicked', self.beautifybutton_cb) beautifybutton.connect('clicked', self.flash_cb, dict({'bw': beautifyicon_bw, 'color': beautifyicon_color})) beautifybutton.set_tooltip("Auto-format") actions_toolbar.insert(beautifybutton, -1) activity_toolbar.show() if not OLD_TOOLBAR: separator = gtk.SeparatorToolItem() separator.props.draw = False separator.set_expand(True) self.get_toolbar_box().toolbar.insert(separator, -1) separator.show() stop = StopButton(self) self.get_toolbar_box().toolbar.insert(stop, -1) # Main layout. self.hpane = gtk.HPaned() self.vpane = gtk.VPaned() # The sidebar. self.sidebar = gtk.VBox() self.model = gtk.TreeStore(gobject.TYPE_PYOBJECT, gobject.TYPE_STRING) treeview = gtk.TreeView(self.model) cellrenderer = gtk.CellRendererText() treecolumn = gtk.TreeViewColumn(_("Available"), cellrenderer, text=1) treeview.get_selection().connect("changed", self.selection_cb) treeview.append_column(treecolumn) treeview.set_size_request(int(SIZE_X * 0.3), SIZE_Y) # Create scrollbars around the view. scrolled = gtk.ScrolledWindow() scrolled.add(treeview) self.sidebar.pack_start(scrolled) self.hpane.add1(self.sidebar) #root = os.path.join(get_bundle_path(), 'data') #initialize snippets self.initialize_snippets_cb(None) # Source buffer import gtksourceview2 global text_buffer lang_manager = gtksourceview2.language_manager_get_default() if hasattr(lang_manager, 'list_languages'): langs = lang_manager.list_languages() else: lang_ids = lang_manager.get_language_ids() langs = [lang_manager.get_language(lang_id) for lang_id in lang_ids] for lang in langs: for m in lang.get_mime_types(): if m == "text/x-lua": text_buffer.set_language(lang) if hasattr(text_buffer, 'set_highlight'): text_buffer.set_highlight(True) else: text_buffer.set_highlight_syntax(True) # The GTK source view window self.text_view = gtksourceview2.View(text_buffer) self.text_view.set_size_request(0, int(SIZE_Y * 0.5)) self.text_view.set_editable(True) self.text_view.set_cursor_visible(True) self.text_view.set_show_line_numbers(True) self.text_view.set_wrap_mode(gtk.WRAP_CHAR) self.text_view.set_insert_spaces_instead_of_tabs(True) self.text_view.set_tab_width(2) self.text_view.set_auto_indent(True) self.text_view.modify_font(pango.FontDescription("Monospace " + str(font_zoom(style.FONT_SIZE)))) # We could change the color theme here, if we want to. #mgr = gtksourceview2.style_manager_get_default() #style_scheme = mgr.get_scheme('kate') #self.text_buffer.set_style_scheme(style_scheme) codesw = gtk.ScrolledWindow() codesw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC) codesw.add(self.text_view) self.vpane.add1(codesw) # An hbox to hold the vte window and its scrollbar. outbox = gtk.HBox() # The vte python window self._vte = vte.Terminal() self._vte.set_encoding('utf-8') self._vte.set_size(30, 5) font = 'Monospace ' + str(font_zoom(style.FONT_SIZE)) self._vte.set_font(pango.FontDescription(font)) self._vte.set_colors(gtk.gdk.color_parse('#000000'), gtk.gdk.color_parse('#E7E7E7'), []) self._vte.connect('child_exited', self.child_exited_cb) self._child_exited_handler = None self._vte.drag_dest_set(gtk.DEST_DEFAULT_ALL, [("text/plain", 0, TARGET_TYPE_TEXT)], gtk.gdk.ACTION_COPY) self._vte.connect('drag_data_received', self.vte_drop_cb) outbox.pack_start(self._vte) outsb = gtk.VScrollbar(self._vte.get_adjustment()) outsb.show() outbox.pack_start(outsb, False, False, 0) self.vpane.add2(outbox) self.hpane.add2(self.vpane) return self.hpane
def build_colors_toolbar(self, toolbox): colors_bar = gtk.Toolbar() ######################################################################## # Point color item = gtk.ToolItem() label = gtk.Label() label.set_text('%s ' % _('Player 1')) item.add(label) colors_bar.insert(item, -1) # select color item = gtk.ToolItem() _fill_color = ColorToolButton() c = gtk.gdk.Color() c.red = 65535 c.green = 65535 c.blue = 65535 _fill_color.set_color(c) _fill_color.connect('notify::color', self.color_player1_change) item.add(_fill_color) colors_bar.insert(item, -1) # Separator separator = gtk.SeparatorToolItem() colors_bar.insert(separator, -1) separator.show() ######################################################################## # Back color item = gtk.ToolItem() label = gtk.Label() label.set_text('%s ' % _('Player 2')) item.add(label) colors_bar.insert(item, -1) # select color item = gtk.ToolItem() _fill_color = ColorToolButton() c = gtk.gdk.Color() c.red = 0 c.green = 0 c.blue = 0 _fill_color.set_color(c) _fill_color.connect('notify::color', self.color_player2_change) item.add(_fill_color) colors_bar.insert(item, -1) # Separator separator = gtk.SeparatorToolItem() colors_bar.insert(separator, -1) separator.show() ######################################################################## # Line color item = gtk.ToolItem() label = gtk.Label() label.set_text('%s ' % _('Lines')) item.add(label) colors_bar.insert(item, -1) # select color item = gtk.ToolItem() _fill_color = ColorToolButton() _fill_color.connect('notify::color', self.color_line_change) item.add(_fill_color) colors_bar.insert(item, -1) # Separator separator = gtk.SeparatorToolItem() colors_bar.insert(separator, -1) separator.show() ######################################################################## # Line color item = gtk.ToolItem() label = gtk.Label() label.set_text('%s ' % _('Background')) item.add(label) colors_bar.insert(item, -1) # select color item = gtk.ToolItem() _fill_color = ColorToolButton() _fill_color.connect('notify::color', self.color_back_change) item.add(_fill_color) colors_bar.insert(item, -1) # Separator separator = gtk.SeparatorToolItem() colors_bar.insert(separator, -1) separator.show() ######################################################################## # Line color item = gtk.ToolItem() label = gtk.Label() label.set_text('%s ' % _('Board')) item.add(label) colors_bar.insert(item, -1) # select color item = gtk.ToolItem() _fill_color = ColorToolButton() _fill_color.connect('notify::color', self.color_board_change) item.add(_fill_color) colors_bar.insert(item, -1) ######################################################################## colors_bar.show_all() colors_button = ToolbarButton(label=_('Colors'), page=colors_bar, icon_name='toolbar-colors') toolbox.toolbar.insert(colors_button, -1) colors_button.show()
def __init__(self, handle): """ Initiate activity. """ super(AbacusActivity, self).__init__(handle) if _new_sugar_system: # 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() # Suanpan (Chinese abacus) 2:5 self.chinese = ToolButton("Con") self.chinese.set_tooltip(_('Suanpan')) self.chinese.props.sensitive = True self.chinese.connect('clicked', self._chinese_cb) toolbar_box.toolbar.insert(self.chinese, -1) self.chinese.show() # Soroban (Japanese abacus) 1:4 self.japanese = ToolButton("Joff") self.japanese.set_tooltip(_('Soroban')) self.japanese.props.sensitive = True self.japanese.connect('clicked', self._japanese_cb) toolbar_box.toolbar.insert(self.japanese, -1) self.japanese.show() # Schety (Russian abacus) 0:10 self.russian = ToolButton("Roff") self.russian.set_tooltip(_('Schety')) self.russian.props.sensitive = True self.russian.connect('clicked', self._russian_cb) toolbar_box.toolbar.insert(self.russian, -1) self.russian.show() # Nepohualtzintzin (Mayan abacus) 3:4 (base 20) self.mayan = ToolButton("Moff") self.mayan.set_tooltip(_('Nepohualtzintzin')) self.mayan.props.sensitive = True self.mayan.connect('clicked', self._mayan_cb) toolbar_box.toolbar.insert(self.mayan, -1) self.mayan.show() # Binary (base 2) self.binary = ToolButton("Boff") self.binary.set_tooltip(_('Binary')) self.binary.props.sensitive = True self.binary.connect('clicked', self._binary_cb) toolbar_box.toolbar.insert(self.binary, -1) self.binary.show() # Hexadecimal (base 16) self.hex = ToolButton("Hoff") self.hex.set_tooltip(_('Hexadecimal')) self.hex.props.sensitive = True self.hex.connect('clicked', self._hex_cb) toolbar_box.toolbar.insert(self.hex, -1) self.hex.show() # Fractions (1/2, 1/3, 1/4, 1/5, 1/6, 1/8, 1/9, 1/10, 1/12) self.fraction = ToolButton("Foff") self.fraction.set_tooltip(_('Fraction')) self.fraction.props.sensitive = True self.fraction.connect('clicked', self._fraction_cb) toolbar_box.toolbar.insert(self.fraction, -1) self.fraction.show() separator = gtk.SeparatorToolItem() separator.props.draw = False separator.set_expand(False) separator.show() toolbar_box.toolbar.insert(separator, -1) # The Customization submenu (roll your own) custom_toolbar = gtk.Toolbar() self._rods_label = gtk.Label(_("Rods:") + " ") self._rods_label.set_line_wrap(True) self._rods_label.show() self._rods_toolitem = gtk.ToolItem() self._rods_toolitem.add(self._rods_label) custom_toolbar.insert(self._rods_toolitem, -1) self._rods_toolitem.show() self._rods_spin_adj = gtk.Adjustment(15, 1, 20, 1, 32, 0) self._rods_spin = gtk.SpinButton(self._rods_spin_adj, 0, 0) self._rods_spin_id = self._rods_spin.connect( 'value-changed', self._rods_spin_cb) self._rods_spin.set_numeric(True) self._rods_spin.show() self.tool_item_rods = gtk.ToolItem() self.tool_item_rods.add(self._rods_spin) custom_toolbar.insert(self.tool_item_rods, -1) self.tool_item_rods.show() self._top_label = gtk.Label(" " + _("Top:") + " ") self._top_label.set_line_wrap(True) self._top_label.show() self._top_toolitem = gtk.ToolItem() self._top_toolitem.add(self._top_label) custom_toolbar.insert(self._top_toolitem, -1) self._top_toolitem.show() self._top_spin_adj = gtk.Adjustment(2, 0, 4, 1, 32, 0) self._top_spin = gtk.SpinButton(self._top_spin_adj, 0, 0) self._top_spin_id = self._top_spin.connect('value-changed', self._top_spin_cb) self._top_spin.set_numeric(True) self._top_spin.show() self.tool_item_top = gtk.ToolItem() self.tool_item_top.add(self._top_spin) custom_toolbar.insert(self.tool_item_top, -1) self.tool_item_top.show() self._bottom_label = gtk.Label(" " + _("Bottom:") + " ") self._bottom_label.set_line_wrap(True) self._bottom_label.show() self._bottom_toolitem = gtk.ToolItem() self._bottom_toolitem.add(self._bottom_label) custom_toolbar.insert(self._bottom_toolitem, -1) self._bottom_toolitem.show() self._bottom_spin_adj = gtk.Adjustment(5, 1, 15, 1, 32, 0) self._bottom_spin = gtk.SpinButton(self._bottom_spin_adj, 0, 0) self._bottom_spin_id = self._bottom_spin.connect( 'value-changed', self._bottom_spin_cb) self._bottom_spin.set_numeric(True) self._bottom_spin.show() self.tool_item_bottom = gtk.ToolItem() self.tool_item_bottom.add(self._bottom_spin) custom_toolbar.insert(self.tool_item_bottom, -1) self.tool_item_bottom.show() self._value_label = gtk.Label(" " + _("Factor:") + " ") self._value_label.set_line_wrap(True) self._value_label.show() self._value_toolitem = gtk.ToolItem() self._value_toolitem.add(self._value_label) custom_toolbar.insert(self._value_toolitem, -1) self._value_toolitem.show() self._value_spin_adj = gtk.Adjustment(5, 1, 20, 1, 32, 0) self._value_spin = gtk.SpinButton(self._value_spin_adj, 0, 0) self._value_spin_id = self._value_spin.connect( 'value-changed', self._value_spin_cb) self._value_spin.set_numeric(True) self._value_spin.show() self.tool_item_value = gtk.ToolItem() self.tool_item_value.add(self._value_spin) custom_toolbar.insert(self.tool_item_value, -1) self.tool_item_value.show() self._base_label = gtk.Label(" " + _("Base:") + " ") self._base_label.set_line_wrap(True) self._base_label.show() self._base_toolitem = gtk.ToolItem() self._base_toolitem.add(self._base_label) custom_toolbar.insert(self._base_toolitem, -1) self._base_toolitem.show() self._base_spin_adj = gtk.Adjustment(10, 1, 20, 1, 32, 0) self._base_spin = gtk.SpinButton(self._base_spin_adj, 0, 0) self._base_spin_id = self._base_spin.connect( 'value-changed', self._base_spin_cb) self._base_spin.set_numeric(True) self._base_spin.show() self.tool_item_base = gtk.ToolItem() self.tool_item_base.add(self._base_spin) custom_toolbar.insert(self.tool_item_base, -1) self.tool_item_base.show() # Custom self._custom = ToolButton("new-game") self._custom.set_tooltip(_('Custom')) self._custom.props.sensitive = True self._custom.connect('clicked', self._custom_cb) custom_toolbar.insert(self._custom, -1) self._custom.show() custom_toolbar_button = ToolbarButton(page=custom_toolbar, icon_name='view-source') custom_toolbar.show() toolbar_box.toolbar.insert(custom_toolbar_button, -1) custom_toolbar_button.show() 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() else: # 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.customToolbar = CustomToolbar(self) self.toolbox.add_toolbar(_('Custom'), self.customToolbar) 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.abacus = Abacus(canvas, self) # Read the current mode from the Journal try: if self.metadata['abacus'] == 'suanpan': self._chinese_cb(None) elif self.metadata['abacus'] == 'soroban': self._japanese_cb(None) elif self.metadata['abacus'] == 'schety': self._russian_cb(None) elif self.metadata['abacus'] == 'nepohualtzintzin': self._mayan_cb(None) elif self.metadata['abacus'] == 'binary': self._binary_cb(None) elif self.metadata['abacus'] == 'hexadecimal': self._hex_cb(None) elif self.metadata['abacus'] == 'fraction': self._fraction_cb(None) else: self._chinese_cb(None) except: pass try: self.abacus.mode.set_value(self.metadata['value']) self.abacus.mode.label(self.abacus.mode.value()) except: pass
def build_calibrate_toolbar(self, toolbox): calibrate_bar = gtk.Toolbar() item1 = gtk.ToolItem() label1 = gtk.Label() label1.set_text(' ' + _('Calibrate/Follow') + ' ') item1.add(label1) calibrate_bar.insert(item1, -1) stop_calibrate = ToolButton('media-playback-stop') stop_calibrate.set_tooltip(_('Stop')) stop_calibrate.set_accelerator('<ctrl>space') stop_calibrate.connect('clicked', self.stop_execute) calibrate_bar.insert(stop_calibrate, -1) separator1 = gtk.SeparatorToolItem() separator1.props.draw = True calibrate_bar.insert(separator1, -1) item3 = gtk.ToolItem() self.label_color_red = gtk.Label() self.label_color_red.set_text(' ' + _('Calibrated color:') + ' ' + _('Red') + ' ') item3.add(self.label_color_red) calibrate_bar.insert(item3, -1) item4 = gtk.ToolItem() self.red_spin = gtk.SpinButton() self.red_spin.set_range(0, 255) self.red_spin.set_increments(1, 10) self.red_spin.props.value = self.colorC[0] self.red_spin.connect('notify::value', self.red_spin_color) item4.add(self.red_spin) calibrate_bar.insert(item4, -1) item5 = gtk.ToolItem() self.label_color_green = gtk.Label() self.label_color_green.set_text(' ' + _('Green') + ' ') item5.add(self.label_color_green) calibrate_bar.insert(item5, -1) item6 = gtk.ToolItem() self.green_spin = gtk.SpinButton() self.green_spin.set_range(0, 255) self.green_spin.set_increments(1, 10) self.green_spin.props.value = self.colorC[1] self.green_spin.connect('notify::value', self.green_spin_color) item6.add(self.green_spin) calibrate_bar.insert(item6, -1) item7 = gtk.ToolItem() self.label_color_blue = gtk.Label() self.label_color_blue.set_text(' ' + _('Blue') + ' ') item7.add(self.label_color_blue) calibrate_bar.insert(item7, -1) item8 = gtk.ToolItem() self.blue_spin = gtk.SpinButton() self.blue_spin.set_range(0, 255) self.blue_spin.set_increments(1, 10) self.blue_spin.props.value = self.colorC[2] self.blue_spin.connect('notify::value', self.blue_spin_color) item8.add(self.blue_spin) calibrate_bar.insert(item8, -1) calibrate_bar.show_all() calibrate_button = ToolbarButton(label=_('Calibrate'), page=calibrate_bar, icon_name='preferences-system') toolbox.toolbar.insert(calibrate_button, -1) calibrate_button.show()
def build_options_toolbar(self, toolbox): options_bar = gtk.Toolbar() item1 = gtk.ToolItem() label1 = gtk.Label() label1.set_text(' ' + _('Pixels') + ' ') item1.add(label1) options_bar.insert(item1, -1) item2 = gtk.ToolItem() pixels = gtk.SpinButton() pixels.set_range(0, 1000) pixels.set_increments(1, 10) pixels.props.value = self.pixels pixels.connect('notify::value', self.pixels_value) item2.add(pixels) options_bar.insert(item2, -1) separator1 = gtk.SeparatorToolItem() separator1.props.draw = True options_bar.insert(separator1, -1) item3 = gtk.ToolItem() self.label_threshold_red = gtk.Label() self.label_threshold_red.set_text(' ' + _('Threshold:') + ' ' + _('Red') + ' ') item3.add(self.label_threshold_red) options_bar.insert(item3, -1) item4 = gtk.ToolItem() red_spin = gtk.SpinButton() red_spin.set_range(0, 255) red_spin.set_increments(1, 10) red_spin.props.value = self.threshold[0] red_spin.connect('notify::value', self.red_spin_threshold) item4.add(red_spin) options_bar.insert(item4, -1) item5 = gtk.ToolItem() self.label_threshold_green = gtk.Label() self.label_threshold_green.set_text(' ' + _('Green') + ' ') item5.add(self.label_threshold_green) options_bar.insert(item5, -1) item6 = gtk.ToolItem() green_spin = gtk.SpinButton() green_spin.set_range(0, 255) green_spin.set_increments(1, 10) green_spin.props.value = self.threshold[1] green_spin.connect('notify::value', self.green_spin_threshold) item6.add(green_spin) options_bar.insert(item6, -1) item7 = gtk.ToolItem() self.label_threshold_blue = gtk.Label() self.label_threshold_blue.set_text(' ' + _('Blue') + ' ') item7.add(self.label_threshold_blue) options_bar.insert(item7, -1) item8 = gtk.ToolItem() blue_spin = gtk.SpinButton() blue_spin.set_range(0, 255) blue_spin.set_increments(1, 10) blue_spin.props.value = self.threshold[2] blue_spin.connect('notify::value', self.blue_spin_threshold) item8.add(blue_spin) options_bar.insert(item8, -1) options_bar.show_all() options_button = ToolbarButton(label=_('Options'), page=options_bar, icon_name='view-source') toolbox.toolbar.insert(options_button, -1) options_button.show()
def __init__(self, handle): activity.Activity.__init__(self, handle) try: # Use new >= 0.86 toolbar design self.max_participants = 1 toolbar_box = ToolbarBox() 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() self.edit_toolbar = ToolbarButton() self.edit_toolbar.props.page = EditToolbar(self) self.edit_toolbar.props.icon_name = 'toolbar-edit' self.edit_toolbar.props.label = _('Edit'), toolbar_box.toolbar.insert(self.edit_toolbar, -1) self._undo = UndoManager.UndoManager( self, self.edit_toolbar.props.page.undo.child, self.edit_toolbar.props.page.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) separator = gtk.SeparatorToolItem() toolbar_box.toolbar.insert(separator, -1) separator = gtk.SeparatorToolItem() separator.props.draw = False separator.set_expand(True) separator.show() toolbar_box.toolbar.insert(separator, -1) target_toolbar = toolbar_box.toolbar tool_offset = 4 tool = StopButton(self) toolbar_box.toolbar.insert(tool, -1) toolbar_box.show_all() self.set_toolbar_box(toolbar_box) except NameError: # 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() target_toolbar = self.edit_toolbar tool_offset = 0 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.mods = [None] * 6 self.mods[0] = RadioToolButton(named_icon='select-mode') self.mods[0].set_tooltip(_('Edit mode')) self.mods[0].set_accelerator(_('<ctrl>e')) self.mods[0].set_group(None) self.mods[0].connect('clicked', self.__mode_cb, MMapArea.MODE_NULL) target_toolbar.insert(self.mods[0], tool_offset) self.mods[1] = RadioToolButton(named_icon='text-mode') self.mods[1].set_tooltip(_('Text mode')) self.mods[1].set_accelerator(_('<ctrl>t')) self.mods[1].set_group(self.mods[0]) self.mods[1].connect('clicked', self.__mode_cb, MMapArea.MODE_TEXT) target_toolbar.insert(self.mods[1], tool_offset + 1) self.mods[2] = RadioToolButton(named_icon='draw-mode') self.mods[2].set_group(self.mods[0]) self.mods[2].set_tooltip(_('Drawing mode')) self.mods[2].set_accelerator(_('<ctrl>d')) self.mods[2].connect('clicked', self.__mode_cb, MMapArea.MODE_DRAW) target_toolbar.insert(self.mods[2], tool_offset + 2) self.mods[3] = RadioToolButton(named_icon='image-mode') self.mods[3].set_group(self.mods[0]) self.mods[3].set_tooltip(_('Image add mode')) self.mods[3].set_accelerator(_('<ctrl>i')) self.mods[3].connect('clicked', self.__mode_cb, MMapArea.MODE_IMAGE) target_toolbar.insert(self.mods[3], tool_offset + 3) self.mods[5] = RadioToolButton(named_icon='label-mode') self.mods[5].set_tooltip(_('Label mode')) self.mods[5].set_accelerator(_('<ctrl>a')) self.mods[5].set_group(self.mods[0]) self.mods[5].connect('clicked', self.__mode_cb, MMapArea.MODE_LABEL) target_toolbar.insert(self.mods[5], tool_offset + 4) separator = gtk.SeparatorToolItem() target_toolbar.insert(separator, tool_offset + 5) tool = ToolButton('link') tool.set_tooltip(_('Link/unlink two selected thoughts')) tool.set_accelerator(_('<ctrl>l')) tool.connect('clicked', self.__link_cb) target_toolbar.insert(tool, tool_offset + 6) tool = ToolButton('edit-delete') tool.set_tooltip(_('Erase selected thought(s)')) tool.connect('clicked', self.__delete_cb) target_toolbar.insert(tool, tool_offset + 7) self.show_all() self._mode = MMapArea.MODE_TEXT self._main_area.set_mode(self._mode) self.mods[MMapArea.MODE_TEXT].set_active(True) self.set_focus_child(self._main_area)
def __init__ (self, handle): if os.path.exists('/tmp/1'): os.remove('/tmp/1') activity.Activity.__init__ (self, handle) # abiword uses the current directory for all its file dialogs os.chdir(os.path.expanduser('~')) # create our main abiword canvas self.abiword_canvas = Canvas() self.set_canvas(self.abiword_canvas) self.abiword_canvas.connect_after('map-event', self.__map_event_cb) self.abiword_canvas.show() if os.path.exists('/tmp/2'): os.remove('/tmp/2') toolbar_box = ToolbarBox() activity_button = ActivityToolbarButton(self) separator = gtk.SeparatorToolItem() separator.show() activity_button.props.page.insert(separator, 2) export_button = ExportButton(self, self.abiword_canvas) export_button.show() activity_button.props.page.insert(export_button, 2) toolbar_box.toolbar.insert(activity_button, 0) edit_toolbar = ToolbarButton() edit_toolbar.props.page = EditToolbar(self, toolbar_box) edit_toolbar.props.icon_name = 'toolbar-edit' edit_toolbar.props.label = _('Edit') toolbar_box.toolbar.insert(edit_toolbar, -1) view_toolbar = ToolbarButton() view_toolbar.props.page = ViewToolbar(self.abiword_canvas) view_toolbar.props.icon_name = 'toolbar-view' view_toolbar.props.label = _('View') toolbar_box.toolbar.insert(view_toolbar, -1) separator = gtk.SeparatorToolItem() toolbar_box.toolbar.insert(separator, -1) toolbar_box.show_all() self.set_toolbar_box(toolbar_box) if os.path.exists('/tmp/3'): os.remove('/tmp/3') text_toolbar = ToolbarButton() text_toolbar.props.page = TextToolbar(self.abiword_canvas) text_toolbar.props.icon_name = 'format-text' text_toolbar.props.label = _('Text') toolbar_box.toolbar.insert(text_toolbar, -1) para_toolbar = ToolbarButton() para_toolbar.props.page = ParagraphToolbar(self.abiword_canvas) para_toolbar.props.icon_name = 'paragraph-bar' para_toolbar.props.label = _('Paragraph') toolbar_box.toolbar.insert(para_toolbar, -1) list_toolbar = ToolbarButton() list_toolbar.props.page = ListToolbar(self.abiword_canvas) list_toolbar.props.icon_name = 'toolbar-bulletlist' list_toolbar.props.label = _('Bullet List') toolbar_box.toolbar.insert(list_toolbar, -1) insert_toolbar = ToolbarButton() insert_toolbar.props.page = InsertToolbar(self.abiword_canvas) insert_toolbar.props.icon_name = 'insert-table' insert_toolbar.props.label = _('Table') toolbar_box.toolbar.insert(insert_toolbar, -1) separator = gtk.SeparatorToolItem() toolbar_box.toolbar.insert(separator, -1) bold = ToggleToolButton('format-text-bold') bold.set_tooltip(_('Bold')) bold_id = bold.connect('clicked', lambda sender: self.abiword_canvas.toggle_bold()) self.abiword_canvas.connect('bold', lambda abi, b: self._setToggleButtonState(bold, b, bold_id)) toolbar_box.toolbar.insert(bold, -1) italic = ToggleToolButton('format-text-italic') italic.set_tooltip(_('Italic')) italic_id = italic.connect('clicked', lambda sender: self.abiword_canvas.toggle_italic()) self.abiword_canvas.connect('italic', lambda abi, b: self._setToggleButtonState(italic, b, italic_id)) toolbar_box.toolbar.insert(italic, -1) underline = ToggleToolButton('format-text-underline') underline.set_tooltip(_('Underline')) underline_id = underline.connect('clicked', lambda sender: self.abiword_canvas.toggle_underline()) self.abiword_canvas.connect('underline', lambda abi, b: self._setToggleButtonState(underline, b, underline_id)) toolbar_box.toolbar.insert(underline, -1) separator = gtk.SeparatorToolItem() toolbar_box.toolbar.insert(separator, -1) color = ColorToolButton() color.connect('color-set', self._text_color_cb, self.abiword_canvas) tool_item = gtk.ToolItem() tool_item.add(color) toolbar_box.toolbar.insert(tool_item, -1) self.abiword_canvas.connect('color', lambda abi, r, g, b: color.set_color(gtk.gdk.Color(r * 256, g * 256, b * 256))) separator = gtk.SeparatorToolItem() separator.props.draw = False separator.set_expand(True) separator.show() toolbar_box.toolbar.insert(separator, -1) stop = StopButton(self) toolbar_box.toolbar.insert(stop, -1) toolbar_box.show_all() self.set_toolbar_box(toolbar_box) self._zoom_handler = self.abiword_canvas.connect("zoom", self.__zoom_cb)
def build_colors_toolbar(self, toolbox): colors_bar = gtk.Toolbar() ######################################################################## # Point color item = gtk.ToolItem() label = gtk.Label() label.set_text('%s ' % _('Points')) item.add(label) colors_bar.insert(item, -1) # select color item = gtk.ToolItem() fill_color = ColorToolButton() fill_color.connect('notify::color', self.color_point_change) item.add(fill_color) colors_bar.insert(item, -1) # Separator separator = gtk.SeparatorToolItem() colors_bar.insert(separator, -1) separator.show() ######################################################################## # Back color item = gtk.ToolItem() label = gtk.Label() label.set_text('%s ' % _('Background')) item.add(label) colors_bar.insert(item, -1) # select color item = gtk.ToolItem() _fill_color = ColorToolButton() c = gtk.gdk.Color() c.red = 21588 c.green = 47546 c.blue = 18504 _fill_color.set_color(c) _fill_color.connect('notify::color', self.color_back_change) item.add(_fill_color) colors_bar.insert(item, -1) # Separator separator = gtk.SeparatorToolItem() colors_bar.insert(separator, -1) separator.show() ######################################################################## # Line color item = gtk.ToolItem() label = gtk.Label() label.set_text('%s ' % _('Lines')) item.add(label) colors_bar.insert(item, -1) # select color item = gtk.ToolItem() _fill_color = ColorToolButton() _fill_color.connect('notify::color', self.color_line_change) item.add(_fill_color) colors_bar.insert(item, -1) # Separator separator = gtk.SeparatorToolItem() colors_bar.insert(separator, -1) separator.show() ######################################################################## # Owner color item = gtk.ToolItem() label = gtk.Label() label.set_text('%s ' % _('Owner')) item.add(label) colors_bar.insert(item, -1) # select color item = gtk.ToolItem() _fill_color = ColorToolButton() c = gtk.gdk.Color() c.red = 65535 _fill_color.set_color(c) _fill_color.connect('notify::color', self.color_owner_change) item.add(_fill_color) colors_bar.insert(item, -1) colors_bar.show_all() colors_button = ToolbarButton(label=_('Colors'), page=colors_bar, icon_name='toolbar-colors') toolbox.toolbar.insert(colors_button, -1) colors_button.show()
def __init__(self, handle): """Set up the XoScope activity.""" activity.Activity.__init__(self, handle) self._instance_directory = os.path.join(self.get_activity_root(),\ 'instance') # we do not have collaboration features # make the share option insensitive self.max_participants = 1 self._capturing = False self._mode = 'live' # 0, 2 or 5 second delay before capturing the image self._delay = 0 # Zoom 1x, 2x, 4x self._zoom = 1 # Exposure bracketing self._bracketing = '0' # Preview mode stuff self._num_pics = 0 # Index of pic to be displayed in preview mode self._pic_index = 0 # This holds the image titles and name information. Saved # across activity instances self._images = [] # Flag to store whether image preview element needs to resize # the pixbuf self._needs_resize = False if OLD_TOOLBAR: self.toolbox = ActivityToolbox(self) self.set_toolbox(self.toolbox) self.toolbox.show() activity_toolbar = self.toolbox.get_activity_toolbar() activity_toolbar = gtk.Toolbar() self.toolbox.add_toolbar(_('Control'), activity_toolbar) self.toolbox.set_current_toolbar(1) self._controls_toolbar = activity_toolbar advanced_toolbar = self.toolbox.get_activity_toolbar() advanced_toolbar = gtk.Toolbar() #self.toolbox.add_toolbar(_('Advanced controls'), advanced_toolbar) else: toolbar_box = ToolbarBox() self.activity_button = ActivityToolbarButton(self) toolbar_box.toolbar.insert(self.activity_button, 0) self.activity_button.show() self.set_toolbar_box(toolbar_box) toolbar_box.show() activity_toolbar = self.activity_button.page self._controls_toolbar = self.get_toolbar_box().toolbar self._controls_toolbar.show() advanced_toolbar = gtk.Toolbar() #advanced_toolbar.show_all() advanced_button = ToolbarButton() advanced_button.props.page = advanced_toolbar advanced_button.props.label = _('Advanced controls') advanced_button.props.icon_name = 'advanced' #advanced_button.show() #toolbar_box.toolbar.insert(advanced_button, -1) self._live_toolitem = gtk.ToolItem() self._live_toolbar_container = gtk.HBox() self._preview_toolitem = gtk.ToolItem() self._preview_toolbar_container = gtk.HBox() separator = gtk.SeparatorToolItem() if not OLD_TOOLBAR: separator.props.draw = True else: separator.props.draw = False separator.set_expand(False) self._controls_toolbar.insert(separator, -1) separator.show() self._photo_button = ToolButton('photo') self._photo_button.props.label = _('Capture photo') self._photo_button.connect('clicked', self.__capture_image_cb) self._live_toolbar_container.add(self._photo_button) self._photo_button.show() self._delay_button = ToolButton('delay_%d' % self._delay) self._delay_button.props.label = _('Capture delay') self._delay_button.connect('clicked', self.__change_capture_delay_cb) self._live_toolbar_container.add(self._delay_button) self._delay_button.show() self._zoom_button = ToolButton('zoom_%d' % self._zoom) self._zoom_button.props.label = _('Image Zoom') self._zoom_button.connect('clicked', self.__change_image_zoom_cb) self._live_toolbar_container.add(self._zoom_button) self._zoom_button.show() #if self._check_available_control(v4l2.V4L2_CID_EXPOSURE): # self._bracketing_button = ToolButton('bracketing_%s' % self._bracketing) # self._bracketing_button.props.label = _('bracketing mode') # self._bracketing_button.connect('clicked', # self.__change_capture_bracketing_cb) # self._live_toolbar_container.add(self._bracketing_button) # self._bracketing_button.show() separator = gtk.SeparatorToolItem() separator.props.draw = True separator.set_expand(False) self._live_toolbar_container.add(separator) separator.show() # Camera control settings follow if self._check_available_control(v4l2.V4L2_CID_EXPOSURE): self._exposure_button = ToolButton('exposure') self._exposure_button.set_palette(ScalePalette('Exposure',\ v4l2.V4L2_CID_EXPOSURE)) self._exposure_button.connect('clicked', self.__button_clicked_cb) self._live_toolbar_container.add(self._exposure_button) self._exposure_button.show() if self._check_available_control(v4l2.V4L2_CID_GAIN): self._gain_button = ToolButton('gain') self._gain_button.set_palette(ScalePalette('Gain',\ v4l2.V4L2_CID_GAIN, self._check_available_control(v4l2.V4L2_CID_AUTOGAIN))) self._gain_button.connect('clicked', self.__button_clicked_cb) advanced_toolbar.insert(self._gain_button, -1) self._gain_button.show() if self._check_available_control(v4l2.V4L2_CID_BRIGHTNESS): self._brightness_button = ToolButton('brightness') self._brightness_button.set_palette(ScalePalette('Brightness',\ v4l2.V4L2_CID_BRIGHTNESS, self._check_available_control( v4l2.V4L2_CID_AUTOBRIGHTNESS))) self._brightness_button.connect('clicked', self.__button_clicked_cb) self._live_toolbar_container.add(self._brightness_button) self._brightness_button.show() if self._check_available_control(v4l2.V4L2_CID_CONTRAST): self._contrast_button = ToolButton('contrast') self._contrast_button.set_palette(ScalePalette('Contrast',\ v4l2.V4L2_CID_CONTRAST)) self._contrast_button.connect('clicked', self.__button_clicked_cb) self._live_toolbar_container.add(self._contrast_button) self._contrast_button.show() if self._check_available_control(v4l2.V4L2_CID_SATURATION): self._saturation_button = ToolButton('saturation') self._saturation_button.set_palette(ScalePalette('Saturation',\ v4l2.V4L2_CID_SATURATION)) self._saturation_button.connect('clicked', self.__button_clicked_cb) advanced_toolbar.insert(self._saturation_button, -1) self._saturation_button.show() if self._check_available_control( v4l2.V4L2_CID_WHITE_BALANCE_TEMPERATURE): self._white_balance_button = ToolButton('white_balance') self._white_balance_button.set_palette(ScalePalette('White' ' balance', v4l2.V4L2_CID_WHITE_BALANCE_TEMPERATURE, self._check_available_control( v4l2.V4L2_CID_AUTO_WHITE_BALANCE))) self._white_balance_button.connect('clicked', self.__button_clicked_cb) advanced_toolbar.insert(self._white_balance_button, -1) self._white_balance_button.show() if self._check_available_control(v4l2.V4L2_CID_HUE): self._color_tone_button = ToolButton('color_tone') self._color_tone_button.set_palette(ScalePalette('Color' ' tone', v4l2.V4L2_CID_HUE, self._check_available_control( v4l2.V4L2_CID_HUE_AUTO))) self._color_tone_button.connect('clicked', self.__button_clicked_cb) advanced_toolbar.insert(self._color_tone_button, -1) self._color_tone_button.show() #if self._check_available_control(v4l2.V4L2_CID_NIGHT_MODE): # self._night_mode_button = ToolButton('night_mode') # self._night_mode_button.set_palette(ScalePalette('Night mode',\ # v4l2.V4L2_CID_NIGHT_MODE)) # self._night_mode_button.connect('clicked', # self.__button_clicked_cb) # self._live_toolbar_container.add(self._night_mode_button) # self._night_mode_button.show() self._previous_image = ToolButton('go-previous-paired') self._previous_image.label = _('Previous image') self._previous_image.connect('clicked', self.__previous_image_clicked_cb) self._preview_toolbar_container.add(self._previous_image) self._previous_image.show() self._next_image = ToolButton('go-next-paired') self._next_image.label = _('Next image') self._next_image.connect('clicked', self.__next_image_clicked_cb) self._preview_toolbar_container.add(self._next_image) self._next_image.show() self._image_name_entry = gtk.Entry() self._image_name_entry.set_text('') self._image_name_entry.set_size_request(400, -1) self._image_name_entry.connect('activate', self.__image_name_entry_activated_cb) self._preview_toolbar_container.add(self._image_name_entry) self._image_name_entry.show() self._save_to_journal = ToolButton('save_to_journal') self._save_to_journal.label = _('Save to journal') self._save_to_journal.connect('clicked', self.__save_to_journal_clicked_cb) self._preview_toolbar_container.add(self._save_to_journal) self._save_to_journal.show() self._trash = ToolButton('trash') self._trash.label = _('Delete') self._trash.connect('clicked', self.__trash_clicked_cb) self._preview_toolbar_container.add(self._trash) self._trash.show() separator = gtk.SeparatorToolItem() separator.props.draw = False separator.set_expand(True) self._controls_toolbar.insert(separator, -1) separator.show() self._mode_button = ToolButton('%s_mode' % self._mode) self._mode_button.props.label = _('Mode') self._mode_button.connect('clicked', self.__switch_modes_cb) self._controls_toolbar.insert(self._mode_button, -1) self._mode_button.show() if not OLD_TOOLBAR: separator = gtk.SeparatorToolItem() separator.props.draw = True separator.set_expand(False) self._controls_toolbar.insert(separator, -1) separator.show() activity_stop = StopButton(self) toolbar_box.toolbar.insert(activity_stop, -1) activity_stop.show() self._preview_toolitem.add(self._preview_toolbar_container) self._live_toolitem.add(self._live_toolbar_container) self._preview_toolbar_container.show() self._live_toolbar_container.show() if self._mode == 'preview': self._controls_toolbar.insert(self._preview_toolitem, 1) self._preview_toolitem.show() else: self._controls_toolbar.insert(self._live_toolitem, 1) self._live_toolitem.show() self._mode = 'live' self._controls_toolbar.show() activity_toolbar.show() self._main_view = gtk.HBox() self._movie_window = gtk.DrawingArea() self._movie_window.connect('realize', self.__movie_window_realize_cb) self._movie_window.unset_flags(gtk.DOUBLE_BUFFERED) self._movie_window.set_flags(gtk.APP_PAINTABLE) self._main_view.add(self._movie_window) self._preview_frame = gtk.AspectFrame(None, 0.5, 0.5, 1, True) self._preview_window = gtk.Image() self._preview_frame.add(self._preview_window) self._preview_window.connect('size_allocate', self.__preview_window_size_allocate_cb) self.xoscope = gst.Pipeline('xoscope_pipe') camsrc = gst.element_factory_make('v4l2src', 'camsrc') caps = gst.Caps('video/x-raw-yuv') filt = gst.element_factory_make('capsfilter', 'filter') filt.set_property('caps', caps) ffmpegcolorspace = gst.element_factory_make('ffmpegcolorspace', 'ffmpegcolorspace') self._disp_sink = gst.element_factory_make('xvimagesink', 'disp_sink') # http://thread.gmane.org/gmane.comp.video.gstreamer.devel/29644 self._disp_sink.set_property('sync', False) self.image_sink = gst.element_factory_make('fakesink', 'image_sink') self.image_sink.set_property('silent', True) tee = gst.element_factory_make('tee', 'tee') queue = gst.element_factory_make('queue', 'dispqueue') queue.set_property('leaky', True) queue.set_property('max-size-buffers', 20) queue2 = gst.element_factory_make('queue', 'imagequeue') queue2.set_property('leaky', True) queue2.set_property('max-size-buffers', 20) self._zoom_element = gst.element_factory_make('videobox', 'zoombox') jpeg = gst.element_factory_make('jpegenc', 'pbjpeg') jpeg.set_property('quality', 100) self.xoscope.add(camsrc, filt, ffmpegcolorspace,\ self._zoom_element, self._disp_sink, tee, queue, queue2,\ self.image_sink, jpeg) gst.element_link_many(camsrc, filt, self._zoom_element,\ ffmpegcolorspace, tee, queue, self._disp_sink) gst.element_link_many(tee, queue2, jpeg, self.image_sink) bus = self.xoscope.get_bus() bus.add_signal_watch() bus.enable_sync_message_emission() bus.connect('message', self.__on_message_cb) bus.connect('sync-message::element', self.__on_sync_message_cb) self._main_view.show() self._movie_window.show() self.set_canvas(self._main_view) # If we start playing without a delay, the live view window # doesn't get attached to the main canvas properly (This is # a problem on slow computers like xo1). gobject.timeout_add(2000, self.__start_live_view)
def _setup_toolbars(self): ''' Setup the toolbars.. ''' # no sharing self.max_participants = 1 if _HAVE_TOOLBOX: toolbox = ToolbarBox() # Activity toolbar activity_button = ActivityToolbarButton(self) toolbox.toolbar.insert(activity_button, 0) activity_button.show() lesson_toolbar = gtk.Toolbar() lesson_toolbar_button = ToolbarButton(label=_('Select a lesson'), page=lesson_toolbar, icon_name='text-x-generic') record_toolbar = gtk.Toolbar() record_toolbar_button = ToolbarButton(label=_('Record a sound'), page=record_toolbar, icon_name='media-audio') self.set_toolbar_box(toolbox) toolbox.show() lesson_toolbar_button.show() toolbox.toolbar.insert(lesson_toolbar_button, -1) record_toolbar_button.show() toolbox.toolbar.insert(record_toolbar_button, -1) primary_toolbar = toolbox.toolbar else: # Use pre-0.86 toolbar design primary_toolbar = gtk.Toolbar() lesson_toolbar = gtk.Toolbar() record_toolbar = gtk.Toolbar() toolbox = activity.ActivityToolbox(self) self.set_toolbox(toolbox) toolbox.add_toolbar(_('Page'), primary_toolbar) toolbox.show() toolbox.add_toolbar(_('Lesson'), lesson_toolbar) toolbox.show() toolbox.add_toolbar(_('Record'), record_toolbar) toolbox.show() toolbox.set_current_toolbar(1) # no sharing if hasattr(toolbox, 'share'): toolbox.share.hide() elif hasattr(toolbox, 'props'): toolbox.props.visible = False _label_factory(_('Select a lesson') + ':', lesson_toolbar) self._levels = self._get_levels(self._lessons_path) self._levels_combo = _combo_factory(self._levels, _('Select a lesson'), lesson_toolbar, self._levels_cb) _separator_factory(lesson_toolbar) self._lesson_button = _button_factory( 'load-from-journal', _('Load a new lesson from the Journal'), self._lesson_cb, lesson_toolbar) _separator_factory(lesson_toolbar) self._create_lesson_button = _button_factory('view-source-insensitive', _('Create a new lesson'), self._create_lesson_cb, lesson_toolbar) self._save_lesson_button = _button_factory( 'save-to-journal-insensitive', _('Nothing to save'), self._save_lesson_cb, lesson_toolbar) self._sounds = self._get_sounds() self.sounds_combo = _combo_factory(self._sounds, _('Record a sound'), record_toolbar, self._sounds_cb) _separator_factory(record_toolbar) _label_factory(_('Record a sound') + ':', record_toolbar) self._record_lesson_button = _button_factory('media-record', _('Start recording'), self._record_lesson_cb, record_toolbar) _separator_factory(record_toolbar) self._playback_button = _button_factory( 'media-playback-start-insensitive', _('Nothing to play'), self._playback_recording_cb, record_toolbar) self._save_recording_button = _button_factory('sound-save-insensitive', _('Nothing to save'), self._save_recording_cb, record_toolbar) _separator_factory(primary_toolbar) self._list_button = _button_factory('letter-list', _('Letter list'), self._list_cb, primary_toolbar) self._prev_page_button = _button_factory('previous-letter-insensitive', _('Previous letter'), self._prev_page_cb, primary_toolbar) self._next_page_button = _button_factory('next-letter', _('Next letter'), self._next_page_cb, primary_toolbar) _separator_factory(primary_toolbar) self._read_button = _button_factory('read', _('Read the sounds one at a time'), self._read_cb, primary_toolbar) _separator_factory(primary_toolbar) self._test_button = _button_factory('go-right', _('Self test'), self._test_cb, primary_toolbar) self.status = _label_factory('', primary_toolbar) if _HAVE_TOOLBOX: _separator_factory(toolbox.toolbar, False, True) stop_button = StopButton(self) stop_button.props.accelerator = '<Ctrl>q' toolbox.toolbar.insert(stop_button, -1) stop_button.show() lesson_toolbar.show() record_toolbar.show()
def _setup_toolbars(self): ''' Setup the toolbars. ''' self.max_participants = 1 # no sharing if HAVE_TOOLBOX: toolbox = ToolbarBox() # Activity toolbar activity_button = ActivityToolbarButton(self) toolbox.toolbar.insert(activity_button, 0) activity_button.show() self.set_toolbar_box(toolbox) toolbox.show() self.toolbar = toolbox.toolbar adjust_toolbar = gtk.Toolbar() adjust_toolbar_button = ToolbarButton( label=_('Adjust'), page=adjust_toolbar, icon_name='preferences-system') adjust_toolbar.show_all() adjust_toolbar_button.show() else: # Use pre-0.86 toolbar design primary_toolbar = gtk.Toolbar() toolbox = activity.ActivityToolbox(self) self.set_toolbox(toolbox) toolbox.add_toolbar(_('Page'), primary_toolbar) adjust_toolbar = gtk.Toolbar() toolbox.add_toolbar(_('Adjust'), adjust_toolbar) toolbox.show() toolbox.set_current_toolbar(1) self.toolbar = primary_toolbar self._prev_button = button_factory('go-previous-inactive', _('Prev slide'), self._prev_cb, self.toolbar, accelerator='<Ctrl>P') self._next_button = button_factory('go-next', _('Next slide'), self._next_cb, self.toolbar, accelerator='<Ctrl>N') separator_factory(self.toolbar) self._auto_button = button_factory('media-playlist-repeat', _('Autoplay'), self._autoplay_cb, self.toolbar) if HAVE_TOOLBOX: toolbox.toolbar.insert(adjust_toolbar_button, -1) label = label_factory(_('Adjust playback speed'), adjust_toolbar) label.show() self._unit_combo = combo_factory(UNITS, TEN, _('Adjust playback speed'), self._unit_combo_cb, adjust_toolbar) self._unit_combo.show() separator_factory(self.toolbar) self._thumb_button = button_factory('thumbs-view', _('Thumbnail view'), self._thumbs_cb, self.toolbar) button_factory('view-fullscreen', _('Fullscreen'), self.do_fullscreen_cb, self.toolbar, accelerator='<Alt>Return') separator_factory(self.toolbar) self._save_button = button_factory('save-as-html', _('Save as HTML'), self._save_as_html_cb, self.toolbar) if HAVE_TOOLBOX: separator_factory(toolbox.toolbar, False, True) stop_button = StopButton(self) stop_button.props.accelerator = '<Ctrl>q' toolbox.toolbar.insert(stop_button, -1) stop_button.show()
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)
import gtk from sugar.graphics.toolbutton import ToolButton from sugar.graphics.toolbarbox import ToolbarBox, ToolbarButton from sugar.graphics import style window = gtk.Window() box = gtk.VBox() window.add(box) toolbar = ToolbarBox() box.pack_start(toolbar, False) tollbarbutton_1 = ToolbarButton( page=gtk.Button('sub-widget #1'), icon_name='computer-xo') toolbar.toolbar.insert(tollbarbutton_1, -1) tollbarbutton_2 = ToolbarButton( page=gtk.Button('sub-widget #2'), icon_name='button_cancel', tooltip='with custom palette instead of sub-widget') toolbar.toolbar.insert(tollbarbutton_2, -1) toolbar.toolbar.insert(gtk.SeparatorToolItem(), -1) def del_cb(widget): toolbar.toolbar.remove(tollbarbutton_3) del_b = gtk.Button('delete sub-widget #3')
def append(icon_name, label, page, position): toolbar_button = ToolbarButton() toolbar_button.props.page = page toolbar_button.props.icon_name = icon_name toolbar_button.props.label = label self._toolbar_box.toolbar.insert(toolbar_button, position)
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)
def __init__(self, handle): activity.Activity.__init__(self, handle) self.props.max_participants = 1 self._web_view = Browser() try: from sugar.graphics.toolbarbox import ToolbarBox, ToolbarButton from sugar.activity.widgets import ActivityToolbarButton, StopButton, \ ShareButton from mybutton import MyActivityToolbarButton toolbar_box = ToolbarBox() activity_button = MyActivityToolbarButton(self) toolbar_box.toolbar.insert(activity_button, 0) activity_button.show() viewtoolbar = ViewToolbar(self) viewbutton = ToolbarButton(page=viewtoolbar, \ icon_name='camera') toolbar_box.toolbar.insert(viewbutton, -1) viewbutton.show() separator = gtk.SeparatorToolItem() #separator.props.draw = False #separator.set_expand(True) toolbar_box.toolbar.insert(separator, -1) separator.show() #lets reuse the code below navtoolbar = Toolbar(self._web_view) toolitem = gtk.ToolItem() navtoolbar._home.reparent(toolitem) toolbar_box.toolbar.insert(toolitem, -1) navtoolbar._home.show() toolitem.show() toolitem = gtk.ToolItem() navtoolbar._back.reparent(toolitem) toolbar_box.toolbar.insert(toolitem, -1) navtoolbar._back.show() toolitem.show() toolitem = gtk.ToolItem() navtoolbar._forward.reparent(toolitem) toolbar_box.toolbar.insert(toolitem, -1) navtoolbar._forward.show() toolitem.show() # we do not have collaboration features # make the share option insensitive self.max_participants = 1 separator = gtk.SeparatorToolItem() separator.props.draw = False separator.set_expand(True) toolbar_box.toolbar.insert(separator, -1) separator.show() stop_button = StopButton(self) stop_button.props.accelerator = '<Ctrl><Shift>Q' toolbar_box.toolbar.insert(stop_button, -1) stop_button.show() self.set_toolbar_box(toolbar_box) toolbar_box.show() except ImportError: toolbox = activity.ActivityToolbox(self) self.set_toolbox(toolbox) toolbox.show() toolbar = Toolbar(self._web_view) toolbox.add_toolbar(_('Navigation'), toolbar) toolbar.show() viewtoolbar = ViewToolbar(self) toolbox.add_toolbar(_('View'), viewtoolbar) viewtoolbar.show() toolbox.set_current_toolbar(1) self.set_canvas(self._web_view) self._web_view.show() self._web_view.load_uri(HOME)
def __init__(self, handle): """ Init canvas, toolbars, etc. The toolbars are in toolbar_top.py and toolbar_side.py The audio controls are in audiograb.py The rendering happens in drawwaveform.py Logging (Journal interactions) are in journal.py """ activity.Activity.__init__(self, handle) try: tmp_dir = path.join(activity.get_activity_root(), "data") except AttributeError: # Early versions of Sugar (e.g., 656) didn't support # get_activity_root() tmp_dir = path.join( environ['HOME'], ".sugar/default/org.laptop.MeasureActivity/data") self.using_gconf = _using_gconf 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.active_status = True self.ACTIVE = True self.LOGGING_IN_SESSION = False self.CONTEXT = '' self.adjustmentf = None # Freq. slider control self.connect('notify::active', self._active_cb) self.connect('destroy', self.on_quit) self.hw = _get_hardware() self.closedSound = None self.openedSound = None self.session_id = 0 self.ji = JournalInteraction(self) colorBlack = Color() colorBlack.init_rgba(0, 0, 0, 255) self.playsoundWin = PlayVideoWindow(colorBlack.gColor) self.playsound = Gplay() self.playsound.window = self.playsoundWin self.wave = DrawWaveform(self, self.playsound) self.hw = _get_hardware() log.debug('running on %s hardware' % (self.hw)) if self.hw == XO15: self.audiograb = AudioGrab_XO15(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 self.has_toolbarbox = _has_toolbarbox self.side_toolbar = SideToolbar(self) self.text_box = TextBox() self.box3 = gtk.HBox(False, 0) self.box3.pack_start(self.wave, True, True, 0) self.box3.pack_start(self.side_toolbar.box1, False, True, 0) self.box1 = gtk.VBox(False, 0) self.box1.pack_start(self.box3, True, True, 0) self.box1.pack_start(self.text_box.box_main, False, True, 0) self.set_canvas(self.box1) self.toolbox = None if self.has_toolbarbox: toolbox = ToolbarBox() self.toolbox = toolbox activity_button = ActivityToolbarButton(self) toolbox.toolbar.insert(activity_button, 0) activity_button.show() else: toolbox = ActivityToolbox(self) self.toolbox = toolbox # no sharing if hasattr(toolbox, 'share'): toolbox.share.hide() elif hasattr(toolbox, 'props'): toolbox.props.visible = False self.set_toolbox(toolbox) toolbox.connect('current-toolbar-changed', self._toolbar_changed_cb) self.sound_toolbar = SoundToolbar(self) if self.has_toolbarbox: self._sound_button = ToolbarButton(label=_('Sound'), page=self.sound_toolbar, icon_name='sound-tools') toolbox.toolbar.insert(self._sound_button, -1) self._sound_button.show() else: toolbox.add_toolbar(_('Sound'), self.sound_toolbar) self.sound_toolbar.show() if _is_xo(self.hw): self.sensor_toolbar = SensorToolbar(self) if self.has_toolbarbox: self._sensor_button = ToolbarButton(label=_('Sensors'), page=self.sensor_toolbar, icon_name='sensor-tools') toolbox.toolbar.insert(self._sensor_button, -1) self._sensor_button.show() else: toolbox.add_toolbar(_('Sensors'), self.sensor_toolbar) self.sensor_toolbar.show() if self.has_toolbarbox: _separator = gtk.SeparatorToolItem() _separator.props.draw = False toolbox.toolbar.insert(_separator, -1) _separator.show() # add a "dummy" button to indicate what capture mode we are in self.label_button = ToolButton('domain-time2') toolbox.toolbar.insert(self.label_button, -1) self.label_button.show() self.label_button.set_tooltip(_('Time Base')) self.label_button.connect('clicked', self._label_cb) self.sound_toolbar.add_frequency_slider(toolbox.toolbar) _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) self._sound_button.set_expanded(True) else: toolbox.set_current_toolbar(TOOLBARS.index('sensor')) toolbox.show() self.sound_toolbar.update_page_size() self.show_all() self.first = True self.set_sound_context() self.set_sensor_context() self.set_show_hide_windows() self.wave.set_active(True) self.wave.set_context_on() self.set_show_hide_windows()