public static Message RemoteForSheet(SheetModel sheet, SheetCollection collection)
{
SheetModel newModel = null;
if (sheet is ImageSheetModel)
{
newModel = sheet;
}
else if (sheet is RealTimeInkSheetModel)
{
using (Synchronizer.Lock(sheet.SyncRoot)) {
newModel = new RealTimeInkSheetModel(sheet.Id, sheet.Disposition | SheetDisposition.Remote, sheet.Bounds);
using (Synchronizer.Lock(newModel.SyncRoot))
((RealTimeInkSheetModel)newModel).CurrentDrawingAttributes = ((RealTimeInkSheetModel)sheet).CurrentDrawingAttributes;
}
}
else if (sheet is InkSheetModel)
{
newModel = sheet;
}
else if (sheet is TextSheetModel)
{
newModel = sheet;
}
else if (sheet is QuickPollSheetModel)
{
newModel = sheet;
}
else if (sheet is XPSPageSheetModel)
{
newModel = sheet;
}
return(SheetMessage.ForSheet(newModel, collection));
}
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);
}
}
public TextSheetNetworkService(SendingQueue sender, PresentationModel presentation, DeckModel deck, SlideModel slide, TextSheetModel sheet, SheetMessage.SheetCollection selector)
: base(sender, presentation, deck, slide, sheet, selector)
{
this.sheet_ = sheet;
this.sheet_.Changed["Text"].Add(new PropertyEventHandler(this.SendText));
this.sheet_.Changed["Color"].Add(new PropertyEventHandler(this.SendText));
this.sheet_.Changed["IsPublic"].Add(new PropertyEventHandler(this.SendPublic));
}
public SSSheetNetworkService(SendingQueue sender, PresentationModel presentation, DeckModel deck, SlideModel slide, SheetModel sheet, SheetMessage.SheetCollection selector)
{
this.m_Sender = sender;
this.m_Presentation = presentation;
this.m_Deck = deck;
this.m_Slide = slide;
this.m_Sheet = sheet;
this.m_Selector = selector;
}
private void HandleCurrentDrawingAttributesChanged(object sender, PropertyEventArgs args)
{
Message message, deck, slide, sheet;
message = new PresentationInformationMessage(this.Presentation);
message.InsertChild(deck = new DeckInformationMessage(this.Deck));
deck.InsertChild(slide = new SlideInformationMessage(GetSubmissionSlideModel(), false));
slide.InsertChild(sheet = SheetMessage.RemoteForSheet(this.Sheet, this.SheetCollectionSelector));
this.Sender.Send(message);
}
public SSInkSheetNetworkService(SendingQueue sender, PresentationModel presentation, DeckModel deck, SlideModel slide, InkSheetModel sheet, SheetMessage.SheetCollection selector)
: base(sender, presentation, deck, slide, sheet, selector)
{
this.m_Sheet = sheet;
this.m_Sheet.InkAdded += new StrokesEventHandler(this.HandleInkAdded);
this.m_Sheet.InkDeleting += new StrokesEventHandler(this.HandleInkDeleting);
this.SendExistingInk();
}
private void HandleInkAddedHelper(Ink extracted)
{
Message message, deck, slide, sheet;
message = new PresentationInformationMessage(this.Presentation);
message.InsertChild(deck = new DeckInformationMessage(this.Deck));
deck.InsertChild(slide = new SlideInformationMessage(GetSubmissionSlideModel(), false));
slide.InsertChild(sheet = new InkSheetStrokesAddedMessage(this.m_Sheet, (Guid)slide.TargetId, this.SheetCollectionSelector, extracted));
sheet.AddOldestPredecessor(SheetMessage.RemoteForSheet(this.m_Sheet, this.SheetCollectionSelector));
this.Sender.Send(message);
}
/// <summary>
/// Construct a listener for a generic sheet
/// </summary>
/// <param name="sender">The event queue</param>
/// <param name="presentation">The presentation</param>
/// <param name="deck">The deck</param>
/// <param name="slide">The slide</param>
/// <param name="sheet">The sheet</param>
/// <param name="selector">The collection that this is part of</param>
public SheetWebService(SendingQueue sender, PresentationModel presentation, DeckModel deck, SlideModel slide, SheetModel sheet, SheetMessage.SheetCollection selector)
{
this.m_Sender = sender;
this.m_Presentation = presentation;
this.m_Deck = deck;
this.m_Slide = slide;
this.m_Sheet = sheet;
this.m_Selector = selector;
// this.m_BoundsChangedDispatcher = new EventQueue.PropertyEventDispatcher(this.Sender, new PropertyEventHandler(this.HandleBoundsChanged));
// this.m_Sheet.Changed["Bounds"].Add(this.m_BoundsChangedDispatcher.Dispatcher);
}
protected virtual void HandleBoundsChanged(object sender, PropertyEventArgs args)
{
// Send a generic update with information about the sheet (including the new bounds).
Message message, deck, slide, sheet;
message = new PresentationInformationMessage(this.Presentation);
message.InsertChild(deck = new DeckInformationMessage(this.Deck));
deck.InsertChild(slide = new SlideInformationMessage(this.Slide));
slide.InsertChild(sheet = SheetMessage.RemoteForSheet(this.Sheet, this.SheetCollectionSelector));
using (Synchronizer.Lock(this.m_Slide.SyncRoot)) {
message.Tags = new MessageTags();
message.Tags.SlideID = this.m_Slide.Id;
}
this.Sender.Send(message);
}
/// <summary>
/// Construct the InkSheetWebService, this class listens for strokes to finish
/// and sends them across the network
/// </summary>
/// <param name="sender">The queue to use</param>
/// <param name="presentation">The presentation model</param>
/// <param name="deck">The deck model</param>
/// <param name="slide">The slide model</param>
/// <param name="sheet">The sheet model</param>
/// <param name="selector">The sheet collection we are part of</param>
public InkSheetWebService(SendingQueue sender, PresentationModel presentation, DeckModel deck, SlideModel slide, SheetModel sheet, SheetMessage.SheetCollection selector)
: base(sender, presentation, deck, slide, sheet, selector)
{
// Keep track of our sheet
this.m_Sheet = (InkSheetModel)sheet;
// Get the slide ID
using (Synchronizer.Lock(slide.SyncRoot)) {
m_SlideID = slide.Id;
}
// Set Events
this.m_Sheet.InkAdded += new StrokesEventHandler(this.HandleInkAdded);
// this.m_Sheet.InkDeleting += new StrokesEventHandler(this.HandleInkDeleting);
}
public InkSheetNetworkService(SendingQueue sender, PresentationModel presentation, DeckModel deck, SlideModel slide, InkSheetModel sheet, SheetMessage.SheetCollection selector)
: base(sender, presentation, deck, slide, sheet, selector)
{
this.m_Sheet = sheet;
using (Synchronizer.Lock(slide.SyncRoot)) {
m_SlideID = slide.Id;
}
this.m_Sheet.InkAdded += new StrokesEventHandler(this.HandleInkAdded);
this.m_Sheet.InkDeleting += new StrokesEventHandler(this.HandleInkDeleting);
Group receivers = Group.AllParticipant;
if( (deck.Disposition & (DeckDisposition.StudentSubmission | DeckDisposition.QuickPoll)) != 0 ) {
receivers = Group.Submissions;
}
this.SendExistingInk(receivers);
}
public RealTimeInkSheetNetworkService(SendingQueue sender, PresentationModel presentation, DeckModel deck, SlideModel slide, RealTimeInkSheetModel sheet, SheetMessage.SheetCollection selector)
: base(sender, presentation, deck, slide, sheet, selector)
{
this.m_Sheet = sheet;
using (Synchronizer.Lock(slide.SyncRoot)) {
m_SlideID = slide.Id;
}
this.PacketBuffers = new Dictionary<int, List<int>>();
this.PacketFlushTimes = new Dictionary<int, long>();
this.m_CurrentDrawingAttributesChangedDispatcher = new EventQueue.PropertyEventDispatcher(this.Sender, new PropertyEventHandler(this.HandleCurrentDrawingAttributesChanged));
this.m_Sheet.Changed["CurrentDrawingAttributes"].Add(this.m_CurrentDrawingAttributesChangedDispatcher.Dispatcher);
this.m_Sheet.StylusUp += new RealTimeInkSheetModel.StylusUpEventHandler(this.HandleStylusUp);
this.m_Sheet.Packets += new RealTimeInkSheetModel.PacketsEventHandler(this.HandlePackets);
this.m_Sheet.StylusDown += new RealTimeInkSheetModel.StylusDownEventHandler(this.HandleStylusDown);
}
/// <summary>
/// Construct the appropriate sheet web service
/// </summary>
/// <param name="sender">The queue</param>
/// <param name="presentation">The presentation</param>
/// <param name="deck">The deck</param>
/// <param name="slide">The slide</param>
/// <param name="sheet">The sheet</param>
/// <param name="selector">The sheet collection type</param>
/// <returns>A sheet web service appropriate for the sheet model</returns>
public static SheetWebService ForSheet(SendingQueue sender, PresentationModel presentation, DeckModel deck, SlideModel slide, SheetModel sheet, SheetMessage.SheetCollection selector)
{
if (sheet is InkSheetModel) {
return new InkSheetWebService( sender, presentation, deck, slide, sheet, selector );
} else {
return new SheetWebService( sender, presentation, deck, slide, sheet, selector );
}
}
public SheetsCollectionHelper(SlideNetworkService service, string property, SheetMessage.SheetCollection selector)
: base(service.m_Sender, service.m_Slide, property)
{
this.m_Service = service;
this.m_Selector = selector;
base.Initialize();
}
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);
}
protected Guid SendStudentSubmission()
{
Guid newSlideGuid = Guid.Empty;
UW.ClassroomPresenter.Network.Messages.Message pres, deck, slide, sheet;
// Add the presentation
if (this.Presentation == null)
{
return(Guid.Empty);
}
pres = new PresentationInformationMessage(this.Presentation);
pres.Group = Groups.Group.Submissions;
//Add the current deck model that corresponds to this slide deck at the remote location
deck = new DeckInformationMessage(this.Deck);
deck.Group = Groups.Group.Submissions;
pres.InsertChild(deck);
// Add the Slide Message
newSlideGuid = Guid.NewGuid();
slide = new StudentSubmissionSlideInformationMessage(this.Slide, newSlideGuid, Guid.NewGuid());
slide.Group = Groups.Group.Submissions;
deck.InsertChild(slide);
// Find the correct user ink layer to send
RealTimeInkSheetModel m_Sheet = null;
using (Synchronizer.Lock(this.Slide.SyncRoot)) {
foreach (SheetModel s in this.Slide.AnnotationSheets)
{
if (s is RealTimeInkSheetModel && (s.Disposition & SheetDisposition.Remote) == 0)
{
m_Sheet = (RealTimeInkSheetModel)s;
break;
}
}
}
// Find the existing ink on the slide
Microsoft.Ink.Ink extracted;
using (Synchronizer.Lock(m_Sheet.Ink.Strokes.SyncRoot)) {
// Ensure that each stroke has a Guid which will uniquely identify it on the remote side
foreach (Microsoft.Ink.Stroke stroke in m_Sheet.Ink.Strokes)
{
if (!stroke.ExtendedProperties.DoesPropertyExist(InkSheetMessage.StrokeIdExtendedProperty))
{
stroke.ExtendedProperties.Add(InkSheetMessage.StrokeIdExtendedProperty, Guid.NewGuid().ToString());
}
}
// Extract all of the strokes
extracted = m_Sheet.Ink.ExtractStrokes(m_Sheet.Ink.Strokes, Microsoft.Ink.ExtractFlags.CopyFromOriginal);
}
// Find the Realtime ink on the slide
RealTimeInkSheetModel newSheet = null;
using (Synchronizer.Lock(m_Sheet.SyncRoot)) {
newSheet = new RealTimeInkSheetModel(Guid.NewGuid(), m_Sheet.Disposition | SheetDisposition.Remote, m_Sheet.Bounds);
using (Synchronizer.Lock(newSheet.SyncRoot)) {
newSheet.CurrentDrawingAttributes = m_Sheet.CurrentDrawingAttributes;
}
}
// Add the Sheet Message for the existing
sheet = new InkSheetStrokesAddedMessage(newSheet, (Guid)slide.TargetId, SheetMessage.SheetCollection.AnnotationSheets, extracted);
sheet.Group = Groups.Group.Submissions;
slide.InsertChild(sheet);
// Add the Sheet Message for the real-time ink
sheet = SheetMessage.ForSheet(newSheet, SheetMessage.SheetCollection.AnnotationSheets);
sheet.Group = Groups.Group.Submissions;
slide.AddOldestPredecessor(sheet);
// Send the message
this.m_Sender.Send(pres);
return(newSlideGuid);
}
public RealTimeInkSheetInformationMessage(RealTimeInkSheetModel sheet, SheetMessage.SheetCollection collection)
: base(sheet, collection)
{
}
public static SheetNetworkService ForSheet(SendingQueue sender, PresentationModel presentation, DeckModel deck, SlideModel slide, SheetModel sheet, SheetMessage.SheetCollection selector)
{
if(sheet is RealTimeInkSheetModel) {
return new RealTimeInkSheetNetworkService(sender, presentation, deck, slide, ((RealTimeInkSheetModel) sheet), selector);
} else if(sheet is InkSheetModel) {
return new InkSheetNetworkService(sender, presentation, deck, slide, ((InkSheetModel) sheet), selector);
} else if(sheet is ImageSheetModel) {
return new ImageSheetNetworkService(sender, presentation, deck, slide, ((ImageSheetModel)sheet), selector);
} else if(sheet is TextSheetModel) {
return new TextSheetNetworkService(sender, presentation, deck, slide, ((TextSheetModel)sheet), selector);
} else if(sheet is QuickPollSheetModel) {
return new QuickPollSheetNetworkService( sender, presentation, deck, slide, ((QuickPollSheetModel)sheet), selector );
} else {
return null;
}
}
public RealTimeInkSheetMessage(RealTimeInkSheetModel sheet, SheetMessage.SheetCollection collection)
: base(sheet, collection)
{
using(Synchronizer.Lock(sheet.SyncRoot)) {
this.CurrentDrawingAttributes = sheet.CurrentDrawingAttributes == null ? null
: new DrawingAttributesSerializer(sheet.CurrentDrawingAttributes);
}
}
public ImageSheetNetworkService(SendingQueue sender, PresentationModel presentation, DeckModel deck, SlideModel slide, ImageSheetModel sheet, SheetMessage.SheetCollection selector)
: base(sender, presentation, deck, slide, sheet, selector)
{
this.sheet_ = sheet;
this.m_SlideModel = slide;
}
