예제 #1
0
    def _new_tube_cb(self, id, initiator, type, service, params, state):
        """ Create a new tube. """
        debug_output(
            'New tube: ID=%d initator=%d type=%d service=%s \
                     params=%r state=%d' %
            (id, initiator, type, service, params, state),
            self._tw.running_sugar)

        if (type == telepathy.TUBE_TYPE_DBUS and service == SERVICE):
            if state == telepathy.TUBE_STATE_LOCAL_PENDING:
                self.tubes_chan[telepathy.CHANNEL_TYPE_TUBES]\
                    .AcceptDBusTube(id)

            tube_conn = TubeConnection(
                self.conn,
                self.tubes_chan[telepathy.CHANNEL_TYPE_TUBES],
                id,
                group_iface=self.text_chan[telepathy.CHANNEL_INTERFACE_GROUP])

            # We'll use a chat tube to send serialized stacks back and forth.
            self.chattube = ChatTube(tube_conn, self.initiating,
                                     self.event_received_cb)

            # Now that we have the tube, we can ask for the turtle dictionary.
            if self.waiting_for_turtles:  # A joiner must wait for turtles.
                debug_output('Sending a request for the turtle dictionary',
                             self._tw.running_sugar)
                # We need to send our own nick, colors, and turtle position
                colors = self._get_colors()
                event = 't|' + data_to_string([self._get_nick(), colors])
                debug_output(event, self._tw.running_sugar)
                self.send_event(event)
예제 #2
0
def _new_tube_cb(id, initiator, type, service, params, state):
    log.debug(
        'New tube: ID=%d initator=%d type=%d service=%s '
        'params=%r state=%d', id, initiator, type, service, params, state)
    if (type == telepathy.TUBE_TYPE_DBUS and service == SERVICE):
        if state == telepathy.TUBE_STATE_LOCAL_PENDING:
            tubes_chan[telepathy.CHANNEL_TYPE_TUBES].AcceptDBusTube(id)
        tube_conn = TubeConnection(
            conn,
            tubes_chan[telepathy.CHANNEL_TYPE_TUBES],
            id,
            group_iface=text_chan[telepathy.CHANNEL_INTERFACE_GROUP])
    def _new_tube_cb(self, id, initiator, type, service, params, state):

        if (type == telepathy.TUBE_TYPE_DBUS and service == SERVICE):
            if state == telepathy.TUBE_STATE_LOCAL_PENDING:
                self.tubes_chan[telepathy.CHANNEL_TYPE_TUBES].AcceptDBusTube(
                    id)

            # Create Tube Connection
            tube_conn = TubeConnection(
                self.conn,
                self.tubes_chan[telepathy.CHANNEL_TYPE_TUBES],
                id,
                group_iface=self.tubes_chan[telepathy.CHANNEL_INTERFACE_GROUP])

            self.controlTube = TubeSpeak(tube_conn, self.__activity.net_cb)
예제 #4
0
 def _new_tube_cb(self, id, initiator, type, service, params, state):
     logging.debug(
         'New tube: ID=%d initator=%d type=%d service=%s '
         'params=%r state=%d', id, initiator, type, service, params, state)
     if (type == telepathy.TUBE_TYPE_DBUS and service == NRLTube.SERVICE):
         if state == telepathy.TUBE_STATE_LOCAL_PENDING:
             self.tubes_chan[telepathy.CHANNEL_TYPE_TUBES].AcceptDBusTube(
                 id)
         tube_conn = TubeConnection(
             self.conn,
             self.tubes_chan[telepathy.CHANNEL_TYPE_TUBES],
             id,
             group_iface=self.text_chan[telepathy.CHANNEL_INTERFACE_GROUP])
         self.newsreader_tube = NRLTube.NRLTube(self, tube_conn,
                                                self.initiating,
                                                self._get_buddy)
 def _new_tube_cb(self, id, initiator, type, service, params, state):
     self._logger.debug(
         'New tube: ID=%d initator=%d type=%d service=%s '
         'params=%r state=%d', id, initiator, type, service, params, state)
     if (type == telepathy.TUBE_TYPE_DBUS and service == SERVICE):
         if state == telepathy.TUBE_STATE_LOCAL_PENDING:
             self.tubes_chan[telepathy.CHANNEL_TYPE_TUBES].AcceptDBusTube(
                 id)
         tube_conn = TubeConnection(
             self.conn,
             self.tubes_chan[telepathy.CHANNEL_TYPE_TUBES],
             id,
             group_iface=self.text_chan[telepathy.CHANNEL_INTERFACE_GROUP])
         self.cmdtube = CanvasSync(tube_conn, self.initiating,
                                   self.process_cmd_cb, self._get_buddy,
                                   self._scribblewidget)
예제 #6
0
 def _new_tube_cb(self, id, initiator, type, service, params, state):
     self.logger.debug(
         'New tube: ID=%d initator=%d type=%d service=%s '
         'params=%r state=%d', id, initiator, type, service, params, state)
     if (type == telepathy.TUBE_TYPE_DBUS and service == self.dbus_name):
         if state == telepathy.TUBE_STATE_LOCAL_PENDING:
             self.tubes_chan[telepathy.CHANNEL_TYPE_TUBES].AcceptDBusTube(
                 id)
         tube_conn = TubeConnection(
             self.conn,
             self.tubes_chan[telepathy.CHANNEL_TYPE_TUBES],
             id,
             group_iface=self.text_chan[telepathy.CHANNEL_INTERFACE_GROUP])
         self.tubebox.insert_tube(tube_conn, self.initiating)
         self._sharing_completed = True
         if self._readfile_completed and not self.initialized:
             self._initialize_display()
