public static void DeleteExistingHighlights(Document document)
{
for (int i = 1; i <= document.GetPageCount(); i++)
{
pdftron.PDF.Page page = document.GetPage(i);
int annotCount = page.GetNumAnnots();
List <Annot> annotsToDelete = new List <Annot>();
for (int j = 0; j < page.GetNumAnnots(); j++)
{
Annot annot = page.GetAnnot(j);
if (annot.GetSDFObj() != null &&
annot.GetType() == Annot.Type.e_Highlight)
{
annotsToDelete.Add(annot);
}
else
{
}
}
foreach (Annot annot in annotsToDelete)
{
page.AnnotRemove(annot);
}
}
}
private void _toolManager_AnnotationAdded(Annot annotation)
{
// Update viewer after annotation added
PDFViewer.Update(annotation, PDFViewer.GetCurrentPage());
ResultSnapshot snap = _undoManager.TakeSnapshot();
}
public static List <ColorPt> ExistingColors(this Document document)
{
List <ColorPt> existingColorPts = new List <ColorPt>();
for (int i = 1; i <= document.GetPageCount(); i++)
{
pdftron.PDF.Page page = document.GetPage(i);
if (page.IsValid())
{
for (int j = 0; j < page.GetNumAnnots(); j++)
{
Annot annot = page.GetAnnot(j);
if (annot.GetSDFObj() != null && (annot.GetType() == Annot.Type.e_Highlight || annot.GetType() == Annot.Type.e_Unknown))
{
ColorPt existingColorPt = annot.GetColorAsRGB();
if (existingColorPts.Where(e =>
e.Get(0) == existingColorPt.Get(0) &&
e.Get(1) == existingColorPt.Get(1) &&
e.Get(2) == existingColorPt.Get(2) &&
e.Get(3) == existingColorPt.Get(3)
).Count() == 0)
{
existingColorPts.Add(existingColorPt);
}
}
}
}
}
return(existingColorPts);
}
static Annot CreateSingleHighlightAnnot(Document document, List <Rect> boxes, ColorPt colorPt, double highlightOpacity)
{
Annot annotation = Annot.Create(document, Annot.Type.e_Highlight, RectangleUnion(boxes));
annotation.SetColor(colorPt);
annotation.SetBorderStyle(new Annot.BorderStyle
(Annot.BorderStyle.Style.e_solid, 1));
Obj quads = annotation.GetSDFObj().PutArray("QuadPoints");
List <Rect> lineRectangles = boxes.GroupBy(box => box.y1).Select(line => RectangleUnion(line.ToList())).ToList();
lineRectangles.ForEach(lineRect => PushBackBox(quads, lineRect));
annotation.SetAppearance(CreateHighlightAppearance(lineRectangles, colorPt, highlightOpacity, document));
return(annotation);
}
public void GetPageDetails_IfPdfPageHasUriLinkWithoutScheme_ObjectEditionHasPageUriLinkAddedUriScheme()
{
// Arrange
const int page02Index = 1;
var pdfDoc = new PDFDoc();
try
{
var pdfPage01 = pdfDoc.PageCreate();
var pdfPage02 = pdfDoc.PageCreate();
pdfDoc.PagePushBack(pdfPage01);
pdfDoc.PagePushBack(pdfPage02);
// create annot of pdfPage02
// uri type of annot to an uri with mailto scheme
var uriAcion = PDFAction.CreateURI(pdfDoc, WebUriWithoutScheme);
var linkAnnot = Annot.CreateLink(pdfDoc, new Rect(X1, Y1, X2, Y2), uriAcion);
pdfPage02.AnnotInsert(0, linkAnnot);
// Act
_testEntityPrivate.Invoke(GetPageDetailsMethodName, pdfDoc);
}
finally
{
pdfDoc.Dispose();
}
// Assert
var page02LinkCollection = _objectEdition.PageCollection[page02Index].LinkCollection;
var page02Links = ConvertToLinkArray(page02LinkCollection);
page02Links.ShouldSatisfyAllConditions(
() => page02Links.Length.ShouldBe(1),
() => page02Links.ShouldContain(link => link.LinkType == UriLinkType),
() => page02Links.First().LinkURL.ShouldStartWith(HttpScheme));
}
public void GetPageDetails_IfPdfPageHasGoToLink_ObjectEditionPageHasGoToLink()
{
// Arrange
const int page01Index = 0;
var pdfDoc = new PDFDoc();
try
{
var pdfPage01 = pdfDoc.PageCreate();
var pdfPage02 = pdfDoc.PageCreate();
pdfDoc.PagePushBack(pdfPage01);
pdfDoc.PagePushBack(pdfPage02);
// create annot of pdfPage01
// goto type of annot links to pdfPage02
var destination = Destination.CreateFit(pdfPage02);
var gotoAction = PDFAction.CreateGoto(destination);
var linkAnnot = Annot.CreateLink(pdfDoc, new Rect(X1, Y1, X2, Y2), gotoAction);
pdfPage01.AnnotInsert(0, linkAnnot);
// Act
_testEntityPrivate.Invoke(GetPageDetailsMethodName, pdfDoc);
}
finally
{
pdfDoc.Dispose();
}
// Assert
var page01LinkCollection = _objectEdition.PageCollection[page01Index].LinkCollection;
var page01Links = ConvertToLinkArray(page01LinkCollection);
page01Links.ShouldSatisfyAllConditions(
() => page01Links.Length.ShouldBe(1),
() => page01Links.ShouldContain(link => link.LinkType == GoToLinkType));
}
public static Annot CreatePDFAnnotation(BaseAnnotation annotation, PDFDoc pdfDocument, bool fromViewer)
{
_currentDoc = pdfDocument;
Annot pdfAnnotation;
switch (annotation.Properties.PropertyName)
{
case XMLHighlightText.Names.Highlight:
case XMLHighlightArea.Names.Highlight:
pdfAnnotation = setHighlight(annotation);
break;
case StickyNote.Names.StickyNote:
pdfAnnotation = setStickyNote((StickyNote)annotation, fromViewer);
break;
case MarkArea.Names.MarkArea:
pdfAnnotation = setMarkArea((MarkArea)annotation);
break;
case FreeText.Names.FreeText:
pdfAnnotation = setFreeText((FreeText)annotation, fromViewer);
break;
case Circle.Names.Circle:
pdfAnnotation = setCircle((Circle)annotation);
break;
case Square.Names.Square:
pdfAnnotation = setSquare((Square)annotation);
break;
case Line.Names.Line:
pdfAnnotation = setLine((Line)annotation);
break;
case StamperImage.Names.Stamper:
pdfAnnotation = setStamperImage((StamperImage)annotation);
break;
case StamperText.Names.Stamper:
pdfAnnotation = setStamperText((StamperText)annotation);
break;
case RubberStamp.Names.RubberStamp:
pdfAnnotation = setRubberStamp((RubberStamp)annotation);
break;
case XMLSquiggly.Names.Squiggly:
pdfAnnotation = setSquiggly((XMLSquiggly)annotation);
break;
case XMLStrikeout.Names.Strikeout:
pdfAnnotation = setStrikeout((XMLStrikeout)annotation);
break;
case XMLUnderline.Names.Underline:
pdfAnnotation = setUnderline((XMLUnderline)annotation);
break;
default:
pdfAnnotation = Annot.Create(null, Annot.Type.e_3D, null); // For Compiler. Should never execute this
break;
}
if (!(annotation is FreeText)) // Quick Fix, need to revamp it
{
pdfAnnotation.SetColor(AnnotationsMannager.ConvertColor(new double[] { annotation.ColorRed(), annotation.ColorGreen(), annotation.ColorBlue() }), 3);
}
_currentDoc.GetPage(annotation.Page()).AnnotPushBack(pdfAnnotation);
return(pdfAnnotation);
}
private void _toolManager_AnnotationRemoved(Annot annotation)
{
ResultSnapshot snap = _undoManager.TakeSnapshot();
}
private static void AnnotationHighLevelAPI(PDFDoc doc)
{
// The following code snippet traverses all annotations in the document
System.Console.WriteLine("Traversing all annotations in the document...");
string uri;
int page_num = 1;
for (PageIterator itr = doc.GetPageIterator(); itr.HasNext(); itr.Next())
{
System.Console.WriteLine("Page " + page_num++ + ": ");
Page page = itr.Current();
int num_annots = page.GetNumAnnots();
for (int i = 0; i < num_annots; ++i)
{
Annot annot = page.GetAnnot(i);
if (!annot.IsValid())
{
continue;
}
System.Console.WriteLine("Annot Type: " + annot.GetSDFObj().Get("Subtype").Value().GetName());
Rect bbox = annot.GetRect();
System.Console.WriteLine(" Position: " + bbox.x1
+ ", " + bbox.y1
+ ", " + bbox.x2
+ ", " + bbox.y2);
switch (annot.GetType())
{
case Annot.Type.e_Link:
{
Link lnk = new Link(annot);
Action action = lnk.GetAction();
if (!action.IsValid())
{
continue;
}
if (action.GetType() == Action.Type.e_GoTo)
{
Destination dest = action.GetDest();
if (!dest.IsValid())
{
System.Console.WriteLine(" Destination is not valid");
}
else
{
int pg_num = dest.GetPage().GetIndex();
System.Console.WriteLine(" Links to: page number " + pg_num + " in this document");
}
}
else if (action.GetType() == Action.Type.e_URI)
{
uri = action.GetSDFObj().Get("URI").Value().GetAsPDFText();
System.Console.WriteLine(" Links to: " + uri);
}
// ...
}
break;
case Annot.Type.e_Widget:
break;
case Annot.Type.e_FileAttachment:
break;
// ...
default:
break;
}
}
}
// Use the high-level API to create new annotations.
Page first_page = doc.GetPage(1);
// Create a hyperlink...
Link hyperlink = Link.Create(doc, new Rect(85, 570, 503, 524), Action.CreateURI(doc, "http://www.pdftron.com"));
first_page.AnnotPushBack(hyperlink);
// Create an intra-document link...
Action goto_page_3 = Action.CreateGoto(Destination.CreateFitH(doc.GetPage(3), 0));
Link link = Link.Create(doc, new Rect(85, 458, 503, 502), goto_page_3);
// Set the annotation border width to 3 points...
Annot.BorderStyle border_style = new Annot.BorderStyle(Annot.BorderStyle.Style.e_solid, 3, 0, 0);
//link.SetBorderStyle(border_style);
link.SetColor(new ColorPt(0, 0, 1));
// Add the new annotation to the first page
first_page.AnnotPushBack(link);
// Create a stamp annotation ...
RubberStamp stamp = RubberStamp.Create(doc, new Rect(30, 30, 300, 200));
stamp.SetIcon("Draft");
first_page.AnnotPushBack(stamp);
// Create a file attachment annotation (embed the 'peppers.jpg').
FileAttachment file_attach = FileAttachment.Create(doc, new Rect(80, 280, 200, 320), (input_path + "peppers.jpg"));
first_page.AnnotPushBack(file_attach);
Ink ink = Ink.Create(doc, new Rect(110, 10, 300, 200));
Point pt3 = new Point(110, 10);
//pt3.x = 110; pt3.y = 10;
ink.SetPoint(0, 0, pt3);
pt3.x = 150; pt3.y = 50;
ink.SetPoint(0, 1, pt3);
pt3.x = 190; pt3.y = 60;
ink.SetPoint(0, 2, pt3);
pt3.x = 180; pt3.y = 90;
ink.SetPoint(1, 0, pt3);
pt3.x = 190; pt3.y = 95;
ink.SetPoint(1, 1, pt3);
pt3.x = 200; pt3.y = 100;
ink.SetPoint(1, 2, pt3);
pt3.x = 166; pt3.y = 86;
ink.SetPoint(2, 0, pt3);
pt3.x = 196; pt3.y = 96;
ink.SetPoint(2, 1, pt3);
pt3.x = 221; pt3.y = 121;
ink.SetPoint(2, 2, pt3);
pt3.x = 288; pt3.y = 188;
ink.SetPoint(2, 3, pt3);
ink.SetColor(new ColorPt(0, 1, 1), 3);
first_page.AnnotPushBack(ink);
}
static void Main(string[] args)
{
PDFNet.Initialize();
// Relative path to the folder containing test files.
// string input_path = "../../TestFiles/";
string output_path = "../../TestFiles/Output/";
// The vector used to store the name and count of all fields.
// This is used later on to clone the fields
Dictionary <string, int> field_names = new Dictionary <string, int>();
//----------------------------------------------------------------------------------
// Example 1: Programatically create new Form Fields and Widget Annotations.
//----------------------------------------------------------------------------------
try
{
using (PDFDoc doc = new PDFDoc())
{
// Create a blank new page and add some form fields.
Page blank_page = doc.PageCreate();
// Text Widget Creation
// Create an empty text widget with black text.
TextWidget text1 = TextWidget.Create(doc, new Rect(110, 700, 380, 730));
text1.SetText("Basic Text Field");
text1.RefreshAppearance();
blank_page.AnnotPushBack(text1);
// Create a vertical text widget with blue text and a yellow background.
TextWidget text2 = TextWidget.Create(doc, new Rect(50, 400, 90, 730));
text2.SetRotation(90);
// Set the text content.
text2.SetText(" ****Lucky Stars!****");
// Set the font type, text color, font size, border color and background color.
text2.SetFont(Font.Create(doc, Font.StandardType1Font.e_helvetica_oblique));
text2.SetFontSize(28);
text2.SetTextColor(new ColorPt(0, 0, 1), 3);
text2.SetBorderColor(new ColorPt(0, 0, 0), 3);
text2.SetBackgroundColor(new ColorPt(1, 1, 0), 3);
text2.RefreshAppearance();
// Add the annotation to the page.
blank_page.AnnotPushBack(text2);
// Create two new text widget with Field names employee.name.first and employee.name.last
// This logic shows how these widgets can be created using either a field name string or
// a Field object
TextWidget text3 = TextWidget.Create(doc, new Rect(110, 660, 380, 690), "employee.name.first");
text3.SetText("Levi");
text3.SetFont(Font.Create(doc, Font.StandardType1Font.e_times_bold));
text3.RefreshAppearance();
blank_page.AnnotPushBack(text3);
Field emp_last_name = doc.FieldCreate("employee.name.last", Field.Type.e_text, "Ackerman");
TextWidget text4 = TextWidget.Create(doc, new Rect(110, 620, 380, 650), emp_last_name);
text4.SetFont(Font.Create(doc, Font.StandardType1Font.e_times_bold));
text4.RefreshAppearance();
blank_page.AnnotPushBack(text4);
// Signature Widget Creation (unsigned)
SignatureWidget signature1 = SignatureWidget.Create(doc, new Rect(110, 560, 260, 610));
signature1.RefreshAppearance();
blank_page.AnnotPushBack(signature1);
// CheckBox Widget Creation
// Create a check box widget that is not checked.
CheckBoxWidget check1 = CheckBoxWidget.Create(doc, new Rect(140, 490, 170, 520));
check1.RefreshAppearance();
blank_page.AnnotPushBack(check1);
// Create a check box widget that is checked.
CheckBoxWidget check2 = CheckBoxWidget.Create(doc, new Rect(190, 490, 250, 540), "employee.name.check1");
check2.SetBackgroundColor(new ColorPt(1, 1, 1), 3);
check2.SetBorderColor(new ColorPt(0, 0, 0), 3);
// Check the widget (by default it is unchecked).
check2.SetChecked(true);
check2.RefreshAppearance();
blank_page.AnnotPushBack(check2);
// PushButton Widget Creation
PushButtonWidget pushbutton1 = PushButtonWidget.Create(doc, new Rect(380, 490, 520, 540));
pushbutton1.SetTextColor(new ColorPt(1, 1, 1), 3);
pushbutton1.SetFontSize(36);
pushbutton1.SetBackgroundColor(new ColorPt(0, 0, 0), 3);
// Add a caption for the pushbutton.
pushbutton1.SetStaticCaptionText("PushButton");
pushbutton1.RefreshAppearance();
blank_page.AnnotPushBack(pushbutton1);
// ComboBox Widget Creation
ComboBoxWidget combo1 = ComboBoxWidget.Create(doc, new Rect(280, 560, 580, 610));
// Add options to the combobox widget.
combo1.AddOption("Combo Box No.1");
combo1.AddOption("Combo Box No.2");
combo1.AddOption("Combo Box No.3");
// Make one of the options in the combo box selected by default.
combo1.SetSelectedOption("Combo Box No.2");
combo1.SetTextColor(new ColorPt(1, 0, 0), 3);
combo1.SetFontSize(28);
combo1.RefreshAppearance();
blank_page.AnnotPushBack(combo1);
// ListBox Widget Creation
ListBoxWidget list1 = ListBoxWidget.Create(doc, new Rect(400, 620, 580, 730));
// Add one option to the listbox widget.
list1.AddOption("List Box No.1");
// Add multiple options to the listbox widget in a batch.
string[] list_options = new string[2] {
"List Box No.2", "List Box No.3"
};
list1.AddOptions(list_options);
// Select some of the options in list box as default options
list1.SetSelectedOptions(list_options);
// Enable list box to have multi-select when editing.
list1.GetField().SetFlag(Field.Flag.e_multiselect, true);
list1.SetFont(Font.Create(doc, Font.StandardType1Font.e_times_italic));
list1.SetTextColor(new ColorPt(1, 0, 0), 3);
list1.SetFontSize(28);
list1.SetBackgroundColor(new ColorPt(1, 1, 1), 3);
list1.RefreshAppearance();
blank_page.AnnotPushBack(list1);
// RadioButton Widget Creation
// Create a radio button group and add three radio buttons in it.
RadioButtonGroup radio_group = RadioButtonGroup.Create(doc, "RadioGroup");
RadioButtonWidget radiobutton1 = radio_group.Add(new Rect(140, 410, 190, 460));
radiobutton1.SetBackgroundColor(new ColorPt(1, 1, 0), 3);
radiobutton1.RefreshAppearance();
RadioButtonWidget radiobutton2 = radio_group.Add(new Rect(310, 410, 360, 460));
radiobutton2.SetBackgroundColor(new ColorPt(0, 1, 0), 3);
radiobutton2.RefreshAppearance();
RadioButtonWidget radiobutton3 = radio_group.Add(new Rect(480, 410, 530, 460));
// Enable the third radio button. By default the first one is selected
radiobutton3.EnableButton();
radiobutton3.SetBackgroundColor(new ColorPt(0, 1, 1), 3);
radiobutton3.RefreshAppearance();
radio_group.AddGroupButtonsToPage(blank_page);
// Custom push button annotation creation
PushButtonWidget custom_pushbutton1 = PushButtonWidget.Create(doc, new Rect(260, 320, 360, 360));
// Set the annotation appearance.
custom_pushbutton1.SetAppearance(CreateCustomButtonAppearance(doc, false), Annot.AnnotationState.e_normal);
// Create 'SubmitForm' action. The action will be linked to the button.
FileSpec url = FileSpec.CreateURL(doc, "http://www.pdftron.com");
pdftron.PDF.Action button_action = pdftron.PDF.Action.CreateSubmitForm(url);
// Associate the above action with 'Down' event in annotations action dictionary.
Obj annot_action = custom_pushbutton1.GetSDFObj().PutDict("AA");
annot_action.Put("D", button_action.GetSDFObj());
blank_page.AnnotPushBack(custom_pushbutton1);
// Add the page as the last page in the document.
doc.PagePushBack(blank_page);
// If you are not satisfied with the look of default auto-generated appearance
// streams you can delete "AP" entry from the Widget annotation and set
// "NeedAppearances" flag in AcroForm dictionary:
// doc.GetAcroForm().PutBool("NeedAppearances", true);
// This will force the viewer application to auto-generate new appearance streams
// every time the document is opened.
//
// Alternatively you can generate custom annotation appearance using ElementWriter
// and then set the "AP" entry in the widget dictionary to the new appearance
// stream.
//
// Yet another option is to pre-populate field entries with dummy text. When
// you edit the field values using PDFNet the new field appearances will match
// the old ones.
doc.RefreshFieldAppearances();
doc.Save(output_path + "forms_test1.pdf", 0);
Console.WriteLine("Done.");
}
}
catch (PDFNetException e)
{
Console.WriteLine(e.Message);
}
//----------------------------------------------------------------------------------
// Example 2:
// Fill-in forms / Modify values of existing fields.
// Traverse all form fields in the document (and print out their names).
// Search for specific fields in the document.
//----------------------------------------------------------------------------------
try
{
using (PDFDoc doc = new PDFDoc(output_path + "forms_test1.pdf"))
{
doc.InitSecurityHandler();
FieldIterator itr;
for (itr = doc.GetFieldIterator(); itr.HasNext(); itr.Next())
{
Field field = itr.Current();
string cur_field_name = field.GetName();
// Add one to the count for this field name for later processing
field_names[cur_field_name] = (field_names.ContainsKey(cur_field_name) ? field_names[cur_field_name] + 1 : 1);
Console.WriteLine("Field name: {0}", field.GetName());
Console.WriteLine("Field partial name: {0}", field.GetPartialName());
string str_val = field.GetValueAsString();
Console.Write("Field type: ");
Field.Type type = field.GetType();
switch (type)
{
case Field.Type.e_button:
Console.WriteLine("Button");
break;
case Field.Type.e_radio:
Console.WriteLine("Radio button: Value = " + str_val);
break;
case Field.Type.e_check:
field.SetValue(true);
Console.WriteLine("Check box: Value = " + str_val);
break;
case Field.Type.e_text:
{
Console.WriteLine("Text");
// Edit all variable text in the document
String old_value = "none";
if (field.GetValue() != null)
{
old_value = field.GetValue().GetAsPDFText();
}
field.SetValue("This is a new value. The old one was: " + old_value);
}
break;
case Field.Type.e_choice:
Console.WriteLine("Choice");
break;
case Field.Type.e_signature:
Console.WriteLine("Signature");
break;
}
Console.WriteLine("------------------------------");
}
// Search for a specific field
Field fld = doc.GetField("employee.name.first");
if (fld != null)
{
Console.WriteLine("Field search for {0} was successful", fld.GetName());
}
else
{
Console.WriteLine("Field search failed.");
}
// Regenerate field appearances.
doc.RefreshFieldAppearances();
doc.Save(output_path + "forms_test_edit.pdf", 0);
Console.WriteLine("Done.");
}
}
catch (PDFNetException e)
{
Console.WriteLine(e.Message);
}
//----------------------------------------------------------------------------------
// Sample: Form templating
// Replicate pages and form data within a document. Then rename field names to make
// them unique.
//----------------------------------------------------------------------------------
try
{
// Sample: Copying the page with forms within the same document
using (PDFDoc doc = new PDFDoc(output_path + "forms_test1.pdf"))
{
doc.InitSecurityHandler();
Page src_page = doc.GetPage(1);
doc.PagePushBack(src_page); // Append several copies of the second page
doc.PagePushBack(src_page); // Note that forms are successfully copied
doc.PagePushBack(src_page);
doc.PagePushBack(src_page);
// Now we rename fields in order to make every field unique.
// You can use this technique for dynamic template filling where you have a 'master'
// form page that should be replicated, but with unique field names on every page.
foreach (KeyValuePair <string, int> cur_field in field_names)
{
RenameAllFields(doc, cur_field.Key, cur_field.Value);
}
doc.Save(output_path + "forms_test1_cloned.pdf", 0);
Console.WriteLine("Done.");
}
}
catch (PDFNetException e)
{
Console.WriteLine(e.Message);
}
//----------------------------------------------------------------------------------
// Sample:
// Flatten all form fields in a document.
// Note that this sample is intended to show that it is possible to flatten
// individual fields. PDFNet provides a utility function PDFDoc.FlattenAnnotations()
// that will automatically flatten all fields.
//----------------------------------------------------------------------------------
try
{
using (PDFDoc doc = new PDFDoc(output_path + "forms_test1.pdf"))
{
doc.InitSecurityHandler();
bool auto = true;
if (auto)
{
doc.FlattenAnnotations();
}
else // Manual flattening
{
// Traverse all pages
PageIterator pitr = doc.GetPageIterator();
for (; pitr.HasNext(); pitr.Next())
{
Page page = pitr.Current();
for (int i = page.GetNumAnnots() - 1; i >= 0; --i)
{
Annot annot = page.GetAnnot(i);
if (annot.GetType() == Annot.Type.e_Widget)
{
annot.Flatten(page);
}
}
}
}
doc.Save(output_path + "forms_test1_flattened.pdf", 0);
Console.WriteLine("Done.");
}
}
catch (PDFNetException e)
{
Console.WriteLine(e.Message);
}
}
static void CreateHighlightAnnots(Annotation annotation, System.Drawing.Color highlightColor, Document document, List <Rect> coveredRectsBefore, out List <Rect> coveredRectsAfter)
{
List <Quad> quads = annotation.Quads.Where(q => q.IsContainer == false).ToList();
List <int> pages = quads.Select(q => q.PageIndex).ToList().Distinct().ToList();
pages.Sort();
KnowledgeItem quotation = (KnowledgeItem)annotation.EntityLinks.Where(e => e.Indication == EntityLink.PdfKnowledgeItemIndication).FirstOrDefault().Source;
string quotationText = quotation.Text;
if (string.IsNullOrEmpty(quotationText))
{
quotationText = quotation.CoreStatement;
}
bool TextAlreadyWrittenToAnAnnotation = false;
coveredRectsAfter = coveredRectsBefore;
double currentR = highlightColor.R;
double currentG = highlightColor.G;
double currentB = highlightColor.B;
double currentA = highlightColor.A;
ColorPt colorPt = new ColorPt(
currentR / 255,
currentG / 255,
currentB / 255
);
double highlightOpacity = currentA / 255;
foreach (int pageIndex in pages)
{
pdftron.PDF.Page page = document.GetPage(pageIndex);
if (page == null)
{
continue;
}
if (!page.IsValid())
{
continue;
}
List <Quad> quadsOnThisPage = annotation.Quads.Where(q => q.PageIndex == pageIndex && q.IsContainer == false).Distinct().ToList();
List <Rect> boxes = new List <Rect>();
foreach (Quad quad in quadsOnThisPage)
{
boxes.Add(new Rect(quad.MinX, quad.MinY, quad.MaxX, quad.MaxY));
}
Annot newAnnot = null;
// If we want to make the later annotation invisible, we should uncomment the following if then else, and comment out the line after that
if (boxes.Select(b => new { b.x1, b.y1, b.x2, b.y2 }).Intersect(coveredRectsAfter.Select(b => new { b.x1, b.y1, b.x2, b.y2 })).Count() == boxes.Count())
{
newAnnot = CreateSingleHighlightAnnot(document, boxes, colorPt, 0);
}
else
{
newAnnot = CreateSingleHighlightAnnot(document, boxes, colorPt, highlightOpacity);
}
// newAnnot = CreateSingleHighlightAnnot(document, boxes, colorPt, highlightOpacity);
if (!TextAlreadyWrittenToAnAnnotation)
{
newAnnot.SetContents(quotationText);
TextAlreadyWrittenToAnAnnotation = true;
}
page.AnnotPushBack(newAnnot);
if (newAnnot.IsValid() == false)
{
continue;
}
if (newAnnot.GetAppearance() == null)
{
newAnnot.RefreshAppearance();
}
coveredRectsAfter.AddRange(boxes);
}
}
public static void AnnotationsImport(QuotationType quotationType)
{
// Static Variables
PreviewControl previewControl = PreviewMethods.GetPreviewControl();
if (previewControl == null)
{
return;
}
PdfViewControl pdfViewControl = previewControl.GetPdfViewControl();
if (pdfViewControl == null)
{
return;
}
Document document = pdfViewControl.Document;
if (document == null)
{
return;
}
Location location = previewControl.ActiveLocation;
if (location == null)
{
return;
}
List <Reference> references = Program.ActiveProjectShell.Project.References.Where(r => r.Locations.Contains(location)).ToList();
if (references == null)
{
return;
}
if (references.Count != 1)
{
MessageBox.Show("The document is not linked with exactly one reference. Import aborted.");
}
Reference reference = references.FirstOrDefault();
if (references == null)
{
return;
}
LinkedResource linkedResource = location.Address;
string pathToFile = linkedResource.Resolve().LocalPath;
PreviewBehaviour previewBehaviour = location.PreviewBehaviour;
// Dynamic Variables
string colorPickerCaption = string.Empty;
List <ColorPt> selectedColorPts = new List <ColorPt>();
int annotationsImportedCount = 0;
bool ImportEmptyAnnotations = false;
bool RedrawAnnotations = true;
// The Magic
Form commentAnnotationsColorPicker = new AnnotationsImporterColorPicker(quotationType, document.ExistingColors(), out selectedColorPts);
DialogResult dialogResult = commentAnnotationsColorPicker.ShowDialog();
RedrawAnnotations = AnnotationsImporterColorPicker.RedrawAnnotationsSelected;
ImportEmptyAnnotations = AnnotationsImporterColorPicker.ImportEmptyAnnotationsSelected;
if (dialogResult == DialogResult.Cancel)
{
MessageBox.Show("Import of external highlights cancelled.");
return;
}
List <Annotation> temporaryAnnotations = new List <Annotation>();
if (ImportEmptyAnnotations || quotationType == QuotationType.Comment)
{
for (int pageIndex = 1; pageIndex <= document.GetPageCount(); pageIndex++)
{
pdftron.PDF.Page page = document.GetPage(pageIndex);
if (page.IsValid())
{
List <Annot> annotsToDelete = new List <Annot>();
for (int j = 0; j < page.GetNumAnnots(); j++)
{
Annot annot = page.GetAnnot(j);
if (annot.GetSDFObj() != null && (annot.GetType() == Annot.Type.e_Highlight || annot.GetType() == Annot.Type.e_Unknown))
{
Highlight highlight = new Highlight(annot);
if (highlight == null)
{
continue;
}
ColorPt annotColorPt = annot.GetColorAsRGB();
if (selectedColorPts.Where(e =>
e.Get(0) == annotColorPt.Get(0) &&
e.Get(1) == annotColorPt.Get(1) &&
e.Get(2) == annotColorPt.Get(2) &&
e.Get(3) == annotColorPt.Get(3)
).Count() == 0)
{
continue;
}
Annotation temporaryAnnotation = highlight.TemporaryAnnotation();
location.Annotations.Add(temporaryAnnotation);
temporaryAnnotations.Add(temporaryAnnotation);
}
} // end for (int j = 1; j <= page.GetNumAnnots(); j++)
} // end if (page.IsValid())
} // end for (int i = 1; i <= document.GetPageCount(); i++)
previewControl.ShowNoPreview();
location.PreviewBehaviour = PreviewBehaviour.SkipEntryPage;
previewControl.ShowLocationPreview(location);
document = new Document(pathToFile);
}
//Uncomment here to get an overview of all annotations
//int x = 0;
//foreach (Annotation a in location.Annotations)
//{
// System.Diagnostics.Debug.WriteLine("Annotation " + x.ToString());
// int y = 0;
// foreach (Quad q in a.Quads)
// {
// System.Diagnostics.Debug.WriteLine("Quad " + y.ToString());
// System.Diagnostics.Debug.WriteLine("IsContainer: " + q.IsContainer.ToString());
// System.Diagnostics.Debug.WriteLine("MinX: " + q.MinX.ToString());
// System.Diagnostics.Debug.WriteLine("MinY: " + q.MinY.ToString());
// System.Diagnostics.Debug.WriteLine("MaxX: " + q.MaxX.ToString());
// System.Diagnostics.Debug.WriteLine("MaxY: " + q.MaxY.ToString());
// y = y + 1;
// }
// x = x + 1;
//}
int v = 0;
for (int pageIndex = 1; pageIndex <= document.GetPageCount(); pageIndex++)
{
pdftron.PDF.Page page = document.GetPage(pageIndex);
if (page.IsValid())
{
List <Annot> annotsToDelete = new List <Annot>();
for (int j = 0; j < page.GetNumAnnots(); j++)
{
Annot annot = page.GetAnnot(j);
if (annot.GetSDFObj() != null && (annot.GetType() == Annot.Type.e_Highlight || annot.GetType() == Annot.Type.e_Unknown))
{
Highlight highlight = new Highlight(annot);
if (highlight == null)
{
continue;
}
ColorPt annotColorPt = annot.GetColorAsRGB();
if (selectedColorPts.Where(e =>
e.Get(0) == annotColorPt.Get(0) &&
e.Get(1) == annotColorPt.Get(1) &&
e.Get(2) == annotColorPt.Get(2) &&
e.Get(3) == annotColorPt.Get(3)
).Count() == 0)
{
continue;
}
// Uncomment here to get an overview of all highlights
//System.Diagnostics.Debug.WriteLine("Highlight " + v.ToString());
//int w = 0;
//foreach (Quad q in highlight.AsAnnotationQuads())
//{
// System.Diagnostics.Debug.WriteLine("Quad " + w.ToString());
// System.Diagnostics.Debug.WriteLine("IsContainer: " + q.IsContainer.ToString());
// System.Diagnostics.Debug.WriteLine("MinX: " + q.MinX.ToString());
// System.Diagnostics.Debug.WriteLine("MinY: " + q.MinY.ToString());
// System.Diagnostics.Debug.WriteLine("MaxX: " + q.MaxX.ToString());
// System.Diagnostics.Debug.WriteLine("MaxY: " + q.MaxY.ToString());
// w = w + 1;
//}
//v = v + 1;
if (highlight.UpdateExistingQuotation(quotationType, location))
{
annotationsImportedCount++;
continue;
}
if (highlight.CreateNewQuotationAndAnnotationFromHighlight(quotationType, ImportEmptyAnnotations, RedrawAnnotations, temporaryAnnotations))
{
annotationsImportedCount++;
continue;
}
}
} // end for (int j = 1; j <= page.GetNumAnnots(); j++)
foreach (Annot annot in annotsToDelete)
{
page.AnnotRemove(annot);
}
} // end if (page.IsValid())
} // end for (int i = 1; i <= document.GetPageCount(); i++)
foreach (Annotation annotation in temporaryAnnotations)
{
location.Annotations.Remove(annotation);
}
location.PreviewBehaviour = previewBehaviour;
MessageBox.Show(annotationsImportedCount.ToString() + " highlights have been imported.");
}
