home *** CD-ROM | disk | FTP | other *** search
/ Club Amiga de Montreal - CAM / CAM_CD_1.iso / files / 568b.lha / PowerSource_v3.0 / source.lzh / source / menufunc.c < prev    next >
C/C++ Source or Header  |  1991-09-15  |  13KB  |  415 lines
  1. /*----------------------------------------------------------------------*
  2.     MenuFunc.c version 3.0 - © Copyright 1991 Jaba Development
  3.  
  4.     Author : Jan van den Baard
  5.     Purpose: Menu editing subroutines.
  6.  *----------------------------------------------------------------------*/
  7. extern struct Window        *MainWindow;
  8. extern struct Screen        *MainScreen;
  9. extern struct RastPort      *MainRP;
  10. extern struct MyMenu        *MenuStrip;
  11. extern struct ListItem      *MenusList;
  12. extern struct ListItem      *ItemsList;
  13. extern struct ListItem      *SubsList;
  14. extern struct Screen        *MainScreen;
  15. extern struct RastPort      *MainRP;
  16. extern struct MyMenu        *MenuStrip;
  17. extern struct Gadget        *Gadget;
  18. extern struct MemoryChain    Memory;
  19. extern struct Menu           MainMenuStrip[];
  20. extern struct Menu           ItemMenuStrip[];
  21. extern struct Menu           SubMenuStrip[];
  22. extern struct MenuItem       MainItem[];
  23. extern struct MenuItem       TheItem[];
  24. extern struct MenuItem       SubItem[];
  25. extern struct MenuItem       dummy;
  26. extern struct MyMenu        *ParentMenu;
  27. extern struct MyMenuItem    *ParentItem;
  28.  
  29. extern ULONG                 Class;
  30. extern UWORD                 Code, Qualifier, FrontPen, BackPen;
  31. extern UWORD                 ItemCount, SubCount, MenuCount;
  32. extern UWORD                 ItemTotal, SubTotal, MenuTotal;
  33.  
  34. struct IntuiText *MakeIText( UBYTE *text, ULONG DrMd , ULONG tsize)
  35. {
  36.     struct IntuiText    *IText;
  37.  
  38.     if(NOT(IText = AllocItem(&Memory,(ULONG)sizeof(struct IntuiText),MEMF_PUBLIC)))
  39.         goto NoIMem;
  40.     if(NOT(IText->IText = (UBYTE *)AllocItem(&Memory,tsize,MEMF_PUBLIC)))
  41.         goto NoIMem;
  42.  
  43.     IText->LeftEdge = 1;
  44.     IText->TopEdge  = 1;
  45.     IText->DrawMode = DrMd;
  46.     IText->FrontPen = FrontPen;
  47.     IText->BackPen  = BackPen;
  48.  
  49.     strncpy((char *)IText->IText,(char *)text,tsize);
  50.  
  51.     return(IText);
  52.  
  53. NoIMem:
  54.     if(IText)   FreeItem(&Memory,IText,(ULONG)sizeof(struct IntuiText));
  55.     return(NULL);
  56. }
  57.  
  58. ULONG WidestItem( register struct MyMenuItem *tmp, ULONG MinWidth)
  59. {
  60.     register struct IntuiText   *itext;
  61.     register ULONG               width = MinWidth, w2 = 0L, flg;
  62.  
  63.     for( ; tmp; tmp = tmp->NextItem) {
  64.         itext = (struct IntuiText *)tmp->ItemFill;
  65.         flg   = (ULONG)tmp->Flags;
  66.         w2 = TEXT_WIDTH(MainRP,itext->IText) + TEXTSPACING;
  67.         if(TestBits(flg,CHECKIT))   w2 += 20;
  68.         if(TestBits(flg,COMMSEQ))   w2 += 40;
  69.         if(w2 > width) width = w2;
  70.     }
  71.     return(width);
  72. }
  73.  
  74. struct MyMenu *LastMenu( void )
  75. {
  76.     register struct MyMenu *tmp;
  77.  
  78.     for(tmp = MenuStrip; tmp->NextMenu; tmp = tmp->NextMenu);
  79.  
  80.     return(tmp);
  81. }
  82.  
  83. struct MyMenuItem *LastItem( struct MyMenuItem *first )
  84. {
  85.     for( ; first->NextItem; first = first->NextItem);
  86.  
  87.     return(first);
  88. }
  89.  
  90. ULONG StripWidth( void )
  91. {
  92.     register struct MyMenu *tmp;
  93.  
  94.     if(NOT MenuStrip)   return(NULL);
  95.  
  96.     tmp = LastMenu();
  97.  
  98.     return(tmp->LeftEdge+tmp->Width);
  99. }
  100.  
  101. ULONG ItemHeight( struct MyMenuItem *tmp )
  102. {
  103.     register ULONG height;
  104.  
  105.     tmp = LastItem(tmp);
  106.  
  107.     return(tmp->TopEdge+tmp->Height);
  108. }
  109.  
  110. struct MyMenuItem *FindPredItem( struct MyMenuItem *first, struct MyMenuItem *search )
  111. {
  112.     for( ; first->NextItem != search; first = first->NextItem);
  113.  
  114.     return(first);
  115. }
  116.  
  117. struct MyMenu *FindPredMenu( struct MyMenu *search )
  118. {
  119.     register struct MyMenu *tmp;
  120.  
  121.     for(tmp = MenuStrip; tmp->NextMenu != search; tmp = tmp->NextMenu);
  122.  
  123.     return(tmp);
  124. }
  125.  
  126. void ReformatList( ULONG Type )
  127. {
  128.     register struct ListItem *tmp;
  129.     register WORD             top = 0, i = 0, left = 120;
  130.  
  131.     if(Type == MENUED)
  132.         tmp = MenusList;
  133.     else if(Type == ITEMED)
  134.         tmp = ItemsList;
  135.     else
  136.         tmp = SubsList;
  137.  
  138.     for(i = 0; tmp; tmp = (struct ListItem *)tmp->AItem.NextItem,i++) {
  139.         if(i == 16) { left = 192; top = 0; }
  140.         tmp->AItem.LeftEdge = left;
  141.         tmp->AItem.TopEdge = top;
  142.         top               += 9;
  143.     }
  144. }
  145.  
  146. struct ListItem *CreateListItem( APTR Object, ULONG Type, ULONG Insert, struct ListItem *pred , ULONG remset)
  147. {
  148.     struct MyMenu       *menu;
  149.     struct MyMenuItem   *item;
  150.     struct ListItem     *list, *ll;
  151.     UWORD                count, num = 0;
  152.  
  153.     menu = (struct MyMenu *)Object;
  154.     item = (struct MyMenuItem *)Object;
  155.  
  156.     if((list = (struct ListItem *)AllocItem(&Memory,(ULONG)sizeof(struct ListItem),MEMF_PUBLIC))) {
  157.         if(Type == ITEMED)
  158.             num = ItemCount;
  159.         else if(Type == SUBED)
  160.             num = SubCount;
  161.         else
  162.             num = MenuCount;
  163.  
  164.         if(num > 16)
  165.             list->AItem.LeftEdge = 192;
  166.         else
  167.             list->AItem.LeftEdge = 120;
  168.  
  169.         list->AItem.Width    = 72;
  170.         list->AItem.Height   = 9;
  171.         list->AItem.Flags    = ITEMTEXT+ITEMENABLED+HIGHCOMP;
  172.         list->AItem.ItemFill = (APTR)&list->Text;
  173.  
  174.         list->Text.FrontPen  = 0;
  175.         list->Text.BackPen   = 1;
  176.         list->Text.DrawMode  = JAM2;
  177.         list->Text.LeftEdge  = 1;
  178.         list->Text.TopEdge   = 1;
  179.         list->Text.IText     = &list->Letters[0];
  180.  
  181.         if(Type == MENUED) {
  182.             list->Menu       = menu;
  183.             strncpy((char *)&list->Letters[0],(char *)&menu->TheMenuName[0],9);
  184.             if(NOT Insert) {
  185.                 if(MenusList) {
  186.                     ll = (struct ListItem *)LastItem((struct MyMenuItem *)MenusList);
  187.                     if(num != 17)
  188.                         list->AItem.TopEdge = ll->AItem.TopEdge+ll->AItem.Height;
  189.                     else
  190.                         list->AItem.TopEdge = 0;
  191.                     ll->AItem.NextItem  = &list->AItem;
  192.                 } else {
  193.                     list->AItem.TopEdge = 0;
  194.                     MenusList           = list;
  195.                 }
  196.             } else {
  197.                 if(pred == MenusList) {
  198.                     list->AItem.NextItem = (struct MenuItem *)MenusList;
  199.                     MenusList = list;
  200.                 } else {
  201.                     ll = (struct ListItem *)FindPredItem((struct MyMenuItem *)MenusList,(struct MyMenuItem *)pred);
  202.                     ll->AItem.NextItem = (struct MenuItem *)list;
  203.                     list->AItem.NextItem = (struct MenuItem *)pred;
  204.                 }
  205.                 ReformatList(MENUED);
  206.             }
  207.             if(remset) ClearMenuStrip(MainWindow);
  208.             for(count = 1; count < 5; count++)
  209.                 MainItem[count].SubItem = (struct MenuItem *)MenusList;
  210.             if(remset) {
  211.                 SetMenuStrip(MainWindow,&MainMenuStrip[0]);
  212.                 SetMainMenus();
  213.             }
  214.             return(list);
  215.         } else if(Type == ITEMED) {
  216.             list->Menu       = ParentMenu;
  217.             list->Item       = item;
  218.             strncpy((char *)&list->Letters[0],(char *)((struct IntuiText *)item->ItemFill)->IText,9);
  219.             if(NOT Insert) {
  220.                 if(ItemsList) {
  221.                     ll = (struct ListItem *)LastItem((struct MyMenuItem *)ItemsList);
  222.                     if(num != 17)
  223.                         list->AItem.TopEdge = ll->AItem.TopEdge+ll->AItem.Height;
  224.                     else
  225.                         list->AItem.TopEdge = 0;
  226.                     ll->AItem.NextItem  = &list->AItem;
  227.                 } else {
  228.                     list->AItem.TopEdge = 0;
  229.                     ItemsList           = list;
  230.                 }
  231.             } else {
  232.                 if(pred == ItemsList) {
  233.                     list->AItem.NextItem = (struct MenuItem *)ItemsList;
  234.                     ItemsList = list;
  235.                 } else {
  236.                     ll = (struct ListItem *)FindPredItem((struct MyMenuItem *)ItemsList,(struct MyMenuItem *)pred);
  237.                     ll->AItem.NextItem = (struct MenuItem *)list;
  238.                     list->AItem.NextItem = (struct MenuItem *)pred;
  239.                 }
  240.             }
  241.             if(remset) ClearMenuStrip(MainWindow);
  242.             for(count = 1; count < 5; count++)
  243.                 TheItem[count].SubItem = (struct MenuItem *)ItemsList;
  244.             if(remset) {
  245.                 SetMenuStrip(MainWindow,&ItemMenuStrip[0]);
  246.                 SetMainMenus();
  247.             }
  248.             return(list);
  249.         } else {
  250.             list->Menu       = ParentMenu;
  251.             list->Item       = ParentItem;
  252.             list->SubItem    = item;
  253.             strncpy((char *)&list->Letters[0],(char *)((struct IntuiText *)item->ItemFill)->IText,9);
  254.             if(NOT Insert) {
  255.                 if(SubsList) {
  256.                     ll = (struct ListItem *)LastItem((struct MyMenuItem *)SubsList);
  257.                     if(num != 17)
  258.                         list->AItem.TopEdge = ll->AItem.TopEdge+ll->AItem.Height;
  259.                     else
  260.                         list->AItem.TopEdge = 0;
  261.                     ll->AItem.NextItem  = &list->AItem;
  262.                 } else {
  263.                     list->AItem.TopEdge = 0;
  264.                     SubsList           = list;
  265.                 }
  266.             } else {
  267.                 if(pred == SubsList) {
  268.                     list->AItem.NextItem = (struct MenuItem *)SubsList;
  269.                     SubsList = list;
  270.                 } else {
  271.                     ll = (struct ListItem *)FindPredItem((struct MyMenuItem *)SubsList,(struct MyMenuItem *)pred);
  272.                     ll->AItem.NextItem = (struct MenuItem *)list;
  273.                     list->AItem.NextItem = (struct MenuItem *)pred;
  274.                 }
  275.             }
  276.             if(remset) ClearMenuStrip(MainWindow);
  277.             for(count = 1; count < 4; count++)
  278.                 SubItem[count].SubItem = (struct MenuItem *)SubsList;
  279.             if(remset) {
  280.                 SetMenuStrip(MainWindow,&SubMenuStrip[0]);
  281.                 SetMainMenus();
  282.             }
  283.             return(list);
  284.         }
  285.     }
  286.     return(NULL);
  287. }
  288.  
  289. void FreeMenuItem( struct MyMenuItem *item )
  290. {
  291.     struct IntuiText    *itext;
  292.  
  293.     if((TestBits((ULONG)item->Flags,ITEMTEXT)) && (item->ItemFill)) {
  294.         itext = (struct IntuiText *)item->ItemFill;
  295.         if(itext->IText) FreeItem(&Memory,itext->IText,80L);
  296.         FreeItem(&Memory,itext,(ULONG)sizeof(struct IntuiText));
  297.     }
  298.     if((TestBits((ULONG)item->Flags,HIGHIMAGE+ITEMTEXT)) && (item->SelectFill)) {
  299.         itext = (struct IntuiText *)item->SelectFill;
  300.         if(itext->IText) FreeItem(&Memory,itext->IText,80L);
  301.         FreeItem(&Memory,itext,(ULONG)sizeof(struct IntuiText));
  302.     }
  303.     FreeItem(&Memory,item->ItsListItem,(ULONG)sizeof(struct ListItem));
  304.     FreeItem(&Memory,item,(ULONG)sizeof(struct MyMenuItem));
  305.  
  306. }
  307.  
  308. void FreeMenu( struct MyMenu *menu )
  309. {
  310.     register struct MyMenuItem *i, *i1, *s, *s1;
  311.  
  312.     if(menu->FirstItem != (struct MyMenuItem *)&dummy) {
  313.         if((i = menu->FirstItem)) {
  314.             while(1) {
  315.                 i1 = i->NextItem;
  316.                 if((s = i->SubItem)) {
  317.                     while(1) {
  318.                         s1 = s->NextItem;
  319.                         FreeMenuItem(s);
  320.                         if(NOT(s = s1)) break;
  321.                     }
  322.                 }
  323.                 FreeMenuItem(i);
  324.                 if(NOT(i = i1)) break;
  325.             }
  326.         }
  327.     }
  328.     FreeItem(&Memory,menu->ItsListItem,(ULONG)sizeof(struct ListItem));
  329.     FreeItem(&Memory,menu,(ULONG)sizeof(struct MyMenu));
  330. }
  331.  
  332. void FreeMenuStrip()
  333. {
  334.     register struct MyMenu *m, *m1;
  335.  
  336.     if(NOT(m = MenuStrip)) return;
  337.  
  338.     while(1) {
  339.         m1 = m->NextMenu;
  340.         FreeMenu(m);
  341.         if(NOT(m = m1)) break;
  342.     }
  343.     MenuStrip = NULL;
  344.     MenuCount = MenuTotal = NULL;
  345.     ItemCount = ItemTotal = NULL;
  346.     SubCount  = SubTotal  = NULL;
  347.     MenusList = ItemsList = SubsList = NULL;
  348. }
  349.  
  350. void ReformatS( register struct MyMenuItem *first, WORD left, WORD top, WORD iw)
  351. {
  352.     register WORD tp = 0, le, width;
  353.  
  354.     width = WidestItem( first, 10 );
  355.  
  356.     if((left + width + 10) > MainScreen->Width)
  357.         le = -(width);
  358.     else
  359.         le = iw;
  360.  
  361.     for( ; first; first = first->NextItem ) {
  362.         if(NOT TestBits((ULONG)first->SpecialFlags,USERFORMAT)) {
  363.             first->TopEdge  = tp;
  364.             first->Width    = width;
  365.             first->LeftEdge = le;
  366.             tp += first->Height;
  367.         } else
  368.             tp = first->TopEdge + first->Height;
  369.     }
  370. }
  371.  
  372. void ReformatI( register struct MyMenuItem *first, WORD left , WORD width)
  373. {
  374.     register WORD top = 0, le;
  375.  
  376.     width = WidestItem( first, width );
  377.  
  378.     if((left + width + 10) > MainScreen->Width)
  379.         le = MainScreen->Width - ( left + width + 10 );
  380.     else
  381.         le = 0;
  382.  
  383.     for( ; first; first = first->NextItem ) {
  384.         if(first->SubItem)
  385.             ReformatS( first->SubItem, left + le + width, first->TopEdge, width);
  386.         if(NOT TestBits((ULONG)first->SpecialFlags,USERFORMAT)) {
  387.             first->TopEdge  = top;
  388.             first->Width    = width;
  389.             first->LeftEdge = le;
  390.             top += first->Height;
  391.         } else
  392.             top = first->TopEdge + first->Height;
  393.     }
  394. }
  395.  
  396. void ReformatM( void )
  397. {
  398.     register struct MyMenu  *menu;
  399.     register WORD            left = 0;
  400.  
  401.     for(menu = MenuStrip; menu; menu = menu->NextMenu) {
  402.         if(NOT TestBits((ULONG)menu->SpecialFlags,USERFORMAT)) {
  403.             menu->LeftEdge = left;
  404.             if(menu->FirstItem != (struct MyMenuItem *)&dummy)
  405.                 ReformatI( menu->FirstItem , left , menu->Width);
  406.             left += menu->Width;
  407.         } else {
  408.             left = menu->LeftEdge;
  409.             if(menu->FirstItem != (struct MyMenuItem *)&dummy)
  410.                 ReformatI( menu->FirstItem , left , menu->Width);
  411.             left = menu->Width;
  412.         }
  413.     }
  414. }
  415.