예제 #7
0
파일: mesh.py 프로젝트: Lasanha/Gambiarra
def new_tube_cb(id, initiator, type, service, params, state):
    log.debug("New_tube_cb called: %s %s %s" % (id, initiator, type))
    if (type == telepathy.TUBE_TYPE_DBUS and service == DBUS_SERVICE):
        if state == telepathy.TUBE_STATE_LOCAL_PENDING:
            channel = tubes_chan[telepathy.CHANNEL_TYPE_TUBES]
            if hasattr(channel, 'AcceptDBusTube'):
                channel.AcceptDBusTube(id)
            else:
                channel.AcceptTube(id)

        tube_conn = TubeConnection(
            conn,
            tubes_chan[telepathy.CHANNEL_TYPE_TUBES],
            id,
            group_iface=text_chan[telepathy.CHANNEL_INTERFACE_GROUP])

        global pygametubes, initiating
        pygametubes.append(PygameTube(tube_conn, initiating, len(pygametubes)))
예제 #8
0
    def _new_tube_cb(self, id, initiator, type, service, params, state):
        logger.debug(
            'New tube: ID=%d initator=%d type=%d service=%s params=%r state=%d',
            id, initiator, type, service, params, state)
        if type != telepathy.TUBE_TYPE_DBUS or service != constants.DBUS_SERVICE:
            return

        if state == telepathy.TUBE_STATE_LOCAL_PENDING:
            self._tubes_channel.AcceptDBusTube(id)
        tube_connection = TubeConnection(self._connection,
                                         self._tubes_channel,
                                         id,
                                         group_iface=self._text_channel)
        self._tube = RecordTube(tube_connection)
        self._tube.connect("new-recd", self._new_recd_cb)
        self._tube.connect("recd-request", self._recd_request_cb)
        self._tube.connect("recd-bits-arrived", self._recd_bits_arrived_cb)
        self._tube.connect("recd-unavailable", self._recd_unavailable_cb)
예제 #9
0
    def _new_tube_cb(self, id, initiator, type, service, params, state):
        """ Create a new tube. """
        print('New tube: ID=%d initator=%d type=%d service=%s params=%r \
state=%d' % (id, initiator, type, service, params, state))

        if (type == telepathy.TUBE_TYPE_DBUS and service == SERVICE):
            if state == telepathy.TUBE_STATE_LOCAL_PENDING:
                self.tubes_chan[ \
                              telepathy.CHANNEL_TYPE_TUBES].AcceptDBusTube(id)

            tube_conn = TubeConnection(self.conn,
                self.tubes_chan[telepathy.CHANNEL_TYPE_TUBES], id, \
                group_iface=self.text_chan[telepathy.CHANNEL_INTERFACE_GROUP])

            self.chattube = ChatTube(tube_conn, self.initiating, \
                self.event_received_cb)

            # Let the sharer know joiner is waiting for a hand.
            if self.waiting_for_hand:
                self.send_event('j|%s' % (json_dump([self.nick, self.colors])))
예제 #10
0
파일: shared.py 프로젝트: Daksh/showntell
    def new_tube_cb(self, tube_id, initiator, type, service, params, state):
        self.__logger.debug('New tube: ID=%d initator=%d type=%d service=%s params=%r state=%d',
                            tube_id, initiator, type, service, params, state)
        if (not self.__got_dbus_tube and type == telepathy.TUBE_TYPE_DBUS and service == SERVICE):
            if( state == telepathy.TUBE_STATE_LOCAL_PENDING):
                self.__iface.AcceptDBusTube(tube_id)

            self.__dbus_tube = TubeConnection(self.__conn, self.__iface, tube_id,
                                              group_iface=self.__iface_grp)
            self.__got_dbus_tube = True
            self.__logger.debug("Got our dbus tube!")

            # lots of stuff to do once we get our tube
            if (self.__is_initiating):
                self.__deck.connect('slide-changed', self.send_slide_changed_signal)
                self.__deck.connect('local-ink-added', self.send_ink_path)
                self.__deck.connect('instructor-ink-cleared', self.instr_clear_ink_cb)
                self.__deck.connect('instructor-ink-removed', self.instr_remove_ink_cb)
                self.__deck.connect('ink-broadcast', self.bcast_submission_cb)
                self.__dbus_tube.add_signal_receiver(self.student_dl_complete_cb, 'Deck_Download_Complete',
                                                     IFACE, path=PATH, sender_keyword='sender')
                self.__dbus_tube.add_signal_receiver(self.receive_submission_cb,
                                                     'Send_Submission', IFACE, path=PATH)
            else:
                self.__deck.connect('ink-submitted', self.submit_ink_cb)
                self.__dbus_tube.add_signal_receiver(self.slide_changed_cb, 'Slide_Changed',
                                                     IFACE, path=PATH)
                self.__dbus_tube.add_signal_receiver(self.lock_nav_cb, 'Lock_Nav',
                                                     IFACE, path=PATH)
                self.__dbus_tube.add_signal_receiver(self.add_ink_path_cb, 'Add_Ink_Path',
                                                     IFACE, path=PATH)
                self.__dbus_tube.add_signal_receiver(self.recv_instr_clear_ink_cb, 'Instructor_Clear_Ink',
                                                     IFACE, path=PATH)
                self.__dbus_tube.add_signal_receiver(self.recv_instr_remove_ink_cb, 'Instructor_Remove_Ink',
                                                     IFACE, path=PATH)
                self.__dbus_tube.add_signal_receiver(self.receive_submission_cb,
                                                     'Bcast_Submission', IFACE, path=PATH)

            #self.__dbus_tube.watch_participants(self.participant_change_cb)

            super(Shared, self).__init__(self.__dbus_tube, PATH)
예제 #11
0
    def _new_tube_cb(self, id, initiator, type, service, params, state):
        '''Callback for when we have a Tube.'''
        logging.debug(
            'New tube: ID=%d initator=%d type=%d service=%s params=%r state=%d',
            id, initiator, type, service, params, state)

        if (type == telepathy.TUBE_TYPE_DBUS and service == MESH_SERVICE):
            if state == telepathy.TUBE_STATE_LOCAL_PENDING:
                self.tubes_chan[telepathy.CHANNEL_TYPE_TUBES].AcceptDBusTube(
                    id)

            tube_conn = TubeConnection(
                self.__telepathy_connection,
                self.tubes_chan[telepathy.CHANNEL_TYPE_TUBES],
                id,
                group_iface=self.text_chan[telepathy.CHANNEL_INTERFACE_GROUP])

            logging.info('Starting a new JokeMachineSession')
            self.__session = JokeMachineSession(tube_conn,
                                                self.__telepathy_initiating,
                                                self._get_buddy, self)
