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