sPdf.cpp

/*
-----------------------------------------------------------------------------
This source file is part of OpenSpace3D
For the latest info, see http://www.openspace3d.com
 
Copyright (c) 2013 I-maginer
 
This program is free software; you can redistribute it and/or modify it under
the terms of the GNU Lesser General Public License as published by the Free Software
Foundation; either version 2 of the License, or (at your option) any later
version.
 
This program is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
 
You should have received a copy of the GNU Lesser General Public License along with
this program; if not, write to the Free Software Foundation, Inc., 59 Temple
Place - Suite 330, Boston, MA 02111-1307, USA, or go to
http://www.gnu.org/copyleft/lesser.txt
 
-----------------------------------------------------------------------------
*/
 
#include "sPdf.h"
 
void SPdfDoc::ErrorHandler(HPDF_STATUS error_no, HPDF_STATUS detail_no, void *user_data)
{
    MMechostr(MSKRUNTIME, "SPdfDoc ERROR: error_no=%04X, detail_no=%u\n", (HPDF_UINT)error_no, (HPDF_UINT)detail_no);
    SPdfDoc* doc = static_cast<SPdfDoc*>(user_data);
 
    //reset error status
    HPDF_Error_Reset (&doc->mDocument->error);
    throw std::exception();
}
 
SPdfDoc::SPdfDoc(std::string title, std::string creator, std::string author, unsigned int dpiResolution)
{
  mDocument = HPDF_New(SPdfDoc::ErrorHandler, this);
  mCharset = "StandardEncoding";
 
  HPDF_SetInfoAttr(mDocument, HPDF_INFO_TITLE, title.c_str());
  HPDF_SetInfoAttr(mDocument, HPDF_INFO_CREATOR, creator.c_str());
  HPDF_SetInfoAttr(mDocument, HPDF_INFO_AUTHOR, author.c_str());
  HPDF_SetCompressionMode(mDocument, HPDF_COMP_ALL);
  mDpi = dpiResolution;
}
 
SPdfDoc::~SPdfDoc()
{
  if (mDocument)
    HPDF_Free(mDocument);
}
 
float SPdfDoc::MmtoDpi(float value)
{
  return value / 25.4f * 72.0f;
}
 
float SPdfDoc::DpiToMm(float value)
{
  return value / 72.0f * 25.4f;
}
 
float SPdfDoc::DpiScale(float value)
{
  return (value / 72.0f) * (float)mDpi;
}
 
void SPdfDoc::AlignCoords(int flags, float pageWidth, float pageHeight, float eltWidth, float eltHeight, float &x, float &y)
{
  if (flags & EM_RIGHT)
    x = pageWidth - x;
 
  if (flags & EM_CENTER)
    x = x + (pageWidth / 2) - (eltWidth / 2);
 
  if (flags & EM_TOP)
    y = pageHeight - y - eltHeight;
 
  if (flags & EM_MIDDLE)
    y = (pageHeight / 2) - (eltHeight / 2) - y;
}
 
float SPdfDoc::GetTextWidth(HPDF_Page page, std::string text, std::string fontname, float fontsize)
{
  HPDF_Font nfont = 0;
  try
  {
    nfont = HPDF_GetFont(mDocument, fontname.c_str(), mCharset.c_str());
  }
  catch (std::exception &)
  {  
  }
 
  // font still found define a default one
  if (nfont == 0)  
    nfont = HPDF_GetFont(mDocument, "Helvetica", mCharset.c_str());
 
  HPDF_Page_SetFontAndSize(page, nfont, MmtoDpi(fontsize));
  return DpiToMm(HPDF_Page_TextWidth(page, text.c_str()));
}
 
HPDF_Page SPdfDoc::AddPage(HPDF_PageSizes sizes, HPDF_PageDirection direction)
{
  HPDF_Page page = HPDF_AddPage(mDocument);
  HPDF_Page_SetSize(page, sizes, direction);
  HPDF_Page_Concat(page, 72.0f / (float)mDpi, 0, 0, 72.0f / (float)mDpi, 0, 0);
  return page;
}
 
