/// <summary> /// Performs a deep copy of the given SheetModel and resets the disposition to remote. /// This seems to be a little more complicated than it needs to be because the disposition is read only. /// If the given sheetmodel is an InkSheet or an editable sheet, it is copied, otherwise, it returns itself. /// </summary> /// <param name="s">The SheetModel to copy</param> /// <returns>A deep copy of an InkSheet or an Editable Sheet, otherwise, itself</returns> public static SheetModel SheetDeepRemoteCopyHelper(SheetModel s) { using (Synchronizer.Lock(s.SyncRoot)) { SheetModel t = null; // Only copy InkSheetModels if (s is InkSheetModel || s is EditableSheetModel) { if (s is RealTimeInkSheetModel) { // Make a deep copy of the SheetModel t = new RealTimeInkSheetModel(Guid.NewGuid(), s.Disposition | SheetDisposition.Remote, s.Bounds, ((RealTimeInkSheetModel)s).Ink.Clone()); using (Synchronizer.Lock(t.SyncRoot)) { ((RealTimeInkSheetModel)t).CurrentDrawingAttributes = ((RealTimeInkSheetModel)s).CurrentDrawingAttributes; } } else if (s is InkSheetModel) { // Make a deep copy of the SheetModel t = new InkSheetModel(Guid.NewGuid(), s.Disposition | SheetDisposition.Remote, s.Bounds, ((InkSheetModel)s).Ink.Clone()); } else if (s is EditableSheetModel) { t = (EditableSheetModel)((EditableSheetModel)s).CloneToRemote(); } // This is a new object so add it to the local references // TODO CMPRINCE: Make this a callback or something UW.ClassroomPresenter.Network.Messages.Message.AddLocalRef(t.Id, t); return(t); } } return(s); }
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(); }
public InkSheetMatch(EventQueue sender, InkSheetModel srcSheet, InkSheetModel dstSheet) : base(sender, srcSheet, dstSheet) { this.m_SourceSheet = srcSheet; this.m_DestSheet = dstSheet; this.m_SourceSheet.InkAdded += new StrokesEventHandler(this.HandleInkAdded); this.m_SourceSheet.InkDeleting += new StrokesEventHandler(this.HandleInkDeleting); this.SendExistingInk(); }
public InkSheetRenderer(SlideDisplayModel display, InkSheetModel sheet) : base(display, sheet) { this.m_Sheet = sheet; this.m_Renderer = new Renderer(); this.m_Sheet.Changed["Selection"].Add(new PropertyEventHandler(this.HandleSelectionChanged)); this.m_Sheet.InkAdded += new StrokesEventHandler(this.HandleInkAdded); this.m_Sheet.InkDeleted += new StrokesEventHandler(this.HandleInkDeleted); this.SlideDisplay.Changed["InkTransform"].Add(new PropertyEventHandler(this.HandleInkTransformChanged)); this.HandleInkTransformChanged(this.SlideDisplay, null); }
/// <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 InkSheetUndoService(EventQueue dispatcher, UndoModel undo, DeckModel deck, SlideModel slide, InkSheetModel sheet) : base(undo, deck, slide, sheet) { this.m_EventQueue = dispatcher; this.m_InkSheet = sheet; this.m_Ignore = new ArrayList(); //Ignore any sheets with the Remote flag if ((this.m_InkSheet.Disposition & SheetDisposition.Remote) == 0) { this.m_HandleInkChangedDelegate = new HandleInkChangedDelegate(this.HandleInkChanged); this.m_InkSheet.InkAdded += new StrokesEventHandler(this.HandleInkAdded); this.m_InkSheet.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); }
/// <summary> /// Performs a deep copy of the given SheetModel. /// If the given sheetmodel is not an InkSheet, then returns itself. /// </summary> /// <param name="s">The SheetModel to copy</param> /// <returns>The given sheetmodel if not an InkSheetModel, otherwise a deep copy of the InkSheetModel</returns> protected SheetModel InkSheetDeepCopyHelper( SheetModel s ) { using( Synchronizer.Lock( s.SyncRoot ) ) { InkSheetModel t; // Only copy InkSheetModels if( s is InkSheetModel ) { if( s is RealTimeInkSheetModel ) { // Make a deep copy of the SheetModel t = new RealTimeInkSheetModel( Guid.NewGuid(), s.Disposition | SheetDisposition.Remote, s.Bounds, ((RealTimeInkSheetModel)s).Ink.Clone() ); using( Synchronizer.Lock( t.SyncRoot ) ) { ((RealTimeInkSheetModel)t).CurrentDrawingAttributes = ((RealTimeInkSheetModel)s).CurrentDrawingAttributes; } } else { // Make a deep copy of the SheetModel t = new InkSheetModel( Guid.NewGuid(), s.Disposition, s.Bounds, ((InkSheetModel)s).Ink.Clone() ); } // This is a new object so add it to the local references Message.AddLocalRef(t.Id, t); return t; } } return s; }
protected override object SetUpMember(int index, object member) { SheetModel sheet = ((SheetModel) member); // Add the SheetMatch to the collection of matches using( Synchronizer.Lock( sheet.SyncRoot ) ) { using (Synchronizer.Lock( this.m_Owner.m_DestSlide.SyncRoot ) ) { if( sheet is RealTimeInkSheetModel ) { // Add the sheet RealTimeInkSheetModel m = new RealTimeInkSheetModel( Guid.NewGuid(), sheet.Disposition, sheet.Bounds ); this.m_Owner.m_DestSlide.AnnotationSheets.Add( m ); // Add the sheet match SheetMatch toAdd = SheetMatch.ForSheet(this.m_Owner.m_Sender, sheet, m ); this.m_Owner.m_SheetMatches.Add( toAdd ); } else if( sheet is InkSheetModel ) { // Add the sheet InkSheetModel m = new InkSheetModel( Guid.NewGuid(), sheet.Disposition, sheet.Bounds ); this.m_Owner.m_DestSlide.AnnotationSheets.Add( m ); // Add the sheet match SheetMatch toAdd = SheetMatch.ForSheet(this.m_Owner.m_Sender, sheet, m ); this.m_Owner.m_SheetMatches.Add( toAdd ); } } } return null; }
public InkSheetStrokesAddedMessage(InkSheetModel sheet, Guid slideId, SheetCollection selector, Ink ink) : base(sheet, selector) { this.SavedInks = new byte[][] { ink.Save() }; SlideId = slideId; }
public InkSheetMessage(InkSheetModel sheet, SheetCollection selector) : base(sheet, selector) { }
public InkSheetStrokesDeletingMessage(InkSheetModel sheet, SheetCollection selector, string[] strokeIds) : base(sheet, selector) { this.StrokeIds = ((string[]) strokeIds.Clone()); }
private void LoadInkIntoTarget(InkSheetModel sheet, byte[] saved, out int[] ids) { Ink restored = new Ink(); restored.Load(saved); using(Synchronizer.Lock(sheet.Ink.Strokes.SyncRoot)) { ids = new int[restored.Strokes.Count]; for(int i = 0; i < ids.Length; i++) { Stroke stroke = restored.Strokes[i]; // Remove any strokes that have the same remote Id as the new one. // Unfortunately, because the InkSheetUndoService cannot preserve stroke referential identity, // we must do a full search each time and cannot simply keep a table. if(stroke.ExtendedProperties.DoesPropertyExist(StrokeIdExtendedProperty)) { object id = stroke.ExtendedProperties[StrokeIdExtendedProperty].Data; foreach(Stroke existing in sheet.Ink.Strokes) { if(existing.ExtendedProperties.DoesPropertyExist(StrokeIdExtendedProperty)) { if(id.Equals(existing.ExtendedProperties[StrokeIdExtendedProperty].Data)) { StrokesEventArgs args = new StrokesEventArgs(new int[] { existing.Id }); sheet.OnInkDeleting(args); sheet.Ink.DeleteStroke(existing); sheet.OnInkDeleted(args); } } } } // The stroke has no association with the current Ink object. // Therefore, we have to recreate it by copying the raw packet data. // This first requires recreating the TabletPropertyDescriptionCollection, // which, for some stupid reason, must be done manually for lack of a better API. TabletPropertyDescriptionCollection properties = new TabletPropertyDescriptionCollection(); foreach(Guid property in stroke.PacketDescription) properties.Add(new TabletPropertyDescription(property, stroke.GetPacketDescriptionPropertyMetrics(property))); // Create a new stroke from the raw packet data. Stroke created = sheet.Ink.CreateStroke(stroke.GetPacketData(), properties); // Copy the DrawingAttributes and all application data // (especially the StrokesIdExtendedProperty) to the new stroke. created.DrawingAttributes = stroke.DrawingAttributes; foreach(ExtendedProperty prop in stroke.ExtendedProperties) created.ExtendedProperties.Add(prop.Id, prop.Data); ids[i] = created.Id; if (ViewerStateModel.NonStandardDpi) created.Transform(ViewerStateModel.DpiNormalizationReceiveMatrix); } } }
/// <summary> /// Performs a deep copy of the given SheetModel. /// If the given sheetmodel is an InkSheet or an editable sheet, it is copied, otherwise, it returns itself. /// </summary> /// <param name="s">The SheetModel to copy</param> /// <returns>A deep copy of an InkSheet or an Editable Sheet, otherwise, itself</returns> public static SheetModel SheetDeepCopyHelper(SheetModel s) { using (Synchronizer.Lock(s.SyncRoot)) { SheetModel t = null; // Only copy InkSheetModels if (s is InkSheetModel || s is EditableSheetModel) { if (s is RealTimeInkSheetModel) { // Make a deep copy of the SheetModel // t = new RealTimeInkSheetModel(Guid.NewGuid(), SheetDisposition.All, s.Bounds, ((RealTimeInkSheetModel)s).Ink.Clone()); t = new RealTimeInkSheetModel(Guid.NewGuid(), s.Disposition, s.Bounds, ((RealTimeInkSheetModel)s).Ink.Clone()); using (Synchronizer.Lock(t.SyncRoot)) { ((RealTimeInkSheetModel)t).CurrentDrawingAttributes = ((RealTimeInkSheetModel)s).CurrentDrawingAttributes; } } else if (s is InkSheetModel) { // Make a deep copy of the SheetModel t = new InkSheetModel(Guid.NewGuid(), s.Disposition, s.Bounds, ((InkSheetModel)s).Ink.Clone()); } else if (s is EditableSheetModel) { t = (EditableSheetModel)((EditableSheetModel)s).Clone(); } // This is a new object so add it to the local references // TODO CMPRINCE: Make this a callback or something UW.ClassroomPresenter.Network.Messages.Message.AddLocalRef(t.Id, t); return t; } } return s; }