//========================================================================
//
// ABWOutputDev.cc
//
// Jauco Noordzij
//
// Based somewhat on HtmlOutputDev.cc
//
//========================================================================

#ifdef __GNUC__
#pragma implementation
#endif

#include "config.h"
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <stddef.h>
#include <ctype.h>
#include <math.h>
#include "goo/GooString.h"
#include "goo/GooList.h"
#include "UnicodeMap.h"
#include "goo/gmem.h"
#include "Error.h"
#include "GfxState.h"
#include "GlobalParams.h"
#include "ABWOutputDev.h"
#include "PDFDoc.h"

#include <libxml/parser.h>
#include <libxml/tree.h>
#include <libxml/xpath.h>
#include <libxml/xpathInternals.h>
#include <libxml/debugXML.h>


// Inter-character space width which will cause addChar to start a new
// word.
#define minWordBreakSpace 0.1

// Maximum inter-word spacing, as a fraction of the font size.
#define maxWordSpacing 1.5

// Max distance between baselines of two lines within a block, as a
// fraction of the font size.
#define maxLineSpacingDelta 1.5

#define C_maxVCutValue 4
#define C_maxHCutValue 5
//------------------------------------------------------------------------
// ABWOutputDev
//------------------------------------------------------------------------

ABWOutputDev::ABWOutputDev(xmlDocPtr ext_doc)
{
  pdfdoc = NULL;
  N_page = N_style = N_text = N_styleset = N_Block = N_word = NULL;
  doc = ext_doc;
  N_root = xmlNewNode(NULL, BAD_CAST "abiword");
  xmlDocSetRootElement(doc, N_root);
  N_styleset = xmlNewChild(N_root, NULL, BAD_CAST "styles", NULL);
  N_content = xmlNewChild(N_root, NULL, BAD_CAST "content", NULL);
  uMap = globalParams->getTextEncoding();
  maxStyle = Style = 1;
}

ABWOutputDev::~ABWOutputDev() {
  xmlCleanupParser();
}

void ABWOutputDev::startPage(int pageNum, GfxState *state) {
  /*While reading a pdf page this node acts as a placeholder parent.
  when conversion is finished and the page is structured as we like it
  all text fragments are moved from N_page to N_content.*/
  N_page = xmlNewNode(NULL, BAD_CAST "page");
  G_pageNum = pageNum;
} 

/*Callback to denote that poppler reached the end of a page
here I insert most of the interesting processing stuff*/
void ABWOutputDev::endPage() {
  //make sure all words are closed
  endTextBlock();
  cleanUpNode(N_page, true);
  //xmlAddChild(N_content, N_page);
  //xmlSaveFormatFileEnc("pre-cut.xml", doc, "UTF-8", 1);
  //xmlUnlinkNode(N_page);
  //call the top down cutting mechanism
  recursiveXYC(N_page);
  //by stopping to worry about creating empty nodes I made the code quite a 
  //bit more robust. This function makes sure we have a nice'n'clean tree
  cleanUpNode(N_page, true);
  //xmlAddChild(N_content, N_page);
  //xmlSaveFormatFileEnc("raw.xml", doc, "UTF-8", 1);
  //xmlUnlinkNode(N_page);
  
  //Interpret the XY tree and infer text blocks and columns
  interpretXYTree();
  cleanUpNode(N_page, true);
  //xmlAddChild(N_content, N_page);
  //xmlSaveFormatFileEnc("interpreted.xml", doc, "UTF-8", 1);
  //xmlUnlinkNode(N_page);
  
  //I have blocks and columns, this function will turn that into paragraphs and
  //columns
  generateParagraphs();
  cleanUpNode(N_page, true);
  //xmlAddChild(N_content, N_page);
  //xmlSaveFormatFileEnc("paragraphs.xml", doc, "UTF-8", 1);
  
  xmlAddChild(N_content, N_page);
  //just for cleanliness
  N_page = NULL;
}

void ABWOutputDev::recursiveXYC(xmlNodePtr nodeset) {
  /*This function implements the recursive XY Cut. basically, it gets
  the largest piece of whitespace (using getBiggestSeperator()) and then
  splits the page using splitNodes on that whitespace. It calls itself again
  with both the halves*/
  float bhs, bvs, X1, X2, Y1, Y2;
  xmlNodePtr N_cur;

  bvs = getBiggestSeperator(nodeset, VERTICAL, &X1, &X2);
  bhs = getBiggestSeperator(nodeset, HORIZONTAL, &Y1, &Y2);
  
  //printf("***\nbetween %f and %f there is a vertical seperation of %f\n",X1,X2,bvs);
  //printf("between %f and %f there is a horizontal seperation of %f\n",Y1,Y2,bhs);
  
  
  if ((bvs == -1) and (bhs > -1)){
    //printf("Make a horizontal cut!\n");
    splitNodes(Y1, HORIZONTAL, nodeset, bhs);
  }
  else {
    if ((bvs > -1) and (bhs == -1)){
      //printf("Make a vertical cut!\n");
      splitNodes(X1, VERTICAL, nodeset, bvs);
    }
    else {
      if ((bvs > -1) and (bhs > -1)){
        if (bvs >= (bhs/1.7)){
          //When people read a text they prefer vertical cuts over horizontal 
          //ones. I'm not that sure about the 1.7 value, but it seems to work.
          //printf("Make a vertical cut!\n");
          splitNodes(X1, VERTICAL, nodeset, bvs);
        }
        else {
        //printf("Make a horizontal cut!\n");
          splitNodes(Y1, HORIZONTAL, nodeset, bhs);
        }
      }
    }
  }
  if (not((bvs == -1) and (bhs == -1))){
      recursiveXYC(nodeset->children);
      recursiveXYC(nodeset->children->next);
  }
}

void ABWOutputDev::splitNodes(float splitValue, unsigned int direction, xmlNodePtr N_parent, double extravalue){
  //This function takes a nodeset and splits it based on a cut value. It returns
  //the nodePtr with two childnodes, the both chunks.
  xmlNodePtr N_move, N_cur, N_newH, N_newL;
  char * propName;
  const char *nodeName;
  char buf[20];
  if (direction == HORIZONTAL) {propName = "Y1"; nodeName = "horizontal";}
  else { propName = "X1"; nodeName = "vertical";}
  N_newH = xmlNewNode(NULL, BAD_CAST nodeName);
  N_newL = xmlNewNode(NULL, BAD_CAST nodeName);
  sprintf(buf, "%f", extravalue); xmlNewProp(N_newH, BAD_CAST "diff", BAD_CAST buf);
  sprintf(buf, "%f", extravalue); xmlNewProp(N_newL, BAD_CAST "diff", BAD_CAST buf);
  N_cur = N_parent->children;
  //only do this if there are at least two child nodes
  if (direction == HORIZONTAL) {propName = "Y1";}
  else { propName = "X1"; }
  while (N_cur){
    N_move = N_cur->next;
    if (xmlXPathCastStringToNumber(xmlGetProp(N_cur,BAD_CAST propName)) > splitValue){
      xmlUnlinkNode(N_cur);
      xmlAddChild(N_newH, N_cur);
    }
    else {
      xmlUnlinkNode(N_cur);
      xmlAddChild(N_newL, N_cur);
    }
    N_cur = N_move;
  }
  xmlAddChild(N_parent, N_newL);
  xmlAddChild(N_parent, N_newH);
}

