bgui/separatorclass.c

   1 /*
   2  * @(#) $Header$
   3  *
   4  * BGUI library
   5  * separatorclass.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/08/17 15:09:18  chodorowski
  18  * Fixed compiler warnings.
  19  *
  20  * Revision 42.1  2000/05/15 19:27:02  stegerg
  21  * another hundreds of REG() macro replacements in func headers/protos.
  22  *
  23  * Revision 42.0  2000/05/09 22:10:11  mlemos
  24  * Bumped to revision 42.0 before handing BGUI to AROS team
  25  *
  26  * Revision 41.11  2000/05/09 19:55:05  mlemos
  27  * Merged with the branch Manuel_Lemos_fixes.
  28  *
  29  * Revision 41.10.2.2  1999/07/28 23:18:15  mlemos
  30  * Fixed superclass call to dispose the objects.
  31  *
  32  * Revision 41.10.2.1  1998/11/23 14:59:51  mlemos
  33  * Removed needless OM_GET method code.
  34  *
  35  * Revision 41.10  1998/02/25 21:13:06  mlemos
  36  * Bumping to 41.10
  37  *
  38  * Revision 1.1  1998/02/25 17:09:44  mlemos
  39  * Ian sources
  40  *
  41  *
  42  */
  43
  44 /// Class definitions.
  45
  46 #include "include/classdefs.h"
  47
  48 /*
  49  * Object Instance data.
  50  */
  51 typedef struct {
  52    ULONG            sd_Flags;     /* See below.          */
  53    Object          *sd_Title;     /* Separator title.    */
  54    UWORD            sd_Place;     /* Position.           */
  55 }  SD;
  56
  57 #define SDF_THIN        (1<<0)         /* Thin lines.          */
  58 #define SDF_HIGHLIGHT   (1<<1)         /* Highlight title.     */
  59 #define SDF_HORIZONTAL  (1<<2)         /* Horizontal separator.*/
  60 #define SDF_CENTER      (1<<3)         /* Center title.        */
  61 #define SDF_RECESSED    (1<<4)         /* Recess lines.        */
  62
  63 ///
  64 /// OM_NEW
  65 /*
  66  * Create a shiny new object.
  67  */
  68 METHOD(SepClassNew, struct opSet *, ops)
  69 {
  70    IPTR            rc;
  71
  72    /*
  73     * Let the superclass create an object.
  74     */
  75    if ((rc = AsmDoSuperMethodA(cl, obj, (Msg)ops)))
  76    {
  77       AsmCoerceMethod(cl, (Object *)rc, OM_SET, ops->ops_AttrList, NULL);
  78    }
  79    return rc;
  80 }
  81 METHOD_END
  82 ///
  83 /// OM_DISPOSE
  84 /*
  85  * Dispose of this.
  86  */
  87 METHOD(SepClassDispose, Msg, msg)
  88 {
  89    SD               *sd = INST_DATA(cl, obj);
  90
  91    if (sd->sd_Title) DisposeObject(sd->sd_Title);
  92
  93    return AsmDoSuperMethodA(cl, obj, msg);
  94 }
  95 METHOD_END
  96 ///
  97 /// OM_SET
  98 /*
  99  * Set.
 100  */
 101 METHOD(SepClassSet, struct opSet *, ops)
 102 {
 103    SD              *sd = INST_DATA(cl, obj);
 104    ULONG            rc, data;
 105    struct TagItem  *tag;
 106    struct TagItem *tstate = ops->ops_AttrList;
 107
 108    rc = AsmDoSuperMethodA(cl, obj, (Msg)ops);
 109
 110    while ((tag = NextTagItem(&tstate)))
 111    {
 112       data = tag->ti_Data;
 113       switch (tag->ti_Tag)
 114       {
 115       case FRM_ThinFrame:
 116       case SEP_Thin:
 117          /*
 118           * Pickup thin lines.
 119           */
 120          if (data) sd->sd_Flags |= SDF_THIN;
 121          else      sd->sd_Flags &= ~SDF_THIN;
 122          break;
 123
 124       case SEP_CenterTitle:
 125          if (data) sd->sd_Flags |= SDF_CENTER;
 126          else      sd->sd_Flags &= ~SDF_CENTER;
 127          break;
 128
 129       case SEP_Horiz:
 130          if (data) sd->sd_Flags |= SDF_HORIZONTAL;
 131          else      sd->sd_Flags &= ~SDF_HORIZONTAL;
 132          break;
 133
 134       case SEP_Highlight:
 135          if (data) sd->sd_Flags |= SDF_HIGHLIGHT;
 136          else      sd->sd_Flags &= ~SDF_HIGHLIGHT;
 137          break;
 138
 139       case SEP_Recessed:
 140          if (data) sd->sd_Flags |= SDF_RECESSED;
 141          else      sd->sd_Flags &= ~SDF_RECESSED;
 142          break;
 143
 144       case SEP_TitleLeft:
 145          if (data) sd->sd_Place = 1;
 146          else      sd->sd_Place = 0;
 147          break;
 148
 149       case SEP_TitleRight:
 150          if (data) sd->sd_Place = 2;
 151          else      sd->sd_Place = 0;
 152          break;
 153
 154       case SEP_Title:
 155          if (!sd->sd_Title) sd->sd_Title = BGUI_NewObject(BGUI_TEXT_GRAPHIC, TEXTA_CopyText, TRUE, TAG_DONE);
 156          if (sd->sd_Title) DoSetMethodNG(sd->sd_Title, TEXTA_Text, data, TAG_DONE);
 157          break;
 158
 159       case SEP_TitleID:
 160          if (!sd->sd_Title) sd->sd_Title = BGUI_NewObject(BGUI_TEXT_GRAPHIC, TEXTA_CopyText, TRUE, TAG_DONE);
 161          if (sd->sd_Title) DoSetMethodNG(sd->sd_Title, TEXTA_TextID, data, TAG_DONE);
 162          break;
 163       };
 164    };
 165    return rc;
 166 }
 167 METHOD_END
 168 ///
 169 /// BASE_RENDER
 170 /*
 171  * Render.
 172  */
 173 METHOD(SepClassRender, struct bmRender *, bmr)
 174 {
 175    SD               *sd = INST_DATA(cl, obj);
 176    BC               *bc = BASE_DATA(obj);
 177    struct BaseInfo  *bi = bmr->bmr_BInfo;
 178    struct RastPort  *rp = bi->bi_RPort;
 179    int               l, t, w, h, s;
 180    BOOL              recessed;
 181
 182    /*
 183     * Render the baseclass.
 184     */
 185    AsmDoSuperMethodA(cl, obj, (Msg)bmr);
 186
 187    /*
 188     * Get left and top.
 189     */
 190    l = bc->bc_OuterBox.Left;
 191    t = bc->bc_OuterBox.Top;
 192    w = bc->bc_OuterBox.Width;
 193    h = bc->bc_OuterBox.Height;
 194
 195    recessed = sd->sd_Flags & SDF_RECESSED;
 196
 197    /*
 198     * Only a single pen.
 199     */
 200    BSetDrMd(bi, JAM1);
 201
 202    /*
 203     * Horizontal?
 204     */
 205    if (sd->sd_Flags & SDF_HORIZONTAL)
 206    {
 207       /*
 208        * Shiny side.
 209        */
 210       BSetDPenA(bi, recessed ? SHADOWPEN : SHINEPEN);
 211
 212       /*
 213        * Center it in the given space?
 214        */
 215       if (sd->sd_Title)
 216       {
 217          if (sd->sd_Flags & SDF_CENTER) t += h >> 1;
 218          else                           t += h - (rp->TxHeight - rp->TxBaseline);
 219       };
 220
 221       /*
 222        * Move to the correct location.
 223        */
 224       Move(rp, l, t);
 225       Draw(rp, l + w - 2, t);
 226       WritePixel(rp, l, t + 1);
 227
 228       /*
 229        * Shadow side.
 230        */
 231       BSetDPenA(bi, recessed ? SHINEPEN : SHADOWPEN);
 232
 233       /*
 234        * Move to the correct location.
 235        */
 236       Move(rp, l + 1, t + 1);
 237       Draw(rp, l + w - 1, t + 1);
 238       WritePixel(rp, l + w - 1, t);
 239
 240       /*
 241        * Title?
 242        */
 243       if (sd->sd_Title)
 244       {
 245          /*
 246           * Set font if necessary.
 247           */
 248          if (bc->bc_TextFont) BSetFont(bi, bc->bc_TextFont);
 249
 250          /*
 251           * Render the title.
 252           */
 253          RenderTitle(sd->sd_Title, bi, l, t, w,
 254                      sd->sd_Flags & SDF_HIGHLIGHT, sd->sd_Flags & SDF_CENTER, sd->sd_Place);
 255       }
 256    }
 257    else
 258    {
 259       /*
 260        * Shiny side.
 261        */
 262       BSetDPenA(bi, recessed ? SHADOWPEN : SHINEPEN);
 263
 264       /*
 265        * Thin or thick.
 266        */
 267       s = sd->sd_Flags & SDF_THIN ? 1 : 2;
 268
 269       /*
 270        * Pick position.
 271        */
 272       l += (w >> 1) - s;
 273
 274       /*
 275        * Render shiny side.
 276        */
 277       Move(rp, l, t);
 278       Draw(rp, l, t + h - 1);
 279
 280       /*
 281        * Thick?
 282        */
 283       if (!(sd->sd_Flags & SDF_THIN))
 284       {
 285          Draw(rp, l + 1, t + h - 1);
 286          Draw(rp, l + 1, t);
 287          Draw(rp, l + 3, t);
 288       }
 289       else
 290       {
 291          Move(rp, l, t);
 292          Draw(rp, l + 1, t);
 293       }
 294
 295       /*
 296        * Shadow side.
 297        */
 298       BSetDPenA(bi, recessed ? SHINEPEN : SHADOWPEN);
 299
 300       /*
 301        * Render.
 302        */
 303       Move(rp, l + s, t + 1);
 304       Draw(rp, l + s, t + h - 1);
 305
 306       /*
 307        * Thick?
 308        */
 309       if (!(sd->sd_Flags & SDF_THIN))
 310       {
 311          s++;
 312          Draw(rp, l + s, t + h - 1);
 313          Draw(rp, l + s, t + 1);
 314          Move(rp, l, t + h - 1);
 315          Draw(rp, l + s, t + h - 1);
 316       }
 317       else
 318          Draw(rp, l, t + h - 1);
 319    };
 320    return 1;
 321 }
 322 METHOD_END
 323 ///
 324 /// GM_HITTEST
 325 /*
 326  * Hit test.
 327  */
 328 METHOD(SepClassHitTest, Msg, msg)
 329 {
 330    return 0;
 331 }
 332 METHOD_END
 333 ///
 334 /// BASE_DIMENSIONS
 335 /*
 336  * Dimensions.
 337  */
 338 METHOD(SepClassDimensions, struct bmDimensions *, bmd)
 339 {
 340    SD               *sd = INST_DATA(cl, obj);
 341    struct BaseInfo  *bi = bmd->bmd_BInfo;
 342    BC               *bc = BASE_DATA(obj);
 343    int               mx, my;
 344
 345    /*
 346     * Minimum width.
 347     */
 348    if (sd->sd_Flags & SDF_HORIZONTAL)
 349    {
 350       /*
 351        * Do we have a font?
 352        */
 353       if (bc->bc_TextFont && sd->sd_Title)
 354          BSetFont(bi, bc->bc_TextFont);
 355
 356       mx = 2;
 357
 358       if (sd->sd_Title) my = bi->bi_RPort->TxHeight;
 359       else              my = 2;
 360    }
 361    else
 362    {
 363       mx = sd->sd_Flags & SDF_THIN ? 2 : 4;
 364       my = 2;
 365    };
 366    return CalcDimensions(cl, obj, bmd, mx, my);
 367 }
 368 METHOD_END
 369 ///
 370 /// BASE_LOCALIZE
 371
 372 METHOD(SepClassLocalize, struct bmLocalize *, bml)
 373 {
 374    SD       *sd = INST_DATA(cl, obj);
 375    ULONG     rc = 0;
 376
 377    if (sd->sd_Title) rc = AsmDoMethodA(sd->sd_Title, (Msg)bml);
 378
 379    return rc;
 380 }
 381 METHOD_END
 382 ///
 383 /// Class initialization.
 384 /*
 385  * Class function table.
 386  */
 387 STATIC DPFUNC ClassFunc[] = {
 388    { BASE_RENDER,          SepClassRender, },
 389    { GM_HITTEST,           SepClassHitTest, },
 390    { BASE_DIMENSIONS,      SepClassDimensions, },
 391    { OM_NEW,               SepClassNew, },
 392    { OM_DISPOSE,           SepClassDispose, },
 393    { OM_SET,               SepClassSet, },
 394    { BASE_LOCALIZE,        SepClassLocalize, },
 395    { DF_END,               NULL },
 396 };
 397
 398 /*
 399  * Initialize the separator class.
 400  */
 401 makeproto Class *InitSepClass(void)
 402 {
 403    return BGUI_MakeClass(CLASS_SuperClassBGUI, BGUI_BASE_GADGET,
 404                          CLASS_ObjectSize,     sizeof(SD),
 405                          CLASS_DFTable,        ClassFunc,
 406                          TAG_DONE);
 407 }
 408 ///