def combo_factory(combo_array, toolbar, callback, cb_arg=None, tooltip=None, default=None): '''Factory for making a toolbar combo box''' combo = ComboBox() if tooltip is not None and hasattr(combo, 'set_tooltip_text'): combo.set_tooltip_text(tooltip) if cb_arg is not None: combo.connect('changed', callback, cb_arg) else: combo.connect('changed', callback) for i, selection in enumerate(combo_array): combo.append_item(i, selection, None) combo.show() toolitem = gtk.ToolItem() toolitem.add(combo) if hasattr(toolbar, 'insert'): # the main toolbar toolbar.insert(toolitem, -1) else: # or a secondary toolbar toolbar.props.page.insert(toolitem, -1) toolitem.show() if default is not None: combo.set_active(combo_array.index(default)) return combo
def _get_with_search_combo(self): with_search = ComboBox() with_search.append_item(_ACTION_EVERYBODY, _('Anyone')) with_search.append_separator() with_search.append_item(_ACTION_MY_FRIENDS, _('My friends')) with_search.append_item(_ACTION_MY_CLASS, _('My class')) with_search.append_separator() # TODO: Ask the model for buddies. with_search.append_item(3, 'Dan', 'theme:xo') with_search.set_active(0) with_search.connect('changed', self._combo_changed_cb) return with_search
def _combo_factory(options, tooltip, toolbar, callback, default=0): ''' Combo box factory ''' combo = ComboBox() if hasattr(combo, 'set_tooltip_text'): combo.set_tooltip_text(tooltip) combo.connect('changed', callback) for i, option in enumerate(options): combo.append_item(i, option.replace('-', ' '), None) combo.set_active(default) combo.show() tool = ToolComboBox(combo) tool.show() toolbar.insert(tool, -1) return combo
def _get_when_search_combo(self): when_search = ComboBox() when_search.append_item(_ACTION_ANYTIME, _('Anytime')) when_search.append_separator() when_search.append_item(_ACTION_TODAY, _('Today')) when_search.append_item(_ACTION_SINCE_YESTERDAY, _('Since yesterday')) # TRANS: Filter entries modified during the last 7 days. when_search.append_item(_ACTION_PAST_WEEK, _('Past week')) # TRANS: Filter entries modified during the last 30 days. when_search.append_item(_ACTION_PAST_MONTH, _('Past month')) # TRANS: Filter entries modified during the last 356 days. when_search.append_item(_ACTION_PAST_YEAR, _('Past year')) when_search.set_active(0) when_search.connect('changed', self._combo_changed_cb) return when_search
def combo_factory(combo_array, default, tooltip, callback, toolbar): '''Factory for making a toolbar combo box''' my_combo = ComboBox() if hasattr(my_combo, 'set_tooltip_text'): my_combo.set_tooltip_text(tooltip) my_combo.connect('changed', callback) for i, s in enumerate(combo_array): my_combo.append_item(i, s, None) tool = ToolComboBox(my_combo) if hasattr(toolbar, 'insert'): # the main toolbar toolbar.insert(tool, -1) else: # or a secondary toolbar toolbar.props.page.insert(tool, -1) tool.show() my_combo.set_active(default) return my_combo
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.detect_sensors() self.load_buttons() separator = gtk.SeparatorToolItem() separator.props.draw = True self.insert(separator, -1) self._log_interval_combo = ComboBox() self.interval = [ _('1/10 second'), _('1 second'), _('30 seconds'), _('5 minutes'), _('30 minutes') ] if hasattr(self._log_interval_combo, 'set_tooltip_text'): self._log_interval_combo.set_tooltip_text(_('Sampling interval')) self._interval_changed_id = self._log_interval_combo.connect( 'changed', self.log_interval_cb) for i, s in enumerate(self.interval): self._log_interval_combo.append_item(i, s, None) if s == _('1 second'): self._log_interval_combo.set_active(i) self._log_interval_tool = ToolComboBox(self._log_interval_combo) self.insert(self._log_interval_tool, -1) self.logging_interval_status = '1 second' # 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() # BUTIA Busca modulos conectados y pregunta si son sensores def detect_sensors(self): self.robot = butiaAPI.robot() log.debug('listando modulos detectados:') modules = self.robot.get_modules_list() 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): is_sensor = 0 descripcion = 'A' #log.debug('DESCRIBIENDO: '+ module) descripcion = self.robot.doCommand('DESCRIBE ' + module) if descripcion == -1: return 0 #log.debug(descripcion) is_sensor = descripcion.count( 'returns={[1]') and module != 'display' and module != 'butia' 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)) if self.sensor.count('temp'): #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) ) radio_tool_button.connect('clicked', self.click_temp_button, self.get_sensor_number(self.sensor)) elif self.sensor.count('dist'): #log.debug('el sensor '+ self.sensor + 'es el numero '+ self.get_sensor_number(self.sensor) ) radio_tool_button.connect('clicked', self.click_dist_button, self.get_sensor_number(self.sensor)) elif self.sensor.count('grey'): #log.debug('el sensor '+ self.sensor + 'es el numero '+ self.get_sensor_number(self.sensor) ) radio_tool_button.connect('clicked', self.click_grises_button, self.get_sensor_number(self.sensor)) elif self.sensor.count('light'): #log.debug('el sensor '+ self.sensor + 'es el numero '+ self.get_sensor_number(self.sensor) ) radio_tool_button.connect('clicked', self.click_luz_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): for s in self.lista_sensores_button: self.remove(s) self.detect_sensors() self.load_buttons() self.show_all() def get_sensor_number(self, sensor): number = 0 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 = 0 value = self.robot.callModule('temp:' + 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 = 0 #value = self.robot.getDistance(num) value = self.robot.callModule('distanc:' + str(num), 'getValue') #log.debug('distance = ' + str(value)) return value def read_grises_from_bobot_server(self, num=0): #log.debug('**********Sensando grises'+ str(num) + '******************') value = '0' value = self.robot.callModule('grey:' + 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 = '0' value = self.robot.callModule('ligth:' + str(num), 'getValue') #log.debug('grey = ' + 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_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 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 TextToolbar(gtk.Toolbar): _ACTION_ALIGNMENT_LEFT = 0 _ACTION_ALIGNMENT_CENTER = 1 _ACTION_ALIGNMENT_RIGHT = 2 _ACTION_ALIGNMENT_JUSTIFY = 3 def __init__(self, toolbox, abiword_canvas, parent): self._colorseldlg = None gtk.Toolbar.__init__(self) self._toolbox = toolbox self._abiword_canvas = abiword_canvas self._parent = parent self._bold = ToggleToolButton('format-text-bold') self._bold.set_tooltip(_('Bold')) self._bold_id = self._bold.connect('clicked', self._bold_cb) self._abiword_canvas.connect('bold', self._isBold_cb) self.insert(self._bold, -1) self._bold.show() self._italic = ToggleToolButton('format-text-italic') self._italic.set_tooltip(_('Italic')) self._italic_id = self._italic.connect('clicked', self._italic_cb) self._abiword_canvas.connect('italic', self._isItalic_cb) self.insert(self._italic, -1) self._italic.show() self._underline = ToggleToolButton('format-text-underline') self._underline.set_tooltip(_('Underline')) self._underline_id = self._underline.connect('clicked', self._underline_cb) self._abiword_canvas.connect('underline', self._isUnderline_cb) self.insert(self._underline, -1) self._underline.show() self._text_color = gtk.ColorButton() self._text_color_id = self._text_color.connect('color-set', self._text_color_cb) tool_item = gtk.ToolItem() tool_item.add(self._text_color) self.insert(tool_item, -1) tool_item.show_all() separator = gtk.SeparatorToolItem() separator.set_draw(True) separator.show() self.insert(separator, -1) self._font_size_icon = Icon(icon_name="format-text-size", icon_size=gtk.ICON_SIZE_LARGE_TOOLBAR) tool_item = gtk.ToolItem() tool_item.add(self._font_size_icon) self.insert(tool_item, -1) tool_item.show_all() self._font_size_combo = ComboBox() self._font_sizes = [ '8', '9', '10', '11', '12', '14', '16', '20', '22', '24', '26', '28', '36', '48', '72' ] self._font_size_changed_id = self._font_size_combo.connect( 'changed', self._font_size_changed_cb) for i, s in enumerate(self._font_sizes): self._font_size_combo.append_item(i, s, None) if s == '12': self._font_size_combo.set_active(i) tool_item = ToolComboBox(self._font_size_combo) self.insert(tool_item, -1) tool_item.show() self._has_custom_fonts = False self._font_combo = ComboBox() self._fonts = sorted(self._abiword_canvas.get_font_names()) self._fonts_changed_id = self._font_combo.connect( 'changed', self._font_changed_cb) for i, f in enumerate(self._fonts): self._font_combo.append_item(i, f, None) if f == 'Times New Roman': self._font_combo.set_active(i) tool_item = ToolComboBox(self._font_combo) self.insert(tool_item, -1) tool_item.show() separator = gtk.SeparatorToolItem() separator.set_draw(True) self.insert(separator, -1) separator.show() self._alignment = ComboBox() self._alignment.append_item(self._ACTION_ALIGNMENT_LEFT, None, 'format-justify-left') self._alignment.append_item(self._ACTION_ALIGNMENT_CENTER, None, 'format-justify-center') self._alignment.append_item(self._ACTION_ALIGNMENT_RIGHT, None, 'format-justify-right') self._alignment.append_item(self._ACTION_ALIGNMENT_JUSTIFY, None, 'format-justify-fill') self._alignment_changed_id = \ self._alignment.connect('changed', self._alignment_changed_cb) tool_item = ToolComboBox(self._alignment) self.insert(tool_item, -1) tool_item.show() self._abiword_canvas.connect('color', self._color_cb) self._abiword_canvas.connect('font-size', self._font_size_cb) self._abiword_canvas.connect('font-family', self._font_family_cb) self._abiword_canvas.connect('left-align', self._isLeftAlign_cb) self._abiword_canvas.connect('center-align', self._isCenterAlign_cb) self._abiword_canvas.connect('right-align', self._isRightAlign_cb) self._abiword_canvas.connect('justify-align', self._isJustifyAlign_cb) self._text_selected_handler = self._abiword_canvas.connect( 'text-selected', self._text_selected_cb) ####btn salir del barrido del menu item self._btn_barrido_menu = ToolButton() self._btn_barrido_menu.set_tooltip(_('Salir \nMenú')) self._btn_barrido_menu_id = self._btn_barrido_menu.connect( 'clicked', self._btn_barrido_menu_cb) self.insert(self._btn_barrido_menu, -1) self._btn_barrido_menu.set_no_show_all(True) #self._btn_barrido_menu.show() # en realidad mostrar solo si esta barriendo def _btn_barrido_menu_cb(self, button): if (self._parent.BOTONESxBARRIDO_MENU_ITEM): self._parent.BOTONESxBARRIDO_MENU = False self._parent.BOTONESxBARRIDO_MENU_ITEM = False self._parent.BOTONESxBARRIDO = False # si le doy True va a ejectuar el escribir porque llama al metodo del eventbox #self._parent.chk_activarBarrido_botones_menu.emit("clicked") self._parent.chk_activarBarrido_botones.set_active(True) ####fin btn salir del barrido del menu item def get_text_selected_handler(self): return self._text_selected_handler def _add_widget(self, widget, expand=False): tool_item = gtk.ToolItem() tool_item.set_expand(expand) tool_item.add(widget) widget.show() self.insert(tool_item, -1) tool_item.show() def setToggleButtonState(self, button, b, id): button.handler_block(id) button.set_active(b) button.handler_unblock(id) def _bold_cb(self, button): self._abiword_canvas.toggle_bold() def _isBold_cb(self, abi, b): self.setToggleButtonState(self._bold, b, self._bold_id) def _italic_cb(self, button): self._abiword_canvas.toggle_italic() def _isItalic_cb(self, abi, b): self.setToggleButtonState(self._italic, b, self._italic_id) def _underline_cb(self, button): self._abiword_canvas.toggle_underline() def _isUnderline_cb(self, abi, b): self.setToggleButtonState(self._underline, b, self._underline_id) def _color_cb(self, abi, r, g, b): self._text_color.set_color(gtk.gdk.Color(r * 256, g * 256, b * 256)) def _text_color_cb(self, button): newcolor = self._text_color.get_color() self._abiword_canvas.set_text_color(newcolor.red // 256.0, newcolor.green // 256.0, newcolor.blue // 256.0) def _font_size_cb(self, abi, size): for i, s in enumerate(self._font_sizes): if int(s) == int(size): self._font_size_combo.handler_block(self._font_size_changed_id) self._font_size_combo.set_active(i) self._font_size_combo.handler_unblock( self._font_size_changed_id) break def _font_size_changed_cb(self, combobox): if self._font_size_combo.get_active() != -1: logger.debug( 'Setting font size: %d', int(self._font_sizes[self._font_size_combo.get_active()])) self._abiword_canvas.set_font_size( self._font_sizes[self._font_size_combo.get_active()]) def _font_family_cb(self, abi, font_family): font_index = -1 # search for the font name in our font list for i, f in enumerate(self._fonts): if f == font_family: font_index = i break # if we don't know this font yet, then add it (temporary) to the list if font_index == -1: logger.debug('Font not found in font list: %s', font_family) if not self._has_custom_fonts: # add a separator to seperate the non-available fonts from # the available ones self._fonts.append('') # ugly self._font_combo.append_separator() self._has_custom_fonts = True # add the new font self._fonts.append(font_family) self._font_combo.append_item(0, font_family, None) # see how many fonts we have now, so we can select the last one model = self._font_combo.get_model() num_children = model.iter_n_children(None) logger.debug('Number of fonts in the list: %d', num_children) font_index = num_children - 1 # activate the found font if (font_index > -1): self._font_combo.handler_block(self._fonts_changed_id) self._font_combo.set_active(font_index) self._font_combo.handler_unblock(self._fonts_changed_id) def _font_changed_cb(self, combobox): if self._font_combo.get_active() != -1: logger.debug('Setting font name: %s', self._fonts[self._font_combo.get_active()]) self._abiword_canvas.set_font_name( self._fonts[self._font_combo.get_active()]) def _alignment_changed_cb(self, combobox): if self._alignment.get_active() == self._ACTION_ALIGNMENT_LEFT: self._abiword_canvas.align_left() elif self._alignment.get_active() == self._ACTION_ALIGNMENT_CENTER: self._abiword_canvas.align_center() elif self._alignment.get_active() == self._ACTION_ALIGNMENT_RIGHT: self._abiword_canvas.align_right() elif self._alignment.get_active() == self._ACTION_ALIGNMENT_JUSTIFY: self._abiword_canvas.align_justify() else: raise ValueError, 'Unknown option in alignment combobox.' def _update_alignment_icon(self, index): self._alignment.handler_block(self._alignment_changed_id) try: self._alignment.set_active(index) finally: self._alignment.handler_unblock(self._alignment_changed_id) def _isLeftAlign_cb(self, abi, b): if b: self._update_alignment_icon(self._ACTION_ALIGNMENT_LEFT) def _isCenterAlign_cb(self, abi, b): if b: self._update_alignment_icon(self._ACTION_ALIGNMENT_CENTER) def _isRightAlign_cb(self, abi, b): if b: self._update_alignment_icon(self._ACTION_ALIGNMENT_RIGHT) def _isJustifyAlign_cb(self, abi, b): if b: self._update_alignment_icon(self._ACTION_ALIGNMENT_JUSTIFY) def _text_selected_cb(self, abi, b): if b: self._toolbox.set_current_toolbar(TOOLBAR_TEXT) self._abiword_canvas.grab_focus() # hack: bad toolbox, bad!
class SpeechToolbar(gtk.Toolbar): def __init__(self): gtk.Toolbar.__init__(self) voicebar = gtk.Toolbar() self.activity = None self.sorted_voices = [i for i in speech.voices()] self.sorted_voices.sort(self.compare_voices) default = 0 for voice in self.sorted_voices: if voice[0] == 'default': break default = default + 1 # Play button Image play_img = gtk.Image() play_img.show() play_img.set_from_icon_name('media-playback-start', gtk.ICON_SIZE_LARGE_TOOLBAR) # Pause button Image pause_img = gtk.Image() pause_img.show() pause_img.set_from_icon_name('media-playback-pause', gtk.ICON_SIZE_LARGE_TOOLBAR) # Play button self.play_btn = ToggleToolButton('media-playback-start') self.play_btn.show() self.play_btn.connect('toggled', self._play_cb, [play_img, pause_img]) self.insert(self.play_btn, -1) self.play_btn.set_tooltip(_('Play / Pause')) self.voice_combo = ComboBox() self.voice_combo.connect('changed', self.voice_changed_cb) for voice in self.sorted_voices: self.voice_combo.append_item(voice, voice[0]) self.voice_combo.set_active(default) combotool = ToolComboBox(self.voice_combo) self.insert(combotool, -1) combotool.show() self.pitchadj = gtk.Adjustment(0, -100, 100, 1, 10, 0) self.pitchadj.connect("value_changed", self.pitch_adjusted_cb) pitchbar = gtk.HScale(self.pitchadj) pitchbar.set_draw_value(False) pitchbar.set_update_policy(gtk.UPDATE_DISCONTINUOUS) pitchbar.set_size_request(240,15) pitchtool = gtk.ToolItem() pitchtool.add(pitchbar) pitchtool.show() self.insert(pitchtool, -1) pitchbar.show() self.rateadj = gtk.Adjustment(0, -100, 100, 1, 10, 0) self.rateadj.connect("value_changed", self.rate_adjusted_cb) ratebar = gtk.HScale(self.rateadj) ratebar.set_draw_value(False) ratebar.set_update_policy(gtk.UPDATE_DISCONTINUOUS) ratebar.set_size_request(240,15) ratetool = gtk.ToolItem() ratetool.add(ratebar) ratetool.show() self.insert(ratetool, -1) ratebar.show() def compare_voices(self, a, b): if a[0].lower() == b[0].lower(): return 0 if a[0] .lower()< b[0].lower(): return -1 if a[0] .lower()> b[0].lower(): return 1 def voice_changed_cb(self, combo): speech.voice = combo.props.value if self.activity != None: speech.say(speech.voice[0]) def pitch_adjusted_cb(self, get): speech.pitch = int(get.value) speech.say(_("pitch adjusted")) def rate_adjusted_cb(self, get): speech.rate = int(get.value) speech.say(_("rate adjusted")) def set_activity(self, activity): self.activity = activity def _play_cb(self, widget, images): widget.set_icon_widget(images[int(widget.get_active())]) if widget.get_active(): if speech.is_stopped(): speech.play(self.activity.add_word_marks()) else: speech.stop()
class SoundToolbar(gtk.Toolbar): """ Set up the toolbar for audio (analog) capture mode """ SAMPLE_NOW = _('Capture now') SAMPLE_30_SEC = _('Every 30 sec.') SAMPLE_2_MIN = _('Every 2 min.') SAMPLE_10_MIN = _('Every 10 min.') SAMPLE_30_MIN = _('Every 30 min.') LOWER = 0.0 UPPER = 1.0 def __init__(self, activity): """ Initialize the toolbar controls. """ gtk.Toolbar.__init__(self) self.activity = activity self._STR_BASIC = _('Sound') + ' ' self._STR1 = _('Time Base') + ' ' self._STR2 = _('Frequency Base') + ' ' self._STR3 = ' ' + _('Invert') + ' ' self._STR_SCALEX = "" self._STR_XAXIS_TEXT = \ _('X Axis Scale: 1 division = %(division)s %(unit)s') # TRANSLATORS: This is milli seconds. self._ms = _('ms') # TRANSLATORS: This is Hertz, so 1/second. self._Hz = _('Hz') self._update_page_size_id = None self.string_for_textbox = "" self.gain = 1.0 self.y_mag = 3.0 self.capture_gain = CAPTURE_GAIN self.mic_boost = MIC_BOOST # self.logging_status = False self._record = None # Set up Time-domain Button self.time = ToolButton('domain-time2') self.insert(self.time, -1) self.time.set_tooltip(_('Time Base')) self.time.connect('clicked', self._timefreq_control_cb, True) # Set up Frequency-domain Button self.freq = ToolButton('domain-freq') self.insert(self.freq, -1) self.freq.show() self.freq.set_tooltip(_('Frequency Base')) self.freq.connect('clicked', self._timefreq_control_cb, False) # Set up Frequency-control Slider and corresponding buttons if not self.activity.has_toolbarbox: self.add_frequency_slider(self) # Set up the Pause Button self._pause = ToolButton('media-playback-pause') self.insert(self._pause, -1) self._pause.set_tooltip(_('Freeze the display')) self._pause.connect('clicked', self._pauseplay_control_cb) if self.activity.has_toolbarbox: separator = gtk.SeparatorToolItem() separator.props.draw = True self.insert(separator, -1) separator.show() self.loginterval_img = gtk.Image() self.loginterval_img.set_from_file(ICONS_DIR + 'sample_rate.svg') self.loginterval_img_tool = gtk.ToolItem() self.loginterval_img_tool.add(self.loginterval_img) self.insert(self.loginterval_img_tool, -1) # Set up the Logging-interval Combo box self._loginterval_combo = ComboBox() self.interval = [ _(self.SAMPLE_NOW), _(self.SAMPLE_30_SEC), _(self.SAMPLE_2_MIN), _(self.SAMPLE_10_MIN), _(self.SAMPLE_30_MIN) ] if hasattr(self._loginterval_combo, 'set_tooltip_text'): self._loginterval_combo.set_tooltip_text(_('Sampling interval')) self._interval_changed_id = self._loginterval_combo.connect( 'changed', self.loginterval_control) for i, s in enumerate(self.interval): self._loginterval_combo.append_item(i, s, None) if s == self.SAMPLE_NOW: self._loginterval_combo.set_active(i) self._loginterval_tool = ToolComboBox(self._loginterval_combo) self.insert(self._loginterval_tool, -1) self.logginginterval_status = 'picture' # Set up Start/Stop Logging Button self._record = ToolButton('media-record') self.insert(self._record, -1) self._record.set_tooltip(_('Capture sample now')) self._record.connect('clicked', self.record_control) if self.activity.has_toolbarbox: separator = gtk.SeparatorToolItem() separator.props.draw = True self.insert(separator, -1) # Set up Trigger Combo box self._trigger_combo = ComboBox() self.trigger = [_('None'), _('Rising Edge'), _('Falling Edge')] self.trigger_conf = [ self.activity.wave.TRIGGER_NONE, self.activity.wave.TRIGGER_POS, self.activity.wave.TRIGGER_NEG ] self._trigger_changed_id = self._trigger_combo.connect( 'changed', self.update_trigger_control) for i, s in enumerate(self.trigger): self._trigger_combo.append_item(i, s, None) self._trigger_combo.set_active(0) if hasattr(self._trigger_combo, 'set_tooltip_text'): self._trigger_combo.set_tooltip_text(_('Create a trigger')) self._trigger_tool = ToolComboBox(self._trigger_combo) self.insert(self._trigger_tool, -1) self.show_all() return def add_frequency_slider(self, toolbar): """ 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.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_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_range_tool = gtk.ToolItem() self._freq_range_tool.add(self._freq_range) toolbar.insert(self._freq_stepper_up, -1) toolbar.insert(self._freq_range_tool, -1) toolbar.insert(self._freq_stepper_down, -1) return def _set_icon_ready(self): self._record.set_icon('media-record') self._record.show() return False def _set_icon_stop(self): self._record.set_icon('record-stop') self._record.show() return False def record_control_delayed(self, data=None): """Depending upon the selected interval, either starts/stops a logging session, or just logs the current buffer""" if not self.activity.LOGGING_IN_SESSION: Xscale = (1.00 / self.activity.audiograb.get_sampling_rate()) Yscale = 0.0 interval = self.interval_convert() username = self.activity.nick self.activity.ji.start_new_session(username, Xscale, Yscale, self.logginginterval_status) self.activity.audiograb.set_logging_params(True, interval, True) self.activity.LOGGING_IN_SESSION = True self._set_icon_stop() if interval == 0: # Flash the stop button when grabbing just one image gobject.timeout_add(250, self._set_icon_ready) self.record_state = False self.activity.LOGGING_IN_SESSION = False self.logging_status = False else: self.activity.audiograb.set_logging_params(False) self.activity.LOGGING_IN_SESSION = False self._set_icon_ready() self._set_record_button_tooltip() return False def record_control(self, data=None): self._record.palette.popdown() gtk.gdk.flush() gobject.timeout_add(10, self.record_control_delayed, data) def interval_convert(self): """Converts picture/time interval 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 1second= about 66 ticks at 48khz sampling""" if self.logginginterval_status == 'picture': return 0 elif self.logginginterval_status == '30second': return 30 #2667 elif self.logginginterval_status == '2minute': return 120 #10668 elif self.logginginterval_status == '10minute': return 600 #53340 elif self.logginginterval_status == '30minute': return 1800 #160000 def loginterval_control(self, combobox): """ The combo box has changed. Set the logging interval status correctly and then set the tooltip on the record button properly depending upon whether logging is currently in progress or not. """ if (self._loginterval_combo.get_active() != -1): if (self._loginterval_combo.get_active() == 0): self.logginginterval_status = 'picture' elif (self._loginterval_combo.get_active() == 1): self.logginginterval_status = '30second' elif (self._loginterval_combo.get_active() == 2): self.logginginterval_status = '2minute' elif (self._loginterval_combo.get_active() == 3): self.logginginterval_status = '10minute' elif (self._loginterval_combo.get_active() == 4): self.logginginterval_status = '30minute' self._set_record_button_tooltip() return def _set_record_button_tooltip(self): """ Determines the tool tip for the record button. The tool tip text depends upon whether sampling is currently on and whether the sampling interval > 0. """ if self._record == None: return if self.activity.LOGGING_IN_SESSION: self._record.set_tooltip(_('Stop sampling')) else: # No sampling in progress if (self._loginterval_combo.get_active() == 0): self._record.set_tooltip(_('Capture sample now')) else: self._record.set_tooltip(_('Start sampling')) return def update_trigger_control(self, *args): """ Callback for trigger control """ active = self._trigger_combo.get_active() if active == -1: return self.activity.wave.set_trigger(self.trigger_conf[active]) return def _pauseplay_control_cb(self, data=None): """ Callback for Pause Button """ if self.activity.audiograb.get_freeze_the_display(): self.activity.audiograb.set_freeze_the_display(False) self._pause.set_icon('media-playback-pause-insensitive') self._pause.set_tooltip(_('Unfreeze the display')) self._pause.show() else: self.activity.audiograb.set_freeze_the_display(True) self._pause.set_icon('media-playback-pause') self._pause.set_tooltip(_('Freeze the display')) self._pause.show() return False def _timefreq_control_cb(self, data=None, time_state=True): """ Callback for Time and Freq. Buttons """ # Make sure the current context is for sound capture. if self.activity.CONTEXT != 'sound': self.activity.set_sound_context() if time_state: self.activity.wave.set_fft_mode(False) self.time.set_icon('domain-time2') self.freq.set_icon('domain-freq') self.time.show() self.freq.show() self._update_string_for_textbox() if self.activity.has_toolbarbox: self.activity.label_button.set_icon('domain-time2') self.activity.label_button.set_tooltip(_('Time Base')) else: self.activity.wave.set_fft_mode(True) self.time.set_icon('domain-time') self.freq.set_icon('domain-freq2') self.time.show() self.freq.show() self._update_string_for_textbox() if self.activity.has_toolbarbox: self.activity.label_button.set_icon('domain-freq2') self.activity.label_button.set_tooltip(_('Frequency Base')) if self.activity.has_toolbarbox and \ hasattr(self.activity, 'sensor_toolbar'): self.activity.sensor_toolbar.resistance.set_icon('bias-on') self.activity.sensor_toolbar.voltage.set_icon('bias-off') return False def _freq_stepper_up_cb(self, data=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, data=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, data=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 context_off(self): """When some other context is switched to and the sound context is switched off""" print "context off: gain and y_mag were %f and %f" %\ (self.gain, self.y_mag) self.gain, self.y_mag = self.activity.wave.get_mag_params() print "context off: gain and y_mag are %f and %f" %\ (self.gain, self.y_mag) self.capture_gain = self.activity.audiograb.get_capture_gain() self.mic_boost = self.activity.audiograb.get_mic_boost() print "context off: capture gain %s and mic boost %s" %\ (str(self.capture_gain), str(self.mic_boost)) self.activity.audiograb.stop_sound_device() self.activity.wave.set_fft_mode(False) def context_on(self): """When the sound context is switched on""" self.activity.audiograb.start_sound_device() self.activity.audiograb.set_sensor_type('sound') self.activity.wave.set_fft_mode(False) print "context on: gain and y_mag are %f and %f" %\ (self.gain, self.y_mag) self.activity.wave.set_mag_params(self.gain, self.y_mag) self._update_string_for_textbox() self.update_trigger_control() return False def _update_string_for_textbox(self): """ Update the text at the bottom of the canvas """ if not self.activity.wave.get_fft_mode(): self._STR_SCALEX = self._STR_XAXIS_TEXT % \ {'unit': self._ms, 'division': self.activity.wave.time_div*1000} else: self._STR_SCALEX = self._STR_XAXIS_TEXT % \ {'unit': self._Hz, 'division': self.activity.wave.freq_div} self.string_for_textbox = "" self.string_for_textbox += (self._STR_BASIC + '\t') if not self.activity.wave.get_fft_mode(): self.string_for_textbox += self._STR1 else: self.string_for_textbox += self._STR2 if self.activity.wave.get_invert_state(): self.string_for_textbox += self._STR3 self.string_for_textbox += ('\n' + self._STR_SCALEX) self.activity.text_box.set_data_params(0, self.string_for_textbox)
def build_toolbar(self): # make a toolbox toolbox = activity.ActivityToolbox(self) # modify the Activity tab activity_toolbar = toolbox.get_activity_toolbar() activity_toolbar.share.props.visible = False self.activity_toolbar = activity_toolbar # make the toolbars toolbars = {} for b in tools.allButtons: if not toolbars.has_key(b.toolBar): toolbars[b.toolBar] = gtk.Toolbar() # make + add the buttons self.buttonList = {} for c in tools.allButtons: button = ToolButton(c.icon) button.set_tooltip(_(c.toolTip)) button.connect('clicked', self.buttonClicked) toolbars[c.toolBar].insert(button, -1) button.show() self.buttonList[button] = c.name # add the toolbars to the toolbox for bar in toolbars: toolbox.add_toolbar(bar, toolbars[bar]) toolbars[bar].show() # make the level chooser combo box lbl = gtk.Label("Load a level: ") lbl.show() cmb = ComboBox() cmb.connect('changed', self.levelChanged) files = os.listdir("levels") for i in files: if i[-6:] == ".level": f = open("levels/" + i) try: n = pickle.load(f)['name'] except: continue f.close() cmb.append_item("levels/" + i, n) cmb = ToolComboBox(cmb) lbl_ti = gtk.ToolItem() lbl_ti.add(lbl) toolbars['Run'].insert(lbl_ti, -1) lbl_ti.show() toolbars['Run'].insert(cmb, -1) cmb.show() button = ToolButton("load") button.set_tooltip(_("Load your own level")) button.connect('clicked', self.loadButtonClicked) toolbars['Run'].insert(button, -1) button.show() # add some level saving stuff to the save toolbar self.quantBox = ComboBox() self.quantBox.connect('changed', self.quantBoxChanged) self.quantBoxIndexes = {} for i in range(26): self.quantBox.append_item(i, str(i)) self.quantBoxIndexes[i] = i self.quantBox.append_item(float('inf'), "Infinity") self.quantBoxIndexes[float('inf')] = 26 cmb = ToolComboBox(self.quantBox) activity_toolbar.insert(cmb, 1) cmb.show() cmb = ComboBox() cmb.connect('changed', self.compQuantBoxChanged) for c in components.allComponents: if c.name != "X" and c.name != "O": cmb.append_item(c.name, c.name) cmb = ToolComboBox(cmb) activity_toolbar.insert(cmb, 1) cmb.show() lbl = gtk.Label(" Component amounts: ") lbl.show() ti = gtk.ToolItem() ti.add(lbl) activity_toolbar.insert(ti, 1) ti.show() toolbox.show() self.set_toolbox(toolbox) toolbox.set_current_toolbar(1) return activity_toolbar
class FormatToolbar(gtk.Toolbar): def __init__(self, toolbox, abiword_canvas, parent): gtk.Toolbar.__init__(self) self._toolbox = toolbox self._abiword_canvas = abiword_canvas self._parent = parent style_label = gtk.Label(_("Style: ")) style_label.show() tool_item_style_label = gtk.ToolItem() tool_item_style_label.add(style_label) self.insert(tool_item_style_label, -1) tool_item_style_label.show() self._has_custom_styles = False self._style_combo = ComboBox() self._styles = [['Heading 1', _('Heading 1')], ['Heading 2', _('Heading 2')], ['Heading 3', _('Heading 3')], ['Heading 4', _('Heading 4')], ['Bullet List', _('Bullet List')], ['Dashed List', _('Dashed List')], ['Numbered List', _('Numbered List')], ['Lower Case List', _('Lower Case List')], ['Upper Case List', _('Upper Case List')], ['Block Text', _('Block Text')], ['Normal', _('Normal')], ['Plain Text', _('Plain Text')]] self._style_changed_id = self._style_combo.connect( 'changed', self._style_changed_cb) for i, s in enumerate(self._styles): self._style_combo.append_item(i, s[1], None) if s[0] == 'Normal': self._style_combo.set_active(i) tool_item = ToolComboBox(self._style_combo) self.insert(tool_item, -1) tool_item.show() self._abiword_canvas.connect('style-name', self._style_cb) ####btn salir del barrido del menu item self._btn_barrido_menu = ToolButton() self._btn_barrido_menu.set_tooltip(_('Salir \nMenú')) self._btn_barrido_menu_id = self._btn_barrido_menu.connect( 'clicked', self._btn_barrido_menu_cb) self.insert(self._btn_barrido_menu, -1) self._btn_barrido_menu.set_no_show_all(True) #self._btn_barrido_menu.show() # en realidad mostrar solo si esta barriendo def _btn_barrido_menu_cb(self, button): if (self._parent.BOTONESxBARRIDO_MENU_ITEM): self._parent.BOTONESxBARRIDO_MENU = False self._parent.BOTONESxBARRIDO_MENU_ITEM = False self._parent.BOTONESxBARRIDO = False # si le doy True va a ejectuar el escribir porque llama al metodo del eventbox #self._parent.chk_activarBarrido_botones_menu.emit("clicked") self._parent.chk_activarBarrido_botones.set_active(True) ####fin btn salir del barrido del menu item def _style_cb(self, abi, style_name): style_index = -1 for i, s in enumerate(self._styles): if s[0] == style_name: style_index = i break # if we don't know this style yet, then add it (temporary) to the list if style_index == -1: logger.debug('Style not found in style list: %s', style_name) if not self._has_custom_styles: # add a separator to seperate the non-available styles from # the available ones self._styles.append(['', '']) # ugly self._style_combo.append_separator() self._has_custom_styles = True # add the new style self._styles.append([style_name, style_name]) self._style_combo.append_item(0, style_name, None) # see how many styles we have now, so we can select the last one model = self._style_combo.get_model() num_children = model.iter_n_children(None) logger.debug('Number of styles in the list: %d', num_children) style_index = num_children - 1 if style_index > -1: self._style_combo.handler_block(self._style_changed_id) self._style_combo.set_active(style_index) self._style_combo.handler_unblock(self._style_changed_id) def _style_changed_cb(self, combobox): if self._style_combo.get_active() != -1: logger.debug('Setting style name: %s', self._styles[self._style_combo.get_active()][0]) self._abiword_canvas.set_style( self._styles[self._style_combo.get_active()][0])
class SpeechToolbar(gtk.Toolbar): def __init__(self, activity): gtk.Toolbar.__init__(self) voicebar = gtk.Toolbar() self._activity = activity if not speech.supported: return self.load_speech_parameters() self.sorted_voices = [i for i in speech.voices()] self.sorted_voices.sort(self.compare_voices) default = 0 for voice in self.sorted_voices: if voice[0] == speech.voice[0]: break default = default + 1 # Play button self.play_btn = ToggleToolButton('media-playback-start') self.play_btn.show() self.play_btn.connect('toggled', self.play_cb) self.insert(self.play_btn, -1) self.play_btn.set_tooltip(_('Play / Pause')) self.voice_combo = ComboBox() for voice in self.sorted_voices: self.voice_combo.append_item(voice, voice[0]) self.voice_combo.set_active(default) self.voice_combo.connect('changed', self.voice_changed_cb) combotool = ToolComboBox(self.voice_combo) self.insert(combotool, -1) combotool.show() self.pitchadj = gtk.Adjustment(0, -100, 100, 1, 10, 0) pitchbar = gtk.HScale(self.pitchadj) pitchbar.set_draw_value(False) pitchbar.set_update_policy(gtk.UPDATE_DISCONTINUOUS) pitchbar.set_size_request(150, 15) self.pitchadj.set_value(speech.pitch) pitchtool = gtk.ToolItem() pitchtool.add(pitchbar) pitchtool.show() self.insert(pitchtool, -1) pitchbar.show() self.rateadj = gtk.Adjustment(0, -100, 100, 1, 10, 0) ratebar = gtk.HScale(self.rateadj) ratebar.set_draw_value(False) ratebar.set_update_policy(gtk.UPDATE_DISCONTINUOUS) ratebar.set_size_request(150, 15) self.rateadj.set_value(speech.rate) ratetool = gtk.ToolItem() ratetool.add(ratebar) ratetool.show() self.insert(ratetool, -1) ratebar.show() self.pitchadj.connect("value_changed", self.pitch_adjusted_cb) self.rateadj.connect("value_changed", self.rate_adjusted_cb) def compare_voices(self, a, b): if a[0].lower() == b[0].lower(): return 0 if a[0] .lower() < b[0].lower(): return -1 if a[0] .lower() > b[0].lower(): return 1 def voice_changed_cb(self, combo): speech.voice = combo.props.value speech.say(speech.voice[0]) self.save_speech_parameters() def pitch_adjusted_cb(self, get): speech.pitch = int(get.value) speech.say(_("pitch adjusted")) self.save_speech_parameters() def rate_adjusted_cb(self, get): speech.rate = int(get.value) speech.say(_("rate adjusted")) self.save_speech_parameters() def load_speech_parameters(self): speech_parameters = {} data_path = os.path.join(self._activity.get_activity_root(), 'data') data_file_name = os.path.join(data_path, 'speech_params.json') if os.path.exists(data_file_name): f = open(data_file_name, 'r') try: speech_parameters = simplejson.load(f) speech.pitch = speech_parameters['pitch'] speech.rate = speech_parameters['rate'] speech.voice = speech_parameters['voice'] finally: f.close() def save_speech_parameters(self): speech_parameters = {} speech_parameters['pitch'] = speech.pitch speech_parameters['rate'] = speech.rate speech_parameters['voice'] = speech.voice data_path = os.path.join(self._activity.get_activity_root(), 'data') data_file_name = os.path.join(data_path, 'speech_params.json') f = open(data_file_name, 'w') try: simplejson.dump(speech_parameters, f) finally: f.close() def play_cb(self, widget): if widget.get_active(): self.play_btn.set_named_icon('media-playback-pause') if speech.is_stopped(): speech.play(self._activity._view.get_marked_words()) else: self.play_btn.set_named_icon('media-playback-start') speech.stop()
class SearchToolbar(gtk.Toolbar): __gtype_name__ = 'SearchToolbar' __gsignals__ = { 'query-changed': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE, ([object])), } def __init__(self): gtk.Toolbar.__init__(self) self._mount_point = None self._search_entry = iconentry.IconEntry() self._search_entry.set_icon_from_name(iconentry.ICON_ENTRY_PRIMARY, 'system-search') self._search_entry.connect('activate', self._search_entry_activated_cb) self._search_entry.connect('changed', self._search_entry_changed_cb) self._search_entry.add_clear_button() self._autosearch_timer = None self._add_widget(self._search_entry, expand=True) self._favorite_button = ToggleToolButton('emblem-favorite') self._favorite_button.connect('toggled', self.__favorite_button_toggled_cb) self.insert(self._favorite_button, -1) self._favorite_button.show() self._what_search_combo = ComboBox() self._what_combo_changed_sid = self._what_search_combo.connect( 'changed', self._combo_changed_cb) tool_item = ToolComboBox(self._what_search_combo) self.insert(tool_item, -1) tool_item.show() self._when_search_combo = self._get_when_search_combo() tool_item = ToolComboBox(self._when_search_combo) self.insert(tool_item, -1) tool_item.show() self._sorting_button = SortingButton() self._sorting_button.connect('clicked', self.__sorting_button_clicked_cb) self.insert(self._sorting_button, -1) self._sorting_button.connect('sort-property-changed', self.__sort_changed_cb) self._sorting_button.show() # TODO: enable it when the DS supports saving the buddies. #self._with_search_combo = self._get_with_search_combo() #tool_item = ToolComboBox(self._with_search_combo) #self.insert(tool_item, -1) #tool_item.show() self._query = self._build_query() self.refresh_filters() def give_entry_focus(self): self._search_entry.grab_focus() def _get_when_search_combo(self): when_search = ComboBox() when_search.append_item(_ACTION_ANYTIME, _('Anytime')) when_search.append_separator() when_search.append_item(_ACTION_TODAY, _('Today')) when_search.append_item(_ACTION_SINCE_YESTERDAY, _('Since yesterday')) # TRANS: Filter entries modified during the last 7 days. when_search.append_item(_ACTION_PAST_WEEK, _('Past week')) # TRANS: Filter entries modified during the last 30 days. when_search.append_item(_ACTION_PAST_MONTH, _('Past month')) # TRANS: Filter entries modified during the last 356 days. when_search.append_item(_ACTION_PAST_YEAR, _('Past year')) when_search.set_active(0) when_search.connect('changed', self._combo_changed_cb) return when_search def _get_with_search_combo(self): with_search = ComboBox() with_search.append_item(_ACTION_EVERYBODY, _('Anyone')) with_search.append_separator() with_search.append_item(_ACTION_MY_FRIENDS, _('My friends')) with_search.append_item(_ACTION_MY_CLASS, _('My class')) with_search.append_separator() # TODO: Ask the model for buddies. with_search.append_item(3, 'Dan', 'theme:xo') with_search.set_active(0) with_search.connect('changed', self._combo_changed_cb) return with_search def _add_widget(self, widget, expand=False): tool_item = gtk.ToolItem() tool_item.set_expand(expand) tool_item.add(widget) widget.show() self.insert(tool_item, -1) tool_item.show() def _build_query(self): query = {} if self._mount_point: query['mountpoints'] = [self._mount_point] if self._favorite_button.props.active: query['keep'] = 1 if self._what_search_combo.props.value: value = self._what_search_combo.props.value generic_type = mime.get_generic_type(value) if generic_type: mime_types = generic_type.mime_types query['mime_type'] = mime_types else: query['activity'] = self._what_search_combo.props.value if self._when_search_combo.props.value: date_from, date_to = self._get_date_range() query['timestamp'] = {'start': date_from, 'end': date_to} if self._search_entry.props.text: text = self._search_entry.props.text.strip() if text: query['query'] = text property_, order = self._sorting_button.get_current_sort() if order == gtk.SORT_ASCENDING: sign = '+' else: sign = '-' query['order_by'] = [sign + property_] return query def _get_date_range(self): today_start = datetime.today().replace(hour=0, minute=0, second=0) right_now = datetime.today() if self._when_search_combo.props.value == _ACTION_TODAY: date_range = (today_start, right_now) elif self._when_search_combo.props.value == _ACTION_SINCE_YESTERDAY: date_range = (today_start - timedelta(1), right_now) elif self._when_search_combo.props.value == _ACTION_PAST_WEEK: date_range = (today_start - timedelta(7), right_now) elif self._when_search_combo.props.value == _ACTION_PAST_MONTH: date_range = (today_start - timedelta(30), right_now) elif self._when_search_combo.props.value == _ACTION_PAST_YEAR: date_range = (today_start - timedelta(356), right_now) return (time.mktime(date_range[0].timetuple()), time.mktime(date_range[1].timetuple())) def _combo_changed_cb(self, combo): self._update_if_needed() def __sort_changed_cb(self, button): self._update_if_needed() def __sorting_button_clicked_cb(self, button): self._sorting_button.palette.popup(immediate=True, state=1) def _update_if_needed(self): new_query = self._build_query() if self._query != new_query: self._query = new_query self.emit('query-changed', self._query) def _search_entry_activated_cb(self, search_entry): if self._autosearch_timer: gobject.source_remove(self._autosearch_timer) new_query = self._build_query() if self._query != new_query: self._query = new_query self.emit('query-changed', self._query) def _search_entry_changed_cb(self, search_entry): if not search_entry.props.text: search_entry.activate() return if self._autosearch_timer: gobject.source_remove(self._autosearch_timer) self._autosearch_timer = gobject.timeout_add(_AUTOSEARCH_TIMEOUT, self._autosearch_timer_cb) def _autosearch_timer_cb(self): logging.debug('_autosearch_timer_cb') self._autosearch_timer = None self._search_entry.activate() return False def set_mount_point(self, mount_point): self._mount_point = mount_point new_query = self._build_query() if self._query != new_query: self._query = new_query self.emit('query-changed', self._query) def set_what_filter(self, what_filter): combo_model = self._what_search_combo.get_model() what_filter_index = -1 for i in range(0, len(combo_model) - 1): if combo_model[i][0] == what_filter: what_filter_index = i break if what_filter_index == -1: logging.warning('what_filter %r not known', what_filter) else: self._what_search_combo.set_active(what_filter_index) def refresh_filters(self): current_value = self._what_search_combo.props.value current_value_index = 0 self._what_search_combo.handler_block(self._what_combo_changed_sid) try: self._what_search_combo.remove_all() # TRANS: Item in a combo box that filters by entry type. self._what_search_combo.append_item(_ACTION_ANYTHING, _('Anything')) registry = bundleregistry.get_registry() appended_separator = False types = mime.get_all_generic_types() for generic_type in types: if not appended_separator: self._what_search_combo.append_separator() appended_separator = True self._what_search_combo.append_item(generic_type.type_id, generic_type.name, generic_type.icon) if generic_type.type_id == current_value: current_value_index = \ len(self._what_search_combo.get_model()) - 1 self._what_search_combo.set_active(current_value_index) self._what_search_combo.append_separator() for service_name in model.get_unique_values('activity'): activity_info = registry.get_bundle(service_name) if activity_info is None: continue if service_name == current_value: combo_model = self._what_search_combo.get_model() current_value_index = len(combo_model) # try activity-provided icon if os.path.exists(activity_info.get_icon()): try: self._what_search_combo.append_item( service_name, activity_info.get_name(), file_name=activity_info.get_icon()) except glib.GError, exception: logging.warning( 'Falling back to default icon for' ' "what" filter because %r (%r) has an' ' invalid icon: %s', activity_info.get_name(), str(service_name), exception) else: continue # fall back to generic icon self._what_search_combo.append_item( service_name, activity_info.get_name(), icon_name='application-octet-stream') finally: self._what_search_combo.handler_unblock( self._what_combo_changed_sid) def __favorite_button_toggled_cb(self, favorite_button): self._update_if_needed() def clear_query(self): self._search_entry.props.text = '' self._what_search_combo.set_active(0) self._when_search_combo.set_active(0) self._favorite_button.props.active = False
class SearchToolbar(gtk.Toolbar): __gtype_name__ = 'SearchToolbar' __gsignals__ = { 'query-changed': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE, ([object])), } def __init__(self): gtk.Toolbar.__init__(self) self._mount_point = None self._search_entry = iconentry.IconEntry() self._search_entry.set_icon_from_name(iconentry.ICON_ENTRY_PRIMARY, 'system-search') self._search_entry.connect('activate', self._search_entry_activated_cb) self._search_entry.connect('changed', self._search_entry_changed_cb) self._search_entry.add_clear_button() self._autosearch_timer = None self._add_widget(self._search_entry, expand=True) self._favorite_button = ToggleToolButton('emblem-favorite') self._favorite_button.connect('toggled', self.__favorite_button_toggled_cb) self.insert(self._favorite_button, -1) self._favorite_button.show() self._what_search_combo = ComboBox() self._what_combo_changed_sid = self._what_search_combo.connect( 'changed', self._combo_changed_cb) tool_item = ToolComboBox(self._what_search_combo) self.insert(tool_item, -1) tool_item.show() self._when_search_combo = self._get_when_search_combo() tool_item = ToolComboBox(self._when_search_combo) self.insert(tool_item, -1) tool_item.show() self._sorting_button = SortingButton() self._sorting_button.connect('clicked', self.__sorting_button_clicked_cb) self.insert(self._sorting_button, -1) self._sorting_button.connect('sort-property-changed', self.__sort_changed_cb) self._sorting_button.show() # TODO: enable it when the DS supports saving the buddies. #self._with_search_combo = self._get_with_search_combo() #tool_item = ToolComboBox(self._with_search_combo) #self.insert(tool_item, -1) #tool_item.show() self._query = self._build_query() self.refresh_filters() def give_entry_focus(self): self._search_entry.grab_focus() def _get_when_search_combo(self): when_search = ComboBox() when_search.append_item(_ACTION_ANYTIME, _('Anytime')) when_search.append_separator() when_search.append_item(_ACTION_TODAY, _('Today')) when_search.append_item(_ACTION_SINCE_YESTERDAY, _('Since yesterday')) # TRANS: Filter entries modified during the last 7 days. when_search.append_item(_ACTION_PAST_WEEK, _('Past week')) # TRANS: Filter entries modified during the last 30 days. when_search.append_item(_ACTION_PAST_MONTH, _('Past month')) # TRANS: Filter entries modified during the last 356 days. when_search.append_item(_ACTION_PAST_YEAR, _('Past year')) when_search.set_active(0) when_search.connect('changed', self._combo_changed_cb) return when_search def _get_with_search_combo(self): with_search = ComboBox() with_search.append_item(_ACTION_EVERYBODY, _('Anyone')) with_search.append_separator() with_search.append_item(_ACTION_MY_FRIENDS, _('My friends')) with_search.append_item(_ACTION_MY_CLASS, _('My class')) with_search.append_separator() # TODO: Ask the model for buddies. with_search.append_item(3, 'Dan', 'theme:xo') with_search.set_active(0) with_search.connect('changed', self._combo_changed_cb) return with_search def _add_widget(self, widget, expand=False): tool_item = gtk.ToolItem() tool_item.set_expand(expand) tool_item.add(widget) widget.show() self.insert(tool_item, -1) tool_item.show() def _build_query(self): query = {} if self._mount_point: query['mountpoints'] = [self._mount_point] if self._favorite_button.props.active: query['keep'] = 1 if self._what_search_combo.props.value: value = self._what_search_combo.props.value generic_type = mime.get_generic_type(value) if generic_type: mime_types = generic_type.mime_types query['mime_type'] = mime_types else: query['activity'] = self._what_search_combo.props.value if self._when_search_combo.props.value: date_from, date_to = self._get_date_range() query['timestamp'] = {'start': date_from, 'end': date_to} if self._search_entry.props.text: text = self._search_entry.props.text.strip() if text: query['query'] = text property_, order = self._sorting_button.get_current_sort() if order == gtk.SORT_ASCENDING: sign = '+' else: sign = '-' query['order_by'] = [sign + property_] return query def _get_date_range(self): today_start = datetime.today().replace(hour=0, minute=0, second=0) right_now = datetime.today() if self._when_search_combo.props.value == _ACTION_TODAY: date_range = (today_start, right_now) elif self._when_search_combo.props.value == _ACTION_SINCE_YESTERDAY: date_range = (today_start - timedelta(1), right_now) elif self._when_search_combo.props.value == _ACTION_PAST_WEEK: date_range = (today_start - timedelta(7), right_now) elif self._when_search_combo.props.value == _ACTION_PAST_MONTH: date_range = (today_start - timedelta(30), right_now) elif self._when_search_combo.props.value == _ACTION_PAST_YEAR: date_range = (today_start - timedelta(356), right_now) return (time.mktime(date_range[0].timetuple()), time.mktime(date_range[1].timetuple())) def _combo_changed_cb(self, combo): self._update_if_needed() def __sort_changed_cb(self, button): self._update_if_needed() def __sorting_button_clicked_cb(self, button): self._sorting_button.palette.popup(immediate=True, state=1) def _update_if_needed(self): new_query = self._build_query() if self._query != new_query: self._query = new_query self.emit('query-changed', self._query) def _search_entry_activated_cb(self, search_entry): if self._autosearch_timer: gobject.source_remove(self._autosearch_timer) new_query = self._build_query() if self._query != new_query: self._query = new_query self.emit('query-changed', self._query) def _search_entry_changed_cb(self, search_entry): if not search_entry.props.text: search_entry.activate() return if self._autosearch_timer: gobject.source_remove(self._autosearch_timer) self._autosearch_timer = gobject.timeout_add(_AUTOSEARCH_TIMEOUT, self._autosearch_timer_cb) def _autosearch_timer_cb(self): logging.debug('_autosearch_timer_cb') self._autosearch_timer = None self._search_entry.activate() return False def set_mount_point(self, mount_point): self._mount_point = mount_point new_query = self._build_query() if self._query != new_query: self._query = new_query self.emit('query-changed', self._query) def set_what_filter(self, what_filter): combo_model = self._what_search_combo.get_model() what_filter_index = -1 for i in range(0, len(combo_model) - 1): if combo_model[i][0] == what_filter: what_filter_index = i break if what_filter_index == -1: logging.warning('what_filter %r not known', what_filter) else: self._what_search_combo.set_active(what_filter_index) def refresh_filters(self): current_value = self._what_search_combo.props.value current_value_index = 0 self._what_search_combo.handler_block(self._what_combo_changed_sid) try: self._what_search_combo.remove_all() # TRANS: Item in a combo box that filters by entry type. self._what_search_combo.append_item(_ACTION_ANYTHING, _('Anything')) registry = bundleregistry.get_registry() appended_separator = False types = mime.get_all_generic_types() for generic_type in types: if not appended_separator: self._what_search_combo.append_separator() appended_separator = True self._what_search_combo.append_item( generic_type.type_id, generic_type.name, generic_type.icon) if generic_type.type_id == current_value: current_value_index = \ len(self._what_search_combo.get_model()) - 1 self._what_search_combo.set_active(current_value_index) self._what_search_combo.append_separator() for service_name in model.get_unique_values('activity'): activity_info = registry.get_bundle(service_name) if activity_info is None: continue if service_name == current_value: combo_model = self._what_search_combo.get_model() current_value_index = len(combo_model) # try activity-provided icon if os.path.exists(activity_info.get_icon()): try: self._what_search_combo.append_item(service_name, activity_info.get_name(), file_name=activity_info.get_icon()) except glib.GError, exception: logging.warning('Falling back to default icon for' ' "what" filter because %r (%r) has an' ' invalid icon: %s', activity_info.get_name(), str(service_name), exception) else: continue # fall back to generic icon self._what_search_combo.append_item(service_name, activity_info.get_name(), icon_name='application-octet-stream') finally: self._what_search_combo.handler_unblock( self._what_combo_changed_sid) def __favorite_button_toggled_cb(self, favorite_button): self._update_if_needed() def clear_query(self): self._search_entry.props.text = '' self._what_search_combo.set_active(0) self._when_search_combo.set_active(0) self._favorite_button.props.active = False
class FontToolbarButton(ToolbarButton): __gsignals__ = { 'load-pango-context': (gobject.SIGNAL_RUN_LAST, gobject.TYPE_PYOBJECT, tuple()), 'font-changed': (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE, (gobject.TYPE_STRING, gobject.TYPE_STRING, gobject.TYPE_INT)) } def __init__(self): ToolbarButton.__init__(self) self.toolbar = gtk.Toolbar() self.props.page = self.toolbar self.props.icon_name = 'format-text' self.family = "Monospace" self.current_face = "Regular" def size_changed(self, adjustment): self.emit("font-changed", self.family, self.current_face, adjustment.get_value()) def face_changed(self, widget): iter = widget.get_active_iter() self.current_face = self.faces[self.family].get_value(iter, 0) self.emit('font-changed', self.family, self.current_face, self.size_adj.get_value()) def family_changed(self, widget): iter = widget.get_active_iter() self.family = self.family_model.get_value(iter, 0) self.face_combo.set_model(self.faces[self.family]) self.face_combo.set_active(0) def load_toolbar(self): self.context = self.emit("load-pango-context") self.family_combo = ComboBox() family_renderer = gtk.CellRendererText() family_renderer.set_property("family-set", True) self.family_combo.pack_start(family_renderer) self.family_combo.add_attribute(family_renderer, 'text', 0) self.family_combo.add_attribute(family_renderer, 'family', 0) self.family_model = gtk.ListStore(str) monospace_index = 0 count = 0 self.faces = {} for i in self.context.list_families(): name = i.get_name() monospace_index = count if name == "Monospace" else 0 count += 1 self.family_model.append([name]) family_faces = gtk.ListStore(str, str) for face in i.list_faces(): face_name = face.get_face_name() family_faces.append([face_name, "%s %s" % (name, face_name)]) self.faces[name] = family_faces self.family_combo.set_model(self.family_model) self.family_combo.set_active(monospace_index) self.family_combo.connect("changed", self.family_changed) self.family_combo.show() self.family_tool_item = ToolComboBox(self.family_combo) self.family_tool_item.show() self.toolbar.insert(self.family_tool_item, -1) self.face_combo = ComboBox() face_renderer = gtk.CellRendererText() face_renderer.set_property("family-set", True) self.face_combo.pack_start(face_renderer) self.face_combo.add_attribute(face_renderer, 'text', 0) self.face_combo.add_attribute(face_renderer, 'font', 1) current_model = self.faces["Monospace"] self.face_combo.set_model(current_model) self.face_combo.set_active(0) self.face_combo.connect("changed", self.face_changed) self.face_combo.show() self.face_tool_item = ToolComboBox(self.face_combo) self.face_tool_item.show() self.toolbar.insert(self.face_tool_item, -1) self.size_adj = gtk.Adjustment(value=10, lower=5, upper=100, step_incr=1) self.size_adj.connect("value-changed", self.size_changed) self.size_spin = gtk.SpinButton(self.size_adj) self.size_spin.show() self.size_spin_item = gtk.ToolItem() self.size_spin_item.add(self.size_spin) self.size_spin_item.show() self.toolbar.insert(self.size_spin_item, -1) self.toolbar.show()
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 # Set up Instrument Combo box self.instrument_combo = ComboBox() self.instrument = [_('None')] for k in INSTRUMENT_DICT.keys(): self.instrument.append(k) self._instrument_changed_id = self.instrument_combo.connect( 'changed', self.update_instrument_control) for i, instrument in enumerate(self.instrument): self.instrument_combo.append_item(i, instrument, None) self.instrument_combo.set_active(0) if hasattr(self.instrument_combo, 'set_tooltip_text'): self.instrument_combo.set_tooltip_text(_('Tune an instrument.')) self._instrument_tool = ToolComboBox(self.instrument_combo) self.insert(self._instrument_tool, -1) if self.activity.has_toolbarbox: separator = gtk.SeparatorToolItem() separator.props.draw = True self.insert(separator, -1) self._notes_combo = ComboBox() n = 0 for octave in range(9): for i in range(len(NOTES)): if octave == 0 and i < 9: # Start with A0 continue self._notes_combo.append_item(n, note_octave(i, octave), None) n += 1 self._notes_combo.set_active(48) # A4 self._notes_changed_id = self._notes_combo.connect( 'changed', self.update_note) if hasattr(self._notes_combo, 'set_tooltip_text'): self._notes_combo.set_tooltip_text(_('Notes')) self._notes_tool = ToolComboBox(self._notes_combo) self.insert(self._notes_tool, -1) # 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) if self.activity.has_toolbarbox: 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) if self.activity.has_toolbarbox: 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) if self.activity.has_toolbarbox: 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, *args): ''' Calculate the frequency based on note combo ''' if not hasattr(self, '_freq_entry'): # Still setting up toolbar return i = self._notes_combo.get_active() 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(), note_octave(index_to_note(i), index_to_octave(i)))) if self._show_tuning_line: self.activity.wave.tuning_line = freq return def update_tuning_control(self, *args): ''' Update note ''' if not hasattr(self, '_freq_entry'): # Still setting up toolbar? return instrument = self.instrument[self.instrument_combo.get_active()] if not instrument in INSTRUMENT_DICT: return if self.tuning[self._tuning_combo.get_active()] == _('All notes'): self._notes_combo.set_active( freq_index(INSTRUMENT_DICT[instrument][0])) 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][self._tuning_combo.get_active() - 1] # All notes is 0 self._notes_combo.set_active( freq_index(INSTRUMENT_DICT[instrument][ self._tuning_combo.get_active() - 1])) 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 update_freq_entry(self, *args): # Calcualte 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 update_instrument_control(self, *args): ''' Callback for instrument control ''' instrument = self.instrument[self.instrument_combo.get_active()] if self._tuning_tool is not None: self.remove(self._tuning_tool) if instrument == _('None'): self.activity.wave.instrument = None if hasattr(self, '_notes_tool'): self.insert(self._notes_tool, 2) return self.remove(self._notes_tool) 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 Combo box for this instrument self._tuning_combo = ComboBox() self.tuning = [_('All notes')] for f in INSTRUMENT_DICT[instrument]: self.tuning.append(freq_note(f)) self._tuning_changed_id = self._tuning_combo.connect( 'changed', self.update_tuning_control) for i, s in enumerate(self.tuning): self._tuning_combo.append_item(i, s, None) self._tuning_combo.set_active(0) if hasattr(self._tuning_combo, 'set_tooltip_text'): self._tuning_combo.set_tooltip_text(instrument) self._tuning_tool = ToolComboBox(self._tuning_combo) self.insert(self._tuning_tool, 1) self._tuning_combo.show() self._tuning_tool.show() self.show_all() 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 ''' freq = float(self._freq_entry.get_text()) 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) 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 ''' if hasattr(subprocess, 'check_output'): try: output = subprocess.check_output([ 'speaker-test', '-t', 'sine', '-l', '1', '-f', '%f' % (freq) ]) except subprocess.CalledProcessError: log.warning('call to speaker-test failed?') else: import commands (status, output) = commands.getstatusoutput( 'speaker-test -t sine -l 1 -f %f' % (freq)) if status != 0: log.warning('call to speaker-test failed?') 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)
class BeatToolbar(gtk.Toolbar): def __init__(self, owner): gtk.Toolbar.__init__(self) self.owner = owner self.toolItem = {} self.blockBeat = False self.beatWheel = [] btn = RadioToolButton(group=None) btn.set_named_icon('beats') btn.connect('toggled', self.setBeat, 0) btn.set_tooltip(_('Jump To Beat')) self.insert(btn, -1) self.beatWheel.append(btn) for i in range(1, 12): btn = RadioToolButton(group=self.beatWheel[0]) btn.set_named_icon('beats') btn.connect('toggled', self.setBeat, i) btn.set_tooltip(_('Jump To Beat')) self.insert(btn, -1) self.beatWheel.append(btn) label = gtk.Label(_("Synch to:")) self.syncLabel = gtk.ToolItem() self.syncLabel.add(label) self.insert(self.syncLabel, 0) self.comboBox = ComboBox() self.comboBox.append_item(1, _("1 Beat")) self.comboBox.append_item(2, _("2 Beats")) self.comboBox.append_item(3, _("3 Beats")) self.comboBox.append_item(4, _("4 Beats")) self.comboBox.append_item(5, _("5 Beats")) self.comboBox.append_item(6, _("6 Beats")) self.comboBox.append_item(7, _("7 Beats")) self.comboBox.append_item(8, _("8 Beats")) self.comboBox.append_item(9, _("9 Beats")) self.comboBox.append_item(10, _("10 Beats")) self.comboBox.append_item(11, _("11 Beats")) self.comboBox.append_item(12, _("12 Beats")) self.comboBox.set_active(4 - 1) # default 4 beats self.comboBox.connect("changed", self.changeSync) self.syncBox = ToolComboBox(self.comboBox) self.insert(self.syncBox, 1) self.show_all() #def _add_palette(self, widget, palette, position = Palette.DEFAULT): def _add_palette(self, widget, palette): widget._palette = palette widget._palette.props.invoker = WidgetInvoker(widget) #widget._palette.set_property("position", position) def _add_tooltip(self, widget, tooltip): #self._add_palette(widget, Palette(tooltip), Palette.DEFAULT) self._add_palette(widget, Palette(tooltip)) def _insert_widget(self, widget, pos): self.toolItem[widget] = gtk.ToolItem() self.toolItem[widget].add(widget) self.insert(self.toolItem[widget], pos) def _insert_separator(self, expand=False): separator = gtk.SeparatorToolItem() separator.set_draw(False) separator.set_expand(expand) self.insert(separator, -1) def setBeat(self, widget, beat): if not self.blockBeat and widget.get_active(): self.owner._setBeat(beat) def updateBeatWheel(self, beat): self.blockBeat = True self.beatWheel[beat].set_active(True) self.blockBeat = False def setSyncBeats(self, beats): self.comboBox.set_active(beats - 1) def changeSync(self, widget): beats = widget.get_active() + 1 for i in range(beats): self.beatWheel[i].show() for i in range(beats, 12): self.beatWheel[i].hide() self.owner._setSyncBeats(beats)
class SensorToolbar(gtk.Toolbar): """ The toolbar for resitance and voltage sensors """ __gsignals__ = { 'add-media': (gobject.SIGNAL_RUN_FIRST, None, [object]), 'add-opened': (gobject.SIGNAL_RUN_FIRST, None, [object]) } def __init__(self, activity): """ By default, start with resistance mode """ gtk.Toolbar.__init__(self) self.mode = 'resistance' self._STR_BASIC = \ _("Sensors, DC (connect sensor to pink 'Mic In' on left side of XO)") \ + ' ' self._STR_R = _('Bias/Offset Enabled') + ' ' + _('Ohms') + ' ' self._STR_V = _('Bias/Offset Disabled') + ' ' + _('Volts') + ' ' self._STR_I = ' ' + _('Invert') + ' ' self.string_for_textbox = "" self.activity = activity self.activity.audiograb.set_sensor(self) # Set up Resistance Button if self.activity.has_toolbarbox: self.resistance = ToolButton('bias-on') else: self.resistance = ToolButton('bias-on2') self.insert(self.resistance, -1) self.resistance.show() self.resistance.set_tooltip(_('Resistance Sensor')) self.resistance.connect('clicked', self.set_resistance_voltage_mode, 'resistance') # Set up Voltage Button self.voltage = ToolButton('bias-off') self.insert(self.voltage, -1) self.voltage.set_tooltip(_('Voltage Sensor')) self.voltage.connect('clicked', self.set_resistance_voltage_mode, 'voltage') # Set up Invert Button self._invert = ToolButton('invert') self.insert(self._invert, -1) self._invert.set_tooltip(_('Invert')) self._invert.connect('clicked', self._invert_control_cb) self.activity.wave.set_invert_state(False) separator = gtk.SeparatorToolItem() separator.props.draw = True self.insert(separator, -1) self.audiobutton = ToolButton('add-icon') self.insert(self.audiobutton, -1) self.audiobutton.show() self.audiobutton.set_tooltip('Close Sound') self.audiobutton.connect('clicked', self.addAudio) self.connect('add-media', self.addThisAudio) self.insert(separator, -1) self.insert(separator, -1) self.openedbutton = ToolButton('delete-icon') self.insert(self.openedbutton, -1) self.openedbutton.show() self.openedbutton.set_tooltip('Open Sound') self.openedbutton.connect('clicked', self.addOpenedAudio) self.connect('add-opened', self.addThisOpenedAudio) self.insert(separator, -1) self.insert(separator, -1) # Set up Logging Interval combo box self.loginterval_img = gtk.Image() self.loginterval_img.set_from_file(ICONS_DIR + '/sample_rate.svg') self.loginterval_img_tool = gtk.ToolItem() self.loginterval_img_tool.add(self.loginterval_img) self.insert(self.loginterval_img_tool, -1) self._loginterval_combo = ComboBox() self.interval = [ _('1/10 second'), _('1 second'), _('30 seconds'), _('5 minutes'), _('30 minutes') ] if hasattr(self._loginterval_combo, 'set_tooltip_text'): self._loginterval_combo.set_tooltip_text(_('Sampling interval')) self._interval_changed_id = self._loginterval_combo.connect( "changed", self.loginterval_control) for i, s in enumerate(self.interval): self._loginterval_combo.append_item(i, s, None) if s == _('1 second'): self._loginterval_combo.set_active(i) self._loginterval_tool = ToolComboBox(self._loginterval_combo) self.insert(self._loginterval_tool, -1) self.logginginterval_status = '1 second' # 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) self.show_all() def addAudio(self, button): #self.activity.showFileLoadBlocker(True) fp = FilePicker() dOb = fp.show() if (dOb != None): if (dOb.file_path != None): self.emit('add-media', dOb) #self.activity.showFileLoadBlocker(False) def addOpenedAudio(self, button): fp = FilePicker() dOb = fp.show() if (dOb != None): if (dOb.file_path != None): self.emit('add-opened', dOb) def addThisAudio(self, ot, datastoreOb): self.activity.closedSound = datastoreOb #self.activity.playsound.setLocation("file://"+datastoreOb.file_path) #self.activity.playsound.play() def addThisOpenedAudio(self, ot, datastoreOb): self.activity.openedSound = datastoreOb def set_sample_value(self, label=None): """ Write a sample value to the textbox """ gtk.threads_enter() self._update_string_for_textbox(label) gtk.threads_leave() return def record_control(self, data=None): """Depending upon the selected interval, does either a logging session, or just logs the current buffer""" if not self.activity.LOGGING_IN_SESSION: Xscale = (1.00 / self.activity.audiograb.get_sampling_rate()) Yscale = 0.0 interval = self.interval_convert() username = self.activity.nick print "calling start new session" self.activity.ji.start_new_session(username, Xscale, Yscale, _(self.logginginterval_status)) self.activity.audiograb.set_logging_params(True, interval, False) self.activity.LOGGING_IN_SESSION = True self._record.set_icon('record-stop') self._record.show() self._record.set_tooltip(_('Stop Recording')) else: self.activity.audiograb.set_logging_params(False) self.activity.LOGGING_IN_SESSION = False self._record.set_icon('media-record') self._record.show() self._record.set_tooltip(_('Start Recording')) 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.logginginterval_status] except ValueError: logging.error('logging interval status = %s' %\ (str(self.logginginterval_status))) return 0 def loginterval_control(self, combobox): """ Callback from the Logging Interval Combo box: sets status """ if self._loginterval_combo.get_active() != -1: intervals = [ '1/10 second', '1 second', '30 seconds', '5 minutes', '30 minutes' ] self.logginginterval_status = \ intervals[self._loginterval_combo.get_active()] def set_resistance_voltage_mode(self, data=None, mode_to_set='resistance'): """ Callback for Resistance/Voltage Buttons """ # Make sure the current context is for sensor capture. if self.activity.CONTEXT != 'sensor': self.activity.set_sensor_context() self.set_mode(mode_to_set) if mode_to_set == 'resistance': self.resistance.set_icon('bias-on2') self.voltage.set_icon('bias-off') self.resistance.show() self.voltage.show() self._update_string_for_textbox() if self.activity.has_toolbarbox: self.activity.label_button.set_icon('bias-on2') self.activity.label_button.set_tooltip(_('Resistance Sensor')) elif mode_to_set == 'voltage': self.resistance.set_icon('bias-on') self.voltage.set_icon('bias-off2') self.resistance.show() self.voltage.show() self._update_string_for_textbox() if self.activity.has_toolbarbox: self.activity.label_button.set_icon('bias-off2') self.activity.label_button.set_tooltip(_('Voltage Sensor')) else: logging.error('unknown mode %s' % (mode_to_set)) if self.activity.has_toolbarbox: self.activity.sound_toolbar.time.set_icon('domain-time') self.activity.sound_toolbar.freq.set_icon('domain-freq') return False def _invert_control_cb(self, data=None): """ Callback for Invert Button """ if self.activity.wave.get_invert_state(): self.activity.wave.set_invert_state(False) self._invert.set_icon('invert') self._invert.show() else: self.activity.wave.set_invert_state(True) self._invert.set_icon('invert2') self._invert.show() self._update_string_for_textbox() return False def set_mode(self, mode='resistance'): """ Set the mixer settings to match the current mode. """ self.mode = mode self.activity.audiograb.set_sensor_type(self.mode) return def context_off(self): """ Called when sensor toolbar is no longer selected. """ self.activity.audiograb.pause_grabbing() def context_on(self): """ Called when sensor toolbar is selected. """ self.activity.audiograb.resume_grabbing() self.activity.audiograb.set_sensor_type(self.mode) self._update_string_for_textbox() self.activity.wave.set_trigger(self.activity.wave.TRIGGER_NONE) return False def _update_string_for_textbox(self, value=None): """ Update the status field at the bottom of the canvas. """ self.string_for_textbox = "" self.string_for_textbox += (self._STR_BASIC + "\n") if self.mode == 'resistance': self.string_for_textbox += self._STR_R else: self.string_for_textbox += self._STR_V if self.activity.wave.get_invert_state(): self.string_for_textbox += self._STR_I if value is not None: self.string_for_textbox += '\t(%s)' % (str(value)) self.activity.text_box.set_data_params(0, self.string_for_textbox)
def create_dialog(self): """Setup most of the dialog.""" # Toolbar try: self._toolbar_box = ToolbarBox() activity_button = ActivityToolbarButton(self._parent) self._toolbar_box.toolbar.insert(activity_button, 0) def append(icon_name, label, page, position): toolbar_button = ToolbarButton() toolbar_button.props.page = page toolbar_button.props.icon_name = icon_name toolbar_button.props.label = label self._toolbar_box.toolbar.insert(toolbar_button, position) append('toolbar-edit', _('Edit'), EditToolbar(self._parent), -1) append('toolbar-algebra', _('Algebra'), AlgebraToolbar(self._parent), -1) append('toolbar-trigonometry', _('Trigonometry'), TrigonometryToolbar(self._parent), -1) append('toolbar-boolean', _('Boolean'), BooleanToolbar(self._parent), -1) self._misc_toolbar = MiscToolbar( self._parent, target_toolbar=self._toolbar_box.toolbar) append('toolbar-constants', _('Miscellaneous'), self._misc_toolbar, 5) self._stop_separator = gtk.SeparatorToolItem() self._stop_separator.props.draw = False self._stop_separator.set_expand(True) self._stop_separator.show() self._toolbar_box.toolbar.insert(self._stop_separator, -1) self._stop = StopButton(self._parent) self._toolbar_box.toolbar.insert(self._stop, -1) self._toolbar_box.show_all() self._parent.set_toolbar_box(self._toolbar_box) except NameError: # Use old toolbar design toolbox = activity.ActivityToolbox(self._parent) self._parent.set_toolbox(toolbox) toolbox.add_toolbar(_('Edit'), EditToolbar(self._parent)) toolbox.add_toolbar(_('Algebra'), AlgebraToolbar(self._parent)) toolbox.add_toolbar(_('Trigonometry'), TrigonometryToolbar(self._parent)) toolbox.add_toolbar(_('Boolean'), BooleanToolbar(self._parent)) toolbox.add_toolbar(_('Miscellaneous'), MiscToolbar(self._parent)) toolbox.show_all() # Some layout constants self.input_font = pango.FontDescription(str='sans bold 12') self.button_font = pango.FontDescription(str='sans bold 16') self.col_white = self.create_color(1.00, 1.00, 1.00) self.col_gray1 = self.create_color(0.76, 0.76, 0.76) self.col_gray2 = self.create_color(0.50, 0.50, 0.50) self.col_gray3 = self.create_color(0.25, 0.25, 0.25) self.col_black = self.create_color(0.00, 0.00, 0.00) self.col_red = self.create_color(1.00, 0.00, 0.00) # Big - Table, 16 rows, 10 columns, homogeneously divided self.grid = gtk.Table(26, 11, True) self.grid.set_border_width(0) self.grid.set_row_spacings(0) self.grid.set_col_spacings(4) # Left part: container and input vc1 = gtk.VBox(False, 0) hc1 = gtk.HBox(False, 10) eb = gtk.EventBox() eb.add(hc1) eb.modify_bg(gtk.STATE_NORMAL, self.col_black) eb.set_border_width(12) eb2 = gtk.EventBox() eb2.add(eb) eb2.modify_bg(gtk.STATE_NORMAL, self.col_black) label1 = gtk.Label(_('Label:')) label1.modify_fg(gtk.STATE_NORMAL, self.col_white) label1.set_alignment(1, 0.5) hc1.pack_start(label1, expand=False, fill=False, padding=10) self.label_entry = gtk.Entry() self.label_entry.modify_bg(gtk.STATE_INSENSITIVE, self.col_black) hc1.pack_start(self.label_entry, expand=True, fill=True, padding=0) vc1.pack_start(eb2, expand=False) self.text_entry = gtk.Entry() try: self.text_entry.props.im_module = 'gtk-im-context-simple' except AttributeError: pass self.text_entry.set_size_request(-1, 75) self.text_entry.connect('key_press_event', self._parent.ignore_key_cb) self.text_entry.modify_font(self.input_font) self.text_entry.modify_bg(gtk.STATE_INSENSITIVE, self.col_black) eb = gtk.EventBox() eb.add(self.text_entry) eb.modify_bg(gtk.STATE_NORMAL, self.col_black) eb.set_border_width(12) eb2 = gtk.EventBox() eb2.add(eb) eb2.modify_bg(gtk.STATE_NORMAL, self.col_black) vc1.pack_start(eb2, expand=True, fill=True, padding=0) self.grid.attach(vc1, 0, 7, 0, 6) # Left part: buttons self.pad = gtk.Table(9, 6, True) self.pad.set_row_spacings(12) self.pad.set_col_spacings(12) self.pad.set_border_width(12) self.create_button_data() self.buttons = {} for x, y, w, h, cap, bgcol, cb in self.button_data: button = self.create_button(_(cap), cb, self.col_white, bgcol, w, h) self.buttons[cap] = button self.pad.attach(button, x, x + w, y, y + h) eb = gtk.EventBox() eb.add(self.pad) eb.modify_bg(gtk.STATE_NORMAL, self.col_black) self.grid.attach(eb, 0, 7, 6, 26) # Right part: container and equation button hc2 = gtk.HBox() combo = ComboBox() combo.append_item(0, _('All equations')) combo.append_item(1, _('My equations')) combo.append_item(2, _('Show variables')) combo.set_active(0) combo.connect('changed', self._history_filter_cb) hc2.pack_start(combo) hc2.set_border_width(6) self.grid.attach(hc2, 7, 11, 0, 2) # Right part: last equation self.last_eq = gtk.TextView() self.last_eq.set_editable(False) self.last_eq.set_wrap_mode(gtk.WRAP_WORD_CHAR) self.last_eq.connect('realize', self._textview_realize_cb) self.last_eq.modify_base(gtk.STATE_NORMAL, gtk.gdk.color_parse( sugar.profile.get_color().get_fill_color())) self.last_eq.modify_bg(gtk.STATE_NORMAL, gtk.gdk.color_parse( sugar.profile.get_color().get_stroke_color())) self.last_eq.set_border_window_size(gtk.TEXT_WINDOW_LEFT, 4) self.last_eq.set_border_window_size(gtk.TEXT_WINDOW_RIGHT, 4) self.last_eq.set_border_window_size(gtk.TEXT_WINDOW_TOP, 4) self.last_eq.set_border_window_size(gtk.TEXT_WINDOW_BOTTOM, 4) # TODO Fix for old Sugar 0.82 builds, red_float not available bright = (gtk.gdk.color_parse(sugar.profile.get_color().get_fill_color()).red_float + gtk.gdk.color_parse(sugar.profile.get_color().get_fill_color()).green_float + gtk.gdk.color_parse(sugar.profile.get_color().get_fill_color()).blue_float) / 3.0 if bright < 0.5: self.last_eq.modify_text(gtk.STATE_NORMAL, self.col_white) else: self.last_eq.modify_text(gtk.STATE_NORMAL, self.col_black) self.grid.attach(self.last_eq, 7, 11, 2, 7) # Right part: history scrolled_window = gtk.ScrolledWindow() scrolled_window.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC) self.history_vbox = gtk.VBox() self.history_vbox.set_homogeneous(False) self.history_vbox.set_border_width(0) self.history_vbox.set_spacing(4) self.variable_vbox = gtk.VBox() self.variable_vbox.set_homogeneous(False) self.variable_vbox.set_border_width(0) self.variable_vbox.set_spacing(4) vbox = gtk.VBox() vbox.pack_start(self.history_vbox) vbox.pack_start(self.variable_vbox) scrolled_window.add_with_viewport(vbox) self.grid.attach(scrolled_window, 7, 11, 7, 26) gtk.gdk.screen_get_default().connect('size-changed', self._configure_cb)
def create_dialog(self): """Setup most of the dialog.""" # Toolbar try: self._toolbar_box = ToolbarBox() activity_button = ActivityToolbarButton(self._parent) self._toolbar_box.toolbar.insert(activity_button, 0) def append(icon_name, label, page, position): toolbar_button = ToolbarButton() toolbar_button.props.page = page toolbar_button.props.icon_name = icon_name toolbar_button.props.label = label self._toolbar_box.toolbar.insert(toolbar_button, position) append('toolbar-edit', _('Edit'), EditToolbar(self._parent), -1) append('toolbar-algebra', _('Algebra'), AlgebraToolbar(self._parent), -1) append('toolbar-trigonometry', _('Trigonometry'), TrigonometryToolbar(self._parent), -1) append('toolbar-boolean', _('Boolean'), BooleanToolbar(self._parent), -1) self._misc_toolbar = MiscToolbar( self._parent, target_toolbar=self._toolbar_box.toolbar) append('toolbar-constants', _('Miscellaneous'), self._misc_toolbar, 5) self._stop_separator = gtk.SeparatorToolItem() self._stop_separator.props.draw = False self._stop_separator.set_expand(True) self._stop_separator.show() self._toolbar_box.toolbar.insert(self._stop_separator, -1) self._stop = StopButton(self._parent) self._toolbar_box.toolbar.insert(self._stop, -1) self._toolbar_box.show_all() self._parent.set_toolbar_box(self._toolbar_box) except NameError: # Use old toolbar design toolbox = activity.ActivityToolbox(self._parent) self._parent.set_toolbox(toolbox) toolbox.add_toolbar(_('Edit'), EditToolbar(self._parent)) toolbox.add_toolbar(_('Algebra'), AlgebraToolbar(self._parent)) toolbox.add_toolbar( _('Trigonometry'), TrigonometryToolbar(self._parent)) toolbox.add_toolbar(_('Boolean'), BooleanToolbar(self._parent)) toolbox.add_toolbar(_('Miscellaneous'), MiscToolbar(self._parent)) toolbox.show_all() # Some layout constants self.input_font = pango.FontDescription(str='sans bold 12') self.button_font = pango.FontDescription(str='sans bold 16') self.col_white = self.create_color(1.00, 1.00, 1.00) self.col_gray1 = self.create_color(0.76, 0.76, 0.76) self.col_gray2 = self.create_color(0.50, 0.50, 0.50) self.col_gray3 = self.create_color(0.25, 0.25, 0.25) self.col_black = self.create_color(0.00, 0.00, 0.00) self.col_red = self.create_color(1.00, 0.00, 0.00) # Big - Table, 16 rows, 10 columns, homogeneously divided self.grid = gtk.Table(26, 11, True) self.grid.set_border_width(0) self.grid.set_row_spacings(0) self.grid.set_col_spacings(4) # Left part: container and input vc1 = gtk.VBox(False, 0) hc1 = gtk.HBox(False, 10) eb = gtk.EventBox() eb.add(hc1) eb.modify_bg(gtk.STATE_NORMAL, self.col_black) eb.set_border_width(12) eb2 = gtk.EventBox() eb2.add(eb) eb2.modify_bg(gtk.STATE_NORMAL, self.col_black) label1 = gtk.Label(_('Label:')) label1.modify_fg(gtk.STATE_NORMAL, self.col_white) label1.set_alignment(1, 0.5) hc1.pack_start(label1, expand=False, fill=False, padding=10) self.label_entry = gtk.Entry() self.label_entry.modify_bg(gtk.STATE_INSENSITIVE, self.col_black) hc1.pack_start(self.label_entry, expand=True, fill=True, padding=0) vc1.pack_start(eb2, expand=False) self.text_entry = gtk.Entry() try: self.text_entry.props.im_module = 'gtk-im-context-simple' except AttributeError: pass self.text_entry.set_size_request(-1, 75) self.text_entry.connect('key_press_event', self._parent.ignore_key_cb) self.text_entry.modify_font(self.input_font) self.text_entry.modify_bg(gtk.STATE_INSENSITIVE, self.col_black) eb = gtk.EventBox() eb.add(self.text_entry) eb.modify_bg(gtk.STATE_NORMAL, self.col_black) eb.set_border_width(12) eb2 = gtk.EventBox() eb2.add(eb) eb2.modify_bg(gtk.STATE_NORMAL, self.col_black) vc1.pack_start(eb2, expand=True, fill=True, padding=0) self.grid.attach(vc1, 0, 7, 0, 6) # Left part: buttons self.pad = gtk.Table(9, 6, True) self.pad.set_row_spacings(12) self.pad.set_col_spacings(12) self.pad.set_border_width(12) self.create_button_data() self.buttons = {} for x, y, w, h, cap, bgcol, cb in self.button_data: button = self.create_button( _(cap), cb, self.col_white, bgcol, w, h) self.buttons[cap] = button self.pad.attach(button, x, x + w, y, y + h) eb = gtk.EventBox() eb.add(self.pad) eb.modify_bg(gtk.STATE_NORMAL, self.col_black) self.grid.attach(eb, 0, 7, 6, 26) # Right part: container and equation button hc2 = gtk.HBox() combo = ComboBox() combo.append_item(0, _('All equations')) combo.append_item(1, _('My equations')) combo.append_item(2, _('Show variables')) combo.set_active(0) combo.connect('changed', self._history_filter_cb) hc2.pack_start(combo) hc2.set_border_width(6) self.grid.attach(hc2, 7, 11, 0, 2) # Right part: last equation self.last_eq = gtk.TextView() self.last_eq.set_editable(False) self.last_eq.set_wrap_mode(gtk.WRAP_WORD_CHAR) self.last_eq.connect('realize', self._textview_realize_cb) self.last_eq.modify_base(gtk.STATE_NORMAL, gtk.gdk.color_parse( sugar.profile.get_color().get_fill_color())) self.last_eq.modify_bg(gtk.STATE_NORMAL, gtk.gdk.color_parse( sugar.profile.get_color().get_stroke_color())) self.last_eq.set_border_window_size(gtk.TEXT_WINDOW_LEFT, 4) self.last_eq.set_border_window_size(gtk.TEXT_WINDOW_RIGHT, 4) self.last_eq.set_border_window_size(gtk.TEXT_WINDOW_TOP, 4) self.last_eq.set_border_window_size(gtk.TEXT_WINDOW_BOTTOM, 4) # TODO Fix for old Sugar 0.82 builds, red_float not available xo_color = sugar.profile.get_color() bright = ( gtk.gdk.color_parse(xo_color.get_fill_color()).red_float + gtk.gdk.color_parse(xo_color.get_fill_color()).green_float + gtk.gdk.color_parse(xo_color.get_fill_color()).blue_float) / 3.0 if bright < 0.5: self.last_eq.modify_text(gtk.STATE_NORMAL, self.col_white) else: self.last_eq.modify_text(gtk.STATE_NORMAL, self.col_black) self.grid.attach(self.last_eq, 7, 11, 2, 7) # Right part: history scrolled_window = gtk.ScrolledWindow() scrolled_window.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC) self.history_vbox = gtk.VBox() self.history_vbox.set_homogeneous(False) self.history_vbox.set_border_width(0) self.history_vbox.set_spacing(4) self.variable_vbox = gtk.VBox() self.variable_vbox.set_homogeneous(False) self.variable_vbox.set_border_width(0) self.variable_vbox.set_spacing(4) vbox = gtk.VBox() vbox.pack_start(self.history_vbox) vbox.pack_start(self.variable_vbox) scrolled_window.add_with_viewport(vbox) self.grid.attach(scrolled_window, 7, 11, 7, 26) gtk.gdk.screen_get_default().connect('size-changed', self._configure_cb)
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_interval_combo = ComboBox() self.interval = [ _('1/10 second'), _('1 second'), _('30 seconds'), _('5 minutes'), _('30 minutes') ] if hasattr(self._log_interval_combo, 'set_tooltip_text'): self._log_interval_combo.set_tooltip_text(_('Sampling interval')) self._interval_changed_id = self._log_interval_combo.connect( 'changed', self.log_interval_cb) for i, s in enumerate(self.interval): self._log_interval_combo.append_item(i, s, None) if s == _('1 second'): self._log_interval_combo.set_active(i) self._log_interval_tool = ToolComboBox(self._log_interval_combo) self.insert(self._log_interval_tool, -1) self.logging_interval_status = '1 second' # 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) if self.activity.has_toolbarbox: separator = gtk.SeparatorToolItem() separator.props.draw = True self.insert(separator, -1) # Set up Trigger Combo box self.trigger_combo = ComboBox() self.trigger = [_('None'), _('Rising Edge'), _('Falling Edge')] self.trigger_conf = [ self.activity.wave.TRIGGER_NONE, self.activity.wave.TRIGGER_POS, self.activity.wave.TRIGGER_NEG ] self._trigger_changed_id = self.trigger_combo.connect( 'changed', self.update_trigger_control) for i, s in enumerate(self.trigger): self.trigger_combo.append_item(i, s, None) self.trigger_combo.set_active(0) if hasattr(self.trigger_combo, 'set_tooltip_text'): self.trigger_combo.set_tooltip_text(_('Create a trigger')) self._trigger_tool = ToolComboBox(self.trigger_combo) self.insert(self._trigger_tool, -1) self.show_all() def add_frequency_slider(self, toolbar): ''' 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.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_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_range_tool = gtk.ToolItem() self._freq_range_tool.add(self._freq_range) toolbar.insert(self._freq_stepper_up, -1) toolbar.insert(self._freq_range_tool, -1) toolbar.insert(self._freq_stepper_down, -1) return def update_trigger_control(self, *args): ''' Callback for trigger control ''' if self.activity.wave.get_fft_mode(): self.trigger_combo.set_active(self.activity.wave.TRIGGER_NONE) active = self.trigger_combo.get_active() if active == -1: return self.activity.wave.set_trigger(self.trigger_conf[active]) return 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() 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.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.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 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 update_string_for_textbox(self): ''' Update the status field at the bottom of the canvas. ''' if self.activity.CONTEXT == 'butia': string_for_textbox = '' else: 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 X2OActivity(olpcgames.PyGameActivity): game_name = 'x2o' game_title = 'x2o' game_size = None # olpcgame will choose size # setup the toolbar def build_toolbar(self): # make a toolbox toolbox = activity.ActivityToolbox(self) # modify the Activity tab activity_toolbar = toolbox.get_activity_toolbar() activity_toolbar.share.props.visible = False self.activity_toolbar = activity_toolbar # make the toolbars toolbars = {} for b in tools.allButtons: if not toolbars.has_key(b.toolBar): toolbars[b.toolBar] = gtk.Toolbar() # make + add the buttons self.buttonList = {} for c in tools.allButtons: button = ToolButton(c.icon) button.set_tooltip(_(c.toolTip)) button.connect('clicked', self.buttonClicked) toolbars[c.toolBar].insert(button, -1) button.show() self.buttonList[button] = c.name # add the toolbars to the toolbox for bar in toolbars: toolbox.add_toolbar(bar, toolbars[bar]) toolbars[bar].show() # make the level chooser combo box lbl = gtk.Label("Load a level: ") lbl.show() cmb = ComboBox() cmb.connect('changed', self.levelChanged) files = os.listdir("levels") for i in files: if i[-6:] == ".level": f = open("levels/" + i) try: n = pickle.load(f)['name'] except: continue f.close() cmb.append_item("levels/" + i, n) cmb = ToolComboBox(cmb) lbl_ti = gtk.ToolItem() lbl_ti.add(lbl) toolbars['Run'].insert(lbl_ti, -1) lbl_ti.show() toolbars['Run'].insert(cmb, -1) cmb.show() button = ToolButton("load") button.set_tooltip(_("Load your own level")) button.connect('clicked', self.loadButtonClicked) toolbars['Run'].insert(button, -1) button.show() # add some level saving stuff to the save toolbar self.quantBox = ComboBox() self.quantBox.connect('changed', self.quantBoxChanged) self.quantBoxIndexes = {} for i in range(26): self.quantBox.append_item(i, str(i)) self.quantBoxIndexes[i] = i self.quantBox.append_item(float('inf'), "Infinity") self.quantBoxIndexes[float('inf')] = 26 cmb = ToolComboBox(self.quantBox) activity_toolbar.insert(cmb, 1) cmb.show() cmb = ComboBox() cmb.connect('changed', self.compQuantBoxChanged) for c in components.allComponents: if c.name != "X" and c.name != "O": cmb.append_item(c.name, c.name) cmb = ToolComboBox(cmb) activity_toolbar.insert(cmb, 1) cmb.show() lbl = gtk.Label(" Component amounts: ") lbl.show() ti = gtk.ToolItem() ti.add(lbl) activity_toolbar.insert(ti, 1) ti.show() toolbox.show() self.set_toolbox(toolbox) toolbox.set_current_toolbar(1) return activity_toolbar def buttonClicked(self, button): pygame.event.post( olpcgames.eventwrap.Event(pygame.USEREVENT, action=self.buttonList[button])) def compQuantBoxChanged(self, cmb): pygame.event.post( olpcgames.eventwrap.Event("UpdateCompQuantBox", action=cmb.props.value)) def quantBoxChanged(self, cmb): pygame.event.post( olpcgames.eventwrap.Event("UpdateQuantBox", action=cmb.props.value)) def levelChanged(self, cmb): event = olpcgames.eventwrap.Event( type=pygame.USEREVENT, code=olpcgames.FILE_READ_REQUEST, filename=cmb.props.value, metadata=None, ) olpcgames.eventwrap.post(event) def loadButtonClicked(self, button): chooser = ObjectChooser( 'Pick a level', self, gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT) try: result = chooser.run() if result == gtk.RESPONSE_ACCEPT: jobject = chooser.get_selected_object() if jobject and jobject.file_path: event = olpcgames.eventwrap.Event( type=pygame.USEREVENT, code=olpcgames.FILE_READ_REQUEST, filename=jobject.file_path, metadata=jobject.metadata, ) olpcgames.eventwrap.post(event) event.block() finally: chooser.destroy() del chooser