/*
This function gets the biggest whitespace in a portion of the document.
It does so by creating an array of begin and end points of non-whitespace
ex: 132,180,200,279,280,600
whitespace ^       ^
however, to get such an array working nicely required quite a bit of hackish:
"let's predict every possible eventuality and describe appropriate actions for 
it."
Better ideas for managing this information are welcomed.
*/
float ABWOutputDev::getBiggestSeperator(xmlNodePtr N_set, unsigned int direction, float * C1, float * C2)
{
  char * buf;
  float curC1, curC2, retVal;
  xmlNodePtr N_cur;
  unsigned int borders_size = 0;
  unsigned int j;
  float * borders;
  borders = new float[borders_size];
  
  for (N_cur = N_set->children; N_cur; N_cur = N_cur->next){
    if (direction == VERTICAL){
      curC1 = xmlXPathCastStringToNumber(xmlGetProp(N_cur,BAD_CAST "X1"));
      curC2 = xmlXPathCastStringToNumber(xmlGetProp(N_cur,BAD_CAST "X2"));
    }
    else {
      curC1 = xmlXPathCastStringToNumber(xmlGetProp(N_cur,BAD_CAST "Y1"));
      curC2 = xmlXPathCastStringToNumber(xmlGetProp(N_cur,BAD_CAST "Y2"));
    }
    /*printf("borders_size = %d, curC1 = %f, curC2 = %f\n",borders_size,curC1,curC2);
    for (unsigned int i = 0; i<borders_size; i++){
      printf("%f, ",borders[i]);
    }
    printf("\n");*/
    j=0;
    /*
    we skip to the array range by range. At any time borders[j] is the beginning
    of the range, borders[j+1] is the end. borders[j+2] is the beginning of the 
    next one etc.
    */
    while (j < borders_size) {
      if (curC1 < borders[j]) {
        //printf("  110:curC1 < borders[j] (%f)\n",borders[j]);
        if (curC2 < borders[j]) {
          //printf("    112:curC2 < borders[j] (%f)\n",borders[j]);
          //printf("***insert before %d\n",j);
          float * borders_new = new float[borders_size+2]; 
          for (unsigned int n = 0; n < borders_size; n++ ) {
            if (n <j){
              borders_new[n] = borders[n];
            }
            else {
              borders_new[n+2] = borders[n];
            }
          }
          delete [] borders;
          borders = borders_new;
          borders[j]   = curC1;
          borders[j+1] = curC2;
          borders_size = borders_size+2;
          break;
        }
        else {
          //printf("  130:curC1 >= borders[j] (%f)\n",borders[j]);
          if (curC2 <= borders[j+1]){
            //printf("***replace %f with %f\n",borders[j], curC1);
            //printf("    132:curC2 <= borders[j+1] (%f)\n",borders[j+1]);
            borders[j] = curC1;
            break;
          }
          else {
            if (curC2 >= borders[j+2]){
              //printf("***replace larger ones.\n");
              //printf("        155:curC2 >= borders[j+2](%f)\n",borders[j+2]);
              //At this point we have a range whose right coordinate is higher
              //then the left coordinate of the following range. ie. the new one
              //overlaps. This code removes all the elements it overlaps, and
              //inserts the new end-marker
              unsigned int c = 0;
              //first, look for how much array elements need to be removed
              //starting fro the right-hand coordinate of the current range.
              for (unsigned int n = j+2; n < borders_size; n++) {
                if (curC2 < borders[n]){
                  break;
                }
                c++;
              }
              //printf("end: c = %d\n",c);
              //Remove the intermediate ones. insert the curC2
              unsigned int newSize;
              if (c %2 ==0){
                newSize = borders_size-c;
              }
              else {
                newSize = borders_size-c-1;
              }
              float * borders_new = new float[newSize];
              for (unsigned int n = 0; n < borders_size; n++ ) {
                if (n <= j){
                  //printf("*copying: old: n = %d, new: n = %d, value = %f\n",n,n,borders[n]);
                  borders_new[n] = borders[n];
                }
                else {
                  if (c %2 ==0){
                    if (n == j+c+1){
                     //printf("*new value: new: n = %d, value = %f\n",n-c),curC2);
                     borders_new[n-c] = curC2;
                    }
                    else {
                      if (n>j+c+1) {
                        //printf("*copy after: old: n = %d, new: n = %d, value = %f\n",n,n-c,borders[n]);
                        borders_new[n-c] = borders[n];
                      }
                    }
                  }
                  else {
                    if (n>j+c+1) {
                    //printf("*copy after: old: n = %d, new: n = %d, value = %f\n",n,n-c,borders[n]);
                      borders_new[n-c-1] = borders[n];
                    }
                  }
                }
              }
              delete [] borders;
              borders = borders_new;
              borders_size = newSize;
              break;
            }
            else {
              //printf("    137:curC2 > borders[j+1] (%f)\n",borders[j+1]);
              //printf("***replace %f with %f and %f with %f\n",borders[j], curC1, borders[j+1], curC2);
              borders[j] = curC1;
              borders[j+1] = curC2;
              break;
            }
          }
        }
      }
      else {
        //printf("  145:curC1 >= borders[j] (%f)\n",borders[j]);
        if (curC1 <= borders[j+1]) {
          //printf("    147:curC1 < borders[j+1] (%f)\n",borders[j]);
          if (curC2 <= borders[j+1]) {
            //printf("***ignore.\n");
            //printf("      149:curC2 <= borders[j+1] (%f)\n",borders[j+1]);
            break;
          }
          else {
            //printf("      153:curC2 > borders[j+1] (%f)\n",borders[j+1]);
            if (curC2 >= borders[j+2]){
              //printf("***replace larger ones.\n");
              //printf("        155:curC2 >= borders[j+2](%f)\n",borders[j+2]);
              //At this point we have a range whose right coordinate is higher
              //then the left coordinate of the following range. ie. the new one
              //overlaps. This code removes all the elements it overlaps, and
              //inserts the new end-marker
              unsigned int c = 0;
              //first, look for how much array elements need to be removed
              //starting fro the right-hand coordinate of the current range.
              for (unsigned int n = j+2; n < borders_size; n++) {
                if (curC2 < borders[n]){
                  break;
                }
                c++;
              }
              //printf("end: c = %d\n",c);
              //Remove the intermediate ones. insert the curC2
              unsigned int newSize;
              if (c %2 ==0){
                newSize = borders_size-c;
              }
              else {
                newSize = borders_size-c-1;
              }
              float * borders_new = new float[newSize];
              for (unsigned int n = 0; n < borders_size; n++ ) {
                if (n <= j){
                  //printf("*copying: old: n = %d, new: n = %d, value = %f\n",n,n,borders[n]);
                  borders_new[n] = borders[n];
                }
                else {
                  if (c %2 ==0){
                    if (n == j+c+1){
                     //printf("*new value: new: n = %d, value = %f\n",n-c),curC2);
                     borders_new[n-c] = curC2;
                    }
                    else {
                      if (n>j+c+1) {
                        //printf("*copy after: old: n = %d, new: n = %d, value = %f\n",n,n-c,borders[n]);
                        borders_new[n-c] = borders[n];
                      }
                    }
                  }
                  else {
                    if (n>j+c+1) {
                    //printf("*copy after: old: n = %d, new: n = %d, value = %f\n",n,n-c,borders[n]);
                      borders_new[n-c-1] = borders[n];
                    }
                  }
                }
              }
              delete [] borders;
              borders = borders_new;
              borders_size = newSize;
              break;
            }
            else {
              //printf("***replace %f with %f\n", borders[j+1], curC2);
              borders[j+1] = curC2;
              break;
            }
          }
        }
        else {
          //printf("    159:curC1 >= borders[j+1] (%f)\n",borders[j]);
          j += 2;
        }
      }
    }
    if (j >= borders_size){
      //printf("    165:appending curC1 and curC2 to borders\n");
      float * borders_new = new float[borders_size+2]; 
      for (unsigned int n = 0; n < borders_size; n++ ) {
        borders_new[n] = borders[n];
      }
      delete [] borders;
      borders = borders_new;
      borders[borders_size]   = curC1;
      borders[borders_size+1] = curC2;
      borders_size = borders_size+2;
    }
  }
  retVal = -1;
  //printf("%f, ",borders[0]);
  for (unsigned int i = 2; i<borders_size; i+=2){
    //printf("%f, %f, ",borders[i-1],borders[i]);
    if (((borders[i]-borders[i-1]) - retVal) > 0.5){
      retVal = borders[i]-borders[i-1];
      *C1 = borders[i-1];
      *C2 = borders[i];
    }
    //printf("between %f and %f there is a seperation of %f\n",borders[i-1],borders[i],borders[i]-borders[i-1]);
  }
  //printf("\n");
  delete [] borders;
  //Arbitrary cut-of values
/*  if (
      (direction == HORIZONTAL and retVal < C_maxHCutValue) or 
      (direction == VERTICAL and retVal < C_maxVCutValue)
     ) 
  {
    retVal = -1;
  }*/
  return retVal;
}

