home *** CD-ROM | disk | FTP | other *** search
/ Amiga ISO Collection / AmigaUtilCD2.iso / Programming / C / OTL-MC7.DMS / in.adf / classsource.lha / ClassSource / BOOPSI / gadgets / label.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-02-12  |  10.4 KB  |  447 lines
  1. #include <classes/BOOPSI/gadgets.h>
  2. #include <classes/BOOPSI/boopsilib.h>
  3.  
  4. #pragma -
  5. #include <pragma/utility_lib.h>
  6. #include <clib/alib_protos.h>
  7. #include <pragma/intuition_lib.h>
  8. #include <pragma/graphics_lib.h>
  9. #include <graphics/gfxmacros.h>
  10. #pragma +
  11.  
  12. #include <tools/str.h>
  13. #include <stdio.h>
  14.  
  15. struct InstanceData {
  16.     InstanceData() { };
  17.     struct TextAttr *tattr;
  18.     struct TextFont *font;
  19.     String text;
  20.     LONG number;
  21.     BOOL isnumber;
  22.     ULONG adjust;
  23.     ULONG labelplace;
  24.     Object *frame;
  25.     WORD leftborder;
  26.     WORD rightborder;
  27.     WORD topborder;
  28.     WORD bottomborder;
  29.     ULONG columns;
  30. };
  31.  
  32. LabelClass::LabelClass()
  33.     : BoopsiClass(sizeof(struct InstanceData),(ULONG (*)()) &dispatcher,GADGETCLASS,NULL)
  34. {
  35. }
  36.  
  37. ULONG LabelClass::dispatcher(Class *cl, Object *o, Msg msg)
  38. {
  39.     struct InstanceData *data;
  40.     ULONG retval = FALSE;
  41.     switch (msg->MethodID)
  42.     {
  43.         case OM_NEW:
  44.         {
  45.             Object *object;
  46.             if (object = (Object *) DoSuperMethodA(cl,o,msg))
  47.             {
  48.                 data = (struct InstanceData *) INST_DATA(cl,object);
  49.                 data->tattr = NULL;
  50.                 data->font = NULL;
  51.                 data->text = "";
  52.                 data->number = 0;
  53.                 data->adjust = LB_AdjustLeft;
  54.                 data->labelplace = LB_LabelLeft;
  55.                 data->columns = 0;
  56.                 data->isnumber = FALSE;
  57.                 BOOL oborder = TRUE;
  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 LBA_Font:
  64.                             data->tattr = (struct TextAttr *) ticData;
  65.                             break;
  66.                         case LBA_Text:
  67.                             data->text = (STRPTR) ticData;
  68.                             data->isnumber = FALSE;
  69.                             break;
  70.                         case LBA_Number:
  71.                             data->number = (ULONG) ticData;
  72.                             data->isnumber = TRUE;
  73.                             break;
  74.                         case LBA_LabelPlace:
  75.                             data->labelplace = (ULONG) ticData;
  76.                             break;
  77.                         case LBA_Adjust:
  78.                             data->adjust = (ULONG) ticData;
  79.                             break;
  80.                         case LBA_Border:
  81.                             oborder = (BOOL) ticData;
  82.                             break;
  83.                         case LBA_Columns:
  84.                             data->columns = (ULONG) ticData;
  85.                             break;
  86.                         default:
  87.                             break;
  88.                     };
  89.                     tic.next();
  90.                 };
  91.                 if (oborder)
  92.                 {
  93.                     data->frame = (Object *) NewObject(NULL,FRAMEICLASS,
  94.                         IA_Recessed, TRUE,
  95.                         IA_EdgesOnly, FALSE,
  96.                         IA_FrameType, FRAME_DEFAULT,
  97.                         TAG_END);
  98.                 };
  99.                 if (data->tattr)
  100.                     data->font = OpenFont(data->tattr);
  101.                 calcBorders(cl,(struct Gadget *) object, data);
  102.                 retval = (ULONG) object;
  103.             };
  104.             break;
  105.         };
  106.         case OM_DISPOSE:
  107.         {
  108.             data = (struct InstanceData *) INST_DATA(cl,o);
  109.             if (data->font)
  110.                 CloseFont(data->font);
  111.             if (data->frame)
  112.                 DisposeObject(data->frame);
  113.             retval = DoSuperMethodA(cl,o,msg);
  114.             break;
  115.         };
  116.         case OM_GET:
  117.         {
  118.             data = (struct InstanceData *) INST_DATA(cl,o);
  119.             switch (((struct opGet *) msg)->opg_AttrID)
  120.             {
  121.                 case GA_Left:
  122.                     *(((struct opGet *) msg)->opg_Storage) = ((struct Gadget *) o)->LeftEdge;
  123.                     retval = TRUE;
  124.                     break;
  125.                 case GA_Top:
  126.                     *(((struct opGet *) msg)->opg_Storage) = ((struct Gadget *) o)->TopEdge;
  127.                     retval = TRUE;
  128.                     break;
  129.                 case GA_Width:
  130.                     *(((struct opGet *) msg)->opg_Storage) = ((struct Gadget *) o)->Width;
  131.                     retval = TRUE;
  132.                     break;
  133.                 case GA_Height:
  134.                     *(((struct opGet *) msg)->opg_Storage) = ((struct Gadget *) o)->Height;
  135.                     retval = TRUE;
  136.                     break;
  137.                 case LBA_Font:
  138.                      *(((struct opGet *) msg)->opg_Storage) = (ULONG) data->font;
  139.                     retval = TRUE;
  140.                     break;
  141.                 case LBA_Text:
  142.                     *(((struct opGet *) msg)->opg_Storage) =
  143.                         (ULONG) (char *) data->text;
  144.                     retval = TRUE;
  145.                     break;
  146.                 case LBA_Number:
  147.                      *(((struct opGet *) msg)->opg_Storage) = (ULONG) data->number;
  148.                     retval = TRUE;
  149.                     break;
  150.                 case LBA_LabelPlace:
  151.                     *(((struct opGet *) msg)->opg_Storage) = (ULONG) data->labelplace;
  152.                     retval = TRUE;
  153.                     break;
  154.                 case LBA_Adjust:
  155.                     *(((struct opGet *) msg)->opg_Storage) = (ULONG) data->adjust;
  156.                     retval = TRUE;
  157.                     break;
  158.                 case LBA_Border:
  159.                     *(((struct opGet *) msg)->opg_Storage) = (ULONG) (data->frame != NULL);
  160.                     retval = TRUE;
  161.                     break;
  162.                 case LBA_LeftBorder:
  163.                     *(((struct opGet *) msg)->opg_Storage) = (ULONG) data->leftborder;
  164.                     retval = TRUE;
  165.                     break;
  166.                 case LBA_RightBorder:
  167.                     *(((struct opGet *) msg)->opg_Storage) = (ULONG) data->rightborder;
  168.                     retval = TRUE;
  169.                     break;
  170.                 case LBA_TopBorder:
  171.                     *(((struct opGet *) msg)->opg_Storage) = (ULONG) data->topborder;
  172.                     retval = TRUE;
  173.                     break;
  174.                 case LBA_BottomBorder:
  175.                     *(((struct opGet *) msg)->opg_Storage) = (ULONG) data->bottomborder;
  176.                     retval = TRUE;
  177.                     break;
  178.                 case LBA_AutoWidth:
  179.                     *(((struct opGet *) msg)->opg_Storage) =
  180.                         (ULONG) calcWidth(cl,(struct Gadget *) o, data);
  181.                     retval = TRUE;
  182.                     break;
  183.                 case LBA_AutoHeight:
  184.                     *(((struct opGet *) msg)->opg_Storage) =
  185.                         (ULONG) calcHeight(cl,(struct Gadget *) o, data);
  186.                     retval = TRUE;
  187.                     break;
  188.                 case LBA_Columns:
  189.                     *(((struct opGet *) msg)->opg_Storage) = (ULONG) data->columns;
  190.                     retval = TRUE;
  191.                     break;
  192.                 default:
  193.                     retval = DoSuperMethodA(cl,o,msg);
  194.                     break;
  195.             };
  196.             break;
  197.         };
  198.         case OM_SET:
  199.         {
  200.             data = (struct InstanceData *) INST_DATA(cl,o);
  201.             BOOL redrawIt = FALSE;
  202.             TagItemCursorC tic(((struct opSet *) msg)->ops_AttrList);
  203.             while (!tic.isDone()) {
  204.                 /* register */ ULONG ticData = tic.itemData();
  205.                 switch (tic.itemTag())
  206.                 {
  207.                     case LBA_Font:
  208.                         if (data->font)
  209.                         {
  210.                             CloseFont(data->font);
  211.                             data->font = NULL;
  212.                         };
  213.                         data->tattr = (struct TextAttr *) ticData;
  214.                         if (data->tattr)
  215.                             data->font = OpenFont(data->tattr);
  216.                         calcBorders(cl,(struct Gadget *) o, data);
  217.                         break;
  218.                     case LBA_Text:
  219.                         data->text = (STRPTR) ticData;
  220.                         data->isnumber = FALSE;
  221.                         redrawIt = TRUE;
  222.                         break;
  223.                     case LBA_Number:
  224.                         data->number = (LONG) ticData;
  225.                         data->isnumber = TRUE;
  226.                         redrawIt = TRUE;
  227.                         break;
  228.                     case LBA_Adjust:
  229.                         data->adjust = (ULONG) ticData;
  230.                         break;
  231.                     case LBA_Columns:
  232.                         data->columns = (ULONG) ticData;
  233.                         break;
  234.                     default:
  235.                         break;
  236.                 };
  237.                 tic.next();
  238.             };
  239.             retval = DoSuperMethodA(cl,o,msg);
  240.             if (redrawIt)
  241.             {
  242.                 render(cl,(struct Gadget *) o,
  243.                     (struct gpRender *) msg,data);
  244.             };
  245.             break;
  246.         };
  247.         case GM_RENDER:
  248.         {
  249.             data = (struct InstanceData *) INST_DATA(cl,o);
  250.             retval = render(cl,(struct Gadget *) o,
  251.                 (struct gpRender *) msg,data);
  252.             break;
  253.         };
  254.         case GM_HITTEST:
  255.         {
  256.             retval = 0;
  257.             break;
  258.         };
  259.         default:
  260.         {
  261.             retval = DoSuperMethodA(cl,o,msg);
  262.             break;
  263.         };
  264.     };
  265.     return retval;
  266. }
  267.  
  268. ULONG LabelClass::render(Class *cl, struct Gadget *g,
  269.     struct gpRender *msg, struct InstanceData *data)
  270. {
  271.     static UWORD ditherData[] = { 0x1111,0x4444 };
  272.  
  273.     struct RastPort *rp;
  274.     struct GadgetInfo *ginfo;
  275.     if (msg->MethodID == OM_SET || msg->MethodID == OM_UPDATE)
  276.         ginfo = ((struct opSet *) msg)->ops_GInfo
  277.     else
  278.         ginfo = msg->gpr_GInfo;
  279.     if (!ginfo)
  280.         return TRUE;
  281.     UWORD *pens = ginfo->gi_DrInfo->dri_Pens;
  282.     if (msg->MethodID == GM_RENDER)
  283.         rp = msg->gpr_RPort
  284.     else
  285.         rp = ObtainGIRPort(ginfo);
  286.     if (rp)
  287.     {
  288.         if (data->frame)
  289.         {
  290.             SetAttrs(data->frame,
  291.                 IA_Left, g->LeftEdge,
  292.                 IA_Top, g->TopEdge,
  293.                 IA_Width, g->Width,
  294.                 IA_Height, g->Height,
  295.                 TAG_END);
  296.             DrawImageState(rp,(struct Image *) data->frame,0,0,IDS_NORMAL,
  297.                 ginfo->gi_DrInfo);
  298.         }
  299.         else {
  300.             SetAPen(rp,pens[BACKGROUNDPEN]);
  301.             SetDrMd(rp,JAM1);
  302.             RectFill(rp, g->LeftEdge, g->TopEdge,
  303.                 g->LeftEdge + g->Width - 1, g->TopEdge + g->Height - 1);
  304.         };
  305.         SetAPen(rp,pens[TEXTPEN]);
  306.         SetBPen(rp,pens[BACKGROUNDPEN]);
  307.         SetDrMd(rp,JAM2);
  308.         SetFont(rp,data->font);
  309.         if (data->font)
  310.         {
  311.             if (g->GadgetText)
  312.             {
  313.                 switch (data->labelplace)
  314.                 {
  315.                     case LB_LabelLeft:
  316.                         PrintClipped(rp,(STRPTR) g->GadgetText,
  317.                             g->LeftEdge - data->leftborder, g->TopEdge,
  318.                             data->leftborder,g->Height,
  319.                             STADJUST_Left);
  320.                         break;
  321.                     case LB_LabelRight:
  322.                         PrintClipped(rp,(STRPTR) g->GadgetText,
  323.                             g->LeftEdge + g->Width + 4, g->TopEdge,
  324.                             data->rightborder - 4, g->Height,
  325.                             STADJUST_Left);
  326.                         break;
  327.                 };
  328.             };
  329.             if (data->isnumber)
  330.             {
  331.                 char buffer[80];
  332.                 sprintf(buffer,"%-ld",(int) data->number);
  333.                 data->text = (char *) buffer;
  334.             };
  335.             ULONG adjust = STADJUST_Left;
  336.             switch (data->adjust)
  337.             {
  338.                 case LB_AdjustCenter:
  339.                     adjust = STADJUST_Center;
  340.                     break;
  341.                 case LB_AdjustRight:
  342.                     adjust = STADJUST_Right;
  343.                     break;
  344.             };
  345.             PrintClipped(rp,(STRPTR) (char *) data->text,
  346.                 g->LeftEdge + 4, g->TopEdge, g->Width - 8, g->Height,
  347.                 adjust);
  348.         };
  349.         if (g->Flags & GFLG_DISABLED)
  350.         {
  351.             SetDrMd(rp,JAM1);
  352.             SetAPen(rp,pens[TEXTPEN]);
  353.             SetAfPt(rp,ditherData,1);
  354.             RectFill(rp,g->LeftEdge, g->TopEdge,
  355.                 g->LeftEdge + g->Width - 1, g->TopEdge + g->Height - 1);
  356.             SetAfPt(rp,NULL,0);
  357.         };
  358.         if (msg->MethodID != GM_RENDER)
  359.             ReleaseGIRPort(rp);
  360.         return TRUE;
  361.     };
  362.     return FALSE;
  363. }
  364.  
  365. VOID LabelClass::calcBorders(Class *cl, struct Gadget *g,
  366.         struct InstanceData *data)
  367. {
  368.     data->leftborder = 0;
  369.     data->rightborder = 0;
  370.     data->topborder = 0;
  371.     data->bottomborder = 0;
  372.     if (data->tattr && g->GadgetText)
  373.     {
  374.         switch (data->labelplace)
  375.         {
  376.             case LB_LabelLeft:
  377.                 data->leftborder = MeasureTextLength((STRPTR) g->GadgetText,
  378.                     data->tattr) + 4;
  379.                 break;
  380.             case LB_LabelRight:
  381.                 data->rightborder = MeasureTextLength((STRPTR) g->GadgetText,
  382.                     data->tattr) + 4;
  383.                 break;
  384.         };
  385.     };
  386. }
  387.  
  388. WORD LabelClass::calcWidth(Class *cl, struct Gadget *g,
  389.         struct InstanceData *data)
  390. {
  391.     if (data->tattr)
  392.     {
  393.         if (data->columns == 0)
  394.         {
  395.             if (data->isnumber && data->number != 0)
  396.             {
  397.                 char buffer[80];
  398.                 sprintf(buffer,"%-ld",(int) data->number);
  399.                 return MeasureTextLength(buffer,data->tattr) + 8;
  400.             }
  401.             else if (!data->isnumber && !(data->text == String("")))
  402.             {
  403.                 return MeasureTextLength(data->text,data->tattr) + 8;
  404.             };
  405.         };
  406.         ULONG chars = 0;
  407.         if (data->columns != 0)
  408.             chars = data->columns
  409.         else if (data->isnumber)
  410.             chars = 7;
  411.         else
  412.             chars = 16;
  413.         return MeasureTextLength("0",data->tattr)*chars + 8;
  414.     };
  415.     return 60;
  416. }
  417.  
  418. WORD LabelClass::calcHeight(Class *cl, struct Gadget *g,
  419.         struct InstanceData *data)
  420. {
  421.     if (data->tattr)
  422.     {
  423.         return data->tattr->ta_YSize + 6;
  424.     };
  425.     return 12;
  426. }
  427.  
  428. // *************************************************************
  429.  
  430. LabelClass BTextC::lc;
  431.  
  432. // *************************************************************
  433.  
  434. BNumberC::BNumberC(GadgetEventC *ev, WindowC &w, Tag tag1type, ...)
  435.         : BGadgetC(ev,lc.boopsiclass(),NULL,w,(struct TagItem *) &tag1type)
  436. {
  437.     set(get());
  438. }
  439.  
  440. BNumberC::BNumberC(GadgetEventC *ev, WindowC &w, struct TagItem *tags)
  441.         : BGadgetC(ev,lc.boopsiclass(),NULL,w,tags)
  442. {
  443.     set(get());
  444. }
  445.  
  446. LabelClass BNumberC::lc;
  447.