home *** CD-ROM | disk | FTP | other *** search
/ Amiga ISO Collection / AmigaUtilCD2.iso / Programming / C / OTL-MC7.DMS / in.adf / classsource.lha / ClassSource / BOOPSI / gadgets / cycle.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-02-12  |  17.9 KB  |  769 lines
  1. #include <classes/BOOPSI/gadgets.h>
  2. #include <classes/BOOPSI/boopsilib.h>
  3.  
  4. #include <intuition/imageclass.h>
  5. #include <classes/boopsi/popupmenuclass.h>
  6. #include <string.h>
  7. #include <exec/memory.h>
  8.  
  9. #pragma -
  10. #include <pragma/utility_lib.h>
  11. #include <clib/alib_protos.h>
  12. #include <pragma/intuition_lib.h>
  13. #include <pragma/graphics_lib.h>
  14. #include <pragma/layers_lib.h>
  15. #include <pragma/exec_lib.h>
  16. #include <graphics/gfxmacros.h>
  17. #pragma +
  18.  
  19. struct InstanceData {
  20.     STRPTR *labels;
  21.     UWORD active;
  22.     struct TextAttr *tattr;
  23.     ULONG minmenu;
  24.     ULONG columns;
  25.     ULONG labelplace;
  26.     UBYTE labelmark;
  27.     UBYTE pad;
  28. // private:
  29.     Object *frame;
  30.     Object *menu;
  31.     struct TextFont *font;
  32.     BOOL menushown;
  33.     UWORD labelCount;
  34.     WORD leftborder;
  35.     WORD rightborder;
  36.     WORD bottomborder;
  37.     WORD topborder;
  38.     struct LabelText *label;
  39. };
  40.  
  41. #define MENULEFT 21
  42.  
  43. CycleClass::CycleClass()
  44.     : BoopsiClass(sizeof(struct InstanceData),(ULONG (*)()) &dispatcher,GADGETCLASS,NULL)
  45. {
  46. }
  47.  
  48. ULONG CycleClass::dispatcher(Class *cl, Object *o, Msg msg)
  49. {
  50.     struct InstanceData *data;
  51.     ULONG retval = FALSE;
  52.     switch (msg->MethodID)
  53.     {
  54.         case OM_NEW:
  55.         {
  56.             Object *object;
  57.             if (object = (Object *) DoSuperMethodA(cl,o,msg))
  58.             {
  59.                 data = (struct InstanceData *) INST_DATA(cl,object);
  60.                 LONG oleft = 0;
  61.                 LONG owidth = 1;
  62.                 LONG otop = 0;
  63.                 LONG oheight = 1;
  64.                 data->labels = NULL;
  65.                 data->active = 0;
  66.                 data->tattr = NULL;
  67.                 data->minmenu = 3;
  68.                 data->font = NULL;
  69.                 data->labelCount = 0;
  70.                 data->columns = 0;
  71.                 data->labelplace = CY_LabelLeft;
  72.                 data->labelmark = '_';
  73.                 TagItemCursorC tic(((struct opSet *) msg)->ops_AttrList);
  74.                 while (!tic.isDone()) {
  75.                     /* register */ ULONG ticData = tic.itemData();
  76.                     switch (tic.itemTag())
  77.                     {
  78.                         case GA_Left:
  79.                             oleft = ticData;
  80.                             break;
  81.                         case GA_Width:
  82.                             owidth = ticData;
  83.                             break;
  84.                         case GA_Top:
  85.                             otop = ticData;
  86.                             break;
  87.                         case GA_Height:
  88.                             oheight = ticData;
  89.                             break;
  90.                         case CYA_Labels:
  91.                             data->labels = (STRPTR *) ticData;
  92.                             break;
  93.                         case CYA_Active:
  94.                             data->active = (UWORD) ticData;
  95.                             break;
  96.                         case CYA_Font:
  97.                             data->tattr = (struct TextAttr *) ticData;
  98.                             break;
  99.                         case CYA_MinMenu:
  100.                             data->minmenu = (ULONG) ticData;
  101.                             break;
  102.                         case CYA_Columns:
  103.                             data->columns = (ULONG) ticData;
  104.                             break;
  105.                         case CYA_LabelPlace:
  106.                             data->labelplace = (ULONG) ticData;
  107.                             break;
  108.                         case CYA_LabelMark:
  109.                             data->labelmark = (UBYTE) ticData;
  110.                             break;
  111.                         default:
  112.                             break;
  113.                     };
  114.                     tic.next();
  115.                 };
  116.                 data->frame = (Object *) NewObject(NULL,FRAMEICLASS,
  117.                     IA_Left, oleft,
  118.                     IA_Top, otop,
  119.                     IA_Width, owidth,
  120.                     IA_Height, oheight,
  121.                     IA_EdgesOnly, FALSE,
  122.                     IA_Recessed, FALSE,
  123.                     IA_FrameType, FRAME_BUTTON,
  124.                     TAG_END);
  125.                 data->menu = (Object *) NewObject(
  126.                     BPopupMenuC::boopsiclass()->boopsiclass(),NULL,
  127.                     GA_Left, oleft + MENULEFT,
  128.                     GA_Top, otop,
  129.                     GA_Width, owidth - MENULEFT,
  130.                     GA_Height, oheight,
  131.                     MA_Labels, data->labels,
  132.                     MA_Font, data->tattr,
  133.                     TAG_END);
  134.                 if (data->tattr)
  135.                 {
  136.                     data->font = OpenFont(data->tattr);
  137.                 };
  138.                 if (data->labels)
  139.                 {
  140.                     int i = 0;
  141.                     while (data->labels[i]) {
  142.                         i++;
  143.                     };
  144.                     data->labelCount = i;
  145.                 };
  146.                 if (data->active >= data->labelCount)
  147.                 {
  148.                     data->active = 0;
  149.                 };
  150.                 data->label = AllocLText(
  151.                     (STRPTR) ((struct Gadget *) object)->GadgetText,
  152.                     data->tattr,1,0,JAM2,data->labelmark);
  153.                 calcBorders(cl,(struct Gadget *) object, data);
  154.                 retval = (ULONG) object;
  155.             };
  156.             break;
  157.         };
  158.         case OM_DISPOSE:
  159.         {
  160.             data = (struct InstanceData *) INST_DATA(cl,o);
  161.             if (data->frame)
  162.             {
  163.                 DisposeObject(data->frame);
  164.             };
  165.             if (data->font)
  166.             {
  167.                 CloseFont(data->font);
  168.             };
  169.             FreeLText(data->label);
  170.             retval = DoSuperMethodA(cl,o,msg);
  171.             break;
  172.         };
  173.         case OM_GET:
  174.         {
  175.             data = (struct InstanceData *) INST_DATA(cl,o);
  176.             switch (((struct opGet *) msg)->opg_AttrID)
  177.             {
  178.                 case GA_Left:
  179.                     *(((struct opGet *) msg)->opg_Storage) = ((struct Gadget *) o)->LeftEdge;
  180.                     retval = TRUE;
  181.                     break;
  182.                 case GA_Top:
  183.                     *(((struct opGet *) msg)->opg_Storage) = ((struct Gadget *) o)->TopEdge;
  184.                     retval = TRUE;
  185.                     break;
  186.                 case GA_Width:
  187.                     *(((struct opGet *) msg)->opg_Storage) = ((struct Gadget *) o)->Width;
  188.                     retval = TRUE;
  189.                     break;
  190.                 case GA_Height:
  191.                     *(((struct opGet *) msg)->opg_Storage) = ((struct Gadget *) o)->Height;
  192.                     retval = TRUE;
  193.                     break;
  194.                 case CYA_Font:
  195.                     *(((struct opGet *) msg)->opg_Storage) = (ULONG) data->tattr;
  196.                     retval = TRUE;
  197.                     break;
  198.                 case CYA_Labels:
  199.                     *(((struct opGet *) msg)->opg_Storage) = (ULONG) data->labels;
  200.                     retval = TRUE;
  201.                     break;
  202.                 case CYA_Active:
  203.                     *(((struct opGet *) msg)->opg_Storage) = (ULONG) data->active;
  204.                     retval = TRUE;
  205.                     break;
  206.                 case CYA_LeftBorder:
  207.                     *(((struct opGet *) msg)->opg_Storage) = (ULONG) data->leftborder;
  208.                     retval = TRUE;
  209.                     break;
  210.                 case CYA_RightBorder:
  211.                     *(((struct opGet *) msg)->opg_Storage) = (ULONG) data->rightborder;
  212.                     retval = TRUE;
  213.                     break;
  214.                 case CYA_TopBorder:
  215.                     *(((struct opGet *) msg)->opg_Storage) = (ULONG) data->topborder;
  216.                     retval = TRUE;
  217.                     break;
  218.                 case CYA_BottomBorder:
  219.                     *(((struct opGet *) msg)->opg_Storage) = (ULONG) data->bottomborder;
  220.                     retval = TRUE;
  221.                     break;
  222.                 case CYA_AutoWidth:
  223.                     *(((struct opGet *) msg)->opg_Storage) =
  224.                         calcWidth(cl,(struct Gadget *) o,data);
  225.                     retval = TRUE;
  226.                     break;
  227.                 case CYA_AutoHeight:
  228.                     *(((struct opGet *) msg)->opg_Storage) =
  229.                         calcHeight(cl,(struct Gadget *) o,data);
  230.                     retval = TRUE;
  231.                     break;
  232.                 case CYA_Columns:
  233.                     *(((struct opGet *) msg)->opg_Storage) = (ULONG) data->columns;
  234.                     retval = TRUE;
  235.                     break;
  236.                 case CYA_MinMenu:
  237.                     *(((struct opGet *) msg)->opg_Storage) = (ULONG) data->minmenu;
  238.                     retval = TRUE;
  239.                     break;
  240.                 case CYA_LabelPlace:
  241.                     *(((struct opGet *) msg)->opg_Storage) = (ULONG) data->labelplace;
  242.                     retval = TRUE;
  243.                     break;
  244.                 case CYA_LabelMark:
  245.                     *(((struct opGet *) msg)->opg_Storage) = (ULONG) data->labelmark;
  246.                     retval = TRUE;
  247.                     break;
  248.                 default:
  249.                     retval = DoSuperMethodA(cl,o,msg);
  250.                     break;
  251.             };
  252.             break;
  253.         };
  254.         case OM_SET:
  255.         {
  256.             data = (struct InstanceData *) INST_DATA(cl,o);
  257.             BOOL needsRendering = FALSE;
  258.             TagItemCursorC tic(((struct opSet *) msg)->ops_AttrList);
  259.             while (!tic.isDone()) {
  260.                 /* register */ ULONG ticData = tic.itemData();
  261.                 switch (tic.itemTag())
  262.                 {
  263.                     case GA_Left:
  264.                         if (data->menu)
  265.                             SetAttrs(data->menu,GA_Left,ticData+MENULEFT,TAG_END);
  266.                         break;
  267.                     case GA_Top:
  268.                         if (data->menu)
  269.                             SetAttrs(data->menu,GA_Top,ticData,TAG_END);
  270.                         break;
  271.                     case GA_Width:
  272.                         if (data->menu)
  273.                             SetAttrs(data->menu,GA_Width,ticData-MENULEFT,TAG_END);
  274.                         break;
  275.                     case GA_Height:
  276.                         if (data->menu)
  277.                             SetAttrs(data->menu,GA_Height,ticData,TAG_END);
  278.                         break;
  279.                     case CYA_Font:
  280.                         if (data->font)
  281.                         {
  282.                             CloseFont(data->font);
  283.                             data->font = NULL;
  284.                         };
  285.                         data->tattr = (struct TextAttr *) ticData;
  286.                         if (data->menu)
  287.                             SetAttrs(data->menu,MA_Font,ticData,TAG_END);
  288.                         if (data->tattr)
  289.                         {
  290.                             data->font = OpenFont(data->tattr);
  291.                         };
  292.                         ChangeLTextFont(data->label,data->tattr);
  293.                         calcBorders(cl,(struct Gadget *) o, data);
  294.                         break;
  295.                     case CYA_Labels:
  296.                         data->labels = (STRPTR *) ticData;
  297.                         if (data->menu)
  298.                             SetAttrs(data->menu,MA_Labels,ticData,TAG_END);
  299.                         if (data->labels)
  300.                         {
  301.                             int i = 0;
  302.                             while (data->labels[i]) {
  303.                                 i++;
  304.                             };
  305.                             data->labelCount = i;
  306.                         }
  307.                         else {
  308.                             data->labelCount = 0;
  309.                         };
  310.                         needsRendering = TRUE;
  311.                         break;
  312.                     case CYA_Active:
  313.                         data->active = (UWORD) ticData;
  314.                         needsRendering = TRUE;
  315.                         break;
  316.                     case CYA_MinMenu:
  317.                         data->minmenu = (ULONG) ticData;
  318.                         break;
  319.                     case CYA_Columns:
  320.                         data->columns = (ULONG) ticData;
  321.                         break;
  322.                     case CYA_Next:
  323.                         (data->active)++;
  324.                         if (data->active >= data->labelCount)
  325.                             data->active = 0;
  326.                         needsRendering = TRUE;
  327.                         break;
  328.                     case CYA_Prev:
  329.                         if (data->active == 0)
  330.                             data->active = data->labelCount - 1
  331.                         else
  332.                             (data->active)--;
  333.                         needsRendering = TRUE;
  334.                         break;
  335.                     default:
  336.                         break;
  337.                 };
  338.                 tic.next();
  339.             };
  340.             retval = DoSuperMethodA(cl,o,msg);
  341.             if (data->active >= data->labelCount)
  342.             {
  343.                 data->active = 0;
  344.             };
  345.             if (needsRendering)
  346.             {
  347.                 renderCycle(cl,(struct Gadget *) o,
  348.                         (struct gpRender *) msg,data);
  349.             };
  350.             break;
  351.         };
  352.         case GM_RENDER:
  353.         {
  354.             data = (struct InstanceData *) INST_DATA(cl,o);
  355.             retval = renderCycle(cl,(struct Gadget *) o,
  356.                 (struct gpRender *) msg,data);
  357.             break;
  358.         };
  359.         case GM_HITTEST:
  360.         {
  361.             retval = GMR_GADGETHIT;
  362.             break;
  363.         };
  364.         case GM_GOACTIVE:
  365.         {
  366.             data = (struct InstanceData *) INST_DATA(cl,o);
  367.             if (((struct gpInput *) msg)->gpi_IEvent)
  368.             {
  369.                 ((struct Gadget *) o)->Flags |= GFLG_SELECTED;
  370.                 renderCycle(cl,(struct Gadget *) o,
  371.                     (struct gpRender *) msg,data);
  372.                 if (((struct gpInput *) msg)->gpi_Mouse.X >= 21
  373.                     && data->minmenu <= data->labelCount)
  374.                 {
  375.                     if (data->menu)
  376.                     {
  377.                         ((struct gpInput *) msg)->gpi_Mouse.X -= MENULEFT;
  378.                         struct InputEvent *ie = ((struct gpInput *) msg)->gpi_IEvent;
  379.                         ((struct gpInput *) msg)->gpi_IEvent = NULL;
  380.                         retval = DoMethodA(data->menu,msg);
  381.                         ((struct gpInput *) msg)->gpi_IEvent = ie;
  382.                     }
  383.                     else
  384.                         retval = GMR_NOREUSE;
  385.                     data->menushown = TRUE;
  386.                 }
  387.                 else {
  388.                     data->menushown = FALSE;
  389.                     retval = GMR_MEACTIVE;
  390.                 };
  391.             }
  392.             else
  393.                 retval = GMR_NOREUSE;
  394.             break;
  395.         };
  396.         case GM_GOINACTIVE:
  397.         {
  398.             data = (struct InstanceData *) INST_DATA(cl,o);
  399.             if (data->menushown)
  400.             {
  401.                 if (data->menu)
  402.                 {
  403.                     ULONG active;
  404.                     DoMethodA(data->menu,msg);
  405.                     GetAttr(MA_Active,data->menu,&active);
  406.                     data->active = active;
  407.                 };
  408.                 data->menushown = FALSE;
  409.             };
  410.             ((struct Gadget *) o)->Flags &= ~GFLG_SELECTED;
  411.             renderCycle(cl,(struct Gadget *) o,
  412.                 (struct gpRender *) msg,data);
  413.             break;
  414.         };
  415.         case GM_HANDLEINPUT:
  416.         {
  417.             data = (struct InstanceData *) INST_DATA(cl,o);
  418.             struct gpInput *gpi = (struct gpInput *) msg;
  419.             struct InputEvent *ie = gpi->gpi_IEvent;
  420.             BOOL mouseOverGadget = ((gpi->gpi_Mouse.X >= 0) &&
  421.                     (gpi->gpi_Mouse.X < ((struct Gadget *) o)->Width) &&
  422.                     (gpi->gpi_Mouse.Y >= 0) &&
  423.                     (gpi->gpi_Mouse.Y < ((struct Gadget *) o)->Height));
  424.             if (data->menushown)
  425.             {
  426.                 if (data->menu)
  427.                 {
  428.                     ((struct gpInput *) msg)->gpi_Mouse.X -= MENULEFT;
  429.                     retval = DoMethodA(data->menu,msg);
  430.                 }
  431.                 else
  432.                     retval = GMR_NOREUSE;
  433.             }
  434.             else {
  435.                 if (mouseOverGadget)
  436.                 {
  437.                     if (!(((struct Gadget *) o)->Flags & GFLG_SELECTED))
  438.                     {
  439.                         ((struct Gadget *) o)->Flags |= GFLG_SELECTED;
  440.                         renderCycle(cl,(struct Gadget *) o,
  441.                             (struct gpRender *) msg,data);
  442.                     };
  443.                 };
  444.                 else {
  445.                     if (((struct Gadget *) o)->Flags & GFLG_SELECTED)
  446.                     {
  447.                         ((struct Gadget *) o)->Flags &= ~GFLG_SELECTED;
  448.                         renderCycle(cl,(struct Gadget *) o,
  449.                             (struct gpRender *) msg,data);
  450.                     };
  451.                 };
  452.                 switch (ie->ie_Class)
  453.                 {
  454.                     case IECLASS_RAWMOUSE:
  455.                         switch (ie->ie_Code)
  456.                         {
  457.                             case SELECTUP:
  458.                                 if (mouseOverGadget)
  459.                                 {
  460.                                     if (ie->ie_Qualifier &
  461.                                         (IEQUALIFIER_LSHIFT|IEQUALIFIER_RSHIFT))
  462.                                     {
  463.                                         if (data->active > 0)
  464.                                             (data->active)--;
  465.                                         else
  466.                                             data->active = data->labelCount-1;
  467.                                         };
  468.                                     else {
  469.                                         if (data->active < data->labelCount-1)
  470.                                             (data->active)++;
  471.                                         else
  472.                                             data->active = 0;
  473.                                     };
  474.                                     retval = GMR_NOREUSE | GMR_VERIFY;
  475.                                 }
  476.                                 else {
  477.                                     retval = GMR_NOREUSE;
  478.                                 };
  479.                                 break;
  480.                             case MENUDOWN:
  481.                                 retval = GMR_REUSE;
  482.                                 break;
  483.                             default:
  484.                                 retval = GMR_MEACTIVE;
  485.                                 break;
  486.                         };
  487.                         break;
  488.                     default:
  489.                         retval = GMR_MEACTIVE;
  490.                         break;
  491.                 };
  492.             };
  493.             break;
  494.         };
  495.         default:
  496.         {
  497.             retval = DoSuperMethodA(cl,o,msg);
  498.             break;
  499.         };
  500.     };
  501.     return retval;
  502. }
  503.  
  504. ULONG CycleClass::renderCycle(Class *cl, struct Gadget *g,
  505.     struct gpRender *msg, struct InstanceData *data)
  506. {
  507.     static UWORD ditherData[] = { 0x1111,0x4444 };
  508.  
  509.     struct RastPort *rp;
  510.     struct GadgetInfo *ginfo;
  511.     if (msg->MethodID == OM_SET || msg->MethodID == OM_UPDATE)
  512.         ginfo = ((struct opSet *) msg)->ops_GInfo
  513.     else
  514.         ginfo = msg->gpr_GInfo;
  515.     if (!ginfo)
  516.         return TRUE;
  517.     UWORD *pens = ginfo->gi_DrInfo->dri_Pens;
  518.     if (msg->MethodID == GM_RENDER)
  519.         rp = msg->gpr_RPort
  520.     else
  521.         rp = ObtainGIRPort(ginfo);
  522.     if (rp)
  523.     {
  524.         UWORD shine = pens[SHINEPEN];
  525.         UWORD shadow = pens[SHADOWPEN];
  526.         if (data->frame)
  527.         {
  528.             SetAttrs(data->frame,
  529.                 IA_Left,g->LeftEdge,
  530.                 IA_Top,g->TopEdge,
  531.                 IA_Width,g->Width,
  532.                 IA_Height,g->Height,
  533.                 TAG_END);
  534.             if (g->Flags & GFLG_SELECTED)
  535.             {
  536.                 DrawImageState(rp,(struct Image *) data->frame,0,0,
  537.                     IDS_SELECTED,ginfo->gi_DrInfo);
  538.                 UWORD x = shine;
  539.                 shine = shadow;
  540.                 shadow = x;
  541.             }
  542.             else {
  543.                 DrawImageState(rp,(struct Image *) data->frame,0,0,
  544.                     IDS_NORMAL,ginfo->gi_DrInfo);
  545.             };
  546.         };
  547.         UWORD l = g->LeftEdge;
  548.         UWORD t = g->TopEdge;
  549.         UWORD h = g->Height;
  550.  
  551.         if (g->GadgetText && data->font)
  552.         {
  553.             SetAPen(rp,pens[TEXTPEN]);
  554.             SetBPen(rp,pens[BACKGROUNDPEN]);
  555.             SetDrMd(rp,JAM2);
  556.             ChangeLTextPens(data->label,pens[TEXTPEN],pens[BACKGROUNDPEN],JAM2);
  557.             switch (data->labelplace)
  558.             {
  559.                 case CY_LabelLeft:
  560.                     PrintLText(rp,data->label,
  561.                         g->LeftEdge - data->leftborder, g->TopEdge,
  562.                         data->leftborder, g->Height);
  563.                     break;
  564.                 case CY_LabelRight:
  565.                     PrintLText(rp,data->label,
  566.                         g->LeftEdge + g->Width, g->TopEdge,
  567.                         data->rightborder, g->Height,
  568.                         STADJUST_Right);
  569.                     break;
  570.             };
  571.         };
  572.  
  573.         if (data->font && g->Width > 25 && h >= 12 && h >= data->font->tf_YSize+4)
  574.         {
  575.             SetAPen(rp,pens[TEXTPEN]);    // Cycle Image
  576.             SetDrMd(rp,JAM1);
  577.             Move(rp,l+6,t+3);
  578.             Draw(rp,l+6,t+h-5);
  579.             Move(rp,l+7,t+3);
  580.             Draw(rp,l+7,t+h-5);
  581.             Move(rp,l+7,t+2);
  582.             Draw(rp,l+13,t+2);
  583.             Move(rp,l+7,t+h-4);
  584.             Draw(rp,l+13,t+h-4);
  585.             WritePixel(rp,l+13,t+3);
  586.             WritePixel(rp,l+14,t+3);
  587.             Move(rp,l+11,t+4);
  588.             Draw(rp,l+16,t+4);
  589.             Move(rp,l+12,t+5);
  590.             Draw(rp,l+15,t+5);
  591.             WritePixel(rp,l+13,t+6);
  592.             WritePixel(rp,l+14,t+6);
  593.             WritePixel(rp,l+13,t+h-5);
  594.             WritePixel(rp,l+14,t+h-5);
  595.  
  596.             SetAPen(rp,shadow);            // Trennstrich
  597.             Move(rp,l+20,t+2);
  598.             Draw(rp,l+20,t+h-3);
  599.             SetAPen(rp,shine);
  600.             Move(rp,l+21,t+2);
  601.             Draw(rp,l+21,t+h-3);
  602.  
  603.             UWORD textwidth = g->Width - 30;
  604.             if (data->labels)
  605.             {
  606.                 STRPTR label = data->labels[data->active];
  607.                 if (label)
  608.                 {
  609.                     TextExtent extent;
  610.                     SetFont(rp,data->font);
  611.                     ULONG c = TextFit(rp,label,strlen(label),&extent,NULL,
  612.                         1,textwidth,h-2);
  613.                     if (c > 0)
  614.                     {
  615.                         SetAPen(rp,pens[TEXTPEN]);
  616.                         SetDrMd(rp,JAM1);
  617.                         Move(rp,l+25+extent.te_Extent.MinX+
  618.                             ((g->Width - 30 - extent.te_Extent.MinX - extent.te_Width) >> 1),
  619.                             t+((h - extent.te_Height) >> 1)- extent.te_Extent.MinY);
  620.                         Text(rp,label,c);
  621.                     };
  622.                 };
  623.             };
  624.         };
  625.  
  626.         if (g->Flags & GFLG_DISABLED)
  627.         {
  628.             SetDrMd(rp,JAM1);
  629.             SetAPen(rp,pens[TEXTPEN]);
  630.             SetAfPt(rp,ditherData,1);
  631.             RectFill(rp,g->LeftEdge, g->TopEdge,
  632.                 g->LeftEdge + g->Width - 1, g->TopEdge + g->Height - 1);
  633.             SetAfPt(rp,NULL,0);
  634.         };
  635.  
  636.         if (msg->MethodID != GM_RENDER)
  637.             ReleaseGIRPort(rp);
  638.         return TRUE;
  639.     };
  640.     return FALSE;
  641. }
  642.  
  643. ULONG CycleClass::calcWidth(Class *cl, struct Gadget *, struct InstanceData *data)
  644. {
  645.     if (!data->tattr)
  646.         return 54;
  647.     ULONG width = 0;
  648.     if (data->columns != 0)
  649.     {
  650.         struct IntuiText it = { 0,0,0,0,0,NULL,NULL,NULL };
  651.         it.ITextFont = data->tattr;
  652.         it.IText = "0";
  653.         width = data->columns*IntuiTextLength(&it);
  654.     }
  655.     else {
  656.         STRPTR *labels = data->labels;
  657.         if (labels == NULL || *labels == NULL)
  658.         {
  659.             struct IntuiText it = { 0,0,0,0,0,NULL,NULL,NULL };
  660.             it.ITextFont = data->tattr;
  661.             it.IText = "0";
  662.             width = 15*IntuiTextLength(&it);
  663.         }
  664.         else {
  665.             while (*labels != NULL)
  666.             {
  667.                 struct IntuiText it = { 0,0,0,0,0,NULL,NULL,NULL };
  668.                 it.ITextFont = data->tattr;
  669.                 it.IText = *labels;
  670.                 LONG w = IntuiTextLength(&it);
  671.                 if (w > width)
  672.                     width = w;
  673.                 labels++;
  674.             };
  675.         };
  676.     };
  677.     if (width < 24)
  678.         width = 24;
  679.     return width + 38;
  680. }
  681.  
  682. ULONG CycleClass::calcHeight(Class *cl, struct Gadget *, struct InstanceData *data)
  683. {
  684.     if (!data->tattr)
  685.         return 12;
  686.     return data->tattr->ta_YSize + 6;
  687. }
  688.  
  689. VOID CycleClass::calcBorders(Class *cl, struct Gadget *g,
  690.         struct InstanceData *data)
  691. {
  692.     data->leftborder = 0;
  693.     data->rightborder = 0;
  694.     data->topborder = 0;
  695.     data->bottomborder = 0;
  696.  
  697.     if (data->tattr && g->GadgetText)
  698.     {
  699.         switch (data->labelplace)
  700.         {
  701.             case CY_LabelLeft:
  702.                 data->leftborder = MeasureLText(data->label) + 4;
  703.                 break;
  704.             case CY_LabelRight:
  705.                 data->rightborder = MeasureLText(data->label) + 4;
  706.                 break;
  707.         };
  708.     };
  709. }
  710.  
  711. // *************************************************************
  712.  
  713. BCycleC::BCycleC(GadgetEventC *ev, WindowC &w, stringarray &l, Tag tag1type, ...)
  714.     : BGadgetC(ev,pmc.boopsiclass(),NULL,w,(struct TagItem *) &tag1type),
  715.       GCycleC(),
  716.       labels(l)
  717. {
  718.     setAttrs(CYA_Labels,labels.strings(),TAG_END);
  719. }
  720.  
  721. BCycleC::BCycleC(GadgetEventC *ev,WindowC &w, stringarray &l, struct TagItem *tags)
  722.     : BGadgetC(ev,pmc.boopsiclass(),NULL,w,tags),
  723.       GCycleC(),
  724.       labels(l)
  725. {
  726.     setAttrs(CYA_Labels,labels.strings(),TAG_END);
  727. }
  728.  
  729. VOID BCycleC::setLabels(STRPTR *l)
  730. {
  731.     labels = stringarray(l);
  732.     setAttrs(CYA_Labels,labels.strings(),TAG_END);
  733. }
  734.  
  735. VOID BCycleC::setLabels(STRPTR label1, ...)
  736. {
  737.     labels = stringarray(&label1);
  738.     setAttrs(CYA_Labels,labels.strings(),TAG_END);
  739. }
  740.  
  741. STRPTR *BCycleC::getLabels()
  742. {
  743.     return labels.strings();
  744. }
  745.  
  746. ULONG BCycleC::labelsCount()
  747. {
  748.     return labels.length();
  749. }
  750.  
  751. UWORD BCycleC::addLabel(STRPTR label)
  752. {
  753.     UWORD c = labels.length();
  754.     labels.addTail(label);
  755.     setAttrs(CYA_Labels,labels.strings(),TAG_END);
  756.     return c;
  757. }
  758.  
  759. VOID BCycleC::remLabel(UWORD count)
  760. {
  761.     labels.remove(count);
  762.     setAttrs(CYA_Labels,labels.strings(),TAG_END);
  763. }
  764.  
  765. CycleClass BCycleC::pmc;
  766.  
  767. // *************************************************************
  768.  
  769.