void ABWOutputDev::updateFont(GfxState *state) {
  char buf[160];
  double x,y;
  xmlNodePtr N_cur;
  GfxFont *font;
  bool found = false;
  xmlChar val[8];
  bool isBold, isItalic, S_isBold, S_isItalic;
  isBold = isItalic = S_isBold =  S_isItalic = false;
  font = state->getFont();
  GooString *ftName;
  char *fnEnd, *fnName;
  int fnLength, fnStart, ftSize;
  //the first time this function is called there is no funt.
  //Fixme: find out if that isn'y a bug
  if (font){
    isBold = (font->isBold() or font->getWeight() >6 or (strstr(font->getOrigName()->getCString(), "Bold")-font->getOrigName()->getCString() == (font->getOrigName()->getLength()-4)));
    isItalic =  (font->isItalic() or (strstr(font->getOrigName()->getCString(), "Italic")-font->getOrigName()->getCString() == (font->getOrigName()->getLength()-6)));
    ftSize = int(state->getTransformedFontSize())-1;
    ftName = new GooString(font->getOrigName());
    fnStart = strcspn(ftName->getCString(), "+");
    if (fnStart < ftName->getLength())
      ftName->del(0,fnStart+1);
    fnEnd = strrchr(ftName->getCString(), 44);
    if (fnEnd == 0)
      fnEnd = strrchr(ftName->getCString(), 45);
    if (fnEnd != 0)
      ftName->del(fnEnd-ftName->getCString(),ftName->getLength()-1);
    
/*    fnName = ftName;
    if (isBold or isItalic){
      fnStart = strcspn(fnName, "+");
      if (fnStart == font->getOrigName()->getLength())
        fnStart = 0;
      else fnStart++;

      fnEnd = strstr(fnName, ",");
      if (fnEnd == 0)
        fnEnd = strstr(fnName, "-");
      if (fnEnd != 0)
        fnName[fnEnd-fnName] = 0;
//      char fntName[fnLength];
//      strncpy (fntName,fnName+fnStart+1,fnLength);
      fnName+=fnStart;
//      fnName = fntName;
    }
    else {*/
      fnName = ftName->getCString();
//    }
    for (N_cur = N_styleset->children; N_cur; N_cur = N_cur ->next){
      if (
       isBold == (xmlStrcasecmp(xmlGetProp(N_cur,BAD_CAST "bold"),BAD_CAST "bold;") == 0)
       and
       isItalic == (xmlStrcasecmp(xmlGetProp(N_cur,BAD_CAST "italic"),BAD_CAST "italic") == 0)
       and
       xmlStrcasecmp(xmlGetProp(N_cur,BAD_CAST "font"),BAD_CAST fnName) == 0
       and
       xmlXPathCastStringToNumber(xmlGetProp(N_cur,BAD_CAST "size")) == ftSize
      ) {
        found = true;
        Style = int(xmlXPathCastStringToNumber(xmlGetProp(N_cur,BAD_CAST "id")));
      }
    }
    if (!found){
      N_cur = xmlNewChild(N_styleset, NULL, BAD_CAST "s", NULL);
      xmlSetProp(N_cur, BAD_CAST "type", BAD_CAST "P");
      sprintf(buf, "%d", maxStyle++);
      xmlSetProp(N_cur, BAD_CAST "name", BAD_CAST buf);
      xmlSetProp(N_cur, BAD_CAST "id", BAD_CAST buf);
      Style = maxStyle;
      sprintf(buf, "%d", ftSize); xmlSetProp(N_cur, BAD_CAST "size", BAD_CAST buf);
      isBold   ? xmlSetProp(N_cur, BAD_CAST "bold", BAD_CAST "bold;")  : xmlSetProp(N_cur, BAD_CAST "bold", BAD_CAST "normal;");
      isItalic ? xmlSetProp(N_cur, BAD_CAST "italic", BAD_CAST "italic"): xmlSetProp(N_cur, BAD_CAST "italic", BAD_CAST "normal");
      xmlSetProp(N_cur, BAD_CAST "font", BAD_CAST fnName);
    }
  }
}

void ABWOutputDev::drawChar(GfxState *state, double x, double y,
			double dx, double dy,
			double originX, double originY,
			CharCode code, int nBytes, Unicode *u, int uLen)
{
  //I wouldn't know what size this should safely be. I guess 64 bytes should be
  //enough for any unicode character
  char buf[64];
  int charLen;
  x = dx;
  y = dy;
  //state->textTransformDelta(dx * state->getHorizScaling(), dy, &dx, &dy);
  //state->transformDelta(dx, dy, &dx, &dy);
  if (uLen == 1 && code == 0x20) {
    //If we break a text sequence on space, then the X1 should be increased
    //but the Y1 and Y2 should remain the same.
    beginWord(state,X2+dx,Y2);
  }
  else {
    X2    += dx;
    Y2    += dy;
    charLen = uMap->mapUnicode(*u,buf,sizeof(buf));
    //Getting Unicode to libxml is something I need to fix.
    //simply passing it using a bad-cast isn't working.
    //I assume that CharCode code it the U+value of the unicode character
    //But for a ligature code gives me DF which is the ringel-s, I guess
    //code should be two bytes wide?
    xmlNodeAddContentLen(N_word, BAD_CAST buf, charLen);
  }
}

void ABWOutputDev::beginString(GfxState *state, GooString *s) {
  double x,y;
  //state->textTransform(x, y, &x, &y);
  state->transform(state->getCurX(), state->getCurY(), &x, &y);
  if (N_word) {
    verDist = y-Y2;
    horDist = x-X2;
    //TEST:changed fabs(horDist) to horDist
    //FIXME: this if statement seems awkward to me.
    if (horDist > (state->getTransformedFontSize()*maxWordSpacing) or (fabs(verDist) > (state->getTransformedFontSize()/maxLineSpacingDelta))) {
      beginTextBlock(state,x,y);
    }
    else {
      if ((horDist > (state->getTransformedFontSize()*minWordBreakSpace)) or (fabs(verDist) > (state->getTransformedFontSize()/maxLineSpacingDelta))) {
        beginWord(state,x,y);
      }
    }
  }
  else {
  //This is the first word. Clear all values and call beginWord;
    X2 = x;
    Y2 = y;
    horDist = 0;
    verDist = 0;
    height  = 0;
    beginTextBlock(state,x,y);
  }
}

void ABWOutputDev::endString(GfxState *state) {

}

