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, &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     onborder = (IS_BORDER_GADGET(gadget) || isonborder(gadget,window));
 549
 550     pi = (struct PropInfo *)gadget->SpecialInfo;
 551     flags = pi->Flags;
 552
 553     if ((dri = GetScreenDrawInfo(window->WScreen)))
 554     {
 555         SetupGInfo(&gi, window, req, gadget, IntuitionBase);
 556
 557         if ((rp = ObtainGIRPort(&gi)))
 558         {
 559             struct BBox      bbox;
 560             struct Rectangle brect;
 561             struct Rectangle krect;
 562
 563             CalcBBox (window, req, gadget, &bbox);
 564             brect.MinX = bbox.Left;
 565             brect.MinY = bbox.Top;
 566             brect.MaxX = bbox.Left + bbox.Width - 1;
 567             brect.MaxY = bbox.Top + bbox.Height - 1;
 568
 569             krect.MinX = knob->Left;
 570             krect.MinY = knob->Top;
 571             krect.MaxX = knob->Left + knob->Width - 1;
 572             krect.MaxY = knob->Top + knob->Height - 1;
 573
 574             SetDrMd (rp, JAM2);
 575
 576             if (clear)
 577             {
 578                 struct Rectangle a, b, clearrects[4];
 579                 WORD             i, nrects;
 580
 581             #if (!(PROP_RENDER_OPTIMIZATION))
 582                 if (!(flags & PROPBORDERLESS))
 583                 {
 584                     clear->Left ++; clear->Top ++;
 585                     clear->Width -= 2; clear->Height -= 2;
 586                 }
 587             #endif
 588
 589             #if 0
 590                 D(bug("RefresPropGadgetKnob: clear Left %d Top %d Width %d Height %d\n",
 591                       clear->Left,
 592                       clear->Top,
 593                       clear->Width,
 594                       clear->Height));
 595
 596                 D(bug("RefresPropGadgetKnob: knob Left %d Top %d Width %d Height %d\n",
 597                       knob->Left,
 598                       knob->Top,
 599                       knob->Width,
 600                       knob->Height));
 601             #endif
 602
 603                 a.MinX = clear->Left;
 604                 a.MinY = clear->Top;
 605                 a.MaxX = clear->Left + clear->Width - 1;
 606                 a.MaxY = clear->Top + clear->Height - 1;
 607
 608                 b.MinX = knob->Left;
 609                 b.MinY = knob->Top;
 610                 b.MaxX = knob->Left + knob->Width - 1;
 611                 b.MaxY = knob->Top + knob->Height - 1;
 612
 613             #if 0
 614                 D(bug("RefresPropGadgetKnob: a MinX %d MinY %d MaxX %d MaxY %d\n",
 615                       a.MinX,
 616                       a.MinY,
 617                       a.MaxX,
 618                       a.MaxY));
 619
 620                 D(bug("RefresPropGadgetKnob: a MinX %d MinY %d MaxX %d MaxY %d\n",
 621                       b.MinX,
 622                       b.MinY,
 623                       b.MaxX,
 624                       b.MaxY));
 625             #endif
 626
 627                 nrects = SubtractRectFromRect(&a, &b, clearrects);
 628
 629                 D(bug("RefresPropGadgetKnob: nrects %d\n",
 630                       nrects));
 631             #if 0
 632                 D(bug("RefresPropGadgetKnob: clearrects[0] MinX %d MinY %d MaxX %d MaxY %d\n",
 633                       clearrects[0].MinX,
 634                       clearrects[0].MinY,
 635                       clearrects[0].MaxX,
 636                       clearrects[0].MaxY));
 637
 638                 D(bug("RefresPropGadgetKnob: clearrects[1] MinX %d MinY %d MaxX %d MaxY %d\n",
 639                       clearrects[1].MinX,
 640                       clearrects[1].MinY,
 641                       clearrects[1].MaxX,
 642                       clearrects[1].MaxY));
 643
 644                 D(bug("RefresPropGadgetKnob: clearrects[2] MinX %d MinY %d MaxX %d MaxY %d\n",
 645                       clearrects[2].MinX,
 646                       clearrects[2].MinY,
 647                       clearrects[2].MaxX,
 648                       clearrects[2].MaxY));
 649
 650                 D(bug("RefresPropGadgetKnob: clearrects[3] MinX %d MinY %d MaxX %d MaxY %d\n",
 651                       clearrects[3].MinX,
 652                       clearrects[3].MinY,
 653                       clearrects[3].MaxX,
 654                       clearrects[3].MaxY));
 655             #endif
 656
 657                 /*kprintf("\n=== oldknob = %d,%d-%d,%d   newknob = %d,%d-%d,%d\n",
 658                     a.MinX,
 659                     a.MinY,
 660                     a.MaxX,
 661                     a.MaxY,
 662                     b.MinX,
 663                     b.MinY,
 664                     b.MaxX,
 665                     b.MaxY);*/
 666
 667                 for(i = 0; i < nrects; i++)
 668                 {
 669                     RenderPropBackground(gadget, window, dri, &clearrects[i], &brect, &krect,
 670                                          pi, rp, onborder, IntuitionBase);
 671                 }
 672
 673             } /* if (clear) */
 674
 675             if (flags & AUTOKNOB)
 676             {
 677                 int hit = ((flags & KNOBHIT) != 0);
 678
 679                 D(bug("RefresPropGadgetKnob: draw knob Left %d Top %d Width %d Height %d\n",
 680                       knob->Left,
 681                       knob->Top,
 682                       knob->Width,
 683                       knob->Height));
 684
 685                 if (onborder)
 686                 {
 687                     struct wdpDrawBorderPropKnob msg;
 688                     struct Rectangle             knobrect;
 689                     knobrect.MinX = knob->Left;
 690                     knobrect.MinY = knob->Top;
 691                     knobrect.MaxX = knob->Left + knob->Width - 1;
 692                     knobrect.MaxY = knob->Top + knob->Height - 1;
 693
 694                     msg.MethodID        = WDM_DRAW_BORDERPROPKNOB;
 695                     msg.wdp_TrueColor   = (((struct IntScreen *)window->WScreen)->DInfo.dri.dri_Flags & DRIF_DIRECTCOLOR);
 696                     msg.wdp_UserBuffer  = ((struct IntWindow *)window)->DecorUserBuffer;
 697                     msg.wdp_Window      = window;
 698                     msg.wdp_RPort       = rp;
 699                     msg.wdp_Gadget      = gadget;
 700                     msg.wdp_RenderRect  = &knobrect;
 701                     msg.wdp_PropRect    = &brect;
 702                     msg.wdp_Flags       = hit ? WDF_DBPK_HIT : 0;
 703                     msg.wdp_Dri         = dri;
 704
 705                     DoMethodA(((struct IntScreen *)(window->WScreen))->WinDecorObj, (Msg)&msg);
 706
 707                 } /* gadget inside window border */
 708                 else
 709                 {
 710                     struct Hook *dhook = NULL;
 711
 712                     if ((gadget->Flags & GFLG_EXTENDED) != 0)
 713                     {
 714                         if ((((struct ExtGadget *) gadget)->MoreFlags & GMORE_BOOPSIGADGET) != 0)
 715                         {
 716                             GetAttr(PGA_DisplayHook, (Object *) gadget, &dhook);
 717                         }
 718                     }
 719                     if (dhook) {
 720                         struct wdpDrawBorderPropKnob msg;
 721                         struct Rectangle                 knobrect;
 722                         knobrect.MinX = knob->Left;
 723                         knobrect.MinY = knob->Top;
 724                         knobrect.MaxX = knob->Left + knob->Width - 1;
 725                         knobrect.MaxY = knob->Top + knob->Height - 1;
 726                         msg.MethodID            = WDM_DRAW_BORDERPROPKNOB;
 727                         msg.wdp_TrueColor   = (((struct IntScreen *)window->WScreen)->DInfo.dri.dri_Flags & DRIF_DIRECTCOLOR);
 728                         msg.wdp_Window          = window;
 729                         msg.wdp_RPort           = rp;
 730                         msg.wdp_Gadget          = gadget;
 731                         msg.wdp_RenderRect  = &knobrect;
 732                         msg.wdp_PropRect        = &brect;
 733                         msg.wdp_Flags           = hit ? WDF_DBPK_HIT : 0;
 734                         msg.wdp_Dri         = dri;
 735
 736                         CallHookPkt(dhook, (Object *) gadget, (Msg)&msg);
 737                     }
 738                     else
 739                     {
 740
 741                         BOOL stdlook = TRUE;
 742
 743                         #ifdef SKINS
 744                         stdlook = RenderPropKnob(window,dri,rp,pi,knob,hit,IntuitionBase);
 745                         #endif
 746
 747                         if (stdlook)
 748                         {
 749                             if (flags & PROPBORDERLESS)
 750                             {
 751                                 SetAPen(rp,dri->dri_Pens[SHADOWPEN]);
 752
 753                                 /* paint black right and bottom edges */
 754
 755                                 RectFill(rp,knob->Left + knob->Width - 1,
 756                                          knob->Top,
 757                                          knob->Left + knob->Width - 1,
 758                                          knob->Top + knob->Height - 1);
 759
 760                                 RectFill(rp,knob->Left,
 761                                          knob->Top + knob->Height - 1,
 762                                          knob->Left + knob->Width - 2,
 763                                          knob->Top + knob->Height - 1);
 764
 765                                 knob->Width--;
 766                                 knob->Height--;
 767
 768                             } /* propborderless */
 769                             else
 770                             {
 771                                 SetAPen(rp,dri->dri_Pens[SHADOWPEN]);
 772
 773                                 if (flags & FREEHORIZ)
 774                                 {
 775                                     /* black line at the left and at the right */
 776
 777                                     RectFill(rp,knob->Left,
 778                                              knob->Top,
 779                                              knob->Left,
 780                                              knob->Top + knob->Height - 1);
 781
 782                                     RectFill(rp,knob->Left + knob->Width - 1,
 783                                              knob->Top,
 784                                              knob->Left + knob->Width - 1,
 785                                              knob->Top + knob->Height - 1);
 786
 787                                     knob->Left++,
 788                                     knob->Width -= 2;
 789                                 }
 790                                 if (flags & FREEVERT)
 791                                 {
 792                                     /* black line at the top and at the bottom */
 793
 794                                     RectFill(rp,knob->Left,
 795                                              knob->Top,
 796                                              knob->Left + knob->Width - 1,
 797                                              knob->Top);
 798
 799                                     RectFill(rp,knob->Left,
 800                                              knob->Top + knob->Height - 1,
 801                                              knob->Left + knob->Width - 1,
 802                                              knob->Top + knob->Height - 1);
 803
 804                                     knob->Top++;
 805                                     knob->Height -= 2;
 806                                 }
 807
 808                             } /* not propborderless */
 809
 810
 811                             SetAPen(rp, dri->dri_Pens[SHINEPEN]);
 812
 813                             /* interior */
 814                             RectFill(rp,knob->Left,
 815                                      knob->Top,
 816                                      knob->Left + knob->Width - 1,
 817                                      knob->Top + knob->Height - 1);
 818                         } /* stdlook */
 819                     } /* gadget has no display (render) hook */
 820                 } /* gadget not inside window border */
 821
 822             } /* if (flags & AUTOKNOB) */
 823             else
 824             {
 825                 struct Image *image = (struct Image *)gadget->GadgetRender;
 826
 827             #if 0 /* CHECKME */
 828                 if (knob->Top + image->Height <= bbox.Top + bbox.Height &&
 829                     knob->Left + image->Width <= bbox.Left + bbox.Width)
 830             #endif
 831                 {
 832                 #if 1
 833                     image->LeftEdge = knob->Left - bbox.Left;
 834                     image->TopEdge = knob->Top - bbox.Top;
 835                     // image->Width = knob->Width;
 836                     // image->Height = knob->Height;
 837
 838                     DrawImageState(rp,
 839                                    image,
 840                                    bbox.Left,
 841                                    bbox.Top,
 842                                    IDS_NORMAL,
 843                                    (struct DrawInfo *)dri);
 844                 #else
 845                     image->LeftEdge = 0;
 846                     image->TopEdge = 0;
 847
 848                     DrawImageState(rp,
 849                                    image,
 850                                    knob->Left,
 851                                    knob->Top,
 852                                    IDS_NORMAL,
 853                                    (struct DrawInfo *)dri);
 854                 #endif
 855                 }
 856             }
 857
 858             if (gadget->Flags & GFLG_DISABLED)
 859             {
 860                 RenderDisabledPattern(rp, (struct DrawInfo *)dri,
 861                                       brect.MinX, brect.MinY,
 862                                       brect.MaxX, brect.MaxY, IntuitionBase);
 863             }
 864
 865             ReleaseGIRPort(rp);
 866
 867         } /* if ((rp = ObtainGIRPort(&gi))) */
 868
 869         FreeScreenDrawInfo(window->WScreen, (struct DrawInfo *)dri);
 870
 871     } /* if ((dri = GetScreenDrawInfo(window->WScreen))) */
 872
 873     ReturnVoid("RefreshPropGadgetKnob");
 874
 875 } /* RefreshPropGadgetKnob */
 876
 877 BOOL isonborder(struct Gadget *gadget, struct Window *window)
 878 {
 879     if ((window->BorderBottom > 2) && (gadget->Flags & GFLG_RELBOTTOM))
 880     if (window->Height + gadget->TopEdge >= window->Height - window->BorderBottom) return TRUE;
 881
 882     if ((window->BorderRight > 2) && (gadget->Flags & GFLG_RELRIGHT))
 883     if (window->Width + gadget->LeftEdge >= window->Width - window->BorderRight) return TRUE;
 884
 885     return FALSE;
 886 }