class Program
    {
        static void Main(string[] args)
        {
            string DEMOPATH = @"..\..\Documents\Myppt14.pptx";
            // Retrieve the number of slides, excluding the hidden slides.
            Console.WriteLine(RetrieveNumberOfSlides(DEMOPATH, false));
            // Retrieve the number of slides, including the hidden slides.
            Console.WriteLine(RetrieveNumberOfSlides(DEMOPATH));
            Console.ReadKey();
        }
        public static int RetrieveNumberOfSlides(string fileName, bool includeHidden = true)
        {
            int slidesCount = 0;

            using (PresentationDocument doc = PresentationDocument.Open(fileName, false))
            {
                // Get the presentation part of the document.
                PresentationPart presentationPart = doc.PresentationPart;
                if (presentationPart != null)
                {
                    if (includeHidden)
                    {
                        slidesCount = presentationPart.SlideParts.Count();
                    }
                    else
                    {
                        // Each slide can include a Show property, which if hidden 
                        // will contain the value "0". The Show property may not 
                        // exist, and most likely will not, for non-hidden slides.
                        var slides = presentationPart.SlideParts.Where(
                            (s) => (s.Slide != null) &&
                              ((s.Slide.Show == null) || (s.Slide.Show.HasValue &&
                              s.Slide.Show.Value)));
                        slidesCount = slides.Count();
                    }
                }
            }
            return slidesCount;
        }

    }

class Program
    {
        static void Main(string[] args)
        {
            string DEMOPATH = @"..\..\Documents\Myppt14.pptx";
            Console.WriteLine(RetrieveNumberOfSlides(DEMOPATH));
            Console.ReadKey();
        }
        public static int RetrieveNumberOfSlides(string fileName)
        {
            //Instantiate a PresentationEx object that represents a PPTX file
            using (Presentation pres = new Presentation(fileName, FileFormat.Pptx2010))
            {

                return pres.Slides.Count;
            }
        }
    }

class Program
    {
        static void Main(string[] args)
        {
            MoveSlide(@"..\..\Documents\Myppt13.pptx", 0, 1);
        }
        // Counting the slides in the presentation.
        public static int CountSlides(string presentationFile)
        {
            // Open the presentation as read-only.
            using (PresentationDocument presentationDocument = PresentationDocument.Open(presentationFile, false))
            {
                // Pass the presentation to the next CountSlides method
                // and return the slide count.
                return CountSlides(presentationDocument);
            }
        }

        // Count the slides in the presentation.
        public static int CountSlides(PresentationDocument presentationDocument)
        {
            // Check for a null document object.
            if (presentationDocument == null)
            {
                throw new ArgumentNullException("presentationDocument");
            }

            int slidesCount = 0;

            // Get the presentation part of document.
            PresentationPart presentationPart = presentationDocument.PresentationPart;

            // Get the slide count from the SlideParts.
            if (presentationPart != null)
            {
                slidesCount = presentationPart.SlideParts.Count();
            }

            // Return the slide count to the previous method.
            return slidesCount;
        }

        // Move a slide to a different position in the slide order in the presentation.
        public static void MoveSlide(string presentationFile, int from, int to)
        {
            using (PresentationDocument presentationDocument = PresentationDocument.Open(presentationFile, true))
            {
                MoveSlide(presentationDocument, from, to);
            }
        }
        // Move a slide to a different position in the slide order in the presentation.
        public static void MoveSlide(PresentationDocument presentationDocument, int from, int to)
        {
            if (presentationDocument == null)
            {
                throw new ArgumentNullException("presentationDocument");
            }

            // Call the CountSlides method to get the number of slides in the presentation.
            int slidesCount = CountSlides(presentationDocument);

            // Verify that both from and to positions are within range and different from one another.
            if (from < 0 || from >= slidesCount)
            {
                throw new ArgumentOutOfRangeException("from");
            }

            if (to < 0 || from >= slidesCount || to == from)
            {
                throw new ArgumentOutOfRangeException("to");
            }

            // Get the presentation part from the presentation document.
            PresentationPart presentationPart = presentationDocument.PresentationPart;

            // The slide count is not zero, so the presentation must contain slides.            
            Presentation presentation = presentationPart.Presentation;
            SlideIdList slideIdList = presentation.SlideIdList;

            // Get the slide ID of the source slide.
            SlideId sourceSlide = slideIdList.ChildElements[from] as SlideId;

            SlideId targetSlide = null;

            // Identify the position of the target slide after which to move the source slide.
            if (to == 0)
            {
                targetSlide = null;
            }
            if (from < to)
            {
                targetSlide = slideIdList.ChildElements[to] as SlideId;
            }
            else
            {
                targetSlide = slideIdList.ChildElements[to - 1] as SlideId;
            }

            // Remove the source slide from its current position.
            sourceSlide.Remove();

            // Insert the source slide at its new position after the target slide.
            slideIdList.InsertAfter(sourceSlide, targetSlide);

            // Save the modified presentation.
            presentation.Save();
        }
    }