void ABWOutputDev::beginWord(GfxState *state, double x, double y){
  char buf[20];
//  printf("***BREAK!***\n");
  endWord();
  X1 = x;
  Y2 = y;

  horDist = X1-X2;
  verDist = Y1-Y2;

  X2 = X1;
  height = state->getFont()->getAscent() * state->getTransformedFontSize();
  Y1 = Y2-height;

  N_word = xmlNewChild(N_Block, NULL, BAD_CAST "word", NULL);
  sprintf(buf, "%f", X1); xmlNewProp(N_word, BAD_CAST "X1", BAD_CAST buf);
  sprintf(buf, "%f", Y1); xmlNewProp(N_word, BAD_CAST "Y1", BAD_CAST buf);
  sprintf(buf, "%d", Style); xmlNewProp(N_word, BAD_CAST "style", BAD_CAST buf);
}

void ABWOutputDev::endWord(){
  char buf[20];
  if (N_word) {
    sprintf(buf, "%f", X2);    xmlNewProp(N_word, BAD_CAST "X2", BAD_CAST buf);
    sprintf(buf, "%f", Y2);    xmlNewProp(N_word, BAD_CAST "Y2", BAD_CAST buf);
    sprintf(buf, "%f", X2-X1); xmlNewProp(N_word, BAD_CAST "width", BAD_CAST buf);
    sprintf(buf, "%f", Y2-Y1); xmlNewProp(N_word, BAD_CAST "height", BAD_CAST buf);
    N_word = NULL;
  }
}

void ABWOutputDev::beginTextBlock(GfxState *state, double x, double y){
  char buf[20];
  endTextBlock();
  N_Block = xmlNewChild(N_page, NULL, BAD_CAST "Textblock", NULL);
  beginWord(state,x,y);
}

void ABWOutputDev::endTextBlock(){
  char buf[20];
  if (N_Block) {
    endWord();
    N_Block = NULL;  
  }
}
/*
This will be a function to retrieve coherent text blocks from the chunk tree.*/
void ABWOutputDev::interpretXYTree(){
  xmlNodePtr N_oldPage;
  N_oldPage = N_page;
  N_page = xmlNewNode(NULL, BAD_CAST "page");
  N_column = N_page;
  //xmlAddChild(N_content, N_page);
  N_Block = xmlNewChild(N_column, NULL, BAD_CAST "chunk", NULL);
  ATP_recursive(N_oldPage);
}

void ABWOutputDev::ATP_recursive(xmlNodePtr N_parent){
  xmlNodePtr N_first, N_second, N_line, N_tempCol, N_tempColset;
  N_first  = N_parent->children;
  if (!N_first)
    return;

  N_second = N_first->next;
  char buf[20];
/*
  Possibilities: 
  there is one child node
    Because we cleaned up before the only case where we allow one childnode is 
    within Textblocks and textBlocks within 'vertical' nodes.
      basically one text node means: add it to the current block.
  There are two childnodes
    This can be two verticals, two horizontals or one horizontal and a text node.
    verticals:
      If the first is vertical, the second is as well.
      verticals mean: create a new Block, add a column per vertical make the
      vertical the block and recurse inside.
      then make the second vertical the block and recurse inside
      then finish the block (ie. create a new one)
    horizontal and or Textblocks
        if first is textnode
          add first to block
          if second is textnode
            at to block
          else
            call again
        else
          begin new block
            call again
          begin new block
          if second is text node
            add to block
          else
            call again
  there are more then two child nodes
    this can be a number of Textblocks and horizontals
    add the textNodes to the current Block
    if a horizontal is encountered enter it and generate a new block afterwards
  */
  //fprintf(stderr,"**********************************************************************\n");
  //xmlSaveFormatFileEnc("-", doc, "UTF-8", 1);
  switch (xmlLsCountNode(N_parent)) {
  case 1:
    //fprintf(stderr,"case 1\n");
    N_line = xmlNewChild(N_Block, NULL, BAD_CAST "line", NULL);
    xmlUnlinkNode(N_first);
    xmlAddChild(N_line, N_first);
    break;
  case 2:
    //fprintf(stderr,"case 2\n");
    if (xmlStrcasecmp(N_first->name,BAD_CAST "vertical") == 0){
      //store the column for the moment
      N_tempCol = N_column;
      /*If we have three columns they will turn up in the tree as:
      <vertical>
        <vertical/>
        <vertical/>
      </vertical>
      <vertical/>
      */
      //if the parent is a vertical as well, we can skip the colset generation 
      //thing here we can also remove the just added column and block, because 
      //these are going to replace them
      if (xmlStrcasecmp(N_parent->name,BAD_CAST "vertical") != 0){
        //fprintf(stderr,"first time column\n");
        N_tempColset = N_colset;
        N_colset = xmlNewChild(N_column, NULL, BAD_CAST "colset", NULL);
        N_column = xmlNewChild(N_colset, NULL, BAD_CAST "column", NULL);
        N_Block = xmlNewChild(N_column, NULL, BAD_CAST "chunk", NULL);
      }
      else {
        //fprintf(stderr,"second time column\n");
        xmlUnlinkNode(N_column);
        N_column = xmlNewChild(N_colset, NULL, BAD_CAST "column", NULL);
        N_Block = xmlNewChild(N_column, NULL, BAD_CAST "chunk", NULL);
      }
      //fprintf(stderr,"Building first column...\n");
      ATP_recursive(N_first);
      N_column = xmlNewChild(N_colset, NULL, BAD_CAST "column", NULL);
      N_Block = xmlNewChild(N_column, NULL, BAD_CAST "chunk", NULL);
      //fprintf(stderr,"Building second column...\n");
      ATP_recursive(N_second);
      //make sure we end the column by continuing in the master column and 
      //setting the block and line to it
      N_column = N_tempCol;
      if (xmlStrcasecmp(N_parent->name,BAD_CAST "vertical") != 0){
        N_colset = N_tempColset;
      }
    }
    else {
      if (xmlStrcasecmp(N_first->name,BAD_CAST "Textblock") == 0) {
        //fprintf(stderr,"add first as textblock\n");
        N_line = xmlNewChild(N_Block, NULL, BAD_CAST "line", NULL);
        xmlUnlinkNode(N_first);
        xmlAddChild(N_line, N_first);
        if (xmlStrcasecmp(N_second->name,BAD_CAST "Textblock") == 0) {
          //fprintf(stderr,"add second as textblock\n");
          //FIXME: this is not neat. We should ignore the cut ignoring when there are only two elements above
          //line aggregation doesn't work anyway atm.
          xmlUnlinkNode(N_second);
          xmlAddChild(N_line, N_second);
          //We have two textChunks that are going to be added to the line.
          //the following statements make the line wrap around both textblocks
          //if the firstX1 is smaller then the second X1 use the first, else use the second etc.
        }
        else {
          //fprintf(stderr,"recursing into second\n");
          ATP_recursive(N_second);
        }
      }
      else {
        N_Block = xmlNewChild(N_column, NULL, BAD_CAST "chunk", NULL);
        //fprintf(stderr,"recursing into first\n");
        ATP_recursive(N_first);
        N_Block = xmlNewChild(N_column, NULL, BAD_CAST "chunk", NULL);
        if (xmlStrcasecmp(N_second->name,BAD_CAST "Textblock") == 0) {
          //fprintf(stderr,"add second as textblock\n");
          N_line = xmlNewChild(N_Block, NULL, BAD_CAST "line", NULL);
          xmlUnlinkNode(N_second);
          xmlAddChild(N_line, N_second);
        }
        else {
          //fprintf(stderr,"recursing into second\n");
          ATP_recursive(N_second);
        }
      }
    }
    break;
  default:
    double tX1=0, tX2=0, tY1=0, tY2=0;
    //fprintf(stderr,"case default\n");
    N_line = xmlNewChild(N_Block, NULL, BAD_CAST "line", NULL);
    while (N_first){
      //xmlXPathCastStringToNumber(xmlGetProp(N_first,BAD_CAST "X1")) < tX1 ? tX1 = xmlXPathCastStringToNumber(xmlGetProp(N_first,BAD_CAST "X1")) : tX1 = tX1;
      //xmlXPathCastStringToNumber(xmlGetProp(N_first,BAD_CAST "X2")) > tX2 ? tX2 = xmlXPathCastStringToNumber(xmlGetProp(N_first,BAD_CAST "X2")) : tX2 = tX2;
      //xmlXPathCastStringToNumber(xmlGetProp(N_first,BAD_CAST "Y1")) < tY1 ? tY1 = xmlXPathCastStringToNumber(xmlGetProp(N_first,BAD_CAST "Y1")) : tY1 = tY1;
      //xmlXPathCastStringToNumber(xmlGetProp(N_first,BAD_CAST "Y2")) > tY2 ? tY2 = xmlXPathCastStringToNumber(xmlGetProp(N_first,BAD_CAST "Y2")) : tY1 = tY2;
      N_second = N_first->next;
      if (xmlStrcasecmp(N_first->name,BAD_CAST "Textblock") == 0){
        xmlUnlinkNode(N_first);
        xmlAddChild(N_line, N_first);
      }
      else { //fprintf(stderr,"This shouldn't happen! (line 700)\n");
      }
      N_first = N_second;
    }
    break;
  }
}

