home *** CD-ROM | disk | FTP | other *** search
/ The World of Computer Software / World_Of_Computer_Software-02-385-Vol-1of3.iso / s / stex2-18.zip / SeeTeX / Xtex / page.c < prev    next >
C/C++ Source or Header  |  1992-05-04  |  39KB  |  1,639 lines
  1. /*
  2.  * Copyright 1989 Dirk Grunwald
  3.  * 
  4.  * Permission to use, copy, modify, distribute, and sell this software
  5.  * and its documentation for any purpose is hereby granted without fee,
  6.  * provided that the above copyright notice appear in all copies and that
  7.  * both that copyright notice and this permission notice appear in
  8.  * supporting documentation, and that the name of Dirk Grunwald or M.I.T.
  9.  * not be used in advertising or publicity pertaining to distribution of
  10.  * the software without specific, written prior permission.  Dirk
  11.  * Grunwald and M.I.T. makes no representations about the suitability of
  12.  * this software for any purpose.  It is provided "as is" without express
  13.  * or implied warranty.
  14.  * 
  15.  * DIRK GRUNWALD AND M.I.T. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS
  16.  * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
  17.  * FITNESS, IN NO EVENT SHALL M.I.T.  BE LIABLE FOR ANY SPECIAL, INDIRECT
  18.  * OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
  19.  * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
  20.  * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE
  21.  * OR PERFORMANCE OF THIS SOFTWARE.
  22.  * 
  23.  * Author:
  24.  *     Dr. Dirk Grunwald
  25.  *     Dept. of Computer Science
  26.  *     Campus Box 430
  27.  *     Univ. of Colorado, Boulder
  28.  *     Boulder, CO 80309
  29.  * 
  30.  *     grunwald@colorado.edu
  31.  *     
  32.  */ 
  33.  
  34. /*
  35.  *
  36.  *    This looks kind of strange because, initially, I had intended to
  37.  *    allow you to `put away' a page without destroying it -- but
  38.  *    I've decided not to do that.
  39.  *
  40.  */
  41.  
  42. #include <stdio.h>
  43. #include <X11/IntrinsicP.h>
  44. #include <X11/Xatom.h>
  45. #include <X11/Object.h>
  46. #include <X11/ObjectP.h>
  47.  
  48. #include <assert.h>
  49.  
  50. #include "dvi-simple.h"
  51.  
  52. #include "xtex.h"
  53.  
  54. #include "DviPage.h"
  55. #include "page.h"
  56. #include "x11fonts.h"
  57. #include "widgets.h"
  58.  
  59. #include "Valuator.h"
  60. #include "EzMenu.h"
  61.  
  62.  
  63. extern Widget TopLevelWidget;
  64.  
  65. #ifdef __STDC__
  66. void TeXPageRealize(TeXPage *, int);
  67. static void showPage(TeXPage *, int);
  68. static void changeMag(TeXPage *, int );
  69. #else
  70. void TeXPageRealize();
  71. static void showPage();
  72. static void changeMag();
  73. #endif
  74.  
  75. int TeXPages;
  76. TeXPage *TheTeXPages[ MAX_TEX_PAGES ];
  77.  
  78. typedef struct {
  79.   char *thePage;
  80.   int refs;
  81. } DviPageRef;
  82.  
  83. DviPageRef *ThePageRefs = 0;
  84.  
  85. #define BUTTONS (xtexResources.useButtons)
  86.  
  87.  
  88. /*
  89.  * free all items in the page stack of a given TeXPage
  90.  */
  91.  
  92. void
  93. TeXPageStackFree(tp)
  94. TeXPage *tp;
  95. {
  96.   while ( tp -> pageStack ) {
  97.     TeXPageStack *p = tp -> pageStack;
  98.     tp -> pageStack = p -> next;
  99.     XtFree( (char *) p );
  100.   }
  101. }
  102.  
  103. void
  104.   TeXPageCloseFile()
  105. {
  106.   int popup;
  107.   
  108.   /* dispose of existing information */
  109.   
  110.   for ( popup = 0; popup < TeXPages; popup++ ) {
  111.     TeXPage *tp = TheTeXPages[popup];
  112.     if ( IS_VALID_PAGE(tp) ) {
  113.       TeXPageDeref( tp );
  114.       TeXFontUnref( tp -> userMag);
  115.       TeXPageStackFree( tp );
  116.       tp -> pageData = 0;
  117.     }
  118.   }
  119.   
  120.   if ( ThePageRefs ) {
  121.     int i;
  122.     for (i = 0; i < DviTotalPages; i++ ) {
  123.       XtFree( ThePageRefs[i].thePage );
  124.       ThePageRefs[ i ].thePage = 0;
  125.     }
  126.   }
  127.   
  128.   XtFree( (char *) ThePageRefs );
  129.   
  130.   ThePageRefs = 0;
  131. }
  132.  
  133. void
  134.   TeXPageSlamPages()
  135. {
  136.   int popup;
  137.   
  138.   /* take down pages, dispose of existing information */
  139.   
  140.   for ( popup = 0; popup < TeXPages; popup++ ) {
  141.     if ( IS_VALID_PAGE(TheTeXPages[popup]) ) {
  142.       XtDestroyWidget( TheTeXPages[ popup ] -> popUpPage ); 
  143.     }
  144.   }
  145. }
  146.  
  147. /*
  148.  *    find the logial page `want'. If we want the next logical page
  149.  *    with that number, set wantNext to True, else False (you can
  150.  *    have multiple logical pages with the same number).
  151.  */
  152. static void findLogicalPage(wantNext, tp, want)
  153.      Bool wantNext;
  154.      TeXPage *tp;
  155.      int want;
  156. {
  157.   int here = tp -> pageNumber;
  158.   int page = here;
  159.   
  160.   if ( here < 0 || here >= DviTotalPages ) {
  161.     here = 0;
  162.   }
  163.   
  164.   if (wantNext) {
  165.     page++;
  166.     if ( page >= DviTotalPages ) {
  167.       page = 0;
  168.     }
  169.   }
  170.   
  171.   for(;;) {
  172.     if ( DviCount[0][page] == want ) {
  173.       tp -> pageNumber = page;
  174.       tp -> logicalPageNumber = want;
  175.       return;
  176.     }
  177.     page++;
  178.     if ( page >= DviTotalPages ) {
  179.       page = 0;
  180.     }
  181.     if ( page == here ) 
  182.       break;
  183.   }
  184.   if ( here < 0 || here >= DviTotalPages ) {
  185.     here = 0;
  186.   }
  187.   tp -> pageNumber = here;
  188.   tp -> logicalPageNumber = DviCount[0][here];
  189. }
  190.  
  191. void
  192.   TeXPageOpenFile()
  193. {
  194.   /* now rebuild it all */
  195.   
  196.   if ( DviFile != 0 ) {
  197.     int i;
  198.     int popup;
  199.     
  200.     ThePageRefs =
  201.       (DviPageRef *)  XtMalloc( (DviTotalPages+1) * sizeof(DviPageRef) );
  202.     
  203.     for (i = 0; i < DviTotalPages; i++ ) {
  204.       ThePageRefs[i].thePage = 0;
  205.       ThePageRefs[i].refs = 0;
  206.     }
  207.     
  208.     /* Scan existing pages, orient new pages based on the count0 field
  209.        of the old page. This field is cached in logicalPageNumber */
  210.     
  211.     for ( popup = 0; popup < TeXPages; popup++ ) {
  212.       
  213.       TeXPage *tp = TheTeXPages[ popup ];
  214.       
  215.       if ( IS_VALID_PAGE(tp) ) {
  216.     int pno;
  217.     findLogicalPage(False, tp, tp -> logicalPageNumber);
  218.     pno = tp -> pageNumber;
  219.     
  220.     if (pno >= 0 && pno < DviTotalPages) {
  221.       Arg argList[20];
  222.       int args = 0;
  223.       
  224.       TeXPageRef(tp, tp -> pageNumber);
  225.       
  226.       XtSetArg(argList[args], XtNredisplay, True); args++;
  227.       XtSetArg(argList[args], XtNpai, &ThePostAmbleInfo); args++;
  228.       XtSetArg(argList[args], XtNpage, tp -> pageData); args++;
  229.       XtSetArg(argList[args], XtNdviFonts, TheFontInfo); args++;
  230.       XtSetArg(argList[args], XtNxFonts,
  231.            TeXFontRef(tp -> userMag)); args++;
  232.       
  233.       XtSetValues( tp -> singleDviPage, argList, args);
  234.       
  235.       showPage( tp, False );
  236.     }
  237.     else {
  238.       XtDestroyWidget( tp -> popUpPage ); 
  239.     }
  240.       }
  241.     }
  242.   }
  243. }
  244.  
  245. /*
  246.  *    Reference and dereference a page structure -- these keep track
  247.  *    of the memory allocated for page buffers & disposes of them
  248.  *    when not in use.
  249.  */
  250.  
  251. void
  252.   TeXPageRef(tp, pageno)
  253. TeXPage *tp;
  254. int pageno;
  255. {
  256.   assert( pageno >= 0 && pageno < DviTotalPages );
  257.   
  258.   ThePageRefs[ pageno ].refs++;
  259.   if ( ThePageRefs[ pageno ].thePage == 0 ) {
  260.     ThePageRefs[ pageno ].thePage = DviFetchPage( pageno );
  261.   }
  262.   
  263.   tp -> pageNumber = pageno;
  264.   tp -> logicalPageNumber = DviCount[0][ pageno ];
  265.   tp -> pageData = ThePageRefs[ pageno ].thePage;
  266. }
  267.  
  268. void
  269.   TeXPageDeref(tp)
  270. TeXPage *tp;
  271. {
  272.   int pageno = tp -> pageNumber;
  273.   
  274.   assert( pageno >= 0 && pageno < DviTotalPages );
  275.   if ( ThePageRefs && ThePageRefs[ pageno ].refs > 0) {
  276.     ThePageRefs[ pageno ].refs--;
  277.     if ( ThePageRefs[ pageno ].refs <= 0 ) {
  278.       XtFree( ThePageRefs[ pageno ].thePage );
  279.       ThePageRefs[ pageno ].thePage = 0;
  280.     }
  281.   }
  282. }
  283.  
  284.  
  285. /*
  286.  *    Locate page containing widget *w*
  287.  */
  288. #ifdef __STDC__
  289. TeXPage *
  290.   TeXPageLocate(Widget w)
  291. #else
  292. TeXPage *
  293.   TeXPageLocate(w) Widget w;
  294. #endif
  295. {
  296.   if ( w ) {
  297.     
  298. #define IS(x) (w == tp -> x)
  299.     int i;
  300.     Widget parent;
  301.     
  302.     for (i = 0; i < TeXPages; i++ ) {
  303.       TeXPage *tp = TheTeXPages[i];
  304.       if ( IS(singleDviPage)
  305.       || IS(popUpPage)
  306.       || IS(dviPageBox)
  307.       || IS( dviPageMenu )
  308.       || IS(viewPort)
  309.       || IS(buttonBox)
  310.       || IS(forewardButton)
  311.       || IS(backwardButton)
  312.       || IS(markButton)
  313.       || IS(dupButton)
  314.       || IS(dupButton)
  315.       || IS(tieButton)
  316.       || IS(largeButton)
  317.       || IS(smallButton)
  318.       || IS(quitButton)
  319.       || IS(pageNumberText)
  320.       || IS(gotoButton)
  321.       || IS(reopenButton) ) {
  322.     return( tp );
  323.       }
  324. #undef IS
  325.     }
  326.     
  327.     /* didn't find it -- attempt to find the parent and try again */
  328.     
  329.     parent = 0;
  330.     if ( XtIsWidget(w) )  {
  331.       parent = XtParent(w);
  332.     }
  333.     else if ( XtIsObject(w) ) {
  334.       Object o = (Object) w;
  335.       parent = o -> object.parent;
  336.     }
  337.     
  338.     if ( parent ) {
  339.       return( TeXPageLocate( parent ) );
  340.     }
  341.   }
  342.   
  343.   return( 0 );
  344. }
  345.  
  346. /*
  347.  *    Locate a free TeXPage structure. See comment at head.
  348.  */
  349. TeXPage *
  350.   TeXPageLocateFree()
  351. {
  352.   int i;
  353.   TeXPage *tp;
  354.   
  355.   for (i = 0; i < TeXPages; i++ ) {
  356.     if ( ! TheTeXPages[ i ] -> active ) {
  357.       return( TheTeXPages[ i ] );
  358.     }
  359.   }
  360.   
  361.   tp = (TeXPage *) XtMalloc(sizeof(TeXPage));
  362.   
  363.   bzero( tp, sizeof(TeXPage) );    /* happily, sets all to default */
  364.   
  365.   /* install the page in the page list */
  366.   
  367.   if ( TeXPages > MAX_TEX_PAGES ) {
  368.     error(0,0,"No more pages available");
  369.     return(0);
  370.   }
  371.   
  372.   TheTeXPages[ TeXPages++ ] = tp;
  373.   
  374.   return( tp );
  375. }
  376.  
  377. /*
  378.  *    The callback when pages die.
  379.  */
  380.  
  381. static void
  382.   dviPageDied(w, clientData,  callData)
  383. Widget w;
  384. caddr_t clientData;    /* unused */
  385. caddr_t callData; /* unused */
  386. {
  387.   TeXPage *tp = (TeXPage*) clientData;
  388.   
  389.   if ( tp != 0 ){
  390.     tp -> active = False;
  391.     tp -> realized = False;
  392.     TeXPageDeref( tp );
  393.     TeXFontUnref( tp -> userMag);
  394.     TeXPageStackFree( tp );
  395.     tp -> popUpPage = 0;
  396.     
  397.     if ( tp -> tiedTo != 0 && tp -> tiedTo -> active ) {
  398.       tp -> tiedTo -> tied = 0;
  399.     }
  400.     
  401.     if ( tp -> tied != 0 && tp -> tied -> active ) {
  402.       tp -> tied -> tiedTo = 0;
  403.     }
  404.     
  405.     tp -> tiedTo = 0;
  406.     tp -> tied = 0;
  407.     
  408.     tp -> inputNumberValid = False;
  409.     
  410.   }
  411. }
  412.  
  413. /* if accelerators haven't been installed yet, so so */
  414.  
  415. static void enableScrollBars(tp)
  416.      TeXPage *tp;
  417. {
  418.   if ( ! tp -> horizBar ) {
  419.     tp -> horizBar = XtNameToWidget(tp -> viewPort, "horizontal");
  420.     if ( tp -> horizBar && ! tp -> horizInit ) {
  421.       XtInstallAccelerators(tp -> singleDviPage, tp -> horizBar);
  422.       tp -> horizInit == TRUE;
  423.     }
  424.   }
  425.   
  426.   if ( ! tp -> vertBar ) {
  427.     tp -> vertBar = XtNameToWidget(tp -> viewPort, "vertical");
  428.     if ( tp -> vertBar && !tp -> vertInit ) {
  429.       XtInstallAccelerators(tp -> singleDviPage, tp -> vertBar);
  430.       tp -> vertInit == TRUE;
  431.     }
  432.   }
  433. }
  434.  
  435. /*
  436.  *    Set all the buttons for this page, possibly also
  437.  *    sending the page information
  438.  */
  439.  
  440. static   Arg sensArgs[] = {
  441.   {XtNsensitive, (XtArgVal) True}
  442. };
  443.  
  444. static   Arg insensArgs[] = {
  445.   {XtNsensitive, (XtArgVal) False}
  446. };
  447.  
  448. static void showPage(tp, displayPage)
  449.      TeXPage *tp;
  450.      Bool displayPage;
  451. {
  452.   Arg argList[20];
  453.   Cardinal args;
  454.   
  455.   Pixel fore;
  456.   Pixel back;
  457.   
  458.   if ( displayPage ) {
  459.     
  460. #if 0
  461.     args = 0;
  462.     XtSetArg(argList[args], XtNresizable, False); args++;
  463.     XtSetValues( tp -> viewPort, argList, args);
  464. #endif
  465.     
  466.     TeXPageRef(tp,  tp -> pageNumber );
  467.     args = 0;
  468.     XtSetArg(argList[args], XtNpage, tp -> pageData); args++;
  469.     XtSetArg(argList[args], XtNredisplay, True); args++;
  470.     XtSetValues(tp -> singleDviPage, argList, args);
  471.     
  472. #if 0
  473.     args = 0;
  474.     XtSetArg(argList[args], XtNresizable, True); args++;
  475.     XtSetValues( tp -> viewPort, argList, args);
  476. #endif
  477.     
  478.   }
  479.   
  480.   if ( xtexResources.updateNames ) {
  481.     char spbuffer[1024];
  482.     
  483.     /* physical pages are zero based internally, one based externally */
  484.     
  485.     sprintf(spbuffer,"%s (%s): Logical Page %d, Physical Page %d",
  486.         ProgName, DVIFileName,
  487.         DviCount[0][tp -> pageNumber],
  488.         tp -> pageNumber + 1);
  489.     
  490.     XChangeProperty(XtDisplay(tp -> popUpPage),
  491.             XtWindow(tp -> popUpPage),
  492.             XA_WM_NAME, XA_STRING, 8, PropModeReplace,
  493.             (unsigned char*) spbuffer, strlen(spbuffer));
  494.     
  495.     sprintf(spbuffer,"%s (%s, page %d)",
  496.         ProgName, DVIFileName, DviCount[0][tp -> pageNumber]);
  497.     
  498.     XChangeProperty(XtDisplay(tp -> popUpPage),
  499.             XtWindow(tp -> popUpPage),
  500.             XA_WM_ICON_NAME, XA_STRING, 8, PropModeReplace,
  501.             (unsigned char*) spbuffer, strlen(spbuffer));
  502.   }
  503.   
  504.   if ( BUTTONS ) {
  505.     if ( tp -> pageNumber == 0 ) {
  506.       XtSetValues( tp -> backwardButton, insensArgs, XtNumber(insensArgs));
  507.     }
  508.     else {
  509.       XtSetValues( tp -> backwardButton, sensArgs, XtNumber(sensArgs));
  510.     }
  511.     
  512.     if ( tp -> pageNumber >= (DviTotalPages-1)) {
  513.       XtSetValues( tp -> forewardButton, insensArgs, XtNumber(insensArgs));
  514.     }
  515.     else {
  516.       XtSetValues( tp -> forewardButton, sensArgs, XtNumber(sensArgs));
  517.     }
  518.     
  519.     /* Take normal values from another button */
  520.     
  521.     args = 0;
  522.     XtSetArg(argList[args], XtNforeground, &fore); args++;
  523.     XtSetArg(argList[args], XtNbackground, &back); args++;
  524.     XtGetValues( tp -> forewardButton, argList, args);
  525.     
  526.     if (TeXMarkState( tp -> pageNumber ) ) {
  527.       Arg argList[20];
  528.       Cardinal args;
  529.       
  530.       args = 0;
  531.       XtSetArg(argList[args], XtNforeground, back); args++;
  532.       XtSetArg(argList[args], XtNbackground, fore); args++;
  533.       
  534.       XtSetValues( tp -> markButton, argList, args );
  535.     }
  536.     else {
  537.       Arg argList[20];
  538.       Cardinal args;
  539.       
  540.       args = 0;
  541.       XtSetArg(argList[args], XtNforeground, fore); args++;
  542.       XtSetArg(argList[args], XtNbackground, back); args++;
  543.       
  544.       XtSetValues( tp -> markButton, argList, args );
  545.     }
  546.   }
  547.   
  548.   enableScrollBars(tp);
  549. }
  550.  
  551. static void changeMag( tp, mag )
  552.      TeXPage *tp;
  553.      int mag;
  554. {
  555.   Arg argList[20];
  556.   Cardinal args;
  557.   
  558.   XFontStruct **x;
  559.   Dimension maxHt;
  560.   Dimension maxWd;
  561.   Dimension dviHt;
  562.   Dimension dviWd;
  563.   Dimension dviBWd;
  564.   Dimension vpWd;
  565.   
  566.   maxWd = xtexResources.pageMaxWd;
  567.   maxHt = xtexResources.pageMaxHt;
  568.   if (maxWd < 1) {
  569.     maxWd = (int) ((WidthOfScreen(XtScreen(TopLevelWidget))) * 0.95);
  570.   }
  571.   if (maxHt < 1) {
  572.     maxHt = (int) ((HeightOfScreen(XtScreen(TopLevelWidget))) * 0.90);
  573.   }
  574.   
  575.   if ( ! xtexResources.autoSize ) {
  576.  
  577.     if ( tp -> userMag != mag ) {
  578.       /*
  579.        * Usually, you use the same fonts over and over. If you unref
  580.        * them first and then ref them, you'll unload them & then load
  581.        * them again. Major waste.
  582.        */
  583.       int oldMag = tp -> userMag;
  584.  
  585.       tp -> userMag = mag;
  586.       x = TeXFontRef(mag);
  587.       TeXFontUnref( oldMag );
  588.  
  589.       args = 0;
  590.       XtSetArg(argList[args], XtNuserMag, tp -> userMag); args++;
  591.       XtSetArg(argList[args], XtNxFonts, x); args++;
  592.       XtSetValues( tp -> singleDviPage, argList, args);
  593.     }
  594.     
  595.   } else {
  596.     
  597.     ViewportWidget vp = (ViewportWidget) (tp -> viewPort);
  598.     
  599.     if ( tp -> userMag != mag ) {
  600.       /*
  601.        * Usually, you use the same fonts over and over. If you unref
  602.        * them first and then ref them, you'll unload them & then load
  603.        * them again. Major waste.
  604.        */
  605.       int oldMag = tp -> userMag;
  606.  
  607.       tp -> userMag = mag;
  608.       x = TeXFontRef(mag);
  609.       TeXFontUnref( oldMag );
  610.       
  611.       XUnmapWindow( XtDisplay(tp -> viewPort), XtWindow(tp -> viewPort));
  612.       
  613.       args = 0;
  614.       XtSetArg(argList[args], XtNuserMag, tp -> userMag); args++;
  615.       XtSetArg(argList[args], XtNxFonts, x); args++;
  616.       XtSetValues( tp -> singleDviPage, argList, args);
  617.     } else {
  618.       XUnmapWindow( XtDisplay(tp -> viewPort), XtWindow(tp -> viewPort));
  619.     }
  620.     
  621.     if ( ! tp -> horizBar ) {
  622.       tp -> horizBar = XtNameToWidget((Widget) vp, "horizontal");
  623.       if ( tp -> horizBar ) {
  624.     XtInstallAccelerators(tp -> singleDviPage, tp -> horizBar);
  625.       }
  626.     }
  627.     
  628.     if ( ! tp -> vertBar ) {
  629.       tp -> vertBar = XtNameToWidget((Widget) vp, "vertical");
  630.       if (tp -> vertBar) {
  631.     XtInstallAccelerators(tp -> singleDviPage, tp -> vertBar);
  632.       }
  633.     }
  634.     
  635.     args = 0;
  636.     XtSetArg(argList[args], XtNwidth, &dviWd); args++;
  637.     XtSetArg(argList[args], XtNborderWidth, &dviBWd); args++;
  638.     XtSetArg(argList[args], XtNheight, &dviHt); args++;
  639.     XtGetValues( tp -> singleDviPage, argList, args);
  640.     
  641.     dviWd += (2 * dviBWd);
  642.     
  643.     if ( dviWd <= maxWd ){
  644.       maxWd = dviWd;
  645.       
  646.       /* will we need scrollbars? */
  647.       
  648.       if ( dviWd <= maxWd ){
  649.     Widget vb = tp -> vertBar;
  650.     maxWd = dviWd;
  651.     if ( vb && dviHt > maxHt ) {
  652.       maxWd = maxWd + vb -> core.width + vb -> core.border_width;
  653.     }
  654.       }
  655.       if ( dviHt <= maxHt ) {
  656.     Widget hb = tp -> horizBar;
  657.     maxHt = dviHt;
  658.     if ( hb && dviWd > maxWd ) {
  659.       maxHt = maxHt + hb -> core.width + hb -> core.border_width;
  660.     }
  661.       }
  662.     }
  663.     
  664.     args = 0;
  665.     XtSetArg(argList[args], XtNwidth, maxWd); args++;
  666.     XtSetArg(argList[args], XtNheight, maxHt); args++;
  667.     XtSetValues( tp -> viewPort, argList, args);
  668.     
  669.     if ( XtIsRealized( tp -> viewPort ) ) {
  670.       XMapWindow( XtDisplay(tp -> viewPort), XtWindow(tp -> viewPort));
  671.     }
  672.   }
  673. }
  674.  
  675. /**************** NUMBER FETCHING ****************/
  676. static int texxPageNumber(tp, def)
  677.      TeXPage *tp;
  678.      int def;
  679. {
  680.   int value;
  681.   if ( tp  && tp -> inputNumberValid ) {
  682.     
  683.     if ( tp -> inputNumberMinus ) {
  684.       value = -( tp -> inputNumber);
  685.     }
  686.     else {
  687.       value = ( tp -> inputNumber );
  688.     }
  689.   }
  690.   else {
  691.     value = def;
  692.   }
  693.   return(value);
  694. }
  695.  
  696. static void texxPageNumberReset(tp)
  697.      TeXPage *tp;
  698. {
  699.   if ( IS_VALID_PAGE(tp) ) {
  700.     tp -> inputNumberValid = False;
  701.     tp -> inputNumberMinus = False;
  702.     tp -> inputNumber = 0;
  703.   }
  704. }
  705.  
  706. /*
  707.  *    Realize the TeXPage structure and pop up the corresponding window
  708.  */
  709. void TeXPageRealize(tp, pageNumber)
  710.      TeXPage *tp;
  711.      int pageNumber;
  712. {
  713.   Arg argList[40];
  714.   int args;
  715.   
  716.   Dimension maxHt;
  717.   Dimension maxWd;
  718.   Dimension dviHt;
  719.   Dimension dviWd;
  720.   extern pushReopenButton();    /* from file */
  721.   Widget scrollBar;
  722.   
  723.   bzero(tp, sizeof(TeXPage));
  724.   
  725.   maxWd = xtexResources.pageMaxWd;
  726.   maxHt = xtexResources.pageMaxHt;
  727.   if (maxWd < 1) {
  728.     maxWd = (int) ((WidthOfScreen(XtScreen(TopLevelWidget))) * 0.95);
  729.   }
  730.   if (maxHt < 1) {
  731.     maxHt = (int) ((HeightOfScreen(XtScreen(TopLevelWidget))) * 0.90);
  732.   }
  733.   
  734.   if ( tp == NULL ) {
  735.     return;
  736.   }
  737.   
  738.   assert(TopLevelWidget != 0);
  739.   
  740.   args = 0;
  741.   tp -> popUpPage = 
  742.     XtCreatePopupShell("xtex-page",
  743.                applicationShellWidgetClass, TopLevelWidget,
  744.                argList,args);
  745.   
  746.   args = 0;
  747.   tp -> dviPageBox =
  748.     XtCreateManagedWidget("form",
  749.               formWidgetClass, tp -> popUpPage,
  750.               argList, args);
  751.   
  752.   if ( BUTTONS ) {
  753.     args = 0;
  754.     XtSetArg(argList[args], XtNleft, XtChainLeft); args++;
  755.     tp -> quitButton =
  756.       XtCreateManagedWidget("quitButton",
  757.                 commandWidgetClass, tp -> dviPageBox,
  758.                 argList, args);
  759.     
  760.     args = 0;
  761.     XtSetArg(argList[args], XtNfromHoriz, tp -> quitButton); args++;
  762.     tp -> forewardButton =
  763.       XtCreateManagedWidget("forwardButton",
  764.                 commandWidgetClass, tp -> dviPageBox,
  765.                 argList, args);
  766.     args = 0;
  767.     XtSetArg(argList[args], XtNfromHoriz, tp -> forewardButton); args++;
  768.     tp -> backwardButton =
  769.       XtCreateManagedWidget("backwardButton",
  770.                 commandWidgetClass, tp -> dviPageBox,
  771.                 argList, args);
  772.     args = 0;
  773.     XtSetArg(argList[args], XtNfromHoriz, tp -> backwardButton); args++;
  774.     tp -> markButton =
  775.       XtCreateManagedWidget("markButton",
  776.                 commandWidgetClass, tp -> dviPageBox,
  777.                 argList, args);
  778.     
  779.     args = 0;
  780.     XtSetArg(argList[args], XtNfromHoriz, tp -> markButton); args++;
  781.     tp -> dupButton =
  782.       XtCreateManagedWidget("dupButton",
  783.                 commandWidgetClass, tp -> dviPageBox,
  784.                 argList, args);
  785.     
  786.     args = 0;
  787.     XtSetArg(argList[args], XtNfromHoriz, tp -> dupButton); args++;
  788.     tp -> tieButton =
  789.       XtCreateManagedWidget("tieButton",
  790.                 commandWidgetClass, tp -> dviPageBox,
  791.                 argList, args);
  792.     
  793.     args = 0;
  794.     XtSetArg(argList[args], XtNfromHoriz, tp -> tieButton); args++;
  795.     tp -> largeButton =
  796.       XtCreateManagedWidget("largeButton",
  797.                 commandWidgetClass, tp -> dviPageBox,
  798.                 argList, args);
  799.     
  800.     args = 0;
  801.     XtSetArg(argList[args], XtNfromHoriz, tp -> largeButton); args++;
  802.     tp -> smallButton =
  803.       XtCreateManagedWidget("smallButton",
  804.                 commandWidgetClass, tp -> dviPageBox,
  805.                 argList, args);
  806.     args = 0;
  807.     XtSetArg(argList[args], XtNfromHoriz, tp -> smallButton); args++;
  808.     tp -> reopenButton = 
  809.       XtCreateManagedWidget("reopenButton",
  810.                 commandWidgetClass, tp -> dviPageBox,
  811.                 argList, args);
  812.     args = 0;
  813.     XtSetArg(argList[args], XtNfromHoriz, tp -> reopenButton); args++;
  814.     XtSetArg(argList[args], XtNeditType, XawtextEdit); args++;
  815.     XtSetArg(argList[args], XtNstring, tp -> pageNumberBuffer); args++;
  816.     XtSetArg(argList[args], XtNlength, MAXPAGENUMBERBUFFER); args++;
  817.     tp -> pageNumberText =
  818.       XtCreateManagedWidget("numberText",
  819.                 asciiTextWidgetClass, tp -> dviPageBox,
  820.                 argList, args);
  821.     
  822.     args = 0;
  823.     XtSetArg(argList[args], XtNfromHoriz, tp -> pageNumberText); args++;
  824.     tp -> gotoButton = 
  825.       XtCreateManagedWidget("gotoButton",
  826.                 commandWidgetClass, tp -> dviPageBox,
  827.                 argList, args);
  828.   }
  829.   
  830.   args = 0;
  831.   if (BUTTONS) {
  832.     XtSetArg(argList[args], XtNfromVert, tp -> pageNumberText); args++;
  833.   }
  834.   tp -> viewPort = 
  835.     XtCreateWidget("viewPort",
  836.            viewportWidgetClass, tp -> dviPageBox,
  837.            argList, args);
  838.   
  839.   bzero(tp -> pageNumberBuffer, MAXPAGENUMBERBUFFER);
  840.   tp -> realized = True;
  841.   TeXPageRef(tp, pageNumber);
  842.   tp -> userMag = xtexResources.userMag;
  843.   tp -> active = True;
  844.   
  845.   args = 0;
  846.   XtSetArg(argList[args], XtNpai, &ThePostAmbleInfo); args++;
  847.   
  848.   XtSetArg(argList[args], XtNdviFonts, TheFontInfo); args++;
  849.   
  850.   {
  851.     IntFloatUnion x;
  852.  
  853.     x.f = xtexResources.dpiHoriz;
  854.     XtSetArg(argList[args], XtNdpiHoriz, x.i); args++;
  855.  
  856.     x.f = xtexResources.dpiVert;
  857.     XtSetArg(argList[args], XtNdpiVert, x.i); args++;
  858.  
  859.     x.f = xtexResources.paperWidth;
  860.     XtSetArg(argList[args], XtNpaperWidth, x.i); args++;
  861.  
  862.     x.f = xtexResources.paperHeight;
  863.     XtSetArg(argList[args], XtNpaperHeight, x.i); args++;
  864.  
  865.     x.f = xtexResources.topOffset;
  866.     XtSetArg(argList[args], XtNtopOffset, x.i); args++;
  867.  
  868.     x.f = xtexResources.leftOffset;
  869.     XtSetArg(argList[args], XtNleftOffset, x.i); args++;
  870.   }
  871.   
  872.   XtSetArg(argList[args], XtNpage, tp -> pageData); args++;
  873.   XtSetArg(argList[args], XtNuserMag, tp -> userMag); args++;
  874.   XtSetArg(argList[args], XtNxFonts, TeXFontRef(tp -> userMag)); args++;
  875.   
  876.   tp -> singleDviPage = 
  877.     XtCreateWidget("dviPage",
  878.            dviPageWidgetClass, tp -> viewPort,
  879.            argList, args);
  880.   
  881.   XtAddCallback( tp -> singleDviPage, XtNdestroyCallback, dviPageDied, tp);
  882.   
  883.   tp -> dviPageMenu = XtCreatePopupShell("menu",
  884.                      ezMenuWidgetClass,
  885.                      tp -> singleDviPage,
  886.                      NULL, 0);
  887.   
  888.   /* get the size of the dvi page. This is an attempt to provide
  889.      a nice default window size */
  890.   
  891.   /* sadly, this appears to be impossible to keep unless we redisplay
  892.      several times each time, so lets just blow it off */
  893.   
  894. #if 0
  895.   args = 0;
  896.   XtSetArg(argList[args], XtNwidth, &dviWd); args++;
  897.   XtSetArg(argList[args], XtNheight, &dviHt); args++;
  898.   XtGetValues( tp -> singleDviPage, argList, args);
  899.   
  900.   scrollBar = XtNameToWidget( tp -> viewPort, "vertical");
  901.   if ( ! scrollBar ) {
  902.     scrollBar = XtNameToWidget( tp -> viewPort, "horizontial");
  903.   }
  904.   
  905.   if ( scrollBar ) {
  906.     Dimension sWd;
  907.     Dimension sHt;
  908.     
  909.     args = 0;
  910.     XtSetArg(argList[args], XtNwidth, &sWd); args++;
  911.     XtSetArg(argList[args], XtNheight, &sHt); args++;
  912.     XtGetValues( scrollBar, argList, args);
  913.     
  914.     dviWd += sWd;
  915.     dviHt += sHt;
  916.   }
  917.   
  918.   if ( dviWd <= maxWd ){
  919.     maxWd = dviWd;
  920.   }
  921.   if ( dviHt <= maxHt ) {
  922.     maxHt = dviHt;
  923.   }
  924.   args = 0;
  925.   XtSetArg(argList[args], XtNwidth, maxWd); args++;
  926.   XtSetArg(argList[args], XtNheight, maxHt); args++;
  927.   XtSetValues( tp -> viewPort, argList, args);
  928. #endif
  929.   
  930.   /* Now manage the viewport & single page */
  931.   XtManageChild( tp -> singleDviPage );
  932.   XtManageChild( tp -> viewPort );
  933.   
  934.   XtRealizeWidget(tp -> popUpPage);
  935.   
  936.   /* some bug somewhere makes the first page not appear unless I reset page */
  937.   args = 0;
  938.   XtSetArg(argList[args], XtNpage, tp -> pageData); args++;
  939.   XtSetValues(tp -> singleDviPage, argList, args);
  940.   
  941.   showPage( tp, False );    /* set remaining buttons */
  942.   
  943.   changeMag( tp, tp -> userMag );
  944.   
  945.   XtPopup( tp -> popUpPage, XtGrabNone);
  946.   
  947.   enableScrollBars(tp);
  948.   
  949. }
  950.  
  951. void TeXPageBuild()
  952. {
  953.   int i;
  954.   
  955.   TeXPage *tp = TeXPageLocateFree();
  956.   
  957.   if ( ! tp -> realized  ) {
  958.     TeXPageRealize(tp, 0);
  959.   }
  960. }
  961.  
  962. /*************** ACTIONS ***************/
  963.  
  964. static int getActionPageNumber(tp, params, num_params)
  965.      TeXPage *tp;
  966.      String *params;
  967.      Cardinal *num_params;
  968. {
  969.   int want;
  970.  
  971.   if ( *num_params == 1 ) {
  972.     if ( tp && strcmp(params[0], "box") == 0) {
  973.       
  974.       if ( ! tp -> pageNumberText ) {
  975.  
  976.     /* do nothing if box doesn't exist... */
  977.  
  978.     want = tp -> logicalPageNumber;
  979.       }
  980.       else {
  981.     Arg argList[2];
  982.     int args = 0;
  983.     char *currentString;
  984.     
  985.     XtSetArg(argList[args], XtNstring, ¤tString); args++;
  986.     XtGetValues(tp -> pageNumberText, argList, args);
  987.     
  988.     want = atoi( currentString );
  989.       }
  990.     }
  991.     else {
  992.       want = atoi( params[0] );
  993.     }
  994.   }
  995.   else {
  996.     int bogus = -99999;
  997.     want = texxPageNumber(tp,bogus);
  998.   }
  999.  
  1000.   return( want );
  1001.  
  1002. }
  1003.  
  1004. static void actionRealize(w, event, params, num_params)
  1005.      Widget w;
  1006.      XEvent *event;
  1007.      String *params;
  1008.      Cardinal *num_params;
  1009. {
  1010.   TeXPage *tp = TeXPageLocate(w);
  1011.   int want = getActionPageNumber( tp, params, num_params ); 
  1012.   TeXPage *newtp = TeXPageLocateFree();
  1013.  
  1014.   if ( ! newtp -> realized  ) {
  1015.     TeXPageRealize(newtp, want);
  1016.   }
  1017. } 
  1018.  
  1019. static void actionQuit(w, event, params, num_params)
  1020.      Widget w;
  1021.      XEvent *event;
  1022.      String *params;
  1023.      Cardinal *num_params;
  1024. {
  1025.   TeXPage *tp = TeXPageLocate(w);
  1026.   if ( IS_VALID_PAGE(tp) ) {
  1027.     XtDestroyWidget( tp -> popUpPage);
  1028.   }
  1029. } 
  1030.  
  1031. static void actionEcho(w, event, params, num_params)
  1032.      Widget w;
  1033.      XEvent *event;
  1034.      String *params;
  1035.      Cardinal *num_params;
  1036. {
  1037.   int totalLen;
  1038.   int i;
  1039.   char *echoCommand;
  1040.   
  1041.   totalLen = 0;
  1042.   for ( i = 1; i < *num_params; i++ ) {
  1043.     
  1044.     /* some error in the toolkit returns num_params==10 when I only have 2 */
  1045.     
  1046.     if ( params[i] ) {
  1047.       totalLen += strlen( params[i] );
  1048.     }
  1049.     else {
  1050.       break;
  1051.     }
  1052.   }
  1053.   
  1054.   totalLen += (*num_params = 10);
  1055.   
  1056.   echoCommand = (char *) XtMalloc( sizeof(char) * totalLen + 1);
  1057.   bzero(echoCommand, totalLen+1);
  1058.   
  1059.   for ( i = 0; i < *num_params; i++ ) {
  1060.     if ( params[i] ) {
  1061.       strncat(echoCommand, params[i], totalLen);
  1062.       strncat(echoCommand, " ", totalLen);
  1063.     }
  1064.     else {
  1065.       break;
  1066.     }
  1067.   }
  1068.   error(0,0, echoCommand );
  1069.   
  1070.   free( echoCommand );
  1071. } 
  1072.  
  1073. static void actionForeward(w, event, params, num_params)
  1074.      Widget w;
  1075.      XEvent *event;
  1076.      String *params;
  1077.      Cardinal *num_params;
  1078. {
  1079.   TeXPage *tp = TeXPageLocate(w);
  1080.   if ( IS_VALID_PAGE(tp) ) {
  1081.     char *p;
  1082.     int increment = texxPageNumber(tp, 1);
  1083.     int nextPageNumber = tp -> pageNumber + increment;
  1084.  
  1085.     /* wants to go to a non-valid page? */
  1086.     
  1087.     if (tp -> pageNumber >= DviTotalPages || nextPageNumber >= DviTotalPages) {
  1088.       nextPageNumber = DviTotalPages-1;
  1089.     }
  1090.     else  if (nextPageNumber < 0) {
  1091.       nextPageNumber = 0;
  1092.     }
  1093.     
  1094.     if (tp -> pageData && nextPageNumber != tp -> pageNumber ) {
  1095.       if ( tp -> pageData )
  1096.     TeXPageDeref( tp );
  1097.  
  1098.       tp -> pageNumber = nextPageNumber;
  1099.       showPage(tp, True);
  1100.       
  1101.       if ( tp -> tied )
  1102.     actionForeward(tp -> tied -> popUpPage, 0, 0, 0);
  1103.     }
  1104.   }
  1105. } 
  1106.  
  1107. static void actionBackward(w, event, params, num_params)
  1108.      Widget w;
  1109.      XEvent *event;
  1110.      String *params;
  1111.      Cardinal *num_params;
  1112. {
  1113.   TeXPage *tp = TeXPageLocate(w);
  1114.   if ( IS_VALID_PAGE(tp) ) {
  1115.     char *p;
  1116.     int increment = texxPageNumber(tp, 1);
  1117.     int nextPageNumber = tp -> pageNumber - increment;
  1118.     
  1119.     if ( tp -> tied ) {
  1120.       actionBackward( tp -> tied -> popUpPage, 0, 0, 0);
  1121.     }
  1122.     
  1123.     if ( tp -> pageNumber < 0 || nextPageNumber < 0 ) {
  1124.       nextPageNumber = 0;
  1125.     }
  1126.     else if (nextPageNumber >= DviTotalPages) {
  1127.       nextPageNumber = DviTotalPages - 1 ;
  1128.     }
  1129.     
  1130.     if ( tp -> pageData && nextPageNumber != tp -> pageNumber )  {
  1131.       TeXPageDeref( tp );
  1132.  
  1133.       tp -> pageNumber = nextPageNumber;
  1134.       showPage(tp, True);
  1135.     }
  1136.   }
  1137. } 
  1138.  
  1139. static void actionDup(w, event, params, num_params)
  1140.      Widget w;
  1141.      XEvent *event;
  1142.      String *params;
  1143.      Cardinal *num_params;
  1144. {
  1145.   TeXPage *tp = TeXPageLocate(w);
  1146.   if ( IS_VALID_PAGE(tp) ) {
  1147.     TeXPage *newtp = TeXPageLocateFree();
  1148.     TeXPageRealize(newtp, tp -> pageNumber);
  1149.   }
  1150. } 
  1151.  
  1152. static void actionTie(w, event, params, num_params)
  1153.      Widget w;
  1154.      XEvent *event;
  1155.      String *params;
  1156.      Cardinal *num_params;
  1157. {
  1158.   TeXPage *tp = TeXPageLocate(w);
  1159.   if ( tp && tp -> tied == 0 ) {
  1160.     TeXPage *newtp = TeXPageLocateFree();
  1161.     tp -> tied = newtp;
  1162.     newtp -> tiedTo = tp;
  1163.     TeXPageRealize(newtp, tp -> pageNumber);
  1164.   }
  1165. } 
  1166.  
  1167. /*
  1168.  *    The goto button. This scans, starting at the current page number,
  1169.  *    until a value of ``DviCount[0]'' meets the goto destination.
  1170.  *    This allows us to hit the multiple ``page 1'' refs.
  1171.  *
  1172.  *    recall that we're going to the LOGICAL page specified. Thus, we
  1173.  *    must map the LOGICAL page number to a PHYSICAL page.
  1174.  *
  1175.  */
  1176. #define GOTO_KIND 0
  1177. #define PUSH_KIND 1
  1178.  
  1179. static void commonGoto(kind, w, event, params, num_params)
  1180.      int kind;
  1181.      Widget w;
  1182.      XEvent *event;
  1183.      String *params;
  1184.      Cardinal *num_params;
  1185. {
  1186.   TeXPage *tp = TeXPageLocate(w);
  1187.   if ( IS_VALID_PAGE(tp) ) {
  1188.     int was = tp -> pageNumber;
  1189.     int want = getActionPageNumber( tp, params, num_params );
  1190.  
  1191.     findLogicalPage(True, tp, want);
  1192.  
  1193.     if ( tp -> pageNumber != was ) {
  1194.  
  1195.       if ( kind == PUSH_KIND ) {
  1196.     TeXPageStack *item = (TeXPageStack *) XtMalloc( sizeof(TeXPageStack) );
  1197.     item -> physicalPageNumber = was;
  1198.     item -> next = tp -> pageStack;
  1199.     tp -> pageStack = item;
  1200.       }
  1201.  
  1202.       TeXPageDeref( tp );
  1203.       TeXPageRef(tp, tp -> pageNumber);
  1204.       showPage(tp, True);
  1205.     }
  1206.   }
  1207. }
  1208.  
  1209. static void actionGoto(w, event, params, num_params)
  1210.      Widget w;
  1211.      XEvent *event;
  1212.      String *params;
  1213.      Cardinal *num_params;
  1214. {
  1215.   commonGoto(GOTO_KIND, w, event, params, num_params);
  1216. }
  1217.  
  1218. static void actionPush(w, event, params, num_params)
  1219.      Widget w;
  1220.      XEvent *event;
  1221.      String *params;
  1222.      Cardinal *num_params;
  1223. {
  1224.   commonGoto(PUSH_KIND, w, event, params, num_params);
  1225. }
  1226.  
  1227. static void actionPop(w, event, params, num_params)
  1228.      Widget w;
  1229.      XEvent *event;
  1230.      String *params;
  1231.      Cardinal *num_params;
  1232. {
  1233.   TeXPage *tp = TeXPageLocate(w);
  1234.   if ( IS_VALID_PAGE(tp) ) {
  1235.     TeXPageStack *item;
  1236.     int toPop = getActionPageNumber(tp, params, num_params);
  1237.     int pageNumber = -1;
  1238.  
  1239.     if ( toPop < 1 ) {
  1240.       toPop = 1;
  1241.     }
  1242.     
  1243.     item = tp -> pageStack;
  1244.     while( item ) {
  1245.  
  1246.       tp -> pageStack = item -> next;
  1247.       pageNumber = item -> physicalPageNumber;
  1248.       XtFree( (char *) item );
  1249.       item = tp -> pageStack;
  1250.  
  1251.       toPop--;
  1252.       if ( toPop < 1) break;
  1253.     };
  1254.     
  1255.     if ( pageNumber > -1 ) {
  1256.       if ( pageNumber != tp -> pageNumber ) {
  1257.     TeXPageDeref( tp );
  1258.     TeXPageRef(tp, pageNumber);
  1259.       }
  1260.       showPage(tp, True);
  1261.     }
  1262.   }
  1263. }
  1264.  
  1265. static void actionDivert(w, event, params, num_params)
  1266.      Widget w;
  1267.      XEvent *event;
  1268.      String *params;
  1269.      Cardinal *num_params;
  1270. {
  1271.   if ( xtexResources.divertByPush ) {
  1272.     actionPush(w, event, params, num_params);
  1273.   } else {
  1274.     actionRealize(w, event, params, num_params);
  1275.   }
  1276. }
  1277.  
  1278. static void actionUnDivert(w, event, params, num_params)
  1279.      Widget w;
  1280.      XEvent *event;
  1281.      String *params;
  1282.      Cardinal *num_params;
  1283. {
  1284.   if ( xtexResources.divertByPush ) {
  1285.     actionPop(w, event, params, num_params);
  1286.   }
  1287. }
  1288.  
  1289. void actionRedisplay(w, event, params, num_params)
  1290.      Widget w;
  1291.      XEvent *event;
  1292.      String *params;
  1293.      Cardinal *num_params;
  1294. {
  1295.   TeXPage *tp = TeXPageLocate(w);
  1296.   if ( IS_VALID_PAGE(tp) ) {
  1297.     Arg argList[20];
  1298.     int args = 0;
  1299.  
  1300.     XtSetArg(argList[args], XtNredisplay, True); args++;
  1301.     XtSetValues( tp -> singleDviPage, argList, args);
  1302.   }
  1303. }
  1304.  
  1305. static Widget PopUpWidget;
  1306. static Widget GotoValuatorWidget;
  1307. static TeXPage *GotoTeXPage;
  1308.  
  1309. static void
  1310.   actionGotoPopupConfirm(w, event, params, num_params)
  1311. Widget w;
  1312. XEvent *event;
  1313. String *params;
  1314. Cardinal *num_params;
  1315. {
  1316.   float value;
  1317.   int want;
  1318.   Arg argList[20];
  1319.   int args = 0;
  1320.   
  1321.   TeXPage *tp = GotoTeXPage;
  1322.   
  1323.   args = 0;
  1324.   XtSetArg(argList[args], XtNvalue, &value); args++;
  1325.   XtGetValues(GotoValuatorWidget, argList, args );
  1326.   want = value - 1;
  1327.   if ( want < 0 ) want = 0;
  1328.   if ( want >= DviTotalPages ) want = DviTotalPages - 1;
  1329.   
  1330.   if ( want != tp -> pageNumber ) {
  1331.     TeXPageDeref(tp);
  1332.     TeXPageRef(tp, want);
  1333.     showPage(tp, True);
  1334.   }
  1335.   XtPopdown( PopUpWidget );
  1336. }
  1337.  
  1338. static void
  1339.   actionGotoPopupCancel(w, event, params, num_params)
  1340. Widget w;
  1341. XEvent *event;
  1342. String *params;
  1343. Cardinal *num_params;
  1344. {
  1345.   TeXPage *tp = TeXPageLocate(w);
  1346.   XtPopdown( PopUpWidget );
  1347. }
  1348.  
  1349. static void
  1350.   actionGotoPopup(w, event, params, num_params)
  1351. Widget w;
  1352. XEvent *event;
  1353. String *params;
  1354. Cardinal *num_params;
  1355. {
  1356.   TeXPage *tp = TeXPageLocate(w);
  1357.   float value;
  1358.   Arg argList[20];
  1359.   int args = 0;
  1360.   
  1361.   Window root, child;
  1362.   static Widget labelWidget, formWidget, cancelWidget, confirmWidget,
  1363.   valueWidget;
  1364.   
  1365.   static Boolean inited = False;
  1366.   int root_x, root_y, child_x, child_y;
  1367.   unsigned int buttons;
  1368.   
  1369.   IntFloatUnion max;
  1370.   IntFloatUnion one;
  1371.   IntFloatUnion here;
  1372.   
  1373.   Dimension width;
  1374.   Dimension height;
  1375.   Dimension px,py,pw,ph;
  1376.   
  1377.   /*
  1378.    * Find out where the mouse is, so we can put the confirmation
  1379.    * box right there.
  1380.    */
  1381.   XQueryPointer(XtDisplay(tp -> popUpPage),
  1382.         XtWindow(tp -> popUpPage), &root, &child,
  1383.         &root_x, &root_y, &child_x, &child_y, &buttons);
  1384.   /*
  1385.    * If we need to construct the confirmation box do that,
  1386.    * otherwise just reset the position and callbacks and
  1387.    * put it up again.
  1388.    */
  1389.   if (!inited) {
  1390.     /*
  1391.      * The confirmation box will be a pop-up widget.
  1392.      */
  1393.     PopUpWidget =
  1394.       XtCreatePopupShell("Goto", POPUP_WINDOW_TYPE,
  1395.              TopLevelWidget, NULL, 0);
  1396.     
  1397.     /*
  1398.      * Make a form to put the buttons in.
  1399.      */
  1400.     formWidget = XtCreateWidget("form", formWidgetClass,
  1401.                 PopUpWidget, NULL, 0);
  1402.     
  1403.     /*
  1404.      * Confirmation button.
  1405.      */
  1406.     labelWidget = XtCreateManagedWidget("valueLabel", labelWidgetClass,
  1407.                     formWidget, NULL, 0);
  1408.     
  1409.     /*
  1410.      * Confirmation button.
  1411.      */
  1412.     confirmWidget = XtCreateManagedWidget("confirm", commandWidgetClass,
  1413.                       formWidget, NULL, 0);
  1414.     
  1415.     /*
  1416.      * Valuator.
  1417.      */
  1418.     
  1419.     one.f = 1.0;
  1420.     args = 0;
  1421.     XtSetArg(argList[args], XtNmin, one.i); args++;
  1422.     XtSetArg(argList[args], XtNincrement, one.i); args++;
  1423.     GotoValuatorWidget = XtCreateManagedWidget("valuator", valuatorWidgetClass,
  1424.                            formWidget, argList, args);
  1425.     
  1426.     valueWidget = XtCreateManagedWidget("value", labelWidgetClass,
  1427.                     formWidget, NULL, 0);
  1428.     
  1429.     args = 0;
  1430.     XtSetArg(argList[args], XtNvalueLabel, valueWidget); args++;
  1431.     XtSetValues(GotoValuatorWidget, argList, args);
  1432.     
  1433.     /*
  1434.      * Cancellation button.
  1435.      */
  1436.     cancelWidget = XtCreateManagedWidget("cancel", commandWidgetClass,
  1437.                      formWidget, NULL, 0);
  1438.     
  1439.     /*
  1440.      * Let the shell widget know we're here.
  1441.      */
  1442.     XtManageChild(formWidget);
  1443.     XtRealizeWidget(PopUpWidget);
  1444.     inited = True;
  1445.   }
  1446.   
  1447.   /*
  1448.    * Take some pains to center the popup on the pointer, but be certain
  1449.    * the thing is visible, else they can never exit
  1450.    */
  1451.   args = 0;
  1452.   XtSetArg(argList[args], XtNx, &px); args++;
  1453.   XtSetArg(argList[args], XtNy, &py); args++;
  1454.   XtSetArg(argList[args], XtNwidth, &pw); args++;
  1455.   XtSetArg(argList[args], XtNheight, &ph); args++;
  1456.   XtGetValues(tp -> popUpPage, argList,args);
  1457.   
  1458.   args = 0;
  1459.   XtSetArg(argList[args], XtNwidth, &width); args++;
  1460.   XtSetArg(argList[args], XtNheight, &height); args++;
  1461.   XtGetValues(PopUpWidget,argList,args);
  1462.   
  1463.   root_x -= (width/2);
  1464.   root_y -= (height/2);
  1465.   
  1466.   if ( root_x < 0 ) root_x = 0;
  1467.   if ( root_y < 0 ) root_y = 0;
  1468.   
  1469.   args = 0;
  1470.   XtSetArg(argList[args], XtNx, root_x); args++;
  1471.   XtSetArg(argList[args], XtNy, root_y); args++;
  1472.   XtSetValues(PopUpWidget,argList,args);
  1473.   
  1474.   /* reset the valuator */
  1475.   
  1476.   max.f = DviTotalPages;
  1477.   here.f = tp -> pageNumber + 1;
  1478.   
  1479.   args = 0;
  1480.   XtSetArg(argList[args], XtNmax, max.i); args++;
  1481.   XtSetArg(argList[args], XtNvalue, here.i); args++;
  1482.   XtSetValues(GotoValuatorWidget, argList, args);
  1483.   
  1484.   GotoTeXPage = tp;
  1485.   
  1486.   /* pop it up */
  1487.   XtPopup(PopUpWidget, XtGrabExclusive);
  1488. }
  1489.  
  1490. static void actionMagnify(w, event, params, num_params)
  1491.      Widget w;
  1492.      XEvent *event;
  1493.      String *params;
  1494.      Cardinal *num_params;
  1495. {
  1496.   TeXPage *tp = TeXPageLocate(w);
  1497.   int mag;
  1498.   
  1499.   if ( *num_params > 0 && *params ) {
  1500.     
  1501.     if ( strcmp(params[0], "large") == 0) {
  1502.       mag = xtexResources.largeMag;
  1503.     }
  1504.     else if ( strcmp(params[0], "small") == 0) {
  1505.       mag = xtexResources.smallMag;
  1506.     }
  1507.     else {
  1508.       mag = atoi( params[0] );
  1509.     }
  1510.   }
  1511.   else {
  1512.     mag = texxPageNumber( tp, tp -> userMag );
  1513.   }
  1514.   
  1515.   changeMag( tp, mag );
  1516. } 
  1517.  
  1518. static void actionNumber(w, event, params, num_params)
  1519.      Widget w;
  1520.      XEvent *event;
  1521.      String *params;
  1522.      Cardinal *num_params;
  1523. {
  1524.   TeXPage *tp = TeXPageLocate(w);
  1525.   if ( IS_VALID_PAGE(tp) && params && *params) {
  1526.     int digits = strlen(*params);
  1527.     int value = atoi(*params);
  1528.     
  1529.     if ( tp -> inputNumberValid ) {
  1530.       while ( digits > 0 ) {
  1531.     tp -> inputNumber *= 10;
  1532.     digits--;
  1533.       }
  1534.     }
  1535.     else {
  1536.       tp -> inputNumber = 0;
  1537.       tp -> inputNumberValid = True;
  1538.       tp -> inputNumberMinus = False;
  1539.     }
  1540.     tp -> inputNumber +=value;
  1541.   }
  1542. } 
  1543.  
  1544. static void actionNumberReset(w, event, params, num_params)
  1545.      Widget w;
  1546.      XEvent *event;
  1547.      String *params;
  1548.      Cardinal *num_params;
  1549. {
  1550.   TeXPage *tp = TeXPageLocate(w);
  1551.   if ( IS_VALID_PAGE(tp) ) {
  1552.     texxPageNumberReset(tp);
  1553.   }
  1554. } 
  1555.  
  1556. static void actionNumberMinus(w, event, params, num_params)
  1557.      Widget w;
  1558.      XEvent *event;
  1559.      String *params;
  1560.      Cardinal *num_params;
  1561. {
  1562.   TeXPage *tp = TeXPageLocate(w);
  1563.   if ( IS_VALID_PAGE(tp) ) {
  1564.     if ( ! tp -> inputNumberValid ) {
  1565.       tp -> inputNumberValid = True;
  1566.       tp -> inputNumber = 0;
  1567.       tp -> inputNumberMinus = True;
  1568.     }
  1569.     else {
  1570.       tp -> inputNumberMinus = ~(tp->inputNumberMinus);
  1571.     }
  1572.   }
  1573. } 
  1574.  
  1575. static Bool actionBool(oldValue, params, num_params)
  1576.      Bool oldValue;
  1577.      String *params;
  1578.      Cardinal *num_params;
  1579. {
  1580.   static char *trues[] = {"true", "True", "yes", "1", 0};
  1581.   static char *falses[] = {"false", "False", "no", "0", 0};
  1582.  
  1583.   if ( *num_params == 1 ) {
  1584.     int i;
  1585.     for (i = 0; trues[i] != 0; i++ ) {
  1586.       if ( strcmp(trues[i], params[0]) == 0 ) return( True );
  1587.     }
  1588.     for (i = 0; falses[i] != 0; i++ ) {
  1589.       if ( strcmp(trues[i], params[0]) == 0 ) return( False );
  1590.     }
  1591.     return( False );
  1592.   } else {
  1593.     return( !oldValue);
  1594.   }
  1595. }
  1596.  
  1597.  
  1598. static void actionChangeShowPostscript(w, event, params, num_params)
  1599.      Widget w;
  1600.      XEvent *event;
  1601.      String *params;
  1602.      Cardinal *num_params;
  1603. {
  1604.   TeXPage *tp = TeXPageLocate(w);
  1605.   xtexResources.showPostScript = actionBool( xtexResources.showPostScript,
  1606.                         params, num_params );
  1607. } 
  1608.  
  1609. static XtActionsRec texxPageActionsTable[] = {
  1610.   {"xtex-echo",  actionEcho },
  1611.   {"xtex-page-realize",  actionRealize },
  1612.   {"xtex-page-quit",  actionQuit },
  1613.   {"xtex-page-forward",  actionForeward },
  1614.   {"xtex-page-foreward",  actionForeward },
  1615.   {"xtex-page-backward",  actionBackward },
  1616.   {"xtex-page-duplicate",  actionDup },
  1617.   {"xtex-page-tie",  actionTie },
  1618.   {"xtex-page-goto",  actionGoto },
  1619.   {"xtex-page-push",  actionPush },
  1620.   {"xtex-page-pop",  actionPop },
  1621.   {"xtex-page-divert",  actionDivert },
  1622.   {"xtex-page-undivert",  actionUnDivert },
  1623.   {"xtex-page-redisplay",  actionRedisplay },
  1624.   {"xtex-page-goto-popup",  actionGotoPopup },
  1625.   {"xtex-page-goto-popup-confirm",  actionGotoPopupConfirm },
  1626.   {"xtex-page-goto-popup-cancel",  actionGotoPopupCancel },
  1627.   {"xtex-page-magnify",  actionMagnify },
  1628.   {"xtex-page-number",  actionNumber },
  1629.   {"xtex-page-number-minus",  actionNumberMinus },
  1630.   {"xtex-page-number-reset",  actionNumberReset },
  1631.   {"xtex-show-postscript",  actionChangeShowPostscript }
  1632. };
  1633.  
  1634. void
  1635.   TeXPageInstallActions()
  1636. {
  1637.   XtAddActions(texxPageActionsTable, XtNumber(texxPageActionsTable));
  1638. }
  1639.