home *** CD-ROM | disk | FTP | other *** search
/ Gold Fish 3 / goldfish_volume_3.bin / files / fish / disks / d1008.lha / Programs / MemMinister / Source / MemMinister.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-08-29  |  11.1 KB  |  317 lines
  1. /*
  2. **  MemMinister is copyright by Marcus Ohlström 1994. All rights reserved
  3. */
  4.  
  5. #include "memminister.h"
  6. #include "memminister_rev.h"
  7. /*#include <stdio.h>*/
  8.  
  9. UBYTE *ver = VERSTAG ;
  10.  
  11. LONG __oslibversion = 37 ;
  12.  
  13. void __regargs __chkabort(void);
  14. void __regargs __chkabort(void){}  /* Oskadliggör hanteringen av CTRL-C */
  15.  
  16. struct TextAttr textattr ;  /* initieras av layoutAll() */
  17.  
  18. UWORD snap_borData[2][6]  = { {0,0,0,0,0,0},{0,0,0,0,0,0} } ;
  19. UWORD flush_borData[2][6] = { {0,0,0,0,0,0},{0,0,0,0,0,0} } ;
  20.  
  21. struct Border snap_bor[] = 
  22. {
  23.     { 0, 0, 2, 0, JAM1, 3, snap_borData[0], &snap_bor[1] },
  24.     { 0, 0, 1, 0, JAM1, 3, snap_borData[1], NULL }
  25. } ;
  26.  
  27. struct Border flush_bor[] = 
  28. {
  29.     { 0, 0, 2, 0, JAM1, 3, flush_borData[0], &flush_bor[1] },
  30.     { 0, 0, 1, 0, JAM1, 3, flush_borData[1], NULL }
  31. } ;
  32.  
  33. struct IntuiText snap_gadText[] = 
  34. {
  35.     { 1, 0, JAM2, 10, 2, &textattr, "Free",     &snap_gadText[1] },
  36.     { 1, 0, JAM2, 45, 2, &textattr, "Snapped",  &snap_gadText[2] },
  37.     { 1, 0, JAM2, 90, 2, &textattr, "Used",     NULL },
  38. } ;
  39.  
  40. struct IntuiText flush_gadText =
  41.     { 1, 0, JAM2, 4,  2, &textattr, "Flush",    NULL } ;
  42.  
  43. struct Gadget snap_gad =  { NULL,     54, 12, 100, 12, GFLG_GADGHCOMP, GACT_RELVERIFY, GTYP_BOOLGADGET,  &snap_bor, NULL,   snap_gadText, NULL, NULL,  SNAP_GAD, NULL } ;
  44. struct Gadget flush_gad = { &snap_gad, 4, 12,  28, 12, GFLG_GADGHCOMP, GACT_RELVERIFY, GTYP_BOOLGADGET, &flush_bor, NULL, &flush_gadText, NULL, NULL, FLUSH_GAD, NULL } ;
  45.  
  46. struct Image image = { 0, 0, 0, 0, 0, NULL, 0, 0, NULL } ;
  47.  
  48. ULONG chip_snapped = 0, fast_snapped = 0 ;
  49. ULONG old_chip_free = 0, old_fast_free = 0 ;
  50.  
  51. /*  nedanstående initieras i layouotAll()  */
  52. ULONG chip_XPos, fast_XPos, total_XPos ;
  53. ULONG win_Width ;
  54. ULONG chip_YPos, fast_YPos, total_YPos ;
  55. ULONG text_RightX, free_RightX, snapped_RightX, used_RightX ;
  56. LONG number_length ;
  57.  
  58. UBYTE *chip_text = "Chip" , *fast_text = "Fast", *total_text = "Total" ;
  59.  
  60. UBYTE str[11] ; /* <-  11 istället för STRLEN gör att fönstret ser        */
  61.                 /* konstigt ut om STRLEN är för litet, men programmet     */
  62.                 /* krashar inte!! (Vilket det gör om det står STRLEN här) */
  63.  
  64. struct IntuiText iText = { 1, 0, JAM2, 0, 0, &textattr, str, NULL } ;
  65.  
  66. WORD zoomsize[] = { ~0, ~0, 20 + 10 + (STRLEN-1)*8 + 10 + 26 + 26, 11 } ;
  67.  
  68. struct Window *win ;
  69. struct Screen *scr ;
  70.  
  71. STRPTR wintitle = "MemMinister  1.1" ;
  72.  
  73. VOID main( VOID )
  74. {
  75.     LONG lng;
  76.     BOOL done = FALSE ;
  77.     struct IntuiMessage *iMsg ;
  78.     ULONG class ;
  79.     struct Gadget *gad ;
  80.     
  81.     if( scr = LockPubScreen( NULL ) )
  82.     {
  83.         /* layoutAll() initierar bla textattr => använd EJ textattr innan */
  84.         layoutAll() ;
  85.         if( win = OpenWindowTags( NULL,
  86. /*
  87.             WA_Left,            100,
  88.             WA_Top,             20,
  89. */
  90.             WA_Width,           win_Width,
  91.             WA_InnerHeight,     scr->RastPort.Font->tf_YSize * 4 + 3 + 1,
  92.             WA_Title,           wintitle,
  93.             WA_ScreenTitle,     "MemMinister 1.1  © Marcus Ohlström",
  94.             WA_Gadgets,         &flush_gad,
  95.             WA_Zoom,            zoomsize,
  96.             WA_AutoAdjust,      TRUE,
  97.             WA_Flags,   WFLG_CLOSEGADGET | WFLG_DEPTHGADGET | WFLG_DRAGBAR,
  98.             WA_IDCMP,   IDCMP_CLOSEWINDOW | IDCMP_GADGETUP | IDCMP_NEWSIZE,
  99.             TAG_END ) )
  100.         {
  101.             writeInit() ;
  102.             writeSnapped( AvailMem(MEMF_CHIP), AvailMem(MEMF_FAST) ) ;
  103.             while( !done )
  104.             {
  105.                 if( !(win->Flags & WFLG_ZOOMED) )
  106.                     writeFree( AvailMem(MEMF_CHIP), AvailMem(MEMF_FAST) ) ;
  107.                 else {
  108.                     lng = AvailMem(MEMF_ANY) ;
  109.                     RawDoFmt("%ld", &lng, (void (*))"\x16\xc0\x4e\x75", str);
  110.                     SetWindowTitles( win, str, (UBYTE *)~0 ) ;
  111.                 }
  112.                 Delay( UPDATEDELAY ) ;
  113.                 
  114.                 /*   denna sats bör ligga här för att programmet inte   */
  115.                 /*   ska vänta ytterligare UPDATEDELAY*1/50 sec efter   */
  116.                 /*   IDCMP-meddelanden                                  */
  117.                 /*                                                      */
  118.                 while( iMsg = (struct IntuiMessage *)GetMsg( win->UserPort ) )
  119.                 {
  120.                     class = iMsg->Class ;
  121.                     gad   = (struct Gadget *)iMsg->IAddress ;
  122.                     /*  använd INTE gad om class != IDCMP_GADGETUP  */
  123.                     ReplyMsg( (struct Message *)iMsg ) ;
  124.  
  125.                     switch( class )
  126.                     {
  127.                         case IDCMP_GADGETUP:
  128.                                 switch( gad->GadgetID )
  129.                                 {
  130.                                     case FLUSH_GAD:
  131.                                         AllocMem( 0, 0 ) ;
  132.                                         break;
  133.                                     case SNAP_GAD:
  134.                                         writeSnapped( AvailMem(MEMF_CHIP), AvailMem(MEMF_FAST) ) ;
  135.                                         writeUsed( 0, 0 ) ;
  136.                                 }
  137.                                 break ;
  138.                         case IDCMP_NEWSIZE:
  139.                                 if( !(win->Flags & WFLG_ZOOMED) )
  140.                                 {
  141.                                     SetWindowTitles( win, wintitle, (UBYTE *)~0 ) ;
  142.                                     writeInit() ;
  143.                                     writeSnapped( chip_snapped, fast_snapped ) ;
  144.                                     old_chip_free = old_fast_free = 0 ;
  145.                                     /* ^ för att free-fälten ska ritas om */
  146.                                 }
  147.                                 break;
  148.                         case IDCMP_CLOSEWINDOW:
  149.                                 done = TRUE ;
  150.                     }
  151.                 }
  152.             }
  153.             CloseWindow( win ) ;
  154.         }
  155.         UnlockPubScreen( NULL, scr ) ;
  156.     }
  157. }
  158.  
  159. VOID layoutAll( VOID )
  160. {
  161.     LONG chip_length, fast_length, total_length, max_length, flush_length ;
  162.     struct TextFont *Font = scr->RastPort.Font ;
  163.     
  164.     number_length = digit_maxlength() ;
  165.     
  166.     textattr.ta_Name  = Font->tf_Message.mn_Node.ln_Name ;
  167.     textattr.ta_YSize = Font->tf_YSize ;
  168.     textattr.ta_Style = Font->tf_Style ;
  169.     textattr.ta_Flags = Font->tf_Flags ;
  170.     
  171.     zoomsize[2] = 20 + number_length + 6 + 26 + 26 ;
  172.     zoomsize[3] = 3 + textattr.ta_YSize ;
  173.     
  174.     iText.IText = chip_text ;   chip_length  = IntuiTextLength( &iText ) ;
  175.     iText.IText = fast_text ;   fast_length  = IntuiTextLength( &iText ) ;
  176.     iText.IText = total_text ;  total_length = IntuiTextLength( &iText ) ;
  177.                                 flush_length = IntuiTextLength( &flush_gadText ) ;
  178.     
  179.     max_length = MAX( MAX(chip_length, fast_length), MAX(total_length, flush_length) ) ;
  180.     
  181.     total_YPos = textattr.ta_YSize +
  182.         (fast_YPos = textattr.ta_YSize +
  183.         (chip_YPos = scr->WBorTop + 1 + 2*textattr.ta_YSize + 3 + 1)) ;
  184.     
  185.     win_Width = scr->WBorRight + 4 +
  186.         (used_RightX = number_length +
  187.         (snapped_RightX = number_length +
  188.         (free_RightX = number_length +
  189.         (text_RightX = scr->WBorLeft + 2 + max_length)))) ;
  190.     
  191.     flush_gad.LeftEdge = scr->WBorRight ;
  192.     flush_gad.TopEdge  = textattr.ta_YSize + 3 ;
  193.     flush_gad.Width    = 2 + max_length + 5 ;
  194.     flush_gad.Height   = textattr.ta_YSize + 3 ;
  195.     
  196.     snap_gad.LeftEdge = scr->WBorRight + flush_gad.Width ;
  197.     snap_gad.TopEdge  = flush_gad.TopEdge ;
  198.     snap_gad.Width    = win_Width-8-flush_gad.Width ;
  199.     snap_gad.Height   = flush_gad.Height ;
  200.     
  201.     buildBoolBorder( &flush_gad ) ;
  202.     buildBoolBorder(  &snap_gad ) ;
  203.     
  204.     snap_gadText[0].LeftEdge = text_RightX    - flush_gad.Width + (number_length - IntuiTextLength(&snap_gadText[0]))/2 ;
  205.     snap_gadText[1].LeftEdge = free_RightX    - flush_gad.Width + (number_length - IntuiTextLength(&snap_gadText[1]))/2 ;
  206.     snap_gadText[2].LeftEdge = snapped_RightX - flush_gad.Width + (number_length - IntuiTextLength(&snap_gadText[2]))/2 ;
  207.     
  208.     image.Height = textattr.ta_YSize ;
  209.     
  210.     chip_XPos  = text_RightX - chip_length  ;
  211.     fast_XPos  = text_RightX - fast_length  ;
  212.     total_XPos = text_RightX - total_length ;
  213. }
  214.  
  215. VOID writeInit( VOID )
  216. {
  217.     struct DrawInfo *di = GetScreenDrawInfo( win->WScreen ) ;
  218.     
  219.     iText.FrontPen = di ? di->dri_Pens[HIGHLIGHTTEXTPEN] : 2 ;
  220.     
  221.     iText.IText = chip_text ;
  222.     PrintIText( win->RPort, &iText, chip_XPos, chip_YPos ) ;
  223.     
  224.     iText.IText = fast_text ;
  225.     PrintIText( win->RPort, &iText, fast_XPos, fast_YPos ) ;
  226.     
  227.     iText.IText = total_text ;
  228.     PrintIText( win->RPort, &iText, total_XPos, total_YPos ) ;
  229.     
  230.     iText.FrontPen = di ? di->dri_Pens[TEXTPEN] : 1 ;
  231.     
  232.     iText.IText = str ;
  233. }
  234.  
  235. VOID writeFree( ULONG chip_free, ULONG fast_free )
  236. {
  237.     BOOL any_change = FALSE ;
  238.     
  239.     if( chip_free != old_chip_free )
  240.     {
  241.         myPrintINumber( chip_free, free_RightX, chip_YPos ) ;
  242.         old_chip_free = chip_free ;
  243.         any_change = TRUE ;
  244.     }
  245.     
  246.     if( fast_free != old_fast_free )
  247.     {
  248.         myPrintINumber( fast_free, free_RightX, fast_YPos ) ;
  249.         old_fast_free = fast_free ;
  250.         any_change = TRUE ;
  251.     }
  252.     
  253.     if( any_change )
  254.     {
  255.         myPrintINumber( chip_free + fast_free, free_RightX, total_YPos ) ;
  256.         
  257.         writeUsed( chip_snapped-chip_free, fast_snapped-fast_free ) ;
  258.     }
  259. }
  260.  
  261. VOID writeSnapped( ULONG chip_now, ULONG fast_now )
  262. {
  263.     myPrintINumber( chip_now, snapped_RightX, chip_YPos ) ;
  264.     myPrintINumber( fast_now, snapped_RightX, fast_YPos ) ;
  265.     myPrintINumber( chip_now + fast_now, snapped_RightX, total_YPos ) ;
  266.     chip_snapped = chip_now ;
  267.     fast_snapped = fast_now ;
  268. }
  269.  
  270. VOID writeUsed( ULONG chip_used, ULONG fast_used )
  271. {
  272.     myPrintINumber( chip_used, used_RightX, chip_YPos ) ;
  273.     myPrintINumber( fast_used, used_RightX, fast_YPos ) ;
  274.     myPrintINumber( chip_used+fast_used, used_RightX, total_YPos ) ;
  275. }
  276.  
  277. VOID myPrintINumber( ULONG number, ULONG XRight, ULONG Y )
  278. {
  279.     RawDoFmt("%ld", &number, (void (*))"\x16\xc0\x4e\x75", iText.IText);
  280.     PrintIText( win->RPort, &iText, XRight-IntuiTextLength(&iText), Y ) ;
  281.     
  282.     image.Width = number_length - IntuiTextLength(&iText) ;
  283.     DrawImage( win->RPort, &image, XRight-number_length, Y ) ;
  284. }
  285.  
  286. /*  gad->GadgetRender->XY MÅSTE vara MEMF_CLEARed WORD[12]  */
  287. VOID buildBoolBorder( struct Gadget *gad )
  288. {
  289.     WORD *XY = ((struct Border *)gad->GadgetRender)->XY ;
  290.     
  291.     XY[1] = XY[9] = XY[11] = gad->Height - 1 ;
  292.     XY[4] = XY[6] = XY[8] = gad->Width - 1 ;
  293.     XY[10] = 1 ;
  294. }
  295.  
  296. LONG digit_maxlength( VOID )
  297. {
  298.     struct TextFont *Font = scr->RastPort.Font ;
  299.     ULONG LoChar = Font->tf_LoChar ;
  300.     
  301.     LONG char_width = 0, tmp, count = 10 ;
  302.     
  303.     if( FPF_PROPORTIONAL & Font->tf_Flags )
  304.     {
  305.         while( count-- )
  306.         {
  307.             tmp = ((WORD*)Font->tf_CharSpace)['0' - LoChar + count] + ((WORD*)Font->tf_CharKern )['0' - LoChar + count] ;
  308.             char_width = MAX( char_width, tmp ) ;
  309.         }
  310.         tmp = ((WORD*)Font->tf_CharSpace)['-' - LoChar] + ((WORD*)Font->tf_CharKern )['-' - LoChar] ;
  311.         tmp = MAX( char_width, tmp ) ;
  312.     } else
  313.         char_width = tmp = Font->tf_XSize ;
  314.     
  315.     return( char_width * (STRLEN-2) + tmp ) ; /* <- för att tänka på '-' */
  316. }
  317.