HPDF_Page_SetSize (HPDF_Page page,
HPDF_PageSizes size,
HPDF_PageDirection direction)
{
HPDF_STATUS ret = HPDF_OK;
HPDF_PTRACE((" HPDF_Page_SetSize\n"));
if (!HPDF_Page_Validate (page))
return HPDF_INVALID_PAGE;
if (size < 0 || size > HPDF_PAGE_SIZE_EOF)
return HPDF_RaiseError (page->error, HPDF_PAGE_INVALID_SIZE,
(HPDF_STATUS)direction);
if (direction == HPDF_PAGE_LANDSCAPE) {
ret += HPDF_Page_SetHeight (page,
HPDF_PREDEFINED_PAGE_SIZES[(HPDF_UINT)size].x);
ret += HPDF_Page_SetWidth (page,
HPDF_PREDEFINED_PAGE_SIZES[(HPDF_UINT)size].y);
} else if (direction == HPDF_PAGE_PORTRAIT) {
ret += HPDF_Page_SetHeight (page,
HPDF_PREDEFINED_PAGE_SIZES[(HPDF_UINT)size].y);
ret += HPDF_Page_SetWidth (page,
HPDF_PREDEFINED_PAGE_SIZES[(HPDF_UINT)size].x);
} else
ret = HPDF_SetError (page->error, HPDF_PAGE_INVALID_DIRECTION,
(HPDF_STATUS)direction);
if (ret != HPDF_OK)
return HPDF_CheckError (page->error);
return HPDF_OK;
}
HPDF_Page_SetSize (HPDF_Page page,
HPDF_PageSizes size,
HPDF_PageDirection direction)
{
HPDF_STATUS ret = HPDF_OK;
HPDF_PTRACE((" HPDF_Page_SetSize\n"));
if (!HPDF_Page_Validate (page))
return HPDF_INVALID_PAGE;
if ((int)size < 0 || size > HPDF_PAGE_SIZE_EOF) //CAL:Supress "comparison of unsigned expression < 0 is always false" warning
return HPDF_RaiseError (page->error, HPDF_PAGE_INVALID_SIZE,
(HPDF_STATUS)direction);
if (direction == HPDF_PAGE_LANDSCAPE) {
ret += HPDF_Page_SetHeight (page,
HPDF_PREDEFINED_PAGE_SIZES[(HPDF_UINT)size].x);
ret += HPDF_Page_SetWidth (page,
HPDF_PREDEFINED_PAGE_SIZES[(HPDF_UINT)size].y);
} else if (direction == HPDF_PAGE_PORTRAIT) {
ret += HPDF_Page_SetHeight (page,
HPDF_PREDEFINED_PAGE_SIZES[(HPDF_UINT)size].y);
ret += HPDF_Page_SetWidth (page,
HPDF_PREDEFINED_PAGE_SIZES[(HPDF_UINT)size].x);
} else
ret = HPDF_SetError (page->error, HPDF_PAGE_INVALID_DIRECTION,
(HPDF_STATUS)direction);
if (ret != HPDF_OK)
return HPDF_CheckError (page->error);
return HPDF_OK;
}
void PDFGenerator::pdfDoc_AddPage(float width, float height)
{
if (pdfDocument)
{
HPDF_Page newPage = HPDF_AddPage(pdfDocument);
if (newPage)
{
pdfDocCurrentPage = newPage;
pdfDocPages.push_back(newPage);
HPDF_Page_SetWidth(newPage, width);
HPDF_Page_SetHeight(newPage, height);
_currentPageSize = mlPDF::PAGESIZE_USER;
HPDF_Page_SetFontAndSize(pdfDocCurrentPage, _currentFontSettings.font, _currentFontSettings.fontSize);
HPDF_Page_SetLineWidth(pdfDocCurrentPage, 1);
pdfDoc_SetStrokeColor(0, 0, 0);
pdfDoc_SetFillColor(0, 0, 0);
pdfDoc_CurrentXPos = 0;
pdfDoc_CurrentYPos = 0;
}
else
{
_handleError("pdfDoc_AddPage(float width, float height)");
}
}
}
WPdfImage::WPdfImage(const WLength& width, const WLength& height)
: width_(width),
height_(height),
painter_(nullptr)
{
myPdf_ = true;
pdf_ = HPDF_New(error_handler, this);
if (!pdf_)
throw WException("Could not create libharu document.");
HPDF_SetCompressionMode(pdf_, HPDF_COMP_ALL);
page_ = HPDF_AddPage(pdf_);
font_ = nullptr;
x_ = y_ = 0;
HPDF_Page_SetWidth(page_, width_.toPixels());
HPDF_Page_SetHeight(page_, height_.toPixels());
HPDF_Page_GSave(page_);
trueTypeFonts_ = new FontSupport(this, FontSupport::TrueTypeOnly);
#if HPDF_VERSION_ID>=20300
HPDF_UseUTFEncodings(pdf_);
#endif
}
extern void AP_AddPage()
{
HPDF_Page page = HPDF_AddPage(AP_getCurrentPdfDoc());
HPDF_Page_SetSize(page, HPDF_PAGE_SIZE_A4, HPDF_PAGE_LANDSCAPE);
//TODO change this-1000
HPDF_Page_SetHeight(page, 1000);
}
int main (int argc, char **argv)
{
HPDF_Doc pdf;
HPDF_Font font;
HPDF_Page page;
char fname[256];
HPDF_Destination dst;
strcpy (fname, argv[0]);
strcat (fname, ".pdf");
pdf = HPDF_New (error_handler, NULL);
if (!pdf) {
printf ("error: cannot create PdfDoc object\n");
return 1;
}
/* error-handler */
if (setjmp(env)) {
HPDF_Free (pdf);
return 1;
}
HPDF_SetCompressionMode (pdf, HPDF_COMP_ALL);
/* create default-font */
font = HPDF_GetFont (pdf, "Helvetica", NULL);
/* add a new page object. */
page = HPDF_AddPage (pdf);
HPDF_Page_SetWidth (page, 650);
HPDF_Page_SetHeight (page, 500);
dst = HPDF_Page_CreateDestination (page);
HPDF_Destination_SetXYZ (dst, 0, HPDF_Page_GetHeight (page), 1);
HPDF_SetOpenAction(pdf, dst);
HPDF_Page_BeginText (page);
HPDF_Page_SetFontAndSize (page, font, 20);
HPDF_Page_MoveTextPos (page, 220, HPDF_Page_GetHeight (page) - 70);
HPDF_Page_ShowText (page, "JpegDemo");
HPDF_Page_EndText (page);
HPDF_Page_SetFontAndSize (page, font, 12);
draw_image (pdf, "rgb.jpg", 70, HPDF_Page_GetHeight (page) - 410,
"24bit color image");
draw_image (pdf, "gray.jpg", 340, HPDF_Page_GetHeight (page) - 410,
"8bit grayscale image");
/* save the document to a file */
HPDF_SaveToFile (pdf, fname);
/* clean up */
HPDF_Free (pdf);
return 0;
}
/*
* Class: org_libharu_PdfPage
* Method: setHeight
* Signature: (F)V
*/
JNIEXPORT void JNICALL
Java_org_libharu_PdfPage_setHeight(JNIEnv *env, jobject obj, jfloat height) {
jint page;
/* Get mHPDFPagePointer */
page = (*env)->GetIntField(env, obj, mHPDFPagePointer);
/* Set page size */
HPDF_Page_SetHeight((HPDF_Page) page, (HPDF_REAL) height);
}
void hpdf_doc::landscape()
{
if (h_direction == HPDF_PAGE_LANDSCAPE)
return;
h_direction = HPDF_PAGE_PORTRAIT;
f_length = INCH2PT(f_page_width);
f_width = INCH2PT(f_page_length);
HPDF_Page_SetHeight(h_current_page, f_length);
HPDF_Page_SetWidth(h_current_page, f_width);
}
void hpdf_doc::protrait()
{
if (h_direction == HPDF_PAGE_PORTRAIT)
return;
h_direction = HPDF_PAGE_LANDSCAPE;
HPDF_Page_SetSize(h_current_page, HPDF_PAGE_SIZE_A4, h_direction);
f_width = INCH2PT(f_page_width);
f_length = INCH2PT(f_page_length);
HPDF_Page_SetHeight(h_current_page, f_length);
HPDF_Page_SetWidth(h_current_page, f_width);
}
HPDF_Page WPdfRenderer::createPage(int page)
{
#ifndef WT_TARGET_JAVA
HPDF_Page result = HPDF_AddPage(pdf_);
HPDF_Page_SetWidth(result, HPDF_Page_GetWidth(page_));
HPDF_Page_SetHeight(result, HPDF_Page_GetHeight(page_));
return result;
#else
return Wt::Render::Utils::createPage(pdf_,
HPDF_Page_GetWidth(page_),
HPDF_Page_GetHeight(page_));
#endif
}
bool addJpgPage(HPDF_Doc pdf, char const* jpgname) {
HPDF_Page page = HPDF_AddPage (pdf);
if (!page)
return false;
HPDF_Image image = HPDF_LoadJpegImageFromFile (pdf, jpgname);
if (!image) {
printf("load error %s\n", jpgname);
return false;
}
HPDF_REAL img_w = HPDF_REAL(HPDF_Image_GetWidth(image));
HPDF_REAL img_h = HPDF_REAL(HPDF_Image_GetHeight(image));
HPDF_Page_SetWidth (page, img_w);
HPDF_Page_SetHeight(page, img_h);
HPDF_Page_DrawImage (page, image, 0, 0, img_w, img_h);
return true;
}
JNIEXPORT jlong JNICALL Java_com_draekko_libharu_PdfPage_setHeight
(JNIEnv *env, jobject obj, jfloat height) {
haru_setup_error_handler(env, __func__);
HPDF_Page page = get_HPDF_Page(env, obj);
if (height < 3) {
height = 3;
}
if (height > 14400) {
height = 14400;
}
HPDF_REAL status = HPDF_Page_SetHeight (page, height);
haru_clear_error_handler();
return (long)status;
}
void
print_page (HPDF_Page page, HPDF_Font font, int page_num)
{
char buf[50];
HPDF_Page_SetWidth (page, 200);
HPDF_Page_SetHeight (page, 200);
HPDF_Page_SetFontAndSize (page, font, 20);
HPDF_Page_BeginText (page);
HPDF_Page_MoveTextPos (page, 50, 150);
#ifdef __WIN32__
_snprintf(buf, 50, "Page:%d", page_num);
#else
snprintf(buf, 50, "Page:%d", page_num);
#endif
HPDF_Page_ShowText (page, buf);
HPDF_Page_EndText (page);
}
void hpdf_doc::new_page()
{
//int n_TX = (et_cp.TX > 0) ? et_cp.TX : et_cp.T,
// n_TY = (et_cp.TY > 0) ? et_cp.TY : et_cp.T;
h_current_page = HPDF_AddPage(h_pdf);
HPDF_Page_SetSize(h_current_page, HPDF_PAGE_SIZE_A4, h_direction);
f_width = INCH2PT(f_page_width); // HPDF_Page_GetWidth(h_current_page);
f_length = INCH2PT(f_page_length); // HPDF_Page_GetHeight(h_current_page);
f_xpos = f_margin_x = INCH2PT(f_margin_left);
f_margin_y = INCH2PT(f_margin_top);
f_ypos = f_margin_y; // f_length - f_margin_y;
HPDF_Page_SetHeight(h_current_page, f_length);
HPDF_Page_SetWidth(h_current_page, f_width);
f_linespace = 0;
}
bool pdf_next_page(void)
{
#ifdef PDF_DEBUG
NSLOG(netsurf, INFO, "pdf_next_page begins");
#endif
clip_update_needed = false;
if (pdf_page != NULL) {
apply_clip_and_mode(false, NS_TRANSPARENT, NS_TRANSPARENT, 0.,
DashPattern_eNone);
pdfw_gs_restore(pdf_page);
}
#ifdef PDF_DEBUG_DUMPGRID
if (pdf_page != NULL) {
pdf_plot_grid(10, 10, 0xCCCCCC);
pdf_plot_grid(100, 100, 0xCCCCFF);
}
#endif
pdf_page = HPDF_AddPage(pdf_doc);
if (pdf_page == NULL)
return false;
HPDF_Page_SetWidth (pdf_page, settings->page_width);
HPDF_Page_SetHeight(pdf_page, settings->page_height);
HPDF_Page_Concat(pdf_page, 1, 0, 0, 1,
FIXTOFLT(settings->margins[MARGINLEFT]), 0);
pdfw_gs_save(pdf_page);
#ifdef PDF_DEBUG
NSLOG(netsurf, INFO, "%f %f", page_width, page_height);
#endif
return true;
}
void
generate_pdf (const char *outname, const char *tmpdirname, int num_fonts,
int num_input_files, const JBDATA * data,
const struct mapping *maps, int debug_draw_borders)
{
int i, j;
/* Create the pdf document */
l_int32 ncomp = numaGetCount (data->naclass);
HPDF_Doc pdf = HPDF_New (pdf_error_handler, NULL);
HPDF_SetCompressionMode (pdf, HPDF_COMP_ALL);
HPDF_Font *fonts = malloc_guarded (num_fonts * (sizeof (HPDF_Font)));
int dirlen = strlen (tmpdirname);
/* Load the fonts */
for (i = 0; i < num_fonts; i++)
{
/* 1 for '/', 8 for %08d, 4 for '.ttf' */
int fontlen = dirlen + 1 + 8 + 4;
char *font_tfname = malloc_guarded (fontlen + 1);
sprintf (font_tfname, "%s/%08d.ttf", tmpdirname, i);
const char *font_name =
HPDF_LoadTTFontFromFile (pdf, font_tfname, HPDF_TRUE);
fonts[i] = HPDF_GetFont (pdf, font_name, "KOI8-R");
free (font_tfname);
}
for (j = 0; j < num_input_files; j++)
{
/* Add page to document */
HPDF_Page pg = HPDF_AddPage (pdf);
HPDF_Page_SetWidth (pg, data->w);
HPDF_Page_SetHeight (pg, data->h);
/* TODO: Boost efficiency by making startcomp go to the next page on the next iteration */
int start_comp = 0;
for (i = start_comp; i < ncomp; i++)
{
l_int32 ipage;
l_int32 iclass;
l_int32 x;
l_int32 y;
numaGetIValue (data->napage, i, &ipage);
if (ipage != j)
continue;
numaGetIValue (data->naclass, i, &iclass);
ptaGetIPt (data->ptaul, i, &x, &y);
/*double left = x;
double top = data->h - y;
double right = x + data->latticew;
double bottom = data->h - (y + data->latticeh); */
char text[2];
text[0] = maps[iclass].code_point;
text[1] = '\0';
HPDF_Font font = fonts[maps[iclass].font_num];
HPDF_Page_BeginText (pg);
double fontsize = 100;
if (fontsize > 300)
{
error_quit ("This is a known bug.\n"
"libharu can't handle fontsizes bigger than 300, which is what is being requested here.\n"
"Please report this bug, and the file that produced this error");
}
HPDF_Page_SetFontAndSize (pg, font, 100);
HPDF_Page_MoveTextPos (pg, x, (data->h - y) - data->latticeh);
HPDF_Page_ShowText (pg, text);
HPDF_Page_EndText (pg);
if (debug_draw_borders)
{
HPDF_Page_SetRGBStroke (pg, 1, 0, 0);
/* In this, x, y is the LOWER LEFT, not UPPER LEFT */
HPDF_Page_Rectangle (pg, x, (data->h - y) - data->latticeh,
data->latticew, data->latticeh);
HPDF_Page_Stroke (pg);
}
}
}
/* Output */
HPDF_SaveToFile (pdf, outname);
/* Cleanup */
HPDF_Free (pdf);
free (fonts);
}
bool Pdf3d::createAdvancedPdf( const char *filepdf, const char *fileprc, const char *filejs, bool bUseCenter, float cenx, float ceny, float cenz )
{
HPDF_Rect rect = {_rcleft, _rctop, _rcwidth, _rcheight};
HPDF_Doc pdf;
HPDF_Page page;
HPDF_Annotation annot;
HPDF_U3D u3d;
pdf = HPDF_New (NULL, NULL);
if (!pdf)
{
printf ("error: cannot create PdfDoc object\n");
return false;
}
// set up some error handling
if (setjmp(g_env))
{
HPDF_Free (pdf);
return false;
}
page = HPDF_AddPage (pdf);
HPDF_Page_SetWidth (page, _rcwidth);
HPDF_Page_SetHeight (page, _rcheight);
//HPDF_Dict js = NULL; SALVA
//js = HPDF_DictStream_New (pdf->mmgr, pdf->xref);
//js->header.obj_class |= HPDF_OSUBCLASS_XOBJECT;
//js->filter = HPDF_STREAM_FILTER_NONE;
//js = HPDF_LoadJSFromFile (pdf, filejs);
u3d = HPDF_LoadU3DFromFile (pdf, fileprc);
// add javeascript action
//HPDF_Dict_Add (u3d, "OnInstantiate", js); SALVA
#define NS2VIEWS 7
HPDF_Dict views[NS2VIEWS+1];
const char *view_names[] = {"Front perspective ('1','H')",
"Back perspective ('2')",
"Right perspective ('3')",
"Left perspective ('4')",
"Bottom perspective ('5')",
"Top perspective ('6')",
"Oblique perspective ('7')"};
const float view_c2c[][3] = {{0., 0., 1.},
{0., 0., -1.},
{-1., 0., 0.},
{1., 0., 0.},
{0., 1., 0.},
{0., -1., 0.},
{-1., 1., -1.}};
const float view_roll[] = {0., 180., 90., -90., 0., 0., 60.};
// query camera point to rotate about - sometimes not the same as focus point
XYZ pr;
pr.x = 0;
pr.y = 0;
pr.z = 0;
// camera focus point
//XYZ focus;
//focus.x = 0;
//focus.y = 0;
//focus.z = 0;
if (bUseCenter)
{
pr.x = cenx;
pr.y = ceny;
pr.z = cenz;
}
float camrot = 5.0;
// create views
for (int iv = 0; iv < NS2VIEWS; iv++)
{
views[iv] = HPDF_Create3DView(u3d->mmgr, view_names[iv]);
HPDF_3DView_SetCamera(views[iv], pr.x, pr.y, pr.z,
view_c2c[iv][0], view_c2c[iv][1], view_c2c[iv][2],
camrot, view_roll[iv]);
HPDF_3DView_SetPerspectiveProjection(views[iv], 45.0);
HPDF_3DView_SetBackgroundColor(views[iv], _bgr, _bgg, _bgb);
HPDF_3DView_SetLighting(views[iv], "White");
HPDF_U3D_Add3DView(u3d, views[iv]);
}
// add a psuedo-orthographic for slicing (actually perspective with point at infinity)
views[NS2VIEWS] = HPDF_Create3DView(u3d->mmgr, "Orthgraphic slicing view");
HPDF_3DView_SetCamera(views[NS2VIEWS], pr.x, pr.y, pr.z,
view_c2c[0][0], view_c2c[0][1], view_c2c[0][2],
camrot*82.70f, view_roll[0]);
HPDF_3DView_SetPerspectiveProjection(views[NS2VIEWS], 0.3333f);
//HPDF_3DView_SetOrthogonalProjection(views[NS2VIEWS], 45.0/1000.0);
HPDF_3DView_SetBackgroundColor(views[NS2VIEWS], _bgr, _bgg, _bgb);
HPDF_3DView_SetLighting(views[NS2VIEWS], "White");
HPDF_U3D_Add3DView(u3d, views[NS2VIEWS]);
HPDF_U3D_SetDefault3DView(u3d, "Front perspective");
// Create annotation
annot = HPDF_Page_Create3DAnnot (page, rect, HPDF_TRUE, HPDF_FALSE, u3d, NULL);
// make the toolbar appear by default
// HPDF_Dict action = (HPDF_Dict)HPDF_Dict_GetItem (annot, "3DA", HPDF_OCLASS_DICT);
// HPDF_Dict_AddBoolean (action, "TB", HPDF_TRUE);
// save the document to a file
HPDF_SaveToFile (pdf, filepdf);
// clean up
HPDF_Free (pdf);
return true;
}
int main(int argc, char **argv)
{
HPDF_Doc pdf;
HPDF_Font font;
HPDF_Page index_page;
HPDF_Page page[9];
HPDF_Destination dst;
char fname[256];
HPDF_Rect rect;
HPDF_Point tp;
HPDF_Annotation annot;
HPDF_UINT i;
const char *uri = "http://libharu.org";
strcpy (fname, argv[0]);
strcat (fname, ".pdf");
pdf = HPDF_New (error_handler, NULL);
if (!pdf) {
printf ("error: cannot create PdfDoc object\n");
return 1;
}
if (setjmp(env)) {
HPDF_Free (pdf);
return 1;
}
/* create default-font */
font = HPDF_GetFont (pdf, "Helvetica", NULL);
/* create index page */
index_page = HPDF_AddPage (pdf);
HPDF_Page_SetWidth (index_page, 300);
HPDF_Page_SetHeight (index_page, 220);
/* Add 7 pages to the document. */
for (i = 0; i < 7; i++) {
page[i] = HPDF_AddPage (pdf);
print_page(page[i], font, i + 1);
}
HPDF_Page_BeginText (index_page);
HPDF_Page_SetFontAndSize (index_page, font, 10);
HPDF_Page_MoveTextPos (index_page, 15, 200);
HPDF_Page_ShowText (index_page, "Link Annotation Demo");
HPDF_Page_EndText (index_page);
/*
* Create Link-Annotation object on index page.
*/
HPDF_Page_BeginText(index_page);
HPDF_Page_SetFontAndSize (index_page, font, 8);
HPDF_Page_MoveTextPos (index_page, 20, 180);
HPDF_Page_SetTextLeading (index_page, 23);
/* page1 (HPDF_ANNOT_NO_HIGHTLIGHT) */
tp = HPDF_Page_GetCurrentTextPos (index_page);
HPDF_Page_ShowText (index_page, "Jump to Page1 (HilightMode=HPDF_ANNOT_NO_HIGHTLIGHT)");
rect.left = tp.x - 4;
rect.bottom = tp.y - 4;
rect.right = HPDF_Page_GetCurrentTextPos (index_page).x + 4;
rect.top = tp.y + 10;
HPDF_Page_MoveToNextLine (index_page);
dst = HPDF_Page_CreateDestination (page[0]);
annot = HPDF_Page_CreateLinkAnnot (index_page, rect, dst);
HPDF_LinkAnnot_SetHighlightMode (annot, HPDF_ANNOT_NO_HIGHTLIGHT);
/* page2 (HPDF_ANNOT_INVERT_BOX) */
tp = HPDF_Page_GetCurrentTextPos (index_page);
HPDF_Page_ShowText (index_page, "Jump to Page2 (HilightMode=HPDF_ANNOT_INVERT_BOX)");
rect.left = tp.x - 4;
rect.bottom = tp.y - 4;
rect.right = HPDF_Page_GetCurrentTextPos (index_page).x + 4;
rect.top = tp.y + 10;
HPDF_Page_MoveToNextLine (index_page);
dst = HPDF_Page_CreateDestination (page[1]);
annot = HPDF_Page_CreateLinkAnnot (index_page, rect, dst);
HPDF_LinkAnnot_SetHighlightMode (annot, HPDF_ANNOT_INVERT_BOX);
/* page3 (HPDF_ANNOT_INVERT_BORDER) */
tp = HPDF_Page_GetCurrentTextPos (index_page);
HPDF_Page_ShowText (index_page, "Jump to Page3 (HilightMode=HPDF_ANNOT_INVERT_BORDER)");
rect.left = tp.x - 4;
rect.bottom = tp.y - 4;
rect.right = HPDF_Page_GetCurrentTextPos (index_page).x + 4;
rect.top = tp.y + 10;
HPDF_Page_MoveToNextLine (index_page);
dst = HPDF_Page_CreateDestination (page[2]);
annot = HPDF_Page_CreateLinkAnnot (index_page, rect, dst);
HPDF_LinkAnnot_SetHighlightMode (annot, HPDF_ANNOT_INVERT_BORDER);
/* page4 (HPDF_ANNOT_DOWN_APPEARANCE) */
tp = HPDF_Page_GetCurrentTextPos (index_page);
HPDF_Page_ShowText (index_page, "Jump to Page4 (HilightMode=HPDF_ANNOT_DOWN_APPEARANCE)");
rect.left = tp.x - 4;
rect.bottom = tp.y - 4;
rect.right = HPDF_Page_GetCurrentTextPos (index_page).x + 4;
rect.top = tp.y + 10;
HPDF_Page_MoveToNextLine (index_page);
dst = HPDF_Page_CreateDestination (page[3]);
annot = HPDF_Page_CreateLinkAnnot (index_page, rect, dst);
HPDF_LinkAnnot_SetHighlightMode (annot, HPDF_ANNOT_DOWN_APPEARANCE);
/* page5 (dash border) */
tp = HPDF_Page_GetCurrentTextPos (index_page);
HPDF_Page_ShowText (index_page, "Jump to Page5 (dash border)");
rect.left = tp.x - 4;
rect.bottom = tp.y - 4;
rect.right = HPDF_Page_GetCurrentTextPos (index_page).x + 4;
rect.top = tp.y + 10;
HPDF_Page_MoveToNextLine (index_page);
dst = HPDF_Page_CreateDestination (page[4]);
annot = HPDF_Page_CreateLinkAnnot (index_page, rect, dst);
HPDF_LinkAnnot_SetBorderStyle (annot, 1, 3, 2);
/* page6 (no border) */
tp = HPDF_Page_GetCurrentTextPos (index_page);
HPDF_Page_ShowText (index_page, "Jump to Page6 (no border)");
rect.left = tp.x - 4;
rect.bottom = tp.y - 4;
rect.right = HPDF_Page_GetCurrentTextPos (index_page).x + 4;
rect.top = tp.y + 10;
HPDF_Page_MoveToNextLine (index_page);
dst = HPDF_Page_CreateDestination (page[5]);
annot = HPDF_Page_CreateLinkAnnot (index_page, rect, dst);
HPDF_LinkAnnot_SetBorderStyle (annot, 0, 0, 0);
/* page7 (bold border) */
tp = HPDF_Page_GetCurrentTextPos (index_page);
HPDF_Page_ShowText (index_page, "Jump to Page7 (bold border)");
rect.left = tp.x - 4;
rect.bottom = tp.y - 4;
rect.right = HPDF_Page_GetCurrentTextPos (index_page).x + 4;
rect.top = tp.y + 10;
HPDF_Page_MoveToNextLine (index_page);
dst = HPDF_Page_CreateDestination (page[6]);
annot = HPDF_Page_CreateLinkAnnot (index_page, rect, dst);
HPDF_LinkAnnot_SetBorderStyle (annot, 2, 0, 0);
/* URI link */
tp = HPDF_Page_GetCurrentTextPos (index_page);
HPDF_Page_ShowText (index_page, "URI (");
HPDF_Page_ShowText (index_page, uri);
HPDF_Page_ShowText (index_page, ")");
rect.left = tp.x - 4;
rect.bottom = tp.y - 4;
rect.right = HPDF_Page_GetCurrentTextPos (index_page).x + 4;
rect.top = tp.y + 10;
HPDF_Page_CreateURILinkAnnot (index_page, rect, uri);
HPDF_Page_EndText (index_page);
/* save the document to a file */
HPDF_SaveToFile (pdf, fname);
/* clean up */
HPDF_Free (pdf);
return 0;
}
int main (int argc, char **argv)
{
HPDF_Doc pdf;
char fname[256];
HPDF_Font font;
const char *font_name;
int i = 0;
HPDF_Outline root;
const char *encodings[] = {
"StandardEncoding",
"MacRomanEncoding",
"WinAnsiEncoding",
"ISO8859-2",
"ISO8859-3",
"ISO8859-4",
"ISO8859-5",
"ISO8859-9",
"ISO8859-10",
"ISO8859-13",
"ISO8859-14",
"ISO8859-15",
"ISO8859-16",
"CP1250",
"CP1251",
"CP1252",
"CP1254",
"CP1257",
"KOI8-R",
"Symbol-Set",
"ZapfDingbats-Set",
NULL
};
pdf = HPDF_NewEx (error_handler, NULL, NULL, 0, NULL);
if (!pdf) {
printf ("error: cannot create PdfDoc object\n");
return 1;
}
if (setjmp(env)) {
HPDF_Free (pdf);
return 1;
}
strcpy (fname, argv[0]);
strcat (fname, ".pdf");
/* set compression mode */
HPDF_SetCompressionMode (pdf, HPDF_COMP_ALL);
/* Set page mode to use outlines. */
HPDF_SetPageMode(pdf, HPDF_PAGE_MODE_USE_OUTLINE);
/* get default font */
font = HPDF_GetFont (pdf, "Helvetica", NULL);
/* load font object */
#ifdef __WIN32__
font_name = HPDF_LoadType1FontFromFile (pdf, "type1\\a010013l.afm",
"type1\\a010013l.pfb");
#else
font_name = HPDF_LoadType1FontFromFile (pdf, "type1/a010013l.afm",
"type1/a010013l.pfb");
#endif
/* create outline root. */
root = HPDF_CreateOutline (pdf, NULL, "Encoding list", NULL);
HPDF_Outline_SetOpened (root, HPDF_TRUE);
while (encodings[i]) {
HPDF_Page page = HPDF_AddPage (pdf);
HPDF_Outline outline;
HPDF_Destination dst;
HPDF_Font font2;
HPDF_Page_SetWidth (page, PAGE_WIDTH);
HPDF_Page_SetHeight (page, PAGE_HEIGHT);
outline = HPDF_CreateOutline (pdf, root, encodings[i], NULL);
dst = HPDF_Page_CreateDestination (page);
HPDF_Destination_SetXYZ(dst, 0, HPDF_Page_GetHeight(page), 1);
/* HPDF_Destination_SetFitB(dst); */
HPDF_Outline_SetDestination(outline, dst);
HPDF_Page_SetFontAndSize (page, font, 15);
draw_graph (page);
HPDF_Page_BeginText (page);
HPDF_Page_SetFontAndSize (page, font, 20);
HPDF_Page_MoveTextPos (page, 40, PAGE_HEIGHT - 50);
HPDF_Page_ShowText (page, encodings[i]);
HPDF_Page_ShowText (page, " Encoding");
HPDF_Page_EndText (page);
if (strcmp (encodings[i], "Symbol-Set") == 0)
font2 = HPDF_GetFont (pdf, "Symbol", NULL);
else if (strcmp (encodings[i], "ZapfDingbats-Set") == 0)
font2 = HPDF_GetFont (pdf, "ZapfDingbats", NULL);
else
font2 = HPDF_GetFont (pdf, font_name, encodings[i]);
HPDF_Page_SetFontAndSize (page, font2, 14);
draw_fonts (page);
i++;
}
/* save the document to a file */
HPDF_SaveToFile (pdf, fname);
/* clean up */
HPDF_Free (pdf);
return 0;
}
int
main (int argc, char **argv)
{
HPDF_Doc pdf;
HPDF_Page page;
char fname[256];
HPDF_Font hfont;
HPDF_ExtGState gstate;
const HPDF_REAL PAGE_WIDTH = 600;
const HPDF_REAL PAGE_HEIGHT = 900;
strcpy (fname, argv[0]);
strcat (fname, ".pdf");
pdf = HPDF_New (error_handler, NULL);
if (!pdf) {
printf ("error: cannot create PdfDoc object\n");
return 1;
}
if (setjmp(env)) {
HPDF_Free (pdf);
return 1;
}
hfont = HPDF_GetFont (pdf, "Helvetica-Bold", NULL);
/* add a new page object. */
page = HPDF_AddPage (pdf);
HPDF_Page_SetFontAndSize (page, hfont, 10);
HPDF_Page_SetHeight (page, PAGE_HEIGHT);
HPDF_Page_SetWidth (page, PAGE_WIDTH);
/* normal */
HPDF_Page_GSave (page);
draw_circles (page, "normal", 40.0f, PAGE_HEIGHT - 170);
HPDF_Page_GRestore (page);
/* transparency (0.8) */
HPDF_Page_GSave (page);
gstate = HPDF_CreateExtGState (pdf);
HPDF_ExtGState_SetAlphaFill (gstate, 0.8);
HPDF_ExtGState_SetAlphaStroke (gstate, 0.8);
HPDF_Page_SetExtGState (page, gstate);
draw_circles (page, "alpha fill = 0.8", 230.0f, PAGE_HEIGHT - 170);
HPDF_Page_GRestore (page);
/* transparency (0.4) */
HPDF_Page_GSave (page);
gstate = HPDF_CreateExtGState (pdf);
HPDF_ExtGState_SetAlphaFill (gstate, 0.4);
HPDF_Page_SetExtGState (page, gstate);
draw_circles (page, "alpha fill = 0.4", 420.0f, PAGE_HEIGHT - 170);
HPDF_Page_GRestore (page);
/* blend-mode=HPDF_BM_MULTIPLY */
HPDF_Page_GSave (page);
gstate = HPDF_CreateExtGState (pdf);
HPDF_ExtGState_SetBlendMode (gstate, HPDF_BM_MULTIPLY);
HPDF_Page_SetExtGState (page, gstate);
draw_circles (page, "HPDF_BM_MULTIPLY", 40.0f, PAGE_HEIGHT - 340);
HPDF_Page_GRestore (page);
/* blend-mode=HPDF_BM_SCREEN */
HPDF_Page_GSave (page);
gstate = HPDF_CreateExtGState (pdf);
HPDF_ExtGState_SetBlendMode (gstate, HPDF_BM_SCREEN);
HPDF_Page_SetExtGState (page, gstate);
draw_circles (page, "HPDF_BM_SCREEN", 230.0f, PAGE_HEIGHT - 340);
HPDF_Page_GRestore (page);
/* blend-mode=HPDF_BM_OVERLAY */
HPDF_Page_GSave (page);
gstate = HPDF_CreateExtGState (pdf);
HPDF_ExtGState_SetBlendMode (gstate, HPDF_BM_OVERLAY);
HPDF_Page_SetExtGState (page, gstate);
draw_circles (page, "HPDF_BM_OVERLAY", 420.0f, PAGE_HEIGHT - 340);
HPDF_Page_GRestore (page);
/* blend-mode=HPDF_BM_DARKEN */
HPDF_Page_GSave (page);
gstate = HPDF_CreateExtGState (pdf);
HPDF_ExtGState_SetBlendMode (gstate, HPDF_BM_DARKEN);
HPDF_Page_SetExtGState (page, gstate);
draw_circles (page, "HPDF_BM_DARKEN", 40.0f, PAGE_HEIGHT - 510);
HPDF_Page_GRestore (page);
/* blend-mode=HPDF_BM_LIGHTEN */
HPDF_Page_GSave (page);
gstate = HPDF_CreateExtGState (pdf);
HPDF_ExtGState_SetBlendMode (gstate, HPDF_BM_LIGHTEN);
HPDF_Page_SetExtGState (page, gstate);
draw_circles (page, "HPDF_BM_LIGHTEN", 230.0f, PAGE_HEIGHT - 510);
HPDF_Page_GRestore (page);
/* blend-mode=HPDF_BM_COLOR_DODGE */
HPDF_Page_GSave (page);
gstate = HPDF_CreateExtGState (pdf);
HPDF_ExtGState_SetBlendMode (gstate, HPDF_BM_COLOR_DODGE);
HPDF_Page_SetExtGState (page, gstate);
draw_circles (page, "HPDF_BM_COLOR_DODGE", 420.0f, PAGE_HEIGHT - 510);
HPDF_Page_GRestore (page);
/* blend-mode=HPDF_BM_COLOR_BUM */
HPDF_Page_GSave (page);
gstate = HPDF_CreateExtGState (pdf);
HPDF_ExtGState_SetBlendMode (gstate, HPDF_BM_COLOR_BUM);
HPDF_Page_SetExtGState (page, gstate);
draw_circles (page, "HPDF_BM_COLOR_BUM", 40.0f, PAGE_HEIGHT - 680);
HPDF_Page_GRestore (page);
/* blend-mode=HPDF_BM_HARD_LIGHT */
HPDF_Page_GSave (page);
gstate = HPDF_CreateExtGState (pdf);
HPDF_ExtGState_SetBlendMode (gstate, HPDF_BM_HARD_LIGHT);
HPDF_Page_SetExtGState (page, gstate);
draw_circles (page, "HPDF_BM_HARD_LIGHT", 230.0f, PAGE_HEIGHT - 680);
HPDF_Page_GRestore (page);
/* blend-mode=HPDF_BM_SOFT_LIGHT */
HPDF_Page_GSave (page);
gstate = HPDF_CreateExtGState (pdf);
HPDF_ExtGState_SetBlendMode (gstate, HPDF_BM_SOFT_LIGHT);
HPDF_Page_SetExtGState (page, gstate);
draw_circles (page, "HPDF_BM_SOFT_LIGHT", 420.0f, PAGE_HEIGHT - 680);
HPDF_Page_GRestore (page);
/* blend-mode=HPDF_BM_DIFFERENCE */
HPDF_Page_GSave (page);
gstate = HPDF_CreateExtGState (pdf);
HPDF_ExtGState_SetBlendMode (gstate, HPDF_BM_DIFFERENCE);
HPDF_Page_SetExtGState (page, gstate);
draw_circles (page, "HPDF_BM_DIFFERENCE", 40.0f, PAGE_HEIGHT - 850);
HPDF_Page_GRestore (page);
/* blend-mode=HPDF_BM_EXCLUSHON */
HPDF_Page_GSave (page);
gstate = HPDF_CreateExtGState (pdf);
HPDF_ExtGState_SetBlendMode (gstate, HPDF_BM_EXCLUSHON);
HPDF_Page_SetExtGState (page, gstate);
draw_circles (page, "HPDF_BM_EXCLUSHON", 230.0f, PAGE_HEIGHT - 850);
HPDF_Page_GRestore (page);
/* save the document to a file */
HPDF_SaveToFile (pdf, fname);
/* clean up */
HPDF_Free (pdf);
return 0;
}
int main(int argc, char **argv)
{
HPDF_Rect rect1 = {50, 350, 150, 400};
HPDF_Rect rect2 = {210, 350, 350, 400};
HPDF_Rect rect3 = {50, 250, 150, 300};
HPDF_Rect rect4 = {210, 250, 350, 300};
HPDF_Rect rect5 = {50, 150, 150, 200};
HPDF_Rect rect6 = {210, 150, 350, 200};
HPDF_Rect rect7 = {50, 50, 150, 100};
HPDF_Rect rect8 = {210, 50, 350, 100};
HPDF_Doc pdf;
char fname[256];
HPDF_Page page;
HPDF_Font font;
HPDF_Encoder encoding;
HPDF_Annotation annot;
strcpy (fname, argv[0]);
strcat (fname, ".pdf");
pdf = HPDF_New (error_handler, NULL);
if (!pdf) {
printf ("error: cannot create PdfDoc object\n");
return 1;
}
if (setjmp(env)) {
HPDF_Free (pdf);
return 1;
}
/* use Times-Roman font. */
font = HPDF_GetFont (pdf, "Times-Roman", "WinAnsiEncoding");
page = HPDF_AddPage (pdf);
HPDF_Page_SetWidth (page, 400);
HPDF_Page_SetHeight (page, 500);
HPDF_Page_BeginText (page);
HPDF_Page_SetFontAndSize (page, font, 16);
HPDF_Page_MoveTextPos (page, 130, 450);
HPDF_Page_ShowText (page, "Annotation Demo");
HPDF_Page_EndText (page);
annot = HPDF_Page_CreateTextAnnot (page, rect1, "Annotation with Comment "
"Icon. \n This annotation set to be opened initially.",
NULL);
HPDF_TextAnnot_SetIcon (annot, HPDF_ANNOT_ICON_COMMENT);
HPDF_TextAnnot_SetOpened (annot, HPDF_TRUE);
annot = HPDF_Page_CreateTextAnnot (page, rect2,
"Annotation with Key Icon", NULL);
HPDF_TextAnnot_SetIcon (annot, HPDF_ANNOT_ICON_PARAGRAPH);
annot = HPDF_Page_CreateTextAnnot (page, rect3,
"Annotation with Note Icon", NULL);
HPDF_TextAnnot_SetIcon (annot, HPDF_ANNOT_ICON_NOTE);
annot = HPDF_Page_CreateTextAnnot (page, rect4,
"Annotation with Help Icon", NULL);
HPDF_TextAnnot_SetIcon (annot, HPDF_ANNOT_ICON_HELP);
annot = HPDF_Page_CreateTextAnnot (page, rect5,
"Annotation with NewParagraph Icon", NULL);
HPDF_TextAnnot_SetIcon (annot, HPDF_ANNOT_ICON_NEW_PARAGRAPH);
annot = HPDF_Page_CreateTextAnnot (page, rect6,
"Annotation with Paragraph Icon", NULL);
HPDF_TextAnnot_SetIcon (annot, HPDF_ANNOT_ICON_PARAGRAPH);
annot = HPDF_Page_CreateTextAnnot (page, rect7,
"Annotation with Insert Icon", NULL);
HPDF_TextAnnot_SetIcon (annot, HPDF_ANNOT_ICON_INSERT);
encoding = HPDF_GetEncoder (pdf, "ISO8859-2");
HPDF_Page_CreateTextAnnot (page, rect8,
"Annotation with ISO8859 text гдежзий", encoding);
HPDF_Page_SetFontAndSize (page, font, 11);
HPDF_Page_BeginText (page);
HPDF_Page_MoveTextPos (page, rect1.left + 35, rect1.top - 20);
HPDF_Page_ShowText (page, "Comment Icon.");
HPDF_Page_EndText (page);
HPDF_Page_BeginText (page);
HPDF_Page_MoveTextPos (page, rect2.left + 35, rect2.top - 20);
HPDF_Page_ShowText (page, "Key Icon");
HPDF_Page_EndText (page);
HPDF_Page_BeginText (page);
HPDF_Page_MoveTextPos (page, rect3.left + 35, rect3.top - 20);
HPDF_Page_ShowText (page, "Note Icon.");
HPDF_Page_EndText (page);
HPDF_Page_BeginText (page);
HPDF_Page_MoveTextPos (page, rect4.left + 35, rect4.top - 20);
HPDF_Page_ShowText (page, "Help Icon");
HPDF_Page_EndText (page);
HPDF_Page_BeginText (page);
HPDF_Page_MoveTextPos (page, rect5.left + 35, rect5.top - 20);
HPDF_Page_ShowText (page, "NewParagraph Icon");
HPDF_Page_EndText (page);
HPDF_Page_BeginText (page);
HPDF_Page_MoveTextPos (page, rect6.left + 35, rect6.top - 20);
HPDF_Page_ShowText (page, "Paragraph Icon");
HPDF_Page_EndText (page);
HPDF_Page_BeginText (page);
HPDF_Page_MoveTextPos (page, rect7.left + 35, rect7.top - 20);
HPDF_Page_ShowText (page, "Insert Icon");
HPDF_Page_EndText (page);
HPDF_Page_BeginText (page);
HPDF_Page_MoveTextPos (page, rect8.left + 35, rect8.top - 20);
HPDF_Page_ShowText (page, "Text Icon(ISO8859-2 text)");
HPDF_Page_EndText (page);
/* save the document to a file */
HPDF_SaveToFile (pdf, fname);
/* clean up */
HPDF_Free (pdf);
return 0;
}
int main (int argc, char **argv)
{
HPDF_Doc pdf;
HPDF_Font font;
HPDF_Page page;
char fname[256];
HPDF_Image image;
HPDF_REAL x, y;
strcpy (fname, argv[0]);
strcat (fname, ".pdf");
pdf = HPDF_New (error_handler, NULL);
if (!pdf) {
printf ("error: cannot create PdfDoc object\n");
return 1;
}
/* error-handler */
if (setjmp(env)) {
HPDF_Free (pdf);
return 1;
}
HPDF_SetCompressionMode (pdf, HPDF_COMP_ALL);
/* create default-font */
font = HPDF_GetFont (pdf, "Helvetica", NULL);
/* add a new page object. */
page = HPDF_AddPage (pdf);
HPDF_Page_SetWidth (page, 172);
HPDF_Page_SetHeight (page, 80);
HPDF_Page_BeginText (page);
HPDF_Page_SetFontAndSize (page, font, 20);
HPDF_Page_MoveTextPos (page, 220, HPDF_Page_GetHeight (page) - 70);
HPDF_Page_ShowText (page, "RawImageDemo");
HPDF_Page_EndText (page);
/* load RGB raw-image file. */
#ifndef __WIN32__
image = HPDF_LoadRawImageFromFile (pdf, "rawimage/32_32_rgb.dat",
32, 32, HPDF_CS_DEVICE_RGB);
#else
image = HPDF_LoadRawImageFromFile (pdf, "rawimage\\32_32_rgb.dat",
32, 32, HPDF_CS_DEVICE_RGB);
#endif
x = 20;
y = 20;
/* Draw image to the canvas. (normal-mode with actual size.)*/
HPDF_Page_DrawImage (page, image, x, y, 32, 32);
/* load GrayScale raw-image file. */
#ifndef __WIN32__
image = HPDF_LoadRawImageFromFile (pdf, "rawimage/32_32_gray.dat",
32, 32, HPDF_CS_DEVICE_GRAY);
#else
image = HPDF_LoadRawImageFromFile (pdf, "rawimage\\32_32_gray.dat",
32, 32, HPDF_CS_DEVICE_GRAY);
#endif
x = 70;
y = 20;
/* Draw image to the canvas. (normal-mode with actual size.)*/
HPDF_Page_DrawImage (page, image, x, y, 32, 32);
/* load GrayScale raw-image (1bit) file from memory. */
image = HPDF_LoadRawImageFromMem (pdf, RAW_IMAGE_DATA, 32, 32,
HPDF_CS_DEVICE_GRAY, 1);
x = 120;
y = 20;
/* Draw image to the canvas. (normal-mode with actual size.)*/
HPDF_Page_DrawImage (page, image, x, y, 32, 32);
/* save the document to a file */
HPDF_SaveToFile (pdf, fname);
/* clean up */
HPDF_Free (pdf);
return 0;
}
int write_pdf(int argc, char ** argv, FILE * pipe_in, FILE * pipe_out, FILE * pipe_err)
{
char * filename = argc > 1 ? argv[1] : "output.pdf";
if (argc == 1)
{
fprintf(stderr, "no filename specified, using '%s'\n", filename);
}
float b[3][2] = {
{FLT_MAX, -FLT_MAX},
{FLT_MAX, -FLT_MAX},
{FLT_MAX, -FLT_MAX}
};
HPDF_Doc pdf;
pdf = HPDF_New(NULL, NULL);
if (!pdf)
{
fprintf(stderr, "ERROR: cannot create pdf object.\n");
return 1;
}
HPDF_SetCompressionMode (pdf, HPDF_COMP_ALL);
HPDF_SetPageMode (pdf, HPDF_PAGE_MODE_USE_OUTLINE);
int num_shapes = 0;
struct Shape ** shapes = NULL;
HPDF_Page page;
page = HPDF_AddPage (pdf);
HPDF_Page_SetSize (page, HPDF_PAGE_SIZE_LETTER, HPDF_PAGE_PORTRAIT);
long i = 0;
struct Shape * shape = NULL;
while ((shape = read_shape(pipe_in)))
{
num_shapes++;
shapes = (struct Shape **)realloc(shapes, sizeof(struct Shape*)*num_shapes);
if (shapes == NULL) { fprintf(stderr, "realloc for shapes failed :(\n"); exit(0); }
shapes[num_shapes-1] = shape;
long j;
for (j = 0 ; j < shape->num_vertexs ; j++)
{
float * v = get_vertex(shape, 0, j);
if (v[0] < b[0][0]) b[0][0] = v[0]; if (v[0] > b[0][1]) b[0][1] = v[0];
if (v[1] < b[1][0]) b[1][0] = v[1]; if (v[1] > b[1][1]) b[1][1] = v[1];
}
}
float dx = b[0][1] - b[0][0];
float dy = b[1][1] - b[1][0];
float ratio = dy / dx;
HPDF_Page_SetWidth(page, 2000);
HPDF_Page_SetHeight(page, 2000.0 * ratio);
for (i = 0 ; i < num_shapes ; i++)
{
shape = shapes[i];
//if (shape->vertex_arrays[0].num_dimensions < 2) { fprintf(stderr, "\n"); continue; }
long j;
for (j = 0 ; j < shape->num_vertexs ; j++)
{
float * v = get_vertex(shape, 0, j);
if (j == 0)
HPDF_Page_MoveTo(page, (v[0] - b[0][0]) / dx * 2000.0, (v[1] - b[1][0]) / dy * (2000.0 * ratio));
else
HPDF_Page_LineTo(page, (float)(v[0] - b[0][0]) / dx * 2000.0, (float)(v[1] - b[1][0]) / dy * (2000.0 * ratio));
}
if (shape->gl_type == GL_LINE_LOOP)
{
float * v = get_vertex(shape, 0, 0);
HPDF_Page_LineTo(page, (float)(v[0] - b[0][0]) / dx * 2000.0, (float)(v[1] - b[1][0]) / dy * (2000.0 * ratio));
}
HPDF_Page_Stroke(page);
free_shape(shape);
}
free(shapes);
HPDF_SaveToFile (pdf, filename);
HPDF_Free(pdf);
}
