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 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 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 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)
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 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)
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 = 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 __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 _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()
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_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 _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 __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_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 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 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):
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_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()