/*The cleanup function. It started out as a simple function to remove empty nodes
so that I could call xmladdnewchildnode as often as I liked so that I wouldn't get seg-faults
It is now a bit more advanced, makes sure the tree is as it's supposed to be and adds information too*/
void ABWOutputDev::cleanUpNode(xmlNodePtr N_parent, bool aggregateInfo){
  double tX1=-1, tX2=-1, tY1=-1, tY2=-1;
  xmlNodePtr N_cur, N_next;
  N_cur = N_parent->children;
  char buf[20];
  int prevStyle = -1;
  xmlChar *val;
  int styleLength = xmlLsCountNode(N_styleset)+1;
  float stylePos;
  int styles[styleLength];
  for (int i=1; i< styleLength; i++) { styles[i] = 0;}
  /*
  ignore two horizontal nodes with textBlocks right underneath them. They 
  signal the end of a chunk, and the horizontal seperation needs to be 
  preserved, because it means they are different lines. The second horizontal 
  therefore needs to be kept.
  */
  if ((xmlLsCountNode(N_parent) == 2)
      and
     xmlStrcasecmp(N_parent->name,BAD_CAST "horizontal") == 0
      and 
     N_cur
      and
     N_cur->next
      and
     xmlStrcasecmp(N_cur->name,BAD_CAST "horizontal") == 0 and xmlStrcasecmp(N_cur->next->name,BAD_CAST "horizontal") == 0
      and
     xmlLsCountNode(N_cur) == 1 and xmlLsCountNode(N_cur->next) == 1
      and
     xmlStrcasecmp(N_cur->children->name,BAD_CAST "Textblock") == 0 and xmlStrcasecmp(N_cur->next->children->name,BAD_CAST "Textblock") == 0
     ) {
    xmlAddPrevSibling(N_cur->next,N_cur->children); 
    xmlUnlinkNode(N_cur);
  } 
  /*
  This removes columns if one of the parts is actually a single letter.
  I found out I liked the columns better, so I have the code commented out.
  */
/*  else if ((xmlLsCountNode(N_parent) == 2)
             and
            N_cur
             and
            N_cur->next
             and 
            xmlStrcasecmp(N_cur->name,BAD_CAST "vertical") == 0
             and
            xmlStrcasecmp(N_cur->next->name,BAD_CAST "vertical") == 0
             and 
            (N_cur->children) 
             and
            (N_cur->children->children)
             and
            (N_cur->children->children->children)
             and
            xmlStrlen(N_cur->children->children->children->content) == 1) {
    N_next = N_cur->next;
    xmlAddChild(N_parent, N_next->children);
    xmlAddPrevSibling(N_next->children->children, N_cur->children);
    xmlUnlinkNode(N_cur);
    xmlUnlinkNode(N_next);
  } */else {
    while (N_cur){
      N_next = N_cur->next;
      cleanUpNode(N_cur, aggregateInfo);
      if (xmlLsCountNode(N_cur) == 0 and (xmlStrcasecmp(N_cur->name,BAD_CAST "cbr") != 0) and (xmlStrcasecmp(N_cur->name,BAD_CAST "s") != 0))
        xmlUnlinkNode(N_cur);
      //If the node is still around
      N_cur = N_next;
    }
  }
  //If a countainer element has only one child, it can be removed except for vertical
  //cuts with only one textElement;
  //the main reason for this code is to remove the crumbs after cleaning up in the loop above
  if ((xmlLsCountNode(N_parent) == 1) and ((xmlStrcasecmp(N_parent->name,BAD_CAST "horizontal") == 0) or ((xmlStrcasecmp(N_parent->name,BAD_CAST "vertical") == 0) and (xmlStrcasecmp(N_parent->children->name,BAD_CAST "Textblock") != 0)))){
    N_cur = N_parent->children;
    xmlAddPrevSibling(N_parent,N_cur);
    xmlUnlinkNode(N_parent);
  }
  //We cannot remove the page element so if it has only one childnode, we remove that childnode instead
  if ((xmlStrcasecmp(N_parent->name,BAD_CAST "page") == 0) and (xmlLsCountNode(N_parent) == 1)) {
    N_cur = N_parent->children->children;
    while (N_cur){
      N_next = N_cur->next;
      xmlUnlinkNode(N_cur);
      xmlAddChild(N_parent, N_cur);
      N_cur = N_next;
    }
    xmlUnlinkNode(N_parent->children);
  }
  //Ok, so by this time the N_parent and his children are guaranteed to be clean
  //this for loop gets information from the 'word' elements and propagates it up
  //the tree. 
  if (aggregateInfo and xmlStrcasecmp(N_parent->name,BAD_CAST "word") != 0) {
    for (N_cur = N_parent->children; N_cur; N_cur = N_cur->next){
      val = xmlGetProp(N_cur,BAD_CAST "style");
      stylePos = xmlXPathCastStringToNumber(val);
      //fprintf(stderr,"1: %f, %d\n",stylePos,int(stylePos));
      styles[int(stylePos)]=styles[int(stylePos)]+1;
      //fprintf(stderr,"2: styles[%d] = %d\n",int(stylePos),styles[int(stylePos)]);
      (xmlXPathCastStringToNumber(xmlGetProp(N_cur,BAD_CAST "X1")) < tX1 or tX1 == -1)? tX1 = xmlXPathCastStringToNumber(xmlGetProp(N_cur,BAD_CAST "X1")) : tX1 = tX1;
      (xmlXPathCastStringToNumber(xmlGetProp(N_cur,BAD_CAST "X2")) > tX2)             ? tX2 = xmlXPathCastStringToNumber(xmlGetProp(N_cur,BAD_CAST "X2")) : tX2 = tX2;
      (xmlXPathCastStringToNumber(xmlGetProp(N_cur,BAD_CAST "Y1")) < tY1 or tY1 == -1)? tY1 = xmlXPathCastStringToNumber(xmlGetProp(N_cur,BAD_CAST "Y1")) : tY1 = tY1;
      (xmlXPathCastStringToNumber(xmlGetProp(N_cur,BAD_CAST "Y2")) > tY2)             ? tY2 = xmlXPathCastStringToNumber(xmlGetProp(N_cur,BAD_CAST "Y2")) : tY2 = tY2;
    }
    sprintf(buf, "%f", tX1);     xmlSetProp(N_parent, BAD_CAST "X1", BAD_CAST buf);
    sprintf(buf, "%f", tX2);     xmlSetProp(N_parent, BAD_CAST "X2", BAD_CAST buf);
    sprintf(buf, "%f", tY1);     xmlSetProp(N_parent, BAD_CAST "Y1", BAD_CAST buf);
    sprintf(buf, "%f", tY2);     xmlSetProp(N_parent, BAD_CAST "Y2", BAD_CAST buf);
    sprintf(buf, "%f", tX2-tX1); xmlSetProp(N_parent, BAD_CAST "width", BAD_CAST buf);
    sprintf(buf, "%f", tY2-tY1); xmlSetProp(N_parent, BAD_CAST "height", BAD_CAST buf);
    prevStyle = 0;
    styles[0] = -1;
    for (int i=1; i< styleLength; i++) { if (styles[i] > styles[prevStyle]) prevStyle = i; }
    //fprintf(stderr,"%d\n", prevStyle);
    if (prevStyle > 0){
      sprintf(buf, "%d", prevStyle);     xmlSetProp(N_parent, BAD_CAST "style", BAD_CAST buf);
    }
  }
  if (N_parent->children and xmlStrcasecmp(N_parent->children->name,BAD_CAST "line") == 0 and xmlGetProp(N_parent->children,BAD_CAST "alignment") != NULL)
    xmlSetProp(N_parent, BAD_CAST "alignment", xmlGetProp(N_parent->children,BAD_CAST "alignment"));
}

