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