def _get_buddy(self, cs_handle):
'''Get a Buddy from a (possibly channel-specific) handle.'''
# XXX This will be made redundant once Presence Service
# provides buddy resolution
# Get the Presence Service
pservice = presenceservice.get_instance()
# Get the Telepathy Connection
tp_name, tp_path = pservice.get_preferred_connection()
conn = TelepathyGLib.Connection.new(TelepathyGLib.DBusDaemon.dup(),
tp_name, tp_path)
group = self._text_chan[TelepathyGLib.IFACE_CHANNEL_INTERFACE_GROUP]
my_csh = group.GetSelfHandle()
if my_csh == cs_handle:
handle = conn.GetSelfHandle()
elif group.GetGroupFlags() & \
TelepathyGLib.ChannelGroupFlags.CHANNEL_SPECIFIC_HANDLES:
handle = group.GetHandleOwners([cs_handle])[0]
else:
handle = cs_handle
# XXX: deal with failure to get the handle owner
assert handle != 0
return pservice.get_buddy_by_telepathy_handle(tp_name, tp_path, handle)
def _get_buddy(self, cs_handle):
'''Get a Buddy from a (possibly channel-specific) handle.'''
# XXX This will be made redundant once Presence Service
# provides buddy resolution
# Get the Presence Service
pservice = presenceservice.get_instance()
# Get the Telepathy Connection
tp_name, tp_path = pservice.get_preferred_connection()
conn = Connection(tp_name, tp_path)
group = self._text_chan[CHANNEL_INTERFACE_GROUP]
my_csh = group.GetSelfHandle()
if my_csh == cs_handle:
handle = conn.GetSelfHandle()
elif (group.GetGroupFlags() &
CHANNEL_GROUP_FLAG_CHANNEL_SPECIFIC_HANDLES):
handle = group.GetHandleOwners([cs_handle])[0]
else:
handle = cs_handle
# XXX: deal with failure to get the handle owner
assert handle != 0
return pservice.get_buddy_by_telepathy_handle(
tp_name, tp_path, handle)
def __init__(self, handle):
Activity.__init__(self, handle)
# Self-Enforced max_participants
self.max_participants = SUGAR_MAX_PARTICIPANTS
# Prepare Storage Components
self.network_stack = None
self.gstreamer_stack = None
# Set Owner
self.owner = presenceservice.get_instance().get_owner()
""" Setup GUI """
logger.debug("Preparing GUI")
self.set_canvas(Gui(self))
""" Setup GSTStack """
logger.debug("Setting up GSTStack")
self.gststack = GSTStack()
self.get_canvas().set_gstreamer_stack(self.gststack);
""" Setup Network Stack """
logger.debug("Connect Event to Setup Network Stack on Demand")
self.establish_activity_sharing(handle)
def __init__(self, handle):
Activity.__init__(self, handle)
# Self-Enforced max_participants
self.max_participants = SUGAR_MAX_PARTICIPANTS
# Prepare Storage Components
self.network_stack = None
self.gstreamer_stack = None
# Set Owner
self.owner = presenceservice.get_instance().get_owner()
# Setup GUI
logger.debug("Preparing GUI")
self.set_canvas(Gui(self))
# Setup GStreamer Stack
logger.debug("Setting up GSTStack")
self.gststack = GSTStack()
self.get_canvas().set_gstreamer_stack(self.gststack);
# Setup Network Stack
logger.debug("Connect Event to Setup Network Stack on Demand")
self.establish_activity_sharing(handle)
def __init__(self, handle, *args, **kwargs):
'''
Initialize the ShareableActivity class.
Kwargs:
service_path
'''
activity.Activity.__init__(self, handle, *args, **kwargs)
self._sync_hid = None
self._message_cbs = {}
self._connection = None
self._tube_conn = None
self._pservice = presenceservice.get_instance()
self._owner = self._pservice.get_owner()
self._owner_id = str(self._owner.props.nick)
self._service_path = kwargs.get('service_path',
self._generate_service_path())
self._dbus_object = None
_logger.debug('Setting service name %s, service path %s',
IFACE, self._service_path)
self._connect_to_ps()
def _object_added_cb(self, cb_service, cb_object):
""" Code snippet to tag clipboard objects from shared activities """
shell = get_model()
logging.debug(shell.get_active_activity())
current = shell.get_active_activity()
active_id = current.get_activity_id()
logging.debug(active_id)
pservice = presenceservice.get_instance()
instance = pservice.get_activity(active_id, warn_if_none=False)
""" For a shared activity should have a pservice entry """
if instance is None:
return
logging.debug("cbobject path " + str(cb_object.get_id()))
if self._icons:
group = self._icons.values()[0]
else:
group = None
icon = ClipboardIcon(cb_object, group)
self.add_item(icon)
icon.show()
self._icons[cb_object.get_id()] = icon
objects_to_delete = self.get_children()[:-self.MAX_ITEMS]
for icon in objects_to_delete:
logging.debug('ClipboardTray: deleting surplus object')
cb_service = clipboard.get_instance()
cb_service.delete_object(icon.get_object_id())
logging.debug('ClipboardTray: %r was added', cb_object.get_id())
def __share_menu_cb(self, menu_item):
if self._account.url_cache is None:
pservice = presenceservice.get_instance()
if self._activity_id is not None:
logging.debug('getting shared activity from activity id')
self._shared_activity = pservice.get_activity(
self._activity_id, warn_if_none=False)
else:
logging.error('Cannot get activity from pservice.')
self.emit('transfer-state-changed',
_('Cannot join Journal Share activity'))
return
# We set up sharing in the same way as
# sugar-toolkit-gtk3/src/sugar3/activity/activity.py
# There's already an instance on the mesh, so join it
logging.debug('*** Act %s joining existing mesh instance %r',
self._activity_id, self._shared_activity)
self._join_id = self._shared_activity.connect('joined',
self.__joined_cb)
self._shared_activity.join()
else:
logging.debug('skipping join setup')
self.__joined_cb(self, True, '')
def __init__(self, buddy, file_name, title, description, mime_type):
presence_service = presenceservice.get_instance()
name, path = presence_service.get_preferred_connection()
connection = {}
conn_proxy = dbus.Bus().get_object(name, path)
connection[CONNECTION_INTERFACE_REQUESTS] = \
dbus.Interface(conn_proxy, CONNECTION_INTERFACE_REQUESTS)
BaseFileTransfer.__init__(self, connection)
self.connect('notify::state', self.__notify_state_cb)
self._service_name = name
self._file_name = file_name
self._socket_address = None
self._socket = None
self._splicer = None
self._output_stream = None
self.buddy = buddy
self.title = title
self.file_size = os.stat(file_name).st_size
self.description = description
self.mime_type = mime_type
self.__connection_ready_cb(connection)
def __share_menu_cb(self, menu_item):
if self._account.url_cache is None:
pservice = presenceservice.get_instance()
if self._activity_id is not None:
logging.debug('getting shared activity from activity id')
self._shared_activity = pservice.get_activity(
self._activity_id, warn_if_none=False)
else:
logging.error('Cannot get activity from pservice.')
self.emit('transfer-state-changed',
_('Cannot join Journal Share activity'))
return
# We set up sharing in the same way as
# sugar-toolkit-gtk3/src/sugar3/activity/activity.py
# There's already an instance on the mesh, so join it
logging.debug('*** Act %s joining existing mesh instance %r',
self._activity_id, self._shared_activity)
self._join_id = self._shared_activity.connect(
'joined', self.__joined_cb)
self._shared_activity.join()
else:
logging.debug('skipping join setup')
self.__joined_cb(self, True, '')
def __init__(self, handle):
activity.Activity.__init__(self, handle)
self.set_title("SocialCalc")
self._logger = logging.getLogger("OnePageWiki-Activity")
# The XOCom object helps us communicate with the browser
# This uses web/index.html as the default page to load
self.xocom = XOCom(
self.control_sending_text
) # REMEMBER THAT I HAVE STILL TO SEND THE ARGUMENT IN THE XOCOM CLASS
toolbox = ToolbarBox()
activity_button = ActivityButton(self)
toolbox.toolbar.insert(activity_button, 0)
activity_button.show()
title_entry = TitleEntry(self)
toolbox.toolbar.insert(title_entry, -1)
title_entry.show()
separator = Gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
toolbox.toolbar.insert(separator, -1)
separator.show()
stop_button = ShareButton(self)
toolbox.toolbar.insert(stop_button, -1)
stop_button.show()
self.set_toolbar_box(toolbox)
toolbox.show()
stop_button = StopButton(self)
toolbox.toolbar.insert(stop_button, -1)
stop_button.show()
self.set_toolbar_box(toolbox)
toolbox.show()
##self.xocom.send_to_browser_localize(['initlocalize'])
self.set_canvas(self.xocom.create_webview())
self.hellotube = None # Shared session #REQUIRED
self.initiating = False
self.pservice = presenceservice.get_instance()
owner = self.pservice.get_owner()
self.owner = owner
self.connect("shared", self._shared_cb)
self.connect("joined", self._joined_cb)
self.filename = "" # ADDED SPECIFICALLY TO CALL WRITE AND READ METHODS
self.content = ""
# calling to initialize strings in localization
# should wait for init complete from browser
GObject.timeout_add(4000, self.xocom.send_to_browser_localize, ["initlocalize"])
def __init__(self, handle, *args, **kwargs):
'''
Initialize the ShareableActivity class.
Kwargs:
service_path
'''
activity.Activity.__init__(self, handle, *args, **kwargs)
self._sync_hid = None
self._message_cbs = {}
self._connection = None
self._tube_conn = None
self._pservice = presenceservice.get_instance()
self._owner = self._pservice.get_owner()
self._owner_id = str(self._owner.props.nick)
self._service_path = kwargs.get('service_path',
self._generate_service_path())
self._dbus_object = None
_logger.debug('Setting service name %s, service path %s', IFACE,
self._service_path)
self._connect_to_ps()
def _get_buddy(self, cs_handle):
'''Get a Buddy from a (possibly channel-specific) handle.'''
# XXX This will be made redundant once Presence Service
# provides buddy resolution
# Get the Presence Service
pservice = presenceservice.get_instance()
# Get the Telepathy Connection
tp_name, tp_path = pservice.get_preferred_connection()
obj = dbus.Bus().get_object(tp_name, tp_path)
conn = dbus.Interface(obj, CONN_INTERFACE)
group = self._text_chan[CHANNEL_INTERFACE_GROUP]
my_csh = group.GetSelfHandle()
if my_csh == cs_handle:
handle = conn.GetSelfHandle()
elif group.GetGroupFlags() & \
CHANNEL_GROUP_FLAG_CHANNEL_SPECIFIC_HANDLES:
handle = group.GetHandleOwners([cs_handle])[0]
else:
handle = cs_handle
# XXX: deal with failure to get the handle owner
assert handle != 0
return pservice.get_buddy_by_telepathy_handle(tp_name, tp_path, handle)
def __init__(self, handle):
activity.Activity.__init__(self, handle)
self.set_title('SocialCalc')
self._logger = logging.getLogger('OnePageWiki-Activity')
# The XOCom object helps us communicate with the browser
# This uses web/index.html as the default page to load
self.xocom = XOCom(self.control_sending_text) #REMEMBER THAT I HAVE STILL TO SEND THE ARGUMENT IN THE XOCOM CLASS
toolbox = ToolbarBox()
activity_button = ActivityButton(self)
toolbox.toolbar.insert(activity_button, 0)
activity_button.show()
title_entry = TitleEntry(self)
toolbox.toolbar.insert(title_entry, -1)
title_entry.show()
separator = Gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
toolbox.toolbar.insert(separator, -1)
separator.show()
stop_button = ShareButton(self)
toolbox.toolbar.insert(stop_button, -1)
stop_button.show()
self.set_toolbar_box(toolbox)
toolbox.show()
stop_button = StopButton(self)
toolbox.toolbar.insert(stop_button, -1)
stop_button.show()
self.set_toolbar_box(toolbox)
toolbox.show()
##self.xocom.send_to_browser_localize(['initlocalize'])
self.set_canvas( self.xocom.create_webview() )
self.hellotube = None # Shared session #REQUIRED
self.initiating = False
self.pservice = presenceservice.get_instance()
owner = self.pservice.get_owner()
self.owner = owner
self.connect('shared', self._shared_cb)
self.connect('joined', self._joined_cb)
self.filename='' #ADDED SPECIFICALLY TO CALL WRITE AND READ METHODS
self.content=''
#calling to initialize strings in localization
#should wait for init complete from browser
GObject.timeout_add(4000, self.xocom.send_to_browser_localize,['initlocalize'])
def _setup_presence_service(self):
''' Setup the Presence Service. '''
self.pservice = presenceservice.get_instance()
owner = self.pservice.get_owner()
self.owner = owner
self._share = ''
self.connect('shared', self._shared_cb)
self.connect('joined', self._joined_cb)
def _setup_presence_service(self):
''' Setup the Presence Service. '''
self.pservice = presenceservice.get_instance()
owner = self.pservice.get_owner()
self.owner = owner
self._share = ''
self.connect('shared', self._shared_cb)
self.connect('joined', self._joined_cb)
def __init__(self, activity):
_logger.debug('__init__')
GObject.GObject.__init__(self)
self.activity = activity
self.shared_activity = activity.shared_activity
self._leader = False
self._init_waiting = False
self._text_channel = None
self._owner = presenceservice.get_instance().get_owner()
def _setup_presence_service(self):
""" Setup the Presence Service. """
self.pservice = presenceservice.get_instance()
self.initiating = None # sharing (True) or joining (False)
owner = self.pservice.get_owner()
self.owner = owner
self._share = ""
self.connect('shared', self._shared_cb)
self.connect('joined', self._joined_cb)
def _send_invites(self):
while self._invites_queue:
account_path, contact_id = self._invites_queue.pop()
pservice = presenceservice.get_instance()
buddy = pservice.get_buddy(account_path, contact_id)
if buddy:
self.shared_activity.invite(
buddy, '', self._invite_response_cb)
else:
logging.error('Cannot invite %s %s, no such buddy',
account_path, contact_id)
def __init__(self, activity, buddy_joined_cb, buddy_left_cb, play_cb, undostack, bootstrap):
self.activity = activity
self.buddy_joined = buddy_joined_cb
self.buddy_left = buddy_left_cb
self.Play_cb = play_cb
self.undostack = undostack
self.bootstrap = bootstrap
self.world = False
self.entered = False
self.presence_service = presenceservice.get_instance()
self.owner = self.presence_service.get_owner()
def _send_invites(self):
while self._invites_queue:
account_path, contact_id = self._invites_queue.pop()
pservice = presenceservice.get_instance()
buddy = pservice.get_buddy(account_path, contact_id)
if buddy:
self.shared_activity.invite(buddy, '',
self._invite_response_cb)
else:
logging.error('Cannot invite %s %s, no such buddy',
account_path, contact_id)
def _setup_presence_service(self):
''' Setup the Presence Service. '''
self.pservice = presenceservice.get_instance()
self.initiating = None # sharing (True) or joining (False)
owner = self.pservice.get_owner()
self.owner = owner
self.vmw.buddies.append(self.owner)
self._share = ''
self.connect('shared', self._shared_cb)
self.connect('joined', self._joined_cb)
def add_buddy(self, buddy):
"""
Passes buddy nick to ovc
"""
if buddy == presenceservice.get_instance().get_owner():
return
if buddy:
nick = buddy.props.nick
else:
nick = '???'
self.activity.net_cb('buddy_add', nick)
def setup(self):
# TODO: hand off role of master if sharer leaves
self.pservice = presenceservice.get_instance()
self.initiating = None # sharing (True) or joining (False)
# Add my buddy object to the list
owner = self.pservice.get_owner()
self.owner = owner
self._tw.buddies.append(self.owner)
self._share = ''
self._activity.connect('shared', self._shared_cb)
self._activity.connect('joined', self._joined_cb)
def setup(self):
# TODO: hand off role of master if sharer leaves
self.pservice = presenceservice.get_instance()
self.initiating = None # sharing (True) or joining (False)
# Add my buddy object to the list
owner = self.pservice.get_owner()
self.owner = owner
self._tw.buddies.append(self.owner)
self._share = ''
self._activity.connect('shared', self._shared_cb)
self._activity.connect('joined', self._joined_cb)
def _setup_presence_service(self):
""" Setup the Presence Service. """
self.pservice = presenceservice.get_instance()
self.initiating = None # sharing (True) or joining (False)
owner = self.pservice.get_owner()
self.owner = owner
self._game.buddies.append(self.nick)
self._player_colors = [self.colors]
self._player_pixbuf = [svg_str_to_pixbuf(
generate_xo(scale=0.8, colors=self.colors))]
self._share = ""
self.connect('shared', self._shared_cb)
self.connect('joined', self._joined_cb)
def init_context(self, args):
"""Init Javascript context sending buddy information"""
# Get XO colors
buddy = {}
client = gconf.client_get_default()
colors = client.get_string("/desktop/sugar/user/color")
buddy["colors"] = colors.split(",")
# Get XO name
presenceService = presenceservice.get_instance()
buddy["name"] = presenceService.get_owner().props.nick
self.enyo.send_message("buddy", buddy)
if self.context != {}:
self.enyo.send_message("load-context", self.context)
def _setup_sharing(self):
''' Setup the Presence Service. '''
self.pservice = presenceservice.get_instance()
self.initiating = None # sharing (True) or joining (False)
owner = self.pservice.get_owner()
self.owner = owner
self._bounce_window.buddies.append(self.nick)
self._player_colors = [self._colors]
self._player_pixbufs = [
svg_str_to_pixbuf(generate_xo_svg(scale=0.8, colors=self._colors))
]
self._share = ''
self.connect('shared', self._shared_cb)
self.connect('joined', self._joined_cb)
def init_context(self, args):
"""Init Javascript context sending buddy information"""
# Get XO colors
buddy = {}
client = gconf.client_get_default()
colors = client.get_string("/desktop/sugar/user/color")
buddy["colors"] = colors.split(",")
# Get XO name
presenceService = presenceservice.get_instance()
buddy["name"] = presenceService.get_owner().props.nick
self.enyo.send_message("buddy", buddy)
if self.context != {}:
self.enyo.send_message("load-context", self.context)
def __init__(self):
Gtk.VBox.__init__(self)
self.messenger = None
self.me = None
self.quiet = False
self._buddies = {}
# chat entry
owner = presenceservice.get_instance().get_owner()
self._chat = ChatBox(owner, _is_tablet_mode())
self._chat.connect('open-on-journal', self.__open_on_journal)
self.me = self._new_face(owner, ENTRY_COLOR)
# add owner to buddy list
self._buddies[owner] = self.me
# buddies box
self._buddies_box = Gtk.HBox()
self._buddies_box.pack_end(self.me, True, True, 0)
self._buddies_sw = Gtk.ScrolledWindow()
self._buddies_sw.set_policy(Gtk.PolicyType.AUTOMATIC,
Gtk.PolicyType.NEVER)
self._buddies_sw.add_with_viewport(self._buddies_box)
self.chat_post = Gtk.Entry()
self.chat_post.modify_font(Pango.FontDescription('sans bold 24'))
self.chat_post.connect('activate', self._activate_cb)
self.chat_post.connect('key-press-event', self._key_press_cb)
self._entry = Gtk.HBox()
self._entry.pack_start(self._buddies_sw, False, False, 0)
self._entry.pack_start(self.chat_post, True, True, 0)
if _is_tablet_mode():
self.pack_start(self._entry, False, False, 0)
self.pack_end(self._chat, True, True, 0)
else:
self.pack_start(self._chat, True, True, 0)
self.pack_end(self._entry, False, False, 0)
self.resize_chat_box(expanded=False)
self.show_all()
def __map_event_cb(self, event, activity):
logger.debug('__map_event_cb')
# set custom keybindings for Write
logger.debug("Loading keybindings")
keybindings_file = os.path.join( get_bundle_path(), "keybindings.xml" )
self.abiword_canvas.invoke_ex(
'com.abisource.abiword.loadbindings.fromURI',
keybindings_file, 0, 0)
# no ugly borders please
##self.abiword_canvas.set_property("shadow-type", gtk.SHADOW_NONE)
# we only do per-word selections (when using the mouse)
self.abiword_canvas.set_word_selections(True)
# we want a nice border so we can select paragraphs easily
self.abiword_canvas.set_show_margin(True)
# activity sharing
self.participants = {}
pservice = presenceservice.get_instance()
bus = dbus.Bus()
name, path = pservice.get_preferred_connection()
self.conn = telepathy.client.Connection(name, path)
self.initiating = None
self.joined = False
self.connect('shared', self._shared_cb)
self._shared_activity = self.get_shared_activity()
if self._shared_activity:
# we are joining the activity
logger.debug("We are joining an activity")
self.connect('joined', self._joined_cb)
self._shared_activity.connect('buddy-joined', self._buddy_joined_cb)
self._shared_activity.connect('buddy-left', self._buddy_left_cb)
if self.get_shared():
# # oh, OK, we've already joined
self._joined_cb()
else:
# we are creating the activity
logger.debug("We are creating an activity")
owner = pservice.get_owner()
def __init__(self):
Gtk.VBox.__init__(self)
self.messenger = None
self.me = None
self.quiet = False
self._buddies = {}
# chat entry
owner = presenceservice.get_instance().get_owner()
self._chat = ChatBox(owner, _is_tablet_mode())
self._chat.connect('open-on-journal', self.__open_on_journal)
self.me = self._new_face(owner, ENTRY_COLOR)
# add owner to buddy list
self._buddies[owner] = self.me
# buddies box
self._buddies_box = Gtk.HBox()
self._buddies_box.pack_end(self.me, True, True, 0)
self._buddies_sw = Gtk.ScrolledWindow()
self._buddies_sw.set_policy(Gtk.PolicyType.AUTOMATIC,
Gtk.PolicyType.NEVER)
self._buddies_sw.add_with_viewport(self._buddies_box)
self.chat_post = Gtk.Entry()
self.chat_post.modify_font(Pango.FontDescription('sans bold 24'))
self.chat_post.connect('activate', self._activate_cb)
self.chat_post.connect('key-press-event', self._key_press_cb)
self._entry = Gtk.HBox()
self._entry.pack_start(self._buddies_sw, False, False, 0)
self._entry.pack_start(self.chat_post, True, True, 0)
if _is_tablet_mode():
self.pack_start(self._entry, False, False, 0)
self.pack_end(self._chat, True, True, 0)
else:
self.pack_start(self._chat, True, True, 0)
self.pack_end(self._entry, False, False, 0)
self.resize_chat_box(expanded=False)
self.show_all()
def __init__(self, handle):
activity.Activity.__init__(self, handle)
self.max_participants = 10
# toolbar with the new toolbar redesign
toolbar_box = ToolbarBox()
activity_button = ActivityToolbarButton(self)
toolbar_box.toolbar.insert(activity_button, 0)
activity_button.show()
self.back_button = BackButton()
self.back_button.connect('clicked', self.show_options1)
toolbar_box.toolbar.insert(self.back_button, -1)
self.back_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)
toolbar_box.show()
self.show_options()
self._logger = logging.getLogger('hellomesh-activity')
self.hellotube = 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):
activity.Activity.__init__(self, handle)
self.max_participants = 10
# toolbar with the new toolbar redesign
toolbar_box = ToolbarBox()
activity_button = ActivityToolbarButton(self)
toolbar_box.toolbar.insert(activity_button, 0)
activity_button.show()
self.back_button = BackButton()
self.back_button.connect('clicked', self.show_options1)
toolbar_box.toolbar.insert(self.back_button, -1)
self.back_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)
toolbar_box.show()
self.show_options()
self._logger = logging.getLogger('hellomesh-activity')
self.hellotube = 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 share(self, private=False):
"""Request that the activity be shared on the network.
private -- bool: True to share by invitation only,
False to advertise as shared to everyone.
Once the activity is shared, its privacy can be changed by setting
its 'private' property.
"""
if self.shared_activity and self.shared_activity.props.joined:
raise RuntimeError('Activity %s already shared.' %
self._activity_id)
verb = private and 'private' or 'public'
logging.debug('Requesting %s share of activity %s.' % (verb,
self._activity_id))
pservice = presenceservice.get_instance()
pservice.connect('activity-shared', self.__share_cb)
pservice.share_activity(self, private=private)
def __init__(self, activity, deck, work_path):
GObject.GObject.__init__(self)
self.__activity = activity
self.__deck = deck
self.__logger = logging.getLogger('Shared')
self.__is_initiating = True # defaults to instructor
self.__shared_slides = None
self.__got_dbus_tube = False
self.__locked = False
self.__pservice = presenceservice.get_instance()
#self.__owner = self.__pservice.get_owner()
self.__cpxo_path = os.path.join(work_path, 'deck.cpxo')
self.__activity.connect('shared', self.shared_cb)
self.__activity.connect('joined', self.joined_cb)
def __got_channel_cb(self, wait_loop, connection_path, channel_path,
handle_type):
logging.debug('Activity.__got_channel_cb')
pservice = presenceservice.get_instance()
if handle_type == CONNECTION_HANDLE_TYPE_ROOM:
connection_name = connection_path.replace('/', '.')[1:]
bus = dbus.SessionBus()
channel = bus.get_object(connection_name, channel_path)
room_handle = channel.Get(CHANNEL, 'TargetHandle')
mesh_instance = pservice.get_activity_by_handle(
connection_path, room_handle)
else:
mesh_instance = pservice.get_activity(self._activity_id,
warn_if_none=False)
self._set_up_sharing(mesh_instance, SCOPE_PRIVATE)
wait_loop.quit()
def __got_channel_cb(self, wait_loop, connection_path, channel_path,
handle_type):
logging.debug('Activity.__got_channel_cb')
pservice = presenceservice.get_instance()
if handle_type == CONNECTION_HANDLE_TYPE_ROOM:
connection_name = connection_path.replace('/', '.')[1:]
bus = dbus.SessionBus()
channel = bus.get_object(connection_name, channel_path)
room_handle = channel.Get(CHANNEL, 'TargetHandle')
mesh_instance = pservice.get_activity_by_handle(connection_path,
room_handle)
else:
mesh_instance = pservice.get_activity(self._activity_id,
warn_if_none=False)
self._set_up_sharing(mesh_instance, SCOPE_PRIVATE)
wait_loop.quit()
def share(self, private=False):
"""Request that the activity be shared on the network.
private -- bool: True to share by invitation only,
False to advertise as shared to everyone.
Once the activity is shared, its privacy can be changed by setting
its 'private' property.
"""
if self.shared_activity and self.shared_activity.props.joined:
raise RuntimeError('Activity %s already shared.' %
self._activity_id)
verb = private and 'private' or 'public'
logging.debug('Requesting %s share of activity %s.', verb,
self._activity_id)
pservice = presenceservice.get_instance()
pservice.connect('activity-shared', self.__share_cb)
pservice.share_activity(self, private=private)
def __init__(self, cactivity):
self._activity = cactivity
self.is_active = False
self.left = self._create_left_panel()
self.right = self._create_right_panel()
self.text_channel = None
self.fixed = Gtk.Fixed()
#self.button = BulletinButton()
#self.button.connect("clicked", self._toggle)
self.button = ToolbarButton()
self.button.connect("clicked", self._toggle)
self.button.props.icon_name = 'computer-xo'
self.toolbar = BulletinToolbar()
self.button.props.page = self.toolbar
self.toolbar.toolitems.entry.connect('activate', self.entry_activate_cb)
#self.share_button = ShareButton(self._activity)
#self.share_button.private.props.active = False
pserv = presenceservice.get_instance()
self.owner = pserv.get_owner()
# If any shared activity exists
if self._activity.shared_activity:
self._activity.connect('joined', self._joined_cb) # joining an activity
if self._activity.get_shared(): # already joined the activity
self._joined_cb(self._activity)
else:
if not self._activity.metadata or (self._activity.metadata.get('share-scope',
activity.SCOPE_PRIVATE) == activity.SCOPE_PRIVATE):
self._alert(_('Off-line'), _('Share, or invite someone.'))
self._activity.connect('shared', self._shared_cb)
def __init__(self, tube_class, service):
"""Set up the tubes for this activity."""
self.tube_class = tube_class
self.service = service
self.pservice = presenceservice.get_instance()
#bus = dbus.Bus()
name, path = self.pservice.get_preferred_connection() or (None, None)
self.tp_conn_name = name
self.tp_conn_path = path
self.game_tube = False
self.initiating = None
# 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, buddy, file_name, title, description, mime_type):
presence_service = presenceservice.get_instance()
name, path = presence_service.get_preferred_connection()
connection = Connection(name, path, ready_handler=self.__connection_ready_cb)
BaseFileTransfer.__init__(self, connection)
self.connect("notify::state", self.__notify_state_cb)
self._file_name = file_name
self._socket_address = None
self._socket = None
self._splicer = None
self._output_stream = None
self.buddy = buddy
self.title = title
self.file_size = os.stat(file_name).st_size
self.description = description
self.mime_type = mime_type
def __init__(self, buddy, file_name, title, description, mime_type):
presence_service = presenceservice.get_instance()
name, path = presence_service.get_preferred_connection()
connection = Connection(name, path,
ready_handler=self.__connection_ready_cb)
BaseFileTransfer.__init__(self, connection)
self.connect('notify::state', self.__notify_state_cb)
self._file_name = file_name
self._socket_address = None
self._socket = None
self._splicer = None
self._output_stream = None
self.buddy = buddy
self.title = title
self.file_size = os.stat(file_name).st_size
self.description = description
self.mime_type = mime_type
def __init__(self, tube_class, service):
"""Set up the tubes for this activity."""
self.tube_class = tube_class
self.service = service
self.pservice = presenceservice.get_instance()
#bus = dbus.Bus()
name, path = self.pservice.get_preferred_connection() or (None, None)
self.tp_conn_name = name
self.tp_conn_path = path
#self.conn = telepathy.client.Connection(name, path)
self.game_tube = False
self.initiating = None
# 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 get_buddy(self, cs_handle):
"""Retrieve a Buddy object given a telepathy handle.
cs_handle: A channel-specific CONTACT type handle.
returns: sugar3.presence Buddy object or None
"""
pservice = presenceservice.get_instance()
if self.self_handle == cs_handle:
# It's me, just get my global handle
handle = self._conn.GetSelfHandle()
elif self._group_iface.GetGroupFlags() & \
CHANNEL_GROUP_FLAG_CHANNEL_SPECIFIC_HANDLES:
# The group (channel) has channel specific handles
handle = self._group_iface.GetHandleOwners([cs_handle])[0]
else:
# The group does not have channel specific handles
handle = cs_handle
# deal with failure to get the handle owner
if handle == 0:
return None
return pservice.get_buddy_by_telepathy_handle(
self._conn.service_name, self._conn.object_path, handle)
def get_buddy(self, cs_handle):
"""Retrieve a Buddy object given a telepathy handle.
cs_handle: A channel-specific CONTACT type handle.
returns: sugar3.presence Buddy object or None
"""
pservice = presenceservice.get_instance()
if self.self_handle == cs_handle:
# It's me, just get my global handle
handle = self._conn.GetSelfHandle()
elif self._group_iface.GetGroupFlags() & \
CHANNEL_GROUP_FLAG_CHANNEL_SPECIFIC_HANDLES:
# The group (channel) has channel specific handles
handle = self._group_iface.GetHandleOwners([cs_handle])[0]
else:
# The group does not have channel specific handles
handle = cs_handle
# deal with failure to get the handle owner
if handle == 0:
return None
return pservice.get_buddy_by_telepathy_handle(self._conn.service_name,
self._conn.object_path,
handle)
def __init__(self, handle):
# self.initiating indicates whether this instance has initiated sharing
# it always starts false, but will be set to true if this activity
# initiates sharing. In particular, if Activity.__init__ calls
# self.share(), self.initiating will be set to True.
self.initiating = False
# self._processed_share indicates whether when_shared() has been called
self._processed_share = False
# self.initialized tracks whether the Activity's display is up and running
self.initialized = False
self.early_setup()
super(GroupActivity, self).__init__(handle)
self.dbus_name = self.get_bundle_id()
self.logger = logging.getLogger(self.dbus_name)
self._handle = handle
##GObject.threads_init()
self._sharing_completed = not self.shared_activity
self._readfile_completed = not handle.object_id
if self.shared_activity:
self.message = self.message_joining
elif handle.object_id:
self.message = self.message_loading
else:
self.message = self.message_preparing
toolbar_box = ToolbarBox()
self.activity_button = ActivityToolbarButton(self)
toolbar_box.toolbar.insert(self.activity_button, 0)
self.set_toolbar_box(toolbar_box)
v = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
self.startup_label = Gtk.Label(label=self.message)
v.pack_start(self.startup_label, True, True, 0)
Window.set_canvas(self,v)
self.show_all()
# The show_all method queues up draw events, but they aren't executed
# until the mainloop has a chance to process them. We want to process
# them immediately, because we need to show the waiting screen
# before the waiting starts, not after.
exhaust_event_loop()
# exhaust_event_loop() provides the possibility that write_file could
# be called at this time, so write_file is designed to trigger read_file
# itself if that path occurs.
self.tubebox = groupthink.TubeBox()
self.timer = groupthink.TimeHandler("main", self.tubebox)
self.cloud = groupthink.Group(self.tubebox)
# self.cloud is extremely important. It is the unified reference point
# that contains all state in the system. Everything else is stateless.
# self.cloud has to be defined before the call to self.set_canvas, because
# set_canvas can trigger almost anything, including pending calls to read_file,
# which relies on self.cloud.
# 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)
if self.get_shared():
if self.initiating:
self._shared_cb(self)
else:
self._joined_cb(self)
self.add_events(Gdk.EventMask.VISIBILITY_NOTIFY_MASK)
self.connect("visibility-notify-event", self._visible_cb)
self.connect("notify::active", self._active_cb)
if not self._readfile_completed:
self.read_file(self._jobject.file_path)
elif not self.shared_activity:
GObject.idle_add(self._initialize_cleanstart)
def __init__(self, handle, create_jobject=True):
"""Initialise the Activity
handle -- sugar3.activity.activityhandle.ActivityHandle
instance providing the activity id and access to the
presence service which *may* provide sharing for this
application
create_jobject -- boolean
define if it should create a journal object if we are
not resuming
Side effects:
Sets the gdk screen DPI setting (resolution) to the
Sugar screen resolution.
Connects our "destroy" message to our _destroy_cb
method.
Creates a base Gtk.Window within this window.
Creates an ActivityService (self._bus) servicing
this application.
Usage:
If your Activity implements __init__(), it should call
the base class __init()__ before doing Activity specific things.
"""
# Stuff that needs to be done early
icons_path = os.path.join(get_bundle_path(), 'icons')
Gtk.IconTheme.get_default().append_search_path(icons_path)
sugar_theme = 'sugar-72'
if 'SUGAR_SCALING' in os.environ:
if os.environ['SUGAR_SCALING'] == '100':
sugar_theme = 'sugar-100'
# This code can be removed when we grow an xsettings daemon (the GTK+
# init routines will then automatically figure out the font settings)
settings = Gtk.Settings.get_default()
settings.set_property('gtk-theme-name', sugar_theme)
settings.set_property('gtk-icon-theme-name', 'sugar')
settings.set_property('gtk-font-name',
'%s %f' % (style.FONT_FACE, style.FONT_SIZE))
Window.__init__(self)
if 'SUGAR_ACTIVITY_ROOT' in os.environ:
# If this activity runs inside Sugar, we want it to take all the
# screen. Would be better if it was the shell to do this, but we
# haven't found yet a good way to do it there. See #1263.
self.connect('window-state-event', self.__window_state_event_cb)
screen = Gdk.Screen.get_default()
screen.connect('size-changed', self.__screen_size_changed_cb)
self._adapt_window_to_screen()
# process titles will only show 15 characters
# but they get truncated anyway so if more characters
# are supported in the future we will get a better view
# of the processes
proc_title = '%s <%s>' % (get_bundle_name(), handle.activity_id)
util.set_proc_title(proc_title)
self.connect('realize', self.__realize_cb)
self.connect('delete-event', self.__delete_event_cb)
self._active = False
self._activity_id = handle.activity_id
self.shared_activity = None
self._join_id = None
self._updating_jobject = False
self._closing = False
self._quit_requested = False
self._deleting = False
self._max_participants = 0
self._invites_queue = []
self._jobject = None
self._read_file_called = False
self._session = _get_session()
self._session.register(self)
self._session.connect('quit-requested',
self.__session_quit_requested_cb)
self._session.connect('quit', self.__session_quit_cb)
accel_group = Gtk.AccelGroup()
self.sugar_accel_group = accel_group
self.add_accel_group(accel_group)
self._bus = ActivityService(self)
self._owns_file = False
share_scope = SCOPE_PRIVATE
if handle.object_id:
self._jobject = datastore.get(handle.object_id)
if 'share-scope' in self._jobject.metadata:
share_scope = self._jobject.metadata['share-scope']
if 'launch-times' in self._jobject.metadata:
self._jobject.metadata['launch-times'] += ', %d' % \
int(time.time())
else:
self._jobject.metadata['launch-times'] = \
str(int(time.time()))
self.shared_activity = None
self._join_id = None
if handle.object_id is None and create_jobject:
logging.debug('Creating a jobject.')
self._jobject = self._initialize_journal_object()
if handle.invited:
wait_loop = GObject.MainLoop()
self._client_handler = _ClientHandler(
self.get_bundle_id(), partial(self.__got_channel_cb,
wait_loop))
# FIXME: The current API requires that self.shared_activity is set
# before exiting from __init__, so we wait until we have got the
# shared activity. http://bugs.sugarlabs.org/ticket/2168
wait_loop.run()
else:
pservice = presenceservice.get_instance()
mesh_instance = pservice.get_activity(self._activity_id,
warn_if_none=False)
self._set_up_sharing(mesh_instance, share_scope)
if not create_jobject:
self.set_title(get_bundle_name())
return
if self.shared_activity is not None:
self._jobject.metadata['title'] = self.shared_activity.props.name
self._jobject.metadata['icon-color'] = \
self.shared_activity.props.color
else:
self._jobject.metadata.connect('updated',
self.__jobject_updated_cb)
self.set_title(self._jobject.metadata['title'])
def __init__(self, handle):
activity.Activity.__init__(self, handle)
_logger.debug('Starting the web activity')
session = WebKit.get_default_session()
session.set_property('accept-language-auto', True)
session.set_property('ssl-use-system-ca-file', True)
session.set_property('ssl-strict', False)
# By default, cookies are not stored persistently, we have to
# add a cookie jar so that they get saved to disk. We use one
# with a SQlite database:
cookie_jar = SoupGNOME.CookieJarSqlite(filename=_cookies_db_path,
read_only=False)
session.add_feature(cookie_jar)
_seed_xs_cookie(cookie_jar)
# FIXME
# downloadmanager.remove_old_parts()
self._force_close = False
self._tabbed_view = TabbedView()
self._tabbed_view.connect('focus-url-entry', self._on_focus_url_entry)
self._tabbed_view.connect('switch-page', self.__switch_page_cb)
self._tray = HTray()
self.set_tray(self._tray, Gtk.PositionType.BOTTOM)
self._primary_toolbar = PrimaryToolbar(self._tabbed_view, self)
self._edit_toolbar = EditToolbar(self)
self._view_toolbar = ViewToolbar(self)
self._primary_toolbar.connect('add-link', self._link_add_button_cb)
self._primary_toolbar.connect('go-home', self._go_home_button_cb)
self._primary_toolbar.connect('go-library', self._go_library_button_cb)
self._primary_toolbar.connect('set-home', self._set_home_button_cb)
self._primary_toolbar.connect('reset-home', self._reset_home_button_cb)
self._edit_toolbar_button = ToolbarButton(
page=self._edit_toolbar, icon_name='toolbar-edit')
self._primary_toolbar.toolbar.insert(
self._edit_toolbar_button, 1)
view_toolbar_button = ToolbarButton(
page=self._view_toolbar, icon_name='toolbar-view')
self._primary_toolbar.toolbar.insert(
view_toolbar_button, 2)
self._primary_toolbar.show_all()
self.set_toolbar_box(self._primary_toolbar)
self.set_canvas(self._tabbed_view)
self._tabbed_view.show()
self.model = Model()
self.model.connect('add_link', self._add_link_model_cb)
self.connect('key-press-event', self._key_press_cb)
if handle.uri:
self._tabbed_view.current_browser.load_uri(handle.uri)
elif not self._jobject.file_path:
# TODO: we need this hack until we extend the activity API for
# opening URIs and default docs.
self._tabbed_view.load_homepage()
self.messenger = None
self.connect('shared', self._shared_cb)
# Get the Presence Service
self.pservice = presenceservice.get_instance()
try:
name, path = self.pservice.get_preferred_connection()
self.tp_conn_name = name
self.tp_conn_path = path
self.conn = telepathy.client.Connection(name, path)
except TypeError:
_logger.debug('Offline')
self.initiating = None
if self.get_shared_activity() is not None:
_logger.debug('shared: %s', self.get_shared())
# We are joining the activity
_logger.debug('Joined activity')
self.connect('joined', self._joined_cb)
if self.get_shared():
# We've already joined
self._joined_cb()
else:
_logger.debug('Created activity')
# README: this is a workaround to remove old temp file
# http://bugs.sugarlabs.org/ticket/3973
self._cleanup_temp_files()
def __init__(self, handle):
pservice = presenceservice.get_instance()
self.owner = pservice.get_owner()
self._ebook_mode_detector = EbookModeDetector()
self.chatbox = ChatBox(
self.owner, self._ebook_mode_detector.get_ebook_mode())
self.chatbox.connect('open-on-journal', self.__open_on_journal)
super(Chat, self).__init__(handle)
self._entry = None
self._has_alert = False
self._has_osk = False
self._setup_canvas()
self._entry.grab_focus()
toolbar_box = ToolbarBox()
self.set_toolbar_box(toolbar_box)
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()
description_item = DescriptionItem(self)
toolbar_box.toolbar.insert(description_item, -1)
description_item.show()
self._share_button = ShareButton(self)
toolbar_box.toolbar.insert(self._share_button, -1)
self._share_button.show()
separator = Gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
toolbar_box.toolbar.insert(separator, -1)
toolbar_box.toolbar.insert(StopButton(self), -1)
toolbar_box.show_all()
# Chat is room or one to one:
self._chat_is_room = False
self.text_channel = None
if _HAS_SOUND:
self.element = Gst.ElementFactory.make('playbin', 'Player')
if self.shared_activity:
# we are joining the activity following an invite
self._entry.props.placeholder_text = \
_('Please wait for a connection before starting to chat.')
self.connect('joined', self._joined_cb)
if self.get_shared():
# we have already joined
self._joined_cb(self)
elif handle.uri:
# XMPP non-sugar3 incoming chat, not sharable
self._share_button.props.visible = False
self._one_to_one_connection(handle.uri)
else:
# we are creating the activity
if not self.metadata or self.metadata.get(
'share-scope', activity.SCOPE_PRIVATE) == \
activity.SCOPE_PRIVATE:
# if we are in private session
self._alert(_('Off-line'), _('Share, or invite someone.'))
else:
# resume of shared activity from journal object without invite
self._entry.props.placeholder_text = \
_('Please wait for a connection before starting to chat.')
self.connect('shared', self._shared_cb)
def __init__(self, handle):
pservice = presenceservice.get_instance()
self.owner = pservice.get_owner()
self._ebook_mode_detector = EbookModeDetector()
self.chatbox = ChatBox(self.owner,
self._ebook_mode_detector.get_ebook_mode())
self.chatbox.connect('open-on-journal', self.__open_on_journal)
self.chatbox.connect('new-message',
self._search_entry_on_new_message_cb)
super(Chat, self).__init__(handle)
self._entry = None
self._has_alert = False
self._has_osk = False
self._setup_canvas()
self._entry.grab_focus()
toolbar_box = ToolbarBox()
self.set_toolbar_box(toolbar_box)
self._activity_toolbar_button = ActivityToolbarButton(self)
self._activity_toolbar_button.connect('clicked', self._fixed_resize_cb)
toolbar_box.toolbar.insert(self._activity_toolbar_button, 0)
self._activity_toolbar_button.show()
self.search_entry = iconentry.IconEntry()
self.search_entry.set_size_request(Gdk.Screen.width() / 3, -1)
self.search_entry.set_icon_from_name(iconentry.ICON_ENTRY_PRIMARY,
'entry-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_activate_cb)
self.connect('key-press-event', self._search_entry_key_press_cb)
self._search_item = Gtk.ToolItem()
self._search_item.add(self.search_entry)
toolbar_box.toolbar.insert(self._search_item, -1)
self._search_prev = ToolButton('go-previous-paired')
self._search_prev.set_tooltip(_('Previous'))
self._search_prev.props.accelerator = "<Shift><Ctrl>g"
self._search_prev.connect('clicked', self._search_prev_cb)
self._search_prev.props.sensitive = False
toolbar_box.toolbar.insert(self._search_prev, -1)
self._search_next = ToolButton('go-next-paired')
self._search_next.set_tooltip(_('Next'))
self._search_next.props.accelerator = "<Ctrl>g"
self._search_next.connect('clicked', self._search_next_cb)
self._search_next.props.sensitive = False
toolbar_box.toolbar.insert(self._search_next, -1)
separator = Gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
toolbar_box.toolbar.insert(separator, -1)
toolbar_box.toolbar.insert(StopButton(self), -1)
toolbar_box.show_all()
# Chat is room or one to one:
self._chat_is_room = False
self.text_channel = None
if _HAS_SOUND:
self.element = Gst.ElementFactory.make('playbin', 'Player')
if self.shared_activity:
# we are joining the activity following an invite
self._alert(_('Off-line'), _('Joining the Chat.'))
self._entry.props.placeholder_text = \
_('Please wait for a connection before starting to chat.')
self.connect('joined', self._joined_cb)
if self.get_shared():
# we have already joined
self._joined_cb(self)
elif handle.uri:
# XMPP non-sugar3 incoming chat, not sharable
self._activity_toolbar_button.props.page.share.props.visible = \
False
self._one_to_one_connection(handle.uri)
else:
# we are creating the activity
if not self.metadata or self.metadata.get(
'share-scope', activity.SCOPE_PRIVATE) == \
activity.SCOPE_PRIVATE:
# if we are in private session
self._alert(_('Off-line'), _('Share, or invite someone.'))
else:
# resume of shared activity from journal object without invite
self._entry.props.placeholder_text = \
_('Please wait for a connection before starting to chat.')
self.connect('shared', self._shared_cb)
def get_buddy(self, handle):
pservice = presenceservice.get_instance()
tp_name, tp_path = pservice.get_preferred_connection()
return pservice.get_buddy_by_telepathy_handle(tp_name, tp_path, handle)
def __init__(self, handle):
"""Set up the StopWatch activity."""
Activity.__init__(self, handle)
self._logger = logging.getLogger('stopwatch-activity')
GObject.threads_init()
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 sugar3.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)
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(Gdk.EventMask.VISIBILITY_NOTIFY_MASK)
self.connect("visibility-notify-event", self._visible_cb)
self.connect("notify::active", self._active_cb)
self.connect('key-press-event', self._keypress_cb)
def __init__(self, handle):
Activity.__init__(self, handle)
self.play_mode = None
toolbar_box = ToolbarBox()
self.set_toolbar_box(toolbar_box)
self.activity_button = ActivityToolbarButton(self)
toolbar_box.toolbar.insert(self.activity_button, -1)
self._memorizeToolbarBuilder = \
memorizetoolbar.MemorizeToolbarBuilder(self)
toolbar_box.toolbar.insert(Gtk.SeparatorToolItem(), -1)
self._edit_button = ToggleToolButton('view-source')
self._edit_button.set_tooltip(_('Edit game'))
self._edit_button.set_active(False)
toolbar_box.toolbar.insert(self._edit_button, -1)
self._createToolbarBuilder = \
createtoolbar.CreateToolbarBuilder(self)
separator = Gtk.SeparatorToolItem()
separator.set_expand(True)
separator.set_draw(False)
separator.set_size_request(0, -1)
toolbar_box.toolbar.insert(separator, -1)
toolbar_box.toolbar.insert(StopButton(self), -1)
self.game = game.MemorizeGame()
# Play game mode
self.table = cardtable.CardTable()
self.scoreboard = scoreboard.Scoreboard()
self.cardlist = cardlist.CardList()
self.createcardpanel = createcardpanel.CreateCardPanel(self.game)
self.cardlist.connect('pair-selected',
self.createcardpanel.pair_selected)
self.cardlist.connect(
'update-create-toolbar',
self._createToolbarBuilder.update_create_toolbar)
self.createcardpanel.connect('add-pair',
self.cardlist.add_pair)
self.createcardpanel.connect('update-pair',
self.cardlist.update_selected)
self.createcardpanel.connect('change-font',
self.cardlist.change_font)
self.createcardpanel.connect('pair-closed',
self.cardlist.rem_current_pair)
self._createToolbarBuilder.connect('create_new_game',
self.cardlist.clean_list)
self._createToolbarBuilder.connect('create_new_game',
self.createcardpanel.clean)
self._createToolbarBuilder.connect(
'create_new_game',
self._memorizeToolbarBuilder.reset)
self._createToolbarBuilder.connect('create_equal_pairs',
self.change_equal_pairs)
self._edit_button.connect('toggled', self._change_mode_bt)
self.connect('key-press-event', self.table.key_press_event)
self.table.connect('card-flipped', self.game.card_flipped)
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._memorizeToolbarBuilder.update_toolbar)
self.game.connect('change_game',
self._memorizeToolbarBuilder.update_toolbar)
self.game.connect('change_game',
self.createcardpanel.update_font_combos)
self._memorizeToolbarBuilder.connect('game_changed',
self.change_game)
self.box = Gtk.HBox(orientation=Gtk.Orientation.VERTICAL,
homogeneous=False)
width = Gdk.Screen.width()
height = Gdk.Screen.height() - style.GRID_CELL_SIZE
self.table.resize(width, height - style.GRID_CELL_SIZE)
self.scoreboard.set_size_request(-1, style.GRID_CELL_SIZE)
self.box.pack_start(self.table, True, True, 0)
self.box.pack_start(self.scoreboard, False, False, 0)
self.set_canvas(self.box)
# 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(Gdk.EventMask.POINTER_MOTION_MASK)
self.connect('motion_notify_event',
lambda widget, event: face.look_at())
Gdk.Screen.get_default().connect('size-changed',
self.__configure_cb)
# start on the game toolbar, might change this
# to the create toolbar later
self._change_mode(_MODE_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.get_shared_activity():
# We are joining the activity
self.connect('joined', self._joined_cb)
if self.get_shared():
# We've already joined
self._joined_cb(self)
elif not self._jobject.file_path:
logging.debug('buddy joined - __init__: %s', self.owner.props.nick)
game_file = os.path.join(os.path.dirname(__file__), 'demos',
'addition.zip')
self.game.load_game(game_file, 4, 'demo')
logging.debug('loading conventional')
self.game.add_buddy(self.owner)
else:
self.game.add_buddy(self.owner)
self.show_all()
def __init__(self, handle, create_jobject=True):
'''
Initialise the Activity
Args:
handle (sugar3.activity.activityhandle.ActivityHandle)
instance providing the activity id and access to the
presence service which *may* provide sharing for this
application
create_jobject (boolean)
define if it should create a journal object if we are
not resuming
Side effects:
Sets the gdk screen DPI setting (resolution) to the
Sugar screen resolution.
Connects our "destroy" message to our _destroy_cb
method.
Creates a base Gtk.Window within this window.
Creates an ActivityService (self._bus) servicing
this application.
Usage:
If your Activity implements __init__(), it should call
the base class __init()__ before doing Activity specific things.
'''
# Stuff that needs to be done early
icons_path = os.path.join(get_bundle_path(), 'icons')
Gtk.IconTheme.get_default().append_search_path(icons_path)
sugar_theme = 'sugar-72'
if 'SUGAR_SCALING' in os.environ:
if os.environ['SUGAR_SCALING'] == '100':
sugar_theme = 'sugar-100'
# This code can be removed when we grow an xsettings daemon (the GTK+
# init routines will then automatically figure out the font settings)
settings = Gtk.Settings.get_default()
settings.set_property('gtk-theme-name', sugar_theme)
settings.set_property('gtk-icon-theme-name', 'sugar')
settings.set_property('gtk-font-name',
'%s %f' % (style.FONT_FACE, style.FONT_SIZE))
Window.__init__(self)
if 'SUGAR_ACTIVITY_ROOT' in os.environ:
# If this activity runs inside Sugar, we want it to take all the
# screen. Would be better if it was the shell to do this, but we
# haven't found yet a good way to do it there. See #1263.
self.connect('window-state-event', self.__window_state_event_cb)
screen = Gdk.Screen.get_default()
screen.connect('size-changed', self.__screen_size_changed_cb)
self._adapt_window_to_screen()
# process titles will only show 15 characters
# but they get truncated anyway so if more characters
# are supported in the future we will get a better view
# of the processes
proc_title = '%s <%s>' % (get_bundle_name(), handle.activity_id)
util.set_proc_title(proc_title)
self.connect('realize', self.__realize_cb)
self.connect('delete-event', self.__delete_event_cb)
self._active = False
self._active_time = None
self._spent_time = 0
self._activity_id = handle.activity_id
self.shared_activity = None
self._join_id = None
self._updating_jobject = False
self._closing = False
self._quit_requested = False
self._deleting = False
self._max_participants = None
self._invites_queue = []
self._jobject = None
self._read_file_called = False
self._session = _get_session()
self._session.register(self)
self._session.connect('quit-requested',
self.__session_quit_requested_cb)
self._session.connect('quit', self.__session_quit_cb)
accel_group = Gtk.AccelGroup()
self.sugar_accel_group = accel_group
self.add_accel_group(accel_group)
self._bus = ActivityService(self)
self._owns_file = False
share_scope = SCOPE_PRIVATE
if handle.object_id:
self._jobject = datastore.get(handle.object_id)
if 'share-scope' in self._jobject.metadata:
share_scope = self._jobject.metadata['share-scope']
if 'launch-times' in self._jobject.metadata:
self._jobject.metadata['launch-times'] += ', %d' % \
int(time.time())
else:
self._jobject.metadata['launch-times'] = \
str(int(time.time()))
if 'spent-times' in self._jobject.metadata:
self._jobject.metadata['spent-times'] += ', 0'
else:
self._jobject.metadata['spent-times'] = '0'
self.shared_activity = None
self._join_id = None
if handle.object_id is None and create_jobject:
logging.debug('Creating a jobject.')
self._jobject = self._initialize_journal_object()
if handle.invited:
wait_loop = GObject.MainLoop()
self._client_handler = _ClientHandler(
self.get_bundle_id(),
partial(self.__got_channel_cb, wait_loop))
# FIXME: The current API requires that self.shared_activity is set
# before exiting from __init__, so we wait until we have got the
# shared activity. http://bugs.sugarlabs.org/ticket/2168
wait_loop.run()
else:
pservice = presenceservice.get_instance()
mesh_instance = pservice.get_activity(self._activity_id,
warn_if_none=False)
self._set_up_sharing(mesh_instance, share_scope)
if not create_jobject:
self.set_title(get_bundle_name())
return
if self.shared_activity is not None:
self._jobject.metadata['title'] = self.shared_activity.props.name
self._jobject.metadata['icon-color'] = \
self.shared_activity.props.color
else:
self._jobject.metadata.connect('updated',
self.__jobject_updated_cb)
self.set_title(self._jobject.metadata['title'])
