home *** CD-ROM | disk | FTP | other *** search
/ Amiga ISO Collection / AmigaUtilCD2.iso / Programming / C / OTL-MC7.DMS / in.adf / classsource.lha / ClassSource / BOOPSI / gadgets / slider.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-02-12  |  11.2 KB  |  475 lines
  1. #include <classes/BOOPSI/gadgets.h>
  2. #include <classes/BOOPSI/boopsilib.h>
  3.  
  4. #include <intuition/icclass.h>
  5.  
  6. #pragma -
  7. #include <pragma/utility_lib.h>
  8. #include <clib/alib_protos.h>
  9. #include <pragma/intuition_lib.h>
  10. #include <pragma/graphics_lib.h>
  11. #pragma +
  12.  
  13. struct InstanceData {
  14.     struct TextAttr *tattr;
  15.     struct TextFont *font;
  16.     ULONG labelplace;
  17.     ULONG valueplace;
  18.     UWORD min;
  19.     UWORD max;
  20.     ULONG freedom;
  21.     Object *prop;
  22.     Object *frame;
  23.     WORD leftborder;
  24.     WORD rightborder;
  25.     WORD topborder;
  26.     WORD bottomborder;
  27. };
  28.  
  29. SliderClass::SliderClass()
  30.     : BoopsiClass(sizeof(struct InstanceData),(ULONG (*)()) &dispatcher,GADGETCLASS,NULL)
  31. {
  32. }
  33.  
  34. ULONG SliderClass::dispatcher(Class *cl, Object *o, Msg msg)
  35. {
  36.     struct InstanceData *data;
  37.     ULONG retval = FALSE;
  38.     switch (msg->MethodID)
  39.     {
  40.         case OM_NEW:
  41.         {
  42.             Object *object;
  43.             if (object = (Object *) DoSuperMethodA(cl,o,msg))
  44.             {
  45.                 data = (struct InstanceData *) INST_DATA(cl,object);
  46.                 data->tattr = NULL;
  47.                 data->font = NULL;
  48.                 data->labelplace = 0;
  49.                 data->valueplace = 0;
  50.                 data->min = 0;
  51.                 data->max = 65535;
  52.                 data->freedom = FREEVERT;
  53.                 WORD otop = 0;
  54.                 WORD oleft = 0;
  55.                 WORD oheight = 0;
  56.                 WORD owidth = 0;
  57.                 UWORD olevel = 0;
  58.                 TagItemCursorC tic(((struct opSet *) msg)->ops_AttrList);
  59.                 while (!tic.isDone()) {
  60.                     /* register */ ULONG ticData = tic.itemData();
  61.                     switch (tic.itemTag())
  62.                     {
  63.                         case GA_Top:
  64.                             otop = (WORD) ticData;
  65.                             break;
  66.                         case GA_Left:
  67.                             oleft = (WORD) ticData;
  68.                             break;
  69.                         case GA_Width:
  70.                             owidth = (WORD) ticData;
  71.                             break;
  72.                         case GA_Height:
  73.                             oheight = (WORD) ticData;
  74.                             break;
  75.                         case SLA_Font:
  76.                             data->tattr = (struct TextAttr *) ticData;
  77.                             break;
  78.                         case SLA_ValuePlace:
  79.                             break;
  80.                         case SLA_LabelPlace:
  81.                             break;
  82.                         case SLA_Min:
  83.                             data->min = (UWORD) ticData;
  84.                             break;
  85.                         case SLA_Max:
  86.                             data->max = (UWORD) ticData;
  87.                             break;
  88.                         case SLA_Level:
  89.                             olevel = (UWORD) ticData;
  90.                             break;
  91.                         case SLA_Freedom:
  92.                             data->freedom = (ULONG) ticData;
  93.                             break;
  94.                         default:
  95.                             break;
  96.                     };
  97.                     tic.next();
  98.                 };
  99.                 calcBorders(cl,(struct Gadget *) object, data);
  100.                 data->prop = (Object *) NewObject(NULL,PROPGCLASS,
  101.                     GA_Top, otop + 2,
  102.                     GA_Left, oleft + 2,
  103.                     GA_Width, owidth - 4,
  104.                     GA_Height, oheight - 4,
  105.                     PGA_Borderless, TRUE,
  106.                     PGA_Freedom, data->freedom,
  107.                     PGA_NewLook, FALSE,
  108.                     PGA_Top, olevel - data->min,
  109.                     PGA_Visible, 1,
  110.                     PGA_Total, data->max - data->min + 1,
  111.                     ICA_TARGET, object,
  112.                     TAG_END);
  113.                 data->frame = (Object *) NewObject(NULL,FRAMEICLASS,
  114.                     IA_Top, otop,
  115.                     IA_Left, oleft,
  116.                     IA_Width, owidth,
  117.                     IA_Height, oheight,
  118.                     IA_Recessed, FALSE,
  119.                     IA_EdgesOnly, TRUE,
  120.                     TAG_END);
  121.                 if (data->tattr)
  122.                     data->font = OpenFont(data->tattr);
  123.                 retval = (ULONG) object;
  124.             };
  125.             break;
  126.         };
  127.         case OM_DISPOSE:
  128.         {
  129.             data = (struct InstanceData *) INST_DATA(cl,o);
  130.             if (data->prop)
  131.             {
  132.                 DisposeObject(data->prop);
  133.             };
  134.             if (data->font)
  135.                 CloseFont(data->font);
  136.             retval = DoSuperMethodA(cl,o,msg);
  137.             break;
  138.         };
  139.         case OM_GET:
  140.         {
  141.             data = (struct InstanceData *) INST_DATA(cl,o);
  142.             switch (((struct opGet *) msg)->opg_AttrID)
  143.             {
  144.                 case GA_Left:
  145.                     *(((struct opGet *) msg)->opg_Storage) = ((struct Gadget *) o)->LeftEdge;
  146.                     retval = TRUE;
  147.                     break;
  148.                 case GA_Top:
  149.                     *(((struct opGet *) msg)->opg_Storage) = ((struct Gadget *) o)->TopEdge;
  150.                     retval = TRUE;
  151.                     break;
  152.                 case GA_Width:
  153.                     *(((struct opGet *) msg)->opg_Storage) = ((struct Gadget *) o)->Width;
  154.                     retval = TRUE;
  155.                     break;
  156.                 case GA_Height:
  157.                     *(((struct opGet *) msg)->opg_Storage) = ((struct Gadget *) o)->Height;
  158.                     retval = TRUE;
  159.                     break;
  160.                 case SLA_Font:
  161.                     *(((struct opGet *) msg)->opg_Storage) = (ULONG) data->tattr;
  162.                     retval = TRUE;
  163.                     break;
  164.                 case SLA_ValuePlace:
  165.                     *(((struct opGet *) msg)->opg_Storage) = (ULONG) data->valueplace;
  166.                     retval = TRUE;
  167.                     break;
  168.                 case SLA_LabelPlace:
  169.                     *(((struct opGet *) msg)->opg_Storage) = (ULONG) data->labelplace;
  170.                     retval = TRUE;
  171.                     break;
  172.                 case SLA_Min:
  173.                     *(((struct opGet *) msg)->opg_Storage) = (ULONG) data->min;
  174.                     retval = TRUE;
  175.                     break;
  176.                 case SLA_Max:
  177.                     *(((struct opGet *) msg)->opg_Storage) = (ULONG) data->max;
  178.                     retval = TRUE;
  179.                     break;
  180.                 case SLA_Level:
  181.                     if (data->prop)
  182.                     {
  183.                         ULONG level;
  184.                         GetAttr(PGA_Top, data->prop, &level);
  185.                         *(((struct opGet *) msg)->opg_Storage) = level + data->min;
  186.                     }
  187.                     else
  188.                         *(((struct opGet *) msg)->opg_Storage) = (ULONG) 0;
  189.                     retval = TRUE;
  190.                     break;
  191.                 case SLA_LeftBorder:
  192.                     *(((struct opGet *) msg)->opg_Storage) = (ULONG) data->leftborder;
  193.                     retval = TRUE;
  194.                     break;
  195.                 case SLA_RightBorder:
  196.                     *(((struct opGet *) msg)->opg_Storage) = (ULONG) data->rightborder;
  197.                     retval = TRUE;
  198.                     break;
  199.                 case SLA_TopBorder:
  200.                     *(((struct opGet *) msg)->opg_Storage) = (ULONG) data->topborder;
  201.                     retval = TRUE;
  202.                     break;
  203.                 case SLA_BottomBorder:
  204.                     *(((struct opGet *) msg)->opg_Storage) = (ULONG) data->bottomborder;
  205.                     retval = TRUE;
  206.                     break;
  207.                 case SLA_AutoWidth:
  208.                     *(((struct opGet *) msg)->opg_Storage) =
  209.                         (ULONG) calcWidth(cl,(struct Gadget *) o, data);
  210.                     retval = TRUE;
  211.                     break;
  212.                 case SLA_AutoHeight:
  213.                     *(((struct opGet *) msg)->opg_Storage) =
  214.                         (ULONG) calcHeight(cl,(struct Gadget *) o, data);
  215.                     retval = TRUE;
  216.                     break;
  217.                 case SLA_Freedom:
  218.                     *(((struct opGet *) msg)->opg_Storage) = (ULONG) data->freedom;
  219.                     retval = TRUE;
  220.                     break;
  221.                 default:
  222.                     retval = DoSuperMethodA(cl,o,msg);
  223.                     break;
  224.             };
  225.             break;
  226.         };
  227.         case OM_SET:
  228.         {
  229.             data = (struct InstanceData *) INST_DATA(cl,o);
  230.             TagItemCursorC tic(((struct opSet *) msg)->ops_AttrList);
  231.             ULONG olevel = 0;
  232.             if (data->prop)
  233.                 GetAttr(PGA_Top, data->prop, &olevel);
  234.             BOOL newProp = FALSE;
  235.             while (!tic.isDone()) {
  236.                 /* register */ ULONG ticData = tic.itemData();
  237.                 switch (tic.itemTag())
  238.                 {
  239.                     case GA_Top:
  240.                         newProp = TRUE;
  241.                         break;
  242.                     case GA_Left:
  243.                         newProp = TRUE;
  244.                         break;
  245.                     case GA_Width:
  246.                         newProp = TRUE;
  247.                         break;
  248.                     case GA_Height:
  249.                         newProp = TRUE;
  250.                         break;
  251.                     case SLA_Font:
  252.                         if (data->font)
  253.                         {
  254.                             CloseFont(data->font);
  255.                             data->font = NULL;
  256.                         };
  257.                         data->tattr = (struct TextAttr *) ticData;
  258.                         if (data->tattr)
  259.                             data->font = OpenFont(data->tattr);
  260.                         calcBorders(cl,(struct Gadget *) o, data);
  261.                         break;
  262.                     case SLA_Min:
  263.                         data->min = (UWORD) ticData;
  264.                         newProp = TRUE;
  265.                         break;
  266.                     case SLA_Max:
  267.                         data->max = (UWORD) ticData;
  268.                         newProp = TRUE;
  269.                         break;
  270.                     case SLA_Level:
  271.                         olevel = (ULONG) ticData;
  272.                         newProp = TRUE;
  273.                         break;
  274.                     default:
  275.                         break;
  276.                 };
  277.                 tic.next();
  278.             };
  279.             retval = DoSuperMethodA(cl,o,msg);
  280.             if (newProp && data->prop)
  281.             {
  282.                 SetGInfoAttrs(data->prop,((struct opSet *) msg)->ops_GInfo,
  283.                     GA_Left, ((struct Gadget *) o)->LeftEdge + 2,
  284.                     GA_Top, ((struct Gadget *) o)->TopEdge + 2,
  285.                     GA_Width, ((struct Gadget *) o)->Width - 4,
  286.                     GA_Height, ((struct Gadget *) o)->Height - 4,
  287.                     PGA_Top, olevel - data->min,
  288.                     PGA_Visible, 1,
  289.                     PGA_Total, data->max - data->min + 1,
  290.                     TAG_END);
  291.             };
  292.             break;
  293.         };
  294.         case OM_UPDATE:
  295.         {
  296.             data = (struct InstanceData *) INST_DATA(cl,o);
  297.             TagItemCursorC tic(((struct opSet *) msg)->ops_AttrList);
  298.             ULONG olevel = 0;
  299.             if (data->prop)
  300.                 GetAttr(PGA_Top, data->prop, &olevel);
  301.             BOOL newProp = FALSE;
  302.             while (!tic.isDone()) {
  303.                 /* register */ ULONG ticData = tic.itemData();
  304.                 switch (tic.itemTag())
  305.                 {
  306.                     case PGA_Top:
  307.                     {
  308.                         struct TagItem tt[2];
  309.                         tt[0].ti_Tag = SLA_Level;
  310.                         tt[0].ti_Data = ticData + data->min;
  311.                         tt[1].ti_Tag = TAG_END;
  312.                         DoMethod(o,OM_NOTIFY,tt,((struct opSet *) msg)->ops_GInfo,0);
  313.                         break;
  314.                     };
  315.                     case SLA_Min:
  316.                         data->min = (UWORD) ticData;
  317.                         newProp = TRUE;
  318.                         break;
  319.                     case SLA_Max:
  320.                         data->max = (UWORD) ticData;
  321.                         newProp = TRUE;
  322.                         break;
  323.                     case SLA_Level:
  324.                         olevel = (ULONG) ticData;
  325.                         newProp = TRUE;
  326.                         break;
  327.                     default:
  328.                         break;
  329.                 };
  330.                 tic.next();
  331.             };
  332.             if (newProp && data->prop)
  333.             {
  334.                 SetGInfoAttrs(data->prop,((struct opSet *) msg)->ops_GInfo,
  335.                     PGA_Top, olevel - data->min,
  336.                     PGA_Visible, 1,
  337.                     PGA_Total, data->max - data->min + 1,
  338.                     TAG_END);
  339.             };
  340.             break;
  341.         };
  342.         case GM_RENDER:
  343.         {
  344.             data = (struct InstanceData *) INST_DATA(cl,o);
  345.             retval = render(cl,(struct Gadget *) o,
  346.                 (struct gpRender *) msg,data);
  347.             break;
  348.         };
  349.         case GM_HITTEST:
  350.         {
  351.             retval = GMR_GADGETHIT;
  352.             break;
  353.         };
  354.         case GM_GOACTIVE:
  355.         {
  356.             data = (struct InstanceData *) INST_DATA(cl,o);
  357.             ((struct Gadget *) o)->Flags |= GFLG_SELECTED;
  358.             if (data->prop)
  359.             {
  360.                 struct gpInput *gpi = (struct gpInput *) msg;
  361.                 if (gpi->gpi_Mouse.X >= 2 &&
  362.                     gpi->gpi_Mouse.X < ((struct Gadget *) o)->Width - 4 &&
  363.                     gpi->gpi_Mouse.Y >= 2 &&
  364.                     gpi->gpi_Mouse.Y < ((struct Gadget *) o)->Height - 4)
  365.                 {
  366.                     gpi->gpi_Mouse.X -= 2;
  367.                     gpi->gpi_Mouse.Y -= 2;
  368.                     retval = DoMethodA(data->prop,(Msg) msg);
  369.                 }
  370.                 else
  371.                     retval = GMR_NOREUSE;
  372.             };
  373.             break;
  374.         };
  375.         case GM_GOINACTIVE:
  376.         {
  377.             data = (struct InstanceData *) INST_DATA(cl,o);
  378.             if (data->prop)
  379.                 retval = DoMethodA(data->prop,(Msg) msg);
  380.             ((struct Gadget *) o)->Flags &= ~GFLG_SELECTED;
  381.             break;
  382.         };
  383.         case GM_HANDLEINPUT:
  384.         {
  385.             data = (struct InstanceData *) INST_DATA(cl,o);
  386.             if (data->prop)
  387.             {
  388.                 struct gpInput *gpi = (struct gpInput *) msg;
  389.                 gpi->gpi_Mouse.X -= 2;
  390.                 gpi->gpi_Mouse.Y -= 2;
  391.                 retval = DoMethodA(data->prop,(Msg) msg);
  392.             };
  393.             break;
  394.         };
  395.         default:
  396.         {
  397.             retval = DoSuperMethodA(cl,o,msg);
  398.             break;
  399.         };
  400.     };
  401.     return retval;
  402. }
  403.  
  404. ULONG SliderClass::render(Class *cl, struct Gadget *g,
  405.     struct gpRender *msg, struct InstanceData *data)
  406. {
  407.     struct RastPort *rp;
  408.     struct GadgetInfo *ginfo;
  409.     if (msg->MethodID == OM_SET || msg->MethodID == OM_UPDATE)
  410.         ginfo = ((struct opSet *) msg)->ops_GInfo
  411.     else
  412.         ginfo = msg->gpr_GInfo;
  413.     if (!ginfo)
  414.         return TRUE;
  415.     UWORD *pens = ginfo->gi_DrInfo->dri_Pens;
  416.     if (msg->MethodID == GM_RENDER)
  417.         rp = msg->gpr_RPort
  418.     else
  419.         rp = ObtainGIRPort(ginfo);
  420.     if (rp)
  421.     {
  422.         if (data->frame)
  423.         {
  424.             SetAttrs(data->frame,
  425.                 IA_Left,g->LeftEdge,
  426.                 IA_Top,g->TopEdge,
  427.                 IA_Width,g->Width,
  428.                 IA_Height,g->Height,
  429.                 TAG_END);
  430.             DrawImageState(rp,(struct Image *) data->frame,
  431.                     0, 0, IDS_NORMAL,ginfo->gi_DrInfo);
  432.         };
  433.         if (data->prop)
  434.         {
  435.             DoMethodA(data->prop,(Msg) msg);
  436.         };
  437.         if (msg->MethodID != GM_RENDER)
  438.             ReleaseGIRPort(rp);
  439.         return TRUE;
  440.     };
  441.     return FALSE;
  442. }
  443.  
  444. VOID SliderClass::calcBorders(Class *cl, struct Gadget *g,
  445.         struct InstanceData *data)
  446. {
  447.     data->leftborder = 0;
  448.     data->rightborder = 0;
  449.     data->topborder = 0;
  450.     data->bottomborder = 0;
  451. }
  452.  
  453. WORD SliderClass::calcWidth(Class *cl, struct Gadget *g,
  454.         struct InstanceData *data)
  455. {
  456.     if (data->freedom == FREEVERT)
  457.         return 15;
  458.     return (data->max - data->min + 1) * 8;
  459. }
  460.  
  461. WORD SliderClass::calcHeight(Class *cl, struct Gadget *g,
  462.         struct InstanceData *data)
  463. {
  464.     if (data->freedom == FREEHORIZ)
  465.         return 13;
  466.     return (data->max - data->min + 1) * 8;
  467. }
  468.  
  469. // *************************************************************
  470.  
  471. SliderClass BSliderC::sc;
  472.  
  473. // *************************************************************
  474.  
  475.