void hpdf_doc::select_font(const char* longfontname)
{
const char *font_name;
font_name = HPDF_LoadTTFontFromFile(h_pdf, longfontname, HPDF_TRUE);
h_current_font = HPDF_GetFont(h_pdf, font_name, PDF_STD_ENCODE);
set_font_handle(h_current_page, h_current_font, true);
}
void hpdf_doc::init_font_table()
{
wstring font_str(L"A");
const char *font_name;
string font_full_path = font_path_parent + PDF_STD_UNICODE;
font_name = HPDF_LoadTTFontFromFile(h_pdf, font_full_path.c_str(), HPDF_TRUE);
HPDF_Font font = HPDF_GetFont(h_pdf, font_name, PDF_STD_ENCODE);
for (int i = 0; i < 26; i++)
{
font_str[0] = L'A' + i;
mapped_font *fm = new mapped_font(font_name, PDF_STD_ENCODE);
fm->font_handle = font;
mapped_font_lookup_table[font_str] = fm;
}
font_full_path = font_path_parent + PDF_STD_KAI;
font_name = HPDF_LoadTTFontFromFile(h_pdf, font_full_path.c_str(), HPDF_TRUE);
font = HPDF_GetFont(h_pdf, font_name, PDF_STD_ENCODE);
mapped_font *kai_fm = new mapped_font(font_name, PDF_STD_ENCODE);
kai_fm->font_handle = font;
mapped_font_lookup_table[L"K"] = kai_fm;
for (map<string, string>::iterator j = external_fonts.begin(); j != external_fonts.end(); ++j)
{
wstring font_letter = StringToWstring(j->first);
string font_path = j->second;
font_full_path = font_path_parent + font_path;
font_name = HPDF_LoadTTFontFromFile(h_pdf, font_full_path.c_str(), HPDF_TRUE);
font = HPDF_GetFont(h_pdf, font_name, PDF_STD_ENCODE);
mapped_font *fm = new mapped_font(font_name, PDF_STD_ENCODE);
fm->font_handle = font;
mapped_font_lookup_table[font_letter] = fm;
}
}
int CHaruPdf::SetTtfFont( const sqbind::stdString &sName, int nSize )
{_STT();
// Sanity checks
if ( !m_pdf || !m_page )
return 0;
// Attempt to load font from file
const char *pFont = HPDF_LoadTTFontFromFile( m_pdf, sName.c_str(), HPDF_TRUE );
if ( !pFont )
{ sqbind::stdString sErr = oexT( "Loading font " );
sErr += sName; sErr += oexT( " : " ); m_sLastError = sErr + m_sLastError;
return 0;
} // end if
return SetFont( pFont, nSize );
}
void WPdfImage::setChanged(WFlags<PainterChangeFlag> flags)
{
if (!flags.empty()) {
HPDF_Page_GRestore(page_);
HPDF_Page_GSave(page_);
HPDF_ExtGState gstate;
gstate = HPDF_CreateExtGState (pdf_);
currentFont_ = WFont();
if (painter()->hasClipping()) {
const WTransform& t = painter()->clipPathTransform();
if (!painter()->clipPath().isEmpty()) {
applyTransform(t);
drawPlainPath(painter()->clipPath());
HPDF_Page_Clip(page_);
HPDF_Page_EndPath(page_);
applyTransform(t.inverted());
}
}
applyTransform(painter()->combinedTransform());
const WPen& pen = painter()->pen();
if (pen.style() != PenStyle::None) {
const WColor& color = pen.color();
HPDF_Page_SetRGBStroke(page_,
color.red() / 255.,
color.green() / 255.,
color.blue() / 255.);
HPDF_ExtGState_SetAlphaStroke (gstate, color.alpha()/255.);
WLength w = painter()->normalizedPenWidth(pen.width(), false);
HPDF_Page_SetLineWidth(page_, w.toPixels());
switch (pen.capStyle()) {
case PenCapStyle::Flat:
HPDF_Page_SetLineCap(page_, HPDF_BUTT_END);
break;
case PenCapStyle::Square:
HPDF_Page_SetLineCap(page_, HPDF_PROJECTING_SCUARE_END); // scuary !
break;
case PenCapStyle::Round:
HPDF_Page_SetLineCap(page_, HPDF_ROUND_END);
break;
}
switch (pen.joinStyle()) {
case PenJoinStyle::Miter:
HPDF_Page_SetLineJoin(page_, HPDF_MITER_JOIN);
break;
case PenJoinStyle::Bevel:
HPDF_Page_SetLineJoin(page_, HPDF_BEVEL_JOIN);
break;
case PenJoinStyle::Round:
HPDF_Page_SetLineJoin(page_, HPDF_ROUND_JOIN);
break;
}
switch (pen.style()) {
case PenStyle::None:
break;
case PenStyle::SolidLine:
HPDF_Page_SetDash(page_, nullptr, 0, 0);
break;
case PenStyle::DashLine: {
const HPDF_UINT16 dash_ptn[] = { 4, 2 };
HPDF_Page_SetDash(page_, dash_ptn, 2, 0);
break;
}
case PenStyle::DotLine: {
const HPDF_UINT16 dash_ptn[] = { 1, 2 };
HPDF_Page_SetDash(page_, dash_ptn, 2, 0);
break;
}
case PenStyle::DashDotLine: {
const HPDF_UINT16 dash_ptn[] = { 4, 2, 1, 2 };
HPDF_Page_SetDash(page_, dash_ptn, 4, 0);
break;
}
case PenStyle::DashDotDotLine: {
const HPDF_UINT16 dash_ptn[] = { 4, 2, 1, 2, 1, 2 };
HPDF_Page_SetDash(page_, dash_ptn, 6, 0);
break;
}
}
}
const WBrush& brush = painter()->brush();
if (brush.style() != BrushStyle::None) {
const WColor& color = painter()->brush().color();
HPDF_Page_SetRGBFill(page_,
color.red() / 255.,
color.green() / 255.,
color.blue() / 255.);
HPDF_ExtGState_SetAlphaFill (gstate, color.alpha()/255.);
}
HPDF_Page_SetExtGState (page_, gstate);
const WFont& font = painter()->font();
if (font == currentFont_ && !trueTypeFonts_->busy())
return;
/*
* First, try a true type font.
*/
std::string ttfFont;
if (trueTypeFonts_->busy()) {
/*
* We have a resolved true type font.
*/
ttfFont = trueTypeFonts_->drawingFontPath();
} else {
FontSupport::FontMatch match = trueTypeFonts_->matchFont(font);
if (match.matched())
ttfFont = match.fileName();
}
LOG_DEBUG("font: " << ttfFont);
if (font == currentFont_ &&
!ttfFont.empty() &&
currentTtfFont_ == ttfFont)
return;
currentFont_ = font;
const char *font_name = nullptr;
font_ = nullptr;
if (!ttfFont.empty()) {
bool fontOk = false;
std::map<std::string, const char *>::const_iterator i
= ttfFonts_.find(ttfFont);
if (i != ttfFonts_.end()) {
font_name = i->second;
fontOk = true;
} else if (ttfFont.length() > 4) {
std::string suffix
= Utils::lowerCase(ttfFont.substr(ttfFont.length() - 4));
if (suffix == ".ttf") {
font_name = HPDF_LoadTTFontFromFile (pdf_, ttfFont.c_str(),
HPDF_TRUE);
} else if (suffix == ".ttc") {
/* Oops, pango didn't tell us which font to load ... */
font_name = HPDF_LoadTTFontFromFile2(pdf_, ttfFont.c_str(),
0, HPDF_TRUE);
}
if (!font_name)
HPDF_ResetError (pdf_);
else {
ttfFonts_[ttfFont] = font_name;
fontOk = true;
}
}
if (!fontOk)
LOG_ERROR("cannot read font: '" << ttfFont << "': "
"expecting a true type font (.ttf, .ttc)");
}
if (!font_ && font_name) {
font_ = HPDF_GetFont (pdf_, font_name, "UTF-8");
if (!font_)
HPDF_ResetError (pdf_);
else {
trueTypeFont_ = true;
currentTtfFont_ = ttfFont;
}
}
if (!font_) {
trueTypeFont_ = false;
currentTtfFont_.clear();
std::string name = Pdf::toBase14Font(font);
font_ = HPDF_GetFont(pdf_, name.c_str(), nullptr);
}
fontSize_ = font.sizeLength(12).toPixels();
HPDF_Page_SetFontAndSize (page_, font_, fontSize_);
}
}
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);
}