void ABWOutputDev::generateParagraphs() {
  xmlNodePtr N_cur, N_parent, N_p, N_line, N_next;
  int lvl;
  //basically I first detect the text-alignment within blocks.
  //ASSUMPTION: my block seperation thing is good enough so I don't need to
  //worry about two alignments in one paragraph
  
  X1 = 0;
  X2 = pdfdoc->getPageCropWidth(G_pageNum);
  Y1 = 0;
  Y2 = pdfdoc->getPageCropHeight(G_pageNum);
  addAlignment(N_page);
  
  //then it's a switch per alignement
  N_cur = N_page->children;
  N_parent = N_page;
  lvl = 1;
  while (N_cur) {
    if (xmlStrcasecmp(N_cur->name,BAD_CAST "chunk") == 0){
      N_p = xmlNewNode(NULL, BAD_CAST "chunk");
      xmlAddPrevSibling(N_cur,N_p);
      //N_p = xmlNewChild(N_parent, NULL, BAD_CAST "chunk", NULL);
      //A new paragraph is created when:
      switch (int(xmlXPathCastStringToNumber(xmlGetProp(N_cur,BAD_CAST "alignment")))){
      //left
      case 1: //the distance between the texblock X2 and the last word X2 is more than
         //the following first word width.
         N_line = N_cur->children;
         while (N_line){
           N_next = N_line->next;
           xmlUnlinkNode(N_line);
           xmlAddChild(N_p,N_line);
           xmlSetProp(N_line, BAD_CAST "alignment", BAD_CAST "1");
           if (N_next and xmlStrcasecmp(N_next->name,BAD_CAST "line") == 0){
             if (xmlXPathCastStringToNumber(xmlGetProp(N_next->children->children,BAD_CAST "width")) < (xmlXPathCastStringToNumber(xmlGetProp(N_cur,BAD_CAST "width")) - xmlXPathCastStringToNumber(xmlGetProp(N_line,BAD_CAST "width")))){
               N_p = xmlNewNode(NULL, BAD_CAST "chunk");
               xmlAddPrevSibling(N_cur,N_p);
             }
           }
           N_line = N_next;
         }
         break;
      //right
      case 2: //the same but now with X1 and first word and following last word
         N_line = N_cur->children;
         while (N_line){
           N_next = N_line->next;
           xmlUnlinkNode(N_line);
           xmlAddChild(N_p,N_line);
           xmlSetProp(N_line, BAD_CAST "alignment", BAD_CAST "2");
           if (N_next and xmlStrcasecmp(N_next->name,BAD_CAST "line") == 0){
             //fprintf(stderr,"width_next=%f, X2_bl=%f, X2_w=%f\n",xmlXPathCastStringToNumber(xmlGetProp(N_next->children->children,BAD_CAST "width")),xmlXPathCastStringToNumber(xmlGetProp(N_cur,BAD_CAST "width")),xmlXPathCastStringToNumber(xmlGetProp(N_line,BAD_CAST "width")));
             if (xmlXPathCastStringToNumber(xmlGetProp(N_next->children->children,BAD_CAST "width")) < (xmlXPathCastStringToNumber(xmlGetProp(N_cur,BAD_CAST "width")) - xmlXPathCastStringToNumber(xmlGetProp(N_line,BAD_CAST "width")))){
               N_p = xmlNewNode(NULL, BAD_CAST "chunk");
               xmlAddPrevSibling(N_cur,N_p);
             }
           }
           N_line = N_next;
         }
         break;
      //centered
      case 3: //the combined left and right space is more than the following first word
         N_line = N_cur->children;
         while (N_line){
           N_next = N_line->next;
           xmlUnlinkNode(N_line);
           xmlAddChild(N_p,N_line);
           xmlSetProp(N_line, BAD_CAST "alignment", BAD_CAST "3");
           if (N_next and xmlStrcasecmp(N_next->name,BAD_CAST "line") == 0){
             //fprintf(stderr,"width_next=%f, X2_bl=%f, X2_w=%f\n",xmlXPathCastStringToNumber(xmlGetProp(N_next->children->children,BAD_CAST "width")),xmlXPathCastStringToNumber(xmlGetProp(N_cur,BAD_CAST "width")),xmlXPathCastStringToNumber(xmlGetProp(N_line,BAD_CAST "width")));
             if (xmlXPathCastStringToNumber(xmlGetProp(N_next->children->children,BAD_CAST "width")) < (xmlXPathCastStringToNumber(xmlGetProp(N_cur,BAD_CAST "width")) - xmlXPathCastStringToNumber(xmlGetProp(N_line,BAD_CAST "width")))){
               N_p = xmlNewNode(NULL, BAD_CAST "chunk");
               xmlAddPrevSibling(N_cur,N_p);
             }
           }
           N_line = N_next;
         }
         break;
      //justified
      case 4:
         //we break on all alignment=1 lines. A line with alignment=1 that is the first of a block will
         //also initiate a paragraph break before.
         N_line = N_cur->children;
         if (xmlXPathCastStringToNumber(xmlGetProp(N_line,BAD_CAST "alignment")) == 1){
           N_p = xmlNewNode(NULL, BAD_CAST "chunk");
           xmlAddPrevSibling(N_cur,N_p);
         }
         while (N_line){
           N_next = N_line->next;
           xmlUnlinkNode(N_line);
           xmlAddChild(N_p,N_line);
           if (xmlXPathCastStringToNumber(xmlGetProp(N_line,BAD_CAST "alignment")) == 1){
             N_p = xmlNewNode(NULL, BAD_CAST "chunk");
             xmlAddPrevSibling(N_cur,N_p);
           }
           xmlSetProp(N_line, BAD_CAST "alignment", BAD_CAST "4");
           N_line = N_next;
         }
         break;
      }
    }
    else if (xmlStrcasecmp(N_cur->name,BAD_CAST "colset") == 0 or xmlStrcasecmp(N_cur->name,BAD_CAST "column") == 0){
      N_parent = N_cur;
      N_cur = N_cur->children;
      lvl++;
      N_p = xmlNewNode(NULL, BAD_CAST "chunk");
      xmlAddPrevSibling(N_cur,N_p);
      continue;
    }
    if (N_cur->next)
      N_cur = N_cur->next;
    else while (lvl > 0){
      N_cur = N_parent;
      N_parent = N_cur->parent;
      lvl--;
      if (N_cur->next){
        N_cur = N_cur->next;
        break;
      }
    }
    if (lvl==0)
      N_cur = NULL;
  }
}

