rom/intuition/propgadgets.c

   1 /*
   2     Copyright  1995-2003, The AROS Development Team. All rights reserved.
   3     Copyright  2001-2003, The MorphOS Development Team. All Rights Reserved.
   4     $Id$
   5 */
   6
   7 #include <proto/graphics.h>
   8 #include <proto/intuition.h>
   9 #include <proto/cybergraphics.h>
  10 #include <proto/layers.h>
  11 #include <proto/utility.h>
  12 #include <graphics/gfxmacros.h>
  13 #include <intuition/cghooks.h>
  14 #include <intuition/intuition.h>
  15 #include <intuition/imageclass.h>
  16 #include <intuition/windecorclass.h>
  17 #include <cybergraphx/cybergraphics.h>
  18 #include <graphics/rpattr.h>
  19 #include "intuition_intern.h"
  20 #include "propgadgets.h"
  21 #ifdef SKINS
  22 #include "intuition_customize.h"
  23 #include "intuition_customizesupport.h"
  24 #include "morphos/proprender.h"
  25 #endif
  26 #include "gadgets.h"
  27
  28 extern IPTR HookEntry();
  29
  30 #undef DEBUG
  31 #define DEBUG 0
  32 #   include <aros/debug.h>
  33
  34 // static data moved to intuibase - Piru
  35 //static WORD clickoffset_x, clickoffset_y;
  36 #define clickoffset_x GetPrivIBase(IntuitionBase)->prop_clickoffset_x
  37 #define clickoffset_y GetPrivIBase(IntuitionBase)->prop_clickoffset_y
  38
  39 BOOL isonborder(struct Gadget *gadget,struct Window *window);
  40
  41 static void RenderPropBackground(struct Gadget *gad, struct Window *win, struct DrawInfo *dri,
  42                                  struct Rectangle *rect, struct Rectangle *proprect,
  43                                  struct Rectangle *knobrect, struct PropInfo *pi,
  44                                  struct RastPort *rp, BOOL onborder,
  45                                  struct IntuitionBase *IntuitionBase)
  46 {
  47     if (onborder)
  48     {
  49         struct wdpDrawBorderPropBack msg;
  50
  51         msg.MethodID        = WDM_DRAW_BORDERPROPBACK;
  52
  53         msg.wdp_Window      = win;
  54     msg.wdp_TrueColor   = (((struct IntScreen *)win->WScreen)->DInfo.dri.dri_Flags & DRIF_DIRECTCOLOR);
  55     msg.wdp_UserBuffer  = ((struct IntWindow *)win)->DecorUserBuffer;
  56
  57         msg.wdp_RPort       = rp;
  58         msg.wdp_Gadget      = gad;
  59         msg.wdp_RenderRect  = rect;
  60         msg.wdp_PropRect    = proprect;
  61         msg.wdp_KnobRect    = knobrect;
  62         msg.wdp_Flags       = 0;
  63         msg.wdp_Dri         = dri;
  64
  65         DoMethodA(((struct IntScreen *)(win->WScreen))->WinDecorObj, (Msg)&msg);
  66     }
  67     else
  68     {
  69         static UWORD     pattern[] = {0x5555,0xAAAA};
  70         struct Hook *dhook = NULL;
  71
  72         if ((gad->Flags & GFLG_EXTENDED) != 0)
  73         {
  74             if ((((struct ExtGadget *) gad)->MoreFlags & GMORE_BOOPSIGADGET) != 0)
  75             {
  76                 GetAttr(PGA_DisplayHook, (Object *) gad, (IPTR *)&dhook);
  77             }
  78         }
  79         if (dhook) {
  80
  81             struct wdpDrawBorderPropBack msg;
  82
  83             msg.MethodID            = WDM_DRAW_BORDERPROPBACK;
  84
  85             msg.wdp_Window      = win;
  86             msg.wdp_TrueColor   = (((struct IntScreen *)win->WScreen)->DInfo.dri.dri_Flags & DRIF_DIRECTCOLOR);
  87             msg.wdp_RPort           = rp;
  88             msg.wdp_Gadget      = gad;
  89             msg.wdp_RenderRect  = rect;
  90             msg.wdp_PropRect    = proprect;
  91             msg.wdp_KnobRect    = knobrect;
  92             msg.wdp_Flags           = 0;
  93             msg.wdp_Dri         = dri;
  94
  95             CallHookPkt(dhook, (Object *) gad, (Msg)&msg);
  96         }
  97         else
  98         {
  99             SetDrMd(rp, JAM2);
 100
 101             if (pi->Flags & PROPNEWLOOK)
 102             {
 103                 SetAfPt(rp, pattern, 1);
 104                 SetAPen(rp, dri->dri_Pens[SHADOWPEN]);
 105                 SetBPen(rp, dri->dri_Pens[BACKGROUNDPEN]);
 106
 107                 RectFill(rp, rect->MinX, rect->MinY, rect->MaxX, rect->MaxY);
 108                 SetAfPt(rp, NULL, 0);
 109             }
 110             else
 111             {
 112                 SetAPen(rp, dri->dri_Pens[BACKGROUNDPEN]);
 113                 RectFill(rp, rect->MinX, rect->MinY, rect->MaxX, rect->MaxY);
 114             }
 115         }
 116     }
 117 }
 118
 119
 120 VOID HandlePropSelectDown(struct Gadget *gadget, struct Window *w, struct Requester *req,
 121                           UWORD mouse_x, UWORD mouse_y, struct IntuitionBase *IntuitionBase)
 122 {
 123     struct BBox          knob;
 124     struct PropInfo     *pi;
 125     UWORD                dx, dy, flags;
 126
 127     pi = (struct PropInfo *)gadget->SpecialInfo;
 128
 129     if (!pi)
 130         return;
 131
 132     CalcBBox (w, req, gadget, &knob);
 133
 134     /* This func gets mouse coords relative to gadget box */
 135
 136     mouse_x += knob.Left;
 137     mouse_y += knob.Top;
 138
 139     if (!CalcKnobSize (gadget, &knob))
 140         return;
 141
 142     clickoffset_x = mouse_x - knob.Left;
 143     clickoffset_y = mouse_y - knob.Top;
 144
 145     dx = pi->HorizPot;
 146     dy = pi->VertPot;
 147
 148     if (pi->Flags & FREEHORIZ)
 149     {
 150         if (mouse_x < knob.Left)
 151         {
 152             if (dx > pi->HPotRes)
 153                 dx -= pi->HPotRes;
 154             else
 155                 dx = 0;
 156         }
 157         else if (mouse_x >= knob.Left + knob.Width)
 158         {
 159             if (dx < MAXPOT - pi->HPotRes)
 160                 dx += pi->HPotRes;
 161             else
 162                 dx = MAXPOT;
 163         }
 164     }
 165
 166     if (pi->Flags & FREEVERT)
 167     {
 168         if (mouse_y < knob.Top)
 169         {
 170             if (dy > pi->VPotRes)
 171                 dy -= pi->VPotRes;
 172             else
 173                 dy = 0;
 174         }
 175         else if (mouse_y >= knob.Top + knob.Height)
 176         {
 177             if (dy < MAXPOT - pi->VPotRes)
 178                 dy += pi->VPotRes;
 179             else
 180                 dy = MAXPOT;
 181         }
 182     }
 183
 184     flags = pi->Flags;
 185
 186     /* jDc: when clicked on frame, prop gadget also gets activated! */
 187     if (!(flags & PROPBORDERLESS))
 188     {
 189         if (pi->Flags & FREEVERT)
 190         {
 191             knob.Left --;
 192             knob.Width += 2;
 193         } else {
 194             knob.Top ++;
 195             knob.Height += 2;
 196         }
 197     }
 198
 199     if (mouse_x >= knob.Left &&
 200         mouse_y >= knob.Top &&
 201         mouse_x < knob.Left + knob.Width &&
 202         mouse_y < knob.Top + knob.Height)
 203     {
 204         flags |= KNOBHIT;
 205     }
 206     else
 207     {
 208         flags &= ~KNOBHIT;
 209     }
 210
 211     gadget->Flags |= GFLG_SELECTED;
 212
 213     D(bug("New HPot: %d, new VPot: %d\n", dx, dy));
 214
 215     NewModifyProp(gadget, w, req, flags, dx, dy, pi->HorizBody, pi->VertBody, 1);
 216
 217     return;
 218 }
 219
 220 VOID HandlePropSelectUp(struct Gadget *gadget, struct Window *w,
 221                         struct Requester *req, struct IntuitionBase *IntuitionBase)
 222 {
 223     struct PropInfo * pi;
 224
 225     pi = (struct PropInfo *)gadget->SpecialInfo;
 226
 227     gadget->Flags &= ~GFLG_SELECTED;
 228     if (pi) pi->Flags &= ~KNOBHIT;
 229
 230     if (pi) RefreshPropGadget (gadget, w, req, IntuitionBase);
 231
 232 /*    if (pi)
 233         NewModifyProp (gadget
 234                        , w
 235                        , req
 236                        , pi->Flags &= ~KNOBHIT
 237                        , pi->HorizPot
 238                        , pi->VertPot
 239                        , pi->HorizBody
 240                        , pi->VertBody
 241                        , 1
 242                       ); */
 243
 244     return;
 245 }
 246
 247 VOID HandlePropMouseMove(struct Gadget *gadget, struct Window *w,struct Requester *req,
 248                          LONG dx, LONG dy, struct IntuitionBase *IntuitionBase)
 249 {
 250     struct BBox      knob;
 251     struct PropInfo *pi;
 252
 253     pi = (struct PropInfo *)gadget->SpecialInfo;
 254
 255     /* Has propinfo and the mouse was over the knob */
 256     if (pi && (pi->Flags & KNOBHIT))
 257     {
 258         CalcBBox (w, req, gadget, &knob);
 259
 260         if (!CalcKnobSize (gadget, &knob))
 261             return;
 262
 263         /* Move the knob the same amount, ie.
 264         knob.Left += dx; knob.Top += dy;
 265
 266         knob.Left = knob.Left
 267         + (pi->CWidth - knob.Width)
 268         * pi->HorizPot / MAXPOT;
 269
 270         ie. dx = (pi->CWidth - knob.Width)
 271         * pi->HorizPot / MAXPOT;
 272
 273         or
 274
 275         pi->HorizPot = (dx * MAXPOT) /
 276         (pi->CWidth - knob.Width);
 277         */
 278
 279         /* stegerg: dx and dy are not delta values
 280                 anymore but relative to gadget
 281                 box */
 282
 283         dx = dx - clickoffset_x;
 284         dy = dy - clickoffset_y;
 285
 286         if (pi->Flags & FREEHORIZ
 287                 && pi->CWidth != knob.Width)
 288         {
 289
 290             dx = (dx * MAXPOT) / (pi->CWidth - knob.Width);
 291             if (dx < 0)
 292             {
 293                 dx = 0;
 294             }
 295             else if (dx > MAXPOT)
 296             {
 297                 dx = MAXPOT;
 298             }
 299
 300         } /* FREEHORIZ */
 301
 302         if (pi->Flags & FREEVERT
 303                 && pi->CHeight != knob.Height)
 304         {
 305             dy = (dy * MAXPOT) / (pi->CHeight - knob.Height);
 306
 307             if (dy < 0)
 308             {
 309                 dy = 0;
 310             }
 311             else if (dy > MAXPOT)
 312             {
 313                 dy = MAXPOT;
 314             }
 315
 316         } /* FREEVERT */
 317
 318         if ( ((pi->Flags & FREEHORIZ) && (dx != pi->HorizPot)) ||
 319                 ((pi->Flags & FREEVERT)  && (dy != pi->VertPot)) )
 320
 321         {
 322             NewModifyProp (gadget, w, req, pi->Flags, dx, dy, pi->HorizBody, pi->VertBody, 1);
 323         }
 324
 325     } /* Has PropInfo and Mouse is over knob */
 326
 327     return;
 328 }
 329
 330 int CalcKnobSize (struct Gadget * propGadget, struct BBox * knobbox)
 331 {
 332     struct PropInfo *pi;
 333     WORD             x, y;
 334
 335     pi = (struct PropInfo *)propGadget->SpecialInfo;
 336
 337     //dprintf("CalcKnobSize(%lx,%d,%d,%d,%d)\n", propGadget,
 338     //      propGadget->LeftEdge, propGadget->TopEdge, propGadget->Width, propGadget->Height);
 339     //dprintf("knob(%d,%d,%d,%d)\n", knobbox->Left, knobbox->Top, knobbox->Width, knobbox->Height);
 340
 341     if (pi->Flags & PROPBORDERLESS)
 342     {
 343         pi->LeftBorder = 0;
 344         pi->TopBorder  = 0;
 345     }
 346     else
 347     {
 348         x = y = 1;
 349
 350         knobbox->Left += x;
 351         knobbox->Top += y;
 352         knobbox->Width -= x * 2;
 353         knobbox->Height -= y * 2;
 354         pi->LeftBorder = x;
 355         pi->TopBorder  = y;
 356     }
 357     //dprintf("knob(%d,%d,%d,%d)\n", knobbox->Left, knobbox->Top, knobbox->Width, knobbox->Height);
 358
 359     pi->CWidth     = knobbox->Width;
 360     pi->CHeight    = knobbox->Height;
 361
 362     if ((!(pi->Flags & AUTOKNOB)) && propGadget->GadgetRender)
 363     {
 364         struct Image *im = propGadget->GadgetRender;
 365
 366         knobbox->Width = im->Width;
 367         knobbox->Height = im->Height;
 368     }
 369
 370     if (pi->Flags & FREEHORIZ)
 371     {
 372         if (pi->Flags & AUTOKNOB)
 373         {
 374             knobbox->Width = pi->CWidth * pi->HorizBody / MAXBODY;
 375             if (knobbox->Width < KNOBHMIN) knobbox->Width = KNOBHMIN;
 376         }
 377
 378         knobbox->Left = knobbox->Left + (pi->CWidth - knobbox->Width)
 379                         * pi->HorizPot / MAXPOT;
 380
 381         if (pi->HorizBody)
 382         {
 383             if (pi->HorizBody < MAXBODY/2)
 384                 pi->HPotRes = MAXPOT * 32768 / ((MAXBODY * 32768 / pi->HorizBody) - 32768);
 385             else
 386                 pi->HPotRes = MAXPOT;
 387         }
 388         else
 389             pi->HPotRes = 1;
 390     }
 391
 392     if (pi->Flags & FREEVERT)
 393     {
 394         if (pi->Flags & AUTOKNOB)
 395         {
 396             knobbox->Height = pi->CHeight * pi->VertBody / MAXBODY;
 397             if (knobbox->Height < KNOBVMIN) knobbox->Height = KNOBVMIN;
 398         }
 399
 400         knobbox->Top = knobbox->Top + (pi->CHeight - knobbox->Height)
 401                        * pi->VertPot / MAXPOT;
 402
 403         if (pi->VertBody)
 404         {
 405             if (pi->VertBody < MAXBODY/2)
 406                 pi->VPotRes = MAXPOT * 32768 / ((MAXBODY * 32768 / pi->VertBody) - 32768);
 407             else
 408                 pi->VPotRes = MAXPOT;
 409         }
 410         else
 411             pi->VPotRes = 1;
 412     }
 413     //dprintf("knob(%d,%d,%d,%d)\n", knobbox->Left, knobbox->Top, knobbox->Width, knobbox->Height);
 414
 415     return TRUE;
 416 } /* CalcKnobSize */
 417
 418
 419 void RefreshPropGadget (struct Gadget * gadget, struct Window * window,
 420                         struct Requester * req, struct IntuitionBase * IntuitionBase)
 421 {
 422     struct PropInfo     *pi;
 423     struct DrawInfo     *dri;
 424     struct GadgetInfo    gi;
 425     struct RastPort     *rp = 0;
 426     struct BBox          bbox, kbox;
 427     BOOL                 onborder;
 428
 429     D(bug("RefreshPropGadget(gad=%p, win=%s, req=%p)\n", gadget, window->Title, req));
 430
 431     onborder = (IS_BORDER_GADGET(gadget) || isonborder(gadget,window));
 432
 433     if ((dri = GetScreenDrawInfo(window->WScreen)))
 434     {
 435
 436         SetupGInfo(&gi, window, req, gadget, IntuitionBase);
 437
 438         if ((rp = ObtainGIRPort(&gi)))
 439         {
 440             for (;;)
 441             {
 442                 CalcBBox (window, req, gadget, &bbox);
 443                 kbox = bbox;
 444
 445                 if (bbox.Width <= 0 || bbox.Height <= 0)
 446                     break;
 447
 448                 if (CalcKnobSize (gadget, &kbox))
 449                 {
 450                     pi = (struct PropInfo *)gadget->SpecialInfo;
 451
 452                     if (!pi)
 453                         break;
 454
 455                     SetDrMd (rp, JAM2);
 456
 457                     if (!(pi->Flags & PROPBORDERLESS))
 458                     {
 459                         SetAPen(rp,dri->dri_Pens[SHADOWPEN]);
 460                         drawrect(rp,bbox.Left,
 461                                  bbox.Top,
 462                                  bbox.Left + bbox.Width - 1,
 463                                  bbox.Top + bbox.Height - 1,
 464                                  IntuitionBase);
 465
 466                         bbox.Left ++; bbox.Top ++;
 467                         bbox.Width -= 2; bbox.Height -= 2;
 468                     }
 469
 470                     RefreshPropGadgetKnob (gadget, &bbox, &kbox, window, req, IntuitionBase);
 471                 }
 472                 else
 473                 {
 474
 475                     pi = (struct PropInfo *)gadget->SpecialInfo;
 476
 477                     if (!pi)
 478                         break;
 479
 480                     SetDrMd (rp, JAM2);
 481
 482                     if (!(pi->Flags & PROPBORDERLESS))
 483                     {
 484                         SetAPen(rp,dri->dri_Pens[SHADOWPEN]);
 485                         drawrect(rp,bbox.Left,
 486                                  bbox.Top,
 487                                  bbox.Left + bbox.Width - 1,
 488                                  bbox.Top + bbox.Height - 1,
 489                                  IntuitionBase);
 490
 491                         bbox.Left ++; bbox.Top ++;
 492                         bbox.Width -= 2; bbox.Height -= 2;
 493
 494                     }
 495
 496                     {
 497                         struct Rectangle tmprect;
 498
 499                         tmprect.MinX = bbox.Left;
 500                         tmprect.MaxX = bbox.Left + bbox.Width - 1;
 501                         tmprect.MinY = bbox.Top;
 502                         tmprect.MaxY = bbox.Top + bbox.Height - 1;
 503
 504                         RenderPropBackground(gadget, window, dri, &tmprect, &tmprect, NULL,
 505                                              pi, rp, onborder, IntuitionBase);
 506                     }
 507                 } // if (CalcKnob
 508                 break;
 509             }
 510
 511         } /* if ((rp = ObtainGIRPort(&gi))) */
 512
 513         if (rp && gadget->Flags & GFLG_DISABLED)
 514         {
 515             CalcBBox (window, req, gadget, &bbox);
 516
 517             RenderDisabledPattern(rp, (struct DrawInfo *)dri, bbox.Left,
 518                                   bbox.Top,
 519                                   bbox.Left + bbox.Width - 1,
 520                                   bbox.Top + bbox.Height - 1,
 521                                   IntuitionBase);
 522         }
 523
 524         if (rp) ReleaseGIRPort(rp);
 525
 526         FreeScreenDrawInfo(window->WScreen, (struct DrawInfo *)dri);
 527
 528     } /* if ((dri = GetScreenDrawInfo(window->WScreen))) */
 529
 530     ReturnVoid("RefreshPropGadget");
 531 } /* RefreshPropGadget */
 532
 533
 534 void RefreshPropGadgetKnob (struct Gadget * gadget, struct BBox * clear,
 535                             struct BBox * knob, struct Window * window, struct Requester * req,
 536                             struct IntuitionBase * IntuitionBase)
 537 {
 538     struct DrawInfo     *dri;
 539     struct RastPort     *rp;
 540     struct PropInfo     *pi;
 541     struct GadgetInfo    gi;
 542     UWORD                flags;
 543     BOOL                 onborder;
 544
 545     D(bug("RefresPropGadgetKnob(flags=%d, clear=%p, knob = %p, win=%s)\n",
 546           flags, clear, knob, window->Title));
 547
 548     if ((knob->Width < 1) || (knob->Height < 1)) return;
 549
 550     onborder = (IS_BORDER_GADGET(gadget) || isonborder(gadget,window));
 551
 552     pi = (struct PropInfo *)gadget->SpecialInfo;
 553     flags = pi->Flags;
 554
 555     if ((dri = GetScreenDrawInfo(window->WScreen)))
 556     {
 557         SetupGInfo(&gi, window, req, gadget, IntuitionBase);
 558
 559         if ((rp = ObtainGIRPort(&gi)))
 560         {
 561             struct BBox      bbox;
 562             struct Rectangle brect;
 563             struct Rectangle krect;
 564
 565             CalcBBox (window, req, gadget, &bbox);
 566
 567             if ((bbox.Width < 1) || (bbox.Height < 1))
 568             {
 569                 ReleaseGIRPort(rp);
 570                 FreeScreenDrawInfo(window->WScreen, (struct DrawInfo *)dri);
 571
 572                 return;
 573             }
 574
 575             brect.MinX = bbox.Left;
 576             brect.MinY = bbox.Top;
 577             brect.MaxX = bbox.Left + bbox.Width - 1;
 578             brect.MaxY = bbox.Top + bbox.Height - 1;
 579
 580             krect.MinX = knob->Left;
 581             krect.MinY = knob->Top;
 582             krect.MaxX = knob->Left + knob->Width - 1;
 583             krect.MaxY = knob->Top + knob->Height - 1;
 584
 585             SetDrMd (rp, JAM2);
 586
 587             if (clear)
 588             {
 589                 struct Rectangle a, b, clearrects[4];
 590                 WORD             i, nrects;
 591
 592             #if (!(PROP_RENDER_OPTIMIZATION))
 593                 if (!(flags & PROPBORDERLESS))
 594                 {
 595                     clear->Left ++; clear->Top ++;
 596                     clear->Width -= 2; clear->Height -= 2;
 597                 }
 598             #endif
 599
 600             #if 0
 601                 D(bug("RefresPropGadgetKnob: clear Left %d Top %d Width %d Height %d\n",
 602                       clear->Left,
 603                       clear->Top,
 604                       clear->Width,
 605                       clear->Height));
 606
 607                 D(bug("RefresPropGadgetKnob: knob Left %d Top %d Width %d Height %d\n",
 608                       knob->Left,
 609                       knob->Top,
 610                       knob->Width,
 611                       knob->Height));
 612             #endif
 613
 614                 a.MinX = clear->Left;
 615                 a.MinY = clear->Top;
 616                 a.MaxX = clear->Left + clear->Width - 1;
 617                 a.MaxY = clear->Top + clear->Height - 1;
 618
 619                 b.MinX = knob->Left;
 620                 b.MinY = knob->Top;
 621                 b.MaxX = knob->Left + knob->Width - 1;
 622                 b.MaxY = knob->Top + knob->Height - 1;
 623
 624             #if 0
 625                 D(bug("RefresPropGadgetKnob: a MinX %d MinY %d MaxX %d MaxY %d\n",
 626                       a.MinX,
 627                       a.MinY,
 628                       a.MaxX,
 629                       a.MaxY));
 630
 631                 D(bug("RefresPropGadgetKnob: a MinX %d MinY %d MaxX %d MaxY %d\n",
 632                       b.MinX,
 633                       b.MinY,
 634                       b.MaxX,
 635                       b.MaxY));
 636             #endif
 637
 638                 nrects = SubtractRectFromRect(&a, &b, clearrects);
 639
 640                 D(bug("RefresPropGadgetKnob: nrects %d\n",
 641                       nrects));
 642             #if 0
 643                 D(bug("RefresPropGadgetKnob: clearrects[0] MinX %d MinY %d MaxX %d MaxY %d\n",
 644                       clearrects[0].MinX,
 645                       clearrects[0].MinY,
 646                       clearrects[0].MaxX,
 647                       clearrects[0].MaxY));
 648
 649                 D(bug("RefresPropGadgetKnob: clearrects[1] MinX %d MinY %d MaxX %d MaxY %d\n",
 650                       clearrects[1].MinX,
 651                       clearrects[1].MinY,
 652                       clearrects[1].MaxX,
 653                       clearrects[1].MaxY));
 654
 655                 D(bug("RefresPropGadgetKnob: clearrects[2] MinX %d MinY %d MaxX %d MaxY %d\n",
 656                       clearrects[2].MinX,
 657                       clearrects[2].MinY,
 658                       clearrects[2].MaxX,
 659                       clearrects[2].MaxY));
 660
 661                 D(bug("RefresPropGadgetKnob: clearrects[3] MinX %d MinY %d MaxX %d MaxY %d\n",
 662                       clearrects[3].MinX,
 663                       clearrects[3].MinY,
 664                       clearrects[3].MaxX,
 665                       clearrects[3].MaxY));
 666             #endif
 667
 668                 /*kprintf("\n=== oldknob = %d,%d-%d,%d   newknob = %d,%d-%d,%d\n",
 669                     a.MinX,
 670                     a.MinY,
 671                     a.MaxX,
 672                     a.MaxY,
 673                     b.MinX,
 674                     b.MinY,
 675                     b.MaxX,
 676                     b.MaxY);*/
 677
 678                 for(i = 0; i < nrects; i++)
 679                 {
 680                     RenderPropBackground(gadget, window, dri, &clearrects[i], &brect, &krect,
 681                                          pi, rp, onborder, IntuitionBase);
 682                 }
 683
 684             } /* if (clear) */
 685
 686             if (flags & AUTOKNOB)
 687             {
 688                 int hit = ((flags & KNOBHIT) != 0);
 689
 690                 D(bug("RefresPropGadgetKnob: draw knob Left %d Top %d Width %d Height %d\n",
 691                       knob->Left,
 692                       knob->Top,
 693                       knob->Width,
 694                       knob->Height));
 695
 696                 if (onborder)
 697                 {
 698                     struct wdpDrawBorderPropKnob msg;
 699                     struct Rectangle             knobrect;
 700                     knobrect.MinX = knob->Left;
 701                     knobrect.MinY = knob->Top;
 702                     knobrect.MaxX = knob->Left + knob->Width - 1;
 703                     knobrect.MaxY = knob->Top + knob->Height - 1;
 704
 705                     msg.MethodID        = WDM_DRAW_BORDERPROPKNOB;
 706                     msg.wdp_TrueColor   = (((struct IntScreen *)window->WScreen)->DInfo.dri.dri_Flags & DRIF_DIRECTCOLOR);
 707                     msg.wdp_UserBuffer  = ((struct IntWindow *)window)->DecorUserBuffer;
 708                     msg.wdp_Window      = window;
 709                     msg.wdp_RPort       = rp;
 710                     msg.wdp_Gadget      = gadget;
 711                     msg.wdp_RenderRect  = &knobrect;
 712                     msg.wdp_PropRect    = &brect;
 713                     msg.wdp_Flags       = hit ? WDF_DBPK_HIT : 0;
 714                     msg.wdp_Dri         = dri;
 715
 716                     DoMethodA(((struct IntScreen *)(window->WScreen))->WinDecorObj, (Msg)&msg);
 717
 718                 } /* gadget inside window border */
 719                 else
 720                 {
 721                     struct Hook *dhook = NULL;
 722
 723                     if ((gadget->Flags & GFLG_EXTENDED) != 0)
 724                     {
 725                         if ((((struct ExtGadget *) gadget)->MoreFlags & GMORE_BOOPSIGADGET) != 0)
 726                         {
 727                             GetAttr(PGA_DisplayHook, (Object *) gadget, (IPTR *)&dhook);
 728                         }
 729                     }
 730                     if (dhook) {
 731                         struct wdpDrawBorderPropKnob msg;
 732                         struct Rectangle                 knobrect;
 733                         knobrect.MinX = knob->Left;
 734                         knobrect.MinY = knob->Top;
 735                         knobrect.MaxX = knob->Left + knob->Width - 1;
 736                         knobrect.MaxY = knob->Top + knob->Height - 1;
 737                         msg.MethodID            = WDM_DRAW_BORDERPROPKNOB;
 738                         msg.wdp_TrueColor   = (((struct IntScreen *)window->WScreen)->DInfo.dri.dri_Flags & DRIF_DIRECTCOLOR);
 739                         msg.wdp_Window          = window;
 740                         msg.wdp_RPort           = rp;
 741                         msg.wdp_Gadget          = gadget;
 742                         msg.wdp_RenderRect  = &knobrect;
 743                         msg.wdp_PropRect        = &brect;
 744                         msg.wdp_Flags           = hit ? WDF_DBPK_HIT : 0;
 745                         msg.wdp_Dri         = dri;
 746
 747                         CallHookPkt(dhook, (Object *) gadget, (Msg)&msg);
 748                     }
 749                     else
 750                     {
 751
 752                         BOOL stdlook = TRUE;
 753
 754                         #ifdef SKINS
 755                         stdlook = RenderPropKnob(window,dri,rp,pi,knob,hit,IntuitionBase);
 756                         #endif
 757
 758                         if (stdlook)
 759                         {
 760                             if (flags & PROPBORDERLESS)
 761                             {
 762                                 SetAPen(rp,dri->dri_Pens[SHADOWPEN]);
 763
 764                                 /* paint black right and bottom edges */
 765
 766                                 RectFill(rp,knob->Left + knob->Width - 1,
 767                                          knob->Top,
 768                                          knob->Left + knob->Width - 1,
 769                                          knob->Top + knob->Height - 1);
 770
 771                                 RectFill(rp,knob->Left,
 772                                          knob->Top + knob->Height - 1,
 773                                          knob->Left + knob->Width - 2,
 774                                          knob->Top + knob->Height - 1);
 775
 776                                 knob->Width--;
 777                                 knob->Height--;
 778
 779                             } /* propborderless */
 780                             else
 781                             {
 782                                 SetAPen(rp,dri->dri_Pens[SHADOWPEN]);
 783
 784                                 if (flags & FREEHORIZ)
 785                                 {
 786                                     /* black line at the left and at the right */
 787
 788                                     RectFill(rp,knob->Left,
 789                                              knob->Top,
 790                                              knob->Left,
 791                                              knob->Top + knob->Height - 1);
 792
 793                                     RectFill(rp,knob->Left + knob->Width - 1,
 794                                              knob->Top,
 795                                              knob->Left + knob->Width - 1,
 796                                              knob->Top + knob->Height - 1);
 797
 798                                     knob->Left++,
 799                                     knob->Width -= 2;
 800                                 }
 801                                 if (flags & FREEVERT)
 802                                 {
 803                                     /* black line at the top and at the bottom */
 804
 805                                     RectFill(rp,knob->Left,
 806                                              knob->Top,
 807                                              knob->Left + knob->Width - 1,
 808                                              knob->Top);
 809
 810                                     RectFill(rp,knob->Left,
 811                                              knob->Top + knob->Height - 1,
 812                                              knob->Left + knob->Width - 1,
 813                                              knob->Top + knob->Height - 1);
 814
 815                                     knob->Top++;
 816                                     knob->Height -= 2;
 817                                 }
 818
 819                             } /* not propborderless */
 820
 821
 822                             SetAPen(rp, dri->dri_Pens[SHINEPEN]);
 823
 824                             /* interior */
 825                             RectFill(rp,knob->Left,
 826                                      knob->Top,
 827                                      knob->Left + knob->Width - 1,
 828                                      knob->Top + knob->Height - 1);
 829                         } /* stdlook */
 830                     } /* gadget has no display (render) hook */
 831                 } /* gadget not inside window border */
 832
 833             } /* if (flags & AUTOKNOB) */
 834             else
 835             {
 836                 struct Image *image = (struct Image *)gadget->GadgetRender;
 837
 838             #if 0 /* CHECKME */
 839                 if (knob->Top + image->Height <= bbox.Top + bbox.Height &&
 840                     knob->Left + image->Width <= bbox.Left + bbox.Width)
 841             #endif
 842                 {
 843                 #if 1
 844                     image->LeftEdge = knob->Left - bbox.Left;
 845                     image->TopEdge = knob->Top - bbox.Top;
 846                     // image->Width = knob->Width;
 847                     // image->Height = knob->Height;
 848
 849                     DrawImageState(rp,
 850                                    image,
 851                                    bbox.Left,
 852                                    bbox.Top,
 853                                    IDS_NORMAL,
 854                                    (struct DrawInfo *)dri);
 855                 #else
 856                     image->LeftEdge = 0;
 857                     image->TopEdge = 0;
 858
 859                     DrawImageState(rp,
 860                                    image,
 861                                    knob->Left,
 862                                    knob->Top,
 863                                    IDS_NORMAL,
 864                                    (struct DrawInfo *)dri);
 865                 #endif
 866                 }
 867             }
 868
 869             if (gadget->Flags & GFLG_DISABLED)
 870             {
 871                 RenderDisabledPattern(rp, (struct DrawInfo *)dri,
 872                                       brect.MinX, brect.MinY,
 873                                       brect.MaxX, brect.MaxY, IntuitionBase);
 874             }
 875
 876             ReleaseGIRPort(rp);
 877
 878         } /* if ((rp = ObtainGIRPort(&gi))) */
 879
 880         FreeScreenDrawInfo(window->WScreen, (struct DrawInfo *)dri);
 881
 882     } /* if ((dri = GetScreenDrawInfo(window->WScreen))) */
 883
 884     ReturnVoid("RefreshPropGadgetKnob");
 885
 886 } /* RefreshPropGadgetKnob */
 887
 888 BOOL isonborder(struct Gadget *gadget, struct Window *window)
 889 {
 890     if ((window->BorderBottom > 2) && (gadget->Flags & GFLG_RELBOTTOM))
 891     if (window->Height + gadget->TopEdge >= window->Height - window->BorderBottom) return TRUE;
 892
 893     if ((window->BorderRight > 2) && (gadget->Flags & GFLG_RELRIGHT))
 894     if (window->Width + gadget->LeftEdge >= window->Width - window->BorderRight) return TRUE;
 895
 896     return FALSE;
 897 }