pdf2json 0.1.0

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

@@ -0,0 +1,45 @@
+//========================================================================
+//
+// XPDFTree.h
+//
+// Copyright 2002-2003 Glyph & Cog, LLC
+//
+//========================================================================
+
+#ifndef XPDFTREE_H
+#define XPDFTREE_H
+
+#include <Xm/Xm.h>
+
+extern "C" {
+
+externalref WidgetClass xpdfTreeWidgetClass;
+
+typedef struct _XPDFTreeClassRec *XPDFTreeWidgetClass;
+typedef struct _XPDFTreeRec      *XPDFTreeWidget;
+
+#ifndef XPDFIsTree
+#define XPDFIsTree(w) XtIsSubclass(w, xpdfTreeWidgetClass)
+#endif
+
+#define XPDFNentryParent       "entryParent"
+#define XPDFNentryExpanded     "entryExpanded"
+#define XPDFNentryPosition     "entryPosition"
+#define XPDFNselectionCallback "selectionCallback"
+
+#define XPDFCentryParent       "EntryParent"
+#define XPDFCentryExpanded     "EntryExpanded"
+#define XPDFCentryPosition     "EntryPosition"
+
+typedef struct {
+  int reason;
+  XEvent *event;
+  Widget selectedItem;
+} XPDFTreeSelectCallbackStruct;
+
+extern Widget XPDFCreateTree(Widget parent, char *name,
+			     ArgList argList, Cardinal argCount);
+
+} // extern "C"
+
+#endif

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

@@ -0,0 +1,87 @@
+//========================================================================
+//
+// XPDFTreeP.h
+//
+// Copyright 2002-2003 Glyph & Cog, LLC
+//
+//========================================================================
+
+#ifndef XPDFTREEP_H
+#define XPDFTREEP_H
+
+#include <Xm/ManagerP.h>
+#include "XPDFTree.h"
+
+extern "C" {
+
+typedef void (*XPDFLayoutProc)(Widget widget, Widget instigator);
+typedef void (*XPDFCalcSizeProc)(Widget widget, Widget instigator,
+				 Dimension *totalWidth,
+				 Dimension *totalHeight);
+typedef Boolean (*XPDFNeedRelayoutProc)(Widget oldWidget, Widget newWidget);
+
+#define XPDFInheritCreateGC ((XtWidgetProc)_XtInherit)
+#define XPDFInheritDestroyGC ((XtWidgetProc)_XtInherit)
+#define XPDFInheritLayout ((XPDFLayoutProc)_XtInherit)
+#define XPDFInheritCalcSize ((XPDFCalcSizeProc)_XtInherit)
+#define XPDFInheritNeedRelayout ((XPDFNeedRelayoutProc)_XtInherit)
+
+typedef struct {
+  XtWidgetProc createGC;
+  XtWidgetProc destroyGC;
+  XPDFLayoutProc layout;
+  XPDFCalcSizeProc calcSize;
+  XPDFNeedRelayoutProc needRelayout;
+  XtPointer extension;
+} XPDFTreeClassPart;
+
+typedef struct _XPDFTreeClassRec {
+  CoreClassPart coreClass;
+  CompositeClassPart compositeClass;
+  ConstraintClassPart constraintClass;
+  XmManagerClassPart managerClass;
+  XPDFTreeClassPart treeClass;
+} XPDFTreeClassRec;
+
+externalref XPDFTreeClassRec xpdfTreeClassRec;
+
+typedef struct _XPDFTreeEntry XPDFTreeEntry;
+
+typedef struct {
+  Dimension marginWidth;
+  Dimension marginHeight;
+  XtCallbackList selectCallback;
+  GC plainGC;
+  GC dottedGC;
+  XPDFTreeEntry *root;
+  int redrawY;
+} XPDFTreePart;
+
+typedef struct _XPDFTreeRec {
+  CorePart core;
+  CompositePart composite;
+  ConstraintPart constraint;
+  XmManagerPart manager;
+  XPDFTreePart tree;
+} XPDFTreeRec;
+
+#define XPDFTreeIndex (XmManagerIndex + 1)
+
+typedef struct _XPDFTreeConstraintPart {
+  Widget entryParent;
+  Boolean entryExpanded;
+  int entryPosition;
+  XPDFTreeEntry *e;
+} XPDFTreeConstraintPart, *XPDFTreeConstraint;
+
+typedef struct _XPDFTreeConstraintRec {
+  XmManagerConstraintPart manager;
+  XPDFTreeConstraintPart tree;
+} XPDFTreeConstraintRec, *XPDFTreeConstraintPtr;
+
+#define XPDFTreeCPart(w) \
+  (&((XPDFTreeConstraintPtr)(w)->core.constraints)->tree)
+
+} // extern "C"
+
+#endif

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

