/// <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);
}
}
}
