rom/intuition/groupgclass.c

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