//function that adds an 'alignment=' property to the <chunk>s
void ABWOutputDev::addAlignment(xmlNodePtr N_parent) {
  xmlNodePtr N_chunk, N_line;
  double tX1, tX2;
  bool leftMatch, rightMatch, centerMatch;
  int leftCnt = 0, rightCnt = 0, cntrCnt = 0, justCnt = 0;
  //fprintf(stderr,"Entering addAlignment\n");
  for (N_chunk = N_parent->children; N_chunk; N_chunk = N_chunk->next) {
    if (xmlStrcasecmp(N_chunk->name,BAD_CAST "chunk") == 0){
      X1 = xmlXPathCastStringToNumber(xmlGetProp(N_chunk,BAD_CAST "X1"));
      X2 = xmlXPathCastStringToNumber(xmlGetProp(N_chunk,BAD_CAST "X2"));
      //fprintf(stderr,"Found chunk\n");
      //if the chunk contains only one line, we don't need to loop through it.
      if (xmlLsCountNode(N_chunk) == 1){
        //fprintf(stderr,"Processing line\n");
        //fprintf(stderr,"X1=%f, X2=%f, cX1=%f, cX2=%f\n",X1,X2,xmlXPathCastStringToNumber(xmlGetProp(N_chunk,BAD_CAST "X1")), xmlXPathCastStringToNumber(xmlGetProp(N_chunk,BAD_CAST "X2")));
        //fprintf(stderr,"%f\n",(xmlXPathCastStringToNumber(xmlGetProp(N_chunk,BAD_CAST "X1")) - X1)-(X2 - xmlXPathCastStringToNumber(xmlGetProp(N_chunk,BAD_CAST "X2"))));
        //fprintf(stderr,"cX1-X1=%f, X2-cX2=%f\n",(xmlXPathCastStringToNumber(xmlGetProp(N_chunk,BAD_CAST "X1")) - X1),(X2 - xmlXPathCastStringToNumber(xmlGetProp(N_chunk,BAD_CAST "X2"))));
        // a one line chunk, is either centered or left or right-aligned.
        if ((xmlXPathCastStringToNumber(xmlGetProp(N_chunk,BAD_CAST "X1"))-X1)-(X2-xmlXPathCastStringToNumber(xmlGetProp(N_chunk,BAD_CAST "X2"))) > 1) {
          xmlNewProp(N_chunk, BAD_CAST "alignment", BAD_CAST "2");
          xmlNewProp(N_chunk->children, BAD_CAST "alignment", BAD_CAST "2");
          //fprintf(stderr,"alignment = right\n");
        }
        else { 
        if ((xmlXPathCastStringToNumber(xmlGetProp(N_chunk,BAD_CAST "X1"))-X1)-(X2 - xmlXPathCastStringToNumber(xmlGetProp(N_chunk,BAD_CAST "X2")))< -1) {
          xmlNewProp(N_chunk, BAD_CAST "alignment", BAD_CAST "1");
          xmlNewProp(N_chunk->children, BAD_CAST "alignment", BAD_CAST "1");
          //fprintf(stderr,"alignment = left\n");
        }
        else {
          xmlNewProp(N_chunk, BAD_CAST "alignment", BAD_CAST "3");
          xmlNewProp(N_chunk->children, BAD_CAST "alignment", BAD_CAST "3");
          //fprintf(stderr,"alignment = center\n");
        }
        }
      }
      else {
      leftCnt = 0;
      rightCnt = 0;
      cntrCnt = 0;
      justCnt = 0;
      for (N_line = N_chunk->children; N_line; N_line = N_line->next) {
        //fprintf(stderr,"Processing line\n");
        /*
        |X1 - cX1| == 1
        |X2 - cX2| == 1
        |(cX1-X1)-(X2-cX2)| == 1
        ok, each line can be just as wide as the current set,
        it can be smaller and moved to the right
        it can be smaller and moved to the left.
        it can 
        */
        //fprintf(stderr,"X1=%f, X2=%f, cX1=%f, cX2=%f\n",X1,X2,xmlXPathCastStringToNumber(xmlGetProp(N_line,BAD_CAST "X1")), xmlXPathCastStringToNumber(xmlGetProp(N_line,BAD_CAST "X2")));
        //fprintf(stderr,"cX1-X1=%f, X2-cX2=%f\n",(xmlXPathCastStringToNumber(xmlGetProp(N_line,BAD_CAST "X1")) - X1),(X2 - xmlXPathCastStringToNumber(xmlGetProp(N_line,BAD_CAST "X2"))));
        leftMatch =  fabs(xmlXPathCastStringToNumber(xmlGetProp(N_line,BAD_CAST "X1"))-X1) < 2;
        rightMatch =  fabs(X2-xmlXPathCastStringToNumber(xmlGetProp(N_line,BAD_CAST "X2"))) < 2;
        centerMatch =  fabs((xmlXPathCastStringToNumber(xmlGetProp(N_line,BAD_CAST "X1"))-X1)-(X2-xmlXPathCastStringToNumber(xmlGetProp(N_line,BAD_CAST "X2")))) < 2;
        if (leftMatch and rightMatch) {
          xmlNewProp(N_line, BAD_CAST "alignment", BAD_CAST "4");
          justCnt++;
        }
        else if (centerMatch) {
          xmlNewProp(N_line, BAD_CAST "alignment", BAD_CAST "3");
          cntrCnt++;
        }
        else if (rightMatch) {
          xmlNewProp(N_line, BAD_CAST "alignment", BAD_CAST "2");
          rightCnt++;
        }
        else {
          xmlNewProp(N_line, BAD_CAST "alignment", BAD_CAST "1");
          leftCnt++;
        }
      }
      //there is almost always one justified line in a centered text
      //and most justified blocks have at least one left aligned line
      //fprintf(stderr,"1:%d ,2:%d ,3:%d ,4:%d\n",leftCnt,justCnt,cntrCnt,rightCnt);
      if ((leftCnt-1 >= justCnt) and (leftCnt >= rightCnt) and (leftCnt >= cntrCnt))
        xmlNewProp(N_chunk, BAD_CAST "alignment", BAD_CAST "1");
      else if ((justCnt >= leftCnt-1) and (justCnt >= rightCnt) and (justCnt >= cntrCnt))
        xmlNewProp(N_chunk, BAD_CAST "alignment", BAD_CAST "4");
      else if ((cntrCnt >= justCnt-1) and (cntrCnt >= rightCnt) and (cntrCnt >= leftCnt))
        xmlNewProp(N_chunk, BAD_CAST "alignment", BAD_CAST "3");
      else
        xmlNewProp(N_chunk, BAD_CAST "alignment", BAD_CAST "2");
      }
    } 
    else {
      if (xmlStrcasecmp(N_chunk->name,BAD_CAST "colset") == 0){
        //fprintf(stderr,"Found a colset\n");
        addAlignment(N_chunk);
      }
      else {
        if (xmlStrcasecmp(N_chunk->name,BAD_CAST "column") == 0){
          //fprintf(stderr,"Found a column\n");
          tX1 = X1;
          tX2 = X2;
          X1 = xmlXPathCastStringToNumber(xmlGetProp(N_chunk,BAD_CAST "X1"));
          X2 = xmlXPathCastStringToNumber(xmlGetProp(N_chunk,BAD_CAST "X2"));
          addAlignment(N_chunk);
          X1 = tX1;
          X2 = tX2;
        }
        else { //fprintf(stderr,"Found something else\n");
	}
      }
    }
  }
//parse all blocks, and all lines within all blocks
//do a set of checks and tick a flag if the check fails
//check for line X1 is textBlock X1
//check for line X2 is textblock X2
//check if line is centered in textBock (LX1 != TX1 && LX2 != TX2 && LX1-TX1 == TX2=LX2)
//if the LX1 != TX1 then how much is the difference?
//a line isn't left aligned if all lines have a different X1 <= not so strong assumption.

//justified if both are straight except for a couple of (same factor sized) indents at the left
//else centered if above calculation is correct
//else left aligned if left side is more straight than right (more lines in the same X1 or common factor
//else right
}