예제 #12
0
    def _new_tube_cb(self, id, initiator, type, service, params, state):
        logger.debug(
            'New tube: ID=%d initator=%d type=%d service=%s '
            'params=%r state=%d', id, initiator, type, service, params, state)

        if (type == telepathy.TUBE_TYPE_DBUS and service == self.service):
            if state == telepathy.TUBE_STATE_LOCAL_PENDING:
                self.tubes_chan[telepathy.CHANNEL_TYPE_TUBES].AcceptDBusTube(
                    id)

            self.tube_conn = TubeConnection(
                self.conn,
                self.tubes_chan[telepathy.CHANNEL_TYPE_TUBES],
                id,
                group_iface=self.text_chan[telepathy.CHANNEL_INTERFACE_GROUP])

            logger.debug("creating game tube")
            self.game_tube = self.tube_class(self.tube_conn, self.initiating,
                                             self)

        self.new_tube_cb()
예제 #13
0
 def _on_new_tube(self, tube_id, initiator, tube_type, service, params,
                  state):
     details = 'ID=%d initiator=%d type=%d service=[%s] params=%r state=%d' % \
                  (tube_id, initiator, tube_type, service, params, state)
     ka_debug.info('New tube ' + details)
     self._new_tubes.append(details)
     self._status.set(ka_status.TOPIC_COLLABORATION, ka_status.SUB_TUBES,
                      self._new_tubes)
     if (tube_type == telepathy.TUBE_TYPE_DBUS
             and service == kandidtube.SERVICE):
         if state == telepathy.TUBE_STATE_LOCAL_PENDING:
             self.tubes_chan[telepathy.CHANNEL_TYPE_TUBES].AcceptDBusTube(
                 tube_id)
         tube_conn = TubeConnection(
             self.telepathy_conn,
             self.tubes_chan[telepathy.CHANNEL_TYPE_TUBES],
             tube_id,
             group_iface=self.text_chan[telepathy.CHANNEL_INTERFACE_GROUP])
         population_controller = self._controller.find_page(
             'PopulationController')
         if population_controller is not None:
             self.kandidtube = population_controller.on_new_tube(
                 self.telepathy_conn, tube_conn, self._get_my_id(),
                 self.initiating, self.get_buddy_by_handle)
