home *** CD-ROM | disk | FTP | other *** search
/ GRIPS 2: Government Rast…rocessing Software & Data / GRIPS_2.cdr / dos / ncsa_tel / contribu / byu_tel2.hqx / tek / rgmac.c < prev    next >
Text File  |  1989-11-10  |  8KB  |  512 lines
  1. #ifdef lint
  2. static char *SCCSid = "%W%    (NCSA)    %G%";
  3. #endif
  4.  
  5. /*
  6.  
  7. rgmac.c by Gaige B. Paulsen
  8.   spawned from rgp.c by Aaron Contorer for NCSA
  9. Copyright 1987, board of trustees, University of Illinois
  10.  
  11. Routines for Macintosh Window output.  
  12.  
  13. */
  14.  
  15.  
  16. /* 
  17.  *    Include files 
  18.  */
  19.  
  20. #include <stdio.h>
  21.  
  22. #include <Controls.h>
  23. #include <Events.h>
  24. #include <OSutils.h>
  25. #include <Packages.h>
  26. #include <Quickdraw.h>
  27. #include <Windows.h>
  28.  
  29. #ifdef MPW
  30. #include "::main:mpw.h"
  31. #endif MPW
  32.  
  33. #define TRUE 1
  34. #define FALSE 0
  35. #define MAXWIND 20
  36. #define WINXMAX 4095
  37. #define WINYMAX 3139
  38. #define INXMAX 4096
  39. #define INYMAX 4096
  40.  
  41. #define SPLASH_SQUARED    4
  42.  
  43. char *malloc();
  44.  
  45. /*
  46.  * display structure....
  47.  */
  48.  
  49. struct RGMwindows {
  50. GrafPtr
  51.     wind;
  52. int
  53.     xorigin,
  54.     yorigin,
  55.     xscale,
  56.     yscale,
  57.     vg,
  58.     vs,
  59.     inuse,
  60.     ingin;
  61. unsigned char
  62.     *name;
  63. int
  64.     width,
  65.     height;
  66. ControlHandle
  67.     zoom,
  68.     vert,
  69.     horiz;
  70.     } *RGMwind[ MAXWIND ];    /* BYU mod - changed from an array of structure to an array of pointers */
  71.  
  72. long RGMlastclick;
  73.  
  74. int RGMcolor[]=
  75.     { 30,            /* black */
  76.       33,            /* white */
  77.       205,            /* red */
  78.       341,            /* green */
  79.       409,            /* blue */
  80.       273,            /* cyan */
  81.       137,            /* magenta */
  82.       69            /* yellow */
  83.       };
  84.  
  85.  
  86. char *macname = "Macintosh Windows";
  87.  
  88.  
  89. RGMgin(w)
  90. {
  91.     if (RGsetwind(w)) return(-1);
  92.  
  93.     setgraphcurs();
  94.     RGMwind[w]->ingin=1;
  95. }
  96.  
  97. RGMoutfunc(f)
  98. int (*f)();
  99. {}
  100.  
  101.  
  102. RGMpencolor(w, color)
  103. {
  104.     if (RGsetwind(w) ) return(-1);
  105.  
  106.     ForeColor((long) RGMcolor[color] );
  107. }
  108.  
  109. RGMclrscr(w)
  110. {
  111.     if (RGsetwind(w) ) return(-1);
  112.  
  113.     ForeColor((long) RGMcolor[0] );
  114.     EraseRect( &RGMwind[w]->wind->portRect);
  115. }
  116.  
  117. RGMclose(w)
  118. {
  119.     if (RGsetwind(w) ) return(-1);
  120.  
  121.     DisposeWindow(RGMwind[w]->wind);
  122.     RGMwind[w]->inuse  = FALSE;
  123.  
  124. }
  125.  
  126. RGMpoint(w,x,y)
  127. {
  128.     if (RGsetwind(w) ) return(-1);
  129.  
  130.     MoveTo(x,y);
  131.     LineTo(x,y);
  132. } 
  133.  
  134. RGMdrawline(w,x0,y0,x1,y1)
  135. int w,x0,y0,x1,y1;
  136. {
  137.     if (RGsetwind(w) ) return(-1);
  138.     x0 = (int) ((long) (x0 * RGMwind[w]->width) / INXMAX);
  139.     y0 = RGMwind[w]->height - (int) ((long) (y0 * RGMwind[w]->height) / INYMAX);
  140.     x1 = (int) ((long) (x1 * RGMwind[w]->width)/INXMAX);
  141.     y1 = RGMwind[w]->height - (int) ((long) (y1 * RGMwind[w]->height) / INYMAX);
  142.  
  143.     MoveTo(x0,y0);
  144.     LineTo(x1,y1);
  145. }
  146.  
  147. RGMpagedone(w)
  148. {
  149. }
  150.  
  151. RGMdataline(w,data,count)
  152. {}
  153.  
  154.  
  155. RGMcharmode(w,rotation,size)
  156. {}
  157.  
  158. RGMshowcur()
  159. {}
  160.  
  161. RGMlockcur()
  162. {}
  163.  
  164. RGMhidecur()
  165. {}
  166.  
  167. RGMbell(w)
  168. {}
  169.  
  170. RGMuncover(w)
  171. {}
  172.  
  173. char *RGMdevname() {
  174.     return(macname);
  175. }
  176.  
  177. RGMalloc()            /* BYU mod - allocate this structure to save global space */
  178. {                    /* BYU mod */
  179.     int i;                            /* BYU mod */
  180.     for(i=0; i<MAXWIND; i++)         /* BYU mod */
  181.         RGMwind[i] = (struct RGMwindows *) malloc(sizeof(struct RGMwindows));    /* BYU mod */
  182. }                    /* BYU mod */
  183.  
  184. RGMinit()
  185. {
  186.     int i;
  187.     for(i=0; i<20; i++) RGMwind[i]->inuse=0;
  188. }
  189.  
  190. RGMinfo(w,v,a,b,c,d)
  191. int w,a,b,c,d,v;
  192. {
  193.  
  194.     RGMwind[w]->vg=v;
  195. }
  196.  
  197. RGMgmode()
  198. {}
  199.  
  200. RGMtmode()
  201. {}
  202.  
  203. RGMnewwin()
  204. {
  205.     int i=0;
  206.  
  207.     while ( (i< MAXWIND) && (RGMwind[i]->inuse) ) i++;
  208.  
  209.     if (i>= MAXWIND) return(-1);
  210.  
  211.     RGMwind[i]->wind = GetNewWindow(256,(Ptr) 0L,(Ptr) -1L);
  212.  
  213.     if (RGMwind[i]->wind==0L) {
  214.         return(-1);
  215.         }
  216.  
  217.     RGMwind[i]->xorigin= 0;
  218.     RGMwind[i]->yorigin= 0;
  219.     RGMwind[i]->xscale = WINXMAX;
  220.     RGMwind[i]->yscale = WINYMAX;
  221.     RGMwind[i]->width  = 400;
  222.     RGMwind[i]->height = 300;
  223.     RGMwind[i]->inuse  = TRUE;
  224.     RGMwind[i]->ingin  = 0;
  225.  
  226.     ValidRect( &RGMwind[i]->wind->portRect);
  227.  
  228.     return(i);
  229. }
  230.  
  231.  
  232. RGattach(vg,virt,name)
  233. int vg,virt;
  234. char *name;
  235. {
  236.     int i,dnum;
  237.     long time;
  238.     char ts[50];
  239.  
  240.     if ( (dnum=RGfindbyVG( vg) ) <0) return(-1);
  241.  
  242.     RGMwind[dnum]->vs=virt;
  243.     RGMwind[dnum]->name=(char *)malloc(256);
  244.  
  245.     if (RGMwind[dnum]->name==0L) return(-2);
  246.  
  247.     RGMwind[dnum]->name[0]=165;
  248.     strncpy( &RGMwind[dnum]->name[1], name,255);
  249.  
  250.     GetDateTime(&time);
  251.     IUTimeString(time,FALSE, ts);                /* Put time in the temp string */
  252.     
  253.     strncat( RGMwind[dnum]->name, "  ",255);            /* Space, please */
  254.     strncat( RGMwind[dnum]->name, ts,255);            /* Place the time string at the end */
  255.  
  256.     SetWTitle(RGMwind[dnum]->wind,RGMwind[dnum]->name);
  257.     return(0);
  258. }
  259.  
  260. RGdetach(dnum)
  261. int dnum;
  262. {
  263.     int i;
  264.     if (dnum<0 || dnum>=MAXWIND) return(-1);
  265.  
  266.     strncpy( RGMwind[dnum]->name, &RGMwind[dnum]->name[1], 255);
  267.  
  268.     SetWTitle(RGMwind[dnum]->wind,RGMwind[dnum]->name);
  269.  
  270.     RGMwind[dnum]->vs=-1;
  271. }
  272.  
  273. RGsetwind(dnum)
  274. int dnum;
  275. {
  276.  
  277.     if (dnum<0 || dnum>=MAXWIND) return(-1);
  278.  
  279.     if (!RGMwind[dnum]->inuse) return(-1);
  280.  
  281.     SetPort( RGMwind[dnum]->wind);
  282.     return(0);
  283. }
  284.  
  285. RGupdate(wind)
  286. GrafPtr wind;
  287. {
  288.     int i=0,done;
  289.  
  290.     if ( (i=RGfindbywind(wind)) <0)
  291.         return(-1);
  292.  
  293.     SetPort(wind);
  294.     BeginUpdate(wind);
  295.  
  296.     VGstopred( RGMwind[i]->vg);
  297.     VGpage( RGMwind[i]->vg);
  298.     done = VGpred(  RGMwind[i]->vg,  RGMwind[i]->vg);
  299.     EndUpdate(wind);
  300.     if (!done)
  301.         netputevent(1,128,RGMwind[i]->vg);
  302.     return(done);
  303. }
  304.  
  305. RGsupdate(i)
  306. {
  307.     int rg;
  308.     rg=RGfindbyVG( i);
  309.  
  310.     if (rg<0) return(0);
  311.     SetPort( RGMwind[rg]->wind);
  312.     if (!VGpred(  RGMwind[rg]->vg,  RGMwind[rg]->vg) ) {
  313.         netputevent( 1, 128, i);
  314.         }
  315.     else return(1);
  316.     return(0);
  317. }
  318.  
  319. RGgetVG(wind)
  320. GrafPtr wind;
  321. {
  322.     int i;
  323.  
  324.     i=RGfindbywind(wind);
  325.  
  326.     return( RGMwind[i]->vg);
  327. }
  328.  
  329. RGgetdnum(wind)
  330. GrafPtr wind;
  331. {
  332.     return(RGfindbywind(wind) );
  333. }
  334.  
  335. RGfindbyVG( vg)
  336. int vg;
  337. {
  338.     int i=0;
  339.  
  340.     while ((i<MAXWIND) && ((!RGMwind[i]->inuse) || (RGMwind[i]->vg!=vg)))
  341.         i++;
  342.     if (i>=MAXWIND) return(-1);
  343.     return(i);
  344. }
  345.  
  346. RGgetVS( dnum)
  347. int dnum;
  348. {
  349.     return( RGMwind[dnum]->vs);
  350. }
  351.  
  352.  
  353. RGfindbywind(wind)
  354. GrafPtr wind;
  355. {
  356.     int i=0;
  357.  
  358.     while ((i<MAXWIND) && ((!RGMwind[i]->inuse) || (RGMwind[i]->wind!=wind)))
  359.         i++;
  360.     if (i>=MAXWIND) return(-1);
  361.     return(i);
  362. }
  363.  
  364. inSplash( p1, p2)
  365. Point *p1,*p2;
  366. {
  367.     if (p1->h-p2->h>3 || p2->h-p1->h >3)
  368.         return(0);
  369.     if (p1->v-p2->v>3 || p2->v-p1->v >3)
  370.         return(0);
  371.  
  372.     return(1);
  373. }
  374.  
  375. RGmousedown( wind, wherein, pnum)
  376. GrafPtr wind;
  377. Point *wherein;
  378. {
  379.     long lx,ly;
  380.     char thispaceforent[6];
  381.     int i;
  382.     Point where;
  383.  
  384.     where = *wherein;
  385.     if ( (i=RGfindbywind(wind)) <0)
  386.         return(-1);
  387.  
  388.     if (!RGMwind[i]->ingin) {
  389.         Point anchor, current,last;
  390. #ifndef MPW
  391.         long TickCount();
  392. #endif MPW
  393.         long GetDblTime(),tc;
  394.         int x0,y0,x1,y1;
  395.         Rect rect;
  396.         char dum[50];
  397.     
  398.         SetPort(wind);
  399.     
  400.         last  = where;
  401.         current = where;
  402.         anchor = where;
  403.     
  404.         PenPat(qd.gray);    
  405.         PenMode( patXor);
  406.     
  407.         SetRect( &rect, 0,0,0,0);
  408.     
  409.         while (StillDown()) {
  410.             GetMouse( ¤t);
  411.             if ( inSplash( ¤t, &anchor) ) continue;
  412.             tc=TickCount();
  413.             while(TickCount()==tc);
  414.             VidSync();
  415.             FrameRect(&rect);
  416.     
  417.             if (anchor.v < current.v) {
  418.                 rect.top=anchor.v;
  419.                 rect.bottom=current.v;
  420.                 }
  421.             else {
  422.                 rect.top=current.v;
  423.                 rect.bottom=anchor.v;
  424.                 }
  425.     
  426.             if (anchor.h < current.h) {
  427.                 rect.left=anchor.h;
  428.                 rect.right=current.h;
  429.                 }
  430.             else {
  431.                 rect.right=anchor.h;
  432.                 rect.left =current.h;
  433.                 }
  434.     
  435.             FrameRect(&rect);
  436.             last=current;
  437.             }
  438.     
  439.         FrameRect(&rect);
  440.  
  441.         PenPat(qd.black);    
  442.         PenMode( patCopy);
  443.  
  444.         if ( !inSplash( &anchor, ¤t)) {
  445.             x0 = (int) ((long) rect.left * RGMwind[i]->xscale / RGMwind[i]->width );
  446.             y0 = (int) RGMwind[i]->yscale -
  447.                  ((long) rect.top * RGMwind[i]->yscale / RGMwind[i]->height);
  448.             x1 = (int) ((long) rect.right * RGMwind[i]->xscale / RGMwind[i]->width);
  449.             y1 = (int) RGMwind[i]->yscale -
  450.                  ((long) rect.bottom * RGMwind[i]->yscale / RGMwind[i]->height);
  451.  
  452.             VGzoom( i,
  453.                     x0 +RGMwind[i]->xorigin,
  454.                     y1 +RGMwind[i]->yorigin,
  455.                     x1 +RGMwind[i]->xorigin,
  456.                     y0 +RGMwind[i]->yorigin);
  457.  
  458.             VGpage( RGMwind[i]->vg);
  459.  
  460.             RGMwind[i]->xscale= x1-x0;
  461.             RGMwind[i]->yscale= y0-y1;
  462.             RGMwind[i]->xorigin= x0+ RGMwind[i]->xorigin;
  463.             RGMwind[i]->yorigin= y1+ RGMwind[i]->yorigin;
  464.  
  465.             sprintf(dum,"VGzoom [%d,%d] -[%d,%d]", x0,y1,x1,y0);
  466.             putln(dum);
  467.             while( !VGpred(  RGMwind[i]->vg,  RGMwind[i]->vg) )
  468.                 Stask();
  469.             RGMlastclick=0L;
  470.             }
  471.         else {
  472.             if (RGMlastclick && ((RGMlastclick +GetDblTime() ) > TickCount()) ) {
  473.                 RGMwind[i]->xscale = WINXMAX;
  474.                 RGMwind[i]->yscale = WINYMAX;
  475.                 RGMwind[i]->xorigin= 0;
  476.                 RGMwind[i]->yorigin= 0;
  477.  
  478.                 VGzoom(i,0,0,WINXMAX,WINYMAX);
  479.                 VGpage( RGMwind[i]->vg);
  480.                 while( !VGpred(  RGMwind[i]->vg,  RGMwind[i]->vg) )
  481.                     Stask();
  482.                 RGMlastclick=0L;
  483.                 }
  484.             else RGMlastclick=TickCount();
  485.             }
  486.         return(0);
  487.     
  488.     }
  489.  
  490.  
  491.     lx= (RGMwind[i]->xscale * where.h) / ((long)RGMwind[i]->width);
  492.     ly= RGMwind[i]->yscale - ((RGMwind[i]->yscale * where.v) / ((long)RGMwind[i]->height));
  493.  
  494.     VGgindata( RGMwind[i]->vg, (int) lx, (int) ly, ' ', thispaceforent);
  495.  
  496.     RSsendstring( RGMwind[i]->vs, thispaceforent, 5);
  497.  
  498.     RGMwind[i]->ingin=0;
  499.     unsetgraphcurs();
  500.     RGMlastclick=TickCount();
  501. }
  502.  
  503. long *Ticks= (long *)0x16a;
  504.  
  505. VidSync()
  506. {
  507.     long a;
  508.  
  509.     a= *Ticks;
  510.     while (a ==*Ticks);
  511. }
  512.