using Compdfkit_Tools.Data; using Compdfkit_Tools.PDFControlUI; using System; using System.Collections.Generic; using System.Windows; using System.Windows.Controls; using System.Windows.Media.Imaging; using Compdfkit_Tools.Annotation.PDFAnnotationPanel.PDFAnnotationUI; using System.IO; using System.Windows.Ink; using Compdfkit_Tools.Annotation.PDFAnnotationUI; using Microsoft.Win32; using System.Windows.Media; using Compdfkit_Tools.Properties; using static ComPDFKit.Tool.CPDFToolManager; using ComPDFKit.PDFAnnotation; using ComPDFKit.Tool; using ComPDFKit.Tool.Help; using ComPDFKit.Tool.SettingParam; using ComPDFKit.Import; using ComPDFKitViewer.BaseObject; using ComPDFKitViewer.Helper; using ComPDFKit.Viewer.Helper; namespace Compdfkit_Tools.PDFControl { public partial class CPDFAnnotationControl : UserControl { private bool isTempPanel = false; private CPDFAnnotationType currentAnnotationType = CPDFAnnotationType.Unknown; private PDFViewControl pdfViewerControl; private UIElement annotationPanel = null; private UIElement tempAnnotationPanel = null; private CPDFMarkupUI pdfHighlightUI; private CPDFMarkupUI pdfUnderlineUI; private CPDFMarkupUI pdfSquigglyUI; private CPDFMarkupUI pdfStrikeoutUI; private CPDFShapeUI pdfSquareUI; private CPDFShapeUI pdfCircleUI; private CPDFShapeUI pdfLineUI; private CPDFShapeUI pdfArrowUI; private CPDFFreehandUI pdfFreehandUI; private CPDFFreeTextUI pdfFreeTextUI; private CPDFNoteUI pdfNoteUI; private CPDFStampUI pdfStampUI; private CPDFSignatureUI pdfSignatureUI; private CPDFLinkUI pdfLinkUI; private bool disableClean; public event EventHandler ClearAnnotationBar; public CPDFAnnotationControl() { InitializeComponent(); } public void SetPDFViewer(PDFViewControl pdfViewer) { if (this.pdfViewerControl != null) { UnLoadPDFViewHandler(); } this.pdfViewerControl = pdfViewer; LoadPDFViewHandler(); } public void LoadPDFViewHandler() { if (this.pdfViewerControl != null) { pdfViewerControl.MouseLeftButtonDownHandler -= PDFToolManager_MouseLeftButtonDownHandler; pdfViewerControl.MouseLeftButtonDownHandler += PDFToolManager_MouseLeftButtonDownHandler; pdfViewerControl.MouseLeftButtonUpHandler -= PdfViewerControl_MouseLeftButtonUpHandler; pdfViewerControl.MouseLeftButtonUpHandler += PdfViewerControl_MouseLeftButtonUpHandler; //this.pdfViewerControl.AnnotActiveHandler += PDFViewer_AnnotActiveHandler; //this.pdfViewerControl.AnnotEditHandler -= PdfViewer_AnnotEditHandler; //this.pdfViewerControl.AnnotEditHandler += PdfViewer_AnnotEditHandler; pdfViewerControl.MouseRightButtonDownHandler -= PDFViewControl_MouseRightButtonDownHandler; pdfViewerControl.MouseRightButtonDownHandler += PDFViewControl_MouseRightButtonDownHandler; } } private void PDFViewControl_MouseRightButtonDownHandler(object sender, MouseEventObject e) { //throw new NotImplementedException(); } private void PdfViewerControl_MouseLeftButtonUpHandler(object sender, MouseEventObject e) { if (e.IsCreate) { pdfViewerControl.UpdateAnnotFrame(); if (currentAnnotationType == CPDFAnnotationType.Image || currentAnnotationType == CPDFAnnotationType.Stamp || currentAnnotationType == CPDFAnnotationType.Signature) { pdfViewerControl.SetToolType(ToolType.Pan); pdfViewerControl.SetIsVisibleCustomMouse(false); pdfViewerControl.SetIsShowStampMouse(false); } } } //private void PdfViewer_AnnotEditHandler(object sender, List e) //{ // if (e != null && e.Count > 0) // { // if (e[0].EditAction == ActionType.Del) // { // if (pdfViewerControl.MouseMode == MouseModes.AnnotCreate && pdfViewerControl.ToolManager.CurrentAnnotArgs is EraseArgs) // { // return; // } // SetAnnotEventData(null); // } // if (e[0].EditAction == ActionType.Modify && e[0].EditAnnotArgs != null && e[0].EditAnnotArgs.EventType == AnnotArgsType.AnnotSticky) // { // CPDFNoteUI tempUI = annotationPanel as CPDFNoteUI; // if (tempUI == null || tempUI.annotAttribEvent == null) // { // tempUI = tempAnnotationPanel as CPDFNoteUI; // } // if (tempUI == null || tempUI.annotAttribEvent == null) // { // tempUI = pdfNoteUI; // } // if (tempUI != null && tempUI.annotAttribEvent != null) // { // AnnotAttribEvent oldEvent = tempUI.annotAttribEvent; // oldEvent.Attribs[AnnotAttrib.NoteText] = e[0].EditAnnotArgs.Content; // tempUI.SetPresentAnnotAttrib(oldEvent); // } // } // if (e[0].EditAction == ActionType.Add && e[0].EditAnnotArgs.EventType == AnnotArgsType.AnnotStamp) // { // pdfViewerControl.SetMouseMode(MouseModes.PanTool); // } // } //} public void UnLoadPDFViewHandler() { if (this.pdfViewerControl != null) { pdfViewerControl.MouseLeftButtonDownHandler -= PDFToolManager_MouseLeftButtonDownHandler; } } private void AnnotationControl_Loaded(object sender, RoutedEventArgs e) { LoadPDFViewHandler(); } private void AnnotationControl_Unloaded(object sender, RoutedEventArgs e) { UnLoadPDFViewHandler(); } private UIElement GetAnnotationPanel() { return AnnotationPanelContainer.Child; } private void SetAnnotationPanel(UIElement newChild) { AnnotationPanelContainer.Child = newChild; } private void ExpandPanel() { AnnotationPanelContainer.Visibility = Visibility.Visible; } private void ChangeAnnotationData() { switch (currentAnnotationType) { case CPDFAnnotationType.Highlight: case CPDFAnnotationType.Underline: case CPDFAnnotationType.Squiggly: case CPDFAnnotationType.Strikeout: (annotationPanel as CPDFMarkupUI).PropertyChanged -= CPDFAnnotationControl_PropertyChanged; (annotationPanel as CPDFMarkupUI).PropertyChanged += CPDFAnnotationControl_PropertyChanged; SetAnnotationProperty((annotationPanel as CPDFMarkupUI).GetMarkupData()); break; case CPDFAnnotationType.Square: case CPDFAnnotationType.Circle: case CPDFAnnotationType.Line: case CPDFAnnotationType.Arrow: (annotationPanel as CPDFShapeUI).PropertyChanged -= CPDFAnnotationControl_PropertyChanged; (annotationPanel as CPDFShapeUI).PropertyChanged += CPDFAnnotationControl_PropertyChanged; SetAnnotationProperty((annotationPanel as CPDFShapeUI).GetShapeData()); break; case CPDFAnnotationType.Note: (annotationPanel as CPDFNoteUI).PropertyChanged -= CPDFAnnotationControl_PropertyChanged; (annotationPanel as CPDFNoteUI).PropertyChanged += CPDFAnnotationControl_PropertyChanged; SetAnnotationProperty((annotationPanel as CPDFNoteUI).GetNoteData()); break; case CPDFAnnotationType.Freehand: (annotationPanel as CPDFFreehandUI).PropertyChanged -= CPDFAnnotationControl_PropertyChanged; (annotationPanel as CPDFFreehandUI).PropertyChanged += CPDFAnnotationControl_PropertyChanged; SetAnnotationProperty((annotationPanel as CPDFFreehandUI).GetFreehandData()); break; case CPDFAnnotationType.FreeText: (annotationPanel as CPDFFreeTextUI).PropertyChanged -= CPDFAnnotationControl_PropertyChanged; (annotationPanel as CPDFFreeTextUI).PropertyChanged += CPDFAnnotationControl_PropertyChanged; SetAnnotationProperty((annotationPanel as CPDFFreeTextUI).GetFreeTextData()); break; case CPDFAnnotationType.Stamp: (annotationPanel as CPDFStampUI).PropertyChanged -= CPDFAnnotationControl_PropertyChanged; (annotationPanel as CPDFStampUI).PropertyChanged += CPDFAnnotationControl_PropertyChanged; break; case CPDFAnnotationType.Signature: (annotationPanel as CPDFSignatureUI).PropertyChanged -= CPDFAnnotationControl_PropertyChanged; (annotationPanel as CPDFSignatureUI).PropertyChanged += CPDFAnnotationControl_PropertyChanged; break; default: break; } } private void SetAnnotationProperty(CPDFAnnotationData pdfAnnotationData = null) { if (pdfAnnotationData == null) { pdfViewerControl.SetToolType(ToolType.Pan); pdfViewerControl.SetIsShowStampMouse(false); pdfViewerControl.SetIsVisibleCustomMouse(false); return; } CPDFAnnotationType annotationType = pdfAnnotationData.AnnotationType; AnnotParam annotHandlerEventArgs = null; pdfViewerControl.SetToolType(ToolType.CreateAnnot); switch (annotationType) { case CPDFAnnotationType.Highlight: { CPDFMarkupData highlightData = pdfAnnotationData as CPDFMarkupData; annotHandlerEventArgs = new HighlightParam(); byte[] Color = new byte[] { highlightData.Color.R, highlightData.Color.G, highlightData.Color.B }; annotHandlerEventArgs.CurrentType = C_ANNOTATION_TYPE.C_ANNOTATION_HIGHLIGHT; (annotHandlerEventArgs as HighlightParam).HighlightColor = Color; (annotHandlerEventArgs as HighlightParam).Transparency = Convert.ToByte(highlightData.Opacity * 255); (annotHandlerEventArgs as HighlightParam).Content = highlightData.Note; (annotHandlerEventArgs as HighlightParam).Author = CPDFMarkupData.Author; (annotHandlerEventArgs as HighlightParam).Locked = highlightData.IsLocked; pdfViewerControl.SetCreateAnnotType(C_ANNOTATION_TYPE.C_ANNOTATION_HIGHLIGHT); } break; case CPDFAnnotationType.Underline: { CPDFMarkupData underlineData = pdfAnnotationData as CPDFMarkupData; annotHandlerEventArgs = new UnderlineParam(); byte[] Color = new byte[] { underlineData.Color.R, underlineData.Color.G, underlineData.Color.B }; annotHandlerEventArgs.CurrentType = C_ANNOTATION_TYPE.C_ANNOTATION_UNDERLINE; (annotHandlerEventArgs as UnderlineParam).UnderlineColor = Color; (annotHandlerEventArgs as UnderlineParam).Transparency = Convert.ToByte(underlineData.Opacity * 255); (annotHandlerEventArgs as UnderlineParam).Author = CPDFMarkupData.Author; (annotHandlerEventArgs as UnderlineParam).Content = underlineData.Note; (annotHandlerEventArgs as UnderlineParam).Locked = underlineData.IsLocked; pdfViewerControl.SetCreateAnnotType(C_ANNOTATION_TYPE.C_ANNOTATION_UNDERLINE); } break; case CPDFAnnotationType.Strikeout: { CPDFMarkupData strikeoutData = pdfAnnotationData as CPDFMarkupData; annotHandlerEventArgs = new StrikeoutParam(); byte[] Color = new byte[] { strikeoutData.Color.R, strikeoutData.Color.G, strikeoutData.Color.B }; annotHandlerEventArgs.CurrentType = C_ANNOTATION_TYPE.C_ANNOTATION_STRIKEOUT; (annotHandlerEventArgs as StrikeoutParam).StrikeoutColor = Color; (annotHandlerEventArgs as StrikeoutParam).Transparency = Convert.ToByte(strikeoutData.Opacity * 255); (annotHandlerEventArgs as StrikeoutParam).Locked = strikeoutData.IsLocked; (annotHandlerEventArgs as StrikeoutParam).Author = CPDFMarkupData.Author; (annotHandlerEventArgs as StrikeoutParam).Content = strikeoutData.Note; pdfViewerControl.SetCreateAnnotType(C_ANNOTATION_TYPE.C_ANNOTATION_STRIKEOUT); } break; case CPDFAnnotationType.Squiggly: { CPDFMarkupData squigglyData = pdfAnnotationData as CPDFMarkupData; annotHandlerEventArgs = new SquigglyParam(); byte[] Color = new byte[] { squigglyData.Color.R, squigglyData.Color.G, squigglyData.Color.B }; annotHandlerEventArgs.CurrentType = C_ANNOTATION_TYPE.C_ANNOTATION_SQUIGGLY; (annotHandlerEventArgs as SquigglyParam).SquigglyColor = Color; (annotHandlerEventArgs as SquigglyParam).Transparency = Convert.ToByte(squigglyData.Opacity * 255); (annotHandlerEventArgs as SquigglyParam).Locked = squigglyData.IsLocked; (annotHandlerEventArgs as SquigglyParam).Author = CPDFMarkupData.Author; (annotHandlerEventArgs as SquigglyParam).Content = squigglyData.Note; pdfViewerControl.SetCreateAnnotType(C_ANNOTATION_TYPE.C_ANNOTATION_SQUIGGLY); } break; case CPDFAnnotationType.Square: { CPDFShapeData squareData = pdfAnnotationData as CPDFShapeData; annotHandlerEventArgs = new SquareParam(); annotHandlerEventArgs.CurrentType = C_ANNOTATION_TYPE.C_ANNOTATION_SQUARE; byte[] LineColor = new byte[] { squareData.BorderColor.R, squareData.BorderColor.G, squareData.BorderColor.B }; (annotHandlerEventArgs as SquareParam).LineColor = LineColor; if (squareData.FillColor != Colors.Transparent) { byte[] FillColor = new byte[] { squareData.FillColor.R, squareData.FillColor.G, squareData.FillColor.B }; (annotHandlerEventArgs as SquareParam).BgColor = FillColor; (annotHandlerEventArgs as SquareParam).HasBgColor = true; } (annotHandlerEventArgs as SquareParam).LineWidth = squareData.Thickness; (annotHandlerEventArgs as SquareParam).Transparency = Convert.ToByte(squareData.Opacity * 255); ParamConverter.ParseDashStyle(squareData.DashStyle, out float[] LineDash, out C_BORDER_STYLE BorderStyle); (annotHandlerEventArgs as SquareParam).LineDash = LineDash; (annotHandlerEventArgs as SquareParam).BorderStyle = BorderStyle; (annotHandlerEventArgs as SquareParam).Author = CPDFMarkupData.Author; (annotHandlerEventArgs as SquareParam).Content = squareData.Note; pdfViewerControl.SetCreateAnnotType(C_ANNOTATION_TYPE.C_ANNOTATION_SQUARE); } break; case CPDFAnnotationType.Circle: { CPDFShapeData cicleData = pdfAnnotationData as CPDFShapeData; annotHandlerEventArgs = new CircleParam(); annotHandlerEventArgs.CurrentType = C_ANNOTATION_TYPE.C_ANNOTATION_CIRCLE; byte[] LineColor = new byte[] { cicleData.BorderColor.R, cicleData.BorderColor.G, cicleData.BorderColor.B }; (annotHandlerEventArgs as CircleParam).LineColor = LineColor; if (cicleData.FillColor != Colors.Transparent) { byte[] BgColor = new byte[] { cicleData.FillColor.R, cicleData.FillColor.G, cicleData.FillColor.B }; (annotHandlerEventArgs as CircleParam).BgColor = BgColor; (annotHandlerEventArgs as CircleParam).HasBgColor = true; } (annotHandlerEventArgs as CircleParam).LineWidth = cicleData.Thickness; (annotHandlerEventArgs as CircleParam).Transparency = Convert.ToByte(cicleData.Opacity * 255); ParamConverter.ParseDashStyle(cicleData.DashStyle, out float[] LineDash, out C_BORDER_STYLE BorderStyle); (annotHandlerEventArgs as CircleParam).LineDash = LineDash; (annotHandlerEventArgs as CircleParam).BorderStyle = BorderStyle; (annotHandlerEventArgs as CircleParam).Author = CPDFMarkupData.Author; (annotHandlerEventArgs as CircleParam).Content = cicleData.Note; pdfViewerControl.SetCreateAnnotType(C_ANNOTATION_TYPE.C_ANNOTATION_CIRCLE); } break; case CPDFAnnotationType.Arrow: case CPDFAnnotationType.Line: { CPDFLineShapeData lineData = pdfAnnotationData as CPDFLineShapeData; annotHandlerEventArgs = new LineParam(); annotHandlerEventArgs.CurrentType = C_ANNOTATION_TYPE.C_ANNOTATION_LINE; byte[] LineColor = new byte[] { lineData.BorderColor.R, lineData.BorderColor.G, lineData.BorderColor.B }; (annotHandlerEventArgs as LineParam).LineColor = LineColor; (annotHandlerEventArgs as LineParam).LineWidth = lineData.Thickness; (annotHandlerEventArgs as LineParam).Transparency = Convert.ToByte(lineData.Opacity * 255); ParamConverter.ParseDashStyle(lineData.DashStyle, out float[] LineDash, out C_BORDER_STYLE BorderStyle); (annotHandlerEventArgs as LineParam).LineDash = LineDash; (annotHandlerEventArgs as LineParam).BorderStyle = BorderStyle; (annotHandlerEventArgs as LineParam).HeadLineType = lineData.LineType.HeadLineType; (annotHandlerEventArgs as LineParam).TailLineType = lineData.LineType.TailLineType; (annotHandlerEventArgs as LineParam).Author = CPDFMarkupData.Author; (annotHandlerEventArgs as LineParam).Content = lineData.Note; pdfViewerControl.SetCreateAnnotType(C_ANNOTATION_TYPE.C_ANNOTATION_LINE); } break; case CPDFAnnotationType.Note: { CPDFNoteData noteData = pdfAnnotationData as CPDFNoteData; annotHandlerEventArgs = new StickyNoteParam(); annotHandlerEventArgs.CurrentType = C_ANNOTATION_TYPE.C_ANNOTATION_TEXT; byte[] StickyNoteColor = new byte[] { noteData.BorderColor.R, noteData.BorderColor.G, noteData.BorderColor.B }; (annotHandlerEventArgs as StickyNoteParam).StickyNoteColor = StickyNoteColor; (annotHandlerEventArgs as StickyNoteParam).Content = noteData.Note; (annotHandlerEventArgs as StickyNoteParam).Transparency = 255; (annotHandlerEventArgs as StickyNoteParam).Author = CPDFMarkupData.Author; pdfViewerControl.SetCreateAnnotType(C_ANNOTATION_TYPE.C_ANNOTATION_TEXT); } break; case CPDFAnnotationType.Freehand: { CPDFFreehandData freehandData = pdfAnnotationData as CPDFFreehandData; annotHandlerEventArgs = new InkParam(); annotHandlerEventArgs.CurrentType = C_ANNOTATION_TYPE.C_ANNOTATION_INK; byte[] LineColor = new byte[] { freehandData.BorderColor.R, freehandData.BorderColor.G, freehandData.BorderColor.B }; (annotHandlerEventArgs as InkParam).InkColor = LineColor; (annotHandlerEventArgs as InkParam).Thickness = freehandData.Thickness; (annotHandlerEventArgs as InkParam).Transparency = Convert.ToByte(freehandData.Opacity * 255); (annotHandlerEventArgs as InkParam).Content = freehandData.Note; (annotHandlerEventArgs as InkParam).Author = CPDFMarkupData.Author; pdfViewerControl.SetCreateAnnotType(C_ANNOTATION_TYPE.C_ANNOTATION_INK); } break; case CPDFAnnotationType.FreeText: { CPDFFreeTextData freeTextData = pdfAnnotationData as CPDFFreeTextData; annotHandlerEventArgs = new FreeTextParam(); annotHandlerEventArgs.CurrentType = C_ANNOTATION_TYPE.C_ANNOTATION_FREETEXT; (annotHandlerEventArgs as FreeTextParam).Transparency = Convert.ToByte(freeTextData.Opacity * 255); (annotHandlerEventArgs as FreeTextParam).FontName = freeTextData.FontFamily.ToString(); byte[] FontColor = new byte[] { freeTextData.BorderColor.R, freeTextData.BorderColor.G, freeTextData.BorderColor.B }; (annotHandlerEventArgs as FreeTextParam).FontColor = FontColor; (annotHandlerEventArgs as FreeTextParam).IsBold = freeTextData.IsBold; (annotHandlerEventArgs as FreeTextParam).IsItalic = freeTextData.IsItalic; (annotHandlerEventArgs as FreeTextParam).FontSize = freeTextData.FontSize; switch (freeTextData.TextAlignment) { case TextAlignment.Left: (annotHandlerEventArgs as FreeTextParam).Alignment = C_TEXT_ALIGNMENT.ALIGNMENT_LEFT; break; case TextAlignment.Right: (annotHandlerEventArgs as FreeTextParam).Alignment = C_TEXT_ALIGNMENT.ALIGNMENT_RIGHT; break; case TextAlignment.Center: (annotHandlerEventArgs as FreeTextParam).Alignment = C_TEXT_ALIGNMENT.ALIGNMENT_CENTER; break; default: break; } (annotHandlerEventArgs as FreeTextParam).Content = freeTextData.Note; (annotHandlerEventArgs as FreeTextParam).Author = CPDFMarkupData.Author; pdfViewerControl.SetCreateAnnotType(C_ANNOTATION_TYPE.C_ANNOTATION_FREETEXT); } break; case CPDFAnnotationType.Stamp: { StampParam stampParam = new StampParam(); stampParam.CurrentType = C_ANNOTATION_TYPE.C_ANNOTATION_STAMP; CPDFStampData stampData = pdfAnnotationData as CPDFStampData; SetStamp(ref stampParam, stampData); annotHandlerEventArgs = stampParam; pdfViewerControl.SetCreateAnnotType(C_ANNOTATION_TYPE.C_ANNOTATION_STAMP); byte[] imageData = null; int imageWidth = 0; int imageHeight = 0; PDFHelp.ImageStreamToByte(stampParam.ImageStream, ref imageData, ref imageWidth, ref imageHeight); if (imageData != null && imageWidth > 0 && imageHeight > 0) { pdfViewerControl.SetStampMouseImage(imageData, imageWidth, imageHeight); } pdfViewerControl.SetIsVisibleCustomMouse(true); pdfViewerControl.SetIsShowStampMouse(true); } break; case CPDFAnnotationType.Signature: { AnnotParam signatureParam = new AnnotParam(); CPDFSignatureData SignatureData = pdfAnnotationData as CPDFSignatureData; SetSignature(ref signatureParam, SignatureData); switch (signatureParam.CurrentType) { case C_ANNOTATION_TYPE.C_ANNOTATION_STAMP: { StampParam stampParam = (StampParam)signatureParam; stampParam.CurrentType = C_ANNOTATION_TYPE.C_ANNOTATION_STAMP; byte[] imageData = null; int imageWidth = 0; int imageHeight = 0; PDFHelp.ImageStreamToByte(stampParam.ImageStream, ref imageData, ref imageWidth, ref imageHeight); if (imageData != null && imageWidth > 0 && imageHeight > 0) { pdfViewerControl.SetStampMouseImage(imageData, imageWidth, imageHeight); pdfViewerControl.SetIsVisibleCustomMouse(true); pdfViewerControl.SetIsShowStampMouse(true); annotHandlerEventArgs = signatureParam; } } break; case C_ANNOTATION_TYPE.C_ANNOTATION_INK: { WriteableBitmap writeableBitmap = CreateInkImaget(signatureParam as InkParam); byte[] imageArray = new byte[writeableBitmap.PixelWidth * writeableBitmap.PixelHeight * 4]; writeableBitmap.CopyPixels(imageArray, writeableBitmap.PixelWidth * 4, 0); pdfViewerControl.SetStampMouseImage(imageArray, writeableBitmap.PixelWidth, writeableBitmap.PixelHeight); pdfViewerControl.SetIsVisibleCustomMouse(true); pdfViewerControl.SetIsShowStampMouse(true); annotHandlerEventArgs = signatureParam; } break; default: return; } } break; case CPDFAnnotationType.Link: if (annotHandlerEventArgs != null) { annotHandlerEventArgs.CurrentType = C_ANNOTATION_TYPE.C_ANNOTATION_LINK; pdfViewerControl.SetCreateAnnotType(C_ANNOTATION_TYPE.C_ANNOTATION_LINK); } break; case CPDFAnnotationType.Unknown: pdfViewerControl.SetToolType(ToolType.Pan); return; default: break; } pdfViewerControl.SetToolType(ToolType.CreateAnnot); if (annotationType != CPDFAnnotationType.Stamp && annotationType != CPDFAnnotationType.Signature && annotationType != CPDFAnnotationType.Image) { pdfViewerControl.SetIsShowStampMouse(false); } pdfViewerControl.SetAnnotParam(annotHandlerEventArgs); } private WriteableBitmap CreateInkImaget(InkParam inkParam) { if (inkParam == null) { return null; } if (inkParam.InkPath != null && inkParam.InkPath.Count > 0) { GeometryGroup PaintGeomtry = new GeometryGroup(); int minLeft = -1; int minTop = -1; int maxLeft = -1; int maxTop = -1; foreach (List Item in inkParam.InkPath) { for (int i = 0; i < Item.Count; i++) { CPoint paintPoint = Item[i]; if (minLeft == -1) { minLeft = (int)paintPoint.x; maxLeft = (int)paintPoint.x; minTop = (int)paintPoint.y; maxTop = (int)paintPoint.y; } else { minLeft = (int)Math.Min(minLeft, paintPoint.x); maxLeft = (int)Math.Max(maxLeft, paintPoint.x); minTop = (int)Math.Min(minTop, paintPoint.y); maxTop = (int)Math.Max(maxTop, paintPoint.y); } } } if (minLeft >= 0 && maxLeft > minLeft && minTop >= 0 && maxTop > minTop) { List> points = new List>(); foreach (List Item in inkParam.InkPath) { PathGeometry PaintPath = new PathGeometry(); PathFigureCollection Figures = new PathFigureCollection(); PathFigure AddFigure = new PathFigure(); Figures.Add(AddFigure); PaintPath.Figures = Figures; PaintGeomtry.Children.Add(PaintPath); List changeList = new List(); for (int i = 0; i < Item.Count; i++) { Point paintPoint = new Point(DpiHelper.PDFNumToStandardNum(Item[i].x - minLeft), DpiHelper.PDFNumToStandardNum(Item[i].y - minTop)); changeList.Add(DataConversionForWPF.PointConversionForCPoint(DpiHelper.StandardPointToPDFPoint(paintPoint))); if (i == 0) { AddFigure.StartPoint = paintPoint; } else { LineSegment AddSegment = new LineSegment(); AddSegment.Point = paintPoint; AddFigure.Segments.Add(AddSegment); } } if (changeList.Count > 0) { points.Add(changeList); } } int drawWidth = (int)DpiHelper.PDFNumToStandardNum(maxLeft - minLeft); int drawHeight = (int)DpiHelper.PDFNumToStandardNum(maxTop - minTop); inkParam.InkPath = points; DefaultSettingParam defaultSettingParam = pdfViewerControl.PDFViewTool.GetDefaultSettingParam(); defaultSettingParam.SetAnnotParam(inkParam); DrawingVisual copyVisual = new DrawingVisual(); DrawingContext copyContext = copyVisual.RenderOpen(); Color color = ParamConverter.ConverterByteForColor(inkParam.InkColor); color.A = inkParam.Transparency; Pen drawPen = new Pen(new SolidColorBrush(color), inkParam.Thickness); copyContext?.DrawGeometry(null, drawPen, PaintGeomtry); copyContext.Close(); RenderTargetBitmap targetBitmap = new RenderTargetBitmap(drawWidth, drawHeight, 96, 96, PixelFormats.Pbgra32); targetBitmap.Render(copyVisual); byte[] ImageArray = new byte[targetBitmap.PixelWidth * targetBitmap.PixelHeight * 4]; targetBitmap.CopyPixels(new Int32Rect(0, 0, (int)targetBitmap.PixelWidth, (int)targetBitmap.PixelHeight), ImageArray, targetBitmap.PixelWidth * 4, 0); WriteableBitmap writeBitmap = new WriteableBitmap(targetBitmap.PixelWidth, targetBitmap.PixelHeight, 96, 96, PixelFormats.Bgra32, null); writeBitmap.WritePixels(new Int32Rect(0, 0, targetBitmap.PixelWidth, targetBitmap.PixelHeight), ImageArray, targetBitmap.PixelWidth * 4, 0); return writeBitmap; } } return null; } public void SetSignature(ref AnnotParam annotParam, CPDFSignatureData stamp) { switch (stamp.Type) { case SignatureType.TextType: case SignatureType.ImageType: { annotParam = new StampParam(); annotParam.CurrentType = C_ANNOTATION_TYPE.C_ANNOTATION_STAMP; (annotParam as StampParam).Transparency = 255; (annotParam as StampParam).StampType = C_STAMP_TYPE.IMAGE_STAMP; if (!string.IsNullOrEmpty(stamp.SourcePath)) { BitmapImage image = new BitmapImage(new Uri(stamp.SourcePath)); PngBitmapEncoder encoder = new PngBitmapEncoder(); encoder.Frames.Add(BitmapFrame.Create(image)); MemoryStream memoryStream = new MemoryStream(); encoder.Save(memoryStream); (annotParam as StampParam).ImageStream = memoryStream; } pdfViewerControl.SetCreateAnnotType(C_ANNOTATION_TYPE.C_ANNOTATION_STAMP); } break; case SignatureType.Drawing: { annotParam = new InkParam(); (annotParam as InkParam).Transparency = stamp.inkColor.A; annotParam.CurrentType = C_ANNOTATION_TYPE.C_ANNOTATION_INK; List> RawPointList = GetPoints(stamp.DrawingPath); if (RawPointList != null && RawPointList.Count > 0) { List> inkPath = new List>(); foreach (List inkPoints in RawPointList) { List ink = new List(); foreach (Point point in inkPoints) { ink.Add(new CPoint((float)DpiHelper.StandardNumToPDFNum(point.X), (float)DpiHelper.StandardNumToPDFNum(point.Y))); } if (ink.Count > 0) { inkPath.Add(ink); } } if (inkPath.Count > 0) { (annotParam as InkParam).InkPath = inkPath; } } (annotParam as InkParam).Thickness = stamp.inkThickness; byte[] InkColor = new byte[] { stamp.inkColor.R, stamp.inkColor.G, stamp.inkColor.B }; (annotParam as InkParam).InkColor = InkColor; pdfViewerControl.SetCreateAnnotType(C_ANNOTATION_TYPE.C_ANNOTATION_INK); } break; default: break; } } private List> GetPoints(string Path) { StrokeCollection Strokes; List> RawPointList = new List>(); using (FileStream strokeStream = File.OpenRead(Path)) { Strokes = new StrokeCollection(strokeStream); } for (int kk = 0; kk < Strokes.Count; kk++) { List p = new List(); RawPointList.Add(p); for (int gg = 0; gg < Strokes[kk].StylusPoints.Count; gg++) { var point = Strokes[kk].StylusPoints[gg].ToPoint(); if (point.X >= 0 && point.Y >= 0) RawPointList[kk].Add(point); } } return RawPointList; } private void SetStamp(ref StampParam stampParam, CPDFStampData stamp) { stampParam.StampText = stamp.StampText; stampParam.Author = CPDFMarkupData.Author; stampParam.Transparency = Convert.ToByte(stamp.Opacity * 255); stampParam.DateText = stamp.StampTextDate; stampParam.TextStampColor = stamp.TextColor; stampParam.TextStampShape = stamp.TextSharp; if (!string.IsNullOrEmpty(stamp.SourcePath)) { BitmapImage image = new BitmapImage(new Uri(stamp.SourcePath)); PngBitmapEncoder encoder = new PngBitmapEncoder(); encoder.Frames.Add(BitmapFrame.Create(image)); MemoryStream memoryStream = new MemoryStream(); encoder.Save(memoryStream); stampParam.ImageStream = memoryStream; } else { var i = pdfStampUI.CustomStampList.IndexOf(stamp); Settings.Default.CustomStampList.RemoveAt(i); Settings.Default.Save(); pdfStampUI.LoadSettings(); return; } stampParam.StampType = stamp.Type; } public void AnnotationCancel() { this.pdfViewerControl.SetToolType(ToolType.Pan); pdfViewerControl.SetIsShowStampMouse(false); ClearPanel(); } private void CPDFAnnotationControl_PropertyChanged(object sender, CPDFAnnotationData e) { SetAnnotationProperty(e); } public void InitAnnotationPanel(CPDFAnnotationType annotationType) { switch (annotationType) { case CPDFAnnotationType.Highlight: if (pdfHighlightUI == null) { pdfHighlightUI = new CPDFMarkupUI(); } annotationPanel = pdfHighlightUI; (annotationPanel as CPDFMarkupUI).InitWithAnnotationType(annotationType); break; case CPDFAnnotationType.Underline: if (pdfUnderlineUI == null) { pdfUnderlineUI = new CPDFMarkupUI(); } annotationPanel = pdfUnderlineUI; (annotationPanel as CPDFMarkupUI).InitWithAnnotationType(annotationType); break; case CPDFAnnotationType.Strikeout: if (pdfStrikeoutUI == null) { pdfStrikeoutUI = new CPDFMarkupUI(); } annotationPanel = pdfStrikeoutUI; (annotationPanel as CPDFMarkupUI).InitWithAnnotationType(annotationType); break; case CPDFAnnotationType.Squiggly: if (pdfSquigglyUI == null) { pdfSquigglyUI = new CPDFMarkupUI(); } annotationPanel = pdfSquigglyUI; (annotationPanel as CPDFMarkupUI).InitWithAnnotationType(annotationType); break; case CPDFAnnotationType.Square: if (pdfSquareUI == null) { pdfSquareUI = new CPDFShapeUI(); } annotationPanel = pdfSquareUI; (annotationPanel as CPDFShapeUI).InitWithAnnotationType(annotationType); break; case CPDFAnnotationType.Circle: if (pdfCircleUI == null) { pdfCircleUI = new CPDFShapeUI(); } annotationPanel = pdfCircleUI; (annotationPanel as CPDFShapeUI).InitWithAnnotationType(annotationType); break; case CPDFAnnotationType.Arrow: if (pdfArrowUI == null) { pdfArrowUI = new CPDFShapeUI(); } annotationPanel = pdfArrowUI; (annotationPanel as CPDFShapeUI).InitWithAnnotationType(annotationType); break; case CPDFAnnotationType.Line: if (pdfLineUI == null) { pdfLineUI = new CPDFShapeUI(); } annotationPanel = pdfLineUI; (annotationPanel as CPDFShapeUI).InitWithAnnotationType(annotationType); break; case CPDFAnnotationType.Freehand: if (pdfFreehandUI == null) { pdfFreehandUI = new CPDFFreehandUI(); pdfFreehandUI.EraseClickHandler -= PdfFreehandUI_EraseClickHandler; pdfFreehandUI.EraseChangeHandler -= PdfFreehandUI_EraseChangeHandler; pdfFreehandUI.EraseClickHandler += PdfFreehandUI_EraseClickHandler; pdfFreehandUI.EraseChangeHandler += PdfFreehandUI_EraseChangeHandler; } annotationPanel = pdfFreehandUI; break; case CPDFAnnotationType.FreeText: if (pdfFreeTextUI == null) { pdfFreeTextUI = new CPDFFreeTextUI(); } annotationPanel = pdfFreeTextUI; break; case CPDFAnnotationType.Note: if (pdfNoteUI == null) { pdfNoteUI = new CPDFNoteUI(); } annotationPanel = pdfNoteUI; break; case CPDFAnnotationType.Stamp: if (pdfStampUI == null) { pdfStampUI = new CPDFStampUI(); } annotationPanel = pdfStampUI; break; case CPDFAnnotationType.Signature: if (pdfSignatureUI == null) { pdfSignatureUI = new CPDFSignatureUI(); } annotationPanel = pdfSignatureUI; break; case CPDFAnnotationType.Link: if (pdfLinkUI == null) { pdfLinkUI = new CPDFLinkUI(); } LinkParam linkAnnotArgs = new LinkParam(); if (this.pdfViewerControl != null && pdfViewerControl.PDFViewTool != null && pdfViewerControl.PDFViewTool.GetCPDFViewer().GetDocument() != null) { pdfViewerControl.SetToolType(ToolType.CreateAnnot); pdfViewerControl.SetCreateAnnotType(C_ANNOTATION_TYPE.C_ANNOTATION_LINK); pdfLinkUI.InitLinkAnnotArgs(linkAnnotArgs, pdfViewerControl.PDFViewTool.GetCPDFViewer().GetDocument().PageCount); } annotationPanel = pdfLinkUI; break; case CPDFAnnotationType.Audio: SoundParam soundParam = new SoundParam(); soundParam.CurrentType = C_ANNOTATION_TYPE.C_ANNOTATION_SOUND; OpenFileDialog openAudioDialog = new OpenFileDialog(); openAudioDialog.Filter = "Wave Files(*.wav)|*.wav|All Files(*.*;)|*.*;"; if (openAudioDialog.ShowDialog() == true) { BitmapImage img = new BitmapImage(new Uri("pack://application:,,,/Compdfkit_Tools;component/Asset/Resource/SoundAnnot.png")); PngBitmapEncoder encoder = new PngBitmapEncoder(); encoder.Frames.Add(BitmapFrame.Create(img)); MemoryStream memoryStream = new MemoryStream(); encoder.Save(memoryStream); soundParam.ImageStream = memoryStream; soundParam.SoundFilePath = openAudioDialog.FileName; pdfViewerControl.SetToolType(ToolType.CreateAnnot); pdfViewerControl.SetCreateAnnotType(C_ANNOTATION_TYPE.C_ANNOTATION_SOUND); pdfViewerControl.SetAnnotParam(soundParam); } else { pdfViewerControl.SetToolType(ToolType.Pan); ClearAnnotationBar?.Invoke(this, EventArgs.Empty); } ClearPanel(); break; case CPDFAnnotationType.Image: StampParam stampParam = new StampParam(); OpenFileDialog openFileDialog = new OpenFileDialog(); openFileDialog.Filter = "Image Files(*.jpg;*.jpeg;*.png;*.bmp)|*.jpg;*.jpeg;*.png;*.bmp;"; if (openFileDialog.ShowDialog() == true) { try { using (FileStream stream = new FileStream(openFileDialog.FileName, FileMode.Open, FileAccess.Read, FileShare.Read)) { PngBitmapEncoder encoder = new PngBitmapEncoder(); encoder.Frames.Add(BitmapFrame.Create(stream, BitmapCreateOptions.DelayCreation, BitmapCacheOption.None)); MemoryStream memoryStream = new MemoryStream(); encoder.Save(memoryStream); stampParam.ImageStream = memoryStream; stampParam.Transparency = 255; stampParam.CurrentType = C_ANNOTATION_TYPE.C_ANNOTATION_STAMP; stampParam.StampType = C_STAMP_TYPE.IMAGE_STAMP; BitmapFrame frame = null; if (encoder != null && encoder.Frames.Count > 0) { frame = encoder.Frames[0]; } if (frame != null) { byte[] imageArray = new byte[frame.PixelWidth * frame.PixelHeight * 4]; if (frame.Format != PixelFormats.Bgra32) { FormatConvertedBitmap covert = new FormatConvertedBitmap( frame, PixelFormats.Bgra32, frame.Palette, 0); covert.CopyPixels(imageArray, frame.PixelWidth * 4, 0); } else { frame.CopyPixels(imageArray, frame.PixelWidth * 4, 0); } pdfViewerControl.SetStampMouseImage(imageArray, frame.PixelWidth, frame.PixelHeight); } pdfViewerControl.SetToolType(ToolType.CreateAnnot); pdfViewerControl.SetCreateAnnotType(C_ANNOTATION_TYPE.C_ANNOTATION_STAMP); pdfViewerControl.SetIsVisibleCustomMouse(true); pdfViewerControl.SetIsShowStampMouse(true); pdfViewerControl.SetAnnotParam(stampParam); } } catch { } } else { pdfViewerControl.SetToolType(ToolType.Pan); ClearAnnotationBar?.Invoke(this, EventArgs.Empty); } ClearPanel(); break; default: break; } } private void PdfFreehandUI_EraseChangeHandler(object sender, double e) { if (pdfViewerControl != null) { pdfViewerControl.PDFViewTool.SetEraseZoom(e); } } private void PdfFreehandUI_EraseClickHandler(object sender, bool e) { if (e) { //pdfViewerControl.PDFToolManager.ClearSelect(); pdfViewerControl.PDFViewTool.SetViewerModel(MouseModes.CustomizeTool); } else { pdfViewerControl.SetToolType(ToolType.CreateAnnot); pdfViewerControl.SetCreateAnnotType(C_ANNOTATION_TYPE.C_ANNOTATION_INK); } //if (pdfViewerControl != null) //{ // CPDFFreehandUI freehandUI = sender as CPDFFreehandUI; // if (e) // { // annotArgs = pdfViewerControl.ToolManager.CurrentAnnotArgs; // eraseArgs = new EraseArgs(); // eraseArgs.UIBorderColor = Color.FromArgb(0x1A, 0x00, 0x00, 0x00); // eraseArgs.UIFillColor = Color.FromArgb(0x1A, 0x00, 0x00, 0x00); // if (freehandUI != null) // { // eraseArgs.Thickness = freehandUI.GetEraseThickness(); // } // else // { // eraseArgs.Thickness = 1; // } // disableClean = true; // pdfViewerControl.PDFToolManager.SetToolType(ToolType.CreateAnnot); // pdfViewerControl.SetToolParam(eraseArgs); // disableClean = false; // EmptyMessage.Visibility = Visibility.Collapsed; // } // else // { // pdfViewerControl.PDFToolManager.SetToolType(ToolType.CreateAnnot); // FreehandAnnotArgs freehandAnnotArgs = annotArgs as FreehandAnnotArgs; // if (freehandAnnotArgs == null) // { // freehandAnnotArgs = new FreehandAnnotArgs(); // freehandAnnotArgs.InkColor = Colors.Red; // freehandAnnotArgs.Transparency = 1; // freehandAnnotArgs.LineWidth = 1; // annotArgs = freehandAnnotArgs; // } // if (freehandUI != null) // { // freehandUI.PropertyChanged -= CPDFAnnotationControl_PropertyChanged; // Dictionary attribDict = new Dictionary(); // attribDict[AnnotAttrib.Color] = freehandAnnotArgs.InkColor; // attribDict[AnnotAttrib.Transparency] = freehandAnnotArgs.Transparency; // attribDict[AnnotAttrib.Thickness] = freehandAnnotArgs.LineWidth; // attribDict[AnnotAttrib.NoteText] = freehandAnnotArgs.Content; // AnnotAttribEvent annotEvent = AnnotAttribEvent.GetAnnotAttribEvent(freehandAnnotArgs, attribDict); // freehandUI.SetPresentAnnotAttrib(annotEvent); // freehandUI.PropertyChanged += CPDFAnnotationControl_PropertyChanged; // freehandUI.ClearAnnotAttribEvent(); // } // pdfViewerControl.SetToolParam(freehandAnnotArgs); // } //} } public void CreatTempAnnotationPanel(BaseAnnot baseAnnot) { switch (baseAnnot.CurrentType) { case C_ANNOTATION_TYPE.C_ANNOTATION_HIGHLIGHT: { tempAnnotationPanel = new CPDFMarkupUI(); (tempAnnotationPanel as CPDFMarkupUI).InitWithAnnotationType(CPDFAnnotationType.Highlight); AnnotParam annotParam = ParamConverter.CPDFDataConverterToAnnotParam( pdfViewerControl.PDFViewTool.GetCPDFViewer().GetDocument(), baseAnnot.GetAnnotData().PageIndex, baseAnnot.GetAnnotData().Annot); (tempAnnotationPanel as CPDFMarkupUI).SetPresentAnnotAttrib(annotParam, baseAnnot.GetAnnotData().Annot as CPDFMarkupAnnotation, pdfViewerControl); } break; case C_ANNOTATION_TYPE.C_ANNOTATION_UNDERLINE: { tempAnnotationPanel = new CPDFMarkupUI(); (tempAnnotationPanel as CPDFMarkupUI).InitWithAnnotationType(CPDFAnnotationType.Underline); AnnotParam annotParam = ParamConverter.CPDFDataConverterToAnnotParam( pdfViewerControl.PDFViewTool.GetCPDFViewer().GetDocument(), baseAnnot.GetAnnotData().PageIndex, baseAnnot.GetAnnotData().Annot); (tempAnnotationPanel as CPDFMarkupUI).SetPresentAnnotAttrib(annotParam, baseAnnot.GetAnnotData().Annot as CPDFMarkupAnnotation, pdfViewerControl); } break; case C_ANNOTATION_TYPE.C_ANNOTATION_STRIKEOUT: { tempAnnotationPanel = new CPDFMarkupUI(); (tempAnnotationPanel as CPDFMarkupUI).InitWithAnnotationType(CPDFAnnotationType.Strikeout); AnnotParam annotParam = ParamConverter.CPDFDataConverterToAnnotParam( pdfViewerControl.PDFViewTool.GetCPDFViewer().GetDocument(), baseAnnot.GetAnnotData().PageIndex, baseAnnot.GetAnnotData().Annot); (tempAnnotationPanel as CPDFMarkupUI).SetPresentAnnotAttrib(annotParam, baseAnnot.GetAnnotData().Annot as CPDFMarkupAnnotation, pdfViewerControl); } break; case C_ANNOTATION_TYPE.C_ANNOTATION_SQUIGGLY: { tempAnnotationPanel = new CPDFMarkupUI(); (tempAnnotationPanel as CPDFMarkupUI).InitWithAnnotationType(CPDFAnnotationType.Squiggly); AnnotParam annotParam = ParamConverter.CPDFDataConverterToAnnotParam( pdfViewerControl.PDFViewTool.GetCPDFViewer().GetDocument(), baseAnnot.GetAnnotData().PageIndex, baseAnnot.GetAnnotData().Annot); (tempAnnotationPanel as CPDFMarkupUI).SetPresentAnnotAttrib(annotParam, baseAnnot.GetAnnotData().Annot as CPDFMarkupAnnotation, pdfViewerControl); } break; case C_ANNOTATION_TYPE.C_ANNOTATION_SQUARE: { tempAnnotationPanel = new CPDFShapeUI(); (tempAnnotationPanel as CPDFShapeUI).InitWithAnnotationType(CPDFAnnotationType.Square); AnnotParam annotParam = ParamConverter.CPDFDataConverterToAnnotParam( pdfViewerControl.PDFViewTool.GetCPDFViewer().GetDocument(), baseAnnot.GetAnnotData().PageIndex, baseAnnot.GetAnnotData().Annot); (tempAnnotationPanel as CPDFShapeUI).SetPresentAnnotAttrib(annotParam, baseAnnot.GetAnnotData().Annot, pdfViewerControl); } break; case C_ANNOTATION_TYPE.C_ANNOTATION_CIRCLE: { tempAnnotationPanel = new CPDFShapeUI(); (tempAnnotationPanel as CPDFShapeUI).InitWithAnnotationType(CPDFAnnotationType.Circle); AnnotParam annotParam = ParamConverter.CPDFDataConverterToAnnotParam( pdfViewerControl.PDFViewTool.GetCPDFViewer().GetDocument(), baseAnnot.GetAnnotData().PageIndex, baseAnnot.GetAnnotData().Annot); (tempAnnotationPanel as CPDFShapeUI).SetPresentAnnotAttrib(annotParam, baseAnnot.GetAnnotData().Annot, pdfViewerControl); } break; case C_ANNOTATION_TYPE.C_ANNOTATION_LINE: { tempAnnotationPanel = new CPDFShapeUI(); (tempAnnotationPanel as CPDFShapeUI).InitWithAnnotationType(CPDFAnnotationType.Line); AnnotParam annotParam = ParamConverter.CPDFDataConverterToAnnotParam( pdfViewerControl.PDFViewTool.GetCPDFViewer().GetDocument(), baseAnnot.GetAnnotData().PageIndex, baseAnnot.GetAnnotData().Annot); (tempAnnotationPanel as CPDFShapeUI).SetPresentAnnotAttrib(annotParam, baseAnnot.GetAnnotData().Annot, pdfViewerControl); } break; case C_ANNOTATION_TYPE.C_ANNOTATION_INK: { CPDFFreehandUI tempFreehandPanel = new CPDFFreehandUI(); AnnotParam annotParam = ParamConverter.CPDFDataConverterToAnnotParam( pdfViewerControl.PDFViewTool.GetCPDFViewer().GetDocument(), baseAnnot.GetAnnotData().PageIndex, baseAnnot.GetAnnotData().Annot); tempFreehandPanel.SetPresentAnnotAttrib(annotParam, baseAnnot.GetAnnotData().Annot, pdfViewerControl.PDFToolManager.GetDocument(), pdfViewerControl); tempFreehandPanel.EraseClickHandler -= PdfFreehandUI_EraseClickHandler; tempFreehandPanel.EraseChangeHandler -= PdfFreehandUI_EraseChangeHandler; tempFreehandPanel.EraseClickHandler += PdfFreehandUI_EraseClickHandler; tempFreehandPanel.EraseChangeHandler += PdfFreehandUI_EraseChangeHandler; tempAnnotationPanel = tempFreehandPanel; } break; case C_ANNOTATION_TYPE.C_ANNOTATION_FREETEXT: { tempAnnotationPanel = new CPDFFreeTextUI(); AnnotParam annotParam = ParamConverter.CPDFDataConverterToAnnotParam( pdfViewerControl.PDFViewTool.GetCPDFViewer().GetDocument(), baseAnnot.GetAnnotData().PageIndex, baseAnnot.GetAnnotData().Annot); (tempAnnotationPanel as CPDFFreeTextUI).SetPresentAnnotAttrib(annotParam as FreeTextParam, baseAnnot.GetAnnotData().Annot as CPDFFreeTextAnnotation, pdfViewerControl); } break; case C_ANNOTATION_TYPE.C_ANNOTATION_TEXT: { tempAnnotationPanel = new CPDFNoteUI(); AnnotParam annotParam = ParamConverter.CPDFDataConverterToAnnotParam( pdfViewerControl.PDFViewTool.GetCPDFViewer().GetDocument(), baseAnnot.GetAnnotData().PageIndex, baseAnnot.GetAnnotData().Annot); (tempAnnotationPanel as CPDFNoteUI).SetPresentAnnotAttrib(annotParam as StickyNoteParam, baseAnnot.GetAnnotData().Annot as CPDFTextAnnotation, pdfViewerControl); } break; case C_ANNOTATION_TYPE.C_ANNOTATION_STAMP: { tempAnnotationPanel = new CPDFTempStampUI(); AnnotParam annotParam = ParamConverter.CPDFDataConverterToAnnotParam( pdfViewerControl.PDFViewTool.GetCPDFViewer().GetDocument(), baseAnnot.GetAnnotData().PageIndex, baseAnnot.GetAnnotData().Annot); (tempAnnotationPanel as CPDFTempStampUI).SetPresentAnnotAttrib(annotParam as StampParam, baseAnnot.GetAnnotData().Annot as CPDFStampAnnotation, pdfViewerControl.PDFToolManager.GetDocument(), pdfViewerControl); } break; case C_ANNOTATION_TYPE.C_ANNOTATION_LINK: { tempAnnotationPanel = new CPDFLinkUI(); AnnotParam annotParam = ParamConverter.CPDFDataConverterToAnnotParam( pdfViewerControl.PDFViewTool.GetCPDFViewer().GetDocument(), baseAnnot.GetAnnotData().PageIndex, baseAnnot.GetAnnotData().Annot); (tempAnnotationPanel as CPDFLinkUI).SetPresentAnnotAttrib(annotParam as LinkParam, baseAnnot.GetAnnotData().Annot as CPDFLinkAnnotation, pdfViewerControl, pdfViewerControl.PDFToolManager.GetDocument().PageCount); } break; case C_ANNOTATION_TYPE.C_ANNOTATION_SOUND: tempAnnotationPanel = null; break; default: break; } } public void LoadAnnotationPanel(CPDFAnnotationType annotationType) { this.pdfViewerControl.SetToolType(ToolType.Pan); currentAnnotationType = annotationType; annotationPanel = GetAnnotationPanel(); InitAnnotationPanel(annotationType); ShowCurrentAnnotPanel(); } private void ShowCurrentAnnotPanel() { if (annotationPanel != null) { if (annotationPanel is CPDFFreehandUI) { (annotationPanel as CPDFFreehandUI)?.SetEraseCheck(false); } SetAnnotationPanel(annotationPanel); ExpandPanel(); ChangeAnnotationData(); EmptyMessage.Visibility = Visibility.Collapsed; } else { EmptyMessage.Visibility = Visibility.Visible; SetAnnotationPanel(null); if (pdfViewerControl != null) { EmptyMessage.Visibility = Visibility.Collapsed; } } } private void ShowTempAnnotPanel() { BaseAnnot baseAnnot = pdfViewerControl.GetCacheHitTestAnnot(); if (baseAnnot != null) { CreatTempAnnotationPanel(baseAnnot); SetAnnotationPanel(tempAnnotationPanel); ExpandPanel(); if (tempAnnotationPanel != null) { EmptyMessage.Visibility = Visibility.Collapsed; } else { EmptyMessage.Visibility = Visibility.Visible; } } } private void PDFToolManager_MouseLeftButtonDownHandler(object sender, MouseEventObject e) { SetAnnotEventData(); } public void ClearPanel() { annotationPanel = null; SetAnnotationPanel(annotationPanel); EmptyMessage.Visibility = Visibility.Visible; } public void SetAnnotEventData() { if (pdfViewerControl.GetCacheHitTestAnnot()!= null) { if (pdfViewerControl.PDFToolManager.GetToolType() == ToolType.CreateAnnot && isTempPanel) { ShowCurrentAnnotPanel(); isTempPanel = false; } else { ShowTempAnnotPanel(); isTempPanel = true; } } else { if (pdfViewerControl != null && pdfViewerControl.PDFToolManager.GetToolType() == ToolType.CreateAnnot) { ShowCurrentAnnotPanel(); isTempPanel = false; } else if (annotationPanel is CPDFStampUI && currentAnnotationType == CPDFAnnotationType.Stamp) { ShowCurrentAnnotPanel(); } else if (annotationPanel is CPDFSignatureUI && currentAnnotationType == CPDFAnnotationType.Signature) { ShowCurrentAnnotPanel(); } else if (disableClean == false) { ClearPanel(); } } } } }