protected override bool UpdateTarget(ReceiveContext context) { SlideModel slide = this.Parent != null ? this.Parent.Target as SlideModel : null; if (slide == null) { return(false); } DeckModel deck = this.Parent.Parent != null ? this.Parent.Parent.Target as DeckModel : null; if (deck == null) { return(false); } TableOfContentsModel.Entry entry = this.Target as TableOfContentsModel.Entry; if (entry == null) { this.Target = entry = new TableOfContentsModel.Entry(((Guid)this.TargetId), deck.TableOfContents, slide); } this.UpdatePathFromRoot(entry); return(true); }
private void InsertSlide() { ///get the index of the current slide that's selected, ///so that we can insert our blank slide there int current_slide_index; using (Synchronizer.Lock(traversal_.SyncRoot)) { current_slide_index = traversal_.AbsoluteCurrentSlideIndex; } ///if current_slide_index == -1, this means there are no slides in current deck. ///This new slide we try to insert is the first slide. if (current_slide_index < 0) { current_slide_index = 0; } // Create a blank slide SlideModel slide; using (Synchronizer.Lock(this.m_Deck.SyncRoot)) { slide = new SlideModel(Guid.NewGuid(), new LocalId(), SlideDisposition.Empty, UW.ClassroomPresenter.Viewer.ViewerForm.DEFAULT_SLIDE_BOUNDS); this.m_Deck.Dirty = true; this.m_Deck.InsertSlide(slide); } ///Insert our blank slide after the current index. This is modeled after the powerpoint ///UI using (Synchronizer.Lock(this.m_Deck.TableOfContents.SyncRoot)) { TableOfContentsModel.Entry entry = new TableOfContentsModel.Entry(Guid.NewGuid(), this.m_Deck.TableOfContents, slide); this.m_WhereTheEntriesGo.Insert(current_slide_index, entry); } }
protected override void OnClick(EventArgs e) { base.OnClick(e); // Change the name of whiteboard according to the number of it string wbname = "WhiteBoard " + (++UW.ClassroomPresenter.Viewer.ViewerForm.white_board_num).ToString(); // NOTE: This code is duplicated in DeckNavigationToolBarButtons.WhiteboardToolBarButton and DeckMessage.UpdateContext DeckModel deck = new DeckModel(Guid.NewGuid(), DeckDisposition.Whiteboard, wbname); using (Synchronizer.Lock(deck.SyncRoot)) { SlideModel slide = new SlideModel(Guid.NewGuid(), new LocalId(), SlideDisposition.Empty, UW.ClassroomPresenter.Viewer.ViewerForm.DEFAULT_SLIDE_BOUNDS); deck.InsertSlide(slide); using (Synchronizer.Lock(deck.TableOfContents.SyncRoot)) { TableOfContentsModel.Entry entry = new TableOfContentsModel.Entry(Guid.NewGuid(), deck.TableOfContents, slide); deck.TableOfContents.Entries.Add(entry); } } DeckTraversalModel traversal = new SlideDeckTraversalModel(Guid.NewGuid(), deck); using (this.m_Model.Workspace.Lock()) { if ((~this.m_Model.Workspace.CurrentPresentation) != null) { using (Synchronizer.Lock((~this.m_Model.Workspace.CurrentPresentation).SyncRoot)) { (~this.m_Model.Workspace.CurrentPresentation).DeckTraversals.Add(traversal); } } else { this.m_Model.Workspace.DeckTraversals.Add(traversal); } } }
/// <summary> /// Gets invoked when an entry is removed from the table of contents /// </summary> /// <param name="index">The index of the entry</param> /// <param name="member">The entry that was removed</param> /// <param name="tag">Unused</param> protected override void TearDownMember(int index, object member, object tag) { if (tag == null) { return; } TableOfContentsModel.Entry entry = ((TableOfContentsModel.Entry)member); // Never delete anything from the local copy, just remove the mapping from our // match state ArrayList toRemove = new ArrayList(); foreach (TableOfContentsEntryMatch match in this.m_Owner.m_TableOfContentsEntryMatches) { if (entry.Id == match.SourceEntry.Id) { toRemove.Add(match); } } foreach (TableOfContentsEntryMatch match in toRemove) { this.m_Owner.m_TableOfContentsEntryMatches.Remove(match); } }
protected override object SetUpMember(int index, object member) { TableOfContentsModel.Entry entry = ((TableOfContentsModel.Entry)member); // Return non-null so TearDownMember can know whether we succeeded. return(entry); }
private void CopySlideToPublicDeck() { ///get the index of the current slide that's selected, ///so that we can insert our blank slide there int current_slide_index; using (Synchronizer.Lock(traversal_.SyncRoot)) { current_slide_index = traversal_.AbsoluteCurrentSlideIndex - 1; } ///don't do anything if no object is selected if (current_slide_index < 0) { return; } DeckModel publicDeck = GetPublicSubmissionDeck(); // Copy slide SlideModel newSlide; using (Synchronizer.Lock(this.m_Deck.SyncRoot)) { SlideModel currentSlide = this.m_Deck.TableOfContents.Entries[current_slide_index].Slide; newSlide = CloneSlideAndSheets(currentSlide); using (Synchronizer.Lock(newSlide.SyncRoot)) { using (Synchronizer.Lock(currentSlide.SyncRoot)) { if (currentSlide.BackgroundTemplate == null) { newSlide.BackgroundTemplate = this.m_Deck.DeckBackgroundTemplate; } if (currentSlide.BackgroundColor == Color.Empty) { newSlide.BackgroundColor = this.m_Deck.DeckBackgroundColor; } } } newSlide.RemoveRemoteDisposition(); } using (Synchronizer.Lock(publicDeck.SyncRoot)) { publicDeck.Dirty = true; publicDeck.InsertSlide(newSlide); UW.ClassroomPresenter.Network.Messages.Message.AddLocalRef(newSlide.Id, newSlide); } using (Synchronizer.Lock(publicDeck.TableOfContents.SyncRoot)) { TableOfContentsModel.Entry e = new TableOfContentsModel.Entry(Guid.NewGuid(), publicDeck.TableOfContents, newSlide); publicDeck.TableOfContents.Entries.Add(e); UW.ClassroomPresenter.Network.Messages.Message.AddLocalRef(e.Id, e); } ///Insert our current slide after the current index. This is modeled after the powerpoint ///UI // using (Synchronizer.Lock(this.m_Deck.TableOfContents.SyncRoot)) { // TableOfContentsModel.Entry entry = new TableOfContentsModel.Entry(Guid.NewGuid(), this.m_Deck.TableOfContents, newSlide); // this.m_WhereTheEntriesGo.Insert(current_slide_index + 1, entry); // } }
private void InsertDeck(FileInfo file) { ///get the index of the current slide that's selected, ///so that we can insert our deck there int current_slide_index; using (Synchronizer.Lock(deck_traversal_.SyncRoot)) { current_slide_index = deck_traversal_.AbsoluteCurrentSlideIndex; } ///if current_slide_index == -1, this means there are no slides in current deck. ///This new slide we try to insert is the first slide. if (current_slide_index < 0) { current_slide_index = 0; } /// get the deck of slides to insert DeckModel deck = null; if (file.Extension == ".cp3") { deck = Decks.PPTDeckIO.OpenCP3(file); } else if (file.Extension == ".ppt") { deck = Decks.PPTDeckIO.OpenPPT(file); } else if (file.Extension == ".pptx") { deck = Decks.PPTDeckIO.OpenPPT(file); } else if (file.Extension == ".xps") { deck = Decks.XPSDeckIO.OpenXPS(file); } if (deck == null) // This should never happen, since we have filtered on extension { throw new Exception("Wrong file extension"); } else { deck_.InsertDeck(deck); } using (Synchronizer.Lock(deck.TableOfContents.SyncRoot)) { using (Synchronizer.Lock(deck_.TableOfContents.SyncRoot)) { ///insert each slide from the deck into our current deck. for (int i = 0; i < deck.TableOfContents.Entries.Count; i++) { ///create our TOC entry TableOfContentsModel.Entry entry = new TableOfContentsModel.Entry(Guid.NewGuid(), deck_.TableOfContents, deck.TableOfContents.Entries[i].Slide); ///insert it into our TOC this.m_WhereTheEntriesGo.Insert(current_slide_index + i, entry);//Natalie - should it be +1? } } } }
public static DeckModel OpenXPS(string file) { try { Misc.ProgressBarForm progressForm = new UW.ClassroomPresenter.Misc.ProgressBarForm("Opening \"" + file + "\"..."); progressForm.Show(); //Open Xps Document XpsDocument xpsDocument = null; xpsDocument = new XpsDocument(file, FileAccess.Read); //Create two DocumentPaginators for the XPS document. One is for local display, the other one is for the delivery to students. DocumentPaginator paginator = xpsDocument.GetFixedDocumentSequence().DocumentPaginator; //Create Deck Model Guid deckGuid = Guid.NewGuid(); DeckModel deck = new DeckModel(deckGuid, DeckDisposition.Empty, file); using (Synchronizer.Lock(deck.SyncRoot)) { deck.IsXpsDeck = true; //Iterate over all pages for (int i = 0; i < paginator.PageCount; i++) { DocumentPage page = paginator.GetPage(i); SlideModel newSlideModel = CreateSlide(page, deck); //Create a new Entry + reference SlideModel TableOfContentsModel.Entry newEntry = new TableOfContentsModel.Entry(Guid.NewGuid(), deck.TableOfContents, newSlideModel); //Lock the TOC using (Synchronizer.Lock(deck.TableOfContents.SyncRoot)) { //Add Entry to TOC deck.TableOfContents.Entries.Add(newEntry); } //Update the Progress Bar progressForm.UpdateProgress(0, paginator.PageCount, i + 1); } } //Close Progress Bar progressForm.Close(); return(deck); } catch (Exception e) { System.Diagnostics.Trace.WriteLine(e.ToString()); } GC.Collect(); return(null); }
protected override void TearDownMember(int index, object member, object tag) { if (tag == null) { return; } TableOfContentsModel.Entry entry = ((TableOfContentsModel.Entry)member); }
public TableOfContentsModel.Entry MarshalDestEntry(TableOfContentsModel.Entry entry) { foreach (TableOfContentsEntryMatch match in this.m_TableOfContentsEntryMatches) { if (entry.Id == match.DestEntry.Id) { return(match.SourceEntry); } } return(null); }
private void SendEntryAdded(TableOfContentsModel.Entry entry, Group receivers) { Message message, deck, slide; message = new PresentationInformationMessage(this.m_Service.m_Presentation); message.Group = receivers; message.InsertChild(deck = new DeckInformationMessage(this.m_Service.m_Deck)); deck.InsertChild(slide = new SlideInformationMessage(entry.Slide)); slide.InsertChild(new TableOfContentsEntryMessage(entry)); this.m_Service.m_Sender.Send(message); }
public TableOfContentsEntryMessage(TableOfContentsModel.Entry entry) : base(entry.Id) { this.AddLocalRef(entry); using (Synchronizer.Lock(entry.SyncRoot)) { int[] path = entry.PathFromRoot; if (path.Length < 1) { throw new ArgumentException("The entry's path is invalid; it must contain at least one index.", "path"); } this.PathFromRoot = ((int[])path.Clone()); } }
protected override bool UpdateTarget(ReceiveContext context) { TableOfContentsModel.Entry entry = this.Target as TableOfContentsModel.Entry; if (entry == null) { return(false); } ///get the deckmodel we'll be dealing with ///I think this is a very ugly way of getting it. DeckModel deck = (DeckModel)this.Parent.Parent.Target; // Locking the TableOfContents locks the entry, its parent, and everything else in the TOC. using (Synchronizer.Lock(deck.TableOfContents.SyncRoot)) { // We created the entry on the local side, so if the TOCs don't match, some message's OnReceive screwed up. // Similarly, if the entry is not a child of its parent, then it's the local OnReceive that screwed up. Debug.Assert(entry.TableOfContents == deck.TableOfContents); TableOfContentsModel.Entry parent = entry.Parent; // Note: The entry might not be a child of its parent if network messages are processed out of order, // or if weird things happen like a DeckTraversalMessage causing an entry to get created before it's // added to the table of contents. if (parent != null) { using (Synchronizer.Lock(parent.SyncRoot)) { foreach (TableOfContentsModel.Entry child in parent.Children) { if (child.Id.Equals(this.TargetId)) { parent.Children.BroadcastRemove(child); } } } } else if (deck != null) { ///remove the TOC entry we need to remove by iterating through all the TOC entries ///and comparing using a backwards loop. using (Synchronizer.Lock(deck.TableOfContents.SyncRoot)) { for (int i = deck.TableOfContents.Entries.Count - 1; i >= 0; i--) { TableOfContentsModel.Entry child = deck.TableOfContents.Entries[i]; if (child.Id.Equals(this.TargetId)) { deck.TableOfContents.Entries.BroadcastRemoveAt(i); } } } } } return(false); }
protected override object SetUpMember(int index, object member) { TableOfContentsModel.Entry entry = ((TableOfContentsModel.Entry)member); if (entry.Slide != null) { return(new SlideUndoService(this.m_UndoService.m_EventQueue, this.m_UndoService.m_Undo, this.m_UndoService.m_Deck, entry.Slide)); } else { return(null); } }
/// <summary> /// If the entry's <see cref="Entry.PathFromRoot"><c>PathFromRoot</c></see> differs from that of /// the <see cref="EntryInformation"/> record, this method removes and re-adds the entry into /// the correct location in its <see cref="TableOfContentsModel"/>. /// </summary> /// <remarks> /// This method is invoked by <see cref="UpdateEntry"/>, but <em>not</em> by <see cref="CreateEntry"/>. /// The reasoning is that <see cref="CreateEntry"/> does nothing other than instantiating the /// <see cref="TableOfContentsModel.Entry"/> object, allowing for other processing between /// the time that the entry is instantiated and when it is inserted into the <see cref="TableOfContentsModel"/>. /// </remarks> /// <param name="entry">The entry to update.</param> public void UpdatePathFromRoot(TableOfContentsModel.Entry entry) { using (Synchronizer.Lock(entry.SyncRoot)) { int[] old = entry.PathFromRoot; int[] path = this.PathFromRoot; bool changed = (old.Length != path.Length); for (int i = 0; !changed && i < path.Length; i++) { changed = (old[i] != path[i]); } if (changed) { // Remove the entry from its current parent, if any. if (entry.Parent == null) { if (entry.TableOfContents.Entries.Contains(entry)) { entry.TableOfContents.Entries.Remove(entry); } } else { entry.Parent.Children.Remove(entry); } // Insert the entry as a child of its new parent, // whether that be as a root entry of the TableOfContents // or as a child of some other entry. Debug.Assert(path.Length >= 1); if (path.Length == 1) { int index = Math.Min(entry.TableOfContents.Entries.Count, Math.Max(0, path[0])); //Natalie // entry.TableOfContents.Entries.Insert(index, entry); //entry.index = path[0]; entry.TableOfContents.Entries.BroadcastInsert(path[0], entry); } else { int[] parentPath = new int[path.Length - 1]; Array.Copy(path, 0, parentPath, 0, parentPath.Length); TableOfContentsModel.Entry parent = entry.TableOfContents[parentPath]; // FIXME: Handle the case when no parent at the specified index exists. int index = Math.Min(parent.Children.Count, Math.Max(0, path[path.Length - 1])); //Natalie - what is this? parent.Children.Insert(index, entry); } } } }
protected void LocalAddStudentSubmission(Guid g, Guid TOCEntryGuid) { using (Synchronizer.Lock(this.m_Slide.SyncRoot)) { // Only create student submissions from slides that exist on the client machine SlideModel newSlide = new SlideModel(g, new LocalId(), SlideDisposition.Remote, new Rectangle(0, 0, 0, 0)); // Update the fields of the slide using (Synchronizer.Lock(newSlide.SyncRoot)) { using (Synchronizer.Lock(this.m_Slide.SyncRoot)) { newSlide.Title = this.m_Slide.Title; newSlide.Bounds = new Rectangle(this.m_Slide.Bounds.Location, this.m_Slide.Bounds.Size); newSlide.Zoom = this.m_Slide.Zoom; newSlide.BackgroundColor = this.m_Slide.BackgroundColor; newSlide.BackgroundTemplate = this.m_Slide.BackgroundTemplate; newSlide.SubmissionSlideGuid = this.m_Slide.SubmissionSlideGuid; newSlide.SubmissionStyle = this.m_Slide.SubmissionStyle; // TODO CMPRINCE: Copy all the sheets over (Do a deep copy?) foreach (SheetModel s in this.m_Slide.ContentSheets) { newSlide.ContentSheets.Add(s); } // Make a deep copy of all the ink sheets foreach (SheetModel s in this.m_Slide.AnnotationSheets) { newSlide.AnnotationSheets.Add(UW.ClassroomPresenter.Model.Presentation.SheetModel.SheetDeepCopyHelper(s)); } } } // Add the slide to the deck DeckModel ssDeck = GetPresentationStudentSubmissionsDeck(); if (ssDeck != null) { // Add the slide itself using (Synchronizer.Lock(ssDeck.SyncRoot)) { ssDeck.InsertSlide(newSlide); Message.AddLocalRef(newSlide.Id, newSlide); } // Add an entry to the deck traversal so that we can navigate to the slide using (Synchronizer.Lock(ssDeck.TableOfContents.SyncRoot)) { TableOfContentsModel.Entry e = new TableOfContentsModel.Entry(TOCEntryGuid, ssDeck.TableOfContents, newSlide); ssDeck.TableOfContents.Entries.Add(e); Message.AddLocalRef(e.Id, e); } } } }
public void OnTableOfContentsEntryChanged(object sender, PropertyEventArgs pea) { PropertyChangeEventArgs args = (PropertyChangeEventArgs)pea; TableOfContentsModel.Entry e = (TableOfContentsModel.Entry)args.NewValue; if (e != null) { using (Synchronizer.Lock(e.SyncRoot)) { SlideModel slide = e.Slide; using (Synchronizer.Lock(slide.SyncRoot)) { m_CurrentSlideID = slide.Id; } } } }
/// <summary> /// If the current slide changes in the source deck traversal, change it to the corresponding slide in /// the destination entry. /// </summary> /// <param name="sender"></param> /// <param name="args"></param> private void HandleCurrentChanged(object sender, PropertyEventArgs args) { // Get the source table of contents entry TableOfContentsModel.Entry entry = null; using (Synchronizer.Lock(this.m_SourceDeckTraversal.SyncRoot)) { entry = this.m_SourceDeckTraversal.Current; } // Get the corresponding destination table of contents entry TableOfContentsModel.Entry destEntry = this.m_DeckMatch.TableOfContents.MarshalSrcEntry(entry); // Set the destination table of contents entry using (Synchronizer.Lock(this.m_DestDeckTraversal.SyncRoot)) { this.m_DestDeckTraversal.Current = destEntry; } }
protected override object SetUpMember(int index, object member) { TableOfContentsModel.Entry entry = ((TableOfContentsModel.Entry)member); Group receivers = Group.AllParticipant; if ((this.m_Service.m_Deck.Disposition & (DeckDisposition.StudentSubmission | DeckDisposition.QuickPoll)) != 0) { receivers = Group.Submissions; } this.SendEntryAdded(entry, receivers); // Return non-null so TearDownMember can know whether we succeeded. return(entry); }
protected override void TearDownMember(int index, object member, object tag) { if (tag == null) { return; } TableOfContentsModel.Entry entry = ((TableOfContentsModel.Entry)member); Message message, deck, slide; message = new PresentationInformationMessage(this.m_Service.m_Presentation); message.InsertChild(deck = new DeckInformationMessage(this.m_Service.m_Deck)); deck.InsertChild(slide = new SlideInformationMessage(entry.Slide)); slide.InsertChild(new TableOfContentsEntryRemovedMessage(entry)); this.m_Service.m_Sender.Send(message); }
public FilmStripSlideViewer(MultiColumnFilmStrip parent, PresenterModel model, DeckTraversalModel traversal, DeckTraversalModel previewTraversal, TableOfContentsModel.Entry entry) { this.m_Model = model; this.m_Parent = parent; this.m_DeckTraversal = traversal; this.m_Entry = entry; this.m_PreviewDeckTraversal = previewTraversal; this.BorderStyle = BorderStyle.FixedSingle; this.m_CurrentEntryChangedDispatcher = new EventQueue.PropertyEventDispatcher(this.SlideDisplay.EventQueue, new PropertyEventHandler(this.HandleCurrentEntryChanged)); this.m_EntriesChangedDispatcher = new EventQueue.PropertyEventDispatcher(this.SlideDisplay.EventQueue, new PropertyEventHandler(this.HandleEntriesChanged)); this.m_DeckBackgroundColorChangedDispatcher = new EventQueue.PropertyEventDispatcher(this.SlideDisplay.EventQueue, new PropertyEventHandler(this.HandleDeckBackgroundColorChanged)); this.m_DeckBackgroundTemplateChangedDispatcher = new EventQueue.PropertyEventDispatcher(this.SlideDisplay.EventQueue, new PropertyEventHandler(this.HandleDeckBackgroundTemplateChanged)); this.m_DeckTraversal.Changed["Current"].Add(this.m_CurrentEntryChangedDispatcher.Dispatcher); this.m_Entry.TableOfContents.Changed["Entries"].Add(this.m_EntriesChangedDispatcher.Dispatcher); using (Synchronizer.Lock(this.m_DeckTraversal.Deck.SyncRoot)) { this.m_DeckTraversal.Deck.Changed["DeckBackgroundColor"].Add(this.m_DeckBackgroundColorChangedDispatcher.Dispatcher); this.m_DeckTraversal.Deck.Changed["DeckBackgroundTemplate"].Add(this.m_DeckBackgroundTemplateChangedDispatcher.Dispatcher); this.DefaultDeckBGColor = this.m_DeckTraversal.Deck.DeckBackgroundColor; this.DefaultDeckBGTemplate = this.m_DeckTraversal.Deck.DeckBackgroundTemplate; } this.m_EntriesChangedDispatcher.Dispatcher(this.m_Entry, null); this.m_CurrentEntryChangedDispatcher.Dispatcher(this.m_DeckTraversal, null); this.m_CurrentDeckTraversalChangedDispatcher = this.m_Model.Workspace.CurrentDeckTraversal.ListenAndInitialize(this.SlideDisplay.EventQueue, delegate(Property <DeckTraversalModel> .EventArgs args) { bool old = this.m_IsCurrentDeckTraversal; using (this.m_Model.Workspace.Lock()) { this.m_IsCurrentDeckTraversal = (~this.m_Model.Workspace.CurrentDeckTraversal == this.m_DeckTraversal); } if (old != this.m_IsCurrentDeckTraversal) { // Invalidate the display to draw the new selection border. this.UpdateSelection(); } }); }
/// <summary> /// Find the current slide /// </summary> /// <param name="instructor"></param> /// <returns></returns> private Guid GetSlideID(InstructorModel instructor) { using (Synchronizer.Lock(instructor.SyncRoot)) { DeckTraversalModel dtm = instructor.CurrentDeckTraversal; if (dtm == null) { return(Guid.Empty); } using (Synchronizer.Lock(dtm.SyncRoot)) { TableOfContentsModel.Entry e = dtm.Current; using (Synchronizer.Lock(e.SyncRoot)) { SlideModel s = e.Slide; using (Synchronizer.Lock(s.SyncRoot)) { return(s.Id); } } } } }
/// <summary> /// Even though we are not an instructor, here we fake an instructor beacon message for the purpose of unicast to multicast /// bridging. /// </summary> /// <returns></returns> protected Message NonInstructorMakeBeaconMessage() { InstructorModel instructor = new InstructorModel(m_NonInstructorId); Message role = RoleMessage.ForRole(instructor); using (Synchronizer.Lock(this.m_Model.Workspace)) { if (this.m_Model.Workspace.CurrentPresentation != null) { using (Synchronizer.Lock(this.m_Model.Workspace.CurrentPresentation.SyncRoot)) { if (this.m_Model.Workspace.CurrentPresentation.Value != null) { role.InsertChild(new InstructorCurrentPresentationChangedMessage(this.m_Model.Workspace.CurrentPresentation)); } } } if (this.m_Model.Workspace.CurrentDeckTraversal != null) { using (Synchronizer.Lock(this.m_Model.Workspace.CurrentDeckTraversal.SyncRoot)) { if (this.m_Model.Workspace.CurrentDeckTraversal.Value != null) { Message traversal = new InstructorCurrentDeckTraversalChangedMessage(this.m_Model.Workspace.CurrentDeckTraversal.Value, false); Message predecessor = traversal.Predecessor; using (Synchronizer.Lock((~this.m_Model.Workspace.CurrentDeckTraversal).SyncRoot)) { using (Synchronizer.Lock((~this.m_Model.Workspace.CurrentDeckTraversal).Current.SyncRoot)) { traversal.Predecessor = new SlideInformationMessage((~this.m_Model.Workspace.CurrentDeckTraversal).Current.Slide); TableOfContentsModel.Entry entry = (~this.m_Model.Workspace.CurrentDeckTraversal).Current; if (entry != null) { traversal.Predecessor.InsertChild(new TableOfContentsEntryMessage(entry)); } traversal.Predecessor.AddOldestPredecessor(predecessor); role.InsertChild(traversal); } } } } } } return(role); }
/// <summary> /// Constructor /// </summary> /// <param name="i">The index of this entry</param> /// <param name="e">The entry this control represents</param> /// <param name="deckColor">The background color for the deck /// containing this entry</param> /// <param name="location">The location for this control</param> /// <param name="size">The size of this control</param> public SSOrganizerEntry(int i, TableOfContentsModel.Entry e, Color deckColor, PointF location, SizeF size) { this.entry = e; this.location = location; this.size = size; this.SuspendLayout(); // Create the background image this.cachedImage = this.CacheSlideImage(deckColor); this.BackgroundImage = this.cachedImage; this.BackgroundImageLayout = ImageLayout.Stretch; this.BackColor = Color.White; this.BorderStyle = BorderStyle.FixedSingle; this.ClientSize = new Size(200, 150); this.Location = new Point(i * this.Size.Width, 0); this.Anchor = AnchorStyles.Left | AnchorStyles.Top; this.ResumeLayout(); }
/// <summary> /// Draw the slide for printing. /// Note: This code first prints to an image and then to the page to allow for transparency and anti-aliasing /// </summary> /// <param name="traversal">The deck traversal to draw from</param> /// <param name="index">The slide index in the deck to draw</param> /// <param name="displayBounds">The bounds to draw the slide in</param> /// <param name="g">The graphics context to draw onto</param> private void DrawSlide3(DeckTraversalModel traversal, int index, System.Drawing.Rectangle displayBounds, System.Drawing.Graphics g) { using (Synchronizer.Lock(traversal.SyncRoot)) { using (Synchronizer.Lock(traversal.Deck.SyncRoot)) { using (Synchronizer.Lock(traversal.Deck.TableOfContents.SyncRoot)) { TableOfContentsModel.Entry currentEntry = traversal.Deck.TableOfContents.Entries[index]; // Get the background color and background template Color background = Color.Transparent; BackgroundTemplate template = null; using (Synchronizer.Lock(currentEntry.Slide.SyncRoot)) { if (currentEntry.Slide.BackgroundTemplate != null) { template = currentEntry.Slide.BackgroundTemplate; } else if (traversal.Deck.DeckBackgroundTemplate != null) { template = traversal.Deck.DeckBackgroundTemplate; } if (currentEntry.Slide.BackgroundColor != Color.Empty) { background = currentEntry.Slide.BackgroundColor; } else if (traversal.Deck.DeckBackgroundColor != Color.Empty) { background = traversal.Deck.DeckBackgroundColor; } } Bitmap toExport = PPTDeckIO.DrawSlide(currentEntry, template, background, SheetDisposition.Background | SheetDisposition.Public | SheetDisposition.Student | SheetDisposition.All); Rectangle newRect = FillUpRectangle(displayBounds, new Rectangle(0, 0, toExport.Width, toExport.Height)); this.DrawSlideBorder(index + 1, newRect, g); g.DrawImage(toExport, newRect); toExport.Dispose(); } } } }
private void DuplicateSlide() { ///get the index of the current slide that's selected, ///so that we can insert our blank slide there int current_slide_index; using (Synchronizer.Lock(traversal_.SyncRoot)) { current_slide_index = traversal_.AbsoluteCurrentSlideIndex - 1; } ///don't do anything if no object is selected if (current_slide_index < 0) { return; } // Copy slide SlideModel newSlide; using (Synchronizer.Lock(this.m_Deck.SyncRoot)) { SlideModel currentSlide = this.m_Deck.TableOfContents.Entries[current_slide_index].Slide; newSlide = CloneSlideAndSheets(currentSlide); //remove remote disposition for student submission slide; The removal may be not necessary for non-student submission slide. //If current role is non-instructor,the sheet models in slide should contain remote disposition if ((currentSlide.Disposition & SlideDisposition.StudentSubmission) != 0) { newSlide.RemoveRemoteDisposition(); } this.m_Deck.Dirty = true; this.m_Deck.InsertSlide(newSlide); } ///Insert our current slide after the current index. This is modeled after the powerpoint ///UI using (Synchronizer.Lock(this.m_Deck.TableOfContents.SyncRoot)) { TableOfContentsModel.Entry entry = new TableOfContentsModel.Entry(Guid.NewGuid(), this.m_Deck.TableOfContents, newSlide); this.m_WhereTheEntriesGo.Insert(current_slide_index + 1, entry); } }
/// <summary> /// Advance to the next slide /// <remarks> /// Code taken from the next slide toolbar button /// </remarks> /// </summary> protected void NextSlide() { using (Synchronizer.Lock(this)) { if (this.currentDeckTraversal == null) { return; } using (Synchronizer.Lock(this.currentDeckTraversal.SyncRoot)) { if (this.currentDeckTraversal.Next != null) { // Advance the slide this.currentDeckTraversal.Current = this.currentDeckTraversal.Next; } else { // Add a whiteboard slide if we are at the end of the deck using (Synchronizer.Lock(this.currentDeckTraversal.Deck.SyncRoot)) { if (((this.currentDeckTraversal.Deck.Disposition & DeckDisposition.Whiteboard) != 0) && ((this.currentDeckTraversal.Deck.Disposition & DeckDisposition.Remote) == 0)) { // Add the new slide SlideModel slide = new SlideModel(Guid.NewGuid(), new LocalId(), SlideDisposition.Empty, UW.ClassroomPresenter.Viewer.ViewerForm.DEFAULT_SLIDE_BOUNDS); this.currentDeckTraversal.Deck.InsertSlide(slide); using (Synchronizer.Lock(this.currentDeckTraversal.Deck.TableOfContents.SyncRoot)) { // Add the new table of contents entry TableOfContentsModel.Entry entry = new TableOfContentsModel.Entry(Guid.NewGuid(), this.currentDeckTraversal.Deck.TableOfContents, slide); this.currentDeckTraversal.Deck.TableOfContents.Entries.Add(entry); // Move to the slide this.currentDeckTraversal.Current = entry; } } } } } } }
protected override bool UpdateTarget(ReceiveContext context) { DeckTraversalModel traversal = this.Target as DeckTraversalModel; if (traversal == null) { return(false); } PresentationModel presentation = (this.Parent != null && this.Parent.Parent != null) ? this.Parent.Parent.Target as PresentationModel : null; if (presentation == null) { return(false); } using (Synchronizer.Lock(presentation.SyncRoot)) { if (!presentation.DeckTraversals.Contains(traversal)) { presentation.DeckTraversals.Add((DeckTraversalModel)this.Target); } } TableOfContentsModel.Entry current = (this.Predecessor != null && this.Predecessor.Child != null) ? this.Predecessor.Child.Target as TableOfContentsModel.Entry: null; if (current != null) { using (Synchronizer.Lock(current.Slide.SyncRoot)){ current.Slide.Visited = true; } using (Synchronizer.Lock(traversal.SyncRoot)) { traversal.Current = current; } } return(false); }
public void OnCurrentDeckTraversalChanged(object sender, PropertyEventArgs pea) { PropertyChangeEventArgs args = (PropertyChangeEventArgs)pea; if (m_DeckTraversal != null) { m_DeckTraversal.Changed["Current"].Remove(new PropertyEventHandler(OnTableOfContentsEntryChanged)); } m_DeckTraversal = (DeckTraversalModel)args.NewValue; if (m_DeckTraversal != null) { using (Synchronizer.Lock(m_DeckTraversal.SyncRoot)) { TableOfContentsModel.Entry e = m_DeckTraversal.Current; using (Synchronizer.Lock(e.SyncRoot)) { SlideModel s = e.Slide; using (Synchronizer.Lock(s.SyncRoot)) { m_CurrentSlideID = s.Id; } } } m_DeckTraversal.Changed["Current"].Add(new PropertyEventHandler(OnTableOfContentsEntryChanged)); } }
/// <summary> /// Gets invoked when an entry is added to the table of contents /// </summary> /// <param name="index">The index of the entry</param> /// <param name="member">The object that was added</param> /// <returns>An object</returns> protected override object SetUpMember(int index, object member) { TableOfContentsModel.Entry entry = ((TableOfContentsModel.Entry)member); // Find paired entries by their path from the root using (Synchronizer.Lock(this.m_Owner.m_DestDeck.TableOfContents.SyncRoot)) { foreach (TableOfContentsModel.Entry e in this.m_Owner.m_DestDeck.TableOfContents.Entries) { using (Synchronizer.Lock(e.SyncRoot)) { using (Synchronizer.Lock(entry.SyncRoot)) { int[] srcPath = entry.PathFromRoot; int[] destPath = e.PathFromRoot; bool bMatch = true; if (srcPath.Length == destPath.Length) { for (int i = 0; i < srcPath.Length; i++) { if (srcPath[i] != destPath[i]) { bMatch = false; } } if (bMatch) { this.m_Owner.m_TableOfContentsEntryMatches.Add(new TableOfContentsEntryMatch(entry, e)); break; } } } } } } // Return non-null so TearDownMember can know whether we succeeded. return(new object()); }