def __init__(self, calc):
gtk.Toolbar.__init__(self)
copy_tool = ToolButton('edit-copy')
copy_tool.set_tooltip(_('Copy'))
copy_tool.set_accelerator(_('<ctrl>c'))
copy_tool.connect('clicked', lambda x: calc.text_copy())
self.insert(copy_tool, -1)
menu_item = MenuItem(_('Cut'))
try:
menu_item.set_accelerator(_('<ctrl>x'))
except AttributeError:
pass
menu_item.connect('activate', lambda x: calc.text_cut())
menu_item.show()
copy_tool.get_palette().menu.append(menu_item)
self.insert(IconToolButton('edit-paste', _('Paste'),
lambda x: calc.text_paste(),
alt_html='Paste'), -1)
self.show_all()
def __init__(self, **kwargs):
gtk.ToolItem.__init__(self)
help_button = ToolButton('help-icon')
help_button.set_tooltip(_('Help'))
self.add(help_button)
self._palette = help_button.get_palette()
sw = gtk.ScrolledWindow()
sw.set_size_request(int(gtk.gdk.screen_width() / 2.8),
gtk.gdk.screen_height() - style.GRID_CELL_SIZE * 3)
sw.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
self._max_text_width = int(gtk.gdk.screen_width() / 3) - 20
self._vbox = gtk.VBox()
self._vbox.set_homogeneous(False)
hbox = gtk.HBox()
hbox.pack_start(self._vbox, False, True, 0)
sw.add_with_viewport(hbox)
self._palette.set_content(sw)
sw.show_all()
help_button.connect('clicked', self.__help_button_clicked_cb)
def __init__(self, activity, **kwargs):
gtk.ToolItem.__init__(self)
description_button = ToolButton('edit-description')
description_button.show()
description_button.set_tooltip(_('Description'))
self._palette = description_button.get_palette()
description_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)
text_buffer = gtk.TextBuffer()
if 'description' in activity.metadata:
text_buffer.set_text(activity.metadata['description'])
self._text_view.set_buffer(text_buffer)
self._text_view.connect('focus-out-event',
self.__description_changed_cb, activity)
sw.add(self._text_view)
description_box.pack_start(sw, False, True, 0)
self._palette.set_content(description_box)
description_box.show_all()
self.add(description_button)
description_button.connect('clicked',
self.__description_button_clicked_cb)
activity.metadata.connect('updated', self.__jobject_updated_cb)
def __init__(self, activity, **kwargs):
gtk.ToolItem.__init__(self)
description_button = ToolButton('edit-description')
description_button.show()
description_button.set_tooltip(_('Description'))
self._palette = description_button.get_palette()
description_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)
text_buffer = gtk.TextBuffer()
if 'description' in activity.metadata:
text_buffer.set_text(activity.metadata['description'])
self._text_view.set_buffer(text_buffer)
self._text_view.connect('focus-out-event',
self.__description_changed_cb, activity)
sw.add(self._text_view)
description_box.pack_start(sw, False, True, 0)
self._palette.set_content(description_box)
description_box.show_all()
self.add(description_button)
description_button.connect('clicked',
self.__description_button_clicked_cb)
activity.metadata.connect('updated', self.__jobject_updated_cb)
def __init__(self, **kwargs):
gtk.ToolItem.__init__(self)
help_button = ToolButton('help-icon')
help_button.set_tooltip(_('Help'))
self.add(help_button)
self._palette = help_button.get_palette()
sw = gtk.ScrolledWindow()
sw.set_size_request(int(gtk.gdk.screen_width() / 2.8),
gtk.gdk.screen_height() - style.GRID_CELL_SIZE * 3)
sw.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
self._max_text_width = int(gtk.gdk.screen_width() / 3) - 20
self._vbox = gtk.VBox()
self._vbox.set_homogeneous(False)
hbox = gtk.HBox()
hbox.pack_start(self._vbox, False, True, 0)
sw.add_with_viewport(hbox)
self._palette.set_content(sw)
sw.show_all()
help_button.connect('clicked', self.__help_button_clicked_cb)
def __init__(self, activity):
self._activity = activity
gtk.ToolItem.__init__(self)
help_button = ToolButton('toolbar-help')
help_button.set_tooltip(_('Ayuda'))
self.add(help_button)
help_button.show()
self._palette = help_button.get_palette()
help_button.connect('clicked', self.__help_button_clicked_cb)
def __init__(self, activity):
self._activity = activity
gtk.ToolItem.__init__(self)
help_button = ToolButton('toolbar-help')
help_button.set_tooltip(_('Ayuda'))
self.add(help_button)
help_button.show()
self._palette = help_button.get_palette()
help_button.connect('clicked', self.__help_button_clicked_cb)
def __init__(self, activity):
self._activity = activity
self._current_palette = 'turtle'
gtk.ToolItem.__init__(self)
help_button = ToolButton('help-toolbar')
help_button.set_tooltip(_('Help'))
self.add(help_button)
help_button.show()
self._palette = help_button.get_palette()
help_button.connect('clicked', self.__help_button_clicked_cb)
def __init__(self, activity):
self._activity = activity
self._current_palette = 'turtle'
gtk.ToolItem.__init__(self)
help_button = ToolButton('help-toolbar')
help_button.set_tooltip(_('Help'))
self.add(help_button)
help_button.show()
self._palette = help_button.get_palette()
help_button.connect('clicked', self.__help_button_clicked_cb)
class ReadSDComics(activity.Activity):
__gsignals__ = {
'go-fullscreen': (gobject.SIGNAL_RUN_FIRST,
gobject.TYPE_NONE,
([]))
}
def __init__(self, handle):
"The entry point to the Activity"
activity.Activity.__init__(self, handle)
self._object_id = handle.object_id
self.zoom_image_to_fit = True
self.total_pages = 0
self.connect("expose_event", self.area_expose_cb)
self.connect("delete_event", self.delete_cb)
if _NEW_TOOLBAR_SUPPORT:
self.create_new_toolbar()
else:
self.create_old_toolbar()
self.scrolled = gtk.ScrolledWindow()
self.scrolled.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
self.scrolled.props.shadow_type = gtk.SHADOW_NONE
self.image = gtk.Image()
self.eventbox = gtk.EventBox()
self.eventbox.add(self.image)
self.image.show()
self.eventbox.show()
self.scrolled.add_with_viewport(self.eventbox)
self.eventbox.set_events(gtk.gdk.KEY_PRESS_MASK | gtk.gdk.BUTTON_PRESS_MASK)
self.eventbox.set_flags(gtk.CAN_FOCUS)
self.eventbox.connect("key_press_event", self.keypress_cb)
self.eventbox.connect("button_press_event", self.buttonpress_cb)
self._filechooser = gtk.FileChooserWidget(
action=gtk.FILE_CHOOSER_ACTION_OPEN, backend=None)
filter = gtk.FileFilter()
filter.add_mime_type('application/zip')
filter.add_mime_type('application/x-cbz')
self._filechooser.set_filter(filter)
self._filechooser.set_current_folder("/media")
self.copy_button = gtk.Button(_("Read Comic"))
self.copy_button.connect('clicked', self.select_comic_path)
self.copy_button.show()
self._filechooser.set_extra_widget(self.copy_button)
preview = gtk.Image()
self._filechooser.set_preview_widget(preview)
self._filechooser.connect("update-preview",
self.update_preview_cb, preview)
vbox = gtk.VBox()
vbox.pack_start(self.scrolled)
vbox.pack_end(self._filechooser)
self.set_canvas(vbox)
if self._object_id is None:
self.scrolled.hide()
self._filechooser.show()
else:
self.scrolled.show()
self._filechooser.hide()
vbox.show()
self.page = 0
self.saved_screen_width = 0
self.eventbox.grab_focus()
pixmap = gtk.gdk.Pixmap(None, 1, 1, 1)
color = gtk.gdk.Color()
self.hidden_cursor = gtk.gdk.Cursor(pixmap, pixmap, color, color, 0, 0)
self.cursor_visible = True
self.link = None
self._close_requested = False
def select_comic_path(self, widget, data=None):
filename = self._filechooser.get_filename()
self._filechooser.hide()
self.scrolled.show()
self.link = filename
self.metadata['title'] = self.make_new_filename(self.link)
self._load_document(filename)
def create_old_toolbar(self):
toolbox = activity.ActivityToolbox(self)
activity_toolbar = toolbox.get_activity_toolbar()
activity_toolbar.keep.props.visible = False
activity_toolbar.share.props.visible = False
self.read_toolbar = ReadToolbar()
toolbox.add_toolbar(_('Read'), self.read_toolbar)
self.read_toolbar.show()
self.read_toolbar.set_activity(self)
self.view_toolbar = ViewToolbar()
toolbox.add_toolbar(_('View'), self.view_toolbar)
self.view_toolbar.set_activity(self)
self.view_toolbar.connect('go-fullscreen',
self.__view_toolbar_go_fullscreen_cb)
self.view_toolbar.show()
self.set_toolbox(toolbox)
toolbox.show()
# start on the read toolbar
self.toolbox.set_current_toolbar(_TOOLBAR_READ)
def update_preview_cb(self, file_chooser, preview):
filename = file_chooser.get_preview_filename()
try:
file_mimetype = mime.get_for_file(filename)
if file_mimetype == 'application/x-cbz' or file_mimetype == 'application/zip':
fname = self.extract_image(filename)
pixbuf = gtk.gdk.pixbuf_new_from_file_at_size(fname,
style.zoom(320), style.zoom(240))
preview.set_from_pixbuf(pixbuf)
have_preview = True
os.remove(fname)
else:
have_preview = False
except:
have_preview = False
file_chooser.set_preview_widget_active(have_preview)
return
def extract_image(self, filename):
zf = zipfile.ZipFile(filename, 'r')
image_files = zf.namelist()
image_files.sort()
file_to_extract = image_files[0]
extract_new_filename = self.make_new_filename(file_to_extract)
if extract_new_filename is None or extract_new_filename == '':
# skip over directory name if the images are in a subdirectory.
file_to_extract = image_files[1]
extract_new_filename = self.make_new_filename(file_to_extract)
if len(image_files) > 0:
if self.save_extracted_file(zf, file_to_extract):
fname = os.path.join(self.get_activity_root(), 'instance',
extract_new_filename)
return fname
def create_new_toolbar(self):
toolbar_box = ToolbarBox()
activity_button = MyActivityToolbarButton(self)
toolbar_box.toolbar.insert(activity_button, 0)
activity_button.show()
self.connect('go-fullscreen', \
self.__view_toolbar_go_fullscreen_cb)
self.back = ToolButton('go-previous')
self.back.set_tooltip(_('Back'))
self.back.props.sensitive = False
palette = self.back.get_palette()
self.menu_prev_page = MenuItem(text_label= _("Previous page"))
palette.menu.append(self.menu_prev_page)
self.menu_prev_page.show_all()
self.back.connect('clicked', self.go_back_cb)
self.menu_prev_page.connect('activate', self.go_back_cb)
toolbar_box.toolbar.insert(self.back, -1)
self.back.show()
self.forward = ToolButton('go-next')
self.forward.set_tooltip(_('Forward'))
self.forward.props.sensitive = False
palette = self.forward.get_palette()
self.menu_next_page = MenuItem(text_label= _("Next page"))
palette.menu.append(self.menu_next_page)
self.menu_next_page.show_all()
self.forward.connect('clicked', self.go_forward_cb)
self.menu_next_page.connect('activate', self.go_forward_cb)
toolbar_box.toolbar.insert(self.forward, -1)
self.forward.show()
num_page_item = gtk.ToolItem()
self.num_page_entry = gtk.Entry()
self.num_page_entry.set_text('0')
self.num_page_entry.set_alignment(1)
self.num_page_entry.connect('insert-text',
self.__new_num_page_entry_insert_text_cb)
self.num_page_entry.connect('activate',
self.__new_num_page_entry_activate_cb)
self.num_page_entry.set_width_chars(4)
num_page_item.add(self.num_page_entry)
self.num_page_entry.show()
toolbar_box.toolbar.insert(num_page_item, -1)
num_page_item.show()
total_page_item = gtk.ToolItem()
self.total_page_label = gtk.Label()
label_attributes = pango.AttrList()
label_attributes.insert(pango.AttrSize(14000, 0, -1))
label_attributes.insert(pango.AttrForeground(65535, 65535,
65535, 0, -1))
self.total_page_label.set_attributes(label_attributes)
self.total_page_label.set_text(' / 0')
total_page_item.add(self.total_page_label)
self.total_page_label.show()
toolbar_box.toolbar.insert(total_page_item, -1)
total_page_item.show()
spacer = gtk.SeparatorToolItem()
toolbar_box.toolbar.insert(spacer, -1)
spacer.show()
self._zoom_out = ToolButton('zoom-out')
self._zoom_out.set_tooltip(_('Zoom out'))
self._zoom_out.connect('clicked', self._zoom_out_cb)
toolbar_box.toolbar.insert(self._zoom_out, -1)
self._zoom_out.props.sensitive = False
self._zoom_out.show()
self._zoom_in = ToolButton('zoom-in')
self._zoom_in.set_tooltip(_('Zoom in'))
self._zoom_in.connect('clicked', self._zoom_in_cb)
toolbar_box.toolbar.insert(self._zoom_in, -1)
self._zoom_in.props.sensitive = True
self._zoom_in.show()
self._fullscreen = ToolButton('view-fullscreen')
self._fullscreen.set_tooltip(_('Fullscreen'))
self._fullscreen.connect('clicked', self._fullscreen_cb)
toolbar_box.toolbar.insert(self._fullscreen, -1)
self._fullscreen.show()
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 _zoom_in_cb(self, button):
self._zoom_in.props.sensitive = False
self._zoom_out.props.sensitive = True
self.zoom_to_width()
def _zoom_out_cb(self, button):
self._zoom_in.props.sensitive = True
self._zoom_out.props.sensitive = False
self.zoom_to_fit()
def enable_zoom_in(self):
self._zoom_in.props.sensitive = True
self._zoom_out.props.sensitive = False
def enable_zoom_out(self):
self._zoom_in.props.sensitive = False
self._zoom_out.props.sensitive = True
def _fullscreen_cb(self, button):
self.emit('go-fullscreen')
def __new_num_page_entry_insert_text_cb(self, entry, text, length, position):
if not re.match('[0-9]', text):
entry.emit_stop_by_name('insert-text')
return True
return False
def __new_num_page_entry_activate_cb(self, entry):
if entry.props.text:
page = int(entry.props.text) - 1
else:
page = 0
if page >= self.total_pages:
page = self.total_pages - 1
elif page < 0:
page = 0
self.set_current_page(page)
self.show_page(page)
entry.props.text = str(page + 1)
self.update_nav_buttons()
def go_back_cb(self, button):
self.previous_page()
def go_forward_cb(self, button):
self.next_page()
def update_nav_buttons(self):
current_page = self.page
self.back.props.sensitive = current_page > 0
self.forward.props.sensitive = \
current_page < self.total_pages - 1
self.num_page_entry.props.text = str(current_page + 1)
self.total_page_label.props.label = \
' / ' + str(self.total_pages)
def set_total_pages(self, pages):
self.total_pages = pages
def setToggleButtonState(self,button,b,id):
button.handler_block(id)
button.set_active(b)
button.handler_unblock(id)
def buttonpress_cb(self, widget, event):
widget.grab_focus()
def __view_toolbar_go_fullscreen_cb(self, view_toolbar):
self.fullscreen()
def zoom_to_width(self):
self.zoom_image_to_fit = False
self.show_page(self.page)
def zoom_to_fit(self):
self.zoom_image_to_fit = True
self.show_page(self.page)
def keypress_cb(self, widget, event):
"Respond when the user presses Escape or one of the arrow keys"
keyname = gtk.gdk.keyval_name(event.keyval)
if keyname == 'Page_Up':
self.previous_page()
return True
if keyname == 'Page_Down' :
self.next_page()
return True
if keyname == 'KP_Right':
self.scroll_down()
return True
if keyname == 'Down' or keyname == 'KP_Down':
self.scroll_down()
return True
if keyname == 'Up' or keyname == 'KP_Up':
self.scroll_up()
return True
if keyname == 'KP_Left':
self.scroll_up()
return True
if keyname == 'KP_Home':
if self.cursor_visible:
self.window.set_cursor(self.hidden_cursor)
self.cursor_visible = False
else:
self.window.set_cursor(None)
self.cursor_visible = True
return True
if keyname == 'plus':
self.view_toolbar.enable_zoom_out()
self.zoom_to_width()
return True
if keyname == 'minus':
self.view_toolbar.enable_zoom_in()
self.zoom_to_fit()
return True
return False
def scroll_down(self):
v_adjustment = self.scrolled.get_vadjustment()
if v_adjustment.value == v_adjustment.upper - v_adjustment.page_size:
self.next_page()
return
if v_adjustment.value < v_adjustment.upper - v_adjustment.page_size:
new_value = v_adjustment.value + v_adjustment.step_increment
if new_value > v_adjustment.upper - v_adjustment.page_size:
new_value = v_adjustment.upper - v_adjustment.page_size
v_adjustment.value = new_value
def scroll_up(self):
v_adjustment = self.scrolled.get_vadjustment()
if v_adjustment.value == v_adjustment.lower:
self.previous_page()
return
if v_adjustment.value > v_adjustment.lower:
new_value = v_adjustment.value - v_adjustment.step_increment
if new_value < v_adjustment.lower:
new_value = v_adjustment.lower
v_adjustment.value = new_value
def previous_page(self):
page = self.page
page=page-1
if page < 0: page=0
if self.save_extracted_file(self.zf, self.image_files[page]) == True:
fname = os.path.join(self.get_activity_root(), 'instance', self.make_new_filename(self.image_files[page]))
self.show_image(fname)
os.remove(fname)
v_adjustment = self.scrolled.get_vadjustment()
v_adjustment.value = v_adjustment.upper - v_adjustment.page_size
if _NEW_TOOLBAR_SUPPORT:
self.set_current_page(page)
else:
self.read_toolbar.set_current_page(page)
self.page = page
def set_current_page(self, page):
self.page = page
if _NEW_TOOLBAR_SUPPORT:
self.update_nav_buttons()
def next_page(self):
page = self.page
page = page + 1
if page >= len(self.image_files): page=len(self.image_files) - 1
if self.save_extracted_file(self.zf, self.image_files[page]) == True:
fname = os.path.join(self.get_activity_root(), 'instance', self.make_new_filename(self.image_files[page]))
self.show_image(fname)
os.remove(fname)
v_adjustment = self.scrolled.get_vadjustment()
v_adjustment.value = v_adjustment.lower
if _NEW_TOOLBAR_SUPPORT:
self.set_current_page(page)
else:
self.read_toolbar.set_current_page(page)
self.page = page
def area_expose_cb(self, area, event):
screen_width = gtk.gdk.screen_width()
screen_height = gtk.gdk.screen_height()
if self.saved_screen_width != screen_width and self.saved_screen_width != 0:
self.show_page(self.page)
self.saved_screen_width = screen_width
return False
def show_page(self, page):
if self.save_extracted_file(self.zf, self.image_files[page]) == True:
fname = os.path.join(self.get_activity_root(), 'instance', self.make_new_filename(self.image_files[page]))
self.show_image(fname)
os.remove(fname)
def show_image(self, filename):
"display a resized image in a full screen window"
TOOLBOX_HEIGHT = 60
BORDER_WIDTH = 30
# get the size of the fullscreen display
screen_width = gtk.gdk.screen_width()
screen_width = screen_width - BORDER_WIDTH
screen_height = gtk.gdk.screen_height()
screen_height = screen_height - TOOLBOX_HEIGHT
# get the size of the image.
im = pygame.image.load(filename)
image_width, image_height = im.get_size()
getcontext().prec = 7
s_a_ratio = Decimal(screen_height) / Decimal(screen_width)
i_a_ratio = Decimal(image_height) / Decimal(image_width)
new_width = image_width
new_height = image_height
if self.zoom_image_to_fit == True:
if s_a_ratio >= i_a_ratio:
new_width = screen_width
new_height = image_height * screen_width
if image_width > 1:
new_height /= image_width
if new_height > screen_width:
new_height *= screen_width
if new_width > 1:
new_height /= new_width
new_width = screen_width
else:
new_height = screen_height
new_width = image_width * screen_height
if image_height > 1:
new_width /= image_height
if new_width > screen_height:
new_width *= screen_height
if new_height > 1:
new_width /= new_height
new_height = screen_height
else:
new_width = screen_width
new_height = image_height * screen_width
if image_width > 1:
new_height /= image_width
if new_height > screen_width:
new_height *= screen_width
if new_width > 1:
new_height /= new_width
new_width = screen_width
pixbuf = gtk.gdk.pixbuf_new_from_file(filename)
scaled_buf = pixbuf.scale_simple(new_width, new_height, gtk.gdk.INTERP_BILINEAR)
self.image.set_from_pixbuf(scaled_buf)
self.image.show()
def save_extracted_file(self, zipfile, filename):
"Extract the file to a temp directory for viewing"
try:
filebytes = zipfile.read(filename)
except BadZipfile, err:
print 'Error opening the zip file: %s' % (err)
return False
except KeyError, err:
self._alert('Key Error', 'Zipfile key not found: ' + str(filename))
return
class SensorToolbar(gtk.Toolbar):
""" The toolbar for specifiying the sensor: sound, resitance, or
voltage """
LOWER = 0.0
UPPER = 1.0
STR_DC_R = (
_(
"Resistive sensor (connect sensor to pink 'Mic In' on left side \
of XO)"
)
+ " "
)
STR_DC_V = (
_(
"Voltage sensor (connect sensor to pink 'Mic In' on left side \
of XO)"
)
+ " "
)
STR_AC = _("Sound") + " "
STR_RESISTANCE = _("Resistance") + " (" + _("Ohms") + ") "
STR_VOLTAGE = _("Voltage") + " (" + _("Volts") + ") "
STR_TIME = _("Time Base") + " "
STR_FREQUENCY = _("Frequency Base") + " "
STR_INVERT = " " + _("Invert") + " "
STR_XAXIS_TEXT = _("X Axis Scale: 1 division = %(division)s %(unit)s")
# TRANSLATORS: This is milli seconds.
MS = _("ms")
# TRANSLATORS: This is Hertz, so 1/second.
HZ = _("Hz")
def __init__(self, activity, channels):
""" By default, start with resistance mode """
gtk.Toolbar.__init__(self)
self.activity = activity
self._channels = channels
self._lock_radio_buttons = False
self._radio_button_pushed = False
self.values = []
for i in range(self._channels):
self.values.append("")
self.string_for_textbox = ""
self.gain = 1.0
self.y_mag = 3.0
self.capture_gain = CAPTURE_GAIN
self.mic_boost = MIC_BOOST
self.mode = "sound"
# Set up Time-domain Button
self.time = RadioToolButton(group=None)
self.time.set_named_icon("media-audio")
self.insert(self.time, -1)
self.time.set_tooltip(_("Sound"))
self.time.connect("clicked", self.analog_resistance_voltage_mode_cb, "sound")
# Set up Resistance Button
self.resistance = RadioToolButton(group=self.time)
self.resistance.set_named_icon("resistance")
if _is_xo(self.activity.hw):
self.insert(self.resistance, -1)
self.resistance.show()
self.resistance.set_tooltip(_("Resistance Sensor"))
self.resistance.connect("clicked", self.analog_resistance_voltage_mode_cb, "resistance")
# Set up Voltage Button
self.voltage = RadioToolButton(group=self.time)
self.voltage.set_named_icon("voltage")
if _is_xo(self.activity.hw):
self.insert(self.voltage, -1)
self.voltage.set_tooltip(_("Voltage Sensor"))
self.voltage.connect("clicked", self.analog_resistance_voltage_mode_cb, "voltage")
separator = gtk.SeparatorToolItem()
separator.props.draw = True
self.insert(separator, -1)
self._log_value = LOG_TIMER_VALUES[1]
self.log_label = gtk.Label(self._log_to_string(self._log_value))
toolitem = gtk.ToolItem()
toolitem.add(self.log_label)
self.insert(toolitem, -1)
self._log_button = ToolButton("timer-10")
self._log_button.set_tooltip(_("Select logging interval"))
self._log_button.connect("clicked", self._log_selection_cb)
self.insert(self._log_button, -1)
self._setup_log_palette()
# Set up Logging/Stop Logging Button
self._record = ToolButton("media-record")
self.insert(self._record, -1)
self._record.set_tooltip(_("Start logging"))
self._record.connect("clicked", self.record_control_cb)
separator = gtk.SeparatorToolItem()
separator.props.draw = True
self.insert(separator, -1)
toolitem = gtk.ToolItem()
self.trigger_label = gtk.Label(_("Trigger"))
toolitem.add(self.trigger_label)
self.insert(toolitem, -1)
# Set up Trigger Combo box
self.trigger_none = RadioToolButton()
self.trigger_none.set_named_icon("trigger-none")
self.insert(self.trigger_none, -1)
self.trigger_none.set_tooltip(_("None"))
self.trigger_none.connect("clicked", self.update_trigger_control_cb, self.activity.wave.TRIGGER_NONE)
self.trigger_rise = RadioToolButton(group=self.trigger_none)
self.trigger_rise.set_named_icon("trigger-rise")
self.insert(self.trigger_rise, -1)
self.trigger_rise.set_tooltip(_("Rising Edge"))
self.trigger_rise.connect("clicked", self.update_trigger_control_cb, self.activity.wave.TRIGGER_POS)
self.trigger_fall = RadioToolButton(group=self.trigger_none)
self.trigger_fall.set_named_icon("trigger-fall")
self.insert(self.trigger_fall, -1)
self.trigger_fall.set_tooltip(_("Falling Edge"))
self.trigger_fall.connect("clicked", self.update_trigger_control_cb, self.activity.wave.TRIGGER_NEG)
self.show_all()
def get_log(self):
return self._log_value
def get_log_idx(self):
if self._log_value in LOG_TIMER_VALUES:
return LOG_TIMER_VALUES.index(self._log_value)
else:
return LOG_TIMER_VALUES[0]
def set_log_idx(self, idx):
self._log_value = LOG_TIMER_VALUES[idx]
self.log_label.set_text(self._log_to_string(self._log_value))
if hasattr(self, "_log_button"):
self._log_button.set_icon("timer-%d" % (self._log_value))
def _log_selection_cb(self, widget):
if self._log_palette:
if not self._log_palette.is_up():
self._log_palette.popup(immediate=True, state=self._log_palette.SECONDARY)
else:
self._log_palette.popdown(immediate=True)
return
def _log_to_seconds(self, tenth_seconds):
return tenth_seconds / 10.0
def _log_to_string(self, tenth_seconds):
if tenth_seconds in LOG_TIMER_LABELS:
return LOG_TIMER_LABELS[tenth_seconds]
else:
return _("1 second")
def _setup_log_palette(self):
self._log_palette = self._log_button.get_palette()
for tenth_seconds in LOG_TIMER_VALUES:
text = self._log_to_string(tenth_seconds)
menu_item = MenuItem(icon_name="timer-%d" % (tenth_seconds), text_label=self._log_to_string(tenth_seconds))
menu_item.connect("activate", self._log_selected_cb, tenth_seconds)
self._log_palette.menu.append(menu_item)
menu_item.show()
def _log_selected_cb(self, button, seconds):
self.set_log_idx(LOG_TIMER_VALUES.index(seconds))
def add_frequency_slider(self, toolbox):
""" Either on the Sound toolbar or the Main toolbar """
self._freq_stepper_up = ToolButton("freq-high")
self._freq_stepper_up.set_tooltip(_("Zoom out"))
self._freq_stepper_up.connect("clicked", self._freq_stepper_up_cb)
self._freq_stepper_up.show()
self.activity.adjustmentf = gtk.Adjustment(0.5, self.LOWER, self.UPPER, 0.01, 0.1, 0)
self.activity.adjustmentf.connect("value_changed", self.cb_page_sizef)
self._freq_range = gtk.HScale(self.activity.adjustmentf)
self._freq_range.set_inverted(True)
self._freq_range.set_draw_value(False)
self._freq_range.set_update_policy(gtk.UPDATE_CONTINUOUS)
self._freq_range.set_size_request(120, 15)
self._freq_range.show()
self._freq_stepper_down = ToolButton("freq-low")
self._freq_stepper_down.set_tooltip(_("Zoom in"))
self._freq_stepper_down.connect("clicked", self._freq_stepper_down_cb)
self._freq_stepper_down.show()
self._freq_range_tool = gtk.ToolItem()
self._freq_range_tool.add(self._freq_range)
self._freq_range_tool.show()
toolbox.add(self._freq_stepper_up)
toolbox.add(self._freq_range_tool)
toolbox.add(self._freq_stepper_down)
return
def update_trigger_control_cb(self, button, value):
if button is None:
value = self.activity.wave.TRIGGER_NONE
if self.activity.wave.get_fft_mode():
self.trigger_none.set_active(True)
else:
self.activity.wave.set_trigger(value)
def analog_resistance_voltage_mode_cb(self, button=None, mode_to_set="sound"):
""" Callback for Analog/Resistance/Voltage Buttons """
if self._lock_radio_buttons:
logging.debug("mode selector locked")
self._radio_button_pushed = True
return
if self.mode == mode_to_set:
logging.debug("mode already set to %s" % mode_to_set)
return
self._lock_radio_buttons = True
if self.activity.CONTEXT == "sound":
self.sound_context_off()
else:
self.sensor_context_off()
# Force time domain when switching modes
if self.activity.wave.get_fft_mode():
self.activity.timefreq_control()
# Turn off logging when switching modes
if self.activity.audiograb.we_are_logging:
self.record_control_cb()
self.set_mode(mode_to_set)
if mode_to_set == "sound":
self.set_sound_context()
elif mode_to_set == "resistance":
self.set_sensor_context()
elif mode_to_set == "voltage":
self.set_sensor_context()
self.update_string_for_textbox()
return False
def unlock_radio_buttons(self):
""" Enable radio button selection """
logging.debug("unlocking radio buttons")
if self._radio_button_pushed:
if self.mode == "sound":
self.time.set_active(True)
elif self.mode == "resistance":
self.resistance.set_active(True)
elif self.mode == "voltage":
self.voltage.set_active(True)
self._lock_radio_buttons = False
self._radio_button_pushed = False
def set_mode(self, mode="sound"):
""" Set the mixer settings to match the current mode. """
self.mode = mode
self.activity.audiograb.set_sensor_type(self.mode)
for i in range(self._channels):
self.values[i] = 0.0
return
def get_mode(self):
""" Get the mixer settings. """
return self.mode
def _freq_stepper_up_cb(self, button=None):
""" Moves the horizontal zoom slider to the left one notch,
where one notch is 1/100 of the total range. This correspond
to zooming out as a larger number of Hertz or milliseconds
will be represented by the same space on the screen. """
new_value = self._freq_range.get_value() + (self.UPPER - self.LOWER) / 100.0
if new_value <= self.UPPER:
self._freq_range.set_value(new_value)
else:
self._freq_range.set_value(self.UPPER)
def _freq_stepper_down_cb(self, button=None):
""" Moves the horizontal zoom slider to the right one notch,
where one notch is 1/100 of the total range. This corresponds
to zooming in. """
new_value = self._freq_range.get_value() - (self.UPPER - self.LOWER) / 100.0
if new_value >= self.LOWER:
self._freq_range.set_value(new_value)
else:
self._freq_range.set_value(self.LOWER)
def cb_page_sizef(self, button=None):
""" Callback to scale the frequency range (zoom in and out) """
if self._update_page_size_id:
gobject.source_remove(self._update_page_size_id)
self._update_page_size_id = gobject.timeout_add(250, self.update_page_size)
return True
def update_page_size(self):
""" Set up the scaling of the display. """
self._update_page_size_id = None
new_value = round(self.activity.adjustmentf.value * 100.0) / 100.0
if self.activity.adjustmentf.value != new_value:
self.activity.adjustmentf.value = new_value
return False
time_div = 0.001 * max(self.activity.adjustmentf.value, 0.05)
freq_div = 1000 * max(self.activity.adjustmentf.value, 0.01)
self.activity.wave.set_div(time_div, freq_div)
self.update_string_for_textbox()
return False
def set_sound_context(self):
""" Called when analog sensing is selected """
self.set_show_hide_windows(mode="sound")
gobject.timeout_add(500, self.sound_context_on)
self.activity.CONTEXT = "sound"
def set_sensor_context(self):
""" Called when digital sensing is selected """
self.set_show_hide_windows(mode="sensor")
gobject.timeout_add(500, self.sensor_context_on)
self.activity.CONTEXT = "sensor"
def set_show_hide_windows(self, mode="sound"):
""" Shows the appropriate window identified by the mode """
self.activity.wave.set_context_on()
for i in range(self._channels):
self.activity.side_toolbars[i].set_show_hide(True, mode)
def sensor_context_off(self):
""" Called when a DC sensor is no longer selected """
# self.activity.audiograb.pause_grabbing()
self.activity.audiograb.stop_grabbing()
def sensor_context_on(self):
""" Called when a DC sensor is selected """
self.update_string_for_textbox()
self.activity.wave.set_trigger(self.activity.wave.TRIGGER_NONE)
# self.activity.audiograb.resume_grabbing()
self.activity.audiograb.start_grabbing()
return False
def sound_context_off(self):
""" Called when an analog sensor is no longer selected """
self.gain, self.y_mag = self.activity.wave.get_mag_params()
self.capture_gain = self.activity.audiograb.get_capture_gain()
self.mic_boost = self.activity.audiograb.get_mic_boost()
self.activity.audiograb.stop_grabbing()
def sound_context_on(self):
""" Called when an analog sensor is selected """
self.activity.wave.set_mag_params(self.gain, self.y_mag)
self.update_string_for_textbox()
self.update_trigger_control_cb(None, self.activity.wave.TRIGGER_NONE)
self.activity.audiograb.start_grabbing()
return False
def set_sample_value(self, value="", channel=0):
""" Write a sample value to the textbox. """
gtk.threads_enter()
self.values[channel] = value
self.update_string_for_textbox()
gtk.threads_leave()
return
def record_control_cb(self, button=None):
""" Depending upon the selected interval, does either a logging
session, or just logs the current buffer. """
if self.activity.audiograb.we_are_logging:
self.activity.audiograb.set_logging_params(start_stop=False)
self._record.set_icon("media-record")
self._record.show()
self._record.set_tooltip(_("Start Recording"))
else:
Xscale = 1.00 / self.activity.audiograb.get_sampling_rate()
Yscale = 0.0
interval = self._log_value / 10.0 # self.interval_convert()
username = self.activity.nick
if self.activity.wave.get_fft_mode():
self.activity.data_logger.start_new_session(
username,
Xscale,
Yscale,
self._log_to_string(self._log_value),
channels=self._channels,
mode="frequency",
)
else:
self.activity.data_logger.start_new_session(
username,
Xscale,
Yscale,
self._log_to_string(self._log_value),
channels=self._channels,
mode=self.mode,
)
self.activity.audiograb.set_logging_params(start_stop=True, interval=interval, screenshot=False)
self._record.set_icon("record-stop")
self._record.show()
self._record.set_tooltip(_("Stop Recording"))
self.activity.new_recording = True
def update_string_for_textbox(self):
""" Update the status field at the bottom of the canvas. """
if self.mode == "resistance":
string_for_textbox = self.STR_DC_R + "\n"
string_for_textbox += self.STR_RESISTANCE
elif self.mode == "voltage":
string_for_textbox = self.STR_DC_V + "\n"
string_for_textbox += self.STR_VOLTAGE
else:
string_for_textbox = self.STR_AC + "\t"
if self.activity.wave.get_fft_mode():
scalex = self.STR_XAXIS_TEXT % {"unit": self.HZ, "division": self.activity.wave.freq_div}
string_for_textbox += self.STR_FREQUENCY
string_for_textbox += "\n" + scalex
elif self.mode == "sound":
scalex = self.STR_XAXIS_TEXT % {"unit": self.MS, "division": self.activity.wave.time_div * 1000}
string_for_textbox += self.STR_TIME
string_for_textbox += "\n" + scalex
else:
for i in range(self._channels):
string_for_textbox += "\t(%s)" % (self.values[i])
invert = False
for i in range(self._channels):
if self.activity.wave.get_invert_state(channel=i):
invert = True
if invert:
string_for_textbox += self.STR_INVERT
self.activity.text_box.set_label(string_for_textbox)
class ViewToolbar(gtk.Toolbar):
__gtype_name__ = 'ViewToolbar'
__gsignals__ = {
'go-fullscreen': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE, ([])),
}
def __init__(self):
gtk.Toolbar.__init__(self)
self._view = None
self._zoom_out = ToolButton('zoom-out')
self._zoom_out.set_tooltip(_('Zoom out'))
self._zoom_out.connect('clicked', self._zoom_out_cb)
self.insert(self._zoom_out, -1)
self._zoom_out.show()
self._zoom_in = ToolButton('zoom-in')
self._zoom_in.set_tooltip(_('Zoom in'))
self._zoom_in.connect('clicked', self._zoom_in_cb)
self.insert(self._zoom_in, -1)
self._zoom_in.show()
self._zoom_to_width = ToolButton('zoom-best-fit')
self._zoom_to_width.set_tooltip(_('Zoom to width'))
self._zoom_to_width.connect('clicked', self._zoom_to_width_cb)
self.insert(self._zoom_to_width, -1)
self._zoom_to_width.show()
palette = self._zoom_to_width.get_palette()
menu_item = MenuItem(_('Zoom to fit'))
menu_item.connect('activate', self._zoom_to_fit_menu_item_activate_cb)
palette.menu.append(menu_item)
menu_item.show()
menu_item = MenuItem(_('Actual size'))
menu_item.connect('activate', self._actual_size_menu_item_activate_cb)
palette.menu.append(menu_item)
menu_item.show()
tool_item = gtk.ToolItem()
self.insert(tool_item, -1)
tool_item.show()
self._zoom_spin = gtk.SpinButton()
self._zoom_spin.set_range(5.409, 400)
self._zoom_spin.set_increments(1, 10)
self._zoom_spin_notify_value_handler = self._zoom_spin.connect(
'notify::value', self._zoom_spin_notify_value_cb)
tool_item.add(self._zoom_spin)
self._zoom_spin.show()
zoom_perc_label = gtk.Label(_("%"))
zoom_perc_label.show()
tool_item_zoom_perc_label = gtk.ToolItem()
tool_item_zoom_perc_label.add(zoom_perc_label)
self.insert(tool_item_zoom_perc_label, -1)
tool_item_zoom_perc_label.show()
spacer = gtk.SeparatorToolItem()
spacer.props.draw = False
self.insert(spacer, -1)
spacer.show()
self._fullscreen = ToolButton('view-fullscreen')
self._fullscreen.set_tooltip(_('Fullscreen'))
self._fullscreen.connect('clicked', self._fullscreen_cb)
self.insert(self._fullscreen, -1)
self._fullscreen.show()
self._view_notify_zoom_handler = None
def set_view(self, view):
self._view = view
self._zoom_spin.props.value = self._view.get_zoom()
self._view_notify_zoom_handler = \
self._view.connect_zoom_handler(self._view_notify_zoom_cb)
self._update_zoom_buttons()
def _zoom_spin_notify_value_cb(self, zoom_spin, pspec):
self._view.set_zoom(zoom_spin.props.value)
def _view_notify_zoom_cb(self, model, pspec):
self._zoom_spin.disconnect(self._zoom_spin_notify_value_handler)
try:
self._zoom_spin.props.value = round(self._view.get_zoom())
finally:
self._zoom_spin_notify_value_handler = self._zoom_spin.connect(
'notify::value', self._zoom_spin_notify_value_cb)
def zoom_in(self):
self._view.zoom_in()
self._update_zoom_buttons()
def _zoom_in_cb(self, button):
self.zoom_in()
def zoom_out(self):
self._view.zoom_out()
self._update_zoom_buttons()
def _zoom_out_cb(self, button):
self.zoom_out()
def zoom_to_width(self):
self._view.zoom_to_width()
self._update_zoom_buttons()
def _zoom_to_width_cb(self, button):
self.zoom_to_width()
def _update_zoom_buttons(self):
self._zoom_in.props.sensitive = self._view.can_zoom_in()
self._zoom_out.props.sensitive = self._view.can_zoom_out()
self._zoom_to_width.props.sensitive = self._view.can_zoom_to_width()
def _zoom_to_fit_menu_item_activate_cb(self, menu_item):
self._view.zoom_to_best_fit()
self._update_zoom_buttons()
def _actual_size_menu_item_activate_cb(self, menu_item):
self._view.zoom_to_actual_size()
self._update_zoom_buttons()
def _fullscreen_cb(self, button):
self.emit('go-fullscreen')
class TextAttributesToolbar(gtk.Toolbar):
def __init__(self, main_area):
gtk.Toolbar.__init__(self)
self._main_area = main_area
self._font_list = ['ABC123', 'Sans', 'Serif', 'Monospace', 'Symbol']
self._font_sizes = [
'8', '9', '10', '11', '12', '14', '16', '20', '22', '24', '26',
'28', '36', '48', '72'
]
self.font_button = ToolButton('font-text')
self.font_button.set_tooltip(_('Select font'))
self.font_button.connect('clicked', self.__font_selection_cb)
self.insert(self.font_button, -1)
self._setup_font_palette()
self.insert(gtk.SeparatorToolItem(), -1)
self.font_size_up = ToolButton('resize+')
self.font_size_up.set_tooltip(_('Bigger'))
self.font_size_up.connect('clicked', self.__font_sizes_cb, True)
self.insert(self.font_size_up, -1)
if len(self._main_area.selected) > 0:
font_size = self._main_area.font_size
else:
font_size = utils.default_font_size
self.size_label = gtk.Label(str(font_size))
self.size_label.show()
toolitem = gtk.ToolItem()
toolitem.add(self.size_label)
toolitem.show()
self.insert(toolitem, -1)
self.font_size_down = ToolButton('resize-')
self.font_size_down.set_tooltip(_('Smaller'))
self.font_size_down.connect('clicked', self.__font_sizes_cb, False)
self.insert(self.font_size_down, -1)
self.insert(gtk.SeparatorToolItem(), -1)
self.bold = ToolButton('bold-text')
self.bold.set_tooltip(_('Bold'))
self.bold.connect('clicked', self.__bold_cb)
self.insert(self.bold, -1)
self.italics = ToolButton('italics-text')
self.italics.set_tooltip(_('Italics'))
self.italics.connect('clicked', self.__italics_cb)
self.insert(self.italics, -1)
self.underline = ToolButton('underline-text')
self.underline.set_tooltip(_('Underline'))
self.underline.connect('clicked', self.__underline_cb)
self.insert(self.underline, -1)
foreground_color = ColorToolButton()
foreground_color.set_title(_('Set font color'))
foreground_color.connect('color-set', self.__foreground_color_cb)
self.insert(foreground_color, -1)
bakground_color = ColorToolButton()
bakground_color.set_title(_('Set background color'))
bakground_color.connect('color-set', self.__background_color_cb)
bakground_color.set_color(gtk.gdk.Color(65535, 65535, 65535))
self.insert(bakground_color, -1)
self.show_all()
def __font_selection_cb(self, widget):
if self._font_palette:
if not self._font_palette.is_up():
self._font_palette.popup(immediate=True,
state=self._font_palette.SECONDARY)
else:
self._font_palette.popdown(immediate=True)
return
def _init_font_list(self):
self._font_white_list = []
self._font_white_list.extend(DEFAULT_FONTS)
# check if there are a user configuration file
if not os.path.exists(USER_FONTS_FILE_PATH):
# verify if exists a file in /etc
if os.path.exists(GLOBAL_FONTS_FILE_PATH):
shutil.copy(GLOBAL_FONTS_FILE_PATH, USER_FONTS_FILE_PATH)
if os.path.exists(USER_FONTS_FILE_PATH):
# get the font names in the file to the white list
fonts_file = open(USER_FONTS_FILE_PATH)
# get the font names in the file to the white list
for line in fonts_file:
self._font_white_list.append(line.strip())
# monitor changes in the file
gio_fonts_file = gio.File(USER_FONTS_FILE_PATH)
self.monitor = gio_fonts_file.monitor_file()
self.monitor.set_rate_limit(5000)
self.monitor.connect('changed', self._reload_fonts)
def _reload_fonts(self, monitor, gio_file, other_file, event):
if event != gio.FILE_MONITOR_EVENT_CHANGES_DONE_HINT:
return
self._font_white_list = []
self._font_white_list.extend(DEFAULT_FONTS)
fonts_file = open(USER_FONTS_FILE_PATH)
for line in fonts_file:
self._font_white_list.append(line.strip())
# update the menu
for child in self._font_palette.menu.get_children():
self._font_palette.menu.remove(child)
child = None
context = self.get_pango_context()
tmp_list = []
for family in context.list_families():
name = family.get_name()
if name in self._font_white_list:
tmp_list.append(name)
for font in sorted(tmp_list):
menu_item = MyMenuItem(image=FontImage(font.replace(' ', '-')),
text_label=font)
menu_item.connect('activate', self.__font_selected_cb, font)
self._font_palette.menu.append(menu_item)
menu_item.show()
return False
def _setup_font_palette(self):
self._init_font_list()
context = self._main_area.pango_context
for family in context.list_families():
name = pango.FontDescription(family.get_name()).to_string()
if name not in self._font_list and \
name in self._font_white_list:
self._font_list.append(name)
self._font_palette = self.font_button.get_palette()
for font in sorted(self._font_list):
menu_item = MyMenuItem(image=FontImage(font.replace(' ', '-')),
text_label=font)
menu_item.connect('activate', self.__font_selected_cb, font)
self._font_palette.menu.append(menu_item)
menu_item.show()
def __font_selected_cb(self, widget, font_name):
if not hasattr(self._main_area, 'font_name'):
return
if len(self._main_area.selected) > 0:
font_size = self._main_area.font_size
else:
font_size = utils.default_font_size
self._main_area.set_font(font_name, font_size)
self._main_area.font_name = font_name
self._main_area.font_size = font_size
def __attribute_values(self):
attributes = {
"bold": True,
"italics": True,
"underline": True,
"font": ""
}
it = self._main_area.selected[0].attributes.get_iterator()
start_index = self._main_area.selected[0].index
end_index = self._main_area.selected[0].end_index
while (1):
found = False
r = it.range()
if start_index == end_index:
if r[0] <= start_index and r[1] > start_index:
found = True
elif start_index < end_index:
if r[0] > end_index:
break
if start_index == end_index and \
r[0] < start_index and \
r[1] > start_index:
found = True
elif start_index != end_index and r[0] <= start_index and \
r[1] >= end_index:
found = True
else:
if r[0] > start_index:
break
if start_index == end_index and \
r[0] < start_index and \
r[1] > start_index:
found = True
elif start_index != end_index and r[0] <= end_index and \
r[1] >= start_index:
found = True
if found:
attr = it.get_attrs()
for x in attr:
if x.type == pango.ATTR_WEIGHT and \
x.value == pango.WEIGHT_BOLD:
attributes["bold"] = False
elif x.type == pango.ATTR_STYLE and \
x.value == pango.STYLE_ITALIC:
attributes["italics"] = False
elif x.type == pango.ATTR_UNDERLINE and \
x.value == pango.UNDERLINE_SINGLE:
attributes["underline"] = False
elif x.type == pango.ATTR_FONT_DESC:
attributes["font"] = x.desc
if it.next() == False:
break
return attributes
def __font_sizes_cb(self, button, increase):
if not hasattr(self._main_area, 'font_size'):
return
if len(self._main_area.selected) < 1:
return
font_size = self._main_area.font_size
if font_size in self._font_sizes:
i = self._font_sizes.index(font_size)
if increase:
if i < len(self._font_sizes) - 2:
i += 1
else:
if i > 0:
i -= 1
else:
i = self._font_sizes.index(utils.default_font_size)
font_size = self._font_sizes[i]
self.size_label.set_text(str(font_size))
self.font_size_down.set_sensitive(i != 0)
self.font_size_up.set_sensitive(i < len(self._font_sizes) - 2)
self._main_area.set_font(self._main_area.font_name, font_size)
def __bold_cb(self, button):
if len(self._main_area.selected) < 1:
return
value = self.__attribute_values()["bold"]
self._main_area.set_bold(value)
def __italics_cb(self, button):
if len(self._main_area.selected) < 1:
return
value = self.__attribute_values()["italics"]
self._main_area.set_italics(value)
def __underline_cb(self, button):
if len(self._main_area.selected) < 1:
return
value = self.__attribute_values()["underline"]
self._main_area.set_underline(value)
def __foreground_color_cb(self, button):
color = button.get_color()
self._main_area.set_foreground_color(color)
def __background_color_cb(self, button):
color = button.get_color()
self._parent._main_area.set_background_color(color)
def change_active_font(self):
# TODO: update the toolbar
return
class ReadToolbar(gtk.Toolbar):
__gtype_name__ = 'ReadToolbar'
def __init__(self):
gtk.Toolbar.__init__(self)
self.back = ToolButton('go-previous')
self.back.set_tooltip(_('Back'))
self.back.props.sensitive = False
palette = self.back.get_palette()
self.prev_page = MenuItem(text_label=_("Previous page"))
palette.menu.append(self.prev_page)
self.prev_page.show_all()
self.back.connect('clicked', self.go_back_cb)
self.prev_page.connect('activate', self.go_back_cb)
self.insert(self.back, -1)
self.back.show()
self.forward = ToolButton('go-next')
self.forward.set_tooltip(_('Forward'))
self.forward.props.sensitive = False
palette = self.forward.get_palette()
self.next_page = MenuItem(text_label=_("Next page"))
palette.menu.append(self.next_page)
self.next_page.show_all()
self.forward.connect('clicked', self.go_forward_cb)
self.next_page.connect('activate', self.go_forward_cb)
self.insert(self.forward, -1)
self.forward.show()
num_page_item = gtk.ToolItem()
self._num_page_entry = gtk.Entry()
self._num_page_entry.set_text('0')
self._num_page_entry.set_alignment(1)
self._num_page_entry.connect('insert-text',
self._num_page_entry_insert_text_cb)
self._num_page_entry.connect('activate',
self._num_page_entry_activate_cb)
self._num_page_entry.set_width_chars(4)
num_page_item.add(self._num_page_entry)
self._num_page_entry.show()
self.insert(num_page_item, -1)
num_page_item.show()
total_page_item = gtk.ToolItem()
self._total_page_label = gtk.Label()
label_attributes = pango.AttrList()
label_attributes.insert(pango.AttrSize(14000, 0, -1))
label_attributes.insert(
pango.AttrForeground(65535, 65535, 65535, 0, -1))
self._total_page_label.set_attributes(label_attributes)
self._total_page_label.set_text(' / 0')
total_page_item.add(self._total_page_label)
self._total_page_label.show()
self.insert(total_page_item, -1)
total_page_item.show()
def _num_page_entry_insert_text_cb(self, entry, text, length, position):
if not re.match('[0-9]', text):
entry.emit_stop_by_name('insert-text')
return True
return False
def _num_page_entry_activate_cb(self, entry):
if entry.props.text:
page = int(entry.props.text) - 1
else:
page = 0
if page >= self.total_pages:
page = self.total_pages - 1
elif page < 0:
page = 0
self.current_page = page
self.activity.set_current_page(page)
self.activity.show_page(page)
entry.props.text = str(page + 1)
self._update_nav_buttons()
def go_back_cb(self, button):
self.activity.previous_page()
def go_forward_cb(self, button):
self.activity.next_page()
def _update_nav_buttons(self):
current_page = self.current_page
self.back.props.sensitive = current_page > 0
self.forward.props.sensitive = \
current_page < self.total_pages - 1
self._num_page_entry.props.text = str(current_page + 1)
self._total_page_label.props.label = \
' / ' + str(self.total_pages)
def set_total_pages(self, pages):
self.total_pages = pages
def set_current_page(self, page):
self.current_page = page
self._update_nav_buttons()
def set_activity(self, activity):
self.activity = activity
def setToggleButtonState(self, button, b, id):
button.handler_block(id)
button.set_active(b)
button.handler_unblock(id)
class TextAttributesToolbar(gtk.Toolbar):
def __init__(self, main_area):
gtk.Toolbar.__init__(self)
self._main_area = main_area
self._font_list = ['ABC123', 'Sans', 'Serif', 'Monospace', 'Symbol']
self._font_sizes = ['8', '9', '10', '11', '12', '14', '16', '20',
'22', '24', '26', '28', '36', '48', '72']
self.font_button = ToolButton('font-text')
self.font_button.set_tooltip(_('Select font'))
self.font_button.connect('clicked', self.__font_selection_cb)
self.insert(self.font_button, -1)
self._setup_font_palette()
self.insert(gtk.SeparatorToolItem(), -1)
self.font_size_up = ToolButton('resize+')
self.font_size_up.set_tooltip(_('Bigger'))
self.font_size_up.connect('clicked', self.__font_sizes_cb, True)
self.insert(self.font_size_up, -1)
if len(self._main_area.selected) > 0:
font_size = self._main_area.font_size
else:
font_size = utils.default_font_size
self.size_label = gtk.Label(str(font_size))
self.size_label.show()
toolitem = gtk.ToolItem()
toolitem.add(self.size_label)
toolitem.show()
self.insert(toolitem, -1)
self.font_size_down = ToolButton('resize-')
self.font_size_down.set_tooltip(_('Smaller'))
self.font_size_down.connect('clicked', self.__font_sizes_cb, False)
self.insert(self.font_size_down, -1)
self.insert(gtk.SeparatorToolItem(), -1)
self.bold = ToolButton('bold-text')
self.bold.set_tooltip(_('Bold'))
self.bold.connect('clicked', self.__bold_cb)
self.insert(self.bold, -1)
self.italics = ToolButton('italics-text')
self.italics.set_tooltip(_('Italics'))
self.italics.connect('clicked', self.__italics_cb)
self.insert(self.italics, -1)
self.underline = ToolButton('underline-text')
self.underline.set_tooltip(_('Underline'))
self.underline.connect('clicked', self.__underline_cb)
self.insert(self.underline, -1)
foreground_color = ColorToolButton()
foreground_color.set_title(_('Set font color'))
foreground_color.connect('color-set', self.__foreground_color_cb)
self.insert(foreground_color, -1)
bakground_color = ColorToolButton()
bakground_color.set_title(_('Set background color'))
bakground_color.connect('color-set', self.__background_color_cb)
bakground_color.set_color(gtk.gdk.Color(65535, 65535, 65535))
self.insert(bakground_color, -1)
self.show_all()
def __font_selection_cb(self, widget):
if self._font_palette:
if not self._font_palette.is_up():
self._font_palette.popup(immediate=True,
state=self._font_palette.SECONDARY)
else:
self._font_palette.popdown(immediate=True)
return
def _init_font_list(self):
self._font_white_list = []
self._font_white_list.extend(DEFAULT_FONTS)
# check if there are a user configuration file
if not os.path.exists(USER_FONTS_FILE_PATH):
# verify if exists a file in /etc
if os.path.exists(GLOBAL_FONTS_FILE_PATH):
shutil.copy(GLOBAL_FONTS_FILE_PATH, USER_FONTS_FILE_PATH)
if os.path.exists(USER_FONTS_FILE_PATH):
# get the font names in the file to the white list
fonts_file = open(USER_FONTS_FILE_PATH)
# get the font names in the file to the white list
for line in fonts_file:
self._font_white_list.append(line.strip())
# monitor changes in the file
gio_fonts_file = gio.File(USER_FONTS_FILE_PATH)
self.monitor = gio_fonts_file.monitor_file()
self.monitor.set_rate_limit(5000)
self.monitor.connect('changed', self._reload_fonts)
def _reload_fonts(self, monitor, gio_file, other_file, event):
if event != gio.FILE_MONITOR_EVENT_CHANGES_DONE_HINT:
return
self._font_white_list = []
self._font_white_list.extend(DEFAULT_FONTS)
fonts_file = open(USER_FONTS_FILE_PATH)
for line in fonts_file:
self._font_white_list.append(line.strip())
# update the menu
for child in self._font_palette.menu.get_children():
self._font_palette.menu.remove(child)
child = None
context = self.get_pango_context()
tmp_list = []
for family in context.list_families():
name = family.get_name()
if name in self._font_white_list:
tmp_list.append(name)
for font in sorted(tmp_list):
menu_item = MyMenuItem(image=FontImage(font.replace(' ', '-')),
text_label=font)
menu_item.connect('activate', self.__font_selected_cb, font)
self._font_palette.menu.append(menu_item)
menu_item.show()
return False
def _setup_font_palette(self):
self._init_font_list()
context = self._main_area.pango_context
for family in context.list_families():
name = pango.FontDescription(family.get_name()).to_string()
if name not in self._font_list and \
name in self._font_white_list:
self._font_list.append(name)
self._font_palette = self.font_button.get_palette()
for font in sorted(self._font_list):
menu_item = MyMenuItem(image=FontImage(font.replace(' ', '-')),
text_label=font)
menu_item.connect('activate', self.__font_selected_cb, font)
self._font_palette.menu.append(menu_item)
menu_item.show()
def __font_selected_cb(self, widget, font_name):
if not hasattr(self._main_area, 'font_name'):
return
if len(self._main_area.selected) > 0:
font_size = self._main_area.font_size
else:
font_size = utils.default_font_size
self._main_area.set_font(font_name, font_size)
self._main_area.font_name = font_name
self._main_area.font_size = font_size
def __attribute_values(self):
attributes = {"bold": True, "italics": True, "underline": True,
"font": ""}
it = self._main_area.selected[0].attributes.get_iterator()
start_index = self._main_area.selected[0].index
end_index = self._main_area.selected[0].end_index
while(1):
found = False
r = it.range()
if start_index == end_index:
if r[0] <= start_index and r[1] > start_index:
found = True
elif start_index < end_index:
if r[0] > end_index:
break
if start_index == end_index and \
r[0] < start_index and \
r[1] > start_index:
found = True
elif start_index != end_index and r[0] <= start_index and \
r[1] >= end_index:
found = True
else:
if r[0] > start_index:
break
if start_index == end_index and \
r[0] < start_index and \
r[1] > start_index:
found = True
elif start_index != end_index and r[0] <= end_index and \
r[1] >= start_index:
found = True
if found:
attr = it.get_attrs()
for x in attr:
if x.type == pango.ATTR_WEIGHT and \
x.value == pango.WEIGHT_BOLD:
attributes["bold"] = False
elif x.type == pango.ATTR_STYLE and \
x.value == pango.STYLE_ITALIC:
attributes["italics"] = False
elif x.type == pango.ATTR_UNDERLINE and \
x.value == pango.UNDERLINE_SINGLE:
attributes["underline"] = False
elif x.type == pango.ATTR_FONT_DESC:
attributes["font"] = x.desc
if not it.next():
break
return attributes
def __font_sizes_cb(self, button, increase):
if not hasattr(self._main_area, 'font_size'):
return
if len(self._main_area.selected) < 1:
return
font_size = self._main_area.font_size
if font_size in self._font_sizes:
i = self._font_sizes.index(font_size)
if increase:
if i < len(self._font_sizes) - 2:
i += 1
else:
if i > 0:
i -= 1
else:
i = self._font_sizes.index(utils.default_font_size)
font_size = self._font_sizes[i]
self.size_label.set_text(str(font_size))
self.font_size_down.set_sensitive(i != 0)
self.font_size_up.set_sensitive(i < len(self._font_sizes) - 2)
self._main_area.set_font(self._main_area.font_name, font_size)
def __bold_cb(self, button):
if len(self._main_area.selected) < 1:
return
value = self.__attribute_values()["bold"]
self._main_area.set_bold(value)
def __italics_cb(self, button):
if len(self._main_area.selected) < 1:
return
value = self.__attribute_values()["italics"]
self._main_area.set_italics(value)
def __underline_cb(self, button):
if len(self._main_area.selected) < 1:
return
value = self.__attribute_values()["underline"]
self._main_area.set_underline(value)
def __foreground_color_cb(self, button):
color = button.get_color()
self._main_area.set_foreground_color(color)
def __background_color_cb(self, button):
color = button.get_color()
self._parent._main_area.set_background_color(color)
def change_active_font(self):
# TODO: update the toolbar
return
class ReadToolbar(gtk.Toolbar):
__gtype_name__ = 'ReadToolbar'
def __init__(self):
gtk.Toolbar.__init__(self)
self.back = ToolButton('go-previous')
self.back.set_tooltip(_('Back'))
self.back.props.sensitive = False
palette = self.back.get_palette()
self.prev_page = MenuItem(text_label= _("Previous page"))
palette.menu.append(self.prev_page)
self.prev_page.show_all()
self.back.connect('clicked', self.go_back_cb)
self.prev_page.connect('activate', self.go_back_cb)
self.insert(self.back, -1)
self.back.show()
self.forward = ToolButton('go-next')
self.forward.set_tooltip(_('Forward'))
self.forward.props.sensitive = False
palette = self.forward.get_palette()
self.next_page = MenuItem(text_label= _("Next page"))
palette.menu.append(self.next_page)
self.next_page.show_all()
self.forward.connect('clicked', self.go_forward_cb)
self.next_page.connect('activate', self.go_forward_cb)
self.insert(self.forward, -1)
self.forward.show()
num_page_item = gtk.ToolItem()
self._num_page_entry = gtk.Entry()
self._num_page_entry.set_text('0')
self._num_page_entry.set_alignment(1)
self._num_page_entry.connect('insert-text',
self._num_page_entry_insert_text_cb)
self._num_page_entry.connect('activate',
self._num_page_entry_activate_cb)
self._num_page_entry.set_width_chars(4)
num_page_item.add(self._num_page_entry)
self._num_page_entry.show()
self.insert(num_page_item, -1)
num_page_item.show()
total_page_item = gtk.ToolItem()
self._total_page_label = gtk.Label()
label_attributes = pango.AttrList()
label_attributes.insert(pango.AttrSize(14000, 0, -1))
label_attributes.insert(pango.AttrForeground(65535, 65535, 65535, 0, -1))
self._total_page_label.set_attributes(label_attributes)
self._total_page_label.set_text(' / 0')
total_page_item.add(self._total_page_label)
self._total_page_label.show()
self.insert(total_page_item, -1)
total_page_item.show()
def _num_page_entry_insert_text_cb(self, entry, text, length, position):
if not re.match('[0-9]', text):
entry.emit_stop_by_name('insert-text')
return True
return False
def _num_page_entry_activate_cb(self, entry):
if entry.props.text:
page = int(entry.props.text) - 1
else:
page = 0
if page >= self.total_pages:
page = self.total_pages - 1
elif page < 0:
page = 0
self.current_page = page
self.activity.set_current_page(page)
self.activity.show_page(page)
entry.props.text = str(page + 1)
self._update_nav_buttons()
def go_back_cb(self, button):
self.activity.previous_page()
def go_forward_cb(self, button):
self.activity.next_page()
def _update_nav_buttons(self):
current_page = self.current_page
self.back.props.sensitive = current_page > 0
self.forward.props.sensitive = \
current_page < self.total_pages - 1
self._num_page_entry.props.text = str(current_page + 1)
self._total_page_label.props.label = \
' / ' + str(self.total_pages)
def set_total_pages(self, pages):
self.total_pages = pages
def set_current_page(self, page):
self.current_page = page
self._update_nav_buttons()
def set_activity(self, activity):
self.activity = activity
def setToggleButtonState(self,button,b,id):
button.handler_block(id)
button.set_active(b)
button.handler_unblock(id)
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
class TuningToolbar(gtk.Toolbar):
''' The toolbar for tuning instruments '''
def __init__(self, activity):
gtk.Toolbar.__init__(self)
self.activity = activity
self._show_tuning_line = False
self._updating_note = True
self._tuning_tool = None
self._instrument_button = ToolButton('instruments')
self._instrument_button.set_tooltip(_('Tune an instrument.'))
self._instrument_button.connect('clicked', self._button_selection_cb)
self.insert(self._instrument_button, -1)
self._setup_instrument_palette()
separator = gtk.SeparatorToolItem()
separator.props.draw = True
self.insert(separator, -1)
self._note = 'A'
self._notes_button = ToolButton('notes')
self._notes_button.set_tooltip(_('Notes'))
self._notes_button.connect('clicked', self._button_selection_cb)
self.insert(self._notes_button, -1)
self._setup_notes_palette()
self._octave = 4
self._octaves_button = ToolButton('octaves')
self._octaves_button.set_tooltip(_('Octaves'))
self._octaves_button.connect('clicked', self._button_selection_cb)
self.insert(self._octaves_button, -1)
self._setup_octaves_palette()
# The entry is used to display a note or for direct user input
self._freq_entry = gtk.Entry()
self._freq_entry.set_text('440') # A
self._freq_entry_changed_id = self._freq_entry.connect(
'changed', self._update_freq_entry)
if hasattr(self._freq_entry, 'set_tooltip_text'):
self._freq_entry.set_tooltip_text(
_('Enter a frequency to display.'))
self._freq_entry.set_width_chars(8)
self._freq_entry.show()
toolitem = gtk.ToolItem()
toolitem.add(self._freq_entry)
self.insert(toolitem, -1)
toolitem.show()
self._new_tuning_line = ToolButton('tuning-tools')
self._new_tuning_line.show()
self.insert(self._new_tuning_line, -1)
self._new_tuning_line.set_tooltip(_('Show tuning line.'))
self._new_tuning_line.connect('clicked', self.tuning_line_cb)
separator = gtk.SeparatorToolItem()
separator.props.draw = True
self.insert(separator, -1)
self._harmonic = ToolButton('harmonics')
self._harmonic.show()
self.insert(self._harmonic, -1)
self._harmonic.set_tooltip(_('Show harmonics.'))
self._harmonic.connect('clicked', self.harmonic_cb)
separator = gtk.SeparatorToolItem()
separator.props.draw = True
self.insert(separator, -1)
self._play_tone = ToolButton('media-playback-start')
self._play_tone.show()
self.insert(self._play_tone, -1)
self._play_tone.set_tooltip(_('Play a note.'))
self._play_tone.connect('clicked', self.play_cb)
separator = gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
self.insert(separator, -1)
self.label = gtk.Label('')
self.label.set_use_markup(True)
self.label.show()
toolitem = gtk.ToolItem()
toolitem.add(self.label)
self.insert(toolitem, -1)
toolitem.show()
self.show_all()
def _update_note(self):
''' Calculate the frequency based on note and octave '''
if not hasattr(self, '_freq_entry'): # Still setting up toolbar
return
i = self._octave * 12 + NOTES.index(self._note)
freq = A0 * pow(TWELTHROOT2, i)
self._updating_note = True
self._freq_entry.set_text('%0.3f' % (freq))
self.label.set_markup(
SPAN %
(style.COLOR_WHITE.get_html(), self._note + str(self._octave)))
if self._show_tuning_line:
self.activity.wave.tuning_line = freq
return
def _update_freq_entry(self, widget):
# Calculate a note from a frequency
if not self._updating_note: # Only if user types in a freq.
try:
freq = float(self._freq_entry.get_text())
# Only consider notes in piano range
if freq < A0 * 0.97:
self.label.set_text('< A0')
return
if freq > C8 * 1.03:
self.label.set_text('> C8')
return
self.label.set_markup(freq_note(freq, flatsharp=True))
except ValueError:
return
self._updating_note = False
def _button_selection_cb(self, widget):
palette = widget.get_palette()
if palette:
if not palette.is_up():
palette.popup(immediate=True, state=palette.SECONDARY)
else:
palette.popdown(immediate=True)
return
def _setup_notes_palette(self):
self._notes_palette = self._notes_button.get_palette()
for note in NOTES:
menu_item = MenuItem(icon_name='', text_label=note)
menu_item.connect('activate', self._note_selected_cb, note)
self._notes_palette.menu.append(menu_item)
menu_item.show()
def _note_selected_cb(self, widget, note):
self._note = note
self._update_note()
def _setup_octaves_palette(self):
self._octaves_palette = self._octaves_button.get_palette()
for octave in range(9):
menu_item = MenuItem(icon_name='', text_label=str(octave))
menu_item.connect('activate', self._octave_selected_cb, octave)
self._octaves_palette.menu.append(menu_item)
menu_item.show()
def _octave_selected_cb(self, widget, octave):
self._octave = octave
self._update_note()
def _setup_instrument_palette(self):
self.instrument_palette = self._instrument_button.get_palette()
self.instrument = []
for k in INSTRUMENT_DICT.keys():
self.instrument.append(k)
menu_item = MenuItem(icon_name='', text_label=k)
menu_item.connect('activate', self.instrument_selected_cb, k)
self.instrument_palette.menu.append(menu_item)
menu_item.show()
def instrument_selected_cb(self, button, instrument):
''' Callback for instrument control '''
logging.debug(instrument)
if self._tuning_tool is not None:
self.remove(self._tuning_tool)
if instrument == _('None'):
self.activity.wave.instrument = None
# Remove any previous tuning button
if hasattr(self, '_tuning_button'):
self._tuning_button.destroy()
# Restore the notes, octaves buttons
if hasattr(self, '_notes_button'):
self.insert(self._notes_button, 2)
self.insert(self._octaves_button, 3)
return
self.remove(self._notes_button)
self.remove(self._octaves_button)
self.activity.wave.instrument = instrument
# If we are not already in freq. base, switch.
if not self.activity.wave.get_fft_mode():
self.activity.timefreq_control()
# Add a Tuning palette for this instrument
self._tuning_button = ToolButton('notes')
self._tuning_button.set_tooltip(instrument)
self._tuning_button.connect('clicked', self._button_selection_cb)
self.insert(self._tuning_button, 1)
self._setup_tuning_palette(instrument)
def _setup_tuning_palette(self, instrument):
self._tuning_palette = self._tuning_button.get_palette()
self.tuning = []
self.tuning.append(_('All notes'))
menu_item = MenuItem(icon_name='', text_label=_('All notes'))
menu_item.connect('activate', self._tuning_selected_cb, instrument, -1)
self._tuning_palette.menu.append(menu_item)
menu_item.show()
for i, f in enumerate(INSTRUMENT_DICT[instrument]):
self.tuning.append(freq_note(f))
menu_item = MenuItem(icon_name='', text_label=freq_note(f))
menu_item.connect('activate', self._tuning_selected_cb, instrument,
i)
self._tuning_palette.menu.append(menu_item)
menu_item.show()
self.show_all()
def _tuning_selected_cb(self, widget, instrument, fidx):
''' Update note '''
if not hasattr(self, '_freq_entry'): # Still setting up toolbar?
return
if not instrument in INSTRUMENT_DICT:
return
if fidx == -1: # All notes
self.activity.wave.instrument = instrument
self.activity.wave.tuning_line = 0.0
self._new_tuning_line.set_icon('tuning-tools')
self._new_tuning_line.set_tooltip(_('Show tuning line.'))
self._show_tuning_line = False
else:
freq = INSTRUMENT_DICT[instrument][fidx]
self.activity.wave.instrument = None
self.activity.wave.tuning_line = freq
self._new_tuning_line.set_icon('tuning-tools-off')
self._new_tuning_line.set_tooltip(_('Hide tuning line.'))
self._show_tuning_line = True
self._updating_note = False
def harmonic_cb(self, *args):
''' Callback for harmonics control '''
self.activity.wave.harmonics = not self.activity.wave.harmonics
if self.activity.wave.harmonics:
self._harmonic.set_icon('harmonics-off')
self._harmonic.set_tooltip(_('Hide harmonics.'))
if self.activity.wave.instrument is None and \
self.activity.wave.tuning_line == 0.0:
self._load_tuning_line()
else:
self._harmonic.set_icon('harmonics')
self._harmonic.set_tooltip(_('Show harmonics.'))
def tuning_line_cb(self, *args):
''' Callback for tuning insert '''
if self._show_tuning_line:
self.activity.wave.tuning_line = 0.0
self._new_tuning_line.set_icon('tuning-tools')
self._new_tuning_line.set_tooltip(_('Show tuning line.'))
self._show_tuning_line = False
else:
self._load_tuning_line()
def _load_tuning_line(self):
''' Read the freq entry and use value to set tuning line '''
freq = self._freq_entry.get_text()
try:
self.activity.wave.tuning_line = float(freq)
if freq < 0:
freq = -freq
self._new_tuning_line.set_icon('tuning-tools-off')
self._new_tuning_line.set_tooltip(_('Hide tuning line.'))
self._show_tuning_line = True
except ValueError:
self.activity.wave.tuning_line = 0.0
self._freq_entry.set_text('0')
# If we are not already in freq. base, switch.
if not self.activity.wave.get_fft_mode():
self.activity.timefreq_control()
def play_cb(self, *args):
''' Save settings, turn off display, and then play a tone at
the current frequency '''
channels = []
for c in range(self.activity.audiograb.channels):
channels.append(self.activity.wave.get_visibility(channel=c))
self.activity.wave.set_visibility(False, channel=c)
wave_status = self.activity.wave.get_active()
self.activity.wave.set_context_off()
self.activity.wave.set_active(False)
if self.activity.hw in [XO4, XO175]:
self.activity.audiograb.stop_grabbing()
freq = float(self._freq_entry.get_text())
gobject.timeout_add(200, self.play_sound, freq, channels, wave_status)
def play_sound(self, freq, channels, wave_status):
''' Play the sound and then restore wave settings '''
self._play_sinewave(freq, 5000, 1)
if self.activity.hw in [XO4, XO175]:
self.activity.sensor_toolbar.set_mode('sound')
self.activity.sensor_toolbar.set_sound_context()
self.activity.audiograb.start_grabbing()
for c in range(self.activity.audiograb.channels):
self.activity.wave.set_visibility(channels[c], channel=c)
self.activity.wave.set_context_on()
self.activity.wave.set_active(wave_status)
def _play_sinewave(self, pitch, amplitude=5000, duration=1):
""" Create a Csound score to play a sine wave. """
self.orchlines = []
self.scorelines = []
self.instrlist = []
try:
pitch = abs(float(pitch))
amplitude = abs(float(amplitude))
duration = abs(float(duration))
except ValueError:
logging.error('bad args to _play_sinewave')
return
self._prepare_sinewave(pitch, amplitude, duration)
path = os.path.join(self.activity.get_activity_root(), 'instance',
'tmp.csd')
# Create a csound file from the score.
self._audio_write(path)
# Play the csound file.
output = check_output(['csound', path], 'call to csound failed?')
# os.system('csound ' + path + ' > /dev/null 2>&1')
def _prepare_sinewave(self,
pitch,
amplitude,
duration,
starttime=0,
pitch_envelope=99,
amplitude_envelope=100,
instrument=1):
pitenv = pitch_envelope
ampenv = amplitude_envelope
if not 1 in self.instrlist:
self.orchlines.append("instr 1\n")
self.orchlines.append("kpitenv oscil 1, 1/p3, p6\n")
self.orchlines.append("aenv oscil 1, 1/p3, p7\n")
self.orchlines.append("asig oscil p5*aenv, p4*kpitenv, p8\n")
self.orchlines.append("out asig\n")
self.orchlines.append("endin\n\n")
self.instrlist.append(1)
self.scorelines.append(
"i1 %s %s %s %s %s %s %s\n" %
(str(starttime), str(duration), str(pitch), str(amplitude),
str(pitenv), str(ampenv), str(instrument)))
def _audio_write(self, file):
""" Compile a .csd file. """
csd = open(file, "w")
csd.write("<CsoundSynthesizer>\n\n")
csd.write("<CsOptions>\n")
csd.write("-+rtaudio=alsa -odevaudio -m0 -d -b256 -B512\n")
csd.write("</CsOptions>\n\n")
csd.write("<CsInstruments>\n\n")
csd.write("sr=16000\n")
csd.write("ksmps=50\n")
csd.write("nchnls=1\n\n")
for line in self.orchlines:
csd.write(line)
csd.write("\n</CsInstruments>\n\n")
csd.write("<CsScore>\n\n")
csd.write("f1 0 2048 10 1\n")
csd.write("f2 0 2048 10 1 0 .33 0 .2 0 .143 0 .111\n")
csd.write("f3 0 2048 10 1 .5 .33 .25 .2 .175 .143 .125 .111 .1\n")
csd.write("f10 0 2048 10 1 0 0 .3 0 .2 0 0 .1\n")
csd.write("f99 0 2048 7 1 2048 1\n")
csd.write("f100 0 2048 7 0. 10 1. 1900 1. 132 0.\n")
csd.write(self.scorelines.pop())
csd.write("e\n")
csd.write("\n</CsScore>\n")
csd.write("\n</CsoundSynthesizer>")
csd.close()
class ReadSDComics(activity.Activity):
__gsignals__ = {
'go-fullscreen': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE, ([]))
}
def __init__(self, handle):
"The entry point to the Activity"
activity.Activity.__init__(self, handle)
self._object_id = handle.object_id
self.zoom_image_to_fit = True
self.total_pages = 0
self.connect("expose_event", self.area_expose_cb)
self.connect("delete_event", self.delete_cb)
if _NEW_TOOLBAR_SUPPORT:
self.create_new_toolbar()
else:
self.create_old_toolbar()
self.scrolled = gtk.ScrolledWindow()
self.scrolled.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
self.scrolled.props.shadow_type = gtk.SHADOW_NONE
self.image = gtk.Image()
self.eventbox = gtk.EventBox()
self.eventbox.add(self.image)
self.image.show()
self.eventbox.show()
self.scrolled.add_with_viewport(self.eventbox)
self.eventbox.set_events(gtk.gdk.KEY_PRESS_MASK
| gtk.gdk.BUTTON_PRESS_MASK)
self.eventbox.set_flags(gtk.CAN_FOCUS)
self.eventbox.connect("key_press_event", self.keypress_cb)
self.eventbox.connect("button_press_event", self.buttonpress_cb)
self._filechooser = gtk.FileChooserWidget(
action=gtk.FILE_CHOOSER_ACTION_OPEN, backend=None)
filter = gtk.FileFilter()
filter.add_mime_type('application/zip')
filter.add_mime_type('application/x-cbz')
self._filechooser.set_filter(filter)
self._filechooser.set_current_folder("/media")
self.copy_button = gtk.Button(_("Read Comic"))
self.copy_button.connect('clicked', self.select_comic_path)
self.copy_button.show()
self._filechooser.set_extra_widget(self.copy_button)
preview = gtk.Image()
self._filechooser.set_preview_widget(preview)
self._filechooser.connect("update-preview", self.update_preview_cb,
preview)
vbox = gtk.VBox()
vbox.pack_start(self.scrolled)
vbox.pack_end(self._filechooser)
self.set_canvas(vbox)
if self._object_id is None:
self.scrolled.hide()
self._filechooser.show()
else:
self.scrolled.show()
self._filechooser.hide()
vbox.show()
self.page = 0
self.saved_screen_width = 0
self.eventbox.grab_focus()
pixmap = gtk.gdk.Pixmap(None, 1, 1, 1)
color = gtk.gdk.Color()
self.hidden_cursor = gtk.gdk.Cursor(pixmap, pixmap, color, color, 0, 0)
self.cursor_visible = True
self.link = None
self._close_requested = False
def select_comic_path(self, widget, data=None):
filename = self._filechooser.get_filename()
self._filechooser.hide()
self.scrolled.show()
self.link = filename
self.metadata['title'] = self.make_new_filename(self.link)
self._load_document(filename)
def create_old_toolbar(self):
toolbox = activity.ActivityToolbox(self)
activity_toolbar = toolbox.get_activity_toolbar()
activity_toolbar.keep.props.visible = False
activity_toolbar.share.props.visible = False
self.read_toolbar = ReadToolbar()
toolbox.add_toolbar(_('Read'), self.read_toolbar)
self.read_toolbar.show()
self.read_toolbar.set_activity(self)
self.view_toolbar = ViewToolbar()
toolbox.add_toolbar(_('View'), self.view_toolbar)
self.view_toolbar.set_activity(self)
self.view_toolbar.connect('go-fullscreen',
self.__view_toolbar_go_fullscreen_cb)
self.view_toolbar.show()
self.set_toolbox(toolbox)
toolbox.show()
# start on the read toolbar
self.toolbox.set_current_toolbar(_TOOLBAR_READ)
def update_preview_cb(self, file_chooser, preview):
filename = file_chooser.get_preview_filename()
try:
file_mimetype = mime.get_for_file(filename)
if file_mimetype == 'application/x-cbz' or file_mimetype == 'application/zip':
fname = self.extract_image(filename)
pixbuf = gtk.gdk.pixbuf_new_from_file_at_size(
fname, style.zoom(320), style.zoom(240))
preview.set_from_pixbuf(pixbuf)
have_preview = True
os.remove(fname)
else:
have_preview = False
except:
have_preview = False
file_chooser.set_preview_widget_active(have_preview)
return
def extract_image(self, filename):
zf = zipfile.ZipFile(filename, 'r')
image_files = zf.namelist()
image_files.sort()
file_to_extract = image_files[0]
extract_new_filename = self.make_new_filename(file_to_extract)
if extract_new_filename is None or extract_new_filename == '':
# skip over directory name if the images are in a subdirectory.
file_to_extract = image_files[1]
extract_new_filename = self.make_new_filename(file_to_extract)
if len(image_files) > 0:
if self.save_extracted_file(zf, file_to_extract):
fname = os.path.join(self.get_activity_root(), 'instance',
extract_new_filename)
return fname
def create_new_toolbar(self):
toolbar_box = ToolbarBox()
activity_button = MyActivityToolbarButton(self)
toolbar_box.toolbar.insert(activity_button, 0)
activity_button.show()
self.connect('go-fullscreen', \
self.__view_toolbar_go_fullscreen_cb)
self.back = ToolButton('go-previous')
self.back.set_tooltip(_('Back'))
self.back.props.sensitive = False
palette = self.back.get_palette()
self.menu_prev_page = MenuItem(text_label=_("Previous page"))
palette.menu.append(self.menu_prev_page)
self.menu_prev_page.show_all()
self.back.connect('clicked', self.go_back_cb)
self.menu_prev_page.connect('activate', self.go_back_cb)
toolbar_box.toolbar.insert(self.back, -1)
self.back.show()
self.forward = ToolButton('go-next')
self.forward.set_tooltip(_('Forward'))
self.forward.props.sensitive = False
palette = self.forward.get_palette()
self.menu_next_page = MenuItem(text_label=_("Next page"))
palette.menu.append(self.menu_next_page)
self.menu_next_page.show_all()
self.forward.connect('clicked', self.go_forward_cb)
self.menu_next_page.connect('activate', self.go_forward_cb)
toolbar_box.toolbar.insert(self.forward, -1)
self.forward.show()
num_page_item = gtk.ToolItem()
self.num_page_entry = gtk.Entry()
self.num_page_entry.set_text('0')
self.num_page_entry.set_alignment(1)
self.num_page_entry.connect('insert-text',
self.__new_num_page_entry_insert_text_cb)
self.num_page_entry.connect('activate',
self.__new_num_page_entry_activate_cb)
self.num_page_entry.set_width_chars(4)
num_page_item.add(self.num_page_entry)
self.num_page_entry.show()
toolbar_box.toolbar.insert(num_page_item, -1)
num_page_item.show()
total_page_item = gtk.ToolItem()
self.total_page_label = gtk.Label()
label_attributes = pango.AttrList()
label_attributes.insert(pango.AttrSize(14000, 0, -1))
label_attributes.insert(
pango.AttrForeground(65535, 65535, 65535, 0, -1))
self.total_page_label.set_attributes(label_attributes)
self.total_page_label.set_text(' / 0')
total_page_item.add(self.total_page_label)
self.total_page_label.show()
toolbar_box.toolbar.insert(total_page_item, -1)
total_page_item.show()
spacer = gtk.SeparatorToolItem()
toolbar_box.toolbar.insert(spacer, -1)
spacer.show()
self._zoom_out = ToolButton('zoom-out')
self._zoom_out.set_tooltip(_('Zoom out'))
self._zoom_out.connect('clicked', self._zoom_out_cb)
toolbar_box.toolbar.insert(self._zoom_out, -1)
self._zoom_out.props.sensitive = False
self._zoom_out.show()
self._zoom_in = ToolButton('zoom-in')
self._zoom_in.set_tooltip(_('Zoom in'))
self._zoom_in.connect('clicked', self._zoom_in_cb)
toolbar_box.toolbar.insert(self._zoom_in, -1)
self._zoom_in.props.sensitive = True
self._zoom_in.show()
self._fullscreen = ToolButton('view-fullscreen')
self._fullscreen.set_tooltip(_('Fullscreen'))
self._fullscreen.connect('clicked', self._fullscreen_cb)
toolbar_box.toolbar.insert(self._fullscreen, -1)
self._fullscreen.show()
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 _zoom_in_cb(self, button):
self._zoom_in.props.sensitive = False
self._zoom_out.props.sensitive = True
self.zoom_to_width()
def _zoom_out_cb(self, button):
self._zoom_in.props.sensitive = True
self._zoom_out.props.sensitive = False
self.zoom_to_fit()
def enable_zoom_in(self):
self._zoom_in.props.sensitive = True
self._zoom_out.props.sensitive = False
def enable_zoom_out(self):
self._zoom_in.props.sensitive = False
self._zoom_out.props.sensitive = True
def _fullscreen_cb(self, button):
self.emit('go-fullscreen')
def __new_num_page_entry_insert_text_cb(self, entry, text, length,
position):
if not re.match('[0-9]', text):
entry.emit_stop_by_name('insert-text')
return True
return False
def __new_num_page_entry_activate_cb(self, entry):
if entry.props.text:
page = int(entry.props.text) - 1
else:
page = 0
if page >= self.total_pages:
page = self.total_pages - 1
elif page < 0:
page = 0
self.set_current_page(page)
self.show_page(page)
entry.props.text = str(page + 1)
self.update_nav_buttons()
def go_back_cb(self, button):
self.previous_page()
def go_forward_cb(self, button):
self.next_page()
def update_nav_buttons(self):
current_page = self.page
self.back.props.sensitive = current_page > 0
self.forward.props.sensitive = \
current_page < self.total_pages - 1
self.num_page_entry.props.text = str(current_page + 1)
self.total_page_label.props.label = \
' / ' + str(self.total_pages)
def set_total_pages(self, pages):
self.total_pages = pages
def setToggleButtonState(self, button, b, id):
button.handler_block(id)
button.set_active(b)
button.handler_unblock(id)
def buttonpress_cb(self, widget, event):
widget.grab_focus()
def __view_toolbar_go_fullscreen_cb(self, view_toolbar):
self.fullscreen()
def zoom_to_width(self):
self.zoom_image_to_fit = False
self.show_page(self.page)
def zoom_to_fit(self):
self.zoom_image_to_fit = True
self.show_page(self.page)
def keypress_cb(self, widget, event):
"Respond when the user presses Escape or one of the arrow keys"
keyname = gtk.gdk.keyval_name(event.keyval)
if keyname == 'Page_Up':
self.previous_page()
return True
if keyname == 'Page_Down':
self.next_page()
return True
if keyname == 'KP_Right':
self.scroll_down()
return True
if keyname == 'Down' or keyname == 'KP_Down':
self.scroll_down()
return True
if keyname == 'Up' or keyname == 'KP_Up':
self.scroll_up()
return True
if keyname == 'KP_Left':
self.scroll_up()
return True
if keyname == 'KP_Home':
if self.cursor_visible:
self.window.set_cursor(self.hidden_cursor)
self.cursor_visible = False
else:
self.window.set_cursor(None)
self.cursor_visible = True
return True
if keyname == 'plus':
self.view_toolbar.enable_zoom_out()
self.zoom_to_width()
return True
if keyname == 'minus':
self.view_toolbar.enable_zoom_in()
self.zoom_to_fit()
return True
return False
def scroll_down(self):
v_adjustment = self.scrolled.get_vadjustment()
if v_adjustment.value == v_adjustment.upper - v_adjustment.page_size:
self.next_page()
return
if v_adjustment.value < v_adjustment.upper - v_adjustment.page_size:
new_value = v_adjustment.value + v_adjustment.step_increment
if new_value > v_adjustment.upper - v_adjustment.page_size:
new_value = v_adjustment.upper - v_adjustment.page_size
v_adjustment.value = new_value
def scroll_up(self):
v_adjustment = self.scrolled.get_vadjustment()
if v_adjustment.value == v_adjustment.lower:
self.previous_page()
return
if v_adjustment.value > v_adjustment.lower:
new_value = v_adjustment.value - v_adjustment.step_increment
if new_value < v_adjustment.lower:
new_value = v_adjustment.lower
v_adjustment.value = new_value
def previous_page(self):
page = self.page
page = page - 1
if page < 0: page = 0
if self.save_extracted_file(self.zf, self.image_files[page]) == True:
fname = os.path.join(
self.get_activity_root(), 'instance',
self.make_new_filename(self.image_files[page]))
self.show_image(fname)
os.remove(fname)
v_adjustment = self.scrolled.get_vadjustment()
v_adjustment.value = v_adjustment.upper - v_adjustment.page_size
if _NEW_TOOLBAR_SUPPORT:
self.set_current_page(page)
else:
self.read_toolbar.set_current_page(page)
self.page = page
def set_current_page(self, page):
self.page = page
if _NEW_TOOLBAR_SUPPORT:
self.update_nav_buttons()
def next_page(self):
page = self.page
page = page + 1
if page >= len(self.image_files): page = len(self.image_files) - 1
if self.save_extracted_file(self.zf, self.image_files[page]) == True:
fname = os.path.join(
self.get_activity_root(), 'instance',
self.make_new_filename(self.image_files[page]))
self.show_image(fname)
os.remove(fname)
v_adjustment = self.scrolled.get_vadjustment()
v_adjustment.value = v_adjustment.lower
if _NEW_TOOLBAR_SUPPORT:
self.set_current_page(page)
else:
self.read_toolbar.set_current_page(page)
self.page = page
def area_expose_cb(self, area, event):
screen_width = gtk.gdk.screen_width()
screen_height = gtk.gdk.screen_height()
if self.saved_screen_width != screen_width and self.saved_screen_width != 0:
self.show_page(self.page)
self.saved_screen_width = screen_width
return False
def show_page(self, page):
if self.save_extracted_file(self.zf, self.image_files[page]) == True:
fname = os.path.join(
self.get_activity_root(), 'instance',
self.make_new_filename(self.image_files[page]))
self.show_image(fname)
os.remove(fname)
def show_image(self, filename):
"display a resized image in a full screen window"
TOOLBOX_HEIGHT = 60
BORDER_WIDTH = 30
# get the size of the fullscreen display
screen_width = gtk.gdk.screen_width()
screen_width = screen_width - BORDER_WIDTH
screen_height = gtk.gdk.screen_height()
screen_height = screen_height - TOOLBOX_HEIGHT
# get the size of the image.
im = pygame.image.load(filename)
image_width, image_height = im.get_size()
getcontext().prec = 7
s_a_ratio = Decimal(screen_height) / Decimal(screen_width)
i_a_ratio = Decimal(image_height) / Decimal(image_width)
new_width = image_width
new_height = image_height
if self.zoom_image_to_fit == True:
if s_a_ratio >= i_a_ratio:
new_width = screen_width
new_height = image_height * screen_width
if image_width > 1:
new_height /= image_width
if new_height > screen_width:
new_height *= screen_width
if new_width > 1:
new_height /= new_width
new_width = screen_width
else:
new_height = screen_height
new_width = image_width * screen_height
if image_height > 1:
new_width /= image_height
if new_width > screen_height:
new_width *= screen_height
if new_height > 1:
new_width /= new_height
new_height = screen_height
else:
new_width = screen_width
new_height = image_height * screen_width
if image_width > 1:
new_height /= image_width
if new_height > screen_width:
new_height *= screen_width
if new_width > 1:
new_height /= new_width
new_width = screen_width
pixbuf = gtk.gdk.pixbuf_new_from_file(filename)
scaled_buf = pixbuf.scale_simple(new_width, new_height,
gtk.gdk.INTERP_BILINEAR)
self.image.set_from_pixbuf(scaled_buf)
self.image.show()
def save_extracted_file(self, zipfile, filename):
"Extract the file to a temp directory for viewing"
try:
filebytes = zipfile.read(filename)
except BadZipfile, err:
print 'Error opening the zip file: %s' % (err)
return False
except KeyError, err:
self._alert('Key Error', 'Zipfile key not found: ' + str(filename))
return
class LegoToolbar(gtk.Toolbar):
''' The toolbar for specifiying the sensor: temp, distance,
light or gray '''
def __init__(self, activity, channels):
#Its used to avoid it from running twice
self._lego_context_id = None
gtk.Toolbar.__init__(self)
self.activity = activity
self._channels = channels
self.mode = 'lego'
# Set up Sensores Button
self.time = RadioToolButton(group=None)
# Keeps the button list (sensors)
# added to the LegoToolbar
self.lista_sensores_button = []
self.we_are_logging = False
self._log_this_sample = False
self._logging_timer = None
self._logging_counter = 0
self._image_counter = 0
self._logging_interval = 0
self._port_status = 1
self._channels_logged = []
self._busy = False
self._take_screenshot = True
self.refrescar_button = RadioToolButton(group=None)
self.refrescar_button.set_named_icon('recargar')
self.insert(self.refrescar_button, -1)
separator = gtk.SeparatorToolItem()
separator.props.draw = True
self.insert(separator, -1)
self.load_buttons()
separator = gtk.SeparatorToolItem()
separator.props.draw = True
self.insert(separator, -1)
self._port = PORT_VALUES[0]
self.port_label = gtk.Label(self._port_to_string(self._port))
toolitem = gtk.ToolItem()
toolitem.add(self.port_label)
self.insert(toolitem, -1)
self._port_button = ToolButton('LEGO-tools')
self._port_button.set_tooltip(_('Select Port'))
self._port_button.connect('clicked', self._port_selection_cb)
self.insert(self._port_button, -1)
self._setup_port_palette()
separator = gtk.SeparatorToolItem()
separator.props.draw = True
self.insert(separator, -1)
self._log_value = LOG_TIMER_VALUES[1]
self.log_label = gtk.Label(self._log_to_string(self._log_value))
toolitem = gtk.ToolItem()
toolitem.add(self.log_label)
self.insert(toolitem, -1)
self._log_button = ToolButton('timer-10')
self._log_button.set_tooltip(_('Select logging interval'))
self._log_button.connect('clicked', self._log_selection_cb)
self.insert(self._log_button, -1)
self._setup_log_palette()
# Set up Logging/Stop Logging Button
self._record = ToolButton('media-record')
self.insert(self._record, -1)
self._record.set_tooltip(_('Start Recording'))
self._record.connect('clicked', self.record_control_cb)
self.show_all()
def get_log(self):
return self._log_value
def get_log_idx(self):
if self._log_value in LOG_TIMER_VALUES:
return LOG_TIMER_VALUES.index(self._log_value)
else:
return LOG_TIMER_VALUES[0]
def set_log_idx(self, idx):
self._log_value = LOG_TIMER_VALUES[idx]
self.log_label.set_text(self._log_to_string(self._log_value))
if hasattr(self, '_log_button'):
self._log_button.set_icon('timer-%d' % (self._log_value))
def _log_selection_cb(self, widget):
if self._log_palette:
if not self._log_palette.is_up():
self._log_palette.popup(immediate=True,
state=self._log_palette.SECONDARY)
else:
self._log_palette.popdown(immediate=True)
return
def _log_to_seconds(self, tenth_seconds):
return tenth_seconds / 10.
def _log_to_string(self, tenth_seconds):
if tenth_seconds in LOG_TIMER_LABELS:
return LOG_TIMER_LABELS[tenth_seconds]
else:
return _('1 second')
def _setup_log_palette(self):
self._log_palette = self._log_button.get_palette()
for tenth_seconds in LOG_TIMER_VALUES:
text = self._log_to_string(tenth_seconds)
menu_item = MenuItem(icon_name='timer-%d' % (tenth_seconds),
text_label=self._log_to_string(tenth_seconds))
menu_item.connect('activate', self._log_selected_cb, tenth_seconds)
self._log_palette.menu.append(menu_item)
menu_item.show()
def _log_selected_cb(self, button, seconds):
self.set_log_idx(LOG_TIMER_VALUES.index(seconds))
def get_port(self):
return self._port_value
def get_port_idx(self):
if self._port_value in PORT_VALUES:
return PORT_VALUES.index(self._port_value)
else:
return PORT_VALUES[0]
def set_port_idx(self, idx):
self._port_value = PORT_VALUES[idx]
self.port_label.set_text(self._port_to_string(self._port_value))
if hasattr(self, '_port_button'):
self._port_button.set_icon('LEGO-tools')
def _port_selection_cb(self, widget):
if self._port_palette:
if not self._port_palette.is_up():
self._port_palette.popup(immediate=True,
state=self._port_palette.SECONDARY)
else:
self._port_palette.popdown(immediate=True)
return
def _port_to_string(self, tenth_seconds):
if tenth_seconds in PORT_LABELS:
return PORT_LABELS[tenth_seconds]
else:
return _('1 second')
def _setup_port_palette(self):
self._port_palette = self._port_button.get_palette()
for tenth_seconds in PORT_VALUES:
text = self._port_to_string(tenth_seconds)
menu_item = MenuItem(icon_name='LEGO-tools',
text_label=self._port_to_string(tenth_seconds))
menu_item.connect('activate', self._port_selected_cb, tenth_seconds)
self._port_palette.menu.append(menu_item)
menu_item.show()
def _port_selected_cb(self, button, seconds):
self.set_port_idx(PORT_VALUES.index(seconds))
#LEGO set up the sensor buttons
def load_buttons(self):
self.sensores = [_('Light Sensor'), _('Distance Sensor'), _('Grey Sensor'), _('Button Sensor'), _('Sound Sensor')]
self.lista_sensores_button = []
for i in range(len(self.sensores)):
self.sensor = self.sensores[i]
radio_tool_button = RadioToolButton(group=self.time)
icono = self.sensor.strip('0123456789:')
radio_tool_button.set_named_icon(icono)
radio_tool_button.set_tooltip(_(self.sensor))
if self.sensor.count(_('Sound Sensor')):
radio_tool_button.connect('clicked',self.click_sound_button)
if self.sensor.count(_('Distance Sensor')):
radio_tool_button.connect('clicked',self.click_dist_button)
elif self.sensor.count(_('Grey Sensor')):
radio_tool_button.connect('clicked',self.click_grises_button)
elif self.sensor.count(_('Button Sensor')):
radio_tool_button.connect('clicked',self.click_button)
log.debug(self.sensores)
elif self.sensor.count(_('Light sensor')):
radio_tool_button.connect('clicked',self.click_luz_button)
self.insert(radio_tool_button, 2)
self.lista_sensores_button.append(radio_tool_button)
def get_sensor_number(self):
log.debug('GETING SENSOR NUMBER')
log.debug(str(self._port_status))
return self._port_status
# LEGO reading sensor functions
def read_sound_from_bobot_server(self):
return nxt.getSound(self.get_port())
def read_dist_from_bobot_server(self):
return nxt.getDistance(self.get_port())
def read_boton_from_bobot_server(self):
return nxt.getButton(self.get_port())
def read_grises_from_bobot_server(self):
return nxt.getGray(self.get_port())
def read_luz_from_bobot_server(self):
return nxt.getLight(self.get_port())
def read_sensor_from_bobot_server(self):
return 0
def click_button(self,button=None):
self.set_lego_context()
return False
def click_sound_button(self, button=None):
self.mode = 'temperatura'
self.read_sensor_from_bobot_server = self.read_sound_from_bobot_server
self.set_lego_context()
return False
def click_dist_button(self, button=None):
self.mode = 'distancia'
self.read_sensor_from_bobot_server = self.read_dist_from_bobot_server
self.activity.limpiar_canales()
self.set_lego_context()
return False
def click_boton_button(self, button=None):
self.mode = 'boton'
self.read_sensor_from_bobot_server = self.read_boton_from_bobot_server
self.activity.limpiar_canales()
self.set_lego_context()
return False
def click_grises_button(self, button=None):
self.mode = 'grises'
self.read_sensor_from_bobot_server = self.read_grises_from_bobot_server
self.activity.limpiar_canales()
self.set_lego_context()
return False
def click_luz_button(self, button=None):
self.mode = 'luz'
self.read_sensor_from_bobot_server = self.read_luz_from_bobot_server
self.activity.limpiar_canales()
self.set_lego_context()
return False
def set_lego_context(self):
self.activity.audiograb.stop_grabbing()
if self._lego_context_id:
gobject.source_remove(self._lego_context_id)
self._lego_context_id =\
gobject.timeout_add(50,self.lego_context_on)
def lego_context_on(self):
bufChannelTmp = []
#If pause button is active, do not add the value
if self.activity.audiograb.get_freeze_the_display():
bufChannelTmp.append(self.read_sensor_from_bobot_server())
for i in range(self.activity.audiograb.channels):
self.activity.wave.new_buffer(bufChannelTmp,i)
if self.we_are_logging:
self.logging_to_file(bufChannelTmp,i)
if self.activity.CONTEXT == 'lego':
return True
else:
return False
def logging_to_file(self, data_buffer, channel):
if self.we_are_logging:
if self._logging_counter == MAX_LOG_ENTRIES:
self._logging_counter = 0
self.we_are_logging = False
self.activity.data_logger.stop_session()
else:
if self._logging_interval == 0:
self._emit_for_logging(data_buffer, channel=channel)
self._log_this_sample = False
self.we_are_logging = False
self.activity.data_logger.stop_session()
elif self._log_this_sample:
# Sample channels in order
if self.activity.audiograb._channels_logged.index(False) ==\
channel:
self.activity.audiograb._channels_logged[channel] =\
True
self._emit_for_logging(data_buffer, channel=channel)
# Have we logged every channel?
if self.activity.audiograb._channels_logged.count(True)\
== self.activity.audiograb.channels:
self._log_this_sample = False
for i in range(self.activity.audiograb.channels):
self.activity.audiograb._channels_logged[i] =\
False
self._logging_counter += 1
def _emit_for_logging(self, data_buffer, channel=0):
'''Sends the data for logging'''
if not self._busy:
self._busy = True
if self._take_screenshot:
if self.activity.data_logger.take_screenshot(
self._image_counter):
self._image_counter += 1
else:
log.debug('failed to take screenshot %d' % (
self._logging_counter))
self._busy = False
return
value_string = data_buffer[0]
def _sample_now(self):
''' Log the current sample now. This method is called from the
_logging_timer object when the interval expires. '''
self._log_this_sample = True
self._make_timer()
def _make_timer(self):
''' Create the next timer that will trigger data logging. '''
self._logging_timer = Timer(self._logging_interval, self._sample_now)
self._logging_timer.start()
def record_control_cb(self, button=None):
''' Depending upon the selected interval, does either a logging
session, or just logs the current buffer. '''
if self.we_are_logging:
self.activity.audiograb.set_logging_params(start_stop=False)
self._record.set_icon('media-record')
self._record.show()
self._record.set_tooltip(_('Start Recording'))
else:
Xscale = (1.00 / self.activity.audiograb.get_sampling_rate())
Yscale = 0.0
interval = self._log_value / 10. # self.interval_convert()
username = self.activity.nick
if self.activity.wave.get_fft_mode():
self.activity.data_logger.start_new_session(
username, Xscale, Yscale,
self._log_to_string(self._log_value),
channels=self._channels, mode='frequency')
else:
self.activity.data_logger.start_new_session(
username, Xscale, Yscale,
self._log_to_string(self._log_value),
channels=self._channels, mode=self.mode)
self.set_logging_params(
start_stop=True, interval=interval, screenshot=False)
self._record.set_icon('record-stop')
self._record.show()
self._record.set_tooltip(_('Stop Recording'))
self.activity.new_recording = True
def set_logging_params(self, start_stop=False, interval=0,
screenshot=True):
''' Configures for logging of data: starts or stops a session;
sets the logging interval; and flags if screenshot is taken. '''
self.we_are_logging = start_stop
self._logging_interval = interval
if not start_stop:
if self._logging_timer:
self._logging_timer.cancel()
self._logging_timer = None
self._log_this_sample = False
self._logging_counter = 0
elif interval != 0:
self._make_timer()
self._take_screenshot = screenshot
self._busy = False
def interval_convert(self):
''' Converts interval string to an integer that denotes the
number of times the audiograb buffer must be called before a
value is written. When set to 0, the whole of current buffer
will be written. '''
interval_dictionary = {'1/10 second': 0.1, '1 second': 1,
'30 seconds': 30,
'5 minutes': 300, '30 minutes': 1800}
try:
return interval_dictionary[self.logging_interval_status]
except ValueError:
logging.error('logging interval status = %s' %\
(str(self.logging_interval_status)))
return 0
def take_screenshot(self):
''' Capture the current screen to the Journal '''
log.debug('taking a screenshot %d' % (self._logging_counter))
self.set_logging_params(start_stop=True, interval=0, screenshot=True)
class SensorToolbar(gtk.Toolbar):
''' The toolbar for specifiying the sensor: sound, resitance, or
voltage '''
LOWER = 0.0
UPPER = 1.0
STR_DC_R = \
_("Resistive sensor (connect sensor to pink 'Mic In' on left side \
of XO)" ) + ' '
STR_DC_V = \
_("Voltage sensor (connect sensor to pink 'Mic In' on left side \
of XO)" ) + ' '
STR_AC = _('Sound') + ' '
STR_RESISTANCE = _('Resistance') + ' (' + _('Ohms') + ') '
STR_VOLTAGE = _('Voltage') + ' (' + _('Volts') + ') '
STR_TIME = _('Time Base') + ' '
STR_FREQUENCY = _('Frequency Base') + ' '
STR_INVERT = ' ' + _('Invert') + ' '
STR_XAXIS_TEXT = _('X Axis Scale: 1 division = %(division)s %(unit)s')
# TRANSLATORS: This is milli seconds.
MS = _('ms')
# TRANSLATORS: This is Hertz, so 1/second.
HZ = _('Hz')
def __init__(self, activity, channels):
''' By default, start with resistance mode '''
gtk.Toolbar.__init__(self)
self.activity = activity
self._channels = channels
self._lock_radio_buttons = False
self._radio_button_pushed = False
self.values = []
for i in range(self._channels):
self.values.append('')
self.string_for_textbox = ''
self.gain = 1.0
self.y_mag = 3.0
self.capture_gain = CAPTURE_GAIN
self.mic_boost = MIC_BOOST
self.mode = 'sound'
# Set up Time-domain Button
self.time = RadioToolButton(group=None)
self.time.set_named_icon('media-audio')
self.insert(self.time, -1)
self.time.set_tooltip(_('Sound'))
self.time.connect('clicked', self.analog_resistance_voltage_mode_cb,
'sound')
# Set up Resistance Button
self.resistance = RadioToolButton(group=self.time)
self.resistance.set_named_icon('resistance')
if _is_xo(self.activity.hw):
self.insert(self.resistance, -1)
self.resistance.show()
self.resistance.set_tooltip(_('Resistance Sensor'))
self.resistance.connect('clicked',
self.analog_resistance_voltage_mode_cb,
'resistance')
# Set up Voltage Button
self.voltage = RadioToolButton(group=self.time)
self.voltage.set_named_icon('voltage')
if _is_xo(self.activity.hw):
self.insert(self.voltage, -1)
self.voltage.set_tooltip(_('Voltage Sensor'))
self.voltage.connect('clicked', self.analog_resistance_voltage_mode_cb,
'voltage')
separator = gtk.SeparatorToolItem()
separator.props.draw = True
self.insert(separator, -1)
self._log_value = LOG_TIMER_VALUES[1]
self.log_label = gtk.Label(self._log_to_string(self._log_value))
toolitem = gtk.ToolItem()
toolitem.add(self.log_label)
self.insert(toolitem, -1)
self._log_button = ToolButton('timer-10')
self._log_button.set_tooltip(_('Select logging interval'))
self._log_button.connect('clicked', self._log_selection_cb)
self.insert(self._log_button, -1)
self._setup_log_palette()
# Set up Logging/Stop Logging Button
self._record = ToolButton('media-record')
self.insert(self._record, -1)
self._record.set_tooltip(_('Start logging'))
self._record.connect('clicked', self.record_control_cb)
separator = gtk.SeparatorToolItem()
separator.props.draw = True
self.insert(separator, -1)
toolitem = gtk.ToolItem()
self.trigger_label = gtk.Label(_('Trigger'))
toolitem.add(self.trigger_label)
self.insert(toolitem, -1)
# Set up Trigger Combo box
self.trigger_none = RadioToolButton()
self.trigger_none.set_named_icon('trigger-none')
self.insert(self.trigger_none, -1)
self.trigger_none.set_tooltip(_('None'))
self.trigger_none.connect('clicked', self.update_trigger_control_cb,
self.activity.wave.TRIGGER_NONE)
self.trigger_rise = RadioToolButton(group=self.trigger_none)
self.trigger_rise.set_named_icon('trigger-rise')
self.insert(self.trigger_rise, -1)
self.trigger_rise.set_tooltip(_('Rising Edge'))
self.trigger_rise.connect('clicked', self.update_trigger_control_cb,
self.activity.wave.TRIGGER_POS)
self.trigger_fall = RadioToolButton(group=self.trigger_none)
self.trigger_fall.set_named_icon('trigger-fall')
self.insert(self.trigger_fall, -1)
self.trigger_fall.set_tooltip(_('Falling Edge'))
self.trigger_fall.connect('clicked', self.update_trigger_control_cb,
self.activity.wave.TRIGGER_NEG)
self.show_all()
def get_log(self):
return self._log_value
def get_log_idx(self):
if self._log_value in LOG_TIMER_VALUES:
return LOG_TIMER_VALUES.index(self._log_value)
else:
return LOG_TIMER_VALUES[0]
def set_log_idx(self, idx):
self._log_value = LOG_TIMER_VALUES[idx]
self.log_label.set_text(self._log_to_string(self._log_value))
if hasattr(self, '_log_button'):
self._log_button.set_icon('timer-%d' % (self._log_value))
def _log_selection_cb(self, widget):
if self._log_palette:
if not self._log_palette.is_up():
self._log_palette.popup(immediate=True,
state=self._log_palette.SECONDARY)
else:
self._log_palette.popdown(immediate=True)
return
def _log_to_seconds(self, tenth_seconds):
return tenth_seconds / 10.
def _log_to_string(self, tenth_seconds):
if tenth_seconds in LOG_TIMER_LABELS:
return LOG_TIMER_LABELS[tenth_seconds]
else:
return _('1 second')
def _setup_log_palette(self):
self._log_palette = self._log_button.get_palette()
for tenth_seconds in LOG_TIMER_VALUES:
text = self._log_to_string(tenth_seconds)
menu_item = MenuItem(icon_name='timer-%d' % (tenth_seconds),
text_label=self._log_to_string(tenth_seconds))
menu_item.connect('activate', self._log_selected_cb, tenth_seconds)
self._log_palette.menu.append(menu_item)
menu_item.show()
def _log_selected_cb(self, button, seconds):
self.set_log_idx(LOG_TIMER_VALUES.index(seconds))
def add_frequency_slider(self, toolbox):
''' Either on the Sound toolbar or the Main toolbar '''
self._freq_stepper_up = ToolButton('freq-high')
self._freq_stepper_up.set_tooltip(_('Zoom out'))
self._freq_stepper_up.connect('clicked', self._freq_stepper_up_cb)
self._freq_stepper_up.show()
self.activity.adjustmentf = gtk.Adjustment(0.5, self.LOWER, self.UPPER,
0.01, 0.1, 0)
self.activity.adjustmentf.connect('value_changed', self.cb_page_sizef)
self._freq_range = gtk.HScale(self.activity.adjustmentf)
self._freq_range.set_inverted(True)
self._freq_range.set_draw_value(False)
self._freq_range.set_update_policy(gtk.UPDATE_CONTINUOUS)
self._freq_range.set_size_request(120, 15)
self._freq_range.show()
self._freq_stepper_down = ToolButton('freq-low')
self._freq_stepper_down.set_tooltip(_('Zoom in'))
self._freq_stepper_down.connect('clicked', self._freq_stepper_down_cb)
self._freq_stepper_down.show()
self._freq_range_tool = gtk.ToolItem()
self._freq_range_tool.add(self._freq_range)
self._freq_range_tool.show()
toolbox.add(self._freq_stepper_up)
toolbox.add(self._freq_range_tool)
toolbox.add(self._freq_stepper_down)
return
def update_trigger_control_cb(self, button, value):
if button is None:
value = self.activity.wave.TRIGGER_NONE
if self.activity.wave.get_fft_mode():
self.trigger_none.set_active(True)
else:
self.activity.wave.set_trigger(value)
def analog_resistance_voltage_mode_cb(self,
button=None,
mode_to_set='sound'):
''' Callback for Analog/Resistance/Voltage Buttons '''
if self._lock_radio_buttons:
logging.debug('mode selector locked')
self._radio_button_pushed = True
return
if self.mode == mode_to_set:
logging.debug('mode already set to %s' % mode_to_set)
return
self._lock_radio_buttons = True
if self.activity.CONTEXT == 'sound':
self.sound_context_off()
else:
self.sensor_context_off()
# Force time domain when switching modes
if self.activity.wave.get_fft_mode():
self.activity.timefreq_control()
# Turn off logging when switching modes
if self.activity.audiograb.we_are_logging:
self.record_control_cb()
self.set_mode(mode_to_set)
if mode_to_set == 'sound':
self.set_sound_context()
elif mode_to_set == 'resistance':
self.set_sensor_context()
elif mode_to_set == 'voltage':
self.set_sensor_context()
self.update_string_for_textbox()
return False
def unlock_radio_buttons(self):
''' Enable radio button selection '''
logging.debug('unlocking radio buttons')
if self._radio_button_pushed:
if self.mode == 'sound':
self.time.set_active(True)
elif self.mode == 'resistance':
self.resistance.set_active(True)
elif self.mode == 'voltage':
self.voltage.set_active(True)
self._lock_radio_buttons = False
self._radio_button_pushed = False
def set_mode(self, mode='sound'):
''' Set the mixer settings to match the current mode. '''
self.mode = mode
self.activity.audiograb.set_sensor_type(self.mode)
for i in range(self._channels):
self.values[i] = 0.0
return
def get_mode(self):
''' Get the mixer settings. '''
return self.mode
def _freq_stepper_up_cb(self, button=None):
''' Moves the horizontal zoom slider to the left one notch,
where one notch is 1/100 of the total range. This correspond
to zooming out as a larger number of Hertz or milliseconds
will be represented by the same space on the screen. '''
new_value = self._freq_range.get_value() +\
(self.UPPER - self.LOWER) / 100.0
if new_value <= self.UPPER:
self._freq_range.set_value(new_value)
else:
self._freq_range.set_value(self.UPPER)
def _freq_stepper_down_cb(self, button=None):
''' Moves the horizontal zoom slider to the right one notch,
where one notch is 1/100 of the total range. This corresponds
to zooming in. '''
new_value = self._freq_range.get_value() -\
(self.UPPER - self.LOWER) / 100.0
if new_value >= self.LOWER:
self._freq_range.set_value(new_value)
else:
self._freq_range.set_value(self.LOWER)
def cb_page_sizef(self, button=None):
''' Callback to scale the frequency range (zoom in and out) '''
if self._update_page_size_id:
gobject.source_remove(self._update_page_size_id)
self._update_page_size_id =\
gobject.timeout_add(250, self.update_page_size)
return True
def update_page_size(self):
''' Set up the scaling of the display. '''
self._update_page_size_id = None
new_value = round(self.activity.adjustmentf.value * 100.0) / 100.0
if self.activity.adjustmentf.value != new_value:
self.activity.adjustmentf.value = new_value
return False
time_div = 0.001 * max(self.activity.adjustmentf.value, 0.05)
freq_div = 1000 * max(self.activity.adjustmentf.value, 0.01)
self.activity.wave.set_div(time_div, freq_div)
self.update_string_for_textbox()
return False
def set_sound_context(self):
''' Called when analog sensing is selected '''
self.set_show_hide_windows(mode='sound')
gobject.timeout_add(500, self.sound_context_on)
self.activity.CONTEXT = 'sound'
def set_sensor_context(self):
''' Called when digital sensing is selected '''
self.set_show_hide_windows(mode='sensor')
gobject.timeout_add(500, self.sensor_context_on)
self.activity.CONTEXT = 'sensor'
def set_show_hide_windows(self, mode='sound'):
''' Shows the appropriate window identified by the mode '''
self.activity.wave.set_context_on()
for i in range(self._channels):
self.activity.side_toolbars[i].set_show_hide(True, mode)
def sensor_context_off(self):
''' Called when a DC sensor is no longer selected '''
# self.activity.audiograb.pause_grabbing()
self.activity.audiograb.stop_grabbing()
def sensor_context_on(self):
''' Called when a DC sensor is selected '''
self.update_string_for_textbox()
self.activity.wave.set_trigger(self.activity.wave.TRIGGER_NONE)
# self.activity.audiograb.resume_grabbing()
self.activity.audiograb.start_grabbing()
return False
def sound_context_off(self):
''' Called when an analog sensor is no longer selected '''
self.gain, self.y_mag = self.activity.wave.get_mag_params()
self.capture_gain = self.activity.audiograb.get_capture_gain()
self.mic_boost = self.activity.audiograb.get_mic_boost()
self.activity.audiograb.stop_grabbing()
def sound_context_on(self):
''' Called when an analog sensor is selected '''
self.activity.wave.set_mag_params(self.gain, self.y_mag)
self.update_string_for_textbox()
self.update_trigger_control_cb(None, self.activity.wave.TRIGGER_NONE)
self.activity.audiograb.start_grabbing()
return False
def set_sample_value(self, value='', channel=0):
''' Write a sample value to the textbox. '''
gtk.threads_enter()
self.values[channel] = value
self.update_string_for_textbox()
gtk.threads_leave()
return
def record_control_cb(self, button=None):
''' Depending upon the selected interval, does either a logging
session, or just logs the current buffer. '''
if self.activity.audiograb.we_are_logging:
self.activity.audiograb.set_logging_params(start_stop=False)
self._record.set_icon('media-record')
self._record.show()
self._record.set_tooltip(_('Start Recording'))
else:
Xscale = (1.00 / self.activity.audiograb.get_sampling_rate())
Yscale = 0.0
interval = self._log_value / 10. # self.interval_convert()
username = self.activity.nick
if self.activity.wave.get_fft_mode():
self.activity.data_logger.start_new_session(
username,
Xscale,
Yscale,
self._log_to_string(self._log_value),
channels=self._channels,
mode='frequency')
else:
self.activity.data_logger.start_new_session(
username,
Xscale,
Yscale,
self._log_to_string(self._log_value),
channels=self._channels,
mode=self.mode)
self.activity.audiograb.set_logging_params(start_stop=True,
interval=interval,
screenshot=False)
self._record.set_icon('record-stop')
self._record.show()
self._record.set_tooltip(_('Stop Recording'))
self.activity.new_recording = True
def update_string_for_textbox(self):
''' Update the status field at the bottom of the canvas. '''
if self.mode == 'resistance':
string_for_textbox = (self.STR_DC_R + '\n')
string_for_textbox += self.STR_RESISTANCE
elif self.mode == 'voltage':
string_for_textbox = (self.STR_DC_V + '\n')
string_for_textbox += self.STR_VOLTAGE
else:
string_for_textbox = (self.STR_AC + '\t')
if self.activity.wave.get_fft_mode():
scalex = self.STR_XAXIS_TEXT % {
'unit': self.HZ,
'division': self.activity.wave.freq_div
}
string_for_textbox += self.STR_FREQUENCY
string_for_textbox += ('\n' + scalex)
elif self.mode == 'sound':
scalex = self.STR_XAXIS_TEXT % {
'unit': self.MS,
'division': self.activity.wave.time_div * 1000
}
string_for_textbox += self.STR_TIME
string_for_textbox += ('\n' + scalex)
else:
for i in range(self._channels):
string_for_textbox += '\t(%s)' % (self.values[i])
invert = False
for i in range(self._channels):
if self.activity.wave.get_invert_state(channel=i):
invert = True
if invert:
string_for_textbox += self.STR_INVERT
self.activity.text_box.set_label(string_for_textbox)
class RecordControl():
def __init__(self, toolbar):
self._timer_value = TIMER_VALUES[0]
self._timer_button = ToolButton('timer-0')
self._timer_button.set_tooltip(_('Select timer'))
self._timer_button.connect('clicked', self._timer_selection_cb)
toolbar.insert(self._timer_button, -1)
self._setup_timer_palette()
self._duration_value = DURATION_VALUES[0]
self._duration_button = ToolButton('duration-2')
self._duration_button.set_tooltip(_('Select duration'))
self._duration_button.connect('clicked', self._duration_selection_cb)
toolbar.insert(self._duration_button, -1)
self._setup_duration_palette()
self._quality_value = 0
self._quality_button = ToolButton('low-quality')
self._quality_button.set_tooltip(_('Select quality'))
self._quality_button.connect('clicked', self._quality_selection_cb)
toolbar.insert(self._quality_button, -1)
self._setup_quality_palette()
def _timer_selection_cb(self, widget):
if self._timer_palette:
if not self._timer_palette.is_up():
self._timer_palette.popup(immediate=True,
state=self._timer_palette.SECONDARY)
else:
self._timer_palette.popdown(immediate=True)
return
def _setup_timer_palette(self):
self._timer_palette = self._timer_button.get_palette()
for seconds in TIMER_VALUES:
if seconds == 0:
text = _('Immediate')
else:
text = ngettext('%s second', '%s seconds', seconds) % seconds
menu_item = MenuItem(icon_name='timer-%d' % (seconds),
text_label=text)
menu_item.connect('activate', self._timer_selected_cb, seconds)
self._timer_palette.menu.append(menu_item)
menu_item.show()
def _timer_selected_cb(self, button, seconds):
self.set_timer_idx(TIMER_VALUES.index(seconds))
def _duration_selection_cb(self, widget):
if self._duration_palette:
if not self._duration_palette.is_up():
self._duration_palette.popup(
immediate=True, state=self._duration_palette.SECONDARY)
else:
self._duration_palette.popdown(immediate=True)
return
def _setup_duration_palette(self):
self._duration_palette = self._duration_button.get_palette()
for minutes in DURATION_VALUES:
if minutes == 0:
text = gtk.Label(_('Immediate'))
else:
text = ngettext('%s minute', '%s minutes', minutes) % minutes
menu_item = MenuItem(icon_name='duration-%d' % (minutes),
text_label=text)
menu_item.connect('activate', self._duration_selected_cb, minutes)
self._duration_palette.menu.append(menu_item)
menu_item.show()
def _duration_selected_cb(self, button, minutes):
self.set_duration_idx(DURATION_VALUES.index(minutes))
def _quality_selection_cb(self, widget):
if self._quality_palette:
if not self._quality_palette.is_up():
self._quality_palette.popup(
immediate=True, state=self._quality_palette.SECONDARY)
else:
self._quality_palette.popdown(immediate=True)
return
def _setup_quality_palette(self):
self._quality_palette = self._quality_button.get_palette()
for quality in QUALITY_VALUES:
text = _('%s quality') % (quality)
menu_item = MenuItem(icon_name=quality + '-quality',
text_label=text)
menu_item.connect('activate', self._quality_selected_cb, quality)
self._quality_palette.menu.append(menu_item)
menu_item.show()
def _quality_selected_cb(self, button, quality):
self.set_quality(QUALITY_VALUES.index(quality))
def set_mode(self, mode):
if mode == constants.MODE_PHOTO:
self._quality_button.set_sensitive(False)
self._timer_button.set_sensitive(True)
self._duration_button.set_sensitive(False)
if mode == constants.MODE_VIDEO:
self._quality_button.set_sensitive(True)
self._timer_button.set_sensitive(True)
self._duration_button.set_sensitive(True)
if mode == constants.MODE_AUDIO:
self._quality_button.set_sensitive(False)
self._timer_button.set_sensitive(True)
self._duration_button.set_sensitive(True)
def get_timer(self):
return self._timer_value
def get_timer_idx(self):
if self._timer_value in TIMER_VALUES:
return TIMER_VALUES.index(self._timer_value)
else:
return TIMER_VALUES[0]
def set_timer_idx(self, idx):
self._timer_value = TIMER_VALUES[idx]
if hasattr(self, '_timer_button'):
self._timer_button.set_icon('timer-%d' % (self._timer_value))
def get_duration(self):
return self._duration_value
def get_duration_idx(self):
if self._duration_value in DURATION_VALUES:
return DURATION_VALUES.index(self._duration_value)
else:
return DURATION_VALUES[0]
def set_duration_idx(self, idx):
self._duration_value = DURATION_VALUES[idx]
if hasattr(self, '_duration_button'):
self._duration_button.set_icon('duration-%d' %
(self._duration_value))
def get_quality(self):
return self._quality_value
def set_quality(self, idx):
self._quality_value = idx
if hasattr(self, '_quality_button'):
self._quality_button.set_icon('%s-quality' % (QUALITY_VALUES[idx]))
class InstrumentToolbar(gtk.Toolbar):
''' The toolbar for adding new instruments '''
def __init__(self, activity):
gtk.Toolbar.__init__(self)
self.activity = activity
self.new_instruments = []
self._name_entry = gtk.Entry()
self._name_entry.set_text(_('my instrument'))
self._name_entry_changed_id = self._name_entry.connect(
'changed', self.update_name_entry)
if hasattr(self._name_entry, 'set_tooltip_text'):
self._name_entry.set_tooltip_text(
_('Enter instrument name.'))
self._name_entry.set_width_chars(24)
self._name_entry.show()
toolitem = gtk.ToolItem()
toolitem.add(self._name_entry)
self.insert(toolitem, -1)
toolitem.show()
self._note = 'A'
self._notes_button = ToolButton('notes')
self._notes_button.set_tooltip(_('Notes'))
self._notes_button.connect('clicked',
self._button_selection_cb)
self.insert(self._notes_button, -1)
self._setup_notes_palette()
self._notes_button.show()
self._octave = 4
self._octaves_button = ToolButton('octaves')
self._octaves_button.set_tooltip(_('Octaves'))
self._octaves_button.connect('clicked',
self._button_selection_cb)
self.insert(self._octaves_button, -1)
self._setup_octaves_palette()
self._octaves_button.show()
self._new_note = ToolButton('list-add')
self._new_note.show()
self.insert(self._new_note, -1)
self._new_note.set_tooltip(_('Add a new note.'))
self._new_note.connect('clicked', self.new_note_cb)
self._new_note.show()
def _button_selection_cb(self, widget):
palette = widget.get_palette()
if palette:
if not palette.is_up():
palette.popup(immediate=True, state=palette.SECONDARY)
else:
palette.popdown(immediate=True)
return
def _setup_notes_palette(self):
self._notes_palette = self._notes_button.get_palette()
for note in NOTES:
menu_item = MenuItem(icon_name='',
text_label=note)
menu_item.connect('activate', self._note_selected_cb, note)
self._notes_palette.menu.append(menu_item)
menu_item.show()
def _note_selected_cb(self, widget, note):
self._note = note
def _setup_octaves_palette(self):
self._octaves_palette = self._octaves_button.get_palette()
for octave in range(9):
menu_item = MenuItem(icon_name='',
text_label=str(octave))
menu_item.connect('activate', self._octave_selected_cb, octave)
self._octaves_palette.menu.append(menu_item)
menu_item.show()
def _octave_selected_cb(self, widget, octave):
self._octave = octave
def update_name_entry(self, *args):
''' Add name to INSTRUMENT_DICT and combo box '''
# Wait until a note has been added...
return
def new_note_cb(self, *args):
''' Add a new note to instrument tuning list '''
name = self._name_entry.get_text()
if name not in INSTRUMENT_DICT:
INSTRUMENT_DICT[name] = []
self.activity.tuning_toolbar.instrument.append(name)
i = len(self.activity.tuning_toolbar.instrument)
menu_item = MenuItem(icon_name='',
text_label=name)
menu_item.connect(
'activate',
self.activity.tuning_toolbar.instrument_selected_cb,
name)
self.activity.tuning_toolbar.instrument_palette.menu.append(
menu_item)
menu_item.show()
self.new_instruments.append(name)
freq = A0 * pow(TWELTHROOT2,
self._octave * 12 + NOTES.index(self._note))
if freq not in INSTRUMENT_DICT[name]:
INSTRUMENT_DICT[name].append(freq)
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
class TuningToolbar(gtk.Toolbar):
''' The toolbar for tuning instruments '''
def __init__(self, activity):
gtk.Toolbar.__init__(self)
self.activity = activity
self._show_tuning_line = False
self._updating_note = True
self._tuning_tool = None
self._instrument_button = ToolButton('instruments')
self._instrument_button.set_tooltip(_('Tune an instrument.'))
self._instrument_button.connect('clicked',
self._button_selection_cb)
self.insert(self._instrument_button, -1)
self._setup_instrument_palette()
separator = gtk.SeparatorToolItem()
separator.props.draw = True
self.insert(separator, -1)
self._note = 'A'
self._notes_button = ToolButton('notes')
self._notes_button.set_tooltip(_('Notes'))
self._notes_button.connect('clicked',
self._button_selection_cb)
self.insert(self._notes_button, -1)
self._setup_notes_palette()
self._octave = 4
self._octaves_button = ToolButton('octaves')
self._octaves_button.set_tooltip(_('Octaves'))
self._octaves_button.connect('clicked',
self._button_selection_cb)
self.insert(self._octaves_button, -1)
self._setup_octaves_palette()
# The entry is used to display a note or for direct user input
self._freq_entry = gtk.Entry()
self._freq_entry.set_text('440') # A
self._freq_entry_changed_id = self._freq_entry.connect(
'changed', self._update_freq_entry)
if hasattr(self._freq_entry, 'set_tooltip_text'):
self._freq_entry.set_tooltip_text(
_('Enter a frequency to display.'))
self._freq_entry.set_width_chars(8)
self._freq_entry.show()
toolitem = gtk.ToolItem()
toolitem.add(self._freq_entry)
self.insert(toolitem, -1)
toolitem.show()
self._new_tuning_line = ToolButton('tuning-tools')
self._new_tuning_line.show()
self.insert(self._new_tuning_line, -1)
self._new_tuning_line.set_tooltip(_('Show tuning line.'))
self._new_tuning_line.connect('clicked', self.tuning_line_cb)
separator = gtk.SeparatorToolItem()
separator.props.draw = True
self.insert(separator, -1)
self._harmonic = ToolButton('harmonics')
self._harmonic.show()
self.insert(self._harmonic, -1)
self._harmonic.set_tooltip(_('Show harmonics.'))
self._harmonic.connect('clicked', self.harmonic_cb)
separator = gtk.SeparatorToolItem()
separator.props.draw = True
self.insert(separator, -1)
self._play_tone = ToolButton('media-playback-start')
self._play_tone.show()
self.insert(self._play_tone, -1)
self._play_tone.set_tooltip(_('Play a note.'))
self._play_tone.connect('clicked', self.play_cb)
separator = gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
self.insert(separator, -1)
self.label = gtk.Label('')
self.label.set_use_markup(True)
self.label.show()
toolitem = gtk.ToolItem()
toolitem.add(self.label)
self.insert(toolitem, -1)
toolitem.show()
self.show_all()
def _update_note(self):
''' Calculate the frequency based on note and octave '''
if not hasattr(self, '_freq_entry'): # Still setting up toolbar
return
i = self._octave * 12 + NOTES.index(self._note)
freq = A0 * pow(TWELTHROOT2, i)
self._updating_note = True
self._freq_entry.set_text('%0.3f' % (freq))
self.label.set_markup(SPAN % (style.COLOR_WHITE.get_html(),
self._note + str(self._octave)))
if self._show_tuning_line:
self.activity.wave.tuning_line = freq
return
def _update_freq_entry(self, widget):
# Calculate a note from a frequency
if not self._updating_note: # Only if user types in a freq.
try:
freq = float(self._freq_entry.get_text())
# Only consider notes in piano range
if freq < A0 * 0.97:
self.label.set_text('< A0')
return
if freq > C8 * 1.03:
self.label.set_text('> C8')
return
self.label.set_markup(freq_note(freq, flatsharp=True))
except ValueError:
return
self._updating_note = False
def _button_selection_cb(self, widget):
palette = widget.get_palette()
if palette:
if not palette.is_up():
palette.popup(immediate=True, state=palette.SECONDARY)
else:
palette.popdown(immediate=True)
return
def _setup_notes_palette(self):
self._notes_palette = self._notes_button.get_palette()
for note in NOTES:
menu_item = MenuItem(icon_name='',
text_label=note)
menu_item.connect('activate', self._note_selected_cb, note)
self._notes_palette.menu.append(menu_item)
menu_item.show()
def _note_selected_cb(self, widget, note):
self._note = note
self._update_note()
def _setup_octaves_palette(self):
self._octaves_palette = self._octaves_button.get_palette()
for octave in range(9):
menu_item = MenuItem(icon_name='',
text_label=str(octave))
menu_item.connect('activate', self._octave_selected_cb, octave)
self._octaves_palette.menu.append(menu_item)
menu_item.show()
def _octave_selected_cb(self, widget, octave):
self._octave = octave
self._update_note()
def _setup_instrument_palette(self):
self.instrument_palette = self._instrument_button.get_palette()
self.instrument = []
for k in INSTRUMENT_DICT.keys():
self.instrument.append(k)
menu_item = MenuItem(icon_name='',
text_label=k)
menu_item.connect('activate', self.instrument_selected_cb, k)
self.instrument_palette.menu.append(menu_item)
menu_item.show()
def instrument_selected_cb(self, button, instrument):
''' Callback for instrument control '''
logging.debug(instrument)
if self._tuning_tool is not None:
self.remove(self._tuning_tool)
if instrument == _('None'):
self.activity.wave.instrument = None
# Remove any previous tuning button
if hasattr(self, '_tuning_button'):
self._tuning_button.destroy()
# Restore the notes, octaves buttons
if hasattr(self, '_notes_button'):
self.insert(self._notes_button, 2)
self.insert(self._octaves_button, 3)
return
self.remove(self._notes_button)
self.remove(self._octaves_button)
self.activity.wave.instrument = instrument
# If we are not already in freq. base, switch.
if not self.activity.wave.get_fft_mode():
self.activity.timefreq_control()
# Add a Tuning palette for this instrument
self._tuning_button = ToolButton('notes')
self._tuning_button.set_tooltip(instrument)
self._tuning_button.connect('clicked', self._button_selection_cb)
self.insert(self._tuning_button, 1)
self._setup_tuning_palette(instrument)
def _setup_tuning_palette(self, instrument):
self._tuning_palette = self._tuning_button.get_palette()
self.tuning = []
self.tuning.append(_('All notes'))
menu_item = MenuItem(icon_name='', text_label=_('All notes'))
menu_item.connect('activate', self._tuning_selected_cb,
instrument, -1)
self._tuning_palette.menu.append(menu_item)
menu_item.show()
for i, f in enumerate(INSTRUMENT_DICT[instrument]):
self.tuning.append(freq_note(f))
menu_item = MenuItem(icon_name='',
text_label=freq_note(f))
menu_item.connect('activate', self._tuning_selected_cb,
instrument, i)
self._tuning_palette.menu.append(menu_item)
menu_item.show()
self.show_all()
def _tuning_selected_cb(self, widget, instrument, fidx):
''' Update note '''
if not hasattr(self, '_freq_entry'): # Still setting up toolbar?
return
if not instrument in INSTRUMENT_DICT:
return
if fidx == -1: # All notes
self.activity.wave.instrument = instrument
self.activity.wave.tuning_line = 0.0
self._new_tuning_line.set_icon('tuning-tools')
self._new_tuning_line.set_tooltip(_('Show tuning line.'))
self._show_tuning_line = False
else:
freq = INSTRUMENT_DICT[instrument][fidx]
self.activity.wave.instrument = None
self.activity.wave.tuning_line = freq
self._new_tuning_line.set_icon('tuning-tools-off')
self._new_tuning_line.set_tooltip(_('Hide tuning line.'))
self._show_tuning_line = True
self._updating_note = False
def harmonic_cb(self, *args):
''' Callback for harmonics control '''
self.activity.wave.harmonics = not self.activity.wave.harmonics
if self.activity.wave.harmonics:
self._harmonic.set_icon('harmonics-off')
self._harmonic.set_tooltip(_('Hide harmonics.'))
if self.activity.wave.instrument is None and \
self.activity.wave.tuning_line == 0.0:
self._load_tuning_line()
else:
self._harmonic.set_icon('harmonics')
self._harmonic.set_tooltip(_('Show harmonics.'))
def tuning_line_cb(self, *args):
''' Callback for tuning insert '''
if self._show_tuning_line:
self.activity.wave.tuning_line = 0.0
self._new_tuning_line.set_icon('tuning-tools')
self._new_tuning_line.set_tooltip(_('Show tuning line.'))
self._show_tuning_line = False
else:
self._load_tuning_line()
def _load_tuning_line(self):
''' Read the freq entry and use value to set tuning line '''
freq = self._freq_entry.get_text()
try:
self.activity.wave.tuning_line = float(freq)
if freq < 0:
freq = -freq
self._new_tuning_line.set_icon('tuning-tools-off')
self._new_tuning_line.set_tooltip(_('Hide tuning line.'))
self._show_tuning_line = True
except ValueError:
self.activity.wave.tuning_line = 0.0
self._freq_entry.set_text('0')
# If we are not already in freq. base, switch.
if not self.activity.wave.get_fft_mode():
self.activity.timefreq_control()
def play_cb(self, *args):
''' Save settings, turn off display, and then play a tone at
the current frequency '''
channels = []
for c in range(self.activity.audiograb.channels):
channels.append(self.activity.wave.get_visibility(channel=c))
self.activity.wave.set_visibility(False, channel=c)
wave_status = self.activity.wave.get_active()
self.activity.wave.set_context_off()
self.activity.wave.set_active(False)
if self.activity.hw in [XO4, XO175]:
self.activity.audiograb.stop_grabbing()
freq = float(self._freq_entry.get_text())
gobject.timeout_add(200, self.play_sound, freq, channels, wave_status)
def play_sound(self, freq, channels, wave_status):
''' Play the sound and then restore wave settings '''
self._play_sinewave(freq, 5000, 1)
if self.activity.hw in [XO4, XO175]:
self.activity.sensor_toolbar.set_mode('sound')
self.activity.sensor_toolbar.set_sound_context()
self.activity.audiograb.start_grabbing()
for c in range(self.activity.audiograb.channels):
self.activity.wave.set_visibility(channels[c], channel=c)
self.activity.wave.set_context_on()
self.activity.wave.set_active(wave_status)
def _play_sinewave(self, pitch, amplitude=5000, duration=1):
""" Create a Csound score to play a sine wave. """
self.orchlines = []
self.scorelines = []
self.instrlist = []
try:
pitch = abs(float(pitch))
amplitude = abs(float(amplitude))
duration = abs(float(duration))
except ValueError:
logging.error('bad args to _play_sinewave')
return
self._prepare_sinewave(pitch, amplitude, duration)
path = os.path.join(self.activity.get_activity_root(), 'instance',
'tmp.csd')
# Create a csound file from the score.
self._audio_write(path)
# Play the csound file.
output = check_output(['csound', path], 'call to csound failed?')
# os.system('csound ' + path + ' > /dev/null 2>&1')
def _prepare_sinewave(self, pitch, amplitude, duration, starttime=0,
pitch_envelope=99, amplitude_envelope=100,
instrument=1):
pitenv = pitch_envelope
ampenv = amplitude_envelope
if not 1 in self.instrlist:
self.orchlines.append("instr 1\n")
self.orchlines.append("kpitenv oscil 1, 1/p3, p6\n")
self.orchlines.append("aenv oscil 1, 1/p3, p7\n")
self.orchlines.append("asig oscil p5*aenv, p4*kpitenv, p8\n")
self.orchlines.append("out asig\n")
self.orchlines.append("endin\n\n")
self.instrlist.append(1)
self.scorelines.append("i1 %s %s %s %s %s %s %s\n" %
(str(starttime), str(duration), str(pitch),
str(amplitude), str(pitenv), str(ampenv),
str(instrument)))
def _audio_write(self, file):
""" Compile a .csd file. """
csd = open(file, "w")
csd.write("<CsoundSynthesizer>\n\n")
csd.write("<CsOptions>\n")
csd.write("-+rtaudio=alsa -odevaudio -m0 -d -b256 -B512\n")
csd.write("</CsOptions>\n\n")
csd.write("<CsInstruments>\n\n")
csd.write("sr=16000\n")
csd.write("ksmps=50\n")
csd.write("nchnls=1\n\n")
for line in self.orchlines:
csd.write(line)
csd.write("\n</CsInstruments>\n\n")
csd.write("<CsScore>\n\n")
csd.write("f1 0 2048 10 1\n")
csd.write("f2 0 2048 10 1 0 .33 0 .2 0 .143 0 .111\n")
csd.write("f3 0 2048 10 1 .5 .33 .25 .2 .175 .143 .125 .111 .1\n")
csd.write("f10 0 2048 10 1 0 0 .3 0 .2 0 0 .1\n")
csd.write("f99 0 2048 7 1 2048 1\n")
csd.write("f100 0 2048 7 0. 10 1. 1900 1. 132 0.\n")
csd.write(self.scorelines.pop())
csd.write("e\n")
csd.write("\n</CsScore>\n")
csd.write("\n</CsoundSynthesizer>")
csd.close()
class ButiaToolbar(gtk.Toolbar):
''' The toolbar for specifiying the sensor: temp, distance,
light or gray '''
def __init__(self, activity, channels):
#Se utiliza para contralar que no se ejecute dos veces
self._butia_context_id = None
gtk.Toolbar.__init__(self)
self.activity = activity
self._channels = channels
self.mode = 'butia'
# Set up Sensores Button
self.time = RadioToolButton(group=None)
# Mantiene la lista de botones (de sensores)
# agregados a la ButiaToolbar
self.lista_sensores_button = []
self.we_are_logging = False
self._log_this_sample = False
self._logging_timer = None
self._logging_counter = 0
self._image_counter = 0
self._logging_interval = 0
self._channels_logged = []
self._busy = False
self._take_screenshot = True
# BUTIA Se detectan sensores
log.debug('se agrega el boton refrescar')
self.refrescar_button = RadioToolButton(group=None)
self.refrescar_button.set_named_icon('recargar')
self.refrescar_button.connect('clicked', self.update_buttons)
self.insert(self.refrescar_button, -1)
separator = gtk.SeparatorToolItem()
separator.props.draw = True
self.insert(separator, -1)
self.robot = pybot_client.robot()
self.detect_sensors()
self.load_buttons()
separator = gtk.SeparatorToolItem()
separator.props.draw = True
self.insert(separator, -1)
self._log_value = LOG_TIMER_VALUES[1]
self.log_label = gtk.Label(self._log_to_string(self._log_value))
toolitem = gtk.ToolItem()
toolitem.add(self.log_label)
self.insert(toolitem, -1)
self._log_button = ToolButton('timer-10')
self._log_button.set_tooltip(_('Select logging interval'))
self._log_button.connect('clicked', self._log_selection_cb)
self.insert(self._log_button, -1)
self._setup_log_palette()
# Set up Logging/Stop Logging Button
self._record = ToolButton('media-record')
self.insert(self._record, -1)
self._record.set_tooltip(_('Start Recording'))
self._record.connect('clicked', self.record_control_cb)
log.debug('***showing all*****')
self.show_all()
gobject.timeout_add(1000, self.update_buttons)
def get_log(self):
return self._log_value
def get_log_idx(self):
if self._log_value in LOG_TIMER_VALUES:
return LOG_TIMER_VALUES.index(self._log_value)
else:
return LOG_TIMER_VALUES[0]
def set_log_idx(self, idx):
self._log_value = LOG_TIMER_VALUES[idx]
self.log_label.set_text(self._log_to_string(self._log_value))
if hasattr(self, '_log_button'):
self._log_button.set_icon('timer-%d' % (self._log_value))
def _log_selection_cb(self, widget):
if self._log_palette:
if not self._log_palette.is_up():
self._log_palette.popup(immediate=True,
state=self._log_palette.SECONDARY)
else:
self._log_palette.popdown(immediate=True)
return
def _log_to_seconds(self, tenth_seconds):
return tenth_seconds / 10.
def _log_to_string(self, tenth_seconds):
if tenth_seconds in LOG_TIMER_LABELS:
return LOG_TIMER_LABELS[tenth_seconds]
else:
return _('1 second')
def _setup_log_palette(self):
self._log_palette = self._log_button.get_palette()
for tenth_seconds in LOG_TIMER_VALUES:
text = self._log_to_string(tenth_seconds)
menu_item = MenuItem(icon_name='timer-%d' % (tenth_seconds),
text_label=self._log_to_string(tenth_seconds))
menu_item.connect('activate', self._log_selected_cb, tenth_seconds)
self._log_palette.menu.append(menu_item)
menu_item.show()
def _log_selected_cb(self, button, seconds):
self.set_log_idx(LOG_TIMER_VALUES.index(seconds))
# BUTIA Busca modulos conectados y pregunta si son sensores
def detect_sensors(self):
log.debug('listando modulos detectados:')
modules = self.robot.getModulesList()
self.sensores = []
log.debug(modules)
for i in range(len(modules)):
if self.is_sensor(modules[i]) :
log.debug(modules[i] +' es sensor!')
self.sensores.append(modules[i])
else:
log.debug(modules[i] +' no es sensor!')
self.sensores.sort()
log.debug('sensores: ')
log.debug(self.sensores)
# BUTIA determina si el modulo que le pasan es sensor! !
def is_sensor(self, module):
#log.debug('DESCRIBIENDO: '+ module)
descripcion = self.robot.describe(module)
if descripcion == -1:
return 0
#log.debug(descripcion)
is_sensor = descripcion.count('getValue')
return is_sensor
#BUTIA Cargo los botones para cada sensor detectado
def load_buttons(self):
self.lista_sensores_button = []
for i in range(len(self.sensores)):
self.sensor = self.sensores[i]
log.debug('agregando boton para : '+ self.sensor)
#radio_tool_button = 0
radio_tool_button = RadioToolButton(group=self.time)
icono = self.sensor.strip('0123456789:')
radio_tool_button.set_named_icon(icono)
radio_tool_button.set_tooltip(_(self.sensor))
#determino el numero de sensor y lo paso por parametro.
#log.debug('el sensor '+ self.sensor + 'es el numero '+ self.get_sensor_number(self.sensor))
if self.sensor.count('temp'):
radio_tool_button.connect('clicked',self.click_temp_button,self.get_sensor_number(self.sensor))
elif self.sensor.count('dist'):
radio_tool_button.connect('clicked',self.click_dist_button,self.get_sensor_number(self.sensor))
elif self.sensor.count('grey'):
radio_tool_button.connect('clicked',self.click_grises_button,self.get_sensor_number(self.sensor))
elif self.sensor.count('button'):
radio_tool_button.connect('clicked',self.click_boton_button,self.get_sensor_number(self.sensor))
elif self.sensor.count('volt'):
radio_tool_button.connect('clicked',self.click_volt_button,self.get_sensor_number(self.sensor))
elif self.sensor.count('light'):
radio_tool_button.connect('clicked',self.click_luz_button,self.get_sensor_number(self.sensor))
elif self.sensor.count('res'):
radio_tool_button.connect('clicked',self.click_res_button,self.get_sensor_number(self.sensor))
self.insert(radio_tool_button, 2)
self.lista_sensores_button.append(radio_tool_button)
def update_buttons(self, button=None):
logging.debug('Updating buttons')
for s in self.lista_sensores_button:
self.remove(s)
self.detect_sensors()
self.load_buttons()
self.show_all()
return True
def get_sensor_number(self, sensor):
sensor_trunked = sensor.strip('0123456789')
number = sensor.strip(sensor_trunked)
log.debug('sensor number :' + sensor.strip(sensor))
return number
# BUTIA metodos para leen sensores
def read_temp_from_bobot_server(self,num=0 ):
#log.debug('**********Sensando temperature' + str(num)+ '***********')
value = self.robot.callModule('temp', 0, str(num), 'getValue')
#log.debug('temperature : ' + value)
return value
def read_dist_from_bobot_server(self,num=0 ):
#log.debug('**********Sensando distance'+ str(num) + '******************')
#value = self.robot.getDistance(num)
value = self.robot.callModule('distanc', 0, str(num), 'getValue')
#log.debug('distance = ' + str(value))
return value
def read_boton_from_bobot_server(self,num=0):
#log.debug('**********Sensando grises'+ str(num) + '******************')
value = self.robot.callModule('button', 0, str(num), 'getValue')
#log.debug('grey = ' + str(value))
return value
def read_grises_from_bobot_server(self,num=0):
#log.debug('**********Sensando grises'+ str(num) + '******************')
value = self.robot.callModule('grey', 0, str(num), 'getValue')
#log.debug('grey = ' + str(value))
return value
def read_luz_from_bobot_server(self,num=0):
#log.debug('**********Sensando luz '+ str(num) + '******************')
value = self.robot.callModule('ligth', 0, str(num),'getValue')
#log.debug('grey = ' + str(value))
return value
def read_volt_from_bobot_server(self,num=0):
log.debug('**********Sensando volt '+ str(num) + '******************')
value = self.robot.callModule('volt', 0, str(num),'getValue', ret_type = float)
log.debug('volt = ' + str(value))
return value
def read_res_from_bobot_server(self,num=0):
log.debug('**********Sensando res '+ str(num) + '******************')
value = self.robot.callModule('res', 0, str(num),'getValue', ret_type = float)
log.debug('res = ' + str(value))
return value
def read_sensor_from_bobot_server(self,num):
log.debug('**********Read Sensor ***********')
return 0
def click_button(self,button=None):
log.debug('********** clicka botton ***********')
self.set_butia_context()
return False
def click_temp_button (self, button=None,num='0'):
log.debug('********** clickea botton temp ***********')
self.mode = 'temperatura'
self.read_sensor_from_bobot_server = self.read_temp_from_bobot_server
self.set_butia_context(num)
return False
def click_dist_button (self, button=None,num='0'):
log.debug('********** clickea botton dist ***********')
self.mode = 'distancia'
self.read_sensor_from_bobot_server = self.read_dist_from_bobot_server
self.activity.limpiar_canales()
self.set_butia_context(num)
return False
def click_boton_button (self, button=None,num='0'):
log.debug('********** clickea botton boton ***********')
self.mode = 'boton'
self.read_sensor_from_bobot_server = self.read_boton_from_bobot_server
self.activity.limpiar_canales()
self.set_butia_context(num)
return False
def click_grises_button (self, button=None,num='0'):
log.debug('********** clickea botton grises ***********')
self.mode = 'grises'
self.read_sensor_from_bobot_server = self.read_grises_from_bobot_server
self.activity.limpiar_canales()
self.set_butia_context(num)
return False
def click_luz_button (self, button=None,num='0'):
log.debug('********** clickea botton luz ***********')
self.mode = 'luz'
self.read_sensor_from_bobot_server = self.read_luz_from_bobot_server
self.activity.limpiar_canales()
self.set_butia_context(num)
return False
def click_volt_button (self, button=None,num='0'):
log.debug('********** clickea boton volt ***********')
self.mode = 'volt'
self.read_sensor_from_bobot_server = self.read_volt_from_bobot_server
self.activity.limpiar_canales()
self.set_butia_context(num)
return False
def click_res_button (self, button=None,num='0'):
log.debug('********** clickea boton res ***********')
self.mode = 'res'
self.read_sensor_from_bobot_server = self.read_res_from_bobot_server
self.activity.limpiar_canales()
self.set_butia_context(num)
return False
def set_butia_context(self,num='0'):
self.activity.audiograb.stop_grabbing()
if self._butia_context_id:
gobject.source_remove(self._butia_context_id)
self._butia_context_id =\
gobject.timeout_add(50,self.butia_context_on,num)
def butia_context_on(self,num='0'):
bufChannelTmp = []
#Si esta el boton de pause activada no se agregar el nuevo valor
if self.activity.audiograb.get_freeze_the_display():
bufChannelTmp.append(self.read_sensor_from_bobot_server(num))
for i in range(self.activity.audiograb.channels):
self.activity.wave.new_buffer(bufChannelTmp,i)
if self.we_are_logging:
self.logging_to_file(bufChannelTmp,i)
if self.activity.CONTEXT == 'butia':
return True
else:
return False
def logging_to_file(self, data_buffer, channel):
if self.we_are_logging:
if self._logging_counter == MAX_LOG_ENTRIES:
self._logging_counter = 0
self.we_are_logging = False
self.activity.data_logger.stop_session()
else:
if self._logging_interval == 0:
self._emit_for_logging(data_buffer, channel=channel)
self._log_this_sample = False
self.we_are_logging = False
self.activity.data_logger.stop_session()
elif self._log_this_sample:
# Sample channels in order
if self.activity.audiograb._channels_logged.index(False) == channel:
self.activity.audiograb._channels_logged[channel] = True
self._emit_for_logging(data_buffer, channel=channel)
# Have we logged every channel?
if self.activity.audiograb._channels_logged.count(True) == self.activity.audiograb.channels:
self._log_this_sample = False
for i in range(self.activity.audiograb.channels):
self.activity.audiograb._channels_logged[i] = False
self._logging_counter += 1
def _emit_for_logging(self, data_buffer, channel=0):
'''Sends the data for logging'''
if not self._busy:
self._busy = True
if self._take_screenshot:
if self.activity.data_logger.take_screenshot(
self._image_counter):
self._image_counter += 1
else:
log.debug('failed to take screenshot %d' % (
self._logging_counter))
self._busy = False
return
value_string = data_buffer[0]
if self.activity.audiograb.channels > 1:
self.activity.data_logger.write_value(
value_string, channel=channel,
sample=self._logging_counter)
else:
self.activity.data_logger.write_value(
value_string, sample=self._logging_counter)
self._busy = False
else:
log.debug('skipping sample %d.%d' % (
self._logging_counter, channel))
def _sample_now(self):
''' Log the current sample now. This method is called from the
_logging_timer object when the interval expires. '''
self._log_this_sample = True
self._make_timer()
def _make_timer(self):
''' Create the next timer that will trigger data logging. '''
self._logging_timer = Timer(self._logging_interval, self._sample_now)
self._logging_timer.start()
def record_control_cb(self, button=None):
''' Depending upon the selected interval, does either a logging
session, or just logs the current buffer. '''
if self.we_are_logging:
self.set_logging_params(start_stop=False)
self._record.set_icon('media-record')
self._record.show()
self._record.set_tooltip(_('Start Recording'))
else:
Xscale = 0.0
Yscale = 0.0
interval = self.interval_convert()
username = self.activity.nick
if self.activity.wave.get_fft_mode():
self.activity.data_logger.start_new_session(
username, Xscale, Yscale, _(self.logging_interval_status),
channels=self._channels, mode='frequency')
else:
self.activity.data_logger.start_new_session(
username, Xscale, Yscale, _(self.logging_interval_status),
channels=self._channels, mode=self.mode)
self.set_logging_params(
start_stop=True, interval=interval, screenshot=False)
self._record.set_icon('record-stop')
self._record.show()
self._record.set_tooltip(_('Stop Recording'))
self.activity.new_recording = True
def set_logging_params(self, start_stop=False, interval=0,
screenshot=True):
''' Configures for logging of data: starts or stops a session;
sets the logging interval; and flags if screenshot is taken. '''
self.we_are_logging = start_stop
self._logging_interval = interval
if not start_stop:
if self._logging_timer:
self._logging_timer.cancel()
self._logging_timer = None
self._log_this_sample = False
self._logging_counter = 0
elif interval != 0:
self._make_timer()
self._take_screenshot = screenshot
self._busy = False
def interval_convert(self):
''' Converts interval string to an integer that denotes the
number of times the audiograb buffer must be called before a
value is written. When set to 0, the whole of current buffer
will be written. '''
interval_dictionary = {'1/10 second': 0.1, '1 second': 1,
'30 seconds': 30,
'5 minutes': 300, '30 minutes': 1800}
try:
return interval_dictionary[self.logging_interval_status]
except ValueError:
logging.error('logging interval status = %s' %\
(str(self.logging_interval_status)))
return 0
def log_interval_cb(self, combobox):
''' Callback from the Logging Interval Combo box: sets status '''
if self._log_interval_combo.get_active() != -1:
intervals = ['1/10 second', '1 second', '30 seconds',
'5 minutes', '30 minutes']
self.logging_interval_status = \
intervals[self._log_interval_combo.get_active()]
def take_screenshot(self):
''' Capture the current screen to the Journal '''
log.debug('taking a screenshot %d' % (self._logging_counter))
self.set_logging_params(start_stop=True, interval=0, screenshot=True)
class RecordControl:
def __init__(self, toolbar):
self._timer_value = TIMER_VALUES[0]
self._timer_button = ToolButton("timer-0")
self._timer_button.set_tooltip(_("Select timer"))
self._timer_button.connect("clicked", self._timer_selection_cb)
toolbar.insert(self._timer_button, -1)
self._setup_timer_palette()
self._duration_value = DURATION_VALUES[0]
self._duration_button = ToolButton("duration-2")
self._duration_button.set_tooltip(_("Select duration"))
self._duration_button.connect("clicked", self._duration_selection_cb)
toolbar.insert(self._duration_button, -1)
self._setup_duration_palette()
self._quality_value = 0
self._quality_button = ToolButton("low-quality")
self._quality_button.set_tooltip(_("Select quality"))
self._quality_button.connect("clicked", self._quality_selection_cb)
toolbar.insert(self._quality_button, -1)
self._setup_quality_palette()
def _timer_selection_cb(self, widget):
if self._timer_palette:
if not self._timer_palette.is_up():
self._timer_palette.popup(immediate=True, state=self._timer_palette.SECONDARY)
else:
self._timer_palette.popdown(immediate=True)
return
def _setup_timer_palette(self):
self._timer_palette = self._timer_button.get_palette()
for seconds in TIMER_VALUES:
if seconds == 0:
text = _("Immediate")
else:
text = ngettext("%s second", "%s seconds", seconds) % seconds
menu_item = MenuItem(icon_name="timer-%d" % (seconds), text_label=text)
menu_item.connect("activate", self._timer_selected_cb, seconds)
self._timer_palette.menu.append(menu_item)
menu_item.show()
def _timer_selected_cb(self, button, seconds):
self.set_timer_idx(TIMER_VALUES.index(seconds))
def _duration_selection_cb(self, widget):
if self._duration_palette:
if not self._duration_palette.is_up():
self._duration_palette.popup(immediate=True, state=self._duration_palette.SECONDARY)
else:
self._duration_palette.popdown(immediate=True)
return
def _setup_duration_palette(self):
self._duration_palette = self._duration_button.get_palette()
for minutes in DURATION_VALUES:
if minutes == 0:
text = gtk.Label(_("Immediate"))
else:
text = ngettext("%s minute", "%s minutes", minutes) % minutes
menu_item = MenuItem(icon_name="duration-%d" % (minutes), text_label=text)
menu_item.connect("activate", self._duration_selected_cb, minutes)
self._duration_palette.menu.append(menu_item)
menu_item.show()
def _duration_selected_cb(self, button, minutes):
self.set_duration_idx(DURATION_VALUES.index(minutes))
def _quality_selection_cb(self, widget):
if self._quality_palette:
if not self._quality_palette.is_up():
self._quality_palette.popup(immediate=True, state=self._quality_palette.SECONDARY)
else:
self._quality_palette.popdown(immediate=True)
return
def _setup_quality_palette(self):
self._quality_palette = self._quality_button.get_palette()
for quality in QUALITY_VALUES:
text = _("%s quality") % (quality)
menu_item = MenuItem(icon_name=quality + "-quality", text_label=text)
menu_item.connect("activate", self._quality_selected_cb, quality)
self._quality_palette.menu.append(menu_item)
menu_item.show()
def _quality_selected_cb(self, button, quality):
self.set_quality(QUALITY_VALUES.index(quality))
def set_mode(self, mode):
if mode == constants.MODE_PHOTO:
self._quality_button.set_sensitive(False)
self._timer_button.set_sensitive(True)
self._duration_button.set_sensitive(False)
if mode == constants.MODE_VIDEO:
self._quality_button.set_sensitive(True)
self._timer_button.set_sensitive(True)
self._duration_button.set_sensitive(True)
if mode == constants.MODE_AUDIO:
self._quality_button.set_sensitive(False)
self._timer_button.set_sensitive(True)
self._duration_button.set_sensitive(True)
def get_timer(self):
return self._timer_value
def get_timer_idx(self):
if self._timer_value in TIMER_VALUES:
return TIMER_VALUES.index(self._timer_value)
else:
return TIMER_VALUES[0]
def set_timer_idx(self, idx):
self._timer_value = TIMER_VALUES[idx]
if hasattr(self, "_timer_button"):
self._timer_button.set_icon("timer-%d" % (self._timer_value))
def get_duration(self):
return self._duration_value
def get_duration_idx(self):
if self._duration_value in DURATION_VALUES:
return DURATION_VALUES.index(self._duration_value)
else:
return DURATION_VALUES[0]
def set_duration_idx(self, idx):
self._duration_value = DURATION_VALUES[idx]
if hasattr(self, "_duration_button"):
self._duration_button.set_icon("duration-%d" % (self._duration_value))
def get_quality(self):
return self._quality_value
def set_quality(self, idx):
self._quality_value = idx
if hasattr(self, "_quality_button"):
self._quality_button.set_icon("%s-quality" % (QUALITY_VALUES[idx]))
class ArduinoToolbar(gtk.Toolbar):
''' The toolbar for specifiying the sensor: temp, distance,
light or gray '''
def __init__(self, activity, channels):
self._arduino_context_id = None
gtk.Toolbar.__init__(self)
self.activity = activity
self._channels = channels
self.mode = 'arduino'
# Set up Sensores Button
self.time = RadioToolButton(group=None)
self.lista_sensores_button = []
self.we_are_logging = False
self._log_this_sample = False
self._logging_timer = None
self._logging_counter = 0
self._image_counter = 0
self._logging_interval = 0
self._channels_logged = []
self._busy = False
self._take_screenshot = True
log.debug('se agrega el boton refrescar')
self.refrescar_button = RadioToolButton(group=None)
self.refrescar_button.set_named_icon('recargar')
self.refrescar_button.connect('clicked', self.click_refresh_button)
self.insert(self.refrescar_button, -1)
separator = gtk.SeparatorToolItem()
separator.props.draw = True
self.insert(separator, -1)
self.robot = Arduino()
self._port_entry = gtk.Entry()
self._port_entry.set_text('A5') # A
self._port_entry_changed_id = self._port_entry.connect(
'changed', self._read_sensor)
if hasattr(self._port_entry, 'set_tooltip_text'):
self._port_entry.set_tooltip_text(_('Enter a port to read.'))
self._port_entry.set_width_chars(2)
self._port_entry.show()
toolitem = gtk.ToolItem()
toolitem.add(self._port_entry)
self.insert(toolitem, -1)
toolitem.show()
separator = gtk.SeparatorToolItem()
separator.props.draw = True
self.insert(separator, -1)
self._log_value = LOG_TIMER_VALUES[1]
self.log_label = gtk.Label(self._log_to_string(self._log_value))
toolitem = gtk.ToolItem()
toolitem.add(self.log_label)
self.insert(toolitem, -1)
self._log_button = ToolButton('timer-10')
self._log_button.set_tooltip(_('Select logging interval'))
self._log_button.connect('clicked', self._log_selection_cb)
self.insert(self._log_button, -1)
self._setup_log_palette()
# Set up Logging/Stop Logging Button
self._record = ToolButton('media-record')
self.insert(self._record, -1)
self._record.set_tooltip(_('Start Recording'))
self._record.connect('clicked', self.record_control_cb)
self.show_all()
def get_log(self):
return self._log_value
def get_log_idx(self):
if self._log_value in LOG_TIMER_VALUES:
return LOG_TIMER_VALUES.index(self._log_value)
else:
return LOG_TIMER_VALUES[0]
def set_log_idx(self, idx):
self._log_value = LOG_TIMER_VALUES[idx]
self.log_label.set_text(self._log_to_string(self._log_value))
if hasattr(self, '_log_button'):
self._log_button.set_icon('timer-%d' % (self._log_value))
def _log_selection_cb(self, widget):
if self._log_palette:
if not self._log_palette.is_up():
self._log_palette.popup(immediate=True,
state=self._log_palette.SECONDARY)
else:
self._log_palette.popdown(immediate=True)
return
def _log_to_seconds(self, tenth_seconds):
return tenth_seconds / 10.
def _log_to_string(self, tenth_seconds):
if tenth_seconds in LOG_TIMER_LABELS:
return LOG_TIMER_LABELS[tenth_seconds]
else:
return _('1 second')
def _setup_log_palette(self):
self._log_palette = self._log_button.get_palette()
for tenth_seconds in LOG_TIMER_VALUES:
text = self._log_to_string(tenth_seconds)
menu_item = MenuItem(icon_name='timer-%d' % (tenth_seconds),
text_label=self._log_to_string(tenth_seconds))
menu_item.connect('activate', self._log_selected_cb, tenth_seconds)
self._log_palette.menu.append(menu_item)
menu_item.show()
def _log_selected_cb(self, button, seconds):
self.set_log_idx(LOG_TIMER_VALUES.index(seconds))
def get_port(self):
return self._port_value
def get_port_idx(self):
if self._port_value in PORT_VALUES:
return PORT_VALUES.index(self._port_value)
else:
return PORT_VALUES[0]
def set_port_idx(self, idx):
self._port_value = PORT_VALUES[idx]
self.port_label.set_text(self._port_to_string(self._port_value))
if hasattr(self, '_port_button'):
self._port_button.set_icon('arduino-tools')
def _port_selection_cb(self, widget):
if self._port_palette:
if not self._port_palette.is_up():
self._port_palette.popup(immediate=True,
state=self._port_palette.SECONDARY)
else:
self._port_palette.popdown(immediate=True)
return
def _port_to_string(self, tenth_seconds):
if tenth_seconds in PORT_LABELS:
return PORT_LABELS[tenth_seconds]
else:
return _('1 second')
def _setup_port_palette(self):
self._port_palette = self._port_button.get_palette()
for tenth_seconds in PORT_VALUES:
text = self._port_to_string(tenth_seconds)
menu_item = MenuItem(
icon_name='arduino-tools',
text_label=self._port_to_string(tenth_seconds))
menu_item.connect('activate', self._port_selected_cb,
tenth_seconds)
self._port_palette.menu.append(menu_item)
menu_item.show()
def _port_selected_cb(self, button, seconds):
self.set_port_idx(PORT_VALUES.index(seconds))
def read_sensor_from_bobot_server(self):
log.debug('**********Read Sensor ***********')
return 0
def click_refresh_button(self, event=None):
log.debug('********** clickea botton refresh ***********')
self.robot.refresh()
self.mode = 'reading'
self.read_sensor_from_bobot_server = self._read_sensor
self.activity.limpiar_canales()
self.set_arduino_context()
return False
def _port_entry_cb(self, event=None):
log.debug('********** port_changed ***********')
self.robot.refresh()
self.mode = 'reading'
self.read_sensor_from_bobot_server = self._read_sensor
self.activity.limpiar_canales()
self.set_arduino_context()
return False
def set_arduino_context(self):
self.activity.audiograb.stop_grabbing()
if self._arduino_context_id:
gobject.source_remove(self._arduino_context_id)
self._arduino_context_id =\
gobject.timeout_add(50,self.arduino_context_on)
def arduino_context_on(self):
bufChannelTmp = []
#Si esta el boton de pause activada no se agregar el nuevo valor
if self.activity.audiograb.get_freeze_the_display():
bufChannelTmp.append(self.read_sensor_from_bobot_server())
for i in range(self.activity.audiograb.channels):
self.activity.wave.new_buffer(bufChannelTmp, i)
if self.we_are_logging:
self.logging_to_file(bufChannelTmp, i)
#if self.activity.CONTEXT == 'arduino':
return True
#else:
#return False
def logging_to_file(self, data_buffer, channel):
if self.we_are_logging:
if self._logging_counter == MAX_LOG_ENTRIES:
self._logging_counter = 0
self.we_are_logging = False
self.activity.data_logger.stop_session()
else:
if self._logging_interval == 0:
self._emit_for_logging(data_buffer, channel=channel)
self._log_this_sample = False
self.we_are_logging = False
self.activity.data_logger.stop_session()
elif self._log_this_sample:
# Sample channels in order
if self.activity.audiograb._channels_logged.index(
False) == channel:
self.activity.audiograb._channels_logged[
channel] = True
self._emit_for_logging(data_buffer, channel=channel)
# Have we logged every channel?
if self.activity.audiograb._channels_logged.count(
True) == self.activity.audiograb.channels:
self._log_this_sample = False
for i in range(self.activity.audiograb.channels):
self.activity.audiograb._channels_logged[
i] = False
self._logging_counter += 1
def _emit_for_logging(self, data_buffer, channel=0):
'''Sends the data for logging'''
if not self._busy:
self._busy = True
if self._take_screenshot:
if self.activity.data_logger.take_screenshot(
self._image_counter):
self._image_counter += 1
else:
log.debug('failed to take screenshot %d' %
(self._logging_counter))
self._busy = False
return
value_string = data_buffer[0]
if self.activity.audiograb.channels > 1:
self.activity.data_logger.write_value(
value_string,
channel=channel,
sample=self._logging_counter)
else:
self.activity.data_logger.write_value(
value_string, sample=self._logging_counter)
self._busy = False
else:
log.debug('skipping sample %d.%d' %
(self._logging_counter, channel))
def _sample_now(self):
''' Log the current sample now. This method is called from the
_logging_timer object when the interval expires. '''
self._log_this_sample = True
self._make_timer()
def _make_timer(self):
''' Create the next timer that will trigger data logging. '''
self._logging_timer = Timer(self._logging_interval, self._sample_now)
self._logging_timer.start()
def record_control_cb(self, button=None):
''' Depending upon the selected interval, does either a logging
session, or just logs the current buffer. '''
if self.we_are_logging:
self.set_logging_params(start_stop=False)
self._record.set_icon('media-record')
self._record.show()
self._record.set_tooltip(_('Start Recording'))
else:
Xscale = 0.0
Yscale = 0.0
interval = self.interval_convert()
username = self.activity.nick
if self.activity.wave.get_fft_mode():
self.activity.data_logger.start_new_session(
username,
Xscale,
Yscale,
_(self.logging_interval_status),
channels=self._channels,
mode='frequency')
else:
self.activity.data_logger.start_new_session(
username,
Xscale,
Yscale,
_(self.logging_interval_status),
channels=self._channels,
mode=self.mode)
self.set_logging_params(start_stop=True,
interval=interval,
screenshot=False)
self._record.set_icon('record-stop')
self._record.show()
self._record.set_tooltip(_('Stop Recording'))
self.activity.new_recording = True
def set_logging_params(self,
start_stop=False,
interval=0,
screenshot=True):
''' Configures for logging of data: starts or stops a session;
sets the logging interval; and flags if screenshot is taken. '''
self.we_are_logging = start_stop
self._logging_interval = interval
if not start_stop:
if self._logging_timer:
self._logging_timer.cancel()
self._logging_timer = None
self._log_this_sample = False
self._logging_counter = 0
elif interval != 0:
self._make_timer()
self._take_screenshot = screenshot
self._busy = False
def interval_convert(self):
''' Converts interval string to an integer that denotes the
number of times the audiograb buffer must be called before a
value is written. When set to 0, the whole of current buffer
will be written. '''
interval_dictionary = {
'1/10 second': 0.1,
'1 second': 1,
'30 seconds': 30,
'5 minutes': 300,
'30 minutes': 1800
}
try:
return interval_dictionary[self.logging_interval_status]
except ValueError:
logging.error('logging interval status = %s' %\
(str(self.logging_interval_status)))
return 0
def take_screenshot(self):
''' Capture the current screen to the Journal '''
log.debug('taking a screenshot %d' % (self._logging_counter))
self.set_logging_params(start_stop=True, interval=0, screenshot=True)
def _read_sensor(self, event=None):
port = self._port_entry.get_text()
if port.count('A'):
log.debug('analogRead')
value = self.robot.analogRead(port.strip('A'))
else:
log.debug('digitalRead')
self.robot.pinMode(port, _('INPUT'))
value = self.robot.digitalRead(port)
log.debug('VALOR A DEVOLVER')
value *= 1000
log.debug(value)
gtk.gdk.flush()
return value
class InstrumentToolbar(gtk.Toolbar):
''' The toolbar for adding new instruments '''
def __init__(self, activity):
gtk.Toolbar.__init__(self)
self.activity = activity
self.new_instruments = []
self._name_entry = gtk.Entry()
self._name_entry.set_text(_('my instrument'))
self._name_entry_changed_id = self._name_entry.connect(
'changed', self.update_name_entry)
if hasattr(self._name_entry, 'set_tooltip_text'):
self._name_entry.set_tooltip_text(_('Enter instrument name.'))
self._name_entry.set_width_chars(24)
self._name_entry.show()
toolitem = gtk.ToolItem()
toolitem.add(self._name_entry)
self.insert(toolitem, -1)
toolitem.show()
self._note = 'A'
self._notes_button = ToolButton('notes')
self._notes_button.set_tooltip(_('Notes'))
self._notes_button.connect('clicked', self._button_selection_cb)
self.insert(self._notes_button, -1)
self._setup_notes_palette()
self._notes_button.show()
self._octave = 4
self._octaves_button = ToolButton('octaves')
self._octaves_button.set_tooltip(_('Octaves'))
self._octaves_button.connect('clicked', self._button_selection_cb)
self.insert(self._octaves_button, -1)
self._setup_octaves_palette()
self._octaves_button.show()
self._new_note = ToolButton('list-add')
self._new_note.show()
self.insert(self._new_note, -1)
self._new_note.set_tooltip(_('Add a new note.'))
self._new_note.connect('clicked', self.new_note_cb)
self._new_note.show()
def _button_selection_cb(self, widget):
palette = widget.get_palette()
if palette:
if not palette.is_up():
palette.popup(immediate=True, state=palette.SECONDARY)
else:
palette.popdown(immediate=True)
return
def _setup_notes_palette(self):
self._notes_palette = self._notes_button.get_palette()
for note in NOTES:
menu_item = MenuItem(icon_name='', text_label=note)
menu_item.connect('activate', self._note_selected_cb, note)
self._notes_palette.menu.append(menu_item)
menu_item.show()
def _note_selected_cb(self, widget, note):
self._note = note
def _setup_octaves_palette(self):
self._octaves_palette = self._octaves_button.get_palette()
for octave in range(9):
menu_item = MenuItem(icon_name='', text_label=str(octave))
menu_item.connect('activate', self._octave_selected_cb, octave)
self._octaves_palette.menu.append(menu_item)
menu_item.show()
def _octave_selected_cb(self, widget, octave):
self._octave = octave
def update_name_entry(self, *args):
''' Add name to INSTRUMENT_DICT and combo box '''
# Wait until a note has been added...
return
def new_note_cb(self, *args):
''' Add a new note to instrument tuning list '''
name = self._name_entry.get_text()
if name not in INSTRUMENT_DICT:
INSTRUMENT_DICT[name] = []
self.activity.tuning_toolbar.instrument.append(name)
i = len(self.activity.tuning_toolbar.instrument)
menu_item = MenuItem(icon_name='', text_label=name)
menu_item.connect(
'activate',
self.activity.tuning_toolbar.instrument_selected_cb, name)
self.activity.tuning_toolbar.instrument_palette.menu.append(
menu_item)
menu_item.show()
self.new_instruments.append(name)
freq = A0 * pow(TWELTHROOT2,
self._octave * 12 + NOTES.index(self._note))
if freq not in INSTRUMENT_DICT[name]:
INSTRUMENT_DICT[name].append(freq)
class WebToolbar(gtk.Toolbar):
__gtype_name__ = 'WebToolbar'
__gsignals__ = {
'add-link': (gobject.SIGNAL_RUN_FIRST,
gobject.TYPE_NONE,
([]))
}
def __init__(self, activity):
gtk.Toolbar.__init__(self)
self._activity = activity
self._browser = activity._browser
self._loading = False
self._back = ToolButton('go-previous-paired')
self._back.set_tooltip(_('Back'))
self._back.props.sensitive = False
self._back.connect('clicked', self._go_back_cb)
self.insert(self._back, -1)
self._back.show()
self._forward = ToolButton('go-next-paired')
self._forward.set_tooltip(_('Forward'))
self._forward.props.sensitive = False
self._forward.connect('clicked', self._go_forward_cb)
self.insert(self._forward, -1)
self._forward.show()
self._stop_and_reload = ToolButton('media-playback-stop')
self._stop_and_reload.connect('clicked', self._stop_and_reload_cb)
self.insert(self._stop_and_reload, -1)
self._stop_and_reload.show()
self.entry = WebEntry()
self.entry.connect('activate', self._entry_activate_cb)
entry_item = gtk.ToolItem()
entry_item.set_expand(True)
entry_item.add(self.entry)
self.entry.show()
self.insert(entry_item, -1)
entry_item.show()
self._link_add = ToolButton('emblem-favorite')
self._link_add.set_tooltip(_('Bookmark'))
self._link_add.connect('clicked', self._link_add_clicked_cb)
self.insert(self._link_add, -1)
self._link_add.show()
progress_listener = self._browser.progress
progress_listener.connect('location-changed',
self._location_changed_cb)
progress_listener.connect('loading-start', self._loading_start_cb)
progress_listener.connect('loading-stop', self._loading_stop_cb)
progress_listener.connect('loading-progress',
self._loading_progress_cb)
self._browser.history.connect('session-history-changed',
self._session_history_changed_cb)
self._browser.connect("notify::title", self._title_changed_cb)
self._create_ssb = ToolButton('activity-ssb')
self._create_ssb.set_tooltip(_('Create SSB'))
self._create_ssb.connect('clicked', self._create_ssb_clicked_cb)
self.insert(self._create_ssb, -1)
self._create_ssb.show()
self._save_document = ToolButton('save')
self._save_document.set_tooltip(_('Save Document'))
self._save_document.connect('clicked', self._save_document_clicked_cb)
self.insert(self._save_document, -1)
self._save_document.show()
def _session_history_changed_cb(self, session_history, current_page_index):
# We have to wait until the history info is updated.
gobject.idle_add(self._reload_session_history, current_page_index)
def _location_changed_cb(self, progress_listener, uri):
cls = components.classes['@mozilla.org/intl/texttosuburi;1']
texttosuburi = cls.getService(interfaces.nsITextToSubURI)
ui_uri = texttosuburi.unEscapeURIForUI(uri.originCharset, uri.spec)
self._set_address(ui_uri)
self._update_navigation_buttons()
filepicker.cleanup_temp_files()
def _loading_start_cb(self, progress_listener):
self._set_title(None)
self._set_loading(True)
self._update_navigation_buttons()
def _loading_stop_cb(self, progress_listener):
self._set_loading(False)
self._update_navigation_buttons()
def _loading_progress_cb(self, progress_listener, progress):
self._set_progress(progress)
def _set_progress(self, progress):
self.entry.props.progress = progress
def _set_address(self, address):
self.entry.props.address = address
def _set_title(self, title):
self.entry.props.title = title
def _show_stop_icon(self):
self._stop_and_reload.set_icon('media-playback-stop')
def _show_reload_icon(self):
self._stop_and_reload.set_icon('view-refresh')
def _update_navigation_buttons(self):
can_go_back = self._browser.web_navigation.canGoBack
self._back.props.sensitive = can_go_back
can_go_forward = self._browser.web_navigation.canGoForward
self._forward.props.sensitive = can_go_forward
def _entry_activate_cb(self, entry):
self._browser.load_uri(entry.props.text)
self._browser.grab_focus()
def _go_back_cb(self, button):
self._browser.web_navigation.goBack()
def _go_forward_cb(self, button):
self._browser.web_navigation.goForward()
def _title_changed_cb(self, embed, spec):
self._set_title(embed.props.title)
def _stop_and_reload_cb(self, button):
if self._loading:
self._browser.web_navigation.stop( \
interfaces.nsIWebNavigation.STOP_ALL)
else:
flags = interfaces.nsIWebNavigation.LOAD_FLAGS_NONE
self._browser.web_navigation.reload(flags)
def _set_loading(self, loading):
self._loading = loading
if self._loading:
self._show_stop_icon()
self._stop_and_reload.set_tooltip(_('Stop'))
else:
self._show_reload_icon()
self._stop_and_reload.set_tooltip(_('Reload'))
def _reload_session_history(self, current_page_index=None):
session_history = self._browser.web_navigation.sessionHistory
if current_page_index is None:
current_page_index = session_history.index
for palette in (self._back.get_palette(), self._forward.get_palette()):
for menu_item in palette.menu.get_children():
palette.menu.remove(menu_item)
if current_page_index > _MAX_HISTORY_ENTRIES:
bottom = current_page_index - _MAX_HISTORY_ENTRIES
else:
bottom = 0
if (session_history.count - current_page_index) > \
_MAX_HISTORY_ENTRIES:
top = current_page_index + _MAX_HISTORY_ENTRIES + 1
else:
top = session_history.count
for i in range(bottom, top):
if i == current_page_index:
continue
entry = session_history.getEntryAtIndex(i, False)
menu_item = MenuItem(entry.title, text_maxlen=60)
menu_item.connect('activate', self._history_item_activated_cb, i)
if i < current_page_index:
palette = self._back.get_palette()
palette.menu.prepend(menu_item)
elif i > current_page_index:
palette = self._forward.get_palette()
palette.menu.append(menu_item)
menu_item.show()
def _history_item_activated_cb(self, menu_item, index):
self._browser.web_navigation.gotoIndex(index)
def _link_add_clicked_cb(self, button):
self.emit('add-link')
def _create_ssb_clicked_cb(self, button):
title = self._activity.webtitle
uri = self._activity.current
#favicon = self._activity.get_favicon()
pattern = re.compile(r'''
(\w+) # first word
[ _-]* # any amount and type of spacing
(\w+)? # second word, may be absent
''', re.VERBOSE)
first, second = re.search(pattern, title).groups()
# CamelCase the two words
first = first.capitalize()
if second is not None:
second = second.capitalize()
name = first + ' ' + second
else:
name = first
self._ssb = ssb.SSBCreator(name, uri)
# alert to show after creation
alert = Alert()
alert.props.title = _('SSB Creation')
cancel_icon = Icon(icon_name='dialog-cancel')
alert.add_button(gtk.RESPONSE_CANCEL, _('Cancel'), cancel_icon)
cancel_icon.show()
open_icon = Icon(icon_name='filesave')
alert.add_button(gtk.RESPONSE_APPLY, _('Show in Journal'), open_icon)
open_icon.show()
ok_icon = Icon(icon_name='dialog-ok')
alert.add_button(gtk.RESPONSE_OK, _('Install'), ok_icon)
ok_icon.show()
self._activity.add_alert(alert)
alert.connect('response', self._create_ssb_alert_cb)
try:
self._ssb.create()
except Exception, e:
# DEBUG: alert shows exception message
alert.props.msg = _('Failed: ') + str(e)
else:
