public static string GetExportValue(AcroFields.Item item)
{
var valueDict = item.GetValue(0);
var appearanceDict = valueDict.GetAsDict(PdfName.AP);
if (appearanceDict != null)
{
var normalAppearances = appearanceDict.GetAsDict(PdfName.N);
if (normalAppearances != null)
{
foreach (var curKey in normalAppearances.Keys)
{
if (!PdfName.OFF.Equals(curKey))
{
return(curKey.ToString().Substring(1));
}
}
}
}
var curVal = valueDict.GetAsName(PdfName.AS);
if (curVal != null)
{
return(curVal.ToString().Substring(1));
}
else
{
return(string.Empty);
}
}
// ---------------------------------------------------------------------------
/**
* Manipulates a PDF file src with the file dest as result
* @param src the original PDF
*/
public byte[] ManipulatePdf(byte[] src)
{
PdfReader reader = new PdfReader(src);
using (MemoryStream ms = new MemoryStream()) {
using (PdfStamper stamper = new PdfStamper(reader, ms)) {
stamper.Writer.AddJavaScript(File.ReadAllText(RESOURCE));
AcroFields form = stamper.AcroFields;
AcroFields.Item fd = form.GetFieldItem("married");
PdfDictionary dictYes =
(PdfDictionary)PdfReader.GetPdfObject(fd.GetWidgetRef(0));
PdfDictionary yesAction = dictYes.GetAsDict(PdfName.AA);
if (yesAction == null)
{
yesAction = new PdfDictionary();
}
yesAction.Put(
new PdfName("Fo"),
PdfAction.JavaScript("ReadOnly = false);", stamper.Writer)
);
dictYes.Put(PdfName.AA, yesAction);
PdfDictionary dictNo =
(PdfDictionary)PdfReader.GetPdfObject(fd.GetWidgetRef(1));
PdfDictionary noAction = dictNo.GetAsDict(PdfName.AA);
if (noAction == null)
{
noAction = new PdfDictionary();
}
noAction.Put(
new PdfName("Fo"),
PdfAction.JavaScript("ReadOnly = true);", stamper.Writer)
);
dictNo.Put(PdfName.AA, noAction);
PdfWriter writer = stamper.Writer;
PushbuttonField button = new PushbuttonField(
writer, new Rectangle(40, 690, 200, 710), "submit"
);
button.Text = "validate and submit";
button.Options = PushbuttonField.VISIBLE_BUT_DOES_NOT_PRINT;
PdfFormField validateAndSubmit = button.Field;
validateAndSubmit.Action = PdfAction.JavaScript(
"validate();", stamper.Writer
);
stamper.AddAnnotation(validateAndSubmit, 1);
}
return(ms.ToArray());
}
}
public static TextProperties GetTextProperties(this AcroFields pdfForm, string acroFieldName)
{
AcroFields.Item acroField = pdfForm.GetFieldItem(acroFieldName);
PdfDictionary merged = acroField.GetMerged(0);
TextField textField = new TextField(null, null, null);
pdfForm.DecodeGenericDictionary(merged, textField);
return(new TextProperties {
FontName = textField.Font.With(x => x.FullFontName[0][3]),
FontSize = textField.FontSize,
Alignment = textField.Alignment
});
}
// ---------------------------------------------------------------------------
/**
* Manipulates a PDF file src with the file dest as result
* @param src the original PDF
*/
public byte[] ManipulatePdf(byte[] src)
{
PdfReader reader = new PdfReader(src);
AcroFields form = reader.AcroFields;
AcroFields.Item item = form.GetFieldItem("post");
PdfDictionary field = item.GetMerged(0);
PdfDictionary action = field.GetAsDict(PdfName.A);
PdfDictionary f = action.GetAsDict(PdfName.F);
f.Put(PdfName.F, new PdfString("http://NON-EXISTENT-DOMAIN.invalid/"));
using (MemoryStream ms = new MemoryStream()) {
using (PdfStamper stamper = new PdfStamper(reader, ms)) {
}
return(ms.ToArray());
}
}
Queue <Tuple <string, string, string> > Fill109Rows(IEnumerable <MissionLog> logs, AcroFields fields, string fieldName)
{
AcroFields.Item item = fields.GetFieldItem(fieldName);
PdfDictionary merged = item.GetMerged(0);
TextField textField = new TextField(null, null, null);
fields.DecodeGenericDictionary(merged, textField);
var collection = new Queue <Tuple <string, string, string> >();
float fieldWidth = fields.GetFieldPositions(fieldName)[0].position.Width;
float padRight = textField.Font.GetWidthPoint("m", textField.FontSize);
foreach (var log in logs)
{
if (log.Data == null)
{
continue;
}
string formTime = log.Time.ToString("HHmm");
string formOperator = (log.Person ?? new Member()).LastName;
foreach (var logMsg in log.Data.Replace("\r", "").Split(new[] { '\n' }, StringSplitOptions.RemoveEmptyEntries))
{
int left = 0;
int right = logMsg.Length - 1;
while (left < right)
{
string part = logMsg.Substring(left, right - left + 1);
while (left < right && (textField.Font.GetWidthPoint(part, textField.FontSize) + padRight) > fieldWidth)
{
right = left + part.LastIndexOf(' ');
part = logMsg.Substring(left, right - left);
}
collection.Enqueue(new Tuple <string, string, string>(formTime, part, formOperator));
formTime = "";
left = right;
right = logMsg.Length - 1;
}
}
}
return(collection);
}
/** Sets all the fields from this <CODE>AcroFields</CODE>
* @param acro the <CODE>AcroFields</CODE>
*/
public void SetFields(AcroFields af)
{
foreach (DictionaryEntry entry in af.Fields)
{
String fn = (String)entry.Key;
AcroFields.Item item = (AcroFields.Item)entry.Value;
PdfDictionary dic = item.GetMerged(0);
PdfObject v = PdfReader.GetPdfObjectRelease(dic.Get(PdfName.V));
if (v == null)
{
continue;
}
PdfObject ft = PdfReader.GetPdfObjectRelease(dic.Get(PdfName.FT));
if (ft == null || PdfName.SIG.Equals(ft))
{
continue;
}
SetField(fn, v);
}
}
// See http://stackoverflow.com/questions/4491156/get-the-export-value-of-a-checkbox-using-itextsharp/
public static string GetExportValue(AcroFields.Item item)
{
var valueDict = item.GetValue(0);
var appearanceDict = valueDict.GetAsDict(PdfName.AP);
if (appearanceDict != null)
{
var normalAppearances = appearanceDict.GetAsDict(PdfName.N);
// /D is for the "down" appearances.
// if there are normal appearances, one key will be "Off", and the other
// will be the export value... there should only be two.
if (normalAppearances != null)
{
foreach (var curKey in normalAppearances.Keys)
{
if (!PdfName.OFF.Equals(curKey))
{
return(curKey.ToString().Substring(1));
}
}
// string will have a leading '/' character, so remove it!
}
}
// if that doesn't work, there might be an /AS key, whose value is a name with
// the export value, again with a leading '/', so remove it!
var curVal = valueDict.GetAsName(PdfName.AS);
if (curVal != null)
{
return(curVal.ToString().Substring(1));
}
else
{
return(string.Empty);
}
}
internal void CreateWidgets(ArrayList list, AcroFields.Item item)
{
for (int k = 0; k < item.Size; ++k)
{
list.Add(item.GetPage(k));
PdfDictionary merged = item.GetMerged(k);
PdfObject dr = merged.Get(PdfName.DR);
if (dr != null)
{
PdfFormField.MergeResources(resources, (PdfDictionary)PdfReader.GetPdfObject(dr));
}
PdfDictionary widget = new PdfDictionary();
foreach (PdfName key in merged.Keys)
{
if (widgetKeys.ContainsKey(key))
{
widget.Put(key, merged.Get(key));
}
}
widget.Put(iTextTag, new PdfNumber(item.GetTabOrder(k) + 1));
list.Add(widget);
}
}
internal void MergeField(String name, AcroFields.Item item)
{
Hashtable map = fieldTree;
StringTokenizer tk = new StringTokenizer(name, ".");
if (!tk.HasMoreTokens())
{
return;
}
while (true)
{
String s = tk.NextToken();
Object obj = map[s];
if (tk.HasMoreTokens())
{
if (obj == null)
{
obj = new Hashtable();
map[s] = obj;
map = (Hashtable)obj;
continue;
}
else if (obj is Hashtable)
{
map = (Hashtable)obj;
}
else
{
return;
}
}
else
{
if (obj is Hashtable)
{
return;
}
PdfDictionary merged = item.GetMerged(0);
if (obj == null)
{
PdfDictionary field = new PdfDictionary();
if (PdfName.SIG.Equals(merged.Get(PdfName.FT)))
{
hasSignature = true;
}
foreach (PdfName key in merged.Keys)
{
if (fieldKeys.ContainsKey(key))
{
field.Put(key, merged.Get(key));
}
}
ArrayList list = new ArrayList();
list.Add(field);
CreateWidgets(list, item);
map[s] = list;
}
else
{
ArrayList list = (ArrayList)obj;
PdfDictionary field = (PdfDictionary)list[0];
PdfName type1 = (PdfName)field.Get(PdfName.FT);
PdfName type2 = (PdfName)merged.Get(PdfName.FT);
if (type1 == null || !type1.Equals(type2))
{
return;
}
int flag1 = 0;
PdfObject f1 = field.Get(PdfName.FF);
if (f1 != null && f1.IsNumber())
{
flag1 = ((PdfNumber)f1).IntValue;
}
int flag2 = 0;
PdfObject f2 = merged.Get(PdfName.FF);
if (f2 != null && f2.IsNumber())
{
flag2 = ((PdfNumber)f2).IntValue;
}
if (type1.Equals(PdfName.BTN))
{
if (((flag1 ^ flag2) & PdfFormField.FF_PUSHBUTTON) != 0)
{
return;
}
if ((flag1 & PdfFormField.FF_PUSHBUTTON) == 0 && ((flag1 ^ flag2) & PdfFormField.FF_RADIO) != 0)
{
return;
}
}
else if (type1.Equals(PdfName.CH))
{
if (((flag1 ^ flag2) & PdfFormField.FF_COMBO) != 0)
{
return;
}
}
CreateWidgets(list, item);
}
return;
}
}
}
/// <summary>
/// Handles the Click event of the BtnGenerateReport control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="EventArgs"/> instance containing the event data.</param>
private void BtnGenerateReport_Click(object sender, EventArgs e)
{
if (!string.IsNullOrWhiteSpace(txtPDFFile.Text))
{
_formFields.Clear();
try
{
using (MemoryStream ms = new MemoryStream())
{
using (FileStream fs = File.OpenRead(txtPDFFile.Text))
{
fs.CopyTo(ms);
}
PdfReader.unethicalreading = true;
PdfReader pdfReader = new PdfReader(ms.ToArray());
AcroFields pdfFormFields = pdfReader.AcroFields;
foreach (KeyValuePair <string, AcroFields.Item> kvp in pdfFormFields.Fields)
{
FormField formField = new FormField
{
FieldName = pdfFormFields.GetTranslatedFieldName(kvp.Key),
FieldValue = pdfFormFields.GetField(kvp.Key),
FieldType = GetFormFieldType(pdfFormFields.GetFieldType(kvp.Key))
};
AcroFields.Item field = pdfFormFields.GetFieldItem(kvp.Key);
PdfDictionary merged = field.GetMerged(0);
TextField fld = new TextField(null, null, null);
pdfFormFields.DecodeGenericDictionary(merged, fld);
formField.FontName = GetFontName(fld.Font);
string fontSize = (fld.FontSize == 0.0f) ? "Auto" : fld.FontSize.ToString();
formField.FontSize = fontSize;
List <AcroFields.FieldPosition> fieldPositions = pdfFormFields.GetFieldPositions(kvp.Key).ToList();
float pageHeight = pdfReader.GetPageSizeWithRotation(fieldPositions[0].page).Height;
formField.FieldPositionTop = (pageHeight - fieldPositions[0].position.Top);
formField.FieldPositionBottom = (pageHeight - fieldPositions[0].position.Bottom);
formField.FieldPositionLeft = fieldPositions[0].position.Left;
formField.FieldPositionRight = fieldPositions[0].position.Right;
formField.FieldHeight = fieldPositions[0].position.Height;
formField.FieldWidth = fieldPositions[0].position.Width;
formField.PageNumber = fieldPositions[0].page;
_formFields.Add(formField);
}
GenerateTreeViewDisplay();
pnlSaveOptions.Enabled = true;
}
}
catch (Exception ex)
{
MessageBox.Show("There was an issue with processing the request. Message: \n\n" + ex.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
pnlSaveOptions.Enabled = pnlSaveOptions.Enabled ? true : false;
}
}
}
private void FillFields(AcroFields acroFields)
{
var fields = new LinkedDictionary <string, AcroFields.Item>();
typeof(AcroFields).GetField("fields", BindingFlags.Instance | BindingFlags.NonPublic).SetValue(acroFields, fields);
PdfDictionary top = (PdfDictionary)GetPdfObjectRelease(Catalog.Get(PdfName.ACROFORM));
if (top == null)
{
return;
}
PdfArray arrfds = (PdfArray)GetPdfObjectRelease(top.Get(PdfName.FIELDS));
if (arrfds == null || arrfds.Size == 0)
{
return;
}
for (int k = 1; k <= NumberOfPages; ++k)
{
PdfDictionary page = GetPageNRelease(k);
PdfArray annots = (PdfArray)GetPdfObjectRelease(page.Get(PdfName.ANNOTS), page);
if (annots == null)
{
continue;
}
for (int j = 0; j < annots.Size; ++j)
{
PdfDictionary annot = annots.GetAsDict(j);
if (annot == null)
{
ReleaseLastXrefPartial(annots.GetAsIndirectObject(j));
continue;
}
if (!PdfName.WIDGET.Equals(annot.GetAsName(PdfName.SUBTYPE)))
{
ReleaseLastXrefPartial(annots.GetAsIndirectObject(j));
continue;
}
PdfDictionary widget = annot;
PdfDictionary dic = new PdfDictionary();
dic.Merge(annot);
string name = string.Empty;
PdfDictionary value = null;
PdfObject lastV = null;
while (annot != null)
{
dic.Merge(annot);
PdfString t = annot.GetAsString(PdfName.T);
if (t != null)
{
name = t.ToUnicodeString() + "." + name;
}
if (lastV == null && annot.Get(PdfName.V) != null)
{
lastV = GetPdfObjectRelease(annot.Get(PdfName.V));
}
if (value == null && t != null)
{
value = annot;
if (annot.Get(PdfName.V) == null && lastV != null)
{
value.Put(PdfName.V, lastV);
}
}
annot = annot.GetAsDict(PdfName.PARENT);
}
if (name.Length > 0)
{
name = name.Substring(0, name.Length - 1);
}
AcroFields.Item item;
if (!fields.TryGetValue(name, out item))
{
item = new AcroFields.Item();
fields[name] = item;
}
var addValueMethod = item.GetType().GetMethod("AddValue", BindingFlags.Instance | BindingFlags.NonPublic);
if (value == null)
{
addValueMethod.Invoke(item, new object[] { widget });
}
else
{
addValueMethod.Invoke(item, new object[] { value });
}
item.GetType().GetMethod("AddWidget", BindingFlags.Instance | BindingFlags.NonPublic).Invoke(item, new object[] { widget });
item.GetType().GetMethod("AddWidgetRef", BindingFlags.Instance | BindingFlags.NonPublic).Invoke(item, new object[] { annots.GetAsIndirectObject(j) }); // must be a reference
if (top != null)
{
dic.MergeDifferent(top);
}
item.GetType().GetMethod("AddMerged", BindingFlags.Instance | BindingFlags.NonPublic).Invoke(item, new object[] { dic });
item.GetType().GetMethod("AddPage", BindingFlags.Instance | BindingFlags.NonPublic).Invoke(item, new object[] { k });
item.GetType().GetMethod("AddTabOrder", BindingFlags.Instance | BindingFlags.NonPublic).Invoke(item, new object[] { j });
}
}
// some tools produce invisible signatures without an entry in the page annotation array
// look for a single level annotation
PdfNumber sigFlags = top.GetAsNumber(PdfName.SIGFLAGS);
if (sigFlags == null || (sigFlags.IntValue & 1) != 1)
{
return;
}
for (int j = 0; j < arrfds.Size; ++j)
{
PdfDictionary annot = arrfds.GetAsDict(j);
if (annot == null)
{
ReleaseLastXrefPartial(arrfds.GetAsIndirectObject(j));
continue;
}
if (!PdfName.WIDGET.Equals(annot.GetAsName(PdfName.SUBTYPE)))
{
ReleaseLastXrefPartial(arrfds.GetAsIndirectObject(j));
continue;
}
PdfArray kids = (PdfArray)GetPdfObjectRelease(annot.Get(PdfName.KIDS));
if (kids != null)
{
continue;
}
PdfDictionary dic = new PdfDictionary();
dic.Merge(annot);
PdfString t = annot.GetAsString(PdfName.T);
if (t == null)
{
continue;
}
string name = t.ToUnicodeString();
if (fields.ContainsKey(name))
{
continue;
}
var item = new AcroFields.Item();
fields[name] = item;
item.GetType().GetMethod("AddValue", BindingFlags.Instance | BindingFlags.NonPublic).Invoke(item, new object[] { dic });
item.GetType().GetMethod("AddWidget", BindingFlags.Instance | BindingFlags.NonPublic).Invoke(item, new object[] { dic });
item.GetType().GetMethod("AddWidgetRef", BindingFlags.Instance | BindingFlags.NonPublic).Invoke(item, new object[] { arrfds.GetAsIndirectObject(j) }); // must be a reference
item.GetType().GetMethod("AddMerged", BindingFlags.Instance | BindingFlags.NonPublic).Invoke(item, new object[] { dic });
item.GetType().GetMethod("AddPage", BindingFlags.Instance | BindingFlags.NonPublic).Invoke(item, new object[] { -1 });
item.GetType().GetMethod("AddTabOrder", BindingFlags.Instance | BindingFlags.NonPublic).Invoke(item, new object[] { -1 });
}
}
