def __init__(self, handle):
"""Set up the Acoustic Tape Measure activity."""
Activity.__init__(self, handle)
gobject.threads_init()
#self.set_title(gettext('Acoustic Tape Measure Activity'))
self._logger = logging.getLogger('acousticmeasure-activity')
try:
self._logger.debug("locale: " + locale.setlocale(locale.LC_ALL, ''))
except locale.Error:
self._logger.error("setlocale failed")
# top toolbar with share and close buttons:
toolbox = ActivityToolbox(self)
self.set_toolbox(toolbox)
toolbox.show()
self._t_h_bar = atm_toolbars.TempToolbar()
toolbox.add_toolbar(gettext("Atmosphere"), self._t_h_bar)
if not self.powerd_running():
try:
bus = dbus.SystemBus()
proxy = bus.get_object('org.freedesktop.ohm',
'/org/freedesktop/ohm/Keystore')
self.ohm_keystore = dbus.Interface(proxy,
'org.freedesktop.ohm.Keystore')
except dbus.DBusException, e:
self._logger.warning("Error setting OHM inhibit: %s" % e)
self.ohm_keystore = None
def __init__(self, handle):
# Initialize the parent
Activity.__init__(self, handle)
logger.debug('Initiating JPeces')
self.java_path = self.get_java_path()
if self.java_path != "":
self.create_script(os.getenv("JPECES_SCRIPT"))
sys.exit(0)
def __init__(self, handle):
logging.debug('Creating MapViewer handler.')
Activity.__init__(self, handle)
self.handle = handle
# Register run() to run from gtk_main_loop
# as soon as it gets idle.
# Which is kludge to make it run after the loop has begun
self.idleFunc = gobject.idle_add(self.run)
def __init__(self, handle):
print("TuxpaintActivity.__init__ ....")
self.prepare_all()
# Initialize the parent
Activity.__init__(self, handle)
hbox = gtk.HBox()
self.set_canvas(hbox)
self.show_all()
self.wait_to_run()
self.close()
def __init__(self, handle):
Activity.__init__(self, handle, False)
self.socket = gtk.Socket()
self.set_canvas(self.socket)
self.interfaz = Interfaz()
self.socket.add_id(self.interfaz.get_id())
self.show_all()
self.connect("key-press-event", self.interfaz.key_press_even)
self.connect("key-release-event", self.interfaz.key_release_even)
def __init__(self, handle):
Activity.__init__(self, handle)
self.modify_bg(gtk.STATE_NORMAL, gtk.gdk.color_parse("#ffeeaa"))
self.socket = gtk.Socket()
self.set_canvas(self.socket)
self.interfaz = Interfaz()
self.socket.add_id(self.interfaz.get_id())
self.show_all()
self.connect("key-press-event", self.interfaz.key_press_event)
self.connect("key-release-event", self.interfaz.key_release_event)
def __init__(self, handle):
# Initialize the parent
Activity.__init__(self, handle)
hbox = gtk.HBox()
self.set_canvas(hbox)
self.show_all()
options = ['tuxpaint', '--nolockfile', '--native', '--fullscreen', '--noprint']
doc_path = self.get_documents_path()
if doc_path is not None:
options.extend(('--savedir', doc_path))
proc = subprocess.Popen(options)
# but get rid of that window if the child exits beforehand
glib.child_watch_add(proc.pid, gtk.main_quit)
def __init__(self, handle):
Activity.__init__(self, handle)
self.gamename = 'BatallaNaval'
# Crea la barra de herramientas básica de Sugar
toolbox = ActivityToolbox(self)
self.set_toolbox(toolbox)
toolbox.show()
# Crea una instancia de Colaboración por si se quiere compartir la actividad
self.colaboracion = CollaborationWrapper(self)
# The activity is a subclass of Window, so it passses itself to the init function
BatallaNaval.init(False, self)
def __init__(self, handle):
Activity.__init__(self, handle)
self.dungeon = None
self.active_room = None
self.action_but_group = None
# INITIALIZE GUI
################
self.set_title('FortuneMaker')
# Create Toolbox
self.build_toolbars()
self.enable_room_icons(False)
self.show_home()
def __init__(self, handle):
Activity.__init__(self, handle)
self.dungeon = None
self.active_room = None
self.action_but_group = None
# INITIALIZE GUI
################
self.set_title('FortuneMaker')
# Create Toolbox
self.build_toolbars()
self.enable_room_icons(False)
self.show_home()
def __init__(self, handle):
Activity.__init__(self, handle)
# gobject is used for timeing (will be removed when rtp is implemented)
gobject.threads_init()
# Set if they started the activity
self.isServer = not self._shared_activity
# Let sugar know we only want a 1 to 1 share (limit to 2 people)
# Note this is not enforced by sugar yet :(
self.max_participants = 2
#FIXME: This is a hack to only allow our ip to be sent once.
#AKA disables others from double streaming
if self.isServer:
# server will send out ip twice, first when joinning empty channel
# second when the user joins
self.sent_ip = 2
else:
self.sent_ip = 1
# INITIALIZE GUI
################
self.set_title('OpenVideoChat')
# Setup Gui
###########
self.gui = Gui(self)
self.gui.show()
self.set_canvas(self.gui)
# Setup Network Stack
#####################
self.netstack = SugarNetworkStack(self)
self._sh_hnd = self.connect('shared', self.netstack.shared_cb)
self._jo_hnd = self.connect('joined', self.netstack.joined_cb)
# Setup Pipeline
#################
self.gststack = GSTStack(self.gui.send_video_to_screen)
self.gststack.build_incoming_pipeline()
gobject.idle_add(self.gststack.start_stop_incoming_pipeline, True)
print "Activity Started"
def __init__(self, handle):
Activity.__init__(self, handle)
# gobject is used for timeing (will be removed when rtp is implemented)
gobject.threads_init()
# Set if they started the activity
self.isServer = not self._shared_activity
# Let sugar know we only want a 1 to 1 share (limit to 2 people)
# Note this is not enforced by sugar yet :(
self.max_participants = 2
#FIXME: This is a hack to only allow our ip to be sent once.
#AKA disables others from double streaming
if self.isServer:
# server will send out ip twice, first when joinning empty channel
# second when the user joins
self.sent_ip = 2
else:
self.sent_ip = 1
# INITIALIZE GUI
################
self.set_title('OpenVideoChat')
# Setup Gui
###########
self.gui = Gui(self)
self.gui.show()
self.set_canvas(self.gui)
# Setup Network Stack
#####################
self.netstack = SugarNetworkStack(self)
self._sh_hnd = self.connect('shared', self.netstack.shared_cb)
self._jo_hnd = self.connect('joined', self.netstack.joined_cb)
# Setup Pipeline
#################
self.gststack = GSTStack( self.gui.send_video_to_screen )
self.gststack.build_incoming_pipeline()
gobject.idle_add( self.gststack.start_stop_incoming_pipeline, True )
print "Activity Started"
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)
toolbox = ActivityToolbox(self)
self.set_toolbox(toolbox)
toolbox.show()
title_widget = toolbox._activity_toolbar.title
title_widget.set_size_request(title_widget.get_layout().get_pixel_size()[0] + 20, -1)
self.ui = SliderPuzzleUI(self)
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)
def __init__(self, handle):
Activity.__init__(self, handle)
logger.debug('Starting Jigsaw Puzzle activity... %s' % str(get_bundle_path()))
os.chdir(get_bundle_path())
self.connect('destroy', self._destroy_cb)
toolbox = ActivityToolbox(self)
self.set_toolbox(toolbox)
toolbox.show()
# Toolbar title size hack
title_widget = toolbox._activity_toolbar.title
title_widget.set_size_request(title_widget.get_layout().get_pixel_size()[0] + 30, -1)
self.ui = JigsawPuzzleUI(self)
self.set_canvas(self.ui)
self.show_all()
TubeHelper.__init__(self, tube_class=GameTube, service=SERVICE)
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)
toolbox = ActivityToolbox(self)
self.set_toolbox(toolbox)
toolbox.show()
title_widget = toolbox._activity_toolbar.title
title_widget.set_size_request(
title_widget.get_layout().get_pixel_size()[0] + 20, -1)
self.ui = SliderPuzzleUI(self)
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)
def __init__(self, handle):
Activity.__init__(self, handle)
logger.debug('Starting Jigsaw Puzzle activity... %s' %
str(get_bundle_path()))
os.chdir(get_bundle_path())
self.connect('destroy', self._destroy_cb)
toolbox = ActivityToolbox(self)
self.set_toolbox(toolbox)
toolbox.show()
# Toolbar title size hack
title_widget = toolbox._activity_toolbar.title
title_widget.set_size_request(
title_widget.get_layout().get_pixel_size()[0] + 30, -1)
self.ui = JigsawPuzzleUI(self)
self.set_canvas(self.ui)
self.show_all()
TubeHelper.__init__(self, tube_class=GameTube, service=SERVICE)
def __init__(self, handle):
Activity.__init__(self, handle)
root = self.make_root()
self.set_canvas(root)
root.show_all()
self.entry.grab_focus()
toolbox = ActivityToolbox(self)
activity_toolbar = toolbox.get_activity_toolbar()
activity_toolbar.keep.props.visible = False
self.set_toolbox(toolbox)
toolbox.show()
self.pservice = PresenceService()
self.owner = self.pservice.get_owner()
# Auto vs manual scrolling:
self._scroll_auto = True
self._scroll_value = 0.0
# Track last message, to combine several messages:
self._last_msg = None
self._last_msg_sender = None
self.text_channel = None
if self._shared_activity:
# we are joining the activity
self.connect('joined', self._joined_cb)
if self.get_shared():
# we have already joined
self._joined_cb()
else:
# we are creating the activity
if not self.metadata or self.metadata.get('share-scope',
SCOPE_PRIVATE) == SCOPE_PRIVATE:
# if we are in private session
self._alert(_('Off-line'), _('Share, or invite someone.'))
self.connect('shared', self._shared_cb)
def __init__(self, handle):
Activity.__init__(self, handle)
root = self.make_root()
self.set_canvas(root)
root.show_all()
self.entry.grab_focus()
toolbox = ActivityToolbox(self)
activity_toolbar = toolbox.get_activity_toolbar()
activity_toolbar.keep.props.visible = False
self.set_toolbox(toolbox)
toolbox.show()
self.owner = self._pservice.get_owner()
# Auto vs manual scrolling:
self._scroll_auto = True
self._scroll_value = 0.0
# Track last message, to combine several messages:
self._last_msg = None
self._last_msg_sender = None
self.text_channel = None
if self._shared_activity:
# we are joining the activity
self.connect('joined', self._joined_cb)
if self.get_shared():
# we have already joined
self._joined_cb()
else:
# we are creating the activity
if not self.metadata or self.metadata.get(
'share-scope', SCOPE_PRIVATE) == SCOPE_PRIVATE:
# if we are in private session
self._alert(_('Off-line'), _('Share, or invite someone.'))
self.connect('shared', self._shared_cb)
def __init__(self, handle):
# Initialize the parent
Activity.__init__(self, handle)
logger.debug('Initiating MathGraph32')
# Set the activity toolbox
toolbox = ActivityToolbox(self)
self.set_toolbox(toolbox)
self.ceibaljam_icon_path = os.getenv("SUGAR_BUNDLE_PATH") + "/images/ceibaljam.png"
self.java_path = self.get_java_path()
#
# There's a good explanation of the use of boxes in PyGTK here:
# http://www.pygtk.org/pygtk2tutorial/sec-DetailsOfBoxes.html
#
box_canvas = gtk.VBox(False, 0)
self.set_canvas(box_canvas)
# Title
box_title = gtk.VBox(False, 0)
label_title = gtk.Label(_("MathGraph32"))
label_title.set_justify(gtk.JUSTIFY_CENTER)
label_title.modify_font(pango.FontDescription("Arial 22"))
box_title.add(gtk.Label("\n\n"))
box_title.add(label_title)
box_title.add(gtk.Label("\n"))
# Author
box_author = gtk.VBox(False, 0)
#box_author.add(gtk.Label(""))
box_author.add(gtk.Label(_("Created by Yves Biton")))
label_author_url = gtk.Label('<b>http://www.mathgraph32.org</b>')
label_author_url.set_use_markup(True)
box_author.add(label_author_url)
# Credits
box_credits = gtk.VBox(False, 0)
box_credits.add(gtk.Label(""))
box_credits.add(gtk.Label(_('Spanish translation and pedagogical evaluation by %(TEACHER)s') % { 'TEACHER': 'Luis Belcredi' }))
label_teacher_email= gtk.Label('<b>http://xsubcero.50webs.biz</b>')
label_teacher_email.set_use_markup(True)
box_credits.add(label_teacher_email)
box_credits.add(gtk.Label(""))
box_credits.add(gtk.Label(_('Sugarized by %(SUGARIZER)s') % { 'SUGARIZER': 'Marcos Orfila' }))
label_sugarizer_website = gtk.Label('<b>http://www.marcosorfila.com</b>')
label_sugarizer_website.set_use_markup(True)
box_credits.add(label_sugarizer_website)
box_credits.add(gtk.Label(""))
# Footer box (Activities on CeibalJAM! website)
box_footer = gtk.VBox(False, 0)
box_footer.add(gtk.Label(""))
box_footer.add(gtk.Label(_('Find more activities on %(CEIBALJAM)s website:') % { 'CEIBALJAM': 'CeibalJAM!'}))
label_ceibaljam_website = gtk.Label('<b>http://activities.ceibaljam.org</b>')
label_ceibaljam_website.set_use_markup(True)
box_footer.add(label_ceibaljam_website)
box_footer.add(gtk.Label(""))
# CeibalJAM! image
box_ceibaljam_image = gtk.VBox(False, 0)
image_ceibaljam = gtk.Image()
image_ceibaljam.set_from_file(self.ceibaljam_icon_path)
box_ceibaljam_image.pack_end(image_ceibaljam, False, False, 0)
# Get all the boxes together
box_canvas.pack_start(box_title, False, False, 0)
box_canvas.pack_start(box_author, False, False, 0)
box_canvas.pack_start(gtk.Label("\n"), False, False, 0)
if self.java_path == "":
box_java_not_found = gtk.VBox(False, 0)
label_java_not_found = gtk.Label('<span foreground="red"><b>' + _("Java was not found!") + '</b></span>')
label_java_not_found.set_justify(gtk.JUSTIFY_CENTER)
label_java_not_found.set_use_markup(True)
label_java_not_found.modify_font(pango.FontDescription("Arial 20"))
box_java_not_found.add(label_java_not_found)
box_java_not_found.add(gtk.Label(_('You can download the Java activity from %(CEIBALJAM)s website (see below)') % { 'CEIBALJAM': 'CeibalJAM!'}))
box_canvas.pack_start(box_java_not_found, False, False, 0)
box_canvas.pack_start(gtk.Label(""), False, False, 0)
else:
box_java_found = gtk.VBox(False, 0)
label_version_info_title = gtk.Label('<b>' + _("Java version found:") + '</b>')
label_version_info_title.set_use_markup(True)
version_information = commands.getoutput(self.java_path + " -version")
label_version_info = gtk.Label(version_information)
label_version_info.set_justify(gtk.JUSTIFY_CENTER)
box_java_found.add(label_version_info_title)
box_java_found.add(label_version_info)
box_canvas.pack_start(box_java_found, False, False, 0)
box_canvas.pack_end(gtk.Label("\n"), False, False, 0)
self.add_buttons(box_canvas)
box_canvas.pack_end(box_footer, False, False, 0)
box_canvas.pack_end(box_ceibaljam_image, False, False, 0)
box_canvas.pack_end(box_credits, False, False, 0)
if self.java_path != '':
self.button_play.grab_focus()
else:
self.button_exit.grab_focus()
self.show_all()
def __init__(self, handle):
print "running activity init", handle
Activity.__init__(self, handle)
print "activity running"
self._logger = logging.getLogger('scribble-activity')
toolbox = ActivityToolbox(self)
self.set_toolbox(toolbox)
toolbox.show()
pencilbtn = sugar.graphics.radiotoolbutton.RadioToolButton()
pencilbtn.set_named_icon('tool-pencil')
pencilbtn.set_tooltip(_("Pencil"))
pencilbtn.connect('toggled', self._pencil_cb)
circlebtn = sugar.graphics.radiotoolbutton.RadioToolButton()
circlebtn.set_named_icon('tool-shape-ellipse')
circlebtn.set_tooltip(_("Ellipse"))
circlebtn.connect('toggled', self._circle_cb)
circlebtn.set_group(pencilbtn)
rectbtn = sugar.graphics.radiotoolbutton.RadioToolButton()
rectbtn.set_named_icon('tool-shape-rectangle')
rectbtn.set_tooltip(_("Rectangle"))
rectbtn.connect('toggled', self._rect_cb)
rectbtn.set_group(circlebtn)
polybtn = sugar.graphics.radiotoolbutton.RadioToolButton()
polybtn.set_named_icon('tool-shape-freeform')
polybtn.set_tooltip(_("Shape"))
polybtn.connect('toggled', self._poly_cb)
polybtn.set_group(rectbtn)
sep = gtk.SeparatorToolItem()
sep.set_expand(False)
sep.set_draw(True)
erasebtn = sugar.graphics.radiotoolbutton.RadioToolButton()
erasebtn.set_named_icon('tool-eraser')
erasebtn.set_tooltip(_("Erase"))
erasebtn.connect('toggled', self._erase_cb)
erasebtn.set_group(polybtn)
toolbar = gtk.Toolbar()
toolbar.insert(pencilbtn, -1)
toolbar.insert(circlebtn, -1)
toolbar.insert(rectbtn, -1)
toolbar.insert(polybtn, -1)
toolbar.insert(sep, -1)
toolbar.insert(erasebtn, -1)
sep = gtk.SeparatorToolItem()
sep.set_expand(True)
sep.set_draw(False)
toolbar.insert(sep, -1)
exportbtn = ExportButton(self)
toolbar.insert(exportbtn, -1)
exportbtn.show()
toolbox.add_toolbar(_('Toolbox'), toolbar)
toolbar.show_all()
self._scribblewidget = scribblewidget.ScribbleWidget()
self._scribblewidget.connect('item-added', \
self.scribblewidget_item_added_cb)
colors = profile.get_color()
self._scribblewidget.set_fill_color(colors.get_fill_color())
self._scribblewidget.set_stroke_color(colors.get_stroke_color())
self._scribblewidget.set_tool('pencil')
sw = gtk.ScrolledWindow()
sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
sw.add(self._scribblewidget)
self.set_canvas(sw)
sw.show_all()
self.cmdtube = None # Shared session
self.initiating = False
# get the Presence Service
self.pservice = presenceservice.get_instance()
# Buddy object for you
owner = self.pservice.get_owner()
self.owner = owner
self.connect('shared', self._shared_cb)
self.connect('joined', self._joined_cb)
def __init__(self, handle):
"""Set up the StopWatch activity."""
Activity.__init__(self, handle)
self._logger = logging.getLogger('stopwatch-activity')
gobject.threads_init()
# top toolbar with share and close buttons:
OLD_TOOLBAR = False
try:
from sugar.graphics.toolbarbox import ToolbarBox, ToolbarButton
from sugar.activity.widgets import ActivityToolbarButton, StopButton, \
ShareButton, TitleEntry, ActivityButton
except ImportError:
OLD_TOOLBAR = True
if OLD_TOOLBAR:
toolbox = ActivityToolbox(self)
self.set_toolbox(toolbox)
toolbox.show()
else:
toolbar_box = ToolbarBox()
self.activity_button = ActivityButton(self)
toolbar_box.toolbar.insert(self.activity_button, 0)
self.activity_button.show()
title_entry = TitleEntry(self)
toolbar_box.toolbar.insert(title_entry, -1)
title_entry.show()
try:
from sugar.activity.widgets import DescriptionItem
description_item = DescriptionItem(self)
toolbar_box.toolbar.insert(description_item, -1)
description_item.show()
except:
pass
share_button = ShareButton(self)
toolbar_box.toolbar.insert(share_button, -1)
share_button.show()
separator = gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
toolbar_box.toolbar.insert(separator, -1)
separator.show()
stop_button = StopButton(self)
toolbar_box.toolbar.insert(stop_button, -1)
stop_button.show()
self.set_toolbar_box(toolbar_box)
self.tubebox = dobject.TubeBox()
self.timer = dobject.TimeHandler("main", self.tubebox)
self.gui = stopwatch.GUIView(self.tubebox, self.timer)
self.set_canvas(self.gui.display)
self.show_all()
self.initiating = False
# get the Presence Service
self.pservice = presenceservice.get_instance()
# Buddy object for you
owner = self.pservice.get_owner()
self.owner = owner
self.connect('shared', self._shared_cb)
self.connect('joined', self._joined_cb)
self.add_events(gtk.gdk.VISIBILITY_NOTIFY_MASK)
self.connect("visibility-notify-event", self._visible_cb)
self.connect("notify::active", self._active_cb)
def __init__(self, *args, **kwargs):
Activity.__init__(self, *args, **kwargs)
self._webkit = None
pythonpath = []
try:
import webkit
except ImportError:
self.set_canvas(self._alert('PyWebKitGtk is not installed.'))
return
try:
import M2Crypto
except ImportError:
self.set_canvas(self._alert('M2Crypto is not installed.'))
return
try:
import gevent
if gevent.version_info[0] < 1:
raise ImportError()
except ImportError:
sys.path.insert(0, bin_packages)
try:
import gevent
except ImportError:
error = 'gevent-1.0 is not installed.'
self.set_canvas(self._alert(error))
return
pythonpath.append(bin_packages)
pythonpath.append(site_packages)
if 'PYTHONPATH' in os.environ:
pythonpath.append(os.environ.get('PYTHONPATH'))
os.environ['PYTHONPATH'] = ':'.join(pythonpath)
returncode = subprocess.call([
'sugar-network-client',
'graceful_start',
'-DDD',
'--hub-root',
join(src_root),
'--webui',
'--lazy-open',
],
env=os.environ)
if returncode:
error = 'Fail to start sugar-network-client. ' \
'See log file for details.'
self.set_canvas(self._alert(error))
return
self._sn_plugin_started = False
try:
from jarabe.plugins import plugins, sn
Option.seek('shell', [plugins])
Option.load([
'/etc/sweets.conf',
'~/.config/sweets/config',
sugar.profile_path('sweets.conf'),
])
self._sn_plugin_started = 'sn' in plugins.value
except ImportError:
pass
self._client = IPCClient()
self._subscription = self._client.subscribe()
gobject.io_add_watch(self._subscription.fileno(),
gobject.IO_IN | gobject.IO_HUP,
self.__subscription_cb)
self._webkit = webkit.WebView()
self._webkit.show()
scrolled = gtk.ScrolledWindow()
scrolled.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
scrolled.set_shadow_type(gtk.SHADOW_NONE)
scrolled.add(self._webkit)
scrolled.show()
self.set_canvas(scrolled)
self._webkit.open(launcher_url)
def __init__(self, handle):
#handle object contains command line inputs to this activity
self.handle = handle
_logger.debug('Activity id:%s.Object id: %s. uri:%s' %
(handle.activity_id, handle.object_id, handle.uri))
self.passed_in_ds_object = None
if handle.object_id and handle.object_id != '':
self.passed_in_ds_object = datastore.get(handle.object_id)
if self.passed_in_ds_object:
d = self.passed_in_ds_object.metadata
#log_dict(d,'initial datastore metadata ==>:')
else:
ds_object = self.get_new_dsobject()
if hasattr(ds_object, 'get_object_id'):
handle.object_id = ds_object.get_object_id()
else:
handle.object_id = ds_object.object_id
_logger.debug(
'no initial datastore object id passed in via handle')
#Save a global poiinter so remote procedure calls can communicate with pydebug
global pydebug_instance
pydebug_instance = self
start_clock = time.clock()
#init variables
self.make_paths()
self.save_icon_clicked = False
self.source_directory = None
self.data_file = None
self.help = None
self.help_x11 = None
self.dirty = False
self.sock = None
#self.last_filename = None
self.debug_dict = {}
self.activity_dict = {}
self.manifest_treeview = None #set up to recognize an re-display of playpen
#self.set_title(_('PyDebug Activity'))
self.ds = None #datastore pointer
self._logger = _logger
self.traceback = 'Context'
self.abandon_changes = False
self.delete_after_load = None
self.find_window = None
self.icon_outline = 'icon_square'
self.icon_window = None
self.last_icon_file = None
self.activity_data_changed = False
self.icon_basename = None
#sugar 0.82 has a different way of getting colors and dies during init unless the following
self.profile = profile.get_profile()
self.profile.color = XoColor()
#get the persistent data across all debug sessions and start using it
self.get_config()
#give the server a chance to get started so terminal can connect to it
self.non_blocking_server()
#glib.idle_add(self.non_blocking_server)
"""
if self.request_new_jobject and self.debug_dict.get('jobject_id','') != '':
self.request_new_jobject = False
#keep on using the same journal entry
if self.debug_dict.get('jobject_id','') != '':
handle.object_id = self.debug_dict.get('jobject_id','')
"""
# init the Classes we are subclassing
_logger.debug('about to init superclass activity. Elapsed time: %f'%\
(time.clock()-start_clock))
Activity.__init__(self, handle, create_jobject=False)
"""
if self.request_new_jobject:
#check to see if the object was created
if self._jobject:
self.debug_dict['jobject_id'] = str(self._jobject.object_id)
else:
_logger.debug('failed to create jobject in Activity.__init__')
"""
self.connect('realize', self.realize_cb)
self.accelerator = gtk.AccelGroup()
self.add_accel_group(self.accelerator)
#set up the PANES for the different functions of the debugger
_logger.debug('about to set up Menu panes. Elapsed time: %f' %
(time.clock() - start_clock))
self.panes = {}
PANES = ['TERMINAL', 'EDITOR', 'PROJECT', 'HELP']
for i in range(len(PANES)):
self.panes[PANES[i]] = i
#toolbox needs to be available during init of modules
self.toolbox = pytoolbar.ActivityToolbox(self)
self.toolbox.connect_after('current_toolbar_changed',
self._toolbar_changed_cb)
self.toolbox.set_current_toolbar(self.panes['TERMINAL'])
#########################################################################################
#init the sub functions
TerminalGui.__init__(self, self, self.toolbox)
EditorGui.__init__(self, self)
ProjectGui.__init__(self, self)
self.help = Help(self)
self.util = Utilities(self)
#########################################################################################
#if first time run on this machine, set up home directory
if not os.path.isfile(os.path.join(self.debugger_home, '.bashrc')):
self.setup_home_directory()
# setup the search options
self.s_opts = SearchOptions(
where=S_WHERE.file,
use_regex=False,
ignore_caps=True,
replace_all=False,
#defaults to avoid creating
#a new SearchOptions object for normal searches
#should never be changed, just make a copy like:
#SearchOptions(self.s_opts, forward=False)
forward=True,
stay=False)
self.safe_to_replace = False
#get the sugar version
(major, minor, micro, release) = self._activity.util.sugar_version()
_logger.debug('sugar version major:%s minor:%s micro:%s release:%s' %
(major, minor, micro, release))
if not minor:
minor = 70
self.sugar_minor = minor
#########################################################################################
_logger.debug(
'All app objects created. about to set up Display . Elapsed time: %f'
% (time.clock() - start_clock))
self.canvas_list = []
self.canvas_list.append(self._get_terminal_canvas())
self.canvas_list.append(self._get_edit_canvas())
self.canvas_list.append(self._get_project_canvas())
self.canvas_list.append(self._get_help_canvas())
nb = gtk.Notebook()
nb.show()
nb.set_show_tabs(False)
for c in self.canvas_list:
nb.append_page(c)
self.pydebug_notebook = nb
#the following call to the activity code puts our notebook under the stock toolbar
self.set_canvas(nb)
helpbar = self.help.get_help_toolbar()
self.toolbox.add_toolbar(_('Edit'), self.get_editbar())
self.toolbox.add_toolbar(_('Project'), self.get_projectbar())
self.toolbox.add_toolbar(_('Help'), self.help.get_help_toolbar())
self.set_toolbox(self.toolbox)
self.toolbox.show()
#set which PANE is visible initially
self.set_visible_canvas(self.panes['PROJECT'])
self.set_toolbar(self.panes['PROJECT'])
_logger.debug('about to setup_project_page. Elapsed time: %f' %
(time.clock() - start_clock))
self.setup_project_page()
_logger.debug(
'about Returned from setup_project_page. Elapsed time: %f' %
(time.clock() - start_clock))
#get the journal datastore information and resume previous activity
#self.metadata = self.ds
if self.passed_in_ds_object and self.passed_in_ds_object.get_file_path(
):
ds_file = self.passed_in_ds_object.get_file_path()
else:
ds_file = ''
_logger.debug('about to call read routine Elapsed time: %f' %
(time.clock() - start_clock))
self.read_file(ds_file)
_logger.debug('about (end of init) Elapsed time: %f' %
(time.clock() - start_clock))
def __init__(self, handle):
# Initialize the parent
Activity.__init__(self, handle)
logger.debug('Initiating Tuxmath')
# Set the activity toolbox
toolbox = ActivityToolbox(self)
self.set_toolbox(toolbox)
self.ceibaljam_icon_path = os.getenv("SUGAR_BUNDLE_PATH") + "/images/ceibaljam.png"
#
# There's a good explanation of the use of boxes in PyGTK here:
# http://www.pygtk.org/pygtk2tutorial/sec-DetailsOfBoxes.html
#
box_canvas = gtk.VBox(False, 0)
self.set_canvas(box_canvas)
# Title
box_title = gtk.VBox(False, 0)
label_title = gtk.Label(_("Tuxmath"))
label_title.set_justify(gtk.JUSTIFY_CENTER)
label_title.modify_font(pango.FontDescription("Arial 22"))
box_title.add(gtk.Label("\n\n\n"))
box_title.add(label_title)
box_title.add(gtk.Label("\n"))
# Author
box_author = gtk.VBox(False, 0)
box_author.add(gtk.Label(""))
box_author.add(gtk.Label(_("Created by Tux4kids")))
label_author_url = gtk.Label('<b>http://tux4kids.alioth.debian.org</b>')
label_author_url.set_use_markup(True)
box_author.add(label_author_url)
# Options box
box_options = gtk.VBox(False, 0)
label_options = gtk.Label(_("Options:"))
label_options.set_justify(gtk.JUSTIFY_LEFT)
self.checkbtn_sound = gtk.CheckButton(label=_("No sound"))
self.checkbtn_sound.set_active(True)
self.checkbtn_negatives = gtk.CheckButton(label=_("Include negative numbers"))
self.checkbtn_negatives.set_active(False)
# Pack the checkboxes in HBoxes to center them
hbox1 = gtk.HBox(False, 0)
hbox1.add(gtk.Label(""))
hbox1.add(gtk.Label(""))
hbox1.add(gtk.Label(""))
hbox1.add(gtk.Label(""))
hbox1.add(gtk.Label(""))
hbox1.add(gtk.Label(""))
hbox1.add(gtk.Label(""))
hbox1.add(self.checkbtn_sound)
hbox1.add(gtk.Label(""))
hbox1.add(gtk.Label(""))
hbox1.add(gtk.Label(""))
hbox1.add(gtk.Label(""))
hbox1.add(gtk.Label(""))
hbox1.add(gtk.Label(""))
box_options.add(hbox1)
#box_options.add(gtk.Label(""))
#box_options.add(label_options)
#box_options.add(self.checkbtn_sound)
#box_options.add(self.checkbtn_negatives)
# Credits
box_credits = gtk.VBox(False, 0)
box_credits.add(gtk.Label(""))
box_credits.add(gtk.Label(_('Spanish translation and pedagogical evaluation by %(TEACHER)s') % { 'TEACHER': 'Ana Cichero' }))
label_teacher_email= gtk.Label('<b>[email protected]</b>')
label_teacher_email.set_use_markup(True)
box_credits.add(label_teacher_email)
box_credits.add(gtk.Label(_('Sugarized by %(SUGARIZER)s') % { 'SUGARIZER': 'Marcos Orfila' }))
label_sugarizer_website = gtk.Label('<b>http://www.marcosorfila.com</b>')
label_sugarizer_website.set_use_markup(True)
box_credits.add(label_sugarizer_website)
box_credits.add(gtk.Label(""))
# Footer box (Activities on CeibalJAM! website)
box_footer = gtk.VBox(False, 0)
box_footer.add(gtk.Label(""))
box_footer.add(gtk.Label(_('Find more activities on %(CEIBALJAM)s website:') % { 'CEIBALJAM': 'CeibalJAM!'}))
label_ceibaljam_website = gtk.Label('<b>http://activities.ceibaljam.org</b>')
label_ceibaljam_website.set_use_markup(True)
box_footer.add(label_ceibaljam_website)
box_footer.add(gtk.Label(""))
# CeibalJAM! image
box_ceibaljam_image = gtk.VBox(False, 0)
image_ceibaljam = gtk.Image()
image_ceibaljam.set_from_file(self.ceibaljam_icon_path)
box_ceibaljam_image.pack_end(image_ceibaljam, False, False, 0)
# Buttons box
box_buttons = gtk.HBox(False, 0)
self.button_play = gtk.Button(_("Play"))
self.button_play.connect("clicked", self._button_play_clicked_cb)
self.button_exit = gtk.Button(_("Exit"))
self.button_exit.connect("clicked", self._button_exit_clicked_cb)
box_buttons.add(gtk.VBox())
box_buttons.add(self.button_play)
box_buttons.add(gtk.VBox())
box_buttons.add(self.button_exit)
box_buttons.add(gtk.VBox())
# Get all the boxes together
box_canvas.pack_start(box_title, False, False, 0)
box_canvas.pack_start(box_options, False, False, 0)
box_canvas.pack_end(gtk.Label("\n\n"), False, False, 0)
box_canvas.pack_end(box_buttons, False, False, 0)
box_canvas.pack_end(gtk.Label("\n"), False, False, 0)
box_canvas.pack_end(box_footer, False, False, 0)
box_canvas.pack_end(box_ceibaljam_image, False, False, 0)
box_canvas.pack_end(box_credits, False, False, 0)
box_canvas.pack_end(box_author, False, False, 0)
self.button_play.grab_focus()
self.show_all()
def __init__(self, handle):
self.game_init = False # Tells if game engine was initialized
self.loaded_game = None
Activity.__init__(self, handle)
# Creates the activiy box for toolbars
self.toolbox = ActivityToolbox(self)
self.set_toolbox(self.toolbox)
self.toolbox.show()
# Retrieves the Activity standard toolbar
self.activity_toolbar = self.toolbox.get_activity_toolbar()
# Creates other toolbars
# Game toolbar gets created on demand
# Library toolbar gets created on demand
self.guides_toolbar = gtk.Toolbar()
self.credits_toolbar = gtk.Toolbar()
self.indexes = ["activity"] # right now only activity toolbar
# Create startup windows
self.startup_window = startup_window.StartupWindow(self._start_cb, self._load_last_cb)
# Create the canvas to embbed pygame
self.pygame_canvas = PygameCanvas(self, False)
# Create Health Library Window
self.health_library = content_window.ContentWindow()
# Create Guides Window
self.guides = guides_window.GuidesWindow()
# Create Credits Window
self.credits = credits.Credits()
self.startup_window.show()
self.pygame_canvas.show()
self.health_library.show()
self.guides.show()
self.credits.show()
self.items = gtk.Notebook()
self.items.set_show_tabs(False)
self.items.set_show_border(False)
self.items.append_page(self.startup_window)
self.items.append_page(self.pygame_canvas)
self.items.append_page(self.health_library)
self.items.append_page(self.guides)
self.items.append_page(self.credits)
self.items.show()
self.set_canvas(self.items)
logging.debug("Create main")
self.game = game.Main()
self.game.set_game_over_callback(self.game_over_callback)
self.toolbox.connect('current-toolbar-changed', self.change_mode)
self.make_toolbox(False)
self.toolbox.set_current_toolbar(0) # Start in activity tab
# force the toolbar change
self.change_mode(None, self.toolbox.get_current_toolbar())
game.set_library_function = self.set_library # Sets the callback to put links in the library
self.show()
def __init__(self, handle):
"""Set up the StopWatch activity."""
Activity.__init__(self, handle)
self._logger = logging.getLogger('stopwatch-activity')
gobject.threads_init()
# top toolbar with share and close buttons:
OLD_TOOLBAR = False
try:
from sugar.graphics.toolbarbox import ToolbarBox, ToolbarButton
from sugar.activity.widgets import ActivityToolbarButton, StopButton, \
ShareButton, TitleEntry, ActivityButton
except ImportError:
OLD_TOOLBAR = True
if OLD_TOOLBAR:
toolbox = ActivityToolbox(self)
self.set_toolbox(toolbox)
toolbox.show()
else:
toolbar_box = ToolbarBox()
self.activity_button = ActivityButton(self)
toolbar_box.toolbar.insert(self.activity_button, 0)
self.activity_button.show()
title_entry = TitleEntry(self)
toolbar_box.toolbar.insert(title_entry, -1)
title_entry.show()
try:
from sugar.activity.widgets import DescriptionItem
description_item = DescriptionItem(self)
toolbar_box.toolbar.insert(description_item, -1)
description_item.show()
except:
pass
share_button = ShareButton(self)
toolbar_box.toolbar.insert(share_button, -1)
share_button.show()
separator = gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
toolbar_box.toolbar.insert(separator, -1)
separator.show()
stop_button = StopButton(self)
toolbar_box.toolbar.insert(stop_button, -1)
stop_button.show()
self.set_toolbar_box(toolbar_box)
self.tubebox = dobject.TubeBox()
self.timer = dobject.TimeHandler("main", self.tubebox)
self.gui = stopwatch.GUIView(self.tubebox, self.timer)
self.set_canvas(self.gui.display)
self.show_all()
self.initiating = False
# get the Presence Service
self.pservice = presenceservice.get_instance()
# Buddy object for you
owner = self.pservice.get_owner()
self.owner = owner
self.connect('shared', self._shared_cb)
self.connect('joined', self._joined_cb)
self.add_events(gtk.gdk.VISIBILITY_NOTIFY_MASK)
self.connect("visibility-notify-event", self._visible_cb)
self.connect("notify::active", self._active_cb)
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)
def __init__(self, handle):
# Initialize the parent
Activity.__init__(self, handle)
logger.debug('Initiating PlayGo')
self.size = DEFAULT_SIZE
self.komi = DEFAULT_KOMI
# Set the activity toolbox
toolbox = ActivityToolbox(self)
self.set_toolbox(toolbox)
self.gameToolbar = GameToolbar(self)
toolbox.add_toolbar(_('Game'), self.gameToolbar)
self.gameToolbar.connect('game-restart', self.restart_game)
self.gameToolbar.connect('game-board-size', self.board_size_change)
self.gameToolbar.connect('ai-activated', self.ai_activated_cb)
self.gameToolbar.connect('ai-deactivated', self.ai_deactivated_cb)
self.gameToolbar.show()
# Initialize the game
self.game = GoGame(self.size)
self.CurrentColor = 'B'
self.PlayerColor = 'B'
self.pass_count = 0
self.ai_activated = False
self.set_up_ui()
if not handle.object_id:
self.infopanel.show(_('Welcome to PlayGo!'))
else:
self.show_score()
self.lastX = -1
self.lastY = -1
# Set keypad actions
self._key_actions = {
'KP_Up': 'move_up',
'KP_Right': 'move_right',
'KP_Down': 'move_down',
'KP_Left': 'move_left',
'KP_Home': 'place_stone',
'KP_Next': 'undo',
'KP_End': 'pass'
}
self._key_grabber = KeyGrabber()
self._key_grabber.connect('key-pressed', self._key_pressed_cb)
# New KeyGrabber API change (ticket #7999)
try:
self._key_grabber.grab_keys(self._key_actions.keys())
except:
for key in self._key_actions.keys():
self._key_grabber.grab(key)
#Set up collaboration
self.collaboration = CollaborationWrapper(self, self.buddy_joined,
self.buddy_left, self.Play,
self.game.undostack,
self.bootstrap)
self.connect('shared', self.collaboration._shared_cb)
if self._shared_activity:
# We are joining the activity
self.connect('joined', self.collaboration._joined_cb)
if self.get_shared():
# We've already joined
self.collaboration._joined_cb()
def __init__(self, handle):
# Initialize the parent
Activity.__init__(self, handle)
logger.debug('Initiating Tuxmath')
# Set the activity toolbox
toolbox = ActivityToolbox(self)
self.set_toolbox(toolbox)
self.ceibaljam_icon_path = os.getenv(
"SUGAR_BUNDLE_PATH") + "/images/ceibaljam.png"
#
# There's a good explanation of the use of boxes in PyGTK here:
# http://www.pygtk.org/pygtk2tutorial/sec-DetailsOfBoxes.html
#
box_canvas = gtk.VBox(False, 0)
self.set_canvas(box_canvas)
# Title
box_title = gtk.VBox(False, 0)
label_title = gtk.Label(_("Tuxmath"))
label_title.set_justify(gtk.JUSTIFY_CENTER)
label_title.modify_font(pango.FontDescription("Arial 22"))
box_title.add(gtk.Label("\n\n\n"))
box_title.add(label_title)
box_title.add(gtk.Label("\n"))
# Author
box_author = gtk.VBox(False, 0)
box_author.add(gtk.Label(""))
box_author.add(gtk.Label(_("Created by Tux4kids")))
label_author_url = gtk.Label(
'<b>http://tux4kids.alioth.debian.org</b>')
label_author_url.set_use_markup(True)
box_author.add(label_author_url)
# Options box
box_options = gtk.VBox(False, 0)
label_options = gtk.Label(_("Options:"))
label_options.set_justify(gtk.JUSTIFY_LEFT)
self.checkbtn_sound = gtk.CheckButton(label=_("No sound"))
self.checkbtn_sound.set_active(True)
self.checkbtn_negatives = gtk.CheckButton(
label=_("Include negative numbers"))
self.checkbtn_negatives.set_active(False)
# Pack the checkboxes in HBoxes to center them
hbox1 = gtk.HBox(False, 0)
hbox1.add(gtk.Label(""))
hbox1.add(gtk.Label(""))
hbox1.add(gtk.Label(""))
hbox1.add(gtk.Label(""))
hbox1.add(gtk.Label(""))
hbox1.add(gtk.Label(""))
hbox1.add(gtk.Label(""))
hbox1.add(self.checkbtn_sound)
hbox1.add(gtk.Label(""))
hbox1.add(gtk.Label(""))
hbox1.add(gtk.Label(""))
hbox1.add(gtk.Label(""))
hbox1.add(gtk.Label(""))
hbox1.add(gtk.Label(""))
box_options.add(hbox1)
#box_options.add(gtk.Label(""))
#box_options.add(label_options)
#box_options.add(self.checkbtn_sound)
#box_options.add(self.checkbtn_negatives)
# Credits
box_credits = gtk.VBox(False, 0)
box_credits.add(gtk.Label(""))
box_credits.add(
gtk.Label(
_('Spanish translation and pedagogical evaluation by %(TEACHER)s'
) % {'TEACHER': 'Ana Cichero'}))
label_teacher_email = gtk.Label('<b>[email protected]</b>')
label_teacher_email.set_use_markup(True)
box_credits.add(label_teacher_email)
box_credits.add(
gtk.Label(
_('Sugarized by %(SUGARIZER)s') %
{'SUGARIZER': 'Marcos Orfila'}))
label_sugarizer_website = gtk.Label(
'<b>http://www.marcosorfila.com</b>')
label_sugarizer_website.set_use_markup(True)
box_credits.add(label_sugarizer_website)
box_credits.add(gtk.Label(""))
# Footer box (Activities on CeibalJAM! website)
box_footer = gtk.VBox(False, 0)
box_footer.add(gtk.Label(""))
box_footer.add(
gtk.Label(
_('Find more activities on %(CEIBALJAM)s website:') %
{'CEIBALJAM': 'CeibalJAM!'}))
label_ceibaljam_website = gtk.Label(
'<b>http://activities.ceibaljam.org</b>')
label_ceibaljam_website.set_use_markup(True)
box_footer.add(label_ceibaljam_website)
box_footer.add(gtk.Label(""))
# CeibalJAM! image
box_ceibaljam_image = gtk.VBox(False, 0)
image_ceibaljam = gtk.Image()
image_ceibaljam.set_from_file(self.ceibaljam_icon_path)
box_ceibaljam_image.pack_end(image_ceibaljam, False, False, 0)
# Buttons box
box_buttons = gtk.HBox(False, 0)
self.button_play = gtk.Button(_("Play"))
self.button_play.connect("clicked", self._button_play_clicked_cb)
self.button_exit = gtk.Button(_("Exit"))
self.button_exit.connect("clicked", self._button_exit_clicked_cb)
box_buttons.add(gtk.VBox())
box_buttons.add(self.button_play)
box_buttons.add(gtk.VBox())
box_buttons.add(self.button_exit)
box_buttons.add(gtk.VBox())
# Get all the boxes together
box_canvas.pack_start(box_title, False, False, 0)
box_canvas.pack_start(box_options, False, False, 0)
box_canvas.pack_end(gtk.Label("\n\n"), False, False, 0)
box_canvas.pack_end(box_buttons, False, False, 0)
box_canvas.pack_end(gtk.Label("\n"), False, False, 0)
box_canvas.pack_end(box_footer, False, False, 0)
box_canvas.pack_end(box_ceibaljam_image, False, False, 0)
box_canvas.pack_end(box_credits, False, False, 0)
box_canvas.pack_end(box_author, False, False, 0)
self.button_play.grab_focus()
self.show_all()
def __init__(self, handle):
Activity.__init__(self, handle)
self.create_load = False
self.play_mode = None
toolbox = ActivityToolbox(self)
activity_toolbar = toolbox.get_activity_toolbar()
self._memorizeToolbar = memorizetoolbar.MemorizeToolbar(self)
toolbox.add_toolbar(_('Play'), self._memorizeToolbar)
self._memorizeToolbar.show()
self._accessibility_toolbar = accessibilitytoolbar.AccessibilityToolbar(self)
toolbox.add_toolbar(_('Accessibility'), self._accessibility_toolbar)
self._accessibility_toolbar.show()
self._createToolbar = createtoolbar.CreateToolbar(self)
toolbox.add_toolbar(_('Create'), self._createToolbar)
self._createToolbar.show()
self.set_toolbox(toolbox)
toolbox.show()
# Play game mode
self.table = cardtable.CardTable()
self.scoreboard = scoreboard.Scoreboard()
self.game = game.MemorizeGame()
self.table.connect('key-press-event', self.table.key_press_event)
self.table.connect('card-flipped', self.game.card_flipped)
self.table.connect('card-overflipped', self.game.card_overflipped)
self.table.connect('card-highlighted', self.game.card_highlighted)
self.game.connect('set-border', self.table.set_border)
self.game.connect('flop-card', self.table.flop_card)
self.game.connect('flip-card', self.table.flip_card)
self.game.connect('cement-card', self.table.cement_card)
self.game.connect('highlight-card', self.table.highlight_card)
self.game.connect('load_mode', self.table.load_msg)
self.game.connect('msg_buddy', self.scoreboard.set_buddy_message)
self.game.connect('add_buddy', self.scoreboard.add_buddy)
self.game.connect('rem_buddy', self.scoreboard.rem_buddy)
self.game.connect('increase-score', self.scoreboard.increase_score)
self.game.connect('wait_mode_buddy', self.scoreboard.set_wait_mode)
self.game.connect('change-turn', self.scoreboard.set_selected)
self.game.connect('change_game', self.scoreboard.change_game)
self.game.connect('reset_scoreboard', self.scoreboard.reset)
self.game.connect('reset_table', self.table.reset)
self.game.connect('load_game', self.table.load_game)
self.game.connect('change_game', self.table.change_game)
self.game.connect('load_game', self._memorizeToolbar.update_toolbar)
self.game.connect('change_game', self._memorizeToolbar.update_toolbar)
self._memorizeToolbar.connect('game_changed', self.game.change_game)
self._accessibility_toolbar.connect('accessibility_changed', self.table.accessibility_changed)
self.hbox = gtk.HBox(False)
self.set_canvas(self.hbox)
# connect to the in/out events of the memorize activity
self.connect('focus_in_event', self._focus_in)
self.connect('focus_out_event', self._focus_out)
self.connect('destroy', self._cleanup_cb)
self.add_events(gtk.gdk.POINTER_MOTION_MASK)
self.connect('motion_notify_event',
lambda widget, event: face.look_at())
# start on the game toolbar, might change this
# to the create toolbar later
self.toolbox.connect('current-toolbar-changed', self.change_mode)
self.toolbox.set_current_toolbar(_TOOLBAR_PLAY)
# Get the Presence Service
self.pservice = presenceservice.get_instance()
self.initiating = None
# Buddy object for you
owner = self.pservice.get_owner()
self.owner = owner
self.current = 0
self.game.set_myself(self.owner)
self.connect('shared', self._shared_cb)
# Owner.props.key
if self._shared_activity:
# We are joining the activity
self.connect('joined', self._joined_cb)
if self.get_shared():
# We've already joined
self._joined_cb()
else:
_logger.debug('buddy joined - __init__: %s', self.owner.props.nick)
game_file = join(dirname(__file__), 'demos', 'addition.zip')
self.game.load_game(game_file, 4, 'demo')
_logger.debug('loading conventional')
self.game.add_buddy(self.owner)
self.show_all()
def __init__(self, handle):
# Initialize the parent
Activity.__init__(self, handle)
self.run()
self.close()
def __init__(self, handle):
# Initialize the parent
Activity.__init__(self, handle)
logger.debug('Initiating PlayGo')
self.size = DEFAULT_SIZE
self.komi = DEFAULT_KOMI
# Set the activity toolbox
toolbox = ActivityToolbox(self)
self.set_toolbox(toolbox)
self.gameToolbar = GameToolbar(self)
toolbox.add_toolbar(_('Game'), self.gameToolbar)
self.gameToolbar.connect('game-restart', self.restart_game)
self.gameToolbar.connect('game-board-size', self.board_size_change)
self.gameToolbar.connect('ai-activated', self.ai_activated_cb)
self.gameToolbar.connect('ai-deactivated', self.ai_deactivated_cb)
self.gameToolbar.show()
# Initialize the game
self.game = GoGame(self.size)
self.CurrentColor = 'B'
self.PlayerColor = 'B'
self.pass_count = 0
self.ai_activated = False
self.set_up_ui()
if not handle.object_id:
self.infopanel.show(_('Welcome to PlayGo!'))
else:
self.show_score()
self.lastX = -1
self.lastY = -1
# Set keypad actions
self._key_actions = {
'KP_Up' : 'move_up',
'KP_Right' : 'move_right',
'KP_Down' : 'move_down',
'KP_Left' : 'move_left',
'KP_Home' : 'place_stone',
'KP_Next' : 'undo',
'KP_End' : 'pass' }
self._key_grabber = KeyGrabber()
self._key_grabber.connect('key-pressed',
self._key_pressed_cb)
# New KeyGrabber API change (ticket #7999)
try:
self._key_grabber.grab_keys(self._key_actions.keys())
except:
for key in self._key_actions.keys():
self._key_grabber.grab(key)
#Set up collaboration
self.collaboration = CollaborationWrapper(self,
self.buddy_joined,
self.buddy_left,
self.Play,
self.game.undostack,
self.bootstrap)
self.connect('shared', self.collaboration._shared_cb)
if self._shared_activity:
# We are joining the activity
self.connect('joined', self.collaboration._joined_cb)
if self.get_shared():
# We've already joined
self.collaboration._joined_cb()
