home *** CD-ROM | disk | FTP | other *** search
/ Amiga Times / AmigaTimes.iso / internet / Term / Extras / Source / gtlayout-source.lha / LTP_Find.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-03-18  |  3.9 KB  |  218 lines
  1. /*
  2. **    GadTools layout toolkit
  3. **
  4. **    Copyright © 1993-1996 by Olaf `Olsen' Barthel
  5. **        Freely distributable.
  6. **
  7. **    :ts=4
  8. */
  9.  
  10. #ifndef _GTLAYOUT_GLOBAL_H
  11. #include "gtlayout_global.h"
  12. #endif
  13.  
  14. LONG
  15. LTP_Find_Clicked_Item(LayoutHandle *handle,ObjectNode *radio,LONG x,LONG y)
  16. {
  17.     if(x >= radio->Left + INTERWIDTH)
  18.     {
  19.         LONG i,top = radio->Top,height,single;
  20.  
  21.         height = ((radio->Height + handle->InterHeight) / radio->Lines);
  22.         single = height - handle->InterHeight;
  23.  
  24.         for(i = 0 ; i <= radio->Max ; i++)
  25.         {
  26.             if(y >= top && y < top + single)
  27.                 return(i);
  28.             else
  29.                 top += height;
  30.         }
  31.     }
  32.  
  33.     return(-1);
  34. }
  35.  
  36.  
  37. /*****************************************************************************/
  38.  
  39.  
  40. ObjectNode *
  41. LTP_FindNode_Position(ObjectNode *group,LONG x,LONG y)
  42. {
  43.     ObjectNode    *node;
  44.     ULONG         page;
  45.  
  46.     SCANPAGE(group,node,page)
  47.     {
  48.         if(node->Type == GROUP_KIND)
  49.         {
  50.             ObjectNode *result;
  51.  
  52.             if(result = LTP_FindNode_Position(node,x,y))
  53.                 return(result);
  54.             else
  55.             {
  56.                 if(node->Top <= y && node->Top + node->Height > y && node->Left <= x && node->Left + node->Width > x)
  57.                 {
  58.                     while(node)
  59.                     {
  60.                         if(node->ID <= PHANTOM_GROUP_ID)
  61.                             node = node->Special.Group.ParentGroup;
  62.                         else
  63.                             return(node);
  64.                     }
  65.  
  66.                     return(NULL);
  67.                 }
  68.             }
  69.         }
  70.         else
  71.         {
  72.             if(node->Top <= y && node->Top + node->Height > y)
  73.             {
  74.                 switch(node->Type)
  75.                 {
  76.                     case CHECKBOX_KIND:
  77.  
  78.                         if(node->LabelPlace == PLACE_LEFT)
  79.                         {
  80.                             if(node->Left - (node->LabelWidth + INTERWIDTH) <= x && node->Left - INTERWIDTH > x)
  81.                                 return(node);
  82.                         }
  83.                         else
  84.                         {
  85.                             if(node->Left + node->Width + INTERWIDTH <= x && node->Left + node->Width + INTERWIDTH + node->LabelWidth > x)
  86.                                 return(node);
  87.                         }
  88.  
  89.                         break;
  90.  
  91.                     case MX_KIND:
  92.  
  93.                         if(node->Left + node->Width + INTERWIDTH <= x && node->Left + node->Width + INTERWIDTH + node->Special.Radio.LabelWidth > x)
  94.                             return(node);
  95.  
  96.                         break;
  97.  
  98.                     default:
  99.  
  100.                         if(node->Left <= x && node->Left + node->Width > x)
  101.                         {
  102.                             switch(node->Type)
  103.                             {
  104.                                 case PICKER_KIND:
  105.  
  106.                                     return(node->Special.Picker.Parent->UserData);
  107.  
  108.                                 case INCREMENTER_KIND:
  109.  
  110.                                     return(node->Special.Incrementer.Parent->UserData);
  111.  
  112.                                 default:
  113.  
  114.                                     return(node);
  115.                             }
  116.                         }
  117.                 }
  118.             }
  119.         }
  120.     }
  121.  
  122.     return(NULL);
  123. }
  124.  
  125.  
  126. /*****************************************************************************/
  127.  
  128. STATIC ObjectNode *
  129. LTP_FindGroupNode(ObjectNode *group,LONG id)
  130. {
  131.     ObjectNode *node;
  132.     ObjectNode *result;
  133.  
  134.     SCANGROUP(group,node)
  135.     {
  136.         switch(node->Type)
  137.         {
  138.             case INCREMENTER_KIND:
  139.             case PICKER_KIND:
  140.  
  141.                 break;
  142.  
  143.             case GROUP_KIND:
  144.  
  145.                 if(node->ID == id)
  146.                     return(node);
  147.                 else
  148.                 {
  149.                     if(result = LTP_FindGroupNode(node,id))
  150.                         return(result);
  151.                 }
  152.  
  153.                 break;
  154.  
  155.             default:
  156.  
  157.                 if(node->ID == id)
  158.                     return(node);
  159.         }
  160.     }
  161.  
  162.     return(NULL);
  163. }
  164.  
  165. ObjectNode *
  166. LTP_FindNode(LayoutHandle *handle,LONG id)
  167. {
  168.     return(LTP_FindGroupNode(handle->TopGroup,id));
  169. }
  170.  
  171. /*****************************************************************************/
  172.  
  173.     // This is the new and improved gadget search routine. It now does a
  174.     // binary search rather than the linear search it used to do. Works
  175.     // much better with large number of gadgets, but requires the gadget
  176.     // pointers to be sorted in the order of the GadgetID entries.
  177.  
  178. struct Gadget *
  179. LTP_FindGadget(LayoutHandle *handle,LONG id)
  180. {
  181.     if(handle->GadgetArray)
  182.     {
  183.         struct Gadget **Tab;
  184.         LONG Left,Mid,Right;
  185.  
  186.         Tab        = handle->GadgetArray;
  187.         Left    = 0;
  188.         Right    = handle->Index - 1;
  189.  
  190.         do
  191.         {
  192.             Mid = (Left + Right) / 2;
  193.  
  194.             if(id < Tab[Mid]->GadgetID)
  195.                 Right    = Mid - 1;
  196.             else
  197.                 Left    = Mid + 1;
  198.         }
  199.         while(id != Tab[Mid]->GadgetID && Left <= Right);
  200.  
  201.         if(id == Tab[Mid]->GadgetID)
  202.         {
  203.             ObjectNode *node;
  204.             struct Gadget *g;
  205.  
  206.             g = Tab[Mid];
  207.  
  208.             if(node = (ObjectNode *)g->UserData)
  209.             {
  210.                 if(node->PointBack == node && node->Host == g)
  211.                     return(g);
  212.             }
  213.         }
  214.     }
  215.  
  216.     return(NULL);
  217. }
  218.