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 _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 __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_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__(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, 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'])