void Application_SlideSelectionChanged(PowerPoint.SlideRange SldRange)
        {
            try
            {

                if (SldRange != null)
                {
                    if (currentlyViewed == "add")
                    {
                        try
                        {
                            addDictionaries.showSlideNumber(SldRange.SlideID.ToString(), SldRange.SlideNumber.ToString());

                        }
                        catch (System.AccessViolationException ex) { }

                    }
                    else if (currentlyViewed == "update")
                    {
                        updateDictionaries.showSlideNumber(SldRange.SlideID.ToString(), SldRange.SlideNumber.ToString());
                    }

                }
            }
            catch (AccessViolationException avEx)
            {

            }
            catch (Exception ex)
            {

            }
        }

 public void AddAutoAnimation(PowerPoint.Shape[] currentSlideShapes, PowerPoint.Shape[] nextSlideSlideShapes, int[] matchingShapeIDs)
 {
     PowerPoint.Shape indicatorShape = AddPowerPointLabsIndicator();
     ManageNonMatchingShapes(matchingShapeIDs, indicatorShape.Id);
     AnimateMatchingShapes(currentSlideShapes, nextSlideSlideShapes, matchingShapeIDs);
     indicatorShape.ZOrder(Office.MsoZOrderCmd.msoBringToFront);
 }

        public static PowerPointSlide FromSlideFactory(PowerPoint.Slide slide)
        {
            if (slide == null)
                return null;

            return new PowerPointAutoAnimateSlide(slide);
        }

        private static bool VerifyIsShapeRangeValid(PowerPoint.ShapeRange shapeRange, bool handleError)
        {
            try
            {
                if (shapeRange.Count < 1)
                {
                    ThrowErrorCode(ErrorCodeForSelectionCountZero);
                }

                if (!IsShapeForSelection(shapeRange))
                {
                    ThrowErrorCode(ErrorCodeForSelectionNonShape);
                }

                return true;
            }
            catch (Exception e)
            {
                if (handleError)
                {
                    ProcessErrorMessage(e);
                    return false;
                }

                throw;
            }
        }

 /// <summary>
 /// For `preview`
 /// </summary>
 /// <param name="slide">the temp slide to produce preview image</param>
 /// <param name="contentSlide">the slide that contains content</param>
 /// <param name="slideWidth"></param>
 /// <param name="slideHeight"></param>
 /// <param name="source"></param>
 private EffectsDesigner(PowerPoint.Slide slide, PowerPoint.Slide contentSlide, 
     float slideWidth, float slideHeight, ImageItem source)
     : base(slide)
 {
     ContentSlide = contentSlide;
     Setup(slideWidth, slideHeight, source);
 }

        private static List<PowerPoint.Shape> GetShapesFromLinesInText(PowerPointSlide currentSlide, Office.TextRange2 text, PowerPoint.Shape shape)
        {
            List<PowerPoint.Shape> shapesToAnimate = new List<PowerPoint.Shape>();

            foreach (Office.TextRange2 line in text.Lines)
            {
                PowerPoint.Shape highlightShape = currentSlide.Shapes.AddShape(
                    Office.MsoAutoShapeType.msoShapeRoundedRectangle,
                    line.BoundLeft,
                    line.BoundTop,
                    line.BoundWidth,
                    line.BoundHeight);

                highlightShape.Adjustments[1] = 0.25f;
                highlightShape.Fill.ForeColor.RGB = Utils.Graphics.ConvertColorToRgb(backgroundColor);
                highlightShape.Fill.Transparency = 0.50f;
                highlightShape.Line.Visible = Office.MsoTriState.msoFalse;
                Utils.Graphics.MoveZToJustBehind(highlightShape, shape);
                highlightShape.Name = "PPTLabsHighlightTextFragmentsShape" + Guid.NewGuid().ToString();
                highlightShape.Tags.Add("HighlightTextFragment", highlightShape.Name);
                highlightShape.Select(Office.MsoTriState.msoFalse);
                shapesToAnimate.Add(highlightShape);
            }

            return shapesToAnimate;
        }

 /**
  * Creates a new TildaShape Object from a powerpoint shape
  * @param PowerPoint.Shape
  */
 public TildaShape(PowerPoint.Shape shape, int id = 0)
 {
     this.shape = shape;
     this.scaler = Settings.Scaler();
     this.id = id;
     animations = new List<TildaAnimation>();
 }

        /// <summary>
        /// Update columns width to fit text (can only decrease size of columns!!)
        /// Looks like sometimes it doesn't work how it should.
        /// </summary>
        /// <param name="shape">Table shape</param>
        /// <param name="settings">Tabular settings (with information about columns)</param>
        /// <exception cref="ArgumentException"></exception>
        internal static void AutoFitColumn(PowerPoint.Shape shape, TabularSettings settings)
        {
            if (shape.HasTable != MsoTriState.msoTrue)
                throw new ArgumentException("Shape must have table.");

            PowerPoint.TextFrame2 frame;

            float width;

            for (int column = 1; column <= shape.Table.Columns.Count; column++)
            {
                if (settings.Columns[column - 1].alignment != 'p' || (settings.Columns[column - 1].alignment == 'p' && settings.Columns[column - 1].width == 0))
                {
                    width = 0.0f;
                    for (int row = 1; row <= shape.Table.Rows.Count; row++)
                    {
                        frame = shape.Table.Cell(row, column).Shape.TextFrame2;

                        width = Math.Max(width, frame.TextRange.BoundWidth + frame.MarginLeft + frame.MarginRight + 1);
                    }
                }
                else
                {
                    width = settings.Columns[column - 1].width;
                }

                shape.Table.Columns[column].Width = width;
            }
        }

        /// <summary>
        /// Adjust the visual width of the specified shapes to the resize factors of first
        /// selected shape's visual width.
        /// </summary>
        /// <param name="selectedShapes"></param>
        public void AdjustVisualWidthProportionally(PowerPoint.ShapeRange selectedShapes)
        {
            try
            {
                var referenceWidth = GetReferenceWidth(selectedShapes);

                if (referenceWidth <= 0 || AdjustProportionallyProportionList?.Count != selectedShapes.Count) return;

                for (int i = 1; i < AdjustProportionallyProportionList.Count; i++)
                {
                    var newWidth = referenceWidth*
                                   (AdjustProportionallyProportionList[i] / AdjustProportionallyProportionList[0]);
                    var shape = new PPShape(selectedShapes[i + 1]);
                    var anchorPoint = GetVisualAnchorPoint(shape);

                    shape.AbsoluteWidth = newWidth;
                    AlignVisualShape(shape, anchorPoint);
                }
                AdjustProportionallyProportionList = null;
            }
            catch (Exception e)
            {
                Logger.LogException(e, "AdjustVisualWidthProportionally");
            }
        }

 private void ManageNonMatchingShapes(PowerPoint.Shape shapeToZoom, PowerPoint.Shape indicatorShape)
 {
     foreach (PowerPoint.Shape sh in _slide.Shapes)
     {
         if (!sh.Equals(indicatorShape) && !sh.Equals(shapeToZoom))
         {
             if (!HasExitAnimation(sh))
             {
                 DeleteShapeAnimations(sh);
                 PowerPoint.Effect effectFade = _slide.TimeLine.MainSequence.AddEffect(sh, PowerPoint.MsoAnimEffect.msoAnimEffectFade, PowerPoint.MsoAnimateByLevel.msoAnimateLevelNone, PowerPoint.MsoAnimTriggerType.msoAnimTriggerWithPrevious);
                 effectFade.Exit = Office.MsoTriState.msoTrue;
                 effectFade.Timing.Duration = AutoAnimate.defaultDuration;
                 //fadeFlag = true;
             }
             else
             {
                 DeleteShapeAnimations(sh);
                 PowerPoint.Effect effectDisappear = null;
                 effectDisappear = _slide.TimeLine.MainSequence.AddEffect(sh, PowerPoint.MsoAnimEffect.msoAnimEffectAppear, PowerPoint.MsoAnimateByLevel.msoAnimateLevelNone, PowerPoint.MsoAnimTriggerType.msoAnimTriggerWithPrevious);
                 effectDisappear.Exit = Office.MsoTriState.msoTrue;
                 effectDisappear.Timing.Duration = 0;
             }
         }
     }
 }

        public static new PowerPointSlide FromSlideFactory(PowerPoint.Slide slide)
        {
            if (slide == null)
                return null;

            return new PowerPointMagnifiedSlide(slide);
        }

 private void CropPicture(PowerPoint.Shape picShape)
 {
     try
     {
         if (picShape.Left < 0)
         {
             picShape.PictureFormat.Crop.ShapeLeft = 0;
         }
         if (picShape.Top < 0)
         {
             picShape.PictureFormat.Crop.ShapeTop = 0;
         }
         if (picShape.Left + picShape.Width > SlideWidth)
         {
             picShape.PictureFormat.Crop.ShapeWidth = SlideWidth - picShape.Left;
         }
         if (picShape.Top + picShape.Height > SlideHeight)
         {
             picShape.PictureFormat.Crop.ShapeHeight = SlideHeight - picShape.Top;
         }
     }
     catch (Exception e)
     {
         // some kind of picture cannot be cropped
         Logger.LogException(e, "CropPicture");
     }
 }

        /// <summary>
        /// Append text with current internal formatting to the end of shape.
        /// </summary>
        /// <param name="shape">Text shape</param>
        /// <param name="text">Appended text</param>
        public void AppendText(PowerPoint.Shape shape, string text)
        {
            if (shape.HasTextFrame != MsoTriState.msoTrue)
                throw new ArgumentException("Shape must contain text frame.");

            AppendText(shape.TextFrame2.TextRange, text);
        }

        public void AddZoomToAreaAnimation(PowerPoint.Shape zoomShape)
        {
            PrepareForZoomToArea(zoomShape);
            PowerPoint.Shape shapeToZoom = null, referenceShape = null;
            if (!ZoomToArea.backgroundZoomChecked)
            {
                shapeToZoom = GetShapeToZoom(zoomShape);
                referenceShape = GetReferenceShape(shapeToZoom);
                DefaultMotionAnimation.AddDefaultMotionAnimation(this, shapeToZoom, referenceShape, 0.5f, PowerPoint.MsoAnimTriggerType.msoAnimTriggerAfterPrevious);
            }
            else
            {
                shapeToZoom = zoomSlideCroppedShapes.Duplicate()[1];
                DeleteShapeAnimations(shapeToZoom);
                PowerPointLabsGlobals.CopyShapePosition(zoomSlideCroppedShapes, ref shapeToZoom);

                referenceShape = GetReferenceShape(zoomShape);
                DefaultMotionAnimation.AddZoomToAreaMotionAnimation(this, shapeToZoom, zoomShape, referenceShape, 0.5f, PowerPoint.MsoAnimTriggerType.msoAnimTriggerAfterPrevious);
            } 

            shapeToZoom.Name = "PPTLabsMagnifyAreaSlide" + DateTime.Now.ToString("yyyyMMddHHmmssffff");
            referenceShape.Delete();
            zoomSlideCroppedShapes.Visible = Office.MsoTriState.msoFalse;
            indicatorShape.ZOrder(Office.MsoZOrderCmd.msoBringToFront);
        }

        private void PrepareForZoomToArea(PowerPoint.Shape zoomShape)
        {
            MoveMotionAnimation();

            //Delete zoom shapes and shapes with exit animations
            List<PowerPoint.Shape> shapes = _slide.Shapes.Cast<PowerPoint.Shape>().ToList();
            var matchingShapes = shapes.Where(current => (HasExitAnimation(current) || current.Equals(zoomShape)));
            foreach (PowerPoint.Shape s in matchingShapes)
                s.Delete();

            AddZoomSlideCroppedPicture();

            DeleteSlideNotes();
            DeleteSlideMedia();
            ManageSlideTransitions();
            indicatorShape = AddPowerPointLabsIndicator();

            //Add fade out effect for non-zoom shapes
            shapes = _slide.Shapes.Cast<PowerPoint.Shape>().ToList();
            matchingShapes = shapes.Where(current => (!(current.Equals(indicatorShape) || current.Equals(zoomSlideCroppedShapes))));
            foreach (PowerPoint.Shape s in matchingShapes)
            {
                DeleteShapeAnimations(s);
                if (!ZoomToArea.backgroundZoomChecked)
                {
                    PowerPoint.Effect effectFade = _slide.TimeLine.MainSequence.AddEffect(s, PowerPoint.MsoAnimEffect.msoAnimEffectFade, PowerPoint.MsoAnimateByLevel.msoAnimateLevelNone, PowerPoint.MsoAnimTriggerType.msoAnimTriggerWithPrevious);
                    effectFade.Exit = Office.MsoTriState.msoTrue;
                    effectFade.Timing.Duration = 0.25f;
                }
                else
                    s.Visible = Office.MsoTriState.msoFalse;
            }
        }

        private void CopySlides(PowerPoint.Presentation sourcePresentation, PowerPoint.Presentation destPresentation)
        {
            PowerPoint.Slides sourceSlides = sourcePresentation.Slides;
            PowerPoint.Slides destSlides = destPresentation.Slides;

            for (int i = 1; i <= sourceSlides.Count; i++)
            {
                PowerPoint.Slide slide = sourceSlides[i];
                slide.Copy();

                if (destSlides.Count > 0)
                {
                    PowerPoint.Slide destSlide = destSlides[destSlides.Count];
                    destSlide.Select();

                    Marshal.ReleaseComObject(destSlide);
                }

                PowerPoint.Application application = destSlides.Application;
                application.CommandBars.ExecuteMso("PasteSourceFormatting");
                Application.DoEvents();

                Marshal.ReleaseComObject(application);
                Marshal.ReleaseComObject(slide);
            }

            Marshal.ReleaseComObject(sourceSlides);
            Marshal.ReleaseComObject(destSlides);
        }

 private void CropPicture(PowerPoint.Shape picShape, float targetLeft, float targetTop, float targetWidth, float targetHeight)
 {
     picShape.PictureFormat.Crop.ShapeLeft = targetLeft;
     picShape.PictureFormat.Crop.ShapeTop = targetTop;
     picShape.PictureFormat.Crop.ShapeWidth = targetWidth;
     picShape.PictureFormat.Crop.ShapeHeight = targetHeight;
 }

        public void AddZoomToAreaAnimation(PowerPoint.Shape zoomShape)
        {
            PrepareForZoomToArea();

            //Create zoomed-in version of the part of the slide specified by zoom shape
            zoomSlideCroppedShapes.PictureFormat.CropLeft += zoomShape.Left;
            zoomSlideCroppedShapes.PictureFormat.CropTop += zoomShape.Top;
            zoomSlideCroppedShapes.PictureFormat.CropRight += (PowerPointPresentation.Current.SlideWidth - (zoomShape.Left + zoomShape.Width));
            zoomSlideCroppedShapes.PictureFormat.CropBottom += (PowerPointPresentation.Current.SlideHeight - (zoomShape.Top + zoomShape.Height));

            PowerPointLabsGlobals.CopyShapePosition(zoomShape, ref zoomSlideCroppedShapes);

            zoomSlideCroppedShapes.LockAspectRatio = Office.MsoTriState.msoTrue;
            if (zoomSlideCroppedShapes.Width > zoomSlideCroppedShapes.Height)
                zoomSlideCroppedShapes.Width = PowerPointPresentation.Current.SlideWidth;
            else
                zoomSlideCroppedShapes.Height = PowerPointPresentation.Current.SlideHeight;

            zoomSlideCroppedShapes.Left = (PowerPointPresentation.Current.SlideWidth / 2) - (zoomSlideCroppedShapes.Width / 2);
            zoomSlideCroppedShapes.Top = (PowerPointPresentation.Current.SlideHeight / 2) - (zoomSlideCroppedShapes.Height / 2);

            zoomSlideCroppedShapes.PictureFormat.CropLeft = 0;
            zoomSlideCroppedShapes.PictureFormat.CropTop = 0;
            zoomSlideCroppedShapes.PictureFormat.CropRight = 0;
            zoomSlideCroppedShapes.PictureFormat.CropBottom = 0;

            indicatorShape.ZOrder(Office.MsoZOrderCmd.msoBringToFront);
        }

        public static void Init(PowerPoint.Application application)
        {
            if (instance == null)
            {
                instance = new PPCopy();
                instance.Visible = false;
                try
                {
                    nextHandle = Native.SetClipboardViewer(instance.Handle);
                    isSuccessful = Native.AddClipboardFormatListener(instance.Handle);
                    //if fails to set up clipboardFormatListener, re-try 5 times
                    for (int i = 0; i < 5; i++)
                    {
                        if (isSuccessful) break;
                        isSuccessful = Native.AddClipboardFormatListener(instance.Handle);
                    }

                    handle = instance.Handle;
                    application.WindowSelectionChange += (selection) =>
                    {
                        selectedRange = selection;
                        if (!isSuccessful)
                        {
                            isSuccessful = Native.AddClipboardFormatListener(instance.Handle);
                        }
                    };
                }
                catch
                {
                    //TODO: support win XP?
                }
            }
        }

        public static new PowerPointSlide FromSlideFactory(PowerPoint.Slide slide)
        {
            if (slide == null)
                return null;

            return new PowerPointStepBackSlide(slide);
        }