00001
00002
00003
00004
00005
00006
00007
00008
00009 #include <aconf.h>
00010
00011 #ifdef USE_GCC_PRAGMAS
00012 #pragma implementation
00013 #endif
00014
00015 #include <stdlib.h>
00016 #include <string.h>
00017 #include <ctype.h>
00018 #include <X11/cursorfont.h>
00019 #ifdef HAVE_X11_XPM_H
00020 #include <X11/xpm.h>
00021 #endif
00022 #include "gmem.h"
00023 #include "gfile.h"
00024 #include "GString.h"
00025 #include "GList.h"
00026 #include "Error.h"
00027 #include "GlobalParams.h"
00028 #include "PDFDoc.h"
00029 #include "ErrorCodes.h"
00030 #include "Outline.h"
00031 #include "UnicodeMap.h"
00032 #ifndef DISABLE_OUTLINE
00033 #define Object XtObject
00034 #include "XPDFTree.h"
00035 #undef Object
00036 #endif
00037 #include "XPDFApp.h"
00038 #include "XPDFViewer.h"
00039 #include "XPixmapOutputDev.h"
00040 #include "PSOutputDev.h"
00041 #include "config.h"
00042
00043
00044 #ifdef LESSTIF_VERSION
00045 #undef XtDisplay
00046 #undef XtScreen
00047 #undef XtWindow
00048 #undef XtParent
00049 #undef XtIsRealized
00050 #endif
00051
00052 #if XmVERSION <= 1
00053 #define XmSET True
00054 #define XmUNSET False
00055 #endif
00056
00057
00058
00059
00060
00061 #include "xpdfIcon.xpm"
00062 #include "leftArrow.xbm"
00063 #include "leftArrowDis.xbm"
00064 #include "dblLeftArrow.xbm"
00065 #include "dblLeftArrowDis.xbm"
00066 #include "rightArrow.xbm"
00067 #include "rightArrowDis.xbm"
00068 #include "dblRightArrow.xbm"
00069 #include "dblRightArrowDis.xbm"
00070 #include "backArrow.xbm"
00071 #include "backArrowDis.xbm"
00072 #include "forwardArrow.xbm"
00073 #include "forwardArrowDis.xbm"
00074 #include "find.xbm"
00075 #include "findDis.xbm"
00076 #include "print.xbm"
00077 #include "printDis.xbm"
00078 #include "about.xbm"
00079 #include "about-text.h"
00080
00081
00082
00083 XPDFViewer::XPDFViewer(XPDFApp *appA, GString *fileName,
00084 int pageA, GString *destName,
00085 GString *ownerPassword, GString *userPassword) {
00086 LinkDest *dest;
00087 int pg, z;
00088 GString *dir;
00089
00090 app = appA;
00091 win = NULL;
00092 core = NULL;
00093 password = NULL;
00094 ok = gFalse;
00095 #ifndef DISABLE_OUTLINE
00096 outlineLabels = NULL;
00097 outlineLabelsLength = outlineLabelsSize = 0;
00098 #endif
00099
00100
00101
00102 initWindow();
00103 initAboutDialog();
00104 initOpenDialog();
00105 initFindDialog();
00106 initSaveAsDialog();
00107 initPrintDialog();
00108 initPasswordDialog();
00109
00110 dest = NULL;
00111 pg = pageA;
00112
00113 if (fileName) {
00114 if (loadFile(fileName, ownerPassword, userPassword)) {
00115 getPageAndDest(pageA, destName, &pg, &dest);
00116 if (pg > 0) {
00117 core->resizeToPage(pg);
00118 }
00119 dir = makePathAbsolute(grabPath(fileName->getCString()));
00120 setOpenDialogDir(dir->getCString());
00121 setSaveAsDialogDir(dir->getCString());
00122 delete dir;
00123 } else {
00124 return;
00125 }
00126 }
00127
00128
00129
00130 mapWindow();
00131
00132
00133 z = app->getFullScreen() ? zoomPage : core->getZoom();
00134 if (dest) {
00135 displayDest(dest, z, core->getRotate(), gTrue);
00136 delete dest;
00137 } else {
00138 displayPage(pg, z, core->getRotate(), gTrue, gTrue);
00139 }
00140
00141 ok = gTrue;
00142 }
00143
00144 XPDFViewer::~XPDFViewer() {
00145 delete core;
00146 XmFontListFree(aboutBigFont);
00147 XmFontListFree(aboutVersionFont);
00148 XmFontListFree(aboutFixedFont);
00149 closeWindow();
00150 #ifndef DISABLE_OUTLINE
00151 if (outlineLabels) {
00152 gfree(outlineLabels);
00153 }
00154 #endif
00155 if (password) {
00156 delete password;
00157 }
00158 }
00159
00160 void XPDFViewer::open(GString *fileName, int pageA, GString *destName) {
00161 LinkDest *dest;
00162 int pg, z;
00163
00164 if (!core->getDoc() || fileName->cmp(core->getDoc()->getFileName())) {
00165 if (!loadFile(fileName, NULL, NULL)) {
00166 return;
00167 }
00168 }
00169 getPageAndDest(pageA, destName, &pg, &dest);
00170 z = app->getFullScreen() ? zoomPage : core->getZoom();
00171 if (dest) {
00172 displayDest(dest, z, core->getRotate(), gTrue);
00173 delete dest;
00174 } else {
00175 displayPage(pg, z, core->getRotate(), gTrue, gTrue);
00176 }
00177 }
00178
00179 void XPDFViewer::clear() {
00180 char *title;
00181 XmString s;
00182
00183 core->clear();
00184
00185
00186 title = app->getTitle() ? app->getTitle()->getCString()
00187 : (char *)xpdfAppName;
00188 XtVaSetValues(win, XmNtitle, title, XmNiconName, title, NULL);
00189 s = XmStringCreateLocalized("");
00190 XtVaSetValues(pageNumText, XmNlabelString, s, NULL);
00191 XmStringFree(s);
00192 s = XmStringCreateLocalized(" of 0");
00193 XtVaSetValues(pageCountLabel, XmNlabelString, s, NULL);
00194 XmStringFree(s);
00195
00196
00197 XtVaSetValues(prevTenPageBtn, XmNsensitive, False, NULL);
00198 XtVaSetValues(prevPageBtn, XmNsensitive, False, NULL);
00199 XtVaSetValues(nextTenPageBtn, XmNsensitive, False, NULL);
00200 XtVaSetValues(nextPageBtn, XmNsensitive, False, NULL);
00201 }
00202
00203
00204
00205
00206
00207 GBool XPDFViewer::loadFile(GString *fileName, GString *ownerPassword,
00208 GString *userPassword) {
00209 return core->loadFile(fileName, ownerPassword, userPassword) == errNone;
00210 }
00211
00212 void XPDFViewer::reloadFile() {
00213 int pg;
00214
00215 if (!core->getDoc()) {
00216 return;
00217 }
00218 pg = core->getPageNum();
00219 loadFile(core->getDoc()->getFileName());
00220 if (pg > core->getDoc()->getNumPages()) {
00221 pg = core->getDoc()->getNumPages();
00222 }
00223 displayPage(pg, core->getZoom(), core->getRotate(), gFalse, gFalse);
00224 }
00225
00226 void XPDFViewer::displayPage(int pageA, int zoomA, int rotateA,
00227 GBool scrollToTop, GBool addToHist) {
00228 core->displayPage(pageA, zoomA, rotateA, scrollToTop, addToHist);
00229 }
00230
00231 void XPDFViewer::displayDest(LinkDest *dest, int zoomA, int rotateA,
00232 GBool addToHist) {
00233 core->displayDest(dest, zoomA, rotateA, addToHist);
00234 }
00235
00236 void XPDFViewer::getPageAndDest(int pageA, GString *destName,
00237 int *pageOut, LinkDest **destOut) {
00238 Ref pageRef;
00239
00240
00241 *pageOut = pageA;
00242 *destOut = NULL;
00243 if (destName && (*destOut = core->getDoc()->findDest(destName))) {
00244 if ((*destOut)->isPageRef()) {
00245 pageRef = (*destOut)->getPageRef();
00246 *pageOut = core->getDoc()->findPage(pageRef.num, pageRef.gen);
00247 } else {
00248 *pageOut = (*destOut)->getPageNum();
00249 }
00250 }
00251
00252 if (*pageOut <= 0) {
00253 *pageOut = 1;
00254 }
00255 if (*pageOut > core->getDoc()->getNumPages()) {
00256 *pageOut = core->getDoc()->getNumPages();
00257 }
00258 }
00259
00260
00261
00262
00263
00264 GString *XPDFViewer::reqPasswordCbk(void *data, GBool again) {
00265 XPDFViewer *viewer = (XPDFViewer *)data;
00266
00267 viewer->getPassword(again);
00268 return viewer->password;
00269 }
00270
00271
00272
00273
00274
00275 void XPDFViewer::actionCbk(void *data, char *action) {
00276 XPDFViewer *viewer = (XPDFViewer *)data;
00277
00278 if (!strcmp(action, "Quit")) {
00279 viewer->app->quit();
00280 }
00281 }
00282
00283
00284
00285
00286
00287 void XPDFViewer::keyPressCbk(void *data, char *s, KeySym key,
00288 Guint modifiers) {
00289 XPDFViewer *viewer = (XPDFViewer *)data;
00290 int z;
00291
00292 if (s[0]) {
00293 switch (s[0]) {
00294 case 'O':
00295 case 'o':
00296 viewer->mapOpenDialog(gFalse);
00297 break;
00298 case 'R':
00299 case 'r':
00300 viewer->reloadFile();
00301 break;
00302 case 'F':
00303 case 'f':
00304 case '\006':
00305 if (viewer->core->getDoc()) {
00306 XtManageChild(viewer->findDialog);
00307 }
00308 break;
00309 case '\007':
00310 if (viewer->core->getDoc()) {
00311 XPDFViewer::findFindCbk(None, viewer, NULL);
00312 }
00313 break;
00314 case '\020':
00315 if (viewer->core->getDoc()) {
00316 XtManageChild(viewer->printDialog);
00317 }
00318 break;
00319 case 'N':
00320 case 'n':
00321 viewer->core->gotoNextPage(1, !(modifiers & Mod5Mask));
00322 break;
00323 case 'P':
00324 case 'p':
00325 viewer->core->gotoPrevPage(1, !(modifiers & Mod5Mask), gFalse);
00326 break;
00327 case ' ':
00328 if (viewer->app->getFullScreen()) {
00329 viewer->core->gotoNextPage(1, gTrue);
00330 } else {
00331 viewer->core->scrollPageDown();
00332 }
00333 break;
00334 case '\b':
00335 case '\177':
00336 if (viewer->app->getFullScreen()) {
00337 viewer->core->gotoPrevPage(1, gTrue, gFalse);
00338 } else {
00339 viewer->core->scrollPageUp();
00340 }
00341 break;
00342 case 'v':
00343 viewer->core->goForward();
00344 break;
00345 case 'b':
00346 viewer->core->goBackward();
00347 break;
00348 case 'g':
00349 if (!viewer->app->getFullScreen()) {
00350 XmTextFieldSetSelection(
00351 viewer->pageNumText, 0,
00352 strlen(XmTextFieldGetString(viewer->pageNumText)),
00353 XtLastTimestampProcessed(viewer->display));
00354 XmProcessTraversal(viewer->pageNumText, XmTRAVERSE_CURRENT);
00355 }
00356 break;
00357 case 'h':
00358 if (!viewer->app->getFullScreen() && viewer->app->getViKeys()) {
00359 viewer->core->scrollLeft();
00360 }
00361 break;
00362 case 'l':
00363 if (!viewer->app->getFullScreen() && viewer->app->getViKeys()) {
00364 viewer->core->scrollRight();
00365 }
00366 break;
00367 case 'k':
00368 if (!viewer->app->getFullScreen() && viewer->app->getViKeys()) {
00369 viewer->core->scrollUp();
00370 }
00371 break;
00372 case 'j':
00373 if (!viewer->app->getFullScreen() && viewer->app->getViKeys()) {
00374 viewer->core->scrollDown();
00375 }
00376 break;
00377 case '0':
00378 if (!viewer->app->getFullScreen() &&
00379 viewer->core->getZoom() != defZoom) {
00380 XtVaSetValues(viewer->zoomMenu,
00381 XmNmenuHistory, viewer->getZoomMenuBtn(defZoom),
00382 NULL);
00383 viewer->displayPage(viewer->core->getPageNum(), defZoom,
00384 viewer->core->getRotate(), gTrue, gFalse);
00385 }
00386 break;
00387 case '+':
00388 if (!viewer->app->getFullScreen() &&
00389 viewer->core->getZoom() >= minZoom &&
00390 viewer->core->getZoom() < maxZoom) {
00391 z = viewer->core->getZoom() + 1;
00392 XtVaSetValues(viewer->zoomMenu,
00393 XmNmenuHistory, viewer->getZoomMenuBtn(z),
00394 NULL);
00395 viewer->displayPage(viewer->core->getPageNum(), z,
00396 viewer->core->getRotate(), gTrue, gFalse);
00397 }
00398 break;
00399 case '-':
00400 if (!viewer->app->getFullScreen() &&
00401 viewer->core->getZoom() > minZoom &&
00402 viewer->core->getZoom() <= maxZoom) {
00403 z = viewer->core->getZoom() - 1;
00404 XtVaSetValues(viewer->zoomMenu,
00405 XmNmenuHistory, viewer->getZoomMenuBtn(z),
00406 NULL);
00407 viewer->displayPage(viewer->core->getPageNum(), z,
00408 viewer->core->getRotate(), gTrue, gFalse);
00409 }
00410 break;
00411 case 'z':
00412 if (!viewer->app->getFullScreen() &&
00413 viewer->core->getZoom() != zoomPage) {
00414 XtVaSetValues(viewer->zoomMenu,
00415 XmNmenuHistory, viewer->getZoomMenuBtn(zoomPage),
00416 NULL);
00417 viewer->displayPage(viewer->core->getPageNum(), zoomPage,
00418 viewer->core->getRotate(), gTrue, gFalse);
00419 }
00420 break;
00421 case 'w':
00422 if (!viewer->app->getFullScreen() &&
00423 viewer->core->getZoom() != zoomWidth) {
00424 XtVaSetValues(viewer->zoomMenu,
00425 XmNmenuHistory, viewer->getZoomMenuBtn(zoomWidth),
00426 NULL);
00427 viewer->displayPage(viewer->core->getPageNum(), zoomWidth,
00428 viewer->core->getRotate(), gTrue, gFalse);
00429 }
00430 break;
00431 case '\014':
00432 viewer->displayPage(viewer->core->getPageNum(), viewer->core->getZoom(),
00433 viewer->core->getRotate(), gFalse, gFalse);
00434 break;
00435 case '\027':
00436 viewer->app->close(viewer, gFalse);
00437 break;
00438 case '?':
00439 XtManageChild(viewer->aboutDialog);
00440 break;
00441 case 'Q':
00442 case 'q':
00443 viewer->app->quit();
00444 break;
00445 }
00446 }
00447 }
00448
00449 void XPDFViewer::mouseCbk(void *data, XEvent *event) {
00450 XPDFViewer *viewer = (XPDFViewer *)data;
00451
00452 if (event->type == ButtonPress && event->xbutton.button == 3) {
00453 XmMenuPosition(viewer->popupMenu, &event->xbutton);
00454 XtManageChild(viewer->popupMenu);
00455 }
00456 }
00457
00458
00459
00460
00461
00462 void XPDFViewer::initWindow() {
00463 Widget btn, label, menuPane, lastBtn;
00464 #ifndef DISABLE_OUTLINE
00465 Widget clipWin;
00466 #endif
00467 Colormap colormap;
00468 XColor xcol;
00469 Arg args[20];
00470 int n;
00471 char *title;
00472 XmString s, s2, emptyString;
00473 char buf[16];
00474 int i;
00475
00476 display = XtDisplay(app->getAppShell());
00477 screenNum = XScreenNumberOfScreen(XtScreen(app->getAppShell()));
00478
00479
00480 if (app->getInstallCmap()) {
00481 XtVaGetValues(app->getAppShell(), XmNcolormap, &colormap, NULL);
00482
00483
00484 xcol.red = xcol.green = xcol.blue = 0;
00485 XAllocColor(display, colormap, &xcol);
00486 xcol.red = xcol.green = xcol.blue = 65535;
00487 XAllocColor(display, colormap, &xcol);
00488 colormap = XCopyColormapAndFree(display, colormap);
00489 }
00490
00491
00492 n = 0;
00493 title = app->getTitle() ? app->getTitle()->getCString()
00494 : (char *)xpdfAppName;
00495 XtSetArg(args[n], XmNtitle, title); ++n;
00496 XtSetArg(args[n], XmNiconName, title); ++n;
00497 XtSetArg(args[n], XmNminWidth, 100); ++n;
00498 XtSetArg(args[n], XmNminHeight, 100); ++n;
00499 XtSetArg(args[n], XmNbaseWidth, 0); ++n;
00500 XtSetArg(args[n], XmNbaseHeight, 0); ++n;
00501 XtSetArg(args[n], XmNdeleteResponse, XmDO_NOTHING); ++n;
00502 if (app->getFullScreen()) {
00503 XtSetArg(args[n], XmNmwmDecorations, 0); ++n;
00504 XtSetArg(args[n], XmNgeometry, "+0+0"); ++n;
00505 } else if (app->getGeometry()) {
00506 XtSetArg(args[n], XmNgeometry, app->getGeometry()->getCString()); ++n;
00507 }
00508 win = XtCreatePopupShell("win", topLevelShellWidgetClass,
00509 app->getAppShell(), args, n);
00510 if (app->getInstallCmap()) {
00511 XtVaSetValues(win, XmNcolormap, colormap, NULL);
00512 }
00513 XmAddWMProtocolCallback(win, XInternAtom(display, "WM_DELETE_WINDOW", False),
00514 &closeMsgCbk, this);
00515
00516
00517 n = 0;
00518 form = XmCreateForm(win, "form", args, n);
00519 XtManageChild(form);
00520
00521
00522 n = 0;
00523 XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); ++n;
00524 XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); ++n;
00525 XtSetArg(args[n], XmNbottomAttachment, XmATTACH_FORM); ++n;
00526 toolBar = XmCreateForm(form, "toolBar", args, n);
00527 XtManageChild(toolBar);
00528
00529
00530
00531 emptyString = XmStringCreateLocalized("");
00532
00533
00534 n = 0;
00535 XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); ++n;
00536 XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); ++n;
00537 XtSetArg(args[n], XmNbottomAttachment, XmATTACH_FORM); ++n;
00538 XtSetArg(args[n], XmNmarginWidth, 6); ++n;
00539 XtSetArg(args[n], XmNsensitive, False); ++n;
00540 XtSetArg(args[n], XmNlabelString, emptyString); ++n;
00541 backBtn = XmCreatePushButton(toolBar, "back", args, n);
00542 XtManageChild(backBtn);
00543 XtAddCallback(backBtn, XmNactivateCallback,
00544 &backCbk, (XtPointer)this);
00545 n = 0;
00546 XtSetArg(args[n], XmNleftAttachment, XmATTACH_WIDGET); ++n;
00547 XtSetArg(args[n], XmNleftWidget, backBtn); ++n;
00548 XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); ++n;
00549 XtSetArg(args[n], XmNbottomAttachment, XmATTACH_FORM); ++n;
00550 XtSetArg(args[n], XmNmarginWidth, 6); ++n;
00551 XtSetArg(args[n], XmNsensitive, False); ++n;
00552 XtSetArg(args[n], XmNlabelString, emptyString); ++n;
00553 prevTenPageBtn = XmCreatePushButton(toolBar, "prevTenPage", args, n);
00554 XtManageChild(prevTenPageBtn);
00555 XtAddCallback(prevTenPageBtn, XmNactivateCallback,
00556 &prevTenPageCbk, (XtPointer)this);
00557 n = 0;
00558 XtSetArg(args[n], XmNleftAttachment, XmATTACH_WIDGET); ++n;
00559 XtSetArg(args[n], XmNleftWidget, prevTenPageBtn); ++n;
00560 XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); ++n;
00561 XtSetArg(args[n], XmNbottomAttachment, XmATTACH_FORM); ++n;
00562 XtSetArg(args[n], XmNmarginWidth, 6); ++n;
00563 XtSetArg(args[n], XmNsensitive, False); ++n;
00564 XtSetArg(args[n], XmNlabelString, emptyString); ++n;
00565 prevPageBtn = XmCreatePushButton(toolBar, "prevPage", args, n);
00566 XtManageChild(prevPageBtn);
00567 XtAddCallback(prevPageBtn, XmNactivateCallback,
00568 &prevPageCbk, (XtPointer)this);
00569 n = 0;
00570 XtSetArg(args[n], XmNleftAttachment, XmATTACH_WIDGET); ++n;
00571 XtSetArg(args[n], XmNleftWidget, prevPageBtn); ++n;
00572 XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); ++n;
00573 XtSetArg(args[n], XmNbottomAttachment, XmATTACH_FORM); ++n;
00574 XtSetArg(args[n], XmNmarginWidth, 6); ++n;
00575 XtSetArg(args[n], XmNsensitive, False); ++n;
00576 XtSetArg(args[n], XmNlabelString, emptyString); ++n;
00577 nextPageBtn = XmCreatePushButton(toolBar, "nextPage", args, n);
00578 XtManageChild(nextPageBtn);
00579 XtAddCallback(nextPageBtn, XmNactivateCallback,
00580 &nextPageCbk, (XtPointer)this);
00581 n = 0;
00582 XtSetArg(args[n], XmNleftAttachment, XmATTACH_WIDGET); ++n;
00583 XtSetArg(args[n], XmNleftWidget, nextPageBtn); ++n;
00584 XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); ++n;
00585 XtSetArg(args[n], XmNbottomAttachment, XmATTACH_FORM); ++n;
00586 XtSetArg(args[n], XmNmarginWidth, 6); ++n;
00587 XtSetArg(args[n], XmNsensitive, False); ++n;
00588 XtSetArg(args[n], XmNlabelString, emptyString); ++n;
00589 nextTenPageBtn = XmCreatePushButton(toolBar, "nextTenPage", args, n);
00590 XtManageChild(nextTenPageBtn);
00591 XtAddCallback(nextTenPageBtn, XmNactivateCallback,
00592 &nextTenPageCbk, (XtPointer)this);
00593 n = 0;
00594 XtSetArg(args[n], XmNleftAttachment, XmATTACH_WIDGET); ++n;
00595 XtSetArg(args[n], XmNleftWidget, nextTenPageBtn); ++n;
00596 XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); ++n;
00597 XtSetArg(args[n], XmNbottomAttachment, XmATTACH_FORM); ++n;
00598 XtSetArg(args[n], XmNmarginWidth, 6); ++n;
00599 XtSetArg(args[n], XmNsensitive, False); ++n;
00600 XtSetArg(args[n], XmNlabelString, emptyString); ++n;
00601 forwardBtn = XmCreatePushButton(toolBar, "forward", args, n);
00602 XtManageChild(forwardBtn);
00603 XtAddCallback(forwardBtn, XmNactivateCallback,
00604 &forwardCbk, (XtPointer)this);
00605
00606
00607 n = 0;
00608 XtSetArg(args[n], XmNleftAttachment, XmATTACH_WIDGET); ++n;
00609 XtSetArg(args[n], XmNleftWidget, forwardBtn); ++n;
00610 XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); ++n;
00611 XtSetArg(args[n], XmNbottomAttachment, XmATTACH_FORM); ++n;
00612 s = XmStringCreateLocalized("Page ");
00613 XtSetArg(args[n], XmNlabelString, s); ++n;
00614 label = XmCreateLabel(toolBar, "pageLabel", args, n);
00615 XmStringFree(s);
00616 XtManageChild(label);
00617 n = 0;
00618 XtSetArg(args[n], XmNleftAttachment, XmATTACH_WIDGET); ++n;
00619 XtSetArg(args[n], XmNleftWidget, label); ++n;
00620 XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); ++n;
00621 XtSetArg(args[n], XmNbottomAttachment, XmATTACH_FORM); ++n;
00622 XtSetArg(args[n], XmNmarginWidth, 3); ++n;
00623 XtSetArg(args[n], XmNmarginHeight, 3); ++n;
00624 XtSetArg(args[n], XmNcolumns, 5); ++n;
00625 pageNumText = XmCreateTextField(toolBar, "pageNum", args, n);
00626 XtManageChild(pageNumText);
00627 XtAddCallback(pageNumText, XmNactivateCallback,
00628 &pageNumCbk, (XtPointer)this);
00629 n = 0;
00630 XtSetArg(args[n], XmNleftAttachment, XmATTACH_WIDGET); ++n;
00631 XtSetArg(args[n], XmNleftWidget, pageNumText); ++n;
00632 XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); ++n;
00633 XtSetArg(args[n], XmNbottomAttachment, XmATTACH_FORM); ++n;
00634 s = XmStringCreateLocalized(" of 00000");
00635 XtSetArg(args[n], XmNlabelString, s); ++n;
00636 XtSetArg(args[n], XmNalignment, XmALIGNMENT_BEGINNING); ++n;
00637 XtSetArg(args[n], XmNrecomputeSize, False); ++n;
00638 pageCountLabel = XmCreateLabel(toolBar, "pageCountLabel", args, n);
00639 XmStringFree(s);
00640 XtManageChild(pageCountLabel);
00641 s = XmStringCreateLocalized(" of 0");
00642 XtVaSetValues(pageCountLabel, XmNlabelString, s, NULL);
00643 XmStringFree(s);
00644
00645
00646 n = 0;
00647 menuPane = XmCreatePulldownMenu(toolBar, "zoomMenuPane", args, n);
00648 for (i = minZoom; i <= maxZoom; ++i) {
00649 n = 0;
00650 sprintf(buf, "%s%d", i > 0 ? "+" : "", i);
00651 s = XmStringCreateLocalized(buf);
00652 XtSetArg(args[n], XmNlabelString, s); ++n;
00653 XtSetArg(args[n], XmNuserData, (XtPointer)i); ++n;
00654 sprintf(buf, "zoom%s%d", i < 0 ? "M" : "", i < 0 ? -i : i);
00655 btn = XmCreatePushButton(menuPane, buf, args, n);
00656 XmStringFree(s);
00657 XtManageChild(btn);
00658 XtAddCallback(btn, XmNactivateCallback,
00659 &zoomMenuCbk, (XtPointer)this);
00660 zoomMenuBtns[i - minZoom] = btn;
00661 }
00662 n = 0;
00663 s = XmStringCreateLocalized("fit page");
00664 XtSetArg(args[n], XmNlabelString, s); ++n;
00665 XtSetArg(args[n], XmNuserData, (XtPointer)zoomPage); ++n;
00666 btn = XmCreatePushButton(menuPane, "zoomPage", args, n);
00667 XmStringFree(s);
00668 XtManageChild(btn);
00669 XtAddCallback(btn, XmNactivateCallback,
00670 &zoomMenuCbk, (XtPointer)this);
00671 zoomMenuBtns[maxZoom - minZoom + 1] = btn;
00672 n = 0;
00673 s = XmStringCreateLocalized("fit width");
00674 XtSetArg(args[n], XmNlabelString, s); ++n;
00675 XtSetArg(args[n], XmNuserData, (XtPointer)zoomWidth); ++n;
00676 btn = XmCreatePushButton(menuPane, "zoomWidth", args, n);
00677 XmStringFree(s);
00678 XtManageChild(btn);
00679 XtAddCallback(btn, XmNactivateCallback,
00680 &zoomMenuCbk, (XtPointer)this);
00681 zoomMenuBtns[maxZoom - minZoom + 2] = btn;
00682 n = 0;
00683 XtSetArg(args[n], XmNleftAttachment, XmATTACH_WIDGET); ++n;
00684 XtSetArg(args[n], XmNleftWidget, pageCountLabel); ++n;
00685 XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); ++n;
00686 XtSetArg(args[n], XmNbottomAttachment, XmATTACH_FORM); ++n;
00687 XtSetArg(args[n], XmNmarginWidth, 0); ++n;
00688 XtSetArg(args[n], XmNmarginHeight, 0); ++n;
00689 XtSetArg(args[n], XmNsubMenuId, menuPane); ++n;
00690 zoomMenu = XmCreateOptionMenu(toolBar, "zoomMenu", args, n);
00691 XtManageChild(zoomMenu);
00692
00693
00694 n = 0;
00695 XtSetArg(args[n], XmNleftAttachment, XmATTACH_WIDGET); ++n;
00696 XtSetArg(args[n], XmNleftWidget, zoomMenu); ++n;
00697 XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); ++n;
00698 XtSetArg(args[n], XmNbottomAttachment, XmATTACH_FORM); ++n;
00699 XtSetArg(args[n], XmNmarginWidth, 6); ++n;
00700 XtSetArg(args[n], XmNlabelString, emptyString); ++n;
00701 findBtn = XmCreatePushButton(toolBar, "find", args, n);
00702 XtManageChild(findBtn);
00703 XtAddCallback(findBtn, XmNactivateCallback,
00704 &findCbk, (XtPointer)this);
00705 n = 0;
00706 XtSetArg(args[n], XmNleftAttachment, XmATTACH_WIDGET); ++n;
00707 XtSetArg(args[n], XmNleftWidget, findBtn); ++n;
00708 XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); ++n;
00709 XtSetArg(args[n], XmNbottomAttachment, XmATTACH_FORM); ++n;
00710 XtSetArg(args[n], XmNmarginWidth, 6); ++n;
00711 XtSetArg(args[n], XmNlabelString, emptyString); ++n;
00712 printBtn = XmCreatePushButton(toolBar, "print", args, n);
00713 XtManageChild(printBtn);
00714 XtAddCallback(printBtn, XmNactivateCallback,
00715 &printCbk, (XtPointer)this);
00716 n = 0;
00717 XtSetArg(args[n], XmNleftAttachment, XmATTACH_WIDGET); ++n;
00718 XtSetArg(args[n], XmNleftWidget, printBtn); ++n;
00719 XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); ++n;
00720 XtSetArg(args[n], XmNbottomAttachment, XmATTACH_FORM); ++n;
00721 XtSetArg(args[n], XmNmarginWidth, 6); ++n;
00722 XtSetArg(args[n], XmNlabelString, emptyString); ++n;
00723 aboutBtn = XmCreatePushButton(toolBar, "about", args, n);
00724 XtManageChild(aboutBtn);
00725 XtAddCallback(aboutBtn, XmNactivateCallback,
00726 &aboutCbk, (XtPointer)this);
00727 lastBtn = aboutBtn;
00728
00729
00730 n = 0;
00731 XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); ++n;
00732 XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); ++n;
00733 XtSetArg(args[n], XmNbottomAttachment, XmATTACH_FORM); ++n;
00734 XtSetArg(args[n], XmNmarginWidth, 6); ++n;
00735 s = XmStringCreateLocalized("Quit");
00736 XtSetArg(args[n], XmNlabelString, s); ++n;
00737 quitBtn = XmCreatePushButton(toolBar, "quit", args, n);
00738 XmStringFree(s);
00739 XtManageChild(quitBtn);
00740 XtAddCallback(quitBtn, XmNactivateCallback,
00741 &quitCbk, (XtPointer)this);
00742
00743
00744 n = 0;
00745 XtSetArg(args[n], XmNleftAttachment, XmATTACH_WIDGET); ++n;
00746 XtSetArg(args[n], XmNleftWidget, lastBtn); ++n;
00747 XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); ++n;
00748 XtSetArg(args[n], XmNrightWidget, btn); ++n;
00749 XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); ++n;
00750 XtSetArg(args[n], XmNbottomAttachment, XmATTACH_FORM); ++n;
00751 s = XmStringCreateLocalized("");
00752 XtSetArg(args[n], XmNlabelString, s); ++n;
00753 XtSetArg(args[n], XmNrecomputeSize, True); ++n;
00754 XtSetArg(args[n], XmNalignment, XmALIGNMENT_BEGINNING); ++n;
00755 linkLabel = XmCreateLabel(toolBar, "linkLabel", args, n);
00756 XmStringFree(s);
00757 XtManageChild(linkLabel);
00758
00759 #ifndef DISABLE_OUTLINE
00760 if (app->getFullScreen()) {
00761 #endif
00762
00763
00764 core = new XPDFCore(win, form, app->getPaperColor(),
00765 app->getFullScreen(), app->getReverseVideo(),
00766 app->getInstallCmap(), app->getRGBCubeSize());
00767 core->setUpdateCbk(&updateCbk, this);
00768 core->setActionCbk(&actionCbk, this);
00769 core->setKeyPressCbk(&keyPressCbk, this);
00770 core->setMouseCbk(&mouseCbk, this);
00771 core->setReqPasswordCbk(&reqPasswordCbk, this);
00772 n = 0;
00773 XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); ++n;
00774 XtSetArg(args[n], XmNbottomAttachment, XmATTACH_WIDGET); ++n;
00775 XtSetArg(args[n], XmNbottomWidget, toolBar); ++n;
00776 XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); ++n;
00777 XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); ++n;
00778 XtSetValues(core->getWidget(), args, n);
00779
00780 #ifndef DISABLE_OUTLINE
00781 } else {
00782
00783
00784 n = 0;
00785 XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); ++n;
00786 XtSetArg(args[n], XmNbottomAttachment, XmATTACH_WIDGET); ++n;
00787 XtSetArg(args[n], XmNbottomWidget, toolBar); ++n;
00788 XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); ++n;
00789 XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); ++n;
00790 XtSetArg(args[n], XmNorientation, XmHORIZONTAL); ++n;
00791 panedWin = XmCreatePanedWindow(form, "panedWin", args, n);
00792 XtManageChild(panedWin);
00793
00794
00795 n = 0;
00796 XtSetArg(args[n], XmNpositionIndex, 0); ++n;
00797 XtSetArg(args[n], XmNallowResize, True); ++n;
00798 XtSetArg(args[n], XmNpaneMinimum, 1); ++n;
00799 XtSetArg(args[n], XmNpaneMaximum, 10000); ++n;
00800 XtSetArg(args[n], XmNwidth, 1); ++n;
00801 XtSetArg(args[n], XmNscrollingPolicy, XmAUTOMATIC); ++n;
00802 outlineScroll = XmCreateScrolledWindow(panedWin, "outlineScroll", args, n);
00803 XtManageChild(outlineScroll);
00804 XtVaGetValues(outlineScroll, XmNclipWindow, &clipWin, NULL);
00805 XtVaSetValues(clipWin, XmNbackground, app->getPaperColor(), NULL);
00806
00807
00808 n = 0;
00809 XtSetArg(args[n], XmNbackground, app->getPaperColor()); ++n;
00810 outlineTree = XPDFCreateTree(outlineScroll, "outlineTree", args, n);
00811 XtManageChild(outlineTree);
00812 XtAddCallback(outlineTree, XPDFNselectionCallback, &outlineSelectCbk,
00813 (XtPointer)this);
00814
00815
00816 core = new XPDFCore(win, panedWin, app->getPaperColor(),
00817 app->getFullScreen(), app->getReverseVideo(),
00818 app->getInstallCmap(), app->getRGBCubeSize());
00819 core->setUpdateCbk(&updateCbk, this);
00820 core->setActionCbk(&actionCbk, this);
00821 core->setKeyPressCbk(&keyPressCbk, this);
00822 core->setMouseCbk(&mouseCbk, this);
00823 core->setReqPasswordCbk(&reqPasswordCbk, this);
00824 n = 0;
00825 XtSetArg(args[n], XmNpositionIndex, 1); ++n;
00826 XtSetArg(args[n], XmNallowResize, True); ++n;
00827 XtSetArg(args[n], XmNpaneMinimum, 1); ++n;
00828 XtSetArg(args[n], XmNpaneMaximum, 10000); ++n;
00829 XtSetValues(core->getWidget(), args, n);
00830 }
00831 #endif
00832
00833
00834 XtVaSetValues(zoomMenu, XmNmenuHistory,
00835 getZoomMenuBtn(core->getZoom()), NULL);
00836
00837
00838 XtVaSetValues(core->getDrawAreaWidget(),
00839 XmNnavigationType, XmEXCLUSIVE_TAB_GROUP, NULL);
00840 XtVaSetValues(backBtn, XmNnavigationType, XmEXCLUSIVE_TAB_GROUP,
00841 NULL);
00842 XtVaSetValues(prevTenPageBtn, XmNnavigationType, XmEXCLUSIVE_TAB_GROUP,
00843 NULL);
00844 XtVaSetValues(prevPageBtn, XmNnavigationType, XmEXCLUSIVE_TAB_GROUP,
00845 NULL);
00846 XtVaSetValues(nextPageBtn, XmNnavigationType, XmEXCLUSIVE_TAB_GROUP,
00847 NULL);
00848 XtVaSetValues(nextTenPageBtn, XmNnavigationType, XmEXCLUSIVE_TAB_GROUP,
00849 NULL);
00850 XtVaSetValues(forwardBtn, XmNnavigationType, XmEXCLUSIVE_TAB_GROUP,
00851 NULL);
00852 XtVaSetValues(pageNumText, XmNnavigationType, XmEXCLUSIVE_TAB_GROUP,
00853 NULL);
00854 XtVaSetValues(zoomMenu, XmNnavigationType, XmEXCLUSIVE_TAB_GROUP,
00855 NULL);
00856 XtVaSetValues(findBtn, XmNnavigationType, XmEXCLUSIVE_TAB_GROUP,
00857 NULL);
00858 XtVaSetValues(printBtn, XmNnavigationType, XmEXCLUSIVE_TAB_GROUP,
00859 NULL);
00860 XtVaSetValues(aboutBtn, XmNnavigationType, XmEXCLUSIVE_TAB_GROUP,
00861 NULL);
00862 XtVaSetValues(quitBtn, XmNnavigationType, XmEXCLUSIVE_TAB_GROUP,
00863 NULL);
00864
00865
00866 n = 0;
00867 XtSetArg(args[n], XmNmenuPost, "<Btn3Down>"); ++n;
00868 popupMenu = XmCreatePopupMenu(core->getDrawAreaWidget(), "popupMenu",
00869 args, n);
00870 n = 0;
00871 s = XmStringCreateLocalized("Open...");
00872 XtSetArg(args[n], XmNlabelString, s); ++n;
00873 s2 = XmStringCreateLocalized("O");
00874 XtSetArg(args[n], XmNacceleratorText, s2); ++n;
00875 btn = XmCreatePushButton(popupMenu, "open", args, n);
00876 XmStringFree(s);
00877 XmStringFree(s2);
00878 XtManageChild(btn);
00879 XtAddCallback(btn, XmNactivateCallback,
00880 &openCbk, (XtPointer)this);
00881 n = 0;
00882 s = XmStringCreateLocalized("Open in new window...");
00883 XtSetArg(args[n], XmNlabelString, s); ++n;
00884 btn = XmCreatePushButton(popupMenu, "openInNewWindow", args, n);
00885 XmStringFree(s);
00886 XtManageChild(btn);
00887 XtAddCallback(btn, XmNactivateCallback,
00888 &openInNewWindowCbk, (XtPointer)this);
00889 n = 0;
00890 s = XmStringCreateLocalized("Reload");
00891 XtSetArg(args[n], XmNlabelString, s); ++n;
00892 s2 = XmStringCreateLocalized("R");
00893 XtSetArg(args[n], XmNacceleratorText, s2); ++n;
00894 btn = XmCreatePushButton(popupMenu, "reload", args, n);
00895 XmStringFree(s);
00896 XmStringFree(s2);
00897 XtManageChild(btn);
00898 XtAddCallback(btn, XmNactivateCallback,
00899 &reloadCbk, (XtPointer)this);
00900 n = 0;
00901 s = XmStringCreateLocalized("Save as...");
00902 XtSetArg(args[n], XmNlabelString, s); ++n;
00903 btn = XmCreatePushButton(popupMenu, "saveAs", args, n);
00904 XmStringFree(s);
00905 XtManageChild(btn);
00906 XtAddCallback(btn, XmNactivateCallback,
00907 &saveAsCbk, (XtPointer)this);
00908 n = 0;
00909 btn = XmCreateSeparator(popupMenu, "sep1", args, n);
00910 XtManageChild(btn);
00911 n = 0;
00912 s = XmStringCreateLocalized("Rotate counterclockwise");
00913 XtSetArg(args[n], XmNlabelString, s); ++n;
00914 btn = XmCreatePushButton(popupMenu, "rotateCCW", args, n);
00915 XmStringFree(s);
00916 XtManageChild(btn);
00917 XtAddCallback(btn, XmNactivateCallback,
00918 &rotateCCWCbk, (XtPointer)this);
00919 n = 0;
00920 s = XmStringCreateLocalized("Rotate clockwise");
00921 XtSetArg(args[n], XmNlabelString, s); ++n;
00922 btn = XmCreatePushButton(popupMenu, "rotateCW", args, n);
00923 XmStringFree(s);
00924 XtManageChild(btn);
00925 XtAddCallback(btn, XmNactivateCallback,
00926 &rotateCWCbk, (XtPointer)this);
00927 n = 0;
00928 btn = XmCreateSeparator(popupMenu, "sep2", args, n);
00929 XtManageChild(btn);
00930 n = 0;
00931 s = XmStringCreateLocalized("Close");
00932 XtSetArg(args[n], XmNlabelString, s); ++n;
00933 s2 = XmStringCreateLocalized("Ctrl+W");
00934 XtSetArg(args[n], XmNacceleratorText, s2); ++n;
00935 btn = XmCreatePushButton(popupMenu, "close", args, n);
00936 XmStringFree(s);
00937 XmStringFree(s2);
00938 XtManageChild(btn);
00939 XtAddCallback(btn, XmNactivateCallback,
00940 &closeCbk, (XtPointer)this);
00941 n = 0;
00942 s = XmStringCreateLocalized("Quit");
00943 XtSetArg(args[n], XmNlabelString, s); ++n;
00944 s2 = XmStringCreateLocalized("Q");
00945 XtSetArg(args[n], XmNacceleratorText, s2); ++n;
00946 btn = XmCreatePushButton(popupMenu, "quit", args, n);
00947 XmStringFree(s);
00948 XmStringFree(s2);
00949 XtManageChild(btn);
00950 XtAddCallback(btn, XmNactivateCallback,
00951 &quitCbk, (XtPointer)this);
00952
00953 XmStringFree(emptyString);
00954 }
00955
00956 void XPDFViewer::mapWindow() {
00957 #ifdef HAVE_X11_XPM_H
00958 Pixmap iconPixmap;
00959 #endif
00960 int depth;
00961 Pixel bg, arm;
00962
00963
00964 XtPopup(win, XtGrabNone);
00965 core->takeFocus();
00966
00967
00968 #ifdef HAVE_X11_XPM_H
00969 if (XpmCreatePixmapFromData(display, XtWindow(win), xpdfIcon,
00970 &iconPixmap, NULL, NULL) == XpmSuccess) {
00971 XtVaSetValues(win, XmNiconPixmap, iconPixmap, NULL);
00972 }
00973 #endif
00974
00975
00976 XtVaGetValues(backBtn, XmNdepth, &depth,
00977 XmNbackground, &bg, XmNarmColor, &arm, NULL);
00978 XtVaSetValues(backBtn, XmNlabelType, XmPIXMAP,
00979 XmNlabelPixmap,
00980 XCreatePixmapFromBitmapData(display, XtWindow(toolBar),
00981 (char *)backArrow_bits,
00982 backArrow_width,
00983 backArrow_height,
00984 BlackPixel(display, screenNum),
00985 bg, depth),
00986 XmNarmPixmap,
00987 XCreatePixmapFromBitmapData(display, XtWindow(toolBar),
00988 (char *)backArrow_bits,
00989 backArrow_width,
00990 backArrow_height,
00991 BlackPixel(display, screenNum),
00992 arm, depth),
00993 XmNlabelInsensitivePixmap,
00994 XCreatePixmapFromBitmapData(display, XtWindow(toolBar),
00995 (char *)backArrowDis_bits,
00996 backArrowDis_width,
00997 backArrowDis_height,
00998 BlackPixel(display, screenNum),
00999 bg, depth),
01000 NULL);
01001 XtVaSetValues(prevTenPageBtn, XmNlabelType, XmPIXMAP,
01002 XmNlabelPixmap,
01003 XCreatePixmapFromBitmapData(display, XtWindow(toolBar),
01004 (char *)dblLeftArrow_bits,
01005 dblLeftArrow_width,
01006 dblLeftArrow_height,
01007 BlackPixel(display, screenNum),
01008 bg, depth),
01009 XmNarmPixmap,
01010 XCreatePixmapFromBitmapData(display, XtWindow(toolBar),
01011 (char *)dblLeftArrow_bits,
01012 dblLeftArrow_width,
01013 dblLeftArrow_height,
01014 BlackPixel(display, screenNum),
01015 arm, depth),
01016 XmNlabelInsensitivePixmap,
01017 XCreatePixmapFromBitmapData(display, XtWindow(toolBar),
01018 (char *)dblLeftArrowDis_bits,
01019 dblLeftArrowDis_width,
01020 dblLeftArrowDis_height,
01021 BlackPixel(display, screenNum),
01022 bg, depth),
01023 NULL);
01024 XtVaSetValues(prevPageBtn, XmNlabelType, XmPIXMAP,
01025 XmNlabelPixmap,
01026 XCreatePixmapFromBitmapData(display, XtWindow(toolBar),
01027 (char *)leftArrow_bits,
01028 leftArrow_width,
01029 leftArrow_height,
01030 BlackPixel(display, screenNum),
01031 bg, depth),
01032 XmNarmPixmap,
01033 XCreatePixmapFromBitmapData(display, XtWindow(toolBar),
01034 (char *)leftArrow_bits,
01035 leftArrow_width,
01036 leftArrow_height,
01037 BlackPixel(display, screenNum),
01038 arm, depth),
01039 XmNlabelInsensitivePixmap,
01040 XCreatePixmapFromBitmapData(display, XtWindow(toolBar),
01041 (char *)leftArrowDis_bits,
01042 leftArrowDis_width,
01043 leftArrowDis_height,
01044 BlackPixel(display, screenNum),
01045 bg, depth),
01046 NULL);
01047 XtVaSetValues(nextPageBtn, XmNlabelType, XmPIXMAP,
01048 XmNlabelPixmap,
01049 XCreatePixmapFromBitmapData(display, XtWindow(toolBar),
01050 (char *)rightArrow_bits,
01051 rightArrow_width,
01052 rightArrow_height,
01053 BlackPixel(display, screenNum),
01054 bg, depth),
01055 XmNarmPixmap,
01056 XCreatePixmapFromBitmapData(display, XtWindow(toolBar),
01057 (char *)rightArrow_bits,
01058 rightArrow_width,
01059 rightArrow_height,
01060 BlackPixel(display, screenNum),
01061 arm, depth),
01062 XmNlabelInsensitivePixmap,
01063 XCreatePixmapFromBitmapData(display, XtWindow(toolBar),
01064 (char *)rightArrowDis_bits,
01065 rightArrowDis_width,
01066 rightArrowDis_height,
01067 BlackPixel(display, screenNum),
01068 bg, depth),
01069 NULL);
01070 XtVaSetValues(nextTenPageBtn, XmNlabelType, XmPIXMAP,
01071 XmNlabelPixmap,
01072 XCreatePixmapFromBitmapData(display, XtWindow(toolBar),
01073 (char *)dblRightArrow_bits,
01074 dblRightArrow_width,
01075 dblRightArrow_height,
01076 BlackPixel(display, screenNum),
01077 bg, depth),
01078 XmNarmPixmap,
01079 XCreatePixmapFromBitmapData(display, XtWindow(toolBar),
01080 (char *)dblRightArrow_bits,
01081 dblRightArrow_width,
01082 dblRightArrow_height,
01083 BlackPixel(display, screenNum),
01084 arm, depth),
01085 XmNlabelInsensitivePixmap,
01086 XCreatePixmapFromBitmapData(display, XtWindow(toolBar),
01087 (char *)dblRightArrowDis_bits,
01088 dblRightArrowDis_width,
01089 dblRightArrowDis_height,
01090 BlackPixel(display, screenNum),
01091 bg, depth),
01092 NULL);
01093 XtVaSetValues(forwardBtn, XmNlabelType, XmPIXMAP,
01094 XmNlabelPixmap,
01095 XCreatePixmapFromBitmapData(display, XtWindow(toolBar),
01096 (char *)forwardArrow_bits,
01097 forwardArrow_width,
01098 forwardArrow_height,
01099 BlackPixel(display, screenNum),
01100 bg, depth),
01101 XmNarmPixmap,
01102 XCreatePixmapFromBitmapData(display, XtWindow(toolBar),
01103 (char *)forwardArrow_bits,
01104 forwardArrow_width,
01105 forwardArrow_height,
01106 BlackPixel(display, screenNum),
01107 arm, depth),
01108 XmNlabelInsensitivePixmap,
01109 XCreatePixmapFromBitmapData(display, XtWindow(toolBar),
01110 (char *)forwardArrowDis_bits,
01111 forwardArrowDis_width,
01112 forwardArrowDis_height,
01113 BlackPixel(display, screenNum),
01114 bg, depth),
01115 NULL);
01116 XtVaSetValues(findBtn, XmNlabelType, XmPIXMAP,
01117 XmNlabelPixmap,
01118 XCreatePixmapFromBitmapData(display, XtWindow(toolBar),
01119 (char *)find_bits,
01120 find_width,
01121 find_height,
01122 BlackPixel(display, screenNum),
01123 bg, depth),
01124 XmNarmPixmap,
01125 XCreatePixmapFromBitmapData(display, XtWindow(toolBar),
01126 (char *)find_bits,
01127 find_width,
01128 find_height,
01129 BlackPixel(display, screenNum),
01130 arm, depth),
01131 XmNlabelInsensitivePixmap,
01132 XCreatePixmapFromBitmapData(display, XtWindow(toolBar),
01133 (char *)findDis_bits,
01134 findDis_width,
01135 findDis_height,
01136 BlackPixel(display, screenNum),
01137 bg, depth),
01138 NULL);
01139 XtVaSetValues(printBtn, XmNlabelType, XmPIXMAP,
01140 XmNlabelPixmap,
01141 XCreatePixmapFromBitmapData(display, XtWindow(toolBar),
01142 (char *)print_bits,
01143 print_width,
01144 print_height,
01145 BlackPixel(display, screenNum),
01146 bg, depth),
01147 XmNarmPixmap,
01148 XCreatePixmapFromBitmapData(display, XtWindow(toolBar),
01149 (char *)print_bits,
01150 print_width,
01151 print_height,
01152 BlackPixel(display, screenNum),
01153 arm, depth),
01154 XmNlabelInsensitivePixmap,
01155 XCreatePixmapFromBitmapData(display, XtWindow(toolBar),
01156 (char *)printDis_bits,
01157 printDis_width,
01158 printDis_height,
01159 BlackPixel(display, screenNum),
01160 bg, depth),
01161 NULL);
01162 XtVaSetValues(aboutBtn, XmNlabelType, XmPIXMAP,
01163 XmNlabelPixmap,
01164 XCreatePixmapFromBitmapData(display, XtWindow(toolBar),
01165 (char *)about_bits,
01166 about_width,
01167 about_height,
01168 BlackPixel(display, screenNum),
01169 bg, depth),
01170 XmNarmPixmap,
01171 XCreatePixmapFromBitmapData(display, XtWindow(toolBar),
01172 (char *)about_bits,
01173 about_width,
01174 about_height,
01175 BlackPixel(display, screenNum),
01176 arm, depth),
01177 NULL);
01178 }
01179
01180 void XPDFViewer::closeWindow() {
01181 XtPopdown(win);
01182 XtDestroyWidget(win);
01183 }
01184
01185 Widget XPDFViewer::getZoomMenuBtn(int z) {
01186 if (z >= minZoom && z <= maxZoom) {
01187 return zoomMenuBtns[z - minZoom];
01188 }
01189 if (z == zoomPage) {
01190 return zoomMenuBtns[maxZoom - minZoom + 1];
01191 }
01192 if (z == zoomWidth) {
01193 return zoomMenuBtns[maxZoom - minZoom + 2];
01194 }
01195 return zoomMenuBtns[0];
01196 }
01197
01198 void XPDFViewer::prevPageCbk(Widget widget, XtPointer ptr,
01199 XtPointer callData) {
01200 XPDFViewer *viewer = (XPDFViewer *)ptr;
01201
01202 viewer->core->gotoPrevPage(1, gTrue, gFalse);
01203 viewer->core->takeFocus();
01204 }
01205
01206 void XPDFViewer::prevTenPageCbk(Widget widget, XtPointer ptr,
01207 XtPointer callData) {
01208 XPDFViewer *viewer = (XPDFViewer *)ptr;
01209
01210 viewer->core->gotoPrevPage(10, gTrue, gFalse);
01211 viewer->core->takeFocus();
01212 }
01213
01214 void XPDFViewer::nextPageCbk(Widget widget, XtPointer ptr,
01215 XtPointer callData) {
01216 XPDFViewer *viewer = (XPDFViewer *)ptr;
01217
01218 viewer->core->gotoNextPage(1, gTrue);
01219 viewer->core->takeFocus();
01220 }
01221
01222 void XPDFViewer::nextTenPageCbk(Widget widget, XtPointer ptr,
01223 XtPointer callData) {
01224 XPDFViewer *viewer = (XPDFViewer *)ptr;
01225
01226 viewer->core->gotoNextPage(10, gTrue);
01227 viewer->core->takeFocus();
01228 }
01229
01230 void XPDFViewer::backCbk(Widget widget, XtPointer ptr,
01231 XtPointer callData) {
01232 XPDFViewer *viewer = (XPDFViewer *)ptr;
01233
01234 viewer->core->goBackward();
01235 viewer->core->takeFocus();
01236 }
01237
01238 void XPDFViewer::forwardCbk(Widget widget, XtPointer ptr,
01239 XtPointer callData) {
01240 XPDFViewer *viewer = (XPDFViewer *)ptr;
01241
01242 viewer->core->goForward();
01243 viewer->core->takeFocus();
01244 }
01245
01246 void XPDFViewer::zoomMenuCbk(Widget widget, XtPointer ptr,
01247 XtPointer callData) {
01248 XPDFViewer *viewer = (XPDFViewer *)ptr;
01249 XtPointer userData;
01250
01251 XtVaGetValues(widget, XmNuserData, &userData, NULL);
01252 if ((int)userData != viewer->core->getZoom()) {
01253 viewer->displayPage(viewer->core->getPageNum(), (int)userData,
01254 viewer->core->getRotate(), gTrue, gFalse);
01255 }
01256 viewer->core->takeFocus();
01257 }
01258
01259 void XPDFViewer::findCbk(Widget widget, XtPointer ptr,
01260 XtPointer callData) {
01261 XPDFViewer *viewer = (XPDFViewer *)ptr;
01262
01263 if (!viewer->core->getDoc()) {
01264 return;
01265 }
01266 XtManageChild(viewer->findDialog);
01267 }
01268
01269 void XPDFViewer::printCbk(Widget widget, XtPointer ptr,
01270 XtPointer callData) {
01271 XPDFViewer *viewer = (XPDFViewer *)ptr;
01272
01273 if (!viewer->core->getDoc()) {
01274 return;
01275 }
01276 XtManageChild(viewer->printDialog);
01277 }
01278
01279 void XPDFViewer::aboutCbk(Widget widget, XtPointer ptr,
01280 XtPointer callData) {
01281 XPDFViewer *viewer = (XPDFViewer *)ptr;
01282
01283 XtManageChild(viewer->aboutDialog);
01284 }
01285
01286 void XPDFViewer::quitCbk(Widget widget, XtPointer ptr,
01287 XtPointer callData) {
01288 XPDFViewer *viewer = (XPDFViewer *)ptr;
01289
01290 viewer->app->quit();
01291 }
01292
01293 void XPDFViewer::openCbk(Widget widget, XtPointer ptr,
01294 XtPointer callData) {
01295 XPDFViewer *viewer = (XPDFViewer *)ptr;
01296
01297 viewer->mapOpenDialog(gFalse);
01298 }
01299
01300 void XPDFViewer::openInNewWindowCbk(Widget widget, XtPointer ptr,
01301 XtPointer callData) {
01302 XPDFViewer *viewer = (XPDFViewer *)ptr;
01303
01304 viewer->mapOpenDialog(gTrue);
01305 }
01306
01307 void XPDFViewer::reloadCbk(Widget widget, XtPointer ptr,
01308 XtPointer callData) {
01309 XPDFViewer *viewer = (XPDFViewer *)ptr;
01310
01311 viewer->reloadFile();
01312 }
01313
01314 void XPDFViewer::saveAsCbk(Widget widget, XtPointer ptr,
01315 XtPointer callData) {
01316 XPDFViewer *viewer = (XPDFViewer *)ptr;
01317
01318 if (!viewer->core->getDoc()) {
01319 return;
01320 }
01321 viewer->mapSaveAsDialog();
01322 }
01323
01324 void XPDFViewer::rotateCCWCbk(Widget widget, XtPointer ptr,
01325 XtPointer callData) {
01326 XPDFViewer *viewer = (XPDFViewer *)ptr;
01327 int r;
01328
01329 r = viewer->core->getRotate();
01330 r = (r == 0) ? 270 : r - 90;
01331 viewer->displayPage(viewer->core->getPageNum(), viewer->core->getZoom(),
01332 r, gTrue, gFalse);
01333 }
01334
01335 void XPDFViewer::rotateCWCbk(Widget widget, XtPointer ptr,
01336 XtPointer callData) {
01337 XPDFViewer *viewer = (XPDFViewer *)ptr;
01338 int r;
01339
01340 r = viewer->core->getRotate();
01341 r = (r == 270) ? 0 : r + 90;
01342 viewer->displayPage(viewer->core->getPageNum(), viewer->core->getZoom(),
01343 r, gTrue, gFalse);
01344 }
01345
01346 void XPDFViewer::closeCbk(Widget widget, XtPointer ptr,
01347 XtPointer callData) {
01348 XPDFViewer *viewer = (XPDFViewer *)ptr;
01349
01350 viewer->app->close(viewer, gFalse);
01351 }
01352
01353 void XPDFViewer::closeMsgCbk(Widget widget, XtPointer ptr,
01354 XtPointer callData) {
01355 XPDFViewer *viewer = (XPDFViewer *)ptr;
01356
01357 viewer->app->close(viewer, gTrue);
01358 }
01359
01360 void XPDFViewer::pageNumCbk(Widget widget, XtPointer ptr,
01361 XtPointer callData) {
01362 XPDFViewer *viewer = (XPDFViewer *)ptr;
01363 char *s, *p;
01364 int pg;
01365 char buf[20];
01366
01367 if (!viewer->core->getDoc()) {
01368 goto err;
01369 }
01370 s = XmTextFieldGetString(viewer->pageNumText);
01371 for (p = s; *p; ++p) {
01372 if (!isdigit(*p)) {
01373 goto err;
01374 }
01375 }
01376 pg = atoi(s);
01377 if (pg < 1 || pg > viewer->core->getDoc()->getNumPages()) {
01378 goto err;
01379 }
01380 viewer->displayPage(pg, viewer->core->getZoom(),
01381 viewer->core->getRotate(), gFalse, gTrue);
01382 viewer->core->takeFocus();
01383 return;
01384
01385 err:
01386 XBell(viewer->display, 0);
01387 sprintf(buf, "%d", viewer->core->getPageNum());
01388 XmTextFieldSetString(viewer->pageNumText, buf);
01389 }
01390
01391 void XPDFViewer::updateCbk(void *data, GString *fileName,
01392 int pageNum, int numPages, char *linkLabel) {
01393 XPDFViewer *viewer = (XPDFViewer *)data;
01394 GString *title;
01395 char buf[20];
01396 XmString s;
01397
01398 if (fileName) {
01399 if (!(title = viewer->app->getTitle())) {
01400 title = (new GString(xpdfAppName))->append(": ")->append(fileName);
01401 }
01402 XtVaSetValues(viewer->win, XmNtitle, title->getCString(),
01403 XmNiconName, title->getCString(), NULL);
01404 if (!viewer->app->getTitle()) {
01405 delete title;
01406 }
01407 #ifndef DISABLE_OUTLINE
01408 if (!viewer->app->getFullScreen()) {
01409 viewer->setupOutline();
01410 }
01411 #endif
01412 viewer->setupPrintDialog();
01413 }
01414
01415 if (pageNum >= 0) {
01416 s = XmStringCreateLocalized("");
01417 XtVaSetValues(viewer->linkLabel, XmNlabelString, s, NULL);
01418 XmStringFree(s);
01419 sprintf(buf, "%d", pageNum);
01420 XmTextFieldSetString(viewer->pageNumText, buf);
01421 XtVaSetValues(viewer->prevTenPageBtn, XmNsensitive,
01422 pageNum > 1, NULL);
01423 XtVaSetValues(viewer->prevPageBtn, XmNsensitive,
01424 pageNum > 1, NULL);
01425 XtVaSetValues(viewer->nextTenPageBtn, XmNsensitive,
01426 pageNum < viewer->core->getDoc()->getNumPages(), NULL);
01427 XtVaSetValues(viewer->nextPageBtn, XmNsensitive,
01428 pageNum < viewer->core->getDoc()->getNumPages(), NULL);
01429 XtVaSetValues(viewer->backBtn, XmNsensitive,
01430 viewer->core->canGoBack(), NULL);
01431 XtVaSetValues(viewer->forwardBtn, XmNsensitive,
01432 viewer->core->canGoForward(), NULL);
01433 }
01434
01435 if (numPages >= 0) {
01436 sprintf(buf, " of %d", numPages);
01437 s = XmStringCreateLocalized(buf);
01438 XtVaSetValues(viewer->pageCountLabel, XmNlabelString, s, NULL);
01439 XmStringFree(s);
01440 }
01441
01442 if (linkLabel) {
01443 s = XmStringCreateLocalized(linkLabel);
01444 XtVaSetValues(viewer->linkLabel, XmNlabelString, s, NULL);
01445 XmStringFree(s);
01446 }
01447 }
01448
01449
01450
01451
01452
01453
01454 #ifndef DISABLE_OUTLINE
01455
01456 void XPDFViewer::setupOutline() {
01457 GList *items;
01458 UnicodeMap *uMap;
01459 GString *enc;
01460 int i;
01461
01462
01463 if (outlineLabels) {
01464 XtUnmanageChildren(outlineLabels, outlineLabelsLength);
01465 for (i = 0; i < outlineLabelsLength; ++i) {
01466 XtDestroyWidget(outlineLabels[i]);
01467 }
01468 gfree(outlineLabels);
01469 outlineLabels = NULL;
01470 outlineLabelsLength = outlineLabelsSize = 0;
01471 }
01472
01473
01474 items = core->getDoc()->getOutline()->getItems();
01475 if (items && items->getLength() > 0) {
01476 enc = new GString("Latin1");
01477 uMap = globalParams->getUnicodeMap(enc);
01478 delete enc;
01479 setupOutlineItems(items, NULL, uMap);
01480 uMap->decRefCnt();
01481 }
01482
01483
01484 XtManageChildren(outlineLabels, outlineLabelsLength);
01485 }
01486
01487 void XPDFViewer::setupOutlineItems(GList *items, Widget parent,
01488 UnicodeMap *uMap) {
01489 OutlineItem *item;
01490 GList *kids;
01491 Widget label;
01492 Arg args[20];
01493 GString *title;
01494 char buf[8];
01495 XmString s;
01496 int i, j, n;
01497
01498 for (i = 0; i < items->getLength(); ++i) {
01499 item = (OutlineItem *)items->get(i);
01500 title = new GString();
01501 for (j = 0; j < item->getTitleLength(); ++j) {
01502 n = uMap->mapUnicode(item->getTitle()[j], buf, sizeof(buf));
01503 title->append(buf, n);
01504 }
01505 n = 0;
01506 XtSetArg(args[n], XPDFNentryPosition, i); ++n;
01507 if (parent) {
01508 XtSetArg(args[n], XPDFNentryParent, parent); ++n;
01509 }
01510 XtSetArg(args[n], XPDFNentryExpanded, item->isOpen()); ++n;
01511 s = XmStringCreateLocalized(title->getCString());
01512 delete title;
01513 XtSetArg(args[n], XmNlabelString, s); ++n;
01514 XtSetArg(args[n], XmNuserData, item); ++n;
01515 XtSetArg(args[n], XmNmarginWidth, 0); ++n;
01516 XtSetArg(args[n], XmNmarginHeight, 2); ++n;
01517 XtSetArg(args[n], XmNshadowThickness, 0); ++n;
01518 XtSetArg(args[n], XmNforeground,
01519 app->getReverseVideo() ? WhitePixel(display, screenNum)
01520 : BlackPixel(display, screenNum)); ++n;
01521 XtSetArg(args[n], XmNbackground, app->getPaperColor()); ++n;
01522 label = XmCreateLabelGadget(outlineTree, "label", args, n);
01523 XmStringFree(s);
01524 if (outlineLabelsLength == outlineLabelsSize) {
01525 outlineLabelsSize += 64;
01526 outlineLabels = (Widget *)grealloc(outlineLabels,
01527 outlineLabelsSize * sizeof(Widget *));
01528 }
01529 outlineLabels[outlineLabelsLength++] = label;
01530 item->open();
01531 if ((kids = item->getKids())) {
01532 setupOutlineItems(kids, label, uMap);
01533 }
01534 }
01535 }
01536
01537 void XPDFViewer::outlineSelectCbk(Widget widget, XtPointer ptr,
01538 XtPointer callData) {
01539 XPDFViewer *viewer = (XPDFViewer *)ptr;
01540 XPDFTreeSelectCallbackStruct *data =
01541 (XPDFTreeSelectCallbackStruct *)callData;
01542 OutlineItem *item;
01543
01544 XtVaGetValues(data->selectedItem, XmNuserData, &item, NULL);
01545 if (item) {
01546 viewer->core->doAction(item->getAction());
01547 }
01548 viewer->core->takeFocus();
01549 }
01550
01551 #endif // !DISABLE_OUTLINE
01552
01553
01554
01555
01556
01557 void XPDFViewer::initAboutDialog() {
01558 Widget scrolledWin, col, label, sep, closeBtn;
01559 Arg args[20];
01560 int n, i;
01561 XmString s;
01562 char buf[20];
01563
01564
01565 n = 0;
01566 s = XmStringCreateLocalized(xpdfAppName ": About");
01567 XtSetArg(args[n], XmNdialogTitle, s); ++n;
01568 XtSetArg(args[n], XmNwidth, 450); ++n;
01569 XtSetArg(args[n], XmNheight, 300); ++n;
01570 aboutDialog = XmCreateFormDialog(win, "aboutDialog", args, n);
01571 XmStringFree(s);
01572
01573
01574 n = 0;
01575 XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); ++n;
01576 XtSetArg(args[n], XmNrightOffset, 4); ++n;
01577 XtSetArg(args[n], XmNbottomAttachment, XmATTACH_FORM); ++n;
01578 XtSetArg(args[n], XmNbottomOffset, 4); ++n;
01579 closeBtn = XmCreatePushButton(aboutDialog, "Close", args, n);
01580 XtManageChild(closeBtn);
01581 n = 0;
01582 XtSetArg(args[n], XmNdefaultButton, closeBtn); ++n;
01583 XtSetArg(args[n], XmNcancelButton, closeBtn); ++n;
01584 XtSetValues(aboutDialog, args, n);
01585
01586
01587 n = 0;
01588 XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); ++n;
01589 XtSetArg(args[n], XmNbottomAttachment, XmATTACH_WIDGET); ++n;
01590 XtSetArg(args[n], XmNbottomWidget, closeBtn); ++n;
01591 XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); ++n;
01592 XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); ++n;
01593 XtSetArg(args[n], XmNscrollingPolicy, XmAUTOMATIC); ++n;
01594 scrolledWin = XmCreateScrolledWindow(aboutDialog, "scrolledWin", args, n);
01595 XtManageChild(scrolledWin);
01596 n = 0;
01597 XtSetArg(args[n], XmNorientation, XmVERTICAL); ++n;
01598 XtSetArg(args[n], XmNpacking, XmPACK_TIGHT); ++n;
01599 col = XmCreateRowColumn(scrolledWin, "col", args, n);
01600 XtManageChild(col);
01601
01602
01603 aboutBigFont = XmFontListAppendEntry(NULL,
01604 XmFontListEntryCreate(XmFONTLIST_DEFAULT_TAG, XmFONT_IS_FONT,
01605 XLoadQueryFont(display,
01606 "-*-times-bold-i-normal--20-*-*-*-*-*-iso8859-1")));
01607 aboutVersionFont = XmFontListAppendEntry(NULL,
01608 XmFontListEntryCreate(XmFONTLIST_DEFAULT_TAG, XmFONT_IS_FONT,
01609 XLoadQueryFont(display,
01610 "-*-times-medium-r-normal--16-*-*-*-*-*-iso8859-1")));
01611 aboutFixedFont = XmFontListAppendEntry(NULL,
01612 XmFontListEntryCreate(XmFONTLIST_DEFAULT_TAG, XmFONT_IS_FONT,
01613 XLoadQueryFont(display,
01614 "-*-courier-medium-r-normal--12-*-*-*-*-*-iso8859-1")));
01615
01616
01617 n = 0;
01618 s = XmStringCreateLocalized("Xpdf");
01619 XtSetArg(args[n], XmNlabelString, s); ++n;
01620 XtSetArg(args[n], XmNfontList, aboutBigFont); ++n;
01621 label = XmCreateLabel(col, "h0", args, n);
01622 XmStringFree(s);
01623 XtManageChild(label);
01624 n = 0;
01625 s = XmStringCreateLocalized("Version " xpdfVersion);
01626 XtSetArg(args[n], XmNlabelString, s); ++n;
01627 XtSetArg(args[n], XmNfontList, aboutVersionFont); ++n;
01628 label = XmCreateLabel(col, "h1", args, n);
01629 XmStringFree(s);
01630 XtManageChild(label);
01631 n = 0;
01632 s = XmStringCreateLocalized(xpdfCopyright);
01633 XtSetArg(args[n], XmNlabelString, s); ++n;
01634 XtSetArg(args[n], XmNfontList, aboutVersionFont); ++n;
01635 label = XmCreateLabel(col, "h2", args, n);
01636 XmStringFree(s);
01637 XtManageChild(label);
01638 n = 0;
01639 s = XmStringCreateLocalized(" ");
01640 XtSetArg(args[n], XmNlabelString, s); ++n;
01641 XtSetArg(args[n], XmNfontList, aboutVersionFont); ++n;
01642 label = XmCreateLabel(col, "h3", args, n);
01643 XmStringFree(s);
01644 XtManageChild(label);
01645 n = 0;
01646 XtSetArg(args[n], XmNorientation, XmHORIZONTAL); ++n;
01647 sep = XmCreateSeparator(col, "sep", args, n);
01648 XtManageChild(sep);
01649 n = 0;
01650 s = XmStringCreateLocalized(" ");
01651 XtSetArg(args[n], XmNlabelString, s); ++n;
01652 XtSetArg(args[n], XmNfontList, aboutVersionFont); ++n;
01653 label = XmCreateLabel(col, "h4", args, n);
01654 XmStringFree(s);
01655 XtManageChild(label);
01656 n = 0;
01657
01658
01659 for (i = 0; aboutWinText[i]; ++i) {
01660 n = 0;
01661 s = XmStringCreateLocalized(aboutWinText[i]);
01662 XtSetArg(args[n], XmNlabelString, s); ++n;
01663 XtSetArg(args[n], XmNfontList, aboutFixedFont); ++n;
01664 sprintf(buf, "t%d", i);
01665 label = XmCreateLabel(col, buf, args, n);
01666 XtManageChild(label);
01667 XmStringFree(s);
01668 }
01669 }
01670
01671
01672
01673
01674
01675 void XPDFViewer::initOpenDialog() {
01676 Arg args[20];
01677 int n;
01678 XmString s1, s2, s3;
01679
01680 n = 0;
01681 s1 = XmStringCreateLocalized("Open");
01682 XtSetArg(args[n], XmNokLabelString, s1); ++n;
01683 s2 = XmStringCreateLocalized("*.[Pp][Dd][Ff]");
01684 XtSetArg(args[n], XmNpattern, s2); ++n;
01685 s3 = XmStringCreateLocalized(xpdfAppName ": Open");
01686 XtSetArg(args[n], XmNdialogTitle, s3); ++n;
01687 XtSetArg(args[n], XmNdialogStyle, XmDIALOG_PRIMARY_APPLICATION_MODAL); ++n;
01688 XtSetArg(args[n], XmNautoUnmanage, True); ++n;
01689 openDialog = XmCreateFileSelectionDialog(win, "openDialog", args, n);
01690 XmStringFree(s1);
01691 XmStringFree(s2);
01692 XmStringFree(s3);
01693 XtUnmanageChild(XmFileSelectionBoxGetChild(openDialog,
01694 XmDIALOG_HELP_BUTTON));
01695 XtAddCallback(openDialog, XmNokCallback,
01696 &openOkCbk, (XtPointer)this);
01697 }
01698
01699 void XPDFViewer::setOpenDialogDir(char *dir) {
01700 XmString s;
01701
01702 s = XmStringCreateLocalized(dir);
01703 XtVaSetValues(openDialog, XmNdirectory, s, NULL);
01704 XmStringFree(s);
01705 }
01706
01707 void XPDFViewer::mapOpenDialog(GBool openInNewWindowA) {
01708 openInNewWindow = openInNewWindowA;
01709 XmFileSelectionDoSearch(openDialog, NULL);
01710 XtManageChild(openDialog);
01711 }
01712
01713 void XPDFViewer::openOkCbk(Widget widget, XtPointer ptr,
01714 XtPointer callData) {
01715 XPDFViewer *viewer = (XPDFViewer *)ptr;
01716 XmFileSelectionBoxCallbackStruct *data =
01717 (XmFileSelectionBoxCallbackStruct *)callData;
01718 char *fileName;
01719 XmStringContext context;
01720 XmStringCharSet charSet;
01721 XmStringDirection dir;
01722 Boolean sep;
01723 GString *fileNameStr;
01724
01725 XmStringInitContext(&context, data->value);
01726 if (XmStringGetNextSegment(context, &fileName, &charSet, &dir, &sep)) {
01727 fileNameStr = new GString(fileName);
01728 if (viewer->openInNewWindow) {
01729 viewer->app->open(fileNameStr);
01730 } else {
01731 if (viewer->loadFile(fileNameStr)) {
01732 viewer->displayPage(1, viewer->core->getZoom(),
01733 viewer->core->getRotate(), gTrue, gTrue);
01734 }
01735 }
01736 delete fileNameStr;
01737 XtFree(charSet);
01738 XtFree(fileName);
01739 }
01740 XmStringFreeContext(context);
01741 }
01742
01743
01744
01745
01746
01747 void XPDFViewer::initFindDialog() {
01748 Widget row1, label, okBtn, closeBtn;
01749 Arg args[20];
01750 int n;
01751 XmString s;
01752
01753
01754 n = 0;
01755 s = XmStringCreateLocalized(xpdfAppName ": Find");
01756 XtSetArg(args[n], XmNdialogTitle, s); ++n;
01757 XtSetArg(args[n], XmNnavigationType, XmNONE); ++n;
01758 XtSetArg(args[n], XmNautoUnmanage, False); ++n;
01759 findDialog = XmCreateFormDialog(win, "findDialog", args, n);
01760 XmStringFree(s);
01761
01762
01763 n = 0;
01764 XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); ++n;
01765 XtSetArg(args[n], XmNtopOffset, 4); ++n;
01766 XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); ++n;
01767 XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); ++n;
01768 XtSetArg(args[n], XmNorientation, XmHORIZONTAL); ++n;
01769 XtSetArg(args[n], XmNpacking, XmPACK_TIGHT); ++n;
01770 row1 = XmCreateRowColumn(findDialog, "row1", args, n);
01771 XtManageChild(row1);
01772 n = 0;
01773 s = XmStringCreateLocalized("Find text: ");
01774 XtSetArg(args[n], XmNlabelString, s); ++n;
01775 label = XmCreateLabel(row1, "label", args, n);
01776 XmStringFree(s);
01777 XtManageChild(label);
01778 n = 0;
01779 XtSetArg(args[n], XmNnavigationType, XmEXCLUSIVE_TAB_GROUP); ++n;
01780 findText = XmCreateTextField(row1, "text", args, n);
01781 XtManageChild(findText);
01782
01783
01784 n = 0;
01785 XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); ++n;
01786 XtSetArg(args[n], XmNtopWidget, row1); ++n;
01787 XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); ++n;
01788 XtSetArg(args[n], XmNleftOffset, 4); ++n;
01789 XtSetArg(args[n], XmNbottomAttachment, XmATTACH_FORM); ++n;
01790 XtSetArg(args[n], XmNbottomOffset, 4); ++n;
01791 XtSetArg(args[n], XmNnavigationType, XmEXCLUSIVE_TAB_GROUP); ++n;
01792 okBtn = XmCreatePushButton(findDialog, "Find", args, n);
01793 XtManageChild(okBtn);
01794 XtAddCallback(okBtn, XmNactivateCallback,
01795 &findFindCbk, (XtPointer)this);
01796 n = 0;
01797 XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); ++n;
01798 XtSetArg(args[n], XmNtopWidget, row1); ++n;
01799 XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); ++n;
01800 XtSetArg(args[n], XmNrightOffset, 4); ++n;
01801 XtSetArg(args[n], XmNbottomAttachment, XmATTACH_FORM); ++n;
01802 XtSetArg(args[n], XmNbottomOffset, 4); ++n;
01803 XtSetArg(args[n], XmNnavigationType, XmEXCLUSIVE_TAB_GROUP); ++n;
01804 closeBtn = XmCreatePushButton(findDialog, "Close", args, n);
01805 XtManageChild(closeBtn);
01806 XtAddCallback(closeBtn, XmNactivateCallback,
01807 &findCloseCbk, (XtPointer)this);
01808 n = 0;
01809 XtSetArg(args[n], XmNdefaultButton, okBtn); ++n;
01810 XtSetArg(args[n], XmNcancelButton, closeBtn); ++n;
01811 XtSetArg(args[n], XmNinitialFocus, findText); ++n;
01812 XtSetValues(findDialog, args, n);
01813 }
01814
01815 void XPDFViewer::findFindCbk(Widget widget, XtPointer ptr,
01816 XtPointer callData) {
01817 XPDFViewer *viewer = (XPDFViewer *)ptr;
01818
01819 viewer->core->find(XmTextFieldGetString(viewer->findText));
01820 }
01821
01822 void XPDFViewer::findCloseCbk(Widget widget, XtPointer ptr,
01823 XtPointer callData) {
01824 XPDFViewer *viewer = (XPDFViewer *)ptr;
01825
01826 XtUnmanageChild(viewer->findDialog);
01827 }
01828
01829
01830
01831
01832
01833 void XPDFViewer::initSaveAsDialog() {
01834 Arg args[20];
01835 int n;
01836 XmString s1, s2, s3;
01837
01838 n = 0;
01839 s1 = XmStringCreateLocalized("Save");
01840 XtSetArg(args[n], XmNokLabelString, s1); ++n;
01841 s2 = XmStringCreateLocalized("*.[Pp][Dd][Ff]");
01842 XtSetArg(args[n], XmNpattern, s2); ++n;
01843 s3 = XmStringCreateLocalized(xpdfAppName ": Save as");
01844 XtSetArg(args[n], XmNdialogTitle, s3); ++n;
01845 XtSetArg(args[n], XmNdialogStyle, XmDIALOG_PRIMARY_APPLICATION_MODAL); ++n;
01846 XtSetArg(args[n], XmNautoUnmanage, True); ++n;
01847 saveAsDialog = XmCreateFileSelectionDialog(win, "saveAsDialog", args, n);
01848 XmStringFree(s1);
01849 XmStringFree(s2);
01850 XmStringFree(s3);
01851 XtUnmanageChild(XmFileSelectionBoxGetChild(saveAsDialog,
01852 XmDIALOG_HELP_BUTTON));
01853 XtAddCallback(saveAsDialog, XmNokCallback,
01854 &saveAsOkCbk, (XtPointer)this);
01855 }
01856
01857 void XPDFViewer::setSaveAsDialogDir(char *dir) {
01858 XmString s;
01859
01860 s = XmStringCreateLocalized(dir);
01861 XtVaSetValues(saveAsDialog, XmNdirectory, s, NULL);
01862 XmStringFree(s);
01863 }
01864
01865 void XPDFViewer::mapSaveAsDialog() {
01866 XmFileSelectionDoSearch(saveAsDialog, NULL);
01867 XtManageChild(saveAsDialog);
01868 }
01869
01870 void XPDFViewer::saveAsOkCbk(Widget widget, XtPointer ptr,
01871 XtPointer callData) {
01872 XPDFViewer *viewer = (XPDFViewer *)ptr;
01873 XmFileSelectionBoxCallbackStruct *data =
01874 (XmFileSelectionBoxCallbackStruct *)callData;
01875 char *fileName;
01876 GString *fileNameStr;
01877 XmStringContext context;
01878 XmStringCharSet charSet;
01879 XmStringDirection dir;
01880 Boolean sep;
01881
01882 XmStringInitContext(&context, data->value);
01883 if (XmStringGetNextSegment(context, &fileName, &charSet, &dir, &sep)) {
01884 fileNameStr = new GString(fileName);
01885 viewer->core->getDoc()->saveAs(fileNameStr);
01886 delete fileNameStr;
01887 XtFree(charSet);
01888 XtFree(fileName);
01889 }
01890 XmStringFreeContext(context);
01891 }
01892
01893
01894
01895
01896
01897 void XPDFViewer::initPrintDialog() {
01898 Widget sep1, sep2, row, label1, label2, okBtn, cancelBtn;
01899 Arg args[20];
01900 int n;
01901 XmString s;
01902
01903
01904 n = 0;
01905 s = XmStringCreateLocalized(xpdfAppName ": Print");
01906 XtSetArg(args[n], XmNdialogTitle, s); ++n;
01907 XtSetArg(args[n], XmNdialogStyle, XmDIALOG_PRIMARY_APPLICATION_MODAL); ++n;
01908 printDialog = XmCreateFormDialog(win, "printDialog", args, n);
01909 XmStringFree(s);
01910
01911
01912 n = 0;
01913 XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); ++n;
01914 XtSetArg(args[n], XmNtopOffset, 4); ++n;
01915 XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); ++n;
01916 XtSetArg(args[n], XmNindicatorType, XmONE_OF_MANY); ++n;
01917 XtSetArg(args[n], XmNset, XmSET); ++n;
01918 s = XmStringCreateLocalized("Print with command:");
01919 XtSetArg(args[n], XmNlabelString, s); ++n;
01920 printWithCmdBtn = XmCreateToggleButton(printDialog, "printWithCmd", args, n);
01921 XmStringFree(s);
01922 XtManageChild(printWithCmdBtn);
01923 XtAddCallback(printWithCmdBtn, XmNvalueChangedCallback,
01924 &printWithCmdBtnCbk, (XtPointer)this);
01925 n = 0;
01926 XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); ++n;
01927 XtSetArg(args[n], XmNtopWidget, printWithCmdBtn); ++n;
01928 XtSetArg(args[n], XmNtopOffset, 2); ++n;
01929 XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); ++n;
01930 XtSetArg(args[n], XmNleftOffset, 16); ++n;
01931 XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); ++n;
01932 XtSetArg(args[n], XmNrightOffset, 4); ++n;
01933 XtSetArg(args[n], XmNcolumns, 40); ++n;
01934 printCmdText = XmCreateTextField(printDialog, "printCmd", args, n);
01935 XtManageChild(printCmdText);
01936
01937
01938 n = 0;
01939 XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); ++n;
01940 XtSetArg(args[n], XmNtopWidget, printCmdText); ++n;
01941 XtSetArg(args[n], XmNtopOffset, 4); ++n;
01942 XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); ++n;
01943 XtSetArg(args[n], XmNindicatorType, XmONE_OF_MANY); ++n;
01944 XtSetArg(args[n], XmNset, XmUNSET); ++n;
01945 s = XmStringCreateLocalized("Print to file:");
01946 XtSetArg(args[n], XmNlabelString, s); ++n;
01947 printToFileBtn = XmCreateToggleButton(printDialog, "printToFile", args, n);
01948 XmStringFree(s);
01949 XtManageChild(printToFileBtn);
01950 XtAddCallback(printToFileBtn, XmNvalueChangedCallback,
01951 &printToFileBtnCbk, (XtPointer)this);
01952 n = 0;
01953 XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); ++n;
01954 XtSetArg(args[n], XmNtopWidget, printToFileBtn); ++n;
01955 XtSetArg(args[n], XmNtopOffset, 2); ++n;
01956 XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); ++n;
01957 XtSetArg(args[n], XmNleftOffset, 16); ++n;
01958 XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); ++n;
01959 XtSetArg(args[n], XmNrightOffset, 4); ++n;
01960 XtSetArg(args[n], XmNcolumns, 40); ++n;
01961 XtSetArg(args[n], XmNsensitive, False); ++n;
01962 printFileText = XmCreateTextField(printDialog, "printFile", args, n);
01963 XtManageChild(printFileText);
01964
01965
01966 n = 0;
01967 XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); ++n;
01968 XtSetArg(args[n], XmNtopWidget, printFileText); ++n;
01969 XtSetArg(args[n], XmNtopOffset, 8); ++n;
01970 XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); ++n;
01971 XtSetArg(args[n], XmNleftOffset, 8); ++n;
01972 XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); ++n;
01973 XtSetArg(args[n], XmNrightOffset, 8); ++n;
01974 XtSetArg(args[n], XmNorientation, XmHORIZONTAL); ++n;
01975 sep1 = XmCreateSeparator(printDialog, "sep1", args, n);
01976 XtManageChild(sep1);
01977
01978
01979 n = 0;
01980 XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); ++n;
01981 XtSetArg(args[n], XmNtopWidget, sep1); ++n;
01982 XtSetArg(args[n], XmNtopOffset, 8); ++n;
01983 XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); ++n;
01984 XtSetArg(args[n], XmNleftOffset, 4); ++n;
01985 XtSetArg(args[n], XmNorientation, XmHORIZONTAL); ++n;
01986 XtSetArg(args[n], XmNpacking, XmPACK_TIGHT); ++n;
01987 row = XmCreateRowColumn(printDialog, "row", args, n);
01988 XtManageChild(row);
01989 n = 0;
01990 s = XmStringCreateLocalized("Pages:");
01991 XtSetArg(args[n], XmNlabelString, s); ++n;
01992 label1 = XmCreateLabel(row, "label1", args, n);
01993 XmStringFree(s);
01994 XtManageChild(label1);
01995 n = 0;
01996 XtSetArg(args[n], XmNcolumns, 5); ++n;
01997 printFirstPage = XmCreateTextField(row, "printFirstPage", args, n);
01998 XtManageChild(printFirstPage);
01999 n = 0;
02000 s = XmStringCreateLocalized("to");
02001 XtSetArg(args[n], XmNlabelString, s); ++n;
02002 label2 = XmCreateLabel(row, "label2", args, n);
02003 XmStringFree(s);
02004 XtManageChild(label2);
02005 n = 0;
02006 XtSetArg(args[n], XmNcolumns, 5); ++n;
02007 printLastPage = XmCreateTextField(row, "printLastPage", args, n);
02008 XtManageChild(printLastPage);
02009
02010
02011 n = 0;
02012 XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); ++n;
02013 XtSetArg(args[n], XmNtopWidget, row); ++n;
02014 XtSetArg(args[n], XmNtopOffset, 8); ++n;
02015 XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); ++n;
02016 XtSetArg(args[n], XmNleftOffset, 8); ++n;
02017 XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); ++n;
02018 XtSetArg(args[n], XmNrightOffset, 8); ++n;
02019 XtSetArg(args[n], XmNorientation, XmHORIZONTAL); ++n;
02020 sep2 = XmCreateSeparator(printDialog, "sep2", args, n);
02021 XtManageChild(sep2);
02022
02023
02024 n = 0;
02025 XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); ++n;
02026 XtSetArg(args[n], XmNtopWidget, sep2); ++n;
02027 XtSetArg(args[n], XmNtopOffset, 8); ++n;
02028 XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); ++n;
02029 XtSetArg(args[n], XmNleftOffset, 4); ++n;
02030 XtSetArg(args[n], XmNbottomAttachment, XmATTACH_FORM); ++n;
02031 XtSetArg(args[n], XmNbottomOffset, 4); ++n;
02032 okBtn = XmCreatePushButton(printDialog, "Print", args, n);
02033 XtManageChild(okBtn);
02034 XtAddCallback(okBtn, XmNactivateCallback,
02035 &printPrintCbk, (XtPointer)this);
02036 n = 0;
02037 XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); ++n;
02038 XtSetArg(args[n], XmNtopWidget, sep2); ++n;
02039 XtSetArg(args[n], XmNtopOffset, 8); ++n;
02040 XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); ++n;
02041 XtSetArg(args[n], XmNrightOffset, 4); ++n;
02042 XtSetArg(args[n], XmNbottomAttachment, XmATTACH_FORM); ++n;
02043 XtSetArg(args[n], XmNbottomOffset, 4); ++n;
02044 cancelBtn = XmCreatePushButton(printDialog, "Cancel", args, n);
02045 XtManageChild(cancelBtn);
02046 n = 0;
02047 XtSetArg(args[n], XmNdefaultButton, okBtn); ++n;
02048 XtSetArg(args[n], XmNcancelButton, cancelBtn); ++n;
02049 XtSetValues(printDialog, args, n);
02050 }
02051
02052 void XPDFViewer::setupPrintDialog() {
02053 PDFDoc *doc;
02054 char buf[20];
02055 GString *pdfFileName, *psFileName;
02056 char *p;
02057
02058 doc = core->getDoc();
02059
02060 psFileName = globalParams->getPSFile();
02061 if (psFileName && psFileName->getChar(0) != '|') {
02062 XmTextFieldSetString(printFileText, psFileName->getCString());
02063 } else {
02064 pdfFileName = doc->getFileName();
02065 p = pdfFileName->getCString() + pdfFileName->getLength() - 4;
02066 if (!strcmp(p, ".pdf") || !strcmp(p, ".PDF")) {
02067 psFileName = new GString(pdfFileName->getCString(),
02068 pdfFileName->getLength() - 4);
02069 } else {
02070 psFileName = pdfFileName->copy();
02071 }
02072 psFileName->append(".ps");
02073 XmTextFieldSetString(printFileText, psFileName->getCString());
02074 delete psFileName;
02075 }
02076
02077 psFileName = globalParams->getPSFile();
02078 if (psFileName && psFileName->getChar(0) == '|') {
02079 XmTextFieldSetString(printCmdText,
02080 psFileName->getCString() + 1);
02081 }
02082
02083 sprintf(buf, "%d", doc->getNumPages());
02084 XmTextFieldSetString(printFirstPage, "1");
02085 XmTextFieldSetString(printLastPage, buf);
02086 }
02087
02088 void XPDFViewer::printWithCmdBtnCbk(Widget widget, XtPointer ptr,
02089 XtPointer callData) {
02090 XPDFViewer *viewer = (XPDFViewer *)ptr;
02091 XmToggleButtonCallbackStruct *data =
02092 (XmToggleButtonCallbackStruct *)callData;
02093
02094 if (data->set != XmSET) {
02095 XmToggleButtonSetState(viewer->printWithCmdBtn, True, False);
02096 }
02097 XmToggleButtonSetState(viewer->printToFileBtn, False, False);
02098 XtVaSetValues(viewer->printCmdText, XmNsensitive, True, NULL);
02099 XtVaSetValues(viewer->printFileText, XmNsensitive, False, NULL);
02100 }
02101
02102 void XPDFViewer::printToFileBtnCbk(Widget widget, XtPointer ptr,
02103 XtPointer callData) {
02104 XPDFViewer *viewer = (XPDFViewer *)ptr;
02105 XmToggleButtonCallbackStruct *data =
02106 (XmToggleButtonCallbackStruct *)callData;
02107
02108 if (data->set != XmSET) {
02109 XmToggleButtonSetState(viewer->printToFileBtn, True, False);
02110 }
02111 XmToggleButtonSetState(viewer->printWithCmdBtn, False, False);
02112 XtVaSetValues(viewer->printFileText, XmNsensitive, True, NULL);
02113 XtVaSetValues(viewer->printCmdText, XmNsensitive, False, NULL);
02114 }
02115
02116 void XPDFViewer::printPrintCbk(Widget widget, XtPointer ptr,
02117 XtPointer callData) {
02118 XPDFViewer *viewer = (XPDFViewer *)ptr;
02119 unsigned char withCmd;
02120 GString *psFileName;
02121 int firstPage, lastPage;
02122 PDFDoc *doc;
02123 PSOutputDev *psOut;
02124
02125 doc = viewer->core->getDoc();
02126 if (!doc->okToPrint()) {
02127 error(-1, "Printing this document is not allowed.");
02128 return;
02129 }
02130
02131 viewer->core->setBusyCursor(gTrue);
02132
02133 XtVaGetValues(viewer->printWithCmdBtn, XmNset, &withCmd, NULL);
02134 if (withCmd) {
02135 psFileName = new GString(XmTextFieldGetString(viewer->printCmdText));
02136 psFileName->insert(0, '|');
02137 } else {
02138 psFileName = new GString(XmTextFieldGetString(viewer->printFileText));
02139 }
02140
02141 firstPage = atoi(XmTextFieldGetString(viewer->printFirstPage));
02142 lastPage = atoi(XmTextFieldGetString(viewer->printLastPage));
02143 if (firstPage < 1) {
02144 firstPage = 1;
02145 } else if (firstPage > doc->getNumPages()) {
02146 firstPage = doc->getNumPages();
02147 }
02148 if (lastPage < firstPage) {
02149 lastPage = firstPage;
02150 } else if (lastPage > doc->getNumPages()) {
02151 lastPage = doc->getNumPages();
02152 }
02153
02154 psOut = new PSOutputDev(psFileName->getCString(), doc->getXRef(),
02155 doc->getCatalog(), firstPage, lastPage,
02156 psModePS);
02157 if (psOut->isOk()) {
02158 doc->displayPages(psOut, firstPage, lastPage, 72, 0, gFalse);
02159 }
02160 delete psOut;
02161 delete psFileName;
02162
02163 viewer->core->setBusyCursor(gFalse);
02164 }
02165
02166
02167
02168
02169
02170 void XPDFViewer::initPasswordDialog() {
02171 Widget row, label, okBtn, cancelBtn;
02172 Arg args[20];
02173 int n;
02174 XmString s;
02175
02176
02177 n = 0;
02178 s = XmStringCreateLocalized(xpdfAppName ": Password");
02179 XtSetArg(args[n], XmNdialogTitle, s); ++n;
02180 XtSetArg(args[n], XmNdialogStyle, XmDIALOG_PRIMARY_APPLICATION_MODAL); ++n;
02181 passwordDialog = XmCreateFormDialog(win, "passwordDialog", args, n);
02182 XmStringFree(s);
02183
02184
02185 n = 0;
02186 XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); ++n;
02187 XtSetArg(args[n], XmNtopOffset, 4); ++n;
02188 XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); ++n;
02189 XtSetArg(args[n], XmNleftOffset, 4); ++n;
02190 s = XmStringCreateLocalized(" ");
02191 XtSetArg(args[n], XmNlabelString, s); ++n;
02192 passwordMsg = XmCreateLabel(passwordDialog, "msg", args, n);
02193 XmStringFree(s);
02194 XtManageChild(passwordMsg);
02195
02196
02197 n = 0;
02198 XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); ++n;
02199 XtSetArg(args[n], XmNtopWidget, passwordMsg); ++n;
02200 XtSetArg(args[n], XmNtopOffset, 4); ++n;
02201 XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); ++n;
02202 XtSetArg(args[n], XmNleftOffset, 4); ++n;
02203 XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); ++n;
02204 XtSetArg(args[n], XmNleftOffset, 4); ++n;
02205 XtSetArg(args[n], XmNorientation, XmHORIZONTAL); ++n;
02206 XtSetArg(args[n], XmNpacking, XmPACK_TIGHT); ++n;
02207 row = XmCreateRowColumn(passwordDialog, "row", args, n);
02208 XtManageChild(row);
02209 n = 0;
02210 s = XmStringCreateLocalized("Password: ");
02211 XtSetArg(args[n], XmNlabelString, s); ++n;
02212 label = XmCreateLabel(row, "label", args, n);
02213 XmStringFree(s);
02214 XtManageChild(label);
02215 n = 0;
02216 XtSetArg(args[n], XmNcolumns, 16); ++n;
02217 passwordText = XmCreateTextField(row, "text", args, n);
02218 XtManageChild(passwordText);
02219 XtAddCallback(passwordText, XmNmodifyVerifyCallback,
02220 &passwordTextVerifyCbk, this);
02221
02222
02223 n = 0;
02224 XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); ++n;
02225 XtSetArg(args[n], XmNtopWidget, row); ++n;
02226 XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); ++n;
02227 XtSetArg(args[n], XmNleftOffset, 4); ++n;
02228 XtSetArg(args[n], XmNbottomAttachment, XmATTACH_FORM); ++n;
02229 XtSetArg(args[n], XmNbottomOffset, 4); ++n;
02230 XtSetArg(args[n], XmNnavigationType, XmEXCLUSIVE_TAB_GROUP); ++n;
02231 okBtn = XmCreatePushButton(passwordDialog, "Ok", args, n);
02232 XtManageChild(okBtn);
02233 XtAddCallback(okBtn, XmNactivateCallback,
02234 &passwordOkCbk, (XtPointer)this);
02235 n = 0;
02236 XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); ++n;
02237 XtSetArg(args[n], XmNtopWidget, row); ++n;
02238 XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); ++n;
02239 XtSetArg(args[n], XmNrightOffset, 4); ++n;
02240 XtSetArg(args[n], XmNbottomAttachment, XmATTACH_FORM); ++n;
02241 XtSetArg(args[n], XmNbottomOffset, 4); ++n;
02242 XtSetArg(args[n], XmNnavigationType, XmEXCLUSIVE_TAB_GROUP); ++n;
02243 cancelBtn = XmCreatePushButton(passwordDialog, "Cancel", args, n);
02244 XtManageChild(cancelBtn);
02245 XtAddCallback(cancelBtn, XmNactivateCallback,
02246 &passwordCancelCbk, (XtPointer)this);
02247 n = 0;
02248 XtSetArg(args[n], XmNdefaultButton, okBtn); ++n;
02249 XtSetArg(args[n], XmNcancelButton, cancelBtn); ++n;
02250 XtSetArg(args[n], XmNinitialFocus, passwordText); ++n;
02251 XtSetValues(passwordDialog, args, n);
02252 }
02253
02254 void XPDFViewer::passwordTextVerifyCbk(Widget widget, XtPointer ptr,
02255 XtPointer callData) {
02256 XPDFViewer *viewer = (XPDFViewer *)ptr;
02257 XmTextVerifyCallbackStruct *data =
02258 (XmTextVerifyCallbackStruct *)callData;
02259 int i, n;
02260
02261 i = (int)data->startPos;
02262 n = (int)data->endPos - i;
02263 if (i > viewer->password->getLength()) {
02264 i = viewer->password->getLength();
02265 }
02266 if (i + n > viewer->password->getLength()) {
02267 n = viewer->password->getLength() - i;
02268 }
02269 viewer->password->del(i, n);
02270 viewer->password->insert(i, data->text->ptr, data->text->length);
02271
02272 for (i = 0; i < data->text->length; ++i) {
02273 data->text->ptr[i] = '*';
02274 }
02275 data->doit = True;
02276 }
02277
02278 void XPDFViewer::passwordOkCbk(Widget widget, XtPointer ptr,
02279 XtPointer callData) {
02280 XPDFViewer *viewer = (XPDFViewer *)ptr;
02281
02282 viewer->passwordDone = 1;
02283 }
02284
02285 void XPDFViewer::passwordCancelCbk(Widget widget, XtPointer ptr,
02286 XtPointer callData) {
02287 XPDFViewer *viewer = (XPDFViewer *)ptr;
02288
02289 viewer->passwordDone = -1;
02290 }
02291
02292 void XPDFViewer::getPassword(GBool again) {
02293 XmString s;
02294 XEvent event;
02295
02296 if (password) {
02297 delete password;
02298 }
02299 password = new GString();
02300
02301 XmTextFieldSetString(passwordText, "");
02302 s = XmStringCreateLocalized(
02303 again ? (char *)"Incorrect password. Please try again."
02304 : (char *)"This document requires a password.");
02305 XtVaSetValues(passwordMsg, XmNlabelString, s, NULL);
02306 XmStringFree(s);
02307 XtManageChild(passwordDialog);
02308 passwordDone = 0;
02309 do {
02310 XtAppNextEvent(app->getAppContext(), &event);
02311 XtDispatchEvent(&event);
02312 } while (!passwordDone);
02313
02314 if (passwordDone < 0) {
02315 delete password;
02316 password = NULL;
02317 }
02318 }