void ABWOutputDev::setPDFDoc(PDFDoc *priv_pdfdoc) {
  pdfdoc = priv_pdfdoc;
}

void ABWOutputDev::createABW() {
  //*************************************************************
  //change styles to abiword format
  xmlNodePtr N_cur, N_next;
  xmlAttrPtr N_prop;
  char buf[500];
  for (N_cur = N_styleset->children; N_cur; N_cur = N_cur->next){
    sprintf(buf,"margin-top:0pt; color:000000; margin-left:0pt; text-position:normal; widows:2; text-indent:0in; font-variant:normal; margin-right:0pt; lang:nl-NL; line-height:1.0; font-size:%dpt; text-decoration:none; margin-bottom:0pt; bgcolor:transparent; text-align:left; font-stretch:normal;",int(xmlXPathCastStringToNumber(xmlGetProp(N_cur,BAD_CAST "size"))));
    strncat(buf,"font-family:",12);
    strncat(buf,(char *)xmlGetProp(N_cur,BAD_CAST "font"),strlen((char *)xmlGetProp(N_cur,BAD_CAST "font")));
    strncat(buf,";",1);
    strncat(buf,"font-weight:",12);
    strncat(buf,(char *)xmlGetProp(N_cur,BAD_CAST "bold"),strlen((char *)xmlGetProp(N_cur,BAD_CAST "bold")));
    strncat(buf,"font-style:",12);
    strncat(buf,(char *)xmlGetProp(N_cur,BAD_CAST "italic"),strlen((char *)xmlGetProp(N_cur,BAD_CAST "italic")));
    xmlSetProp(N_cur, BAD_CAST "props", BAD_CAST buf);
    N_prop = xmlHasProp(N_cur, BAD_CAST "id");
    if (N_prop != NULL) xmlRemoveProp(N_prop);
    N_prop = xmlHasProp(N_cur, BAD_CAST "size");
    if (N_prop != NULL) xmlRemoveProp(N_prop);
    N_prop = xmlHasProp(N_cur, BAD_CAST "bold");
    if (N_prop != NULL) xmlRemoveProp(N_prop);
    N_prop = xmlHasProp(N_cur, BAD_CAST "italic");
    if (N_prop != NULL) xmlRemoveProp(N_prop);
    N_prop = xmlHasProp(N_cur, BAD_CAST "font");
    if (N_prop != NULL) xmlRemoveProp(N_prop);
  }
  //*************************************************************
  //Change the rest of the document
  //each child of N_content is a page
  N_cur = N_content->children;
  while (N_cur){
    //we creat a section node and attach it to the root, it will com after all
    //the page nodes. Then we transform the page, and finally remove it
    N_next = N_cur->next;
    //fprintf(stderr,"***Transforming page\n");
    N_Block = xmlNewChild(N_root, NULL, BAD_CAST "section", NULL);
    transformPage(N_cur);
    xmlUnlinkNode(N_cur);
    //fprintf(stderr,"***Finished transforming page\n");
    N_cur = N_next;
  }
  cleanUpNode(N_root, false);
}

void ABWOutputDev::transformPage(xmlNodePtr N_parent){
  char buf[60];
  xmlNodePtr N_cur, N_curLine, N_curText, N_curWord, text, space;
  //translate the nodes into abiword nodes
  if (xmlStrcasecmp(N_parent->name,BAD_CAST "page") == 0){
    for (N_cur = N_parent->children; N_cur; N_cur = N_cur->next){
      //fprintf(stderr,"**pass a page child\n");
      transformPage(N_cur);
    }
  }
  if (xmlStrcasecmp(N_parent->name,BAD_CAST "chunk") == 0){
    //fprintf(stderr,"Found a chunk\n");
    //I start a <p> on each chunk and add all word containment
    N_text = xmlNewChild(N_Block, NULL, BAD_CAST "p", NULL);
    if (int(xmlXPathCastStringToNumber(xmlGetProp(N_parent,BAD_CAST "style"))) > 0){
      xmlNewProp(N_text, BAD_CAST "style", xmlGetProp(N_parent,BAD_CAST "style"));
    }
    switch (int(xmlXPathCastStringToNumber(xmlGetProp(N_parent,BAD_CAST "alignment")))){
    case 1: xmlNewProp(N_text, BAD_CAST "props", BAD_CAST "text-align:left");
           break;
    case 2: xmlNewProp(N_text, BAD_CAST "props", BAD_CAST "text-align:right");
           break;
    case 3: xmlNewProp(N_text, BAD_CAST "props", BAD_CAST "text-align:center");
           break;
    case 4: xmlNewProp(N_text, BAD_CAST "props", BAD_CAST "text-align:justify");
           break;
    }
    for (N_curLine = N_parent->children; N_curLine; N_curLine = N_curLine->next){
      //fprintf(stderr,"A line\n");
      for (N_curText = N_curLine->children; N_curText; N_curText = N_curText->next){
        //fprintf(stderr,"a textNode\n");
        for (N_curWord = N_curText->children; N_curWord; N_curWord = N_curWord->next){
          //fprintf(stderr,"a word\n");
          text = N_curWord->children;
          xmlUnlinkNode(text);
          xmlAddChild(N_text,text);
          space = xmlNewText(BAD_CAST " ");
          xmlAddChild(N_text,space);
        }
      }
    }
  }
  if (xmlStrcasecmp(N_parent->name,BAD_CAST "column") == 0){
    //fprintf(stderr,"Found a column\n");
    for (N_cur = N_parent->children; N_cur; N_cur = N_cur->next){
      transformPage(N_cur);
    }
    xmlNewChild(N_text, NULL, BAD_CAST "cbr", NULL);
  }
  if (xmlStrcasecmp(N_parent->name,BAD_CAST "colset") == 0){
    //fprintf(stderr,"Found a colset\n");
    //create new section columns: count childNodes of N_cur
    //recurse through chunks and create textNodes
    N_Block = xmlNewChild(N_root, NULL, BAD_CAST "section", NULL);
    sprintf(buf,"columns:%d",xmlLsCountNode(N_parent));
    xmlNewProp(N_Block, BAD_CAST "props", BAD_CAST buf);
    for (N_cur = N_parent->children; N_cur; N_cur = N_cur->next){
      transformPage(N_cur);
    }
    N_Block = xmlNewChild(N_root, NULL, BAD_CAST "section", NULL);
  }
  //fprintf(stderr,"at the end\n");
}