workbench/libs/asl/buttonclass.c

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