예제 #14
0
class Shared(ExportedGObject):

    __gsignals__ = {
        'navigation-lock-change':
        (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE, (gobject.TYPE_BOOLEAN, )),
        'deck-download-complete':
        (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE, ()),
    }

    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')
        print 'cpxo_path', self.__cpxo_path

        self.__activity.connect('shared', self.shared_cb)
        self.__activity.connect('joined', self.joined_cb)

    def shared_cb(self, activity):
        """ Called when the activity is shared """
        self.__logger.debug('The activity has been shared.')
        self.__is_initiating = True
        print 'shared_cb call write_file', self.__cpxo.path
        self.__activity.write_file(self.__cpxo_path)
        self.__deck.set_is_initiating(is_init=True)
        self.shared_setup()

    def joined_cb(self, activity):
        """ Called when the activity is joined """
        self.__logger.debug('Joined another activity.')
        self.__is_initiating = False
        self.__deck.set_is_initiating(is_init=False)
        # for showing slide deck download progress
        activity.do_progress_view()
        activity.set_progress(0.0)
        self.shared_setup()

    def shared_setup(self):
        """ Called by joined_cb and shared_cb because all of this needs to happen
            whether we are sharing or joining the activity """

        self.__shared_activity = self.__activity.get_shared_activity()

        if self.__shared_activity is None:
            self.__logger.error('Failed to share or join activity!')
            return

        self.__tubes_chan = self.__shared_activity.telepathy_tubes_chan
        self.__iface = self.__tubes_chan[telepathy.CHANNEL_TYPE_TUBES]

        self.__text_chan = self.__shared_activity.telepathy_text_chan
        self.__iface_grp = self.__text_chan[telepathy.CHANNEL_INTERFACE_GROUP]

        self.__conn = self.__shared_activity.telepathy_conn
        self.__my_handle = self.__conn.GetSelfHandle()

        #self.__shared_activity.connect('buddy-joined', self.buddy_joined_cb)
        #self.__shared_activity.connect('buddy-left', self.buddy_left_cb)

        # takes care of downloading (and then sharing) the slide deck over stream tubes
        self.__shared_slides = SharedSlides(self.__is_initiating,
                                            self.__cpxo_path,
                                            self.__shared_activity,
                                            self.__activity.read_file)
        self.__shared_slides.connect('deck-download-complete',
                                     self.deck_download_complete_cb)

        # now for the dbus tube
        self.__iface.connect_to_signal('NewTube', self.new_tube_cb)

        if (self.__is_initiating):
            self.__logger.debug(
                "We are sharing, making a dbus tube and setting locked nav mode."
            )
            self.lock_nav()
            id = self.__iface.OfferDBusTube(SERVICE, {})
        else:
            self.__logger.debug(
                "We are joining, looking for the global dbus tube.")
            self.__tubes_chan[telepathy.CHANNEL_TYPE_TUBES].ListTubes(
                reply_handler=self.list_tubes_reply_cb,
                error_handler=self.list_tubes_error_cb)

    """ --- START DBUS TUBE CODE --- """

    def deck_download_complete_cb(self, object):
        """ Catches the local deck_download_complete signal and sends the appropriate dbus signal """
        self.__logger.debug(
            "Deck download is complete, sending Deck_Download_Complete dbus signal."
        )
        self.Deck_Download_Complete()
        self.emit('deck-download-complete')

    def student_dl_complete_cb(self, sender):
        """ Catches the Deck_Download_Complete dbus signal from students, lets us know that they
            are ready to have initial state information pushed onto them """
        self.__logger.debug(
            "Got Deck_Download_Complete dbus signal, pushing initial state info to student."
        )
        proxy_object = self.__dbus_tube.get_object(sender, PATH)
        proxy_object.Push_Initial_State(self.__locked,
                                        self.__deck.getIndex(),
                                        dbus_interface=IFACE)

    def list_tubes_reply_cb(self, tubes):
        for tube_info in tubes:
            self.new_tube_cb(*tube_info)

    def list_tubes_error_cb(self, e):
        self.__logger.error('ListTubes() failed: %s', e)

    def new_tube_cb(self, tube_id, initiator, type, service, params, state):
        self.__logger.debug(
            'New tube: ID=%d initator=%d type=%d service=%s params=%r state=%d',
            tube_id, initiator, type, service, params, state)
        if (not self.__got_dbus_tube and type == telepathy.TUBE_TYPE_DBUS
                and service == SERVICE):
            if (state == telepathy.TUBE_STATE_LOCAL_PENDING):
                self.__iface.AcceptDBusTube(tube_id)

            self.__dbus_tube = TubeConnection(self.__conn,
                                              self.__iface,
                                              tube_id,
                                              group_iface=self.__iface_grp)
            self.__got_dbus_tube = True
            self.__logger.debug("Got our dbus tube!")

            # lots of stuff to do once we get our tube
            if (self.__is_initiating):
                self.__deck.connect('slide-changed',
                                    self.send_slide_changed_signal)
                self.__deck.connect('local-ink-added', self.send_ink_path)
                self.__deck.connect('instructor-ink-cleared',
                                    self.instr_clear_ink_cb)
                self.__deck.connect('instructor-ink-removed',
                                    self.instr_remove_ink_cb)
                self.__deck.connect('ink-broadcast', self.bcast_submission_cb)
                self.__dbus_tube.add_signal_receiver(
                    self.student_dl_complete_cb,
                    'Deck_Download_Complete',
                    IFACE,
                    path=PATH,
                    sender_keyword='sender')
                self.__dbus_tube.add_signal_receiver(
                    self.receive_submission_cb,
                    'Send_Submission',
                    IFACE,
                    path=PATH)
            else:
                self.__deck.connect('ink-submitted', self.submit_ink_cb)
                self.__dbus_tube.add_signal_receiver(self.slide_changed_cb,
                                                     'Slide_Changed',
                                                     IFACE,
                                                     path=PATH)
                self.__dbus_tube.add_signal_receiver(self.lock_nav_cb,
                                                     'Lock_Nav',
                                                     IFACE,
                                                     path=PATH)
                self.__dbus_tube.add_signal_receiver(self.add_ink_path_cb,
                                                     'Add_Ink_Path',
                                                     IFACE,
                                                     path=PATH)
                self.__dbus_tube.add_signal_receiver(
                    self.recv_instr_clear_ink_cb,
                    'Instructor_Clear_Ink',
                    IFACE,
                    path=PATH)
                self.__dbus_tube.add_signal_receiver(
                    self.recv_instr_remove_ink_cb,
                    'Instructor_Remove_Ink',
                    IFACE,
                    path=PATH)
                self.__dbus_tube.add_signal_receiver(
                    self.receive_submission_cb,
                    'Bcast_Submission',
                    IFACE,
                    path=PATH)

            #self.__dbus_tube.watch_participants(self.participant_change_cb)

            super(Shared, self).__init__(self.__dbus_tube, PATH)

    def participant_change_cb(self, added, removed):
        """ Callback on instructor XO for when someone joins or leaves the tube """
        for handle, bus_name in added:
            buddy = self._get_buddy(handle)
            if buddy is not None:
                if handle != self.__my_handle and self.__is_initiating:
                    self.__logger.debug("New student joined: %s",
                                        buddy.props.nick)

        for handle in removed:
            buddy = self._get_buddy(handle)
            if buddy is not None:
                self.__logger.debug('Buddy %s was removed' % buddy.props.nick)

    @signal(dbus_interface=IFACE, signature='u')
    def Slide_Changed(self, slide_num):
        """ Signals joiners to move to given slide """
        self.__logger.debug(
            "Sending the Slide_Changed signal with slide num %d.", slide_num)
        pass

    @signal(dbus_interface=IFACE, signature='')
    def Deck_Download_Complete(self):
        """ Signal from the student informing instructor that the deck download has finished """
        self.__logger.debug(
            "Sending Deck_Download_Complete signal, ready for initial state info."
        )
        pass

    @signal(dbus_interface=IFACE, signature='u')
    def Lock_Nav(self, lock):
        """ Signals joiners to lock or unlock navigation """
        self.__logger.debug("Sending Lock_Nav signal with bool %u", lock)
        pass

    @method(dbus_interface=IFACE, in_signature='uu', out_signature='')
    def Push_Initial_State(self, locked, slide_idx):
        """ Called on student XO to push initial state info """
        # push current slide index and go to that slide
        self.__deck.goToIndex(slide_idx, is_local=False)

        # push nav lock information
        if locked:
            self.lock_nav()
        else:
            self.unlock_nav()

    def send_slide_changed_signal(self, widget):
        """ Arbitrates the sending of the Slide_Changed signal """
        self.__logger.debug("Got the slide-changed signal.")
        if self.__locked:
            self.__logger.debug(
                "Navigation is locked, sending Slide_Changed to students.")
            self.Slide_Changed(self.__deck.getIndex())

    def slide_changed_cb(self, slide_idx):
        """ Called on the joiners when they receive the Slide_Changed signal """
        self.__logger.debug(
            "Received the Slide_Changed signal and changing to slide %d.",
            slide_idx)

        self.__deck.goToIndex(slide_idx, is_local=False)

    def lock_nav_cb(self, lock):
        """ Called on joiners when they receive the Lock_Nav signal """
        self.__logger.debug("Received the Lock_Nav signal with bool %u", lock)
        if (lock):
            self.lock_nav()
        else:
            self.unlock_nav()

    def lock_mode_switch(self, widget=None):
        """ Switches the lock mode from locked to unlocked and vice versa """
        # first switch our own lock mode
        if (self.__locked):
            self.unlock_nav()
        else:
            self.lock_nav()

        # if we are instructor, tell student XOs to go into our new lock mode
        if (self.__is_initiating):
            self.Lock_Nav(self.__locked)

    def lock_nav(self):
        self.__logger.debug("Locking navigation.")
        self.__locked = True
        # if we are the instructor, force students to jump to our slide
        if self.__got_dbus_tube and self.__is_initiating:
            self.Slide_Changed(self.__deck.getIndex())
        self.__deck.set_locked_mode(locked=True)
        self.emit('navigation-lock-change', self.__locked)

    def unlock_nav(self):
        self.__logger.debug("Unlocking navigation.")
        self.__locked = False
        self.__deck.set_locked_mode(locked=False)
        self.emit('navigation-lock-change', self.__locked)

    def send_ink_path(self, widget, inkstr):
        self.__logger.debug("send_ink_path called")
        if (self.__is_initiating and self.__got_dbus_tube):
            self.Add_Ink_Path(self.__deck.getIndex(), inkstr)

    @signal(dbus_interface=IFACE, signature='us')
    def Add_Ink_Path(self, slide_idx, pathstr):
        self.__logger.debug("Sending new ink path")
        pass

    def _get_buddy(self, cs_handle):
        """Get a Buddy from a channel specific handle."""
        self.__logger.debug('Trying to find owner of handle %u...', cs_handle)
        my_csh = self.__iface_grp.GetSelfHandle()
        self.__logger.debug('My handle in that group is %u', my_csh)
        if my_csh == cs_handle:
            handle = self.__conn.GetSelfHandle()
            self.__logger.debug('CS handle %u belongs to me, %u', cs_handle,
                                handle)
        elif group.GetGroupFlags(
        ) & telepathy.CHANNEL_GROUP_FLAG_CHANNEL_SPECIFIC_HANDLES:
            handle = group.GetHandleOwners([cs_handle])[0]
            self.__logger.debug('CS handle %u belongs to %u', cs_handle,
                                handle)
        else:
            handle = cs_handle
            self.__logger.debug('non-CS handle %u belongs to itself', handle)
            # XXX: deal with failure to get the handle owner
            assert handle != 0
        return self.__pservice.get_buddy_by_telepathy_handle(
            self.__conn.service_name, self.__conn.object_path, handle)

    def add_ink_path_cb(self, idx, inkstr):
        self.__logger.debug("Received new ink path")
        self.__deck.addInkToSlide(inkstr, islocal=False, n=idx)

    def submit_ink_cb(self, widget, inks, text):
        if not self.__is_initiating and self.__got_dbus_tube:
            cur_idx = self.__deck.getIndex()
            my_csh = self.__iface_grp.GetSelfHandle()
            buddy = self._get_buddy(my_csh)

            if buddy is not None:
                sender = buddy.props.nick
            else:
                sender = 'Unknown'

            self.__logger.debug("Sending submission: idx '%d', sender '%s'.",
                                cur_idx, sender)
            self.Send_Submission(sender, cur_idx, inks, text)

    @signal(dbus_interface=IFACE, signature='suss')
    def Send_Submission(self, sender, slide_idx, inks, text):
        pass

    def receive_submission_cb(self, sender, slide_idx, inks, text):
        self.__logger.debug("Received submission from '%s'.", sender)
        self.__deck.addSubmission(sender, inks, text, slide_idx)

    def bcast_submission_cb(self, widget, whofrom, inks, text):
        if self.__is_initiating and self.__got_dbus_tube:
            cur_idx = self.__deck.getIndex()
            self.Bcast_Submission(whofrom, cur_idx, inks, text)

    @signal(dbus_interface=IFACE, signature='suss')
    def Bcast_Submission(self, sender, slide_idx, inks, text):
        pass

    def instr_clear_ink_cb(self, widget, idx):
        if self.__is_initiating and self.__got_dbus_tube:
            self.Instructor_Clear_Ink(idx)

    @signal(dbus_interface=IFACE, signature='u')
    def Instructor_Clear_Ink(self, idx):
        pass

    def recv_instr_clear_ink_cb(self, idx):
        self.__deck.clearInstructorInk(idx)

    def instr_remove_ink_cb(self, widget, uid, idx):
        if self.__is_initiating and self.__got_dbus_tube:
            self.Instructor_Remove_Ink(uid, idx)

    @signal(dbus_interface=IFACE, signature='uu')
    def Instructor_Remove_Ink(self, uid, idx):
        pass

    def recv_instr_remove_ink_cb(self, uid, idx):
        self.__deck.removeInstructorPathByUID(uid, idx)

    """ --- END DBUS TUBE CODE --- """

    # DEPRECATED
    def buddy_joined_cb(self, activity, buddy):
        """ Called when a buddy joins the activity """
        if self.__is_initiating is True:
            utils.run_dialog("Instructor", buddy.props.nick + " has joined!")

    # DEPRECATED
    def buddy_left_cb(self, activity, buddy):
        """ Called when a buddy leaves the activity """
        if self.__is_initiating is True:
            utils.run_dialog("Instructor", buddy.props.nick + " has left!")
