def build_toolbar(self):
toolbar_box = ToolbarBox()
self.set_toolbar_box(toolbar_box)
toolbar_box.show()
activity_button = ActivityToolbarButton(self)
toolbar_box.toolbar.insert(activity_button, -1)
activity_button.show()
self.blocklist = []
self.radioList = {}
for c in tools.allTools:
button = ToolButton(c.icon)
button.set_tooltip(_(c.toolTip))
button.connect('clicked',self.radioClicked)
toolbar_box.toolbar.insert(button, -1)
button.show()
self.radioList[button] = c.name
separator = gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
toolbar_box.toolbar.insert(separator, -1)
separator.show()
stop_button = StopButton(self)
toolbar_box.toolbar.insert(stop_button, -1)
stop_button.show()
self.show_all()
class TitleBox(VolumesToolbar):
__gtype_name__ = 'TitleBox'
def __init__(self):
VolumesToolbar.__init__(self)
label = gtk.Label()
label.set_markup('<b>%s</b>' % _('Choose an object'))
label.set_alignment(0, 0.5)
self._add_widget(label, expand=True)
self.close_button = ToolButton(icon_name='dialog-cancel')
self.close_button.set_tooltip(_('Close'))
self.insert(self.close_button, -1)
self.close_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()
class ViewToolbar(gtk.Toolbar):
__gtype_name__ = 'ViewToolbar'
def __init__(self):
gtk.Toolbar.__init__(self)
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()
def _zoom_in_cb(self, button):
self.activity.font_increase()
def _zoom_out_cb(self, button):
self.activity.font_decrease()
def set_activity(self, activity):
self.activity = activity
def __init__(self, activity, **kwargs):
gtk.ToolItem.__init__(self)
description_button = ToolButton('edit-description')
description_button.show()
description_button.set_tooltip(_('Description'))
self._palette = description_button.get_palette()
description_box = gtk.HBox()
sw = gtk.ScrolledWindow()
sw.set_size_request(int(gtk.gdk.screen_width() / 2),
2 * style.GRID_CELL_SIZE)
sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
self._text_view = gtk.TextView()
self._text_view.set_left_margin(style.DEFAULT_PADDING)
self._text_view.set_right_margin(style.DEFAULT_PADDING)
self._text_view.set_wrap_mode(gtk.WRAP_WORD_CHAR)
text_buffer = gtk.TextBuffer()
if 'description' in activity.metadata:
text_buffer.set_text(activity.metadata['description'])
self._text_view.set_buffer(text_buffer)
self._text_view.connect('focus-out-event',
self.__description_changed_cb, activity)
sw.add(self._text_view)
description_box.pack_start(sw, False, True, 0)
self._palette.set_content(description_box)
description_box.show_all()
self.add(description_button)
description_button.connect('clicked',
self.__description_button_clicked_cb)
activity.metadata.connect('updated', self.__jobject_updated_cb)
def __init__(self, web_view):
gobject.GObject.__init__(self)
self._web_view = web_view
self._back = ToolButton('go-previous-paired')
self._back.set_tooltip(_('Back'))
self._back.props.sensitive = False
self._back.connect('clicked', self._go_back_cb)
self.insert(self._back, -1)
self._back.show()
self._forward = ToolButton('go-next-paired')
self._forward.set_tooltip(_('Forward'))
self._forward.props.sensitive = False
self._forward.connect('clicked', self._go_forward_cb)
self.insert(self._forward, -1)
self._forward.show()
home = ToolButton('zoom-home')
home.set_tooltip(_('Home'))
home.connect('clicked', self._go_home_cb)
self.insert(home, -1)
home.show()
self._listener = xpcom.server.WrapObject(
ProgressListener(self), interfaces.nsIWebProgressListener)
weak_ref = xpcom.client.WeakReference(self._listener)
mask = interfaces.nsIWebProgress.NOTIFY_STATE_NETWORK | \
interfaces.nsIWebProgress.NOTIFY_LOCATION
self._web_view.web_progress.addProgressListener(self._listener, mask)
def __init__(self, activity, **kwargs):
gtk.ToolItem.__init__(self)
description_button = ToolButton('edit-description')
description_button.show()
description_button.set_tooltip(_('Description'))
self._palette = description_button.get_palette()
description_box = gtk.HBox()
sw = gtk.ScrolledWindow()
sw.set_size_request(int(gtk.gdk.screen_width() / 2),
2 * style.GRID_CELL_SIZE)
sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
self._text_view = gtk.TextView()
self._text_view.set_left_margin(style.DEFAULT_PADDING)
self._text_view.set_right_margin(style.DEFAULT_PADDING)
text_buffer = gtk.TextBuffer()
if 'description' in activity.metadata:
text_buffer.set_text(activity.metadata['description'])
self._text_view.set_buffer(text_buffer)
self._text_view.connect('focus-out-event',
self.__description_changed_cb, activity)
sw.add(self._text_view)
description_box.pack_start(sw, False, True, 0)
self._palette.set_content(description_box)
description_box.show_all()
self.add(description_button)
description_button.connect('clicked',
self.__description_button_clicked_cb)
activity.metadata.connect('updated', self.__jobject_updated_cb)
def __init__(self, handle):
activity.Activity.__init__(self, handle)
self.toolbox = activity.ActivityToolbox(self)
activity_toolbar = self.toolbox.get_activity_toolbar()
activity_toolbar.share.props.visible = False
activity_toolbar.keep.props.visible = False
go_up = ToolButton("gtk-go-up")
go_up.props.tooltip = _("Go Up")
go_up.show()
activity_toolbar.insert(go_up, 2)
refresh = ToolButton("gtk-refresh")
refresh.props.tooltip = _("Refresh")
refresh.show()
activity_toolbar.insert(refresh, 2)
self.set_toolbox(self.toolbox)
self.toolbox.show()
widget = filemanager.Widget()
go_up.connect("clicked", self.go_up_callback, widget)
refresh.connect("clicked", self.refresh_callback, widget)
widget.show()
current_directory = gio.File(path=os.environ["HOME"])
widget.set_current_directory(current_directory.get_uri())
widget.connect("file-menu", self.file_menu)
widget.connect('current-directory-menu', self.current_directory_menu)
self.set_canvas(widget)
self.show()
class ActivityToolbarXO2XO(gtk.Toolbar):
def __init__(self, activity, orientation_left=False):
gtk.Toolbar.__init__(self)
self._activity = activity
if orientation_left == False:
separator = gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
self.insert(separator,-1)
separator.show()
self._object_insert = ToolButton('object-insert')
self.insert(self._object_insert, -1)
self._object_insert.show()
self.stop = StopButton(activity)
self.insert(self.stop, -1)
self.stop.show()
self._object_insert.connect('clicked', self.insertImage, activity)
def insertImage(self, widget, activity):
self._activity = activity
chooser = ObjectChooser('Choose image', self._activity,
gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT)
try:
result = chooser.run()
if result == gtk.RESPONSE_ACCEPT:
jobject = chooser.get_selected_object()
if jobject and jobject.file_path:
self._activity.toUploadChosen(jobject.file_path)
finally:
chooser.destroy()
del chooser
def __init__(self, handle):
activity.Activity.__init__(self, handle)
self.toolbox = activity.ActivityToolbox(self)
activity_toolbar = self.toolbox.get_activity_toolbar()
activity_toolbar.share.props.visible = False
activity_toolbar.keep.props.visible = False
connect = ToolButton("gtk-refresh")
connect.props.tooltip = "Conectar"
connect.connect("clicked", self.connect_vnc)
connect.show()
activity_toolbar.insert(connect, 2)
fullscreen = ToolButton("view-fullscreen")
fullscreen.props.tooltip = "Pantalla Completa"
fullscreen.connect("clicked", self.fullscreen_cb)
fullscreen.show()
activity_toolbar.insert(fullscreen, 2)
self.set_toolbox(self.toolbox)
self.toolbox.show()
area = gtk.ScrolledWindow()
area.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
area.show()
self.vnc = GRFBWidget()
area.add_with_viewport(self.vnc)
self.vnc.show()
self.set_canvas(area)
self.present()
self.maximize()
self.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()
# Pause/Play button:
stop_play = ToolButton('media-playback-stop')
stop_play.set_tooltip(_("Stop"))
stop_play.set_accelerator(_('<ctrl>space'))
stop_play.connect('clicked', self._stop_play_cb)
stop_play.show()
toolbar_box.toolbar.insert(stop_play, -1)
# Blank space (separator) and Stop button at the end:
separator = gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
toolbar_box.toolbar.insert(separator, -1)
separator.show()
stop_button = StopButton(self)
toolbar_box.toolbar.insert(stop_button, -1)
stop_button.show()
class TitleBox(VolumesToolbar):
__gtype_name__ = 'TitleBox'
def __init__(self):
VolumesToolbar.__init__(self)
label = gtk.Label()
label.set_markup('<b>%s</b>' % _('Choose an object'))
label.set_alignment(0, 0.5)
self._add_widget(label, expand=True)
self.close_button = ToolButton(icon_name='dialog-cancel')
self.close_button.set_tooltip(_('Close'))
self.insert(self.close_button, -1)
self.close_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()
class InstrumentToolbar(gtk.Toolbar):
''' The toolbar for adding new instruments '''
def __init__(self, activity):
gtk.Toolbar.__init__(self)
self.activity = activity
self.new_instruments = []
self._name_entry = gtk.Entry()
self._name_entry.set_text(_('my instrument'))
self._name_entry_changed_id = self._name_entry.connect(
'changed', self.update_name_entry)
if hasattr(self._name_entry, 'set_tooltip_text'):
self._name_entry.set_tooltip_text(_('Enter instrument name.'))
self._name_entry.set_width_chars(24)
self._name_entry.show()
toolitem = gtk.ToolItem()
toolitem.add(self._name_entry)
self.insert(toolitem, -1)
toolitem.show()
self._notes_combo = ComboBox()
n = 0
for octave in range(9):
for i in range(len(NOTES)):
if octave == 0 and i < 9: # Start with A0
continue
self._notes_combo.append_item(n, note_octave(i, octave), None)
n += 1
self._notes_combo.set_active(48) # A4
if hasattr(self._notes_combo, 'set_tooltip_text'):
self._notes_combo.set_tooltip_text(_('Notes'))
self._notes_tool = ToolComboBox(self._notes_combo)
self.insert(self._notes_tool, -1)
self._notes_tool.show()
self._new_note = ToolButton('list-add')
self._new_note.show()
self.insert(self._new_note, -1)
self._new_note.set_tooltip(_('Add a new note.'))
self._new_note.connect('clicked', self.new_note_cb)
def update_name_entry(self, *args):
''' Add name to INSTRUMENT_DICT and combo box '''
# Wait until a note has been added...
return
def new_note_cb(self, *args):
''' Add a new note to instrument tuning list '''
name = self._name_entry.get_text()
if name not in INSTRUMENT_DICT:
INSTRUMENT_DICT[name] = []
self.activity.tuning_toolbar.instrument.append(name)
i = len(self.activity.tuning_toolbar.instrument)
self.activity.tuning_toolbar.instrument_combo.append_item(
i, name, None)
self.new_instruments.append(name)
i = self._notes_combo.get_active()
freq = A0 * pow(TWELTHROOT2, i)
if freq not in INSTRUMENT_DICT[name]:
INSTRUMENT_DICT[name].append(freq)
def __init__(self, web_view):
gobject.GObject.__init__(self)
self._web_view = web_view
self._back = ToolButton('go-previous-paired')
self._back.set_tooltip(_('Back'))
self._back.props.sensitive = False
self._back.connect('clicked', self._go_back_cb)
self.insert(self._back, -1)
self._back.show()
self._forward = ToolButton('go-next-paired')
self._forward.set_tooltip(_('Forward'))
self._forward.props.sensitive = False
self._forward.connect('clicked', self._go_forward_cb)
self.insert(self._forward, -1)
self._forward.show()
home = ToolButton('zoom-home')
home.set_tooltip(_('Home'))
home.connect('clicked', self._go_home_cb)
self.insert(home, -1)
home.show()
progress_listener = self._web_view.progress
progress_listener.connect('location-changed',
self._location_changed_cb)
progress_listener.connect('loading-stop', self._loading_stop_cb)
class T2Activity(activity.Activity):
def xois_clicked(self, widget, data=None):
self.webview.load_uri('http://teach-teacher.ep.io/slides/1')
def guide_clicked(self, widget, data=None):
self.webview.load_uri('http://teach-teacher.ep.io/slides/17')
def back_clicked(self, widget, data=None):
if self.webview.get_web_navigation().canGoBack:
self.webview.get_web_navigation().goBack()
def home_clicked(self, widget, data=None):
self.webview.load_uri('http://147.47.120.20/~tsquare/menu.php')
def __init__(self, handle):
print "running activity init", handle
activity.Activity.__init__(self, handle)
print "activity running"
self.set_title('Teach Teacher')
toolbox = activity.ActivityToolbox(self)
self.set_toolbox(toolbox)
toolbar = gtk.Toolbar()
self.goBack = ToolButton('go-left')
self.goBack.set_tooltip("Go Back")
self.goBack.connect('clicked', self.back_clicked)
toolbar.insert(self.goBack, -1)
self.goBack.show()
self.home = ToolButton('go-home')
self.home.set_tooltip("Home")
self.home.connect('clicked', self.home_clicked)
toolbar.insert(self.home, -1)
self.home.show()
self.xois = ToolButton('computer-xo')
self.xois.set_tooltip("T's XO")
self.xois.connect('clicked', self.xois_clicked)
# toolbar.insert(self.xois, -1)
# self.xois.show()
self.guide = ToolButton('go-next')
self.guide.set_tooltip("T's Guide")
self.guide.connect('clicked', self.guide_clicked)
# toolbar.insert(self.guide, -1)
# self.guide.show()
toolbar.show()
toolbox.add_toolbar("Menu", toolbar)
toolbox.show()
self.webview = WebView()
self.set_canvas(self.webview)
self.webview.show()
self.webview.load_uri('http://147.47.120.20/~tsquare/menu.php')
print "AT END OF THE CLASS"
class EditToolbar(activity.EditToolbar):
__gtype_name__ = 'EditToolbar'
def __init__(self):
activity.EditToolbar.__init__(self)
separator = gtk.SeparatorToolItem()
separator.set_draw(False)
separator.set_expand(True)
self.insert(separator, -1)
separator.show()
search_item = gtk.ToolItem()
self._search_entry = gtk.Entry()
self._search_entry.connect('activate', self._search_entry_activate_cb)
width = int(gtk.gdk.screen_width() / 3)
self._search_entry.set_size_request(width, -1)
search_item.add(self._search_entry)
self._search_entry.show()
self.insert(search_item, -1)
search_item.show()
self._prev = ToolButton('go-previous-paired')
self._prev.set_tooltip(_('Previous'))
self._prev.props.sensitive = False
self._prev.connect('clicked', self._find_prev_cb)
self.insert(self._prev, -1)
self._prev.show()
self._next = ToolButton('go-next-paired')
self._next.set_tooltip(_('Next'))
self._next.props.sensitive = False
self._next.connect('clicked', self._find_next_cb)
self.insert(self._next, -1)
self._next.show()
def set_activity(self, activity):
self.activity = activity
def _search_entry_activate_cb(self, entry):
current_page = self.activity.get_current_page()
self.activity.find_begin(entry.props.text)
self._update_find_buttons()
def _find_changed_cb(self, page, spec):
self._update_find_buttons()
def _find_prev_cb(self, button):
self.activity.find_previous()
def _find_next_cb(self, button):
self.activity.find_next()
def _update_find_buttons(self):
self._prev.props.sensitive = self.activity.can_find_previous()
self._next.props.sensitive = self.activity.can_find_next()
class MainToolbar(gtk.Toolbar):
""" Main toolbar of the control panel
"""
__gtype_name__ = 'MainToolbar'
__gsignals__ = {
'stop-clicked': (gobject.SIGNAL_RUN_FIRST,
gobject.TYPE_NONE,
([])),
'search-changed': (gobject.SIGNAL_RUN_FIRST,
gobject.TYPE_NONE,
([str])),
}
def __init__(self):
gtk.Toolbar.__init__(self)
self._add_separator()
tool_item = gtk.ToolItem()
self.insert(tool_item, -1)
tool_item.show()
self._search_entry = iconentry.IconEntry()
self._search_entry.set_icon_from_name(iconentry.ICON_ENTRY_PRIMARY,
'system-search')
self._search_entry.add_clear_button()
self._search_entry.set_width_chars(25)
self._search_entry.connect('changed', self.__search_entry_changed_cb)
tool_item.add(self._search_entry)
self._search_entry.show()
self._add_separator(True)
self.stop = ToolButton(icon_name='dialog-cancel')
self.stop.set_tooltip(_('Done'))
self.stop.connect('clicked', self.__stop_clicked_cb)
self.stop.show()
self.insert(self.stop, -1)
self.stop.show()
def get_entry(self):
return self._search_entry
def _add_separator(self, expand=False):
separator = gtk.SeparatorToolItem()
separator.props.draw = False
if expand:
separator.set_expand(True)
else:
separator.set_size_request(style.DEFAULT_SPACING, -1)
self.insert(separator, -1)
separator.show()
def __search_entry_changed_cb(self, search_entry):
self.emit('search-changed', search_entry.props.text)
def __stop_clicked_cb(self, button):
self.emit('stop-clicked')
class NamingToolbar(gtk.Toolbar):
""" Toolbar of the naming alert
"""
__gtype_name__ = 'SugarNamingToolbar'
__gsignals__ = {
'keep-clicked': (gobject.SIGNAL_RUN_FIRST,
gobject.TYPE_NONE,
([]))
}
def __init__(self):
gtk.Toolbar.__init__(self)
client = gconf.client_get_default()
color = XoColor(client.get_string('/desktop/sugar/user/color'))
icon = Icon()
icon.set_from_icon_name('activity-journal',
gtk.ICON_SIZE_LARGE_TOOLBAR)
icon.props.xo_color = color
self._add_widget(icon)
self._add_separator()
self._title = gtk.Label(_('Name this entry'))
self._add_widget(self._title)
self._add_separator(True)
self._keep_button = ToolButton('dialog-ok', tooltip=_('Keep'))
self._keep_button.props.accelerator = 'Return'
self._keep_button.connect('clicked', self.__keep_button_clicked_cb)
self.insert(self._keep_button, -1)
self._keep_button.show()
def _add_separator(self, expand=False):
separator = gtk.SeparatorToolItem()
separator.props.draw = False
if expand:
separator.set_expand(True)
else:
separator.set_size_request(style.DEFAULT_SPACING, -1)
self.insert(separator, -1)
separator.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 __keep_button_clicked_cb(self, widget, data=None):
self.emit('keep-clicked')
def __init__(self, handle):
activity.Activity.__init__(self, handle)
toolbar_box = ToolbarBox()
activity_button = ActivityToolbarButton(self)
toolbar_box.toolbar.insert(activity_button, 0)
activity_button.show()
separator = gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
toolbar_box.toolbar.insert(separator, -1)
separator.show()
change_color_button = ToolButton('toolbar-colors')
change_color_button.set_tooltip(_('Click here to change the background color'))
change_color_button.connect('clicked', self.on_change_color_clicked)
toolbar_box.toolbar.insert(change_color_button, -1)
change_color_button.show()
separator = gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
toolbar_box.toolbar.insert(separator, -1)
separator.show()
stop_button = StopButton(self)
stop_button.props.accelerator = '<Ctrl><Shift>Q'
toolbar_box.toolbar.insert(stop_button, -1)
stop_button.show()
button = gtk.Button("Click here to change the background color")
button.connect('clicked', self.on_change_color_clicked)
button.set_flags(gtk.CAN_DEFAULT)
button.grab_default()
toolbar_box.add(button)
button.show()
self.set_toolbar_box(toolbar_box)
toolbar_box.show()
canvas = gtk.HBox(False, 0)
color = gtk.gdk.color_parse("skyblue")
self.d_area = gtk.DrawingArea()
self.d_area.connect("expose-event", self.expose)
self.d_area.modify_bg(gtk.STATE_NORMAL, color)
canvas.add(self.d_area)
self.set_canvas(canvas)
self.show_all()
class NamingToolbar(gtk.Toolbar):
""" Toolbar of the naming alert
"""
__gtype_name__ = 'MyNamingToolbar'
__gsignals__ = {
'keep-clicked': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE, ([])),
}
def __init__(self):
gtk.Toolbar.__init__(self)
client = gconf.client_get_default()
color = XoColor(client.get_string('/desktop/sugar/user/color'))
icon = Icon()
icon.set_from_icon_name('activity-journal',
gtk.ICON_SIZE_LARGE_TOOLBAR)
icon.props.xo_color = color
self._add_widget(icon)
self._add_separator()
self._title = gtk.Label(_('Describe your activity'))
self._add_widget(self._title)
self._add_separator(True)
self._keep_button = ToolButton('dialog-ok', tooltip=_('Keep'))
self._keep_button.props.accelerator = '<Ctrl>s'
self._keep_button.connect('clicked', self.__keep_button_clicked_cb)
self.insert(self._keep_button, -1)
self._keep_button.show()
def _add_separator(self, expand=False):
separator = gtk.SeparatorToolItem()
separator.props.draw = False
if expand:
separator.set_expand(True)
else:
separator.set_size_request(style.DEFAULT_SPACING, -1)
self.insert(separator, -1)
separator.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 __keep_button_clicked_cb(self, widget, data=None):
self.emit('keep-clicked')
class ImageToolbar(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._image = ToolButton('insert-image')
self._image.set_tooltip(_('Insert Image'))
self._image_id = self._image.connect('clicked', self._image_cb)
self.insert(self._image, -1)
self._image.show()
self._abiword_canvas.connect('image-selected', self._image_selected_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 _image_cb(self, button):
chooser = ObjectChooser(
_('Choose image'), self._parent,
gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT)
try:
result = chooser.run()
if result == gtk.RESPONSE_ACCEPT:
logging.debug('ObjectChooser: %r' %
chooser.get_selected_object())
jobject = chooser.get_selected_object()
if jobject and jobject.file_path:
self._abiword_canvas.insert_image(jobject.file_path, True)
finally:
chooser.destroy()
del chooser
def _image_selected_cb(self, abi, b):
if b:
self._toolbox.set_current_toolbar(TOOLBAR_IMAGE)
self._abiword_canvas.grab_focus() # hack: bad toolbox, bad!
def _load_toolbar(self):
toolbar = gtk.Toolbar()
# Remove Feed Palette
remove_button = ToolButton(icon_name='list-remove')
vbox = gtk.VBox()
label = gtk.Label(_('Really delete feed?'))
vbox.pack_start(label)
hbox = gtk.HBox()
expander_label = gtk.Label(' ')
hbox.pack_start(expander_label)
#b = gtk.Button(icon_name='stock-remove')
b = ToolButton(icon_name='list-remove')
#b.set_use_stock(True)
b.connect('clicked', self._on_remove_feed_activate)
hbox.pack_start(b, False)
vbox.pack_start(hbox)
palette = Palette(_('Remove Feed?'))
palette.set_content(vbox)
vbox.show_all()
remove_button.set_palette(palette)
toolbar.insert(remove_button, -1)
remove_button.show()
# Add Feed Palette
button = ToolButton(icon_name='list-add')
toolbar.insert(button, -1)
button.show()
self._add_feed_dialog = AddFeedDialog.AddFeedDialog(
gtk.glade.XML(os.path.join(self.glade_prefix, 'penguintv.glade'),
"window_add_feed", 'penguintv'), self) #MAGIC
content = self._add_feed_dialog.extract_content()
content.show_all()
#button.connect('clicked', self._add_feed_dialog.show)
palette = Palette(_('Subscribe to Feed'))
palette.set_content(content)
button.set_palette(palette)
self._feedlist = gtk.ListStore(int, str, str)
self._combo = gtk.ComboBox(self._feedlist)
cell = gtk.CellRendererText()
self._combo.pack_start(cell, True)
self._combo.add_attribute(cell, 'text', 1)
self._combo.connect("changed", self._on_combo_select)
toolcombo = ToolComboBox(self._combo)
toolbar.insert(toolcombo, -1)
toolcombo.show_all()
toolbar.show()
return toolbar
def __init__(self, parent, web_view):
gobject.GObject.__init__(self)
self._help = parent
self._web_view = web_view
self._back = ToolButton('go-previous-paired')
self._back.set_tooltip(_('Back'))
self._back.props.sensitive = False
self._back.connect('clicked', self._go_back_cb)
self.insert(self._back, -1)
self._back.show()
self._forward = ToolButton('go-next-paired')
self._forward.set_tooltip(_('Forward'))
self._forward.props.sensitive = False
self._forward.connect('clicked', self._go_forward_cb)
self.insert(self._forward, -1)
self._forward.show()
home = ToolButton('zoom-home')
home.set_tooltip(_('Home'))
home.connect('clicked', self._go_home_cb)
self.insert(home, -1)
home.show()
separator = gtk.SeparatorToolItem()
separator.set_draw(False)
separator.set_expand(True)
self.insert(separator, -1)
separator.show()
stop_button = ToolButton('activity-stop')
stop_button.set_tooltip(_('Stop'))
#stop_button.props.accelerator = '<Ctrl>Q'
stop_button.connect('clicked', self.__stop_clicked_cb)
self.insert(stop_button, -1)
stop_button.show()
if version < 0.838:
self._listener = xpcom.server.WrapObject(
EarlyListener(self), interfaces.nsIWebProgressListener)
weak_ref = xpcom.client.WeakReference(self._listener)
mask = interfaces.nsIWebProgress.NOTIFY_STATE_NETWORK | \
interfaces.nsIWebProgress.NOTIFY_LOCATION
self._web_view.web_progress.addProgressListener(
self._listener, mask)
else:
progress_listener = self._web_view.progress
progress_listener.connect('location-changed',
self._location_changed_cb)
progress_listener.connect('loading-stop', self._loading_stop_cb)
def enable_zoom_bestfit(self, on_zoom_bestfit):
"""
Enables zoom-to-best-fit support on this toolbar.
@param on_zoom_bestfit: The callback function to be called when user
wants to zoom to best extent.
"""
zoom_best_fit_btn = ToolButton('zoom-best-fit')
zoom_best_fit_btn.set_tooltip(_('Zoom best fitting extent.'))
zoom_best_fit_btn.connect('clicked', on_zoom_bestfit)
zoom_best_fit_btn.show()
self.insert(zoom_best_fit_btn, -1)
class Toolbar(gtk.Toolbar):
def __init__(self, web_view):
gobject.GObject.__init__(self)
self._web_view = web_view
self._back = ToolButton('go-previous-paired')
self._back.set_tooltip(_('Back'))
self._back.props.sensitive = False
self._back.connect('clicked', self._go_back_cb)
self.insert(self._back, -1)
self._back.show()
self._forward = ToolButton('go-next-paired')
self._forward.set_tooltip(_('Forward'))
self._forward.props.sensitive = False
self._forward.connect('clicked', self._go_forward_cb)
self.insert(self._forward, -1)
self._forward.show()
home = ToolButton('zoom-home')
home.set_tooltip(_('Home'))
home.connect('clicked', self._go_home_cb)
self.insert(home, -1)
home.show()
progress_listener = self._web_view.progress
progress_listener.connect('location-changed',
self._location_changed_cb)
progress_listener.connect('loading-stop', self._loading_stop_cb)
def _location_changed_cb(self, progress_listener, uri):
self.update_navigation_buttons()
def _loading_stop_cb(self, progress_listener):
self.update_navigation_buttons()
def update_navigation_buttons(self):
can_go_back = self._web_view.web_navigation.canGoBack
self._back.props.sensitive = can_go_back
can_go_forward = self._web_view.web_navigation.canGoForward
self._forward.props.sensitive = can_go_forward
def _go_back_cb(self, button):
self._web_view.web_navigation.goBack()
def _go_forward_cb(self, button):
self._web_view.web_navigation.goForward()
def _go_home_cb(self, button):
self._web_view.load_uri(HOME)
def _load_toolbar(self):
toolbar = gtk.Toolbar()
# Remove Feed Palette
remove_button = ToolButton(icon_name='list-remove')
vbox = gtk.VBox()
label = gtk.Label(_('Really delete feed?'))
vbox.pack_start(label)
hbox = gtk.HBox()
expander_label = gtk.Label(' ')
hbox.pack_start(expander_label)
#b = gtk.Button(icon_name='stock-remove')
b = ToolButton(icon_name='list-remove')
#b.set_use_stock(True)
b.connect('clicked', self._on_remove_feed_activate)
hbox.pack_start(b, False)
vbox.pack_start(hbox)
palette = Palette(_('Remove Feed?'))
palette.set_content(vbox)
vbox.show_all()
remove_button.set_palette(palette)
toolbar.insert(remove_button, -1)
remove_button.show()
# Add Feed Palette
button = ToolButton(icon_name='list-add')
toolbar.insert(button, -1)
button.show()
self._add_feed_dialog = AddFeedDialog.AddFeedDialog(gtk.glade.XML(os.path.join(self.glade_prefix, 'penguintv.glade'), "window_add_feed",'penguintv'), self) #MAGIC
content = self._add_feed_dialog.extract_content()
content.show_all()
#button.connect('clicked', self._add_feed_dialog.show)
palette = Palette(_('Subscribe to Feed'))
palette.set_content(content)
button.set_palette(palette)
self._feedlist = gtk.ListStore(int, str, str)
self._combo = gtk.ComboBox(self._feedlist)
cell = gtk.CellRendererText()
self._combo.pack_start(cell, True)
self._combo.add_attribute(cell, 'text', 1)
self._combo.connect("changed", self._on_combo_select)
toolcombo = ToolComboBox(self._combo)
toolbar.insert(toolcombo, -1)
toolcombo.show_all()
toolbar.show()
return toolbar
def __init__(self, activity):
self._activity = activity
gtk.ToolItem.__init__(self)
help_button = ToolButton('toolbar-help')
help_button.set_tooltip(_('Ayuda'))
self.add(help_button)
help_button.show()
self._palette = help_button.get_palette()
help_button.connect('clicked', self.__help_button_clicked_cb)
def __init__(self, activity):
self._activity = activity
gtk.ToolItem.__init__(self)
help_button = ToolButton('toolbar-help')
help_button.set_tooltip(_('Ayuda'))
self.add(help_button)
help_button.show()
self._palette = help_button.get_palette()
help_button.connect('clicked', self.__help_button_clicked_cb)
def __init__(self, activity):
self._activity = activity
self._current_palette = 'turtle'
gtk.ToolItem.__init__(self)
help_button = ToolButton('help-toolbar')
help_button.set_tooltip(_('Help'))
self.add(help_button)
help_button.show()
self._palette = help_button.get_palette()
help_button.connect('clicked', self.__help_button_clicked_cb)
def __init__(self, activity):
self._activity = activity
self._current_palette = 'turtle'
gtk.ToolItem.__init__(self)
help_button = ToolButton('help-toolbar')
help_button.set_tooltip(_('Help'))
self.add(help_button)
help_button.show()
self._palette = help_button.get_palette()
help_button.connect('clicked', self.__help_button_clicked_cb)
class T2Activity(activity.Activity):
def xois_clicked(self, widget, data=None):
self.webview.load_uri('http://teach-teacher.ep.io/slides/1')
def guide_clicked(self, widget, data=None):
self.webview.load_uri('http://teach-teacher.ep.io/slides/17')
def diary_clicked(self, widget, data=None):
self.webview.load_uri('http://laptop.org/')
def society_clicked(self, widget, data=None):
self.webview.load_uri('http://147.47.120.20/~olpc_community/')
def __init__(self, handle):
print "running activity init", handle
activity.Activity.__init__(self, handle)
print "activity running"
self.set_title('Teach Teacher')
toolbox = activity.ActivityToolbox(self)
self.set_toolbox(toolbox)
toolbar = gtk.Toolbar()
self.xois = ToolButton('computer-xo')
self.xois.set_tooltip("T's XO")
self.xois.connect('clicked', self.xois_clicked)
toolbar.insert(self.xois, -1)
self.xois.show()
self.guide = ToolButton('go-next')
self.guide.set_tooltip("T's Guide")
self.guide.connect('clicked', self.guide_clicked)
toolbar.insert(self.guide, -1)
self.guide.show()
self.diary = ToolButton('activity-journal')
self.diary.set_tooltip("T's Diary")
self.diary.connect('clicked', self.diary_clicked)
toolbar.insert(self.diary, -1)
self.diary.show()
self.society = ToolButton('zoom-neighborhood')
self.society.set_tooltip("T's Society")
self.society.connect('clicked', self.society_clicked)
toolbar.insert(self.society, -1)
self.society.show()
toolbar.show()
toolbox.add_toolbar("Menu", toolbar)
toolbox.show()
self.webview = WebView()
self.set_canvas(self.webview)
self.webview.show()
self.webview.load_uri('http://teach-teacher.ep.io/')
print "AT END OF THE CLASS"
class EditToolbar(gtk.Toolbar):
"""Provides the standard edit toolbar for Activities.
Members:
undo -- the undo button
redo -- the redo button
copy -- the copy button
paste -- the paste button
separator -- A separator between undo/redo and copy/paste
This class only provides the 'edit' buttons in a standard layout,
your activity will need to either hide buttons which make no sense for your
Activity, or you need to connect the button events to your own callbacks:
## Example from Read.activity:
# Create the edit toolbar:
self._edit_toolbar = EditToolbar(self._view)
# Hide undo and redo, they're not needed
self._edit_toolbar.undo.props.visible = False
self._edit_toolbar.redo.props.visible = False
# Hide the separator too:
self._edit_toolbar.separator.props.visible = False
# As long as nothing is selected, copy needs to be insensitive:
self._edit_toolbar.copy.set_sensitive(False)
# When the user clicks the button, call _edit_toolbar_copy_cb()
self._edit_toolbar.copy.connect('clicked', self._edit_toolbar_copy_cb)
# Add the edit toolbar:
toolbox.add_toolbar(_('Edit'), self._edit_toolbar)
# And make it visible:
self._edit_toolbar.show()
"""
def __init__(self):
gtk.Toolbar.__init__(self)
self.undo = ToolButton('edit-undo')
self.undo.set_tooltip(_('Undo'))
self.insert(self.undo, -1)
self.undo.show()
self.redo = ToolButton('edit-redo')
self.redo.set_tooltip(_('Redo'))
self.insert(self.redo, -1)
self.redo.show()
self.separator = gtk.SeparatorToolItem()
self.separator.set_draw(True)
self.insert(self.separator, -1)
self.separator.show()
self.copy = ToolButton('edit-copy')
self.copy.set_tooltip(_('Copy'))
self.insert(self.copy, -1)
self.copy.show()
self.paste = ToolButton('edit-paste')
self.paste.set_tooltip(_('Paste'))
self.insert(self.paste, -1)
self.paste.show()
class TestPalette(Test):
def __init__(self):
Test.__init__(self)
toolbar = gtk.Toolbar()
self._invoker = ToolButton('go-previous')
toolbar.insert(self._invoker, -1)
self._invoker.show()
self.pack_start(toolbar, False)
toolbar.show()
def set_palette(self, palette):
self._invoker.set_palette(palette)
def addButton(self, nameID, image1path, image2path, tooltip1, tooltip2, cb):
button = ToolButton()
button.image1 = gtk.Image()
button.image1.set_from_file(image1path)
button.image2 = gtk.Image()
button.image2.set_from_file(image2path)
button.image1.show()
button.nameID = nameID
button.tooltip1, button.tooltip2 = tooltip1, tooltip2
button.set_icon_widget(button.image1)
button.connect('clicked', cb)
button.set_tooltip(_(button.tooltip1))
button.active = False
self.insert(button, -1)
button.show()
return button
def addButton(self, nameID, image1path, image2path, tooltip1, tooltip2, cb):
button = ToolButton()
log.info("addButtonIMAGE PATH ____ " + image1path )
button.image1 = gtk.Image()
button.image1.set_from_file(image1path)
button.image2 = gtk.Image()
button.image2.set_from_file(image2path)
button.image1.show()
button.tooltip1, button.tooltip2 = tooltip1, tooltip2
button.set_icon_widget(button.image1)
button.connect('clicked', cb)
button.set_tooltip(_(button.tooltip1))
button.nameID = nameID
self.toolbar_box.toolbar.insert(button, -1)
button.show()
self.nameID.update({nameID:button})
def __init__(self, title, bundle_path, document_path):
gtk.Toolbar.__init__(self)
self._add_separator()
activity_bundle = ActivityBundle(bundle_path)
file_name = activity_bundle.get_icon()
if document_path is not None and os.path.exists(document_path):
document_button = DocumentButton(file_name, document_path, title)
document_button.connect('toggled', self.__button_toggled_cb,
document_path)
self.insert(document_button, -1)
document_button.show()
self._add_separator()
if bundle_path is not None and os.path.exists(bundle_path):
activity_button = RadioToolButton()
icon = Icon(file=file_name,
icon_size=gtk.ICON_SIZE_LARGE_TOOLBAR,
fill_color=style.COLOR_TRANSPARENT.get_svg(),
stroke_color=style.COLOR_WHITE.get_svg())
activity_button.set_icon_widget(icon)
icon.show()
if document_path is not None:
activity_button.props.group = document_button
activity_button.props.tooltip = _('Activity Bundle Source')
activity_button.connect('toggled', self.__button_toggled_cb,
bundle_path)
self.insert(activity_button, -1)
activity_button.show()
self._add_separator()
text = _('View source: %r') % title
label = gtk.Label()
label.set_markup('<b>%s</b>' % text)
label.set_alignment(0, 0.5)
self._add_widget(label)
self._add_separator(True)
stop = ToolButton(icon_name='dialog-cancel')
stop.set_tooltip(_('Close'))
stop.connect('clicked', self.__stop_clicked_cb)
stop.show()
self.insert(stop, -1)
stop.show()
def __init__(self):
gtk.HBox.__init__(self)
self.toolbar = VTray()
copy = ToolButton("edit-copy")
copy.set_tooltip('Copy')
copy.connect("clicked", self.__copy_cb)
copy.show()
self.toolbar.add_item(copy, -1)
paste = ToolButton("edit-paste")
paste.set_tooltip("Paste")
paste.connect("clicked", self.__paste_cb)
paste.show()
self.toolbar.add_item(paste, -1)
fgcolor = ColorToolButton()
fgcolor.get_child()._title = "Font Color"
self.toolbar.add_item(fgcolor, -1)
fgcolor.connect('notify::color', self._fgcolor_cb)
fgcolor.show_all()
bgcolor = ColorToolButton()
bgcolor.get_child()._title = "Background Color"
bgcolor.connect('notify::color', self._bgcolor_cb)
self.toolbar.add_item(bgcolor, -1)
bgcolor.show_all()
self.console = Console()
self.console.set_bgcolor(gtk.gdk.color_parse("#FFFFFF"))
self.console.set_fgcolor(gtk.gdk.color_parse("#000000"))
bgcolor.set_color(gtk.gdk.color_parse("#FFFFFF"))
fgcolor.set_color(gtk.gdk.color_parse("#000000"))
self.console.show()
font = ToolButton("format-text")
font.set_tooltip("Console Font")
fontselection = gtk.FontSelection()
fontselection.get_family_list().get_selection().connect("changed", self.update_font, fontselection)
fontselection.get_face_list().get_selection().connect("changed", self.update_font, fontselection)
fontselection.get_size_entry().connect("changed", self.update_font, fontselection)
fontselection.get_size_entry().connect("activate", self.update_font, fontselection)
fontselection.show()
font.props.palette.set_content(fontselection)
fontselection.set_font_name("Monospace Regular 10")
font.show()
self.toolbar.add_item(font, -1)
reset = ToolButton("view-refresh")
reset.set_tooltip("Reset Console")
reset.connect("clicked", self.reset)
reset.show()
self.toolbar.add_item(reset, -1)
self.toolbar.show()
self.pack_start(self.toolbar, False, True, 0)
self.console.run_command("python")
self.pack_start(self.console)
def button_factory(icon_name, tooltip, callback, toolbar, cb_arg=None,
accelerator=None):
'''Factory for making toolbar buttons'''
my_button = ToolButton(icon_name)
my_button.set_tooltip(tooltip)
my_button.props.sensitive = True
if accelerator is not None:
my_button.props.accelerator = accelerator
if cb_arg is not None:
my_button.connect('clicked', callback, cb_arg)
else:
my_button.connect('clicked', callback)
if hasattr(toolbar, 'insert'): # the main toolbar
toolbar.insert(my_button, -1)
else: # or a secondary toolbar
toolbar.props.page.insert(my_button, -1)
my_button.show()
return my_button
def build_toolbar(self):
self.max_participants = 1
toolbox = ToolbarBox()
activity_button = ActivityToolbarButton(self)
toolbox.toolbar.insert(activity_button, -1)
activity_button.show()
pano_toolbar = toolbox.toolbar
new_button = ToolButton('stock_refresh')
new_button.set_tooltip(_('New Panorama'))
new_button.connect('clicked', self.new_event)
pano_toolbar.insert(new_button, -1)
new_button.show()
capture_button = ToolButton('add_capture')
capture_button.set_tooltip(_('Add a capture to the Panorama'))
capture_button.connect('clicked', self.capture_event)
pano_toolbar.insert(capture_button, -1)
capture_button.show()
stitch_button = ToolButton('format-columns-triple')
stitch_button.set_tooltip(_('Stitch Panorama'))
stitch_button.connect('clicked', self.stitch_event)
pano_toolbar.insert(stitch_button, -1)
stitch_button.show()
stiching_auto = ToolButton('media-playback-start')
stiching_auto.set_tooltip(_('Enable auto-stitch'))
stiching_auto.connect('clicked', self.change_stich)
pano_toolbar.insert(stiching_auto, -1)
save_button = ToolButton('filesave')
save_button.set_tooltip(_('Save Panorama'))
save_button.connect('clicked', self.save_event)
pano_toolbar.insert(save_button, -1)
save_button.show()
separator = gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
pano_toolbar.insert(separator,-1)
stop_button = StopButton(self)
stop_button.props.accelerator = '<Ctrl>q'
pano_toolbar.insert(stop_button, -1)
stop_button.show()
self.set_toolbar_box(toolbox)
toolbox.show_all()
def button_factory(icon_name, toolbar, callback, cb_arg=None, tooltip=None,
accelerator=None):
'''Factory for making toolbar buttons'''
button = ToolButton(icon_name)
if tooltip is not None:
button.set_tooltip(tooltip)
button.props.sensitive = True
if accelerator is not None:
button.props.accelerator = accelerator
if cb_arg is not None:
button.connect('clicked', callback, cb_arg)
else:
button.connect('clicked', callback)
if hasattr(toolbar, 'insert'): # the main toolbar
toolbar.insert(button, -1)
else: # or a secondary toolbar
toolbar.props.page.insert(button, -1)
button.show()
return button
class ViewToolbar(gtk.Toolbar):
__gtype_name__ = 'ViewToolbar'
__gsignals__ = {
'needs-update-size':
(gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE, ([])),
'go-fullscreen': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE, ([]))
}
def __init__(self):
gtk.Toolbar.__init__(self)
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 fullscreen_cb(self, button):
self.emit('go-fullscreen')
class RecordToolbar(gtk.Toolbar):
def __init__(self, jam):
gtk.Toolbar.__init__(self)
def _insertSeparator(x=1):
for i in range(x):
self.separator = gtk.SeparatorToolItem()
self.separator.set_draw(True)
self.insert(self.separator, -1)
self.separator.show()
#self.toolbox = toolbox
self.jam = jam
if Config.FEATURES_MIC:
self.micRec1Button = ToolButton('rec1')
self.micRec1Button.connect('clicked', self.jam.micRec, 'mic1')
self.insert(self.micRec1Button, -1)
self.micRec1Button.show()
self.micRec1Button.set_tooltip(_('Record microphone into slot 1'))
self.micRec2Button = ToolButton('rec2')
self.micRec2Button.connect('clicked', self.jam.micRec, 'mic2')
self.insert(self.micRec2Button, -1)
self.micRec2Button.show()
self.micRec2Button.set_tooltip(_('Record microphone into slot 2'))
self.micRec3Button = ToolButton('rec3')
self.micRec3Button.connect('clicked', self.jam.micRec, 'mic3')
self.insert(self.micRec3Button, -1)
self.micRec3Button.show()
self.micRec3Button.set_tooltip(_('Record microphone into slot 3'))
self.micRec4Button = ToolButton('rec4')
self.micRec4Button.connect('clicked', self.jam.micRec, 'mic4')
self.insert(self.micRec4Button, -1)
self.micRec4Button.show()
self.micRec4Button.set_tooltip(('Record microphone into slot 4'))
_insertSeparator()
if Config.FEATURES_NEWSOUNDS:
self._loopSettingsPalette = LoopSettingsPalette(
_('Add new Sound'), self.jam)
self.loopSetButton = ToggleToolButton('loop')
self.loopSetButton.set_palette(self._loopSettingsPalette)
self.insert(self.loopSetButton, -1)
self.loopSetButton.show()
self.show_all()
class RecordToolbar(gtk.Toolbar):
def __init__(self, jam):
gtk.Toolbar.__init__(self)
def _insertSeparator(x=1):
for i in range(x):
self.separator = gtk.SeparatorToolItem()
self.separator.set_draw(True)
self.insert(self.separator, -1)
self.separator.show()
#self.toolbox = toolbox
self.jam = jam
if Config.FEATURES_MIC:
self.micRec1Button = ToolButton('rec1')
self.micRec1Button.connect('clicked', self.jam.micRec, 'mic1')
self.insert(self.micRec1Button, -1)
self.micRec1Button.show()
self.micRec1Button.set_tooltip(_('Record microphone into slot 1'))
self.micRec2Button = ToolButton('rec2')
self.micRec2Button.connect('clicked', self.jam.micRec, 'mic2')
self.insert(self.micRec2Button, -1)
self.micRec2Button.show()
self.micRec2Button.set_tooltip(_('Record microphone into slot 2'))
self.micRec3Button = ToolButton('rec3')
self.micRec3Button.connect('clicked', self.jam.micRec, 'mic3')
self.insert(self.micRec3Button, -1)
self.micRec3Button.show()
self.micRec3Button.set_tooltip(_('Record microphone into slot 3'))
self.micRec4Button = ToolButton('rec4')
self.micRec4Button.connect('clicked', self.jam.micRec, 'mic4')
self.insert(self.micRec4Button, -1)
self.micRec4Button.show()
self.micRec4Button.set_tooltip(('Record microphone into slot 4'))
_insertSeparator()
if Config.FEATURES_NEWSOUNDS:
self._loopSettingsPalette = LoopSettingsPalette(
_('Add new Sound'), self.jam)
self.loopSetButton = ToggleToolButton('loop')
self.loopSetButton.set_palette(self._loopSettingsPalette)
self.insert(self.loopSetButton, -1)
self.loopSetButton.show()
self.show_all()
class ViewToolbar(gtk.Toolbar):
__gtype_name__ = 'ViewToolbar'
__gsignals__ = {
'needs-update-size':
(gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE, ([])),
'go-fullscreen': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE, ([]))
}
def __init__(self):
gtk.Toolbar.__init__(self)
self.zoom_out = ToolButton('zoom-out')
self.zoom_out.set_tooltip(_('Zoom out'))
self.insert(self.zoom_out, -1)
self.zoom_out.show()
self.zoom_in = ToolButton('zoom-in')
self.zoom_in.set_tooltip(_('Zoom in'))
self.insert(self.zoom_in, -1)
self.zoom_in.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 fullscreen_cb(self, button):
self.emit('go-fullscreen')
class ViewToolbar(gtk.Toolbar):
__gtype_name__ = 'ViewToolbar'
__gsignals__ = {
'needs-update-size': (gobject.SIGNAL_RUN_FIRST,
gobject.TYPE_NONE,
([])),
'go-fullscreen': (gobject.SIGNAL_RUN_FIRST,
gobject.TYPE_NONE,
([]))
}
def __init__(self):
gtk.Toolbar.__init__(self)
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 fullscreen_cb(self, button):
self.emit('go-fullscreen')
def __init__(self):
gtk.Toolbar.__init__(self)
self._metadata = None
self._temp_file_path = None
self._resume = ToolButton('activity-start')
self._resume.connect('clicked', self._resume_clicked_cb)
self.add(self._resume)
self._resume.show()
client = gconf.client_get_default()
color = XoColor(client.get_string('/desktop/sugar/user/color'))
self._copy = ToolButton()
icon = Icon(icon_name='edit-copy', xo_color=color)
self._copy.set_icon_widget(icon)
icon.show()
self._copy.set_tooltip(_('Copy to'))
self._copy.connect('clicked', self._copy_clicked_cb)
self.add(self._copy)
self._copy.show()
self._duplicate = ToolButton()
icon = Icon(icon_name='edit-duplicate', xo_color=color)
self._duplicate.set_icon_widget(icon)
self._duplicate.set_tooltip(_('Duplicate'))
self._duplicate.connect('clicked', self._duplicate_clicked_cb)
self.add(self._duplicate)
separator = gtk.SeparatorToolItem()
self.add(separator)
separator.show()
erase_button = ToolButton('list-remove')
erase_button.set_tooltip(_('Erase'))
erase_button.connect('clicked', self._erase_button_clicked_cb)
self.add(erase_button)
erase_button.show()
def __init__(self):
gtk.Toolbar.__init__(self)
self._metadata = None
self._temp_file_path = None
self._resume = ToolButton('activity-start')
self._resume.connect('clicked', self._resume_clicked_cb)
self.add(self._resume)
self._resume.show()
client = gconf.client_get_default()
color = XoColor(client.get_string('/desktop/sugar/user/color'))
self._copy = ToolButton()
icon = Icon(icon_name='edit-copy', xo_color=color)
self._copy.set_icon_widget(icon)
icon.show()
self._copy.set_tooltip(_('Copy to'))
self._copy.connect('clicked', self._copy_clicked_cb)
self.add(self._copy)
self._copy.show()
self._duplicate = ToolButton()
icon = Icon(icon_name='edit-duplicate', xo_color=color)
self._duplicate.set_icon_widget(icon)
self._duplicate.set_tooltip(_('Duplicate'))
self._duplicate.connect('clicked', self._duplicate_clicked_cb)
self.add(self._duplicate)
separator = gtk.SeparatorToolItem()
self.add(separator)
separator.show()
erase_button = ToolButton('list-remove')
erase_button.set_tooltip(_('Erase'))
erase_button.connect('clicked', self._erase_button_clicked_cb)
self.add(erase_button)
erase_button.show()
class ViewToolbar(gtk.Toolbar):
__gsignals__ = {
'go-fullscreen': (gobject.SIGNAL_RUN_FIRST,
gobject.TYPE_NONE,
([]))
}
def __init__(self):
gtk.Toolbar.__init__(self)
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.props.sensitive = False
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.props.sensitive = True
self._zoom_in.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.props.sensitive = False
self._zoom_out.props.sensitive = True
self.activity.zoom_to_width()
def _zoom_out_cb(self, button):
self._zoom_in.props.sensitive = True
self._zoom_out.props.sensitive = False
self.activity.zoom_to_fit()
def enable_zoom_in(self):
self._zoom_in.props.sensitive = True
self._zoom_out.props.sensitive = False
def enable_zoom_out(self):
self._zoom_in.props.sensitive = False
self._zoom_out.props.sensitive = True
def set_activity(self, activity):
self.activity = activity
def _fullscreen_cb(self, button):
self.emit('go-fullscreen')
class WebToolbar(gtk.Toolbar):
def __init__(self,browser):
from sugar.graphics.toolbutton import ToolButton
self.logger = logging.getLogger("gvr.Widgets.WebToolbar")
gtk.Toolbar.__init__(self)
self._browser = browser
self._back = ToolButton('go-previous')
self._back.set_tooltip(_('Go back one page'))
self._back.connect('clicked', self._go_back_cb)
self.insert(self._back, -1)
self._back.show()
self._forw = ToolButton('go-next')
self._forw.set_tooltip(_('Go one page forward'))
self._forw.connect('clicked', self._go_forward_cb)
self.insert(self._forw, -1)
self._forw.show()
def _go_forward_cb(self,button):
self._browser.web_navigation.goForward()
def _go_back_cb(self,button):
self._browser.web_navigation.goBack()
class Toolbar(gtk.Toolbar):
def __init__(self, web_view):
gobject.GObject.__init__(self)
self._web_view = web_view
self._back = ToolButton("go-previous-paired")
self._back.set_tooltip(_("Back"))
self._back.props.sensitive = False
self._back.connect("clicked", self._go_back_cb)
self.insert(self._back, -1)
self._back.show()
self._forward = ToolButton("go-next-paired")
self._forward.set_tooltip(_("Forward"))
self._forward.props.sensitive = False
self._forward.connect("clicked", self._go_forward_cb)
self.insert(self._forward, -1)
self._forward.show()
self._home = ToolButton("go-home")
self._home.set_tooltip(_("Home"))
self._home.connect("clicked", self._go_home_cb)
self.insert(self._home, -1)
self._home.show()
progress_listener = self._web_view.progress
progress_listener.connect("location-changed", self._location_changed_cb)
progress_listener.connect("loading-stop", self._loading_stop_cb)
def _location_changed_cb(self, progress_listener, uri):
self.update_navigation_buttons()
def _loading_stop_cb(self, progress_listener):
self.update_navigation_buttons()
def update_navigation_buttons(self):
can_go_back = self._web_view.web_navigation.canGoBack
self._back.props.sensitive = can_go_back
can_go_forward = self._web_view.web_navigation.canGoForward
self._forward.props.sensitive = can_go_forward
def _go_back_cb(self, button):
self._web_view.web_navigation.goBack()
def _go_forward_cb(self, button):
self._web_view.web_navigation.goForward()
def _go_home_cb(self, button):
self._web_view.load_uri(HOME)
class ViewToolbar(gtk.Toolbar):
def __init__(self, activity):
gtk.Toolbar.__init__(self)
self._activity = activity
self._browser = self._activity._web_view
self.zoomout = ToolButton('zoom-out')
self.zoomout.set_tooltip(_('Zoom out'))
self.zoomout.connect('clicked', self.__zoomout_clicked_cb)
self.insert(self.zoomout, -1)
self.zoomout.show()
self.zoomin = ToolButton('zoom-in')
self.zoomin.set_tooltip(_('Zoom in'))
self.zoomin.connect('clicked', self.__zoomin_clicked_cb)
self.insert(self.zoomin, -1)
self.zoomin.show()
self.separator = gtk.SeparatorToolItem()
self.separator.set_draw(True)
self.insert(self.separator, -1)
self.separator.show()
self.fullscreen = ToolButton('view-fullscreen')
self.fullscreen.set_tooltip(_('Fullscreen'))
self.fullscreen.connect('clicked', self.__fullscreen_clicked_cb)
self.insert(self.fullscreen, -1)
self.fullscreen.show()
def __zoomin_clicked_cb(self, button):
self._browser.zoom_in()
def __zoomout_clicked_cb(self, button):
self._browser.zoom_out()
def __fullscreen_clicked_cb(self, button):
self._activity.fullscreen()
class ViewToolbar(gtk.Toolbar):
__gtype_name__ = 'ViewToolbar'
__gsignals__ = {
'needs-update-size': (gobject.SIGNAL_RUN_FIRST,
gobject.TYPE_NONE,
([])),
'go-fullscreen': (gobject.SIGNAL_RUN_FIRST,
gobject.TYPE_NONE,
([]))
}
def __init__(self):
gtk.Toolbar.__init__(self)
self.zoom_out = ToolButton('zoom-out')
self.zoom_out.set_tooltip(_('Zoom out'))
self.insert(self.zoom_out, -1)
self.zoom_out.show()
self.zoom_in = ToolButton('zoom-in')
self.zoom_in.set_tooltip(_('Zoom in'))
self.insert(self.zoom_in, -1)
self.zoom_in.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 fullscreen_cb(self, button):
self.emit('go-fullscreen')
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 ActivityToolbar(gtk.Toolbar):
"""The Activity toolbar with the Journal entry title, sharing,
Keep and Stop buttons
All activities should have this toolbar. It is easiest to add it to your
Activity by using the ActivityToolbox.
"""
def __init__(self, activity):
gtk.Toolbar.__init__(self)
self._activity = activity
self._updating_share = False
"""
activity.connect('shared', self.__activity_shared_cb)
activity.connect('joined', self.__activity_shared_cb)
activity.connect('notify::max_participants',
self.__max_participants_changed_cb)
"""
#if activity.metadata:
if True:
self.label = gtk.Label(display.menu_journal_label)
self.label.show()
self._add_widget(self.label)
self.title = gtk.Entry()
self.title.set_size_request(int(gtk.gdk.screen_width() / 6), -1)
if activity.metadata:
self.title.set_text(activity.metadata['title'])
#activity.metadata.connect('updated', self.__jobject_updated_cb)
self.title.connect('changed', self.__title_changed_cb)
self.title.connect('activate', self.__update_title_cb)
self._add_widget(self.title)
fn = os.path.join(os.getcwd(),'assets','stack_new.png')
button = ImageButton()
tooltip = _("Add Album Stack")
button.set_image(fn,tip=tooltip)
self.add_album = button
self.add_album.show()
self.add_album.connect('clicked', self.__add_album_clicked_cb)
self.insert(self.add_album,-1)
fn = os.path.join(os.getcwd(),'assets','stack_del.png')
button = ImageButton()
tooltip = _("Delete Album Stack")
button.set_image(fn,tip=tooltip)
button.connect('clicked', self.__delete_album_clicked_cb)
self.insert(button,-1)
fn = os.path.join(os.getcwd(),'assets','trash_del.png')
button = ImageButton()
tooltip = _("Remove Trash Images from XO")
button.set_image(fn,tip=tooltip)
self.empty_journal_button = button
self.empty_journal_button.hide()
self.empty_journal_button.connect('clicked',self.__empty_trash_clicked_cb)
self.insert(self.empty_journal_button,-1)
"""
separator = gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
self.insert(separator, -1)
separator.show()
self.share = ToolComboBox(label_text=_('Traceback:'))
self.share.combo.connect('changed', self.__traceback_changed_cb)
self.share.combo.append_item("traceback_plain", _('Plain'))
self.share.combo.append_item('traceback_context', _('Context'))
self.share.combo.append_item('traceback_verbose', _('Verbose'))
self.insert(self.share, -1)
self.share.show()
self._update_share()
"""
separator = gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
self.insert(separator, -1)
separator.show()
self.keep = ToolButton()
self.keep.set_tooltip(_('Save and Start New'))
#client = gconf.client_get_default()
#color = XoColor(client.get_string('/desktop/sugar/user/color'))
#keep_icon = Icon(icon_name='document-save', xo_color=color)
keep_icon = Icon(icon_name='document-save')
keep_icon.show()
self.keep.set_icon_widget(keep_icon)
#self.keep.props.accelerator = '<Ctrl>S'
self.keep.connect('clicked', self.__keep_clicked_cb)
self.insert(self.keep, -1)
self.keep.show()
self.stop = ToolButton('activity-stop')
self.stop.set_tooltip(_('Stop'))
#self.stop.props.accelerator = '<Ctrl>Q'
self.stop.connect('clicked', self.__stop_clicked_cb)
self.insert(self.stop, -1)
self.stop.show()
self._update_title_sid = None
def set_label(self,text,visible=True):
self.label.set_text(text)
if not visible:
self.title.set_sensitive(False)
else:
self.title.set_sensitive(True)
def _update_share(self):
self._updating_share = True
if self._activity.props.max_participants == 1:
self.share.hide()
if self._activity.get_shared():
self.share.set_sensitive(False)
self.share.combo.set_active(1)
else:
self.share.set_sensitive(True)
self.share.combo.set_active(0)
self._updating_share = False
def __add_album_clicked_cb (self,button):
title = self.title.get_text()
self._activity.activity_toolbar_add_album_cb(title)
def __delete_album_clicked_cb (self,button):
self._activity.activity_toolbar_delete_album_cb()
def __empty_trash_clicked_cb(self,button):
self._activity.activity_toolbar_empty_trash_cb()
def __traceback_changed_cb(self, combo):
model = self.share.combo.get_model()
it = self.share.combo.get_active_iter()
(scope, ) = model.get(it, 0)
if scope == 'traceback_plain':
self._activity.traceback = 'Plain'
self._activity.debug_dict['traceback'] = 'plain'
elif scope == 'traceback_context':
self._activity.traceback = 'Context'
self._activity.debug_dict['traceback'] = 'context'
elif scope == 'traceback_verbose':
self._activity.traceback = 'Verbose'
self._activity.debug_dict['traceback'] = 'verbose'
self._activity.set_ipython_traceback()
def __keep_clicked_cb(self, button):
self._activity.save_icon_clicked = True
self._activity.copy()
def __stop_clicked_cb(self, button):
self._activity.stop()
def __jobject_updated_cb(self, jobject):
self.title.set_text(jobject['title'])
def __title_changed_cb(self, entry):
if not self._update_title_sid:
self._update_title_sid = gobject.timeout_add(
1000, self.__update_title_cb)
def __update_title_cb(self, entry=None):
title = self.title.get_text()
if self._activity.game.is_journal():
self._activity.metadata['title'] = title
self._activity.metadata['title_set_by_user'] = '******'
else:
self._activity.game.change_album_name(title)
title_set_by_user = self._activity.metadata.get('title_set_by_user')
if not title_set_by_user: #let the journal title reflect the most recent stack
self._activity.metadata['title'] = title
self._update_title_sid = None
return False
def _add_widget(self, widget, expand=False):
tool_item = gtk.ToolItem()
tool_item.set_expand(expand)
tool_item.add(widget)
widget.show()
self.insert(tool_item, -1)
tool_item.show()
def __activity_shared_cb(self, activity):
self._update_share()
def __max_participants_changed_cb(self, activity, pspec):
self._update_share()
class SectionToolbar(gtk.Toolbar):
""" Toolbar of the sections of the control panel
"""
__gtype_name__ = 'SectionToolbar'
__gsignals__ = {
'cancel-clicked': (gobject.SIGNAL_RUN_FIRST,
gobject.TYPE_NONE,
([])),
'accept-clicked': (gobject.SIGNAL_RUN_FIRST,
gobject.TYPE_NONE,
([])),
}
def __init__(self):
gtk.Toolbar.__init__(self)
self._add_separator()
self._icon = Icon()
self._add_widget(self._icon)
self._add_separator()
self._title = gtk.Label()
self._add_widget(self._title)
self._add_separator(True)
self.cancel_button = ToolButton('dialog-cancel')
self.cancel_button.set_tooltip(_('Cancel'))
self.cancel_button.connect('clicked', self.__cancel_button_clicked_cb)
self.insert(self.cancel_button, -1)
self.cancel_button.show()
self.accept_button = ToolButton('dialog-ok')
self.accept_button.set_tooltip(_('Ok'))
self.accept_button.connect('clicked', self.__accept_button_clicked_cb)
self.insert(self.accept_button, -1)
self.accept_button.show()
def get_icon(self):
return self._icon
def get_title(self):
return self._title
def _add_separator(self, expand=False):
separator = gtk.SeparatorToolItem()
separator.props.draw = False
if expand:
separator.set_expand(True)
else:
separator.set_size_request(style.DEFAULT_SPACING, -1)
self.insert(separator, -1)
separator.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 __cancel_button_clicked_cb(self, widget, data=None):
self.emit('cancel-clicked')
def __accept_button_clicked_cb(self, widget, data=None):
self.emit('accept-clicked')
class ActivityToolbar(gtk.Toolbar):
"""The Activity toolbar with the Journal entry title, sharing,
Keep and Stop buttons
All activities should have this toolbar. It is easiest to add it to your
Activity by using the ActivityToolbox.
"""
def __init__(self, activity):
gtk.Toolbar.__init__(self)
self._activity = activity
self._updating_share = False
self._focus_out_hid = None
activity.connect('shared', self.__activity_shared_cb)
activity.connect('joined', self.__activity_shared_cb)
activity.connect('notify::max_participants',
self.__max_participants_changed_cb)
if activity.metadata:
self.title = gtk.Entry()
self.title.set_size_request(int(gtk.gdk.screen_width() / 3), -1)
self.title.set_text(activity.metadata['title'])
self._focus_out_hid = self.title.connect('focus-out-event',
self.__title_changed_cb)
self._add_widget(self.title)
activity.metadata.connect('updated', self.__jobject_updated_cb)
separator = gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
self.insert(separator, -1)
separator.show()
self.share = ToolComboBox(label_text=_('Share with:'))
self.share.combo.connect('changed', self.__share_changed_cb)
self.share.combo.append_item(SCOPE_PRIVATE, _('Private'), 'zoom-home')
self.share.combo.append_item(SCOPE_NEIGHBORHOOD, _('My Neighborhood'),
'zoom-neighborhood')
self.insert(self.share, -1)
self.share.show()
self._update_share()
self.keep = ToolButton(tooltip=_('Keep'))
client = gconf.client_get_default()
color = XoColor(client.get_string('/desktop/sugar/user/color'))
keep_icon = Icon(icon_name='document-save', xo_color=color)
self.keep.set_icon_widget(keep_icon)
keep_icon.show()
self.keep.props.accelerator = '<Ctrl>S'
self.keep.connect('clicked', self.__keep_clicked_cb)
self.insert(self.keep, -1)
self.keep.show()
self.stop = ToolButton('activity-stop', tooltip=_('Stop'))
self.stop.props.accelerator = '<Ctrl>Q'
self.stop.connect('clicked', self.__stop_clicked_cb)
self.insert(self.stop, -1)
self.stop.show()
def _update_share(self):
self._updating_share = True
if self._activity.props.max_participants == 1:
self.share.hide()
if self._activity.get_shared():
self.share.set_sensitive(False)
self.share.combo.set_active(1)
else:
self.share.set_sensitive(True)
self.share.combo.set_active(0)
self._updating_share = False
def __share_changed_cb(self, combo):
if self._updating_share:
return
model = self.share.combo.get_model()
it = self.share.combo.get_active_iter()
(scope, ) = model.get(it, 0)
if scope == SCOPE_NEIGHBORHOOD:
self._activity.share()
def __keep_clicked_cb(self, button):
self._activity.copy()
def __stop_clicked_cb(self, button):
if self._focus_out_hid is not None:
self.title.disconnect(self._focus_out_hid)
self._update_title(self.title.get_text())
self._activity.close()
def __jobject_updated_cb(self, jobject):
self.title.set_text(jobject['title'])
def __title_changed_cb(self, editable, event):
title = editable.get_text()
self._update_title(title)
def _update_title(self, title):
# Title really changed?
if title == self._activity.metadata['title']:
return False
self._activity.metadata['title'] = title
self._activity.metadata['title_set_by_user'] = '******'
self._activity.save()
shared_activity = self._activity.get_shared_activity()
if shared_activity:
shared_activity.props.name = title
return False
def _add_widget(self, widget, expand=False):
tool_item = gtk.ToolItem()
tool_item.set_expand(expand)
tool_item.add(widget)
widget.show()
self.insert(tool_item, -1)
tool_item.show()
def __activity_shared_cb(self, activity):
self._update_share()
def __max_participants_changed_cb(self, activity, pspec):
self._update_share()
class 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)
