def __init__(self, owner):
gtk.Toolbar.__init__(self)
self.owner = owner
self._insert_separator(True)
self.desktop = []
btn = RadioToolButton(group=None)
btn.set_named_icon('jam-preset1')
btn.connect('toggled', self.setDesktop, 0)
btn.set_tooltip(_('Desktop 1'))
self.insert(btn, -1)
self.desktop.append(btn)
for i in range(2, 11):
btn = RadioToolButton(group=self.desktop[0])
btn.set_named_icon('jam-preset%d' % i)
btn.connect('toggled', self.setDesktop, i - 1)
btn.set_tooltip(_('Desktop %d' % i))
self.insert(btn, -1)
self.desktop.append(btn)
self._insert_separator(True)
self.show_all()
def _insert_create_tools(self, create_toolbar):
# Stop/play button
self.stop_play_state = True
self.stop_play = ToolButton('media-playback-stop')
self.stop_play.set_tooltip(_("Stop"))
self.stop_play.set_accelerator(_('<ctrl>space'))
self.stop_play.connect('clicked', self.stop_play_cb)
create_toolbar.insert(self.stop_play, -1)
self.stop_play.show()
separator = gtk.SeparatorToolItem()
create_toolbar.insert(separator, -1)
separator.show()
# Make + add the component buttons
self.radioList = {}
firstButton = None
for c in tools.allTools:
button = RadioToolButton(named_icon=c.icon)
if firstButton:
button.set_group(firstButton)
else:
button.set_group(None)
firstButton = button
button.set_tooltip(c.toolTip)
button.set_accelerator(c.toolAccelerator)
button.connect('clicked', self.radioClicked)
create_toolbar.insert(button, -1)
button.show()
self.radioList[button] = c.name
def __init__(self, owner):
gtk.Toolbar.__init__(self)
self.owner = owner
self._insert_separator(True)
self.desktop = []
btn = RadioToolButton(group=None)
btn.set_named_icon('jam-preset1')
btn.connect('toggled', self.setDesktop, 0)
btn.set_tooltip(_('Desktop 1'))
self.insert(btn, -1)
self.desktop.append(btn)
for i in range(2, 11):
btn = RadioToolButton(group=self.desktop[0])
btn.set_named_icon('jam-preset%d' % i)
btn.connect('toggled', self.setDesktop, i - 1)
btn.set_tooltip(_('Desktop %d' % i))
self.insert(btn, -1)
self.desktop.append(btn)
self._insert_separator(True)
self.show_all()
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 add_level_button(icon_name, tooltip, signal_name):
if levels:
button = RadioToolButton(named_icon=icon_name, group=levels[0])
else:
button = RadioToolButton(named_icon=icon_name)
levels.append(button)
toolbar.add(button)
def callback(source):
if source.get_active():
self.emit(signal_name)
button.connect('clicked', callback)
button.set_tooltip(tooltip)
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 __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 _radio_button_factory(name='', toolbar=None, cb=None, arg=None,
tooltip=None, group=None):
''' Add a radio button to a toolbar '''
button = RadioToolButton(group=group)
button.set_named_icon(name)
if cb is not None:
if arg is None:
button.connect('clicked', cb)
else:
button.connect('clicked', cb, arg)
if toolbar is not None:
toolbar.insert(button, -1)
button.show()
if tooltip is not None:
button.set_tooltip(tooltip)
return button
def radio_factory(button_name, toolbar, callback, cb_arg=None, tooltip=None,
group=None):
''' Add a radio button to a toolbar '''
button = RadioToolButton(group=group)
button.set_named_icon(button_name)
if callback is not None:
if cb_arg is None:
button.connect('clicked', callback)
else:
button.connect('clicked', callback, cb_arg)
if hasattr(toolbar, 'insert'): # Add button to the main toolbar...
toolbar.insert(button, -1)
else: # ...or a secondary toolbar.
toolbar.props.page.insert(button, -1)
button.show()
if tooltip is not None:
button.set_tooltip(tooltip)
return button
def get_toolbar(self):
toolbar = gtk.Toolbar()
radio_adv = RadioToolButton()
radio_adv.set_active(True)
radio_adv.set_label("Avanzada")
radio_adv.set_tooltip("Mostrar biblioteca avanzada")
radio_adv.connect("clicked", self.switch, "advanced")
toolbar.insert(radio_adv, -1)
radio_adv.show()
radio_bas = RadioToolButton(group=radio_adv)
radio_bas.set_label("Simple")
radio_bas.set_tooltip("Mostrar biblioteca sencilla")
radio_bas.connect("clicked", self.switch, "basic")
toolbar.insert(radio_bas, -1)
toolbar.show_all()
return toolbar
def load_buttons(self):
self.sensores = [_('Light Sensor'), _('Distance Sensor'), _('Grey Sensor'), _('Button Sensor'), _('Sound Sensor')]
self.lista_sensores_button = []
for i in range(len(self.sensores)):
self.sensor = self.sensores[i]
radio_tool_button = RadioToolButton(group=self.time)
icono = self.sensor.strip('0123456789:')
radio_tool_button.set_named_icon(icono)
radio_tool_button.set_tooltip(_(self.sensor))
if self.sensor.count(_('Sound Sensor')):
radio_tool_button.connect('clicked',self.click_sound_button)
if self.sensor.count(_('Distance Sensor')):
radio_tool_button.connect('clicked',self.click_dist_button)
elif self.sensor.count(_('Grey Sensor')):
radio_tool_button.connect('clicked',self.click_grises_button)
elif self.sensor.count(_('Button Sensor')):
radio_tool_button.connect('clicked',self.click_button)
log.debug(self.sensores)
elif self.sensor.count(_('Light sensor')):
radio_tool_button.connect('clicked',self.click_luz_button)
self.insert(radio_tool_button, 2)
self.lista_sensores_button.append(radio_tool_button)
def 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.blocklist = []
# make a 'create' toolbar
create_toolbar = gtk.Toolbar()
# make + add the component buttons
self.radioList = {}
for c in tools.allTools:
button = RadioToolButton(named_icon=c.icon)
button.set_tooltip(_(c.toolTip))
button.connect('clicked',self.radioClicked)
create_toolbar.insert(button,-1)
button.show()
self.radioList[button] = c.name
# add the toolbars to the toolbox
toolbox.add_toolbar("Create",create_toolbar)
create_toolbar.show()
# add a ILF specific toolbar which gives feedback about problems
#ilf_toolbar = gtk.Toolbar()
#self.ilf_label = gtk.Label("test")
#ilf_toolbar.insert_widget(self.ilf_label, "testlabel", None, -1)
#self.ilf_label.show()
#toolbox.add_toolbar("ILF", ilf_toolbar)
#ilf_toolbar.show()
toolbox.show()
self.set_toolbox(toolbox)
toolbox.set_current_toolbar(1)
return activity_toolbar
def __init__(self, parent):
gtk.Toolbar.__init__(self)
self._parent = parent
text_mode_btn = RadioToolButton(named_icon='text-mode')
text_mode_btn.set_tooltip(_('Text mode'))
text_mode_btn.set_accelerator(_('<ctrl>t'))
text_mode_btn.set_group(None)
text_mode_btn.connect('clicked', self._parent.mode_cb,
MMapArea.MODE_TEXT)
self._parent.btn_group = text_mode_btn
self.insert(text_mode_btn, -1)
image_mode_btn = RadioToolButton(named_icon='image-mode')
image_mode_btn.set_group(text_mode_btn)
image_mode_btn.set_tooltip(_('Image add mode'))
image_mode_btn.set_accelerator(_('<ctrl>i'))
image_mode_btn.connect('clicked', self._parent.mode_cb,
MMapArea.MODE_IMAGE)
self.insert(image_mode_btn, -1)
draw_mode_btn = RadioToolButton(named_icon='draw-mode')
draw_mode_btn.set_group(text_mode_btn)
draw_mode_btn.set_tooltip(_('Drawing mode'))
draw_mode_btn.set_accelerator(_('<ctrl>d'))
draw_mode_btn.connect('clicked', self._parent.mode_cb,
MMapArea.MODE_DRAW)
self.insert(draw_mode_btn, -1)
label_mode_btn = RadioToolButton(named_icon='label-mode')
label_mode_btn.set_tooltip(_('Label mode'))
label_mode_btn.set_accelerator(_('<ctrl>a'))
label_mode_btn.set_group(text_mode_btn)
label_mode_btn.connect('clicked', self._parent.mode_cb,
MMapArea.MODE_LABEL)
self.insert(label_mode_btn, -1)
self.show_all()
def __init__(self, parent):
gtk.Toolbar.__init__(self)
self._parent = parent
text_mode_btn = RadioToolButton(named_icon='text-mode')
text_mode_btn.set_tooltip(_('Text mode'))
text_mode_btn.set_accelerator(_('<ctrl>t'))
text_mode_btn.set_group(None)
text_mode_btn.connect('clicked', self._parent.mode_cb,
MMapArea.MODE_TEXT)
self._parent.btn_group = text_mode_btn
self.insert(text_mode_btn, -1)
image_mode_btn = RadioToolButton(named_icon='image-mode')
image_mode_btn.set_group(text_mode_btn)
image_mode_btn.set_tooltip(_('Image add mode'))
image_mode_btn.set_accelerator(_('<ctrl>i'))
image_mode_btn.connect('clicked', self._parent.mode_cb,
MMapArea.MODE_IMAGE)
self.insert(image_mode_btn, -1)
draw_mode_btn = RadioToolButton(named_icon='draw-mode')
draw_mode_btn.set_group(text_mode_btn)
draw_mode_btn.set_tooltip(_('Drawing mode'))
draw_mode_btn.set_accelerator(_('<ctrl>d'))
draw_mode_btn.connect('clicked', self._parent.mode_cb,
MMapArea.MODE_DRAW)
self.insert(draw_mode_btn, -1)
label_mode_btn = RadioToolButton(named_icon='label-mode')
label_mode_btn.set_tooltip(_('Label mode'))
label_mode_btn.set_accelerator(_('<ctrl>a'))
label_mode_btn.set_group(text_mode_btn)
label_mode_btn.connect('clicked', self._parent.mode_cb,
MMapArea.MODE_LABEL)
self.insert(label_mode_btn, -1)
self.show_all()
def instance(self):
book.wiki = book.WikiBook()
if not book.custom:
book.custom = book.CustomBook()
self.edit_page = 1
self.edit = edit.View()
self.library = library.View(self)
if OLD_TOOLBAR:
self.edit_toolbar = gtk.Toolbar()
self.edit_bar = edit.ToolbarBuilder(self.edit, self.edit_toolbar)
self.edit_toolbar.show_all()
self.library_toolbar = gtk.Toolbar()
self.library_bar = library.ToolbarBuilder(self.library,
self.library_toolbar)
self.library_toolbar.show_all()
toolbox = ActivityToolbox(self)
toolbox.connect('current-toolbar-changed',
self._toolbar_changed_cb)
self.set_toolbox(toolbox)
toolbox.add_toolbar(_('Library'), self.library_toolbar)
toolbox.add_toolbar(_('Edit'), self.edit_toolbar)
toolbox.set_current_toolbar(1)
else:
toolbar_box = ToolbarBox()
activity_button = ActivityToolbarButton(self)
toolbar_box.toolbar.insert(activity_button, 0)
self.set_toolbar_box(toolbar_box)
self._toolbar = toolbar_box.toolbar
tool_group = None
search_button = RadioToolButton()
search_button.props.group = tool_group
tool_group = search_button
search_button.props.icon_name = 'white-search'
search_button.set_tooltip(_('Library'))
search_button.mode = 'search'
search_button.connect('clicked', self.__mode_button_clicked)
self._toolbar.insert(search_button, -1)
edit_button = RadioToolButton()
edit_button.props.group = tool_group
edit_button.props.icon_name = 'toolbar-edit'
edit_button.set_tooltip(_('Edit'))
edit_button.mode = 'edit'
edit_button.connect('clicked', self.__mode_button_clicked)
self._toolbar.insert(edit_button, -1)
self._toolbar.insert(gtk.SeparatorToolItem(), -1)
self.edit_bar = edit.ToolbarBuilder(self.edit, self._toolbar)
self.library_bar = library.ToolbarBuilder(self.library,
self._toolbar)
edit_fake = gtk.EventBox()
self.notebook.append_page(self.library)
self.notebook.append_page(self.edit)
self.notebook.append_page(edit_fake)
self.show_all()
if not OLD_TOOLBAR:
self.__mode_button_clicked(search_button)
separator = gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
separator.show()
self._toolbar.insert(separator, -1)
stop_button = StopButton(self)
stop_button.show()
self._toolbar.insert(stop_button, -1)
class ActionButtons():
''' This class manages the action buttons that move among toolsbars '''
def __init__(self, parent):
self._main_toolbar = parent.get_toolbar_box().toolbar
self._main_area = parent._main_area
self._erase_button = parent.edit_toolbar.erase_button
self._sw = parent._sw
if HASTOOLBARBOX:
target_toolbar = self._main_toolbar
else:
target_toolbar = self.parent.edit_toolbar
self._mods = RadioToolButton(named_icon='select-mode')
self._mods.set_tooltip(_('Select thoughts'))
self._mods.set_group(parent.btn_group)
self._mods.set_accelerator(_('<ctrl>e'))
self._mods.connect('clicked', parent.mode_cb, MMapArea.MODE_NULL)
target_toolbar.insert(self._mods, -1)
self._link_button = RadioToolButton(named_icon='link')
self._link_button.set_tooltip(_('Link/unlink two selected thoughts'))
self._link_button.set_group(parent.btn_group)
self._link_button.set_accelerator(_('<ctrl>l'))
self._link_button.connect('clicked', self.__link_cb)
target_toolbar.insert(self._link_button, -1)
self.move_button = RadioToolButton(named_icon='move')
self.move_button.set_tooltip(_('Move selected thoughs'))
self.move_button.set_group(parent.btn_group)
self.move_button.set_accelerator(_('<ctrl>m'))
self.move_button.connect('clicked', self.__move_cb)
target_toolbar.insert(self.move_button, -1)
self.drag_button = RadioToolButton(named_icon='drag')
self.drag_button.set_tooltip(_('Scroll the screen'))
self.drag_button.set_group(parent.btn_group)
self.drag_button.connect('clicked', self.__drag_cb)
target_toolbar.insert(self.drag_button, -1)
if HASTOOLBARBOX:
self._separator_2 = gtk.SeparatorToolItem()
self._separator_2.props.draw = False
#self._separator_2.set_size_request(0, -1)
self._separator_2.set_expand(True)
self._separator_2.show()
target_toolbar.insert(self._separator_2, -1)
self._stop_button = StopButton(parent)
target_toolbar.insert(self._stop_button, -1)
def stop_dragging(self):
if self._main_area.is_dragging():
self._main_area.drag_menu_cb(self._sw, False)
def _stop_moving(self):
self._main_area.move_mode = False
def __link_cb(self, widget):
self._stop_moving()
self.stop_dragging()
self._main_area.link_menu_cb()
def __move_cb(self, widget):
self.stop_dragging()
if self._main_area.move_mode:
self._main_area.stop_moving()
else:
self._main_area.start_moving(self.move_button)
self._erase_button.set_sensitive(False)
def __drag_cb(self, widget):
# If we were moving, stop
self._stop_moving()
if not self._main_area.is_dragging():
self._main_area.drag_menu_cb(self._sw, True)
else:
self.stop_dragging()
self._erase_button.set_sensitive(False)
def reconfigure(self):
''' If screen width has changed, we may need to reconfigure
the toolbars '''
if not HASTOOLBARBOX:
return
if hasattr(self, '_separator_2'):
if gtk.gdk.screen_width() / 13 > style.GRID_CELL_SIZE:
if self._separator_2.get_parent() is None:
self._main_toolbar.remove(self._stop_button)
self._main_toolbar.insert(self._separator_2, -1)
self._main_toolbar.insert(self._stop_button, -1)
else:
self._main_toolbar.remove(self._separator_2)
class SensorToolbar(gtk.Toolbar):
''' The toolbar for specifiying the sensor: sound, resitance, or
voltage '''
LOWER = 0.0
UPPER = 1.0
STR_DC_R = \
_("Resistive sensor (connect sensor to pink 'Mic In' on left side \
of XO)" ) + ' '
STR_DC_V = \
_("Voltage sensor (connect sensor to pink 'Mic In' on left side \
of XO)" ) + ' '
STR_AC = _('Sound') + ' '
STR_RESISTANCE = _('Resistance') + ' (' + _('Ohms') + ') '
STR_VOLTAGE = _('Voltage') + ' (' + _('Volts') + ') '
STR_TIME = _('Time Base') + ' '
STR_FREQUENCY = _('Frequency Base') + ' '
STR_INVERT = ' ' + _('Invert') + ' '
STR_XAXIS_TEXT = _('X Axis Scale: 1 division = %(division)s %(unit)s')
# TRANSLATORS: This is milli seconds.
MS = _('ms')
# TRANSLATORS: This is Hertz, so 1/second.
HZ = _('Hz')
def __init__(self, activity, channels):
''' By default, start with resistance mode '''
gtk.Toolbar.__init__(self)
self.activity = activity
self._channels = channels
self._lock_radio_buttons = False
self._radio_button_pushed = False
self.values = []
for i in range(self._channels):
self.values.append('')
self.string_for_textbox = ''
self.gain = 1.0
self.y_mag = 3.0
self.capture_gain = CAPTURE_GAIN
self.mic_boost = MIC_BOOST
self.mode = 'sound'
# Set up Time-domain Button
self.time = RadioToolButton(group=None)
self.time.set_named_icon('media-audio')
self.insert(self.time, -1)
self.time.set_tooltip(_('Sound'))
self.time.connect('clicked', self.analog_resistance_voltage_mode_cb,
'sound')
# Set up Resistance Button
self.resistance = RadioToolButton(group=self.time)
self.resistance.set_named_icon('resistance')
if _is_xo(self.activity.hw):
self.insert(self.resistance, -1)
self.resistance.show()
self.resistance.set_tooltip(_('Resistance Sensor'))
self.resistance.connect('clicked',
self.analog_resistance_voltage_mode_cb,
'resistance')
# Set up Voltage Button
self.voltage = RadioToolButton(group=self.time)
self.voltage.set_named_icon('voltage')
if _is_xo(self.activity.hw):
self.insert(self.voltage, -1)
self.voltage.set_tooltip(_('Voltage Sensor'))
self.voltage.connect('clicked', self.analog_resistance_voltage_mode_cb,
'voltage')
separator = gtk.SeparatorToolItem()
separator.props.draw = True
self.insert(separator, -1)
self._log_value = LOG_TIMER_VALUES[1]
self.log_label = gtk.Label(self._log_to_string(self._log_value))
toolitem = gtk.ToolItem()
toolitem.add(self.log_label)
self.insert(toolitem, -1)
self._log_button = ToolButton('timer-10')
self._log_button.set_tooltip(_('Select logging interval'))
self._log_button.connect('clicked', self._log_selection_cb)
self.insert(self._log_button, -1)
self._setup_log_palette()
# Set up Logging/Stop Logging Button
self._record = ToolButton('media-record')
self.insert(self._record, -1)
self._record.set_tooltip(_('Start logging'))
self._record.connect('clicked', self.record_control_cb)
separator = gtk.SeparatorToolItem()
separator.props.draw = True
self.insert(separator, -1)
toolitem = gtk.ToolItem()
self.trigger_label = gtk.Label(_('Trigger'))
toolitem.add(self.trigger_label)
self.insert(toolitem, -1)
# Set up Trigger Combo box
self.trigger_none = RadioToolButton()
self.trigger_none.set_named_icon('trigger-none')
self.insert(self.trigger_none, -1)
self.trigger_none.set_tooltip(_('None'))
self.trigger_none.connect('clicked', self.update_trigger_control_cb,
self.activity.wave.TRIGGER_NONE)
self.trigger_rise = RadioToolButton(group=self.trigger_none)
self.trigger_rise.set_named_icon('trigger-rise')
self.insert(self.trigger_rise, -1)
self.trigger_rise.set_tooltip(_('Rising Edge'))
self.trigger_rise.connect('clicked', self.update_trigger_control_cb,
self.activity.wave.TRIGGER_POS)
self.trigger_fall = RadioToolButton(group=self.trigger_none)
self.trigger_fall.set_named_icon('trigger-fall')
self.insert(self.trigger_fall, -1)
self.trigger_fall.set_tooltip(_('Falling Edge'))
self.trigger_fall.connect('clicked', self.update_trigger_control_cb,
self.activity.wave.TRIGGER_NEG)
self.show_all()
def get_log(self):
return self._log_value
def get_log_idx(self):
if self._log_value in LOG_TIMER_VALUES:
return LOG_TIMER_VALUES.index(self._log_value)
else:
return LOG_TIMER_VALUES[0]
def set_log_idx(self, idx):
self._log_value = LOG_TIMER_VALUES[idx]
self.log_label.set_text(self._log_to_string(self._log_value))
if hasattr(self, '_log_button'):
self._log_button.set_icon('timer-%d' % (self._log_value))
def _log_selection_cb(self, widget):
if self._log_palette:
if not self._log_palette.is_up():
self._log_palette.popup(immediate=True,
state=self._log_palette.SECONDARY)
else:
self._log_palette.popdown(immediate=True)
return
def _log_to_seconds(self, tenth_seconds):
return tenth_seconds / 10.
def _log_to_string(self, tenth_seconds):
if tenth_seconds in LOG_TIMER_LABELS:
return LOG_TIMER_LABELS[tenth_seconds]
else:
return _('1 second')
def _setup_log_palette(self):
self._log_palette = self._log_button.get_palette()
for tenth_seconds in LOG_TIMER_VALUES:
text = self._log_to_string(tenth_seconds)
menu_item = MenuItem(icon_name='timer-%d' % (tenth_seconds),
text_label=self._log_to_string(tenth_seconds))
menu_item.connect('activate', self._log_selected_cb, tenth_seconds)
self._log_palette.menu.append(menu_item)
menu_item.show()
def _log_selected_cb(self, button, seconds):
self.set_log_idx(LOG_TIMER_VALUES.index(seconds))
def add_frequency_slider(self, toolbox):
''' Either on the Sound toolbar or the Main toolbar '''
self._freq_stepper_up = ToolButton('freq-high')
self._freq_stepper_up.set_tooltip(_('Zoom out'))
self._freq_stepper_up.connect('clicked', self._freq_stepper_up_cb)
self._freq_stepper_up.show()
self.activity.adjustmentf = gtk.Adjustment(0.5, self.LOWER, self.UPPER,
0.01, 0.1, 0)
self.activity.adjustmentf.connect('value_changed', self.cb_page_sizef)
self._freq_range = gtk.HScale(self.activity.adjustmentf)
self._freq_range.set_inverted(True)
self._freq_range.set_draw_value(False)
self._freq_range.set_update_policy(gtk.UPDATE_CONTINUOUS)
self._freq_range.set_size_request(120, 15)
self._freq_range.show()
self._freq_stepper_down = ToolButton('freq-low')
self._freq_stepper_down.set_tooltip(_('Zoom in'))
self._freq_stepper_down.connect('clicked', self._freq_stepper_down_cb)
self._freq_stepper_down.show()
self._freq_range_tool = gtk.ToolItem()
self._freq_range_tool.add(self._freq_range)
self._freq_range_tool.show()
toolbox.add(self._freq_stepper_up)
toolbox.add(self._freq_range_tool)
toolbox.add(self._freq_stepper_down)
return
def update_trigger_control_cb(self, button, value):
if button is None:
value = self.activity.wave.TRIGGER_NONE
if self.activity.wave.get_fft_mode():
self.trigger_none.set_active(True)
else:
self.activity.wave.set_trigger(value)
def analog_resistance_voltage_mode_cb(self,
button=None,
mode_to_set='sound'):
''' Callback for Analog/Resistance/Voltage Buttons '''
if self._lock_radio_buttons:
logging.debug('mode selector locked')
self._radio_button_pushed = True
return
if self.mode == mode_to_set:
logging.debug('mode already set to %s' % mode_to_set)
return
self._lock_radio_buttons = True
if self.activity.CONTEXT == 'sound':
self.sound_context_off()
else:
self.sensor_context_off()
# Force time domain when switching modes
if self.activity.wave.get_fft_mode():
self.activity.timefreq_control()
# Turn off logging when switching modes
if self.activity.audiograb.we_are_logging:
self.record_control_cb()
self.set_mode(mode_to_set)
if mode_to_set == 'sound':
self.set_sound_context()
elif mode_to_set == 'resistance':
self.set_sensor_context()
elif mode_to_set == 'voltage':
self.set_sensor_context()
self.update_string_for_textbox()
return False
def unlock_radio_buttons(self):
''' Enable radio button selection '''
logging.debug('unlocking radio buttons')
if self._radio_button_pushed:
if self.mode == 'sound':
self.time.set_active(True)
elif self.mode == 'resistance':
self.resistance.set_active(True)
elif self.mode == 'voltage':
self.voltage.set_active(True)
self._lock_radio_buttons = False
self._radio_button_pushed = False
def set_mode(self, mode='sound'):
''' Set the mixer settings to match the current mode. '''
self.mode = mode
self.activity.audiograb.set_sensor_type(self.mode)
for i in range(self._channels):
self.values[i] = 0.0
return
def get_mode(self):
''' Get the mixer settings. '''
return self.mode
def _freq_stepper_up_cb(self, button=None):
''' Moves the horizontal zoom slider to the left one notch,
where one notch is 1/100 of the total range. This correspond
to zooming out as a larger number of Hertz or milliseconds
will be represented by the same space on the screen. '''
new_value = self._freq_range.get_value() +\
(self.UPPER - self.LOWER) / 100.0
if new_value <= self.UPPER:
self._freq_range.set_value(new_value)
else:
self._freq_range.set_value(self.UPPER)
def _freq_stepper_down_cb(self, button=None):
''' Moves the horizontal zoom slider to the right one notch,
where one notch is 1/100 of the total range. This corresponds
to zooming in. '''
new_value = self._freq_range.get_value() -\
(self.UPPER - self.LOWER) / 100.0
if new_value >= self.LOWER:
self._freq_range.set_value(new_value)
else:
self._freq_range.set_value(self.LOWER)
def cb_page_sizef(self, button=None):
''' Callback to scale the frequency range (zoom in and out) '''
if self._update_page_size_id:
gobject.source_remove(self._update_page_size_id)
self._update_page_size_id =\
gobject.timeout_add(250, self.update_page_size)
return True
def update_page_size(self):
''' Set up the scaling of the display. '''
self._update_page_size_id = None
new_value = round(self.activity.adjustmentf.value * 100.0) / 100.0
if self.activity.adjustmentf.value != new_value:
self.activity.adjustmentf.value = new_value
return False
time_div = 0.001 * max(self.activity.adjustmentf.value, 0.05)
freq_div = 1000 * max(self.activity.adjustmentf.value, 0.01)
self.activity.wave.set_div(time_div, freq_div)
self.update_string_for_textbox()
return False
def set_sound_context(self):
''' Called when analog sensing is selected '''
self.set_show_hide_windows(mode='sound')
gobject.timeout_add(500, self.sound_context_on)
self.activity.CONTEXT = 'sound'
def set_sensor_context(self):
''' Called when digital sensing is selected '''
self.set_show_hide_windows(mode='sensor')
gobject.timeout_add(500, self.sensor_context_on)
self.activity.CONTEXT = 'sensor'
def set_show_hide_windows(self, mode='sound'):
''' Shows the appropriate window identified by the mode '''
self.activity.wave.set_context_on()
for i in range(self._channels):
self.activity.side_toolbars[i].set_show_hide(True, mode)
def sensor_context_off(self):
''' Called when a DC sensor is no longer selected '''
# self.activity.audiograb.pause_grabbing()
self.activity.audiograb.stop_grabbing()
def sensor_context_on(self):
''' Called when a DC sensor is selected '''
self.update_string_for_textbox()
self.activity.wave.set_trigger(self.activity.wave.TRIGGER_NONE)
# self.activity.audiograb.resume_grabbing()
self.activity.audiograb.start_grabbing()
return False
def sound_context_off(self):
''' Called when an analog sensor is no longer selected '''
self.gain, self.y_mag = self.activity.wave.get_mag_params()
self.capture_gain = self.activity.audiograb.get_capture_gain()
self.mic_boost = self.activity.audiograb.get_mic_boost()
self.activity.audiograb.stop_grabbing()
def sound_context_on(self):
''' Called when an analog sensor is selected '''
self.activity.wave.set_mag_params(self.gain, self.y_mag)
self.update_string_for_textbox()
self.update_trigger_control_cb(None, self.activity.wave.TRIGGER_NONE)
self.activity.audiograb.start_grabbing()
return False
def set_sample_value(self, value='', channel=0):
''' Write a sample value to the textbox. '''
gtk.threads_enter()
self.values[channel] = value
self.update_string_for_textbox()
gtk.threads_leave()
return
def record_control_cb(self, button=None):
''' Depending upon the selected interval, does either a logging
session, or just logs the current buffer. '''
if self.activity.audiograb.we_are_logging:
self.activity.audiograb.set_logging_params(start_stop=False)
self._record.set_icon('media-record')
self._record.show()
self._record.set_tooltip(_('Start Recording'))
else:
Xscale = (1.00 / self.activity.audiograb.get_sampling_rate())
Yscale = 0.0
interval = self._log_value / 10. # self.interval_convert()
username = self.activity.nick
if self.activity.wave.get_fft_mode():
self.activity.data_logger.start_new_session(
username,
Xscale,
Yscale,
self._log_to_string(self._log_value),
channels=self._channels,
mode='frequency')
else:
self.activity.data_logger.start_new_session(
username,
Xscale,
Yscale,
self._log_to_string(self._log_value),
channels=self._channels,
mode=self.mode)
self.activity.audiograb.set_logging_params(start_stop=True,
interval=interval,
screenshot=False)
self._record.set_icon('record-stop')
self._record.show()
self._record.set_tooltip(_('Stop Recording'))
self.activity.new_recording = True
def update_string_for_textbox(self):
''' Update the status field at the bottom of the canvas. '''
if self.mode == 'resistance':
string_for_textbox = (self.STR_DC_R + '\n')
string_for_textbox += self.STR_RESISTANCE
elif self.mode == 'voltage':
string_for_textbox = (self.STR_DC_V + '\n')
string_for_textbox += self.STR_VOLTAGE
else:
string_for_textbox = (self.STR_AC + '\t')
if self.activity.wave.get_fft_mode():
scalex = self.STR_XAXIS_TEXT % {
'unit': self.HZ,
'division': self.activity.wave.freq_div
}
string_for_textbox += self.STR_FREQUENCY
string_for_textbox += ('\n' + scalex)
elif self.mode == 'sound':
scalex = self.STR_XAXIS_TEXT % {
'unit': self.MS,
'division': self.activity.wave.time_div * 1000
}
string_for_textbox += self.STR_TIME
string_for_textbox += ('\n' + scalex)
else:
for i in range(self._channels):
string_for_textbox += '\t(%s)' % (self.values[i])
invert = False
for i in range(self._channels):
if self.activity.wave.get_invert_state(channel=i):
invert = True
if invert:
string_for_textbox += self.STR_INVERT
self.activity.text_box.set_label(string_for_textbox)
def size_allocate_cb(self, widget, event):
"""
Builds the tag star around the center where the selected
category is shown.
"""
self._logger.debug('size_allocate_cb()')
x, y, width, height = self.fixed.get_allocation()
self._logger.debug('x: %s, y: %s, w: %s, h: %s', x, y, width, height)
self.set_size_request(width, height)
######################################################################
# place togglebuttons around the current position in a radio group
color_fill = profile.get_color().get_fill_color()
color_stroke = profile.get_color().get_stroke_color()
button_width, button_height = self.BUTTON_SIZE
cat_names = get_categories()
radius = 300 # px
x_center = width / 2 - 40
y_center = height / 2 - 40
step_angle = math.radians(360 / (len(cat_names) + 1)) # plus reset btn
# add a reset button
self.reset_selected_btn = RadioToolButton()
img_name = os.path.join(GeoTag.ICONS_PATH, 'reset.svg')
icon = gtk.image_new_from_pixbuf(utils.load_svg_image(img_name,
color_stroke,
color_fill,
self.IMG_SIZE))
self.reset_selected_btn.set_icon_widget(icon)
self.reset_selected_btn.set_tooltip(_('Reset selected tag.'))
self.reset_selected_btn.connect('clicked', self.reset_toggled)
self.reset_selected_btn.show_all()
self.reset_selected_btn.set_size_request(button_width, button_height)
self.fixed.put(self.reset_selected_btn,
x_center, # + int(radius * math.sin(i * step_angle)),
y_center + radius) # + int(radius * math.cos(i * step_angle)))
self.reset_selected_btn.set_active(False)
# read all available categories dynamically
for i, category in enumerate(cat_names):
button = RadioToolButton(group=self.reset_selected_btn)
img_name = os.path.join(GeoTag.ICONS_PATH, category)
icon = get_gtkimage_from_plugin(img_name, color_stroke, color_fill, self.IMG_SIZE)
button.set_icon_widget(icon)
button.set_tooltip(_('Tag some %s.' % category)) # XXX check translation here!!
button.connect('clicked', self.set_toggled, category)
button.show_all()
button.set_size_request(button_width, button_height)
self.fixed.put(button,
x_center + int(radius * math.sin((i + 1) * step_angle)),
y_center + int(radius * math.cos((i + 1) * step_angle)))
button.set_active(False)
img_name = os.path.join(GeoTag.ICONS_PATH, NONE_CATEGORY)
self._set_selected(get_gtkimage_from_plugin(img_name, color_stroke,color_fill, self.IMG_SIZE))
###################################################################
self._logger.debug("size_allocation done")
self.disconnect(self.size_cb) ## use only once
def __init__(self, handle):
activity.Activity.__init__(self, handle, True)
self.max_participants = 1
# ****** Editor ******
self.editor = Editor()
self.editor.connect("pep8-aviable", self.enable_pep8)
self.editor.connect('language-changed', self.language_changed)
self.editor.set_size_request(800, 790)
scroll = gtk.ScrolledWindow()
scroll.set_policy(gtk.POLICY_AUTOMATIC,
gtk.POLICY_AUTOMATIC)
scroll.add(self.editor)
vbox = gtk.VBox()
vpaned = gtk.VPaned()
vbox.pack_start(vpaned, True, True, 0)
vpaned.show()
vpaned.pack1(scroll, resize=True)
scroll.show_all()
self.set_canvas(vbox)
# ****** Toolbars ******
self.toolbar_box = options.OptionWidget(self, self.editor.get_pango_context())
self.toolbar_box.connect('open-from-journal', file_choosers.open_from_journal, None, self)
self.toolbar_box.connect('open-file', self.open_file)
self.toolbar_box.connect('save-file', self.save_file)
self.toolbar_box.connect('save-as', self.save_file_as)
self.toolbar_box.connect('new-file', self.new)
self.toolbar_box.connect('pep8-check', self.pep8_check)
self.toolbar_box.connect('insert-datetime', self.editor._insert_date_time)
self.toolbar_box.connect('copy', self.editor._copy_cb)
self.toolbar_box.connect('paste', self.editor._paste_cb)
self.toolbar_box.connect('undo', self.editor._undo_cb)
self.toolbar_box.connect('redo', self.editor._redo_cb)
self.toolbar_box.connect('cut', self.editor._cut_cb)
self.toolbar_box.connect('search-text', self._search_text)
self.toolbar_box.connect('search-prev', self.editor._search_prev_cb)
self.toolbar_box.connect('search-next', self.editor._search_next_cb)
self.toolbar_box.connect('show-line-numbers', self.editor._set_show_line_numbers)
self.toolbar_box.connect('language-changed', self.change_language)
self.toolbar_box.connect('style-changed', self.change_style)
self.toolbar_box.connect('font-changed', self.change_font)
self.toolbar_box.show_all()
self.set_toolbar_box(self.toolbar_box)
# Barra de estado de PEP8 / PEP8 status bar
self.pep8 = PEP8_Check()
self.pep8_bar = gtk.Statusbar()
self.pep8.connect("show-bar", (lambda w, bar: bar.show_all()), self.pep8_bar)
self.pep8.connect("hide-bar", (lambda w, bar: bar.hide()), self.pep8_bar)
self.pep8_bar.label = gtk.Label()
self.pep8.connect("bar-text", (lambda w, t, l: l.set_text(t)), self.pep8_bar.label)
self.pep8_bar.add(self.pep8_bar.label)
vbox.pack_end(self.pep8_bar, False, True, 0)
tray = VTray()
self.test_notebook = gtk.Notebook()
self.test_notebook.set_show_tabs(False)
terminal = consoles.Terminal()
terminal.show()
terminal_item = RadioToolButton()
terminal_item.set_named_icon("console-terminal")
terminal_item.set_tooltip("Terminal")
terminal_item.connect("toggled", self.page_changed, 0)
terminal_item.show()
self.test_notebook.append_page(terminal, None)
tray.add_item(terminal_item)
python_console = consoles.PythonConsole()
python_console.show()
python_item = RadioToolButton()
python_item.set_named_icon("console-python")
python_item.set_tooltip("Python Console")
python_item.set_group(terminal_item)
python_item.connect("toggled", self.page_changed, 1)
python_item.show()
self.test_notebook.append_page(python_console)
tray.add_item(python_item)
hbox = gtk.HBox()
hbox.pack_start(tray, False, True, 0)
hbox.pack_start(self.test_notebook)
self.test_notebook.show()
vpaned.pack2(hbox, resize=True)
vpaned.show_all()
tray.show()
hbox.show()
vbox.show_all()
class Activity(sugar.activity.activity.Activity):
def __init__(self, handle):
super(Activity, self).__init__(handle)
self.paused = False
watch = gtk.gdk.Cursor(gtk.gdk.WATCH)
self.window.set_cursor(watch)
self.p = gtk.VPaned()
self.p.connect("notify::position", self.redraw)
self.box = gtk.Notebook()
self.p.pack2(self.box)
self.p.show()
self.box.set_show_tabs(False)
self.splash = gtk.Image()
pixbuf = gtk.gdk.pixbuf_new_from_file("images/splash-colgadito.png")
screen = self.window.get_screen()
width, height = screen.get_width(), screen.get_height() - style.GRID_CELL_SIZE
pixbuf = pixbuf.scale_simple(width, height, gtk.gdk.INTERP_BILINEAR)
self.splash.set_from_pixbuf(pixbuf)
self.splash.show()
eb = gtk.EventBox()
eb.add(self.splash)
eb.modify_bg(gtk.STATE_NORMAL, gtk.gdk.color_parse("white"))
eb.show()
self.box.append_page(eb, gtk.Label("Inicio"))
self._pygamecanvas = sugargame2.canvas.PygameCanvas(self)
self._pygamecanvas.set_flags(gtk.EXPAND)
self._pygamecanvas.set_flags(gtk.FILL)
self.connect("visibility-notify-event", self.redraw)
self._pygamecanvas.set_events(gtk.gdk.BUTTON_PRESS_MASK)
self._pygamecanvas.connect("button-press-event", self._pygamecanvas.grab_focus)
self.box.append_page(self._pygamecanvas, gtk.Label("Juego"))
self.box.show()
self.set_canvas(self.p)
gobject.timeout_add(300, self.pump)
gobject.timeout_add(2000, self.init_interpreter)
#gobject.timeout_add(1000, self.build_editor)
gobject.timeout_add(1500, self.check_modified)
self.build_toolbar()
self.credits = None
self.editor = None
self._pygamecanvas.run_pygame(self.run_game)
def redraw(self, widget=None, b=None, c=None):
scene = spyral.director.get_scene()
if scene:
scene.redraw()
def alert(self, title=None, text=None, delay=5):
alert = NotifyAlert(delay)
alert.props.title = title
alert.props.msg = text
print text
self.add_alert(alert)
alert.connect('response', self._alert_ok)
alert.show()
def _alert_ok(self, alert, *args):
self.remove_alert(alert)
def check_modified(self):
if self.box.current_page()==2:
if not self.save_button.get_sensitive():
if self.editor.modificado():
self.save_button.set_sensitive(True)
return False
return True
def pump(self):
# Esto es necesario porque sino pygame acumula demasiados eventos.
pygame.event.pump()
def focus_interpreter(self, widget, event):
self._interpreter.text.grab_focus()
return True
def init_interpreter(self):
# diferido unos segundos para evitar ver errores superfluos al iniciar
self._interpreter = GTKInterpreterConsole(self.redraw)
self._interpreter.text.connect('button-press-event', self.focus_interpreter)
self.p.pack1(self._interpreter)
return False
def open_file(self, widget, path):
if path:
if not os.path.isdir(path):
self.editor.open_file(widget, path)
def save_file(self, widget):
if self.editor.modificado():
self.save_button.set_sensitive(False)
self.editor.save_file()
filename = self.editor.current_file()
self.alert(filename, "Archivo guardado.")
gobject.timeout_add(1500, self.check_modified)
def build_editor(self):
dir_real = os.getcwd()
f = os.path.realpath(JUEGO.__file__)
f = "." + f.replace(dir_real ,"") # todo esto para obtener una ruta relativa
f = f.rstrip("c") # en caso que sea .pyc compilado
self.h = gtk.HPaned()
self.tree = FileViewer(".", os.path.basename(f))
self.tree.connect("file-selected", self.open_file)
self.tree.show()
self.h.pack1(self.tree)
self.box.append_page(self.h, gtk.Label("Editor"))
if False: #os.path.isfile("/usr/bin/gvim"):
# Si podemos, lo hacemos
self.socket = gtk.Socket()
self.socket.show()
self.h.pack2(self.socket)
sock_id = str(self.socket.get_id())
self.editor = VimSourceView(sock_id)
if not self.editor.bufInfo.bufferList:
f = JUEGO.__file__
if f.endswith("pyc"):
f = f[:-1]
self.open_file(None, f)
else:
self.editor = SourceView()
scroller = gtk.ScrolledWindow()
scroller.set_policy(gtk.POLICY_AUTOMATIC,
gtk.POLICY_AUTOMATIC)
scroller.add(self.editor)
scroller.show()
self.h.pack2(scroller)
self.editor.show()
self.h.show()
self.open_file(None, f)
def build_toolbar(self):
toolbar_box = ToolbarBox()
self.set_toolbar_box(toolbar_box)
toolbar_box.show()
activity_button = ActivityToolbarButton(self)
toolbar_box.toolbar.insert(activity_button, -1)
activity_button.show()
tool_group = None
self.game_button = RadioToolButton()
self.game_button.props.icon_name = 'gamecanvas'
self.game_button.set_tooltip(_('Juego'))
self.game_button.accelerator = "<Ctrl>1"
self.game_button.props.group = tool_group
self.game_button.connect('clicked', self.show_game)
toolbar_box.toolbar.insert(self.game_button, -1)
self.game_button.show()
tool_group = self.game_button
button = RadioToolButton()
button.props.icon_name = 'view-source'
button.set_tooltip(_('Editor'))
button.accelerator = "<Ctrl>2"
button.props.group = tool_group
button.connect('clicked', self.show_editor)
toolbar_box.toolbar.insert(button, -1)
button.show()
self.save_button = ToolButton('dialog-ok')
self.save_button.set_tooltip(_('Guardar'))
self.save_button.accelerator = "<Ctrl>s"
self.save_button.connect('clicked', self.save_file)
self.save_button.set_sensitive(False)
toolbar_box.toolbar.insert(self.save_button, -1)
self.save_button.show()
separator = gtk.SeparatorToolItem()
toolbar_box.toolbar.insert(separator, -1)
separator.show()
button = ToolButton('system-restart')
button.set_tooltip(_('Reiniciar juego'))
button.accelerator = "<Alt><Shift>r"
button.connect('clicked', self.restart_game)
toolbar_box.toolbar.insert(button, -1)
button.show()
self.editor_button = ToolButton('sources')
self.editor_button.set_tooltip(_('Consola'))
self.editor_button.accelerator = "<Ctrl>grave"
self.editor_button.connect('clicked', self.toggle_console)
toolbar_box.toolbar.insert(self.editor_button, -1)
self.editor_button.show()
separator = gtk.SeparatorToolItem()
toolbar_box.toolbar.insert(separator, -1)
separator.show()
button = helpbutton.HelpButton(self)
toolbar_box.toolbar.insert(button, -1)
button.show()
button = ToolButton()
button.props.icon_name = 'activity-about'
button.set_tooltip(_('Acerca de'))
button.accelerator = "<Ctrl>i"
button.connect('clicked', self.run_credits)
toolbar_box.toolbar.insert(button, -1)
button.show()
# Blank space (separator) and Stop button at the end:
separator = gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
toolbar_box.toolbar.insert(separator, -1)
separator.show()
stop_button = StopButton(self)
toolbar_box.toolbar.insert(stop_button, -1)
stop_button.show()
def run_game(self):
spyral.director.init((0,0), fullscreen=False, max_fps=30)
self.game = JUEGO.Game(activity=self)
self.box.connect("switch-page", self.redraw)
spyral.director.push(self.game)
self.start()
def run_credits(self, widget):
if not (spyral.director.get_scene()==self.credits):
self.credits = game.credits.Creditos(self.game.size)
spyral.director.push(self.credits)
def start(self):
#try:
spyral.director.run(sugar = True)
#except AttributeError as detail:
# detail2 = traceback.format_exc()
# self.box.set_page(0)
# self.alert( detail2, "Spyral se ha detenido abruptamente.", 60)
def show_game(self, widget):
self.box.set_page(1)
self.redraw()
def show_editor(self, widget):
if not self.editor:
self.build_editor()
self.box.set_page(2)
self.redraw()
def restart_game(self, widget):
global JUEGO
import objetos
try:
objetos.reset()
except AttributeError:
pass
self.show_game(None)
watch = gtk.gdk.Cursor(gtk.gdk.WATCH)
self.window.set_cursor(watch)
JUEGO = reload(JUEGO)
self.game = JUEGO.Game(activity=self)
spyral.director.replace(self.game)
self.start()
def game_ready(self, widget = None):
self.game_button.set_active(True)
self.box.set_page(1)
self._pygamecanvas.grab_focus()
self.window.set_cursor(None)
def read_file(self, file_path):
pass
def write_file(self, file_path):
pass
def can_close(self):
if self.editor:
self.editor.close()
self.box.set_page(0)
try:
spyral.director.quit()
except spyral.exceptions.GameEndException:
pass
finally:
return True
def toggle_console(self, e):
if self._interpreter.props.visible:
self._interpreter.hide()
self._pygamecanvas.grab_focus()
else:
self.p.set_position(160)
self._interpreter.show()
self._interpreter.text.grab_focus()
self.redraw()
def animate_console(self):
easing = spyral.easing.Linear(0,160)
self.p.set_position(0)
class ActionButtons():
''' This class manages the action buttons that move among toolsbars '''
def __init__(self, parent):
self._main_toolbar = parent.get_toolbar_box().toolbar
self._main_area = parent._main_area
self._erase_button = parent.edit_toolbar.erase_button
self._sw = parent._sw
if HASTOOLBARBOX:
target_toolbar = self._main_toolbar
else:
target_toolbar = self.parent.edit_toolbar
self._mods = RadioToolButton(named_icon='select-mode')
self._mods.set_tooltip(_('Select thoughts'))
self._mods.set_group(parent.btn_group)
self._mods.set_accelerator(_('<ctrl>e'))
self._mods.connect('clicked', parent.mode_cb, MMapArea.MODE_NULL)
target_toolbar.insert(self._mods, -1)
self._link_button = RadioToolButton(named_icon='link')
self._link_button.set_tooltip(_('Link/unlink two selected thoughts'))
self._link_button.set_group(parent.btn_group)
self._link_button.set_accelerator(_('<ctrl>l'))
self._link_button.connect('clicked', self.__link_cb)
target_toolbar.insert(self._link_button, -1)
self.move_button = RadioToolButton(named_icon='move')
self.move_button.set_tooltip(_('Move selected thoughs'))
self.move_button.set_group(parent.btn_group)
self.move_button.set_accelerator(_('<ctrl>m'))
self.move_button.connect('clicked', self.__move_cb)
target_toolbar.insert(self.move_button, -1)
self.drag_button = RadioToolButton(named_icon='drag')
self.drag_button.set_tooltip(_('Scroll the screen'))
self.drag_button.set_group(parent.btn_group)
self.drag_button.connect('clicked', self.__drag_cb)
target_toolbar.insert(self.drag_button, -1)
if HASTOOLBARBOX:
self._separator_2 = gtk.SeparatorToolItem()
self._separator_2.props.draw = False
# self._separator_2.set_size_request(0, -1)
self._separator_2.set_expand(True)
self._separator_2.show()
target_toolbar.insert(self._separator_2, -1)
self._stop_button = StopButton(parent)
target_toolbar.insert(self._stop_button, -1)
def stop_dragging(self):
if self._main_area.is_dragging():
self._main_area.drag_menu_cb(self._sw, False)
def _stop_moving(self):
self._main_area.move_mode = False
def __link_cb(self, widget):
self._stop_moving()
self.stop_dragging()
self._main_area.link_menu_cb()
def __move_cb(self, widget):
self.stop_dragging()
if self._main_area.move_mode:
self._main_area.stop_moving()
else:
self._main_area.start_moving(self.move_button)
self._erase_button.set_sensitive(False)
def __drag_cb(self, widget):
# If we were moving, stop
self._stop_moving()
if not self._main_area.is_dragging():
self._main_area.drag_menu_cb(self._sw, True)
else:
self.stop_dragging()
self._erase_button.set_sensitive(False)
def reconfigure(self):
''' If screen width has changed, we may need to reconfigure
the toolbars '''
if not HASTOOLBARBOX:
return
if hasattr(self, '_separator_2'):
if gtk.gdk.screen_width() / 13 > style.GRID_CELL_SIZE:
if self._separator_2.get_parent() is None:
self._main_toolbar.remove(self._stop_button)
self._main_toolbar.insert(self._separator_2, -1)
self._main_toolbar.insert(self._stop_button, -1)
else:
self._main_toolbar.remove(self._separator_2)
class SensorToolbar(gtk.Toolbar):
""" The toolbar for specifiying the sensor: sound, resitance, or
voltage """
LOWER = 0.0
UPPER = 1.0
STR_DC_R = (
_(
"Resistive sensor (connect sensor to pink 'Mic In' on left side \
of XO)"
)
+ " "
)
STR_DC_V = (
_(
"Voltage sensor (connect sensor to pink 'Mic In' on left side \
of XO)"
)
+ " "
)
STR_AC = _("Sound") + " "
STR_RESISTANCE = _("Resistance") + " (" + _("Ohms") + ") "
STR_VOLTAGE = _("Voltage") + " (" + _("Volts") + ") "
STR_TIME = _("Time Base") + " "
STR_FREQUENCY = _("Frequency Base") + " "
STR_INVERT = " " + _("Invert") + " "
STR_XAXIS_TEXT = _("X Axis Scale: 1 division = %(division)s %(unit)s")
# TRANSLATORS: This is milli seconds.
MS = _("ms")
# TRANSLATORS: This is Hertz, so 1/second.
HZ = _("Hz")
def __init__(self, activity, channels):
""" By default, start with resistance mode """
gtk.Toolbar.__init__(self)
self.activity = activity
self._channels = channels
self._lock_radio_buttons = False
self._radio_button_pushed = False
self.values = []
for i in range(self._channels):
self.values.append("")
self.string_for_textbox = ""
self.gain = 1.0
self.y_mag = 3.0
self.capture_gain = CAPTURE_GAIN
self.mic_boost = MIC_BOOST
self.mode = "sound"
# Set up Time-domain Button
self.time = RadioToolButton(group=None)
self.time.set_named_icon("media-audio")
self.insert(self.time, -1)
self.time.set_tooltip(_("Sound"))
self.time.connect("clicked", self.analog_resistance_voltage_mode_cb, "sound")
# Set up Resistance Button
self.resistance = RadioToolButton(group=self.time)
self.resistance.set_named_icon("resistance")
if _is_xo(self.activity.hw):
self.insert(self.resistance, -1)
self.resistance.show()
self.resistance.set_tooltip(_("Resistance Sensor"))
self.resistance.connect("clicked", self.analog_resistance_voltage_mode_cb, "resistance")
# Set up Voltage Button
self.voltage = RadioToolButton(group=self.time)
self.voltage.set_named_icon("voltage")
if _is_xo(self.activity.hw):
self.insert(self.voltage, -1)
self.voltage.set_tooltip(_("Voltage Sensor"))
self.voltage.connect("clicked", self.analog_resistance_voltage_mode_cb, "voltage")
separator = gtk.SeparatorToolItem()
separator.props.draw = True
self.insert(separator, -1)
self._log_value = LOG_TIMER_VALUES[1]
self.log_label = gtk.Label(self._log_to_string(self._log_value))
toolitem = gtk.ToolItem()
toolitem.add(self.log_label)
self.insert(toolitem, -1)
self._log_button = ToolButton("timer-10")
self._log_button.set_tooltip(_("Select logging interval"))
self._log_button.connect("clicked", self._log_selection_cb)
self.insert(self._log_button, -1)
self._setup_log_palette()
# Set up Logging/Stop Logging Button
self._record = ToolButton("media-record")
self.insert(self._record, -1)
self._record.set_tooltip(_("Start logging"))
self._record.connect("clicked", self.record_control_cb)
separator = gtk.SeparatorToolItem()
separator.props.draw = True
self.insert(separator, -1)
toolitem = gtk.ToolItem()
self.trigger_label = gtk.Label(_("Trigger"))
toolitem.add(self.trigger_label)
self.insert(toolitem, -1)
# Set up Trigger Combo box
self.trigger_none = RadioToolButton()
self.trigger_none.set_named_icon("trigger-none")
self.insert(self.trigger_none, -1)
self.trigger_none.set_tooltip(_("None"))
self.trigger_none.connect("clicked", self.update_trigger_control_cb, self.activity.wave.TRIGGER_NONE)
self.trigger_rise = RadioToolButton(group=self.trigger_none)
self.trigger_rise.set_named_icon("trigger-rise")
self.insert(self.trigger_rise, -1)
self.trigger_rise.set_tooltip(_("Rising Edge"))
self.trigger_rise.connect("clicked", self.update_trigger_control_cb, self.activity.wave.TRIGGER_POS)
self.trigger_fall = RadioToolButton(group=self.trigger_none)
self.trigger_fall.set_named_icon("trigger-fall")
self.insert(self.trigger_fall, -1)
self.trigger_fall.set_tooltip(_("Falling Edge"))
self.trigger_fall.connect("clicked", self.update_trigger_control_cb, self.activity.wave.TRIGGER_NEG)
self.show_all()
def get_log(self):
return self._log_value
def get_log_idx(self):
if self._log_value in LOG_TIMER_VALUES:
return LOG_TIMER_VALUES.index(self._log_value)
else:
return LOG_TIMER_VALUES[0]
def set_log_idx(self, idx):
self._log_value = LOG_TIMER_VALUES[idx]
self.log_label.set_text(self._log_to_string(self._log_value))
if hasattr(self, "_log_button"):
self._log_button.set_icon("timer-%d" % (self._log_value))
def _log_selection_cb(self, widget):
if self._log_palette:
if not self._log_palette.is_up():
self._log_palette.popup(immediate=True, state=self._log_palette.SECONDARY)
else:
self._log_palette.popdown(immediate=True)
return
def _log_to_seconds(self, tenth_seconds):
return tenth_seconds / 10.0
def _log_to_string(self, tenth_seconds):
if tenth_seconds in LOG_TIMER_LABELS:
return LOG_TIMER_LABELS[tenth_seconds]
else:
return _("1 second")
def _setup_log_palette(self):
self._log_palette = self._log_button.get_palette()
for tenth_seconds in LOG_TIMER_VALUES:
text = self._log_to_string(tenth_seconds)
menu_item = MenuItem(icon_name="timer-%d" % (tenth_seconds), text_label=self._log_to_string(tenth_seconds))
menu_item.connect("activate", self._log_selected_cb, tenth_seconds)
self._log_palette.menu.append(menu_item)
menu_item.show()
def _log_selected_cb(self, button, seconds):
self.set_log_idx(LOG_TIMER_VALUES.index(seconds))
def add_frequency_slider(self, toolbox):
""" Either on the Sound toolbar or the Main toolbar """
self._freq_stepper_up = ToolButton("freq-high")
self._freq_stepper_up.set_tooltip(_("Zoom out"))
self._freq_stepper_up.connect("clicked", self._freq_stepper_up_cb)
self._freq_stepper_up.show()
self.activity.adjustmentf = gtk.Adjustment(0.5, self.LOWER, self.UPPER, 0.01, 0.1, 0)
self.activity.adjustmentf.connect("value_changed", self.cb_page_sizef)
self._freq_range = gtk.HScale(self.activity.adjustmentf)
self._freq_range.set_inverted(True)
self._freq_range.set_draw_value(False)
self._freq_range.set_update_policy(gtk.UPDATE_CONTINUOUS)
self._freq_range.set_size_request(120, 15)
self._freq_range.show()
self._freq_stepper_down = ToolButton("freq-low")
self._freq_stepper_down.set_tooltip(_("Zoom in"))
self._freq_stepper_down.connect("clicked", self._freq_stepper_down_cb)
self._freq_stepper_down.show()
self._freq_range_tool = gtk.ToolItem()
self._freq_range_tool.add(self._freq_range)
self._freq_range_tool.show()
toolbox.add(self._freq_stepper_up)
toolbox.add(self._freq_range_tool)
toolbox.add(self._freq_stepper_down)
return
def update_trigger_control_cb(self, button, value):
if button is None:
value = self.activity.wave.TRIGGER_NONE
if self.activity.wave.get_fft_mode():
self.trigger_none.set_active(True)
else:
self.activity.wave.set_trigger(value)
def analog_resistance_voltage_mode_cb(self, button=None, mode_to_set="sound"):
""" Callback for Analog/Resistance/Voltage Buttons """
if self._lock_radio_buttons:
logging.debug("mode selector locked")
self._radio_button_pushed = True
return
if self.mode == mode_to_set:
logging.debug("mode already set to %s" % mode_to_set)
return
self._lock_radio_buttons = True
if self.activity.CONTEXT == "sound":
self.sound_context_off()
else:
self.sensor_context_off()
# Force time domain when switching modes
if self.activity.wave.get_fft_mode():
self.activity.timefreq_control()
# Turn off logging when switching modes
if self.activity.audiograb.we_are_logging:
self.record_control_cb()
self.set_mode(mode_to_set)
if mode_to_set == "sound":
self.set_sound_context()
elif mode_to_set == "resistance":
self.set_sensor_context()
elif mode_to_set == "voltage":
self.set_sensor_context()
self.update_string_for_textbox()
return False
def unlock_radio_buttons(self):
""" Enable radio button selection """
logging.debug("unlocking radio buttons")
if self._radio_button_pushed:
if self.mode == "sound":
self.time.set_active(True)
elif self.mode == "resistance":
self.resistance.set_active(True)
elif self.mode == "voltage":
self.voltage.set_active(True)
self._lock_radio_buttons = False
self._radio_button_pushed = False
def set_mode(self, mode="sound"):
""" Set the mixer settings to match the current mode. """
self.mode = mode
self.activity.audiograb.set_sensor_type(self.mode)
for i in range(self._channels):
self.values[i] = 0.0
return
def get_mode(self):
""" Get the mixer settings. """
return self.mode
def _freq_stepper_up_cb(self, button=None):
""" Moves the horizontal zoom slider to the left one notch,
where one notch is 1/100 of the total range. This correspond
to zooming out as a larger number of Hertz or milliseconds
will be represented by the same space on the screen. """
new_value = self._freq_range.get_value() + (self.UPPER - self.LOWER) / 100.0
if new_value <= self.UPPER:
self._freq_range.set_value(new_value)
else:
self._freq_range.set_value(self.UPPER)
def _freq_stepper_down_cb(self, button=None):
""" Moves the horizontal zoom slider to the right one notch,
where one notch is 1/100 of the total range. This corresponds
to zooming in. """
new_value = self._freq_range.get_value() - (self.UPPER - self.LOWER) / 100.0
if new_value >= self.LOWER:
self._freq_range.set_value(new_value)
else:
self._freq_range.set_value(self.LOWER)
def cb_page_sizef(self, button=None):
""" Callback to scale the frequency range (zoom in and out) """
if self._update_page_size_id:
gobject.source_remove(self._update_page_size_id)
self._update_page_size_id = gobject.timeout_add(250, self.update_page_size)
return True
def update_page_size(self):
""" Set up the scaling of the display. """
self._update_page_size_id = None
new_value = round(self.activity.adjustmentf.value * 100.0) / 100.0
if self.activity.adjustmentf.value != new_value:
self.activity.adjustmentf.value = new_value
return False
time_div = 0.001 * max(self.activity.adjustmentf.value, 0.05)
freq_div = 1000 * max(self.activity.adjustmentf.value, 0.01)
self.activity.wave.set_div(time_div, freq_div)
self.update_string_for_textbox()
return False
def set_sound_context(self):
""" Called when analog sensing is selected """
self.set_show_hide_windows(mode="sound")
gobject.timeout_add(500, self.sound_context_on)
self.activity.CONTEXT = "sound"
def set_sensor_context(self):
""" Called when digital sensing is selected """
self.set_show_hide_windows(mode="sensor")
gobject.timeout_add(500, self.sensor_context_on)
self.activity.CONTEXT = "sensor"
def set_show_hide_windows(self, mode="sound"):
""" Shows the appropriate window identified by the mode """
self.activity.wave.set_context_on()
for i in range(self._channels):
self.activity.side_toolbars[i].set_show_hide(True, mode)
def sensor_context_off(self):
""" Called when a DC sensor is no longer selected """
# self.activity.audiograb.pause_grabbing()
self.activity.audiograb.stop_grabbing()
def sensor_context_on(self):
""" Called when a DC sensor is selected """
self.update_string_for_textbox()
self.activity.wave.set_trigger(self.activity.wave.TRIGGER_NONE)
# self.activity.audiograb.resume_grabbing()
self.activity.audiograb.start_grabbing()
return False
def sound_context_off(self):
""" Called when an analog sensor is no longer selected """
self.gain, self.y_mag = self.activity.wave.get_mag_params()
self.capture_gain = self.activity.audiograb.get_capture_gain()
self.mic_boost = self.activity.audiograb.get_mic_boost()
self.activity.audiograb.stop_grabbing()
def sound_context_on(self):
""" Called when an analog sensor is selected """
self.activity.wave.set_mag_params(self.gain, self.y_mag)
self.update_string_for_textbox()
self.update_trigger_control_cb(None, self.activity.wave.TRIGGER_NONE)
self.activity.audiograb.start_grabbing()
return False
def set_sample_value(self, value="", channel=0):
""" Write a sample value to the textbox. """
gtk.threads_enter()
self.values[channel] = value
self.update_string_for_textbox()
gtk.threads_leave()
return
def record_control_cb(self, button=None):
""" Depending upon the selected interval, does either a logging
session, or just logs the current buffer. """
if self.activity.audiograb.we_are_logging:
self.activity.audiograb.set_logging_params(start_stop=False)
self._record.set_icon("media-record")
self._record.show()
self._record.set_tooltip(_("Start Recording"))
else:
Xscale = 1.00 / self.activity.audiograb.get_sampling_rate()
Yscale = 0.0
interval = self._log_value / 10.0 # self.interval_convert()
username = self.activity.nick
if self.activity.wave.get_fft_mode():
self.activity.data_logger.start_new_session(
username,
Xscale,
Yscale,
self._log_to_string(self._log_value),
channels=self._channels,
mode="frequency",
)
else:
self.activity.data_logger.start_new_session(
username,
Xscale,
Yscale,
self._log_to_string(self._log_value),
channels=self._channels,
mode=self.mode,
)
self.activity.audiograb.set_logging_params(start_stop=True, interval=interval, screenshot=False)
self._record.set_icon("record-stop")
self._record.show()
self._record.set_tooltip(_("Stop Recording"))
self.activity.new_recording = True
def update_string_for_textbox(self):
""" Update the status field at the bottom of the canvas. """
if self.mode == "resistance":
string_for_textbox = self.STR_DC_R + "\n"
string_for_textbox += self.STR_RESISTANCE
elif self.mode == "voltage":
string_for_textbox = self.STR_DC_V + "\n"
string_for_textbox += self.STR_VOLTAGE
else:
string_for_textbox = self.STR_AC + "\t"
if self.activity.wave.get_fft_mode():
scalex = self.STR_XAXIS_TEXT % {"unit": self.HZ, "division": self.activity.wave.freq_div}
string_for_textbox += self.STR_FREQUENCY
string_for_textbox += "\n" + scalex
elif self.mode == "sound":
scalex = self.STR_XAXIS_TEXT % {"unit": self.MS, "division": self.activity.wave.time_div * 1000}
string_for_textbox += self.STR_TIME
string_for_textbox += "\n" + scalex
else:
for i in range(self._channels):
string_for_textbox += "\t(%s)" % (self.values[i])
invert = False
for i in range(self._channels):
if self.activity.wave.get_invert_state(channel=i):
invert = True
if invert:
string_for_textbox += self.STR_INVERT
self.activity.text_box.set_label(string_for_textbox)
def __init__(self, handle):
activity.Activity.__init__(self, handle, True)
self.max_participants = 1
# CHART_OPTIONS
self.x_label = ""
self.y_label = ""
self.chart_color = utils.get_user_fill_color('str')
self.chart_line_color = utils.get_user_stroke_color('str')
self.current_chart = None
self.charts_area = None
self.chart_data = []
# TOOLBARS
toolbarbox = ToolbarBox()
activity_button = ActivityToolbarButton(self)
activity_btn_toolbar = activity_button.page
activity_btn_toolbar.title.connect('changed', self._set_chart_title)
save_as_image = ToolButton("save-as-image")
save_as_image.connect("clicked", self._save_as_image)
save_as_image.set_tooltip(_("Save as image"))
activity_btn_toolbar.insert(save_as_image, -1)
save_as_image.show()
import_stopwatch = ToolButton("import-stopwatch")
import_stopwatch.connect("clicked", self.__import_stopwatch_cb)
import_stopwatch.set_tooltip(_("Read StopWatch data"))
activity_btn_toolbar.insert(import_stopwatch, -1)
import_stopwatch.show()
import_measure = ToolButton("import-measure")
import_measure.set_tooltip(_("Read Measure data"))
if utils.get_channels() == 1:
import_measure.connect("clicked", self.__import_measure_cb, 1)
else:
import_measure.connect("clicked", self._measure_btn_clicked)
self._create_measure_palette(import_measure)
activity_btn_toolbar.insert(import_measure, -1)
import_measure.show()
activity_btn_toolbar.keep.hide()
toolbarbox.toolbar.insert(activity_button, 0)
add_v = ToolButton("row-insert")
add_v.connect("clicked", self._add_value)
add_v.set_tooltip(_("Add a value"))
toolbarbox.toolbar.insert(add_v, -1)
remove_v = ToolButton("row-remove")
remove_v.connect("clicked", self._remove_value)
remove_v.set_tooltip(_("Remove the selected value"))
toolbarbox.toolbar.insert(remove_v, -1)
separator = gtk.SeparatorToolItem()
separator.set_draw(True)
separator.set_expand(False)
toolbarbox.toolbar.insert(separator, -1)
add_vbar_chart = RadioToolButton()
add_vbar_chart.connect("clicked", self._add_chart_cb, "vbar")
add_vbar_chart.set_tooltip(_("Vertical Bar Chart"))
add_vbar_chart.props.icon_name = "vbar"
charts_group = add_vbar_chart
toolbarbox.toolbar.insert(add_vbar_chart, -1)
add_hbar_chart = RadioToolButton()
add_hbar_chart.connect("clicked", self._add_chart_cb, "hbar")
add_hbar_chart.set_tooltip(_("Horizontal Bar Chart"))
add_hbar_chart.props.icon_name = "hbar"
add_hbar_chart.props.group = charts_group
toolbarbox.toolbar.insert(add_hbar_chart, -1)
add_line_chart = RadioToolButton()
add_line_chart.connect("clicked", self._add_chart_cb, "line")
add_line_chart.set_tooltip(_("Line Chart"))
add_line_chart.props.icon_name = "line"
add_line_chart.props.group = charts_group
toolbarbox.toolbar.insert(add_line_chart, -1)
add_pie_chart = RadioToolButton()
add_pie_chart.connect("clicked", self._add_chart_cb, "pie")
add_pie_chart.set_tooltip(_("Pie Chart"))
add_pie_chart.props.icon_name = "pie"
add_pie_chart.props.group = charts_group
add_pie_chart.set_active(True)
toolbarbox.toolbar.insert(add_pie_chart, -1)
self.chart_type_buttons = [
add_vbar_chart, add_hbar_chart, add_line_chart, add_pie_chart
]
separator = gtk.SeparatorToolItem()
separator.set_draw(True)
separator.set_expand(False)
toolbarbox.toolbar.insert(separator, -1)
options_button = ToolbarButton(icon_name='preferences-system')
options_toolbar = gtk.Toolbar()
self.chart_color_btn = ColorToolButton()
self.chart_color_btn.set_color(_COLOR1)
self.chart_color_btn.set_title(_("Chart Color"))
self.chart_color_btn.connect('notify::color', self._set_chart_color)
options_toolbar.insert(self.chart_color_btn, -1)
self.line_color_btn = ColorToolButton()
self.line_color_btn.set_color(_COLOR2)
self.line_color_btn.set_title(_("Line Color"))
self.line_color_btn.connect('notify::color',
self._set_chart_line_color)
options_toolbar.insert(self.line_color_btn, -1)
separator = gtk.SeparatorToolItem()
separator.set_draw(True)
separator.set_expand(False)
options_toolbar.insert(separator, -1)
h_label_icon = Icon(icon_name="hlabel")
h_label_tool_item = gtk.ToolItem()
h_label_tool_item.add(h_label_icon)
options_toolbar.insert(h_label_tool_item, -1)
self.h_label = Entry(_("Horizontal label..."))
self.h_label.entry.connect("changed", self._set_h_label)
options_toolbar.insert(self.h_label, -1)
separator = gtk.SeparatorToolItem()
separator.set_draw(False)
separator.set_expand(False)
options_toolbar.insert(separator, -1)
v_label_icon = Icon(icon_name="vlabel")
v_label_tool_item = gtk.ToolItem()
v_label_tool_item.add(v_label_icon)
options_toolbar.insert(v_label_tool_item, -1)
self.v_label = Entry(_("Vertical label..."))
self.v_label.entry.connect("changed", self._set_v_label)
options_toolbar.insert(self.v_label, -1)
options_button.props.page = options_toolbar
options_toolbar.show_all()
toolbarbox.toolbar.insert(options_button, -1)
separator = gtk.SeparatorToolItem()
separator.set_draw(True)
separator.set_expand(False)
toolbarbox.toolbar.insert(separator, -1)
fullscreen_btn = ToolButton('view-fullscreen')
fullscreen_btn.set_tooltip(_('Fullscreen'))
fullscreen_btn.connect("clicked", self.__fullscreen_cb)
toolbarbox.toolbar.insert(fullscreen_btn, -1)
separator = gtk.SeparatorToolItem()
separator.set_draw(False)
separator.set_expand(True)
toolbarbox.toolbar.insert(separator, -1)
simplegraphhelp.create_help(toolbarbox.toolbar)
stopbtn = StopButton(self)
toolbarbox.toolbar.insert(stopbtn, -1)
self.set_toolbar_box(toolbarbox)
# CANVAS
paned = gtk.HPaned()
box = gtk.VBox()
self.box = box
# Set the info box width to 1/3 of the screen:
def size_allocate_cb(widget, allocation):
paned.disconnect(self._setup_handle)
box_width = allocation.width / 3
box.set_size_request(box_width, -1)
self._setup_handle = paned.connect('size_allocate', size_allocate_cb)
scroll = gtk.ScrolledWindow()
scroll.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
self.labels_and_values = ChartData(self)
scroll.add(self.labels_and_values)
self.labels_and_values.connect("label-changed", self._label_changed)
self.labels_and_values.connect("value-changed", self._value_changed)
box.pack_start(scroll, True, True, 0)
paned.add1(box)
# CHARTS AREA
eventbox = gtk.EventBox()
self.charts_area = ChartArea(self)
self.charts_area.connect('size_allocate', self._chart_size_allocate)
eventbox.modify_bg(gtk.STATE_NORMAL, _WHITE)
eventbox.add(self.charts_area)
paned.add2(eventbox)
self.set_canvas(paned)
self.show_all()
class LybnizActivity(activity.Activity):
def write_file(self, file_path):
x, y, w, h = self.graph.drawing_area.get_allocation()
pix_buffer = gtk.gdk.Pixbuf(gtk.gdk.COLORSPACE_RGB, False, 8, w, h)
pix_buffer.get_from_drawable(self.graph.pix_map, self.graph.pix_map.get_colormap(), 0, 0, 0, 0, w, h)
pix_buffer.save(file_path, "png")
def parameter_entries_repopulate(self):
# set text in entries for parameters
self.y1_entry.set_text(y1)
self.y2_entry.set_text(y2)
self.y3_entry.set_text(y3)
self.x_min_entry.set_text(str(self.graph.x_min))
self.x_max_entry.set_text(str(self.graph.x_max))
self.x_scale_entry.set_text(str(self.graph.x_scale))
self.y_min_entry.set_text(str(self.graph.y_min))
self.y_max_entry.set_text(str(self.graph.y_max))
self.y_scale_entry.set_text(str(self.graph.y_scale))
def zoom_in(self, widget, event=None):
"Narrow the plotted section by half"
center_x = (self.graph.x_min + self.graph.x_max) / 2
center_y = (self.graph.y_min + self.graph.y_max) / 2
range_x = (self.graph.x_max - self.graph.x_min)
range_y = (self.graph.y_max - self.graph.y_min)
self.graph.x_min = center_x - (range_x / 4)
self.graph.x_max = center_x + (range_x / 4)
self.graph.y_min = center_y - (range_y / 4)
self.graph.y_max = center_y +(range_y / 4)
self.parameter_entries_repopulate()
self.graph.plot()
def zoom_out(self, widget, event=None):
"Double the plotted section"
center_x = (self.graph.x_min + self.graph.x_max) / 2
center_y = (self.graph.y_min + self.graph.y_max) / 2
range_x = (self.graph.x_max - self.graph.x_min)
range_y = (self.graph.y_max - self.graph.y_min)
self.graph.x_min = center_x - (range_x)
self.graph.x_max = center_x + (range_x)
self.graph.y_min = center_y - (range_y)
self.graph.y_max = center_y +(range_y)
self.parameter_entries_repopulate()
self.graph.plot()
def zoom_reset(self, widget, event=None):
"Set the range back to the user's input"
self.graph.x_min = eval(x_min,{"__builtins__":{}},safe_dict)
self.graph.y_min = eval(y_min,{"__builtins__":{}},safe_dict)
self.graph.x_max = eval(x_max,{"__builtins__":{}},safe_dict)
self.graph.y_max = eval(y_max,{"__builtins__":{}},safe_dict)
self.x_min_entry.set_text(self.x_min)
self.x_max_entry.set_text(self.x_max)
self.x_scale_entry.set_text(self.x_scale)
self.y_min_entry.set_text(self.y_min)
self.y_max_entry.set_text(self.y_max)
self.y_scale_entry.set_text(self.y_scale)
self.graph.plot()
def evaluate(self, widget, event=None):
"Evaluate a given x for the three functions"
def entry_changed(widget):
for e in ((y1, dlg_win.y1_entry), (y2, dlg_win.y2_entry), (y3, dlg_win.y3_entry)):
try:
x = float(dlg_win.x_entry.get_text())
safe_dict['x']=x
e[1].set_text(str(eval(e[0].replace("^","**"),{"__builtins__":{}},safe_dict)))
except:
if len(e[0]) > 0:
e[1].set_text("Error: %s" % sys.exc_value)
else:
e[1].set_text("")
def close(self):
dlg_win.destroy()
dlg_win = gtk.Window(gtk.WINDOW_TOPLEVEL)
dlg_win.set_position(gtk.WIN_POS_CENTER)
dlg_win.set_title(_("Evaluate"))
dlg_win.connect("destroy", close)
dlg_win.x_entry = gtk.Entry()
dlg_win.x_entry.set_editable(True)
dlg_win.x_entry.connect("changed", entry_changed)
dlg_win.y1_entry = gtk.Entry()
dlg_win.y1_entry.set_size_request(200, 24)
dlg_win.y1_entry.set_sensitive(False)
dlg_win.y2_entry = gtk.Entry()
dlg_win.y2_entry.set_size_request(200, 24)
dlg_win.y2_entry.set_sensitive(False)
dlg_win.y3_entry = gtk.Entry()
dlg_win.y3_entry.set_size_request(200, 24)
dlg_win.y3_entry.set_sensitive(False)
table = gtk.Table(2, 5)
label = gtk.Label("x = ")
label.set_alignment(0, .5)
table.attach(label, 0, 1, 0, 1, xpadding=5, ypadding=5, xoptions=gtk.FILL)
table.attach(dlg_win.x_entry, 1, 2, 0, 1)
label = gtk.Label("y1 = ")
label.set_alignment(0, .5)
label.modify_fg(gtk.STATE_NORMAL, gtk.gdk.color_parse("blue"))
table.attach(label, 0, 1, 1, 2, xpadding=5, ypadding=5, xoptions=gtk.FILL)
table.attach(dlg_win.y1_entry, 1, 2, 1, 2)
label = gtk.Label("y2 = ")
label.set_alignment(0, .5)
label.modify_fg(gtk.STATE_NORMAL, gtk.gdk.color_parse("red"))
table.attach(label, 0, 1, 2, 3, xpadding=5, ypadding=5, xoptions=gtk.FILL)
table.attach(dlg_win.y2_entry, 1, 2, 2, 3)
label = gtk.Label("y3 = ")
label.set_alignment(0, .5)
label.modify_fg(gtk.STATE_NORMAL, gtk.gdk.color_parse("DarkGreen"))
table.attach(label, 0, 1, 3, 4, xpadding=5, ypadding=5, xoptions=gtk.FILL)
table.attach(dlg_win.y3_entry, 1, 2, 3, 4)
table.set_border_width(24)
dlg_win.add(table)
dlg_win.show_all()
def plot(self, widget, event=None):
global x_max, x_min, x_scale, y_max, y_min, y_scale, y1, y2, y3
x_max = self.x_max_entry.get_text()
x_min = self.x_min_entry.get_text()
x_scale = self.x_scale_entry.get_text()
y_max = self.y_max_entry.get_text()
y_min = self.y_min_entry.get_text()
y_scale = self.y_scale_entry.get_text()
self.graph.x_max = eval(x_max,{"__builtins__":{}},safe_dict)
self.graph.x_min = eval(x_min,{"__builtins__":{}},safe_dict)
self.graph.x_scale = eval(x_scale,{"__builtins__":{}},safe_dict)
self.graph.y_max = eval(y_max,{"__builtins__":{}},safe_dict)
self.graph.y_min = eval(y_min,{"__builtins__":{}},safe_dict)
self.graph.y_scale = eval(y_scale,{"__builtins__":{}},safe_dict)
y1 = self.y1_entry.get_text()
y2 = self.y2_entry.get_text()
y3 = self.y3_entry.get_text()
self.graph.plot()
def toggle_connect(self, widget, event=None):
"Toggle between a graph that connects points with lines and one that does not"
global connect_points
connect_points = not connect_points
self.graph.plot()
def scale_dec(self, widget, event=None):
self.graph.scale_style = "dec"
self.scale_box.hide()
self.plot(None)
def scale_rad(self, widget, event=None):
self.graph.scale_style = "rad"
self.scale_box.hide()
self.plot(None)
def scale_cust(self, widget, event=None):
self.graph.scale_style = "cust"
self.scale_box.show()
self.plot(None)
def __init__(self, handle):
activity.Activity.__init__(self, handle)
self.y1 = y1
self.y2 = y2
self.y3 = y3
self.x_max = x_max
self.x_min = x_min
self.x_scale = x_scale
self.y_max = y_max
self.y_min = y_min
self.y_scale = y_scale
if have_toolbox:
self.toolbar_box = ToolbarBox()
self.activity_button = ActivityToolbarButton(self)
self.activity_button.page.share.hide()
self.toolbar_box.toolbar.insert(self.activity_button, 0)
self.activity_button.show()
self.graph_item = ToolbarButton()
self.graph_item.props.icon_name = 'graph'
else:
self.toolbox = activity.ActivityToolbox(self)
activity_toolbar = self.toolbox.get_activity_toolbar()
activity_toolbar.share.props.visible = False
self.graph_toolbar = gtk.Toolbar()
if have_toolbox:
self.graph_item.props.page = self.graph_toolbar
else:
self.toolbox.add_toolbar(_('Graph'), self.graph_toolbar)
self.plot_item = ToolButton('gtk-refresh')
self.plot_item.props.tooltip = _("Plot")
self.plot_item.connect("clicked", self.plot)
self.plot_item.show()
self.graph_toolbar.insert(self.plot_item, 0)
self.evaluate_item = ToolButton('evaluate')
self.evaluate_item.props.tooltip = _('Evaluate')
self.evaluate_item.connect("clicked", self.evaluate)
self.evaluate_item.show()
self.graph_toolbar.insert(self.evaluate_item, -1)
separator = gtk.SeparatorToolItem()
separator.show()
self.graph_toolbar.insert(separator, -1)
self.zoom_in_item = ToolButton('zoom-in')
self.zoom_in_item.props.tooltip = _('Zoom In')
self.zoom_in_item.connect("clicked", self.zoom_in)
self.zoom_in_item.show()
self.graph_toolbar.insert(self.zoom_in_item, -1)
self.zoom_out_item = ToolButton('zoom-out')
self.zoom_out_item.props.tooltip = _('Zoom Out')
self.zoom_out_item.connect("clicked", self.zoom_out)
self.zoom_out_item.show()
self.graph_toolbar.insert(self.zoom_out_item, -1)
self.zoom_reset_item = ToolButton('zoom-original')
self.zoom_reset_item.props.tooltip = _('Zoom Reset')
self.zoom_reset_item.connect("clicked", self.zoom_reset)
self.zoom_reset_item.show()
self.graph_toolbar.insert(self.zoom_reset_item, -1)
separator = gtk.SeparatorToolItem()
separator.show()
self.graph_toolbar.insert(separator, -1)
self.connect_points_item = ToggleToolButton('connect-points')
self.connect_points_item.set_tooltip(_("Connect Points"))
self.connect_points_item.set_active(True)
self.connect_points_item.connect("toggled", self.toggle_connect)
self.connect_points_item.show()
self.graph_toolbar.insert(self.connect_points_item, -1)
separator = gtk.SeparatorToolItem()
separator.show()
self.graph_toolbar.insert(separator, -1)
self.decimal_item = RadioToolButton()
self.decimal_item.set_named_icon('decimal')
self.decimal_item.set_tooltip(_("Decimal Scale Style"))
self.decimal_item.connect("toggled", self.scale_dec)
self.decimal_item.show()
self.graph_toolbar.insert(self.decimal_item, -1)
self.radians_item = RadioToolButton()
self.radians_item.set_named_icon('radian')
self.radians_item.set_tooltip(_("Radians Scale Style"))
self.radians_item.set_group(self.decimal_item)
self.radians_item.connect("toggled", self.scale_rad)
self.radians_item.show()
self.graph_toolbar.insert(self.radians_item, -1)
self.custom_item = RadioToolButton()
self.custom_item.set_named_icon('custom')
self.custom_item.set_tooltip(_("Custom Scale Style"))
self.custom_item.set_group(self.radians_item)
self.custom_item.connect("toggled", self.scale_cust)
self.custom_item.show()
self.graph_toolbar.insert(self.custom_item, -1)
self.graph_toolbar.show()
if have_toolbox:
self.graph_item.show()
self.toolbar_box.toolbar.insert(self.graph_item, -1)
separator = gtk.SeparatorToolItem()
separator.set_draw(False)
separator.set_expand(True)
separator.show()
self.toolbar_box.toolbar.insert(separator, -1)
self.stop = StopButton(self)
self.stop.show()
self.toolbar_box.toolbar.insert(self.stop, -1)
self.set_toolbar_box(self.toolbar_box)
self.toolbar_box.show()
else:
self.toolbox.show()
self.set_toolbox(self.toolbox)
self.v_box = gtk.VBox()
self.set_canvas(self.v_box)
self.parameter_entries = gtk.Table(6, 3)
self.y1_entry = gtk.Entry()
self.y2_entry = gtk.Entry()
self.y3_entry = gtk.Entry()
self.x_min_entry = gtk.Entry()
self.x_min_entry.set_size_request(90, 24)
self.x_min_entry.set_alignment(1)
self.x_max_entry = gtk.Entry()
self.x_max_entry.set_size_request(90, 24)
self.x_max_entry.set_alignment(1)
self.x_scale_entry = gtk.Entry()
self.x_scale_entry.set_size_request(90, 24)
self.x_scale_entry.set_alignment(1)
self.y_min_entry = gtk.Entry()
self.y_min_entry.set_size_request(90, 24)
self.y_min_entry.set_alignment(1)
self.y_max_entry = gtk.Entry()
self.y_max_entry.set_size_request(90, 24)
self.y_max_entry.set_alignment(1)
self.y_scale_entry = gtk.Entry()
self.y_scale_entry.set_size_request(90, 24)
self.y_scale_entry.set_alignment(1)
self.y1_entry.set_text(self.y1)
self.y2_entry.set_text(self.y2)
self.y3_entry.set_text(self.y3)
self.x_min_entry.set_text(self.x_min)
self.x_max_entry.set_text(self.x_max)
self.x_scale_entry.set_text(self.x_scale)
self.y_min_entry.set_text(self.y_min)
self.y_max_entry.set_text(self.y_max)
self.y_scale_entry.set_text(self.y_scale)
self.scale_box = gtk.HBox()
label = gtk.Label("y1 = ")
label.set_alignment(0, .5)
label.modify_fg(gtk.STATE_NORMAL, gtk.gdk.color_parse("blue"))
self.parameter_entries.attach(label, 0, 1, 0, 1, xpadding=5, ypadding=5, xoptions=gtk.FILL)
self.parameter_entries.attach(self.y1_entry, 1, 2, 0, 1)
label = gtk.Label(_("X min"))
label.set_alignment(1, .5)
self.parameter_entries.attach(label, 2, 3, 0, 1, xpadding=5, ypadding=7, xoptions=gtk.FILL)
self.parameter_entries.attach(self.x_min_entry, 3, 4, 0, 1, xoptions=gtk.FILL)
label = gtk.Label(_("Y min"))
label.set_alignment(1, .5)
self.parameter_entries.attach(label, 4, 5, 0, 1, xpadding=5, ypadding=5, xoptions=gtk.FILL)
self.parameter_entries.attach(self.y_min_entry, 5, 6, 0, 1, xpadding=5, xoptions=gtk.FILL)
label = gtk.Label("y2 = ")
label.set_alignment(0, .5)
label.modify_fg(gtk.STATE_NORMAL, gtk.gdk.color_parse("red"))
self.parameter_entries.attach(label, 0, 1, 1, 2, xpadding=5, ypadding=5, xoptions=gtk.FILL)
self.parameter_entries.attach(self.y2_entry, 1, 2, 1, 2)
label = gtk.Label(_("X max"))
label.set_alignment(1, .5)
self.parameter_entries.attach(label, 2, 3, 1, 2, xpadding=5, ypadding=7, xoptions=gtk.FILL)
self.parameter_entries.attach(self.x_max_entry, 3, 4, 1, 2, xoptions=gtk.FILL)
label = gtk.Label(_("Y max"))
label.set_alignment(1, .5)
self.parameter_entries.attach(label, 4, 5, 1, 2, xpadding=5, ypadding=5, xoptions=gtk.FILL)
self.parameter_entries.attach(self.y_max_entry, 5, 6, 1, 2, xpadding=5, xoptions=gtk.FILL)
label = gtk.Label("y3 = ")
label.set_alignment(0, .5)
label.modify_fg(gtk.STATE_NORMAL, gtk.gdk.color_parse("DarkGreen"))
self.parameter_entries.attach(label, 0, 1, 2, 3, xpadding=5, ypadding=5, xoptions=gtk.FILL)
self.parameter_entries.attach(self.y3_entry, 1, 2, 2, 3)
label = gtk.Label(_("X scale"))
label.set_alignment(0, .5)
self.scale_box.add(label)
self.scale_box.add(self.x_scale_entry)
label = gtk.Label(_("Y scale"))
label.set_alignment(0, .5)
self.scale_box.add(label)
self.scale_box.add(self.y_scale_entry)
self.parameter_entries.attach(self.scale_box, 2, 6, 2, 3, xpadding=5, xoptions=gtk.FILL)
self.v_box.pack_start(self.parameter_entries, False, True, 4)
self.parameter_entries.show_all()
self.graph = GraphClass(self)
self.v_box.pack_start(self.graph.drawing_area, True, True, 0)
self.status_bar = gtk.Statusbar()
self.status_bar.ContextId = self.status_bar.get_context_id("Dummy")
self.status_bar.show()
self.v_box.pack_end(self.status_bar, False, True, 0)
self.v_box.show_all()
def __init__(self, handle):
activity.Activity.__init__(self, handle, True)
self.max_participants = 1
# CHART_OPTIONS
self.x_label = ""
self.y_label = ""
self.chart_color = utils.get_user_fill_color('str')
self.chart_line_color = utils.get_user_stroke_color('str')
self.current_chart = None
self.charts_area = None
self.chart_data = []
# TOOLBARS
toolbarbox = ToolbarBox()
activity_button = ActivityToolbarButton(self)
activity_btn_toolbar = activity_button.page
activity_btn_toolbar.title.connect('changed', self._set_chart_title)
save_as_image = ToolButton("save-as-image")
save_as_image.connect("clicked", self._save_as_image)
save_as_image.set_tooltip(_("Save as image"))
activity_btn_toolbar.insert(save_as_image, -1)
save_as_image.show()
toolbarbox.toolbar.insert(activity_button, 0)
import_freespace = ToolButton("import-freespace")
import_freespace.connect("clicked", self.__import_freespace_cb)
import_freespace.set_tooltip(_("Read Freespace data"))
toolbarbox.toolbar.insert(import_freespace, -1)
import_freespace.show()
import_journal = ToolButton('import-journal')
import_journal.connect('clicked', self.__import_journal_cb)
import_journal.set_tooltip(_('Read Journal data'))
toolbarbox.toolbar.insert(import_journal, -1)
import_journal.show()
import_turtle = ToolButton('import-turtle')
import_turtle.connect('clicked', self.__import_turtle_cb)
import_turtle.set_tooltip(_('Read Turtle data'))
toolbarbox.toolbar.insert(import_turtle, -1)
import_turtle.show()
separator = gtk.SeparatorToolItem()
separator.set_draw(True)
separator.set_expand(False)
toolbarbox.toolbar.insert(separator, -1)
add_vbar_chart = RadioToolButton()
add_vbar_chart.connect("clicked", self._add_chart_cb, "vbar")
add_vbar_chart.set_tooltip(_("Vertical Bar Chart"))
add_vbar_chart.props.icon_name = "vbar"
charts_group = add_vbar_chart
toolbarbox.toolbar.insert(add_vbar_chart, -1)
add_hbar_chart = RadioToolButton()
add_hbar_chart.connect("clicked", self._add_chart_cb, "hbar")
add_hbar_chart.set_tooltip(_("Horizontal Bar Chart"))
add_hbar_chart.props.icon_name = "hbar"
add_hbar_chart.props.group = charts_group
toolbarbox.toolbar.insert(add_hbar_chart, -1)
add_pie_chart = RadioToolButton()
add_pie_chart.connect("clicked", self._add_chart_cb, "pie")
add_pie_chart.set_tooltip(_("Pie Chart"))
add_pie_chart.props.icon_name = "pie"
add_pie_chart.props.group = charts_group
add_pie_chart.set_active(True)
toolbarbox.toolbar.insert(add_pie_chart, -1)
self.chart_type_buttons = [
add_vbar_chart, add_hbar_chart, add_pie_chart
]
separator = gtk.SeparatorToolItem()
separator.set_draw(True)
separator.set_expand(False)
toolbarbox.toolbar.insert(separator, -1)
fullscreen_btn = ToolButton('view-fullscreen')
fullscreen_btn.set_tooltip(_('Fullscreen'))
fullscreen_btn.connect("clicked", self.__fullscreen_cb)
toolbarbox.toolbar.insert(fullscreen_btn, -1)
charthelp.create_help(toolbarbox.toolbar)
separator = gtk.SeparatorToolItem()
separator.set_draw(False)
separator.set_expand(True)
toolbarbox.toolbar.insert(separator, -1)
stopbtn = StopButton(self)
toolbarbox.toolbar.insert(stopbtn, -1)
self.set_toolbar_box(toolbarbox)
# CANVAS
paned = gtk.HPaned()
box = gtk.VBox()
self.box = box
# Set the info box width to 1/3 of the screen:
def size_allocate_cb(widget, allocation):
paned.disconnect(self._setup_handle)
box_width = allocation.width / 3
box.set_size_request(box_width, -1)
self._setup_handle = paned.connect('size_allocate', size_allocate_cb)
scroll = gtk.ScrolledWindow()
scroll.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
self.labels_and_values = ChartData(self)
scroll.add(self.labels_and_values)
self.labels_and_values.connect("label-changed", self._label_changed)
self.labels_and_values.connect("value-changed", self._value_changed)
box.pack_start(scroll, True, True, 0)
paned.add1(box)
# CHARTS AREA
eventbox = gtk.EventBox()
self.charts_area = ChartArea(self)
self.charts_area.connect('size_allocate', self._chart_size_allocate)
eventbox.modify_bg(gtk.STATE_NORMAL, _WHITE)
eventbox.add(self.charts_area)
paned.add2(eventbox)
self.set_canvas(paned)
self.show_all()
def build_toolbar(self):
toolbar_box = ToolbarBox()
self.set_toolbar_box(toolbar_box)
toolbar_box.show()
activity_button = ActivityToolbarButton(self)
toolbar_box.toolbar.insert(activity_button, -1)
activity_button.show()
tool_group = None
self.game_button = RadioToolButton()
self.game_button.props.icon_name = 'gamecanvas'
self.game_button.set_tooltip(_('Juego'))
self.game_button.accelerator = "<Ctrl>1"
self.game_button.props.group = tool_group
self.game_button.connect('clicked', self.show_game)
toolbar_box.toolbar.insert(self.game_button, -1)
self.game_button.show()
tool_group = self.game_button
button = RadioToolButton()
button.props.icon_name = 'view-source'
button.set_tooltip(_('Editor'))
button.accelerator = "<Ctrl>2"
button.props.group = tool_group
button.connect('clicked', self.show_editor)
toolbar_box.toolbar.insert(button, -1)
button.show()
self.save_button = ToolButton('dialog-ok')
self.save_button.set_tooltip(_('Guardar'))
self.save_button.accelerator = "<Ctrl>s"
self.save_button.connect('clicked', self.save_file)
self.save_button.set_sensitive(False)
toolbar_box.toolbar.insert(self.save_button, -1)
self.save_button.show()
separator = gtk.SeparatorToolItem()
toolbar_box.toolbar.insert(separator, -1)
separator.show()
button = ToolButton('system-restart')
button.set_tooltip(_('Reiniciar juego'))
button.accelerator = "<Alt><Shift>r"
button.connect('clicked', self.restart_game)
toolbar_box.toolbar.insert(button, -1)
button.show()
self.editor_button = ToolButton('sources')
self.editor_button.set_tooltip(_('Consola'))
self.editor_button.accelerator = "<Ctrl>grave"
self.editor_button.connect('clicked', self.toggle_console)
toolbar_box.toolbar.insert(self.editor_button, -1)
self.editor_button.show()
separator = gtk.SeparatorToolItem()
toolbar_box.toolbar.insert(separator, -1)
separator.show()
button = helpbutton.HelpButton(self)
toolbar_box.toolbar.insert(button, -1)
button.show()
button = ToolButton()
button.props.icon_name = 'activity-about'
button.set_tooltip(_('Acerca de'))
button.accelerator = "<Ctrl>i"
button.connect('clicked', self.run_credits)
toolbar_box.toolbar.insert(button, -1)
button.show()
# Blank space (separator) and Stop button at the end:
separator = gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
toolbar_box.toolbar.insert(separator, -1)
separator.show()
stop_button = StopButton(self)
toolbar_box.toolbar.insert(stop_button, -1)
stop_button.show()
class TagStar(gtk.HBox):
"""
A L{gtk.HBox} which arranges togglebuttons around the current position
within a L{gtk.Fixed} widget.
This is the central tag element, where a user can either tag his current
position with a category specified in L{geotagplugin.ECategory}. If
one of the user's already tagged features is selected in the tree, the
made change action will be handled as an edit.
"""
IMG_SIZE = (100, 100)
BUTTON_SIZE = (100, 100)
EMPTY_LIST_STORE = gtk.ListStore(gobject.TYPE_STRING)
toggled = NONE_CATEGORY # selected category
selected = None # gtk.Image displaying selected category
def __init__(self, toolbar, control):
gtk.HBox.__init__(self)
self._logger = logging.getLogger('TagStar')
self._logger.setLevel(constants.LOG_LEVEL)
self.toolbar = toolbar
self.control = control
self.size_cb = self.connect('size_allocate', self.size_allocate_cb)
self.fixed = gtk.Fixed()
self.pack_start(self.fixed)
self.show_all()
def size_allocate_cb(self, widget, event):
"""
Builds the tag star around the center where the selected
category is shown.
"""
self._logger.debug('size_allocate_cb()')
x, y, width, height = self.fixed.get_allocation()
self._logger.debug('x: %s, y: %s, w: %s, h: %s', x, y, width, height)
self.set_size_request(width, height)
######################################################################
# place togglebuttons around the current position in a radio group
color_fill = profile.get_color().get_fill_color()
color_stroke = profile.get_color().get_stroke_color()
button_width, button_height = self.BUTTON_SIZE
cat_names = get_categories()
radius = 300 # px
x_center = width / 2 - 40
y_center = height / 2 - 40
step_angle = math.radians(360 / (len(cat_names) + 1)) # plus reset btn
# add a reset button
self.reset_selected_btn = RadioToolButton()
img_name = os.path.join(GeoTag.ICONS_PATH, 'reset.svg')
icon = gtk.image_new_from_pixbuf(utils.load_svg_image(img_name,
color_stroke,
color_fill,
self.IMG_SIZE))
self.reset_selected_btn.set_icon_widget(icon)
self.reset_selected_btn.set_tooltip(_('Reset selected tag.'))
self.reset_selected_btn.connect('clicked', self.reset_toggled)
self.reset_selected_btn.show_all()
self.reset_selected_btn.set_size_request(button_width, button_height)
self.fixed.put(self.reset_selected_btn,
x_center, # + int(radius * math.sin(i * step_angle)),
y_center + radius) # + int(radius * math.cos(i * step_angle)))
self.reset_selected_btn.set_active(False)
# read all available categories dynamically
for i, category in enumerate(cat_names):
button = RadioToolButton(group=self.reset_selected_btn)
img_name = os.path.join(GeoTag.ICONS_PATH, category)
icon = get_gtkimage_from_plugin(img_name, color_stroke, color_fill, self.IMG_SIZE)
button.set_icon_widget(icon)
button.set_tooltip(_('Tag some %s.' % category)) # XXX check translation here!!
button.connect('clicked', self.set_toggled, category)
button.show_all()
button.set_size_request(button_width, button_height)
self.fixed.put(button,
x_center + int(radius * math.sin((i + 1) * step_angle)),
y_center + int(radius * math.cos((i + 1) * step_angle)))
button.set_active(False)
img_name = os.path.join(GeoTag.ICONS_PATH, NONE_CATEGORY)
self._set_selected(get_gtkimage_from_plugin(img_name, color_stroke,color_fill, self.IMG_SIZE))
###################################################################
self._logger.debug("size_allocation done")
self.disconnect(self.size_cb) ## use only once
def reset_toggled(self, button):
"""
Resets toggled property and combobox liststore.
@param button: The reset button (can be omitted by passing None).
@note: If a tag was selected within the L{geotagmodel.GeotagModel},
the tag will be deleted.
"""
self.toggled = NONE_CATEGORY
# reset liststore
combo = self.toolbar.combobox
combo.set_model(self.EMPTY_LIST_STORE)
# reset selected widget
color_fill = profile.get_color().get_fill_color()
color_stroke = profile.get_color().get_stroke_color()
self._set_selected(get_gtkimage_from_plugin(NONE_CATEGORY,
color_stroke,
color_fill,
self.IMG_SIZE))
self.reset_selected_btn.set_active(True)
self.selected.queue_draw()
combo.queue_draw()
def set_toggled(self, button, category):
"""
Switches the empty Button and the tagged category button clicked.
Also, sets the appropriate liststore for the combobox.
@param button: Toggled button (can be omittted).
@param category: The corresponding category to set.
"""
self._logger.debug("set_toggled()")
self.toggled = category
# set liststore
combo = self.toolbar.combobox
combo.set_model(self.toolbar.description_sets[category])
color_fill = profile.get_color().get_fill_color()
color_stroke = profile.get_color().get_stroke_color()
# self._logger.debug("storage type: %s", self.selected.get_property("storage-type"))
self._set_selected(get_gtkimage_from_plugin(category,
color_stroke,
color_fill,
self.IMG_SIZE))
combo.queue_draw()
def _set_selected(self, widget):
"""
Sets the widget as the currently selected tag category.
@param widget: The L{gtk.Image} to set.
"""
x, y, width, height = self.fixed.get_allocation()
x_center = width / 2 - 40
y_center = height / 2 - 40
if self.selected:
self.selected.clear()
button_width, button_height = self.BUTTON_SIZE
widget.set_size_request(button_width, button_height)
widget.show_all()
self.selected = widget
self.selected.queue_draw()
self.fixed.put(self.selected, x_center, y_center)
def __init__(self, handle):
activity.Activity.__init__(self, handle)
self.max_participants = 1
# Canvas
canvas = Canvas(self)
self.set_canvas(canvas)
self._download_list = canvas.gtk_list.download_list
# Toolbars
toolbarbox = ToolbarBox()
activity_button = ActivityToolbarButton(self)
toolbarbox.toolbar.insert(activity_button, 0)
separator = gtk.SeparatorToolItem()
separator.set_draw(False)
separator.set_expand(False)
toolbarbox.toolbar.insert(separator, -1)
# Switch
store_list = RadioToolButton()
store_list.set_active(True)
store_list.props.icon_name = 'view-list'
store_list.connect("clicked", canvas.switch_to_list)
store_list.set_tooltip(_("Show the search list"))
toolbarbox.toolbar.insert(store_list, -1)
downloads_list = RadioToolButton()
downloads_list.connect("clicked", canvas.switch_to_downloads_list)
downloads_list.set_tooltip(_("Show the downloads list"))
downloads_list.props.group = store_list
self.downloads_icon = DownloadsIcon()
downloads_list.set_icon_widget(self.downloads_icon)
toolbarbox.toolbar.insert(downloads_list, -1)
self.store_list = store_list
self.downloads_list = downloads_list
separator = gtk.SeparatorToolItem()
separator.set_draw(True)
separator.set_expand(False)
toolbarbox.toolbar.insert(separator, -1)
# Search
search_entry = iconentry.IconEntry()
search_entry.set_size_request(gtk.gdk.screen_width() / 4, -1)
search_entry.set_icon_from_name(iconentry.ICON_ENTRY_PRIMARY,
'system-search')
search_entry.connect('activate', canvas.gtk_list.search)
search_entry.connect('activate', lambda w: canvas.switch_to_list(None))
search_entry.add_clear_button()
search_item = gtk.ToolItem()
search_item.add(search_entry)
toolbarbox.toolbar.insert(search_item, -1)
separator = gtk.SeparatorToolItem()
separator.set_draw(False)
separator.set_expand(True)
toolbarbox.toolbar.insert(separator, -1)
stopbtn = StopButton(self)
toolbarbox.toolbar.insert(stopbtn, -1)
self.set_toolbar_box(toolbarbox)
self.show_all()
canvas.set_page(0)
def __init__(self, handle):
activity.Activity.__init__(self, handle, True)
# ToolbarBox:
toolbarbox = ToolbarBox()
activitybutton = ActivityButton(self)
toolbarbox.toolbar.insert(activitybutton, 0)
separator = gtk.SeparatorToolItem()
toolbarbox.toolbar.insert(separator, -1)
explorer_btn = RadioToolButton()
explorer_btn.set_tooltip('Explorador')
explorer_btn.props.icon_name = 'activity-explorer'
toolbarbox.toolbar.insert(explorer_btn, -1)
self._goup = ToolButton('to-subjects')
self._goup.connect('clicked', self._go_up_clicked)
self._goup.set_tooltip('Ver Materias')
self._goup.set_accelerator("<Shift><M>")
self._goup.set_sensitive(False)
toolbarbox.toolbar.insert(self._goup, -1)
self._select_all = ToolButton('select-all')
self._select_all.set_tooltip('Seleccionar todo')
self._select_all.connect("clicked", self._select_all_clicked)
self._select_all.set_sensitive(False)
toolbarbox.toolbar.insert(self._select_all, -1)
self._download = ToolButton('download')
self._download.set_tooltip('Descargar')
self._download.set_sensitive(False)
toolbarbox.toolbar.insert(self._download, -1)
separator = gtk.SeparatorToolItem()
toolbarbox.toolbar.insert(separator, -1)
homework_btn = RadioToolButton()
homework_btn.set_tooltip('Tareas Domiciliarias')
homework_btn.props.icon_name = 'homework'
homework_btn.props.group = explorer_btn
toolbarbox.toolbar.insert(homework_btn, -1)
open_btn = ToolButton()
open_btn.set_tooltip('Seleccionar tarea')
open_btn.props.icon_name = 'open-from-journal'
open_btn.set_sensitive(False)
open_btn.connect("clicked", self._select_hw_from_journal)
toolbarbox.toolbar.insert(open_btn, -1)
self._send = ToolButton()
self._send.set_tooltip('Enviar tarea')
self._send.connect('clicked', self._send_hw_to_server)
self._send.props.icon_name = 'document-send'
self._send.set_sensitive(False)
toolbarbox.toolbar.insert(self._send, -1)
homework_btn.connect('clicked', self.homework_btn_cb, open_btn)
explorer_btn.connect('clicked', self.explorer_btn_cb, open_btn)
separator = gtk.SeparatorToolItem()
separator.set_expand(True)
separator.set_draw(False)
toolbarbox.toolbar.insert(separator, -1)
stopbtn = StopButton(self)
toolbarbox.toolbar.insert(stopbtn, -1)
self.set_toolbar_box(toolbarbox)
self._one_alert = None
# Canvas
self._canvas = gtk.EventBox()
self._name = ''
self._last_name = ''
self._hw_title = ''
self._hw_description = ''
self._hw_path = ''
self._hw_mimetype = ''
self.set_canvas(self._canvas)
self.show_all()
if not utils.get_group():
self.choose_group()
else:
self._do_canvas()
class GeoToolbar(gtk.Toolbar):
"""
Tools which interacts with the currently chosen view.
This toolbar is meant general: General map tools can be enabled. The
toolbar serves as controller. Because you use a specific geo you have
to wire specific functionality to the common tools offered by this toolbar.
Tools you may want to enable:
=========== ==========================
enable_goto_current_position
User wants to center map over current
position.
toggle_crosslines
User wants to show crosslines.
navigation
User wants to navigate the map. Includes
buttons for NESW.
zoom-in
User wants to zoom-in the current map view.
zoom-out
User wants to zoom-out the current map view.
zoom-bestfit
User wants to zoom-in the current map view.
=========== ==========================
Enable one of these tools by calling the appropriate method with your
custom callback method before adding the toolbar to the toolbox.
"""
title = _('Map tools')
radio_show_own_pos_btn = None
radio_show_all_pos_btn = None
def __init__(self, view, name=None):
"""
Creates general toolbar where general map tools can be enabled.
@param name: The name of the toolbar.
"""
gtk.Toolbar.__init__(self)
self.set_property('can-focus', False)
self.view = view
if name:
self.name = name
self._logger = logging.getLogger(name)
else:
self._logger = logging.getLogger('geo.GeoToolbar')
self._logger.setLevel(constants.LOG_LEVEL)
# remove predefined key bindings
gtk.binding_entry_remove(self, gtk.keysyms.Left, 0)
gtk.binding_entry_remove(self, gtk.keysyms.Right, 0)
gtk.binding_entry_remove(self, gtk.keysyms.Up, 0)
gtk.binding_entry_remove(self, gtk.keysyms.Down, 0)
gtk.binding_entry_remove(self, gtk.keysyms.plus, 0)
gtk.binding_entry_remove(self, gtk.keysyms.minus, 0)
self.callbacks = {}
self.connect('key-press-event', self.key_pressed_cb, self.callbacks)
self.show_no_positions = RadioToolButton()
icon_name = os.path.join(constants.ICON_PATH, "show-no-positions.svg")
icon = utils.load_svg_image(icon_name, None, None, BTN_ICON_SIZE)
img = gtk.image_new_from_pixbuf(icon)
self.show_no_positions.set_icon_widget(img)
self.show_no_positions.set_tooltip(_('Show no players.'))
def enable_show_own_position(self, view):
"""
Shows the only the own position on the map.
"""
self.radio_show_own_pos_btn = RadioToolButton(group=self.show_no_positions)
(fill, stroke) = ('#ffffff', '#000000') # black/white explicit
buddy_icon = utils.get_xo_icon(stroke, fill, BTN_ICON_SIZE)
img = gtk.image_new_from_pixbuf(buddy_icon)
self.radio_show_own_pos_btn.set_icon_widget(img)
self.radio_show_own_pos_btn.set_tooltip(_('Show only me.'))
self.radio_show_own_pos_btn.connect('clicked', view.radio_show_own_position_cb)
self.insert(self.radio_show_own_pos_btn, -1)
self.radio_show_own_pos_btn.show_all()
if self.radio_show_all_pos_btn:
self.show_no_positions.connect("clicked", view.radio_show_no_positions_cb)
self.show_no_positions.show_all()
self.insert(self.show_no_positions, -1)
def enable_show_all_positions(self, view):
"""
Shows the position of all players participating the game.
"""
self.radio_show_all_pos_btn = RadioToolButton(group=self.show_no_positions)
icon_name = os.path.join(constants.ICON_PATH , 'show-all-players.svg')
icon = utils.load_svg_image(icon_name, None, None, BTN_ICON_SIZE)
img = gtk.image_new_from_pixbuf(icon)
self.radio_show_all_pos_btn.set_icon_widget(img)
self.radio_show_all_pos_btn.set_tooltip(_('Show all players.'))
self.radio_show_all_pos_btn.connect('clicked', view.radio_show_all_position_cb)
self.insert(self.radio_show_all_pos_btn, -1)
self.radio_show_all_pos_btn.show_all()
if self.radio_show_own_pos_btn:
self.show_no_positions.connect("clicked", view.radio_show_no_positions_cb)
self.show_no_positions.show_all()
self.insert(self.show_no_positions, -1)
self.radio_show_all_pos_btn.set_active(True)
def enable_center_current_position(self, on_center_on_current_position):
"""
Enables tool to set the map center to current lon/lat position.
@param on_goto_current_position: The callback function to be called when
user wants to center the map to current position.
"""
goto_current_pos_btn = ToggleToolButton('goto-current-pos')
goto_current_pos_btn.set_tooltip(_('Center map on my position.'))
goto_current_pos_btn.connect('clicked', on_center_on_current_position)
goto_current_pos_btn.set_active(GeoCanvas._CENTER_MAP)
goto_current_pos_btn.show()
self.insert(goto_current_pos_btn, -1)
def enable_toggle_crosslines(self, view):
"""
Enables tool to toggle crosslines.
@param view: The view for which the crosslines shall be displayed.
"""
toggle_crossline_btn = ToggleToolButton('toggle-crosslines')
toggle_crossline_btn.set_tooltip(_('Show crossline.'))
toggle_crossline_btn.set_active(GeoCanvas._CROSSLINES)
toggle_crossline_btn.connect('clicked', view.toggle_crossline_cb)
toggle_crossline_btn.show()
self.insert(toggle_crossline_btn, -1)
def enable_zoom(self, zoom_callbacks):
"""
Enables tools to zoom the map via buttons.
@param zoom_callbacks: A dict containing zoom callbacks:
=========== =============
zoom_callbacks['zoom_in'] A callback to zoom in
zoom_callbacks['zoom_out'] A callback to zoom out
=========== =============
"""
self.zoom_in_btn = ToolButton('zoom-in')
self.zoom_in_btn.set_tooltip(_('Zoom in.'))
self.zoom_in_btn.connect('clicked', zoom_callbacks['zoom_in'])
self.zoom_in_btn.show()
self.insert(self.zoom_in_btn, -1)
self.zoom_out_btn = ToolButton('zoom-out')
self.zoom_out_btn.set_tooltip(_('Zoom out.'))
self.zoom_out_btn.connect('clicked', zoom_callbacks['zoom_out'])
self.zoom_out_btn.show()
self.insert(self.zoom_out_btn, -1)
self.callbacks.update(zoom_callbacks)
def enable_zoom_bestfit(self, on_zoom_bestfit):
"""
Enables zoom-to-best-fit support on this toolbar.
@param on_zoom_bestfit: The callback function to be called when user
wants to zoom to best extent.
"""
zoom_best_fit_btn = ToolButton('zoom-best-fit')
zoom_best_fit_btn.set_tooltip(_('Zoom best fitting extent.'))
zoom_best_fit_btn.connect('clicked', on_zoom_bestfit)
zoom_best_fit_btn.show()
self.insert(zoom_best_fit_btn, -1)
def enable_navigation(self, nav_callbacks):
"""
Enables tools to navigate the map via buttons.
@param nav_callbacks: A dict containing navigation callbacks:
=========== =============
nav_callbacks['west'] A callback to step west
nav_callbacks['north'] A callback to step north
nav_callbacks['south'] A callback to step south
nav_callbacks['east'] A callback to step east
=========== =============
"""
self._enable_step_west(nav_callbacks['west'])
self._enable_step_north(nav_callbacks['north'])
self._enable_step_south(nav_callbacks['south'])
self._enable_step_east(nav_callbacks['east'])
self.callbacks.update(nav_callbacks)
def enable_custom_Button(self, button):
"""
Inserts a custom button to the map toolbar.
Consider to use it only, if it does not make much sense to place
the button in its own toolbar (e.g. if there will be only one
button, which might an extra toolbar dispensable).
"""
self.insert(button, -1)
def key_pressed_cb(self, widget, event, callbacks):
"""
Callback handles all incoming keyevents and calls the appropriate
callback-method.
"""
keyname = gtk.gdk.keyval_name(event.keyval)
#self._logger.debug('\'%s\' key pressed' % keyname)
if(keyname in ['KP_Up']): # up
self.set_focus_child(self.step_north_btn)
callbacks['north'](None)
elif(keyname in ['KP_Down']): # down
self.set_focus_child(self.step_south_btn)
callbacks['south'](None)
elif(keyname in ['KP_Left']): #left
self.set_focus_child(self.step_west_btn)
callbacks['west'](None)
elif(keyname in ['KP_Right']): #right
self.set_focus_child(self.step_east_btn)
callbacks['east'](None)
elif(keyname in ['plus', 'KP_Add', 'KP_Page_Up']): # zoom in
self.set_focus_child(self.zoom_in_btn)
callbacks['zoom_in'](None)
elif(keyname in ['minus', 'KP_Substract', 'KP_Page_Down']): # zoom out
self.set_focus_child(self.zoom_out_btn)
callbacks['zoom_out'](None)
if self.view._CROSSLINES:
self.view.motion_crosslines(self.view.fixed)
def _enable_step_north(self, on_step_north):
"""
Enables button to step north.
@param on_step_north: The callback function to be called when the user
wants to step north.
"""
self.step_north_btn = ToolButton('step-north')
self.step_north_btn.set_tooltip(_('Move North.'))
self.step_north_btn.connect('clicked', on_step_north)
self.step_north_btn.show()
self.insert(self.step_north_btn, -1)
def _enable_step_east(self, on_step_east):
"""
Enables button to step east.
@param on_step_east: The callback function to be called when the user
wants to step east.
"""
self.step_east_btn = ToolButton('step-east')
self.step_east_btn.set_tooltip(_('Move East.'))
self.step_east_btn.connect('clicked', on_step_east)
self.step_east_btn.show()
self.insert(self.step_east_btn, -1)
def _enable_step_south(self, on_step_south):
"""
Enables button to step south.
@param on_step_south: The callback function to be called when the user
wants to step south.
"""
self.step_south_btn = ToolButton('step-south')
self.step_south_btn.set_tooltip(_('Move South.'))
self.step_south_btn.connect('clicked', on_step_south)
self.step_south_btn.show()
self.insert(self.step_south_btn, -1)
def _enable_step_west(self, on_step_west):
"""
Enables button to step west.
@param on_step_west: The callback function to be called when the user
wants to step west.
"""
self.step_west_btn = ToolButton('step-west')
self.step_west_btn.set_tooltip(_('Move West.'))
self.step_west_btn.connect('clicked', on_step_west)
self.step_west_btn.show()
self.insert(self.step_west_btn, -1)
def build_toolbar(self):
toolbar_box = ToolbarBox()
self.set_toolbar_box(toolbar_box)
toolbar_box.show()
activity_button = ActivityToolbarButton(self)
toolbar_box.toolbar.insert(activity_button, -1)
activity_button.show()
tool_group = None
self.game_button = RadioToolButton()
self.game_button.props.icon_name = 'gamecanvas'
self.game_button.set_tooltip(_('Juego'))
self.game_button.accelerator = "<Ctrl>1"
self.game_button.props.group = tool_group
self.game_button.connect('clicked', self.show_game)
toolbar_box.toolbar.insert(self.game_button, -1)
self.game_button.show()
tool_group = self.game_button
button = RadioToolButton()
button.props.icon_name = 'view-source'
button.set_tooltip(_('Editor'))
button.accelerator = "<Ctrl>2"
button.props.group = tool_group
button.connect('clicked', self.show_editor)
toolbar_box.toolbar.insert(button, -1)
button.show()
self.save_button = ToolButton('dialog-ok')
self.save_button.set_tooltip(_('Guardar'))
self.save_button.accelerator = "<Ctrl>s"
self.save_button.connect('clicked', self.save_file)
self.save_button.set_sensitive(False)
toolbar_box.toolbar.insert(self.save_button, -1)
self.save_button.show()
separator = gtk.SeparatorToolItem()
toolbar_box.toolbar.insert(separator, -1)
separator.show()
button = ToolButton('system-restart')
button.set_tooltip(_('Reiniciar juego'))
button.accelerator = "<Alt><Shift>r"
button.connect('clicked', self.restart_game)
toolbar_box.toolbar.insert(button, -1)
button.show()
self.editor_button = ToolButton('sources')
self.editor_button.set_tooltip(_('Consola'))
self.editor_button.accelerator = "<Ctrl>grave"
self.editor_button.connect('clicked', self.toggle_console)
toolbar_box.toolbar.insert(self.editor_button, -1)
self.editor_button.show()
separator = gtk.SeparatorToolItem()
toolbar_box.toolbar.insert(separator, -1)
separator.show()
button = helpbutton.HelpButton(self)
toolbar_box.toolbar.insert(button, -1)
button.show()
button = ToolButton()
button.props.icon_name = 'activity-about'
button.set_tooltip(_('Acerca de'))
button.accelerator = "<Ctrl>i"
button.connect('clicked', self.run_credits)
toolbar_box.toolbar.insert(button, -1)
button.show()
# Blank space (separator) and Stop button at the end:
separator = gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
toolbar_box.toolbar.insert(separator, -1)
separator.show()
stop_button = StopButton(self)
toolbar_box.toolbar.insert(stop_button, -1)
stop_button.show()
class ConvertActivity(activity.Activity):
def __init__(self, handle):
activity.Activity.__init__(self, handle, True)
self.max_participants = 1
self.dic = {}
# Canvas
self._canvas = gtk.VBox()
hbox = gtk.HBox()
self._liststore1 = gtk.ListStore(str)
self.combo1 = gtk.ComboBox(self._liststore1)
cell = gtk.CellRendererText()
self.combo1.pack_start(cell, True)
self.combo1.add_attribute(cell, 'markup', 0)
self.combo1.connect('changed', self._call)
flip_btn = gtk.Button()
flip_btn.connect('clicked', self._flip)
flip_btn.add(gtk.image_new_from_file('icons/flip.svg'))
self._liststore2 = gtk.ListStore(str)
self.combo2 = gtk.ComboBox(self._liststore1)
cell = gtk.CellRendererText()
self.combo2.pack_start(cell, True)
self.combo2.add_attribute(cell, 'markup', 0)
self.combo2.connect('changed', self._call)
self.label_box = gtk.HBox()
self.adjustment = gtk.Adjustment(1.0, 0.0000000001, 10.0**20.0, 0.1,
1.0)
self.spin = gtk.SpinButton(self.adjustment, 0.0, 2)
self.label = gtk.Label()
self.label.set_selectable(True)
self.label._size = 12
self.label.connect('expose-event', self.resize_label)
self.convert_btn = gtk.Button(_('Convert'))
self.convert_btn.connect('clicked', self._call)
self._canvas.pack_start(hbox, False, False, 20)
hbox.pack_start(self.combo1, False, True, 20)
hbox.pack_start(flip_btn, True, False)
hbox.pack_end(self.combo2, False, True, 20)
spin_box = gtk.HBox()
convert_box = gtk.HBox()
convert_box.pack_start(spin_box, True, False, 0)
spin_box.pack_start(self.spin, False, False, 0)
self._canvas.pack_start(convert_box, False, False, 5)
self._canvas.pack_start(self.label_box, True, False, 0)
self.label_box.add(self.label)
spin_box.pack_start(self.convert_btn, False, False, 20)
self.set_canvas(self._canvas)
# Toolbar
toolbarbox = ToolbarBox()
activity_button = ActivityToolbarButton(self)
toolbarbox.toolbar.insert(activity_button, 0)
separator = gtk.SeparatorToolItem()
separator.set_expand(False)
separator.set_draw(True)
toolbarbox.toolbar.insert(separator, -1)
# RadioToolButton
self._length_btn = RadioToolButton()
self._length_btn.connect('clicked',
lambda w: self._update_combo(convert.length))
self._length_btn.set_tooltip(_('Length'))
self._length_btn.props.icon_name = 'length'
self._volume_btn = RadioToolButton()
self._volume_btn.connect('clicked',
lambda w: self._update_combo(convert.volume))
self._volume_btn.set_tooltip(_('Volume'))
self._volume_btn.props.icon_name = 'volume'
self._volume_btn.props.group = self._length_btn
self._area_btn = RadioToolButton()
self._area_btn.connect('clicked',
lambda w: self._update_combo(convert.area))
self._area_btn.set_tooltip(_('Area'))
self._area_btn.props.icon_name = 'area'
self._area_btn.props.group = self._length_btn
self._weight_btn = RadioToolButton()
self._weight_btn.connect('clicked',
lambda w: self._update_combo(convert.weight))
self._weight_btn.set_tooltip(_('Weight'))
self._weight_btn.props.icon_name = 'weight'
self._weight_btn.props.group = self._length_btn
self._speed_btn = RadioToolButton()
self._speed_btn.connect('clicked',
lambda w: self._update_combo(convert.speed))
self._speed_btn.set_tooltip(_('Speed'))
self._speed_btn.props.icon_name = 'speed'
self._speed_btn.props.group = self._length_btn
self._time_btn = RadioToolButton()
self._time_btn.connect('clicked',
lambda w: self._update_combo(convert.time))
self._time_btn.set_tooltip(_('Time'))
self._time_btn.props.icon_name = 'time'
self._time_btn.props.group = self._length_btn
self._temp_btn = RadioToolButton()
self._temp_btn.connect('clicked',
lambda w: self._update_combo(convert.temp))
self._temp_btn.set_tooltip(_('Temperature'))
self._temp_btn.props.icon_name = 'temp'
self._temp_btn.props.group = self._length_btn
toolbarbox.toolbar.insert(self._length_btn, -1)
toolbarbox.toolbar.insert(self._volume_btn, -1)
toolbarbox.toolbar.insert(self._area_btn, -1)
toolbarbox.toolbar.insert(self._weight_btn, -1)
toolbarbox.toolbar.insert(self._speed_btn, -1)
toolbarbox.toolbar.insert(self._time_btn, -1)
toolbarbox.toolbar.insert(self._temp_btn, -1)
separator = gtk.SeparatorToolItem()
separator.set_expand(True)
separator.set_draw(False)
toolbarbox.toolbar.insert(separator, -1)
stopbtn = StopButton(self)
toolbarbox.toolbar.insert(stopbtn, -1)
self.set_toolbar_box(toolbarbox)
self._update_combo(convert.length)
self.show_all()
def _update_label(self):
try:
spin_value = str(self.spin.get_value())
decimals = str(len(spin_value.split('.')[-1]))
new_value = locale.format('%.' + decimals + 'f', float(spin_value))
convert_value = str(self.convert())
decimals = str(len(convert_value.split('.')[-1]))
new_convert = locale.format('%.' + decimals + 'f',
float(convert_value))
text = '%s ~ %s' % (new_value, new_convert)
self.label.set_text(text)
except KeyError:
pass
def _call(self, widget=None):
_unit = self._get_active_text(self.combo1)
_to_unit = self._get_active_text(self.combo2)
self._update_label()
self.show_all()
def _update_combo(self, data):
self._liststore1.clear()
self._liststore2.clear()
self.dic = data
keys = self.dic.keys()
keys.sort()
for x in keys:
symbol = ''
if len(self.dic[x]) == 3:
symbol = self.dic[x][-1]
symbol = '<sup><b>%s</b></sup>' % symbol
self._liststore1.append(['%s%s' % (x, symbol)])
self._liststore2.append(['%s%s' % (x, symbol)])
self.combo1.set_active(0)
self.combo2.set_active(0)
self._call()
self.show_all()
def _get_active_text(self, combobox):
active = combobox.get_active()
keys = self.dic.keys()
keys.sort()
if active < 0:
return None
text = keys[active]
if '<sup>' in text:
text = text.split('<b>')[1].split('</b>')[0]
return text
def _flip(self, widget):
active_combo1 = self.combo1.get_active()
active_combo2 = self.combo2.get_active()
self.combo1.set_active(active_combo2)
self.combo2.set_active(active_combo1)
self.spin.set_value(
float(self.label.get_text().split(' ~ ')[1].replace(',', '.')))
self._call()
def resize_label(self, widget, event):
num_label = len(self.label.get_text())
try:
size = str((60 * SCREEN_WIDTH / 100) / num_label)
if not size == self.label._size:
self.label.modify_font(pango.FontDescription(size))
self.label._size = size
except ZeroDivisionError:
pass
def convert(self):
number = float(self.spin.get_text().replace(',', '.'))
unit = self._get_active_text(self.combo1)
to_unit = self._get_active_text(self.combo2)
return convert.convert(number, unit, to_unit, self.dic)
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)
def __init__(self, handle):
activity.Activity.__init__(self, handle, True)
self.max_participants = 1
# CHART_OPTIONS
self.x_label = ""
self.y_label = ""
self.chart_color = utils.get_user_fill_color('str')
self.chart_line_color = utils.get_user_stroke_color('str')
self.current_chart = None
self.charts_area = None
self.chart_data = []
# TOOLBARS
toolbarbox = ToolbarBox()
activity_button = ActivityToolbarButton(self)
activity_btn_toolbar = activity_button.page
activity_btn_toolbar.title.connect('changed', self._set_chart_title)
save_as_image = ToolButton("save-as-image")
save_as_image.connect("clicked", self._save_as_image)
save_as_image.set_tooltip(_("Save as image"))
activity_btn_toolbar.insert(save_as_image, -1)
save_as_image.show()
toolbarbox.toolbar.insert(activity_button, 0)
import_freespace = ToolButton("import-freespace")
import_freespace.connect("clicked", self.__import_freespace_cb)
import_freespace.set_tooltip(_("Read Freespace data"))
toolbarbox.toolbar.insert(import_freespace, -1)
import_freespace.show()
import_journal = ToolButton('import-journal')
import_journal.connect('clicked', self.__import_journal_cb)
import_journal.set_tooltip(_('Read Journal data'))
toolbarbox.toolbar.insert(import_journal, -1)
import_journal.show()
import_turtle = ToolButton('import-turtle')
import_turtle.connect('clicked', self.__import_turtle_cb)
import_turtle.set_tooltip(_('Read Turtle data'))
toolbarbox.toolbar.insert(import_turtle, -1)
import_turtle.show()
separator = gtk.SeparatorToolItem()
separator.set_draw(True)
separator.set_expand(False)
toolbarbox.toolbar.insert(separator, -1)
add_vbar_chart = RadioToolButton()
add_vbar_chart.connect("clicked", self._add_chart_cb, "vbar")
add_vbar_chart.set_tooltip(_("Vertical Bar Chart"))
add_vbar_chart.props.icon_name = "vbar"
charts_group = add_vbar_chart
toolbarbox.toolbar.insert(add_vbar_chart, -1)
add_hbar_chart = RadioToolButton()
add_hbar_chart.connect("clicked", self._add_chart_cb, "hbar")
add_hbar_chart.set_tooltip(_("Horizontal Bar Chart"))
add_hbar_chart.props.icon_name = "hbar"
add_hbar_chart.props.group = charts_group
toolbarbox.toolbar.insert(add_hbar_chart, -1)
add_pie_chart = RadioToolButton()
add_pie_chart.connect("clicked", self._add_chart_cb, "pie")
add_pie_chart.set_tooltip(_("Pie Chart"))
add_pie_chart.props.icon_name = "pie"
add_pie_chart.props.group = charts_group
add_pie_chart.set_active(True)
toolbarbox.toolbar.insert(add_pie_chart, -1)
self.chart_type_buttons = [add_vbar_chart,
add_hbar_chart,
add_pie_chart]
separator = gtk.SeparatorToolItem()
separator.set_draw(True)
separator.set_expand(False)
toolbarbox.toolbar.insert(separator, -1)
fullscreen_btn = ToolButton('view-fullscreen')
fullscreen_btn.set_tooltip(_('Fullscreen'))
fullscreen_btn.connect("clicked", self.__fullscreen_cb)
toolbarbox.toolbar.insert(fullscreen_btn, -1)
charthelp.create_help(toolbarbox.toolbar)
separator = gtk.SeparatorToolItem()
separator.set_draw(False)
separator.set_expand(True)
toolbarbox.toolbar.insert(separator, -1)
stopbtn = StopButton(self)
toolbarbox.toolbar.insert(stopbtn, -1)
self.set_toolbar_box(toolbarbox)
# CANVAS
paned = gtk.HPaned()
box = gtk.VBox()
self.box = box
# Set the info box width to 1/3 of the screen:
def size_allocate_cb(widget, allocation):
paned.disconnect(self._setup_handle)
box_width = allocation.width / 3
box.set_size_request(box_width, -1)
self._setup_handle = paned.connect('size_allocate',
size_allocate_cb)
scroll = gtk.ScrolledWindow()
scroll.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
self.labels_and_values = ChartData(self)
scroll.add(self.labels_and_values)
self.labels_and_values.connect("label-changed", self._label_changed)
self.labels_and_values.connect("value-changed", self._value_changed)
box.pack_start(scroll, True, True, 0)
paned.add1(box)
# CHARTS AREA
eventbox = gtk.EventBox()
self.charts_area = ChartArea(self)
self.charts_area.connect('size_allocate', self._chart_size_allocate)
eventbox.modify_bg(gtk.STATE_NORMAL, _WHITE)
eventbox.add(self.charts_area)
paned.add2(eventbox)
self.set_canvas(paned)
self.show_all()
class Activity(sugar.activity.activity.Activity):
def __init__(self, handle):
super(Activity, self).__init__(handle)
self.paused = False
watch = gtk.gdk.Cursor(gtk.gdk.WATCH)
self.window.set_cursor(watch)
self.p = gtk.VPaned()
self.p.connect("notify::position", self.redraw)
self.box = gtk.Notebook()
self.p.pack2(self.box)
self.p.show()
self.box.set_show_tabs(False)
self.splash = gtk.Image()
pixbuf = gtk.gdk.pixbuf_new_from_file("images/splash_comodo.png")
screen = self.window.get_screen()
width, height = screen.get_width(), screen.get_height() - style.GRID_CELL_SIZE
pixbuf = pixbuf.scale_simple(width, height, gtk.gdk.INTERP_BILINEAR)
self.splash.set_from_pixbuf(pixbuf)
self.splash.show()
eb = gtk.EventBox()
eb.add(self.splash)
eb.modify_bg(gtk.STATE_NORMAL, gtk.gdk.color_parse("white"))
eb.show()
self.box.append_page(eb, gtk.Label("Inicio"))
self._pygamecanvas = sugargame2.canvas.PygameCanvas(self)
self._pygamecanvas.set_flags(gtk.EXPAND)
self._pygamecanvas.set_flags(gtk.FILL)
self.connect("visibility-notify-event", self.redraw)
self._pygamecanvas.set_events(gtk.gdk.BUTTON_PRESS_MASK)
self._pygamecanvas.connect("button-press-event", self._pygamecanvas.grab_focus)
self.box.append_page(self._pygamecanvas, gtk.Label("Juego"))
self.box.show()
self.set_canvas(self.p)
gobject.timeout_add(300, self.pump)
gobject.timeout_add(2000, self.init_interpreter)
#gobject.timeout_add(1000, self.build_editor)
gobject.timeout_add(1500, self.check_modified)
self.build_toolbar()
self.credits = None
self.editor = None
#self.reader = None
self._pygamecanvas.run_pygame(self.run_game)
def redraw(self, widget=None, b=None, c=None):
scene = spyral.director.get_scene()
if scene:
scene.redraw()
def alert(self, title=None, text=None, delay=5):
alert = NotifyAlert(delay)
alert.props.title = title
alert.props.msg = text
self.add_alert(alert)
alert.connect('response', self._alert_ok)
alert.show()
def _alert_ok(self, alert, *args):
self.remove_alert(alert)
def check_modified(self):
if self.box.current_page()==2:
if not self.save_button.get_sensitive():
if self.editor.modificado():
self.save_button.set_sensitive(True)
return False
return True
def pump(self):
# Esto es necesario porque sino pygame acumula demasiados eventos.
pygame.event.pump()
def focus_interpreter(self, widget, event):
self._interpreter.text.grab_focus()
return True
def init_interpreter(self):
# diferido unos segundos para evitar ver errores superfluos al iniciar
self._interpreter = GTKInterpreterConsole(self.redraw)
self._interpreter.text.connect('button-press-event', self.focus_interpreter)
self.p.pack1(self._interpreter)
return False
def open_file(self, widget, path):
if path:
if not os.path.isdir(path):
self.editor.open_file(widget, path)
def save_file(self, widget):
if self.editor.modificado():
self.save_button.set_sensitive(False)
self.editor.save_file()
filename = self.editor.current_file()
self.alert(filename, "Archivo guardado.")
gobject.timeout_add(1500, self.check_modified)
def build_editor(self):
dir_real = os.getcwd()
f = os.path.realpath(JUEGO.__file__)
f = "." + f.replace(dir_real ,"") # todo esto para obtener una ruta relativa
f = f.rstrip("c") # en caso que sea .pyc compilado
self.h = gtk.HPaned()
self.tree = FileViewer(".", os.path.basename(f))
self.tree.connect("file-selected", self.open_file)
self.tree.show()
self.h.pack1(self.tree)
self.box.append_page(self.h, gtk.Label("Editor"))
if False: #os.path.isfile("/usr/bin/gvim"):
# Si podemos, lo hacemos
self.socket = gtk.Socket()
self.socket.show()
self.h.pack2(self.socket)
sock_id = str(self.socket.get_id())
self.editor = VimSourceView(sock_id)
if not self.editor.bufInfo.bufferList:
f = JUEGO.__file__
if f.endswith("pyc"):
f = f[:-1]
self.open_file(None, f)
else:
self.editor = SourceView()
scroller = gtk.ScrolledWindow()
scroller.set_policy(gtk.POLICY_AUTOMATIC,
gtk.POLICY_AUTOMATIC)
scroller.add(self.editor)
scroller.show()
self.h.pack2(scroller)
self.editor.show()
self.h.show()
self.open_file(None, f)
def build_reader(self):
self.reader = webkit.WebView()
curdir = os.getcwd()
self.reader.load_uri("file://%s/docs/index.html" % curdir)
self.box.append_page(self.reader, gtk.Label("Lector"))
self.reader.show()
def build_toolbar(self):
toolbar_box = ToolbarBox()
self.set_toolbar_box(toolbar_box)
toolbar_box.show()
activity_button = ActivityToolbarButton(self)
toolbar_box.toolbar.insert(activity_button, -1)
activity_button.show()
tool_group = None
self.game_button = RadioToolButton()
self.game_button.props.icon_name = 'gamecanvas'
self.game_button.set_tooltip(_('Juego'))
self.game_button.accelerator = "<Ctrl>1"
self.game_button.props.group = tool_group
self.game_button.connect('clicked', self.show_game)
toolbar_box.toolbar.insert(self.game_button, -1)
self.game_button.show()
tool_group = self.game_button
button = RadioToolButton()
button.props.icon_name = 'view-source'
button.set_tooltip(_('Editor'))
button.accelerator = "<Ctrl>2"
button.props.group = tool_group
button.connect('clicked', self.show_editor)
toolbar_box.toolbar.insert(button, -1)
button.show()
self.save_button = ToolButton('dialog-ok')
self.save_button.set_tooltip(_('Guardar'))
self.save_button.accelerator = "<Ctrl>s"
self.save_button.connect('clicked', self.save_file)
self.save_button.set_sensitive(False)
toolbar_box.toolbar.insert(self.save_button, -1)
self.save_button.show()
separator = gtk.SeparatorToolItem()
toolbar_box.toolbar.insert(separator, -1)
separator.show()
button = ToolButton('system-restart')
button.set_tooltip(_('Reiniciar juego'))
button.accelerator = "<Alt><Shift>r"
button.connect('clicked', self.restart_game)
toolbar_box.toolbar.insert(button, -1)
button.show()
self.editor_button = ToolButton('sources')
self.editor_button.set_tooltip(_('Consola'))
self.editor_button.accelerator = "<Ctrl>grave"
self.editor_button.connect('clicked', self.toggle_console)
toolbar_box.toolbar.insert(self.editor_button, -1)
self.editor_button.show()
separator = gtk.SeparatorToolItem()
toolbar_box.toolbar.insert(separator, -1)
separator.show()
button = helpbutton.HelpButton(self)
toolbar_box.toolbar.insert(button, -1)
button.show()
button = ToolButton()
button.props.icon_name = 'activity-about'
button.set_tooltip(_('Acerca de'))
button.accelerator = "<Ctrl>i"
button.connect('clicked', self.run_credits)
toolbar_box.toolbar.insert(button, -1)
button.show()
# Blank space (separator) and Stop button at the end:
separator = gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
toolbar_box.toolbar.insert(separator, -1)
separator.show()
stop_button = StopButton(self)
toolbar_box.toolbar.insert(stop_button, -1)
stop_button.show()
def run_game(self):
spyral.director.init((0,0), fullscreen=False, max_fps=30)
self.game = JUEGO.Juego(self, callback=self.game_ready)
self.box.connect("switch-page", self.redraw)
spyral.director.push(self.game)
self.start()
def run_credits(self, widget):
if not (spyral.director.get_scene()==self.credits):
self.credits = game.credits.Creditos(self.game.size)
spyral.director.push(self.credits)
def start(self):
try:
spyral.director.run(sugar = True)
except AttributeError as detail:
detail2 = traceback.format_exc()
self.box.set_page(0)
self.alert( detail2, "Spyral se ha detenido abruptamente.", 60)
def show_game(self, widget):
self.box.set_page(1)
self.redraw()
def show_editor(self, widget):
if not self.editor:
self.build_editor()
self.box.set_page(2)
self.redraw()
def show_reader(self, widget):
if not self.reader:
self.build_reader()
self.box.set_page(3)
self.redraw()
def restart_game(self, widget):
global JUEGO
import objetos
try:
objetos.reset()
except AttributeError:
pass
self.box.set_page(0)
watch = gtk.gdk.Cursor(gtk.gdk.WATCH)
self.window.set_cursor(watch)
JUEGO = reload(JUEGO)
self.game = JUEGO.Juego(self, callback=self.game_ready)
spyral.director.replace(self.game)
self.start()
def game_ready(self, widget = None):
self.game_button.set_active(True)
self.box.set_page(1)
self._pygamecanvas.grab_focus()
self.window.set_cursor(None)
def read_file(self, file_path):
pass
def write_file(self, file_path):
pass
def can_close(self):
if self.editor:
self.editor.close()
self.box.set_page(0)
try:
spyral.director.quit()
except spyral.exceptions.GameEndException:
pass
finally:
return True
def toggle_console(self, e):
if self._interpreter.props.visible:
self._interpreter.hide()
self._pygamecanvas.grab_focus()
else:
self.p.set_position(160)
self._interpreter.show()
self._interpreter.text.grab_focus()
self.redraw()
def animate_console(self):
easing = spyral.easing.Linear(0,160)
self.p.set_position(0)
class Activity(sugar.activity.activity.Activity):
def __init__(self, handle):
super(Activity, self).__init__(handle)
self.build_toolbar()
self.build_editor()
self.p = gtk.VPaned()
self.set_canvas(self.p)
self.p.pack2(self.h)
self.console = gtk.Notebook()
self.init_interpreter()
self.console.append_page(self.interpreter)
self.p.pack1(self.console)
self.fugit = Fugit(".")
self.console.append_page(self.fugit.widget)
self.show_all()
def alert(self, title=None, text=None, delay=5):
alert = NotifyAlert(delay)
alert.props.title = title
alert.props.msg = text
self.add_alert(alert)
alert.connect('response', self._alert_ok)
alert.show()
def _alert_ok(self, alert, *args):
self.remove_alert(alert)
def init_interpreter(self):
frame = self.get_frame()
self.interpreter = GTKInterpreterConsole(frame)
self.interpreter.text.connect('button-press-event', self.focus_interpreter)
return False
def focus_interpreter(self, widget, event):
self.interpreter.text.grab_focus()
return True
def get_frame(self):
# esto es necesario para que la consola funcione
try:
raise None
except:
frame = sys.exc_info()[2].tb_frame
return frame
def open_file(self, widget, path):
if path:
if not os.path.isdir(path):
self.editor.open_file(widget, path)
def save_file(self, widget):
if self.editor.modificado():
self.editor.save_file()
filename = self.editor.current_file()
self.alert(filename, "Archivo guardado.")
def build_editor(self):
self.h = gtk.HPaned()
self.tree = FileViewer(".")
self.tree.connect("file-selected", self.open_file)
self.tree.show()
self.h.pack1(self.tree)
self.editor = SourceView()
scroller = gtk.ScrolledWindow()
scroller.set_policy(gtk.POLICY_AUTOMATIC,
gtk.POLICY_AUTOMATIC)
scroller.add(self.editor)
self.h.pack2(scroller)
self.h.show_all()
def build_reader(self):
self.reader = webkit.WebView()
curdir = os.getcwd()
self.reader.load_uri("file://%s/docs/index.html" % curdir)
self.box.append_page(self.reader, gtk.Label("Lector"))
self.reader.show()
def build_toolbar(self):
toolbar_box = ToolbarBox()
self.set_toolbar_box(toolbar_box)
toolbar_box.show()
activity_button = ActivityToolbarButton(self)
toolbar_box.toolbar.insert(activity_button, -1)
activity_button.show()
tool_group = None
self.game_button = RadioToolButton()
self.game_button.props.icon_name = 'gamecanvas'
self.game_button.set_tooltip(_('Juego'))
self.game_button.accelerator = "<Ctrl>1"
self.game_button.props.group = tool_group
#self.game_button.connect('clicked', self.show_game)
toolbar_box.toolbar.insert(self.game_button, -1)
self.game_button.show()
tool_group = self.game_button
button = RadioToolButton()
button.props.icon_name = 'view-source'
button.set_tooltip(_('Editor'))
button.accelerator = "<Ctrl>2"
button.props.group = tool_group
#button.connect('clicked', self.show_editor)
toolbar_box.toolbar.insert(button, -1)
button.show()
self.save_button = ToolButton('dialog-ok')
self.save_button.set_tooltip(_('Guardar'))
self.save_button.accelerator = "<Ctrl>s"
self.save_button.connect('clicked', self.save_file)
toolbar_box.toolbar.insert(self.save_button, -1)
self.save_button.show()
separator = gtk.SeparatorToolItem()
toolbar_box.toolbar.insert(separator, -1)
separator.show()
self.editor_button = ToolButton('sources')
self.editor_button.set_tooltip(_('Consola'))
self.editor_button.accelerator = "<Ctrl>grave"
self.editor_button.connect('clicked', self.toggle_console)
toolbar_box.toolbar.insert(self.editor_button, -1)
self.editor_button.show()
separator = gtk.SeparatorToolItem()
toolbar_box.toolbar.insert(separator, -1)
separator.show()
button = helpbutton.HelpButton(self)
toolbar_box.toolbar.insert(button, -1)
button.show()
# Blank space (separator) and Stop button at the end:
separator = gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
toolbar_box.toolbar.insert(separator, -1)
separator.show()
stop_button = StopButton(self)
toolbar_box.toolbar.insert(stop_button, -1)
stop_button.show()
def read_file(self, file_path):
pass
def write_file(self, file_path):
pass
def can_close(self):
if self.editor:
self.editor.close()
return True
def toggle_console(self, e):
if self.console.props.visible:
self.console.hide()
else:
self.p.set_position(160)
self.console.show()
self.console.text.grab_focus()