HPDF_Page SPdfDoc::GetPageByIndex(HPDF_UINT index)
{
  return HPDF_GetPageByIndex(mDocument, index);
}
 
float SPdfDoc::GetPageWidth(HPDF_Page page)
{
  return DpiToMm(HPDF_Page_GetWidth(page));
}
 
float SPdfDoc::GetPageHeight(HPDF_Page page)
{
  return DpiToMm(HPDF_Page_GetHeight(page));
}
 
void SPdfDoc::SetCharset(std::string charset)
{
  mCharset = charset;
}
 
void SPdfDoc::SetPageMode(HPDF_PageMode mode)
{
  HPDF_SetPageMode(mDocument, mode);
}
 
HPDF_PageMode SPdfDoc::GetPageMode()
{
  return HPDF_GetPageMode(mDocument);
}
 
void SPdfDoc::SetPageLayout(HPDF_PageLayout layout)
{
  HPDF_SetPageLayout(mDocument, layout);
}
 
HPDF_PageLayout SPdfDoc::GetPageLayout()
{
  return HPDF_GetPageLayout(mDocument);
}
 
void SPdfDoc::AddPageLabel(HPDF_UINT pagenum, HPDF_PageNumStyle style, HPDF_UINT firstpage, std::string prefix)
{
  HPDF_AddPageLabel(mDocument, pagenum, style, firstpage, prefix.c_str());
}
 
std::string SPdfDoc::LoadFontTTF(std::string fontpath)
{
  std::string fontname;
  try
  {
    fontname = HPDF_LoadTTFontFromFile(mDocument, fontpath.c_str(), HPDF_TRUE);
  }
  catch(std::exception&)
  {
    fontname = HPDF_LoadTTFontFromFile2(mDocument, fontpath.c_str(), 0, HPDF_TRUE);
  }
  return fontname;
}
 
void SPdfDoc::AddPageText(HPDF_Page page, std::string text, float posx, float posy, int color, std::string fontname, float fontsize, int align, bool relative)
{
  HPDF_Font nfont = 0;
  try
  {
    nfont = HPDF_GetFont(mDocument, fontname.c_str(), mCharset.c_str());
  }
  catch (std::exception &)
  {  
  }
 
  // font still found define a default one
  if (nfont == 0)  
    nfont = HPDF_GetFont(mDocument, "Helvetica", mCharset.c_str());    
 
  HPDF_RGBColor ccolor = ConvertColor(color);
 
  HPDF_Page_BeginText(page);
  HPDF_Page_SetFontAndSize(page, nfont, fontsize);
  HPDF_Page_SetRGBFill(page, ccolor.r, ccolor.g, ccolor.b);
 
  float width = HPDF_Page_TextWidth(page, text.c_str());
  AlignCoords(align, GetPageWidth(page), GetPageHeight(page), width, fontsize, posx, posy);
 
  // now with transformed fontsize
  HPDF_Page_SetFontAndSize(page, nfont, DpiScale(MmtoDpi(fontsize)));
  if (relative)
  {
    HPDF_Page_ShowText(page, text.c_str());
    HPDF_Page_MoveTextPos(page, (HPDF_REAL)DpiScale(MmtoDpi(posx)), (HPDF_REAL)DpiScale(MmtoDpi(posy)));
  }
  else
  {
    HPDF_Page_TextOut(page, (HPDF_REAL)DpiScale(MmtoDpi(posx)), (HPDF_REAL)DpiScale(MmtoDpi(posy)), text.c_str());
  }
 
  HPDF_Page_EndText(page);
}
 
void SPdfDoc::AddPageBitmap(HPDF_Page page, PtrObjBitmap bitmap, float posx, float posy, float width, float height, int align)
{
  HPDF_Image image = ConvertBitmap(bitmap);
 
  AlignCoords(align, GetPageWidth(page), GetPageHeight(page), width, height, posx, posy);
  HPDF_Page_DrawImage(page, image, (HPDF_REAL)DpiScale(MmtoDpi(posx)), (HPDF_REAL)DpiScale(MmtoDpi(posy)), (HPDF_REAL)DpiScale(MmtoDpi(width)), (HPDF_REAL)DpiScale(MmtoDpi(height)));
}
 
