class EditToolbar(activity.EditToolbar):
def __init__(self, _parent):
activity.EditToolbar.__init__(self)
self._parent = _parent
self.undo.connect('clicked', self.__undo_cb)
self.redo.connect('clicked', self.__redo_cb)
self.copy.connect('clicked', self.__copy_cb)
self.paste.connect('clicked', self.__paste_cb)
menu_item = MenuItem(_('Cut'))
menu_item.connect('activate', self.__cut_cb)
menu_item.show()
self.copy.get_palette().menu.append(menu_item)
self.insert(gtk.SeparatorToolItem(), -1)
self.erase_button = ToolButton('edit-delete')
self.erase_button.set_tooltip(_('Erase selected thought(s)'))
self.erase_button.connect('clicked', self.__delete_cb)
self.insert(self.erase_button, -1)
self.show_all()
self.clipboard = gtk.Clipboard()
self.copy.child.set_sensitive(False)
self.paste.child.set_sensitive(False)
self.erase_button.set_sensitive(False)
def __undo_cb(self, button):
self._parent._undo.undo_action(None)
def __redo_cb(self, button):
self._parent._undo.redo_action(None)
def __cut_cb(self, event):
self._parent._main_area.cut_clipboard(self.clipboard)
def __copy_cb(self, event):
self._parent._main_area.copy_clipboard(self.clipboard)
def __paste_cb(self, event):
self._parent._main_area.paste_clipboard(self.clipboard)
def __delete_cb(self, widget):
self._stop_moving()
self.stop_dragging()
self._parent._main_area.delete_selected_elements()
def stop_dragging(self):
if self._parent._main_area.is_dragging():
self._parent._main_area.drag_menu_cb(self._sw, False)
def _stop_moving(self):
self._parent._main_area.move_mode = False
class EditToolbar(activity.EditToolbar):
def __init__(self, _parent):
activity.EditToolbar.__init__(self)
self._parent = _parent
self.undo.connect('clicked', self.__undo_cb)
self.redo.connect('clicked', self.__redo_cb)
self.copy.connect('clicked', self.__copy_cb)
self.paste.connect('clicked', self.__paste_cb)
menu_item = MenuItem(_('Cut'))
menu_item.connect('activate', self.__cut_cb)
menu_item.show()
self.copy.get_palette().menu.append(menu_item)
self.insert(gtk.SeparatorToolItem(), -1)
self.erase_button = ToolButton('edit-delete')
self.erase_button.set_tooltip(_('Erase selected thought(s)'))
self.erase_button.connect('clicked', self.__delete_cb)
self.insert(self.erase_button, -1)
self.show_all()
self.clipboard = gtk.Clipboard()
self.copy.child.set_sensitive(False)
self.paste.child.set_sensitive(False)
self.erase_button.set_sensitive(False)
def __undo_cb(self, button):
self._parent._undo.undo_action(None)
def __redo_cb(self, button):
self._parent._undo.redo_action(None)
def __cut_cb(self, event):
self._parent._main_area.cut_clipboard(self.clipboard)
def __copy_cb(self, event):
self._parent._main_area.copy_clipboard(self.clipboard)
def __paste_cb(self, event):
self._parent._main_area.paste_clipboard(self.clipboard)
def __delete_cb(self, widget):
self._stop_moving()
self.stop_dragging()
self._parent._main_area.delete_selected_elements()
def stop_dragging(self):
if self._parent._main_area.is_dragging():
self._parent._main_area.drag_menu_cb(self._sw, False)
def _stop_moving(self):
self._parent._main_area.move_mode = False
class Avatars(gtk.VBox):
def __init__(self, btnfunction, loadfunction, win, path="none"):
super(Avatars, self).__init__()
win.set_title(_('Select a avatar'))
win.set_decorated(False)
win.set_position(gtk.WIN_POS_CENTER)
y = gtk.gdk.screen_height() - 100
win.set_size_request(gtk.gdk.screen_width() - 100, y)
self.win = win
scroll = gtk.ScrolledWindow()
scroll.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
self.hbox = gtk.HBox()
self.show_all()
self.function = btnfunction
self.a = 0
self.vbx = gtk.VBox()
self.vbx.pack_start(self.hbox, False, False, 6)
self.eventbox = gtk.EventBox()
self.eventbox.modify_bg(gtk.STATE_NORMAL, gtk.gdk.color_parse('white'))
self.eventbox.add(self.vbx)
scroll.add_with_viewport(self.eventbox)
####
# Sugar Style
####
tl = gtk.Toolbar()
tl.modify_bg(gtk.STATE_NORMAL, gtk.gdk.color_parse('black'))
self.loadfromjournal = ToolButton('open-from-journal')
self.loadfromjournal.set_tooltip(_('Load from journal'))
self.loadfromjournal.connect('clicked', loadfunction, win)
self.accept = ToolButton('dialog-ok')
self.accept.set_tooltip(_('Accept'))
self.cancel = ToolButton('gtk-cancel')
self.cancel.set_tooltip(_('Cancel'))
self.cancel.connect('clicked', lambda x: win.destroy())
sep = gtk.SeparatorToolItem()
sep.set_expand(True)
sep.props.draw = False
tl.insert(self.loadfromjournal, 0)
tl.insert(sep, 1)
tl.insert(self.accept, 2)
tl.insert(self.cancel, 3)
tl.set_size_request(55, -1)
self.pack_start(tl, False, False, 0)
self.eventbox.add(scroll)
self.pack_end(scroll, True, True, 0)
####
self.path = None
self.actual = None
for x in os.listdir('avatars'):
if path != "none":
if path == os.path.join(os.getcwd(), 'avatars', x):
sensitive = False
else:
sensitive = True
else:
sensitive = True
self._gen_avatars(x, sensitive)
gobject.timeout_add(10, self._check)
def _check(self):
a = str(type(self.path)).lower()
if 'none' in a:
self.accept.set_sensitive(False)
else:
self.accept.set_sensitive(True)
return True
def _gen_avatars(self, name, sensi):
path = os.path.join(os.getcwd(), 'avatars', name)
button = gtk.Button()
if not sensi:
self.actual = button
button.set_sensitive(sensi)
button.set_tooltip_text(path)
image = gtk.Image()
pix = gtk.gdk.pixbuf_new_from_file_at_size(path, 100, 100)
image.set_from_pixbuf(pix)
button.add(image)
button.connect('clicked', self._set_path)
if not self.a + 1 == 6:
self.hbox.pack_start(button, False, False, 0)
self.a += 1
else:
self.hbox = gtk.HBox()
self.vbx.pack_start(self.hbox, False, False, 6)
self.hbox.pack_start(button, False, False, 0)
self.a = 0
button.props.has_tooltip = False
self.show_all()
def _set_path(self, widget):
try:
self.actual.set_sensitive(True)
except:
pass
self.path = widget.get_tooltip_text()
self.accept.connect('clicked', self.function, self.path, self.win)
widget.set_sensitive(False)
self.actual = widget
class ViewToolbar(gtk.Toolbar):
__gtype_name__ = 'ViewToolbar'
__gsignals__ = {
'go-fullscreen': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE, ([]))
}
def __init__(self, view):
gtk.Toolbar.__init__(self)
self._view = view
self._zoom_out = ToolButton('zoom-out')
self._zoom_out.set_tooltip(_('Zoom out'))
self._zoom_out.connect('clicked', self._zoom_out_cb)
self.insert(self._zoom_out, -1)
self._zoom_out.show()
self._zoom_in = ToolButton('zoom-in')
self._zoom_in.set_tooltip(_('Zoom in'))
self._zoom_in.connect('clicked', self._zoom_in_cb)
self.insert(self._zoom_in, -1)
self._zoom_in.show()
self._zoom_tofit = ToolButton('zoom-best-fit')
self._zoom_tofit.set_tooltip(_('Fit to window'))
self._zoom_tofit.connect('clicked', self._zoom_tofit_cb)
self.insert(self._zoom_tofit, -1)
self._zoom_tofit.show()
self._zoom_original = ToolButton('zoom-original')
self._zoom_original.set_tooltip(_('Original size'))
self._zoom_original.connect('clicked', self._zoom_original_cb)
self.insert(self._zoom_original, -1)
self._zoom_original.show()
spacer = gtk.SeparatorToolItem()
spacer.props.draw = False
self.insert(spacer, -1)
spacer.show()
self._rotate_anticlockwise = ToolButton('rotate_anticlockwise')
self._rotate_anticlockwise.set_tooltip(_('Rotate anticlockwise'))
self._rotate_anticlockwise.connect('clicked',
self._rotate_anticlockwise_cb)
self.insert(self._rotate_anticlockwise, -1)
self._rotate_anticlockwise.show()
self._rotate_clockwise = ToolButton('rotate_clockwise')
self._rotate_clockwise.set_tooltip(_('Rotate clockwise'))
self._rotate_clockwise.connect('clicked', self._rotate_clockwise_cb)
self.insert(self._rotate_clockwise, -1)
self._rotate_clockwise.show()
spacer = gtk.SeparatorToolItem()
spacer.props.draw = False
self.insert(spacer, -1)
spacer.show()
self._fullscreen = ToolButton('view-fullscreen')
self._fullscreen.set_tooltip(_('Fullscreen'))
self._fullscreen.connect('clicked', self._fullscreen_cb)
self.insert(self._fullscreen, -1)
self._fullscreen.show()
def _zoom_in_cb(self, button):
self._zoom_in.set_sensitive(self._view.zoom_in())
self._zoom_out.set_sensitive(True)
def _zoom_out_cb(self, button):
self._zoom_out.set_sensitive(self._view.zoom_out())
self._zoom_in.set_sensitive(True)
def _zoom_tofit_cb(self, button):
zoom = self._view.calculate_optimal_zoom()
self._view.set_zoom(zoom)
def _zoom_original_cb(self, button):
self._view.set_zoom(1)
def _rotate_anticlockwise_cb(self, button):
angle = self._view.get_property('angle')
self._view.set_angle(angle + 90)
def _rotate_clockwise_cb(self, button):
angle = self._view.get_property('angle')
if angle == 0:
angle = 360
self._view.set_angle(angle - 90)
def _fullscreen_cb(self, button):
self.emit('go-fullscreen')
class EditToolbar(gtk.Toolbar):
def __init__(self, pc, toolbar_box):
gtk.Toolbar.__init__(self)
self._abiword_canvas = pc.abiword_canvas
copy = CopyButton()
copy.props.accelerator = '<Ctrl>C'
copy.connect('clicked', lambda button: pc.abiword_canvas.copy())
self.insert(copy, -1)
copy.show()
paste = PasteButton()
paste.props.accelerator = '<Ctrl>V'
paste.connect('clicked', lambda button: pc.abiword_canvas.paste())
self.insert(paste, -1)
paste.show()
separator = gtk.SeparatorToolItem()
self.insert(separator, -1)
separator.show()
undo = UndoButton(sensitive=False)
undo.connect('clicked', lambda button: pc.abiword_canvas.undo())
pc.abiword_canvas.connect("can-undo", lambda abi, can_undo:
undo.set_sensitive(can_undo))
self.insert(undo, -1)
undo.show()
redo = RedoButton(sensitive=False)
redo.connect('clicked', lambda button: pc.abiword_canvas.redo())
pc.abiword_canvas.connect("can-redo", lambda abi, can_redo:
redo.set_sensitive(can_redo))
self.insert(redo, -1)
redo.show()
pc.abiword_canvas.connect('text-selected', lambda abi, b:
copy.set_sensitive(True))
pc.abiword_canvas.connect('image-selected', lambda abi, b:
copy.set_sensitive(True))
pc.abiword_canvas.connect('selection-cleared', lambda abi, b:
copy.set_sensitive(False))
separator = gtk.SeparatorToolItem()
self.insert(separator, -1)
separator.show()
search_label = gtk.Label(_("Search") + ": ")
search_label.show()
search_item_page_label = gtk.ToolItem()
search_item_page_label.add(search_label)
self.insert(search_item_page_label, -1)
search_item_page_label.show()
# setup the search options
self._search_entry = iconentry.IconEntry()
self._search_entry.set_icon_from_name(iconentry.ICON_ENTRY_PRIMARY,
'system-search')
self._search_entry.connect('activate', self._search_entry_activated_cb)
self._search_entry.connect('changed', self._search_entry_changed_cb)
self._search_entry.add_clear_button()
self._add_widget(self._search_entry, expand=True)
self._findprev = ToolButton('go-previous-paired')
self._findprev.set_tooltip(_('Find previous'))
self.insert(self._findprev, -1)
self._findprev.show()
self._findprev.connect('clicked', self._findprev_cb)
self._findnext = ToolButton('go-next-paired')
self._findnext.set_tooltip(_('Find next'))
self.insert(self._findnext, -1)
self._findnext.show()
self._findnext.connect('clicked', self._findnext_cb)
# set the initial state of the search controls
# note: we won't simple call self._search_entry_changed_cb
# here, as that will call into the abiword_canvas, which
# is not mapped on screen here, causing the set_find_string
# call to fail
self._findprev.set_sensitive(False)
self._findnext.set_sensitive(False)
def _search_entry_activated_cb(self, entry):
logger.debug('_search_entry_activated_cb')
if not self._search_entry.props.text:
return
# find the next entry
self._abiword_canvas.find_next(False)
def _search_entry_changed_cb(self, entry):
logger.debug('_search_entry_changed_cb search for \'%s\'',
self._search_entry.props.text)
if not self._search_entry.props.text:
self._search_entry.activate()
# set the button contexts
self._findprev.set_sensitive(False)
self._findnext.set_sensitive(False)
return
self._abiword_canvas.set_find_string(self._search_entry.props.text)
# set the button contexts
self._findprev.set_sensitive(True)
self._findnext.set_sensitive(True)
# immediately start seaching
self._abiword_canvas.find_next(True)
def _findprev_cb(self, button):
logger.debug('_findprev_cb')
if self._search_entry.props.text:
self._abiword_canvas.find_prev()
else:
logger.debug('nothing to search for!')
def _findnext_cb(self, button):
logger.debug('_findnext_cb')
if self._search_entry.props.text:
self._abiword_canvas.find_next(False)
else:
logger.debug('nothing to search for!')
# bad foddex! this function was copied from sugar's activity.py
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 __init__(self, handle):
activity.Activity.__init__(self, handle, True)
self.max_participants = 1
# 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.__add_note_cb)
toolbarbox.toolbar.insert(note_add, -1)
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)
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()
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)
class NavToolBar(gtk.Toolbar):
__gsignals__ = {
'lock-button-clicked' : (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE, ())
}
def __init__(self, arbiter):
gtk.Toolbar.__init__(self)
self.__arbiter = arbiter
self.__logger = logging.getLogger('Navigation Toolbar')
self.__logger.setLevel(logging.DEBUG)
self.__prevbtn = ToolButton('go-previous')
self.__prevbtn.set_tooltip(_("Previous slide"))
self.__prevbtn.connect('clicked', self.previous_btn_clicked)
self.__nextbtn = ToolButton('go-next')
self.__nextbtn.set_tooltip(_("Next slide"))
self.__nextbtn.connect('clicked', self.next_btn_clicked)
# page number widget and navigation
self.__num_page_item = gtk.ToolItem()
self.__num_current_page = 1
self.__num_page_entry = gtk.Entry()
self.__num_page_entry.set_text(str(self.__num_current_page))
self.__num_page_entry.set_alignment(1)
self.__num_page_entry.connect('activate', self.num_page_activate)
self.__num_page_entry.set_width_chars(4)
self.__num_page_item.add(self.__num_page_entry)
self.__num_page_entry.show()
# total page number widget
self.__total_page_item = gtk.ToolItem()
self.__total_page_label = gtk.Label()
label_attributes = pango.AttrList()
label_attributes.insert(pango.AttrSize(14000, 0, -1))
label_attributes.insert(pango.AttrForeground(65535, 65535, 65535, 0, -1))
self.__total_page_label.set_attributes(label_attributes)
self.__total_page_label.set_text(' / ' + str(self.__arbiter.get_slide_count()))
self.__total_page_item.add(self.__total_page_label)
self.__total_page_label.show()
# Instructor/Student mode label
self.__mode_item = gtk.ToolItem()
self.__mode_label = gtk.Label()
label_attributes = pango.AttrList()
label_attributes.insert(pango.AttrSize(14000, 0, -1))
label_attributes.insert(pango.AttrForeground(65535, 65535, 65535, 0, -1))
self.__mode_label.set_attributes(label_attributes)
self.__mode_label.set_text(_("Not Connected"))
self.__mode_item.add(self.__mode_label)
self.__mode_label.show()
# separator between navigation buttons and mode label
self.__separator1 = gtk.SeparatorToolItem()
self.__separator1.set_draw(True)
self.__separator1.set_expand(True)
# separator between mode label and lock button
self.__separator2 = gtk.SeparatorToolItem()
self.__separator2.set_draw(True)
self.__separator2.set_expand(True)
# unlocked button
self.__unlockBtn = ToolButton('unlocked')
self.__unlockBtn.set_tooltip(_("Student Navigation Unlocked"))
# navigation is unlocked by default, so insert the unlock button
# locked button
self.__lockBtn = ToolButton('locked')
self.__lockBtn.set_tooltip(_("Student Navigation Locked"))
self.__logger.debug("Connecting to navigation locking and activity sharing signals.")
self.__arbiter.connect_shared(self.activity_shared_cb)
self.__arbiter.connect_joined(self.activity_joined_cb)
self.__arbiter.connect_navigation_lock_change(self.set_lock_button)
# triggers for when slides are changed
self.__arbiter.connect_slide_changed(self.slide_changed_cb)
self.__arbiter.connect_deck_changed(self.slide_changed_cb)
self.slide_changed_cb()
self.insert(self.__prevbtn, -1)
self.insert(self.__nextbtn, -1)
self.insert(self.__num_page_item, -1)
self.insert(self.__total_page_item, -1)
self.insert(self.__separator1, -1)
self.insert(self.__mode_item, -1)
self.insert(self.__separator2, -1)
self.insert(self.__unlockBtn, -1)
self.__prevbtn.show()
self.__nextbtn.show()
self.__num_page_item.show()
self.__total_page_item.show()
self.__separator1.show()
self.__mode_item.show()
self.__separator2.show()
self.__unlockBtn.show()
self.show() # show the entire toolbar
def activity_shared_cb(self, widget):
#Callback for when the activity is shared
# bind the lock button click with switching lock mode
self.__lockBtn.connect('clicked', self.lock_btn_cb)
self.__unlockBtn.connect('clicked', self.lock_btn_cb)
self.__mode_label.set_text(_("Instructor"))
def activity_joined_cb(self, widget):
""" Callback for when the activity is joined """
self.__mode_label.set_text(_("Student"))
self.__lockBtn.set_sensitive(False)
self.__unlockBtn.set_sensitive(False)
def lock_btn_cb(self, widget):
""" The lock/unlock button has been clicked. """
self.emit('lock-button-clicked')
def set_lock_button(self, widget, is_locked):
sharing = self.__arbiter.get_is_instructor()
self.__logger.debug("Changing lock button, lock mode %u, init %u",
is_locked, sharing)
if is_locked:
new_button = self.__lockBtn
if not sharing:
self.__prevbtn.set_sensitive(False)
self.__nextbtn.set_sensitive(False)
else:
new_button = self.__unlockBtn
if not sharing:
self.__prevbtn.set_sensitive(True)
self.__nextbtn.set_sensitive(True)
old = self.get_nth_item(7)
self.remove(old)
self.insert(new_button, 7)
new_button.show()
self.queue_draw()
def next_btn_clicked(self, widget):
self.__arbiter.do_next_slide()
def previous_btn_clicked(self, widget):
self.__arbiter.do_previous_slide()
def slide_changed_cb(self, widget=None):
self.__logger.debug("Changing slides!")
if self.__arbiter.get_deck_is_at_beginning():
self.__prevbtn.set_sensitive(False)
else:
self.__prevbtn.set_sensitive(True)
if self.__arbiter.get_deck_is_at_end():
self.__nextbtn.set_sensitive(False)
else:
self.__nextbtn.set_sensitive(True)
self.__num_current_page = self.__arbiter.get_slide_index()
self.__num_page_entry.set_text(str(self.__num_current_page + 1))
self.__total_page_label.set_text(' / ' + str(self.__arbiter.get_slide_count()))
def num_page_activate(self, entry):
page_entered = int(entry.get_text())
if page_entered < 1:
page_entered = 1
elif self.__arbiter.get_slide_count() < page_entered:
page_entered = self.__arbiter.get_slide_count()
self.__arbiter.do_goto_slide(page_entered - 1, local_request=True)
class TableToolbar(gtk.Toolbar):
def __init__(self, toolbox, abiword_canvas, parent):
gtk.Toolbar.__init__(self)
self._toolbox = toolbox
self._abiword_canvas = abiword_canvas
self._parent = parent
self._table = abiword.TableCreator()
self._table.set_labels(_('Table'), _('Cancel'))
self._table_id = self._table.connect('selected', self._table_cb)
self._table.show()
tool_item = gtk.ToolItem()
tool_item.add(self._table)
self.insert(tool_item, -1)
tool_item.show_all()
self._table_rows_after = ToolButton('row-insert')
self._table_rows_after.set_tooltip(_('Insert Row'))
self._table_rows_after_id = self._table_rows_after.connect(
'clicked', self._table_rows_after_cb)
self.insert(self._table_rows_after, -1)
self._table_rows_after.show()
self._table_delete_rows = ToolButton('row-remove')
self._table_delete_rows.set_tooltip(_('Delete Row'))
self._table_delete_rows_id = self._table_delete_rows.connect(
'clicked', self._table_delete_rows_cb)
self.insert(self._table_delete_rows, -1)
self._table_delete_rows.show()
self._table_cols_after = ToolButton('column-insert')
self._table_cols_after.set_tooltip(_('Insert Column'))
self._table_cols_after_id = self._table_cols_after.connect(
'clicked', self._table_cols_after_cb)
self.insert(self._table_cols_after, -1)
self._table_cols_after.show()
self._table_delete_cols = ToolButton('column-remove')
self._table_delete_cols.set_tooltip(_('Delete Column'))
self._table_delete_cols_id = self._table_delete_cols.connect(
'clicked', self._table_delete_cols_cb)
self.insert(self._table_delete_cols, -1)
self._table_delete_cols.show()
self._abiword_canvas.connect('table-state', self._isTable_cb)
####btn salir del barrido del menu item
self._btn_barrido_menu = ToolButton()
self._btn_barrido_menu.set_tooltip(_('Salir \nMenú'))
self._btn_barrido_menu_id = self._btn_barrido_menu.connect(
'clicked', self._btn_barrido_menu_cb)
self.insert(self._btn_barrido_menu, -1)
self._btn_barrido_menu.set_no_show_all(True)
#self._btn_barrido_menu.show() # en realidad mostrar solo si esta barriendo
def _btn_barrido_menu_cb(self, button):
if (self._parent.BOTONESxBARRIDO_MENU_ITEM):
self._parent.BOTONESxBARRIDO_MENU = False
self._parent.BOTONESxBARRIDO_MENU_ITEM = False
self._parent.BOTONESxBARRIDO = False # si le doy True va a ejectuar el escribir porque llama al metodo del eventbox
#self._parent.chk_activarBarrido_botones_menu.emit("clicked")
self._parent.chk_activarBarrido_botones.set_active(True)
####fin btn salir del barrido del menu item
def _table_cb(self, abi, rows, cols):
self._abiword_canvas.insert_table(rows, cols)
def _table_rows_after_cb(self, button):
self._abiword_canvas.invoke_cmd('insertRowsAfter', '', 0, 0)
def _table_delete_rows_cb(self, button):
self._abiword_canvas.invoke_cmd('deleteRows', '', 0, 0)
def _table_cols_after_cb(self, button):
self._abiword_canvas.invoke_cmd('insertColsAfter', '', 0, 0)
def _table_delete_cols_cb(self, button):
self._abiword_canvas.invoke_cmd('deleteColumns', '', 0, 0)
def _isTable_cb(self, abi, b):
self._table_rows_after.set_sensitive(b)
self._table_delete_rows.set_sensitive(b)
self._table_cols_after.set_sensitive(b)
self._table_delete_cols.set_sensitive(b)
if b:
self._toolbox.set_current_toolbar(TOOLBAR_TABLE)
self._abiword_canvas.grab_focus() # hack: bad toolbox, bad!
class WriteEditToolbar(EditToolbar):
def __init__(self, toolbox, abiword_canvas, text_toolbar, parent):
EditToolbar.__init__(self)
self._toolbox = toolbox
self._abiword_canvas = abiword_canvas
self._text_toolbar = text_toolbar
self._parent = parent
# connect existing buttons
self.undo.set_sensitive(False)
self.redo.set_sensitive(False)
self.undo.connect('clicked', self._undo_cb)
self.redo.connect('clicked', self._redo_cb)
self.copy.connect('clicked', self._copy_cb)
self.paste.connect('clicked', self._paste_cb)
self._abiword_canvas.connect("can-undo", self._can_undo_cb)
self._abiword_canvas.connect("can-redo", self._can_redo_cb)
# make expanded non-drawn visible separator to make the search stuff right-align
separator = gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
self.insert(separator, -1)
separator.show()
# setup the search options
self._search_entry = iconentry.IconEntry()
self._search_entry.set_icon_from_name(iconentry.ICON_ENTRY_PRIMARY,
'system-search')
self._search_entry.connect('activate', self._search_entry_activated_cb)
self._search_entry.connect('changed', self._search_entry_changed_cb)
self._search_entry.add_clear_button()
self._add_widget(self._search_entry, expand=True)
self._findprev = ToolButton('go-previous')
self._findprev.set_tooltip(_('Find previous'))
self.insert(self._findprev, -1)
self._findprev.show()
self._findprev.connect('clicked', self._findprev_cb)
self._findnext = ToolButton('go-next')
self._findnext.set_tooltip(_('Find next'))
self.insert(self._findnext, -1)
self._findnext.show()
self._findnext.connect('clicked', self._findnext_cb)
# set the initial state of the search controls
# note: we won't simple call self._search_entry_changed_cb
# here, as that will call into the abiword_canvas, which
# is not mapped on screen here, causing the set_find_string
# call to fail
self._findprev.set_sensitive(False)
self._findnext.set_sensitive(False)
####btn salir del barrido del menu item
self._btn_barrido_menu = ToolButton()
self._btn_barrido_menu.set_tooltip(_('Salir \nMenú'))
self._btn_barrido_menu_id = self._btn_barrido_menu.connect(
'clicked', self._btn_barrido_menu_cb)
self.insert(self._btn_barrido_menu, -1)
self._btn_barrido_menu.set_no_show_all(True)
#self._btn_barrido_menu.show() # en realidad mostrar solo si esta barriendo
def _btn_barrido_menu_cb(self, button):
if (self._parent.BOTONESxBARRIDO_MENU_ITEM):
self._parent.BOTONESxBARRIDO_MENU = False
self._parent.BOTONESxBARRIDO_MENU_ITEM = False
self._parent.BOTONESxBARRIDO = False # si le doy True va a ejectuar el escribir porque llama al metodo del eventbox
#self._parent.chk_activarBarrido_botones_menu.emit("clicked")
self._parent.chk_activarBarrido_botones.set_active(True)
####fin btn salir del barrido del menu item
def _undo_cb(self, button):
self._abiword_canvas.undo()
def _redo_cb(self, button):
self._abiword_canvas.redo()
def _copy_cb(self, button):
self._abiword_canvas.copy()
def _paste_cb(self, button):
self._abiword_canvas.paste()
def _can_undo_cb(self, canvas, can_undo):
self.undo.set_sensitive(can_undo)
def _can_redo_cb(self, canvas, can_redo):
self.redo.set_sensitive(can_redo)
def _search_entry_activated_cb(self, entry):
logger.debug('_search_entry_activated_cb')
if not self._search_entry.props.text:
return
# find the next entry
id = self._text_toolbar.get_text_selected_handler()
self._abiword_canvas.handler_block(id)
self._abiword_canvas.find_next(False)
self._abiword_canvas.handler_unblock(id)
def _search_entry_changed_cb(self, entry):
logger.debug('_search_entry_changed_cb search for \'%s\'',
self._search_entry.props.text)
if not self._search_entry.props.text:
self._search_entry.activate()
# set the button contexts
self._findprev.set_sensitive(False)
self._findnext.set_sensitive(False)
return
self._abiword_canvas.set_find_string(self._search_entry.props.text)
# set the button contexts
self._findprev.set_sensitive(True)
self._findnext.set_sensitive(True)
# immediately start seaching
id = self._text_toolbar.get_text_selected_handler()
self._abiword_canvas.handler_block(id)
self._abiword_canvas.find_next(True)
self._abiword_canvas.handler_unblock(id)
def _findprev_cb(self, button):
logger.debug('_findprev_cb')
if self._search_entry.props.text:
id = self._text_toolbar.get_text_selected_handler()
self._abiword_canvas.handler_block(id)
self._abiword_canvas.find_prev()
self._abiword_canvas.handler_unblock(id)
else:
logger.debug('nothing to search for!')
def _findnext_cb(self, button):
logger.debug('_findnext_cb')
if self._search_entry.props.text:
id = self._text_toolbar.get_text_selected_handler()
self._abiword_canvas.handler_block(id)
self._abiword_canvas.find_next(False)
self._abiword_canvas.handler_unblock(id)
else:
logger.debug('nothing to search for!')
# bad foddex! this function was copied from sugar's activity.py
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()
class TextAttributesToolbar(gtk.Toolbar):
def __init__(self, main_area):
gtk.Toolbar.__init__(self)
self._main_area = main_area
self._font_list = ['ABC123', 'Sans', 'Serif', 'Monospace', 'Symbol']
self._font_sizes = ['8', '9', '10', '11', '12', '14', '16', '20',
'22', '24', '26', '28', '36', '48', '72']
self.font_button = ToolButton('font-text')
self.font_button.set_tooltip(_('Select font'))
self.font_button.connect('clicked', self.__font_selection_cb)
self.insert(self.font_button, -1)
self._setup_font_palette()
self.insert(gtk.SeparatorToolItem(), -1)
self.font_size_up = ToolButton('resize+')
self.font_size_up.set_tooltip(_('Bigger'))
self.font_size_up.connect('clicked', self.__font_sizes_cb, True)
self.insert(self.font_size_up, -1)
if len(self._main_area.selected) > 0:
font_size = self._main_area.font_size
else:
font_size = utils.default_font_size
self.size_label = gtk.Label(str(font_size))
self.size_label.show()
toolitem = gtk.ToolItem()
toolitem.add(self.size_label)
toolitem.show()
self.insert(toolitem, -1)
self.font_size_down = ToolButton('resize-')
self.font_size_down.set_tooltip(_('Smaller'))
self.font_size_down.connect('clicked', self.__font_sizes_cb, False)
self.insert(self.font_size_down, -1)
self.insert(gtk.SeparatorToolItem(), -1)
self.bold = ToolButton('bold-text')
self.bold.set_tooltip(_('Bold'))
self.bold.connect('clicked', self.__bold_cb)
self.insert(self.bold, -1)
self.italics = ToolButton('italics-text')
self.italics.set_tooltip(_('Italics'))
self.italics.connect('clicked', self.__italics_cb)
self.insert(self.italics, -1)
self.underline = ToolButton('underline-text')
self.underline.set_tooltip(_('Underline'))
self.underline.connect('clicked', self.__underline_cb)
self.insert(self.underline, -1)
foreground_color = ColorToolButton()
foreground_color.set_title(_('Set font color'))
foreground_color.connect('color-set', self.__foreground_color_cb)
self.insert(foreground_color, -1)
bakground_color = ColorToolButton()
bakground_color.set_title(_('Set background color'))
bakground_color.connect('color-set', self.__background_color_cb)
bakground_color.set_color(gtk.gdk.Color(65535, 65535, 65535))
self.insert(bakground_color, -1)
self.show_all()
def __font_selection_cb(self, widget):
if self._font_palette:
if not self._font_palette.is_up():
self._font_palette.popup(immediate=True,
state=self._font_palette.SECONDARY)
else:
self._font_palette.popdown(immediate=True)
return
def _init_font_list(self):
self._font_white_list = []
self._font_white_list.extend(DEFAULT_FONTS)
# check if there are a user configuration file
if not os.path.exists(USER_FONTS_FILE_PATH):
# verify if exists a file in /etc
if os.path.exists(GLOBAL_FONTS_FILE_PATH):
shutil.copy(GLOBAL_FONTS_FILE_PATH, USER_FONTS_FILE_PATH)
if os.path.exists(USER_FONTS_FILE_PATH):
# get the font names in the file to the white list
fonts_file = open(USER_FONTS_FILE_PATH)
# get the font names in the file to the white list
for line in fonts_file:
self._font_white_list.append(line.strip())
# monitor changes in the file
gio_fonts_file = gio.File(USER_FONTS_FILE_PATH)
self.monitor = gio_fonts_file.monitor_file()
self.monitor.set_rate_limit(5000)
self.monitor.connect('changed', self._reload_fonts)
def _reload_fonts(self, monitor, gio_file, other_file, event):
if event != gio.FILE_MONITOR_EVENT_CHANGES_DONE_HINT:
return
self._font_white_list = []
self._font_white_list.extend(DEFAULT_FONTS)
fonts_file = open(USER_FONTS_FILE_PATH)
for line in fonts_file:
self._font_white_list.append(line.strip())
# update the menu
for child in self._font_palette.menu.get_children():
self._font_palette.menu.remove(child)
child = None
context = self.get_pango_context()
tmp_list = []
for family in context.list_families():
name = family.get_name()
if name in self._font_white_list:
tmp_list.append(name)
for font in sorted(tmp_list):
menu_item = MyMenuItem(image=FontImage(font.replace(' ', '-')),
text_label=font)
menu_item.connect('activate', self.__font_selected_cb, font)
self._font_palette.menu.append(menu_item)
menu_item.show()
return False
def _setup_font_palette(self):
self._init_font_list()
context = self._main_area.pango_context
for family in context.list_families():
name = pango.FontDescription(family.get_name()).to_string()
if name not in self._font_list and \
name in self._font_white_list:
self._font_list.append(name)
self._font_palette = self.font_button.get_palette()
for font in sorted(self._font_list):
menu_item = MyMenuItem(image=FontImage(font.replace(' ', '-')),
text_label=font)
menu_item.connect('activate', self.__font_selected_cb, font)
self._font_palette.menu.append(menu_item)
menu_item.show()
def __font_selected_cb(self, widget, font_name):
if not hasattr(self._main_area, 'font_name'):
return
if len(self._main_area.selected) > 0:
font_size = self._main_area.font_size
else:
font_size = utils.default_font_size
self._main_area.set_font(font_name, font_size)
self._main_area.font_name = font_name
self._main_area.font_size = font_size
def __attribute_values(self):
attributes = {"bold": True, "italics": True, "underline": True,
"font": ""}
it = self._main_area.selected[0].attributes.get_iterator()
start_index = self._main_area.selected[0].index
end_index = self._main_area.selected[0].end_index
while(1):
found = False
r = it.range()
if start_index == end_index:
if r[0] <= start_index and r[1] > start_index:
found = True
elif start_index < end_index:
if r[0] > end_index:
break
if start_index == end_index and \
r[0] < start_index and \
r[1] > start_index:
found = True
elif start_index != end_index and r[0] <= start_index and \
r[1] >= end_index:
found = True
else:
if r[0] > start_index:
break
if start_index == end_index and \
r[0] < start_index and \
r[1] > start_index:
found = True
elif start_index != end_index and r[0] <= end_index and \
r[1] >= start_index:
found = True
if found:
attr = it.get_attrs()
for x in attr:
if x.type == pango.ATTR_WEIGHT and \
x.value == pango.WEIGHT_BOLD:
attributes["bold"] = False
elif x.type == pango.ATTR_STYLE and \
x.value == pango.STYLE_ITALIC:
attributes["italics"] = False
elif x.type == pango.ATTR_UNDERLINE and \
x.value == pango.UNDERLINE_SINGLE:
attributes["underline"] = False
elif x.type == pango.ATTR_FONT_DESC:
attributes["font"] = x.desc
if not it.next():
break
return attributes
def __font_sizes_cb(self, button, increase):
if not hasattr(self._main_area, 'font_size'):
return
if len(self._main_area.selected) < 1:
return
font_size = self._main_area.font_size
if font_size in self._font_sizes:
i = self._font_sizes.index(font_size)
if increase:
if i < len(self._font_sizes) - 2:
i += 1
else:
if i > 0:
i -= 1
else:
i = self._font_sizes.index(utils.default_font_size)
font_size = self._font_sizes[i]
self.size_label.set_text(str(font_size))
self.font_size_down.set_sensitive(i != 0)
self.font_size_up.set_sensitive(i < len(self._font_sizes) - 2)
self._main_area.set_font(self._main_area.font_name, font_size)
def __bold_cb(self, button):
if len(self._main_area.selected) < 1:
return
value = self.__attribute_values()["bold"]
self._main_area.set_bold(value)
def __italics_cb(self, button):
if len(self._main_area.selected) < 1:
return
value = self.__attribute_values()["italics"]
self._main_area.set_italics(value)
def __underline_cb(self, button):
if len(self._main_area.selected) < 1:
return
value = self.__attribute_values()["underline"]
self._main_area.set_underline(value)
def __foreground_color_cb(self, button):
color = button.get_color()
self._main_area.set_foreground_color(color)
def __background_color_cb(self, button):
color = button.get_color()
self._parent._main_area.set_background_color(color)
def change_active_font(self):
# TODO: update the toolbar
return
class EditToolbar(gtk.Toolbar):
def __init__(self, pc, toolbar_box):
gtk.Toolbar.__init__(self)
self._abiword_canvas = pc.abiword_canvas
copy = CopyButton()
copy.props.accelerator = '<Ctrl>C'
copy.connect('clicked', lambda button: pc.abiword_canvas.copy())
self.insert(copy, -1)
copy.show()
paste = PasteButton()
paste.props.accelerator = '<Ctrl>V'
paste.connect('clicked', lambda button: pc.abiword_canvas.paste())
self.insert(paste, -1)
paste.show()
separator = gtk.SeparatorToolItem()
self.insert(separator, -1)
separator.show()
undo = UndoButton(sensitive=False)
undo.connect('clicked', lambda button: pc.abiword_canvas.undo())
pc.abiword_canvas.connect(
"can-undo", lambda abi, can_undo: undo.set_sensitive(can_undo))
self.insert(undo, -1)
undo.show()
redo = RedoButton(sensitive=False)
redo.connect('clicked', lambda button: pc.abiword_canvas.redo())
pc.abiword_canvas.connect(
"can-redo", lambda abi, can_redo: redo.set_sensitive(can_redo))
self.insert(redo, -1)
redo.show()
pc.abiword_canvas.connect('text-selected',
lambda abi, b: copy.set_sensitive(True))
pc.abiword_canvas.connect('image-selected',
lambda abi, b: copy.set_sensitive(True))
pc.abiword_canvas.connect('selection-cleared',
lambda abi, b: copy.set_sensitive(False))
separator = gtk.SeparatorToolItem()
self.insert(separator, -1)
separator.show()
search_label = gtk.Label(_("Search") + ": ")
search_label.show()
search_item_page_label = gtk.ToolItem()
search_item_page_label.add(search_label)
self.insert(search_item_page_label, -1)
search_item_page_label.show()
# setup the search options
self._search_entry = iconentry.IconEntry()
self._search_entry.set_icon_from_name(iconentry.ICON_ENTRY_PRIMARY,
'system-search')
self._search_entry.connect('activate', self._search_entry_activated_cb)
self._search_entry.connect('changed', self._search_entry_changed_cb)
self._search_entry.add_clear_button()
self._add_widget(self._search_entry, expand=True)
self._findprev = ToolButton('go-previous-paired')
self._findprev.set_tooltip(_('Find previous'))
self.insert(self._findprev, -1)
self._findprev.show()
self._findprev.connect('clicked', self._findprev_cb)
self._findnext = ToolButton('go-next-paired')
self._findnext.set_tooltip(_('Find next'))
self.insert(self._findnext, -1)
self._findnext.show()
self._findnext.connect('clicked', self._findnext_cb)
# set the initial state of the search controls
# note: we won't simple call self._search_entry_changed_cb
# here, as that will call into the abiword_canvas, which
# is not mapped on screen here, causing the set_find_string
# call to fail
self._findprev.set_sensitive(False)
self._findnext.set_sensitive(False)
def _search_entry_activated_cb(self, entry):
logger.debug('_search_entry_activated_cb')
if not self._search_entry.props.text:
return
# find the next entry
self._abiword_canvas.find_next(False)
def _search_entry_changed_cb(self, entry):
logger.debug('_search_entry_changed_cb search for \'%s\'',
self._search_entry.props.text)
if not self._search_entry.props.text:
self._search_entry.activate()
# set the button contexts
self._findprev.set_sensitive(False)
self._findnext.set_sensitive(False)
return
self._abiword_canvas.set_find_string(self._search_entry.props.text)
# set the button contexts
self._findprev.set_sensitive(True)
self._findnext.set_sensitive(True)
# immediately start seaching
self._abiword_canvas.find_next(True)
def _findprev_cb(self, button):
logger.debug('_findprev_cb')
if self._search_entry.props.text:
self._abiword_canvas.find_prev()
else:
logger.debug('nothing to search for!')
def _findnext_cb(self, button):
logger.debug('_findnext_cb')
if self._search_entry.props.text:
self._abiword_canvas.find_next(False)
else:
logger.debug('nothing to search for!')
# bad foddex! this function was copied from sugar's activity.py
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()
class InsertToolbar(gtk.Toolbar):
def __init__(self, abiword_canvas):
gtk.Toolbar.__init__(self)
self._abiword_canvas = abiword_canvas
self._table = abiword.TableCreator()
self._table.set_labels(_('Table'), _('Cancel'))
self._table_id = self._table.connect('selected', self._table_cb)
image = gtk.Image()
image.set_from_icon_name('insert-table', -1)
self._table.set_image(image)
self._table.set_relief(gtk.RELIEF_NONE)
tool_item = gtk.ToolItem()
tool_item.add(self._table)
self.insert(tool_item, -1)
tool_item.show_all()
self._table_rows_after = ToolButton('row-insert')
self._table_rows_after.set_tooltip(_('Insert Row'))
self._table_rows_after_id = self._table_rows_after.connect( \
'clicked', self._table_rows_after_cb)
self.insert(self._table_rows_after, -1)
self._table_delete_rows = ToolButton('row-remove')
self._table_delete_rows.set_tooltip(_('Delete Row'))
self._table_delete_rows_id = self._table_delete_rows.connect( \
'clicked', self._table_delete_rows_cb)
self.insert(self._table_delete_rows, -1)
self._table_cols_after = ToolButton('column-insert')
self._table_cols_after.set_tooltip(_('Insert Column'))
self._table_cols_after_id = self._table_cols_after.connect( \
'clicked', self._table_cols_after_cb)
self.insert(self._table_cols_after, -1)
self._table_delete_cols = ToolButton('column-remove')
self._table_delete_cols.set_tooltip(_('Delete Column'))
self._table_delete_cols_id = self._table_delete_cols.connect( \
'clicked', self._table_delete_cols_cb)
self.insert(self._table_delete_cols, -1)
separator = gtk.SeparatorToolItem()
self.insert(separator, -1)
image = ToolButton('insert-picture')
image.set_tooltip(_('Insert Image'))
self._image_id = image.connect('clicked', self._image_cb)
self.insert(image, -1)
self.show_all()
self._abiword_canvas.connect('table-state', self._isTable_cb)
#self._abiword_canvas.connect('image-selected', self._image_selected_cb)
def _image_cb(self, button):
def cb(object):
logging.debug('ObjectChooser: %r' % object)
self._abiword_canvas.insert_image(object.file_path, True)
chooser.pick(what=chooser.IMAGE, cb=cb)
def _table_cb(self, abi, rows, cols):
self._abiword_canvas.insert_table(rows, cols)
def _table_rows_after_cb(self, button):
self._abiword_canvas.invoke_cmd('insertRowsAfter', '', 0, 0)
def _table_delete_rows_cb(self, button):
self._abiword_canvas.invoke_cmd('deleteRows', '', 0, 0)
def _table_cols_after_cb(self, button):
self._abiword_canvas.invoke_cmd('insertColsAfter', '', 0, 0)
def _table_delete_cols_cb(self, button):
self._abiword_canvas.invoke_cmd('deleteColumns', '', 0, 0)
def _isTable_cb(self, abi, b):
self._table_rows_after.set_sensitive(b)
self._table_delete_rows.set_sensitive(b)
self._table_cols_after.set_sensitive(b)
self._table_delete_cols.set_sensitive(b)
class HomeWorkViewer(activity.Activity):
def __init__(self, handle):
"""Set up the HelloWorld activity."""
activity.Activity.__init__(self, handle)
self._logger = logging.getLogger('home-work-viewer')
self._logger.setLevel(logging.DEBUG)
self._logger.debug("Inside to __init__ of HomeWorkViewer")
ts = time.time()
self._logger.debug(ts)
#self._logger.debug( datetime.datetime.fromtimestamp(ts).strftime('%Y-%m-%d %H:%M:%S'))
'''Obtenemos el JSON de la Actividad'''
json_data=open('json.txt')
self.activity = json.load(json_data, object_hook=lambda d: namedtuple('Activity', d.keys())(*d.values()))
json_data.close()
# 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 = ActivityButton(self)
toolbar_box.toolbar.insert(activity_button, 0)
activity_button.show()
title_entry = TitleEntry(self)
toolbar_box.toolbar.insert(title_entry, 1)
title_entry.show()
separator = gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
toolbar_box.toolbar.insert(separator, -1)
separator.show()
self.buttonBefore = ToolButton('go-previous')
self.buttonBefore.set_tooltip(_('Back'))
self.buttonBefore.connect("clicked", self.backButtonCallBack)
toolbar_box.toolbar.insert(self.buttonBefore, 2)
self.buttonBefore.show()
self.buttonNext = ToolButton('go-next')
self.buttonNext.set_tooltip(_('Next'))
self.buttonNext.connect("clicked", self.nextButtonCallBack)
toolbar_box.toolbar.insert(self.buttonNext, 3)
self.buttonNext.show()
stop_button = StopButton(self)
toolbar_box.toolbar.insert(stop_button, -1)
stop_button.show()
self.set_toolbar_box(toolbar_box)
toolbar_box.show()
self.vBoxMain = gtk.VBox(True, 2)
self.vBoxMain.show()
self.set_canvas(self.vBoxMain)
self.jsonState = None
self.createWindowExercises()
"""Leave this line always in the last"""
#self.show_all()
def exerciseCompletedCallBack(self):
if self.amountExercises > self.exercisesMatches:
self.exercisesMatches = self.exercisesMatches + 1
self.modalDoneWindow = ModalWindowDone(self)
self.modalDoneWindow.show()
self.freezeExerciseWindow()
def manageBackNextButtons(self):
self.getLogger().debug("Inside to manageBackNextButtons")
self.getLogger().debug(self.currentIndexExercise)
self.getLogger().debug(self.amountExercises)
if self.currentIndexExercise == 0:
self.buttonBefore.set_sensitive(False)
if self.amountExercises != 1:
self.buttonNext.set_sensitive(True)
else:
self.buttonNext.set_sensitive(False)
elif self.currentIndexExercise > 0 and self.currentIndexExercise < (self.amountExercises-1):
self.buttonBefore.set_sensitive(True)
self.buttonNext.set_sensitive(True)
else:
self.buttonBefore.set_sensitive(True)
self.buttonNext.set_sensitive(False)
def nextButtonCallBack(self, button, *args):
self.vBoxMain.get_children()[self.currentIndexExercise].hide()
self.currentIndexExercise = self.currentIndexExercise + 1
self.vBoxMain.get_children()[self.currentIndexExercise].show_all()
self.manageBackNextButtons()
def backButtonCallBack(self, button, *args):
self.vBoxMain.get_children()[self.currentIndexExercise].hide()
self.currentIndexExercise = self.currentIndexExercise - 1
self.vBoxMain.get_children()[self.currentIndexExercise].show_all()
self.manageBackNextButtons()
def createWindowExercises(self):
self._logger.debug("inside to createWindowExercises")
ts = time.time()
self._logger.debug(ts)
self.amountExercises = len(self.activity.exercises)
self.currentIndexExercise = 0
self.exercisesMatches = 0
self.clearBox()
index = 0
while index < self.amountExercises:
newExercise = None
newWindowExercise = None
stateExercise = None
if self.jsonState is not None:
stateExercise = self.jsonState['exercises'][index]
if self.activity.exercises[index].codeType == 1:
newExercise = SimpleAssociation()
newWindowExercise = newExercise.getWindow(self.activity.exercises[index], self, stateExercise)
elif self.activity.exercises[index].codeType == 2:
newExercise = FindTheDifferent()
newWindowExercise = newExercise.getWindow(self.activity.exercises[index] ,self, stateExercise)
elif self.activity.exercises[index].codeType == 3:
newExercise = SearchTheSame()
newWindowExercise = newExercise.getWindow(self.activity.exercises[index] ,self, stateExercise)
#newWindowExercise.hide()
self.vBoxMain.pack_start(newWindowExercise, True, True, 0)
index = index + 1
if self.jsonState is None:
self.vBoxMain.get_children()[self.currentIndexExercise].show_all()
self.getLogger().debug("Inside to if: self.jsonState is None")
else:
self.exercisesMatches = self.jsonState['exercisesMatches']
self.moveToExerciseIndex(self.jsonState['currentIndexExercise'])
self.manageBackNextButtons()
def clearBox(self):
allExercisesWindows = self.vBoxMain.get_children()
for exerciseWindow in allExercisesWindows:
exerciseWindow.hide()
self.vBoxMain.remove(exerciseWindow)
def read_file(self, tmp_file):
self.getLogger().debug("Inside to read_file()")
ts = time.time()
self._logger.debug(ts)
with open(tmp_file, 'r') as stateFile:
fileJsonState = json.load(stateFile)
if fileJsonState is not None:
self.jsonState = fileJsonState
stateFile.close()
self.createWindowExercises()
def write_file(self, tmp_file):
self.getLogger().debug("Inside to write_file")
self.saveActivityState(tmp_file)
def getLogger(self):
return self._logger
def saveActivityState(self, filePath):
self.getLogger().debug("inside to saveActivityState")
allExerciseWindows = self.vBoxMain.get_children()
theJson = {}
theJson["name"] = "JSON de prueba"
theJson['currentIndexExercise'] = self.currentIndexExercise
theJson['exercisesMatches'] = self.exercisesMatches
theJson["exercises"] = []
itemsToCopy = []
activityName = self.metadata.get('title')
metadataKeys = self.metadata.keys()
#self.getLogger().debug(metadataKeys)
#for key in metadataKeys:
#self.getLogger().debug(key)
#self.getLogger().debug(self.metadata.get(key))
for index, exerciseWindow in enumerate( allExerciseWindows ):
exerciseJson = exerciseWindow.exerciseInstance.saveExerciseState()
theJson['exercises'].append(exerciseJson)
self.getLogger().debug(theJson)
with open( filePath, 'w+') as stateFile:
json.dump(theJson,stateFile )
stateFile.close()
def freezeExerciseWindow(self):
currentWindowsExercise = self.vBoxMain.get_children()[self.currentIndexExercise]
currentWindowsExercise.exerciseInstance.disconnectEventBoxs()
def moveToExerciseIndex(self, indexExercise):
self.getLogger().debug("Inside to moveToExerciseIndex")
vBoxMain = self.vBoxMain
allWindowsExercises = vBoxMain.get_children()
for index, windowExercise in enumerate(allWindowsExercises):
self.getLogger().debug(index)
self.getLogger().debug(indexExercise)
if index != indexExercise:
windowExercise.hide()
else:
windowExercise.show_all()
self.currentIndexExercise = indexExercise
self.manageBackNextButtons()
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 Activity(sugar.activity.activity.Activity):
def __init__(self, handle):
super(Activity, self).__init__(handle)
self.paused = False
watch = gtk.gdk.Cursor(gtk.gdk.WATCH)
self.window.set_cursor(watch)
self.p = gtk.VPaned()
self.p.connect("notify::position", self.redraw)
self.box = gtk.Notebook()
self.p.pack2(self.box)
self.p.show()
self.box.set_show_tabs(False)
self.splash = gtk.Image()
pixbuf = gtk.gdk.pixbuf_new_from_file("images/splash-colgadito.png")
screen = self.window.get_screen()
width, height = screen.get_width(), screen.get_height() - style.GRID_CELL_SIZE
pixbuf = pixbuf.scale_simple(width, height, gtk.gdk.INTERP_BILINEAR)
self.splash.set_from_pixbuf(pixbuf)
self.splash.show()
eb = gtk.EventBox()
eb.add(self.splash)
eb.modify_bg(gtk.STATE_NORMAL, gtk.gdk.color_parse("white"))
eb.show()
self.box.append_page(eb, gtk.Label("Inicio"))
self._pygamecanvas = sugargame2.canvas.PygameCanvas(self)
self._pygamecanvas.set_flags(gtk.EXPAND)
self._pygamecanvas.set_flags(gtk.FILL)
self.connect("visibility-notify-event", self.redraw)
self._pygamecanvas.set_events(gtk.gdk.BUTTON_PRESS_MASK)
self._pygamecanvas.connect("button-press-event", self._pygamecanvas.grab_focus)
self.box.append_page(self._pygamecanvas, gtk.Label("Juego"))
self.box.show()
self.set_canvas(self.p)
gobject.timeout_add(300, self.pump)
gobject.timeout_add(2000, self.init_interpreter)
#gobject.timeout_add(1000, self.build_editor)
gobject.timeout_add(1500, self.check_modified)
self.build_toolbar()
self.credits = None
self.editor = None
self._pygamecanvas.run_pygame(self.run_game)
def redraw(self, widget=None, b=None, c=None):
scene = spyral.director.get_scene()
if scene:
scene.redraw()
def alert(self, title=None, text=None, delay=5):
alert = NotifyAlert(delay)
alert.props.title = title
alert.props.msg = text
print text
self.add_alert(alert)
alert.connect('response', self._alert_ok)
alert.show()
def _alert_ok(self, alert, *args):
self.remove_alert(alert)
def check_modified(self):
if self.box.current_page()==2:
if not self.save_button.get_sensitive():
if self.editor.modificado():
self.save_button.set_sensitive(True)
return False
return True
def pump(self):
# Esto es necesario porque sino pygame acumula demasiados eventos.
pygame.event.pump()
def focus_interpreter(self, widget, event):
self._interpreter.text.grab_focus()
return True
def init_interpreter(self):
# diferido unos segundos para evitar ver errores superfluos al iniciar
self._interpreter = GTKInterpreterConsole(self.redraw)
self._interpreter.text.connect('button-press-event', self.focus_interpreter)
self.p.pack1(self._interpreter)
return False
def open_file(self, widget, path):
if path:
if not os.path.isdir(path):
self.editor.open_file(widget, path)
def save_file(self, widget):
if self.editor.modificado():
self.save_button.set_sensitive(False)
self.editor.save_file()
filename = self.editor.current_file()
self.alert(filename, "Archivo guardado.")
gobject.timeout_add(1500, self.check_modified)
def build_editor(self):
dir_real = os.getcwd()
f = os.path.realpath(JUEGO.__file__)
f = "." + f.replace(dir_real ,"") # todo esto para obtener una ruta relativa
f = f.rstrip("c") # en caso que sea .pyc compilado
self.h = gtk.HPaned()
self.tree = FileViewer(".", os.path.basename(f))
self.tree.connect("file-selected", self.open_file)
self.tree.show()
self.h.pack1(self.tree)
self.box.append_page(self.h, gtk.Label("Editor"))
if False: #os.path.isfile("/usr/bin/gvim"):
# Si podemos, lo hacemos
self.socket = gtk.Socket()
self.socket.show()
self.h.pack2(self.socket)
sock_id = str(self.socket.get_id())
self.editor = VimSourceView(sock_id)
if not self.editor.bufInfo.bufferList:
f = JUEGO.__file__
if f.endswith("pyc"):
f = f[:-1]
self.open_file(None, f)
else:
self.editor = SourceView()
scroller = gtk.ScrolledWindow()
scroller.set_policy(gtk.POLICY_AUTOMATIC,
gtk.POLICY_AUTOMATIC)
scroller.add(self.editor)
scroller.show()
self.h.pack2(scroller)
self.editor.show()
self.h.show()
self.open_file(None, f)
def build_toolbar(self):
toolbar_box = ToolbarBox()
self.set_toolbar_box(toolbar_box)
toolbar_box.show()
activity_button = ActivityToolbarButton(self)
toolbar_box.toolbar.insert(activity_button, -1)
activity_button.show()
tool_group = None
self.game_button = RadioToolButton()
self.game_button.props.icon_name = 'gamecanvas'
self.game_button.set_tooltip(_('Juego'))
self.game_button.accelerator = "<Ctrl>1"
self.game_button.props.group = tool_group
self.game_button.connect('clicked', self.show_game)
toolbar_box.toolbar.insert(self.game_button, -1)
self.game_button.show()
tool_group = self.game_button
button = RadioToolButton()
button.props.icon_name = 'view-source'
button.set_tooltip(_('Editor'))
button.accelerator = "<Ctrl>2"
button.props.group = tool_group
button.connect('clicked', self.show_editor)
toolbar_box.toolbar.insert(button, -1)
button.show()
self.save_button = ToolButton('dialog-ok')
self.save_button.set_tooltip(_('Guardar'))
self.save_button.accelerator = "<Ctrl>s"
self.save_button.connect('clicked', self.save_file)
self.save_button.set_sensitive(False)
toolbar_box.toolbar.insert(self.save_button, -1)
self.save_button.show()
separator = gtk.SeparatorToolItem()
toolbar_box.toolbar.insert(separator, -1)
separator.show()
button = ToolButton('system-restart')
button.set_tooltip(_('Reiniciar juego'))
button.accelerator = "<Alt><Shift>r"
button.connect('clicked', self.restart_game)
toolbar_box.toolbar.insert(button, -1)
button.show()
self.editor_button = ToolButton('sources')
self.editor_button.set_tooltip(_('Consola'))
self.editor_button.accelerator = "<Ctrl>grave"
self.editor_button.connect('clicked', self.toggle_console)
toolbar_box.toolbar.insert(self.editor_button, -1)
self.editor_button.show()
separator = gtk.SeparatorToolItem()
toolbar_box.toolbar.insert(separator, -1)
separator.show()
button = helpbutton.HelpButton(self)
toolbar_box.toolbar.insert(button, -1)
button.show()
button = ToolButton()
button.props.icon_name = 'activity-about'
button.set_tooltip(_('Acerca de'))
button.accelerator = "<Ctrl>i"
button.connect('clicked', self.run_credits)
toolbar_box.toolbar.insert(button, -1)
button.show()
# Blank space (separator) and Stop button at the end:
separator = gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
toolbar_box.toolbar.insert(separator, -1)
separator.show()
stop_button = StopButton(self)
toolbar_box.toolbar.insert(stop_button, -1)
stop_button.show()
def run_game(self):
spyral.director.init((0,0), fullscreen=False, max_fps=30)
self.game = JUEGO.Game(activity=self)
self.box.connect("switch-page", self.redraw)
spyral.director.push(self.game)
self.start()
def run_credits(self, widget):
if not (spyral.director.get_scene()==self.credits):
self.credits = game.credits.Creditos(self.game.size)
spyral.director.push(self.credits)
def start(self):
#try:
spyral.director.run(sugar = True)
#except AttributeError as detail:
# detail2 = traceback.format_exc()
# self.box.set_page(0)
# self.alert( detail2, "Spyral se ha detenido abruptamente.", 60)
def show_game(self, widget):
self.box.set_page(1)
self.redraw()
def show_editor(self, widget):
if not self.editor:
self.build_editor()
self.box.set_page(2)
self.redraw()
def restart_game(self, widget):
global JUEGO
import objetos
try:
objetos.reset()
except AttributeError:
pass
self.show_game(None)
watch = gtk.gdk.Cursor(gtk.gdk.WATCH)
self.window.set_cursor(watch)
JUEGO = reload(JUEGO)
self.game = JUEGO.Game(activity=self)
spyral.director.replace(self.game)
self.start()
def game_ready(self, widget = None):
self.game_button.set_active(True)
self.box.set_page(1)
self._pygamecanvas.grab_focus()
self.window.set_cursor(None)
def read_file(self, file_path):
pass
def write_file(self, file_path):
pass
def can_close(self):
if self.editor:
self.editor.close()
self.box.set_page(0)
try:
spyral.director.quit()
except spyral.exceptions.GameEndException:
pass
finally:
return True
def toggle_console(self, e):
if self._interpreter.props.visible:
self._interpreter.hide()
self._pygamecanvas.grab_focus()
else:
self.p.set_position(160)
self._interpreter.show()
self._interpreter.text.grab_focus()
self.redraw()
def animate_console(self):
easing = spyral.easing.Linear(0,160)
self.p.set_position(0)
class 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 NavToolBar(gtk.Toolbar):
def __init__(self, activity, shared, deck):
gtk.Toolbar.__init__(self)
self.__deck = deck
self.__activity = activity
self.__shared = shared
self.__logger = logging.getLogger('Navigation Toolbar')
self.__is_initiating = True
self.__prevbtn = ToolButton('go-previous')
self.__prevbtn.set_tooltip("Previous slide")
self.__prevbtn.connect('clicked', self.previous)
self.insert(self.__prevbtn, -1)
self.__prevbtn.show()
self.__nextbtn = ToolButton('go-next')
self.__nextbtn.set_tooltip("Next slide")
self.__nextbtn.connect('clicked', self.next)
self.insert(self.__nextbtn, -1)
self.__nextbtn.show()
# page number widget and navigation
self.__num_page_item = gtk.ToolItem()
self.__num_current_page = 1
self.__num_page_entry = gtk.Entry()
self.__num_page_entry.set_text(str(self.__num_current_page))
self.__num_page_entry.set_alignment(1)
self.__num_page_entry.connect('activate', self.num_page_activate)
self.__num_page_entry.set_width_chars(4)
self.__num_page_item.add(self.__num_page_entry)
self.__num_page_entry.show()
self.insert(self.__num_page_item, -1)
self.__num_page_item.show()
# total page number widget
self.__total_page_item = gtk.ToolItem()
self.__total_page_label = gtk.Label()
label_attributes = pango.AttrList()
label_attributes.insert(pango.AttrSize(14000, 0, -1))
label_attributes.insert(pango.AttrForeground(65535, 65535, 65535, 0, -1))
self.__total_page_label.set_attributes(label_attributes)
self.__total_page_label.set_text(' / ' + str(self.__deck.getSlideCount()))
self.__total_page_item.add(self.__total_page_label)
self.__total_page_label.show()
self.insert(self.__total_page_item, -1)
self.__total_page_item.show()
# separator between navigation buttons and lock button
separator = gtk.SeparatorToolItem()
separator.set_draw(False)
separator.set_expand(True)
self.insert(separator, -1)
separator.show()
# unlocked button
self.__unlockBtn = ToolButton('unlocked')
self.__unlockBtn.set_tooltip("Student Navigation Unlocked")
# navigation is unlocked by default, so insert the unlock button
self.insert(self.__unlockBtn, 5)
self.__unlockBtn.show()
# locked button
self.__lockBtn = ToolButton('locked')
self.__lockBtn.set_tooltip("Student Navigation Locked")
self.__logger.debug("Connecting to navigation locking and activity sharing signals.")
self.__activity.connect('shared', self.activity_shared_cb)
self.__activity.connect('joined', self.activity_joined_cb)
self.__shared.connect('navigation-lock-change', self.set_lock_button)
# triggers for when slides are changed
self.__deck.connect("slide-changed", self.slide_changed)
self.__deck.connect("deck-changed", self.slide_changed)
self.slide_changed(self.__deck)
self.show()
def activity_shared_cb(self, widget):
#Callback for when the activity is shared
# bind the lock button click with switching lock mode
self.__lockBtn.connect('clicked', self.__shared.lock_mode_switch)
self.__unlockBtn.connect('clicked', self.__shared.lock_mode_switch)
def activity_joined_cb(self, widget):
""" Callback for when the activity is joined """
self.__is_initiating = False
def set_lock_button(self, widget, is_locked):
self.__logger.debug("Changing lock button, lock mode %u, init %u",
is_locked, self.__is_initiating)
if is_locked:
new_button = self.__lockBtn
if not self.__is_initiating:
self.__prevbtn.set_sensitive(False)
self.__nextbtn.set_sensitive(False)
else:
new_button = self.__unlockBtn
if not self.__is_initiating:
self.__prevbtn.set_sensitive(True)
self.__nextbtn.set_sensitive(True)
old = self.get_nth_item(5)
self.remove(old)
self.insert(new_button, 5)
new_button.show()
self.queue_draw()
def next(self, widget):
self.__deck.next()
def previous(self, widget):
self.__deck.previous()
def slide_changed(self, widget):
self.__logger.debug("Changing slides!")
if self.__deck.isAtBeginning():
self.__prevbtn.set_sensitive(False)
else:
self.__prevbtn.set_sensitive(True)
if self.__deck.isAtEnd():
self.__nextbtn.set_sensitive(False)
else:
self.__nextbtn.set_sensitive(True)
self.__num_current_page = self.__deck.getIndex()
self.__num_page_entry.set_text(str(self.__num_current_page + 1))
self.__total_page_label.set_text(' / ' + str(self.__deck.getSlideCount()))
def num_page_activate(self, entry):
page_entered = int(entry.get_text())
if page_entered < 1:
page_entered = 1
elif self.__deck.getSlideCount() < page_entered:
page_entered = self.__deck.getSlideCount()
self.__deck.goToIndex(page_entered - 1, is_local=True)
class RecordControl():
def __init__(self, toolbar):
self._timer_value = TIMER_VALUES[0]
self._timer_button = ToolButton('timer-0')
self._timer_button.set_tooltip(_('Select timer'))
self._timer_button.connect('clicked', self._timer_selection_cb)
toolbar.insert(self._timer_button, -1)
self._setup_timer_palette()
self._duration_value = DURATION_VALUES[0]
self._duration_button = ToolButton('duration-2')
self._duration_button.set_tooltip(_('Select duration'))
self._duration_button.connect('clicked', self._duration_selection_cb)
toolbar.insert(self._duration_button, -1)
self._setup_duration_palette()
self._quality_value = 0
self._quality_button = ToolButton('low-quality')
self._quality_button.set_tooltip(_('Select quality'))
self._quality_button.connect('clicked', self._quality_selection_cb)
toolbar.insert(self._quality_button, -1)
self._setup_quality_palette()
def _timer_selection_cb(self, widget):
if self._timer_palette:
if not self._timer_palette.is_up():
self._timer_palette.popup(immediate=True,
state=self._timer_palette.SECONDARY)
else:
self._timer_palette.popdown(immediate=True)
return
def _setup_timer_palette(self):
self._timer_palette = self._timer_button.get_palette()
for seconds in TIMER_VALUES:
if seconds == 0:
text = _('Immediate')
else:
text = ngettext('%s second', '%s seconds', seconds) % seconds
menu_item = MenuItem(icon_name='timer-%d' % (seconds),
text_label=text)
menu_item.connect('activate', self._timer_selected_cb, seconds)
self._timer_palette.menu.append(menu_item)
menu_item.show()
def _timer_selected_cb(self, button, seconds):
self.set_timer_idx(TIMER_VALUES.index(seconds))
def _duration_selection_cb(self, widget):
if self._duration_palette:
if not self._duration_palette.is_up():
self._duration_palette.popup(
immediate=True, state=self._duration_palette.SECONDARY)
else:
self._duration_palette.popdown(immediate=True)
return
def _setup_duration_palette(self):
self._duration_palette = self._duration_button.get_palette()
for minutes in DURATION_VALUES:
if minutes == 0:
text = gtk.Label(_('Immediate'))
else:
text = ngettext('%s minute', '%s minutes', minutes) % minutes
menu_item = MenuItem(icon_name='duration-%d' % (minutes),
text_label=text)
menu_item.connect('activate', self._duration_selected_cb, minutes)
self._duration_palette.menu.append(menu_item)
menu_item.show()
def _duration_selected_cb(self, button, minutes):
self.set_duration_idx(DURATION_VALUES.index(minutes))
def _quality_selection_cb(self, widget):
if self._quality_palette:
if not self._quality_palette.is_up():
self._quality_palette.popup(
immediate=True, state=self._quality_palette.SECONDARY)
else:
self._quality_palette.popdown(immediate=True)
return
def _setup_quality_palette(self):
self._quality_palette = self._quality_button.get_palette()
for quality in QUALITY_VALUES:
text = _('%s quality') % (quality)
menu_item = MenuItem(icon_name=quality + '-quality',
text_label=text)
menu_item.connect('activate', self._quality_selected_cb, quality)
self._quality_palette.menu.append(menu_item)
menu_item.show()
def _quality_selected_cb(self, button, quality):
self.set_quality(QUALITY_VALUES.index(quality))
def set_mode(self, mode):
if mode == constants.MODE_PHOTO:
self._quality_button.set_sensitive(False)
self._timer_button.set_sensitive(True)
self._duration_button.set_sensitive(False)
if mode == constants.MODE_VIDEO:
self._quality_button.set_sensitive(True)
self._timer_button.set_sensitive(True)
self._duration_button.set_sensitive(True)
if mode == constants.MODE_AUDIO:
self._quality_button.set_sensitive(False)
self._timer_button.set_sensitive(True)
self._duration_button.set_sensitive(True)
def get_timer(self):
return self._timer_value
def get_timer_idx(self):
if self._timer_value in TIMER_VALUES:
return TIMER_VALUES.index(self._timer_value)
else:
return TIMER_VALUES[0]
def set_timer_idx(self, idx):
self._timer_value = TIMER_VALUES[idx]
if hasattr(self, '_timer_button'):
self._timer_button.set_icon('timer-%d' % (self._timer_value))
def get_duration(self):
return self._duration_value
def get_duration_idx(self):
if self._duration_value in DURATION_VALUES:
return DURATION_VALUES.index(self._duration_value)
else:
return DURATION_VALUES[0]
def set_duration_idx(self, idx):
self._duration_value = DURATION_VALUES[idx]
if hasattr(self, '_duration_button'):
self._duration_button.set_icon('duration-%d' %
(self._duration_value))
def get_quality(self):
return self._quality_value
def set_quality(self, idx):
self._quality_value = idx
if hasattr(self, '_quality_button'):
self._quality_button.set_icon('%s-quality' % (QUALITY_VALUES[idx]))
class SwiftFeetActivity(activity.Activity):
def __init__(self, handle):
activity.Activity.__init__(self, handle)
self._current_video_idx = None
self.max_participants = 1
# Set blackground as black
self.modify_bg(gtk.STATE_NORMAL, gtk.gdk.color_parse("#000000"))
if hasattr(self, '_event_box'):
# for pre-0.96
self._event_box.modify_bg(gtk.STATE_NORMAL,
gtk.gdk.color_parse("#000000"))
toolbar_box = ToolbarBox()
activity_button = ActivityToolbarButton(self)
toolbar_box.toolbar.insert(activity_button, 0)
activity_button.show()
self._exercise_button = ToolButton('fitness')
self._exercise_button.set_tooltip(_("Excercises"))
self._exercise_button.connect('clicked', self._index_clicked)
self._exercise_button.set_sensitive(False)
self._exercise_button.show()
toolbar_box.toolbar.insert(self._exercise_button, -1)
self._dance_button = ToolButton('dancer')
self._dance_button.set_tooltip(_("Dances"))
self._dance_button.connect('clicked', self._index_clicked)
self._dance_button.show()
toolbar_box.toolbar.insert(self._dance_button, -1)
separator = gtk.SeparatorToolItem()
toolbar_box.toolbar.insert(separator, -1)
separator.show()
self._prev_button = ToolButton('go-left')
self._prev_button.set_tooltip(_("Previous exercise"))
self._prev_button.connect('clicked', self._prev_clicked)
self._prev_button.set_sensitive(False)
self._prev_button.show()
toolbar_box.toolbar.insert(self._prev_button, -1)
self._next_button = ToolButton('go-right')
self._next_button.set_tooltip(_("Next exercise"))
self._next_button.connect('clicked', self._next_clicked)
self._next_button.set_sensitive(False)
self._next_button.show()
toolbar_box.toolbar.insert(self._next_button, -1)
separator = gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
separator.show()
toolbar_box.toolbar.insert(separator, -1)
tool = StopButton(self)
toolbar_box.toolbar.insert(tool, -1)
tool.show()
self.set_toolbox(toolbar_box)
toolbar_box.show()
vbox = PaddedVBox()
vbox.show()
self.set_canvas(vbox)
self._menu = gtk.Table(4, 5, True)
self._menu.set_row_spacings(10)
self._menu.set_col_spacings(10)
vbox.pack_start(self._menu, expand=True, fill=True)
self._menu.show()
self._videos = EXERCISES
self._generate_menu()
self._video_title = gtk.Label()
self._video_title.modify_fg(gtk.STATE_NORMAL,
gtk.gdk.color_parse("#FFFFFF"))
vbox.pack_start(self._video_title, expand=False)
self._video = VideoPlayer()
vbox.pack_start(self._video, expand=True, fill=True, padding=10)
self._video.realize()
self._video_description = gtk.Label()
self._video_description.set_line_wrap(True)
self._video_description.modify_fg(gtk.STATE_NORMAL,
gtk.gdk.color_parse("#FFFFFF"))
vbox.pack_start(self._video_description, expand=False)
# Try to fix description height to 3 lines so that it doesn't shift size while
# changing videos.
self._video_description.set_text("\n\n\n")
size_req = self._video_description.size_request()
self._video_description.set_size_request(-1, size_req[1])
def _generate_menu(self):
for child in self._menu.get_children():
self._menu.remove(child)
for (i, video) in enumerate(self._videos):
path = os.path.join(activity.get_bundle_path(), "thumbnails",
video[0] + ".png")
button = VideoButton(video[1], path)
button.connect('button_press_event', self.__menu_item_clicked, i)
col = i % 5
row = i / 5
self._menu.attach(button, col, col + 1, row, row + 1)
button.show_all()
def _play_video(self, idx):
video = self._videos[idx]
self._menu.hide()
self._video.show()
self._video.stop()
self._video_title.set_markup('<span size="x-large" weight="bold">' +
glib.markup_escape_text(video[1]) +
'</span>')
self._video_title.show()
if len(video) > 2:
self._video_description.set_text(video[2].strip())
else:
self._video_description.set_text('')
self._video_description.show()
if len(video) > 3:
music_name = video[3]
else:
music_name = None
self._video.play(video[0], music_name)
self._current_video_idx = idx
self._dance_button.set_sensitive(True)
self._exercise_button.set_sensitive(True)
self._prev_button.set_sensitive(idx != 0)
self._next_button.set_sensitive(idx != (len(self._videos) - 1))
def _index_clicked(self, widget):
self._video.stop()
self._video.hide()
self._next_button.set_sensitive(False)
self._prev_button.set_sensitive(False)
self._video_title.hide()
self._video_description.hide()
if widget == self._exercise_button:
self._videos = EXERCISES
else:
self._videos = DANCES
self._generate_menu()
self._menu.show()
self._exercise_button.set_sensitive(widget == self._dance_button)
self._dance_button.set_sensitive(widget == self._exercise_button)
def _next_clicked(self, widget):
self._play_video(self._current_video_idx + 1)
def _prev_clicked(self, widget):
self._play_video(self._current_video_idx - 1)
def __menu_item_clicked(self, widget, event, idx):
logging.warning("CLICKED")
self._play_video(idx)
class Item(gobject.GObject):
__gsignals__ = {
'activate': (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE, tuple())
}
toolitem = None
def __init__(self, stock_id=gtk.STOCK_CLEAR, important=False):
gobject.GObject.__init__(self)
self._stock_id = stock_id
self.accel_group = None
self.important = important
self.connection = None
self.connection_data = None
self.tooltip = None
def set_stock_id(self, stock_id):
self._stock_id = stock_id
def get_stock_id(self):
return self._stock_id
stock_id = property(get_stock_id, set_stock_id)
def get_menu_item(self):
return None
def activate_cb(self, widget):
self.emit('activate')
def setup_accelerator(self):
accelerator = stock.get_accelerator(self._stock_id)
logger.debug(str(accelerator))
try:
if accelerator[1] > 0:
self.toolitem.props.accelerator = gtk.accelerator_name(
accelerator[1], accelerator[0])
except:
logger.error(
'Could not set up accelerator; if toogletoolbutton, update your sugar version'
)
def get_tool_item(self):
if self._stock_id in stock.icons:
icon_name = stock.icons[self._stock_id]
else:
icon_name = self._stock_id
sensitive = self.sensitive
self.toolitem = ToolButton(icon_name)
self.toolitem.connect('clicked', self.activate_cb)
self.setup_tooltip()
self.toolitem.set_sensitive(sensitive)
return self.toolitem
def setup_tooltip(self):
if self.tooltip:
self.toolitem.set_tooltip(self.tooltip)
else:
text = gtk.stock_lookup(self._stock_id)[1]
self.toolitem.set_tooltip(text.replace('_', ''))
self.setup_accelerator()
def set_sensitive(self, setting):
if self.toolitem:
self.toolitem.set_sensitive(setting)
def get_sensitive(self):
if self.toolitem:
return self.toolitem.get_sensitive()
else:
return True
sensitive = property(get_sensitive, set_sensitive)
class InsertToolbar(gtk.Toolbar):
def __init__(self, abiword_canvas):
gtk.Toolbar.__init__(self)
self._abiword_canvas = abiword_canvas
self._table = abiword.TableCreator()
self._table.set_labels(_('Table'), _('Cancel'))
self._table_id = self._table.connect('selected', self._table_cb)
image = gtk.Image()
image.set_from_icon_name('insert-table', -1)
self._table.set_image(image)
self._table.set_relief(gtk.RELIEF_NONE)
tool_item = gtk.ToolItem()
tool_item.add(self._table)
self.insert(tool_item, -1)
tool_item.show_all()
self._table_rows_after = ToolButton('row-insert')
self._table_rows_after.set_tooltip(_('Insert Row'))
self._table_rows_after_id = self._table_rows_after.connect( \
'clicked', self._table_rows_after_cb)
self.insert(self._table_rows_after, -1)
self._table_delete_rows = ToolButton('row-remove')
self._table_delete_rows.set_tooltip(_('Delete Row'))
self._table_delete_rows_id = self._table_delete_rows.connect( \
'clicked', self._table_delete_rows_cb)
self.insert(self._table_delete_rows, -1)
self._table_cols_after = ToolButton('column-insert')
self._table_cols_after.set_tooltip(_('Insert Column'))
self._table_cols_after_id = self._table_cols_after.connect( \
'clicked', self._table_cols_after_cb)
self.insert(self._table_cols_after, -1)
self._table_delete_cols = ToolButton('column-remove')
self._table_delete_cols.set_tooltip(_('Delete Column'))
self._table_delete_cols_id = self._table_delete_cols.connect( \
'clicked', self._table_delete_cols_cb)
self.insert(self._table_delete_cols, -1)
separator = gtk.SeparatorToolItem()
self.insert(separator, -1)
image = ToolButton('insert-picture')
image.set_tooltip(_('Insert Image'))
self._image_id = image.connect('clicked', self._image_cb)
self.insert(image, -1)
self.show_all()
self._abiword_canvas.connect('table-state', self._isTable_cb)
#self._abiword_canvas.connect('image-selected', self._image_selected_cb)
def _image_cb(self, button):
def cb(object):
logging.debug('ObjectChooser: %r' % object)
self._abiword_canvas.insert_image(object.file_path, True)
chooser.pick(what=chooser.IMAGE, cb=cb)
def _table_cb(self, abi, rows, cols):
self._abiword_canvas.insert_table(rows, cols)
def _table_rows_after_cb(self, button):
self._abiword_canvas.invoke_cmd('insertRowsAfter', '', 0, 0)
def _table_delete_rows_cb(self, button):
self._abiword_canvas.invoke_cmd('deleteRows', '', 0, 0)
def _table_cols_after_cb(self, button):
self._abiword_canvas.invoke_cmd('insertColsAfter', '', 0, 0)
def _table_delete_cols_cb(self, button):
self._abiword_canvas.invoke_cmd('deleteColumns', '', 0, 0)
def _isTable_cb(self, abi, b):
self._table_rows_after.set_sensitive(b)
self._table_delete_rows.set_sensitive(b)
self._table_cols_after.set_sensitive(b)
self._table_delete_cols.set_sensitive(b)
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)
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)
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)
class TextAttributesToolbar(gtk.Toolbar):
def __init__(self, main_area):
gtk.Toolbar.__init__(self)
self._main_area = main_area
self._font_list = ['ABC123', 'Sans', 'Serif', 'Monospace', 'Symbol']
self._font_sizes = [
'8', '9', '10', '11', '12', '14', '16', '20', '22', '24', '26',
'28', '36', '48', '72'
]
self.font_button = ToolButton('font-text')
self.font_button.set_tooltip(_('Select font'))
self.font_button.connect('clicked', self.__font_selection_cb)
self.insert(self.font_button, -1)
self._setup_font_palette()
self.insert(gtk.SeparatorToolItem(), -1)
self.font_size_up = ToolButton('resize+')
self.font_size_up.set_tooltip(_('Bigger'))
self.font_size_up.connect('clicked', self.__font_sizes_cb, True)
self.insert(self.font_size_up, -1)
if len(self._main_area.selected) > 0:
font_size = self._main_area.font_size
else:
font_size = utils.default_font_size
self.size_label = gtk.Label(str(font_size))
self.size_label.show()
toolitem = gtk.ToolItem()
toolitem.add(self.size_label)
toolitem.show()
self.insert(toolitem, -1)
self.font_size_down = ToolButton('resize-')
self.font_size_down.set_tooltip(_('Smaller'))
self.font_size_down.connect('clicked', self.__font_sizes_cb, False)
self.insert(self.font_size_down, -1)
self.insert(gtk.SeparatorToolItem(), -1)
self.bold = ToolButton('bold-text')
self.bold.set_tooltip(_('Bold'))
self.bold.connect('clicked', self.__bold_cb)
self.insert(self.bold, -1)
self.italics = ToolButton('italics-text')
self.italics.set_tooltip(_('Italics'))
self.italics.connect('clicked', self.__italics_cb)
self.insert(self.italics, -1)
self.underline = ToolButton('underline-text')
self.underline.set_tooltip(_('Underline'))
self.underline.connect('clicked', self.__underline_cb)
self.insert(self.underline, -1)
foreground_color = ColorToolButton()
foreground_color.set_title(_('Set font color'))
foreground_color.connect('color-set', self.__foreground_color_cb)
self.insert(foreground_color, -1)
bakground_color = ColorToolButton()
bakground_color.set_title(_('Set background color'))
bakground_color.connect('color-set', self.__background_color_cb)
bakground_color.set_color(gtk.gdk.Color(65535, 65535, 65535))
self.insert(bakground_color, -1)
self.show_all()
def __font_selection_cb(self, widget):
if self._font_palette:
if not self._font_palette.is_up():
self._font_palette.popup(immediate=True,
state=self._font_palette.SECONDARY)
else:
self._font_palette.popdown(immediate=True)
return
def _init_font_list(self):
self._font_white_list = []
self._font_white_list.extend(DEFAULT_FONTS)
# check if there are a user configuration file
if not os.path.exists(USER_FONTS_FILE_PATH):
# verify if exists a file in /etc
if os.path.exists(GLOBAL_FONTS_FILE_PATH):
shutil.copy(GLOBAL_FONTS_FILE_PATH, USER_FONTS_FILE_PATH)
if os.path.exists(USER_FONTS_FILE_PATH):
# get the font names in the file to the white list
fonts_file = open(USER_FONTS_FILE_PATH)
# get the font names in the file to the white list
for line in fonts_file:
self._font_white_list.append(line.strip())
# monitor changes in the file
gio_fonts_file = gio.File(USER_FONTS_FILE_PATH)
self.monitor = gio_fonts_file.monitor_file()
self.monitor.set_rate_limit(5000)
self.monitor.connect('changed', self._reload_fonts)
def _reload_fonts(self, monitor, gio_file, other_file, event):
if event != gio.FILE_MONITOR_EVENT_CHANGES_DONE_HINT:
return
self._font_white_list = []
self._font_white_list.extend(DEFAULT_FONTS)
fonts_file = open(USER_FONTS_FILE_PATH)
for line in fonts_file:
self._font_white_list.append(line.strip())
# update the menu
for child in self._font_palette.menu.get_children():
self._font_palette.menu.remove(child)
child = None
context = self.get_pango_context()
tmp_list = []
for family in context.list_families():
name = family.get_name()
if name in self._font_white_list:
tmp_list.append(name)
for font in sorted(tmp_list):
menu_item = MyMenuItem(image=FontImage(font.replace(' ', '-')),
text_label=font)
menu_item.connect('activate', self.__font_selected_cb, font)
self._font_palette.menu.append(menu_item)
menu_item.show()
return False
def _setup_font_palette(self):
self._init_font_list()
context = self._main_area.pango_context
for family in context.list_families():
name = pango.FontDescription(family.get_name()).to_string()
if name not in self._font_list and \
name in self._font_white_list:
self._font_list.append(name)
self._font_palette = self.font_button.get_palette()
for font in sorted(self._font_list):
menu_item = MyMenuItem(image=FontImage(font.replace(' ', '-')),
text_label=font)
menu_item.connect('activate', self.__font_selected_cb, font)
self._font_palette.menu.append(menu_item)
menu_item.show()
def __font_selected_cb(self, widget, font_name):
if not hasattr(self._main_area, 'font_name'):
return
if len(self._main_area.selected) > 0:
font_size = self._main_area.font_size
else:
font_size = utils.default_font_size
self._main_area.set_font(font_name, font_size)
self._main_area.font_name = font_name
self._main_area.font_size = font_size
def __attribute_values(self):
attributes = {
"bold": True,
"italics": True,
"underline": True,
"font": ""
}
it = self._main_area.selected[0].attributes.get_iterator()
start_index = self._main_area.selected[0].index
end_index = self._main_area.selected[0].end_index
while (1):
found = False
r = it.range()
if start_index == end_index:
if r[0] <= start_index and r[1] > start_index:
found = True
elif start_index < end_index:
if r[0] > end_index:
break
if start_index == end_index and \
r[0] < start_index and \
r[1] > start_index:
found = True
elif start_index != end_index and r[0] <= start_index and \
r[1] >= end_index:
found = True
else:
if r[0] > start_index:
break
if start_index == end_index and \
r[0] < start_index and \
r[1] > start_index:
found = True
elif start_index != end_index and r[0] <= end_index and \
r[1] >= start_index:
found = True
if found:
attr = it.get_attrs()
for x in attr:
if x.type == pango.ATTR_WEIGHT and \
x.value == pango.WEIGHT_BOLD:
attributes["bold"] = False
elif x.type == pango.ATTR_STYLE and \
x.value == pango.STYLE_ITALIC:
attributes["italics"] = False
elif x.type == pango.ATTR_UNDERLINE and \
x.value == pango.UNDERLINE_SINGLE:
attributes["underline"] = False
elif x.type == pango.ATTR_FONT_DESC:
attributes["font"] = x.desc
if it.next() == False:
break
return attributes
def __font_sizes_cb(self, button, increase):
if not hasattr(self._main_area, 'font_size'):
return
if len(self._main_area.selected) < 1:
return
font_size = self._main_area.font_size
if font_size in self._font_sizes:
i = self._font_sizes.index(font_size)
if increase:
if i < len(self._font_sizes) - 2:
i += 1
else:
if i > 0:
i -= 1
else:
i = self._font_sizes.index(utils.default_font_size)
font_size = self._font_sizes[i]
self.size_label.set_text(str(font_size))
self.font_size_down.set_sensitive(i != 0)
self.font_size_up.set_sensitive(i < len(self._font_sizes) - 2)
self._main_area.set_font(self._main_area.font_name, font_size)
def __bold_cb(self, button):
if len(self._main_area.selected) < 1:
return
value = self.__attribute_values()["bold"]
self._main_area.set_bold(value)
def __italics_cb(self, button):
if len(self._main_area.selected) < 1:
return
value = self.__attribute_values()["italics"]
self._main_area.set_italics(value)
def __underline_cb(self, button):
if len(self._main_area.selected) < 1:
return
value = self.__attribute_values()["underline"]
self._main_area.set_underline(value)
def __foreground_color_cb(self, button):
color = button.get_color()
self._main_area.set_foreground_color(color)
def __background_color_cb(self, button):
color = button.get_color()
self._parent._main_area.set_background_color(color)
def change_active_font(self):
# TODO: update the toolbar
return
class VideoPlayerActivity(activity.Activity):
def __init__(self, handle):
activity.Activity.__init__(self, handle)
self._current_video_idx = 0
self._lesson_state = False
self.max_participants = 1
# Set blackground as blue
self.modify_bg(gtk.STATE_NORMAL, gtk.gdk.color_parse('#3FBDAC'))
if hasattr(self, '_event_box'):
# for pre-0.96
self._event_box.modify_bg(gtk.STATE_NORMAL,
gtk.gdk.color_parse('#3FBDAC'))
toolbar_box = ToolbarBox()
activity_button = ActivityToolbarButton(self)
toolbar_box.toolbar.insert(activity_button, 0)
activity_button.show()
self._play_button = ToolButton('media-playback-start')
self._play_button.set_tooltip(_('Play video'))
self._play_button.connect('clicked', self._play_clicked)
self._play_button.set_sensitive(True)
self._play_button.show()
toolbar_box.toolbar.insert(self._play_button, -1)
self._pause_button = ToolButton('media-playback-pause')
self._pause_button.set_tooltip(_('Pause video'))
self._pause_button.connect('clicked', self._pause_clicked)
self._pause_button.set_sensitive(False)
self._pause_button.show()
toolbar_box.toolbar.insert(self._pause_button, -1)
self._stop_button = ToolButton('media-playback-stop')
self._stop_button.set_tooltip(_('Stop video'))
self._stop_button.connect('clicked', self._stop_clicked)
self._stop_button.set_sensitive(False)
self._stop_button.show()
toolbar_box.toolbar.insert(self._stop_button, -1)
self._lesson_button = ToolButton('view-list')
self._lesson_button.connect('clicked', self._toggle_lesson)
self._lesson_button.set_tooltip(_('View lesson'))
self._lesson_button.set_sensitive(False)
self._lesson_button.show()
toolbar_box.toolbar.insert(self._lesson_button, -1)
separator = gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
separator.show()
toolbar_box.toolbar.insert(separator, -1)
tool = StopButton(self)
toolbar_box.toolbar.insert(tool, -1)
tool.show()
self.set_toolbox(toolbar_box)
toolbar_box.show()
vbox = PaddedVBox()
vbox.show()
self.set_canvas(vbox)
self._menu = gtk.Table(2, 3, True)
self._menu.set_row_spacings(10)
self._menu.set_col_spacings(10)
vbox.pack_start(self._menu, expand=True, fill=True)
self._menu.show()
self._videos = VIDEOS
self._lessons = LESSONS
self._generate_menu()
self._video_title = gtk.Label()
# self._video_title.modify_fg(
# gtk.STATE_NORMAL, gtk.gdk.color_parse('#FFFFFF'))
vbox.pack_start(self._video_title, expand=False)
self._video = VideoPlayer()
vbox.pack_start(self._video, expand=True, fill=True, padding=10)
self._video.realize()
self._video_description = gtk.Label()
self._video_description.set_text('\n\n\n\n')
self._video_description.set_line_wrap(True)
self._video_description.set_size_request(
gtk.gdk.screen_width() - style.GRID_CELL_SIZE * 2, -1)
# self._video_description.modify_fg(
# gtk.STATE_NORMAL, gtk.gdk.color_parse('#FFFFFF'))
vbox.pack_start(self._video_description, expand=False)
self._lesson_text = gtk.Label()
self._lesson_text.set_line_wrap(True)
# self._lesson_text.modify_fg(
# gtk.STATE_NORMAL, gtk.gdk.color_parse('#FFFFFF'))
self._lesson_text.set_size_request(
gtk.gdk.screen_width() - style.GRID_CELL_SIZE * 3,
gtk.gdk.screen_height() - style.GRID_CELL_SIZE * 3)
vbox.pack_start(self._lesson_text, expand=True, fill=True, padding=10)
vbox.show()
# Try to fix description height to 4 lines so that it doesn't
# shift size while changing videos.
# self._video_description.set_text('\n\n\n\n')
# size_req = self._video_description.size_request()
# self._video_description.set_size_request(-1, size_req[1])
def write_file(self, file_path):
# Force video to stop
self._stop_clicked(None)
def _generate_menu(self):
for child in self._menu.get_children():
self._menu.remove(child)
for (i, video) in enumerate(self._videos):
print video[0]
path = os.path.join(activity.get_bundle_path(), 'thumbnails',
video[0][0:-4] +
'.png') # FIXME: make more robust
button = VideoButton(video[1], path)
button.connect('button_press_event', self.__menu_item_clicked, i)
col = i % 4
row = i / 4
self._menu.attach(button, col, col + 1, row, row + 1)
button.show_all()
def _toggle_lesson(self, button):
if not self._lesson_state:
self._pause_clicked(None)
self._show_lesson()
else:
self._hide_lesson()
self._play_clicked(None)
def _show_lesson(self):
self._lesson_state = True
self._video.hide()
self._video_description.hide()
self._lesson_text.show()
self._lesson_button.set_sensitive(False)
def _hide_lesson(self):
self._lesson_state = False
self._lesson_text.hide()
self._video.show()
self._video_description.show()
self._lesson_button.set_sensitive(True)
def _play_video(self, idx):
video = self._videos[idx]
self._menu.hide()
self._hide_lesson()
self._video.show()
self._video.stop()
self._video_title.set_markup('<span size="x-large" weight="bold">' + \
glib.markup_escape_text(video[1]) + \
'</span>')
self._video_title.show()
if len(video) > 2:
self._video_description.set_text(video[2].strip())
else:
self._video_description.set_text('')
self._video_description.show()
self._lesson_button.set_sensitive(True)
self._lesson_text.set_markup(self._lessons[idx])
self._video.play(video[0])
self._current_video_idx = idx
def __menu_item_clicked(self, widget, event, idx):
self._pause_button.set_sensitive(True)
self._stop_button.set_sensitive(True)
self._lesson_button.set_sensitive(True)
self._play_button.set_sensitive(False)
self._play_video(idx)
def _play_clicked(self, widget):
if self._lesson_state:
self._hide_lesson()
if self._video.paused:
self._video.unpause()
else:
self._play_video(self._current_video_idx)
self._pause_button.set_sensitive(True)
self._stop_button.set_sensitive(True)
self._lesson_button.set_sensitive(True)
self._play_button.set_sensitive(False)
def _pause_clicked(self, widget):
if not self._video.paused:
self._video.pause()
self._pause_button.set_sensitive(False)
self._stop_button.set_sensitive(True)
self._lesson_button.set_sensitive(True)
self._play_button.set_sensitive(True)
def _stop_clicked(self, widget):
if self._video.playing:
self._video.stop()
self._pause_button.set_sensitive(False)
self._stop_button.set_sensitive(False)
self._lesson_button.set_sensitive(False)
self._play_button.set_sensitive(True)
self._video.hide()
self._video_title.hide()
self._video_description.hide()
self._lesson_text.hide()
self._menu.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
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)
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)
class FreeFromMalariaActivity(activity.Activity):
def __init__(self, handle):
activity.Activity.__init__(self, handle)
self.activity_state = {}
self._name = handle
self.set_title(_("Free From Malaria"))
restartTitle = _("End User Licence");
restartText = _("The materials in this game are in no way intended to replace or supersede professional medical care, advice, diagnosis or treatment of a doctor. The game only provides general advice on Malaria. This advice may not apply to everyone in every locality. If you notice medical symptoms or feel ill, you should consult your doctor. Please seek further advice from your local health authority for further information about Malaria.All information provided in this activity has been produced using peer reviewed scientific and health documentation. By clicking OK you agree that this game should be used for general educational and information purposes only and is not intended to replace medical advice or act as a diagnosis tool. For more details please visit http://worldclassproject.org.uk/.");
dialog = self.create_dialog_ok(restartTitle, restartText)
result = dialog.run()
dialog.destroy()
#init the controller
#game controller
if handle.object_id == None:
print "Launched from home."
else:
print "Journal resume."
# Set title for our Activity
self.set_title('Free From Malaria')
# Attach sugar toolbox (Share, ...)
# Use old <= 0.84 toolbar design
toolbox = activity.ActivityToolbox(self)
view_tool_bar = toolbox.get_activity_toolbar();#gtk.Toolbar()
#for debug only
# self.previous_chapter = ToolButton('gtk-media-forward-rtl')
# self.previous_chapter.set_tooltip("Previous Chapter")
# self.previous_chapter_id = self.previous_chapter.connect('clicked', self.previous_chapter_clicked)
# view_tool_bar.insert(self.previous_chapter, 0)
# self.previous_chapter.show()
########################################
self.previous_scene_button = ToolButton('previous')
self.previous_scene_button.set_tooltip("Previous Scene")
self.previous_scene_id = self.previous_scene_button.connect('clicked', self.previous_scene_clicked)
view_tool_bar.insert(self.previous_scene_button, 1)
self.previous_scene_button.show()
###########print "CHANGING"
self.next_scene = ToolButton('next')
self.next_scene.set_tooltip("Next Scene")
self.next_scene_id = self.next_scene.connect('clicked', self.next_scene_clicked)
view_tool_bar.insert(self.next_scene, 2)
self.next_scene.show()
###########
#disable comic buttons in the main menu
self.set_navigation(False)
######################
self.sound = ToolButton('audio-volume-high')
homeString = _("Enable/Disable Sound");
self.sound.set_tooltip(homeString)
self.sound_id = self.sound.connect('clicked', self.sound_clicked)
view_tool_bar.insert(self.sound, 3)
self.sound.show()
#############################
###########
self.reload = ToolButton('reload')
restart = _("Restart");
self.reload.set_tooltip(restart)
self.reload_id = self.reload.connect('clicked', self.reload_clicked)
view_tool_bar.insert(self.reload, 4)
self.reload.show()
######################
######################
self.home = ToolButton('go-home')
homeString = _("Go to main menu");
self.home.set_tooltip(homeString)
self.home_id = self.home.connect('clicked', self.home_clicked)
view_tool_bar.insert(self.home, 5)
self.home.show()
#############################
view_tool_bar.show()
# toolbox.add_toolbar('Game Control', view_tool_bar)
self.set_toolbox(toolbox)
toolbox.show()
activity_toolbar = toolbox.get_activity_toolbar()
activity_toolbar.share.props.visible = False
#global game state
##restore previous session
self.controller = controller.GameController.GlobalGameController(self)
self.read_and_parse_prefs(os.environ['SUGAR_ACTIVITY_ROOT'] + '/data/defaults')
#welcomeview = WelcomeScreen.GameWelcomeScreen(self.controller);
#self.create_new_window(welcomeview)
# self.mywindow = welcomeview.get_window()
# self.w_child = self.mywindow.get_child()
# self.widget = self.w_child
# self.pack_and_show()
def next_scene_clicked(self, event):
self.controller.next_scene();
def previous_scene_clicked(self, event):
self.controller.previous_scene();
def reload_clicked(self, event):
restartTitle = _("Restart The Story?");
restartText = _("Are you sure you want to restart the story?");
dialog = self.create_dialog(restartTitle, restartText)
result = dialog.run()
dialog.destroy()
if result == gtk.RESPONSE_YES:
self.controller.reload();
def home_clicked(self, event):
restartTitle = _("Restart The Main Menu?");
restartText = _("Are you sure you want to return to the main menu?");
dialog = self.create_dialog(restartTitle, restartText)
result = dialog.run()
dialog.destroy()
if result == gtk.RESPONSE_YES:
self.controller.play_game("Welcome", None);
def sound_clicked(self, event):
if(self.controller.get_sound() == True):
self.sound.set_icon("audio-volume-muted")
self.controller.set_sound(False);
else:
self.controller.set_sound(True);
self.sound.set_icon("audio-volume-high")
def create_dialog(self, title, message):
dialog = gtk.MessageDialog(parent=None,
buttons=gtk.BUTTONS_YES_NO,
flags=gtk.DIALOG_DESTROY_WITH_PARENT,
type=gtk.MESSAGE_QUESTION,
message_format=message);
dialog.set_title(title)
return dialog;
def create_dialog_ok(self, title, message):
dialog = gtk.MessageDialog(parent=None,
buttons=gtk.BUTTONS_OK,
flags=gtk.DIALOG_DESTROY_WITH_PARENT,
type=gtk.MESSAGE_QUESTION,
message_format=message);
dialog.set_title(title)
return dialog;
##disables the nav buttons when comic is not being shown
def set_navigation(self, switch):
self.previous_scene_button.set_sensitive(switch);
self.next_scene.set_sensitive(switch);
def create_new_window(self, view):
#self.view = view;
self.mywindow = view.get_window()
self.w_child = self.mywindow.get_child()
self.widget = self.w_child
# if(self.widget==None or self.w_child==None):
# raise RuntimeError("No widget available")
self.pack_and_show()
def pack_and_show(self):
# Create the main container
self._main_view = gtk.VBox()
# Import our class gtktest():
# Step 1: Load class, which creates gtktest.widget
#self.gtktest = devtest2(self)
# Step 2: Remove the widget's parent
if self.widget.parent:
self.widget.parent.remove(self.widget)
# Step 3: We attach that widget to our window
self._main_view.pack_start(self.widget)
# Display everything
self.widget.show()
self._main_view.show()
self.set_canvas(self._main_view)
self.show_all()
def read_and_parse_prefs(self, file_path):
#Parse and set preference data from a given file.
#file_path=os.environ['SUGAR_ACTIVITY_ROOT'] + '/data/defaults'
#file_path=os.environ['SUGAR_ACTIVITY_ROOT'] + '/data/defaults';
print "Restoring ", file_path
try:
read_file = open(file_path, 'r')
self.activity_state = json.loads(read_file.read())
if self.activity_state.has_key('comic_index'):
comic_index = self.activity_state['comic_index']
# print "Restoring with index ",comic_index
self.controller.set_comic_index(comic_index)
print "Restored COMIC SCENE from ", file_path
if self.activity_state.has_key('current_language_code'):
current_language = self.activity_state['current_language_code']
self.controller.load_language_by_code(current_language)
print "Restored LANGUAGE from ", file_path
self.controller.update_scene();
read_file.close();
except IOError:# as (errno, strerror):
print "Error: Preferences error"
except AttributeError:# as (errno):
print "Warning: controller not initialised and prefs called. {0}"
except:
raise;
def read_file(self, file_path):
#Read state from datastore.
self.read_and_parse_prefs(file_path)
def write_file(self, file_path):
# #"""Write state to journal datastore and to persistent file system.
# #"""
#file_path=os.environ['SUGAR_ACTIVITY_ROOT'] + '/data/defaults';
# print "WRITING FILE TO JOURNAL : "+os.environ['SUGAR_ACTIVITY_ROOT'] + '/data/defaults'
# BUG [ID: 3334629]
try:
print "WRITING FILE TO JOURNAL : " + file_path
self.activity_state['comic_index'] = self.controller.get_comic_index();
self.activity_state['current_language_code'] = self.controller.get_current_language_code();
serialised_data = json.dumps(self.activity_state)
to_journal = file(file_path, 'w')
try:
to_journal.write(serialised_data)
except:
raise
finally:
to_journal.close()
to_persistent_fs = file(os.environ['SUGAR_ACTIVITY_ROOT'] + '/data/defaults', 'w')
try:
to_persistent_fs.write(serialised_data)
except:
raise;
finally:
to_persistent_fs.close()
except AttributeError:# BUG [ID: 3334629]
print "Warning: controller not initialised and trying to write. {0}"
class RecordControl:
def __init__(self, toolbar):
self._timer_value = TIMER_VALUES[0]
self._timer_button = ToolButton("timer-0")
self._timer_button.set_tooltip(_("Select timer"))
self._timer_button.connect("clicked", self._timer_selection_cb)
toolbar.insert(self._timer_button, -1)
self._setup_timer_palette()
self._duration_value = DURATION_VALUES[0]
self._duration_button = ToolButton("duration-2")
self._duration_button.set_tooltip(_("Select duration"))
self._duration_button.connect("clicked", self._duration_selection_cb)
toolbar.insert(self._duration_button, -1)
self._setup_duration_palette()
self._quality_value = 0
self._quality_button = ToolButton("low-quality")
self._quality_button.set_tooltip(_("Select quality"))
self._quality_button.connect("clicked", self._quality_selection_cb)
toolbar.insert(self._quality_button, -1)
self._setup_quality_palette()
def _timer_selection_cb(self, widget):
if self._timer_palette:
if not self._timer_palette.is_up():
self._timer_palette.popup(immediate=True, state=self._timer_palette.SECONDARY)
else:
self._timer_palette.popdown(immediate=True)
return
def _setup_timer_palette(self):
self._timer_palette = self._timer_button.get_palette()
for seconds in TIMER_VALUES:
if seconds == 0:
text = _("Immediate")
else:
text = ngettext("%s second", "%s seconds", seconds) % seconds
menu_item = MenuItem(icon_name="timer-%d" % (seconds), text_label=text)
menu_item.connect("activate", self._timer_selected_cb, seconds)
self._timer_palette.menu.append(menu_item)
menu_item.show()
def _timer_selected_cb(self, button, seconds):
self.set_timer_idx(TIMER_VALUES.index(seconds))
def _duration_selection_cb(self, widget):
if self._duration_palette:
if not self._duration_palette.is_up():
self._duration_palette.popup(immediate=True, state=self._duration_palette.SECONDARY)
else:
self._duration_palette.popdown(immediate=True)
return
def _setup_duration_palette(self):
self._duration_palette = self._duration_button.get_palette()
for minutes in DURATION_VALUES:
if minutes == 0:
text = gtk.Label(_("Immediate"))
else:
text = ngettext("%s minute", "%s minutes", minutes) % minutes
menu_item = MenuItem(icon_name="duration-%d" % (minutes), text_label=text)
menu_item.connect("activate", self._duration_selected_cb, minutes)
self._duration_palette.menu.append(menu_item)
menu_item.show()
def _duration_selected_cb(self, button, minutes):
self.set_duration_idx(DURATION_VALUES.index(minutes))
def _quality_selection_cb(self, widget):
if self._quality_palette:
if not self._quality_palette.is_up():
self._quality_palette.popup(immediate=True, state=self._quality_palette.SECONDARY)
else:
self._quality_palette.popdown(immediate=True)
return
def _setup_quality_palette(self):
self._quality_palette = self._quality_button.get_palette()
for quality in QUALITY_VALUES:
text = _("%s quality") % (quality)
menu_item = MenuItem(icon_name=quality + "-quality", text_label=text)
menu_item.connect("activate", self._quality_selected_cb, quality)
self._quality_palette.menu.append(menu_item)
menu_item.show()
def _quality_selected_cb(self, button, quality):
self.set_quality(QUALITY_VALUES.index(quality))
def set_mode(self, mode):
if mode == constants.MODE_PHOTO:
self._quality_button.set_sensitive(False)
self._timer_button.set_sensitive(True)
self._duration_button.set_sensitive(False)
if mode == constants.MODE_VIDEO:
self._quality_button.set_sensitive(True)
self._timer_button.set_sensitive(True)
self._duration_button.set_sensitive(True)
if mode == constants.MODE_AUDIO:
self._quality_button.set_sensitive(False)
self._timer_button.set_sensitive(True)
self._duration_button.set_sensitive(True)
def get_timer(self):
return self._timer_value
def get_timer_idx(self):
if self._timer_value in TIMER_VALUES:
return TIMER_VALUES.index(self._timer_value)
else:
return TIMER_VALUES[0]
def set_timer_idx(self, idx):
self._timer_value = TIMER_VALUES[idx]
if hasattr(self, "_timer_button"):
self._timer_button.set_icon("timer-%d" % (self._timer_value))
def get_duration(self):
return self._duration_value
def get_duration_idx(self):
if self._duration_value in DURATION_VALUES:
return DURATION_VALUES.index(self._duration_value)
else:
return DURATION_VALUES[0]
def set_duration_idx(self, idx):
self._duration_value = DURATION_VALUES[idx]
if hasattr(self, "_duration_button"):
self._duration_button.set_icon("duration-%d" % (self._duration_value))
def get_quality(self):
return self._quality_value
def set_quality(self, idx):
self._quality_value = idx
if hasattr(self, "_quality_button"):
self._quality_button.set_icon("%s-quality" % (QUALITY_VALUES[idx]))
class Explorer(activity.Activity):
'''Es la clase que crea la actividad'''
def __init__(self, handle):
activity.Activity.__init__(self, handle, True)
# ToolbarBox:
toolbarbox = ToolbarBox()
activitybutton = ActivityButton(self)
toolbarbox.toolbar.insert(activitybutton, 0)
separator = gtk.SeparatorToolItem()
toolbarbox.toolbar.insert(separator, -1)
explorer_btn = RadioToolButton()
explorer_btn.set_tooltip('Explorador')
explorer_btn.props.icon_name = 'activity-explorer'
toolbarbox.toolbar.insert(explorer_btn, -1)
self._goup = ToolButton('to-subjects')
self._goup.connect('clicked', self._go_up_clicked)
self._goup.set_tooltip('Ver Materias')
self._goup.set_accelerator("<Shift><M>")
self._goup.set_sensitive(False)
toolbarbox.toolbar.insert(self._goup, -1)
self._select_all = ToolButton('select-all')
self._select_all.set_tooltip('Seleccionar todo')
self._select_all.connect("clicked", self._select_all_clicked)
self._select_all.set_sensitive(False)
toolbarbox.toolbar.insert(self._select_all, -1)
self._download = ToolButton('download')
self._download.set_tooltip('Descargar')
self._download.set_sensitive(False)
toolbarbox.toolbar.insert(self._download, -1)
separator = gtk.SeparatorToolItem()
toolbarbox.toolbar.insert(separator, -1)
homework_btn = RadioToolButton()
homework_btn.set_tooltip('Tareas Domiciliarias')
homework_btn.props.icon_name = 'homework'
homework_btn.props.group = explorer_btn
toolbarbox.toolbar.insert(homework_btn, -1)
open_btn = ToolButton()
open_btn.set_tooltip('Seleccionar tarea')
open_btn.props.icon_name = 'open-from-journal'
open_btn.set_sensitive(False)
open_btn.connect("clicked", self._select_hw_from_journal)
toolbarbox.toolbar.insert(open_btn, -1)
self._send = ToolButton()
self._send.set_tooltip('Enviar tarea')
self._send.connect('clicked', self._send_hw_to_server)
self._send.props.icon_name = 'document-send'
self._send.set_sensitive(False)
toolbarbox.toolbar.insert(self._send, -1)
homework_btn.connect('clicked', self.homework_btn_cb, open_btn)
explorer_btn.connect('clicked', self.explorer_btn_cb, open_btn)
separator = gtk.SeparatorToolItem()
separator.set_expand(True)
separator.set_draw(False)
toolbarbox.toolbar.insert(separator, -1)
stopbtn = StopButton(self)
toolbarbox.toolbar.insert(stopbtn, -1)
self.set_toolbar_box(toolbarbox)
self._one_alert = None
# Canvas
self._canvas = gtk.EventBox()
self._name = ''
self._last_name = ''
self._hw_title = ''
self._hw_description = ''
self._hw_path = ''
self._hw_mimetype = ''
self.set_canvas(self._canvas)
self.show_all()
if not utils.get_group():
self.choose_group()
else:
self._do_canvas()
def homework_btn_cb(self, button, open_btn):
'''Se ejecuta cuando se hace click en el boton
de tareas domiciliarias, se encarga de cambiar de pagina'''
self._notebook.set_current_page(2)
self._goup.set_sensitive(False)
self._select_all.set_sensitive(False)
self._download.set_sensitive(False)
open_btn.set_sensitive(True)
self._send.set_sensitive(False)
def explorer_btn_cb(self, widget, open_btn):
'''Se ejecuta cuando se hace click en el boton
del explorador, se encarga de cambiar de pagina'''
self._notebook.set_current_page(0)
open_btn.set_sensitive(False)
self._send.set_sensitive(False)
def _select_hw_from_journal(self, widget):
'''Abre un selector de objetos del diario'''
chooser = ObjectChooser()
response = chooser.run()
if response == gtk.RESPONSE_ACCEPT:
jobject = chooser.get_selected_object()
self._hw_path = str(jobject.get_file_path())
self._notebook.set_current_page(-1)
self._send.set_sensitive(True)
self._hw_title.set_text(jobject.get_metadata()["title"])
self._hw_mimetype = mime.get_for_file(self._hw_path)
def _send_hw_to_server(self, widget):
'''Envia las tareas domiciliarias'''
_buffer = self._hw_description.get_buffer()
start = _buffer.get_start_iter()
end = _buffer.get_end_iter()
comments = _buffer.get_text(start, end)
utils.send_homework(self._subjects._sftp,
self._subjects_selector.\
get_active_text(),
self._hw_path,
self._hw_title.get_text(),
comments, self._hw_mimetype)
self._notebook.set_current_page(2)
def _set_text(self, widget, name=True):
if name:
self._name = widget.get_text()
else:
self._last_name = widget.get_text()
def _do_homework_canvas(self):
'''Arma el canvas para la tareas domiciliarias '''
main_container = gtk.VBox()
self._hw_title = widgets.Entry('Escriba el titulo aqui')
main_container.pack_start(self._hw_title, False, True, 0)
label = gtk.Label('Comentarios:')
main_container.pack_start(label, False, True, 10)
self._hw_description = gtk.TextView()
self._hw_description.set_property('wrap-mode', gtk.WRAP_WORD_CHAR)
main_container.pack_start(self._hw_description, True, True, 5)
hbox = gtk.HBox()
main_container.pack_start(hbox, False, True)
self._subjects_selector = widgets.SubjectChooser()
hbox.pack_start(self._subjects_selector, False, True, 0)
return main_container
def choose_group(self):
'''Selector de los grupos'''
vbox = gtk.VBox()
vbox.set_border_width(20)
title = gtk.Label('Registrate en Aula Virtual')
title.modify_font(pango.FontDescription('bold 25'))
vbox.pack_start(title, False, padding=40)
note = gtk.Label('<span foreground="#FF0000"><i>\
* Por favor ingresa los datos correctamente.</i></span>')
note.set_use_markup(True)
vbox.pack_start(note, False, True, padding=5)
hbox = gtk.HBox()
vbox.pack_start(hbox, False, padding=10)
label = gtk.Label("Nombre: ")
hbox.pack_start(label, False, padding=10)
entry = gtk.Entry()
entry.connect('changed', self._set_text)
hbox.pack_start(entry, True, padding=0)
hbox1 = gtk.HBox()
hbox1.set_border_width(20)
label = gtk.Label("Apellido: ")
hbox1.pack_start(label, False, padding=0)
entry = gtk.Entry()
entry.connect('changed', self._set_text, False)
hbox1.pack_start(entry, True, padding=0)
vbox.pack_start(hbox1, False, padding=10)
hbox2 = gtk.HBox()
vbox.pack_start(hbox2, False, padding=10)
label_combo = gtk.Label("Elige tu grupo: ")
hbox2.pack_start(label_combo, False, True, padding=10)
combo = gtk.ComboBox()
liststore = gtk.ListStore(str)
combo.set_model(liststore)
cell = gtk.CellRendererText()
combo.pack_start(cell, True)
combo.add_attribute(cell, 'text', 0)
hbox2.pack_start(combo, False, True, padding=10)
for group in GROUPS:
liststore.append([group])
combo.set_active(0)
accept = gtk.Button('Aceptar')
accept.connect('clicked', self._accept_clicked, combo, entry, vbox)
box = gtk.HBox()
box.pack_end(accept, False)
vbox.pack_start(box, False)
self._canvas.add(vbox)
self.show_all()
def _accept_clicked(self, widget, combo, entry, vbox):
'''Se encarga de guardar la informacion de
la maquina en el sevidor'''
group = GROUPS[combo.get_active()]
utils.GROUP = group
vbox.destroy()
self._do_canvas()
utils.save_me(self._subjects._sftp,
group,
'%s %s' % (self._name, self._last_name))
def _go_up_clicked(self, widget):
'''Mustra la lista de materias'''
self._notebook.set_current_page(0)
self._goup.set_sensitive(False)
self._select_all.set_sensitive(False)
self._download.set_sensitive(False)
def _select_all_clicked(self, widget):
'''Selecciona todo'''
self._documents.select_all()
def _do_canvas(self):
'''Crea el canvas principal'''
scroll_documents = gtk.ScrolledWindow()
scroll_documents.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
self._documents = Documents(self)
self._notebook = gtk.Notebook()
self._subjects = Subjects(self._notebook, self._documents,
self._go_up_clicked)
self._subjects.connect('selected',
lambda w: self._goup.set_sensitive(True))
scroll_documents.add_with_viewport(self._documents)
scroll_subjects = gtk.ScrolledWindow()
scroll_subjects.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
scroll_subjects.add_with_viewport(self._subjects)
self._notebook.append_page(scroll_subjects)
self._notebook.append_page(scroll_documents)
self._notebook.append_page(documents.HomeWorks(self._subjects._sftp))
self._notebook.append_page(self._do_homework_canvas())
self._notebook.set_property("show-tabs", False)
self._canvas.add(self._notebook)
self._canvas.show_all()
self._notebook.set_current_page(0)
def get_alert(self):
'''Devuelve la alerta'''
if not self._one_alert:
self._one_alert = Alert()
self.add_alert(self._one_alert)
return self._one_alert
class InkToolBar(gtk.Toolbar):
# Constructor
def __init__(self, arbiter):
gtk.Toolbar.__init__(self)
self.__arbiter = arbiter
self.__logger = logging.getLogger('InkToolBar')
self.__logger.setLevel(logging.DEBUG)
self.__cur_color = self.__arbiter.get_pen_color()
self.__cur_color_str = "blue"
self.__cur_pen = self.__arbiter.get_pen_size()
self.__arbiter.connect_slide_redraw(self.update_buttons)
self.__arbiter.connect_undo_redo_changed(self.update_buttons)
# Red Ink
self.__red = gtk.RadioToolButton()
self.__red.set_icon_name('red-button')
self.insert(self.__red, -1)
self.__red.show()
#self.__red.set_tooltip('Red Ink')
self.__red.connect('clicked', self.set_ink_color, 1.0, 0.0, 0.0, "red")
# Green Ink
self.__green = gtk.RadioToolButton(group=self.__red)
self.__green.set_icon_name('green-button')
self.insert(self.__green, -1)
self.__green.show()
#self.__green.set_tooltip('Green Ink')
self.__green.connect('clicked', self.set_ink_color, 0.0, 1.0, 0.0, "green")
# Blue Ink
self.__blue = gtk.RadioToolButton(group=self.__red)
self.__blue.set_icon_name('blue-button')
self.insert(self.__blue, -1)
self.__blue.show()
#self.__blue.set_tooltip('Blue Ink')
self.__blue.connect('clicked', self.set_ink_color, 0.0, 0.0, 1.0, "blue")
# Black Ink
self.__black = gtk.RadioToolButton(group=self.__red)
self.__black.set_icon_name('black-button')
self.insert(self.__black, -1)
self.__black.show()
#self.__black.set_tooltip('Black Ink')
self.__black.connect('clicked', self.set_ink_color, 0.0, 0.0, 0.0, "black")
# Separate ink from untensils
separator = gtk.SeparatorToolItem()
separator.set_draw(False)
self.insert(separator, -1)
separator.show()
# Pencil
self.__pencil = gtk.RadioToolButton()
self.__pencil.set_icon_name('tool-pencil')
self.insert(self.__pencil, -1)
self.__pencil.show()
#self.__pencil.set_tooltip('Pencil')
self.__pencil.connect('clicked', self.set_cur_pen, 4)
# Brush
self.__brush = gtk.RadioToolButton(self.__pencil)
self.__brush.set_icon_name('tool-brush')
self.insert(self.__brush, -1)
self.__brush.show()
#self.__brush.set_tooltip('Brush')
self.__brush.connect('clicked', self.set_cur_pen, 8)
# Erase
self.__erase = ToolButton('tool-eraser')
self.insert(self.__erase, -1)
self.__erase.show()
self.__erase.set_tooltip(_('Erase All Ink'))
self.__erase.connect('clicked', self.erase_btn_clicked)
"""
# Text
self.__text = ToolButton('text')
self.insert(self.__text, -1)
self.__text.show()
self.__text.set_tooltip('Text')
"""
# Separate tools from text
separator = gtk.SeparatorToolItem()
separator.set_draw(False)
self.insert(separator, -1)
separator.show()
# Undo
self.__undo = ToolButton('edit-undo')
self.insert(self.__undo, -1)
self.__undo.show()
self.__undo.set_tooltip(_('Undo'))
self.__undo.connect('clicked', self.undo)
# Redo
self.__redo = ToolButton('edit-redo')
self.insert(self.__redo, -1)
self.__redo.show()
self.__redo.set_tooltip(_('Redo'))
self.__redo.connect('clicked', self.redo)
separator = gtk.SeparatorToolItem()
separator.set_draw(False)
separator.set_expand(True)
self.insert(separator, -1)
separator.show()
self.__submit = ToolButton('broadcast')
self.insert(self.__submit, -1)
self.__submit.show()
self.__submit.set_tooltip(_('Broadcast Submission'))
self.__submit.connect('clicked', self.submit_ink_cb)
self.__arbiter.connect_joined(self.activity_joined_cb)
self.set_tool_buttons()
self.show()
self.update_buttons()
def activity_joined_cb(self, widget):
self.__submit.set_tooltip(_('Submit Ink'))
self.__submit.set_icon('dialog-ok')
def set_cur_pen(self, widget, size):
self.__arbiter.do_set_pen(size)
def set_ink_color(self, widget, r, g, b, color):
self.__arbiter.do_set_color(r, g, b)
def erase_btn_clicked(self, widget):
self.__arbiter.do_clear_ink()
def set_tool_buttons(self):
if self.__cur_color == (1.0, 0.0, 0.0):
self.__red.set_active(True)
elif self.__cur_color == (0.0, 1.0, 0.0):
self.__green.set_active(True)
elif self.__cur_color == (0.0, 0.0, 1.0):
self.__blue.set_active(True)
else:
self.__black.set_active(True)
if self.__cur_pen == 2:
self.__pencil.set_active(True)
elif self.__cur_pen == 5:
self.__brush.set_active(True)
def submit_ink_cb(self, widget):
if self.__arbiter.get_is_instructor():
self.__logger.debug("Broadcast clicked")
self.broadcast_ink()
else:
self.__logger.debug("Submit clicked")
self.__submit.set_sensitive(False)
self.__timer = threading.Timer(10.0, self.reenable_submissions)
self.__timer.start()
self.__arbiter.do_submit_ink()
def broadcast_ink(self):
self.__arbiter.do_broadcast_ink()
def reenable_submissions(self):
gtk.gdk.threads_enter()
self.__submit.set_sensitive(True)
self.__submit.queue_draw()
gtk.gdk.threads_leave()
def undo(self, widget):
self.__arbiter.do_undo()
def redo(self, widget):
self.__arbiter.do_redo()
def update_buttons(self, widget=None):
can_undo, can_redo = self.__arbiter.get_can_undo_redo()
self.__undo.set_sensitive(can_undo)
self.__redo.set_sensitive(can_redo)
if self.__arbiter.get_is_instructor():
if self.__arbiter.get_active_submission() == -1:
self.__submit.set_sensitive(False)
else:
self.__submit.set_sensitive(True)
def __init__(self, handle):
activity.Activity.__init__(self, handle, True)
# ToolbarBox:
toolbarbox = ToolbarBox()
activitybutton = ActivityButton(self)
toolbarbox.toolbar.insert(activitybutton, 0)
separator = gtk.SeparatorToolItem()
toolbarbox.toolbar.insert(separator, -1)
explorer_btn = RadioToolButton()
explorer_btn.set_tooltip('Explorador')
explorer_btn.props.icon_name = 'activity-explorer'
toolbarbox.toolbar.insert(explorer_btn, -1)
self._goup = ToolButton('to-subjects')
self._goup.connect('clicked', self._go_up_clicked)
self._goup.set_tooltip('Ver Materias')
self._goup.set_accelerator("<Shift><M>")
self._goup.set_sensitive(False)
toolbarbox.toolbar.insert(self._goup, -1)
self._select_all = ToolButton('select-all')
self._select_all.set_tooltip('Seleccionar todo')
self._select_all.connect("clicked", self._select_all_clicked)
self._select_all.set_sensitive(False)
toolbarbox.toolbar.insert(self._select_all, -1)
self._download = ToolButton('download')
self._download.set_tooltip('Descargar')
self._download.set_sensitive(False)
toolbarbox.toolbar.insert(self._download, -1)
separator = gtk.SeparatorToolItem()
toolbarbox.toolbar.insert(separator, -1)
homework_btn = RadioToolButton()
homework_btn.set_tooltip('Tareas Domiciliarias')
homework_btn.props.icon_name = 'homework'
homework_btn.props.group = explorer_btn
toolbarbox.toolbar.insert(homework_btn, -1)
open_btn = ToolButton()
open_btn.set_tooltip('Seleccionar tarea')
open_btn.props.icon_name = 'open-from-journal'
open_btn.set_sensitive(False)
open_btn.connect("clicked", self._select_hw_from_journal)
toolbarbox.toolbar.insert(open_btn, -1)
self._send = ToolButton()
self._send.set_tooltip('Enviar tarea')
self._send.connect('clicked', self._send_hw_to_server)
self._send.props.icon_name = 'document-send'
self._send.set_sensitive(False)
toolbarbox.toolbar.insert(self._send, -1)
homework_btn.connect('clicked', self.homework_btn_cb, open_btn)
explorer_btn.connect('clicked', self.explorer_btn_cb, open_btn)
separator = gtk.SeparatorToolItem()
separator.set_expand(True)
separator.set_draw(False)
toolbarbox.toolbar.insert(separator, -1)
stopbtn = StopButton(self)
toolbarbox.toolbar.insert(stopbtn, -1)
self.set_toolbar_box(toolbarbox)
self._one_alert = None
# Canvas
self._canvas = gtk.EventBox()
self._name = ''
self._last_name = ''
self._hw_title = ''
self._hw_description = ''
self._hw_path = ''
self._hw_mimetype = ''
self.set_canvas(self._canvas)
self.show_all()
if not utils.get_group():
self.choose_group()
else:
self._do_canvas()
class Activity(sugar.activity.activity.Activity):
def __init__(self, handle):
super(Activity, self).__init__(handle)
self.paused = False
watch = gtk.gdk.Cursor(gtk.gdk.WATCH)
self.window.set_cursor(watch)
self.p = gtk.VPaned()
self.p.connect("notify::position", self.redraw)
self.box = gtk.Notebook()
self.p.pack2(self.box)
self.p.show()
self.box.set_show_tabs(False)
self.splash = gtk.Image()
pixbuf = gtk.gdk.pixbuf_new_from_file("images/splash_comodo.png")
screen = self.window.get_screen()
width, height = screen.get_width(), screen.get_height() - style.GRID_CELL_SIZE
pixbuf = pixbuf.scale_simple(width, height, gtk.gdk.INTERP_BILINEAR)
self.splash.set_from_pixbuf(pixbuf)
self.splash.show()
eb = gtk.EventBox()
eb.add(self.splash)
eb.modify_bg(gtk.STATE_NORMAL, gtk.gdk.color_parse("white"))
eb.show()
self.box.append_page(eb, gtk.Label("Inicio"))
self._pygamecanvas = sugargame2.canvas.PygameCanvas(self)
self._pygamecanvas.set_flags(gtk.EXPAND)
self._pygamecanvas.set_flags(gtk.FILL)
self.connect("visibility-notify-event", self.redraw)
self._pygamecanvas.set_events(gtk.gdk.BUTTON_PRESS_MASK)
self._pygamecanvas.connect("button-press-event", self._pygamecanvas.grab_focus)
self.box.append_page(self._pygamecanvas, gtk.Label("Juego"))
self.box.show()
self.set_canvas(self.p)
gobject.timeout_add(300, self.pump)
gobject.timeout_add(2000, self.init_interpreter)
#gobject.timeout_add(1000, self.build_editor)
gobject.timeout_add(1500, self.check_modified)
self.build_toolbar()
self.credits = None
self.editor = None
#self.reader = None
self._pygamecanvas.run_pygame(self.run_game)
def redraw(self, widget=None, b=None, c=None):
scene = spyral.director.get_scene()
if scene:
scene.redraw()
def alert(self, title=None, text=None, delay=5):
alert = NotifyAlert(delay)
alert.props.title = title
alert.props.msg = text
self.add_alert(alert)
alert.connect('response', self._alert_ok)
alert.show()
def _alert_ok(self, alert, *args):
self.remove_alert(alert)
def check_modified(self):
if self.box.current_page()==2:
if not self.save_button.get_sensitive():
if self.editor.modificado():
self.save_button.set_sensitive(True)
return False
return True
def pump(self):
# Esto es necesario porque sino pygame acumula demasiados eventos.
pygame.event.pump()
def focus_interpreter(self, widget, event):
self._interpreter.text.grab_focus()
return True
def init_interpreter(self):
# diferido unos segundos para evitar ver errores superfluos al iniciar
self._interpreter = GTKInterpreterConsole(self.redraw)
self._interpreter.text.connect('button-press-event', self.focus_interpreter)
self.p.pack1(self._interpreter)
return False
def open_file(self, widget, path):
if path:
if not os.path.isdir(path):
self.editor.open_file(widget, path)
def save_file(self, widget):
if self.editor.modificado():
self.save_button.set_sensitive(False)
self.editor.save_file()
filename = self.editor.current_file()
self.alert(filename, "Archivo guardado.")
gobject.timeout_add(1500, self.check_modified)
def build_editor(self):
dir_real = os.getcwd()
f = os.path.realpath(JUEGO.__file__)
f = "." + f.replace(dir_real ,"") # todo esto para obtener una ruta relativa
f = f.rstrip("c") # en caso que sea .pyc compilado
self.h = gtk.HPaned()
self.tree = FileViewer(".", os.path.basename(f))
self.tree.connect("file-selected", self.open_file)
self.tree.show()
self.h.pack1(self.tree)
self.box.append_page(self.h, gtk.Label("Editor"))
if False: #os.path.isfile("/usr/bin/gvim"):
# Si podemos, lo hacemos
self.socket = gtk.Socket()
self.socket.show()
self.h.pack2(self.socket)
sock_id = str(self.socket.get_id())
self.editor = VimSourceView(sock_id)
if not self.editor.bufInfo.bufferList:
f = JUEGO.__file__
if f.endswith("pyc"):
f = f[:-1]
self.open_file(None, f)
else:
self.editor = SourceView()
scroller = gtk.ScrolledWindow()
scroller.set_policy(gtk.POLICY_AUTOMATIC,
gtk.POLICY_AUTOMATIC)
scroller.add(self.editor)
scroller.show()
self.h.pack2(scroller)
self.editor.show()
self.h.show()
self.open_file(None, f)
def build_reader(self):
self.reader = webkit.WebView()
curdir = os.getcwd()
self.reader.load_uri("file://%s/docs/index.html" % curdir)
self.box.append_page(self.reader, gtk.Label("Lector"))
self.reader.show()
def build_toolbar(self):
toolbar_box = ToolbarBox()
self.set_toolbar_box(toolbar_box)
toolbar_box.show()
activity_button = ActivityToolbarButton(self)
toolbar_box.toolbar.insert(activity_button, -1)
activity_button.show()
tool_group = None
self.game_button = RadioToolButton()
self.game_button.props.icon_name = 'gamecanvas'
self.game_button.set_tooltip(_('Juego'))
self.game_button.accelerator = "<Ctrl>1"
self.game_button.props.group = tool_group
self.game_button.connect('clicked', self.show_game)
toolbar_box.toolbar.insert(self.game_button, -1)
self.game_button.show()
tool_group = self.game_button
button = RadioToolButton()
button.props.icon_name = 'view-source'
button.set_tooltip(_('Editor'))
button.accelerator = "<Ctrl>2"
button.props.group = tool_group
button.connect('clicked', self.show_editor)
toolbar_box.toolbar.insert(button, -1)
button.show()
self.save_button = ToolButton('dialog-ok')
self.save_button.set_tooltip(_('Guardar'))
self.save_button.accelerator = "<Ctrl>s"
self.save_button.connect('clicked', self.save_file)
self.save_button.set_sensitive(False)
toolbar_box.toolbar.insert(self.save_button, -1)
self.save_button.show()
separator = gtk.SeparatorToolItem()
toolbar_box.toolbar.insert(separator, -1)
separator.show()
button = ToolButton('system-restart')
button.set_tooltip(_('Reiniciar juego'))
button.accelerator = "<Alt><Shift>r"
button.connect('clicked', self.restart_game)
toolbar_box.toolbar.insert(button, -1)
button.show()
self.editor_button = ToolButton('sources')
self.editor_button.set_tooltip(_('Consola'))
self.editor_button.accelerator = "<Ctrl>grave"
self.editor_button.connect('clicked', self.toggle_console)
toolbar_box.toolbar.insert(self.editor_button, -1)
self.editor_button.show()
separator = gtk.SeparatorToolItem()
toolbar_box.toolbar.insert(separator, -1)
separator.show()
button = helpbutton.HelpButton(self)
toolbar_box.toolbar.insert(button, -1)
button.show()
button = ToolButton()
button.props.icon_name = 'activity-about'
button.set_tooltip(_('Acerca de'))
button.accelerator = "<Ctrl>i"
button.connect('clicked', self.run_credits)
toolbar_box.toolbar.insert(button, -1)
button.show()
# Blank space (separator) and Stop button at the end:
separator = gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
toolbar_box.toolbar.insert(separator, -1)
separator.show()
stop_button = StopButton(self)
toolbar_box.toolbar.insert(stop_button, -1)
stop_button.show()
def run_game(self):
spyral.director.init((0,0), fullscreen=False, max_fps=30)
self.game = JUEGO.Juego(self, callback=self.game_ready)
self.box.connect("switch-page", self.redraw)
spyral.director.push(self.game)
self.start()
def run_credits(self, widget):
if not (spyral.director.get_scene()==self.credits):
self.credits = game.credits.Creditos(self.game.size)
spyral.director.push(self.credits)
def start(self):
try:
spyral.director.run(sugar = True)
except AttributeError as detail:
detail2 = traceback.format_exc()
self.box.set_page(0)
self.alert( detail2, "Spyral se ha detenido abruptamente.", 60)
def show_game(self, widget):
self.box.set_page(1)
self.redraw()
def show_editor(self, widget):
if not self.editor:
self.build_editor()
self.box.set_page(2)
self.redraw()
def show_reader(self, widget):
if not self.reader:
self.build_reader()
self.box.set_page(3)
self.redraw()
def restart_game(self, widget):
global JUEGO
import objetos
try:
objetos.reset()
except AttributeError:
pass
self.box.set_page(0)
watch = gtk.gdk.Cursor(gtk.gdk.WATCH)
self.window.set_cursor(watch)
JUEGO = reload(JUEGO)
self.game = JUEGO.Juego(self, callback=self.game_ready)
spyral.director.replace(self.game)
self.start()
def game_ready(self, widget = None):
self.game_button.set_active(True)
self.box.set_page(1)
self._pygamecanvas.grab_focus()
self.window.set_cursor(None)
def read_file(self, file_path):
pass
def write_file(self, file_path):
pass
def can_close(self):
if self.editor:
self.editor.close()
self.box.set_page(0)
try:
spyral.director.quit()
except spyral.exceptions.GameEndException:
pass
finally:
return True
def toggle_console(self, e):
if self._interpreter.props.visible:
self._interpreter.hide()
self._pygamecanvas.grab_focus()
else:
self.p.set_position(160)
self._interpreter.show()
self._interpreter.text.grab_focus()
self.redraw()
def animate_console(self):
easing = spyral.easing.Linear(0,160)
self.p.set_position(0)
class InkToolBar(gtk.Toolbar):
# Constructor
def __init__(self, slideviewer, deck):
gtk.Toolbar.__init__(self)
self.__slideviewer = slideviewer
self.__cur_color = slideviewer.get_color()
self.__cur_color_str = "blue"
self.__cur_pen = slideviewer.get_pen()
self.__deck = deck
self.__deck.connect('slide-redraw', self.update_buttons)
self.__slideviewer.connect('undo-redo-changed', self.update_buttons)
self.__is_instr = False
# Red Ink
self.__red = gtk.RadioToolButton()
self.__red.set_icon_name('red-button')
self.insert(self.__red, -1)
self.__red.show()
#self.__red.set_tooltip('Red Ink')
self.__red.connect('clicked', self.set_ink_color, 1.0, 0.0, 0.0, "red")
# Green Ink
self.__green = gtk.RadioToolButton(group=self.__red)
self.__green.set_icon_name('green-button')
self.insert(self.__green, -1)
self.__green.show()
#self.__green.set_tooltip('Green Ink')
self.__green.connect('clicked', self.set_ink_color, 0.0, 1.0, 0.0, "green")
# Blue Ink
self.__blue = gtk.RadioToolButton(group=self.__red)
self.__blue.set_icon_name('blue-button')
self.insert(self.__blue, -1)
self.__blue.show()
#self.__blue.set_tooltip('Blue Ink')
self.__blue.connect('clicked', self.set_ink_color, 0.0, 0.0, 1.0, "blue")
# Black Ink
self.__black = gtk.RadioToolButton(group=self.__red)
self.__black.set_icon_name('black-button')
self.insert(self.__black, -1)
self.__black.show()
#self.__black.set_tooltip('Black Ink')
self.__black.connect('clicked', self.set_ink_color, 0.0, 0.0, 0.0, "black")
# Separate ink from untensils
separator = gtk.SeparatorToolItem()
separator.set_draw(False)
self.insert(separator, -1)
separator.show()
# Pencil
self.__pencil = gtk.RadioToolButton()
self.__pencil.set_icon_name('tool-pencil')
self.insert(self.__pencil, -1)
self.__pencil.show()
#self.__pencil.set_tooltip('Pencil')
self.__pencil.connect('clicked', self.set_cur_pen, 4)
# Brush
self.__brush = gtk.RadioToolButton(self.__pencil)
self.__brush.set_icon_name('tool-brush')
self.insert(self.__brush, -1)
self.__brush.show()
#self.__brush.set_tooltip('Brush')
self.__brush.connect('clicked', self.set_cur_pen, 8)
# Erase
self.__erase = ToolButton('tool-eraser')
self.insert(self.__erase, -1)
self.__erase.show()
self.__erase.set_tooltip('Erase All Ink')
self.__erase.connect('clicked', self.set_erase)
"""
# Text
self.__text = ToolButton('text')
self.insert(self.__text, -1)
self.__text.show()
self.__text.set_tooltip('Text')
"""
# Separate tools from text
separator = gtk.SeparatorToolItem()
separator.set_draw(False)
self.insert(separator, -1)
separator.show()
# Undo
self.__undo = ToolButton('edit-undo')
self.insert(self.__undo, -1)
self.__undo.show()
self.__undo.set_tooltip('Undo')
self.__undo.connect('clicked', self.undo)
# Redo
self.__redo = ToolButton('edit-redo')
self.insert(self.__redo, -1)
self.__redo.show()
self.__redo.set_tooltip('Redo')
self.__redo.connect('clicked', self.redo)
separator = gtk.SeparatorToolItem()
separator.set_draw(False)
separator.set_expand(True)
self.insert(separator, -1)
separator.show()
self.__submit = ToolButton('dialog-ok') #FIXME (though actually not a terrible icon)
self.insert(self.__submit, -1)
self.__submit.show()
self.__submit.set_tooltip('Broadcast Submission')
self.__submit.connect('clicked', self.submit_ink)
self.__deck.connect('instr_state_propagate', self.instructor_state_cb)
self.set_tool_buttons()
self.show()
def instructor_state_cb(self, widget, is_instr):
self.__is_instr = is_instr
if is_instr:
self.__submit.set_tooltip('Broadcast Submission')
else:
self.__submit.set_tooltip('Submit Ink')
def set_cur_pen(self, widget, size):
self.__slideviewer.set_pen(size)
def set_ink_color(self, widget, r, g, b, color):
self.__slideviewer.set_color(r, g, b)
def set_erase(self, widget):
self.__slideviewer.clear_ink()
def set_tool_buttons(self):
if self.__cur_color == (1.0, 0.0, 0.0):
self.__red.set_active(True)
elif self.__cur_color == (0.0, 1.0, 0.0):
self.__green.set_active(True)
elif self.__cur_color == (0.0, 0.0, 1.0):
self.__blue.set_active(True)
else:
self.__black.set_active(True)
if self.__cur_pen == 2:
self.__pencil.set_active(True)
elif self.__cur_pen == 5:
self.__brush.set_active(True)
def submit_ink(self, widget):
if self.__is_instr:
self.broadcast_ink()
else:
self.__submit.set_sensitive(False)
self.__timer = threading.Timer(3.0, self.reenable_submissions)
self.__timer.start()
self.__slideviewer.submit_ink()
def broadcast_ink(self):
self.__slideviewer.broadcast_ink()
def reenable_submissions(self):
self.__submit.set_sensitive(True)
self.__submit.queue_draw()
def undo(self, widget):
self.__slideviewer.undo()
def redo(self, widget):
self.__slideviewer.redo()
def update_buttons(self, widget=None):
can_undo, can_redo = self.__slideviewer.can_undo_redo()
self.__undo.set_sensitive(can_undo)
self.__redo.set_sensitive(can_redo)
if self.__is_instr:
if self.__deck.getActiveSubmission() == -1:
self.__submit.set_sensitive(False)
else:
self.__submit.set_sensitive(True)
