home *** CD-ROM | disk | FTP | other *** search
/ Frozen Fish 1: Amiga / FrozenFish-Apr94.iso / bbs / gnu / groff-1.09-src.lha / src / amiga / groff-1.09 / xditview / xditview.c < prev    next >
C/C++ Source or Header  |  1993-04-29  |  15KB  |  589 lines
  1. /*
  2.  * Copyright 1991 Massachusetts Institute of Technology
  3.  *
  4.  * Permission to use, copy, modify, distribute, and sell this software and its
  5.  * documentation for any purpose is hereby granted without fee, provided that
  6.  * the above copyright notice appear in all copies and that both that
  7.  * copyright notice and this permission notice appear in supporting
  8.  * documentation, and that the name of M.I.T. not be used in advertising or
  9.  * publicity pertaining to distribution of the software without specific,
  10.  * written prior permission.  M.I.T. makes no representations about the
  11.  * suitability of this software for any purpose.  It is provided "as is"
  12.  * without express or implied warranty.
  13.  *
  14.  * M.I.T. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL
  15.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL M.I.T.
  16.  * BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  17.  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
  18.  * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
  19.  * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  20.  *
  21.  */
  22. /*
  23.  * xditview -- 
  24.  *
  25.  *   Display ditroff output in an X window
  26.  */
  27.  
  28. #ifndef SABER
  29. #ifndef lint
  30. static char rcsid[] = "$XConsortium: xditview.c,v 1.17 89/12/10 17:05:08 rws Exp $";
  31. #endif /* lint */
  32. #endif /* SABER */
  33.  
  34. #include <X11/Xatom.h>
  35. #include <X11/Xlib.h>
  36. #include <X11/Xos.h>
  37. #include <X11/Intrinsic.h>
  38. #include <X11/StringDefs.h>
  39. #include <X11/Shell.h>
  40. #include <X11/Xaw/Paned.h>
  41. #include <X11/Xaw/Viewport.h>
  42. #include <X11/Xaw/Box.h>
  43. #include <X11/Xaw/Command.h>
  44. #include <X11/Xaw/Dialog.h>
  45. #include <X11/Xaw/Label.h>
  46. #include <X11/Xaw/SimpleMenu.h>
  47. #include <X11/Xaw/SmeBSB.h>
  48.  
  49. #include <signal.h>
  50.  
  51. #include "Dvi.h"
  52.  
  53. #include "xdit.bm"
  54. #include "xdit_mask.bm"
  55. #include "stdio.h"
  56.  
  57. extern FILE *popen();
  58. extern void exit();
  59.  
  60. static struct app_resources {
  61.     char *print_command;
  62.     char *filename;
  63. } app_resources;
  64.  
  65. #define offset(field) XtOffset(struct app_resources *, field)
  66.  
  67. /* Application resources. */
  68.  
  69. static XtResource resources[] = {
  70.   {"printCommand", "PrintCommand", XtRString, sizeof(char*),
  71.        offset(print_command), XtRString, NULL},
  72.   {"filename", "Filename", XtRString, sizeof(char*),
  73.        offset(filename), XtRString, NULL},
  74. };
  75.  
  76. #undef offset
  77.  
  78. /* Command line options table.  Only resources are entered here...there is a
  79.    pass over the remaining options after XtParseCommand is let loose. */
  80.  
  81. static XrmOptionDescRec options[] = {
  82. {"-page",        "*dvi.pageNumber",        XrmoptionSepArg,    NULL},
  83. {"-backingStore",   "*dvi.backingStore",    XrmoptionSepArg,    NULL},
  84. {"-resolution",        "*dvi.resolution",      XrmoptionSepArg,    NULL},
  85. {"-printCommand",   ".printCommand",        XrmoptionSepArg,    NULL},
  86. {"-filename",       ".filename",            XrmoptionSepArg,    NULL},
  87. {"-noPolyText",        "*dvi.noPolyText",        XrmoptionNoArg,    "TRUE"},
  88. };
  89.  
  90. static char current_print_command[1024];
  91.  
  92. static char    current_file_name[1024];
  93. static FILE    *current_file;
  94.  
  95. /*
  96.  * Report the syntax for calling xditview.
  97.  */
  98.  
  99. static
  100. Syntax(call)
  101.     char *call;
  102. {
  103.     (void) printf ("Usage: %s [-fg <color>] [-bg <color>]\n", call);
  104.     (void) printf ("       [-bd <color>] [-bw <pixels>] [-help]\n");
  105.     (void) printf ("       [-display displayname] [-geometry geom]\n");
  106.     (void) printf ("       [-page <page-number>] [-backing <backing-store>]\n");
  107.     (void) printf ("       [-resolution <res>] [-print <command>]\n");
  108.     (void) printf ("       [-filename <file>] [filename]\n\n");
  109.     exit(1);
  110. }
  111.  
  112. static void    NewFile (), SetPageNumber ();
  113. static Widget    toplevel, paned, viewport, dvi;
  114. static Widget    page;
  115. static Widget    simpleMenu;
  116.  
  117. static void    NextPage(), PreviousPage(), SelectPage(), OpenFile(), Quit();
  118. static void    Print();
  119.  
  120. static struct menuEntry {
  121.     char    *name;
  122.     void    (*function)();
  123. } menuEntries[] = {
  124.     "nextPage",        NextPage,
  125.     "previousPage", PreviousPage,
  126.     "selectPage",   SelectPage,
  127.     "print",        Print,
  128.     "openFile",        OpenFile,
  129.     "quit",        Quit,
  130. };
  131.  
  132. static void    NextPageAction(), PreviousPageAction(), SelectPageAction();
  133. static void    OpenFileAction(), QuitAction();
  134. static void    AcceptAction(), CancelAction();
  135. static void    PrintAction();
  136. static void    RerasterizeAction();
  137.  
  138. XtActionsRec xditview_actions[] = {
  139.     "NextPage",        NextPageAction,
  140.     "PreviousPage", PreviousPageAction,
  141.     "SelectPage",   SelectPageAction,
  142.     "Print",        PrintAction,
  143.     "OpenFile",        OpenFileAction,
  144.     "Rerasterize",  RerasterizeAction,
  145.     "Quit",        QuitAction,
  146.     "Accept",        AcceptAction,
  147.     "Cancel",        CancelAction,
  148. };
  149.  
  150. #define MenuNextPage        0
  151. #define MenuPreviousPage    1
  152. #define MenuSelectPage        2
  153. #define MenuPrint        3
  154. #define MenuOpenFile        4
  155. #define    MenuQuit        5
  156.  
  157. static char    pageLabel[256] = "Page <none>";
  158.  
  159. void main(argc, argv)
  160.     int argc;
  161.     char **argv;
  162. {
  163.     char        *file_name = 0;
  164.     int            i;
  165.     static Arg        labelArgs[] = {
  166.             {XtNlabel, (XtArgVal) pageLabel},
  167.     };
  168.     Arg            topLevelArgs[2];
  169.     Widget          entry;
  170.     Arg            pageNumberArgs[1];
  171.     int            page_number;
  172.  
  173.     toplevel = XtInitialize("main", "GXditview",
  174.                 options, XtNumber (options),
  175.                  &argc, argv);
  176.     if (argc > 2)
  177.     Syntax(argv[0]);
  178.  
  179.     XtGetApplicationResources(toplevel, (XtPointer)&app_resources,
  180.                   resources, XtNumber(resources),
  181.                   NULL, (Cardinal) 0);
  182.     if (app_resources.print_command)
  183.     strcpy(current_print_command, app_resources.print_command);
  184.  
  185.     XtAppAddActions(XtWidgetToApplicationContext(toplevel),
  186.             xditview_actions, XtNumber (xditview_actions));
  187.  
  188.     XtSetArg (topLevelArgs[0], XtNiconPixmap,
  189.           XCreateBitmapFromData (XtDisplay (toplevel),
  190.                      XtScreen(toplevel)->root,
  191.                      xdit_bits, xdit_width, xdit_height));
  192.                     
  193.     XtSetArg (topLevelArgs[1], XtNiconMask,
  194.           XCreateBitmapFromData (XtDisplay (toplevel),
  195.                      XtScreen(toplevel)->root,
  196.                      xdit_mask_bits, 
  197.                      xdit_mask_width, xdit_mask_height));
  198.     XtSetValues (toplevel, topLevelArgs, 2);
  199.     if (argc > 1)
  200.     file_name = argv[1];
  201.  
  202.     /*
  203.      * create the menu and insert the entries
  204.      */
  205.     simpleMenu = XtCreatePopupShell ("menu", simpleMenuWidgetClass, toplevel,
  206.                     NULL, 0);
  207.     for (i = 0; i < XtNumber (menuEntries); i++) {
  208.     entry = XtCreateManagedWidget(menuEntries[i].name, 
  209.                       smeBSBObjectClass, simpleMenu,
  210.                       NULL, (Cardinal) 0);
  211.     XtAddCallback(entry, XtNcallback, menuEntries[i].function, NULL);
  212.     }
  213.  
  214.     paned = XtCreateManagedWidget("paned", panedWidgetClass, toplevel,
  215.                     NULL, (Cardinal) 0);
  216.     viewport = XtCreateManagedWidget("viewport", viewportWidgetClass, paned,
  217.                      NULL, (Cardinal) 0);
  218.     dvi = XtCreateManagedWidget ("dvi", dviWidgetClass, viewport, NULL, 0);
  219.     page = XtCreateManagedWidget ("label", labelWidgetClass, paned,
  220.                     labelArgs, XtNumber (labelArgs));
  221.     XtSetArg (pageNumberArgs[0], XtNpageNumber, &page_number);
  222.     XtGetValues (dvi, pageNumberArgs, 1);
  223.     if (file_name)
  224.     NewFile (file_name);
  225.     /* NewFile modifies current_file_name, so do this here. */
  226.     if (app_resources.filename)
  227.     strcpy(current_file_name, app_resources.filename);
  228.     XtRealizeWidget (toplevel);
  229.     if (file_name)
  230.     SetPageNumber (page_number);
  231.     XtMainLoop();
  232. }
  233.  
  234. static void
  235. SetPageNumber (number)
  236. {
  237.     Arg    arg[2];
  238.     int    actual_number, last_page;
  239.  
  240.     XtSetArg (arg[0], XtNpageNumber, number);
  241.     XtSetValues (dvi, arg, 1);
  242.     XtSetArg (arg[0], XtNpageNumber, &actual_number);
  243.     XtSetArg (arg[1], XtNlastPageNumber, &last_page);
  244.     XtGetValues (dvi, arg, 2);
  245.     if (actual_number == 0)
  246.     sprintf (pageLabel, "Page <none>");
  247.     else if (last_page > 0)
  248.     sprintf (pageLabel, "Page %d of %d", actual_number, last_page);
  249.     else
  250.     sprintf (pageLabel, "Page %d", actual_number);
  251.     XtSetArg (arg[0], XtNlabel, pageLabel);
  252.     XtSetValues (page, arg, 1);
  253. }
  254.  
  255. static void
  256. SelectPageNumber (number_string)
  257. char    *number_string;
  258. {
  259.     SetPageNumber (atoi(number_string));
  260. }
  261.  
  262. static int hadFile = 0;
  263.  
  264. static void
  265. NewFile (name)
  266. char    *name;
  267. {
  268.     Arg        arg[2];
  269.     char    *n;
  270.     FILE    *new_file;
  271.     Boolean seek = 0;
  272.  
  273.     if (current_file) {
  274.     if (!strcmp (current_file_name, "-"))
  275.         ;
  276.     else if (current_file_name[0] == '|')
  277.         pclose (current_file);
  278.     else
  279.         fclose (current_file);
  280.     }
  281.     if (!strcmp (name, "-"))
  282.     new_file = stdin;
  283.     else if (name[0] == '|')
  284.     new_file = popen (name+1, "r");
  285.     else {
  286.     new_file = fopen (name, "r");
  287.     seek = 1;
  288.     }
  289.     if (!new_file) {
  290.     /* XXX display error message */
  291.     return;
  292.     }
  293.     XtSetArg (arg[0], XtNfile, new_file);
  294.     XtSetArg (arg[1], XtNseek, seek);
  295.     XtSetValues (dvi, arg, 2);
  296.     if (hadFile || name[0] != '-' || name[1] != '\0') {
  297.     XtSetArg (arg[0], XtNtitle, name);
  298.     if (name[0] != '/' && (n = strrchr (name, '/')))
  299.         n = n + 1;
  300.     else
  301.         n = name;
  302.     XtSetArg (arg[1], XtNiconName, n);
  303.     XtSetValues (toplevel, arg, 2);
  304.     }
  305.     hadFile = 1;
  306.     SelectPageNumber ("1");
  307.     strcpy (current_file_name, name);
  308.     current_file = new_file;
  309. }
  310.  
  311. static char fileBuf[1024];
  312.  
  313. ResetMenuEntry (entry)
  314.     Widget  entry;
  315. {
  316.     Arg    arg[1];
  317.  
  318.     XtSetArg (arg[0], XtNpopupOnEntry, entry);
  319.     XtSetValues (XtParent(entry) , arg, (Cardinal) 1);
  320. }
  321.  
  322. /*ARGSUSED*/
  323.  
  324. static void
  325. NextPage (entry, name, data)
  326.     Widget  entry;
  327.     caddr_t name, data;
  328. {
  329.     NextPageAction();
  330.     ResetMenuEntry (entry);
  331. }
  332.  
  333. static void
  334. NextPageAction ()
  335. {
  336.     Arg    args[1];
  337.     int    number;
  338.  
  339.     XtSetArg (args[0], XtNpageNumber, &number);
  340.     XtGetValues (dvi, args, 1);
  341.     SetPageNumber (number+1);
  342. }
  343.  
  344. /*ARGSUSED*/
  345.  
  346. static void
  347. PreviousPage (entry, name, data)
  348.     Widget  entry;
  349.     caddr_t name, data;
  350. {
  351.     PreviousPageAction ();
  352.     ResetMenuEntry (entry);
  353. }
  354.  
  355. static void
  356. PreviousPageAction ()
  357. {
  358.     Arg    args[1];
  359.     int    number;
  360.  
  361.     XtSetArg (args[0], XtNpageNumber, &number);
  362.     XtGetValues (dvi, args, 1);
  363.     SetPageNumber (number-1);
  364. }
  365.  
  366. /* ARGSUSED */
  367.  
  368. static void
  369. SelectPage (entry, name, data)
  370.     Widget  entry;
  371.     caddr_t name, data;
  372. {
  373.     SelectPageAction ();
  374.     ResetMenuEntry (entry);
  375. }
  376.  
  377. static void
  378. SelectPageAction ()
  379. {
  380.     MakePrompt (toplevel, "Page number", SelectPageNumber, "");
  381. }
  382.  
  383.  
  384. static void
  385. DoPrint (name)
  386.     char *name;
  387. {
  388.     FILE *print_file;
  389. #ifdef SIGNALRETURNSINT
  390.     int (*handler)();
  391. #else
  392.     void (*handler)();
  393. #endif
  394.     /* Avoid dieing because of an invalid command. */
  395.     handler = signal(SIGPIPE, SIG_IGN);
  396.  
  397.     print_file = popen(name, "w");
  398.     if (!print_file)
  399.     /* XXX print error message */
  400.     return;
  401.     DviSaveToFile(dvi, print_file);
  402.     pclose(print_file);
  403.     signal(SIGPIPE, handler);
  404.     strcpy(current_print_command, name);
  405. }
  406.  
  407. static void
  408. RerasterizeAction()
  409. {
  410.     Arg    args[1];
  411.     int    number;
  412.  
  413.     if (current_file_name[0] == 0) {
  414.     /* XXX display an error message */
  415.     return;
  416.     } 
  417.     XtSetArg (args[0], XtNpageNumber, &number);
  418.     XtGetValues (dvi, args, 1);
  419.     NewFile(current_file_name);
  420.     SetPageNumber (number);
  421. }
  422.  
  423. /* ARGSUSED */
  424.  
  425. static void
  426. Print (entry, name, data)
  427.     Widget  entry;
  428.     caddr_t name, data;
  429. {
  430.     PrintAction ();
  431.     ResetMenuEntry (entry);
  432. }
  433.  
  434. static void
  435. PrintAction ()
  436. {
  437.     if (current_print_command[0])
  438.     strcpy (fileBuf, current_print_command);
  439.     else
  440.     fileBuf[0] = '\0';
  441.     MakePrompt (toplevel, "Print command:", DoPrint, fileBuf);
  442. }
  443.  
  444.  
  445. /* ARGSUSED */
  446.  
  447. static void
  448. OpenFile (entry, name, data)
  449.     Widget  entry;
  450.     caddr_t name, data;
  451. {
  452.     OpenFileAction ();
  453.     ResetMenuEntry (entry);
  454. }
  455.  
  456. static void
  457. OpenFileAction ()
  458. {
  459.     if (current_file_name[0])
  460.     strcpy (fileBuf, current_file_name);
  461.     else
  462.     fileBuf[0] = '\0';
  463.     MakePrompt (toplevel, "File to open:", NewFile, fileBuf);
  464. }
  465.  
  466. /* ARGSUSED */
  467.  
  468. static void
  469. Quit (entry, closure, data)
  470.     Widget  entry;
  471.     caddr_t closure, data;
  472. {
  473.     QuitAction ();
  474. }
  475.  
  476. static void
  477. QuitAction ()
  478. {
  479.     exit (0);
  480. }
  481.  
  482. Widget    promptShell, promptDialog;
  483. void    (*promptfunction)();
  484.  
  485. /* ARGSUSED */
  486. static
  487. void CancelAction (widget, event, params, num_params)
  488.     Widget    widget;
  489.     XEvent    *event;
  490.     String    *params;
  491.     Cardinal    *num_params;
  492. {
  493.     if (promptShell) {
  494.     XtSetKeyboardFocus(toplevel, (Widget) None);
  495.     XtDestroyWidget(promptShell);
  496.     promptShell = (Widget) 0;
  497.     }
  498. }
  499.  
  500. static
  501. void AcceptAction (widget, event, params, num_params)
  502.     Widget    widget;
  503.     XEvent    *event;
  504.     String    *params;
  505.     Cardinal    *num_params;
  506. {
  507.     (*promptfunction)(XawDialogGetValueString(promptDialog));
  508.     CancelAction (widget, event, params, num_params);
  509. }
  510.  
  511. MakePrompt(centerw, prompt, func, def)
  512. Widget    centerw;
  513. char *prompt;
  514. void (*func)();
  515. char    *def;
  516. {
  517.     static Arg dialogArgs[] = {
  518.     {XtNlabel, NULL},
  519.     {XtNvalue, NULL},
  520.     };
  521.     Arg valueArgs[1];
  522.     Arg centerArgs[2];
  523.     Position    source_x, source_y;
  524.     Position    dest_x, dest_y;
  525.     Dimension center_width, center_height;
  526.     Dimension prompt_width, prompt_height;
  527.     Widget  valueWidget;
  528.     
  529.     CancelAction ((Widget)NULL, (XEvent *) 0, (String *) 0, (Cardinal *) 0);
  530.     promptShell = XtCreatePopupShell ("promptShell", transientShellWidgetClass,
  531.                       toplevel, NULL, (Cardinal) 0);
  532.     dialogArgs[0].value = (XtArgVal)prompt;
  533.     dialogArgs[1].value = (XtArgVal)def;
  534.     promptDialog = XtCreateManagedWidget( "promptDialog", dialogWidgetClass,
  535.             promptShell, dialogArgs, XtNumber (dialogArgs));
  536.     XawDialogAddButton(promptDialog, "accept", NULL, (caddr_t) 0);
  537.     XawDialogAddButton(promptDialog, "cancel", NULL, (caddr_t) 0);
  538.     valueWidget = XtNameToWidget (promptDialog, "value");
  539.     if (valueWidget) {
  540.         XtSetArg (valueArgs[0], XtNresizable, TRUE);
  541.         XtSetValues (valueWidget, valueArgs, 1);
  542.     /*
  543.      * as resizable isn't set until just above, the
  544.      * default value will be displayed incorrectly.
  545.      * rectify the situation by resetting the values
  546.      */
  547.         XtSetValues (promptDialog, dialogArgs, XtNumber (dialogArgs));
  548.     }
  549.     XtSetKeyboardFocus (promptDialog, valueWidget);
  550.     XtSetKeyboardFocus (toplevel, valueWidget);
  551.     XtRealizeWidget (promptShell);
  552.     /*
  553.      * place the widget in the center of the "parent"
  554.      */
  555.     XtSetArg (centerArgs[0], XtNwidth, ¢er_width);
  556.     XtSetArg (centerArgs[1], XtNheight, ¢er_height);
  557.     XtGetValues (centerw, centerArgs, 2);
  558.     XtSetArg (centerArgs[0], XtNwidth, &prompt_width);
  559.     XtSetArg (centerArgs[1], XtNheight, &prompt_height);
  560.     XtGetValues (promptShell, centerArgs, 2);
  561.     source_x = (center_width - prompt_width) / 2;
  562.     source_y = (center_height - prompt_height) / 3;
  563.     XtTranslateCoords (centerw, source_x, source_y, &dest_x, &dest_y);
  564.     XtSetArg (centerArgs[0], XtNx, dest_x);
  565.     XtSetArg (centerArgs[1], XtNy, dest_y);
  566.     XtSetValues (promptShell, centerArgs, 2);
  567.     XtMapWidget(promptShell);
  568.     promptfunction = func;
  569. }
  570.  
  571. /* For DviChar.c */
  572.  
  573. char *xmalloc(n)
  574.     int n;
  575. {
  576.     return XtMalloc(n);
  577. }
  578.  
  579. /*
  580. Local Variables:
  581. c-indent-level: 4
  582. c-continued-statement-offset: 4
  583. c-brace-offset: -4
  584. c-argdecl-indent: 4
  585. c-label-offset: -4
  586. c-tab-always-indent: nil
  587. End:
  588. */
  589.