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