Пример #1
0
/*
 *      public DeckSlideContentMessage( DeckModel deck, ByteArray hash )
 *          : this( deck, hash, 320, 240, 32, System.Drawing.Imaging.ImageFormat.Png ) {
 *      }
 *
 *      private bool Stub() {
 *          return true;
 *      }
 *
 *      public DeckSlideContentMessage( DeckModel deck, ByteArray hash, int width, int height, int depth, System.Drawing.Imaging.ImageFormat fmt ) : 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" );
 *
 *              Image.GetThumbnailImageAbort callback = new Image.GetThumbnailImageAbort( Stub );
 *              Image small = image.GetThumbnailImage( width, height, callback, System.IntPtr.Zero );
 *              string tempFile = System.IO.Path.GetTempFileName();
 *              small.Save( tempFile, fmt );
 *              byte[] smallData = System.IO.File.ReadAllBytes( tempFile );
 *              System.IO.MemoryStream ms = new System.IO.MemoryStream( smallData );
 *              Image newSmall = Image.FromStream( ms );
 *
 *              // Cleanup Temp File
 *              this.Target = this.Content = new ImageHashtable.ImageHashTableItem( hash, newSmall );
 *              this.AddLocalRef( this.Target );
 *          }
 *      }
 */
        protected override bool UpdateTarget(ReceiveContext context)
        {
#if GENERIC_SERIALIZATION
            if (this.Content == null)
            {
                return(true);
            }
#else
            Debug.Assert(this.Content != null);
#endif
            if (this.Content.image == null)
            {
                throw new ArgumentException("The deserialized content image is null.", "Content");
            }

            this.Target = this.Content;

            DeckModel deck = this.Parent != null ? this.Parent.Target as DeckModel : null;
            if (deck != null)
            {
                using (Synchronizer.Lock(deck.SyncRoot)) {
                    // Note: If the deck already has content with this hash, nothing will happen.
                    deck.AddSlideContent(this.Content.key, this.Content.image);
                }
            }

            return(true);
        }
