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: