home *** CD-ROM | disk | FTP | other *** search
/ No Fragments Archive 12: Textmags & Docs / nf_archive_12.iso / MAGS / SOURCES / ATARI_SRC.ZIP / atari source / DSMODS / HANDLERS.C < prev    next >
Encoding:
C/C++ Source or Header  |  2001-02-10  |  112.2 KB  |  4,663 lines
  1. /**************************************************************************/
  2. /*  FILE:  HANDLERS.C        PROGRAM TITLE: DeskSET II Alpha Version   */
  3. /*  Date Created: 12/15/87                          */ 
  4. /*  Last Modified: 06/30/89                          */
  5. /*                                      */
  6. /*  Description: MENU, MESSAGE, EVNT_MULTI HANDLERS              */
  7. /*  Routines:                                  */
  8. /*        o front_end()       - Initializer                  */
  9. /*    o initialize()      - Initialize variables              */
  10. /*      o event()            - Event Multi                  */
  11. /*    o hndl_keybd()        - Event Keyboard Handler          */
  12. /*      o mesag_handle()    - Event Message Handler              */
  13. /*    o menu_handler()     - Menu Event Handler              */
  14. /*    o button_handler()     - Button Event Handler                */
  15. /*    o do_nada()        - Handler to select a region          */
  16. /*    o screen_clip()        - Set Screen clipping              */
  17. /*    o scrn2clip()        - Another clip setting routine - PADJCNT  */
  18. /*    o poly_handler()    - Secondary poly draw handler          */
  19. /*    o button_end()      - Concludes Button and poly handler       */
  20. /*    o check_region_ptr()    - checks for active graphic or text region*/
  21. /*    o check_only_blit()    - check if all we need is a blit...      */
  22. /*    o do_delregion()    - Delete the currently selected region      */
  23. /*    o do_unlinkreg()    - Unlink the current text region      */
  24. /*    o do_delpage()        - Delete the current page          */
  25. /*    o do_move_region()    - Handles moving a selected region      */
  26. /*    o check_boxes()        - handles 8 boxes for scaling region       */
  27. /*    o do_rule_mark()    - Handles the ruler markers          */
  28. /*    o update_repel()    - Repels new region for flowing of text      */
  29. /*    o snap_to_grid()    - snaps vertices to a specific grid      */
  30. /*    o snap_mu()        - snap in machine units              */
  31. /*    o do_edit_prim()    - Select w/ right button a primitive      */
  32. /*    o calc_prim()        - Calculate outer boundary of primitive   */
  33. /*    o edit_prims()        - Move and Size Primitives          */
  34. /*    o check_prim_box()    - Size a primitive              */
  35. /*    o recalc_region()    - Recalc region bndry after editing prim  */
  36. /*    o move_prim_box()    - move a primitive within a region      */
  37. /*    o inside_primitive()    - check if clicked within a primitive      */
  38. /*    o hndl_icons()        - handle left icon panel selections      */
  39. /**************************************************************************/
  40.  
  41. /**************************************************************************/
  42. /* HISTORY                                  */
  43. /*                                       */
  44. /* 11/03/89    Changes made to delete the page if the last region on     */
  45. /*        that page is deleted.                      */
  46. /*         Modified  - do_delregion()                  */
  47. /*              - do_delmulti()                  */
  48. /**************************************************************************/
  49.  
  50. /**************************************************************************/
  51. /* INCLUDE FILES                              */
  52. /**************************************************************************/
  53. #include "define.h"
  54. #include "gemdefs.h"
  55. #include "deskset2.h"
  56. #include <obdefs.h>
  57. #include <osbind.h>
  58. #include "alert.h"
  59. #include "dbase.h"
  60.  
  61. /**************************************************************************/
  62. /* DEFINES                                  */
  63. /**************************************************************************/
  64.  
  65. #define max(x,y)   (((x) > (y)) ? (x) : (y))
  66. #define min(x,y)   (((x) < (y)) ? (x) : (y))
  67. #define MICRON   319
  68. #define NULLPTR  0x0L
  69. #define MIN_MEM_TO_RUN 5000L
  70.  
  71. /**************************************************************************/
  72. /* EXTERNALS                                  */
  73. /**************************************************************************/
  74. extern int ptsin[];            /* PTSIN array              */
  75. extern char rscerr3[];            /* Delete Regions Alert Box text  */
  76. extern char del_page[];
  77. extern char delregion[];
  78. extern char quiter[];
  79.  
  80. extern int (*funcs)();            /* Drawing Primitive Functions    */
  81. extern long find_region();        /* Function - Find Region       */
  82. extern int nada();            /* Default Drawing Primitive      */
  83. extern int poly_draw();
  84. extern long getf_scaninfo();
  85. extern long getn_scaninfo();
  86. extern long prev_aregion();
  87. extern int scrntomu();
  88. extern int recalc_txtptrs();
  89.  
  90. extern OBJECT *ad_menu;            /* OBJECT for menu bar etc.       */
  91. extern OBJECT *ad_deskset;        /* OBJECT for ABOUT dialog box    */
  92. extern OBJECT *ad_paths;
  93. extern OBJECT *adpagedef;        /* page type dialog box          */
  94.  
  95. extern int dummy;            /* well, dummy...          */
  96. extern int hpage_size;            /* horizontal and vertical page   */
  97. extern int vpage_size;            /* size in Machine Units (MU)     */
  98. extern int view_size;            /* Current scaling size-ACTUAL etc*/
  99. extern int prev_size;            /* Previous Scale Size...      */
  100.  
  101. extern int curr_page;            /* Current Page Number displayed  */
  102.  
  103. extern unsigned long region_ptr;    /* Pointer to Region in STructure */
  104. extern unsigned long gl_region_ptr;    /* Ptr to Current Active region   */
  105. extern unsigned long gl_grregion_ptr;   /* Ptr to current graphic region  */
  106.  
  107. extern int shandle;            /* screen workstation handle      */
  108. extern int mhandle;            /* Preview Buffer Driver Handle   */
  109. extern int xor_handle;            /* Secondary Screen workstation   */
  110. extern int prev_handle;            /* Preview window handle.      */
  111. extern int rule_handle;
  112.  
  113. extern int txt_handle;
  114.  
  115. extern GRECT work;            /* GRECT of work area of window   */
  116. extern GRECT pwork;            /* Preview GRECT Work Window      */
  117. extern GRECT dpwork;
  118.  
  119. extern int pagew,pageh;            /* page width and height (Pixels) */
  120. extern int opwidth,opheight;
  121.                     /* Note: Size is for current scale*/
  122.  
  123. int rect_in_mu[4];            /* x1,y1,x2,y2 of current region  */
  124.  
  125. extern int mode_flag;            /* Outline/Solid Mode           */
  126. extern char *mode_text[];        /* Info for Prev Window         */
  127.  
  128. extern int write_flag;            /* write white/black flag         */
  129. extern char *write_mode[];        /* write white/black menu text    */
  130. extern char *ruler_mode[];
  131.  
  132. extern int clip_area[];            /* Supposed clip area set         */
  133. extern unsigned long page_ptr;        /* Preview Buffer Pointer         */
  134. extern FDB page_MFDB;            /* Preview MFDB area          */
  135.  
  136. extern int gl_lstyle;            /* Current line styles and fill   */
  137. extern int gl_lwidth;            /* styles...              */
  138. extern int gl_fstyle;
  139. extern int gl_findex;
  140. extern int gl_repel;
  141. extern int gl_repoffset;
  142. extern int gl_repbounds;
  143.  
  144. extern int SH;                /* adjusted point size ht in pix  */
  145. extern int zdevice;            /* index into xdip/ydpi          */
  146.  
  147. extern int BSTATE;            /* Button State...          */
  148. extern BUT_OR();            /* routine to get button state    */
  149. extern long BADDR;
  150. extern int BREAL;
  151.  
  152. extern int  article_flag;        
  153. extern char pathbuf[];            /* path to file...          */
  154.  
  155. extern int cur_scale;            /* current scale          */
  156. extern int cur_primitive;        /* current primitive in RCS #s    */
  157.         
  158. extern struct txtattr gltxtattr;    /* Global txt attributes       */
  159. extern struct txtattr cp;
  160. extern int glgrattr[];            /* Global graphics attributes     */
  161.  
  162. extern int force_draw_flag;
  163.  
  164. extern long get_regart();        /* Return regions article pointer */
  165.  
  166. extern int mboxx1[];
  167. extern int mboxx2[];
  168. extern int mboxy1[];
  169. extern int mboxy2[];
  170.  
  171. extern int count,wmode;
  172. extern int ptsarray[];
  173. extern int xruler_offset;
  174. extern int yruler_offset;
  175.  
  176. extern int hhalf,vhalf;
  177.  
  178. extern int mouse_on;
  179. extern int clipf[];
  180. extern int *clipe;
  181. extern int *icdata;
  182. extern int *primicons;
  183. extern BITBLK *bgicptr;
  184. extern ICONBLK *icnptr;
  185. extern OBJECT *ad_bkgrnd;
  186. extern int ybook;
  187. extern int syres;
  188.  
  189. extern char fntdrs[];
  190. extern int alt_offset;
  191.  
  192. extern long location;
  193.  
  194. extern struct textobj gltext;
  195. extern long get_fregion();
  196. extern long get_nregion();
  197.  
  198. extern char *winfo[][4];
  199.  
  200. extern long get_curreg();
  201.  
  202. extern char *dpath1;
  203. extern char *dpath2;
  204. extern char *dpath3;
  205. extern char *dpath4;
  206.  
  207. extern char *get_edit();
  208.  
  209. extern long getf_aregion();
  210. extern long getn_aregion();
  211.  
  212. extern int reopen_prim;
  213.  
  214. extern short mlink[];
  215. extern long curregion;
  216. extern long sfregion;
  217.  
  218. extern int tmplate_flag;
  219. extern char *template_mode[];
  220.  
  221. extern PAGE *curpage;
  222. extern PAGE *pagehd;
  223.  
  224. extern unsigned char *get_lcmem();
  225.  
  226. extern char *disp_tmpl[];
  227. extern OBJECT *ad_settmpl;
  228.  
  229. extern long MALLOC();
  230. extern ARTICLE *arthd;
  231. extern ARTICLE *curart;
  232. extern long curprim;
  233.  
  234. extern int sxres,syres;
  235. extern long first_aregion();
  236. extern long lmalloc();
  237. extern int free();
  238. extern int force_preview();
  239. extern int do_blit();
  240. extern int dotext();
  241. extern int redraw_laser;
  242.  
  243. extern REGION *create_region();
  244. extern OBJECT *unitobj;
  245.  
  246. extern int sdevm;
  247. extern int zrat;
  248.  
  249. extern int info_what; /* info dialog box - DOC,TEMPLATE,CLIP 0,1,2 */
  250. extern int info_type; /* info dialog box - TEXT,GRAPHIC 0 or 1     */
  251. extern OBJECT *ad_info;
  252.  
  253. extern char pfname[];    /* title for preview window */
  254. extern char basefname[]; /* title for base page */
  255.  
  256. int    *gcurx;                    /* Ptr to mouse x position*/
  257. int    *gcury;                    /* Ptr to mouse y position*/
  258.  
  259. char outdev_alert[] = 
  260. "[1][      Output to:              ][PRINTER|DISK (TDO FILE)]";
  261.  
  262.  
  263. extern long OVMOUSE;
  264. extern long NVMOUSE;
  265. extern KICKAES();
  266.  
  267. extern int circle_draw();
  268. extern int ellipse_draw();
  269. extern int axdpi[];
  270. extern int aydpi[];
  271. extern int zdevice;
  272. extern int scan_xres;
  273. extern int scan_yres;
  274.  
  275. /**************************************************************************/
  276. /* GLOBAL VARIABLES                              */
  277. /**************************************************************************/
  278. GRECT page_area;            /* Page area/work area of prev    */
  279. int done;                    /* event multi flag       */
  280. int evnt_which;
  281. int msg_buff[8];                /* event message buffer   */
  282. int pxyarray[254];
  283.  
  284. GRECT area;                    /* Well, you got me?      */
  285. int newx,newy;                    /* new x and y mouse pos  */
  286. int mode_change;                /* Flag if solid/text mode*/
  287. int button,key;                    /* following used for the */
  288. int oldx,oldy;                    /* evnt_multi calls.      */
  289. int nmx,nmy;
  290. int status;
  291. int pxy[254];
  292. int num;
  293. int aindex;
  294.  
  295. USERBLK   filler[24];
  296. int ob_x[24];
  297. int ob_y[24];
  298. int graph_flag;                /* graphic primitive? 0-no,1-yes  */
  299. int image_status;            /* display images? 0-no,1-yes     */
  300.  
  301.  
  302. sbox0() { pxy[0] = newx; pxy[1] = newy; }
  303. sbox1() { pxy[1] = newy; }
  304. sbox2() { pxy[1] = newy; pxy[2] = newx; }
  305. sbox3() { pxy[2] = newx; }
  306. sbox4() { pxy[2] = newx; pxy[3] = newy; }
  307. sbox5() { pxy[3] = newy; }
  308. sbox6() { pxy[0] = newx; pxy[3] = newy; }
  309. sbox7() { pxy[0] = newx; }
  310.  
  311. amouse0() {*gcurx = pxy[0]; *gcury = pxy[1];}
  312. amouse1() {*gcury = pxy[1]; *gcurx = (pxy[0] + pxy[2])/2;} /* * */
  313. amouse2() {*gcury = pxy[1]; *gcurx = pxy[2];}
  314. amouse3() {*gcurx = pxy[2]; *gcury = (pxy[1] + pxy[3])/2;} /* * */
  315. amouse4() {*gcurx = pxy[2]; *gcury = pxy[3];}
  316. amouse5() {*gcury = pxy[3]; *gcurx = (pxy[0] + pxy[2])/2;} /* * */
  317. amouse6() {*gcurx = pxy[0]; *gcury = pxy[3];}
  318. amouse7() {*gcurx = pxy[0]; *gcury = (pxy[1] + pxy[3])/2;} /* * */
  319.  
  320.  
  321. bmouse0() {*gcurx = pxy[0] - 5; *gcury = pxy[1] - 5;}
  322. bmouse1() {*gcury = pxy[1] - 5; *gcurx = (pxy[0] + pxy[2])/ 2;} /* * */
  323. bmouse2() {*gcury = pxy[1] - 5; *gcurx = pxy[2] + 5;}
  324. bmouse3() {*gcurx = pxy[2] + 5; *gcury = (pxy[1] + pxy[3])/2;}/* * */
  325. bmouse4() {*gcurx = pxy[2] + 5; *gcury = pxy[3] + 5;}
  326. bmouse5() {*gcury = pxy[3] + 5; *gcurx = (pxy[0] + pxy[2]) / 2;}/* * */
  327. bmouse6() {*gcurx = pxy[0] - 5; *gcury = pxy[3] + 5;}
  328. bmouse7() {*gcurx = pxy[0] - 5; *gcury = (pxy[1] + pxy[3]) / 2;}/* * */
  329.  
  330.  
  331.  
  332. int (*da_box[8])() = 
  333.         {
  334.           &sbox0,
  335.           &sbox1,
  336.           &sbox2,
  337.           &sbox3,
  338.           &sbox4,
  339.           &sbox5,
  340.           &sbox6,
  341.           &sbox7
  342.         };
  343.  
  344. int (*adj_mouse[8])() = 
  345.           {
  346.             &amouse0,
  347.             &amouse1,
  348.             &amouse2,
  349.             &amouse3,
  350.             &amouse4,
  351.             &amouse5,
  352.             &amouse6,
  353.             &amouse7
  354.           };
  355.  
  356. int (*bdj_mouse[8])() = 
  357.           {
  358.             &bmouse0,
  359.             &bmouse1,
  360.             &bmouse2,
  361.             &bmouse3,
  362.             &bmouse4,
  363.             &bmouse5,
  364.             &bmouse6,
  365.             &bmouse7
  366.           };
  367.  
  368. int voldx,voldy;
  369. int deltax,deltay;
  370. int txscale,tyscale;
  371. int ruler_flag;
  372.  
  373. int     unit_type;
  374. int xold_mark,yold_mark;
  375. int deferhj;
  376. int show_grids,snap_to_grids,hgridspace,vgridspace;
  377. int clipfull;
  378. int pagetype;                /* current page type          */
  379.                     /* DEFAULT to US LETTER          */
  380.                     /* A4, B5, Letter, Legal,        */
  381.                     /* Landscape A4, Landscape B5,   */
  382.                     /* Landscape Letter, Landscape   */
  383.                     /* Legal (eof)             */
  384.  
  385. /* The page x and y sizes are based in machine units             */
  386. /* 1296 mu per inch horizontally...                       */
  387. /* 1152 mu per inch vertically...                     */
  388. /* All sizes are in inches                         */
  389. /* Paper sizes are:    PAPER TYPE      WIDTH           HEIGHT         */
  390. /*             LETTER          8.0                 10.6           */
  391. /*                       LEGAL           8.0              13.6           */
  392. /*                 A4              7.787            11.287     */
  393. /*                 B5              6.72              9.713         */
  394.  
  395.  
  396.  
  397.  
  398. /* Paper Sizes (LASER Printer: 300 DPI)                  */
  399. /* Sizes were calculated at base 0 (ergo, there is 1 pixel more)     */
  400. /* All units are in pixels                                               */
  401. /*                     PAPER TYPE      WIDTH           HEIGHT            */
  402. /*                       LETTER        2400             3180             */
  403. /*                       LEGAL         2400             4080             */
  404. /*                       A4            2336             3386             */
  405. /*                       B5            2016             2914             */
  406.  
  407. /* Below are page sizes converted to machine units (MUs)         */
  408. /* 1296 Horizontal MUs == 1 horizontal inch                 */
  409. /* 1152 Vertical MUs == 1 vertical inch                     */
  410.  
  411. int pagemux[] = {            /* A4,B5,Letter,Legal - Horizonta*/
  412.            10092,        /*A4 Portrait         7.787 * 1296  */
  413.            8709,        /*B5 Portrait        6.72  * 1296  */
  414.            10368,        /*Letter Portrait    8.0   * 1296  */
  415.            10368,        /*Legal Portrait     8.0   * 1296  */
  416.  
  417.            14628,        /* A4 Landscape     11.287 * 1296  */
  418.            12588,        /* B5 Landscape      9.713 * 1296  */
  419.            13738,        /* Letter Landscape 10.6   * 1296  */
  420.            17626        /* Legal Landscape  13.6   * 1296  */
  421.             };
  422.  
  423. int pagemuy[] = {            /* A4,B5,Letter,Legal -VERTICAL  */
  424.            13003,        /* A4 Portrait        11.287 * 1152  */
  425.            11189,        /* B5 Portrait         9.713 * 1152  */
  426.            12211,        /* Letter Portrait  10.6   * 1152  */
  427.            15667,        /* Legal Portrait   13.6   * 1152  */ 
  428.  
  429.            8971,        /* A4 Landscape      7.787 * 1152  */
  430.            7741,        /* B5 Landscape      6.72  * 1152  */
  431.            9216,        /* Letter Landscape  8.0   * 1152  */
  432.            9216            /* Legal Landscape   8.0   * 1152  */
  433.         };
  434.  
  435.  
  436. /* mu_array and world_setup must contain the largest x width in mu possible*/
  437. int mu_array[17625];            /* CS store mu to pix conversions */
  438.  
  439. int active_prim;            /* flag */
  440. long prim_ptr;                /* ptr to current primitive*/
  441.  
  442. short mlink1[37];
  443.  
  444. PAGE *left_tmplate;
  445. PAGE *right_tmplate;
  446.  
  447. int  temp_page;                /* backup of actual page for template*/
  448.  
  449. PAGE *tpagehd;
  450. PAGE *tcurpage;
  451. ARTICLE *tarthd;
  452. ARTICLE *tcurart;
  453. ARTICLE *ltarthd;
  454. ARTICLE *rtarthd;
  455.  
  456. int  displ_tmpl_flag;            /* display template? 0-no 1 - yes */
  457. int disp_pos;                /* template in front or back?     */
  458. int disp_type;                /* template - both,left,right     */
  459. int kstat;
  460.  
  461. PNUMBER pnum;
  462.  
  463. #define DSMSG 0x1000
  464. int dsbuff[30];
  465. int multi_mode;            /* multiple regions selected         */
  466. int multi_box[4];
  467.  
  468. int rcopy_flag;            /* copy a region flag? */
  469.  
  470. int (*boxes)();
  471.  
  472. long funct_array[10];
  473.  
  474. /**************************************************************************/
  475. /* Function: front_end()                          */
  476. /* Description: Initialize everything else and call event_multi().      */
  477. /**************************************************************************/
  478. front_end(docname)
  479. char *docname;
  480. {
  481.      long msize;
  482.  
  483.      initialize();                   /* Initialize variables    */
  484.      init_structs();                   /* Initialize data structre*/
  485.      world_setup();
  486.      msize = Malloc(-1L);
  487.       
  488.      if(msize >= MIN_MEM_TO_RUN)
  489.      {
  490.     force_preview();
  491.     if(docname)
  492.     {
  493.        load_doc(docname);
  494.     }
  495.         event();                   /* Do the event...         */
  496.      }
  497.      else
  498.     alert_cntre(ALERT14);
  499.      close_work();                   /* and exit program        */
  500. }
  501.  
  502. world_setup()
  503. {
  504.    int dummy;
  505.    register int i;
  506.  
  507.    zrat = 100;
  508.    graf_mouse(2,&dummy);        /* Busy bee */
  509.    for(i = 0;i < 17625;i++)
  510.    {
  511.     mu_array[i] = world_rc_x(i);
  512.    }
  513.    graf_mouse(ARROW,&dummy);
  514. }
  515.  
  516.  
  517. /**************************************************************************/
  518. /*  Function:     initialize()                          */
  519. /*  Description:  Initialize Variables                      */
  520. /**************************************************************************/
  521. initialize()
  522. {
  523.      char *buf;
  524.      int drv;
  525.      char obuf[40];
  526.      register int i;
  527.      int titem;
  528.      int dummy;
  529.  
  530.      location = 0x0L;
  531.      set_ad_dpi();                /* set dialog box for dpi to  */
  532.                         /* at LEAST, 95dpi. Below will*/
  533.                         /* change the defaults, if    */
  534.                         /* necessary...          */
  535.  
  536.      vmicron(mhandle,MICRON,MICRON);        /* adjust memory driver to    */
  537.      vmicron(shandle,MICRON,MICRON);        /* this micron size...      */
  538.  
  539.      xruler_offset = yruler_offset = 0;
  540.      deferhj = 0;
  541.      curr_page  = 1;                    /* Current Page = 1          */
  542.      funcs      = &nada;                /* Default drawing function   */
  543.      mode_flag  = FALSE;            /* solid/text fill - OFF      */
  544.      write_flag = TRUE;                /* write black - default      */
  545.      page_area.g_x = page_area.g_y = 0;     /* Preview area blit defaults */
  546.      page_MFDB.fd_addr = page_ptr;        /* Preview address MFDB       */
  547.      opwidth = opheight = 0;            /* old page width and height  */
  548.    
  549.      vswr_mode(shandle,1);            /* replace mode...            */
  550.      vswr_mode(xor_handle,3);            /* xor mode for xor handle    */
  551.  
  552.      vswr_mode(mhandle,1);            /* replace mode for preview   */
  553.      write_black(mhandle);            /* and set to write black...  */
  554.     
  555.      vswr_mode(rule_handle,3);            /* xor mode for ruler      */
  556.      article_flag = FALSE;
  557.  
  558.      vex_butv(xor_handle,&BUT_OR,&BADDR);
  559.  
  560.      vex_motv(shandle,&NVMOUSE,&OVMOUSE);
  561.      vex_motv(shandle,OVMOUSE,&dummy);
  562.  
  563.  
  564.      if(!restore_defaults())
  565.      {
  566.        set_text_defaults();
  567.        init_tattr();
  568.  
  569.        hpage_size = pagemux[PLETTER - PA4];    /* Default to US LETTER       */
  570.        vpage_size = pagemuy[PLETTER - PA4];
  571.        mutomem(hpage_size,vpage_size,&scan_xres,&scan_yres);
  572.        pagetype   = PLETTER;
  573.        view_size  = PSIZE;               /* Default to Size to Fit     */
  574.        wind_set(prev_handle,WF_INFO,winfo[view_size - PSIZE][unit_type]);
  575.        ruler_flag = FALSE;     
  576.        gl_lstyle = 1;
  577.        gl_lwidth = 0;            /* 0 mu's means line width of 1 pix */
  578.        gl_fstyle = 2;
  579.        gl_fstyle |= 0x8000;        /* high bit set for perimeter on*/
  580.        gl_findex = 10;
  581.        gl_repel = 0;
  582.        gl_repbounds = 0;
  583.        gl_repoffset = 10;
  584.  
  585.        unit_type = 0;                /* Inches    */
  586.        show_grids = 0;
  587.        snap_to_grids = 0;
  588.        disp_pos = 1;            /* Set initial to back      */
  589.        disp_type = 0;            /* Set to Both...        */
  590.        ad_settmpl[SETTBOTH].ob_state = SELECTED;
  591.        ad_settmpl[SETTBACK].ob_state = SELECTED;     
  592.        pnum.pfnum = 1;
  593.        pnum.pptsize = 24*8;    /* ptsize and setsize stored*/
  594.        pnum.pstsize = 24*8;    /* as x8   11-14-88        */
  595.        pnum.units = 0;        /* inches */
  596.        pnum.ljust  = 1;        /* center */
  597.        pnum.rjust  = 1;
  598.        pnum.usage = 2;        /* both   */
  599.        pnum.vpos  = 1;        /* bottom */
  600.        pnum.distance = 0.0;    /* 0 distance */
  601.        pnum.text[0]  = NULLPTR;    /* blank space */
  602.        pnum.display = 0;        /* Don't display till later  */
  603.        pnum.tpage = pnum.fpage = 0; /* number from page 0 to 0 */
  604.  
  605.        hgridspace = 1296;
  606.        vgridspace = 1152;
  607.  
  608.        get_work(prev_handle);
  609.        prev_size = view_size;
  610.        size_fit_handle();
  611.  
  612.      }
  613.      else
  614.      {
  615.        hpage_size = pagemux[pagetype - PA4];
  616.        vpage_size = pagemuy[pagetype - PA4];
  617.        mutomem(hpage_size,vpage_size,&scan_xres,&scan_yres);
  618.  
  619.        get_work(prev_handle);
  620.        prev_size = view_size;
  621.        for(i=PSIZE;i<= PADJCNT;i++)
  622.            menu_icheck(ad_menu,i,FALSE);
  623.        menu_icheck(ad_menu,view_size,TRUE);
  624.        if(pagetype == PLEGAL + 4) /* Landscape Legal Paper?  */
  625.        {              /* Disable 200% and Adjacent pages for now*/
  626.             menu_ienable(ad_menu,PADJCNT,FALSE);
  627.             menu_ienable(ad_menu,P200,FALSE);
  628.        }
  629.       if(!sdevm)
  630.        change_dpi();
  631.     
  632.       if(view_size == PADJCNT)
  633.         recalc_alt_text();
  634.       
  635.       if(view_size != PADJCNT)
  636.      titem = view_size;
  637.       else
  638.         titem = ((curr_page % 2)?(view_size + 1):(view_size));        
  639.  
  640.       wind_set(prev_handle,WF_INFO,winfo[titem - PSIZE][unit_type]);
  641.       wind_set(prev_handle,WF_TOP,&dummy,&dummy,&dummy,&dummy);
  642.       page_area.g_x = page_area.g_y = 0L;
  643.  
  644.       vsf_interior(shandle,0);            /* Set to Solid   */
  645.  
  646.       if( (view_size == PSIZE) ||
  647.       (view_size == PADJCNT))
  648.          pdraw_fit(view_size);
  649.       else
  650.          pdraw_scale();
  651.  
  652.  
  653.       prev_size = view_size;
  654.       zoom_setup();
  655.       cur_scale = get_scale_num(view_size);
  656.       get_work(prev_handle);
  657.       update_preview_blit();
  658.       set_clip(TRUE,&pwork);
  659.       vr_recfl(shandle,pxy);
  660.       clear_window(prev_handle,2,1);
  661.       init_rulers();
  662.       slider_chk();
  663.       set_clip(TRUE,&dpwork);
  664.  
  665.                                 
  666.       menu_text(ad_menu,PRULER,ruler_mode[ruler_flag]); /* ruler   */
  667.  
  668.       for(i=MINCHES;i<=MCICERO;i++)    /* handle unit dialog box  */
  669.         unitobj[i].ob_state = NORMAL;
  670.       unitobj[MINCHES+unit_type].ob_state = SELECTED;
  671.  
  672.     
  673.       if(show_grids)            /* handle display of grids */
  674.        change_icstate(SELECTED,ICBOX7,1);
  675.       else
  676.        change_icstate(NORMAL,ICBOX7,1);
  677.       menu_icheck(ad_menu,OSHOWGR,show_grids);
  678.  
  679.  
  680.       if(snap_to_grids)            /* handle snap to grids       */
  681.        change_icstate(SELECTED,ICBOX8,1);
  682.       else
  683.        change_icstate(NORMAL,ICBOX8,1);
  684.       menu_icheck(ad_menu,OSNAP,snap_to_grids);
  685.       
  686.      }
  687.  
  688.      update_point_dialog();
  689.  
  690.      zdevice = SCANNER;
  691.      SH = vmutopix((int)gltxtattr.lnsp);
  692.  
  693.  
  694.      buf = pathbuf;
  695.      *buf++ = (drv= Dgetdrv()) + 'A';
  696.      *buf++=':';
  697.      *buf++='\\';
  698.      *buf++=0;
  699.      Dgetpath(obuf,drv+1);
  700.      if(strlen(obuf)== 0);
  701.      else strcat(pathbuf,&obuf[1]);
  702.  
  703.      if(pathbuf[strlen(pathbuf)-1]!='\\')
  704.               strcat(pathbuf,"\\");
  705.      icon_setup();
  706.  
  707.  
  708.      gl_region_ptr = gl_grregion_ptr = 0L;
  709.      graph_flag = image_status = 0;
  710. /*     menu_ienable(ad_menu,ACREATE,FALSE);*/
  711.      menu_ienable(ad_menu,RDELETE,FALSE);
  712.      menu_ienable(ad_menu,RUNLINK,FALSE);
  713.      menu_ienable(ad_menu,RCOORD,FALSE);
  714.  
  715.      clipfull = 0;
  716.  
  717.  
  718.      dpath1 = get_edit(ad_paths,PATHTEXT);
  719.      dpath2 = get_edit(ad_paths,PATHCLIP);
  720.      dpath3 = get_edit(ad_paths,PATHGRAP);
  721.      dpath4 = get_edit(ad_paths,PATHDOC);
  722.  
  723.  
  724.      if(read_path(dpath1,dpath2,dpath3,dpath4))
  725.      {
  726.        set_tedit(ad_paths,PATHTEXT,dpath1);
  727.        set_tedit(ad_paths,PATHCLIP,dpath2);
  728.        set_tedit(ad_paths,PATHGRAP,dpath3);
  729.        set_tedit(ad_paths,PATHDOC,dpath4);
  730.      }
  731.      else
  732.      {
  733.        set_tedit(ad_paths,PATHTEXT,pathbuf);
  734.        set_tedit(ad_paths,PATHCLIP,pathbuf);
  735.        set_tedit(ad_paths,PATHGRAP,pathbuf);
  736.        set_tedit(ad_paths,PATHDOC,pathbuf);
  737.        store_paths(dpath1,dpath2,dpath3,dpath4);
  738.      }
  739.      reopen_prim = FALSE;        /* reopen_region init = FALSE*/
  740.      for(i = 0;i < 5;i++)
  741.     mlink1[i] = mlink[i];
  742.      for(i = 21;i < 37;i++)        /* Invert data */
  743.     mlink1[i] = mlink[i] ^ 0xffff;
  744.  
  745.      displ_tmpl_flag = TRUE;
  746.      init_templates();
  747.  
  748.      f_move(&gltxtattr,&pnum.tattrib,sizeof(pnum.tattrib));
  749.      pnum.tattrib.ptsz = pnum.pptsize;
  750.      pnum.tattrib.font = pnum.pfnum;
  751.      pnum.tattrib.ssiz = pnum.pstsize;
  752.      pnum.tattrib.lnsp = (long)pttomu(pnum.pptsize/8);
  753.  
  754.      pnum.tattrib.kernmd = 0;        /* kerning      */
  755.      pnum.tattrib.rvomd  = 0;        /* reverse video*/
  756.  
  757.      if(!sdevm)
  758.         menu_ienable(ad_menu,ODPI,TRUE);
  759.      else
  760.         menu_ienable(ad_menu,ODPI,FALSE);
  761.  
  762.  
  763.      info_what = info_type = 0;  /* set info dialog box to DOC and TEXT  */
  764.      ad_info[info_what + DIDOC].ob_state = SELECTED;
  765.      ad_info[info_type + DITEXT].ob_state = SELECTED;
  766. }
  767.  
  768.  
  769.  
  770. /**************************************************************************/
  771. /*  Function:     event()                          */
  772. /*  Description:  Event Multi Call...                      */
  773. /**************************************************************************/
  774. event()
  775. {
  776. int flag;
  777. int key;
  778.  
  779.     done = FALSE;
  780.     while(done == FALSE)
  781.     {
  782.        flag = MU_BUTTON|MU_MESAG|MU_KEYBD;
  783.        if(ruler_flag)
  784.        flag |= MU_M1;
  785.        evnt_which = evnt_multi(flag,
  786.                  1,1,1,
  787.                  1,oldx,oldy,1,1,
  788.                  0,0,0,0,0,
  789.                  msg_buff,
  790.                  0,0,
  791.                  &newx,&newy,
  792.                  &dummy,
  793.                  &kstat,    /* Kbd shift state for GOG      */
  794.                  &key,
  795.                  &dummy);
  796.  
  797.        wind_update(TRUE);
  798.        if(evnt_which & MU_M1)
  799.        {
  800.        do_rule_mark();
  801.            oldx = newx;
  802.            oldy = newy;
  803.        }
  804.        if(evnt_which & MU_KEYBD)
  805.           hndl_keybd(key);
  806.  
  807.        if(evnt_which & MU_MESAG)
  808.        if(msg_buff[0] == 0x1000)
  809.         hndl_acc();
  810.        else
  811.                 mesag_handle(msg_buff);
  812.  
  813.        if(evnt_which & MU_BUTTON)
  814.                    button_handler(newx,newy);
  815.  
  816.        if(check_TWtop()) Editor();
  817.        wind_update(FALSE);
  818.     }
  819. }
  820.  
  821.  
  822. hndl_acc()
  823. {
  824.    long *buffptr;
  825.    int id;
  826.    long holder;
  827.  
  828.    id = appl_find("DSACC   ");
  829.    if(id != -1)
  830.    {
  831.       msg_buff[0] = DSMSG;
  832.       buffptr = (long *)(msg_buff + 1);
  833.       *buffptr = dsbuff;
  834.       holder = &pagehd;
  835.       f_move(&holder,&dsbuff[0],4);
  836.       holder = &arthd;
  837.       f_move(&holder,&dsbuff[2],4);
  838.       holder = &gl_region_ptr;
  839.       f_move(&holder,&dsbuff[4],4);
  840.       holder = &gl_grregion_ptr;
  841.       f_move(&holder,&dsbuff[6],4);
  842.       holder = &curprim;
  843.       f_move(&holder,&dsbuff[8],4);
  844.       dsbuff[10] = active_prim;            /* Primitive selected? */
  845.       dsbuff[11] = curr_page;            /* Current page           */
  846.       holder = &cp;
  847.       f_move(&holder,&dsbuff[12],4);
  848.       holder = funct_array;
  849.       f_move(&holder,&dsbuff[14],4);
  850.       dsbuff[16] = multi_mode;
  851.       dsbuff[17] = hpage_size;
  852.       dsbuff[18] = vpage_size;
  853.       funct_array[0] = &lmalloc;
  854.       funct_array[1] = &free;
  855.       funct_array[2] = &force_preview;
  856.       funct_array[3] = &do_blit;
  857.       funct_array[4] = &dotext;
  858.       funct_array[5] = &redraw_laser;
  859.       funct_array[6] = &scrntomu;
  860.       funct_array[7] = &recalc_txtptrs;
  861.       appl_write(id,16,msg_buff);
  862.    }
  863. }
  864.  
  865. /**************************************************************************/
  866. /* Function: hndl_keybd()                          */
  867. /* Description: Keyboard handler                      */
  868. /**************************************************************************/
  869. hndl_keybd(key)
  870. int key;
  871. {
  872.     register int menu;
  873.     register int item;
  874.     char ch;
  875.     ch = (char)key & 0xff;
  876.     switch(ch)
  877.     {
  878.   /* FILE MENU ITEMS    */
  879.     case 0x0e:
  880.         menu = TFILE;                /* ^N */
  881.         item = FNEW;
  882.         break;
  883.     case 0x0c:
  884.         menu = TFILE;                /* ^L */
  885.         item = FLOADDOC;
  886.         break;
  887.     case 0x13:
  888.         menu = TFILE;            /* ^S */
  889.         item = FSAVEDOC;
  890.         break;
  891.     case 0x1b:    
  892.         menu = TFILE;            /* ^[ */
  893.         item = FLOADCLI;
  894.         break;
  895.     case 0x1d:    
  896.         menu = TFILE;            /* ^] */
  897.         item = FSAVECLI;
  898.         break;
  899.     case 0x10:    
  900.         menu = TFILE;            /* ^P */
  901.         item = FPRINT;
  902.         break;
  903.     case 0x11:    
  904.         menu = TFILE;            /* ^Q */
  905.         item = FQUIT;
  906.         break;
  907.   /* PAGE MENU ITEMS    */
  908.     case 0x07:    
  909.         menu = TPAGE;            /* ^G */
  910.         item = PGOTO;
  911.         break;
  912.     case 0x00:
  913.         menu = TPAGE;
  914.         if(key == 0x4d00)
  915.             item = PNEXT;
  916.         else if(key == 0x4b00)
  917.             item = PPREV;
  918.         else 
  919.             item = 0;
  920.         break;
  921.     case 0x16:    
  922.         menu = TPAGE;            /* ^V */
  923.         item = PCLTOP;
  924.         break;
  925.     case 0x18:    
  926.         menu = TPAGE;            /* ^X */
  927.         item = PPTOCL;
  928.         break;
  929.     case 0x0b:    
  930.         menu = TPAGE;            /* ^K */
  931.         item = PDELCLIP;
  932.         break;
  933.   /* REGION MENU ITEMS  */
  934.     case 0x14:    
  935.         menu = TREGION;            /* ^T */
  936.         item = RTOGGLE;
  937.         break;
  938.     case 0x09:    
  939.         menu = TREGION;            /* ^I */
  940.         item = RDIMAGES;
  941.         break;
  942.     case 0x01:    
  943.         menu = TREGION;            /* ^A */
  944.         item = RGRATTR;
  945.         break;
  946.  
  947.     case 0x1C:
  948.         menu = TREGION;            /* ^\ */
  949.         item = RSCANOFF;
  950.         break;
  951.  
  952.   /* SETUP MENU ITEMS   */
  953.     case 0x06:    
  954.         menu = TSETUP;            /* ^F */
  955.         item = PPOINT;
  956.         break;
  957.     case 0x03:    
  958.         menu = TSETUP;            /* ^C */
  959.         item = CHARCPMN;
  960.         break;
  961.     case 0x08:    
  962.         menu = TSETUP;            /* ^H */
  963.         item = HYPARMN;
  964.         break;
  965.     case 0x0a:    
  966.         menu = TSETUP;            /* ^J */
  967.         item = JUSTMN;
  968.         break;
  969.     case 0x17:    
  970.         menu = TSETUP;            /* ^W */
  971.         item = WSPMN;
  972.         break;
  973.   /* OPTIONS MENU ITEMS */
  974.     case 0x12:    
  975.         menu = TOPTIONS;        /* ^R */
  976.         item = PRULER;
  977.         break;
  978.     case 0x15:
  979.         menu = TOPTIONS;
  980.         item = PUNITS;            /* ^U */
  981.         break;
  982.     case 0x0d:
  983.         menu = TOPTIONS;
  984.         item = OGRIDSP;            /* ^M */
  985.         break;
  986.     case 0x1a:        
  987.         menu = TOPTIONS;        /* ^Z */
  988.         item = OSHOWGR;
  989.         break;
  990.     case 0x0f:        
  991.         menu = TOPTIONS;        /* ^O */
  992.         item = OSNAP;
  993.         break;
  994.     default:
  995.         item = 0;
  996.         break;
  997.     }
  998.     if(item && !(ad_menu[item].ob_state & DISABLED))
  999.     {
  1000.     if(!(ad_menu[menu].ob_state & DISABLED))
  1001.         menu_handler(1,item);
  1002.     }
  1003. }
  1004.  
  1005.  
  1006.  
  1007. /**************************************************************************/
  1008. /* Function:    Mesag_handler()                          */
  1009. /* Description: Event Message Handler                      */
  1010. /**************************************************************************/
  1011. mesag_handle(msg_buff)
  1012. register int msg_buff[];
  1013. {
  1014.     switch(msg_buff[0])
  1015.     {
  1016.       case MN_SELECTED: menu_handler(msg_buff[3],msg_buff[4]);
  1017.             break;
  1018.  
  1019.       case WM_REDRAW:   do_redraw(msg_buff);
  1020.             break;
  1021.  
  1022.       case WM_TOPPED:    top_window(msg_buff[3],0L);
  1023.             do_redraw(msg_buff);
  1024.             break;
  1025.  
  1026.       case WM_CLOSED:   close_window(msg_buff[3]);
  1027.             break;
  1028.  
  1029.       case WM_FULLED:   full_window(msg_buff[3]);
  1030.             break;
  1031.  
  1032.       case WM_ARROWED:  arrow_window(msg_buff[3],msg_buff[4]);
  1033.             break;
  1034.  
  1035.       case WM_HSLID:    hslide_window(msg_buff[3],msg_buff[4]);
  1036.             break;
  1037.  
  1038.       case WM_VSLID:    vslide_window(msg_buff[3],msg_buff[4]);
  1039.             break;
  1040.  
  1041.       case WM_SIZED:    size_window(msg_buff);
  1042.             break;
  1043.  
  1044.       case WM_MOVED:    move_window(msg_buff);
  1045.             break;
  1046.     }
  1047. }
  1048.  
  1049.  
  1050. /**************************************************************************/
  1051. /* Function:    menu_handler()                          */
  1052. /* Description: Menu Control Routines                      */
  1053. /**************************************************************************/
  1054. menu_handler(menu,item)
  1055. int menu;
  1056. int item;
  1057. {
  1058.         int x,y;
  1059.     int rtmplate_flag;
  1060.         
  1061.     menu_tnormal(ad_menu,menu,1);
  1062.     switch(item)
  1063.     {
  1064.       case ABOUT:    do_about();
  1065.             active_prim = FALSE;
  1066.             ad_deskset[OK].ob_state = NORMAL;
  1067.             break;
  1068.  
  1069.       case FNEW:    
  1070.             if(alert_cntre(ALERT4) == 1)
  1071.             {
  1072.                  graf_mouse(BUSY_BEE,&dummy);
  1073.              /*    menu_ienable(ad_menu,ACREATE,FALSE);*/
  1074.                  menu_ienable(ad_menu,ODELPRIM,FALSE);
  1075.                  menu_ienable(ad_menu,OPCOORD,FALSE);
  1076.                  menu_ienable(ad_menu,OMOVEFNT,FALSE);
  1077.                  menu_ienable(ad_menu,OMOVEBAK,FALSE);
  1078.                  if(view_size == PADJCNT)
  1079.                                 wind_set(prev_handle,WF_INFO,
  1080.                       winfo[PADJCNT - PSIZE + 1][unit_type]);
  1081.                  article_flag = FALSE;
  1082.                              erase_all(1);
  1083.                  init_tattr();
  1084.                  strcpy(pfname," Preview Window ");
  1085.                  wind_set(prev_handle,WF_NAME,pfname,0,0);
  1086.                      graf_mouse(ARROW,&dummy);        
  1087.             }
  1088.             break;
  1089.  
  1090.       case FLOADDOC: 
  1091.                 graf_mouse(BUSY_BEE,&dummy);
  1092.             active_prim = FALSE;
  1093.             load_doc(0L);
  1094.             if(deferhj)
  1095.             {
  1096.                menu_icheck(ad_menu,ADEFER,0);
  1097.                deferhj = 0;
  1098.             }
  1099.                 graf_mouse(ARROW,&dummy);        
  1100.             break;
  1101.  
  1102.       case FSAVEDOC:
  1103.                 graf_mouse(BUSY_BEE,&dummy);
  1104.                 if(deferhj)
  1105.                 {
  1106.                menu_icheck(ad_menu,ADEFER,0);
  1107.                deferhj = 0;
  1108.                recalc_txtptrs();
  1109.                 }
  1110.             active_prim = FALSE;
  1111.             save_doc();
  1112.                 graf_mouse(ARROW,&dummy);        
  1113.             break;
  1114.  
  1115.       case FDINFO:  do_info();
  1116.             break;
  1117.  
  1118.       case FPRINT:     active_prim = FALSE;
  1119.             change_icstate(SELECTED,ICBOX6,1);
  1120.             output_doc();
  1121.             change_icstate(NORMAL,ICBOX6,1);
  1122.             break;
  1123.  
  1124.       case FQUIT:   if(form_alert(2,quiter) == 1)
  1125.             {
  1126.                    graf_mouse(BUSY_BEE,&dummy);
  1127.                   done = TRUE;
  1128.                       delete_clip();
  1129.               erase_all(0);
  1130.                   graf_mouse(ARROW,&dummy);        
  1131.             }
  1132.             break;
  1133.  
  1134.       case FLOADCLI:active_prim = FALSE; 
  1135.                 graf_mouse(BUSY_BEE,&dummy);
  1136.             if(!load_clipb())
  1137.             {
  1138.                clipfull = 1;
  1139.                icnptr->ib_pdata = &clipf[0];
  1140.                form_dial(3,0,0,0,0,
  1141.                 ad_bkgrnd[CLIPOBJ].ob_x,
  1142.                 ybook,
  1143.                 ad_bkgrnd[CLIPOBJ].ob_width,
  1144.                 syres - ybook);
  1145.                        menu_ienable(ad_menu,ACREATE,1);
  1146.             }
  1147.                 graf_mouse(ARROW,&dummy);        
  1148.             break;
  1149.  
  1150.       case FSAVECLI:
  1151.                  graf_mouse(BUSY_BEE,&dummy);
  1152.              save_clipb();
  1153.                  graf_mouse(ARROW,&dummy);        
  1154.              break;
  1155.  
  1156.           case FLOADTMP: graf_mouse(BUSY_BEE,&dummy);
  1157.              active_prim = FALSE;
  1158.              load_tmplate();
  1159.                    graf_mouse(ARROW,&dummy);        
  1160.              break;
  1161.     
  1162.           case FSAVETMP: graf_mouse(BUSY_BEE,&dummy);
  1163.              active_prim = FALSE;
  1164.              save_tmplate();
  1165.                   graf_mouse(ARROW,&dummy);        
  1166.              break;
  1167.  
  1168.       case FLOADTAG: graf_mouse(BUSY_BEE,&dummy);
  1169.              active_prim = FALSE;
  1170.              load_tags();
  1171.                  graf_mouse(ARROW,&dummy);        
  1172.              break;
  1173.  
  1174.       case FSAVETAG: graf_mouse(BUSY_BEE,&dummy);
  1175.              active_prim = FALSE;
  1176.              save_tags();
  1177.                  graf_mouse(ARROW,&dummy);        
  1178.              break;
  1179.  
  1180.       case PSIZE:
  1181.       case P50:
  1182.       case P75:
  1183.       case PACTUAL:
  1184.       case P200:
  1185.       case PADJCNT: do_view_size(item);
  1186.             break;
  1187.  
  1188.       case RGRATTR: do_grdialog();
  1189.             active_prim = FALSE;
  1190.             break;
  1191.  
  1192.           case RSCANOFF: 
  1193.             do_scoffset();
  1194.             active_prim = FALSE;
  1195.             break;
  1196.  
  1197.       case RCOORD: 
  1198.             do_rcoord();
  1199.             break;
  1200.  
  1201.       case PGOTO:   do_go_page();
  1202.             active_prim = FALSE;
  1203.             break;
  1204.  
  1205.       case PPREV:
  1206.       case PNEXT:   do_flip_page(item);
  1207.                 do_pagenum(curr_page,(curr_page%2)?1:0);
  1208.             active_prim = FALSE;
  1209.             break;
  1210.  
  1211.       case PDELETE: do_delpage();
  1212.             active_prim = FALSE;
  1213.             break;
  1214.  
  1215.       case PINSERT:    active_prim = FALSE;
  1216.             ins_page();
  1217.             force_draw_flag = TRUE;
  1218.             recalc_txtptrs();
  1219.             force_preview();
  1220.             break;
  1221.  
  1222.       case PRULER:  ruler_flag ^= TRUE;
  1223.             menu_text(ad_menu,PRULER,ruler_mode[ruler_flag]);
  1224.                 wind_set(prev_handle,WF_TOP,&dummy,&dummy,&dummy,&dummy);
  1225.             get_work(prev_handle);
  1226.             update_preview_blit();
  1227.             gsx_moff();
  1228.             if((view_size == PSIZE) ||
  1229.                (view_size == PADJCNT))
  1230.             {
  1231.                force_draw_flag = TRUE;
  1232.                vsf_interior(shandle,0);
  1233.                pdraw_fit(view_size);
  1234.                vr_recfl(shandle,pxy);
  1235.                zoom_setup();
  1236.                cur_scale = get_scale_num(view_size);
  1237.                get_work(prev_handle);
  1238.                update_preview_blit();
  1239.                set_clip(TRUE,&pwork);
  1240.             }
  1241.             clear_window(prev_handle,2,1);
  1242.             slider_chk();
  1243.             set_clip(TRUE,&dpwork);
  1244.             
  1245.             if(!ruler_flag)
  1246.                 xruler_offset = yruler_offset = 0;
  1247.             else
  1248.                        init_rulers();
  1249.             send_redraw(prev_handle);
  1250.             gsx_mon();
  1251.             break;
  1252.  
  1253.       case PUNITS:  if(do_unit_dialog())
  1254.             {
  1255.               if(ruler_flag)
  1256.               {
  1257.                  init_rulers();
  1258.                   if(show_grids)
  1259.                         force_preview();
  1260.                  else
  1261.                         send_redraw(prev_handle);
  1262.               }
  1263.             }
  1264.              break;
  1265.  
  1266.       case PCLTOP:  
  1267.             if(clipfull)
  1268.             {
  1269.                active_prim = FALSE;
  1270.                do_clip_dialog();
  1271.             }
  1272.                         break;
  1273.  
  1274.       case PPTOCL:  
  1275.             if(!clipfull)
  1276.             {
  1277.                    if(page_to_clip())
  1278.                {
  1279.                   clipfull = 1;
  1280.                   icnptr->ib_pdata = &clipf[0];
  1281.                   form_dial(3,0,0,0,0,
  1282.                        ad_bkgrnd[CLIPOBJ].ob_x,
  1283.                        ybook,
  1284.                        ad_bkgrnd[CLIPOBJ].ob_width,
  1285.                        syres - ybook);
  1286.                }
  1287.             }
  1288.             else
  1289.                alert_cntre(ALERT26);       
  1290.             break;
  1291.  
  1292.  
  1293.       case PDELCLIP:
  1294.             if(clipfull)
  1295.             {
  1296.                clipfull = 0;
  1297.                delete_clip();
  1298.                icnptr->ib_pdata = clipe;
  1299.                form_dial(3,0,0,0,0,
  1300.                        ad_bkgrnd[CLIPOBJ].ob_x,
  1301.                        ybook,
  1302.                        ad_bkgrnd[CLIPOBJ].ob_width,
  1303.                        syres - ybook);
  1304.             }
  1305.             break;
  1306.  
  1307.       case PPAGENUM: page_numbering();
  1308.              active_prim = FALSE;
  1309.              break;
  1310.  
  1311.           case ACREATE: make_article();
  1312.             active_prim = FALSE;
  1313.             break;
  1314.  
  1315.       case ACLOSE:  close_article();
  1316.             break;
  1317.  
  1318.       case AAUTOFL: do_autoflow();
  1319.             active_prim = FALSE;
  1320.             break;
  1321.  
  1322.       case ASAVEART: do_saveart();
  1323.              active_prim = FALSE;
  1324.              break;
  1325.  
  1326.       case ASELECT:    active_prim = FALSE;
  1327.             do_artopen();
  1328.             break;
  1329.  
  1330.       case ADELETE: do_artdelete();
  1331.             active_prim = FALSE;
  1332.             break;
  1333.  
  1334.       case ADEFER:  deferhj ^= 1;
  1335.             menu_icheck(ad_menu,ADEFER,deferhj);
  1336.             if(!deferhj)
  1337.                recalc_txtptrs();
  1338.             break;
  1339.  
  1340.       case RCREATE: rmenu_fix(1);
  1341.             active_prim = FALSE;
  1342.             genesis_region();
  1343.             
  1344.             if(bgicptr->bi_pdata == icdata)
  1345.             {
  1346.                bgicptr->bi_pdata = primicons;
  1347.                objc_offset(ad_bkgrnd,BGICBOX,&x,&y);
  1348.                ad_bkgrnd[ICBOX6].ob_state = DISABLED;
  1349.                ad_bkgrnd[ICBOX7].ob_state = DISABLED;
  1350.                ad_bkgrnd[ICBOX8].ob_state = DISABLED;
  1351.                clr_bgicons(0);
  1352.                form_dial(3,0,0,0,0,x,y,
  1353.                 ad_bkgrnd[BGICBOX].ob_width,
  1354.                 ad_bkgrnd[BGICBOX].ob_height);
  1355.             }
  1356.             clr_bgicons(1);
  1357.             change_icstate(SELECTED,(OBOX - OPOLYGON)+ICBOX2,1);
  1358.             break;
  1359.  
  1360.       case RDELETE: 
  1361.             if(alert_cntre(ALERT7) == 1)
  1362.                         {
  1363.               do_delregion();
  1364.               active_prim = FALSE;
  1365.               }
  1366.             clear_regprim_flags();
  1367.             break;
  1368.  
  1369.       case RUNLINK: do_unlinkreg();
  1370.             break;
  1371.  
  1372.           case ROPENGR: rmenu_fix(1);
  1373.             graphic_region();
  1374.             if(bgicptr->bi_pdata == icdata)
  1375.             {
  1376.                bgicptr->bi_pdata = primicons;
  1377.                objc_offset(ad_bkgrnd,BGICBOX,&x,&y);
  1378.                clr_bgicons(0);
  1379.                form_dial(3,0,0,0,0,x,y,
  1380.                 ad_bkgrnd[BGICBOX].ob_width,
  1381.                 ad_bkgrnd[BGICBOX].ob_height);
  1382.             }
  1383.             clr_bgicons(1);
  1384.             change_icstate(SELECTED,(OBOX - OPOLYGON)+ICBOX2,1);
  1385.             break;
  1386.  
  1387.       case RCLOSE:  close_region();
  1388.             break;
  1389.  
  1390.           case RTOGGLE: 
  1391.             graf_mouse(BUSY_BEE,&dummy);
  1392.             if(mode_flag)
  1393.                change_icstate(NORMAL,ICBOX3,1);
  1394.             else
  1395.                change_icstate(SELECTED,ICBOX3,1);
  1396.             clear_regprim_flags();
  1397.             display_toggle();
  1398.                     graf_mouse(ARROW,&dummy);        
  1399.             break;
  1400.  
  1401.           case RDIMAGES: image_status ^= TRUE;
  1402.              graf_mouse(BUSY_BEE,&dummy);
  1403.              if(image_status)
  1404.                 change_icstate(SELECTED,ICBOX4,1);
  1405.              else
  1406.                 change_icstate(NORMAL,ICBOX4,1);
  1407.              menu_icheck(ad_menu,RDIMAGES,image_status);
  1408.              force_draw_flag = TRUE;
  1409.              clear_regprim_flags();
  1410.              force_preview();
  1411.                  graf_mouse(ARROW,&dummy);        
  1412.              break;
  1413.  
  1414.           case RWRITE:  write_flag ^= TRUE;
  1415.             menu_text(ad_menu,RWRITE,write_mode[write_flag]);
  1416.             break;
  1417.  
  1418.       case RMOVEFNT:  graf_mouse(BUSY_BEE,&dummy);
  1419.               region_front();
  1420.                    graf_mouse(ARROW,&dummy);        
  1421.               break;
  1422.  
  1423.       case RMOVEBAK:  graf_mouse(BUSY_BEE,&dummy);
  1424.               region_back();
  1425.                   graf_mouse(ARROW,&dummy);        
  1426.               break;
  1427.  
  1428.  
  1429.       case OPOLYGON:
  1430.       case OCIRCLE:
  1431.       case OELLIPSE:
  1432.       case OBOX:
  1433.       case OLINE:
  1434.       case ORBOX:
  1435.       case OIMAGE:  
  1436.             clr_bgicons(1);
  1437.             change_icstate(SELECTED,(item - OPOLYGON)+ICBOX2,1);
  1438.             draw_items(item);
  1439.             break;
  1440.     
  1441.           case OADDPRIM:
  1442.              if(region_ptr)
  1443.              {
  1444.                rmenu_fix(1);
  1445.                reopen_region();
  1446.                if(bgicptr->bi_pdata == icdata)
  1447.                {
  1448.                  bgicptr->bi_pdata = primicons;
  1449.                  if(mode_flag)    /* Enable close box */
  1450.                     ad_bkgrnd[ICBOX1].ob_state = NORMAL;
  1451.                  if(gl_region_ptr)    /* Text region */
  1452.                  {
  1453.                     ad_bkgrnd[ICBOX6].ob_state = DISABLED;
  1454.                     ad_bkgrnd[ICBOX7].ob_state = DISABLED;
  1455.                     ad_bkgrnd[ICBOX8].ob_state = DISABLED;
  1456.                  }
  1457.                  clr_bgicons(0);
  1458.                  objc_offset(ad_bkgrnd,BGICBOX,&x,&y);
  1459.                  form_dial(3,0,0,0,0,x,y,
  1460.                  ad_bkgrnd[BGICBOX].ob_width,
  1461.                  ad_bkgrnd[BGICBOX].ob_height);
  1462.                }
  1463.                clr_bgicons(1);
  1464.                change_icstate(SELECTED,(OBOX - OPOLYGON)+ICBOX2,1);
  1465.              }
  1466.              else
  1467.                 clear_regprim_flags();
  1468.              break;
  1469.  
  1470.       case ODELPRIM: del_prim();
  1471.              break;
  1472.  
  1473.           case OPCOORD:  do_pcoord();
  1474.              break;
  1475.   
  1476.           case OMOVEFNT: graf_mouse(BUSY_BEE,&dummy);
  1477.              prim_front();
  1478.                  graf_mouse(ARROW,&dummy);        
  1479.              break;
  1480.  
  1481.       case OMOVEBAK: graf_mouse(BUSY_BEE,&dummy);
  1482.              prim_back();
  1483.                  graf_mouse(ARROW,&dummy);        
  1484.              break;
  1485.  
  1486.  
  1487.     /* Options */
  1488.       case OSHOWGR: show_grids ^= 1;
  1489.             if(show_grids)
  1490.                change_icstate(SELECTED,ICBOX7,1);
  1491.             else
  1492.                change_icstate(NORMAL,ICBOX7,1);
  1493.             menu_icheck(ad_menu,OSHOWGR,show_grids);
  1494.             force_preview();
  1495.             break;
  1496.  
  1497.       case OGRIDSP: if(do_grid_space())
  1498.             {
  1499.               if(show_grids)
  1500.                   force_preview();
  1501.             }
  1502.             break;
  1503.       case OSNAP:    snap_to_grids ^= 1;
  1504.             if(snap_to_grids)
  1505.                change_icstate(SELECTED,ICBOX8,1);
  1506.             else
  1507.                change_icstate(NORMAL,ICBOX8,1);
  1508.             menu_icheck(ad_menu,OSNAP,snap_to_grids);
  1509.             break;        
  1510.  
  1511.        case OEDITTMP: do_template_edit(); 
  1512.              active_prim = FALSE;
  1513.                break;
  1514.  
  1515.           case OERASETP: erase_template();    /* erase current template */
  1516.              active_prim = FALSE;
  1517.              break;
  1518.  
  1519.           case ODISPTMP: displ_tmpl_flag ^= TRUE;
  1520.              menu_text(ad_menu,ODISPTMP,disp_tmpl[displ_tmpl_flag]);
  1521.              force_preview();
  1522.              break;          
  1523.  
  1524.           case OTMPLOPT: set_template();
  1525.              break;
  1526.  
  1527.       case ODELTMPL: if(alert_cntre(ALERT28) == 1)
  1528.              {
  1529.               rtmplate_flag = tmplate_flag;
  1530.               active_prim = FALSE;
  1531.               delete_tmplates();
  1532.               if(tmplate_flag)
  1533.               {
  1534.                        curpage=((curr_page%2)?(right_tmplate):(left_tmplate));
  1535.                pagehd = curpage;
  1536.                curr_page = pagehd->pagenum;
  1537.                curart = arthd = ((curr_page%2)?(rtarthd):(ltarthd));
  1538.                    wind_set(prev_handle,WF_NAME,basefname,0,0);
  1539.               }
  1540.               tmplate_flag = rtmplate_flag;
  1541.               force_preview();
  1542.              }
  1543.              break;
  1544.  
  1545.       case ODPI:    do_dpi();
  1546.             active_prim = FALSE;
  1547.             break;
  1548.           
  1549.           case OCACHE:  IF_close();
  1550.             IF_open(0);        /* Free cache memory */
  1551.             break;
  1552.  
  1553.     /* setup */                
  1554.     
  1555.       case DPTDRS:    Fnt_cmd('D',"");
  1556.             active_prim = FALSE;
  1557.             break;
  1558.  
  1559.       case MDTDRS:
  1560.             Fnt_cmd('M',fntdrs);
  1561.             active_prim = FALSE;
  1562.             break;
  1563.  
  1564.       case DICTMN:
  1565.             runExDict();    
  1566.               break;
  1567.  
  1568.          case TRANMN:  runTrans();
  1569.             break;
  1570.  
  1571.       case HYLANMN:
  1572.             do_hylang();
  1573.               break;
  1574.  
  1575.       case PWUPFLMN:
  1576.             do_pwrup();
  1577.               break;
  1578. /*      case FONTSMN:*/
  1579.       case PPOINT:
  1580.             /*do_fonts();*/        /* GOG   version */
  1581.             do_point_size();    /* ATARI version */
  1582.             active_prim = FALSE;
  1583.               break;
  1584.  
  1585.       case CHARCPMN:
  1586.             do_chcomp();
  1587.             active_prim = FALSE;
  1588.               break;
  1589.       case WSPMN:
  1590.             do_wdsp();
  1591.             active_prim = FALSE;
  1592.               break;
  1593.  
  1594.       case HYPARMN:
  1595.             do_hypar();
  1596.               break;
  1597.       case JUSTMN:
  1598.             do_just();
  1599.               break;
  1600.         case SPDEF:    
  1601.             do_page_def();
  1602.             break;
  1603.  
  1604.       case SPATHS:  do_set_paths();
  1605.             break;
  1606.  
  1607.       case SDEFPARM: save_parameters();
  1608.              break;
  1609.         }
  1610. }
  1611.  
  1612.  
  1613. rmenu_fix(disable)
  1614. int disable;
  1615. {
  1616.    register int i;
  1617.  
  1618.    for(i = TFILE;i <= TOPTIONS;i++)
  1619.         menu_ienable(ad_menu,0x8000|i,disable^1);
  1620.    menu_ienable(ad_menu,0x8000|TREGION,1);
  1621.    menu_ienable(ad_menu,0x8000|TOBJECTS,1);
  1622.    if(disable)
  1623.    {
  1624.           for(i = RUNLINK;i <= RMOVEBAK;i++)
  1625.        menu_ienable(ad_menu,i,0);
  1626.     for(i = OADDPRIM;i <= OMOVEBAK;i++)
  1627.        menu_ienable(ad_menu,i,0);
  1628.     menu_ienable(ad_menu,RWRITE,TRUE);    /* still need RWRITE */
  1629.    }
  1630.    else
  1631.    {
  1632.     menu_ienable(ad_menu,0x8000|TEXT,0);
  1633.     menu_ienable(ad_menu,RTOGGLE,1);
  1634.     menu_ienable(ad_menu,RDIMAGES,1);
  1635.     menu_ienable(ad_menu,RWRITE,1);
  1636.     menu_ienable(ad_menu,RGRATTR,1);
  1637.     menu_ienable(ad_menu,RSCANOFF,1);
  1638.    }
  1639. }
  1640.  
  1641.  
  1642. amenu_fix(disable)
  1643. int disable;
  1644. {
  1645.    register int i;
  1646.  
  1647.    for(i = TFILE;i <= TOPTIONS;i++)
  1648.     menu_ienable(ad_menu,0x8000|i,disable^1);
  1649.    menu_ienable(ad_menu,0x8000|TPAGE,1);
  1650.    menu_ienable(ad_menu,0x8000|TARTICLE,1);
  1651.    menu_ienable(ad_menu,0x8000|TEXT,0);
  1652.    for(i = PSIZE;i <= PINSERT;i++)
  1653.     menu_ienable(ad_menu,i,disable^1);
  1654.    menu_ienable(ad_menu,ASELECT,disable^1);
  1655.    menu_ienable(ad_menu,ADELETE,disable^1);
  1656.    menu_ienable(ad_menu,ADEFER,disable^1);
  1657.    if(disable)
  1658.    {
  1659.     menu_ienable(ad_menu,PGOTO,1);
  1660.     menu_ienable(ad_menu,PPREV,1);
  1661.     menu_ienable(ad_menu,PNEXT,1);
  1662.    }
  1663.    else
  1664.    {
  1665.     menu_ienable(ad_menu,PADJCNT+1,0);    /* disable dashed separator*/
  1666.     menu_ienable(ad_menu,PINSERT+1,0);
  1667.    }
  1668. }
  1669.     
  1670.  
  1671. /**************************************************************************/
  1672. /* Function:    button_handler()                      */
  1673. /* Description: Mouse Button Control Routines                  */
  1674. /**************************************************************************/
  1675. button_handler(mx,my)
  1676. int mx;
  1677. int my;
  1678. {
  1679.    int whandle;
  1680.    int obj;
  1681.    int axy[4];
  1682.    int planted;
  1683.    int tmp_buff[8];
  1684.    int event;
  1685.    int omx,omy;
  1686.  
  1687.    whandle = wind_find(mx,my);
  1688.    if(!whandle)
  1689.    {
  1690.      obj = objc_find(ad_bkgrnd,BGICBOX,MAX_DEPTH,mx,my);
  1691.      if(obj != -1)
  1692.      {
  1693.         hndl_icons(obj);   
  1694.       return;
  1695.      }
  1696.    }
  1697.  
  1698.    screen_clip();                /* set screen clipping    */
  1699.  
  1700.    if(article_flag)                /* if opening a new       */
  1701.    {                        /* let's calculate links  */
  1702.       if(whandle == prev_handle)
  1703.       {
  1704.          do_hot_link(mx,my);
  1705.          return;
  1706.       }
  1707.    }
  1708.  
  1709.  
  1710.    if(funcs == &nada)                /* no primitive to draw   */
  1711.    {                        /* so we select a region  */
  1712.       if(BSTATE == 1)
  1713.               do_nada(mx,my);
  1714.       
  1715.       if(BSTATE == 2)
  1716.         do_edit_prim();
  1717.       return;
  1718.    }
  1719.  
  1720.  
  1721.  
  1722.  
  1723.     
  1724.    if((whandle != prev_handle) || !check_dpwork_box(mx,my))
  1725.                 return; /*Didn't click within work area */
  1726.  
  1727.    if(snap_to_grids)
  1728.     snap_to_grid(&mx,&my);
  1729.    pxy[0] = pxy[2] = newx = mx;
  1730.    pxy[1] = pxy[3] = newy = my;
  1731.  
  1732.    wind_update(BEG_MCTRL);
  1733.    wind_update(BEG_UPDATE);
  1734.  
  1735.    gsx_moff();
  1736.  
  1737.    if(gl_grregion_ptr)
  1738.         get_grattr(gl_grregion_ptr,glgrattr);
  1739.  
  1740.    scrn2clip();
  1741.  
  1742.    if(funcs == &poly_draw)           /* polygon drawing routine*/
  1743.    {
  1744.        if(BSTATE == 1)
  1745.              poly_handler(mx,my);
  1746.        else
  1747.        {
  1748.           gsx_mon();
  1749.           wind_update(END_UPDATE);
  1750.           wind_update(END_MCTRL);
  1751.        }   
  1752.        mclip();
  1753.        return;
  1754.    }
  1755.  
  1756.  
  1757.    button = 1;
  1758.    evnt_mouse(1,mx,my,1,1,&oldx,&oldy,&button,&key);
  1759.    if(button == 0)
  1760.    {
  1761.      gsx_mon();
  1762.      wind_update(END_UPDATE);
  1763.      wind_update(END_MCTRL);
  1764.      mclip();
  1765.      return;
  1766.    }
  1767.    
  1768.  
  1769.    while(button == 1)
  1770.    {
  1771.       graf_mkstate(&newx,&newy,&button,&key);
  1772.       if( (oldx != newx) || (oldy != newy))
  1773.       {
  1774.      do_rule_mark();
  1775.          (*funcs)(xor_handle);
  1776.          pxy[2] = newx;
  1777.          pxy[3] = newy;
  1778.          (*funcs)(xor_handle);
  1779.       }
  1780.       oldx = newx;
  1781.       oldy = newy;
  1782.    }
  1783.  
  1784.    planted = TRUE;
  1785.    axy[0] = pxy[0];
  1786.    axy[1] = pxy[1];
  1787.    axy[2] = pxy[2];
  1788.    axy[3] = pxy[3];
  1789.    omx = oldx;
  1790.    omy = oldy;
  1791.  
  1792.    while(planted)
  1793.    {
  1794.  
  1795.       evnt_which = 0;
  1796.       while((evnt_which & MU_BUTTON) == 0)
  1797.       {
  1798.         evnt_which = evnt_multi((MU_BUTTON|MU_M1),
  1799.                  1,1,1,            /* evnt button */
  1800.                  1,oldx,oldy,1,1,    /* evnt_mouse1 */
  1801.                  0,0,0,0,0,
  1802.                  &dummy,
  1803.                  0,0,
  1804.                  &newx,&newy,
  1805.                   &dummy,
  1806.                  &dummy,
  1807.                  &dummy,
  1808.                  &dummy);
  1809.  
  1810.     if((oldx != newx) || (oldy != newy))
  1811.     {
  1812.        do_rule_mark();
  1813.        (*funcs)(xor_handle);
  1814.        pxy[0] += newx - oldx;
  1815.        pxy[1] += newy - oldy;
  1816.            pxy[2] += newx - oldx;
  1817.            pxy[3] += newy - oldy;
  1818.        (*funcs)(xor_handle);
  1819.         }
  1820.         oldx = newx;
  1821.         oldy = newy;
  1822.       }
  1823.  
  1824.       if(!check_dpwork_box(newx,newy))
  1825.       {
  1826.       (*funcs)(xor_handle);            /* erase last drawn */
  1827.           newx = oldx = *gcurx = omx;
  1828.           newy = oldy = *gcury = omy;          
  1829.           Supexec(KICKAES);            /* now adjust system  */
  1830.       pxy[0] = axy[0];            /* restore old array  */
  1831.       pxy[1] = axy[1];
  1832.       pxy[2] = axy[2];
  1833.       pxy[3] = axy[3];
  1834.       (*funcs)(xor_handle);            /* and draw new line  */
  1835.       planted = TRUE;
  1836.       do_rule_mark();
  1837.           BSTATE = 0;
  1838.           event = 0;
  1839.  
  1840.           while( (BREAL == 1) || (BREAL == 2) || (BREAL == 3));    /* sit when button down */
  1841.                             
  1842.                 
  1843.           for(;;)    /* used to bleed off unwanted messages...*/
  1844.           {
  1845.         event = evnt_multi((MU_MESAG|MU_TIMER),
  1846.                     0,0,0,
  1847.                     0,0,0,0,0,
  1848.                     0,0,0,0,0,
  1849.                     tmp_buff,
  1850.                     0,0,        /* timer == 0 */
  1851.                     &dummy,&dummy,
  1852.                     &dummy,&dummy,
  1853.                     &dummy,&dummy);
  1854.  
  1855.         if(event == MU_TIMER)
  1856.                 break;
  1857.           }
  1858.           BSTATE = 0;
  1859.       }
  1860.       else
  1861.      planted = FALSE;
  1862.    }
  1863.    if(snap_to_grids)
  1864.    {
  1865.       snap_to_grid(&pxy[0],&pxy[1]);
  1866.       snap_to_grid(&pxy[2],&pxy[3]);
  1867.    }
  1868.    (*funcs)(shandle);
  1869.    button_end();
  1870. }
  1871.  
  1872.  
  1873. /**************************************************************************/
  1874. /* Function:    do_nada()                          */
  1875. /* Description: Handler for object/region/primitive selections          */
  1876. /**************************************************************************/
  1877. do_nada(mx,my)
  1878. int mx,my;
  1879. {
  1880.    int whandle;
  1881.    int direction;
  1882.    int type;
  1883.    int page;
  1884.    int x1,y1,x2,y2;
  1885.    long txtptr,slvptr;
  1886.    int found;
  1887.    long scanlist;
  1888.    int msg[8];
  1889.    REGION *rptr;
  1890.    REGION *rptr1;
  1891.    int no_go;
  1892.    int bwidth,bheight;
  1893.    int boxmu_w,boxmu_h;
  1894.  
  1895. if(whandle = wind_find(mx,my))
  1896. {
  1897.  if(whandle == prev_handle)
  1898.  {
  1899.    if(check_dpwork_box(mx,my))
  1900.    {
  1901.     
  1902.       scrntomu(mx,my,&nmx,&nmy,0);
  1903.       if(multi_mode && curr_page % 2 && view_size == PADJCNT)
  1904.       {
  1905.        nmx += hpage_size;
  1906.       }
  1907.       if(multi_mode && (nmx >= multi_box[0]) && (nmy >= multi_box[1]) &&
  1908.             (nmx <= multi_box[2]) && (nmy <= multi_box[3]))
  1909.       {
  1910.        do_move_multi(mx,my);        /* Move multiple boxes */
  1911.        return;
  1912.       }
  1913.  
  1914.       if(gl_region_ptr  || gl_grregion_ptr)
  1915.       {
  1916.  
  1917.       if(active_prim)
  1918.           { 
  1919.         edit_prims(mx,my);
  1920.         return;
  1921.           }
  1922.  
  1923.           region_ptr = ((gl_region_ptr) ? (gl_region_ptr):(gl_grregion_ptr));    
  1924.       if(check_boxes(mx,my))
  1925.                return;
  1926.  
  1927.           if(inside_region(nmx,nmy,region_ptr,
  1928.               &rect_in_mu[0],&rect_in_mu[1],
  1929.               &rect_in_mu[2],&rect_in_mu[3],&type,&page))
  1930.           {
  1931.              if( (((page % 2) && alt_offset) ||
  1932.              (!( page % 2) && !alt_offset) && (view_size == PADJCNT)) 
  1933.              || (view_size != PADJCNT))
  1934.              {
  1935.         if(alt_offset)
  1936.             {
  1937.            rect_in_mu[0] += hpage_size;
  1938.            rect_in_mu[2] += hpage_size;
  1939.             }
  1940.                 do_move_region(mx,my,type);
  1941.             return;
  1942.              }
  1943.  
  1944.           }
  1945.       }    
  1946.   } /* if check dpwork_box()      */
  1947.   else
  1948.      active_prim = FALSE;
  1949.  }  /* check if in prev_handle    */
  1950.  else
  1951.      active_prim = FALSE;
  1952. }   /* check if clicked on window */
  1953. else
  1954.      active_prim = FALSE;
  1955.  
  1956.  
  1957.    if(whandle = wind_find(mx,my))
  1958.    {
  1959.       if(whandle == prev_handle)
  1960.       {
  1961.         if(check_dpwork_box(mx,my))
  1962.         {
  1963.             scrntomu(mx,my,&nmx,&nmy,0);
  1964.  
  1965.                        /* alt_offset set by scrntomu()*/
  1966.                 /* 0 - clicked on left page    */
  1967.                 /* 1 - clicked on right page   */
  1968.  
  1969.             if(view_size == PADJCNT)
  1970.         {
  1971.            if(curr_page % 2)        /*right active */
  1972.            no_go = ((!alt_offset)?(TRUE):(FALSE));
  1973.            else                /* left active */
  1974.            no_go = ((!alt_offset)?(FALSE):(TRUE));
  1975.             }
  1976.         else
  1977.            no_go = FALSE;            /* not adjacent pages */
  1978.  
  1979.  
  1980.             if(!no_go)
  1981.         {
  1982.                region_ptr = find_region(nmx,nmy,curr_page,
  1983.                                      &rect_in_mu[0],&rect_in_mu[1],
  1984.                                     &rect_in_mu[2],&rect_in_mu[3],&type);
  1985.  
  1986.  
  1987.            if(alt_offset && (view_size == PADJCNT))
  1988.            {
  1989.           rect_in_mu[0] += hpage_size;
  1990.               rect_in_mu[2] += hpage_size;
  1991.            }
  1992.  
  1993.         }
  1994.         else
  1995.            region_ptr = 0L;
  1996.  
  1997.  
  1998.  
  1999.             if(region_ptr)
  2000.             {
  2001.              do_blit();
  2002.          if((kstat & 0x0001)||(kstat & 0x0002))     /* multi-box */
  2003.          {
  2004.             if(gl_region_ptr)
  2005.             rptr = (REGION *)gl_region_ptr;
  2006.             else if(gl_grregion_ptr)
  2007.             rptr = (REGION *)gl_grregion_ptr;
  2008.             else 
  2009.             rptr = 0L;
  2010.             if(rptr)
  2011.             {
  2012.             rptr->multi_select = 1;
  2013.             }
  2014.             if(rptr || multi_mode)
  2015.             {
  2016.             rptr1 = (REGION *)region_ptr;
  2017.             rptr1->multi_select = 1;
  2018.             calc_multbox(multi_box);
  2019.             multi_mode = 1;
  2020.             gl_region_ptr = gl_grregion_ptr = 0L;
  2021.                  menu_ienable(ad_menu,RCOORD,FALSE);
  2022.                  menu_ienable(ad_menu,OADDPRIM,FALSE);
  2023.                  menu_ienable(ad_menu,RMOVEFNT,FALSE);
  2024.                 menu_ienable(ad_menu,RMOVEBAK,FALSE);
  2025.             }
  2026.          }
  2027.          else
  2028.          {
  2029.             clr_multi_flags(curr_page);
  2030.             multi_mode = 0;
  2031.          }
  2032.          gsx_moff();
  2033.          if(multi_mode)
  2034.          {
  2035.                     mutoscrn(multi_box[0],multi_box[1],&pxy[0],&pxy[1],0);
  2036.                     mutoscrn(multi_box[2],multi_box[3],&pxy[2],&pxy[3],0);
  2037.             do_outer(xor_handle,pxy);     /* don't draw size boxes */
  2038.          }
  2039.          else
  2040.          {
  2041. /*********        if(!mode_flag)         only of non-text display */
  2042.                  menu_ienable(ad_menu,OADDPRIM,TRUE);
  2043.             menu_ienable(ad_menu,RUNLINK,TRUE);
  2044.             menu_ienable(ad_menu,RDELETE,TRUE);
  2045.             menu_ienable(ad_menu,RCOORD,TRUE);
  2046.             menu_ienable(ad_menu,RMOVEFNT,TRUE);
  2047.             menu_ienable(ad_menu,RMOVEBAK,TRUE);
  2048.                     mutoscrn(rect_in_mu[0],rect_in_mu[1],&pxy[0],&pxy[1],0);
  2049.                     mutoscrn(rect_in_mu[2],rect_in_mu[3],&pxy[2],&pxy[3],0);
  2050.             do_outline(xor_handle,pxy);
  2051.          }
  2052.          gsx_mon();
  2053.  
  2054.                  if(!type)
  2055.                  {
  2056.                       gl_region_ptr = region_ptr;
  2057.            gl_grregion_ptr = 0L;
  2058.                    get_txtattr(gl_region_ptr,&gltxtattr);
  2059.                    update_point_dialog();
  2060.  
  2061.                    zdevice = SCANNER;
  2062.                    SH = vmutopix((int)gltxtattr.lnsp);
  2063.            
  2064.  
  2065.            if(kstat & 0x0008)        /* alt click    */
  2066.            {
  2067.             found = 0;
  2068.             scanlist = getf_scaninfo(region_ptr,&x1,&y1,
  2069.                         &x2,&y2,&txtptr,&slvptr);
  2070.             while(scanlist)
  2071.             {
  2072.                 if(nmx >= x1 && nmx <= x2 && nmy >= y1 &&
  2073.                    nmy <= y2)
  2074.                 {
  2075.                 found = 1;
  2076.                 break;
  2077.                 }
  2078.                 scanlist = getn_scaninfo(&x1,&y1,&x2,&y2,
  2079.                     &txtptr,&slvptr);
  2080.             }
  2081.             if(found)
  2082.             {
  2083.                 top_window(txt_handle,txtptr);
  2084.                 wind_get(txt_handle,WF_CURRXYWH,&msg[4],
  2085.                 &msg[5],&msg[6],&msg[7]);
  2086.                 msg[3] = txt_handle;
  2087.                 do_redraw(msg);
  2088.             }
  2089.            }
  2090.             
  2091.                  }
  2092.              else
  2093.                  {
  2094.             gl_grregion_ptr = region_ptr;
  2095.             gl_region_ptr = 0L;
  2096.                     get_grattr(gl_grregion_ptr,glgrattr);
  2097.                     gl_lstyle = glgrattr[0];
  2098.                       gl_lwidth = glgrattr[1];
  2099.                       gl_fstyle = glgrattr[2];
  2100.                       gl_findex = glgrattr[3];
  2101.             gl_repel  = glgrattr[4];
  2102.             gl_repbounds = glgrattr[6];
  2103.             gl_repoffset = glgrattr[5];
  2104.                  }
  2105.              evnt_button(1,1,0,&dummy,&dummy,&dummy,&dummy);
  2106.            }
  2107.            else
  2108.        {
  2109.           if(gl_region_ptr  || gl_grregion_ptr || multi_mode)
  2110.           {
  2111.              check_only_blit();
  2112.           }
  2113.  
  2114.           if(valid_page(curr_page))
  2115.           {
  2116.                 graf_rubbox(mx,my,0,0,&bwidth,&bheight);
  2117.                 scrntomu(bwidth,bheight,&boxmu_w,&boxmu_h,1);
  2118.                 do_calc_multi(nmx,nmy,boxmu_w,boxmu_h);
  2119.           }
  2120.            }
  2121.  
  2122.        }            /* if(check_dpwork_box()     */
  2123.        else
  2124.       check_only_blit();
  2125.       }                /* if whandle == prev_handle */
  2126.    }
  2127.    else
  2128.    {
  2129.     check_only_blit();
  2130.      if(icon_clicked(mx,my))
  2131.        if(animate_icon(mx,&direction))
  2132.           do_flip_page(direction);    
  2133.    }
  2134. }
  2135.  
  2136.  
  2137.  
  2138.  
  2139. do_calc_multi(x,y,w,h)
  2140. int x,y,w,h;
  2141. {
  2142.    int rubbox[4];
  2143.    int rect[4];
  2144.    int pxy[4];
  2145.    register REGION *rptr;
  2146.    int found;
  2147.  
  2148.    found = 0;
  2149.    rptr = curpage->regptr;
  2150.    rubbox[0] = x;
  2151.    rubbox[1] = y;
  2152.    rubbox[2] = x + w - 1;
  2153.    rubbox[3] = y + h - 1;
  2154.    while(rptr)
  2155.    {
  2156.     rect[0] = rptr->x1;
  2157.         rect[1] = rptr->y1;
  2158.         rect[2] = rptr->x2;
  2159.         rect[3] = rptr->y2;
  2160.     if(rect_intersect(rubbox,rect))
  2161.     {
  2162.        found = 1;
  2163.        rptr->multi_select = 1;
  2164.     }
  2165.     rptr = rptr->plink;
  2166.    }
  2167.    multi_mode = found;
  2168.    if(multi_mode)
  2169.    {
  2170.       menu_ienable(ad_menu,RUNLINK,TRUE);
  2171.       menu_ienable(ad_menu,RDELETE,TRUE);
  2172.       calc_multbox(multi_box);
  2173.       mutoscrn(multi_box[0],multi_box[1],&pxy[0],&pxy[1],0);
  2174.       mutoscrn(multi_box[2],multi_box[3],&pxy[2],&pxy[3],0);
  2175.       gsx_moff();
  2176.       do_outer(xor_handle,pxy);     /* don't draw size boxes */
  2177.       gsx_mon();
  2178.    }
  2179. }
  2180.  
  2181. /**************************************************************************/
  2182. /* Function:    screen_clip()                          */
  2183. /* Description:                               */
  2184. /**************************************************************************/
  2185. screen_clip()
  2186. {
  2187.    set_clip(TRUE,&dpwork);
  2188.    grect_to_array(&dpwork,clip_area);
  2189.    vs_clip(xor_handle,TRUE,clip_area);
  2190.    grect_to_array(&pwork,clip_area);
  2191.    vs_clip(rule_handle,TRUE,clip_area);
  2192. }
  2193.  
  2194.  
  2195.  
  2196. /**************************************************************************/
  2197. /* Function: scrn2clip()                          */
  2198. /* Description: Allows clipping settings for PADJCNT              */
  2199. /**************************************************************************/
  2200. scrn2clip()
  2201. {
  2202.   GRECT  tpwork;
  2203.  
  2204.   if(view_size == PADJCNT)
  2205.   {
  2206.        tpwork.g_w = dpwork.g_w / 2;
  2207.        tpwork.g_h = dpwork.g_h;
  2208.        tpwork.g_y = dpwork.g_y;
  2209.        tpwork.g_x = ((curr_page % 2) ? (dpwork.g_x + tpwork.g_w):(dpwork.g_x));
  2210.        set_clip(TRUE,&tpwork);
  2211.   }
  2212.   else
  2213.      set_clip(TRUE,&dpwork);
  2214.   grect_to_array(&dpwork,clip_area);
  2215.   vs_clip(xor_handle,TRUE,clip_area);
  2216.   grect_to_array(&pwork,clip_area);
  2217.   vs_clip(rule_handle,TRUE,clip_area);
  2218.  
  2219.  
  2220. }
  2221.  
  2222.  
  2223.  
  2224. /**************************************************************************/
  2225. /* Function:    poly_handler()                          */
  2226. /* Description: Polygon handler                          */
  2227. /**************************************************************************/
  2228. poly_handler(mx,my)
  2229. int mx,my;
  2230. {
  2231.      pxy[0] = pxyarray[0] = pxyarray[2] = mx;
  2232.      pxy[1] = pxyarray[1] = pxyarray[3] = my;
  2233.      num    = 1;
  2234.      aindex  = 2;
  2235.  
  2236.  
  2237.      while(BSTATE != 2)
  2238.      {
  2239.          while((BSTATE != 1) && (BSTATE != 2) && (BSTATE != 3))
  2240.          {
  2241.             graf_mkstate(&newx,&newy,&button,&key);
  2242.             if((oldx != newx) || (oldy != newy))
  2243.             {
  2244.           if(snap_to_grids)
  2245.          snap_to_grid(&newx,&newy);
  2246.           do_rule_mark();
  2247.               (*funcs)(xor_handle,2);
  2248.           pxyarray[2] = newx;
  2249.               pxyarray[3] = newy;
  2250.               (*funcs)(xor_handle,2);              
  2251.         }
  2252.         oldx = newx;
  2253.         oldy = newy;
  2254.          }
  2255.      
  2256.      if(BSTATE == 1)
  2257.          {
  2258.             v_pline(xor_handle,2,pxyarray);
  2259.             v_pline(xor_handle,2,pxyarray);
  2260.             pxy[aindex++] = pxyarray[2];
  2261.          pxy[aindex++] = pxyarray[3];
  2262.         pxyarray[0] = pxyarray[2];
  2263.         pxyarray[1] = pxyarray[3];
  2264.             num++;
  2265.         BSTATE = 0;
  2266.         if(num > 125)        /* max of 125 vertices */
  2267.           BSTATE = 2;        /* so exit immediately.*/
  2268.          }
  2269.      }
  2270.      evnt_button(1,1,0,&dummy,&dummy,&dummy,&dummy);
  2271.      evnt_button(1,2,0,&dummy,&dummy,&dummy,&dummy);
  2272.      (*funcs)(xor_handle,2);
  2273.      (*funcs)(shandle,num);
  2274.      button_end();
  2275. }
  2276.  
  2277.  
  2278.  
  2279.  
  2280. /**************************************************************************/
  2281. /* Function:    button_end()                          */
  2282. /* Description: Button handler and poly_handler completion routines      */
  2283. /**************************************************************************/
  2284. button_end()
  2285. {
  2286.    int pxy[4];
  2287.  
  2288.    if(view_size == PADJCNT)
  2289.    {
  2290.       pxy[0] = pxy[2] = pagew/2;
  2291.       pxy[1] = 0;
  2292.       pxy[3] = pageh;
  2293.       v_pline(mhandle,2,pxy);
  2294.    }
  2295.  
  2296.    do_blit();
  2297.    set_clip(TRUE,&dpwork);
  2298.    gsx_mon();
  2299.    mclip();
  2300.    wind_update(END_UPDATE);
  2301.    wind_update(END_MCTRL);
  2302.    evnt_button(1,1,0,&dummy,&dummy,&dummy,&dummy);
  2303. }
  2304.  
  2305.  
  2306.  
  2307. /**************************************************************************/
  2308. /* Function:    check_region_ptr                      */
  2309. /* Description: checks for active graphic or text region          */
  2310. /**************************************************************************/
  2311. check_region_ptr()
  2312. {
  2313.     if(gl_region_ptr || gl_grregion_ptr || multi_mode)
  2314.     {
  2315.        if(multi_mode)
  2316.        {
  2317.       clr_multi_flags(curr_page);
  2318.       multi_mode = 0;
  2319.        }
  2320.        region_ptr = gl_grregion_ptr = gl_region_ptr = 0L;
  2321.        active_prim = FALSE;
  2322.        force_blit_redraw(0);
  2323.     }
  2324. }
  2325.  
  2326.  
  2327.  
  2328.  
  2329.  
  2330. /**************************************************************************/
  2331. /* Function:    check_only_blit                          */
  2332. /* Description:    Checks if a blit is all that is needed              */
  2333. /**************************************************************************/
  2334. check_only_blit()
  2335. {
  2336.        gl_grregion_ptr = gl_region_ptr = 0L;
  2337.        if(multi_mode)
  2338.        {
  2339.           clr_multi_flags(curr_page);
  2340.           multi_mode = 0;
  2341.        }
  2342.        menu_ienable(ad_menu,RDELETE,FALSE);
  2343.        menu_ienable(ad_menu,RUNLINK,FALSE);
  2344.        menu_ienable(ad_menu,RCOORD,FALSE);
  2345.        menu_ienable(ad_menu,OADDPRIM,FALSE);
  2346.        menu_ienable(ad_menu,RMOVEFNT,FALSE);
  2347.        menu_ienable(ad_menu,RMOVEBAK,FALSE);
  2348.        do_blit();
  2349. }
  2350.  
  2351.  
  2352.  
  2353.  
  2354. /**************************************************************************/
  2355. /* Function:    do_delregion()                          */
  2356. /* Description:  Delete the currently selected region              */
  2357. /**************************************************************************/
  2358. do_delregion()
  2359. {
  2360. int dummy;
  2361. long tmp;
  2362. long nextregion;
  2363. int rect[4];
  2364.  
  2365.    if((!gl_grregion_ptr)&&(!gl_region_ptr) && !multi_mode)
  2366.    {
  2367.     clear_regprim_flags();
  2368.     return;
  2369.    }
  2370.         if(multi_mode)
  2371.     {
  2372.        do_delmulti();
  2373.        return;
  2374.  
  2375.         }
  2376.     if(gl_grregion_ptr)
  2377.     {
  2378.        find_boundary(gl_grregion_ptr,&rect[0],&rect[1],&rect[2],
  2379.              &rect[3],&dummy,&dummy);
  2380.             tmp = 0L;
  2381.        delete_region(gl_grregion_ptr);
  2382.        gl_grregion_ptr = 0L;
  2383.        update_repel(0,rect);
  2384.     }
  2385.     else
  2386.     {
  2387.        find_boundary(gl_region_ptr,&rect[0],&rect[1],&rect[2],
  2388.              &rect[3],&dummy,&dummy);
  2389.        tmp = get_regart(gl_region_ptr);
  2390.        if(tmp)
  2391.        {
  2392.           curregion = gl_region_ptr;
  2393.           nextregion = prev_aregion(curregion); /* To properly clean up */
  2394.           if(!nextregion)   /* we must get the region before the deleted*/
  2395.                 /* one. If 0L then start from the next one  */
  2396.          nextregion = getn_aregion(&dummy,&dummy,&dummy,&dummy,&dummy);
  2397.        }        
  2398.        delete_region(gl_region_ptr);
  2399.        
  2400.     }
  2401.     if(tmp)
  2402.     {
  2403.        open_article(tmp);
  2404.        if(nextregion)
  2405.           page_redraw(nextregion);
  2406.        graf_mouse(ARROW,&dummy);
  2407.     }
  2408.  
  2409.     if(view_size == PADJCNT)
  2410.                  force_preview();
  2411.      
  2412.         if((view_size != PADJCNT) && !deferhj)
  2413.         redraw_area(0L,rect,1);
  2414.         clear_regprim_flags();
  2415.     if(curpage->regptr == 0L )        /* If no more regions on    */
  2416.     {                    /* the page..delete the page*/
  2417.         delete_page();
  2418.         recalc_txtptrs();
  2419.         force_preview();
  2420.     }
  2421. }    
  2422.  
  2423.  
  2424.  
  2425. do_delmulti()
  2426. {
  2427. int dummy;
  2428. long tmp;
  2429. long nextregion;
  2430. int rect[4];
  2431. register REGION *rptr;
  2432. REGION *nextptr;
  2433. REGION *tmpregion;
  2434.  
  2435.    multi_mode = 0;
  2436.    tmpregion = curregion;
  2437.    rptr = curpage->regptr;
  2438.    while(rptr)
  2439.    {
  2440.       nextptr = rptr->plink;
  2441.       if(rptr->multi_select)
  2442.       {
  2443.     if(rptr->type)
  2444.     {
  2445.        find_boundary(rptr,&rect[0],&rect[1],&rect[2],
  2446.              &rect[3],&dummy,&dummy);
  2447.             tmp = 0L;
  2448.        delete_region(rptr);
  2449.            gl_grregion_ptr = 0L;
  2450.        update_repel(0,rect);
  2451.     }
  2452.     else
  2453.     {
  2454.        find_boundary(rptr,&rect[0],&rect[1],&rect[2],
  2455.              &rect[3],&dummy,&dummy);
  2456.        tmp = get_regart(rptr);
  2457.        if(tmp)
  2458.        {
  2459.           curregion = rptr;
  2460.           nextregion = prev_aregion(curregion);
  2461.           if(!nextregion)
  2462.          nextregion = getn_aregion(&dummy,&dummy,&dummy,&dummy,&dummy);
  2463.        }        
  2464.        delete_region(rptr);
  2465.     }
  2466.     if(tmp)
  2467.     {
  2468.  
  2469.        open_article(tmp);
  2470.        if(nextregion)
  2471.           page_redraw(nextregion);
  2472.        graf_mouse(ARROW,&dummy);
  2473.     }
  2474.     redraw_area(0L,rect,1);
  2475.       }
  2476.      rptr = nextptr;
  2477.    }
  2478.    curregion = tmpregion;
  2479.    clr_multi_flags(curr_page);
  2480. /*   multi_mode = 0;  */
  2481.    clear_regprim_flags();
  2482.    if(curpage->regptr == 0L )            /* if no more regions on the */
  2483.    {                        /* page, delete the page too */
  2484.     delete_page();
  2485.     recalc_txtptrs();
  2486.      force_preview();
  2487.    }
  2488. }
  2489.  
  2490.  
  2491. /**************************************************************************/
  2492. /* Function:    do_unlinkreg();                          */
  2493. /* Description:  unlink  the currently selected region    from it's article */
  2494. /**************************************************************************/
  2495. do_unlinkreg()
  2496. {
  2497. int dummy;
  2498. long tmp;
  2499. long nextregion;
  2500. int rect[4];
  2501.  
  2502.    if(multi_mode)
  2503.    {
  2504.     do_multunlink();
  2505.     return;
  2506.    }
  2507.    if(!gl_region_ptr)
  2508.    {
  2509.     clear_regprim_flags();
  2510.     return;
  2511.    }
  2512.    active_prim = FALSE;
  2513.    tmp = get_regart(gl_region_ptr);
  2514.    if(tmp)
  2515.    {
  2516.        find_boundary(gl_region_ptr,&rect[0],&rect[1],&rect[2],
  2517.              &rect[3],&dummy,&dummy);
  2518.        curregion = gl_region_ptr;
  2519.        nextregion = prev_aregion(curregion);
  2520.        if(!nextregion)
  2521.                nextregion = getn_aregion(&dummy,&dummy,&dummy,&dummy,&dummy);
  2522.    }
  2523.    unlink_region(gl_region_ptr);
  2524.  
  2525.    if(tmp)
  2526.    {
  2527.       graf_mouse(2,&dummy);
  2528.       open_article(tmp);
  2529.       if(nextregion)
  2530.           page_redraw(nextregion);
  2531.       graf_mouse(ARROW,&dummy);
  2532.    }
  2533.    redraw_area(gl_region_ptr,rect,1);
  2534.    clear_regprim_flags();
  2535. }
  2536.  
  2537.  
  2538. do_multunlink()
  2539. {
  2540. int dummy;
  2541. long tmp;
  2542. int rect[4];
  2543. REGION *nextregion;
  2544. register REGION *rptr;
  2545. REGION *tmpregion;
  2546.  
  2547.    multi_mode = 0;
  2548.    tmpregion = curregion;
  2549.    rptr = curpage->regptr;
  2550.    while(rptr)
  2551.    {
  2552.       if(rptr->multi_select)
  2553.       {
  2554.     if(!rptr->type)
  2555.            {
  2556.        tmp = get_regart(rptr);
  2557.        if(tmp)
  2558.        {
  2559.             find_boundary(rptr,&rect[0],&rect[1],&rect[2],
  2560.              &rect[3],&dummy,&dummy);
  2561.           curregion = rptr;
  2562.           nextregion = prev_aregion(curregion);
  2563.           if(!nextregion)
  2564.          nextregion = getn_aregion(&dummy,&dummy,&dummy,&dummy,&dummy);
  2565.        }        
  2566.        unlink_region(rptr);
  2567.        if(tmp)
  2568.        {
  2569.           open_article(tmp);
  2570.           if(nextregion)
  2571.              page_redraw(nextregion);
  2572.           graf_mouse(ARROW,&dummy);
  2573.              redraw_area(0L,rect,1);
  2574.        }
  2575.         }
  2576.       }
  2577.       rptr = rptr->plink;
  2578.    }
  2579.    curregion = tmpregion;
  2580.    clr_multi_flags(curr_page);
  2581.    clear_regprim_flags();
  2582. }
  2583.  
  2584. /**************************************************************************/
  2585. /* Function:    do_delpage()                          */
  2586. /* Description:  Delete the current page.                  */
  2587. /**************************************************************************/
  2588. do_delpage()
  2589. {
  2590.    register PAGE *pptr;
  2591.    register REGION *rptr;
  2592.  
  2593.    if(alert_cntre(ALERT6) == 1)
  2594.    {    
  2595.     if(valid_page(curr_page))
  2596.         {
  2597.        delete_page();            /* Delete and recalc text ptrs    */
  2598.         }
  2599.         else
  2600.         {
  2601.            pptr = pagehd;        /* all pages AFTER the current one  */
  2602.            do                /* have their page numbers bumped   */
  2603.            {                /* DOWN by 1 due to deletion of page*/
  2604.               if(pptr->pagenum > curr_page)
  2605.               {
  2606.                 pptr->pagenum -= 1;
  2607.                 rptr = pptr->regptr;
  2608.             while(rptr)
  2609.             {
  2610.            rptr->p = pptr->pagenum;
  2611.            rptr = rptr->plink;
  2612.         }
  2613.                 }
  2614.               pptr = pptr->nextpage;
  2615.            }while(pptr != NULLPTR);
  2616.         }
  2617.     recalc_txtptrs();
  2618.     force_preview();
  2619.    }
  2620. }
  2621.     
  2622.  
  2623.  
  2624.  
  2625. /**************************************************************************/
  2626. /* Function: do_move_region()                          */
  2627. /* Description: Handles a selected region that is moved...          */
  2628. /**************************************************************************/
  2629. do_move_region(mx,my,type)
  2630. int mx,my;
  2631. int type;
  2632. {
  2633.          int opcode;
  2634.     int fflag;
  2635.     int fx,fy;
  2636.         register int i;
  2637.     long tregion_ptr;
  2638.     int mbutton;
  2639.     int toggle;
  2640.     int tempx,tempy;
  2641.     int page;
  2642.     int line_flag;
  2643.         int gtype;
  2644.  
  2645.     mutoscrn(rect_in_mu[0],rect_in_mu[1],&pxy[0],&pxy[1],0);
  2646.     mutoscrn(rect_in_mu[2],rect_in_mu[3],&pxy[2],&pxy[3],0);
  2647.  
  2648.     voldx = oldx = mx;
  2649.     voldy = oldy = my;
  2650.     
  2651.     graf_mouse(4,&dummy);
  2652.  
  2653.             
  2654.         line_flag=(((pxy[0]==pxy[2])||(pxy[1]==pxy[3]))?(TRUE):(FALSE));
  2655.  
  2656.     gsx_moff();
  2657.     do_outline(xor_handle,pxy);
  2658.     if(line_flag)
  2659.         do_outer(xor_handle,pxy);
  2660.     else
  2661.         do_box(xor_handle,pxy[0],pxy[1],pxy[2],pxy[3]);
  2662.     gsx_mon();
  2663.  
  2664.     mbutton = TRUE;
  2665.     while(mbutton)
  2666.     {
  2667.         graf_mkstate(&newx,&newy,&mbutton,&dummy);
  2668.         if((oldx != newx) || (oldy != newy))
  2669.         {
  2670.           gsx_moff();
  2671.           do_rule_mark();
  2672.           if(line_flag)
  2673.             do_outer(xor_handle,pxy);
  2674.           else
  2675.             do_box(xor_handle,pxy[0],pxy[1],pxy[2],pxy[3]);
  2676.           pxy[0] += newx - oldx;
  2677.           pxy[1] += newy - oldy;
  2678.           pxy[2] += newx - oldx;
  2679.           pxy[3] += newy - oldy;
  2680.           if(line_flag)
  2681.             do_outer(xor_handle,pxy);
  2682.           else
  2683.             do_box(xor_handle,pxy[0],pxy[1],pxy[2],pxy[3]);
  2684.           gsx_mon();          
  2685.         }
  2686.             oldx = newx;
  2687.         oldy = newy;
  2688.     }
  2689.  
  2690.   if(check_dpwork_box(newx,newy))
  2691.   {    
  2692.     if((voldx != newx) || (voldy != newy))
  2693.     {
  2694.        deltax = newx - voldx;
  2695.        deltay = newy - voldy;
  2696.        fx = ((deltax < 0) ? (-1) : (1));
  2697.        fy = ((deltay < 0) ? (-1) : (1));
  2698.  
  2699.        scrntomu(abs(newx - voldx),abs(newy - voldy),&deltax,&deltay,1);
  2700.  
  2701.        deltax *= fx;
  2702.        deltay *= fy;
  2703.        
  2704.        if(snap_to_grids)
  2705.        {
  2706.         tempx = deltax + rect_in_mu[0];
  2707.         tempy = deltay + rect_in_mu[1];
  2708.         snap_mu(&tempx,&tempy);
  2709.         deltax = tempx - rect_in_mu[0];
  2710.         deltay = tempy - rect_in_mu[1];
  2711.            }       
  2712.  
  2713.            if(kstat & 0x0004)
  2714.            {
  2715.             copy_region();
  2716.             return;
  2717.            }
  2718.  
  2719.        opcode = get_fprimitive(region_ptr,&count,&wmode);
  2720.        fflag = TRUE;
  2721.        while(opcode != -1)
  2722.        {
  2723.         switch(opcode)
  2724.         {
  2725.             case 3:
  2726.             case 4:
  2727.             case 0: toggle = TRUE;
  2728.                     for(i=0;i<(count*2);i++)
  2729.                 {
  2730.                    ptsarray[i] += ((toggle) ? (deltax):(deltay));
  2731.                    toggle ^= TRUE;
  2732.                 }
  2733.                 break;
  2734.  
  2735.             case 1: ptsarray[0] += deltax;
  2736.                 ptsarray[1] += deltay;
  2737.                 break;
  2738.  
  2739.             case 2: ptsarray[0] += deltax;
  2740.                 ptsarray[2] += deltax;
  2741.                 ptsarray[1] += deltay;
  2742.                 ptsarray[3] += deltay;
  2743.                 break;
  2744.        
  2745.         }    /* end of switch(opcode) */
  2746.         update_primitive(opcode,count,wmode,fflag);
  2747.         fflag = FALSE;
  2748.         opcode = get_nprimitive(&count,&wmode);
  2749.        }        /* end of while         */
  2750.  
  2751.        tregion_ptr = region_ptr;
  2752.        graf_mkstate(&mx,&my,&mbutton,&dummy);
  2753.  
  2754.        if(gl_region_ptr)
  2755.        {        
  2756.         page_redraw(region_ptr);
  2757.         gtype = FALSE;
  2758.        }
  2759.        else
  2760.        {
  2761.         update_repel(1,rect_in_mu);
  2762.         gtype = TRUE;
  2763.        }
  2764.          if(view_size != PADJCNT && !deferhj && gl_region_ptr)
  2765.           redraw_area(tregion_ptr,rect_in_mu,1);    /* Cleanup old area */
  2766.        if(gtype)
  2767.         gl_grregion_ptr = tregion_ptr;
  2768.        else
  2769.         gl_region_ptr = tregion_ptr;
  2770.        region_ptr = tregion_ptr;
  2771.        find_boundary(tregion_ptr,
  2772.                   &rect_in_mu[0],&rect_in_mu[1],
  2773.                   &rect_in_mu[2],&rect_in_mu[3],&dummy,&page);
  2774.  
  2775.        if((page % 2) && (view_size == PADJCNT))
  2776.        {
  2777.         alt_offset = TRUE;
  2778.         rect_in_mu[0] += hpage_size;
  2779.         rect_in_mu[2] += hpage_size;
  2780.        }
  2781.        mutoscrn(rect_in_mu[0],rect_in_mu[1],&pxy[0],&pxy[1],0);
  2782.        mutoscrn(rect_in_mu[2],rect_in_mu[3],&pxy[2],&pxy[3],0);
  2783.        gsx_moff();
  2784.        do_outline(xor_handle,pxy);
  2785.        gsx_mon();
  2786.     }
  2787.     else
  2788.     {
  2789.        gsx_moff();
  2790.        do_outline(xor_handle,pxy);
  2791.        do_box(xor_handle,pxy[0],pxy[1],pxy[2],pxy[3]);
  2792.        gsx_mon();
  2793.     }
  2794.    }
  2795.    else
  2796.    {
  2797.       gsx_moff();
  2798.       do_blit();
  2799.       find_boundary(region_ptr,&rect_in_mu[0],&rect_in_mu[1],
  2800.             &rect_in_mu[2],&rect_in_mu[3],&dummy,&dummy);
  2801.       if((curr_page % 2) && (view_size == PADJCNT))
  2802.       {
  2803.     alt_offset = TRUE;
  2804.     rect_in_mu[0] += hpage_size;
  2805.     rect_in_mu[2] += hpage_size;
  2806.       }
  2807.       mutoscrn(rect_in_mu[0],rect_in_mu[1],&pxy[0],&pxy[1],0);
  2808.       mutoscrn(rect_in_mu[2],rect_in_mu[3],&pxy[2],&pxy[3],0);
  2809.  
  2810.       do_outline(xor_handle,pxy);
  2811.       gsx_mon();
  2812.    }
  2813.     graf_mouse(0,&dummy);
  2814. }
  2815.  
  2816.  
  2817.  
  2818. /**************************************************************************/
  2819. /* Function: do_move_multi()                          */
  2820. /* Description: Handles moving multiple regions                  */
  2821. /**************************************************************************/
  2822. do_move_multi(mx,my)
  2823. int mx,my;
  2824. {
  2825.          int opcode;
  2826.     int fflag;
  2827.     int fx,fy,i;
  2828.     int mbutton;
  2829.     int toggle;
  2830.     long art;
  2831.     int tempx,tempy;
  2832.         register REGION *rptr;
  2833.         int type;
  2834.         long tmpcurregion;
  2835.         register long *rtable;
  2836.         register int rcount;
  2837.         long rtblsize;
  2838.         int line_flag;
  2839.         REGION *saveregion;
  2840.  
  2841.     rcount = 0;
  2842.         rptr = curpage->regptr;
  2843.     while(rptr)            /* How many selected regions ? */
  2844.         {
  2845.        if(rptr->multi_select)
  2846.        {
  2847.         rcount++;
  2848.            }
  2849.            rptr = rptr->plink;
  2850.         }
  2851.         rtblsize = 4L * ((long)rcount + 1L);
  2852.         rtable = (long *)lmalloc(rtblsize);   /* Get table to save them */
  2853.         if(!rtable)
  2854.         {
  2855.        alert_cntre(ALERT12);
  2856.        return;
  2857.         }
  2858.         i = 0;
  2859.         rptr = curpage->regptr;
  2860.     while(rptr)            /* Save selected regions           */ 
  2861.         {                /* They get reset during redraw    */
  2862.        if(rptr->multi_select)    /* and this is the only case where */
  2863.        {                /* we want to preserve them        */
  2864.         rtable[i++] = (long)rptr;
  2865.            }
  2866.            rptr = rptr->plink;
  2867.         }
  2868.              
  2869.     mutoscrn(multi_box[0],multi_box[1],&pxy[0],&pxy[1],0);
  2870.     mutoscrn(multi_box[2],multi_box[3],&pxy[2],&pxy[3],0);
  2871.  
  2872.     voldx = oldx = mx;
  2873.     voldy = oldy = my;
  2874.     
  2875.     graf_mouse(4,&dummy);
  2876.  
  2877.         line_flag=(((pxy[0]==pxy[2])||(pxy[1]==pxy[3]))?(TRUE):(FALSE));
  2878.  
  2879.     gsx_moff();
  2880.     if(!line_flag)
  2881.     {
  2882.       do_box(xor_handle,pxy[0],pxy[1],pxy[2],pxy[3]);
  2883.       do_outer(xor_handle,pxy);
  2884.     }
  2885.  
  2886.     gsx_mon();
  2887.     
  2888.     mbutton = TRUE;
  2889.     while(mbutton)
  2890.     {
  2891.         graf_mkstate(&newx,&newy,&mbutton,&dummy);
  2892.         if((oldx != newx) || (oldy != newy))
  2893.         {
  2894.           gsx_moff();
  2895.           do_rule_mark();
  2896.           if(line_flag)
  2897.             do_outer(xor_handle,pxy);
  2898.           else        
  2899.               do_box(xor_handle,pxy[0],pxy[1],pxy[2],pxy[3]);
  2900.           pxy[0] += newx - oldx;
  2901.           pxy[1] += newy - oldy;
  2902.           pxy[2] += newx - oldx;
  2903.           pxy[3] += newy - oldy;
  2904.           if(line_flag)
  2905.             do_outer(xor_handle,pxy);
  2906.           else
  2907.               do_box(xor_handle,pxy[0],pxy[1],pxy[2],pxy[3]);
  2908.           gsx_mon();          
  2909.         }
  2910.             oldx = newx;
  2911.         oldy = newy;
  2912.     }
  2913.  
  2914.     if(check_dpwork_box(newx,newy))
  2915.     {
  2916.     if((voldx != newx) || (voldy != newy))
  2917.     {
  2918.        deltax = newx - voldx;
  2919.        deltay = newy - voldy;
  2920.        fx = ((deltax < 0) ? (-1) : (1));
  2921.        fy = ((deltay < 0) ? (-1) : (1));
  2922.  
  2923.        scrntomu(abs(newx - voldx),abs(newy - voldy),&deltax,&deltay,1);
  2924.  
  2925.        deltax *= fx;
  2926.        deltay *= fy;
  2927.        
  2928.        if(snap_to_grids)
  2929.        {
  2930.         tempx = deltax + multi_box[0];
  2931.         tempy = deltay + multi_box[1];
  2932.         snap_mu(&tempx,&tempy);
  2933.         deltax = tempx - multi_box[0];
  2934.         deltay = tempy - multi_box[1];
  2935.            }       
  2936.        tmpcurregion = curregion;
  2937.  
  2938.            if(kstat & 0x004)
  2939.        {
  2940.           for(i = 0;i < rcount;i++)
  2941.         {
  2942.            curregion = rtable[i];
  2943.            copy_region();
  2944.         }
  2945.  
  2946.             for(i = 0;i < rcount;i++)
  2947.                 {
  2948.                rptr = (REGION *)rtable[i];
  2949.                rptr->multi_select = 1;
  2950.                 }
  2951.            free(rtable);
  2952.  
  2953.         curregion = 0L;
  2954.                 multi_mode = 1;
  2955.                 gl_region_ptr = gl_grregion_ptr = 0L;
  2956.             mcalc_multbox(multi_box);
  2957.  
  2958.             if((curr_page % 2) && (view_size == PADJCNT))
  2959.             {
  2960.            alt_offset = TRUE;
  2961.            multi_box[0] += hpage_size;
  2962.            multi_box[2] += hpage_size;
  2963.             }
  2964.         
  2965.             mutoscrn(multi_box[0],multi_box[1],&pxy[0],&pxy[1],0);
  2966.             mutoscrn(multi_box[2],multi_box[3],&pxy[2],&pxy[3],0);
  2967.             gsx_moff();
  2968.             do_outer(xor_handle,pxy);
  2969.             gsx_mon();
  2970.         return;
  2971.        }
  2972.            rptr = get_fregion(curr_page,&rect_in_mu[0],&rect_in_mu[1],
  2973.                   &rect_in_mu[2],&rect_in_mu[3],&type);
  2974.            while(rptr)
  2975.            {
  2976.           if(rect_in_mu[0] >= hpage_size)    /* clip it out! */
  2977.                     goto next;
  2978.  
  2979.           curregion = (long)rptr;
  2980.           if(rptr->multi_select)
  2981.               {
  2982.              opcode = get_fprimitive(rptr,&count,&wmode);
  2983.              fflag = TRUE;
  2984.              while(opcode != -1)
  2985.              {
  2986.             switch(opcode)
  2987.             {
  2988.                case 3:
  2989.                case 4:
  2990.                case 0: 
  2991.                 toggle = TRUE;
  2992.                     for(i=0;i<(count*2);i++)
  2993.                 {
  2994.                    ptsarray[i] += ((toggle) ? (deltax):(deltay));
  2995.                    toggle ^= TRUE;
  2996.                 }
  2997.                 break;
  2998.  
  2999.                case 1: 
  3000.                             ptsarray[0] += deltax;
  3001.                 ptsarray[1] += deltay;
  3002.                 break;
  3003.  
  3004.                case 2: 
  3005.                             ptsarray[0] += deltax;
  3006.                 ptsarray[2] += deltax;
  3007.                 ptsarray[1] += deltay;
  3008.                 ptsarray[3] += deltay;
  3009.                 break;
  3010.        
  3011.             }    /* end of switch(opcode) */
  3012.            update_primitive(opcode,count,wmode,fflag);
  3013.            fflag = FALSE;
  3014.            opcode = get_nprimitive(&count,&wmode);
  3015.              }        /* end of while         */
  3016.              if(!rptr->type)
  3017.              {
  3018.             art = get_regart(rptr);
  3019.             if(art)
  3020.             {
  3021.                saveregion = sfregion;
  3022.                open_article(art);
  3023.                do_artcleanup(rptr,0);
  3024.                sfregion = saveregion;
  3025.             }
  3026.              }
  3027.           }
  3028. next:          rptr = get_nregion(&rect_in_mu[0],&rect_in_mu[1],
  3029.               &rect_in_mu[2],&rect_in_mu[3],&type);
  3030.            }
  3031.            curregion = tmpcurregion;
  3032.  
  3033.            force_preview();
  3034.            for(i = 0;i < rcount;i++)
  3035.            {
  3036.           rptr = (REGION *)rtable[i];
  3037.           rptr->multi_select = 1;
  3038.            }
  3039.        free(rtable);
  3040.            multi_mode = 1;
  3041.        mcalc_multbox(multi_box);
  3042.  
  3043.        if((curr_page % 2) && (view_size == PADJCNT))
  3044.        {
  3045.         alt_offset = TRUE;
  3046.         multi_box[0] += hpage_size;
  3047.         multi_box[2] += hpage_size;
  3048.        }
  3049.        mutoscrn(multi_box[0],multi_box[1],&pxy[0],&pxy[1],0);
  3050.        mutoscrn(multi_box[2],multi_box[3],&pxy[2],&pxy[3],0);
  3051.        gsx_moff();
  3052.        do_outer(xor_handle,pxy);
  3053.        gsx_mon();
  3054.     }
  3055.     else
  3056.     {
  3057.        gsx_moff();
  3058.        do_outer(xor_handle,pxy);
  3059.        do_box(xor_handle,pxy[0],pxy[1],pxy[2],pxy[3]);
  3060.        gsx_mon();
  3061.     }
  3062.    }
  3063.    else
  3064.    {
  3065.       gsx_moff();
  3066.       do_blit();
  3067.       mutoscrn(multi_box[0],multi_box[1],&pxy[0],&pxy[1],0);
  3068.       mutoscrn(multi_box[2],multi_box[3],&pxy[2],&pxy[3],0);
  3069.       do_outer(xor_handle,pxy);
  3070.       gsx_mon();
  3071.    }
  3072.     graf_mouse(0,&dummy);
  3073. }
  3074.  
  3075.  
  3076.  
  3077.  
  3078. /**************************************************************************/
  3079. /* Function: check_boxes();                          */
  3080. /* Description: Selects a box of a selected region.              */
  3081. /**************************************************************************/
  3082. check_boxes(mx,my)
  3083. int mx,my;
  3084. {
  3085.     int type;
  3086.     int dflag;
  3087.     register int pos;
  3088.     int tpxy[4];
  3089.     int old_width,old_height;
  3090.     int new_width,new_height;
  3091.     int opcode,fflag;
  3092.         register int i;
  3093.     int mbutton;
  3094.         int odeltax,odeltay;
  3095.     int ndeltax,ndeltay;
  3096.         int old_murect[4];
  3097.     int new_murect[4];
  3098.     int temp;
  3099.     long tregion_ptr;
  3100.     int page;
  3101.     long treg_ptr;
  3102.         int dummy;    
  3103.  
  3104.     mutoscrn(rect_in_mu[0],rect_in_mu[1],&pxy[0],&pxy[1],0);
  3105.         mutoscrn(rect_in_mu[2],rect_in_mu[3],&pxy[2],&pxy[3],0);
  3106.  
  3107.     dflag = FALSE;
  3108.     tpxy[0] = pxy[0];
  3109.     tpxy[1] = pxy[1];
  3110.     tpxy[2] = pxy[2];
  3111.     tpxy[3] = pxy[3];
  3112.  
  3113.     for(pos=0;pos<8;pos++)
  3114.     {
  3115.       if( (mx >= mboxx1[pos]) &&
  3116.           (mx <= mboxx2[pos]) &&
  3117.           (my >= mboxy1[pos]) &&
  3118.           (my <= mboxy2[pos])
  3119.         )
  3120.       {
  3121.          graf_mouse(3,&dummy);
  3122.          dflag = TRUE;
  3123.          break;
  3124.       }
  3125.     }
  3126.  
  3127.     if(dflag)
  3128.     {
  3129.        oldx = mx;
  3130.        oldy = my;
  3131.  
  3132.        gsx_moff();
  3133.        do_outline(xor_handle,pxy);
  3134.        (*adj_mouse[pos])();        /* shift mouse */
  3135.        Supexec(KICKAES);
  3136.        do_box(xor_handle,pxy[0],pxy[1],pxy[2],pxy[3]);
  3137.        gsx_mon();
  3138.  
  3139.        mbutton = TRUE;
  3140.        while(mbutton)
  3141.        {
  3142.           graf_mkstate(&newx,&newy,&mbutton,&dummy);
  3143.           if((oldx != newx) || (oldy != newy))
  3144.           {
  3145.          gsx_moff();
  3146.          do_rule_mark();
  3147.              do_box(xor_handle,pxy[0],pxy[1],pxy[2],pxy[3]);
  3148.          (*da_box[pos])();
  3149.              do_box(xor_handle,pxy[0],pxy[1],pxy[2],pxy[3]);
  3150.          gsx_mon();
  3151.           }
  3152.           oldx = newx;
  3153.           oldy = newy;
  3154.        }
  3155.        graf_mouse(2,&dummy);    
  3156.  
  3157.  
  3158.        if(pxy[2] < pxy[0])        /* If x2 < x1 then swap     */
  3159.          {
  3160.             temp = pxy[0];
  3161.         pxy[0] = pxy[2];
  3162.         pxy[2] = temp;
  3163.        }
  3164.        if(pxy[3] < pxy[1])
  3165.        {
  3166.         temp = pxy[1];
  3167.         pxy[1] = pxy[3];
  3168.         pxy[3] = temp;
  3169.        }
  3170.        if(snap_to_grids)
  3171.        {
  3172.         snap_to_grid(&pxy[0],&pxy[1]);
  3173.         snap_to_grid(&pxy[2],&pxy[3]);
  3174.        }
  3175.     
  3176.         treg_ptr = ((gl_region_ptr) ? (gl_region_ptr):(gl_grregion_ptr));
  3177.        find_page(treg_ptr,&page);
  3178.  
  3179.        alt_offset = (((page % 2)&&(view_size == PADJCNT))?(TRUE):(FALSE));
  3180.  
  3181.        scrn2mu(tpxy[0],tpxy[1],&old_murect[0],&old_murect[1],0,alt_offset);
  3182.        scrn2mu(tpxy[2],tpxy[3],&old_murect[2],&old_murect[3],0,alt_offset);
  3183.        scrn2mu(pxy[0],pxy[1],&new_murect[0],&new_murect[1],0,alt_offset);
  3184.        scrn2mu(pxy[2],pxy[3],&new_murect[2],&new_murect[3],0,alt_offset);
  3185.  
  3186.        gsx_moff();
  3187.            (*bdj_mouse[pos])();        /* shift mouse */
  3188.            if(*gcurx < 0) *gcurx = 0;
  3189.         if(*gcurx >= sxres) *gcurx = sxres - 1;
  3190.            if(*gcury < 0) *gcury = 0;
  3191.              if(*gcury >= syres) *gcury = syres - 1;
  3192.               Supexec(KICKAES);
  3193.            gsx_mon();
  3194.  
  3195.        if((voldx != newx) || (voldy != newy))
  3196.        {
  3197.  
  3198.         old_width = old_murect[2] - old_murect[0] + 1;
  3199.         old_height = old_murect[3] - old_murect[1] + 1;
  3200.  
  3201.         new_width = new_murect[2] - new_murect[0];
  3202.         new_height = new_murect[3] - new_murect[1];
  3203.         opcode = get_fprimitive(region_ptr,&count,&wmode);
  3204.         fflag = TRUE;
  3205.         while(opcode != -1)
  3206.          {
  3207.             switch(opcode)
  3208.             {
  3209.             case 0: 
  3210.             case 3:
  3211.             case 4:
  3212.                 i=0;
  3213.                 while(i<count*2)
  3214.                 {
  3215.                    odeltax = ptsarray[i] - old_murect[0];
  3216.                    ndeltax = scale_iv(odeltax,new_width,
  3217.                     old_width); 
  3218.                    ptsarray[i++] = new_murect[0] + ndeltax;
  3219.  
  3220.                    odeltay = ptsarray[i] - old_murect[1];
  3221.                    ndeltay = scale_iv(odeltay,new_height,
  3222.                     old_height);
  3223.                    ptsarray[i++] = new_murect[1] + ndeltay;
  3224.                 }
  3225.                 break;
  3226.  
  3227.             case 1: case12_scale(old_murect[0],
  3228.                          old_murect[1],
  3229.                          old_width,old_height,
  3230.                          new_murect[0],
  3231.                          new_murect[1],
  3232.                          new_width,
  3233.                          new_height,1);
  3234.                 break;
  3235.  
  3236.             case 2: case12_scale(old_murect[0],
  3237.                          old_murect[1],
  3238.                          old_width,old_height,
  3239.                          new_murect[0],
  3240.                          new_murect[1],
  3241.                          new_width,
  3242.                          new_height,2);
  3243.                 break;
  3244.             }
  3245.             update_primitive(opcode,count,wmode,fflag);
  3246.             fflag = FALSE;
  3247.             opcode = get_nprimitive(&count,&wmode);
  3248.         }
  3249.            tregion_ptr = region_ptr;
  3250.         if(gl_region_ptr)
  3251.         {
  3252.            page_redraw(gl_region_ptr);
  3253.            type = FALSE;
  3254.         }
  3255.         else
  3256.         {
  3257.            update_repel(1,old_murect);
  3258.            type = TRUE;
  3259.          }
  3260.          if(view_size != PADJCNT && !deferhj && gl_region_ptr)
  3261.           redraw_area(tregion_ptr,old_murect,1);    /* Cleanup old area */        
  3262.        if(type)
  3263.         gl_grregion_ptr = tregion_ptr;
  3264.        else
  3265.         gl_region_ptr = tregion_ptr;
  3266.        region_ptr = tregion_ptr;
  3267.        find_boundary(tregion_ptr,
  3268.                   &rect_in_mu[0],&rect_in_mu[1],
  3269.                   &rect_in_mu[2],&rect_in_mu[3],&dummy,&page);
  3270.        if((page % 2) && (view_size == PADJCNT))
  3271.        {
  3272.         rect_in_mu[0] += hpage_size;
  3273.         rect_in_mu[2] += hpage_size;
  3274.        }
  3275.        mutoscrn(rect_in_mu[0],rect_in_mu[1],&pxy[0],&pxy[1],0);
  3276.        mutoscrn(rect_in_mu[2],rect_in_mu[3],&pxy[2],&pxy[3],0);
  3277.        gsx_moff();
  3278.        do_outline(xor_handle,pxy);
  3279.        gsx_mon();
  3280.            }
  3281.     }
  3282.     graf_mouse(0,&dummy);
  3283.         return(dflag);
  3284. }
  3285.  
  3286.  
  3287.  
  3288.  
  3289. /**************************************************************************/
  3290. /* Function: do_rule_mark()                          */
  3291. /* Description: Handles the ruler markers                  */
  3292. /**************************************************************************/
  3293. do_rule_mark()
  3294. {
  3295.    int thandle;
  3296.    int dummy;
  3297.    int pts[4];
  3298.    int temp;
  3299.    int temp_mouse;
  3300.  
  3301.    if(!ruler_flag)
  3302.     return;
  3303.    if(newx < dpwork.g_x)
  3304.      return;
  3305.    if(newy < dpwork.g_y)
  3306.     return;
  3307.    temp = dpwork.g_x + dpwork.g_w - 1;
  3308.    if(newx > temp)
  3309.     return;
  3310.    temp = dpwork.g_y + dpwork.g_h - 1;
  3311.    if(newy > temp)
  3312.     return;
  3313.  
  3314.    wind_get(0,WF_TOP,&thandle,&dummy,&dummy,&dummy);
  3315.    if(thandle != prev_handle)
  3316.         return;
  3317.     
  3318.    temp_mouse = mouse_on;
  3319.    if(mouse_on)
  3320.       gsx_moff();
  3321.    pts[1] = pwork.g_y;            /* Erase horizontal mark    */
  3322.    pts[3] = pts[1] + vhalf;
  3323.    if(xold_mark >= 0)
  3324.    {
  3325.       pts[0] = pts[2] = xold_mark;
  3326.       v_pline(rule_handle,2,pts);
  3327.    }
  3328.    pts[0] = pts[2] =  newx;
  3329.    v_pline(rule_handle,2,pts);        /* Draw new horizontal mark    */
  3330.    xold_mark = newx;            /* Save x for erasing later    */
  3331.  
  3332.    pts[0] = pwork.g_x;
  3333.    pts[2] = pts[0] + hhalf;
  3334.    if(yold_mark >= 0)
  3335.    {
  3336.       pts[1] = pts[3] =  yold_mark;
  3337.       v_pline(rule_handle,2,pts);    /* Erase old vertical mark    */
  3338.    }
  3339.    pts[1] = pts[3] = newy;
  3340.    v_pline(rule_handle,2,pts);        /* Draw new vertical mark    */
  3341.    yold_mark = newy;            /* Save for erasing later       */
  3342.    if(temp_mouse)
  3343.       gsx_mon();
  3344. }
  3345.  
  3346.  
  3347.  
  3348.  
  3349. rect_intersect(rect,grect)
  3350. int rect[];
  3351. int grect[];
  3352. {
  3353.     int x1,y1,x2,y2;
  3354.     x2 = min(rect[2],grect[2]);
  3355.     y2 = min(rect[3],grect[3]);
  3356.     x1 = max(rect[0],grect[0]);
  3357.     y1 = max(rect[1],grect[1]);
  3358.     return(x2 >= x1 && y2 >= y1);
  3359. }
  3360.  
  3361.  
  3362.  
  3363.  
  3364. long first_aregion(reg1,reg2,art)
  3365. long reg1,reg2;
  3366. long art;
  3367. {
  3368.    long rptr;
  3369.    long tmpreg;
  3370.    int dummy;
  3371.    long tmpart;
  3372.    long firstreg;
  3373.    
  3374.    firstreg = 0L;
  3375.    tmpart = curart;
  3376.    curart = art;
  3377.    tmpreg = curregion;
  3378.    rptr = getf_aregion(&dummy,&dummy,&dummy,&dummy,&dummy);
  3379.    while(rptr)
  3380.    {
  3381.     if(rptr == reg1)
  3382.     {
  3383.        firstreg = reg1;
  3384.        break;
  3385.     }
  3386.         if(rptr == reg2)
  3387.     {
  3388.        firstreg = reg2;
  3389.        break;
  3390.         }
  3391.         rptr = getn_aregion(&dummy,&dummy,&dummy,&dummy,&dummy);
  3392.    }
  3393.    curregion = tmpreg;
  3394.    curart = tmpart;
  3395.    return firstreg;
  3396. }
  3397.  
  3398.  
  3399.  
  3400.  
  3401.  
  3402. /**************************************************************************/
  3403. /* Function: update_repel()                          */
  3404. /* Description: Repels new region for flowing of text              */
  3405. /*     Check each text region to see if it intersects with the affected  */
  3406. /*    graphic region.  If it does, put it's article into the list of    */
  3407. /*    articles that need to be redrawn if...1) a previous region did    */
  3408. /*      not have the same article and 2) that previous region was linked  */
  3409. /*    after the current one.  In other words, make sure all intersecting*/
  3410. /*    regions are redrawn at least once but not more than once      */
  3411. /**************************************************************************/
  3412. update_repel(check,oldrect)
  3413. int check;
  3414. int oldrect[];
  3415. {
  3416.    int grattr[11];
  3417.    long tmprptr;
  3418.    int rect[4];
  3419.    int gflag;
  3420.    int grect[4];
  3421.    int redraw_rect[4];
  3422.    int dummy;
  3423.    long art;
  3424.    int found;
  3425.    long mouse_ptr;
  3426.    REGION *saveregion;
  3427.    
  3428.    graf_mouse(2,&mouse_ptr);        /* Busy bee */
  3429.    if(gl_grregion_ptr)
  3430.       find_boundary(gl_grregion_ptr,&grect[0],&grect[1],&grect[2],
  3431.             &grect[3],&dummy,&dummy);
  3432.    if(gl_grregion_ptr && view_size != PADJCNT)
  3433.    {
  3434.       if(oldrect && rect_intersect(oldrect,grect))
  3435.       {
  3436.         redraw_rect[0] = min(grect[0],oldrect[0]);
  3437.      redraw_rect[1] = min(grect[1],oldrect[1]);
  3438.         redraw_rect[2] = max(grect[2],oldrect[2]);
  3439.         redraw_rect[3] = max(grect[3],oldrect[3]);
  3440.         redraw_area(gl_grregion_ptr,redraw_rect,1);
  3441.       }
  3442.       else
  3443.       {
  3444.         if(oldrect)
  3445.            redraw_area(gl_grregion_ptr,oldrect,1);
  3446.         redraw_area(gl_grregion_ptr,grect,1);
  3447.       }
  3448.    }
  3449.    else
  3450.       if(gl_grregion_ptr && oldrect && view_size != PADJCNT)
  3451.          redraw_area(gl_grregion_ptr,oldrect,1);
  3452.    if(check)        /* If flow through, don't re H and J */
  3453.    {
  3454.       get_grattr(gl_grregion_ptr,grattr);
  3455.       if(!grattr[4])
  3456.       {
  3457.      if(view_size == PADJCNT)
  3458.        force_preview();
  3459.      graf_mouse(ARROW,&mouse_ptr);            /* Busy bee */
  3460.      return;
  3461.       }
  3462.    }
  3463.    tmprptr = gl_region_ptr;
  3464.  
  3465.    gl_region_ptr = get_fregion(curr_page,&rect[0],&rect[1],&rect[2],
  3466.                 &rect[3],&gflag);
  3467.    while(gl_region_ptr)
  3468.    {
  3469.       if(rect[0] >= hpage_size)    /* clip it out! */
  3470.            goto next;
  3471.  
  3472.       art = get_regart(gl_region_ptr);
  3473.       if((!gflag && art && gl_grregion_ptr && rect_intersect(rect,grect)) || 
  3474.      (!gflag && art && oldrect && rect_intersect(oldrect,rect)))
  3475.       {
  3476.       saveregion = sfregion;
  3477.       page_redraw(gl_region_ptr);
  3478.       sfregion = saveregion;
  3479.       }
  3480. next: gl_region_ptr = get_nregion(&rect[0],&rect[1],&rect[2],&rect[3],&gflag);    
  3481.    }
  3482.    if(view_size == PADJCNT)
  3483.     force_preview();
  3484.    gl_region_ptr = tmprptr;
  3485.    graf_mouse(ARROW,&mouse_ptr);        /* Busy bee */
  3486. }
  3487.  
  3488.  
  3489.  
  3490.  
  3491. /**************************************************************************/
  3492. /* Function: snap_to_grid()                          */
  3493. /* Description: snaps vertices to a specific grid              */
  3494. /**************************************************************************/
  3495. snap_to_grid(sx,sy)
  3496. int *sx;
  3497. int *sy;
  3498. {
  3499.    int hremain;
  3500.    int vremain;
  3501.    int mux,muy;
  3502.  
  3503.    if(sx < 0 || sy < 0)
  3504.     return;
  3505.  
  3506.    scrntomu(*sx,*sy,&mux,&muy,0);
  3507.    hremain = mux % hgridspace;
  3508.    vremain = muy % vgridspace;     
  3509.    mux /= hgridspace;
  3510.    mux *= hgridspace;
  3511.    muy /= vgridspace;
  3512.    muy *= vgridspace;
  3513.  
  3514.    if(hremain >= hgridspace/2)
  3515.     mux += hgridspace;
  3516.    if(vremain >= vgridspace/2)
  3517.     muy += vgridspace;   
  3518.  
  3519.    mutoscrn(mux,muy,sx,sy,0);
  3520. }
  3521.  
  3522.  
  3523.  
  3524.  
  3525. /**************************************************************************/
  3526. /* Function: snap_mu()                              */
  3527. /* Description: Snaps vertice in mu...        ???              */
  3528. /**************************************************************************/
  3529. snap_mu(mux,muy)
  3530. register int *mux;
  3531. register int *muy;
  3532. {
  3533.    int hremain;
  3534.    int vremain;
  3535.  
  3536.    if(*mux < 0 || *muy < 0)
  3537.     return;
  3538.    hremain = *mux % hgridspace;
  3539.    vremain = *muy % vgridspace;     
  3540.    *mux /= hgridspace;
  3541.    *mux *= hgridspace;
  3542.    *muy /= vgridspace;
  3543.    *muy *= vgridspace;
  3544.  
  3545.    if(hremain >= hgridspace/2)
  3546.     *mux += hgridspace;
  3547.    if(vremain >= vgridspace/2)
  3548.     *muy += vgridspace;   
  3549. }
  3550.  
  3551.  
  3552. /**************************************************************************/
  3553. /* Function: do_edit_prim()                           */
  3554. /* Description: Select with right button a primitive to edit          */
  3555. /**************************************************************************/
  3556. do_edit_prim()
  3557. {
  3558.    int opcode;
  3559.    int minx,miny,maxx,maxy;
  3560.    int page;
  3561.    int pcount;
  3562.    int type;
  3563.  
  3564.    if(gl_region_ptr  || gl_grregion_ptr)
  3565.    {
  3566.       region_ptr = ((gl_region_ptr)?(gl_region_ptr):(gl_grregion_ptr));
  3567.  
  3568.       if(!active_prim)                    /* get first prim...*/
  3569.     opcode = get_fprimitive(region_ptr,&pcount,&wmode);
  3570.       else                        /* get next prim    */
  3571.         opcode = get_nprimitive(&pcount,&wmode);
  3572.         
  3573.       do_blit();
  3574.       if(opcode != -1)                /* outline primitive */
  3575.       {
  3576.     calc_prim(opcode,&minx,&miny,&maxx,&maxy,pcount);
  3577.     active_prim = TRUE;
  3578.     menu_ienable(ad_menu,ODELPRIM,TRUE);
  3579.     menu_ienable(ad_menu,OPCOORD,TRUE);
  3580.         menu_ienable(ad_menu,OMOVEFNT,TRUE);
  3581.     menu_ienable(ad_menu,OMOVEBAK,TRUE);
  3582.     find_page(region_ptr,&page);
  3583.     region_ptr = get_curreg(&type);
  3584.       }
  3585.       else                    /* out of primitives      */
  3586.       {
  3587.     find_boundary(region_ptr,&minx,&miny,
  3588.                  &maxx, &maxy,&dummy,&page);
  3589.     menu_ienable(ad_menu,ODELPRIM,FALSE);
  3590.     menu_ienable(ad_menu,OPCOORD,FALSE);
  3591.         menu_ienable(ad_menu,OMOVEFNT,FALSE);
  3592.         menu_ienable(ad_menu,OMOVEBAK,FALSE);
  3593.         active_prim = FALSE;
  3594.       }
  3595.       outline_primman(minx,miny,maxx,maxy,type,page);
  3596.    }
  3597.    evnt_button(1,1,0,&dummy,&dummy,&dummy,&dummy);
  3598. }
  3599.  
  3600.  
  3601.  
  3602.  
  3603. /**************************************************************************/
  3604. /* Function: calc_prim()                          */
  3605. /* Description: Calculate boundary rectangle of the current primitive     */
  3606. /**************************************************************************/
  3607. calc_prim(op,minx,miny,maxx,maxy,count)
  3608. int op;
  3609. int *minx,*miny,*maxx,*maxy;
  3610. register int count;
  3611. {
  3612.      register int i;
  3613.      int tcount;
  3614.  
  3615.      tcount = count;
  3616.  
  3617.      if(op == 1)            /* ELLIPSE - CIRCLE */
  3618.      {
  3619.     *minx = ptsarray[0] - ptsarray[2];
  3620.         *maxx = ptsarray[0] + ptsarray[2];
  3621.     *miny = ptsarray[1] - ptsarray[3];
  3622.         *maxy = ptsarray[1] + ptsarray[3];
  3623.      }
  3624.      else
  3625.      {                    /* poly,lines, and boxes...*/
  3626.         if((op == 0) || (op == 3) || (op == 4))
  3627.         {
  3628.        i = 0;
  3629.            --count;
  3630.        *minx = *maxx = ptsarray[i++];
  3631.        *miny = *maxy = ptsarray[i++];
  3632.            while(count--)
  3633.            {
  3634.           if(ptsarray[i] > *maxx)
  3635.             *maxx = ptsarray[i];
  3636.               if(ptsarray[i] < *minx)
  3637.             *minx = ptsarray[i];
  3638.           i++;
  3639.               if(ptsarray[i] > *maxy)
  3640.             *maxy = ptsarray[i];
  3641.           if(ptsarray[i] < *miny)
  3642.             *miny = ptsarray[i];
  3643.           i++;
  3644.        }
  3645.         }
  3646.         else
  3647.         {
  3648.        if(op == 2)        /* Graphic images       */
  3649.        {
  3650.         *minx = ptsarray[0];
  3651.         *miny = ptsarray[1];
  3652.         *maxx = ptsarray[2];
  3653.             *maxy = ptsarray[3];
  3654.        }
  3655.         }
  3656.      }
  3657.      count = tcount;
  3658. }
  3659.  
  3660.  
  3661.  
  3662.  
  3663.  
  3664. /**************************************************************************/
  3665. /* Function: edit_prims()                          */
  3666. /* Description: Move and Size Primitives...                  */
  3667. /**************************************************************************/
  3668. edit_prims(mx,my)
  3669. int mx,my;
  3670. {
  3671.      int nmx,nmy;
  3672.  
  3673.      if(check_prim_box(mx,my))
  3674.      {
  3675.     region_ptr = ((gl_region_ptr)?(gl_region_ptr):(gl_grregion_ptr));
  3676.     active_prim = TRUE;
  3677.     return;
  3678.      }
  3679.      scrntomu(mx,my,&nmx,&nmy,0);
  3680.      if(inside_primitive(nmx,nmy))
  3681.      {
  3682.     move_prim_box(mx,my);
  3683.     active_prim = TRUE;
  3684.     return;
  3685.      }
  3686.      menu_ienable(ad_menu,ODELPRIM,FALSE);
  3687.      menu_ienable(ad_menu,OPCOORD,FALSE);
  3688.      menu_ienable(ad_menu,OMOVEFNT,FALSE);
  3689.      menu_ienable(ad_menu,OMOVEBAK,FALSE);
  3690.  
  3691. /*     router_selected(); Deleted because this means it was outside the box*/
  3692. /*   hence, no item is now selected                       */
  3693.  
  3694.      active_prim = FALSE;        
  3695.      check_only_blit();          /* clears menu items and blits to screen */
  3696. }
  3697.  
  3698.  
  3699.  
  3700.  
  3701.  
  3702. /**************************************************************************/
  3703. /* Function: check_prim_box()                          */
  3704. /* Description: Size a primitve                          */
  3705. /**************************************************************************/
  3706. check_prim_box(mx,my)
  3707. int mx,my;
  3708. {
  3709.       int dflag;
  3710.       register int pos;
  3711.       int tpxy[4];
  3712.       int mbutton;
  3713.       int temp;
  3714.       int opcode;
  3715.       int page;
  3716.       int old_width,old_height;
  3717.       int new_width,new_height;
  3718.       int odeltax,odeltay;
  3719.       int ndeltax,ndeltay;
  3720.       int old_murect[4];
  3721.       int new_murect[4];
  3722.       register int i;
  3723.       int topcode;
  3724.       int pcount;
  3725.       int minx,miny,maxx,maxy;
  3726.  
  3727.       dflag = FALSE;
  3728.  
  3729.       topcode = opcode = get_cur_prim(&pcount,&wmode,&prim_ptr);
  3730.       calc_prim(opcode,&minx,&miny,&maxx,&maxy,pcount);
  3731.  
  3732.       if(alt_offset)
  3733.       {
  3734.     minx += hpage_size;
  3735.     maxx += hpage_size;
  3736.       }
  3737.  
  3738.       mutoscrn(minx,miny,&pxy[0],&pxy[1],0);
  3739.       mutoscrn(maxx,maxy,&pxy[2],&pxy[3],0);
  3740.  
  3741.       tpxy[0] = pxy[0];        /* where the hell do these #s come from?*/
  3742.       tpxy[1] = pxy[1];        /* from outline_primman();        */
  3743.       tpxy[2] = pxy[2];        /* aka do_edit_prims();            */
  3744.       tpxy[3] = pxy[3];
  3745.  
  3746.       for(pos=0;pos<8;pos++)
  3747.       {
  3748.     if( (mx >= mboxx1[pos]) &&    /* setup by outline_primman()    */
  3749.         (mx <= mboxx2[pos]) &&
  3750.         (my >= mboxy1[pos]) &&
  3751.         (my <= mboxy2[pos])
  3752.           )
  3753.         {
  3754.         graf_mouse(3,&dummy);
  3755.         dflag = TRUE;
  3756.         break;
  3757.     }
  3758.       }
  3759.  
  3760.       if(dflag)
  3761.       {
  3762.     oldx = mx;
  3763.     oldy = my;
  3764.     
  3765.         gsx_moff();
  3766.         do_outline(xor_handle,pxy);
  3767.         (*adj_mouse[pos])();        /* shift mouse */
  3768.     Supexec(KICKAES);
  3769.     do_box(xor_handle,pxy[0],pxy[1],pxy[2],pxy[3]);
  3770.     gsx_mon();
  3771.  
  3772.         mbutton = TRUE;
  3773.     while(mbutton)
  3774.         {
  3775.        graf_mkstate(&newx,&newy,&mbutton,&dummy);
  3776.            if((oldx != newx) || (oldy != newy))
  3777.            {
  3778.         gsx_moff();
  3779.         do_rule_mark();
  3780.          do_box(xor_handle,pxy[0],pxy[1],pxy[2],pxy[3]);
  3781.         (*da_box[pos])();
  3782.          do_box(xor_handle,pxy[0],pxy[1],pxy[2],pxy[3]);
  3783.         gsx_mon();
  3784.        }
  3785.        oldx = newx;
  3786.        oldy = newy;
  3787.         }
  3788.  
  3789.     graf_mouse(2,&dummy);
  3790.     if(pxy[2] < pxy[0])       /* if x2 < x1 then swap */
  3791.     {
  3792.        temp = pxy[0];
  3793.        pxy[0] = pxy[2];
  3794.        pxy[2] = temp;
  3795.     }
  3796.         if(pxy[3] < pxy[1])
  3797.     {
  3798.        temp = pxy[1];
  3799.        pxy[1] = pxy[3];
  3800.        pxy[3] = temp;
  3801.     }
  3802.     
  3803.      if(snap_to_grids)
  3804.     {
  3805.         snap_to_grid(&pxy[0],&pxy[1]);
  3806.         snap_to_grid(&pxy[2],&pxy[3]);
  3807.     }
  3808.  
  3809.         gsx_moff();
  3810.         (*bdj_mouse[pos])();        /* shift mouse */
  3811.         if(*gcurx < 0) *gcurx = 0;
  3812.      if(*gcurx >= sxres) *gcurx = sxres - 1;
  3813.         if(*gcury < 0) *gcury = 0;
  3814.           if(*gcury >= syres) *gcury = syres - 1;
  3815.         Supexec(KICKAES);
  3816.     gsx_mon();
  3817.  
  3818.     region_ptr = ((gl_region_ptr) ? (gl_region_ptr):(gl_grregion_ptr));
  3819.     find_page(region_ptr,&page);
  3820.     alt_offset = (((page % 2) && (view_size == PADJCNT))?(TRUE):(FALSE));
  3821.     
  3822.     scrn2mu(tpxy[0],tpxy[1],&old_murect[0],&old_murect[1],0,alt_offset);
  3823.     scrn2mu(tpxy[2],tpxy[3],&old_murect[2],&old_murect[3],0,alt_offset);
  3824.     scrn2mu(pxy[0],pxy[1],&new_murect[0],&new_murect[1],0,alt_offset);
  3825.     scrn2mu(pxy[2],pxy[3],&new_murect[2],&new_murect[3],0,alt_offset);
  3826.  
  3827.     if((voldx != newx) || (voldy != newy))
  3828.     {
  3829.      /* modify primitive to new data coordinates */       
  3830.      old_width  = old_murect[2] - old_murect[0] + 1;
  3831.      old_height = old_murect[3] - old_murect[1] + 1;
  3832.  
  3833.      new_width  = new_murect[2] - new_murect[0];
  3834.      new_height = new_murect[3] - new_murect[1];
  3835.  
  3836.      topcode = opcode = get_cur_prim(&pcount,&wmode,&prim_ptr);
  3837.      if(opcode != -1)
  3838.      {
  3839.            switch(opcode)
  3840.            {
  3841.          case 0: 
  3842.          case 3:
  3843.          case 4:
  3844.             i=0;
  3845.             while(i<pcount*2)
  3846.             {
  3847.                odeltax = ptsarray[i] - old_murect[0];
  3848.                ndeltax = scale_iv(odeltax,new_width,
  3849.                 old_width); 
  3850.                ptsarray[i++] = new_murect[0] + ndeltax;
  3851.                    odeltay = ptsarray[i] - old_murect[1];
  3852.                ndeltay = scale_iv(odeltay,new_height,
  3853.                 old_height);
  3854.                ptsarray[i++] = new_murect[1] + ndeltay;
  3855.             }
  3856.             break;
  3857.  
  3858.         case 1: case12_scale(old_murect[0],
  3859.                      old_murect[1],
  3860.                      old_width,old_height,
  3861.                      new_murect[0],
  3862.                      new_murect[1],
  3863.                      new_width,
  3864.                      new_height,1);
  3865.             break;
  3866.  
  3867.         case 2: case12_scale(old_murect[0],
  3868.                      old_murect[1],
  3869.                      old_width,old_height,
  3870.                      new_murect[0],
  3871.                      new_murect[1],
  3872.                      new_width,
  3873.                      new_height,2);
  3874.             break;
  3875.            }
  3876.            post_edit_prim(opcode,pcount,wmode,prim_ptr);
  3877.      }
  3878.     }
  3879.       }
  3880.    graf_mouse(0,&dummy);    
  3881.    return(dflag);
  3882. }
  3883.  
  3884.  
  3885.  
  3886.  
  3887.  
  3888. /**************************************************************************/
  3889. /* Function: recalc_region()                          */
  3890. /* Description: Calculate region boundary after editing primitive      */
  3891. /**************************************************************************/
  3892. recalc_region()
  3893. {
  3894.    register int opcode;
  3895.    int fflag;
  3896.    int pcount;
  3897.  
  3898.    opcode = get_fprimitive(region_ptr,&pcount,&wmode);
  3899.    fflag = TRUE;
  3900.    while(opcode != -1)
  3901.    {
  3902.       calc_newbounds(fflag,opcode,pcount);
  3903.       opcode = get_nprimitive(&pcount,&wmode);
  3904.       fflag = FALSE;
  3905.    }    
  3906. }
  3907.  
  3908.  
  3909.  
  3910.  
  3911.  
  3912. /**************************************************************************/
  3913. /* Function: move_prim_box()                          */
  3914. /* Description: move a primitive within a region              */
  3915. /**************************************************************************/
  3916. move_prim_box(mx,my)
  3917. int mx,my;
  3918. {
  3919.     int opcode;
  3920.     int mbutton;
  3921.     int fx,fy;
  3922.     register int i;
  3923.     int tempx,tempy;
  3924.     int toggle;
  3925.     int minx,miny,maxx,maxy;
  3926.     int topcode;
  3927.     int pcount;
  3928.     int line_flag;
  3929.  
  3930.     topcode = opcode = get_cur_prim(&pcount,&wmode,&prim_ptr);
  3931.     calc_prim(opcode,&minx,&miny,&maxx,&maxy,pcount);
  3932.  
  3933.     if(alt_offset)
  3934.     {
  3935.     minx += hpage_size;
  3936.     maxx += hpage_size;
  3937.     }
  3938.     mutoscrn(minx,miny,&pxy[0],&pxy[1],0);
  3939.     mutoscrn(maxx,maxy,&pxy[2],&pxy[3],0);
  3940.  
  3941.     voldx = oldx = mx;
  3942.     voldy = oldy = my;
  3943.  
  3944.     line_flag=(((pxy[0]==pxy[2])||(pxy[1]==pxy[3]))?(TRUE):(FALSE));
  3945.  
  3946.     graf_mouse(4,&dummy);
  3947.     gsx_moff();
  3948.     do_outline(xor_handle,pxy);
  3949.     if(line_flag)
  3950.     do_outer(xor_handle,pxy);
  3951.     else
  3952.     do_box(xor_handle,pxy[0],pxy[1],pxy[2],pxy[3]);
  3953.     gsx_mon();
  3954.  
  3955.     mbutton = TRUE;
  3956.     while(mbutton)
  3957.     {
  3958.       graf_mkstate(&newx,&newy,&mbutton,&dummy);
  3959.       if((oldx != newx) || (oldy != newy))
  3960.       {
  3961.      gsx_moff();
  3962.          do_rule_mark();
  3963.          if(line_flag)
  3964.         do_outer(xor_handle,pxy);
  3965.          else
  3966.         do_box(xor_handle,pxy[0],pxy[1],pxy[2],pxy[3]);
  3967.  
  3968.      pxy[0] += newx - oldx;
  3969.          pxy[1] += newy - oldy;
  3970.          pxy[2] += newx - oldx;
  3971.          pxy[3] += newy - oldy;
  3972.          if(line_flag)
  3973.            do_outer(xor_handle,pxy);
  3974.          else
  3975.         do_box(xor_handle,pxy[0],pxy[1],pxy[2],pxy[3]);
  3976.  
  3977.      gsx_mon();
  3978.       }
  3979.       oldx = newx;
  3980.       oldy = newy;
  3981.     }
  3982.  
  3983.  
  3984.   if(check_dpwork_box(newx,newy))
  3985.   {
  3986.      if((voldx != newx) || (voldy != newy))
  3987.      {
  3988.        deltax = newx - voldx;
  3989.        deltay = newy - voldy;
  3990.  
  3991.        fx = ((deltax < 0) ? (-1) : (1));
  3992.        fy = ((deltay < 0) ? (-1) : (1));
  3993.  
  3994.        scrntomu(abs(newx - voldx),abs(newy - voldy),&deltax,&deltay,1);
  3995.  
  3996.        deltax *= fx;
  3997.        deltay *= fy;
  3998.  
  3999.        if(snap_to_grids)
  4000.        {
  4001.       tempx = deltax + minx;
  4002.       tempy = deltay + miny;
  4003.       snap_mu(&tempx,&tempy);
  4004.       deltax = tempx - minx;
  4005.       deltay = tempy - miny;
  4006.        }
  4007.  
  4008.        
  4009.     switch(opcode)
  4010.     {
  4011.         case 3:
  4012.         case 4:
  4013.         case 0: toggle = TRUE;
  4014.                 for(i=0;i<(pcount*2);i++)
  4015.             {
  4016.                ptsarray[i] += ((toggle) ? (deltax):(deltay));
  4017.                toggle ^= TRUE;
  4018.             }
  4019.             break;
  4020.  
  4021.         case 1: ptsarray[0] += deltax;
  4022.             ptsarray[1] += deltay;
  4023.             break;
  4024.  
  4025.         case 2: ptsarray[0] += deltax;
  4026.             ptsarray[2] += deltax;
  4027.             ptsarray[1] += deltay;
  4028.             ptsarray[3] += deltay;
  4029.             break;
  4030.        
  4031.     }    /* end of switch(opcode) */
  4032.  
  4033.         if(kstat & 0x0004)
  4034.     {
  4035.            copy_prim(opcode,pcount,wmode);
  4036.            return;
  4037.         }
  4038.  
  4039.         post_edit_prim(opcode,pcount,wmode,prim_ptr);
  4040.     }
  4041.     else
  4042.     {
  4043.        gsx_moff();
  4044.        do_outline(xor_handle,pxy);
  4045.        do_box(xor_handle,pxy[0],pxy[1],pxy[2],pxy[3]);
  4046.        gsx_mon();
  4047.  
  4048.     }
  4049.  }
  4050.  else
  4051.  {
  4052.    gsx_moff();
  4053.    do_blit();
  4054.    mutoscrn(minx,miny,&pxy[0],&pxy[1],0);
  4055.    mutoscrn(maxx,maxy,&pxy[2],&pxy[3],0);
  4056.    do_outline(xor_handle,pxy);
  4057.    gsx_mon();
  4058.  }
  4059.     graf_mouse(0,&dummy);
  4060. }
  4061.  
  4062.  
  4063.  
  4064. /**************************************************************************/
  4065. /* Function: inside_primitive()                            */
  4066. /* Description: Check if clicked within a primitive              */
  4067. /**************************************************************************/
  4068. inside_primitive(x,y)
  4069. int x,y;
  4070. {
  4071.    int opcode;
  4072.    int minx,miny,maxx,maxy;
  4073.    int pcount;
  4074.    int xoffset,yoffset;            /* Offset for 1 pixel of mu's */
  4075.    int temp;
  4076.  
  4077.    temp = alt_offset;
  4078.    scrntomu(2,2,&xoffset,&yoffset,1);
  4079.    alt_offset = temp;
  4080.  
  4081.    opcode = get_cur_prim(&pcount,&wmode,&prim_ptr);    
  4082.    calc_prim(opcode,&minx,&miny,&maxx,&maxy,pcount);
  4083.    if(minx == maxx || miny == maxy)
  4084.    {
  4085.         xoffset *= 3;
  4086.         yoffset *= 3;
  4087.    }
  4088.    if(x >= minx-xoffset && x <= maxx+xoffset &&
  4089.       y >= miny-yoffset && y <= maxy+yoffset)
  4090.     return 1;
  4091.    else
  4092.     return 0;
  4093. }
  4094.  
  4095.  
  4096.  
  4097. /**************************************************************************/
  4098. /*        Handle left icon panel selections              */
  4099. /**************************************************************************/
  4100. hndl_icons(obj)
  4101. int obj;
  4102. {
  4103.    int item;
  4104.    int title;
  4105.  
  4106.    if(ad_bkgrnd[obj].ob_state == DISABLED)
  4107.     return;
  4108.    if(bgicptr->bi_pdata == primicons)
  4109.    {
  4110.       switch(obj)
  4111.       {
  4112.     case ICBOX1:
  4113.         item = RCLOSE;
  4114.         title = TREGION;
  4115.         break;
  4116.  
  4117.     case ICBOX2:
  4118.            item = OPOLYGON;
  4119.         title = TOBJECTS;
  4120.         break;
  4121.  
  4122.     case ICBOX3:
  4123.               item = OCIRCLE;
  4124.         title = TOBJECTS;
  4125.         break;
  4126.  
  4127.     case ICBOX4:
  4128.         item = OELLIPSE;
  4129.         title = TOBJECTS;
  4130.         break;
  4131.  
  4132.     case ICBOX5:
  4133.         item = OBOX;
  4134.         title = TOBJECTS;
  4135.         break;
  4136.  
  4137.     case ICBOX6:
  4138.         item = OLINE;
  4139.         title = TOBJECTS;
  4140.         break;
  4141.  
  4142.     case ICBOX7:
  4143.         item = ORBOX;
  4144.         title = TOBJECTS;
  4145.         break;
  4146.  
  4147.     case ICBOX8:
  4148.         item = OIMAGE;
  4149.         title = TOBJECTS;
  4150.         break;
  4151.  
  4152.     default:
  4153.         item = 0;
  4154.         title = 0;
  4155.         break;
  4156.     }
  4157.    }
  4158.    else
  4159.    {
  4160.       switch(obj)
  4161.       {
  4162.     case ICBOX1:
  4163.            item = RCREATE;
  4164.         title = TREGION;
  4165.         break;
  4166.  
  4167.     case ICBOX2:
  4168.               item = ROPENGR;
  4169.         title = TREGION;
  4170.         break;
  4171.  
  4172.     case ICBOX3:
  4173.         item = RTOGGLE;
  4174.         title = TREGION;
  4175.         break;
  4176.  
  4177.     case ICBOX4:
  4178.         item = RDIMAGES;
  4179.         title = TREGION;
  4180.         break;
  4181.  
  4182.     case ICBOX5:
  4183.         item = FNEW;
  4184.         title = TFILE;
  4185.         break;
  4186.  
  4187.     case ICBOX6:
  4188.         item = FPRINT;
  4189.         title = TFILE;
  4190.         break;
  4191.  
  4192.     case ICBOX7:
  4193.         item = OSHOWGR;
  4194.         title = TOPTIONS;
  4195.         break;
  4196.  
  4197.     case ICBOX8:
  4198.         item = OSNAP;
  4199.         title = TOPTIONS;
  4200.         break;
  4201.  
  4202.     default:
  4203.         item = 0;
  4204.         title = 0;
  4205.         break;
  4206.     }
  4207.    }
  4208.  
  4209.    if(item && !(ad_menu[item].ob_state & DISABLED)
  4210.        && !(ad_menu[title].ob_state & DISABLED))
  4211.    {
  4212.     menu_handler(1,item);
  4213.    }
  4214. }
  4215.     
  4216. change_icstate(state,obj,redraw_flag)
  4217. int state;
  4218. int obj;
  4219. int redraw_flag;
  4220. {
  4221.    int x,y;
  4222.    ad_bkgrnd[obj].ob_state = state;
  4223.    if(redraw_flag)
  4224.    {
  4225.       objc_offset(ad_bkgrnd,obj,&x,&y);
  4226.       form_dial(3,0,0,0,0,x,y,
  4227.       ad_bkgrnd[obj].ob_width,
  4228.       ad_bkgrnd[obj].ob_height); 
  4229.    }
  4230. }
  4231.  
  4232. clr_bgicons(redraw_flag)
  4233. int redraw_flag;
  4234. {
  4235.    register int i;
  4236.  
  4237.    for(i = ICBOX1;i <= ICBOX8;i++)
  4238.       if(ad_bkgrnd[i].ob_state == SELECTED)
  4239.       change_icstate(NORMAL,i,redraw_flag);
  4240. }      
  4241.  
  4242.  
  4243.  
  4244.  
  4245.  
  4246. do_template_edit()
  4247. {
  4248.    int titem;
  4249.  
  4250.    tmplate_flag ^= TRUE;
  4251.  
  4252.    menu_text(ad_menu,OEDITTMP,template_mode[tmplate_flag]);
  4253.    if(tmplate_flag)            /* now editing templates     */
  4254.    {
  4255. /*     wind_set(prev_handle,WF_NAME," Base Page Window ",0,0);*/
  4256.      wind_set(prev_handle,WF_NAME,basefname,0,0);
  4257.       menu_ienable(ad_menu,OERASETP,TRUE);
  4258.      menu_ienable(ad_menu,PGOTO,FALSE);
  4259.      menu_ienable(ad_menu,PDELETE,FALSE);
  4260.      menu_ienable(ad_menu,PINSERT,FALSE);
  4261.      tpagehd = pagehd;
  4262.      tcurpage = curpage;
  4263.      temp_page = curr_page;
  4264.      tarthd = arthd;
  4265.      tcurart = curart;     
  4266.  
  4267.      curr_page = right_tmplate->pagenum;
  4268.      pagehd = curpage = right_tmplate;
  4269.      do_pagenum(curr_page,(curr_page%2)?1:0);
  4270.      curart = arthd = ((curr_page % 2)?(rtarthd):(ltarthd));
  4271.  
  4272.      if(view_size == PADJCNT)
  4273.      {
  4274.        titem = ((curr_page % 2) ? (PADJCNT + 1) : (PADJCNT));
  4275.        wind_set(prev_handle,WF_INFO,winfo[titem - PSIZE][unit_type]);       
  4276.      }
  4277.  
  4278.    }
  4279.    else                    /* Now editing preview buffers  */
  4280.    {
  4281.      wind_set(prev_handle,WF_NAME,pfname,0,0);
  4282.      menu_ienable(ad_menu,OERASETP,FALSE);
  4283.      menu_ienable(ad_menu,PGOTO,TRUE);
  4284.      menu_ienable(ad_menu,PDELETE,TRUE);
  4285.      menu_ienable(ad_menu,PINSERT,TRUE);
  4286.  
  4287.      if(curr_page == -2)
  4288.         ltarthd = arthd;
  4289.      else
  4290.         rtarthd = arthd;
  4291.     
  4292.      curart = tcurart;
  4293.      arthd  = tarthd;
  4294.      pagehd = tpagehd;
  4295.      curpage = tcurpage;
  4296.      curr_page = temp_page;
  4297.      do_pagenum(curr_page,(curr_page%2)?1:0);
  4298.      if(view_size == PADJCNT)
  4299.      {
  4300.        titem = ((curr_page % 2) ? (PADJCNT + 1) : (PADJCNT));
  4301.        wind_set(prev_handle,WF_INFO,winfo[titem - PSIZE][unit_type]);       
  4302.      }
  4303.    }
  4304.    force_preview();
  4305. }
  4306.  
  4307.  
  4308. /* clears only one template */
  4309. erase_template()
  4310. {
  4311.    if(alert_cntre(ALERT27) == 1)
  4312.    {
  4313.      if(pagehd  == right_tmplate)
  4314.           free_right_tmplate();
  4315.      else
  4316.           free_left_tmplate();
  4317.      strcpy(basefname," Base Page Window ");
  4318.      wind_set(prev_handle,WF_NAME,basefname,0,0);
  4319.      force_preview();
  4320.    }
  4321. }
  4322.  
  4323.  
  4324.  
  4325. /* clears both templates*/
  4326. delete_tmplates()
  4327. {
  4328.    strcpy(basefname," Base Page Window ");
  4329.    free_templates();
  4330.    init_templates();
  4331. }
  4332.  
  4333.  
  4334.  
  4335. init_templates()
  4336. {
  4337. /*   tmplate_flag = FALSE;        * Set to Edit Preview       */
  4338.  
  4339.    left_tmplate  = (PAGE *)get_lcmem((long)sizeof(PAGE));
  4340.    right_tmplate = (PAGE *)get_lcmem((long)sizeof(PAGE));
  4341.  
  4342.    left_tmplate->pagenum = -2;        /* left page */
  4343.    right_tmplate->pagenum = -1;        /* right page */
  4344.    
  4345.    left_tmplate->nextpage = NULLPTR;
  4346.    right_tmplate->nextpage = NULLPTR;
  4347.    
  4348.    ltarthd = 0L;
  4349.    rtarthd = 0L;
  4350. }
  4351.  
  4352.  
  4353.  
  4354. free_templates()
  4355. {
  4356.    PAGE *rpagehd;
  4357.    PAGE *rcurpage;
  4358.    int  dummy;
  4359.    ARTICLE *art;
  4360.    ARTICLE *rarthd;
  4361.    ARTICLE *rcurart;
  4362.    int rcurr_page;
  4363.  
  4364.    rpagehd = pagehd;
  4365.    rcurpage = curpage;
  4366.    rcurr_page = curr_page;
  4367.    rarthd = arthd;
  4368.    rcurart = curart;
  4369.  
  4370.    pagehd = curpage = left_tmplate;
  4371.    get_fpage(&dummy);
  4372.    while(delete_page());
  4373.  
  4374.    pagehd = curpage = right_tmplate;
  4375.    get_fpage(&dummy);
  4376.    while(delete_page());
  4377.    arthd = ltarthd;
  4378.    art = getf_article();
  4379.    while(delete_article());
  4380.    
  4381.    arthd = rtarthd;
  4382.    art = getf_article();
  4383.    while(delete_article());
  4384.  
  4385.    
  4386.    ltarthd = rtarthd = 0L;    /* CJG */
  4387.  
  4388.    pagehd = rpagehd;
  4389.    curpage = rcurpage;
  4390.    arthd = rarthd;
  4391.    curart = rcurart;
  4392.    curr_page = rcurr_page;
  4393.  
  4394. }
  4395.  
  4396.  
  4397. free_right_tmplate()
  4398. {
  4399.     ARTICLE *art;
  4400.     int dummy;
  4401.  
  4402.     get_fpage(&dummy);
  4403.     while(delete_page());
  4404.  
  4405.     right_tmplate  = (PAGE *)get_lcmem((long)sizeof(PAGE));    
  4406.     right_tmplate->pagenum = -1;        /* right page */
  4407.     right_tmplate->nextpage = NULLPTR;
  4408.  
  4409.     art = getf_article();
  4410.     while(delete_article());
  4411.     rtarthd = 0L;
  4412.  
  4413.     pagehd = curpage = right_tmplate;
  4414.     curr_page = -1;
  4415. }
  4416.  
  4417.  
  4418.  
  4419.  
  4420. free_left_tmplate()
  4421. {
  4422.     ARTICLE *art;
  4423.     int dummy;
  4424.  
  4425.     get_fpage(&dummy);
  4426.     while(delete_page());
  4427.  
  4428.     left_tmplate  = (PAGE *)get_lcmem((long)sizeof(PAGE));    
  4429.     left_tmplate->pagenum = -2;        /* left page */
  4430.     left_tmplate->nextpage = NULLPTR;
  4431.  
  4432.     art = getf_article();
  4433.     while(delete_article());
  4434.     ltarthd = 0L;
  4435.     pagehd = curpage = left_tmplate;
  4436.     curr_page = -2;
  4437. }
  4438.  
  4439.  
  4440.  
  4441.  
  4442. copy_region()
  4443. {
  4444.    int opcode;
  4445.    REGION *new_region;
  4446.    REGION *old_region;
  4447.    int type;
  4448.    PRIMITIVE *tprim;
  4449.    int toggle;
  4450.    register int i;
  4451.    int page;
  4452.    int rectmu[4];
  4453.    int tmulti;
  4454.  
  4455.    rcopy_flag = FALSE;
  4456.  
  4457.    old_region = get_curreg(&type);
  4458.  
  4459.    if(!type)
  4460.        get_txtattr(old_region,&gltxtattr);
  4461.    else
  4462.         get_grattr(old_region,glgrattr);
  4463.    
  4464.  
  4465.    curregion = new_region = create_region(curr_page,type);
  4466.    if(!type)
  4467.     put_txtattr(curregion,&gltxtattr);
  4468.    else
  4469.         put_grattr(curregion,glgrattr);
  4470.  
  4471.    
  4472.    opcode = get_fprimitive(old_region,&count,&wmode);
  4473.    
  4474.    while(opcode != -1)
  4475.    {
  4476.        switch(opcode)
  4477.        {
  4478.          case 3:
  4479.          case 4:
  4480.          case 0: toggle = TRUE;
  4481.          for(i=0;i<(count*2);i++)
  4482.          {
  4483.            ptsarray[i] += ((toggle) ?(deltax):(deltay));
  4484.            toggle ^= TRUE;
  4485.                  }
  4486.                break;
  4487.  
  4488.          case 1: ptsarray[0] += deltax;
  4489.                  ptsarray[1] += deltay;
  4490.          break;
  4491.  
  4492.          case 2: ptsarray[0] += deltax;
  4493.                  ptsarray[2] += deltax;
  4494.                  ptsarray[1] += deltay;
  4495.          ptsarray[3] += deltay;
  4496.          break;
  4497.        }
  4498.  
  4499.        tprim = curprim;
  4500.        switch(opcode)
  4501.        {
  4502.       case 3:
  4503.       case 4:
  4504.       case 0: 
  4505.       case 2: put_poly(opcode,count,wmode,type);
  4506.           break;
  4507.  
  4508.           case 1: put_ellipse(wmode,type);
  4509.           break;
  4510.        }
  4511.        
  4512.        curprim = tprim;
  4513.        opcode = get_nprimitive(&count,&wmode);
  4514.    }
  4515.    graf_mouse(ARROW,&dummy);
  4516.  
  4517.  
  4518.    curregion = region_ptr = new_region;
  4519.  
  4520.    if(type)
  4521.        gl_grregion_ptr = new_region;
  4522.    else
  4523.        gl_region_ptr = new_region;
  4524.  
  4525.  
  4526.    find_boundary(region_ptr,
  4527.                  &rect_in_mu[0],&rect_in_mu[1],
  4528.                  &rect_in_mu[2],&rect_in_mu[3],&dummy,&page);
  4529.  
  4530.    rectmu[0] = rect_in_mu[0];
  4531.    rectmu[1] = rect_in_mu[1];
  4532.    rectmu[2] = rect_in_mu[2];
  4533.    rectmu[3] = rect_in_mu[3];
  4534.  
  4535.  
  4536.    tmulti = multi_mode;
  4537.    if(!type)
  4538.     page_redraw(region_ptr);
  4539.    else
  4540.     update_repel(1,rect_in_mu);
  4541.  
  4542.    if(view_size != PADJCNT && !deferhj && gl_region_ptr)
  4543.         redraw_area(region_ptr,rect_in_mu,1);/* Cleanup old area */
  4544.  
  4545.    multi_mode = tmulti;
  4546.    rect_in_mu[0] = rectmu[0];
  4547.    rect_in_mu[1] = rectmu[1];
  4548.    rect_in_mu[2] = rectmu[2];
  4549.    rect_in_mu[3] = rectmu[3];
  4550.  
  4551.    curregion = region_ptr = new_region;
  4552.    if(!type)                    /* cjg 01/31/89 */
  4553.          gl_region_ptr = region_ptr;
  4554.    else
  4555.      gl_grregion_ptr = region_ptr;
  4556.  
  4557.    if((page % 2) && (view_size == PADJCNT))
  4558.    {
  4559.       alt_offset = TRUE;
  4560.       rect_in_mu[0] += hpage_size;
  4561.       rect_in_mu[2] += hpage_size;
  4562.    }
  4563.    mutoscrn(rect_in_mu[0],rect_in_mu[1],&pxy[0],&pxy[1],0);
  4564.    mutoscrn(rect_in_mu[2],rect_in_mu[3],&pxy[2],&pxy[3],0);
  4565.    if(!multi_mode)
  4566.    {
  4567.       gsx_moff();
  4568.       do_outline(xor_handle,pxy);
  4569.       gsx_mon();
  4570.    }
  4571. }
  4572.  
  4573.  
  4574.  
  4575.  
  4576. copy_prim(opcode,count,wmode)
  4577. int opcode;
  4578. int count;
  4579. int wmode;
  4580. {
  4581.    int type;
  4582.    REGION *tregion;
  4583.    int oldrect[4];
  4584.    int dummy;
  4585.    long prim_ptr;
  4586.    int minx,miny,maxx,maxy;
  4587.  
  4588.    tregion = get_curreg(&type);
  4589.  
  4590.    switch(opcode)
  4591.    {
  4592.       case 3:
  4593.       case 4:
  4594.       case 0: 
  4595.       case 2: put_poly(opcode,count,wmode,type);
  4596.                break;
  4597.  
  4598.       case 1: put_ellipse(wmode,type);
  4599.           break;
  4600.    }
  4601.    get_cur_prim(&count,&wmode,&prim_ptr);
  4602.  
  4603.    region_ptr = tregion;
  4604.  
  4605.    find_boundary(tregion,&oldrect[0],&oldrect[1],&oldrect[2],
  4606.              &oldrect[3],&dummy,&dummy);
  4607.  
  4608.    if(!type)
  4609.    {
  4610.       page_redraw(region_ptr);
  4611.       gl_region_ptr = tregion;
  4612.    }
  4613.    else
  4614.    {
  4615.       update_repel(1,oldrect);
  4616.       gl_grregion_ptr = tregion;
  4617.    }
  4618.    region_ptr = tregion;
  4619.    active_prim = TRUE;
  4620.    open_region(region_ptr);
  4621.    recalc_region();
  4622.    set_cur_prim(prim_ptr);
  4623.    calc_prim(opcode,&minx,&miny,&maxx,&maxy,count);   
  4624.    outline_primman(minx,miny,maxx,maxy,type,curr_page);
  4625.    graf_mouse(ARROW,&dummy);
  4626. }
  4627.  
  4628.  
  4629.  
  4630. check_dpwork_box(mx,my)
  4631. int mx,my;
  4632. {
  4633.     int x1,y1,x2,y2;
  4634.  
  4635.     y1 = dpwork.g_y;
  4636.     y2 = dpwork.g_y + dpwork.g_h - 1;
  4637.  
  4638.     if(view_size == PADJCNT)
  4639.     {
  4640.       if(curr_page % 2)
  4641.       {                /* right side of alternate pages */
  4642.          x1 = dpwork.g_x + (dpwork.g_w/2);
  4643.          x2 = dpwork.g_x + dpwork.g_w - 1;
  4644.       }
  4645.       else
  4646.       {                /* left side of alternate pages  */
  4647.          x1 = dpwork.g_x;
  4648.          x2 = dpwork.g_x + (dpwork.g_w/2) - 1;
  4649.       }
  4650.     }
  4651.     else
  4652.     {
  4653.       x1 = dpwork.g_x;
  4654.       x2 = dpwork.g_x + dpwork.g_w - 1;
  4655.     }
  4656.  
  4657.     if(((mx > x1) && (mx < x2)) &&
  4658.       ((my > y1) && (my < y2)))
  4659.             return(1);
  4660.     else
  4661.        return(0);
  4662. }
  4663.