def update_instrument_control(self, *args):
''' Callback for instrument control '''
instrument = self.instrument[self.instrument_combo.get_active()]
if self._tuning_tool is not None:
self.remove(self._tuning_tool)
if instrument == _('None'):
self.activity.wave.instrument = None
if hasattr(self, '_notes_tool'):
self.insert(self._notes_tool, 2)
return
self.remove(self._notes_tool)
self.activity.wave.instrument = instrument
# If we are not already in freq. base, switch.
if not self.activity.wave.get_fft_mode():
self.activity.timefreq_control()
# Add a Tuning Combo box for this instrument
self._tuning_combo = ComboBox()
self.tuning = [_('All notes')]
for f in INSTRUMENT_DICT[instrument]:
self.tuning.append(freq_note(f))
self._tuning_changed_id = self._tuning_combo.connect(
'changed', self.update_tuning_control)
for i, s in enumerate(self.tuning):
self._tuning_combo.append_item(i, s, None)
self._tuning_combo.set_active(0)
if hasattr(self._tuning_combo, 'set_tooltip_text'):
self._tuning_combo.set_tooltip_text(instrument)
self._tuning_tool = ToolComboBox(self._tuning_combo)
self.insert(self._tuning_tool, 1)
self._tuning_combo.show()
self._tuning_tool.show()
self.show_all()
class InstrumentToolbar(gtk.Toolbar):
''' The toolbar for adding new instruments '''
def __init__(self, activity):
gtk.Toolbar.__init__(self)
self.activity = activity
self.new_instruments = []
self._name_entry = gtk.Entry()
self._name_entry.set_text(_('my instrument'))
self._name_entry_changed_id = self._name_entry.connect(
'changed', self.update_name_entry)
if hasattr(self._name_entry, 'set_tooltip_text'):
self._name_entry.set_tooltip_text(_('Enter instrument name.'))
self._name_entry.set_width_chars(24)
self._name_entry.show()
toolitem = gtk.ToolItem()
toolitem.add(self._name_entry)
self.insert(toolitem, -1)
toolitem.show()
self._notes_combo = ComboBox()
n = 0
for octave in range(9):
for i in range(len(NOTES)):
if octave == 0 and i < 9: # Start with A0
continue
self._notes_combo.append_item(n, note_octave(i, octave), None)
n += 1
self._notes_combo.set_active(48) # A4
if hasattr(self._notes_combo, 'set_tooltip_text'):
self._notes_combo.set_tooltip_text(_('Notes'))
self._notes_tool = ToolComboBox(self._notes_combo)
self.insert(self._notes_tool, -1)
self._notes_tool.show()
self._new_note = ToolButton('list-add')
self._new_note.show()
self.insert(self._new_note, -1)
self._new_note.set_tooltip(_('Add a new note.'))
self._new_note.connect('clicked', self.new_note_cb)
def update_name_entry(self, *args):
''' Add name to INSTRUMENT_DICT and combo box '''
# Wait until a note has been added...
return
def new_note_cb(self, *args):
''' Add a new note to instrument tuning list '''
name = self._name_entry.get_text()
if name not in INSTRUMENT_DICT:
INSTRUMENT_DICT[name] = []
self.activity.tuning_toolbar.instrument.append(name)
i = len(self.activity.tuning_toolbar.instrument)
self.activity.tuning_toolbar.instrument_combo.append_item(
i, name, None)
self.new_instruments.append(name)
i = self._notes_combo.get_active()
freq = A0 * pow(TWELTHROOT2, i)
if freq not in INSTRUMENT_DICT[name]:
INSTRUMENT_DICT[name].append(freq)
def __init__(self, activity):
gtk.Toolbar.__init__(self)
voicebar = gtk.Toolbar()
self._activity = activity
if not speech.supported:
return
self.load_speech_parameters()
self.sorted_voices = [i for i in speech.voices()]
self.sorted_voices.sort(self.compare_voices)
default = 0
for voice in self.sorted_voices:
if voice[0] == speech.voice[0]:
break
default = default + 1
# Play button
self.play_btn = ToggleToolButton('media-playback-start')
self.play_btn.show()
self.play_btn.connect('toggled', self.play_cb)
self.insert(self.play_btn, -1)
self.play_btn.set_tooltip(_('Play / Pause'))
self.voice_combo = ComboBox()
for voice in self.sorted_voices:
self.voice_combo.append_item(voice, voice[0])
self.voice_combo.set_active(default)
self.voice_combo.connect('changed', self.voice_changed_cb)
combotool = ToolComboBox(self.voice_combo)
self.insert(combotool, -1)
combotool.show()
self.pitchadj = gtk.Adjustment(0, -100, 100, 1, 10, 0)
pitchbar = gtk.HScale(self.pitchadj)
pitchbar.set_draw_value(False)
pitchbar.set_update_policy(gtk.UPDATE_DISCONTINUOUS)
pitchbar.set_size_request(150, 15)
self.pitchadj.set_value(speech.pitch)
pitchtool = gtk.ToolItem()
pitchtool.add(pitchbar)
pitchtool.show()
self.insert(pitchtool, -1)
pitchbar.show()
self.rateadj = gtk.Adjustment(0, -100, 100, 1, 10, 0)
ratebar = gtk.HScale(self.rateadj)
ratebar.set_draw_value(False)
ratebar.set_update_policy(gtk.UPDATE_DISCONTINUOUS)
ratebar.set_size_request(150, 15)
self.rateadj.set_value(speech.rate)
ratetool = gtk.ToolItem()
ratetool.add(ratebar)
ratetool.show()
self.insert(ratetool, -1)
ratebar.show()
self.pitchadj.connect("value_changed", self.pitch_adjusted_cb)
self.rateadj.connect("value_changed", self.rate_adjusted_cb)
def load_toolbar(self):
self.context = self.emit("load-pango-context")
self.family_combo = ComboBox()
family_renderer = gtk.CellRendererText()
family_renderer.set_property("family-set", True)
self.family_combo.pack_start(family_renderer)
self.family_combo.add_attribute(family_renderer, 'text', 0)
self.family_combo.add_attribute(family_renderer, 'family', 0)
self.family_model = gtk.ListStore(str)
monospace_index = 0
count = 0
self.faces = {}
for i in self.context.list_families():
name = i.get_name()
monospace_index = count if name == "Monospace" else 0
count += 1
self.family_model.append([name])
family_faces = gtk.ListStore(str, str)
for face in i.list_faces():
face_name = face.get_face_name()
family_faces.append([face_name, "%s %s" % (name, face_name)])
self.faces[name] = family_faces
self.family_combo.set_model(self.family_model)
self.family_combo.set_active(monospace_index)
self.family_combo.connect("changed", self.family_changed)
self.family_combo.show()
self.family_tool_item = ToolComboBox(self.family_combo)
self.family_tool_item.show()
self.toolbar.insert(self.family_tool_item, -1)
self.face_combo = ComboBox()
face_renderer = gtk.CellRendererText()
face_renderer.set_property("family-set", True)
self.face_combo.pack_start(face_renderer)
self.face_combo.add_attribute(face_renderer, 'text', 0)
self.face_combo.add_attribute(face_renderer, 'font', 1)
current_model = self.faces["Monospace"]
self.face_combo.set_model(current_model)
self.face_combo.set_active(0)
self.face_combo.connect("changed", self.face_changed)
self.face_combo.show()
self.face_tool_item = ToolComboBox(self.face_combo)
self.face_tool_item.show()
self.toolbar.insert(self.face_tool_item, -1)
self.size_adj = gtk.Adjustment(value=10,
lower=5,
upper=100,
step_incr=1)
self.size_adj.connect("value-changed", self.size_changed)
self.size_spin = gtk.SpinButton(self.size_adj)
self.size_spin.show()
self.size_spin_item = gtk.ToolItem()
self.size_spin_item.add(self.size_spin)
self.size_spin_item.show()
self.toolbar.insert(self.size_spin_item, -1)
self.toolbar.show()
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 _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, abiword_canvas):
gtk.Toolbar.__init__(self)
font_name = ToolComboBox(FontCombo(abiword_canvas))
self.insert(font_name, -1)
font_size = ToolComboBox(FontSizeCombo(abiword_canvas))
self.insert(font_size, -1)
# MAGIC NUMBER WARNING: Secondary toolbars are not a standard height?
self.set_size_request(-1, style.GRID_CELL_SIZE)
self.show_all()
def _combo_factory(options, tooltip, toolbar, callback, default=0):
''' Combo box factory '''
combo = ComboBox()
if hasattr(combo, 'set_tooltip_text'):
combo.set_tooltip_text(tooltip)
combo.connect('changed', callback)
for i, option in enumerate(options):
combo.append_item(i, option.replace('-', ' '), None)
combo.set_active(default)
combo.show()
tool = ToolComboBox(combo)
tool.show()
toolbar.insert(tool, -1)
return combo
def __init__(self, toolbox, abiword_canvas, parent):
gtk.Toolbar.__init__(self)
self._toolbox = toolbox
self._abiword_canvas = abiword_canvas
self._parent = parent
style_label = gtk.Label(_("Style: "))
style_label.show()
tool_item_style_label = gtk.ToolItem()
tool_item_style_label.add(style_label)
self.insert(tool_item_style_label, -1)
tool_item_style_label.show()
self._has_custom_styles = False
self._style_combo = ComboBox()
self._styles = [['Heading 1', _('Heading 1')],
['Heading 2', _('Heading 2')],
['Heading 3', _('Heading 3')],
['Heading 4', _('Heading 4')],
['Bullet List', _('Bullet List')],
['Dashed List', _('Dashed List')],
['Numbered List', _('Numbered List')],
['Lower Case List',
_('Lower Case List')],
['Upper Case List',
_('Upper Case List')],
['Block Text',
_('Block Text')], ['Normal', _('Normal')],
['Plain Text', _('Plain Text')]]
self._style_changed_id = self._style_combo.connect(
'changed', self._style_changed_cb)
for i, s in enumerate(self._styles):
self._style_combo.append_item(i, s[1], None)
if s[0] == 'Normal':
self._style_combo.set_active(i)
tool_item = ToolComboBox(self._style_combo)
self.insert(tool_item, -1)
tool_item.show()
self._abiword_canvas.connect('style-name', self._style_cb)
####btn salir del barrido del menu item
self._btn_barrido_menu = ToolButton()
self._btn_barrido_menu.set_tooltip(_('Salir \nMenú'))
self._btn_barrido_menu_id = self._btn_barrido_menu.connect(
'clicked', self._btn_barrido_menu_cb)
self.insert(self._btn_barrido_menu, -1)
self._btn_barrido_menu.set_no_show_all(True)
def __init__(self, activity):
gtk.Toolbar.__init__(self)
self.activity = activity
# Reset Button
restart_icon = join(dirname(__file__), 'images', 'gtk-refresh.svg')
restart_image = gtk.Image()
restart_image.set_from_file(restart_icon)
self._restart_button = ToolButton()
self._restart_button.set_icon_widget(restart_image)
self._restart_button.connect('clicked', self._game_restart_cb)
self._restart_button.set_tooltip(_('Restart Game'))
self.insert(self._restart_button, -1)
self._restart_button.show()
# Separator
separator = gtk.SeparatorToolItem()
separator.set_draw(True)
self.insert(separator, -1)
self._add_widget(gtk.Label(_('Board size') + ': '))
# Change size combobox
self._size_combo = ToolComboBox()
self._sizes = ['19 X 19', '13 X 13', '9 X 9']
for i, f in enumerate(self._sizes):
self._size_combo.combo.append_item(i, f)
self._size_combo.combo.connect('changed', self._game_size_cb)
self._add_widget(self._size_combo)
self._size_combo.combo.set_active(0)
# Separator
separator = gtk.SeparatorToolItem()
separator.set_draw(True)
self.insert(separator, -1)
# Artificial Intelligence Button
self._ai_button = gtk.ToggleToolButton()
if search_for_gnugo():
self._ai_button.connect('toggled', self._ai_toggled_cb)
self._ai_button.set_label(_('Play against PlayGo!'))
else:
self._ai_button.set_label(
_('You need to install gnugo to play against PlayGo'))
self._ai_button.set_sensitive(False)
self.insert(self._ai_button, -1)
self._ai_button.show()
def create_toolbar(self):
"""
This function creates the game toolbar
"""
toolbar_box = ToolbarBox()
self.set_toolbar_box(toolbar_box)
toolbar_box.toolbar.insert(ActivityToolbarButton(self), -1)
separator = gtk.SeparatorToolItem()
separator.props.draw = False
toolbar_box.toolbar.insert(separator, -1)
scoreButton = ScoreButton(self)
toolbar_box.toolbar.insert(scoreButton, -1)
separator = gtk.SeparatorToolItem()
separator.props.draw = False
toolbar_box.toolbar.insert(separator, -1)
self._modes = ToolComboBox()
self._modelist = ['Select Mode', '+ Addition', '- Subtraction']
for i, f in enumerate(self._modelist):
self._modes.combo.append_item(i, f)
self.modes_handle_id = self._modes.combo.connect("changed", self._change_modes_toolbar)
toolbar_box.toolbar.insert(self._modes, -1)
self._modes.combo.set_active(0)
separator = gtk.SeparatorToolItem()
separator.props.draw = False
toolbar_box.toolbar.insert(separator, -1)
scorestats = VisualScore(self)
toolbar_box.toolbar.insert(scorestats, -1)
separator = gtk.SeparatorToolItem()
separator.props.draw = False
toolbar_box.toolbar.insert(separator, -1)
separator = gtk.SeparatorToolItem()
separator.props.draw = False
toolbar_box.toolbar.insert(separator, -1)
timestats = VisualTime(self)
toolbar_box.toolbar.insert(timestats, -1)
separator = gtk.SeparatorToolItem()
separator.props.draw = False
toolbar_box.toolbar.insert(separator, -1)
separator = gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
toolbar_box.toolbar.insert(separator, -1)
stopButton = StopButton(self)
toolbar_box.toolbar.insert(stopButton, -1)
toolbar_box.show_all()
def combo_factory(combo_array, default, tooltip, callback, toolbar):
'''Factory for making a toolbar combo box'''
my_combo = ComboBox()
if hasattr(my_combo, 'set_tooltip_text'):
my_combo.set_tooltip_text(tooltip)
my_combo.connect('changed', callback)
for i, s in enumerate(combo_array):
my_combo.append_item(i, s, None)
tool = ToolComboBox(my_combo)
if hasattr(toolbar, 'insert'): # the main toolbar
toolbar.insert(tool, -1)
else: # or a secondary toolbar
toolbar.props.page.insert(tool, -1)
tool.show()
my_combo.set_active(default)
return my_combo
def __init__(self, activity):
gtk.Toolbar.__init__(self)
self._activity = activity
self._updating_share = False
self._focus_out_hid = None
activity.connect('shared', self.__activity_shared_cb)
activity.connect('joined', self.__activity_shared_cb)
activity.connect('notify::max_participants',
self.__max_participants_changed_cb)
if activity.metadata:
self.title = gtk.Entry()
self.title.set_size_request(int(gtk.gdk.screen_width() / 3), -1)
self.title.set_text(activity.metadata['title'])
self._focus_out_hid = self.title.connect('focus-out-event',
self.__title_changed_cb)
self._add_widget(self.title)
activity.metadata.connect('updated', self.__jobject_updated_cb)
separator = gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
self.insert(separator, -1)
separator.show()
self.share = ToolComboBox(label_text=_('Share with:'))
self.share.combo.connect('changed', self.__share_changed_cb)
self.share.combo.append_item(SCOPE_PRIVATE, _('Private'), 'zoom-home')
self.share.combo.append_item(SCOPE_NEIGHBORHOOD, _('My Neighborhood'),
'zoom-neighborhood')
self.insert(self.share, -1)
self.share.show()
self._update_share()
self.keep = ToolButton(tooltip=_('Keep'))
client = gconf.client_get_default()
color = XoColor(client.get_string('/desktop/sugar/user/color'))
keep_icon = Icon(icon_name='document-save', xo_color=color)
self.keep.set_icon_widget(keep_icon)
keep_icon.show()
self.keep.props.accelerator = '<Ctrl>S'
self.keep.connect('clicked', self.__keep_clicked_cb)
self.insert(self.keep, -1)
self.keep.show()
self.stop = ToolButton('activity-stop', tooltip=_('Stop'))
self.stop.props.accelerator = '<Ctrl>Q'
self.stop.connect('clicked', self.__stop_clicked_cb)
self.insert(self.stop, -1)
self.stop.show()
def __init__(self):
gtk.Toolbar.__init__(self)
self._mount_point = None
self._search_entry = iconentry.IconEntry()
self._search_entry.set_icon_from_name(iconentry.ICON_ENTRY_PRIMARY,
'system-search')
self._search_entry.connect('activate', self._search_entry_activated_cb)
self._search_entry.connect('changed', self._search_entry_changed_cb)
self._search_entry.add_clear_button()
self._autosearch_timer = None
self._add_widget(self._search_entry, expand=True)
self._favorite_button = ToggleToolButton('emblem-favorite')
self._favorite_button.connect('toggled',
self.__favorite_button_toggled_cb)
self.insert(self._favorite_button, -1)
self._favorite_button.show()
self._what_search_combo = ComboBox()
self._what_combo_changed_sid = self._what_search_combo.connect(
'changed', self._combo_changed_cb)
tool_item = ToolComboBox(self._what_search_combo)
self.insert(tool_item, -1)
tool_item.show()
self._when_search_combo = self._get_when_search_combo()
tool_item = ToolComboBox(self._when_search_combo)
self.insert(tool_item, -1)
tool_item.show()
self._sorting_button = SortingButton()
self._sorting_button.connect('clicked',
self.__sorting_button_clicked_cb)
self.insert(self._sorting_button, -1)
self._sorting_button.connect('sort-property-changed',
self.__sort_changed_cb)
self._sorting_button.show()
# TODO: enable it when the DS supports saving the buddies.
#self._with_search_combo = self._get_with_search_combo()
#tool_item = ToolComboBox(self._with_search_combo)
#self.insert(tool_item, -1)
#tool_item.show()
self._query = self._build_query()
self.refresh_filters()
def __init__(self, activity):
gtk.Toolbar.__init__(self)
self.activity = activity
self.new_instruments = []
self._name_entry = gtk.Entry()
self._name_entry.set_text(_('my instrument'))
self._name_entry_changed_id = self._name_entry.connect(
'changed', self.update_name_entry)
if hasattr(self._name_entry, 'set_tooltip_text'):
self._name_entry.set_tooltip_text(_('Enter instrument name.'))
self._name_entry.set_width_chars(24)
self._name_entry.show()
toolitem = gtk.ToolItem()
toolitem.add(self._name_entry)
self.insert(toolitem, -1)
toolitem.show()
self._notes_combo = ComboBox()
n = 0
for octave in range(9):
for i in range(len(NOTES)):
if octave == 0 and i < 9: # Start with A0
continue
self._notes_combo.append_item(n, note_octave(i, octave), None)
n += 1
self._notes_combo.set_active(48) # A4
if hasattr(self._notes_combo, 'set_tooltip_text'):
self._notes_combo.set_tooltip_text(_('Notes'))
self._notes_tool = ToolComboBox(self._notes_combo)
self.insert(self._notes_tool, -1)
self._notes_tool.show()
self._new_note = ToolButton('list-add')
self._new_note.show()
self.insert(self._new_note, -1)
self._new_note.set_tooltip(_('Add a new note.'))
self._new_note.connect('clicked', self.new_note_cb)
def __init__(self, owner):
gtk.Toolbar.__init__(self)
self.owner = owner
self.toolItem = {}
self.blockBeat = False
self.beatWheel = []
btn = RadioToolButton(group=None)
btn.set_named_icon('beats')
btn.connect('toggled', self.setBeat, 0)
btn.set_tooltip(_('Jump To Beat'))
self.insert(btn, -1)
self.beatWheel.append(btn)
for i in range(1, 12):
btn = RadioToolButton(group=self.beatWheel[0])
btn.set_named_icon('beats')
btn.connect('toggled', self.setBeat, i)
btn.set_tooltip(_('Jump To Beat'))
self.insert(btn, -1)
self.beatWheel.append(btn)
label = gtk.Label(_("Synch to:"))
self.syncLabel = gtk.ToolItem()
self.syncLabel.add(label)
self.insert(self.syncLabel, 0)
self.comboBox = ComboBox()
self.comboBox.append_item(1, _("1 Beat"))
self.comboBox.append_item(2, _("2 Beats"))
self.comboBox.append_item(3, _("3 Beats"))
self.comboBox.append_item(4, _("4 Beats"))
self.comboBox.append_item(5, _("5 Beats"))
self.comboBox.append_item(6, _("6 Beats"))
self.comboBox.append_item(7, _("7 Beats"))
self.comboBox.append_item(8, _("8 Beats"))
self.comboBox.append_item(9, _("9 Beats"))
self.comboBox.append_item(10, _("10 Beats"))
self.comboBox.append_item(11, _("11 Beats"))
self.comboBox.append_item(12, _("12 Beats"))
self.comboBox.set_active(4 - 1) # default 4 beats
self.comboBox.connect("changed", self.changeSync)
self.syncBox = ToolComboBox(self.comboBox)
self.insert(self.syncBox, 1)
self.show_all()
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 __init__(self, activity):
gtk.Toolbar.__init__(self)
self.activity = activity
# Reset Button
restart_icon = join(dirname(__file__), 'images', 'gtk-refresh.svg')
restart_image = gtk.Image()
restart_image.set_from_file(restart_icon)
self._restart_button = ToolButton()
self._restart_button.set_icon_widget(restart_image)
self._restart_button.connect('clicked', self._game_restart_cb)
self._restart_button.set_tooltip(_('Restart Game'))
self.insert(self._restart_button, -1)
self._restart_button.show()
# Separator
separator = gtk.SeparatorToolItem()
separator.set_draw(True)
self.insert(separator, -1)
self._add_widget(gtk.Label(_('Board size') + ': '))
# Change size combobox
self._size_combo = ToolComboBox()
self._sizes = ['19 X 19', '13 X 13', '9 X 9']
for i, f in enumerate(self._sizes):
self._size_combo.combo.append_item(i, f)
self._size_combo.combo.connect('changed', self._game_size_cb)
self._add_widget(self._size_combo)
self._size_combo.combo.set_active(0)
# Separator
separator = gtk.SeparatorToolItem()
separator.set_draw(True)
self.insert(separator, -1)
# Artificial Intelligence Button
self._ai_button = gtk.ToggleToolButton()
if search_for_gnugo():
self._ai_button.connect('toggled', self._ai_toggled_cb)
self._ai_button.set_label(_('Play against PlayGo!'))
else:
self._ai_button.set_label(_('You need to install gnugo to play against PlayGo'))
self._ai_button.set_sensitive(False)
self.insert(self._ai_button, -1)
self._ai_button.show()
def __init__(self):
gtk.HBox.__init__(self)
self.toolitems = []
readarticle_box = gtk.VBox()
readarticle_box.show()
labeleb = gtk.EventBox()
labeleb.modify_bg(gtk.STATE_NORMAL, gtk.gdk.color_parse("#EEEEEE"))
readarticle_box.pack_start(labeleb, False, False, 0)
labeleb.show()
self.articletitle = gtk.Label()
self.articletitle.set_justify(gtk.JUSTIFY_CENTER)
labeleb.add(self.articletitle)
self.articletitle.show()
vbox = gtk.VBox()
snap = ToolComboBox(label_text=_('Snap selection to:'))
snap.combo.append_item(0, _("Nothing"))
snap.combo.append_item(1, _("Sentences"))
snap.combo.append_item(2, _("Paragraphs"))
snap.combo.append_item(3, _("Sections"))
snap.combo.set_active(1)
vbox.pack_start(snap, False)
"""
Create reading and editing panels
"""
self.readarticle = Reading_View()
self.readarticle.set_size_request(gtk.gdk.screen_width() / 2, -1)
self.readarticle.show()
readarticle_box.pack_start(self.readarticle)
vbox.pack_start(readarticle_box)
self.pack_start(vbox, False)
self.editarticle = Editing_View()
self.pack_start(self.editarticle)
self.editarticle.show()
snap.combo.connect("changed", self.selection_mode_changed, None)
def __init__(self):
gtk.Toolbar.__init__(self)
self._mount_point = None
self._search_entry = iconentry.IconEntry()
self._search_entry.set_icon_from_name(iconentry.ICON_ENTRY_PRIMARY,
'system-search')
self._search_entry.connect('activate', self._search_entry_activated_cb)
self._search_entry.connect('changed', self._search_entry_changed_cb)
self._search_entry.add_clear_button()
self._autosearch_timer = None
self._add_widget(self._search_entry, expand=True)
self._favorite_button = ToggleToolButton('emblem-favorite')
self._favorite_button.connect('toggled',
self.__favorite_button_toggled_cb)
self.insert(self._favorite_button, -1)
self._favorite_button.show()
self._what_search_combo = ComboBox()
self._what_combo_changed_sid = self._what_search_combo.connect(
'changed', self._combo_changed_cb)
tool_item = ToolComboBox(self._what_search_combo)
self.insert(tool_item, -1)
tool_item.show()
self._when_search_combo = self._get_when_search_combo()
tool_item = ToolComboBox(self._when_search_combo)
self.insert(tool_item, -1)
tool_item.show()
self._sorting_button = SortingButton()
self._sorting_button.connect('clicked',
self.__sorting_button_clicked_cb)
self.insert(self._sorting_button, -1)
self._sorting_button.connect('sort-property-changed',
self.__sort_changed_cb)
self._sorting_button.show()
# TODO: enable it when the DS supports saving the buddies.
#self._with_search_combo = self._get_with_search_combo()
#tool_item = ToolComboBox(self._with_search_combo)
#self.insert(tool_item, -1)
#tool_item.show()
self._query = self._build_query()
self.refresh_filters()
class FontToolbarButton(ToolbarButton):
__gsignals__ = {
'load-pango-context':
(gobject.SIGNAL_RUN_LAST, gobject.TYPE_PYOBJECT, tuple()),
'font-changed':
(gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE,
(gobject.TYPE_STRING, gobject.TYPE_STRING, gobject.TYPE_INT))
}
def __init__(self):
ToolbarButton.__init__(self)
self.toolbar = gtk.Toolbar()
self.props.page = self.toolbar
self.props.icon_name = 'format-text'
self.family = "Monospace"
self.current_face = "Regular"
def size_changed(self, adjustment):
self.emit("font-changed", self.family, self.current_face,
adjustment.get_value())
def face_changed(self, widget):
iter = widget.get_active_iter()
self.current_face = self.faces[self.family].get_value(iter, 0)
self.emit('font-changed', self.family, self.current_face,
self.size_adj.get_value())
def family_changed(self, widget):
iter = widget.get_active_iter()
self.family = self.family_model.get_value(iter, 0)
self.face_combo.set_model(self.faces[self.family])
self.face_combo.set_active(0)
def load_toolbar(self):
self.context = self.emit("load-pango-context")
self.family_combo = ComboBox()
family_renderer = gtk.CellRendererText()
family_renderer.set_property("family-set", True)
self.family_combo.pack_start(family_renderer)
self.family_combo.add_attribute(family_renderer, 'text', 0)
self.family_combo.add_attribute(family_renderer, 'family', 0)
self.family_model = gtk.ListStore(str)
monospace_index = 0
count = 0
self.faces = {}
for i in self.context.list_families():
name = i.get_name()
monospace_index = count if name == "Monospace" else 0
count += 1
self.family_model.append([name])
family_faces = gtk.ListStore(str, str)
for face in i.list_faces():
face_name = face.get_face_name()
family_faces.append([face_name, "%s %s" % (name, face_name)])
self.faces[name] = family_faces
self.family_combo.set_model(self.family_model)
self.family_combo.set_active(monospace_index)
self.family_combo.connect("changed", self.family_changed)
self.family_combo.show()
self.family_tool_item = ToolComboBox(self.family_combo)
self.family_tool_item.show()
self.toolbar.insert(self.family_tool_item, -1)
self.face_combo = ComboBox()
face_renderer = gtk.CellRendererText()
face_renderer.set_property("family-set", True)
self.face_combo.pack_start(face_renderer)
self.face_combo.add_attribute(face_renderer, 'text', 0)
self.face_combo.add_attribute(face_renderer, 'font', 1)
current_model = self.faces["Monospace"]
self.face_combo.set_model(current_model)
self.face_combo.set_active(0)
self.face_combo.connect("changed", self.face_changed)
self.face_combo.show()
self.face_tool_item = ToolComboBox(self.face_combo)
self.face_tool_item.show()
self.toolbar.insert(self.face_tool_item, -1)
self.size_adj = gtk.Adjustment(value=10,
lower=5,
upper=100,
step_incr=1)
self.size_adj.connect("value-changed", self.size_changed)
self.size_spin = gtk.SpinButton(self.size_adj)
self.size_spin.show()
self.size_spin_item = gtk.ToolItem()
self.size_spin_item.add(self.size_spin)
self.size_spin_item.show()
self.toolbar.insert(self.size_spin_item, -1)
self.toolbar.show()
def __init__(self, activity, channels):
#Se utiliza para contralar que no se ejecute dos veces
self._butia_context_id = None
gtk.Toolbar.__init__(self)
self.activity = activity
self._channels = channels
self.mode = 'butia'
# Set up Sensores Button
self.time = RadioToolButton(group=None)
# Mantiene la lista de botones (de sensores)
# agregados a la ButiaToolbar
self.lista_sensores_button = []
self.we_are_logging = False
self._log_this_sample = False
self._logging_timer = None
self._logging_counter = 0
self._image_counter = 0
self._logging_interval = 0
self._channels_logged = []
self._busy = False
self._take_screenshot = True
# BUTIA Se detectan sensores
log.debug('se agrega el boton refrescar')
self.refrescar_button = RadioToolButton(group=None)
self.refrescar_button.set_named_icon('recargar')
self.refrescar_button.connect('clicked', self.update_buttons)
self.insert(self.refrescar_button, -1)
separator = gtk.SeparatorToolItem()
separator.props.draw = True
self.insert(separator, -1)
self.detect_sensors()
self.load_buttons()
separator = gtk.SeparatorToolItem()
separator.props.draw = True
self.insert(separator, -1)
self._log_interval_combo = ComboBox()
self.interval = [
_('1/10 second'),
_('1 second'),
_('30 seconds'),
_('5 minutes'),
_('30 minutes')
]
if hasattr(self._log_interval_combo, 'set_tooltip_text'):
self._log_interval_combo.set_tooltip_text(_('Sampling interval'))
self._interval_changed_id = self._log_interval_combo.connect(
'changed', self.log_interval_cb)
for i, s in enumerate(self.interval):
self._log_interval_combo.append_item(i, s, None)
if s == _('1 second'):
self._log_interval_combo.set_active(i)
self._log_interval_tool = ToolComboBox(self._log_interval_combo)
self.insert(self._log_interval_tool, -1)
self.logging_interval_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_cb)
self.show_all()
def __init__(self, activity):
gtk.EventBox.__init__(self)
self.activity = activity
self.wiki = BookView(book.wiki, _('Wiki'), _('Wiki articles'), False)
self.custom = BookView(book.custom, _('Custom'), _('Custom articles'),
True)
# stubs for empty articles
def create_stub(icon_name, head_text, tail_text):
head_label = gtk.Label(head_text)
head_label_a = gtk.Alignment(0.5, 1, 0, 0)
head_label_a.add(head_label)
icon = Icon(icon_name=icon_name,
icon_size=gtk.ICON_SIZE_LARGE_TOOLBAR)
tail_label = gtk.Label(tail_text)
tail_label_a = gtk.Alignment(0.5, 0, 0, 0)
tail_label_a.add(tail_label)
stub = gtk.VBox()
stub.pack_start(head_label_a)
stub.pack_start(icon, False)
stub.pack_start(tail_label_a)
return stub
wiki_stub = create_stub(
'white-search',
_('To download Wiki article\ntype "Article name" and click'),
_('button on the top "Library" panel'))
custom_stub = create_stub('add', _('To create custom article click'),
_('button on the left "Custom" panel'))
# articles viewers
lang_code = locale.getdefaultlocale()[0] or 'en_US'
wiki_prefix = lang_code[0:2] + '.'
language_order = 0
order = 0
search_box = gtk.HBox()
self.wikimenu = ToolComboBox(label_text=_('Get article from:'))
for i in sorted(WIKI.keys()):
self.wikimenu.combo.append_item(WIKI[i], i)
if WIKI[i].startswith(wiki_prefix):
language_order = order
order = order + 1
self.wikimenu.combo.set_active(language_order)
search_box.pack_start(self.wikimenu, False)
self.searchentry = gtk.Entry()
self.searchentry.set_size_request(int(gtk.gdk.screen_width() / 4), -1)
self.searchentry.set_text(_("Article name"))
self.searchentry.select_region(0, -1)
self.searchentry.connect('activate', self._search_activate_cb)
search_box.pack_start(self.searchentry)
search_box.show_all()
self.searchbutton = gtk.Button(label=_('Search'))
self.searchbutton.connect('clicked', self._search_clicked_cb)
search_box.pack_start(self.searchbutton, False)
wiki_widget = Reading_View()
wiki = gtk.Notebook()
wiki.props.show_border = False
wiki.props.show_tabs = False
wiki.append_page(wiki_stub)
wiki.append_page(wiki_widget)
self.progress = gtk.Label()
#self.progress.set_size_request(-1, style.SMALL_ICON_SIZE+4)
#progress_box = gtk.HBox()
#progress_box.pack_start(gtk.HSeparator(), False)
#progress_box.pack_start(self.progress, False)
wiki_box = gtk.VBox()
wiki_box.pack_start(search_box, False)
wiki_box.pack_start(wiki)
wiki_box.pack_start(self.progress, False)
wiki_box.set_size_request(gtk.gdk.screen_width() / 4 * 3,
gtk.gdk.screen_height() / 2)
custom_widget = Reading_View()
custom = gtk.Notebook()
custom.props.show_border = False
custom.props.show_tabs = False
custom.append_page(custom_stub)
custom.append_page(custom_widget)
custom.set_size_request(gtk.gdk.screen_width() / 4 * 3,
gtk.gdk.screen_height() / 2)
# workspace
articles_box = gtk.HBox()
articles_box.pack_start(self.wiki)
articles_box.pack_start(gtk.VSeparator(), False)
articles_box.pack_start(wiki_box, False)
custom_box = gtk.HBox()
custom_box.pack_start(self.custom)
custom_box.pack_start(gtk.VSeparator(), False)
custom_box.pack_start(custom, False)
workspace = gtk.VBox()
workspace.pack_start(articles_box, False)
workspace.pack_start(custom_box, False)
workspace.show_all()
self.add(workspace)
# init components
book.wiki.connect('article-selected', self._article_selected_cb,
wiki_widget, [wiki, custom])
book.wiki.connect('article-deleted', self._article_deleted_cb,
[wiki, custom])
book.custom.connect('article-selected', self._article_selected_cb,
custom_widget, [custom, wiki])
book.custom.connect('article-deleted', self._article_deleted_cb,
[custom, wiki])
self._article_selected_cb(book.wiki, book.wiki.article, wiki_widget,
[wiki, custom])
self._article_selected_cb(book.custom, book.custom.article,
custom_widget, [custom, wiki])
self.connect('map', self._map_cb)
class TuningToolbar(gtk.Toolbar):
''' The toolbar for tuning instruments '''
def __init__(self, activity):
gtk.Toolbar.__init__(self)
self.activity = activity
self._show_tuning_line = False
self._updating_note = True
self._tuning_tool = None
# Set up Instrument Combo box
self.instrument_combo = ComboBox()
self.instrument = [_('None')]
for k in INSTRUMENT_DICT.keys():
self.instrument.append(k)
self._instrument_changed_id = self.instrument_combo.connect(
'changed', self.update_instrument_control)
for i, instrument in enumerate(self.instrument):
self.instrument_combo.append_item(i, instrument, None)
self.instrument_combo.set_active(0)
if hasattr(self.instrument_combo, 'set_tooltip_text'):
self.instrument_combo.set_tooltip_text(_('Tune an instrument.'))
self._instrument_tool = ToolComboBox(self.instrument_combo)
self.insert(self._instrument_tool, -1)
if self.activity.has_toolbarbox:
separator = gtk.SeparatorToolItem()
separator.props.draw = True
self.insert(separator, -1)
self._notes_combo = ComboBox()
n = 0
for octave in range(9):
for i in range(len(NOTES)):
if octave == 0 and i < 9: # Start with A0
continue
self._notes_combo.append_item(n, note_octave(i, octave), None)
n += 1
self._notes_combo.set_active(48) # A4
self._notes_changed_id = self._notes_combo.connect(
'changed', self.update_note)
if hasattr(self._notes_combo, 'set_tooltip_text'):
self._notes_combo.set_tooltip_text(_('Notes'))
self._notes_tool = ToolComboBox(self._notes_combo)
self.insert(self._notes_tool, -1)
# The entry is used to display a note or for direct user input
self._freq_entry = gtk.Entry()
self._freq_entry.set_text('440') # A
self._freq_entry_changed_id = self._freq_entry.connect(
'changed', self.update_freq_entry)
if hasattr(self._freq_entry, 'set_tooltip_text'):
self._freq_entry.set_tooltip_text(
_('Enter a frequency to display.'))
self._freq_entry.set_width_chars(8)
self._freq_entry.show()
toolitem = gtk.ToolItem()
toolitem.add(self._freq_entry)
self.insert(toolitem, -1)
toolitem.show()
self._new_tuning_line = ToolButton('tuning-tools')
self._new_tuning_line.show()
self.insert(self._new_tuning_line, -1)
self._new_tuning_line.set_tooltip(_('Show tuning line.'))
self._new_tuning_line.connect('clicked', self.tuning_line_cb)
if self.activity.has_toolbarbox:
separator = gtk.SeparatorToolItem()
separator.props.draw = True
self.insert(separator, -1)
self._harmonic = ToolButton('harmonics')
self._harmonic.show()
self.insert(self._harmonic, -1)
self._harmonic.set_tooltip(_('Show harmonics.'))
self._harmonic.connect('clicked', self.harmonic_cb)
if self.activity.has_toolbarbox:
separator = gtk.SeparatorToolItem()
separator.props.draw = True
self.insert(separator, -1)
self._play_tone = ToolButton('media-playback-start')
self._play_tone.show()
self.insert(self._play_tone, -1)
self._play_tone.set_tooltip(_('Play a note.'))
self._play_tone.connect('clicked', self.play_cb)
if self.activity.has_toolbarbox:
separator = gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
self.insert(separator, -1)
self.label = gtk.Label('')
self.label.set_use_markup(True)
self.label.show()
toolitem = gtk.ToolItem()
toolitem.add(self.label)
self.insert(toolitem, -1)
toolitem.show()
self.show_all()
def update_note(self, *args):
''' Calculate the frequency based on note combo '''
if not hasattr(self, '_freq_entry'): # Still setting up toolbar
return
i = self._notes_combo.get_active()
freq = A0 * pow(TWELTHROOT2, i)
self._updating_note = True
self._freq_entry.set_text('%0.3f' % (freq))
self.label.set_markup(
SPAN % (style.COLOR_WHITE.get_html(),
note_octave(index_to_note(i), index_to_octave(i))))
if self._show_tuning_line:
self.activity.wave.tuning_line = freq
return
def update_tuning_control(self, *args):
''' Update note '''
if not hasattr(self, '_freq_entry'): # Still setting up toolbar?
return
instrument = self.instrument[self.instrument_combo.get_active()]
if not instrument in INSTRUMENT_DICT:
return
if self.tuning[self._tuning_combo.get_active()] == _('All notes'):
self._notes_combo.set_active(
freq_index(INSTRUMENT_DICT[instrument][0]))
self.activity.wave.instrument = instrument
self.activity.wave.tuning_line = 0.0
self._new_tuning_line.set_icon('tuning-tools')
self._new_tuning_line.set_tooltip(_('Show tuning line.'))
self._show_tuning_line = False
else:
freq = INSTRUMENT_DICT[instrument][self._tuning_combo.get_active()
- 1] # All notes is 0
self._notes_combo.set_active(
freq_index(INSTRUMENT_DICT[instrument][
self._tuning_combo.get_active() - 1]))
self.activity.wave.instrument = None
self.activity.wave.tuning_line = freq
self._new_tuning_line.set_icon('tuning-tools-off')
self._new_tuning_line.set_tooltip(_('Hide tuning line.'))
self._show_tuning_line = True
self._updating_note = False
def update_freq_entry(self, *args):
# Calcualte a note from a frequency
if not self._updating_note: # Only if user types in a freq.
try:
freq = float(self._freq_entry.get_text())
# Only consider notes in piano range
if freq < A0 * 0.97:
self.label.set_text('< A0')
return
if freq > C8 * 1.03:
self.label.set_text('> C8')
return
self.label.set_markup(freq_note(freq, flatsharp=True))
except ValueError:
return
self._updating_note = False
def update_instrument_control(self, *args):
''' Callback for instrument control '''
instrument = self.instrument[self.instrument_combo.get_active()]
if self._tuning_tool is not None:
self.remove(self._tuning_tool)
if instrument == _('None'):
self.activity.wave.instrument = None
if hasattr(self, '_notes_tool'):
self.insert(self._notes_tool, 2)
return
self.remove(self._notes_tool)
self.activity.wave.instrument = instrument
# If we are not already in freq. base, switch.
if not self.activity.wave.get_fft_mode():
self.activity.timefreq_control()
# Add a Tuning Combo box for this instrument
self._tuning_combo = ComboBox()
self.tuning = [_('All notes')]
for f in INSTRUMENT_DICT[instrument]:
self.tuning.append(freq_note(f))
self._tuning_changed_id = self._tuning_combo.connect(
'changed', self.update_tuning_control)
for i, s in enumerate(self.tuning):
self._tuning_combo.append_item(i, s, None)
self._tuning_combo.set_active(0)
if hasattr(self._tuning_combo, 'set_tooltip_text'):
self._tuning_combo.set_tooltip_text(instrument)
self._tuning_tool = ToolComboBox(self._tuning_combo)
self.insert(self._tuning_tool, 1)
self._tuning_combo.show()
self._tuning_tool.show()
self.show_all()
def harmonic_cb(self, *args):
''' Callback for harmonics control '''
self.activity.wave.harmonics = not self.activity.wave.harmonics
if self.activity.wave.harmonics:
self._harmonic.set_icon('harmonics-off')
self._harmonic.set_tooltip(_('Hide harmonics.'))
if self.activity.wave.instrument is None and \
self.activity.wave.tuning_line == 0.0:
self._load_tuning_line()
else:
self._harmonic.set_icon('harmonics')
self._harmonic.set_tooltip(_('Show harmonics.'))
def tuning_line_cb(self, *args):
''' Callback for tuning insert '''
if self._show_tuning_line:
self.activity.wave.tuning_line = 0.0
self._new_tuning_line.set_icon('tuning-tools')
self._new_tuning_line.set_tooltip(_('Show tuning line.'))
self._show_tuning_line = False
else:
self._load_tuning_line()
def _load_tuning_line(self):
''' Read the freq entry and use value to set tuning line '''
freq = self._freq_entry.get_text()
try:
self.activity.wave.tuning_line = float(freq)
if freq < 0:
freq = -freq
self._new_tuning_line.set_icon('tuning-tools-off')
self._new_tuning_line.set_tooltip(_('Hide tuning line.'))
self._show_tuning_line = True
except ValueError:
self.activity.wave.tuning_line = 0.0
self._freq_entry.set_text('0')
# If we are not already in freq. base, switch.
if not self.activity.wave.get_fft_mode():
self.activity.timefreq_control()
def play_cb(self, *args):
''' Save settings, turn off display, and then play a tone at
the current frequency '''
freq = float(self._freq_entry.get_text())
channels = []
for c in range(self.activity.audiograb.channels):
channels.append(self.activity.wave.get_visibility(channel=c))
self.activity.wave.set_visibility(False, channel=c)
wave_status = self.activity.wave.get_active()
self.activity.wave.set_context_off()
self.activity.wave.set_active(False)
gobject.timeout_add(200, self.play_sound, freq, channels, wave_status)
def play_sound(self, freq, channels, wave_status):
''' Play the sound and then restore wave settings '''
if hasattr(subprocess, 'check_output'):
try:
output = subprocess.check_output([
'speaker-test', '-t', 'sine', '-l', '1', '-f',
'%f' % (freq)
])
except subprocess.CalledProcessError:
log.warning('call to speaker-test failed?')
else:
import commands
(status, output) = commands.getstatusoutput(
'speaker-test -t sine -l 1 -f %f' % (freq))
if status != 0:
log.warning('call to speaker-test failed?')
for c in range(self.activity.audiograb.channels):
self.activity.wave.set_visibility(channels[c], channel=c)
self.activity.wave.set_context_on()
self.activity.wave.set_active(wave_status)
class RecordControl():
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 set_mode(self, mode):
if mode == constants.MODE_PHOTO:
self.quality.set_sensitive(True)
self._timer_combo.set_sensitive(True)
self._duration_combo.set_sensitive(False)
if mode == constants.MODE_VIDEO:
self.quality.set_sensitive(True)
self._timer_combo.set_sensitive(True)
self._duration_combo.set_sensitive(True)
if mode == constants.MODE_AUDIO:
self.quality.set_sensitive(False)
self._timer_combo.set_sensitive(True)
self._duration_combo.set_sensitive(True)
def get_timer(self):
return self._timer_combo.get_value()
def get_timer_idx(self):
return self._timer_combo.get_value_idx()
def set_timer_idx(self, idx):
self._timer_combo.set_value_idx(idx)
def get_duration(self):
return self._duration_combo.get_value()
def get_duration_idx(self):
return self._duration_combo.get_value_idx()
def set_duration_idx(self, idx):
return self._duration_combo.set_value_idx(idx)
def get_quality(self):
return self.quality.combo.get_active()
def set_quality(self, idx):
self.quality.combo.set_active(idx)
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)
class GameToolbar(gtk.Toolbar):
__gtype_name__ = 'GameToolbar'
__gsignals__ = {
'game-restart': (SIGNAL_RUN_FIRST, TYPE_NONE, []),
'ai-activated': (SIGNAL_RUN_FIRST, TYPE_NONE, []),
'ai-deactivated': (SIGNAL_RUN_FIRST, TYPE_NONE, []),
'game-board-size': (SIGNAL_RUN_FIRST, TYPE_NONE, [TYPE_INT]),
}
def __init__(self, activity):
gtk.Toolbar.__init__(self)
self.activity = activity
# Reset Button
restart_icon = join(dirname(__file__), 'images', 'gtk-refresh.svg')
restart_image = gtk.Image()
restart_image.set_from_file(restart_icon)
self._restart_button = ToolButton()
self._restart_button.set_icon_widget(restart_image)
self._restart_button.connect('clicked', self._game_restart_cb)
self._restart_button.set_tooltip(_('Restart Game'))
self.insert(self._restart_button, -1)
self._restart_button.show()
# Separator
separator = gtk.SeparatorToolItem()
separator.set_draw(True)
self.insert(separator, -1)
self._add_widget(gtk.Label(_('Board size') + ': '))
# Change size combobox
self._size_combo = ToolComboBox()
self._sizes = ['19 X 19', '13 X 13', '9 X 9']
for i, f in enumerate(self._sizes):
self._size_combo.combo.append_item(i, f)
self._size_combo.combo.connect('changed', self._game_size_cb)
self._add_widget(self._size_combo)
self._size_combo.combo.set_active(0)
# Separator
separator = gtk.SeparatorToolItem()
separator.set_draw(True)
self.insert(separator, -1)
# Artificial Intelligence Button
self._ai_button = gtk.ToggleToolButton()
if search_for_gnugo():
self._ai_button.connect('toggled', self._ai_toggled_cb)
self._ai_button.set_label(_('Play against PlayGo!'))
else:
self._ai_button.set_label(_('You need to install gnugo to play against PlayGo'))
self._ai_button.set_sensitive(False)
self.insert(self._ai_button, -1)
self._ai_button.show()
def _add_widget(self, widget, expand=False):
tool_item = gtk.ToolItem()
tool_item.set_expand(expand)
tool_item.add(widget)
widget.show()
self.insert(tool_item, -1)
tool_item.show()
def _game_restart_cb(self, widget):
self._size_combo.set_sensitive(True)
self.emit('game-restart')
def grey_out_restart(self):
self._restart_button.set_sensitive(False)
def _game_size_cb(self, widget):
game_size = int(self._sizes[self._size_combo.combo.get_active()][:2])
self.emit('game-board-size', game_size)
def grey_out_size_change(self):
self._size_combo.set_sensitive(False)
def update_toolbar(self, widget, data, grid):
size = data.get('size')
self._size_combo.combo.handler_block(self.size_handle_id)
size_index = self._sizes.index(size+' X '+size)
self._size_combo.combo.set_active(int(size_index))
self._size_combo.combo.handler_unblock(self.size_handle_id)
def _ai_toggled_cb(self, widget):
if widget.get_active():
self.emit('ai-activated')
else:
self.emit('ai-deactivated')
def grey_out_ai(self):
self._ai_button.set_sensitive(False)
def set_ai_button_state(self, value):
self._ai_button.set_active(value)
class 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, activity):
gtk.Toolbar.__init__(self)
self.activity = activity
self._show_tuning_line = False
self._updating_note = True
self._tuning_tool = None
# Set up Instrument Combo box
self.instrument_combo = ComboBox()
self.instrument = [_('None')]
for k in INSTRUMENT_DICT.keys():
self.instrument.append(k)
self._instrument_changed_id = self.instrument_combo.connect(
'changed', self.update_instrument_control)
for i, instrument in enumerate(self.instrument):
self.instrument_combo.append_item(i, instrument, None)
self.instrument_combo.set_active(0)
if hasattr(self.instrument_combo, 'set_tooltip_text'):
self.instrument_combo.set_tooltip_text(_('Tune an instrument.'))
self._instrument_tool = ToolComboBox(self.instrument_combo)
self.insert(self._instrument_tool, -1)
if self.activity.has_toolbarbox:
separator = gtk.SeparatorToolItem()
separator.props.draw = True
self.insert(separator, -1)
self._notes_combo = ComboBox()
n = 0
for octave in range(9):
for i in range(len(NOTES)):
if octave == 0 and i < 9: # Start with A0
continue
self._notes_combo.append_item(n, note_octave(i, octave), None)
n += 1
self._notes_combo.set_active(48) # A4
self._notes_changed_id = self._notes_combo.connect(
'changed', self.update_note)
if hasattr(self._notes_combo, 'set_tooltip_text'):
self._notes_combo.set_tooltip_text(_('Notes'))
self._notes_tool = ToolComboBox(self._notes_combo)
self.insert(self._notes_tool, -1)
# The entry is used to display a note or for direct user input
self._freq_entry = gtk.Entry()
self._freq_entry.set_text('440') # A
self._freq_entry_changed_id = self._freq_entry.connect(
'changed', self.update_freq_entry)
if hasattr(self._freq_entry, 'set_tooltip_text'):
self._freq_entry.set_tooltip_text(
_('Enter a frequency to display.'))
self._freq_entry.set_width_chars(8)
self._freq_entry.show()
toolitem = gtk.ToolItem()
toolitem.add(self._freq_entry)
self.insert(toolitem, -1)
toolitem.show()
self._new_tuning_line = ToolButton('tuning-tools')
self._new_tuning_line.show()
self.insert(self._new_tuning_line, -1)
self._new_tuning_line.set_tooltip(_('Show tuning line.'))
self._new_tuning_line.connect('clicked', self.tuning_line_cb)
if self.activity.has_toolbarbox:
separator = gtk.SeparatorToolItem()
separator.props.draw = True
self.insert(separator, -1)
self._harmonic = ToolButton('harmonics')
self._harmonic.show()
self.insert(self._harmonic, -1)
self._harmonic.set_tooltip(_('Show harmonics.'))
self._harmonic.connect('clicked', self.harmonic_cb)
if self.activity.has_toolbarbox:
separator = gtk.SeparatorToolItem()
separator.props.draw = True
self.insert(separator, -1)
self._play_tone = ToolButton('media-playback-start')
self._play_tone.show()
self.insert(self._play_tone, -1)
self._play_tone.set_tooltip(_('Play a note.'))
self._play_tone.connect('clicked', self.play_cb)
if self.activity.has_toolbarbox:
separator = gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
self.insert(separator, -1)
self.label = gtk.Label('')
self.label.set_use_markup(True)
self.label.show()
toolitem = gtk.ToolItem()
toolitem.add(self.label)
self.insert(toolitem, -1)
toolitem.show()
self.show_all()
def __init__(self, toolbox, abiword_canvas, parent):
self._colorseldlg = None
gtk.Toolbar.__init__(self)
self._toolbox = toolbox
self._abiword_canvas = abiword_canvas
self._parent = parent
self._bold = ToggleToolButton('format-text-bold')
self._bold.set_tooltip(_('Bold'))
self._bold_id = self._bold.connect('clicked', self._bold_cb)
self._abiword_canvas.connect('bold', self._isBold_cb)
self.insert(self._bold, -1)
self._bold.show()
self._italic = ToggleToolButton('format-text-italic')
self._italic.set_tooltip(_('Italic'))
self._italic_id = self._italic.connect('clicked', self._italic_cb)
self._abiword_canvas.connect('italic', self._isItalic_cb)
self.insert(self._italic, -1)
self._italic.show()
self._underline = ToggleToolButton('format-text-underline')
self._underline.set_tooltip(_('Underline'))
self._underline_id = self._underline.connect('clicked',
self._underline_cb)
self._abiword_canvas.connect('underline', self._isUnderline_cb)
self.insert(self._underline, -1)
self._underline.show()
self._text_color = gtk.ColorButton()
self._text_color_id = self._text_color.connect('color-set',
self._text_color_cb)
tool_item = gtk.ToolItem()
tool_item.add(self._text_color)
self.insert(tool_item, -1)
tool_item.show_all()
separator = gtk.SeparatorToolItem()
separator.set_draw(True)
separator.show()
self.insert(separator, -1)
self._font_size_icon = Icon(icon_name="format-text-size",
icon_size=gtk.ICON_SIZE_LARGE_TOOLBAR)
tool_item = gtk.ToolItem()
tool_item.add(self._font_size_icon)
self.insert(tool_item, -1)
tool_item.show_all()
self._font_size_combo = ComboBox()
self._font_sizes = [
'8', '9', '10', '11', '12', '14', '16', '20', '22', '24', '26',
'28', '36', '48', '72'
]
self._font_size_changed_id = self._font_size_combo.connect(
'changed', self._font_size_changed_cb)
for i, s in enumerate(self._font_sizes):
self._font_size_combo.append_item(i, s, None)
if s == '12':
self._font_size_combo.set_active(i)
tool_item = ToolComboBox(self._font_size_combo)
self.insert(tool_item, -1)
tool_item.show()
self._has_custom_fonts = False
self._font_combo = ComboBox()
self._fonts = sorted(self._abiword_canvas.get_font_names())
self._fonts_changed_id = self._font_combo.connect(
'changed', self._font_changed_cb)
for i, f in enumerate(self._fonts):
self._font_combo.append_item(i, f, None)
if f == 'Times New Roman':
self._font_combo.set_active(i)
tool_item = ToolComboBox(self._font_combo)
self.insert(tool_item, -1)
tool_item.show()
separator = gtk.SeparatorToolItem()
separator.set_draw(True)
self.insert(separator, -1)
separator.show()
self._alignment = ComboBox()
self._alignment.append_item(self._ACTION_ALIGNMENT_LEFT, None,
'format-justify-left')
self._alignment.append_item(self._ACTION_ALIGNMENT_CENTER, None,
'format-justify-center')
self._alignment.append_item(self._ACTION_ALIGNMENT_RIGHT, None,
'format-justify-right')
self._alignment.append_item(self._ACTION_ALIGNMENT_JUSTIFY, None,
'format-justify-fill')
self._alignment_changed_id = \
self._alignment.connect('changed', self._alignment_changed_cb)
tool_item = ToolComboBox(self._alignment)
self.insert(tool_item, -1)
tool_item.show()
self._abiword_canvas.connect('color', self._color_cb)
self._abiword_canvas.connect('font-size', self._font_size_cb)
self._abiword_canvas.connect('font-family', self._font_family_cb)
self._abiword_canvas.connect('left-align', self._isLeftAlign_cb)
self._abiword_canvas.connect('center-align', self._isCenterAlign_cb)
self._abiword_canvas.connect('right-align', self._isRightAlign_cb)
self._abiword_canvas.connect('justify-align', self._isJustifyAlign_cb)
self._text_selected_handler = self._abiword_canvas.connect(
'text-selected', self._text_selected_cb)
####btn salir del barrido del menu item
self._btn_barrido_menu = ToolButton()
self._btn_barrido_menu.set_tooltip(_('Salir \nMenú'))
self._btn_barrido_menu_id = self._btn_barrido_menu.connect(
'clicked', self._btn_barrido_menu_cb)
self.insert(self._btn_barrido_menu, -1)
self._btn_barrido_menu.set_no_show_all(True)
def __init__(self, activity):
""" Initialize the toolbar controls. """
gtk.Toolbar.__init__(self)
self.activity = activity
self._STR_BASIC = _('Sound') + ' '
self._STR1 = _('Time Base') + ' '
self._STR2 = _('Frequency Base') + ' '
self._STR3 = ' ' + _('Invert') + ' '
self._STR_SCALEX = ""
self._STR_XAXIS_TEXT = \
_('X Axis Scale: 1 division = %(division)s %(unit)s')
# TRANSLATORS: This is milli seconds.
self._ms = _('ms')
# TRANSLATORS: This is Hertz, so 1/second.
self._Hz = _('Hz')
self._update_page_size_id = None
self.string_for_textbox = ""
self.gain = 1.0
self.y_mag = 3.0
self.capture_gain = CAPTURE_GAIN
self.mic_boost = MIC_BOOST
# self.logging_status = False
self._record = None
# Set up Time-domain Button
self.time = ToolButton('domain-time2')
self.insert(self.time, -1)
self.time.set_tooltip(_('Time Base'))
self.time.connect('clicked', self._timefreq_control_cb, True)
# Set up Frequency-domain Button
self.freq = ToolButton('domain-freq')
self.insert(self.freq, -1)
self.freq.show()
self.freq.set_tooltip(_('Frequency Base'))
self.freq.connect('clicked', self._timefreq_control_cb, False)
# Set up Frequency-control Slider and corresponding buttons
if not self.activity.has_toolbarbox:
self.add_frequency_slider(self)
# Set up the Pause Button
self._pause = ToolButton('media-playback-pause')
self.insert(self._pause, -1)
self._pause.set_tooltip(_('Freeze the display'))
self._pause.connect('clicked', self._pauseplay_control_cb)
if self.activity.has_toolbarbox:
separator = gtk.SeparatorToolItem()
separator.props.draw = True
self.insert(separator, -1)
separator.show()
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)
# Set up the Logging-interval Combo box
self._loginterval_combo = ComboBox()
self.interval = [
_(self.SAMPLE_NOW),
_(self.SAMPLE_30_SEC),
_(self.SAMPLE_2_MIN),
_(self.SAMPLE_10_MIN),
_(self.SAMPLE_30_MIN)
]
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 == self.SAMPLE_NOW:
self._loginterval_combo.set_active(i)
self._loginterval_tool = ToolComboBox(self._loginterval_combo)
self.insert(self._loginterval_tool, -1)
self.logginginterval_status = 'picture'
# Set up Start/Stop Logging Button
self._record = ToolButton('media-record')
self.insert(self._record, -1)
self._record.set_tooltip(_('Capture sample now'))
self._record.connect('clicked', self.record_control)
if self.activity.has_toolbarbox:
separator = gtk.SeparatorToolItem()
separator.props.draw = True
self.insert(separator, -1)
# Set up Trigger Combo box
self._trigger_combo = ComboBox()
self.trigger = [_('None'), _('Rising Edge'), _('Falling Edge')]
self.trigger_conf = [
self.activity.wave.TRIGGER_NONE, self.activity.wave.TRIGGER_POS,
self.activity.wave.TRIGGER_NEG
]
self._trigger_changed_id = self._trigger_combo.connect(
'changed', self.update_trigger_control)
for i, s in enumerate(self.trigger):
self._trigger_combo.append_item(i, s, None)
self._trigger_combo.set_active(0)
if hasattr(self._trigger_combo, 'set_tooltip_text'):
self._trigger_combo.set_tooltip_text(_('Create a trigger'))
self._trigger_tool = ToolComboBox(self._trigger_combo)
self.insert(self._trigger_tool, -1)
self.show_all()
return
def __init__(self):
gtk.Toolbar.__init__(self)
voicebar = gtk.Toolbar()
self.activity = None
self.sorted_voices = [i for i in speech.voices()]
self.sorted_voices.sort(self.compare_voices)
default = 0
for voice in self.sorted_voices:
if voice[0] == 'default':
break
default = default + 1
# Play button Image
play_img = gtk.Image()
play_img.show()
play_img.set_from_icon_name('media-playback-start',
gtk.ICON_SIZE_LARGE_TOOLBAR)
# Pause button Image
pause_img = gtk.Image()
pause_img.show()
pause_img.set_from_icon_name('media-playback-pause',
gtk.ICON_SIZE_LARGE_TOOLBAR)
# Play button
self.play_btn = ToggleToolButton('media-playback-start')
self.play_btn.show()
self.play_btn.connect('toggled', self._play_cb, [play_img, pause_img])
self.insert(self.play_btn, -1)
self.play_btn.set_tooltip(_('Play / Pause'))
self.voice_combo = ComboBox()
self.voice_combo.connect('changed', self.voice_changed_cb)
for voice in self.sorted_voices:
self.voice_combo.append_item(voice, voice[0])
self.voice_combo.set_active(default)
combotool = ToolComboBox(self.voice_combo)
self.insert(combotool, -1)
combotool.show()
self.pitchadj = gtk.Adjustment(0, -100, 100, 1, 10, 0)
self.pitchadj.connect("value_changed", self.pitch_adjusted_cb)
pitchbar = gtk.HScale(self.pitchadj)
pitchbar.set_draw_value(False)
pitchbar.set_update_policy(gtk.UPDATE_DISCONTINUOUS)
pitchbar.set_size_request(240,15)
pitchtool = gtk.ToolItem()
pitchtool.add(pitchbar)
pitchtool.show()
self.insert(pitchtool, -1)
pitchbar.show()
self.rateadj = gtk.Adjustment(0, -100, 100, 1, 10, 0)
self.rateadj.connect("value_changed", self.rate_adjusted_cb)
ratebar = gtk.HScale(self.rateadj)
ratebar.set_draw_value(False)
ratebar.set_update_policy(gtk.UPDATE_DISCONTINUOUS)
ratebar.set_size_request(240,15)
ratetool = gtk.ToolItem()
ratetool.add(ratebar)
ratetool.show()
self.insert(ratetool, -1)
ratebar.show()
class ActivityToolbar(gtk.Toolbar):
"""The Activity toolbar with the Journal entry title, sharing,
Keep and Stop buttons
All activities should have this toolbar. It is easiest to add it to your
Activity by using the ActivityToolbox.
"""
def __init__(self, activity):
gtk.Toolbar.__init__(self)
self._activity = activity
self._updating_share = False
self._focus_out_hid = None
activity.connect('shared', self.__activity_shared_cb)
activity.connect('joined', self.__activity_shared_cb)
activity.connect('notify::max_participants',
self.__max_participants_changed_cb)
if activity.metadata:
self.title = gtk.Entry()
self.title.set_size_request(int(gtk.gdk.screen_width() / 3), -1)
self.title.set_text(activity.metadata['title'])
self._focus_out_hid = self.title.connect('focus-out-event',
self.__title_changed_cb)
self._add_widget(self.title)
activity.metadata.connect('updated', self.__jobject_updated_cb)
separator = gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
self.insert(separator, -1)
separator.show()
self.share = ToolComboBox(label_text=_('Share with:'))
self.share.combo.connect('changed', self.__share_changed_cb)
self.share.combo.append_item(SCOPE_PRIVATE, _('Private'), 'zoom-home')
self.share.combo.append_item(SCOPE_NEIGHBORHOOD, _('My Neighborhood'),
'zoom-neighborhood')
self.insert(self.share, -1)
self.share.show()
self._update_share()
self.keep = ToolButton(tooltip=_('Keep'))
client = gconf.client_get_default()
color = XoColor(client.get_string('/desktop/sugar/user/color'))
keep_icon = Icon(icon_name='document-save', xo_color=color)
self.keep.set_icon_widget(keep_icon)
keep_icon.show()
self.keep.props.accelerator = '<Ctrl>S'
self.keep.connect('clicked', self.__keep_clicked_cb)
self.insert(self.keep, -1)
self.keep.show()
self.stop = ToolButton('activity-stop', tooltip=_('Stop'))
self.stop.props.accelerator = '<Ctrl>Q'
self.stop.connect('clicked', self.__stop_clicked_cb)
self.insert(self.stop, -1)
self.stop.show()
def _update_share(self):
self._updating_share = True
if self._activity.props.max_participants == 1:
self.share.hide()
if self._activity.get_shared():
self.share.set_sensitive(False)
self.share.combo.set_active(1)
else:
self.share.set_sensitive(True)
self.share.combo.set_active(0)
self._updating_share = False
def __share_changed_cb(self, combo):
if self._updating_share:
return
model = self.share.combo.get_model()
it = self.share.combo.get_active_iter()
(scope, ) = model.get(it, 0)
if scope == SCOPE_NEIGHBORHOOD:
self._activity.share()
def __keep_clicked_cb(self, button):
self._activity.copy()
def __stop_clicked_cb(self, button):
if self._focus_out_hid is not None:
self.title.disconnect(self._focus_out_hid)
self._update_title(self.title.get_text())
self._activity.close()
def __jobject_updated_cb(self, jobject):
self.title.set_text(jobject['title'])
def __title_changed_cb(self, editable, event):
title = editable.get_text()
self._update_title(title)
def _update_title(self, title):
# Title really changed?
if title == self._activity.metadata['title']:
return False
self._activity.metadata['title'] = title
self._activity.metadata['title_set_by_user'] = '******'
self._activity.save()
shared_activity = self._activity.get_shared_activity()
if shared_activity:
shared_activity.props.name = title
return False
def _add_widget(self, widget, expand=False):
tool_item = gtk.ToolItem()
tool_item.set_expand(expand)
tool_item.add(widget)
widget.show()
self.insert(tool_item, -1)
tool_item.show()
def __activity_shared_cb(self, activity):
self._update_share()
def __max_participants_changed_cb(self, activity, pspec):
self._update_share()
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 __init__(self, activity, channels):
''' By default, start with resistance mode '''
gtk.Toolbar.__init__(self)
self.activity = activity
self._channels = channels
self._lock_radio_buttons = False
self._radio_button_pushed = False
self.values = []
for i in range(self._channels):
self.values.append('')
self.string_for_textbox = ''
self.gain = 1.0
self.y_mag = 3.0
self.capture_gain = CAPTURE_GAIN
self.mic_boost = MIC_BOOST
self.mode = 'sound'
# Set up Time-domain Button
self.time = RadioToolButton(group=None)
self.time.set_named_icon('media-audio')
self.insert(self.time, -1)
self.time.set_tooltip(_('Sound'))
self.time.connect('clicked', self.analog_resistance_voltage_mode_cb,
'sound')
# Set up Resistance Button
self.resistance = RadioToolButton(group=self.time)
self.resistance.set_named_icon('resistance')
if _is_xo(self.activity.hw):
self.insert(self.resistance, -1)
self.resistance.show()
self.resistance.set_tooltip(_('Resistance Sensor'))
self.resistance.connect('clicked',
self.analog_resistance_voltage_mode_cb,
'resistance')
# Set up Voltage Button
self.voltage = RadioToolButton(group=self.time)
self.voltage.set_named_icon('voltage')
if _is_xo(self.activity.hw):
self.insert(self.voltage, -1)
self.voltage.set_tooltip(_('Voltage Sensor'))
self.voltage.connect('clicked', self.analog_resistance_voltage_mode_cb,
'voltage')
separator = gtk.SeparatorToolItem()
separator.props.draw = True
self.insert(separator, -1)
self._log_interval_combo = ComboBox()
self.interval = [
_('1/10 second'),
_('1 second'),
_('30 seconds'),
_('5 minutes'),
_('30 minutes')
]
if hasattr(self._log_interval_combo, 'set_tooltip_text'):
self._log_interval_combo.set_tooltip_text(_('Sampling interval'))
self._interval_changed_id = self._log_interval_combo.connect(
'changed', self.log_interval_cb)
for i, s in enumerate(self.interval):
self._log_interval_combo.append_item(i, s, None)
if s == _('1 second'):
self._log_interval_combo.set_active(i)
self._log_interval_tool = ToolComboBox(self._log_interval_combo)
self.insert(self._log_interval_tool, -1)
self.logging_interval_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_cb)
if self.activity.has_toolbarbox:
separator = gtk.SeparatorToolItem()
separator.props.draw = True
self.insert(separator, -1)
# Set up Trigger Combo box
self.trigger_combo = ComboBox()
self.trigger = [_('None'), _('Rising Edge'), _('Falling Edge')]
self.trigger_conf = [
self.activity.wave.TRIGGER_NONE, self.activity.wave.TRIGGER_POS,
self.activity.wave.TRIGGER_NEG
]
self._trigger_changed_id = self.trigger_combo.connect(
'changed', self.update_trigger_control)
for i, s in enumerate(self.trigger):
self.trigger_combo.append_item(i, s, None)
self.trigger_combo.set_active(0)
if hasattr(self.trigger_combo, 'set_tooltip_text'):
self.trigger_combo.set_tooltip_text(_('Create a trigger'))
self._trigger_tool = ToolComboBox(self.trigger_combo)
self.insert(self._trigger_tool, -1)
self.show_all()
class GameToolbar(gtk.Toolbar):
__gtype_name__ = 'GameToolbar'
__gsignals__ = {
'game-restart': (SIGNAL_RUN_FIRST, TYPE_NONE, []),
'ai-activated': (SIGNAL_RUN_FIRST, TYPE_NONE, []),
'ai-deactivated': (SIGNAL_RUN_FIRST, TYPE_NONE, []),
'game-board-size': (SIGNAL_RUN_FIRST, TYPE_NONE, [TYPE_INT]),
}
def __init__(self, activity):
gtk.Toolbar.__init__(self)
self.activity = activity
# Reset Button
restart_icon = join(dirname(__file__), 'images', 'gtk-refresh.svg')
restart_image = gtk.Image()
restart_image.set_from_file(restart_icon)
self._restart_button = ToolButton()
self._restart_button.set_icon_widget(restart_image)
self._restart_button.connect('clicked', self._game_restart_cb)
self._restart_button.set_tooltip(_('Restart Game'))
self.insert(self._restart_button, -1)
self._restart_button.show()
# Separator
separator = gtk.SeparatorToolItem()
separator.set_draw(True)
self.insert(separator, -1)
self._add_widget(gtk.Label(_('Board size') + ': '))
# Change size combobox
self._size_combo = ToolComboBox()
self._sizes = ['19 X 19', '13 X 13', '9 X 9']
for i, f in enumerate(self._sizes):
self._size_combo.combo.append_item(i, f)
self._size_combo.combo.connect('changed', self._game_size_cb)
self._add_widget(self._size_combo)
self._size_combo.combo.set_active(0)
# Separator
separator = gtk.SeparatorToolItem()
separator.set_draw(True)
self.insert(separator, -1)
# Artificial Intelligence Button
self._ai_button = gtk.ToggleToolButton()
if search_for_gnugo():
self._ai_button.connect('toggled', self._ai_toggled_cb)
self._ai_button.set_label(_('Play against PlayGo!'))
else:
self._ai_button.set_label(
_('You need to install gnugo to play against PlayGo'))
self._ai_button.set_sensitive(False)
self.insert(self._ai_button, -1)
self._ai_button.show()
def _add_widget(self, widget, expand=False):
tool_item = gtk.ToolItem()
tool_item.set_expand(expand)
tool_item.add(widget)
widget.show()
self.insert(tool_item, -1)
tool_item.show()
def _game_restart_cb(self, widget):
self._size_combo.set_sensitive(True)
self.emit('game-restart')
def grey_out_restart(self):
self._restart_button.set_sensitive(False)
def _game_size_cb(self, widget):
game_size = int(self._sizes[self._size_combo.combo.get_active()][:2])
self.emit('game-board-size', game_size)
def grey_out_size_change(self):
self._size_combo.set_sensitive(False)
def update_toolbar(self, widget, data, grid):
size = data.get('size')
self._size_combo.combo.handler_block(self.size_handle_id)
size_index = self._sizes.index(size + ' X ' + size)
self._size_combo.combo.set_active(int(size_index))
self._size_combo.combo.handler_unblock(self.size_handle_id)
def _ai_toggled_cb(self, widget):
if widget.get_active():
self.emit('ai-activated')
else:
self.emit('ai-deactivated')
def grey_out_ai(self):
self._ai_button.set_sensitive(False)
def set_ai_button_state(self, value):
self._ai_button.set_active(value)