class Program
    {
        static void Main(string[] args)
        {
            MoveSlide(@"..\..\Documents\Myppt13.pptx", 0, 1);
        }
        // Move a slide to a different position in the slide order in the presentation.
        public static void MoveSlide(string presentationFile, int from, int to)
        {
            //Initialize an instances of Presentation class 
            using (Presentation pres = new Presentation(presentationFile, FileFormat.Pptx2010))
            {
                //Get the slide whose position is to be changed
                ISlide sld = pres.Slides[from];
                ISlide sld2 = pres.Slides[to];

                //Set the new position for the slide
                sld2.SlideNumber = from + 1;
                sld.SlideNumber = to + 1;

                //Save the document to disk
                pres.SaveToFile(presentationFile, FileFormat.Pptx2010);
            }
        }
    }

class Program
    {
        static void Main(string[] args)
        {
            string sourceFile = @"..\..\Documents\Myppt12.pptx";
            string targetFile = @"..\..\Documents\Myppt11.pptx";
            MoveParagraphToPresentation(sourceFile, targetFile);
        }
        // Moves a paragraph range in a TextBody shape in the source document
        // to another TextBody shape in the target document.
        public static void MoveParagraphToPresentation(string sourceFile, string targetFile)
        {
            // Open the source file as read/write.
            using (PresentationDocument sourceDoc = PresentationDocument.Open(sourceFile, true))
            {
                // Open the target file as read/write.
                using (PresentationDocument targetDoc = PresentationDocument.Open(targetFile, true))
                {
                    // Get the first slide in the source presentation.
                    SlidePart slide1 = GetFirstSlide(sourceDoc);

                    // Get the first TextBody shape in it.
                    TextBody textBody1 = slide1.Slide.Descendants().First();

                    // Get the first paragraph in the TextBody shape.
                    // Note: "Drawing" is the alias of namespace DocumentFormat.OpenXml.Drawing
                    Drawing.Paragraph p1 = textBody1.Elements().First();

                    // Get the first slide in the target presentation.
                    SlidePart slide2 = GetFirstSlide(targetDoc);

                    // Get the first TextBody shape in it.
                    TextBody textBody2 = slide2.Slide.Descendants().First();

                    // Clone the source paragraph and insert the cloned. paragraph into the target TextBody shape.
                    // Passing "true" creates a deep clone, which creates a copy of the 
                    // Paragraph object and everything directly or indirectly referenced by that object.
                    textBody2.Append(p1.CloneNode(true));

                    // Remove the source paragraph from the source file.
                    textBody1.RemoveChild(p1);

                    // Replace the removed paragraph with a placeholder.
                    textBody1.AppendChild(new Drawing.Paragraph());

                    // Save the slide in the source file.
                    slide1.Slide.Save();

                    // Save the slide in the target file.
                    slide2.Slide.Save();
                }
            }
        }

        // Get the slide part of the first slide in the presentation document.
        public static SlidePart GetFirstSlide(PresentationDocument presentationDocument)
        {
            // Get relationship ID of the first slide
            PresentationPart part = presentationDocument.PresentationPart;
            SlideId slideId = part.Presentation.SlideIdList.GetFirstChild();
            string relId = slideId.RelationshipId;

            // Get the slide part by the relationship ID.
            SlidePart slidePart = (SlidePart)part.GetPartById(relId);

            return slidePart;
        }
    }

