pdf2json 0.1.0

data/pdf2json-0.52-source/xpdf/XPDFCore.h

@@ -0,0 +1,251 @@
+//========================================================================
+//
+// XPDFCore.h
+//
+// Copyright 2002-2003 Glyph & Cog, LLC
+//
+//========================================================================
+
+#ifndef XPDFCORE_H
+#define XPDFCORE_H
+
+#include <aconf.h>
+
+#ifdef USE_GCC_PRAGMAS
+#pragma interface
+#endif
+
+#define Object XtObject
+#include <Xm/XmAll.h>
+#undef Object
+#include "gtypes.h"
+#include "gfile.h" // for time_t
+#include "SplashTypes.h"
+#include "PDFCore.h"
+
+class GString;
+class BaseStream;
+class PDFDoc;
+class LinkAction;
+
+//------------------------------------------------------------------------
+
+#define xMaxRGBCube 6		// max size of RGB color cube
+
+//------------------------------------------------------------------------
+// callbacks
+//------------------------------------------------------------------------
+
+typedef void (*XPDFUpdateCbk)(void *data, GString *fileName,
+			      int pageNum, int numPages, char *linkLabel);
+
+typedef void (*XPDFActionCbk)(void *data, char *action);
+
+typedef void (*XPDFKeyPressCbk)(void *data, KeySym key, Guint modifiers,
+				XEvent *event);
+
+typedef void (*XPDFMouseCbk)(void *data, XEvent *event);
+
+//------------------------------------------------------------------------
+// XPDFCore
+//------------------------------------------------------------------------
+
+class XPDFCore: public PDFCore {
+public:
+
+  // Create viewer core inside <parentWidgetA>.
+  XPDFCore(Widget shellA, Widget parentWidgetA,
+	   SplashColorPtr paperColorA, Gulong paperPixelA,
+	   Gulong mattePixelA, GBool fullScreenA, GBool reverseVideoA,
+	   GBool installCmap, int rgbCubeSizeA);
+
+  ~XPDFCore();
+
+  //----- loadFile / displayPage / displayDest
+
+  // Load a new file.  Returns pdfOk or error code.
+  virtual int loadFile(GString *fileName, GString *ownerPassword = NULL,
+		       GString *userPassword = NULL);
+
+  // Load a new file, via a Stream instead of a file name.  Returns
+  // pdfOk or error code.
+  virtual int loadFile(BaseStream *stream, GString *ownerPassword = NULL,
+		       GString *userPassword = NULL);
+
+  // Load an already-created PDFDoc object.
+  virtual void loadDoc(PDFDoc *docA);
+
+  // Resize the window to fit page <pg> of the current document.
+  void resizeToPage(int pg);
+
+  // Update the display, given the specified parameters.
+  virtual void update(int topPageA, int scrollXA, int scrollYA,
+		      double zoomA, int rotateA,
+		      GBool force, GBool addToHist);
+
+  //----- page/position changes
+
+  virtual GBool gotoNextPage(int inc, GBool top);
+  virtual GBool gotoPrevPage(int dec, GBool top, GBool bottom);
+  virtual GBool goForward();
+  virtual GBool goBackward();
+
+  //----- selection
+
+  void startSelection(int wx, int wy);
+  void endSelection(int wx, int wy);
+  void copySelection();
+  void startPan(int wx, int wy);
+  void endPan(int wx, int wy);
+
+  //----- hyperlinks
+
+  void doAction(LinkAction *action);
+  LinkAction *getLinkAction() { return linkAction; }
+  GString *mungeURL(GString *url);
+
+  //----- find
+
+  virtual GBool find(char *s, GBool caseSensitive,
+		     GBool next, GBool backward, GBool onePageOnly);
+  virtual GBool findU(Unicode *u, int len, GBool caseSensitive,
+		      GBool next, GBool backward, GBool onePageOnly);
+
+  //----- simple modal dialogs
+
+  GBool doQuestionDialog(char *title, GString *msg);
+  void doInfoDialog(char *title, GString *msg);
+  void doErrorDialog(char *title, GString *msg);
+
+  //----- password dialog
+
+  GString *getPassword();
+
+  //----- misc access
+
+  Widget getWidget() { return scrolledWin; }
+  Widget getDrawAreaWidget() { return drawArea; }
+  virtual void setBusyCursor(GBool busy);
+  Cursor getBusyCursor() { return busyCursor; }
+  void takeFocus();
+  void enableHyperlinks(GBool on) { hyperlinksEnabled = on; }
+  GBool getHyperlinksEnabled() { return hyperlinksEnabled; }
+  void enableSelect(GBool on) { selectEnabled = on; }
+  void setUpdateCbk(XPDFUpdateCbk cbk, void *data)
+    { updateCbk = cbk; updateCbkData = data; }
+  void setActionCbk(XPDFActionCbk cbk, void *data)
+    { actionCbk = cbk; actionCbkData = data; }
+  void setKeyPressCbk(XPDFKeyPressCbk cbk, void *data)
+    { keyPressCbk = cbk; keyPressCbkData = data; }
+  void setMouseCbk(XPDFMouseCbk cbk, void *data)
+    { mouseCbk = cbk; mouseCbkData = data; }
+  GBool getFullScreen() { return fullScreen; }
+
+private:
+
+  virtual GBool checkForNewFile();
+
+  //----- hyperlinks
+  void runCommand(GString *cmdFmt, GString *arg);
+
+  //----- selection
+  static Boolean convertSelectionCbk(Widget widget, Atom *selection,
+				     Atom *target, Atom *type,
+				     XtPointer *value, unsigned long *length,
+				     int *format);
+
+  //----- GUI code
+  void setupX(GBool installCmap, int rgbCubeSizeA);
+  void initWindow();
+  static void hScrollChangeCbk(Widget widget, XtPointer ptr,
+			       XtPointer callData);
+  static void hScrollDragCbk(Widget widget, XtPointer ptr,
+			     XtPointer callData);
+  static void vScrollChangeCbk(Widget widget, XtPointer ptr,
+			       XtPointer callData);
+  static void vScrollDragCbk(Widget widget, XtPointer ptr,
+			     XtPointer callData);
+  static void resizeCbk(Widget widget, XtPointer ptr, XtPointer callData);
+  static void redrawCbk(Widget widget, XtPointer ptr, XtPointer callData);
+  static void inputCbk(Widget widget, XtPointer ptr, XtPointer callData);
+  virtual PDFCoreTile *newTile(int xDestA, int yDestA);
+  virtual void updateTileData(PDFCoreTile *tileA, int xSrc, int ySrc,
+			      int width, int height, GBool composited);
+  virtual void redrawRect(PDFCoreTile *tileA, int xSrc, int ySrc,
+			  int xDest, int yDest, int width, int height,
+			  GBool composited);
+  virtual void updateScrollbars();
+  void setCursor(Cursor cursor);
+  GBool doDialog(int type, GBool hasCancel,
+		 char *title, GString *msg);
+  static void dialogOkCbk(Widget widget, XtPointer ptr,
+			  XtPointer callData);
+  static void dialogCancelCbk(Widget widget, XtPointer ptr,
+			      XtPointer callData);
+  void initPasswordDialog();
+  static void passwordTextVerifyCbk(Widget widget, XtPointer ptr,
+				    XtPointer callData);
+  static void passwordOkCbk(Widget widget, XtPointer ptr,
+			    XtPointer callData);
+  static void passwordCancelCbk(Widget widget, XtPointer ptr,
+				XtPointer callData);
+
+  Gulong paperPixel;
+  Gulong mattePixel;
+  //~unimp: move fullScreen into PDFCore?
+  GBool fullScreen;
+
+  Display *display;
+  int screenNum;
+  Visual *visual;
+  Colormap colormap;
+  Guint depth;                  // visual depth
+  GBool trueColor;              // set if using a TrueColor visual
+  int rDiv, gDiv, bDiv;         // RGB right shifts (for TrueColor)
+  int rShift, gShift, bShift;   // RGB left shifts (for TrueColor)
+  int rgbCubeSize;              // size of color cube (for non-TrueColor)
+  Gulong                        // color cube (for non-TrueColor)
+    colors[xMaxRGBCube * xMaxRGBCube * xMaxRGBCube];
+
+  Widget shell;			// top-level shell containing the widget
+  Widget parentWidget;		// parent widget (not created by XPDFCore)
+  Widget scrolledWin;
+  Widget hScrollBar;
+  Widget vScrollBar;
+  Widget drawAreaFrame;
+  Widget drawArea;
+  Cursor busyCursor, linkCursor, selectCursor;
+  Cursor currentCursor;
+  GC drawAreaGC;		// GC for blitting into drawArea
+
+  static GString *currentSelection;  // selected text
+  static XPDFCore *currentSelectionOwner;
+  static Atom targetsAtom;
+
+  GBool panning;
+  int panMX, panMY;
+
+  time_t modTime;		// last modification time of PDF file
+
+  LinkAction *linkAction;	// mouse cursor is over this link
+
+  XPDFUpdateCbk updateCbk;
+  void *updateCbkData;
+  XPDFActionCbk actionCbk;
+  void *actionCbkData;
+  XPDFKeyPressCbk keyPressCbk;
+  void *keyPressCbkData;
+  XPDFMouseCbk mouseCbk;
+  void *mouseCbkData;
+
+  GBool hyperlinksEnabled;
+  GBool selectEnabled;
+
+  int dialogDone;
+
+  Widget passwordDialog;
+  Widget passwordText;
+  GString *password;
+};
+
+#endif

