fish/memsnap/memsnap.c

   1 #include <aros/oldprograms.h>
   2
   3 /*
   4 *       MemSnap.c
   5 *
   6 *       Just like MeMeter (a program I've been using for ages now).
   7 *       Why write it? The MeMeter I've been using crashes under 2.0,
   8 *       and I thought I'd take the time to learn (a bit) about 2.0
   9 *       by programming with it. Nothing groundbreaking here, though.
  10 *
  11 *       Martin W Scott, 3/92.
  12 */
  13 #include <exec/types.h>
  14 #include <exec/memory.h>
  15 #include <intuition/intuition.h>
  16 #include <proto/exec.h>
  17 #include <proto/dos.h>
  18 #include <proto/intuition.h>
  19 #include "wintext.h"            /* font-independent positioning of text */
  20 #include "icon.h"
  21 #include "menu.h"
  22
  23 char version_str[] = "$VER: MemSnapII 1.0 (" __DATE__ ")";
  24
  25 #define CHARS_ACROSS    32      /* max chars across for window texts */
  26 #define CHARS_DOWN       4      /* how many rows of text in window */
  27 #define REMOVECHARS     18      /* how many cols removed when window small */
  28
  29 #define LARGE_HEADER "       Current Snapshot     Used"
  30 #define SMALL_HEADER "    Memory"
  31
  32 #define ABOUT_TXT "\
  33   MemSnapII v1.0\n\
  34 by Martin W. Scott\n\
  35 \n\
  36      Freeware"
  37
  38 WINTEXT wtexts[] =
  39 {
  40     {&wtexts[1], "       Current Snapshot     Used", 0, 0, 3, 0, JAM2},
  41     {&wtexts[2], " Chip", 0, 1, 2, 0, JAM2},
  42     {&wtexts[3], " Fast", 0, 2, 2, 0, JAM2},
  43     {NULL, "Total", 0, 3, 2, 0, JAM2}
  44 };
  45
  46 char cbuf[3][9], sbuf[3][9], ubuf[3][9];
  47
  48 WINTEXT ctexts[] =
  49 {
  50     {&ctexts[1], &cbuf[0][0], 6, 1, 1, 0, JAM2},
  51     {&ctexts[2], &cbuf[1][0], 6, 2, 1, 0, JAM2},
  52     {NULL, &cbuf[2][0], 6, 3, 1, 0, JAM2}
  53 };
  54
  55 WINTEXT stexts[] =
  56 {
  57     {&stexts[1], &sbuf[0][0], 15, 1, 1, 0, JAM2},
  58     {&stexts[2], &sbuf[1][0], 15, 2, 1, 0, JAM2},
  59     {NULL, &sbuf[2][0], 15, 3, 1, 0, JAM2}
  60 };
  61
  62 WINTEXT utexts[] =
  63 {
  64     {&utexts[1], &ubuf[0][0], 24, 1, 1, 0, JAM2},
  65     {&utexts[2], &ubuf[1][0], 24, 2, 1, 0, JAM2},
  66     {NULL, &ubuf[2][0], 24, 3, 1, 0, JAM2}
  67 };
  68
  69 /* back to normal stuff */
  70
  71 struct Gadget drag_gadget =
  72 {
  73 /* whole window */
  74     NULL,
  75     0, 0, 0, 0,
  76     GRELWIDTH | GRELHEIGHT | GADGHNONE,
  77     GADGIMMEDIATE,
  78     GTYP_WDRAGGING
  79 /* rest is 0/NULL */
  80 };
  81
  82 struct Gadget biggadget =       /* this will be snapshot gadget */
  83 {
  84     &drag_gadget,
  85     0, 0, 0, 0,
  86     GRELWIDTH | GADGHCOMP,
  87     RELVERIFY,
  88     GTYP_BOOLGADGET
  89 /* rest is 0/NULL */
  90 };
  91
  92 #define LEFTEDGE 40             /* window coordinates */
  93 #define TOPEDGE  20
  94
  95 struct NewWindow nw =
  96 {
  97     LEFTEDGE, TOPEDGE, 0, 0, -1, -1,    /* dimension, pens */
  98     NEWSIZE | MENUPICK | GADGETUP,      /* IDCMP flags */
  99     WFLG_SMART_REFRESH,         /* window flags */
 100     &biggadget, NULL,           /* gadgets, checkmark */
 101     NULL,                       /* title */
 102     NULL, NULL,                 /* screen, bitmap */
 103     0, 0, 0, 0,                 /* extrema of dimensions */
 104     WBENCHSCREEN                /* screen to open onto */
 105 };
 106
 107 struct TagItem wtags[] =
 108 {
 109     {WA_AutoAdjust, TRUE},
 110     {TAG_DONE}
 111 };
 112
 113 struct Window *w;               /* screen pointer */
 114 struct Menu *menu;
 115 struct GfxBase *GfxBase;        /* graphics pointer */
 116 struct IntuitionBase *IntuitionBase;    /* intuition pointer */
 117 struct Library *IconBase, *DiskfontBase, *GadToolsBase;
 118 WINTEXTINFO wtinfo;
 119 struct WBStartup *WBenchMsg = NULL;
 120
 121 #define MEMSNAP_TIME    10L
 122 #define MEMONLY_TIME    25L
 123
 124 /******************************************************************************/
 125
 126 /* prototypes for general routines */
 127
 128 int main (int, char **);
 129 BOOL OpenLibs(void);
 130 void CloseAll(void); //, main(int, char **);
 131 BOOL long2str(LONG, char *, UWORD);
 132
 133 #ifdef LATTICE  /* save the odd byte */
 134 #include <stdlib.h>
 135 void MemCleanup(void){}
 136 #endif
 137
 138 BOOL
 139 OpenLibs()                      /* open required libraries */
 140 {
 141     if ((GfxBase = (void *) OpenLibrary("graphics.library", 0L)) &&
 142         (IntuitionBase = (void *) OpenLibrary("intuition.library", 37L)) &&
 143         (DiskfontBase = (void *) OpenLibrary("diskfont.library", 36L)) &&
 144         (GadToolsBase = (void *) OpenLibrary("gadtools.library", 37L)) &&
 145         (IconBase = (void *) OpenLibrary("icon.library", 37L)))
 146         return TRUE;
 147     CloseAll();
 148     return FALSE;
 149 }
 150
 151
 152 void
 153 CloseAll()                      /* close opened libraries */
 154 {
 155     if (menu)
 156     {
 157         ClearMenuStrip(w);
 158         FreeMemSnapMenu();
 159     }
 160     if (wtinfo.tf)
 161         CloseFont(wtinfo.tf);
 162     if (w)
 163         CloseWindow(w);
 164     if (IconBase)
 165         CloseLibrary(IconBase);
 166     if (DiskfontBase)
 167         CloseLibrary(DiskfontBase);
 168     if (GadToolsBase)
 169         CloseLibrary(GadToolsBase);
 170     if (GfxBase)
 171         CloseLibrary((struct Library *)GfxBase);
 172     if (IntuitionBase)
 173         CloseLibrary((struct Library *)IntuitionBase);
 174 }
 175
 176
 177 /* and this one is rather specific to this program... */
 178
 179 BOOL
 180 long2str(LONG n, char *s, UWORD len)    /* long to string, right-adjusted */
 181 {                               /* will NOT null-terminate */
 182     /* len is space in buffer (excl. '\0') */
 183     /* also, prints nothin if zero */
 184     short sign;                 /* minus sign required? */
 185     char *t = &s[len - 1];      /* get last space in string */
 186
 187     if (n < 0)                  /* get sign of n */
 188     {
 189         n = -n;
 190         sign = -1;
 191         len--;                  /* reduce space (we'll need it for '-') */
 192     }
 193     else
 194         sign = 0;
 195
 196     while (n && len)            /* work to do and space to do it */
 197     {
 198         *t = '0' + (n % 10);    /* get rightmost digit */
 199         t--;                    /* mave back up string */
 200         len--;
 201         n /= 10;
 202     }
 203
 204     if (sign)
 205         *t-- = '-';             /* put sign in now */
 206
 207     while (len--)               /* fill remainder with spaces */
 208         *t-- = ' ';
 209
 210     if (n)
 211         return FALSE;           /* failure */
 212     return TRUE;
 213 }
 214
 215
 216 /******************************************************************************/
 217
 218 /* Memory data management/manipulation routines */
 219
 220 void obtainmem(ULONG *), submem(ULONG *, ULONG *, ULONG *), updatemem(ULONG *, WINTEXT *);
 221
 222 #define CHIP 0
 223 #define FAST 1
 224 #define TOTAL 2
 225
 226 #define clearmem(mem)           mem[CHIP] = mem[FAST] = mem[TOTAL] = 0L
 227
 228 void
 229 obtainmem(ULONG * mem)          /* store current memory */
 230 {
 231     mem[TOTAL] = mem[CHIP] = AvailMem(MEMF_CHIP);
 232     mem[TOTAL] += (mem[FAST] = AvailMem(MEMF_FAST));
 233 }
 234
 235
 236 void
 237 submem(ULONG * to, ULONG * from, ULONG * howmuch)       /* to = from - howmuch */
 238 {
 239     to[CHIP] = from[CHIP] - howmuch[CHIP];
 240     to[FAST] = from[FAST] - howmuch[FAST];
 241     to[TOTAL] = from[TOTAL] - howmuch[TOTAL];
 242 }
 243
 244
 245 void
 246 updatemem(ULONG * mem, WINTEXT * memtext)       /* update specified display */
 247 {
 248     long2str(mem[CHIP], memtext[CHIP].text, 8);
 249     long2str(mem[FAST], memtext[FAST].text, 8);
 250     long2str(mem[TOTAL], memtext[TOTAL].text, 8);
 251
 252     RenderWinTexts(&wtinfo, memtext);
 253 }
 254
 255 /* pop up a requester */
 256 void
 257 EasyEasyRequest(char *str)
 258 {
 259     struct EasyStruct es;
 260
 261     es.es_StructSize = sizeof(struct EasyStruct);
 262
 263     es.es_Flags = 0L;
 264     es.es_Title = "MemSnap Message";
 265     es.es_TextFormat = str;
 266     es.es_GadgetFormat = "OK";
 267     EasyRequestArgs(NULL, &es, NULL, NULL);
 268 }
 269
 270
 271 #define Msg(s) EasyEasyRequest(s)
 272
 273 /******************************************************************************/
 274
 275
 276 int
 277 main (int argc, char **argv)            /* provide a memory 'meter' */
 278 {
 279     struct IntuiMessage *msg;           /* our window messages */
 280     ULONG cmem[3], smem[3], umem[3];    /* storage of memory information */
 281     ULONG class;                        /* message class */
 282     UWORD code;                         /* and code */
 283     WORD smallwidth, largewidth;        /* possible window sizes */
 284     BOOL small;                         /* are we small? */
 285
 286
 287     if (argc == 0)
 288         WBenchMsg = (struct WBStartup *) argv;
 289
 290     if (!OpenLibs())            /* failure => under 1.3 */
 291         return RETURN_FAIL;
 292
 293     GetOurIcon(WBenchMsg);
 294     if (InitWinTextInfo(&wtinfo))
 295     {
 296         /* size window to fit screen font */
 297         nw.LeftEdge = TTInt("LEFTEDGE", LEFTEDGE);
 298         nw.TopEdge = TTInt("TOPEDGE", TOPEDGE);
 299         small = TTBool("SMALL", FALSE);
 300         FreeOurIcon();          /* finished with it */
 301
 302         nw.Height = CHARS_DOWN * wtinfo.font_y + wtinfo.toffset + wtinfo.boffset;
 303         largewidth = CHARS_ACROSS * wtinfo.font_x + wtinfo.loffset + wtinfo.roffset;
 304         smallwidth = largewidth - REMOVECHARS * wtinfo.font_x;
 305         nw.Width = small ? smallwidth : largewidth;
 306         wtexts[0].text = small ? SMALL_HEADER : LARGE_HEADER;
 307
 308         /* and set up big gadget */
 309         biggadget.LeftEdge = wtinfo.loffset;
 310         biggadget.TopEdge = wtinfo.toffset;
 311         biggadget.Width = -wtinfo.roffset-wtinfo.loffset;
 312         biggadget.Height = wtinfo.font_y;
 313
 314         if ((w = OpenWindowTagList(&nw, wtags)))
 315         {
 316             if (w->Width != nw.Width)
 317             {
 318                 Msg("Window too small for text\nChoose a smaller font");
 319                 CloseAll();
 320                 return RETURN_FAIL;
 321             }
 322
 323             if ((menu = AllocMemSnapMenu(w)))
 324                 SetMenuStrip(w, menu);
 325             else
 326             {
 327                 Msg("Couldn't create menus");
 328                 CloseAll();
 329                 return RETURN_FAIL;
 330             }
 331
 332             wtinfo.window = w;
 333             SetFont(w->RPort, wtinfo.tf);
 334             RenderWinTexts(&wtinfo, wtexts);    /* draw initial texts */
 335
 336             clearmem(smem);     /* initialize memory display */
 337
 338             for (;;)            /* main event loop */
 339             {
 340                 while ((msg = (struct IntuiMessage *) GetMsg(w->UserPort)))
 341                 {
 342                     class = msg->Class;
 343                     code = msg->Code;
 344                     ReplyMsg((struct Message *) msg);
 345
 346                     if (class == GADGETUP)
 347                     {
 348                         if (!small)
 349                         {
 350                                 /* new snapshot */
 351                                 obtainmem(smem);
 352                                 updatemem(smem, stexts);
 353                         }
 354                         else goto makelarge;    /* naughty but so what? */
 355                     }
 356                     else if (class == NEWSIZE)
 357                     {
 358                         RenderWinTexts(&wtinfo, wtexts);        /* redraw texts */
 359                         if (!small)
 360                             updatemem(smem, stexts);
 361                     }
 362                     else if (class == MENUPICK)
 363                     {
 364                         switch (ITEMNUM(code))
 365                         {
 366                         case SMALL:
 367                             if (!small)
 368                             {
 369                                 wtexts[0].text = SMALL_HEADER;
 370                                 SizeWindow(w, smallwidth-largewidth, 0);
 371                                 small = TRUE;
 372                             }
 373                             break;
 374
 375                         case LARGE:
 376 makelarge:                  if (small)  /* to do: move if nec. */
 377                             {
 378                                 WORD movex;
 379                                 wtexts[0].text = LARGE_HEADER;
 380                                 movex = w->WScreen->Width - w->LeftEdge - largewidth;
 381                                 if (movex < 0)
 382                                     MoveWindow(w, movex, 0);
 383                                 SizeWindow(w, largewidth-smallwidth, 0);
 384                                 small = FALSE;
 385                             }
 386                             break;
 387
 388                         case ABOUT:
 389                             Msg(ABOUT_TXT);
 390                             break;
 391
 392                         case QUIT:
 393                             CloseAll();
 394                             return RETURN_OK;
 395                         }
 396                     }
 397
 398                 }               /* while */
 399
 400                 /* do memory window stuff */
 401                 obtainmem(cmem);
 402                 updatemem(cmem, ctexts);
 403
 404                 if (small)
 405                 {
 406                     Delay(MEMONLY_TIME);
 407                 }
 408                 else
 409                 {
 410                     submem(umem, smem, cmem);
 411                     updatemem(umem, utexts);
 412
 413                     Delay(MEMSNAP_TIME);
 414                 }
 415
 416             } /* for */
 417         }
 418         else
 419             Msg("Can't open window");
 420     }
 421     else
 422         Msg("Can't open font");
 423
 424     FreeOurIcon();
 425
 426     CloseAll();
 427     return RETURN_FAIL;
 428 }