Пример #2
0
        /// <summary>
        /// Create a slide model from a powerpoint slide
        /// </summary>
        /// <param name="pageSetup"></param>
        /// <param name="pptpm"></param>
        /// <param name="deck"></param>
        /// <param name="tempFileCollection"></param>
        /// <param name="dirpath"></param>
        /// <param name="currentSlide"></param>
        /// <returns></returns>
        private static SlideModel CreateSlide(PowerPoint.PageSetup pageSetup, PPTPaneManagement.PPTPaneManager pptpm, DeckModel deck, TempFileCollection tempFileCollection, string dirpath, PowerPoint._Slide currentSlide)
        {
            int   slideWidth  = (int)pageSetup.SlideWidth;  //Standard = 720  => 6000
            int   slideHeight = (int)pageSetup.SlideHeight; //Standard = 540  => 4500
            float emfWidth    = slideWidth * 25 / 3;
            float emfHeight   = slideHeight * 25 / 3;

            PowerPoint.Shapes currentShapes = currentSlide.Shapes;

            List <TaggedShape> taggedShapeList = PPTDeckIO.BuildTaggedShapeList(currentShapes, pptpm);

            //Create a new SlideModel
            SlideModel newSlideModel = new SlideModel(Guid.NewGuid(), new LocalId(), SlideDisposition.Empty, new Rectangle(0, 0, slideWidth, slideHeight));

            //Lock it
            using (Synchronizer.Lock(newSlideModel.SyncRoot)) {
                //Set the slide's title
                newSlideModel.Title = PPTDeckIO.FindSlideTitle(taggedShapeList);

                PPTDeckIO.MakeShapesInvisible(currentShapes);

                //Create the Background image
                //Generate a new filename
                string filename   = PPTDeckIO.GenerateFilename();
                bool   bitmapMode = true;
                if (bitmapMode)
                {
                    filename = dirpath + "\\" + filename + ".JPG";
                    currentSlide.Export(filename, "JPG", 0, 0);

                    // Need to also export as EMF to get the size of the slide in inches
                    currentSlide.Export(filename + "_TEMP", "EMF", 0, 0);
                    tempFileCollection.AddFile(filename + "_TEMP", false);
                }
                else
                {
                    filename = dirpath + "\\" + filename + ".emf";
                    currentSlide.Export(filename, "EMF", 0, 0);
                }
                tempFileCollection.AddFile(filename, false);

                //Compute the MD5 of the BG
                FileStream fs          = new FileStream(filename, FileMode.Open, FileAccess.Read);
                MD5        md5Provider = new MD5CryptoServiceProvider();
                byte[]     md5         = md5Provider.ComputeHash(fs);
                fs.Seek(0, SeekOrigin.Begin);
                Image image = Image.FromStream(fs);
                if (bitmapMode)
                {
                    image = DisassociateBitmap(image);
                }
                fs.Close();

                // Open the EMF version if we used a bitmap to get the conversion
                if (bitmapMode)
                {
                    FileStream fsEMF     = new FileStream(filename + "_TEMP", FileMode.Open, FileAccess.Read);
                    Image      image_emf = Image.FromStream(fsEMF);
                    emfWidth  = image_emf.Width;
                    emfHeight = image_emf.Height;
                    fsEMF.Close();
                    image_emf.Dispose();
                }
                else
                {
                    emfWidth  = image.Width;
                    emfHeight = image.Height;
                }

                //Create the ImageSheet
                ImageSheetModel sheet = new ImageSheetModel(deck, Guid.NewGuid(), Model.Presentation.SheetDisposition.Background,
                                                            new Rectangle(0, 0, slideWidth, slideHeight), (ByteArray)md5, 1);
                //Add the ImageSheet to the Slide
                newSlideModel.ContentSheets.Add(sheet);
                //Add the Image+MD5 to the deck
                deck.AddSlideContent((ByteArray)md5, image);

                // Restore visibility - this makes everything visible - a bug?
                PPTDeckIO.MakeShapesVisible(currentShapes);

                List <List <TaggedShape> > layerList = PPTDeckIO.SeparateIntoLayers(taggedShapeList);

                int startHeight = 2;
                foreach (List <TaggedShape> layer in layerList)
                {
                    PPTDeckIO.ProcessLayer(layer, tempFileCollection, currentShapes, deck, newSlideModel,
                                           slideWidth / emfWidth, slideHeight / emfHeight, startHeight++);
                }

                //Add SlideModel to the deck
                deck.InsertSlide(newSlideModel);
            }
            return(newSlideModel);
        }