void SPdfDoc::AddPageImage(HPDF_Page page, std::string path, float posx, float posy, float width, float height, int align)
{
  HPDF_Image image = 0;
 
  // try to load jpg or png file
  try
  {
    image = HPDF_LoadJpegImageFromFile(mDocument, path.c_str());
  }
  catch (std::exception &)
  {
  }
 
  if (image == 0)
    image = HPDF_LoadPngImageFromFile(mDocument, path.c_str());
 
  if (width == 0)
    width = (float)HPDF_Image_GetWidth(image);
 
  if (height == 0)
    height = (float)HPDF_Image_GetHeight(image);
 
  AlignCoords(align, GetPageWidth(page), GetPageHeight(page), width, height, posx, posy);
  HPDF_Page_DrawImage(page, image, (HPDF_REAL)DpiScale(MmtoDpi(posx)), (HPDF_REAL)DpiScale(MmtoDpi(posy)), (HPDF_REAL)DpiScale(MmtoDpi(width)), (HPDF_REAL)DpiScale(MmtoDpi(height)));
}
 
void SPdfDoc::AddPageRectangle(HPDF_Page page, float posx, float posy, float width, float height, float lineWith, int lineColor, int fillColor, bool filled, int align)
{
  HPDF_RGBColor fcolor = ConvertColor(fillColor);
  HPDF_Page_SetRGBFill(page, fcolor.r, fcolor.g, fcolor.b);
  HPDF_RGBColor ccolor = ConvertColor(lineColor);
  
  AlignCoords(align, GetPageWidth(page), GetPageHeight(page), width, height, posx, posy);
  HPDF_Page_SetLineWidth(page, (HPDF_REAL)DpiScale(MmtoDpi(lineWith)));
  HPDF_Page_Rectangle(page, (HPDF_REAL)DpiScale(MmtoDpi(posx)), (HPDF_REAL)DpiScale(MmtoDpi(posy)), (HPDF_REAL)DpiScale(MmtoDpi(width)), (HPDF_REAL)DpiScale(MmtoDpi(height)));
  
  if (filled)
    HPDF_Page_Fill(page);
 
  if (lineWith > 0)
  {
    HPDF_Page_SetRGBStroke(page, ccolor.r, ccolor.g, ccolor.b);
    HPDF_Page_Rectangle(page, (HPDF_REAL)DpiScale(MmtoDpi(posx)), (HPDF_REAL)DpiScale(MmtoDpi(posy)), (HPDF_REAL)DpiScale(MmtoDpi(width)), (HPDF_REAL)DpiScale(MmtoDpi(height)));
    HPDF_Page_Stroke(page);
  }
}
 
void SPdfDoc::AddPageEllipse(HPDF_Page page, float posx, float posy, float xradius, float yradius, float lineWith, int lineColor, int fillColor, bool filled, int align)
{
  HPDF_RGBColor fcolor = ConvertColor(fillColor);
  HPDF_Page_SetRGBFill(page, fcolor.r, fcolor.g, fcolor.b);
  HPDF_RGBColor ccolor = ConvertColor(lineColor);
  
  AlignCoords(align, GetPageWidth(page), GetPageHeight(page), 0, 0, posx, posy);
  HPDF_Page_SetLineWidth(page, (HPDF_REAL)DpiScale(MmtoDpi(lineWith)));
  HPDF_Page_Ellipse(page, (HPDF_REAL)DpiScale(MmtoDpi(posx)), (HPDF_REAL)DpiScale(MmtoDpi(posy)), (HPDF_REAL)DpiScale(MmtoDpi(xradius)), (HPDF_REAL)DpiScale(MmtoDpi(yradius)));
  
  if (filled)
    HPDF_Page_Fill(page);
 
  if (lineWith > 0.0f)
  {
    HPDF_Page_SetRGBStroke(page, ccolor.r, ccolor.g, ccolor.b);
    HPDF_Page_Ellipse(page, (HPDF_REAL)DpiScale(MmtoDpi(posx)), (HPDF_REAL)DpiScale(MmtoDpi(posy)), (HPDF_REAL)DpiScale(MmtoDpi(xradius)), (HPDF_REAL)DpiScale(MmtoDpi(yradius)));
    HPDF_Page_Stroke(page);
  }
}
 
