def addButton(self, nameID, image1path, image2path, tooltip1, tooltip2, cb):
button = ToolButton()
log.info("addButtonIMAGE PATH ____ " + image1path )
button.image1 = gtk.Image()
button.image1.set_from_file(image1path)
button.image2 = gtk.Image()
button.image2.set_from_file(image2path)
button.image1.show()
button.tooltip1, button.tooltip2 = tooltip1, tooltip2
button.set_icon_widget(button.image1)
button.connect('clicked', cb)
button.set_tooltip(_(button.tooltip1))
button.nameID = nameID
self.toolbar_box.toolbar.insert(button, -1)
button.show()
self.nameID.update({nameID:button})
def addButton(self, nameID, image1path, image2path, tooltip1, tooltip2, cb):
button = ToolButton()
button.image1 = gtk.Image()
button.image1.set_from_file(image1path)
button.image2 = gtk.Image()
button.image2.set_from_file(image2path)
button.image1.show()
button.nameID = nameID
button.tooltip1, button.tooltip2 = tooltip1, tooltip2
button.set_icon_widget(button.image1)
button.connect('clicked', cb)
button.set_tooltip(_(button.tooltip1))
button.active = False
self.insert(button, -1)
button.show()
return button
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 MemorizeToolbar(gtk.Toolbar):
__gtype_name__ = 'MemoryToolbar'
standard_game_names = ['Load demo games',
'addition',
'letters',
'sounds'
]
translated_game_names = [_('Load demo games'),
_('addition'),
_('letters'),
_('sounds')
]
__gsignals__ = {
'game_changed': (SIGNAL_RUN_FIRST, None, 5 * [TYPE_PYOBJECT]),
}
def __init__(self, activity):
gtk.Toolbar.__init__(self)
self.activity = activity
self._lock = True
self.jobject = None
# Reset Button
restart_icon = join(dirname(__file__), 'images', 'game-restart.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_reset_cb)
self._restart_button.set_tooltip(_('Restart Game'))
self.insert(self._restart_button, -1)
self._restart_button.show()
# Load Button
load_icon = join(dirname(__file__), 'images', 'game-load.svg')
load_image = gtk.Image()
load_image.set_from_file(load_icon)
self._load_button = ToolButton()
self._load_button.set_icon_widget(load_image)
self._load_button.set_tooltip(_('Load game'))
self._load_button.connect('clicked', self._load_game)
self._add_widget(self._load_button)
# Separator
separator = gtk.SeparatorToolItem()
separator.set_draw(True)
self.insert(separator, -1)
# Change size combobox
self._size_combo = ToolComboBox()
self._sizes = ['4 X 4', '5 X 5', '6 X 6']
for i, f in enumerate(self._sizes):
self._size_combo.combo.append_item(i, f)
self.size_handle_id = self._size_combo.combo.connect( \
'changed', self._game_size_cb)
self._add_widget(self._size_combo)
self._size_combo.combo.set_active(0)
separator = gtk.SeparatorToolItem()
separator.set_draw(True)
self.insert(separator, -1)
self._lock = False
# Change demo games combobox
self._game_combo = ToolComboBox()
for i, f in enumerate(self.standard_game_names):
f = _(f)
self._game_combo.combo.append_item(i, f)
self._game_combo.combo.set_active(0)
self._game_combo.combo.connect('changed', self._game_changed_cb)
self._add_widget(self._game_combo)
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_reset_cb(self, widget):
self.emit('game_changed', None, None, 'reset', None, None)
def _load_game(self, button):
chooser = ObjectChooser(_('Choose memorize game'),
parent=self.activity,
flags=gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT)
jobject = ''
try:
result = chooser.run()
if result == gtk.RESPONSE_ACCEPT:
logging.debug('ObjectChooser: %r',
chooser.get_selected_object())
jobject = chooser.get_selected_object()
if not jobject or not jobject.file_path:
return
finally:
chooser.destroy()
del chooser
if jobject and jobject.file_path:
title = jobject.metadata['title']
if jobject.metadata.has_key('icon-color'):
color = jobject.metadata['icon-color']
else:
color = profile.get_color().to_string()
self.emit('game_changed', jobject.file_path, 4,
'file', title, color)
if self.jobject != None:
self.jobject.destroy()
self.jobject = jobject
def _game_size_cb(self, widget):
game_size = int(self._sizes[self._size_combo.combo.get_active()][0])
self.emit('game_changed', None, game_size, 'size', None, None)
def _game_changed_cb(self, combobox):
if combobox.get_active() == 0:
return
current_game = self._game_combo.combo.get_active()
game_name = self.standard_game_names[current_game]
title = game_name
game_size = int(self._sizes[self._size_combo.combo.get_active()][0])
if game_name in self.translated_game_names:
index = self.translated_game_names.index(game_name)
game_name = self.standard_game_names[index]
game_file = join(dirname(__file__), 'demos', game_name+'.zip')
self.emit('game_changed', game_file, game_size, 'demo', title, None)
self._game_combo.combo.set_active(0)
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 __init__(self, activity, top_level_toolbox):
self._activity = activity
self.toolbox = top_level_toolbox
Terminal.__init__(self, self)
#set up tool box/menu buttons
activity_toolbar = self.toolbox.get_activity_toolbar()
separator = gtk.SeparatorToolItem()
separator.set_draw(True)
separator.show()
activity_toolbar.insert(separator, 0)
activity_go = ToolButton()
activity_go.set_stock_id('gtk-media-forward')
activity_go.set_icon_widget(None)
activity_go.set_tooltip(_('Start Debugging'))
activity_go.connect('clicked', self.project_run_cb)
activity_go.add_accelerator('clicked', self.get_accelerator(),
ord('O'), gtk.gdk.CONTROL_MASK,
gtk.ACCEL_VISIBLE)
activity_go.show()
activity_toolbar.insert(activity_go, 0)
activity_copy_tb = ToolButton('edit-copy')
activity_copy_tb.set_tooltip(_('Copy'))
activity_copy_tb.connect('clicked', self._copy_cb)
activity_toolbar.insert(activity_copy_tb, 3)
activity_copy_tb.show()
activity_paste_tb = ToolButton('edit-paste')
activity_paste_tb.set_tooltip(_('Paste'))
activity_paste_tb.connect('clicked', self._paste_cb)
activity_paste_tb.add_accelerator('clicked', self.get_accelerator(),
ord('V'), gtk.gdk.CONTROL_MASK,
gtk.ACCEL_VISIBLE)
activity_toolbar.insert(activity_paste_tb, 4)
activity_paste_tb.show()
activity_tab_tb = sugar.graphics.toolbutton.ToolButton('list-add')
activity_tab_tb.set_tooltip(_("Open New Tab"))
activity_tab_tb.add_accelerator('clicked', self.get_accelerator(),
ord('T'), gtk.gdk.CONTROL_MASK,
gtk.ACCEL_VISIBLE)
activity_tab_tb.show()
activity_tab_tb.connect('clicked', self._open_tab_cb)
activity_toolbar.insert(activity_tab_tb, 5)
activity_tab_delete_tv = sugar.graphics.toolbutton.ToolButton(
'list-remove')
activity_tab_delete_tv.set_tooltip(_("Close Tab"))
activity_tab_delete_tv.show()
activity_tab_delete_tv.connect('clicked', self._close_tab_cb)
activity_toolbar.insert(activity_tab_delete_tv, 6)
activity_fullscreen_tb = sugar.graphics.toolbutton.ToolButton(
'view-fullscreen')
activity_fullscreen_tb.set_tooltip(_("Fullscreen"))
activity_fullscreen_tb.connect('clicked',
self._activity._fullscreen_cb)
activity_toolbar.insert(activity_fullscreen_tb, 7)
activity_fullscreen_tb.hide()
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 EntryToolbar(gtk.Toolbar):
__gsignals__ = {
'volume-error':
(gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE, ([str, str])),
}
def __init__(self):
gtk.Toolbar.__init__(self)
self._metadata = None
self._temp_file_path = None
self._resume = ToolButton('activity-start')
self._resume.connect('clicked', self._resume_clicked_cb)
self.add(self._resume)
self._resume.show()
client = gconf.client_get_default()
color = XoColor(client.get_string('/desktop/sugar/user/color'))
self._copy = ToolButton()
icon = Icon(icon_name='edit-copy', xo_color=color)
self._copy.set_icon_widget(icon)
icon.show()
self._copy.set_tooltip(_('Copy to'))
self._copy.connect('clicked', self._copy_clicked_cb)
self.add(self._copy)
self._copy.show()
self._duplicate = ToolButton()
icon = Icon(icon_name='edit-duplicate', xo_color=color)
self._duplicate.set_icon_widget(icon)
self._duplicate.set_tooltip(_('Duplicate'))
self._duplicate.connect('clicked', self._duplicate_clicked_cb)
self.add(self._duplicate)
separator = gtk.SeparatorToolItem()
self.add(separator)
separator.show()
erase_button = ToolButton('list-remove')
erase_button.set_tooltip(_('Erase'))
erase_button.connect('clicked', self._erase_button_clicked_cb)
self.add(erase_button)
erase_button.show()
def set_metadata(self, metadata):
self._metadata = metadata
self._refresh_copy_palette()
self._refresh_duplicate_palette()
self._refresh_resume_palette()
def _resume_clicked_cb(self, button):
misc.resume(self._metadata)
def _copy_clicked_cb(self, button):
button.palette.popup(immediate=True, state=Palette.SECONDARY)
def _duplicate_clicked_cb(self, button):
file_path = model.get_file(self._metadata['uid'])
try:
model.copy(self._metadata, '/')
except IOError, e:
logging.exception('Error while copying the entry.')
self.emit('volume-error',
_('Error while copying the entry. %s') % (e.strerror, ),
_('Error'))
class CreateCardPanel(gtk.EventBox):
__gsignals__ = {
'add-pair': (SIGNAL_RUN_FIRST, None, 8 * [TYPE_PYOBJECT]),
'update-pair': (SIGNAL_RUN_FIRST, None, 8 * [TYPE_PYOBJECT]),
}
def __init__(self):
def make_label(icon_name, label):
label_box = gtk.HBox()
icon = Icon(
icon_name=icon_name,
icon_size=gtk.ICON_SIZE_LARGE_TOOLBAR)
label_box.pack_start(icon, False)
label = gtk.Label(label)
label.modify_fg(gtk.STATE_NORMAL,
style.COLOR_TOOLBAR_GREY.get_gdk_color())
label_box.pack_start(label)
label_box.show_all()
return label_box
gtk.EventBox.__init__(self)
self.equal_pairs = False
self._updatebutton_sensitive = False
self._card1_has_sound = False
self._card2_has_sound = False
# save buttons
buttons_bar = gtk.HBox()
buttons_bar.props.border_width = 10
self._addbutton = ToolButton(
tooltip=_('Add as new pair'),
sensitive=False)
self._addbutton.set_icon_widget(
make_label('pair-add', ' ' + _('Add')))
self._addbutton.connect('clicked', self.emit_add_pair)
buttons_bar.pack_start(self._addbutton, False)
self._updatebutton = ToolButton(
tooltip=_('Update selected pair'),
sensitive=False)
self._updatebutton.set_icon_widget(
make_label('pair-update', ' ' + _('Update')))
self._updatebutton.connect('clicked', self.emit_update_pair)
buttons_bar.pack_start(self._updatebutton, False)
# Set card editors
self.cardeditor1 = CardEditor()
self.cardeditor2 = CardEditor()
self.clean(None)
self.cardeditor1.connect('has-text', self.receive_text_signals)
self.cardeditor2.connect('has-text', self.receive_text_signals)
self.cardeditor1.connect('has-picture', self.receive_picture_signals)
self.cardeditor2.connect('has-picture', self.receive_picture_signals)
self.cardeditor1.connect('has-sound', self.receive_sound_signals)
self.cardeditor2.connect('has-sound', self.receive_sound_signals)
# edit panel
self.card_box = gtk.HBox()
self.card_box.pack_start(self.cardeditor1)
self.card_box.pack_start(self.cardeditor2)
box = gtk.VBox()
box.pack_start(self.card_box, False)
box.pack_start(buttons_bar, False)
self.add(box)
self.show_all()
def emit_add_pair(self, widget):
self._addbutton.set_sensitive(False)
if self.equal_pairs:
self.emit('add-pair', self.cardeditor1.get_text(),
self.cardeditor1.get_text(),
self.cardeditor1.get_pixbuf(),
self.cardeditor1.get_pixbuf(),
self.cardeditor1.get_snd(), self.cardeditor1.get_snd(),
self.cardeditor1.get_speak(), self.cardeditor1.get_speak()
)
else:
self.emit('add-pair', self.cardeditor1.get_text(),
self.cardeditor2.get_text(),
self.cardeditor1.get_pixbuf(),
self.cardeditor2.get_pixbuf(),
self.cardeditor1.get_snd(), self.cardeditor2.get_snd(),
self.cardeditor1.get_speak(), self.cardeditor2.get_speak()
)
self.clean(None)
def emit_update_pair(self, widget):
self._addbutton.set_sensitive(False)
if self.equal_pairs:
self.emit('update-pair', self.cardeditor1.get_text(),
self.cardeditor1.get_text(),
self.cardeditor1.get_pixbuf(),
self.cardeditor1.get_pixbuf(),
self.cardeditor1.get_snd(), self.cardeditor1.get_snd(),
self.cardeditor1.get_speak(), self.cardeditor1.get_speak()
)
else:
self.emit('update-pair', self.cardeditor1.get_text(),
self.cardeditor2.get_text(),
self.cardeditor1.get_pixbuf(),
self.cardeditor2.get_pixbuf(),
self.cardeditor1.get_snd(), self.cardeditor2.get_snd(),
self.cardeditor1.get_speak(), self.cardeditor2.get_speak()
)
self.clean(None)
def pair_selected(self, widget, selected, newtext1, newtext2, aimg, bimg,
asnd, bsnd, aspeak, bspeak):
if selected:
self.cardeditor1.set_text(newtext1)
self.cardeditor2.set_text(newtext2)
self.cardeditor1.set_pixbuf(aimg)
self.cardeditor2.set_pixbuf(bimg)
self.cardeditor1.set_snd(asnd)
self.cardeditor2.set_snd(bsnd)
self.cardeditor1.set_speak(aspeak)
self.cardeditor2.set_speak(bspeak)
self._addbutton.set_sensitive(True)
self._updatebutton.set_sensitive(selected)
self._updatebutton_sensitive = selected
def change_equal_pairs(self, widget, state):
self.equal_pairs = state
self.clean(None)
if self.equal_pairs:
if self.cardeditor2.parent:
self.card_box.remove(self.cardeditor2)
else:
if not self.cardeditor2.parent:
self.card_box.pack_start(self.cardeditor2)
def clean(self, widget):
self.cardeditor1.clean()
self.cardeditor2.clean()
self._addbutton.set_sensitive(False)
self._card1_has_text = False
self._card2_has_text = False
self._card1_has_picture = False
self._card2_has_picture = False
def receive_text_signals(self, widget, has_text):
if widget == self.cardeditor1:
self._card1_has_text = has_text
if widget == self.cardeditor2:
self._card2_has_text = has_text
self._update_buttom_status()
def receive_picture_signals(self, widget, has_picture):
if widget == self.cardeditor1:
self._card1_has_picture = has_picture
if widget == self.cardeditor2:
self._card2_has_picture = has_picture
self._update_buttom_status()
def receive_sound_signals(self, widget, has_sound):
if widget == self.cardeditor1:
self._card1_has_sound = has_sound
if widget == self.cardeditor2:
self._card2_has_sound = has_sound
self._update_buttom_status()
def _update_buttom_status(self):
if not self.equal_pairs:
if (self._card1_has_text or self._card1_has_picture \
or self._card1_has_sound) and (self._card2_has_text
or self._card2_has_picture
or self._card2_has_sound):
self._addbutton.set_sensitive(True)
self._updatebutton.set_sensitive(self._updatebutton_sensitive)
else:
self._addbutton.set_sensitive(False)
self._updatebutton.set_sensitive(False)
else:
if (self._card1_has_text or self._card1_has_picture \
or self._card1_has_sound):
self._addbutton.set_sensitive(True)
self._updatebutton.set_sensitive(self._updatebutton_sensitive)
else:
self._addbutton.set_sensitive(False)
self._updatebutton.set_sensitive(False)
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)
def __init__(self, activity):
self._activity = activity
GtkSourceview2Editor.__init__(self, activity)
#set the default contents for edit,override fixed font size
self.font_size = activity.debug_dict.get('font_size', 8)
self.find_window = None
self.editbar = gtk.Toolbar()
self.last_folder = None
editopen = ToolButton()
editopen.set_stock_id('gtk-new')
editopen.set_icon_widget(None)
editopen.set_tooltip(_('New File'))
editopen.connect('clicked', self._new_file_cb)
editopen.add_accelerator('clicked', activity.accelerator, ord('N'),
gtk.gdk.CONTROL_MASK, gtk.ACCEL_VISIBLE)
#editopen.props.accelerator = '<Ctrl>O'
editopen.show()
self.editbar.insert(editopen, -1)
editfile = ToolButton()
editfile.set_stock_id('gtk-open')
editfile.set_icon_widget(None)
editfile.set_tooltip(_('Open File'))
editfile.connect('clicked', self._read_file_cb)
editfile.add_accelerator('clicked', activity.accelerator, ord('O'),
gtk.gdk.CONTROL_MASK, gtk.ACCEL_VISIBLE)
#editfile.props.accelerator = '<Ctrl>O'
editfile.show()
self.editbar.insert(editfile, -1)
editsave = ToolButton()
editsave.set_stock_id('gtk-save')
editsave.set_icon_widget(None)
editsave.set_tooltip(_('Save File'))
editsave.add_accelerator('clicked', activity.accelerator, ord('S'),
gtk.gdk.CONTROL_MASK, gtk.ACCEL_VISIBLE)
#editsave.props.accelerator = '<Ctrl>S'
editsave.connect('clicked', self.save_cb)
editsave.show()
self.editbar.insert(editsave, -1)
editsaveas = ToolButton()
editsaveas.set_stock_id('gtk-save-as')
editsaveas.set_icon_widget(None)
editsaveas.set_tooltip(_('Save As'))
#editsaveas.props.accelerator = '<Ctrl>S'
editsaveas.connect('clicked', self.save_file_cb)
editsaveas.show()
self.editbar.insert(editsaveas, -1)
"""
editjournal = ToolButton(tooltip=_('Open Journal'))
client = gconf.client_get_default()
color = XoColor(client.get_string('/desktop/sugar/user/color'))
journal_icon = Icon(icon_name='document-save', xo_color=color)
editjournal.set_icon_widget(journal_icon)
editjournal.connect('clicked', self._show_journal_object_picker_cb)
#editjournal.props.accelerator = '<Ctrl>J'
editjournal.show()
self.editbar.insert(editjournal, -1)
"""
separator = gtk.SeparatorToolItem()
separator.set_draw(True)
separator.show()
self.editbar.insert(separator, -1)
editundo = ToolButton('undo')
editundo.set_tooltip(_('Undo'))
editundo.connect('clicked', self.undo)
editundo.add_accelerator('clicked', activity.accelerator, ord('Z'),
gtk.gdk.CONTROL_MASK, gtk.ACCEL_VISIBLE)
#editundo.props.accelerator = '<Ctrl>Z'
editundo.show()
self.editbar.insert(editundo, -1)
editredo = ToolButton('redo')
editredo.set_tooltip(_('Redo'))
editredo.connect('clicked', self.redo)
editredo.add_accelerator('clicked', activity.accelerator, ord('Y'),
gtk.gdk.CONTROL_MASK, gtk.ACCEL_VISIBLE)
#editredo.props.accelerator = '<Ctrl>Y'
editredo.show()
self.editbar.insert(editredo, -1)
separator = gtk.SeparatorToolItem()
separator.set_draw(True)
separator.show()
self.editbar.insert(separator, -1)
editcut = ToolButton()
editcut.set_stock_id('gtk-cut')
editcut.set_icon_widget(None)
editcut.set_tooltip(_('Cut'))
self.edit_cut_handler_id = editcut.connect('clicked', self.cut)
editcut.add_accelerator('clicked', activity.accelerator, ord('X'),
gtk.gdk.CONTROL_MASK, gtk.ACCEL_VISIBLE)
#editcut.props.accelerator = '<Ctrl>X'
self.editbar.insert(editcut, -1)
editcut.show()
editcopy = ToolButton('edit-copy')
editcopy.set_tooltip(_('Copy'))
self.edit_copy_handler_id = editcopy.connect('clicked',
self.copy_to_clipboard_cb)
editcopy.add_accelerator('clicked', activity.accelerator, ord('C'),
gtk.gdk.CONTROL_MASK, gtk.ACCEL_VISIBLE)
#editcopy.props.accelerator = '<Ctrl>C'
self.editbar.insert(editcopy, -1)
editcopy.show()
editpaste = ToolButton('edit-paste')
editpaste.set_tooltip(_('Paste'))
self.edit_paste_handler_id = editpaste.connect('clicked', self.paste)
editpaste.add_accelerator('clicked', activity.accelerator, ord('V'),
gtk.gdk.CONTROL_MASK, gtk.ACCEL_VISIBLE)
#editpaste.props.accelerator = '<Ctrl>V'
editpaste.show()
self.editbar.insert(editpaste, -1)
"""
separator = gtk.SeparatorToolItem()
separator.set_draw(True)
separator.show()
self.editbar.insert(separator, -1)
"""
editfind = ToolButton('viewmag1')
editfind.set_tooltip(_('Find and Replace'))
editfind.connect('clicked', self.show_find)
editfind.add_accelerator('clicked', activity.accelerator, ord('F'),
gtk.gdk.CONTROL_MASK, gtk.ACCEL_VISIBLE)
#editfind.props.accelerator = '<Ctrl>F'
editfind.show()
self.editbar.insert(editfind, -1)
"""
separator = gtk.SeparatorToolItem()
separator.set_draw(True)
separator.show()
self.editbar.insert(separator, -1)
"""
self.zoomout = ToolButton('zoom-out')
self.zoomout.set_tooltip(_('Zoom out'))
self.zoomout.connect('clicked', self.__zoomout_clicked_cb)
self.editbar.insert(self.zoomout, -1)
self.zoomout.show()
self.zoomin = ToolButton('zoom-in')
self.zoomin.set_tooltip(_('Zoom in'))
self.zoomin.connect('clicked', self.__zoomin_clicked_cb)
self.editbar.insert(self.zoomin, -1)
self.zoomin.show()
stop_button = ToolButton('activity-stop')
stop_button.set_tooltip(_('Stop'))
#stop_button.props.accelerator = '<Ctrl>Q'
stop_button.connect('clicked', self.__stop_clicked_cb)
self.editbar.insert(stop_button, -1)
stop_button.show()
self.editbar.show_all()
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
"""
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:
if True:
self.label = gtk.Label(display.menu_journal_label)
self.label.show()
self._add_widget(self.label)
self.title = gtk.Entry()
self.title.set_size_request(int(gtk.gdk.screen_width() / 6), -1)
if activity.metadata:
self.title.set_text(activity.metadata['title'])
#activity.metadata.connect('updated', self.__jobject_updated_cb)
self.title.connect('changed', self.__title_changed_cb)
self.title.connect('activate', self.__update_title_cb)
self._add_widget(self.title)
fn = os.path.join(os.getcwd(), 'assets', 'stack_new.png')
button = ImageButton()
tooltip = _("Add Album Stack")
button.set_image(fn, tip=tooltip)
self.add_album = button
self.add_album.show()
self.add_album.connect('clicked', self.__add_album_clicked_cb)
self.insert(self.add_album, -1)
fn = os.path.join(os.getcwd(), 'assets', 'stack_del.png')
button = ImageButton()
tooltip = _("Delete Album Stack")
button.set_image(fn, tip=tooltip)
button.connect('clicked', self.__delete_album_clicked_cb)
self.insert(button, -1)
fn = os.path.join(os.getcwd(), 'assets', 'trash_del.png')
button = ImageButton()
tooltip = _("Remove Trash Images from XO")
button.set_image(fn, tip=tooltip)
self.empty_journal_button = button
self.empty_journal_button.hide()
self.empty_journal_button.connect('clicked',
self.__empty_trash_clicked_cb)
self.insert(self.empty_journal_button, -1)
"""
separator = gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
self.insert(separator, -1)
separator.show()
self.share = ToolComboBox(label_text=_('Traceback:'))
self.share.combo.connect('changed', self.__traceback_changed_cb)
self.share.combo.append_item("traceback_plain", _('Plain'))
self.share.combo.append_item('traceback_context', _('Context'))
self.share.combo.append_item('traceback_verbose', _('Verbose'))
self.insert(self.share, -1)
self.share.show()
self._update_share()
"""
separator = gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
self.insert(separator, -1)
separator.show()
self.keep = ToolButton()
self.keep.set_tooltip(_('Save and Start New'))
#client = gconf.client_get_default()
#color = XoColor(client.get_string('/desktop/sugar/user/color'))
#keep_icon = Icon(icon_name='document-save', xo_color=color)
keep_icon = Icon(icon_name='document-save')
keep_icon.show()
self.keep.set_icon_widget(keep_icon)
#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')
self.stop.set_tooltip(_('Stop'))
#self.stop.props.accelerator = '<Ctrl>Q'
self.stop.connect('clicked', self.__stop_clicked_cb)
self.insert(self.stop, -1)
self.stop.show()
self._update_title_sid = None
def set_label(self, text, visible=True):
self.label.set_text(text)
if not visible:
self.title.set_sensitive(False)
else:
self.title.set_sensitive(True)
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 __add_album_clicked_cb(self, button):
title = self.title.get_text()
self._activity.activity_toolbar_add_album_cb(title)
def __delete_album_clicked_cb(self, button):
self._activity.activity_toolbar_delete_album_cb()
def __empty_trash_clicked_cb(self, button):
self._activity.activity_toolbar_empty_trash_cb()
def __traceback_changed_cb(self, combo):
model = self.share.combo.get_model()
it = self.share.combo.get_active_iter()
(scope, ) = model.get(it, 0)
if scope == 'traceback_plain':
self._activity.traceback = 'Plain'
self._activity.debug_dict['traceback'] = 'plain'
elif scope == 'traceback_context':
self._activity.traceback = 'Context'
self._activity.debug_dict['traceback'] = 'context'
elif scope == 'traceback_verbose':
self._activity.traceback = 'Verbose'
self._activity.debug_dict['traceback'] = 'verbose'
self._activity.set_ipython_traceback()
def __keep_clicked_cb(self, button):
self._activity.save_icon_clicked = True
self._activity.copy()
def __stop_clicked_cb(self, button):
self._activity.stop()
def __jobject_updated_cb(self, jobject):
self.title.set_text(jobject['title'])
def __title_changed_cb(self, entry):
if not self._update_title_sid:
self._update_title_sid = gobject.timeout_add(
1000, self.__update_title_cb)
def __update_title_cb(self, entry=None):
title = self.title.get_text()
if self._activity.game.is_journal():
self._activity.metadata['title'] = title
self._activity.metadata['title_set_by_user'] = '******'
else:
self._activity.game.change_album_name(title)
title_set_by_user = self._activity.metadata.get(
'title_set_by_user')
if not title_set_by_user: #let the journal title reflect the most recent stack
self._activity.metadata['title'] = title
self._update_title_sid = None
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()
def initialize_display(self):
self._logger = logging.getLogger('butialo-activity')
# Top toolbar with share and close buttons:
if OLD_TOOLBAR:
activity_toolbar = self.toolbox.get_activity_toolbar()
else:
activity_toolbar = self.activity_button.page
# add 'make bundle' entry to 'keep' palette.
palette = activity_toolbar.keep.get_palette()
# XXX: should clear out old palette entries?
from sugar.graphics.menuitem import MenuItem
from sugar.graphics.icon import Icon
menu_item = MenuItem(_('As Butialo Document'))
menu_item.set_image(Icon(file=('%s/activity/activity-icon.svg' %
get_bundle_path()),
icon_size=gtk.ICON_SIZE_MENU))
menu_item.connect('activate', self.keepbutton_cb)
palette.menu.append(menu_item)
menu_item.show()
#xop guardar como bundle
#menu_item = MenuItem(_('As Activity Bundle'))
#menu_item.set_image(Icon(file=('%s/activity/activity-default.svg' %
# get_bundle_path()),
# icon_size=gtk.ICON_SIZE_MENU))
#menu_item.connect('activate', self.makebutton_cb)
#palette.menu.append(menu_item)
#menu_item.show()
self._edit_toolbar = activity.EditToolbar()
if OLD_TOOLBAR:
activity_toolbar = gtk.Toolbar()
self.toolbox.add_toolbar(_('Actions'), activity_toolbar)
self.toolbox.set_current_toolbar(1)
self.toolbox.add_toolbar(_('Edit'), self._edit_toolbar)
else:
edit_toolbar_button = ToolbarButton()
edit_toolbar_button.set_page(self._edit_toolbar)
edit_toolbar_button.props.icon_name = 'toolbar-edit'
edit_toolbar_button.props.label = _('Edit')
self.get_toolbar_box().toolbar.insert(edit_toolbar_button, -1)
self._edit_toolbar.show()
self._edit_toolbar.undo.connect('clicked', self.__undobutton_cb)
self._edit_toolbar.redo.connect('clicked', self.__redobutton_cb)
self._edit_toolbar.copy.connect('clicked', self.__copybutton_cb)
self._edit_toolbar.paste.connect('clicked', self.__pastebutton_cb)
if OLD_TOOLBAR:
actions_toolbar = activity_toolbar
else:
actions_toolbar = self.get_toolbar_box().toolbar
# The "go" button
goicon_bw = gtk.Image()
goicon_bw.set_from_file("%s/icons/run_bw.svg" % os.getcwd())
goicon_color = gtk.Image()
goicon_color.set_from_file("%s/icons/run_color.svg" % os.getcwd())
gobutton = ToolButton(label=_("_Run!"))
gobutton.props.accelerator = _('<alt>r')
gobutton.set_icon_widget(goicon_bw)
gobutton.set_tooltip("Run")
gobutton.connect('clicked', self.flash_cb, dict({'bw': goicon_bw,
'color': goicon_color}))
gobutton.connect('clicked', self.gobutton_cb)
actions_toolbar.insert(gobutton, -1)
# The "stop" button
stopicon_bw = gtk.Image()
stopicon_bw.set_from_file("%s/icons/stopit_bw.svg" % os.getcwd())
stopicon_color = gtk.Image()
stopicon_color.set_from_file("%s/icons/stopit_color.svg" % os.getcwd())
stopbutton = ToolButton(label=_("_Stop"))
stopbutton.props.accelerator = _('<alt>s')
stopbutton.set_icon_widget(stopicon_bw)
stopbutton.connect('clicked', self.flash_cb, dict({'bw': stopicon_bw,
'color': stopicon_color}))
stopbutton.connect('clicked', self.stopbutton_cb)
stopbutton.set_tooltip("Stop Running")
actions_toolbar.insert(stopbutton, -1)
# The "refresh" button
refreshicon_bw = gtk.Image()
refreshicon_bw.set_from_file("%s/icons/butiaoff.svg" % os.getcwd())
refreshicon_color = gtk.Image()
refreshicon_color.set_from_file("%s/icons/butiaon.svg" % os.getcwd())
refreshbutton = ToolButton(label=_("_Reload"))
refreshbutton.props.accelerator = _('<alt>d')
refreshbutton.set_icon_widget(refreshicon_bw)
refreshbutton.connect('clicked', self.flash_cb, dict({'bw': refreshicon_bw,
'color': refreshicon_color}))
refreshbutton.connect('clicked', self.initialize_snippets_cb)
refreshbutton.set_tooltip("Reload devices")
actions_toolbar.insert(refreshbutton, -1)
# The "clear" button
#clearicon_bw = gtk.Image()
#clearicon_bw.set_from_file("%s/icons/eraser_bw.svg" % os.getcwd())
#clearicon_color = gtk.Image()
#clearicon_color.set_from_file("%s/icons/eraser_color.svg" %
# os.getcwd())
#clearbutton = ToolButton(label=_("_Clear"))
#clearbutton.props.accelerator = _('<alt>c')
#clearbutton.set_icon_widget(clearicon_bw)
#clearbutton.connect('clicked', self.clearbutton_cb)
#clearbutton.connect('clicked', self.flash_cb, dict({'bw': clearicon_bw,
# 'color': clearicon_color}))
#clearbutton.set_tooltip("Clear")
#actions_toolbar.insert(clearbutton, -1)
# The "beautify" button
beautifyicon_bw = gtk.Image()
beautifyicon_bw.set_from_file("%s/icons/beautifyicon_bw.svg" % os.getcwd())
beautifyicon_color = gtk.Image()
beautifyicon_color.set_from_file("%s/icons/beautifyicon_color.svg" %
os.getcwd())
beautifybutton = ToolButton(label=_("_Auto-format"))
beautifybutton.props.accelerator = _('<alt>f')
beautifybutton.set_icon_widget(beautifyicon_bw)
beautifybutton.connect('clicked', self.beautifybutton_cb)
beautifybutton.connect('clicked', self.flash_cb, dict({'bw': beautifyicon_bw,
'color': beautifyicon_color}))
beautifybutton.set_tooltip("Auto-format")
actions_toolbar.insert(beautifybutton, -1)
activity_toolbar.show()
if not OLD_TOOLBAR:
separator = gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
self.get_toolbar_box().toolbar.insert(separator, -1)
separator.show()
stop = StopButton(self)
self.get_toolbar_box().toolbar.insert(stop, -1)
# Main layout.
self.hpane = gtk.HPaned()
self.vpane = gtk.VPaned()
# The sidebar.
self.sidebar = gtk.VBox()
self.model = gtk.TreeStore(gobject.TYPE_PYOBJECT, gobject.TYPE_STRING)
treeview = gtk.TreeView(self.model)
cellrenderer = gtk.CellRendererText()
treecolumn = gtk.TreeViewColumn(_("Available"), cellrenderer, text=1)
treeview.get_selection().connect("changed", self.selection_cb)
treeview.append_column(treecolumn)
treeview.set_size_request(int(SIZE_X * 0.3), SIZE_Y)
# Create scrollbars around the view.
scrolled = gtk.ScrolledWindow()
scrolled.add(treeview)
self.sidebar.pack_start(scrolled)
self.hpane.add1(self.sidebar)
#root = os.path.join(get_bundle_path(), 'data')
#initialize snippets
self.initialize_snippets_cb(None)
# Source buffer
import gtksourceview2
global text_buffer
lang_manager = gtksourceview2.language_manager_get_default()
if hasattr(lang_manager, 'list_languages'):
langs = lang_manager.list_languages()
else:
lang_ids = lang_manager.get_language_ids()
langs = [lang_manager.get_language(lang_id)
for lang_id in lang_ids]
for lang in langs:
for m in lang.get_mime_types():
if m == "text/x-lua":
text_buffer.set_language(lang)
if hasattr(text_buffer, 'set_highlight'):
text_buffer.set_highlight(True)
else:
text_buffer.set_highlight_syntax(True)
# The GTK source view window
self.text_view = gtksourceview2.View(text_buffer)
self.text_view.set_size_request(0, int(SIZE_Y * 0.5))
self.text_view.set_editable(True)
self.text_view.set_cursor_visible(True)
self.text_view.set_show_line_numbers(True)
self.text_view.set_wrap_mode(gtk.WRAP_CHAR)
self.text_view.set_insert_spaces_instead_of_tabs(True)
self.text_view.set_tab_width(2)
self.text_view.set_auto_indent(True)
self.text_view.modify_font(pango.FontDescription("Monospace " +
str(font_zoom(style.FONT_SIZE))))
# We could change the color theme here, if we want to.
#mgr = gtksourceview2.style_manager_get_default()
#style_scheme = mgr.get_scheme('kate')
#self.text_buffer.set_style_scheme(style_scheme)
codesw = gtk.ScrolledWindow()
codesw.set_policy(gtk.POLICY_AUTOMATIC,
gtk.POLICY_AUTOMATIC)
codesw.add(self.text_view)
self.vpane.add1(codesw)
# An hbox to hold the vte window and its scrollbar.
outbox = gtk.HBox()
# The vte python window
self._vte = vte.Terminal()
self._vte.set_encoding('utf-8')
self._vte.set_size(30, 5)
font = 'Monospace ' + str(font_zoom(style.FONT_SIZE))
self._vte.set_font(pango.FontDescription(font))
self._vte.set_colors(gtk.gdk.color_parse('#000000'),
gtk.gdk.color_parse('#E7E7E7'),
[])
self._vte.connect('child_exited', self.child_exited_cb)
self._child_exited_handler = None
self._vte.drag_dest_set(gtk.DEST_DEFAULT_ALL,
[("text/plain", 0, TARGET_TYPE_TEXT)],
gtk.gdk.ACTION_COPY)
self._vte.connect('drag_data_received', self.vte_drop_cb)
outbox.pack_start(self._vte)
outsb = gtk.VScrollbar(self._vte.get_adjustment())
outsb.show()
outbox.pack_start(outsb, False, False, 0)
self.vpane.add2(outbox)
self.hpane.add2(self.vpane)
return self.hpane
class ShockTherapyActivity(activity.Activity):
_MAIN_URL = "layout/main.html"
_SCREENSAVER_URL = "layout/main.html#screensaver"
_OPTIONS_URL = "layout/main.html#options"
_ABOUT_URL = "layout/main.html#about"
_URI_WHITELIST = ("http://electroshocktherapy.googlecode.com/",
"https://electroshocktherapy.googlecode.com/",
"http://wiki.electroshocktherapy.googlecode.com/",
"https://wiki.electroshocktherapy.googlecode.com/",
"http://code.google.com/p/electroshocktherapy/",
"https://code.google.com/p/electroshocktherapy/")
def __init__(self, handle):
activity.Activity.__init__(self, handle)
#logging.getLogger().setLevel(logging.DEBUG)
self._http_dir = activity.get_bundle_path() + '/web/'
self._base_uri = "file://" + self._http_dir
# toolbar with the new toolbar redesign
toolbar_box = ToolbarBox()
self._back = ToolButton('go-previous')
self._back.set_tooltip(_('Back'))
self._back.connect('clicked', self._go_back_cb)
toolbar_box.toolbar.insert(self._back, -1)
separator = gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
toolbar_box.toolbar.insert(separator, -1)
self._main_button = ToolButton()
self._main_button.set_tooltip(_('Main'))
self._main_button.set_icon_widget(
Icon(file=os.path.join(activity.get_bundle_path(), 'activity',
'high-voltage-warning.svg')))
self._main_button.connect('clicked', self._main_cb)
toolbar_box.toolbar.insert(self._main_button, -1)
self._screensaver_button = ToolButton('player_play')
self._screensaver_button.set_tooltip(_('Screen Saver'))
self._screensaver_button.connect('clicked', self._screensaver_cb)
toolbar_box.toolbar.insert(self._screensaver_button, -1)
self._options_button = ToolButton('preferences-system')
self._options_button.set_tooltip(_('Options'))
self._options_button.connect('clicked', self._options_cb)
toolbar_box.toolbar.insert(self._options_button, -1)
self._about_button = ToolButton('emblem-question')
self._about_button.set_tooltip(_('About'))
self._about_button.connect('clicked', self._about_cb)
toolbar_box.toolbar.insert(self._about_button, -1)
separator = gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
toolbar_box.toolbar.insert(separator, -1)
reload_button = ToolButton('view-refresh')
reload_button.set_tooltip(_('Refresh'))
reload_button.connect('clicked', self._reload_cb)
toolbar_box.toolbar.insert(reload_button, -1)
dev_tools_button = ToolButton('view-source')
dev_tools_button.set_tooltip(_('Developer Tools'))
toolbar_box.toolbar.insert(dev_tools_button, -1)
separator = gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
toolbar_box.toolbar.insert(separator, -1)
fullscreen_button = ToolButton('view-fullscreen')
fullscreen_button.set_tooltip(_('Fullscreen'))
fullscreen_button.connect('clicked', self._fullscreen_cb)
toolbar_box.toolbar.insert(fullscreen_button, -1)
zoom_in_button = ToolButton('zoom-in')
zoom_in_button.set_tooltip(_('Zoom In'))
zoom_in_button.connect('clicked', self._zoom_in_cb)
toolbar_box.toolbar.insert(zoom_in_button, -1)
zoom_out_button = ToolButton('zoom-out')
zoom_out_button.set_tooltip(_('Zoom Out'))
zoom_out_button.connect('clicked', self._zoom_out_cb)
toolbar_box.toolbar.insert(zoom_out_button, -1)
zoom_default_button = ToolButton('zoom-original')
zoom_default_button.set_tooltip(_('Zoom Default'))
zoom_default_button.connect('clicked', self._zoom_default_cb)
toolbar_box.toolbar.insert(zoom_default_button, -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)
self._webview = webkit.WebView()
settings = self._webview.get_settings()
settings.set_property(
'user-agent',
settings.get_property('user-agent') +
" sugar:com.googlecode.electroshocktherapy")
self._title_req_ids = set()
self._webview.connect_after('notify::title', self._dom_title_cb)
self._webview.connect('navigation-policy-decision-requested',
self._navigate_cb)
self._webview.connect('notify::uri', self._webview_uri_cb)
self._scrolled_window = gtk.ScrolledWindow()
self._scrolled_window.props.hscrollbar_policy = gtk.POLICY_AUTOMATIC
self._scrolled_window.props.vscrollbar_policy = gtk.POLICY_AUTOMATIC
self._scrolled_window.add(self._webview)
self._vpaned = gtk.VPaned()
self.set_canvas(self._vpaned)
self._vpaned.add1(self._scrolled_window)
self.show_all()
self._inspector_manager = WebKitWebInspectorManager(
self._webview, self._vpaned)
dev_tools_button.connect('clicked', self._inspector_manager.toggle)
self._urls = {}
self._urls["MAIN"] = self._base_uri + self._MAIN_URL
self._urls["SCREENSAVER"] = self._base_uri + self._SCREENSAVER_URL
self._urls["OPTIONS"] = self._base_uri + self._OPTIONS_URL
self._urls["ABOUT"] = self._base_uri + self._ABOUT_URL
self._url_button_map = {}
self._url_button_map[self._urls["MAIN"]] = self._main_button
self._url_button_map[
self._urls["SCREENSAVER"]] = self._screensaver_button
self._url_button_map[self._urls["OPTIONS"]] = self._options_button
self._url_button_map[self._urls["ABOUT"]] = self._about_button
# Initialize button state without delay, so it's in the desired
# initial state even before the first page finishes loading.
self._uri_cb(self._urls["MAIN"])
self._webview.load_uri(self._urls["MAIN"])
def _navigate_cb(self, view, frame, request, nav_action, policy_decision):
uri = request.get_uri()
logging.debug("_navigate_cb: %s" % (uri, ))
if uri.startswith("about:"):
return False
elif uri.startswith(self._base_uri) or \
uri.rstrip("/") == self._base_uri.rstrip("/"):
return False
for allowed_uri in self._URI_WHITELIST:
if uri.startswith(allowed_uri) or \
uri.rstrip("/") == allowed_uri.rstrip("/"):
return False
logging.debug("_navigate_cb reject: %s" % (uri, ))
return True
def _dom_title_cb(self, view, gParamSpec):
"""
Use the document.title notify::title property change signal to call
Python from JavaScript, as suggested here:
http://code.google.com/p/pywebkitgtk/wiki/HowDoI
"""
title = self._webview.get_main_frame().get_title()
#logging.debug("_dom_title_cb: %s" % (title,))
if title is None:
self._title_req_ids.clear()
else:
if title.startswith("ShockTherapySugarRequest:"):
parts = title.split(":", 2)
if len(parts) != 3:
raise ValueError(title)
callback = parts[1]
path = parts[2]
req_id = int(callback[len("shockTherapySugarRequest"):])
if req_id in self._title_req_ids:
# suppress event with duplicate req_id
pass
else:
self._title_req_ids.add(req_id)
if path.startswith("file:///ShockTherapy."):
command = path[len("file:///ShockTherapy."):]
status = 200
content = b''
if command.startswith("viewChanged:"):
uri = unquote(command[len("viewChanged:"):])
self._uri_cb(uri)
elif path.startswith("file:///ShockTherapyConfig."):
command = path[len("file:///ShockTherapyConfig."):]
status = 200
content = b''
if command == "load":
content = self.metadata.get("options")
if content is None:
content = b"{}"
else:
content = content.decode(encoding="utf_8",
errors="replace")
elif command.startswith("persist:"):
self.metadata['options'] = unquote(
command[len("persist:"):])
elif command.startswith("export:"):
options = unquote(command[len("export:"):])
self.metadata['options'] = options
options.encode(encoding='utf_8', errors='replace')
dsobject = self._save_dsobject(
"ShockTherapyOptions.json", options)
self._saved_dsobject_alert(dsobject)
elif command == "import":
chooser = ObjectChooser(
parent=self,
what_filter=mime.GENERIC_TYPE_TEXT)
result = chooser.run()
if result == gtk.RESPONSE_ACCEPT:
f = open(
chooser.get_selected_object().
get_file_path(), 'rb')
try:
options = f.read()
finally:
f.close()
options = options.decode(encoding='utf_8',
errors='replace')
self.metadata['options'] = options
self._webview.reload()
else:
path = path[len(self._base_uri):]
path = os.path.join(self._http_dir, path)
path = os.path.normpath(path)
if not (path.startswith(self._http_dir)):
# don't allow traversal above _http_dir via ../
status = 404
content = ""
else:
f = None
try:
f = open(path, 'rb')
content = f.read()
except IOError:
status = 404
content = ""
else:
status = 200
finally:
if f is not None:
f.close()
#logging.debug(
# "ShockTherapySugarRequest: %s status: %s content: %s" %
# (path, status, content))
self._webview.execute_script(
"%s(%s, \"%s\")" %
(callback, status, base64.b64encode(content)))
def _save_dsobject(self,
filename,
content,
mime_type=None,
description=None):
parent_dir = os.path.join(self.get_activity_root(), 'tmp')
try:
os.makedirs(parent_dir)
except OSError:
pass
fd, tmp_filename = tempfile.mkstemp(dir=parent_dir,
suffix=filename,
prefix='tmp')
try:
os.write(fd, content)
except:
raise
else:
dsobject = datastore.create()
dsobject.metadata['title'] = filename
if mime_type is None:
mime_type = mime.get_for_file(tmp_filename)
dsobject.metadata['mime_type'] = mime_type
if description is None:
description = _('From: %s') % (self.metadata['title'], )
dsobject.metadata['description'] = description
dsobject.set_file_path(tmp_filename)
datastore.write(dsobject)
finally:
os.close(fd)
os.unlink(tmp_filename)
return dsobject
def _saved_dsobject_alert(self, dsobject):
saved_alert = Alert()
saved_alert.props.title = _('Download completed')
saved_alert.props.msg = dsobject.metadata['title']
saved_alert.add_button(gtk.RESPONSE_APPLY, _('Show in Journal'),
Icon(icon_name='zoom-activity'))
saved_alert.add_button(gtk.RESPONSE_OK, _('Ok'),
Icon(icon_name='dialog-ok'))
def response_cb(alert, response_id):
if response_id is gtk.RESPONSE_APPLY:
activity.show_object_in_journal(dsobject.object_id)
self.remove_alert(alert)
saved_alert.connect('response', response_cb)
self.add_alert(saved_alert)
saved_alert.show_all()
def _webview_uri_cb(self, view, gParamSpec):
self._uri_cb(view.get_property("uri"))
def _uri_cb(self, uri):
self._back.props.sensitive = self._webview.can_go_back()
self._main_button.set_sensitive(True)
self._screensaver_button.set_sensitive(True)
self._options_button.set_sensitive(True)
self._about_button.set_sensitive(True)
uri = uri.rstrip("#")
disabled_button = self._url_button_map.get(uri)
if disabled_button is not None:
disabled_button.set_sensitive(False)
@staticmethod
def _strip_fragment(uri):
index = uri.find("#")
if index != -1:
uri = uri[:index]
return uri
def _load_uri(self, uri):
previous = self._webview.get_property("uri")
if self._strip_fragment(uri) == self._strip_fragment(previous):
# avoid page reload
index = uri.find("#")
if index == -1:
location_hash = ""
else:
location_hash = uri[index:]
self._webview.execute_script("window.location.hash='%s'" %
location_hash)
else:
self._webview.load_uri(uri)
def _go_back_cb(self, button):
if self._webview.get_property("uri").startswith(self._urls["MAIN"]):
# avoid page reload
self._webview.execute_script("ShockTherapy.goBack()")
else:
self._webview.go_back()
def _main_cb(self, button):
self._load_uri(self._urls["MAIN"])
def _screensaver_cb(self, button):
self._load_uri(self._urls["SCREENSAVER"])
def _options_cb(self, button):
self._load_uri(self._urls["OPTIONS"])
def _about_cb(self, button):
self._load_uri(self._urls["ABOUT"])
def _reload_cb(self, button):
self._webview.reload()
def _fullscreen_cb(self, button):
self.fullscreen()
def _zoom_in_cb(self, button):
self._webview.zoom_in()
def _zoom_out_cb(self, button):
self._webview.zoom_out()
def _zoom_default_cb(self, button):
if self._webview.get_zoom_level() != 1.0:
self._webview.set_zoom_level(1.0)
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 CreateToolbar(gtk.Toolbar):
__gtype_name__ = 'CreateToolbar'
__gsignals__ = {
'create_new_game': (SIGNAL_RUN_FIRST, None, []),
'create_load_game': (SIGNAL_RUN_FIRST, None, [TYPE_PYOBJECT]),
'create_save_game': (SIGNAL_RUN_FIRST, None, 3 * [TYPE_PYOBJECT]),
'create_equal_pairs': (SIGNAL_RUN_FIRST, None, [TYPE_PYOBJECT]),
}
def __init__(self, activity):
gtk.Toolbar.__init__(self)
self.activity = activity
self._lock = True
# New Button
new_icon = join(dirname(__file__), 'images', 'game-new.svg')
new_image = gtk.Image()
new_image.set_from_file(new_icon)
self._new_button = ToolButton()
self._new_button.set_icon_widget(new_image)
self._new_button.set_tooltip(_('New game'))
self._new_button.connect('clicked', self._new_game_bt)
self._add_widget(self._new_button)
# Load Button
load_icon = join(dirname(__file__), 'images', 'game-load.svg')
load_image = gtk.Image()
load_image.set_from_file(load_icon)
self._load_button = ToolButton()
self._load_button.set_icon_widget(load_image)
self._load_button.set_tooltip(_('Load game'))
self._load_button.connect('clicked', self._load_game)
self._add_widget(self._load_button)
# Save Button
save_icon = join(dirname(__file__), 'images', 'game-save.svg')
save_image = gtk.Image()
save_image.set_from_file(save_icon)
self._save_button = ToolButton()
self._save_button.set_icon_widget(save_image)
self._save_button.set_tooltip(_('Save game'))
self._save_button.connect('clicked', self._save_game_bt)
self._save_button.set_sensitive(False)
self._add_widget(self._save_button)
# Separator
separator2 = gtk.SeparatorToolItem()
separator2.set_draw(True)
self.insert(separator2, -1)
self._add_widget(gtk.Label(_('Game name') + ': '))
self.game_name_entry = gtk.Entry()
self._add_widget(self.game_name_entry)
self._equal_pairs = gtk.CheckButton(_('Equal pairs'))
self._add_widget(self._equal_pairs)
self._equal_pairs.connect('toggled', self._emit_equal_pairs)
self._grouped_icon1 = join(dirname(__file__), 'images', 'equal_pairs1.svg')
self._grouped_icon2 = join(dirname(__file__), 'images', 'equal_pairs2.svg')
self._grouped_image1 = gtk.Image()
self._grouped_image2 = gtk.Image()
self._grouped_image1.set_from_file(self._grouped_icon1)
self._grouped_image2.set_from_file(self._grouped_icon2)
self._grouped = ToggleToolButton()
self._grouped.set_icon_widget(self._grouped_image1)
self._grouped.set_tooltip(_('Click for grouped game'))
self._grouped.connect('toggled', self._grouped_cb)
self._add_widget(self._grouped)
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_changed_cb(self, combobox, game_name):
self.game_name_entry.set_text(game_name)
self.emit('create_load_game', game_name)
def _load_game(self, button):
chooser = ObjectChooser(_('Choose memorize game'),
parent=self.activity,
flags=gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT)
jobject = ''
try:
result = chooser.run()
if result == gtk.RESPONSE_ACCEPT:
logging.debug('ObjectChooser: %r' % chooser.get_selected_object())
jobject = chooser.get_selected_object()
if not jobject or not jobject.file_path:
return
finally:
chooser.destroy()
del chooser
if jobject and jobject.file_path:
self.emit('create_load_game', jobject.file_path)
self._save_button.set_sensitive(False)
def _new_game_bt(self, button):
self.game_name_entry.set_text('')
self._equal_pairs.set_active(False)
self._grouped.set_active(False)
self.emit('create_new_game')
self._new_button.set_sensitive(False)
self._save_button.set_sensitive(False)
def _save_game_bt(self, button):
self.emit('create_save_game', self.game_name_entry.get_text(), self._equal_pairs.get_active(), self._grouped.get_active())
self._save_button.set_sensitive(False)
def _emit_equal_pairs(self, checkbutton):
self.emit('create_equal_pairs', checkbutton.get_active())
self._save_button.set_sensitive(True)
def _grouped_cb(self, widget):
self._save_button.set_sensitive(True)
if self._grouped.get_active():
self._grouped.set_icon_widget(self._grouped_image2)
self._grouped_image2.show()
self._grouped.set_tooltip(_('Click for ungrouped game'))
else:
self._grouped.set_icon_widget(self._grouped_image1)
self._grouped_image1.show()
self._grouped.set_tooltip(_('Click for grouped game'))
def update_create_toolbar(self, widget, game_name, equal_pairs, grouped):
self.game_name_entry.set_text(game_name)
self._equal_pairs.set_active(equal_pairs == 'True')
self._grouped.set_active(grouped == '1')
def update_buttons_status(self, widget, new, save):
self._new_button.set_sensitive(new)
self._save_button.set_sensitive(save)
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
"""
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:
if True:
self.label = gtk.Label(display.menu_journal_label)
self.label.show()
self._add_widget(self.label)
self.title = gtk.Entry()
self.title.set_size_request(int(gtk.gdk.screen_width() / 6), -1)
if activity.metadata:
self.title.set_text(activity.metadata['title'])
#activity.metadata.connect('updated', self.__jobject_updated_cb)
self.title.connect('changed', self.__title_changed_cb)
self.title.connect('activate', self.__update_title_cb)
self._add_widget(self.title)
fn = os.path.join(os.getcwd(),'assets','stack_new.png')
button = ImageButton()
tooltip = _("Add Album Stack")
button.set_image(fn,tip=tooltip)
self.add_album = button
self.add_album.show()
self.add_album.connect('clicked', self.__add_album_clicked_cb)
self.insert(self.add_album,-1)
fn = os.path.join(os.getcwd(),'assets','stack_del.png')
button = ImageButton()
tooltip = _("Delete Album Stack")
button.set_image(fn,tip=tooltip)
button.connect('clicked', self.__delete_album_clicked_cb)
self.insert(button,-1)
fn = os.path.join(os.getcwd(),'assets','trash_del.png')
button = ImageButton()
tooltip = _("Remove Trash Images from XO")
button.set_image(fn,tip=tooltip)
self.empty_journal_button = button
self.empty_journal_button.hide()
self.empty_journal_button.connect('clicked',self.__empty_trash_clicked_cb)
self.insert(self.empty_journal_button,-1)
"""
separator = gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
self.insert(separator, -1)
separator.show()
self.share = ToolComboBox(label_text=_('Traceback:'))
self.share.combo.connect('changed', self.__traceback_changed_cb)
self.share.combo.append_item("traceback_plain", _('Plain'))
self.share.combo.append_item('traceback_context', _('Context'))
self.share.combo.append_item('traceback_verbose', _('Verbose'))
self.insert(self.share, -1)
self.share.show()
self._update_share()
"""
separator = gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
self.insert(separator, -1)
separator.show()
self.keep = ToolButton()
self.keep.set_tooltip(_('Save and Start New'))
#client = gconf.client_get_default()
#color = XoColor(client.get_string('/desktop/sugar/user/color'))
#keep_icon = Icon(icon_name='document-save', xo_color=color)
keep_icon = Icon(icon_name='document-save')
keep_icon.show()
self.keep.set_icon_widget(keep_icon)
#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')
self.stop.set_tooltip(_('Stop'))
#self.stop.props.accelerator = '<Ctrl>Q'
self.stop.connect('clicked', self.__stop_clicked_cb)
self.insert(self.stop, -1)
self.stop.show()
self._update_title_sid = None
def set_label(self,text,visible=True):
self.label.set_text(text)
if not visible:
self.title.set_sensitive(False)
else:
self.title.set_sensitive(True)
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 __add_album_clicked_cb (self,button):
title = self.title.get_text()
self._activity.activity_toolbar_add_album_cb(title)
def __delete_album_clicked_cb (self,button):
self._activity.activity_toolbar_delete_album_cb()
def __empty_trash_clicked_cb(self,button):
self._activity.activity_toolbar_empty_trash_cb()
def __traceback_changed_cb(self, combo):
model = self.share.combo.get_model()
it = self.share.combo.get_active_iter()
(scope, ) = model.get(it, 0)
if scope == 'traceback_plain':
self._activity.traceback = 'Plain'
self._activity.debug_dict['traceback'] = 'plain'
elif scope == 'traceback_context':
self._activity.traceback = 'Context'
self._activity.debug_dict['traceback'] = 'context'
elif scope == 'traceback_verbose':
self._activity.traceback = 'Verbose'
self._activity.debug_dict['traceback'] = 'verbose'
self._activity.set_ipython_traceback()
def __keep_clicked_cb(self, button):
self._activity.save_icon_clicked = True
self._activity.copy()
def __stop_clicked_cb(self, button):
self._activity.stop()
def __jobject_updated_cb(self, jobject):
self.title.set_text(jobject['title'])
def __title_changed_cb(self, entry):
if not self._update_title_sid:
self._update_title_sid = gobject.timeout_add(
1000, self.__update_title_cb)
def __update_title_cb(self, entry=None):
title = self.title.get_text()
if self._activity.game.is_journal():
self._activity.metadata['title'] = title
self._activity.metadata['title_set_by_user'] = '******'
else:
self._activity.game.change_album_name(title)
title_set_by_user = self._activity.metadata.get('title_set_by_user')
if not title_set_by_user: #let the journal title reflect the most recent stack
self._activity.metadata['title'] = title
self._update_title_sid = None
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 EntryToolbar(gtk.Toolbar):
__gsignals__ = {
'volume-error': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE,
([str, str])),
}
def __init__(self):
gtk.Toolbar.__init__(self)
self._metadata = None
self._temp_file_path = None
self._resume = ToolButton('activity-start')
self._resume.connect('clicked', self._resume_clicked_cb)
self.add(self._resume)
self._resume.show()
client = gconf.client_get_default()
color = XoColor(client.get_string('/desktop/sugar/user/color'))
self._copy = ToolButton()
icon = Icon(icon_name='edit-copy', xo_color=color)
self._copy.set_icon_widget(icon)
icon.show()
self._copy.set_tooltip(_('Copy to'))
self._copy.connect('clicked', self._copy_clicked_cb)
self.add(self._copy)
self._copy.show()
self._duplicate = ToolButton()
icon = Icon(icon_name='edit-duplicate', xo_color=color)
self._duplicate.set_icon_widget(icon)
self._duplicate.set_tooltip(_('Duplicate'))
self._duplicate.connect('clicked', self._duplicate_clicked_cb)
self.add(self._duplicate)
separator = gtk.SeparatorToolItem()
self.add(separator)
separator.show()
erase_button = ToolButton('list-remove')
erase_button.set_tooltip(_('Erase'))
erase_button.connect('clicked', self._erase_button_clicked_cb)
self.add(erase_button)
erase_button.show()
def set_metadata(self, metadata):
self._metadata = metadata
self._refresh_copy_palette()
self._refresh_duplicate_palette()
self._refresh_resume_palette()
def _resume_clicked_cb(self, button):
misc.resume(self._metadata)
def _copy_clicked_cb(self, button):
button.palette.popup(immediate=True, state=Palette.SECONDARY)
def _duplicate_clicked_cb(self, button):
file_path = model.get_file(self._metadata['uid'])
try:
model.copy(self._metadata, '/')
except IOError, e:
logging.exception('Error while copying the entry.')
self.emit('volume-error',
_('Error while copying the entry. %s') % (e.strerror, ),
_('Error'))