class Program
    {
        static void Main(string[] args)
        {
            string sourceFile = @"..\..\Documents\Myppt12.pptx";
            string targetFile = @"..\..\Documents\Myppt11.pptx";
            MoveParagraphToPresentation(sourceFile, targetFile);
        }
        public static void MoveParagraphToPresentation(string sourceFile, string targetFile)
        {
            string Text = "";

            //Initialize an instances of Presentation class 
            Presentation sourcePres = new Presentation(sourceFile, FileFormat.Pptx2010);

            IShape shp = sourcePres.Slides[0].Shapes[0];
            if (shp.Placeholder != null)
            {
                //Get text from the shape
                Text = ((IAutoShape)shp).TextFrame.Text;
                ((IAutoShape)shp).TextFrame.Text = "";
            }
            Presentation destPres = new Presentation(targetFile, FileFormat.Pptx2010);
            //Access first shape in first slide
            IShape destshp = destPres.Slides[0].Shapes[0];
            if (destshp.Placeholder != null)
            {
                //Get text from placeholder
                ((IAutoShape)destshp).TextFrame.Text += Text;
            }
            destPres.SaveToFile(@"..\..\Documents\Myppt11.pptx", FileFormat.Pptx2010);
        }
    }

class Program
    {
        static void Main(string[] args)
        {
            InsertNewSlide(@"..\..\Documents\Myppt2.pptx", 1, "My new slide");
        }
        // Insert a slide into the specified presentation.
        public static void InsertNewSlide(string presentationFile, int position, string slideTitle)
        {
            // Open the source document as read/write. 
            using (PresentationDocument presentationDocument = PresentationDocument.Open(presentationFile, true))
            {
                // Pass the source document and the position and title of the slide to be inserted to the next method.
                InsertNewSlide(presentationDocument, position, slideTitle);
            }
        }

        // Insert the specified slide into the presentation at the specified position.
        public static void InsertNewSlide(PresentationDocument presentationDocument, int position, string slideTitle)
        {

            if (presentationDocument == null)
            {
                throw new ArgumentNullException("presentationDocument");
            }

            if (slideTitle == null)
            {
                throw new ArgumentNullException("slideTitle");
            }

            PresentationPart presentationPart = presentationDocument.PresentationPart;

            // Verify that the presentation is not empty.
            if (presentationPart == null)
            {
                throw new InvalidOperationException("The presentation document is empty.");
            }

            // Declare and instantiate a new slide.
            Slide slide = new Slide(new CommonSlideData(new ShapeTree()));
            uint drawingObjectId = 1;

            // Construct the slide content.            
            // Specify the non-visual properties of the new slide.
            NonVisualGroupShapeProperties nonVisualProperties = slide.CommonSlideData.ShapeTree.AppendChild(new NonVisualGroupShapeProperties());
            nonVisualProperties.NonVisualDrawingProperties = new NonVisualDrawingProperties() { Id = 1, Name = "" };
            nonVisualProperties.NonVisualGroupShapeDrawingProperties = new NonVisualGroupShapeDrawingProperties();
            nonVisualProperties.ApplicationNonVisualDrawingProperties = new ApplicationNonVisualDrawingProperties();

            // Specify the group shape properties of the new slide.
            slide.CommonSlideData.ShapeTree.AppendChild(new GroupShapeProperties());

            // Declare and instantiate the title shape of the new slide.
            Shape titleShape = slide.CommonSlideData.ShapeTree.AppendChild(new Shape());

            drawingObjectId++;

            // Specify the required shape properties for the title shape. 
            titleShape.NonVisualShapeProperties = new NonVisualShapeProperties
                (new NonVisualDrawingProperties() { Id = drawingObjectId, Name = "Title" },
                new NonVisualShapeDrawingProperties(new Drawing.ShapeLocks() { NoGrouping = true }),
                new ApplicationNonVisualDrawingProperties(new PlaceholderShape() { Type = PlaceholderValues.Title }));
            titleShape.ShapeProperties = new ShapeProperties();

            // Specify the text of the title shape.
            titleShape.TextBody = new TextBody(new Drawing.BodyProperties(),
                    new Drawing.ListStyle(),
                    new Drawing.Paragraph(new Drawing.Run(new Drawing.Text() { Text = slideTitle })));

            // Declare and instantiate the body shape of the new slide.
            Shape bodyShape = slide.CommonSlideData.ShapeTree.AppendChild(new Shape());
            drawingObjectId++;

            // Specify the required shape properties for the body shape.
            bodyShape.NonVisualShapeProperties = new NonVisualShapeProperties(new NonVisualDrawingProperties() { Id = drawingObjectId, Name = "Content Placeholder" },
                    new NonVisualShapeDrawingProperties(new Drawing.ShapeLocks() { NoGrouping = true }),
                    new ApplicationNonVisualDrawingProperties(new PlaceholderShape() { Index = 1 }));
            bodyShape.ShapeProperties = new ShapeProperties();

            // Specify the text of the body shape.
            bodyShape.TextBody = new TextBody(new Drawing.BodyProperties(),
                    new Drawing.ListStyle(),
                    new Drawing.Paragraph());

            // Create the slide part for the new slide.
            SlidePart slidePart = presentationPart.AddNewPart();

            // Save the new slide part.
            slide.Save(slidePart);

            // Modify the slide ID list in the presentation part.
            // The slide ID list should not be null.
            SlideIdList slideIdList = presentationPart.Presentation.SlideIdList;

            // Find the highest slide ID in the current list.
            uint maxSlideId = 1;
            SlideId prevSlideId = null;

            foreach (SlideId slideId in slideIdList.ChildElements)
            {
                if (slideId.Id > maxSlideId)
                {
                    maxSlideId = slideId.Id;
                }

                position--;
                if (position == 0)
                {
                    prevSlideId = slideId;
                }

            }

            maxSlideId++;

            // Get the ID of the previous slide.
            SlidePart lastSlidePart;

            if (prevSlideId != null)
            {
                lastSlidePart = (SlidePart)presentationPart.GetPartById(prevSlideId.RelationshipId);
            }
            else
            {
                lastSlidePart = (SlidePart)presentationPart.GetPartById(((SlideId)(slideIdList.ChildElements[0])).RelationshipId);
            }

            // Use the same slide layout as that of the previous slide.
            if (null != lastSlidePart.SlideLayoutPart)
            {
                slidePart.AddPart(lastSlidePart.SlideLayoutPart);
            }

            // Insert the new slide into the slide list after the previous slide.
            SlideId newSlideId = slideIdList.InsertAfter(new SlideId(), prevSlideId);
            newSlideId.Id = maxSlideId;
            newSlideId.RelationshipId = presentationPart.GetIdOfPart(slidePart);

            // Save the modified presentation.
            presentationPart.Presentation.Save();
        }

    }

class Program
    {
        static void Main(string[] args)
        {
            InsertNewSlide(@"..\..\Documents\Myppt2.pptx", 1, "My new slide");
        }
        public static void InsertNewSlide(string presentationFile, int position, string slideTitle)
        {

            //Initialize an instances of Presentation class and load the sample PowerPoint file
            Presentation presentation = new Presentation();
            presentation.LoadFromFile(presentationFile);

            //Add a new slide by position
            presentation.Slides.Insert(position);

            //Add a shape to the new slide and then add some text to the shape 
            RectangleF rect = new RectangleF(0, 0, presentation.SlideSize.Size.Width, presentation.SlideSize.Size.Height);
            IAutoShape shape = presentation.Slides[position].Shapes.AppendShape(ShapeType.Rectangle, new RectangleF(50, 150, 600, 200));
            shape.AppendTextFrame(slideTitle);

            //Save PPT document
            presentation.SaveToFile(@"..\..\Documents\result.pptx", FileFormat.Pptx2010);
        }
    }