class ActivityToolbar(gtk.Toolbar):
"""The Activity toolbar with the Journal entry title, sharing,
Keep and Stop buttons
All activities should have this toolbar. It is easiest to add it to your
Activity by using the ActivityToolbox.
"""
def __init__(self, activity):
gtk.Toolbar.__init__(self)
self._activity = activity
self._updating_share = False
self._focus_out_hid = None
activity.connect('shared', self.__activity_shared_cb)
activity.connect('joined', self.__activity_shared_cb)
activity.connect('notify::max_participants',
self.__max_participants_changed_cb)
if activity.metadata:
self.title = gtk.Entry()
self.title.set_size_request(int(gtk.gdk.screen_width() / 3), -1)
self.title.set_text(activity.metadata['title'])
self._focus_out_hid = self.title.connect('focus-out-event',
self.__title_changed_cb)
self._add_widget(self.title)
activity.metadata.connect('updated', self.__jobject_updated_cb)
separator = gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
self.insert(separator, -1)
separator.show()
self.share = ToolComboBox(label_text=_('Share with:'))
self.share.combo.connect('changed', self.__share_changed_cb)
self.share.combo.append_item(SCOPE_PRIVATE, _('Private'), 'zoom-home')
self.share.combo.append_item(SCOPE_NEIGHBORHOOD, _('My Neighborhood'),
'zoom-neighborhood')
self.insert(self.share, -1)
self.share.show()
self._update_share()
self.keep = ToolButton(tooltip=_('Keep'))
client = gconf.client_get_default()
color = XoColor(client.get_string('/desktop/sugar/user/color'))
keep_icon = Icon(icon_name='document-save', xo_color=color)
self.keep.set_icon_widget(keep_icon)
keep_icon.show()
self.keep.props.accelerator = '<Ctrl>S'
self.keep.connect('clicked', self.__keep_clicked_cb)
self.insert(self.keep, -1)
self.keep.show()
self.stop = ToolButton('activity-stop', tooltip=_('Stop'))
self.stop.props.accelerator = '<Ctrl>Q'
self.stop.connect('clicked', self.__stop_clicked_cb)
self.insert(self.stop, -1)
self.stop.show()
def _update_share(self):
self._updating_share = True
if self._activity.props.max_participants == 1:
self.share.hide()
if self._activity.get_shared():
self.share.set_sensitive(False)
self.share.combo.set_active(1)
else:
self.share.set_sensitive(True)
self.share.combo.set_active(0)
self._updating_share = False
def __share_changed_cb(self, combo):
if self._updating_share:
return
model = self.share.combo.get_model()
it = self.share.combo.get_active_iter()
(scope, ) = model.get(it, 0)
if scope == SCOPE_NEIGHBORHOOD:
self._activity.share()
def __keep_clicked_cb(self, button):
self._activity.copy()
def __stop_clicked_cb(self, button):
if self._focus_out_hid is not None:
self.title.disconnect(self._focus_out_hid)
self._update_title(self.title.get_text())
self._activity.close()
def __jobject_updated_cb(self, jobject):
self.title.set_text(jobject['title'])
def __title_changed_cb(self, editable, event):
title = editable.get_text()
self._update_title(title)
def _update_title(self, title):
# Title really changed?
if title == self._activity.metadata['title']:
return False
self._activity.metadata['title'] = title
self._activity.metadata['title_set_by_user'] = '******'
self._activity.save()
shared_activity = self._activity.get_shared_activity()
if shared_activity:
shared_activity.props.name = title
return False
def _add_widget(self, widget, expand=False):
tool_item = gtk.ToolItem()
tool_item.set_expand(expand)
tool_item.add(widget)
widget.show()
self.insert(tool_item, -1)
tool_item.show()
def __activity_shared_cb(self, activity):
self._update_share()
def __max_participants_changed_cb(self, activity, pspec):
self._update_share()
class RecordControl():
def __init__(self, toolbar):
self._timer_combo = TimerCombo()
toolbar.insert(self._timer_combo, -1)
self._duration_combo = DurationCombo()
toolbar.insert(self._duration_combo, -1)
preferences_toolbar = gtk.Toolbar()
combo = gtk.combo_box_new_text()
self.quality = ToolComboBox(combo=combo, label_text=_('Quality:'))
self.quality.combo.append_text(_('Low'))
if hw.get_xo_version() != 1:
# Disable High quality on XO-1. The system simply isn't beefy
# enough for recording to work well.
self.quality.combo.append_text(_('High'))
self.quality.combo.set_active(0)
self.quality.show_all()
preferences_toolbar.insert(self.quality, -1)
preferences_button = ToolbarButton()
preferences_button.set_page(preferences_toolbar)
preferences_button.props.icon_name = 'preferences-system'
preferences_button.props.label = _('Preferences')
toolbar.insert(preferences_button, -1)
def set_mode(self, mode):
if mode == constants.MODE_PHOTO:
self.quality.set_sensitive(True)
self._timer_combo.set_sensitive(True)
self._duration_combo.set_sensitive(False)
if mode == constants.MODE_VIDEO:
self.quality.set_sensitive(True)
self._timer_combo.set_sensitive(True)
self._duration_combo.set_sensitive(True)
if mode == constants.MODE_AUDIO:
self.quality.set_sensitive(False)
self._timer_combo.set_sensitive(True)
self._duration_combo.set_sensitive(True)
def get_timer(self):
return self._timer_combo.get_value()
def get_timer_idx(self):
return self._timer_combo.get_value_idx()
def set_timer_idx(self, idx):
self._timer_combo.set_value_idx(idx)
def get_duration(self):
return self._duration_combo.get_value()
def get_duration_idx(self):
return self._duration_combo.get_value_idx()
def set_duration_idx(self, idx):
return self._duration_combo.set_value_idx(idx)
def get_quality(self):
return self.quality.combo.get_active()
def set_quality(self, idx):
self.quality.combo.set_active(idx)
class Jam2JamToolBar(gtk.Toolbar):
def __init__(self, activity):
gtk.Toolbar.__init__(self)
self.activity = activity
self.parameters = ['Density', 'Pitch', 'Length', 'Timbre', 'Volume'] # no tempo here.
scene_stuff = readScenes(self.activity._ScenePath)
self.scenes = scene_stuff.get_scene_list()
#example of scene data. This gets read from file
#self.scenes = [['City', 'A', 'minor pentatonic'], ['City', 'G#', 'major']] #this data needs to be obtained from directories
self.play_pause_state = 'Playing'
self.scene_init = True
# Separator
separator = gtk.SeparatorToolItem()
separator.set_draw(True)
self.insert(separator, -1)
#Horizontal Parameter control combobox
self._add_widget(gtk.Label(_('Horizontal:')))
self._Hparameter_combo = ToolComboBox()
for i, f in enumerate(self.parameters):
self._Hparameter_combo.combo.append_item(i, f)
self._Hparameter_combo.combo.connect('changed', self._Hparameter_change_cb)
self._add_widget(self._Hparameter_combo)
self._Hparameter_combo.combo.set_active(0)
# Separator
separator = gtk.SeparatorToolItem()
separator.set_draw(True)
separator.show()
self.insert(separator, -1)
#Vertical Parameter control combobox
self._add_widget(gtk.Label(_('Vertical:')))
self._Vparameter_combo = ToolComboBox()
for j, k in enumerate(self.parameters):
self._Vparameter_combo.combo.append_item(j, k)
self._Vparameter_combo.combo.connect('changed', self._Vparameter_change_cb)
self._add_widget(self._Vparameter_combo)
self._Vparameter_combo.combo.set_active(1)
# Separator
separator = gtk.SeparatorToolItem()
separator.set_draw(True)
separator.show()
self.insert(separator, -1)
#Scene Selection control combobox
self._add_widget(gtk.Label(_('Scene:')))
self._Scene_combo = ToolComboBox()
for l, m in enumerate(self.scenes):
self._Scene_combo.combo.append_item(l, m[0])
self._Scene_combo.combo.connect('changed', self._Scene_change_cb)
self._add_widget(self._Scene_combo)
#ought to do this safely somehow.
self._Scene_combo.combo.set_active(0)
self.scene_init = False
# Separator
separator = gtk.SeparatorToolItem()
separator.set_draw(True)
separator.show()
self.insert(separator, -1)
#Camera Button
self.camera_ready = True
camera_icon = ImagePath + "/camera-external.svg"
camera_busy_icon = ImagePath + "/camera-busy.svg"
self.camera_image, self.camera_busy_image = gtk.Image(), gtk.Image()
self.camera_image.set_from_file(camera_icon)
self.camera_busy_image.set_from_file(camera_busy_icon)
self.camera_image.show()
#camera_busy_image.show()
self._cameraButton = ToolButton()
self._cameraButton.set_icon_widget(self.camera_image)
self._cameraButton.connect('clicked', self._cameraSnap_cb)
self._cameraButton.set_tooltip(_('Snapshot'))
self.insert(self._cameraButton, -1)
self._cameraButton.show()
# Separator
separator = gtk.SeparatorToolItem()
separator.set_draw(True)
separator.show()
self.insert(separator, -1)
#Play/Pause Button
pause_icon = ImagePath + "/media-playback-pause.svg"
play_icon = ImagePath + "/media-playback-start.svg"
self.pause_image = gtk.Image()
self.pause_image.set_from_file(pause_icon)
self.play_image = gtk.Image()
self.play_image.set_from_file(play_icon)
self._pauseButton = ToolButton()
self._pauseButton.connect('clicked', self._pause_cb)
self.pause_image.show()
self._pauseButton.set_icon_widget(self.pause_image)
self._pauseButton.set_tooltip(_('Pause'))
#self._toggleplay_pause()
self.insert(self._pauseButton, -1)
self._pauseButton.show()
# Separator
separator = gtk.SeparatorToolItem()
separator.set_draw(True)
separator.show()
self.insert(separator, -1)
def _add_widget(self, widget, expand=False):
tool_item = gtk.ToolItem()
tool_item.set_expand(expand)
tool_item.add(widget)
widget.show()
self.insert(tool_item, -1)
tool_item.show()
def _toggleplay_pause(self):
if self.play_pause_state == "Playing":
self.activity.jamScene.music_player.pause()
self.play_image.show()
self._pauseButton.set_icon_widget(self.play_image)
self._pauseButton.set_tooltip(_('Play'))
self.play_pause_state = "Paused"
else:
self.activity.jamScene.music_player.resume()
self.pause_image.show()
self._pauseButton.set_icon_widget(self.pause_image)
self._pauseButton.set_tooltip(_('Pause'))
self.play_pause_state = "Playing"
try:
self.activity._pgc.grab_focus()
except AttributeError:
pass
def _show_busy_camera(self):
self.camera_ready = False
self.camera_busy_image.show()
self._cameraButton.set_icon_widget(self.camera_busy_image)
self._cameraButton.set_tooltip(_('Please wait...'))
def _show_active_camera(self):
self.camera_image.show()
self._cameraButton.set_icon_widget(self.camera_image)
self._cameraButton.set_tooltip(_('Snap'))
self.camera_ready = True
def _Hparameter_change_cb(self, widget):
param = "Parameter|Horizontal|" + self.parameters[self._Hparameter_combo.combo.get_active()]
olpcgames.eventwrap.post(olpcgames.eventwrap.Event(pygame.USEREVENT, action=param))
try:
self.activity._pgc.grab_focus()
except AttributeError:
pass
def _Vparameter_change_cb(self, widget):
param = "Parameter|Vertical|" + self.parameters[self._Vparameter_combo.combo.get_active()]
olpcgames.eventwrap.post(olpcgames.eventwrap.Event(pygame.USEREVENT, action=param))
try:
self.activity._pgc.grab_focus()
except AttributeError:
pass
def _Scene_change_cb(self, widget):
if self.scene_init:
pass
else:
selection = self.scenes[self._Scene_combo.combo.get_active()]
scene = "Reload|" + '|'.join(map(lambda x: str(x), selection))
olpcgames.eventwrap.post(olpcgames.eventwrap.Event(pygame.USEREVENT, action=scene))
try:
self.activity._pgc.grab_focus()
except AttributeError:
pass
### functions to assist calls from pygame
def deactivate_scene_change(self):
self._Scene_combo.set_sensitive(False)
def reactivate_scene_change(self):
self._Scene_combo.set_sensitive(True)
def set_horizontal_parameter(self, param):
ndx = self.parameters.index(param)
self._Hparameter_combo.combo.set_active(ndx)
def set_vertical_parameter(self, param):
ndx = self.parameters.index(param)
self._Vparameter_combo.combo.set_active(ndx)
def _cameraSnap_cb(self, widget):
"Here I could wrap a camera event..."
def snaptime():
snap = CameraSnap()
self.activity.cameras_loaded.append(snap)
picpath = snap.Snap()
self.activity.load_image(picpath)
snap.Stop()
self._show_active_camera()
self.activity._pgc.grab_focus()
if self.camera_ready:
self._show_busy_camera()
thread.start_new_thread(snaptime, ())
else:
log.info('Ignoring request to use camera, as camera is currently busy')
def _pause_cb(self, widget):
self._toggleplay_pause()
log.info("Play/Pause Button pressed")
class GameToolbar(gtk.Toolbar):
__gtype_name__ = 'GameToolbar'
__gsignals__ = {
'game-restart': (SIGNAL_RUN_FIRST, TYPE_NONE, []),
'ai-activated': (SIGNAL_RUN_FIRST, TYPE_NONE, []),
'ai-deactivated': (SIGNAL_RUN_FIRST, TYPE_NONE, []),
'game-board-size': (SIGNAL_RUN_FIRST, TYPE_NONE, [TYPE_INT]),
}
def __init__(self, activity):
gtk.Toolbar.__init__(self)
self.activity = activity
# Reset Button
restart_icon = join(dirname(__file__), 'images', 'gtk-refresh.svg')
restart_image = gtk.Image()
restart_image.set_from_file(restart_icon)
self._restart_button = ToolButton()
self._restart_button.set_icon_widget(restart_image)
self._restart_button.connect('clicked', self._game_restart_cb)
self._restart_button.set_tooltip(_('Restart Game'))
self.insert(self._restart_button, -1)
self._restart_button.show()
# Separator
separator = gtk.SeparatorToolItem()
separator.set_draw(True)
self.insert(separator, -1)
self._add_widget(gtk.Label(_('Board size') + ': '))
# Change size combobox
self._size_combo = ToolComboBox()
self._sizes = ['19 X 19', '13 X 13', '9 X 9']
for i, f in enumerate(self._sizes):
self._size_combo.combo.append_item(i, f)
self._size_combo.combo.connect('changed', self._game_size_cb)
self._add_widget(self._size_combo)
self._size_combo.combo.set_active(0)
# Separator
separator = gtk.SeparatorToolItem()
separator.set_draw(True)
self.insert(separator, -1)
# Artificial Intelligence Button
self._ai_button = gtk.ToggleToolButton()
if search_for_gnugo():
self._ai_button.connect('toggled', self._ai_toggled_cb)
self._ai_button.set_label(_('Play against PlayGo!'))
else:
self._ai_button.set_label(_('You need to install gnugo to play against PlayGo'))
self._ai_button.set_sensitive(False)
self.insert(self._ai_button, -1)
self._ai_button.show()
def _add_widget(self, widget, expand=False):
tool_item = gtk.ToolItem()
tool_item.set_expand(expand)
tool_item.add(widget)
widget.show()
self.insert(tool_item, -1)
tool_item.show()
def _game_restart_cb(self, widget):
self._size_combo.set_sensitive(True)
self.emit('game-restart')
def grey_out_restart(self):
self._restart_button.set_sensitive(False)
def _game_size_cb(self, widget):
game_size = int(self._sizes[self._size_combo.combo.get_active()][:2])
self.emit('game-board-size', game_size)
def grey_out_size_change(self):
self._size_combo.set_sensitive(False)
def update_toolbar(self, widget, data, grid):
size = data.get('size')
self._size_combo.combo.handler_block(self.size_handle_id)
size_index = self._sizes.index(size+' X '+size)
self._size_combo.combo.set_active(int(size_index))
self._size_combo.combo.handler_unblock(self.size_handle_id)
def _ai_toggled_cb(self, widget):
if widget.get_active():
self.emit('ai-activated')
else:
self.emit('ai-deactivated')
def grey_out_ai(self):
self._ai_button.set_sensitive(False)
def set_ai_button_state(self, value):
self._ai_button.set_active(value)
class GameToolbar(gtk.Toolbar):
__gtype_name__ = 'GameToolbar'
__gsignals__ = {
'game-restart': (SIGNAL_RUN_FIRST, TYPE_NONE, []),
'ai-activated': (SIGNAL_RUN_FIRST, TYPE_NONE, []),
'ai-deactivated': (SIGNAL_RUN_FIRST, TYPE_NONE, []),
'game-board-size': (SIGNAL_RUN_FIRST, TYPE_NONE, [TYPE_INT]),
}
def __init__(self, activity):
gtk.Toolbar.__init__(self)
self.activity = activity
# Reset Button
restart_icon = join(dirname(__file__), 'images', 'gtk-refresh.svg')
restart_image = gtk.Image()
restart_image.set_from_file(restart_icon)
self._restart_button = ToolButton()
self._restart_button.set_icon_widget(restart_image)
self._restart_button.connect('clicked', self._game_restart_cb)
self._restart_button.set_tooltip(_('Restart Game'))
self.insert(self._restart_button, -1)
self._restart_button.show()
# Separator
separator = gtk.SeparatorToolItem()
separator.set_draw(True)
self.insert(separator, -1)
self._add_widget(gtk.Label(_('Board size') + ': '))
# Change size combobox
self._size_combo = ToolComboBox()
self._sizes = ['19 X 19', '13 X 13', '9 X 9']
for i, f in enumerate(self._sizes):
self._size_combo.combo.append_item(i, f)
self._size_combo.combo.connect('changed', self._game_size_cb)
self._add_widget(self._size_combo)
self._size_combo.combo.set_active(0)
# Separator
separator = gtk.SeparatorToolItem()
separator.set_draw(True)
self.insert(separator, -1)
# Artificial Intelligence Button
self._ai_button = gtk.ToggleToolButton()
if search_for_gnugo():
self._ai_button.connect('toggled', self._ai_toggled_cb)
self._ai_button.set_label(_('Play against PlayGo!'))
else:
self._ai_button.set_label(
_('You need to install gnugo to play against PlayGo'))
self._ai_button.set_sensitive(False)
self.insert(self._ai_button, -1)
self._ai_button.show()
def _add_widget(self, widget, expand=False):
tool_item = gtk.ToolItem()
tool_item.set_expand(expand)
tool_item.add(widget)
widget.show()
self.insert(tool_item, -1)
tool_item.show()
def _game_restart_cb(self, widget):
self._size_combo.set_sensitive(True)
self.emit('game-restart')
def grey_out_restart(self):
self._restart_button.set_sensitive(False)
def _game_size_cb(self, widget):
game_size = int(self._sizes[self._size_combo.combo.get_active()][:2])
self.emit('game-board-size', game_size)
def grey_out_size_change(self):
self._size_combo.set_sensitive(False)
def update_toolbar(self, widget, data, grid):
size = data.get('size')
self._size_combo.combo.handler_block(self.size_handle_id)
size_index = self._sizes.index(size + ' X ' + size)
self._size_combo.combo.set_active(int(size_index))
self._size_combo.combo.handler_unblock(self.size_handle_id)
def _ai_toggled_cb(self, widget):
if widget.get_active():
self.emit('ai-activated')
else:
self.emit('ai-deactivated')
def grey_out_ai(self):
self._ai_button.set_sensitive(False)
def set_ai_button_state(self, value):
self._ai_button.set_active(value)
