bgui/viewclass.c

   1 /*
   2  * @(#) $Header$
   3  *
   4  * BGUI library
   5  * viewclass.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:03  stegerg
  18  * another hundreds of REG() macro replacements in func headers/protos.
  19  *
  20  * Revision 42.0  2000/05/09 22:10:39  mlemos
  21  * Bumped to revision 42.0 before handing BGUI to AROS team
  22  *
  23  * Revision 41.11  2000/05/09 19:55:27  mlemos
  24  * Merged with the branch Manuel_Lemos_fixes.
  25  *
  26  * Revision 41.10.2.4  1999/08/01 22:49:31  mlemos
  27  * Assured proper replacement of scroller bars after the object is created.
  28  *
  29  * Revision 41.10.2.3  1999/08/01 19:23:33  mlemos
  30  * Assured that external scroller gadgets are redrawn when the view position
  31  * is updated.
  32  *
  33  * Revision 41.10.2.2  1999/08/01 04:13:48  mlemos
  34  * Assured that the rendering of a view within a view is not clipped against
  35  * the window boundaries.
  36  * Assured that the view of the self created scroll bars is the same as of the
  37  * view object.
  38  * Made the scroll bars be rendered or updated in the GM_RENDER method.
  39  * Added support for the VIEW_CLIP method to not clip against the parent view
  40  * if requested.
  41  *
  42  * Revision 41.10.2.1  1998/12/06 22:36:10  mlemos
  43  * Set parent window of contained object on the view object creation.
  44  * Set parent window and parent view of of the scroller gadgets on the view
  45  * object creation.
  46  *
  47  * Revision 41.10  1998/02/25 21:13:31  mlemos
  48  * Bumping to 41.10
  49  *
  50  * Revision 1.1  1998/02/25 17:10:04  mlemos
  51  * Ian sources
  52  *
  53  *
  54  */
  55
  56 /// Class definitiions.
  57 #include "include/classdefs.h"
  58
  59 /*
  60  * Instance data.
  61  */
  62 typedef struct {
  63    ULONG              vd_Flags;           /* View flags.               */
  64    struct IBox        vd_AreaBox;         /* Current area bounds.      */
  65    UWORD              vd_MinWidth;        /* Minimum width of area.    */
  66    UWORD              vd_MinHeight;       /* Minimum height of area.   */
  67    Object            *vd_Object;          /* Object to view.           */
  68    UWORD              vd_ObjectWidth;     /* Width of object.          */
  69    UWORD              vd_ObjectHeight;    /* Height of object.         */
  70    struct RastPort   *vd_ObjectBuffer;    /* RastPort buffer.          */
  71    UWORD              vd_ScaleWidth;      /* Extra width.              */
  72    UWORD              vd_ScaleHeight;     /* Extra height.             */
  73    UWORD              vd_ScaleMinWidth;   /* Scaled minimum width.     */
  74    UWORD              vd_ScaleMinHeight;  /* Scaled minimum height.    */
  75    Object            *vd_VScroller;       /* Vertical scroller.        */
  76    Object            *vd_HScroller;       /* Horizontal scroller.      */
  77    UWORD              vd_ScrollerW;       /* Width of v-scroller.      */
  78    UWORD              vd_ScrollerH;       /* Height of h-scroller.     */
  79    WORD               vd_X, vd_Y;         /* Current position.         */
  80    WORD               vd_BX, vd_BY;       /* Base position.            */
  81    WORD               vd_LX, vd_LY;       /* Last position.            */
  82    UWORD              vd_Qualifier;       /* Qualifier for drag move.  */
  83    Object            *vd_Parent;          /* Parent window.            */
  84    Object            *vd_ParentView;      /* Parent view.              */
  85    struct Rectangle   vd_ClipRect;        /* Clipping rectangle.       */
  86    UWORD              vd_CachedWidth;     /* Cached width of object.   */
  87    UWORD              vd_CachedHeight;    /* Cached height of object.  */
  88    BOOL               vd_OwnVScroller;    /* Own Vertical scroller.    */
  89    BOOL               vd_OwnHScroller;    /* Own Horizontal scroller.  */
  90 }  VD;
  91
  92 #define VDF_NODISPOSEOBJECT   (1<<0)      /* Don't dispose object.     */
  93 #define VDF_VPROPACTIVE       (1<<1)      /* VScroller active.         */
  94 #define VDF_HPROPACTIVE       (1<<2)      /* HScroller active.         */
  95 #define VDF_DIRECT            (1<<3)      /* Directly access object.   */
  96 #define VDF_DRAGMOVE          (1<<4)      /* Move while dragging.      */
  97 #define VDF_NO_DRAGMOVE       (1<<5)      /* Allow this feature.       */
  98
  99 /*
 100  * Prop map-lists.
 101  */
 102 static struct TagItem VProp2View[] = {
 103    PGA_Top,       VIEW_Y,
 104    TAG_DONE
 105 };
 106
 107 static struct TagItem HProp2View[] = {
 108    PGA_Top,       VIEW_X,
 109    TAG_DONE
 110 };
 111
 112 ///
 113 /// OM_NEW
 114
 115 METHOD(ViewClassNew, struct opSet *, ops)
 116 {
 117    VD             *vd;
 118    ULONG           rc;
 119    struct TagItem *tstate, *tag, *tags;
 120
 121    tags = DefTagList(BGUI_VIEW_GADGET, ops->ops_AttrList);
 122
 123    /*
 124     * Let the superclass create an object.
 125     */
 126    if (rc = NewSuperObject(cl, obj, tags))
 127    {
 128       vd = INST_DATA(cl, rc);
 129
 130       AsmCoerceMethod(cl, (Object *)rc, OM_SET, tags, NULL);
 131
 132       /*
 133        * Object required!
 134        */
 135       if (vd->vd_Object)
 136       {
 137          BC *bc = BASE_DATA(rc);
 138
 139          DoSetMethodNG(vd->vd_Object, BT_ParentView, rc, BT_ParentGroup, rc, BT_ParentWindow, vd->vd_Parent, TAG_DONE);
 140
 141          vd->vd_OwnHScroller=vd->vd_OwnVScroller=TRUE;
 142
 143          /*
 144           * Filter out frame and label attributes.
 145           */
 146          tstate = tags;
 147          while (tag = NextTagItem(&tstate))
 148          {
 149             switch (tag->ti_Tag)
 150             {
 151             /*
 152              * We control the horizontal, we control the vertical.
 153              */
 154             case PGA_Freedom:
 155             /*
 156              * Don't disable prop!
 157              */
 158             case GA_Disabled:
 159             /*
 160              * No drag'n'drop on the prop.
 161              */
 162             case BT_DragObject:
 163             case BT_DropObject:
 164                tag->ti_Tag = TAG_IGNORE;
 165                break;
 166
 167             case VIEW_HScroller:
 168                tag->ti_Tag = TAG_IGNORE;
 169                vd->vd_OwnHScroller=FALSE;
 170                break;
 171
 172             case VIEW_VScroller:
 173                tag->ti_Tag = TAG_IGNORE;
 174                vd->vd_OwnVScroller=FALSE;
 175                break;
 176
 177             default:
 178                if (FRM_TAG(tag->ti_Tag) || LAB_TAG(tag->ti_Tag))
 179                   tag->ti_Tag = TAG_IGNORE;
 180                break;
 181             };
 182          };
 183
 184          if(vd->vd_OwnHScroller)
 185          {
 186             Object *scroller;
 187
 188             vd->vd_OwnHScroller=FALSE;
 189             if((scroller = BGUI_NewObject(BGUI_PROP_GADGET,
 190                GA_ID, GADGET(rc)->GadgetID,
 191                PGA_DontTarget, TRUE,
 192                PGA_Freedom, FREEHORIZ,
 193                PGA_Arrows, FALSE,
 194                BT_ParentView, bc->bc_View,
 195                BT_ParentWindow, vd->vd_Parent,
 196                TAG_MORE, tags)))
 197             {
 198                DoSetMethodNG((Object *)rc, VIEW_HScroller, scroller, TAG_DONE);
 199                vd->vd_OwnHScroller=TRUE;
 200                vd->vd_ScrollerH = 14;
 201             }
 202          }
 203
 204          if(vd->vd_OwnVScroller)
 205          {
 206             Object *scroller;
 207
 208             vd->vd_OwnVScroller=FALSE;
 209             if((scroller = BGUI_NewObject(BGUI_PROP_GADGET,
 210                GA_ID, GADGET(rc)->GadgetID,
 211                PGA_DontTarget, TRUE,
 212                PGA_Freedom, FREEVERT,
 213                PGA_Arrows, FALSE,
 214                BT_ParentView, bc->bc_View,
 215                BT_ParentWindow, vd->vd_Parent,
 216                TAG_MORE, tags)))
 217             {
 218                DoSetMethodNG((Object *)rc, VIEW_VScroller, scroller, TAG_DONE);
 219                vd->vd_OwnVScroller=TRUE;
 220                vd->vd_ScrollerW = 14;
 221             }
 222          }
 223
 224          return rc;
 225       }
 226       else
 227       {
 228          /*
 229           * Fail :(
 230           */
 231          AsmCoerceMethod(cl, (Object *)rc, OM_DISPOSE);
 232          rc = 0;
 233       };
 234    };
 235    FreeTagItems(tags);
 236
 237    return rc;
 238 }
 239 METHOD_END
 240 ///
 241 /// OM_DISPOSE
 242
 243 METHOD(ViewClassDispose, Msg, msg)
 244 {
 245    VD             *vd = INST_DATA(cl, obj);
 246
 247    if (vd->vd_OwnVScroller) DisposeObject(vd->vd_VScroller);
 248    if (vd->vd_OwnHScroller) DisposeObject(vd->vd_HScroller);
 249
 250    if (vd->vd_ObjectBuffer) BGUI_FreeRPortBitMap(vd->vd_ObjectBuffer);
 251
 252    if (!(vd->vd_Flags & VDF_NODISPOSEOBJECT))
 253       if (vd->vd_Object) DisposeObject(vd->vd_Object);
 254
 255    return AsmDoSuperMethodA(cl, obj, msg);
 256 }
 257 METHOD_END
 258 ///
 259 /// OM_SET
 260 METHOD(ViewClassSet, struct opSet *, ops)
 261 {
 262    VD             *vd = INST_DATA(cl, obj);
 263    struct TagItem *tstate = ops->ops_AttrList, *tag;
 264    ULONG           rc = 1, update = FALSE, data;
 265
 266    /*
 267     * First we let the superclass
 268     * do it's thing.
 269     */
 270    AsmDoSuperMethodA(cl, obj, (Msg)ops);
 271
 272    while (tag = NextTagItem(&tstate))
 273    {
 274       data = tag->ti_Data;
 275       switch (tag->ti_Tag)
 276       {
 277       case VIEW_MinWidth:
 278          vd->vd_MinWidth = data;
 279          break;
 280
 281       case VIEW_MinHeight:
 282          vd->vd_MinHeight = data;
 283          break;
 284
 285       case VIEW_ScaleMinWidth:
 286          vd->vd_ScaleMinWidth = data;
 287          break;
 288
 289       case VIEW_ScaleMinHeight:
 290          vd->vd_ScaleMinHeight = data;
 291          break;
 292
 293       case VIEW_ScaleWidth:
 294          vd->vd_ScaleWidth = data;
 295          break;
 296
 297       case VIEW_ScaleHeight:
 298          vd->vd_ScaleHeight = data;
 299          break;
 300
 301       case VIEW_Object:
 302          vd->vd_Object = (Object *)data;
 303          break;
 304
 305       case VIEW_X:
 306          if (vd->vd_X != data) update = TRUE;
 307          vd->vd_X = data;
 308          break;
 309
 310       case VIEW_Y:
 311          if (vd->vd_Y != data) update = TRUE;
 312          vd->vd_Y = data;
 313          break;
 314
 315       case VIEW_ObjectBuffer:
 316          if (vd->vd_ObjectBuffer) BGUI_FreeRPortBitMap(vd->vd_ObjectBuffer);
 317          vd->vd_ObjectBuffer = (struct RastPort *)data;
 318          break;
 319
 320       case VIEW_NoDisposeObject:
 321          if (data)
 322             vd->vd_Flags |= VDF_NODISPOSEOBJECT;
 323          else
 324             vd->vd_Flags &= ~VDF_NODISPOSEOBJECT;
 325          break;
 326
 327       case VIEW_VScroller:
 328          if (vd->vd_OwnVScroller)
 329          {
 330             DisposeObject(vd->vd_VScroller);
 331             vd->vd_OwnVScroller=FALSE;
 332          }
 333          if (vd->vd_VScroller = (Object *)data)
 334          {
 335             AsmDoMethod(vd->vd_VScroller, BASE_ADDMAP, obj, VProp2View);
 336             vd->vd_ScrollerW = 0;
 337             update=TRUE;
 338          };
 339          break;
 340
 341       case VIEW_HScroller:
 342          if (vd->vd_OwnHScroller)
 343          {
 344             DisposeObject(vd->vd_HScroller);
 345             vd->vd_OwnHScroller=FALSE;
 346          }
 347          if (vd->vd_HScroller = (Object *)data)
 348          {
 349             AsmDoMethod(vd->vd_HScroller, BASE_ADDMAP, obj, HProp2View);
 350             vd->vd_ScrollerH = 0;
 351             update=TRUE;
 352          };
 353          break;
 354
 355       case BT_ParentView:
 356          vd->vd_ParentView = (Object *)data;
 357          break;
 358
 359       case BT_ParentWindow:
 360          vd->vd_Parent = (Object *)data;
 361       case BT_TextAttr:
 362       case FRM_ThinFrame:
 363          DoMultiSet(tag->ti_Tag, data, 3, vd->vd_Object, vd->vd_HScroller, vd->vd_VScroller);
 364          break;
 365       };
 366    };
 367    if (vd->vd_ScaleWidth  < 100) vd->vd_ScaleWidth  = 100;
 368    if (vd->vd_ScaleHeight < 100) vd->vd_ScaleHeight = 100;
 369
 370    if (update
 371    &&  ops->ops_GInfo)
 372       DoRenderMethod(obj, ops->ops_GInfo, GREDRAW_UPDATE);
 373
 374    return rc;
 375 }
 376 METHOD_END
 377 ///
 378 /// OM_GET
 379 METHOD(ViewClassGet, struct opGet *, opg)
 380 {
 381    VD       *vd = INST_DATA(cl, obj);
 382    BC       *bc = BASE_DATA(obj);
 383    ULONG     rc = 1;
 384    ULONG    *store = opg->opg_Storage;
 385
 386    switch (opg->opg_AttrID)
 387    {
 388    case VIEW_MinWidth:
 389       STORE vd->vd_MinWidth;
 390       break;
 391
 392    case VIEW_MinHeight:
 393       STORE vd->vd_MinHeight;
 394       break;
 395
 396    case VIEW_ScaleMinWidth:
 397       STORE vd->vd_ScaleMinWidth;
 398       break;
 399
 400    case VIEW_ScaleMinHeight:
 401       STORE vd->vd_ScaleMinHeight;
 402       break;
 403
 404    case VIEW_ScaleWidth:
 405       STORE vd->vd_ScaleWidth;
 406       break;
 407
 408    case VIEW_ScaleHeight:
 409       STORE vd->vd_ScaleHeight;
 410       break;
 411
 412    case VIEW_X:
 413       STORE vd->vd_X;
 414       break;
 415
 416    case VIEW_Y:
 417       STORE vd->vd_Y;
 418       break;
 419
 420    case VIEW_AbsoluteX:
 421       if (vd->vd_ParentView)
 422          Get_Attr(vd->vd_ParentView, VIEW_AbsoluteX, store);
 423       else
 424          *store = 0;
 425       *store += ((vd->vd_Flags & VDF_DIRECT) ? &bc->bc_OuterBox : &bc->bc_InnerBox)->Left - vd->vd_X;
 426       break;
 427
 428    case VIEW_AbsoluteY:
 429       if (vd->vd_ParentView)
 430          Get_Attr(vd->vd_ParentView, VIEW_AbsoluteY, store);
 431       else
 432          *store = 0;
 433       *store += ((vd->vd_Flags & VDF_DIRECT) ? &bc->bc_OuterBox : &bc->bc_InnerBox)->Top - vd->vd_Y;
 434       break;
 435
 436    case VIEW_ObjectBuffer:
 437       STORE vd->vd_ObjectBuffer;
 438       break;
 439
 440    case BT_PostRenderHighestClass:
 441       STORE cl;
 442       break;
 443
 444    default:
 445       rc = AsmDoSuperMethodA(cl, obj, (Msg)opg);
 446       break;
 447    };
 448    return rc;
 449 }
 450 METHOD_END
 451 ///
 452 /// ViewClassForward
 453 /*
 454  * Forward a message to the object.
 455  */
 456 METHOD(ViewClassForward, Msg, msg)
 457 {
 458    VD              *vd = INST_DATA(cl, obj);
 459    ULONG            rc = GMR_NOREUSE;
 460
 461    /*
 462     * Do we have an active member?
 463     */
 464    if (vd->vd_Object)
 465    {
 466       /*
 467        * Forward the message to the object.
 468        */
 469       rc = AsmDoMethodA(vd->vd_Object, msg);
 470
 471       /*
 472        * Take over the object's GadgetID.
 473        */
 474       GADGET(obj)->GadgetID = GADGET(vd->vd_Object)->GadgetID;
 475    }
 476    return rc;
 477 }
 478 METHOD_END
 479 ///
 480 /// GM_RENDER
 481
 482 METHOD(ViewClassRender, struct gpRender *, gpr)
 483 {
 484    VD                *vd = INST_DATA(cl, obj);
 485    BC                *bc = BASE_DATA(obj);
 486    struct GadgetInfo *gi = gpr->gpr_GInfo;
 487    struct RastPort   *rp;
 488    Object            *o = vd->vd_Object, *vscroll, *hscroll;
 489    ULONG              rc = 0;
 490    UWORD              ow, oh, vw, vh, sw, sh;
 491    struct Rectangle   cr;
 492    struct IBox       *box;
 493
 494    DoSetMethodNG(bc->bc_Frame, FRM_OuterOffsetRight,  vd->vd_ScrollerW,
 495                                FRM_OuterOffsetBottom, vd->vd_ScrollerH,
 496                                TAG_DONE);
 497
 498    /*
 499     * See if rendering is allowed.
 500     */
 501    if (!AsmDoSuperMethodA(cl, obj, (Msg)gpr))
 502       return 0;
 503
 504    if (o && (rp = bc->bc_RPort))
 505    {
 506       if ((gpr->gpr_Redraw == GREDRAW_REDRAW) || !vd->vd_ObjectBuffer)
 507       {
 508          AsmDoMethod(o, GRM_DIMENSIONS, gi, rp, &vd->vd_CachedWidth, &vd->vd_CachedHeight, 0);
 509       }
 510
 511       ow = ScaleWeight(vd->vd_CachedWidth, 100, vd->vd_ScaleWidth);
 512       oh = ScaleWeight(vd->vd_CachedHeight, 100, vd->vd_ScaleHeight);
 513
 514       vscroll = vd->vd_VScroller;
 515       hscroll = vd->vd_HScroller;
 516
 517       sw = vd->vd_ScrollerW;
 518       sh = vd->vd_ScrollerH;
 519
 520       if ((ow < bc->bc_OuterBox.Width) && (oh < bc->bc_OuterBox.Height))
 521       {
 522          vd->vd_Flags |= VDF_DIRECT;
 523
 524          if (sw) vscroll = 0;
 525          if (sh) hscroll = 0;
 526
 527          box = &bc->bc_OuterBox;
 528       }
 529       else
 530       {
 531          vd->vd_Flags &= ~VDF_DIRECT;
 532
 533          box = &bc->bc_InnerBox;
 534       };
 535
 536       vw = box->Width;
 537       vh = box->Height;
 538
 539       if (ow < vw) ow = vw;
 540       if (oh < vh) oh = vh;
 541
 542       vd->vd_ObjectWidth  = ow;
 543       vd->vd_ObjectHeight = oh;
 544
 545       vd->vd_X = range(vd->vd_X, 0, ow - vw);
 546       vd->vd_Y = range(vd->vd_Y, 0, oh - vh);
 547
 548       if (hscroll) DoSetMethodNG(hscroll, PGA_Top, vd->vd_X, PGA_Total, ow, PGA_Visible, vw, TAG_DONE);
 549       if (vscroll) DoSetMethodNG(vscroll, PGA_Top, vd->vd_Y, PGA_Total, oh, PGA_Visible, vh, TAG_DONE);
 550
 551       DoSetMethodNG(o, GA_Left, 0, GA_Top, 0, GA_Width, ow, GA_Height, oh, TAG_DONE);
 552       if ((gpr->gpr_Redraw == GREDRAW_REDRAW) || !vd->vd_ObjectBuffer)
 553       {
 554          if (vd->vd_ObjectBuffer) BGUI_FreeRPortBitMap(vd->vd_ObjectBuffer);
 555
 556          if (!(vd->vd_ObjectBuffer = BGUI_CreateRPortBitMap(rp, ow, oh, FGetDepth(rp))))
 557             return 0;
 558
 559          AsmDoMethod(o, GM_RENDER, gi, vd->vd_ObjectBuffer, GREDRAW_REDRAW);
 560       }
 561
 562       if (hscroll
 563       &&  (!(vd->vd_Flags & VDF_DIRECT)
 564       ||   !sw))
 565       {
 566          if (sw)
 567          {
 568             DoSetMethodNG(hscroll, GA_Left,     bc->bc_OuterBox.Left,
 569                                    GA_Top,      bc->bc_OuterBox.Top + bc->bc_OuterBox.Height - sh,
 570                                    GA_Width,    bc->bc_OuterBox.Width - sw,
 571                                    GA_Height,   sh,
 572                                    TAG_DONE);
 573          }
 574          AsmDoMethod(hscroll, GM_RENDER, gi, rp, gpr->gpr_Redraw);
 575       }
 576       if (vscroll
 577       &&  (!(vd->vd_Flags & VDF_DIRECT)
 578       ||   !sh))
 579       {
 580          if (sh)
 581          {
 582             DoSetMethodNG(vscroll, GA_Left,     bc->bc_OuterBox.Left + bc->bc_OuterBox.Width - sw,
 583                                    GA_Top,      bc->bc_OuterBox.Top,
 584                                    GA_Width,    sw,
 585                                    GA_Height,   bc->bc_OuterBox.Height - sh,
 586                                    TAG_DONE);
 587          }
 588          AsmDoMethod(vscroll, GM_RENDER, gi, rp, gpr->gpr_Redraw);
 589       }
 590
 591       box = (vd->vd_Flags & VDF_DIRECT) ? &bc->bc_OuterBox : &bc->bc_InnerBox;
 592
 593       vd->vd_X = range(vd->vd_X, 0, vd->vd_ObjectWidth  - box->Width);
 594       vd->vd_Y = range(vd->vd_Y, 0, vd->vd_ObjectHeight - box->Height);
 595
 596       cr.MinX = box->Left;
 597       cr.MinY = box->Top;
 598       cr.MaxX = box->Left + box->Width  - 1;
 599       cr.MaxY = box->Top  + box->Height - 1;
 600
 601       AsmDoMethod(obj, VIEW_CLIP, &cr, FALSE);
 602       ClipBlit(vd->vd_ObjectBuffer, vd->vd_X, vd->vd_Y,
 603                rp, cr.MinX, cr.MinY, cr.MaxX - cr.MinX + 1, cr.MaxY - cr.MinY + 1, 0xC0);
 604
 605       rc = 1;
 606    };
 607    BGUI_PostRender(cl, obj, gpr);
 608
 609    return rc;
 610 }
 611 METHOD_END
 612 ///
 613
 614 /*
 615  * Forward certain types of messages with modifications.
 616  */
 617 ULONG ForwardViewMsg(Class *cl, Object *s, Object *d, Msg msg)
 618 {
 619    VD            *vd = INST_DATA(cl, s);
 620    WORD          *mouse = NULL;
 621    ULONG          rc, storage;
 622
 623    /*
 624     * Get address of mouse coordinates in message.
 625     */
 626    switch (msg->MethodID)
 627    {
 628    case GM_HITTEST:
 629    case GM_HELPTEST:
 630       mouse = (WORD *)&((struct gpHitTest *)msg)->gpht_Mouse;
 631       break;
 632    case GM_GOACTIVE:
 633    case GM_HANDLEINPUT:
 634       mouse = (WORD *)&((struct gpInput *)msg)->gpi_Mouse;
 635       break;
 636    };
 637    if (!mouse) return 0;
 638
 639    /*
 640     * Store the coordinates.
 641     */
 642    storage = *(ULONG *)mouse;
 643
 644    /*
 645     * Adjust the coordinates to be relative to the destination object.
 646     */
 647    mouse[0] += vd->vd_X;
 648    mouse[1] += vd->vd_Y;
 649
 650    /*
 651     * Send the message to the destination object.
 652     */
 653    rc = AsmDoMethodA(d, msg);
 654
 655    /*
 656     * Put the coordinates back to what they were originally.
 657     */
 658    *(ULONG *)mouse = storage;
 659
 660    return rc;
 661 }
 662
 663 /// GM_HITTEST
 664 /*
 665  * Forward a message to the object.
 666  */
 667 METHOD(ViewClassHitTest, struct gpHitTest *, gph)
 668 {
 669    VD              *vd = INST_DATA(cl, obj);
 670    BC              *bc = BASE_DATA(obj);
 671    ULONG            rc = 0;
 672
 673    /*
 674     * Get absolute click position.
 675     */
 676    WORD l = GADGET(obj)->LeftEdge + gph->gpht_Mouse.X;
 677    WORD t = GADGET(obj)->TopEdge  + gph->gpht_Mouse.Y;
 678
 679    if (PointInBox(&bc->bc_InnerBox, l, t))
 680    {
 681       /*
 682        * Hit inside the view area?
 683        */
 684       rc = ForwardViewMsg(cl, obj, vd->vd_Object, (Msg)gph);
 685       if (rc != GMR_GADGETHIT)
 686       {
 687          if (!(vd->vd_Flags & (VDF_NO_DRAGMOVE|VDF_DIRECT)))
 688          {
 689             vd->vd_Flags |= VDF_DRAGMOVE;
 690
 691             vd->vd_BX = vd->vd_X;
 692             vd->vd_BY = vd->vd_Y;
 693             vd->vd_LX = gph->gpht_Mouse.X;
 694             vd->vd_LY = gph->gpht_Mouse.Y;
 695
 696             rc = GMR_GADGETHIT;
 697          };
 698       };
 699
 700       /*
 701        * Take over the object's GadgetID.
 702        */
 703       GADGET(obj)->GadgetID = GADGET(vd->vd_Object)->GadgetID;
 704    };
 705
 706    if (!rc && vd->vd_VScroller)
 707    {
 708       /*
 709        * Route the message.
 710        */
 711       rc = ForwardMsg(obj, vd->vd_VScroller, (Msg)gph);
 712
 713       /*
 714        * Mark the scroller active.
 715        */
 716       if (rc == GMR_GADGETHIT) vd->vd_Flags |= VDF_VPROPACTIVE;
 717    };
 718
 719    if (!rc && vd->vd_HScroller)
 720    {
 721       /*
 722        * Route the message.
 723        */
 724       rc = ForwardMsg(obj, vd->vd_HScroller, (Msg)gph);
 725
 726       /*
 727        * Mark the scroller active.
 728        */
 729       if (rc == GMR_GADGETHIT) vd->vd_Flags |= VDF_HPROPACTIVE;
 730    };
 731    return rc;
 732 }
 733 METHOD_END
 734 ///
 735 /// GM_HANDLEINPUT
 736 /*
 737  * Handle input.
 738  */
 739 METHOD(ViewClassHandleInput, struct gpInput *, gpi)
 740 {
 741    VD                *vd = INST_DATA(cl, obj);
 742    struct InputEvent *ie;
 743    ULONG              rc;
 744
 745    /*
 746     * Drag-moving?
 747     */
 748    if (vd->vd_Flags & VDF_DRAGMOVE)
 749    {
 750       ie = gpi->gpi_IEvent;
 751
 752       // qualifier stuff here  return GMR_NOREUSE;
 753
 754       if (ie->ie_Class == IECLASS_RAWMOUSE)
 755       {
 756          if (ie->ie_Code == SELECTUP)
 757          {
 758             return GMR_NOREUSE;
 759          };
 760          if (ie->ie_Code == MENUDOWN)
 761          {
 762             DoSetMethod(obj, gpi->gpi_GInfo, VIEW_X, vd->vd_BX, VIEW_Y, vd->vd_BY, TAG_DONE);
 763
 764             return GMR_NOREUSE;
 765          };
 766       };
 767       //if (ie->ie_Class == IECLASS_POINTERPOS)
 768       {
 769          DoSetMethod(obj, gpi->gpi_GInfo, VIEW_X, vd->vd_BX - gpi->gpi_Mouse.X + vd->vd_LX,
 770                                           VIEW_Y, vd->vd_BY - gpi->gpi_Mouse.Y + vd->vd_LY, TAG_DONE);
 771       };
 772
 773       return GMR_MEACTIVE;
 774    };
 775
 776    /*
 777     * VScroller active?
 778     */
 779    if (vd->vd_Flags & VDF_VPROPACTIVE)
 780       return ForwardMsg(obj, vd->vd_VScroller, (Msg)gpi) & ~GMR_VERIFY;
 781
 782    /*
 783     * HScroller active?
 784     */
 785    if (vd->vd_Flags & VDF_HPROPACTIVE)
 786       return ForwardMsg(obj, vd->vd_HScroller, (Msg)gpi) & ~GMR_VERIFY;
 787
 788    if (vd->vd_Object)
 789    {
 790       /*
 791        * Route the message.
 792        */
 793       rc = ForwardViewMsg(cl, obj, vd->vd_Object, (Msg)gpi);
 794
 795       /*
 796        * Take over the object's GadgetID.
 797        */
 798       *(gpi->gpi_Termination) =
 799       GADGET(obj)->GadgetID = GADGET(vd->vd_Object)->GadgetID;
 800
 801       return rc;
 802    };
 803    return 0;
 804 }
 805 METHOD_END
 806 ///
 807 /// GM_GOINACTIVE
 808 /*
 809  * Go inactive.
 810  */
 811 METHOD(ViewClassGoInactive, struct gpGoInactive *, gpgi)
 812 {
 813    VD       *vd = INST_DATA(cl, obj);
 814    ULONG     rc = 0;
 815
 816    if (vd->vd_Flags & VDF_DRAGMOVE)
 817    {
 818       vd->vd_Flags &= ~VDF_DRAGMOVE;
 819       return AsmDoSuperMethodA(cl, obj, (Msg)gpgi);
 820    };
 821
 822    if (vd->vd_VScroller && (vd->vd_Flags & VDF_VPROPACTIVE))
 823    {
 824       /*
 825        * Mark the scroller as not active.
 826        */
 827       vd->vd_Flags &= ~VDF_VPROPACTIVE;
 828       /*
 829        * If the scroller was active pass this message on for compatibility reasons.
 830        */
 831       return AsmDoMethodA(vd->vd_VScroller, (Msg)gpgi);
 832    };
 833
 834    if (vd->vd_HScroller && (vd->vd_Flags & VDF_HPROPACTIVE))
 835    {
 836       /*
 837        * Mark the scroller as not active.
 838        */
 839       vd->vd_Flags &= ~VDF_HPROPACTIVE;
 840       /*
 841        * If the scroller was active pass this message on for compatibility reasons.
 842        */
 843       return AsmDoMethodA(vd->vd_HScroller, (Msg)gpgi);
 844    };
 845
 846    if (vd->vd_Object)
 847    {
 848       /*
 849        * Route the message.
 850        */
 851       rc = AsmDoMethodA(vd->vd_Object, (Msg)gpgi);
 852
 853       /*
 854        * Take over the object's GadgetID.
 855        */
 856       GADGET(obj)->GadgetID = GADGET(vd->vd_Object)->GadgetID;
 857    };
 858    return rc;
 859 }
 860 METHOD_END
 861 ///
 862 /// GRM_WHICHOBJECT
 863 /*
 864  * Get the object under the mouse.
 865  */
 866 METHOD(ViewClassWhichObject, struct grmWhichObject *, grwo)
 867 {
 868    VD                    *vd = INST_DATA(cl, obj);
 869    BC                    *bc = BASE_DATA(obj);
 870    Object                *ob = vd->vd_Object;
 871    struct grmWhichObject  wo = *grwo;
 872
 873    int x = grwo->grwo_Coords.X;
 874    int y = grwo->grwo_Coords.Y;
 875    int r = bc->bc_OuterBox.Left + bc->bc_OuterBox.Width  - vd->vd_ScrollerW;
 876    int b = bc->bc_OuterBox.Top  + bc->bc_OuterBox.Height - vd->vd_ScrollerH;
 877
 878    if ((x >= r) && (y >= b));
 879
 880    if (x >= r)
 881    {
 882       return (ULONG)vd->vd_VScroller;
 883    };
 884    if (y >= b)
 885    {
 886       return (ULONG)vd->vd_HScroller;
 887    };
 888
 889    wo.MethodID = GRM_WHICHOBJECT;
 890    wo.grwo_Coords.X = x + vd->vd_X;
 891    wo.grwo_Coords.Y = y + vd->vd_Y;
 892
 893    /*
 894     * Is object a group?
 895     */
 896    if (IsMulti(ob))
 897    {
 898       /*
 899        * Route message.
 900        */
 901       ob = (Object *)AsmDoMethodA(ob, (Msg)&wo);
 902    };
 903    return (ULONG)ob;
 904 }
 905 METHOD_END
 906 ///
 907 /// BASE_DIMENSIONS
 908 /*
 909  * Simple dimensions request.
 910  */
 911 METHOD(ViewClassDimensions, struct bmDimensions *, bmd)
 912 {
 913    VD              *vd = INST_DATA(cl, obj);
 914    struct BaseInfo *bi = bmd->bmd_BInfo;
 915    UWORD            ow, oh;
 916    ULONG            mw, mh;
 917
 918    if (vd->vd_ScaleMinWidth || vd->vd_ScaleMinHeight)
 919    {
 920       AsmDoMethod(vd->vd_Object, GRM_DIMENSIONS, bi, bi->bi_RPort, &ow, &oh, 0);
 921    };
 922
 923    if (vd->vd_ScaleMinWidth)
 924    {
 925       mw = ScaleWeight(ow, 100, vd->vd_ScaleMinWidth);
 926    }
 927    else
 928    {
 929       mw = vd->vd_MinWidth;
 930    };
 931
 932    if (vd->vd_ScaleMinHeight)
 933    {
 934       mh = ScaleWeight(oh, 100, vd->vd_ScaleMinHeight);
 935    }
 936    else
 937    {
 938       mh = vd->vd_MinHeight;
 939    };
 940
 941    if (mw < 8) mw = 8;
 942    if (mh < 8) mh = 8;
 943
 944    /*
 945     * We simply add the specified minimum width and height
 946     * which are passed to us at create time, plus the scrollers.
 947     */
 948    return CalcDimensions(cl, obj, bmd, mw + vd->vd_ScrollerW, mh + vd->vd_ScrollerH);
 949 }
 950 METHOD_END
 951 ///
 952 /// VIEW_CLIP
 953
 954 METHOD(ViewClassClip, struct vmClip *, vmc)
 955 {
 956    VD          *vd = INST_DATA(cl, obj);
 957    BC          *bc = BASE_DATA(obj);
 958    struct IBox *box = (vd->vd_Flags & VDF_DIRECT) ? &bc->bc_OuterBox : &bc->bc_InnerBox;
 959
 960    int     x1 = box->Left;
 961    int     y1 = box->Top;
 962    int     x2 = box->Width  + x1 - 1;
 963    int     y2 = box->Height + y1 - 1;
 964
 965    if (vmc->vmc_Rectangle->MinX < x1) vmc->vmc_Rectangle->MinX = x1;
 966    if (vmc->vmc_Rectangle->MaxX > x2) vmc->vmc_Rectangle->MaxX = x2;
 967    if (vmc->vmc_Rectangle->MinY < y1) vmc->vmc_Rectangle->MinY = y1;
 968    if (vmc->vmc_Rectangle->MaxY > y2) vmc->vmc_Rectangle->MaxY = y2;
 969
 970    if (vmc->vmc_WindowClip
 971    &&  vd->vd_ParentView)
 972       AsmDoMethodA(vd->vd_ParentView, (Msg)vmc);
 973
 974    return 1;
 975 }
 976 METHOD_END
 977 ///
 978 /// BASE_IS_MULTI
 979 METHOD(ViewClassIsMulti, Msg, msg)
 980 {
 981    return TRUE;
 982 }
 983 METHOD_END
 984 ///
 985 /// Class initialization.
 986 /*
 987  * Class function table.
 988  */
 989 STATIC DPFUNC ClassFunc[] = {
 990    VIEW_CLIP,           (FUNCPTR)ViewClassClip,
 991    OM_NEW,              (FUNCPTR)ViewClassNew,
 992    OM_GET,              (FUNCPTR)ViewClassGet,
 993    OM_SET,              (FUNCPTR)ViewClassSet,
 994    OM_UPDATE,           (FUNCPTR)ViewClassSet,
 995    OM_DISPOSE,          (FUNCPTR)ViewClassDispose,
 996    GM_RENDER,           (FUNCPTR)ViewClassRender,
 997    BASE_DIMENSIONS,     (FUNCPTR)ViewClassDimensions,
 998    GRM_WHICHOBJECT,     (FUNCPTR)ViewClassWhichObject,
 999    GM_HITTEST,          (FUNCPTR)ViewClassHitTest,
1000    GM_GOACTIVE,         (FUNCPTR)ViewClassHandleInput,
1001    GM_HANDLEINPUT,      (FUNCPTR)ViewClassHandleInput,
1002    GM_GOINACTIVE,       (FUNCPTR)ViewClassGoInactive,
1003    BASE_MOVEBOUNDS,     (FUNCPTR)ViewClassForward,
1004    BASE_LOCALIZE,       (FUNCPTR)ViewClassForward,
1005    BASE_KEYLABEL,       (FUNCPTR)ViewClassForward,
1006    BASE_FINDKEY,        (FUNCPTR)ViewClassForward,
1007    BASE_SHOWHELP,       (FUNCPTR)ViewClassForward,
1008    BASE_INHIBIT,        (FUNCPTR)ViewClassForward,
1009    BASE_IS_MULTI,       (FUNCPTR)ViewClassIsMulti,
1010    DF_END,              NULL
1011 };
1012
1013 /*
1014  * Simple class initialization.
1015  */
1016 makeproto Class *InitViewClass(void)
1017 {
1018    return BGUI_MakeClass(CLASS_SuperClassBGUI, BGUI_BASE_GADGET,
1019                          CLASS_ObjectSize,     sizeof(VD),
1020                          CLASS_DFTable,        ClassFunc,
1021                          TAG_DONE);
1022 }
1023 ///