rom/intuition/groupgclass.c

   1 /*
   2     Copyright © 1995-2005, The AROS Development Team. All rights reserved.
   3     Copyright © 2001-2003, The MorphOS Development Team. All Rights Reserved.
   4     $Id$
   5 */
   6
   7 /****************************************************************************************/
   8
   9 #include <exec/types.h>
  10
  11 #include <dos/dos.h>
  12 #include <dos/dosextens.h>
  13
  14 #include <intuition/intuition.h>
  15 #include <intuition/intuitionbase.h>
  16 #include <intuition/classes.h>
  17 #include <intuition/classusr.h>
  18 #include <intuition/gadgetclass.h>
  19
  20 #include <utility/tagitem.h>
  21 #include <utility/hooks.h>
  22
  23 #include <clib/macros.h>
  24
  25 #include <proto/exec.h>
  26 #include <proto/intuition.h>
  27 #include <proto/utility.h>
  28
  29 #ifndef __MORPHOS__
  30 #include <aros/asmcall.h>
  31 #include <proto/alib.h>
  32 #include "intuition_intern.h"
  33 #endif /* !__MORPHOS__ */
  34
  35 #ifdef IntuitionBase
  36 #    undef IntuitionBase
  37 #endif
  38
  39 /****************************************************************************************/
  40
  41 /* On the Amiga tabcycling between member (string) gadgets of a group
  42    gadget does not work at all -> freeze */
  43
  44 #define SUPPORT_TABCYCLE    1
  45
  46 #define IntuitionBase       ((struct IntuitionBase *)(cl->cl_UserData))
  47
  48 /****************************************************************************************/
  49
  50 static void recalcgroupsize(Class *cl, struct Gadget *g)
  51 {
  52     struct GroupGData   *data = INST_DATA(cl, g);
  53     struct Gadget       *member, *memberstate;
  54     WORD                 w, h, width = 0/*g->Width*/, height = 0/*g->Height*/;
  55
  56     memberstate = (struct Gadget *)data->memberlist.mlh_Head;
  57     while((member = NextObject(&memberstate)))
  58     {
  59         /* No "width - 1" / "height - 1" here! Coords of members are absolute here! */
  60
  61         w = member->LeftEdge - g->LeftEdge + member->Width;
  62         h = member->TopEdge  - g->TopEdge  + member->Height;
  63
  64         if (w > width)  width  = w;
  65         if (h > height) height = h;
  66     }
  67
  68     g->Width  = width;
  69     g->Height = height;
  70 }
  71
  72 /****************************************************************************************/
  73
  74 #if SUPPORT_TABCYCLE
  75
  76 /****************************************************************************************/
  77
  78 struct Gadget *next_tabcycleobject(Class *cl, struct Gadget *g)
  79 {
  80     struct GroupGData   *data = INST_DATA(cl, g);
  81     struct Gadget       *member, *memberstate, *actobj;
  82     struct Gadget       *rc = NULL;
  83
  84     actobj = data->activegad;
  85
  86     memberstate = (struct Gadget *)data->memberlist.mlh_Head;
  87     while ((member = NextObject(&memberstate)))
  88     {
  89         if (member == actobj) break;
  90     }
  91
  92     if (member)
  93     {
  94         while ((member = NextObject(&memberstate)))
  95         {
  96             if ( (member->Flags & (GFLG_TABCYCLE | GFLG_DISABLED)) == GFLG_TABCYCLE )
  97             {
  98                 rc = member;
  99                 break;
 100             }
 101         }
 102
 103         if (!member)
 104         {
 105             memberstate = (struct Gadget *)data->memberlist.mlh_Head;
 106             while ((member = NextObject(&memberstate)))
 107             {
 108                 if (member == actobj) break;
 109
 110                 if (member->Flags & GFLG_TABCYCLE)
 111                 {
 112                     rc = member;
 113                     break;
 114                 }
 115             }
 116
 117         } /* if (!rc) */
 118
 119     } /* if (member) */
 120
 121     return rc;
 122 }
 123
 124 /****************************************************************************************/
 125
 126 struct Gadget *prev_tabcycleobject(Class *cl, struct Gadget *g)
 127 {
 128     struct GroupGData   *data = INST_DATA(cl, g);
 129     struct Gadget       *member, *memberstate, *actobj;
 130     struct Gadget       *prevmember = NULL, *rc = NULL;
 131
 132     actobj = data->activegad;
 133
 134     memberstate = (struct Gadget *)data->memberlist.mlh_Head;
 135     while ((member = NextObject(&memberstate)))
 136     {
 137         if (member == actobj)
 138         {
 139             if (prevmember) rc = prevmember;
 140             break;
 141         }
 142
 143         if ( (member->Flags & (GFLG_TABCYCLE | GFLG_DISABLED)) == GFLG_TABCYCLE )
 144         {
 145             prevmember = member;
 146         }
 147     }
 148
 149     if (member && !rc)
 150     {
 151         prevmember = NULL;
 152         while ((member = NextObject(&memberstate)))
 153         {
 154             if (((struct Gadget *)member)->Flags & GFLG_TABCYCLE)
 155             {
 156                 prevmember = member;
 157             }
 158         }
 159
 160         rc = prevmember;
 161
 162     } /* if (member && !rc) */
 163
 164     return rc;
 165
 166 }
 167
 168 /****************************************************************************************/
 169
 170 #endif /* SUPPORT_TABCYCLE */
 171
 172 /****************************************************************************************/
 173
 174 IPTR GroupGClass__OM_NEW(Class *cl, Object *obj, struct opSet *msg)
 175 {
 176     struct GroupGData *data;
 177
 178     struct Gadget *g = (struct Gadget *)DoSuperMethodA(cl, obj, (Msg)msg);
 179     if (g)
 180     {
 181         data = INST_DATA(cl, g);
 182
 183         NEWLIST(&data->memberlist);
 184
 185         /* Width and height of group gadget is determined by members. No members -> 0 size */
 186
 187         g->Width  = 0;
 188         g->Height = 0;
 189     }
 190
 191     return (IPTR)g;
 192 }
 193
 194 /****************************************************************************************/
 195
 196 IPTR GroupGClass__OM_SET(Class *cl, struct Gadget *g, struct opSet *msg)
 197 {
 198     struct GroupGData   *data = INST_DATA(cl, g);
 199     struct Gadget       *member, *memberstate;
 200     WORD                 dx, new_groupleft, old_groupleft = g->LeftEdge;
 201     WORD                 dy, new_grouptop , old_grouptop  = g->TopEdge;
 202     IPTR                 rc;
 203
 204     rc = DoSuperMethodA(cl, (Object *)g, (Msg)msg);
 205
 206     new_groupleft = g->LeftEdge;
 207     new_grouptop  = g->TopEdge;
 208
 209     dx = new_groupleft - old_groupleft;
 210     dy = new_grouptop  - old_grouptop;
 211
 212     if (dx || dy)
 213     {
 214         struct opSet   m;
 215         struct TagItem tags[3];
 216
 217         m.MethodID     = OM_SET;
 218         m.ops_AttrList = tags;
 219         m.ops_GInfo    = msg->ops_GInfo;
 220
 221         tags[0].ti_Tag = GA_Left;
 222         tags[1].ti_Tag = GA_Top;
 223         tags[2].ti_Tag = TAG_DONE;
 224
 225         memberstate = (struct Gadget *)data->memberlist.mlh_Head;
 226         while((member = NextObject(&memberstate)))
 227         {
 228             tags[0].ti_Data = member->LeftEdge + dx;
 229             tags[1].ti_Data = member->TopEdge  + dy;
 230             DoMethodA((Object *)member, (Msg)&m);
 231         }
 232
 233     } /* if (dx || dy) */
 234
 235     return rc;
 236
 237 }
 238
 239 /****************************************************************************************/
 240
 241 IPTR GroupGClass__OM_DISPOSE(Class *cl, struct Gadget *g, Msg msg)
 242 {
 243     struct GroupGData *data = INST_DATA(cl, g);
 244
 245     /* Free all members */
 246
 247     for(;;)
 248     {
 249         struct Gadget *member, *memberstate;
 250         ULONG method;
 251
 252         memberstate = (struct Gadget *)data->memberlist.mlh_Head;
 253         member = NextObject(&memberstate);
 254         if (!member) break;
 255
 256         method = OM_REMOVE;
 257         DoMethodA((Object *)member, (Msg)&method);
 258         DisposeObject(member);
 259     }
 260
 261     DoSuperMethodA(cl, (Object *)g, msg);
 262
 263     return 0;
 264 }
 265
 266 /****************************************************************************************/
 267
 268 IPTR GroupGClass__OM_ADDMEMBER(Class *cl, struct Gadget *g, struct opMember *msg)
 269 {
 270     struct GroupGData   *data = INST_DATA(cl, g);
 271     struct opAddTail     m;
 272     struct opSet         m2;
 273     struct TagItem       tags[3];
 274     IPTR                 rc;
 275
 276     m.MethodID  = OM_ADDTAIL;
 277     m.opat_List = (struct List *)&data->memberlist;
 278
 279     rc = DoMethodA(msg->opam_Object, (Msg)&m);
 280
 281     /* Member gadget had its coords relative to group gadget.
 282        Convert the coords to absolute coords. */
 283
 284     m2.MethodID = OM_SET;
 285     m2.ops_AttrList = tags;
 286     m2.ops_GInfo = NULL;
 287
 288     tags[0].ti_Tag  = GA_Left;
 289     tags[0].ti_Data = ((struct Gadget *)msg->opam_Object)->LeftEdge + g->LeftEdge;
 290     tags[1].ti_Tag  = GA_Top;
 291     tags[1].ti_Data = ((struct Gadget *)msg->opam_Object)->TopEdge + g->TopEdge;
 292     tags[2].ti_Tag  = TAG_DONE;
 293
 294     DoMethodA(msg->opam_Object, (Msg)&m2);
 295
 296     recalcgroupsize(cl, g);
 297
 298     return rc;
 299 }
 300
 301 /****************************************************************************************/
 302
 303 IPTR GroupGClass__OM_REMMEMBER(Class *cl, struct Gadget *g, struct opMember *msg)
 304 {
 305     struct opSet    m2;
 306     struct TagItem  tags[3];
 307     IPTR            rc;
 308     STACKULONG      method = OM_REMOVE;
 309
 310     rc = DoMethodA(msg->opam_Object, (Msg)&method);
 311
 312     /* Member gadget had its coords absolute here.
 313        Convert the coords back to relative coords. */
 314
 315     m2.MethodID     = OM_SET;
 316     m2.ops_AttrList = tags;
 317     m2.ops_GInfo    = NULL;
 318
 319     tags[0].ti_Tag  = GA_Left;
 320     tags[0].ti_Data = ((struct Gadget *)msg->opam_Object)->LeftEdge - g->LeftEdge;
 321     tags[1].ti_Tag  = GA_Top;
 322     tags[1].ti_Data = ((struct Gadget *)msg->opam_Object)->TopEdge - g->TopEdge;
 323     tags[2].ti_Tag  = TAG_DONE;
 324
 325     DoMethodA(msg->opam_Object, (Msg)&m2);
 326
 327     recalcgroupsize(cl, g);
 328
 329     return rc;
 330 }
 331
 332 /****************************************************************************************/
 333
 334 IPTR GroupGClass__GM_HITTEST(Class *cl, struct Gadget *g, struct gpHitTest *msg)
 335 {
 336     struct GroupGData   *data = INST_DATA(cl, g);
 337     struct gpHitTest     m;
 338     struct Gadget       *member, *memberstate;
 339     WORD                 x, y;
 340     IPTR                 rc = 0;
 341
 342     m = *msg;
 343
 344     /* gpht_Mouse.X/Y are relative to (group) gadget */
 345
 346     x = msg->gpht_Mouse.X + g->LeftEdge;
 347     y = msg->gpht_Mouse.Y + g->TopEdge;
 348
 349     memberstate = (struct Gadget *)data->memberlist.mlh_Head;
 350     while((member = NextObject(&memberstate)))
 351     {
 352         if (!(member->Flags & GFLG_DISABLED))
 353         {
 354             /* make mouse coords relative to member gadget */
 355
 356             m.gpht_Mouse.X = x - member->LeftEdge;
 357             m.gpht_Mouse.Y = y - member->TopEdge;
 358
 359             if ((m.gpht_Mouse.X >= 0) &&
 360                 (m.gpht_Mouse.Y >= 0) &&
 361                 (m.gpht_Mouse.X < member->Width) &&
 362                 (m.gpht_Mouse.Y < member->Height))
 363             {
 364                 rc = DoMethodA((Object *)member, (Msg)&m);
 365                 if (rc == GMR_GADGETHIT)
 366                 {
 367                     data->activegad = member;
 368                     break;
 369                 }
 370
 371             }
 372
 373         } /* if (!(member->Flags & GFLG_DISABLED)) */
 374
 375     } /* while((member = NextObject(&memberstate))) */
 376
 377     return rc;
 378 }
 379
 380 /****************************************************************************************/
 381
 382 IPTR GroupGClass__GM_HANDLEINPUT(Class *cl, struct Gadget *g, struct gpInput *msg)
 383 {
 384     struct GroupGData   *data = INST_DATA(cl, g);
 385     struct gpInput       m;
 386     IPTR                 rc;
 387
 388     /* If someone activates us with ActivateGadget(), activegad will be NULL.
 389      * In that case, activate the first object.
 390      */
 391     if (!data->activegad)
 392     {
 393         struct Gadget *memberstate = (struct Gadget *)data->memberlist.mlh_Head;
 394
 395         data->activegad = NextObject(&memberstate);
 396     }
 397
 398     m = *msg;
 399
 400     /* gpi_Mouse coords are relative to group gadget. Make them relative
 401        to activate object */
 402
 403     m.gpi_Mouse.X = g->LeftEdge + msg->gpi_Mouse.X - data->activegad->LeftEdge;
 404     m.gpi_Mouse.Y = g->TopEdge  + msg->gpi_Mouse.Y - data->activegad->TopEdge;
 405
 406     rc = DoMethodA((Object *)data->activegad, (Msg)&m);
 407
 408 #if SUPPORT_TABCYCLE
 409     {
 410         struct Gadget *newgad = NULL;
 411
 412         if (rc & GMR_NEXTACTIVE) newgad = next_tabcycleobject(cl, g);
 413         if (rc & GMR_PREVACTIVE) newgad = prev_tabcycleobject(cl, g);
 414
 415         if (newgad && (newgad != data->activegad))
 416         {
 417             struct gpGoInactive im;
 418
 419             /* Make old member gadget inactive */
 420
 421             im.MethodID   = GM_GOINACTIVE;
 422             im.gpgi_GInfo = msg->gpi_GInfo;
 423             im.gpgi_Abort = 0;          /* The gadget itself wanted to be deactivated */
 424
 425             DoMethodA((Object *)data->activegad, (Msg)&im);
 426
 427             /* Make new member gadget active */
 428
 429             data->activegad = newgad;
 430
 431             m.MethodID    = GM_GOACTIVE;
 432             m.gpi_Mouse.X = g->LeftEdge + msg->gpi_Mouse.X - newgad->LeftEdge;
 433             m.gpi_Mouse.Y = g->TopEdge  + msg->gpi_Mouse.Y - newgad->TopEdge;
 434
 435             rc = DoMethodA((Object *)newgad, (Msg)&m);
 436
 437         }
 438
 439     }
 440 #endif
 441
 442     return rc;
 443 }
 444
 445 /****************************************************************************************/
 446
 447 IPTR GroupGClass__GM_GOINACTIVE(Class *cl, struct Gadget *g, struct gpGoInactive *msg)
 448 {
 449     struct GroupGData   *data = INST_DATA(cl, g);
 450     IPTR                 rc;
 451
 452     ASSERT_VALID_PTR(data->activegad);
 453
 454     rc = DoMethodA((Object *)data->activegad, (Msg)msg);
 455     data->activegad = NULL;
 456
 457     return rc;
 458 }
 459
 460 /****************************************************************************************/
 461
 462 IPTR GroupGClass__GM_RENDER(Class *cl, struct Gadget *g, struct gpRender *msg)
 463 {
 464     struct GroupGData   *data = INST_DATA(cl, g);
 465     struct Gadget       *member, *memberstate;
 466
 467     memberstate = (struct Gadget *)data->memberlist.mlh_Head;
 468     while((member = NextObject(&memberstate)))
 469     {
 470         DoMethodA((Object *)member, (Msg)msg);
 471     }
 472
 473     return 0;
 474 }
 475
 476 /****************************************************************************************/