bgui/indicatorclass.c

   1 /*
   2  * @(#) $Header$
   3  *
   4  * BGUI library
   5  * indicatorclass.c
   6  *
   7  * (C) Copyright 1998 Manuel Lemos.
   8  * (C) Copyright 1996-1997 Ian J. Einman.
   9  * (C) Copyright 1993-1996 Jaba Development.
  10  * (C) Copyright 1993-1996 Jan van den Baard.
  11  * All Rights Reserved.
  12  *
  13  * $Log$
  14  * Revision 42.2  2004/06/16 20:16:48  verhaegs
  15  * Use METHODPROTO, METHOD_END and REGFUNCPROTOn where needed.
  16  *
  17  * Revision 42.1  2000/05/15 19:27:01  stegerg
  18  * another hundreds of REG() macro replacements in func headers/protos.
  19  *
  20  * Revision 42.0  2000/05/09 22:09:12  mlemos
  21  * Bumped to revision 42.0 before handing BGUI to AROS team
  22  *
  23  * Revision 41.11  2000/05/09 19:54:25  mlemos
  24  * Merged with the branch Manuel_Lemos_fixes.
  25  *
  26  * Revision 41.10.2.1  1998/03/01 19:55:15  mlemos
  27  * Fixed short allocation for indicator text string.
  28  *
  29  * Revision 41.10  1998/02/25 21:12:15  mlemos
  30  * Bumping to 41.10
  31  *
  32  * Revision 1.1  1998/02/25 17:08:33  mlemos
  33  * Ian sources
  34  *
  35  *
  36  */
  37
  38 /// Class definitions.
  39 #include "include/classdefs.h"
  40
  41 /*
  42  * Object instance data.
  43  */
  44 typedef struct id_ {
  45    UWORD              id_Flags;           /* see below               */
  46    Object            *id_Text;            /* the text to display     */
  47    IPTR               id_Args[1];         /* Args to the label       */
  48    LONG               id_Min;             /* minimum indication      */
  49    LONG               id_Max;             /* maximum indication      */
  50    LONG               id_Level;           /* Current level           */
  51    UWORD              id_Justification;   /* label justification     */
  52    struct TextFont   *id_Font;            /* use this font           */
  53    UWORD              id_MinSize;         /* pre-calculated min size */
  54 }  ID;
  55
  56 #define IDF_INVALID_MINSIZE  (1<<0)    /* re-calculate minsize    */
  57
  58 #define ID_ENTRY(tag, offset, flags) PACK_ENTRY(INDIC_TAGSTART, tag, id_, offset, flags)
  59 #define ID_FLAG(tag, flag) PACK_LONGBIT(INDIC_TAGSTART, tag, id_, bd_Flags, PKCTRL_BIT, flag)
  60
  61 static ULONG IndicatorPackTable[] =
  62 {
  63    PACK_STARTTABLE(INDIC_TAGSTART),
  64
  65    ID_ENTRY(INDIC_Justification,    id_Justification,   PKCTRL_UWORD),
  66    ID_ENTRY(INDIC_Min,              id_Min,             PKCTRL_LONG),
  67    ID_ENTRY(INDIC_Max,              id_Max,             PKCTRL_LONG),
  68    ID_ENTRY(INDIC_Level,            id_Level,           PKCTRL_LONG),
  69
  70    PACK_ENDTABLE
  71 };
  72
  73 static void SetLevel(ID *id, LONG level)
  74 {
  75     id->id_Level = level;
  76     id->id_Args[0] = (IPTR)level;
  77 }
  78
  79 ///
  80 /// OM_NEW
  81 /*
  82  * Create a shiny new object.
  83  */
  84 METHOD(IClassNew, struct opSet *, ops)
  85 {
  86    ID             *id;
  87    struct TagItem *tags;
  88    IPTR            rc;
  89
  90    tags = DefTagList(BGUI_INDICATOR_GADGET, ops->ops_AttrList);
  91
  92    /*
  93     * Let the superclass create us an object.
  94     */
  95    if ((rc = NewSuperObject(cl, obj, tags)))
  96    {
  97       struct TagItem *tstate;
  98       struct TagItem *tag;
  99       id = INST_DATA(cl, rc);
 100
 101       /*
 102        * Initialize the local instance
 103        * data.
 104        */
 105       id->id_Justification = IDJ_LEFT;
 106       id->id_Max           = 100;
 107       id->id_Text          = BGUI_NewObject(BGUI_TEXT_GRAPHIC, TEXTA_Args, &id->id_Args[0], TAG_DONE);
 108
 109       BGUI_PackStructureTags((APTR)id, IndicatorPackTable, tags);
 110       tstate = tags;
 111       while ((tag = NextTagItem(&tstate))) {
 112           if (tag->ti_Tag == INDIC_Level) {
 113               SetLevel(id, (LONG)tag->ti_Data);
 114           }
 115       }
 116
 117       /*
 118        * are we setup OK?
 119        */
 120       if (!id->id_Text || (id->id_Min > id->id_Max))
 121       {
 122          AsmCoerceMethod(cl, (Object *)rc, OM_DISPOSE);
 123          rc = 0;
 124       }
 125       DoSetMethodNG((Object *)rc, INDIC_FormatString, "%ld", TAG_DONE);
 126    };
 127    FreeTagItems(tags);
 128
 129    return rc;
 130 }
 131 METHOD_END
 132 ///
 133 /// OM_DISPOSE
 134 /*
 135  * Hmm, they want us out of here.
 136  */
 137 METHOD(IClassDispose, Msg, msg)
 138 {
 139    ID    *id = INST_DATA(cl, obj);
 140
 141    /*
 142     * Dispose of the text graphic.
 143     */
 144    if (id->id_Text) DisposeObject(id->id_Text);
 145
 146    /*
 147     * And let the superclass take
 148     * care of the rest.
 149     */
 150    return AsmDoSuperMethodA(cl, obj, msg);
 151 }
 152 METHOD_END
 153 ///
 154 /// OM_SET, OM_UPDATE
 155 /*
 156  * Set/Update object attributes.
 157  */
 158 METHOD(IClassSetUpdate, struct opUpdate *, opu)
 159 {
 160    ID             *id = INST_DATA(cl, obj);
 161    IPTR            data;
 162    struct TagItem *tstate = opu->opu_AttrList;
 163    struct TagItem *tag;
 164    BOOL            update = FALSE;
 165    LONG            old_level = id->id_Level;
 166    UBYTE          *full_format;
 167
 168    /*
 169     * First we let the superclass have a go at it.
 170     */
 171    AsmDoSuperMethodA(cl, obj, (Msg)opu);
 172
 173    /*
 174     * Set attributes.
 175     */
 176    BGUI_PackStructureTags((APTR)id, IndicatorPackTable, opu->opu_AttrList);
 177
 178    while ((tag = NextTagItem(&tstate)))
 179    {
 180       data = tag->ti_Data;
 181
 182       switch (tag->ti_Tag)
 183       {
 184       /*
 185        * Intercept the font.
 186        */
 187       case BT_TextFont:
 188          id->id_Font = (struct TextFont *)data;
 189          id->id_Flags |= IDF_INVALID_MINSIZE;
 190          break;
 191
 192       case INDIC_FormatString:
 193          if ((full_format = BGUI_AllocPoolMem(3 + strlen((UBYTE *)data))))
 194          {
 195             sprintf(full_format, "\033l%s", (UBYTE *)data);
 196             DoSetMethodNG(id->id_Text, TEXTA_Text, full_format, TEXTA_CopyText, TRUE, TAG_DONE);
 197             BGUI_FreePoolMem(full_format);
 198          };
 199       case INDIC_Justification:
 200          update = TRUE;
 201          break;
 202       case INDIC_Level:
 203          SetLevel(id, (LONG)data);
 204          update = TRUE;
 205          break;
 206       };
 207    };
 208
 209    if (id->id_Level < id->id_Min) id->id_Level = id->id_Min;
 210    if (id->id_Level > id->id_Max) id->id_Level = id->id_Max;
 211    if (id->id_Level != old_level) update = TRUE;
 212
 213    /*
 214     * Refresh gadget?
 215     */
 216    if (update) DoRenderMethod(obj, opu->opu_GInfo, GREDRAW_REDRAW);
 217
 218    return 1;
 219 }
 220 METHOD_END
 221 ///
 222 /// OM_GET
 223 METHOD(IClassGet, struct opGet *, opg)
 224 {
 225    ID          *id = INST_DATA(cl, obj);
 226    ULONG        rc = 1;
 227    Tag          attr = opg->opg_AttrID;
 228    IPTR        *store = opg->opg_Storage;
 229
 230    switch (attr)
 231    {
 232    case INDIC_FormatString:
 233       Get_Attr(id->id_Text, TEXTA_Text, store);
 234       *store += 2;
 235       break;
 236
 237    default:
 238       /*
 239        * First we see if the attribute they want is known to us. If not
 240        * we pass it onto the superclass.
 241        */
 242       rc = BGUI_UnpackStructureTag((UBYTE *)id, IndicatorPackTable, attr, store);
 243       if (!rc) rc = AsmDoSuperMethodA(cl, obj, (Msg)opg);
 244       break;
 245    };
 246    return rc;
 247 }
 248 METHOD_END
 249 ///
 250 /// BASE_RENDER
 251 /*
 252  * Render the object.
 253  */
 254 METHOD(IClassRender, struct bmRender *, bmr)
 255 {
 256    ID                *id = INST_DATA(cl, obj);
 257    BC                *bc = BASE_DATA(obj);
 258    struct BaseInfo   *bi = bmr->bmr_BInfo;
 259    UBYTE             *str = NULL;
 260
 261    /*
 262     * Render the baseclass.
 263     */
 264    AsmDoSuperMethodA(cl, obj, (Msg)bmr);
 265
 266    /*
 267     * Setup the font.
 268     */
 269    if (id->id_Font) BSetFont(bi, id->id_Font);
 270
 271    Get_Attr(id->id_Text, TEXTA_Text, (IPTR *)&str);
 272
 273    if (str)
 274    {
 275       switch (id->id_Justification)
 276       {
 277       case IDJ_LEFT:
 278          str[1] = 'l';
 279          break;
 280       case IDJ_RIGHT:
 281          str[1] = 'r';
 282          break;
 283       case IDJ_CENTER:
 284          str[1] = 'c';
 285          break;
 286       }
 287       BSetDPenA(bi, TEXTPEN);
 288       DoMethod(id->id_Text, TEXTM_RENDER, bi, &bc->bc_InnerBox);
 289    };
 290    return 1;
 291 }
 292 METHOD_END
 293 ///
 294 /// GM_HITTEST
 295 /*
 296  * This object cannot be hit.
 297  */
 298 METHOD(IClassHitTest, Msg, msg)
 299 {
 300    return 0;
 301 }
 302 METHOD_END
 303 ///
 304 /// BASE_DIMENSIONS
 305 /*
 306  * Our parent group needs to know
 307  * something about our dimensions.
 308  */
 309 METHOD(IClassDimensions, struct bmDimensions *, bmd)
 310 {
 311    ID                *id = INST_DATA(cl, obj);
 312    struct RastPort   *rp = bmd->bmd_BInfo->bi_RPort;
 313    UWORD              mw, mh, w, h;
 314    LONG               old_level = id->id_Level;
 315
 316    mw = mh = w = h = 0;
 317
 318    /*
 319     * Compute size of minimum level.
 320     */
 321    SetLevel(id, id->id_Min);
 322
 323    DoMethod(id->id_Text, TEXTM_DIMENSIONS, rp, &mw, &mh);
 324
 325    /*
 326     * Compute size of maximum level.
 327     */
 328    SetLevel(id, id->id_Max);
 329
 330    DoMethod(id->id_Text, TEXTM_DIMENSIONS, rp, &w, &h);
 331
 332    if (mw < w) mw = w;
 333    if (mh < h) mh = h;
 334
 335    SetLevel(id, old_level);
 336
 337    /*
 338     * Add the width of an average digit.
 339     */
 340    mw += TextWidthNum(rp, "0123456789", 10) / 10;
 341
 342    /*
 343     * Setup minimum dimensions.
 344     */
 345    return CalcDimensions(cl, obj, bmd, mw, mh);
 346 }
 347 METHOD_END
 348 ///
 349 /// Class initialization.
 350 /*
 351  * Function table.
 352  */
 353 STATIC DPFUNC ClassFunc[] =
 354 {
 355    { BASE_RENDER,      IClassRender, },
 356    { BASE_DIMENSIONS,  IClassDimensions, },
 357
 358    { OM_NEW,           IClassNew, },
 359    { OM_SET,           IClassSetUpdate, },
 360    { OM_UPDATE,        IClassSetUpdate, },
 361    { OM_GET,           IClassGet, },
 362    { OM_DISPOSE,       IClassDispose, },
 363    { GM_HITTEST,       IClassHitTest, },
 364    { DF_END,           NULL },
 365 };
 366
 367 /*
 368  * Simple class initialization
 369  */
 370 makeproto Class *InitIndicatorClass(void)
 371 {
 372    return BGUI_MakeClass(CLASS_SuperClassBGUI, BGUI_BASE_GADGET,
 373                          CLASS_ObjectSize,     sizeof(ID),
 374                          CLASS_DFTable,        ClassFunc,
 375                          TAG_DONE);
 376 }
 377 ///