def __init__(self, **kwargs):
gtk.ToolItem.__init__(self)
help_button = ToolButton('help-icon')
help_button.set_tooltip(_('Help'))
self.add(help_button)
self._palette = help_button.get_palette()
sw = gtk.ScrolledWindow()
sw.set_size_request(int(gtk.gdk.screen_width() / 2.8),
gtk.gdk.screen_height() - style.GRID_CELL_SIZE * 3)
sw.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
self._max_text_width = int(gtk.gdk.screen_width() / 3) - 20
self._vbox = gtk.VBox()
self._vbox.set_homogeneous(False)
hbox = gtk.HBox()
hbox.pack_start(self._vbox, False, True, 0)
sw.add_with_viewport(hbox)
self._palette.set_content(sw)
sw.show_all()
help_button.connect('clicked', self.__help_button_clicked_cb)
class WriteToolbar(gtk.Toolbar):
canvas = WriteCanvas
def __init__(self, activity):
gtk.Toolbar.__init__(self)
self._activity = activity
self._send_button = ToolButton('send-email', tooltip=_('Send email'))
self._send_button.connect('clicked', self.__send_email_cb)
self.insert(self._send_button, -1)
self._attach_button = ToolButton('add-attachment', tooltip=_('Add attachment'))
self._attach_button.connect('clicked', self.__add_attachment_cb)
self.insert(self._attach_button, -1)
self.show_all()
def __send_email_cb(self, *args):
msg = self._activity.canvas.make_msg()
if utility.check_online():
func = self._activity.config.transport_account.send
args = ([msg], OutboundTracker(self._activity))
thread.start_new_thread(func, args)
else:
self._keep_as_outbound(msg)
self._activity.toolbox.current_toolbar = 1 # egh
def __add_attachment_cb(self, *args):
pass
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)
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
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 ReadToolbar(gtk.Toolbar):
'''
TODO:
* the toolbutton's sensitivity depends on context
'''
canvas = ReadCanvas
def __init__(self, activity):
gtk.Toolbar.__init__(self)
self._activity = activity
self._sendreceive_button = ToolButton('send-and-receive', tooltip=_('Send/receive email'))
self._sendreceive_button.connect('clicked', self._sendreceive_cb)
self.insert(self._sendreceive_button, -1)
self.show_all()
'''
self._reply_button = ToolButton('reply', tooltip=_('Write a reply'))
self._reply_button.connect('clicked', self._reply_msg_cb)
self.insert(self._reply_button, -1)
self._forward_button = ToolButton('forward', tooltip=_('Forward this message'))
self._forward_button.connect('clicked', self._forward_msg_cb)
self.insert(self._forward_button, -1)
'''
def _sendreceive_cb(self, *args):
sweetmail.mailactivity.run_bgsrt_once(self._activity)
def _reply_msg_cb(self, *args):
pass
def _forward_msg_cb(self, *args):
pass
def build_toolbar(self):
toolbar_box = ToolbarBox()
self.set_toolbar_box(toolbar_box)
toolbar_box.show()
activity_button = ActivityToolbarButton(self)
toolbar_box.toolbar.insert(activity_button, -1)
activity_button.show()
# Pause/Play button:
stop_play = ToolButton('media-playback-stop')
stop_play.set_tooltip(_("Stop"))
stop_play.set_accelerator(_('<ctrl>space'))
stop_play.connect('clicked', self._stop_play_cb)
stop_play.show()
toolbar_box.toolbar.insert(stop_play, -1)
# Blank space (separator) and Stop button at the end:
separator = gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
toolbar_box.toolbar.insert(separator, -1)
separator.show()
stop_button = StopButton(self)
toolbar_box.toolbar.insert(stop_button, -1)
stop_button.show()
def __init__(self, handle):
gtk.Toolbar.__init__(self)
self.handle = handle
#Tytuł pola tekstowego
self.add_widget(gtk.Label("Id testu: "))
#Pole tekstowe
self.test_entry = gtk.Entry()
self.test_entry.set_size_request(200,25)
self.test_entry.set_text('709rqd')
self.add_widget(self.test_entry)
#Separator
separator = gtk.SeparatorToolItem()
separator.set_draw(True)
separator.set_size_request(50,25)
self.add_widget(separator)
#Tytuł pola tekstowego
self.add_widget(gtk.Label("Hasło: "))
#Pole tekstowe
self.pass_entry = gtk.Entry()
self.pass_entry.set_size_request(300,25)
# self.pass_entry.set_text('123123')
self.add_widget(self.pass_entry)
#Przycisk pobierania
download_button = ToolButton("download")
download_button.set_tooltip("Pobierz test")
download_button.connect("clicked", handle.get_test_bt)
self.add_widget(download_button)
def build_toolbar(self):
toolbar_box = ToolbarBox()
self.set_toolbar_box(toolbar_box)
toolbar_box.show()
activity_button = ActivityToolbarButton(self)
toolbar_box.toolbar.insert(activity_button, -1)
activity_button.show()
self.blocklist = []
self.radioList = {}
for c in tools.allTools:
button = ToolButton(c.icon)
button.set_tooltip(_(c.toolTip))
button.connect('clicked',self.radioClicked)
toolbar_box.toolbar.insert(button, -1)
button.show()
self.radioList[button] = c.name
separator = gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
toolbar_box.toolbar.insert(separator, -1)
separator.show()
stop_button = StopButton(self)
toolbar_box.toolbar.insert(stop_button, -1)
stop_button.show()
self.show_all()
def build_toolbar(self):
toolbar_box = ToolbarBox()
self.set_toolbar_box(toolbar_box)
toolbar_box.show()
activity_button = ActivityToolbarButton(self)
toolbar_box.toolbar.insert(activity_button, -1)
activity_button.show()
separator1 = gtk.SeparatorToolItem()
separator1.props.draw = True
separator1.set_expand(False)
toolbar_box.toolbar.insert(separator1, -1)
separator1.show()
item1 = gtk.ToolItem()
label1 = gtk.Label()
label1.set_text(_('Levels') + ' ')
item1.add(label1)
toolbar_box.toolbar.insert(item1, -1)
item2 = gtk.ToolItem()
levels = (_('Cross'),
_('Cross 2'),
#TRANS:'chimney' - the place where you make fire
_('Hearth'),
_('Arrow'),
_('Pyramid'),
_('Diamond'),
_('Solitaire'))
combo = Combo(levels)
item2.add(combo)
combo.connect('changed', self.change_combo)
toolbar_box.toolbar.insert(item2, -1)
separator2 = gtk.SeparatorToolItem()
separator2.props.draw = True
separator2.set_expand(False)
toolbar_box.toolbar.insert(separator2, -1)
separator2.show()
sound_button = ToolButton('speaker-muted-100')
sound_button.set_tooltip(_('Sound'))
sound_button.connect('clicked', self.sound_control)
toolbar_box.toolbar.insert(sound_button, -1)
separator3 = gtk.SeparatorToolItem()
separator3.props.draw = False
separator3.set_expand(True)
toolbar_box.toolbar.insert(separator3, -1)
separator3.show()
stop_button = StopButton(self)
toolbar_box.toolbar.insert(stop_button, -1)
stop_button.show()
self.show_all()
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 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 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 build_resolution_toolbar(self, toolbox):
resolution_bar = gtk.Toolbar()
item1 = gtk.ToolItem()
label1 = gtk.Label()
label1.set_text(' ' + _('Show size') + ' ')
item1.add(label1)
resolution_bar.insert(item1, -1)
item2 = gtk.ToolItem()
x_size_spin = gtk.SpinButton()
x_size_spin.set_range(160, 1200)
x_size_spin.set_increments(1, 10)
x_size_spin.props.value = int(self.show_size[0])
x_size_spin.connect('notify::value', self.x_size_spin_change)
item2.add(x_size_spin)
resolution_bar.insert(item2, -1)
item3 = gtk.ToolItem()
label3 = gtk.Label()
label3.set_text(' X ')
item3.add(label3)
resolution_bar.insert(item3, -1)
item4 = gtk.ToolItem()
y_size_spin = gtk.SpinButton()
y_size_spin.set_range(120, 900)
y_size_spin.set_increments(1, 10)
y_size_spin.props.value = int(self.show_size[1])
y_size_spin.connect('notify::value', self.y_size_spin_change)
item4.add(y_size_spin)
resolution_bar.insert(item4, -1)
separator1 = gtk.SeparatorToolItem()
separator1.props.draw = True
resolution_bar.insert(separator1, -1)
item5 = gtk.ToolItem()
label5 = gtk.Label()
label5.set_text(' ' + _('Show grid'))
item5.add(label5)
resolution_bar.insert(item5, -1)
grid = ToolButton('grid-icon')
grid.connect('clicked', self.grid_click)
resolution_bar.insert(grid, -1)
resolution_bar.show_all()
resolution_button = ToolbarButton(label=_('Resolution'),
page=resolution_bar,
icon_name='camera')
toolbox.toolbar.insert(resolution_button, -1)
resolution_button.show()
def __init__(self, handle):
gtk.Toolbar.__init__(self)
self.handle = handle
self._logger = logging.getLogger("activity-knut")
self._logger.setLevel(logging.DEBUG)
# First log handler: outputs to a file
file_handler = logging.FileHandler("/home/wiktor/code/knut.log")
file_formatter = logging.Formatter("%(message)s")
file_handler.setFormatter(file_formatter)
self._logger.addHandler(file_handler)
# Tytuł pola tekstowego
self.add_widget(gtk.Label("Kategoria: "))
# Pole tekstowe
self.test_type = ComboBox()
for id, name in BrowseToolbar.TEST_CATEGORIES.items():
self.test_type.append_item(id, name)
self.test_type.set_active(0)
self.add_widget(self.test_type)
# Separator
# separator = gtk.SeparatorToolItem()
# separator.set_draw(True)
# separator.set_size_request(50,25)
# self.add_widget(separator)
# Tytuł pola tekstowego
self.add_widget(gtk.Label(" Szukaj w tytule: "))
# Pole tekstowe
self.search_entry = gtk.Entry()
self.search_entry.set_size_request(100, 25)
# self.pass_entry.set_text('123123')
self.add_widget(self.search_entry)
# Przycisk pobierania
download_button = ToolButton("download")
download_button.set_tooltip("Przeglądaj testy")
download_button.connect("clicked", self.list_download)
self.add_widget(download_button)
separator2 = gtk.SeparatorToolItem()
separator2.set_draw(True)
separator2.set_size_request(50, 25)
self.add_widget(separator2)
self.add_widget(gtk.Label("Hasło: "))
self.pass_entry = gtk.Entry()
self.pass_entry.set_size_request(100, 25)
# self.pass_entry.set_text('123123')
self.add_widget(self.pass_entry)
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)
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
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, main_area):
gtk.Toolbar.__init__(self)
self._main_area = main_area
tool = ToolButton('zoom-best-fit')
tool.set_tooltip(_('Fit to window'))
tool.set_accelerator(_('<ctrl>9'))
tool.connect('clicked', self.__zoom_tofit_cb)
self.insert(tool, -1)
tool = ToolButton('zoom-original')
tool.set_tooltip(_('Original size'))
tool.set_accelerator(_('<ctrl>0'))
tool.connect('clicked', self.__zoom_original_cb)
self.insert(tool, -1)
tool = ToolButton('zoom-out')
tool.set_tooltip(_('Zoom out'))
tool.set_accelerator(_('<ctrl>minus'))
tool.connect('clicked', self.__zoom_out_cb)
self.insert(tool, -1)
tool = ToolButton('zoom-in')
tool.set_tooltip(_('Zoom in'))
tool.set_accelerator(_('<ctrl>equal'))
tool.connect('clicked', self.__zoom_in_cb)
self.insert(tool, -1)
self.show_all()
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, icon_name, title):
super(_DialogToolbar, self).__init__()
if icon_name is not None:
sep = gtk.SeparatorToolItem()
sep.set_draw(False)
self._add_widget(sep)
icon = Icon()
icon.set_from_icon_name(icon_name, gtk.ICON_SIZE_LARGE_TOOLBAR)
self._add_widget(icon)
label = gtk.Label(' ' + title)
self._add_widget(label)
self._add_separator(expand=True)
stop = ToolButton(icon_name='dialog-cancel')
stop.set_tooltip('Salir')
stop.connect('clicked', self._stop_clicked_cb)
self.add(stop)
def __init__(self, editor):
Palette.__init__(self, _('Pronounce text during tile flip'))
self.face = speak.face.View()
toolbar = gtk.HBox()
toolbar.modify_bg(gtk.STATE_NORMAL, style.COLOR_BLACK.get_gdk_color())
usespeak_play = ToolButton(icon_name='media-playback-start')
usespeak_play.connect('clicked', lambda button:
self.face.say(editor.get_text()))
toolbar.pack_start(usespeak_play, False)
self.voices = speak.widgets.Voices(self.face)
toolbar.pack_start(ToolComboBox(self.voices))
toolbar.show_all()
self.set_content(toolbar)
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
def __init__(self, handle):
activity.Activity.__init__(self, handle)
# we do not have collaboration features
# make the share option insensitive
self.max_participants = 1
# toolbar with the new toolbar redesign
toolbar_box = ToolbarBox()
activity_button = ActivityToolbarButton(self)
toolbar_box.toolbar.insert(activity_button, 0)
toolbar_box.toolbar.insert(gtk.SeparatorToolItem(), -1)
self.image_viewer = ImageCollectionViewer(False)
prev_bt = ToolButton("go-previous-paired")
prev_bt.connect("clicked", self.image_viewer.prev_anim_clicked_cb,
None)
toolbar_box.toolbar.insert(prev_bt, -1)
next_bt = ToolButton("go-next-paired")
next_bt.connect("clicked", self.image_viewer.next_anim_clicked_cb,
None)
toolbar_box.toolbar.insert(next_bt, -1)
separator = gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
toolbar_box.toolbar.insert(separator, -1)
stop_button = StopButton(self)
toolbar_box.toolbar.insert(stop_button, -1)
self.set_toolbar_box(toolbar_box)
toolbar_box.show_all()
self.modify_bg(gtk.STATE_NORMAL, style.COLOR_WHITE.get_gdk_color())
self.set_canvas(self.image_viewer)
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()
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)
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 build_toolbar(self):
"""Build our Activity toolbar for the Sugar system."""
toolbar_box = ToolbarBox()
activity_button = ActivityToolbarButton(self)
toolbar_box.toolbar.insert(activity_button, 0)
activity_button.show()
separator = gtk.SeparatorToolItem()
toolbar_box.toolbar.insert(separator, -1)
separator.show()
easier_button = ToolButton('create-easier')
easier_button.set_tooltip(_('Easier level'))
easier_button.connect('clicked', self._easier_button_cb)
toolbar_box.toolbar.insert(easier_button, -1)
harder_button = ToolButton('create-harder')
harder_button.set_tooltip(_('Harder level'))
harder_button.connect('clicked', self._harder_button_cb)
toolbar_box.toolbar.insert(harder_button, -1)
separator = gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_size_request(0, -1)
separator.set_expand(True)
toolbar_box.toolbar.insert(separator, -1)
separator.show()
stop_button = StopButton(self)
toolbar_box.toolbar.insert(stop_button, -1)
stop_button.show()
self.set_toolbar_box(toolbar_box)
toolbar_box.show_all()
self.connect("destroy", self.__stop_pygame)
return toolbar_box
def __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, activity, top_level_toolbox):
self._activity = activity
self.toolbox = top_level_toolbox
Terminal.__init__(self, self)
#set up tool box/menu buttons
activity_toolbar = self.toolbox.get_activity_toolbar()
separator = gtk.SeparatorToolItem()
separator.set_draw(True)
separator.show()
activity_toolbar.insert(separator, 0)
activity_go = ToolButton()
activity_go.set_stock_id('gtk-media-forward')
activity_go.set_icon_widget(None)
activity_go.set_tooltip(_('Start Debugging'))
activity_go.connect('clicked', self.project_run_cb)
activity_go.add_accelerator('clicked', self.get_accelerator(),
ord('O'), gtk.gdk.CONTROL_MASK,
gtk.ACCEL_VISIBLE)
activity_go.show()
activity_toolbar.insert(activity_go, 0)
activity_copy_tb = ToolButton('edit-copy')
activity_copy_tb.set_tooltip(_('Copy'))
activity_copy_tb.connect('clicked', self._copy_cb)
activity_toolbar.insert(activity_copy_tb, 3)
activity_copy_tb.show()
activity_paste_tb = ToolButton('edit-paste')
activity_paste_tb.set_tooltip(_('Paste'))
activity_paste_tb.connect('clicked', self._paste_cb)
activity_paste_tb.add_accelerator('clicked', self.get_accelerator(),
ord('V'), gtk.gdk.CONTROL_MASK,
gtk.ACCEL_VISIBLE)
activity_toolbar.insert(activity_paste_tb, 4)
activity_paste_tb.show()
activity_tab_tb = sugar.graphics.toolbutton.ToolButton('list-add')
activity_tab_tb.set_tooltip(_("Open New Tab"))
activity_tab_tb.add_accelerator('clicked', self.get_accelerator(),
ord('T'), gtk.gdk.CONTROL_MASK,
gtk.ACCEL_VISIBLE)
activity_tab_tb.show()
activity_tab_tb.connect('clicked', self._open_tab_cb)
activity_toolbar.insert(activity_tab_tb, 5)
activity_tab_delete_tv = sugar.graphics.toolbutton.ToolButton(
'list-remove')
activity_tab_delete_tv.set_tooltip(_("Close Tab"))
activity_tab_delete_tv.show()
activity_tab_delete_tv.connect('clicked', self._close_tab_cb)
activity_toolbar.insert(activity_tab_delete_tv, 6)
activity_fullscreen_tb = sugar.graphics.toolbutton.ToolButton(
'view-fullscreen')
activity_fullscreen_tb.set_tooltip(_("Fullscreen"))
activity_fullscreen_tb.connect('clicked',
self._activity._fullscreen_cb)
activity_toolbar.insert(activity_fullscreen_tb, 7)
activity_fullscreen_tb.hide()
class canvas(gtk.HPaned):
def __init__(self):
super(canvas, self).__init__()
####
self.toolbar = gtk.Toolbar()
self.remove = ToolButton('remove')
self.remove.set_tooltip(_('Remove this contact'))
self.addbtn = ToolButton('add')
self.addbtn.connect('clicked', self._show_palette_add_button)
self.sep = gtk.SeparatorToolItem()
self.toolarea = AddTelephoneArea(self.addbtn, self)
self.sep.props.draw = False
self.sep.set_expand(True)
self.toolbar.insert(self.sep, -1)
self.toolbar.insert(self.remove, -1)
###
self.ficha = Ficha()
self.set1 = Telefonos(self.remove, self.ficha)
self.scroll = gtk.ScrolledWindow()
self.scroll.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
self.scroll.add_with_viewport(self.set1)
self.vbx = gtk.VBox()
self.vbx.pack_start(self.scroll, True, True, 0)
self.vbx.pack_end(self.toolbar, False, True, 0)
self.vbx.set_size_request(gtk.gdk.screen_width() / 3, -1)
self.add1(self.vbx)
self.add2(self.ficha)
self.show_all()
self.addbtn.set_tooltip(_('Add a new contact'))
if __name__ == "__main__":
self.toolbar.insert(self.addbtn, -1)
if os.path.isfile("users"):
self.read_file('users')
self._create_palette_add_button(self.addbtn)
def read_file(self, file_path):
fd = open(file_path, 'r')
text = fd.read()
data = simplejson.loads(text)
fd.close()
current = 0
for x in data['names']:
numero = data['telephones'][current]
edad = data['ages'][current]
email = data['emails'][current]
direction = data['directions'][current]
avatar = data['avatars'][current]
self._add(x, numero, edad, email, direction, avatar)
current += 1
def _show_palette_add_button(self, button):
button.props.palette.popup(immediate=True, state=1)
def _create_palette_add_button(self, button):
pallete = button.get_palette()
pallete.set_content(self.toolarea)
txt = _("Unknown")
pt = os.path.join(os.getcwd(), 'avatars', 'none.svg')
td = _("None")
def _add(self, name, number=txt, age=1, email=td, direct=txt, av=pt):
self.set1._add_telephone(name, number, age, email, direct, av)
self.show_all()
class ViewToolbar(gtk.Toolbar):
__gtype_name__ = 'ViewToolbar'
__gsignals__ = {
'go-fullscreen': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE, ([])),
}
def __init__(self):
gtk.Toolbar.__init__(self)
self._view = None
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_to_width = ToolButton('zoom-best-fit')
self._zoom_to_width.set_tooltip(_('Zoom to width'))
self._zoom_to_width.connect('clicked', self._zoom_to_width_cb)
self.insert(self._zoom_to_width, -1)
self._zoom_to_width.show()
palette = self._zoom_to_width.get_palette()
menu_item = MenuItem(_('Zoom to fit'))
menu_item.connect('activate', self._zoom_to_fit_menu_item_activate_cb)
palette.menu.append(menu_item)
menu_item.show()
menu_item = MenuItem(_('Actual size'))
menu_item.connect('activate', self._actual_size_menu_item_activate_cb)
palette.menu.append(menu_item)
menu_item.show()
tool_item = gtk.ToolItem()
self.insert(tool_item, -1)
tool_item.show()
self._zoom_spin = gtk.SpinButton()
self._zoom_spin.set_range(5.409, 400)
self._zoom_spin.set_increments(1, 10)
self._zoom_spin_notify_value_handler = self._zoom_spin.connect(
'notify::value', self._zoom_spin_notify_value_cb)
tool_item.add(self._zoom_spin)
self._zoom_spin.show()
zoom_perc_label = gtk.Label(_("%"))
zoom_perc_label.show()
tool_item_zoom_perc_label = gtk.ToolItem()
tool_item_zoom_perc_label.add(zoom_perc_label)
self.insert(tool_item_zoom_perc_label, -1)
tool_item_zoom_perc_label.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()
self._view_notify_zoom_handler = None
def set_view(self, view):
self._view = view
self._zoom_spin.props.value = self._view.get_zoom()
self._view_notify_zoom_handler = \
self._view.connect_zoom_handler(self._view_notify_zoom_cb)
self._update_zoom_buttons()
def _zoom_spin_notify_value_cb(self, zoom_spin, pspec):
self._view.set_zoom(zoom_spin.props.value)
def _view_notify_zoom_cb(self, model, pspec):
self._zoom_spin.disconnect(self._zoom_spin_notify_value_handler)
try:
self._zoom_spin.props.value = round(self._view.get_zoom())
finally:
self._zoom_spin_notify_value_handler = self._zoom_spin.connect(
'notify::value', self._zoom_spin_notify_value_cb)
def zoom_in(self):
self._view.zoom_in()
self._update_zoom_buttons()
def _zoom_in_cb(self, button):
self.zoom_in()
def zoom_out(self):
self._view.zoom_out()
self._update_zoom_buttons()
def _zoom_out_cb(self, button):
self.zoom_out()
def zoom_to_width(self):
self._view.zoom_to_width()
self._update_zoom_buttons()
def _zoom_to_width_cb(self, button):
self.zoom_to_width()
def _update_zoom_buttons(self):
self._zoom_in.props.sensitive = self._view.can_zoom_in()
self._zoom_out.props.sensitive = self._view.can_zoom_out()
self._zoom_to_width.props.sensitive = self._view.can_zoom_to_width()
def _zoom_to_fit_menu_item_activate_cb(self, menu_item):
self._view.zoom_to_best_fit()
self._update_zoom_buttons()
def _actual_size_menu_item_activate_cb(self, menu_item):
self._view.zoom_to_actual_size()
self._update_zoom_buttons()
def _fullscreen_cb(self, button):
self.emit('go-fullscreen')
def __init__(self, book, name, tooltip, custom):
gtk.VBox.__init__(self)
self.book = book
self._changing = None
self._check = None
title = gtk.Toolbar()
# title checkbox
if custom:
self._check = gtk.CheckButton()
self._check.props.can_focus = False
self._check.props.tooltip_text = \
_('Articles are ready to be published')
self._check.connect('toggled', self._check_toggled_cb)
check_box = gtk.HBox()
check_box.set_size_request(50, -1)
check_box.pack_start(self._check, True, False)
title.insert(ToolWidget(check_box), -1)
else:
title.insert(ToolWidget(gtk.Label(' ')), -1)
# title caption
caption_label = gtk.Label(name)
caption_label.props.tooltip_text = tooltip
caption_label.modify_fg(gtk.STATE_NORMAL, COLOR_WHITE.get_gdk_color())
caption_box = gtk.HBox()
caption_box.pack_start(caption_label, False)
caption = gtk.EventBox()
caption.add(caption_box)
caption.modify_bg(gtk.STATE_NORMAL, COLOR_TOOLBAR_GREY.get_gdk_color())
title.insert(ToolWidget(caption), -1)
separator = gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
title.insert(separator, -1)
# create article button
if custom:
create = ToolButton('add',
padding=0,
tooltip=_('Create new article'))
create.connect('clicked', self._create_cb)
title.insert(create, -1)
else:
logger.debug('BookView(%s): listen for new articles' % name)
self.book.connect('article-added', self._article_added_cb)
# delete article button
delete = ToolButton('edit-delete',
padding=0,
tooltip=_('Delete current article'))
delete.connect('clicked', self._delete_cb)
title.insert(delete, -1)
# move buttons
downward = ToolButton('down',
padding=0,
tooltip=_('Move article downward'))
downward.connect('clicked', self._swap_cb, +1)
title.insert(downward, -1)
upward = ToolButton('up', padding=0, tooltip=_('Move article upward'))
upward.connect('clicked', self._swap_cb, -1)
title.insert(upward, -1)
# tree
self.store = gtk.ListStore(bool, str)
self.tree = gtk.TreeView(self.store)
self.tree.props.headers_visible = False
self.tree.connect('cursor-changed', self._cursor_changed_cb)
cell = gtk.CellRendererToggle()
cell.connect('toggled', self._cell_toggled_cb)
cell.props.activatable = True
column = self.tree.insert_column_with_attributes(0, '', cell, active=0)
column.props.sizing = gtk.TREE_VIEW_COLUMN_FIXED
column.props.fixed_width = 50
column.props.visible = custom
cell = gtk.CellRendererText()
cell.connect('edited', self._cell_edited_cb)
cell.props.editable = True
self.tree.insert_column_with_attributes(1, '', cell, text=1)
for i in self.book.index:
self.store.append((i['ready'], i['title']))
# scrolled tree
tree_scroll = gtk.ScrolledWindow()
tree_scroll.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
tree_scroll.add(self.tree)
self.pack_start(title, False)
self.pack_start(tree_scroll)
if len(self.store):
self.tree.set_cursor(0, self.tree.get_column(1), False)
if custom:
self._update_check(self.store[0][PUBLISH])
self.show_all()
def __init__(self, handle):
activity.Activity.__init__(self, handle, True)
self.max_participants = 1
# CHART_OPTIONS
self.x_label = ""
self.y_label = ""
self.chart_color = utils.get_user_fill_color('str')
self.chart_line_color = utils.get_user_stroke_color('str')
self.current_chart = None
self.charts_area = None
self.chart_data = []
# TOOLBARS
toolbarbox = ToolbarBox()
activity_button = ActivityToolbarButton(self)
activity_btn_toolbar = activity_button.page
activity_btn_toolbar.title.connect('changed', self._set_chart_title)
save_as_image = ToolButton("save-as-image")
save_as_image.connect("clicked", self._save_as_image)
save_as_image.set_tooltip(_("Save as image"))
activity_btn_toolbar.insert(save_as_image, -1)
save_as_image.show()
toolbarbox.toolbar.insert(activity_button, 0)
import_freespace = ToolButton("import-freespace")
import_freespace.connect("clicked", self.__import_freespace_cb)
import_freespace.set_tooltip(_("Read Freespace data"))
toolbarbox.toolbar.insert(import_freespace, -1)
import_freespace.show()
import_journal = ToolButton('import-journal')
import_journal.connect('clicked', self.__import_journal_cb)
import_journal.set_tooltip(_('Read Journal data'))
toolbarbox.toolbar.insert(import_journal, -1)
import_journal.show()
import_turtle = ToolButton('import-turtle')
import_turtle.connect('clicked', self.__import_turtle_cb)
import_turtle.set_tooltip(_('Read Turtle data'))
toolbarbox.toolbar.insert(import_turtle, -1)
import_turtle.show()
separator = gtk.SeparatorToolItem()
separator.set_draw(True)
separator.set_expand(False)
toolbarbox.toolbar.insert(separator, -1)
add_vbar_chart = RadioToolButton()
add_vbar_chart.connect("clicked", self._add_chart_cb, "vbar")
add_vbar_chart.set_tooltip(_("Vertical Bar Chart"))
add_vbar_chart.props.icon_name = "vbar"
charts_group = add_vbar_chart
toolbarbox.toolbar.insert(add_vbar_chart, -1)
add_hbar_chart = RadioToolButton()
add_hbar_chart.connect("clicked", self._add_chart_cb, "hbar")
add_hbar_chart.set_tooltip(_("Horizontal Bar Chart"))
add_hbar_chart.props.icon_name = "hbar"
add_hbar_chart.props.group = charts_group
toolbarbox.toolbar.insert(add_hbar_chart, -1)
add_pie_chart = RadioToolButton()
add_pie_chart.connect("clicked", self._add_chart_cb, "pie")
add_pie_chart.set_tooltip(_("Pie Chart"))
add_pie_chart.props.icon_name = "pie"
add_pie_chart.props.group = charts_group
add_pie_chart.set_active(True)
toolbarbox.toolbar.insert(add_pie_chart, -1)
self.chart_type_buttons = [
add_vbar_chart, add_hbar_chart, add_pie_chart
]
separator = gtk.SeparatorToolItem()
separator.set_draw(True)
separator.set_expand(False)
toolbarbox.toolbar.insert(separator, -1)
fullscreen_btn = ToolButton('view-fullscreen')
fullscreen_btn.set_tooltip(_('Fullscreen'))
fullscreen_btn.connect("clicked", self.__fullscreen_cb)
toolbarbox.toolbar.insert(fullscreen_btn, -1)
charthelp.create_help(toolbarbox.toolbar)
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)
# CANVAS
paned = gtk.HPaned()
box = gtk.VBox()
self.box = box
# Set the info box width to 1/3 of the screen:
def size_allocate_cb(widget, allocation):
paned.disconnect(self._setup_handle)
box_width = allocation.width / 3
box.set_size_request(box_width, -1)
self._setup_handle = paned.connect('size_allocate', size_allocate_cb)
scroll = gtk.ScrolledWindow()
scroll.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
self.labels_and_values = ChartData(self)
scroll.add(self.labels_and_values)
self.labels_and_values.connect("label-changed", self._label_changed)
self.labels_and_values.connect("value-changed", self._value_changed)
box.pack_start(scroll, True, True, 0)
paned.add1(box)
# CHARTS AREA
eventbox = gtk.EventBox()
self.charts_area = ChartArea(self)
self.charts_area.connect('size_allocate', self._chart_size_allocate)
eventbox.modify_bg(gtk.STATE_NORMAL, _WHITE)
eventbox.add(self.charts_area)
paned.add2(eventbox)
self.set_canvas(paned)
self.show_all()
class EntryToolbar(gtk.Toolbar):
__gsignals__ = {
'volume-error':
(gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE, ([str, str])),
}
def __init__(self):
gtk.Toolbar.__init__(self)
self._metadata = None
self._temp_file_path = None
self._resume = ToolButton('activity-start')
self._resume.connect('clicked', self._resume_clicked_cb)
self.add(self._resume)
self._resume.show()
client = gconf.client_get_default()
color = XoColor(client.get_string('/desktop/sugar/user/color'))
self._copy = ToolButton()
icon = Icon(icon_name='edit-copy', xo_color=color)
self._copy.set_icon_widget(icon)
icon.show()
self._copy.set_tooltip(_('Copy to'))
self._copy.connect('clicked', self._copy_clicked_cb)
self.add(self._copy)
self._copy.show()
self._duplicate = ToolButton()
icon = Icon(icon_name='edit-duplicate', xo_color=color)
self._duplicate.set_icon_widget(icon)
self._duplicate.set_tooltip(_('Duplicate'))
self._duplicate.connect('clicked', self._duplicate_clicked_cb)
self.add(self._duplicate)
separator = gtk.SeparatorToolItem()
self.add(separator)
separator.show()
erase_button = ToolButton('list-remove')
erase_button.set_tooltip(_('Erase'))
erase_button.connect('clicked', self._erase_button_clicked_cb)
self.add(erase_button)
erase_button.show()
def set_metadata(self, metadata):
self._metadata = metadata
self._refresh_copy_palette()
self._refresh_duplicate_palette()
self._refresh_resume_palette()
def _resume_clicked_cb(self, button):
misc.resume(self._metadata)
def _copy_clicked_cb(self, button):
button.palette.popup(immediate=True, state=Palette.SECONDARY)
def _duplicate_clicked_cb(self, button):
file_path = model.get_file(self._metadata['uid'])
try:
model.copy(self._metadata, '/')
except IOError, e:
logging.exception('Error while copying the entry.')
self.emit('volume-error',
_('Error while copying the entry. %s') % (e.strerror, ),
_('Error'))
def __init__(self, handle):
Activity.__init__(self, handle)
logger.debug('Starting Slider Puzzle activity... %s' %
str(get_bundle_path()))
os.chdir(get_bundle_path())
self.connect('destroy', self._destroy_cb)
self._sample_window = None
self.fixed = gtk.Fixed()
self.ui = SliderPuzzleUI(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()
btn_9 = ToolButton()
btn_9.set_tooltip(_('9 blocks'))
toolbar_box.toolbar.insert(btn_9, -1)
#btn_9.set_active(True)
btn_9.connect('clicked', self.ui.set_nr_pieces, 9)
btn_9.show()
btn_12 = ToolButton()
btn_12.set_tooltip(_('12 blocks'))
toolbar_box.toolbar.insert(btn_12, -1)
#btn_9.set_active(True)
btn_12.connect('clicked', self.ui.set_nr_pieces, 12)
btn_12.show()
btn_16 = ToolButton()
btn_16.set_tooltip(_('16 blocks'))
toolbar_box.toolbar.insert(btn_16, -1)
#btn_9.set_active(True)
btn_16.connect('clicked', self.ui.set_nr_pieces, 16)
btn_16.show()
btn_solve = ToolButton()
btn_solve.set_tooltip(_('Solve'))
toolbar_box.toolbar.insert(btn_solve, -1)
#btn_9.set_active(True)
btn_solve.connect('clicked', self.ui.do_solve)
btn_solve.show()
btn_shuffle = ToolButton()
btn_shuffle.set_tooltip(_('Shuffle'))
toolbar_box.toolbar.insert(btn_shuffle, -1)
#btn_9.set_active(True)
btn_shuffle.connect('clicked', self.ui.do_shuffle)
btn_shuffle.show()
btn_add = ToolButton()
btn_add.set_tooltip(_('Add Picture'))
toolbar_box.toolbar.insert(btn_add, -1)
#btn_9.set_active(True)
btn_add.connect('clicked', self.ui.do_add_image)
btn_add.show()
btn_select = ToolButton()
btn_select.set_tooltip(_('Add Picture'))
toolbar_box.toolbar.insert(btn_select, -1)
#btn_9.set_active(True)
btn_select.connect('clicked', self.do_samples_cb)
btn_select.show()
self.set_canvas(self.ui)
self.show_all()
self.frozen = FrozenState(self.ui)
self.ui.game.connect('shuffled', self.frozen.sync)
TubeHelper.__init__(self, tube_class=GameTube, service=SERVICE)
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 SensorToolbar(gtk.Toolbar):
""" The toolbar for resitance and voltage sensors """
__gsignals__ = {
'add-media': (gobject.SIGNAL_RUN_FIRST, None, [object]),
'add-opened': (gobject.SIGNAL_RUN_FIRST, None, [object])
}
def __init__(self, activity):
""" By default, start with resistance mode """
gtk.Toolbar.__init__(self)
self.mode = 'resistance'
self._STR_BASIC = \
_("Sensors, DC (connect sensor to pink 'Mic In' on left side of XO)") \
+ ' '
self._STR_R = _('Bias/Offset Enabled') + ' ' + _('Ohms') + ' '
self._STR_V = _('Bias/Offset Disabled') + ' ' + _('Volts') + ' '
self._STR_I = ' ' + _('Invert') + ' '
self.string_for_textbox = ""
self.activity = activity
self.activity.audiograb.set_sensor(self)
# Set up Resistance Button
if self.activity.has_toolbarbox:
self.resistance = ToolButton('bias-on')
else:
self.resistance = ToolButton('bias-on2')
self.insert(self.resistance, -1)
self.resistance.show()
self.resistance.set_tooltip(_('Resistance Sensor'))
self.resistance.connect('clicked', self.set_resistance_voltage_mode,
'resistance')
# Set up Voltage Button
self.voltage = ToolButton('bias-off')
self.insert(self.voltage, -1)
self.voltage.set_tooltip(_('Voltage Sensor'))
self.voltage.connect('clicked', self.set_resistance_voltage_mode,
'voltage')
# Set up Invert Button
self._invert = ToolButton('invert')
self.insert(self._invert, -1)
self._invert.set_tooltip(_('Invert'))
self._invert.connect('clicked', self._invert_control_cb)
self.activity.wave.set_invert_state(False)
separator = gtk.SeparatorToolItem()
separator.props.draw = True
self.insert(separator, -1)
self.audiobutton = ToolButton('add-icon')
self.insert(self.audiobutton, -1)
self.audiobutton.show()
self.audiobutton.set_tooltip('Close Sound')
self.audiobutton.connect('clicked', self.addAudio)
self.connect('add-media', self.addThisAudio)
self.insert(separator, -1)
self.insert(separator, -1)
self.openedbutton = ToolButton('delete-icon')
self.insert(self.openedbutton, -1)
self.openedbutton.show()
self.openedbutton.set_tooltip('Open Sound')
self.openedbutton.connect('clicked', self.addOpenedAudio)
self.connect('add-opened', self.addThisOpenedAudio)
self.insert(separator, -1)
self.insert(separator, -1)
# Set up Logging Interval combo box
self.loginterval_img = gtk.Image()
self.loginterval_img.set_from_file(ICONS_DIR + '/sample_rate.svg')
self.loginterval_img_tool = gtk.ToolItem()
self.loginterval_img_tool.add(self.loginterval_img)
self.insert(self.loginterval_img_tool, -1)
self._loginterval_combo = ComboBox()
self.interval = [
_('1/10 second'),
_('1 second'),
_('30 seconds'),
_('5 minutes'),
_('30 minutes')
]
if hasattr(self._loginterval_combo, 'set_tooltip_text'):
self._loginterval_combo.set_tooltip_text(_('Sampling interval'))
self._interval_changed_id = self._loginterval_combo.connect(
"changed", self.loginterval_control)
for i, s in enumerate(self.interval):
self._loginterval_combo.append_item(i, s, None)
if s == _('1 second'):
self._loginterval_combo.set_active(i)
self._loginterval_tool = ToolComboBox(self._loginterval_combo)
self.insert(self._loginterval_tool, -1)
self.logginginterval_status = '1 second'
# Set up Logging/Stop Logging Button
self._record = ToolButton('media-record')
self.insert(self._record, -1)
self._record.set_tooltip(_('Start Recording'))
self._record.connect('clicked', self.record_control)
self.show_all()
def addAudio(self, button):
#self.activity.showFileLoadBlocker(True)
fp = FilePicker()
dOb = fp.show()
if (dOb != None):
if (dOb.file_path != None):
self.emit('add-media', dOb)
#self.activity.showFileLoadBlocker(False)
def addOpenedAudio(self, button):
fp = FilePicker()
dOb = fp.show()
if (dOb != None):
if (dOb.file_path != None):
self.emit('add-opened', dOb)
def addThisAudio(self, ot, datastoreOb):
self.activity.closedSound = datastoreOb
#self.activity.playsound.setLocation("file://"+datastoreOb.file_path)
#self.activity.playsound.play()
def addThisOpenedAudio(self, ot, datastoreOb):
self.activity.openedSound = datastoreOb
def set_sample_value(self, label=None):
""" Write a sample value to the textbox """
gtk.threads_enter()
self._update_string_for_textbox(label)
gtk.threads_leave()
return
def record_control(self, data=None):
"""Depending upon the selected interval, does either
a logging session, or just logs the current buffer"""
if not self.activity.LOGGING_IN_SESSION:
Xscale = (1.00 / self.activity.audiograb.get_sampling_rate())
Yscale = 0.0
interval = self.interval_convert()
username = self.activity.nick
print "calling start new session"
self.activity.ji.start_new_session(username, Xscale, Yscale,
_(self.logginginterval_status))
self.activity.audiograb.set_logging_params(True, interval, False)
self.activity.LOGGING_IN_SESSION = True
self._record.set_icon('record-stop')
self._record.show()
self._record.set_tooltip(_('Stop Recording'))
else:
self.activity.audiograb.set_logging_params(False)
self.activity.LOGGING_IN_SESSION = False
self._record.set_icon('media-record')
self._record.show()
self._record.set_tooltip(_('Start Recording'))
def interval_convert(self):
"""Converts interval string to an integer that denotes the number
of times the audiograb buffer must be called before a value is written.
When set to 0, the whole of current buffer will be written"""
interval_dictionary = {
'1/10 second': 0.1,
'1 second': 1,
'30 seconds': 30,
'5 minutes': 300,
'30 minutes': 1800
}
try:
return interval_dictionary[self.logginginterval_status]
except ValueError:
logging.error('logging interval status = %s' %\
(str(self.logginginterval_status)))
return 0
def loginterval_control(self, combobox):
""" Callback from the Logging Interval Combo box: sets status """
if self._loginterval_combo.get_active() != -1:
intervals = [
'1/10 second', '1 second', '30 seconds', '5 minutes',
'30 minutes'
]
self.logginginterval_status = \
intervals[self._loginterval_combo.get_active()]
def set_resistance_voltage_mode(self, data=None, mode_to_set='resistance'):
""" Callback for Resistance/Voltage Buttons """
# Make sure the current context is for sensor capture.
if self.activity.CONTEXT != 'sensor':
self.activity.set_sensor_context()
self.set_mode(mode_to_set)
if mode_to_set == 'resistance':
self.resistance.set_icon('bias-on2')
self.voltage.set_icon('bias-off')
self.resistance.show()
self.voltage.show()
self._update_string_for_textbox()
if self.activity.has_toolbarbox:
self.activity.label_button.set_icon('bias-on2')
self.activity.label_button.set_tooltip(_('Resistance Sensor'))
elif mode_to_set == 'voltage':
self.resistance.set_icon('bias-on')
self.voltage.set_icon('bias-off2')
self.resistance.show()
self.voltage.show()
self._update_string_for_textbox()
if self.activity.has_toolbarbox:
self.activity.label_button.set_icon('bias-off2')
self.activity.label_button.set_tooltip(_('Voltage Sensor'))
else:
logging.error('unknown mode %s' % (mode_to_set))
if self.activity.has_toolbarbox:
self.activity.sound_toolbar.time.set_icon('domain-time')
self.activity.sound_toolbar.freq.set_icon('domain-freq')
return False
def _invert_control_cb(self, data=None):
""" Callback for Invert Button """
if self.activity.wave.get_invert_state():
self.activity.wave.set_invert_state(False)
self._invert.set_icon('invert')
self._invert.show()
else:
self.activity.wave.set_invert_state(True)
self._invert.set_icon('invert2')
self._invert.show()
self._update_string_for_textbox()
return False
def set_mode(self, mode='resistance'):
""" Set the mixer settings to match the current mode. """
self.mode = mode
self.activity.audiograb.set_sensor_type(self.mode)
return
def context_off(self):
""" Called when sensor toolbar is no longer selected. """
self.activity.audiograb.pause_grabbing()
def context_on(self):
""" Called when sensor toolbar is selected. """
self.activity.audiograb.resume_grabbing()
self.activity.audiograb.set_sensor_type(self.mode)
self._update_string_for_textbox()
self.activity.wave.set_trigger(self.activity.wave.TRIGGER_NONE)
return False
def _update_string_for_textbox(self, value=None):
""" Update the status field at the bottom of the canvas. """
self.string_for_textbox = ""
self.string_for_textbox += (self._STR_BASIC + "\n")
if self.mode == 'resistance':
self.string_for_textbox += self._STR_R
else:
self.string_for_textbox += self._STR_V
if self.activity.wave.get_invert_state():
self.string_for_textbox += self._STR_I
if value is not None:
self.string_for_textbox += '\t(%s)' % (str(value))
self.activity.text_box.set_data_params(0, self.string_for_textbox)
def __init__(self, client, event):
gtk.Window.__init__(self)
self._client = client
self._event = event
self.set_decorated(False)
self.set_position(gtk.WIN_POS_CENTER_ALWAYS)
self.set_border_width(style.LINE_WIDTH)
window = gtk.VBox()
self.add(window)
toolbar = gtk.Toolbar()
window.pack_start(toolbar, False)
icon = Icon()
icon.set_from_icon_name('emblem-warning', gtk.ICON_SIZE_LARGE_TOOLBAR)
icon.props.xo_color = profile.get_color()
tool_item = gtk.ToolItem()
tool_item.add(icon)
toolbar.insert(tool_item, -1)
separator = gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_size_request(style.DEFAULT_SPACING, -1)
toolbar.insert(separator, -1)
title = gtk.Label(_('Submit failure report'))
tool_item = gtk.ToolItem()
tool_item.add(title)
toolbar.insert(tool_item, -1)
separator = gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
toolbar.insert(separator, -1)
submit = ToolButton('dialog-ok', tooltip=_('Submit'))
submit.connect('clicked', lambda button: self._submit())
toolbar.insert(submit, -1)
cancel = ToolButton('dialog-cancel', tooltip=_('Cancel'))
cancel.connect('clicked', lambda button: self.destroy())
toolbar.insert(cancel, -1)
bg = gtk.EventBox()
bg.modify_bg(gtk.STATE_NORMAL, style.COLOR_WHITE.get_gdk_color())
window.pack_start(bg)
canvas = gtk.VBox()
canvas.set_border_width(style.DEFAULT_SPACING)
canvas.props.spacing = style.DEFAULT_SPACING
bg.add(canvas)
box = gtk.HBox()
box.props.spacing = style.DEFAULT_SPACING
canvas.pack_start(box, False)
if 'icon' in event:
icon = Icon(file=event['icon'], pixel_size=style.XLARGE_ICON_SIZE)
else:
icon = Icon()
icon.set_from_icon_name('emblem-warning',
gtk.ICON_SIZE_LARGE_TOOLBAR)
box.pack_start(icon, False)
label = gtk.Label()
label.props.use_markup = True
if 'solution' in event:
activity_name = '%(name)s-%(version)s' % event['solution'][0]
else:
activity_name = event['context']
label.props.label = '<b>%s</b>\n%s' % (activity_name, event['error'])
label.props.wrap = True
box.pack_start(label, False)
frame = gtk.Frame(
_('Optionally, describe the problem in common sentences'))
canvas.pack_start(frame)
self._message = gtk.TextView()
scrolled = gtk.ScrolledWindow()
scrolled.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
scrolled.set_border_width(style.DEFAULT_PADDING)
scrolled.add(self._message)
frame.add(scrolled)
frame = gtk.Frame(_('Log'))
canvas.pack_start(frame)
text = gtk.TextView()
text.props.editable = False
if 'trace' in event:
text.props.buffer.props.text = '\n'.join(event['trace'])
scrolled = gtk.ScrolledWindow()
scrolled.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
scrolled.set_border_width(style.DEFAULT_PADDING)
scrolled.add(text)
frame.add(scrolled)
self.show_all()
self.set_focus(self._message)
self.connect('realize', self.__realize_cb)
gap = style.GRID_CELL_SIZE
width = gtk.gdk.screen_width() - gap * 2
height = gtk.gdk.screen_height() - gap * 2
self.set_size_request(width, height)
self.move(gap, gap)
class EcomundoActivity(activity.Activity):
def __init__(self, handle):
activity.Activity.__init__(self, handle)
self.set_title("Ecomundo")
print "Init activity Ecomundo"
#print os.path.abspath(__file__)
toolbox = activity.ActivityToolbox(self)
self.toolbar = gtk.Toolbar()
toolbox.add_toolbar(_('Ecomundo'), self.toolbar)
self.toolbar.show()
self.set_toolbox(toolbox)
toolbox.show()
self.btnNew = ToolButton('reload')
self.btnNew.connect('clicked', self.onBtNewClicked)
self.toolbar.insert(self.btnNew, -1)
self.btnNew.show()
self.btPlay = ToolButton('next')
self.btPlay.connect('clicked', self.onBtPlayClicked)
self.toolbar.insert(self.btPlay, -1)
self.btPlay.show()
self.btStop = ToolButton('process-stop')
self.btStop.connect('clicked', self.onBtStopClicked)
self.toolbar.insert(self.btStop, -1)
self.btStop.show()
self.btStop.props.sensitive = False
self.btPlay.props.sensitive = True
toolbox.set_current_toolbar(1)
hBox = gtk.HBox(False, 0)
self.set_canvas(hBox)
self.drawingarea1 = gtk.DrawingArea()
self.drawingarea1.set_size_request(
World.SIZE_WORLD + (2 * World.MARGEN),
World.SIZE_WORLD + (2 * World.MARGEN))
self.drawingarea1.show()
hBox.pack_start(self.drawingarea1, False, True, 5)
table = gtk.Table(rows=4, columns=2, homogeneous=False)
hBox.pack_start(table, False, False, 5)
label_attributes = pango.AttrList()
label_attributes.insert(pango.AttrSize(14000, 0, -1))
label_attributes.insert(
pango.AttrForeground(65535, 65535, 65535, 0, -1))
lbTitle = gtk.Label()
lbTitle.set_attributes(label_attributes)
lbTitle.set_text(_('Initial Values'))
#table.attach(lbTitle, 0, 1, 0, 1,yoptions=gtk.SHRINK,xpadding=5)
table.attach(lbTitle, 0, 2, 0, 1, yoptions=gtk.SHRINK, xpadding=10)
lbGreen = gtk.Label()
lbGreen.set_attributes(label_attributes)
lbGreen.set_text(_('Green'))
table.attach(lbGreen,
0,
1,
1,
2,
yoptions=gtk.SHRINK,
xoptions=gtk.SHRINK,
xpadding=10)
adjGreen = gtk.Adjustment(10, 1, 400, 1, 1, 0)
self.spbGreen = gtk.SpinButton(adjustment=adjGreen,
climb_rate=1.0,
digits=2)
table.attach(self.spbGreen,
1,
2,
1,
2,
yoptions=gtk.SHRINK,
xoptions=gtk.SHRINK,
ypadding=10)
lbRabbit = gtk.Label()
lbRabbit.set_attributes(label_attributes)
lbRabbit.set_text(_('Rabbits'))
table.attach(lbRabbit,
0,
1,
2,
3,
yoptions=gtk.SHRINK,
xoptions=gtk.SHRINK,
xpadding=10)
adjRabbit = gtk.Adjustment(10, 1, 400, 1, 1, 0)
self.spbRabbit = gtk.SpinButton(adjustment=adjRabbit,
climb_rate=1.0,
digits=2)
table.attach(self.spbRabbit,
1,
2,
2,
3,
yoptions=gtk.SHRINK,
xoptions=gtk.SHRINK,
ypadding=10)
lbFox = gtk.Label()
lbFox.set_attributes(label_attributes)
lbFox.set_text(_('Foxs'))
table.attach(lbFox,
0,
1,
3,
4,
yoptions=gtk.SHRINK,
xoptions=gtk.SHRINK,
xpadding=10)
adjFox = gtk.Adjustment(10, 1, 400, 1, 1, 0)
self.spbFox = gtk.SpinButton(adjustment=adjFox,
climb_rate=1.0,
digits=2)
table.attach(self.spbFox,
1,
2,
3,
4,
yoptions=gtk.SHRINK,
xoptions=gtk.SHRINK,
ypadding=10)
print "test resize"
print "antes de initWorld"
initWorld()
print "antes de init Green"
initGreen()
print "antes de init Animals"
initAnimals()
hBox.resize_children()
hBox.show_all()
self.drawingarea1.connect('expose-event', self.onDrawingAreaExposed)
def onDrawingAreaExposed(self, da, event):
#print "drawingarea exposed"
x, y, width, height = da.allocation
ctx = da.window.cairo_create()
drawStateWorld(ctx)
drawGrid(ctx)
def onBtPlayClicked(self, widget):
self.btStop.props.sensitive = True
self.btPlay.props.sensitive = False
world.playState = True
source_id = gobject.timeout_add(2000, updateState, self.drawingarea1)
# http://www.pygtk.org/pygtk2tutorial-es/ch-TimeoutsIOAndIdleFunctions.html#sec-Timeouts
def onBtStopClicked(self, widget):
self.btStop.props.sensitive = False
self.btPlay.props.sensitive = True
world.playState = False
def onBtNewClicked(self, widget):
initWorld()
world.initialGreen = self.spbGreen.get_value_as_int()
world.initialRabbits = self.spbRabbit.get_value_as_int()
world.initialFoxs = self.spbFox.get_value_as_int()
initGreen()
initAnimals()
# Despues de esto hay que recargar la pantalla
drawingarea1 = self.drawingarea1
ctx = drawingarea1.window.cairo_create()
drawStateWorld(ctx)
drawGrid(ctx)
def __init__(self, activity):
self._activity = activity
GtkSourceview2Editor.__init__(self, activity)
#set the default contents for edit,override fixed font size
self.font_size = activity.debug_dict.get('font_size', 8)
self.find_window = None
self.editbar = gtk.Toolbar()
self.last_folder = None
editopen = ToolButton()
editopen.set_stock_id('gtk-new')
editopen.set_icon_widget(None)
editopen.set_tooltip(_('New File'))
editopen.connect('clicked', self._new_file_cb)
editopen.add_accelerator('clicked', activity.accelerator, ord('N'),
gtk.gdk.CONTROL_MASK, gtk.ACCEL_VISIBLE)
#editopen.props.accelerator = '<Ctrl>O'
editopen.show()
self.editbar.insert(editopen, -1)
editfile = ToolButton()
editfile.set_stock_id('gtk-open')
editfile.set_icon_widget(None)
editfile.set_tooltip(_('Open File'))
editfile.connect('clicked', self._read_file_cb)
editfile.add_accelerator('clicked', activity.accelerator, ord('O'),
gtk.gdk.CONTROL_MASK, gtk.ACCEL_VISIBLE)
#editfile.props.accelerator = '<Ctrl>O'
editfile.show()
self.editbar.insert(editfile, -1)
editsave = ToolButton()
editsave.set_stock_id('gtk-save')
editsave.set_icon_widget(None)
editsave.set_tooltip(_('Save File'))
editsave.add_accelerator('clicked', activity.accelerator, ord('S'),
gtk.gdk.CONTROL_MASK, gtk.ACCEL_VISIBLE)
#editsave.props.accelerator = '<Ctrl>S'
editsave.connect('clicked', self.save_cb)
editsave.show()
self.editbar.insert(editsave, -1)
editsaveas = ToolButton()
editsaveas.set_stock_id('gtk-save-as')
editsaveas.set_icon_widget(None)
editsaveas.set_tooltip(_('Save As'))
#editsaveas.props.accelerator = '<Ctrl>S'
editsaveas.connect('clicked', self.save_file_cb)
editsaveas.show()
self.editbar.insert(editsaveas, -1)
"""
editjournal = ToolButton(tooltip=_('Open Journal'))
client = gconf.client_get_default()
color = XoColor(client.get_string('/desktop/sugar/user/color'))
journal_icon = Icon(icon_name='document-save', xo_color=color)
editjournal.set_icon_widget(journal_icon)
editjournal.connect('clicked', self._show_journal_object_picker_cb)
#editjournal.props.accelerator = '<Ctrl>J'
editjournal.show()
self.editbar.insert(editjournal, -1)
"""
separator = gtk.SeparatorToolItem()
separator.set_draw(True)
separator.show()
self.editbar.insert(separator, -1)
editundo = ToolButton('undo')
editundo.set_tooltip(_('Undo'))
editundo.connect('clicked', self.undo)
editundo.add_accelerator('clicked', activity.accelerator, ord('Z'),
gtk.gdk.CONTROL_MASK, gtk.ACCEL_VISIBLE)
#editundo.props.accelerator = '<Ctrl>Z'
editundo.show()
self.editbar.insert(editundo, -1)
editredo = ToolButton('redo')
editredo.set_tooltip(_('Redo'))
editredo.connect('clicked', self.redo)
editredo.add_accelerator('clicked', activity.accelerator, ord('Y'),
gtk.gdk.CONTROL_MASK, gtk.ACCEL_VISIBLE)
#editredo.props.accelerator = '<Ctrl>Y'
editredo.show()
self.editbar.insert(editredo, -1)
separator = gtk.SeparatorToolItem()
separator.set_draw(True)
separator.show()
self.editbar.insert(separator, -1)
editcut = ToolButton()
editcut.set_stock_id('gtk-cut')
editcut.set_icon_widget(None)
editcut.set_tooltip(_('Cut'))
self.edit_cut_handler_id = editcut.connect('clicked', self.cut)
editcut.add_accelerator('clicked', activity.accelerator, ord('X'),
gtk.gdk.CONTROL_MASK, gtk.ACCEL_VISIBLE)
#editcut.props.accelerator = '<Ctrl>X'
self.editbar.insert(editcut, -1)
editcut.show()
editcopy = ToolButton('edit-copy')
editcopy.set_tooltip(_('Copy'))
self.edit_copy_handler_id = editcopy.connect('clicked',
self.copy_to_clipboard_cb)
editcopy.add_accelerator('clicked', activity.accelerator, ord('C'),
gtk.gdk.CONTROL_MASK, gtk.ACCEL_VISIBLE)
#editcopy.props.accelerator = '<Ctrl>C'
self.editbar.insert(editcopy, -1)
editcopy.show()
editpaste = ToolButton('edit-paste')
editpaste.set_tooltip(_('Paste'))
self.edit_paste_handler_id = editpaste.connect('clicked', self.paste)
editpaste.add_accelerator('clicked', activity.accelerator, ord('V'),
gtk.gdk.CONTROL_MASK, gtk.ACCEL_VISIBLE)
#editpaste.props.accelerator = '<Ctrl>V'
editpaste.show()
self.editbar.insert(editpaste, -1)
"""
separator = gtk.SeparatorToolItem()
separator.set_draw(True)
separator.show()
self.editbar.insert(separator, -1)
"""
editfind = ToolButton('viewmag1')
editfind.set_tooltip(_('Find and Replace'))
editfind.connect('clicked', self.show_find)
editfind.add_accelerator('clicked', activity.accelerator, ord('F'),
gtk.gdk.CONTROL_MASK, gtk.ACCEL_VISIBLE)
#editfind.props.accelerator = '<Ctrl>F'
editfind.show()
self.editbar.insert(editfind, -1)
"""
separator = gtk.SeparatorToolItem()
separator.set_draw(True)
separator.show()
self.editbar.insert(separator, -1)
"""
self.zoomout = ToolButton('zoom-out')
self.zoomout.set_tooltip(_('Zoom out'))
self.zoomout.connect('clicked', self.__zoomout_clicked_cb)
self.editbar.insert(self.zoomout, -1)
self.zoomout.show()
self.zoomin = ToolButton('zoom-in')
self.zoomin.set_tooltip(_('Zoom in'))
self.zoomin.connect('clicked', self.__zoomin_clicked_cb)
self.editbar.insert(self.zoomin, -1)
self.zoomin.show()
stop_button = ToolButton('activity-stop')
stop_button.set_tooltip(_('Stop'))
#stop_button.props.accelerator = '<Ctrl>Q'
stop_button.connect('clicked', self.__stop_clicked_cb)
self.editbar.insert(stop_button, -1)
stop_button.show()
self.editbar.show_all()
class Jam2JamToolBar(gtk.Toolbar):
def __init__(self, activity):
gtk.Toolbar.__init__(self)
self.activity = activity
self.parameters = ['Density', 'Pitch', 'Length', 'Timbre', 'Volume'] # no tempo here.
scene_stuff = readScenes(self.activity._ScenePath)
self.scenes = scene_stuff.get_scene_list()
#example of scene data. This gets read from file
#self.scenes = [['City', 'A', 'minor pentatonic'], ['City', 'G#', 'major']] #this data needs to be obtained from directories
self.play_pause_state = 'Playing'
self.scene_init = True
# Separator
separator = gtk.SeparatorToolItem()
separator.set_draw(True)
self.insert(separator, -1)
#Horizontal Parameter control combobox
self._add_widget(gtk.Label(_('Horizontal:')))
self._Hparameter_combo = ToolComboBox()
for i, f in enumerate(self.parameters):
self._Hparameter_combo.combo.append_item(i, f)
self._Hparameter_combo.combo.connect('changed', self._Hparameter_change_cb)
self._add_widget(self._Hparameter_combo)
self._Hparameter_combo.combo.set_active(0)
# Separator
separator = gtk.SeparatorToolItem()
separator.set_draw(True)
separator.show()
self.insert(separator, -1)
#Vertical Parameter control combobox
self._add_widget(gtk.Label(_('Vertical:')))
self._Vparameter_combo = ToolComboBox()
for j, k in enumerate(self.parameters):
self._Vparameter_combo.combo.append_item(j, k)
self._Vparameter_combo.combo.connect('changed', self._Vparameter_change_cb)
self._add_widget(self._Vparameter_combo)
self._Vparameter_combo.combo.set_active(1)
# Separator
separator = gtk.SeparatorToolItem()
separator.set_draw(True)
separator.show()
self.insert(separator, -1)
#Scene Selection control combobox
self._add_widget(gtk.Label(_('Scene:')))
self._Scene_combo = ToolComboBox()
for l, m in enumerate(self.scenes):
self._Scene_combo.combo.append_item(l, m[0])
self._Scene_combo.combo.connect('changed', self._Scene_change_cb)
self._add_widget(self._Scene_combo)
#ought to do this safely somehow.
self._Scene_combo.combo.set_active(0)
self.scene_init = False
# Separator
separator = gtk.SeparatorToolItem()
separator.set_draw(True)
separator.show()
self.insert(separator, -1)
#Camera Button
self.camera_ready = True
camera_icon = ImagePath + "/camera-external.svg"
camera_busy_icon = ImagePath + "/camera-busy.svg"
self.camera_image, self.camera_busy_image = gtk.Image(), gtk.Image()
self.camera_image.set_from_file(camera_icon)
self.camera_busy_image.set_from_file(camera_busy_icon)
self.camera_image.show()
#camera_busy_image.show()
self._cameraButton = ToolButton()
self._cameraButton.set_icon_widget(self.camera_image)
self._cameraButton.connect('clicked', self._cameraSnap_cb)
self._cameraButton.set_tooltip(_('Snapshot'))
self.insert(self._cameraButton, -1)
self._cameraButton.show()
# Separator
separator = gtk.SeparatorToolItem()
separator.set_draw(True)
separator.show()
self.insert(separator, -1)
#Play/Pause Button
pause_icon = ImagePath + "/media-playback-pause.svg"
play_icon = ImagePath + "/media-playback-start.svg"
self.pause_image = gtk.Image()
self.pause_image.set_from_file(pause_icon)
self.play_image = gtk.Image()
self.play_image.set_from_file(play_icon)
self._pauseButton = ToolButton()
self._pauseButton.connect('clicked', self._pause_cb)
self.pause_image.show()
self._pauseButton.set_icon_widget(self.pause_image)
self._pauseButton.set_tooltip(_('Pause'))
#self._toggleplay_pause()
self.insert(self._pauseButton, -1)
self._pauseButton.show()
# Separator
separator = gtk.SeparatorToolItem()
separator.set_draw(True)
separator.show()
self.insert(separator, -1)
def _add_widget(self, widget, expand=False):
tool_item = gtk.ToolItem()
tool_item.set_expand(expand)
tool_item.add(widget)
widget.show()
self.insert(tool_item, -1)
tool_item.show()
def _toggleplay_pause(self):
if self.play_pause_state == "Playing":
self.activity.jamScene.music_player.pause()
self.play_image.show()
self._pauseButton.set_icon_widget(self.play_image)
self._pauseButton.set_tooltip(_('Play'))
self.play_pause_state = "Paused"
else:
self.activity.jamScene.music_player.resume()
self.pause_image.show()
self._pauseButton.set_icon_widget(self.pause_image)
self._pauseButton.set_tooltip(_('Pause'))
self.play_pause_state = "Playing"
try:
self.activity._pgc.grab_focus()
except AttributeError:
pass
def _show_busy_camera(self):
self.camera_ready = False
self.camera_busy_image.show()
self._cameraButton.set_icon_widget(self.camera_busy_image)
self._cameraButton.set_tooltip(_('Please wait...'))
def _show_active_camera(self):
self.camera_image.show()
self._cameraButton.set_icon_widget(self.camera_image)
self._cameraButton.set_tooltip(_('Snap'))
self.camera_ready = True
def _Hparameter_change_cb(self, widget):
param = "Parameter|Horizontal|" + self.parameters[self._Hparameter_combo.combo.get_active()]
olpcgames.eventwrap.post(olpcgames.eventwrap.Event(pygame.USEREVENT, action=param))
try:
self.activity._pgc.grab_focus()
except AttributeError:
pass
def _Vparameter_change_cb(self, widget):
param = "Parameter|Vertical|" + self.parameters[self._Vparameter_combo.combo.get_active()]
olpcgames.eventwrap.post(olpcgames.eventwrap.Event(pygame.USEREVENT, action=param))
try:
self.activity._pgc.grab_focus()
except AttributeError:
pass
def _Scene_change_cb(self, widget):
if self.scene_init:
pass
else:
selection = self.scenes[self._Scene_combo.combo.get_active()]
scene = "Reload|" + '|'.join(map(lambda x: str(x), selection))
olpcgames.eventwrap.post(olpcgames.eventwrap.Event(pygame.USEREVENT, action=scene))
try:
self.activity._pgc.grab_focus()
except AttributeError:
pass
### functions to assist calls from pygame
def deactivate_scene_change(self):
self._Scene_combo.set_sensitive(False)
def reactivate_scene_change(self):
self._Scene_combo.set_sensitive(True)
def set_horizontal_parameter(self, param):
ndx = self.parameters.index(param)
self._Hparameter_combo.combo.set_active(ndx)
def set_vertical_parameter(self, param):
ndx = self.parameters.index(param)
self._Vparameter_combo.combo.set_active(ndx)
def _cameraSnap_cb(self, widget):
"Here I could wrap a camera event..."
def snaptime():
snap = CameraSnap()
self.activity.cameras_loaded.append(snap)
picpath = snap.Snap()
self.activity.load_image(picpath)
snap.Stop()
self._show_active_camera()
self.activity._pgc.grab_focus()
if self.camera_ready:
self._show_busy_camera()
thread.start_new_thread(snaptime, ())
else:
log.info('Ignoring request to use camera, as camera is currently busy')
def _pause_cb(self, widget):
self._toggleplay_pause()
log.info("Play/Pause Button pressed")
def __init__(self, handle):
activity.Activity.__init__(self, handle)
if HASTOOLBARBOX:
self.max_participants = 1
toolbar_box = ToolbarBox()
self.set_toolbar_box(toolbar_box)
activity_button = ActivityToolbarButton(self)
toolbar_box.toolbar.insert(activity_button, 0)
separator = gtk.SeparatorToolItem()
separator.props.draw = True
activity_button.props.page.insert(separator, -1)
separator.show()
tool = ToolButton('pdf-export')
tool.set_tooltip(_('Portable Document Format (PDF)'))
tool.connect('clicked', self.__export_pdf_cb)
activity_button.props.page.insert(tool, -1)
tool.show()
tool = ToolButton('png-export')
tool.set_tooltip(_('Portable Network Graphic (PNG)'))
tool.connect('clicked', self.__export_png_cb)
activity_button.props.page.insert(tool, -1)
tool.show()
tool = ToolbarButton()
self.edit_toolbar = EditToolbar(self)
tool.props.page = self.edit_toolbar
tool.props.icon_name = 'toolbar-edit'
tool.props.label = _('Edit'),
toolbar_box.toolbar.insert(tool, -1)
self._undo = UndoManager.UndoManager(self,
self.edit_toolbar.undo.child,
self.edit_toolbar.redo.child)
self.__build_main_canvas_area()
tool = ToolbarButton()
tool.props.page = ViewToolbar(self._main_area)
tool.props.icon_name = 'toolbar-view'
tool.props.label = _('View'),
toolbar_box.toolbar.insert(tool, -1)
tool = ToolbarButton()
self.text_format_toolbar = TextAttributesToolbar(self._main_area)
tool.props.page = self.text_format_toolbar
tool.props.icon_name = 'toolbar-text'
tool.props.label = _('Text')
toolbar_box.toolbar.insert(tool, -1)
# self._main_area.set_text_attributes(self.text_format_toolbar)
self.thought_toolbar = ToolbarButton()
self.thought_toolbar.props.page = ThoughtsToolbar(self)
self.thought_toolbar.props.icon_name = 'thought'
self.thought_toolbar.props.label = _('Thought Type')
toolbar_box.toolbar.insert(self.thought_toolbar, -1)
self.action_buttons = ActionButtons(self)
toolbar_box.show_all()
else:
# Use old <= 0.84 toolbar design
toolbox = activity.ActivityToolbox(self)
self.set_toolbox(toolbox)
activity_toolbar = toolbox.get_activity_toolbar()
keep_palette = activity_toolbar.keep.get_palette()
menu_item = MenuItem(_('Portable Document Format (PDF)'))
menu_item.connect('activate', self.__export_pdf_cb)
keep_palette.menu.append(menu_item)
menu_item.show()
menu_item = MenuItem(_('Portable Network Graphic (PNG)'))
menu_item.connect('activate', self.__export_png_cb)
keep_palette.menu.append(menu_item)
menu_item.show()
self.edit_toolbar = EditToolbar(self)
toolbox.add_toolbar(_('Edit'), self.edit_toolbar)
separator = gtk.SeparatorToolItem()
self.edit_toolbar.insert(separator, 0)
self.edit_toolbar.show()
self._undo = UndoManager.UndoManager(self,
self.edit_toolbar.undo.child,
self.edit_toolbar.redo.child)
self.__build_main_canvas_area()
view_toolbar = ViewToolbar(self._main_area)
toolbox.add_toolbar(_('View'), view_toolbar)
activity_toolbar = toolbox.get_activity_toolbar()
activity_toolbar.share.props.visible = False
toolbox.set_current_toolbar(1)
self.show_all()
self.__configure_cb(None)
self._mode = MMapArea.MODE_TEXT
self._main_area.set_mode(self._mode)
self.set_focus_child(self._main_area)
class AboutMeActivity(activity.Activity):
def colour_changed_callback(self, widget, type):
colour = widget.get_current_color()
red = "%x" % int(colour.red / 65535.0 * 255)
if len(red) == 1:
red = "0%s" % red
green = "%x" % int(colour.green / 65535.0 * 255)
if len(green) == 1:
green = "0%s" % green
blue = "%x" % int(colour.blue / 65535.0 * 255)
if len(blue) == 1:
blue = "0%s" % blue
new_colour = "#%s%s%s" % (red, green, blue)
if type == "out":
in_colour = self.in_colour_selector.get_current_color()
red = "%x" % int(in_colour.red / 65535.0 * 255)
if len(red) == 1:
red = "0%s" % red
green = "%x" % int(in_colour.green / 65535.0 * 255)
if len(green) == 1:
green = "0%s" % green
blue = "%x" % int(in_colour.blue / 65535.0 * 255)
if len(blue) == 1:
blue = "0%s" % blue
in_colour = "#%s%s%s" % (red, green, blue)
self.icon.props.xo_color = XoColor("%s,%s" %
(new_colour, in_colour))
if type == "in":
out_colour = self.out_colour_selector.get_current_color()
red = "%x" % int(out_colour.red / 65535.0 * 255)
if len(red) == 1:
red = "0%s" % red
green = "%x" % int(out_colour.green / 65535.0 * 255)
if len(green) == 1:
green = "0%s" % green
blue = "%x" % int(out_colour.blue / 65535.0 * 255)
if len(blue) == 1:
blue = "0%s" % blue
out_colour = "#%s%s%s" % (red, green, blue)
self.icon.props.xo_color = XoColor("%s,%s" %
(out_colour, new_colour))
def apply(self, widget):
nick = unicode(self.name_entry.get_text(), 'utf-8')
if nick != self.current_nick:
self.client.set_string("/desktop/sugar/user/nick", nick)
colour = self.icon._buffer.xo_color.to_string()
if colour != self.current_colour:
self.client.set_string("/desktop/sugar/user/color", colour)
def __init__(self, handle):
activity.Activity.__init__(self, handle)
self.client = gconf.client_get_default()
self.current_nick = self.client.get_string("/desktop/sugar/user/nick")
self.current_colour = self.client.get_string(
"/desktop/sugar/user/color")
self.current_colours = _parse_string(self.current_colour)
self.toolbox = activity.ActivityToolbox(self)
activity_toolbar = self.toolbox.get_activity_toolbar()
activity_toolbar.share.props.visible = False
activity_toolbar.keep.props.visible = False
self.ok_button = ToolButton(icon)
self.ok_button.props.tooltip = "Aplicar"
self.ok_button.connect("clicked", self.apply)
self.ok_button.show()
activity_toolbar.insert(self.ok_button, 2)
self.set_toolbox(self.toolbox)
self.toolbox.show()
self.canvas = gtk.VBox()
name_box = gtk.HBox()
self.canvas.pack_start(name_box, True, True, 5)
name_label = gtk.Label("Nombre:")
self.name_entry = gtk.Entry()
self.name_entry.set_text(self.current_nick)
name_label.show()
self.name_entry.show()
name_box.pack_start(name_label, False, True, 0)
name_box.pack_start(self.name_entry, True, True, 0)
name_box.show()
self.colour_picker = gtk.HBox()
selectors = gtk.VBox()
self.out_colour_selector = gtk.ColorSelection()
self.out_colour_selector.set_current_color(
gtk.gdk.color_parse(self.current_colours[0]))
self.out_colour_selector.connect("color-changed",
self.colour_changed_callback, "out")
self.out_colour_selector.show()
selectors.pack_start(self.out_colour_selector, True, True, 0)
self.in_colour_selector = gtk.ColorSelection()
self.in_colour_selector.set_current_color(
gtk.gdk.color_parse(self.current_colours[1]))
self.in_colour_selector.connect("color-changed",
self.colour_changed_callback, "in")
self.in_colour_selector.show()
selectors.pack_start(self.in_colour_selector, True, True, 0)
selectors.show()
self.colour_picker.pack_start(selectors, True, True, 0)
self.xo_icon = gtk.EventBox()
self.icon = Icon(pixel_size=style.XLARGE_ICON_SIZE)
self.icon.props.xo_color = XoColor(self.current_colour)
self.icon.props.icon_name = 'computer-xo'
self.icon.props.pixel_size = style.XLARGE_ICON_SIZE
self.icon.show()
self.xo_icon.add(self.icon)
self.xo_icon.show()
self.colour_picker.pack_start(self.xo_icon)
self.canvas.pack_start(self.colour_picker, True, True, 5)
self.colour_picker.show()
self.canvas.show()
self.set_canvas(self.canvas)
self.show()
def write_file(self, file_path):
raise NotImplementedError
def read_file(self, file_path):
raise NotImplementedError
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 recordToolbar(gtk.Toolbar):
def __init__(self, miniTamTam):
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.miniTamTam = miniTamTam
self.micRec1Button = ToolButton('rec1')
self.micRec1Button.connect('clicked',self.miniTamTam.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.miniTamTam.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.miniTamTam.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.miniTamTam.micRec,'mic4')
self.insert(self.micRec4Button, -1)
self.micRec4Button.show()
self.micRec4Button.set_tooltip(('Record microphone into slot 4'))
_insertSeparator()
self.keyboardRecButton = ToggleToolButton('keyrec')
self.keyboardRecButton.connect('clicked', self.miniTamTam.sequencer.handleRecordButton )
self.insert(self.keyboardRecButton, -1)
self.keyboardRecButton.show()
self.keyboardRecButton.set_tooltip(_('Click to record a loop'))
self.keyboardRecOverButton = ToggleToolButton('overrec')
self.keyboardRecOverButton.connect('clicked', self.miniTamTam.sequencer.handleOverButton )
self.insert(self.keyboardRecOverButton, -1)
self.keyboardRecOverButton.show()
self.keyboardRecOverButton.set_tooltip(_('Click to add a loop'))
#self.keyboardRecOverButton.set_sensitive(False)
self.keyboardRecMinusButton = ToolButton('minusrec')
self.keyboardRecMinusButton.connect('clicked', self.miniTamTam.sequencer.clearSequencer )
self.insert(self.keyboardRecMinusButton, -1)
self.keyboardRecMinusButton.show()
self.keyboardRecMinusButton.set_tooltip(_('Click to clear all loops'))
_insertSeparator()
self._loopSettingsPalette = LoopSettingsPalette(_('Add new Sound'), self.miniTamTam)
self.loopSetButton = ToggleToolButton('loop')
self.loopSetButton.set_palette(self._loopSettingsPalette)
self.insert(self.loopSetButton, -1)
self.loopSetButton.show()
class ReadToolbar(gtk.Toolbar):
__gtype_name__ = 'ReadToolbar'
def __init__(self):
gtk.Toolbar.__init__(self)
self._back = ToolButton('go-previous')
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')
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()
num_page_item = gtk.ToolItem()
self._num_page_entry = gtk.Entry()
self._num_page_entry.set_text('0')
self._num_page_entry.set_alignment(1)
self._num_page_entry.connect('insert-text',
self._num_page_entry_insert_text_cb)
self._num_page_entry.connect('activate',
self._num_page_entry_activate_cb)
self._num_page_entry.set_width_chars(4)
num_page_item.add(self._num_page_entry)
self._num_page_entry.show()
self.insert(num_page_item, -1)
num_page_item.show()
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(' / 0')
total_page_item.add(self._total_page_label)
self._total_page_label.show()
self.insert(total_page_item, -1)
total_page_item.show()
downloaded_item = gtk.ToolItem()
self._downloaded_label = gtk.Label()
self._downloaded_label.set_attributes(label_attributes)
self._downloaded_label.set_text('')
downloaded_item.add(self._downloaded_label)
self._downloaded_label.show()
self.insert(downloaded_item, -1)
downloaded_item.show()
def set_downloaded_bytes(self, bytes, total):
self._downloaded_label.props.label = ' ' + str(bytes) + ' of ' + str(total) + ' received'
def _num_page_entry_insert_text_cb(self, entry, text, length, position):
if not re.match('[0-9]', text):
entry.emit_stop_by_name('insert-text')
return True
return False
def _num_page_entry_activate_cb(self, entry):
if entry.props.text:
page = int(entry.props.text) - 1
else:
page = 0
if page >= self.total_pages:
page = self.total_pages - 1
elif page < 0:
page = 0
self.current_page = page
self.activity.set_current_page(page)
self.activity.show_page(page)
entry.props.text = str(page + 1)
self._update_nav_buttons()
def _go_back_cb(self, button):
self.activity.page_previous()
def _go_forward_cb(self, button):
self.activity.page_next()
def _update_nav_buttons(self):
current_page = self.current_page
self._back.props.sensitive = current_page > 0
self._forward.props.sensitive = \
current_page < self.total_pages - 1
self._num_page_entry.props.text = str(current_page + 1)
self._total_page_label.props.label = \
' / ' + str(self.total_pages)
def set_total_pages(self, pages):
self.total_pages = pages
def set_current_page(self, page):
self.current_page = page
self._update_nav_buttons()
def set_activity(self, activity):
self.activity = activity
def build_toolbar(self):
toolbox = ToolbarBox()
activity_button = ActivityToolbarButton(self)
toolbox.toolbar.insert(activity_button, -1)
activity_button.show()
barra = toolbox.toolbar
separador1 = gtk.SeparatorToolItem()
separador1.props.draw = True
barra.insert(separador1, 1)
item1 = gtk.ToolItem()
self.label_radio1 = gtk.Label()
self.label_radio1.set_text(_('Circles between') + ' ')
item1.add(self.label_radio1)
barra.insert(item1, 2)
item2 = gtk.ToolItem()
self.cradio1 = gtk.SpinButton()
self.cradio1.set_range(1, 20)
self.cradio1.set_increments(1, 2)
self.cradio1.props.value = self.radio_uno
self.cradio1_handler = self.cradio1.connect('notify::value',
self.cradio1_valor)
item2.add(self.cradio1)
barra.insert(item2, 3)
item3 = gtk.ToolItem()
self.label_and = gtk.Label()
self.label_and.set_text(' ' + _('and') + ' ')
item3.add(self.label_and)
barra.insert(item3, 4)
item4 = gtk.ToolItem()
self.cradio2 = gtk.SpinButton()
self.cradio2.set_range(1, 20)
self.cradio2.set_increments(1, 2)
self.cradio2.props.value = self.radio_dos
self.cradio2_handler = self.cradio2.connect('notify::value',
self.cradio2_valor)
item4.add(self.cradio2)
barra.insert(item4, 5)
separator1 = gtk.SeparatorToolItem()
separator1.props.draw = True
separator1.set_expand(False)
barra.insert(separator1, 6)
save_button = ToolButton('filesave')
save_button.set_tooltip(_('Save Image'))
save_button.connect('clicked', self._savebutton_cb)
barra.insert(save_button, 7)
save_button.show()
separator2 = gtk.SeparatorToolItem()
separator2.props.draw = False
separator2.set_expand(True)
barra.insert(separator2, 8)
stop_button = StopButton(self)
stop_button.props.accelerator = '<Ctrl>q'
barra.insert(stop_button, 9)
stop_button.show()
self.set_toolbar_box(toolbox)
toolbox.show_all()
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 MeasureActivity(activity.Activity):
''' Oscilloscope Sugar activity '''
def __init__(self, handle):
''' Init canvas, toolbars, etc.
The toolbars are in sensor_toolbar.py and toolbar_side.py
The audio controls are in audiograb.py
The rendering happens in drawwaveform.py
Logging is in journal.py '''
activity.Activity.__init__(self, handle)
self.mode_images = {}
self.mode_images['sound'] = gtk.gdk.pixbuf_new_from_file_at_size(
os.path.join(ICONS_DIR, 'media-audio.svg'), 45, 45)
self.mode_images['resistance'] = gtk.gdk.pixbuf_new_from_file_at_size(
os.path.join(ICONS_DIR, 'resistance.svg'), 45, 45)
self.mode_images['voltage'] = gtk.gdk.pixbuf_new_from_file_at_size(
os.path.join(ICONS_DIR, 'voltage.svg'), 45, 45)
self.icon_colors = self.get_icon_colors_from_sugar()
self.stroke_color, self.fill_color = self.icon_colors.split(',')
self.nick = self.get_nick_from_sugar()
self.CONTEXT = ''
self.adjustmentf = None # Freq. slider control
self.new_recording = False
self.session_id = 0
self.read_metadata()
self._active = True
self._dsobject = None
self.connect('notify::active', self._notify_active_cb)
self.connect('destroy', self.on_quit)
self.data_logger = DataLogger(self)
self.hw = _get_hardware()
log.debug('running on %s hardware' % (self.hw))
self.wave = DrawWaveform(self)
if self.hw == XO15:
self.audiograb = AudioGrab_XO15(self.wave.new_buffer, self)
elif self.hw == XO175:
self.audiograb = AudioGrab_XO175(self.wave.new_buffer, self)
elif self.hw == XO4:
self.audiograb = AudioGrab_XO4(self.wave.new_buffer, self)
elif self.hw == XO1:
self.audiograb = AudioGrab_XO1(self.wave.new_buffer, self)
else:
self.audiograb = AudioGrab_Unknown(self.wave.new_buffer, self)
# no sharing
self.max_participants = 1
box3 = gtk.HBox(False, 0)
box3.pack_start(self.wave, True, True, 0)
# We need event boxes in order to set the background color.
side_eventboxes = []
self.side_toolbars = []
for i in range(self.audiograb.channels):
side_eventboxes.append(gtk.EventBox())
side_eventboxes[i].modify_bg(
gtk.STATE_NORMAL, style.COLOR_TOOLBAR_GREY.get_gdk_color())
self.side_toolbars.append(SideToolbar(self, channel=i))
side_eventboxes[i].add(self.side_toolbars[i].box1)
box3.pack_start(side_eventboxes[i], False, True, 0)
event_box = gtk.EventBox()
self.text_box = gtk.Label()
self.text_box.set_justify(gtk.JUSTIFY_LEFT)
alist = pango.AttrList()
alist.insert(pango.AttrForeground(65535, 65535, 65535, 0, -1))
self.text_box.set_attributes(alist)
event_box.add(self.text_box)
event_box.modify_bg(gtk.STATE_NORMAL,
style.COLOR_TOOLBAR_GREY.get_gdk_color())
box1 = gtk.VBox(False, 0)
box1.pack_start(box3, True, True, 0)
box1.pack_start(event_box, False, True, 0)
self.set_canvas(box1)
toolbox = ToolbarBox()
activity_button = ActivityToolbarButton(self)
toolbox.toolbar.insert(activity_button, 0)
activity_button.show()
self.sensor_toolbar = SensorToolbar(self, self.audiograb.channels)
#Added by Lego
# Turn on bobot Server
log.debug('Starting Server...')
self.bobot = subprocess.Popen(['python', 'pybot_server.py'],
cwd='./pybot')
log.debug("Start : %s" % time.ctime())
time.sleep(bobot_delay_start)
log.debug("Started : %s" % time.ctime())
self.lego_toolbar = LegoToolbar(self, self.audiograb.channels)
#Lego end
# Added by Butia
self.butia_toolbar = ButiaToolbar(self, self.audiograb.channels)
#Butia end
#Added by Arduino
self.arduino_toolbar = ArduinoToolbar(self, self.audiograb.channels)
#Arduino end
self.tuning_toolbar = TuningToolbar(self)
self.new_instrument_toolbar = InstrumentToolbar(self)
self._extras_toolbar = gtk.Toolbar()
self.control_toolbar = gtk.Toolbar()
sensor_button = ToolbarButton(label=_('Sensors'),
page=self.sensor_toolbar,
icon_name='sensor-tools')
toolbox.toolbar.insert(sensor_button, -1)
#Added by Lego
sensor_button.connect('clicked', self._sensor_toolbar_cb)
#Lego end
sensor_button.show()
lego_button = ToolbarButton(label=_('Lego'),
page=self.lego_toolbar,
icon_name='LEGO-tools')
toolbox.toolbar.insert(lego_button, -1)
lego_button.connect('clicked', self._lego_toolbar_cb)
lego_button.show()
#Lego end
#Added by Butia
sensor_button.connect('clicked', self._sensor_toolbar_cb)
#Butia end
sensor_button.show()
#Added by Butia
butia_button = ToolbarButton(label=_('Butia'),
page=self.butia_toolbar,
icon_name='butia-tools')
toolbox.toolbar.insert(butia_button, -1)
butia_button.connect('clicked', self._butia_toolbar_cb)
butia_button.show()
#Butia end
#Added by Arduino
sensor_button.connect('clicked', self._sensor_toolbar_cb)
#Arduino end
sensor_button.show()
#Added by Arduino
arduino_button = ToolbarButton(label=_('Arduino'),
page=self.arduino_toolbar,
icon_name='arduino-tools')
toolbox.toolbar.insert(arduino_button, -1)
arduino_button.connect('clicked', self._arduino_toolbar_cb)
arduino_button.show()
#Arduino end
tuning_button = ToolbarButton(
# TRANS: Tuning insruments
label=_('Tuning'),
page=self.tuning_toolbar,
icon_name='tuning-tools')
toolbox.toolbar.insert(tuning_button, -1)
tuning_button.show()
new_instrument_button = ToolbarButton(label=_('Add instrument'),
page=self.new_instrument_toolbar,
icon_name='view-source')
toolbox.toolbar.insert(new_instrument_button, -1)
new_instrument_button.show()
#Added by butia
self.butia_toolbar.show()
#Butia end
self._extras_button = ToolbarButton(page=self._extras_toolbar,
icon_name='domain-time')
toolbox.toolbar.insert(self._extras_button, -1)
self._extras_toolbar_item = gtk.ToolItem()
self._extras_toolbar.insert(self._extras_toolbar_item, -1)
self._extras_button.hide()
self.sensor_toolbar.show()
self._extra_tools = gtk.HBox()
# Set up Frequency-domain Button
self.freq = ToolButton('domain-time')
self.freq.set_tooltip(_('Time Base'))
self.freq.connect('clicked', self.timefreq_control)
self.freq.show()
self._extra_tools.add(self.freq)
self.sensor_toolbar.add_frequency_slider(self._extra_tools)
self._extra_item = gtk.ToolItem()
self._extra_item.add(self._extra_tools)
self._extra_tools.show()
toolbox.toolbar.insert(self._extra_item, -1)
self._extra_item.show()
self._pause = ToolButton('media-playback-pause')
self._pause.set_tooltip(_('Freeze the display'))
self._pause.connect('clicked', self._pause_play_cb)
self._pause.show()
toolbox.toolbar.insert(self._pause, -1)
self._capture = ToolButton('image-saveoff')
self._capture.set_tooltip(_('Capture sample now'))
self._capture.connect('clicked', self._capture_cb)
self._capture.show()
toolbox.toolbar.insert(self._capture, -1)
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()
self.set_toolbox(toolbox)
sensor_button.set_expanded(True)
toolbox.show()
self.sensor_toolbar.update_page_size()
self.show_all()
self._first = True
# Always start in 'sound' mode.
self.sensor_toolbar.set_mode('sound')
self.sensor_toolbar.set_sound_context()
self.sensor_toolbar.set_show_hide_windows()
self.wave.set_active(True)
self.wave.set_context_on()
gtk.gdk.screen_get_default().connect('size-changed',
self._configure_cb)
self._configure_cb(None)
def _configure_cb(self, event):
''' Screen size has changed, so check to see if the toolbar
elements still fit.'''
self.width = gtk.gdk.screen_width()
if self.width < style.GRID_CELL_SIZE * 14:
self._extras_button.show()
if self._extra_tools in self._extra_item:
self._extra_item.remove(self._extra_tools)
if not self._extra_tools in self._extras_toolbar_item:
self._extras_toolbar_item.add(self._extra_tools)
self._extras_toolbar_item.show()
self.sensor_toolbar.log_label.hide()
self.sensor_toolbar.trigger_label.hide()
else:
self._extras_button.hide()
if self._extra_tools in self._extras_toolbar_item:
self._extras_toolbar_item.remove(self._extra_tools)
if not self._extra_tools in self._extra_item:
self._extra_item.add(self._extra_tools)
if self._extras_button.is_expanded():
self._extras_button.set_expanded(False)
self._extras_toolbar_item.hide()
self.sensor_toolbar.log_label.show()
self.sensor_toolbar.trigger_label.show()
self._extra_tools.show()
#Added by Lego
def _sensor_toolbar_cb(self, button=None):
'''Callback al hacer clic en sensor toolbar'''
log.debug('Click en sensor toolbar')
self.sensor_toolbar.set_mode('sound')
self.sensor_toolbar.set_sound_context()
self.sensor_toolbar.set_show_hide_windows()
self.limpiar_canales()
self.CONTEXT = 'sound'
#Added by Lego
def _lego_toolbar_cb(self, button=None):
'''Callback al hacer clic en lego toolbar'''
log.debug('Click en lego toolbar')
self.audiograb.stop_grabbing()
self.limpiar_canales()
log.debug('CONTEXTO ANTERIOR: %s' % self.CONTEXT)
self.CONTEXT = 'lego'
self.sensor_toolbar.update_string_for_textbox()
#Added by Butia
def _butia_toolbar_cb(self, button=None):
'''Callback al hacer clic en butia toolbar'''
log.debug('Click en butia toolbar')
self.audiograb.stop_grabbing()
self.limpiar_canales()
log.debug('CONTEXTO ANTERIOR: %s' % self.CONTEXT)
self.CONTEXT = 'butia'
self.sensor_toolbar.update_string_for_textbox()
#Added by Arduino
def _arduino_toolbar_cb(self, button=None):
'''Callback al hacer clic en arduino toolbar'''
log.debug('Click en arduino toolbar')
self.audiograb.stop_grabbing()
self.limpiar_canales()
log.debug('CONTEXTO ANTERIOR: %s' % self.CONTEXT)
log.debug('***** ARDUINO CONTEXT ******')
self.CONTEXT = 'arduino'
self.sensor_toolbar.update_string_for_textbox()
#Added by lego
def limpiar_canales(self):
for i in range(self.audiograb.channels):
self.wave.ringbuffer[i] = RingBuffer1d(self.wave.max_samples,
dtype='int16')
self.wave.new_buffer([0], i)
def on_quit(self, data=None):
'''Clean up, close journal on quit'''
self.audiograb.on_activity_quit()
def _notify_active_cb(self, widget, pspec):
''' Callback to handle starting/pausing capture when active/idle '''
if self._first:
log.debug('_notify_active_cb: start grabbing')
self.audiograb.start_grabbing()
self._first = False
elif not self.props.active:
log.debug('_notify_active_cb: pause grabbing')
self.audiograb.pause_grabbing()
elif self.props.active:
log.debug('_notify_active_cb: resume grabbing')
self.audiograb.resume_grabbing()
self._active = self.props.active
self.wave.set_active(self._active)
def read_metadata(self):
''' Any saved instruments? '''
for data in self.metadata.keys():
if data[0] == PREFIX: # instrument
log.debug('found an instrument: %s' % (data[1:]))
instrument = data[1:]
log.debug(self.metadata[data])
INSTRUMENT_DICT[instrument] = []
for note in self.metadata[data].split(' '):
INSTRUMENT_DICT[instrument].append(float(note))
def write_file(self, file_path):
''' Write data to journal, if there is any data to write '''
# Check to see if there are any new instruments to save
if hasattr(self, 'new_instrument_toolbar'):
for i, instrument in enumerate(
self.new_instrument_toolbar.new_instruments):
log.debug('saving %s' % (instrument))
notes = ''
for i, note in enumerate(INSTRUMENT_DICT[instrument]):
notes += '%0.3f' % note
if i < len(INSTRUMENT_DICT[instrument]) - 1:
notes += ' '
self.metadata['%s%s' % (PREFIX, instrument)] = notes
# FIXME: Don't use ""s around data
if hasattr(self, 'data_logger') and \
self.new_recording and \
len(self.data_logger.data_buffer) > 0:
# Append new data to Journal entry
fd = open(file_path, 'ab')
writer = csv.writer(fd)
# Also output to a separate file as a workaround to Ticket 2127
# (the assumption being that this file will be opened by the user)
tmp_data_file = os.path.join(os.environ['SUGAR_ACTIVITY_ROOT'],
'instance', 'sensor_data' + '.csv')
log.debug('saving sensor data to %s' % (tmp_data_file))
if self._dsobject is None: # first time, so create
fd2 = open(tmp_data_file, 'wb')
else: # we've been here before, so append
fd2 = open(tmp_data_file, 'ab')
writer2 = csv.writer(fd2)
# Pop data off start of buffer until it is empty
for i in range(len(self.data_logger.data_buffer)):
datum = self.data_logger.data_buffer.pop(0)
writer.writerow([datum])
writer2.writerow([datum])
fd.close()
fd2.close()
# Set the proper mimetype
self.metadata['mime_type'] = 'text/csv'
if os.path.exists(tmp_data_file):
if self._dsobject is None:
self._dsobject = datastore.create()
self._dsobject.metadata['title'] = _('Measure Log')
self._dsobject.metadata['icon-color'] = self.icon_colors
self._dsobject.metadata['mime_type'] = 'text/csv'
self._dsobject.set_file_path(tmp_data_file)
datastore.write(self._dsobject)
# remove(tmp_data_file)
def read_file(self, file_path):
''' Read csv data from journal on start '''
reader = csv.reader(open(file_path, "rb"))
# Count the number of sessions.
for row in reader:
if len(row) > 0:
if row[0].find(_('Session')) != -1:
# log.debug('found a previously recorded session')
self.session_id += 1
elif row[0].find('abiword') != -1:
# File has been opened by Write cannot be read by Measure
# See Ticket 2127
log.error('File was opened by Write: Measure cannot read')
self.data_logger.data_buffer = []
return
self.data_logger.data_buffer.append(row[0])
if self.session_id == 0:
# log.debug('setting data_logger buffer to []')
self.data_logger.data_buffer = []
def _pause_play_cb(self, button=None):
''' Callback for Pause Button '''
if self.audiograb.get_freeze_the_display():
self.audiograb.set_freeze_the_display(False)
self._pause.set_icon('media-playback-start')
self._pause.set_tooltip(_('Unfreeze the display'))
self._pause.show()
else:
self.audiograb.set_freeze_the_display(True)
self._pause.set_icon('media-playback-pause')
self._pause.set_tooltip(_('Freeze the display'))
self._pause.show()
return False
def _capture_cb(self, button=None):
''' Callback for screen capture '''
if self.CONTEXT == 'butia':
self.butia_toolbar.take_screenshot()
self.audiograb.take_screenshot()
def timefreq_control(self, button=None):
''' Callback for Freq. Button '''
# Turn off logging when switching modes
if self.audiograb.we_are_logging:
self.sensor_toolbar.record_control_cb()
#Added by Lego
self.lego_toolbar.set_sound_context()
#Lego end
#Added by Butia
self.butia_toolbar.set_sound_context()
#Butia end
#Added by Arduino
self.arduino_toolbar.set_sound_context()
#Arduino end
if self.wave.get_fft_mode():
self.wave.set_fft_mode(False)
self.freq.set_icon('domain-time')
self.freq.set_tooltip(_('Time Base'))
else:
self.wave.set_fft_mode(True)
self.freq.set_icon('domain-freq')
self.freq.set_tooltip(_('Frequency Base'))
# Turn off triggering in Frequencey Base
self.sensor_toolbar.trigger_none.set_active(True)
self.wave.set_trigger(self.wave.TRIGGER_NONE)
# Turn off invert in Frequencey Base
for i in range(self.audiograb.channels):
if self.wave.get_invert_state(channel=i):
self.side_toolbars[i].invert_control_cb()
self.sensor_toolbar.update_string_for_textbox()
return False
def get_icon_colors_from_sugar(self):
''' Returns the icon colors from the Sugar profile '''
return profile.get_color().to_string()
def get_nick_from_sugar(self):
''' Returns nick from Sugar '''
return profile.get_nick_name()
class VncLauncherActivity(activity.Activity):
def __init__(self, handle):
activity.Activity.__init__(self, handle)
self.max_participants = 1
self.toolbarbox = ToolbarBox()
self.toolbar = self.toolbarbox.toolbar
self.start_vnc = RadioToolButton(icon_name="start_vnc",
tooltip=_("Start VNC Server"))
self.stop_vnc = RadioToolButton(icon_name="stop_vnc",
tooltip=_("Stop VNC Server"),
group=self.start_vnc)
self.stop_vnc.set_active(True)
self.get_ipbutton = ToolButton(icon_name="get_ip",
tooltip=_("Get the current IP"))
##
self.messages = gtk.TreeView()
self.messages.set_rules_hint(True)
modelo = gtk.ListStore(str, str, gtk.gdk.Color)
self.messages.set_model(modelo)
render = gtk.CellRendererText()
render1 = gtk.CellRendererText()
column1 = gtk.TreeViewColumn(_("Hour"), render, markup=0)
column2 = gtk.TreeViewColumn(_("Message"), render1, markup=1)
column1.add_attribute(render, 'foreground-gdk', 2)
column2.add_attribute(render1, 'foreground-gdk', 2)
self.messages.append_column(column1)
self.messages.append_column(column2)
color = gtk.gdk.color_parse("dark blue")
modelo.insert(0, [
time.strftime("\n<b>%H:%M:%S</b>\n"),
_("\n<b>Start of activity.</b>\n"), color
])
self.showed_message_stop = True
self.showed_message_start = False
self.isrunning = True
self.stop_vnc.connect("clicked", self.__stop_vnc)
self.start_vnc.connect("clicked", self.__start_vnc)
self.clear_model = ToolButton(icon_name="clear_console",
tooltip=_("Delete messages"))
self.clear_model.connect("clicked", lambda x: modelo.clear())
self.get_ipbutton.connect("clicked", self.__get_ip)
self.last_message = 1
self.__get_x11vnc_path()
##
separator = gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
self.stop_activity = StopButton(self)
self.toolbar.insert(ActivityToolbarButton(self), -1)
self.toolbar.insert(gtk.SeparatorToolItem(), -1)
self.toolbar.insert(self.start_vnc, -1)
self.toolbar.insert(self.stop_vnc, -1)
self.toolbar.insert(gtk.SeparatorToolItem(), -1)
self.toolbar.insert(self.get_ipbutton, -1)
self.toolbar.insert(self.clear_model, -1)
self.toolbar.insert(separator, -1)
self.toolbar.insert(self.stop_activity, -1)
self.messages_scroll = gtk.ScrolledWindow()
self.messages_scroll.set_policy(gtk.POLICY_AUTOMATIC,
gtk.POLICY_AUTOMATIC)
self.messages_scroll.add_with_viewport(self.messages)
self.set_toolbar_box(self.toolbarbox)
self.set_canvas(self.messages_scroll)
self.show_all()
gobject.timeout_add(100, self.__check_is_on)
def __check_is_on(self):
pid = commands.getoutput("pidof x11vnc")
if self.start_vnc.get_active() and pid == "" and self.isrunning:
self.showed_message_stop = True
self.stop_vnc.set_active(True)
self.start_vnc.set_active(False)
self.showed_message_start = False
color = gtk.gdk.color_parse("dark red")
self.messages.get_model().insert(self.last_message, [
time.strftime("\n<b>%H:%M:%S</b>\n"),
("\n<b>It has stopped unexpectedly the server..</b>\n"), color
])
self.last_message += 1
return True
def __get_x11vnc_path(self):
system = platform.machine()
color = gtk.gdk.color_parse("dark red")
if os.path.exists("/usr/bin/x11vnc"):
self.path = "/usr/bin/x11vnc"
message = _("PATH: %s") % self.path
else:
if "arm" in system:
self.path = os.path.join(activity.get_bundle_path(), "bin",
"arm", "x11vnc")
elif "64" in system:
self.path = os.path.join(activity.get_bundle_path(), "bin",
"x64", "x11vnc")
else:
self.path = os.path.join(activity.get_bundle_path(), "bin",
"i586", "x11vnc")
os.environ["LD_LIBRARY_PATH"] = self.path.replace("x11vnc", "lib/")
message = _("PATH: %s") % self.path
self.messages.get_model().insert(self.last_message, [
time.strftime("\n<b>%H:%M:%S</b>\n"), "<b>" + message + "</b>",
color
])
self.last_message += 1
def __start_vnc(self, widget):
def servidor():
commands.getoutput(self.path)
Thread(target=servidor).start()
if not self.showed_message_start:
self.showed_message_start = True
pass
else:
return
self.showed_message_stop = False
self.isrunning = True
color = gtk.gdk.color_parse("green")
self.messages.get_model().insert(self.last_message, [
time.strftime("\n<b>%H:%M:%S</b>\n"),
("\n<b>VNC server is started</b>\n"), color
])
self.last_message += 1
def __stop_vnc(self, widget):
if not self.showed_message_stop:
self.showed_message_stop = True
pass
else:
return
self.showed_message_start = False
self.pid_nuevo = commands.getoutput("pidof x11vnc")
color = gtk.gdk.color_parse('red')
os.system("kill " + self.pid_nuevo)
self.messages.get_model().insert(self.last_message, [
time.strftime("\n<b>%H:%M:%S</b>\n"),
("\n<b>The VNC server is now stopped.</b>\n"), color
])
self.last_message += 1
def close(self):
self.isrunning = False
pid = commands.getoutput("pidof x11vnc")
os.system("kill " + pid)
self.destroy()
def __get_ip(self, widget):
system = platform.platform()
if "olpc" in system:
target = "eth0"
else:
target = "wlan0"
ifconfig = "/sbin/ifconfig"
cmd = "%s %s" % (ifconfig, target)
output = commands.getoutput(cmd)
error = _("No wireless connection.")
ip = error
inet = output.find('inet')
if inet >= 0:
start = inet + len('inet')
end = output.find(" ", start + 1)
ip = output[start:end]
else:
ip = error
if ip == _("No wireless connection."):
mensaje = error
else:
ip = ip.replace(":", "")
ip = ip.replace("addr", "")
ip = ip.replace(" ", "")
mensaje = "IP: " + ip
color = gtk.gdk.color_parse("dark blue")
self.messages.get_model().insert(self.last_message, [
time.strftime("\n<b>%H:%M:%S</b>\n"), "\n<b>" + mensaje + "</b>\n",
color
])
self.last_message += 1
def build_colors_toolbar(self, toolbox):
barra_colors = gtk.Toolbar()
item1 = gtk.ToolItem()
label1 = gtk.Label()
label1.set_text(_('Color mode') + ' ')
item1.add(label1)
barra_colors.insert(item1, -1)
item2 = gtk.ToolItem()
modes = ('RGB', 'YUV', 'HSV')
combo = Combo(modes)
item2.add(combo)
combo.connect('changed', self.change_combo)
barra_colors.insert(item2, -1)
separator1 = gtk.SeparatorToolItem()
separator1.props.draw = True
barra_colors.insert(separator1, -1)
item_l = gtk.ToolItem()
label4 = gtk.Label()
label4.set_text(_('Brightness') + ' ')
item_l.add(label4)
barra_colors.insert(item_l, -1)
item = gtk.ToolItem()
brightness_spin = gtk.SpinButton()
brightness_spin.set_range(-1, 255)
brightness_spin.set_increments(1, 10)
brightness_spin.props.value = int(self.brightness)
brightness_spin.connect('notify::value', self.brightness_spin_change)
item.add(brightness_spin)
barra_colors.insert(item, -1)
separator2 = gtk.SeparatorToolItem()
separator2.props.draw = True
barra_colors.insert(separator2, -1)
item3 = gtk.ToolItem()
label3 = gtk.Label()
label3.set_text(_('Threshold view'))
item3.add(label3)
barra_colors.insert(item3, -1)
threshold_view = ToolButton('media-playback-stop')
threshold_view.connect('clicked', self.threshold_view)
threshold_view.set_tooltip(_('Yes'))
barra_colors.insert(threshold_view, -1)
separator3 = gtk.SeparatorToolItem()
separator3.props.draw = True
barra_colors.insert(separator3, -1)
item4 = gtk.ToolItem()
label4 = gtk.Label()
label4.set_text(_('Outline'))
item4.add(label4)
barra_colors.insert(item4, -1)
outline_view = ToolButton('media-playback-stop')
outline_view.connect('clicked', self.outline_view)
outline_view.set_tooltip(_('Yes'))
barra_colors.insert(outline_view, -1)
separator4 = gtk.SeparatorToolItem()
separator4.props.draw = True
barra_colors.insert(separator4, -1)
item5 = gtk.ToolItem()
label5 = gtk.Label()
label5.set_text(_('Rects'))
item5.add(label5)
barra_colors.insert(item5, -1)
rects_view = ToolButton('media-playback-stop')
rects_view.connect('clicked', self.rects_view)
rects_view.set_tooltip(_('Yes'))
barra_colors.insert(rects_view, -1)
barra_colors.show_all()
colors_button = ToolbarButton(label=_('Colors'),
page=barra_colors,
icon_name='toolbar-colors')
toolbox.toolbar.insert(colors_button, -1)
colors_button.show()
def build_toolbar(self):
toolbar_box = ToolbarBox()
self.set_toolbar_box(toolbar_box)
toolbar_box.show()
activity_button = ActivityToolbarButton(self)
toolbar_box.toolbar.insert(activity_button, -1)
activity_button.show()
separator = gtk.SeparatorToolItem()
toolbar_box.toolbar.insert(separator, -1)
separator.show()
self.build_colors_toolbar(toolbar_box)
separator = gtk.SeparatorToolItem()
toolbar_box.toolbar.insert(separator, -1)
separator.show()
# new game button
new_game = ToolButton('new-game')
new_game.connect('clicked', self._new_game)
new_game.set_tooltip(_('New game'))
toolbar_box.toolbar.insert(new_game, -1)
separator = gtk.SeparatorToolItem()
toolbar_box.toolbar.insert(separator, -1)
separator.show()
#current
item = gtk.ToolItem()
label = gtk.Label()
label.set_text(' %s ' % _('Current player:'))
item.add(label)
toolbar_box.toolbar.insert(item, -1)
#player
item = gtk.ToolItem()
self.current_label = gtk.Label()
self.current_label.set_text(' %s' % 1)
item.add(self.current_label)
toolbar_box.toolbar.insert(item, -1)
separator = gtk.SeparatorToolItem()
toolbar_box.toolbar.insert(separator, -1)
separator.show()
sound_button = ToolButton('speaker-muted-100')
sound_button.set_tooltip(_('Sound'))
sound_button.connect('clicked', self.sound_control)
toolbar_box.toolbar.insert(sound_button, -1)
# separator and stop
separator = gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
toolbar_box.toolbar.insert(separator, -1)
separator.show()
stop_button = StopButton(self)
toolbar_box.toolbar.insert(stop_button, -1)
stop_button.show()
self.show_all()
class SideToolbar(gtk.Toolbar):
''' A toolbar on the side of the canvas for adjusting gain/bias '''
def __init__(self, activity, channel=0):
''' Set up initial toolbars '''
gtk.Toolbar.__init__(self)
self.activity = activity
self._channel = channel
if self._channel == 0:
self.show_toolbar = True
else: # Don't show second channel until we need it
self.show_toolbar = False
self.mode = 'sound'
self.mode_values = {'sound': 3, 'sensor': 2}
self._toggle = gtk.CheckButton()
self._toggle.set_active(True)
self._toggle.connect('clicked', self.toggle_cb)
self._toggle.show()
self._toggle_box = gtk.HBox()
self._toggle_box.pack_start(self._toggle, False, True, 18)
self._invert = ToolButton('invert')
self._invert.set_tooltip(_('Invert'))
self._invert.connect('clicked', self.invert_control_cb)
self._invert.show()
self.activity.wave.set_invert_state(False, channel=self._channel)
self.button_up = ToolButton('amp-high')
self.button_up.set_tooltip(_('Increase amplitude'))
self.button_up.connect('clicked', self._button_up_cb)
self.button_up.show()
self.adjustmenty = gtk.Adjustment(self.mode_values[self.mode], LOWER,
UPPER, 0.1, 0.1, 0.0)
self.adjustmenty.connect('value_changed', self._yscrollbar_cb,
self.adjustmenty)
self.yscrollbar = gtk.VScale(self.adjustmenty)
self.yscrollbar.set_draw_value(False)
self.yscrollbar.set_inverted(True)
self.yscrollbar.set_update_policy(gtk.UPDATE_CONTINUOUS)
self.button_down = ToolButton('amp-low')
self.button_down.set_tooltip(_('Decrease amplitude'))
self.button_down.connect('clicked', self._button_down_cb)
self.button_down.show()
self.box1 = gtk.VBox(False, 0)
if self._channel == 0:
self.box1.pack_start(self._color_wave(self.activity.stroke_color),
False, True, 0)
elif self._channel == 1:
self.box1.pack_start(self._color_wave(self.activity.fill_color),
False, True, 0)
else:
self.box1.pack_start(self._color_wave('#FFFFFF'), False, True, 0)
self.box1.pack_start(self._toggle_box, False, True, 0)
self.box1.pack_start(self._invert, False, True, 0)
self.box1.pack_start(self.button_up, False, True, 0)
self.box1.pack_start(self.yscrollbar, True, True, 0)
self.box1.pack_start(self.button_down, False, True, 0)
self.set_show_hide(False)
def _yscrollbar_cb(self, adjy, data=None):
''' Callback for scrollbar '''
if self.mode == 'sound':
self.activity.wave.set_mag_params(1.0,
adjy.value,
channel=self._channel)
self.activity.wave.set_bias_param(0, channel=self._channel)
elif self.mode == 'sensor':
self.activity.wave.set_bias_param(int(
300 * (adjy.value - (UPPER - LOWER) / 2.)),
channel=self._channel)
self.mode_values[self.mode] = adjy.value
return True
def _button_up_cb(self, data=None):
'''Moves slider up'''
new_value = self.yscrollbar.get_value() + (UPPER - LOWER) \
/ 100.
if new_value <= UPPER:
self.yscrollbar.set_value(new_value)
else:
self.yscrollbar.set_value(UPPER)
return True
def _button_down_cb(self, data=None):
'''Moves slider down'''
new_value = self.yscrollbar.get_value() - (UPPER - LOWER) \
/ 100.
if new_value >= LOWER:
self.yscrollbar.set_value(new_value)
else:
self.yscrollbar.set_value(LOWER)
return True
def set_show_hide(self, show=True, mode='sound'):
''' Show or hide the toolbar '''
self.show_toolbar = show
self.set_side_mode(mode)
def set_side_mode(self, mode='sound'):
''' Set the toolbar to either 'sound' or 'sensor' '''
self.mode = mode
if self.mode == 'sound':
self.button_up.set_icon('amp-high')
self.button_up.set_tooltip(_('Increase amplitude'))
self.button_down.set_icon('amp-low')
self.button_down.set_tooltip(_('Decrease amplitude'))
elif self.mode == 'sensor':
self.button_up.set_icon('bias-high')
self.button_up.set_tooltip(_('Increase bias'))
self.button_down.set_icon('bias-low')
self.button_down.set_tooltip(_('Decrease bias'))
self._invert.show()
self.yscrollbar.set_value(self.mode_values[self.mode])
return
def toggle_cb(self, data=None):
self.activity.wave.set_visibility(self._toggle.get_active(),
channel=self._channel)
return True
def invert_control_cb(self, data=None):
''' Callback for Invert Button '''
if self.activity.wave.get_invert_state(channel=self._channel):
self.activity.wave.set_invert_state(False, self._channel)
self._invert.set_icon('invert')
self._invert.show()
elif not self.activity.wave.get_fft_mode():
self.activity.wave.set_invert_state(True, self._channel)
self._invert.set_icon('invert2')
self._invert.show()
self.activity.sensor_toolbar.update_string_for_textbox()
return False
def _color_wave(self, color):
''' Generate a wave graphic in color to label each side toolbar '''
svg = '<?xml version="1.0" ?>\n\
<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN"\n\
"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">\n\
<svg enable-background="new 0 0 55.125 55" height="55px" version="1.1"\n\
viewBox="0 0 55.125 55" width="55.125px" x="0px" xml:space="preserve"\n\
xmlns="http://www.w3.org/2000/svg"\n\
xmlns:xlink="http://www.w3.org/1999/xlink" y="0px">\n\
<path d="M9.066,27.5 c2.32-6.917,4.666-13.834,9.255-13.834\n\
c9.179,0,9.179,27.668,18.358,27.668c4.59,0,6.986-6.917,9.332-13.834"\n\
fill="none" stroke="%s" stroke-linecap="round" stroke-width="3.5"/>\n\
</svg>' % (color)
pixbuf = svg_str_to_pixbuf(svg)
img = gtk.Image()
img.set_from_pixbuf(pixbuf)
img_tool = gtk.ToolItem()
img_tool.add(img)
return img_tool
def __init__(self, montage):
gtk.Toolbar.__init__(self)
self.montage = montage
# edit buttons
setframe = ToolButton('dialog-ok')
setframe.connect('clicked', self._setframe_cb)
setframe.set_tooltip(_('Set frame'))
self.insert(setframe, -1)
clearframe = ToolButton('gtk-delete')
clearframe.connect('clicked', self._clearframe_cb)
clearframe.set_tooltip(_('Clear frame'))
self.insert(clearframe, -1)
resetframe = ToolButton('gtk-cancel')
resetframe.connect('clicked', self._resetframe_cb)
resetframe.set_tooltip(_('Reset'))
self.insert(resetframe, -1)
separator = gtk.SeparatorToolItem()
self.insert(separator, -1)
# play/pause buttons
play_img_1 = gtk.Image()
play_img_1.set_from_icon_name('media-playback-start-back',
gtk.ICON_SIZE_LARGE_TOOLBAR)
pause_img_1 = gtk.Image()
pause_img_1.set_from_icon_name('media-playback-pause',
gtk.ICON_SIZE_LARGE_TOOLBAR)
play_img_2 = gtk.Image()
play_img_2.set_from_icon_name('media-playback-start',
gtk.ICON_SIZE_LARGE_TOOLBAR)
pause_img_2 = gtk.Image()
pause_img_2.set_from_icon_name('media-playback-pause',
gtk.ICON_SIZE_LARGE_TOOLBAR)
paly_1 = ToggleToolButton('media-playback-start-back')
play_2 = ToggleToolButton('media-playback-start')
paly_1.connect('toggled', self._play_cb, (paly_1, play_2),
(play_img_1, pause_img_1), self.montage.playbackwards)
self.insert(paly_1, -1)
paly_1.set_tooltip(_('Play backward / Pause'))
play_2.connect('toggled', self._play_cb, (play_2, paly_1),
(play_img_2, pause_img_2), self.montage.playforwards)
self.insert(play_2, -1)
play_2.set_tooltip(_('Play forward / Pause'))
# tempo button
tempo = TempoSlider(0, 99)
tempo.adjustment.connect("value-changed", self._tempo_cb)
tempo.set_size_request(250, -1)
tempo.set_value(50)
tempo_item = gtk.ToolItem()
tempo_item.add(tempo)
self.insert(tempo_item, -1)
separator = gtk.SeparatorToolItem()
self.insert(separator, -1)
# export buttons
exportframe = ToolButton('image')
exportframe.connect('clicked', self._exportframe_cb)
exportframe.set_tooltip(_('Snapshot'))
self.insert(exportframe, -1)
self.show_all()
class PeterActivity(activity.Activity):
LOWER = 0
UPPER = 400
def __init__(self, handle):
super(PeterActivity, self).__init__(handle)
# Get user's Sugar colors
sugarcolors = profile.get_color().to_string().split(',')
colors = [[
int(sugarcolors[0][1:3], 16),
int(sugarcolors[0][3:5], 16),
int(sugarcolors[0][5:7], 16)
],
[
int(sugarcolors[1][1:3], 16),
int(sugarcolors[1][3:5], 16),
int(sugarcolors[1][5:7], 16)
]]
# No sharing
self.max_participants = 1
self.datapath = os.path.join(activity.get_activity_root(), 'instance')
# Build the activity toolbar.
toolbox = ToolbarBox()
activity_button = ActivityToolbarButton(self)
toolbox.toolbar.insert(activity_button, 0)
activity_button.show()
self._add_speed_slider(toolbox.toolbar)
cyan = ToolButton('cyan')
toolbox.toolbar.insert(cyan, -1)
cyan.set_tooltip(_('Next pattern'))
cyan.connect('clicked', self._button_cb, 'cyan')
cyan.set_sensitive(False)
cyan.show()
green = ToolButton('green')
toolbox.toolbar.insert(green, -1)
green.set_tooltip(_('Draw'))
green.connect('clicked', self._button_cb, 'green')
green.show()
red = ToolButton('red')
toolbox.toolbar.insert(red, -1)
red.set_tooltip(_('Stop'))
red.connect('clicked', self._button_cb, 'red')
red.show()
separator = gtk.SeparatorToolItem()
separator.props.draw = True
toolbox.toolbar.insert(separator, -1)
separator.show()
label = gtk.Label('')
label.set_use_markup(True)
label.show()
labelitem = gtk.ToolItem()
labelitem.add(label)
toolbox.toolbar.insert(labelitem, -1)
labelitem.show()
export = ToolButton('export-turtleblocks')
toolbox.toolbar.insert(export, -1)
export.set_tooltip(_('Export to TurtleBlocks'))
export.connect('clicked', self._export_turtleblocks_cb)
export.show()
separator = gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
toolbox.toolbar.insert(separator, -1)
separator.show()
stop_button = StopButton(self)
stop_button.props.accelerator = _('<Ctrl>Q')
toolbox.toolbar.insert(stop_button, -1)
stop_button.show()
toolbox.show()
self.set_toolbox(toolbox)
# Create the game instance.
self.game = Spirolaterals.Spirolaterals(colors)
# Build the Pygame canvas.
self._pygamecanvas = \
sugargame.canvas.PygameCanvas(self)
# Note that set_canvas implicitly calls
# read_file when resuming from the Journal.
self.set_canvas(self._pygamecanvas)
self.game.canvas = self._pygamecanvas
gtk.gdk.screen_get_default().connect('size-changed',
self.__configure_cb)
# Start the game running.
self.game.set_cyan_button(cyan)
self.game.set_label(label)
self._speed_range.set_value(200)
self._pygamecanvas.run_pygame(self.game.run)
def __configure_cb(self, event):
''' Screen size has changed '''
logging.debug(self._pygamecanvas.get_allocation())
pygame.display.set_mode(
(gtk.gdk.screen_width(), gtk.gdk.screen_height() - GRID_CELL_SIZE),
pygame.RESIZABLE)
self.game.save_pattern()
self.game.g_init()
self._speed_range.set_value(200)
self.game.run(restore=True)
def read_file(self, file_path):
try:
f = open(file_path, 'r')
except Exception as e:
logging.debug('Error opening %s: %s' % (file_path, e))
return
load_save.load(f)
f.close()
def write_file(self, file_path):
f = open(file_path, 'w')
load_save.save(f)
f.close()
def _button_cb(self, button=None, color=None):
self.game.do_button(color)
def _add_speed_slider(self, toolbar):
self._speed_stepper_down = ToolButton('speed-down')
self._speed_stepper_down.set_tooltip(_('Slow down'))
self._speed_stepper_down.connect('clicked',
self._speed_stepper_down_cb)
self._speed_stepper_down.show()
self._adjustment = gtk.Adjustment(200, self.LOWER, self.UPPER, 25, 100,
0)
self._adjustment.connect('value_changed', self._speed_change_cb)
self._speed_range = gtk.HScale(self._adjustment)
self._speed_range.set_inverted(True)
self._speed_range.set_draw_value(False)
self._speed_range.set_update_policy(gtk.UPDATE_CONTINUOUS)
self._speed_range.set_size_request(120, 15)
self._speed_range.show()
self._speed_stepper_up = ToolButton('speed-up')
self._speed_stepper_up.set_tooltip(_('Speed up'))
self._speed_stepper_up.connect('clicked', self._speed_stepper_up_cb)
self._speed_stepper_up.show()
self._speed_range_tool = gtk.ToolItem()
self._speed_range_tool.add(self._speed_range)
self._speed_range_tool.show()
toolbar.insert(self._speed_stepper_down, -1)
toolbar.insert(self._speed_range_tool, -1)
toolbar.insert(self._speed_stepper_up, -1)
return
def _speed_stepper_down_cb(self, button=None):
new_value = self._speed_range.get_value() + 25
if new_value <= self.UPPER:
self._speed_range.set_value(new_value)
else:
self._speed_range.set_value(self.UPPER)
def _speed_stepper_up_cb(self, button=None):
new_value = self._speed_range.get_value() - 25
if new_value >= self.LOWER:
self._speed_range.set_value(new_value)
else:
self._speed_range.set_value(self.LOWER)
def _speed_change_cb(self, button=None):
logging.debug(self._adjustment.value)
self.game.do_slider(self._adjustment.value)
return True
def _export_turtleblocks_cb(self, button=None):
alert = Alert()
alert.props.title = _('Save as TurtleBlocks project')
self.add_alert(alert)
alert.show()
gobject.idle_add(self._export_turtleblocks, alert)
def _export_turtleblocks(self, alert):
data = self.game.tu.current
step = 75
first = data[0] * step
second = data[1] * step
third = data[2] * step
fourth = data[3] * step
fifth = data[4] * step
turtle_data = '[[0, ["start", 219], 248, 92, [null, 1]],' +\
'[1, ["repeat", 189], 266, 138, [0, 2, 3, null]],' +\
'[2, ["number", 4], 322, 138, [1, null]],' +\
'[3, "forward", 284, 180, [1, 4, 5]],' +\
('[4, ["number", %s], 348, 180, [3, null]],' % first) +\
'[5, "right", 284, 222, [3, 6, 7]],' +\
'[6, ["number", 90], 342, 222, [5, null]],' +\
'[7, "forward", 284, 264, [5, 8, 9]],' +\
('[8, ["number", %s], 348, 264, [7, null]],' % second) +\
'[9, "right", 284, 306, [7, 10, 11]],' +\
'[10, ["number", 90], 342, 306, [9, null]],' +\
'[11, "forward", 284, 348, [9, 12, 13]],' +\
('[12, ["number", %s], 348, 348, [11, null]],'% third) +\
'[13, "right", 284, 390, [11, 14, 15]],' +\
'[14, ["number", 90], 342, 390, [13, null]],' +\
'[15, "forward", 284, 432, [13, 16, 17]],' +\
('[16, ["number", %s], 348, 432, [15, null]],'% fourth) +\
'[17, "right", 284, 474, [15, 18, 19]],' +\
'[18, ["number", 90], 342, 474, [17, null]],' +\
'[19, "forward", 284, 516, [17, 20, 21]],' +\
('[20, ["number", %s], 348, 516, [19, null]],'% fifth) +\
'[21, "right", 284, 558, [19, 22, null]],' +\
'[22, ["number", 90], 342, 558, [21, null]]]'
file_path = os.path.join(self.datapath, 'output.tb')
with open(file_path, "w") as file:
file.write(turtle_data)
dsobject = datastore.create()
dsobject.metadata['title'] = '%s %s' % (self.metadata['title'],
_('TurtleBlocks'))
dsobject.metadata['icon-color'] = profile.get_color().to_string()
dsobject.metadata['mime_type'] = 'application/x-turtle-art'
dsobject.metadata['activity'] = 'org.laptop.TurtleArtActivity'
dsobject.set_file_path(file_path)
datastore.write(dsobject)
dsobject.destroy()
os.remove(file_path)
gobject.timeout_add(1000, self._remove_alert, alert)
def _remove_alert(self, alert):
self.remove_alert(alert)
class ErikosActivity(activity.Activity):
def __init__(self, handle):
super(ErikosActivity, self).__init__(handle)
try:
# Use 0.86 toolbar design
toolbar_box = ToolbarBox()
# Buttons added to the Activity toolbar
activity_button = ActivityToolbarButton(self)
toolbar_box.toolbar.insert(activity_button, 0)
activity_button.show()
# Play Button
self.play = ToolButton("media-playback-start")
self.play.set_tooltip(_('Play'))
self.play.props.sensitive = True
self.play.connect('clicked', self._play_cb)
toolbar_box.toolbar.insert(self.play, -1)
self.play.show()
# Sound Toggle Button
self.sound = ToolButton("speaker-muted-100")
self.sound.set_tooltip(_('Mute'))
self.sound.props.sensitive = True
self.sound.connect('clicked', self._sound_cb)
toolbar_box.toolbar.insert(self.sound, -1)
self.sound.show()
separator = gtk.SeparatorToolItem()
separator.show()
toolbar_box.toolbar.insert(separator, -1)
# Label for showing level
self.level_label = gtk.Label("%s %d" % (_("Level"), 1))
self.level_label.show()
level_toolitem = gtk.ToolItem()
level_toolitem.add(self.level_label)
toolbar_box.toolbar.insert(level_toolitem, -1)
separator = gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
separator.show()
toolbar_box.toolbar.insert(separator, -1)
# The ever-present Stop Button
stop_button = StopButton(self)
stop_button.props.accelerator = '<Ctrl>Q'
toolbar_box.toolbar.insert(stop_button, -1)
stop_button.show()
self.set_toolbar_box(toolbar_box)
toolbar_box.show()
except NameError:
# Use pre-0.86 toolbar design
self.toolbox = activity.ActivityToolbox(self)
self.set_toolbox(self.toolbox)
self.projectToolbar = ProjectToolbar(self)
self.toolbox.add_toolbar(_('Project'), self.projectToolbar)
self.toolbox.show()
# Create a canvas
canvas = gtk.DrawingArea()
canvas.set_size_request(gtk.gdk.screen_width(), \
gtk.gdk.screen_height())
self.set_canvas(canvas)
canvas.show()
self.show_all()
# Initialize the canvas
self.sw = window.new_window(canvas, \
os.path.join(activity.get_bundle_path(), \
'images/'), \
self)
self.sw.activity = self
# Read the level from the Journal
try:
sw.level = int(self.metadata['level'])
except:
pass
def _play_cb(self, button):
window.play_the_game(self.sw)
return True
def _sound_cb(self, button):
if self.sw.sound is True:
self.sound.set_icon("speaker-muted-000")
self.sound.set_tooltip(_('Unmute'))
self.sw.sound = False
else:
self.sound.set_icon("speaker-muted-100")
self.sound.set_tooltip(_('Mute'))
self.sw.sound = True
return True
"""
Write the slider positions to the Journal
"""
def write_file(self, file_path):
_logger.debug("Write level: " + str(self.sw.level))
self.metadata['level'] = self.sw.level
class EditToolbar(activity.EditToolbar):
__gtype_name__ = 'EditToolbar'
def __init__(self):
activity.EditToolbar.__init__(self)
self._view = None
self._find_job = None
search_item = gtk.ToolItem()
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.connect('activate', self._search_entry_activate_cb)
self._search_entry.connect('changed', self._search_entry_changed_cb)
self._search_entry_changed = True
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_view(self, view):
self._view = view
self._view.find_set_highlight_search(True)
def _clear_find_job(self):
if self._find_job is None:
return
if not self._find_job.is_finished():
self._find_job.cancel()
self._find_job.disconnect(self._find_updated_handler)
self._find_job = None
def _search_find_first(self):
self._clear_find_job()
text = self._search_entry.props.text
if text != "":
self._find_job, self._find_updated_handler = \
self._view.setup_find_job(text, self._find_updated_cb)
else:
# FIXME: highlight nothing
pass
self._search_entry_changed = False
self._update_find_buttons()
def _search_find_next(self):
self._view.find_next()
def _search_find_last(self):
# FIXME: does Evince support find last?
return
def _search_find_prev(self):
self._view.find_previous()
def _search_entry_activate_cb(self, entry):
if self._search_entry_changed:
self._search_find_first()
else:
self._search_find_next()
def _search_entry_changed_cb(self, entry):
logging.debug('Search entry: %s' % (entry.props.text))
self._search_entry_changed = True
self._update_find_buttons()
# gobject.timeout_add(500, self._search_entry_timeout_cb)
#
#def _search_entry_timeout_cb(self):
# self._clear_find_job()
# self._search_find_first()
# return False
def _find_changed_cb(self, page, spec):
self._update_find_buttons()
def _find_updated_cb(self, job, page=None):
self._view.find_changed(job, page)
def _find_prev_cb(self, button):
if self._search_entry_changed:
self._search_find_last()
else:
self._search_find_prev()
def _find_next_cb(self, button):
if self._search_entry_changed:
self._search_find_first()
else:
self._search_find_next()
def _update_find_buttons(self):
if self._search_entry_changed:
if self._search_entry.props.text != "":
self._prev.props.sensitive = False
# self._prev.set_tooltip(_('Find last'))
self._next.props.sensitive = True
self._next.set_tooltip(_('Find first'))
else:
self._prev.props.sensitive = False
self._next.props.sensitive = False
else:
self._prev.props.sensitive = True
self._prev.set_tooltip(_('Find previous'))
self._next.props.sensitive = True
self._next.set_tooltip(_('Find next'))
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)
