home *** CD-ROM | disk | FTP | other *** search
/ Collection of Hack-Phreak Scene Programs / cleanhpvac.zip / cleanhpvac / TIERRA40.ZIP / ALMOND / OVERVIEW / OVEXPOSE.C < prev    next >
C/C++ Source or Header  |  1992-07-06  |  14KB  |  589 lines
  1. /*
  2. * ovexpose.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. #include <stdlib.h>
  11. #include <errno.h>
  12.  
  13. #include <X11/Intrinsic.h>
  14.  
  15. #include "portlayr.h"
  16.  
  17. #include "debug.h"
  18.  
  19. #include "overview.h"
  20.  
  21.  
  22.  
  23. extern void        actually_scroll_screen P_(( float where ));
  24.  
  25.  
  26. void        expose_memory P_(( int xlo, int xhi, int ylo, int yhi ));
  27. void        expose_memory_row P_(( int xlo, int xhi, int row ));
  28. void        expose_memaxis_row P_(( int xlo, int xhi, int row,
  29.           int viewport ));
  30. void        handle_client_message P_(( Widget w, XtPointer client_data,
  31.           XClientMessageEvent *event, Boolean *ctd ));
  32. void        expose_stats P_(( int xlo, int xhi, int ylo, int yhi ));
  33. void        draw_stat_keys P_(( int xlo, int xhi, int ylo, int yhi,
  34.           int force ));
  35.  
  36.  
  37.  
  38.  
  39.  
  40. /* DONE
  41. * expose_memframe()
  42. *
  43. * event handler
  44. *
  45. */
  46.  
  47. XtEventHandler
  48. expose_memframe( w, client_data, event, ctd )
  49.   Widget    w;
  50.   XtPointer    client_data;
  51.   XEvent    *event;
  52.   Boolean    *ctd;
  53. {
  54.   XExposeEvent        *ev;
  55.   static int        state = 0;
  56.   static int        xhi, xlo, yhi, ylo;
  57.   register int        valtmp;
  58.  
  59.   if ( event->type == NoExpose )
  60.     return;
  61.  
  62.   if ( event->type == ClientMessage ) {
  63.     handle_client_message( w, client_data, (XClientMessageEvent *)event, ctd );
  64.     return;
  65.   }
  66.  
  67.   if ( event->type != Expose && event->type != GraphicsExpose ) {
  68.     fprintf( stderr, "expose_ovframe() got event %d... ???\n", event->type );
  69.     return;
  70.   }
  71.   ev = (XExposeEvent *)event;
  72.  
  73.   if ( state == 0 ) {
  74.  
  75.     state = 1;
  76.     xlo = ev->x;
  77.     xhi = xlo + ev->width - 1;
  78.     ylo = ev->y;
  79.     yhi = ylo + ev->height - 1;
  80.  
  81.   } else {
  82.  
  83.     if ( ev->x < xlo )
  84.       xlo = ev->x;
  85.     if ( (valtmp = ev->x + ev->width - 1) > xhi )
  86.       xhi = valtmp;
  87.  
  88.     if ( ev->y < ylo )
  89.       ylo = ev->y;
  90.     if ( (valtmp = ev->y + ev->height - 1) > yhi )
  91.       yhi = valtmp;
  92.  
  93.   }
  94.   if ( ev->count == 0 ) {
  95.  
  96.     state = 0;
  97.     expose_memory( xlo, xhi, ylo, yhi );
  98.  
  99.   }
  100. }
  101.  
  102.  
  103. /* DONE
  104. * expose_memory()
  105. *
  106. */
  107.  
  108. void
  109. expose_memory( xlo, xhi, ylo, yhi )
  110.   int        xlo;
  111.   int        xhi;
  112.   int        ylo;
  113.   int        yhi;
  114. {
  115.   register int        row, startrow, endrow, rowsep;
  116.  
  117.   rowsep = GS.memrwidth + GS.memrspace;
  118.  
  119.   startrow = ( ylo + GS.memviewport - GS.vbd ) / rowsep;
  120.   if ( startrow >= GS.memrows )
  121.     return;
  122.  
  123.   endrow = ( yhi + GS.memviewport - GS.vbd ) / rowsep;
  124.   if ( endrow < 0 )
  125.     return;
  126.  
  127.   if ( startrow < 0 )        startrow = 0;
  128.   if ( endrow >= GS.memrows )    endrow = GS.memrows - 1;
  129.  
  130.   for ( row = startrow; row <= endrow; row++ )
  131.     expose_memory_row( xlo, xhi, row );
  132.  
  133.   XFlush( GS.X.d );
  134.  
  135. }
  136.  
  137.  
  138. /* DONE
  139. * expose_memory_row()
  140. *
  141. */
  142.  
  143. void
  144. expose_memory_row( xlo, xhi, row )
  145.   int        xlo;
  146.   int        xhi;
  147.   int        row;
  148. {
  149.   register MemMap    *mm;
  150.   register int        hhash;
  151.   register int        introw;
  152.   register int        oldmmend;
  153.   register int        x1, x2, y1;
  154.   register int        starthash, endhash;
  155.  
  156.   if ( GS.hashlen == 0 )
  157.     XSetLineAttributes( GS.X.d, GS.X.memgc, GS.memrwidth, LineSolid,
  158.             CapButt, JoinMiter );
  159.  
  160.   hhash = GS.hashlen + ( GS.memrwidth / 2 );
  161.   introw = GS.memrwidth + GS.memrspace;
  162.  
  163.   oldmmend = 0;        /* actually end of an organism + 1 */
  164.   y1 = GS.vbd + hhash + introw * row - GS.memviewport;
  165.  
  166.   XSetLineAttributes( GS.X.d, GS.X.memgc, GS.memrwidth , LineSolid, CapButt,
  167.               JoinMiter );
  168.  
  169.   for ( mm = GS.memmap[row]; mm != (MemMap *)NULL; mm = mm->next ) {
  170.  
  171.     starthash = (long)mm->org->start / GS.memrlen;
  172.     endhash = ((long)mm->org->start + (long)mm->org->len - 1) / GS.memrlen;
  173.  
  174.     if ( mm->start - oldmmend > 0 ) {    /* there is blank mem to draw */
  175.  
  176.       x1 = GS.lbd + oldmmend;
  177.       x2 = GS.lbd + mm->start;
  178.  
  179.       if ( ! (xlo > x2 || xhi < x1) ) {
  180.         XSetForeground( GS.X.d, GS.X.memgc, GS.X.cmemory );
  181.     XDrawLine( GS.X.d, XtWindow( GS.X.memframe ), GS.X.memgc,
  182.            x1, y1, x2, y1 );
  183.       }
  184.     }
  185.  
  186.     x1 = GS.lbd + mm->start;
  187.     x2 = x1 + mm->len;
  188.  
  189.     if ( ! (xlo > x2 || xhi < x1 ) ) {
  190.       if ( GS.hashlen > 0 ) {
  191.         XSetForeground( GS.X.d, GS.X.memgc, WhitePixel( GS.X.d, 0 ) );
  192.     XSetLineAttributes( GS.X.d, GS.X.memgc, 1, LineSolid, CapButt,
  193.                 JoinMiter );
  194.     if ( row == starthash )
  195.       XDrawLine( GS.X.d, XtWindow( GS.X.memframe ), GS.X.memgc,
  196.              x1, y1 - hhash, x1, y1 + hhash + 1 );
  197.     if ( row == endhash )
  198.       XDrawLine( GS.X.d, XtWindow( GS.X.memframe ), GS.X.memgc,
  199.              x2-1, y1 - hhash, x2-1, y1 + hhash + 1 );
  200.     XSetLineAttributes( GS.X.d, GS.X.memgc, GS.memrwidth, LineSolid,
  201.                 CapButt, JoinMiter );
  202.       }
  203.       XSetForeground( GS.X.d, GS.X.memgc, mm->org->colour );
  204.       XDrawLine( GS.X.d, XtWindow( GS.X.memframe ), GS.X.memgc,
  205.          x1, y1, x2, y1 );
  206.     }
  207.  
  208.     oldmmend = mm->start + mm->len;
  209.  
  210.   }
  211.  
  212.   if ( GS.memrlen - oldmmend > 0 ) {    /* there is blank mem to draw */
  213.  
  214.     x1 = GS.lbd + oldmmend;
  215.     x2 = (row == GS.memrows - 1) ? GS.lbd + (GS.memsize - 1) % GS.memrlen + 2
  216.                  : GS.lbd + GS.memrlen;
  217.  
  218.     if ( ! (xlo > x2 || xhi < x1) ) {
  219.       XSetForeground( GS.X.d, GS.X.memgc, GS.X.cmemory );
  220.       XDrawLine( GS.X.d, XtWindow( GS.X.memframe ), GS.X.memgc,
  221.          x1, y1, x2, y1 );
  222.     }
  223.   }
  224.  
  225. }
  226.  
  227.  
  228. /* NOTE:  look into the possibility of moving the functionality of
  229. *  expose_etcbox() and expose_memaxis() into expose_memframe() and
  230. *  expose_memory(); expose_etcbox() is identical to expose_memframe(),
  231. *  and expose_memaxis() is 90% identical to expose_memory().
  232. */
  233.  
  234.  
  235. /* DONE
  236. * expose_etcbox()
  237. *
  238. */
  239.  
  240. XtEventHandler
  241. expose_etcbox( w, client_data, event, ctd )
  242.   Widget    w;
  243.   XtPointer    client_data;
  244.   XEvent    *event;
  245.   Boolean    *ctd;
  246. {
  247.   XExposeEvent        *ev;
  248.   static int        state = 0;
  249.   static int        xhi, xlo, yhi, ylo;
  250.   register int        valtmp;
  251.  
  252.   if ( event->type == NoExpose )
  253.     return;
  254.  
  255.   if ( event->type != Expose && event->type != GraphicsExpose ) {
  256.     fprintf( stderr, "expose_etcbox() got event %d... ???\n", event->type );
  257.     return;
  258.   }
  259.   ev = (XExposeEvent *)event;
  260.  
  261.   if ( state == 0 ) {
  262.  
  263.     state = 1;
  264.     xlo = ev->x;
  265.     xhi = xlo + ev->width - 1;
  266.     ylo = ev->y;
  267.     yhi = ylo + ev->height - 1;
  268.  
  269.   } else {
  270.  
  271.     if ( ev->x < xlo )
  272.       xlo = ev->x;
  273.     if ( (valtmp = ev->x + ev->width - 1) > xhi )
  274.       xhi = valtmp;
  275.  
  276.     if ( ev->y < ylo )
  277.       ylo = ev->y;
  278.     if ( (valtmp = ev->y + ev->height - 1) > yhi )
  279.       yhi = valtmp;
  280.  
  281.   }
  282.   if ( ev->count == 0 ) {
  283.     
  284.     state = 0;
  285.     expose_memaxis( xlo, xhi, ylo, yhi, GS.memviewport,
  286.             WhitePixel( GS.X.d, 0 ) );
  287.   }
  288. }
  289.  
  290.  
  291. /* DONE
  292. * expose_memaxis
  293. *
  294. */
  295.  
  296. expose_memaxis( xlo, xhi, ylo, yhi, viewport, colour )
  297.   int        xlo;
  298.   int        xhi;
  299.   int        ylo;
  300.   int        yhi;
  301.   int        viewport;
  302.   Pixel        colour;
  303. {
  304.   register int        row, startrow, endrow, rowsep;
  305.  
  306.   rowsep = GS.memrwidth + GS.memrspace;
  307.  
  308.   startrow = ( ylo + viewport - GS.vbd ) / rowsep;
  309.   if ( startrow >= GS.memrows )
  310.     return;
  311.  
  312.   endrow = ( yhi + viewport - GS.vbd ) / rowsep;
  313.   if ( endrow < 0 )
  314.     return;
  315.  
  316.   if ( startrow < 0 )        startrow = 0;
  317.   startrow -= startrow % GS.memlabelskip;
  318.  
  319.   endrow++;
  320.   if ( endrow >= GS.memrows )    endrow = GS.memrows - 1;
  321.  
  322.   XSetFont( GS.X.d, GS.X.memgc, GS.X.memlabelfont->fid );
  323.   XSetForeground( GS.X.d, GS.X.memgc, colour );
  324.  
  325.   for ( row = startrow; row <= endrow; row += GS.memlabelskip )
  326.     expose_memaxis_row( xlo, xhi, row, viewport );
  327.  
  328.   XFlush( GS.X.d );
  329.  
  330. }
  331.  
  332.  
  333. /* DONE
  334. * expose_memaxis_row()
  335. *
  336. * NOTE that xhi and xlo are unused so far.
  337. *
  338. */
  339.  
  340. void
  341. expose_memaxis_row( xlo, xhi, row, viewport )
  342.   int        xlo;
  343.   int        xhi;
  344.   int        row;
  345.   int        viewport;
  346. {
  347.   char        labelbuf[10];    /* big enough to store "9000000".  i doubt */
  348.                 /* we'll be running 9 Meg soups! */
  349.   register int    x, y, lx1, lx2, ly;
  350.  
  351.   sprintf( labelbuf, "%d", row * GS.memrlen );
  352.  
  353.   lx1 = GS.ebwidth - GS.X.memlabelfont->max_bounds.rbearing +
  354.     GS.X.memlabelfont->min_bounds.lbearing;
  355.   x = lx1 - XTextWidth( GS.X.memlabelfont, labelbuf, strlen( labelbuf ) );
  356.   lx1 += 2;
  357.   lx2 = GS.ebwidth - 1;
  358.  
  359.   ly = GS.vbd + row * ( GS.memrwidth + GS.memrspace ) + ( GS.memrwidth / 2 ) -
  360.     viewport;
  361.   y = ly + ( GS.X.memlabelfont->max_bounds.ascent / 2 );
  362.   ly += GS.hashlen;
  363.  
  364.   XDrawString( GS.X.d, XtWindow( GS.X.etcbox ), GS.X.memgc, x, y, labelbuf,
  365.            strlen( labelbuf ) );
  366.   XDrawLine( GS.X.d, XtWindow( GS.X.etcbox ), GS.X.memgc, lx1, ly, lx2, ly );
  367.   
  368. }
  369.  
  370.  
  371. void
  372. handle_client_message( w, client_data, event, ctd )
  373.   Widget        w;
  374.   XtPointer        client_data;
  375.   XClientMessageEvent    *event;
  376.   Boolean        *ctd;
  377. {
  378.  
  379.   if ( event->message_type != MEM_SCROLL ) {
  380.     fprintf( stderr, "handle_client_message: message_type %d unknown\n",
  381.          event->message_type );
  382.     return;
  383.   }
  384.  
  385.   actually_scroll_screen( *(float *)event->data.l[0] );
  386.  
  387. }
  388.  
  389.  
  390. /* DONE
  391. * expose_statbox()
  392. *
  393. * event handler
  394. *
  395. */
  396.  
  397. XtEventHandler
  398. expose_statbox( w, client_data, event, ctd )
  399.   Widget    w;
  400.   XtPointer    client_data;
  401.   XEvent    *event;
  402.   Boolean    *ctd;
  403. {
  404.   XExposeEvent        *ev;
  405.   static int        state = 0;
  406.   static int        si_xhi = 0;
  407.   static int        si_xlo = 0;
  408.   static int        si_yhi = 0;
  409.   static int        si_ylo = 0;
  410.   register int        valtmp;
  411.  
  412.   if ( event->type != Expose ) {
  413.     fprintf( stderr, "expose_ovframe() got event %d... ???\n", event->type );
  414.     return;
  415.   }
  416.   ev = (XExposeEvent *)event;
  417.  
  418.   if ( state == 0 ) {
  419.  
  420.     state = 1;
  421.     si_xlo = ev->x;
  422.     si_xhi = si_xlo + ev->width - 1;
  423.     si_ylo = ev->y;
  424.     si_yhi = si_ylo + ev->height - 1;
  425.  
  426.   } else {
  427.  
  428.     if ( ev->x < si_xlo )
  429.       si_xlo = ev->x;
  430.     if ( (valtmp = ev->x + ev->width - 1) > si_xhi )
  431.       si_xhi = valtmp;
  432.  
  433.     if ( ev->y < si_ylo )
  434.       si_ylo = ev->y;
  435.     if ( (valtmp = ev->y + ev->height - 1) > si_yhi )
  436.       si_yhi = valtmp;
  437.  
  438.   }
  439.   if ( ev->count == 0 ) {
  440.  
  441.     state = 0;
  442.     expose_stats( si_xlo, si_xhi, si_ylo, si_yhi );
  443.  
  444.   }
  445. }
  446.  
  447.  
  448. void
  449. expose_stats( xlo, xhi, ylo, yhi )
  450.   int        xlo;
  451.   int        xhi;
  452.   int        ylo;
  453.   int        yhi;
  454. {
  455.  
  456.   draw_stat_keys( xlo, xhi, ylo, yhi, True );
  457.  
  458. }
  459.  
  460.  
  461. void
  462. draw_stat_keys( xlo, xhi, ylo, yhi, force )
  463.   int        xlo;
  464.   int        xhi;
  465.   int        ylo;
  466.   int        yhi;
  467.   int        force;
  468. {
  469.   register int        i, x, y, dx;
  470.   register Sizemap    *sm;
  471.   char            textbuf[32];    /* big enough; HARDCODED CONSTANT */
  472.   register int        notused;
  473.   register int        skipspace0, skipspace1, skipspace2;
  474.   static char        _stat_not_applicable[] = "   < n/a >   ";
  475.   static char        _stat_none[] = "      ---      ";
  476.   u_long        popsum;
  477.   float            wpopsum;
  478.  
  479.   XSetLineAttributes( GS.X.d, GS.X.memgc, ST_KeyWidth, LineSolid,
  480.               CapButt, JoinMiter );
  481.   dx = GS.mfwidth / (NUM_SPECCOLOURS + 1);
  482.   x = GS.ebwidth + 3 - dx / 2;
  483.   skipspace0 = (int)(ST_Skip0 * (float)GS.X.memlabelfont->max_bounds.ascent);
  484.   skipspace1 = (int)(ST_Skip1 * (float)GS.X.memlabelfont->max_bounds.ascent);
  485.   skipspace2 = (int)(ST_Skip2 * (float)GS.X.statfont->max_bounds.ascent);
  486.  
  487.   sm = GS.sizemaproot;
  488.  
  489.   for ( i = 0; i <= NUM_SPECCOLOURS; i++ ) {
  490.  
  491.     if ( ! force ) {
  492.       if ( sm == (Sizemap *)NULL ) {
  493.     int        j;
  494.  
  495.     for ( j = 0; j < 4; j++ )
  496.       GS.key_list[i][j] = 0L;
  497.       } else {
  498.     if ( i < NUM_SPECCOLOURS ) {
  499.       GS.key_list[i][0] = sm->len;
  500.       GS.key_list[i][2] = sm->pop;
  501.       GS.key_list[i][3] = (u_long)sm->colour;
  502.                            /* HARDCODED CONSTANT */
  503.       GS.key_list[i][1] = (u_long)( ( (float)sm->pop * (float)sm->len *
  504.                       10000.0 ) / (float)GS.memsize );
  505.       sm = sm->next;
  506.     } else {
  507.       GS.key_list[i][0] = 1L;    /* any nonzero */
  508.       GS.key_list[i][3] = GS.X.cother;
  509.  
  510.       popsum = 0L;
  511.       wpopsum = 0.0;
  512.       while ( sm != (Sizemap *)NULL ) {
  513.         popsum += sm->pop;
  514.         wpopsum += ( (float)sm->pop * (float)sm->len ) / (float)GS.memsize;
  515.         sm = sm->next;
  516.       }
  517.  
  518.       GS.key_list[i][2] = popsum;
  519.       GS.key_list[i][1] = (u_long)( wpopsum * 10000.0 );
  520.     }
  521.       }
  522.     }
  523.  
  524.     notused = ( GS.key_list[i][0] == 0 );
  525.     x += dx;
  526.     y = ST_UBorder + (ST_KeyWidth / 2);
  527.  
  528.     if ( notused ) {        /* no size here yet */
  529.       XSetForeground( GS.X.d, GS.X.memgc, GS.X.cmemory );
  530.       XDrawLine( GS.X.d, XtWindow( GS.X.statbox ), GS.X.memgc,
  531.              x - (ST_KeyLength / 2), y, x + (ST_KeyLength / 2), y );
  532.       XSetForeground( GS.X.d, GS.X.memgc, GS.X.cother );
  533.     } else {
  534.       XSetForeground( GS.X.d, GS.X.memgc,
  535.     ( i == NUM_SPECCOLOURS ) ? GS.X.cother : GS.key_list[i][3] );
  536.       XDrawLine( GS.X.d, XtWindow( GS.X.statbox ), GS.X.memgc,
  537.              x - (ST_KeyLength / 2), y, x + (ST_KeyLength / 2), y );
  538.       XSetForeground( GS.X.d, GS.X.memgc, WhitePixel( GS.X.d, 0 ) );
  539.     }
  540.  
  541.     y = ST_UBorder + ST_KeyWidth + skipspace0 +
  542.     GS.X.memlabelfont->max_bounds.ascent;
  543.  
  544.     if ( notused )
  545.       strcpy( textbuf, _stat_not_applicable );
  546.     else {
  547.       if ( i == NUM_SPECCOLOURS )
  548.     strcpy( textbuf, "   others   " );
  549.       else
  550.         sprintf( textbuf, "     %lu     ", GS.key_list[i][0] );
  551.     }
  552.  
  553.     XSetForeground( GS.X.d, GS.X.memgc, WhitePixel( GS.X.d, 0 ) );
  554.     XSetBackground( GS.X.d, GS.X.memgc, BlackPixel( GS.X.d, 0 ) );
  555.     XSetFont( GS.X.d, GS.X.memgc, GS.X.memlabelfont->fid );
  556.     XDrawImageString( GS.X.d, XtWindow( GS.X.statbox ), GS.X.memgc,
  557.       x - XTextWidth( GS.X.memlabelfont, textbuf, strlen( textbuf ) ) / 2, y,
  558.       textbuf, strlen( textbuf ) );
  559.  
  560.     y += skipspace1 + GS.X.statfont->max_bounds.ascent;
  561.  
  562.     if ( notused )
  563.       strcpy( textbuf, _stat_none );
  564.     else
  565.       sprintf( textbuf, "  %.4f  ", (float)GS.key_list[i][1] / 10000.0 );
  566.  
  567.     XSetFont( GS.X.d, GS.X.memgc, GS.X.statfont->fid );
  568.     XDrawImageString( GS.X.d, XtWindow( GS.X.statbox ), GS.X.memgc,
  569.       x - XTextWidth( GS.X.statfont, textbuf, strlen( textbuf ) ) / 2, y,
  570.       textbuf, strlen( textbuf ) );
  571.  
  572.     y += skipspace2 + GS.X.statfont->max_bounds.ascent;
  573.  
  574.     if ( notused )
  575.       strcpy( textbuf, _stat_none );
  576.     else
  577.       sprintf( textbuf, "     %lu     ", GS.key_list[i][2] );
  578.  
  579.     XDrawImageString( GS.X.d, XtWindow( GS.X.statbox ), GS.X.memgc,
  580.       x - XTextWidth( GS.X.statfont, textbuf, strlen( textbuf ) ) / 2, y,
  581.       textbuf, strlen( textbuf ) );
  582.  
  583.   }
  584.  
  585.   XFlush( GS.X.d );
  586. }
  587.  
  588.  
  589.