workbench/classes/gadgets/gradientslider/gradientsliderclass.c

   1 /*
   2     Copyright © 1995-2005, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc: AROS gradientslider gadget.
   6     Lang: english
   7 */
   8
   9 #include <exec/types.h>
  10
  11 #ifdef __AROS__
  12 //#define USE_BOOPSI_STUBS
  13 #include <proto/utility.h>
  14 #include <proto/intuition.h>
  15 #include <proto/graphics.h>
  16 #include <intuition/classes.h>
  17 #include <intuition/classusr.h>
  18 #include <intuition/cghooks.h>
  19 #include <intuition/gadgetclass.h>
  20 #include <intuition/imageclass.h>
  21 #include <utility/tagitem.h>
  22 #include <gadgets/gradientslider.h>
  23
  24 #include <aros/asmcall.h>
  25
  26 #include <stdlib.h> /* abs() */
  27 #include "gradientslider_intern.h"
  28
  29 #define SDEBUG 0
  30 #define DEBUG 0
  31
  32 #include <aros/debug.h>
  33
  34 #else /* !AROS */
  35
  36 #include <intuition/icclass.h>
  37 #include <intuition/classes.h>
  38 #include <intuition/classusr.h>
  39 #include <intuition/cghooks.h>
  40 #include <intuition/gadgetclass.h>
  41 #include <intuition/imageclass.h>
  42 #include <utility/tagitem.h>
  43 #include <gadgets/gradientslider.h>
  44
  45 #include <inline/graphics.h>
  46 #include <inline/intuition.h>
  47 #include <inline/exec.h>
  48 #include <inline/utility.h>
  49 #include <inline/cybergraphics.h>
  50
  51 #include "gradientslider_intern.h"
  52 #include "BoopsiStubs.h"
  53
  54 #endif
  55
  56 #ifndef __AROS__
  57
  58 #if 1
  59 #undef SysBase
  60 void kprintf( STRPTR FormatStr, ... )
  61 {
  62         TEXT    PutChData[64];
  63         STRPTR  p = PutChData;
  64         struct Library *SysBase = (*(struct Library **)4L);
  65         RawDoFmt(FormatStr, ((STRPTR)(&FormatStr))+4, (void (*)())"\x16\xc0\x4e\x75", PutChData);
  66
  67         do RawPutChar( *p );
  68         while( *p++ );
  69 }
  70 #define SysBase         GSB(GradientSliderBase)->sysbase
  71 #endif
  72
  73 #ifdef __STORMGCC__
  74 LONG myBltBitMap( struct BitMap *srcBitMap, long xSrc, long ySrc,
  75         struct BitMap *destBitMap, long xDest, long yDest, long xSize,
  76         long ySize, unsigned long minterm, unsigned long mask,
  77         PLANEPTR tempA, struct Library *Graphics );
  78 #endif
  79
  80 #endif
  81
  82 /***************************************************************************************************/
  83
  84 STATIC VOID notify_curval(Class *cl, Object *o, struct GadgetInfo *gi, BOOL interim, BOOL userinput)
  85 {
  86     struct GradientSliderData   *data = INST_DATA(cl, o);
  87     struct opUpdate             opu, *p_opu = &opu;
  88     struct TagItem              tags[] =
  89     {
  90         {GA_ID                  , EG(o)->GadgetID       },
  91         {GA_UserInput           , userinput             },
  92         {GRAD_CurVal            , data->curval          },
  93         {TAG_DONE                                       }
  94     };
  95
  96     opu.MethodID     = OM_NOTIFY;
  97     opu.opu_AttrList = tags;
  98     opu.opu_GInfo    = gi;
  99     opu.opu_Flags    = interim ? OPUF_INTERIM : 0;
 100
 101     DoMethodA(o, (Msg)p_opu);
 102 }
 103
 104 /***************************************************************************************************/
 105
 106 IPTR GradientSlider__OM_SET(Class *cl, Object *o, struct opSet *msg)
 107 {
 108     const struct TagItem        *tstate;
 109     struct TagItem              *tag;
 110     IPTR                        retval;
 111     struct GradientSliderData   *data = INST_DATA(cl, o);
 112     BOOL                        redraw_all = data->savebm == NULL;
 113     LONG                        flags = EG(o)->Flags;
 114
 115     EnterFunc(bug("GradientSlider::Set()\n"));
 116
 117     retval = 0;
 118
 119     if (msg->MethodID != OM_NEW) retval = DoSuperMethodA(cl, o, (Msg)msg);
 120
 121     tstate = msg->ops_AttrList;
 122     while((tag = NextTagItem(&tstate)))
 123     {
 124         IPTR tidata = tag->ti_Data;
 125
 126         switch (tag->ti_Tag)
 127         {
 128             case GRAD_CurVal:
 129                 data->curval = (ULONG)tidata;
 130                 notify_curval(cl, o, msg->ops_GInfo, FALSE, FALSE);
 131                 retval += 1UL;
 132                 break;
 133
 134             case GA_Disabled:
 135                 if ((EG(o)->Flags&GFLG_DISABLED) != (flags&GFLG_DISABLED))
 136                 {
 137                     retval += 1UL;
 138                     redraw_all = TRUE;
 139                 }
 140                 break;
 141
 142             case GRAD_MaxVal:
 143                 if (tidata > 0 && tidata < 65536) // ReAction fix.
 144                 {
 145                     ULONG new_curval;
 146
 147                     new_curval = ( tidata > 0L ) ? (((ULONG)tidata) * data->curval) / data->maxval : 0L;
 148                     data->maxval = (ULONG)tidata;
 149
 150                     if (new_curval != data->curval)
 151                     {
 152                         data->curval = new_curval;
 153                         notify_curval(cl, o, msg->ops_GInfo, FALSE, FALSE);
 154                     }
 155                     retval += 1UL;
 156                 }
 157                 break;
 158
 159             case GRAD_SkipVal:
 160                 data->skipval = (ULONG)tidata;
 161                 break;
 162
 163             case GRAD_PenArray:
 164             {
 165                 if( tidata ) // REACTION_TextAttr collides with this one
 166                 {
 167                     UWORD *pen = (UWORD *) tidata;
 168
 169                     if( ( pen[0] & 0xff00 ) && ( pen[0] != 0xffff ) )
 170                         break;
 171
 172                     if( ( pen[1] & 0xff00 ) && ( pen[1] != 0xffff ) )
 173                         break;
 174                 }
 175
 176                 data->penarray = (UWORD *)tidata;
 177                 data->numpens = 0;
 178
 179                 if (data->penarray)
 180                 {
 181                     UWORD *pen = data->penarray;
 182
 183                     while(*pen++ != (UWORD)~0) data->numpens++;
 184                 }
 185
 186                 retval += 1UL;
 187                 redraw_all = TRUE;
 188             }
 189             break;
 190
 191             default:
 192                 break;
 193
 194         } /* switch (tag->ti_Tag) */
 195
 196     } /* for (each attr in attrlist) */
 197
 198     if (retval)
 199     {
 200         struct RastPort *rp;
 201
 202         if ((rp = ObtainGIRPort(msg->ops_GInfo)))
 203         {
 204             DoMethod(o, GM_RENDER, (IPTR)msg->ops_GInfo, (IPTR)rp, redraw_all ? GREDRAW_REDRAW : GREDRAW_UPDATE);
 205             ReleaseGIRPort(rp);
 206             retval = 0L;
 207         }
 208     }
 209
 210     ReturnPtr ("GradientSlider::Set", IPTR, retval);
 211 }
 212
 213 /***************************************************************************************************/
 214
 215 Object *GradientSlider__OM_NEW(Class *cl, Object *o, struct opSet *msg)
 216 {
 217     EnterFunc(bug("GradientSlider::New()\n"));
 218
 219     o = (Object *)DoSuperMethodA(cl, o, (Msg)msg);
 220     if (o)
 221     {
 222         struct GradientSliderData       *data = INST_DATA(cl, o);
 223         static struct TagItem           fitags[]=
 224         {
 225            {IA_FrameType        , FRAME_BUTTON  },
 226            {TAG_DONE                            }
 227         };
 228
 229         if ((data->frame = NewObjectA(NULL, FRAMEICLASS, fitags)))
 230         {
 231             data->maxval     = 0xFFFF;
 232             data->curval     = 0;
 233             data->skipval    = 0x1111;
 234             data->knobpixels = GetTagData(GRAD_KnobPixels, 5, msg->ops_AttrList);
 235             data->freedom    = GetTagData(PGA_Freedom, LORIENT_HORIZ, msg->ops_AttrList);
 236
 237             InitRastPort( &data->trp );
 238
 239             GradientSlider__OM_SET(cl, o, msg);
 240
 241         } else {
 242             CoerceMethod(cl, o, OM_DISPOSE);
 243             o = NULL;
 244         }
 245
 246     }
 247     ReturnPtr ("GradientSlider::New", Object *, o);
 248 }
 249
 250 /***************************************************************************************************/
 251
 252 VOID GradientSlider__OM_DISPOSE(Class *cl, Object *o, Msg msg)
 253 {
 254     struct GradientSliderData   *data = INST_DATA(cl, o);
 255
 256     if (data->frame) DisposeObject(data->frame);
 257
 258     if (data->savebm)
 259     {
 260         WaitBlit();
 261         FreeBitMap(data->savebm);
 262     }
 263
 264     if (data->knobbm)
 265     {
 266         WaitBlit();
 267         FreeBitMap(data->knobbm);
 268     }
 269
 270     if (data->buffer)
 271     {
 272         FreeVec(data->buffer);
 273     }
 274
 275     DeinitRastPort( &data->trp );
 276
 277     DoSuperMethodA(cl, o, msg);
 278 }
 279
 280 /***************************************************************************************************/
 281
 282 IPTR GradientSlider__OM_GET(Class *cl, Object *o, struct opGet *msg)
 283 {
 284     struct GradientSliderData   *data = INST_DATA(cl, o);
 285     IPTR                        retval = 1UL;
 286
 287     switch(msg->opg_AttrID)
 288     {
 289         case GRAD_MaxVal:
 290             *msg->opg_Storage = data->maxval;
 291             break;
 292
 293         case GRAD_CurVal:
 294             *msg->opg_Storage = data->curval;
 295             break;
 296
 297         case GRAD_SkipVal:
 298             *msg->opg_Storage = data->skipval;
 299             break;
 300
 301         default:
 302             retval = DoSuperMethodA(cl, o, (Msg)msg);
 303             break;
 304
 305     } /* switch(msg->opg_AttrID) */
 306
 307     return retval;
 308 }
 309
 310 /***************************************************************************************************/
 311
 312 VOID GradientSlider__GM_RENDER(Class *cl, Object *o, struct gpRender *msg)
 313 {
 314     struct GradientSliderData   *data = INST_DATA(cl, o);
 315     struct DrawInfo             *dri = msg->gpr_GInfo->gi_DrInfo;
 316     struct RastPort             *rp = msg->gpr_RPort;
 317     struct IBox                 gbox, sbox, kbox;
 318     LONG                        redraw = msg->gpr_Redraw;
 319
 320     EnterFunc(bug("GradientSlider::Render()\n"));
 321
 322     GetGadgetIBox(o, msg->gpr_GInfo, &gbox);
 323     GetSliderBox(&gbox, &sbox);
 324     sbox.Left -= gbox.Left;
 325     sbox.Top -= gbox.Top;
 326     GetKnobBox(data, &sbox, &kbox);
 327
 328     switch (redraw)
 329     {
 330         case GREDRAW_UPDATE:
 331             if ((kbox.Width <= sbox.Width) && (kbox.Height <= sbox.Height) && (data->savebm))
 332             {
 333                 if( gbox.Width == data->savebmwidth && gbox.Height == data->savebmheight )
 334                 {
 335                     if ((kbox.Left != data->savefromx) || (kbox.Top != data->savefromy))
 336                     {
 337                          /* Restore old area behind knob */
 338                     #ifdef __STORMGCC__
 339                          myBltBitMap( data->knobbm, 0,0, data->savebm, data->savefromx,data->savefromy, kbox.Width,kbox.Height, 0xc0, 0xff, NULL, GfxBase);
 340                     #else
 341                          BltBitMap( data->knobbm, 0,0, data->savebm, data->savefromx,data->savefromy, kbox.Width,kbox.Height, 0xc0, 0xff, NULL);
 342                     #endif
 343                          //BltBitMapRastPort( data->savebm, data->savefromx,data->savefromy, rp, gbox.Left+data->savefromx,gbox.Top+data->savefromy, kbox.Width,kbox.Height, 0xc0 );
 344
 345                          data->savefromx = kbox.Left;
 346                          data->savefromy = kbox.Top;
 347                     #ifdef __STORMGCC__
 348                          myBltBitMap( data->savebm, kbox.Left,kbox.Top, data->knobbm, 0,0, kbox.Width,kbox.Height, 0xc0, 0xff, NULL, GfxBase );
 349                     #else
 350                          BltBitMap( data->savebm, kbox.Left,kbox.Top, data->knobbm, 0,0, kbox.Width,kbox.Height, 0xc0, 0xff, NULL );
 351                     #endif
 352                          data->trp.BitMap = data->savebm;
 353
 354                          DrawKnob(data, &data->trp, dri, &kbox, 0);
 355                          //BltBitMapRastPort( data->savebm, kbox.Left,kbox.Top, rp, gbox.Left+kbox.Left,gbox.Top+kbox.Top, kbox.Width,kbox.Height, 0xc0 );
 356                          BltBitMapRastPort( data->savebm, sbox.Left,sbox.Top, rp, gbox.Left+sbox.Left,gbox.Top+sbox.Top, sbox.Width,sbox.Height, 0xc0 );
 357                     } /* if (!data->savebm || (kbox.Left != data->savefromx) || (kbox.Top != data->savefromy)) */
 358
 359                     break;
 360                 }
 361
 362             } /* if ((kbox.Width <= sbox.Width) && (kbox.Height <= sbox.Height)) */
 363
 364         case GREDRAW_REDRAW:
 365             {
 366                 struct RastPort *trp = &data->trp;
 367
 368                 if( gbox.Width != data->savebmwidth || gbox.Height != data->savebmheight )
 369                 {
 370                     if( data->savebm )
 371                     {
 372                         WaitBlit();
 373                         FreeBitMap( data->savebm );
 374                         data->savebm = NULL;
 375                     }
 376
 377                     if( data->knobbm )
 378                     {
 379                         WaitBlit();
 380                         FreeBitMap( data->knobbm );
 381                         data->knobbm = NULL;
 382                     }
 383
 384                     if( data->buffer )
 385                     {
 386                         FreeVec( data->buffer );
 387                         data->buffer = NULL;
 388                     }
 389                 }
 390
 391                 if( data->savebm == NULL )
 392                 {
 393                     struct TagItem fitags[] =
 394                     {
 395                         {IA_Width       , gbox.Width    },
 396                         {IA_Height      , gbox.Height   },
 397                         {TAG_DONE                       }
 398                     };
 399
 400                     SetAttrsA(data->frame, fitags);
 401
 402                     if( ! ( data->savebm = AllocBitMap(
 403                             gbox.Width, gbox.Height,
 404                             GetBitMapAttr(rp->BitMap, BMA_DEPTH),
 405                             BMF_MINPLANES, rp->BitMap ) ) )
 406                     {
 407                         break;
 408                     }
 409
 410                     data->savebmwidth = gbox.Width;
 411                     data->savebmheight = gbox.Height;
 412
 413                     if( ! ( data->knobbm = AllocBitMap(
 414                             kbox.Width, kbox.Height,
 415                             GetBitMapAttr(data->savebm, BMA_DEPTH),
 416                             BMF_MINPLANES, data->savebm ) ) )
 417                     {
 418                         FreeBitMap( data->savebm );
 419                         data->savebm = NULL;
 420                         break;
 421                     }
 422
 423                     /* Draw frame */
 424                     trp->BitMap = data->savebm;
 425                     DrawImageState( trp, (struct Image *) data->frame, 0,0, IDS_NORMAL, dri );
 426                 }
 427
 428                 /* Draw slider background */
 429                 if( (sbox.Width >= 2) && (sbox.Height >= 2) )
 430                 {
 431                     if (data->numpens < 2)
 432                     {
 433                         WORD pen = dri->dri_Pens[BACKGROUNDPEN];
 434
 435                         if (data->penarray && (data->numpens == 1))
 436                         {
 437                             pen = data->penarray[0];
 438                         }
 439
 440                         SetDrMd(trp, JAM1);
 441                         SetAPen(trp, pen);
 442                         RectFill(trp, sbox.Left, sbox.Top, sbox.Left + sbox.Width - 1, sbox.Top + sbox.Height - 1);
 443                     } /* ff (data->numpens < 2) */
 444                     else
 445                     {
 446                         DrawGradient(trp,
 447                                      sbox.Left,
 448                                      sbox.Top,
 449                                      sbox.Left + sbox.Width - 1,
 450                                      sbox.Top + sbox.Height - 1,
 451                                      data->penarray, data->numpens, data->freedom,
 452                                      msg->gpr_GInfo->gi_Screen->ViewPort.ColorMap
 453                         );
 454                     } /* data->numpens >= 2 */
 455                 } /* if ((sbox.Width >= 2) && (sbox.Height >= 2)) */
 456
 457                 /* Backup area over which knob will be drawn */
 458                 if ((kbox.Width > 0) && (kbox.Height > 0) &&
 459                     (kbox.Width <= sbox.Width) && (kbox.Height <= sbox.Height))
 460                 {
 461                 #ifdef __STORMGCC__
 462                     myBltBitMap( data->savebm, kbox.Left,kbox.Top, data->knobbm, 0,0, kbox.Width,kbox.Height, 0xc0, 0xff, NULL, GfxBase );
 463                 #else
 464                     BltBitMap( data->savebm, kbox.Left,kbox.Top, data->knobbm, 0,0, kbox.Width,kbox.Height, 0xc0, 0xff, NULL );
 465                 #endif
 466
 467                     data->savefromx    = kbox.Left;
 468                     data->savefromy    = kbox.Top;
 469
 470                     /* Render knob */
 471                     DrawKnob(data, trp, dri, &kbox, 0);
 472                 } /* if ((kbox.Width > 0) && (kbox.Height > 0) && (kbox.Width <= sbox.Width) && (kbox.Height <= sbox.Height)) */
 473
 474                 BltBitMapRastPort( data->savebm, 0,0, rp, gbox.Left,gbox.Top,gbox.Width,gbox.Height, 0xc0 );
 475             }
 476             break;
 477     } /* switch (redraw) */
 478
 479     if( EG(o)->Flags & GFLG_DISABLED )
 480             DrawDisabledPattern( rp, &gbox, dri->dri_Pens[SHADOWPEN]);
 481
 482     ReturnVoid("GradientSlider::Render");
 483 }
 484
 485 /***************************************************************************************************/
 486
 487 IPTR GradientSlider__GM_HITTEST(Class *cl, Object *o, struct gpHitTest *msg)
 488 {
 489 //  struct GradientSliderData   *data = INST_DATA(cl, o);
 490     struct IBox                 gbox, sbox;
 491     WORD                        mousex, mousey;
 492     IPTR                        retval = 0UL;
 493
 494     EnterFunc(bug("GradientSlider::HitTest()\n"));
 495
 496     if( EG(o)->Flags & GFLG_DISABLED )
 497         return 0UL;
 498
 499     GetGadgetIBox(o, msg->gpht_GInfo, &gbox);
 500     GetSliderBox(&gbox, &sbox);
 501
 502     if ((sbox.Width > 2) && (sbox.Height > 2))
 503     {
 504         /* calc mouse coords relative to slider box */
 505
 506         mousex = msg->gpht_Mouse.X - (sbox.Left - gbox.Left);
 507         mousey = msg->gpht_Mouse.Y - (sbox.Top  - gbox.Top);
 508
 509         if ((mousex >= 0) && (mousey >= 0) &&
 510             (mousex < sbox.Width) && (mousey < sbox.Height)) retval = GMR_GADGETHIT;
 511     }
 512
 513     ReturnInt("GradientSlider::HitTest", IPTR, retval);
 514 }
 515
 516 /***************************************************************************************************/
 517
 518 IPTR GradientSlider__GM_GOACTIVE(Class *cl, Object *o, struct gpInput *msg)
 519 {
 520     struct GradientSliderData   *data = INST_DATA(cl, o);
 521     struct IBox                 gbox, sbox, kbox;
 522     WORD                        mousex, mousey;
 523     ULONG                       old_curval = data->curval;
 524     ULONG                       new_curval;
 525     BOOL                        knobhit = TRUE;
 526     IPTR                        retval = 0UL;
 527
 528     EnterFunc(bug("GradientSlider::GoActive()\n"));
 529
 530     if (!msg->gpi_IEvent) return GMR_NOREUSE;
 531
 532     GetGadgetIBox(o, msg->gpi_GInfo, &gbox);
 533     GetSliderBox(&gbox, &sbox);
 534     GetKnobBox(data, &sbox, &kbox);
 535
 536     mousex = msg->gpi_Mouse.X + gbox.Left;
 537     mousey = msg->gpi_Mouse.Y + gbox.Top;
 538
 539     data->x = msg->gpi_Mouse.X;
 540     data->y = msg->gpi_Mouse.Y;
 541
 542     data->clickoffsetx = mousex - kbox.Left + (sbox.Left - gbox.Left);
 543     data->clickoffsety = mousey - kbox.Top  + (sbox.Top - gbox.Top);
 544
 545     if ( ((data->freedom == LORIENT_HORIZ) && (mousex < kbox.Left)) ||
 546          ((data->freedom == LORIENT_VERT)  && (mousey < kbox.Top)) )
 547     {
 548         new_curval = old_curval - data->skipval;
 549         if ((LONG)new_curval < 0) new_curval = 0;
 550         knobhit = FALSE;
 551     }
 552     else if ( ((data->freedom == LORIENT_HORIZ) && (mousex >= kbox.Left + kbox.Width)) ||
 553               ((data->freedom == LORIENT_VERT)  && (mousey >= kbox.Top + kbox.Height)) )
 554
 555     {
 556         new_curval = old_curval + data->skipval;
 557         if (new_curval > data->maxval) new_curval = (LONG)data->maxval;
 558         knobhit = FALSE;
 559     }
 560
 561     data->saveval = data->curval;
 562
 563     if (!knobhit)
 564     {
 565         struct RastPort *rp;
 566
 567         data->curval = new_curval;
 568
 569         GetKnobBox(data, &sbox, &kbox);
 570
 571         notify_curval(cl, o, msg->gpi_GInfo, FALSE, TRUE);
 572
 573         if ((rp = ObtainGIRPort(msg->gpi_GInfo)))
 574         {
 575             DoMethod(o, GM_RENDER, (IPTR)msg->gpi_GInfo, (IPTR)rp, GREDRAW_UPDATE );
 576             ReleaseGIRPort( rp );
 577         }
 578    /*
 579         if( mousex >= kbox.Left &&
 580             mousey >= kbox.Top &&
 581             mousex < (kbox.Left+kbox.Width) &&
 582             mousey < (kbox.Top+kbox.Height) )
 583         {
 584             data->clickoffsetx = mousex - kbox.Left + (sbox.Left - gbox.Left);
 585             data->clickoffsety = mousey - kbox.Top  + (sbox.Top - gbox.Top);
 586             return GMR_MEACTIVE;
 587         }
 588    */
 589
 590         retval = GMR_VERIFY | GMR_NOREUSE;
 591         /* original AmigaOS gradientslider.gadget does not seem to place any meaningful
 592            value into gpi_Termination :-\ */
 593         *msg->gpi_Termination = data->curval;
 594
 595     } else {
 596         retval = GMR_MEACTIVE;
 597     }
 598
 599     ReturnInt("GradientSlider::GoActive", IPTR, retval);
 600 }
 601
 602 /***************************************************************************************************/
 603
 604 IPTR GradientSlider__GM_HANDLEINPUT(Class *cl, Object *o, struct gpInput *msg)
 605 {
 606     struct GradientSliderData   *data = INST_DATA(cl, o);
 607     struct IBox                 gbox, sbox, kbox;
 608     struct InputEvent           *ie = msg->gpi_IEvent;
 609     LONG                        new_curval;                     /* use LONG instead of ULONG for easier checks against < 0 */
 610     WORD                        mousex, mousey;
 611     IPTR                        retval = GMR_MEACTIVE;
 612
 613     //EnterFunc(bug("GradientSlider::HandleInput\n"));
 614
 615     GetGadgetIBox(o, msg->gpi_GInfo, &gbox);
 616     GetSliderBox(&gbox, &sbox);
 617     GetKnobBox(data, &sbox, &kbox);
 618
 619     switch(ie->ie_Class)
 620     {
 621         case IECLASS_RAWMOUSE:
 622             switch(ie->ie_Code)
 623             {
 624                 case SELECTUP:
 625                     retval = GMR_VERIFY | GMR_NOREUSE;
 626                     /* original AmigaOS gradientslider.gadget does not seem to place any meaningful
 627                        value into gpi_Termination :-\ */
 628                     *msg->gpi_Termination = data->curval;
 629
 630                     notify_curval(cl, o, msg->gpi_GInfo, FALSE, TRUE);
 631
 632                     break; /* SELECTUP */
 633
 634                 case IECODE_NOBUTTON:
 635                     if( data->x == msg->gpi_Mouse.X && data->y == msg->gpi_Mouse.Y )
 636                         break;
 637
 638                     data->x = msg->gpi_Mouse.X;
 639                     data->y = msg->gpi_Mouse.Y;
 640
 641                     mousex = msg->gpi_Mouse.X - data->clickoffsetx;
 642                     mousey = msg->gpi_Mouse.Y - data->clickoffsety;
 643
 644                     if (data->freedom == LORIENT_HORIZ)
 645                     {
 646                         if (sbox.Width != data->knobpixels) /* avoid div by 0 */
 647                         {
 648                             new_curval = mousex * ((LONG)data->maxval) / (sbox.Width - (LONG)data->knobpixels);
 649                         }
 650                     } else {
 651                         if (sbox.Height != data->knobpixels) /* avoid div by 0 */
 652                         {
 653                             new_curval = mousey * ((LONG)data->maxval) / (sbox.Height - (LONG)data->knobpixels);
 654                         }
 655                     }
 656
 657                     if (new_curval < 0)
 658                     {
 659                         new_curval = 0;
 660                     }
 661                     else if (new_curval > data->maxval)
 662                     {
 663                         new_curval = (LONG)data->maxval;
 664                     }
 665
 666                     if ((ULONG)new_curval != data->curval)
 667                     {
 668                         struct RastPort *rp;
 669
 670                         data->curval = (ULONG)new_curval;
 671
 672                         if ((rp = ObtainGIRPort(msg->gpi_GInfo)))
 673                         {
 674                             DoMethod(o, GM_RENDER, (IPTR)msg->gpi_GInfo, (IPTR)rp, GREDRAW_UPDATE);
 675                             ReleaseGIRPort(rp);
 676                         }
 677
 678                         notify_curval(cl, o, msg->gpi_GInfo, TRUE, TRUE);
 679                     }
 680                     break; /* IECODE_NOBUTTON */
 681
 682             } /* switch(ie->ie_Code) */
 683
 684             break; /* IECLASS_RAWMOUSE */
 685
 686     } /* switch(ie->ie_Class) */
 687
 688     ReturnInt("GradientSlider::HandleInput", IPTR, retval);
 689 }
 690
 691 /***************************************************************************************************/
 692
 693 IPTR GradientSlider__GM_DOMAIN(Class *cl, Object *o, struct gpDomain *msg)
 694 {
 695     struct GradientSliderData *data = INST_DATA(cl, o);
 696     struct DrawInfo           *dri = (struct DrawInfo *) GetTagData( GA_DrawInfo, 0, msg->gpd_Attrs );
 697     struct RastPort           *rp = msg->gpd_RPort;
 698     UWORD                      width, height, x=1,y=1;
 699
 700     if( dri )
 701     {
 702         y = dri->dri_Resolution.X;
 703         x = dri->dri_Resolution.Y;
 704     }
 705
 706     switch( msg->gpd_Which )
 707     {
 708         case GDOMAIN_MINIMUM:
 709            if( data->freedom == LORIENT_VERT )
 710            {
 711                 width  = 3 + ( ( rp->TxHeight * x ) / y ) + 3;
 712                 height = 2 + (data->knobpixels*5) + 2;
 713            }
 714            else
 715            {
 716                 width = 3 + (data->knobpixels*5) + 3;
 717                 height = 2 + rp->TxHeight + 2;
 718            }
 719         break;
 720
 721         case GDOMAIN_NOMINAL:
 722            if( data->freedom == LORIENT_VERT )
 723            {
 724                 width = 3 + ( ( rp->TxHeight * x ) / y ) + 3;
 725                 height = 2 + (10*data->knobpixels) + 2;
 726            }
 727            else
 728            {
 729                 width = 3 + (10*data->knobpixels) + 3;
 730                 height = 2 + rp->TxHeight + 2;
 731            }
 732         break;
 733
 734         case GDOMAIN_MAXIMUM:
 735            if( data->freedom == LORIENT_VERT )
 736            {
 737                 width = 3 + ( ( rp->TxHeight * x ) / y ) + 3;
 738                 height = 0x7fff;
 739            }
 740            else
 741            {
 742                 width = 0x7fff;
 743                 height = 2 + rp->TxHeight + 2;
 744            }
 745         break;
 746     }
 747
 748     msg->gpd_Domain.Left        =
 749     msg->gpd_Domain.Top         = 0;
 750     msg->gpd_Domain.Width       = width;
 751     msg->gpd_Domain.Height      = height;
 752
 753     return 1L;
 754 }
 755
 756 /***************************************************************************************************/