?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Bringing apdf from vendor into main branch.
[AROS-Contrib.git] / apdf / xpdf / XPDFViewer.cc
blob0c66dc6cdc74efaecaea983d63c1089ff9ed530f
1 //========================================================================
2 //
3 // XPDFViewer.cc
4 //
5 // Copyright 2002-2003 Glyph & Cog, LLC
6 //
7 //========================================================================
8
9 #include <aconf.h>
10
11 #ifdef USE_GCC_PRAGMAS
12 #pragma implementation
13 #endif
14
15 #include <stdlib.h>
16 #include <string.h>
17 #include <ctype.h>
18 #include <X11/cursorfont.h>
19 #ifdef HAVE_X11_XPM_H
20 #include <X11/xpm.h>
21 #endif
22 #if defined(__sgi) && (XmVERSION <= 1)
23 #define Object XtObject
24 #include <Sgm/HPanedW.h>
25 #undef Object
26 #endif
27 #include "gmem.h"
28 #include "gfile.h"
29 #include "GString.h"
30 #include "GList.h"
31 #include "Error.h"
32 #include "GlobalParams.h"
33 #include "PDFDoc.h"
34 #include "Link.h"
35 #include "ErrorCodes.h"
36 #include "Outline.h"
37 #include "UnicodeMap.h"
38 #ifndef DISABLE_OUTLINE
39 #define Object XtObject
40 #include "XPDFTree.h"
41 #undef Object
42 #endif
43 #include "XPDFApp.h"
44 #include "XPDFViewer.h"
45 #include "PSOutputDev.h"
46 #include "config.h"
47
48 // these macro defns conflict with xpdf's Object class
49 #ifdef LESSTIF_VERSION
50 #undef XtDisplay
51 #undef XtScreen
52 #undef XtWindow
53 #undef XtParent
54 #undef XtIsRealized
55 #endif
56
57 #if XmVERSION <= 1
58 #define XmSET True
59 #define XmUNSET False
60 #endif
61
62 //------------------------------------------------------------------------
63 // GUI includes
64 //------------------------------------------------------------------------
65
66 #include "xpdfIcon.xpm"
67 #include "leftArrow.xbm"
68 #include "leftArrowDis.xbm"
69 #include "dblLeftArrow.xbm"
70 #include "dblLeftArrowDis.xbm"
71 #include "rightArrow.xbm"
72 #include "rightArrowDis.xbm"
73 #include "dblRightArrow.xbm"
74 #include "dblRightArrowDis.xbm"
75 #include "backArrow.xbm"
76 #include "backArrowDis.xbm"
77 #include "forwardArrow.xbm"
78 #include "forwardArrowDis.xbm"
79 #include "find.xbm"
80 #include "findDis.xbm"
81 #include "print.xbm"
82 #include "printDis.xbm"
83 #include "about.xbm"
84 #include "about-text.h"
85
86 //------------------------------------------------------------------------
87
88 struct ZoomMenuInfo {
89 char *label;
90 double zoom;
91 };
92
93 static ZoomMenuInfo zoomMenuInfo[nZoomMenuItems] = {
94 { "400%", 400 },
95 { "200%", 200 },
96 { "150%", 150 },
97 { "125%", 125 },
98 { "100%", 100 },
99 { "50%", 50 },
100 { "25%", 25 },
101 { "12.5%", 12.5 },
102 { "fit page", zoomPage },
103 { "fit width", zoomWidth }
104 };
105
106 #define maxZoomIdx 0
107 #define defZoomIdx 3
108 #define minZoomIdx 7
109 #define zoomPageIdx 8
110 #define zoomWidthIdx 9
111
112 //------------------------------------------------------------------------
113
114 XPDFViewer::XPDFViewer(XPDFApp *appA, GString *fileName,
115 int pageA, GString *destName,
116 GString *ownerPassword, GString *userPassword) {
117 LinkDest *dest;
118 int pg;
119 double z;
120
121 app = appA;
122 win = NULL;
123 core = NULL;
124 ok = gFalse;
125 #ifndef DISABLE_OUTLINE
126 outlineLabels = NULL;
127 outlineLabelsLength = outlineLabelsSize = 0;
128 #endif
129
130 // do Motif-specific initialization and create the window;
131 // this also creates the core object
132 initWindow();
133 initAboutDialog();
134 initFindDialog();
135 initPrintDialog();
136 openDialog = NULL;
137 saveAsDialog = NULL;
138
139 dest = NULL; // make gcc happy
140 pg = pageA; // make gcc happy
141
142 if (fileName) {
143 if (loadFile(fileName, ownerPassword, userPassword)) {
144 getPageAndDest(pageA, destName, &pg, &dest);
145 #ifndef DISABLE_OUTLINE
146 if (!app->getFullScreen() &&
147 core->getDoc()->getOutline()->getItems() &&
148 core->getDoc()->getOutline()->getItems()->getLength() > 0) {
149 XtVaSetValues(outlineScroll, XmNwidth, 175, NULL);
150 }
151 #endif
152 if (pg > 0) {
153 core->resizeToPage(pg);
154 }
155 } else {
156 return;
157 }
158 }
159
160 // map the window -- we do this after calling resizeToPage to avoid
161 // an annoying on-screen resize
162 mapWindow();
163
164 // display the first page
165 z = app->getFullScreen() ? zoomPage : core->getZoom();
166 if (dest) {
167 displayDest(dest, z, core->getRotate(), gTrue);
168 delete dest;
169 } else {
170 displayPage(pg, z, core->getRotate(), gTrue, gTrue);
171 }
172
173 ok = gTrue;
174 }
175
176 XPDFViewer::~XPDFViewer() {
177 delete core;
178 XmFontListFree(aboutBigFont);
179 XmFontListFree(aboutVersionFont);
180 XmFontListFree(aboutFixedFont);
181 closeWindow();
182 #ifndef DISABLE_OUTLINE
183 if (outlineLabels) {
184 gfree(outlineLabels);
185 }
186 #endif
187 }
188
189 void XPDFViewer::open(GString *fileName, int pageA, GString *destName) {
190 LinkDest *dest;
191 int pg;
192 double z;
193
194 if (!core->getDoc() || fileName->cmp(core->getDoc()->getFileName())) {
195 if (!loadFile(fileName, NULL, NULL)) {
196 return;
197 }
198 }
199 getPageAndDest(pageA, destName, &pg, &dest);
200 z = app->getFullScreen() ? zoomPage : core->getZoom();
201 if (dest) {
202 displayDest(dest, z, core->getRotate(), gTrue);
203 delete dest;
204 } else {
205 displayPage(pg, z, core->getRotate(), gTrue, gTrue);
206 }
207 }
208
209 void XPDFViewer::clear() {
210 char *title;
211 XmString s;
212
213 core->clear();
214
215 // set up title, number-of-pages display
216 title = app->getTitle() ? app->getTitle()->getCString()
217 : (char *)xpdfAppName;
218 XtVaSetValues(win, XmNtitle, title, XmNiconName, title, NULL);
219 s = XmStringCreateLocalized("");
220 XtVaSetValues(pageNumText, XmNlabelString, s, NULL);
221 XmStringFree(s);
222 s = XmStringCreateLocalized(" of 0");
223 XtVaSetValues(pageCountLabel, XmNlabelString, s, NULL);
224 XmStringFree(s);
225
226 // disable buttons
227 XtVaSetValues(prevTenPageBtn, XmNsensitive, False, NULL);
228 XtVaSetValues(prevPageBtn, XmNsensitive, False, NULL);
229 XtVaSetValues(nextTenPageBtn, XmNsensitive, False, NULL);
230 XtVaSetValues(nextPageBtn, XmNsensitive, False, NULL);
231
232 // remove the old outline
233 #ifndef DISABLE_OUTLINE
234 setupOutline();
235 #endif
236 }
237
238 //------------------------------------------------------------------------
239 // load / display
240 //------------------------------------------------------------------------
241
242 GBool XPDFViewer::loadFile(GString *fileName, GString *ownerPassword,
243 GString *userPassword) {
244 return core->loadFile(fileName, ownerPassword, userPassword) == errNone;
245 }
246
247 void XPDFViewer::reloadFile() {
248 int pg;
249
250 if (!core->getDoc()) {
251 return;
252 }
253 pg = core->getPageNum();
254 loadFile(core->getDoc()->getFileName());
255 if (pg > core->getDoc()->getNumPages()) {
256 pg = core->getDoc()->getNumPages();
257 }
258 displayPage(pg, core->getZoom(), core->getRotate(), gFalse, gFalse);
259 }
260
261 void XPDFViewer::displayPage(int pageA, double zoomA, int rotateA,
262 GBool scrollToTop, GBool addToHist) {
263 core->displayPage(pageA, zoomA, rotateA, scrollToTop, addToHist);
264 }
265
266 void XPDFViewer::displayDest(LinkDest *dest, double zoomA, int rotateA,
267 GBool addToHist) {
268 core->displayDest(dest, zoomA, rotateA, addToHist);
269 }
270
271 void XPDFViewer::getPageAndDest(int pageA, GString *destName,
272 int *pageOut, LinkDest **destOut) {
273 Ref pageRef;
274
275 // find the page number for a named destination
276 *pageOut = pageA;
277 *destOut = NULL;
278 if (destName && (*destOut = core->getDoc()->findDest(destName))) {
279 if ((*destOut)->isPageRef()) {
280 pageRef = (*destOut)->getPageRef();
281 *pageOut = core->getDoc()->findPage(pageRef.num, pageRef.gen);
282 } else {
283 *pageOut = (*destOut)->getPageNum();
284 }
285 }
286
287 if (*pageOut <= 0) {
288 *pageOut = 1;
289 }
290 if (*pageOut > core->getDoc()->getNumPages()) {
291 *pageOut = core->getDoc()->getNumPages();
292 }
293 }
294
295 //------------------------------------------------------------------------
296 // actions
297 //------------------------------------------------------------------------
298
299 void XPDFViewer::actionCbk(void *data, char *action) {
300 XPDFViewer *viewer = (XPDFViewer *)data;
301
302 if (!strcmp(action, "Quit")) {
303 viewer->app->quit();
304 }
305 }
306
307 //------------------------------------------------------------------------
308 // keyboard/mouse input
309 //------------------------------------------------------------------------
310
311 void XPDFViewer::keyPressCbk(void *data, char *s, KeySym key,
312 Guint modifiers) {
313 XPDFViewer *viewer = (XPDFViewer *)data;
314 int z;
315
316 if (s[0]) {
317 switch (s[0]) {
318 case 'O':
319 case 'o':
320 viewer->mapOpenDialog(gFalse);
321 break;
322 case 'R':
323 case 'r':
324 viewer->reloadFile();
325 break;
326 case 'F':
327 case 'f':
328 case '\006': // ctrl-F
329 if (viewer->core->getDoc()) {
330 viewer->mapFindDialog();
331 }
332 break;
333 case '\007': // ctrl-G
334 if (viewer->core->getDoc()) {
335 viewer->doFind(gTrue);
336 }
337 break;
338 case '\020': // ctrl-P
339 if (viewer->core->getDoc()) {
340 XtManageChild(viewer->printDialog);
341 }
342 break;
343 case 'N':
344 case 'n':
345 viewer->core->gotoNextPage(1, !(modifiers & Mod5Mask));
346 break;
347 case 'P':
348 case 'p':
349 viewer->core->gotoPrevPage(1, !(modifiers & Mod5Mask), gFalse);
350 break;
351 case ' ':
352 if (viewer->app->getFullScreen()) {
353 viewer->core->gotoNextPage(1, gTrue);
354 } else {
355 viewer->core->scrollPageDown();
356 }
357 break;
358 case '\b': // bs
359 case '\177': // del
360 if (viewer->app->getFullScreen()) {
361 viewer->core->gotoPrevPage(1, gTrue, gFalse);
362 } else {
363 viewer->core->scrollPageUp();
364 }
365 break;
366 case 'v':
367 viewer->core->goForward();
368 break;
369 case 'b':
370 viewer->core->goBackward();
371 break;
372 case 'g':
373 if (!viewer->app->getFullScreen()) {
374 XmTextFieldSetSelection(
375 viewer->pageNumText, 0,
376 strlen(XmTextFieldGetString(viewer->pageNumText)),
377 XtLastTimestampProcessed(viewer->display));
378 XmProcessTraversal(viewer->pageNumText, XmTRAVERSE_CURRENT);
379 }
380 break;
381 case 'h': // vi-style left
382 if (!viewer->app->getFullScreen() && viewer->app->getViKeys()) {
383 viewer->core->scrollLeft();
384 }
385 break;
386 case 'l': // vi-style right
387 if (!viewer->app->getFullScreen() && viewer->app->getViKeys()) {
388 viewer->core->scrollRight();
389 }
390 break;
391 case 'k': // vi-style up
392 if (!viewer->app->getFullScreen() && viewer->app->getViKeys()) {
393 viewer->core->scrollUp();
394 }
395 break;
396 case 'j': // vi-style down
397 if (!viewer->app->getFullScreen() && viewer->app->getViKeys()) {
398 viewer->core->scrollDown();
399 }
400 break;
401 case '0':
402 if (!viewer->app->getFullScreen() &&
403 viewer->core->getZoom() != defZoom) {
404 viewer->setZoomIdx(defZoomIdx);
405 viewer->displayPage(viewer->core->getPageNum(), defZoom,
406 viewer->core->getRotate(), gTrue, gFalse);
407 }
408 break;
409 case '+':
410 if (!viewer->app->getFullScreen()) {
411 z = viewer->getZoomIdx();
412 if (z <= minZoomIdx && z > maxZoomIdx) {
413 --z;
414 viewer->setZoomIdx(z);
415 viewer->displayPage(viewer->core->getPageNum(),
416 zoomMenuInfo[z].zoom,
417 viewer->core->getRotate(), gTrue, gFalse);
418 }
419 }
420 break;
421 case '-':
422 if (!viewer->app->getFullScreen()) {
423 z = viewer->getZoomIdx();
424 if (z < minZoomIdx && z >= maxZoomIdx) {
425 ++z;
426 viewer->setZoomIdx(z);
427 viewer->displayPage(viewer->core->getPageNum(),
428 zoomMenuInfo[z].zoom,
429 viewer->core->getRotate(), gTrue, gFalse);
430 }
431 }
432 break;
433 case 'z':
434 if (!viewer->app->getFullScreen() &&
435 viewer->core->getZoom() != zoomPage) {
436 viewer->setZoomIdx(zoomPageIdx);
437 viewer->displayPage(viewer->core->getPageNum(), zoomPage,
438 viewer->core->getRotate(), gTrue, gFalse);
439 }
440 break;
441 case 'w':
442 if (!viewer->app->getFullScreen() &&
443 viewer->core->getZoom() != zoomWidth) {
444 viewer->setZoomIdx(zoomWidthIdx);
445 viewer->displayPage(viewer->core->getPageNum(), zoomWidth,
446 viewer->core->getRotate(), gTrue, gFalse);
447 }
448 break;
449 case '\014': // ^L
450 viewer->displayPage(viewer->core->getPageNum(), viewer->core->getZoom(),
451 viewer->core->getRotate(), gFalse, gFalse);
452 break;
453 case '\027': // ^W
454 viewer->app->close(viewer, gFalse);
455 break;
456 case '?':
457 XtManageChild(viewer->aboutDialog);
458 break;
459 case 'Q':
460 case 'q':
461 viewer->app->quit();
462 break;
463 }
464 }
465 }
466
467 void XPDFViewer::mouseCbk(void *data, XEvent *event) {
468 XPDFViewer *viewer = (XPDFViewer *)data;
469
470 if (event->type == ButtonPress && event->xbutton.button == 3) {
471 XmMenuPosition(viewer->popupMenu, &event->xbutton);
472 XtManageChild(viewer->popupMenu);
473
474 // this is magic (taken from DDD) - weird things happen if this
475 // call isn't made (this is done in two different places, in hopes
476 // of squashing this stupid bug)
477 XtUngrabButton(viewer->core->getDrawAreaWidget(), AnyButton, AnyModifier);
478 }
479 }
480
481 //------------------------------------------------------------------------
482 // GUI code: main window
483 //------------------------------------------------------------------------
484
485 void XPDFViewer::initWindow() {
486 Widget btn, label, lastBtn, zoomWidget;
487 #ifndef DISABLE_OUTLINE
488 Widget clipWin;
489 #endif
490 Colormap colormap;
491 XColor xcol;
492 Arg args[20];
493 int n;
494 char *title;
495 XmString s, s2, emptyString;
496 int i;
497
498 display = XtDisplay(app->getAppShell());
499 screenNum = XScreenNumberOfScreen(XtScreen(app->getAppShell()));
500
501 // private colormap
502 if (app->getInstallCmap()) {
503 XtVaGetValues(app->getAppShell(), XmNcolormap, &colormap, NULL);
504 // ensure that BlackPixel and WhitePixel are reserved in the
505 // new colormap
506 xcol.red = xcol.green = xcol.blue = 0;
507 XAllocColor(display, colormap, &xcol);
508 xcol.red = xcol.green = xcol.blue = 65535;
509 XAllocColor(display, colormap, &xcol);
510 colormap = XCopyColormapAndFree(display, colormap);
511 }
512
513 // top-level window
514 n = 0;
515 title = app->getTitle() ? app->getTitle()->getCString()
516 : (char *)xpdfAppName;
517 XtSetArg(args[n], XmNtitle, title); ++n;
518 XtSetArg(args[n], XmNiconName, title); ++n;
519 XtSetArg(args[n], XmNminWidth, 100); ++n;
520 XtSetArg(args[n], XmNminHeight, 100); ++n;
521 XtSetArg(args[n], XmNbaseWidth, 0); ++n;
522 XtSetArg(args[n], XmNbaseHeight, 0); ++n;
523 XtSetArg(args[n], XmNdeleteResponse, XmDO_NOTHING); ++n;
524 if (app->getFullScreen()) {
525 XtSetArg(args[n], XmNmwmDecorations, 0); ++n;
526 XtSetArg(args[n], XmNgeometry, "+0+0"); ++n;
527 } else if (app->getGeometry()) {
528 XtSetArg(args[n], XmNgeometry, app->getGeometry()->getCString()); ++n;
529 }
530 win = XtCreatePopupShell("win", topLevelShellWidgetClass,
531 app->getAppShell(), args, n);
532 if (app->getInstallCmap()) {
533 XtVaSetValues(win, XmNcolormap, colormap, NULL);
534 }
535 XmAddWMProtocolCallback(win, XInternAtom(display, "WM_DELETE_WINDOW", False),
536 &closeMsgCbk, this);
537
538 // form
539 n = 0;
540 form = XmCreateForm(win, "form", args, n);
541 XtManageChild(form);
542
543 // toolbar
544 n = 0;
545 XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); ++n;
546 XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); ++n;
547 XtSetArg(args[n], XmNbottomAttachment, XmATTACH_FORM); ++n;
548 toolBar = XmCreateForm(form, "toolBar", args, n);
549 XtManageChild(toolBar);
550
551 // create an empty string -- this is used for buttons that will get
552 // pixmaps later
553 emptyString = XmStringCreateLocalized("");
554
555 // page movement buttons
556 n = 0;
557 XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); ++n;
558 XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); ++n;
559 XtSetArg(args[n], XmNbottomAttachment, XmATTACH_FORM); ++n;
560 XtSetArg(args[n], XmNmarginWidth, 6); ++n;
561 XtSetArg(args[n], XmNsensitive, False); ++n;
562 XtSetArg(args[n], XmNlabelString, emptyString); ++n;
563 backBtn = XmCreatePushButton(toolBar, "back", args, n);
564 addToolTip(backBtn, "Back");
565 XtManageChild(backBtn);
566 XtAddCallback(backBtn, XmNactivateCallback,
567 &backCbk, (XtPointer)this);
568 n = 0;
569 XtSetArg(args[n], XmNleftAttachment, XmATTACH_WIDGET); ++n;
570 XtSetArg(args[n], XmNleftWidget, backBtn); ++n;
571 XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); ++n;
572 XtSetArg(args[n], XmNbottomAttachment, XmATTACH_FORM); ++n;
573 XtSetArg(args[n], XmNmarginWidth, 6); ++n;
574 XtSetArg(args[n], XmNsensitive, False); ++n;
575 XtSetArg(args[n], XmNlabelString, emptyString); ++n;
576 prevTenPageBtn = XmCreatePushButton(toolBar, "prevTenPage", args, n);
577 addToolTip(prevTenPageBtn, "-10 pages");
578 XtManageChild(prevTenPageBtn);
579 XtAddCallback(prevTenPageBtn, XmNactivateCallback,
580 &prevTenPageCbk, (XtPointer)this);
581 n = 0;
582 XtSetArg(args[n], XmNleftAttachment, XmATTACH_WIDGET); ++n;
583 XtSetArg(args[n], XmNleftWidget, prevTenPageBtn); ++n;
584 XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); ++n;
585 XtSetArg(args[n], XmNbottomAttachment, XmATTACH_FORM); ++n;
586 XtSetArg(args[n], XmNmarginWidth, 6); ++n;
587 XtSetArg(args[n], XmNsensitive, False); ++n;
588 XtSetArg(args[n], XmNlabelString, emptyString); ++n;
589 prevPageBtn = XmCreatePushButton(toolBar, "prevPage", args, n);
590 addToolTip(prevPageBtn, "Previous page");
591 XtManageChild(prevPageBtn);
592 XtAddCallback(prevPageBtn, XmNactivateCallback,
593 &prevPageCbk, (XtPointer)this);
594 n = 0;
595 XtSetArg(args[n], XmNleftAttachment, XmATTACH_WIDGET); ++n;
596 XtSetArg(args[n], XmNleftWidget, prevPageBtn); ++n;
597 XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); ++n;
598 XtSetArg(args[n], XmNbottomAttachment, XmATTACH_FORM); ++n;
599 XtSetArg(args[n], XmNmarginWidth, 6); ++n;
600 XtSetArg(args[n], XmNsensitive, False); ++n;
601 XtSetArg(args[n], XmNlabelString, emptyString); ++n;
602 nextPageBtn = XmCreatePushButton(toolBar, "nextPage", args, n);
603 addToolTip(nextPageBtn, "Next page");
604 XtManageChild(nextPageBtn);
605 XtAddCallback(nextPageBtn, XmNactivateCallback,
606 &nextPageCbk, (XtPointer)this);
607 n = 0;
608 XtSetArg(args[n], XmNleftAttachment, XmATTACH_WIDGET); ++n;
609 XtSetArg(args[n], XmNleftWidget, nextPageBtn); ++n;
610 XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); ++n;
611 XtSetArg(args[n], XmNbottomAttachment, XmATTACH_FORM); ++n;
612 XtSetArg(args[n], XmNmarginWidth, 6); ++n;
613 XtSetArg(args[n], XmNsensitive, False); ++n;
614 XtSetArg(args[n], XmNlabelString, emptyString); ++n;
615 nextTenPageBtn = XmCreatePushButton(toolBar, "nextTenPage", args, n);
616 addToolTip(nextTenPageBtn, "+10 pages");
617 XtManageChild(nextTenPageBtn);
618 XtAddCallback(nextTenPageBtn, XmNactivateCallback,
619 &nextTenPageCbk, (XtPointer)this);
620 n = 0;
621 XtSetArg(args[n], XmNleftAttachment, XmATTACH_WIDGET); ++n;
622 XtSetArg(args[n], XmNleftWidget, nextTenPageBtn); ++n;
623 XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); ++n;
624 XtSetArg(args[n], XmNbottomAttachment, XmATTACH_FORM); ++n;
625 XtSetArg(args[n], XmNmarginWidth, 6); ++n;
626 XtSetArg(args[n], XmNsensitive, False); ++n;
627 XtSetArg(args[n], XmNlabelString, emptyString); ++n;
628 forwardBtn = XmCreatePushButton(toolBar, "forward", args, n);
629 addToolTip(forwardBtn, "Forward");
630 XtManageChild(forwardBtn);
631 XtAddCallback(forwardBtn, XmNactivateCallback,
632 &forwardCbk, (XtPointer)this);
633
634 // page number display
635 n = 0;
636 XtSetArg(args[n], XmNleftAttachment, XmATTACH_WIDGET); ++n;
637 XtSetArg(args[n], XmNleftWidget, forwardBtn); ++n;
638 XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); ++n;
639 XtSetArg(args[n], XmNbottomAttachment, XmATTACH_FORM); ++n;
640 s = XmStringCreateLocalized("Page ");
641 XtSetArg(args[n], XmNlabelString, s); ++n;
642 label = XmCreateLabel(toolBar, "pageLabel", args, n);
643 XmStringFree(s);
644 XtManageChild(label);
645 n = 0;
646 XtSetArg(args[n], XmNleftAttachment, XmATTACH_WIDGET); ++n;
647 XtSetArg(args[n], XmNleftWidget, label); ++n;
648 XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); ++n;
649 XtSetArg(args[n], XmNbottomAttachment, XmATTACH_FORM); ++n;
650 XtSetArg(args[n], XmNmarginWidth, 3); ++n;
651 XtSetArg(args[n], XmNmarginHeight, 3); ++n;
652 XtSetArg(args[n], XmNcolumns, 5); ++n;
653 pageNumText = XmCreateTextField(toolBar, "pageNum", args, n);
654 XtManageChild(pageNumText);
655 XtAddCallback(pageNumText, XmNactivateCallback,
656 &pageNumCbk, (XtPointer)this);
657 n = 0;
658 XtSetArg(args[n], XmNleftAttachment, XmATTACH_WIDGET); ++n;
659 XtSetArg(args[n], XmNleftWidget, pageNumText); ++n;
660 XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); ++n;
661 XtSetArg(args[n], XmNbottomAttachment, XmATTACH_FORM); ++n;
662 s = XmStringCreateLocalized(" of 00000");
663 XtSetArg(args[n], XmNlabelString, s); ++n;
664 XtSetArg(args[n], XmNalignment, XmALIGNMENT_BEGINNING); ++n;
665 XtSetArg(args[n], XmNrecomputeSize, False); ++n;
666 pageCountLabel = XmCreateLabel(toolBar, "pageCountLabel", args, n);
667 XmStringFree(s);
668 XtManageChild(pageCountLabel);
669 s = XmStringCreateLocalized(" of 0");
670 XtVaSetValues(pageCountLabel, XmNlabelString, s, NULL);
671 XmStringFree(s);
672
673 // zoom menu
674 #if USE_COMBO_BOX
675 XmString st[nZoomMenuItems];
676 n = 0;
677 XtSetArg(args[n], XmNleftAttachment, XmATTACH_WIDGET); ++n;
678 XtSetArg(args[n], XmNleftWidget, pageCountLabel); ++n;
679 XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); ++n;
680 XtSetArg(args[n], XmNbottomAttachment, XmATTACH_FORM); ++n;
681 XtSetArg(args[n], XmNmarginWidth, 0); ++n;
682 XtSetArg(args[n], XmNmarginHeight, 0); ++n;
683 XtSetArg(args[n], XmNcomboBoxType, XmDROP_DOWN_COMBO_BOX); ++n;
684 XtSetArg(args[n], XmNpositionMode, XmONE_BASED); ++n;
685 XtSetArg(args[n], XmNcolumns, 7); ++n;
686 for (i = 0; i < nZoomMenuItems; ++i) {
687 st[i] = XmStringCreateLocalized(zoomMenuInfo[i].label);
688 }
689 XtSetArg(args[n], XmNitems, st); ++n;
690 XtSetArg(args[n], XmNitemCount, nZoomMenuItems); ++n;
691 zoomComboBox = XmCreateComboBox(toolBar, "zoomComboBox", args, n);
692 for (i = 0; i < nZoomMenuItems; ++i) {
693 XmStringFree(st[i]);
694 }
695 addToolTip(zoomComboBox, "Zoom");
696 XtAddCallback(zoomComboBox, XmNselectionCallback,
697 &zoomComboBoxCbk, (XtPointer)this);
698 XtManageChild(zoomComboBox);
699 zoomWidget = zoomComboBox;
700 #else
701 Widget menuPane;
702 char buf[16];
703 n = 0;
704 menuPane = XmCreatePulldownMenu(toolBar, "zoomMenuPane", args, n);
705 for (i = 0; i < nZoomMenuItems; ++i) {
706 n = 0;
707 s = XmStringCreateLocalized(zoomMenuInfo[i].label);
708 XtSetArg(args[n], XmNlabelString, s); ++n;
709 XtSetArg(args[n], XmNuserData, (XtPointer)i); ++n;
710 sprintf(buf, "zoom%d", i);
711 btn = XmCreatePushButton(menuPane, buf, args, n);
712 XmStringFree(s);
713 XtManageChild(btn);
714 XtAddCallback(btn, XmNactivateCallback,
715 &zoomMenuCbk, (XtPointer)this);
716 zoomMenuBtns[i] = btn;
717 }
718 n = 0;
719 XtSetArg(args[n], XmNleftAttachment, XmATTACH_WIDGET); ++n;
720 XtSetArg(args[n], XmNleftWidget, pageCountLabel); ++n;
721 XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); ++n;
722 XtSetArg(args[n], XmNbottomAttachment, XmATTACH_FORM); ++n;
723 XtSetArg(args[n], XmNmarginWidth, 0); ++n;
724 XtSetArg(args[n], XmNmarginHeight, 0); ++n;
725 XtSetArg(args[n], XmNsubMenuId, menuPane); ++n;
726 zoomMenu = XmCreateOptionMenu(toolBar, "zoomMenu", args, n);
727 addToolTip(zoomMenu, "Zoom");
728 XtManageChild(zoomMenu);
729 zoomWidget = zoomMenu;
730 #endif
731
732 // find/print/about buttons
733 n = 0;
734 XtSetArg(args[n], XmNleftAttachment, XmATTACH_WIDGET); ++n;
735 XtSetArg(args[n], XmNleftWidget, zoomWidget); ++n;
736 XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); ++n;
737 XtSetArg(args[n], XmNbottomAttachment, XmATTACH_FORM); ++n;
738 XtSetArg(args[n], XmNmarginWidth, 6); ++n;
739 XtSetArg(args[n], XmNlabelString, emptyString); ++n;
740 findBtn = XmCreatePushButton(toolBar, "find", args, n);
741 addToolTip(findBtn, "Find");
742 XtManageChild(findBtn);
743 XtAddCallback(findBtn, XmNactivateCallback,
744 &findCbk, (XtPointer)this);
745 n = 0;
746 XtSetArg(args[n], XmNleftAttachment, XmATTACH_WIDGET); ++n;
747 XtSetArg(args[n], XmNleftWidget, findBtn); ++n;
748 XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); ++n;
749 XtSetArg(args[n], XmNbottomAttachment, XmATTACH_FORM); ++n;
750 XtSetArg(args[n], XmNmarginWidth, 6); ++n;
751 XtSetArg(args[n], XmNlabelString, emptyString); ++n;
752 printBtn = XmCreatePushButton(toolBar, "print", args, n);
753 addToolTip(printBtn, "Print");
754 XtManageChild(printBtn);
755 XtAddCallback(printBtn, XmNactivateCallback,
756 &printCbk, (XtPointer)this);
757 n = 0;
758 XtSetArg(args[n], XmNleftAttachment, XmATTACH_WIDGET); ++n;
759 XtSetArg(args[n], XmNleftWidget, printBtn); ++n;
760 XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); ++n;
761 XtSetArg(args[n], XmNbottomAttachment, XmATTACH_FORM); ++n;
762 XtSetArg(args[n], XmNmarginWidth, 6); ++n;
763 XtSetArg(args[n], XmNlabelString, emptyString); ++n;
764 aboutBtn = XmCreatePushButton(toolBar, "about", args, n);
765 addToolTip(aboutBtn, "About / help");
766 XtManageChild(aboutBtn);
767 XtAddCallback(aboutBtn, XmNactivateCallback,
768 &aboutCbk, (XtPointer)this);
769 lastBtn = aboutBtn;
770
771 // quit button
772 n = 0;
773 XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); ++n;
774 XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); ++n;
775 XtSetArg(args[n], XmNbottomAttachment, XmATTACH_FORM); ++n;
776 XtSetArg(args[n], XmNmarginWidth, 6); ++n;
777 s = XmStringCreateLocalized("Quit");
778 XtSetArg(args[n], XmNlabelString, s); ++n;
779 quitBtn = XmCreatePushButton(toolBar, "quit", args, n);
780 XmStringFree(s);
781 XtManageChild(quitBtn);
782 XtAddCallback(quitBtn, XmNactivateCallback,
783 &quitCbk, (XtPointer)this);
784
785 // link label
786 n = 0;
787 XtSetArg(args[n], XmNleftAttachment, XmATTACH_WIDGET); ++n;
788 XtSetArg(args[n], XmNleftWidget, lastBtn); ++n;
789 XtSetArg(args[n], XmNrightAttachment, XmATTACH_WIDGET); ++n;
790 XtSetArg(args[n], XmNrightWidget, quitBtn); ++n;
791 XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); ++n;
792 XtSetArg(args[n], XmNbottomAttachment, XmATTACH_FORM); ++n;
793 s = XmStringCreateLocalized("");
794 XtSetArg(args[n], XmNlabelString, s); ++n;
795 XtSetArg(args[n], XmNrecomputeSize, True); ++n;
796 XtSetArg(args[n], XmNalignment, XmALIGNMENT_BEGINNING); ++n;
797 linkLabel = XmCreateLabel(toolBar, "linkLabel", args, n);
798 XmStringFree(s);
799 XtManageChild(linkLabel);
800
801 #ifndef DISABLE_OUTLINE
802 if (app->getFullScreen()) {
803 #endif
804
805 // core
806 core = new XPDFCore(win, form,
807 app->getPaperRGB(), app->getPaperPixel(),
808 app->getMattePixel(),
809 app->getFullScreen(), app->getReverseVideo(),
810 app->getInstallCmap(), app->getRGBCubeSize());
811 core->setUpdateCbk(&updateCbk, this);
812 core->setActionCbk(&actionCbk, this);
813 core->setKeyPressCbk(&keyPressCbk, this);
814 core->setMouseCbk(&mouseCbk, this);
815 n = 0;
816 XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); ++n;
817 XtSetArg(args[n], XmNbottomAttachment, XmATTACH_WIDGET); ++n;
818 XtSetArg(args[n], XmNbottomWidget, toolBar); ++n;
819 XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); ++n;
820 XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); ++n;
821 XtSetValues(core->getWidget(), args, n);
822
823 #ifndef DISABLE_OUTLINE
824 } else {
825
826 // paned window
827 n = 0;
828 XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); ++n;
829 XtSetArg(args[n], XmNbottomAttachment, XmATTACH_WIDGET); ++n;
830 XtSetArg(args[n], XmNbottomWidget, toolBar); ++n;
831 XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); ++n;
832 XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); ++n;
833 XtSetArg(args[n], XmNorientation, XmHORIZONTAL); ++n;
834 #if defined(__sgi) && (XmVERSION <= 1)
835 panedWin = SgCreateHorzPanedWindow(form, "panedWin", args, n);
836 #else
837 panedWin = XmCreatePanedWindow(form, "panedWin", args, n);
838 #endif
839 XtManageChild(panedWin);
840
841 // scrolled window for outline container
842 n = 0;
843 XtSetArg(args[n], XmNpositionIndex, 0); ++n;
844 XtSetArg(args[n], XmNallowResize, True); ++n;
845 XtSetArg(args[n], XmNpaneMinimum, 1); ++n;
846 XtSetArg(args[n], XmNpaneMaximum, 10000); ++n;
847 #if !(defined(__sgi) && (XmVERSION <= 1))
848 XtSetArg(args[n], XmNwidth, 1); ++n;
849 #endif
850 XtSetArg(args[n], XmNscrollingPolicy, XmAUTOMATIC); ++n;
851 outlineScroll = XmCreateScrolledWindow(panedWin, "outlineScroll", args, n);
852 XtManageChild(outlineScroll);
853 XtVaGetValues(outlineScroll, XmNclipWindow, &clipWin, NULL);
854 XtVaSetValues(clipWin, XmNbackground, app->getPaperPixel(), NULL);
855
856 // outline tree
857 n = 0;
858 XtSetArg(args[n], XmNbackground, app->getPaperPixel()); ++n;
859 outlineTree = XPDFCreateTree(outlineScroll, "outlineTree", args, n);
860 XtManageChild(outlineTree);
861 XtAddCallback(outlineTree, XPDFNselectionCallback, &outlineSelectCbk,
862 (XtPointer)this);
863
864 // core
865 core = new XPDFCore(win, panedWin,
866 app->getPaperRGB(), app->getPaperPixel(),
867 app->getMattePixel(),
868 app->getFullScreen(), app->getReverseVideo(),
869 app->getInstallCmap(), app->getRGBCubeSize());
870 core->setUpdateCbk(&updateCbk, this);
871 core->setActionCbk(&actionCbk, this);
872 core->setKeyPressCbk(&keyPressCbk, this);
873 core->setMouseCbk(&mouseCbk, this);
874 n = 0;
875 XtSetArg(args[n], XmNpositionIndex, 1); ++n;
876 XtSetArg(args[n], XmNallowResize, True); ++n;
877 XtSetArg(args[n], XmNpaneMinimum, 1); ++n;
878 XtSetArg(args[n], XmNpaneMaximum, 10000); ++n;
879 XtSetValues(core->getWidget(), args, n);
880 }
881 #endif
882
883 // set the zoom menu to match the initial zoom setting
884 setZoomVal(core->getZoom());
885
886 // set traversal order
887 XtVaSetValues(core->getDrawAreaWidget(),
888 XmNnavigationType, XmEXCLUSIVE_TAB_GROUP, NULL);
889 XtVaSetValues(backBtn, XmNnavigationType, XmEXCLUSIVE_TAB_GROUP,
890 NULL);
891 XtVaSetValues(prevTenPageBtn, XmNnavigationType, XmEXCLUSIVE_TAB_GROUP,
892 NULL);
893 XtVaSetValues(prevPageBtn, XmNnavigationType, XmEXCLUSIVE_TAB_GROUP,
894 NULL);
895 XtVaSetValues(nextPageBtn, XmNnavigationType, XmEXCLUSIVE_TAB_GROUP,
896 NULL);
897 XtVaSetValues(nextTenPageBtn, XmNnavigationType, XmEXCLUSIVE_TAB_GROUP,
898 NULL);
899 XtVaSetValues(forwardBtn, XmNnavigationType, XmEXCLUSIVE_TAB_GROUP,
900 NULL);
901 XtVaSetValues(pageNumText, XmNnavigationType, XmEXCLUSIVE_TAB_GROUP,
902 NULL);
903 XtVaSetValues(zoomWidget, XmNnavigationType, XmEXCLUSIVE_TAB_GROUP,
904 NULL);
905 XtVaSetValues(findBtn, XmNnavigationType, XmEXCLUSIVE_TAB_GROUP,
906 NULL);
907 XtVaSetValues(printBtn, XmNnavigationType, XmEXCLUSIVE_TAB_GROUP,
908 NULL);
909 XtVaSetValues(aboutBtn, XmNnavigationType, XmEXCLUSIVE_TAB_GROUP,
910 NULL);
911 XtVaSetValues(quitBtn, XmNnavigationType, XmEXCLUSIVE_TAB_GROUP,
912 NULL);
913
914 // popup menu
915 n = 0;
916 #if XmVersion < 1002
917 // older versions of Motif need this, newer ones choke on it,
918 // sometimes not displaying the menu at all, maybe depending on the
919 // state of the NumLock key (taken from DDD)
920 XtSetArg(args[n], XmNmenuPost, "<Btn3Down>"); ++n;
921 #endif
922 popupMenu = XmCreatePopupMenu(core->getDrawAreaWidget(), "popupMenu",
923 args, n);
924 n = 0;
925 s = XmStringCreateLocalized("Open...");
926 XtSetArg(args[n], XmNlabelString, s); ++n;
927 s2 = XmStringCreateLocalized("O");
928 XtSetArg(args[n], XmNacceleratorText, s2); ++n;
929 btn = XmCreatePushButton(popupMenu, "open", args, n);
930 XmStringFree(s);
931 XmStringFree(s2);
932 XtManageChild(btn);
933 XtAddCallback(btn, XmNactivateCallback,
934 &openCbk, (XtPointer)this);
935 n = 0;
936 s = XmStringCreateLocalized("Open in new window...");
937 XtSetArg(args[n], XmNlabelString, s); ++n;
938 btn = XmCreatePushButton(popupMenu, "openInNewWindow", args, n);
939 XmStringFree(s);
940 XtManageChild(btn);
941 XtAddCallback(btn, XmNactivateCallback,
942 &openInNewWindowCbk, (XtPointer)this);
943 n = 0;
944 s = XmStringCreateLocalized("Reload");
945 XtSetArg(args[n], XmNlabelString, s); ++n;
946 s2 = XmStringCreateLocalized("R");
947 XtSetArg(args[n], XmNacceleratorText, s2); ++n;
948 btn = XmCreatePushButton(popupMenu, "reload", args, n);
949 XmStringFree(s);
950 XmStringFree(s2);
951 XtManageChild(btn);
952 XtAddCallback(btn, XmNactivateCallback,
953 &reloadCbk, (XtPointer)this);
954 n = 0;
955 s = XmStringCreateLocalized("Save as...");
956 XtSetArg(args[n], XmNlabelString, s); ++n;
957 btn = XmCreatePushButton(popupMenu, "saveAs", args, n);
958 XmStringFree(s);
959 XtManageChild(btn);
960 XtAddCallback(btn, XmNactivateCallback,
961 &saveAsCbk, (XtPointer)this);
962 n = 0;
963 btn = XmCreateSeparator(popupMenu, "sep1", args, n);
964 XtManageChild(btn);
965 n = 0;
966 s = XmStringCreateLocalized("Continuous view");
967 XtSetArg(args[n], XmNlabelString, s); ++n;
968 XtSetArg(args[n], XmNindicatorType, XmN_OF_MANY); ++n;
969 XtSetArg(args[n], XmNvisibleWhenOff, True); ++n;
970 XtSetArg(args[n], XmNset, core->getContinuousMode() ? XmSET : XmUNSET); ++n;
971 btn = XmCreateToggleButton(popupMenu, "continuousMode", args, n);
972 XmStringFree(s);
973 XtManageChild(btn);
974 XtAddCallback(btn, XmNvalueChangedCallback,
975 &continuousModeToggleCbk, (XtPointer)this);
976 n = 0;
977 s = XmStringCreateLocalized("Rotate counterclockwise");
978 XtSetArg(args[n], XmNlabelString, s); ++n;
979 btn = XmCreatePushButton(popupMenu, "rotateCCW", args, n);
980 XmStringFree(s);
981 XtManageChild(btn);
982 XtAddCallback(btn, XmNactivateCallback,
983 &rotateCCWCbk, (XtPointer)this);
984 n = 0;
985 s = XmStringCreateLocalized("Rotate clockwise");
986 XtSetArg(args[n], XmNlabelString, s); ++n;
987 btn = XmCreatePushButton(popupMenu, "rotateCW", args, n);
988 XmStringFree(s);
989 XtManageChild(btn);
990 XtAddCallback(btn, XmNactivateCallback,
991 &rotateCWCbk, (XtPointer)this);
992 n = 0;
993 btn = XmCreateSeparator(popupMenu, "sep2", args, n);
994 XtManageChild(btn);
995 n = 0;
996 s = XmStringCreateLocalized("Close");
997 XtSetArg(args[n], XmNlabelString, s); ++n;
998 s2 = XmStringCreateLocalized("Ctrl+W");
999 XtSetArg(args[n], XmNacceleratorText, s2); ++n;
1000 btn = XmCreatePushButton(popupMenu, "close", args, n);
1001 XmStringFree(s);
1002 XmStringFree(s2);
1003 XtManageChild(btn);
1004 XtAddCallback(btn, XmNactivateCallback,
1005 &closeCbk, (XtPointer)this);
1006 n = 0;
1007 s = XmStringCreateLocalized("Quit");
1008 XtSetArg(args[n], XmNlabelString, s); ++n;
1009 s2 = XmStringCreateLocalized("Q");
1010 XtSetArg(args[n], XmNacceleratorText, s2); ++n;
1011 btn = XmCreatePushButton(popupMenu, "quit", args, n);
1012 XmStringFree(s);
1013 XmStringFree(s2);
1014 XtManageChild(btn);
1015 XtAddCallback(btn, XmNactivateCallback,
1016 &quitCbk, (XtPointer)this);
1017
1018 // this is magic (taken from DDD) - weird things happen if this
1019 // call isn't made
1020 XtUngrabButton(core->getDrawAreaWidget(), AnyButton, AnyModifier);
1021
1022 XmStringFree(emptyString);
1023 }
1024
1025 void XPDFViewer::addToolTip(Widget widget, char *text) {
1026 #ifdef XmNtoolTipString
1027 XmString s;
1028 Cardinal n, i;
1029 WidgetList children;
1030
1031 if (XtIsComposite(widget)) {
1032 XtVaGetValues(widget, XmNnumChildren, &n, XmNchildren, &children, NULL);
1033 for (i = 0; i < n; ++i) {
1034 addToolTip(children[i], text);
1035 }
1036 } else {
1037 s = XmStringCreateLocalized(text);
1038 XtVaSetValues(widget, XmNtoolTipString, s, NULL);
1039 XmStringFree(s);
1040 }
1041 #endif
1042 }
1043
1044 void XPDFViewer::mapWindow() {
1045 #ifdef HAVE_X11_XPM_H
1046 Pixmap iconPixmap;
1047 #endif
1048 int depth;
1049 Pixel fg, bg, arm;
1050
1051 // show the window
1052 XtPopup(win, XtGrabNone);
1053 core->takeFocus();
1054
1055 // create the icon
1056 #ifdef HAVE_X11_XPM_H
1057 if (XpmCreatePixmapFromData(display, XtWindow(win), xpdfIcon,
1058 &iconPixmap, NULL, NULL) == XpmSuccess) {
1059 XtVaSetValues(win, XmNiconPixmap, iconPixmap, NULL);
1060 }
1061 #endif
1062
1063 // set button bitmaps (must be done after the window is mapped)
1064 XtVaGetValues(backBtn, XmNdepth, &depth,
1065 XmNforeground, &fg, XmNbackground, &bg,
1066 XmNarmColor, &arm, NULL);
1067 XtVaSetValues(backBtn, XmNlabelType, XmPIXMAP,
1068 XmNlabelPixmap,
1069 XCreatePixmapFromBitmapData(display, XtWindow(toolBar),
1070 (char *)backArrow_bits,
1071 backArrow_width,
1072 backArrow_height,
1073 fg, bg, depth),
1074 XmNarmPixmap,
1075 XCreatePixmapFromBitmapData(display, XtWindow(toolBar),
1076 (char *)backArrow_bits,
1077 backArrow_width,
1078 backArrow_height,
1079 fg, arm, depth),
1080 XmNlabelInsensitivePixmap,
1081 XCreatePixmapFromBitmapData(display, XtWindow(toolBar),
1082 (char *)backArrowDis_bits,
1083 backArrowDis_width,
1084 backArrowDis_height,
1085 fg, bg, depth),
1086 NULL);
1087 XtVaSetValues(prevTenPageBtn, XmNlabelType, XmPIXMAP,
1088 XmNlabelPixmap,
1089 XCreatePixmapFromBitmapData(display, XtWindow(toolBar),
1090 (char *)dblLeftArrow_bits,
1091 dblLeftArrow_width,
1092 dblLeftArrow_height,
1093 fg, bg, depth),
1094 XmNarmPixmap,
1095 XCreatePixmapFromBitmapData(display, XtWindow(toolBar),
1096 (char *)dblLeftArrow_bits,
1097 dblLeftArrow_width,
1098 dblLeftArrow_height,
1099 fg, arm, depth),
1100 XmNlabelInsensitivePixmap,
1101 XCreatePixmapFromBitmapData(display, XtWindow(toolBar),
1102 (char *)dblLeftArrowDis_bits,
1103 dblLeftArrowDis_width,
1104 dblLeftArrowDis_height,
1105 fg, bg, depth),
1106 NULL);
1107 XtVaSetValues(prevPageBtn, XmNlabelType, XmPIXMAP,
1108 XmNlabelPixmap,
1109 XCreatePixmapFromBitmapData(display, XtWindow(toolBar),
1110 (char *)leftArrow_bits,
1111 leftArrow_width,
1112 leftArrow_height,
1113 fg, bg, depth),
1114 XmNarmPixmap,
1115 XCreatePixmapFromBitmapData(display, XtWindow(toolBar),
1116 (char *)leftArrow_bits,
1117 leftArrow_width,
1118 leftArrow_height,
1119 fg, arm, depth),
1120 XmNlabelInsensitivePixmap,
1121 XCreatePixmapFromBitmapData(display, XtWindow(toolBar),
1122 (char *)leftArrowDis_bits,
1123 leftArrowDis_width,
1124 leftArrowDis_height,
1125 fg, bg, depth),
1126 NULL);
1127 XtVaSetValues(nextPageBtn, XmNlabelType, XmPIXMAP,
1128 XmNlabelPixmap,
1129 XCreatePixmapFromBitmapData(display, XtWindow(toolBar),
1130 (char *)rightArrow_bits,
1131 rightArrow_width,
1132 rightArrow_height,
1133 fg, bg, depth),
1134 XmNarmPixmap,
1135 XCreatePixmapFromBitmapData(display, XtWindow(toolBar),
1136 (char *)rightArrow_bits,
1137 rightArrow_width,
1138 rightArrow_height,
1139 fg, arm, depth),
1140 XmNlabelInsensitivePixmap,
1141 XCreatePixmapFromBitmapData(display, XtWindow(toolBar),
1142 (char *)rightArrowDis_bits,
1143 rightArrowDis_width,
1144 rightArrowDis_height,
1145 fg, bg, depth),
1146 NULL);
1147 XtVaSetValues(nextTenPageBtn, XmNlabelType, XmPIXMAP,
1148 XmNlabelPixmap,
1149 XCreatePixmapFromBitmapData(display, XtWindow(toolBar),
1150 (char *)dblRightArrow_bits,
1151 dblRightArrow_width,
1152 dblRightArrow_height,
1153 fg, bg, depth),
1154 XmNarmPixmap,
1155 XCreatePixmapFromBitmapData(display, XtWindow(toolBar),
1156 (char *)dblRightArrow_bits,
1157 dblRightArrow_width,
1158 dblRightArrow_height,
1159 fg, arm, depth),
1160 XmNlabelInsensitivePixmap,
1161 XCreatePixmapFromBitmapData(display, XtWindow(toolBar),
1162 (char *)dblRightArrowDis_bits,
1163 dblRightArrowDis_width,
1164 dblRightArrowDis_height,
1165 fg, bg, depth),
1166 NULL);
1167 XtVaSetValues(forwardBtn, XmNlabelType, XmPIXMAP,
1168 XmNlabelPixmap,
1169 XCreatePixmapFromBitmapData(display, XtWindow(toolBar),
1170 (char *)forwardArrow_bits,
1171 forwardArrow_width,
1172 forwardArrow_height,
1173 fg, bg, depth),
1174 XmNarmPixmap,
1175 XCreatePixmapFromBitmapData(display, XtWindow(toolBar),
1176 (char *)forwardArrow_bits,
1177 forwardArrow_width,
1178 forwardArrow_height,
1179 fg, arm, depth),
1180 XmNlabelInsensitivePixmap,
1181 XCreatePixmapFromBitmapData(display, XtWindow(toolBar),
1182 (char *)forwardArrowDis_bits,
1183 forwardArrowDis_width,
1184 forwardArrowDis_height,
1185 fg, bg, depth),
1186 NULL);
1187 XtVaSetValues(findBtn, XmNlabelType, XmPIXMAP,
1188 XmNlabelPixmap,
1189 XCreatePixmapFromBitmapData(display, XtWindow(toolBar),
1190 (char *)find_bits,
1191 find_width,
1192 find_height,
1193 fg, bg, depth),
1194 XmNarmPixmap,
1195 XCreatePixmapFromBitmapData(display, XtWindow(toolBar),
1196 (char *)find_bits,
1197 find_width,
1198 find_height,
1199 fg, arm, depth),
1200 XmNlabelInsensitivePixmap,
1201 XCreatePixmapFromBitmapData(display, XtWindow(toolBar),
1202 (char *)findDis_bits,
1203 findDis_width,
1204 findDis_height,
1205 fg, bg, depth),
1206 NULL);
1207 XtVaSetValues(printBtn, XmNlabelType, XmPIXMAP,
1208 XmNlabelPixmap,
1209 XCreatePixmapFromBitmapData(display, XtWindow(toolBar),
1210 (char *)print_bits,
1211 print_width,
1212 print_height,
1213 fg, bg, depth),
1214 XmNarmPixmap,
1215 XCreatePixmapFromBitmapData(display, XtWindow(toolBar),
1216 (char *)print_bits,
1217 print_width,
1218 print_height,
1219 fg, arm, depth),
1220 XmNlabelInsensitivePixmap,
1221 XCreatePixmapFromBitmapData(display, XtWindow(toolBar),
1222 (char *)printDis_bits,
1223 printDis_width,
1224 printDis_height,
1225 fg, bg, depth),
1226 NULL);
1227 XtVaSetValues(aboutBtn, XmNlabelType, XmPIXMAP,
1228 XmNlabelPixmap,
1229 XCreatePixmapFromBitmapData(display, XtWindow(toolBar),
1230 (char *)about_bits,
1231 about_width,
1232 about_height,
1233 fg, bg, depth),
1234 XmNarmPixmap,
1235 XCreatePixmapFromBitmapData(display, XtWindow(toolBar),
1236 (char *)about_bits,
1237 about_width,
1238 about_height,
1239 fg, arm, depth),
1240 NULL);
1241 }
1242
1243 void XPDFViewer::closeWindow() {
1244 XtPopdown(win);
1245 XtDestroyWidget(win);
1246 }
1247
1248 int XPDFViewer::getZoomIdx() {
1249 #if USE_COMBO_BOX
1250 int z;
1251
1252 XtVaGetValues(zoomComboBox, XmNselectedPosition, &z, NULL);
1253 return z - 1;
1254 #else
1255 Widget w;
1256 int i;
1257
1258 XtVaGetValues(zoomMenu, XmNmenuHistory, &w, NULL);
1259 for (i = 0; i < nZoomMenuItems; ++i) {
1260 if (w == zoomMenuBtns[i]) {
1261 return i;
1262 }
1263 }
1264 // this should never happen
1265 return 0;
1266 #endif
1267 }
1268
1269 void XPDFViewer::setZoomIdx(int idx) {
1270 #if USE_COMBO_BOX
1271 XtVaSetValues(zoomComboBox, XmNselectedPosition, idx + 1, NULL);
1272 #else
1273 XtVaSetValues(zoomMenu, XmNmenuHistory, zoomMenuBtns[idx], NULL);
1274 #endif
1275 }
1276
1277 void XPDFViewer::setZoomVal(double z) {
1278 #if USE_COMBO_BOX
1279 char buf[32];
1280 XmString s;
1281 int i;
1282
1283 for (i = 0; i < nZoomMenuItems; ++i) {
1284 if (z == zoomMenuInfo[i].zoom) {
1285 XtVaSetValues(zoomComboBox, XmNselectedPosition, i + 1, NULL);
1286 return;
1287 }
1288 }
1289 sprintf(buf, "%d", (int)z);
1290 s = XmStringCreateLocalized(buf);
1291 XtVaSetValues(zoomComboBox, XmNselectedItem, s, NULL);
1292 XmStringFree(s);
1293 #else
1294 int i;
1295
1296 for (i = 0; i < nZoomMenuItems; ++i) {
1297 if (z == zoomMenuInfo[i].zoom) {
1298 XtVaSetValues(zoomMenu, XmNmenuHistory, zoomMenuBtns[i], NULL);
1299 return;
1300 }
1301 }
1302 for (i = maxZoomIdx; i < minZoomIdx; ++i) {
1303 if (z > zoomMenuInfo[i].zoom) {
1304 break;
1305 }
1306 }
1307 XtVaSetValues(zoomMenu, XmNmenuHistory, zoomMenuBtns[i], NULL);
1308 #endif
1309 }
1310
1311 void XPDFViewer::prevPageCbk(Widget widget, XtPointer ptr,
1312 XtPointer callData) {
1313 XPDFViewer *viewer = (XPDFViewer *)ptr;
1314
1315 viewer->core->gotoPrevPage(1, gTrue, gFalse);
1316 viewer->core->takeFocus();
1317 }
1318
1319 void XPDFViewer::prevTenPageCbk(Widget widget, XtPointer ptr,
1320 XtPointer callData) {
1321 XPDFViewer *viewer = (XPDFViewer *)ptr;
1322
1323 viewer->core->gotoPrevPage(10, gTrue, gFalse);
1324 viewer->core->takeFocus();
1325 }
1326
1327 void XPDFViewer::nextPageCbk(Widget widget, XtPointer ptr,
1328 XtPointer callData) {
1329 XPDFViewer *viewer = (XPDFViewer *)ptr;
1330
1331 viewer->core->gotoNextPage(1, gTrue);
1332 viewer->core->takeFocus();
1333 }
1334
1335 void XPDFViewer::nextTenPageCbk(Widget widget, XtPointer ptr,
1336 XtPointer callData) {
1337 XPDFViewer *viewer = (XPDFViewer *)ptr;
1338
1339 viewer->core->gotoNextPage(10, gTrue);
1340 viewer->core->takeFocus();
1341 }
1342
1343 void XPDFViewer::backCbk(Widget widget, XtPointer ptr,
1344 XtPointer callData) {
1345 XPDFViewer *viewer = (XPDFViewer *)ptr;
1346
1347 viewer->core->goBackward();
1348 viewer->core->takeFocus();
1349 }
1350
1351 void XPDFViewer::forwardCbk(Widget widget, XtPointer ptr,
1352 XtPointer callData) {
1353 XPDFViewer *viewer = (XPDFViewer *)ptr;
1354
1355 viewer->core->goForward();
1356 viewer->core->takeFocus();
1357 }
1358
1359 #if USE_COMBO_BOX
1360
1361 void XPDFViewer::zoomComboBoxCbk(Widget widget, XtPointer ptr,
1362 XtPointer callData) {
1363 XPDFViewer *viewer = (XPDFViewer *)ptr;
1364 XmComboBoxCallbackStruct *data = (XmComboBoxCallbackStruct *)callData;
1365 double z;
1366 char *s;
1367 XmStringContext context;
1368 XmStringCharSet charSet;
1369 XmStringDirection dir;
1370 Boolean sep;
1371
1372 z = viewer->core->getZoom();
1373 if (data->item_position == 0) {
1374 XmStringInitContext(&context, data->item_or_text);
1375 if (XmStringGetNextSegment(context, &s, &charSet, &dir, &sep)) {
1376 z = atof(s);
1377 if (z <= 1) {
1378 z = defZoom;
1379 }
1380 XtFree(charSet);
1381 XtFree(s);
1382 }
1383 XmStringFreeContext(context);
1384 } else {
1385 z = zoomMenuInfo[data->item_position - 1].zoom;
1386 }
1387 // only redraw if this was triggered by an event; otherwise
1388 // the caller is responsible for doing the redraw
1389 if (z != viewer->core->getZoom() && data->event) {
1390 viewer->displayPage(viewer->core->getPageNum(), z,
1391 viewer->core->getRotate(), gTrue, gFalse);
1392 }
1393 viewer->core->takeFocus();
1394 }
1395
1396 #else // USE_COMBO_BOX
1397
1398 void XPDFViewer::zoomMenuCbk(Widget widget, XtPointer ptr,
1399 XtPointer callData) {
1400 XPDFViewer *viewer = (XPDFViewer *)ptr;
1401 XmPushButtonCallbackStruct *data = (XmPushButtonCallbackStruct *)callData;
1402 XtPointer userData;
1403 double z;
1404
1405 XtVaGetValues(widget, XmNuserData, &userData, NULL);
1406 z = zoomMenuInfo[(long)userData].zoom;
1407 // only redraw if this was triggered by an event; otherwise
1408 // the caller is responsible for doing the redraw
1409 if (z != viewer->core->getZoom() && data->event) {
1410 viewer->displayPage(viewer->core->getPageNum(), z,
1411 viewer->core->getRotate(), gTrue, gFalse);
1412 }
1413 viewer->core->takeFocus();
1414 }
1415
1416 #endif // USE_COMBO_BOX
1417
1418 void XPDFViewer::findCbk(Widget widget, XtPointer ptr,
1419 XtPointer callData) {
1420 XPDFViewer *viewer = (XPDFViewer *)ptr;
1421
1422 if (!viewer->core->getDoc()) {
1423 return;
1424 }
1425 viewer->mapFindDialog();
1426 }
1427
1428 void XPDFViewer::printCbk(Widget widget, XtPointer ptr,
1429 XtPointer callData) {
1430 XPDFViewer *viewer = (XPDFViewer *)ptr;
1431
1432 if (!viewer->core->getDoc()) {
1433 return;
1434 }
1435 XtManageChild(viewer->printDialog);
1436 }
1437
1438 void XPDFViewer::aboutCbk(Widget widget, XtPointer ptr,
1439 XtPointer callData) {
1440 XPDFViewer *viewer = (XPDFViewer *)ptr;
1441
1442 XtManageChild(viewer->aboutDialog);
1443 }
1444
1445 void XPDFViewer::quitCbk(Widget widget, XtPointer ptr,
1446 XtPointer callData) {
1447 XPDFViewer *viewer = (XPDFViewer *)ptr;
1448
1449 viewer->app->quit();
1450 }
1451
1452 void XPDFViewer::openCbk(Widget widget, XtPointer ptr,
1453 XtPointer callData) {
1454 XPDFViewer *viewer = (XPDFViewer *)ptr;
1455
1456 viewer->mapOpenDialog(gFalse);
1457 }
1458
1459 void XPDFViewer::openInNewWindowCbk(Widget widget, XtPointer ptr,
1460 XtPointer callData) {
1461 XPDFViewer *viewer = (XPDFViewer *)ptr;
1462
1463 viewer->mapOpenDialog(gTrue);
1464 }
1465
1466 void XPDFViewer::reloadCbk(Widget widget, XtPointer ptr,
1467 XtPointer callData) {
1468 XPDFViewer *viewer = (XPDFViewer *)ptr;
1469
1470 viewer->reloadFile();
1471 }
1472
1473 void XPDFViewer::saveAsCbk(Widget widget, XtPointer ptr,
1474 XtPointer callData) {
1475 XPDFViewer *viewer = (XPDFViewer *)ptr;
1476
1477 if (!viewer->core->getDoc()) {
1478 return;
1479 }
1480 viewer->mapSaveAsDialog();
1481 }
1482
1483 void XPDFViewer::continuousModeToggleCbk(Widget widget, XtPointer ptr,
1484 XtPointer callData) {
1485 XPDFViewer *viewer = (XPDFViewer *)ptr;
1486 XmToggleButtonCallbackStruct *data =
1487 (XmToggleButtonCallbackStruct *)callData;
1488
1489 viewer->core->setContinuousMode(data->set == XmSET);
1490 }
1491
1492 void XPDFViewer::rotateCCWCbk(Widget widget, XtPointer ptr,
1493 XtPointer callData) {
1494 XPDFViewer *viewer = (XPDFViewer *)ptr;
1495 int r;
1496
1497 r = viewer->core->getRotate();
1498 r = (r == 0) ? 270 : r - 90;
1499 viewer->displayPage(viewer->core->getPageNum(), viewer->core->getZoom(),
1500 r, gTrue, gFalse);
1501 }
1502
1503 void XPDFViewer::rotateCWCbk(Widget widget, XtPointer ptr,
1504 XtPointer callData) {
1505 XPDFViewer *viewer = (XPDFViewer *)ptr;
1506 int r;
1507
1508 r = viewer->core->getRotate();
1509 r = (r == 270) ? 0 : r + 90;
1510 viewer->displayPage(viewer->core->getPageNum(), viewer->core->getZoom(),
1511 r, gTrue, gFalse);
1512 }
1513
1514 void XPDFViewer::closeCbk(Widget widget, XtPointer ptr,
1515 XtPointer callData) {
1516 XPDFViewer *viewer = (XPDFViewer *)ptr;
1517
1518 viewer->app->close(viewer, gFalse);
1519 }
1520
1521 void XPDFViewer::closeMsgCbk(Widget widget, XtPointer ptr,
1522 XtPointer callData) {
1523 XPDFViewer *viewer = (XPDFViewer *)ptr;
1524
1525 viewer->app->close(viewer, gTrue);
1526 }
1527
1528 void XPDFViewer::pageNumCbk(Widget widget, XtPointer ptr,
1529 XtPointer callData) {
1530 XPDFViewer *viewer = (XPDFViewer *)ptr;
1531 char *s, *p;
1532 int pg;
1533 char buf[20];
1534
1535 if (!viewer->core->getDoc()) {
1536 goto err;
1537 }
1538 s = XmTextFieldGetString(viewer->pageNumText);
1539 for (p = s; *p; ++p) {
1540 if (!isdigit(*p)) {
1541 goto err;
1542 }
1543 }
1544 pg = atoi(s);
1545 if (pg < 1 || pg > viewer->core->getDoc()->getNumPages()) {
1546 goto err;
1547 }
1548 viewer->displayPage(pg, viewer->core->getZoom(),
1549 viewer->core->getRotate(), gFalse, gTrue);
1550 viewer->core->takeFocus();
1551 return;
1552
1553 err:
1554 XBell(viewer->display, 0);
1555 sprintf(buf, "%d", viewer->core->getPageNum());
1556 XmTextFieldSetString(viewer->pageNumText, buf);
1557 }
1558
1559 void XPDFViewer::updateCbk(void *data, GString *fileName,
1560 int pageNum, int numPages, char *linkString) {
1561 XPDFViewer *viewer = (XPDFViewer *)data;
1562 GString *title;
1563 char buf[20];
1564 XmString s;
1565
1566 if (fileName) {
1567 if (!(title = viewer->app->getTitle())) {
1568 title = (new GString(xpdfAppName))->append(": ")->append(fileName);
1569 }
1570 XtVaSetValues(viewer->win, XmNtitle, title->getCString(),
1571 XmNiconName, title->getCString(), NULL);
1572 if (!viewer->app->getTitle()) {
1573 delete title;
1574 }
1575 #ifndef DISABLE_OUTLINE
1576 if (!viewer->app->getFullScreen()) {
1577 viewer->setupOutline();
1578 }
1579 #endif
1580 viewer->setupPrintDialog();
1581 }
1582
1583 if (pageNum >= 0) {
1584 s = XmStringCreateLocalized("");
1585 XtVaSetValues(viewer->linkLabel, XmNlabelString, s, NULL);
1586 XmStringFree(s);
1587 sprintf(buf, "%d", pageNum);
1588 XmTextFieldSetString(viewer->pageNumText, buf);
1589 XtVaSetValues(viewer->prevTenPageBtn, XmNsensitive,
1590 pageNum > 1, NULL);
1591 XtVaSetValues(viewer->prevPageBtn, XmNsensitive,
1592 pageNum > 1, NULL);
1593 XtVaSetValues(viewer->nextTenPageBtn, XmNsensitive,
1594 pageNum < viewer->core->getDoc()->getNumPages(), NULL);
1595 XtVaSetValues(viewer->nextPageBtn, XmNsensitive,
1596 pageNum < viewer->core->getDoc()->getNumPages(), NULL);
1597 XtVaSetValues(viewer->backBtn, XmNsensitive,
1598 viewer->core->canGoBack(), NULL);
1599 XtVaSetValues(viewer->forwardBtn, XmNsensitive,
1600 viewer->core->canGoForward(), NULL);
1601 }
1602
1603 if (numPages >= 0) {
1604 sprintf(buf, " of %d", numPages);
1605 s = XmStringCreateLocalized(buf);
1606 XtVaSetValues(viewer->pageCountLabel, XmNlabelString, s, NULL);
1607 XmStringFree(s);
1608 }
1609
1610 if (linkString) {
1611 s = XmStringCreateLocalized(linkString);
1612 XtVaSetValues(viewer->linkLabel, XmNlabelString, s, NULL);
1613 XmStringFree(s);
1614 }
1615 }
1616
1617
1618 //------------------------------------------------------------------------
1619 // GUI code: outline
1620 //------------------------------------------------------------------------
1621
1622 #ifndef DISABLE_OUTLINE
1623
1624 void XPDFViewer::setupOutline() {
1625 GList *items;
1626 UnicodeMap *uMap;
1627 GString *enc;
1628 int i;
1629
1630 // unmanage and destroy the old labels
1631 if (outlineLabels) {
1632 XtUnmanageChildren(outlineLabels, outlineLabelsLength);
1633 for (i = 0; i < outlineLabelsLength; ++i) {
1634 XtDestroyWidget(outlineLabels[i]);
1635 }
1636 gfree(outlineLabels);
1637 outlineLabels = NULL;
1638 outlineLabelsLength = outlineLabelsSize = 0;
1639 }
1640
1641 if (core->getDoc()) {
1642
1643 // create the new labels
1644 items = core->getDoc()->getOutline()->getItems();
1645 if (items && items->getLength() > 0) {
1646 enc = new GString("Latin1");
1647 uMap = globalParams->getUnicodeMap(enc);
1648 delete enc;
1649 setupOutlineItems(items, NULL, uMap);
1650 uMap->decRefCnt();
1651 }
1652
1653 // manage the new labels
1654 XtManageChildren(outlineLabels, outlineLabelsLength);
1655 }
1656 }
1657
1658 void XPDFViewer::setupOutlineItems(GList *items, Widget parent,
1659 UnicodeMap *uMap) {
1660 OutlineItem *item;
1661 GList *kids;
1662 Widget label;
1663 Arg args[20];
1664 GString *title;
1665 char buf[8];
1666 XmString s;
1667 int i, j, n;
1668
1669 for (i = 0; i < items->getLength(); ++i) {
1670 item = (OutlineItem *)items->get(i);
1671 title = new GString();
1672 for (j = 0; j < item->getTitleLength(); ++j) {
1673 n = uMap->mapUnicode(item->getTitle()[j], buf, sizeof(buf));
1674 title->append(buf, n);
1675 }
1676 n = 0;
1677 XtSetArg(args[n], XPDFNentryPosition, i); ++n;
1678 if (parent) {
1679 XtSetArg(args[n], XPDFNentryParent, parent); ++n;
1680 }
1681 XtSetArg(args[n], XPDFNentryExpanded, item->isOpen()); ++n;
1682 s = XmStringCreateLocalized(title->getCString());
1683 delete title;
1684 XtSetArg(args[n], XmNlabelString, s); ++n;
1685 XtSetArg(args[n], XmNuserData, item); ++n;
1686 XtSetArg(args[n], XmNmarginWidth, 0); ++n;
1687 XtSetArg(args[n], XmNmarginHeight, 2); ++n;
1688 XtSetArg(args[n], XmNshadowThickness, 0); ++n;
1689 XtSetArg(args[n], XmNforeground,
1690 app->getReverseVideo() ? WhitePixel(display, screenNum)
1691 : BlackPixel(display, screenNum)); ++n;
1692 XtSetArg(args[n], XmNbackground, app->getPaperPixel()); ++n;
1693 label = XmCreateLabelGadget(outlineTree, "label", args, n);
1694 XmStringFree(s);
1695 if (outlineLabelsLength == outlineLabelsSize) {
1696 outlineLabelsSize += 64;
1697 outlineLabels = (Widget *)greallocn(outlineLabels,
1698 outlineLabelsSize, sizeof(Widget *));
1699 }
1700 outlineLabels[outlineLabelsLength++] = label;
1701 item->open();
1702 if ((kids = item->getKids())) {
1703 setupOutlineItems(kids, label, uMap);
1704 }
1705 }
1706 }
1707
1708 void XPDFViewer::outlineSelectCbk(Widget widget, XtPointer ptr,
1709 XtPointer callData) {
1710 XPDFViewer *viewer = (XPDFViewer *)ptr;
1711 XPDFTreeSelectCallbackStruct *data =
1712 (XPDFTreeSelectCallbackStruct *)callData;
1713 OutlineItem *item;
1714
1715 XtVaGetValues(data->selectedItem, XmNuserData, &item, NULL);
1716 if (item) {
1717 if (item->getAction()) {
1718 viewer->core->doAction(item->getAction());
1719 }
1720 }
1721 viewer->core->takeFocus();
1722 }
1723
1724 #endif // !DISABLE_OUTLINE
1725
1726 //------------------------------------------------------------------------
1727 // GUI code: "about" dialog
1728 //------------------------------------------------------------------------
1729
1730 void XPDFViewer::initAboutDialog() {
1731 Widget scrolledWin, col, label, sep, closeBtn;
1732 Arg args[20];
1733 int n, i;
1734 XmString s;
1735 char buf[20];
1736
1737 //----- dialog
1738 n = 0;
1739 s = XmStringCreateLocalized(xpdfAppName ": About");
1740 XtSetArg(args[n], XmNdialogTitle, s); ++n;
1741 XtSetArg(args[n], XmNwidth, 450); ++n;
1742 XtSetArg(args[n], XmNheight, 300); ++n;
1743 aboutDialog = XmCreateFormDialog(win, "aboutDialog", args, n);
1744 XmStringFree(s);
1745
1746 //----- "close" button
1747 n = 0;
1748 XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); ++n;
1749 XtSetArg(args[n], XmNrightOffset, 4); ++n;
1750 XtSetArg(args[n], XmNbottomAttachment, XmATTACH_FORM); ++n;
1751 XtSetArg(args[n], XmNbottomOffset, 4); ++n;
1752 closeBtn = XmCreatePushButton(aboutDialog, "Close", args, n);
1753 XtManageChild(closeBtn);
1754 n = 0;
1755 XtSetArg(args[n], XmNdefaultButton, closeBtn); ++n;
1756 XtSetArg(args[n], XmNcancelButton, closeBtn); ++n;
1757 XtSetValues(aboutDialog, args, n);
1758
1759 //----- scrolled window and RowColumn
1760 n = 0;
1761 XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); ++n;
1762 XtSetArg(args[n], XmNbottomAttachment, XmATTACH_WIDGET); ++n;
1763 XtSetArg(args[n], XmNbottomWidget, closeBtn); ++n;
1764 XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); ++n;
1765 XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); ++n;
1766 XtSetArg(args[n], XmNscrollingPolicy, XmAUTOMATIC); ++n;
1767 scrolledWin = XmCreateScrolledWindow(aboutDialog, "scrolledWin", args, n);
1768 XtManageChild(scrolledWin);
1769 n = 0;
1770 XtSetArg(args[n], XmNorientation, XmVERTICAL); ++n;
1771 XtSetArg(args[n], XmNpacking, XmPACK_TIGHT); ++n;
1772 col = XmCreateRowColumn(scrolledWin, "col", args, n);
1773 XtManageChild(col);
1774
1775 //----- fonts
1776 aboutBigFont =
1777 createFontList("-*-times-bold-i-normal--20-*-*-*-*-*-iso8859-1");
1778 aboutVersionFont =
1779 createFontList("-*-times-medium-r-normal--16-*-*-*-*-*-iso8859-1");
1780 aboutFixedFont =
1781 createFontList("-*-courier-medium-r-normal--12-*-*-*-*-*-iso8859-1");
1782
1783 //----- heading
1784 n = 0;
1785 s = XmStringCreateLocalized("Xpdf");
1786 XtSetArg(args[n], XmNlabelString, s); ++n;
1787 XtSetArg(args[n], XmNfontList, aboutBigFont); ++n;
1788 label = XmCreateLabel(col, "h0", args, n);
1789 XmStringFree(s);
1790 XtManageChild(label);
1791 n = 0;
1792 s = XmStringCreateLocalized("Version " xpdfVersion);
1793 XtSetArg(args[n], XmNlabelString, s); ++n;
1794 XtSetArg(args[n], XmNfontList, aboutVersionFont); ++n;
1795 label = XmCreateLabel(col, "h1", args, n);
1796 XmStringFree(s);
1797 XtManageChild(label);
1798 n = 0;
1799 s = XmStringCreateLocalized(xpdfCopyright);
1800 XtSetArg(args[n], XmNlabelString, s); ++n;
1801 XtSetArg(args[n], XmNfontList, aboutVersionFont); ++n;
1802 label = XmCreateLabel(col, "h2", args, n);
1803 XmStringFree(s);
1804 XtManageChild(label);
1805 n = 0;
1806 s = XmStringCreateLocalized(" ");
1807 XtSetArg(args[n], XmNlabelString, s); ++n;
1808 XtSetArg(args[n], XmNfontList, aboutVersionFont); ++n;
1809 label = XmCreateLabel(col, "h3", args, n);
1810 XmStringFree(s);
1811 XtManageChild(label);
1812 n = 0;
1813 XtSetArg(args[n], XmNorientation, XmHORIZONTAL); ++n;
1814 sep = XmCreateSeparator(col, "sep", args, n);
1815 XtManageChild(sep);
1816 n = 0;
1817 s = XmStringCreateLocalized(" ");
1818 XtSetArg(args[n], XmNlabelString, s); ++n;
1819 XtSetArg(args[n], XmNfontList, aboutVersionFont); ++n;
1820 label = XmCreateLabel(col, "h4", args, n);
1821 XmStringFree(s);
1822 XtManageChild(label);
1823 n = 0;
1824
1825 //----- text
1826 for (i = 0; aboutWinText[i]; ++i) {
1827 n = 0;
1828 s = XmStringCreateLocalized(aboutWinText[i]);
1829 XtSetArg(args[n], XmNlabelString, s); ++n;
1830 XtSetArg(args[n], XmNfontList, aboutFixedFont); ++n;
1831 sprintf(buf, "t%d", i);
1832 label = XmCreateLabel(col, buf, args, n);
1833 XtManageChild(label);
1834 XmStringFree(s);
1835 }
1836 }
1837
1838 //------------------------------------------------------------------------
1839 // GUI code: "open" dialog
1840 //------------------------------------------------------------------------
1841
1842 void XPDFViewer::initOpenDialog() {
1843 Arg args[20];
1844 int n;
1845 XmString s1, s2, s3;
1846 GString *dir;
1847
1848 n = 0;
1849 s1 = XmStringCreateLocalized("Open");
1850 XtSetArg(args[n], XmNokLabelString, s1); ++n;
1851 s2 = XmStringCreateLocalized("*.[Pp][Dd][Ff]");
1852 XtSetArg(args[n], XmNpattern, s2); ++n;
1853 s3 = XmStringCreateLocalized(xpdfAppName ": Open");
1854 XtSetArg(args[n], XmNdialogTitle, s3); ++n;
1855 XtSetArg(args[n], XmNdialogStyle, XmDIALOG_PRIMARY_APPLICATION_MODAL); ++n;
1856 XtSetArg(args[n], XmNautoUnmanage, True); ++n;
1857 openDialog = XmCreateFileSelectionDialog(win, "openDialog", args, n);
1858 XmStringFree(s1);
1859 XmStringFree(s2);
1860 XmStringFree(s3);
1861 XtUnmanageChild(XmFileSelectionBoxGetChild(openDialog,
1862 XmDIALOG_HELP_BUTTON));
1863 XtAddCallback(openDialog, XmNokCallback,
1864 &openOkCbk, (XtPointer)this);
1865
1866 if (core->getDoc() && core->getDoc()->getFileName()) {
1867 dir = makePathAbsolute(grabPath(
1868 core->getDoc()->getFileName()->getCString()));
1869 s1 = XmStringCreateLocalized(dir->getCString());
1870 XtVaSetValues(openDialog, XmNdirectory, s1, NULL);
1871 XmStringFree(s1);
1872 delete dir;
1873 }
1874 }
1875
1876 void XPDFViewer::mapOpenDialog(GBool openInNewWindowA) {
1877 if (!openDialog) {
1878 initOpenDialog();
1879 }
1880 openInNewWindow = openInNewWindowA;
1881 XmFileSelectionDoSearch(openDialog, NULL);
1882 XtManageChild(openDialog);
1883 }
1884
1885 void XPDFViewer::openOkCbk(Widget widget, XtPointer ptr,
1886 XtPointer callData) {
1887 XPDFViewer *viewer = (XPDFViewer *)ptr;
1888 XmFileSelectionBoxCallbackStruct *data =
1889 (XmFileSelectionBoxCallbackStruct *)callData;
1890 char *fileName;
1891 XmStringContext context;
1892 XmStringCharSet charSet;
1893 XmStringDirection dir;
1894 Boolean sep;
1895 GString *fileNameStr;
1896
1897 XmStringInitContext(&context, data->value);
1898 if (XmStringGetNextSegment(context, &fileName, &charSet, &dir, &sep)) {
1899 fileNameStr = new GString(fileName);
1900 if (viewer->openInNewWindow) {
1901 viewer->app->open(fileNameStr);
1902 } else {
1903 if (viewer->loadFile(fileNameStr)) {
1904 viewer->displayPage(1, viewer->core->getZoom(),
1905 viewer->core->getRotate(), gTrue, gTrue);
1906 }
1907 }
1908 delete fileNameStr;
1909 XtFree(charSet);
1910 XtFree(fileName);
1911 }
1912 XmStringFreeContext(context);
1913 }
1914
1915 //------------------------------------------------------------------------
1916 // GUI code: "find" dialog
1917 //------------------------------------------------------------------------
1918
1919 void XPDFViewer::initFindDialog() {
1920 Widget form1, label, okBtn, closeBtn;
1921 Arg args[20];
1922 int n;
1923 XmString s;
1924
1925 //----- dialog
1926 n = 0;
1927 s = XmStringCreateLocalized(xpdfAppName ": Find");
1928 XtSetArg(args[n], XmNdialogTitle, s); ++n;
1929 XtSetArg(args[n], XmNnavigationType, XmNONE); ++n;
1930 XtSetArg(args[n], XmNautoUnmanage, False); ++n;
1931 findDialog = XmCreateFormDialog(win, "findDialog", args, n);
1932 XmStringFree(s);
1933
1934 //----- "find" and "close" buttons
1935 n = 0;
1936 XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); ++n;
1937 XtSetArg(args[n], XmNleftOffset, 4); ++n;
1938 XtSetArg(args[n], XmNbottomAttachment, XmATTACH_FORM); ++n;
1939 XtSetArg(args[n], XmNbottomOffset, 4); ++n;
1940 XtSetArg(args[n], XmNnavigationType, XmEXCLUSIVE_TAB_GROUP); ++n;
1941 okBtn = XmCreatePushButton(findDialog, "Find", args, n);
1942 XtManageChild(okBtn);
1943 XtAddCallback(okBtn, XmNactivateCallback,
1944 &findFindCbk, (XtPointer)this);
1945 n = 0;
1946 XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); ++n;
1947 XtSetArg(args[n], XmNrightOffset, 4); ++n;
1948 XtSetArg(args[n], XmNbottomAttachment, XmATTACH_FORM); ++n;
1949 XtSetArg(args[n], XmNbottomOffset, 4); ++n;
1950 XtSetArg(args[n], XmNnavigationType, XmEXCLUSIVE_TAB_GROUP); ++n;
1951 closeBtn = XmCreatePushButton(findDialog, "Close", args, n);
1952 XtManageChild(closeBtn);
1953 XtAddCallback(closeBtn, XmNactivateCallback,
1954 &findCloseCbk, (XtPointer)this);
1955
1956 //----- checkboxes
1957 n = 0;
1958 XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); ++n;
1959 XtSetArg(args[n], XmNleftOffset, 4); ++n;
1960 XtSetArg(args[n], XmNbottomAttachment, XmATTACH_WIDGET); ++n;
1961 XtSetArg(args[n], XmNbottomWidget, okBtn); ++n;
1962 XtSetArg(args[n], XmNindicatorType, XmN_OF_MANY); ++n;
1963 #if XmVERSION <= 1
1964 XtSetArg(args[n], XmNindicatorOn, True); ++n;
1965 #else
1966 XtSetArg(args[n], XmNindicatorOn, XmINDICATOR_FILL); ++n;
1967 #endif
1968 XtSetArg(args[n], XmNset, XmUNSET); ++n;
1969 s = XmStringCreateLocalized("Search backward");
1970 XtSetArg(args[n], XmNlabelString, s); ++n;
1971 findBackwardToggle = XmCreateToggleButton(findDialog, "backward", args, n);
1972 XmStringFree(s);
1973 XtManageChild(findBackwardToggle);
1974 n = 0;
1975 XtSetArg(args[n], XmNleftAttachment, XmATTACH_WIDGET); ++n;
1976 XtSetArg(args[n], XmNleftWidget, findBackwardToggle); ++n;
1977 XtSetArg(args[n], XmNleftOffset, 16); ++n;
1978 XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); ++n;
1979 XtSetArg(args[n], XmNrightOffset, 4); ++n;
1980 XtSetArg(args[n], XmNbottomAttachment, XmATTACH_WIDGET); ++n;
1981 XtSetArg(args[n], XmNbottomWidget, okBtn); ++n;
1982 XtSetArg(args[n], XmNindicatorType, XmN_OF_MANY); ++n;
1983 #if XmVERSION <= 1
1984 XtSetArg(args[n], XmNindicatorOn, True); ++n;
1985 #else
1986 XtSetArg(args[n], XmNindicatorOn, XmINDICATOR_FILL); ++n;
1987 #endif
1988 XtSetArg(args[n], XmNset, XmUNSET); ++n;
1989 s = XmStringCreateLocalized("Match case");
1990 XtSetArg(args[n], XmNlabelString, s); ++n;
1991 findCaseSensitiveToggle =
1992 XmCreateToggleButton(findDialog, "matchCase", args, n);
1993 XmStringFree(s);
1994 XtManageChild(findCaseSensitiveToggle);
1995
1996 //----- search string entry
1997 n = 0;
1998 XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); ++n;
1999 XtSetArg(args[n], XmNtopOffset, 4); ++n;
2000 XtSetArg(args[n], XmNbottomAttachment, XmATTACH_WIDGET); ++n;
2001 XtSetArg(args[n], XmNbottomWidget, findBackwardToggle); ++n;
2002 XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); ++n;
2003 XtSetArg(args[n], XmNleftOffset, 2); ++n;
2004 XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); ++n;
2005 XtSetArg(args[n], XmNrightOffset, 2); ++n;
2006 form1 = XmCreateForm(findDialog, "form", args, n);
2007 XtManageChild(form1);
2008 n = 0;
2009 XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); ++n;
2010 XtSetArg(args[n], XmNbottomAttachment, XmATTACH_FORM); ++n;
2011 XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); ++n;
2012 s = XmStringCreateLocalized("Find text: ");
2013 XtSetArg(args[n], XmNlabelString, s); ++n;
2014 label = XmCreateLabel(form1, "label", args, n);
2015 XmStringFree(s);
2016 XtManageChild(label);
2017 n = 0;
2018 XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); ++n;
2019 XtSetArg(args[n], XmNbottomAttachment, XmATTACH_FORM); ++n;
2020 XtSetArg(args[n], XmNleftAttachment, XmATTACH_WIDGET); ++n;
2021 XtSetArg(args[n], XmNleftWidget, label); ++n;
2022 XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); ++n;
2023 findText = XmCreateTextField(form1, "text", args, n);
2024 XtManageChild(findText);
2025 #ifdef LESSTIF_VERSION
2026 XtAddCallback(findText, XmNactivateCallback,
2027 &findFindCbk, (XtPointer)this);
2028 #endif
2029
2030 //----- dialog parameters
2031 n = 0;
2032 XtSetArg(args[n], XmNdefaultButton, okBtn); ++n;
2033 XtSetArg(args[n], XmNcancelButton, closeBtn); ++n;
2034 #if XmVersion > 1001
2035 XtSetArg(args[n], XmNinitialFocus, findText); ++n;
2036 #endif
2037 XtSetValues(findDialog, args, n);
2038 }
2039
2040 void XPDFViewer::findFindCbk(Widget widget, XtPointer ptr,
2041 XtPointer callData) {
2042 XPDFViewer *viewer = (XPDFViewer *)ptr;
2043
2044 viewer->doFind(gFalse);
2045 }
2046
2047 void XPDFViewer::mapFindDialog() {
2048 XmTextFieldSetSelection(findText, 0, XmTextFieldGetLastPosition(findText),
2049 XtLastTimestampProcessed(display));
2050 XmTextFieldSetInsertionPosition(findText, 0);
2051 XtManageChild(findDialog);
2052 }
2053
2054 void XPDFViewer::doFind(GBool next) {
2055 if (XtWindow(findDialog)) {
2056 XDefineCursor(display, XtWindow(findDialog), core->getBusyCursor());
2057 }
2058 core->find(XmTextFieldGetString(findText),
2059 XmToggleButtonGetState(findCaseSensitiveToggle),
2060 next,
2061 XmToggleButtonGetState(findBackwardToggle),
2062 gFalse);
2063 if (XtWindow(findDialog)) {
2064 XUndefineCursor(display, XtWindow(findDialog));
2065 }
2066 }
2067
2068 void XPDFViewer::findCloseCbk(Widget widget, XtPointer ptr,
2069 XtPointer callData) {
2070 XPDFViewer *viewer = (XPDFViewer *)ptr;
2071
2072 XtUnmanageChild(viewer->findDialog);
2073 }
2074
2075 //------------------------------------------------------------------------
2076 // GUI code: "save as" dialog
2077 //------------------------------------------------------------------------
2078
2079 void XPDFViewer::initSaveAsDialog() {
2080 Arg args[20];
2081 int n;
2082 XmString s1, s2, s3;
2083 GString *dir;
2084
2085 n = 0;
2086 s1 = XmStringCreateLocalized("Save");
2087 XtSetArg(args[n], XmNokLabelString, s1); ++n;
2088 s2 = XmStringCreateLocalized("*.[Pp][Dd][Ff]");
2089 XtSetArg(args[n], XmNpattern, s2); ++n;
2090 s3 = XmStringCreateLocalized(xpdfAppName ": Save as");
2091 XtSetArg(args[n], XmNdialogTitle, s3); ++n;
2092 XtSetArg(args[n], XmNdialogStyle, XmDIALOG_PRIMARY_APPLICATION_MODAL); ++n;
2093 XtSetArg(args[n], XmNautoUnmanage, True); ++n;
2094 saveAsDialog = XmCreateFileSelectionDialog(win, "saveAsDialog", args, n);
2095 XmStringFree(s1);
2096 XmStringFree(s2);
2097 XmStringFree(s3);
2098 XtUnmanageChild(XmFileSelectionBoxGetChild(saveAsDialog,
2099 XmDIALOG_HELP_BUTTON));
2100 XtAddCallback(saveAsDialog, XmNokCallback,
2101 &saveAsOkCbk, (XtPointer)this);
2102
2103 if (core->getDoc() && core->getDoc()->getFileName()) {
2104 dir = makePathAbsolute(grabPath(
2105 core->getDoc()->getFileName()->getCString()));
2106 s1 = XmStringCreateLocalized(dir->getCString());
2107 XtVaSetValues(saveAsDialog, XmNdirectory, s1, NULL);
2108 XmStringFree(s1);
2109 delete dir;
2110 }
2111 }
2112
2113 void XPDFViewer::mapSaveAsDialog() {
2114 if (!saveAsDialog) {
2115 initSaveAsDialog();
2116 }
2117 XmFileSelectionDoSearch(saveAsDialog, NULL);
2118 XtManageChild(saveAsDialog);
2119 }
2120
2121 void XPDFViewer::saveAsOkCbk(Widget widget, XtPointer ptr,
2122 XtPointer callData) {
2123 XPDFViewer *viewer = (XPDFViewer *)ptr;
2124 XmFileSelectionBoxCallbackStruct *data =
2125 (XmFileSelectionBoxCallbackStruct *)callData;
2126 char *fileName;
2127 GString *fileNameStr;
2128 XmStringContext context;
2129 XmStringCharSet charSet;
2130 XmStringDirection dir;
2131 Boolean sep;
2132
2133 XmStringInitContext(&context, data->value);
2134 if (XmStringGetNextSegment(context, &fileName, &charSet, &dir, &sep)) {
2135 fileNameStr = new GString(fileName);
2136 viewer->core->getDoc()->saveAs(fileNameStr);
2137 delete fileNameStr;
2138 XtFree(charSet);
2139 XtFree(fileName);
2140 }
2141 XmStringFreeContext(context);
2142 }
2143
2144 //------------------------------------------------------------------------
2145 // GUI code: "print" dialog
2146 //------------------------------------------------------------------------
2147
2148 void XPDFViewer::initPrintDialog() {
2149 Widget sep1, sep2, row, label1, label2, okBtn, cancelBtn;
2150 Arg args[20];
2151 int n;
2152 XmString s;
2153 GString *psFileName;
2154
2155 //----- dialog
2156 n = 0;
2157 s = XmStringCreateLocalized(xpdfAppName ": Print");
2158 XtSetArg(args[n], XmNdialogTitle, s); ++n;
2159 XtSetArg(args[n], XmNdialogStyle, XmDIALOG_PRIMARY_APPLICATION_MODAL); ++n;
2160 printDialog = XmCreateFormDialog(win, "printDialog", args, n);
2161 XmStringFree(s);
2162
2163 //----- "print with command"
2164 n = 0;
2165 XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); ++n;
2166 XtSetArg(args[n], XmNtopOffset, 4); ++n;
2167 XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); ++n;
2168 XtSetArg(args[n], XmNindicatorType, XmONE_OF_MANY); ++n;
2169 XtSetArg(args[n], XmNset, XmSET); ++n;
2170 s = XmStringCreateLocalized("Print with command:");
2171 XtSetArg(args[n], XmNlabelString, s); ++n;
2172 printWithCmdBtn = XmCreateToggleButton(printDialog, "printWithCmd", args, n);
2173 XmStringFree(s);
2174 XtManageChild(printWithCmdBtn);
2175 XtAddCallback(printWithCmdBtn, XmNvalueChangedCallback,
2176 &printWithCmdBtnCbk, (XtPointer)this);
2177 n = 0;
2178 XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); ++n;
2179 XtSetArg(args[n], XmNtopWidget, printWithCmdBtn); ++n;
2180 XtSetArg(args[n], XmNtopOffset, 2); ++n;
2181 XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); ++n;
2182 XtSetArg(args[n], XmNleftOffset, 16); ++n;
2183 XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); ++n;
2184 XtSetArg(args[n], XmNrightOffset, 4); ++n;
2185 XtSetArg(args[n], XmNcolumns, 40); ++n;
2186 printCmdText = XmCreateTextField(printDialog, "printCmd", args, n);
2187 XtManageChild(printCmdText);
2188
2189 //----- "print to file"
2190 n = 0;
2191 XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); ++n;
2192 XtSetArg(args[n], XmNtopWidget, printCmdText); ++n;
2193 XtSetArg(args[n], XmNtopOffset, 4); ++n;
2194 XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); ++n;
2195 XtSetArg(args[n], XmNindicatorType, XmONE_OF_MANY); ++n;
2196 XtSetArg(args[n], XmNset, XmUNSET); ++n;
2197 s = XmStringCreateLocalized("Print to file:");
2198 XtSetArg(args[n], XmNlabelString, s); ++n;
2199 printToFileBtn = XmCreateToggleButton(printDialog, "printToFile", args, n);
2200 XmStringFree(s);
2201 XtManageChild(printToFileBtn);
2202 XtAddCallback(printToFileBtn, XmNvalueChangedCallback,
2203 &printToFileBtnCbk, (XtPointer)this);
2204 n = 0;
2205 XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); ++n;
2206 XtSetArg(args[n], XmNtopWidget, printToFileBtn); ++n;
2207 XtSetArg(args[n], XmNtopOffset, 2); ++n;
2208 XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); ++n;
2209 XtSetArg(args[n], XmNleftOffset, 16); ++n;
2210 XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); ++n;
2211 XtSetArg(args[n], XmNrightOffset, 4); ++n;
2212 XtSetArg(args[n], XmNcolumns, 40); ++n;
2213 XtSetArg(args[n], XmNsensitive, False); ++n;
2214 printFileText = XmCreateTextField(printDialog, "printFile", args, n);
2215 XtManageChild(printFileText);
2216
2217 //----- separator
2218 n = 0;
2219 XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); ++n;
2220 XtSetArg(args[n], XmNtopWidget, printFileText); ++n;
2221 XtSetArg(args[n], XmNtopOffset, 8); ++n;
2222 XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); ++n;
2223 XtSetArg(args[n], XmNleftOffset, 8); ++n;
2224 XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); ++n;
2225 XtSetArg(args[n], XmNrightOffset, 8); ++n;
2226 XtSetArg(args[n], XmNorientation, XmHORIZONTAL); ++n;
2227 sep1 = XmCreateSeparator(printDialog, "sep1", args, n);
2228 XtManageChild(sep1);
2229
2230 //----- page range
2231 n = 0;
2232 XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); ++n;
2233 XtSetArg(args[n], XmNtopWidget, sep1); ++n;
2234 XtSetArg(args[n], XmNtopOffset, 8); ++n;
2235 XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); ++n;
2236 XtSetArg(args[n], XmNleftOffset, 4); ++n;
2237 XtSetArg(args[n], XmNorientation, XmHORIZONTAL); ++n;
2238 XtSetArg(args[n], XmNpacking, XmPACK_TIGHT); ++n;
2239 row = XmCreateRowColumn(printDialog, "row", args, n);
2240 XtManageChild(row);
2241 n = 0;
2242 s = XmStringCreateLocalized("Pages:");
2243 XtSetArg(args[n], XmNlabelString, s); ++n;
2244 label1 = XmCreateLabel(row, "label1", args, n);
2245 XmStringFree(s);
2246 XtManageChild(label1);
2247 n = 0;
2248 XtSetArg(args[n], XmNcolumns, 5); ++n;
2249 printFirstPage = XmCreateTextField(row, "printFirstPage", args, n);
2250 XtManageChild(printFirstPage);
2251 n = 0;
2252 s = XmStringCreateLocalized("to");
2253 XtSetArg(args[n], XmNlabelString, s); ++n;
2254 label2 = XmCreateLabel(row, "label2", args, n);
2255 XmStringFree(s);
2256 XtManageChild(label2);
2257 n = 0;
2258 XtSetArg(args[n], XmNcolumns, 5); ++n;
2259 printLastPage = XmCreateTextField(row, "printLastPage", args, n);
2260 XtManageChild(printLastPage);
2261
2262 //----- separator
2263 n = 0;
2264 XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); ++n;
2265 XtSetArg(args[n], XmNtopWidget, row); ++n;
2266 XtSetArg(args[n], XmNtopOffset, 8); ++n;
2267 XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); ++n;
2268 XtSetArg(args[n], XmNleftOffset, 8); ++n;
2269 XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); ++n;
2270 XtSetArg(args[n], XmNrightOffset, 8); ++n;
2271 XtSetArg(args[n], XmNorientation, XmHORIZONTAL); ++n;
2272 sep2 = XmCreateSeparator(printDialog, "sep2", args, n);
2273 XtManageChild(sep2);
2274
2275 //----- "print" and "cancel" buttons
2276 n = 0;
2277 XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); ++n;
2278 XtSetArg(args[n], XmNtopWidget, sep2); ++n;
2279 XtSetArg(args[n], XmNtopOffset, 8); ++n;
2280 XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); ++n;
2281 XtSetArg(args[n], XmNleftOffset, 4); ++n;
2282 XtSetArg(args[n], XmNbottomAttachment, XmATTACH_FORM); ++n;
2283 XtSetArg(args[n], XmNbottomOffset, 4); ++n;
2284 okBtn = XmCreatePushButton(printDialog, "Print", args, n);
2285 XtManageChild(okBtn);
2286 XtAddCallback(okBtn, XmNactivateCallback,
2287 &printPrintCbk, (XtPointer)this);
2288 n = 0;
2289 XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); ++n;
2290 XtSetArg(args[n], XmNtopWidget, sep2); ++n;
2291 XtSetArg(args[n], XmNtopOffset, 8); ++n;
2292 XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); ++n;
2293 XtSetArg(args[n], XmNrightOffset, 4); ++n;
2294 XtSetArg(args[n], XmNbottomAttachment, XmATTACH_FORM); ++n;
2295 XtSetArg(args[n], XmNbottomOffset, 4); ++n;
2296 cancelBtn = XmCreatePushButton(printDialog, "Cancel", args, n);
2297 XtManageChild(cancelBtn);
2298 n = 0;
2299 XtSetArg(args[n], XmNdefaultButton, okBtn); ++n;
2300 XtSetArg(args[n], XmNcancelButton, cancelBtn); ++n;
2301 XtSetValues(printDialog, args, n);
2302
2303 //----- initial values
2304 if ((psFileName = globalParams->getPSFile())) {
2305 if (psFileName->getChar(0) == '|') {
2306 XmTextFieldSetString(printCmdText,
2307 psFileName->getCString() + 1);
2308 } else {
2309 XmTextFieldSetString(printFileText, psFileName->getCString());
2310 }
2311 delete psFileName;
2312 }
2313 }
2314
2315 void XPDFViewer::setupPrintDialog() {
2316 PDFDoc *doc;
2317 char buf[20];
2318 GString *pdfFileName, *psFileName, *psFileName2;
2319 char *p;
2320
2321 doc = core->getDoc();
2322 psFileName = globalParams->getPSFile();
2323 if (!psFileName || psFileName->getChar(0) == '|') {
2324 pdfFileName = doc->getFileName();
2325 p = pdfFileName->getCString() + pdfFileName->getLength() - 4;
2326 if (!strcmp(p, ".pdf") || !strcmp(p, ".PDF")) {
2327 psFileName2 = new GString(pdfFileName->getCString(),
2328 pdfFileName->getLength() - 4);
2329 } else {
2330 psFileName2 = pdfFileName->copy();
2331 }
2332 psFileName2->append(".ps");
2333 XmTextFieldSetString(printFileText, psFileName2->getCString());
2334 delete psFileName2;
2335 }
2336 if (psFileName && psFileName->getChar(0) == '|') {
2337 XmToggleButtonSetState(printWithCmdBtn, True, False);
2338 XmToggleButtonSetState(printToFileBtn, False, False);
2339 XtVaSetValues(printCmdText, XmNsensitive, True, NULL);
2340 XtVaSetValues(printFileText, XmNsensitive, False, NULL);
2341 } else {
2342 XmToggleButtonSetState(printWithCmdBtn, False, False);
2343 XmToggleButtonSetState(printToFileBtn, True, False);
2344 XtVaSetValues(printCmdText, XmNsensitive, False, NULL);
2345 XtVaSetValues(printFileText, XmNsensitive, True, NULL);
2346 }
2347 if (psFileName) {
2348 delete psFileName;
2349 }
2350
2351 sprintf(buf, "%d", doc->getNumPages());
2352 XmTextFieldSetString(printFirstPage, "1");
2353 XmTextFieldSetString(printLastPage, buf);
2354 }
2355
2356 void XPDFViewer::printWithCmdBtnCbk(Widget widget, XtPointer ptr,
2357 XtPointer callData) {
2358 XPDFViewer *viewer = (XPDFViewer *)ptr;
2359 XmToggleButtonCallbackStruct *data =
2360 (XmToggleButtonCallbackStruct *)callData;
2361
2362 if (data->set != XmSET) {
2363 XmToggleButtonSetState(viewer->printWithCmdBtn, True, False);
2364 }
2365 XmToggleButtonSetState(viewer->printToFileBtn, False, False);
2366 XtVaSetValues(viewer->printCmdText, XmNsensitive, True, NULL);
2367 XtVaSetValues(viewer->printFileText, XmNsensitive, False, NULL);
2368 }
2369
2370 void XPDFViewer::printToFileBtnCbk(Widget widget, XtPointer ptr,
2371 XtPointer callData) {
2372 XPDFViewer *viewer = (XPDFViewer *)ptr;
2373 XmToggleButtonCallbackStruct *data =
2374 (XmToggleButtonCallbackStruct *)callData;
2375
2376 if (data->set != XmSET) {
2377 XmToggleButtonSetState(viewer->printToFileBtn, True, False);
2378 }
2379 XmToggleButtonSetState(viewer->printWithCmdBtn, False, False);
2380 XtVaSetValues(viewer->printFileText, XmNsensitive, True, NULL);
2381 XtVaSetValues(viewer->printCmdText, XmNsensitive, False, NULL);
2382 }
2383
2384 void XPDFViewer::printPrintCbk(Widget widget, XtPointer ptr,
2385 XtPointer callData) {
2386 XPDFViewer *viewer = (XPDFViewer *)ptr;
2387 unsigned char withCmd;
2388 GString *psFileName;
2389 int firstPage, lastPage;
2390 PDFDoc *doc;
2391 PSOutputDev *psOut;
2392
2393 doc = viewer->core->getDoc();
2394 if (!doc->okToPrint()) {
2395 error(-1, "Printing this document is not allowed.");
2396 return;
2397 }
2398
2399 viewer->core->setBusyCursor(gTrue);
2400
2401 XtVaGetValues(viewer->printWithCmdBtn, XmNset, &withCmd, NULL);
2402 if (withCmd) {
2403 psFileName = new GString(XmTextFieldGetString(viewer->printCmdText));
2404 psFileName->insert(0, '|');
2405 } else {
2406 psFileName = new GString(XmTextFieldGetString(viewer->printFileText));
2407 }
2408
2409 firstPage = atoi(XmTextFieldGetString(viewer->printFirstPage));
2410 lastPage = atoi(XmTextFieldGetString(viewer->printLastPage));
2411 if (firstPage < 1) {
2412 firstPage = 1;
2413 } else if (firstPage > doc->getNumPages()) {
2414 firstPage = doc->getNumPages();
2415 }
2416 if (lastPage < firstPage) {
2417 lastPage = firstPage;
2418 } else if (lastPage > doc->getNumPages()) {
2419 lastPage = doc->getNumPages();
2420 }
2421
2422 psOut = new PSOutputDev(psFileName->getCString(), doc->getXRef(),
2423 doc->getCatalog(), firstPage, lastPage,
2424 psModePS);
2425 if (psOut->isOk()) {
2426 doc->displayPages(psOut, firstPage, lastPage, 72, 72,
2427 0, gTrue, globalParams->getPSCrop(), gFalse);
2428 }
2429 delete psOut;
2430 delete psFileName;
2431
2432 viewer->core->setBusyCursor(gFalse);
2433 }
2434
2435 //------------------------------------------------------------------------
2436 // Motif support
2437 //------------------------------------------------------------------------
2438
2439 XmFontList XPDFViewer::createFontList(char *xlfd) {
2440 XmFontList fontList;
2441
2442 #if XmVersion <= 1001
2443
2444 XFontStruct *font;
2445 String params;
2446 Cardinal nParams;
2447
2448 font = XLoadQueryFont(display, xlfd);
2449 if (font) {
2450 fontList = XmFontListCreate(font, XmSTRING_DEFAULT_CHARSET);
2451 } else {
2452 params = (String)xlfd;
2453 nParams = 1;
2454 XtAppWarningMsg(app->getAppContext(),
2455 "noSuchFont", "CvtStringToXmFontList",
2456 "XtToolkitError", "No such font: %s",
2457 &params, &nParams);
2458 fontList = NULL;
2459 }
2460
2461 #else
2462
2463 XmFontListEntry entry;
2464
2465 entry = XmFontListEntryLoad(display, xlfd,
2466 XmFONT_IS_FONT, XmFONTLIST_DEFAULT_TAG);
2467 fontList = XmFontListAppendEntry(NULL, entry);
2468 XmFontListEntryFree(&entry);
2469
2470 #endif
2471
2472 return fontList;
2473 }
Mirror of AROS' Contrib svn.