void SPdfDoc::AddPageLine(HPDF_Page page, float posx, float posy, float dstx, float dsty, float lineWith, int lineColor)
{
  HPDF_RGBColor ccolor = ConvertColor(lineColor);
  HPDF_Page_SetLineWidth(page, (HPDF_REAL)DpiScale(MmtoDpi(lineWith)));
 
  HPDF_Page_SetRGBStroke(page, ccolor.r, ccolor.g, ccolor.b);
  HPDF_Page_MoveTo(page, DpiScale(MmtoDpi(posx)), DpiScale(MmtoDpi(GetPageHeight(page) - posy)));
  HPDF_Page_LineTo(page, DpiScale(MmtoDpi(dstx)), DpiScale(MmtoDpi(GetPageHeight(page) - dsty)));
  HPDF_Page_Stroke(page);
}
 
 
void SPdfDoc::SaveToFile(std::string path)
{
  HPDF_SaveToFile(mDocument, path.c_str());
}
 
HPDF_Image SPdfDoc::ConvertBitmap(PtrObjBitmap scolBitmap)
{
  if (scolBitmap == 0)
    return 0;
  
  HPDF_ColorSpace color = (scolBitmap->BytesPP == 3) ? HPDF_CS_DEVICE_RGB : HPDF_CS_DEVICE_GRAY;
  HPDF_Image cimage = 0;
 
  //Scol bitmap are 32bits aligned
  int sbpl = scolBitmap->BPL;
  int dbpl = scolBitmap->TailleW * scolBitmap->BytesPP;
 
  // have to switch RGB / BGR and re-align.
  /*if (sbpl == dbpl)
    cimage = HPDF_LoadRawImageFromMem(mDocument, scolBitmap->bits, scolBitmap->TailleW, scolBitmap->TailleH, color, scolBitmap->BPP / scolBitmap->BytesPP);
  else*/
  {
    int size = (sizeof(unsigned char*) * scolBitmap->BytesPP);
    unsigned char* buff = (unsigned char*)malloc(scolBitmap->TailleW * scolBitmap->TailleH * size);
 
    for (long y=0; y<scolBitmap->TailleH; y++)
    {
      for (long x=0; x<scolBitmap->TailleW; x++)
      {
        unsigned long srcByte = (x * scolBitmap->BytesPP) + (sbpl * y);
        unsigned long destByte = (x * scolBitmap->BytesPP) + (dbpl * y);
 
        buff[destByte] = scolBitmap->bits[srcByte + 2]; // revert R / B
        buff[destByte + 1] = scolBitmap->bits[srcByte + 1];
        buff[destByte + 2] = scolBitmap->bits[srcByte];
      }
    }
 
    cimage = HPDF_LoadRawImageFromMem(mDocument, buff, scolBitmap->TailleW, scolBitmap->TailleH, color, scolBitmap->BPP / scolBitmap->BytesPP);
    free(buff);
  }
 
  return cimage;
}
 
HPDF_RGBColor SPdfDoc::ConvertColor(int color)
{
  float b = ((color>>16) & 0x000000ff) / 255.0f;
        float g = ((color>>8)  & 0x000000ff) / 255.0f;
        float r = ((color)     & 0x000000ff) / 255.0f;
        
  HPDF_RGBColor ccolor;
  ccolor.r = r;
  ccolor.g = g;
  ccolor.b = b;
 
  return ccolor;
}