@@ -0,0 +1,3488 @@
+//========================================================================
+//
+// XPDFViewer.cc
+//
+// Copyright 2002-2003 Glyph & Cog, LLC
+//
+//========================================================================
+
+#include <aconf.h>
+
+#ifdef USE_GCC_PRAGMAS
+#pragma implementation
+#endif
+
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+#include <X11/keysym.h>
+#include <X11/cursorfont.h>
+#ifdef HAVE_X11_XPM_H
+#include <X11/xpm.h>
+#endif
+#if defined(__sgi) && (XmVERSION <= 1)
+#define Object XtObject
+#include <Sgm/HPanedW.h>
+#undef Object
+#endif
+#include "gmem.h"
+#include "gfile.h"
+#include "GString.h"
+#include "GList.h"
+#include "Error.h"
+#include "GlobalParams.h"
+#include "PDFDoc.h"
+#include "Link.h"
+#include "ErrorCodes.h"
+#include "Outline.h"
+#include "UnicodeMap.h"
+#ifndef DISABLE_OUTLINE
+#define Object XtObject
+#include "XPDFTree.h"
+#undef Object
+#endif
+#include "XPDFApp.h"
+#include "XPDFViewer.h"
+#include "PSOutputDev.h"
+#include "config.h"
+
+// these macro defns conflict with xpdf's Object class
+#ifdef LESSTIF_VERSION
+#undef XtDisplay
+#undef XtScreen
+#undef XtWindow
+#undef XtParent
+#undef XtIsRealized
+#endif
+
+#if XmVERSION <= 1
+#define XmSET   True
+#define XmUNSET False
+#endif
+
+// hack around old X includes which are missing these symbols
+#ifndef XK_Page_Up
+#define XK_Page_Up              0xFF55
+#endif
+#ifndef XK_Page_Down
+#define XK_Page_Down            0xFF56
+#endif
+#ifndef XK_KP_Home
+#define XK_KP_Home              0xFF95
+#endif
+#ifndef XK_KP_Left
+#define XK_KP_Left              0xFF96
+#endif
+#ifndef XK_KP_Up
+#define XK_KP_Up                0xFF97
+#endif
+#ifndef XK_KP_Right
+#define XK_KP_Right             0xFF98
+#endif
+#ifndef XK_KP_Down
+#define XK_KP_Down              0xFF99
+#endif
+#ifndef XK_KP_Prior
+#define XK_KP_Prior             0xFF9A
+#endif
+#ifndef XK_KP_Page_Up
+#define XK_KP_Page_Up           0xFF9A
+#endif
+#ifndef XK_KP_Next
+#define XK_KP_Next              0xFF9B
+#endif
+#ifndef XK_KP_Page_Down
+#define XK_KP_Page_Down         0xFF9B
+#endif
+#ifndef XK_KP_End
+#define XK_KP_End               0xFF9C
+#endif
+#ifndef XK_KP_Begin
+#define XK_KP_Begin             0xFF9D
+#endif
+#ifndef XK_KP_Insert
+#define XK_KP_Insert            0xFF9E
+#endif
+#ifndef XK_KP_Delete
+#define XK_KP_Delete            0xFF9F
+#endif
+
+//------------------------------------------------------------------------
+// GUI includes
+//------------------------------------------------------------------------
+
+#include "xpdfIcon.xpm"
+#include "leftArrow.xbm"
+#include "leftArrowDis.xbm"
+#include "dblLeftArrow.xbm"
+#include "dblLeftArrowDis.xbm"
+#include "rightArrow.xbm"
+#include "rightArrowDis.xbm"
+#include "dblRightArrow.xbm"
+#include "dblRightArrowDis.xbm"
+#include "backArrow.xbm"
+#include "backArrowDis.xbm"
+#include "forwardArrow.xbm"
+#include "forwardArrowDis.xbm"
+#include "find.xbm"
+#include "findDis.xbm"
+#include "print.xbm"
+#include "printDis.xbm"
+#include "about.xbm"
+#include "about-text.h"
+
+//------------------------------------------------------------------------
+
+struct ZoomMenuInfo {
+  char *label;
+  double zoom;
+};
+
+static ZoomMenuInfo zoomMenuInfo[nZoomMenuItems] = {
+  { "400%",      400 },
+  { "200%",      200 },
+  { "150%",      150 },
+  { "125%",      125 },
+  { "100%",      100 },
+  { "50%",        50 },
+  { "25%",        25 },
+  { "12.5%",      12.5 },
+  { "fit page",  zoomPage },
+  { "fit width", zoomWidth }
+};
+
+#define maxZoomIdx   0
+#define defZoomIdx   3
+#define minZoomIdx   7
+#define zoomPageIdx  8
+#define zoomWidthIdx 9
+
+//------------------------------------------------------------------------
+
+#define cmdMaxArgs 2
+
+XPDFViewerCmd XPDFViewer::cmdTab[] = {
+  { "about",                   0, gFalse, gFalse, &XPDFViewer::cmdAbout },
+  { "closeOutline",            0, gFalse, gFalse, &XPDFViewer::cmdCloseOutline },
+  { "closeWindow",             0, gFalse, gFalse, &XPDFViewer::cmdCloseWindow },
+  { "continuousMode",          0, gFalse, gFalse, &XPDFViewer::cmdContinuousMode },
+  { "endPan",                  0, gTrue,  gTrue,  &XPDFViewer::cmdEndPan },
+  { "endSelection",            0, gTrue,  gTrue,  &XPDFViewer::cmdEndSelection },
+  { "find",                    0, gTrue,  gFalse, &XPDFViewer::cmdFind },
+  { "findNext",                0, gTrue,  gFalse, &XPDFViewer::cmdFindNext },
+  { "focusToDocWin",           0, gFalse, gFalse, &XPDFViewer::cmdFocusToDocWin },
+  { "focusToPageNum",          0, gFalse, gFalse, &XPDFViewer::cmdFocusToPageNum },
+  { "followLink",              0, gTrue,  gTrue,  &XPDFViewer::cmdFollowLink },
+  { "followLinkInNewWin",      0, gTrue,  gTrue,  &XPDFViewer::cmdFollowLinkInNewWin },
+  { "followLinkInNewWinNoSel", 0, gTrue,  gTrue,  &XPDFViewer::cmdFollowLinkInNewWinNoSel },
+  { "followLinkNoSel",         0, gTrue,  gTrue,  &XPDFViewer::cmdFollowLinkNoSel },
+  { "fullScreenMode",          0, gFalse, gFalse, &XPDFViewer::cmdFullScreenMode },
+  { "goBackward",              0, gFalse, gFalse, &XPDFViewer::cmdGoBackward },
+  { "goForward",               0, gFalse, gFalse, &XPDFViewer::cmdGoForward },
+  { "gotoDest",                1, gTrue,  gFalse, &XPDFViewer::cmdGotoDest },
+  { "gotoLastPage",            0, gTrue,  gFalse, &XPDFViewer::cmdGotoLastPage },
+  { "gotoLastPageNoScroll",    0, gTrue,  gFalse, &XPDFViewer::cmdGotoLastPageNoScroll },
+  { "gotoPage",                1, gTrue,  gFalse, &XPDFViewer::cmdGotoPage },
+  { "gotoPageNoScroll",        1, gTrue,  gFalse, &XPDFViewer::cmdGotoPageNoScroll },
+  { "nextPage",                0, gTrue,  gFalse, &XPDFViewer::cmdNextPage },
+  { "nextPageNoScroll",        0, gTrue,  gFalse, &XPDFViewer::cmdNextPageNoScroll },
+  { "open",                    0, gFalse, gFalse, &XPDFViewer::cmdOpen },
+  { "openFile",                1, gFalse, gFalse, &XPDFViewer::cmdOpenFile },
+  { "openFileAtDest",          2, gFalse, gFalse, &XPDFViewer::cmdOpenFileAtDest },
+  { "openFileAtDestInNewWin",  2, gFalse, gFalse, &XPDFViewer::cmdOpenFileAtDestInNewWin },
+  { "openFileAtPage",          2, gFalse, gFalse, &XPDFViewer::cmdOpenFileAtPage },
+  { "openFileAtPageInNewWin",  2, gFalse, gFalse, &XPDFViewer::cmdOpenFileAtPageInNewWin },
+  { "openFileInNewWin",        1, gFalse, gFalse, &XPDFViewer::cmdOpenFileInNewWin },
+  { "openInNewWin",            0, gFalse, gFalse, &XPDFViewer::cmdOpenInNewWin },
+  { "openOutline",             0, gFalse, gFalse, &XPDFViewer::cmdOpenOutline },
+  { "pageDown",                0, gTrue,  gFalse, &XPDFViewer::cmdPageDown },
+  { "pageUp",                  0, gTrue,  gFalse, &XPDFViewer::cmdPageUp },
+  { "postPopupMenu",           0, gFalse, gTrue,  &XPDFViewer::cmdPostPopupMenu },
+  { "prevPage",                0, gTrue,  gFalse, &XPDFViewer::cmdPrevPage },
+  { "prevPageNoScroll",        0, gTrue,  gFalse, &XPDFViewer::cmdPrevPageNoScroll },
+  { "print",                   0, gTrue,  gFalse, &XPDFViewer::cmdPrint },
+  { "quit",                    0, gFalse, gFalse, &XPDFViewer::cmdQuit },
+  { "raise",                   0, gFalse, gFalse, &XPDFViewer::cmdRaise },
+  { "redraw",                  0, gTrue,  gFalse, &XPDFViewer::cmdRedraw },
+  { "reload",                  0, gTrue,  gFalse, &XPDFViewer::cmdReload },
+  { "run",                     1, gFalse, gFalse, &XPDFViewer::cmdRun },
+  { "scrollDown",              1, gTrue,  gFalse, &XPDFViewer::cmdScrollDown },
+  { "scrollDownNextPage",      1, gTrue,  gFalse, &XPDFViewer::cmdScrollDownNextPage },
+  { "scrollLeft",              1, gTrue,  gFalse, &XPDFViewer::cmdScrollLeft },
+  { "scrollOutlineDown",       1, gTrue,  gFalse, &XPDFViewer::cmdScrollOutlineDown },
+  { "scrollOutlineUp",         1, gTrue,  gFalse, &XPDFViewer::cmdScrollOutlineUp },
+  { "scrollRight",             1, gTrue,  gFalse, &XPDFViewer::cmdScrollRight },
+  { "scrollToBottomEdge",      0, gTrue,  gFalse, &XPDFViewer::cmdScrollToBottomEdge },
+  { "scrollToBottomRight",     0, gTrue,  gFalse, &XPDFViewer::cmdScrollToBottomRight },
+  { "scrollToLeftEdge",        0, gTrue,  gFalse, &XPDFViewer::cmdScrollToLeftEdge },
+  { "scrollToRightEdge",       0, gTrue,  gFalse, &XPDFViewer::cmdScrollToRightEdge },
+  { "scrollToTopEdge",         0, gTrue,  gFalse, &XPDFViewer::cmdScrollToTopEdge },
+  { "scrollToTopLeft",         0, gTrue,  gFalse, &XPDFViewer::cmdScrollToTopLeft },
+  { "scrollUp",                1, gTrue,  gFalse, &XPDFViewer::cmdScrollUp },
+  { "scrollUpPrevPage",        1, gTrue,  gFalse, &XPDFViewer::cmdScrollUpPrevPage },
+  { "singlePageMode",          0, gFalse, gFalse, &XPDFViewer::cmdSinglePageMode },
+  { "startPan",                0, gTrue,  gTrue,  &XPDFViewer::cmdStartPan },
+  { "startSelection",          0, gTrue,  gTrue,  &XPDFViewer::cmdStartSelection },
+  { "toggleContinuousMode",    0, gFalse, gFalse, &XPDFViewer::cmdToggleContinuousMode },
+  { "toggleFullScreenMode",    0, gFalse, gFalse, &XPDFViewer::cmdToggleFullScreenMode },
+  { "toggleOutline",           0, gFalse, gFalse, &XPDFViewer::cmdToggleOutline },
+  { "windowMode",              0, gFalse, gFalse, &XPDFViewer::cmdWindowMode },
+  { "zoomFitPage",             0, gFalse, gFalse, &XPDFViewer::cmdZoomFitPage },
+  { "zoomFitWidth",            0, gFalse, gFalse, &XPDFViewer::cmdZoomFitWidth },
+  { "zoomIn",                  0, gFalse, gFalse, &XPDFViewer::cmdZoomIn },
+  { "zoomOut",                 0, gFalse, gFalse, &XPDFViewer::cmdZoomOut },
+  { "zoomPercent",             1, gFalse, gFalse, &XPDFViewer::cmdZoomPercent },
+  { "zoomToSelection",         0, gTrue,  gFalse, &XPDFViewer::cmdZoomToSelection }
+};
+
+#define nCmds (sizeof(cmdTab) / sizeof(XPDFViewerCmd))
+
+//------------------------------------------------------------------------
+
+XPDFViewer::XPDFViewer(XPDFApp *appA, GString *fileName,
+		       int pageA, GString *destName, GBool fullScreen,
+		       GString *ownerPassword, GString *userPassword) {
+  LinkDest *dest;
+  int pg;
+  double z;
+
+  app = appA;
+  win = NULL;
+  core = NULL;
+  ok = gFalse;
+#ifndef DISABLE_OUTLINE
+  outlineLabels = NULL;
+  outlineLabelsLength = outlineLabelsSize = 0;
+  outlinePaneWidth = 175;
+#endif
+
+  // do Motif-specific initialization and create the window;
+  // this also creates the core object
+  initWindow(fullScreen);
+  initAboutDialog();
+  initFindDialog();
+  initPrintDialog();
+  openDialog = NULL;
+  saveAsDialog = NULL;
+
+  dest = NULL; // make gcc happy
+  pg = pageA; // make gcc happy
+
+  if (fileName) {
+    if (loadFile(fileName, ownerPassword, userPassword)) {
+      getPageAndDest(pageA, destName, &pg, &dest);
+#ifndef DISABLE_OUTLINE
+      if (outlineScroll != None &&
+	  core->getDoc()->getOutline()->getItems() &&
+	  core->getDoc()->getOutline()->getItems()->getLength() > 0) {
+	XtVaSetValues(outlineScroll, XmNwidth, outlinePaneWidth, NULL);
+      }
+#endif
+    } else {
+      return;
+    }
+  }
+  core->resizeToPage(pg);
+
+  // map the window -- we do this after calling resizeToPage to avoid
+  // an annoying on-screen resize
+  mapWindow();
+
+  // display the first page
+  z = core->getZoom();
+  if (dest) {
+    displayDest(dest, z, core->getRotate(), gTrue);
+    delete dest;
+  } else {
+    displayPage(pg, z, core->getRotate(), gTrue, gTrue);
+  }
+
+  ok = gTrue;
+}
+
+XPDFViewer::XPDFViewer(XPDFApp *appA, PDFDoc *doc, int pageA,
+		       GString *destName, GBool fullScreen) {
+  LinkDest *dest;
+  int pg;
+  double z;
+
+  app = appA;
+  win = NULL;
+  core = NULL;
+  ok = gFalse;
+#ifndef DISABLE_OUTLINE
+  outlineLabels = NULL;
+  outlineLabelsLength = outlineLabelsSize = 0;
+  outlinePaneWidth = 175;
+#endif
+
+  // do Motif-specific initialization and create the window;
+  // this also creates the core object
+  initWindow(fullScreen);
+  initAboutDialog();
+  initFindDialog();
+  initPrintDialog();
+  openDialog = NULL;
+  saveAsDialog = NULL;
+
+  dest = NULL; // make gcc happy
+  pg = pageA; // make gcc happy
+
+  if (doc) {
+    core->loadDoc(doc);
+    getPageAndDest(pageA, destName, &pg, &dest);
+#ifndef DISABLE_OUTLINE
+    if (outlineScroll != None &&
+	core->getDoc()->getOutline()->getItems() &&
+	core->getDoc()->getOutline()->getItems()->getLength() > 0) {
+      XtVaSetValues(outlineScroll, XmNwidth, outlinePaneWidth, NULL);
+    }
+#endif
+  }
+  core->resizeToPage(pg);
+
+  // map the window -- we do this after calling resizeToPage to avoid
+  // an annoying on-screen resize
+  mapWindow();
+
+  // display the first page
+  z = core->getZoom();
+  if (dest) {
+    displayDest(dest, z, core->getRotate(), gTrue);
+    delete dest;
+  } else {
+    displayPage(pg, z, core->getRotate(), gTrue, gTrue);
+  }
+
+  ok = gTrue;
+}
+
+XPDFViewer::~XPDFViewer() {
+  delete core;
+  XmFontListFree(aboutBigFont);
+  XmFontListFree(aboutVersionFont);
+  XmFontListFree(aboutFixedFont);
+  closeWindow();
+#ifndef DISABLE_OUTLINE
+  if (outlineLabels) {
+    gfree(outlineLabels);
+  }
+#endif
+}
+
+void XPDFViewer::open(GString *fileName, int pageA, GString *destName) {
+  LinkDest *dest;
+  int pg;
+  double z;
+
+  if (!core->getDoc() || fileName->cmp(core->getDoc()->getFileName())) {
+    if (!loadFile(fileName, NULL, NULL)) {
+      return;
+    }
+  }
+  getPageAndDest(pageA, destName, &pg, &dest);
+  z = core->getZoom();
+  if (dest) {
+    displayDest(dest, z, core->getRotate(), gTrue);
+    delete dest;
+  } else {
+    displayPage(pg, z, core->getRotate(), gTrue, gTrue);
+  }
+}
+
+void XPDFViewer::clear() {
+  char *title;
+  XmString s;
+
+  core->clear();
+
+  // set up title, number-of-pages display
+  title = app->getTitle() ? app->getTitle()->getCString()
+                          : (char *)xpdfAppName;
+  XtVaSetValues(win, XmNtitle, title, XmNiconName, title, NULL);
+  s = XmStringCreateLocalized("");
+  XtVaSetValues(pageNumText, XmNlabelString, s, NULL);
+  XmStringFree(s);
+  s = XmStringCreateLocalized(" of 0");
+  XtVaSetValues(pageCountLabel, XmNlabelString, s, NULL);
+  XmStringFree(s);
+
+  // disable buttons
+  XtVaSetValues(prevTenPageBtn, XmNsensitive, False, NULL);
+  XtVaSetValues(prevPageBtn, XmNsensitive, False, NULL);
+  XtVaSetValues(nextTenPageBtn, XmNsensitive, False, NULL);
+  XtVaSetValues(nextPageBtn, XmNsensitive, False, NULL);
+
+  // remove the old outline
+#ifndef DISABLE_OUTLINE
+  setupOutline();
+#endif
+}
+
+//------------------------------------------------------------------------
+// load / display
+//------------------------------------------------------------------------
+
+GBool XPDFViewer::loadFile(GString *fileName, GString *ownerPassword,
+			   GString *userPassword) {
+  return core->loadFile(fileName, ownerPassword, userPassword) == errNone;
+}
+
+void XPDFViewer::reloadFile() {
+  int pg;
+
+  if (!core->getDoc()) {
+    return;
+  }
+  pg = core->getPageNum();
+  loadFile(core->getDoc()->getFileName());
+  if (pg > core->getDoc()->getNumPages()) {
+    pg = core->getDoc()->getNumPages();
+  }
+  displayPage(pg, core->getZoom(), core->getRotate(), gFalse, gFalse);
+}
+
+void XPDFViewer::displayPage(int pageA, double zoomA, int rotateA,
+			     GBool scrollToTop, GBool addToHist) {
+  core->displayPage(pageA, zoomA, rotateA, scrollToTop, addToHist);
+}
+
+void XPDFViewer::displayDest(LinkDest *dest, double zoomA, int rotateA,
+			     GBool addToHist) {
+  core->displayDest(dest, zoomA, rotateA, addToHist);
+}
+
+void XPDFViewer::getPageAndDest(int pageA, GString *destName,
+				int *pageOut, LinkDest **destOut) {
+  Ref pageRef;
+
+  // find the page number for a named destination
+  *pageOut = pageA;
+  *destOut = NULL;
+  if (destName && (*destOut = core->getDoc()->findDest(destName))) {
+    if ((*destOut)->isPageRef()) {
+      pageRef = (*destOut)->getPageRef();
+      *pageOut = core->getDoc()->findPage(pageRef.num, pageRef.gen);
+    } else {
+      *pageOut = (*destOut)->getPageNum();
+    }
+  }
+
+  if (*pageOut <= 0) {
+    *pageOut = 1;
+  }
+  if (*pageOut > core->getDoc()->getNumPages()) {
+    *pageOut = core->getDoc()->getNumPages();
+  }
+}
+
+//------------------------------------------------------------------------
+// hyperlinks / actions
+//------------------------------------------------------------------------
+
+void XPDFViewer::doLink(int wx, int wy, GBool onlyIfNoSelection,
+			GBool newWin) {
+  XPDFViewer *newViewer;
+  LinkAction *action;
+  int pg, selPg;
+  double xu, yu, selULX, selULY, selLRX, selLRY;
+
+  if (core->getHyperlinksEnabled() &&
+      core->cvtWindowToUser(wx, wy, &pg, &xu, &yu) &&
+      !(onlyIfNoSelection &&
+	core->getSelection(&selPg, &selULX, &selULY, &selLRX, &selLRY))) {
+    if ((action = core->findLink(pg, xu, yu))) {
+      if (newWin &&
+	  core->getDoc()->getFileName() &&
+	  (action->getKind() == actionGoTo ||
+	   action->getKind() == actionGoToR ||
+	   (action->getKind() == actionNamed &&
+	    ((LinkNamed *)action)->getName()->cmp("Quit")))) {
+	newViewer = app->open(core->getDoc()->getFileName());
+	newViewer->core->doAction(action);
+      } else {
+	core->doAction(action);
+      }
+    }
+  }
+}
+
+void XPDFViewer::actionCbk(void *data, char *action) {
+  XPDFViewer *viewer = (XPDFViewer *)data;
+
+  if (!strcmp(action, "Quit")) {
+    viewer->app->quit();
+  }
+}
+
+//------------------------------------------------------------------------
+// keyboard/mouse input
+//------------------------------------------------------------------------
+
+void XPDFViewer::keyPressCbk(void *data, KeySym key, Guint modifiers,
+			     XEvent *event) {
+  XPDFViewer *viewer = (XPDFViewer *)data;
+  int keyCode;
+  GList *cmds;
+  int i;
+
+  if (key >= 0x20 && key <= 0xfe) {
+    keyCode = (int)key;
+  } else if (key == XK_Tab ||
+	     key == XK_KP_Tab) {
+    keyCode = xpdfKeyCodeTab;
+  } else if (key == XK_Return) {
+    keyCode = xpdfKeyCodeReturn;
+  } else if (key == XK_KP_Enter) {
+    keyCode = xpdfKeyCodeEnter;
+  } else if (key == XK_BackSpace) {
+    keyCode = xpdfKeyCodeBackspace;
+  } else if (key == XK_Insert ||
+	     key == XK_KP_Insert) {
+    keyCode = xpdfKeyCodeInsert;
+  } else if (key == XK_Delete ||
+	     key == XK_KP_Delete) {
+    keyCode = xpdfKeyCodeDelete;
+  } else if (key == XK_Home ||
+	     key == XK_KP_Home) {
+    keyCode = xpdfKeyCodeHome;
+  } else if (key == XK_End ||
+	     key == XK_KP_End) {
+    keyCode = xpdfKeyCodeEnd;
+  } else if (key == XK_Page_Up ||
+	     key == XK_KP_Page_Up) {
+    keyCode = xpdfKeyCodePgUp;
+  } else if (key == XK_Page_Down ||
+	     key == XK_KP_Page_Down) {
+    keyCode = xpdfKeyCodePgDn;
+  } else if (key == XK_Left ||
+	     key == XK_KP_Left) {
+    keyCode = xpdfKeyCodeLeft;
+  } else if (key == XK_Right ||
+	     key == XK_KP_Right) {
+    keyCode = xpdfKeyCodeRight;
+  } else if (key == XK_Up ||
+	     key == XK_KP_Up) {
+    keyCode = xpdfKeyCodeUp;
+  } else if (key == XK_Down ||
+	     key == XK_KP_Down) {
+    keyCode = xpdfKeyCodeDown;
+  } else if (key >= XK_F1 && key <= XK_F35) {
+    keyCode = xpdfKeyCodeF1 + (key - XK_F1);
+  } else {
+    return;
+  }
+
+  if ((cmds = globalParams->getKeyBinding(keyCode,
+					  viewer->getModifiers(modifiers),
+					  viewer->getContext(modifiers)))) {
+    for (i = 0; i < cmds->getLength(); ++i) {
+      viewer->execCmd((GString *)cmds->get(i), event);
+    }
+    deleteGList(cmds, GString);
+  }
+}
+
+void XPDFViewer::mouseCbk(void *data, XEvent *event) {
+  XPDFViewer *viewer = (XPDFViewer *)data;
+  int keyCode;
+  GList *cmds;
+  int i;
+
+  if (event->type == ButtonPress) {
+    if (event->xbutton.button >= 1 && event->xbutton.button <= 7) {
+      keyCode = xpdfKeyCodeMousePress1 + event->xbutton.button - 1;
+    } else {
+      return;
+    }
+  } else if (event->type == ButtonRelease) {
+    if (event->xbutton.button >= 1 && event->xbutton.button <= 7) {
+      keyCode = xpdfKeyCodeMouseRelease1 + event->xbutton.button - 1;
+    } else {
+      return;
+    }
+  } else {
+    return;
+  }
+
+  if ((cmds = globalParams->getKeyBinding(keyCode,
+					  viewer->getModifiers(
+						      event->xkey.state),
+					  viewer->getContext(
+						      event->xkey.state)))) {
+    for (i = 0; i < cmds->getLength(); ++i) {
+      viewer->execCmd((GString *)cmds->get(i), event);
+    }
+    deleteGList(cmds, GString);
+  }
+}
+
+int XPDFViewer::getModifiers(Guint modifiers) {
+  int mods;
+
+  mods = 0;
+  if (modifiers & ShiftMask) {
+    mods |= xpdfKeyModShift;
+  }
+  if (modifiers & ControlMask) {
+    mods |= xpdfKeyModCtrl;
+  }
+  if (modifiers & Mod1Mask) {
+    mods |= xpdfKeyModAlt;
+  }
+  return mods;
+}
+
+int XPDFViewer::getContext(Guint modifiers) {
+  int context;
+
+  context = (core->getFullScreen() ? xpdfKeyContextFullScreen
+                                   : xpdfKeyContextWindow) |
+            (core->getContinuousMode() ? xpdfKeyContextContinuous
+                                       : xpdfKeyContextSinglePage) |
+            (core->getLinkAction() ? xpdfKeyContextOverLink
+                                   : xpdfKeyContextOffLink) |
+            ((modifiers & Mod5Mask) ? xpdfKeyContextScrLockOn
+	                            : xpdfKeyContextScrLockOff);
+  return context;
+}
+
+void XPDFViewer::execCmd(GString *cmd, XEvent *event) {
+  GString *name;
+  GString *args[cmdMaxArgs];
+  char *p0, *p1;
+  int nArgs, i;
+  int a, b, m, cmp;
+
+  //----- parse the command
+  name = NULL;
+  nArgs = 0;
+  for (i = 0; i < cmdMaxArgs; ++i) {
+    args[i] = NULL;
+  }
+  p0 = cmd->getCString();
+  for (p1 = p0; *p1 && isalnum(*p1); ++p1) ;
+  if (p1 == p0) {
+    goto err1;
+  }
+  name = new GString(p0, p1 - p0);
+  if (*p1 == '(') {
+    while (nArgs < cmdMaxArgs) {
+      p0 = p1 + 1;
+      for (p1 = p0; *p1 && *p1 != ',' && *p1 != ')'; ++p1) ;
+      args[nArgs++] = new GString(p0, p1 - p0);
+      if (*p1 != ',') {
+	break;
+      }
+    }
+    if (*p1 != ')') {
+      goto err1;
+    }
+    ++p1;
+  }
+  if (*p1) {
+    goto err1;
+  }
+  
+  //----- find the command
+  a = -1;
+  b = nCmds;
+  // invariant: cmdTab[a].name < name < cmdTab[b].name
+  while (b - a > 1) {
+    m = (a + b) / 2;
+    cmp = strcmp(cmdTab[m].name, name->getCString());
+    if (cmp < 0) {
+      a = m;
+    } else if (cmp > 0) {
+      b = m;
+    } else {
+      a = b = m;
+    }
+  }
+  if (cmp != 0) {
+    goto err1;
+  }
+
+  //----- execute the command
+  if (nArgs != cmdTab[a].nArgs ||
+      (cmdTab[a].requiresEvent && !event)) {
+    goto err1;
+  }
+  if (cmdTab[a].requiresDoc && !core->getDoc()) {
+    // don't issue an error message for this -- it happens, e.g., when
+    // clicking in a window with no open PDF file
+    goto err2;
+  }
+  (this->*cmdTab[a].func)(args, nArgs, event);
+
+  //----- clean up
+  delete name;
+  for (i = 0; i < nArgs; ++i) {
+    if (args[i]) {
+      delete args[i];
+    }
+  }
+  return;
+
+ err1:
+  error(-1, "Invalid command syntax: '%s'", cmd->getCString());
+ err2:
+  if (name) {
+    delete name;
+  }
+  for (i = 0; i < nArgs; ++i) {
+    if (args[i]) {
+      delete args[i];
+    }
+  }
+}
+
+//------------------------------------------------------------------------
+// command functions
+//------------------------------------------------------------------------
+
+static int mouseX(XEvent *event) {
+  switch (event->type) {
+  case ButtonPress:
+  case ButtonRelease:
+    return event->xbutton.x;
+  case KeyPress:
+    return event->xkey.x;
+  }
+  return 0;
+}
+
+static int mouseY(XEvent *event) {
+  switch (event->type) {
+  case ButtonPress:
+  case ButtonRelease:
+    return event->xbutton.y;
+  case KeyPress:
+    return event->xkey.y;
+  }
+  return 0;
+}
+
+void XPDFViewer::cmdAbout(GString *args[], int nArgs,
+			  XEvent *event) {
+  XtManageChild(aboutDialog);
+}
+
+void XPDFViewer::cmdCloseOutline(GString *args[], int nArgs,
+				 XEvent *event) {
+#ifndef DISABLE_OUTLINE
+  Dimension w;
+
+  if (outlineScroll == None) {
+    return;
+  }
+  XtVaGetValues(outlineScroll, XmNwidth, &w, NULL);
+  if (w > 1) {
+    outlinePaneWidth = w;
+    // this ugly kludge is apparently the only way to resize the panes
+    // within an XmPanedWindow
+    XtVaSetValues(outlineScroll, XmNpaneMinimum, 1,
+		  XmNpaneMaximum, 1, NULL);
+    XtVaSetValues(outlineScroll, XmNpaneMinimum, 1,
+		  XmNpaneMaximum, 10000, NULL);
+  }
+#endif
+}
+
+void XPDFViewer::cmdCloseWindow(GString *args[], int nArgs,
+				XEvent *event) {
+  app->close(this, gFalse);
+}
+
+void XPDFViewer::cmdContinuousMode(GString *args[], int nArgs,
+				   XEvent *event) {
+  Widget btn;
+
+  if (core->getContinuousMode()) {
+    return;
+  }
+  core->setContinuousMode(gTrue);
+
+  btn = XtNameToWidget(popupMenu, "continuousMode");
+  XtVaSetValues(btn, XmNset, XmSET, NULL);
+}
+
+void XPDFViewer::cmdEndPan(GString *args[], int nArgs,
+			   XEvent *event) {
+  core->endPan(mouseX(event), mouseY(event));
+}
+
+void XPDFViewer::cmdEndSelection(GString *args[], int nArgs,
+				 XEvent *event) {
+  core->endSelection(mouseX(event), mouseY(event));
+}
+
+void XPDFViewer::cmdFind(GString *args[], int nArgs,
+			 XEvent *event) {
+  mapFindDialog();
+}
+
+void XPDFViewer::cmdFindNext(GString *args[], int nArgs,
+			     XEvent *event) {
+  doFind(gTrue);
+}
+
+void XPDFViewer::cmdFocusToDocWin(GString *args[], int nArgs,
+				  XEvent *event) {
+  core->takeFocus();
+}
+
+void XPDFViewer::cmdFocusToPageNum(GString *args[], int nArgs,
+				   XEvent *event) {
+  XmTextFieldSetSelection(pageNumText, 0,
+			  strlen(XmTextFieldGetString(pageNumText)),
+			  XtLastTimestampProcessed(display));
+  XmProcessTraversal(pageNumText, XmTRAVERSE_CURRENT);
+}
+
+void XPDFViewer::cmdFollowLink(GString *args[], int nArgs,
+			       XEvent *event) {
+  doLink(mouseX(event), mouseY(event), gFalse, gFalse);
+}
+
+void XPDFViewer::cmdFollowLinkInNewWin(GString *args[], int nArgs,
+				       XEvent *event) {
+  doLink(mouseX(event), mouseY(event), gFalse, gTrue);
+}
+
+void XPDFViewer::cmdFollowLinkInNewWinNoSel(GString *args[], int nArgs,
+					    XEvent *event) {
+  doLink(mouseX(event), mouseY(event), gTrue, gTrue);
+}
+
+void XPDFViewer::cmdFollowLinkNoSel(GString *args[], int nArgs,
+				    XEvent *event) {
+  doLink(mouseX(event), mouseY(event), gTrue, gFalse);
+}
+
+void XPDFViewer::cmdFullScreenMode(GString *args[], int nArgs,
+				   XEvent *event) {
+  PDFDoc *doc;
+  XPDFViewer *viewer;
+  int pg;
+  Widget btn;
+
+  if (core->getFullScreen()) {
+    return;
+  }
+  pg = core->getPageNum();
+  XtPopdown(win);
+  doc = core->takeDoc(gFalse);
+  viewer = app->reopen(this, doc, pg, gTrue);
+
+  btn = XtNameToWidget(viewer->popupMenu, "fullScreen");
+  XtVaSetValues(btn, XmNset, XmSET, NULL);
+}
+
+void XPDFViewer::cmdGoBackward(GString *args[], int nArgs,
+			       XEvent *event) {
+  core->goBackward();
+}
+
+void XPDFViewer::cmdGoForward(GString *args[], int nArgs,
+			      XEvent *event) {
+  core->goForward();
+}
+
+void XPDFViewer::cmdGotoDest(GString *args[], int nArgs,
+			     XEvent *event) {
+  int pg;
+  LinkDest *dest;
+
+  getPageAndDest(1, args[0], &pg, &dest);
+  if (dest) {
+    displayDest(dest, core->getZoom(), core->getRotate(), gTrue);
+    delete dest;
+  }
+}
+
+void XPDFViewer::cmdGotoLastPage(GString *args[], int nArgs,
+				 XEvent *event) {
+  displayPage(core->getDoc()->getNumPages(),
+	      core->getZoom(), core->getRotate(),
+	      gTrue, gTrue);
+}
+
+void XPDFViewer::cmdGotoLastPageNoScroll(GString *args[], int nArgs,
+					 XEvent *event) {
+  displayPage(core->getDoc()->getNumPages(),
+	      core->getZoom(), core->getRotate(),
+	      gFalse, gTrue);
+}
+
+void XPDFViewer::cmdGotoPage(GString *args[], int nArgs,
+			     XEvent *event) {
+  int pg;
+
+  pg = atoi(args[0]->getCString());
+  if (pg < 1 || pg > core->getDoc()->getNumPages()) {
+    return;
+  }
+  displayPage(pg, core->getZoom(), core->getRotate(), gTrue, gTrue);
+}
+
+void XPDFViewer::cmdGotoPageNoScroll(GString *args[], int nArgs,
+				     XEvent *event) {
+  int pg;
+
+  pg = atoi(args[0]->getCString());
+  if (pg < 1 || pg > core->getDoc()->getNumPages()) {
+    return;
+  }
+  displayPage(pg, core->getZoom(), core->getRotate(), gFalse, gTrue);
+}
+
+void XPDFViewer::cmdNextPage(GString *args[], int nArgs,
+			     XEvent *event) {
+  core->gotoNextPage(1, gTrue);
+}
+
+void XPDFViewer::cmdNextPageNoScroll(GString *args[], int nArgs,
+				     XEvent *event) {
+  core->gotoNextPage(1, gFalse);
+}
+
+void XPDFViewer::cmdOpen(GString *args[], int nArgs,
+			 XEvent *event) {
+  mapOpenDialog(gFalse);
+}
+
+void XPDFViewer::cmdOpenFile(GString *args[], int nArgs,
+			     XEvent *event) {
+  open(args[0], 1, NULL);
+}
+
+void XPDFViewer::cmdOpenFileAtDest(GString *args[], int nArgs,
+				   XEvent *event) {
+  open(args[0], 1, args[1]);
+}
+
+void XPDFViewer::cmdOpenFileAtDestInNewWin(GString *args[], int nArgs,
+					   XEvent *event) {
+  app->openAtDest(args[0], args[1]);
+}
+
+void XPDFViewer::cmdOpenFileAtPage(GString *args[], int nArgs,
+				   XEvent *event) {
+  open(args[0], atoi(args[1]->getCString()), NULL);
+}
+
+void XPDFViewer::cmdOpenFileAtPageInNewWin(GString *args[], int nArgs,
+					   XEvent *event) {
+  app->open(args[0], atoi(args[1]->getCString()));
+}
+
+void XPDFViewer::cmdOpenFileInNewWin(GString *args[], int nArgs,
+				     XEvent *event) {
+  app->open(args[0]);
+}
+
+void XPDFViewer::cmdOpenInNewWin(GString *args[], int nArgs,
+				 XEvent *event) {
+  mapOpenDialog(gTrue);
+}
+
+void XPDFViewer::cmdOpenOutline(GString *args[], int nArgs,
+				XEvent *event) {
+#ifndef DISABLE_OUTLINE
+  Dimension w;
+
+  if (outlineScroll == None) {
+    return;
+  }
+  XtVaGetValues(outlineScroll, XmNwidth, &w, NULL);
+  if (w == 1) {
+    // this ugly kludge is apparently the only way to resize the panes
+    // within an XmPanedWindow
+    XtVaSetValues(outlineScroll, XmNpaneMinimum, outlinePaneWidth,
+		  XmNpaneMaximum, outlinePaneWidth, NULL);
+    XtVaSetValues(outlineScroll, XmNpaneMinimum, 1,
+		  XmNpaneMaximum, 10000, NULL);
+  }
+#endif
+}
+
+void XPDFViewer::cmdPageDown(GString *args[], int nArgs,
+			     XEvent *event) {
+  core->scrollPageDown();
+}
+
+void XPDFViewer::cmdPageUp(GString *args[], int nArgs,
+			   XEvent *event) {
+  core->scrollPageUp();
+}
+
+void XPDFViewer::cmdPostPopupMenu(GString *args[], int nArgs,
+				  XEvent *event) {
+  XmMenuPosition(popupMenu, event->type == ButtonPress ? &event->xbutton
+		                                       : (XButtonEvent *)NULL);
+  XtManageChild(popupMenu);
+
+  // this is magic (taken from DDD) - weird things happen if this
+  // call isn't made (this is done in two different places, in hopes
+  // of squashing this stupid bug)
+  XtUngrabButton(core->getDrawAreaWidget(), AnyButton, AnyModifier);
+}
+
+void XPDFViewer::cmdPrevPage(GString *args[], int nArgs,
+			     XEvent *event) {
+  core->gotoPrevPage(1, gTrue, gFalse);
+}
+
+void XPDFViewer::cmdPrevPageNoScroll(GString *args[], int nArgs,
+				     XEvent *event) {
+  core->gotoPrevPage(1, gFalse, gFalse);
+}
+
+void XPDFViewer::cmdPrint(GString *args[], int nArgs,
+			  XEvent *event) {
+  XtManageChild(printDialog);
+}
+
+void XPDFViewer::cmdQuit(GString *args[], int nArgs,
+			 XEvent *event) {
+  app->quit();
+}
+
+void XPDFViewer::cmdRaise(GString *args[], int nArgs,
+			  XEvent *event) {
+  XMapRaised(display, XtWindow(win));
+  XFlush(display);
+}
+
+void XPDFViewer::cmdRedraw(GString *args[], int nArgs,
+			   XEvent *event) {
+  displayPage(core->getPageNum(), core->getZoom(), core->getRotate(),
+	      gFalse, gFalse);
+}
+
+void XPDFViewer::cmdReload(GString *args[], int nArgs,
+			   XEvent *event) {
+  reloadFile();
+}
+
+void XPDFViewer::cmdRun(GString *args[], int nArgs,
+			XEvent *event) {
+  GString *fmt, *cmd, *s;
+  LinkAction *action;
+  double selLRX, selLRY, selURX, selURY;
+  int selPage;
+  GBool gotSel;
+  char buf[64];
+  char *p;
+  char c0, c1;
+  int i;
+
+  cmd = new GString();
+  fmt = args[0];
+  i = 0;
+  gotSel = gFalse;
+  while (i < fmt->getLength()) {
+    c0 = fmt->getChar(i);
+    if (c0 == '%' && i+1 < fmt->getLength()) {
+      c1 = fmt->getChar(i+1);
+      switch (c1) {
+      case 'f':
+	if (core->getDoc() && (s = core->getDoc()->getFileName())) {
+	  cmd->append(s);
+	}
+	break;
+      case 'b':
+	if (core->getDoc() && (s = core->getDoc()->getFileName())) {
+	  if ((p = strrchr(s->getCString(), '.'))) {
+	    cmd->append(s->getCString(), p - s->getCString());
+	  } else {
+	    cmd->append(s);
+	  }
+	}
+	break;
+      case 'u':
+	if ((action = core->getLinkAction()) &&
+	    action->getKind() == actionURI) {
+	  s = core->mungeURL(((LinkURI *)action)->getURI());
+	  cmd->append(s);
+	  delete s;
+	}
+	break;
+      case 'x':
+      case 'y':
+      case 'X':
+      case 'Y':
+	if (!gotSel) {
+	  if (!core->getSelection(&selPage, &selURX, &selURY,
+				  &selLRX, &selLRY)) {
+	    selPage = 0;
+	    selURX = selURY = selLRX = selLRY = 0;
+	  }
+	  gotSel = gTrue;
+	}
+	sprintf(buf, "%g",
+		(c1 == 'x') ? selURX :
+		(c1 == 'y') ? selURY :
+		(c1 == 'X') ? selLRX : selLRY);
+	cmd->append(buf);
+	break;
+      default:
+	cmd->append(c1);
+	break;
+      }
+      i += 2;
+    } else {
+      cmd->append(c0);
+      ++i;
+    }
+  }
+#ifdef VMS
+  cmd->insert(0, "spawn/nowait ");
+#elif defined(__EMX__)
+  cmd->insert(0, "start /min /n ");
+#else
+  cmd->append(" &");
+#endif
+  system(cmd->getCString());
+  delete cmd;
+}
+
+void XPDFViewer::cmdScrollDown(GString *args[], int nArgs,
+			       XEvent *event) {
+  core->scrollDown(atoi(args[0]->getCString()));
+}
+
+void XPDFViewer::cmdScrollDownNextPage(GString *args[], int nArgs,
+				       XEvent *event) {
+  core->scrollDownNextPage(atoi(args[0]->getCString()));
+}
+
+void XPDFViewer::cmdScrollLeft(GString *args[], int nArgs,
+			       XEvent *event) {
+  core->scrollLeft(atoi(args[0]->getCString()));
+}
+
+void XPDFViewer::cmdScrollOutlineDown(GString *args[], int nArgs,
+				      XEvent *event) {
+#ifndef DISABLE_OUTLINE
+  Widget sb;
+  int val, inc, pageInc, m, slider;
+
+  if (outlineScroll == None) {
+    return;
+  }
+  if ((sb = XtNameToWidget(outlineScroll, "VertScrollBar"))) {
+    XtVaGetValues(sb, XmNvalue, &val, XmNincrement, &inc,
+		  XmNpageIncrement, &pageInc, XmNmaximum, &m,
+		  XmNsliderSize, &slider, NULL);
+    if ((val += inc * atoi(args[0]->getCString())) > m - slider) {
+      val = m - slider;
+    }
+    XmScrollBarSetValues(sb, val, slider, inc, pageInc, True);
+  }
+#endif
+}
+
+void XPDFViewer::cmdScrollOutlineUp(GString *args[], int nArgs,
+				    XEvent *event) {
+#ifndef DISABLE_OUTLINE
+  Widget sb;
+  int val, inc, pageInc, m, slider;
+
+  if (outlineScroll == None) {
+    return;
+  }
+  if ((sb = XtNameToWidget(outlineScroll, "VertScrollBar"))) {
+    XtVaGetValues(sb, XmNvalue, &val, XmNincrement, &inc,
+		  XmNpageIncrement, &pageInc, XmNminimum, &m,
+		  XmNsliderSize, &slider, NULL);
+    if ((val -= inc * atoi(args[0]->getCString())) < m) {
+      val = m;
+    }
+    XmScrollBarSetValues(sb, val, slider, inc, pageInc, True);
+  }
+#endif
+}
+
+void XPDFViewer::cmdScrollRight(GString *args[], int nArgs,
+				XEvent *event) {
+  core->scrollRight(atoi(args[0]->getCString()));
+}
+
+void XPDFViewer::cmdScrollToBottomEdge(GString *args[], int nArgs,
+				       XEvent *event) {
+  core->scrollToBottomEdge();
+}
+
+void XPDFViewer::cmdScrollToBottomRight(GString *args[], int nArgs,
+					XEvent *event) {
+  core->scrollToBottomRight();
+}
+
+void XPDFViewer::cmdScrollToLeftEdge(GString *args[], int nArgs,
+				     XEvent *event) {
+  core->scrollToLeftEdge();
+}
+
+void XPDFViewer::cmdScrollToRightEdge(GString *args[], int nArgs,
+				      XEvent *event) {
+  core->scrollToRightEdge();
+}
+
+void XPDFViewer::cmdScrollToTopEdge(GString *args[], int nArgs,
+				    XEvent *event) {
+  core->scrollToTopEdge();
+}
+
+void XPDFViewer::cmdScrollToTopLeft(GString *args[], int nArgs,
+				    XEvent *event) {
+  core->scrollToTopLeft();
+}
+
+void XPDFViewer::cmdScrollUp(GString *args[], int nArgs,
+			     XEvent *event) {
+  core->scrollUp(atoi(args[0]->getCString()));
+}
+
+void XPDFViewer::cmdScrollUpPrevPage(GString *args[], int nArgs,
+				     XEvent *event) {
+  core->scrollUpPrevPage(atoi(args[0]->getCString()));
+}
+
+void XPDFViewer::cmdSinglePageMode(GString *args[], int nArgs,
+				   XEvent *event) {
+  Widget btn;
+
+  if (!core->getContinuousMode()) {
+    return;
+  }
+  core->setContinuousMode(gFalse);
+
+  btn = XtNameToWidget(popupMenu, "continuousMode");
+  XtVaSetValues(btn, XmNset, XmUNSET, NULL);
+}
+
+void XPDFViewer::cmdStartPan(GString *args[], int nArgs,
+			     XEvent *event) {
+  core->startPan(mouseX(event), mouseY(event));
+}
+
+void XPDFViewer::cmdStartSelection(GString *args[], int nArgs,
+				   XEvent *event) {
+  core->startSelection(mouseX(event), mouseY(event));
+}
+
+void XPDFViewer::cmdToggleContinuousMode(GString *args[], int nArgs,
+					 XEvent *event) {
+  if (core->getContinuousMode()) {
+    cmdSinglePageMode(NULL, 0, event);
+  } else {
+    cmdContinuousMode(NULL, 0, event);
+  }
+}
+
+void XPDFViewer::cmdToggleFullScreenMode(GString *args[], int nArgs,
+					 XEvent *event) {
+  if (core->getFullScreen()) {
+    cmdWindowMode(NULL, 0, event);
+  } else {
+    cmdFullScreenMode(NULL, 0, event);
+  }
+}
+
+void XPDFViewer::cmdToggleOutline(GString *args[], int nArgs,
+				  XEvent *event) {
+#ifndef DISABLE_OUTLINE
+  Dimension w;
+
+  if (outlineScroll == None) {
+    return;
+  }
+  XtVaGetValues(outlineScroll, XmNwidth, &w, NULL);
+  if (w > 1) {
+    cmdCloseOutline(NULL, 0, event);
+  } else {
+    cmdOpenOutline(NULL, 0, event);
+  }
+#endif
+}
+
+void XPDFViewer::cmdWindowMode(GString *args[], int nArgs,
+			       XEvent *event) {
+  PDFDoc *doc;
+  XPDFViewer *viewer;
+  int pg;
+  Widget btn;
+
+  if (!core->getFullScreen()) {
+    return;
+  }
+  pg = core->getPageNum();
+  XtPopdown(win);
+  doc = core->takeDoc(gFalse);
+  viewer = app->reopen(this, doc, pg, gFalse);
+
+  btn = XtNameToWidget(viewer->popupMenu, "fullScreen");
+  XtVaSetValues(btn, XmNset, XmUNSET, NULL);
+}
+
+void XPDFViewer::cmdZoomFitPage(GString *args[], int nArgs,
+				XEvent *event) {
+  if (core->getZoom() != zoomPage) {
+    setZoomIdx(zoomPageIdx);
+    displayPage(core->getPageNum(), zoomPage,
+		core->getRotate(), gTrue, gFalse);
+  }
+}
+
+void XPDFViewer::cmdZoomFitWidth(GString *args[], int nArgs,
+				 XEvent *event) {
+  if (core->getZoom() != zoomWidth) {
+    setZoomIdx(zoomWidthIdx);
+    displayPage(core->getPageNum(), zoomWidth,
+		core->getRotate(), gTrue, gFalse);
+  }
+}
+
+void XPDFViewer::cmdZoomIn(GString *args[], int nArgs,
+			   XEvent *event) {
+  int z;
+
+  z = getZoomIdx();
+  if (z <= minZoomIdx && z > maxZoomIdx) {
+    --z;
+    setZoomIdx(z);
+    displayPage(core->getPageNum(), zoomMenuInfo[z].zoom,
+		core->getRotate(), gTrue, gFalse);
+  }
+}
+
+void XPDFViewer::cmdZoomOut(GString *args[], int nArgs,
+			    XEvent *event) {
+  int z;
+
+  z = getZoomIdx();
+  if (z < minZoomIdx && z >= maxZoomIdx) {
+    ++z;
+    setZoomIdx(z);
+    displayPage(core->getPageNum(), zoomMenuInfo[z].zoom,
+		core->getRotate(), gTrue, gFalse);
+  }
+}
+
+void XPDFViewer::cmdZoomPercent(GString *args[], int nArgs,
+				XEvent *event) {
+  double z;
+
+  z = atof(args[0]->getCString());
+  setZoomVal(z);
+  displayPage(core->getPageNum(), z, core->getRotate(), gTrue, gFalse);
+}
+
+void XPDFViewer::cmdZoomToSelection(GString *args[], int nArgs,
+				    XEvent *event) {
+  int pg;
+  double ulx, uly, lrx, lry;
+
+  if (core->getSelection(&pg, &ulx, &uly, &lrx, &lry)) {
+    core->zoomToRect(pg, ulx, uly, lrx, lry);
+  }
+}
+
+//------------------------------------------------------------------------
+// GUI code: main window
+//------------------------------------------------------------------------
+
+void XPDFViewer::initWindow(GBool fullScreen) {
+  Colormap colormap;
+  XColor xcol;
+  Atom state, val;
+  Arg args[20];
+  int n;
+  char *title;
+
+  display = XtDisplay(app->getAppShell());
+  screenNum = XScreenNumberOfScreen(XtScreen(app->getAppShell()));
+
+  toolBar = None;
+#ifndef DISABLE_OUTLINE
+  outlineScroll = None;
+#endif
+
+  // private colormap
+  if (app->getInstallCmap()) {
+    XtVaGetValues(app->getAppShell(), XmNcolormap, &colormap, NULL);
+    // ensure that BlackPixel and WhitePixel are reserved in the
+    // new colormap
+    xcol.red = xcol.green = xcol.blue = 0;
+    XAllocColor(display, colormap, &xcol);
+    xcol.red = xcol.green = xcol.blue = 65535;
+    XAllocColor(display, colormap, &xcol);
+    colormap = XCopyColormapAndFree(display, colormap);
+  }
+
+  // top-level window
+  n = 0;
+  title = app->getTitle() ? app->getTitle()->getCString()
+                          : (char *)xpdfAppName;
+  XtSetArg(args[n], XmNtitle, title); ++n;
+  XtSetArg(args[n], XmNiconName, title); ++n;
+  XtSetArg(args[n], XmNminWidth, 100); ++n;
+  XtSetArg(args[n], XmNminHeight, 100); ++n;
+  XtSetArg(args[n], XmNbaseWidth, 0); ++n;
+  XtSetArg(args[n], XmNbaseHeight, 0); ++n;
+  XtSetArg(args[n], XmNdeleteResponse, XmDO_NOTHING); ++n;
+  win = XtCreatePopupShell("win", topLevelShellWidgetClass,
+			   app->getAppShell(), args, n);
+  if (app->getInstallCmap()) {
+    XtVaSetValues(win, XmNcolormap, colormap, NULL);
+  }
+  XmAddWMProtocolCallback(win, XInternAtom(display, "WM_DELETE_WINDOW", False),
+			  &closeMsgCbk, this);
+
+  // create the full-screen window
+  if (fullScreen) {
+    initCore(win, gTrue);
+
+  // create the normal (non-full-screen) window
+  } else {
+    if (app->getGeometry()) {
+      n = 0;
+      XtSetArg(args[n], XmNgeometry, app->getGeometry()->getCString()); ++n;
+      XtSetValues(win, args, n);
+    }
+
+    n = 0;
+    form = XmCreateForm(win, "form", args, n);
+    XtManageChild(form);
+
+#ifdef DISABLE_OUTLINE
+    initToolbar(form);
+    n = 0;
+    XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); ++n;
+    XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); ++n;
+    XtSetArg(args[n], XmNbottomAttachment, XmATTACH_FORM); ++n;
+    XtSetValues(toolBar, args, n);
+
+    initCore(form, gFalse);
+    n = 0;
+    XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); ++n;
+    XtSetArg(args[n], XmNbottomAttachment, XmATTACH_WIDGET); ++n;
+    XtSetArg(args[n], XmNbottomWidget, toolBar); ++n;
+    XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); ++n;
+    XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); ++n;
+    XtSetValues(core->getWidget(), args, n);
+#else
+    initToolbar(form);
+    n = 0;
+    XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); ++n;
+    XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); ++n;
+    XtSetArg(args[n], XmNbottomAttachment, XmATTACH_FORM); ++n;
+    XtSetValues(toolBar, args, n);
+
+    initPanedWin(form);
+    n = 0;
+    XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); ++n;
+    XtSetArg(args[n], XmNbottomAttachment, XmATTACH_WIDGET); ++n;
+    XtSetArg(args[n], XmNbottomWidget, toolBar); ++n;
+    XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); ++n;
+    XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); ++n;
+    XtSetValues(panedWin, args, n);
+
+    initCore(panedWin, fullScreen);
+    n = 0;
+    XtSetArg(args[n], XmNpositionIndex, 1); ++n;
+    XtSetArg(args[n], XmNallowResize, True); ++n;
+    XtSetArg(args[n], XmNpaneMinimum, 1); ++n;
+    XtSetArg(args[n], XmNpaneMaximum, 10000); ++n;
+    XtSetValues(core->getWidget(), args, n);
+#endif
+  }
+
+  // set the zoom menu to match the initial zoom setting
+  setZoomVal(core->getZoom());
+
+  // set traversal order
+  XtVaSetValues(core->getDrawAreaWidget(),
+		XmNnavigationType, XmEXCLUSIVE_TAB_GROUP, NULL);
+  if (toolBar != None) {
+    XtVaSetValues(backBtn, XmNnavigationType, XmEXCLUSIVE_TAB_GROUP,
+		  NULL);
+    XtVaSetValues(prevTenPageBtn, XmNnavigationType, XmEXCLUSIVE_TAB_GROUP,
+		  NULL);
+    XtVaSetValues(prevPageBtn, XmNnavigationType, XmEXCLUSIVE_TAB_GROUP,
+		  NULL);
+    XtVaSetValues(nextPageBtn, XmNnavigationType, XmEXCLUSIVE_TAB_GROUP,
+		  NULL);
+    XtVaSetValues(nextTenPageBtn, XmNnavigationType, XmEXCLUSIVE_TAB_GROUP,
+		  NULL);
+    XtVaSetValues(forwardBtn, XmNnavigationType, XmEXCLUSIVE_TAB_GROUP,
+		  NULL);
+    XtVaSetValues(pageNumText, XmNnavigationType, XmEXCLUSIVE_TAB_GROUP,
+		  NULL);
+    XtVaSetValues(zoomWidget, XmNnavigationType, XmEXCLUSIVE_TAB_GROUP,
+		  NULL);
+    XtVaSetValues(findBtn, XmNnavigationType, XmEXCLUSIVE_TAB_GROUP,
+		  NULL);
+    XtVaSetValues(printBtn, XmNnavigationType, XmEXCLUSIVE_TAB_GROUP,
+		  NULL);
+    XtVaSetValues(aboutBtn, XmNnavigationType, XmEXCLUSIVE_TAB_GROUP,
+		  NULL);
+    XtVaSetValues(quitBtn, XmNnavigationType, XmEXCLUSIVE_TAB_GROUP,
+		  NULL);
+  }
+
+  initPopupMenu();
+
+  if (fullScreen) {
+    // Set both the old-style Motif decorations hint and the new-style
+    // _NET_WM_STATE property.  This is redundant, but might be useful
+    // for older window managers.  We also set the geometry to +0+0 to
+    // avoid interactive placement.  (Note: we need to realize the
+    // shell, so it has a Window on which to set the _NET_WM_STATE
+    // property, but we don't want to map it until later, so we set
+    // mappedWhenManaged to false.)
+    n = 0;
+    XtSetArg(args[n], XmNmappedWhenManaged, False); ++n;
+    XtSetArg(args[n], XmNmwmDecorations, 0); ++n;
+    XtSetArg(args[n], XmNgeometry, "+0+0"); ++n;
+    XtSetValues(win, args, n);
+    XtRealizeWidget(win);
+    state = XInternAtom(display, "_NET_WM_STATE", False);
+    val = XInternAtom(display, "_NET_WM_STATE_FULLSCREEN", False);
+    XChangeProperty(display, XtWindow(win), state, XA_ATOM, 32,
+		    PropModeReplace, (Guchar *)&val, 1);
+  }
+}
+
+void XPDFViewer::initToolbar(Widget parent) {
+  Widget label, lastBtn;
+#ifndef USE_COMBO_BOX
+  Widget btn;
+#endif
+  Arg args[20];
+  int n;
+  XmString s, emptyString;
+  int i;
+
+  // toolbar
+  n = 0;
+  toolBar = XmCreateForm(parent, "toolBar", args, n);
+  XtManageChild(toolBar);
+
+  // create an empty string -- this is used for buttons that will get
+  // pixmaps later
+  emptyString = XmStringCreateLocalized("");
+
+  // page movement buttons
+  n = 0;
+  XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); ++n;
+  XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); ++n;
+  XtSetArg(args[n], XmNbottomAttachment, XmATTACH_FORM); ++n;
+  XtSetArg(args[n], XmNmarginWidth, 6); ++n;
+  XtSetArg(args[n], XmNsensitive, False); ++n;
+  XtSetArg(args[n], XmNlabelString, emptyString); ++n;
+  backBtn = XmCreatePushButton(toolBar, "back", args, n);
+  addToolTip(backBtn, "Back");
+  XtManageChild(backBtn);
+  XtAddCallback(backBtn, XmNactivateCallback,
+		&backCbk, (XtPointer)this);
+  n = 0;
+  XtSetArg(args[n], XmNleftAttachment, XmATTACH_WIDGET); ++n;
+  XtSetArg(args[n], XmNleftWidget, backBtn); ++n;
+  XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); ++n;
+  XtSetArg(args[n], XmNbottomAttachment, XmATTACH_FORM); ++n;
+  XtSetArg(args[n], XmNmarginWidth, 6); ++n;
+  XtSetArg(args[n], XmNsensitive, False); ++n;
+  XtSetArg(args[n], XmNlabelString, emptyString); ++n;
+  prevTenPageBtn = XmCreatePushButton(toolBar, "prevTenPage", args, n);
+  addToolTip(prevTenPageBtn, "-10 pages");
+  XtManageChild(prevTenPageBtn);
+  XtAddCallback(prevTenPageBtn, XmNactivateCallback,
+		&prevTenPageCbk, (XtPointer)this);
+  n = 0;
+  XtSetArg(args[n], XmNleftAttachment, XmATTACH_WIDGET); ++n;
+  XtSetArg(args[n], XmNleftWidget, prevTenPageBtn); ++n;
+  XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); ++n;
+  XtSetArg(args[n], XmNbottomAttachment, XmATTACH_FORM); ++n;
+  XtSetArg(args[n], XmNmarginWidth, 6); ++n;
+  XtSetArg(args[n], XmNsensitive, False); ++n;
+  XtSetArg(args[n], XmNlabelString, emptyString); ++n;
+  prevPageBtn = XmCreatePushButton(toolBar, "prevPage", args, n);
+  addToolTip(prevPageBtn, "Previous page");
+  XtManageChild(prevPageBtn);
+  XtAddCallback(prevPageBtn, XmNactivateCallback,
+		&prevPageCbk, (XtPointer)this);
+  n = 0;
+  XtSetArg(args[n], XmNleftAttachment, XmATTACH_WIDGET); ++n;
+  XtSetArg(args[n], XmNleftWidget, prevPageBtn); ++n;
+  XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); ++n;
+  XtSetArg(args[n], XmNbottomAttachment, XmATTACH_FORM); ++n;
+  XtSetArg(args[n], XmNmarginWidth, 6); ++n;
+  XtSetArg(args[n], XmNsensitive, False); ++n;
+  XtSetArg(args[n], XmNlabelString, emptyString); ++n;
+  nextPageBtn = XmCreatePushButton(toolBar, "nextPage", args, n);
+  addToolTip(nextPageBtn, "Next page");
+  XtManageChild(nextPageBtn);
+  XtAddCallback(nextPageBtn, XmNactivateCallback,
+		&nextPageCbk, (XtPointer)this);
+  n = 0;
+  XtSetArg(args[n], XmNleftAttachment, XmATTACH_WIDGET); ++n;
+  XtSetArg(args[n], XmNleftWidget, nextPageBtn); ++n;
+  XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); ++n;
+  XtSetArg(args[n], XmNbottomAttachment, XmATTACH_FORM); ++n;
+  XtSetArg(args[n], XmNmarginWidth, 6); ++n;
+  XtSetArg(args[n], XmNsensitive, False); ++n;
+  XtSetArg(args[n], XmNlabelString, emptyString); ++n;
+  nextTenPageBtn = XmCreatePushButton(toolBar, "nextTenPage", args, n);
+  addToolTip(nextTenPageBtn, "+10 pages");
+  XtManageChild(nextTenPageBtn);
+  XtAddCallback(nextTenPageBtn, XmNactivateCallback,
+		&nextTenPageCbk, (XtPointer)this);
+  n = 0;
+  XtSetArg(args[n], XmNleftAttachment, XmATTACH_WIDGET); ++n;
+  XtSetArg(args[n], XmNleftWidget, nextTenPageBtn); ++n;
+  XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); ++n;
+  XtSetArg(args[n], XmNbottomAttachment, XmATTACH_FORM); ++n;
+  XtSetArg(args[n], XmNmarginWidth, 6); ++n;
+  XtSetArg(args[n], XmNsensitive, False); ++n;
+  XtSetArg(args[n], XmNlabelString, emptyString); ++n;
+  forwardBtn = XmCreatePushButton(toolBar, "forward", args, n);
+  addToolTip(forwardBtn, "Forward");
+  XtManageChild(forwardBtn);
+  XtAddCallback(forwardBtn, XmNactivateCallback,
+		&forwardCbk, (XtPointer)this);
+
+  // page number display
+  n = 0;
+  XtSetArg(args[n], XmNleftAttachment, XmATTACH_WIDGET); ++n;
+  XtSetArg(args[n], XmNleftWidget, forwardBtn); ++n;
+  XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); ++n;
+  XtSetArg(args[n], XmNbottomAttachment, XmATTACH_FORM); ++n;
+  s = XmStringCreateLocalized("Page ");
+  XtSetArg(args[n], XmNlabelString, s); ++n;
+  label = XmCreateLabel(toolBar, "pageLabel", args, n);
+  XmStringFree(s);
+  XtManageChild(label);
+  n = 0;
+  XtSetArg(args[n], XmNleftAttachment, XmATTACH_WIDGET); ++n;
+  XtSetArg(args[n], XmNleftWidget, label); ++n;
+  XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); ++n;
+  XtSetArg(args[n], XmNbottomAttachment, XmATTACH_FORM); ++n;
+  XtSetArg(args[n], XmNmarginWidth, 3); ++n;
+  XtSetArg(args[n], XmNmarginHeight, 3); ++n;
+  XtSetArg(args[n], XmNcolumns, 5); ++n;
+  pageNumText = XmCreateTextField(toolBar, "pageNum", args, n);
+  XtManageChild(pageNumText);
+  XtAddCallback(pageNumText, XmNactivateCallback,
+		&pageNumCbk, (XtPointer)this);
+  n = 0;
+  XtSetArg(args[n], XmNleftAttachment, XmATTACH_WIDGET); ++n;
+  XtSetArg(args[n], XmNleftWidget, pageNumText); ++n;
+  XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); ++n;
+  XtSetArg(args[n], XmNbottomAttachment, XmATTACH_FORM); ++n;
+  s = XmStringCreateLocalized(" of 00000");
+  XtSetArg(args[n], XmNlabelString, s); ++n;
+  XtSetArg(args[n], XmNalignment, XmALIGNMENT_BEGINNING); ++n;
+  XtSetArg(args[n], XmNrecomputeSize, False); ++n;
+  pageCountLabel = XmCreateLabel(toolBar, "pageCountLabel", args, n);
+  XmStringFree(s);
+  XtManageChild(pageCountLabel);
+  s = XmStringCreateLocalized(" of 0");
+  XtVaSetValues(pageCountLabel, XmNlabelString, s, NULL);
+  XmStringFree(s);
+
+  // zoom menu
+#if USE_COMBO_BOX
+  XmString st[nZoomMenuItems];
+  n = 0;
+  XtSetArg(args[n], XmNleftAttachment, XmATTACH_WIDGET); ++n;
+  XtSetArg(args[n], XmNleftWidget, pageCountLabel); ++n;
+  XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); ++n;
+  XtSetArg(args[n], XmNbottomAttachment, XmATTACH_FORM); ++n;
+  XtSetArg(args[n], XmNmarginWidth, 0); ++n;
+  XtSetArg(args[n], XmNmarginHeight, 0); ++n;
+  XtSetArg(args[n], XmNcomboBoxType, XmDROP_DOWN_COMBO_BOX); ++n;
+  XtSetArg(args[n], XmNpositionMode, XmONE_BASED); ++n;
+  XtSetArg(args[n], XmNcolumns, 7); ++n;
+  for (i = 0; i < nZoomMenuItems; ++i) {
+    st[i] = XmStringCreateLocalized(zoomMenuInfo[i].label);
+  }
+  XtSetArg(args[n], XmNitems, st); ++n;
+  XtSetArg(args[n], XmNitemCount, nZoomMenuItems); ++n;
+  zoomComboBox = XmCreateComboBox(toolBar, "zoomComboBox", args, n);
+  for (i = 0; i < nZoomMenuItems; ++i) {
+    XmStringFree(st[i]);
+  }
+  addToolTip(zoomComboBox, "Zoom");
+  XtAddCallback(zoomComboBox, XmNselectionCallback,
+		&zoomComboBoxCbk, (XtPointer)this);
+  XtManageChild(zoomComboBox);
+  zoomWidget = zoomComboBox;
+#else
+  Widget menuPane;
+  char buf[16];
+  n = 0;
+  menuPane = XmCreatePulldownMenu(toolBar, "zoomMenuPane", args, n);
+  for (i = 0; i < nZoomMenuItems; ++i) {
+    n = 0;
+    s = XmStringCreateLocalized(zoomMenuInfo[i].label);
+    XtSetArg(args[n], XmNlabelString, s); ++n;
+    XtSetArg(args[n], XmNuserData, (XtPointer)i); ++n;
+    sprintf(buf, "zoom%d", i);
+    btn = XmCreatePushButton(menuPane, buf, args, n);
+    XmStringFree(s);
+    XtManageChild(btn);
+    XtAddCallback(btn, XmNactivateCallback,
+		  &zoomMenuCbk, (XtPointer)this);
+    zoomMenuBtns[i] = btn;
+  }
+  n = 0;
+  XtSetArg(args[n], XmNleftAttachment, XmATTACH_WIDGET); ++n;
+  XtSetArg(args[n], XmNleftWidget, pageCountLabel); ++n;
+  XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); ++n;
+  XtSetArg(args[n], XmNbottomAttachment, XmATTACH_FORM); ++n;
+  XtSetArg(args[n], XmNmarginWidth, 0); ++n;
+  XtSetArg(args[n], XmNmarginHeight, 0); ++n;
+  XtSetArg(args[n], XmNsubMenuId, menuPane); ++n;
+  zoomMenu = XmCreateOptionMenu(toolBar, "zoomMenu", args, n);
+  addToolTip(zoomMenu, "Zoom");
+  XtManageChild(zoomMenu);
+  zoomWidget = zoomMenu;
+#endif
+
+  // find/print/about buttons
+  n = 0;
+  XtSetArg(args[n], XmNleftAttachment, XmATTACH_WIDGET); ++n;
+  XtSetArg(args[n], XmNleftWidget, zoomWidget); ++n;
+  XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); ++n;
+  XtSetArg(args[n], XmNbottomAttachment, XmATTACH_FORM); ++n;
+  XtSetArg(args[n], XmNmarginWidth, 6); ++n;
+  XtSetArg(args[n], XmNlabelString, emptyString); ++n;
+  findBtn = XmCreatePushButton(toolBar, "find", args, n);
+  addToolTip(findBtn, "Find");
+  XtManageChild(findBtn);
+  XtAddCallback(findBtn, XmNactivateCallback,
+		&findCbk, (XtPointer)this);
+  n = 0;
+  XtSetArg(args[n], XmNleftAttachment, XmATTACH_WIDGET); ++n;
+  XtSetArg(args[n], XmNleftWidget, findBtn); ++n;
+  XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); ++n;
+  XtSetArg(args[n], XmNbottomAttachment, XmATTACH_FORM); ++n;
+  XtSetArg(args[n], XmNmarginWidth, 6); ++n;
+  XtSetArg(args[n], XmNlabelString, emptyString); ++n;
+  printBtn = XmCreatePushButton(toolBar, "print", args, n);
+  addToolTip(printBtn, "Print");
+  XtManageChild(printBtn);
+  XtAddCallback(printBtn, XmNactivateCallback,
+		&printCbk, (XtPointer)this);
+  n = 0;
+  XtSetArg(args[n], XmNleftAttachment, XmATTACH_WIDGET); ++n;
+  XtSetArg(args[n], XmNleftWidget, printBtn); ++n;
+  XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); ++n;
+  XtSetArg(args[n], XmNbottomAttachment, XmATTACH_FORM); ++n;
+  XtSetArg(args[n], XmNmarginWidth, 6); ++n;
+  XtSetArg(args[n], XmNlabelString, emptyString); ++n;
+  aboutBtn = XmCreatePushButton(toolBar, "about", args, n);
+  addToolTip(aboutBtn, "About / help");
+  XtManageChild(aboutBtn);
+  XtAddCallback(aboutBtn, XmNactivateCallback,
+		&aboutCbk, (XtPointer)this);
+  lastBtn = aboutBtn;
+
+  // quit button
+  n = 0;
+  XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); ++n;
+  XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); ++n;
+  XtSetArg(args[n], XmNbottomAttachment, XmATTACH_FORM); ++n;
+  XtSetArg(args[n], XmNmarginWidth, 6); ++n;
+  s = XmStringCreateLocalized("Quit");
+  XtSetArg(args[n], XmNlabelString, s); ++n;
+  quitBtn = XmCreatePushButton(toolBar, "quit", args, n);
+  XmStringFree(s);
+  XtManageChild(quitBtn);
+  XtAddCallback(quitBtn, XmNactivateCallback,
+		&quitCbk, (XtPointer)this);
+
+  // link label
+  n = 0;
+  XtSetArg(args[n], XmNleftAttachment, XmATTACH_WIDGET); ++n;
+  XtSetArg(args[n], XmNleftWidget, lastBtn); ++n;
+  XtSetArg(args[n], XmNrightAttachment, XmATTACH_WIDGET); ++n;
+  XtSetArg(args[n], XmNrightWidget, quitBtn); ++n;
+  XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); ++n;
+  XtSetArg(args[n], XmNbottomAttachment, XmATTACH_FORM); ++n;
+  s = XmStringCreateLocalized("");
+  XtSetArg(args[n], XmNlabelString, s); ++n;
+  XtSetArg(args[n], XmNrecomputeSize, True); ++n;
+  XtSetArg(args[n], XmNalignment, XmALIGNMENT_BEGINNING); ++n;
+  linkLabel = XmCreateLabel(toolBar, "linkLabel", args, n);
+  XmStringFree(s);
+  XtManageChild(linkLabel);
+
+  XmStringFree(emptyString);
+}
+
+#ifndef DISABLE_OUTLINE
+void XPDFViewer::initPanedWin(Widget parent) {
+  Widget clipWin;
+  Arg args[20];
+  int n;
+
+  // paned window
+  n = 0;
+  XtSetArg(args[n], XmNorientation, XmHORIZONTAL); ++n;
+#if defined(__sgi) && (XmVERSION <= 1)
+  panedWin = SgCreateHorzPanedWindow(parent, "panedWin", args, n);
+#else
+  panedWin = XmCreatePanedWindow(parent, "panedWin", args, n);
+#endif
+  XtManageChild(panedWin);
+
+  // scrolled window for outline container
+  n = 0;
+  XtSetArg(args[n], XmNpositionIndex, 0); ++n;
+  XtSetArg(args[n], XmNallowResize, True); ++n;
+  XtSetArg(args[n], XmNpaneMinimum, 1); ++n;
+  XtSetArg(args[n], XmNpaneMaximum, 10000); ++n;
+#if !(defined(__sgi) && (XmVERSION <= 1))
+  XtSetArg(args[n], XmNwidth, 1); ++n;
+#endif
+  XtSetArg(args[n], XmNscrollingPolicy, XmAUTOMATIC); ++n;
+  outlineScroll = XmCreateScrolledWindow(panedWin, "outlineScroll", args, n);
+  XtManageChild(outlineScroll);
+  XtVaGetValues(outlineScroll, XmNclipWindow, &clipWin, NULL);
+  XtVaSetValues(clipWin, XmNbackground, app->getPaperPixel(), NULL);
+
+  // outline tree
+  n = 0;
+  XtSetArg(args[n], XmNbackground, app->getPaperPixel()); ++n;
+  outlineTree = XPDFCreateTree(outlineScroll, "outlineTree", args, n);
+  XtManageChild(outlineTree);
+  XtAddCallback(outlineTree, XPDFNselectionCallback, &outlineSelectCbk,
+		(XtPointer)this);
+}
+#endif
+
+void XPDFViewer::initCore(Widget parent, GBool fullScreen) {
+  core = new XPDFCore(win, parent,
+		      app->getPaperRGB(), app->getPaperPixel(),
+		      app->getMattePixel(fullScreen),
+		      fullScreen, app->getReverseVideo(),
+		      app->getInstallCmap(), app->getRGBCubeSize());
+  core->setUpdateCbk(&updateCbk, this);
+  core->setActionCbk(&actionCbk, this);
+  core->setKeyPressCbk(&keyPressCbk, this);
+  core->setMouseCbk(&mouseCbk, this);
+}
+
+void XPDFViewer::initPopupMenu() {
+  Widget btn;
+  Arg args[20];
+  int n;
+  XmString s, s2;
+
+  n = 0;
+#if XmVersion < 1002
+  // older versions of Motif need this, newer ones choke on it,
+  // sometimes not displaying the menu at all, maybe depending on the
+  // state of the NumLock key (taken from DDD)
+  XtSetArg(args[n], XmNmenuPost, "<Btn3Down>"); ++n;
+#endif
+  popupMenu = XmCreatePopupMenu(core->getDrawAreaWidget(), "popupMenu",
+				args, n);
+  n = 0;
+  s = XmStringCreateLocalized("Open...");
+  XtSetArg(args[n], XmNlabelString, s); ++n;
+  s2 = XmStringCreateLocalized("O");
+  XtSetArg(args[n], XmNacceleratorText, s2); ++n;
+  btn = XmCreatePushButton(popupMenu, "open", args, n);
+  XmStringFree(s);
+  XmStringFree(s2);
+  XtManageChild(btn);
+  XtAddCallback(btn, XmNactivateCallback,
+		&openCbk, (XtPointer)this);
+  n = 0;
+  s = XmStringCreateLocalized("Open in new window...");
+  XtSetArg(args[n], XmNlabelString, s); ++n;
+  btn = XmCreatePushButton(popupMenu, "openInNewWindow", args, n);
+  XmStringFree(s);
+  XtManageChild(btn);
+  XtAddCallback(btn, XmNactivateCallback,
+		&openInNewWindowCbk, (XtPointer)this);
+  n = 0;
+  s = XmStringCreateLocalized("Reload");
+  XtSetArg(args[n], XmNlabelString, s); ++n;
+  s2 = XmStringCreateLocalized("R");
+  XtSetArg(args[n], XmNacceleratorText, s2); ++n;
+  btn = XmCreatePushButton(popupMenu, "reload", args, n);
+  XmStringFree(s);
+  XmStringFree(s2);
+  XtManageChild(btn);
+  XtAddCallback(btn, XmNactivateCallback,
+		&reloadCbk, (XtPointer)this);
+  n = 0;
+  s = XmStringCreateLocalized("Save as...");
+  XtSetArg(args[n], XmNlabelString, s); ++n;
+  btn = XmCreatePushButton(popupMenu, "saveAs", args, n);
+  XmStringFree(s);
+  XtManageChild(btn);
+  XtAddCallback(btn, XmNactivateCallback,
+		&saveAsCbk, (XtPointer)this);
+  n = 0;
+  btn = XmCreateSeparator(popupMenu, "sep1", args, n);
+  XtManageChild(btn);
+  n = 0;
+  s = XmStringCreateLocalized("Continuous view");
+  XtSetArg(args[n], XmNlabelString, s); ++n;
+  XtSetArg(args[n], XmNindicatorType, XmN_OF_MANY); ++n;
+  XtSetArg(args[n], XmNvisibleWhenOff, True); ++n;
+  XtSetArg(args[n], XmNset, core->getContinuousMode() ? XmSET : XmUNSET); ++n;
+  btn = XmCreateToggleButton(popupMenu, "continuousMode", args, n);
+  XmStringFree(s);
+  XtManageChild(btn);
+  XtAddCallback(btn, XmNvalueChangedCallback,
+		&continuousModeToggleCbk, (XtPointer)this);
+  n = 0;
+  s = XmStringCreateLocalized("Full screen");
+  XtSetArg(args[n], XmNlabelString, s); ++n;
+  XtSetArg(args[n], XmNindicatorType, XmN_OF_MANY); ++n;
+  XtSetArg(args[n], XmNvisibleWhenOff, True); ++n;
+  XtSetArg(args[n], XmNset, core->getFullScreen() ? XmSET : XmUNSET); ++n;
+  btn = XmCreateToggleButton(popupMenu, "fullScreen", args, n);
+  XmStringFree(s);
+  XtManageChild(btn);
+  XtAddCallback(btn, XmNvalueChangedCallback,
+		&fullScreenToggleCbk, (XtPointer)this);
+  n = 0;
+  s = XmStringCreateLocalized("Rotate counterclockwise");
+  XtSetArg(args[n], XmNlabelString, s); ++n;
+  btn = XmCreatePushButton(popupMenu, "rotateCCW", args, n);
+  XmStringFree(s);
+  XtManageChild(btn);
+  XtAddCallback(btn, XmNactivateCallback,
+		&rotateCCWCbk, (XtPointer)this);
+  n = 0;
+  s = XmStringCreateLocalized("Rotate clockwise");
+  XtSetArg(args[n], XmNlabelString, s); ++n;
+  btn = XmCreatePushButton(popupMenu, "rotateCW", args, n);
+  XmStringFree(s);
+  XtManageChild(btn);
+  XtAddCallback(btn, XmNactivateCallback,
+		&rotateCWCbk, (XtPointer)this);
+  n = 0;
+  s = XmStringCreateLocalized("Zoom to selection");
+  XtSetArg(args[n], XmNlabelString, s); ++n;
+  btn = XmCreatePushButton(popupMenu, "zoomToSelection", args, n);
+  XmStringFree(s);
+  XtManageChild(btn);
+  XtAddCallback(btn, XmNactivateCallback,
+		&zoomToSelectionCbk, (XtPointer)this);
+  n = 0;
+  btn = XmCreateSeparator(popupMenu, "sep2", args, n);
+  XtManageChild(btn);
+  n = 0;
+  s = XmStringCreateLocalized("Close");
+  XtSetArg(args[n], XmNlabelString, s); ++n;
+  s2 = XmStringCreateLocalized("Ctrl+W");
+  XtSetArg(args[n], XmNacceleratorText, s2); ++n;
+  btn = XmCreatePushButton(popupMenu, "close", args, n);
+  XmStringFree(s);
+  XmStringFree(s2);
+  XtManageChild(btn);
+  XtAddCallback(btn, XmNactivateCallback,
+		&closeCbk, (XtPointer)this);
+  n = 0;
+  s = XmStringCreateLocalized("Quit");
+  XtSetArg(args[n], XmNlabelString, s); ++n;
+  s2 = XmStringCreateLocalized("Q");
+  XtSetArg(args[n], XmNacceleratorText, s2); ++n;
+  btn = XmCreatePushButton(popupMenu, "quit", args, n);
+  XmStringFree(s);
+  XmStringFree(s2);
+  XtManageChild(btn);
+  XtAddCallback(btn, XmNactivateCallback,
+		&quitCbk, (XtPointer)this);
+
+  // this is magic (taken from DDD) - weird things happen if this
+  // call isn't made
+  XtUngrabButton(core->getDrawAreaWidget(), AnyButton, AnyModifier);
+}
+
+void XPDFViewer::addToolTip(Widget widget, char *text) {
+#ifdef XmNtoolTipString
+  XmString s;
+  Cardinal n, i;
+  WidgetList children;
+
+  if (XtIsComposite(widget)) {
+    XtVaGetValues(widget, XmNnumChildren, &n, XmNchildren, &children, NULL);
+    for (i = 0; i < n; ++i) {
+      addToolTip(children[i], text);
+    }
+  } else {
+    s = XmStringCreateLocalized(text);
+    XtVaSetValues(widget, XmNtoolTipString, s, NULL);
+    XmStringFree(s);
+  }
+#endif
+}
+
+void XPDFViewer::mapWindow() {
+#ifdef HAVE_X11_XPM_H
+  Pixmap iconPixmap;
+#endif
+  int depth;
+  Pixel fg, bg, arm;
+
+  // show the window
+  XtPopup(win, XtGrabNone);
+  core->takeFocus();
+
+  // create the icon
+#ifdef HAVE_X11_XPM_H
+  if (XpmCreatePixmapFromData(display, XtWindow(win), xpdfIcon,
+			      &iconPixmap, NULL, NULL) == XpmSuccess) {
+    XtVaSetValues(win, XmNiconPixmap, iconPixmap, NULL);
+  }
+#endif
+
+  // set button bitmaps (must be done after the window is mapped)
+  if (toolBar != None) {
+    XtVaGetValues(backBtn, XmNdepth, &depth,
+		  XmNforeground, &fg, XmNbackground, &bg,
+		  XmNarmColor, &arm, NULL);
+    XtVaSetValues(backBtn, XmNlabelType, XmPIXMAP,
+		  XmNlabelPixmap,
+		  XCreatePixmapFromBitmapData(display, XtWindow(toolBar),
+					      (char *)backArrow_bits,
+					      backArrow_width,
+					      backArrow_height,
+					      fg, bg, depth),
+		  XmNarmPixmap,
+		  XCreatePixmapFromBitmapData(display, XtWindow(toolBar),
+					      (char *)backArrow_bits,
+					      backArrow_width,
+					      backArrow_height,
+					      fg, arm, depth),
+		  XmNlabelInsensitivePixmap,
+		  XCreatePixmapFromBitmapData(display, XtWindow(toolBar),
+					      (char *)backArrowDis_bits,
+					      backArrowDis_width,
+					      backArrowDis_height,
+					      fg, bg, depth),
+		  NULL);
+    XtVaSetValues(prevTenPageBtn, XmNlabelType, XmPIXMAP,
+		  XmNlabelPixmap,
+		  XCreatePixmapFromBitmapData(display, XtWindow(toolBar),
+					      (char *)dblLeftArrow_bits,
+					      dblLeftArrow_width,
+					      dblLeftArrow_height,
+					      fg, bg, depth),
+		  XmNarmPixmap,
+		  XCreatePixmapFromBitmapData(display, XtWindow(toolBar),
+					      (char *)dblLeftArrow_bits,
+					      dblLeftArrow_width,
+					      dblLeftArrow_height,
+					      fg, arm, depth),
+		  XmNlabelInsensitivePixmap,
+		  XCreatePixmapFromBitmapData(display, XtWindow(toolBar),
+					      (char *)dblLeftArrowDis_bits,
+					      dblLeftArrowDis_width,
+					      dblLeftArrowDis_height,
+					      fg, bg, depth),
+		  NULL);
+    XtVaSetValues(prevPageBtn, XmNlabelType, XmPIXMAP,
+		  XmNlabelPixmap,
+		  XCreatePixmapFromBitmapData(display, XtWindow(toolBar),
+					      (char *)leftArrow_bits,
+					      leftArrow_width,
+					      leftArrow_height,
+					      fg, bg, depth),
+		  XmNarmPixmap,
+		  XCreatePixmapFromBitmapData(display, XtWindow(toolBar),
+					      (char *)leftArrow_bits,
+					      leftArrow_width,
+					      leftArrow_height,
+					      fg, arm, depth),
+		  XmNlabelInsensitivePixmap,
+		  XCreatePixmapFromBitmapData(display, XtWindow(toolBar),
+					      (char *)leftArrowDis_bits,
+					      leftArrowDis_width,
+					      leftArrowDis_height,
+					      fg, bg, depth),
+		  NULL);
+    XtVaSetValues(nextPageBtn, XmNlabelType, XmPIXMAP,
+		  XmNlabelPixmap,
+		  XCreatePixmapFromBitmapData(display, XtWindow(toolBar),
+					      (char *)rightArrow_bits,
+					      rightArrow_width,
+					      rightArrow_height,
+					      fg, bg, depth),
+		  XmNarmPixmap,
+		  XCreatePixmapFromBitmapData(display, XtWindow(toolBar),
+					      (char *)rightArrow_bits,
+					      rightArrow_width,
+					      rightArrow_height,
+					      fg, arm, depth),
+		  XmNlabelInsensitivePixmap,
+		  XCreatePixmapFromBitmapData(display, XtWindow(toolBar),
+					      (char *)rightArrowDis_bits,
+					      rightArrowDis_width,
+					      rightArrowDis_height,
+					      fg, bg, depth),
+		  NULL);
+    XtVaSetValues(nextTenPageBtn, XmNlabelType, XmPIXMAP,
+		  XmNlabelPixmap,
+		  XCreatePixmapFromBitmapData(display, XtWindow(toolBar),
+					      (char *)dblRightArrow_bits,
+					      dblRightArrow_width,
+					      dblRightArrow_height,
+					      fg, bg, depth),
+		  XmNarmPixmap,
+		  XCreatePixmapFromBitmapData(display, XtWindow(toolBar),
+					      (char *)dblRightArrow_bits,
+					      dblRightArrow_width,
+					      dblRightArrow_height,
+					      fg, arm, depth),
+		  XmNlabelInsensitivePixmap,
+		  XCreatePixmapFromBitmapData(display, XtWindow(toolBar),
+					      (char *)dblRightArrowDis_bits,
+					      dblRightArrowDis_width,
+					      dblRightArrowDis_height,
+					      fg, bg, depth),
+		  NULL);
+    XtVaSetValues(forwardBtn, XmNlabelType, XmPIXMAP,
+		  XmNlabelPixmap,
+		  XCreatePixmapFromBitmapData(display, XtWindow(toolBar),
+					      (char *)forwardArrow_bits,
+					      forwardArrow_width,
+					      forwardArrow_height,
+					      fg, bg, depth),
+		  XmNarmPixmap,
+		  XCreatePixmapFromBitmapData(display, XtWindow(toolBar),
+					      (char *)forwardArrow_bits,
+					      forwardArrow_width,
+					      forwardArrow_height,
+					      fg, arm, depth),
+		  XmNlabelInsensitivePixmap,
+		  XCreatePixmapFromBitmapData(display, XtWindow(toolBar),
+					      (char *)forwardArrowDis_bits,
+					      forwardArrowDis_width,
+					      forwardArrowDis_height,
+					      fg, bg, depth),
+		  NULL);
+    XtVaSetValues(findBtn, XmNlabelType, XmPIXMAP,
+		  XmNlabelPixmap,
+		  XCreatePixmapFromBitmapData(display, XtWindow(toolBar),
+					      (char *)find_bits,
+					      find_width,
+					      find_height,
+					      fg, bg, depth),
+		  XmNarmPixmap,
+		  XCreatePixmapFromBitmapData(display, XtWindow(toolBar),
+					      (char *)find_bits,
+					      find_width,
+					      find_height,
+					      fg, arm, depth),
+		  XmNlabelInsensitivePixmap,
+		  XCreatePixmapFromBitmapData(display, XtWindow(toolBar),
+					      (char *)findDis_bits,
+					      findDis_width,
+					      findDis_height,
+					      fg, bg, depth),
+		  NULL);
+    XtVaSetValues(printBtn, XmNlabelType, XmPIXMAP,
+		  XmNlabelPixmap,
+		  XCreatePixmapFromBitmapData(display, XtWindow(toolBar),
+					      (char *)print_bits,
+					      print_width,
+					      print_height,
+					      fg, bg, depth),
+		  XmNarmPixmap,
+		  XCreatePixmapFromBitmapData(display, XtWindow(toolBar),
+					      (char *)print_bits,
+					      print_width,
+					      print_height,
+					      fg, arm, depth),
+		  XmNlabelInsensitivePixmap,
+		  XCreatePixmapFromBitmapData(display, XtWindow(toolBar),
+					      (char *)printDis_bits,
+					      printDis_width,
+					      printDis_height,
+					      fg, bg, depth),
+		  NULL);
+    XtVaSetValues(aboutBtn, XmNlabelType, XmPIXMAP,
+		  XmNlabelPixmap,
+		  XCreatePixmapFromBitmapData(display, XtWindow(toolBar),
+					      (char *)about_bits,
+					      about_width,
+					      about_height,
+					      fg, bg, depth),
+		  XmNarmPixmap,
+		  XCreatePixmapFromBitmapData(display, XtWindow(toolBar),
+					      (char *)about_bits,
+					      about_width,
+					      about_height,
+					      fg, arm, depth),
+		  NULL);
+  }
+}
+
+void XPDFViewer::closeWindow() {
+  XtPopdown(win);
+  XtDestroyWidget(win);
+}
+
+int XPDFViewer::getZoomIdx() {
+  int i;
+
+  for (i = 0; i < nZoomMenuItems; ++i) {
+    if (core->getZoom() == zoomMenuInfo[i].zoom) {
+      return i;
+    }
+  }
+  return -1;
+}
+
+void XPDFViewer::setZoomIdx(int idx) {
+  if (toolBar == None) {
+    return;
+  }
+#if USE_COMBO_BOX
+  XtVaSetValues(zoomComboBox, XmNselectedPosition, idx + 1, NULL);
+#else
+  XtVaSetValues(zoomMenu, XmNmenuHistory, zoomMenuBtns[idx], NULL);
+#endif
+}
+
+void XPDFViewer::setZoomVal(double z) {
+  if (toolBar == None) {
+    return;
+  }
+
+#if USE_COMBO_BOX
+  char buf[32];
+  XmString s;
+  int i;
+
+  for (i = 0; i < nZoomMenuItems; ++i) {
+    if (z == zoomMenuInfo[i].zoom) {
+      XtVaSetValues(zoomComboBox, XmNselectedPosition, i + 1, NULL);
+      return;
+    }
+  }
+  sprintf(buf, "%d%%", (int)z);
+  s = XmStringCreateLocalized(buf);
+  XtVaSetValues(zoomComboBox, XmNselectedItem, s, NULL);
+  XmStringFree(s);
+#else
+  int i;
+
+  for (i = 0; i < nZoomMenuItems; ++i) {
+    if (z == zoomMenuInfo[i].zoom) {
+      XtVaSetValues(zoomMenu, XmNmenuHistory, zoomMenuBtns[i], NULL);
+      return;
+    }
+  }
+  for (i = maxZoomIdx; i < minZoomIdx; ++i) {
+    if (z > zoomMenuInfo[i].zoom) {
+      break;
+    }
+  }
+  XtVaSetValues(zoomMenu, XmNmenuHistory, zoomMenuBtns[i], NULL);
+#endif
+}
+
+void XPDFViewer::prevPageCbk(Widget widget, XtPointer ptr,
+			     XtPointer callData) {
+  XPDFViewer *viewer = (XPDFViewer *)ptr;
+
+  viewer->core->gotoPrevPage(1, gTrue, gFalse);
+  viewer->core->takeFocus();
+}
+
+void XPDFViewer::prevTenPageCbk(Widget widget, XtPointer ptr,
+				XtPointer callData) {
+  XPDFViewer *viewer = (XPDFViewer *)ptr;
+
+  viewer->core->gotoPrevPage(10, gTrue, gFalse);
+  viewer->core->takeFocus();
+}
+
+void XPDFViewer::nextPageCbk(Widget widget, XtPointer ptr,
+			     XtPointer callData) {
+  XPDFViewer *viewer = (XPDFViewer *)ptr;
+
+  viewer->core->gotoNextPage(1, gTrue);
+  viewer->core->takeFocus();
+}
+
+void XPDFViewer::nextTenPageCbk(Widget widget, XtPointer ptr,
+				XtPointer callData) {
+  XPDFViewer *viewer = (XPDFViewer *)ptr;
+
+  viewer->core->gotoNextPage(10, gTrue);
+  viewer->core->takeFocus();
+}
+
+void XPDFViewer::backCbk(Widget widget, XtPointer ptr,
+			 XtPointer callData) {
+  XPDFViewer *viewer = (XPDFViewer *)ptr;
+
+  viewer->core->goBackward();
+  viewer->core->takeFocus();
+}
+
+void XPDFViewer::forwardCbk(Widget widget, XtPointer ptr,
+			    XtPointer callData) {
+  XPDFViewer *viewer = (XPDFViewer *)ptr;
+
+  viewer->core->goForward();
+  viewer->core->takeFocus();
+}
+
+#if USE_COMBO_BOX
+
+void XPDFViewer::zoomComboBoxCbk(Widget widget, XtPointer ptr,
+				 XtPointer callData) {
+  XPDFViewer *viewer = (XPDFViewer *)ptr;
+  XmComboBoxCallbackStruct *data = (XmComboBoxCallbackStruct *)callData;
+  double z;
+  char *s;
+  XmStringContext context;
+  XmStringCharSet charSet;
+  XmStringDirection dir;
+  Boolean sep;
+
+  z = viewer->core->getZoom();
+  if (data->item_position == 0) {
+    XmStringInitContext(&context, data->item_or_text);
+    if (XmStringGetNextSegment(context, &s, &charSet, &dir, &sep)) {
+      z = atof(s);
+      if (z <= 1) {
+	z = defZoom;
+      }
+      XtFree(charSet);
+      XtFree(s);
+    }
+    XmStringFreeContext(context);
+  } else {
+    z = zoomMenuInfo[data->item_position - 1].zoom;
+  }
+  // only redraw if this was triggered by an event; otherwise
+  // the caller is responsible for doing the redraw
+  if (z != viewer->core->getZoom() && data->event) {
+    viewer->displayPage(viewer->core->getPageNum(), z,
+			viewer->core->getRotate(), gTrue, gFalse);
+  }
+  viewer->core->takeFocus();
+}
+
+#else // USE_COMBO_BOX
+
+void XPDFViewer::zoomMenuCbk(Widget widget, XtPointer ptr,
+			     XtPointer callData) {
+  XPDFViewer *viewer = (XPDFViewer *)ptr;
+  XmPushButtonCallbackStruct *data = (XmPushButtonCallbackStruct *)callData;
+  XtPointer userData;
+  double z;
+
+  XtVaGetValues(widget, XmNuserData, &userData, NULL);
+  z = zoomMenuInfo[(long)userData].zoom;
+  // only redraw if this was triggered by an event; otherwise
+  // the caller is responsible for doing the redraw
+  if (z != viewer->core->getZoom() && data->event) {
+    viewer->displayPage(viewer->core->getPageNum(), z,
+			viewer->core->getRotate(), gTrue, gFalse);
+  }
+  viewer->core->takeFocus();
+}
+
+#endif // USE_COMBO_BOX
+
+void XPDFViewer::findCbk(Widget widget, XtPointer ptr,
+			 XtPointer callData) {
+  XPDFViewer *viewer = (XPDFViewer *)ptr;
+
+  if (!viewer->core->getDoc()) {
+    return;
+  }
+  viewer->mapFindDialog();
+}
+
+void XPDFViewer::printCbk(Widget widget, XtPointer ptr,
+			  XtPointer callData) {
+  XPDFViewer *viewer = (XPDFViewer *)ptr;
+
+  if (!viewer->core->getDoc()) {
+    return;
+  }
+  XtManageChild(viewer->printDialog);
+}
+
+void XPDFViewer::aboutCbk(Widget widget, XtPointer ptr,
+			  XtPointer callData) {
+  XPDFViewer *viewer = (XPDFViewer *)ptr;
+
+  XtManageChild(viewer->aboutDialog);
+}
+
+void XPDFViewer::quitCbk(Widget widget, XtPointer ptr,
+			 XtPointer callData) {
+  XPDFViewer *viewer = (XPDFViewer *)ptr;
+
+  viewer->app->quit();
+}
+
+void XPDFViewer::openCbk(Widget widget, XtPointer ptr,
+			 XtPointer callData) {
+  XPDFViewer *viewer = (XPDFViewer *)ptr;
+
+  viewer->mapOpenDialog(gFalse);
+}
+
+void XPDFViewer::openInNewWindowCbk(Widget widget, XtPointer ptr,
+				    XtPointer callData) {
+  XPDFViewer *viewer = (XPDFViewer *)ptr;
+
+  viewer->mapOpenDialog(gTrue);
+}
+
+void XPDFViewer::reloadCbk(Widget widget, XtPointer ptr,
+			 XtPointer callData) {
+  XPDFViewer *viewer = (XPDFViewer *)ptr;
+
+  viewer->reloadFile();
+}
+
+void XPDFViewer::saveAsCbk(Widget widget, XtPointer ptr,
+			   XtPointer callData) {
+  XPDFViewer *viewer = (XPDFViewer *)ptr;
+
+  if (!viewer->core->getDoc()) {
+    return;
+  }
+  viewer->mapSaveAsDialog();
+}
+
+void XPDFViewer::continuousModeToggleCbk(Widget widget, XtPointer ptr,
+					 XtPointer callData) {
+  XPDFViewer *viewer = (XPDFViewer *)ptr;
+  XmToggleButtonCallbackStruct *data =
+      (XmToggleButtonCallbackStruct *)callData;
+
+  viewer->core->setContinuousMode(data->set == XmSET);
+}
+
+void XPDFViewer::fullScreenToggleCbk(Widget widget, XtPointer ptr,
+				     XtPointer callData) {
+  XPDFViewer *viewer = (XPDFViewer *)ptr;
+  XmToggleButtonCallbackStruct *data =
+      (XmToggleButtonCallbackStruct *)callData;
+
+  if (data->set == XmSET) {
+    viewer->cmdFullScreenMode(NULL, 0, NULL);
+  } else {
+    viewer->cmdWindowMode(NULL, 0, NULL);
+  }
+}
+
+void XPDFViewer::rotateCCWCbk(Widget widget, XtPointer ptr,
+			      XtPointer callData) {
+  XPDFViewer *viewer = (XPDFViewer *)ptr;
+  int r;
+
+  r = viewer->core->getRotate();
+  r = (r == 0) ? 270 : r - 90;
+  viewer->displayPage(viewer->core->getPageNum(), viewer->core->getZoom(),
+		      r, gTrue, gFalse);
+}
+
+void XPDFViewer::rotateCWCbk(Widget widget, XtPointer ptr,
+			     XtPointer callData) {
+  XPDFViewer *viewer = (XPDFViewer *)ptr;
+  int r;
+
+  r = viewer->core->getRotate();
+  r = (r == 270) ? 0 : r + 90;
+  viewer->displayPage(viewer->core->getPageNum(), viewer->core->getZoom(),
+		      r, gTrue, gFalse);
+}
+
+void XPDFViewer::zoomToSelectionCbk(Widget widget, XtPointer ptr,
+				    XtPointer callData) {
+  XPDFViewer *viewer = (XPDFViewer *)ptr;
+  int pg;
+  double ulx, uly, lrx, lry;
+
+  if (viewer->core->getSelection(&pg, &ulx, &uly, &lrx, &lry)) {
+    viewer->core->zoomToRect(pg, ulx, uly, lrx, lry);
+  }
+}
+
+void XPDFViewer::closeCbk(Widget widget, XtPointer ptr,
+			  XtPointer callData) {
+  XPDFViewer *viewer = (XPDFViewer *)ptr;
+
+  viewer->app->close(viewer, gFalse);
+}
+
+void XPDFViewer::closeMsgCbk(Widget widget, XtPointer ptr,
+			     XtPointer callData) {
+  XPDFViewer *viewer = (XPDFViewer *)ptr;
+
+  viewer->app->close(viewer, gTrue);
+}
+
+void XPDFViewer::pageNumCbk(Widget widget, XtPointer ptr,
+			    XtPointer callData) {
+  XPDFViewer *viewer = (XPDFViewer *)ptr;
+  char *s, *p;
+  int pg;
+  char buf[20];
+
+  if (!viewer->core->getDoc()) {
+    goto err;
+  }
+  s = XmTextFieldGetString(viewer->pageNumText);
+  for (p = s; *p; ++p) {
+    if (!isdigit(*p)) {
+      goto err;
+    }
+  }
+  pg = atoi(s);
+  if (pg < 1 || pg > viewer->core->getDoc()->getNumPages()) {
+    goto err;
+  }
+  viewer->displayPage(pg, viewer->core->getZoom(),
+		      viewer->core->getRotate(), gFalse, gTrue);
+  viewer->core->takeFocus();
+  return;
+
+ err:
+  XBell(viewer->display, 0);
+  sprintf(buf, "%d", viewer->core->getPageNum());
+  XmTextFieldSetString(viewer->pageNumText, buf);
+}
+
+void XPDFViewer::updateCbk(void *data, GString *fileName,
+			   int pageNum, int numPages, char *linkString) {
+  XPDFViewer *viewer = (XPDFViewer *)data;
+  GString *title;
+  char buf[20];
+  XmString s;
+
+  if (fileName) {
+    if (!(title = viewer->app->getTitle())) {
+      title = (new GString(xpdfAppName))->append(": ")->append(fileName);
+    }
+    XtVaSetValues(viewer->win, XmNtitle, title->getCString(),
+		  XmNiconName, title->getCString(), NULL);
+    if (!viewer->app->getTitle()) {
+      delete title;
+    }
+#ifndef DISABLE_OUTLINE
+    viewer->setupOutline();
+#endif
+    viewer->setupPrintDialog();
+  }
+
+  if (viewer->toolBar != None) {
+    if (pageNum >= 0) {
+      s = XmStringCreateLocalized("");
+      XtVaSetValues(viewer->linkLabel, XmNlabelString, s, NULL);
+      XmStringFree(s);
+      sprintf(buf, "%d", pageNum);
+      XmTextFieldSetString(viewer->pageNumText, buf);
+      XtVaSetValues(viewer->prevTenPageBtn, XmNsensitive,
+		    pageNum > 1, NULL);
+      XtVaSetValues(viewer->prevPageBtn, XmNsensitive,
+		    pageNum > 1, NULL);
+      XtVaSetValues(viewer->nextTenPageBtn, XmNsensitive,
+		    pageNum < viewer->core->getDoc()->getNumPages(), NULL);
+      XtVaSetValues(viewer->nextPageBtn, XmNsensitive,
+		    pageNum < viewer->core->getDoc()->getNumPages(), NULL);
+      XtVaSetValues(viewer->backBtn, XmNsensitive,
+		    viewer->core->canGoBack(), NULL);
+      XtVaSetValues(viewer->forwardBtn, XmNsensitive,
+		    viewer->core->canGoForward(), NULL);
+    }
+
+    if (numPages >= 0) {
+      sprintf(buf, " of %d", numPages);
+      s = XmStringCreateLocalized(buf);
+      XtVaSetValues(viewer->pageCountLabel, XmNlabelString, s, NULL);
+      XmStringFree(s);
+    }
+
+    if (linkString) {
+      s = XmStringCreateLocalized(linkString);
+      XtVaSetValues(viewer->linkLabel, XmNlabelString, s, NULL);
+      XmStringFree(s);
+    }
+  }
+}
+
+
+//------------------------------------------------------------------------
+// GUI code: outline
+//------------------------------------------------------------------------
+
+#ifndef DISABLE_OUTLINE
+
+void XPDFViewer::setupOutline() {
+  GList *items;
+  UnicodeMap *uMap;
+  GString *enc;
+  int i;
+
+  if (outlineScroll == None) {
+    return;
+  }
+
+  // unmanage and destroy the old labels
+  if (outlineLabels) {
+    XtUnmanageChildren(outlineLabels, outlineLabelsLength);
+    for (i = 0; i < outlineLabelsLength; ++i) {
+      XtDestroyWidget(outlineLabels[i]);
+    }
+    gfree(outlineLabels);
+    outlineLabels = NULL;
+    outlineLabelsLength = outlineLabelsSize = 0;
+  }
+
+  if (core->getDoc()) {
+
+    // create the new labels
+    items = core->getDoc()->getOutline()->getItems();
+    if (items && items->getLength() > 0) {
+      enc = new GString("Latin1");
+      uMap = globalParams->getUnicodeMap(enc);
+      delete enc;
+      setupOutlineItems(items, NULL, uMap);
+      uMap->decRefCnt();
+    }
+
+    // manage the new labels
+    XtManageChildren(outlineLabels, outlineLabelsLength);
+  }
+}
+
+void XPDFViewer::setupOutlineItems(GList *items, Widget parent,
+				   UnicodeMap *uMap) {
+  OutlineItem *item;
+  GList *kids;
+  Widget label;
+  Arg args[20];
+  GString *title;
+  char buf[8];
+  XmString s;
+  int i, j, n;
+
+  for (i = 0; i < items->getLength(); ++i) {
+    item = (OutlineItem *)items->get(i);
+    title = new GString();
+    for (j = 0; j < item->getTitleLength(); ++j) {
+      n = uMap->mapUnicode(item->getTitle()[j], buf, sizeof(buf));
+      title->append(buf, n);
+    }
+    n = 0;
+    XtSetArg(args[n], XPDFNentryPosition, i); ++n;
+    if (parent) {
+      XtSetArg(args[n], XPDFNentryParent, parent); ++n;
+    }
+    XtSetArg(args[n], XPDFNentryExpanded, item->isOpen()); ++n;
+    s = XmStringCreateLocalized(title->getCString());
+    delete title;
+    XtSetArg(args[n], XmNlabelString, s); ++n;
+    XtSetArg(args[n], XmNuserData, item); ++n;
+    XtSetArg(args[n], XmNmarginWidth, 0); ++n;
+    XtSetArg(args[n], XmNmarginHeight, 2); ++n;
+    XtSetArg(args[n], XmNshadowThickness, 0); ++n;
+    XtSetArg(args[n], XmNforeground,
+	     app->getReverseVideo() ? WhitePixel(display, screenNum)
+	                            : BlackPixel(display, screenNum)); ++n;
+    XtSetArg(args[n], XmNbackground, app->getPaperPixel()); ++n;
+    label = XmCreateLabelGadget(outlineTree, "label", args, n);
+    XmStringFree(s);
+    if (outlineLabelsLength == outlineLabelsSize) {
+      outlineLabelsSize += 64;
+      outlineLabels = (Widget *)greallocn(outlineLabels,
+					  outlineLabelsSize, sizeof(Widget *));
+    }
+    outlineLabels[outlineLabelsLength++] = label;
+    item->open();
+    if ((kids = item->getKids())) {
+      setupOutlineItems(kids, label, uMap);
+    }
+  }
+}
+
+void XPDFViewer::outlineSelectCbk(Widget widget, XtPointer ptr,
+				  XtPointer callData) {
+  XPDFViewer *viewer = (XPDFViewer *)ptr;
+  XPDFTreeSelectCallbackStruct *data =
+      (XPDFTreeSelectCallbackStruct *)callData;
+  OutlineItem *item;
+
+  XtVaGetValues(data->selectedItem, XmNuserData, &item, NULL);
+  if (item) {
+    if (item->getAction()) {
+      viewer->core->doAction(item->getAction());
+    }
+  }
+  viewer->core->takeFocus();
+}
+
+#endif // !DISABLE_OUTLINE
+
+//------------------------------------------------------------------------
+// GUI code: "about" dialog
+//------------------------------------------------------------------------
+
+void XPDFViewer::initAboutDialog() {
+  Widget scrolledWin, col, label, sep, closeBtn;
+  Arg args[20];
+  int n, i;
+  XmString s;
+  char buf[20];
+
+  //----- dialog
+  n = 0;
+  s = XmStringCreateLocalized(xpdfAppName ": About");
+  XtSetArg(args[n], XmNdialogTitle, s); ++n;
+  XtSetArg(args[n], XmNwidth, 450); ++n;
+  XtSetArg(args[n], XmNheight, 300); ++n;
+  aboutDialog = XmCreateFormDialog(win, "aboutDialog", args, n);
+  XmStringFree(s);
+
+  //----- "close" button
+  n = 0;
+  XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); ++n;
+  XtSetArg(args[n], XmNrightOffset, 4); ++n;
+  XtSetArg(args[n], XmNbottomAttachment, XmATTACH_FORM); ++n;
+  XtSetArg(args[n], XmNbottomOffset, 4); ++n;
+  closeBtn = XmCreatePushButton(aboutDialog, "Close", args, n);
+  XtManageChild(closeBtn);
+  n = 0;
+  XtSetArg(args[n], XmNdefaultButton, closeBtn); ++n;
+  XtSetArg(args[n], XmNcancelButton, closeBtn); ++n;
+  XtSetValues(aboutDialog, args, n);
+
+  //----- scrolled window and RowColumn
+  n = 0;
+  XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); ++n;
+  XtSetArg(args[n], XmNbottomAttachment, XmATTACH_WIDGET); ++n;
+  XtSetArg(args[n], XmNbottomWidget, closeBtn); ++n;
+  XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); ++n;
+  XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); ++n;
+  XtSetArg(args[n], XmNscrollingPolicy, XmAUTOMATIC); ++n;
+  scrolledWin = XmCreateScrolledWindow(aboutDialog, "scrolledWin", args, n);
+  XtManageChild(scrolledWin);
+  n = 0;
+  XtSetArg(args[n], XmNorientation, XmVERTICAL); ++n;
+  XtSetArg(args[n], XmNpacking, XmPACK_TIGHT); ++n;
+  col = XmCreateRowColumn(scrolledWin, "col", args, n);
+  XtManageChild(col);
+
+  //----- fonts
+  aboutBigFont =
+    createFontList("-*-times-bold-i-normal--20-*-*-*-*-*-iso8859-1");
+  aboutVersionFont =
+    createFontList("-*-times-medium-r-normal--16-*-*-*-*-*-iso8859-1");
+  aboutFixedFont =
+    createFontList("-*-courier-medium-r-normal--12-*-*-*-*-*-iso8859-1");
+
+  //----- heading
+  n = 0;
+  s = XmStringCreateLocalized("Xpdf");
+  XtSetArg(args[n], XmNlabelString, s); ++n;
+  XtSetArg(args[n], XmNfontList, aboutBigFont); ++n;
+  label = XmCreateLabel(col, "h0", args, n);
+  XmStringFree(s);
+  XtManageChild(label);
+  n = 0;
+  s = XmStringCreateLocalized("Version " xpdfVersion);
+  XtSetArg(args[n], XmNlabelString, s); ++n;
+  XtSetArg(args[n], XmNfontList, aboutVersionFont); ++n;
+  label = XmCreateLabel(col, "h1", args, n);
+  XmStringFree(s);
+  XtManageChild(label);
+  n = 0;
+  s = XmStringCreateLocalized(xpdfCopyright);
+  XtSetArg(args[n], XmNlabelString, s); ++n;
+  XtSetArg(args[n], XmNfontList, aboutVersionFont); ++n;
+  label = XmCreateLabel(col, "h2", args, n);
+  XmStringFree(s);
+  XtManageChild(label);
+  n = 0;
+  s = XmStringCreateLocalized(" ");
+  XtSetArg(args[n], XmNlabelString, s); ++n;
+  XtSetArg(args[n], XmNfontList, aboutVersionFont); ++n;
+  label = XmCreateLabel(col, "h3", args, n);
+  XmStringFree(s);
+  XtManageChild(label);
+  n = 0;
+  XtSetArg(args[n], XmNorientation, XmHORIZONTAL); ++n;
+  sep = XmCreateSeparator(col, "sep", args, n);
+  XtManageChild(sep);
+  n = 0;
+  s = XmStringCreateLocalized(" ");
+  XtSetArg(args[n], XmNlabelString, s); ++n;
+  XtSetArg(args[n], XmNfontList, aboutVersionFont); ++n;
+  label = XmCreateLabel(col, "h4", args, n);
+  XmStringFree(s);
+  XtManageChild(label);
+  n = 0;
+
+  //----- text
+  for (i = 0; aboutWinText[i]; ++i) {
+    n = 0;
+    s = XmStringCreateLocalized(aboutWinText[i]);
+    XtSetArg(args[n], XmNlabelString, s); ++n;
+    XtSetArg(args[n], XmNfontList, aboutFixedFont); ++n;
+    sprintf(buf, "t%d", i);
+    label = XmCreateLabel(col, buf, args, n);
+    XtManageChild(label);
+    XmStringFree(s);
+  }
+}
+
+//------------------------------------------------------------------------
+// GUI code: "open" dialog
+//------------------------------------------------------------------------
+
+void XPDFViewer::initOpenDialog() {
+  Arg args[20];
+  int n;
+  XmString s1, s2, s3;
+  GString *dir;
+
+  n = 0;
+  s1 = XmStringCreateLocalized("Open");
+  XtSetArg(args[n], XmNokLabelString, s1); ++n;
+  s2 = XmStringCreateLocalized("*.[Pp][Dd][Ff]");
+  XtSetArg(args[n], XmNpattern, s2); ++n;
+  s3 = XmStringCreateLocalized(xpdfAppName ": Open");
+  XtSetArg(args[n], XmNdialogTitle, s3); ++n;
+  XtSetArg(args[n], XmNdialogStyle, XmDIALOG_PRIMARY_APPLICATION_MODAL); ++n;
+  XtSetArg(args[n], XmNautoUnmanage, True); ++n;
+  openDialog = XmCreateFileSelectionDialog(win, "openDialog", args, n);
+  XmStringFree(s1);
+  XmStringFree(s2);
+  XmStringFree(s3);
+  XtUnmanageChild(XmFileSelectionBoxGetChild(openDialog,
+					     XmDIALOG_HELP_BUTTON));
+  XtAddCallback(openDialog, XmNokCallback,
+		&openOkCbk, (XtPointer)this);
+
+  if (core->getDoc() && core->getDoc()->getFileName()) {
+    dir = makePathAbsolute(grabPath(
+	      core->getDoc()->getFileName()->getCString()));
+    s1 = XmStringCreateLocalized(dir->getCString());
+    XtVaSetValues(openDialog, XmNdirectory, s1, NULL);
+    XmStringFree(s1);
+    delete dir;
+  }
+}
+
+void XPDFViewer::mapOpenDialog(GBool openInNewWindowA) {
+  if (!openDialog) {
+    initOpenDialog();
+  }
+  openInNewWindow = openInNewWindowA;
+  XmFileSelectionDoSearch(openDialog, NULL);
+  XtManageChild(openDialog);
+}
+
+void XPDFViewer::openOkCbk(Widget widget, XtPointer ptr,
+			   XtPointer callData) {
+  XPDFViewer *viewer = (XPDFViewer *)ptr;
+  XmFileSelectionBoxCallbackStruct *data =
+    (XmFileSelectionBoxCallbackStruct *)callData;
+  char *fileName;
+  XmStringContext context;
+  XmStringCharSet charSet;
+  XmStringDirection dir;
+  Boolean sep;
+  GString *fileNameStr;
+
+  XmStringInitContext(&context, data->value);
+  if (XmStringGetNextSegment(context, &fileName, &charSet, &dir, &sep)) {
+    fileNameStr = new GString(fileName);
+    if (viewer->openInNewWindow) {
+      viewer->app->open(fileNameStr);
+    } else {
+      if (viewer->loadFile(fileNameStr)) {
+	viewer->displayPage(1, viewer->core->getZoom(),
+			    viewer->core->getRotate(), gTrue, gTrue);
+      }
+    }
+    delete fileNameStr;
+    XtFree(charSet);
+    XtFree(fileName);
+  }
+  XmStringFreeContext(context);
+}
+
+//------------------------------------------------------------------------
+// GUI code: "find" dialog
+//------------------------------------------------------------------------
+
+void XPDFViewer::initFindDialog() {
+  Widget form1, label, okBtn, closeBtn;
+  Arg args[20];
+  int n;
+  XmString s;
+
+  //----- dialog
+  n = 0;
+  s = XmStringCreateLocalized(xpdfAppName ": Find");
+  XtSetArg(args[n], XmNdialogTitle, s); ++n;
+  XtSetArg(args[n], XmNnavigationType, XmNONE); ++n;
+  XtSetArg(args[n], XmNautoUnmanage, False); ++n;
+  findDialog = XmCreateFormDialog(win, "findDialog", args, n);
+  XmStringFree(s);
+
+  //----- "find" and "close" buttons
+  n = 0;
+  XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); ++n;
+  XtSetArg(args[n], XmNleftOffset, 4); ++n;
+  XtSetArg(args[n], XmNbottomAttachment, XmATTACH_FORM); ++n;
+  XtSetArg(args[n], XmNbottomOffset, 4); ++n;
+  XtSetArg(args[n], XmNnavigationType, XmEXCLUSIVE_TAB_GROUP); ++n;
+  okBtn = XmCreatePushButton(findDialog, "Find", args, n);
+  XtManageChild(okBtn);
+  XtAddCallback(okBtn, XmNactivateCallback,
+		&findFindCbk, (XtPointer)this);
+  n = 0;
+  XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); ++n;
+  XtSetArg(args[n], XmNrightOffset, 4); ++n;
+  XtSetArg(args[n], XmNbottomAttachment, XmATTACH_FORM); ++n;
+  XtSetArg(args[n], XmNbottomOffset, 4); ++n;
+  XtSetArg(args[n], XmNnavigationType, XmEXCLUSIVE_TAB_GROUP); ++n;
+  closeBtn = XmCreatePushButton(findDialog, "Close", args, n);
+  XtManageChild(closeBtn);
+  XtAddCallback(closeBtn, XmNactivateCallback,
+		&findCloseCbk, (XtPointer)this);
+
+  //----- checkboxes
+  n = 0;
+  XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); ++n;
+  XtSetArg(args[n], XmNleftOffset, 4); ++n;
+  XtSetArg(args[n], XmNbottomAttachment, XmATTACH_WIDGET); ++n;
+  XtSetArg(args[n], XmNbottomWidget, okBtn); ++n;
+  XtSetArg(args[n], XmNindicatorType, XmN_OF_MANY); ++n;
+#if XmVERSION <= 1
+  XtSetArg(args[n], XmNindicatorOn, True); ++n;
+#else
+  XtSetArg(args[n], XmNindicatorOn, XmINDICATOR_FILL); ++n;
+#endif
+  XtSetArg(args[n], XmNset, XmUNSET); ++n;
+  s = XmStringCreateLocalized("Search backward");
+  XtSetArg(args[n], XmNlabelString, s); ++n;
+  findBackwardToggle = XmCreateToggleButton(findDialog, "backward", args, n);
+  XmStringFree(s);
+  XtManageChild(findBackwardToggle);
+  n = 0;
+  XtSetArg(args[n], XmNleftAttachment, XmATTACH_WIDGET); ++n;
+  XtSetArg(args[n], XmNleftWidget, findBackwardToggle); ++n;
+  XtSetArg(args[n], XmNleftOffset, 16); ++n;
+  XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); ++n;
+  XtSetArg(args[n], XmNrightOffset, 4); ++n;
+  XtSetArg(args[n], XmNbottomAttachment, XmATTACH_WIDGET); ++n;
+  XtSetArg(args[n], XmNbottomWidget, okBtn); ++n;
+  XtSetArg(args[n], XmNindicatorType, XmN_OF_MANY); ++n;
+#if XmVERSION <= 1
+  XtSetArg(args[n], XmNindicatorOn, True); ++n;
+#else
+  XtSetArg(args[n], XmNindicatorOn, XmINDICATOR_FILL); ++n;
+#endif
+  XtSetArg(args[n], XmNset, XmUNSET); ++n;
+  s = XmStringCreateLocalized("Match case");
+  XtSetArg(args[n], XmNlabelString, s); ++n;
+  findCaseSensitiveToggle =
+      XmCreateToggleButton(findDialog, "matchCase", args, n);
+  XmStringFree(s);
+  XtManageChild(findCaseSensitiveToggle);
+
+  //----- search string entry
+  n = 0;
+  XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); ++n;
+  XtSetArg(args[n], XmNtopOffset, 4); ++n;
+  XtSetArg(args[n], XmNbottomAttachment, XmATTACH_WIDGET); ++n;
+  XtSetArg(args[n], XmNbottomWidget, findBackwardToggle); ++n;
+  XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); ++n;
+  XtSetArg(args[n], XmNleftOffset, 2); ++n;
+  XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); ++n;
+  XtSetArg(args[n], XmNrightOffset, 2); ++n;
+  form1 = XmCreateForm(findDialog, "form", args, n);
+  XtManageChild(form1);
+  n = 0;
+  XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); ++n;
+  XtSetArg(args[n], XmNbottomAttachment, XmATTACH_FORM); ++n;
+  XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); ++n;
+  s = XmStringCreateLocalized("Find text: ");
+  XtSetArg(args[n], XmNlabelString, s); ++n;
+  label = XmCreateLabel(form1, "label", args, n);
+  XmStringFree(s);
+  XtManageChild(label);
+  n = 0;
+  XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); ++n;
+  XtSetArg(args[n], XmNbottomAttachment, XmATTACH_FORM); ++n;
+  XtSetArg(args[n], XmNleftAttachment, XmATTACH_WIDGET); ++n;
+  XtSetArg(args[n], XmNleftWidget, label); ++n;
+  XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); ++n;
+  findText = XmCreateTextField(form1, "text", args, n);
+  XtManageChild(findText);
+#ifdef LESSTIF_VERSION
+  XtAddCallback(findText, XmNactivateCallback,
+		&findFindCbk, (XtPointer)this);
+#endif
+
+  //----- dialog parameters
+  n = 0;
+  XtSetArg(args[n], XmNdefaultButton, okBtn); ++n;
+  XtSetArg(args[n], XmNcancelButton, closeBtn); ++n;
+#if XmVersion > 1001
+  XtSetArg(args[n], XmNinitialFocus, findText); ++n;
+#endif
+  XtSetValues(findDialog, args, n);
+}
+
+void XPDFViewer::findFindCbk(Widget widget, XtPointer ptr,
+			     XtPointer callData) {
+  XPDFViewer *viewer = (XPDFViewer *)ptr;
+
+  viewer->doFind(gFalse);
+}
+
+void XPDFViewer::mapFindDialog() {
+  XmTextFieldSetSelection(findText, 0, XmTextFieldGetLastPosition(findText),
+			  XtLastTimestampProcessed(display));
+  XmTextFieldSetInsertionPosition(findText, 0);
+  XtManageChild(findDialog);
+}
+
+void XPDFViewer::doFind(GBool next) {
+  if (XtWindow(findDialog)) {
+    XDefineCursor(display, XtWindow(findDialog), core->getBusyCursor());
+  }
+  core->find(XmTextFieldGetString(findText),
+	     XmToggleButtonGetState(findCaseSensitiveToggle),
+	     next,
+	     XmToggleButtonGetState(findBackwardToggle),
+	     gFalse);
+  if (XtWindow(findDialog)) {
+    XUndefineCursor(display, XtWindow(findDialog));
+  }
+}
+
+void XPDFViewer::findCloseCbk(Widget widget, XtPointer ptr,
+			      XtPointer callData) {
+  XPDFViewer *viewer = (XPDFViewer *)ptr;
+
+  XtUnmanageChild(viewer->findDialog);
+}
+
+//------------------------------------------------------------------------
+// GUI code: "save as" dialog
+//------------------------------------------------------------------------
+
+void XPDFViewer::initSaveAsDialog() {
+  Arg args[20];
+  int n;
+  XmString s1, s2, s3;
+  GString *dir;
+
+  n = 0;
+  s1 = XmStringCreateLocalized("Save");
+  XtSetArg(args[n], XmNokLabelString, s1); ++n;
+  s2 = XmStringCreateLocalized("*.[Pp][Dd][Ff]");
+  XtSetArg(args[n], XmNpattern, s2); ++n;
+  s3 = XmStringCreateLocalized(xpdfAppName ": Save as");
+  XtSetArg(args[n], XmNdialogTitle, s3); ++n;
+  XtSetArg(args[n], XmNdialogStyle, XmDIALOG_PRIMARY_APPLICATION_MODAL); ++n;
+  XtSetArg(args[n], XmNautoUnmanage, True); ++n;
+  saveAsDialog = XmCreateFileSelectionDialog(win, "saveAsDialog", args, n);
+  XmStringFree(s1);
+  XmStringFree(s2);
+  XmStringFree(s3);
+  XtUnmanageChild(XmFileSelectionBoxGetChild(saveAsDialog,
+					     XmDIALOG_HELP_BUTTON));
+  XtAddCallback(saveAsDialog, XmNokCallback,
+		&saveAsOkCbk, (XtPointer)this);
+
+  if (core->getDoc() && core->getDoc()->getFileName()) {
+    dir = makePathAbsolute(grabPath(
+	      core->getDoc()->getFileName()->getCString()));
+    s1 = XmStringCreateLocalized(dir->getCString());
+    XtVaSetValues(saveAsDialog, XmNdirectory, s1, NULL);
+    XmStringFree(s1);
+    delete dir;
+  }
+}
+
+void XPDFViewer::mapSaveAsDialog() {
+  if (!saveAsDialog) {
+    initSaveAsDialog();
+  }
+  XmFileSelectionDoSearch(saveAsDialog, NULL);
+  XtManageChild(saveAsDialog);
+}
+
+void XPDFViewer::saveAsOkCbk(Widget widget, XtPointer ptr,
+			     XtPointer callData) {
+  XPDFViewer *viewer = (XPDFViewer *)ptr;
+  XmFileSelectionBoxCallbackStruct *data =
+    (XmFileSelectionBoxCallbackStruct *)callData;
+  char *fileName;
+  GString *fileNameStr;
+  XmStringContext context;
+  XmStringCharSet charSet;
+  XmStringDirection dir;
+  Boolean sep;
+
+  XmStringInitContext(&context, data->value);
+  if (XmStringGetNextSegment(context, &fileName, &charSet, &dir, &sep)) {
+    fileNameStr = new GString(fileName);
+    viewer->core->getDoc()->saveAs(fileNameStr);
+    delete fileNameStr;
+    XtFree(charSet);
+    XtFree(fileName);
+  }
+  XmStringFreeContext(context);
+}
+
+//------------------------------------------------------------------------
+// GUI code: "print" dialog
+//------------------------------------------------------------------------
+
+void XPDFViewer::initPrintDialog() {
+  Widget sep1, sep2, row, label1, label2, okBtn, cancelBtn;
+  Arg args[20];
+  int n;
+  XmString s;
+  GString *psFileName;
+
+  //----- dialog
+  n = 0;
+  s = XmStringCreateLocalized(xpdfAppName ": Print");
+  XtSetArg(args[n], XmNdialogTitle, s); ++n;
+  XtSetArg(args[n], XmNdialogStyle, XmDIALOG_PRIMARY_APPLICATION_MODAL); ++n;
+  printDialog = XmCreateFormDialog(win, "printDialog", args, n);
+  XmStringFree(s);
+
+  //----- "print with command"
+  n = 0;
+  XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); ++n;
+  XtSetArg(args[n], XmNtopOffset, 4); ++n;
+  XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); ++n;
+  XtSetArg(args[n], XmNindicatorType, XmONE_OF_MANY); ++n;
+  XtSetArg(args[n], XmNset, XmSET); ++n;
+  s = XmStringCreateLocalized("Print with command:");
+  XtSetArg(args[n], XmNlabelString, s); ++n;
+  printWithCmdBtn = XmCreateToggleButton(printDialog, "printWithCmd", args, n);
+  XmStringFree(s);
+  XtManageChild(printWithCmdBtn);
+  XtAddCallback(printWithCmdBtn, XmNvalueChangedCallback,
+		&printWithCmdBtnCbk, (XtPointer)this);
+  n = 0;
+  XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); ++n;
+  XtSetArg(args[n], XmNtopWidget, printWithCmdBtn); ++n;
+  XtSetArg(args[n], XmNtopOffset, 2); ++n;
+  XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); ++n;
+  XtSetArg(args[n], XmNleftOffset, 16); ++n;
+  XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); ++n;
+  XtSetArg(args[n], XmNrightOffset, 4); ++n;
+  XtSetArg(args[n], XmNcolumns, 40); ++n;
+  printCmdText = XmCreateTextField(printDialog, "printCmd", args, n);
+  XtManageChild(printCmdText);
+
+  //----- "print to file"
+  n = 0;
+  XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); ++n;
+  XtSetArg(args[n], XmNtopWidget, printCmdText); ++n;
+  XtSetArg(args[n], XmNtopOffset, 4); ++n;
+  XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); ++n;
+  XtSetArg(args[n], XmNindicatorType, XmONE_OF_MANY); ++n;
+  XtSetArg(args[n], XmNset, XmUNSET); ++n;
+  s = XmStringCreateLocalized("Print to file:");
+  XtSetArg(args[n], XmNlabelString, s); ++n;
+  printToFileBtn = XmCreateToggleButton(printDialog, "printToFile", args, n);
+  XmStringFree(s);
+  XtManageChild(printToFileBtn);
+  XtAddCallback(printToFileBtn, XmNvalueChangedCallback,
+		&printToFileBtnCbk, (XtPointer)this);
+  n = 0;
+  XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); ++n;
+  XtSetArg(args[n], XmNtopWidget, printToFileBtn); ++n;
+  XtSetArg(args[n], XmNtopOffset, 2); ++n;
+  XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); ++n;
+  XtSetArg(args[n], XmNleftOffset, 16); ++n;
+  XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); ++n;
+  XtSetArg(args[n], XmNrightOffset, 4); ++n;
+  XtSetArg(args[n], XmNcolumns, 40); ++n;
+  XtSetArg(args[n], XmNsensitive, False); ++n;
+  printFileText = XmCreateTextField(printDialog, "printFile", args, n);
+  XtManageChild(printFileText);
+
+  //----- separator
+  n = 0;
+  XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); ++n;
+  XtSetArg(args[n], XmNtopWidget, printFileText); ++n;
+  XtSetArg(args[n], XmNtopOffset, 8); ++n;
+  XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); ++n;
+  XtSetArg(args[n], XmNleftOffset, 8); ++n;
+  XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); ++n;
+  XtSetArg(args[n], XmNrightOffset, 8); ++n;
+  XtSetArg(args[n], XmNorientation, XmHORIZONTAL); ++n;
+  sep1 = XmCreateSeparator(printDialog, "sep1", args, n);
+  XtManageChild(sep1);
+
+  //----- page range
+  n = 0;
+  XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); ++n;
+  XtSetArg(args[n], XmNtopWidget, sep1); ++n;
+  XtSetArg(args[n], XmNtopOffset, 8); ++n;
+  XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); ++n;
+  XtSetArg(args[n], XmNleftOffset, 4); ++n;
+  XtSetArg(args[n], XmNorientation, XmHORIZONTAL); ++n;
+  XtSetArg(args[n], XmNpacking, XmPACK_TIGHT); ++n;
+  row = XmCreateRowColumn(printDialog, "row", args, n);
+  XtManageChild(row);
+  n = 0;
+  s = XmStringCreateLocalized("Pages:");
+  XtSetArg(args[n], XmNlabelString, s); ++n;
+  label1 = XmCreateLabel(row, "label1", args, n);
+  XmStringFree(s);
+  XtManageChild(label1);
+  n = 0;
+  XtSetArg(args[n], XmNcolumns, 5); ++n;
+  printFirstPage = XmCreateTextField(row, "printFirstPage", args, n);
+  XtManageChild(printFirstPage);
+  n = 0;
+  s = XmStringCreateLocalized("to");
+  XtSetArg(args[n], XmNlabelString, s); ++n;
+  label2 = XmCreateLabel(row, "label2", args, n);
+  XmStringFree(s);
+  XtManageChild(label2);
+  n = 0;
+  XtSetArg(args[n], XmNcolumns, 5); ++n;
+  printLastPage = XmCreateTextField(row, "printLastPage", args, n);
+  XtManageChild(printLastPage);
+
+  //----- separator
+  n = 0;
+  XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); ++n;
+  XtSetArg(args[n], XmNtopWidget, row); ++n;
+  XtSetArg(args[n], XmNtopOffset, 8); ++n;
+  XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); ++n;
+  XtSetArg(args[n], XmNleftOffset, 8); ++n;
+  XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); ++n;
+  XtSetArg(args[n], XmNrightOffset, 8); ++n;
+  XtSetArg(args[n], XmNorientation, XmHORIZONTAL); ++n;
+  sep2 = XmCreateSeparator(printDialog, "sep2", args, n);
+  XtManageChild(sep2);
+
+  //----- "print" and "cancel" buttons
+  n = 0;
+  XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); ++n;
+  XtSetArg(args[n], XmNtopWidget, sep2); ++n;
+  XtSetArg(args[n], XmNtopOffset, 8); ++n;
+  XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); ++n;
+  XtSetArg(args[n], XmNleftOffset, 4); ++n;
+  XtSetArg(args[n], XmNbottomAttachment, XmATTACH_FORM); ++n;
+  XtSetArg(args[n], XmNbottomOffset, 4); ++n;
+  okBtn = XmCreatePushButton(printDialog, "Print", args, n);
+  XtManageChild(okBtn);
+  XtAddCallback(okBtn, XmNactivateCallback,
+		&printPrintCbk, (XtPointer)this);
+  n = 0;
+  XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); ++n;
+  XtSetArg(args[n], XmNtopWidget, sep2); ++n;
+  XtSetArg(args[n], XmNtopOffset, 8); ++n;
+  XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); ++n;
+  XtSetArg(args[n], XmNrightOffset, 4); ++n;
+  XtSetArg(args[n], XmNbottomAttachment, XmATTACH_FORM); ++n;
+  XtSetArg(args[n], XmNbottomOffset, 4); ++n;
+  cancelBtn = XmCreatePushButton(printDialog, "Cancel", args, n);
+  XtManageChild(cancelBtn);
+  n = 0;
+  XtSetArg(args[n], XmNdefaultButton, okBtn); ++n;
+  XtSetArg(args[n], XmNcancelButton, cancelBtn); ++n;
+  XtSetValues(printDialog, args, n);
+
+  //----- initial values
+  if ((psFileName = globalParams->getPSFile())) {
+    if (psFileName->getChar(0) == '|') {
+      XmTextFieldSetString(printCmdText,
+			   psFileName->getCString() + 1);
+    } else {
+      XmTextFieldSetString(printFileText, psFileName->getCString());
+    }
+    delete psFileName;
+  }
+}
+
+void XPDFViewer::setupPrintDialog() {
+  PDFDoc *doc;
+  char buf[20];
+  GString *pdfFileName, *psFileName, *psFileName2;
+  char *p;
+
+  doc = core->getDoc();
+  psFileName = globalParams->getPSFile();
+  if (!psFileName || psFileName->getChar(0) == '|') {
+    pdfFileName = doc->getFileName();
+    p = pdfFileName->getCString() + pdfFileName->getLength() - 4;
+    if (!strcmp(p, ".pdf") || !strcmp(p, ".PDF")) {
+      psFileName2 = new GString(pdfFileName->getCString(),
+				pdfFileName->getLength() - 4);
+    } else {
+      psFileName2 = pdfFileName->copy();
+    }
+    psFileName2->append(".ps");
+    XmTextFieldSetString(printFileText, psFileName2->getCString());
+    delete psFileName2;
+  }
+  if (psFileName && psFileName->getChar(0) == '|') {
+    XmToggleButtonSetState(printWithCmdBtn, True, False);
+    XmToggleButtonSetState(printToFileBtn, False, False);
+    XtVaSetValues(printCmdText, XmNsensitive, True, NULL);
+    XtVaSetValues(printFileText, XmNsensitive, False, NULL);
+  } else {
+    XmToggleButtonSetState(printWithCmdBtn, False, False);
+    XmToggleButtonSetState(printToFileBtn, True, False);
+    XtVaSetValues(printCmdText, XmNsensitive, False, NULL);
+    XtVaSetValues(printFileText, XmNsensitive, True, NULL);
+  }
+  if (psFileName) {
+    delete psFileName;
+  }
+
+  sprintf(buf, "%d", doc->getNumPages());
+  XmTextFieldSetString(printFirstPage, "1");
+  XmTextFieldSetString(printLastPage, buf);
+}
+
+void XPDFViewer::printWithCmdBtnCbk(Widget widget, XtPointer ptr,
+				    XtPointer callData) {
+  XPDFViewer *viewer = (XPDFViewer *)ptr;
+  XmToggleButtonCallbackStruct *data =
+      (XmToggleButtonCallbackStruct *)callData;
+
+  if (data->set != XmSET) {
+    XmToggleButtonSetState(viewer->printWithCmdBtn, True, False);
+  }
+  XmToggleButtonSetState(viewer->printToFileBtn, False, False);
+  XtVaSetValues(viewer->printCmdText, XmNsensitive, True, NULL);
+  XtVaSetValues(viewer->printFileText, XmNsensitive, False, NULL);
+}
+
+void XPDFViewer::printToFileBtnCbk(Widget widget, XtPointer ptr,
+				   XtPointer callData) {
+  XPDFViewer *viewer = (XPDFViewer *)ptr;
+  XmToggleButtonCallbackStruct *data =
+      (XmToggleButtonCallbackStruct *)callData;
+
+  if (data->set != XmSET) {
+    XmToggleButtonSetState(viewer->printToFileBtn, True, False);
+  }
+  XmToggleButtonSetState(viewer->printWithCmdBtn, False, False);
+  XtVaSetValues(viewer->printFileText, XmNsensitive, True, NULL);
+  XtVaSetValues(viewer->printCmdText, XmNsensitive, False, NULL);
+}
+
+void XPDFViewer::printPrintCbk(Widget widget, XtPointer ptr,
+			       XtPointer callData) {
+  XPDFViewer *viewer = (XPDFViewer *)ptr;
+  unsigned char withCmd;
+  GString *psFileName;
+  int firstPage, lastPage;
+  PDFDoc *doc;
+  PSOutputDev *psOut;
+
+  doc = viewer->core->getDoc();
+  if (!doc->okToPrint()) {
+    error(-1, "Printing this document is not allowed.");
+    return;
+  }
+
+  viewer->core->setBusyCursor(gTrue);
+
+  XtVaGetValues(viewer->printWithCmdBtn, XmNset, &withCmd, NULL);
+  if (withCmd) {
+    psFileName = new GString(XmTextFieldGetString(viewer->printCmdText));
+    psFileName->insert(0, '|');
+  } else {
+    psFileName = new GString(XmTextFieldGetString(viewer->printFileText));
+  }
+
+  firstPage = atoi(XmTextFieldGetString(viewer->printFirstPage));
+  lastPage = atoi(XmTextFieldGetString(viewer->printLastPage));
+  if (firstPage < 1) {
+    firstPage = 1;
+  } else if (firstPage > doc->getNumPages()) {
+    firstPage = doc->getNumPages();
+  }
+  if (lastPage < firstPage) {
+    lastPage = firstPage;
+  } else if (lastPage > doc->getNumPages()) {
+    lastPage = doc->getNumPages();
+  }
+
+  psOut = new PSOutputDev(psFileName->getCString(), doc->getXRef(),
+			  doc->getCatalog(), firstPage, lastPage,
+			  psModePS);
+  if (psOut->isOk()) {
+    doc->displayPages(psOut, firstPage, lastPage, 72, 72,
+		      0, gTrue, globalParams->getPSCrop(), gTrue);
+  }
+  delete psOut;
+  delete psFileName;
+
+  viewer->core->setBusyCursor(gFalse);
+}
+
+//------------------------------------------------------------------------
+// Motif support
+//------------------------------------------------------------------------
+
+XmFontList XPDFViewer::createFontList(char *xlfd) {
+  XmFontList fontList;
+
+#if XmVersion <= 1001
+
+  XFontStruct *font;
+  String params;
+  Cardinal nParams;
+
+  font = XLoadQueryFont(display, xlfd);
+  if (font) {
+    fontList = XmFontListCreate(font, XmSTRING_DEFAULT_CHARSET);
+  } else {
+    params = (String)xlfd;
+    nParams = 1;
+    XtAppWarningMsg(app->getAppContext(),
+		    "noSuchFont", "CvtStringToXmFontList",
+		    "XtToolkitError", "No such font: %s",
+		    &params, &nParams);
+    fontList = NULL;
+  }
+
+#else
+
+  XmFontListEntry entry;
+
+  entry = XmFontListEntryLoad(display, xlfd,
+			      XmFONT_IS_FONT, XmFONTLIST_DEFAULT_TAG);
+  fontList = XmFontListAppendEntry(NULL, entry);
+  XmFontListEntryFree(&entry);
+
+#endif
+
+  return fontList;
+}