def setup_toolbar(self):
'''Setup the top toolbar. Groupthink needs some work here.'''
toolbar_box = ToolbarBox()
activity_button = ActivityToolbarButton(self)
toolbar_box.toolbar.insert(activity_button, 0)
activity_button.show()
self.edit_toolbar = EditToolbar()
edit_toolbar_button = ToolbarButton(page=self.edit_toolbar,
icon_name='toolbar-edit')
self.edit_toolbar.show()
toolbar_box.toolbar.insert(edit_toolbar_button, -1)
edit_toolbar_button.show()
self.edit_toolbar.undo.connect('clicked', self.undobutton_cb)
self.edit_toolbar.redo.connect('clicked', self.redobutton_cb)
self.edit_toolbar.copy.connect('clicked', self.copybutton_cb)
self.edit_toolbar.paste.connect('clicked', self.pastebutton_cb)
separator = gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
toolbar_box.toolbar.insert(separator, -1)
separator.show()
stop_button = StopButton(self)
stop_button.props.accelerator = '<Ctrl><Shift>Q'
toolbar_box.toolbar.insert(stop_button, -1)
stop_button.show()
self.set_toolbar_box(toolbar_box)
toolbar_box.show()
def __init__(self, activity, **kwargs):
print "MY Alternative tOOLbARbUTTON init\n"
toolbar = ActivityToolbar(activity, orientation_left=True)
toolbar.stop.hide()
toolbar.keep.hide()
ToolbarButton.__init__(self, page=toolbar, **kwargs)
icon = _create_activity_icon(activity.metadata)
self.set_icon_widget(icon)
icon.show()
def build_colors_toolbar(self, toolbox):
barra_colors = gtk.Toolbar()
item1 = gtk.ToolItem()
label1 = gtk.Label()
label1.set_text(_('Color mode') + ' ')
item1.add(label1)
barra_colors.insert(item1, -1)
item2 = gtk.ToolItem()
modes = ('RGB', 'YUV', 'HSV')
combo = Combo(modes)
item2.add(combo)
combo.connect('changed', self.change_combo)
barra_colors.insert(item2, -1)
separator1 = gtk.SeparatorToolItem()
separator1.props.draw = True
barra_colors.insert(separator1, -1)
item_l = gtk.ToolItem()
label4 = gtk.Label()
label4.set_text(_('Brightness') + ' ')
item_l.add(label4)
barra_colors.insert(item_l, -1)
item = gtk.ToolItem()
brightness_spin = gtk.SpinButton()
brightness_spin.set_range(-1, 255)
brightness_spin.set_increments(1, 10)
brightness_spin.props.value = int(self.brightness)
brightness_spin.connect('notify::value', self.brightness_spin_change)
item.add(brightness_spin)
barra_colors.insert(item, -1)
separator2 = gtk.SeparatorToolItem()
separator2.props.draw = True
barra_colors.insert(separator2, -1)
item3 = gtk.ToolItem()
label3 = gtk.Label()
label3.set_text(_('Show threshold view'))
item3.add(label3)
barra_colors.insert(item3, -1)
threshold_view = ToolButton('media-playback-stop')
threshold_view.connect('clicked', self.threshold_view)
threshold_view.set_tooltip(_('Yes'))
barra_colors.insert(threshold_view, -1)
barra_colors.show_all()
colors_button = ToolbarButton(label=_('Colors'),
page=barra_colors,
icon_name='toolbar-colors')
toolbox.toolbar.insert(colors_button, -1)
colors_button.show()
def addToolBarButton(self, nameID, icon_name, toolbar=None):
"I wonder if this can be merged with the ad button below?"
button = ToolbarButton(
page=toolbar,
icon_name=icon_name)
self.toolbar_box.toolbar.insert(button, -1)
button.show()
toolbar.show()
self.nameID.update({nameID:button})
def __init__(self, activity, **kwargs):
toolbar = ActivityToolbar(activity, orientation_left=True)
toolbar.stop.hide()
ToolbarButton.__init__(self, page=toolbar, **kwargs)
icon = _create_activity_icon(activity.metadata)
self.set_icon_widget(icon)
icon.show()
def __init__(self, activity, **kwargs):
toolbar = ActivityToolbar(activity, orientation_left=True)
toolbar.stop.hide()
ToolbarButton.__init__(self, page=toolbar, **kwargs)
icon = _create_activity_icon(activity.metadata)
self.set_icon_widget(icon)
icon.show()
def build_birth_toolbar(self, toolbox):
birth_bar = gtk.Toolbar()
item1 = gtk.ToolItem()
self.label_birth = gtk.Label()
self.label_birth.set_text(_('Birth:') + ' ' + _('Day') + ' ')
item1.add(self.label_birth)
birth_bar.insert(item1, -1)
item2 = gtk.ToolItem()
self.day_birth_spin = gtk.SpinButton()
self.day_birth_spin.set_range(1, 31)
self.day_birth_spin.set_increments(1, 5)
self.day_birth_spin.props.value = 10
self.day_birth_spin.connect('notify::value', self.day_birth_change)
item2.add(self.day_birth_spin)
birth_bar.insert(item2, -1)
item3 = gtk.ToolItem()
self.label_birth_month = gtk.Label()
self.label_birth_month.set_text(' ' + _('Month') + ' ')
item3.add(self.label_birth_month)
birth_bar.insert(item3, -1)
item4 = gtk.ToolItem()
self.month_birth_spin = gtk.SpinButton()
self.month_birth_spin.set_range(1, 12)
self.month_birth_spin.set_increments(1, 4)
self.month_birth_spin.props.value = 2
self.month_birth_spin.connect('notify::value', self.month_birth_change)
item4.add(self.month_birth_spin)
birth_bar.insert(item4, -1)
item5 = gtk.ToolItem()
self.label_birth_year = gtk.Label()
self.label_birth_year.set_text(' ' + _('Year') + ' ')
item5.add(self.label_birth_year)
birth_bar.insert(item5, -1)
item6 = gtk.ToolItem()
self.year_birth_spin = gtk.SpinButton()
self.year_birth_spin.set_range(1900, self._now.year)
self.year_birth_spin.set_increments(1, 10)
self.year_birth_spin.props.value = 1990
self.year_birth_spin.connect('notify::value', self.year_birth_change)
item6.add(self.year_birth_spin)
birth_bar.insert(item6, -1)
birth_bar.show_all()
birth_button = ToolbarButton(label=_('Birth'),
page=birth_bar,
icon_name='write-date')
toolbox.toolbar.insert(birth_button, -1)
birth_button.show()
def build_birth_toolbar(self, toolbox):
birth_bar = gtk.Toolbar()
item1 = gtk.ToolItem()
self.label_birth = gtk.Label()
self.label_birth.set_text(_('Birth:') + ' ' + _('Day') + ' ')
item1.add(self.label_birth)
birth_bar.insert(item1, -1)
item2 = gtk.ToolItem()
self.day_birth_spin = gtk.SpinButton()
self.day_birth_spin.set_range(1, 31)
self.day_birth_spin.set_increments(1, 5)
self.day_birth_spin.props.value = 10
self.day_birth_spin.connect('notify::value', self.day_birth_change)
item2.add(self.day_birth_spin)
birth_bar.insert(item2, -1)
item3 = gtk.ToolItem()
self.label_birth_month = gtk.Label()
self.label_birth_month.set_text(' ' + _('Month') + ' ')
item3.add(self.label_birth_month)
birth_bar.insert(item3, -1)
item4 = gtk.ToolItem()
self.month_birth_spin = gtk.SpinButton()
self.month_birth_spin.set_range(1, 12)
self.month_birth_spin.set_increments(1, 4)
self.month_birth_spin.props.value = 2
self.month_birth_spin.connect('notify::value', self.month_birth_change)
item4.add(self.month_birth_spin)
birth_bar.insert(item4, -1)
item5 = gtk.ToolItem()
self.label_birth_year = gtk.Label()
self.label_birth_year.set_text(' ' + _('Year') + ' ')
item5.add(self.label_birth_year)
birth_bar.insert(item5, -1)
item6 = gtk.ToolItem()
self.year_birth_spin = gtk.SpinButton()
self.year_birth_spin.set_range(1900, self._now.year)
self.year_birth_spin.set_increments(1, 10)
self.year_birth_spin.props.value = 1990
self.year_birth_spin.connect('notify::value', self.year_birth_change)
item6.add(self.year_birth_spin)
birth_bar.insert(item6, -1)
birth_bar.show_all()
birth_button = ToolbarButton(label=_('Birth'),
page=birth_bar,
icon_name='write-date')
toolbox.toolbar.insert(birth_button, -1)
birth_button.show()
def build_today_toolbar(self, toolbox):
today_bar = gtk.Toolbar()
item1 = gtk.ToolItem()
self.label_today = gtk.Label()
self.label_today.set_text(_('Today:') + ' ' + _('Day') + ' ')
item1.add(self.label_today)
today_bar.insert(item1, -1)
item2 = gtk.ToolItem()
self.day_today_spin = gtk.SpinButton()
self.day_today_spin.set_range(1, 31)
self.day_today_spin.set_increments(1, 5)
self.day_today_spin.props.value = self._today[0]
self.day_today_spin.connect('notify::value', self.day_today_change)
item2.add(self.day_today_spin)
today_bar.insert(item2, -1)
item3 = gtk.ToolItem()
self.label_today_month = gtk.Label()
self.label_today_month.set_text(' ' + _('Month') + ' ')
item3.add(self.label_today_month)
today_bar.insert(item3, -1)
item4 = gtk.ToolItem()
self.month_today_spin = gtk.SpinButton()
self.month_today_spin.set_range(1, 12)
self.month_today_spin.set_increments(1, 4)
self.month_today_spin.props.value = self._today[1]
self.month_today_spin.connect('notify::value', self.month_today_change)
item4.add(self.month_today_spin)
today_bar.insert(item4, -1)
item5 = gtk.ToolItem()
self.label_today_year = gtk.Label()
self.label_today_year.set_text(' ' + _('Year') + ' ')
item5.add(self.label_today_year)
today_bar.insert(item5, -1)
item6 = gtk.ToolItem()
self.year_today_spin = gtk.SpinButton()
self.year_today_spin.set_range(1900, self._now.year + 1)
self.year_today_spin.set_increments(1, 10)
self.year_today_spin.props.value = self._today[2]
self.year_today_spin.connect('notify::value', self.year_today_change)
item6.add(self.year_today_spin)
today_bar.insert(item6, -1)
today_bar.show_all()
today_button = ToolbarButton(label=_('Today'),
page=today_bar,
icon_name='write-time')
toolbox.toolbar.insert(today_button, -1)
today_button.show()
def build_today_toolbar(self, toolbox):
today_bar = gtk.Toolbar()
item1 = gtk.ToolItem()
self.label_today = gtk.Label()
self.label_today.set_text(_('Today:') + ' ' + _('Day') + ' ')
item1.add(self.label_today)
today_bar.insert(item1, -1)
item2 = gtk.ToolItem()
self.day_today_spin = gtk.SpinButton()
self.day_today_spin.set_range(1, 31)
self.day_today_spin.set_increments(1, 5)
self.day_today_spin.props.value = self._today[0]
self.day_today_spin.connect('notify::value', self.day_today_change)
item2.add(self.day_today_spin)
today_bar.insert(item2, -1)
item3 = gtk.ToolItem()
self.label_today_month = gtk.Label()
self.label_today_month.set_text(' ' + _('Month') + ' ')
item3.add(self.label_today_month)
today_bar.insert(item3, -1)
item4 = gtk.ToolItem()
self.month_today_spin = gtk.SpinButton()
self.month_today_spin.set_range(1, 12)
self.month_today_spin.set_increments(1, 4)
self.month_today_spin.props.value = self._today[1]
self.month_today_spin.connect('notify::value', self.month_today_change)
item4.add(self.month_today_spin)
today_bar.insert(item4, -1)
item5 = gtk.ToolItem()
self.label_today_year = gtk.Label()
self.label_today_year.set_text(' ' + _('Year') + ' ')
item5.add(self.label_today_year)
today_bar.insert(item5, -1)
item6 = gtk.ToolItem()
self.year_today_spin = gtk.SpinButton()
self.year_today_spin.set_range(1900, self._now.year + 1)
self.year_today_spin.set_increments(1, 10)
self.year_today_spin.props.value = self._today[2]
self.year_today_spin.connect('notify::value', self.year_today_change)
item6.add(self.year_today_spin)
today_bar.insert(item6, -1)
today_bar.show_all()
today_button = ToolbarButton(label=_('Today'),
page=today_bar,
icon_name='write-time')
toolbox.toolbar.insert(today_button, -1)
today_button.show()
def build_resolution_toolbar(self, toolbox):
resolution_bar = gtk.Toolbar()
item1 = gtk.ToolItem()
label1 = gtk.Label()
label1.set_text(' ' + _('Show size') + ' ')
item1.add(label1)
resolution_bar.insert(item1, -1)
item2 = gtk.ToolItem()
x_size_spin = gtk.SpinButton()
x_size_spin.set_range(160, 1200)
x_size_spin.set_increments(1, 10)
x_size_spin.props.value = int(self.show_size[0])
x_size_spin.connect('notify::value', self.x_size_spin_change)
item2.add(x_size_spin)
resolution_bar.insert(item2, -1)
item3 = gtk.ToolItem()
label3 = gtk.Label()
label3.set_text(' X ')
item3.add(label3)
resolution_bar.insert(item3, -1)
item4 = gtk.ToolItem()
y_size_spin = gtk.SpinButton()
y_size_spin.set_range(120, 900)
y_size_spin.set_increments(1, 10)
y_size_spin.props.value = int(self.show_size[1])
y_size_spin.connect('notify::value', self.y_size_spin_change)
item4.add(y_size_spin)
resolution_bar.insert(item4, -1)
separator1 = gtk.SeparatorToolItem()
separator1.props.draw = True
resolution_bar.insert(separator1, -1)
item5 = gtk.ToolItem()
label5 = gtk.Label()
label5.set_text(' ' + _('Show grid'))
item5.add(label5)
resolution_bar.insert(item5, -1)
grid = ToolButton('grid-icon')
grid.connect('clicked', self.grid_click)
resolution_bar.insert(grid, -1)
resolution_bar.show_all()
resolution_button = ToolbarButton(label=_('Resolution'),
page=resolution_bar,
icon_name='camera')
toolbox.toolbar.insert(resolution_button, -1)
resolution_button.show()
def build_resolution_toolbar(self, toolbox):
resolution_bar = gtk.Toolbar()
item1 = gtk.ToolItem()
label1 = gtk.Label()
label1.set_text(' ' + _('Show size') + ' ')
item1.add(label1)
resolution_bar.insert(item1, -1)
item2 = gtk.ToolItem()
x_size_spin = gtk.SpinButton()
x_size_spin.set_range(160, 1200)
x_size_spin.set_increments(1, 10)
x_size_spin.props.value = int(self.show_size[0])
x_size_spin.connect('notify::value', self.x_size_spin_change)
item2.add(x_size_spin)
resolution_bar.insert(item2, -1)
item3 = gtk.ToolItem()
label3 = gtk.Label()
label3.set_text(' X ')
item3.add(label3)
resolution_bar.insert(item3, -1)
item4 = gtk.ToolItem()
y_size_spin = gtk.SpinButton()
y_size_spin.set_range(120, 900)
y_size_spin.set_increments(1, 10)
y_size_spin.props.value = int(self.show_size[1])
y_size_spin.connect('notify::value', self.y_size_spin_change)
item4.add(y_size_spin)
resolution_bar.insert(item4, -1)
separator1 = gtk.SeparatorToolItem()
separator1.props.draw = True
resolution_bar.insert(separator1, -1)
item5 = gtk.ToolItem()
label5 = gtk.Label()
label5.set_text(' ' + _('Show grid'))
item5.add(label5)
resolution_bar.insert(item5, -1)
grid = ToolButton('grid-icon')
grid.connect('clicked', self.grid_click)
resolution_bar.insert(grid, -1)
resolution_bar.show_all()
resolution_button = ToolbarButton(label=_('Resolution'),
page=resolution_bar,
icon_name='camera')
toolbox.toolbar.insert(resolution_button, -1)
resolution_button.show()
def build_size_toolbar(self, toolbox):
size_bar = gtk.Toolbar()
#Horizontal
item1 = gtk.ToolItem()
label1 = gtk.Label()
label1.set_text(' %s ' % _('H'))
item1.add(label1)
size_bar.insert(item1, -1)
item2 = gtk.ToolItem()
self.h_spin = gtk.SpinButton()
self.h_spin.set_range(2, 30)
self.h_spin.set_increments(1, 2)
self.h_spin.props.value = self.game_size[0]
self.h_spin.connect('notify::value', self.h_spin_change)
item2.add(self.h_spin)
size_bar.insert(item2, -1)
#Vertical
item3 = gtk.ToolItem()
label2 = gtk.Label()
label2.set_text(' %s ' % _('V'))
item3.add(label2)
size_bar.insert(item3, -1)
item4 = gtk.ToolItem()
self.v_spin = gtk.SpinButton()
self.v_spin.set_range(2, 20)
self.v_spin.set_increments(1, 2)
self.v_spin.props.value = self.game_size[1]
self.v_spin.connect('notify::value', self.v_spin_change)
item4.add(self.v_spin)
size_bar.insert(item4, -1)
size_bar.show_all()
size_button = ToolbarButton(label=_('Board size'),
page=size_bar,
icon_name='preferences-system')
toolbox.toolbar.insert(size_button, -1)
size_button.show()
def _setup_toolbars(self):
''' Add buttons to toolbars '''
custom_toolbar = gtk.Toolbar()
if HAS_TOOLBARBOX:
toolbox = ToolbarBox()
self.toolbar = toolbox.toolbar
activity_button = ActivityToolbarButton(self)
self.toolbar.insert(activity_button, 0)
activity_button.show()
custom_toolbar_button = ToolbarButton(
label=_('Custom'),
page=custom_toolbar,
icon_name='view-source')
custom_toolbar.show()
self.toolbar.insert(custom_toolbar_button, -1)
custom_toolbar_button.show()
self._load_standard_buttons(self.toolbar)
separator_factory(self.toolbar, expand=True, visible=False)
stop_button = StopButton(self)
stop_button.props.accelerator = _('<Ctrl>Q')
self.toolbar.insert(stop_button, -1)
stop_button.show()
self.set_toolbox(toolbox)
toolbox.show()
else:
toolbox = activity.ActivityToolbox(self)
self.set_toolbox(toolbox)
self.toolbar = gtk.Toolbar()
toolbox.add_toolbar(_('Project'), self.toolbar)
toolbox.add_toolbar(_('Custom'), custom_toolbar)
self._load_standard_buttons(self.toolbar)
self._load_custom_buttons(custom_toolbar)
def __init__(self, toolbar):
self._timer_combo = TimerCombo()
toolbar.insert(self._timer_combo, -1)
self._duration_combo = DurationCombo()
toolbar.insert(self._duration_combo, -1)
preferences_toolbar = gtk.Toolbar()
combo = gtk.combo_box_new_text()
self.quality = ToolComboBox(combo=combo, label_text=_('Quality:'))
self.quality.combo.append_text(_('Low'))
if hw.get_xo_version() != 1:
# Disable High quality on XO-1. The system simply isn't beefy
# enough for recording to work well.
self.quality.combo.append_text(_('High'))
self.quality.combo.set_active(0)
self.quality.show_all()
preferences_toolbar.insert(self.quality, -1)
preferences_button = ToolbarButton()
preferences_button.set_page(preferences_toolbar)
preferences_button.props.icon_name = 'preferences-system'
preferences_button.props.label = _('Preferences')
toolbar.insert(preferences_button, -1)
def __init__(self, handle):
activity.Activity.__init__(self, handle)
if HASTOOLBARBOX:
self.max_participants = 1
toolbar_box = ToolbarBox()
self.set_toolbar_box(toolbar_box)
activity_button = ActivityToolbarButton(self)
toolbar_box.toolbar.insert(activity_button, 0)
separator = gtk.SeparatorToolItem()
separator.props.draw = True
activity_button.props.page.insert(separator, -1)
separator.show()
tool = ToolButton('pdf-export')
tool.set_tooltip(_('Portable Document Format (PDF)'))
tool.connect('clicked', self.__export_pdf_cb)
activity_button.props.page.insert(tool, -1)
tool.show()
tool = ToolButton('png-export')
tool.set_tooltip(_('Portable Network Graphic (PNG)'))
tool.connect('clicked', self.__export_png_cb)
activity_button.props.page.insert(tool, -1)
tool.show()
tool = ToolbarButton()
self.edit_toolbar = EditToolbar(self)
tool.props.page = self.edit_toolbar
tool.props.icon_name = 'toolbar-edit'
tool.props.label = _('Edit'),
toolbar_box.toolbar.insert(tool, -1)
self._undo = UndoManager.UndoManager(self,
self.edit_toolbar.undo.child,
self.edit_toolbar.redo.child)
self.__build_main_canvas_area()
tool = ToolbarButton()
tool.props.page = ViewToolbar(self._main_area)
tool.props.icon_name = 'toolbar-view'
tool.props.label = _('View'),
toolbar_box.toolbar.insert(tool, -1)
tool = ToolbarButton()
self.text_format_toolbar = TextAttributesToolbar(self._main_area)
tool.props.page = self.text_format_toolbar
tool.props.icon_name = 'toolbar-text'
tool.props.label = _('Text')
toolbar_box.toolbar.insert(tool, -1)
# self._main_area.set_text_attributes(self.text_format_toolbar)
self.thought_toolbar = ToolbarButton()
self.thought_toolbar.props.page = ThoughtsToolbar(self)
self.thought_toolbar.props.icon_name = 'thought'
self.thought_toolbar.props.label = _('Thought Type')
toolbar_box.toolbar.insert(self.thought_toolbar, -1)
self.action_buttons = ActionButtons(self)
toolbar_box.show_all()
else:
# Use old <= 0.84 toolbar design
toolbox = activity.ActivityToolbox(self)
self.set_toolbox(toolbox)
activity_toolbar = toolbox.get_activity_toolbar()
keep_palette = activity_toolbar.keep.get_palette()
menu_item = MenuItem(_('Portable Document Format (PDF)'))
menu_item.connect('activate', self.__export_pdf_cb)
keep_palette.menu.append(menu_item)
menu_item.show()
menu_item = MenuItem(_('Portable Network Graphic (PNG)'))
menu_item.connect('activate', self.__export_png_cb)
keep_palette.menu.append(menu_item)
menu_item.show()
self.edit_toolbar = EditToolbar(self)
toolbox.add_toolbar(_('Edit'), self.edit_toolbar)
separator = gtk.SeparatorToolItem()
self.edit_toolbar.insert(separator, 0)
self.edit_toolbar.show()
self._undo = UndoManager.UndoManager(self,
self.edit_toolbar.undo.child,
self.edit_toolbar.redo.child)
self.__build_main_canvas_area()
view_toolbar = ViewToolbar(self._main_area)
toolbox.add_toolbar(_('View'), view_toolbar)
activity_toolbar = toolbox.get_activity_toolbar()
activity_toolbar.share.props.visible = False
toolbox.set_current_toolbar(1)
self.show_all()
self.__configure_cb(None)
self._mode = MMapArea.MODE_TEXT
self._main_area.set_mode(self._mode)
self.set_focus_child(self._main_area)
def __init__(self, handle):
super(SpeakActivity, self).__init__(handle)
self._notebook = gtk.Notebook()
self.set_canvas(self._notebook)
self._notebook.show()
self._colors = profile.get_color().to_string().split(',')
lighter = style.Color(self._colors[
_lighter_color(self._colors)])
self._mode = MODE_TYPE
self._tablet_mode = _is_tablet_mode()
self._robot_idle_id = None
self._active_eyes = None
self._active_number_of_eyes = None
self._current_voice = None
# make an audio device for playing back and rendering audio
self.connect('notify::active', self._active_cb)
self._cfg = {}
# make a box to type into
hbox = gtk.HBox()
if self._tablet_mode:
self._entry = gtk.Entry()
hbox.pack_start(self._entry, expand=True)
talk_button = ToolButton('microphone')
talk_button.set_tooltip(_('Speak'))
talk_button.connect('clicked', self._talk_cb)
hbox.pack_end(talk_button, expand=False)
else:
self._entrycombo = gtk.combo_box_entry_new_text()
self._entrycombo.connect('changed', self._combo_changed_cb)
self._entry = self._entrycombo.child
self._entry.set_size_request(-1, style.GRID_CELL_SIZE)
hbox.pack_start(self._entrycombo, expand=True)
self._entry.set_editable(True)
self._entry.connect('activate', self._entry_activate_cb)
self._entry.connect('key-press-event', self._entry_key_press_cb)
self._entry.modify_font(pango.FontDescription(str='sans bold 24'))
hbox.show()
self.face = face.View(fill_color=lighter)
self.face.set_size_request(
-1, gtk.gdk.screen_height() - 2 * style.GRID_CELL_SIZE)
self.face.show()
# layout the screen
box = gtk.VBox(homogeneous=False)
if self._tablet_mode:
box.pack_start(hbox, expand=False)
box.pack_start(self.face)
else:
box.pack_start(self.face, expand=True)
box.pack_start(hbox)
self.add_events(gtk.gdk.POINTER_MOTION_HINT_MASK
| gtk.gdk.POINTER_MOTION_MASK)
self.connect('motion_notify_event', self._mouse_moved_cb)
box.add_events(gtk.gdk.BUTTON_PRESS_MASK)
box.connect('button_press_event', self._mouse_clicked_cb)
# desktop
self._notebook.show()
self._notebook.props.show_border = False
self._notebook.props.show_tabs = False
box.show_all()
self._notebook.append_page(box)
self._chat = chat.View()
self._chat.show_all()
self._notebook.append_page(self._chat)
# make the text box active right away
if not self._tablet_mode:
self._entry.grab_focus()
self._entry.connect('move-cursor', self._cursor_moved_cb)
self._entry.connect('changed', self._cursor_moved_cb)
toolbox = ToolbarBox()
self._activity_button = ActivityToolbarButton(self)
self._activity_button.connect('clicked', self._configure_cb)
toolbox.toolbar.insert(self._activity_button, -1)
mode_type = RadioToolButton(
named_icon='mode-type',
tooltip=_('Type something to hear it'))
mode_type.connect('toggled', self.__toggled_mode_type_cb)
toolbox.toolbar.insert(mode_type, -1)
mode_robot = RadioToolButton(
named_icon='mode-robot',
group=mode_type,
tooltip=_('Ask robot any question'))
mode_robot.connect('toggled', self.__toggled_mode_robot_cb)
toolbox.toolbar.insert(mode_robot, -1)
self._mode_chat = RadioToolButton(
named_icon='mode-chat',
group=mode_type,
tooltip=_('Voice chat'))
self._mode_chat.connect('toggled', self.__toggled_mode_chat_cb)
toolbox.toolbar.insert(self._mode_chat, -1)
self._voice_button = ToolbarButton(
page=self._make_voice_bar(),
label=_('Voice'),
icon_name='voice')
self._voice_button.connect('clicked', self._configure_cb)
toolbox.toolbar.insert(self._voice_button, -1)
self._face_button = ToolbarButton(
page=self._make_face_bar(),
label=_('Face'),
icon_name='face')
self._face_button.connect('clicked', self._configure_cb)
toolbox.toolbar.insert(self._face_button, -1)
separator = gtk.SeparatorToolItem()
separator.set_draw(False)
separator.set_expand(True)
toolbox.toolbar.insert(separator, -1)
toolbox.toolbar.insert(StopButton(self), -1)
toolbox.show_all()
self.toolbar_box = toolbox
gtk.gdk.screen_get_default().connect('size-changed',
self._configure_cb)
self._first_time = True
self._new_instance()
self._configure_cb()
self._poll_accelerometer()
if self.shared_activity:
# we are joining the activity
self.connect('joined', self._joined_cb)
if self.get_shared():
# we have already joined
self._joined_cb(self)
self._mode_chat.set_active(True)
self._setup_chat_mode()
elif handle.uri:
# XMPP non-sugar3 incoming chat, not sharable
self._activity_button.props.page.share.props.visible = \
False
self._one_to_one_connection(handle.uri)
else:
# we are creating the activity
self.connect('shared', self._shared_cb)
class SpeakActivity(activity.Activity):
def __init__(self, handle):
super(SpeakActivity, self).__init__(handle)
self._notebook = gtk.Notebook()
self.set_canvas(self._notebook)
self._notebook.show()
self._colors = profile.get_color().to_string().split(',')
lighter = style.Color(self._colors[
_lighter_color(self._colors)])
self._mode = MODE_TYPE
self._tablet_mode = _is_tablet_mode()
self._robot_idle_id = None
self._active_eyes = None
self._active_number_of_eyes = None
self._current_voice = None
# make an audio device for playing back and rendering audio
self.connect('notify::active', self._active_cb)
self._cfg = {}
# make a box to type into
hbox = gtk.HBox()
if self._tablet_mode:
self._entry = gtk.Entry()
hbox.pack_start(self._entry, expand=True)
talk_button = ToolButton('microphone')
talk_button.set_tooltip(_('Speak'))
talk_button.connect('clicked', self._talk_cb)
hbox.pack_end(talk_button, expand=False)
else:
self._entrycombo = gtk.combo_box_entry_new_text()
self._entrycombo.connect('changed', self._combo_changed_cb)
self._entry = self._entrycombo.child
self._entry.set_size_request(-1, style.GRID_CELL_SIZE)
hbox.pack_start(self._entrycombo, expand=True)
self._entry.set_editable(True)
self._entry.connect('activate', self._entry_activate_cb)
self._entry.connect('key-press-event', self._entry_key_press_cb)
self._entry.modify_font(pango.FontDescription(str='sans bold 24'))
hbox.show()
self.face = face.View(fill_color=lighter)
self.face.set_size_request(
-1, gtk.gdk.screen_height() - 2 * style.GRID_CELL_SIZE)
self.face.show()
# layout the screen
box = gtk.VBox(homogeneous=False)
if self._tablet_mode:
box.pack_start(hbox, expand=False)
box.pack_start(self.face)
else:
box.pack_start(self.face, expand=True)
box.pack_start(hbox)
self.add_events(gtk.gdk.POINTER_MOTION_HINT_MASK
| gtk.gdk.POINTER_MOTION_MASK)
self.connect('motion_notify_event', self._mouse_moved_cb)
box.add_events(gtk.gdk.BUTTON_PRESS_MASK)
box.connect('button_press_event', self._mouse_clicked_cb)
# desktop
self._notebook.show()
self._notebook.props.show_border = False
self._notebook.props.show_tabs = False
box.show_all()
self._notebook.append_page(box)
self._chat = chat.View()
self._chat.show_all()
self._notebook.append_page(self._chat)
# make the text box active right away
if not self._tablet_mode:
self._entry.grab_focus()
self._entry.connect('move-cursor', self._cursor_moved_cb)
self._entry.connect('changed', self._cursor_moved_cb)
toolbox = ToolbarBox()
self._activity_button = ActivityToolbarButton(self)
self._activity_button.connect('clicked', self._configure_cb)
toolbox.toolbar.insert(self._activity_button, -1)
mode_type = RadioToolButton(
named_icon='mode-type',
tooltip=_('Type something to hear it'))
mode_type.connect('toggled', self.__toggled_mode_type_cb)
toolbox.toolbar.insert(mode_type, -1)
mode_robot = RadioToolButton(
named_icon='mode-robot',
group=mode_type,
tooltip=_('Ask robot any question'))
mode_robot.connect('toggled', self.__toggled_mode_robot_cb)
toolbox.toolbar.insert(mode_robot, -1)
self._mode_chat = RadioToolButton(
named_icon='mode-chat',
group=mode_type,
tooltip=_('Voice chat'))
self._mode_chat.connect('toggled', self.__toggled_mode_chat_cb)
toolbox.toolbar.insert(self._mode_chat, -1)
self._voice_button = ToolbarButton(
page=self._make_voice_bar(),
label=_('Voice'),
icon_name='voice')
self._voice_button.connect('clicked', self._configure_cb)
toolbox.toolbar.insert(self._voice_button, -1)
self._face_button = ToolbarButton(
page=self._make_face_bar(),
label=_('Face'),
icon_name='face')
self._face_button.connect('clicked', self._configure_cb)
toolbox.toolbar.insert(self._face_button, -1)
separator = gtk.SeparatorToolItem()
separator.set_draw(False)
separator.set_expand(True)
toolbox.toolbar.insert(separator, -1)
toolbox.toolbar.insert(StopButton(self), -1)
toolbox.show_all()
self.toolbar_box = toolbox
gtk.gdk.screen_get_default().connect('size-changed',
self._configure_cb)
self._first_time = True
self._new_instance()
self._configure_cb()
self._poll_accelerometer()
if self.shared_activity:
# we are joining the activity
self.connect('joined', self._joined_cb)
if self.get_shared():
# we have already joined
self._joined_cb(self)
self._mode_chat.set_active(True)
self._setup_chat_mode()
elif handle.uri:
# XMPP non-sugar3 incoming chat, not sharable
self._activity_button.props.page.share.props.visible = \
False
self._one_to_one_connection(handle.uri)
else:
# we are creating the activity
self.connect('shared', self._shared_cb)
def _toolbar_expanded(self):
if self._activity_button.is_expanded():
return True
if self._voice_button.is_expanded():
return True
if self._face_button.is_expanded():
return True
return False
def _configure_cb(self, event=None):
self._entry.set_size_request(-1, style.GRID_CELL_SIZE)
if self._toolbar_expanded():
self.face.set_size_request(
-1, gtk.gdk.screen_height() - 3 * style.GRID_CELL_SIZE)
self._chat.resize_chat_box(expanded=True)
self._chat.resize_buddy_list()
else:
self.face.set_size_request(
-1, gtk.gdk.screen_height() - 2 * style.GRID_CELL_SIZE)
self._chat.resize_chat_box()
self._chat.resize_buddy_list()
def _new_instance(self):
if self._first_time:
# self.voices.connect('changed', self.__changed_voices_cb)
self.pitchadj.connect('value_changed', self._pitch_adjusted_cb,
self.pitchadj)
self.rateadj.connect('value_changed', self._rate_adjusted_cb,
self.rateadj)
if self._active_number_of_eyes is None:
self._number_of_eyes_changed_event_cb(None, None, 'two', True)
if self._active_eyes is None:
self._eyes_changed_event_cb(None, None, 'eyes', True)
self._mouth_changed_cb(None, True)
self.face.look_ahead()
presenceService = presenceservice.get_instance()
self.owner = presenceService.get_owner()
if self._first_time:
# say hello to the user
if self._tablet_mode:
self._entry.props.text = _('Hello %s.') \
% self.owner.props.nick.encode('utf-8', 'ignore')
self.face.say_notification(_('Hello %s. Please Type something.')
% self.owner.props.nick)
else:
if self._tablet_mode:
self._entry.props.text = _('Welcome back %s.') \
% self.owner.props.nick.encode('utf-8', 'ignore')
self.face.say_notification(_('Welcome back %s.')
% self.owner.props.nick)
self._set_idle_phrase(speak=False)
self._first_time = False
def read_file(self, file_path):
self._cfg = json.loads(file(file_path, 'r').read())
current_voice = self.face.status.voice
status = self.face.status = \
face.Status().deserialize(self._cfg['status'])
found_my_voice = False
for name in self._voice_evboxes.keys():
if self._voice_evboxes[name][1] == current_voice:
self._voice_evboxes[name][0].modify_bg(
0, style.COLOR_BLACK.get_gdk_color())
if self._voice_evboxes[name][1] == status.voice and \
not found_my_voice:
self._voice_evboxes[name][0].modify_bg(
0, style.COLOR_BUTTON_GREY.get_gdk_color())
self.face.set_voice(status.voice)
if self._mode == MODE_BOT:
brain.load(self, status.voice)
found_my_voice = True
self.pitchadj.value = self.face.status.pitch
self.rateadj.value = self.face.status.rate
if status.mouth in MOUTHS:
self._mouth_type[MOUTHS.index(status.mouth)].set_active(True)
self._number_of_eyes_changed_event_cb(
None, None, NUMBERS[len(status.eyes) - 1], True)
for name in EYE_DICT.keys():
if status.eyes[0] == EYE_DICT[name]['widget']:
self._eye_type[name].set_icon(name + '-selected')
self._eyes_changed_event_cb(None, None, name, True)
break
self._entry.props.text = self._cfg['text'].encode('utf-8', 'ignore')
if not self._tablet_mode:
for i in self._cfg['history']:
self._entrycombo.append_text(i.encode('utf-8', 'ignore'))
self._new_instance()
def write_file(self, file_path):
if self._tablet_mode:
if 'history' in self._cfg:
history = self._cfg['history'] # retain old history
else:
history = []
else:
history = [unicode(i[0], 'utf-8', 'ignore')
for i in self._entrycombo.get_model()]
cfg = {'status': self.face.status.serialize(),
'text': unicode(self._entry.props.text, 'utf-8', 'ignore'),
'history': history, }
file(file_path, 'w').write(json.dumps(cfg))
def _cursor_moved_cb(self, entry, *ignored):
# make the eyes track the motion of the text cursor
index = entry.props.cursor_position
layout = entry.get_layout()
pos = layout.get_cursor_pos(index)
x = pos[0][0] / pango.SCALE - entry.props.scroll_offset
y = entry.get_allocation().y
self.face.look_at(pos=(x, y))
def _poll_accelerometer(self):
if _has_accelerometer():
idle_time = self._test_orientation()
gobject.timeout_add(idle_time, self._poll_accelerometer)
def _test_orientation(self):
if _has_accelerometer():
fh = open(ACCELEROMETER_DEVICE)
string = fh.read()
fh.close()
xyz = string[1:-2].split(',')
x = int(xyz[0])
y = int(xyz[1])
# DO SOMETHING HERE
if ((gtk.gdk.screen_width() > gtk.gdk.screen_height() and
abs(x) > abs(y)) or
(gtk.gdk.screen_width() < gtk.gdk.screen_height() and
abs(x) < abs(y))):
sideways_phrase = SIDEWAYS_PHRASES[
random.randint(0, len(SIDEWAYS_PHRASES) - 1)]
self.face.say(SIDEWAYS_PHRASES[sideways_phrase])
return IDLE_DELAY # Don't repeat the message for a while
return 1000 # Test again soon
def get_mouse(self):
display = gtk.gdk.display_get_default()
screen, mouseX, mouseY, modifiers = display.get_pointer()
return mouseX, mouseY
def _mouse_moved_cb(self, widget, event):
# make the eyes track the motion of the mouse cursor
self.face.look_at()
self._chat.look_at()
def _mouse_clicked_cb(self, widget, event):
pass
def _make_voice_bar(self):
voicebar = gtk.Toolbar()
all_voices = []
for name in sorted(voice_model.allVoices().keys()):
if len(name) < 26:
friendly_name = name
else:
friendly_name = name[:26] + '...'
all_voices.append([voice_model.allVoices()[name], friendly_name])
# A palette for the voice selection
logging.error(self.face.status.voice)
self._voice_evboxes = {}
self._voice_box = gtk.HBox()
vboxes = [gtk.VBox(), gtk.VBox(), gtk.VBox()]
count = len(voice_model.allVoices().keys())
found_my_voice = False
for i, voice in enumerate(sorted(all_voices)):
label = gtk.Label()
label.set_use_markup(True)
label.set_justify(gtk.JUSTIFY_LEFT)
label.set_markup('<span size="large">%s</span>' % voice[1])
alignment = gtk.Alignment(0, 0, 0, 0)
alignment.add(label)
label.show()
evbox = gtk.EventBox()
self._voice_evboxes[voice[1]] = [evbox, voice[0]]
self._voice_evboxes[voice[1]][0].connect(
'button-press-event', self._voices_changed_event_cb, voice)
if voice[0] == self.face.status.voice and not found_my_voice:
self._current_voice = voice
evbox.modify_bg(
0, style.COLOR_BUTTON_GREY.get_gdk_color())
found_my_voice = True
evbox.add(alignment)
alignment.show()
if i < count / 3:
vboxes[0].pack_start(evbox)
elif i < 2 * count / 3:
vboxes[1].pack_start(evbox)
else:
vboxes[2].pack_start(evbox)
self._voice_box.pack_start(vboxes[0], padding=style.DEFAULT_PADDING)
self._voice_box.pack_start(vboxes[1], padding=style.DEFAULT_PADDING)
self._voice_box.pack_start(vboxes[2], padding=style.DEFAULT_PADDING)
voice_palette_button = ToolButton('module-language')
voice_palette_button.set_tooltip(_('Choose voice:'))
self._voice_palette = voice_palette_button.get_palette()
self._voice_palette.set_content(self._voice_box)
self._voice_box.show_all()
voice_palette_button.connect('clicked', self._face_palette_cb)
voicebar.insert(voice_palette_button, -1)
voice_palette_button.show()
brain_voices = []
for name in sorted(brain.BOTS.keys()):
brain_voices.append([voice_model.allVoices()[name], name])
self._brain_evboxes = {}
self._brain_box = gtk.HBox()
vboxes = gtk.VBox()
count = brain.BOTS.keys()
found_my_voice = False
for i, voice in enumerate(brain_voices):
label = gtk.Label()
label.set_use_markup(True)
label.set_justify(gtk.JUSTIFY_LEFT)
label.set_markup('<span size="large">%s</span>' % voice[1])
alignment = gtk.Alignment(0, 0, 0, 0)
alignment.add(label)
label.show()
evbox = gtk.EventBox()
self._brain_evboxes[voice[1]] = [evbox, voice[0]]
self._brain_evboxes[voice[1]][0].connect(
'button-press-event', self._voices_changed_event_cb, voice)
if voice[0] == self.face.status.voice and not found_my_voice:
evbox.modify_bg(
0, style.COLOR_BUTTON_GREY.get_gdk_color())
found_my_voice = True
evbox.add(alignment)
alignment.show()
vboxes.pack_start(evbox)
self._brain_box.pack_start(vboxes, padding=style.DEFAULT_PADDING)
self._brain_box.show_all()
separator = gtk.SeparatorToolItem()
separator.set_draw(True)
separator.set_expand(False)
voicebar.insert(separator, -1)
self.pitchadj = gtk.Adjustment(self.face.status.pitch, 0,
espeak.PITCH_MAX, 1,
espeak.PITCH_MAX/10, 0)
pitchbar = gtk.HScale(self.pitchadj)
pitchbar.set_draw_value(False)
# pitchbar.set_inverted(True)
pitchbar.set_update_policy(gtk.UPDATE_DISCONTINUOUS)
pitchbar.set_size_request(240, 15)
pitchbar_toolitem = ToolWidget(widget=pitchbar, label_text=_('Pitch:'))
voicebar.insert(pitchbar_toolitem, -1)
self.rateadj = gtk.Adjustment(self.face.status.rate, 0,
espeak.RATE_MAX,
1, espeak.RATE_MAX / 10, 0)
ratebar = gtk.HScale(self.rateadj)
ratebar.set_draw_value(False)
# ratebar.set_inverted(True)
ratebar.set_update_policy(gtk.UPDATE_DISCONTINUOUS)
ratebar.set_size_request(240, 15)
ratebar_toolitem = ToolWidget(widget=ratebar, label_text=_('Rate:'))
voicebar.insert(ratebar_toolitem, -1)
voicebar.show_all()
return voicebar
def _pitch_adjusted_cb(self, get, data=None):
self.face.status.pitch = get.value
self.face.say_notification(_('pitch adjusted'))
def _rate_adjusted_cb(self, get, data=None):
self.face.status.rate = get.value
self.face.say_notification(_('rate adjusted'))
def _make_face_bar(self):
facebar = gtk.Toolbar()
self._mouth_type = []
self._mouth_type.append(RadioToolButton(
named_icon='mouth',
group=None,
tooltip=_('Simple')))
self._mouth_type[-1].connect('clicked', self._mouth_changed_cb, False)
facebar.insert(self._mouth_type[-1], -1)
self._mouth_type.append(RadioToolButton(
named_icon='waveform',
group=self._mouth_type[0],
tooltip=_('Waveform')))
self._mouth_type[-1].connect('clicked', self._mouth_changed_cb, False)
facebar.insert(self._mouth_type[-1], -1)
self._mouth_type.append(RadioToolButton(
named_icon='frequency',
group=self._mouth_type[0],
tooltip=_('Frequency')))
self._mouth_type[-1].connect('clicked', self._mouth_changed_cb, False)
facebar.insert(self._mouth_type[-1], -1)
separator = gtk.SeparatorToolItem()
separator.set_draw(True)
separator.set_expand(False)
facebar.insert(separator, -1)
eye_box = gtk.VBox()
self._eye_type = {}
for name in EYE_DICT.keys():
self._eye_type[name] = ToolButton(name)
self._eye_type[name].connect('clicked',
self._eyes_changed_event_cb,
None, name, False)
label = gtk.Label(EYE_DICT[name]['label'])
hbox = gtk.HBox()
hbox.pack_start(self._eye_type[name])
self._eye_type[name].show()
hbox.pack_start(label)
label.show()
evbox = gtk.EventBox()
evbox.connect('button-press-event', self._eyes_changed_event_cb,
name, False)
evbox.add(hbox)
hbox.show()
eye_box.pack_start(evbox)
eye_palette_button = ToolButton('eyes')
eye_palette_button.set_tooltip(_('Choose eyes:'))
palette = eye_palette_button.get_palette()
palette.set_content(eye_box)
eye_box.show_all()
eye_palette_button.connect('clicked', self._face_palette_cb)
facebar.insert(eye_palette_button, -1)
eye_palette_button.show()
number_of_eyes_box = gtk.VBox()
self._number_of_eyes_type = {}
for name in NUMBERS:
self._number_of_eyes_type[name] = ToolButton(name)
self._number_of_eyes_type[name].connect(
'clicked', self._number_of_eyes_changed_event_cb,
None, name, False)
label = gtk.Label(name)
hbox = gtk.HBox()
hbox.pack_start(self._number_of_eyes_type[name])
self._number_of_eyes_type[name].show()
hbox.pack_start(label)
label.show()
evbox = gtk.EventBox()
evbox.connect('button-press-event',
self._number_of_eyes_changed_event_cb,
name, False)
evbox.add(hbox)
hbox.show()
number_of_eyes_box.pack_start(evbox)
number_of_eyes_palette_button = ToolButton('number')
number_of_eyes_palette_button.set_tooltip(_('Eyes number:'))
palette = number_of_eyes_palette_button.get_palette()
palette.set_content(number_of_eyes_box)
number_of_eyes_box.show_all()
number_of_eyes_palette_button.connect('clicked', self._face_palette_cb)
facebar.insert(number_of_eyes_palette_button, -1)
number_of_eyes_palette_button.show()
facebar.show_all()
return facebar
def _face_palette_cb(self, button):
palette = button.get_palette()
if palette:
if not palette.is_up():
palette.popup(immediate=True, state=palette.SECONDARY)
else:
palette.popdown(immediate=True)
def _get_active_mouth(self):
for i, button in enumerate(self._mouth_type):
if button.get_active():
return MOUTHS[i]
def _mouth_changed_cb(self, ignored, quiet):
value = self._get_active_mouth()
if value is None:
return
self.face.status.mouth = value
self._update_face()
# this SegFaults: self.face.say(combo.get_active_text())
if not quiet:
self.face.say_notification(_('mouth changed'))
def _voices_changed_event_cb(self, widget, event, voice):
logging.error('voices_changed_event_cb %r %s' % (voice[0], voice[1]))
if self._mode == MODE_BOT:
evboxes = self._brain_evboxes
else:
evboxes = self._voice_evboxes
for old_voice in evboxes.keys():
if evboxes[old_voice][1] == self.face.status.voice:
evboxes[old_voice][0].modify_bg(
0, style.COLOR_BLACK.get_gdk_color())
break
evboxes[voice[1]][0].modify_bg(
0, style.COLOR_BUTTON_GREY.get_gdk_color())
self.face.set_voice(voice[0])
if self._mode == MODE_BOT:
brain.load(self, voice[0])
else:
self._current_voice = voice
def _get_active_eyes(self):
for name in EYE_DICT.keys():
if EYE_DICT[name]['index'] == self._active_eyes:
return EYE_DICT[name]['widget']
return None
def _eyes_changed_event_cb(self, widget, event, name, quiet):
if self._active_eyes is not None:
for old_name in EYE_DICT.keys():
if EYE_DICT[old_name]['index'] == self._active_eyes:
self._eye_type[old_name].set_icon(old_name)
break
if self._active_number_of_eyes is None:
self._active_number_of_eyes = 2
if name is not None:
self._active_eyes = EYE_DICT[name]['index']
self._eye_type[name].set_icon(name + '-selected')
value = EYE_DICT[name]['widget']
self.face.status.eyes = [value] * self._active_number_of_eyes
self._update_face()
if not quiet:
self.face.say_notification(_('eyes changed'))
def _number_of_eyes_changed_event_cb(self, widget, event, name, quiet):
if self._active_number_of_eyes is not None:
old_name = NUMBERS[self._active_number_of_eyes - 1]
self._number_of_eyes_type[old_name].set_icon(old_name)
if name in NUMBERS:
self._active_number_of_eyes = NUMBERS.index(name) + 1
self._number_of_eyes_type[name].set_icon(name + '-selected')
if self._active_eyes is not None:
for eye_name in EYE_DICT.keys():
if EYE_DICT[eye_name]['index'] == self._active_eyes:
value = EYE_DICT[eye_name]['widget']
self.face.status.eyes = \
[value] * self._active_number_of_eyes
self._update_face()
if not quiet:
self.face.say_notification(_('eyes changed'))
break
def _update_face(self):
self.face.update()
self._chat.update(self.face.status)
def _combo_changed_cb(self, combo):
# when a new item is chosen, make sure the text is selected
if not self._entry.is_focus():
if not self._tablet_mode:
self._entry.grab_focus()
self._entry.select_region(0, -1)
def _entry_key_press_cb(self, combo, event):
# make the up/down arrows navigate through our history
if self._tablet_mode:
return
keyname = gtk.gdk.keyval_name(event.keyval)
if keyname == 'Up':
index = self._entrycombo.get_active()
if index > 0:
index -= 1
self._entrycombo.set_active(index)
self._entry.select_region(0, -1)
return True
elif keyname == 'Down':
index = self._entrycombo.get_active()
if index < len(self._entrycombo.get_model()) - 1:
index += 1
self._entrycombo.set_active(index)
self._entry.select_region(0, -1)
return True
return False
def _entry_activate_cb(self, entry):
# the user pressed Return, say the text and clear it out
text = entry.props.text
if self._tablet_mode:
self._dismiss_OSK(entry)
timeout = DELAY_BEFORE_SPEAKING
else:
timeout = 100
gobject.timeout_add(timeout, self._speak_the_text, entry, text)
def _dismiss_OSK(self, entry):
entry.hide()
entry.show()
def _talk_cb(self, button):
text = self._entry.props.text
self._speak_the_text(self._entry, text)
def _speak_the_text(self, entry, text):
self._remove_idle()
if text:
self.face.look_ahead()
# speak the text
if self._mode == MODE_BOT:
self.face.say(brain.respond(text))
else:
self.face.say(text)
if text and not self._tablet_mode:
# add this text to our history unless it is the same as
# the last item
history = self._entrycombo.get_model()
if len(history) == 0 or history[-1][0] != text:
self._entrycombo.append_text(text)
# don't let the history get too big
while len(history) > 20:
self._entrycombo.remove_text(0)
# select the new item
self._entrycombo.set_active(len(history) - 1)
if text:
# select the whole text
entry.select_region(0, -1)
# Launch an robot idle phase after 2 minutes
self._robot_idle_id = gobject.timeout_add(IDLE_DELAY,
self._set_idle_phrase)
def _load_sleeping_face(self):
current_eyes = self.face.status.eyes
self.face.status.eyes = [SLEEPY_EYES] * self._active_number_of_eyes
self._update_face()
self.face.status.eyes = current_eyes
def _set_idle_phrase(self, speak=True):
if speak:
self._load_sleeping_face()
idle_phrase = IDLE_PHRASES[random.randint(
0, len(IDLE_PHRASES) - 1)]
if self.props.active:
self.face.say(idle_phrase)
self._robot_idle_id = gobject.timeout_add(IDLE_DELAY,
self._set_idle_phrase)
def _active_cb(self, widget, pspec):
# only generate sound when this activity is active
if not self.props.active:
self._load_sleeping_face()
self.face.shut_up()
self._chat.shut_up()
def _set_voice(self, new_voice=None):
if new_voice is not None:
logging.error('set_voice %r' % new_voice)
self.face.status.voice = new_voice
else:
logging.error('set_voice to current voice %s' %
self._current_voice[1])
self.face.status.voice = self._current_voice[0]
def __toggled_mode_type_cb(self, button):
if not button.props.active:
return
self._mode = MODE_TYPE
self._chat.shut_up()
self.face.shut_up()
self._notebook.set_current_page(0)
self._voice_palette.set_content(self._voice_box)
self._set_voice()
def __toggled_mode_robot_cb(self, button):
if not button.props.active:
return
self._remove_idle()
self._mode = MODE_BOT
self._chat.shut_up()
self.face.shut_up()
self._notebook.set_current_page(0)
self._voice_palette.set_content(self._brain_box)
new_voice = None
for name in brain.BOTS.keys():
if self._current_voice[0].short_name == name:
new_voice == self._current_voice[0]
break
if new_voice is None:
new_voice = brain.get_default_voice()
if new_voice.friendlyname in self._current_voice[0].friendlyname:
logging.debug('skipping sorry message for %s %s' %
(new_voice.friendlyname,
self._current_voice[0].friendlyname))
sorry = None
else:
sorry = _("Sorry, I can't speak %(old_voice)s, "
"let's talk %(new_voice)s instead.") % {
'old_voice': self._current_voice[0].friendlyname,
'new_voice': new_voice.friendlyname}
else:
new_voice = new_voice[0]
sorry = None
self._set_voice(new_voice)
evboxes = self._brain_evboxes
for old_voice in evboxes.keys():
evboxes[old_voice][0].modify_bg(
0, style.COLOR_BLACK.get_gdk_color())
if new_voice.short_name in evboxes:
evboxes[new_voice.short_name][0].modify_bg(
0, style.COLOR_BUTTON_GREY.get_gdk_color())
if not brain.load(self, new_voice, sorry):
if sorry:
self.face.say_notification(sorry)
def __toggled_mode_chat_cb(self, button):
if not button.props.active:
return
self._remove_idle()
is_first_session = not self.shared_activity
self._setup_chat_mode()
if is_first_session:
self._chat.me.say_notification(
_('You are in off-line mode, share and invite someone.'))
def _remove_idle(self):
if self._robot_idle_id is not None:
gobject.source_remove(self._robot_idle_id)
value = self._get_active_eyes()
if value is not None:
self.face.status.eyes = [value] * self._active_number_of_eyes
self._update_face()
def _setup_chat_mode(self):
self._mode = MODE_CHAT
self._remove_idle()
self.face.shut_up()
self._notebook.set_current_page(1)
self._voice_palette.set_content(self._voice_box)
self._set_voice()
def _shared_cb(self, sender):
logging.error('SHARED A CHAT')
self._setup_text_channel()
def _joined_cb(self, sender):
'''Joined a shared activity.'''
if not self.shared_activity:
return
logger.error('JOINED A SHARED CHAT')
for buddy in self.shared_activity.get_joined_buddies():
self._buddy_already_exists(buddy)
self._setup_text_channel()
def _one_to_one_connection(self, tp_channel):
'''Handle a private invite from a non-sugar3 XMPP client.'''
if self.shared_activity or self.text_channel:
return
bus_name, connection, channel = json.loads(tp_channel)
logger.debug('GOT XMPP: %s %s %s', bus_name, connection, channel)
Connection(bus_name, connection, ready_handler=lambda conn:
self._one_to_one_connection_ready_cb(
bus_name, channel, conn))
def _one_to_one_connection_ready_cb(self, bus_name, channel, conn):
'''Callback for Connection for one to one connection'''
text_channel = Channel(bus_name, channel)
self.text_channel = TextChannelWrapper(text_channel, conn)
self.text_channel.set_received_callback(self._received_cb)
self.text_channel.handle_pending_messages()
self.text_channel.set_closed_callback(
self._one_to_one_connection_closed_cb)
# XXX How do we detect the sender going offline?
self._chat.chat_post.set_sensitive(True)
# self._chat.chat_post.props.placeholder_text = None
self._chat.chat_post.grab_focus()
def _one_to_one_connection_closed_cb(self):
'''Callback for when the text channel closes.'''
pass
def _setup_text_channel(self):
logging.error('_SETUP_TEXTCHANNEL')
self.text_channel = TextChannelWrapper(
self.shared_activity.telepathy_text_chan,
self.shared_activity.telepathy_conn)
self.text_channel.set_received_callback(self._received_cb)
self.shared_activity.connect('buddy-joined', self._buddy_joined_cb)
self.shared_activity.connect('buddy-left', self._buddy_left_cb)
self._chat.messenger = self.text_channel
self._chat.chat_post.set_sensitive(True)
self._chat.chat_post.grab_focus()
def _buddy_joined_cb(self, sender, buddy):
'''Show a buddy who joined'''
if buddy == self.owner:
return
logging.error('%s joined the chat (%r)' % (buddy.props.nick, buddy))
self._chat.post(
buddy, _('%s joined the chat') % buddy.props.nick,
status_message=True)
def _buddy_left_cb(self, sender, buddy):
'''Show a buddy who joined'''
if buddy == self.owner:
return
logging.error('%s left the chat (%r)' % (buddy.props.nick, buddy))
self._chat.post(
buddy, _('%s left the chat') % buddy.props.nick,
status_message=True)
self._chat.farewell(buddy)
def _buddy_already_exists(self, buddy):
'''Show a buddy already in the chat.'''
if buddy == self.owner:
return
logging.error('%s is here (%r)' % (buddy.props.nick, buddy))
self._chat.post(
buddy, _('%s is here') % buddy.props.nick,
status_message=True)
def _received_cb(self, buddy, text):
'''Show message that was received.'''
if buddy:
if type(buddy) is dict:
nick = buddy['nick']
else:
nick = buddy.props.nick
else:
nick = '???'
logger.debug('Received message from %s: %s', nick, text)
self._chat.post(buddy, text)
def append(icon_name, label, page, position):
toolbar_button = ToolbarButton()
toolbar_button.props.page = page
toolbar_button.props.icon_name = icon_name
toolbar_button.props.label = label
self._toolbar_box.toolbar.insert(toolbar_button, position)
def _setup_toolbars(self):
''' Setup the toolbars.. '''
# no sharing
self.max_participants = 1
if _HAVE_TOOLBOX:
toolbox = ToolbarBox()
# Activity toolbar
activity_button = ActivityToolbarButton(self)
toolbox.toolbar.insert(activity_button, 0)
activity_button.show()
lesson_toolbar = gtk.Toolbar()
lesson_toolbar_button = ToolbarButton(label=_('Select a lesson'),
page=lesson_toolbar,
icon_name='text-x-generic')
record_toolbar = gtk.Toolbar()
record_toolbar_button = ToolbarButton(label=_('Record a sound'),
page=record_toolbar,
icon_name='media-audio')
self.set_toolbar_box(toolbox)
toolbox.show()
lesson_toolbar_button.show()
toolbox.toolbar.insert(lesson_toolbar_button, -1)
record_toolbar_button.show()
toolbox.toolbar.insert(record_toolbar_button, -1)
primary_toolbar = toolbox.toolbar
else:
# Use pre-0.86 toolbar design
primary_toolbar = gtk.Toolbar()
lesson_toolbar = gtk.Toolbar()
record_toolbar = gtk.Toolbar()
toolbox = activity.ActivityToolbox(self)
self.set_toolbox(toolbox)
toolbox.add_toolbar(_('Page'), primary_toolbar)
toolbox.show()
toolbox.add_toolbar(_('Lesson'), lesson_toolbar)
toolbox.show()
toolbox.add_toolbar(_('Record'), record_toolbar)
toolbox.show()
toolbox.set_current_toolbar(1)
# no sharing
if hasattr(toolbox, 'share'):
toolbox.share.hide()
elif hasattr(toolbox, 'props'):
toolbox.props.visible = False
_label_factory(_('Select a lesson') + ':', lesson_toolbar)
self._levels = self._get_levels(self._lessons_path)
self._levels_combo = _combo_factory(self._levels, _('Select a lesson'),
lesson_toolbar, self._levels_cb)
_separator_factory(lesson_toolbar)
self._lesson_button = _button_factory(
'load-from-journal', _('Load a new lesson from the Journal'),
self._lesson_cb, lesson_toolbar)
_separator_factory(lesson_toolbar)
self._create_lesson_button = _button_factory('view-source-insensitive',
_('Create a new lesson'),
self._create_lesson_cb,
lesson_toolbar)
self._save_lesson_button = _button_factory(
'save-to-journal-insensitive', _('Nothing to save'),
self._save_lesson_cb, lesson_toolbar)
self._sounds = self._get_sounds()
self.sounds_combo = _combo_factory(self._sounds, _('Record a sound'),
record_toolbar, self._sounds_cb)
_separator_factory(record_toolbar)
_label_factory(_('Record a sound') + ':', record_toolbar)
self._record_lesson_button = _button_factory('media-record',
_('Start recording'),
self._record_lesson_cb,
record_toolbar)
_separator_factory(record_toolbar)
self._playback_button = _button_factory(
'media-playback-start-insensitive', _('Nothing to play'),
self._playback_recording_cb, record_toolbar)
self._save_recording_button = _button_factory('sound-save-insensitive',
_('Nothing to save'),
self._save_recording_cb,
record_toolbar)
_separator_factory(primary_toolbar)
self._list_button = _button_factory('letter-list', _('Letter list'),
self._list_cb, primary_toolbar)
self._prev_page_button = _button_factory('previous-letter-insensitive',
_('Previous letter'),
self._prev_page_cb,
primary_toolbar)
self._next_page_button = _button_factory('next-letter',
_('Next letter'),
self._next_page_cb,
primary_toolbar)
_separator_factory(primary_toolbar)
self._read_button = _button_factory('read',
_('Read the sounds one at a time'),
self._read_cb, primary_toolbar)
_separator_factory(primary_toolbar)
self._test_button = _button_factory('go-right', _('Self test'),
self._test_cb, primary_toolbar)
self.status = _label_factory('', primary_toolbar)
if _HAVE_TOOLBOX:
_separator_factory(toolbox.toolbar, False, True)
stop_button = StopButton(self)
stop_button.props.accelerator = '<Ctrl>q'
toolbox.toolbar.insert(stop_button, -1)
stop_button.show()
lesson_toolbar.show()
record_toolbar.show()
class MeasureActivity(activity.Activity):
""" Oscilloscope Sugar activity """
def __init__(self, handle):
""" Init canvas, toolbars, etc.
The toolbars are in toolbar_top.py and toolbar_side.py
The audio controls are in audiograb.py
The rendering happens in drawwaveform.py
Logging (Journal interactions) are in journal.py """
activity.Activity.__init__(self, handle)
try:
tmp_dir = path.join(activity.get_activity_root(), "data")
except AttributeError:
# Early versions of Sugar (e.g., 656) didn't support
# get_activity_root()
tmp_dir = path.join(
environ['HOME'],
".sugar/default/org.laptop.MeasureActivity/data")
self.using_gconf = _using_gconf
self.icon_colors = self.get_icon_colors_from_sugar()
self.stroke_color, self.fill_color = self.icon_colors.split(',')
self.nick = self.get_nick_from_sugar()
self.active_status = True
self.ACTIVE = True
self.LOGGING_IN_SESSION = False
self.CONTEXT = ''
self.adjustmentf = None # Freq. slider control
self.connect('notify::active', self._active_cb)
self.connect('destroy', self.on_quit)
self.hw = _get_hardware()
self.closedSound = None
self.openedSound = None
self.session_id = 0
self.ji = JournalInteraction(self)
colorBlack = Color()
colorBlack.init_rgba(0, 0, 0, 255)
self.playsoundWin = PlayVideoWindow(colorBlack.gColor)
self.playsound = Gplay()
self.playsound.window = self.playsoundWin
self.wave = DrawWaveform(self, self.playsound)
self.hw = _get_hardware()
log.debug('running on %s hardware' % (self.hw))
if self.hw == XO15:
self.audiograb = AudioGrab_XO15(self.wave.new_buffer, self)
elif self.hw == XO1:
self.audiograb = AudioGrab_XO1(self.wave.new_buffer, self)
else:
self.audiograb = AudioGrab_Unknown(self.wave.new_buffer, self)
# no sharing
self.max_participants = 1
self.has_toolbarbox = _has_toolbarbox
self.side_toolbar = SideToolbar(self)
self.text_box = TextBox()
self.box3 = gtk.HBox(False, 0)
self.box3.pack_start(self.wave, True, True, 0)
self.box3.pack_start(self.side_toolbar.box1, False, True, 0)
self.box1 = gtk.VBox(False, 0)
self.box1.pack_start(self.box3, True, True, 0)
self.box1.pack_start(self.text_box.box_main, False, True, 0)
self.set_canvas(self.box1)
self.toolbox = None
if self.has_toolbarbox:
toolbox = ToolbarBox()
self.toolbox = toolbox
activity_button = ActivityToolbarButton(self)
toolbox.toolbar.insert(activity_button, 0)
activity_button.show()
else:
toolbox = ActivityToolbox(self)
self.toolbox = toolbox
# no sharing
if hasattr(toolbox, 'share'):
toolbox.share.hide()
elif hasattr(toolbox, 'props'):
toolbox.props.visible = False
self.set_toolbox(toolbox)
toolbox.connect('current-toolbar-changed',
self._toolbar_changed_cb)
self.sound_toolbar = SoundToolbar(self)
if self.has_toolbarbox:
self._sound_button = ToolbarButton(label=_('Sound'),
page=self.sound_toolbar,
icon_name='sound-tools')
toolbox.toolbar.insert(self._sound_button, -1)
self._sound_button.show()
else:
toolbox.add_toolbar(_('Sound'), self.sound_toolbar)
self.sound_toolbar.show()
if _is_xo(self.hw):
self.sensor_toolbar = SensorToolbar(self)
if self.has_toolbarbox:
self._sensor_button = ToolbarButton(label=_('Sensors'),
page=self.sensor_toolbar,
icon_name='sensor-tools')
toolbox.toolbar.insert(self._sensor_button, -1)
self._sensor_button.show()
else:
toolbox.add_toolbar(_('Sensors'), self.sensor_toolbar)
self.sensor_toolbar.show()
if self.has_toolbarbox:
_separator = gtk.SeparatorToolItem()
_separator.props.draw = False
toolbox.toolbar.insert(_separator, -1)
_separator.show()
# add a "dummy" button to indicate what capture mode we are in
self.label_button = ToolButton('domain-time2')
toolbox.toolbar.insert(self.label_button, -1)
self.label_button.show()
self.label_button.set_tooltip(_('Time Base'))
self.label_button.connect('clicked', self._label_cb)
self.sound_toolbar.add_frequency_slider(toolbox.toolbar)
_separator = gtk.SeparatorToolItem()
_separator.props.draw = False
_separator.set_expand(True)
toolbox.toolbar.insert(_separator, -1)
_separator.show()
_stop_button = StopButton(self)
_stop_button.props.accelerator = _('<Ctrl>Q')
toolbox.toolbar.insert(_stop_button, -1)
_stop_button.show()
self.set_toolbox(toolbox)
self._sound_button.set_expanded(True)
else:
toolbox.set_current_toolbar(TOOLBARS.index('sensor'))
toolbox.show()
self.sound_toolbar.update_page_size()
self.show_all()
self.first = True
self.set_sound_context()
self.set_sensor_context()
self.set_show_hide_windows()
self.wave.set_active(True)
self.wave.set_context_on()
self.set_show_hide_windows()
#wait(10)
#self.toolbox.set_current_toolbar(TOOLBARS.index('sensor'))
#self._toolbar_changed_cb(self.toolbox, TOOLBARS.index('sensor'))
#self.set_show_hide_windows('sensor')
def set_show_hide_windows(self, mode='sound'):
"""Shows the appropriate window identified by the mode """
if mode == 'sound':
self.wave.set_context_on()
self.side_toolbar.set_show_hide(True, mode)
elif mode == 'sensor':
self.wave.set_context_on()
self.side_toolbar.set_show_hide(True, mode)
def on_quit(self, data=None):
"""Clean up, close journal on quit"""
self.audiograb.on_activity_quit()
def _active_cb(self, widget, pspec):
""" Callback to handle starting/pausing capture when active/idle """
if self.first:
self.audiograb.start_grabbing()
self.first = False
if not self.props.active and self.ACTIVE:
self.audiograb.pause_grabbing()
self.active_status = False
elif self.props.active and not self.ACTIVE:
self.audiograb.resume_grabbing()
self.active_status = True
self.ACTIVE = self.props.active
self.wave.set_active(self.ACTIVE)
def write_file(self, file_path):
""" Write data to journal on quit """
if hasattr(self, 'ji') and len(self.ji.temp_buffer) > 0:
# Append new data to Journal entry
writer = csv.writer(open(file_path, 'ab'))
# Also output to a separate file as a workaround to Ticket 2127
tmp_file_path = join(environ['SUGAR_ACTIVITY_ROOT'], 'instance',
'sensor_data' + '.csv')
log.debug('saving sensor data to %s' % (tmp_file_path))
writer2 = csv.writer(open(tmp_file_path, 'ab'))
for datum in self.ji.temp_buffer:
writer.writerow([datum])
writer2.writerow([datum])
# Set the mimetype so that the file can be read by other Activities
self.metadata['mime_type'] = 'text/csv'
jobject = datastore.create()
jobject.metadata['title'] = _('Measure Log')
jobject.metadata['keep'] = '0'
jobject.metadata['buddies'] = ''
jobject.metadata['preview'] = ''
jobject.metadata['icon-color'] = self.icon_colors
jobject.metadata['mime_type'] = 'text/csv'
jobject.file_path = tmp_file_path
datastore.write(jobject)
jobject.destroy()
del jobject
remove(tmp_file_path)
def read_file(self, file_path):
""" Read csv data from journal on start """
reader = csv.reader(open(file_path, "rb"))
# Count the number of sessions
for r in reader:
if len(r) > 0:
if r[0] == _('Session'):
self.session_id += 1
elif r[0].find('abiword') != -1:
# File has been opened by Write cannot be read by Measure
# See Ticket 2127
log.error('File was opened by Write: Measure cannot read')
return
def _label_cb(self, data=None):
""" Ignore the click on the label button """
return
def _toolbar_changed_cb(self, toolbox, num):
""" Callback for changing the primary toolbar (0.84-) """
if TOOLBARS[num] == 'sound':
self.set_sound_context()
elif TOOLBARS[num] == 'sensor':
self.set_sensor_context()
return True
def set_sound_context(self):
""" Called when sound toolbar is selected or button pushed """
self.set_show_hide_windows('sound')
if _is_xo(self.hw):
self.sensor_toolbar.context_off()
gobject.timeout_add(500, self.sound_toolbar.context_on)
self.CONTEXT = 'sound'
def set_sensor_context(self):
""" Called when sensor toolbar is selected or button pushed """
self.set_show_hide_windows('sensor')
self.sound_toolbar.context_off()
gobject.timeout_add(500, self.sensor_toolbar.context_on)
self.CONTEXT = 'sensor'
def get_icon_colors_from_sugar(self):
"""Returns the icon colors from the Sugar profile"""
if self.using_gconf:
client = gconf.client_get_default()
return client.get_string('/desktop/sugar/user/color')
else:
return profile.get_color().to_string()
def get_nick_from_sugar(self):
""" Returns nick from Sugar """
if self.using_gconf:
client = gconf.client_get_default()
return client.get_string('/desktop/sugar/user/nick')
else:
return profile.get_nick_name()
def __init__(self, handle):
activity.Activity.__init__(self, handle)
self.props.max_participants = 1
self._web_view = Browser()
try:
from sugar.graphics.toolbarbox import ToolbarBox, ToolbarButton
from sugar.activity.widgets import ActivityToolbarButton, StopButton, \
ShareButton
from mybutton import MyActivityToolbarButton
toolbar_box = ToolbarBox()
activity_button = MyActivityToolbarButton(self)
toolbar_box.toolbar.insert(activity_button, 0)
activity_button.show()
viewtoolbar = ViewToolbar(self)
viewbutton = ToolbarButton(page=viewtoolbar, \
icon_name='camera')
toolbar_box.toolbar.insert(viewbutton, -1)
viewbutton.show()
separator = gtk.SeparatorToolItem()
#separator.props.draw = False
#separator.set_expand(True)
toolbar_box.toolbar.insert(separator, -1)
separator.show()
#lets reuse the code below
navtoolbar = Toolbar(self._web_view)
toolitem = gtk.ToolItem()
navtoolbar._home.reparent(toolitem)
toolbar_box.toolbar.insert(toolitem, -1)
navtoolbar._home.show()
toolitem.show()
toolitem = gtk.ToolItem()
navtoolbar._back.reparent(toolitem)
toolbar_box.toolbar.insert(toolitem, -1)
navtoolbar._back.show()
toolitem.show()
toolitem = gtk.ToolItem()
navtoolbar._forward.reparent(toolitem)
toolbar_box.toolbar.insert(toolitem, -1)
navtoolbar._forward.show()
toolitem.show()
# we do not have collaboration features
# make the share option insensitive
self.max_participants = 1
separator = gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
toolbar_box.toolbar.insert(separator, -1)
separator.show()
stop_button = StopButton(self)
stop_button.props.accelerator = '<Ctrl><Shift>Q'
toolbar_box.toolbar.insert(stop_button, -1)
stop_button.show()
self.set_toolbar_box(toolbar_box)
toolbar_box.show()
except ImportError:
toolbox = activity.ActivityToolbox(self)
self.set_toolbox(toolbox)
toolbox.show()
toolbar = Toolbar(self._web_view)
toolbox.add_toolbar(_('Navigation'), toolbar)
toolbar.show()
viewtoolbar = ViewToolbar(self)
toolbox.add_toolbar(_('View'), viewtoolbar)
viewtoolbar.show()
toolbox.set_current_toolbar(1)
self.set_canvas(self._web_view)
self._web_view.show()
self._web_view.load_uri(HOME)
def build_options_toolbar(self, toolbox):
options_bar = gtk.Toolbar()
item1 = gtk.ToolItem()
label1 = gtk.Label()
label1.set_text(' ' + _('Pixels') + ' ')
item1.add(label1)
options_bar.insert(item1, -1)
item2 = gtk.ToolItem()
pixels = gtk.SpinButton()
pixels.set_range(0, 1000)
pixels.set_increments(1, 10)
pixels.props.value = self.pixels
pixels.connect('notify::value', self.pixels_value)
item2.add(pixels)
options_bar.insert(item2, -1)
separator1 = gtk.SeparatorToolItem()
separator1.props.draw = True
options_bar.insert(separator1, -1)
item3 = gtk.ToolItem()
self.label_threshold_red = gtk.Label()
self.label_threshold_red.set_text(' ' + _('Threshold:') + ' ' + _('Red') + ' ')
item3.add(self.label_threshold_red)
options_bar.insert(item3, -1)
item4 = gtk.ToolItem()
red_spin = gtk.SpinButton()
red_spin.set_range(0, 255)
red_spin.set_increments(1, 10)
red_spin.props.value = self.threshold[0]
red_spin.connect('notify::value', self.red_spin_threshold)
item4.add(red_spin)
options_bar.insert(item4, -1)
item5 = gtk.ToolItem()
self.label_threshold_green = gtk.Label()
self.label_threshold_green.set_text(' ' + _('Green') + ' ')
item5.add(self.label_threshold_green)
options_bar.insert(item5, -1)
item6 = gtk.ToolItem()
green_spin = gtk.SpinButton()
green_spin.set_range(0, 255)
green_spin.set_increments(1, 10)
green_spin.props.value = self.threshold[1]
green_spin.connect('notify::value', self.green_spin_threshold)
item6.add(green_spin)
options_bar.insert(item6, -1)
item7 = gtk.ToolItem()
self.label_threshold_blue = gtk.Label()
self.label_threshold_blue.set_text(' ' + _('Blue') + ' ')
item7.add(self.label_threshold_blue)
options_bar.insert(item7, -1)
item8 = gtk.ToolItem()
blue_spin = gtk.SpinButton()
blue_spin.set_range(0, 255)
blue_spin.set_increments(1, 10)
blue_spin.props.value = self.threshold[2]
blue_spin.connect('notify::value', self.blue_spin_threshold)
item8.add(blue_spin)
options_bar.insert(item8, -1)
options_bar.show_all()
options_button = ToolbarButton(label=_('Options'),
page=options_bar,
icon_name='view-source')
toolbox.toolbar.insert(options_button, -1)
options_button.show()
def __init__(self, handle):
''' Init canvas, toolbars, etc.
The toolbars are in sensor_toolbar.py and toolbar_side.py
The audio controls are in audiograb.py
The rendering happens in drawwaveform.py
Logging is in journal.py '''
activity.Activity.__init__(self, handle)
self.mode_images = {}
self.mode_images['sound'] = gtk.gdk.pixbuf_new_from_file_at_size(
os.path.join(ICONS_DIR, 'media-audio.svg'), 45, 45)
self.mode_images['resistance'] = gtk.gdk.pixbuf_new_from_file_at_size(
os.path.join(ICONS_DIR, 'resistance.svg'), 45, 45)
self.mode_images['voltage'] = gtk.gdk.pixbuf_new_from_file_at_size(
os.path.join(ICONS_DIR, 'voltage.svg'), 45, 45)
self.icon_colors = self.get_icon_colors_from_sugar()
self.stroke_color, self.fill_color = self.icon_colors.split(',')
self.nick = self.get_nick_from_sugar()
self.CONTEXT = ''
self.adjustmentf = None # Freq. slider control
self.new_recording = False
self.session_id = 0
self.read_metadata()
self._active = True
self._dsobject = None
self.connect('notify::active', self._notify_active_cb)
self.connect('destroy', self.on_quit)
self.data_logger = DataLogger(self)
self.hw = _get_hardware()
log.debug('running on %s hardware' % (self.hw))
self.wave = DrawWaveform(self)
if self.hw == XO15:
self.audiograb = AudioGrab_XO15(self.wave.new_buffer, self)
elif self.hw == XO175:
self.audiograb = AudioGrab_XO175(self.wave.new_buffer, self)
elif self.hw == XO4:
self.audiograb = AudioGrab_XO4(self.wave.new_buffer, self)
elif self.hw == XO1:
self.audiograb = AudioGrab_XO1(self.wave.new_buffer, self)
else:
self.audiograb = AudioGrab_Unknown(self.wave.new_buffer, self)
# no sharing
self.max_participants = 1
box3 = gtk.HBox(False, 0)
box3.pack_start(self.wave, True, True, 0)
# We need event boxes in order to set the background color.
side_eventboxes = []
self.side_toolbars = []
for i in range(self.audiograb.channels):
side_eventboxes.append(gtk.EventBox())
side_eventboxes[i].modify_bg(
gtk.STATE_NORMAL, style.COLOR_TOOLBAR_GREY.get_gdk_color())
self.side_toolbars.append(SideToolbar(self, channel=i))
side_eventboxes[i].add(self.side_toolbars[i].box1)
box3.pack_start(side_eventboxes[i], False, True, 0)
event_box = gtk.EventBox()
self.text_box = gtk.Label()
self.text_box.set_justify(gtk.JUSTIFY_LEFT)
alist = pango.AttrList()
alist.insert(pango.AttrForeground(65535, 65535, 65535, 0, -1))
self.text_box.set_attributes(alist)
event_box.add(self.text_box)
event_box.modify_bg(gtk.STATE_NORMAL,
style.COLOR_TOOLBAR_GREY.get_gdk_color())
box1 = gtk.VBox(False, 0)
box1.pack_start(box3, True, True, 0)
box1.pack_start(event_box, False, True, 0)
self.set_canvas(box1)
toolbox = ToolbarBox()
activity_button = ActivityToolbarButton(self)
toolbox.toolbar.insert(activity_button, 0)
activity_button.show()
self.sensor_toolbar = SensorToolbar(self, self.audiograb.channels)
#Added by Lego
# Turn on bobot Server
log.debug('Starting Server...')
self.bobot = subprocess.Popen(['python', 'pybot_server.py'],
cwd='./pybot')
log.debug("Start : %s" % time.ctime())
time.sleep(bobot_delay_start)
log.debug("Started : %s" % time.ctime())
self.lego_toolbar = LegoToolbar(self, self.audiograb.channels)
#Lego end
# Added by Butia
self.butia_toolbar = ButiaToolbar(self, self.audiograb.channels)
#Butia end
#Added by Arduino
self.arduino_toolbar = ArduinoToolbar(self, self.audiograb.channels)
#Arduino end
self.tuning_toolbar = TuningToolbar(self)
self.new_instrument_toolbar = InstrumentToolbar(self)
self._extras_toolbar = gtk.Toolbar()
self.control_toolbar = gtk.Toolbar()
sensor_button = ToolbarButton(label=_('Sensors'),
page=self.sensor_toolbar,
icon_name='sensor-tools')
toolbox.toolbar.insert(sensor_button, -1)
#Added by Lego
sensor_button.connect('clicked', self._sensor_toolbar_cb)
#Lego end
sensor_button.show()
lego_button = ToolbarButton(label=_('Lego'),
page=self.lego_toolbar,
icon_name='LEGO-tools')
toolbox.toolbar.insert(lego_button, -1)
lego_button.connect('clicked', self._lego_toolbar_cb)
lego_button.show()
#Lego end
#Added by Butia
sensor_button.connect('clicked', self._sensor_toolbar_cb)
#Butia end
sensor_button.show()
#Added by Butia
butia_button = ToolbarButton(label=_('Butia'),
page=self.butia_toolbar,
icon_name='butia-tools')
toolbox.toolbar.insert(butia_button, -1)
butia_button.connect('clicked', self._butia_toolbar_cb)
butia_button.show()
#Butia end
#Added by Arduino
sensor_button.connect('clicked', self._sensor_toolbar_cb)
#Arduino end
sensor_button.show()
#Added by Arduino
arduino_button = ToolbarButton(label=_('Arduino'),
page=self.arduino_toolbar,
icon_name='arduino-tools')
toolbox.toolbar.insert(arduino_button, -1)
arduino_button.connect('clicked', self._arduino_toolbar_cb)
arduino_button.show()
#Arduino end
tuning_button = ToolbarButton(
# TRANS: Tuning insruments
label=_('Tuning'),
page=self.tuning_toolbar,
icon_name='tuning-tools')
toolbox.toolbar.insert(tuning_button, -1)
tuning_button.show()
new_instrument_button = ToolbarButton(label=_('Add instrument'),
page=self.new_instrument_toolbar,
icon_name='view-source')
toolbox.toolbar.insert(new_instrument_button, -1)
new_instrument_button.show()
#Added by butia
self.butia_toolbar.show()
#Butia end
self._extras_button = ToolbarButton(page=self._extras_toolbar,
icon_name='domain-time')
toolbox.toolbar.insert(self._extras_button, -1)
self._extras_toolbar_item = gtk.ToolItem()
self._extras_toolbar.insert(self._extras_toolbar_item, -1)
self._extras_button.hide()
self.sensor_toolbar.show()
self._extra_tools = gtk.HBox()
# Set up Frequency-domain Button
self.freq = ToolButton('domain-time')
self.freq.set_tooltip(_('Time Base'))
self.freq.connect('clicked', self.timefreq_control)
self.freq.show()
self._extra_tools.add(self.freq)
self.sensor_toolbar.add_frequency_slider(self._extra_tools)
self._extra_item = gtk.ToolItem()
self._extra_item.add(self._extra_tools)
self._extra_tools.show()
toolbox.toolbar.insert(self._extra_item, -1)
self._extra_item.show()
self._pause = ToolButton('media-playback-pause')
self._pause.set_tooltip(_('Freeze the display'))
self._pause.connect('clicked', self._pause_play_cb)
self._pause.show()
toolbox.toolbar.insert(self._pause, -1)
self._capture = ToolButton('image-saveoff')
self._capture.set_tooltip(_('Capture sample now'))
self._capture.connect('clicked', self._capture_cb)
self._capture.show()
toolbox.toolbar.insert(self._capture, -1)
separator = gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
toolbox.toolbar.insert(separator, -1)
separator.show()
stop_button = StopButton(self)
stop_button.props.accelerator = _('<Ctrl>Q')
toolbox.toolbar.insert(stop_button, -1)
stop_button.show()
self.set_toolbox(toolbox)
sensor_button.set_expanded(True)
toolbox.show()
self.sensor_toolbar.update_page_size()
self.show_all()
self._first = True
# Always start in 'sound' mode.
self.sensor_toolbar.set_mode('sound')
self.sensor_toolbar.set_sound_context()
self.sensor_toolbar.set_show_hide_windows()
self.wave.set_active(True)
self.wave.set_context_on()
gtk.gdk.screen_get_default().connect('size-changed',
self._configure_cb)
self._configure_cb(None)
def _setup_toolbars(self):
''' Setup the toolbars. '''
self.max_participants = 1 # no sharing
if HAVE_TOOLBOX:
toolbox = ToolbarBox()
# Activity toolbar
activity_button = ActivityToolbarButton(self)
toolbox.toolbar.insert(activity_button, 0)
activity_button.show()
self.set_toolbar_box(toolbox)
toolbox.show()
self.toolbar = toolbox.toolbar
adjust_toolbar = gtk.Toolbar()
adjust_toolbar_button = ToolbarButton(
label=_('Adjust'),
page=adjust_toolbar,
icon_name='preferences-system')
adjust_toolbar.show_all()
adjust_toolbar_button.show()
else:
# Use pre-0.86 toolbar design
primary_toolbar = gtk.Toolbar()
toolbox = activity.ActivityToolbox(self)
self.set_toolbox(toolbox)
toolbox.add_toolbar(_('Page'), primary_toolbar)
adjust_toolbar = gtk.Toolbar()
toolbox.add_toolbar(_('Adjust'), adjust_toolbar)
toolbox.show()
toolbox.set_current_toolbar(1)
self.toolbar = primary_toolbar
self._prev_button = button_factory('go-previous-inactive',
_('Prev slide'),
self._prev_cb,
self.toolbar,
accelerator='<Ctrl>P')
self._next_button = button_factory('go-next',
_('Next slide'),
self._next_cb,
self.toolbar,
accelerator='<Ctrl>N')
separator_factory(self.toolbar)
self._auto_button = button_factory('media-playlist-repeat',
_('Autoplay'), self._autoplay_cb,
self.toolbar)
if HAVE_TOOLBOX:
toolbox.toolbar.insert(adjust_toolbar_button, -1)
label = label_factory(_('Adjust playback speed'), adjust_toolbar)
label.show()
self._unit_combo = combo_factory(UNITS, TEN,
_('Adjust playback speed'),
self._unit_combo_cb, adjust_toolbar)
self._unit_combo.show()
separator_factory(self.toolbar)
self._thumb_button = button_factory('thumbs-view', _('Thumbnail view'),
self._thumbs_cb, self.toolbar)
button_factory('view-fullscreen',
_('Fullscreen'),
self.do_fullscreen_cb,
self.toolbar,
accelerator='<Alt>Return')
separator_factory(self.toolbar)
self._save_button = button_factory('save-as-html', _('Save as HTML'),
self._save_as_html_cb, self.toolbar)
if HAVE_TOOLBOX:
separator_factory(toolbox.toolbar, False, True)
stop_button = StopButton(self)
stop_button.props.accelerator = '<Ctrl>q'
toolbox.toolbar.insert(stop_button, -1)
stop_button.show()
def build_colors_toolbar(self, toolbox):
colors_bar = gtk.Toolbar()
########################################################################
# Point color
item = gtk.ToolItem()
label = gtk.Label()
label.set_text('%s ' % _('Points'))
item.add(label)
colors_bar.insert(item, -1)
# select color
item = gtk.ToolItem()
fill_color = ColorToolButton()
fill_color.connect('notify::color', self.color_point_change)
item.add(fill_color)
colors_bar.insert(item, -1)
# Separator
separator = gtk.SeparatorToolItem()
colors_bar.insert(separator, -1)
separator.show()
########################################################################
# Back color
item = gtk.ToolItem()
label = gtk.Label()
label.set_text('%s ' % _('Background'))
item.add(label)
colors_bar.insert(item, -1)
# select color
item = gtk.ToolItem()
_fill_color = ColorToolButton()
c = gtk.gdk.Color()
c.red = 21588
c.green = 47546
c.blue = 18504
_fill_color.set_color(c)
_fill_color.connect('notify::color', self.color_back_change)
item.add(_fill_color)
colors_bar.insert(item, -1)
# Separator
separator = gtk.SeparatorToolItem()
colors_bar.insert(separator, -1)
separator.show()
########################################################################
# Line color
item = gtk.ToolItem()
label = gtk.Label()
label.set_text('%s ' % _('Lines'))
item.add(label)
colors_bar.insert(item, -1)
# select color
item = gtk.ToolItem()
_fill_color = ColorToolButton()
_fill_color.connect('notify::color', self.color_line_change)
item.add(_fill_color)
colors_bar.insert(item, -1)
# Separator
separator = gtk.SeparatorToolItem()
colors_bar.insert(separator, -1)
separator.show()
########################################################################
# Owner color
item = gtk.ToolItem()
label = gtk.Label()
label.set_text('%s ' % _('Owner'))
item.add(label)
colors_bar.insert(item, -1)
# select color
item = gtk.ToolItem()
_fill_color = ColorToolButton()
c = gtk.gdk.Color()
c.red = 65535
_fill_color.set_color(c)
_fill_color.connect('notify::color', self.color_owner_change)
item.add(_fill_color)
colors_bar.insert(item, -1)
colors_bar.show_all()
colors_button = ToolbarButton(label=_('Colors'),
page=colors_bar,
icon_name='toolbar-colors')
toolbox.toolbar.insert(colors_button, -1)
colors_button.show()
def __init__(self, handle):
"""Set up the XoScope activity."""
activity.Activity.__init__(self, handle)
self._instance_directory = os.path.join(self.get_activity_root(),\
'instance')
# we do not have collaboration features
# make the share option insensitive
self.max_participants = 1
self._capturing = False
self._mode = 'live'
# 0, 2 or 5 second delay before capturing the image
self._delay = 0
# Zoom 1x, 2x, 4x
self._zoom = 1
# Exposure bracketing
self._bracketing = '0'
# Preview mode stuff
self._num_pics = 0
# Index of pic to be displayed in preview mode
self._pic_index = 0
# This holds the image titles and name information. Saved
# across activity instances
self._images = []
# Flag to store whether image preview element needs to resize
# the pixbuf
self._needs_resize = False
if OLD_TOOLBAR:
self.toolbox = ActivityToolbox(self)
self.set_toolbox(self.toolbox)
self.toolbox.show()
activity_toolbar = self.toolbox.get_activity_toolbar()
activity_toolbar = gtk.Toolbar()
self.toolbox.add_toolbar(_('Control'), activity_toolbar)
self.toolbox.set_current_toolbar(1)
self._controls_toolbar = activity_toolbar
advanced_toolbar = self.toolbox.get_activity_toolbar()
advanced_toolbar = gtk.Toolbar()
#self.toolbox.add_toolbar(_('Advanced controls'), advanced_toolbar)
else:
toolbar_box = ToolbarBox()
self.activity_button = ActivityToolbarButton(self)
toolbar_box.toolbar.insert(self.activity_button, 0)
self.activity_button.show()
self.set_toolbar_box(toolbar_box)
toolbar_box.show()
activity_toolbar = self.activity_button.page
self._controls_toolbar = self.get_toolbar_box().toolbar
self._controls_toolbar.show()
advanced_toolbar = gtk.Toolbar()
#advanced_toolbar.show_all()
advanced_button = ToolbarButton()
advanced_button.props.page = advanced_toolbar
advanced_button.props.label = _('Advanced controls')
advanced_button.props.icon_name = 'advanced'
#advanced_button.show()
#toolbar_box.toolbar.insert(advanced_button, -1)
self._live_toolitem = gtk.ToolItem()
self._live_toolbar_container = gtk.HBox()
self._preview_toolitem = gtk.ToolItem()
self._preview_toolbar_container = gtk.HBox()
separator = gtk.SeparatorToolItem()
if not OLD_TOOLBAR:
separator.props.draw = True
else:
separator.props.draw = False
separator.set_expand(False)
self._controls_toolbar.insert(separator, -1)
separator.show()
self._photo_button = ToolButton('photo')
self._photo_button.props.label = _('Capture photo')
self._photo_button.connect('clicked',
self.__capture_image_cb)
self._live_toolbar_container.add(self._photo_button)
self._photo_button.show()
self._delay_button = ToolButton('delay_%d' % self._delay)
self._delay_button.props.label = _('Capture delay')
self._delay_button.connect('clicked',
self.__change_capture_delay_cb)
self._live_toolbar_container.add(self._delay_button)
self._delay_button.show()
self._zoom_button = ToolButton('zoom_%d' % self._zoom)
self._zoom_button.props.label = _('Image Zoom')
self._zoom_button.connect('clicked',
self.__change_image_zoom_cb)
self._live_toolbar_container.add(self._zoom_button)
self._zoom_button.show()
#if self._check_available_control(v4l2.V4L2_CID_EXPOSURE):
# self._bracketing_button = ToolButton('bracketing_%s' % self._bracketing)
# self._bracketing_button.props.label = _('bracketing mode')
# self._bracketing_button.connect('clicked',
# self.__change_capture_bracketing_cb)
# self._live_toolbar_container.add(self._bracketing_button)
# self._bracketing_button.show()
separator = gtk.SeparatorToolItem()
separator.props.draw = True
separator.set_expand(False)
self._live_toolbar_container.add(separator)
separator.show()
# Camera control settings follow
if self._check_available_control(v4l2.V4L2_CID_EXPOSURE):
self._exposure_button = ToolButton('exposure')
self._exposure_button.set_palette(ScalePalette('Exposure',\
v4l2.V4L2_CID_EXPOSURE))
self._exposure_button.connect('clicked',
self.__button_clicked_cb)
self._live_toolbar_container.add(self._exposure_button)
self._exposure_button.show()
if self._check_available_control(v4l2.V4L2_CID_GAIN):
self._gain_button = ToolButton('gain')
self._gain_button.set_palette(ScalePalette('Gain',\
v4l2.V4L2_CID_GAIN,
self._check_available_control(v4l2.V4L2_CID_AUTOGAIN)))
self._gain_button.connect('clicked',
self.__button_clicked_cb)
advanced_toolbar.insert(self._gain_button, -1)
self._gain_button.show()
if self._check_available_control(v4l2.V4L2_CID_BRIGHTNESS):
self._brightness_button = ToolButton('brightness')
self._brightness_button.set_palette(ScalePalette('Brightness',\
v4l2.V4L2_CID_BRIGHTNESS,
self._check_available_control(
v4l2.V4L2_CID_AUTOBRIGHTNESS)))
self._brightness_button.connect('clicked',
self.__button_clicked_cb)
self._live_toolbar_container.add(self._brightness_button)
self._brightness_button.show()
if self._check_available_control(v4l2.V4L2_CID_CONTRAST):
self._contrast_button = ToolButton('contrast')
self._contrast_button.set_palette(ScalePalette('Contrast',\
v4l2.V4L2_CID_CONTRAST))
self._contrast_button.connect('clicked',
self.__button_clicked_cb)
self._live_toolbar_container.add(self._contrast_button)
self._contrast_button.show()
if self._check_available_control(v4l2.V4L2_CID_SATURATION):
self._saturation_button = ToolButton('saturation')
self._saturation_button.set_palette(ScalePalette('Saturation',\
v4l2.V4L2_CID_SATURATION))
self._saturation_button.connect('clicked',
self.__button_clicked_cb)
advanced_toolbar.insert(self._saturation_button, -1)
self._saturation_button.show()
if self._check_available_control(
v4l2.V4L2_CID_WHITE_BALANCE_TEMPERATURE):
self._white_balance_button = ToolButton('white_balance')
self._white_balance_button.set_palette(ScalePalette('White'
' balance', v4l2.V4L2_CID_WHITE_BALANCE_TEMPERATURE,
self._check_available_control(
v4l2.V4L2_CID_AUTO_WHITE_BALANCE)))
self._white_balance_button.connect('clicked',
self.__button_clicked_cb)
advanced_toolbar.insert(self._white_balance_button, -1)
self._white_balance_button.show()
if self._check_available_control(v4l2.V4L2_CID_HUE):
self._color_tone_button = ToolButton('color_tone')
self._color_tone_button.set_palette(ScalePalette('Color'
' tone', v4l2.V4L2_CID_HUE,
self._check_available_control(
v4l2.V4L2_CID_HUE_AUTO)))
self._color_tone_button.connect('clicked',
self.__button_clicked_cb)
advanced_toolbar.insert(self._color_tone_button, -1)
self._color_tone_button.show()
#if self._check_available_control(v4l2.V4L2_CID_NIGHT_MODE):
# self._night_mode_button = ToolButton('night_mode')
# self._night_mode_button.set_palette(ScalePalette('Night mode',\
# v4l2.V4L2_CID_NIGHT_MODE))
# self._night_mode_button.connect('clicked',
# self.__button_clicked_cb)
# self._live_toolbar_container.add(self._night_mode_button)
# self._night_mode_button.show()
self._previous_image = ToolButton('go-previous-paired')
self._previous_image.label = _('Previous image')
self._previous_image.connect('clicked',
self.__previous_image_clicked_cb)
self._preview_toolbar_container.add(self._previous_image)
self._previous_image.show()
self._next_image = ToolButton('go-next-paired')
self._next_image.label = _('Next image')
self._next_image.connect('clicked',
self.__next_image_clicked_cb)
self._preview_toolbar_container.add(self._next_image)
self._next_image.show()
self._image_name_entry = gtk.Entry()
self._image_name_entry.set_text('')
self._image_name_entry.set_size_request(400, -1)
self._image_name_entry.connect('activate',
self.__image_name_entry_activated_cb)
self._preview_toolbar_container.add(self._image_name_entry)
self._image_name_entry.show()
self._save_to_journal = ToolButton('save_to_journal')
self._save_to_journal.label = _('Save to journal')
self._save_to_journal.connect('clicked',
self.__save_to_journal_clicked_cb)
self._preview_toolbar_container.add(self._save_to_journal)
self._save_to_journal.show()
self._trash = ToolButton('trash')
self._trash.label = _('Delete')
self._trash.connect('clicked',
self.__trash_clicked_cb)
self._preview_toolbar_container.add(self._trash)
self._trash.show()
separator = gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
self._controls_toolbar.insert(separator, -1)
separator.show()
self._mode_button = ToolButton('%s_mode' % self._mode)
self._mode_button.props.label = _('Mode')
self._mode_button.connect('clicked',
self.__switch_modes_cb)
self._controls_toolbar.insert(self._mode_button, -1)
self._mode_button.show()
if not OLD_TOOLBAR:
separator = gtk.SeparatorToolItem()
separator.props.draw = True
separator.set_expand(False)
self._controls_toolbar.insert(separator, -1)
separator.show()
activity_stop = StopButton(self)
toolbar_box.toolbar.insert(activity_stop, -1)
activity_stop.show()
self._preview_toolitem.add(self._preview_toolbar_container)
self._live_toolitem.add(self._live_toolbar_container)
self._preview_toolbar_container.show()
self._live_toolbar_container.show()
if self._mode == 'preview':
self._controls_toolbar.insert(self._preview_toolitem, 1)
self._preview_toolitem.show()
else:
self._controls_toolbar.insert(self._live_toolitem, 1)
self._live_toolitem.show()
self._mode = 'live'
self._controls_toolbar.show()
activity_toolbar.show()
self._main_view = gtk.HBox()
self._movie_window = gtk.DrawingArea()
self._movie_window.connect('realize',
self.__movie_window_realize_cb)
self._movie_window.unset_flags(gtk.DOUBLE_BUFFERED)
self._movie_window.set_flags(gtk.APP_PAINTABLE)
self._main_view.add(self._movie_window)
self._preview_frame = gtk.AspectFrame(None, 0.5, 0.5, 1, True)
self._preview_window = gtk.Image()
self._preview_frame.add(self._preview_window)
self._preview_window.connect('size_allocate',
self.__preview_window_size_allocate_cb)
self.xoscope = gst.Pipeline('xoscope_pipe')
camsrc = gst.element_factory_make('v4l2src', 'camsrc')
caps = gst.Caps('video/x-raw-yuv')
filt = gst.element_factory_make('capsfilter', 'filter')
filt.set_property('caps', caps)
ffmpegcolorspace = gst.element_factory_make('ffmpegcolorspace',
'ffmpegcolorspace')
self._disp_sink = gst.element_factory_make('xvimagesink', 'disp_sink')
# http://thread.gmane.org/gmane.comp.video.gstreamer.devel/29644
self._disp_sink.set_property('sync', False)
self.image_sink = gst.element_factory_make('fakesink',
'image_sink')
self.image_sink.set_property('silent', True)
tee = gst.element_factory_make('tee', 'tee')
queue = gst.element_factory_make('queue', 'dispqueue')
queue.set_property('leaky', True)
queue.set_property('max-size-buffers', 20)
queue2 = gst.element_factory_make('queue', 'imagequeue')
queue2.set_property('leaky', True)
queue2.set_property('max-size-buffers', 20)
self._zoom_element = gst.element_factory_make('videobox', 'zoombox')
jpeg = gst.element_factory_make('jpegenc', 'pbjpeg')
jpeg.set_property('quality', 100)
self.xoscope.add(camsrc, filt, ffmpegcolorspace,\
self._zoom_element, self._disp_sink, tee, queue, queue2,\
self.image_sink, jpeg)
gst.element_link_many(camsrc, filt, self._zoom_element,\
ffmpegcolorspace, tee, queue, self._disp_sink)
gst.element_link_many(tee, queue2, jpeg, self.image_sink)
bus = self.xoscope.get_bus()
bus.add_signal_watch()
bus.enable_sync_message_emission()
bus.connect('message', self.__on_message_cb)
bus.connect('sync-message::element', self.__on_sync_message_cb)
self._main_view.show()
self._movie_window.show()
self.set_canvas(self._main_view)
# If we start playing without a delay, the live view window
# doesn't get attached to the main canvas properly (This is
# a problem on slow computers like xo1).
gobject.timeout_add(2000, self.__start_live_view)
def build_colors_toolbar(self, toolbox):
barra_colors = gtk.Toolbar()
item1 = gtk.ToolItem()
label1 = gtk.Label()
label1.set_text(_('Color mode') + ' ')
item1.add(label1)
barra_colors.insert(item1, -1)
item2 = gtk.ToolItem()
modes = ('RGB', 'YUV', 'HSV')
combo = Combo(modes)
item2.add(combo)
combo.connect('changed', self.change_combo)
barra_colors.insert(item2, -1)
separator1 = gtk.SeparatorToolItem()
separator1.props.draw = True
barra_colors.insert(separator1, -1)
item_l = gtk.ToolItem()
label4 = gtk.Label()
label4.set_text(_('Brightness') + ' ')
item_l.add(label4)
barra_colors.insert(item_l, -1)
item = gtk.ToolItem()
brightness_spin = gtk.SpinButton()
brightness_spin.set_range(-1, 255)
brightness_spin.set_increments(1, 10)
brightness_spin.props.value = int(self.brightness)
brightness_spin.connect('notify::value', self.brightness_spin_change)
item.add(brightness_spin)
barra_colors.insert(item, -1)
separator2 = gtk.SeparatorToolItem()
separator2.props.draw = True
barra_colors.insert(separator2, -1)
item3 = gtk.ToolItem()
label3 = gtk.Label()
label3.set_text(_('Threshold view'))
item3.add(label3)
barra_colors.insert(item3, -1)
threshold_view = ToolButton('media-playback-stop')
threshold_view.connect('clicked', self.threshold_view)
threshold_view.set_tooltip(_('Yes'))
barra_colors.insert(threshold_view, -1)
separator3 = gtk.SeparatorToolItem()
separator3.props.draw = True
barra_colors.insert(separator3, -1)
item4 = gtk.ToolItem()
label4 = gtk.Label()
label4.set_text(_('Outline'))
item4.add(label4)
barra_colors.insert(item4, -1)
outline_view = ToolButton('media-playback-stop')
outline_view.connect('clicked', self.outline_view)
outline_view.set_tooltip(_('Yes'))
barra_colors.insert(outline_view, -1)
separator4 = gtk.SeparatorToolItem()
separator4.props.draw = True
barra_colors.insert(separator4, -1)
item5 = gtk.ToolItem()
label5 = gtk.Label()
label5.set_text(_('Rects'))
item5.add(label5)
barra_colors.insert(item5, -1)
rects_view = ToolButton('media-playback-stop')
rects_view.connect('clicked', self.rects_view)
rects_view.set_tooltip(_('Yes'))
barra_colors.insert(rects_view, -1)
barra_colors.show_all()
colors_button = ToolbarButton(label=_('Colors'),
page=barra_colors,
icon_name='toolbar-colors')
toolbox.toolbar.insert(colors_button, -1)
colors_button.show()
def build_colors_toolbar(self, toolbox):
colors_bar = gtk.Toolbar()
########################################################################
# Point color
item = gtk.ToolItem()
label = gtk.Label()
label.set_text('%s ' % _('Player 1'))
item.add(label)
colors_bar.insert(item, -1)
# select color
item = gtk.ToolItem()
_fill_color = ColorToolButton()
c = gtk.gdk.Color()
c.red = 65535
c.green = 65535
c.blue = 65535
_fill_color.set_color(c)
_fill_color.connect('notify::color', self.color_player1_change)
item.add(_fill_color)
colors_bar.insert(item, -1)
# Separator
separator = gtk.SeparatorToolItem()
colors_bar.insert(separator, -1)
separator.show()
########################################################################
# Back color
item = gtk.ToolItem()
label = gtk.Label()
label.set_text('%s ' % _('Player 2'))
item.add(label)
colors_bar.insert(item, -1)
# select color
item = gtk.ToolItem()
_fill_color = ColorToolButton()
c = gtk.gdk.Color()
c.red = 0
c.green = 0
c.blue = 0
_fill_color.set_color(c)
_fill_color.connect('notify::color', self.color_player2_change)
item.add(_fill_color)
colors_bar.insert(item, -1)
# Separator
separator = gtk.SeparatorToolItem()
colors_bar.insert(separator, -1)
separator.show()
########################################################################
# Line color
item = gtk.ToolItem()
label = gtk.Label()
label.set_text('%s ' % _('Lines'))
item.add(label)
colors_bar.insert(item, -1)
# select color
item = gtk.ToolItem()
_fill_color = ColorToolButton()
_fill_color.connect('notify::color', self.color_line_change)
item.add(_fill_color)
colors_bar.insert(item, -1)
# Separator
separator = gtk.SeparatorToolItem()
colors_bar.insert(separator, -1)
separator.show()
########################################################################
# Line color
item = gtk.ToolItem()
label = gtk.Label()
label.set_text('%s ' % _('Background'))
item.add(label)
colors_bar.insert(item, -1)
# select color
item = gtk.ToolItem()
_fill_color = ColorToolButton()
_fill_color.connect('notify::color', self.color_back_change)
item.add(_fill_color)
colors_bar.insert(item, -1)
# Separator
separator = gtk.SeparatorToolItem()
colors_bar.insert(separator, -1)
separator.show()
########################################################################
# Line color
item = gtk.ToolItem()
label = gtk.Label()
label.set_text('%s ' % _('Board'))
item.add(label)
colors_bar.insert(item, -1)
# select color
item = gtk.ToolItem()
_fill_color = ColorToolButton()
_fill_color.connect('notify::color', self.color_board_change)
item.add(_fill_color)
colors_bar.insert(item, -1)
########################################################################
colors_bar.show_all()
colors_button = ToolbarButton(label=_('Colors'),
page=colors_bar,
icon_name='toolbar-colors')
toolbox.toolbar.insert(colors_button, -1)
colors_button.show()
def __init__(self, handle):
""" Init canvas, toolbars, etc.
The toolbars are in toolbar_top.py and toolbar_side.py
The audio controls are in audiograb.py
The rendering happens in drawwaveform.py
Logging (Journal interactions) are in journal.py """
activity.Activity.__init__(self, handle)
try:
tmp_dir = path.join(activity.get_activity_root(), "data")
except AttributeError:
# Early versions of Sugar (e.g., 656) didn't support
# get_activity_root()
tmp_dir = path.join(
environ['HOME'],
".sugar/default/org.laptop.MeasureActivity/data")
self.using_gconf = _using_gconf
self.icon_colors = self.get_icon_colors_from_sugar()
self.stroke_color, self.fill_color = self.icon_colors.split(',')
self.nick = self.get_nick_from_sugar()
self.active_status = True
self.ACTIVE = True
self.LOGGING_IN_SESSION = False
self.CONTEXT = ''
self.adjustmentf = None # Freq. slider control
self.connect('notify::active', self._active_cb)
self.connect('destroy', self.on_quit)
self.hw = _get_hardware()
self.closedSound = None
self.openedSound = None
self.session_id = 0
self.ji = JournalInteraction(self)
colorBlack = Color()
colorBlack.init_rgba(0, 0, 0, 255)
self.playsoundWin = PlayVideoWindow(colorBlack.gColor)
self.playsound = Gplay()
self.playsound.window = self.playsoundWin
self.wave = DrawWaveform(self, self.playsound)
self.hw = _get_hardware()
log.debug('running on %s hardware' % (self.hw))
if self.hw == XO15:
self.audiograb = AudioGrab_XO15(self.wave.new_buffer, self)
elif self.hw == XO1:
self.audiograb = AudioGrab_XO1(self.wave.new_buffer, self)
else:
self.audiograb = AudioGrab_Unknown(self.wave.new_buffer, self)
# no sharing
self.max_participants = 1
self.has_toolbarbox = _has_toolbarbox
self.side_toolbar = SideToolbar(self)
self.text_box = TextBox()
self.box3 = gtk.HBox(False, 0)
self.box3.pack_start(self.wave, True, True, 0)
self.box3.pack_start(self.side_toolbar.box1, False, True, 0)
self.box1 = gtk.VBox(False, 0)
self.box1.pack_start(self.box3, True, True, 0)
self.box1.pack_start(self.text_box.box_main, False, True, 0)
self.set_canvas(self.box1)
self.toolbox = None
if self.has_toolbarbox:
toolbox = ToolbarBox()
self.toolbox = toolbox
activity_button = ActivityToolbarButton(self)
toolbox.toolbar.insert(activity_button, 0)
activity_button.show()
else:
toolbox = ActivityToolbox(self)
self.toolbox = toolbox
# no sharing
if hasattr(toolbox, 'share'):
toolbox.share.hide()
elif hasattr(toolbox, 'props'):
toolbox.props.visible = False
self.set_toolbox(toolbox)
toolbox.connect('current-toolbar-changed',
self._toolbar_changed_cb)
self.sound_toolbar = SoundToolbar(self)
if self.has_toolbarbox:
self._sound_button = ToolbarButton(label=_('Sound'),
page=self.sound_toolbar,
icon_name='sound-tools')
toolbox.toolbar.insert(self._sound_button, -1)
self._sound_button.show()
else:
toolbox.add_toolbar(_('Sound'), self.sound_toolbar)
self.sound_toolbar.show()
if _is_xo(self.hw):
self.sensor_toolbar = SensorToolbar(self)
if self.has_toolbarbox:
self._sensor_button = ToolbarButton(label=_('Sensors'),
page=self.sensor_toolbar,
icon_name='sensor-tools')
toolbox.toolbar.insert(self._sensor_button, -1)
self._sensor_button.show()
else:
toolbox.add_toolbar(_('Sensors'), self.sensor_toolbar)
self.sensor_toolbar.show()
if self.has_toolbarbox:
_separator = gtk.SeparatorToolItem()
_separator.props.draw = False
toolbox.toolbar.insert(_separator, -1)
_separator.show()
# add a "dummy" button to indicate what capture mode we are in
self.label_button = ToolButton('domain-time2')
toolbox.toolbar.insert(self.label_button, -1)
self.label_button.show()
self.label_button.set_tooltip(_('Time Base'))
self.label_button.connect('clicked', self._label_cb)
self.sound_toolbar.add_frequency_slider(toolbox.toolbar)
_separator = gtk.SeparatorToolItem()
_separator.props.draw = False
_separator.set_expand(True)
toolbox.toolbar.insert(_separator, -1)
_separator.show()
_stop_button = StopButton(self)
_stop_button.props.accelerator = _('<Ctrl>Q')
toolbox.toolbar.insert(_stop_button, -1)
_stop_button.show()
self.set_toolbox(toolbox)
self._sound_button.set_expanded(True)
else:
toolbox.set_current_toolbar(TOOLBARS.index('sensor'))
toolbox.show()
self.sound_toolbar.update_page_size()
self.show_all()
self.first = True
self.set_sound_context()
self.set_sensor_context()
self.set_show_hide_windows()
self.wave.set_active(True)
self.wave.set_context_on()
self.set_show_hide_windows()
def __init__(self, handle):
activity.Activity.__init__(self, handle)
self.props.max_participants = 1
self._web_view = Browser()
try:
from sugar.graphics.toolbarbox import ToolbarBox, ToolbarButton
from sugar.activity.widgets import ActivityToolbarButton, StopButton, ShareButton
from mybutton import MyActivityToolbarButton
toolbar_box = ToolbarBox()
activity_button = MyActivityToolbarButton(self)
toolbar_box.toolbar.insert(activity_button, 0)
activity_button.show()
viewtoolbar = ViewToolbar(self)
viewbutton = ToolbarButton(page=viewtoolbar, icon_name="camera")
toolbar_box.toolbar.insert(viewbutton, -1)
viewbutton.show()
separator = gtk.SeparatorToolItem()
# separator.props.draw = False
# separator.set_expand(True)
toolbar_box.toolbar.insert(separator, -1)
separator.show()
# lets reuse the code below
navtoolbar = Toolbar(self._web_view)
toolitem = gtk.ToolItem()
navtoolbar._home.reparent(toolitem)
toolbar_box.toolbar.insert(toolitem, -1)
navtoolbar._home.show()
toolitem.show()
toolitem = gtk.ToolItem()
navtoolbar._back.reparent(toolitem)
toolbar_box.toolbar.insert(toolitem, -1)
navtoolbar._back.show()
toolitem.show()
toolitem = gtk.ToolItem()
navtoolbar._forward.reparent(toolitem)
toolbar_box.toolbar.insert(toolitem, -1)
navtoolbar._forward.show()
toolitem.show()
# we do not have collaboration features
# make the share option insensitive
self.max_participants = 1
separator = gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
toolbar_box.toolbar.insert(separator, -1)
separator.show()
stop_button = StopButton(self)
stop_button.props.accelerator = "<Ctrl><Shift>Q"
toolbar_box.toolbar.insert(stop_button, -1)
stop_button.show()
self.set_toolbar_box(toolbar_box)
toolbar_box.show()
except ImportError:
toolbox = activity.ActivityToolbox(self)
self.set_toolbox(toolbox)
toolbox.show()
toolbar = Toolbar(self._web_view)
toolbox.add_toolbar(_("Navigation"), toolbar)
toolbar.show()
viewtoolbar = ViewToolbar(self)
toolbox.add_toolbar(_("View"), viewtoolbar)
viewtoolbar.show()
toolbox.set_current_toolbar(1)
self.set_canvas(self._web_view)
self._web_view.show()
self._web_view.load_uri(HOME)
def __init__(self, handle):
""" Initiate activity. """
super(AbacusActivity, self).__init__(handle)
if _new_sugar_system:
# Use 0.86 toolbar design
toolbar_box = ToolbarBox()
# Buttons added to the Activity toolbar
activity_button = ActivityToolbarButton(self)
toolbar_box.toolbar.insert(activity_button, 0)
activity_button.show()
# Suanpan (Chinese abacus) 2:5
self.chinese = ToolButton("Con")
self.chinese.set_tooltip(_('Suanpan'))
self.chinese.props.sensitive = True
self.chinese.connect('clicked', self._chinese_cb)
toolbar_box.toolbar.insert(self.chinese, -1)
self.chinese.show()
# Soroban (Japanese abacus) 1:4
self.japanese = ToolButton("Joff")
self.japanese.set_tooltip(_('Soroban'))
self.japanese.props.sensitive = True
self.japanese.connect('clicked', self._japanese_cb)
toolbar_box.toolbar.insert(self.japanese, -1)
self.japanese.show()
# Schety (Russian abacus) 0:10
self.russian = ToolButton("Roff")
self.russian.set_tooltip(_('Schety'))
self.russian.props.sensitive = True
self.russian.connect('clicked', self._russian_cb)
toolbar_box.toolbar.insert(self.russian, -1)
self.russian.show()
# Nepohualtzintzin (Mayan abacus) 3:4 (base 20)
self.mayan = ToolButton("Moff")
self.mayan.set_tooltip(_('Nepohualtzintzin'))
self.mayan.props.sensitive = True
self.mayan.connect('clicked', self._mayan_cb)
toolbar_box.toolbar.insert(self.mayan, -1)
self.mayan.show()
# Binary (base 2)
self.binary = ToolButton("Boff")
self.binary.set_tooltip(_('Binary'))
self.binary.props.sensitive = True
self.binary.connect('clicked', self._binary_cb)
toolbar_box.toolbar.insert(self.binary, -1)
self.binary.show()
# Hexadecimal (base 16)
self.hex = ToolButton("Hoff")
self.hex.set_tooltip(_('Hexadecimal'))
self.hex.props.sensitive = True
self.hex.connect('clicked', self._hex_cb)
toolbar_box.toolbar.insert(self.hex, -1)
self.hex.show()
# Fractions (1/2, 1/3, 1/4, 1/5, 1/6, 1/8, 1/9, 1/10, 1/12)
self.fraction = ToolButton("Foff")
self.fraction.set_tooltip(_('Fraction'))
self.fraction.props.sensitive = True
self.fraction.connect('clicked', self._fraction_cb)
toolbar_box.toolbar.insert(self.fraction, -1)
self.fraction.show()
separator = gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(False)
separator.show()
toolbar_box.toolbar.insert(separator, -1)
# The Customization submenu (roll your own)
custom_toolbar = gtk.Toolbar()
self._rods_label = gtk.Label(_("Rods:") + " ")
self._rods_label.set_line_wrap(True)
self._rods_label.show()
self._rods_toolitem = gtk.ToolItem()
self._rods_toolitem.add(self._rods_label)
custom_toolbar.insert(self._rods_toolitem, -1)
self._rods_toolitem.show()
self._rods_spin_adj = gtk.Adjustment(15, 1, 20, 1, 32, 0)
self._rods_spin = gtk.SpinButton(self._rods_spin_adj, 0, 0)
self._rods_spin_id = self._rods_spin.connect(
'value-changed', self._rods_spin_cb)
self._rods_spin.set_numeric(True)
self._rods_spin.show()
self.tool_item_rods = gtk.ToolItem()
self.tool_item_rods.add(self._rods_spin)
custom_toolbar.insert(self.tool_item_rods, -1)
self.tool_item_rods.show()
self._top_label = gtk.Label(" " + _("Top:") + " ")
self._top_label.set_line_wrap(True)
self._top_label.show()
self._top_toolitem = gtk.ToolItem()
self._top_toolitem.add(self._top_label)
custom_toolbar.insert(self._top_toolitem, -1)
self._top_toolitem.show()
self._top_spin_adj = gtk.Adjustment(2, 0, 4, 1, 32, 0)
self._top_spin = gtk.SpinButton(self._top_spin_adj, 0, 0)
self._top_spin_id = self._top_spin.connect('value-changed',
self._top_spin_cb)
self._top_spin.set_numeric(True)
self._top_spin.show()
self.tool_item_top = gtk.ToolItem()
self.tool_item_top.add(self._top_spin)
custom_toolbar.insert(self.tool_item_top, -1)
self.tool_item_top.show()
self._bottom_label = gtk.Label(" " + _("Bottom:") + " ")
self._bottom_label.set_line_wrap(True)
self._bottom_label.show()
self._bottom_toolitem = gtk.ToolItem()
self._bottom_toolitem.add(self._bottom_label)
custom_toolbar.insert(self._bottom_toolitem, -1)
self._bottom_toolitem.show()
self._bottom_spin_adj = gtk.Adjustment(5, 1, 15, 1, 32, 0)
self._bottom_spin = gtk.SpinButton(self._bottom_spin_adj, 0, 0)
self._bottom_spin_id = self._bottom_spin.connect(
'value-changed', self._bottom_spin_cb)
self._bottom_spin.set_numeric(True)
self._bottom_spin.show()
self.tool_item_bottom = gtk.ToolItem()
self.tool_item_bottom.add(self._bottom_spin)
custom_toolbar.insert(self.tool_item_bottom, -1)
self.tool_item_bottom.show()
self._value_label = gtk.Label(" " + _("Factor:") + " ")
self._value_label.set_line_wrap(True)
self._value_label.show()
self._value_toolitem = gtk.ToolItem()
self._value_toolitem.add(self._value_label)
custom_toolbar.insert(self._value_toolitem, -1)
self._value_toolitem.show()
self._value_spin_adj = gtk.Adjustment(5, 1, 20, 1, 32, 0)
self._value_spin = gtk.SpinButton(self._value_spin_adj, 0, 0)
self._value_spin_id = self._value_spin.connect(
'value-changed', self._value_spin_cb)
self._value_spin.set_numeric(True)
self._value_spin.show()
self.tool_item_value = gtk.ToolItem()
self.tool_item_value.add(self._value_spin)
custom_toolbar.insert(self.tool_item_value, -1)
self.tool_item_value.show()
self._base_label = gtk.Label(" " + _("Base:") + " ")
self._base_label.set_line_wrap(True)
self._base_label.show()
self._base_toolitem = gtk.ToolItem()
self._base_toolitem.add(self._base_label)
custom_toolbar.insert(self._base_toolitem, -1)
self._base_toolitem.show()
self._base_spin_adj = gtk.Adjustment(10, 1, 20, 1, 32, 0)
self._base_spin = gtk.SpinButton(self._base_spin_adj, 0, 0)
self._base_spin_id = self._base_spin.connect(
'value-changed', self._base_spin_cb)
self._base_spin.set_numeric(True)
self._base_spin.show()
self.tool_item_base = gtk.ToolItem()
self.tool_item_base.add(self._base_spin)
custom_toolbar.insert(self.tool_item_base, -1)
self.tool_item_base.show()
# Custom
self._custom = ToolButton("new-game")
self._custom.set_tooltip(_('Custom'))
self._custom.props.sensitive = True
self._custom.connect('clicked', self._custom_cb)
custom_toolbar.insert(self._custom, -1)
self._custom.show()
custom_toolbar_button = ToolbarButton(page=custom_toolbar,
icon_name='view-source')
custom_toolbar.show()
toolbar_box.toolbar.insert(custom_toolbar_button, -1)
custom_toolbar_button.show()
separator = gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
separator.show()
toolbar_box.toolbar.insert(separator, -1)
# The ever-present Stop Button
stop_button = StopButton(self)
stop_button.props.accelerator = _('<Ctrl>Q')
toolbar_box.toolbar.insert(stop_button, -1)
stop_button.show()
self.set_toolbar_box(toolbar_box)
toolbar_box.show()
else:
# Use pre-0.86 toolbar design
self.toolbox = activity.ActivityToolbox(self)
self.set_toolbox(self.toolbox)
self.projectToolbar = ProjectToolbar(self)
self.toolbox.add_toolbar(_('Project'), self.projectToolbar)
self.customToolbar = CustomToolbar(self)
self.toolbox.add_toolbar(_('Custom'), self.customToolbar)
self.toolbox.show()
# Create a canvas
canvas = gtk.DrawingArea()
canvas.set_size_request(gtk.gdk.screen_width(),
gtk.gdk.screen_height())
self.set_canvas(canvas)
canvas.show()
self.show_all()
# Initialize the canvas
self.abacus = Abacus(canvas, self)
# Read the current mode from the Journal
try:
if self.metadata['abacus'] == 'suanpan':
self._chinese_cb(None)
elif self.metadata['abacus'] == 'soroban':
self._japanese_cb(None)
elif self.metadata['abacus'] == 'schety':
self._russian_cb(None)
elif self.metadata['abacus'] == 'nepohualtzintzin':
self._mayan_cb(None)
elif self.metadata['abacus'] == 'binary':
self._binary_cb(None)
elif self.metadata['abacus'] == 'hexadecimal':
self._hex_cb(None)
elif self.metadata['abacus'] == 'fraction':
self._fraction_cb(None)
else:
self._chinese_cb(None)
except:
pass
try:
self.abacus.mode.set_value(self.metadata['value'])
self.abacus.mode.label(self.abacus.mode.value())
except:
pass
def build_calibrate_toolbar(self, toolbox):
calibrate_bar = gtk.Toolbar()
item1 = gtk.ToolItem()
label1 = gtk.Label()
label1.set_text(' ' + _('Calibrate/Follow') + ' ')
item1.add(label1)
calibrate_bar.insert(item1, -1)
stop_calibrate = ToolButton('media-playback-stop')
stop_calibrate.set_tooltip(_('Stop'))
stop_calibrate.set_accelerator('<ctrl>space')
stop_calibrate.connect('clicked', self.stop_execute)
calibrate_bar.insert(stop_calibrate, -1)
separator1 = gtk.SeparatorToolItem()
separator1.props.draw = True
calibrate_bar.insert(separator1, -1)
item3 = gtk.ToolItem()
self.label_color_red = gtk.Label()
self.label_color_red.set_text(' ' + _('Calibrated color:') + ' ' + _('Red') + ' ')
item3.add(self.label_color_red)
calibrate_bar.insert(item3, -1)
item4 = gtk.ToolItem()
self.red_spin = gtk.SpinButton()
self.red_spin.set_range(0, 255)
self.red_spin.set_increments(1, 10)
self.red_spin.props.value = self.colorC[0]
self.red_spin.connect('notify::value', self.red_spin_color)
item4.add(self.red_spin)
calibrate_bar.insert(item4, -1)
item5 = gtk.ToolItem()
self.label_color_green = gtk.Label()
self.label_color_green.set_text(' ' + _('Green') + ' ')
item5.add(self.label_color_green)
calibrate_bar.insert(item5, -1)
item6 = gtk.ToolItem()
self.green_spin = gtk.SpinButton()
self.green_spin.set_range(0, 255)
self.green_spin.set_increments(1, 10)
self.green_spin.props.value = self.colorC[1]
self.green_spin.connect('notify::value', self.green_spin_color)
item6.add(self.green_spin)
calibrate_bar.insert(item6, -1)
item7 = gtk.ToolItem()
self.label_color_blue = gtk.Label()
self.label_color_blue.set_text(' ' + _('Blue') + ' ')
item7.add(self.label_color_blue)
calibrate_bar.insert(item7, -1)
item8 = gtk.ToolItem()
self.blue_spin = gtk.SpinButton()
self.blue_spin.set_range(0, 255)
self.blue_spin.set_increments(1, 10)
self.blue_spin.props.value = self.colorC[2]
self.blue_spin.connect('notify::value', self.blue_spin_color)
item8.add(self.blue_spin)
calibrate_bar.insert(item8, -1)
calibrate_bar.show_all()
calibrate_button = ToolbarButton(label=_('Calibrate'),
page=calibrate_bar,
icon_name='preferences-system')
toolbox.toolbar.insert(calibrate_button, -1)
calibrate_button.show()
class MeasureActivity(activity.Activity):
''' Oscilloscope Sugar activity '''
def __init__(self, handle):
''' Init canvas, toolbars, etc.
The toolbars are in sensor_toolbar.py and toolbar_side.py
The audio controls are in audiograb.py
The rendering happens in drawwaveform.py
Logging is in journal.py '''
activity.Activity.__init__(self, handle)
self.mode_images = {}
self.mode_images['sound'] = gtk.gdk.pixbuf_new_from_file_at_size(
os.path.join(ICONS_DIR, 'media-audio.svg'), 45, 45)
self.mode_images['resistance'] = gtk.gdk.pixbuf_new_from_file_at_size(
os.path.join(ICONS_DIR, 'resistance.svg'), 45, 45)
self.mode_images['voltage'] = gtk.gdk.pixbuf_new_from_file_at_size(
os.path.join(ICONS_DIR, 'voltage.svg'), 45, 45)
self.icon_colors = self.get_icon_colors_from_sugar()
self.stroke_color, self.fill_color = self.icon_colors.split(',')
self.nick = self.get_nick_from_sugar()
self.CONTEXT = ''
self.adjustmentf = None # Freq. slider control
self.new_recording = False
self.session_id = 0
self.read_metadata()
self._active = True
self._dsobject = None
self.connect('notify::active', self._notify_active_cb)
self.connect('destroy', self.on_quit)
self.data_logger = DataLogger(self)
self.hw = _get_hardware()
log.debug('running on %s hardware' % (self.hw))
self.wave = DrawWaveform(self)
if self.hw == XO15:
self.audiograb = AudioGrab_XO15(self.wave.new_buffer, self)
elif self.hw == XO175:
self.audiograb = AudioGrab_XO175(self.wave.new_buffer, self)
elif self.hw == XO4:
self.audiograb = AudioGrab_XO4(self.wave.new_buffer, self)
elif self.hw == XO1:
self.audiograb = AudioGrab_XO1(self.wave.new_buffer, self)
else:
self.audiograb = AudioGrab_Unknown(self.wave.new_buffer, self)
# no sharing
self.max_participants = 1
box3 = gtk.HBox(False, 0)
box3.pack_start(self.wave, True, True, 0)
# We need event boxes in order to set the background color.
side_eventboxes = []
self.side_toolbars = []
for i in range(self.audiograb.channels):
side_eventboxes.append(gtk.EventBox())
side_eventboxes[i].modify_bg(
gtk.STATE_NORMAL, style.COLOR_TOOLBAR_GREY.get_gdk_color())
self.side_toolbars.append(SideToolbar(self, channel=i))
side_eventboxes[i].add(self.side_toolbars[i].box1)
box3.pack_start(side_eventboxes[i], False, True, 0)
event_box = gtk.EventBox()
self.text_box = gtk.Label()
self.text_box.set_justify(gtk.JUSTIFY_LEFT)
alist = pango.AttrList()
alist.insert(pango.AttrForeground(65535, 65535, 65535, 0, -1))
self.text_box.set_attributes(alist)
event_box.add(self.text_box)
event_box.modify_bg(gtk.STATE_NORMAL,
style.COLOR_TOOLBAR_GREY.get_gdk_color())
box1 = gtk.VBox(False, 0)
box1.pack_start(box3, True, True, 0)
box1.pack_start(event_box, False, True, 0)
self.set_canvas(box1)
toolbox = ToolbarBox()
activity_button = ActivityToolbarButton(self)
toolbox.toolbar.insert(activity_button, 0)
activity_button.show()
self.sensor_toolbar = SensorToolbar(self, self.audiograb.channels)
#Added by Lego
# Turn on bobot Server
log.debug('Starting Server...')
self.bobot = subprocess.Popen(['python', 'pybot_server.py'],
cwd='./pybot')
log.debug("Start : %s" % time.ctime())
time.sleep(bobot_delay_start)
log.debug("Started : %s" % time.ctime())
self.lego_toolbar = LegoToolbar(self, self.audiograb.channels)
#Lego end
# Added by Butia
self.butia_toolbar = ButiaToolbar(self, self.audiograb.channels)
#Butia end
#Added by Arduino
self.arduino_toolbar = ArduinoToolbar(self, self.audiograb.channels)
#Arduino end
self.tuning_toolbar = TuningToolbar(self)
self.new_instrument_toolbar = InstrumentToolbar(self)
self._extras_toolbar = gtk.Toolbar()
self.control_toolbar = gtk.Toolbar()
sensor_button = ToolbarButton(label=_('Sensors'),
page=self.sensor_toolbar,
icon_name='sensor-tools')
toolbox.toolbar.insert(sensor_button, -1)
#Added by Lego
sensor_button.connect('clicked', self._sensor_toolbar_cb)
#Lego end
sensor_button.show()
lego_button = ToolbarButton(label=_('Lego'),
page=self.lego_toolbar,
icon_name='LEGO-tools')
toolbox.toolbar.insert(lego_button, -1)
lego_button.connect('clicked', self._lego_toolbar_cb)
lego_button.show()
#Lego end
#Added by Butia
sensor_button.connect('clicked', self._sensor_toolbar_cb)
#Butia end
sensor_button.show()
#Added by Butia
butia_button = ToolbarButton(label=_('Butia'),
page=self.butia_toolbar,
icon_name='butia-tools')
toolbox.toolbar.insert(butia_button, -1)
butia_button.connect('clicked', self._butia_toolbar_cb)
butia_button.show()
#Butia end
#Added by Arduino
sensor_button.connect('clicked', self._sensor_toolbar_cb)
#Arduino end
sensor_button.show()
#Added by Arduino
arduino_button = ToolbarButton(label=_('Arduino'),
page=self.arduino_toolbar,
icon_name='arduino-tools')
toolbox.toolbar.insert(arduino_button, -1)
arduino_button.connect('clicked', self._arduino_toolbar_cb)
arduino_button.show()
#Arduino end
tuning_button = ToolbarButton(
# TRANS: Tuning insruments
label=_('Tuning'),
page=self.tuning_toolbar,
icon_name='tuning-tools')
toolbox.toolbar.insert(tuning_button, -1)
tuning_button.show()
new_instrument_button = ToolbarButton(label=_('Add instrument'),
page=self.new_instrument_toolbar,
icon_name='view-source')
toolbox.toolbar.insert(new_instrument_button, -1)
new_instrument_button.show()
#Added by butia
self.butia_toolbar.show()
#Butia end
self._extras_button = ToolbarButton(page=self._extras_toolbar,
icon_name='domain-time')
toolbox.toolbar.insert(self._extras_button, -1)
self._extras_toolbar_item = gtk.ToolItem()
self._extras_toolbar.insert(self._extras_toolbar_item, -1)
self._extras_button.hide()
self.sensor_toolbar.show()
self._extra_tools = gtk.HBox()
# Set up Frequency-domain Button
self.freq = ToolButton('domain-time')
self.freq.set_tooltip(_('Time Base'))
self.freq.connect('clicked', self.timefreq_control)
self.freq.show()
self._extra_tools.add(self.freq)
self.sensor_toolbar.add_frequency_slider(self._extra_tools)
self._extra_item = gtk.ToolItem()
self._extra_item.add(self._extra_tools)
self._extra_tools.show()
toolbox.toolbar.insert(self._extra_item, -1)
self._extra_item.show()
self._pause = ToolButton('media-playback-pause')
self._pause.set_tooltip(_('Freeze the display'))
self._pause.connect('clicked', self._pause_play_cb)
self._pause.show()
toolbox.toolbar.insert(self._pause, -1)
self._capture = ToolButton('image-saveoff')
self._capture.set_tooltip(_('Capture sample now'))
self._capture.connect('clicked', self._capture_cb)
self._capture.show()
toolbox.toolbar.insert(self._capture, -1)
separator = gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
toolbox.toolbar.insert(separator, -1)
separator.show()
stop_button = StopButton(self)
stop_button.props.accelerator = _('<Ctrl>Q')
toolbox.toolbar.insert(stop_button, -1)
stop_button.show()
self.set_toolbox(toolbox)
sensor_button.set_expanded(True)
toolbox.show()
self.sensor_toolbar.update_page_size()
self.show_all()
self._first = True
# Always start in 'sound' mode.
self.sensor_toolbar.set_mode('sound')
self.sensor_toolbar.set_sound_context()
self.sensor_toolbar.set_show_hide_windows()
self.wave.set_active(True)
self.wave.set_context_on()
gtk.gdk.screen_get_default().connect('size-changed',
self._configure_cb)
self._configure_cb(None)
def _configure_cb(self, event):
''' Screen size has changed, so check to see if the toolbar
elements still fit.'''
self.width = gtk.gdk.screen_width()
if self.width < style.GRID_CELL_SIZE * 14:
self._extras_button.show()
if self._extra_tools in self._extra_item:
self._extra_item.remove(self._extra_tools)
if not self._extra_tools in self._extras_toolbar_item:
self._extras_toolbar_item.add(self._extra_tools)
self._extras_toolbar_item.show()
self.sensor_toolbar.log_label.hide()
self.sensor_toolbar.trigger_label.hide()
else:
self._extras_button.hide()
if self._extra_tools in self._extras_toolbar_item:
self._extras_toolbar_item.remove(self._extra_tools)
if not self._extra_tools in self._extra_item:
self._extra_item.add(self._extra_tools)
if self._extras_button.is_expanded():
self._extras_button.set_expanded(False)
self._extras_toolbar_item.hide()
self.sensor_toolbar.log_label.show()
self.sensor_toolbar.trigger_label.show()
self._extra_tools.show()
#Added by Lego
def _sensor_toolbar_cb(self, button=None):
'''Callback al hacer clic en sensor toolbar'''
log.debug('Click en sensor toolbar')
self.sensor_toolbar.set_mode('sound')
self.sensor_toolbar.set_sound_context()
self.sensor_toolbar.set_show_hide_windows()
self.limpiar_canales()
self.CONTEXT = 'sound'
#Added by Lego
def _lego_toolbar_cb(self, button=None):
'''Callback al hacer clic en lego toolbar'''
log.debug('Click en lego toolbar')
self.audiograb.stop_grabbing()
self.limpiar_canales()
log.debug('CONTEXTO ANTERIOR: %s' % self.CONTEXT)
self.CONTEXT = 'lego'
self.sensor_toolbar.update_string_for_textbox()
#Added by Butia
def _butia_toolbar_cb(self, button=None):
'''Callback al hacer clic en butia toolbar'''
log.debug('Click en butia toolbar')
self.audiograb.stop_grabbing()
self.limpiar_canales()
log.debug('CONTEXTO ANTERIOR: %s' % self.CONTEXT)
self.CONTEXT = 'butia'
self.sensor_toolbar.update_string_for_textbox()
#Added by Arduino
def _arduino_toolbar_cb(self, button=None):
'''Callback al hacer clic en arduino toolbar'''
log.debug('Click en arduino toolbar')
self.audiograb.stop_grabbing()
self.limpiar_canales()
log.debug('CONTEXTO ANTERIOR: %s' % self.CONTEXT)
log.debug('***** ARDUINO CONTEXT ******')
self.CONTEXT = 'arduino'
self.sensor_toolbar.update_string_for_textbox()
#Added by lego
def limpiar_canales(self):
for i in range(self.audiograb.channels):
self.wave.ringbuffer[i] = RingBuffer1d(self.wave.max_samples,
dtype='int16')
self.wave.new_buffer([0], i)
def on_quit(self, data=None):
'''Clean up, close journal on quit'''
self.audiograb.on_activity_quit()
def _notify_active_cb(self, widget, pspec):
''' Callback to handle starting/pausing capture when active/idle '''
if self._first:
log.debug('_notify_active_cb: start grabbing')
self.audiograb.start_grabbing()
self._first = False
elif not self.props.active:
log.debug('_notify_active_cb: pause grabbing')
self.audiograb.pause_grabbing()
elif self.props.active:
log.debug('_notify_active_cb: resume grabbing')
self.audiograb.resume_grabbing()
self._active = self.props.active
self.wave.set_active(self._active)
def read_metadata(self):
''' Any saved instruments? '''
for data in self.metadata.keys():
if data[0] == PREFIX: # instrument
log.debug('found an instrument: %s' % (data[1:]))
instrument = data[1:]
log.debug(self.metadata[data])
INSTRUMENT_DICT[instrument] = []
for note in self.metadata[data].split(' '):
INSTRUMENT_DICT[instrument].append(float(note))
def write_file(self, file_path):
''' Write data to journal, if there is any data to write '''
# Check to see if there are any new instruments to save
if hasattr(self, 'new_instrument_toolbar'):
for i, instrument in enumerate(
self.new_instrument_toolbar.new_instruments):
log.debug('saving %s' % (instrument))
notes = ''
for i, note in enumerate(INSTRUMENT_DICT[instrument]):
notes += '%0.3f' % note
if i < len(INSTRUMENT_DICT[instrument]) - 1:
notes += ' '
self.metadata['%s%s' % (PREFIX, instrument)] = notes
# FIXME: Don't use ""s around data
if hasattr(self, 'data_logger') and \
self.new_recording and \
len(self.data_logger.data_buffer) > 0:
# Append new data to Journal entry
fd = open(file_path, 'ab')
writer = csv.writer(fd)
# Also output to a separate file as a workaround to Ticket 2127
# (the assumption being that this file will be opened by the user)
tmp_data_file = os.path.join(os.environ['SUGAR_ACTIVITY_ROOT'],
'instance', 'sensor_data' + '.csv')
log.debug('saving sensor data to %s' % (tmp_data_file))
if self._dsobject is None: # first time, so create
fd2 = open(tmp_data_file, 'wb')
else: # we've been here before, so append
fd2 = open(tmp_data_file, 'ab')
writer2 = csv.writer(fd2)
# Pop data off start of buffer until it is empty
for i in range(len(self.data_logger.data_buffer)):
datum = self.data_logger.data_buffer.pop(0)
writer.writerow([datum])
writer2.writerow([datum])
fd.close()
fd2.close()
# Set the proper mimetype
self.metadata['mime_type'] = 'text/csv'
if os.path.exists(tmp_data_file):
if self._dsobject is None:
self._dsobject = datastore.create()
self._dsobject.metadata['title'] = _('Measure Log')
self._dsobject.metadata['icon-color'] = self.icon_colors
self._dsobject.metadata['mime_type'] = 'text/csv'
self._dsobject.set_file_path(tmp_data_file)
datastore.write(self._dsobject)
# remove(tmp_data_file)
def read_file(self, file_path):
''' Read csv data from journal on start '''
reader = csv.reader(open(file_path, "rb"))
# Count the number of sessions.
for row in reader:
if len(row) > 0:
if row[0].find(_('Session')) != -1:
# log.debug('found a previously recorded session')
self.session_id += 1
elif row[0].find('abiword') != -1:
# File has been opened by Write cannot be read by Measure
# See Ticket 2127
log.error('File was opened by Write: Measure cannot read')
self.data_logger.data_buffer = []
return
self.data_logger.data_buffer.append(row[0])
if self.session_id == 0:
# log.debug('setting data_logger buffer to []')
self.data_logger.data_buffer = []
def _pause_play_cb(self, button=None):
''' Callback for Pause Button '''
if self.audiograb.get_freeze_the_display():
self.audiograb.set_freeze_the_display(False)
self._pause.set_icon('media-playback-start')
self._pause.set_tooltip(_('Unfreeze the display'))
self._pause.show()
else:
self.audiograb.set_freeze_the_display(True)
self._pause.set_icon('media-playback-pause')
self._pause.set_tooltip(_('Freeze the display'))
self._pause.show()
return False
def _capture_cb(self, button=None):
''' Callback for screen capture '''
if self.CONTEXT == 'butia':
self.butia_toolbar.take_screenshot()
self.audiograb.take_screenshot()
def timefreq_control(self, button=None):
''' Callback for Freq. Button '''
# Turn off logging when switching modes
if self.audiograb.we_are_logging:
self.sensor_toolbar.record_control_cb()
#Added by Lego
self.lego_toolbar.set_sound_context()
#Lego end
#Added by Butia
self.butia_toolbar.set_sound_context()
#Butia end
#Added by Arduino
self.arduino_toolbar.set_sound_context()
#Arduino end
if self.wave.get_fft_mode():
self.wave.set_fft_mode(False)
self.freq.set_icon('domain-time')
self.freq.set_tooltip(_('Time Base'))
else:
self.wave.set_fft_mode(True)
self.freq.set_icon('domain-freq')
self.freq.set_tooltip(_('Frequency Base'))
# Turn off triggering in Frequencey Base
self.sensor_toolbar.trigger_none.set_active(True)
self.wave.set_trigger(self.wave.TRIGGER_NONE)
# Turn off invert in Frequencey Base
for i in range(self.audiograb.channels):
if self.wave.get_invert_state(channel=i):
self.side_toolbars[i].invert_control_cb()
self.sensor_toolbar.update_string_for_textbox()
return False
def get_icon_colors_from_sugar(self):
''' Returns the icon colors from the Sugar profile '''
return profile.get_color().to_string()
def get_nick_from_sugar(self):
''' Returns nick from Sugar '''
return profile.get_nick_name()
def _setup_toolbars(self):
''' Setup the toolbars. '''
self.max_participants = 6
if HAVE_TOOLBOX:
toolbox = ToolbarBox()
# Activity toolbar
activity_button_toolbar = ActivityToolbarButton(self)
toolbox.toolbar.insert(activity_button_toolbar, 0)
activity_button_toolbar.show()
self.set_toolbar_box(toolbox)
toolbox.show()
self.toolbar = toolbox.toolbar
self.record_toolbar = gtk.Toolbar()
record_toolbar_button = ToolbarButton(
label=_('Record a sound'),
page=self.record_toolbar,
icon_name='media-audio')
self.record_toolbar.show_all()
record_toolbar_button.show()
toolbox.toolbar.insert(record_toolbar_button, -1)
else:
# Use pre-0.86 toolbar design
primary_toolbar = gtk.Toolbar()
toolbox = activity.ActivityToolbox(self)
self.set_toolbox(toolbox)
toolbox.add_toolbar(_('Page'), primary_toolbar)
self.record_toolbar = gtk.Toolbar()
toolbox.add_toolbar(_('Record'), self.record_toolbar)
toolbox.show()
toolbox.set_current_toolbar(1)
self.toolbar = primary_toolbar
self._prev_button = button_factory(
'go-previous-inactive', self.toolbar, self._prev_cb,
tooltip=_('Prev slide'), accelerator='<Ctrl>P')
self._next_button = button_factory(
'go-next', self.toolbar, self._next_cb,
tooltip=_('Next slide'), accelerator='<Ctrl>N')
separator_factory(self.toolbar)
slide_button = radio_factory('slide-view', self.toolbar,
self._slides_cb, group=None,
tooltip=_('Slide view'))
radio_factory('thumbs-view', self.toolbar, self._thumbs_cb,
tooltip=_('Thumbnail view'),
group=slide_button)
button_factory('view-fullscreen', self.toolbar,
self.do_fullscreen_cb, tooltip=_('Fullscreen'),
accelerator='<Alt>Return')
separator_factory(self.toolbar)
journal_button = button_factory(
'write-journal', self.toolbar, self._do_journal_cb,
tooltip=_('Update description'))
self._palette = journal_button.get_palette()
msg_box = gtk.HBox()
sw = gtk.ScrolledWindow()
sw.set_size_request(int(gtk.gdk.screen_width() / 2),
2 * style.GRID_CELL_SIZE)
sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
self._text_view = gtk.TextView()
self._text_view.set_left_margin(style.DEFAULT_PADDING)
self._text_view.set_right_margin(style.DEFAULT_PADDING)
self._text_view.set_wrap_mode(gtk.WRAP_WORD_CHAR)
self._text_view.connect('focus-out-event',
self._text_view_focus_out_event_cb)
sw.add(self._text_view)
sw.show()
msg_box.pack_start(sw, expand=False)
msg_box.show_all()
self._palette.set_content(msg_box)
label_factory(self.record_toolbar, _('Record a sound') + ':')
self._record_button = button_factory(
'media-record', self.record_toolbar,
self._record_cb, tooltip=_('Start recording'))
separator_factory(self.record_toolbar)
# Look to see if we have audio previously recorded
obj_id = self._get_audio_obj_id()
dsobject = self._search_for_audio_note(obj_id)
if dsobject is not None:
_logger.debug('Found previously recorded audio')
self._add_playback_button(profile.get_nick_name(),
self.colors,
dsobject.file_path)
if HAVE_TOOLBOX:
button_factory('system-restart', activity_button_toolbar,
self._resend_cb, tooltip=_('Refresh'))
separator_factory(activity_button_toolbar)
self._save_pdf = button_factory(
'save-as-pdf', activity_button_toolbar,
self._save_as_pdf_cb, tooltip=_('Save as PDF'))
else:
separator_factory(self.toolbar)
self._save_pdf = button_factory(
'save-as-pdf', self.toolbar,
self._save_as_pdf_cb, tooltip=_('Save as PDF'))
if HAVE_TOOLBOX:
separator_factory(toolbox.toolbar, True, False)
stop_button = StopButton(self)
stop_button.props.accelerator = '<Ctrl>q'
toolbox.toolbar.insert(stop_button, -1)
stop_button.show()
def build_options_toolbar(self, toolbox):
options_bar = gtk.Toolbar()
item1 = gtk.ToolItem()
label1 = gtk.Label()
label1.set_text(' ' + _('Pixels') + ' ')
item1.add(label1)
options_bar.insert(item1, -1)
item2 = gtk.ToolItem()
pixels = gtk.SpinButton()
pixels.set_range(0, 1000)
pixels.set_increments(1, 10)
pixels.props.value = self.pixels
pixels.connect('notify::value', self.pixels_value)
item2.add(pixels)
options_bar.insert(item2, -1)
separator1 = gtk.SeparatorToolItem()
separator1.props.draw = True
options_bar.insert(separator1, -1)
item3 = gtk.ToolItem()
self.label_threshold_red = gtk.Label()
self.label_threshold_red.set_text(' ' + _('Threshold:') + ' ' +
_('Red') + ' ')
item3.add(self.label_threshold_red)
options_bar.insert(item3, -1)
item4 = gtk.ToolItem()
red_spin = gtk.SpinButton()
red_spin.set_range(0, 255)
red_spin.set_increments(1, 10)
red_spin.props.value = self.threshold[0]
red_spin.connect('notify::value', self.red_spin_threshold)
item4.add(red_spin)
options_bar.insert(item4, -1)
item5 = gtk.ToolItem()
self.label_threshold_green = gtk.Label()
self.label_threshold_green.set_text(' ' + _('Green') + ' ')
item5.add(self.label_threshold_green)
options_bar.insert(item5, -1)
item6 = gtk.ToolItem()
green_spin = gtk.SpinButton()
green_spin.set_range(0, 255)
green_spin.set_increments(1, 10)
green_spin.props.value = self.threshold[1]
green_spin.connect('notify::value', self.green_spin_threshold)
item6.add(green_spin)
options_bar.insert(item6, -1)
item7 = gtk.ToolItem()
self.label_threshold_blue = gtk.Label()
self.label_threshold_blue.set_text(' ' + _('Blue') + ' ')
item7.add(self.label_threshold_blue)
options_bar.insert(item7, -1)
item8 = gtk.ToolItem()
blue_spin = gtk.SpinButton()
blue_spin.set_range(0, 255)
blue_spin.set_increments(1, 10)
blue_spin.props.value = self.threshold[2]
blue_spin.connect('notify::value', self.blue_spin_threshold)
item8.add(blue_spin)
options_bar.insert(item8, -1)
options_bar.show_all()
options_button = ToolbarButton(label=_('Options'),
page=options_bar,
icon_name='view-source')
toolbox.toolbar.insert(options_button, -1)
options_button.show()
import gtk
from sugar.graphics.toolbutton import ToolButton
from sugar.graphics.toolbarbox import ToolbarBox, ToolbarButton
from sugar.graphics import style
window = gtk.Window()
box = gtk.VBox()
window.add(box)
toolbar = ToolbarBox()
box.pack_start(toolbar, False)
tollbarbutton_1 = ToolbarButton(
page=gtk.Button('sub-widget #1'),
icon_name='computer-xo')
toolbar.toolbar.insert(tollbarbutton_1, -1)
tollbarbutton_2 = ToolbarButton(
page=gtk.Button('sub-widget #2'),
icon_name='button_cancel',
tooltip='with custom palette instead of sub-widget')
toolbar.toolbar.insert(tollbarbutton_2, -1)
toolbar.toolbar.insert(gtk.SeparatorToolItem(), -1)
def del_cb(widget):
toolbar.toolbar.remove(tollbarbutton_3)
del_b = gtk.Button('delete sub-widget #3')
def build_calibrate_toolbar(self, toolbox):
calibrate_bar = gtk.Toolbar()
item1 = gtk.ToolItem()
label1 = gtk.Label()
label1.set_text(' ' + _('Calibrate/Follow') + ' ')
item1.add(label1)
calibrate_bar.insert(item1, -1)
stop_calibrate = ToolButton('media-playback-stop')
stop_calibrate.set_tooltip(_('Stop'))
stop_calibrate.set_accelerator('<ctrl>space')
stop_calibrate.connect('clicked', self.stop_execute)
calibrate_bar.insert(stop_calibrate, -1)
separator1 = gtk.SeparatorToolItem()
separator1.props.draw = True
calibrate_bar.insert(separator1, -1)
item3 = gtk.ToolItem()
self.label_color_red = gtk.Label()
self.label_color_red.set_text(' ' + _('Calibrated color:') + ' ' +
_('Red') + ' ')
item3.add(self.label_color_red)
calibrate_bar.insert(item3, -1)
item4 = gtk.ToolItem()
self.red_spin = gtk.SpinButton()
self.red_spin.set_range(0, 255)
self.red_spin.set_increments(1, 10)
self.red_spin.props.value = self.colorC[0]
self.red_spin.connect('notify::value', self.red_spin_color)
item4.add(self.red_spin)
calibrate_bar.insert(item4, -1)
item5 = gtk.ToolItem()
self.label_color_green = gtk.Label()
self.label_color_green.set_text(' ' + _('Green') + ' ')
item5.add(self.label_color_green)
calibrate_bar.insert(item5, -1)
item6 = gtk.ToolItem()
self.green_spin = gtk.SpinButton()
self.green_spin.set_range(0, 255)
self.green_spin.set_increments(1, 10)
self.green_spin.props.value = self.colorC[1]
self.green_spin.connect('notify::value', self.green_spin_color)
item6.add(self.green_spin)
calibrate_bar.insert(item6, -1)
item7 = gtk.ToolItem()
self.label_color_blue = gtk.Label()
self.label_color_blue.set_text(' ' + _('Blue') + ' ')
item7.add(self.label_color_blue)
calibrate_bar.insert(item7, -1)
item8 = gtk.ToolItem()
self.blue_spin = gtk.SpinButton()
self.blue_spin.set_range(0, 255)
self.blue_spin.set_increments(1, 10)
self.blue_spin.props.value = self.colorC[2]
self.blue_spin.connect('notify::value', self.blue_spin_color)
item8.add(self.blue_spin)
calibrate_bar.insert(item8, -1)
calibrate_bar.show_all()
calibrate_button = ToolbarButton(label=_('Calibrate'),
page=calibrate_bar,
icon_name='preferences-system')
toolbox.toolbar.insert(calibrate_button, -1)
calibrate_button.show()
def __init__(self, handle):
activity.Activity.__init__(self, handle)
try:
# Use new >= 0.86 toolbar design
self.max_participants = 1
toolbar_box = ToolbarBox()
activity_button = ActivityToolbarButton(self)
toolbar_box.toolbar.insert(activity_button, 0)
separator = gtk.SeparatorToolItem()
separator.props.draw = True
activity_button.props.page.insert(separator, -1)
separator.show()
tool = ToolButton('pdf-export')
tool.set_tooltip(_('Portable Document Format (PDF)'))
tool.connect('clicked', self.__export_pdf_cb)
activity_button.props.page.insert(tool, -1)
tool.show()
tool = ToolButton('png-export')
tool.set_tooltip(_('Portable Network Graphic (PNG)'))
tool.connect('clicked', self.__export_png_cb)
activity_button.props.page.insert(tool, -1)
tool.show()
self.edit_toolbar = ToolbarButton()
self.edit_toolbar.props.page = EditToolbar(self)
self.edit_toolbar.props.icon_name = 'toolbar-edit'
self.edit_toolbar.props.label = _('Edit'),
toolbar_box.toolbar.insert(self.edit_toolbar, -1)
self._undo = UndoManager.UndoManager(
self, self.edit_toolbar.props.page.undo.child,
self.edit_toolbar.props.page.redo.child)
self.__build_main_canvas_area()
tool = ToolbarButton()
tool.props.page = ViewToolbar(self._main_area)
tool.props.icon_name = 'toolbar-view'
tool.props.label = _('View'),
toolbar_box.toolbar.insert(tool, -1)
separator = gtk.SeparatorToolItem()
toolbar_box.toolbar.insert(separator, -1)
separator = gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
separator.show()
toolbar_box.toolbar.insert(separator, -1)
target_toolbar = toolbar_box.toolbar
tool_offset = 4
tool = StopButton(self)
toolbar_box.toolbar.insert(tool, -1)
toolbar_box.show_all()
self.set_toolbar_box(toolbar_box)
except NameError:
# Use old <= 0.84 toolbar design
toolbox = activity.ActivityToolbox(self)
self.set_toolbox(toolbox)
activity_toolbar = toolbox.get_activity_toolbar()
keep_palette = activity_toolbar.keep.get_palette()
menu_item = MenuItem(_('Portable Document Format (PDF)'))
menu_item.connect('activate', self.__export_pdf_cb)
keep_palette.menu.append(menu_item)
menu_item.show()
menu_item = MenuItem(_('Portable Network Graphic (PNG)'))
menu_item.connect('activate', self.__export_png_cb)
keep_palette.menu.append(menu_item)
menu_item.show()
self.edit_toolbar = EditToolbar(self)
toolbox.add_toolbar(_('Edit'), self.edit_toolbar)
separator = gtk.SeparatorToolItem()
self.edit_toolbar.insert(separator, 0)
self.edit_toolbar.show()
target_toolbar = self.edit_toolbar
tool_offset = 0
self._undo = UndoManager.UndoManager(self,
self.edit_toolbar.undo.child,
self.edit_toolbar.redo.child)
self.__build_main_canvas_area()
view_toolbar = ViewToolbar(self._main_area)
toolbox.add_toolbar(_('View'), view_toolbar)
activity_toolbar = toolbox.get_activity_toolbar()
activity_toolbar.share.props.visible = False
toolbox.set_current_toolbar(1)
self.mods = [None] * 6
self.mods[0] = RadioToolButton(named_icon='select-mode')
self.mods[0].set_tooltip(_('Edit mode'))
self.mods[0].set_accelerator(_('<ctrl>e'))
self.mods[0].set_group(None)
self.mods[0].connect('clicked', self.__mode_cb, MMapArea.MODE_NULL)
target_toolbar.insert(self.mods[0], tool_offset)
self.mods[1] = RadioToolButton(named_icon='text-mode')
self.mods[1].set_tooltip(_('Text mode'))
self.mods[1].set_accelerator(_('<ctrl>t'))
self.mods[1].set_group(self.mods[0])
self.mods[1].connect('clicked', self.__mode_cb, MMapArea.MODE_TEXT)
target_toolbar.insert(self.mods[1], tool_offset + 1)
self.mods[2] = RadioToolButton(named_icon='draw-mode')
self.mods[2].set_group(self.mods[0])
self.mods[2].set_tooltip(_('Drawing mode'))
self.mods[2].set_accelerator(_('<ctrl>d'))
self.mods[2].connect('clicked', self.__mode_cb, MMapArea.MODE_DRAW)
target_toolbar.insert(self.mods[2], tool_offset + 2)
self.mods[3] = RadioToolButton(named_icon='image-mode')
self.mods[3].set_group(self.mods[0])
self.mods[3].set_tooltip(_('Image add mode'))
self.mods[3].set_accelerator(_('<ctrl>i'))
self.mods[3].connect('clicked', self.__mode_cb, MMapArea.MODE_IMAGE)
target_toolbar.insert(self.mods[3], tool_offset + 3)
self.mods[5] = RadioToolButton(named_icon='label-mode')
self.mods[5].set_tooltip(_('Label mode'))
self.mods[5].set_accelerator(_('<ctrl>a'))
self.mods[5].set_group(self.mods[0])
self.mods[5].connect('clicked', self.__mode_cb, MMapArea.MODE_LABEL)
target_toolbar.insert(self.mods[5], tool_offset + 4)
separator = gtk.SeparatorToolItem()
target_toolbar.insert(separator, tool_offset + 5)
tool = ToolButton('link')
tool.set_tooltip(_('Link/unlink two selected thoughts'))
tool.set_accelerator(_('<ctrl>l'))
tool.connect('clicked', self.__link_cb)
target_toolbar.insert(tool, tool_offset + 6)
tool = ToolButton('edit-delete')
tool.set_tooltip(_('Erase selected thought(s)'))
tool.connect('clicked', self.__delete_cb)
target_toolbar.insert(tool, tool_offset + 7)
self.show_all()
self._mode = MMapArea.MODE_TEXT
self._main_area.set_mode(self._mode)
self.mods[MMapArea.MODE_TEXT].set_active(True)
self.set_focus_child(self._main_area)
def __init__ (self, handle):
if os.path.exists('/tmp/1'):
os.remove('/tmp/1')
activity.Activity.__init__ (self, handle)
# abiword uses the current directory for all its file dialogs
os.chdir(os.path.expanduser('~'))
# create our main abiword canvas
self.abiword_canvas = Canvas()
self.set_canvas(self.abiword_canvas)
self.abiword_canvas.connect_after('map-event', self.__map_event_cb)
self.abiword_canvas.show()
if os.path.exists('/tmp/2'):
os.remove('/tmp/2')
toolbar_box = ToolbarBox()
activity_button = ActivityToolbarButton(self)
separator = gtk.SeparatorToolItem()
separator.show()
activity_button.props.page.insert(separator, 2)
export_button = ExportButton(self, self.abiword_canvas)
export_button.show()
activity_button.props.page.insert(export_button, 2)
toolbar_box.toolbar.insert(activity_button, 0)
edit_toolbar = ToolbarButton()
edit_toolbar.props.page = EditToolbar(self, toolbar_box)
edit_toolbar.props.icon_name = 'toolbar-edit'
edit_toolbar.props.label = _('Edit')
toolbar_box.toolbar.insert(edit_toolbar, -1)
view_toolbar = ToolbarButton()
view_toolbar.props.page = ViewToolbar(self.abiword_canvas)
view_toolbar.props.icon_name = 'toolbar-view'
view_toolbar.props.label = _('View')
toolbar_box.toolbar.insert(view_toolbar, -1)
separator = gtk.SeparatorToolItem()
toolbar_box.toolbar.insert(separator, -1)
toolbar_box.show_all()
self.set_toolbar_box(toolbar_box)
if os.path.exists('/tmp/3'):
os.remove('/tmp/3')
text_toolbar = ToolbarButton()
text_toolbar.props.page = TextToolbar(self.abiword_canvas)
text_toolbar.props.icon_name = 'format-text'
text_toolbar.props.label = _('Text')
toolbar_box.toolbar.insert(text_toolbar, -1)
para_toolbar = ToolbarButton()
para_toolbar.props.page = ParagraphToolbar(self.abiword_canvas)
para_toolbar.props.icon_name = 'paragraph-bar'
para_toolbar.props.label = _('Paragraph')
toolbar_box.toolbar.insert(para_toolbar, -1)
list_toolbar = ToolbarButton()
list_toolbar.props.page = ListToolbar(self.abiword_canvas)
list_toolbar.props.icon_name = 'toolbar-bulletlist'
list_toolbar.props.label = _('Bullet List')
toolbar_box.toolbar.insert(list_toolbar, -1)
insert_toolbar = ToolbarButton()
insert_toolbar.props.page = InsertToolbar(self.abiword_canvas)
insert_toolbar.props.icon_name = 'insert-table'
insert_toolbar.props.label = _('Table')
toolbar_box.toolbar.insert(insert_toolbar, -1)
separator = gtk.SeparatorToolItem()
toolbar_box.toolbar.insert(separator, -1)
bold = ToggleToolButton('format-text-bold')
bold.set_tooltip(_('Bold'))
bold_id = bold.connect('clicked', lambda sender:
self.abiword_canvas.toggle_bold())
self.abiword_canvas.connect('bold', lambda abi, b:
self._setToggleButtonState(bold, b, bold_id))
toolbar_box.toolbar.insert(bold, -1)
italic = ToggleToolButton('format-text-italic')
italic.set_tooltip(_('Italic'))
italic_id = italic.connect('clicked', lambda sender:
self.abiword_canvas.toggle_italic())
self.abiword_canvas.connect('italic', lambda abi, b:
self._setToggleButtonState(italic, b, italic_id))
toolbar_box.toolbar.insert(italic, -1)
underline = ToggleToolButton('format-text-underline')
underline.set_tooltip(_('Underline'))
underline_id = underline.connect('clicked', lambda sender:
self.abiword_canvas.toggle_underline())
self.abiword_canvas.connect('underline', lambda abi, b:
self._setToggleButtonState(underline, b, underline_id))
toolbar_box.toolbar.insert(underline, -1)
separator = gtk.SeparatorToolItem()
toolbar_box.toolbar.insert(separator, -1)
color = ColorToolButton()
color.connect('color-set', self._text_color_cb, self.abiword_canvas)
tool_item = gtk.ToolItem()
tool_item.add(color)
toolbar_box.toolbar.insert(tool_item, -1)
self.abiword_canvas.connect('color', lambda abi, r, g, b:
color.set_color(gtk.gdk.Color(r * 256, g * 256, b * 256)))
separator = gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
separator.show()
toolbar_box.toolbar.insert(separator, -1)
stop = StopButton(self)
toolbar_box.toolbar.insert(stop, -1)
toolbar_box.show_all()
self.set_toolbar_box(toolbar_box)
self._zoom_handler = self.abiword_canvas.connect("zoom", self.__zoom_cb)
def initialize_display(self):
self._logger = logging.getLogger('butialo-activity')
# Top toolbar with share and close buttons:
if OLD_TOOLBAR:
activity_toolbar = self.toolbox.get_activity_toolbar()
else:
activity_toolbar = self.activity_button.page
# add 'make bundle' entry to 'keep' palette.
palette = activity_toolbar.keep.get_palette()
# XXX: should clear out old palette entries?
from sugar.graphics.menuitem import MenuItem
from sugar.graphics.icon import Icon
menu_item = MenuItem(_('As Butialo Document'))
menu_item.set_image(Icon(file=('%s/activity/activity-icon.svg' %
get_bundle_path()),
icon_size=gtk.ICON_SIZE_MENU))
menu_item.connect('activate', self.keepbutton_cb)
palette.menu.append(menu_item)
menu_item.show()
#xop guardar como bundle
#menu_item = MenuItem(_('As Activity Bundle'))
#menu_item.set_image(Icon(file=('%s/activity/activity-default.svg' %
# get_bundle_path()),
# icon_size=gtk.ICON_SIZE_MENU))
#menu_item.connect('activate', self.makebutton_cb)
#palette.menu.append(menu_item)
#menu_item.show()
self._edit_toolbar = activity.EditToolbar()
if OLD_TOOLBAR:
activity_toolbar = gtk.Toolbar()
self.toolbox.add_toolbar(_('Actions'), activity_toolbar)
self.toolbox.set_current_toolbar(1)
self.toolbox.add_toolbar(_('Edit'), self._edit_toolbar)
else:
edit_toolbar_button = ToolbarButton()
edit_toolbar_button.set_page(self._edit_toolbar)
edit_toolbar_button.props.icon_name = 'toolbar-edit'
edit_toolbar_button.props.label = _('Edit')
self.get_toolbar_box().toolbar.insert(edit_toolbar_button, -1)
self._edit_toolbar.show()
self._edit_toolbar.undo.connect('clicked', self.__undobutton_cb)
self._edit_toolbar.redo.connect('clicked', self.__redobutton_cb)
self._edit_toolbar.copy.connect('clicked', self.__copybutton_cb)
self._edit_toolbar.paste.connect('clicked', self.__pastebutton_cb)
if OLD_TOOLBAR:
actions_toolbar = activity_toolbar
else:
actions_toolbar = self.get_toolbar_box().toolbar
# The "go" button
goicon_bw = gtk.Image()
goicon_bw.set_from_file("%s/icons/run_bw.svg" % os.getcwd())
goicon_color = gtk.Image()
goicon_color.set_from_file("%s/icons/run_color.svg" % os.getcwd())
gobutton = ToolButton(label=_("_Run!"))
gobutton.props.accelerator = _('<alt>r')
gobutton.set_icon_widget(goicon_bw)
gobutton.set_tooltip("Run")
gobutton.connect('clicked', self.flash_cb, dict({'bw': goicon_bw,
'color': goicon_color}))
gobutton.connect('clicked', self.gobutton_cb)
actions_toolbar.insert(gobutton, -1)
# The "stop" button
stopicon_bw = gtk.Image()
stopicon_bw.set_from_file("%s/icons/stopit_bw.svg" % os.getcwd())
stopicon_color = gtk.Image()
stopicon_color.set_from_file("%s/icons/stopit_color.svg" % os.getcwd())
stopbutton = ToolButton(label=_("_Stop"))
stopbutton.props.accelerator = _('<alt>s')
stopbutton.set_icon_widget(stopicon_bw)
stopbutton.connect('clicked', self.flash_cb, dict({'bw': stopicon_bw,
'color': stopicon_color}))
stopbutton.connect('clicked', self.stopbutton_cb)
stopbutton.set_tooltip("Stop Running")
actions_toolbar.insert(stopbutton, -1)
# The "refresh" button
refreshicon_bw = gtk.Image()
refreshicon_bw.set_from_file("%s/icons/butiaoff.svg" % os.getcwd())
refreshicon_color = gtk.Image()
refreshicon_color.set_from_file("%s/icons/butiaon.svg" % os.getcwd())
refreshbutton = ToolButton(label=_("_Reload"))
refreshbutton.props.accelerator = _('<alt>d')
refreshbutton.set_icon_widget(refreshicon_bw)
refreshbutton.connect('clicked', self.flash_cb, dict({'bw': refreshicon_bw,
'color': refreshicon_color}))
refreshbutton.connect('clicked', self.initialize_snippets_cb)
refreshbutton.set_tooltip("Reload devices")
actions_toolbar.insert(refreshbutton, -1)
# The "clear" button
#clearicon_bw = gtk.Image()
#clearicon_bw.set_from_file("%s/icons/eraser_bw.svg" % os.getcwd())
#clearicon_color = gtk.Image()
#clearicon_color.set_from_file("%s/icons/eraser_color.svg" %
# os.getcwd())
#clearbutton = ToolButton(label=_("_Clear"))
#clearbutton.props.accelerator = _('<alt>c')
#clearbutton.set_icon_widget(clearicon_bw)
#clearbutton.connect('clicked', self.clearbutton_cb)
#clearbutton.connect('clicked', self.flash_cb, dict({'bw': clearicon_bw,
# 'color': clearicon_color}))
#clearbutton.set_tooltip("Clear")
#actions_toolbar.insert(clearbutton, -1)
# The "beautify" button
beautifyicon_bw = gtk.Image()
beautifyicon_bw.set_from_file("%s/icons/beautifyicon_bw.svg" % os.getcwd())
beautifyicon_color = gtk.Image()
beautifyicon_color.set_from_file("%s/icons/beautifyicon_color.svg" %
os.getcwd())
beautifybutton = ToolButton(label=_("_Auto-format"))
beautifybutton.props.accelerator = _('<alt>f')
beautifybutton.set_icon_widget(beautifyicon_bw)
beautifybutton.connect('clicked', self.beautifybutton_cb)
beautifybutton.connect('clicked', self.flash_cb, dict({'bw': beautifyicon_bw,
'color': beautifyicon_color}))
beautifybutton.set_tooltip("Auto-format")
actions_toolbar.insert(beautifybutton, -1)
activity_toolbar.show()
if not OLD_TOOLBAR:
separator = gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
self.get_toolbar_box().toolbar.insert(separator, -1)
separator.show()
stop = StopButton(self)
self.get_toolbar_box().toolbar.insert(stop, -1)
# Main layout.
self.hpane = gtk.HPaned()
self.vpane = gtk.VPaned()
# The sidebar.
self.sidebar = gtk.VBox()
self.model = gtk.TreeStore(gobject.TYPE_PYOBJECT, gobject.TYPE_STRING)
treeview = gtk.TreeView(self.model)
cellrenderer = gtk.CellRendererText()
treecolumn = gtk.TreeViewColumn(_("Available"), cellrenderer, text=1)
treeview.get_selection().connect("changed", self.selection_cb)
treeview.append_column(treecolumn)
treeview.set_size_request(int(SIZE_X * 0.3), SIZE_Y)
# Create scrollbars around the view.
scrolled = gtk.ScrolledWindow()
scrolled.add(treeview)
self.sidebar.pack_start(scrolled)
self.hpane.add1(self.sidebar)
#root = os.path.join(get_bundle_path(), 'data')
#initialize snippets
self.initialize_snippets_cb(None)
# Source buffer
import gtksourceview2
global text_buffer
lang_manager = gtksourceview2.language_manager_get_default()
if hasattr(lang_manager, 'list_languages'):
langs = lang_manager.list_languages()
else:
lang_ids = lang_manager.get_language_ids()
langs = [lang_manager.get_language(lang_id)
for lang_id in lang_ids]
for lang in langs:
for m in lang.get_mime_types():
if m == "text/x-lua":
text_buffer.set_language(lang)
if hasattr(text_buffer, 'set_highlight'):
text_buffer.set_highlight(True)
else:
text_buffer.set_highlight_syntax(True)
# The GTK source view window
self.text_view = gtksourceview2.View(text_buffer)
self.text_view.set_size_request(0, int(SIZE_Y * 0.5))
self.text_view.set_editable(True)
self.text_view.set_cursor_visible(True)
self.text_view.set_show_line_numbers(True)
self.text_view.set_wrap_mode(gtk.WRAP_CHAR)
self.text_view.set_insert_spaces_instead_of_tabs(True)
self.text_view.set_tab_width(2)
self.text_view.set_auto_indent(True)
self.text_view.modify_font(pango.FontDescription("Monospace " +
str(font_zoom(style.FONT_SIZE))))
# We could change the color theme here, if we want to.
#mgr = gtksourceview2.style_manager_get_default()
#style_scheme = mgr.get_scheme('kate')
#self.text_buffer.set_style_scheme(style_scheme)
codesw = gtk.ScrolledWindow()
codesw.set_policy(gtk.POLICY_AUTOMATIC,
gtk.POLICY_AUTOMATIC)
codesw.add(self.text_view)
self.vpane.add1(codesw)
# An hbox to hold the vte window and its scrollbar.
outbox = gtk.HBox()
# The vte python window
self._vte = vte.Terminal()
self._vte.set_encoding('utf-8')
self._vte.set_size(30, 5)
font = 'Monospace ' + str(font_zoom(style.FONT_SIZE))
self._vte.set_font(pango.FontDescription(font))
self._vte.set_colors(gtk.gdk.color_parse('#000000'),
gtk.gdk.color_parse('#E7E7E7'),
[])
self._vte.connect('child_exited', self.child_exited_cb)
self._child_exited_handler = None
self._vte.drag_dest_set(gtk.DEST_DEFAULT_ALL,
[("text/plain", 0, TARGET_TYPE_TEXT)],
gtk.gdk.ACTION_COPY)
self._vte.connect('drag_data_received', self.vte_drop_cb)
outbox.pack_start(self._vte)
outsb = gtk.VScrollbar(self._vte.get_adjustment())
outsb.show()
outbox.pack_start(outsb, False, False, 0)
self.vpane.add2(outbox)
self.hpane.add2(self.vpane)
return self.hpane
