Google Git
Sign in
skia / third_party / poppler / refs/tags/poppler-0.8.6 / . / poppler / ABWOutputDev.cc
blob: 3c8cf70001213f4036b8ef51a709015a12c00368 [file] [log] [blame]
//========================================================================
//
// 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>
// 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);
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;
bvs = getBiggestSeperator(nodeset, VERTICAL, &X1, &X2);
bhs = getBiggestSeperator(nodeset, HORIZONTAL, &Y1, &Y2);
if (bvs == -1){
if (bhs == -1){//both -1
//FIXME: add assertions that bvs and bhs are >=-1
printf("No seperators\n");
return;
}
else { //only bhs > -1
splitNodes(Y1, HORIZONTAL, nodeset, bhs);
}
}
else {
if (bhs == -1){//only bvs > -1
splitNodes(X1, VERTICAL, nodeset, bvs);
}
else {//both > -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.
splitNodes(X1, VERTICAL, nodeset, bvs);
}
else {
splitNodes(Y1, HORIZONTAL, nodeset, bhs);
}
}
}
recursiveXYC(nodeset->children);
recursiveXYC(nodeset->children->next);
}
void ABWOutputDev::splitNodes(float splitValue, unsigned int direction, xmlNodePtr N_parent, double seperator){
//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", seperator);
xmlNewProp(N_newH, BAD_CAST "diff", BAD_CAST buf);
sprintf(buf, "%f", seperator);
xmlNewProp(N_newL, BAD_CAST "diff", BAD_CAST buf);
N_cur = N_parent->children;
while (N_cur){
N_move = N_cur->next;
xmlUnlinkNode(N_cur);
if (xmlXPathCastStringToNumber(xmlGetProp(N_cur,BAD_CAST propName)) > splitValue){
xmlAddChild(N_newH, N_cur);
}
else {
xmlAddChild(N_newL, N_cur);
}
N_cur = N_move;
}
xmlAddChild(N_parent, N_newL);
xmlAddChild(N_parent, N_newH);
}
float ABWOutputDev::getBiggestSeperator(xmlNodePtr N_set, unsigned int direction, float * C1, float * C2)
{
int i = 0;
int nodeCount = xmlLsCountNode(N_set);
float store;
int min;
float gap, endV;
float * stt;
float * end;
if (nodeCount == 0){
//Add assertion that this shouldn't happen
fprintf(stderr,"No child nodes");
return -1;
}
stt = new float[nodeCount];
end = new float[nodeCount];
//store all variables in two arrays (one for start, one for end coordinates)
if (direction == VERTICAL) {
for (xmlNodePtr N_cur = N_set->children; N_cur != NULL; N_cur = N_cur->next){
stt[i] = xmlXPathCastStringToNumber(xmlGetProp(N_cur,BAD_CAST "X1"));
end[i] = xmlXPathCastStringToNumber(xmlGetProp(N_cur,BAD_CAST "X2"));
i++;
}
}
else {
for (xmlNodePtr N_cur = N_set->children; N_cur != NULL; N_cur = N_cur->next){
stt[i] = xmlXPathCastStringToNumber(xmlGetProp(N_cur,BAD_CAST "Y1"));
end[i] = xmlXPathCastStringToNumber(xmlGetProp(N_cur,BAD_CAST "Y2"));
i++;
}
}
//Sort them
for (i = 0; i < nodeCount - 1; i++){
min = i;
for (int j = i + 1; j < nodeCount; j++)
if (stt[j] < stt[i])
min = j;
store = stt[i];
stt[i] = stt[min];
stt[min] = store;
store = end[i];
end[i] = end[min];
end[min] = store;
}
//find the largest gap
gap = -1;
endV = end[0];
*C1 = 0;
*C2 = 0;
for (int inspect = 1; inspect < nodeCount; inspect++){
//no gap
if (((stt[inspect] - endV) - gap) < 0.5){ //FIXME:This is copied almost directly from the previous function, needs checking out
//partial overlap instead of complete one
if (end[inspect] > endV)
endV = end[inspect];
}
//gap
else{
//gap is larger than any previous gap
if (gap < (stt[inspect] - endV)){
gap = stt[inspect] - endV;
*C1 = endV;
*C2 = stt[inspect];
}
endV = end[inspect];
}
}
delete[] stt;
delete[] end;
return gap;
}
void ABWOutputDev::updateFont(GfxState *state) {
char buf[160];
xmlNodePtr N_cur;
GfxFont *font;
bool found = false;
bool isBold, isItalic, S_isBold, S_isItalic;
isBold = isItalic = S_isBold = S_isItalic = false;
font = state->getFont();
GooString *ftName;
char *fnEnd, *fnName;
int 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() || font->getWeight() >6 || (strstr(font->getOrigName()->getCString(), "Bold")-font->getOrigName()->getCString() == (font->getOrigName()->getLength()-4)));
isItalic = (font->isItalic() || (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)
&&
isItalic == (xmlStrcasecmp(xmlGetProp(N_cur,BAD_CAST "italic"),BAD_CAST "italic") == 0)
&&
xmlStrcasecmp(xmlGetProp(N_cur,BAD_CAST "font"),BAD_CAST fnName) == 0
&&
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) || (fabs(verDist) > (state->getTransformedFontSize()/maxLineSpacingDelta))) {
beginTextBlock(state,x,y);
}
else {
if ((horDist > (state->getTransformedFontSize()*minWordBreakSpace)) || (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){
endTextBlock();
N_Block = xmlNewChild(N_page, NULL, BAD_CAST "Textblock", NULL);
beginWord(state,x,y);
}
void ABWOutputDev::endTextBlock(){
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;
/*
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){
if (N_tempColset != NULL)
N_colset = N_tempColset;
else
fprintf(stderr,"N_templColset should not! be empty (line 823)");//FIXME: add assert
}
}
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 = new int[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)
&&
xmlStrcasecmp(N_parent->name,BAD_CAST "horizontal") == 0
&&
N_cur
&&
N_cur->next
&&
xmlStrcasecmp(N_cur->name,BAD_CAST "horizontal") == 0 && xmlStrcasecmp(N_cur->next->name,BAD_CAST "horizontal") == 0
&&
xmlLsCountNode(N_cur) == 1 && xmlLsCountNode(N_cur->next) == 1
&&
xmlStrcasecmp(N_cur->children->name,BAD_CAST "Textblock") == 0 && 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)
&&
N_cur
&&
N_cur->next
&&
xmlStrcasecmp(N_cur->name,BAD_CAST "vertical") == 0
&&
xmlStrcasecmp(N_cur->next->name,BAD_CAST "vertical") == 0
&&
(N_cur->children)
&&
(N_cur->children->children)
&&
(N_cur->children->children->children)
&&
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 && (xmlStrcasecmp(N_cur->name,BAD_CAST "cbr") != 0) && (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) && ((xmlStrcasecmp(N_parent->name,BAD_CAST "horizontal") == 0) || ((xmlStrcasecmp(N_parent->name,BAD_CAST "vertical") == 0) && (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) && (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 && 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 || 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 || 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 && xmlStrcasecmp(N_parent->children->name,BAD_CAST "line") == 0 && xmlGetProp(N_parent->children,BAD_CAST "alignment") != NULL)
xmlSetProp(N_parent, BAD_CAST "alignment", xmlGetProp(N_parent->children,BAD_CAST "alignment"));
delete styles;
}
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 && 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 && 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 && 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 || 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 && 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) && (leftCnt >= rightCnt) && (leftCnt >= cntrCnt))
xmlNewProp(N_chunk, BAD_CAST "alignment", BAD_CAST "1");
else if ((justCnt >= leftCnt-1) && (justCnt >= rightCnt) && (justCnt >= cntrCnt))
xmlNewProp(N_chunk, BAD_CAST "alignment", BAD_CAST "4");
else if ((cntrCnt >= justCnt-1) && (cntrCnt >= rightCnt) && (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");
}
//Count nodes, copied from debugxml.c from libxml
// libxml copyright file below
/*
Except where otherwise noted in the source code (e.g. the files hash.c,
list.c and the trio files, which are covered by a similar licence but
with different Copyright notices) all the files are:
Copyright (C) 1998-2003 Daniel Veillard. All Rights Reserved.
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is fur-
nished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FIT-
NESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
DANIEL VEILLARD BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CON-
NECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
Except as contained in this notice, the name of Daniel Veillard shall not
be used in advertising or otherwise to promote the sale, use or other deal-
ings in this Software without prior written authorization from him.
*/
int ABWOutputDev::xmlLsCountNode(xmlNodePtr node) {
int ret = 0;
xmlNodePtr list = NULL;
if (node == NULL)
return(0);
switch (node->type) {
case XML_ELEMENT_NODE:
list = node->children;
break;
case XML_DOCUMENT_NODE:
case XML_HTML_DOCUMENT_NODE:
#ifdef LIBXML_DOCB_ENABLED
case XML_DOCB_DOCUMENT_NODE:
#endif
list = ((xmlDocPtr) node)->children;
break;
case XML_ATTRIBUTE_NODE:
list = ((xmlAttrPtr) node)->children;
break;
case XML_TEXT_NODE:
case XML_CDATA_SECTION_NODE:
case XML_PI_NODE:
case XML_COMMENT_NODE:
if (node->content != NULL) {
ret = xmlStrlen(node->content);
}
break;
case XML_ENTITY_REF_NODE:
case XML_DOCUMENT_TYPE_NODE:
case XML_ENTITY_NODE:
case XML_DOCUMENT_FRAG_NODE:
case XML_NOTATION_NODE:
case XML_DTD_NODE:
case XML_ELEMENT_DECL:
case XML_ATTRIBUTE_DECL:
case XML_ENTITY_DECL:
case XML_NAMESPACE_DECL:
case XML_XINCLUDE_START:
case XML_XINCLUDE_END:
ret = 1;
break;
}
for (;list != NULL;ret++)
list = list->next;
return(ret);
}