public ImageSheetModel(DeckModel deck, Guid id, SheetDisposition disp, Rectangle bounds, ByteArray md5, int height)
: base(id, disp, bounds, false, height)
{
this.m_MD5 = md5;
this.m_Deck = deck;
this.visible_ = true;
}
public DeckNetworkService(SendingQueue sender, PresentationModel presentation, DeckModel deck)
{
this.m_Sender = sender;
this.m_Presentation = presentation;
this.m_Deck = deck;
this.m_SlideRemovedDispatcher = new EventQueue.PropertyEventDispatcher(this.m_Sender, new PropertyEventHandler(this.HandleSlideRemoved));
this.m_SlideAddedDispatcher = new EventQueue.PropertyEventDispatcher(this.m_Sender, new PropertyEventHandler(this.HandleSlideAdded));
this.m_SlideContentAddedDispatcher = new EventQueue.PropertyEventDispatcher(this.m_Sender, new PropertyEventHandler(this.HandleSlideContentAdded));
this.m_DeckBackgroundColorChangedDispatcher = new EventQueue.PropertyEventDispatcher(this.m_Sender, new PropertyEventHandler(this.HandleDeckBackgroundColorChanged));
this.m_SlideNetworkServices = new Hashtable();
this.m_TableOfContentsNetworkService = new TableOfContentsNetworkService(this.m_Sender, this.m_Presentation, this.m_Deck);
// Lock the deck so no content can be added between registering the event listeners and calling SendAllSlidesAndContent().
using( Synchronizer.Lock(this.m_Presentation.SyncRoot) ) {
using(Synchronizer.Lock(deck.SyncRoot)) {
this.m_Deck.SlideRemoved += this.m_SlideRemovedDispatcher.Dispatcher;
this.m_Deck.SlideAdded += this.m_SlideAddedDispatcher.Dispatcher;
this.m_Deck.SlideContentAdded += this.m_SlideContentAddedDispatcher.Dispatcher;
this.m_Deck.Changed["DeckBackgroundColor"].Add(this.m_DeckBackgroundColorChangedDispatcher.Dispatcher);
this.SendAllSlidesAndContent(Group.AllParticipant);
}
}
}
public TableOfContentsNetworkService(SendingQueue sender, PresentationModel presentation, DeckModel deck)
{
this.m_Sender = sender;
this.m_Presentation = presentation;
this.m_Deck = deck;
this.m_EntriesCollectionHelper = new EntriesCollectionHelper(this);
}
/// <summary>
/// Constructs a TableOfContentMatch to marshal changes from one table of
/// contents to the other
/// </summary>
/// <param name="sender">The event quene for async calls</param>
/// <param name="srcDeck">The source deck</param>
/// <param name="destDeck">The dest deck</param>
public TableOfContentsMatch( EventQueue sender, DeckModel srcDeck, DeckModel destDeck )
{
this.m_Sender = sender;
this.m_SrcDeck = srcDeck;
this.m_DestDeck = destDeck;
this.m_SourceEntriesCollectionHelper = new EntriesCollectionHelper( this );
}
protected SheetUndoService(UndoModel undo, DeckModel deck, SlideModel slide, SheetModel sheet)
{
this.m_Undo = undo;
this.m_Deck = deck;
this.m_Slide = slide;
this.m_Sheet = sheet;
this.m_Sheet.Changed["Bounds"].Add(new PropertyEventHandler(this.HandleSheetChanged));
}
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;
}
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;
}
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 DeckMessage(DeckModel deck)
: base(deck.Id)
{
this.AddLocalRef( deck );
using(Synchronizer.Lock(deck.SyncRoot)) {
this.Group = deck.Group;
this.HumanName = deck.HumanName;
this.Disposition = deck.Disposition;
this.DeckBackgroundColor = deck.DeckBackgroundColor;
}
}
public SSSlideNetworkService(SendingQueue sender, PresentationModel presentation, DeckModel deck, SlideModel slide)
{
this.m_Sender = sender;
this.m_Presentation = presentation;
this.m_Deck = deck;
this.m_Slide = slide;
this.m_SubmissionStyleChangeDispatcher = new EventQueue.PropertyEventDispatcher( this.m_Sender, new PropertyEventHandler( this.HandleChange ) );
this.m_Slide.Changed["SubmissionStyle"].Add( this.m_SubmissionStyleChangeDispatcher.Dispatcher );
this.m_AnnotationSheetsCollectionHelper = new SSSheetsCollectionHelper(this, "AnnotationSheets", SheetMessage.SheetCollection.AnnotationSheets);
}
public DeckUndoService(EventQueue dispatcher, UndoModel undo, DeckModel deck)
{
this.m_EventQueue = dispatcher;
this.m_Undo = undo;
this.m_Deck = deck;
this.m_DeckChangedDispatcher = new EventQueue.PropertyEventDispatcher(this.m_EventQueue, new PropertyEventHandler(this.HandleDeckChanged));
this.m_Deck.Changed["HumanName"].Add(this.m_DeckChangedDispatcher.Dispatcher);
this.m_Deck.TableOfContents.Changed["Entries"].Add(this.m_DeckChangedDispatcher.Dispatcher);
this.m_EntriesCollectionHelper = new EntriesCollectionHelper(this);
}
/// <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);
}
public TextSheetUndoService(EventQueue dispatcher, UndoModel undo, DeckModel deck, SlideModel slide, TextSheetModel sheet)
: base(undo, deck, slide, sheet)
{
this.m_EventQueue = dispatcher;
this.m_SheetChangedDispatcher = new EventQueue.PropertyEventDispatcher(this.m_EventQueue, new PropertyEventHandler(this.HandleSheetChanged));
//Ignore any sheets with the Remote flag
if ((sheet.Disposition & SheetDisposition.Remote) == 0) {
this.Sheet.Changed["Text"].Add(this.m_SheetChangedDispatcher.Dispatcher);
this.Sheet.Changed["Font"].Add(this.m_SheetChangedDispatcher.Dispatcher);
}
}
public DeckSlideContentMessage(DeckModel deck, ByteArray hash)
: base(hash)
{
using(Synchronizer.Lock(deck.SyncRoot)) {
Image image = deck.GetSlideContent(hash);
if(image == null)
throw new ArgumentException("The specified ByteArray does not map to slide content in the specified deck.", "hash");
this.Target = this.Content = new ImageHashtable.ImageHashTableItem(hash, image);
this.AddLocalRef( this.Target );
}
}
/// <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);
}
}
protected override bool UpdateTarget(ReceiveContext context)
{
DeckModel deck = this.Target as DeckModel;
if(deck == null) {
this.Target = deck = new DeckModel(((Guid) this.TargetId), this.Disposition | DeckDisposition.Remote, this.HumanName);
} else {
using(Synchronizer.Lock(deck.SyncRoot)) {
deck.HumanName = this.HumanName;
}
}
using (Synchronizer.Lock(deck.SyncRoot)) {
deck.DeckBackgroundColor = this.DeckBackgroundColor;
}
return true;
}
/// <summary>
/// Construct the service
/// </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>
public SlideWebService(SendingQueue sender, PresentationModel presentation, DeckModel deck, SlideModel slide)
{
this.m_Sender = sender;
this.m_Presentation = presentation;
this.m_Deck = deck;
this.m_Slide = slide;
this.m_ChangeDispatcher = new EventQueue.PropertyEventDispatcher(this.m_Sender, new PropertyEventHandler(this.HandleChange));
this.m_Slide.Changed["Bounds"].Add(this.m_ChangeDispatcher.Dispatcher);
this.m_Slide.Changed["Zoom"].Add(this.m_ChangeDispatcher.Dispatcher);
this.m_Slide.Changed["BackgroundColor"].Add(this.m_ChangeDispatcher.Dispatcher);
this.m_Slide.Changed["BackgroundTemplate"].Add(this.m_ChangeDispatcher.Dispatcher);
this.m_ContentSheetsCollectionHelper = new SheetsCollectionHelper(this, "ContentSheets", SheetMessage.SheetCollection.ContentSheets);
this.m_AnnotationSheetsCollectionHelper = new SheetsCollectionHelper(this, "AnnotationSheets", SheetMessage.SheetCollection.AnnotationSheets);
}
public SlideUndoService(EventQueue dispatcher, UndoModel undo, DeckModel deck, SlideModel slide)
{
this.m_EventQueue = dispatcher;
this.m_Undo = undo;
this.m_Deck = deck;
this.m_Slide = slide;
this.m_SlideChangedDispatcher = new EventQueue.PropertyEventDispatcher(this.m_EventQueue, new PropertyEventHandler(this.HandleSlideChanged));
this.m_Slide.Changed["Title"].Add(this.m_SlideChangedDispatcher.Dispatcher);
this.m_Slide.Changed["Bounds"].Add(this.m_SlideChangedDispatcher.Dispatcher);
this.m_Slide.Changed["ContentSheets"].Add(this.m_SlideChangedDispatcher.Dispatcher);
this.m_Slide.Changed["AnnotationSheets"].Add(this.m_SlideChangedDispatcher.Dispatcher);
this.m_ContentSheetsCollectionHelper = new SheetsCollectionHelper(this, "ContentSheets");
this.m_AnnotationSheetsCollectionHelper = new SheetsCollectionHelper(this, "AnnotationSheets");
}
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>
/// Constructs the dialog form
/// </summary>
public SSOrganizerForm(PresenterModel m)
{
// Save the model
this.model = m;
// Get the student submission deck
if(this.model != null) {
using (Synchronizer.Lock(this.model.SyncRoot)) {
if (this.model.Workspace != null) {
using (this.model.Workspace.Lock()) {
if (~this.model.Workspace.CurrentPresentation != null) {
using (Synchronizer.Lock((~this.model.Workspace.CurrentPresentation).SyncRoot)) {
deckModel = (~this.model.Workspace.CurrentPresentation).GetStudentSubmissionDeck();
}
}
}
}
}
}
// Setup the display of the form
// Suspend the layout
this.SuspendLayout();
this.AutoScaleBaseSize = new Size(5, 13);
this.ClientSize = new System.Drawing.Size(564, 342);
this.Font = ViewerStateModel.FormFont;
this.FormBorderStyle = FormBorderStyle.Sizable;
this.MaximizeBox = true;
this.MinimumSize = new Size(220, 220);
this.Name = "SSOrganizerForm";
// TODO CMPRINCE: Need to localize this string
this.Text = "Student Submission Organizer";
// Add the child controls
SSOrganizerMainPanel mainPanel = new SSOrganizerMainPanel(this.deckModel, new Point(0, 0), new Size(564, 304), 0);
this.Controls.Add(mainPanel);
this.Controls.Add(new SSOrganizerOKButton(this.deckModel, mainPanel, new Point(182, 310), 1));
this.Controls.Add(new SSOrganizerCancelButton(new Point(300, 310), 2));
this.ResumeLayout();
}
protected DefaultDeckTraversalModel(Guid id, DeckModel deck, EntryFilterDelegate filter)
: base(id, deck)
{
this.m_HandleEntriesChangedHelperDelegate = new MethodInvoker(this.HandleEntriesChangedHelper);
this.m_HandleEntriesChangedCallbackDelegate = new AsyncCallback(this.HandleEntriesChangedCallback);
this.m_AbsCurrentSlideIndex = -1;
this.m_Parents = new Stack();
this.m_Filter = filter;
this.Deck.TableOfContents.Changed["Entries"].Add(new PropertyEventHandler(this.HandleEntriesChanged));
using (Synchronizer.Lock(this.SyncRoot)) {
using (Synchronizer.Lock(this.Deck.TableOfContents.SyncRoot)) {
this.Reset();
}
}
this.HandleEntriesChanged(this.Deck.TableOfContents, null);
}
public DeckModel Copy()
{
//should it have a new id?
string hn = "";
using (Synchronizer.Lock(this)) { hn = this.HumanName; }
DeckModel deck = new DeckModel(this.Id, this.Disposition, hn, this.TableOfContents, this.m_Slides, this.m_SlideContent, this.m_ContentToSlideLookup);
using (Synchronizer.Lock(deck)) {
using (Synchronizer.Lock(this)) {
deck.Dirty = this.Dirty;
deck.DeckBackgroundColor = this.DeckBackgroundColor;
deck.DeckBackgroundTemplate = this.DeckBackgroundTemplate;
}
}
deck.current_subs = this.current_subs;
deck.current_poll = this.current_poll;
deck.Group = this.Group;
deck.Filename = this.Filename;
return(deck);
}
public SSDeckNetworkService(SendingQueue sender, PresentationModel presentation, DeckModel deck)
{
this.m_Sender = sender;
this.m_Presentation = presentation;
this.m_Deck = deck;
this.m_SlideRemovedDispatcher = new EventQueue.PropertyEventDispatcher(this.m_Sender, new PropertyEventHandler(this.HandleSlideRemoved));
this.m_SlideAddedDispatcher = new EventQueue.PropertyEventDispatcher(this.m_Sender, new PropertyEventHandler(this.HandleSlideAdded));
this.m_SlideNetworkServices = new Hashtable();
// Lock the deck so no content can be added between registering the event listeners and calling SendAllSlidesAndContent().
using( Synchronizer.Lock(this.m_Presentation.SyncRoot) ) {
using(Synchronizer.Lock(deck.SyncRoot)) {
this.m_Deck.SlideRemoved += this.m_SlideRemovedDispatcher.Dispatcher;
this.m_Deck.SlideAdded += this.m_SlideAddedDispatcher.Dispatcher;
this.AttachAllSlides();
}
}
}
/// <summary>
/// Creates a matching between the two decks and recursively creates matchings amongst all
/// child objects
/// </summary>
/// <param name="sender">The EventQueue to invoke async things on</param>
/// <param name="srcDeck">The deck to marshal changes from</param>
/// <param name="destDeck">The deck to marshal changes to</param>
public DeckMatch( EventQueue sender, DeckModel srcDeck, DeckModel destDeck )
{
this.m_Sender = sender;
this.m_SrcDeck = srcDeck;
this.m_DestDeck = destDeck;
this.m_SlideMatches = new ArrayList();
this.m_TableOfContentsMatch = new TableOfContentsMatch( this.m_Sender, this.m_SrcDeck, this.m_DestDeck );
this.SetupInitialMappings();
this.m_SlideRemovedDispatcher = new EventQueue.PropertyEventDispatcher(this.m_Sender, new PropertyEventHandler(this.HandleSlideRemoved));
this.m_SlideAddedDispatcher = new EventQueue.PropertyEventDispatcher(this.m_Sender, new PropertyEventHandler(this.HandleSlideAdded));
this.m_SlideContentAddedDispatcher = new EventQueue.PropertyEventDispatcher(this.m_Sender, new PropertyEventHandler(this.HandleSlideContentAdded));
// Lock the deck so no content can be added between registering the event listeners.
using(Synchronizer.Lock(this.m_SrcDeck.SyncRoot)) {
this.m_SrcDeck.SlideRemoved += this.m_SlideRemovedDispatcher.Dispatcher;
this.m_SrcDeck.SlideAdded += this.m_SlideAddedDispatcher.Dispatcher;
this.m_SrcDeck.SlideContentAdded += this.m_SlideContentAddedDispatcher.Dispatcher;
}
}
/// <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 SlideDeckTraversalModel(Guid id, DeckModel deck)
: base(id, deck, new DefaultDeckTraversalModel.EntryFilterDelegate(TestEntry))
{
}
public DeckTraversalModel(Guid id, DeckModel deck)
{
this.m_Id = id;
this.m_Deck = deck;
}
public DeckTraversalModel(Guid id, DeckModel deck)
{
this.m_Id = id;
this.m_Deck = deck;
}
public SlideDeckTraversalModel(Guid id, DeckModel deck)
: base(id, deck, new DefaultDeckTraversalModel.EntryFilterDelegate(TestEntry))
{
}
public DeckModel Copy()
{
//should it have a new id?
string hn = "";
using (Synchronizer.Lock(this)) { hn = this.HumanName; }
DeckModel deck = new DeckModel(this.Id, this.Disposition, hn, this.TableOfContents, this.m_Slides, this.m_SlideContent, this.m_ContentToSlideLookup);
using (Synchronizer.Lock(deck)) {
using (Synchronizer.Lock(this)) {
deck.Dirty = this.Dirty;
deck.DeckBackgroundColor = this.DeckBackgroundColor;
}
}
deck.current_subs = this.current_subs;
deck.current_poll = this.current_poll;
deck.Group = this.Group;
deck.Filename = this.Filename;
return deck;
}
/// <summary>
/// Inserts a deck into the current deck by adding all the slides in the
/// deck. Does so by calling insertSlide method.
/// </summary>
/// <param name="deck">the original deck to be inserted into this deck</param>
public void InsertDeck(DeckModel deck)
{
using (Synchronizer.Lock(deck.SyncRoot)) {
using (Synchronizer.Lock(this.SyncRoot)) {
foreach (SlideModel s in deck.Slides) {
this.InsertSlide(s);
}
}
}
}
public ImageSheetModel(DeckModel deck, Guid id, SheetDisposition disp, Rectangle bounds, ByteArray md5, int height) : base(id, disp, bounds, false, height)
{
this.m_MD5 = md5;
this.m_Deck = deck;
this.visible_ = true;
}
