home *** CD-ROM | disk | FTP | other *** search
/ Collection of Hack-Phreak Scene Programs / cleanhpvac.zip / cleanhpvac / TIERRA40.ZIP / ALMOND / OVERVIEW / OV_GFX.C < prev    next >
C/C++ Source or Header  |  1992-07-06  |  7KB  |  400 lines
  1. /*
  2. * ov_gfx.c
  3. *
  4. * Copyright (c) 1991, 1992 by Marc W. Cygnus and Virtual Life
  5. * All Rights Reserved.
  6. *
  7. */
  8.  
  9. #include <stdio.h>
  10.  
  11. #include <sys/param.h>        /* stuff like hostname length */
  12.  
  13. #include <X11/Intrinsic.h>
  14. #include <X11/StringDefs.h>
  15. #include <X11/Shell.h>
  16.  
  17. #include "portlayr.h"
  18.  
  19. #include "overview.h"
  20.  
  21. #include "debug.h"
  22.  
  23.  
  24. /*** prototypes ********************************************************/
  25.  
  26. void        re_add_to_sizemap();
  27. Pixel        pop_colour_assignment P_(( void ));
  28. void        push_colour_assignment P_(( Pixel colour ));
  29. void        depict_colour_swap P_(( u_long len1, u_long c1, u_long len2,
  30.           u_long c2 ));
  31. u_long        add_org_to_sizemap P_(( OrgMap *om ));
  32. void        del_org_from_sizemap P_(( OrgMap *om ));
  33.  
  34. extern OrgMap    *del_org_from_orgmap();
  35.  
  36.  
  37. /*** application specific **********************************************/
  38.  
  39.  
  40.  
  41.  
  42.  
  43. /* DONE
  44. * initialise_ov_statistics()
  45. *
  46. */
  47.  
  48. void
  49. initialise_ov_statistics()
  50. {
  51.   int        i;
  52.  
  53.   GS.sizemaproot = (Sizemap *)NULL;
  54.   for ( i = 0; i < NUM_SPECCOLOURS; i++ )
  55.     GS.colours[i] = GS.X.cspectrum[ NUM_SPECCOLOURS - 1 - i ];
  56.   GS.numcolours = NUM_SPECCOLOURS;
  57.  
  58. }
  59.  
  60.  
  61. /* DONE
  62. * record_organism_birth()
  63. *
  64. */
  65.  
  66. void
  67. record_organism_birth( start, length )
  68.   u_long    start;
  69.   u_long    length;
  70. {
  71.   OrgMap    *om;
  72.   static int    addcounter = 0;
  73.  
  74. DEBUG(DBGD)
  75.     fprintf( stderr, "B: %lu:%lu\n", start, length ); 
  76. ENDDB()
  77.  
  78.   if (( om = (OrgMap *)ALMalloc( sizeof( OrgMap ) )) == (OrgMap *)NULL ) {
  79.     fprintf( stderr, "record_organism_birth: can't malloc orgmap\n" );
  80.     exit( 1 );
  81.   }
  82.   om->start = start;
  83.   om->len = length;
  84.   om->colour = add_org_to_sizemap( om );
  85.  
  86.   add_org_to_orgmap( om );
  87.   add_org_to_memmap( om, True );
  88.  
  89.   if ( ++addcounter == ST_UpdateRate ) {
  90.     addcounter = 0;
  91.     draw_stat_keys( 0, GS.winwidth, 0, GS.statheight, False );
  92.   }
  93.  
  94. }
  95.  
  96.  
  97. /* DONE
  98. * add_org_to_sizemap()
  99. *
  100. */
  101.  
  102. u_long
  103. add_org_to_sizemap( om )
  104.   OrgMap    *om;
  105. {
  106.   Sizemap    **node, *sptr, *sprev, *movenode;
  107.  
  108.   node = &(GS.sizemaproot);
  109.   sprev = (Sizemap *)NULL;
  110.  
  111.   while ( *node != (Sizemap *)NULL && (*node)->len != om->len ) {
  112.     sprev = *node;
  113.     node = &( (*node)->next );
  114.   }
  115.  
  116.   if ( *node == (Sizemap *)NULL ) {
  117.  
  118.     if (( sptr = (Sizemap *)ALMalloc( sizeof( Sizemap ) )
  119.     ) == (Sizemap *)NULL ) {
  120.       fprintf( stderr, "error malloc-ing Sizemap node!\n" );
  121.       exit( 1 );
  122.     }
  123.     sptr->len = om->len;
  124.     sptr->pop = 1;
  125.     sptr->colour = pop_colour_assignment();
  126.     sptr->next = (Sizemap *)NULL;
  127.     *node = sptr;
  128.  
  129.   } else {
  130.  
  131.     (*node)->pop++;
  132.     if ( sprev != (Sizemap *)NULL && (*node)->pop > sprev->pop ) {
  133.       movenode = *node;
  134.       *node = (*node)->next;
  135.  
  136.       re_add_to_sizemap( &(GS.sizemaproot), movenode );
  137.  
  138.       return movenode->colour;
  139.     }
  140.   }
  141.  
  142.   return (*node)->colour;
  143. }
  144.  
  145.  
  146. /* DONE
  147. * re_add_to_sizemap()
  148. *
  149. */
  150.  
  151. void
  152. re_add_to_sizemap( node, newnode )
  153.   Sizemap    **node;
  154.   Sizemap    *newnode;
  155. {
  156.   Sizemap    *sptr;
  157.   int        count;
  158.  
  159.   count = 0;
  160.   while ( *node != (Sizemap *)NULL && (*node)->pop > newnode->pop ) {
  161.     node = &((*node)->next);
  162.     count++;
  163.   }
  164.   sptr = *node;
  165.   *node = newnode;
  166.   newnode->next = sptr;
  167.  
  168.   if ( newnode->colour != GS.X.cother )
  169.     return;
  170.  
  171.   if ( count >= NUM_SPECCOLOURS )
  172.     newnode->colour = GS.X.cother;
  173.   else {
  174.     while ( *node != (Sizemap *)NULL && count < NUM_SPECCOLOURS ) {
  175.       node = &((*node)->next);
  176.       count++;
  177.     }
  178.     newnode->colour = (*node)->colour;
  179.     (*node)->colour = GS.X.cother;
  180.     depict_colour_swap( newnode->len, newnode->colour, (*node)->len,
  181.                 (*node)->colour );
  182.   }
  183. }
  184.  
  185.  
  186. /* DONE
  187. * record_organism_death()
  188. *
  189. */
  190.  
  191. void
  192. record_organism_death( start, length )
  193.   u_long    start;
  194.   u_long    length;
  195. {
  196.   OrgMap    *om;
  197.   static int    delcounter;
  198.  
  199. DEBUG(DBGD)
  200.   fprintf( stderr, "     D: %lu:%lu\n", start, length );
  201. ENDDB()
  202.  
  203.   om = del_org_from_orgmap( start );
  204.   del_org_from_memmap( om );
  205.   del_org_from_sizemap( om );
  206.  
  207.   if ( ++delcounter == ST_UpdateRate ) {
  208.     delcounter = 0;
  209.     draw_stat_keys( 0, GS.winwidth, 0, GS.statheight, False );
  210.   }
  211.  
  212.   ALFree( (char *)om );
  213. }
  214.  
  215.  
  216. /*
  217. * DONE
  218. * del_org_from_sizemap()
  219. *
  220. */
  221.  
  222. void
  223. del_org_from_sizemap( om )
  224.   OrgMap    *om;
  225. {
  226.   Sizemap    **node, *moveblock, *stmp;
  227.   int        count;
  228.  
  229.   node = &GS.sizemaproot;
  230.  
  231.   count = 0;
  232.   while ( *node != (Sizemap *)NULL && (*node)->len != om->len ) {
  233.     node = &((*node)->next);
  234.     count++;
  235.   }
  236.  
  237.   if ( *node == (Sizemap *)NULL ) {
  238.     fprintf( stderr, "Bogus death: size = %d!\n", om->len );
  239.     return;
  240.   }
  241.  
  242.   (*node)->pop--;
  243.  
  244.   if ( (*node)->pop == 0 ) {
  245.  
  246.     stmp = *node;
  247.     *node = (*node)->next;
  248.  
  249.     if ( count < NUM_SPECCOLOURS ) {
  250.       while ( *node != (Sizemap *)NULL && count < (NUM_SPECCOLOURS - 1) ) {
  251.     node = &((*node)->next);
  252.     count++;
  253.       }
  254.       if ( *node != (Sizemap *)NULL ) {
  255.     (*node)->colour = stmp->colour;
  256.     depict_colour_swap( stmp->len, GS.X.cmemory, (*node)->len,
  257.                 (*node)->colour );
  258.       } else
  259.         push_colour_assignment( stmp->colour );
  260.     } 
  261.     ALFree( (char *)stmp );
  262.  
  263.   } else if ( (*node)->next != (Sizemap *)NULL &&
  264.           (*node)->next->pop > (*node)->pop ) {
  265.  
  266.     moveblock = *node;
  267.     *node = (*node)->next;
  268.     if ( count < NUM_SPECCOLOURS ) {
  269.       while ( *node != (Sizemap *)NULL && count < (NUM_SPECCOLOURS - 1) ) {
  270.     node = &((*node)->next);
  271.     count++;
  272.       }
  273.       if ( *node != (Sizemap *)NULL ) {
  274.     (*node)->colour = moveblock->colour;
  275.     moveblock->colour = GS.X.cother;
  276.     depict_colour_swap( moveblock->len, moveblock->colour, (*node)->len,
  277.                 (*node)->colour );
  278.       }
  279.     }
  280.  
  281.     re_add_to_sizemap( &GS.sizemaproot, moveblock );
  282.  
  283.   }
  284.  
  285. }
  286.  
  287.  
  288. /*** FOR DEBUGGING PURPOSES ONLY ***/
  289.  
  290. /* DONE
  291. * depict_sizemaplist()
  292. *
  293. */
  294.  
  295. void
  296. depict_sizemaplist()
  297. {
  298.   Sizemap    *s;
  299.  
  300.   printf( "Sizemap: " );
  301.   s = GS.sizemaproot;
  302.   while ( s != (Sizemap *)NULL ) {
  303.     printf( "[%d;%d=%d]->", s->len, s->pop, s->colour );
  304.     s = s->next;
  305.   }
  306.   printf( "[NULL]\n" );
  307. }
  308.  
  309. /*** END DEBUG CODE ***/
  310.  
  311.  
  312. /* DONE
  313. * pop_colour_assignment()
  314. *
  315. */
  316.  
  317. Pixel
  318. pop_colour_assignment()
  319. {
  320.   if ( GS.numcolours == 0 )
  321.     return GS.X.cother;
  322.  
  323.   return GS.colours[ --GS.numcolours ];
  324. }
  325.  
  326.  
  327. /* DONE
  328. * push_colour_assignment()
  329. *
  330. */
  331.  
  332. void
  333. push_colour_assignment( colour )
  334.   Pixel        colour;
  335. {
  336.   if ( GS.numcolours == NUM_SPECCOLOURS ) {
  337.     fprintf( stderr, "push_colour_assignment(): stack overflow!\n" );
  338.     return;
  339.   }
  340.   if ( colour != GS.X.cother )
  341.     GS.colours[ GS.numcolours++ ] = colour;
  342. }
  343.  
  344.  
  345. /* DONE
  346. * depict_colour_swap()
  347. *
  348. */
  349.  
  350. void
  351. depict_colour_swap( len1, c1, len2, c2 )
  352.   u_long    len1;
  353.   u_long    c1;
  354.   u_long    len2;
  355.   u_long    c2;
  356. {
  357.   MemMap    *mm;
  358.   int        i;
  359.   int        x1, x2, y1, hhash, introw;
  360.   int        redraw;
  361.  
  362.   redraw = False;
  363.  
  364.   hhash = GS.hashlen + ( GS.memrwidth / 2 );
  365.   introw = ( GS.memrwidth + GS.memrspace );
  366.   y1 = GS.vbd + hhash - introw - GS.memviewport;
  367.  
  368.   XSetLineAttributes( GS.X.d, GS.X.memgc, GS.memrwidth, LineSolid,
  369.               CapButt, JoinMiter );
  370.  
  371.   for ( i = 0; i < GS.memrows; i++ ) {
  372.  
  373.     y1 += introw;
  374.     mm = GS.memmap[i];
  375.  
  376.     for ( mm = GS.memmap[i]; mm != (MemMap *)NULL; mm = mm->next ) {
  377.  
  378.       if ( mm->org->len == len1 ) {
  379.     mm->org->colour = c1;
  380.     redraw = True;
  381.       } else if ( mm->org->len == len2 ) {
  382.     mm->org->colour = c2;
  383.     redraw = True;
  384.       }
  385.  
  386.       if ( redraw == True && y1 - hhash >= 0 && y1 + hhash < GS.mfheight ) {
  387.     redraw = False;
  388.     x1 = GS.lbd + mm->start;
  389.     x2 = x1 + mm->len;
  390.     XSetForeground( GS.X.d, GS.X.memgc, mm->org->colour );
  391.     XDrawLine( GS.X.d, XtWindow( GS.X.memframe ), GS.X.memgc,
  392.            x1, y1, x2, y1);
  393.       }
  394.  
  395.     }
  396.  
  397.   }
  398. }
  399.  
  400.