workbench/libs/asl/buttonclass.c

   1 /*
   2     Copyright © 1995-2011, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc:
   6     Lang: english
   7 */
   8
   9 #include <proto/alib.h>
  10 #include <proto/exec.h>
  11 #include <proto/dos.h>
  12 #include <proto/utility.h>
  13 #include <proto/intuition.h>
  14 #include <proto/graphics.h>
  15 #include <proto/cybergraphics.h>
  16 #include <exec/memory.h>
  17 #include <intuition/screens.h>
  18 #include <intuition/icclass.h>
  19 #include <intuition/cghooks.h>
  20 #include <intuition/imageclass.h>
  21 #include <intuition/gadgetclass.h>
  22 #include <graphics/gfx.h>
  23 #include <cybergraphx/cybergraphics.h>
  24
  25 #include <string.h>
  26
  27 #include "asl_intern.h"
  28 #include "layout.h"
  29
  30 #if USE_SHARED_COOLIMAGES
  31 #include <libraries/coolimages.h>
  32 #else
  33 #include "coolimages.h"
  34 #endif
  35
  36 #define SDEBUG 0
  37 #define DEBUG 0
  38
  39 #include <aros/debug.h>
  40
  41 #define CLASS_ASLBASE ((struct AslBase_intern *)cl->cl_UserData)
  42 #define HOOK_ASLBASE  ((struct AslBase_intern *)hook->h_Data)
  43
  44 #define AslBase CLASS_ASLBASE
  45
  46 /********************** ASL BUTTON CLASS **************************************************/
  47
  48 IPTR AslButton__OM_NEW(Class * cl, Object * o, struct opSet * msg)
  49 {
  50     struct AslButtonData *data;
  51     struct TagItem fitags[] =
  52     {
  53         {IA_FrameType, FRAME_BUTTON},
  54         {IA_EdgesOnly, TRUE        },
  55         {TAG_DONE, 0UL}
  56     };
  57
  58     struct Gadget *g = (struct Gadget *)DoSuperMethodA(cl, o, (Msg)msg);
  59
  60     if (g)
  61     {
  62         data = INST_DATA(cl, g);
  63
  64         /* {GA_Image, whatever} means, a frame shall be created */
  65
  66         if (FindTagItem(GA_Image, msg->ops_AttrList))
  67         {
  68             if (g->GadgetText) fitags[1].ti_Tag = TAG_IGNORE;
  69             data->frame = NewObjectA(NULL, FRAMEICLASS, fitags);
  70         }
  71
  72         data->coolimage = (struct CoolImage *)GetTagData(ASLBT_CoolImage, 0, msg->ops_AttrList);
  73
  74         data->ld = (struct LayoutData *)GetTagData(GA_UserData, 0, msg->ops_AttrList);
  75
  76         if (!data->ld)
  77         {
  78             CoerceMethod(cl, (Object *)g, OM_DISPOSE);
  79             g = NULL;
  80         } else {
  81             if (data->coolimage && data->ld->ld_TrueColor && CyberGfxBase)
  82             {
  83             #if SHARED_COOLIMAGES_LIBRARY
  84                 WORD numcols = data->coolimage->numcolors;
  85             #else
  86                 WORD numcols = 1 << data->coolimage->depth;
  87             #endif
  88
  89                 if ((data->coolimagepal = AllocVec(numcols * sizeof(ULONG), MEMF_PUBLIC)))
  90                 {
  91                     ULONG *p = data->coolimagepal;
  92                     WORD i;
  93
  94                     for(i = 0; i < numcols; i++)
  95                     {
  96                         *p++ = (data->coolimage->pal[i * 3] << 16) |
  97                                (data->coolimage->pal[i * 3 + 1] << 8) |
  98                                (data->coolimage->pal[i * 3 + 2]);
  99                     }
 100
 101                 } else {
 102                     data->coolimage = NULL;
 103                 }
 104             } else {
 105                 data->coolimage = NULL;
 106             }
 107         }
 108
 109     } /* if (g) */
 110
 111     return (IPTR)g;
 112 }
 113
 114 /***********************************************************************************/
 115
 116 IPTR AslButton__OM_DISPOSE(Class * cl, Object * o, Msg msg)
 117 {
 118     struct AslButtonData *data;
 119     IPTR retval;
 120
 121     data = INST_DATA(cl, o);
 122     if (data->frame) DisposeObject(data->frame);
 123     if (data->coolimagepal) FreeVec(data->coolimagepal);
 124
 125     retval = DoSuperMethodA(cl, o, msg);
 126
 127     return retval;
 128 }
 129
 130 /***********************************************************************************/
 131
 132 IPTR AslButton__GM_HITTEST(Class *cl, struct Gadget *g, struct gpHitTest *msg)
 133 {
 134     WORD gadx, gady, gadw, gadh;
 135
 136     getgadgetcoords(g, msg->gpht_GInfo, &gadx, &gady, &gadw, &gadh);
 137
 138     return ((msg->gpht_Mouse.X >= 0) &&
 139             (msg->gpht_Mouse.Y >= 0) &&
 140             (msg->gpht_Mouse.X < gadw) &&
 141             (msg->gpht_Mouse.Y < gadh)) ? GMR_GADGETHIT : 0;
 142 }
 143
 144 /***********************************************************************************/
 145
 146 #if BUTTON_OWN_INPUT_HANDLING
 147
 148 /***********************************************************************************/
 149
 150 IPTR AslButton__GM_GOACTIVE(Class *cl, struct Gadget *g, struct gpInput *msg)
 151 {
 152     struct GadgetInfo   *gi = msg->gpi_GInfo;
 153     IPTR                retval = GMR_NOREUSE;
 154
 155     if (gi)
 156     {
 157         struct RastPort *rp = ObtainGIRPort(gi);
 158
 159         if (rp)
 160         {
 161             g->Flags |= GFLG_SELECTED;
 162
 163             DoMethod((Object *)g, GM_RENDER, (IPTR) gi, (IPTR) rp, GREDRAW_REDRAW);
 164             ReleaseGIRPort(rp);
 165
 166             retval = GMR_MEACTIVE;
 167         }
 168     }
 169
 170     return retval;
 171  }
 172
 173 /***********************************************************************************/
 174
 175 IPTR AslButton__GM_HANDLEINPUT(Class *cl, struct Gadget *g, struct gpInput *msg)
 176 {
 177     struct GadgetInfo   *gi = msg->gpi_GInfo;
 178     IPTR                retval = GMR_MEACTIVE;
 179
 180     if (gi)
 181     {
 182         struct InputEvent *ie = ((struct gpInput *)msg)->gpi_IEvent;
 183
 184         switch(ie->ie_Class)
 185         {
 186             case IECLASS_RAWMOUSE:
 187                 switch( ie->ie_Code )
 188                 {
 189                     case SELECTUP:
 190                         if( g->Flags & GFLG_SELECTED )
 191                         {
 192                             struct RastPort *rp;
 193
 194                             /* mouse is over gadget */
 195                             g->Flags &= ~GFLG_SELECTED;
 196
 197                             if ((rp = ObtainGIRPort(gi)))
 198                             {
 199                                 DoMethod((Object *)g, GM_RENDER, (IPTR) gi, (IPTR) rp, GREDRAW_UPDATE);
 200                                 ReleaseGIRPort(rp);
 201                             }
 202                             retval = GMR_NOREUSE | GMR_VERIFY;
 203                             *msg->gpi_Termination = IDCMP_GADGETUP;
 204                         }
 205                         else
 206                         {
 207                             retval = GMR_NOREUSE;
 208                         }
 209                         break;
 210
 211                     case IECODE_NOBUTTON:
 212                         {
 213                             struct gpHitTest gpht;
 214
 215                             gpht.MethodID     = GM_HITTEST;
 216                             gpht.gpht_GInfo   = gi;
 217                             gpht.gpht_Mouse.X = ((struct gpInput *)msg)->gpi_Mouse.X;
 218                             gpht.gpht_Mouse.Y = ((struct gpInput *)msg)->gpi_Mouse.Y;
 219
 220                             /*
 221                                This case handles selection state toggling when the
 222                                left button is depressed and the mouse is moved
 223                                around on/off the gadget bounds.
 224                             */
 225                             if ( DoMethodA((Object *)g, (Msg)&gpht) == GMR_GADGETHIT )
 226                             {
 227                                 if ( (g->Flags & GFLG_SELECTED) == 0 )
 228                                 {
 229                                     struct RastPort *rp;
 230
 231                                     /* mouse is over gadget */
 232                                     g->Flags |= GFLG_SELECTED;
 233
 234                                     if ((rp = ObtainGIRPort(gi)))
 235                                     {
 236                                         DoMethod((Object *)g, GM_RENDER, (IPTR) gi, (IPTR) rp, GREDRAW_UPDATE);
 237                                         ReleaseGIRPort(rp);
 238                                     }
 239                                 }
 240                             }
 241                             else
 242                             {
 243                                 if ( (g->Flags & GFLG_SELECTED) != 0 )
 244                                 {
 245                                     struct RastPort *rp;
 246
 247                                     /* mouse is not over gadget */
 248                                     g->Flags &= ~GFLG_SELECTED;
 249
 250                                     if ((rp = ObtainGIRPort(gi)))
 251                                     {
 252                                         DoMethod((Object *)g, GM_RENDER, (IPTR) gi, (IPTR) rp, GREDRAW_UPDATE);
 253                                         ReleaseGIRPort(rp);
 254                                     }
 255                                 }
 256                             }
 257                             break;
 258                         }
 259
 260                     default:
 261                         retval = GMR_REUSE;
 262                         *((struct gpInput *)msg)->gpi_Termination = 0UL;
 263                         break;
 264
 265                 } /* switch(ie->ie_Code) */
 266                 break;
 267
 268         } /* switch(ie->ie_Class) */
 269
 270     } /* if (gi) */
 271     else
 272     {
 273         retval = GMR_NOREUSE;
 274     }
 275
 276     return retval;
 277 }
 278
 279 /***********************************************************************************/
 280
 281 IPTR AslButton__GM_GOINACTIVE(Class *cl, struct Gadget *g, struct gpGoInactive *msg)
 282 {
 283     struct GadgetInfo *gi = msg->gpgi_GInfo;
 284
 285     g->Flags &= ~GFLG_SELECTED;
 286
 287     if (gi)
 288     {
 289         struct RastPort *rp = ObtainGIRPort(gi);
 290
 291         if (rp)
 292         {
 293             DoMethod((Object *)g, GM_RENDER, (IPTR) gi, (IPTR) rp, GREDRAW_REDRAW);
 294             ReleaseGIRPort(rp);
 295         }
 296     }
 297
 298     return 0;
 299 }
 300
 301 /***********************************************************************************/
 302
 303 #else /* BUTTON_OWN_INPUT_HANDLING */
 304
 305 IPTR AslButton__GM_GOACTIVE(Class *cl, Object *o, Msg msg)
 306 {
 307     return DoSuperMethodA(cl, o, msg);
 308 }
 309 IPTR AslButton__GM_HANDLEINPUT(Class *cl, Object *o, Msg msg)
 310 {
 311     return DoSuperMethodA(cl, o, msg);
 312 }
 313 IPTR AslButton__GM_GOINACTIVE(Class *cl, Object *o, Msg msg)
 314 {
 315     return DoSuperMethodA(cl, o, msg);
 316 }
 317
 318 #endif /* BUTTON_OWN_INPUT_HANDLING */
 319
 320 /***********************************************************************************/
 321
 322 IPTR AslButton__GM_RENDER(Class *cl, struct Gadget *g, struct gpRender *msg)
 323 {
 324     struct AslButtonData *data;
 325     char *text = (STRPTR)g->GadgetText;
 326     struct TagItem im_tags[] =
 327     {
 328         {IA_Width       , 0     },
 329         {IA_Height      , 0     },
 330         {TAG_DONE               }
 331     };
 332     WORD x, y, w, h;
 333
 334     getgadgetcoords(g, msg->gpr_GInfo, &x, &y, &w, &h);
 335
 336     data = INST_DATA(cl, g);
 337
 338     if (data->frame)
 339     {
 340         im_tags[0].ti_Data = w;
 341         im_tags[1].ti_Data = h;
 342
 343         SetAttrsA(data->frame, im_tags);
 344
 345         DrawImageState(msg->gpr_RPort,
 346                        (struct Image *)data->frame,
 347                        x,
 348                        y,
 349                        (!text || (g->Flags & GFLG_SELECTED)) ? IDS_SELECTED : IDS_NORMAL,
 350                        msg->gpr_GInfo->gi_DrInfo);
 351     }
 352
 353     if (text)
 354     {
 355         WORD len = strlen(text);
 356         WORD tx = x, ty = y;
 357
 358         SetFont(msg->gpr_RPort, data->ld->ld_Font);
 359
 360         if (data->coolimage)
 361         {
 362             tx += BORDERIMAGESPACINGX + data->coolimage->width + BORDERIMAGESPACINGX;
 363             w  -= (BORDERIMAGESPACINGX + data->coolimage->width + BORDERIMAGESPACINGX + BORDERIMAGESPACINGX);
 364         }
 365
 366         tx += (w - TextLength(msg->gpr_RPort, text, len)) / 2;
 367         ty += (h - msg->gpr_RPort->TxHeight) / 2 + msg->gpr_RPort->TxBaseline;
 368
 369         if (data->frame)
 370         {
 371             SetABPenDrMd(msg->gpr_RPort,
 372                          data->ld->ld_Dri->dri_Pens[(g->Flags & GFLG_SELECTED) ? FILLTEXTPEN : TEXTPEN],
 373                          0,
 374                          JAM1);
 375         }
 376         else
 377         {
 378         #if AVOID_FLICKER
 379             struct TextExtent te;
 380             struct IBox obox, ibox;
 381
 382             getgadgetcoords(g, msg->gpr_GInfo, &obox.Left, &obox.Top, &obox.Width, &obox.Height);
 383
 384             TextExtent(msg->gpr_RPort, text, len, &te);
 385
 386             ibox.Width  = te.te_Extent.MaxX - te.te_Extent.MinX + 1;
 387             ibox.Height = te.te_Extent.MaxY - te.te_Extent.MinY + 1;
 388             ibox.Left   = te.te_Extent.MinX + tx;
 389             ibox.Top    = te.te_Extent.MinY + ty;
 390
 391             PaintBoxFrame(msg->gpr_RPort,
 392                           &obox,
 393                           &ibox,
 394                           data->ld->ld_Dri->dri_Pens[BACKGROUNDPEN],
 395                           AslBase);
 396
 397         #endif
 398             SetABPenDrMd(msg->gpr_RPort,
 399                          data->ld->ld_Dri->dri_Pens[(g->Flags & GFLG_SELECTED) ? FILLTEXTPEN : TEXTPEN],
 400                          data->ld->ld_Dri->dri_Pens[BACKGROUNDPEN],
 401                          JAM2);
 402
 403         }
 404
 405         Move(msg->gpr_RPort, tx, ty);
 406         Text(msg->gpr_RPort, text, len);
 407     }
 408     else
 409     {
 410         x += 3; w -= 6;
 411         y += 3; h -= 6;
 412
 413     #if AVOID_FLICKER
 414         if (data->frame)
 415         {
 416             struct IBox ibox, fbox;
 417
 418             getgadgetcoords(g, msg->gpr_GInfo, &fbox.Left, &fbox.Top, &fbox.Width, &fbox.Height);
 419
 420             ibox.Left = x;
 421             ibox.Top = y;
 422             ibox.Width = w;
 423             ibox.Height = h;
 424
 425             PaintInnerFrame(msg->gpr_RPort,
 426                             data->ld->ld_Dri,
 427                             data->frame,
 428                             &fbox,
 429                             &ibox,
 430                             data->ld->ld_Dri->dri_Pens[BACKGROUNDPEN],
 431                             AslBase);
 432         }
 433
 434     #endif
 435
 436         SetABPenDrMd(msg->gpr_RPort,
 437                      data->ld->ld_Dri->dri_Pens[(g->Flags & GFLG_SELECTED) ? FILLPEN : BACKGROUNDPEN],
 438                      0,
 439                      JAM1);
 440
 441         RectFill(msg->gpr_RPort, x, y, x + w - 1, y + h - 1);
 442     }
 443
 444     if (data->coolimage)
 445     {
 446         struct ColorMap *cm = msg->gpr_GInfo->gi_Screen->ViewPort.ColorMap;
 447         ULONG bg[3];
 448
 449         GetRGB32(cm, data->ld->ld_Dri->dri_Pens[(g->Flags & GFLG_SELECTED) ? FILLPEN : BACKGROUNDPEN], 1, bg);
 450         data->coolimagepal[0] = ((bg[0] & 0xFF000000) >> 8) + ((bg[1] & 0xFF000000) >> 16) + ((bg[2] & 0xFF000000) >> 24);
 451
 452         WriteLUTPixelArray((APTR)data->coolimage->data,
 453                             0,
 454                             0,
 455                             data->coolimage->width,
 456                             msg->gpr_RPort,
 457                             data->coolimagepal,
 458                             x + BORDERIMAGESPACINGX,
 459                             y + (h - data->coolimage->height) / 2,
 460                             data->coolimage->width,
 461                             data->coolimage->height,
 462                             CTABFMT_XRGB8);
 463
 464     }
 465
 466     return 0;
 467 }
 468
 469 /***********************************************************************************/
 470
 471 IPTR AslButton__GM_LAYOUT(Class * cl, struct Gadget * g, struct gpLayout * msg)
 472 {
 473     struct AslButtonData *data;
 474     IPTR retval;
 475     WORD innerwidth;
 476     WORD spacing;
 477     WORD x;
 478
 479     data = INST_DATA(cl, g);
 480
 481     retval = DoSuperMethodA(cl, (Object *)g, (Msg)msg);
 482
 483     switch (g->GadgetID)
 484     {
 485         case ID_MAINBUTTON_OK:
 486         case ID_MAINBUTTON_MIDDLELEFT:
 487         case ID_MAINBUTTON_MIDDLERIGHT:
 488         case ID_MAINBUTTON_CANCEL:
 489
 490             /* multiply width 16 for sub-pixel accuracy */
 491
 492             x = (data->ld->ld_WBorLeft + OUTERSPACINGX) * 16 + 8;
 493
 494             innerwidth = msg->gpl_GInfo->gi_Window->Width -
 495                          msg->gpl_GInfo->gi_Window->BorderLeft -
 496                          msg->gpl_GInfo->gi_Window->BorderRight -
 497                          OUTERSPACINGX * 2;
 498
 499             /* multiply width 16 for sub-pixel accuracy */
 500
 501             spacing = (innerwidth - data->ld->ld_ButWidth * data->ld->ld_NumButtons) * 16 /
 502                       (data->ld->ld_NumButtons - 1);
 503
 504             x += (g->GadgetID - ID_MAINBUTTON_OK) * (data->ld->ld_ButWidth * 16 + spacing);
 505             g->LeftEdge = x / 16;
 506             break;
 507     }
 508
 509     return retval;
 510 }
 511
 512 /***********************************************************************************/
 513