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 _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):
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):
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 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
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):
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 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 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, 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):
gtk.Toolbar.__init__(self)
self._activity = activity
self._updating_share = False
"""
activity.connect('shared', self.__activity_shared_cb)
activity.connect('joined', self.__activity_shared_cb)
activity.connect('notify::max_participants',
self.__max_participants_changed_cb)
"""
#if activity.metadata:
if True:
self.title = gtk.Entry()
self.title.set_size_request(int(gtk.gdk.screen_width() / 6), -1)
if activity.metadata:
self.title.set_text(activity.metadata['title'])
activity.metadata.connect('updated', self.__jobject_updated_cb)
self.title.connect('changed', self.__title_changed_cb)
self._add_widget(self.title)
"""
separator = gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
self.insert(separator, -1)
separator.show()
"""
lookup = {'plain': 0, 'context': 1, 'verbose': 2}
traceback = ToolComboBox(label_text=_('Traceback:'))
traceback.combo.append_item("plain", _('Plain'))
traceback.combo.append_item('context', _('Context'))
traceback.combo.append_item('verbose', _('Verbose'))
index = self._activity.debug_dict.get('traceback', 0)
_logger.debug('retrieved traceback:%s' % (index, ))
traceback.combo.set_active(lookup.get(index, 0))
traceback.combo.connect('changed', self.__traceback_changed_cb)
self.insert(traceback, -1)
traceback.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)
keep_icon = Icon(icon_name='document-save')
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.hide()
"""
separator = gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
self.insert(separator, -1)
separator.show()
stop_button = ToolButton('activity-stop')
stop_button.set_tooltip(_('Stop'))
#stop_button.props.accelerator = '<Ctrl>Q'
stop_button.connect('clicked', self.__stop_clicked_cb)
self.insert(stop_button, -1)
stop_button.show()
self._update_title_sid = None