예제 #15
0
    def new_tube_cb(self, tube_id, initiator, type, service, params, state):
        self.__logger.debug(
            'New tube: ID=%d initator=%d type=%d service=%s params=%r state=%d',
            tube_id, initiator, type, service, params, state)
        if (not self.__got_dbus_tube and type == telepathy.TUBE_TYPE_DBUS
                and service == SERVICE):
            if (state == telepathy.TUBE_STATE_LOCAL_PENDING):
                self.__iface.AcceptDBusTube(tube_id)

            self.__dbus_tube = TubeConnection(self.__conn,
                                              self.__iface,
                                              tube_id,
                                              group_iface=self.__iface_grp)
            self.__got_dbus_tube = True
            self.__logger.debug("Got our dbus tube!")

            # lots of stuff to do once we get our tube
            if (self.__is_initiating):
                self.__deck.connect('slide-changed',
                                    self.send_slide_changed_signal)
                self.__deck.connect('local-ink-added', self.send_ink_path)
                self.__deck.connect('instructor-ink-cleared',
                                    self.instr_clear_ink_cb)
                self.__deck.connect('instructor-ink-removed',
                                    self.instr_remove_ink_cb)
                self.__deck.connect('ink-broadcast', self.bcast_submission_cb)
                self.__dbus_tube.add_signal_receiver(
                    self.student_dl_complete_cb,
                    'Deck_Download_Complete',
                    IFACE,
                    path=PATH,
                    sender_keyword='sender')
                self.__dbus_tube.add_signal_receiver(
                    self.receive_submission_cb,
                    'Send_Submission',
                    IFACE,
                    path=PATH)
            else:
                self.__deck.connect('ink-submitted', self.submit_ink_cb)
                self.__dbus_tube.add_signal_receiver(self.slide_changed_cb,
                                                     'Slide_Changed',
                                                     IFACE,
                                                     path=PATH)
                self.__dbus_tube.add_signal_receiver(self.lock_nav_cb,
                                                     'Lock_Nav',
                                                     IFACE,
                                                     path=PATH)
                self.__dbus_tube.add_signal_receiver(self.add_ink_path_cb,
                                                     'Add_Ink_Path',
                                                     IFACE,
                                                     path=PATH)
                self.__dbus_tube.add_signal_receiver(
                    self.recv_instr_clear_ink_cb,
                    'Instructor_Clear_Ink',
                    IFACE,
                    path=PATH)
                self.__dbus_tube.add_signal_receiver(
                    self.recv_instr_remove_ink_cb,
                    'Instructor_Remove_Ink',
                    IFACE,
                    path=PATH)
                self.__dbus_tube.add_signal_receiver(
                    self.receive_submission_cb,
                    'Bcast_Submission',
                    IFACE,
                    path=PATH)

            #self.__dbus_tube.watch_participants(self.participant_change_cb)

            super(Shared, self).__init__(self.__dbus_tube, PATH)
