home *** CD-ROM | disk | FTP | other *** search
/ Club Amiga de Montreal - CAM / CAM_CD_1.iso / files / 171.lha / DME_v1.30 / Sources / menu.c < prev    next >
C/C++ Source or Header  |  1988-04-28  |  5KB  |  279 lines
  1.  
  2. /*
  3.  *  MENU.C
  4.  *
  5.  *  Menu routines... made to take up as little space as possible, and
  6.  *  thus uses many tricks which you should watch out for.
  7.  */
  8.  
  9. #include "defs.h"
  10.  
  11. typedef struct {
  12.     ITEM item;
  13.     char *com;
  14. } XITEM;
  15.  
  16. short Menuoff;
  17. short DoMenuoff;
  18.  
  19. MENU *Menu;
  20.  
  21. menu_strip(win)
  22. WIN *win;
  23. {
  24.     if (!Menuoff && Menu) {
  25.     SetMenuStrip(win,Menu);
  26.     Forbid();
  27.     win->Flags &= ~RMBTRAP;
  28.     Permit();
  29.     }
  30. }
  31.  
  32. menu_off()
  33. {
  34.     register ED *ed;
  35.     if (Menuoff == 0) {
  36.     for (ed = (ED *)DBase.mlh_Head; ed->Node.mln_Succ; ed = (ED *)ed->Node.mln_Succ) {
  37.         ClearMenuStrip(ed->Win);
  38.         Forbid();
  39.         ed->Win->Flags |= RMBTRAP;
  40.         Permit();
  41.     }
  42.     }
  43.     ++Menuoff;
  44. }
  45.  
  46. menu_on()
  47. {
  48.     register ED *ed;
  49.     if (Menu && Menuoff == 1) {
  50.     fixmenu();
  51.     for (ed = (ED *)DBase.mlh_Head; ed->Node.mln_Succ; ed = (ED *)ed->Node.mln_Succ) {
  52.         SetMenuStrip(ed->Win,Menu);
  53.         Forbid();
  54.         ed->Win->Flags &= ~RMBTRAP;
  55.         Permit();
  56.     }
  57.     }
  58.     --Menuoff;
  59. }
  60.  
  61. do_menuoff()
  62. {
  63.     menu_off();
  64.     ++DoMenuoff;
  65. }
  66.  
  67. do_menuon()
  68. {
  69.     if (DoMenuoff) {
  70.     --DoMenuoff;
  71.     menu_on();
  72.     }
  73. }
  74.  
  75. char *
  76. menutomacro(str)
  77. char *str;
  78. {
  79.     char header[64];
  80.     char itembuf[64];
  81.     register short i;
  82.     register char *ptr;
  83.     register MENU *menu;
  84.     register ITEM *item;
  85.  
  86.     for (i = 0; str[i] && str[i] != '-'; ++i);
  87.     if (str[i] == '-') {
  88.     strncpy(header, str, i);
  89.     header[i] = 0;
  90.     strcpy(itembuf, str + i + 1);
  91.     for (menu = Menu; menu; menu = menu->NextMenu) {
  92.         if (ncstrcmp(header, menu->MenuName) == 0) {
  93.         for (item = menu->FirstItem; item; item = item->NextItem) {
  94.             ptr = (char *)((ITEXT *)item->ItemFill)->IText;
  95.             if (ncstrcmp(itembuf, ptr) == 0) {
  96.             ptr = ((XITEM *)item)->com;
  97.             goto done;
  98.             }
  99.         }
  100.         }
  101.     }
  102.     }
  103.     ptr = NULL;
  104. done:
  105.     return(ptr);
  106. }
  107.  
  108. char *
  109. menu_cmd(im)
  110. IMESS *im;
  111. {
  112.     XITEM *item;
  113.     char *ptr;
  114.  
  115.     if (item = (XITEM *)ItemAddress(Menu, im->Code))
  116.     return(item->com);
  117.     return(NULL);
  118. }
  119.  
  120. fixmenu()
  121. {
  122.     register MENU *menu;
  123.     register ITEM *item;
  124.     register ITEXT *it;
  125.     register int row, col, maxc, scr;
  126.  
  127.     col = 0;
  128.     for (menu = Menu; menu; menu = menu->NextMenu) {
  129.     maxc = strlen(menu->MenuName);
  130.     row = 0;
  131.     for (item = menu->FirstItem; item; item = item->NextItem) {
  132.         it = (ITEXT *)item->ItemFill;
  133.         item->TopEdge = row;
  134.         scr = strlen(((ITEXT *)item->ItemFill)->IText);
  135.         if (scr > maxc)
  136.         maxc = scr;
  137.         item->Height = 10;
  138.         row += item->Height;
  139.     }
  140.     maxc = (maxc * 8) + 16;
  141.     for (item = menu->FirstItem; item; item = item->NextItem)
  142.         item->Width = maxc;
  143.     menu->Width = maxc;
  144.     menu->LeftEdge = col;
  145.     menu->Height = row;
  146.     col += maxc;
  147.     }
  148. }
  149.  
  150. /*
  151.  *  menuclear
  152.  *  menuadd    header    item    command
  153.  *  menudel    header    item
  154.  *  menudelhdr    header
  155.  */
  156.  
  157. do_menuclear()
  158. {
  159.     menu_off();
  160.     while (Menu) {
  161.     av[1] = (ubyte *)Menu->MenuName;
  162.     do_menudelhdr();
  163.     }
  164.     menu_on();
  165. }
  166.  
  167. do_menuadd()
  168. {
  169.     register MENU *menu, **mpr;
  170.     register ITEM *item, **ipr;
  171.     register ITEXT *it;
  172.  
  173.     menu_off();
  174.     mpr = &Menu;
  175.     for (menu = *mpr; menu; menu = *mpr) {
  176.     if (strcmp(av[1], menu->MenuName) == 0) {
  177.         ipr = &menu->FirstItem;
  178.         for (item = *ipr; item; item = *ipr) {
  179.         if (strcmp(av[2], ((ITEXT *)item->ItemFill)->IText) == 0)
  180.             goto newname;
  181.         ipr = &item->NextItem;
  182.         }
  183.         goto newitem;
  184.     }
  185.     mpr = &menu->NextMenu;
  186.     }
  187. newmenu:    /*    create new menu */
  188.     menu = malloc(sizeof(MENU));
  189.     bzero(menu, sizeof(MENU));
  190.     menu->NextMenu = *mpr;
  191.     *mpr = menu;
  192.     menu->Flags = MENUENABLED;
  193.     menu->MenuName = malloc(strlen(av[1])+1);
  194.     strcpy(menu->MenuName, av[1]);
  195.     ipr = &menu->FirstItem;
  196.     *ipr = NULL;
  197. newitem:    /*    create new item */
  198.     it = malloc(sizeof(ITEXT));
  199.     bzero(it, sizeof(ITEXT));
  200.     it->BackPen = 1;
  201.     it->DrawMode = JAM2;
  202.     it->IText = malloc(strlen(av[2])+1);
  203.     strcpy(it->IText, av[2]);
  204.     item = malloc(sizeof(XITEM));
  205.     bzero(item, sizeof(XITEM));
  206.     item->NextItem = *ipr;
  207.     *ipr = item;
  208.     item->ItemFill = (APTR)it;
  209.     item->Flags = ITEMTEXT|ITEMENABLED|HIGHCOMP;
  210. newname:    /*    create new name */
  211.     if (((XITEM *)item)->com)
  212.     free(((XITEM *)item)->com);
  213.     ((XITEM *)item)->com = malloc(strlen(av[3])+1);
  214.     strcpy(((XITEM *)item)->com, av[3]);
  215.     menu_on();
  216. }
  217.  
  218. do_menudelhdr()
  219. {
  220.     register MENU *menu;
  221.     register MENU **mpr;
  222.  
  223.     menu_off();
  224.     mpr = &Menu;
  225.     for (menu = *mpr; menu; menu = *mpr) {
  226.     if (strcmp(av[1], menu->MenuName) == 0) {
  227.         if (menu->FirstItem) {
  228.         while (menu->FirstItem) {
  229.             av[2] = ((ITEXT *)menu->FirstItem->ItemFill)->IText;
  230.             if (do_menudel())
  231.             break;
  232.         }
  233.         break;
  234.         }
  235.         *mpr = menu->NextMenu;
  236.         free(menu->MenuName);
  237.         free(menu);
  238.         break;
  239.     }
  240.     mpr = &menu->NextMenu;
  241.     }
  242.     menu_on();
  243. }
  244.  
  245. do_menudel()
  246. {
  247.     register MENU *menu;
  248.     register ITEM *item, **ipr;
  249.     register ITEXT *it;
  250.     short ret = 0;
  251.  
  252.     menu_off();
  253.     for (menu = Menu; menu; menu = menu->NextMenu) {
  254.     if (strcmp(av[1], menu->MenuName) == 0) {
  255.         ipr = &menu->FirstItem;
  256.         for (item = *ipr; item; item = *ipr) {
  257.         it = (ITEXT *)item->ItemFill;
  258.         if (strcmp(av[2], it->IText) == 0) {
  259.             *ipr = item->NextItem;
  260.             free(it->IText);
  261.             free(it);
  262.             free(((XITEM *)item)->com);
  263.             free(item);
  264.             if (!menu->FirstItem) {
  265.             do_menudelhdr();
  266.             ret = 1;
  267.             }
  268.             menu_on();
  269.             return(ret);
  270.         }
  271.         ipr = &item->NextItem;
  272.         }
  273.     }
  274.     }
  275.     menu_on();
  276.     return(ret);
  277. }
  278.  
  279.