bgui/stringclass.c

   1 /*
   2  * @(#) $Header$
   3  *
   4  * BGUI library
   5  * stringclass.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.3  2004/06/16 20:16:48  verhaegs
  15  * Use METHODPROTO, METHOD_END and REGFUNCPROTOn where needed.
  16  *
  17  * Revision 42.2  2000/05/15 19:27:02  stegerg
  18  * another hundreds of REG() macro replacements in func headers/protos.
  19  *
  20  * Revision 42.1  2000/05/14 23:32:48  stegerg
  21  * changed over 200 function headers which all use register
  22  * parameters (oh boy ...), because the simple REG() macro
  23  * doesn't work with AROS. And there are still hundreds
  24  * of headers left to be fixed :(
  25  *
  26  * Many of these functions would also work with stack
  27  * params, but since i have fixed every single one
  28  * I encountered up to now, I guess will have to do
  29  * the same for the rest.
  30  *
  31  * Revision 42.0  2000/05/09 22:10:23  mlemos
  32  * Bumped to revision 42.0 before handing BGUI to AROS team
  33  *
  34  * Revision 41.11  2000/05/09 19:55:14  mlemos
  35  * Merged with the branch Manuel_Lemos_fixes.
  36  *
  37  * Revision 41.10.2.2  1999/08/05 01:40:28  mlemos
  38  * Added Jilles Tjoelker fix to assure that OM_GET always get a STRING_LongVal
  39  * value within the integer range limits.
  40  *
  41  * Revision 41.10.2.1  1998/07/05 19:27:59  mlemos
  42  * Made calls to RectFill be made to safe RectFill instead.
  43  *
  44  * Revision 41.10  1998/02/25 21:13:15  mlemos
  45  * Bumping to 41.10
  46  *
  47  * Revision 1.1  1998/02/25 17:09:52  mlemos
  48  * Ian sources
  49  *
  50  *
  51  */
  52
  53 /// Class definitions.
  54
  55 #include "include/classdefs.h"
  56
  57 /*
  58  * Object instance data.
  59  */
  60 typedef struct {
  61    Object             *sd_StrGad;        /* strgclass object                 */
  62    UBYTE              *sd_TextContents;     /* contents of the string gadget   */
  63    LONG                sd_IntegerContents;     /* contents of the integer gadget  */
  64    LONG                sd_IntegerMin;       /* minimum integer contents         */
  65    LONG                sd_IntegerMax;       /* maximum integer contents         */
  66    struct TextFont    *sd_Font;         /* string gadget font     */
  67    ULONG               sd_Pens;          /* Copy of user-pens.     */
  68    ULONG               sd_Active;        /*   "   "   "    "                  */
  69    ULONG               sd_MinChars;      /* Min # of chars visible.      */
  70    UBYTE              *sd_Buffer;        /* BGUI allocated buffers    */
  71    UBYTE              *sd_UndoBuffer;       /*   "       "       "               */
  72    UBYTE              *sd_WorkBuffer;       /*   "       "       "               */
  73    UWORD               sd_Flags;         /* See below        */
  74    Object             *sd_T_View;
  75    WORD                sd_T_X, sd_T_Y;
  76    WORD                sd_T_W, sd_T_H;
  77    struct RastPort    *sd_T_Buffer;
  78    struct Window      *sd_T_Window;
  79 } SD;
  80
  81 #define SDF_STRINGACTIVE    (1<<0)         /* The strgclass object is active  */
  82
  83 ///
  84
  85
  86 /*
  87  * Obtain the LongVal and TextVal
  88  * values from the strgclass object.
  89  */
  90 STATIC ASM VOID GetValues(REG(a0) SD *sd)
  91 {
  92    IPTR tmp;
  93    Get_Attr(sd->sd_StrGad, STRINGA_TextVal, (IPTR *)&sd->sd_TextContents);
  94    Get_Attr(sd->sd_StrGad, STRINGA_LongVal, &tmp);
  95    sd->sd_IntegerContents = (LONG)tmp;
  96 }
  97
  98 /*
  99  * Object cleanup.
 100  */
 101 STATIC METHOD(StringClassDispose, Msg, msg )
 102 {
 103    SD       *sd = INST_DATA(cl, obj);
 104
 105    /*
 106     * Dispose of the strgadget.
 107     */
 108    DisposeObject(sd->sd_StrGad);
 109
 110    /*
 111     * Kill the buffers.
 112     */
 113    if (sd->sd_Buffer    ) BGUI_FreePoolMem(sd->sd_Buffer    );
 114    if (sd->sd_UndoBuffer) BGUI_FreePoolMem(sd->sd_UndoBuffer);
 115    if (sd->sd_WorkBuffer) BGUI_FreePoolMem(sd->sd_WorkBuffer);
 116
 117    /*
 118     * The rest is for the superclass.
 119     */
 120    return AsmDoSuperMethodA(cl, obj, msg);
 121 }
 122 METHOD_END
 123
 124 /*
 125  * Allocate buffers. (Only when maxchars > 128)
 126  */
 127 STATIC ASM BOOL StringClassBuffers( REG(a0) SD *sd, REG(a1) struct TagItem *tags, REG(d0) ULONG max )
 128 {
 129    /*
 130     * We only allocate buffer when:
 131     *
 132     * A) The maximum amount of characters exceeds
 133     *    128 bytes.
 134     * B) The user did not supply his/her own
 135     *    buffers.
 136     */
 137    if ( ! FindTagItem( STRINGA_Buffer, tags )) {
 138       if ( ! ( sd->sd_Buffer = ( UBYTE * )BGUI_AllocPoolMem( max )))
 139          return( FALSE );
 140    }
 141    if ( ! FindTagItem( STRINGA_UndoBuffer, tags )) {
 142       if ( ! ( sd->sd_UndoBuffer = ( UBYTE * )BGUI_AllocPoolMem( max )))
 143          return( FALSE );
 144    }
 145    if ( ! FindTagItem( STRINGA_WorkBuffer, tags )) {
 146       if ( ! ( sd->sd_WorkBuffer = ( UBYTE * )BGUI_AllocPoolMem( max )))
 147          return( FALSE );
 148    }
 149    return( TRUE );
 150 }
 151
 152 /*
 153  * Create a shiny new object.
 154  */
 155 STATIC METHOD(StringClassNew, struct opSet *, ops )
 156 {
 157    SD             *sd;
 158    struct TagItem *tag, *tags;
 159    IPTR            rc;
 160
 161    tags = DefTagList(BGUI_STRING_GADGET, ops->ops_AttrList);
 162
 163    /*
 164     * First we let the superclass
 165     * create an object.
 166     */
 167    if ((rc = NewSuperObject(cl, obj, tags)))
 168    {
 169       sd = INST_DATA(cl, rc);
 170
 171       /*
 172        * Force activation flags.
 173        */
 174       GADGET(rc)->Activation |= GACT_RELVERIFY;
 175
 176       /*
 177        * Setup defaults.
 178        */
 179       sd->sd_IntegerMin = GetTagData(STRINGA_IntegerMin, 0xEFFFFFFF, tags);
 180       sd->sd_IntegerMax = GetTagData(STRINGA_IntegerMax, 0x0FFFFFFF, tags);
 181
 182       /*
 183        * We take care of the GA_Disabled attribute
 184        * so we don't let the strgclass see it.
 185        */
 186       if ((tag = FindTagItem(GA_Disabled, tags)))
 187          tag->ti_Tag = TAG_IGNORE;
 188
 189       /*
 190        * Handle NULL-STRINGA_TextVal.
 191        */
 192       if ((tag = FindTagItem(STRINGA_TextVal, tags)))
 193       {
 194          if (!tag->ti_Data)
 195             tag->ti_Data = (IPTR)"";
 196       }
 197       else if ((tag = FindTagItem(STRINGA_LongVal, tags)))
 198       {
 199          /*
 200           * Clamp the integer value between
 201           * min and max.
 202           */
 203          tag->ti_Data = range((LONG)tag->ti_Data, sd->sd_IntegerMin, sd->sd_IntegerMax);
 204       };
 205
 206       /*
 207        * Work-around for STRINGA_MaxChars.
 208        */
 209       if ((tag = FindTagItem(STRINGA_MaxChars, tags)))
 210       {
 211          tag->ti_Data++;
 212          /*
 213           * See if we need to allocate the
 214           * buffers.
 215           */
 216          if (tag->ti_Data > 128)
 217          {
 218             if (!StringClassBuffers(sd, tags, tag->ti_Data))
 219                goto stringFail;
 220          };
 221       };
 222
 223       /*
 224        * Create a strgclass object.
 225        */
 226       if ((sd->sd_StrGad = NewObject( NULL, StrGClass,
 227                             sd->sd_Buffer     ? STRINGA_Buffer     : TAG_IGNORE, sd->sd_Buffer,
 228                             sd->sd_UndoBuffer ? STRINGA_UndoBuffer : TAG_IGNORE, sd->sd_UndoBuffer,
 229                             sd->sd_WorkBuffer ? STRINGA_WorkBuffer : TAG_IGNORE, sd->sd_WorkBuffer,
 230                             TAG_MORE, tags)))
 231       {
 232          /*
 233           * Copy of the pens.
 234           */
 235          if ((tag = FindTagItem(STRINGA_Pens,       tags))) sd->sd_Pens   = tag->ti_Data;
 236          if ((tag = FindTagItem(STRINGA_ActivePens, tags))) sd->sd_Active = tag->ti_Data;
 237
 238          /*
 239           * Obtain LongVal and TextVal values.
 240           */
 241          GetValues(sd);
 242
 243          /*
 244           * Get the minimum number of chars always visible.
 245           */
 246          sd->sd_MinChars = GetTagData(STRINGA_MinCharsVisible, 2, tags);
 247          if (sd->sd_MinChars < 2) sd->sd_MinChars = 2;
 248       }
 249       else
 250       {
 251          stringFail:
 252          AsmCoerceMethod(cl, (Object *)rc, OM_DISPOSE);
 253          rc = 0;
 254       };
 255    };
 256    FreeTagItems(tags);
 257
 258    return rc;
 259 }
 260 METHOD_END
 261
 262 /*
 263  * Change the object attributes.
 264  */
 265 STATIC METHOD(StringClassSetUpdate, struct opUpdate *, opu )
 266 {
 267    SD                *sd = INST_DATA(cl, obj);
 268    struct TagItem    *clones, *tag;
 269    WORD               dis = GADGET( obj )->Flags & GFLG_DISABLED, gv = 0;
 270    ULONG              rc = 1;
 271    IPTR               inhibit;
 272    //BC                *bc = BASE_DATA(obj);
 273    struct GadgetInfo *gi = opu->opu_GInfo;
 274
 275    /*
 276     * First we let the superclass
 277     * change what it can.
 278     */
 279    AsmDoSuperMethodA(cl, obj, (Msg)opu);
 280
 281    /*
 282     * Clone tags.
 283     */
 284    if ((clones = CloneTagItems(opu->opu_AttrList)))
 285    {
 286       /*
 287        * Get min and max.
 288        */
 289       sd->sd_IntegerMin = GetTagData(STRINGA_IntegerMin, sd->sd_IntegerMin, clones);
 290       sd->sd_IntegerMax = GetTagData(STRINGA_IntegerMax, sd->sd_IntegerMax, clones);
 291       /*
 292        * Handle NULL-STRINGA_TextVal.
 293        */
 294       if ((tag = FindTagItem(STRINGA_TextVal, clones)))
 295       {
 296          if (!tag->ti_Data) tag->ti_Data = (IPTR)"";
 297          gv = TRUE;
 298       }
 299       else if ((tag = FindTagItem(STRINGA_LongVal, clones)))
 300       {
 301          /*
 302           * Clamp value between min and max.
 303           */
 304          tag->ti_Data = range((LONG)tag->ti_Data, sd->sd_IntegerMin, sd->sd_IntegerMax);
 305          gv = TRUE;
 306       }
 307
 308       /*
 309        * We handle GA_Disabled.
 310        */
 311       if ((tag = FindTagItem(GA_Disabled, clones)))
 312          tag->ti_Tag = TAG_IGNORE;
 313
 314       /*
 315       if (tag = FindTagItem(GA_Left,   clones)) tag->ti_Data += bc->bc_InnerBox.Left   - bc->bc_OuterBox.Left;
 316       if (tag = FindTagItem(GA_Top,    clones)) tag->ti_Data += bc->bc_InnerBox.Top    - bc->bc_OuterBox.Top;
 317       if (tag = FindTagItem(GA_Width,  clones)) tag->ti_Data += bc->bc_InnerBox.Width  - bc->bc_OuterBox.Width;
 318       if (tag = FindTagItem(GA_Height, clones)) tag->ti_Data += bc->bc_InnerBox.Height - bc->bc_OuterBox.Height;
 319       */
 320
 321       /*
 322        * Rendering inhibited?
 323        */
 324       Get_SuperAttr(cl, obj, BT_Inhibit, &inhibit);
 325
 326       /*
 327        * Set strgclass attributes.
 328        */
 329       AsmDoMethod(sd->sd_StrGad, opu->MethodID, clones, inhibit ? NULL : gi, opu->opu_Flags);
 330
 331       /*
 332        * Force activation flags.
 333        */
 334       GADGET( obj )->Activation |= GACT_RELVERIFY;
 335
 336       /*
 337        * Setting a new font? Save it..
 338        */
 339       if (opu->MethodID == OM_SET)
 340       {
 341          if ((tag = FindTagItem(BT_TextAttr, clones)))
 342          {
 343             Get_SuperAttr(cl, obj, BT_TextFont, (IPTR *)&sd->sd_Font);
 344             DoSetMethodNG(sd->sd_StrGad, STRINGA_Font, sd->sd_Font, TAG_END);
 345          }
 346          /*
 347           * Copy of the pens.
 348           */
 349          if ((tag = FindTagItem(STRINGA_Pens,       clones))) sd->sd_Pens   = tag->ti_Data;
 350          if ((tag = FindTagItem(STRINGA_ActivePens, clones))) sd->sd_Active = tag->ti_Data;
 351       }
 352
 353       /*
 354        * Get the LongVal and TextVal values.
 355        */
 356       GetValues(sd);
 357
 358       /*
 359        * Change visually?
 360        */
 361       if (((GADGET(obj)->Flags & GFLG_DISABLED) != dis) || gv)
 362          DoRenderMethod(obj, gi, GREDRAW_UPDATE);
 363
 364       /*
 365        * When GACT_LONGINT is set we notify
 366        * STRINGA_LongVal when it changed. Otherwise
 367        * we notify STRINGA_TextVal.
 368        */
 369       if (gv)
 370       {
 371          if (GADGET(sd->sd_StrGad)->Activation & GACT_LONGINT)
 372             DoNotifyMethod(obj, gi, opu->opu_Flags, GA_ID, GADGET(obj)->GadgetID, STRINGA_LongVal, sd->sd_IntegerContents, TAG_END);
 373          else
 374             DoNotifyMethod(obj, gi, opu->opu_Flags, GA_ID, GADGET(obj)->GadgetID, STRINGA_TextVal, sd->sd_TextContents, TAG_END);
 375       }
 376
 377       /*
 378        * Free the clones.
 379        */
 380       FreeTagItems(clones);
 381    } else
 382       rc = 0;
 383
 384    return rc;
 385 }
 386 METHOD_END
 387
 388 /// OM_GET
 389 /*
 390  * Get an attribute.
 391  */
 392 METHOD(StringClassGet, struct opGet *, opg)
 393 {
 394    SD          *sd = INST_DATA(cl, obj);
 395    ULONG        rc = 1;
 396    IPTR        *store = opg->opg_Storage;
 397
 398    switch (opg->opg_AttrID)
 399    {
 400    case STRINGA_StringInfo:
 401       /*
 402        * Give 'm the pointer to the
 403        * StringInfo structure.
 404        */
 405       STORE GADGET( sd->sd_StrGad )->SpecialInfo;
 406       break;
 407
 408    default:
 409       /*
 410        * First we try the strgclass object.
 411        */
 412       rc = AsmDoMethodA(sd->sd_StrGad, (Msg)opg);
 413
 414       /*
 415        * Then the superclass.
 416        */
 417       if (!rc) rc = AsmDoSuperMethodA(cl, obj, (Msg)opg);
 418
 419       /*
 420        * Clamp the integer value between min and max
 421        * Use: if the program does GetAttr() when the user has typed a
 422        * value but did not press return, or if the strgclass OM_GET failed
 423        * for some reason.
 424        */
 425       if (opg->opg_AttrID == STRINGA_LongVal) {
 426          *(opg->opg_Storage) = range(*(opg->opg_Storage), sd->sd_IntegerMin, sd->sd_IntegerMax);
 427       }
 428       break;
 429    };
 430    return rc;
 431 }
 432 METHOD_END
 433 ///
 434 /// BASE_RENDER
 435 /*
 436  * Render the gadget.
 437  */
 438 METHOD(StringClassRender, struct bmRender *, bmr)
 439 {
 440    SD              *sd = INST_DATA(cl, obj);
 441    BC              *bc = BASE_DATA(obj);
 442    struct BaseInfo *bi = bmr->bmr_BInfo;
 443    ULONG            rc, mypens;
 444
 445    /*
 446     * First the superclass.
 447     */
 448    AsmDoSuperMethodA(cl, obj, (Msg)bmr);
 449
 450    /*
 451     * Setup default pens.
 452     */
 453    mypens = PACKPENS(bi->bi_Pens[TEXTPEN], bi->bi_Pens[BACKGROUNDPEN]);
 454
 455    /*
 456     * Setup string object size and pens.
 457     */
 458    *GADGETBOX(sd->sd_StrGad) = bc->bc_InnerBox;
 459
 460    DoSetMethodNG(sd->sd_StrGad, STRINGA_Pens,       sd->sd_Pens   ? sd->sd_Pens   : mypens,
 461                                 STRINGA_ActivePens, sd->sd_Active ? sd->sd_Active : mypens,
 462                                 TAG_DONE);
 463
 464    /*
 465     * Let the strgclass render itself.
 466     */
 467    BClearAfPt(bi);
 468    rc = AsmDoMethod(sd->sd_StrGad, GM_RENDER, bi, bi->bi_RPort, GREDRAW_REDRAW);
 469
 470    /*
 471     * Disable the gadget when necessary.
 472     */
 473    if (GADGET(obj)->Flags & GFLG_DISABLED) BDisableBox(bi, &bc->bc_InnerBox);
 474
 475    return rc;
 476 }
 477 METHOD_END
 478 ///
 479 /// GM_HITTEST
 480 /*
 481  * Did they click in the strgclass object?
 482  */
 483 METHOD(StringClassHitTest, struct gpHitTest *, gph)
 484 {
 485    SD          *sd = INST_DATA(cl, obj);
 486    ULONG        rc = 0;
 487
 488    /*
 489     * Only when not disabled.
 490     */
 491    if (!(GADGET(obj)->Flags & GFLG_DISABLED))
 492    {
 493       /*
 494        * Hit inside the object?
 495        */
 496       if (AsmDoSuperMethodA(cl, obj, (Msg)gph) == GMR_GADGETHIT)
 497       {
 498          /*
 499           * Pass on to the strgclass object.
 500           */
 501          rc = AsmDoMethodA(sd->sd_StrGad, (Msg)gph);
 502       };
 503    }
 504    return rc;
 505 }
 506 METHOD_END
 507 ///
 508 /// GM_GOACTIVE
 509 /*
 510  * Go to the active state and/or handle the user input.
 511  */
 512 METHOD(StringClassGoActive, struct gpInput *, gpi)
 513 {
 514    SD                *sd = INST_DATA(cl, obj);
 515    BC                *bc = BASE_DATA(obj);
 516    ULONG              rc = GMR_NOREUSE;
 517    struct GadgetInfo *gi;
 518    struct RastPort   *rp;
 519    struct Window     *win;
 520    int                x, y, w, h, wx1, wy1, wx2, wy2;
 521    IPTR               tmp;
 522
 523    /*
 524     * Only if not disabled.
 525     */
 526    if (!(GADGET(obj)->Flags & GFLG_DISABLED))
 527    {
 528       if (bc->bc_View)
 529       {
 530          /*
 531           * Get coordinates of object.
 532           */
 533          Get_Attr(bc->bc_View, VIEW_AbsoluteX, &tmp);
 534          x = (int)tmp;
 535          Get_Attr(bc->bc_View, VIEW_AbsoluteY, &tmp);
 536          y = (int)tmp;
 537
 538          gi = gpi->gpi_GInfo;
 539          win = gi->gi_Window;
 540
 541          x = bc->bc_OuterBox.Left + x - 2;
 542          y = bc->bc_OuterBox.Top  + y - 2;
 543          w = bc->bc_OuterBox.Width    + 4;
 544          h = bc->bc_OuterBox.Height   + 4;
 545
 546          /*
 547           * Get bounds of master group.
 548           */
 549          wx1 = win->BorderLeft;
 550          wy1 = win->BorderTop;
 551          wx2 = win->Width  - win->BorderRight;
 552          wy2 = win->Height - win->BorderBottom;
 553
 554          /*
 555           * Clip to fit in the master group.
 556           */
 557          if (x < wx1) x = wx1;
 558          if (y < wy1) y = wy1;
 559
 560          if ((x + w) > wx2) x -= (x + w) - wx2;
 561          if ((y + h) > wy2) y -= (y + h) - wy2;
 562
 563          if (x < wx1) { x = wx1; w = wx2 - wx1; };
 564          if (y < wy1) { y = wy1; h = wy2 - wy1; };
 565
 566          if ((rp = BGUI_ObtainGIRPort(gi)))
 567          {
 568             if (!(sd->sd_T_Buffer = BGUI_CreateRPortBitMap(rp, w, h, FGetDepth(rp))))
 569             {
 570                ReleaseGIRPort(rp);
 571                return rc;
 572             };
 573
 574             /*
 575              * Store deltas.
 576              */
 577             sd->sd_T_X = (x + 2) - bc->bc_OuterBox.Left;
 578             sd->sd_T_Y = (y + 2) - bc->bc_OuterBox.Top;
 579             sd->sd_T_W = (w - 4) - bc->bc_OuterBox.Width;
 580             sd->sd_T_H = (h - 4) - bc->bc_OuterBox.Height;
 581
 582             sd->sd_T_Window = win;
 583             sd->sd_T_View   = bc->bc_View;
 584             bc->bc_View     = NULL;
 585
 586             /*
 587              * Save area to buffer.
 588              */
 589             ClipBlit(rp, x, y, sd->sd_T_Buffer, 0, 0, w, h, 0xC0);
 590
 591             AsmDoMethod(obj, BASE_MOVEBOUNDS, sd->sd_T_X, sd->sd_T_Y, sd->sd_T_W, sd->sd_T_H, TAG_DONE);
 592
 593             /*
 594              * Clear the area and render the object.
 595              */
 596             SetAPen(rp, 0);
 597             SRectFill(rp, x, y, x + w - 1, y + h - 1);
 598             AsmDoMethod(obj, GM_RENDER, gi, rp, GREDRAW_REDRAW);
 599
 600             ReleaseGIRPort(rp);
 601          };
 602       };
 603
 604       /*
 605        * Let the superclass have a go...
 606        */
 607       AsmDoSuperMethodA(cl, obj, (Msg)gpi);
 608
 609       /*
 610        * Pass message on.
 611        */
 612       if ((rc = AsmDoMethodA(sd->sd_StrGad, (Msg)gpi)) == GMR_MEACTIVE)
 613          /*
 614           * Mark us as active.
 615           */
 616          sd->sd_Flags |= SDF_STRINGACTIVE;
 617    }
 618
 619    return rc;
 620 }
 621 METHOD_END
 622 ///
 623 /// GM_HANDLEINPUT
 624 /*
 625  * Handle the user input.
 626  */
 627 METHOD(StringClassHandleInput, struct gpInput *, gpi)
 628 {
 629    SD                *sd = INST_DATA(cl, obj);
 630    ULONG              rc;
 631    LONG               val;
 632    struct GadgetInfo *gi = gpi->gpi_GInfo;
 633    IPTR               tmp;
 634
 635    /*
 636     * Pass on the message.
 637     */
 638    rc = AsmDoMethodA(sd->sd_StrGad, (Msg)gpi);
 639
 640    /*
 641     * RETURN or TAB or SHIFT TAB?
 642     */
 643    if (rc & GMR_VERIFY)
 644    {
 645       GetValues(sd);
 646
 647       /*
 648        * Check if the entered value of an integer object is in range and,
 649        * if not, adjust it and don't go inactive.
 650        */
 651       if (GADGET(sd->sd_StrGad)->Activation & GACT_LONGINT)
 652       {
 653          /*
 654           * Get the value.
 655           */
 656          Get_Attr(sd->sd_StrGad, STRINGA_LongVal, &tmp);
 657          val = (LONG)tmp;
 658          /*
 659           * Out of range?
 660           */
 661          if (val < sd->sd_IntegerMin)
 662          {
 663             val = sd->sd_IntegerMin;
 664             rc = GMR_MEACTIVE;
 665          }
 666          else if (val > sd->sd_IntegerMax)
 667          {
 668             val = sd->sd_IntegerMax;
 669             rc = GMR_MEACTIVE;
 670          }
 671          if (rc == GMR_MEACTIVE)
 672          {
 673             sd->sd_IntegerContents = val;
 674             DisplayBeep(gi->gi_Window->WScreen);
 675             DoSetMethod(sd->sd_StrGad, gi, STRINGA_LongVal, val, TAG_END);
 676          };
 677
 678          DoNotifyMethod(obj, gi, 0, GA_ID, GADGET(obj)->GadgetID, STRINGA_LongVal, sd->sd_IntegerContents, TAG_END);
 679       } else
 680          DoNotifyMethod(obj, gi, 0, GA_ID, GADGET(obj)->GadgetID, STRINGA_TextVal, sd->sd_TextContents, TAG_END);
 681
 682       /*
 683        * Shift-tabbed?
 684        */
 685       if (rc & GMR_NEXTACTIVE)
 686       {
 687          /*
 688           * Tell the window we're in
 689           * to activate the previous
 690           * GA_TabCycle object.
 691           */
 692          DoNotifyMethod(obj, gi, 0, GA_ID, GADGET(obj)->GadgetID, STRINGA_Tabbed, obj, TAG_END);
 693          /*
 694           * We handle this ourselves.
 695           */
 696          rc &= ~GMR_NEXTACTIVE;
 697       }
 698       else if (rc & GMR_PREVACTIVE)
 699       {
 700          /*
 701           * Tell the window we're in
 702           * to activate the next
 703           * GA_TabCycle object.
 704           */
 705          DoNotifyMethod(obj, gi, 0, GA_ID, GADGET(obj)->GadgetID, STRINGA_ShiftTabbed, obj, TAG_END);
 706          /*
 707           * We handle this ourselves.
 708           */
 709          rc &= ~GMR_PREVACTIVE;
 710       };
 711    };
 712    return rc;
 713 }
 714 METHOD_END
 715 ///
 716 /// GM_GOINACTIVE
 717 /*
 718  * Go inactive.
 719  */
 720 METHOD(StringClassGoInActive, struct gpGoInactive *, gpi)
 721 {
 722    SD       *sd = INST_DATA(cl, obj);
 723    BC       *bc = BASE_DATA(obj);
 724
 725    int       x, y, w, h;
 726
 727    /*
 728     * Pass on to the string object
 729     * if it was active.
 730     */
 731    if (sd->sd_Flags & SDF_STRINGACTIVE)
 732    {
 733       AsmDoMethodA(sd->sd_StrGad, (Msg)gpi);
 734       /*
 735        * Were not active nomore.
 736        */
 737       sd->sd_Flags &= ~SDF_STRINGACTIVE;
 738    };
 739
 740    if (sd->sd_T_View)
 741    {
 742       bc->bc_View = sd->sd_T_View;
 743       sd->sd_T_View = NULL;
 744
 745       x = bc->bc_OuterBox.Left   - 2;
 746       y = bc->bc_OuterBox.Top    - 2;
 747       w = bc->bc_OuterBox.Width  + 4;
 748       h = bc->bc_OuterBox.Height + 4;
 749
 750       AsmDoMethod(obj, BASE_MOVEBOUNDS, -sd->sd_T_X, -sd->sd_T_Y, -sd->sd_T_W, -sd->sd_T_H, TAG_DONE);
 751
 752       ClipBlit(sd->sd_T_Buffer, 0, 0, sd->sd_T_Window->RPort, x, y, w, h, 0xC0);
 753       BGUI_DoGadgetMethod(obj, sd->sd_T_Window, NULL, GM_RENDER, NULL, sd->sd_T_Window->RPort, GREDRAW_REDRAW);
 754       BGUI_FreeRPortBitMap(sd->sd_T_Buffer);
 755    };
 756
 757    return AsmDoSuperMethodA(cl, obj, (Msg)gpi);
 758 }
 759 METHOD_END
 760 ///
 761 /// BASE_DIMENSIONS
 762 /*
 763  * The object size is requested.
 764  */
 765 METHOD(StringClassDimensions, struct bmDimensions *, bmd)
 766 {
 767    SD              *sd = INST_DATA(cl, obj);
 768    struct BaseInfo *bi = bmd->bmd_BInfo;
 769    int              tlen;
 770
 771    if (sd->sd_Font) BSetFont(bi, sd->sd_Font);
 772
 773    /*
 774     * We must make sure that at least sd_MinChars
 775     * characters will fit.
 776     */
 777    tlen = TextWidth(bi->bi_RPort, "M");
 778
 779    /*
 780     * Set it up.
 781     */
 782    return CalcDimensions(cl, obj, bmd, tlen * sd->sd_MinChars + (tlen >> 1), bi->bi_RPort->TxHeight);
 783 }
 784 METHOD_END
 785 ///
 786 /// WM_KEYACTIVE
 787 /*
 788  * Keyboard activation.
 789  */
 790 METHOD(StringClassKeyActive, struct wmKeyInput *, wmki)
 791 {
 792    /*
 793     * Let intuition do it.
 794     */
 795    return WMKF_ACTIVATE;
 796 }
 797 METHOD_END
 798 ///
 799 /// SM_FORMAT_STRING
 800 /*
 801  * Format string to the string object.
 802  */
 803 METHOD(StringClassFString, struct smFormatString *, smfs)
 804 {
 805    SD       *sd = INST_DATA(cl, obj);
 806    UBYTE    *sb;
 807    ULONG     rc = 0;
 808
 809    /*
 810     * Only on string objects.
 811     */
 812    if (!(GADGET(obj)->Activation & GACT_LONGINT))
 813    {
 814       /*
 815        * Allocate string buffer.
 816        */
 817       if ((sb = (UBYTE *)BGUI_AllocPoolMem(CompStrlenF(smfs->smfs_FStr, (RAWARG)&smfs->smfs_Arg1))))
 818       {
 819          /*
 820           * Format and set it.
 821           */
 822          DoSPrintF(sb, smfs->smfs_FStr, (RAWARG)&smfs->smfs_Arg1);
 823          DoSetMethod(sd->sd_StrGad, smfs->smfs_GInfo, STRINGA_TextVal, sb, TAG_END);
 824          /*
 825           * Free the string.
 826           */
 827          BGUI_FreePoolMem(sb);
 828          rc = 1;
 829       }
 830    }
 831    return rc;
 832 }
 833 METHOD_END
 834 ///
 835
 836 /// Class initialization.
 837 /*
 838  * Class function table.
 839  */
 840 STATIC DPFUNC ClassFunc[] = {
 841    { BASE_RENDER,         StringClassRender, },
 842    { BASE_DIMENSIONS,     StringClassDimensions, },
 843
 844    { OM_NEW,              StringClassNew, },
 845    { OM_SET,              StringClassSetUpdate, },
 846    { OM_UPDATE,           StringClassSetUpdate, },
 847    { OM_GET,              StringClassGet, },
 848    { OM_DISPOSE,          StringClassDispose, },
 849    { GM_HITTEST,          StringClassHitTest, },
 850    { GM_GOACTIVE,         StringClassGoActive, },
 851    { GM_HANDLEINPUT,      StringClassHandleInput, },
 852    { GM_GOINACTIVE,       StringClassGoInActive, },
 853    { WM_KEYACTIVE,        StringClassKeyActive, },
 854    { SM_FORMAT_STRING,    StringClassFString, },
 855    { DF_END,              NULL },
 856 };
 857
 858 /*
 859  * Simple class initialization.
 860  */
 861 makeproto Class *InitStringClass(void)
 862 {
 863    return BGUI_MakeClass(CLASS_SuperClassBGUI, BGUI_BASE_GADGET,
 864                          CLASS_ObjectSize,     sizeof(SD),
 865                          CLASS_DFTable,        ClassFunc,
 866                          TAG_DONE);
 867 }
 868 ///