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