home *** CD-ROM | disk | FTP | other *** search
/ Club Amiga de Montreal - CAM / CAM_CD_1.iso / files / 552.lha / ParM_v3.0 / source.LZH / source / MenuAlloc.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-07-18  |  4.4 KB  |  186 lines
  1. /*
  2.  *    MenuAlloc.c - Copyright © 1990 by S.R. & P.C.
  3.  *
  4.  *    Created:    16 Jun 1990
  5.  *    Modified:    17 Jul 1991  20:58:46
  6.  *
  7.  *    Make>> make
  8.  */
  9.  
  10. #include "ParMBase.h"
  11.  
  12. #define MEM_BLOCK_SIZE 1024
  13.  
  14. extern void RemParMEvents(struct Window *Win);
  15.  
  16. /* Memory allocation functions */
  17.  
  18. static void *Malloc(struct ParMConfig *PCfg, size_t size)
  19. {
  20.     void *chunck;
  21.  
  22.     size += 3;            /* make chuncks long word aligned */
  23.     size &= ~(3L);
  24.     if (size > PCfg->Avail) {
  25.         if (size > MEM_BLOCK_SIZE) {
  26.             SimpleRequest(PCfg->ReqTitle, "Line too long");
  27.             return NULL;
  28.         }
  29.         if (!(PCfg->mem = AllocRemember(&PCfg->MemList, MEM_BLOCK_SIZE, MEMF_PUBLIC|MEMF_CLEAR)))
  30.             return NULL;
  31.         PCfg->Avail = MEM_BLOCK_SIZE;
  32.     }
  33.     chunck = PCfg->mem;
  34.     PCfg->mem += size;
  35.     PCfg->Avail -= size;
  36.     return chunck;
  37. }
  38.  
  39.  
  40. /*****  make (and Mallocate) a copy of the passed string *****/
  41.  
  42. static char *MallocStr(struct ParMConfig *PCfg, char *str)
  43. {
  44.     char *newstr;
  45.  
  46.     if (newstr = Malloc(PCfg, strlen(str)+1))
  47.         strcpy(newstr, str);
  48.     return newstr;
  49. }
  50.  
  51.  
  52. /* clean up widths and other info now that menu is all built */
  53.  
  54. void CleanUp(struct Menu *Menu, short LeftEdge, short ItemHeight)
  55. {
  56.     UWORD maxw, smaxw, txtw, top, stop;
  57.     struct MenuItem *iptr, *sptr;
  58.  
  59.     for( ; Menu ; Menu = Menu->NextMenu ) {
  60.         Menu->LeftEdge = LeftEdge;
  61.         maxw = Menu->Width = strlen(Menu->MenuName) * 8 + 12;
  62.         LeftEdge += maxw;
  63.         top = 0;
  64.         /* determine max width */
  65.         for( iptr = Menu->FirstItem ; iptr ; iptr=iptr->NextItem ) {
  66.             iptr->TopEdge = top;
  67.             top += (iptr->Height = ItemHeight);
  68.             txtw = IntuiTextLength((struct IntuiText *)iptr->ItemFill)+2;
  69.             if( iptr->Flags & COMMSEQ ) txtw += 48;
  70.             if( txtw > maxw ) maxw = txtw;
  71.         }
  72.         for( iptr = Menu->FirstItem ; iptr ; iptr=iptr->NextItem ) {
  73.             iptr->Width = maxw;
  74.             stop = smaxw = 0;
  75.             for( sptr=iptr->SubItem ; sptr ; sptr=sptr->NextItem ) {
  76.                 sptr->LeftEdge = maxw;
  77.                 sptr->TopEdge = stop;
  78.                 stop += (sptr->Height = ItemHeight);
  79.                 txtw = IntuiTextLength((struct IntuiText *)sptr->ItemFill)+2;
  80.                 if( sptr->Flags & COMMSEQ ) txtw += 48;
  81.                 if( txtw > smaxw ) smaxw = txtw;
  82.             }
  83.             for( sptr=iptr->SubItem ; sptr ; sptr=sptr->NextItem )
  84.                 sptr->Width = smaxw;
  85.         }
  86.     }
  87. }
  88.  
  89.  
  90. /* allocate and initialize a new MenuItem */
  91.  
  92. struct Extended_MenuItem *AllocItem(struct ParMConfig *PCfg, char *itemstr)
  93. {
  94.     struct IntuiText *IT;
  95.     struct Extended_MenuItem *emi;
  96.  
  97.     if (!(emi = Malloc(PCfg, sizeof(struct Extended_MenuItem))))
  98.         return FALSE;
  99.     if (!(IT = Malloc(PCfg, sizeof(struct IntuiText))))
  100.         return FALSE;
  101.     emi->emi_MenuItem.Flags = ITEMTEXT+HIGHCOMP+ITEMENABLED;
  102.     IT->FrontPen = PCfg->MenuPen;
  103.     IT->LeftEdge = IT->TopEdge = 1;
  104.     IT->DrawMode = JAM1;
  105.     if (!(IT->IText = (UBYTE *)MallocStr(PCfg, itemstr)))
  106.         return FALSE;
  107.     emi->emi_MenuItem.ItemFill = (APTR)IT;
  108.     return emi;
  109. }
  110.  
  111.  
  112. /* allocate and initialize a new Menu */
  113.  
  114. BOOL AddMenu(struct ParMConfig *PCfg, char *str)
  115. {
  116.     struct Menu *Menu;
  117.  
  118.     if (!(Menu = Malloc(PCfg, sizeof(struct Menu))))
  119.         return FALSE;
  120.     if (!(Menu->MenuName = MallocStr(PCfg, str)))
  121.         return FALSE;
  122.     Menu->Flags = MENUENABLED;
  123.     PCfg->CurrentMenu->NextMenu = Menu;
  124.     PCfg->CurrentMenu = Menu;
  125.     PCfg->CurrentItem = &Menu->FirstItem;
  126.     return TRUE;
  127. }
  128.  
  129.  
  130. BOOL AddSubMenu(struct ParMConfig *PCfg, char *substr)
  131. {
  132.     if (!(*PCfg->CurrentItem = (struct MenuItem *)AllocItem(PCfg, substr)))
  133.         return FALSE;
  134.     PCfg->CurrentSubMenu = *PCfg->CurrentItem;
  135.     PCfg->CurrentItem = &PCfg->CurrentSubMenu->SubItem;
  136.     return TRUE;
  137. }
  138.  
  139.  
  140. BOOL AddEntry(    struct ParMConfig *PCfg,
  141.                 char *item,
  142.                 char *cmd,
  143.                 char *args,
  144.                 char *win,
  145.                 char shortcut,
  146.                 char mode,
  147.                 long stk,
  148.                 short pri )
  149. {
  150.     struct Extended_MenuItem *emi;
  151.  
  152.     if (!(emi = AllocItem(PCfg, item)))
  153.         return FALSE;
  154.     emi->emi_Mode = mode;
  155.     if (!(emi->emi_RunInfo.ri_Cmd = MallocStr(PCfg, cmd)))
  156.         return FALSE;
  157.     if (args && !(emi->emi_RunInfo.ri_Args = MallocStr(PCfg, args)))
  158.         return FALSE;
  159.     if (shortcut) {
  160.         emi->emi_MenuItem.Flags |= COMMSEQ;
  161.         emi->emi_MenuItem.Command = shortcut;
  162.     }
  163.     if (win && !(emi->emi_RunInfo.ri_Window = MallocStr(PCfg, win)))
  164.         return FALSE;
  165.     emi->emi_RunInfo.ri_Pri = pri;
  166.     emi->emi_RunInfo.ri_Stack = stk;
  167.     *PCfg->CurrentItem = (struct MenuItem *)emi;
  168.     PCfg->CurrentItem = &emi->emi_MenuItem.NextItem;
  169.     return TRUE;
  170. }
  171.  
  172.  
  173. /* free up all space taken up by our menus */
  174.  
  175. void FreeMenus(struct ParMConfig *PCfg)
  176. {
  177.     struct ParMBase *ParMBase;
  178.  
  179.     FreeRemember(&PCfg->MemList, TRUE);
  180.     PCfg->CurrentMenu = PCfg->LinkMenu;
  181.     PCfg->LinkMenu->NextMenu = NULL;
  182.     PCfg->Avail = 0;
  183.     RemParMEvents(PCfg->Win);
  184. }
  185.  
  186.