Пример #3
0
        /// <summary>
        /// Handle the receipt of this message
        /// </summary>
        /// <param name="context">The context of the receiver from which the message was sent</param>
        protected override bool UpdateTarget(ReceiveContext context)
        {
#if DEBUG
            // Add logging of slide change events
            string machine_name = "";
            string machine_guid = "";
            using (Synchronizer.Lock(context.Participant.SyncRoot)) {
                machine_name = context.Participant.HumanName;
                machine_guid = context.Participant.Guid.ToString();
            }

            Debug.WriteLine(string.Format("SUBMISSION RCVD ({0}): Machine -- {1}, GUID -- {2}", System.DateTime.Now.Ticks, machine_name, machine_guid));
#endif

            SlideModel slide = this.Target as SlideModel;
            // Only create student submissions from slides that exist on the client machine
            // TODO CMPRINCE: Should we create these anyway???
            if (slide != null)
            {
                // Get the student submissions deck
                DeckModel ssDeck = GetPresentationStudentSubmissionsDeck();
                if (ssDeck != null)
                {
                    // Check if this entry already exists
                    using (Synchronizer.Lock(ssDeck.TableOfContents.SyncRoot)) {
                        foreach (TableOfContentsModel.Entry ent in ssDeck.TableOfContents.Entries)
                        {
                            if (ent.Id == this.TOCEntryGuid)
                            {
                                this.Target = ent.Slide;
                                return(false);
                            }
                        }
                    }

                    // Create the new slide to add
                    SlideModel newSlide = new SlideModel(this.SlideGuid, this.LocalId, SlideDisposition.Remote | SlideDisposition.StudentSubmission, this.Bounds, (Guid)this.TargetId);
                    this.Target = newSlide;

                    // Make a list of image content sheets that need to be added to the deck.
                    List <ImageSheetModel> images = new List <ImageSheetModel>();

                    // Update the fields of the slide
                    using (Synchronizer.Lock(newSlide.SyncRoot)) {
                        using (Synchronizer.Lock(slide.SyncRoot)) {
                            newSlide.Title               = this.Title;
                            newSlide.Bounds              = this.Bounds;
                            newSlide.Zoom                = this.Zoom;
                            newSlide.BackgroundColor     = this.SlideBackgroundColor;
                            newSlide.BackgroundTemplate  = this.SlideBackgroundTemplate;
                            newSlide.SubmissionSlideGuid = this.SubmissionSlideGuid;
                            newSlide.SubmissionStyle     = this.SubmissionStyle;

                            //If the slide background is null, then update the slide background with deck setting
                            if (this.SlideBackgroundColor == Color.Empty && this.Parent is DeckInformationMessage)
                            {
                                newSlide.BackgroundColor = ((DeckInformationMessage)this.Parent).DeckBackgroundColor;
                            }
                            if (this.SlideBackgroundTemplate == null && this.Parent is DeckInformationMessage)
                            {
                                newSlide.BackgroundTemplate = ((DeckInformationMessage)this.Parent).DeckBackgroundTemplate;
                            }

                            // Copy all of the content sheets.
                            // Because ContentSheets do not change, there is no
                            // need to do a deep copy (special case for ImageSheetModels).
                            foreach (SheetModel s in slide.ContentSheets)
                            {
                                newSlide.ContentSheets.Add(s);

                                // Queue up any image content to be added the deck below.
                                ImageSheetModel ism = s as ImageSheetModel;
                                if (ism != null)
                                {
                                    images.Add(ism);
                                }
                            }

                            // Make a deep copy of all the ink sheets
                            foreach (SheetModel s in slide.AnnotationSheets)
                            {
                                SheetModel newSheet = UW.ClassroomPresenter.Model.Presentation.SheetModel.SheetDeepRemoteCopyHelper(s);
                                newSlide.AnnotationSheets.Add(newSheet);

                                // Queue up any image content to be added the deck below.
                                ImageSheetModel ism = s as ImageSheetModel;
                                if (ism != null)
                                {
                                    images.Add(ism);
                                }
                            }
                        }
                    }

                    using (Synchronizer.Lock(ssDeck.SyncRoot)) {
                        // Add the slide content to the deck.
                        foreach (ImageSheetModel ism in images)
                        {
                            Image image = ism.Image;
                            if (image == null)
                            {
                                using (Synchronizer.Lock(ism.Deck.SyncRoot))
                                    using (Synchronizer.Lock(ism.SyncRoot))
                                        image = ism.Deck.GetSlideContent(ism.MD5);
                            }
                            if (image != null)
                            {
                                ssDeck.AddSlideContent(ism.MD5, image);
                            }
                        }

                        // Add the slide to the deck.
                        ssDeck.InsertSlide(newSlide);
                        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(this.TOCEntryGuid, ssDeck.TableOfContents, newSlide);
                        ssDeck.TableOfContents.Entries.Add(e);
                        AddLocalRef(e.Id, e);
                    }
                }
            }

            // Fix Bug 803: "Erased ink and text still shows up in student submissions".
            // We've updated our target with 'newSheet', which is NOT the real target!
            // Child messages should be able to access this target, but we don't want to
            // save the 'newSheet' in the targets table.  We want to keep the original sheet.
            return(false);
        }