Attachment 80407 Details for Bug 64815 – [PATCH v3 2/7] Tagged-PDF: Interpret the document structure

[patch] [PATCH v3 2/7] Tagged-PDF: Interpret the document structure

0002-Tagged-PDF-Interpret-the-document-structure.patch (text/plain), 76.05 KB, created by Adrian Perez de Castro on 2013-06-06 14:17:24 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Adrian Perez de Castro

Created: 2013-06-06 14:17:24 UTC

Size: 76.05 KB

patch

obsolete

>From f8dc3e5a704bce46c77c526b2b390eba381cf89d Mon Sep 17 00:00:00 2001
>From: Adrian Perez de Castro <aperez@igalia.com>
>Date: Fri, 26 Apr 2013 01:22:13 +0300
>Subject: [PATCH v3 2/7] Tagged-PDF: Interpret the document structure
>
>Picking from StructTreeRoot, recursively creates a tree of StructTreeNode
>objects representing the structure of the document. The biggest missing
>things are:
>
>- Presenting more information in StructTreeNode, being the most
>	important reading the structure and attribute dictionaries for
>	the elements in the tree.
>- Resolving marked-content identifiers which refer to information
>	stored in page object streams.
>- Creating a synthetic tree when the PDF is not tagged to use as
>	fall-back.
>---
> poppler/Catalog.cc        |   36 +-
> poppler/Catalog.h         |    5 +-
> poppler/MCOutputDev.cc    |  161 ++++++
> poppler/MCOutputDev.h     |  113 ++++
> poppler/Makefile.am       |    6 +
> poppler/PDFDoc.h          |    3 +-
> poppler/StructElement.cc  | 1409 +++++++++++++++++++++++++++++++++++++++++++++
> poppler/StructElement.h   |  286 +++++++++
> poppler/StructTreeRoot.cc |  196 +++++++
> poppler/StructTreeRoot.h  |   76 +++
> 10 files changed, 2273 insertions(+), 18 deletions(-)
> create mode 100644 poppler/MCOutputDev.cc
> create mode 100644 poppler/MCOutputDev.h
> create mode 100644 poppler/StructElement.cc
> create mode 100644 poppler/StructElement.h
> create mode 100644 poppler/StructTreeRoot.cc
> create mode 100644 poppler/StructTreeRoot.h
>
>diff --git a/poppler/Catalog.cc b/poppler/Catalog.cc
>index c365e06..f24f8a3 100644
>--- a/poppler/Catalog.cc
>+++ b/poppler/Catalog.cc
>@@ -55,6 +55,7 @@
> #include "OptionalContent.h"
> #include "ViewerPreferences.h"
> #include "FileSpec.h"
>+#include "StructTreeRoot.h"
> 
> #if MULTITHREADED
> #  define catalogLocker()   MutexLocker locker(&mutex)
>@@ -90,6 +91,7 @@ Catalog::Catalog(PDFDoc *docA) {
>   embeddedFileNameTree = NULL;
>   jsNameTree = NULL;
>   viewerPrefs = NULL;
>+  structTreeRoot = NULL;
> 
>   pagesList = NULL;
>   pagesRefList = NULL;
>@@ -175,8 +177,8 @@ Catalog::~Catalog() {
>   delete form;
>   delete optContent;
>   delete viewerPrefs;
>+  delete structTreeRoot;
>   metadata.free();
>-  structTreeRoot.free();
>   outline.free();
>   acroForm.free();
>   viewerPreferences.free();
>@@ -837,24 +839,28 @@ PageLabelInfo *Catalog::getPageLabelInfo()
>   return pageLabelInfo;
> }
> 
>-Object *Catalog::getStructTreeRoot()
>+StructTreeRoot *Catalog::getStructTreeRoot()
> {
>   catalogLocker();
>-  if (structTreeRoot.isNone())
>-  {
>-     Object catDict;
>+  if (!structTreeRoot) {
>+    Object catalog;
>+    Object root;
> 
>-     xref->getCatalog(&catDict);
>-     if (catDict.isDict()) {
>-       catDict.dictLookup("StructTreeRoot", &structTreeRoot);
>-     } else {
>-       error(errSyntaxError, -1, "Catalog object is wrong type ({0:s})", catDict.getTypeName());
>-       structTreeRoot.initNull();
>-     }
>-     catDict.free();
>+    xref->getCatalog(&catalog);
>+    if (!catalog.isDict()) {
>+      error(errSyntaxError, -1, "Catalog object is wrong type ({0:s})", catalog.getTypeName());
>+      catalog.free();
>+      return NULL;
>+    }
>+
>+    if (catalog.dictLookup("StructTreeRoot", &root)->isDict("StructTreeRoot")) {
>+      structTreeRoot = new StructTreeRoot(doc, root.getDict(), getMarkInfo() & markInfoMarked);
>+    }
>+
>+    root.free();
>+    catalog.free();
>   }
>-
>-  return &structTreeRoot;
>+  return structTreeRoot;
> }
> 
> Guint Catalog::getMarkInfo()
>diff --git a/poppler/Catalog.h b/poppler/Catalog.h
>index 35b4f87..bdba3ce 100644
>--- a/poppler/Catalog.h
>+++ b/poppler/Catalog.h
>@@ -53,6 +53,7 @@ class Form;
> class OCGs;
> class ViewerPreferences;
> class FileSpec;
>+class StructTreeRoot;
> 
> //------------------------------------------------------------------------
> // NameTree
>@@ -123,7 +124,7 @@ public:
>   GooString *readMetadata();
> 
>   // Return the structure tree root object.
>-  Object *getStructTreeRoot();
>+  StructTreeRoot* getStructTreeRoot();
> 
>   // Return values from the MarkInfo dictionary as flags in a bitfield.
>   enum MarkInfoFlags {
>@@ -227,8 +228,8 @@ private:
>   NameTree *jsNameTree;		// Java Script name-tree
>   GooString *baseURI;		// base URI for URI-type links
>   Object metadata;		// metadata stream
>-  Object structTreeRoot;	// structure tree root dictionary
>   int markInfo;                 // Flags from MarkInfo dictionary
>+  StructTreeRoot *structTreeRoot;	// structure tree root
>   Object outline;		// outline dictionary
>   Object acroForm;		// AcroForm dictionary
>   Object viewerPreferences;     // ViewerPreference dictionary
>diff --git a/poppler/MCOutputDev.cc b/poppler/MCOutputDev.cc
>new file mode 100644
>index 0000000..7f9e409
>--- /dev/null
>+++ b/poppler/MCOutputDev.cc
>@@ -0,0 +1,161 @@
>+//========================================================================
>+//
>+// MCOutputDev.cc
>+//
>+// Copyright 2013 Igalia S.L.
>+//
>+//========================================================================
>+
>+#include "MCOutputDev.h"
>+#include "GfxFont.h"
>+#include "GfxState.h"
>+#include "Annot.h"
>+#include "Link.h"
>+#include <vector>
>+
>+struct MCOutputDev::Priv
>+{
>+  MCOpArray mcOps;
>+  bool      capturing;
>+  int       mcid;
>+  GfxFont  *lastFont;
>+  Guint     lastFlags;
>+  double    pageWidth;
>+  double    pageHeight;
>+
>+  Priv(int mcidA):
>+    mcOps(),
>+    capturing(false),
>+    mcid(mcidA),
>+    lastFont(0),
>+    lastFlags(0),
>+    pageWidth(0.0),
>+    pageHeight(0.0)
>+  {}
>+};
>+
>+
>+MCOutputDev::MCOutputDev(int mcid):
>+  p(new Priv(mcid))
>+{
>+}
>+
>+
>+MCOutputDev::~MCOutputDev()
>+{
>+  delete p;
>+}
>+
>+
>+void MCOutputDev::startPage(int pageNum, GfxState *state, XRef *xref)
>+{
>+  if (state) {
>+    p->pageWidth  = state->getPageWidth();
>+    p->pageHeight = state->getPageHeight();
>+  } else {
>+    p->pageWidth = p->pageHeight = 0.0;
>+  }
>+}
>+
>+
>+void MCOutputDev::endPage()
>+{
>+  p->pageWidth = p->pageHeight = 0.0;
>+}
>+
>+
>+void MCOutputDev::beginMarkedContent(char *name, Dict *properties)
>+{
>+  int id = -1;
>+  if (properties && properties->lookupInt("MCID", NULL, &id) && id == p->mcid)
>+    p->capturing = true;
>+}
>+
>+
>+void MCOutputDev::endMarkedContent(GfxState *state)
>+{
>+  p->capturing = false;
>+}
>+
>+
>+void MCOutputDev::drawChar(GfxState *state,
>+                           double xx, double yy,
>+                           double dx, double dy,
>+                           double ox, double oy,
>+                           CharCode c, int nBytes,
>+                           Unicode *u, int uLen)
>+{
>+  if (!p->capturing || !uLen)
>+    return;
>+
>+  double sp, dx2, dy2, w1, h1, x1, y1;
>+
>+  // Subtract char and word spacing from the (dx,dy) values
>+  sp = state->getCharSpace();
>+  if (c == (CharCode) 0x20)
>+    sp += state->getWordSpace();
>+  state->textTransformDelta(sp * state->getHorizScaling(), 0, &dx2, &dy2);
>+  dx -= dx2;
>+  dy -= dy2;
>+  state->transformDelta(dx, dy, &w1, &h1);
>+  state->transform(xx, yy, &x1, &y1);
>+
>+  // Throw away characters that are not inside the page boundaries.
>+  if (x1 + w1 < 0 || x1 > p->pageWidth || y1 + h1 < 0 || y1 > p->pageHeight)
>+    return;
>+
>+  // Make a sanity check on character size. Note: (x != x) <-> isnan(x)
>+  if (x1 != x1 || y1 != y1 || w1 != w1 || h1 != h1)
>+    return;
>+
>+  for (int i = 0; i < uLen; i++) {
>+    // Soft hyphen markers are skipped, as they are invisible unless
>+    // rendering is done to an actual device and the hyphenation hint
>+    // used. MCOutputDev extracts the *visible* text content.
>+    if (u[i] != 0x00AD)
>+      p->mcOps.push_back(MCOp(u[i]));
>+  }
>+}
>+
>+
>+void MCOutputDev::updateFont(GfxState *state)
>+{
>+  GfxFont *font = state->getFont();
>+  if (!font || font == p->lastFont) return;
>+
>+  if (!p->lastFont || (p->lastFont->getFamily() && p->lastFont->getFamily()->cmp(font->getFamily()))) {
>+    if (p->capturing && font->getFamily())
>+      p->mcOps.push_back(MCOp(font->getFamily()->getCString()));
>+    if (p->lastFont) p->lastFont->decRefCnt();
>+    p->lastFont = font;
>+    font->incRefCnt();
>+  }
>+
>+  Guint flags = 0;
>+
>+  if (font->isFixedWidth()) flags |= MCOp::FlagFontItalic;
>+  if (font->isItalic()) flags |= MCOp::FlagFontItalic;
>+  if (font->isBold()) flags |= MCOp::FlagFontBold;
>+  else {
>+    switch (font->getWeight()) {
>+      case GfxFont::W700: // Font weights over 600 are bold
>+      case GfxFont::W800:
>+      case GfxFont::W900:
>+        flags |= MCOp::FlagFontBold;
>+      default:
>+        break;
>+    }
>+  }
>+
>+  if (p->lastFlags != flags) {
>+    if (p->capturing)
>+      p->mcOps.push_back(MCOp(MCOp::Flags, flags));
>+    p->lastFlags = flags;
>+  }
>+}
>+
>+
>+const MCOpArray& MCOutputDev::getMCOps() const
>+{
>+  return p->mcOps;
>+}
>diff --git a/poppler/MCOutputDev.h b/poppler/MCOutputDev.h
>new file mode 100644
>index 0000000..13475af
>--- /dev/null
>+++ b/poppler/MCOutputDev.h
>@@ -0,0 +1,113 @@
>+//========================================================================
>+//
>+// MCOutputDev.h
>+//
>+// Copyright 2013 Igalia S.L.
>+//
>+//========================================================================
>+
>+#ifndef MCDOUTPUTDEV_H
>+#define MCDOUTPUTDEV_H
>+
>+#include "goo/gtypes.h"
>+#include "goo/gmem.h"
>+#include "OutputDev.h"
>+#include <vector>
>+
>+class GfxState;
>+class GooString;
>+class Dict;
>+
>+struct MCOp {
>+  enum Type {
>+    Unichar,
>+    FontName,
>+    Flags,
>+    Color,
>+  };
>+
>+  struct OpColor {
>+    double r, g, b;
>+
>+    Guint rgbPixel() const {
>+      return ((Guint) (r * 255) & 0xFF) << 16
>+           | ((Guint) (g * 255) & 0xFF) << 8
>+           | ((Guint) (b * 255) & 0xFF);
>+    }
>+  };
>+
>+  enum Flags {
>+    FlagFontBold   = (1 << 0),
>+    FlagFontItalic = (1 << 1),
>+    FlagFontFixed  = (1 << 2),
>+  };
>+
>+  Type type;
>+
>+  union {
>+    Unicode unichar;
>+    char   *value;
>+    Guint   flags;
>+    OpColor color;
>+  };
>+
>+  MCOp(const MCOp& op): type(op.type) {
>+    switch (type) {
>+      case Flags: flags = op.flags; break;
>+      case Unichar: unichar = op.unichar; break;
>+      case Color: memcpy(&color, &op.color, sizeof(OpColor)); break;
>+      case FontName: value = strdup(op.value); break;
>+    }
>+  }
>+  ~MCOp() {
>+    switch (type) {
>+      case FontName: gfree(value); break;
>+      default: /* nothing */ break;
>+    }
>+  }
>+  MCOp(): type(FontName), value(NULL) {}
>+  MCOp(Unicode u): type(Unichar), unichar(u) {}
>+  MCOp(const char *s): type(FontName), value(strdup(s)) {}
>+  MCOp(Type t, Guint f = 0): type(t), flags(f) {}
>+};
>+
>+
>+typedef std::vector<MCOp> MCOpArray;
>+
>+
>+class MCOutputDev: public OutputDev {
>+public:
>+  MCOutputDev(int mcid);
>+  virtual ~MCOutputDev();
>+
>+  virtual GBool isOk() { return gTrue; }
>+  virtual GBool upsideDown() { return gTrue; }
>+  virtual GBool useDrawChar() { return gTrue; }
>+  virtual GBool interpretType3Chars() { return gFalse; }
>+  virtual GBool needNonText() { return gFalse; }
>+  virtual GBool needCharCount() { return gFalse; }
>+
>+  virtual void startPage(int pageNum, GfxState *state, XRef *xref);
>+  virtual void endPage();
>+
>+  virtual void restoreState(GfxState *state) { updateFont(state); }
>+  virtual void updateFont(GfxState *state);
>+
>+  virtual void drawChar(GfxState *state,
>+                        double xx, double yy,
>+                        double dx, double dy,
>+                        double ox, double oy,
>+                        CharCode c, int nBytes,
>+                        Unicode *u, int uLen);
>+
>+  virtual void beginMarkedContent(char *name, Dict *properties);
>+  virtual void endMarkedContent(GfxState *state);
>+
>+  const MCOpArray& getMCOps() const;
>+
>+private:
>+  struct Priv;
>+  Priv *p;
>+};
>+
>+#endif /* !MCOUTPUTDEV_H */
>diff --git a/poppler/Makefile.am b/poppler/Makefile.am
>index ac51d05..eaff39d 100644
>--- a/poppler/Makefile.am
>+++ b/poppler/Makefile.am
>@@ -236,6 +236,8 @@ poppler_include_HEADERS =	\
> 	StdinPDFDocBuilder.h	\
> 	Stream-CCITT.h		\
> 	Stream.h		\
>+	StructElement.h		\
>+	StructTreeRoot.h	\
> 	UnicodeMap.h		\
> 	UnicodeMapTables.h	\
> 	UnicodeTypeTable.h	\
>@@ -250,6 +252,7 @@ poppler_include_HEADERS =	\
> 	NameToUnicodeTable.h	\
> 	PSOutputDev.h		\
> 	TextOutputDev.h		\
>+	MCOutputDev.h		\
> 	SecurityHandler.h	\
> 	UTF.h			\
> 	UTF8.h			\
>@@ -315,6 +318,8 @@ libpoppler_la_SOURCES =		\
> 	StdinCachedFile.cc	\
> 	StdinPDFDocBuilder.cc	\
> 	Stream.cc 		\
>+	StructElement.cc	\
>+	StructTreeRoot.cc	\
> 	strtok_r.cpp		\
> 	UnicodeMap.cc		\
> 	UnicodeTypeTable.cc	\
>@@ -323,6 +328,7 @@ libpoppler_la_SOURCES =		\
> 	XRef.cc			\
> 	PSOutputDev.cc		\
> 	TextOutputDev.cc	\
>+	MCOutputDev.cc		\
> 	PageLabelInfo.h		\
> 	PageLabelInfo.cc	\
> 	SecurityHandler.cc	\
>diff --git a/poppler/PDFDoc.h b/poppler/PDFDoc.h
>index da9bf5b..48189bc 100644
>--- a/poppler/PDFDoc.h
>+++ b/poppler/PDFDoc.h
>@@ -60,6 +60,7 @@ class Outline;
> class Linearization;
> class SecurityHandler;
> class Hints;
>+class StructTreeRoot;
> 
> enum PDFWriteMode {
>   writeStandard,
>@@ -139,7 +140,7 @@ public:
>   GooString *readMetadata() { return catalog->readMetadata(); }
> 
>   // Return the structure tree root object.
>-  Object *getStructTreeRoot() { return catalog->getStructTreeRoot(); }
>+  StructTreeRoot *getStructTreeRoot() { return catalog->getStructTreeRoot(); }
> 
>   // Get page.
>   Page *getPage(int page);
>diff --git a/poppler/StructElement.cc b/poppler/StructElement.cc
>new file mode 100644
>index 0000000..9e7fd4d
>--- /dev/null
>+++ b/poppler/StructElement.cc
>@@ -0,0 +1,1409 @@
>+//========================================================================
>+//
>+// StructElement.cc
>+//
>+// This file is licensed under the GPLv2 or later
>+//
>+// Copyright 2013 Igalia S.L.
>+//
>+//========================================================================
>+
>+#ifdef USE_GCC_PRAGMAS
>+#pragma interface
>+#endif
>+
>+#include "StructElement.h"
>+#include "StructTreeRoot.h"
>+#include "TextOutputDev.h"
>+#include "GlobalParams.h"
>+#include "UnicodeMap.h"
>+#include "PDFDoc.h"
>+#include "Dict.h"
>+
>+#include <assert.h>
>+
>+class GfxState;
>+
>+
>+static GBool isPlacementName(Object* value)
>+{
>+  return value->isName("Block")
>+      || value->isName("Inline")
>+      || value->isName("Before")
>+      || value->isName("Start")
>+      || value->isName("End");
>+}
>+
>+static GBool isWritingModeName(Object* value)
>+{
>+  return value->isName("LrTb")
>+      || value->isName("RlTb")
>+      || value->isName("TbRl");
>+}
>+
>+static GBool isBorderStyleName(Object* value)
>+{
>+  return value->isName("None")
>+      || value->isName("Hidden")
>+      || value->isName("Dotted")
>+      || value->isName("Dashed")
>+      || value->isName("Solid")
>+      || value->isName("Double")
>+      || value->isName("Groove")
>+      || value->isName("Ridge")
>+      || value->isName("Inset")
>+      || value->isName("Outset");
>+}
>+
>+static GBool isTextAlignName(Object* value)
>+{
>+  return value->isName("Start")
>+      || value->isName("End")
>+      || value->isName("Center")
>+      || value->isName("Justify");
>+}
>+
>+static GBool isBlockAlignName(Object* value)
>+{
>+  return value->isName("Before")
>+      || value->isName("Middle")
>+      || value->isName("After")
>+      || value->isName("Justify");
>+}
>+
>+static GBool isInlineAlignName(Object* value)
>+{
>+  return value->isName("Start")
>+      || value->isName("End")
>+      || value->isName("Center");
>+}
>+
>+static GBool isNumber(Object* value);
>+
>+static GBool isLineHeight(Object* value)
>+{
>+  return value->isName("Normal")
>+      || value->isName("Auto")
>+      || isNumber(value);
>+}
>+
>+static GBool isTextDecorationName(Object* value)
>+{
>+  return value->isName("None")
>+      || value->isName("Underline")
>+      || value->isName("Overline")
>+      || value->isName("LineThrough");
>+}
>+
>+static GBool isRubyAlignName(Object* value)
>+{
>+  return value->isName("Start")
>+      || value->isName("End")
>+      || value->isName("Center")
>+      || value->isName("Justify")
>+      || value->isName("Distribute");
>+}
>+
>+static GBool isRubyPositionName(Object* value)
>+{
>+  return value->isName("Before")
>+      || value->isName("After")
>+      || value->isName("Warichu")
>+      || value->isName("Inline");
>+}
>+
>+static GBool isGlyphOrientationName(Object* value)
>+{
>+  return value->isName("Auto")
>+      || value->isName("90")
>+      || value->isName("180")
>+      || value->isName("270")
>+      || value->isName("360")
>+      || value->isName("-90")
>+      || value->isName("-180");
>+}
>+
>+static GBool isListNumberingName(Object* value)
>+{
>+  return value->isName("None")
>+      || value->isName("Disc")
>+      || value->isName("Circle")
>+      || value->isName("Square")
>+      || value->isName("Decimal")
>+      || value->isName("UpperRoman")
>+      || value->isName("LowerRoman")
>+      || value->isName("UpperAlpha")
>+      || value->isName("LowerAlpha");
>+}
>+
>+static GBool isFieldRoleName(Object* value)
>+{
>+  return value->isName("rb")
>+      || value->isName("cb")
>+      || value->isName("pb")
>+      || value->isName("tv");
>+}
>+
>+static GBool isFieldCheckedName(Object* value)
>+{
>+  return value->isName("on")
>+      || value->isName("off")
>+      || value->isName("neutral");
>+}
>+
>+static GBool isTableScopeName(Object* value)
>+{
>+  return value->isName("Row")
>+      || value->isName("Column")
>+      || value->isName("Both");
>+}
>+
>+static GBool isRGBColor(Object* value)
>+{
>+  if (!(value->isArray() && value->arrayGetLength() == 3))
>+    return gFalse;
>+
>+  GBool okay = gTrue;
>+  for (int i = 0; i < 3; i++) {
>+    Object obj;
>+    if (!value->arrayGet(i, &obj)->isNum()) {
>+      okay = gFalse;
>+      obj.free();
>+      break;
>+    }
>+    if (obj.getNum() < 0.0 || obj.getNum() > 1.0) {
>+      okay = gFalse;
>+      obj.free();
>+      break;
>+    }
>+    obj.free();
>+  }
>+
>+  return okay;
>+}
>+
>+static GBool isNatural(Object* value)
>+{
>+  return (value->isInt()   && value->getInt()   > 0)
>+      || (value->isInt64() && value->getInt64() > 0);
>+}
>+
>+static GBool isPositive(Object* value)
>+{
>+  return value->isNum() && value->getNum() >= 0.0;
>+}
>+
>+static GBool isNumber(Object* value)
>+{
>+  return value->isNum();
>+}
>+
>+static GBool isNumber_or_AutoName(Object* value)
>+{
>+  return isNumber(value) || value->isName("Auto");
>+}
>+
>+static GBool isTextString(Object* value)
>+{
>+  // XXX: Shall isName() also be checked?
>+  return value->isString();
>+}
>+
>+
>+#define ARRAY_CHECKER(name, checkItem, length, allowSingle, allowNulls) \
>+    static GBool name(Object* value) {                                  \
>+      if (!value->isArray())                                            \
>+        return allowSingle ? checkItem(value) : gFalse;                 \
>+                                                                        \
>+      if (length && value->arrayGetLength() != length)                  \
>+        return gFalse;                                                  \
>+                                                                        \
>+      GBool okay = gTrue;                                               \
>+      for (int i = 0; i < value->arrayGetLength(); i++) {               \
>+        Object obj;                                                     \
>+        value->arrayGet(i, &obj);                                       \
>+        if ((!allowNulls && obj.isNull()) || !checkItem(&obj)) {        \
>+          okay = gFalse;                                                \
>+          obj.free();                                                   \
>+          break;                                                        \
>+        }                                                               \
>+        obj.free();                                                     \
>+      }                                                                 \
>+      return okay;                                                      \
>+    }
>+
>+ARRAY_CHECKER(isRGBColor_or_OptX4, isRGBColor,        4, gTrue,  gTrue );
>+ARRAY_CHECKER(isPositive_or_OptX4, isPositive,        4, gTrue,  gTrue );
>+ARRAY_CHECKER(isPositive_or_X4,    isPositive,        4, gTrue,  gFalse);
>+ARRAY_CHECKER(isBorderStyle,       isBorderStyleName, 4, gTrue,  gTrue );
>+ARRAY_CHECKER(isNumber_X4,         isNumber,          4, gFalse, gFalse);
>+ARRAY_CHECKER(isNumber_or_Xn,      isNumber,          0, gTrue,  gFalse);
>+ARRAY_CHECKER(isTableHeaders,      isTextString,      0, gFalse, gFalse);
>+
>+
>+// Type of functions used to do type-checking on attribute values
>+typedef GBool (*AttributeCheckFunc)(Object*);
>+
>+// Maps attributes to their names and whether the attribute can be inherited.
>+struct AttributeMapEntry {
>+  Attribute::Type    type;
>+  const char*        name;
>+  const Object*      defval;
>+  GBool              inherit;
>+  AttributeCheckFunc check;
>+};
>+
>+struct AttributeDefaults {
>+  Object Inline;
>+  Object LrTb;
>+  Object Normal;
>+  Object Distribute;
>+  Object off;
>+  Object Zero;
>+  Object Auto;
>+  Object Start;
>+  Object None;
>+  Object Before;
>+  Object Nat1;
>+
>+  AttributeDefaults() {
>+    Inline.initName("Inline");
>+    LrTb.initName("LrTb");
>+    Normal.initName("Normal");
>+    Distribute.initName("Distribute");
>+    off.initName("off");
>+
>+    Zero.initReal(0.0);
>+    Auto.initName("Auto");
>+    Start.initName("Start");
>+    None.initName("None");
>+    Before.initName("Before");
>+    Nat1.initInt(1);
>+  }
>+};
>+
>+static const AttributeDefaults attributeDefaults;
>+
>+
>+#define ATTR_LIST_END      { Attribute::Unknown, NULL, NULL, gFalse, NULL }
>+#define ATTR_D(x, i, c, v) { Attribute::x, #x, &attributeDefaults.v, i, c }
>+#define ATTR_N(x, i, c)    { Attribute::x, #x, NULL, i, c }
>+
>+static const AttributeMapEntry attributeMapCommonShared[] =
>+{
>+  ATTR_D(Placement,       gFalse, isPlacementName, Inline),
>+  ATTR_D(WritingMode,     gFalse, isWritingModeName, LrTb),
>+  ATTR_N(BackgroundColor, gFalse, isRGBColor),
>+  ATTR_N(BorderColor,     gTrue,  isRGBColor_or_OptX4),
>+  ATTR_D(BorderStyle,     gFalse, isBorderStyle, None),
>+  ATTR_N(BorderThickness, gTrue,  isPositive_or_OptX4),
>+  ATTR_D(Padding,         gFalse, isPositive_or_X4, Zero),
>+  ATTR_N(Color,           gTrue,  isRGBColor),
>+  ATTR_LIST_END
>+};
>+
>+static const AttributeMapEntry attributeMapCommonBlock[] =
>+{
>+  ATTR_D(SpaceBefore, gFalse, isPositive, Zero),
>+  ATTR_D(SpaceAfter,  gFalse, isPositive, Zero),
>+  ATTR_D(StartIndent, gTrue,  isNumber,   Zero),
>+  ATTR_D(EndIndent,   gTrue,  isNumber,   Zero),
>+  ATTR_D(TextIndent,  gTrue,  isNumber,   Zero),
>+  ATTR_D(TextAlign,   gTrue,  isTextAlignName, Start),
>+  ATTR_N(BBox,        gFalse, isNumber_X4),
>+  ATTR_D(Width,       gFalse, isNumber_or_AutoName, Auto),
>+  ATTR_D(Height,      gFalse, isNumber_or_AutoName, Auto),
>+  ATTR_D(BlockAlign,  gTrue,  isBlockAlignName, Before),
>+  ATTR_D(InlineAlign, gTrue,  isInlineAlignName, Start),
>+  ATTR_LIST_END
>+};
>+
>+static const AttributeMapEntry attributeMapCommonInline[] =
>+{
>+  ATTR_D(BaselineShift,            gFalse, isNumber, Zero),
>+  ATTR_D(LineHeight,               gTrue,  isLineHeight, Normal),
>+  ATTR_N(TextDecorationColor,      gTrue,  isRGBColor),
>+  ATTR_N(TextDecorationThickness,  gTrue,  isPositive),
>+  ATTR_D(TextDecorationType,       gFalse, isTextDecorationName, None),
>+  ATTR_D(GlyphOrientationVertical, gTrue,  isGlyphOrientationName, Auto),
>+  ATTR_LIST_END
>+};
>+
>+static const AttributeMapEntry attributeMapCommonRubyText[] =
>+{
>+  ATTR_D(RubyPosition, gTrue, isRubyPositionName, Before),
>+  ATTR_D(RubyAlign,    gTrue, isRubyAlignName, Distribute),
>+  ATTR_LIST_END
>+};
>+
>+static const AttributeMapEntry attributeMapCommonColumns[] =
>+{
>+  ATTR_D(ColumnCount,  gFalse, isNatural, Nat1),
>+  ATTR_N(ColumnGap,    gFalse, isNumber_or_Xn),
>+  ATTR_N(ColumnWidths, gFalse, isNumber_or_Xn),
>+  ATTR_LIST_END
>+};
>+
>+static const AttributeMapEntry attributeMapCommonList[] = {
>+  ATTR_D(ListNumbering, gFalse, isListNumberingName, None),
>+  ATTR_LIST_END
>+};
>+
>+static const AttributeMapEntry attributeMapCommonPrintField[] =
>+{
>+  ATTR_N(Role,    gFalse, isFieldRoleName),
>+  ATTR_D(checked, gFalse, isFieldCheckedName, off),
>+  ATTR_N(Desc,    gFalse, isTextString),
>+  ATTR_LIST_END
>+};
>+
>+static const AttributeMapEntry attributeMapCommonTable[] =
>+{
>+  ATTR_N(Headers, gFalse, isTableHeaders),
>+  ATTR_N(Scope,   gFalse, isTableScopeName),
>+  ATTR_N(Summary, gFalse, isTextString),
>+  ATTR_LIST_END
>+};
>+
>+static const AttributeMapEntry attributeMapCommonTableCell[] =
>+{
>+  ATTR_D(RowSpan,      gFalse, isNatural, Nat1),
>+  ATTR_D(ColSpan,      gFalse, isNatural, Nat1),
>+  ATTR_D(TBorderStyle, gTrue,  isBorderStyle, None),
>+  ATTR_D(TPadding,     gTrue,  isPositive_or_X4, Zero),
>+  ATTR_LIST_END
>+};
>+
>+
>+static const AttributeMapEntry* attributeMapAll[] = {
>+  attributeMapCommonShared,
>+  attributeMapCommonBlock,
>+  attributeMapCommonInline,
>+  attributeMapCommonRubyText,
>+  attributeMapCommonColumns,
>+  attributeMapCommonList,
>+  attributeMapCommonPrintField,
>+  attributeMapCommonTable,
>+  attributeMapCommonTableCell,
>+  NULL,
>+};
>+
>+static const AttributeMapEntry* attributeMapShared[] = {
>+  attributeMapCommonShared,
>+  NULL,
>+};
>+
>+static const AttributeMapEntry* attributeMapBlock[] = {
>+  attributeMapCommonShared,
>+  attributeMapCommonBlock,
>+  NULL,
>+};
>+
>+static const AttributeMapEntry* attributeMapInline[] = {
>+  attributeMapCommonShared,
>+  attributeMapCommonInline,
>+  NULL,
>+};
>+
>+static const AttributeMapEntry* attributeMapTableCell[] = {
>+  attributeMapCommonShared,
>+  attributeMapCommonBlock,
>+  attributeMapCommonTable,
>+  attributeMapCommonTableCell,
>+  NULL,
>+};
>+
>+static const AttributeMapEntry* attributeMapRubyText[] = {
>+  attributeMapCommonShared,
>+  attributeMapCommonInline,
>+  attributeMapCommonRubyText,
>+  NULL,
>+};
>+
>+static const AttributeMapEntry* attributeMapColumns[] = {
>+  attributeMapCommonShared,
>+  attributeMapCommonInline,
>+  attributeMapCommonColumns,
>+  NULL,
>+};
>+
>+static const AttributeMapEntry* attributeMapList[] = {
>+  attributeMapCommonShared,
>+  attributeMapCommonList,
>+  NULL,
>+};
>+
>+static const AttributeMapEntry* attributeMapPrintField[] = {
>+  attributeMapCommonShared,
>+  attributeMapCommonPrintField,
>+  NULL,
>+};
>+
>+static const AttributeMapEntry* attributeMapTable[] = {
>+  attributeMapCommonShared,
>+  attributeMapCommonBlock,
>+  attributeMapCommonTable,
>+  NULL,
>+};
>+
>+static const AttributeMapEntry* attributeMapIllustration[] = {
>+  // XXX: Illustrations may have some attributes from the "shared", "inline",
>+  //      the "block" sets. This is a loose specification; making it better
>+  //      means duplicating entries from the sets. This seems good enough...
>+  attributeMapCommonShared,
>+  attributeMapCommonBlock,
>+  attributeMapCommonInline,
>+  NULL,
>+};
>+
>+// Table mapping owners of attributes to their names.
>+static const struct OwnerMapEntry {
>+  Attribute::Owner owner;
>+  const char*      name;
>+} ownerMap[] = {
>+  // XXX: Those are sorted in the owner priority resolution order. If the
>+  //      same attribute is defined with two owners, the order in the table
>+  //      can be used to know which one has more priority.
>+  { Attribute::XML_1_00,       "XML-1.00"       },
>+  { Attribute::HTML_3_20,      "HTML-3.20"      },
>+  { Attribute::HTML_4_01,      "HTML-4.01"      },
>+  { Attribute::OEB_1_00,       "OEB-1.00"       },
>+  { Attribute::RTF_1_05,       "RTF-1.05"       },
>+  { Attribute::CSS_1_00,       "CSS-1.00"       },
>+  { Attribute::CSS_2_00,       "CSS-2.00"       },
>+  { Attribute::Layout,         "Layout"         },
>+  { Attribute::PrintField,     "PrintField"     },
>+  { Attribute::Table,          "Table"          },
>+  { Attribute::List,           "List"           },
>+  { Attribute::UserProperties, "UserProperties" },
>+};
>+
>+
>+static GBool ownerHasMorePriority(Attribute::Owner a, Attribute::Owner b)
>+{
>+  unsigned a_index, b_index;
>+
>+  for (unsigned i = a_index = b_index = 0; i < sizeof(ownerMap) / sizeof(ownerMap[0]); i++) {
>+    if (ownerMap[i].owner == a)
>+      a_index = i;
>+    if (ownerMap[i].owner == b)
>+      b_index = i;
>+  }
>+
>+  return a_index < b_index;
>+}
>+
>+
>+// Maps element types to their names and also serves as lookup table
>+// for additional element type attributes.
>+
>+enum ElementType {
>+  elementTypeUndefined,
>+  elementTypeInline,
>+  elementTypeBlock,
>+};
>+
>+static const struct TypeMapEntry {
>+  StructElement::Type       type;
>+  const char*               name;
>+  ElementType               elementType;
>+  const AttributeMapEntry** attributes;
>+} typeMap[] = {
>+  { StructElement::Document,   "Document",   elementTypeInline,    attributeMapShared       },
>+  { StructElement::Part,       "Part",       elementTypeInline,    attributeMapShared       },
>+  { StructElement::Art,        "Art",        elementTypeInline,    attributeMapColumns      },
>+  { StructElement::Sect,       "Sect",       elementTypeInline,    attributeMapColumns      },
>+  { StructElement::Div,        "Div",        elementTypeInline,    attributeMapColumns      },
>+  { StructElement::BlockQuote, "BlockQuote", elementTypeInline,    attributeMapInline       },
>+  { StructElement::Caption,    "Caption",    elementTypeInline,    attributeMapInline       },
>+  { StructElement::NonStruct,  "NonStruct",  elementTypeInline,    attributeMapInline       },
>+  { StructElement::Index,      "Index",      elementTypeInline,    attributeMapInline       },
>+  { StructElement::Private,    "Private",    elementTypeInline,    attributeMapInline       },
>+  { StructElement::Span,       "Span",       elementTypeInline,    attributeMapInline       },
>+  { StructElement::Quote,      "Quote",      elementTypeInline,    attributeMapInline       },
>+  { StructElement::Note,       "Note",       elementTypeInline,    attributeMapInline       },
>+  { StructElement::Reference,  "Reference",  elementTypeInline,    attributeMapInline       },
>+  { StructElement::BibEntry,   "BibEntry",   elementTypeInline,    attributeMapInline       },
>+  { StructElement::Code,       "Code",       elementTypeInline,    attributeMapInline       },
>+  { StructElement::Link,       "Link",       elementTypeInline,    attributeMapInline       },
>+  { StructElement::Annot,      "Annot",      elementTypeInline,    attributeMapInline       },
>+  { StructElement::Ruby,       "Ruby",       elementTypeInline,    attributeMapRubyText     },
>+  { StructElement::RB,         "RB",         elementTypeUndefined, attributeMapRubyText     },
>+  { StructElement::RT,         "RT",         elementTypeUndefined, attributeMapRubyText     },
>+  { StructElement::RP,         "RP",         elementTypeUndefined, attributeMapShared       },
>+  { StructElement::Warichu,    "Warichu",    elementTypeInline,    attributeMapRubyText     },
>+  { StructElement::WT,         "WT",         elementTypeUndefined, attributeMapShared       },
>+  { StructElement::WP,         "WP",         elementTypeUndefined, attributeMapShared       },
>+  { StructElement::P,          "P",          elementTypeBlock,     attributeMapBlock        },
>+  { StructElement::H,          "H",          elementTypeBlock,     attributeMapBlock        },
>+  { StructElement::H1,         "H1",         elementTypeBlock,     attributeMapBlock        },
>+  { StructElement::H2,         "H2",         elementTypeBlock,     attributeMapBlock        },
>+  { StructElement::H3,         "H3",         elementTypeBlock,     attributeMapBlock        },
>+  { StructElement::H4,         "H4",         elementTypeBlock,     attributeMapBlock        },
>+  { StructElement::H5,         "H5",         elementTypeBlock,     attributeMapBlock        },
>+  { StructElement::H6,         "H6",         elementTypeBlock,     attributeMapBlock        },
>+  { StructElement::L,          "L",          elementTypeBlock,     attributeMapList         },
>+  { StructElement::LI,         "LI",         elementTypeBlock,     attributeMapBlock        },
>+  { StructElement::Lbl,        "Lbl",        elementTypeBlock,     attributeMapBlock        },
>+  { StructElement::Table,      "Table",      elementTypeBlock,     attributeMapTable        },
>+  { StructElement::TR,         "TR",         elementTypeUndefined, attributeMapShared       },
>+  { StructElement::TH,         "TH",         elementTypeUndefined, attributeMapTableCell    },
>+  { StructElement::TD,         "TD",         elementTypeUndefined, attributeMapTableCell    },
>+  { StructElement::THead,      "THead",      elementTypeUndefined, attributeMapShared       },
>+  { StructElement::TFoot,      "TFoot",      elementTypeUndefined, attributeMapShared       },
>+  { StructElement::TBody,      "TBody",      elementTypeUndefined, attributeMapShared       },
>+  { StructElement::Figure,     "Figure",     elementTypeUndefined, attributeMapIllustration },
>+  { StructElement::Formula,    "Formula",    elementTypeUndefined, attributeMapIllustration },
>+  { StructElement::Form,       "Form",       elementTypeUndefined, attributeMapIllustration },
>+  { StructElement::TOC,        "TOC",        elementTypeUndefined, attributeMapShared       },
>+  { StructElement::TOCI,       "TOCI",       elementTypeUndefined, attributeMapShared       },
>+};
>+
>+
>+//------------------------------------------------------------------------
>+// Helpers for the attribute and structure type tables
>+//------------------------------------------------------------------------
>+
>+static inline const AttributeMapEntry*
>+getAttributeMapEntry(const AttributeMapEntry** entryList, Attribute::Type type)
>+{
>+  assert(entryList);
>+  while (*entryList) {
>+    const AttributeMapEntry* entry = *entryList;
>+    while (entry->type != Attribute::Unknown) {
>+      assert(entry->name);
>+      if (type == entry->type)
>+        return entry;
>+      entry++;
>+    }
>+    entryList++;
>+  }
>+  return NULL;
>+}
>+
>+static inline const AttributeMapEntry*
>+getAttributeMapEntry(const AttributeMapEntry** entryList, const char* name)
>+{
>+  assert(entryList);
>+  while (*entryList) {
>+    const AttributeMapEntry* entry = *entryList;
>+    while (entry->type != Attribute::Unknown) {
>+      assert(entry->name);
>+      if (strcmp(name, entry->name) == 0)
>+        return entry;
>+      entry++;
>+    }
>+    entryList++;
>+  }
>+  return NULL;
>+}
>+
>+static inline const OwnerMapEntry* getOwnerMapEntry(Attribute::Owner owner)
>+{
>+  for (unsigned i = 0; i < sizeof(ownerMap) / sizeof(ownerMap[0]); i++) {
>+    if (owner == ownerMap[i].owner)
>+      return &ownerMap[i];
>+  }
>+  return NULL;
>+}
>+
>+static inline const OwnerMapEntry* getOwnerMapEntry(const char* name)
>+{
>+  for (unsigned i = 0; i < sizeof(ownerMap) / sizeof(ownerMap[0]); i++) {
>+    if (strcmp(name, ownerMap[i].name) == 0)
>+      return &ownerMap[i];
>+  }
>+  return NULL;
>+}
>+
>+static const char* ownerToName(Attribute::Owner owner)
>+{
>+  const OwnerMapEntry* entry = getOwnerMapEntry(owner);
>+  return entry ? entry->name : "UnknownOwner";
>+}
>+
>+Attribute::Owner nameToOwner(const char* name)
>+{
>+  const OwnerMapEntry* entry = getOwnerMapEntry(name);
>+  return entry ? entry->owner : Attribute::UnknownOwner;
>+}
>+
>+static inline const TypeMapEntry* getTypeMapEntry(StructElement::Type type)
>+{
>+  for (unsigned i = 0; i < sizeof(typeMap) / sizeof(typeMap[0]); i++) {
>+    if (type == typeMap[i].type)
>+      return &typeMap[i];
>+  }
>+  return NULL;
>+}
>+
>+static inline const TypeMapEntry* getTypeMapEntry(const char* name)
>+{
>+  for (unsigned i = 0; i < sizeof(typeMap) / sizeof(typeMap[0]); i++) {
>+    if (strcmp(name, typeMap[i].name) == 0)
>+      return &typeMap[i];
>+  }
>+  return NULL;
>+}
>+
>+static const char* typeToName(StructElement::Type type)
>+{
>+  if (type == StructElement::MCID)
>+    return "MarkedContent";
>+  if (type == StructElement::OBJR)
>+    return "ObjectReference";
>+
>+  const TypeMapEntry* entry = getTypeMapEntry(type);
>+  return entry ? entry->name : "Unknown";
>+}
>+
>+static StructElement::Type nameToType(const char* name)
>+{
>+  const TypeMapEntry* entry = getTypeMapEntry(name);
>+  return entry ? entry->type : StructElement::Unknown;
>+}
>+
>+
>+//------------------------------------------------------------------------
>+// Attribute
>+//------------------------------------------------------------------------
>+
>+Attribute::Attribute(const char* nameA, Object* valueA, GBool copyValue):
>+  type(UserProperty),
>+  owner(UserProperties),
>+  revision(0),
>+  name(nameA),
>+  value(),
>+  hidden(gFalse),
>+  formatted(NULL)
>+{
>+  assert(valueA);
>+
>+  if (copyValue)
>+    valueA->copy(&value);
>+  else
>+    valueA->shallowCopy(&value);
>+}
>+
>+Attribute::Attribute(Type type, Object* valueA, GBool copyValue):
>+  type(type),
>+  owner(UserProperties), // TODO: Determine corresponding owner from Type
>+  revision(0),
>+  name(),
>+  value(),
>+  hidden(gFalse),
>+  formatted(NULL)
>+{
>+  assert(valueA);
>+
>+  if (copyValue)
>+    valueA->copy(&value);
>+  else
>+    valueA->shallowCopy(&value);
>+
>+  if (!typeCheck()) {
>+    type = Unknown;
>+  }
>+}
>+
>+Attribute::~Attribute()
>+{
>+  delete formatted;
>+  value.free();
>+}
>+
>+const char* Attribute::getTypeName() const
>+{
>+  if (type == UserProperty)
>+    return name.getCString();
>+
>+  const AttributeMapEntry* entry = getAttributeMapEntry(attributeMapAll, type);
>+  if (entry)
>+    return entry->name;
>+
>+  return "Unknown";
>+}
>+
>+const char* Attribute::getOwnerName() const
>+{
>+  return ownerToName(owner);
>+}
>+
>+Object* Attribute::getDefaultValue(Attribute::Type type)
>+{
>+  const AttributeMapEntry* entry = getAttributeMapEntry(attributeMapAll, type);
>+  return entry ? const_cast<Object*>(entry->defval) : NULL;
>+}
>+
>+void Attribute::setFormattedValue(const char* formattedA)
>+{
>+  if (formattedA) {
>+    if (formatted)
>+      formatted->Set(formattedA);
>+    else
>+      formatted = new GooString(formattedA);
>+  } else {
>+    delete formatted;
>+  }
>+}
>+
>+GBool Attribute::typeCheck(StructElement* element)
>+{
>+  // If an element is passed, tighther type-checking can be done.
>+  if (element) {
>+    const TypeMapEntry* elementTypeEntry = getTypeMapEntry(element->getType());
>+    if (elementTypeEntry && elementTypeEntry->attributes) {
>+      const AttributeMapEntry* entry = getAttributeMapEntry(elementTypeEntry->attributes, type);
>+      if (entry) {
>+        if (entry->check && !((*entry->check)(&value))) {
>+          return gFalse;
>+        }
>+      } else {
>+        // No entry: the attribute is not valid for the containing element.
>+        return gFalse;
>+      }
>+    }
>+  }
>+
>+  return gTrue;
>+}
>+
>+Attribute::Type Attribute::typeForName(const char* name, StructElement* element)
>+{
>+  const AttributeMapEntry** attributes = attributeMapAll;
>+  if (element) {
>+    const TypeMapEntry* elementTypeEntry = getTypeMapEntry(element->getType());
>+    if (elementTypeEntry && elementTypeEntry->attributes) {
>+      attributes = elementTypeEntry->attributes;
>+    }
>+  }
>+
>+  const AttributeMapEntry* entry = getAttributeMapEntry(attributes, name);
>+  return entry ? entry->type : Unknown;
>+}
>+
>+Attribute* Attribute::parseUserProperty(Dict* property)
>+{
>+  Object obj, value;
>+  const char* name = NULL;
>+
>+  if (property->lookup("N", &obj)->isString())
>+    name = obj.getString()->getCString();
>+  else if (obj.isName())
>+    name = obj.getName();
>+  else {
>+    error(errSyntaxError, -1, "N object is wrong type ({0:s})", obj.getTypeName());
>+    obj.free();
>+    return NULL;
>+  }
>+
>+  if (property->lookup("V", &value)->isNull()) {
>+    error(errSyntaxError, -1, "V object is wrong type ({0:s})", value.getTypeName());
>+    value.free();
>+    obj.free();
>+    return NULL;
>+  }
>+
>+  Attribute *attribute = new Attribute(name, &value, gFalse);
>+  obj.free();
>+
>+  if (property->lookup("F", &obj)->isString()) {
>+    attribute->setFormattedValue(obj.getString()->getCString());
>+  } else if (!obj.isNull()) {
>+    error(errSyntaxWarning, -1, "F object is wrong type ({0:s})", obj.getTypeName());
>+  }
>+  obj.free();
>+
>+  if (property->lookup("H", &obj)->isBool()) {
>+    attribute->setHidden(obj.getBool());
>+  } else if (!obj.isNull()) {
>+    error(errSyntaxWarning, -1, "H object is wrong type ({0:s})", obj.getTypeName());
>+  }
>+  obj.free();
>+
>+  return attribute;
>+}
>+
>+
>+//------------------------------------------------------------------------
>+// StructElement
>+//------------------------------------------------------------------------
>+
>+const Ref StructElement::InvalidRef = { -1, -1 };
>+
>+
>+StructElement::StructData::StructData():
>+  parentRef(),
>+  altText(0),
>+  actualText(0),
>+  id(0),
>+  title(0),
>+  expandedAbbr(0),
>+  language(0),
>+  revision(0),
>+  elements(),
>+  attributes()
>+{
>+}
>+
>+StructElement::StructData::~StructData()
>+{
>+  delete altText;
>+  delete actualText;
>+  delete id;
>+  delete title;
>+  gfree(language);
>+  parentRef.free();
>+  for (std::vector<StructElement*>::iterator i = elements.begin(); i != elements.end(); ++i) delete *i;
>+  for (std::vector<Attribute*>::iterator i = attributes.begin(); i != attributes.end(); ++i) delete *i;
>+}
>+
>+
>+StructElement::StructElement(Dict *element, StructTreeRoot *treeRootA, StructElement *parentA):
>+  type(Unknown),
>+  treeRoot(treeRootA),
>+  parent(parentA),
>+  pageRef(),
>+  s(new StructData())
>+{
>+  assert(treeRoot);
>+  assert(element);
>+  parse(element);
>+}
>+
>+StructElement::StructElement(int mcid, StructTreeRoot *treeRootA, StructElement *parentA):
>+  type(MCID),
>+  treeRoot(treeRootA),
>+  parent(parentA),
>+  pageRef(),
>+  c(new ContentData(mcid))
>+{
>+  assert(treeRoot);
>+  assert(parent);
>+  assert(c->mcid != InvalidMCID);
>+}
>+
>+StructElement::StructElement(const Ref& ref, StructTreeRoot *treeRootA, StructElement *parentA):
>+  type(OBJR),
>+  treeRoot(treeRootA),
>+  parent(parentA),
>+  pageRef(),
>+  c(new ContentData(ref))
>+{
>+  assert(treeRoot);
>+  assert(parent);
>+  assert(c->ref.num >= 0);
>+  assert(c->ref.gen >= 0);
>+}
>+
>+StructElement::~StructElement()
>+{
>+  if (isContent())
>+    delete c;
>+  else
>+    delete s;
>+  pageRef.free();
>+}
>+
>+GBool StructElement::isBlock() const
>+{
>+  const TypeMapEntry* entry = getTypeMapEntry(type);
>+  return entry ? (entry->elementType == elementTypeBlock) : gFalse;
>+}
>+
>+GBool StructElement::isInline() const
>+{
>+  const TypeMapEntry* entry = getTypeMapEntry(type);
>+  return entry ? (entry->elementType == elementTypeInline) : gFalse;
>+}
>+
>+GBool StructElement::hasPageRef() const
>+{
>+  return pageRef.isRef() || (parent && parent->hasPageRef());
>+}
>+
>+Ref StructElement::getPageRef() const
>+{
>+  if (pageRef.isRef())
>+    return pageRef.getRef();
>+
>+  if (parent)
>+    return parent->getPageRef();
>+
>+  static const Ref invalidRef = { -1, -1 };
>+  return invalidRef;
>+}
>+
>+const char* StructElement::getTypeName() const
>+{
>+  return typeToName(type);
>+}
>+
>+const Attribute* StructElement::findAttribute(Attribute::Type attributeType, GBool inherit,
>+                                              Attribute::Owner attributeOwner) const
>+{
>+  if (isContent())
>+    return parent->findAttribute(attributeType, inherit, attributeOwner);
>+
>+  if (attributeType != Attribute::Unknown && attributeType != Attribute::UserProperty) {
>+    const Attribute *result = NULL;
>+
>+    if (attributeOwner == Attribute::UnknownOwner) {
>+      // Search for the attribute, no matter who the owner is
>+      for (unsigned i = 0; i < getNumAttributes(); i++) {
>+        const Attribute *attr = getAttribute(i);
>+        if (attributeType == attr->getType()) {
>+          if (!result || ownerHasMorePriority(attr->getOwner(), result->getOwner()))
>+            result = attr;
>+        }
>+      }
>+    } else {
>+      // Search for the attribute, with a specific owner
>+      for (unsigned i = 0; i < getNumAttributes(); i++) {
>+        const Attribute *attr = getAttribute(i);
>+        if (attributeType == attr->getType() && attributeOwner == attr->getOwner()) {
>+          result = attr;
>+          break;
>+        }
>+      }
>+    }
>+
>+    if (result)
>+      return result;
>+
>+    if (inherit && parent) {
>+      const AttributeMapEntry *entry = getAttributeMapEntry(attributeMapAll, attributeType);
>+      assert(entry);
>+      // TODO: Take into account special inheritance cases, for example:
>+      //       inline elements which have been changed to be block using
>+      //       "/Placement/Block" have slightly different rules.
>+      if (entry->inherit)
>+        return parent->findAttribute(attributeType, inherit, attributeOwner);
>+    }
>+  }
>+  return NULL;
>+}
>+
>+GooString* StructElement::getText(GooString *string, GBool recursive) const
>+{
>+  if (isContent() && !isObjectRef()) {
>+    UnicodeMap *map = globalParams->getTextEncoding();
>+    if (!map) {
>+      GooString mapName("UTF-8");
>+      map = UnicodeMap::parse(&mapName);
>+    }
>+    assert(map);
>+
>+    const MCOpArray& ops(getMCOps());
>+    if (!ops.size())
>+      return NULL;
>+
>+    if (!string)
>+      string = new GooString();
>+
>+    char buf[9];
>+    int n;
>+
>+    for (MCOpArray::const_iterator i = ops.begin(); i != ops.end(); ++i) {
>+      if (i->type == MCOp::Unichar) {
>+        n = map->mapUnicode(i->unichar, buf, sizeof(buf));
>+        string->append(buf, n);
>+      }
>+    }
>+    map->decRefCnt();
>+    return string;
>+  }
>+
>+  if (!recursive)
>+    return NULL;
>+
>+  // Do a depth-first traversal, to get elements in logical order
>+  if (!string)
>+    string = new GooString();
>+
>+  for (unsigned i = 0; i < getNumElements(); i++)
>+    getElement(i)->getText(string, recursive);
>+
>+  return string;
>+}
>+
>+
>+const MCOpArray StructElement::getMCOps() const
>+{
>+  if (!isContent())
>+    return MCOpArray(); // Empty array
>+
>+  MCOutputDev mcdev(getMCID());
>+  int startPage = 0, endPage = 0;
>+
>+  if (hasPageRef()) {
>+    Ref ref = getPageRef();
>+    startPage = endPage = treeRoot->getDoc()->findPage(ref.num, ref.gen);
>+  }
>+
>+  if (!(startPage && endPage)) {
>+    startPage = 1;
>+    endPage = treeRoot->getDoc()->getNumPages();
>+  }
>+
>+  treeRoot->getDoc()->displayPages(&mcdev, startPage, endPage, 72.0, 72.0, 0, gTrue, gFalse, gFalse);
>+  return mcdev.getMCOps();
>+}
>+
>+
>+static StructElement::Type roleMapResolve(Dict *roleMap, const char *name, const char *curName, Object *resolved)
>+{
>+  // Circular reference
>+  if (curName && !strcmp(name, curName))
>+    return StructElement::Unknown;
>+
>+  if (roleMap->lookup(curName ? curName : name, resolved)->isName()) {
>+    StructElement::Type type = nameToType(resolved->getName());
>+    return type == StructElement::Unknown
>+      ? roleMapResolve(roleMap, name, resolved->getName(), resolved)
>+      : type;
>+  }
>+
>+  if (!resolved->isNull())
>+    error(errSyntaxWarning, -1, "RoleMap entry is wrong type ({0:s})", resolved->getTypeName());
>+  return StructElement::Unknown;
>+}
>+
>+
>+void StructElement::parse(Dict* element)
>+{
>+  Object obj;
>+
>+  // Type is optional, but if present must be StructElem
>+  if (!element->lookup("Type", &obj)->isNull() && !obj.isName("StructElem")) {
>+    error(errSyntaxError, -1, "Type of StructElem object is wrong");
>+    obj.free();
>+    return;
>+  }
>+  obj.free();
>+
>+  // Parent object reference (required).
>+  if (!element->lookupNF("P", &s->parentRef)->isRef()) {
>+    error(errSyntaxError, -1, "P object is wrong type ({0:s})", obj.getTypeName());
>+    return;
>+  }
>+
>+  // Check whether the S-type is valid for the top level
>+  // element and create a node of the appropriate type.
>+  if (!element->lookup("S", &obj)->isName()) {
>+    error(errSyntaxError, -1, "S object is wrong type ({0:s})", obj.getTypeName());
>+    obj.free();
>+    return;
>+  }
>+
>+  // Type name may not be standard, resolve through RoleMap first.
>+  if (treeRoot->getRoleMap()) {
>+    Object resolvedName;
>+    type = roleMapResolve(treeRoot->getRoleMap(), obj.getName(), NULL, &resolvedName);
>+  }
>+
>+  // Resolving through RoleMap may leave type as Unknown, e.g. for types
>+  // which are not present in it, yet they are standard element types.
>+  if (type == Unknown)
>+    type = nameToType(obj.getName());
>+
>+  // At this point either the type name must have been resolved.
>+  if (type == Unknown) {
>+    error(errSyntaxError, -1, "StructElem object is wrong type ({0:s})", obj.getName());
>+    obj.free();
>+    return;
>+  }
>+  obj.free();
>+
>+  // Object ID (optional), to be looked at the IDTree in the tree root.
>+  if (element->lookup("ID", &obj)->isString()) {
>+    s->id = new GooString(obj.getString());
>+  } else if (!obj.isNull()) {
>+    error(errSyntaxWarning, -1, "ID object is wrong type ({0:s})", obj.getTypeName());
>+  }
>+  obj.free();
>+
>+  // Page reference (optional) in which at least one of the child items
>+  // is to be rendered in. Note: each element stores only the /Pg value
>+  // contained by it, and StructElement::getPageRef() may look in parent
>+  // elements to find the page where an element belongs.
>+  if (!element->lookupNF("Pg", &pageRef)->isRef() && !pageRef.isNull()) {
>+    error(errSyntaxWarning, -1, "Pg object is wrong type ({0:s})", pageRef.getTypeName());
>+  }
>+
>+  // Revision number (optional).
>+  if (element->lookup("R", &obj)->isInt()) {
>+    s->revision = obj.getInt();
>+  } else if (!obj.isNull()) {
>+    error(errSyntaxWarning, -1, "R object is wrong type ({0:s})", obj.getTypeName());
>+  }
>+  obj.free();
>+
>+  // Element title (optional).
>+  if (element->lookup("T", &obj)->isString()) {
>+    s->title = new GooString(obj.getString());
>+  } else if (!obj.isNull()) {
>+    error(errSyntaxWarning, -1, "T object is wrong type ({0:s})", obj.getTypeName());
>+  }
>+  obj.free();
>+
>+  // Language (optional).
>+  if (element->lookup("Lang", &obj)->isString()) {
>+    s->language = obj.getString()->getCString();
>+    obj.initNull(); // The StructElement takes ownership of the GooString
>+  } else if (!obj.isNull()) {
>+    error(errSyntaxWarning, -1, "Lang object is wrong type ({0:s})", obj.getTypeName());
>+  }
>+  obj.free();
>+
>+  // Alternative text (optional).
>+  if (element->lookup("Alt", &obj)->isString()) {
>+    s->altText = obj.getString();
>+    obj.initNull(); // The StructElement takes ownership of the GooString
>+  } else if (!obj.isNull()) {
>+    error(errSyntaxWarning, -1, "Alt object is wrong type ({0:s})", obj.getTypeName());
>+  }
>+  obj.free();
>+
>+  // Expanded form of an abbreviation (optional).
>+  if (element->lookup("E", &obj)->isString()) {
>+    s->expandedAbbr = obj.getString();
>+    obj.initNull(); // The StructElement takes ownership of the GooString
>+  } else if (!obj.isNull()) {
>+    error(errSyntaxWarning, -1, "E object is wrong type ({0:s})", obj.getTypeName());
>+  }
>+  obj.free();
>+
>+  // Actual text (optional).
>+  if (element->lookup("ActualText", &obj)->isString()) {
>+    s->actualText = obj.getString();
>+    obj.initNull(); // The StructElement takes ownership of the GooString
>+  } else if (!obj.isNull()) {
>+    error(errSyntaxWarning, -1, "ActualText object is wrong type ({0:s})", obj.getTypeName());
>+  }
>+  obj.free();
>+
>+  // Attributes directly attached to the element (optional).
>+  if (element->lookup("A", &obj)->isDict()) {
>+    parseAttributes(obj.getDict());
>+  } else if (obj.isArray()) {
>+    Object iobj;
>+    unsigned attrIndex = getNumAttributes();
>+    for (int i = 0; i < obj.arrayGetLength(); i++) {
>+      if (obj.arrayGet(i, &iobj)->isDict()) {
>+        attrIndex = getNumAttributes();
>+        parseAttributes(obj.getDict());
>+      } else if (iobj.isInt()) {
>+        const int revision = iobj.getInt();
>+        // Set revision numbers for the elements previously created.
>+        for (unsigned j = attrIndex; j < getNumAttributes(); j++)
>+          getAttribute(j)->setRevision(revision);
>+      } else {
>+        error(errSyntaxWarning, -1, "A item is wrong type ({0:s})", iobj.getTypeName());
>+      }
>+      iobj.free();
>+    }
>+  } else if (!obj.isNull()) {
>+    error(errSyntaxWarning, -1, "A is wrong type ({0:s})", obj.getTypeName());
>+  }
>+  obj.free();
>+
>+  // Attributes referenced indirectly through the ClassMap (optional).
>+  if (treeRoot->getClassMap()) {
>+    Object classes;
>+    if (element->lookup("C", &classes)->isName()) {
>+      Object attr;
>+      if (treeRoot->getClassMap()->lookup(classes.getName(), &attr)->isDict()) {
>+        parseAttributes(attr.getDict(), gTrue);
>+      } else if (attr.isArray()) {
>+        for (int i = 0; i < attr.arrayGetLength(); i++) {
>+          Object iobj;
>+          unsigned attrIndex = getNumAttributes();
>+          if (attr.arrayGet(i, &iobj)->isDict()) {
>+            attrIndex = getNumAttributes();
>+            parseAttributes(iobj.getDict(), gTrue);
>+          } else if (iobj.isInt()) {
>+            // Set revision numbers for the elements previously created.
>+            const int revision = iobj.getInt();
>+            for (unsigned j = attrIndex; j < getNumAttributes(); j++)
>+              getAttribute(j)->setRevision(revision);
>+          } else {
>+            error(errSyntaxWarning, -1, "C item is wrong type ({0:s})", iobj.getTypeName());
>+          }
>+        }
>+      } else if (!attr.isNull()) {
>+        error(errSyntaxWarning, -1, "C object is wrong type ({0:s})", classes.getTypeName());
>+      }
>+      classes.free();
>+    }
>+  }
>+
>+  parseChildren(element);
>+}
>+
>+StructElement* StructElement::parseChild(Object *ref, Object* childObj)
>+{
>+  assert(childObj);
>+  StructElement* child = NULL;
>+
>+  if (childObj->isInt()) {
>+    child = new StructElement(childObj->getInt(), treeRoot, this);
>+  } else if (childObj->isDict("MCR")) {
>+    /*
>+     * TODO: The optional Stm/StwOwn attributes are not handled, so all the
>+     *      page will be always scanned when calling StructElement::getText().
>+     */
>+    Object mcidObj;
>+    Object pageRefObj;
>+
>+    if (!childObj->dictLookup("MCID", &mcidObj)->isInt()) {
>+      error(errSyntaxError, -1, "MCID object is wrong type ({0:s})", mcidObj.getTypeName());
>+      mcidObj.free();
>+      return NULL;
>+    }
>+
>+    child = new StructElement(mcidObj.getInt(), treeRoot, this);
>+
>+    if (childObj->dictLookupNF("Pg", &pageRefObj)->isRef()) {
>+      child->pageRef = pageRefObj;
>+    } else {
>+      pageRefObj.free();
>+    }
>+  } else if (childObj->isDict("OBJR")) {
>+    Object refObj;
>+
>+    if (childObj->dictLookupNF("Obj", &refObj)->isRef()) {
>+      Object pageRefObj;
>+
>+      child = new StructElement(refObj.getRef(), treeRoot, this);
>+
>+      if (childObj->dictLookupNF("Pg", &pageRefObj)->isRef()) {
>+        child->pageRef = pageRefObj;
>+      } else {
>+        pageRefObj.free();
>+      }
>+    } else {
>+      error(errSyntaxError, -1, "Obj object is wrong type ({0:s})", refObj.getTypeName());
>+    }
>+    refObj.free();
>+  } else if (childObj->isDict()) {
>+    child = new StructElement(childObj->getDict(), treeRoot, this);
>+  } else {
>+    error(errSyntaxWarning, -1, "K has a child of wrong type ({0:s})", childObj->getTypeName());
>+  }
>+
>+  if (child) {
>+    if (child->isOk()) {
>+      appendElement(child);
>+      if (ref->isRef())
>+        treeRoot->parentTreeAdd(ref->getRef(), child);
>+    } else {
>+      delete child;
>+      child = NULL;
>+    }
>+  }
>+
>+  return child;
>+}
>+
>+void StructElement::parseChildren(Dict* element)
>+{
>+  Object kids;
>+
>+  if (element->lookup("K", &kids)->isArray()) {
>+    for (int i = 0; i < kids.arrayGetLength(); i++) {
>+      Object obj, ref;
>+      parseChild(kids.arrayGetNF(i, &ref), kids.arrayGet(i, &obj));
>+      obj.free();
>+      ref.free();
>+    }
>+  } else if (kids.isDict() || kids.isInt()) {
>+    Object ref;
>+    parseChild(element->lookupNF("K", &ref), &kids);
>+    ref.free();
>+  } else if (!kids.isNull()) {
>+    error(errSyntaxWarning, -1, "K in StructElement is wrong type ({0:s})", kids.getTypeName());
>+  }
>+
>+  kids.free();
>+}
>+
>+void StructElement::parseAttributes(Dict* attributes, GBool keepExisting)
>+{
>+  Object owner;
>+  if (attributes->lookup("O", &owner)->isName("UserProperties")) {
>+    // In this case /P is an array of UserProperty dictionaries
>+    Object userProperties;
>+    if (attributes->lookup("P", &userProperties)->isArray()) {
>+      for (int i = 0; i < userProperties.arrayGetLength(); i++) {
>+        Object property;
>+        if (userProperties.arrayGet(i, &property)->isDict()) {
>+          Attribute* attribute = Attribute::parseUserProperty(property.getDict());
>+          if (attribute && attribute->isOk()) {
>+            appendAttribute(attribute);
>+          } else {
>+            error(errSyntaxWarning, -1, "Item in P is invalid");
>+            delete attribute;
>+          }
>+        } else {
>+          error(errSyntaxWarning, -1, "Item in P is wrong type ({0:s})", property.getTypeName());
>+        }
>+        property.free();
>+      }
>+    } else {
>+      error(errSyntaxWarning, -1, "P is wrong type ({0:s})", userProperties.getTypeName());
>+    }
>+    userProperties.free();
>+  } else if (owner.isName()) {
>+    // In this case /P contains standard attributes.
>+    // Check first if the owner is a valid standard one.
>+    Attribute::Owner ownerValue = nameToOwner(owner.getName());
>+    if (ownerValue != Attribute::UnknownOwner) {
>+      // Iterate over the entries of the "attributes" dictionary.
>+      // The /O entry (owner) is skipped.
>+      for (int i = 0; i < attributes->getLength(); i++) {
>+        const char* key = attributes->getKey(i);
>+        if (strcmp(key, "O") != 0) {
>+          Attribute::Type type = Attribute::typeForName(key, this);
>+
>+          // Check if the attribute is already defined.
>+          if (keepExisting) {
>+            GBool exists = gFalse;
>+            for (unsigned j = 0; j < getNumAttributes(); j++) {
>+              if (getAttribute(j)->getType() == type) {
>+                exists = gTrue;
>+                break;
>+              }
>+            }
>+            if (exists)
>+              continue;
>+          }
>+
>+          if (type != Attribute::Unknown) {
>+            Object value;
>+            GBool typeCheckOk = gTrue;
>+            Attribute* attribute = new Attribute(type, attributes->getVal(i, &value), gFalse);
>+            if (attribute->isOk() && (typeCheckOk = attribute->typeCheck(this))) {
>+              appendAttribute(attribute);
>+            } else {
>+              // It is not needed to free "value", the Attribute instance
>+              // owns the contents, so deleting "attribute" is enough.
>+              if (!typeCheckOk) {
>+                error(errSyntaxWarning, -1, "Attribute {0:s} value is of wrong type ({1:s})",
>+                      attribute->getTypeName(), attribute->getValue()->getTypeName());
>+              }
>+              delete attribute;
>+            }
>+          } else {
>+            error(errSyntaxWarning, -1, "Wrong Attribute '{0:s}' in element {1:s}", key, getTypeName());
>+          }
>+        }
>+      }
>+    } else {
>+      error(errSyntaxWarning, -1, "O object is invalid value ({0:s})", owner.getName());
>+    }
>+  } else if (!owner.isNull()) {
>+    error(errSyntaxWarning, -1, "O is wrong type ({0:s})", owner.getTypeName());
>+  }
>+  owner.free();
>+}
>diff --git a/poppler/StructElement.h b/poppler/StructElement.h
>new file mode 100644
>index 0000000..67553a3
>--- /dev/null
>+++ b/poppler/StructElement.h
>@@ -0,0 +1,286 @@
>+//========================================================================
>+//
>+// StructElement.h
>+//
>+// This file is licensed under the GPLv2 or later
>+//
>+// Copyright 2013 Igalia S.L.
>+//
>+//========================================================================
>+
>+#ifndef STRUCTELEMENT_H
>+#define STRUCTELEMENT_H
>+
>+#ifdef USE_GCC_PRAGMAS
>+#pragma interface
>+#endif
>+
>+#include "goo/gtypes.h"
>+#include "goo/GooString.h"
>+#include "MCOutputDev.h"
>+#include "Object.h"
>+#include <vector>
>+
>+class GooString;
>+class Dict;
>+class StructElement;
>+class StructTreeRoot;
>+class TextWordList;
>+
>+
>+class Attribute {
>+public:
>+  enum Type {
>+    Unknown = 0,        // Uninitialized, parsing error, etc.
>+    UserProperty,       // User defined attribute (i.e. non-standard)
>+
>+    // Common standard attributes
>+    Placement, WritingMode, BackgroundColor, BorderColor, BorderStyle,
>+    BorderThickness, Color, Padding,
>+
>+    // Block element standard attributes
>+    SpaceBefore, SpaceAfter, StartIndent, EndIndent, TextIndent, TextAlign,
>+    BBox, Width, Height, BlockAlign, InlineAlign, TBorderStyle, TPadding,
>+
>+    // Inline element standard attributes
>+    BaselineShift, LineHeight, TextDecorationColor, TextDecorationThickness,
>+    TextDecorationType, RubyAlign, RubyPosition, GlyphOrientationVertical,
>+
>+    // Column-only standard attributes
>+    ColumnCount, ColumnGap, ColumnWidths,
>+
>+    // List-only standard attributes
>+    ListNumbering,
>+
>+    // PrintField-only standard attributes
>+    Role, checked, Desc,
>+
>+    // Table-only standard attributes
>+    RowSpan, ColSpan, Headers, Scope, Summary,
>+  };
>+
>+  enum Owner {
>+    UnknownOwner = 0,
>+    // User-defined attributes
>+    UserProperties,
>+    // Standard attributes
>+    Layout, List, PrintField, Table,
>+    // Translation to other formats
>+    XML_1_00, HTML_3_20, HTML_4_01, OEB_1_00, RTF_1_05, CSS_1_00, CSS_2_00,
>+  };
>+
>+  // Creates a standard attribute. The name is predefined, and the
>+  // value is type-checked to conform to the PDF specification.
>+  Attribute(Type type, Object* value, GBool copyValue = gTrue);
>+
>+  // Creates an UserProperty attribute, with an arbitrary name and value.
>+  Attribute(const char* name, Object* value, GBool copyValue = gTrue);
>+
>+  GBool isOk() const { return type != Unknown; }
>+
>+  // Name, type and value can be set only on construction.
>+  Type getType() const { return type; }
>+  Owner getOwner() const { return owner; }
>+  const char* getTypeName() const;
>+  const char* getOwnerName() const;
>+  Object* getValue() const { return &value; }
>+  static Object* getDefaultValue(Type type);
>+
>+  const char* getName() const { return type == UserProperty ? name.getCString() : getTypeName(); }
>+
>+  // The revision is optional, and defaults to zero.
>+  Guint getRevision() const { return revision; }
>+  void setRevision(Guint revisionA) { revision = revisionA; }
>+
>+  // Hidden elements should not be displayed by the user agent
>+  GBool isHidden() const { return hidden; }
>+  void setHidden(GBool hiddenA) { hidden = hiddenA; }
>+
>+  // The formatted value may be in the PDF, or be left undefined (NULL).
>+  // In the later case the user agent should provide a default representation.
>+  const char* getFormattedValue() const { return formatted ? formatted->getCString() : NULL; }
>+  void setFormattedValue(const char *formattedA);
>+
>+  ~Attribute();
>+
>+private:
>+  Type type;
>+  Owner owner;
>+  Guint revision;
>+  mutable GooString name;
>+  mutable Object value;
>+  GBool hidden;
>+  GooString *formatted;
>+
>+  GBool typeCheck(StructElement* element = NULL);
>+  static Type typeForName(const char* name, StructElement* element = NULL);
>+  static Attribute* parseUserProperty(Dict* property);
>+
>+  friend class StructElement;
>+};
>+
>+
>+class StructElement {
>+public:
>+  enum Type {
>+    Unknown = 0,
>+    MCID,                                   // MCID reference, used internally
>+    OBJR,                                   // Object reference, used internally
>+
>+    Document, Part, Art, Sect, Div,         // Structural elements
>+
>+    Span, Quote, Note, Reference, BibEntry, // Inline elements
>+    Code, Link, Annot,
>+    BlockQuote, Caption, NonStruct,
>+    TOC, TOCI, Index, Private,
>+
>+    P, H, H1, H2, H3, H4, H5, H6,           // Paragraph-like
>+
>+    L, LI, Lbl,                             // List elements
>+
>+    Table, TR, TH, TD, THead, TFoot, TBody, // Table elements
>+
>+    Ruby, RB, RT, RP,                       // Ruby text elements
>+    Warichu, WT, WP,
>+
>+    Figure, Formula, Form,                  // Illustration-like elements
>+  };
>+
>+  static const int InvalidMCID = -1;
>+  static const Ref InvalidRef;
>+
>+  const char* getTypeName() const;
>+  Type getType() const { return type; }
>+  GBool isOk() const { return type != Unknown; }
>+  GBool isBlock() const;
>+  GBool isInline() const;
>+
>+  inline GBool isContent() const { return (type == MCID && c->mcid != InvalidMCID) || isObjectRef(); }
>+  inline GBool isObjectRef() const { return (type == OBJR && c->ref.num != -1 && c->ref.gen != -1); }
>+
>+  int getMCID() const { return type == MCID ? c->mcid : InvalidMCID; }
>+  Ref getObjectRef() const { return type == OBJR ? c->ref : InvalidRef; }
>+  Ref getParentRef() { return isContent() ? parent->getParentRef() : s->parentRef.getRef(); }
>+  GBool hasPageRef() const;
>+  Ref getPageRef() const;
>+  StructTreeRoot* getStructTreeRoot() { return treeRoot; }
>+
>+  // Optional element identifier.
>+  const GooString* getID() const { return isContent() ? NULL : s->id; }
>+  GooString* getID() { return isContent() ? NULL : s->id; }
>+
>+  // Optional ISO language name, e.g. en_US
>+  const char* getLang() const
>+  { return (!isContent() && s->language) ? s->language : (parent ? parent->getLang() : NULL); }
>+
>+  // Optional revision number, defaults to zero.
>+  Guint getRevision() const { return isContent() ? 0 : s->revision; }
>+  void setRevision(Guint revision) { if (isContent()) s->revision = revision; }
>+
>+  // Optional element title, in human-readable form.
>+  const GooString* getTitle() const { return isContent() ? NULL : s->title; }
>+  GooString* getTitle() { return isContent() ? NULL : s->title; }
>+
>+  // Optional element expanded abbreviation text.
>+  const GooString* getExpandedAbbr() const { return isContent() ? NULL : s->expandedAbbr; }
>+  GooString* getExpandedAbbr() { return isContent() ? NULL : s->expandedAbbr; }
>+
>+  unsigned getNumElements() const { return isContent() ? 0 : s->elements.size(); }
>+  const StructElement* getElement(int i) const { return isContent() ? NULL : s->elements.at(i); }
>+  StructElement* getElement(int i) { return isContent() ? NULL : s->elements.at(i); }
>+
>+  void appendElement(StructElement* element)
>+  { if (!isContent() && element && element->isOk()) s->elements.push_back(element); }
>+
>+  unsigned getNumAttributes() const { return isContent() ? 0 : s->attributes.size(); }
>+  const Attribute* getAttribute(int i) const { return isContent() ? NULL : s->attributes.at(i); }
>+  Attribute* getAttribute(int i) { return isContent() ? NULL : s->attributes.at(i); }
>+
>+  void appendAttribute(Attribute* attribute)
>+  { if (!isContent() && attribute) s->attributes.push_back(attribute); }
>+
>+  const Attribute* findAttribute(Attribute::Type attributeType, GBool inherit = gFalse,
>+                                 Attribute::Owner owner = Attribute::UnknownOwner) const;
>+
>+  const GooString* getAltText() const { return isContent() ? NULL : s->altText; }
>+  GooString* getAltText() { return isContent() ? NULL : s->altText; }
>+
>+  const GooString* getActualText() const { return isContent() ? NULL : s->actualText; }
>+  GooString* getActualText() { return isContent() ? NULL : s->actualText; }
>+
>+  // Content text referenced by the element:
>+  //
>+  // - For MCID reference elements, this is just the text of the
>+  //   corresponding marked content object in the page stream, regardless
>+  //   of the setting of the "recursive" flag.
>+  // - For other elements, if the "recursive" flag is set, the text
>+  //   enclosed by *all* the child MCID reference elements of the subtree
>+  //   is returned. The text is assembled by traversing the leaf MCID
>+  //   reference elements in logical order.
>+  // - In any other case, the function returns NULL.
>+  //
>+  // The text will be appended to the passed GooString. If NULL is passed,
>+  // a new string is returned, and the ownership passed to the caller.
>+  //
>+  GooString* getText(GooString *string = NULL, GBool recursive = gTrue) const;
>+
>+  const MCOpArray getMCOps() const;
>+
>+  ~StructElement();
>+
>+private:
>+  typedef std::vector<Attribute*>     AttrPtrArray;
>+  typedef std::vector<StructElement*> ElemPtrArray;
>+
>+  struct StructData {
>+    Object       parentRef;
>+    GooString   *altText;
>+    GooString   *actualText;
>+    GooString   *id;
>+    GooString   *title;
>+    GooString   *expandedAbbr;
>+    char        *language;
>+    Guint        revision;
>+    ElemPtrArray elements;
>+    AttrPtrArray attributes;
>+
>+    StructData();
>+    ~StructData();
>+  };
>+
>+  // Data in content elements (MCID, MCR)
>+  struct ContentData {
>+    union {
>+      int mcid;
>+      Ref ref;
>+    };
>+
>+    ContentData(int mcidA = InvalidMCID): mcid(mcidA) {}
>+    ContentData(const Ref& r) { ref.num = r.num; ref.gen = r.gen; }
>+  };
>+
>+  // Common data
>+  Type type;
>+  StructTreeRoot* treeRoot;
>+  StructElement* parent;
>+  mutable Object pageRef;
>+
>+  union {
>+    StructData  *s;
>+    ContentData *c;
>+  };
>+
>+  StructElement(Dict* elementDict, StructTreeRoot* treeRootA, StructElement* parentA = 0);
>+  StructElement(int mcid, StructTreeRoot* treeRootA, StructElement* parentA);
>+  StructElement(const Ref& ref, StructTreeRoot* treeRootA, StructElement* parentA);
>+
>+  void parse(Dict* elementDict);
>+  StructElement* parseChild(Object *ref, Object* childObj);
>+  void parseChildren(Dict* element);
>+  void parseAttributes(Dict* element, GBool keepExisting = gFalse);
>+
>+  friend class StructTreeRoot;
>+};
>+
>+#endif
>+
>diff --git a/poppler/StructTreeRoot.cc b/poppler/StructTreeRoot.cc
>new file mode 100644
>index 0000000..dda13c2
>--- /dev/null
>+++ b/poppler/StructTreeRoot.cc
>@@ -0,0 +1,196 @@
>+//========================================================================
>+//
>+// StructTreeRoot.cc
>+//
>+// This file is licensed under the GPLv2 or later
>+//
>+// Copyright 2013 Igalia S.L.
>+//
>+//========================================================================
>+
>+#ifdef USE_GCC_PRAGMAS
>+#pragma interface
>+#endif
>+
>+#include "goo/GooString.h"
>+#include "StructTreeRoot.h"
>+#include "StructElement.h"
>+#include "Object.h"
>+#include "Dict.h"
>+
>+#include <assert.h>
>+
>+
>+StructTreeRoot::StructTreeRoot(PDFDoc *docA, Dict* structTreeRootDict, GBool marked):
>+  doc(docA),
>+  roleMap(),
>+  classMap(),
>+  elements()
>+{
>+  assert(doc);
>+  assert(structTreeRootDict);
>+  parse(structTreeRootDict, marked);
>+}
>+
>+StructTreeRoot::~StructTreeRoot()
>+{
>+  for (ElemPtrArray::iterator i = elements.begin(); i != elements.end(); ++i)
>+    delete *i;
>+  classMap.free();
>+  roleMap.free();
>+}
>+
>+void StructTreeRoot::parse(Dict* root, GBool marked)
>+{
>+  // The RoleMap/ClassMap dictionaries are needed by all the parsing
>+  // functions, which will resolve the custom names to canonical
>+  // standard names.
>+  root->lookup("RoleMap", &roleMap);
>+  root->lookup("ClassMap", &classMap);
>+
>+  // ParentTree (optional). If present, it must be a number tree,
>+  // otherwise it is not possible to map stream objects to their
>+  // corresponsing structure element. Here only the references are
>+  // loaded into the array, the pointers to the StructElements will
>+  // be filled-in later when parsing them.
>+  Object obj;
>+  if (root->lookup("ParentTree", &obj)->isDict()) {
>+    Object nums;
>+    if (obj.dictLookup("Nums", &nums)->isArray()) {
>+      if (nums.arrayGetLength() % 2 == 0) {
>+        parentTree.resize(nums.arrayGetLength() / 2);
>+        // Index numbers in even positions, references in odd ones
>+        for (int i = 0; i < nums.arrayGetLength(); i += 2) {
>+          Object index, value;
>+
>+          if (!nums.arrayGet(i, &index)->isInt()) {
>+            error(errSyntaxError, -1, "Nums item at position {0:d} is wrong type ({1:s})", i, index.getTypeName());
>+            index.free();
>+            continue;
>+          }
>+          if (index.getInt() < 0) {
>+            error(errSyntaxError, -1, "Nums item at position {0:d} is invalid value ({1:d})", i, index.getInt());
>+            index.free();
>+            continue;
>+          }
>+
>+          const unsigned idx = index.getInt();
>+          if (nums.arrayGetNF(i + 1, &value)->isRef()) {
>+            parentTree[idx].resize(1);
>+            parentTree[idx][0].ref = value.getRef();
>+          } else if (nums.arrayGet(i + 1, &value)->isArray()) {
>+            parentTree[idx].resize(value.arrayGetLength());
>+            for (int j = 0; j < value.arrayGetLength(); j++) {
>+              Object itemvalue;
>+              if (value.arrayGetNF(j, &itemvalue)->isRef())
>+                parentTree[idx][j].ref = itemvalue.getRef();
>+              else
>+                error(errSyntaxError, -1, "Nums array item at position {0:d}/{1:d} is invalid type ({2:s})", i, j, itemvalue.getTypeName());
>+              itemvalue.free();
>+            }
>+          } else {
>+            error(errSyntaxError, -1, "Nums item at position {0:d} is wrong type ({1:s})", i + 1, value.getTypeName());
>+          }
>+
>+          value.free();
>+          index.free();
>+        }
>+      } else {
>+        error(errSyntaxError, -1, "Nums array length is not a even ({0:i})", nums.arrayGetLength());
>+      }
>+    } else {
>+      error(errSyntaxError, -1, "Nums object is wrong type ({0:s})", nums.getTypeName());
>+    }
>+    nums.free();
>+  } else if (!obj.isNull()) {
>+    error(errSyntaxError, -1, "ParentTree object is wrong type ({0:s})", obj.getTypeName());
>+  }
>+  obj.free();
>+
>+  // Parse the children StructElements
>+  Object kids;
>+  if (root->lookup("K", &kids)->isArray()) {
>+    if (marked && kids.arrayGetLength() > 1) {
>+      error(errSyntaxWarning, -1, "K in StructTreeRoot has more than one children in a tagged PDF");
>+    }
>+    for (int i = 0; i < kids.arrayGetLength(); i++) {
>+      Object obj, ref;
>+      kids.arrayGetNF(i, &ref);
>+      if (kids.arrayGet(i, &obj)->isDict()) {
>+        StructElement* child = new StructElement(obj.getDict(), this);
>+        if (child->isOk()) {
>+          if (marked && !(child->getType() == StructElement::Document ||
>+                          child->getType() == StructElement::Part ||
>+                          child->getType() == StructElement::Art ||
>+                          child->getType() == StructElement::Div)) {
>+            error(errSyntaxWarning, -1, "StructTreeRoot element of tagged PDF is wrong type ({0:s})", child->getTypeName());
>+          }
>+          appendElement(child);
>+          if (ref.isRef()) parentTreeAdd(ref.getRef(), child);
>+        } else {
>+          error(errSyntaxWarning, -1, "StructTreeRoot element could not be parsed");
>+          delete child;
>+        }
>+      } else {
>+        error(errSyntaxWarning, -1, "K has a child of wrong type ({0:s})", obj.getTypeName());
>+      }
>+      obj.free();
>+      ref.free();
>+    }
>+  } else if (kids.isDict()) {
>+    if (marked) {
>+      error(errSyntaxWarning, -1, "K has a child of wrong type for a tagged PDF ({0:s})", kids.getTypeName());
>+    }
>+    StructElement* child = new StructElement(kids.getDict(), this);
>+    if (child->isOk()) {
>+      appendElement(child);
>+      Object ref;
>+      if (root->lookupNF("K", &ref)->isRef())
>+        parentTreeAdd(ref.getRef(), child);
>+      ref.free();
>+    } else {
>+      error(errSyntaxWarning, -1, "StructTreeRoot element could not be parsed");
>+      delete child;
>+    }
>+  } else if (!kids.isNull()) {
>+    error(errSyntaxWarning, -1, "K in StructTreeRoot is wrong type ({0:s})", kids.getTypeName());
>+  }
>+
>+  kids.free();
>+}
>+
>+static const StructElement* findElementAux(GooString* elementId, const StructElement* element)
>+{
>+  if (element->getID()->cmp(elementId) == 0) {
>+    return element;
>+  }
>+  for (unsigned i = 0; i < element->getNumElements(); i++) {
>+    const StructElement* child = findElementAux(elementId, element->getElement(i));
>+    if (child) {
>+      return child;
>+    }
>+  }
>+  return NULL;
>+}
>+
>+const StructElement* StructTreeRoot::findElement(GooString* elementId) const
>+{
>+  assert(elementId);
>+  for (unsigned i = 0; i < getNumElements(); i++) {
>+    const StructElement* element = findElementAux(elementId, getElement(i));
>+    if (element) {
>+      return element;
>+    }
>+  }
>+  return NULL;
>+}
>+
>+void StructTreeRoot::parentTreeAdd(const Ref& objectRef, StructElement *element)
>+{
>+  for (std::vector< std::vector<Parent> >::iterator i = parentTree.begin(); i != parentTree.end(); ++i) {
>+    for (std::vector<Parent>::iterator j = i->begin(); j != i->end(); ++j) {
>+      if (j->ref.num == objectRef.num && j->ref.gen == objectRef.gen)
>+        j->element = element;
>+    }
>+  }
>+}
>diff --git a/poppler/StructTreeRoot.h b/poppler/StructTreeRoot.h
>new file mode 100644
>index 0000000..84369a8
>--- /dev/null
>+++ b/poppler/StructTreeRoot.h
>@@ -0,0 +1,76 @@
>+//========================================================================
>+//
>+// StructTreeRoot.h
>+//
>+// This file is licensed under the GPLv2 or later
>+//
>+// Copyright 2013 Igalia S.L.
>+//
>+//========================================================================
>+
>+#ifndef STRUCTTREEROOT_H
>+#define STRUCTTREEROOT_H
>+
>+#ifdef USE_GCC_PRAGMAS
>+#pragma interface
>+#endif
>+
>+#include "goo/gtypes.h"
>+#include "Object.h"
>+#include "StructElement.h"
>+#include <vector>
>+
>+class Dict;
>+class PDFDoc;
>+
>+
>+class StructTreeRoot
>+{
>+public:
>+  StructTreeRoot(PDFDoc *docA, Dict* rootDict, GBool marked);
>+  ~StructTreeRoot();
>+
>+  PDFDoc* getDoc() { return doc; }
>+  Dict* getRoleMap() { return roleMap.isDict() ? roleMap.getDict() : NULL; }
>+  Dict* getClassMap() { return classMap.isDict() ? classMap.getDict() : NULL; }
>+  unsigned getNumElements() const { return elements.size(); }
>+  const StructElement* getElement(int i) const { return elements.at(i); }
>+  StructElement* getElement(int i) { return elements.at(i); }
>+  void appendElement(StructElement* element)
>+  { if (element && element->isOk()) elements.push_back(element); }
>+
>+  const StructElement* findElement(GooString* elementId) const;
>+  const StructElement* findParentElement(unsigned index) const
>+  { return (index < parentTree.size() && parentTree[index].size() == 1) ? parentTree[index][0].element : NULL; }
>+
>+private:
>+  typedef std::vector<StructElement*> ElemPtrArray;
>+
>+  // Structure for items in /ParentTree, it keeps a mapping of
>+  // object references and pointers to StructElement objects.
>+  struct Parent {
>+    Ref            ref;
>+    StructElement *element;
>+
>+    Parent(): element(NULL) { ref.num = ref.gen = -1; }
>+    Parent(const Parent& p): element(p.element) {
>+      ref.num = p.ref.num;
>+      ref.gen = p.ref.gen;
>+    }
>+    ~Parent() {}
>+  };
>+
>+  PDFDoc *doc;
>+  Object roleMap;
>+  Object classMap;
>+  ElemPtrArray elements;
>+  std::vector< std::vector<Parent> > parentTree;
>+
>+  void parse(Dict* rootDict, GBool marked);
>+  void parentTreeAdd(const Ref& objectRef, StructElement *element);
>+
>+  friend class StructElement;
>+};
>+
>+#endif
>+
>-- 
>1.8.3
>

Actions: View | Splinter Review

Attachments on bug 64815: 79990 | 79991 | 80101 | 80407 | 81008 | 81009 | 81010 | 81011 | 81012 | 82286 | 82287 | 82288 | 82289 | 82290 | 86674 | 86675 | 86676 | 86677 | 86678 | 86730 | 87701 | 89046 | 89047 | 89917 | 90249 | 90311

Use of freedesktop.org services, including Bugzilla, is subject to our Code of Conduct. How we collect and use information is described in our Privacy Policy.