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;
 }
Beispiel #8
0
        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();
        }
Beispiel #24
0
        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);
        }
Beispiel #25
0
        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();
                }
            }
        }
Beispiel #27
0
        /// <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;
 }
Beispiel #31
0
 public DeckTraversalModel(Guid id, DeckModel deck)
 {
     this.m_Id   = id;
     this.m_Deck = deck;
 }
Beispiel #32
0
 public SlideDeckTraversalModel(Guid id, DeckModel deck)
     : base(id, deck, new DefaultDeckTraversalModel.EntryFilterDelegate(TestEntry))
 {
 }
Beispiel #33
0
 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;
 }
Beispiel #34
0
 /// <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);
             }
         }
     }
 }
Beispiel #35
0
 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;
 }