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 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 combo_factory(combo_array,
toolbar,
callback,
cb_arg=None,
tooltip=None,
default=None):
'''Factory for making a toolbar combo box'''
combo = ComboBox()
if tooltip is not None and hasattr(combo, 'set_tooltip_text'):
combo.set_tooltip_text(tooltip)
if cb_arg is not None:
combo.connect('changed', callback, cb_arg)
else:
combo.connect('changed', callback)
for i, selection in enumerate(combo_array):
combo.append_item(i, selection, None)
combo.show()
toolitem = gtk.ToolItem()
toolitem.add(combo)
if hasattr(toolbar, 'insert'): # the main toolbar
toolbar.insert(toolitem, -1)
else: # or a secondary toolbar
toolbar.props.page.insert(toolitem, -1)
toolitem.show()
if default is not None:
combo.set_active(combo_array.index(default))
return combo
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 __init__(self, icon_name, **kwargs):
gtk.ToolItem.__init__(self, **kwargs)
self.icon_name = icon_name
self.set_border_width(style.DEFAULT_PADDING)
self.combo = ComboBox()
self.combo.set_focus_on_click(False)
self.combo.show()
self.add(self.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 _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 _get_with_search_combo(self):
with_search = ComboBox()
with_search.append_item(_ACTION_EVERYBODY, _('Anyone'))
with_search.append_separator()
with_search.append_item(_ACTION_MY_FRIENDS, _('My friends'))
with_search.append_item(_ACTION_MY_CLASS, _('My class'))
with_search.append_separator()
# TODO: Ask the model for buddies.
with_search.append_item(3, 'Dan', 'theme:xo')
with_search.set_active(0)
with_search.connect('changed', self._combo_changed_cb)
return with_search
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):
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 _get_when_search_combo(self):
when_search = ComboBox()
when_search.append_item(_ACTION_ANYTIME, _('Anytime'))
when_search.append_separator()
when_search.append_item(_ACTION_TODAY, _('Today'))
when_search.append_item(_ACTION_SINCE_YESTERDAY, _('Since yesterday'))
# TRANS: Filter entries modified during the last 7 days.
when_search.append_item(_ACTION_PAST_WEEK, _('Past week'))
# TRANS: Filter entries modified during the last 30 days.
when_search.append_item(_ACTION_PAST_MONTH, _('Past month'))
# TRANS: Filter entries modified during the last 356 days.
when_search.append_item(_ACTION_PAST_YEAR, _('Past year'))
when_search.set_active(0)
when_search.connect('changed', self._combo_changed_cb)
return when_search
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.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, combo=None, **kwargs):
self.label = None
self._label_text = ''
gobject.GObject.__init__(self, **kwargs)
self.set_border_width(style.DEFAULT_PADDING)
hbox = gtk.HBox(False, style.DEFAULT_SPACING)
self.label = gtk.Label(self._label_text)
hbox.pack_start(self.label, False)
self.label.show()
if combo:
self.combo = combo
else:
self.combo = ComboBox()
hbox.pack_start(self.combo)
self.combo.show()
self.add(hbox)
hbox.show()
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):
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()
def create_dialog(self):
"""Setup most of the dialog."""
# Toolbar
try:
self._toolbar_box = ToolbarBox()
activity_button = ActivityToolbarButton(self._parent)
self._toolbar_box.toolbar.insert(activity_button, 0)
def append(icon_name, label, page, position):
toolbar_button = ToolbarButton()
toolbar_button.props.page = page
toolbar_button.props.icon_name = icon_name
toolbar_button.props.label = label
self._toolbar_box.toolbar.insert(toolbar_button, position)
append('toolbar-edit',
_('Edit'),
EditToolbar(self._parent),
-1)
append('toolbar-algebra',
_('Algebra'),
AlgebraToolbar(self._parent),
-1)
append('toolbar-trigonometry',
_('Trigonometry'),
TrigonometryToolbar(self._parent),
-1)
append('toolbar-boolean',
_('Boolean'),
BooleanToolbar(self._parent),
-1)
self._misc_toolbar = MiscToolbar(
self._parent,
target_toolbar=self._toolbar_box.toolbar)
append('toolbar-constants',
_('Miscellaneous'),
self._misc_toolbar,
5)
self._stop_separator = gtk.SeparatorToolItem()
self._stop_separator.props.draw = False
self._stop_separator.set_expand(True)
self._stop_separator.show()
self._toolbar_box.toolbar.insert(self._stop_separator, -1)
self._stop = StopButton(self._parent)
self._toolbar_box.toolbar.insert(self._stop, -1)
self._toolbar_box.show_all()
self._parent.set_toolbar_box(self._toolbar_box)
except NameError:
# Use old toolbar design
toolbox = activity.ActivityToolbox(self._parent)
self._parent.set_toolbox(toolbox)
toolbox.add_toolbar(_('Edit'), EditToolbar(self._parent))
toolbox.add_toolbar(_('Algebra'), AlgebraToolbar(self._parent))
toolbox.add_toolbar(
_('Trigonometry'), TrigonometryToolbar(self._parent))
toolbox.add_toolbar(_('Boolean'), BooleanToolbar(self._parent))
toolbox.add_toolbar(_('Miscellaneous'), MiscToolbar(self._parent))
toolbox.show_all()
# Some layout constants
self.input_font = pango.FontDescription(str='sans bold 12')
self.button_font = pango.FontDescription(str='sans bold 16')
self.col_white = self.create_color(1.00, 1.00, 1.00)
self.col_gray1 = self.create_color(0.76, 0.76, 0.76)
self.col_gray2 = self.create_color(0.50, 0.50, 0.50)
self.col_gray3 = self.create_color(0.25, 0.25, 0.25)
self.col_black = self.create_color(0.00, 0.00, 0.00)
self.col_red = self.create_color(1.00, 0.00, 0.00)
# Big - Table, 16 rows, 10 columns, homogeneously divided
self.grid = gtk.Table(26, 11, True)
self.grid.set_border_width(0)
self.grid.set_row_spacings(0)
self.grid.set_col_spacings(4)
# Left part: container and input
vc1 = gtk.VBox(False, 0)
hc1 = gtk.HBox(False, 10)
eb = gtk.EventBox()
eb.add(hc1)
eb.modify_bg(gtk.STATE_NORMAL, self.col_black)
eb.set_border_width(12)
eb2 = gtk.EventBox()
eb2.add(eb)
eb2.modify_bg(gtk.STATE_NORMAL, self.col_black)
label1 = gtk.Label(_('Label:'))
label1.modify_fg(gtk.STATE_NORMAL, self.col_white)
label1.set_alignment(1, 0.5)
hc1.pack_start(label1, expand=False, fill=False, padding=10)
self.label_entry = gtk.Entry()
self.label_entry.modify_bg(gtk.STATE_INSENSITIVE, self.col_black)
hc1.pack_start(self.label_entry, expand=True, fill=True, padding=0)
vc1.pack_start(eb2, expand=False)
self.text_entry = gtk.Entry()
try:
self.text_entry.props.im_module = 'gtk-im-context-simple'
except AttributeError:
pass
self.text_entry.set_size_request(-1, 75)
self.text_entry.connect('key_press_event', self._parent.ignore_key_cb)
self.text_entry.modify_font(self.input_font)
self.text_entry.modify_bg(gtk.STATE_INSENSITIVE, self.col_black)
eb = gtk.EventBox()
eb.add(self.text_entry)
eb.modify_bg(gtk.STATE_NORMAL, self.col_black)
eb.set_border_width(12)
eb2 = gtk.EventBox()
eb2.add(eb)
eb2.modify_bg(gtk.STATE_NORMAL, self.col_black)
vc1.pack_start(eb2, expand=True, fill=True, padding=0)
self.grid.attach(vc1, 0, 7, 0, 6)
# Left part: buttons
self.pad = gtk.Table(9, 6, True)
self.pad.set_row_spacings(12)
self.pad.set_col_spacings(12)
self.pad.set_border_width(12)
self.create_button_data()
self.buttons = {}
for x, y, w, h, cap, bgcol, cb in self.button_data:
button = self.create_button(
_(cap), cb, self.col_white, bgcol, w, h)
self.buttons[cap] = button
self.pad.attach(button, x, x + w, y, y + h)
eb = gtk.EventBox()
eb.add(self.pad)
eb.modify_bg(gtk.STATE_NORMAL, self.col_black)
self.grid.attach(eb, 0, 7, 6, 26)
# Right part: container and equation button
hc2 = gtk.HBox()
combo = ComboBox()
combo.append_item(0, _('All equations'))
combo.append_item(1, _('My equations'))
combo.append_item(2, _('Show variables'))
combo.set_active(0)
combo.connect('changed', self._history_filter_cb)
hc2.pack_start(combo)
hc2.set_border_width(6)
self.grid.attach(hc2, 7, 11, 0, 2)
# Right part: last equation
self.last_eq = gtk.TextView()
self.last_eq.set_editable(False)
self.last_eq.set_wrap_mode(gtk.WRAP_WORD_CHAR)
self.last_eq.connect('realize', self._textview_realize_cb)
self.last_eq.modify_base(gtk.STATE_NORMAL, gtk.gdk.color_parse(
sugar.profile.get_color().get_fill_color()))
self.last_eq.modify_bg(gtk.STATE_NORMAL, gtk.gdk.color_parse(
sugar.profile.get_color().get_stroke_color()))
self.last_eq.set_border_window_size(gtk.TEXT_WINDOW_LEFT, 4)
self.last_eq.set_border_window_size(gtk.TEXT_WINDOW_RIGHT, 4)
self.last_eq.set_border_window_size(gtk.TEXT_WINDOW_TOP, 4)
self.last_eq.set_border_window_size(gtk.TEXT_WINDOW_BOTTOM, 4)
# TODO Fix for old Sugar 0.82 builds, red_float not available
xo_color = sugar.profile.get_color()
bright = (
gtk.gdk.color_parse(xo_color.get_fill_color()).red_float +
gtk.gdk.color_parse(xo_color.get_fill_color()).green_float +
gtk.gdk.color_parse(xo_color.get_fill_color()).blue_float) / 3.0
if bright < 0.5:
self.last_eq.modify_text(gtk.STATE_NORMAL, self.col_white)
else:
self.last_eq.modify_text(gtk.STATE_NORMAL, self.col_black)
self.grid.attach(self.last_eq, 7, 11, 2, 7)
# Right part: history
scrolled_window = gtk.ScrolledWindow()
scrolled_window.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
self.history_vbox = gtk.VBox()
self.history_vbox.set_homogeneous(False)
self.history_vbox.set_border_width(0)
self.history_vbox.set_spacing(4)
self.variable_vbox = gtk.VBox()
self.variable_vbox.set_homogeneous(False)
self.variable_vbox.set_border_width(0)
self.variable_vbox.set_spacing(4)
vbox = gtk.VBox()
vbox.pack_start(self.history_vbox)
vbox.pack_start(self.variable_vbox)
scrolled_window.add_with_viewport(vbox)
self.grid.attach(scrolled_window, 7, 11, 7, 26)
gtk.gdk.screen_get_default().connect('size-changed',
self._configure_cb)
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, 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, 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, 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()
def build_toolbar(self):
# make a toolbox
toolbox = activity.ActivityToolbox(self)
# modify the Activity tab
activity_toolbar = toolbox.get_activity_toolbar()
activity_toolbar.share.props.visible = False
self.activity_toolbar = activity_toolbar
# make the toolbars
toolbars = {}
for b in tools.allButtons:
if not toolbars.has_key(b.toolBar):
toolbars[b.toolBar] = gtk.Toolbar()
# make + add the buttons
self.buttonList = {}
for c in tools.allButtons:
button = ToolButton(c.icon)
button.set_tooltip(_(c.toolTip))
button.connect('clicked', self.buttonClicked)
toolbars[c.toolBar].insert(button, -1)
button.show()
self.buttonList[button] = c.name
# add the toolbars to the toolbox
for bar in toolbars:
toolbox.add_toolbar(bar, toolbars[bar])
toolbars[bar].show()
# make the level chooser combo box
lbl = gtk.Label("Load a level: ")
lbl.show()
cmb = ComboBox()
cmb.connect('changed', self.levelChanged)
files = os.listdir("levels")
for i in files:
if i[-6:] == ".level":
f = open("levels/" + i)
try:
n = pickle.load(f)['name']
except:
continue
f.close()
cmb.append_item("levels/" + i, n)
cmb = ToolComboBox(cmb)
lbl_ti = gtk.ToolItem()
lbl_ti.add(lbl)
toolbars['Run'].insert(lbl_ti, -1)
lbl_ti.show()
toolbars['Run'].insert(cmb, -1)
cmb.show()
button = ToolButton("load")
button.set_tooltip(_("Load your own level"))
button.connect('clicked', self.loadButtonClicked)
toolbars['Run'].insert(button, -1)
button.show()
# add some level saving stuff to the save toolbar
self.quantBox = ComboBox()
self.quantBox.connect('changed', self.quantBoxChanged)
self.quantBoxIndexes = {}
for i in range(26):
self.quantBox.append_item(i, str(i))
self.quantBoxIndexes[i] = i
self.quantBox.append_item(float('inf'), "Infinity")
self.quantBoxIndexes[float('inf')] = 26
cmb = ToolComboBox(self.quantBox)
activity_toolbar.insert(cmb, 1)
cmb.show()
cmb = ComboBox()
cmb.connect('changed', self.compQuantBoxChanged)
for c in components.allComponents:
if c.name != "X" and c.name != "O":
cmb.append_item(c.name, c.name)
cmb = ToolComboBox(cmb)
activity_toolbar.insert(cmb, 1)
cmb.show()
lbl = gtk.Label(" Component amounts: ")
lbl.show()
ti = gtk.ToolItem()
ti.add(lbl)
activity_toolbar.insert(ti, 1)
ti.show()
toolbox.show()
self.set_toolbox(toolbox)
toolbox.set_current_toolbar(1)
return activity_toolbar
