home *** CD-ROM | disk | FTP | other *** search
/ Gold Fish 1 / GoldFishApril1994_CD1.img / d1xx / d122 / iff2pcs / source / popmenu.c < prev    next >
C/C++ Source or Header  |  1987-12-31  |  9KB  |  255 lines
  1. /* PopMenu code by Helene (Lee) Taran, from the Splines program 
  2. ** from Fish disk 97 (which replace disk 57).
  3. */
  4.  
  5. #include <functions.h>
  6. #include "popmenu.h"
  7.  
  8. /* For some reason, someone forgot to include NewLayerInfo() in functions.h...
  9. */
  10. struct Layer_Info *NewLayerInfo();
  11. struct Layer_Info *PopUp_LayerInfo;
  12. struct Font *menufont;
  13.  
  14. /* User should call Init_MenuPackage() before trying to pop up any
  15.  * menus. Will return TRUE if the package has been initialized correctly.
  16.  * Do not attempt to use this package if this initialization routine 
  17.  * returns FALSE.
  18.  */
  19. int Init_MenuPackage()
  20. { 
  21.   static struct TextAttr MenuFont = {(UBYTE *)"topaz.font",8,0,0};
  22.  
  23.   if (!(menufont = OpenFont(&MenuFont))) return (0);
  24.   if (!(PopUp_LayerInfo = (struct Layer_Info *)NewLayerInfo())) return (0);
  25.   return(1);
  26. }
  27.  
  28. /* The user should call Close_MenuPackage before exiting their program
  29.  * to ensure that the menu package releases any memory that it
  30.  * has allocated for its own use. 
  31.  */
  32. Close_MenuPackage()
  33. {
  34.   CloseFont(menufont);
  35.   if (PopUp_LayerInfo != NULL) DisposeLayerInfo(PopUp_LayerInfo);
  36. }
  37.  
  38. int Init_PopUp_Menu (menu)
  39. struct PopUp_Menu *menu;
  40. {
  41.   struct PopUp_Item *item;
  42.   int longest = 0;
  43.   int total_height = 0;
  44.   int i;
  45.  
  46.   if (menu == NULL) return(0);
  47.   item = menu->first_item;
  48.   while (item != NULL) {
  49.     /* note: bad things may happen if you allocate an empty string for
  50.      * your item text.
  51.      */
  52.      item->width = MAX(item->width, FONT_WIDTH * strlen(item->text));
  53.      item->left  = MAX(0,item->left);
  54.      longest = MAX(longest, (item->width + item->left));
  55.      item->height = MAX(item->height, FONT_HEIGHT);
  56.      item->top = MAX(0,item->top);
  57.      total_height += (item->height + item->top);
  58.     /* re-initialize item-top to be the top relative to the menu top */
  59.      item->top = (total_height  - item->height); 
  60.      item = item->next;
  61.   }
  62.   menu->height = total_height+1;
  63.   menu->width  = MAX(menu->width, longest);
  64.   
  65.   /* initialize a bitmap the same size as the required menu image  */
  66.   /* initialize a raster port to facillitate drawing into the bitmap */
  67.   InitBitMap(&(menu->bitmap),
  68.              (long)menu->depth,(long)menu->width,(long)menu->height);
  69.   InitRastPort(&(menu->rp));  
  70.   SetFont(&(menu->rp),menufont);
  71.   for (i = 0; i < menu->depth; i++) 
  72.     if (!(menu->bitmap.Planes[i] = (PLANEPTR) AllocRaster((long)menu->width, (long)menu->height))) {
  73.       Dispose_PopUp(menu); return(0);
  74.     }
  75.   menu->rp.BitMap = &(menu->bitmap); 
  76.   menu->cr.BitMap = &(menu->bitmap);
  77.  
  78.   /* draw the menu outline and background color into its own bitmap */
  79.   SetDrMd(&(menu->rp),JAM1);
  80.   SetAPen(&(menu->rp),(long)menu->area_color);
  81.   SetOPen(&(menu->rp),(long)menu->outline_color);
  82.  
  83.   RectFill(&(menu->rp),0L,0L,menu->width-1L,menu->height-1L);  
  84.   BNDRYOFF(&(menu->rp));  /* turn off the raster port outlining */
  85.  
  86.   item = menu->first_item;  
  87.    
  88.   /* Now, draw each menu item */
  89.   while (item != NULL) {
  90.      SetAPen(&(menu->rp),(long)item->color);
  91.      Move(&(menu->rp),(long)item->left,(long)item->top + FONT_BASELINE);
  92.      Text(&(menu->rp),item->text,(long)strlen(item->text));
  93.      item = item->next;
  94.   }
  95.   return(1);
  96. }
  97.  
  98. /* SelectItem : activates the item located at <x,y>. Assumes the <menu>
  99.  * is currently active and thus, menu->left and menu->top should represent
  100.  * the menu's current top,left corner.  If there is an item located
  101.  * at <x,y> within the menu, then it is made 'active' ...this means
  102.  * that the item becomes menu->active_item and is highlighted. The
  103.  * old menu->active_item, if any, is deselected. Note: if you're using
  104.  * a GIMMEZEROZERO window you'll have to fiddle with the x,y coordinates.
  105.  */
  106. SelectItem(menu,Window)
  107. struct PopUp_Menu *menu;
  108. struct Window *Window;
  109. {  struct PopUp_Item *item;
  110.  
  111.    SHORT x = Window->MouseX + Window->LeftEdge;
  112.    SHORT y = Window->MouseY + Window->TopEdge;
  113.   
  114.    item = menu->first_item;
  115.    x -= menu->left;  y -= menu->top;
  116.    if ((x >= 0) && (x < menu->width) && (y >= 0) && (y < menu->height))
  117.       while (item != NULL) { 
  118.          if ((y >= item->top -1) && (y < item->top -1 + item->height))
  119.              break; /* we found an active item {yeah yeah...bad style, i know...} */
  120.           else item = item->next;
  121.          }
  122.    else item = NULL;    /* mouse isn't on menu */
  123.  
  124.    if (menu->active_item != item) {     /* deselect previously active item */
  125.       ComplementItem(menu,menu->active_item,Window);
  126.       ComplementItem(menu,item,Window);
  127.    }
  128.    menu->active_item = item;
  129. }
  130.        
  131.         
  132.    
  133.          
  134. /* ComplementItem : complements the given menu item area.  Assumes that
  135.  * the <menu> is currently being displayed and thus,the current menu->left
  136.  * and menu->top represent the current coordinates of the menu's top,left
  137.  * corner.  Assumes the <item> is  an popup_item that belongs to <menu>
  138.  * and that its left/top offsets have been initialized.
  139.  */
  140. ComplementItem(menu,item,Window)
  141. struct PopUp_Menu *menu;
  142. struct PopUp_Item *item;
  143. struct Window *Window;
  144. {  BYTE old_mode = Window->WScreen->RastPort.DrawMode;
  145.  
  146.    if (item == NULL) return;  /* do nothing */
  147.    SetDrMd(&(Window->WScreen->RastPort), COMPLEMENT);
  148.    RectFill(&(Window->WScreen->RastPort), (long)menu->left,
  149.                            menu->top +  item->top - 1L,
  150.                            menu->left + menu->width -1L,
  151.                            menu->top +  item->top + item->height - 2L);
  152.    SetDrMd(&(Window->WScreen->RastPort), (long)old_mode);
  153. }
  154.  
  155. /* PopUp : this is one of those 'do everything' type of functions. It
  156.  * displays the <menu> in the window  given its upper left hand 
  157.  * coordinates <left,top>.  It tracks the user's mouse movements,
  158.  * highlighting the currently active item until the user deselects
  159.  * the menu by releasing the mouse's select button, at which time,
  160.  * this function will remove the menu from the display. Returns the
  161.  * selection_id of the item that was active when the user releases
  162.  * the select button. Returns 0 if nothing was selected.
  163.  * Assumes that the <menu> has been initialized by a call to 
  164.  * Init_PopUp_Menu and that the user has requested ReportMouse for the
  165.  * Window in question (ReportMouse makes sure that the Window's MouseX and
  166.  * MouseY coordinates are kept up to date).
  167.  */
  168. int PopUp(menu,Window)
  169. struct PopUp_Menu *menu;
  170. struct Window *Window;
  171. { ULONG oldflags;
  172.   SHORT left, top;
  173.  
  174.   left = Window->MouseX;
  175.   top = Window->MouseY;
  176.   if (!Inside_Window(left,top,Window)) return(OUTSIDE_WINDOW);
  177.  
  178.   if ((menu->width <= Window->Width) && (left + menu->width > Window->Width))
  179.      left += Window->Width - (left + menu->width);
  180.  
  181.   if ((menu->height <= Window->Height) && (top + menu->height > Window->Height))
  182.      top += Window->Height - (top + menu->height);
  183.  
  184.   LockLayers(PopUp_LayerInfo);
  185.   /* SwapBits...() requires that the clipping rectangle's bounds are given
  186.    * with respect to the screen's 0,0 coordinate but mouse movements
  187.    * are reported to the Window and are given in terms of the window's
  188.    * coordinate system so...sLeft and sTop represent the adjustment of
  189.    * the Window's coordinates to match the screen's coordinates.
  190.    * Note: if you're using a GIMMEZEROZERO window, you'll have to muck
  191.    * with the left,top coordinates to get the complementing to work.
  192.    */
  193.   left = (left + Window->LeftEdge) & 0xfff0;
  194.   top =  top + Window->TopEdge;
  195.  
  196.   menu->cr.bounds.MinX = left;    
  197.   menu->cr.bounds.MinY = top;
  198.   menu->cr.bounds.MaxX = left + menu->width -1;
  199.   menu->cr.bounds.MaxY = top + menu->height -1;
  200.  
  201.   SwapBitsRastPortClipRect(Window->RPort,&(menu->cr));
  202.  
  203.   menu->left = left;
  204.   menu->top =  top;
  205.   SelectItem(menu,Window);  
  206. /*
  207. **oldflags = Window->IDCMPFlags;
  208. **ModifyIDCMP(Window,oldflags | MOUSEMOVE);
  209. */
  210.  
  211.   ReportMouse (TRUE, Window);  /* Start telling us about mouse loc */    
  212.  
  213.   while (1)  /* wait for the user to select an item and deselect the menu */
  214.      { struct IntuiMessage msg, *message;
  215.        int MouseMoved = FALSE;
  216.  
  217.        Wait(1L << Window->UserPort->mp_SigBit);
  218.        while (message = (struct IntuiMessage *)GetMsg(Window->UserPort)) { 
  219.             msg = *message;         /* make a backup copy of message */
  220.             ReplyMsg(message);      /* reply immediately to prevent deadlock */
  221.             if (msg.Class == MOUSEMOVE)
  222.                /* just keep track of the fact that the mouse moved */
  223.             MouseMoved = TRUE; 
  224.             else if ((msg.Class == MOUSEBUTTONS) && (msg.Code == menu->deactivate)) {
  225.                 /* user has deselected the menu */
  226.                     ReportMouse (FALSE, Window);  
  227.                     SelectItem(menu,Window);
  228.                     SwapBitsRastPortClipRect(Window->RPort,&(menu->cr));
  229.                     UnlockLayers(PopUp_LayerInfo); 
  230.                     if (menu->active_item != NULL)
  231.                        return(menu->active_item->selection_id);
  232.                     else return(NOITEM_SELECTED);
  233.                 } /* end of deselection routine */
  234.             }
  235.        /* 
  236.         * at this point the message queue should be empty so the mouse
  237.         * has stopped for the moment.
  238.         */
  239.           if (MouseMoved) SelectItem(menu,Window);
  240.       } 
  241. }
  242.  
  243. Dispose_PopUp(menu)
  244. struct PopUp_Menu *menu;
  245. {
  246.   int i;
  247.   for (i = 0; i < menu->depth; i++)
  248.     if (menu->bitmap.Planes[i] != NULL)
  249.        FreeRaster(menu->bitmap.Planes[i], (long)menu->width, (long)menu->height);
  250. }
  251.            
  252.  
  253.      
  254.      
  255.