bgui/labelclass.c

   1 /*
   2  * @(#) $Header$
   3  *
   4  * BGUI library
   5  * labelclass.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.8  2004/06/16 20:16:48  verhaegs
  15  * Use METHODPROTO, METHOD_END and REGFUNCPROTOn where needed.
  16  *
  17  * Revision 42.7  2003/01/18 19:09:57  chodorowski
  18  * Instead of using the _AROS or __AROS preprocessor symbols, use __AROS__.
  19  *
  20  * Revision 42.6  2000/08/17 15:09:18  chodorowski
  21  * Fixed compiler warnings.
  22  *
  23  * Revision 42.5  2000/07/03 21:21:00  bergers
  24  * Replaced stch_l & stcu_d and had to make a few changes in other places because of that.
  25  *
  26  * Revision 42.4  2000/07/02 06:08:33  bergers
  27  * Compiles library alright (except that I took stch_l & stcu_d out) and seems to create the right type of object. Test1 also compiles alright but crashes somewhere...
  28  *
  29  * Revision 42.3  2000/05/29 15:42:49  stegerg
  30  * fixed some "comparison is always 1 due to limited range of data type"
  31  * errors
  32  *
  33  * Revision 42.2  2000/05/29 00:40:24  bergers
  34  * Update to compile with AROS now. Should also still compile with SASC etc since I only made changes that test the define __AROS__. The compilation is still very noisy but it does the trick for the main directory. Maybe members of the BGUI team should also have a look at the compiler warnings because some could also cause problems on other systems... (Comparison always TRUE due to datatype (or something like that)). And please compile it on an Amiga to see whether it still works... Thanks.
  35  *
  36  * Revision 42.1  2000/05/15 19:27:01  stegerg
  37  * another hundreds of REG() macro replacements in func headers/protos.
  38  *
  39  * Revision 42.0  2000/05/09 22:09:16  mlemos
  40  * Bumped to revision 42.0 before handing BGUI to AROS team
  41  *
  42  * Revision 41.11  2000/05/09 19:54:29  mlemos
  43  * Merged with the branch Manuel_Lemos_fixes.
  44  *
  45  * Revision 41.10.2.7  1999/08/03 05:11:53  mlemos
  46  * Ensured that the creation of the label rotation bitmaps are allocated as
  47  * friends of the rastport's bitmap.
  48  *
  49  * Revision 41.10.2.6  1998/12/07 03:07:01  mlemos
  50  * Replaced OpenFont and CloseFont calls by the respective BGUI debug macros.
  51  *
  52  * Revision 41.10.2.5  1998/10/16 02:58:47  mlemos
  53  * Fixed a bug in the computation of label dimensions that was ignoring that
  54  * labels may have padding space to left or above them.
  55  *
  56  * Revision 41.10.2.4  1998/10/15 04:59:44  mlemos
  57  * Fixed a bug in the computation of label dimensions that was ignoring that
  58  * labels have padding space arround them depending on their positions.
  59  * Fixed a bug that was making label class maximum size to not update
  60  * depending on nominal size.
  61  *
  62  * Revision 41.10.2.3  1998/05/22 03:50:04  mlemos
  63  * Ensured that the extent fields are initialized even when the label text is
  64  * set to NULL.
  65  *
  66  * Revision 41.10.2.2  1998/03/02 23:48:46  mlemos
  67  * Switched vector allocation functions calls to BGUI allocation functions.
  68  *
  69  * Revision 41.10.2.1  1998/02/28 02:24:43  mlemos
  70  * Made Dimensions method return size (0,0) when the label text is set to NULL
  71  *
  72  * Revision 41.10  1998/02/25 21:12:21  mlemos
  73  * Bumping to 41.10
  74  *
  75  * Revision 1.1  1998/02/25 17:08:42  mlemos
  76  * Ian sources
  77  *
  78  *
  79  */
  80
  81 /// Class definitions.
  82 #include "include/classdefs.h"
  83
  84 /*
  85  * Object instance data.
  86  */
  87 typedef struct ld_ {
  88    ULONG            ld_Flags;              /* Flags.                           */
  89    UBYTE           *ld_Text;               /* The label itself.                */
  90    ULONG            ld_TextID;             /* Text ID.                         */
  91    struct IBox      ld_Extent;             /* Label extent.                    */
  92    UWORD            ld_Width, ld_Height;   /* Nominal label size.              */
  93    struct TextAttr *ld_TextAttr;           /* Font to use.                     */
  94    struct TextFont *ld_Font;               /* The opened font.                 */
  95    UWORD            ld_Style, ld_SelStyle; /* Style in which to render.        */
  96    UBYTE            ld_Pen, ld_SelPen;     /* Pens to render normal/selected.  */
  97    UBYTE            ld_Place;              /* Where to render.                 */
  98    UBYTE            ld_UnderscoreChar;     /* Underscore indicator.            */
  99    UBYTE            ld_ErasePen;           /* Pen to erase with.               */
 100 }  LD;
 101
 102 #define LABF_SELFOPEN      (1<<31)
 103 #define LABF_EXT_VALID     (1<<30)
 104 #define LABF_DRIPEN        (1<<29)
 105 #define LABF_SELDRIPEN     (1<<28)
 106 #define LABF_DEFPEN        (1<<27)
 107 #define LABF_DEFSELPEN     (1<<26)
 108 #define LABF_NOPLACEIN     (1<<25)
 109
 110 #define LD_ENTRY(tag, offset, flags) PACK_ENTRY(LAB_TAGSTART, tag, ld_, offset, flags)
 111 #define LD_FLAG(tag, flag) PACK_LONGBIT(LAB_TAGSTART, tag, ld_, ld_Flags, PKCTRL_BIT, flag)
 112
 113 #define LD_PENTRY(tag, offset, flags) PACK_ENTRY(BGUI_PB, tag, ld_, offset, flags)
 114 #define LD_PFLAG(tag, flag) PACK_LONGBIT(BGUI_PB, tag, ld_, ld_Flags, PKCTRL_BIT, flag)
 115
 116 static ULONG LabelPackTable[] =
 117 {
 118    PACK_STARTTABLE(LAB_TAGSTART),
 119
 120    LD_ENTRY(LAB_LabelID,          ld_TextID,            PKCTRL_ULONG),
 121    LD_ENTRY(LAB_Style,            ld_Style,             PKCTRL_UWORD),
 122    LD_ENTRY(LAB_SelectedStyle,    ld_SelStyle,          PKCTRL_UWORD),
 123    LD_ENTRY(LAB_Place,            ld_Place,             PKCTRL_UBYTE),
 124    LD_ENTRY(LAB_Underscore,       ld_UnderscoreChar,    PKCTRL_UBYTE),
 125    LD_FLAG(LAB_Highlight,         LABF_HIGHLIGHT),
 126    LD_FLAG(LAB_HighUScore,        LABF_HIGH_USCORE),
 127    LD_FLAG(LAB_FlipX,             LABF_FLIP_X),
 128    LD_FLAG(LAB_FlipY,             LABF_FLIP_Y),
 129    LD_FLAG(LAB_FlipXY,            LABF_FLIP_XY),
 130    LD_FLAG(LAB_NoPlaceIn,         LABF_NOPLACEIN),
 131
 132    PACK_NEWOFFSET(BGUI_PB),
 133
 134    LD_PENTRY(IMAGE_ErasePen,      ld_ErasePen,          PKCTRL_UBYTE),
 135
 136    PACK_ENDTABLE
 137 };
 138 ///
 139
 140 /// OM_NEW
 141 /*
 142  * Create a shiny new object.
 143  */
 144 METHOD(LabelClassNew, struct opSet *, ops)
 145 {
 146    LD       *ld;
 147    IPTR      rc;
 148
 149    /*
 150     * First we let the superclass
 151     * create an object.
 152     */
 153    if ((rc = AsmDoSuperMethodA(cl, obj, (Msg)ops)))
 154    {
 155       /*
 156        * Get to the instance data.
 157        */
 158       ld = INST_DATA(cl, rc);
 159
 160       /*
 161        * Clear instance data and
 162        * setup the defaults.
 163        */
 164       ld->ld_Flags          = LABF_DEFPEN|LABF_DEFSELPEN;
 165       ld->ld_Style          = (UWORD)~0;
 166       ld->ld_SelStyle       = (UWORD)~0;
 167       ld->ld_Place          = PLACE_IN;
 168       ld->ld_UnderscoreChar = '_';
 169
 170       /*
 171        * Set attributes.
 172        */
 173       AsmCoerceMethod(cl, (Object *)rc, RM_SETM, ops->ops_AttrList, RAF_INITIAL);
 174
 175 #if 0
 176       if (fail)
 177       {
 178          /*
 179           * Failure!
 180           */
 181          AsmCoerceMethod(cl, (Object *)rc, OM_DISPOSE);
 182          rc = 0;
 183       }
 184 #endif
 185       // ld->ld_Flags |= LABF_FLIP_XY;
 186
 187    }
 188    return rc;
 189 }
 190 METHOD_END
 191 ///
 192 /// RM_GETATTRFLAGS
 193 /*
 194  * Get the flags of an attribute.
 195  */
 196 METHOD(LabelClassGetAttrFlags, struct rmAttr *, ra)
 197 {
 198    static struct TagItem chart[] =
 199    {
 200       { LAB_Label,            CHART_ATTR(ld_, ld_Text           ) | RAF_RESIZE, },
 201       { LAB_LabelID,          CHART_ATTR(ld_, ld_TextID         ), },
 202       { LAB_TextAttr,         CHART_ATTR(ld_, ld_TextAttr       ) | RAF_CUSTOM | RAF_RESIZE, },
 203       { LAB_Style,            CHART_ATTR(ld_, ld_Style          ) | RAF_REDRAW, },
 204       { LAB_SelectedStyle,    CHART_ATTR(ld_, ld_SelStyle       ) | RAF_REDRAW, },
 205       { LAB_Place,            CHART_ATTR(ld_, ld_Place          ) | RAF_REDRAW, },
 206       { LAB_Underscore,       CHART_ATTR(ld_, ld_UnderscoreChar ) | RAF_CUSTOM, },
 207       { LAB_Template,         CHART_ATTR(ld_, ld_Flags          ) | RAF_CUSTOM | RAF_ADDRESS, },
 208       { IMAGE_ErasePen,       CHART_ATTR(ld_, ld_ErasePen       ), },
 209       { IMAGE_TextFont,       CHART_ATTR(ld_, ld_Font           ) | RAF_CUSTOM | RAF_NOP, },
 210       { LAB_Pen,              CHART_ATTR(ld_, ld_Pen            ) | RAF_CUSTOM | RAF_NOP, },
 211       { LAB_DriPen,           CHART_ATTR(ld_, ld_Pen            ) | RAF_CUSTOM | RAF_NOP, },
 212       { LAB_SelectedPen,      CHART_ATTR(ld_, ld_SelPen         ) | RAF_CUSTOM | RAF_NOP, },
 213       { LAB_SelectedDriPen,   CHART_ATTR(ld_, ld_SelPen         ) | RAF_CUSTOM | RAF_NOP, },
 214
 215       { LAB_Highlight,        CHART_FLAG(ld_, ld_Flags, LABF_HIGHLIGHT  ) | RAF_REDRAW, },
 216       { LAB_HighUScore,       CHART_FLAG(ld_, ld_Flags, LABF_HIGH_USCORE) | RAF_REDRAW, },
 217       { LAB_FlipX,            CHART_FLAG(ld_, ld_Flags, LABF_FLIP_X     ) | RAF_REDRAW, },
 218       { LAB_FlipY,            CHART_FLAG(ld_, ld_Flags, LABF_FLIP_Y     ) | RAF_REDRAW, },
 219       { LAB_FlipXY,           CHART_FLAG(ld_, ld_Flags, LABF_FLIP_XY    ) | RAF_RESIZE, },
 220       { LAB_NoPlaceIn,        CHART_FLAG(ld_, ld_Flags, LABF_NOPLACEIN  ) | RAF_CUSTOM, },
 221
 222       { TAG_DONE },
 223    };
 224
 225    ULONG rc = GetTagData(ra->ra_Attr->ti_Tag, 0, chart);
 226
 227    return rc;
 228 }
 229 METHOD_END
 230 ///
 231 /// RM_SET
 232 /*
 233  * Set standard attributes.
 234  */
 235 METHOD(LabelClassSet, struct rmAttr *, ra)
 236 {
 237    return BGUI_SetAttrChart(cl, obj, ra);
 238 }
 239 METHOD_END
 240 ///
 241 /// RM_SETCUSTOM
 242 /*
 243  * Set custom attributes.
 244  */
 245 METHOD(LabelClassSetCustom, struct rmAttr *, ra)
 246 {
 247    LD               *ld = (LD *)INST_DATA(cl, obj);
 248    struct TextFont  *tf;
 249    IPTR              attr = ra->ra_Attr->ti_Tag;
 250    IPTR              data = ra->ra_Attr->ti_Data;
 251
 252    switch (attr)
 253    {
 254    case LAB_Template:
 255       if (data)
 256       {
 257          attr = 0;
 258          Get_Attr((Object *)data, LAB_Template, &attr);
 259          if (attr)
 260          {
 261             CopyMem((LD *)attr, ld, sizeof(LD));
 262             ld->ld_Flags &= ~LABF_SELFOPEN;
 263          };
 264       };
 265       break;
 266
 267    case IMAGE_TextFont:
 268       if (ld->ld_Font && (ld->ld_Flags & LABF_SELFOPEN))
 269          BGUI_CloseFont(ld->ld_Font);
 270       ld->ld_Font   = (struct TextFont *)data;
 271       ld->ld_Flags &= ~LABF_SELFOPEN;
 272       break;
 273
 274    case LAB_Place:
 275    case LAB_NoPlaceIn:
 276       if ((ld->ld_Flags & LABF_NOPLACEIN) && (ld->ld_Place == PLACE_IN))
 277          ld->ld_Place = PLACE_LEFT;
 278       break;
 279
 280    case LAB_Flags:
 281       ld->ld_Flags = (ld->ld_Flags & 0xFFFF0000) | data;
 282       break;
 283
 284    case LAB_TextAttr:
 285       if (data && (tf = BGUI_OpenFont((struct TextAttr *)data)))
 286       {
 287          if (ld->ld_Font && (ld->ld_Flags & LABF_SELFOPEN))
 288             BGUI_CloseFont(ld->ld_Font);
 289          ld->ld_Font     = tf;
 290          ld->ld_TextAttr = (struct TextAttr *)data;
 291          ld->ld_Flags   |= LABF_SELFOPEN;
 292       };
 293       break;
 294
 295    case LAB_Pen:
 296    case LAB_DriPen:
 297       if ((UWORD)data == (UWORD)~0)
 298       {
 299          ld->ld_Flags |= LABF_DEFPEN;
 300       }
 301       else
 302       {
 303          ld->ld_Flags &= ~LABF_DEFPEN;
 304          ld->ld_Pen    = data;
 305       };
 306       if (attr == LAB_Pen) ld->ld_Flags &= ~LABF_DRIPEN;
 307       else                 ld->ld_Flags |=  LABF_DRIPEN;
 308       break;
 309
 310    case LAB_SelectedPen:
 311    case LAB_SelectedDriPen:
 312       if ((UWORD)data == (UWORD)~0)
 313       {
 314          ld->ld_Flags |= LABF_DEFSELPEN;
 315       }
 316       else
 317       {
 318          ld->ld_Flags &= ~LABF_DEFSELPEN;
 319          ld->ld_SelPen = data;
 320       };
 321       if (attr == LAB_SelectedPen) ld->ld_Flags &= ~LABF_SELDRIPEN;
 322       else                         ld->ld_Flags |=  LABF_SELDRIPEN;
 323       break;
 324    };
 325    return 1;
 326 }
 327 METHOD_END
 328 ///
 329
 330 /// OM_GET
 331 /*
 332  * Give an attribute.
 333  */
 334 METHOD(LabelClassGet, struct opGet *, opg)
 335 {
 336    LD       *ld = INST_DATA(cl, obj);
 337    ULONG     rc = 1;
 338    Tag       tag = opg->opg_AttrID;
 339    IPTR     *store = opg->opg_Storage;
 340    UBYTE    *u;
 341
 342    /*
 343     * First we try if the attribute is known to us. If not we pass
 344     * it on to the superclass.
 345     */
 346    switch (tag)
 347    {
 348       case LAB_Template:
 349          STORE ld;
 350          break;
 351       case LAB_Label:
 352          STORE ld->ld_Text;
 353          break;
 354       case LAB_TextAttr:
 355          STORE ld->ld_TextAttr;
 356          break;
 357       case LAB_Pen:
 358          STORE (!(ld->ld_Flags & LABF_DEFPEN) && !(ld->ld_Flags & LABF_DRIPEN)) ? ld->ld_Pen : (ULONG)~0;
 359          break;
 360       case LAB_DriPen:
 361          STORE (!(ld->ld_Flags & LABF_DEFPEN) &&  (ld->ld_Flags & LABF_DRIPEN)) ? ld->ld_Pen : (ULONG)~0;
 362          break;
 363       case LAB_SelectedPen:
 364          STORE (!(ld->ld_Flags & LABF_DEFSELPEN) && !(ld->ld_Flags & LABF_SELDRIPEN)) ? ld->ld_SelPen : (ULONG)~0;
 365          break;
 366       case LAB_SelectedDriPen:
 367          STORE (!(ld->ld_Flags & LABF_DEFSELPEN) &&  (ld->ld_Flags & LABF_SELDRIPEN)) ? ld->ld_SelPen : (ULONG)~0;
 368          break;
 369       case LAB_KeyChar:
 370          if (ld->ld_Text && ld->ld_UnderscoreChar)
 371          {
 372             if ((u = strchr(ld->ld_Text, ld->ld_UnderscoreChar)))
 373                STORE (u + 1);
 374          };
 375          break;
 376       case LAB_Flags:
 377          STORE ld->ld_Flags;
 378          break;
 379       default:
 380          rc = BGUI_UnpackStructureTag((UBYTE *)ld, LabelPackTable, tag, store);
 381          if (!rc) rc = AsmDoSuperMethodA(cl, obj, (Msg)opg);
 382          break;
 383    };
 384    return rc;
 385 }
 386 METHOD_END
 387 ///
 388 /// OM_DISPOSE
 389 /*
 390  * Dispose of the object.
 391  */
 392 METHOD(LabelClassDispose, Msg, msg)
 393 {
 394    LD       *ld = INST_DATA(cl, obj);
 395
 396    /*
 397     * Close the font.
 398     */
 399    if (ld->ld_Font && (ld->ld_Flags & LABF_SELFOPEN))
 400       BGUI_CloseFont(ld->ld_Font);
 401
 402    /*
 403     * The rest goes to the superclass.
 404     */
 405    return AsmDoSuperMethodA(cl, obj, msg);
 406 }
 407 METHOD_END
 408 ///
 409 /// IM_DRAW, IM_ERASE, IM_EXTENT
 410 /*
 411  * Render, erase or find out it's extensions.
 412  */
 413 METHOD(LabelClassDrawErase, struct impDraw *, dr)
 414 {
 415    LD                *ld = INST_DATA(cl, obj);
 416    struct RastPort    rrp = *(dr->imp_RPort), trp;
 417    struct impExtent  *ie = (struct impExtent *)dr;
 418    struct IBox       *bounds, box;
 419    UBYTE             *chunky1, *chunky2;
 420
 421    UBYTE       *text = NULL, *s, *d, c;
 422    UWORD       *pens = NULL, pen, style;
 423    WORD         xpos, ypos, tw, th;
 424    ULONG        rc = 0;
 425    int          i1, j1, j2, rw, rh;
 426
 427    BOOL         sel = (dr->imp_State == IDS_SELECTED) || (dr->imp_State == IDS_INACTIVESELECTED);
 428
 429    /*
 430     * Obtain image box bounds.
 431     */
 432    WORD l = IMAGE(obj)->LeftEdge;
 433    WORD t = IMAGE(obj)->TopEdge;
 434    WORD w = IMAGE(obj)->Width;
 435    WORD h = IMAGE(obj)->Height;
 436
 437    /*
 438     * Get pens.
 439     */
 440    if (dr->MethodID == IM_DRAW) pens = PENS(dr->imp_DrInfo);
 441
 442    /*
 443     * Add offsets when necessary.
 444     */
 445    if (dr->MethodID != IM_EXTENT)
 446    {
 447       l += dr->imp_Offset.X;
 448       t += dr->imp_Offset.Y;
 449    }
 450    else
 451    {
 452       bounds = ie->impe_Extent;
 453       bounds->Left = bounds->Top = bounds->Width = bounds->Height = 0;
 454    }
 455
 456    /*
 457     * Only do the label when it actually exists.
 458     */
 459    if ((s = ld->ld_Text))
 460    {
 461       text = BGUI_AllocPoolMem(strlen(s) + 30);
 462    };
 463    if ((d = text))
 464    {
 465       rc = 1;
 466
 467       *d++ = '\33';                          /* 2 */
 468       switch (ld->ld_Place)
 469       {
 470       case PLACE_LEFT:
 471          *d++ = 'r';
 472          break;
 473       case PLACE_RIGHT:
 474          *d++ = 'l';
 475          break;
 476       default:
 477          *d++ = 'c';
 478          break;
 479       };
 480
 481       /*
 482        * Set font style.
 483        */
 484       style = sel ? ld->ld_SelStyle : ld->ld_Style;
 485       if (sel && (style == (UWORD)~0)) style = ld->ld_Style;
 486
 487       if (style != (UWORD)~0)
 488       {
 489          if (style & FSF_ITALIC)      /* 2 */
 490          {
 491             *d++ = '\33';
 492             *d++ = 'i';
 493          };
 494          if (style & FSF_BOLD)        /* 2 */
 495          {
 496             *d++ = '\33';
 497             *d++ = 'b';
 498          };
 499          if (style & FSF_UNDERLINED)  /* 2 */
 500          {
 501             *d++ = '\33';
 502             *d++ = 'u';
 503          };
 504       };
 505
 506       c = 0;
 507       if (dr->MethodID == IM_DRAW)           /* 5 */
 508       {
 509          if (ld->ld_Flags & LABF_HIGHLIGHT)
 510          {
 511             c   = 'd';
 512             pen = HIGHLIGHTTEXTPEN;
 513          }
 514          else
 515          {
 516             /*
 517              * What state are we in?
 518              */
 519             if (sel)
 520             {
 521                /*
 522                 * First see if a selected (dri)pen is
 523                 * given. If not use the default colors.
 524                 */
 525                if (ld->ld_Flags & LABF_DEFSELPEN)
 526                {
 527                   c   = 'd';
 528                   pen = (dr->imp_State == IDS_SELECTED) ? FILLTEXTPEN : TEXTPEN;
 529                }
 530                else
 531                {
 532                   c = (ld->ld_Flags & LABF_SELDRIPEN) ? 'd' : 'p';
 533                   pen = ld->ld_SelPen;
 534                };
 535             }
 536             else
 537             {
 538                /*
 539                 * First see if a normal (dri)pen is
 540                 * given. If not use the default colors.
 541                 */
 542                if (ld->ld_Flags & LABF_DEFPEN)
 543                {
 544                   c   = 'd';
 545                   pen = TEXTPEN;
 546                }
 547                else
 548                {
 549                   c   = (ld->ld_Flags & LABF_DRIPEN) ? 'd' : 'p';
 550                   pen = ld->ld_Pen;
 551                };
 552             };
 553          };
 554       }
 555       else if (dr->MethodID == IM_ERASE)
 556       {
 557          c   = 'p';
 558          pen = ld->ld_ErasePen;
 559       };
 560       if (c)                                       /* 6 */
 561       {
 562          *d++ = '\33';
 563          *d++ = c;
 564 #ifdef __AROS__
 565         d += sprintf(d, "%u", pen);
 566 #else
 567          d += stcu_d(d, pen);
 568 #endif
 569       };
 570
 571       *d++ = '\33';                                /* 2 */
 572       *d++ = '\33';
 573
 574       while ((c = *s++))
 575       {
 576          if (c == ld->ld_UnderscoreChar)           /* 5 */
 577          {
 578             if (*s)
 579             {
 580                if ((*s < 32) || (*s == 127))
 581                {
 582                   s++;
 583                }
 584                else
 585                {
 586                   c = (ld->ld_Flags & LABF_HIGH_USCORE) ? 'Z' : 'z';
 587                   *d++ = '\33';
 588                   *d++ = c;
 589                   *d++ = *s++;
 590                   if (*s)
 591                   {
 592                      *d++ = '\33';
 593                      *d++ = '-';
 594                      *d++ = c;
 595                   };
 596                };
 597                strcpy(d, s);
 598             };
 599             break;
 600          };
 601          *d++ = c;
 602       };
 603
 604       /*
 605        * If a font is available, set it in the rastport.
 606        */
 607       if (ld->ld_Font) FSetFont(&rrp, ld->ld_Font);
 608
 609       /*
 610        * Setup drawmode.
 611        */
 612       FSetDrMd(&rrp, JAM1);
 613
 614       /*
 615        * Get label pixel size.
 616        */
 617       th = TotalHeight(&rrp, text);
 618       tw = TotalWidth (&rrp, text);
 619
 620       if (ld->ld_Flags & LABF_FLIP_XY)
 621       {
 622          i1 = th; th = tw; tw = i1;
 623       };
 624
 625       ld->ld_Width  = tw;
 626       ld->ld_Height = th;
 627
 628       /*
 629        * Preset x & y position.
 630        */
 631       xpos = l;
 632       ypos = t;
 633
 634       /*
 635        * No need to place the text when we
 636        * want the maximum extentiions.
 637        */
 638       if (dr->MethodID == IM_EXTENT && (ie->impe_Flags & EXTF_MAXIMUM))
 639          goto maximumExtent;
 640
 641       reCalculate:
 642
 643       /*
 644        * Determine Y position.
 645        */
 646       switch (ld->ld_Place)
 647       {
 648          case PLACE_LEFT:
 649          case PLACE_IN:
 650          case PLACE_RIGHT:
 651             ypos += (h - th) >> 1;
 652             break;
 653
 654          case PLACE_ABOVE:
 655             ypos -= (th + 4);
 656             break;
 657
 658          case PLACE_BELOW:
 659             ypos += (h + 3);
 660             break;
 661       }
 662
 663       /*
 664        * Determine X position.
 665        */
 666       switch (ld->ld_Place)
 667       {
 668          case PLACE_ABOVE:
 669          case PLACE_IN:
 670          case PLACE_BELOW:
 671             xpos += (w - tw) >> 1;
 672             break;
 673
 674          case PLACE_LEFT:
 675             xpos -= (tw + 8);
 676             break;
 677
 678          case PLACE_RIGHT:
 679             xpos += (w + 7);
 680             break;
 681       }
 682
 683       /*
 684        * IM_EXTENT method?
 685        */
 686       if (dr->MethodID == IM_EXTENT)
 687       {
 688          maximumExtent:
 689          /*
 690           * Pick up extent storage, preset to 0.
 691           */
 692          bounds = ie->impe_Extent;
 693          bounds->Left = bounds->Top = bounds->Width = bounds->Height = 0;
 694
 695          /*
 696           * No negative offsets.
 697           */
 698          if ((l <= 0) || (t <= 0))
 699          {
 700             if (l <= 0) l = tw + 8;
 701             if (t <= 0) t = th + 4;
 702             goto reCalculate;
 703          }
 704
 705          /*
 706           * Maximum?
 707           */
 708          if (ie->impe_Flags & EXTF_MAXIMUM)
 709          {
 710             switch (ld->ld_Place)
 711             {
 712             case PLACE_LEFT:
 713                bounds->Left   = -(tw + 8);
 714                break;
 715             case PLACE_RIGHT:
 716                bounds->Width  =  (tw + 7);
 717                break;
 718             case PLACE_ABOVE:
 719                bounds->Top    = -(th + 4);
 720                break;
 721             case PLACE_BELOW:
 722                bounds->Height =  (th + 3);
 723                break;
 724             }
 725          }
 726          else
 727          {
 728             if (xpos < l)                    bounds->Left   = -(l - xpos);
 729             if ((xpos + tw) > (l + w - 1))   bounds->Width  = (xpos + tw) - (l + w - 1);
 730             if (ypos < t)                    bounds->Top    = -(t - ypos);
 731             if ((ypos + th) > (t + h - 1))   bounds->Height = (ypos + th) - (t + h - 1);
 732          }
 733
 734          /*
 735           * Store label width and height.
 736           */
 737          if (ie->impe_LabelSize.Width)  *(ie->impe_LabelSize.Width)  = tw;
 738          if (ie->impe_LabelSize.Height) *(ie->impe_LabelSize.Height) = th;
 739       }
 740       else
 741       {
 742          if (ld->ld_Flags & (LABF_FLIP_XY|LABF_FLIP_X|LABF_FLIP_Y))
 743          {
 744             rrp.BitMap = BGUI_AllocBitMap(tw, th, FGetDepth(&rrp), BMF_STANDARD, dr->imp_RPort->BitMap);
 745
 746             if (rrp.BitMap)
 747             {
 748                rrp.Layer = NULL;
 749                ClipBlit(dr->imp_RPort, xpos, ypos, &rrp, 0, 0, tw, th, 0xC0);
 750             };
 751             box.Left = box.Top = 0;
 752          }
 753          else
 754          {
 755             box.Left = xpos;
 756             box.Top  = ypos;
 757          };
 758
 759          /*
 760           * Move to the correct location.
 761           */
 762          box.Width   = tw;
 763          box.Height  = th;
 764
 765          if (rrp.BitMap) RenderInfoText(&rrp, text, pens, &box, (UWORD)~0);
 766
 767          if (ld->ld_Flags & (LABF_FLIP_XY|LABF_FLIP_X|LABF_FLIP_Y))
 768          {
 769             if (rrp.BitMap)
 770             {
 771                rw = ((tw + 15) >> 4) << 4;
 772
 773                if ((chunky1 = BGUI_AllocPoolMem(rw * th)))
 774                {
 775                   trp = rrp;
 776                   if ((trp.BitMap = BGUI_AllocBitMap(rw, 1, FGetDepth(&rrp), BMF_STANDARD, dr->imp_RPort->BitMap)))
 777                   {
 778                      ReadPixelArray8(&rrp, 0, 0, tw - 1, th - 1, chunky1, &trp);
 779                      BGUI_FreeBitMap(rrp.BitMap);
 780                      rrp.BitMap = NULL;
 781
 782                      if (ld->ld_Flags & LABF_FLIP_X)
 783                      {
 784                         s = chunky1;
 785
 786                         for (i1 = th; i1; i1--)
 787                         {
 788                            for (j1 = 0, j2 = tw - 1; j1 < j2; j1++, j2--)
 789                            {
 790                               c = s[j1];
 791                               s[j1] = s[j2];
 792                               s[j2] = c;
 793                            };
 794                            s += rw;
 795                         };
 796                      };
 797
 798                      if (ld->ld_Flags & LABF_FLIP_Y)
 799                      {
 800                         s = chunky1;
 801                         d = chunky1 + rw * (th - 1);
 802
 803                         while (s < d)
 804                         {
 805                            for (j1 = tw - 1; j1; j1--)
 806                            {
 807                               c = s[j1];
 808                               s[j1] = d[j1];
 809                               d[j1] = c;
 810                            };
 811                            s += rw;
 812                            d -= rw;
 813                         };
 814                      };
 815
 816                      if (ld->ld_Flags & LABF_FLIP_XY)
 817                      {
 818                         chunky2 = chunky1;
 819                         rh = ((th + 15) >> 4) << 4;
 820
 821                         if ((chunky1 = BGUI_AllocPoolMem(tw * rh)))
 822                         {
 823                            for (i1 = 0; i1 < th; i1++)
 824                            {
 825                               for (j1 = 0; j1 < tw; j1++)
 826                               {
 827                                  chunky1[(j1 * rh) + i1] = chunky2[(i1 * rw) + j1];
 828                               };
 829                            };
 830                            BGUI_FreePoolMem(chunky2);
 831                         }
 832                         else chunky1 = chunky2;
 833                         i1 = tw; tw = th; th = i1;
 834
 835                         BGUI_FreeBitMap(trp.BitMap);
 836                         trp.BitMap = BGUI_AllocBitMap(rw, 1, FGetDepth(&rrp), BMF_STANDARD, dr->imp_RPort->BitMap);
 837                      };
 838                      if (trp.BitMap)
 839                      {
 840                         WritePixelArray8(dr->imp_RPort, xpos, ypos,
 841                            xpos + tw - 1, ypos + th - 1, chunky1, &trp);
 842                         BGUI_FreeBitMap(trp.BitMap);
 843                      };
 844                   };
 845                   BGUI_FreePoolMem(chunky1);
 846                };
 847                BGUI_FreeBitMap(rrp.BitMap);
 848             };
 849          };
 850       };
 851       BGUI_FreePoolMem(text);
 852    }
 853    return rc;
 854 }
 855 METHOD_END
 856 ///
 857 /// BASE_LOCALIZE
 858
 859 METHOD(LabelClassLocalize, struct bmLocalize *, bml)
 860 {
 861    LD    *ld = INST_DATA(cl, obj);
 862    ULONG  rc = 0;
 863
 864    if (ld->ld_TextID)
 865    {
 866       ld->ld_Text = BGUI_GetCatalogStr(bml->bml_Locale, ld->ld_TextID, ld->ld_Text);
 867       rc = 1;
 868    }
 869    return rc;
 870 }
 871 METHOD_END
 872 ///
 873 /// BASE_DIMENSIONS
 874
 875 METHOD(LabelClassDimensions, struct bmDimensions *, bmd)
 876 {
 877    LD                *ld = INST_DATA(cl, obj);
 878    struct BaseInfo   *bi = bmd->bmd_BInfo;
 879    struct bguiExtent *be = bmd->bmd_Extent;
 880    UWORD                lh;
 881    UWORD                lw;
 882
 883    {
 884       struct IBox extentions;
 885
 886       if(DoExtentMethod(obj, bi->bi_RPort, &extentions, &lw, &lh, EXTF_MAXIMUM))
 887       {
 888          lw=max(lw,max(-extentions.Left,extentions.Width));
 889          lh=max(lh,max(-extentions.Top,extentions.Height));
 890       }
 891       else
 892          lw=lh=0;
 893    }
 894    switch (ld->ld_Place)
 895    {
 896    case PLACE_ABOVE:
 897    case PLACE_BELOW:
 898       if (be->be_Min.Width < lw) be->be_Min.Width = lw;
 899       if (be->be_Nom.Width < lw) be->be_Nom.Width = lw;
 900       break;
 901    case PLACE_IN:
 902       lw += 4;
 903    default:
 904       be->be_Min.Width += lw;
 905       be->be_Nom.Width += lw;
 906       break;
 907    };
 908
 909    switch (ld->ld_Place)
 910    {
 911    case PLACE_LEFT:
 912    case PLACE_RIGHT:
 913       if (be->be_Min.Height < lh) be->be_Min.Height = lh;
 914       if (be->be_Nom.Height < lh) be->be_Nom.Height = lh;
 915       break;
 916    case PLACE_IN:
 917       lh += 2;
 918    default:
 919       be->be_Min.Height += lh;
 920       be->be_Nom.Height += lh;
 921       break;
 922    };
 923    be->be_Max.Width=max(be->be_Max.Width,be->be_Nom.Width);
 924    be->be_Max.Height=max(be->be_Max.Height,be->be_Nom.Height);
 925    return 1;
 926 }
 927 METHOD_END
 928 ///
 929
 930 /// Class initialization.
 931
 932 /*
 933  * Class function table.
 934  */
 935 STATIC DPFUNC ClassFunc[] = {
 936    { RM_SET,                LabelClassSet, },
 937    { RM_SETCUSTOM,          LabelClassSetCustom, },
 938    { RM_GETATTRFLAGS,       LabelClassGetAttrFlags, },
 939    { IM_DRAW,               LabelClassDrawErase, },
 940
 941    { OM_GET,                LabelClassGet, },
 942    { OM_NEW,                LabelClassNew, },
 943    { OM_DISPOSE,            LabelClassDispose, },
 944    { IM_EXTENT,             LabelClassDrawErase, },
 945    { IM_ERASE,              LabelClassDrawErase, },
 946    { BASE_LOCALIZE,         LabelClassLocalize, },
 947    { BASE_DIMENSIONS,       LabelClassDimensions, },
 948    { DF_END },
 949 };
 950
 951 /*
 952  * Simple class initialization.
 953  */
 954 makeproto Class *InitLabelClass(void)
 955 {
 956    return BGUI_MakeClass(CLASS_SuperClassBGUI, BGUI_IMAGE_OBJECT,
 957                          CLASS_ObjectSize,     sizeof(LD),
 958                          CLASS_DFTable,        ClassFunc,
 959                          TAG_DONE);
 960 }
 961 ///
 962