data/pdf2json-0.52-source/xpdf/XPDFTree.cc

@@ -0,0 +1,931 @@
+//========================================================================
+//
+// XPDFTree.cc
+//
+// Copyright 2002-2003 Glyph & Cog, LLC
+//
+//========================================================================
+
+#include <stdlib.h>
+#include "gmem.h"
+#include "XPDFTreeP.h"
+
+//------------------------------------------------------------------------
+
+#define xpdfTreeIndent 16
+
+//------------------------------------------------------------------------
+
+struct _XPDFTreeEntry {
+  Widget widget;
+  XPDFTreeEntry *children;
+  XPDFTreeEntry *next;
+};
+
+//------------------------------------------------------------------------
+
+static void classPartInitialize(WidgetClass widgetClass);
+static void initialize(Widget requestWidget, Widget newWidget,
+		       ArgList args, Cardinal *numArgs);
+static void destroy(Widget widget);
+static void destroySubtree(XPDFTreeEntry *e);
+static void resize(Widget widget);
+static void redisplay(Widget widget, XEvent *event, Region region);
+static void redisplaySubtree(XPDFTreeWidget w, XPDFTreeEntry *e,
+			     XEvent *event, Region region);
+static void drawExpandedIcon(XPDFTreeWidget w, Position x, Position y);
+static void drawCollapsedIcon(XPDFTreeWidget w, Position x, Position y);
+static Boolean setValues(Widget oldWidget, Widget requestWidget,
+			 Widget newWidget, ArgList args, Cardinal *numArgs);
+static void setValuesAlmost(Widget oldWidget, Widget newWidget,
+			    XtWidgetGeometry *request,
+			    XtWidgetGeometry *reply);
+static XtGeometryResult queryGeometry(Widget widget,
+				      XtWidgetGeometry *request,
+				      XtWidgetGeometry *reply);
+static XtGeometryResult geometryManager(Widget widget,
+					XtWidgetGeometry *request,
+					XtWidgetGeometry *reply);
+static void changeManaged(Widget widget);
+static void initConstraint(Widget requestWidget, Widget newWidget,
+			   ArgList args, Cardinal *numArgs);
+static void destroyConstraint(Widget widget);
+static void deleteSubtree(Widget widget);
+static Boolean constraintSetValues(Widget oldWidget, Widget requestWidget,
+				   Widget newWidget,
+				   ArgList args, Cardinal *numArgs);
+static void insertChildOnList(XPDFTreeEntry *e, XPDFTreeEntry **listHead);
+static void deleteChildFromList(XPDFTreeEntry *e, XPDFTreeEntry **listHead);
+static void createGC(Widget widget);
+static void destroyGC(Widget widget);
+static void layout(Widget widget, Widget instigator);
+static int layoutSubtree(XPDFTreeWidget w, Widget instigator,
+			 XPDFTreeEntry *e, Position x, Position y,
+			 Boolean visible);
+static void calcSize(Widget widget, Widget instigator,
+		     Dimension *totalWidth,
+		     Dimension *totalHeight);
+static void calcSubtreeSize(XPDFTreeWidget w, Widget instigator,
+			    XPDFTreeEntry *e,
+			    Dimension *width, Dimension *height);
+static Boolean needRelayout(Widget oldWidget, Widget newWidget);
+static void click(Widget widget, XEvent *event,
+		  String *params, Cardinal *numParams);
+static Boolean findPosition(XPDFTreeWidget w, int x, int y,
+			    XPDFTreeEntry **e, Boolean *onExpandIcon);
+static Boolean findPositionInSubtree(XPDFTreeWidget w, int x, int y,
+				     XPDFTreeEntry **e,
+				     Boolean *onExpandIcon);
+
+//------------------------------------------------------------------------
+
+static XtResource resources[] = {
+  { XmNmarginWidth, XmCMarginWidth, XmRHorizontalDimension,
+    sizeof(Dimension), XtOffsetOf(XPDFTreeRec, tree.marginWidth),
+    XmRImmediate, (XtPointer)0 },
+  { XmNmarginHeight, XmCMarginHeight, XmRVerticalDimension,
+    sizeof(Dimension), XtOffsetOf(XPDFTreeRec, tree.marginHeight),
+    XmRImmediate, (XtPointer)0 },
+  { XPDFNselectionCallback, XmCCallback, XmRCallback,
+    sizeof(XtCallbackList), XtOffsetOf(XPDFTreeRec, tree.selectCallback),
+    XmRImmediate, (XtPointer)NULL }
+};
+
+static XmSyntheticResource synResources[] = {
+  { XmNmarginWidth, sizeof(Dimension),
+    XtOffsetOf(XPDFTreeRec, tree.marginWidth),
+#if XmVERSION > 1
+    XmeFromHorizontalPixels, XmeToHorizontalPixels
+#else
+    _XmFromHorizontalPixels, _XmToHorizontalPixels
+#endif
+  },
+  { XmNmarginHeight, sizeof(Dimension),
+    XtOffsetOf(XPDFTreeRec, tree.marginHeight),
+#if XmVERSION > 1
+    XmeFromVerticalPixels, XmeToVerticalPixels
+#else
+    _XmFromVerticalPixels, _XmToVerticalPixels
+#endif
+  }
+};
+
+static XtResource constraints[] = {
+  { XPDFNentryParent, XPDFCentryParent, XmRWidget,
+    sizeof(Widget), XtOffsetOf(XPDFTreeConstraintRec, tree.entryParent),
+    XmRImmediate, (XtPointer)NULL },
+  { XPDFNentryExpanded, XPDFCentryExpanded, XmRBoolean,
+    sizeof(Boolean), XtOffsetOf(XPDFTreeConstraintRec, tree.entryExpanded),
+    XmRImmediate, (XtPointer)False },
+  { XPDFNentryPosition, XPDFCentryPosition, XmRInt,
+    sizeof(int), XtOffsetOf(XPDFTreeConstraintRec, tree.entryPosition),
+    XmRImmediate, (XtPointer)0 }
+};
+
+static char defaultTranslations[] =
+  "<Btn1Down>: XPDFTreeClick()";
+
+static XtActionsRec actions[] = {
+  { "XPDFTreeClick", click }
+};
+
+externaldef(xpdftreeclassrec) XPDFTreeClassRec xpdfTreeClassRec = {
+  { // Core
+    (WidgetClass)&xmManagerClassRec,		// superclass
+    "XPDFTree",					// class_name
+    sizeof(XPDFTreeRec),			// widget_size
+    NULL,					// class_initialize
+    &classPartInitialize,			// class_part_initialize
+    FALSE,					// class_inited
+    &initialize,				// initialize
+    NULL,					// initialize_hook
+    XtInheritRealize,				// realize
+    actions,					// actions
+    XtNumber(actions),				// num_actions
+    resources,					// resources
+    XtNumber(resources),			// num_resources
+    NULLQUARK,					// xrm_class
+    TRUE,					// compress_motion
+    XtExposeCompressMaximal,			// compress_exposure
+    TRUE,					// compress_enterleave
+    FALSE,					// visible_interest
+    &destroy,					// destroy
+    &resize,					// resize
+    &redisplay,					// expose
+    &setValues,					// set_values
+    NULL,					// set_values_hook
+    &setValuesAlmost,				// set_values_almost
+    NULL,					// get_values_hook
+    NULL,					// accept_focus
+    XtVersion,					// version
+    NULL,					// callback_private
+    defaultTranslations,			// tm_table
+    &queryGeometry,				// query_geometry
+    NULL,					// display_accelerator
+    NULL					// extension
+  },
+  { // Composite
+    &geometryManager,				// geometry_manager
+    &changeManaged,				// change_managed
+    XtInheritInsertChild,			// insert_child
+    XtInheritDeleteChild,			// delete_child
+    NULL					// extension
+  },
+  { // Constraint
+    constraints,				// constraint_resources
+    XtNumber(constraints),			// constraint_num_resources
+    sizeof(XPDFTreeConstraintRec),		// constraint_size
+    &initConstraint,				// constraint_initialize
+    &destroyConstraint,				// constraint_destroy
+    &constraintSetValues,			// constraint_set_values
+    NULL					// extension
+  },
+  { // XmManager
+    XtInheritTranslations,			// translations
+#if XmVERSION > 1
+    synResources,				// syn_resources
+    XtNumber(synResources),			// num_syn_resources
+#else
+    NULL,					// syn_resources
+    0,						// num_syn_resources
+#endif
+    NULL,					// syn_constraint_resources
+    0,						// num_syn_constraint_res's
+    XmInheritParentProcess,			// parent_process
+    NULL					// extension
+  },
+  { // XPDFTree
+    &createGC,					// createGC
+    &destroyGC,					// destroyGC
+    &layout,					// layout
+    &calcSize,					// calcSize
+    &needRelayout,				// needRelayout
+    NULL					// extension
+  }
+};
+
+externaldef(xpdftreewidgetclass) WidgetClass xpdfTreeWidgetClass =
+  (WidgetClass)&xpdfTreeClassRec;
+
+//------------------------------------------------------------------------
+
+static void classPartInitialize(WidgetClass widgetCls) {
+  XPDFTreeWidgetClass wc = (XPDFTreeWidgetClass)widgetCls;
+  XPDFTreeWidgetClass sc = (XPDFTreeWidgetClass)wc->coreClass.superclass;
+
+  // method inheritance
+  if (wc->treeClass.createGC == XPDFInheritCreateGC) {
+    wc->treeClass.createGC = sc->treeClass.createGC;
+  }
+  if (wc->treeClass.destroyGC == XPDFInheritDestroyGC) {
+    wc->treeClass.destroyGC = sc->treeClass.destroyGC;
+  }
+  if (wc->treeClass.layout == XPDFInheritLayout) {
+    wc->treeClass.layout = sc->treeClass.layout;
+  }
+  if (wc->treeClass.calcSize == XPDFInheritCalcSize) {
+    wc->treeClass.calcSize = sc->treeClass.calcSize;
+  }
+  if (wc->treeClass.needRelayout == XPDFInheritNeedRelayout) {
+    wc->treeClass.needRelayout = sc->treeClass.needRelayout;
+  }
+}
+
+static void initialize(Widget requestWidget, Widget newWidget,
+		       ArgList args, Cardinal *numArgs) {
+  XPDFTreeWidget nw = (XPDFTreeWidget)newWidget;
+  XPDFTreeWidgetClass cls = (XPDFTreeWidgetClass)XtClass(newWidget);
+
+  nw->tree.root = NULL;
+  nw->tree.redrawY = -1;
+  if (cls->treeClass.createGC) {
+    (*cls->treeClass.createGC)(newWidget);
+  } else {
+    createGC(newWidget);
+  }
+}
+
+static void destroy(Widget widget) {
+  XPDFTreeWidget w = (XPDFTreeWidget)widget;
+  XPDFTreeWidgetClass cls = (XPDFTreeWidgetClass)XtClass(widget);
+
+  if (w->tree.root) {
+    destroySubtree(w->tree.root);
+    w->tree.root = NULL;
+  }
+  if (cls->treeClass.destroyGC) {
+    (*cls->treeClass.destroyGC)(widget);
+  } else {
+    destroyGC(widget);
+  }
+}
+
+static void destroySubtree(XPDFTreeEntry *e) {
+  if (e->children) {
+    destroySubtree(e->children);
+  }
+  if (e->next) {
+    destroySubtree(e->next);
+  }
+}
+
+static void resize(Widget widget) {
+  XPDFTreeWidgetClass cls = (XPDFTreeWidgetClass)XtClass(widget);
+
+  if (cls->treeClass.layout) {
+    (*cls->treeClass.layout)(widget, NULL);
+  } else {
+    layout(widget, NULL);
+  }
+}
+
+static void redisplay(Widget widget, XEvent *event, Region region) {
+  XPDFTreeWidget w = (XPDFTreeWidget)widget;
+  XPDFTreeEntry *e;
+
+  if (w->tree.redrawY >= 0) {
+    XClearArea(XtDisplay((Widget)w), XtWindow((Widget)w),
+	       0, w->tree.redrawY, w->core.width, w->core.height, False);
+    w->tree.redrawY = -1;
+  }
+  for (e = w->tree.root; e; e = e->next) {
+    redisplaySubtree(w, e, event, region);
+  }
+}
+
+static void redisplaySubtree(XPDFTreeWidget w, XPDFTreeEntry *e,
+			     XEvent *event, Region region) {
+  XPDFTreeConstraint c;
+  Position x, y, y2;
+  XPDFTreeEntry *child;
+
+  (*XtClass(e->widget)->core_class.expose)(e->widget, event, region);
+  c = XPDFTreeCPart(e->widget);
+  x = e->widget->core.x;
+  y = e->widget->core.y + e->widget->core.height / 2;
+  if (e->children) {
+    if (c->entryExpanded) {
+      drawExpandedIcon(w, x - 8, y);
+      y2 = y; // make gcc happy
+      for (child = e->children; child; child = child->next) {
+	y2 = child->widget->core.y + child->widget->core.height / 2;
+	XDrawLine(XtDisplay((Widget)w), XtWindow((Widget)w), w->tree.dottedGC,
+		  x - 8, y2, x + 6, y2);
+	redisplaySubtree(w, child, event, region);
+      }
+      XDrawLine(XtDisplay((Widget)w), XtWindow((Widget)w), w->tree.dottedGC,
+		x - 8, y + 2, x - 8, y2);
+    } else {
+      drawCollapsedIcon(w, x - 8, y);
+    }
+  }
+}
+
+static void drawExpandedIcon(XPDFTreeWidget w, Position x, Position y) {
+  XPoint pts[4];
+
+  pts[0].x = x - 4;    pts[0].y = y - 2;
+  pts[1].x = x + 4;    pts[1].y = y - 2;
+  pts[2].x = x;        pts[2].y = y + 2;
+  pts[3].x = x - 4;    pts[3].y = y - 2;
+  XDrawLines(XtDisplay((Widget)w), XtWindow((Widget)w), w->tree.plainGC,
+	     pts, 4, CoordModeOrigin);
+}
+
+static void drawCollapsedIcon(XPDFTreeWidget w, Position x, Position y) {
+  XPoint pts[4];
+
+  pts[0].x = x - 2;    pts[0].y = y - 4;
+  pts[1].x = x - 2;    pts[1].y = y + 4;
+  pts[2].x = x + 2;    pts[2].y = y;
+  pts[3].x = x - 2;    pts[3].y = y - 4;
+  XDrawLines(XtDisplay((Widget)w), XtWindow((Widget)w), w->tree.plainGC,
+	     pts, 4, CoordModeOrigin);
+}
+
+static Boolean setValues(Widget oldWidget, Widget requestWidget,
+			 Widget newWidget, ArgList args, Cardinal *numArgs) {
+  XPDFTreeWidget ow = (XPDFTreeWidget)oldWidget;
+  XPDFTreeWidget nw = (XPDFTreeWidget)newWidget;
+  XPDFTreeWidgetClass cls = (XPDFTreeWidgetClass)XtClass(nw);
+  Boolean relayout, redisp;
+
+  // check to see if layout-affecting resources have changed
+  if (cls->treeClass.needRelayout) {
+    relayout = (*cls->treeClass.needRelayout)((Widget)ow, (Widget)nw);
+  } else {
+    relayout = needRelayout((Widget)ow, (Widget)nw);
+  }
+  redisp = False;
+  if (relayout) {
+
+    // calculate a new ideal size (reset the widget size first so
+    // calcSize will compute a new one)
+    if (nw->core.width == ow->core.width) {
+      nw->core.width = 0;
+    }
+    if (nw->core.height == ow->core.height) {
+      nw->core.height = 0;
+    }
+    if (cls->treeClass.calcSize) {
+      (*cls->treeClass.calcSize)((Widget)nw, NULL,
+				 &nw->core.width, &nw->core.height);
+    } else {
+      calcSize((Widget)nw, NULL, &nw->core.width, &nw->core.height);
+    }
+
+    // if resources have changed but size hasn't, layout manually
+    // (because Xt just looks at the size)
+    if (nw->core.width == ow->core.width &&
+	nw->core.height == ow->core.height) {
+      if (cls->treeClass.layout) {
+	(*cls->treeClass.layout)((Widget)nw, NULL);
+      } else {
+	layout((Widget)nw, NULL);
+      }
+      redisp = True;
+    }
+  }
+
+  return redisp;
+}
+
+static void setValuesAlmost(Widget oldWidget, Widget newWidget,
+			    XtWidgetGeometry *request,
+			    XtWidgetGeometry *reply) {
+  XPDFTreeWidgetClass cls = (XPDFTreeWidgetClass)XtClass(newWidget);
+
+  // our parent rejected a geometry request, so accept the compromise
+  // and relayout
+  if (!reply->request_mode) {
+    if (cls->treeClass.layout) {
+      (*cls->treeClass.layout)(newWidget, NULL);
+    } else {
+      layout(newWidget, NULL);
+    }
+  }
+  *request = *reply;
+}
+
+static XtGeometryResult queryGeometry(Widget widget,
+				      XtWidgetGeometry *request,
+				      XtWidgetGeometry *reply) {
+  XPDFTreeWidgetClass cls = (XPDFTreeWidgetClass)XtClass(widget);
+
+  if (!XtIsRealized(widget)) {
+    reply->width = XtWidth(widget);
+    reply->height = XtHeight(widget);
+  } else {
+    reply->width = 0;
+    reply->height = 0;
+  }
+  if (cls->treeClass.calcSize) {
+    (*cls->treeClass.calcSize)(widget, NULL, &reply->width, &reply->height);
+  } else {
+    calcSize(widget, NULL, &reply->width, &reply->height);
+  }
+#if XmVERSION > 1
+  return XmeReplyToQueryGeometry(widget, request, reply);
+#else
+  if ((request->request_mode & CWWidth) &&
+      (request->request_mode & CWHeight) &&
+      request->width == reply->width &&
+      request->height == reply->height) {
+    return XtGeometryYes;
+  }
+  if (reply->width == XtWidth(widget) &&
+      reply->height == XtHeight(widget)) {
+    return XtGeometryNo;
+  }
+  reply->request_mode = CWWidth | CWHeight;
+  return XtGeometryAlmost;
+#endif
+}
+
+static XtGeometryResult geometryManager(Widget widget,
+					XtWidgetGeometry *request,
+					XtWidgetGeometry *reply) {
+  XPDFTreeWidget w = (XPDFTreeWidget)XtParent(widget);
+  XPDFTreeWidgetClass cls = (XPDFTreeWidgetClass)XtClass(w);
+  Dimension curWidth, curHeight, curBW;
+  XtWidgetGeometry parentReq;
+  XtGeometryResult result;
+
+  // deny any requests for a new position
+  if ((request->request_mode & CWX) || (request->request_mode & CWY)) {
+    return XtGeometryNo;
+  }
+
+  // save the current geometry
+  curWidth = w->core.width;
+  curHeight = w->core.height;
+  curBW = w->core.border_width;
+
+  // make the requested changes
+  if (request->request_mode & CWWidth) {
+    w->core.width = request->width;
+  }
+  if (request->request_mode & CWHeight) {
+    w->core.height = request->height;
+  }
+  if (request->request_mode & CWBorderWidth) {
+    w->core.border_width = request->border_width;
+  }
+
+  // calculate the new ideal size
+  parentReq.width = 0;
+  parentReq.height = 0;
+  if (cls->treeClass.calcSize) {
+    (*cls->treeClass.calcSize)((Widget)w, widget,
+			       &parentReq.width, &reply->height);
+  } else {
+    calcSize((Widget)w, widget, &parentReq.width, &reply->height);
+  }
+
+  // send geometry request to our parent
+  parentReq.request_mode = CWWidth | CWHeight;
+  if (request->request_mode & XtCWQueryOnly) {
+    parentReq.request_mode |= XtCWQueryOnly;
+  }
+  result = XtMakeGeometryRequest((Widget)w, &parentReq, NULL);
+  if (result == XtGeometryAlmost) {
+    result = XtGeometryNo;
+  }
+
+  if (result == XtGeometryNo || (request->request_mode & XtCWQueryOnly)) {
+    // restore the original geometry
+    w->core.width = curWidth;
+    w->core.height = curHeight;
+    w->core.border_width = curBW;
+  } else {
+    if (cls->treeClass.layout) {
+      (*cls->treeClass.layout)((Widget)w, widget);
+    } else {
+      layout((Widget)w, widget);
+    }
+  }
+
+  return result;
+}
+
+static void changeManaged(Widget widget) {
+  Dimension width, height;
+  XPDFTreeWidgetClass cls = (XPDFTreeWidgetClass)XtClass(widget);
+
+  // compute the ideal size
+  if (!XtIsRealized(widget)) {
+    width = XtWidth(widget);
+    height = XtHeight(widget);
+  } else {
+    width = 0;
+    height = 0;
+  }
+  if (cls->treeClass.calcSize) {
+    (*cls->treeClass.calcSize)(widget, NULL, &width, &height);
+  } else {
+    calcSize(widget, NULL, &width, &height);
+  }
+
+  // make resize request to parent -- keep asking until we get a yes
+  // or no
+  while (XtMakeResizeRequest(widget, width, height, &width, &height)
+	 == XtGeometryAlmost) ;
+
+  // relayout
+  if (cls->treeClass.layout) {
+    (*cls->treeClass.layout)(widget, NULL);
+  } else {
+    layout(widget, NULL);
+  }
+
+#if XmVERSION > 1
+  // update keyboard traversal
+  XmeNavigChangeManaged(widget);
+#else
+  _XmNavigChangeManaged(widget);
+#endif
+}
+
+static void initConstraint(Widget requestWidget, Widget newWidget,
+			   ArgList args, Cardinal *numArgs) {
+  XPDFTreeWidget w = (XPDFTreeWidget)XtParent(newWidget);
+  XPDFTreeConstraint c;
+
+  c = XPDFTreeCPart(newWidget);
+  c->e = (XPDFTreeEntry *)gmalloc(sizeof(XPDFTreeEntry));
+  c->e->widget = newWidget;
+  c->e->children = NULL;
+  c->e->next = NULL;
+  if (c->entryParent) {
+    insertChildOnList(c->e, &XPDFTreeCPart(c->entryParent)->e->children);
+  } else {
+    insertChildOnList(c->e, &w->tree.root);
+  }
+}
+
+static void destroyConstraint(Widget widget) {
+  deleteSubtree(widget);
+}
+
+static void deleteSubtree(Widget widget) {
+  XPDFTreeWidget w = (XPDFTreeWidget)XtParent(widget);
+  XPDFTreeConstraint c;
+
+  c = XPDFTreeCPart(widget);
+  if (!c->e) {
+    return;
+  }
+  while (c->e->children) {
+    deleteSubtree(c->e->children->widget);
+  }
+  if (c->entryParent) {
+    deleteChildFromList(c->e, &XPDFTreeCPart(c->entryParent)->e->children);
+  } else {
+    deleteChildFromList(c->e, &w->tree.root);
+  }
+  gfree(c->e);
+  c->e = NULL;
+}
+
+static Boolean constraintSetValues(Widget oldWidget, Widget requestWidget,
+				   Widget newWidget,
+				   ArgList args, Cardinal *numArgs) {
+  XPDFTreeWidget w = (XPDFTreeWidget)XtParent(newWidget);
+  XPDFTreeWidgetClass cls = (XPDFTreeWidgetClass)XtClass((Widget)w);
+  XPDFTreeConstraint oc, nc;
+  Boolean relayout;
+  Dimension width, height;
+
+  if (!XtIsManaged(newWidget)) {
+    return False;
+  }
+  oc = XPDFTreeCPart(oldWidget);
+  nc = XPDFTreeCPart(newWidget);
+  relayout = False;
+  if (nc->entryParent != oc->entryParent ||
+      nc->entryPosition != oc->entryPosition) {
+    if (oc->entryParent) {
+      deleteChildFromList(oc->e, &XPDFTreeCPart(oc->entryParent)->e->children);
+    } else {
+      deleteChildFromList(oc->e, &w->tree.root);
+    }
+    if (nc->entryParent) {
+      insertChildOnList(nc->e, &XPDFTreeCPart(nc->entryParent)->e->children);
+    } else {
+      insertChildOnList(nc->e, &w->tree.root);
+    }
+    relayout = True;
+  } else if (nc->entryExpanded != oc->entryExpanded) {
+    relayout = True;
+  }
+
+  if (relayout) {
+
+    // calculate a new ideal size (reset the widget size first so
+    // calcSize will compute a new one)
+    width = 0;
+    height = 0;
+    if (cls->treeClass.calcSize) {
+      (*cls->treeClass.calcSize)((Widget)w, NULL, &width, &height);
+    } else {
+      calcSize((Widget)w, NULL, &width, &height);
+    }
+
+    // make resize request to parent -- keep asking until we get a yes
+    // or no
+    while (XtMakeResizeRequest((Widget)w, width, height, &width, &height)
+	   == XtGeometryAlmost) ;
+
+    // relayout the widget
+    if (cls->treeClass.layout) {
+      (*cls->treeClass.layout)((Widget)w, NULL);
+    } else {
+      layout((Widget)w, NULL);
+    }
+  }
+
+  return relayout;
+}
+
+static void insertChildOnList(XPDFTreeEntry *e, XPDFTreeEntry **listHead) {
+  int pos;
+  XPDFTreeEntry *e2;
+
+  pos = XPDFTreeCPart(e->widget)->entryPosition;
+  if (!*listHead || pos < XPDFTreeCPart((*listHead)->widget)->entryPosition) {
+    e->next = *listHead;
+    *listHead = e;
+  } else {
+    for (e2 = *listHead;
+	 e2->next && pos >= XPDFTreeCPart(e2->next->widget)->entryPosition;
+	 e2 = e2->next) ;
+    e->next = e2->next;
+    e2->next = e;
+  }
+}
+
+static void deleteChildFromList(XPDFTreeEntry *e, XPDFTreeEntry **listHead) {
+  XPDFTreeEntry **p;
+
+  for (p = listHead; *p; p = &(*p)->next) {
+    if (*p == e) {
+      *p = e->next;
+      e->next = NULL;
+      return;
+    }
+  }
+}
+
+static void createGC(Widget widget) {
+  XPDFTreeWidget w = (XPDFTreeWidget)widget;
+  XGCValues gcValues;
+
+  gcValues.foreground = w->manager.foreground;
+  gcValues.line_width = 0;
+  gcValues.line_style = LineSolid;
+  w->tree.plainGC = XtGetGC(widget,
+			    GCForeground | GCLineWidth | GCLineStyle,
+			    &gcValues);
+
+  gcValues.line_style = LineOnOffDash;
+  gcValues.dashes = 1;
+  gcValues.dash_offset = 0;
+  w->tree.dottedGC = XtGetGC(widget,
+			     GCForeground | GCLineWidth | GCLineStyle |
+			         GCDashList | GCDashOffset,
+			     &gcValues);
+}
+
+static void destroyGC(Widget widget) {
+  XPDFTreeWidget w = (XPDFTreeWidget)widget;
+
+  XtReleaseGC(widget, w->tree.plainGC);
+  XtReleaseGC(widget, w->tree.dottedGC);
+}
+
+static void layout(Widget widget, Widget instigator) {
+  XPDFTreeWidget w = (XPDFTreeWidget)widget;
+  XPDFTreeEntry *e;
+  Position x, y;
+
+  x = w->tree.marginWidth + xpdfTreeIndent;
+  y = w->tree.marginHeight;
+  for (e = w->tree.root; e; e = e->next) {
+    y = layoutSubtree(w, instigator, e, x, y, True);
+  }
+}
+
+static int layoutSubtree(XPDFTreeWidget w, Widget instigator,
+			 XPDFTreeEntry *e, Position x, Position y,
+			 Boolean visible) {
+  Widget ew;
+  XPDFTreeEntry *child;
+  XPDFTreeConstraint c;
+
+  ew = e->widget;
+  if (!XtIsManaged(ew)) {
+    return y;
+  }
+  c = XPDFTreeCPart(ew);
+
+  // place this entry
+  if (ew) {
+    if (visible) {
+      if (ew == instigator) {
+	ew->core.x = x;
+	ew->core.y = y;
+      } else {
+#if XmVERSION > 1
+	XmeConfigureObject(ew, x, y, ew->core.width, ew->core.height,
+			   ew->core.border_width);
+#else
+	_XmConfigureObject(ew, x, y, ew->core.width, ew->core.height,
+			   ew->core.border_width);
+#endif
+      }
+      y += ew->core.height + 2 * ew->core.border_width;
+    }
+  }
+
+  // place this entry's children
+  x += xpdfTreeIndent;
+  for (child = e->children; child; child = child->next) {
+    y = layoutSubtree(w, instigator, child, x, y,
+		      visible && (!c || c->entryExpanded));
+  }
+
+  return y;
+}
+
+static void calcSize(Widget widget, Widget instigator,
+		     Dimension *totalWidth,
+		     Dimension *totalHeight) {
+  XPDFTreeWidget w = (XPDFTreeWidget)widget;
+  XPDFTreeEntry *e;
+  Dimension w1, h1, w2, h2;
+
+  w1 = h1 = 0;
+  for (e = w->tree.root; e; e = e->next) {
+    calcSubtreeSize(w, instigator, e, &w2, &h2);
+    if (w2 > w1) {
+      w1 = w2;
+    }
+    h1 += h2;
+  }
+  w1 += xpdfTreeIndent + 2 * w->tree.marginWidth;
+  h1 += 2 * w->tree.marginHeight;
+  if (h1 == 0) {
+    h1 = 1;
+  }
+  if (!*totalWidth) {
+    *totalWidth = w1;
+  }
+  if (!*totalHeight) {
+    *totalHeight = h1;
+  }
+}
+
+static void calcSubtreeSize(XPDFTreeWidget w, Widget instigator,
+			    XPDFTreeEntry *e,
+			    Dimension *width, Dimension *height) {
+  Widget ew;
+  XPDFTreeEntry *child;
+  XPDFTreeConstraint c;
+  XtWidgetGeometry geom;
+  Dimension w1, h1, w2, h2;
+  
+  ew = e->widget;
+  if (!XtIsManaged(ew)) {
+    *width = *height = 0;
+    return;
+  }
+  c = XPDFTreeCPart(ew);
+
+  // get size of this entry
+  if (ew) {
+    if (!XtIsManaged(ew)) {
+      *width = *height = 0;
+      return;
+    }
+    if (ew == instigator) {
+      w1 = ew->core.width;
+      h1 = ew->core.height;
+    } else {
+      XtQueryGeometry(ew, NULL, &geom);
+      w1 = (geom.request_mode & CWWidth) ? geom.width : ew->core.width;
+      h1 = (geom.request_mode & CWHeight) ? geom.height : ew->core.height;
+    }
+    h1 += 2 * ew->core.border_width;
+  } else {
+    // root of tree
+    w1 = 0;
+    h1 = 0;
+  }
+
+  // if this entry is expanded, get size of all of its children
+  if (c->entryExpanded) {
+    for (child = e->children; child; child = child->next) {
+      calcSubtreeSize(w, instigator, child, &w2, &h2);
+      w2 += xpdfTreeIndent;
+      if (w2 > w1) {
+	w1 = w2;
+      }
+      h1 += h2;
+    }
+  }
+
+  *width = w1;
+  *height = h1;
+}
+
+static Boolean needRelayout(Widget oldWidget, Widget newWidget) {
+  XPDFTreeWidget ow = (XPDFTreeWidget)oldWidget;
+  XPDFTreeWidget nw = (XPDFTreeWidget)newWidget;
+
+  if (nw->tree.marginWidth != ow->tree.marginWidth ||
+      nw->tree.marginHeight != ow->tree.marginHeight) {
+    return True;
+  }
+  return False;
+}
+
+static void click(Widget widget, XEvent *event,
+		  String *params, Cardinal *numParams) {
+  XPDFTreeWidget w = (XPDFTreeWidget)widget;
+  XButtonPressedEvent *bpe;
+  XPDFTreeEntry *e;
+  Boolean onExpandIcon;
+  XPDFTreeConstraint c;
+  XPDFTreeSelectCallbackStruct cbs;
+
+  if (event->type != ButtonPress) {
+    return;
+  }
+  bpe = (XButtonPressedEvent *)event;
+  if (findPosition(w, bpe->x, bpe->y, &e, &onExpandIcon)) {
+    if (onExpandIcon) {
+      c = XPDFTreeCPart(e->widget);
+      w->tree.redrawY = e->widget->core.y;
+      XtVaSetValues(e->widget, XPDFNentryExpanded, !c->entryExpanded, NULL);
+    } else {
+      XmProcessTraversal(e->widget, XmTRAVERSE_CURRENT);
+      XtCallActionProc(widget, "ManagerGadgetActivate", event, NULL, 0);
+      cbs.reason = XmCR_ACTIVATE;
+      cbs.event = event;
+      cbs.selectedItem = e->widget;
+      XtCallCallbackList(widget, w->tree.selectCallback, &cbs);
+    }
+  }
+}
+
+static Boolean findPosition(XPDFTreeWidget w, int x, int y,
+			    XPDFTreeEntry **e, Boolean *onExpandIcon) {
+  XPDFTreeEntry *e2;
+
+  for (e2 = w->tree.root; e2; e2 = e2->next) {
+    *e = e2;
+    if (findPositionInSubtree(w, x, y, e, onExpandIcon)) {
+      return True;
+    }
+  }
+  return False;
+}
+
+// If (x,y) falls on either an expand/collapse icon or a label gadget,
+// set *<e> and *<onExpandIcon> and return true.
+static Boolean findPositionInSubtree(XPDFTreeWidget w, int x, int y,
+				     XPDFTreeEntry **e,
+				     Boolean *onExpandIcon) {
+  Widget child;
+  XPDFTreeConstraint c;
+  XPDFTreeEntry *e2;
+  int y1;
+
+  child = (*e)->widget;
+  y1 = child->core.y + child->core.height / 2;
+  if (x >= child->core.x && x < child->core.x + child->core.width &&
+      y >= child->core.y && y < child->core.y + child->core.height) {
+    *onExpandIcon = False;
+    return True;
+  } else if (x >= child->core.x - 16 && x < child->core.x - 4 &&
+	     y >= y1 - 6 && y < y1 + 6 &&
+	     (*e)->children) {
+    *onExpandIcon = True;
+    return True;
+  }
+  c = XPDFTreeCPart(child);
+  if (!c || c->entryExpanded) {
+    for (e2 = (*e)->children; e2; e2 = e2->next) {
+      *e = e2;
+      if (findPositionInSubtree(w, x, y, e, onExpandIcon)) {
+	return True;
+      }
+    }
+  }
+  return False;
+}
+
+Widget XPDFCreateTree(Widget parent, char *name,
+		      ArgList argList, Cardinal numArgs) {
+  return XtCreateWidget(name, xpdfTreeWidgetClass, parent, argList, numArgs);
+}