home *** CD-ROM | disk | FTP | other *** search
/ No Fragments Archive 12: Textmags & Docs / nf_archive_12.iso / MAGS / SOURCES / ATARI_SRC.ZIP / atari source / DSHJ2 / REDRAW.C < prev    next >
Encoding:
C/C++ Source or Header  |  2001-02-10  |  78.9 KB  |  3,149 lines
  1. /**************************************************************************/
  2. /*  FILE:  REDRAW.C        PROGRAM TITLE: DeskSET II Alpha Version   */
  3. /*  Date Created: 12/15/87                          */ 
  4. /*  Last Modified: 06/30/89                          */
  5. /*                                      */
  6. /*  Description: REDRAW ROUTINES                      */
  7. /*  Routines:     o  do_redraw()      - Event Redraw Routine          */
  8. /*        o  text_draw()    - Txt Window Redraw Routine          */
  9. /*        o  prev_draw()      - Preview Window Redraw Routine      */
  10. /*        o  pdraw_fit()    - Draw Preview Background (size to fit) */
  11. /*        o  pdraw_scale()  - Draw Preview Background (any scale)   */
  12. /*        o  rc_equal()      - Equal Rectangle Check          */
  13. /*        o  send_redraw()  - Self Redraw Routine              */
  14. /*        o  set_clip()      - Set Clip Rectangle              */
  15. /*        o  clear_window() - Clear Text and Preview Windows        */
  16. /*        o  redraw_images()- Redraw Images Routines          */
  17. /*        o  zoom_setup()   - Closes/Opens Preview Buffer          */
  18. /*        o  do_blit()      - Performs blit from Preview to Screen  */
  19. /*        o  mclip()      - set clip in preview buffer          */
  20. /*        o  scan_clip()    - set clip in scan buffer          */
  21. /*        o  redraw_laser() - Redraw Laser Buffer at curr_page      */
  22. /*        o  do_update_text()- update text ptrs for vgtext      */
  23. /*        o  graphic_setup() - Display or hide graphic images      */
  24. /*        o  force_preview() - Redraw preview window - immediate    */
  25. /*        o  force_blit_redraw() - Another force redraw message     */
  26. /*        o  recalc_txtptrs()- Recalc txt ptrs for dotext       */
  27. /*        o  recalc_rtext()  - Only recalc 1 articles reg. textptrs */
  28. /*        o  clear_preview() - Clear preview window          */
  29. /*         o  update_preview_blit() - Update blit rectangles         */
  30. /*        o  update_size_fit() - Update window params in size to fit*/
  31. /*        o  init_rulers()   - Initialize h and v rulers        */
  32. /*        o  init_hrulers()  - Initialize horizontal rulers      */
  33. /*        o  init_vrulers()  - Initialize vertical rulers          */
  34. /*        o  init_hinches()  - Initialize h ruler to inches      */
  35. /*        o  init_hpicas()   - Initialize h ruler to picas      */
  36. /*        o  init_hcents()   - Initialize h ruler to centimeters    */
  37. /*        o  init_vinches()  - Initialize v ruler to inches      */
  38. /*        o  init_vpicas()   - Initialize v ruler to picas      */
  39. /*        o  init_vcents()   - Initialize v ruler to centimeters    */
  40. /*        o  show_rulers()   - Show rulers on screen           */
  41. /*        o  do_grids()       - Display grids on screen          */
  42. /*        o  put_mpix()       - Put grid pixel in memory buffer      */
  43. /*        o  calc_size_fit() - Calc size of page for STF and PADJCNT*/
  44. /*        o  redraw_alt()       - Redraw Handler for PADJCNT          */
  45. /**************************************************************************/
  46.  
  47.  
  48. /**************************************************************************/
  49. /* INCLUDE FILES                              */
  50. /**************************************************************************/
  51. #include <obdefs.h>
  52. #include "define.h"
  53. #include "gemdefs.h"
  54. #include "deskset2.h"
  55. #include <osbind.h>
  56. #include "defs.h"
  57. #include "dbase.h"
  58. #include "alert.h"
  59.  
  60. /**************************************************************************/
  61. /* DEFINES                                  */
  62. /**************************************************************************/
  63. #define max(x,y)   (((x) > (y)) ? (x) :  (y))    /* Max function              */
  64. #define    min(x,y)   (((x) < (y)) ? (x) :  (y))    /* Min function          */
  65.  
  66.  
  67. /**************************************************************************/
  68. /* EXTERNALS                                  */
  69. /**************************************************************************/
  70. extern int gl_apid;                /* gl_apid used for redraw*/
  71.  
  72. extern int txt_handle;                /* text window handle     */
  73. extern int prev_handle;                /* preview window handle  */
  74. extern int dummy;                /* dummy, you dummy...    */
  75.  
  76. extern GRECT dpwork;                /* work area of window    */
  77. extern GRECT pwork;                /* preview window wrk area*/
  78. extern GRECT twork;                /* txt window work area   */
  79.  
  80. extern int phandle;                /* printer handle         */
  81. extern int mhandle;                /* preview buffer handle  */
  82. extern int shandle;                             /* screen handle          */
  83.  
  84. extern int view_size;                /* Current Viewing Size   */
  85.  
  86. extern int hpage_size;                /* Horiz Page Width -MU   */
  87. extern int vpage_size;                /* Vert. Page Width - MU  */
  88. extern FDB page_MFDB;                /* Preview Buffer MFDB    */
  89. extern GRECT page_area;             /* Preview BUffer GRECT   */
  90. extern long location;                /* Screen MFDB          */
  91.  
  92. extern int ptsin[];                /* PTSIN array for data   */
  93. extern int intout[];
  94.  
  95. extern long get_fregion();            /* get first region      */
  96. extern long get_nregion();            /* get next region        */
  97. extern long getf_aregion();            /* get first article reg..*/
  98. extern long getn_aregion();            /* get next article region*/
  99. extern long getf_article();
  100. extern long getn_article();
  101. extern long get_regart();
  102. extern SCANINFO *getf_scaninfo();
  103. extern SCANINFO *getn_scaninfo();
  104.  
  105. extern curr_page;                /* current page          */
  106.  
  107. extern int rect_in_mu[];;            /* x1,y1,x2,y2 variables  */
  108. extern int mode_flag;                /* current fill mode      */
  109. extern int msg_buff[];                /* evnt_multi buffer      */
  110.  
  111. extern unsigned long scanptr;            /* Ptr to Scan Buffer     */
  112. extern unsigned long page_ptr;            /* Ptr to Preview Buffer  */
  113. extern unsigned long pageim;            /* Ptr to Laser Buffer    */
  114. extern int mxres,myres;                /* Preview Buffer rez     */
  115. extern int mode_change;                /* Flag - just change     */
  116.                         /* fill type????  0 no    */
  117.                         /*          1 yes   */
  118. extern unsigned long prev_bytes;        /* #bytes in preview buf  */
  119. extern unsigned long laser_bytes;
  120. extern unsigned long scan_bytes;
  121.  
  122. extern int scan_xres;                /* scan buffer xres      */
  123. extern int scan_yres;                /* scan buffer yres      */
  124.  
  125. extern int  zdevice;                /* index into xdpi/ydpi   */
  126. extern int  pxy[];                /* tmp array          */
  127.  
  128. extern char *do_handjreg();            /* Do jim's scan routine  */
  129. extern char *get_arttxt();            
  130. extern char *get_txtptr();
  131. extern int  SH;                    /* Line space for scanner */
  132.  
  133. extern int ptsarray[];                /* Interface to DBASE.C   */
  134. extern unsigned long gl_region_ptr;        /* txt region pointer...  */
  135. extern int cur_primitive;            /* current primitive RCS  */
  136. extern int image_status;            /* Image Display? or not..*/
  137.  
  138. extern struct txtattr gltxtattr;        /* global text attrib     */
  139. extern int glgrattr[];                /* global graphic attrib  */
  140.  
  141. extern int sdevm;
  142.  
  143. extern int xruler_offset;
  144. extern int yruler_offset;
  145. extern int ruler_flag;
  146. extern int unit_type;
  147. extern int splane;
  148. extern unsigned long scanptr;
  149. extern int newx,newy;
  150. extern int xold_mark,yold_mark;
  151. extern int xor_handle;
  152. extern char *get_lcmem();
  153. extern int rule_handle;
  154. extern int deferhj;
  155. extern int show_grids;
  156. extern int hgridspace;
  157. extern int vgridspace;
  158.  
  159. extern long pagebytes;
  160.  
  161. extern int print_flag;
  162.  
  163. extern    int    TWrfmod;            /* TWindow refresh mode    */
  164. extern    long    TWart_ptr;            /* TW current article    */
  165.  
  166. extern PAGE *curpage;
  167. extern long curregion;
  168.  
  169.  
  170. extern PAGE *pagehd;
  171. extern PAGE *left_tmplate;
  172. extern PAGE *right_tmplate;
  173. extern int tmplate_flag;
  174. extern int temp_page;
  175. extern PAGE *tpagehd;
  176. extern PAGE *tcurpage;
  177. extern int displ_tmpl_flag;
  178. extern int disp_pos;                /* template-FRONT or BACK   */
  179. extern int disp_type;                /* templ type-BOTH,LEFT,RITE*/
  180.  
  181. extern ARTICLE *rtarthd;
  182. extern ARTICLE *ltarthd;
  183. extern ARTICLE *arthd;
  184.  
  185. extern int TYF_Gx0;
  186. extern int TYF_Gy0;
  187. extern int TYF_Gx1;
  188. extern int TYF_Gy1;
  189. extern int TYF_Gtype;
  190. extern char *TYF_Gfile;
  191.  
  192. extern unsigned char *buf_end;
  193. extern long    curart;
  194. extern int mnumfnt;            /* Number of fnts in mem driver   */
  195. extern long daveptr;
  196. extern int pagetype;
  197. extern int pxres;
  198. extern int pyres;
  199.  
  200. extern char cpabt;            /* DOTEXT VARIABLE CJG 08/26/89   */
  201.  
  202. /**************************************************************************/
  203. /* GLOBAL VARIABLES                              */
  204. /**************************************************************************/
  205. char *savecptr;
  206. int pagew;                    /* Current Page width and */
  207. int pageh;                    /* height in pixels for   */
  208.                         /* reference purposes only*/
  209. int opwidth;                    /* Old page width pixels  */
  210. int opheight;                    /* Old page ht - pixels   */
  211.  
  212. int clip_area[4];                /* Global Clipping rect.  */
  213.  
  214. unsigned long region_ptr;            /* Ptr to current region  */
  215.  
  216. int  opcode;                    /* opcode of poly type    */
  217. int  count;                    /* number of vertices     */
  218. int  wmode;                    /* writing mode          */
  219.  
  220. int txoffset,tyoffset;                /* tmp xoffset and yoffset*/
  221. int prev_size;                    /* preview size          */
  222. int blit_flag;                    /* to blit or not to blit */
  223. int xwidth,ywidth;                /* Calc screen width/ht   */
  224.  
  225. char *txtptr;                    /* Text Pointer...        */
  226. GRECT page;                    /* GRECT of page area?    */
  227. int force_draw_flag;                /* Force a redraw on Prev.*/
  228. int blit_area[8];
  229. int aclear[4];                    /* preview clear_window rect*/
  230. int aclear2[4];
  231.  
  232. int *hrbuffer;
  233. int *vrbuffer;
  234. FDB hrule_mfdb;
  235. FDB vrule_mfdb;
  236. int vhalf,hhalf;
  237. int hlen,vlen;
  238. int x_eighths,y_eighths;
  239.  
  240. int ruler_hasmem;
  241.  
  242. char pixtbl[] = {0x80,
  243.          0x40,
  244.          0x20,
  245.          0x10,
  246.          0x08,
  247.          0x04,
  248.          0x02,
  249.          0x01};
  250.  
  251. int alt_offset;
  252.  
  253.  
  254. long newscreen;
  255. long realscreen;
  256. int alerted;
  257.  
  258. /**************************************************************************/
  259. /* Function:    do_redraw()                          */
  260. /* Description: Event Driven Redraw Routine                  */
  261. /**************************************************************************/
  262. do_redraw(msg)
  263. register int msg[];
  264. {
  265.    register int whandle;
  266.    GRECT t1,t2;
  267.    int pxy[4];
  268.  
  269.    gsx_moff();
  270.    whandle = msg[3];
  271.    t2.g_x  = msg[4];
  272.    t2.g_y  = msg[5];
  273.    t2.g_w  = msg[6];
  274.    t2.g_h  = msg[7];
  275.  
  276.    if(whandle == txt_handle)
  277.    {
  278.       if (!TWart_ptr || TWrfmod == 2)        /* force full TW area    */
  279.       {
  280.       t2.g_x = twork.g_x;
  281.       t2.g_y = twork.g_y;
  282.       t2.g_w = twork.g_w;
  283.       t2.g_h = twork.g_h;
  284.       }
  285.       if (TWart_ptr)
  286.       {
  287.       clrcursor();
  288.       hilicheck(0);
  289.       review(TWrfmod);
  290.       }
  291.  
  292.    }
  293.    wind_get(whandle,WF_FIRSTXYWH,&t1.g_x,&t1.g_y,&t1.g_w,&t1.g_h);
  294.    while(t1.g_w && t1.g_h)
  295.    {  
  296.       gsx_moff();
  297.       if(rc_intersect(&t2,&t1))
  298.       {
  299.          set_clip(TRUE,&t1);
  300.      grect_to_array(&t1,pxy);        /* experimental */
  301.      vs_clip(rule_handle,1,pxy);
  302.  
  303.          if(whandle ==  txt_handle)
  304.      {
  305.             txt_draw(&t1);
  306.         set_clip(FALSE,&t1);
  307.          }
  308.          else
  309.             if(whandle == prev_handle) 
  310.              prev_draw();
  311.       }
  312.       wind_get(whandle,WF_NEXTXYWH,&t1.g_x,&t1.g_y,&t1.g_w,&t1.g_h);
  313.    }
  314.  
  315.    if (whandle == txt_handle && TWart_ptr)
  316.    {
  317.     endreview(0);
  318.     cursor();
  319.     if (TWrfmod <= 2) TWrfmod = 3;
  320.    }
  321.  
  322.    vs_clip(rule_handle,0,pxy);
  323.    check_region_ptr();
  324.    gsx_mon();
  325. }
  326.  
  327.  
  328.  
  329. /**************************************************************************/
  330. /* Function:    txt_draw()                          */
  331. /* Description: Redraw Txt Window                      */
  332. /**************************************************************************/
  333. txt_draw(rect)
  334. GRECT *rect;
  335. {
  336.    clrTW(rect);
  337.    if (TWart_ptr) new_screen();
  338. }
  339.  
  340.  
  341.  
  342. /**************************************************************************/
  343. /* Function:    prev_draw()                          */
  344. /* Description: Redraw Preview Window                      */
  345. /**************************************************************************/
  346. prev_draw()
  347. {
  348.    blit_flag = TRUE;
  349.    if(force_draw_flag)
  350.    {
  351.        blit_flag = FALSE;
  352.        force_draw_flag = FALSE;
  353.    }
  354.    clear_preview();
  355.    if(view_size == PADJCNT)
  356.         redraw_alt();
  357.    else
  358.            redraw_images();
  359. }
  360.  
  361.  
  362.  
  363.  
  364. /**************************************************************************/
  365. /* Function:    pdraw_fit()                          */
  366. /* Description: Calculate screen page width and height              */
  367. /**************************************************************************/
  368. pdraw_fit(item)
  369. int item;
  370. {
  371.     if(ruler_flag)
  372.          mutoscrn(648,576,&xruler_offset,&yruler_offset,1);
  373.     else
  374.          xruler_offset = yruler_offset = 0;
  375.     dpwork.g_x = pwork.g_x + xruler_offset;
  376.     dpwork.g_y = pwork.g_y + yruler_offset;
  377.     dpwork.g_w = pwork.g_w - xruler_offset;
  378.     dpwork.g_h = pwork.g_h - yruler_offset;
  379.     calc_size_fit(item);
  380. }
  381.  
  382.  
  383. /**************************************************************************/
  384. /* Function:    pdraw_scale()                          */
  385. /* Description: Draw the preview background page (any scale)          */
  386. /**************************************************************************/
  387. pdraw_scale()
  388. {
  389.       txoffset = page_area.g_x;
  390.       tyoffset = page_area.g_y;
  391.  
  392.       zdevice  = SCREEN;
  393.       pagew = hmutopix(hpage_size);        /* can make this a variable */
  394.       pageh = vmutopix(vpage_size);        /* for later...            */
  395.  
  396.       scale(&pagew,&pageh,&txoffset,&tyoffset,0);
  397.  
  398.       pxy[0] = pwork.g_x + hmutopix(txoffset);
  399.       pxy[1] = pwork.g_y + vmutopix(tyoffset); 
  400.       xwidth = pxy[2] = pxy[0] + pagew - 1;
  401.       ywidth = pxy[3] = pxy[1] + pageh - 1;
  402. }
  403.  
  404. /**************************************************************************/
  405. /* Function:    rc_equal()                          */
  406. /* Description: check if 2 rectangles are equal                  */
  407. /**************************************************************************/
  408. rc_equal(p1,p2)
  409. register GRECT *p1,*p2;
  410. {
  411.     if((p1->g_x != p2->g_x) ||
  412.        (p1->g_y != p2->g_y) ||
  413.        (p1->g_w != p2->g_w) ||
  414.        (p1->g_h != p2->g_h))
  415.        return(FALSE);
  416.     return(TRUE);
  417. }
  418.  
  419.  
  420.  
  421. /**************************************************************************/
  422. /* Function:    send_redraw()                          */
  423. /* Description: Perform a self-redraw                      */
  424. /**************************************************************************/
  425. send_redraw(wh)
  426. int wh;
  427. {
  428.     msg_buff[0] = WM_REDRAW;
  429.     msg_buff[1] = gl_apid;
  430.     msg_buff[2] = 0;
  431.     msg_buff[3] = wh;
  432.     msg_buff[4] = pwork.g_x;
  433.     msg_buff[5] = pwork.g_y;
  434.     msg_buff[6] = pwork.g_w;
  435.     msg_buff[7] = pwork.g_h;
  436.     appl_write(gl_apid,16,msg_buff);
  437. }
  438.  
  439.  
  440.  
  441. /**************************************************************************/
  442. /* Function:    set_clip()                          */
  443. /* Description: Set a clipping Rectangle                  */
  444. /* INPUT: clip_flag o 0 - Clip Off  1 - Clip On                  */
  445. /*        area      0 Area to Clip                      */
  446. /**************************************************************************/
  447. set_clip(clip_flag,area)
  448. int clip_flag;
  449. GRECT *area;
  450. {
  451.      int pxy[4];
  452.  
  453.      grect_to_array(area,pxy);
  454.      vs_clip(shandle,clip_flag,pxy);
  455. }
  456.  
  457.  
  458.  
  459. /**************************************************************************/
  460. /* Function:    clear_window()                          */
  461. /* Description: Clears the window  - Text Window  to white          */
  462. /*                   - Preview Window to Dithered.          */
  463. /* INPUT: whandle - handle of window                          */
  464. /*      pattern - interior pattern                      */
  465. /*      style   - style type.                          */
  466. /**************************************************************************/
  467. clear_window(whandle,pattern,style)
  468. int whandle;
  469. int pattern;
  470. int style;
  471. {
  472.     int pxy[4];
  473.   
  474.     vsf_interior(shandle,pattern);
  475.     vsf_style(shandle,style);
  476.     vsf_perimeter(shandle,0);
  477.     if(whandle == prev_handle)
  478.     {
  479.          aclear[0] = dpwork.g_x + pagew;    /* clears right of page */
  480.      aclear[1] = pwork.g_y;
  481.          aclear[2] = aclear[0] + pwork.g_w - 1;
  482.          aclear[3] = aclear[1] + pwork.g_h - 1;
  483.  
  484.          aclear2[0] = pwork.g_x;        /* clears below of page */
  485.      aclear2[1] = dpwork.g_y + pageh;
  486.          aclear2[2] = aclear2[0] + pwork.g_w - 1;
  487.      aclear2[3] = aclear2[1] + pwork.g_h - 1;
  488.     }
  489.     else
  490.     {
  491.        grect_to_array(&twork,pxy);
  492.        vr_recfl(shandle,pxy);
  493.     }    
  494. }
  495.  
  496.  
  497. /**************************************************************************/
  498. /*    Clean up all rectangles of regions that have been re H&J ed       */
  499. /*    from the current article.  Start with the given region which was  */
  500. /*    the first one h&jed and clean up all other regions on the         */
  501. /*     same page.                              */
  502. /**************************************************************************/
  503. make_slave(rptr,stop_ptr)
  504. long rptr;
  505. long stop_ptr;
  506. {
  507.    register long region_ptr;
  508.    int rect[4];
  509.    int page;
  510.    long tmpregion;
  511.    int endflag;
  512.    long slvptr;
  513.    long ldummy;
  514.    int dummy;
  515.  
  516.    region_ptr = getf_aregion(&rect[0],&rect[1],
  517.                  &rect[2],&rect[3],&page);
  518.  
  519.    while(region_ptr != rptr && region_ptr)
  520.       region_ptr = getn_aregion(&rect[0],&rect[1],
  521.                     &rect[2],&rect[3],&page);    
  522.  
  523.    while(region_ptr && (region_ptr != stop_ptr))
  524.    {
  525.       getf_scaninfo(region_ptr,&dummy,&dummy,&dummy,&dummy,&ldummy,&slvptr);
  526.       if(page == curr_page && !slvptr)
  527.       {
  528.          get_txtattr(region_ptr,&gltxtattr);
  529.          tmpregion = curregion;
  530.      if(txtptr = get_txtptr(region_ptr))
  531.          {
  532.        if(*txtptr)
  533.        {
  534.          get_buffvars(region_ptr);
  535.          open_region(region_ptr);
  536.              do_slave_only(txtptr,&endflag);
  537. /*             put_buffvars(region_ptr);        */
  538.        }
  539.          }
  540.          curregion = tmpregion;
  541.       }
  542.       region_ptr = getn_aregion(&rect[0],&rect[1],
  543.                           &rect[2],&rect[3],&page);    
  544.  
  545.    }
  546. }
  547.  
  548. /**************************************************************************/
  549. /*    Clean up all rectangles of regions that have been re H&J ed       */
  550. /*    from the current article.  Start with the given region which was  */
  551. /*    the first one h&jed and clean up all other regions on the         */
  552. /*     same page.                              */
  553. /**************************************************************************/
  554. page_cleanup(rptr,stop_ptr)
  555. long rptr;
  556. long stop_ptr;
  557. {
  558.    register long region_ptr;
  559.    int rect[4];
  560.    int page;
  561.    long tmpregion;
  562.  
  563.    region_ptr = getf_aregion(&rect[0],&rect[1],
  564.                  &rect[2],&rect[3],&page);
  565.  
  566.    while(region_ptr != rptr && region_ptr)
  567.       region_ptr = getn_aregion(&rect[0],&rect[1],
  568.                     &rect[2],&rect[3],&page);    
  569.  
  570.    while(region_ptr && (region_ptr != stop_ptr))
  571.    {
  572.       if(page == curr_page)
  573.       {
  574.          tmpregion = curregion;
  575.          redraw_area(region_ptr,rect,0);
  576.          curregion = tmpregion;
  577.       }
  578.       region_ptr = getn_aregion(&rect[0],&rect[1],
  579.                           &rect[2],&rect[3],&page);    
  580.  
  581.    }
  582.    do_blit();   
  583. }
  584.  
  585.  
  586. redr_regarea(rptr,bltflag)
  587. register long rptr;
  588. int bltflag;
  589. {
  590.    int rect[4];
  591.    int dummy;
  592.  
  593.    find_boundary(rptr,&rect[0],&rect[1],&rect[2],&rect[3],&dummy,&dummy);
  594.    redraw_area(rptr,rect,bltflag);
  595. }
  596.  
  597. /**************************************************************************/
  598. /* Function:    redraw_area()                          */
  599. /* Description    Redraw loop for polygons, ellipses etc...          */
  600. /**************************************************************************/
  601. redraw_area(rptr,murect,bltflag)
  602.    register REGION *rptr;
  603.    register int murect[];
  604.    int bltflag;
  605. {
  606.    int g_flag;                /* graphic region? */
  607.    int rgrect[4];
  608.    int tgrect[4];
  609.    int rpxy[4];
  610.    int tpxy[4];
  611.    int murec1[4];
  612.    int pts;
  613.  
  614.    int xoffset,yoffset;
  615.  
  616.    if(!rptr)
  617.    {
  618.     pts = 36;
  619.     xoffset = pts * 18;
  620.     yoffset = pts * 16;
  621.    }    
  622.    else
  623.    {
  624.     pts = rptr->grattr[1];
  625.         if(pts && (rptr->grattr[2] & 0x8000))
  626.         {
  627.        xoffset = pts * 18;
  628.        yoffset = pts * 16;
  629.         }
  630.         else
  631.     {
  632.        xoffset = 162; /* offsets are in machine units */
  633.        yoffset = 144; /* an eighth of an inch each way*/
  634.               /* based on 1296 and 1152 mus   */
  635.     }
  636.    }
  637.  
  638.    murect[0] -= xoffset;
  639.    murect[1] -= yoffset;
  640.    murect[2] += xoffset;
  641.    murect[3] += yoffset;
  642.  
  643.  
  644.    GDvq_extnd(mhandle,0,intout,mxres,myres,&page_ptr);
  645.  
  646.    mutopage(murect[0],murect[1],&rpxy[0],&rpxy[1],0);
  647.    mutopage(murect[2],murect[3],&rpxy[2],&rpxy[3],0);
  648. #if NEVER
  649.    rpxy[0] -= 2;        /* With solid fills perimeter is on */
  650.    rpxy[1] -= 2;        /* so when erasing with hollow fill */
  651.    rpxy[2] += 2;        /* we must ......            */
  652.    rpxy[3] += 2;        /* Adjust for perimeter being off   */
  653. #endif
  654.    rpxy[0] = max(0,rpxy[0]);
  655.    rpxy[1] = max(0,rpxy[1]);
  656.    rpxy[2] = min(pagew - 1,rpxy[2]);
  657.    rpxy[3] = min(pageh - 1,rpxy[3]);
  658.  
  659.    vs_clip(mhandle,1,rpxy);
  660.    write_white(mhandle);
  661.    v_bar(mhandle,rpxy);
  662.    write_black(mhandle);
  663.  
  664.    rgrect[0] = rpxy[0];
  665.    rgrect[1] = rpxy[1];
  666.    rgrect[2] = rpxy[2] - rpxy[0] + 1;
  667.    rgrect[3] = rpxy[3] - rpxy[1] + 1;
  668.  
  669.    if(show_grids)    /* moved it here cjg */
  670.     do_grids(1,murect[0],murect[1],murect[2],murect[3]);
  671.  
  672.    display_template(1,rgrect);
  673.    
  674.    region_ptr = get_fregion(curr_page,
  675.     &murec1[0],&murec1[1],
  676.     &murec1[2],&murec1[3],&g_flag);
  677.    while(region_ptr)
  678.    {
  679.         if(murec1[0] >= hpage_size)    /* clip it out */
  680.             goto next;
  681.  
  682.         mutopage(murec1[0],murec1[1],&tpxy[0],&tpxy[1],0);
  683.         mutopage(murec1[2],murec1[3],&tpxy[2],&tpxy[3],0);
  684.     
  685.     tgrect[0] = tpxy[0];
  686.         tgrect[1] = tpxy[1];
  687.         tgrect[2] = tpxy[2] - tpxy[0] + 1;
  688.         tgrect[3] = tpxy[3] - tpxy[1] + 1;
  689.     
  690.     if(rc_intersect(rgrect,tgrect))
  691.     {
  692.        if(g_flag)
  693.                get_grattr(region_ptr,glgrattr);
  694.  
  695.            if(g_flag || !mode_flag)
  696.            {
  697.                opcode = get_fprimitive(region_ptr,&count,&wmode);
  698.                while(opcode != -1)
  699.                {
  700.                    switch(opcode)
  701.                    {
  702.                    case 3:
  703.                    case 4:
  704.                    case 0: redraw_polygon(count,wmode,g_flag);
  705.                                break;
  706.  
  707.                case 1: redraw_ellipse(wmode,g_flag);
  708.                        break;
  709.  
  710.                case 2: graphic_setup();
  711.                          break;
  712.                 }
  713.                     opcode = get_nprimitive(&count,&wmode);
  714.                }
  715.        }
  716.            if(mode_flag && !g_flag)
  717.        {
  718.           if(txtptr = get_txtptr(region_ptr))
  719.               {
  720.               if(*txtptr)
  721.           {
  722.                  open_region(region_ptr);
  723.                      do_clipregout(tgrect[0],tgrect[1],
  724.             tgrect[2] + tgrect[0] - 1,
  725.             tgrect[3] + tgrect[1] - 1);
  726.                   }
  727.           }
  728.            }
  729.     }
  730. next:    region_ptr = get_nregion(&murec1[0],&murec1[1],
  731.                         &murec1[2],&murec1[3],&g_flag);
  732.    }
  733.  
  734.    display_template(2,rgrect);
  735.    do_numbers(rgrect,0);
  736.  
  737.    if(bltflag)
  738.    {
  739.       mclip();
  740.       do_blit();
  741.    }
  742. }
  743.  
  744.  
  745. /**************************************************************************/
  746. /* Function:    redraw_images()                          */
  747. /* Description    Redraw loop for polygons, ellipses etc...          */
  748. /**************************************************************************/
  749. redraw_images()
  750. {
  751.    int endflag;
  752.    int g_flag;                /* graphic region? */
  753.  
  754.    if((!blit_flag) || mode_change)
  755.    {
  756.       clrmem(page_ptr,pagebytes);
  757.  
  758.       if(show_grids)
  759.     do_grids(0,0,0,0,0);
  760.  
  761.         display_template(1,0L);
  762.         region_ptr = get_fregion(curr_page,
  763.             &rect_in_mu[0],&rect_in_mu[1],
  764.             &rect_in_mu[2],&rect_in_mu[3],&g_flag);
  765.         while(region_ptr)
  766.         {
  767.              if(rect_in_mu[0] >= hpage_size)    /* clip it out! */
  768.                 goto next;
  769.  
  770.              mclip();
  771.              if(!g_flag)
  772.                  get_txtattr(region_ptr,&gltxtattr);
  773.          else 
  774.          get_grattr(region_ptr,glgrattr);
  775.          if(g_flag || !mode_flag)
  776.          {
  777.                 opcode = get_fprimitive(region_ptr,&count,&wmode);
  778.                 while(opcode != -1)
  779.                 {
  780.                    switch(opcode)
  781.                    {
  782.                    case 3:
  783.                    case 4:
  784.                    case 0: redraw_polygon(count,wmode,g_flag);
  785.                                break;
  786.  
  787.                case 1: redraw_ellipse(wmode,g_flag);
  788.                        break;
  789.  
  790.                case 2: graphic_setup();
  791.                          break;
  792.                 }
  793.                     opcode = get_nprimitive(&count,&wmode);
  794.                  }
  795.          }
  796.              if(mode_flag && !g_flag)
  797.          {
  798.             if(txtptr = get_txtptr(region_ptr))
  799.                 {
  800.            if(*txtptr)
  801.            {
  802.                  get_buffvars(region_ptr);
  803.              open_region(region_ptr);
  804.                      do_regoutput(txtptr,&endflag);
  805.                      put_buffvars(region_ptr);
  806.            }
  807.                 }
  808.             GDvq_extnd(mhandle,0,intout,mxres,myres,&page_ptr);
  809.              }
  810.  
  811. next:      region_ptr = get_nregion(&rect_in_mu[0],&rect_in_mu[1],
  812.                         &rect_in_mu[2],&rect_in_mu[3],&g_flag);
  813.       }
  814.       mode_change = FALSE;
  815.       display_template(2,0L);
  816.       do_numbers(0L,0);
  817.    }
  818.    do_blit();            /* Either blit now or redraw,then blit*/
  819. }
  820.  
  821. /**************************************************************************/
  822. /* Function:    zoom_setup()                          */
  823. /* Description    Closes/Open Preview Buffer with new sizes          */
  824. /**************************************************************************/
  825. zoom_setup()
  826. {
  827.       opwidth  = pwork.g_w;
  828.       opheight = pwork.g_h;
  829.       mxres    = pagew;
  830.       myres    = pageh;
  831.  
  832.       if((view_size == PSIZE) || (view_size == PADJCNT))
  833.        mxres = ((mxres + 15)/16)*16;
  834.       GDvq_extnd(mhandle,0,intout,mxres,myres,&page_ptr);
  835.       page_MFDB.fd_w = mxres; 
  836.       page_MFDB.fd_h = myres;
  837.       page_MFDB.fd_wdwidth = (mxres + 15)/16;
  838. }
  839.  
  840.  
  841.  
  842. /**************************************************************************/
  843. /* Function:    do_blit()                          */
  844. /* Description:    Blit GRECT from preview buffer to screen          */
  845. /**************************************************************************/
  846. do_blit()
  847. {
  848.         int color[2];
  849.         color[0] = 1;
  850.         color[1] = 0;
  851.         mutopage(page_area.g_x,page_area.g_y,&page.g_x,&page.g_y,1);
  852.         grect_to_array(&page,blit_area);
  853.     gsx_moff();
  854.     vrt_cpyfm(shandle,1,blit_area,&page_MFDB,&location,color);
  855.     if(ruler_flag)
  856.        show_rulers();
  857.         gsx_mon();
  858. }
  859.  
  860. /**************************************************************************/
  861. /* Function:    mclip()                              */
  862. /* Description: set clipping rectangle in preview buffer          */
  863. /**************************************************************************/
  864. mclip()
  865. {
  866.    int pxy[4];
  867.  
  868.    pxy[0] = pxy[1] = 0;  
  869.    pxy[3] = pageh - 1;
  870.  
  871.    if(view_size == PADJCNT)
  872.    {
  873.      pxy[0] = ((curr_page % 2) ? (pagew/2):(0));
  874.      pxy[2] = ((curr_page % 2) ? (pagew - 1) : (pagew/2));
  875.    }
  876.    else
  877.      pxy[2] = pagew - 1;
  878.  
  879.    vs_clip(mhandle,1,pxy);
  880. }
  881.  
  882.  
  883.  
  884. /**************************************************************************/
  885. /* Function:    scan_clip()                              */
  886. /* Description: set clipping rectangle in scan buffer                 */
  887. /**************************************************************************/
  888. scan_clip()
  889. {
  890.    int pxy[4];
  891.   
  892.    pxy[0] = pxy[1] = 0;
  893.    pxy[2] = scan_xres - 1;
  894.    pxy[3] = scan_yres - 1;
  895.    vs_clip(mhandle,1,pxy);
  896. }
  897.  
  898.  
  899.  
  900. /**************************************************************************/
  901. /* Function:    redraw_laser()                          */
  902. /* Description    Redraw loop for polygons, ellipses etc...          */
  903. /*        Redraw Loop for playing back to the laser printer...      */
  904. /**************************************************************************/
  905. redraw_laser(pagenum)
  906. int pagenum;
  907. {
  908.    int status;
  909.    int prev_flag;
  910.    int endflag;
  911.    int g_flag;                    /* graphic region? */
  912.    int temp;
  913.    int tmp_handle;
  914.    int dxres,dyres;
  915.    int pxy[4];
  916.    long buffer;
  917.  
  918.    endflag = 0;
  919.    g_flag  = FALSE;
  920.    prev_flag = mode_flag;
  921.    mode_flag = TRUE;
  922.    temp = sdevm;
  923.    sdevm = 3;                /* Laser printer CS 4/12 */
  924.  
  925.  
  926.    if(pagetype > PLEGAL)
  927.    {
  928.        tmp_handle = phandle;
  929.        phandle = mhandle;
  930.    }
  931.  
  932.    clrmem(pageim,laser_bytes);
  933.  
  934.    display_template(1,0L);
  935.  
  936.        region_ptr = get_fregion(pagenum,
  937.                 &rect_in_mu[0],&rect_in_mu[1],
  938.                 &rect_in_mu[2],&rect_in_mu[3],&g_flag);
  939.        while(region_ptr)
  940.        {
  941.        if(rect_in_mu[0] >= hpage_size)
  942.                 goto next;
  943.  
  944.            if(!g_flag)
  945.                get_txtattr(region_ptr,&gltxtattr);
  946.            else
  947.                get_grattr(region_ptr,glgrattr);
  948.        if(g_flag || !mode_flag)
  949.        {
  950.                opcode = get_fprimitive(region_ptr,&count,&wmode);
  951.                while(opcode != -1)
  952.                {
  953.                   switch(opcode)
  954.                   {
  955.             case 3:
  956.             case 4:
  957.             case 0:  redraw_polygon(count,wmode,g_flag);
  958.                      break;
  959.             case 1:  redraw_ellipse(wmode,g_flag);
  960.                   break;
  961.             case 2:  insert_graphic();
  962.                  break;
  963.                   }
  964.                   opcode = get_nprimitive(&count,&wmode);
  965.                }
  966.        }
  967.            if(!g_flag)
  968.            {
  969.               if(txtptr = get_txtptr(region_ptr))
  970.               {
  971.          if(*txtptr)
  972.          {
  973.                 get_buffvars(region_ptr);
  974.             open_region(region_ptr);
  975.                     do_regoutput(txtptr,&endflag);         
  976.                     put_buffvars(region_ptr);
  977.          }
  978.               }
  979.        if(pagetype <= PLEGAL)    /* Don't do this if Landscape*/
  980.                     GDvq_extnd(mhandle,0,intout,mxres,myres,&page_ptr);
  981.  
  982.          }                 /* if(graphics && g_flag) etc... */
  983. next:    region_ptr = get_nregion(&rect_in_mu[0],&rect_in_mu[1],
  984.                          &rect_in_mu[2],&rect_in_mu[3],&g_flag);
  985.  
  986.  
  987.    }                /* while(region_ptr          */
  988.    display_template(2,0L);
  989.    do_numbers(0L,0);
  990.  
  991.  
  992.    if(pagetype > PLEGAL)
  993.    {
  994.        phandle = tmp_handle;
  995.     mutolas(hpage_size,vpage_size,&dxres,&dyres);
  996.     dxres = ((dxres + 15)/16)*2;
  997.     dyres = ((dyres + 15)/16)*2;
  998.         rotate(pageim,daveptr,dxres,dyres,4);
  999.    }
  1000.  
  1001.    pxy[0] = pxy[1] = 0;
  1002.    pxy[2] = pxres;
  1003.    pxy[3] = pyres;
  1004.    vs_clip(phandle,1,pxy);
  1005.    buffer = 0L;
  1006.    GDv_updwk(phandle,&buffer,1,&status); 
  1007.    v_clrwk(phandle);
  1008.  
  1009.    mode_flag = prev_flag;
  1010.    sdevm = temp;
  1011. }
  1012.  
  1013.  
  1014. /**************************************************************************/
  1015. /* Function:    redraw_tdo()                          */
  1016. /* Description    Redraw loop for polygons, ellipses etc...          */
  1017. /*        Redraw Loop for playing back to the tdo file...       */
  1018. /**************************************************************************/
  1019. redraw_tdo(pagenum,lastp)
  1020. int pagenum;
  1021. int lastp;
  1022. {
  1023.    int prev_flag;
  1024.    int endflag;
  1025.    int g_flag;                    /* graphic region? */
  1026.  
  1027.    endflag = 0;
  1028.    g_flag  = FALSE;
  1029.    prev_flag = mode_flag;
  1030.    mode_flag = TRUE;
  1031.  
  1032.    
  1033.    tdo_template(1);
  1034.  
  1035.        region_ptr = get_fregion(pagenum,
  1036.                 &rect_in_mu[0],&rect_in_mu[1],
  1037.                 &rect_in_mu[2],&rect_in_mu[3],&g_flag);
  1038.        while(region_ptr)
  1039.        {
  1040.        cpabt = 0;                /* CJG 08/26/89 */
  1041.  
  1042.        if(rect_in_mu[0] >= hpage_size)
  1043.                 goto next;
  1044.            if(!g_flag)
  1045.                get_txtattr(region_ptr,&gltxtattr);
  1046.            else
  1047.                get_grattr(region_ptr,glgrattr);
  1048.        if(g_flag)
  1049.        {
  1050.                opcode = get_fprimitive(region_ptr,&count,&wmode);
  1051.                while(opcode != -1)
  1052.                {
  1053.           switch(opcode)
  1054.                   {
  1055.             case 3:
  1056.             case 4:
  1057.             case 0:
  1058.             case 1:
  1059.                     calc_prim(opcode,&TYF_Gx0,&TYF_Gy0,
  1060.                     &TYF_Gx1,&TYF_Gy1,count);
  1061.                  TYF_Gtype = 5;
  1062.                  insGR_TYF(opcode,count,glgrattr);
  1063.                   break;
  1064.             case 2:  TYF_Gfile = (char *)&ptsarray[5];
  1065.                  TYF_Gx0 = ptsarray[0];
  1066.                  TYF_Gy0 = ptsarray[1];
  1067.                  TYF_Gx1 = ptsarray[2];
  1068.                  TYF_Gy1 = ptsarray[3];
  1069.                  switch(ptsarray[4])
  1070.                  {
  1071.                 case 0:
  1072.                    TYF_Gtype = 2;
  1073.                    break;
  1074.                 case 1:
  1075.                    TYF_Gtype = 3;
  1076.                    break;
  1077.                 case 2:
  1078.                    TYF_Gtype = 1;
  1079.                    break;
  1080.                     case 3:
  1081.                    TYF_Gtype = 4;
  1082.                    break;
  1083.                  }
  1084.                  insGR_TYF(opcode,count,glgrattr);
  1085.                  break;
  1086.                   }
  1087.                   opcode = get_nprimitive(&count,&wmode);
  1088.                }
  1089.        }
  1090.            if(!g_flag)
  1091.            {
  1092.               if(txtptr = get_txtptr(region_ptr))
  1093.               {
  1094.          if(*txtptr)
  1095.          {
  1096.                 get_buffvars(region_ptr);
  1097.             open_region(region_ptr);
  1098.                     do_tdoout(txtptr,&endflag);         
  1099.          }
  1100.               }
  1101.          }                 /* if(graphics && g_flag) etc... */
  1102. next:    region_ptr = get_nregion(&rect_in_mu[0],&rect_in_mu[1],
  1103.                          &rect_in_mu[2],&rect_in_mu[3],&g_flag);
  1104.  
  1105.  
  1106.    }                /* while(region_ptr          */
  1107.    tdo_template(2);
  1108.    do_numbers(0L,1);
  1109.    if(pagenum < lastp)
  1110.       newPge_TYF();
  1111.    mode_flag = prev_flag;
  1112. }
  1113.  
  1114. /**************************************************************************/
  1115. /*  Function:  do_update_text()                          */
  1116. /*  Description: update text pointers                      */
  1117. /**************************************************************************/
  1118. do_update_text()
  1119. {
  1120.    int prev_flag;
  1121.    int dflag;
  1122.    char *txtptr;
  1123.    char *endptr;
  1124.    int g_flag;
  1125.    int page;
  1126.  
  1127.    if(deferhj)            /* Don't recalc text if h&j deferred */
  1128.     return;
  1129.  
  1130.    endptr = -1L;
  1131.    prev_flag = mode_flag;
  1132.    mode_flag = TRUE;
  1133.    g_flag = FALSE;
  1134.  
  1135.    region_ptr = getf_aregion(&rect_in_mu[0],&rect_in_mu[1],
  1136.                  &rect_in_mu[2],&rect_in_mu[3],&page);
  1137.  
  1138.    while(region_ptr)
  1139.    {
  1140.       free_scanrects(region_ptr);
  1141.  
  1142.       region_ptr = getn_aregion(&rect_in_mu[0],&rect_in_mu[1],
  1143.                     &rect_in_mu[2],&rect_in_mu[3],&page);    
  1144.    }
  1145.  
  1146.    GDvq_extnd(mhandle,0,intout,scan_xres,scan_yres,&scanptr);
  1147.    scan_clip();
  1148.    txtptr = get_arttxt();
  1149.  
  1150.    region_ptr = getf_aregion(&rect_in_mu[0],&rect_in_mu[1],
  1151.                  &rect_in_mu[2],&rect_in_mu[3],&page);
  1152.    get_abuffvars(curart);
  1153.    CPrewindow(txtptr);        /* 12/14/89*/
  1154.    savecptr = current_char;
  1155.    while(region_ptr)
  1156.    {
  1157.       clrmem(scanptr,scan_bytes);
  1158.       put_txtptr(region_ptr,txtptr);
  1159.       get_txtattr(region_ptr,&gltxtattr);
  1160.  
  1161.       opcode = get_fprimitive(region_ptr,&count,&wmode);
  1162.       while(opcode != -1)
  1163.       {
  1164.          switch(opcode)
  1165.          {
  1166.             case 0:
  1167.                    redraw_polygon(count,wmode,g_flag);
  1168.            break;
  1169.         case 1:
  1170.                    redraw_ellipse(wmode,g_flag);
  1171.            break;
  1172.  
  1173.         case 2:       /* deliberately skip...*/
  1174.         case 3:
  1175.         case 4:
  1176.                break;
  1177.          }
  1178.              opcode = get_nprimitive(&count,&wmode);
  1179.       }
  1180.       if(!g_flag && txtptr)
  1181.       {
  1182.      chk_repel(region_ptr,rect_in_mu);
  1183.          zdevice = SCANNER;
  1184.          SH = vmutopix((int)gltxtattr.lnsp);
  1185.      open_region(region_ptr);
  1186.          endptr = do_handjreg(txtptr,&dflag,1,rect_in_mu);
  1187.       } 
  1188.  
  1189.       if(dflag || (endptr == -1L))
  1190.       {
  1191.           CPrewindow(buf_end);
  1192.           put_abuffvars(curart);
  1193.       mode_flag = prev_flag;
  1194.           GDvq_extnd(mhandle,0,intout,mxres,myres,&page_ptr);
  1195.           return;
  1196.       }
  1197.  
  1198.       if(!g_flag && txtptr)
  1199.            txtptr = endptr;
  1200.  
  1201.       region_ptr = getn_aregion(&rect_in_mu[0],&rect_in_mu[1],
  1202.                     &rect_in_mu[2],&rect_in_mu[3],&page);
  1203.    }
  1204.    CPrewindow(buf_end);
  1205.    put_abuffvars(curart);
  1206.    mode_flag = prev_flag;
  1207.    free_repbuffs();
  1208.    GDvq_extnd(mhandle,0,intout,mxres,myres,&page_ptr);
  1209. }
  1210.  
  1211. page_redraw(rptr)
  1212. long rptr;
  1213. {
  1214. long tmp;
  1215.  
  1216.    tmp = get_regart(rptr);
  1217.    if(tmp)                /* If region is linked        */
  1218.    {
  1219.         open_article(tmp);
  1220.         if(deferhj || view_size == PADJCNT)
  1221.         {
  1222.        do_artcleanup(rptr,0);    /* Re h and j but don't redraw */
  1223.        force_preview();        /* redraw entire page           */
  1224.         }
  1225.         else
  1226.        do_artcleanup(rptr,1);    /* Re h and j and re output    */
  1227.    }
  1228.    else
  1229.    {                    /* Just cleanup region area    */
  1230.         if(view_size == PADJCNT)
  1231.     {       
  1232.        force_preview();
  1233.         }
  1234.     else
  1235.        redr_regarea(rptr,1);
  1236.    }
  1237. }
  1238.  
  1239. /**************************************************************************/
  1240. /*  Function:  do_artcleanup()                          */
  1241. /*  Description: update text pointers                            */
  1242. /*             cleanup page if "redraw_flag" flag is true          */
  1243. /**************************************************************************/
  1244. do_artcleanup(rptr,redraw_flag)
  1245. long rptr;        /* First region that needs updating          */
  1246. int redraw_flag;
  1247. {        
  1248.    int prev_flag;
  1249.    int dflag;
  1250.    char *txtptr;
  1251.    char *endptr;
  1252.    int g_flag;
  1253.    int page;
  1254.    int rect_in_mu[4];
  1255.    long dummy;
  1256.    long scantxt;
  1257.    int i;
  1258.    int hj_aborted;
  1259.    REGION *savereg;
  1260.    long save_free_start;
  1261.  
  1262.    if(deferhj)            /* Don't recalc text if h&j deferred */
  1263.     return;
  1264.   
  1265.    graf_mouse(2,&dummy);
  1266.    get_buffvars(rptr);    /* cjg 060789 */
  1267.    save_free_start = (long)free_start;
  1268.    prev_flag = mode_flag;
  1269.    mode_flag = TRUE;
  1270.    hj_aborted = g_flag = FALSE;
  1271.    endptr = -1L;
  1272.  
  1273. /*
  1274.    region_ptr = getf_aregion(&rect_in_mu[0],&rect_in_mu[1],
  1275.                  &rect_in_mu[2],&rect_in_mu[3],&page);
  1276.  
  1277.    while(region_ptr != rptr && region_ptr)
  1278.    {
  1279.       region_ptr = getn_aregion(&rect_in_mu[0],&rect_in_mu[1],
  1280.                     &rect_in_mu[2],&rect_in_mu[3],&page);    
  1281.    }
  1282.  
  1283.    while(region_ptr)
  1284.    {
  1285.       free_scanrects(region_ptr);
  1286.       region_ptr = getn_aregion(&rect_in_mu[0],&rect_in_mu[1],
  1287.                     &rect_in_mu[2],&rect_in_mu[3],&page);    
  1288.    }
  1289. Add a region, article doesn't flow into last region, but slave code
  1290. remains for this region, therefore we must erase all of the slave 
  1291. code for all regions
  1292. ********** Delete for now */
  1293.    GDvq_extnd(mhandle,0,intout,scan_xres,scan_yres,&scanptr);
  1294.    scan_clip();
  1295.    txtptr = get_arttxt();
  1296.    region_ptr = getf_aregion(&rect_in_mu[0],&rect_in_mu[1],
  1297.                  &rect_in_mu[2],&rect_in_mu[3],&page);
  1298.  
  1299.    while(region_ptr != rptr && region_ptr)
  1300.    {
  1301.       region_ptr = getn_aregion(&rect_in_mu[0],&rect_in_mu[1],
  1302.                     &rect_in_mu[2],&rect_in_mu[3],&page);    
  1303.       txtptr = get_txtptr(region_ptr);
  1304.    }
  1305.    get_abuffvars(curart);
  1306.    CPrewindow(txtptr);        /* 12/14/89*/
  1307.    savecptr = current_char;
  1308.    while(region_ptr)
  1309.    {
  1310.       free_scanrects(region_ptr);
  1311.       clrmem(scanptr,scan_bytes);
  1312.       put_txtptr(region_ptr,txtptr);
  1313.       get_txtattr(region_ptr,&gltxtattr);
  1314.  
  1315.       opcode = get_fprimitive(region_ptr,&count,&wmode);
  1316.       while(opcode != -1)
  1317.       {
  1318.          switch(opcode)
  1319.          {
  1320.             case 0:
  1321.                    redraw_polygon(count,wmode,g_flag);
  1322.            break;
  1323.         case 1:
  1324.                    redraw_ellipse(wmode,g_flag);
  1325.            break;
  1326.  
  1327.         case 2:       /* deliberately skip...*/
  1328.         case 3:
  1329.         case 4:
  1330.                break;
  1331.          }
  1332.              opcode = get_nprimitive(&count,&wmode);
  1333.       }
  1334.       if(!g_flag && txtptr && *txtptr)
  1335.       {
  1336.      chk_repel(region_ptr,rect_in_mu);
  1337.          zdevice = SCANNER;
  1338.          SH = vmutopix((int)gltxtattr.lnsp);
  1339.      open_region(region_ptr);
  1340.          endptr = do_handjreg(txtptr,&dflag,1,rect_in_mu);
  1341.       } 
  1342.  
  1343.       if(dflag || (endptr == -1L))
  1344.       {
  1345.           CPrewindow(buf_end);
  1346.           put_abuffvars(curart);
  1347.  
  1348.           region_ptr = getn_aregion(&rect_in_mu[0],&rect_in_mu[1],
  1349.                     &rect_in_mu[2],&rect_in_mu[3],&page);    
  1350.           while(region_ptr)
  1351.           {
  1352.              free_scanrects(region_ptr);
  1353.              region_ptr = getn_aregion(&rect_in_mu[0],&rect_in_mu[1],
  1354.                     &rect_in_mu[2],&rect_in_mu[3],&page);    
  1355.           }
  1356.       mode_flag = prev_flag;
  1357.           GDvq_extnd(mhandle,0,intout,mxres,myres,&page_ptr);
  1358.       make_slave(rptr,0L);
  1359.       if(redraw_flag)
  1360.          page_cleanup(rptr,0L);
  1361.           graf_mouse(ARROW,&dummy);
  1362.           return;
  1363.       }
  1364.  
  1365.       if(!g_flag && txtptr)
  1366.            txtptr = endptr;
  1367.  
  1368.       region_ptr = getn_aregion(&rect_in_mu[0],&rect_in_mu[1],
  1369.                     &rect_in_mu[2],&rect_in_mu[3],&page);
  1370.       if(region_ptr)
  1371.       {
  1372.          getf_scaninfo(region_ptr,&i,&i,&i,&i,&scantxt,&dummy);
  1373.          if(save_free_start - scantxt == buf_end - savecptr)
  1374.      {
  1375.         savereg = region_ptr;
  1376.         hj_aborted = 1;
  1377.         region_ptr = 0L;          /* Text matches up              */
  1378.      }
  1379.       }
  1380.    }
  1381.    CPrewindow(buf_end);
  1382.    if(hj_aborted)
  1383.    {
  1384.       adjust_txtptrs(savereg,endptr);
  1385.    }
  1386.    put_abuffvars(curart);
  1387.    mode_flag = prev_flag;
  1388.    free_repbuffs();
  1389.    GDvq_extnd(mhandle,0,intout,mxres,myres,&page_ptr);
  1390.    if(hj_aborted)
  1391.         make_slave(rptr,savereg);
  1392.    else
  1393.          make_slave(rptr,0L);
  1394.  
  1395.    if(redraw_flag)
  1396.    {
  1397.       if(hj_aborted)
  1398.         page_cleanup(rptr,savereg);
  1399.       else
  1400.               page_cleanup(rptr,0L);
  1401.    }
  1402.    graf_mouse(ARROW,&dummy);
  1403. }
  1404.  
  1405.  
  1406. adjust_txtptrs(rptr,txtptr)
  1407. REGION *rptr;
  1408. char *txtptr;
  1409. {
  1410.    int dummy;
  1411.    long ldummy;
  1412.    SCANINFO *rscan;
  1413.    while(rptr)
  1414.    {
  1415.       rscan = getf_scaninfo(rptr,&dummy,&dummy,&dummy,&dummy,&ldummy,&ldummy);
  1416.       rptr->txtstart = txtptr;
  1417.       while(rscan)
  1418.       {
  1419.          rscan->textptr = txtptr;
  1420.          while(txtptr <= free_start)
  1421.      {
  1422.         if(  *txtptr == 0x0A && 
  1423.         (*(txtptr - 2) == 0x0C || 
  1424.          *(txtptr - 2) == 0x1F || 
  1425.          *(txtptr - 2) == 0x0F))
  1426.              {
  1427.                 txtptr++;        /* Read past the line feed */
  1428.             break;
  1429.          }
  1430.          else
  1431.                     txtptr++;
  1432.      }
  1433.          if(txtptr >= free_start)
  1434.          return;
  1435.          rscan = getn_scaninfo(&dummy,&dummy,&dummy,&dummy,&ldummy,&ldummy);
  1436.       }
  1437.       rptr = rptr->alink;
  1438.    }
  1439. }
  1440.          
  1441. /**************************************************************************/
  1442. /*  Function:   graphic_setup()                          */
  1443. /*  Description: if "image_status" == 0, draw with filled Atari Logos      */
  1444. /*         else draw the actual image.                  */
  1445. /**************************************************************************/
  1446. graphic_setup()
  1447. {
  1448.    if(!image_status)
  1449.    {
  1450.       ptsarray[4] = ptsarray[2];
  1451.       ptsarray[5] = ptsarray[3];
  1452.          
  1453.       ptsarray[2] = ptsarray[0];
  1454.       ptsarray[3] = ptsarray[5];
  1455.  
  1456.       ptsarray[6] = ptsarray[4];
  1457.       ptsarray[7] = ptsarray[1];
  1458.       cur_primitive = OIMAGE;
  1459.       redraw_polygon(4,wmode,1);
  1460.       cur_primitive = 0;
  1461.    }
  1462.    else insert_graphic();
  1463. }
  1464.  
  1465.  
  1466.  
  1467. /**************************************************************************/
  1468. /*  Function:   force_preview()                          */
  1469. /*  Description: Forces a redraw on the preview window...          */
  1470. /**************************************************************************/
  1471. force_preview()
  1472. {
  1473.      force_draw_flag = TRUE;
  1474.      msg_buff[0] = msg_buff[1] = msg_buff[2] = 0;
  1475.      msg_buff[3] = prev_handle;
  1476.      msg_buff[4] = pwork.g_x;
  1477.      msg_buff[5] = pwork.g_y;
  1478.      msg_buff[6] = pwork.g_w;
  1479.      msg_buff[7] = pwork.g_h;
  1480.      do_redraw(msg_buff);
  1481. }
  1482.  
  1483.  
  1484.  
  1485. /**************************************************************************/
  1486. /* Function: force_blit_redraw()                      */
  1487. /* Description: Another force redraw message                  */
  1488. /**************************************************************************/
  1489. force_blit_redraw(noprev)
  1490. int noprev;
  1491. {
  1492.      if(!noprev)
  1493.      {
  1494.         msg_buff[0] = msg_buff[1] = msg_buff[2] = 0;
  1495.         msg_buff[3] = prev_handle;
  1496.         msg_buff[4] = pwork.g_x;
  1497.         msg_buff[5] = pwork.g_y;
  1498.         msg_buff[6] = pwork.g_w;
  1499.         msg_buff[7] = pwork.g_h;
  1500.         do_redraw(msg_buff);
  1501.      }
  1502. }
  1503.  
  1504.  
  1505. /**************************************************************************/
  1506. /* Function:  recalc_txtptrs()                          */
  1507. /* Description: Adjusts the vgtext to break on consistent boundaries.     */
  1508. /**************************************************************************/
  1509. recalc_txtptrs()
  1510. {
  1511.     register unsigned long txtptr;
  1512.     int dummy;
  1513.  
  1514.     if(deferhj)            /* Defer h&j so don't recalc text ptrs */
  1515.     return;
  1516.     graf_mouse(2,&dummy);
  1517.     txtptr = getf_article();
  1518.     while(txtptr)
  1519.     {
  1520.          do_update_text();
  1521.          txtptr = getn_article();
  1522.     }
  1523.     graf_mouse(ARROW,&dummy);
  1524. }
  1525.  
  1526.  
  1527.  
  1528.  
  1529. /**************************************************************************/
  1530. /* Function: recalc_rtext()                          */
  1531. /* Description: Only recalc 1 articles region textptrs              */
  1532. /**************************************************************************/
  1533. recalc_rtext()
  1534. {
  1535.    int dummy;
  1536.    long tempart;
  1537.  
  1538.    if(deferhj)
  1539.     return;
  1540.    graf_mouse(2,&dummy);
  1541.    tempart = get_regart(gl_region_ptr);
  1542.    if(tempart)
  1543.    {
  1544.       open_article(tempart);
  1545.       do_update_text();
  1546.    }
  1547.    graf_mouse(ARROW,&dummy);
  1548. }
  1549.  
  1550.  
  1551.  
  1552.  
  1553. /**************************************************************************/
  1554. /* Function: clear_preview()                          */
  1555. /* Description: Clear preview window                      */
  1556. /**************************************************************************/
  1557. clear_preview()
  1558. {
  1559. /*    gsx_moff();*/
  1560.     vsf_interior(shandle,2);
  1561.     vsf_style(shandle,1);
  1562.     vsf_perimeter(shandle,0);
  1563.  
  1564.     vr_recfl(shandle,aclear);
  1565.     vr_recfl(shandle,aclear2);
  1566. /*    gsx_mon();*/
  1567. }
  1568.  
  1569.  
  1570.  
  1571. /**************************************************************************/
  1572. /* Function: update_preview_blit()                      */
  1573. /* Description: update blit rectangles...                  */
  1574. /**************************************************************************/
  1575. update_preview_blit()
  1576. {
  1577.     blit_area[4] = dpwork.g_x;
  1578.     blit_area[5] = dpwork.g_y;
  1579.     blit_area[6] = dpwork.g_x + dpwork.g_w - 1;
  1580.     blit_area[7] = dpwork.g_y + dpwork.g_h - 1;
  1581.     mutopage(page_area.g_w,page_area.g_h,&page.g_w,&page.g_h,1);
  1582. }
  1583.  
  1584.  
  1585.  
  1586.  
  1587.  
  1588. /**************************************************************************/
  1589. /* Function: init_rulers()                          */
  1590. /* Description: initialize h and v rulers                  */
  1591. /**************************************************************************/
  1592. init_rulers()
  1593. {
  1594.    int pxy[4];
  1595.  
  1596.    vsf_interior(rule_handle,0);
  1597.    vswr_mode(rule_handle,1);
  1598.    
  1599.    vsl_width(mhandle,1);        /* set line width to 1          */
  1600.    vsl_type(mhandle,1);            /* set line type to solid      */
  1601.    vsl_ends(mhandle,0,0);         /* restore end styles          */
  1602.    
  1603.    pxy[0] = pwork.g_x;
  1604.    pxy[1] = pwork.g_y;
  1605.    pxy[2] = dpwork.g_x;
  1606.    pxy[3] = dpwork.g_y;
  1607.    vr_recfl(rule_handle,pxy);
  1608.  
  1609.    vswr_mode(rule_handle,3);
  1610.  
  1611.    if(view_size == P200)
  1612.    {
  1613.     mutopage(324,288,&hhalf,&vhalf,1);
  1614.     mutopage(41,36,&hlen,&vlen,1);
  1615.    }
  1616.    else
  1617.    {
  1618.         mutopage(648,576,&hhalf,&vhalf,1);
  1619.         mutopage(81,72,&hlen,&vlen,1);        /* Ruler length 1/16 incs    */
  1620.    }
  1621.  
  1622.    
  1623.    x_eighths = 162;
  1624.    y_eighths = 144;
  1625.   
  1626.    if(hrbuffer)
  1627.    {
  1628.       free(hrbuffer);
  1629.    }
  1630.    if(vrbuffer)
  1631.    {
  1632.       free(vrbuffer);
  1633.    }
  1634.    hrbuffer = (int *)get_lcmem((long)(vhalf*(((mxres+7)/8)+1)));
  1635.    vrbuffer = (int *)get_lcmem((long)(myres * (((hhalf+7)/8)+1)));
  1636.    if(hrbuffer && vrbuffer)
  1637.    {
  1638.       ruler_hasmem = 1;
  1639.       init_hrulers();
  1640.       init_vrulers();
  1641.       GDvq_extnd(mhandle,0,intout,mxres,myres,&page_ptr);
  1642.    }
  1643.    else
  1644.    {
  1645.       alert_cntre(ALERT30);
  1646.       ruler_hasmem = 0;
  1647.    }
  1648.    xold_mark = -1;                /* Init ruler marks */
  1649.    yold_mark = -1;   
  1650.  
  1651. }
  1652.  
  1653.  
  1654.  
  1655.  
  1656.  
  1657. /**************************************************************************/
  1658. /* Function: init_hrulers()                          */
  1659. /* Description: initialize horizontal rulers                  */
  1660. /**************************************************************************/
  1661. init_hrulers()
  1662. {
  1663.    int pxy[4];
  1664.    int dummy;
  1665.  
  1666.    GDvq_extnd(mhandle,0,intout,mxres,vhalf,&hrbuffer);
  1667.    vst_alignment(mhandle,1,5,&dummy,&dummy);
  1668.    hrule_mfdb.fd_addr = hrbuffer;
  1669.    hrule_mfdb.fd_w    = mxres;
  1670.    hrule_mfdb.fd_h    = vhalf;
  1671.    hrule_mfdb.fd_wdwidth = (mxres + 15)/16;
  1672.    hrule_mfdb.fd_stand = 0;
  1673.    hrule_mfdb.fd_nplanes = 1;
  1674.  
  1675.    pxy[0] = 0;
  1676.    pxy[1] = 0;
  1677.    pxy[2] = mxres - 1;
  1678.    pxy[3] = vhalf - 1;
  1679.    vs_clip(mhandle,1,pxy);
  1680.  
  1681.    pxy[0] = 0;
  1682.    pxy[1] = vhalf - 1;
  1683.    pxy[2] = mxres;
  1684.    pxy[3] = vhalf - 1;
  1685.    v_pline(mhandle,2,pxy);
  1686.  
  1687.    switch(unit_type)
  1688.    {
  1689.       case 0:
  1690.         init_hinches();
  1691.         break;
  1692.  
  1693.     case 1:
  1694.         init_hpicas();
  1695.         break;
  1696.  
  1697.     case 2:
  1698.         init_hcents();
  1699.         break;
  1700.  
  1701.     case 3: init_hciceros();
  1702.         break;
  1703.    }
  1704. }
  1705.  
  1706.  
  1707.  
  1708.  
  1709. /**************************************************************************/
  1710. /* Function: init_vrulers()                          */
  1711. /* Description: Initialize vertical rulers                  */
  1712. /**************************************************************************/
  1713. init_vrulers()
  1714. {
  1715.    int pxy[4];
  1716.    int dummy;
  1717.  
  1718.    GDvq_extnd(mhandle,0,intout,hhalf,myres,&vrbuffer);
  1719.    vst_alignment(mhandle,1,1,&dummy,&dummy);
  1720.    vrule_mfdb.fd_addr = vrbuffer;
  1721.    vrule_mfdb.fd_w    = hhalf;
  1722.    vrule_mfdb.fd_h    = myres;
  1723.    vrule_mfdb.fd_wdwidth = (hhalf + 15)/16;
  1724.    vrule_mfdb.fd_stand = 0;
  1725.    vrule_mfdb.fd_nplanes = 1;
  1726.  
  1727.    pxy[0] = 0;
  1728.    pxy[1] = 0;
  1729.    pxy[2] = hhalf - 1;
  1730.    pxy[3] = myres - 1;
  1731.    vs_clip(mhandle,1,pxy);
  1732.  
  1733.  
  1734.    pxy[0] = hhalf - 1;
  1735.    pxy[1] = 0;
  1736.    pxy[2] = hhalf - 1;
  1737.    pxy[3] = myres - 1;
  1738.    v_pline(mhandle,2,pxy);
  1739.  
  1740.    switch(unit_type)
  1741.    {
  1742.       case 0:
  1743.         init_vinches();
  1744.         break;
  1745.  
  1746.     case 1:
  1747.         init_vpicas();
  1748.         break;
  1749.  
  1750.     case 2:
  1751.         init_vcents();
  1752.         break;
  1753.  
  1754.     case 3: init_vciceros();
  1755.         break;
  1756.    }
  1757. }
  1758.  
  1759.  
  1760.  
  1761.  
  1762. /**************************************************************************/
  1763. /* Function: init_hinches()                          */
  1764. /* Description: Initialize h-ruler to inches                  */
  1765. /**************************************************************************/
  1766. init_hinches()
  1767. {
  1768.    int hpos;
  1769.    int vpos;
  1770.    int pxy[4];
  1771.    register int i;
  1772.    register int xmu_pos;
  1773.    register int len;
  1774.    char str[3];
  1775.  
  1776.    i = 1;
  1777.    xmu_pos = x_eighths;
  1778.    mutopage(xmu_pos,0,&hpos,&vpos,1);
  1779.  
  1780.    while(hpos < pagew)
  1781.    {
  1782.         hpos ++;
  1783.     len = vlen;
  1784.     if(!(i%2))
  1785.        len += vlen;
  1786.     if(!(i%4))
  1787.        len += vlen;
  1788.     if(!(i%8))
  1789.        {
  1790.        len += vlen;
  1791.        if((view_size != PSIZE) &&
  1792.           (view_size != PADJCNT) && mnumfnt)
  1793.        {
  1794.           itoa(i/8,str);
  1795.           v_gtext(mhandle,hpos+2*hlen,2*vlen,str);
  1796.        }
  1797.     }
  1798.  
  1799.     pxy[0] = pxy[2] = hpos;
  1800.     pxy[1] = vhalf - 1;
  1801.     pxy[3] = pxy[1] - len;
  1802.     v_pline(mhandle,2,pxy);
  1803.     xmu_pos += x_eighths;            /* Add an eighth to hpos */
  1804.     mutopage(xmu_pos,0,&hpos,&vpos,1);
  1805.         i++;
  1806.    }
  1807.  
  1808. }
  1809.  
  1810.  
  1811.  
  1812.  
  1813.  
  1814. /**************************************************************************/
  1815. /* Function: init_hpicas()                          */
  1816. /* Description: Initialize h-ruler to picas                  */
  1817. /**************************************************************************/
  1818. init_hpicas()
  1819. {
  1820.    int hpos;
  1821.    int vpos;
  1822.    int pxy[4];
  1823.    register int i;
  1824.    register int len;
  1825.    register int xmu_pos;
  1826.    char str[3];
  1827.  
  1828.    i = 1;
  1829.    xmu_pos = 216;            /* mu's per pica    */
  1830.    mutopage(xmu_pos,0,&hpos,&vpos,1);
  1831.    while(hpos < pagew)
  1832.    {
  1833.     hpos++;
  1834.         len = vlen;
  1835.     if(!(i%10))
  1836.     {
  1837.        len += vlen;
  1838.        if( (view_size != PSIZE) && (view_size != PADJCNT) && mnumfnt)
  1839.        {
  1840.           itoa(i,str);
  1841.           v_gtext(mhandle,hpos+2*hlen,2*vlen,str);
  1842.        }
  1843.         }
  1844.     pxy[0] = pxy[2] = hpos;
  1845.     pxy[1] = vhalf - 1;
  1846.     pxy[3] = pxy[1] - len;
  1847.     v_pline(mhandle,2,pxy);
  1848.     xmu_pos += 216;
  1849.     mutopage(xmu_pos,0,&hpos,&vpos,1);
  1850.         i++;
  1851.    }
  1852.  
  1853. }
  1854.  
  1855.  
  1856.  
  1857.  
  1858.  
  1859. /**************************************************************************/
  1860. /* Function: init_hcents()                          */
  1861. /* Description: Initialize h-ruler to centimeters              */
  1862. /**************************************************************************/
  1863. init_hcents()
  1864. {
  1865.    int hpos,vpos;
  1866.    int pxy[4];
  1867.    register int i;
  1868.    register int xmu_pos;
  1869.    register int len;
  1870.    char str[3];
  1871.    int centi_pos;
  1872.  
  1873.    i = 1;
  1874.    centi_pos = 0;        /* Avoid propagating error       */
  1875.    xmu_pos = 51;                /* Mu's/millimeter */
  1876.    mutopage(xmu_pos,0,&hpos,&vpos,1);
  1877.    while(hpos < pagew)
  1878.    {
  1879.     hpos++;
  1880.     len = vlen;
  1881.     if(!(i%10))
  1882.        {
  1883.        len += vlen;
  1884.        if((view_size != PSIZE) &&
  1885.           (view_size != PADJCNT) && mnumfnt)
  1886.        {
  1887.           itoa(i/10,str);
  1888.           v_gtext(mhandle,hpos+2*hlen,2*vlen,str);
  1889.        }
  1890.        centi_pos += 510;
  1891.        xmu_pos = centi_pos;        /* re-calibrate spacing */
  1892.     }
  1893.  
  1894.     pxy[0] = pxy[2] = hpos;
  1895.     pxy[1] = vhalf - 1;
  1896.     pxy[3] = pxy[1] - len;
  1897.     v_pline(mhandle,2,pxy);
  1898.     xmu_pos += 51;
  1899.     mutopage(xmu_pos,0,&hpos,&vpos,1);
  1900.         i++;
  1901.    }
  1902.  
  1903. }
  1904.  
  1905.  
  1906.  
  1907. /**************************************************************************/
  1908. /* Function: init_hciceros()                          */
  1909. /* Description: Initialize h-ruler to ciceros                  */
  1910. /**************************************************************************/
  1911. init_hciceros()
  1912. {
  1913.    int hpos;
  1914.    int vpos;
  1915.    int pxy[4];
  1916.    register int i;
  1917.    register int len;
  1918.    register int xmu_pos;
  1919.    char str[3];
  1920.  
  1921.    i = 1;
  1922.    xmu_pos = 231;            /* mu's per cicero    */
  1923.    mutopage(xmu_pos,0,&hpos,&vpos,1);
  1924.    while(hpos < pagew)
  1925.    {
  1926.     hpos++;
  1927.         len = vlen;
  1928.     if(!(i%10))
  1929.     {
  1930.        len += vlen;
  1931.        if( (view_size != PSIZE) && (view_size != PADJCNT) && mnumfnt)
  1932.        {
  1933.           itoa(i,str);
  1934.           v_gtext(mhandle,hpos+2*hlen,2*vlen,str);
  1935.        }
  1936.         }
  1937.     pxy[0] = pxy[2] = hpos;
  1938.     pxy[1] = vhalf - 1;
  1939.     pxy[3] = pxy[1] - len;
  1940.     v_pline(mhandle,2,pxy);
  1941.     xmu_pos += 231;
  1942.     mutopage(xmu_pos,0,&hpos,&vpos,1);
  1943.         i++;
  1944.    }
  1945. }
  1946.  
  1947.  
  1948.  
  1949. /**************************************************************************/
  1950. /* Function: init_vinches()                          */
  1951. /* Description: initialize v-ruler to inches                  */
  1952. /**************************************************************************/
  1953. init_vinches()
  1954. {
  1955.    int hpos;
  1956.    int vpos;
  1957.    int pxy[4];
  1958.    register int i;
  1959.    register int ymu_pos;
  1960.    int len;
  1961.    char str[3];
  1962.  
  1963.    i = 1;
  1964.    ymu_pos = y_eighths;
  1965.    mutopage(0,ymu_pos,&hpos,&vpos,1);
  1966.    while(vpos < pageh)
  1967.    {
  1968.     len = hlen;
  1969.     if(!(i%2))
  1970.        len += hlen;
  1971.     if(!(i%4))
  1972.        len += hlen;
  1973.     if(!(i%8))
  1974.        {
  1975.        len += hlen;
  1976.        if((view_size != PSIZE) &&
  1977.           (view_size != PADJCNT) && mnumfnt)
  1978.        {
  1979.           itoa(i/8,str);
  1980.           v_gtext(mhandle,3*hlen,vpos+vlen,str);
  1981.        }
  1982.     }
  1983.  
  1984.     pxy[0] = hhalf - 1;
  1985.     pxy[1] = pxy[3] = vpos;
  1986.     pxy[2] = pxy[0] - len;
  1987.     v_pline(mhandle,2,pxy);
  1988.     ymu_pos += y_eighths;            /* Add an eighth to hpos */
  1989.     mutopage(0,ymu_pos,&hpos,&vpos,1);
  1990.         i++;
  1991.    }
  1992.  
  1993. }
  1994.  
  1995.  
  1996.  
  1997.  
  1998. /**************************************************************************/
  1999. /* Function: init_vpicas()                          */
  2000. /* Description: Initialize v-ruler to picas                  */
  2001. /**************************************************************************/
  2002. init_vpicas()
  2003. {
  2004.    int hpos;
  2005.    int vpos;
  2006.    int pxy[4];
  2007.    register int i;
  2008.    register int ymu_pos;
  2009.    register int len;
  2010.    char str[3];
  2011.  
  2012.    i = 1;
  2013.    ymu_pos = 192;
  2014.    mutopage(0,ymu_pos,&hpos,&vpos,1);
  2015.    while(vpos < pageh)
  2016.    {
  2017.         len = hlen;
  2018.     if(!(i%10))
  2019.     {
  2020.        len += hlen;
  2021.        if((view_size != PSIZE) &&
  2022.           (view_size != PADJCNT) && mnumfnt)
  2023.        {
  2024.           itoa(i,str);
  2025.           v_gtext(mhandle,3*hlen,vpos+vlen,str);
  2026.        }
  2027.     }
  2028.     pxy[0] = hhalf - 1;
  2029.     pxy[1] = pxy[3] = vpos;
  2030.     pxy[2] = pxy[0] - len;
  2031.     v_pline(mhandle,2,pxy);
  2032.     ymu_pos += 192;
  2033.     mutopage(0,ymu_pos,&hpos,&vpos,1);
  2034.         i++;
  2035.    }
  2036. }
  2037.  
  2038.  
  2039.  
  2040.  
  2041. /**************************************************************************/
  2042. /* Function: init_vcents()                          */
  2043. /* Description: Initialize v-ruler to centimeters              */
  2044. /**************************************************************************/
  2045. init_vcents()
  2046. {
  2047.    int hpos;
  2048.    int vpos;
  2049.    int pxy[4];
  2050.    register int i;
  2051.    register int ymu_pos;
  2052.    register int len;
  2053.    char str[3];
  2054.    int centi_pos;
  2055.  
  2056.    i = 1;
  2057.    centi_pos = 0;
  2058.    ymu_pos = 45;
  2059.    mutopage(0,ymu_pos,&hpos,&vpos,1);
  2060.    while(vpos < pageh)
  2061.    {
  2062.     len = hlen;
  2063.     if(!(i%10))
  2064.        {
  2065.        len += hlen;
  2066.        if((view_size != PSIZE) &&
  2067.           (view_size != PADJCNT) && mnumfnt)
  2068.        {
  2069.           itoa(i/10,str);
  2070.           v_gtext(mhandle,3*hlen,vlen+vpos,str);
  2071.        }
  2072.        centi_pos += 454;
  2073.        ymu_pos = centi_pos;
  2074.     }
  2075.  
  2076.     pxy[0] = hhalf - 1;
  2077.     pxy[1] = pxy[3] = vpos;
  2078.     pxy[2] = pxy[0] - len;
  2079.     v_pline(mhandle,2,pxy);
  2080.     ymu_pos += 45;   
  2081.     mutopage(0,ymu_pos,&hpos,&vpos,1);
  2082.         i++;
  2083.    }
  2084.  
  2085. }
  2086.  
  2087.  
  2088.  
  2089.  
  2090. /**************************************************************************/
  2091. /* Function: init_vciceros()                          */
  2092. /* Description: Initialize v-ruler to ciceros                  */
  2093. /**************************************************************************/
  2094. init_vciceros()
  2095. {
  2096.    int hpos;
  2097.    int vpos;
  2098.    int pxy[4];
  2099.    register int i;
  2100.    register int ymu_pos;
  2101.    register int len;
  2102.    char str[3];
  2103.  
  2104.    i = 1;
  2105.    ymu_pos = 205;
  2106.    mutopage(0,ymu_pos,&hpos,&vpos,1);
  2107.    while(vpos < pageh)
  2108.    {
  2109.         len = hlen;
  2110.     if(!(i%10))
  2111.     {
  2112.        len += hlen;
  2113.        if((view_size != PSIZE) &&
  2114.           (view_size != PADJCNT) && mnumfnt)
  2115.        {
  2116.           itoa(i,str);
  2117.           v_gtext(mhandle,3*hlen,vpos+vlen,str);
  2118.        }
  2119.     }
  2120.     pxy[0] = hhalf - 1;
  2121.     pxy[1] = pxy[3] = vpos;
  2122.     pxy[2] = pxy[0] - len;
  2123.     v_pline(mhandle,2,pxy);
  2124.     ymu_pos += 205;
  2125.     mutopage(0,ymu_pos,&hpos,&vpos,1);
  2126.         i++;
  2127.    }
  2128. }
  2129.  
  2130.  
  2131.  
  2132. /**************************************************************************/
  2133. /* Function: show_rulers()                          */
  2134. /* Description: Handle the display of rulers                  */
  2135. /**************************************************************************/   
  2136. show_rulers()
  2137. {
  2138. int pxy[8];
  2139. long scrn_mfdb;
  2140. int xoffset,yoffset;
  2141. int dummy;
  2142. int color_index[2];
  2143.  
  2144.  
  2145.    color_index[0] = 1;
  2146.    color_index[1] = 0;
  2147.    scrn_mfdb = 0L;
  2148.    mutopage(page_area.g_x,page_area.g_y,&xoffset,&yoffset,1);
  2149.    vsf_interior(shandle,0);
  2150.  
  2151.    pxy[0] = xoffset;
  2152.    pxy[1] = 0;
  2153.    pxy[2] = pxy[0] + dpwork.g_w - 1;
  2154.    pxy[3] = vhalf - 1;
  2155.    pxy[4] = pwork.g_x + hhalf - 1;
  2156.    pxy[5] = pwork.g_y;
  2157.    pxy[6] = pxy[4] + dpwork.g_w - 1;
  2158.    pxy[7] = pxy[5] + vhalf - 1;
  2159.    if(ruler_hasmem)
  2160.       vrt_cpyfm(rule_handle,1,pxy,&hrule_mfdb,&scrn_mfdb,color_index);
  2161.    else
  2162.       vr_recfl(shandle,&pxy[4]);        /* Don't draw in xor */
  2163.    pxy[0] = 0;
  2164.    pxy[1] = yoffset;
  2165.    pxy[2] = hhalf - 1;
  2166.    pxy[3] = pxy[1] + dpwork.g_h - 1;
  2167.    pxy[4] = pwork.g_x;
  2168.    pxy[5] = dpwork.g_y;
  2169.    pxy[6] = pxy[4] + hhalf - 1;
  2170.    pxy[7] = pxy[5] + dpwork.g_h - 1;
  2171.    if(ruler_hasmem)
  2172.       vrt_cpyfm(rule_handle,1,pxy,&vrule_mfdb,&scrn_mfdb,color_index);
  2173.    else
  2174.       vr_recfl(shandle,&pxy[4]);
  2175.    pxy[0] = pwork.g_x;
  2176.    pxy[1] = pwork.g_y;
  2177.    pxy[2] = dpwork.g_x;
  2178.    pxy[3] = dpwork.g_y;
  2179.    vr_recfl(shandle,pxy);        /* Don't draw in xor */
  2180.  
  2181.    pxy[0] = dpwork.g_x;
  2182.    pxy[1] = pwork.g_y;
  2183.    pxy[2] = dpwork.g_x;
  2184.    pxy[3] = dpwork.g_y;
  2185.    pxy[4] = pwork.g_x;
  2186.    pxy[5] = dpwork.g_y;
  2187.    v_pline(rule_handle,3,pxy);
  2188.  
  2189.    graf_mkstate(&newx,&newy,&dummy,&dummy);
  2190.    xold_mark = -1;
  2191.    yold_mark = -1;
  2192.    do_rule_mark();
  2193. }
  2194.  
  2195.  
  2196.  
  2197.  
  2198. /**************************************************************************/
  2199. /* Function: do_grids()                              */
  2200. /* Description: Display grids on screen                      */
  2201. /**************************************************************************/
  2202. do_grids(clip,x1,y1,x2,y2)
  2203. int clip;
  2204. register int x1;
  2205. int y1;
  2206. register int x2;
  2207. int y2;
  2208. {
  2209.  
  2210.    int xpos,ypos;
  2211.    register int hmus,vmus;
  2212.    int bytes_line;
  2213.  
  2214.    bytes_line = (mxres + 7)/8;
  2215.    bytes_line = (bytes_line + 1) & 0xFFFE;
  2216.  
  2217.    if(clip)
  2218.    {
  2219.     x1 -= hgridspace;
  2220.     x2 += hgridspace;
  2221.     y1 -= vgridspace;
  2222.     y2 += vgridspace;
  2223.    }
  2224.    x1 = max(0,x1);
  2225.    y1 = max(0,y1);
  2226.  
  2227.    for(vmus = vgridspace;vmus < vpage_size;vmus += vgridspace)
  2228.    {
  2229.         if(!clip || (vmus >= y1 && vmus <= y2))
  2230.         {
  2231.        for(hmus = hgridspace;hmus < hpage_size;hmus += hgridspace)
  2232.        {
  2233.           if(!clip || (hmus >= x1 && hmus <= x2))
  2234.           {
  2235.              mutopage(hmus,vmus,&xpos,&ypos,1);
  2236.              put_mpix(xpos,ypos,bytes_line);
  2237.           }
  2238.        }
  2239.         }
  2240.    }
  2241. }
  2242.  
  2243.  
  2244.  
  2245.  
  2246. /**************************************************************************/
  2247. /* Function: put_mpix()                              */
  2248. /* Description: Put grid pixel in memory buffer                  */ 
  2249. /**************************************************************************/
  2250. put_mpix(x,y,bytes_line)
  2251. int x,y;
  2252. int bytes_line;
  2253. {
  2254.    char *ptr;
  2255.    register long offset;
  2256.  
  2257.  
  2258.    offset = page_ptr;
  2259.  
  2260.    offset += (long)((long)bytes_line*(long)y);
  2261.    offset += (long)(x/8);
  2262.    ptr = (char *)offset;
  2263.    *ptr |= pixtbl[x%8];
  2264. }
  2265.  
  2266.  
  2267.  
  2268.  
  2269. /**************************************************************************/
  2270. /* Function: calc_size_fit()                          */
  2271. /* Description: Calc page size for size to fit and PADJCNT          */
  2272. /**************************************************************************/
  2273. calc_size_fit(item)
  2274. int item;
  2275. {
  2276.     int hwidth;
  2277.     int pixw;
  2278.      int pixh;
  2279.  
  2280.     pixw = hmutopix(hpage_size);
  2281.     pixh = vmutopix(vpage_size);    
  2282.         hwidth = ((item == PADJCNT) ? (pixw * 2) : (pixw));
  2283.     if(dpwork.g_w <= scale_iv(dpwork.g_h,hwidth,pixh))
  2284.     {
  2285.         pagew = dpwork.g_w;
  2286.         pageh = scale_iv(dpwork.g_w,pixh,hwidth);
  2287.     }
  2288.     else
  2289.     {
  2290.         pageh = dpwork.g_h;
  2291.         pagew = scale_iv(dpwork.g_h,hwidth,pixh);
  2292.         pageh = dpwork.g_h = scale_iv(pagew,pixh,hwidth);
  2293.     }
  2294.         pxy[0] = dpwork.g_x;
  2295.         pxy[1] = dpwork.g_y;
  2296.     pxy[2] = dpwork.g_x + pagew - 1;
  2297.     pxy[3] = dpwork.g_y + pageh - 1;
  2298.  
  2299. }
  2300.  
  2301.  
  2302.  
  2303.  
  2304. /**************************************************************************/
  2305. /* Function: redraw_alt()                          */
  2306. /* Description: Redraw Handler for PADJCNT                  */
  2307. /**************************************************************************/
  2308. redraw_alt()
  2309. {
  2310.    int endflag;
  2311.    int g_flag;                /* graphic region? */
  2312.    int pxy[4];
  2313.    int rtemp_page;
  2314.    int tpage;
  2315.  
  2316.    PAGE *rpagehd;
  2317.    PAGE *rcurpage;
  2318.    ARTICLE *rarthd;
  2319.  
  2320.    if(tmplate_flag)
  2321.    {
  2322.       rpagehd = pagehd;
  2323.       rcurpage = curpage;
  2324.       rarthd   = arthd;
  2325.    }
  2326.  
  2327.    endflag = 0;
  2328.    if((!blit_flag) || mode_change)
  2329.    {
  2330.       clrmem(page_ptr,pagebytes);
  2331.  
  2332.       pxy[1] = 0;
  2333.       pxy[3] = pageh-1;
  2334.  
  2335.       if(show_grids)
  2336.     do_grids(0,0,0,0,0);
  2337.  
  2338.       rtemp_page = curr_page;
  2339.       tpage = ((curr_page % 2) ? (curr_page - 1) : (curr_page));
  2340.       for(curr_page = tpage;curr_page <= tpage+1;curr_page++)
  2341.       {
  2342.       if(tmplate_flag)
  2343.           {
  2344.         if(curr_page == -2)
  2345.         {
  2346.           pagehd = curpage = left_tmplate;
  2347.           arthd  = ltarthd;
  2348.         }
  2349.         else
  2350.         {
  2351.           pagehd = curpage = right_tmplate;
  2352.           arthd = rtarthd;
  2353.         }
  2354.           
  2355.           }
  2356.  
  2357.           display_template(1,0L);
  2358.  
  2359.           region_ptr = get_fregion(curr_page,
  2360.             &rect_in_mu[0],&rect_in_mu[1],
  2361.             &rect_in_mu[2],&rect_in_mu[3],&g_flag);
  2362.  
  2363.           while(region_ptr)
  2364.           {
  2365.              if(rect_in_mu[0] >= hpage_size)
  2366.                     goto next;
  2367.  
  2368.           mclip();
  2369.              if(!g_flag)
  2370.                 get_txtattr(region_ptr,&gltxtattr);
  2371.          else
  2372.             get_grattr(region_ptr,glgrattr);
  2373.          if(g_flag || !mode_flag)
  2374.          {
  2375.                 opcode = get_fprimitive(region_ptr,&count,&wmode);
  2376.                 while(opcode != -1)
  2377.                 {
  2378.               switch(opcode)
  2379.               {
  2380.                case 3:
  2381.                 case 4:
  2382.                 case 0: redraw_polygon(count,wmode,g_flag);
  2383.                             break;
  2384.  
  2385.             case 1: redraw_ellipse(wmode,g_flag);
  2386.                     break;
  2387.  
  2388.                 case 2: graphic_setup();
  2389.                           break;
  2390.               }
  2391.                   opcode = get_nprimitive(&count,&wmode);
  2392.                 }
  2393.         }
  2394.             if(mode_flag && !g_flag)
  2395.         {
  2396.            if(txtptr = get_txtptr(region_ptr))
  2397.                {
  2398.           if(*txtptr)
  2399.           {
  2400.                  get_buffvars(region_ptr);
  2401.              open_region(region_ptr);
  2402.                      do_regoutput(txtptr,&endflag);
  2403.                      put_buffvars(region_ptr);
  2404.           }
  2405.                }
  2406.            GDvq_extnd(mhandle,0,intout,mxres,myres,&page_ptr);        
  2407.             }
  2408. next:        region_ptr = get_nregion(&rect_in_mu[0],&rect_in_mu[1],
  2409.                            &rect_in_mu[2],&rect_in_mu[3],&g_flag);
  2410.      } /* while region_ptr */
  2411.          display_template(2,0L);
  2412.      do_numbers(0L,0);
  2413.        }   /* for(curr_page =temp_page;curr_page <= temp_page+1;curr_page++)*/
  2414.  
  2415.        set_clip(TRUE,&dpwork);
  2416.         if(view_size == PADJCNT)
  2417.         {
  2418.       vsl_type(mhandle,1);
  2419.       vsl_width(mhandle,1);
  2420.       vsl_ends(mhandle,0,0);
  2421.           pxy[0] = pxy[2] = pagew/2;
  2422.           pxy[1] = 0;
  2423.           pxy[3] = pageh;
  2424.           v_pline(mhandle,2,pxy);
  2425.         }
  2426.         mode_change = FALSE;
  2427.         curr_page = rtemp_page;    
  2428.     alt_offset = ((curr_page % 2) ? (1) : (0));
  2429.      }               /*if((!blit_flag) || mode_change)*/
  2430.    do_blit();            /* Either blit now or redraw,then blit*/
  2431.    if(tmplate_flag)
  2432.    {
  2433.      pagehd = rpagehd;
  2434.      curpage = rcurpage;
  2435.      arthd   = rarthd;
  2436.    }
  2437. }
  2438.  
  2439. /************************************************************************/
  2440. /*                                    */
  2441. /*    In:    Pointer to graphic region to repel around        */
  2442. /*        x1,y1,x2,y2, bounding rectangle in mus of this region   */
  2443. /*                                    */
  2444. /*    Builds graphic region using scanner mem driver into another     */
  2445. /*    scan buffer. Assumes scan buffer already has masks drawn into   */
  2446. /*    it so display list can now be cleared.  Blit to a smaller buffer*/
  2447. /*    then call buildmask to build actual mask.  AND this buffer into */
  2448. /*        the original scan buffer to create repel effect            */
  2449. /************************************************************************/
  2450. repel_images(region_ptr,mux1,muy1,mux2,muy2,repoffset,buffaddr)
  2451. long region_ptr;
  2452. int mux1,muy1,mux2,muy2;
  2453. int repoffset;
  2454. long *buffaddr;
  2455. {
  2456.    long tmp_scanbuf;
  2457.    long maskbuf;
  2458.    int count,wmode,opcode;
  2459.    int tmpmode;
  2460.    int tmpprint;
  2461.    int x1,y1,x2,y2;
  2462.    int width,height;
  2463.    FDB scanmfdb;
  2464.    FDB maskmfdb;
  2465.    int pxy[8];
  2466.    int hoffset,voffset;
  2467.    int nrect[4];
  2468.    int oldwidth,oldheight;
  2469.    int newwidth,newheight;
  2470.    register int i;
  2471.    int odeltax,ndeltax,odeltay,ndeltay;
  2472.    int byte_width;
  2473.    long bufsize;
  2474.  
  2475.    hoffset = repoffset * 18;
  2476.    voffset = repoffset * 16;        /* Convert to mus */
  2477.  
  2478.    nrect[0] = mux1 - hoffset;
  2479.    nrect[1] = muy1 - voffset;
  2480.    nrect[2] = mux2 + hoffset;
  2481.    nrect[3] = muy2 + voffset;
  2482.  
  2483.    mutomem(nrect[0],nrect[1],&x1,&y1);
  2484.    mutomem(nrect[2],nrect[3],&x2,&y2);
  2485.    if(x1 < 0)
  2486.     x1 = 0;
  2487.    if(y1 < 0)
  2488.     y1 = 0;
  2489.    if(x2 > scan_xres)
  2490.     x2 = scan_xres;
  2491.    if(y2 > scan_yres)
  2492.     y2 = scan_yres;
  2493.    width = x2 - x1 + 1;
  2494.    height = y2 - y1 + 1;
  2495.    scanmfdb.fd_w = scan_xres;
  2496.    maskmfdb.fd_w = width;
  2497.    scanmfdb.fd_h = scan_yres;
  2498.    maskmfdb.fd_h = height;
  2499.    scanmfdb.fd_wdwidth = (scan_xres + 15)/16;
  2500.    maskmfdb.fd_wdwidth = (width + 15)/16;
  2501.    scanmfdb.fd_stand = maskmfdb.fd_stand = 0;
  2502.    scanmfdb.fd_nplanes = maskmfdb.fd_nplanes = 1;
  2503.    if(*buffaddr)
  2504.    {
  2505.       scanmfdb.fd_addr = scanptr;
  2506.       maskmfdb.fd_addr = *buffaddr;
  2507.    }    
  2508.    else
  2509.    {
  2510.       oldwidth = mux2 - mux1 + 1;
  2511.       oldheight = muy2 - muy1 + 1;
  2512.       newwidth = nrect[2] - nrect[0] + 1;
  2513.       newheight = nrect[3] - nrect[1] + 1;
  2514.       maskbuf = get_lcmem((long)((long)height * ((((long)width+7)/8)+1)));
  2515.       tmpmode = mode_flag;
  2516.       tmpprint = print_flag;
  2517.       tmp_scanbuf = scanptr;
  2518.       scanptr = get_lcmem((long)((long)scan_yres * ((((long)scan_xres+7)/8)+1)));
  2519.  
  2520.       byte_width = ((width+2+15)/16)*2;
  2521.       bufsize = (long)byte_width * (long)(height + 2);
  2522.       newscreen = (((realscreen = (long)get_lcmem(bufsize + 512)) + 512)
  2523.                 &0xFFFFFE00L);
  2524.       if(!scanptr || !maskbuf || !newscreen)
  2525.       {
  2526.      if(!alerted)
  2527.      {
  2528.         alerted = 1;
  2529.           alert_cntre(ALERT31);
  2530.      }
  2531.      scanptr = tmp_scanbuf;
  2532.      return;
  2533.       }     
  2534.      
  2535.       GDvq_extnd(mhandle,0,intout,scan_xres,scan_yres,&scanptr);
  2536.       scanmfdb.fd_addr = scanptr;
  2537.       maskmfdb.fd_addr = maskbuf;
  2538.  
  2539.       pxy[0] = x1;
  2540.       pxy[1] = y1;
  2541.       pxy[2] = x2;
  2542.       pxy[3] = y2;
  2543.       pxy[4] = pxy[5] = 0;
  2544.       pxy[6] = width - 1;
  2545.       pxy[7] = height - 1;
  2546.  
  2547.       mode_flag = TRUE;
  2548.       print_flag = 2;
  2549.       opcode = get_fprimitive(region_ptr,&count,&wmode);
  2550.              while(opcode != -1)
  2551.              {
  2552.             switch(opcode)
  2553.             {
  2554.            case 3:
  2555.                case 4:
  2556.                case 0:
  2557.                i=0;
  2558.                while(i<count*2)
  2559.                {
  2560.                    odeltax = ptsarray[i] - mux1;
  2561.                    ndeltax = scale_iv(odeltax,newwidth,
  2562.                     oldwidth); 
  2563.                    ptsarray[i++] = nrect[0] + ndeltax;
  2564.  
  2565.                    odeltay = ptsarray[i] - muy1;
  2566.                    ndeltay = scale_iv(odeltay,newheight,
  2567.                     oldheight);
  2568.                    ptsarray[i++] = nrect[1] + ndeltay;
  2569.                } 
  2570.                redraw_polygon(count,wmode,0);
  2571.                            break;
  2572.  
  2573.            case 1: 
  2574.                     case12_scale(mux1,muy1,
  2575.                          oldwidth,oldheight,
  2576.                          nrect[0],
  2577.                          nrect[1],
  2578.                          newwidth,
  2579.                          newheight,1);
  2580.                 redraw_ellipse(wmode,0);
  2581.                    break;
  2582.  
  2583.            case 2: 
  2584.                     case12_scale(mux1,muy1,
  2585.                          oldwidth,oldheight,
  2586.                          nrect[0],
  2587.                          nrect[1],
  2588.                          newwidth,
  2589.                          newheight,2);
  2590.                insert_graphic();
  2591.                      break;
  2592.             }
  2593.                 opcode = get_nprimitive(&count,&wmode);
  2594.              }
  2595.       vro_cpyfm(shandle,3,pxy,&scanmfdb,&maskmfdb);
  2596.       buildmsk(maskbuf,width,height);
  2597.       free(scanptr);
  2598.       scanptr = tmp_scanbuf;   
  2599.       GDvq_extnd(mhandle,0,intout,scan_xres,scan_yres,&scanptr);
  2600.       scanmfdb.fd_addr = scanptr;
  2601.       mode_flag = tmpmode;
  2602.       print_flag = tmpprint;
  2603.       set_repbuff(region_ptr,maskbuf);
  2604.    }
  2605.  
  2606.    pxy[0] = pxy[1] = 0;
  2607.    pxy[2] = width - 1;
  2608.    pxy[3] = height - 1;
  2609.    pxy[4] = x1;
  2610.    pxy[5] = y1;
  2611.    pxy[6] = x2;
  2612.    pxy[7] = y2;
  2613.    vro_cpyfm(shandle,1,pxy,&maskmfdb,&scanmfdb);    /* "AND" blt */
  2614.  
  2615. }
  2616.  
  2617.  
  2618. buildmsk(srcbuf,xres,yres)
  2619. long srcbuf;
  2620. register int xres,yres;
  2621. {
  2622.    FDB srcmfdb;
  2623.    FDB desmfdb;
  2624.    int clip[4];
  2625.    int pts[8];
  2626.    int byte_width;
  2627.    long bufsize;
  2628.    long screen;
  2629.    int attr[5];
  2630.  
  2631.    gsx_moff();   
  2632.    vqf_attributes(shandle,attr);
  2633.    vsf_interior(shandle,1);        /* Solid fills for seed fill */
  2634.    screen = Logbase();
  2635.  
  2636.    byte_width = ((xres+2+15)/16)*2;
  2637.    bufsize = (long)byte_width * (long)(yres + 2);
  2638.  
  2639.    srcmfdb.fd_addr = srcbuf;
  2640.    desmfdb.fd_addr = newscreen;
  2641.    srcmfdb.fd_w = xres;
  2642.    desmfdb.fd_w = xres + 2;
  2643.    srcmfdb.fd_h = yres;
  2644.    desmfdb.fd_h = yres + 2;
  2645.    srcmfdb.fd_wdwidth = (xres + 15)/16;
  2646.    desmfdb.fd_wdwidth = (xres + 2 + 15)/16;
  2647.    srcmfdb.fd_stand = desmfdb.fd_stand = 0;
  2648.    srcmfdb.fd_nplanes = desmfdb.fd_nplanes = 1;
  2649.  
  2650.    pts[0] = 0;
  2651.    pts[1] = 0;
  2652.    pts[2] = xres - 1;
  2653.    pts[3] = yres - 1;
  2654.    pts[4] = 1;
  2655.    pts[5] = 1;
  2656.    pts[6] = xres;
  2657.    pts[7] = yres;
  2658.  
  2659.    vro_cpyfm(shandle,3,pts,&srcmfdb,&desmfdb);
  2660.  
  2661.    setvdi(xres+2,yres+2,byte_width);        /* Set vdi variables */
  2662.  
  2663.    Setscreen(newscreen,-1L,-1L);
  2664.    clip[0] = 0;
  2665.    clip[1] = 0;
  2666.    clip[2] = xres+1;
  2667.    clip[3] = yres+1;
  2668.    vs_clip(shandle,1,clip);   
  2669.  
  2670.    v_contourfill(shandle,0,0,1);
  2671.    vro_cpyfm(shandle,6,pts,&srcmfdb,&desmfdb);
  2672.    pts[0] += 1;
  2673.    pts[1] += 1;
  2674.    pts[2] += 1;
  2675.    pts[3] += 1;
  2676.    pts[4] -= 1;
  2677.    pts[5] -= 1;
  2678.    pts[6] -= 1;
  2679.    pts[7] -= 1;
  2680.    vro_cpyfm(shandle,3,pts,&desmfdb,&srcmfdb);
  2681.    fixvdi();
  2682.    Setscreen(screen,-1L,-1L);
  2683.  
  2684.    vs_clip(shandle,0,clip);
  2685.    vsf_interior(shandle,attr[0]);
  2686.    free(realscreen);
  2687.    gsx_mon();
  2688. }
  2689.  
  2690.  
  2691. free_repbuffs()
  2692. {
  2693.    register long region_ptr;
  2694.    int g_flag;
  2695.    int rect[4];
  2696.    long tmppage;
  2697.  
  2698.    tmppage = curpage;   
  2699.    region_ptr = get_fregion(curr_page,
  2700.             &rect[0],&rect[1],
  2701.             &rect[2],&rect[3],&g_flag);
  2702.    while(region_ptr)
  2703.    {
  2704.     if(g_flag)
  2705.         clr_grbuff(region_ptr);
  2706.         region_ptr = get_nregion(&rect[0],&rect[1],
  2707.                         &rect[2],&rect[3],&g_flag);
  2708.     }
  2709.     curpage = tmppage;
  2710. }
  2711.  
  2712.  
  2713.  
  2714. display_template(num,rgrect)
  2715. int num;
  2716. register int rgrect[];
  2717. {
  2718.   int endflag;
  2719.   int g_flag;                /* graphic region? */
  2720.   PAGE *rpagehd;
  2721.   PAGE *rcurpage;
  2722.   int  rtemp_page;
  2723.   ARTICLE *rarthd;
  2724.   int tgrect[4];
  2725.   int tpxy[4];
  2726.   int rectmu[4];
  2727.   char *tptr;
  2728.  
  2729.   if(disp_pos)                /* display in back */
  2730.   {
  2731.      if(num != 1)            /* so goes first   */
  2732.        return;
  2733.   }
  2734.   else
  2735.   {
  2736.      if(num != 2)
  2737.        return;
  2738.   }
  2739.  
  2740.   if(!tmplate_flag && displ_tmpl_flag)  
  2741.   {
  2742.     rpagehd = pagehd;
  2743.     rcurpage = curpage;
  2744.     rarthd   = arthd;
  2745.  
  2746.     switch(disp_type)
  2747.     {
  2748.       case 0: /* both */
  2749.           pagehd=curpage=((curr_page%2)?(right_tmplate):(left_tmplate));
  2750.           arthd = ((curr_page%2)?(rtarthd):(ltarthd));
  2751.           break;
  2752.       case 1: /* left only */
  2753.           pagehd = curpage = left_tmplate;
  2754.           arthd  = ltarthd;
  2755.           break;
  2756.       case 2: /* right only */
  2757.           pagehd = curpage = right_tmplate;
  2758.           arthd = rtarthd;
  2759.           break;
  2760.     }
  2761.  
  2762.     rtemp_page = curr_page;
  2763.     curr_page = curpage->pagenum;
  2764.  
  2765.     endflag = 0;
  2766.  
  2767.     region_ptr = get_fregion(curr_page,
  2768.                 &rectmu[0],&rectmu[1],
  2769.             &rectmu[2],&rectmu[3],&g_flag);
  2770.  
  2771.  
  2772.     while(region_ptr)
  2773.     {
  2774.  
  2775.        if((view_size == PADJCNT) && !print_flag && disp_type)
  2776.                     curr_page = rtemp_page;
  2777.  
  2778.        if(rectmu[0] >= hpage_size)
  2779.                 goto next;
  2780.  
  2781.         if(rgrect)
  2782.     {
  2783.            mutopage(rectmu[0],rectmu[1],&tpxy[0],&tpxy[1],0);
  2784.            mutopage(rectmu[2],rectmu[3],&tpxy[2],&tpxy[3],0);
  2785.  
  2786.        tgrect[0] = tpxy[0];
  2787.            tgrect[1] = tpxy[1];
  2788.            tgrect[2] = tpxy[2] - tpxy[0] + 1;
  2789.            tgrect[3] = tpxy[3] - tpxy[1] + 1;
  2790.         }
  2791.  
  2792.         if(!rgrect || rc_intersect(rgrect,tgrect))
  2793.     {
  2794.       if((!rgrect) && (print_flag != 1))
  2795.               mclip();
  2796.  
  2797.           if(!g_flag)
  2798.           {
  2799.              get_txtattr(region_ptr,&gltxtattr);
  2800.          if(mode_flag)
  2801.          {
  2802.             GDvq_extnd(mhandle,0,intout,scan_xres,scan_yres,&scanptr);
  2803.         if(!rgrect)
  2804.                     scan_clip();
  2805.             clrmem(scanptr,scan_bytes);
  2806.          }
  2807.           }
  2808.       else 
  2809.          get_grattr(region_ptr,glgrattr);
  2810.  
  2811.       if(g_flag || !mode_flag)
  2812.           {        
  2813.             opcode = get_fprimitive(region_ptr,&count,&wmode);
  2814.             while(opcode != -1)
  2815.             {
  2816.           switch(opcode)
  2817.           {
  2818.             case 3:
  2819.             case 4:
  2820.             case 0: redraw_polygon(count,wmode,g_flag);
  2821.                         break;
  2822.  
  2823.             case 1: redraw_ellipse(wmode,g_flag);
  2824.                     break;
  2825.  
  2826.             case 2: graphic_setup();
  2827.                   break;
  2828.           }
  2829.               opcode = get_nprimitive(&count,&wmode);
  2830.             }
  2831.           }
  2832.        
  2833.           if(mode_flag && !g_flag)
  2834.       {
  2835.         if(txtptr = get_txtptr(region_ptr))
  2836.             {
  2837.            if(*txtptr)
  2838.            {
  2839.           if(!rgrect)
  2840.           {
  2841.                 get_buffvars(region_ptr);
  2842.                 open_region(region_ptr);
  2843.             do_regoutput(txtptr,&endflag);
  2844.                     put_buffvars(region_ptr);
  2845.           }
  2846.           else
  2847.           {
  2848.              open_region(region_ptr);
  2849.                      do_clipregout(tgrect[0],tgrect[1],
  2850.             tgrect[2] + tgrect[0] - 1,
  2851.             tgrect[3] + tgrect[1] - 1);
  2852.           }
  2853.            }
  2854.             }
  2855.         if(print_flag != 1)              /* Don't do this for printing only */
  2856.                 GDvq_extnd(mhandle,0,intout,mxres,myres,&page_ptr);
  2857.           }
  2858.     }
  2859. next:   region_ptr = get_nregion(&rectmu[0],&rectmu[1],
  2860.                               &rectmu[2],&rectmu[3],&g_flag);
  2861.  
  2862.         if((view_size == PADJCNT) && !print_flag && disp_type)
  2863.                     rtemp_page = curr_page;
  2864.  
  2865.    }
  2866.    pagehd    = rpagehd;
  2867.    curpage   = rcurpage;
  2868.    curr_page = rtemp_page;
  2869.    arthd     = rarthd;
  2870.   }
  2871. }
  2872.  
  2873.  
  2874.  
  2875.  
  2876. tdo_template(num)
  2877. int num;
  2878. {
  2879.   int endflag;
  2880.   int g_flag;                /* graphic region? */
  2881.   PAGE *rpagehd;
  2882.   PAGE *rcurpage;
  2883.   int  rtemp_page;
  2884.   ARTICLE *rarthd;
  2885.   int rectmu[4];
  2886.  
  2887.   if(disp_pos)                /* display in back */
  2888.   {
  2889.      if(num != 1)            /* so goes first   */
  2890.        return;
  2891.   }
  2892.   else
  2893.   {
  2894.      if(num != 2)
  2895.        return;
  2896.   }
  2897.  
  2898.   if(!tmplate_flag && displ_tmpl_flag)  
  2899.   {
  2900.     rpagehd = pagehd;
  2901.     rcurpage = curpage;
  2902.     rarthd   = arthd;
  2903.  
  2904.     switch(disp_type)
  2905.     {
  2906.       case 0: /* both */
  2907.           pagehd=curpage=((curr_page%2)?(right_tmplate):(left_tmplate));
  2908.           arthd = ((curr_page%2)?(rtarthd):(ltarthd));
  2909.           break;
  2910.       case 1: /* left only */
  2911.           pagehd = curpage = left_tmplate;
  2912.           arthd  = ltarthd;
  2913.           break;
  2914.       case 2: /* right only */
  2915.           pagehd = curpage = right_tmplate;
  2916.           arthd = rtarthd;
  2917.           break;
  2918.     }
  2919.  
  2920.     rtemp_page = curr_page;
  2921.     curr_page = curpage->pagenum;
  2922.  
  2923.     endflag = 0;
  2924.  
  2925.     region_ptr = get_fregion(curr_page,
  2926.                 &rectmu[0],&rectmu[1],
  2927.             &rectmu[2],&rectmu[3],&g_flag);
  2928.     while(region_ptr)
  2929.     {
  2930.       cpabt = 0;            /* CJG 08/26/89 */
  2931.           if(rectmu[0] >= hpage_size)
  2932.                 goto next;
  2933.  
  2934.           if(!g_flag)
  2935.              get_txtattr(region_ptr,&gltxtattr);
  2936.       else 
  2937.          get_grattr(region_ptr,glgrattr);
  2938.  
  2939.       if(g_flag)
  2940.           {        
  2941.             opcode = get_fprimitive(region_ptr,&count,&wmode);
  2942.             while(opcode != -1)
  2943.             {
  2944.           switch(opcode)
  2945.           {
  2946.             case 3:
  2947.             case 4:
  2948.             case 0:
  2949.             case 1:  TYF_Gtype = 5;
  2950.                     calc_prim(opcode,&TYF_Gx0,&TYF_Gy0,
  2951.                     &TYF_Gx1,&TYF_Gy1,count);
  2952.                  insGR_TYF(opcode,count,glgrattr);
  2953.                   break;
  2954.             case 2:  TYF_Gfile = (char *)&ptsarray[5];
  2955.                  TYF_Gx0 = ptsarray[0];
  2956.                  TYF_Gy0 = ptsarray[1];
  2957.                  TYF_Gx1 = ptsarray[2];
  2958.                  TYF_Gy1 = ptsarray[3];
  2959.                  switch(ptsarray[4])
  2960.                  {
  2961.                 case 0:
  2962.                    TYF_Gtype = 2;
  2963.                    break;
  2964.                 case 1:
  2965.                    TYF_Gtype = 3;
  2966.                    break;
  2967.                 case 2:
  2968.                    TYF_Gtype = 1;
  2969.                    break;
  2970.                     case 3:
  2971.                    TYF_Gtype = 4;
  2972.                    break;
  2973.                  }
  2974.                  insGR_TYF(opcode,count,glgrattr);
  2975.                  break;
  2976.           }
  2977.               opcode = get_nprimitive(&count,&wmode);
  2978.             } /* while */
  2979.           }   /* if g_flag */
  2980.        
  2981.           if(!g_flag)
  2982.       {
  2983.         if(txtptr = get_txtptr(region_ptr))
  2984.             {
  2985.            if(*txtptr)
  2986.            {
  2987.           get_buffvars(region_ptr);
  2988.           open_region(region_ptr);
  2989.           do_tdoout(txtptr,&endflag);
  2990.            }
  2991.             }
  2992.           }
  2993.  
  2994. next:   region_ptr = get_nregion(&rectmu[0],&rectmu[1],
  2995.                               &rectmu[2],&rectmu[3],&g_flag);
  2996.     }
  2997.    pagehd    = rpagehd;
  2998.    curpage   = rcurpage;
  2999.    curr_page = rtemp_page;
  3000.    arthd     = rarthd;
  3001.   }
  3002. }
  3003.  
  3004. redraw_spot(rptr,murect,bltflag)
  3005. register REGION *rptr;
  3006. register int murect[];
  3007. int bltflag;
  3008. {
  3009.    int g_flag;                /* graphic region? */
  3010.    int rgrect[4];
  3011.    int tgrect[4];
  3012.    int rpxy[4];
  3013.    int tpxy[4];
  3014.    int murec1[4];
  3015.    int pts;
  3016.  
  3017.    int xoffset,yoffset;
  3018.  
  3019.    if(!rptr)
  3020.    {
  3021.     pts = 36;
  3022.     xoffset = pts * 18;
  3023.     yoffset = pts * 16;
  3024.    }    
  3025.    else
  3026.    {
  3027.     pts = rptr->grattr[1];
  3028.         if(pts && (rptr->grattr[2] & 0x8000))
  3029.         {
  3030.        xoffset = pts * 18;
  3031.        yoffset = pts * 16;
  3032.         }
  3033.         else
  3034.     {
  3035.        xoffset = 162; /* offsets are in machine units */
  3036.        yoffset = 144; /* an eighth of a inch each way*/
  3037.     }
  3038.    }
  3039.  
  3040.    murect[0] -= xoffset;
  3041.    murect[1] -= yoffset;
  3042.    murect[2] += xoffset;
  3043.    murect[3] += yoffset;
  3044.  
  3045.    
  3046.    GDvq_extnd(mhandle,0,intout,mxres,myres,&page_ptr);
  3047.  
  3048.    mutopage(murect[0],murect[1],&rpxy[0],&rpxy[1],1);
  3049.    mutopage(murect[2],murect[3],&rpxy[2],&rpxy[3],1);
  3050. #if NEVER
  3051.    rpxy[0] -= 2;        /* With solid fills perimeter is on */
  3052.    rpxy[1] -= 2;        /* so when erasing with hollow fill */
  3053.    rpxy[2] += 2;        /* we must ......            */
  3054.    rpxy[3] += 2;        /* Adjust for perimeter being off   */
  3055. #endif
  3056.    rpxy[0] = max(0,rpxy[0]);
  3057.    rpxy[1] = max(0,rpxy[1]);
  3058.    rpxy[2] = min(pagew - 1,rpxy[2]);
  3059.    rpxy[3] = min(pageh - 1,rpxy[3]);
  3060.  
  3061.    vs_clip(mhandle,1,rpxy);
  3062.    write_white(mhandle);
  3063.    v_bar(mhandle,rpxy);
  3064.    write_black(mhandle);
  3065.  
  3066.    rgrect[0] = rpxy[0];
  3067.    rgrect[1] = rpxy[1];
  3068.    rgrect[2] = rpxy[2] - rpxy[0] + 1;
  3069.    rgrect[3] = rpxy[3] - rpxy[1] + 1;
  3070.  
  3071.    if(show_grids)    /* moved it here cjg */
  3072.     do_grids(1,murect[0],murect[1],murect[2],murect[3]);
  3073.  
  3074.    display_template(1,rgrect);
  3075.    
  3076.    region_ptr = get_fregion(curr_page,
  3077.     &murec1[0],&murec1[1],
  3078.     &murec1[2],&murec1[3],&g_flag);
  3079.    while(region_ptr)
  3080.    {
  3081.      if(murec1[0] >= hpage_size)
  3082.             goto next;
  3083.  
  3084.      if(rptr != region_ptr)
  3085.      {
  3086.         mutopage(murec1[0],murec1[1],&tpxy[0],&tpxy[1],0);
  3087.         mutopage(murec1[2],murec1[3],&tpxy[2],&tpxy[3],0);
  3088.     
  3089.     tgrect[0] = tpxy[0];
  3090.         tgrect[1] = tpxy[1];
  3091.         tgrect[2] = tpxy[2] - tpxy[0] + 1;
  3092.         tgrect[3] = tpxy[3] - tpxy[1] + 1;
  3093.     
  3094.     if(rc_intersect(rgrect,tgrect))
  3095.     {
  3096.        if(g_flag)
  3097.                get_grattr(region_ptr,glgrattr);
  3098.  
  3099.            if(g_flag || !mode_flag)
  3100.            {
  3101.                opcode = get_fprimitive(region_ptr,&count,&wmode);
  3102.                while(opcode != -1)
  3103.                {
  3104.                    switch(opcode)
  3105.                    {
  3106.                    case 3:
  3107.                    case 4:
  3108.                    case 0: redraw_polygon(count,wmode,g_flag);
  3109.                                break;
  3110.  
  3111.                case 1: redraw_ellipse(wmode,g_flag);
  3112.                        break;
  3113.  
  3114.                case 2: graphic_setup();
  3115.                          break;
  3116.                 }
  3117.                     opcode = get_nprimitive(&count,&wmode);
  3118.                }
  3119.        }
  3120.            if(mode_flag && !g_flag)
  3121.        {
  3122.           if(txtptr = get_txtptr(region_ptr))
  3123.               {
  3124.               if(*txtptr)
  3125.           {
  3126.                  open_region(region_ptr);
  3127.                      do_clipregout(tgrect[0],tgrect[1],
  3128.             tgrect[2] + tgrect[0] - 1,
  3129.             tgrect[3] + tgrect[1] - 1);
  3130.                   }
  3131.           }
  3132.            }
  3133.     }
  3134.       }
  3135. next: region_ptr = get_nregion(&murec1[0],&murec1[1],
  3136.                     &murec1[2],&murec1[3],&g_flag);
  3137.    }
  3138.  
  3139.    display_template(2,rgrect);
  3140.    do_numbers(rgrect,0);
  3141.  
  3142.    if(bltflag)
  3143.    {
  3144.       mclip();
  3145.       do_blit();
  3146.    }
  3147.  
  3148. }
  3149.