예제 #16
0
class Shared(ExportedGObject):

    __gsignals__ = {
        'navigation-lock-change' : (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE, (gobject.TYPE_BOOLEAN,)),
        'deck-download-complete' : (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE, ()),
        }
        
    def __init__(self, arbiter, work_path):
        gobject.GObject.__init__(self)

        self.__arbiter = arbiter

        self.__logger = logging.getLogger('Shared')
        self.__logger.setLevel(logging.DEBUG)

        self.__sharing = False
        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.__arbiter.connect_shared(self.shared_cb)
        self.__arbiter.connect_joined(self.joined_cb)

        self.__logger.debug('Hello from Shared. Waiting to become sharer or joiner.')

    def get_is_instructor(self):
        """ Returns a flag that indicates whether we shared the activity.
            Also called 'instructor mode'. """
        return self.__sharing

    def get_lock_mode(self):
        """ Returns a flag that indicates whether student navigation is locked. """
        return self.__locked

    def shared_cb(self, activity):
        """ Called when the activity is shared """
        self.__logger.debug('The activity has been shared.')
        self.__sharing = True
        self.__arbiter.do_write_file(self.__cpxo_path)

        # connect to local instructor signals
        self.__arbiter.connect_quitting(self.activity_quit_cb)
        self.__arbiter.connect_slide_changed(self.send_slide_changed_signal_cb)
        self.__arbiter.connect_local_ink_added(self.send_ink_path_cb)
        self.__arbiter.connect_instructor_ink_cleared(self.instr_clear_ink_cb)
        self.__arbiter.connect_instructor_ink_removed(self.instr_remove_ink_cb)
        self.__arbiter.connect_ink_broadcast(self.bcast_submission_cb)
        self.__arbiter.connect_lock_button_clicked(self.lock_mode_switch)

        self.shared_setup()

    def joined_cb(self, activity):
        """ Called when the activity is joined """
        self.__logger.debug('Joined another activity.')
        self.__sharing = False
        # for showing slide deck download progress
        activity.do_progress_view()
        activity.set_progress(0.0)

        # connect to local student signals
        self.__arbiter.connect_ink_submitted(self.submit_ink_cb)

        self.shared_setup()

    def shared_setup(self):
        """ Called by joined_cb and shared_cb because all of this needs to happen
            whether we are sharing or joining the activity """

        self.__shared_activity = self.__arbiter.get_shared_activity()

        if self.__shared_activity is None:
            self.__logger.error('Failed to share or join activity!')
            return

        self.__tubes_chan = self.__shared_activity.telepathy_tubes_chan
        self.__iface = self.__tubes_chan[telepathy.CHANNEL_TYPE_TUBES]

        self.__text_chan = self.__shared_activity.telepathy_text_chan
        self.__iface_grp = self.__text_chan[telepathy.CHANNEL_INTERFACE_GROUP]

        self.__conn = self.__shared_activity.telepathy_conn
        self.__my_handle = self.__conn.GetSelfHandle()

        #self.__shared_activity.connect('buddy-joined', self.buddy_joined_cb)
        #self.__shared_activity.connect('buddy-left', self.buddy_left_cb)

        # takes care of downloading (and then sharing) the slide deck over stream tubes
        self.__shared_slides = SharedSlides(self.__sharing, self.__cpxo_path,
                                            self.__shared_activity, self.__arbiter.do_read_file)
        self.__shared_slides.connect('deck-download-complete', self.deck_download_complete_cb)

        # now for the dbus tube
        self.__iface.connect_to_signal('NewTube', self.new_tube_cb)

        if (self.__sharing):
            self.__logger.debug("We are sharing, making a dbus tube and setting locked nav mode.")
            self.lock_nav()
            id = self.__iface.OfferDBusTube(SERVICE, {})
        else:
            self.__logger.debug("We are joining, looking for the global dbus tube.")
            self.__iface.ListTubes( reply_handler=self.list_tubes_reply_cb,
                                    error_handler=self.list_tubes_error_cb )

    def lock_mode_switch(self, widget=None):
        """ Switches the lock mode from locked to unlocked and vice versa """
        # first switch our own lock mode
        if (self.__locked):
            self.unlock_nav()
        else:
            self.lock_nav()
    
        # if we are instructor, tell student XOs to go into our new lock mode
        if (self.__sharing):
            self.Lock_Nav(self.__locked)
            
    def lock_nav(self):
        self.__logger.debug("Locking navigation.")
        self.__locked = True
        # if we are the instructor, force students to jump to our slide
        if self.__got_dbus_tube and self.__sharing:
            self.Slide_Changed(self.__arbiter.get_slide_index())
        self.emit('navigation-lock-change', self.__locked)

    def unlock_nav(self):
        self.__logger.debug("Unlocking navigation.")
        self.__locked = False
        self.emit('navigation-lock-change', self.__locked)


    def deck_download_complete_cb(self, object):
        """ Catches the deck_download_complete signal from SharedSlides and sends a local
            and dbus signal. """
        self.__logger.debug("Deck download is complete, sending Deck_Download_Complete dbus signal.")
        self.Deck_Download_Complete()
        self.emit('deck-download-complete')

    def student_dl_complete_cb(self, sender):
        """ Catches the Deck_Download_Complete dbus signal from students, lets us know that they
            are ready to have initial state information pushed onto them """
        self.__logger.debug("Got Deck_Download_Complete dbus signal, pushing initial state info to student.")
        proxy_object = self.__dbus_tube.get_object(sender, PATH)
        proxy_object.Push_Initial_State(self.__locked, self.__arbiter.get_slide_index(),
                                        dbus_interface=IFACE)
        
    def list_tubes_reply_cb(self, tubes):
        for tube_info in tubes:
            self.new_tube_cb(*tube_info)

    def list_tubes_error_cb(self, e):
        self.__logger.error('ListTubes() failed: %s', e)

    def new_tube_cb(self, tube_id, initiator, type, service, params, state):
        self.__logger.debug('New tube: ID=%d initator=%d type=%d service=%s params=%r state=%d',
                            tube_id, initiator, type, service, params, state)
        if (not self.__got_dbus_tube and type == telepathy.TUBE_TYPE_DBUS and service == SERVICE):
            if( state == telepathy.TUBE_STATE_LOCAL_PENDING):
                self.__iface.AcceptDBusTube(tube_id)

            self.__dbus_tube = TubeConnection(self.__conn, self.__iface, tube_id,
                                              group_iface=self.__iface_grp)
            self.__got_dbus_tube = True
            self.__logger.debug("Got our dbus tube!")

            # lots of stuff to do once we get our tube
            if (self.__sharing):
                # connect to dbus signals sent by students:
                self.__dbus_tube.add_signal_receiver(self.student_dl_complete_cb, 'Deck_Download_Complete',
                                                     IFACE, path=PATH, sender_keyword='sender')
                self.__dbus_tube.add_signal_receiver(self.receive_submission_cb, 'Send_Submission',
                                                     IFACE, path=PATH)
            else:
                # connect to dbus signals sent by instructor
                self.__dbus_tube.add_signal_receiver(self.slide_changed_cb, 'Slide_Changed',
                                                     IFACE, path=PATH)
                self.__dbus_tube.add_signal_receiver(self.lock_nav_cb, 'Lock_Nav',
                                                     IFACE, path=PATH)
                self.__dbus_tube.add_signal_receiver(self.add_ink_path_cb, 'Add_Ink_Path',
                                                     IFACE, path=PATH)
                self.__dbus_tube.add_signal_receiver(self.recv_instr_clear_ink_cb, 'Instructor_Clear_Ink',
                                                     IFACE, path=PATH)
                self.__dbus_tube.add_signal_receiver(self.recv_instr_remove_ink_cb, 'Instructor_Remove_Ink',
                                                     IFACE, path=PATH)
                self.__dbus_tube.add_signal_receiver(self.receive_submission_cb, 'Bcast_Submission',
                                                     IFACE, path=PATH)

            #self.__dbus_tube.watch_participants(self.participant_change_cb)

            super(Shared, self).__init__(self.__dbus_tube, PATH)


    # --- BEGIN Instructor CallBacks ---

    # UNUSED
    def participant_change_cb(self, added, removed):
        """ Callback on instructor XO for when someone joins or leaves the tube """
        for handle, bus_name in added:
            buddy = self._get_buddy(handle)
            if buddy is not None:
                if handle != self.__my_handle and self.__sharing:
                    self.__logger.debug("New student joined: %s", buddy.props.nick)

        for handle in removed:
            buddy = self._get_buddy(handle)
            if buddy is not None:
                self.__logger.debug('Buddy %s was removed' % buddy.props.nick)

    def activity_quit_cb(self, widget):
        """ Called when the activity is quit. """
        self.__logger.debug("Activity is quitting. Making sure student navigation is unlocked.")
        if self.__locked:
            self.lock_mode_switch()

    def send_slide_changed_signal_cb(self, widget):
        """ Arbitrates the sending of the Slide_Changed signal """
        self.__logger.debug("Got the slide-changed signal.")
        if self.__locked:
            self.__logger.debug("Navigation is locked, sending Slide_Changed to students.")
            self.Slide_Changed(self.__arbiter.get_slide_index())

    def send_ink_path_cb(self, widget, inkstr):
        self.__logger.debug("send_ink_path_cb called")
        if (self.__sharing and self.__got_dbus_tube):
            self.Add_Ink_Path(self.__arbiter.get_slide_index(), inkstr)
    
    def receive_submission_cb(self, sender, slide_idx, inks, text):
        self.__logger.debug("Received submission from '%s'.", sender)
        self.__arbiter.do_add_submission(sender, inks, text, slide_idx)
        
    def bcast_submission_cb(self, widget, whofrom, inks, text):
        if self.__sharing and self.__got_dbus_tube:
            cur_idx = self.__arbiter.get_slide_index()
            self.Bcast_Submission(whofrom, cur_idx, inks, text)
    
    def instr_clear_ink_cb(self, widget, idx):
        if self.__sharing and self.__got_dbus_tube:
            self.Instructor_Clear_Ink(idx)

    def instr_remove_ink_cb(self, widget, uid, idx):
        if self.__sharing and self.__got_dbus_tube:
            self.Instructor_Remove_Ink(uid, idx)

    # --- END Instructor CallBacks ---


    # --- BEGIN Instructor DBus Signals/Methods ---

    @signal(dbus_interface=IFACE, signature='uu')
    def Instructor_Remove_Ink(self, uid, idx):
        pass
    
    @signal(dbus_interface=IFACE, signature='u')
    def Instructor_Clear_Ink(self, idx):
        pass
    
    @signal(dbus_interface=IFACE, signature='u')
    def Slide_Changed(self, slide_num):
        """ Signals joiners to move to given slide """
        self.__logger.debug("Sending the Slide_Changed signal with slide num %d.", slide_num)
        pass

    @signal(dbus_interface=IFACE, signature='u')
    def Lock_Nav(self, lock):
        """ Signals joiners to lock or unlock navigation """
        self.__logger.debug("Sending Lock_Nav signal with bool %u", lock)
        pass

    @signal(dbus_interface=IFACE, signature='us')
    def Add_Ink_Path(self, slide_idx, pathstr):
        self.__logger.debug("Sending new ink path")
        pass

    @signal(dbus_interface=IFACE, signature='suss')
    def Bcast_Submission(self, sender, slide_idx, inks, text):
        pass    

    # --- END Instructor DBus Signals/Methods ---


    # --- BEGIN Student CallBacks ---

    def recv_instr_remove_ink_cb(self, uid, idx):
        self.__arbiter.do_remove_instructor_path_by_uid(uid, idx)

    def recv_instr_clear_ink_cb(self, idx):
        self.__arbiter.do_clear_instructor_ink(idx)

    def slide_changed_cb(self, slide_idx):
        """ Called on the joiners when they receive the Slide_Changed dbus signal """
        self.__logger.debug("Received the Slide_Changed signal and changing to slide %d.",
                            slide_idx)

        self.__arbiter.do_goto_slide(slide_idx, local_request=False)

    def lock_nav_cb(self, lock):
        """ Called on joiners when they receive the Lock_Nav dbus signal """
        self.__logger.debug("Received the Lock_Nav signal with bool %u", lock)
        if (lock):
            self.lock_nav()
        else:
            self.unlock_nav()

    def add_ink_path_cb(self, idx, inkstr):
        self.__logger.debug("Received new ink path")
        self.__arbiter.do_add_ink_to_slide(inkstr, local_request=False, n=idx)

    def submit_ink_cb(self, widget, inks, text):
        if not self.__sharing and self.__got_dbus_tube:
            cur_idx = self.__arbiter.get_slide_index()
            my_csh = self.__iface_grp.GetSelfHandle()
            buddy = self._get_buddy(my_csh)

            if buddy is not None:
                sender = buddy.props.nick
            else:
                sender = 'Unknown'

            self.__logger.debug("Sending submission: idx '%d', sender '%s'.", cur_idx, sender)
            self.Send_Submission(sender, cur_idx, inks, text)
    
    # --- END Student CallBacks ---


    # --- BEGIN Student DBus Signals/Methods ---

    @signal(dbus_interface=IFACE, signature='')
    def Deck_Download_Complete(self):
        """ Signal from the student informing instructor that the deck download has finished """
        self.__logger.debug("Sending Deck_Download_Complete signal, ready for initial state info.")
        pass

    @signal(dbus_interface=IFACE, signature='suss')
    def Send_Submission(self, sender, slide_idx, inks, text):
        pass
    
    @method(dbus_interface=IFACE, in_signature='uu', out_signature='')
    def Push_Initial_State(self, locked, slide_idx):
        """ Called on student XO to push initial state info """
        self.__logger.debug("Got initial state data from instructor: locked? %u, slide? %u",
                            locked, slide_idx)

        self.__arbiter.do_goto_slide(slide_idx, local_request=False)

        if locked:
            self.lock_nav()
        else:
            self.unlock_nav()

    # --- END Student DBus Signals/Methods ---


    # BEGIN Private Methods

    def _get_buddy(self, cs_handle):
        """Get a Buddy from a channel specific handle."""
        self.__logger.debug('Trying to find owner of handle %u...', cs_handle)
        my_csh = self.__iface_grp.GetSelfHandle()
        self.__logger.debug('My handle in that group is %u', my_csh)
        if my_csh == cs_handle:
            handle = self.__conn.GetSelfHandle()
            self.__logger.debug('CS handle %u belongs to me, %u', cs_handle, handle)
        elif group.GetGroupFlags() & telepathy.CHANNEL_GROUP_FLAG_CHANNEL_SPECIFIC_HANDLES:
            handle = group.GetHandleOwners([cs_handle])[0]
            self.__logger.debug('CS handle %u belongs to %u', cs_handle, handle)
        else:
            handle = cs_handle
            self.__logger.debug('non-CS handle %u belongs to itself', handle)
            # XXX: deal with failure to get the handle owner
            assert handle != 0
        return self.__pservice.get_buddy_by_telepathy_handle(
            self.__conn.service_name, self.__conn.object_path, handle)

    # END Private Methods


    # DEPRECATED
    def buddy_joined_cb(self, activity, buddy):
        """ Called when a buddy joins the activity """
        if self.__sharing is True:
            utils.run_dialog("Instructor", buddy.props.nick + " has joined!")

    # DEPRECATED
    def buddy_left_cb(self, activity, buddy):
        """ Called when a buddy leaves the activity """
        if self.__sharing is True:
            utils.run_dialog("Instructor", buddy.props.nick + " has left!")