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