rom/intuition/buttongclass.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     AROS buttongclass implementation.
   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 #include <intuition/cghooks.h>
  20 #include <intuition/icclass.h>
  21 #include <intuition/imageclass.h>
  22
  23 #include <graphics/gfxbase.h>
  24 #include <graphics/gfxmacros.h>
  25
  26 #include <utility/tagitem.h>
  27 #include <utility/hooks.h>
  28
  29 #include <clib/macros.h>
  30 #include <proto/exec.h>
  31 #include <proto/intuition.h>
  32 #include <proto/graphics.h>
  33 #include <proto/utility.h>
  34
  35 #ifndef __MORPHOS__
  36 #include "intuition_intern.h"
  37 #include <aros/asmcall.h>
  38 #include <proto/alib.h>
  39 #include "gadgets.h"
  40 #endif /* !__MORPHOS__ */
  41
  42 #define DEBUG_BUTTON(x) ;
  43 /***********************************************************************************/
  44
  45 static VOID notifypressed(Class *cl, struct Gadget *g, struct GadgetInfo *ginfo, ULONG flags)
  46 {
  47     struct opUpdate method;
  48
  49     struct TagItem  ntags[] =
  50     {
  51         { GA_ID     , 0UL   },
  52         { TAG_DONE          }
  53     };
  54
  55     method.MethodID     = OM_NOTIFY;
  56     method.opu_AttrList = ntags;
  57     method.opu_GInfo    = ginfo;
  58     method.opu_Flags    = flags;
  59
  60     ntags[0].ti_Data = ((g->Flags & GFLG_SELECTED) ? g->GadgetID : - g->GadgetID);
  61
  62     DoMethodA((Object *)g, (Msg)&method);
  63 }
  64
  65 /***********************************************************************************/
  66
  67 IPTR ButtonGClass__OM_NEW(Class *cl, Object *o, struct opSet *msg)
  68 {
  69     struct IntuitionBase *IntuitionBase = (struct IntuitionBase *)cl->cl_UserData;
  70     struct Library *UtilityBase = GetPrivIBase(IntuitionBase)->UtilityBase;
  71     struct TagItem *ti;
  72     struct Gadget *g;
  73
  74     g = (struct Gadget *)DoSuperMethodA(cl, o, (Msg)msg);
  75     if (g)
  76     {
  77         ti = FindTagItem(GA_Image, msg->ops_AttrList);
  78         if (ti)
  79         {
  80             struct Image *im = (struct Image *)g->GadgetRender;
  81
  82             if (im)
  83             {
  84                 g->Width  = im->Width;
  85                 g->Height = im->Height;
  86             }
  87         };
  88     }
  89
  90     return (IPTR)g;
  91 }
  92
  93 /***********************************************************************************/
  94
  95 IPTR ButtonGClass__OM_SET(Class *cl, struct Gadget *g, struct opSet *msg)
  96 {
  97     struct IntuitionBase *IntuitionBase = (struct IntuitionBase *)cl->cl_UserData;
  98     struct Library *UtilityBase = GetPrivIBase(IntuitionBase)->UtilityBase;
  99     struct TagItem *ti;
 100     IPTR            retval;
 101
 102     retval = DoSuperMethodA(cl, (Object *)g, (Msg)msg);
 103
 104     /* If we have been subclassed, OM_UPDATE should not cause a GM_RENDER
 105         * because it would circumvent the subclass from fully overriding it.
 106         * The check of cl == OCLASS(o) should fail if we have been
 107         * subclassed, and we have gotten here via DoSuperMethodA().
 108         */
 109
 110     ti = FindTagItem(GA_Image, msg->ops_AttrList);
 111     if (ti)
 112     {
 113         struct Image *im = (struct Image *)g->GadgetRender;
 114
 115         if (im)
 116         {
 117             g->Width  = im->Width;
 118             g->Height = im->Height;
 119         }
 120     };
 121
 122     if ( retval && ( (msg->MethodID != OM_UPDATE) || (cl == OCLASS(g)) ) )
 123     {
 124         struct GadgetInfo *gi = msg->ops_GInfo;
 125
 126         if (gi)
 127         {
 128             struct RastPort *rp = ObtainGIRPort(gi);
 129
 130             if (rp)
 131             {
 132                 DoMethod((Object *)g, GM_RENDER, (IPTR) gi, (IPTR) rp, GREDRAW_REDRAW);
 133                 ReleaseGIRPort(rp);
 134             }
 135         }
 136     }
 137
 138     return retval;
 139 }
 140
 141 /***********************************************************************************/
 142
 143 IPTR ButtonGClass__GM_RENDER(Class *cl, struct Gadget *g, struct gpRender *msg)
 144 {
 145     struct IntuitionBase *IntuitionBase = (struct IntuitionBase *)cl->cl_UserData;
 146     struct GfxBase *GfxBase = GetPrivIBase(IntuitionBase)->GfxBase;
 147     /* We will let the AROS gadgetclass test if it is safe to render */
 148     if ( DoSuperMethodA(cl, (Object *)g, (Msg)msg) != 0 && msg->gpr_GInfo)
 149     {
 150         UWORD           *pens = msg->gpr_GInfo->gi_DrInfo->dri_Pens;
 151         struct RastPort *rp = msg->gpr_RPort;
 152         struct IBox      container;
 153
 154         SANITY_CHECKR(msg->gpr_RPort, 0)
 155
 156         /*dprintf("button_render: rp %p[%p] win %p[%p] req %p[%p] gi->rp %p[%p]\n",
 157                 rp, rp->Layer,
 158                 msg->gpr_GInfo->gi_Window, msg->gpr_GInfo->gi_Window->WLayer,
 159                 msg->gpr_GInfo->gi_Requester, msg->gpr_GInfo->gi_Requester->ReqLayer,
 160                 msg->gpr_GInfo->gi_RastPort, msg->gpr_GInfo->gi_RastPort->Layer);*/
 161
 162         GetGadgetIBox((struct Gadget *)g, msg->gpr_GInfo, &container);
 163
 164         if (container.Width <= 1 || container.Height <= 1)
 165             return (IPTR)0;
 166
 167         if ((g->Flags & GFLG_GADGIMAGE) == 0) /* not an image-button */
 168         {
 169             /* draw border */
 170             if ((g->SelectRender != NULL ) &&  (g->Flags & GFLG_SELECTED))
 171                 DrawBorder(rp,
 172                        ((struct Border *)g->SelectRender),
 173                        container.Left,
 174                        container.Top);
 175             else if (g->GadgetRender != NULL)
 176                 DrawBorder(rp,
 177                        ((struct Border *)g->GadgetRender),
 178                        container.Left,
 179                        container.Top);
 180
 181         }
 182         else /* GFLG_GADGIMAGE set */
 183         {
 184             ULONG state;
 185
 186             if (g->Activation & (GACT_LEFTBORDER |
 187                          GACT_TOPBORDER |
 188                          GACT_RIGHTBORDER |
 189                          GACT_BOTTOMBORDER |
 190                          GACT_BORDERSNIFF))
 191             {
 192                 if (msg->gpr_GInfo->gi_Window->Flags & (WFLG_WINDOWACTIVE | WFLG_TOOLBOX))
 193                 {
 194                     state = IDS_NORMAL;
 195                 }
 196                 else
 197                 {
 198                     state = IDS_INACTIVENORMAL;
 199                 }
 200             }
 201             else
 202             {
 203                 state = IDS_NORMAL;
 204             }
 205
 206             if ((g->SelectRender != NULL) &&
 207                 (g->Flags & GFLG_SELECTED)) /* render selected image */
 208             {
 209                 /* No centering of the image inside the gadget to be done! */
 210
 211                 DrawImageState(rp,
 212                            (struct Image *)g->SelectRender,
 213                            container.Left, container.Top,
 214                            state + IDS_SELECTED,
 215                            msg->gpr_GInfo->gi_DrInfo );
 216             }
 217             else if ( g->GadgetRender != NULL ) /* render normal image */
 218             {
 219                 /* No centering of the image inside the gadget to be done! */
 220
 221                 DrawImageState(rp,
 222                            (struct Image *)g->GadgetRender,
 223                            container.Left, container.Top,
 224                            state + ((g->Flags & GFLG_SELECTED) ? IDS_SELECTED : IDS_NORMAL ),
 225                            msg->gpr_GInfo->gi_DrInfo);
 226             }
 227         }
 228
 229 #if 0
 230         /*#warning Amiga buttongclass does not seem to render gadgetlabel at all*/
 231
 232         /* print label */
 233         printgadgetlabel(cl, (Object *)g, msg, IntuitionBase);
 234 #endif
 235
 236         if ( g->Flags & GFLG_DISABLED )
 237         {
 238             UWORD pattern[] = { 0x8888, 0x2222 };
 239
 240             SetDrMd( rp, JAM1 );
 241             SetAPen( rp, pens[SHADOWPEN] );
 242             SetAfPt( rp, pattern, 1);
 243
 244             /* render disable pattern */
 245             RectFill(rp,
 246                  container.Left,
 247                  container.Top,
 248                  container.Left + container.Width - 1,
 249                  container.Top + container.Height - 1 );
 250         }
 251     }
 252
 253     return (IPTR)0;
 254 }
 255
 256 /***********************************************************************************/
 257
 258 IPTR ButtonGClass__GM_HITTEST(Class *cl, struct Gadget *g, struct gpHitTest * msg)
 259 {
 260     struct Image *image = (struct Image *)g->GadgetRender;
 261
 262     IPTR retval = GMR_GADGETHIT;
 263
 264     if (image)
 265     {
 266         if (image->Depth == CUSTOMIMAGEDEPTH)
 267         {
 268             struct impHitTest imph;
 269
 270             imph.MethodID    = IM_HITTEST;
 271             imph.imp_Point.X = msg->gpht_Mouse.X;
 272             imph.imp_Point.Y = msg->gpht_Mouse.Y;
 273
 274             retval = DoMethodA((Object *)image, (Msg)&imph) ? GMR_GADGETHIT : 0;
 275         }
 276         else
 277         {
 278                 DEBUG_BUTTON(dprintf("buttong_hittest without customimage called\n");)
 279         }
 280     }
 281
 282     return retval;
 283 }
 284
 285 /***********************************************************************************/
 286
 287 IPTR ButtonGClass__GM_GOACTIVE(Class * cl, struct Gadget * g, struct gpInput * msg)
 288 {
 289     struct IntuitionBase *IntuitionBase = (struct IntuitionBase *)cl->cl_UserData;
 290     struct GadgetInfo *gi = msg->gpi_GInfo;
 291     IPTR               retval = GMR_NOREUSE;
 292
 293
 294     if (gi)
 295     {
 296         struct RastPort *rp = ObtainGIRPort(gi);
 297         if (rp)
 298         {
 299             struct gpRender method;
 300
 301             g->Flags ^= GFLG_SELECTED;
 302
 303             method.MethodID   = GM_RENDER;
 304             method.gpr_GInfo  = gi;
 305             method.gpr_RPort  = rp;
 306             method.gpr_Redraw = GREDRAW_REDRAW;
 307
 308
 309             DoMethodA((Object *)g, (Msg)&method);
 310             ReleaseGIRPort(rp);
 311
 312             /* Let's support toggleselect buttons too, for SnoopDos (DIE!),
 313              * which creates gadtools buttons and sets the toggleselect flag
 314              * afterwards (spit).
 315              */
 316             if (!(g->Activation & GACT_TOGGLESELECT))
 317             {
 318                 notifypressed(cl, g, gi, OPUF_INTERIM);
 319                 retval = GMR_MEACTIVE;
 320             }
 321             else
 322             {
 323                 notifypressed(cl, g, gi, 0);
 324                 retval = GMR_NOREUSE | GMR_VERIFY;
 325             }
 326         }
 327     }
 328
 329     return retval;
 330
 331 }
 332
 333 /***********************************************************************************/
 334
 335 IPTR ButtonGClass__GM_HANDLEINPUT(Class * cl, struct Gadget * g, struct gpInput * msg)
 336 {
 337     struct IntuitionBase *IntuitionBase = (struct IntuitionBase *)cl->cl_UserData;
 338     struct GadgetInfo  *gi = msg->gpi_GInfo;
 339     IPTR                retval = GMR_MEACTIVE;
 340
 341     if (gi)
 342     {
 343         struct InputEvent *ie = ((struct gpInput *)msg)->gpi_IEvent;
 344
 345         switch( ie->ie_Class )
 346         {
 347             case IECLASS_RAWMOUSE:
 348                 switch( ie->ie_Code )
 349                 {
 350                 case SELECTUP:
 351                     if( g->Flags & GFLG_SELECTED )
 352                     {
 353                         struct RastPort *rp;
 354
 355                         /* mouse is over gadget */
 356                         g->Flags &= ~GFLG_SELECTED;
 357
 358                         if ((rp = ObtainGIRPort(gi)))
 359                         {
 360                             struct gpRender method;
 361
 362                             method.MethodID   = GM_RENDER;
 363                             method.gpr_GInfo  = gi;
 364                             method.gpr_RPort  = rp;
 365                             method.gpr_Redraw = GREDRAW_UPDATE;
 366
 367                             DoMethodA((Object *)g, (Msg)&method);
 368
 369                             ReleaseGIRPort(rp);
 370                         }
 371
 372                         retval = GMR_NOREUSE | GMR_VERIFY;
 373                         /* This doesn't really make sense, as Termination will
 374                          * be sent in msg->Code. The original intuition puts
 375                          * junk here.
 376                          */
 377                         *msg->gpi_Termination = IDCMP_GADGETUP;
 378                     }
 379                     else
 380                         retval = GMR_NOREUSE;
 381
 382                     notifypressed(cl, g, gi, 0);
 383                     break;
 384
 385                 case IECODE_NOBUTTON:
 386                     {
 387                         struct gpHitTest gpht;
 388
 389                         gpht.MethodID     = GM_HITTEST;
 390                         gpht.gpht_GInfo   = gi;
 391                         gpht.gpht_Mouse.X = ((struct gpInput *)msg)->gpi_Mouse.X;
 392                         gpht.gpht_Mouse.Y = ((struct gpInput *)msg)->gpi_Mouse.Y;
 393
 394                         /*
 395                            This case handles selection state toggling when the
 396                            left button is depressed and the mouse is moved
 397                            around on/off the gadget bounds.
 398                         */
 399                         if ( DoMethodA((Object *)g, (Msg)&gpht) == GMR_GADGETHIT )
 400                         {
 401                             if ( (g->Flags & GFLG_SELECTED) == 0 )
 402                             {
 403                                 struct RastPort *rp;
 404
 405                                 /* mouse is over gadget */
 406                                 g->Flags |= GFLG_SELECTED;
 407
 408                                 if ((rp = ObtainGIRPort(gi)))
 409                                 {
 410                                     struct gpRender method;
 411
 412                                     method.MethodID   = GM_RENDER;
 413                                     method.gpr_GInfo  = gi;
 414                                     method.gpr_RPort  = rp;
 415                                     method.gpr_Redraw = GREDRAW_UPDATE;
 416
 417                                     DoMethodA((Object *)g, (Msg)&method);
 418
 419                                     ReleaseGIRPort(rp);
 420                                 }
 421                             }
 422                         }
 423                         else
 424                         {
 425                             if ( (g->Flags & GFLG_SELECTED) != 0 )
 426                             {
 427                                 struct RastPort *rp;
 428
 429                                 /* mouse is not over gadget */
 430                                 g->Flags &= ~GFLG_SELECTED;
 431
 432                                 if ((rp = ObtainGIRPort(gi)))
 433                                 {
 434                                     struct gpRender method;
 435
 436                                     method.MethodID   = GM_RENDER;
 437                                     method.gpr_GInfo  = gi;
 438                                     method.gpr_RPort  = rp;
 439                                     method.gpr_Redraw = GREDRAW_UPDATE;
 440
 441                                     DoMethodA((Object *)g, (Msg)&method);
 442
 443                                     ReleaseGIRPort(rp);
 444                                 }
 445                             }
 446                         }
 447                         break;
 448
 449                     } /**/
 450
 451                 default:
 452                     retval = GMR_REUSE;
 453                     *((struct gpInput *)msg)->gpi_Termination = 0UL;
 454                     break;
 455
 456                 } /* switch( ie->ie_Code ) */
 457                 break;
 458
 459             case IECLASS_TIMER:
 460                 notifypressed(cl, g, msg->gpi_GInfo, OPUF_INTERIM);
 461                 break;
 462
 463         } /* switch( ie->ie_Class ) */
 464
 465     } /* if (gi) */
 466     else
 467     {
 468         retval = GMR_NOREUSE;
 469     }
 470
 471     return retval;
 472 }
 473
 474 /***********************************************************************************/
 475
 476 IPTR ButtonGClass__GM_GOINACTIVE(Class * cl, struct Gadget *g, struct gpGoInactive * msg)
 477 {
 478     struct IntuitionBase *IntuitionBase = (struct IntuitionBase *)cl->cl_UserData;
 479     struct GadgetInfo *gi = msg->gpgi_GInfo;
 480
 481     if (!(g->Activation & GACT_TOGGLESELECT))
 482     {
 483         g->Flags &= ~GFLG_SELECTED;
 484
 485         if (gi)
 486         {
 487             struct RastPort *rp = ObtainGIRPort(gi);
 488
 489             if (rp)
 490             {
 491                 struct gpRender method;
 492                 struct opUpdate method2;
 493
 494                 method.MethodID   = GM_RENDER;
 495                 method.gpr_GInfo  = gi;
 496                 method.gpr_RPort  = rp;
 497                 method.gpr_Redraw = GREDRAW_REDRAW;
 498
 499                 DoMethodA((Object *)g, (Msg)&method);
 500
 501                 ReleaseGIRPort(rp);
 502
 503                 method2.MethodID     = OM_NOTIFY;
 504                 method2.opu_AttrList = NULL;
 505                 method2.opu_GInfo    = gi;
 506                 method2.opu_Flags    = 0;
 507
 508                 DoMethodA((Object *)g, (Msg)&method2);
 509             }
 510         }
 511     }
 512
 513     return (IPTR)0;
 514 }
 515
 516 /***********************************************************************************/