def __init__(self):
Gtk.Toolbar.__init__(self)
self.button = ToolbarButton(page=self, icon_name="toolbar-view")
self.buttons = {
CelestialBodyType.MERCURY: None,
CelestialBodyType.VENUS: None,
CelestialBodyType.EARTH: None,
CelestialBodyType.MARS: None,
CelestialBodyType.JUPITER: None,
CelestialBodyType.SATURN: None,
CelestialBodyType.URANUS: None,
CelestialBodyType.NEPTUNE: None
}
self.orbits_button = ToggleToolButton("show-orbits")
self.orbits_button.set_tooltip(_("Show planets orbits"))
self.orbits_button.set_active(True)
self.orbits_button.connect("toggled", self._show_orbits_cb)
self.insert(self.orbits_button, -1)
self.insert(make_separator(False), -1)
for planet in self.buttons:
button = ToggleToolButton(get_icon_name(planet))
button.set_tooltip(get_body_name(planet))
button.set_active(True)
button.connect("toggled", self._show_planet_cb, planet)
self.insert(button, -1)
self.buttons[planet] = button
self.show_all()
def _add_clock_controls(self, display_toolbar):
# First group of radio button to select the type of clock to display
button1 = RadioToolButton(icon_name="simple-clock")
button1.set_tooltip(_('Simple Clock'))
button1.connect("toggled", self._display_mode_changed_cb,
_MODE_SIMPLE_CLOCK)
display_toolbar.insert(button1, -1)
self._display_mode_buttons.append(button1)
button2 = RadioToolButton(icon_name="nice-clock",
group=button1)
button2.set_tooltip(_('Nice Clock'))
button2.connect("toggled", self._display_mode_changed_cb,
_MODE_NICE_CLOCK)
display_toolbar.insert(button2, -1)
self._display_mode_buttons.append(button2)
button3 = RadioToolButton(icon_name="digital-clock",
group=button1)
button3.set_tooltip(_('Digital Clock'))
button3.connect("toggled", self._display_mode_changed_cb,
_MODE_DIGITAL_CLOCK)
display_toolbar.insert(button3, -1)
self._display_mode_buttons.append(button3)
# A separator between the two groups of buttons
separator = Gtk.SeparatorToolItem()
separator.set_draw(True)
display_toolbar.insert(separator, -1)
# Now the options buttons to display other elements: date, day
# of week... A button in the toolbar to write the time in
# full letters
self._write_time_btn = ToggleToolButton("write-time")
self._write_time_btn.set_tooltip(_('Display time in full letters'))
self._write_time_btn.connect("toggled", self._write_time_clicked_cb)
display_toolbar.insert(self._write_time_btn, -1)
# The button to display the weekday and date
self._write_date_btn = ToggleToolButton("write-date")
self._write_date_btn.set_tooltip(_('Display weekday and date'))
self._write_date_btn.connect("toggled", self._write_date_clicked_cb)
display_toolbar.insert(self._write_date_btn, -1)
# Another button to speak aloud the time
self._speak_time_btn = ToggleToolButton("microphone")
self._speak_time_btn.set_tooltip(_('Talking clock'))
self._speak_time_btn.connect("toggled", self._speak_time_clicked_cb)
display_toolbar.insert(self._speak_time_btn, -1)
# A separator between the two groups of buttons
separator = Gtk.SeparatorToolItem()
separator.set_draw(True)
display_toolbar.insert(separator, -1)
# And another button to toggle grabbing the hands
self._grab_button = ToggleToolButton("grab")
self._grab_button.set_tooltip(_('Grab the hands'))
self._grab_button.connect("toggled", self._grab_clicked_cb)
display_toolbar.insert(self._grab_button, -1)
def build_toolbar(self):
"""Build our Activity toolbar for the Sugar system."""
toolbar_box = ToolbarBox()
activity_button = ActivityToolbarButton(self)
toolbar_box.toolbar.insert(activity_button, 0)
activity_button.show()
separator = Gtk.SeparatorToolItem()
toolbar_box.toolbar.insert(separator, -1)
separator.show()
easier_button = ToolButton('create-easier')
easier_button.set_tooltip(_('Easier level'))
easier_button.connect('clicked', self._easier_button_cb)
toolbar_box.toolbar.insert(easier_button, -1)
harder_button = ToolButton('create-harder')
harder_button.set_tooltip(_('Harder level'))
harder_button.connect('clicked', self._harder_button_cb)
toolbar_box.toolbar.insert(harder_button, -1)
self._risk_button = ToggleToolButton('make-risk')
self._risk_button.set_tooltip(_('Make risk'))
if self.state and 'risk' in self.state:
self._risk_button.set_active(self.state['risk'])
self._risk_button.connect('toggled', self._make_risk_button_cb)
toolbar_box.toolbar.insert(self._risk_button, -1)
separator = Gtk.SeparatorToolItem()
toolbar_box.toolbar.insert(separator, -1)
separator.show()
self.show_trail_button = ToggleToolButton('show-trail')
self.show_trail_button.set_tooltip(_('Show trail'))
self.show_trail_button.set_active(True)
self.show_trail_button.connect('toggled', self._toggled_show_trail_cb)
toolbar_box.toolbar.insert(self.show_trail_button, -1)
separator = Gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_size_request(0, -1)
separator.set_expand(True)
toolbar_box.toolbar.insert(separator, -1)
separator.show()
stop_button = StopButton(self)
toolbar_box.toolbar.insert(stop_button, -1)
stop_button.show()
self.set_toolbar_box(toolbar_box)
toolbar_box.show_all()
return toolbar_box
def __init__(self, page):
self._colorseldlg = None
Gtk.Toolbar.__init__(self)
self._page = page
page._text_toolbar = self
self._bold = ToggleToolButton('format-text-bold')
self._bold.set_tooltip(_('Bold'))
self._bold_id = self._bold.connect('clicked', self._bold_cb)
self.insert(self._bold, -1)
self._italic = ToggleToolButton('format-text-italic')
self._italic.set_tooltip(_('Italic'))
self._italic_id = self._italic.connect('clicked', self._italic_cb)
self.insert(self._italic, -1)
"""
self._underline = ToggleToolButton('format-text-underline')
self._underline.set_tooltip(_('Underline'))
self._underline_id = self._underline.connect('clicked',
self._underline_cb)
self.insert(self._underline, -1)
self._underline.show()
"""
self._text_color = TextButtonColor(page)
self._text_color.set_title(_('Text Color'))
item = Gtk.ToolItem()
item.add(self._text_color)
self.insert(item, -1)
separator = Gtk.SeparatorToolItem()
separator.set_draw(True)
self.insert(separator, -1)
self._font_size_combo = FontSize()
self._font_size_changed_id = self._font_size_combo.connect(
'changed', self._font_size_changed_cb)
self.insert(self._font_size_combo, -1)
# font
self._font_combo = FontComboBox()
self._font_combo.set_font_name(globos.DEFAULT_FONT)
self._fonts_changed_id = self._font_combo.connect(
'changed', self._font_changed_cb)
self.insert(ToolComboBox(self._font_combo), -1)
self.show_all()
def __init__(self, activity):
Gtk.Toolbar.__init__(self)
self._activity = activity
self._speech = SpeechManager()
self._is_paused = False
self.load_speech_parameters()
self._voices = self._speech.get_all_voices() # a dictionary
locale = os.environ.get('LANG', '')
language_location = locale.split('.', 1)[0].lower()
language = language_location.split('_')[0]
# if the language is es but not es_es default to es_la (latin voice)
if language == 'es' and language_location != 'es_es':
language_location = 'es_la'
self._voice = 'en_us'
if language_location in self._voices:
self._voice = language_location
elif language in self._voices:
self._voice = language
voice_names = []
for language, name in self._voices.iteritems():
voice_names.append((language, name))
voice_names.sort(self._compare_voice)
# Play button
self._play_button = ToggleToolButton('media-playback-start')
self._play_button.show()
self._play_button.connect('toggled', self._play_toggled_cb)
self.insert(self._play_button, -1)
self._play_button.set_tooltip(_('Play / Pause'))
# Stop button
self._stop_button = ToolButton('media-playback-stop')
self._stop_button.show()
self._stop_button.connect('clicked', self._stop_clicked_cb)
self._stop_button.set_sensitive(False)
self.insert(self._stop_button, -1)
self._stop_button.set_tooltip(_('Stop'))
# Language list
combo = ComboBox()
which = 0
for pair in voice_names:
language, name = pair
combo.append_item(language, name)
if language == self._voice:
combo.set_active(which)
which += 1
combo.connect('changed', self._voice_changed_cb)
combotool = ToolComboBox(combo)
self.insert(combotool, -1)
combotool.show()
self._speech.connect('stop', self._reset_buttons_cb)
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 _add_search_controls(self, toolbar):
book_search_item = Gtk.ToolItem()
toolbar.search_entry = iconentry.IconEntry()
toolbar.search_entry.set_icon_from_name(iconentry.ICON_ENTRY_PRIMARY,
'system-search')
toolbar.search_entry.add_clear_button()
toolbar.search_entry.connect('activate',
self.__search_entry_activate_cb)
width = int(Gdk.Screen.width() / 4)
toolbar.search_entry.set_size_request(width, -1)
book_search_item.add(toolbar.search_entry)
toolbar.search_entry.show()
toolbar.insert(book_search_item, -1)
book_search_item.show()
toolbar.source_combo = ComboBox()
toolbar.source_combo.props.sensitive = True
toolbar.source_changed_cb_id = \
toolbar.source_combo.connect('changed', self.__source_changed_cb)
combotool = ToolComboBox(toolbar.source_combo)
toolbar.insert(combotool, -1)
combotool.show()
self.bt_catalogs = ToggleToolButton('books')
self.bt_catalogs.set_tooltip(_('Catalogs'))
toolbar.insert(self.bt_catalogs, -1)
self.bt_catalogs.connect('toggled', self.__toggle_cats_cb)
if len(self.catalogs) > 0:
self.bt_catalogs.show()
if len(self.languages) > 0:
toolbar.config_toolbarbutton = ToolbarButton()
toolbar.config_toolbarbutton.props.icon_name = 'preferences-system'
toolbar.config_toolbarbox = Gtk.Toolbar()
toolbar.config_toolbarbutton.props.page = toolbar.config_toolbarbox
toolbar.language_combo = ComboBox()
toolbar.language_combo.props.sensitive = True
combotool = ToolComboBox(toolbar.language_combo)
toolbar.language_combo.append_item('all', _('Any language'))
for key in self.languages.keys():
toolbar.language_combo.append_item(key, self.languages[key])
toolbar.language_combo.set_active(0)
toolbar.config_toolbarbutton.props.page.insert(combotool, -1)
toolbar.insert(toolbar.config_toolbarbutton, -1)
toolbar.config_toolbarbutton.show()
combotool.show()
toolbar.language_changed_cb_id = \
toolbar.language_combo.connect('changed',
self.__language_changed_cb)
self._device_manager = devicemanager.DeviceManager()
self._refresh_sources(toolbar)
self._device_manager.connect('device-changed',
self.__device_changed_cb)
toolbar.search_entry.grab_focus()
return toolbar
def __init__(self, game, editor_index):
Gtk.EventBox.__init__(self)
self._game = game
self.snd = None
self.editor_index = editor_index
self.temp_folder = None
box = Gtk.Grid()
box.set_column_spacing(style.DEFAULT_SPACING)
box.set_row_spacing(style.DEFAULT_SPACING)
box.props.margin = style.DEFAULT_SPACING
self.card = svgcard.SvgCard(-1, {
'front_text': {
'card_text': '',
'text_color': style.Color('#ffffff')
}
}, None, PAIR_SIZE, '#c0c0c0')
self.card.flip()
card_align = Gtk.Alignment.new(.5, .5, 0, 0)
card_align.add(self.card)
box.attach(card_align, 0, 0, 1, 1)
self.textentry = Gtk.Entry()
self.textentry.connect('changed', self.update_text)
self.textentry.set_valign(Gtk.Align.START)
box.attach(self.textentry, 0, 1, 1, 1)
toolbar = Gtk.VBox()
toolbar.set_valign(Gtk.Align.CENTER)
browsepicture = ToolButton(icon_name='import_picture',
tooltip=_('Insert picture'))
toolbar.add(browsepicture)
browsesound = ToolButton(icon_name='import_sound',
tooltip=_('Insert sound'))
toolbar.add(browsesound)
browsepicture.connect('clicked', self._load_image)
browsesound.connect('clicked', self._load_audio)
if speak.espeak.supported:
self.usespeak = ToggleToolButton(icon_name='speak')
self.usespeak.set_palette(SpeakPalette(self))
toolbar.add(self.usespeak)
self.usespeak.connect('toggled', self._usespeak_cb)
else:
self.usespeak = None
self.fontbutton = FontButton()
toolbar.add(self.fontbutton)
self.id_font_changed = self.fontbutton.connect('changed',
self.__font_changed_cb)
box.attach(toolbar, 1, 0, 1, 2)
self.add(box)
def setup_toolbar(self):
activity_button = ActivityToolbarButton(self)
self.toolbar.insert(activity_button, -1)
self.toolbar.insert(Gtk.SeparatorToolItem(), -1)
edit_toolbar = EditToolbar()
self.toolbar.insert(
ToolbarButton(
page=edit_toolbar, icon_name="toolbar-edit"), -1)
edit_toolbar.insert(Gtk.SeparatorToolItem(), -1)
self.button_bold = ToggleToolButton("format-text-bold")
self.button_bold.set_tooltip(_("Bold"))
self.button_bold.props.accelerator = "<Ctrl>B"
self.button_bold.connect(
"toggled", lambda button: self.edit.toggle_bold())
edit_toolbar.insert(self.button_bold, -1)
self.button_italic = ToggleToolButton("format-text-italic")
self.button_italic.set_tooltip(_("Italic"))
self.button_italic.props.accelerator = "<Ctrl>I"
self.button_italic.connect(
"toggled", lambda button: self.edit.toggle_italic())
edit_toolbar.insert(self.button_italic, -1)
self.button_underline = ToggleToolButton("format-text-underline")
self.button_underline.set_tooltip(_("Underline"))
self.button_underline.props.accelerator = "<Ctrl>U"
self.button_underline.connect(
"toggled", lambda button: self.edit.toggle_underline())
edit_toolbar.insert(self.button_underline, -1)
separator = Gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
self.toolbar.insert(separator, -1)
stop_button = StopButton(self)
self.toolbar.insert(stop_button, -1)
self.toolbarbox.show_all()
edit_toolbar.show_all()
def __init__(self, activity):
Gtk.Toolbar.__init__(self)
self._activity = activity
self.properties = self._activity.area.tool
self._text = DrawToolButton('text', activity.tool_group, _('Type'))
self.insert(self._text, -1)
self._text.connect('clicked', self.set_tool, self._ACTION_TEXT_NAME)
separator = Gtk.SeparatorToolItem()
separator.set_draw(True)
self.insert(separator, -1)
self._bold = ToggleToolButton('format-text-bold')
self.insert(self._bold, -1)
self._bold.show()
self._bold.connect('clicked', self.__bold_bt_cb)
self._italic = ToggleToolButton('format-text-italic')
self.insert(self._italic, -1)
self._italic.show()
self._italic.connect('clicked', self.__italic_bt_cb)
separator = Gtk.SeparatorToolItem()
separator.set_draw(True)
self.insert(separator, -1)
self._font_size = FontSize()
self.insert(self._font_size, -1)
self._font_size_changed_id = self._font_size.connect(
'changed', self.__font_size_changed_cb)
self._font_combo = FontComboBox()
self._fonts_changed_id = self._font_combo.connect(
'changed', self.__font_changed_cb)
fd = activity.area.get_font_description()
font_name = fd.get_family()
self._font_combo.set_font_name(font_name)
self._font_size.set_font_size(int(fd.get_size() / Pango.SCALE))
tool_item = ToolComboBox(self._font_combo)
self.insert(tool_item, -1)
self.show_all()
def __init__(self, edit, toolbar):
self.edit = edit
logging.debug('init edit toolbar')
logging.debug(self.edit)
self.txt_toggle = ToggleToolButton('ascii')
self.img_toggle = ToggleToolButton('image')
self.jimg_toggle = ToggleToolButton('journal-image')
self.jimg_chooser_toggle = ToolButton('load-image-from-journal')
self.jtext_chooser_toggle = ToolButton('load-text-from-journal')
self.txt_toggle.set_tooltip(_('Text'))
self.txt_toggle.connect(
'toggled', self._toggle_cb,
[self.txt_toggle, self.img_toggle, self.jimg_toggle])
toolbar.insert(self.txt_toggle, -1)
self.img_toggle.set_tooltip(_('Images'))
self.img_toggle.connect(
'toggled', self._toggle_cb,
[self.txt_toggle, self.img_toggle, self.jimg_toggle])
toolbar.insert(self.img_toggle, -1)
self.jimg_toggle.set_tooltip(_('Journal Images'))
self.jimg_toggle.connect(
'toggled', self._toggle_cb,
[self.txt_toggle, self.img_toggle, self.jimg_toggle])
toolbar.insert(self.jimg_toggle, -1)
self.jimg_chooser_toggle.set_tooltip(_('Choose Journal Images'))
self.jimg_chooser_toggle.connect('clicked', self._toggle_image_chooser)
toolbar.insert(self.jimg_chooser_toggle, -1)
self.jtext_chooser_toggle.set_tooltip(_('Choose Journal Text'))
self.jtext_chooser_toggle.connect('clicked', self._toggle_text_chooser)
toolbar.insert(self.jtext_chooser_toggle, -1)
for tab in TABS:
for i in tab.toolitems:
toolbar.insert(i, -1)
self.txt_toggle.set_active(True)
def __init__(self, activity):
GObject.GObject.__init__(self)
self.activity = activity
self.toolbar = self.activity.get_toolbar_box().toolbar
self._equal_pairs = ToggleToolButton('pair-non-equals')
self._equal_pairs.set_tooltip(_('Match different tiles'))
self._equal_pairs.connect('toggled', self._emit_equal_pairs)
self.toolbar.insert(self._equal_pairs, -1)
self._grouped = ToggleToolButton('grouped_game1')
self._grouped.set_tooltip(_('Mixed tiles game'))
self._grouped.connect('toggled', self._grouped_cb)
self.toolbar.insert(self._grouped, -1)
self._clear_button = ToolButton('edit-clear')
self._clear_button.set_tooltip(_('Clear all tiles'))
self._clear_button.connect('clicked', self._clear_game_bt)
self.toolbar.insert(self._clear_button, -1)
self.toolbar.show_all()
def toggle_factory(icon_name, callback, toolbar, tooltip=None):
''' add a toggle button to a toolbar'''
t_button = ToggleToolButton(icon_name)
t_button.connect('toggled', callback)
if tooltip:
t_button.set_tooltip(tooltip)
if hasattr(toolbar, 'insert'): # the main toolbar
toolbar.insert(t_button, -1)
else: # or a secondary toolbar
toolbar.props.page.insert(t_button, -1)
t_button.show()
def __init__(self):
ToolbarBox.__init__(self)
self._mount_point = None
self._filter_type = None
self._what_filter = None
self.search_entry = iconentry.IconEntry()
self.search_entry.set_icon_from_name(iconentry.ICON_ENTRY_PRIMARY,
'entry-search')
text = _('Search in %s') % _('Journal')
self.search_entry.set_placeholder_text(text)
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.set_tooltip(_('Favorite entries'))
self._favorite_button.connect('toggled',
self.__favorite_button_toggled_cb)
self.toolbar.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.toolbar.insert(tool_item, -1)
tool_item.show()
self._when_search_combo = self._get_when_search_combo()
tool_item = ToolComboBox(self._when_search_combo)
self.toolbar.insert(tool_item, -1)
tool_item.show()
self._sorting_button = SortingButton()
self.toolbar.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):
GObject.GObject.__init__(self)
self._browser = None
self._activity = activity
self.zoomout = ToolButton('zoom-out')
self.zoomout.set_tooltip(_('Zoom out'))
self.zoomout.connect('clicked', self.__zoomout_clicked_cb)
self.insert(self.zoomout, -1)
self.zoomout.show()
self.zoomin = ToolButton('zoom-in')
self.zoomin.set_tooltip(_('Zoom in'))
self.zoomin.connect('clicked', self.__zoomin_clicked_cb)
self.insert(self.zoomin, -1)
self.zoomin.show()
self.zoom_original = ToolButton('zoom-original')
self.zoom_original.set_tooltip(_('Actual size'))
self.zoom_original.connect('clicked', self.__zoom_original_clicked_cb)
self.insert(self.zoom_original, -1)
self.zoom_original.show()
self.separator = Gtk.SeparatorToolItem()
self.separator.set_draw(True)
self.insert(self.separator, -1)
self.separator.show()
self.fullscreen = ToolButton('view-fullscreen')
self.fullscreen.set_tooltip(_('Fullscreen'))
self.fullscreen.connect('clicked', self.__fullscreen_clicked_cb)
self.insert(self.fullscreen, -1)
self.fullscreen.show()
self.traybutton = ToggleToolButton('tray-show')
self.traybutton.set_icon_name('tray-favourite')
self.traybutton.connect('toggled', self.__tray_toggled_cb)
self.traybutton.props.sensitive = False
self.traybutton.props.active = False
self.insert(self.traybutton, -1)
self.traybutton.show()
tabbed_view = self._activity.get_canvas()
if tabbed_view.get_n_pages():
self._connect_to_browser(tabbed_view.props.current_browser)
tabbed_view.connect_after('switch-page', self.__switch_page_cb)
def __init__(self, jam):
GObject.GObject.__init__(self)
def _insertSeparator(x=1):
for i in range(x):
self.separator = Gtk.SeparatorToolItem()
self.separator.set_draw(True)
self.insert(self.separator, -1)
self.separator.show()
#self.toolbox = toolbox
self.jam = jam
if Config.FEATURES_MIC:
self.micRec1Button = ToolButton('rec1')
self.micRec1Button.connect('clicked', self.jam.micRec, 'mic1')
self.insert(self.micRec1Button, -1)
self.micRec1Button.show()
self.micRec1Button.set_tooltip(_('Record microphone into slot 1'))
self.micRec2Button = ToolButton('rec2')
self.micRec2Button.connect('clicked', self.jam.micRec, 'mic2')
self.insert(self.micRec2Button, -1)
self.micRec2Button.show()
self.micRec2Button.set_tooltip(_('Record microphone into slot 2'))
self.micRec3Button = ToolButton('rec3')
self.micRec3Button.connect('clicked', self.jam.micRec, 'mic3')
self.insert(self.micRec3Button, -1)
self.micRec3Button.show()
self.micRec3Button.set_tooltip(_('Record microphone into slot 3'))
self.micRec4Button = ToolButton('rec4')
self.micRec4Button.connect('clicked', self.jam.micRec, 'mic4')
self.insert(self.micRec4Button, -1)
self.micRec4Button.show()
self.micRec4Button.set_tooltip(('Record microphone into slot 4'))
_insertSeparator()
if Config.FEATURES_NEWSOUNDS:
self._loopSettingsPalette = LoopSettingsPalette(
_('Add new Sound'), self.jam)
self.loopSetButton = ToggleToolButton('loop')
self.loopSetButton.set_palette(self._loopSettingsPalette)
self.insert(self.loopSetButton, -1)
self.loopSetButton.show()
self.show_all()
def __init__(self, handle):
activity.Activity.__init__(self, handle)
logging.debug('Starting the IRC Activity')
self.set_title(_('IRC Activity'))
self.add_events(Gdk.EventMask.VISIBILITY_NOTIFY_MASK)
self.connect('visibility-notify-event',
self.__visibility_notify_event_cb)
self.is_visible = False
self.client = purk.Client(self)
if handle.object_id is None:
self.default_config()
self.client.show()
widget = self.client.get_widget()
# CANVAS
self.set_canvas(widget)
toolbar_box = ToolbarBox()
self.activity_button = ActivityButton(self)
toolbar_box.toolbar.insert(self.activity_button, 0)
self.activity_button.show()
title_entry = TitleEntry(self)
toolbar_box.toolbar.insert(title_entry, -1)
title_entry.show()
connectionbtn = ToggleToolButton('connect')
connectionbtn.set_active(True)
connectionbtn.set_tooltip(_('Disconnect'))
connectionbtn.connect('toggled', self._connection_cb)
toolbar_box.toolbar.insert(connectionbtn, -1)
connectionbtn.show()
separator = Gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
toolbar_box.toolbar.insert(separator, -1)
separator.show()
stop_button = StopButton(self)
toolbar_box.toolbar.insert(stop_button, -1)
stop_button.show()
self.set_toolbar_box(toolbar_box)
toolbar_box.show()
def __init__(self):
GObject.GObject.__init__(self)
self._show_playlist = ToggleToolButton('view-list')
self._show_playlist.set_active(False)
self._show_playlist.set_tooltip(_('Show Playlist'))
self._show_playlist.connect('toggled', self._playlist_toggled_cb)
self.insert(self._show_playlist, -1)
self._show_playlist.show()
self._fullscreen = ToolButton('view-fullscreen')
self._fullscreen.set_tooltip(_('Fullscreen'))
self._fullscreen.connect('clicked', self._fullscreen_cb)
self.insert(self._fullscreen, -1)
self._fullscreen.show()
def __init__(self):
BaseEditToolbar.__init__(self)
self._view = None
self._find_job = None
search_item = Gtk.ToolItem()
self._search_entry = iconentry.IconEntry()
self._search_entry.set_icon_from_name(iconentry.ICON_ENTRY_PRIMARY,
'entry-search')
self._search_entry.add_clear_button()
self._search_entry.connect('activate', self._search_entry_activate_cb)
self._search_entry.connect('changed', self._search_entry_changed_cb)
self._search_entry_changed = True
width = int(Gdk.Screen.width() / 3)
self._search_entry.set_size_request(width, -1)
search_item.add(self._search_entry)
self._search_entry.show()
self.insert(search_item, -1)
search_item.show()
self._prev = ToolButton('go-previous-paired')
self._prev.set_tooltip(_('Previous'))
self._prev.props.sensitive = False
self._prev.connect('clicked', self._find_prev_cb)
self.insert(self._prev, -1)
self._prev.show()
self._next = ToolButton('go-next-paired')
self._next.set_tooltip(_('Next'))
self._next.props.sensitive = False
self._next.connect('clicked', self._find_next_cb)
self.insert(self._next, -1)
self._next.show()
separator = Gtk.SeparatorToolItem()
separator.show()
self.insert(separator, -1)
self.highlight = ToggleToolButton('format-text-underline')
self.highlight.set_tooltip(_('Highlight'))
self.highlight.props.sensitive = False
self.insert(self.highlight, -1)
def common_playback_buttons(toolbar, owner):
""" Playback and mute buttons are either on the main toolbar or
the Playback toolbar, depending upon whether or not the new
toolbars are available. """
toolbar.stopButton = ToolButton('media-playback-stop')
toolbar.stopButton.connect('clicked', owner.handleStopButton)
toolbar.insert(toolbar.stopButton, -1)
toolbar.stopButton.show()
toolbar.stopButton.set_tooltip(_('Stop Loops'))
toolbar.muteButton = ToggleToolButton('mute')
toolbar.muteButton.connect('clicked', owner.handleMuteButton)
toolbar.insert(toolbar.muteButton, -1)
toolbar.muteButton.show()
toolbar.muteButton.set_tooltip(_('Mute Loops'))
def __init__(self):
Gtk.Toolbar.__init__(self)
self._show_playlist = ToggleToolButton('view-list')
self._show_playlist.set_active(True) # due to Activity.show_all()
self._show_playlist.set_tooltip(_('Playlist'))
self._show_playlist.set_accelerator('<ctrl>l')
self._show_playlist.connect('toggled', self._playlist_toggled_cb)
self.insert(self._show_playlist, -1)
self._show_playlist.show()
self._fullscreen = ToolButton('view-fullscreen')
self._fullscreen.set_tooltip(_('Fullscreen'))
self._fullscreen.set_accelerator('<ctrl>f')
self._fullscreen.connect('clicked', self._fullscreen_cb)
self.insert(self._fullscreen, -1)
self._fullscreen.show()
def __make_toolbar(self):
self.toolbar = Gtk.Toolbar()
self.toolbar.modify_bg(Gtk.StateType.NORMAL,
style.COLOR_TOOLBAR_GREY.get_gdk_color())
self.go_up_button = ToolButton(icon_name='go-up')
self.go_up_button.props.accelerator = '<Alt>S'
self.go_up_button.set_tooltip(_('Go to pather directory'))
self.go_up_button.connect('clicked', self.go_up)
self.toolbar.insert(self.go_up_button, -1)
self.toolbar.insert(Gtk.SeparatorToolItem(), -1)
self.hidden_files_button = ToggleToolButton('show-hidden-files')
self.hidden_files_button.props.accelerator = '<Ctrl>H'
self.hidden_files_button.set_tooltip(_('Show hidden files'))
self.hidden_files_button.connect('clicked', self.__show_hidden_files)
self.toolbar.insert(self.hidden_files_button, -1)
self.toolbar.insert(Gtk.SeparatorToolItem(), -1)
item = Gtk.ToolItem()
self.entry = Gtk.Entry()
self.entry.set_size_request(300, -1)
self.entry.set_text(self.folder)
self.entry.connect('activate', self.__open_path_from_entry)
item.add(self.entry)
self.toolbar.insert(item, -1)
separator = Gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
self.toolbar.insert(separator, -1)
self.button_open = ToolButton(icon_name='fileopen')
self.button_open.set_tooltip(_('Open selected file'))
self.button_open.set_sensitive(False)
self.button_open.connect('clicked', self.__open_path)
self.toolbar.insert(self.button_open, -1)
self.close_button = ToolButton(icon_name='dialog-cancel')
self.close_button.connect('clicked', self.close)
self.toolbar.insert(self.close_button, -1)
self.vbox.pack_start(self.toolbar, False, False, 0)
def __init__(self, activity):
GObject.GObject.__init__(self)
self._activity = activity
if not speech.supported:
return
self.is_paused = False
self._cnf_client = GConf.Client.get_default()
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_toggled_handler = self.play_btn.connect(
'toggled', self.play_cb)
self.insert(self.play_btn, -1)
self.play_btn.set_tooltip(_('Play / Pause'))
# Stop button
self.stop_btn = ToolButton('media-playback-stop')
self.stop_btn.show()
self.stop_btn.connect('clicked', self.stop_cb)
self.stop_btn.set_sensitive(False)
self.insert(self.stop_btn, -1)
self.stop_btn.set_tooltip(_('Stop'))
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()
speech.reset_cb = self.reset_buttons_cb
speech.end_text_cb = self.reset_buttons_cb
def __init__(self, activity):
EditToolbar.__init__(self)
self._activity = activity
self.undo.set_tooltip(_('Undo'))
self.redo.set_tooltip(_('Redo'))
self.copy.set_tooltip(_('Copy'))
self.paste.set_tooltip(_('Paste'))
separator = Gtk.SeparatorToolItem()
separator.set_draw(True)
self.insert(separator, -1)
self._clear_all = ToolButton('edit-clear')
self.insert(self._clear_all, -1)
self._clear_all.set_tooltip(_('Clear'))
self._clear_all.show()
self._sound = ToggleToolButton('speaker-100')
self._sound.set_tooltip(_('Enable sound'))
if self._activity.area._player is not None:
self.insert(self._sound, -1)
self._sound.show()
self._sound.connect('clicked', self.__sound_cb)
self.undo.connect('clicked', self._undo_cb)
self.redo.connect('clicked', self._redo_cb)
self.copy.connect('clicked', self._copy_cb)
self.paste.connect('clicked', self._paste_cb)
self._clear_all.connect('clicked', self._clear_all_cb)
self._activity.area.connect('undo', self._on_signal_undo_cb)
self._activity.area.connect('redo', self._on_signal_redo_cb)
self._activity.area.connect('select', self._on_signal_select_cb)
self._activity.area.connect('action-saved',
self._on_signal_action_saved_cb)
def _create_montage_toolbar(self):
toolbar = Gtk.Toolbar()
playButtonImg = Gtk.Image()
playButtonImg.show()
playButtonImg.set_from_icon_name('media-playback-start',
Gtk.IconSize.LARGE_TOOLBAR)
pauseButtonImg = Gtk.Image()
pauseButtonImg.show()
pauseButtonImg.set_from_icon_name('media-playback-pause',
Gtk.IconSize.LARGE_TOOLBAR)
self.playButton = ToggleToolButton('media-playback-start')
self.playButton.connect('toggled', self.__play_cb, playButtonImg,
pauseButtonImg)
toolbar.insert(self.playButton, -1)
self.playButton.set_tooltip(_('Play / Pause'))
tempo = TempoSlider(0, 10)
tempo.adjustment.connect("value-changed", self.__tempo_cb)
tempo.set_size_request(250, -1)
tempo.set_value(5)
tempo_item = Gtk.ToolItem()
tempo_item.add(tempo)
toolbar.insert(tempo_item, -1)
separator = Gtk.SeparatorToolItem()
toolbar.insert(separator, -1)
clear_tape = ToolButton('sl-reset')
clear_tape.connect('clicked', self.__clear_tape_cb)
clear_tape.set_tooltip(_('Reset'))
toolbar.insert(clear_tape, -1)
toolbar.show_all()
return toolbar
def __make_toolbar(self):
self.toolbar = Gtk.Toolbar()
self.toolbar.modify_bg(
Gtk.StateType.NORMAL, style.COLOR_TOOLBAR_GREY.get_gdk_color())
self.toolbar.insert(self.go_up_button, -1)
self.toolbar.insert(Gtk.SeparatorToolItem(), -1)
self.hidden_files_button = ToggleToolButton("show-hidden-files")
self.hidden_files_button.props.accelerator = "<Ctrl>H"
self.hidden_files_button.set_tooltip(_("Show hidden files"))
self.hidden_files_button.connect("clicked", self.__show_hidden_files)
self.toolbar.insert(self.hidden_files_button, -1)
self.toolbar.insert(Gtk.SeparatorToolItem(), -1)
item = Gtk.ToolItem()
item.add(self.entry)
self.toolbar.insert(item, -1)
separator = Gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
self.toolbar.insert(separator, -1)
self.button_open = ToolButton(icon_name="fileopen")
self.button_open.set_tooltip(_("Open selected file"))
self.button_open.set_sensitive(False)
self.button_open.connect("clicked", self._open_path)
self.toolbar.insert(self.button_open, -1)
self.close_button = ToolButton(icon_name="dialog-cancel")
self.close_button.connect("clicked", self.close)
self.toolbar.insert(self.close_button, -1)
self.vbox.pack_start(self.toolbar, False, False, 0)
def __init__(self, handle):
activity.Activity.__init__(self, handle)
self.set_title('FotoToon')
self._max_participants = 1
self.page = None
toolbar_box = ToolbarBox()
activity_button = ActivityToolbarButton(self)
activity_toolbar = activity_button.page
toolbar_box.toolbar.insert(activity_button, 0)
edit_toolbar_btn = ToolbarButton()
edit_toolbar = Gtk.Toolbar()
edit_toolbar_btn.props.page = edit_toolbar
edit_toolbar_btn.props.icon_name = 'toolbar-edit'
edit_toolbar_btn.label = _('Edit')
toolbar_box.toolbar.insert(edit_toolbar_btn, -1)
view_toolbar_btn = ToolbarButton()
view_toolbar = Gtk.Toolbar()
view_toolbar_btn.props.page = view_toolbar
view_toolbar_btn.props.icon_name = 'toolbar-view'
view_toolbar_btn.label = _('View')
toolbar_box.toolbar.insert(view_toolbar_btn, -1)
slideview_btn = ToggleToolButton('slideshow')
slideview_btn.set_tooltip(_('Slideshow'))
slideview_btn.set_active(False)
slideview_btn.connect('clicked', self._switch_view_mode, False)
view_toolbar.insert(slideview_btn, -1)
slideview_btn.show()
slideview_timings_btn = ToggleToolButton('slideshow-stopwatch')
slideview_timings_btn.set_tooltip(_('Slideshow with Timings'))
slideview_timings_btn.set_active(False)
slideview_timings_btn.connect('clicked', self._switch_view_mode, True)
view_toolbar.insert(slideview_timings_btn, -1)
slideview_timings_btn.show()
time_button = ToolButton('stopwatch')
time_button.set_tooltip(_('Set Image Duration in Slideshow (Seconds)'))
view_toolbar.insert(time_button, -1)
time_button.show()
self._time_spin = Gtk.SpinButton.new_with_range(MIN_TIME, MAX_TIME, 1)
self._time_spin.connect('value-changed', self.__time_spin_changed_cb)
self._time_spin.props.value = DEFAULT_TIME
self._time_spin.props.update_policy = \
Gtk.SpinButtonUpdatePolicy.IF_VALID
palette = time_button.get_palette()
palette.connect('popup', self.__time_button_popup_cb)
time_button.connect(
'clicked', lambda *args: palette.popup(immediate=True,
state=Palette.SECONDARY))
alignment = Gtk.Alignment()
alignment.set_padding(style.DEFAULT_PADDING, style.DEFAULT_PADDING,
style.DEFAULT_PADDING, style.DEFAULT_PADDING)
alignment.add(self._time_spin)
self._time_spin.show()
palette.set_content(alignment)
alignment.show()
fullscreen_btn = ToolButton('view-fullscreen')
fullscreen_btn.set_tooltip(_('Fullscreen'))
fullscreen_btn.props.accelerator = '<Alt>Return'
fullscreen_btn.connect('clicked', lambda w: self.fullscreen())
view_toolbar.insert(fullscreen_btn, -1)
fullscreen_btn.show()
self.set_toolbar_box(toolbar_box)
toolbar = toolbar_box.toolbar
self.page = Page()
self.globes_manager = GlobesManager(toolbar, edit_toolbar, self)
# fonts
self._text_button = ToolbarButton()
self._text_button.props.page = TextToolbar(self.page)
self._text_button.props.icon_name = 'format-text-size'
self._text_button.props.label = _('Text')
self._toolbar_box.toolbar.insert(self._text_button, -1)
reorder_img_btn = ToolButton('thumbs-view')
reorder_img_btn.set_icon_name('thumbs-view')
reorder_img_btn.set_tooltip(_('Change image order'))
reorder_img_btn.connect('clicked', self.__image_order_cb)
edit_toolbar.insert(reorder_img_btn, -1)
reorder_img_btn.show()
bgchange = ToolButton(icon_name='contract-coordinates')
bgchange.set_tooltip(_('Edit background image'))
bgchange.connect('clicked', self.__bgchange_clicked_cb)
edit_toolbar.insert(bgchange, -1)
bgchange.show()
separator = Gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
toolbar_box.toolbar.insert(separator, -1)
stop = StopButton(self)
toolbar_box.toolbar.insert(stop, -1)
toolbar_box.show_all()
# add export button
separator_2 = Gtk.SeparatorToolItem()
separator_2.show()
activity_toolbar.insert(separator_2, -1)
self.bt_save_as_image = ToolButton()
self.bt_save_as_image.props.icon_name = 'save-as-image'
self.bt_save_as_image.connect('clicked', self.write_image)
self.bt_save_as_image.set_tooltip(_('Save as Image'))
activity_toolbar.insert(self.bt_save_as_image, -1)
self.bt_save_as_image.show()
save_as_pdf = ToolButton()
save_as_pdf.props.icon_name = 'save-as-pdf'
save_as_pdf.connect('clicked', self._save_as_pdf)
save_as_pdf.set_tooltip(_('Save as a Book (PDF)'))
activity_toolbar.insert(save_as_pdf, -1)
save_as_pdf.show()
save_as_ogg = ToolButton()
save_as_ogg.props.icon_name = 'save-as-ogg'
save_as_ogg.connect('clicked', self.__save_as_ogg_cb)
save_as_ogg.set_tooltip(_('Save as a Movie (OGG)'))
activity_toolbar.insert(save_as_ogg, -1)
Gst.init(None)
if Gst.version_string() != 'GStreamer 1.0.10':
save_as_ogg.show()
activity_button.page.title.connect("focus-in-event", self.on_title)
scrolled = Gtk.ScrolledWindow()
# scrolled.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.ALWAYS)
scrolled.add_with_viewport(self.page)
scrolled.set_kinetic_scrolling(False)
scrolled.show_all()
self._slideview = SlideView(self)
self._slideview.show_all()
self._notebook = Gtk.Notebook()
self._notebook.set_show_tabs(False)
self._notebook.append_page(scrolled, None)
self._notebook.append_page(self._slideview, None)
self._notebook.show_all()
if self._jobject.file_path is None or self._jobject.file_path == '':
empty_widget = EmptyWidget()
empty_widget.connect('choose-image', self.__add_image)
self.set_canvas(empty_widget)
else:
self.set_canvas(self._notebook)
self.show()
self.metadata['mime_type'] = 'application/x-fototoon-activity'
self.page.empty_page = handle.object_id is None
self._key_press_signal_id = None
def __init__(self):
Gtk.Toolbar.__init__(self)
self.back = ToolButton('go-previous')
self.back.set_tooltip(_('Back'))
self.back.props.sensitive = False
palette = self.back.get_palette()
self.prev_page = MenuItem(text_label=_("Previous page"))
palette.menu.append(self.prev_page)
self.prev_page.show_all()
self.prev_bookmark = MenuItem(text_label=_("Previous bookmark"))
palette.menu.append(self.prev_bookmark)
self.prev_bookmark.show_all()
self.back.connect('clicked', self.go_back_cb)
self.prev_page.connect('activate', self.go_back_cb)
self.prev_bookmark.connect('activate', self.prev_bookmark_activate_cb)
self.insert(self.back, -1)
self.back.show()
self.forward = ToolButton('go-next')
self.forward.set_tooltip(_('Forward'))
self.forward.props.sensitive = False
palette = self.forward.get_palette()
self.next_page = MenuItem(text_label=_("Next page"))
palette.menu.append(self.next_page)
self.next_page.show_all()
self.next_bookmark = MenuItem(text_label=_("Next bookmark"))
palette.menu.append(self.next_bookmark)
self.next_bookmark.show_all()
self.forward.connect('clicked', self.go_forward_cb)
self.next_page.connect('activate', self.go_forward_cb)
self.next_bookmark.connect('activate', self.next_bookmark_activate_cb)
self.insert(self.forward, -1)
self.forward.show()
num_page_item = Gtk.ToolItem()
self.num_page_entry = Gtk.Entry()
self.num_page_entry.set_text('0')
self.num_page_entry.set_alignment(1)
self.num_page_entry.connect('insert-text',
self.num_page_entry_insert_text_cb)
self.num_page_entry.connect('activate',
self.num_page_entry_activate_cb)
self.num_page_entry.set_width_chars(4)
num_page_item.add(self.num_page_entry)
self.num_page_entry.show()
self.insert(num_page_item, -1)
num_page_item.show()
total_page_item = Gtk.ToolItem()
self.total_page_label = Gtk.Label()
self.total_page_label.set_markup(
"<span size='14000' foreground='black'>")
self.total_page_label.set_text(' / 0')
total_page_item.add(self.total_page_label)
self.total_page_label.show()
self.insert(total_page_item, -1)
total_page_item.show()
spacer = Gtk.SeparatorToolItem()
self.insert(spacer, -1)
spacer.show()
bookmarkitem = Gtk.ToolItem()
self.bookmarker = ToggleToolButton('emblem-favorite')
self.bookmarker.set_tooltip(_('Toggle Bookmark'))
self.bookmarker_handler_id = self.bookmarker.connect(
'clicked', self.bookmarker_clicked_cb)
bookmarkitem.add(self.bookmarker)
self.insert(bookmarkitem, -1)
bookmarkitem.show_all()
underline_item = Gtk.ToolItem()
self.underline = ToggleToolButton('format-text-underline')
self.underline.set_tooltip(_('Underline'))
self.underline.props.sensitive = False
self.underline_id = self.underline.connect('clicked',
self.underline_cb)
underline_item.add(self.underline)
self.insert(underline_item, -1)
underline_item.show_all()
def __init__(self):
Gtk.Toolbar.__init__(self)
self.activity = None
self._speech = SpeechManager()
self._voices = self._speech.get_all_voices() # a dictionary
locale = os.environ.get('LANG', '')
language_location = locale.split('.', 1)[0].lower()
language = language_location.split('_')[0]
# if the language is es but not es_es default to es_la (latin voice)
if language == 'es' and language_location != 'es_es':
language_location = 'es_la'
self._voice = 'en_us'
if language_location in self._voices:
self._voice = language_location
elif language in self._voices:
self._voice = language
voice_names = []
for language, name in self._voices.items():
voice_names.append((language, name))
voice_names.sort()
# Play button Image
play_img = Gtk.Image()
play_img.show()
play_img.set_from_icon_name('media-playback-start',
Gtk.IconSize.LARGE_TOOLBAR)
# Pause button Image
pause_img = Gtk.Image()
pause_img.show()
pause_img.set_from_icon_name('media-playback-pause',
Gtk.IconSize.LARGE_TOOLBAR)
# Play button
self.play_button = ToggleToolButton('media-playback-start')
self.play_button.show()
self.play_button.connect('toggled', self._play_toggled_cb,
[play_img, pause_img])
self.insert(self.play_button, -1)
self.play_button.set_tooltip(_('Play / Pause'))
combo = ComboBox()
which = 0
for pair in voice_names:
language, name = pair
combo.append_item(language, name)
if language == self._voice:
combo.set_active(which)
which += 1
combo.connect('changed', self._voice_changed_cb)
combotool = ToolComboBox(combo)
self.insert(combotool, -1)
combotool.show()
self.pitchadj = Gtk.Adjustment(0, -100, 100, 1, 10, 0)
pitchbar = Gtk.HScale()
pitchbar.set_adjustment(self.pitchadj)
pitchbar.set_draw_value(False)
# pitchbar.set_update_policy(Gtk.UpdatePolicy.ALWAYS)
pitchbar.set_size_request(150, 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)
ratebar = Gtk.HScale()
ratebar.set_adjustment(self.rateadj)
ratebar.set_draw_value(False)
# ratebar.set_update_policy(Gtk.UpdatePolicy.ALWAYS)
ratebar.set_size_request(150, 15)
ratetool = Gtk.ToolItem()
ratetool.add(ratebar)
ratetool.show()
self.insert(ratetool, -1)
ratebar.show()
def build_toolbar(self):
self.max_participants = 4
toolbar_box = ToolbarBox()
activity_button = ActivityToolbarButton(self)
toolbar_box.toolbar.insert(activity_button, 0)
activity_button.show()
create_toolbar = ToolbarButton()
create_toolbar.props.page = Gtk.Toolbar()
create_toolbar.props.icon_name = 'magicpen'
create_toolbar.props.label = _('Create')
toolbar_box.toolbar.insert(create_toolbar, -1)
self._insert_create_tools(create_toolbar)
color = ColorToolButton('color')
color.connect('notify::color', self.__color_notify_cb)
toolbar_box.toolbar.insert(color, -1)
color.show()
random = ToggleToolButton('colorRandom')
random.set_tooltip(_('Toggle random color'))
toolbar_box.toolbar.insert(random, -1)
random.set_active(True)
random.connect('toggled', self.__random_toggled_cb)
random.show()
color.random = random
random.color = color
random.timeout_id = GLib.timeout_add(100, self.__timeout_cb, random)
self._insert_stop_play_button(toolbar_box.toolbar)
clear_trace = ToolButton('clear-trace')
clear_trace.set_tooltip(_('Clear Trace Marks'))
clear_trace.set_accelerator(_('<ctrl>x'))
clear_trace.connect('clicked', self.clear_trace_cb)
clear_trace.set_sensitive(False)
toolbar_box.toolbar.insert(clear_trace, -1)
clear_trace.show()
self.clear_trace = clear_trace
self._insert_clear_all_button(toolbar_box.toolbar)
load_example = ToolButton('load-sample')
load_example.set_tooltip(_('Show sample projects'))
load_example.connect('clicked', self._create_store)
toolbar_box.toolbar.insert(Gtk.SeparatorToolItem(), -1)
toolbar_box.toolbar.insert(load_example, -1)
load_example.show()
separator = Gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_size_request(0, -1)
separator.set_expand(True)
toolbar_box.toolbar.insert(separator, -1)
separator.show()
stop = StopButton(self)
toolbar_box.toolbar.insert(stop, -1)
stop.show()
separator = Gtk.SeparatorToolItem()
activity_button.props.page.insert(separator, -1)
separator.show()
export_json = ToolButton('save-as-json')
export_json.set_tooltip(_('Export tracked objects to journal'))
export_json.connect('clicked', self._export_json_cb)
activity_button.props.page.insert(export_json, -1)
export_json.show()
load_project = ToolButton('load-project')
load_project.set_tooltip(_('Load project from journal'))
load_project.connect('clicked', self._load_project)
activity_button.props.page.insert(load_project, -1)
load_project.show()
self.set_toolbar_box(toolbar_box)
toolbar_box.show_all()
create_toolbar.set_expanded(True)
return toolbar_box
