def build_toolbar(self):
toolbox = ToolbarBox()
activity_button = ActivityToolbarButton(self)
toolbox.toolbar.insert(activity_button, -1)
activity_button.show()
self.build_calibrate_toolbar(toolbox)
self.build_options_toolbar(toolbox)
self.build_resolution_toolbar(toolbox)
self.build_colors_toolbar(toolbox)
separador13 = gtk.SeparatorToolItem()
separador13.props.draw = False
separador13.set_expand(True)
toolbox.toolbar.insert(separador13, -1)
stop_button = StopButton(self)
stop_button.props.accelerator = _('<Ctrl>Q')
toolbox.toolbar.insert(stop_button, -1)
stop_button.show()
self.set_toolbox(toolbox)
toolbox.show()
self.show_all()
def build_toolbar(self):
toolbar_box = ToolbarBox()
activity_button = ActivityToolbarButton(self)
toolbar_box.toolbar.insert(activity_button, 0)
activity_button.show()
separator = gtk.SeparatorToolItem()
toolbar_box.toolbar.insert(separator, -1)
separator.show()
separator = gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_size_request(0, -1)
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()
self.set_toolbar_box(toolbar_box)
toolbar_box.show_all()
return toolbar_box
def build_toolbar(self):
toolbox = ToolbarBox()
activity_button = ActivityToolbarButton(self)
toolbox.toolbar.insert(activity_button, -1)
activity_button.show()
barra = toolbox.toolbar
"""
separator1 = gtk.SeparatorToolItem()
separator1.props.draw = True
separator1.set_expand(False)
barra.insert(separator1,-1)
save_button = ToolButton('filesave')
save_button.set_tooltip(_('Save Image'))
save_button.connect('clicked', self._savebutton_cb)
barra.insert(save_button, -1)
save_button.show()"""
separator2 = gtk.SeparatorToolItem()
separator2.props.draw = False
separator2.set_expand(True)
barra.insert(separator2, -1)
stop_button = StopButton(self)
stop_button.props.accelerator = '<Ctrl>q'
barra.insert(stop_button, -1)
stop_button.show()
self.set_toolbar_box(toolbox)
toolbox.show_all()
def build_toolbar(self):
"""Build our Activity toolbar for the Sugar system."""
toolbar_box = ToolbarBox()
activity_button = ActivityToolbarButton(self)
toolbar_box.toolbar.insert(activity_button, -1)
activity_button.show()
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()
self.set_toolbar_box(toolbar_box)
toolbar_box.show_all()
self.connect("destroy", self.__stop_pygame)
return toolbar_box
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()
separator = gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(False)
toolbar_box.toolbar.insert(separator, -1)
separator.show()
button = ToolButton('speaker-muted-100')
button.set_tooltip(_('Sound'))
button.connect('clicked', self.sound_control)
toolbar_box.toolbar.insert(button, -1)
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()
self.show_all()
def _setup_toolbars(self, have_toolbox):
""" Setup the toolbars. """
self.max_participants = MAX_HANDS
if have_toolbox:
toolbox = ToolbarBox()
# Activity toolbar
activity_button = ActivityToolbarButton(self)
toolbox.toolbar.insert(activity_button, 0)
activity_button.show()
self.set_toolbar_box(toolbox)
toolbox.show()
self.toolbar = toolbox.toolbar
else:
# Use pre-0.86 toolbar design
games_toolbar = gtk.Toolbar()
toolbox = activity.ActivityToolbox(self)
self.set_toolbox(toolbox)
toolbox.add_toolbar(_('Game'), games_toolbar)
toolbox.show()
toolbox.set_current_toolbar(1)
self.toolbar = games_toolbar
self._new_game_button = button_factory(
'new-game', self.toolbar, self._new_game_cb,
tooltip=_('Start a new game.'))
self.robot_button = button_factory(
'robot-off', self.toolbar, self._robot_cb,
tooltip= _('Play with the robot.'))
self.player = image_factory(
svg_str_to_pixbuf(generate_xo(scale=0.8,
colors=['#303030', '#303030'])),
self.toolbar, tooltip=self.nick)
self.dialog_button = button_factory(
'go-next', self.toolbar, self._dialog_cb,
tooltip=_('Turn complete'))
self.status = label_factory(self.toolbar, '')
self.hint_button = button_factory(
'help-toolbar', self.toolbar, self._hint_cb,
tooltip=_('Help'))
self.score = label_factory(self.toolbar, _('Score: ') + '0')
if _have_toolbox:
separator_factory(toolbox.toolbar, True, False)
stop_button = StopButton(self)
stop_button.props.accelerator = '<Ctrl>q'
toolbox.toolbar.insert(stop_button, -1)
stop_button.show()
def _configure_toolbars(self):
if _USE_OLD_TOOLBARS:
toolbox = ActivityToolbox(self)
toolbar = gtk.Toolbar()
else:
toolbar_box = ToolbarBox()
toolbar = toolbar_box.toolbar
activity_button = ActivityToolbarButton(self)
toolbar_box.toolbar.insert(activity_button, 0)
activity_button.show()
self._add_expander(toolbar_box.toolbar)
toolbar.add(gtk.SeparatorToolItem())
if _USE_OLD_TOOLBARS:
self.set_toolbox(toolbox)
toolbox.show()
else:
stop_button = StopButton(self)
stop_button.props.accelerator = '<Ctrl><Shift>Q'
toolbar_box.toolbar.insert(stop_button, -1)
stop_button.show()
self.set_toolbar_box(toolbar_box)
toolbar_box.show()
def _setup_toolbars(self, have_toolbox):
""" Setup the toolbars. """
self.max_participants = MAX_HANDS
if have_toolbox:
toolbox = ToolbarBox()
# Activity toolbar
activity_button = ActivityToolbarButton(self)
toolbox.toolbar.insert(activity_button, 0)
activity_button.show()
self.set_toolbar_box(toolbox)
toolbox.show()
self.toolbar = toolbox.toolbar
else:
# Use pre-0.86 toolbar design
games_toolbar = gtk.Toolbar()
toolbox = activity.ActivityToolbox(self)
self.set_toolbox(toolbox)
toolbox.add_toolbar(_('Game'), games_toolbar)
toolbox.show()
toolbox.set_current_toolbar(1)
self.toolbar = games_toolbar
self._new_game_button = _button_factory(
'new-game', _('Start a new game.'), self._new_game_cb,
self.toolbar)
self.robot_button = _button_factory(
'robot-off', _('Play with the robot.'), self._robot_cb,
self.toolbar)
self.player = _image_factory(
svg_str_to_pixbuf(generate_xo(scale=0.8,
colors=['#303030', '#303030'])),
self.toolbar, tooltip=self.nick)
self.dialog_button = _button_factory('go-next',
_('Turn complete'),
self._dialog_cb, self.toolbar)
self.status = _label_factory('', self.toolbar)
self.hint_button = _button_factory('help-toolbar',
_('Help'),
self._hint_cb, self.toolbar)
self.score = _label_factory(_('Score: ') + '0', self.toolbar)
if _have_toolbox:
_separator_factory(toolbox.toolbar, False, True)
stop_button = StopButton(self)
stop_button.props.accelerator = '<Ctrl>q'
toolbox.toolbar.insert(stop_button, -1)
stop_button.show()
def build_toolbar(self):
toolbox = ToolbarBox()
activity_button = ActivityToolbarButton(self)
toolbox.toolbar.insert(activity_button, -1)
activity_button.show()
self.build_calibrate_toolbar(toolbox)
self.build_options_toolbar(toolbox)
self.build_resolution_toolbar(toolbox)
self.build_colors_toolbar(toolbox)
separador13 = gtk.SeparatorToolItem()
separador13.props.draw = False
separador13.set_expand(True)
toolbox.toolbar.insert(separador13, -1)
stop_button = StopButton(self)
stop_button.props.accelerator = _('<Ctrl>Q')
toolbox.toolbar.insert(stop_button, -1)
stop_button.show()
self.set_toolbox(toolbox)
toolbox.show()
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()
# Pause/Play button:
stop_play = ToolButton('media-playback-stop')
stop_play.set_tooltip(_("Stop"))
stop_play.set_accelerator(_('<ctrl>space'))
stop_play.connect('clicked', self._stop_play_cb)
stop_play.show()
toolbar_box.toolbar.insert(stop_play, -1)
# 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 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()
self.blocklist = []
self.radioList = {}
for c in tools.allTools:
button = ToolButton(c.icon)
button.set_tooltip(_(c.toolTip))
button.connect('clicked',self.radioClicked)
toolbar_box.toolbar.insert(button, -1)
button.show()
self.radioList[button] = c.name
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()
self.show_all()
def build_toolbar(self):
self.max_participants = 1
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()
separator = gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
toolbar_box.toolbar.insert(separator, -1)
separator.show()
self.create_help(toolbar_box.toolbar)
stop_button = StopButton(self)
toolbar_box.toolbar.insert(stop_button, -1)
stop_button.show()
self.show_all()
def __init__(self, pca):
self.ca = pca
# listen for ctrl+c & escape key
self.ca.connect('key-press-event', self._key_press_event_cb)
self.ACTIVE = False
self.LAUNCHING = True
self.ca.add_events(gtk.gdk.VISIBILITY_NOTIFY_MASK)
self.ca.connect("visibility-notify-event", self._visible_notify_cb)
self.control_bar_ht = 60
# True when we're showing live video feed in the primary screen
self.CAPTUREMODE = True
#self.inset = self.__class__.dim_INSET
#init
self.mapped = False
self.setup = False
self.tbars = {Constants.MODE_VIDEO: 1,
Constants.MODE_HELP: 2}
# Use 0.86 toolbar design
self.toolbox = ToolbarBox()
# Buttons added to the Activity toolbar
activity_button = ActivityToolbarButton(self.ca)
self.toolbox.toolbar.insert(activity_button, 0)
activity_button.show()
separator = gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
separator.show()
self.toolbox.toolbar.insert(separator, -1)
# The ever-present Stop Button
stop_button = StopButton(self)
stop_button.props.accelerator = '<Ctrl>Q'
self.toolbox.toolbar.insert(stop_button, -1)
stop_button.show()
self.ca.set_toolbar_box(self.toolbox)
self.toolbox.show()
self.toolbox_ht = self.toolbox.size_request()[1]
self.vh = gtk.gdk.screen_height() - \
(self.toolbox_ht + self.control_bar_ht)
self.vw = int(self.vh / .75)
main_box = gtk.VBox()
self.ca.set_canvas(main_box)
main_box.get_parent().modify_bg(gtk.STATE_NORMAL,
Constants.color_black.gColor)
main_box.show()
self._play_button = PlayButton()
self._play_button.connect('clicked', self._button_play_click)
main_box.pack_start(self._play_button, expand=True)
self._play_button.show()
self.setup_windows()
def __init__(self, pca):
self.ca = pca
# listen for ctrl+c & escape key
self.ca.connect('key-press-event', self._key_press_event_cb)
self.ACTIVE = False
self.LAUNCHING = True
self.ca.add_events(gtk.gdk.VISIBILITY_NOTIFY_MASK)
self.ca.connect("visibility-notify-event", self._visible_notify_cb)
self.control_bar_ht = 60
# True when we're showing live video feed in the primary screen
self.CAPTUREMODE = True
#self.inset = self.__class__.dim_INSET
#init
self.mapped = False
self.setup = False
self.tbars = {Constants.MODE_VIDEO: 1, Constants.MODE_HELP: 2}
# Use 0.86 toolbar design
self.toolbox = ToolbarBox()
# Buttons added to the Activity toolbar
activity_button = ActivityToolbarButton(self.ca)
self.toolbox.toolbar.insert(activity_button, 0)
activity_button.show()
separator = gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
separator.show()
self.toolbox.toolbar.insert(separator, -1)
# The ever-present Stop Button
stop_button = StopButton(self)
stop_button.props.accelerator = '<Ctrl>Q'
self.toolbox.toolbar.insert(stop_button, -1)
stop_button.show()
self.ca.set_toolbar_box(self.toolbox)
self.toolbox.show()
self.toolbox_ht = self.toolbox.size_request()[1]
self.vh = gtk.gdk.screen_height() - \
(self.toolbox_ht + self.control_bar_ht)
self.vw = int(self.vh / .75)
main_box = gtk.VBox()
self.ca.set_canvas(main_box)
main_box.get_parent().modify_bg(gtk.STATE_NORMAL,
Constants.color_black.gColor)
main_box.show()
self._play_button = PlayButton()
self._play_button.connect('clicked', self._button_play_click)
main_box.pack_start(self._play_button, expand=True)
self._play_button.show()
self.setup_windows()
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()
separator1 = gtk.SeparatorToolItem()
separator1.props.draw = True
separator1.set_expand(False)
toolbar_box.toolbar.insert(separator1, -1)
separator1.show()
item1 = gtk.ToolItem()
label1 = gtk.Label()
label1.set_text(_('Levels') + ' ')
item1.add(label1)
toolbar_box.toolbar.insert(item1, -1)
item2 = gtk.ToolItem()
levels = (
_('Cross'),
_('Cross 2'),
#TRANS:'chimney' - the place where you make fire
_('Hearth'),
_('Arrow'),
_('Pyramid'),
_('Diamond'),
_('Solitaire'))
combo = Combo(levels)
item2.add(combo)
combo.connect('changed', self.change_combo)
toolbar_box.toolbar.insert(item2, -1)
separator2 = gtk.SeparatorToolItem()
separator2.props.draw = True
separator2.set_expand(False)
toolbar_box.toolbar.insert(separator2, -1)
separator2.show()
sound_button = ToolButton('speaker-muted-100')
sound_button.set_tooltip(_('Sound'))
sound_button.connect('clicked', self.sound_control)
toolbar_box.toolbar.insert(sound_button, -1)
separator3 = gtk.SeparatorToolItem()
separator3.props.draw = False
separator3.set_expand(True)
toolbar_box.toolbar.insert(separator3, -1)
separator3.show()
stop_button = StopButton(self)
toolbar_box.toolbar.insert(stop_button, -1)
stop_button.show()
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()
separator1 = gtk.SeparatorToolItem()
separator1.props.draw = True
separator1.set_expand(False)
toolbar_box.toolbar.insert(separator1, -1)
separator1.show()
item1 = gtk.ToolItem()
label1 = gtk.Label()
label1.set_text(_('Levels') + ' ')
item1.add(label1)
toolbar_box.toolbar.insert(item1, -1)
item2 = gtk.ToolItem()
levels = (_('Cross'),
_('Cross 2'),
#TRANS:'chimney' - the place where you make fire
_('Hearth'),
_('Arrow'),
_('Pyramid'),
_('Diamond'),
_('Solitaire'))
combo = Combo(levels)
item2.add(combo)
combo.connect('changed', self.change_combo)
toolbar_box.toolbar.insert(item2, -1)
separator2 = gtk.SeparatorToolItem()
separator2.props.draw = True
separator2.set_expand(False)
toolbar_box.toolbar.insert(separator2, -1)
separator2.show()
sound_button = ToolButton('speaker-muted-100')
sound_button.set_tooltip(_('Sound'))
sound_button.connect('clicked', self.sound_control)
toolbar_box.toolbar.insert(sound_button, -1)
separator3 = gtk.SeparatorToolItem()
separator3.props.draw = False
separator3.set_expand(True)
toolbar_box.toolbar.insert(separator3, -1)
separator3.show()
stop_button = StopButton(self)
toolbar_box.toolbar.insert(stop_button, -1)
stop_button.show()
self.show_all()
def __init__(self, handle):
activity.Activity.__init__(self, handle)
toolbar_box = ToolbarBox()
activity_button = ActivityToolbarButton(self)
toolbar_box.toolbar.insert(activity_button, 0)
activity_button.show()
separator = gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
toolbar_box.toolbar.insert(separator, -1)
separator.show()
change_color_button = ToolButton('toolbar-colors')
change_color_button.set_tooltip(_('Click here to change the background color'))
change_color_button.connect('clicked', self.on_change_color_clicked)
toolbar_box.toolbar.insert(change_color_button, -1)
change_color_button.show()
separator = gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
toolbar_box.toolbar.insert(separator, -1)
separator.show()
stop_button = StopButton(self)
stop_button.props.accelerator = '<Ctrl><Shift>Q'
toolbar_box.toolbar.insert(stop_button, -1)
stop_button.show()
button = gtk.Button("Click here to change the background color")
button.connect('clicked', self.on_change_color_clicked)
button.set_flags(gtk.CAN_DEFAULT)
button.grab_default()
toolbar_box.add(button)
button.show()
self.set_toolbar_box(toolbar_box)
toolbar_box.show()
canvas = gtk.HBox(False, 0)
color = gtk.gdk.color_parse("skyblue")
self.d_area = gtk.DrawingArea()
self.d_area.connect("expose-event", self.expose)
self.d_area.modify_bg(gtk.STATE_NORMAL, color)
canvas.add(self.d_area)
self.set_canvas(canvas)
self.show_all()
def _setup_toolbars(self, have_toolbox):
""" Setup the toolbars.. """
if have_toolbox:
toolbox = ToolbarBox()
# Activity toolbar
activity_button = ActivityToolbarButton(self)
toolbox.toolbar.insert(activity_button, 0)
activity_button.show()
self.set_toolbar_box(toolbox)
toolbox.show()
toolbar = toolbox.toolbar
else:
# Use pre-0.86 toolbar design
games_toolbar = gtk.Toolbar()
toolbox = activity.ActivityToolbox(self)
self.set_toolbox(toolbox)
toolbox.add_toolbar(_('Game'), games_toolbar)
toolbox.show()
toolbox.set_current_toolbar(1)
toolbar = games_toolbar
# Add the buttons and labels to the toolbars
self.level_button = button_factory(
LEVEL_ICONS[self._play_level], toolbar, self.change_play_level_cb,
tooltip=_('Set difficulty level.'))
mode = self._play_mode
mode += 1
if mode == len(GAME_ICONS):
mode = 0
self.game_buttons = []
for i in range(len(GAME_ICONS)):
if i==0:
self.game_buttons.append(radio_factory(
GAME_ICONS[0], toolbar, self.change_play_mode_cb,
cb_arg=0, tooltip=_('Select game.'), group=None))
else:
self.game_buttons.append(radio_factory(
GAME_ICONS[i], toolbar, self.change_play_mode_cb,
cb_arg=i, tooltip=_('Select game.'),
group=self.game_buttons[0]))
self.game_buttons[mode].set_active(True)
separator_factory(toolbar, False, True)
self.status_label = label_factory(toolbar, _("drag to swap"))
if _have_toolbox:
separator_factory(toolbox.toolbar, True, False)
stop_button = StopButton(self)
stop_button.props.accelerator = '<Ctrl>q'
toolbox.toolbar.insert(stop_button, -1)
stop_button.show()
def build_toolbar(self):
self.max_participants = 1
toolbox = ToolbarBox()
activity_button = ActivityToolbarButton(self)
toolbox.toolbar.insert(activity_button, -1)
activity_button.show()
pano_toolbar = toolbox.toolbar
new_button = ToolButton('stock_refresh')
new_button.set_tooltip(_('New Panorama'))
new_button.connect('clicked', self.new_event)
pano_toolbar.insert(new_button, -1)
new_button.show()
capture_button = ToolButton('add_capture')
capture_button.set_tooltip(_('Add a capture to the Panorama'))
capture_button.connect('clicked', self.capture_event)
pano_toolbar.insert(capture_button, -1)
capture_button.show()
stitch_button = ToolButton('format-columns-triple')
stitch_button.set_tooltip(_('Stitch Panorama'))
stitch_button.connect('clicked', self.stitch_event)
pano_toolbar.insert(stitch_button, -1)
stitch_button.show()
stiching_auto = ToolButton('media-playback-start')
stiching_auto.set_tooltip(_('Enable auto-stitch'))
stiching_auto.connect('clicked', self.change_stich)
pano_toolbar.insert(stiching_auto, -1)
save_button = ToolButton('filesave')
save_button.set_tooltip(_('Save Panorama'))
save_button.connect('clicked', self.save_event)
pano_toolbar.insert(save_button, -1)
save_button.show()
separator = gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
pano_toolbar.insert(separator,-1)
stop_button = StopButton(self)
stop_button.props.accelerator = '<Ctrl>q'
pano_toolbar.insert(stop_button, -1)
stop_button.show()
self.set_toolbar_box(toolbox)
toolbox.show_all()
def __init__(self, activity, box, export_formats=None):
ActivityToolbarButton.__init__(self, activity)
box.toolbar.insert(self, 0)
self.show()
if export_formats != None:
if len(export_formats) == 1:
stock.register('sweetener-%s' % export_formats[0][1],
_('Export as %s') % export_formats[0][0], None,
export_formats[0][1].replace('/', '-'))
export = Item('sweetener-%s' % export_formats[0][1])
export.connect('activate', activity.export, export_formats[0])
self.page.insert(export.get_tool_item(), -1)
def __init__(self, handle):
activity.Activity.__init__(self, handle)
self.max_participants = 1
toolbar_box = ToolbarBox()
activity_button = ActivityToolbarButton(self)
toolbar_box.toolbar.insert(activity_button, 0)
activity_button.show()
jugarc_button = ToolButton('chico')
jugarc_button.set_tooltip(('Jugar el juego en pantalla chica'))
jugarc_button.connect('clicked', self._jugar_chico)
toolbar_box.toolbar.insert(jugarc_button, -1)
jugarc_button.show
jugarm_button = ToolButton('mediano')
jugarm_button.set_tooltip(('Jugar el juego en pantalla mediana'))
jugarm_button.connect('clicked', self._jugar_mediano)
toolbar_box.toolbar.insert(jugarm_button, -1)
jugarm_button.show
jugarg_button = ToolButton('grande')
jugarg_button.set_tooltip(('Jugar el juego en pantalla grande'))
jugarg_button.connect('clicked', self._jugar_grande)
toolbar_box.toolbar.insert(jugarg_button, -1)
jugarg_button.show
separator = gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
toolbar_box.toolbar.insert(separator, -1)
separator.show()
self.create_help(toolbar_box.toolbar)
self.set_toolbar_box(toolbar_box)
toolbar_box.show()
self._update_accelerators(toolbar_box)
self._filechooser = gtk.FileChooserWidget(\
action=gtk.FILE_CHOOSER_ACTION_OPEN,backend=None)
self._filechooser.set_current_folder("/")
self.botonJugar = gtk.Button("Jugar rom")
self.botonJugar.connect('clicked', self._jugar_mediano)
self.botonJugar.show()
self._filechooser.set_extra_widget(self.botonJugar)
self.set_canvas(self._filechooser)
self.show_all()
def build_toolbar(self):
toolbar_box = ToolbarBox()
toolbar = toolbar_box.toolbar
activity = ActivityToolbarButton(self)
stop = StopButton(self)
separator = gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
retroness = gtk.Adjustment(3, 0, MAX_DELAY, 1, 10, 0)
retroness.connect("value_changed", self.retroness_adjusted_cb)
retro_bar = gtk.HScale(retroness)
retro_bar.set_digits(0)
retro_bar.set_value_pos(gtk.POS_RIGHT)
retro_bar.set_size_request(240, 15)
retro_tool = gtk.ToolItem()
retro_tool.add(retro_bar)
label = gtk.ToolItem()
label.add(gtk.Label(_("Seconds Delayed:")))
toolbar.insert(activity, -1)
toolbar.insert(gtk.SeparatorToolItem(), -1)
toolbar.insert(label, -1)
toolbar.insert(retro_tool, -1)
toolbar.insert(separator, -1)
toolbar.insert(stop, -1)
return toolbar_box
def __init__(self, handle):
super(Agenda, self).__init__(handle, True)
tool = ToolbarBox()
toolbar = tool.toolbar
activitybtn = ActivityToolbarButton(self)
self.separator = gtk.SeparatorToolItem()
self.separator.props.draw = False
self.separator.set_expand(True)
stpbtn = StopButton(self)
self.addbtn = ToolButton('add')
self.addbtn.connect('clicked', self._show_palette_add_button)
toolbar.insert(activitybtn, 0)
toolbar.insert(gtk.SeparatorToolItem(), -1)
toolbar.insert(self.addbtn, -1)
toolbar.insert(self.separator, -1)
toolbar.insert(stpbtn, -1)
self.canvas = canvas()
self.toolarea = AddTelephoneArea(self.addbtn, self.canvas)
self.set_toolbar_box(tool)
self.set_canvas(self.canvas)
self.addbtn.set_tooltip(_('Add a new contact'))
self._create_palette_add_button(self.addbtn)
self.show_all()
def build_toolbar(self):
self.max_participants = 1
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()
# toolbars
self.build_size_toolbar(toolbar_box)
self.build_colors_toolbar(toolbar_box)
separator = gtk.SeparatorToolItem()
toolbar_box.toolbar.insert(separator, -1)
separator.show()
#current
item = gtk.ToolItem()
label = gtk.Label()
label.set_text(' %s ' % _('Current player:'))
item.add(label)
toolbar_box.toolbar.insert(item, -1)
#player
item = gtk.ToolItem()
self.current_label = gtk.Label()
self.current_label.set_text(' %s ' % _('Player 1'))
item.add(self.current_label)
toolbar_box.toolbar.insert(item, -1)
# end separator
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()
self.show_all()
def build_toolbar(self):
try:
# Use new >= 0.86 toolbar
self.max_participants = 1
toolbar_box = ToolbarBox()
activity_button = ActivityToolbarButton(self)
toolbar_box.toolbar.insert(activity_button, 0)
activity_button.show()
separator = gtk.SeparatorToolItem()
toolbar_box.toolbar.insert(separator, -1)
separator.show()
self._insert_create_tools(toolbar_box.toolbar)
separator = gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_size_request(0, -1)
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()
self.set_toolbar_box(toolbar_box)
toolbar_box.show()
return toolbar_box
except NameError:
# Use old <= 0.84 toolbar design
toolbox = activity.ActivityToolbox(self)
activity_toolbar = toolbox.get_activity_toolbar()
activity_toolbar.share.props.visible = False
create_toolbar = gtk.Toolbar()
self._insert_create_tools(create_toolbar)
toolbox.add_toolbar(_("Create"), create_toolbar)
create_toolbar.show()
toolbox.set_current_toolbar(1)
toolbox.show()
self.set_toolbox(toolbox)
return activity_toolbar
def build_toolbar(self):
self.max_participants = 1
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()
# new pic button
new_pic = ToolButton('new-pic')
new_pic.connect('clicked', self._new_picture)
new_pic.set_tooltip(_('New picture'))
toolbar_box.toolbar.insert(new_pic, -1)
# add / remove point buttons
add_point = ToolButton("row-insert")
add_point.connect("clicked", self._add_point)
add_point.set_tooltip(_("Add a point"))
toolbar_box.toolbar.insert(add_point, -1)
rem_point = ToolButton("row-remove")
rem_point.connect("clicked", self._remove_point)
rem_point.set_tooltip(_("Remove the selected point"))
toolbar_box.toolbar.insert(rem_point, -1)
# save list button
save = ToolButton('filesave')
save.connect('clicked', self._save)
save.set_tooltip(_('Save data'))
toolbar_box.toolbar.insert(save, -1)
# separator and stop button
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 create_toolbar(self):
"""
This function creates the game toolbar
"""
toolbar_box = ToolbarBox()
self.set_toolbar_box(toolbar_box)
toolbar_box.toolbar.insert(ActivityToolbarButton(self), -1)
separator = gtk.SeparatorToolItem()
separator.props.draw = False
toolbar_box.toolbar.insert(separator, -1)
scoreButton = ScoreButton(self)
toolbar_box.toolbar.insert(scoreButton, -1)
separator = gtk.SeparatorToolItem()
separator.props.draw = False
toolbar_box.toolbar.insert(separator, -1)
self._modes = ToolComboBox()
self._modelist = ['Select Mode', '+ Addition', '- Subtraction']
for i, f in enumerate(self._modelist):
self._modes.combo.append_item(i, f)
self.modes_handle_id = self._modes.combo.connect("changed", self._change_modes_toolbar)
toolbar_box.toolbar.insert(self._modes, -1)
self._modes.combo.set_active(0)
separator = gtk.SeparatorToolItem()
separator.props.draw = False
toolbar_box.toolbar.insert(separator, -1)
scorestats = VisualScore(self)
toolbar_box.toolbar.insert(scorestats, -1)
separator = gtk.SeparatorToolItem()
separator.props.draw = False
toolbar_box.toolbar.insert(separator, -1)
separator = gtk.SeparatorToolItem()
separator.props.draw = False
toolbar_box.toolbar.insert(separator, -1)
timestats = VisualTime(self)
toolbar_box.toolbar.insert(timestats, -1)
separator = gtk.SeparatorToolItem()
separator.props.draw = False
toolbar_box.toolbar.insert(separator, -1)
separator = gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
toolbar_box.toolbar.insert(separator, -1)
stopButton = StopButton(self)
toolbar_box.toolbar.insert(stopButton, -1)
toolbar_box.show_all()
def build_toolbar(self):
toolbar_box = ToolbarBox()
toolbar_box.show()
activity_button = ActivityToolbarButton(self)
toolbar_box.toolbar.insert(activity_button, -1)
activity_button.show()
separator = gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
toolbar_box.toolbar.insert(separator, -1)
stop_button = StopButton(self)
toolbar_box.toolbar.insert(stop_button, -1)
stop_button.show()
self.set_toolbar_box(toolbar_box)
toolbar_box.show_all()
def build_toolbar(self):
toolbox = ToolbarBox()
activity_button = ActivityToolbarButton(self)
toolbox.toolbar.insert(activity_button, -1)
activity_button.show()
separator = gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
toolbox.toolbar.insert(separator, -1)
stop_button = StopButton(self)
stop_button.props.accelerator = _('<Ctrl>Q')
toolbox.toolbar.insert(stop_button, -1)
stop_button.show()
self.set_toolbox(toolbox)
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()
# 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 __init__(self, handle):
activity.Activity.__init__(self, handle, True)
# Toolbar(s)
toolbarbox = ToolbarBox()
# The Activity Button:
activity_button = ActivityToolbarButton(self)
# Insert the Activity Toolbar Button in the toolbarbox
toolbarbox.toolbar.insert(activity_button, 0)
separator = gtk.SeparatorToolItem()
separator.set_expand(False)
separator.set_draw(True)
toolbarbox.toolbar.insert(separator, -1)
stopbtn = StopButton(self)
toolbarbox.toolbar.insert(stopbtn, -1)
self.set_toolbar_box(toolbarbox)
# For a white background:
canvas = gtk.EventBox()
canvas.modify_bg(gtk.STATE_NORMAL, gtk.gdk.color_parse("white"))
db_file = self.get_activity_root() + "/articles.db"
if not os.path.exists(db_file):
shutil.copy(activity.get_bundle_path() + "/default.db", db_file)
self.manager = ArticlesManager(sqlite3.connect(db_file, isolation_level=None, \
check_same_thread=False))
self.manager.initialize_db()
track = ArticlesTracker(config.TRACKER_URL)
self.manager.connect(
'article-liked',
lambda m, article_id: track.track_action_on_thread(
'liked', article_id))
self.manager.connect(
'article-read', lambda m, article_id: track.track_action_on_thread(
'read', article_id))
web = ArticlesBrowser(self.manager,
base="file://" + activity.get_bundle_path() +
"/")
scroller = gtk.ScrolledWindow()
scroller.add(web)
scroller.show()
web.show()
canvas.add(scroller)
self.set_canvas(canvas)
self.show_all()
def build_toolbar(self):
"""Build our Activity toolbar for the Sugar system."""
toolbar_box = ToolbarBox()
activity_button = ActivityToolbarButton(self)
toolbar_box.toolbar.insert(activity_button, 0)
activity_button.show()
separator = gtk.SeparatorToolItem()
toolbar_box.toolbar.insert(separator, -1)
separator.show()
easier_button = ToolButton('create-easier')
easier_button.set_tooltip(_('Easier level'))
easier_button.connect('clicked', self._easier_button_cb)
toolbar_box.toolbar.insert(easier_button, -1)
harder_button = ToolButton('create-harder')
harder_button.set_tooltip(_('Harder level'))
harder_button.connect('clicked', self._harder_button_cb)
toolbar_box.toolbar.insert(harder_button, -1)
separator = gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_size_request(0, -1)
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()
self.set_toolbar_box(toolbar_box)
toolbar_box.show_all()
self.connect("destroy", self.__stop_pygame)
return toolbar_box
def build_toolbar(self):
toolbox = ToolbarBox()
activity_button = ActivityToolbarButton(self)
toolbox.toolbar.insert(activity_button, -1)
activity_button.show()
barra = toolbox.toolbar
separator2 = gtk.SeparatorToolItem()
separator2.props.draw = False
separator2.set_expand(True)
barra.insert(separator2, -1)
stop_button = StopButton(self)
stop_button.props.accelerator = '<Ctrl>q'
barra.insert(stop_button, -1)
stop_button.show()
self.set_toolbar_box(toolbox)
toolbox.show_all()
def _setup_toolbars(self):
''' Add buttons to toolbars '''
custom_toolbar = gtk.Toolbar()
if HAS_TOOLBARBOX:
toolbox = ToolbarBox()
self.toolbar = toolbox.toolbar
activity_button = ActivityToolbarButton(self)
self.toolbar.insert(activity_button, 0)
activity_button.show()
custom_toolbar_button = ToolbarButton(
label=_('Custom'),
page=custom_toolbar,
icon_name='view-source')
custom_toolbar.show()
self.toolbar.insert(custom_toolbar_button, -1)
custom_toolbar_button.show()
self._load_standard_buttons(self.toolbar)
separator_factory(self.toolbar, expand=True, visible=False)
stop_button = StopButton(self)
stop_button.props.accelerator = _('<Ctrl>Q')
self.toolbar.insert(stop_button, -1)
stop_button.show()
self.set_toolbox(toolbox)
toolbox.show()
else:
toolbox = activity.ActivityToolbox(self)
self.set_toolbox(toolbox)
self.toolbar = gtk.Toolbar()
toolbox.add_toolbar(_('Project'), self.toolbar)
toolbox.add_toolbar(_('Custom'), custom_toolbar)
self._load_standard_buttons(self.toolbar)
self._load_custom_buttons(custom_toolbar)
def build_toolbar(self):
# Creates the Toolbox. It contains the Activity Toolbar, which is the
# bar that appears on every Sugar window and contains essential
# functionalities, such as the 'Collaborate' and 'Close' buttons.
toolbox = ToolbarBox()
activity_button = ActivityToolbarButton(self)
toolbox.toolbar.insert(activity_button, -1)
activity_button.show()
# Blank space (separator) and Stop button at the end:
separator = gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
toolbox.toolbar.insert(separator, -1)
separator.show()
# Activity stop button
stop_button = StopButton(self)
toolbox.toolbar.insert(stop_button, -1)
stop_button.show()
self.set_toolbox(toolbox)
toolbox.show()
def __init__(self, handle):
activity.Activity.__init__(self, handle)
# we do not have collaboration features
# make the share option insensitive
self.max_participants = 1
# toolbar with the new toolbar redesign
toolbar_box = ToolbarBox()
activity_button = ActivityToolbarButton(self)
toolbar_box.toolbar.insert(activity_button, 0)
toolbar_box.toolbar.insert(gtk.SeparatorToolItem(), -1)
self.image_viewer = ImageCollectionViewer(False)
prev_bt = ToolButton("go-previous-paired")
prev_bt.connect("clicked", self.image_viewer.prev_anim_clicked_cb,
None)
toolbar_box.toolbar.insert(prev_bt, -1)
next_bt = ToolButton("go-next-paired")
next_bt.connect("clicked", self.image_viewer.next_anim_clicked_cb,
None)
toolbar_box.toolbar.insert(next_bt, -1)
separator = gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
toolbar_box.toolbar.insert(separator, -1)
stop_button = StopButton(self)
toolbar_box.toolbar.insert(stop_button, -1)
self.set_toolbar_box(toolbar_box)
toolbar_box.show_all()
self.modify_bg(gtk.STATE_NORMAL, style.COLOR_WHITE.get_gdk_color())
self.set_canvas(self.image_viewer)
def __init__(self, handle):
super(ErikosActivity,self).__init__(handle)
try:
# Use 0.86 toolbar design
toolbar_box = ToolbarBox()
# Buttons added to the Activity toolbar
activity_button = ActivityToolbarButton(self)
toolbar_box.toolbar.insert(activity_button, 0)
activity_button.show()
# Play Button
self.play = ToolButton( "media-playback-start" )
self.play.set_tooltip(_('Play'))
self.play.props.sensitive = True
self.play.connect('clicked', self._play_cb)
toolbar_box.toolbar.insert(self.play, -1)
self.play.show()
# Sound Toggle Button
self.sound = ToolButton( "speaker-muted-100" )
self.sound.set_tooltip(_('Mute'))
self.sound.props.sensitive = True
self.sound.connect('clicked', self._sound_cb)
toolbar_box.toolbar.insert(self.sound, -1)
self.sound.show()
separator = gtk.SeparatorToolItem()
separator.show()
toolbar_box.toolbar.insert(separator, -1)
# Label for showing level
self.level_label = gtk.Label("%s %d" % (_("Level"),1))
self.level_label.show()
level_toolitem = gtk.ToolItem()
level_toolitem.add(self.level_label)
toolbar_box.toolbar.insert(level_toolitem,-1)
separator = gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
separator.show()
toolbar_box.toolbar.insert(separator, -1)
# The ever-present Stop Button
stop_button = StopButton(self)
stop_button.props.accelerator = '<Ctrl>Q'
toolbar_box.toolbar.insert(stop_button, -1)
stop_button.show()
self.set_toolbar_box(toolbar_box)
toolbar_box.show()
except NameError:
# Use pre-0.86 toolbar design
self.toolbox = activity.ActivityToolbox(self)
self.set_toolbox(self.toolbox)
self.projectToolbar = ProjectToolbar(self)
self.toolbox.add_toolbar( _('Project'), self.projectToolbar )
self.toolbox.show()
# Create a canvas
canvas = gtk.DrawingArea()
canvas.set_size_request(gtk.gdk.screen_width(), \
gtk.gdk.screen_height())
self.set_canvas(canvas)
canvas.show()
self.show_all()
# Initialize the canvas
self.sw = window.new_window(canvas, \
os.path.join(activity.get_bundle_path(), \
'images/'), \
self)
self.sw.activity = self
# Read the level from the Journal
try:
sw.level = int(self.metadata['level'])
except:
pass
def __init__(self, handle):
super(PeterActivity, self).__init__(handle)
# Get user's Sugar colors
sugarcolors = profile.get_color().to_string().split(",")
colors = [
[int(sugarcolors[0][1:3], 16), int(sugarcolors[0][3:5], 16), int(sugarcolors[0][5:7], 16)],
[int(sugarcolors[1][1:3], 16), int(sugarcolors[1][3:5], 16), int(sugarcolors[1][5:7], 16)],
]
# No sharing
self.max_participants = 1
self.datapath = os.path.join(activity.get_activity_root(), "instance")
# Build the activity toolbar.
toolbox = ToolbarBox()
activity_button = ActivityToolbarButton(self)
toolbox.toolbar.insert(activity_button, 0)
activity_button.show()
self._add_speed_slider(toolbox.toolbar)
cyan = ToolButton("cyan")
toolbox.toolbar.insert(cyan, -1)
cyan.set_tooltip(_("Next pattern"))
cyan.connect("clicked", self._button_cb, "cyan")
cyan.set_sensitive(False)
cyan.show()
green = ToolButton("green")
toolbox.toolbar.insert(green, -1)
green.set_tooltip(_("Draw"))
green.connect("clicked", self._button_cb, "green")
green.show()
red = ToolButton("red")
toolbox.toolbar.insert(red, -1)
red.set_tooltip(_("Stop"))
red.connect("clicked", self._button_cb, "red")
red.show()
separator = gtk.SeparatorToolItem()
separator.props.draw = True
toolbox.toolbar.insert(separator, -1)
separator.show()
label = gtk.Label("")
label.set_use_markup(True)
label.show()
labelitem = gtk.ToolItem()
labelitem.add(label)
toolbox.toolbar.insert(labelitem, -1)
labelitem.show()
export = ToolButton("export-turtleblocks")
toolbox.toolbar.insert(export, -1)
export.set_tooltip(_("Export to TurtleBlocks"))
export.connect("clicked", self._export_turtleblocks_cb)
export.show()
separator = gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
toolbox.toolbar.insert(separator, -1)
separator.show()
stop_button = StopButton(self)
stop_button.props.accelerator = _("<Ctrl>Q")
toolbox.toolbar.insert(stop_button, -1)
stop_button.show()
toolbox.show()
self.set_toolbox(toolbox)
# Create the game instance.
self.game = Spirolaterals.Spirolaterals(colors)
# Build the Pygame canvas.
self._pygamecanvas = sugargame.canvas.PygameCanvas(self)
# Note that set_canvas implicitly calls
# read_file when resuming from the Journal.
self.set_canvas(self._pygamecanvas)
self.game.canvas = self._pygamecanvas
gtk.gdk.screen_get_default().connect("size-changed", self.__configure_cb)
# Start the game running.
self.game.set_cyan_button(cyan)
self.game.set_label(label)
self._speed_range.set_value(200)
self._pygamecanvas.run_pygame(self.game.run)
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 __init__(self, handle):
super(PeterActivity, self).__init__(handle)
# Get user's Sugar colors
sugarcolors = profile.get_color().to_string().split(',')
colors = [[int(sugarcolors[0][1:3], 16),
int(sugarcolors[0][3:5], 16),
int(sugarcolors[0][5:7], 16)],
[int(sugarcolors[1][1:3], 16),
int(sugarcolors[1][3:5], 16),
int(sugarcolors[1][5:7], 16)]]
# No sharing
self.max_participants = 1
# Build the activity toolbar.
toolbox = ToolbarBox()
activity_button = ActivityToolbarButton(self)
toolbox.toolbar.insert(activity_button, 0)
activity_button.show()
self._add_speed_slider(toolbox.toolbar)
cyan = ToolButton('cyan')
toolbox.toolbar.insert(cyan, -1)
cyan.set_tooltip(_('Next pattern'))
cyan.connect('clicked', self._button_cb, 'cyan')
cyan.set_sensitive(False)
cyan.show()
green = ToolButton('green')
toolbox.toolbar.insert(green, -1)
green.set_tooltip(_('Draw'))
green.connect('clicked', self._button_cb, 'green')
green.show()
red = ToolButton('red')
toolbox.toolbar.insert(red, -1)
red.set_tooltip(_('Stop'))
red.connect('clicked', self._button_cb, 'red')
red.show()
separator = gtk.SeparatorToolItem()
separator.props.draw = True
toolbox.toolbar.insert(separator, -1)
separator.show()
label = gtk.Label('')
label.set_use_markup(True)
label.show()
labelitem = gtk.ToolItem()
labelitem.add(label)
toolbox.toolbar.insert(labelitem, -1)
labelitem.show()
separator = gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
toolbox.toolbar.insert(separator, -1)
separator.show()
stop_button = StopButton(self)
stop_button.props.accelerator = _('<Ctrl>Q')
toolbox.toolbar.insert(stop_button, -1)
stop_button.show()
toolbox.show()
self.set_toolbox(toolbox)
# Create the game instance.
self.game = Spirolaterals.Spirolaterals(colors)
# Build the Pygame canvas.
self._pygamecanvas = \
sugargame.canvas.PygameCanvas(self)
# Note that set_canvas implicitly calls
# read_file when resuming from the Journal.
self.set_canvas(self._pygamecanvas)
self.game.canvas = self._pygamecanvas
gtk.gdk.screen_get_default().connect('size-changed',
self.__configure_cb)
# Start the game running.
self.game.set_cyan_button(cyan)
self.game.set_label(label)
self._speed_range.set_value(200)
self._pygamecanvas.run_pygame(self.game.run)
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 __init__(self, handle):
activity.Activity.__init__(self, handle, True)
self.max_participants = 1
# Calendar
self._calendar = gtk.Calendar()
self._calendar_size_ready = False
self._calendar.connect('size_allocate', self._calendar_size_allocate)
# TODO: Create a Help dialog like Implode
#self._helpdialog = HelpDialog()
# Canvas
scroll = gtk.ScrolledWindow()
scroll.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
self.notes_area = NotesArea()
scroll.add_with_viewport(self.notes_area)
self.set_canvas(scroll)
# Toolbars
toolbarbox = ToolbarBox()
activity_button = ActivityToolbarButton(self)
toolbarbox.toolbar.insert(activity_button, 0)
activity_button.show()
separator = gtk.SeparatorToolItem()
toolbarbox.toolbar.insert(separator, -1)
note_add = ToolButton('gtk-add')
note_add.set_tooltip(_('Add a note'))
note_add.connect('clicked', self._show_add_button_pallete)
toolbarbox.toolbar.insert(note_add, -1)
self._calendar.connect('day-selected-double-click',
self.__add_note_cb, note_add)
note_remove = ToggleToolButton('gtk-remove')
note_remove.set_tooltip(_('Remove notes'))
note_remove.connect('clicked', self._active_remove)
toolbarbox.toolbar.insert(note_remove, -1)
separator = gtk.SeparatorToolItem()
toolbarbox.toolbar.insert(separator, -1)
back = ToolButton('go-left')
back.set_tooltip(_('Select previous note'))
back.set_sensitive(False)
back.connect('clicked', lambda w: self.notes_area.select_note(-1))
toolbarbox.toolbar.insert(back, -1)
_next = ToolButton('go-right')
_next.set_tooltip(_('Select next note'))
_next.connect('clicked', lambda w: self.notes_area.select_note(+1))
_next.set_sensitive(False)
toolbarbox.toolbar.insert(_next, -1)
#helpbtn = ToolButton('toolbar-help')
#helpbtn.set_tooltip(_('Help'))
#helpbtn.connect('clicked', self.help)
#toolbarbox.toolbar.insert(helpbtn)
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.notes_area.connect('no-notes', self._no_notes,
note_remove, back, _next)
self.notes_area.connect('note-added', self._note_added, back, _next)
self.show_all()
self._create_add_button_pallete(note_add)
def __init__(self, handle):
super(PeterActivity, self).__init__(handle)
# Get user's Sugar colors
sugarcolors = profile.get_color().to_string().split(',')
colors = [[int(sugarcolors[0][1:3], 16),
int(sugarcolors[0][3:5], 16),
int(sugarcolors[0][5:7], 16)],
[int(sugarcolors[1][1:3], 16),
int(sugarcolors[1][3:5], 16),
int(sugarcolors[1][5:7], 16)]]
# No sharing
self.max_participants = 1
# Build the activity toolbar.
toolbox = ToolbarBox()
activity_button = ActivityToolbarButton(self)
toolbox.toolbar.insert(activity_button, 0)
activity_button.show()
self._add_level_slider(toolbox.toolbar)
green = ToolButton('green')
toolbox.toolbar.insert(green, -1)
green.set_tooltip(_('Run'))
green.connect('clicked', self._button_cb, 'green')
green.show()
separator = gtk.SeparatorToolItem()
separator.props.draw = True
toolbox.toolbar.insert(separator, -1)
separator.show()
label = gtk.Label('')
label.set_use_markup(True)
label.show()
labelitem = gtk.ToolItem()
labelitem.add(label)
toolbox.toolbar.insert(labelitem, -1)
labelitem.show()
separator = gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
toolbox.toolbar.insert(separator, -1)
separator.show()
stop = ToolButton('activity-stop')
toolbox.toolbar.insert(stop, -1)
stop.props.tooltip = _('Stop')
stop.props.accelerator = '<Ctrl>Q'
stop.connect('clicked', self.__stop_button_clicked_cb, activity)
stop.show()
toolbox.show()
self.set_toolbox(toolbox)
# Create the game instance.
self.game = Numbers.Numbers(colors, sugar=True)
# Build the Pygame canvas.
self._pygamecanvas = sugargame.canvas.PygameCanvas(self)
# Note that set_canvas implicitly calls
# read_file when resuming from the Journal.
self.set_canvas(self._pygamecanvas)
self.game.canvas = self._pygamecanvas
self.game.set_buttons(green)
self.game.set_label(label)
gtk.gdk.screen_get_default().connect('size-changed',
self.__configure_cb)
# Start the game running.
self._pygamecanvas.run_pygame(self.game.run)
def build_toolbar(self):
toolbox = ToolbarBox()
activity_button = ActivityToolbarButton(self)
toolbox.toolbar.insert(activity_button, -1)
activity_button.show()
barra = toolbox.toolbar
separador1 = gtk.SeparatorToolItem()
separador1.props.draw = True
barra.insert(separador1, 1)
item1 = gtk.ToolItem()
self.label_radio1 = gtk.Label()
self.label_radio1.set_text(_('Circles between') + ' ')
item1.add(self.label_radio1)
barra.insert(item1, 2)
item2 = gtk.ToolItem()
self.cradio1 = gtk.SpinButton()
self.cradio1.set_range(1, 20)
self.cradio1.set_increments(1, 2)
self.cradio1.props.value = self.radio_uno
self.cradio1_handler = self.cradio1.connect('notify::value', self.cradio1_valor)
item2.add(self.cradio1)
barra.insert(item2, 3)
item3 = gtk.ToolItem()
self.label_and = gtk.Label()
self.label_and.set_text(' ' + _('and') + ' ')
item3.add(self.label_and)
barra.insert(item3, 4)
item4 = gtk.ToolItem()
self.cradio2 = gtk.SpinButton()
self.cradio2.set_range(1, 20)
self.cradio2.set_increments(1, 2)
self.cradio2.props.value = self.radio_dos
self.cradio2_handler = self.cradio2.connect('notify::value', self.cradio2_valor)
item4.add(self.cradio2)
barra.insert(item4, 5)
separator1 = gtk.SeparatorToolItem()
separator1.props.draw = True
separator1.set_expand(False)
barra.insert(separator1,6)
save_button = ToolButton('filesave')
save_button.set_tooltip(_('Save Image'))
save_button.connect('clicked', self._savebutton_cb)
barra.insert(save_button, 7)
save_button.show()
separator2 = gtk.SeparatorToolItem()
separator2.props.draw = False
separator2.set_expand(True)
barra.insert(separator2,8)
stop_button = StopButton(self)
stop_button.props.accelerator = '<Ctrl>q'
barra.insert(stop_button, 9)
stop_button.show()
self.set_toolbar_box(toolbox)
toolbox.show_all()
def _setup_toolbars(self, have_toolbox):
""" Setup the toolbars.. """
if have_toolbox:
toolbox = ToolbarBox()
# Activity toolbar
activity_button = ActivityToolbarButton(self)
toolbox.toolbar.insert(activity_button, 0)
activity_button.show()
self.set_toolbar_box(toolbox)
toolbox.show()
toolbar = toolbox.toolbar
else:
# Use pre-0.86 toolbar design
games_toolbar = gtk.Toolbar()
toolbox = activity.ActivityToolbox(self)
self.set_toolbox(toolbox)
toolbox.add_toolbar(_('Game'), games_toolbar)
toolbox.show()
toolbox.set_current_toolbar(1)
toolbar = games_toolbar
# Add the buttons and labels to the toolbars
self.level_button = button_factory(LEVEL_ICONS[self._play_level],
toolbar,
self.change_play_level_cb,
tooltip=_('Set difficulty level.'))
mode = self._play_mode
mode += 1
if mode == len(GAME_ICONS):
mode = 0
self.game_buttons = []
for i in range(len(GAME_ICONS)):
if i == 0:
self.game_buttons.append(
radio_factory(GAME_ICONS[0],
toolbar,
self.change_play_mode_cb,
cb_arg=0,
tooltip=_('Select game.'),
group=None))
else:
self.game_buttons.append(
radio_factory(GAME_ICONS[i],
toolbar,
self.change_play_mode_cb,
cb_arg=i,
tooltip=_('Select game.'),
group=self.game_buttons[0]))
self.game_buttons[mode].set_active(True)
separator_factory(toolbar, False, True)
self.status_label = label_factory(toolbar, _("drag to swap"))
if _have_toolbox:
separator_factory(toolbox.toolbar, True, False)
stop_button = StopButton(self)
stop_button.props.accelerator = '<Ctrl>q'
toolbox.toolbar.insert(stop_button, -1)
stop_button.show()
class SpeakActivity(activity.Activity):
def __init__(self, handle):
super(SpeakActivity, self).__init__(handle)
self._notebook = gtk.Notebook()
self.set_canvas(self._notebook)
self._notebook.show()
self._colors = profile.get_color().to_string().split(',')
lighter = style.Color(self._colors[
_lighter_color(self._colors)])
self._mode = MODE_TYPE
self._tablet_mode = _is_tablet_mode()
self._robot_idle_id = None
self._active_eyes = None
self._active_number_of_eyes = None
self._current_voice = None
# make an audio device for playing back and rendering audio
self.connect('notify::active', self._active_cb)
self._cfg = {}
# make a box to type into
hbox = gtk.HBox()
if self._tablet_mode:
self._entry = gtk.Entry()
hbox.pack_start(self._entry, expand=True)
talk_button = ToolButton('microphone')
talk_button.set_tooltip(_('Speak'))
talk_button.connect('clicked', self._talk_cb)
hbox.pack_end(talk_button, expand=False)
else:
self._entrycombo = gtk.combo_box_entry_new_text()
self._entrycombo.connect('changed', self._combo_changed_cb)
self._entry = self._entrycombo.child
self._entry.set_size_request(-1, style.GRID_CELL_SIZE)
hbox.pack_start(self._entrycombo, expand=True)
self._entry.set_editable(True)
self._entry.connect('activate', self._entry_activate_cb)
self._entry.connect('key-press-event', self._entry_key_press_cb)
self._entry.modify_font(pango.FontDescription(str='sans bold 24'))
hbox.show()
self.face = face.View(fill_color=lighter)
self.face.set_size_request(
-1, gtk.gdk.screen_height() - 2 * style.GRID_CELL_SIZE)
self.face.show()
# layout the screen
box = gtk.VBox(homogeneous=False)
if self._tablet_mode:
box.pack_start(hbox, expand=False)
box.pack_start(self.face)
else:
box.pack_start(self.face, expand=True)
box.pack_start(hbox)
self.add_events(gtk.gdk.POINTER_MOTION_HINT_MASK
| gtk.gdk.POINTER_MOTION_MASK)
self.connect('motion_notify_event', self._mouse_moved_cb)
box.add_events(gtk.gdk.BUTTON_PRESS_MASK)
box.connect('button_press_event', self._mouse_clicked_cb)
# desktop
self._notebook.show()
self._notebook.props.show_border = False
self._notebook.props.show_tabs = False
box.show_all()
self._notebook.append_page(box)
self._chat = chat.View()
self._chat.show_all()
self._notebook.append_page(self._chat)
# make the text box active right away
if not self._tablet_mode:
self._entry.grab_focus()
self._entry.connect('move-cursor', self._cursor_moved_cb)
self._entry.connect('changed', self._cursor_moved_cb)
toolbox = ToolbarBox()
self._activity_button = ActivityToolbarButton(self)
self._activity_button.connect('clicked', self._configure_cb)
toolbox.toolbar.insert(self._activity_button, -1)
mode_type = RadioToolButton(
named_icon='mode-type',
tooltip=_('Type something to hear it'))
mode_type.connect('toggled', self.__toggled_mode_type_cb)
toolbox.toolbar.insert(mode_type, -1)
mode_robot = RadioToolButton(
named_icon='mode-robot',
group=mode_type,
tooltip=_('Ask robot any question'))
mode_robot.connect('toggled', self.__toggled_mode_robot_cb)
toolbox.toolbar.insert(mode_robot, -1)
self._mode_chat = RadioToolButton(
named_icon='mode-chat',
group=mode_type,
tooltip=_('Voice chat'))
self._mode_chat.connect('toggled', self.__toggled_mode_chat_cb)
toolbox.toolbar.insert(self._mode_chat, -1)
self._voice_button = ToolbarButton(
page=self._make_voice_bar(),
label=_('Voice'),
icon_name='voice')
self._voice_button.connect('clicked', self._configure_cb)
toolbox.toolbar.insert(self._voice_button, -1)
self._face_button = ToolbarButton(
page=self._make_face_bar(),
label=_('Face'),
icon_name='face')
self._face_button.connect('clicked', self._configure_cb)
toolbox.toolbar.insert(self._face_button, -1)
separator = gtk.SeparatorToolItem()
separator.set_draw(False)
separator.set_expand(True)
toolbox.toolbar.insert(separator, -1)
toolbox.toolbar.insert(StopButton(self), -1)
toolbox.show_all()
self.toolbar_box = toolbox
gtk.gdk.screen_get_default().connect('size-changed',
self._configure_cb)
self._first_time = True
self._new_instance()
self._configure_cb()
self._poll_accelerometer()
if self.shared_activity:
# we are joining the activity
self.connect('joined', self._joined_cb)
if self.get_shared():
# we have already joined
self._joined_cb(self)
self._mode_chat.set_active(True)
self._setup_chat_mode()
elif handle.uri:
# XMPP non-sugar3 incoming chat, not sharable
self._activity_button.props.page.share.props.visible = \
False
self._one_to_one_connection(handle.uri)
else:
# we are creating the activity
self.connect('shared', self._shared_cb)
def _toolbar_expanded(self):
if self._activity_button.is_expanded():
return True
if self._voice_button.is_expanded():
return True
if self._face_button.is_expanded():
return True
return False
def _configure_cb(self, event=None):
self._entry.set_size_request(-1, style.GRID_CELL_SIZE)
if self._toolbar_expanded():
self.face.set_size_request(
-1, gtk.gdk.screen_height() - 3 * style.GRID_CELL_SIZE)
self._chat.resize_chat_box(expanded=True)
self._chat.resize_buddy_list()
else:
self.face.set_size_request(
-1, gtk.gdk.screen_height() - 2 * style.GRID_CELL_SIZE)
self._chat.resize_chat_box()
self._chat.resize_buddy_list()
def _new_instance(self):
if self._first_time:
# self.voices.connect('changed', self.__changed_voices_cb)
self.pitchadj.connect('value_changed', self._pitch_adjusted_cb,
self.pitchadj)
self.rateadj.connect('value_changed', self._rate_adjusted_cb,
self.rateadj)
if self._active_number_of_eyes is None:
self._number_of_eyes_changed_event_cb(None, None, 'two', True)
if self._active_eyes is None:
self._eyes_changed_event_cb(None, None, 'eyes', True)
self._mouth_changed_cb(None, True)
self.face.look_ahead()
presenceService = presenceservice.get_instance()
self.owner = presenceService.get_owner()
if self._first_time:
# say hello to the user
if self._tablet_mode:
self._entry.props.text = _('Hello %s.') \
% self.owner.props.nick.encode('utf-8', 'ignore')
self.face.say_notification(_('Hello %s. Please Type something.')
% self.owner.props.nick)
else:
if self._tablet_mode:
self._entry.props.text = _('Welcome back %s.') \
% self.owner.props.nick.encode('utf-8', 'ignore')
self.face.say_notification(_('Welcome back %s.')
% self.owner.props.nick)
self._set_idle_phrase(speak=False)
self._first_time = False
def read_file(self, file_path):
self._cfg = json.loads(file(file_path, 'r').read())
current_voice = self.face.status.voice
status = self.face.status = \
face.Status().deserialize(self._cfg['status'])
found_my_voice = False
for name in self._voice_evboxes.keys():
if self._voice_evboxes[name][1] == current_voice:
self._voice_evboxes[name][0].modify_bg(
0, style.COLOR_BLACK.get_gdk_color())
if self._voice_evboxes[name][1] == status.voice and \
not found_my_voice:
self._voice_evboxes[name][0].modify_bg(
0, style.COLOR_BUTTON_GREY.get_gdk_color())
self.face.set_voice(status.voice)
if self._mode == MODE_BOT:
brain.load(self, status.voice)
found_my_voice = True
self.pitchadj.value = self.face.status.pitch
self.rateadj.value = self.face.status.rate
if status.mouth in MOUTHS:
self._mouth_type[MOUTHS.index(status.mouth)].set_active(True)
self._number_of_eyes_changed_event_cb(
None, None, NUMBERS[len(status.eyes) - 1], True)
for name in EYE_DICT.keys():
if status.eyes[0] == EYE_DICT[name]['widget']:
self._eye_type[name].set_icon(name + '-selected')
self._eyes_changed_event_cb(None, None, name, True)
break
self._entry.props.text = self._cfg['text'].encode('utf-8', 'ignore')
if not self._tablet_mode:
for i in self._cfg['history']:
self._entrycombo.append_text(i.encode('utf-8', 'ignore'))
self._new_instance()
def write_file(self, file_path):
if self._tablet_mode:
if 'history' in self._cfg:
history = self._cfg['history'] # retain old history
else:
history = []
else:
history = [unicode(i[0], 'utf-8', 'ignore')
for i in self._entrycombo.get_model()]
cfg = {'status': self.face.status.serialize(),
'text': unicode(self._entry.props.text, 'utf-8', 'ignore'),
'history': history, }
file(file_path, 'w').write(json.dumps(cfg))
def _cursor_moved_cb(self, entry, *ignored):
# make the eyes track the motion of the text cursor
index = entry.props.cursor_position
layout = entry.get_layout()
pos = layout.get_cursor_pos(index)
x = pos[0][0] / pango.SCALE - entry.props.scroll_offset
y = entry.get_allocation().y
self.face.look_at(pos=(x, y))
def _poll_accelerometer(self):
if _has_accelerometer():
idle_time = self._test_orientation()
gobject.timeout_add(idle_time, self._poll_accelerometer)
def _test_orientation(self):
if _has_accelerometer():
fh = open(ACCELEROMETER_DEVICE)
string = fh.read()
fh.close()
xyz = string[1:-2].split(',')
x = int(xyz[0])
y = int(xyz[1])
# DO SOMETHING HERE
if ((gtk.gdk.screen_width() > gtk.gdk.screen_height() and
abs(x) > abs(y)) or
(gtk.gdk.screen_width() < gtk.gdk.screen_height() and
abs(x) < abs(y))):
sideways_phrase = SIDEWAYS_PHRASES[
random.randint(0, len(SIDEWAYS_PHRASES) - 1)]
self.face.say(SIDEWAYS_PHRASES[sideways_phrase])
return IDLE_DELAY # Don't repeat the message for a while
return 1000 # Test again soon
def get_mouse(self):
display = gtk.gdk.display_get_default()
screen, mouseX, mouseY, modifiers = display.get_pointer()
return mouseX, mouseY
def _mouse_moved_cb(self, widget, event):
# make the eyes track the motion of the mouse cursor
self.face.look_at()
self._chat.look_at()
def _mouse_clicked_cb(self, widget, event):
pass
def _make_voice_bar(self):
voicebar = gtk.Toolbar()
all_voices = []
for name in sorted(voice_model.allVoices().keys()):
if len(name) < 26:
friendly_name = name
else:
friendly_name = name[:26] + '...'
all_voices.append([voice_model.allVoices()[name], friendly_name])
# A palette for the voice selection
logging.error(self.face.status.voice)
self._voice_evboxes = {}
self._voice_box = gtk.HBox()
vboxes = [gtk.VBox(), gtk.VBox(), gtk.VBox()]
count = len(voice_model.allVoices().keys())
found_my_voice = False
for i, voice in enumerate(sorted(all_voices)):
label = gtk.Label()
label.set_use_markup(True)
label.set_justify(gtk.JUSTIFY_LEFT)
label.set_markup('<span size="large">%s</span>' % voice[1])
alignment = gtk.Alignment(0, 0, 0, 0)
alignment.add(label)
label.show()
evbox = gtk.EventBox()
self._voice_evboxes[voice[1]] = [evbox, voice[0]]
self._voice_evboxes[voice[1]][0].connect(
'button-press-event', self._voices_changed_event_cb, voice)
if voice[0] == self.face.status.voice and not found_my_voice:
self._current_voice = voice
evbox.modify_bg(
0, style.COLOR_BUTTON_GREY.get_gdk_color())
found_my_voice = True
evbox.add(alignment)
alignment.show()
if i < count / 3:
vboxes[0].pack_start(evbox)
elif i < 2 * count / 3:
vboxes[1].pack_start(evbox)
else:
vboxes[2].pack_start(evbox)
self._voice_box.pack_start(vboxes[0], padding=style.DEFAULT_PADDING)
self._voice_box.pack_start(vboxes[1], padding=style.DEFAULT_PADDING)
self._voice_box.pack_start(vboxes[2], padding=style.DEFAULT_PADDING)
voice_palette_button = ToolButton('module-language')
voice_palette_button.set_tooltip(_('Choose voice:'))
self._voice_palette = voice_palette_button.get_palette()
self._voice_palette.set_content(self._voice_box)
self._voice_box.show_all()
voice_palette_button.connect('clicked', self._face_palette_cb)
voicebar.insert(voice_palette_button, -1)
voice_palette_button.show()
brain_voices = []
for name in sorted(brain.BOTS.keys()):
brain_voices.append([voice_model.allVoices()[name], name])
self._brain_evboxes = {}
self._brain_box = gtk.HBox()
vboxes = gtk.VBox()
count = brain.BOTS.keys()
found_my_voice = False
for i, voice in enumerate(brain_voices):
label = gtk.Label()
label.set_use_markup(True)
label.set_justify(gtk.JUSTIFY_LEFT)
label.set_markup('<span size="large">%s</span>' % voice[1])
alignment = gtk.Alignment(0, 0, 0, 0)
alignment.add(label)
label.show()
evbox = gtk.EventBox()
self._brain_evboxes[voice[1]] = [evbox, voice[0]]
self._brain_evboxes[voice[1]][0].connect(
'button-press-event', self._voices_changed_event_cb, voice)
if voice[0] == self.face.status.voice and not found_my_voice:
evbox.modify_bg(
0, style.COLOR_BUTTON_GREY.get_gdk_color())
found_my_voice = True
evbox.add(alignment)
alignment.show()
vboxes.pack_start(evbox)
self._brain_box.pack_start(vboxes, padding=style.DEFAULT_PADDING)
self._brain_box.show_all()
separator = gtk.SeparatorToolItem()
separator.set_draw(True)
separator.set_expand(False)
voicebar.insert(separator, -1)
self.pitchadj = gtk.Adjustment(self.face.status.pitch, 0,
espeak.PITCH_MAX, 1,
espeak.PITCH_MAX/10, 0)
pitchbar = gtk.HScale(self.pitchadj)
pitchbar.set_draw_value(False)
# pitchbar.set_inverted(True)
pitchbar.set_update_policy(gtk.UPDATE_DISCONTINUOUS)
pitchbar.set_size_request(240, 15)
pitchbar_toolitem = ToolWidget(widget=pitchbar, label_text=_('Pitch:'))
voicebar.insert(pitchbar_toolitem, -1)
self.rateadj = gtk.Adjustment(self.face.status.rate, 0,
espeak.RATE_MAX,
1, espeak.RATE_MAX / 10, 0)
ratebar = gtk.HScale(self.rateadj)
ratebar.set_draw_value(False)
# ratebar.set_inverted(True)
ratebar.set_update_policy(gtk.UPDATE_DISCONTINUOUS)
ratebar.set_size_request(240, 15)
ratebar_toolitem = ToolWidget(widget=ratebar, label_text=_('Rate:'))
voicebar.insert(ratebar_toolitem, -1)
voicebar.show_all()
return voicebar
def _pitch_adjusted_cb(self, get, data=None):
self.face.status.pitch = get.value
self.face.say_notification(_('pitch adjusted'))
def _rate_adjusted_cb(self, get, data=None):
self.face.status.rate = get.value
self.face.say_notification(_('rate adjusted'))
def _make_face_bar(self):
facebar = gtk.Toolbar()
self._mouth_type = []
self._mouth_type.append(RadioToolButton(
named_icon='mouth',
group=None,
tooltip=_('Simple')))
self._mouth_type[-1].connect('clicked', self._mouth_changed_cb, False)
facebar.insert(self._mouth_type[-1], -1)
self._mouth_type.append(RadioToolButton(
named_icon='waveform',
group=self._mouth_type[0],
tooltip=_('Waveform')))
self._mouth_type[-1].connect('clicked', self._mouth_changed_cb, False)
facebar.insert(self._mouth_type[-1], -1)
self._mouth_type.append(RadioToolButton(
named_icon='frequency',
group=self._mouth_type[0],
tooltip=_('Frequency')))
self._mouth_type[-1].connect('clicked', self._mouth_changed_cb, False)
facebar.insert(self._mouth_type[-1], -1)
separator = gtk.SeparatorToolItem()
separator.set_draw(True)
separator.set_expand(False)
facebar.insert(separator, -1)
eye_box = gtk.VBox()
self._eye_type = {}
for name in EYE_DICT.keys():
self._eye_type[name] = ToolButton(name)
self._eye_type[name].connect('clicked',
self._eyes_changed_event_cb,
None, name, False)
label = gtk.Label(EYE_DICT[name]['label'])
hbox = gtk.HBox()
hbox.pack_start(self._eye_type[name])
self._eye_type[name].show()
hbox.pack_start(label)
label.show()
evbox = gtk.EventBox()
evbox.connect('button-press-event', self._eyes_changed_event_cb,
name, False)
evbox.add(hbox)
hbox.show()
eye_box.pack_start(evbox)
eye_palette_button = ToolButton('eyes')
eye_palette_button.set_tooltip(_('Choose eyes:'))
palette = eye_palette_button.get_palette()
palette.set_content(eye_box)
eye_box.show_all()
eye_palette_button.connect('clicked', self._face_palette_cb)
facebar.insert(eye_palette_button, -1)
eye_palette_button.show()
number_of_eyes_box = gtk.VBox()
self._number_of_eyes_type = {}
for name in NUMBERS:
self._number_of_eyes_type[name] = ToolButton(name)
self._number_of_eyes_type[name].connect(
'clicked', self._number_of_eyes_changed_event_cb,
None, name, False)
label = gtk.Label(name)
hbox = gtk.HBox()
hbox.pack_start(self._number_of_eyes_type[name])
self._number_of_eyes_type[name].show()
hbox.pack_start(label)
label.show()
evbox = gtk.EventBox()
evbox.connect('button-press-event',
self._number_of_eyes_changed_event_cb,
name, False)
evbox.add(hbox)
hbox.show()
number_of_eyes_box.pack_start(evbox)
number_of_eyes_palette_button = ToolButton('number')
number_of_eyes_palette_button.set_tooltip(_('Eyes number:'))
palette = number_of_eyes_palette_button.get_palette()
palette.set_content(number_of_eyes_box)
number_of_eyes_box.show_all()
number_of_eyes_palette_button.connect('clicked', self._face_palette_cb)
facebar.insert(number_of_eyes_palette_button, -1)
number_of_eyes_palette_button.show()
facebar.show_all()
return facebar
def _face_palette_cb(self, button):
palette = button.get_palette()
if palette:
if not palette.is_up():
palette.popup(immediate=True, state=palette.SECONDARY)
else:
palette.popdown(immediate=True)
def _get_active_mouth(self):
for i, button in enumerate(self._mouth_type):
if button.get_active():
return MOUTHS[i]
def _mouth_changed_cb(self, ignored, quiet):
value = self._get_active_mouth()
if value is None:
return
self.face.status.mouth = value
self._update_face()
# this SegFaults: self.face.say(combo.get_active_text())
if not quiet:
self.face.say_notification(_('mouth changed'))
def _voices_changed_event_cb(self, widget, event, voice):
logging.error('voices_changed_event_cb %r %s' % (voice[0], voice[1]))
if self._mode == MODE_BOT:
evboxes = self._brain_evboxes
else:
evboxes = self._voice_evboxes
for old_voice in evboxes.keys():
if evboxes[old_voice][1] == self.face.status.voice:
evboxes[old_voice][0].modify_bg(
0, style.COLOR_BLACK.get_gdk_color())
break
evboxes[voice[1]][0].modify_bg(
0, style.COLOR_BUTTON_GREY.get_gdk_color())
self.face.set_voice(voice[0])
if self._mode == MODE_BOT:
brain.load(self, voice[0])
else:
self._current_voice = voice
def _get_active_eyes(self):
for name in EYE_DICT.keys():
if EYE_DICT[name]['index'] == self._active_eyes:
return EYE_DICT[name]['widget']
return None
def _eyes_changed_event_cb(self, widget, event, name, quiet):
if self._active_eyes is not None:
for old_name in EYE_DICT.keys():
if EYE_DICT[old_name]['index'] == self._active_eyes:
self._eye_type[old_name].set_icon(old_name)
break
if self._active_number_of_eyes is None:
self._active_number_of_eyes = 2
if name is not None:
self._active_eyes = EYE_DICT[name]['index']
self._eye_type[name].set_icon(name + '-selected')
value = EYE_DICT[name]['widget']
self.face.status.eyes = [value] * self._active_number_of_eyes
self._update_face()
if not quiet:
self.face.say_notification(_('eyes changed'))
def _number_of_eyes_changed_event_cb(self, widget, event, name, quiet):
if self._active_number_of_eyes is not None:
old_name = NUMBERS[self._active_number_of_eyes - 1]
self._number_of_eyes_type[old_name].set_icon(old_name)
if name in NUMBERS:
self._active_number_of_eyes = NUMBERS.index(name) + 1
self._number_of_eyes_type[name].set_icon(name + '-selected')
if self._active_eyes is not None:
for eye_name in EYE_DICT.keys():
if EYE_DICT[eye_name]['index'] == self._active_eyes:
value = EYE_DICT[eye_name]['widget']
self.face.status.eyes = \
[value] * self._active_number_of_eyes
self._update_face()
if not quiet:
self.face.say_notification(_('eyes changed'))
break
def _update_face(self):
self.face.update()
self._chat.update(self.face.status)
def _combo_changed_cb(self, combo):
# when a new item is chosen, make sure the text is selected
if not self._entry.is_focus():
if not self._tablet_mode:
self._entry.grab_focus()
self._entry.select_region(0, -1)
def _entry_key_press_cb(self, combo, event):
# make the up/down arrows navigate through our history
if self._tablet_mode:
return
keyname = gtk.gdk.keyval_name(event.keyval)
if keyname == 'Up':
index = self._entrycombo.get_active()
if index > 0:
index -= 1
self._entrycombo.set_active(index)
self._entry.select_region(0, -1)
return True
elif keyname == 'Down':
index = self._entrycombo.get_active()
if index < len(self._entrycombo.get_model()) - 1:
index += 1
self._entrycombo.set_active(index)
self._entry.select_region(0, -1)
return True
return False
def _entry_activate_cb(self, entry):
# the user pressed Return, say the text and clear it out
text = entry.props.text
if self._tablet_mode:
self._dismiss_OSK(entry)
timeout = DELAY_BEFORE_SPEAKING
else:
timeout = 100
gobject.timeout_add(timeout, self._speak_the_text, entry, text)
def _dismiss_OSK(self, entry):
entry.hide()
entry.show()
def _talk_cb(self, button):
text = self._entry.props.text
self._speak_the_text(self._entry, text)
def _speak_the_text(self, entry, text):
self._remove_idle()
if text:
self.face.look_ahead()
# speak the text
if self._mode == MODE_BOT:
self.face.say(brain.respond(text))
else:
self.face.say(text)
if text and not self._tablet_mode:
# add this text to our history unless it is the same as
# the last item
history = self._entrycombo.get_model()
if len(history) == 0 or history[-1][0] != text:
self._entrycombo.append_text(text)
# don't let the history get too big
while len(history) > 20:
self._entrycombo.remove_text(0)
# select the new item
self._entrycombo.set_active(len(history) - 1)
if text:
# select the whole text
entry.select_region(0, -1)
# Launch an robot idle phase after 2 minutes
self._robot_idle_id = gobject.timeout_add(IDLE_DELAY,
self._set_idle_phrase)
def _load_sleeping_face(self):
current_eyes = self.face.status.eyes
self.face.status.eyes = [SLEEPY_EYES] * self._active_number_of_eyes
self._update_face()
self.face.status.eyes = current_eyes
def _set_idle_phrase(self, speak=True):
if speak:
self._load_sleeping_face()
idle_phrase = IDLE_PHRASES[random.randint(
0, len(IDLE_PHRASES) - 1)]
if self.props.active:
self.face.say(idle_phrase)
self._robot_idle_id = gobject.timeout_add(IDLE_DELAY,
self._set_idle_phrase)
def _active_cb(self, widget, pspec):
# only generate sound when this activity is active
if not self.props.active:
self._load_sleeping_face()
self.face.shut_up()
self._chat.shut_up()
def _set_voice(self, new_voice=None):
if new_voice is not None:
logging.error('set_voice %r' % new_voice)
self.face.status.voice = new_voice
else:
logging.error('set_voice to current voice %s' %
self._current_voice[1])
self.face.status.voice = self._current_voice[0]
def __toggled_mode_type_cb(self, button):
if not button.props.active:
return
self._mode = MODE_TYPE
self._chat.shut_up()
self.face.shut_up()
self._notebook.set_current_page(0)
self._voice_palette.set_content(self._voice_box)
self._set_voice()
def __toggled_mode_robot_cb(self, button):
if not button.props.active:
return
self._remove_idle()
self._mode = MODE_BOT
self._chat.shut_up()
self.face.shut_up()
self._notebook.set_current_page(0)
self._voice_palette.set_content(self._brain_box)
new_voice = None
for name in brain.BOTS.keys():
if self._current_voice[0].short_name == name:
new_voice == self._current_voice[0]
break
if new_voice is None:
new_voice = brain.get_default_voice()
if new_voice.friendlyname in self._current_voice[0].friendlyname:
logging.debug('skipping sorry message for %s %s' %
(new_voice.friendlyname,
self._current_voice[0].friendlyname))
sorry = None
else:
sorry = _("Sorry, I can't speak %(old_voice)s, "
"let's talk %(new_voice)s instead.") % {
'old_voice': self._current_voice[0].friendlyname,
'new_voice': new_voice.friendlyname}
else:
new_voice = new_voice[0]
sorry = None
self._set_voice(new_voice)
evboxes = self._brain_evboxes
for old_voice in evboxes.keys():
evboxes[old_voice][0].modify_bg(
0, style.COLOR_BLACK.get_gdk_color())
if new_voice.short_name in evboxes:
evboxes[new_voice.short_name][0].modify_bg(
0, style.COLOR_BUTTON_GREY.get_gdk_color())
if not brain.load(self, new_voice, sorry):
if sorry:
self.face.say_notification(sorry)
def __toggled_mode_chat_cb(self, button):
if not button.props.active:
return
self._remove_idle()
is_first_session = not self.shared_activity
self._setup_chat_mode()
if is_first_session:
self._chat.me.say_notification(
_('You are in off-line mode, share and invite someone.'))
def _remove_idle(self):
if self._robot_idle_id is not None:
gobject.source_remove(self._robot_idle_id)
value = self._get_active_eyes()
if value is not None:
self.face.status.eyes = [value] * self._active_number_of_eyes
self._update_face()
def _setup_chat_mode(self):
self._mode = MODE_CHAT
self._remove_idle()
self.face.shut_up()
self._notebook.set_current_page(1)
self._voice_palette.set_content(self._voice_box)
self._set_voice()
def _shared_cb(self, sender):
logging.error('SHARED A CHAT')
self._setup_text_channel()
def _joined_cb(self, sender):
'''Joined a shared activity.'''
if not self.shared_activity:
return
logger.error('JOINED A SHARED CHAT')
for buddy in self.shared_activity.get_joined_buddies():
self._buddy_already_exists(buddy)
self._setup_text_channel()
def _one_to_one_connection(self, tp_channel):
'''Handle a private invite from a non-sugar3 XMPP client.'''
if self.shared_activity or self.text_channel:
return
bus_name, connection, channel = json.loads(tp_channel)
logger.debug('GOT XMPP: %s %s %s', bus_name, connection, channel)
Connection(bus_name, connection, ready_handler=lambda conn:
self._one_to_one_connection_ready_cb(
bus_name, channel, conn))
def _one_to_one_connection_ready_cb(self, bus_name, channel, conn):
'''Callback for Connection for one to one connection'''
text_channel = Channel(bus_name, channel)
self.text_channel = TextChannelWrapper(text_channel, conn)
self.text_channel.set_received_callback(self._received_cb)
self.text_channel.handle_pending_messages()
self.text_channel.set_closed_callback(
self._one_to_one_connection_closed_cb)
# XXX How do we detect the sender going offline?
self._chat.chat_post.set_sensitive(True)
# self._chat.chat_post.props.placeholder_text = None
self._chat.chat_post.grab_focus()
def _one_to_one_connection_closed_cb(self):
'''Callback for when the text channel closes.'''
pass
def _setup_text_channel(self):
logging.error('_SETUP_TEXTCHANNEL')
self.text_channel = TextChannelWrapper(
self.shared_activity.telepathy_text_chan,
self.shared_activity.telepathy_conn)
self.text_channel.set_received_callback(self._received_cb)
self.shared_activity.connect('buddy-joined', self._buddy_joined_cb)
self.shared_activity.connect('buddy-left', self._buddy_left_cb)
self._chat.messenger = self.text_channel
self._chat.chat_post.set_sensitive(True)
self._chat.chat_post.grab_focus()
def _buddy_joined_cb(self, sender, buddy):
'''Show a buddy who joined'''
if buddy == self.owner:
return
logging.error('%s joined the chat (%r)' % (buddy.props.nick, buddy))
self._chat.post(
buddy, _('%s joined the chat') % buddy.props.nick,
status_message=True)
def _buddy_left_cb(self, sender, buddy):
'''Show a buddy who joined'''
if buddy == self.owner:
return
logging.error('%s left the chat (%r)' % (buddy.props.nick, buddy))
self._chat.post(
buddy, _('%s left the chat') % buddy.props.nick,
status_message=True)
self._chat.farewell(buddy)
def _buddy_already_exists(self, buddy):
'''Show a buddy already in the chat.'''
if buddy == self.owner:
return
logging.error('%s is here (%r)' % (buddy.props.nick, buddy))
self._chat.post(
buddy, _('%s is here') % buddy.props.nick,
status_message=True)
def _received_cb(self, buddy, text):
'''Show message that was received.'''
if buddy:
if type(buddy) is dict:
nick = buddy['nick']
else:
nick = buddy.props.nick
else:
nick = '???'
logger.debug('Received message from %s: %s', nick, text)
self._chat.post(buddy, text)
def __init__(self, handle):
super(SpeakActivity, self).__init__(handle)
self._notebook = gtk.Notebook()
self.set_canvas(self._notebook)
self._notebook.show()
self._colors = profile.get_color().to_string().split(',')
lighter = style.Color(self._colors[
_lighter_color(self._colors)])
self._mode = MODE_TYPE
self._tablet_mode = _is_tablet_mode()
self._robot_idle_id = None
self._active_eyes = None
self._active_number_of_eyes = None
self._current_voice = None
# make an audio device for playing back and rendering audio
self.connect('notify::active', self._active_cb)
self._cfg = {}
# make a box to type into
hbox = gtk.HBox()
if self._tablet_mode:
self._entry = gtk.Entry()
hbox.pack_start(self._entry, expand=True)
talk_button = ToolButton('microphone')
talk_button.set_tooltip(_('Speak'))
talk_button.connect('clicked', self._talk_cb)
hbox.pack_end(talk_button, expand=False)
else:
self._entrycombo = gtk.combo_box_entry_new_text()
self._entrycombo.connect('changed', self._combo_changed_cb)
self._entry = self._entrycombo.child
self._entry.set_size_request(-1, style.GRID_CELL_SIZE)
hbox.pack_start(self._entrycombo, expand=True)
self._entry.set_editable(True)
self._entry.connect('activate', self._entry_activate_cb)
self._entry.connect('key-press-event', self._entry_key_press_cb)
self._entry.modify_font(pango.FontDescription(str='sans bold 24'))
hbox.show()
self.face = face.View(fill_color=lighter)
self.face.set_size_request(
-1, gtk.gdk.screen_height() - 2 * style.GRID_CELL_SIZE)
self.face.show()
# layout the screen
box = gtk.VBox(homogeneous=False)
if self._tablet_mode:
box.pack_start(hbox, expand=False)
box.pack_start(self.face)
else:
box.pack_start(self.face, expand=True)
box.pack_start(hbox)
self.add_events(gtk.gdk.POINTER_MOTION_HINT_MASK
| gtk.gdk.POINTER_MOTION_MASK)
self.connect('motion_notify_event', self._mouse_moved_cb)
box.add_events(gtk.gdk.BUTTON_PRESS_MASK)
box.connect('button_press_event', self._mouse_clicked_cb)
# desktop
self._notebook.show()
self._notebook.props.show_border = False
self._notebook.props.show_tabs = False
box.show_all()
self._notebook.append_page(box)
self._chat = chat.View()
self._chat.show_all()
self._notebook.append_page(self._chat)
# make the text box active right away
if not self._tablet_mode:
self._entry.grab_focus()
self._entry.connect('move-cursor', self._cursor_moved_cb)
self._entry.connect('changed', self._cursor_moved_cb)
toolbox = ToolbarBox()
self._activity_button = ActivityToolbarButton(self)
self._activity_button.connect('clicked', self._configure_cb)
toolbox.toolbar.insert(self._activity_button, -1)
mode_type = RadioToolButton(
named_icon='mode-type',
tooltip=_('Type something to hear it'))
mode_type.connect('toggled', self.__toggled_mode_type_cb)
toolbox.toolbar.insert(mode_type, -1)
mode_robot = RadioToolButton(
named_icon='mode-robot',
group=mode_type,
tooltip=_('Ask robot any question'))
mode_robot.connect('toggled', self.__toggled_mode_robot_cb)
toolbox.toolbar.insert(mode_robot, -1)
self._mode_chat = RadioToolButton(
named_icon='mode-chat',
group=mode_type,
tooltip=_('Voice chat'))
self._mode_chat.connect('toggled', self.__toggled_mode_chat_cb)
toolbox.toolbar.insert(self._mode_chat, -1)
self._voice_button = ToolbarButton(
page=self._make_voice_bar(),
label=_('Voice'),
icon_name='voice')
self._voice_button.connect('clicked', self._configure_cb)
toolbox.toolbar.insert(self._voice_button, -1)
self._face_button = ToolbarButton(
page=self._make_face_bar(),
label=_('Face'),
icon_name='face')
self._face_button.connect('clicked', self._configure_cb)
toolbox.toolbar.insert(self._face_button, -1)
separator = gtk.SeparatorToolItem()
separator.set_draw(False)
separator.set_expand(True)
toolbox.toolbar.insert(separator, -1)
toolbox.toolbar.insert(StopButton(self), -1)
toolbox.show_all()
self.toolbar_box = toolbox
gtk.gdk.screen_get_default().connect('size-changed',
self._configure_cb)
self._first_time = True
self._new_instance()
self._configure_cb()
self._poll_accelerometer()
if self.shared_activity:
# we are joining the activity
self.connect('joined', self._joined_cb)
if self.get_shared():
# we have already joined
self._joined_cb(self)
self._mode_chat.set_active(True)
self._setup_chat_mode()
elif handle.uri:
# XMPP non-sugar3 incoming chat, not sharable
self._activity_button.props.page.share.props.visible = \
False
self._one_to_one_connection(handle.uri)
else:
# we are creating the activity
self.connect('shared', self._shared_cb)
def _setup_toolbars(self):
''' Setup the toolbars. '''
self.max_participants = 6
if HAVE_TOOLBOX:
toolbox = ToolbarBox()
# Activity toolbar
activity_button_toolbar = ActivityToolbarButton(self)
toolbox.toolbar.insert(activity_button_toolbar, 0)
activity_button_toolbar.show()
self.set_toolbar_box(toolbox)
toolbox.show()
self.toolbar = toolbox.toolbar
self.record_toolbar = gtk.Toolbar()
record_toolbar_button = ToolbarButton(
label=_('Record a sound'),
page=self.record_toolbar,
icon_name='media-audio')
self.record_toolbar.show_all()
record_toolbar_button.show()
toolbox.toolbar.insert(record_toolbar_button, -1)
else:
# Use pre-0.86 toolbar design
primary_toolbar = gtk.Toolbar()
toolbox = activity.ActivityToolbox(self)
self.set_toolbox(toolbox)
toolbox.add_toolbar(_('Page'), primary_toolbar)
self.record_toolbar = gtk.Toolbar()
toolbox.add_toolbar(_('Record'), self.record_toolbar)
toolbox.show()
toolbox.set_current_toolbar(1)
self.toolbar = primary_toolbar
self._prev_button = button_factory(
'go-previous-inactive', self.toolbar, self._prev_cb,
tooltip=_('Prev slide'), accelerator='<Ctrl>P')
self._next_button = button_factory(
'go-next', self.toolbar, self._next_cb,
tooltip=_('Next slide'), accelerator='<Ctrl>N')
separator_factory(self.toolbar)
slide_button = radio_factory('slide-view', self.toolbar,
self._slides_cb, group=None,
tooltip=_('Slide view'))
radio_factory('thumbs-view', self.toolbar, self._thumbs_cb,
tooltip=_('Thumbnail view'),
group=slide_button)
button_factory('view-fullscreen', self.toolbar,
self.do_fullscreen_cb, tooltip=_('Fullscreen'),
accelerator='<Alt>Return')
separator_factory(self.toolbar)
journal_button = button_factory(
'write-journal', self.toolbar, self._do_journal_cb,
tooltip=_('Update description'))
self._palette = journal_button.get_palette()
msg_box = gtk.HBox()
sw = gtk.ScrolledWindow()
sw.set_size_request(int(gtk.gdk.screen_width() / 2),
2 * style.GRID_CELL_SIZE)
sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
self._text_view = gtk.TextView()
self._text_view.set_left_margin(style.DEFAULT_PADDING)
self._text_view.set_right_margin(style.DEFAULT_PADDING)
self._text_view.set_wrap_mode(gtk.WRAP_WORD_CHAR)
self._text_view.connect('focus-out-event',
self._text_view_focus_out_event_cb)
sw.add(self._text_view)
sw.show()
msg_box.pack_start(sw, expand=False)
msg_box.show_all()
self._palette.set_content(msg_box)
label_factory(self.record_toolbar, _('Record a sound') + ':')
self._record_button = button_factory(
'media-record', self.record_toolbar,
self._record_cb, tooltip=_('Start recording'))
separator_factory(self.record_toolbar)
# Look to see if we have audio previously recorded
obj_id = self._get_audio_obj_id()
dsobject = self._search_for_audio_note(obj_id)
if dsobject is not None:
_logger.debug('Found previously recorded audio')
self._add_playback_button(profile.get_nick_name(),
self.colors,
dsobject.file_path)
if HAVE_TOOLBOX:
button_factory('system-restart', activity_button_toolbar,
self._resend_cb, tooltip=_('Refresh'))
separator_factory(activity_button_toolbar)
self._save_pdf = button_factory(
'save-as-pdf', activity_button_toolbar,
self._save_as_pdf_cb, tooltip=_('Save as PDF'))
else:
separator_factory(self.toolbar)
self._save_pdf = button_factory(
'save-as-pdf', self.toolbar,
self._save_as_pdf_cb, tooltip=_('Save as PDF'))
if HAVE_TOOLBOX:
separator_factory(toolbox.toolbar, True, False)
stop_button = StopButton(self)
stop_button.props.accelerator = '<Ctrl>q'
toolbox.toolbar.insert(stop_button, -1)
stop_button.show()
def 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()
separator = gtk.SeparatorToolItem()
toolbar_box.toolbar.insert(separator, -1)
separator.show()
self.build_colors_toolbar(toolbar_box)
separator = gtk.SeparatorToolItem()
toolbar_box.toolbar.insert(separator, -1)
separator.show()
# new game button
new_game = ToolButton('new-game')
new_game.connect('clicked', self._new_game)
new_game.set_tooltip(_('New game'))
toolbar_box.toolbar.insert(new_game, -1)
separator = gtk.SeparatorToolItem()
toolbar_box.toolbar.insert(separator, -1)
separator.show()
#current
item = gtk.ToolItem()
label = gtk.Label()
label.set_text(' %s ' % _('Current player:'))
item.add(label)
toolbar_box.toolbar.insert(item, -1)
#player
item = gtk.ToolItem()
self.current_label = gtk.Label()
self.current_label.set_text(' %s' % 1)
item.add(self.current_label)
toolbar_box.toolbar.insert(item, -1)
separator = gtk.SeparatorToolItem()
toolbar_box.toolbar.insert(separator, -1)
separator.show()
sound_button = ToolButton('speaker-muted-100')
sound_button.set_tooltip(_('Sound'))
sound_button.connect('clicked', self.sound_control)
toolbar_box.toolbar.insert(sound_button, -1)
# separator and stop
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()
self.show_all()