home *** CD-ROM | disk | FTP | other *** search
/ GEMini Atari / GEMini_Atari_CD-ROM_Walnut_Creek_December_1993.iso / files / gnu / gemlib27 / doodle_c < prev    next >
Text File  |  1993-07-30  |  46KB  |  1,947 lines
  1. /************************************************************************/
  2. /*    File:    doodle.c                        */
  3. /************************************************************************/
  4. /*                                    */
  5. /*             GGGGG        EEEEEEEE     MM      MM        */
  6. /*           GG             EE           MMMM  MMMM        */
  7. /*           GG   GGG       EEEEE        MM  MM  MM        */
  8. /*           GG   GG        EE           MM      MM        */
  9. /*             GGGGG        EEEEEEEE     MM      MM        */
  10. /*                                    */
  11. /************************************************************************/
  12. /*                                    */
  13. /*                                    */
  14. /*   The  source code  contained in  this listing is a non-copyrighted    */
  15. /*   work which  can be  freely used.  In applications of  this source    */
  16. /*   code you  are requested to  acknowledge Digital Research, Inc. as    */
  17. /*   the originator of portions of this code.    The code was        */
  18. /*   originally developed by them for the IBM PC.            */
  19. /*                                    */
  20. /*    ATARI ADAPTATION IN COLOR BY HARRY KOONS            */
  21. /*        VERSION 1.1B    7/11/85                    */
  22. /*                                    */
  23. /*    If you find this program of value, I would appreciate a        */
  24. /*    contribution of $20 for the time and effort I have spent in    */
  25. /*    making it work on the Atari 520 ST.                */
  26. /*                                    */
  27. /*    Harry Koons                            */
  28. /*    1123 Oakfair Lane                        */
  29. /*    Harbor City, CA 90710                        */
  30. /*                                    */
  31. /************************************************************************/
  32.  
  33.  
  34. /*
  35.  
  36. Page*/
  37. /*------------------------------*/
  38. /*    includes        */
  39. /*------------------------------*/
  40. #ifndef __GNUC__
  41. #include "define.h"                /* misc. definitions    */
  42. #include "osbind.h"                /* gemdos bindings    */
  43. #include "portab.h"                 /* portable coding conv    */
  44. /* #include "machine.h"  */              /* machine dependent    */
  45. #include "obdefs.h"                /* object definitions    */
  46. #include "gemdefs.h"                /* misc gem definitions */
  47. #include "taddr.h"                /* tree address macros    */
  48. #include "vdibind.h"                /* vdi binding structs    */
  49. #include "b:doodle.h"                /* doodle apl resource  */
  50. #else
  51. #define __OLD_WAY__
  52. #include <osbind.h>                /* gemdos bindings    */
  53. #include <gemfast.h>                /* misc gem definitions */
  54. #include <aesbind.h>                /* aes binding structs    */
  55. #include <vdibind.h>                /* vdi binding structs    */
  56. #include <string.h>                /* string library       */
  57. #include "portab.h"                 /* portable coding conv    */
  58. #include "taddr.h"                /* tree address macros    */
  59. #include "doodle.h"                /* doodle apl resource  */
  60.  
  61. #define WF_HSLSIZ    WF_HSLSIZE
  62. #define WF_VSLSIZ    WF_VSLSIZE
  63. #endif
  64.  
  65. /*------------------------------*/
  66. /*    defines            */
  67. /*------------------------------*/
  68.  
  69.  
  70. #define    DESK        0
  71.  
  72. #define END_UPDATE    0
  73. #define    BEG_UPDATE    1
  74.  
  75. #define SHADE0        0
  76. #define SHADE1        1
  77. #define SHADE2        2
  78. #define SHADE3        3
  79. #define SHADE4        4
  80. #define SHADE5        5
  81. #define SHADE6        6
  82. #define SHADE7        7
  83. #define SHADE8        8
  84. #define SHADE9        9
  85. #define SHADE10        10
  86. #define SHADE11        11
  87. #define SHADE12        12
  88. #define SHADE13        13
  89. #define SHADE14        14
  90. #define SHADE15        15
  91.  
  92.  
  93.  
  94. #define    PEN_FINE    1
  95. #define    PEN_MEDIUM    5
  96. #define    PEN_BROAD    9
  97.  
  98.  
  99.  
  100. /*------------------------------*/
  101. /*    Macros            */
  102. /*------------------------------*/
  103.  
  104. #define LLGET(x) (*((LONG*)(x)))
  105. #define LLSET(x,y) (*((LONG*)(x))=y)
  106. #define LWGET(x) ((WORD)*((WORD*)(x)))
  107. #define LWSET(x,y) (*((WORD*)(x))=y)
  108. #define YSCALE(x) umul_div(x, scrn_xsize, scrn_ysize)
  109. #define TE_TXTLEN(x) (x + 24)
  110. #define ADDR /**/
  111. /* #define GLOBAL */
  112. /*
  113.  
  114. Page*/
  115. /************************************************************************/
  116. /************************************************************************/
  117. /****                                     ****/
  118. /****                Data Structures                 ****/
  119. /****                                     ****/
  120. /************************************************************************/
  121. /************************************************************************/
  122.  
  123.  
  124. /*------------------------------*/
  125. /*    Extrnl Data Structures    */
  126. /*------------------------------*/
  127.  
  128. UWORD    dos_err;    /* no longer external  */
  129.  
  130.  
  131. /*------------------------------*/
  132. /*    Global Data Structures    */
  133. /*------------------------------*/
  134. #ifndef __GNUC__
  135. GLOBAL WORD    contrl[11];        /* control inputs        */
  136. GLOBAL WORD    intin[80];        /* max string length        */
  137. GLOBAL WORD    ptsin[256];        /* polygon fill points        */
  138. GLOBAL WORD    intout[45];        /* open workstation output    */
  139. GLOBAL WORD    ptsout[12];
  140. #endif
  141.  
  142. /*------------------------------*/
  143. /*    Local Data Structures    */
  144. /*------------------------------*/
  145.  
  146. WORD    gl_wchar;            /* character width        */
  147. WORD    gl_hchar;            /* character height        */
  148. WORD    gl_wbox;            /* box (cell) width        */
  149. WORD    gl_hbox;            /* box (cell) height        */
  150. WORD    gl_hspace;            /* height of space between lines*/
  151. WORD    gem_handle;            /* GEM vdi handle        */
  152. WORD    vdi_handle;            /* doodle vdi handle        */
  153. WORD    work_out[57];            /* open virt workstation values    */
  154. GRECT    scrn_area;            /* whole scrn area        */
  155. GRECT    work_area;            /* drawing area of main window  */
  156. GRECT    undo_area;            /* area equal to work_area    */
  157. GRECT    save_area;            /* save area for full/unfulling */
  158. WORD    gl_rmsg[8];            /* message buffer        */
  159. LONG    ad_rmsg;            /* LONG pointer to message bfr    */
  160. LONG    gl_menu;            /* menu tree address        */
  161. WORD    gl_apid;            /* application ID        */
  162. WORD    gl_xfull;            /* full window 'x'        */
  163. WORD    gl_yfull;            /* full window 'y'        */
  164. WORD    gl_wfull;            /* full window 'w'        */
  165. WORD    gl_hfull;            /* full window 'h'        */
  166. WORD    scrn_width;            /* scrn width in pixels    */
  167. WORD    scrn_height;            /* scrn height in pixels    */
  168. WORD    scrn_planes;            /* number of color planes    */
  169. WORD    scrn_xsize;            /* width of one pixel        */
  170. WORD    scrn_ysize;            /* height of one pixel        */
  171. UWORD    m_out = FALSE;            /* mouse in/out of window flag    */
  172. WORD    ev_which;            /* event multi return state(s)    */
  173. UWORD    mousex, mousey;            /* mouse x,y position        */
  174. UWORD    bstate, bclicks;        /* button state, & # of clicks    */
  175. UWORD    kstate, kreturn;        /* key state and keyboard char    */
  176. MFDB    undo_mfdb;            /* undo buffer mmry frm def blk */
  177. MFDB    scrn_mfdb;            /* scrn memory form defn blk    */
  178. LONG    buff_size;            /* buffer size req'd for scrn    */
  179. LONG    buff_location;            /* scrn buffer pointer        */
  180. WORD    dodle_whndl;            /* doodle window handle        */
  181. BOOLEAN    dood_fill = FALSE;        /* fill or draw flag        */
  182. BOOLEAN first_fill = FALSE;        /* to set background color    */
  183. WORD    dodle_shade = SHADE1;        /* doodle current pen shade    */
  184. WORD    pen_ink = SHADE1;        /* current ink shade        */
  185. WORD    bkgr_color = SHADE0;        /* current background shade    */
  186. WORD    bkgr_next = SHADE0;        /* next background shade    */
  187. WORD    dodle_pen = 1;            /* doodle current pen width    */
  188. WORD    dodle_height = 4;        /* doodle current char height    */
  189. WORD    char_fine;            /* character height for fine    */
  190. WORD    char_medium;            /* character height for medium    */
  191. WORD    char_broad;            /* character height for broad    */
  192. WORD    monumber = 5;            /* mouse form number        */
  193. LONG    mofaddr = 0x0L;            /* mouse form address        */
  194. WORD    file_handle;            /* file handle -> pict ld/sv    */
  195. BYTE    file_name[64] = "";        /* current pict file name    */
  196. BOOLEAN    key_input;            /* key inputting state        */
  197. WORD    key_xbeg;            /* x position for line beginning*/
  198. WORD    key_ybeg;            /* y position for line beginning*/
  199. WORD    key_xcurr;            /* current x position        */
  200. WORD    key_ycurr;            /* current y position        */
  201.                     /* doodle window title        */
  202. BYTE    *wdw_title = " Dr Doodle Window ";
  203.  
  204. /*
  205.  
  206. Page*/
  207. /*------------------------------*/
  208. /*    Mouse Data Structures    */
  209. /*------------------------------*/
  210.  
  211. WORD    erase_broad[37] =        /* mouse form for broad eraser    */
  212. {
  213.     7, 7, 1, 0, 1,
  214.     0x0000, 0x0000, 0x0000, 0x0000,    /* mask */
  215.     0x0000, 0x1ff0, 0x1ff0, 0x1ff0,
  216.     0x1ff0, 0x1ff0, 0x0000, 0x0000,
  217.     0x0000, 0x0000, 0x0000, 0x0000,
  218.     0x0000, 0x0000, 0x0000, 0x0000,    /* data */
  219.     0x7ffc, 0x600c, 0x600c, 0x600c,
  220.     0x600c, 0x600c, 0x7ffc, 0x0000,
  221.     0x0000, 0x0000, 0x0000, 0x0000
  222. };
  223. WORD    erase_medium[37] =        /* mouse form for medium eraser    */
  224. {
  225.     7, 7, 1, 0, 1,
  226.     0x0000, 0x0000, 0x0000, 0x0000,    /* mask */
  227.     0x0000, 0x0000, 0x07c0, 0x07c0,
  228.     0x07c0, 0x0000, 0x0000, 0x0000,
  229.     0x0000, 0x0000, 0x0000, 0x0000,
  230.     0x0000, 0x0000, 0x0000, 0x0000,    /* data */
  231.     0x0000, 0x1ff0, 0x1830, 0x1830,
  232.     0x1830, 0x1ff0, 0x0000, 0x0000,
  233.     0x0000, 0x0000, 0x0000, 0x0000
  234. };
  235. WORD    erase_fine[37] =        /* mouse form for fine eraser    */
  236. {
  237.     7, 7, 1, 0, 1,
  238.     0x0000, 0x0000, 0x0000, 0x0000,    /* mask */
  239.     0x0000, 0x0000, 0x0000, 0x0100,
  240.     0x0000, 0x0000, 0x0000, 0x0000,
  241.     0x0000, 0x0000, 0x0000, 0x0000,
  242.     0x0000, 0x0000, 0x0000, 0x0000,    /* data */
  243.     0x0000, 0x0000, 0x07c0, 0x06c0,
  244.     0x07c0, 0x0000, 0x0000, 0x0000,
  245.     0x0000, 0x0000, 0x0000, 0x0000
  246. };
  247.  
  248.  
  249.  
  250. /*
  251.  
  252. Page*/
  253. /************************************************************************/
  254. /************************************************************************/
  255. /****                                     ****/
  256. /****                Local Procedures                 ****/
  257. /****                                     ****/
  258. /************************************************************************/
  259. /************************************************************************/
  260.  
  261.  
  262. /*------------------------------*/
  263. /*    min            */
  264. /*------------------------------*/
  265. WORD
  266. min(a, b)            /* return min of two values */
  267. WORD        a, b;
  268. {
  269.     return( (a < b) ? a : b );
  270. }
  271.  
  272.  
  273. /*------------------------------*/
  274. /*    max            */
  275. /*------------------------------*/
  276. WORD
  277. max(a, b)            /* return max of two values */
  278. WORD        a, b;
  279. {
  280.     return( (a > b) ? a : b );
  281. }
  282.  
  283.  
  284. /*------------------------------*/
  285. /*    string_addr        */
  286. /*------------------------------*/
  287. LONG
  288. string_addr(which)        /* returns a tedinfo LONG string addr    */
  289. WORD    which;
  290. {
  291.     LONG    where;
  292.  
  293.     rsrc_gaddr(R_STRING, which, &where);
  294.     return (where);
  295. } 
  296.  
  297.  
  298. /*------------------------------*/
  299. /*    rc_equal        */
  300. /*------------------------------*/
  301. WORD
  302. rc_equal(p1, p2)        /* tests for two rectangles equal    */
  303. GRECT        *p1, *p2;
  304. {
  305.     if ((p1->g_x != p2->g_x) ||
  306.         (p1->g_y != p2->g_y) ||
  307.         (p1->g_w != p2->g_w) ||
  308.         (p1->g_h != p2->g_h))
  309.         return(FALSE);
  310.     return(TRUE);
  311. }
  312.  
  313.  
  314.  
  315. /*------------------------------*/
  316. /*    rc_copy            */
  317. /*------------------------------*/
  318. WORD
  319. rc_copy(psbox, pdbox)        /* copy source to destination rectangle    */
  320. GRECT    *psbox;
  321. GRECT    *pdbox;
  322. {
  323.     pdbox->g_x = psbox->g_x;
  324.     pdbox->g_y = psbox->g_y;
  325.     pdbox->g_w = psbox->g_w;
  326.     pdbox->g_h = psbox->g_h;
  327. }
  328.  
  329.  
  330. /*------------------------------*/
  331. /*    rc_intersect        */
  332. /*------------------------------*/
  333. WORD
  334. rc_intersect(p1, p2)        /* compute intersect of two rectangles    */
  335. GRECT        *p1, *p2;
  336. {
  337.     WORD        tx, ty, tw, th;
  338.  
  339.     tw = min(p2->g_x + p2->g_w, p1->g_x + p1->g_w);
  340.     th = min(p2->g_y + p2->g_h, p1->g_y + p1->g_h);
  341.     tx = max(p2->g_x, p1->g_x);
  342.     ty = max(p2->g_y, p1->g_y);
  343.     p2->g_x = tx;
  344.     p2->g_y = ty;
  345.     p2->g_w = tw - tx;
  346.     p2->g_h = th - ty;
  347.     return( (tw > tx) && (th > ty) );
  348. }
  349.  
  350.  
  351. /*------------------------------*/
  352. /*    inside            */
  353. /*------------------------------*/
  354. UWORD
  355. inside(x, y, pt)        /* determine if x,y is in rectangle    */
  356. UWORD        x, y;
  357. GRECT        *pt;
  358. {
  359.     if ( (x >= pt->g_x) && (y >= pt->g_y) &&
  360.         (x < pt->g_x + pt->g_w) && (y < pt->g_y + pt->g_h) )
  361.         return(TRUE);
  362.     else
  363.         return(FALSE);
  364. } /* inside */
  365.  
  366.  
  367. /*------------------------------*/
  368. /*    grect_to_array        */
  369. /*------------------------------*/
  370. VOID
  371. grect_to_array(area, array)    /* convert x,y,w,h to upr lt x,y and    */
  372. GRECT    *area;            /*              lwr rt x,y    */
  373. WORD    *array;
  374. {
  375.     *array++ = area->g_x;
  376.     *array++ = area->g_y;
  377.     *array++ = area->g_x + area->g_w - 1;
  378.     *array = area->g_y + area->g_h - 1;
  379. }
  380.  
  381.  
  382. /*------------------------------*/
  383. /*    rast_op            */
  384. /*------------------------------*/
  385. VOID
  386. rast_op(mode, s_area, s_mfdb, d_area, d_mfdb)    /* bit block level trns    */
  387. WORD    mode;
  388. GRECT    *s_area, *d_area;
  389. MFDB    *s_mfdb, *d_mfdb;
  390. {
  391.     WORD    pxy[8];
  392.  
  393.     grect_to_array(s_area, pxy);
  394.     grect_to_array(d_area, &pxy[4]);
  395.     vro_cpyfm(vdi_handle, mode, pxy, s_mfdb, d_mfdb);
  396. }
  397.  
  398.  
  399. /*------------------------------*/
  400. /*    do_open            */
  401. /*------------------------------*/
  402. VOID
  403. do_open(wh, org_x, org_y, x, y, w, h)    /* grow and open specified wdw    */
  404. WORD    wh;
  405. WORD    org_x, org_y;
  406. WORD    x, y, w, h;
  407. {
  408.     graf_growbox(org_x, org_y, 21, 21, x, y, w, h);
  409.     wind_open(wh, x, y, w, h);
  410. }
  411.  
  412.  
  413. /*------------------------------*/
  414. /*    do_close        */
  415. /*------------------------------*/
  416. VOID
  417. do_close(wh, org_x, org_y)    /* close and shrink specified window    */
  418. WORD    wh;
  419. WORD    org_x, org_y;
  420. {
  421.     WORD    x, y, w, h;
  422.  
  423.     wind_get(wh, WF_CURRXYWH, &x, &y, &w, &h);
  424.     wind_close(wh);
  425.     graf_shrinkbox(org_x, org_y, 21, 21, x, y, w, h);
  426. }
  427.  
  428.  
  429. /*------------------------------*/
  430. /*    hndl_dial        */
  431. /*------------------------------*/
  432. WORD
  433. hndl_dial(tree, def, x, y, w, h)    /* center, display and get input*/
  434. LONG    tree;                /*   from specified dialogue box*/
  435. WORD    def;
  436. WORD    x, y, w, h;
  437. {
  438.     WORD    xdial, ydial, wdial, hdial;
  439.     WORD    exit_obj;
  440.  
  441.     form_center(tree, &xdial, &ydial, &wdial, &hdial);
  442.     form_dial(0, x, y, w, h, xdial, ydial, wdial, hdial);
  443.     form_dial(1, x, y, w, h, xdial, ydial, wdial, hdial);
  444.     objc_draw(tree, ROOT, MAX_DEPTH, xdial, ydial, wdial, hdial);
  445.     exit_obj = form_do(tree, def);
  446.     form_dial(2, x, y, w, h, xdial, ydial, wdial, hdial);
  447.     form_dial(3, x, y, w, h, xdial, ydial, wdial, hdial);
  448.     return (exit_obj);
  449. }
  450.  
  451.  
  452. /*------------------------------*/
  453. /*    set_clip        */
  454. /*------------------------------*/
  455. VOID
  456. set_clip(clip_flag, s_area)    /* set clip to specified area    */
  457. WORD    clip_flag;
  458. GRECT    *s_area;
  459. {
  460.     WORD    pxy[4];
  461.  
  462.     grect_to_array(s_area, pxy);
  463.     vs_clip(vdi_handle, clip_flag, pxy);
  464. }
  465.  
  466.  
  467. /*------------------------------*/
  468. /*    align_x            */
  469. /*------------------------------*/
  470. WORD
  471. align_x(x)        /* forces word alignment for column position    */
  472. WORD    x;        /*   rounding to nearest word            */
  473. {
  474.     /*    return((x & 0xfff0) + ((x & 0x000c) ? 0x0010 : 0));    IBM */
  475.     return(x);    /* ATARI    */    
  476. }    
  477.  
  478.  
  479. /*
  480.  
  481. Page*/
  482. /************************************************************************/
  483. /************************************************************************/
  484. /****                                     ****/
  485. /****                Work Area Management             ****/
  486. /****                                     ****/
  487. /************************************************************************/
  488. /************************************************************************/
  489.  
  490.  
  491. /*------------------------------*/
  492. /*    set_work        */
  493. /*------------------------------*/
  494. VOID
  495. set_work(slider_update)        /* update undo area, clamping to page    */
  496. BOOLEAN    slider_update;        /*   edges, and updt sliders if req'd    */
  497. {
  498.     WORD    i;
  499.  
  500.     wind_get(dodle_whndl, WF_WORKXYWH,
  501.     &work_area.g_x, &work_area.g_y,
  502.     &work_area.g_w, &work_area.g_h);
  503.  
  504.     undo_area.g_w = work_area.g_w;
  505.     undo_area.g_h = work_area.g_h;
  506.     /**/                    /* clamp work area to page edges */
  507.     if ((i = undo_mfdb.fwp - (undo_area.g_x + undo_area.g_w)) < 0)
  508.         undo_area.g_x += i;
  509.     if ((i = undo_mfdb.fh - (undo_area.g_y + undo_area.g_h)) < 0)
  510.         undo_area.g_y += i;
  511.  
  512.     if (slider_update)
  513.     {
  514.         wind_set(dodle_whndl, WF_HSLIDE, umul_div(undo_area.g_x, 1000,
  515.             undo_mfdb.fwp - undo_area.g_w), 0, 0, 0);
  516.         wind_set(dodle_whndl, WF_VSLIDE, umul_div(undo_area.g_y, 1000,
  517.             undo_mfdb.fh - undo_area.g_h), 0, 0, 0);
  518.         wind_set(dodle_whndl, WF_HSLSIZ, umul_div(work_area.g_w, 1000,
  519.             undo_mfdb.fwp), 0, 0, 0);
  520.         wind_set(dodle_whndl, WF_VSLSIZ, umul_div(work_area.g_h, 1000,
  521.             undo_mfdb.fh), 0, 0, 0);
  522.     }
  523.  
  524.     undo_area.g_x = align_x(undo_area.g_x);
  525.     /* only use portion of work_area on scrn    */
  526.     rc_intersect(&scrn_area, &work_area);
  527.     undo_area.g_w = work_area.g_w;
  528.     undo_area.g_h = work_area.g_h;
  529. }
  530.  
  531.  
  532. /*------------------------------*/
  533. /*    save_work        */
  534. /*------------------------------*/
  535. VOID
  536. save_work()            /* copy work_area to undo_area buffer    */
  537. {
  538.     GRECT    tmp_area;
  539.  
  540.     rc_copy(&work_area,&tmp_area);
  541.     rc_intersect(&scrn_area,&tmp_area);
  542.     graf_mouse(M_OFF, 0x0L);
  543.     rast_op(3, &tmp_area, &scrn_mfdb, &undo_area, &undo_mfdb);
  544.     graf_mouse(M_ON, 0x0L);
  545. }
  546.  
  547.  
  548. /*------------------------------*/
  549. /*    restore_work        */
  550. /*------------------------------*/
  551. VOID
  552. restore_work()            /* restore work_area from undo_area    */
  553. {
  554.     GRECT    tmp_area;
  555.  
  556.     rc_copy(&work_area,&tmp_area);
  557.     rc_intersect(&scrn_area,&tmp_area);
  558.     graf_mouse(M_OFF, 0x0L);
  559.     rast_op(3, &undo_area, &undo_mfdb, &tmp_area, &scrn_mfdb);
  560.     graf_mouse(M_ON, 0x0L);
  561. }
  562.  
  563.  
  564. /*
  565.  
  566. Page*/
  567. /************************************************************************/
  568. /************************************************************************/
  569. /****                                     ****/
  570. /****                Object Tree Manipulation             ****/
  571. /****                                     ****/
  572. /************************************************************************/
  573. /************************************************************************/
  574.  
  575.  
  576. /*------------------------------*/
  577. /*    do_obj            */
  578. /*------------------------------*/
  579. VOID
  580. do_obj(tree, which, bit)    /* set specified bit in object state    */
  581. LONG    tree;
  582. WORD    which, bit;
  583. {
  584.     WORD    state;
  585.  
  586.     state = LWGET(OB_STATE(which));
  587.     LWSET(OB_STATE(which), state | bit);
  588. }
  589.  
  590.  
  591. /*------------------------------*/
  592. /*    undo_obj        */
  593. /*------------------------------*/
  594. VOID
  595. undo_obj(tree, which, bit)    /* clear specified bit in object state    */
  596. LONG    tree;
  597. WORD    which, bit;
  598. {
  599.     WORD    state;
  600.  
  601.     state = LWGET(OB_STATE(which));
  602.     LWSET(OB_STATE(which), state & ~bit);
  603. }
  604.  
  605. /*------------------------------*/
  606. /*    sel_obj            */
  607. /*------------------------------*/
  608. VOID
  609. sel_obj(tree, which)        /* turn on selected bit of spcfd object    */
  610. LONG    tree;
  611. WORD    which;
  612. {
  613.     do_obj(tree, which, SELECTED);
  614. }
  615.  
  616.  
  617. /*------------------------------*/
  618. /*    desel_obj        */
  619. /*------------------------------*/
  620. VOID
  621. desel_obj(tree, which)        /* turn off selected bit of spcfd object*/
  622. LONG    tree;
  623. WORD    which;
  624. {
  625.     undo_obj(tree, which, SELECTED);
  626. }
  627.  
  628.  
  629. /*------------------------------*/
  630. /*    enab_menu        */
  631. /*------------------------------*/
  632. VOID
  633. enab_menu(which)        /* enable specified menu item    */
  634. WORD    which;
  635. {
  636.     undo_obj(gl_menu, which, DISABLED);
  637. }
  638.  
  639. /*------------------------------*/
  640. /*    objc_xywh        */
  641. /*------------------------------*/
  642. VOID
  643. objc_xywh(tree, obj, p)        /* get x,y,w,h for specified object    */
  644. LONG    tree;
  645. WORD    obj;
  646. GRECT    *p;
  647. {
  648.     objc_offset(tree, obj, &p->g_x, &p->g_y);
  649.     p->g_w = LWGET(OB_WIDTH(obj));
  650.     p->g_h = LWGET(OB_HEIGHT(obj));
  651. }
  652.  
  653.  
  654. /*
  655.  
  656. Page*/
  657. /************************************************************************/
  658. /************************************************************************/
  659. /****                                     ****/
  660. /****                File Path Name Functions             ****/
  661. /****                                     ****/
  662. /************************************************************************/
  663. /************************************************************************/
  664.  
  665.  
  666. /*------------------------------*/
  667. /*    dial_name        */
  668. /*------------------------------*/
  669. WORD
  670. dial_name ( name )        /* dialogue box input filename    */
  671. BYTE    *name;
  672. {            
  673.     LONG    tree ;
  674.     LONG    ted_addr ;
  675.     BYTE    c ;    
  676.     WORD    i, j;
  677.     GRECT    box;
  678.  
  679.  
  680.     objc_xywh(gl_menu, DOODFILE, &box);
  681.     rsrc_gaddr( R_TREE, DOODSVAD, &tree) ;
  682.     ted_addr = LLGET(OB_SPEC(DOODNAME));
  683.     LLSET( ted_addr, ADDR(name) ) ;
  684.     LWSET( TE_TXTLEN(ted_addr),8);
  685.     name[0] = '\0';
  686.     if (hndl_dial(tree, DOODNAME, box.g_x, box.g_y, box.g_w, box.g_h) == DOODSOK)
  687.     {
  688.         i =
  689.             j =  0;
  690.         while (TRUE)
  691.         {
  692.             c = name[i++];
  693.             if (!c) 
  694.                 break ;
  695.             if ( (c != ' ') && (c != '_') )
  696.                 name[j++] = c ;
  697.         }
  698.         if ( *name )
  699.             strcpy( &name[j], ".DOO" ) ;
  700.         desel_obj(tree, DOODSOK);
  701.         return ((WORD) *name);
  702.     }
  703.     else
  704.     {
  705.         desel_obj(tree, DOODSCNL);
  706.         return (FALSE);
  707.     }
  708. }
  709.  
  710.  
  711. /*------------------------------*/
  712. /*    get_path        */
  713. /*------------------------------*/
  714. VOID
  715. get_path(tmp_path, spec)    /* get directory path name    */
  716. BYTE    *tmp_path, *spec;
  717. {
  718.     WORD    cur_drv;
  719.  
  720.     cur_drv = Dgetdrv();
  721.     tmp_path[0] = cur_drv + 'A';
  722.     tmp_path[1] = ':';
  723.     tmp_path[2] = '\\';
  724.         Dgetpath(ADDR(&tmp_path[3]), cur_drv+1);
  725.     if ((int)strlen(tmp_path) > 3)
  726.         strcat(tmp_path, "\\");
  727.     else
  728.         tmp_path[2] = '\0';
  729.     strcat(tmp_path, spec);
  730. }
  731.  
  732.  
  733. /*------------------------------*/
  734. /*    add_file_name        */
  735. /*------------------------------*/
  736. VOID
  737. add_file_name(dname, fname)    /* replace name at end of input file spec*/
  738. BYTE    *dname, *fname;
  739. {
  740.     BYTE    c;
  741.     WORD    ii;
  742.  
  743.  
  744.     ii = (int)strlen(dname);
  745.     while (ii && (((c = dname[ii-1])  != '\\') && (c != ':')))
  746.         ii--;
  747.     dname[ii] = '\0';
  748.     strcat(dname, fname);
  749. }
  750.  
  751.  
  752. /*------------------------------*/
  753. /*    get_file        */
  754. /*------------------------------*/
  755. WORD
  756. get_file(loop)            /* use file selector to get input file    */
  757. BOOLEAN    loop;
  758. {
  759.     WORD    fs_iexbutton;
  760.     BYTE    fs_iinsel[13];
  761.  
  762.     while (TRUE)
  763.     {
  764.         get_path(file_name, "*.DOO");
  765.         fs_iinsel[0] = '\0';
  766.  
  767.         fsel_input(ADDR(file_name), ADDR(fs_iinsel), &fs_iexbutton);
  768.         if (fs_iexbutton)
  769.         {
  770.             add_file_name(file_name, fs_iinsel);
  771.             file_handle = Fopen(ADDR(file_name),2);
  772.             dos_err = (file_handle < 0) ? -1 : 0;
  773.             if (!loop || (loop && !dos_err))
  774.                 return(1);
  775.         }
  776.         else
  777.             return (0);
  778.     }
  779. } /* get_file */
  780.  
  781.  
  782. /*
  783.  
  784. Page*/
  785. /************************************************************************/
  786. /************************************************************************/
  787. /****                                     ****/
  788. /****                Soft Cursor Support                 ****/
  789. /****                                     ****/
  790. /************************************************************************/
  791. /************************************************************************/
  792.  
  793.  
  794. /*------------------------------*/
  795. /*    cursor            */
  796. /*------------------------------*/
  797. VOID
  798. cursor(color)            /* turn cursor on,  color = pen_ink    */
  799. WORD    color;            /*   or cursor off, color = bkgr_color    */
  800. {
  801.     WORD    pxy[4];
  802.  
  803.     pxy[0] = key_xcurr + 1;
  804.     pxy[1] = key_ycurr + gl_hspace;
  805.     pxy[2] = key_xcurr + 1;
  806.     pxy[3] = key_ycurr - gl_hbox;
  807.  
  808.     vsl_color(vdi_handle,color);
  809.     vswr_mode(vdi_handle,MD_REPLACE);
  810.     vsl_type (vdi_handle,IP_1PATT);
  811.     vsl_width (vdi_handle,PEN_FINE);
  812.     v_pline(vdi_handle, 2, pxy);
  813. }
  814.  
  815.  
  816. /*------------------------------*/
  817. /*    curs_on            */
  818. /*------------------------------*/
  819. VOID
  820. curs_on()            /* turn 'soft' cursor 'on'    */
  821. {
  822.     cursor(pen_ink);
  823. }
  824.  
  825. /*------------------------------*/
  826. /*    curs_off        */
  827. /*------------------------------*/
  828. VOID
  829. curs_off()            /* turn 'soft' cursor 'off'    */
  830. {
  831.     cursor(bkgr_color);
  832. }
  833.  
  834.  
  835. /*
  836.  
  837. Page*/
  838. /************************************************************************/
  839. /************************************************************************/
  840. /****                                     ****/
  841. /****                Menu Handling                 ****/
  842. /****                                     ****/
  843. /************************************************************************/
  844. /************************************************************************/
  845.  
  846.  
  847. /*------------------------------*/
  848. /*    hdl_menu        */
  849. /*------------------------------*/
  850. WORD
  851. hdl_menu(title, item)
  852. WORD     title, item;
  853. {
  854.     WORD    done;
  855.     WORD    me_creturn;
  856.  
  857.     graf_mouse(ARROW, 0x0L);
  858.     done = FALSE;
  859.     switch (title) {
  860.     case DOODDESK:
  861.         if (item == DOODINFO)
  862.             do_about();
  863.         break;
  864.  
  865.     case DOODFILE:
  866.         switch (item)
  867.         {
  868.         case DOODLOAD:
  869.             do_load(TRUE);
  870.             break;
  871.         case DOODSAVE:
  872.             do_sav();
  873.             break;
  874.         case DOODSVAS:
  875.             do_savas();
  876.             break;
  877.         case DOODABAN:
  878.             file_handle = Fopen(ADDR(file_name),2);
  879.             do_load(FALSE);
  880.             break;
  881.         case DOODQUIT:
  882.             done = TRUE;
  883.             break;
  884.         }
  885.  
  886.     case DOODOPTS:
  887.         switch (item)
  888.         {
  889.         case DOODPENS:
  890.             do_penselect();
  891.             break;
  892.         case DOODERAP:
  893.             do_erase();
  894.             first_fill = TRUE;
  895.             break;
  896.         }
  897.  
  898.     case DOODCOLR:
  899.         switch (item)
  900.         {
  901.         case COLOR0:
  902.             pen_ink = SHADE0;
  903.             do_clnormal();
  904.             me_creturn = menu_icheck (gl_menu, COLOR0, SELECTED);
  905.             break;
  906.         case COLOR1:
  907.             pen_ink = SHADE1;
  908.             do_clnormal();
  909.             me_creturn = menu_icheck (gl_menu, COLOR1, SELECTED);
  910.             break;
  911.         case COLOR2:
  912.             pen_ink = SHADE2;
  913.             do_clnormal();
  914.             me_creturn = menu_icheck (gl_menu, COLOR2, SELECTED);
  915.             break;
  916.         case COLOR3:
  917.             pen_ink = SHADE3;
  918.             do_clnormal();
  919.             me_creturn = menu_icheck (gl_menu, COLOR3, SELECTED);
  920.             break;
  921.         case COLOR4:
  922.             pen_ink = SHADE4;
  923.             do_clnormal();
  924.             me_creturn = menu_icheck (gl_menu, COLOR4, SELECTED);
  925.             break;
  926.         case COLOR5:
  927.             pen_ink = SHADE5;
  928.             do_clnormal();
  929.             me_creturn = menu_icheck (gl_menu, COLOR5, SELECTED);
  930.             break;
  931.         case COLOR6:
  932.             pen_ink = SHADE6;
  933.             do_clnormal();
  934.             me_creturn = menu_icheck (gl_menu, COLOR6, SELECTED);
  935.             break;
  936.         case COLOR7:
  937.             pen_ink = SHADE7;
  938.             do_clnormal();
  939.             me_creturn = menu_icheck (gl_menu, COLOR7, SELECTED);
  940.             break;
  941.         case COLOR8:
  942.             pen_ink = SHADE8;
  943.             do_clnormal();
  944.             me_creturn = menu_icheck (gl_menu, COLOR8, SELECTED);
  945.             break;
  946.         case COLOR9:
  947.             pen_ink = SHADE9;
  948.             do_clnormal();
  949.             me_creturn = menu_icheck (gl_menu, COLOR9, SELECTED);
  950.             break;
  951.         case COLOR10:
  952.             pen_ink = SHADE10;
  953.             do_clnormal();
  954.             me_creturn = menu_icheck (gl_menu, COLOR10, SELECTED);
  955.             break;
  956.         case COLOR11:
  957.             pen_ink = SHADE11;
  958.             do_clnormal();
  959.             me_creturn = menu_icheck (gl_menu, COLOR11, SELECTED);
  960.             break;
  961.         case COLOR12:
  962.             pen_ink = SHADE12;
  963.             do_clnormal();
  964.             me_creturn = menu_icheck (gl_menu, COLOR12, SELECTED);
  965.             break;
  966.         case COLOR13:
  967.             pen_ink = SHADE13;
  968.             do_clnormal();
  969.             me_creturn = menu_icheck (gl_menu, COLOR13, SELECTED);
  970.             break;
  971.         case COLOR14:
  972.             pen_ink = SHADE14;
  973.             do_clnormal();
  974.             me_creturn = menu_icheck (gl_menu, COLOR14, SELECTED);
  975.             break;
  976.         case COLOR15:
  977.             pen_ink = SHADE15;
  978.             do_clnormal();
  979.             me_creturn = menu_icheck (gl_menu, COLOR15, SELECTED);
  980.             break;
  981.         }
  982.  
  983.         dodle_shade = pen_ink;
  984.  
  985.     }
  986.     menu_tnormal(gl_menu,title,TRUE);
  987.     graf_mouse(monumber, mofaddr);
  988.     return (done);
  989. }
  990.  
  991.  
  992. /*------------------------------*/
  993. /*    do_clnormal        */
  994. /*------------------------------*/
  995. VOID
  996. do_clnormal()    /*    set all color checks to NORMAL in color menu    */
  997. {
  998.     WORD    me_creturn;
  999.  
  1000.     me_creturn = menu_icheck(gl_menu, COLOR0, NORMAL);
  1001.     me_creturn = menu_icheck(gl_menu, COLOR1, NORMAL);
  1002.     me_creturn = menu_icheck(gl_menu, COLOR2, NORMAL);
  1003.     me_creturn = menu_icheck(gl_menu, COLOR3, NORMAL);
  1004.     me_creturn = menu_icheck(gl_menu, COLOR4, NORMAL);
  1005.     me_creturn = menu_icheck(gl_menu, COLOR5, NORMAL);
  1006.     me_creturn = menu_icheck(gl_menu, COLOR6, NORMAL);
  1007.     me_creturn = menu_icheck(gl_menu, COLOR7, NORMAL);
  1008.     me_creturn = menu_icheck(gl_menu, COLOR8, NORMAL);
  1009.     me_creturn = menu_icheck(gl_menu, COLOR9, NORMAL);
  1010.     me_creturn = menu_icheck(gl_menu, COLOR10, NORMAL);
  1011.     me_creturn = menu_icheck(gl_menu, COLOR11, NORMAL);
  1012.     me_creturn = menu_icheck(gl_menu, COLOR12, NORMAL);
  1013.     me_creturn = menu_icheck(gl_menu, COLOR13, NORMAL);
  1014.     me_creturn = menu_icheck(gl_menu, COLOR14, NORMAL);
  1015.     me_creturn = menu_icheck(gl_menu, COLOR15, NORMAL);
  1016. }
  1017.  
  1018. /*------------------------------*/
  1019. /*    do_about        */
  1020. /*------------------------------*/
  1021. VOID
  1022. do_about()            /* display Doodle Info...     */
  1023. {
  1024.     LONG    tree;
  1025.     GRECT    box;
  1026.  
  1027.     objc_xywh(gl_menu, DOODDESK, &box);
  1028.     rsrc_gaddr(R_TREE, DOODINFD, &tree);
  1029.     hndl_dial(tree, 0, box.g_x, box.g_y, box.g_w, box.g_h);
  1030.     desel_obj(tree, DOODOK);
  1031. }
  1032.  
  1033.  
  1034. /*------------------------------*/
  1035. /*    do_load            */
  1036. /*------------------------------*/
  1037. VOID
  1038. do_load(need_name)        /* load doodle picture file    */
  1039. BOOLEAN    need_name;
  1040. {
  1041.     if (!need_name || get_file(TRUE))
  1042.     {
  1043.         if (!dos_err)
  1044.         {
  1045.             Fread(file_handle, buff_size,buff_location);
  1046.             Fclose(file_handle);
  1047.             enab_menu(DOODSAVE);
  1048.             enab_menu(DOODABAN);
  1049.             restore_work();
  1050.         }
  1051.     }
  1052. }
  1053.  
  1054.  
  1055. /*------------------------------*/
  1056. /*    do_sav            */
  1057. /*------------------------------*/
  1058. VOID
  1059. do_sav()            /* save current named doodle picture    */
  1060. {
  1061.     if (*file_name)
  1062.     {
  1063.         file_handle = Fopen(ADDR(file_name),2);
  1064.         dos_err = (file_handle < 0) ? 1 : 0;
  1065.         if (dos_err)
  1066.             file_handle = Fcreate(ADDR(file_name),0);
  1067.         else
  1068.         {
  1069.             if (form_alert(1, string_addr(DOODOVWR)) == 2)
  1070.                 return;
  1071.         }
  1072.         Fwrite(file_handle, buff_size, buff_location);
  1073.         enab_menu(DOODSAVE);
  1074.         enab_menu(DOODABAN);
  1075.         Fclose(file_handle);
  1076.     }
  1077. }
  1078.  
  1079.  
  1080. /*------------------------------*/
  1081. /*    do_sav_as        */
  1082. /*------------------------------*/
  1083. VOID
  1084. do_savas()            /* save doodle picture as named    */
  1085. {
  1086.     BYTE    name[13];
  1087.  
  1088.     if (dial_name(&name[0]))
  1089.     {
  1090.         add_file_name(file_name, name);
  1091.         do_sav();
  1092.     }
  1093. }
  1094.  
  1095.  
  1096. /*------------------------------*/
  1097. /*    do_penselect        */
  1098. /*------------------------------*/
  1099. VOID
  1100. do_penselect()            /* use dialogue box to input selection    */
  1101. {                /*   of specified pen/eraser        */
  1102.     WORD    exit_obj;
  1103.     LONG    tree;
  1104.     GRECT    box;
  1105.  
  1106.     objc_xywh(gl_menu, DOODPENS, &box);
  1107.     rsrc_gaddr(R_TREE, DOODPEND, &tree);
  1108.     /**/            /* first setup current selection state    */
  1109.     if (dodle_pen == PEN_FINE)
  1110.     {
  1111.         sel_obj(tree, DOODFINE);
  1112.         desel_obj(tree, DOODMED);
  1113.         desel_obj(tree, DOODBRD);
  1114.     }
  1115.     else
  1116.         if (dodle_pen == PEN_MEDIUM)
  1117.         {
  1118.             sel_obj(tree, DOODMED);
  1119.             desel_obj(tree, DOODFINE);
  1120.             desel_obj(tree, DOODBRD);
  1121.         }
  1122.         else
  1123.         {
  1124.             sel_obj(tree, DOODBRD);
  1125.             desel_obj(tree, DOODFINE);
  1126.             desel_obj(tree, DOODMED);
  1127.         }
  1128.     if (dodle_shade == pen_ink && dood_fill == FALSE)
  1129.     {
  1130.         sel_obj(tree, DOODPEN);
  1131.         desel_obj(tree, DOODERSR);
  1132.         desel_obj(tree, DOODFILL);
  1133.     }
  1134.     else if (dodle_shade == pen_ink && dood_fill == TRUE)
  1135.     {
  1136.         desel_obj(tree, DOODPEN);
  1137.         desel_obj(tree, DOODERSR);
  1138.         sel_obj(tree, DOODFILL);
  1139.     }
  1140.     else
  1141.     {
  1142.         desel_obj(tree, DOODPEN);
  1143.         sel_obj(tree, DOODERSR);
  1144.         desel_obj(tree, DOODFILL);
  1145.     }
  1146.  
  1147.     /* get dialogue box input    */
  1148.  
  1149.     exit_obj = hndl_dial(tree, 0, box.g_x, box.g_y, box.g_w, box.g_h);
  1150.     if (exit_obj == DOODPSOK)
  1151.     {
  1152.         if (LWGET(OB_STATE(DOODFINE)) & SELECTED)
  1153.         {
  1154.             dodle_pen = PEN_FINE;
  1155.             dodle_height = char_fine;
  1156.         }
  1157.         else
  1158.             if (LWGET(OB_STATE(DOODMED)) & SELECTED)
  1159.             {
  1160.                 dodle_pen = PEN_MEDIUM;
  1161.                 dodle_height = char_medium;
  1162.             }
  1163.             else
  1164.             {
  1165.                 dodle_pen = PEN_BROAD;
  1166.                 dodle_height = char_broad;
  1167.             }
  1168.         if (LWGET(OB_STATE(DOODPEN)) & SELECTED)
  1169.         {
  1170.             dodle_shade = pen_ink;
  1171.             monumber = 5;
  1172.             mofaddr = 0x0L;
  1173.             dood_fill = FALSE;
  1174.         }
  1175.         else if (LWGET(OB_STATE(DOODERSR)) & SELECTED)
  1176.         {
  1177.             dodle_shade = bkgr_color;
  1178.             monumber = 255;
  1179.             mofaddr = (dodle_pen == PEN_FINE) ? ADDR((BYTE *)erase_fine) :
  1180.             (dodle_pen == PEN_MEDIUM) ? ADDR((BYTE *)erase_medium) :
  1181.             ADDR((BYTE *)erase_broad);
  1182.             dood_fill = FALSE;
  1183.         }
  1184.         else
  1185.         {
  1186.             dodle_shade = pen_ink;
  1187.             monumber = POINT_HAND;
  1188.             mofaddr = 0x0L;
  1189.             dood_fill = TRUE;
  1190.         }
  1191.  
  1192.         desel_obj(tree, DOODPSOK);
  1193.     }
  1194.     else
  1195.         desel_obj(tree, DOODCNCL);
  1196. }
  1197.  
  1198.  
  1199. /*------------------------------*/
  1200. /*    do_erase        */
  1201. /*------------------------------*/
  1202. VOID
  1203. do_erase()            /* clear the scrn and the undo buffer    */
  1204. {
  1205.     WORD    fo_aexbttn;
  1206.  
  1207.     fo_aexbttn = form_alert(0, string_addr(ERASEWRN));
  1208.  
  1209.     if (fo_aexbttn == 1)
  1210.     {
  1211.         rast_op(0, &scrn_area, &scrn_mfdb, &scrn_area, &undo_mfdb);
  1212.         restore_work();
  1213.     }
  1214. }
  1215. /*
  1216.  
  1217. Page*/
  1218. /************************************************************************/
  1219. /************************************************************************/
  1220. /****                                     ****/
  1221. /****                Keyboard Handling                 ****/
  1222. /****                                     ****/
  1223. /************************************************************************/
  1224. /************************************************************************/
  1225.  
  1226.  
  1227. /*------------------------------*/
  1228. /*    hndl_keyboard        */
  1229. /*------------------------------*/
  1230. WORD
  1231. hndl_keyboard()
  1232. {
  1233.     WORD    i;
  1234.     BYTE    str[2];
  1235.  
  1236.     if ((str[0] = kreturn) == 0x03)
  1237.         return(TRUE);
  1238.     graf_mouse(M_OFF, 0x0L);
  1239.     if (!key_input)
  1240.     {
  1241.         vsl_color(vdi_handle,dodle_shade);
  1242.         vswr_mode(vdi_handle,MD_TRANS);
  1243.         vsl_type (vdi_handle,IP_1PATT);
  1244.         vst_height(vdi_handle, dodle_height,
  1245.         &gl_wchar,&gl_hchar,&gl_wbox,&gl_hbox);
  1246.         gl_hspace = gl_hbox - gl_hchar;
  1247.         set_clip(TRUE, &work_area);
  1248.         graf_mkstate(&key_xbeg, &key_ybeg, &i, &i);
  1249.         key_xcurr = ++key_xbeg;
  1250.         key_ycurr = --key_ybeg;
  1251.     }
  1252.     else
  1253.  
  1254.     /*    curs_off();    remove from color version 6/30/85    */
  1255.  
  1256.     str[1] = '\0';
  1257.     if (str[0] == 0x1A)
  1258.     {
  1259.         save_work();
  1260.         graf_mouse(M_ON, 0x0L);
  1261.         return(key_input = FALSE);
  1262.     }
  1263.     else
  1264.         if (str[0] == 0x0D)
  1265.         {
  1266.             key_ycurr += gl_hbox + gl_hspace;
  1267.             key_xcurr = key_xbeg;
  1268.         }
  1269.         else
  1270.             if (str[0] == 0x08)
  1271.             {
  1272.                 if (key_input && (key_xcurr != key_xbeg))
  1273.                 {
  1274.                     for (i = 0; i < gl_wbox; i++)
  1275.                     {
  1276.                         key_xcurr--;
  1277.                     /*    curs_off();    */
  1278.                     }
  1279.                 }
  1280.             }
  1281.             else
  1282.                 if ((str[0] >= ' ') && (str[0] <= 'z'))
  1283.                 {
  1284.                     str[1] = '\0';
  1285.                     vswr_mode(vdi_handle, MD_TRANS);
  1286.                     vst_color(vdi_handle, pen_ink);
  1287.                     v_gtext(vdi_handle, key_xcurr,
  1288.                     key_ycurr, str);
  1289.                     key_xcurr += gl_wbox;
  1290.                 }
  1291.     if (!key_input)
  1292.     {
  1293.         key_input = TRUE;
  1294.     }
  1295.     /*    curs_on();    remove from color version 6/30/85  */
  1296.     graf_mouse(M_ON, 0x0L);
  1297.     return(FALSE);
  1298. }
  1299.  
  1300.  
  1301.  
  1302. /*
  1303.  
  1304. Page*/
  1305. /************************************************************************/
  1306. /************************************************************************/
  1307. /****                                     ****/
  1308. /****                Message Handling                 ****/
  1309. /****                                     ****/
  1310. /************************************************************************/
  1311. /************************************************************************/
  1312.  
  1313.  
  1314. /*------------------------------*/
  1315. /*    hdl_message        */
  1316. /*------------------------------*/
  1317. /*MLOCAL*/    BOOLEAN    hdl_message()
  1318. {
  1319.     BOOLEAN    done; 
  1320.     WORD    wdw_hndl;
  1321.  
  1322.     done = FALSE;
  1323.     wdw_hndl = gl_rmsg[3];
  1324.     switch( gl_rmsg[0] )
  1325.     {
  1326.     case MN_SELECTED:
  1327.         done = hdl_menu(wdw_hndl, gl_rmsg[4]);
  1328.         break;
  1329.  
  1330.     case WM_REDRAW:
  1331.         do_redraw(wdw_hndl, (GRECT *) &gl_rmsg[4]);
  1332.         break;
  1333.  
  1334.     case WM_TOPPED:
  1335.         wind_set(wdw_hndl, WF_TOP, 0, 0, 0, 0);
  1336.         break;
  1337.     case WM_CLOSED:
  1338.         done = TRUE;
  1339.         break;
  1340.     case WM_FULLED:
  1341.         do_full(wdw_hndl);
  1342.         break;
  1343.     case WM_ARROWED:
  1344.         switch(gl_rmsg[4])
  1345.         {
  1346.         case WA_UPPAGE:
  1347.             undo_area.g_y = max(undo_area.g_y - undo_area.g_h, 0);
  1348.             break;
  1349.         case WA_DNPAGE:
  1350.             undo_area.g_y += undo_area.g_h;
  1351.             break;
  1352.         case WA_UPLINE:
  1353.             undo_area.g_y = max(undo_area.g_y - YSCALE(16), 0);
  1354.             break;
  1355.         case WA_DNLINE:
  1356.             undo_area.g_y += YSCALE(16);
  1357.             break;
  1358.         case WA_LFPAGE:
  1359.             undo_area.g_x = max(undo_area.g_x-undo_area.g_w, 0);
  1360.             break;
  1361.         case WA_RTPAGE:
  1362.             undo_area.g_x += undo_area.g_w;
  1363.             break;
  1364.         case WA_LFLINE:
  1365.             undo_area.g_x = max(undo_area.g_x - 16, 0);
  1366.             break;
  1367.         case WA_RTLINE:
  1368.             undo_area.g_x += 16;
  1369.             break;
  1370.         }
  1371.         set_work(TRUE);
  1372.         restore_work();
  1373.         break;
  1374.     case WM_HSLID:
  1375.         undo_area.g_x = align_x(umul_div(undo_mfdb.fwp - undo_area.g_w,
  1376.         gl_rmsg[4], 1000));
  1377.         wind_set(dodle_whndl, WF_HSLIDE, umul_div(undo_area.g_x, 1000,
  1378.         undo_mfdb.fwp - undo_area.g_w), 0, 0, 0);
  1379.         restore_work();
  1380.         break;
  1381.     case WM_VSLID:
  1382.         undo_area.g_y = umul_div(undo_mfdb.fh - undo_area.g_h,
  1383.         gl_rmsg[4],1000);
  1384.         wind_set(dodle_whndl, WF_VSLIDE, umul_div(undo_area.g_y, 1000,
  1385.         undo_mfdb.fh - undo_area.g_h), 0, 0, 0);
  1386.         restore_work();
  1387.         break;
  1388.     case WM_SIZED:
  1389.         wind_set(wdw_hndl, WF_CURRXYWH, align_x(gl_rmsg[4]) - 1,
  1390.         gl_rmsg[5], gl_rmsg[6], gl_rmsg[7]);
  1391.         set_work(TRUE);
  1392.         break;
  1393.     case WM_MOVED:
  1394.         gl_rmsg[4] = align_x(gl_rmsg[4]);
  1395.         wind_set(wdw_hndl, WF_CURRXYWH, align_x(gl_rmsg[4]) - 1,
  1396.         gl_rmsg[5], gl_rmsg[6], gl_rmsg[7]);
  1397.         set_work(FALSE);
  1398.         break;
  1399.     } /* switch */
  1400.     return(done);
  1401. } /* hdl_mesag */
  1402.  
  1403. /*------------------------------*/
  1404. /*    do_redraw        */
  1405. /*------------------------------*/
  1406. VOID
  1407. do_redraw(wh, area)        /* redraw specified area from undo bfr    */
  1408. WORD    wh;
  1409. GRECT    *area;
  1410. {
  1411.     GRECT    box;
  1412.     GRECT    dirty_source, dirty_dest;
  1413.  
  1414.     graf_mouse(M_OFF, 0x0L);
  1415.  
  1416.     wind_get(wh, WF_FIRSTXYWH, &box.g_x, &box.g_y, &box.g_w, &box.g_h);
  1417.     while ( box.g_w && box.g_h )
  1418.     {
  1419.         if (rc_intersect(area, &box))
  1420.         {
  1421.             if (wh == dodle_whndl)
  1422.             {
  1423.                 rc_copy(&box, &dirty_dest);
  1424.                 if (rc_intersect(&work_area, &dirty_dest))
  1425.                 {
  1426.                     dirty_source.g_x = (dirty_dest.g_x - work_area.g_x)
  1427.                         + undo_area.g_x;
  1428.                     dirty_source.g_y = (dirty_dest.g_y - work_area.g_y)
  1429.                         + undo_area.g_y;
  1430.                     dirty_source.g_w = dirty_dest.g_w;
  1431.                     dirty_source.g_h = dirty_dest.g_h;
  1432.                     rast_op(3, &dirty_source, &undo_mfdb,
  1433.                     &dirty_dest, &scrn_mfdb);
  1434.                 }
  1435.             }
  1436.         }
  1437.         wind_get(wh, WF_NEXTXYWH, &box.g_x, &box.g_y, &box.g_w, &box.g_h);
  1438.     }
  1439.     graf_mouse(M_ON, 0x0L);
  1440. }
  1441.  
  1442. /*------------------------------*/
  1443. /*    do_full            */
  1444. /*------------------------------*/
  1445. VOID
  1446. do_full(wh)    /* depending on current window state, either make window*/
  1447. WORD    wh;    /*   full size -or- return to previous shrunken size    */
  1448. {
  1449.     GRECT    prev;
  1450.     GRECT    curr;
  1451.     GRECT    full;
  1452.  
  1453.     graf_mouse(M_OFF,0x0L);
  1454.     wind_get(wh, WF_CURRXYWH, &curr.g_x, &curr.g_y, &curr.g_w, &curr.g_h);
  1455.     wind_get(wh, WF_PREVXYWH, &prev.g_x, &prev.g_y, &prev.g_w, &prev.g_h);
  1456.     wind_get(wh, WF_FULLXYWH, &full.g_x, &full.g_y, &full.g_w, &full.g_h);
  1457.     if ( rc_equal(&curr, &full) )
  1458.     {                    /* is full now so change*/
  1459.         /**/                    /*   to previous    */
  1460.         graf_shrinkbox(prev.g_x, prev.g_y, prev.g_w, prev.g_h,
  1461.             full.g_x, full.g_y, full.g_w, full.g_h);
  1462.         wind_set(wh, WF_CURRXYWH, prev.g_x, prev.g_y, prev.g_w, prev.g_h);
  1463.         rc_copy(&save_area, &undo_area);
  1464.         set_work(TRUE);
  1465.         if ((prev.g_x == full.g_x) && (prev.g_y == full.g_y))
  1466.             do_redraw(wh, &work_area);
  1467.     }
  1468.     else
  1469.     {                    /* is not full so make    */
  1470.         /**/                    /*   it full        */
  1471.         rc_copy(&undo_area, &save_area);
  1472.         graf_growbox(curr.g_x, curr.g_y, curr.g_w, curr.g_h,
  1473.             full.g_x, full.g_y, full.g_w, full.g_h);
  1474.         wind_set(wh, WF_CURRXYWH, full.g_x, full.g_y, full.g_w, full.g_h);
  1475.         set_work(TRUE);
  1476.     }
  1477.     graf_mouse(M_ON,0x0L);
  1478. }
  1479. /*
  1480.  
  1481. Page*/
  1482. /************************************************************************/
  1483. /************************************************************************/
  1484. /****                                     ****/
  1485. /****                Mouse Handling                 ****/
  1486. /****                                     ****/
  1487. /************************************************************************/
  1488. /************************************************************************/
  1489.  
  1490.  
  1491. /*------------------------------*/
  1492. /*    hdl_mouse        */
  1493. /*------------------------------*/
  1494. WORD
  1495. hdl_mouse()
  1496. {
  1497.     BOOLEAN    done;
  1498.  
  1499.     if (m_out)
  1500.         graf_mouse(ARROW, 0x0L);
  1501.     else
  1502.         graf_mouse(monumber, mofaddr);
  1503.  
  1504.     m_out = !m_out;
  1505.     done = FALSE;
  1506.     return(done);
  1507. }
  1508.  
  1509.  
  1510. /*
  1511.  
  1512. Page*/
  1513. /************************************************************************/
  1514. /************************************************************************/
  1515. /****                                     ****/
  1516. /****                Button Handling                 ****/
  1517. /****                                     ****/
  1518. /************************************************************************/
  1519. /************************************************************************/
  1520.  
  1521.  
  1522. /*------------------------------*/
  1523. /*    hndl_button        */
  1524. /*------------------------------*/
  1525. WORD
  1526. hndl_button()
  1527. {
  1528.     WORD    done;
  1529.  
  1530.     done = FALSE;
  1531.     if (inside(mousex, mousey, &work_area))
  1532.     {
  1533.         if (dood_fill == TRUE)
  1534.             do_fill(mousex, mousey);
  1535.         else
  1536.             draw_pencil(mousex, mousey);
  1537.     }
  1538.     return(done);
  1539. }
  1540.  
  1541.  
  1542. /*------------------------------*/
  1543. /*    draw_pencil        */
  1544. /*------------------------------*/
  1545. WORD
  1546. draw_pencil(x, y)
  1547. UWORD    x, y;
  1548. {
  1549.     UWORD    pxy[4];
  1550.     WORD    done;
  1551.     UWORD    mflags;
  1552.     UWORD    locount, hicount;
  1553.     UWORD    ev_which, bbutton, kstate, kreturn, breturn;
  1554.  
  1555.     set_clip(TRUE, &work_area);
  1556.     pxy[0] = x;
  1557.     pxy[1] = y;
  1558.  
  1559.     vsl_color(vdi_handle,dodle_shade);
  1560.     vswr_mode(vdi_handle,MD_REPLACE);
  1561.     vsl_type (vdi_handle,IP_1PATT);
  1562.  
  1563.     if (dodle_shade == pen_ink)
  1564.     {
  1565.         vsl_width (vdi_handle,dodle_pen);
  1566.         vsl_ends(vdi_handle, 2, 2);
  1567.         hicount = 0;
  1568.         locount = 125;
  1569.         mflags = MU_BUTTON | MU_M1 | MU_TIMER;
  1570.         graf_mouse(M_OFF, 0x0L);
  1571.     }
  1572.     else
  1573.     {
  1574.         vsf_interior(vdi_handle, 1);
  1575.         vsf_color(vdi_handle, bkgr_color);
  1576.         mflags = MU_BUTTON | MU_M1;
  1577.     }
  1578.  
  1579.     done = FALSE;
  1580.     while (!done)
  1581.     {
  1582.         ev_which = evnt_multi(mflags,
  1583.         0x01, 0x01, 0x00, 
  1584.         1, pxy[0], pxy[1], 1, 1,
  1585.         0, 0, 0, 0, 0,
  1586.         ad_rmsg, locount, hicount,
  1587.         &pxy[2], &pxy[3], &bbutton, &kstate,
  1588.         &kreturn, &breturn);
  1589.  
  1590.         if (ev_which & MU_BUTTON)
  1591.         {
  1592.             if (!(mflags & MU_TIMER))
  1593.                 graf_mouse(M_OFF, 0x0L);
  1594.             if (dodle_shade == pen_ink)
  1595.                 v_pline(vdi_handle, 2, (WORD *) pxy);
  1596.             else
  1597.                 eraser((WORD) pxy[2], (WORD) pxy[3]);
  1598.             graf_mouse(M_ON, 0x0L);
  1599.             done = TRUE;
  1600.         }
  1601.         else
  1602.             if (ev_which & MU_TIMER)
  1603.             {
  1604.                 graf_mouse(M_ON, 0x0L);
  1605.                 mflags = MU_BUTTON | MU_M1;
  1606.             }
  1607.             else
  1608.             {
  1609.                 if (!(mflags & MU_TIMER))
  1610.                     graf_mouse(M_OFF, 0x0L);
  1611.                 if (dodle_shade == pen_ink)
  1612.                 {
  1613.                     v_pline(vdi_handle, 2, (WORD *) pxy);
  1614.                     mflags = MU_BUTTON | MU_M1 | MU_TIMER;
  1615.                 }
  1616.                 else
  1617.                 {
  1618.                     eraser((WORD) pxy[2], (WORD) pxy[3]);
  1619.                     graf_mouse(M_ON,0x0L);
  1620.                 }
  1621.                 pxy[0] = pxy[2];
  1622.                 pxy[1] = pxy[3];
  1623.             }
  1624.     } /* while */
  1625.  
  1626.     set_clip(FALSE, &work_area);
  1627.     save_work();
  1628. }
  1629.  
  1630.  
  1631. /*------------------------------*/
  1632. /*    eraser            */
  1633. /*------------------------------*/
  1634. VOID
  1635. eraser(x, y)            /* erase rectangle of eraser size at x,y */
  1636. WORD    x, y;
  1637. {
  1638.     WORD    erase_xy[4];
  1639.  
  1640.     if (dodle_pen == PEN_FINE)
  1641.     {
  1642.         erase_xy[0] = x - 2;
  1643.         erase_xy[1] = y - 1;
  1644.         erase_xy[2] = x + 2;
  1645.         erase_xy[3] = y + 1;
  1646.     }
  1647.     else
  1648.         if (dodle_pen == PEN_MEDIUM)
  1649.         {
  1650.             erase_xy[0] = x - 4;
  1651.             erase_xy[1] = y - 2;
  1652.             erase_xy[2] = x + 4;
  1653.             erase_xy[3] = y + 2;
  1654.         }
  1655.         else
  1656.         {
  1657.             erase_xy[0] = x - 6;
  1658.             erase_xy[1] = y - 3;
  1659.             erase_xy[2] = x + 6;
  1660.             erase_xy[3] = y + 3;
  1661.         }
  1662.     vr_recfl(vdi_handle, erase_xy);
  1663. }
  1664.  
  1665. /*----------------------------------------------*/
  1666. /*    do_fill        HK 6/30/85        */
  1667. /*----------------------------------------------*/
  1668. WORD
  1669. do_fill(x, y)
  1670. WORD x, y;
  1671. {
  1672.     WORD    index;
  1673.  
  1674.     vsf_interior(vdi_handle, IP_1PATT);
  1675.     vsf_color(vdi_handle, pen_ink);
  1676.     index = -1;    /* for complete fill */
  1677.  
  1678.     graf_mouse(M_OFF, 0x0L);
  1679.     v_contourfill(vdi_handle, x, y, index);
  1680.     save_work();
  1681.     graf_mouse(M_ON, 0x0L);
  1682.     
  1683.     if (first_fill == TRUE)
  1684.     {
  1685.         bkgr_color = pen_ink;
  1686.         first_fill = FALSE;
  1687.     }
  1688. }
  1689.  
  1690. /*
  1691.  
  1692. Page*/
  1693. /************************************************************************/
  1694. /************************************************************************/
  1695. /****                                     ****/
  1696. /****                Doodle Event Handler             ****/
  1697. /****                                     ****/
  1698. /************************************************************************/
  1699. /************************************************************************/
  1700.  
  1701. /*------------------------------*/
  1702. /*    dodle            */
  1703. /*------------------------------*/
  1704. dodle()
  1705. {
  1706.     BOOLEAN    done;
  1707.  
  1708.     key_input = FALSE;
  1709.     done = FALSE;
  1710.     while( !done )        /* loop handling user input until done    */
  1711.     {
  1712.         ev_which = evnt_multi(MU_BUTTON | MU_MESAG | MU_M1 | MU_KEYBD,
  1713.         0x02, 0x01, 0x01, 
  1714.         m_out,
  1715.         (UWORD) work_area.g_x, (UWORD) work_area.g_y,
  1716.         (UWORD) work_area.g_w, (UWORD) work_area.g_h,
  1717.         0, 0, 0, 0, 0,
  1718.         ad_rmsg, 0, 0, 
  1719.         &mousex, &mousey, &bstate, &kstate,
  1720.         &kreturn, &bclicks);
  1721.  
  1722.         wind_update(BEG_UPDATE);
  1723.  
  1724.         if (!(ev_which & MU_KEYBD))
  1725.         {
  1726.             if (key_input)
  1727.             {
  1728. /*                curs_off();    */
  1729.                 key_input = FALSE;
  1730.                 save_work();
  1731.             }
  1732.         }
  1733.  
  1734.         if (ev_which & MU_BUTTON)
  1735.             done = hndl_button();
  1736.  
  1737.         if (ev_which & MU_M1)
  1738.             done = hdl_mouse();
  1739.  
  1740.         if (ev_which & MU_MESAG)
  1741.             done = hdl_message();
  1742.  
  1743.         if (ev_which & MU_KEYBD)
  1744.             done = hndl_keyboard();
  1745.  
  1746.         wind_update(END_UPDATE);
  1747.     }
  1748. }
  1749. /*
  1750.  
  1751. Page*/
  1752. /************************************************************************/
  1753. /************************************************************************/
  1754. /****                                     ****/
  1755. /****                Termination                     ****/
  1756. /****                                     ****/
  1757. /************************************************************************/
  1758. /************************************************************************/
  1759.  
  1760.  
  1761. /*------------------------------*/
  1762. /*    dodle_term        */
  1763. /*------------------------------*/
  1764. dodle_term(term_type)
  1765. WORD    term_type;
  1766. {
  1767.     switch (term_type)    /* NOTE: all cases fall through        */
  1768.     {
  1769.         case (0 /* normal termination */):
  1770.             do_close(dodle_whndl, gl_wfull/2, gl_hfull/2);
  1771.             wind_delete(dodle_whndl);
  1772.         case (3):
  1773.             menu_bar(0x0L, FALSE);
  1774.             Mfree(undo_mfdb.mp);
  1775.         case (2):
  1776.             v_clsvwk( vdi_handle );
  1777.         case (1):
  1778.             appl_exit();
  1779.         case (4):
  1780.             break;
  1781.     }
  1782. }
  1783.  
  1784. /*
  1785.  
  1786. Page*/
  1787. /************************************************************************/
  1788. /************************************************************************/
  1789. /****                                     ****/
  1790. /****                Initialization                 ****/
  1791. /****                                     ****/
  1792. /************************************************************************/
  1793. /************************************************************************/
  1794.  
  1795.  
  1796. /*------------------------------*/
  1797. /*    dodle_init        */
  1798. /*------------------------------*/
  1799. WORD
  1800. dodle_init()
  1801. {
  1802.     WORD    work_in[11];
  1803.     WORD    i;
  1804.     WORD    me_creturn;
  1805.     gl_apid = appl_init();            /* initialize libraries    */
  1806.     if (gl_apid == -1)
  1807.         return(4);
  1808.     wind_update(BEG_UPDATE);
  1809.     graf_mouse(HOURGLASS, 0x0L);
  1810.     if (!rsrc_load( ADDR("DOODLE.RSC") ))
  1811.     {
  1812.         graf_mouse(ARROW, 0x0L);
  1813.         form_alert(1,
  1814.         ADDR("[3][Fatal Error !|DOODLE.RSC|File Not Found][ Abort ]"));
  1815.         return(1);
  1816.     }
  1817.     /* open virtual workstation */
  1818.     /* allocate undo buffer    */
  1819.     for (i=0; i<10; i++)
  1820.     {
  1821.         work_in[i]=1;
  1822.     }
  1823.     work_in[10]=2;
  1824.  
  1825.     gem_handle = graf_handle(&gl_wchar,&gl_hchar,&gl_wbox,&gl_hbox);
  1826.     vdi_handle = gem_handle;
  1827.     v_opnvwk(work_in,&vdi_handle,work_out);
  1828.  
  1829.     if (vdi_handle == 0)
  1830.         return(1);
  1831.  
  1832.     scrn_width = work_out[0] + 1;
  1833.     scrn_height = work_out[1] + 1;
  1834.     scrn_xsize = work_out[3];
  1835.     scrn_ysize = work_out[4];
  1836.  
  1837.     char_fine = work_out[46];
  1838.     char_medium = work_out[48];
  1839.     char_broad = char_medium * 2;
  1840.  
  1841.     vq_extnd(vdi_handle, 1, work_out);
  1842.     scrn_planes = work_out[4];
  1843.  
  1844.     undo_mfdb.fwp = scrn_width;
  1845.     undo_mfdb.fww = undo_mfdb.fwp>>4;
  1846.     undo_mfdb.fh = scrn_height;
  1847.     undo_mfdb.np = scrn_planes;
  1848.     undo_mfdb.ff = 0;
  1849.  
  1850.     buff_size = (LONG)(undo_mfdb.fwp>>3) *
  1851.         (LONG)undo_mfdb.fh *
  1852.         (LONG)undo_mfdb.np;
  1853.     buff_location =
  1854.         undo_mfdb.mp  = Malloc(buff_size);
  1855.     if (undo_mfdb.mp == 0)
  1856.         return(2);
  1857.     scrn_area.g_x = 0;
  1858.     scrn_area.g_y = 0;
  1859.     scrn_area.g_w = scrn_width;
  1860.     scrn_area.g_h = scrn_height;
  1861.     scrn_mfdb.mp = 0x0L;
  1862.  
  1863.     rc_copy(&scrn_area, &undo_area);
  1864.     rast_op(0, &undo_area, &scrn_mfdb, &undo_area, &undo_mfdb);
  1865.  
  1866.     ad_rmsg = ADDR((BYTE *) &gl_rmsg[0]);
  1867.  
  1868.     wind_get(DESK, WF_WORKXYWH, &gl_xfull, &gl_yfull, &gl_wfull, &gl_hfull);
  1869.  
  1870.     /* initialize menu    */
  1871.     rsrc_gaddr(R_TREE, DOODMENU, &gl_menu);
  1872.     do_clnormal();
  1873.     me_creturn = menu_icheck (gl_menu, COLOR1, SELECTED);
  1874.  
  1875.     /* show menu        */
  1876.     menu_bar(gl_menu, TRUE);    
  1877.  
  1878.     dodle_whndl = wind_create(0x0fef, gl_xfull - 1, gl_yfull,
  1879.     gl_wfull, gl_hfull);
  1880.     if (dodle_whndl == -1)
  1881.     {
  1882.         form_alert(1, string_addr(DOODNWDW));
  1883.         return(3);
  1884.     }
  1885.  
  1886.     graf_mouse(HOURGLASS, 0x0L);
  1887.     wind_set(dodle_whndl, WF_NAME,
  1888.     " Dr. Doodle Window ", 0, 0);
  1889.     gl_xfull = align_x(gl_xfull);
  1890.     do_open(dodle_whndl, gl_wfull/2, gl_hfull/2, align_x(gl_xfull),
  1891.         gl_yfull, gl_wfull, gl_hfull);
  1892.     wind_get(dodle_whndl, WF_WORKXYWH,
  1893.     &work_area.g_x, &work_area.g_y,
  1894.     &work_area.g_w, &work_area.g_h);
  1895.  
  1896.     set_work(TRUE);
  1897.     rc_copy (&undo_area, &save_area);
  1898.  
  1899.     graf_mouse(ARROW,0x0L);
  1900.     wind_update(END_UPDATE);
  1901.     return(0);
  1902. }
  1903. /*
  1904.  
  1905. Page*/
  1906. /************************************************************************/
  1907. /************************************************************************/
  1908. /****                                     ****/
  1909. /****                Main Program                 ****/
  1910. /****                                     ****/
  1911. /************************************************************************/
  1912. /************************************************************************/
  1913.  
  1914.  
  1915. /*------------------------------*/
  1916. /*    main()            */
  1917. /*------------------------------*/
  1918. main()
  1919. {
  1920.     WORD    term_type;
  1921.  
  1922.     if (!(term_type = dodle_init()))
  1923.         dodle();
  1924.     dodle_term(term_type);
  1925. }
  1926.  
  1927. /*
  1928. * umul_div() 
  1929. */
  1930.  
  1931. int umul_div(m1, m2, d1)
  1932. unsigned int m1;
  1933. unsigned int m2;
  1934. unsigned int d1;
  1935. {
  1936.     unsigned int x;
  1937.  
  1938.     x = m2;
  1939.     x = x << 1;
  1940.     x *= m1;
  1941.     x /= d1;
  1942.     x += 1;
  1943.     x = x >> 1;
  1944.  
  1945.     return(x);
  1946. }
  1947.