/// <summary> /// Add a group, but only if not already a member. /// </summary> /// <param name="g"></param> private void addGroup(Group g) { if (!this.m_Participant.Groups.Contains(g)) { Trace.WriteLine("RoleSynchronizer adding group: " + g.FriendlyName, this.GetType().ToString()); this.m_Participant.Groups.Add(g); } }
/// <summary> /// This is similar to the texthelpermethod, but here we send a removal message /// if the message is private. I am having two different methods for the sake of seperating /// the two different types of messages. /// </summary> /// <param name="receivers"></param> private void SendPublicHelper(Group receivers) { Message message, deck, slide; message = new PresentationInformationMessage(this.Presentation); message.Group = receivers; message.InsertChild(deck = new DeckInformationMessage(this.Deck)); deck.InsertChild(slide = new SlideInformationMessage(this.Slide)); ///send the text message bool sheet_is_public; using (Synchronizer.Lock(sheet_.SyncRoot)) { sheet_is_public = sheet_.IsPublic; } ///if the sheet is private, the users should not be able to see any part of the sheet, ///so we should just remove a private sheet. if (sheet_is_public) { slide.InsertChild(new TextSheetMessage(this.sheet_, this.SheetCollectionSelector)); } else { slide.InsertChild(new SheetRemovedMessage(this.sheet_, this.SheetCollectionSelector)); } using (Synchronizer.Lock(this.Slide.SyncRoot)) { message.Tags = new MessageTags(); message.Tags.SlideID = this.Slide.Id; } this.Sender.Send(message); }
public GroupInformationMessage(Group group) : base(Guid.Empty) { this.GroupId = group.ID; this.FriendlyName = group.FriendlyName; this.Singleton = (group is SingletonGroup); }
public void ForceUpdate(Group receivers) { // Don't send a GenericChange, since DeckNetworkService.ForceUpdate // will already have sent the basic slide information. // Send all the slides using( Synchronizer.Lock( this.m_Presentation.SyncRoot ) ) { using (Synchronizer.Lock(this.m_Deck.SyncRoot)) { using (Synchronizer.Lock(this.m_Slide.SyncRoot)) { foreach (SheetModel sheet in this.m_Slide.ContentSheets) { using (Synchronizer.Lock(sheet.SyncRoot)) { // Don't create a network service for the sheet if it is remote, // UNLESS this is a student submission slide in which case we're responsible for rebroadcasting its ink. if ((sheet.Disposition & SheetDisposition.Remote) == 0 || (this.m_Slide.Disposition & SlideDisposition.StudentSubmission) != 0) this.SendSheetInformation(sheet, SheetMessage.SheetCollection.ContentSheets, receivers); } } foreach (SheetModel sheet in this.m_Slide.AnnotationSheets) { using (Synchronizer.Lock(sheet.SyncRoot)) { // Don't create a network service for the sheet if it is remote, // UNLESS this is a student submission slide in which case we're responsible for rebroadcasting its ink. if ((sheet.Disposition & SheetDisposition.Remote) == 0 || (this.m_Slide.Disposition & SlideDisposition.StudentSubmission) != 0) this.SendSheetInformation(sheet, SheetMessage.SheetCollection.AnnotationSheets, receivers); } } } } } // Also don't send any Student Submissions. this.m_ContentSheetsCollectionHelper.ForceUpdate(receivers); this.m_AnnotationSheetsCollectionHelper.ForceUpdate(receivers); }
/// <summary> /// Sends the status of a student submission out to a teacher or student. /// </summary> /// <param name="group"></param> private void SendStatusHelper(Group group) { Message message; using (Synchronizer.Lock(submission_status_model_.SyncRoot)) { if (submission_status_model_.SubmissionStatus == SubmissionStatusModel.Status.Received) { return; } } message = new SubmissionStatusMessage(submission_status_model_); message.Group = group; sender_.Send(message); }
private void SendQuickPollSheetHelper( Group receivers ) { //Don't send message if it's an instructor note. if( this.sheet.Disposition != SheetDisposition.Instructor ) { Message message, deck, poll, slide; message = new PresentationInformationMessage( this.Presentation ); message.Group = receivers; message.InsertChild( deck = new DeckInformationMessage( this.Deck ) ); deck.InsertChild( slide = new SlideInformationMessage( this.Slide ) ); using( Synchronizer.Lock( this.Sheet.SyncRoot ) ) { slide.InsertChild( poll = new QuickPollInformationMessage( this.sheet.QuickPoll ) ); } poll.InsertChild( new QuickPollSheetMessage( this.sheet, this.SheetCollectionSelector ) ); using( Synchronizer.Lock( m_SlideModel.SyncRoot ) ) { message.Tags = new MessageTags(); message.Tags.SlideID = m_SlideModel.Id; } this.Sender.Send( message ); } }
private void SendImageHelper(Group receivers) { //Don't send message if it's an instructor note. if (this.sheet_.Disposition != SheetDisposition.Instructor) { Message message, deck, slide; message = new PresentationInformationMessage(this.Presentation); message.Group = receivers; message.InsertChild(deck = new DeckInformationMessage(this.Deck)); deck.InsertChild(slide = new SlideInformationMessage(this.Slide)); slide.InsertChild(new ImageSheetMessage(this.sheet_, this.SheetCollectionSelector)); using (Synchronizer.Lock(m_SlideModel.SyncRoot)) { message.Tags = new MessageTags(); message.Tags.SlideID = m_SlideModel.Id; } if (this.sheet_.Image != null) { using (Synchronizer.Lock(this.sheet_.SyncRoot)) { this.Sender.Send(message); } } else this.Sender.Send(message); } }
public int IndexOf( Group value ) { return List.IndexOf( value ); }
public void ForceUpdate(Group receivers) { using (Synchronizer.Lock(this.Owner.SyncRoot)) { foreach (SheetNetworkService service_ in this.Tags) { SheetNetworkService service = service_; // For access by delayed delgate. if (service != null) { this.m_Service.m_Sender.Post(delegate() { service.ForceUpdate(receivers); }); } } } }
private void SendGenericChange(Group receivers) { // Send a generic update with information about the slide (including the new bounds/zoom). Message message, deck; message = new PresentationInformationMessage( this.m_Presentation ); message.Group = receivers; message.InsertChild( deck = new DeckInformationMessage( this.m_Deck ) ); deck.InsertChild( new SlideInformationMessage( this.m_Slide ) ); this.m_Sender.Send( message ); }
public void SendSheetInformation( SheetModel sheet, SheetMessage.SheetCollection selector, Group receivers ) { // TODO: Also pass the index so the sheet can be inserted into the correct index on the remote side. Message message, deck, slide; message = new PresentationInformationMessage( this.m_Presentation ); message.Group = receivers; message.InsertChild( deck = new DeckInformationMessage( this.m_Deck ) ); deck.InsertChild( slide = new SlideInformationMessage( this.m_Slide ) ); Message sm = SheetMessage.RemoteForSheet(sheet, selector); //if sm is null that means that the sheet is an instructor note and shouldn't be sent. if (sm != null) { slide.InsertChild(sm); } using( Synchronizer.Lock( this.m_Slide.SyncRoot ) ) { message.Tags = new MessageTags(); message.Tags.SlideID = this.m_Slide.Id; } if (sheet is ImageSheetModel && ((ImageSheetModel)sheet).Image != null) { using (Synchronizer.Lock(sheet.SyncRoot)) { this.m_Sender.Send( message ); } } else this.m_Sender.Send(message); }
/// <summary> /// Constructor for this object /// </summary> /// <param name="id">The globally unique identifier for this deck</param> /// <param name="disposition"></param> /// <param name="humanName"></param> public DeckModel(Guid id, DeckDisposition disposition, string humanName, TableOfContentsModel toc, Hashtable slides, ImageHashtable sc, Hashtable ctsl) { this.m_Id = id; this.m_Disposition = disposition; this.m_HumanName = humanName; this.m_DeckBackgroundColor = Color.White; this.Filename = ""; this.Group = Group.AllParticipant; if (this.Disposition == DeckDisposition.StudentSubmission || this.Disposition == DeckDisposition.QuickPoll) { this.m_Dirty = true; } else { this.m_Dirty = false; } if (toc == null) { this.m_TableOfContents = new TableOfContentsModel(); } else { this.m_TableOfContents = toc; } if (slides == null) { this.m_Slides = new Hashtable(); } else { this.m_Slides = slides; } if (sc == null) { this.m_SlideContent = new ImageHashtable(); } else { this.m_SlideContent = sc; } if (ctsl != null) { this.m_ContentToSlideLookup = ctsl; } }
private void SendPollResultInformation( QuickPollResultModel result, Group receivers ) { Message message, poll, res; message = new PresentationInformationMessage( this.m_Service.m_Presentation ); message.Group = receivers; poll = new QuickPollInformationMessage( this.m_Service.m_QuickPoll ); poll.Group = receivers; message.InsertChild( poll ); res = new QuickPollResultInformationMessage( result ); res.Group = receivers; poll.InsertChild( res ); this.m_Service.m_Sender.Send( message ); }
public void ForceUpdate(Group receivers) { using(Synchronizer.Lock(this.Owner.SyncRoot)) { foreach (DeckTraversalNetworkService service in this.Tags) { if (service != null) { this.SendTraversalInformation(service.DeckTraversal, receivers); service.ForceUpdate(receivers); } } } }
public void ForceUpdate(Group receivers) { this.m_DeckTraversalsCollectionHelper.ForceUpdate(receivers); this.m_QuickPollNetworkService.ForceUpdate(receivers); this.SendQuickPollChanged( receivers ); }
public void ForceUpdate(UW.ClassroomPresenter.Network.Groups.Group receivers) { //Nothing }
private void SendExistingInk(Group receivers) { Ink extracted; using(Synchronizer.Lock(this.m_Sheet.Ink.Strokes.SyncRoot)) { // Ensure that each stroke has a Guid which will uniquely identify it on the remote side. foreach(Stroke stroke in this.m_Sheet.Ink.Strokes) { if(!stroke.ExtendedProperties.DoesPropertyExist(InkSheetMessage.StrokeIdExtendedProperty)) stroke.ExtendedProperties.Add(InkSheetMessage.StrokeIdExtendedProperty, Guid.NewGuid().ToString()); } // Extract all of the strokes. extracted = this.m_Sheet.Ink.ExtractStrokes(this.m_Sheet.Ink.Strokes, ExtractFlags.CopyFromOriginal); } // Send a message as if the already-existing ink was just added to the sheet. this.Sender.Post(delegate() { this.HandleInkAddedHelper(extracted, receivers); }); }
public bool Contains( Group value ) { return List.Contains( value ); }
public int Add( Group value ) { return List.Add( value ); }
public override void ForceUpdate(UW.ClassroomPresenter.Network.Groups.Group receivers) { this.SendQuickPollSheet(receivers); }
public void ForceUpdate(UW.ClassroomPresenter.Network.Groups.Group receivers) { sender_.Post(delegate() { this.SendStatusHelper(receivers); }); }
public override void ForceUpdate(UW.ClassroomPresenter.Network.Groups.Group receivers) { this.SendImage(receivers); }
private void HandleInkAddedHelper(Ink extracted, Group receivers) { if (ViewerStateModel.NonStandardDpi) { extracted.Strokes.Transform(ViewerStateModel.DpiNormalizationSendMatrix, true); } try { Message message = new InkSheetStrokesAddedMessage(this.m_Sheet, m_SlideID, this.SheetCollectionSelector, extracted); message.Group = receivers; message.Tags = new MessageTags(); message.Tags.SlideID = m_SlideID; message.Tags.BridgePriority = MessagePriority.Higher; this.Sender.Send(message); } catch (OutOfMemoryException e) { Trace.WriteLine(e.ToString()); GC.Collect(); } }
public void Insert( int index, Group value ) { List.Insert( index, value ); }
public override void ForceUpdate(Group receivers) { this.SendExistingInk(receivers); }
public void Remove( Group value ) { List.Remove( value ); }
private void SendTraversalInformation(DeckTraversalModel traversal, Group receivers) { Message message, deck; message = new PresentationInformationMessage(this.m_Service.m_Presentation); message.Group = receivers; message.InsertChild(deck = new DeckInformationMessage(traversal.Deck)); deck.InsertChild(DeckTraversalMessage.ForDeckTraversal(traversal)); this.m_Service.m_Sender.Send(message); }
private void SendRoleChangedMessage(RoleModel role, Group receivers) { Message message = RoleMessage.ForRole(role); message.Group = receivers; if(message != null) { this.m_Sender.Send(message); } }
private void SendQuickPollChanged( Group receivers ) { Message message; message = new PresentationInformationMessage( this.m_Presentation ); message.Group = receivers; using( Synchronizer.Lock( this.m_Presentation.SyncRoot ) ) { message.InsertChild( new QuickPollInformationMessage( this.m_Presentation.QuickPoll ) ); } this.m_Sender.Send( message ); }
public void ForceUpdate(Group receivers) { using (Synchronizer.Lock(this.Owner.SyncRoot)) { foreach (Group group in this.Tags) { if (group != null) this.SendGroupAddedMessage(group, receivers); } } }
public void ForceUpdate( Group receivers ) { using( Synchronizer.Lock( this.Owner.SyncRoot ) ) { foreach( QuickPollResultNetworkService service in this.Tags ) { if( service != null ) { this.SendPollResultInformation( service.Result, receivers ); service.ForceUpdate( receivers ); } } } }
private void SendGroupAddedMessage(Group group, Group receivers) { Message message = new ParticipantGroupAddedMessage(group); message.Group = receivers; this.m_Service.m_Sender.Send(message); }
/// <summary> /// Force this network service to resend all information that it is responsible for /// </summary> /// <param name="receivers">The group of receivers that should get the update</param> public void ForceUpdate( Group receivers ) { this.m_QuickPollResultCollectionHelper.ForceUpdate( receivers ); }
public void ForceUpdate(Group receivers) { using (Synchronizer.Lock(this.m_Participant.SyncRoot)) { if (this.Role != null) { this.SendRoleChangedMessage(this.Role, receivers); this.m_RoleNetworkService.ForceUpdate(receivers); this.m_GroupCollectionHelper.ForceUpdate(receivers); } } }