// pdfio2.c (307, 1) // ptraConcatenatePdfToData(pa_data, sa, pdata, pnbytes) as int // ptraConcatenatePdfToData(L_PTRA *, SARRAY *, l_uint8 **, size_t *) as l_ok /// <summary> /// (1) This only works with leptonica-formatted single-page pdf files. /// pdf files generated by other programs will have unpredictable /// (and usually bad) results. The requirements for each pdf file: /// (a) The Catalog and Info objects are the first two. /// (b) Object 3 is Pages /// (c) Object 4 is Page /// (d) The remaining objects are Contents, XObjects, and ColorSpace<para/> /// /// (2) We remove trailers from each page, and append the full trailer /// for all pages at the end.<para/> /// /// (3) For all but the first file, remove the ID and the first 3 /// objects (catalog, info, pages), so that each subsequent /// file has only objects of these classes: /// Page, Contents, XObject, ColorSpace (Indexed RGB). /// For those objects, we substitute these refs to objects /// in the local file: /// Page: Parent(object 3), Contents, XObject(typically multiple) /// XObject: [ColorSpace if indexed] /// The Pages object on the first page (object 3) has a Kids array /// of references to all the Page objects, with a Count equal /// to the number of pages. Each Page object refers back to /// this parent. /// </summary> /// <remarks> /// </remarks> /// <include file="..\CHM_Help\IncludeComments.xml" path="Comments/ptraConcatenatePdfToData/*"/> /// <param name="pa_data">[in] - ptra array of pdf strings, each for a single-page pdf file</param> /// <param name="sa">[in] - string array [optional] of pathnames for input pdf files</param> /// <param name="pdata">[out] - concatenated pdf data in memory</param> /// <param name="pnbytes">[out] - number of bytes in pdf data</param> /// <returns>0 if OK, 1 on error</returns> public static int ptraConcatenatePdfToData( L_Ptra pa_data, Sarray sa, out Byte[] pdata, out uint pnbytes) { if (pa_data == null) { throw new ArgumentNullException("pa_data cannot be Nothing"); } IntPtr saPtr = IntPtr.Zero; if (sa != null) { saPtr = sa.Pointer; } IntPtr pdataPtr = IntPtr.Zero; int _Result = Natives.ptraConcatenatePdfToData(pa_data.Pointer, saPtr, out pdataPtr, out pnbytes); Byte[] pdataGen = new Byte[pnbytes]; if (pdataPtr != IntPtr.Zero) { Marshal.Copy(pdataPtr, pdataGen, 0, pdataGen.Length); } pdata = pdataGen; return(_Result); }
// ptra.c (625, 1) // ptraReverse(pa) as int // ptraReverse(L_PTRA *) as l_ok /// <summary> /// ptraReverse() /// </summary> /// <remarks> /// </remarks> /// <include file="..\CHM_Help\IncludeComments.xml" path="Comments/ptraReverse/*"/> /// <param name="pa">[in] - ptra</param> /// <returns>0 if OK, 1 on error</returns> public static int ptraReverse( L_Ptra pa) { if (pa == null) { throw new ArgumentNullException("pa cannot be Nothing"); } int _Result = Natives.ptraReverse(pa.Pointer); return(_Result); }
// ptra.c (727, 1) // ptraGetActualCount(pa, pcount) as int // ptraGetActualCount(L_PTRA *, l_int32 *) as l_ok /// <summary> /// (1) The actual number of items on the ptr array, patonactual, /// will be smaller than paton if the array is not compacted. /// </summary> /// <remarks> /// </remarks> /// <include file="..\CHM_Help\IncludeComments.xml" path="Comments/ptraGetActualCount/*"/> /// <param name="pa">[in] - ptra</param> /// <param name="pcount">[out] - actual number of items on the ptr array</param> /// <returns>0 if OK 1 on error</returns> public static int ptraGetActualCount( L_Ptra pa, out int pcount) { if (pa == null) { throw new ArgumentNullException("pa cannot be Nothing"); } int _Result = Natives.ptraGetActualCount(pa.Pointer, out pcount); return(_Result); }
// ptra.c (699, 1) // ptraGetMaxIndex(pa, pmaxindex) as int // ptraGetMaxIndex(L_PTRA *, l_int32 *) as l_ok /// <summary> /// (1) The largest index to an item in the array is %maxindex. /// %maxindex is one less than the number of items that would be /// in the array if there were no null pointers between 0 /// and %maxindex - 1. However, because the internal ptr array /// need not be compacted, there may be NULL pointers at /// indices below %maxindex for example, if items have /// been removed.<para/> /// /// (2) When an item is added to the end of the array, it goes /// into patoarray[maxindex + 1], and maxindex is then /// incremented by 1.<para/> /// /// (3) If there are no items in the array, this returns %maxindex = -1. /// </summary> /// <remarks> /// </remarks> /// <include file="..\CHM_Help\IncludeComments.xml" path="Comments/ptraGetMaxIndex/*"/> /// <param name="pa">[in] - ptra</param> /// <param name="pmaxindex">[out] - index of last item in the array</param> /// <returns>0 if OK 1 on error</returns> public static int ptraGetMaxIndex( L_Ptra pa, out int pmaxindex) { if (pa == null) { throw new ArgumentNullException("pa cannot be Nothing"); } int _Result = Natives.ptraGetMaxIndex(pa.Pointer, out pmaxindex); return(_Result); }
// ptra.c (553, 1) // ptraSwap(pa, index1, index2) as int // ptraSwap(L_PTRA *, l_int32, l_int32) as l_ok /// <summary> /// ptraSwap() /// </summary> /// <remarks> /// </remarks> /// <include file="..\CHM_Help\IncludeComments.xml" path="Comments/ptraSwap/*"/> /// <param name="pa">[in] - ptra</param> /// <param name="index1">[in] - </param> /// <param name="index2">[in] - </param> /// <returns>0 if OK, 1 on error</returns> public static int ptraSwap( L_Ptra pa, int index1, int index2) { if (pa == null) { throw new ArgumentNullException("pa cannot be Nothing"); } int _Result = Natives.ptraSwap(pa.Pointer, index1, index2); return(_Result); }
// ptra.c (483, 1) // ptraRemoveLast(pa) as Object // ptraRemoveLast(L_PTRA *) as void * /// <summary> /// ptraRemoveLast() /// </summary> /// <remarks> /// </remarks> /// <include file="..\CHM_Help\IncludeComments.xml" path="Comments/ptraRemoveLast/*"/> /// <param name="pa">[in] - ptra</param> /// <returns>item, or NULL on error or if the array is empty</returns> public static Object ptraRemoveLast( L_Ptra pa) { if (pa == null) { throw new ArgumentNullException("pa cannot be Nothing"); } IntPtr _Result = Natives.ptraRemoveLast(pa.Pointer); Byte[] B = new Byte[1]; Marshal.Copy(_Result, B, 0, B.Length); return(B); }
// ptra.c (649, 1) // ptraJoin(pa1, pa2) as int // ptraJoin(L_PTRA *, L_PTRA *) as l_ok /// <summary> /// ptraJoin() /// </summary> /// <remarks> /// </remarks> /// <include file="..\CHM_Help\IncludeComments.xml" path="Comments/ptraJoin/*"/> /// <param name="pa1">[in] - add to this one</param> /// <param name="pa2">[in] - appended to pa1, and emptied of items can be null</param> /// <returns>0 if OK, 1 on error</returns> public static int ptraJoin( L_Ptra pa1, L_Ptra pa2) { if (pa1 == null) { throw new ArgumentNullException("pa1 cannot be Nothing"); } if (pa2 == null) { throw new ArgumentNullException("pa2 cannot be Nothing"); } int _Result = Natives.ptraJoin(pa1.Pointer, pa2.Pointer); return(_Result); }
// ptra.c (898, 1) // ptraaInsertPtra(paa, index, pa) as int // ptraaInsertPtra(L_PTRAA *, l_int32, L_PTRA *) as l_ok /// <summary> /// (1) Caller should check return value. On success, the Ptra /// is inserted in the Ptraa and is owned by it. However, /// on error, the Ptra remains owned by the caller. /// </summary> /// <remarks> /// </remarks> /// <include file="..\CHM_Help\IncludeComments.xml" path="Comments/ptraaInsertPtra/*"/> /// <param name="paa">[in] - ptraa</param> /// <param name="index">[in] - location in array for insertion</param> /// <param name="pa">[in] - to be inserted</param> /// <returns>0 if OK 1 on error</returns> public static int ptraaInsertPtra( L_Ptraa paa, int index, L_Ptra pa) { if (paa == null) { throw new ArgumentNullException("paa cannot be Nothing"); } if (pa == null) { throw new ArgumentNullException("pa cannot be Nothing"); } int _Result = Natives.ptraaInsertPtra(paa.Pointer, index, pa.Pointer); return(_Result); }
// ptra.c (512, 1) // ptraReplace(pa, index, item, freeflag) as Object // ptraReplace(L_PTRA *, l_int32, void *, l_int32) as void * /// <summary> /// ptraReplace() /// </summary> /// <remarks> /// </remarks> /// <include file="..\CHM_Help\IncludeComments.xml" path="Comments/ptraReplace/*"/> /// <param name="pa">[in] - ptra</param> /// <param name="index">[in] - element to be replaced</param> /// <param name="item">[in] - new generic ptr to a struct can be null</param> /// <param name="freeflag">[in] - TRUE to free old item FALSE to return it</param> /// <returns>item old item, if it exists and is not freed, or NULL on error</returns> public static Object ptraReplace( L_Ptra pa, int index, Object item, int freeflag) { if (pa == null) { throw new ArgumentNullException("pa cannot be Nothing"); } if (item == null) { throw new ArgumentNullException("item cannot be Nothing"); } IntPtr itemPtr = IntPtr.Zero; if (item.GetType() == typeof(IntPtr)) { itemPtr = (IntPtr)item; } else if (item.GetType() == typeof(Byte[])) { var cdata = (Byte[])item; itemPtr = Marshal.AllocHGlobal(cdata.Length); Marshal.Copy(cdata, 0, itemPtr, cdata.Length); } else if (item.GetType().GetProperty("item") != null) { var cdata = (Byte[])item.GetType().GetProperty("data").GetValue(item, null); itemPtr = Marshal.AllocHGlobal(cdata.Length); Marshal.Copy(cdata, 0, itemPtr, cdata.Length); } IntPtr _Result = Natives.ptraReplace(pa.Pointer, index, itemPtr, freeflag); Marshal.FreeHGlobal(itemPtr); Byte[] B = new Byte[1]; Marshal.Copy(_Result, B, 0, B.Length); return(B); }
// ptra.c (185, 1) // ptraDestroy(ppa, freeflag, warnflag) as Object // ptraDestroy(L_PTRA **, l_int32, l_int32) as void /// <summary> /// (1) If %freeflag == TRUE, frees each item in the array.<para/> /// /// (2) If %freeflag == FALSE and %warnflag == TRUE, and there are /// items on the array, this gives a warning and destroys the array. /// If these items are not owned elsewhere, this will cause /// a memory leak of all the items that were on the array. /// So if the items are not owned elsewhere and require their /// own destroy function, they must be destroyed before the ptra.<para/> /// /// (3) If %warnflag == FALSE, no warnings will be issued. This is /// useful if the items are owned elsewhere, such as a /// PixMemoryStore().<para/> /// /// (4) To destroy the ptra, we destroy the ptr array, then /// the ptra, and then null the contents of the input ptr. /// </summary> /// <remarks> /// </remarks> /// <include file="..\CHM_Help\IncludeComments.xml" path="Comments/ptraDestroy/*"/> /// <param name="ppa">[in,out] - ptra to be nulled</param> /// <param name="freeflag">[in] - TRUE to free each remaining item in the array</param> /// <param name="warnflag">[in] - TRUE to warn if any remaining items are not destroyed</param> public static void ptraDestroy( ref L_Ptra ppa, int freeflag, int warnflag) { IntPtr ppaPtr = IntPtr.Zero; if (ppa != null) { ppaPtr = ppa.Pointer; } Natives.ptraDestroy(ref ppaPtr, freeflag, warnflag); if (ppaPtr == IntPtr.Zero) { ppa = null; } else { ppa = new L_Ptra(ppaPtr); }; }
// ptra.c (242, 1) // ptraAdd(pa, item) as int // ptraAdd(L_PTRA *, void *) as l_ok /// <summary> /// (1) This adds the element to the next location beyond imax, /// which is the largest occupied ptr in the array. This is /// what you expect from a stack, where all ptrs up to and /// including imax are occupied, but here the occuption of /// items in the array is entirely arbitrary. /// </summary> /// <remarks> /// </remarks> /// <include file="..\CHM_Help\IncludeComments.xml" path="Comments/ptraAdd/*"/> /// <param name="pa">[in] - ptra</param> /// <param name="item">[in] - generic ptr to a struct</param> /// <returns>0 if OK, 1 on error</returns> public static int ptraAdd( L_Ptra pa, Object item) { if (pa == null) { throw new ArgumentNullException("pa cannot be Nothing"); } if (item == null) { throw new ArgumentNullException("item cannot be Nothing"); } IntPtr itemPtr = IntPtr.Zero; if (item.GetType() == typeof(IntPtr)) { itemPtr = (IntPtr)item; } else if (item.GetType() == typeof(Byte[])) { var cdata = (Byte[])item; itemPtr = Marshal.AllocHGlobal(cdata.Length); Marshal.Copy(cdata, 0, itemPtr, cdata.Length); } else if (item.GetType().GetProperty("item") != null) { var cdata = (Byte[])item.GetType().GetProperty("data").GetValue(item, null); itemPtr = Marshal.AllocHGlobal(cdata.Length); Marshal.Copy(cdata, 0, itemPtr, cdata.Length); } int _Result = Natives.ptraAdd(pa.Pointer, itemPtr); Marshal.FreeHGlobal(itemPtr); return(_Result); }