dlls/winedib.drv/graphics.c

   1 /*
   2  * DIBDRV implementation of GDI driver graphics functions
   3  *
   4  * Copyright 2009 Massimo Del Fedele
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include "config.h"
  22 #include "wine/port.h"
  23
  24 #include "dibdrv.h"
  25
  26 WINE_DEFAULT_DEBUG_CHANNEL(dibdrv);
  27
  28 static inline void OrderInt(int *i1, int *i2)
  29 {
  30     if(*i1 > *i2)
  31     {
  32         int tmp;
  33         tmp = *i1;
  34         *i1 = *i2;
  35         *i2 = tmp;
  36     }
  37 }
  38
  39 #define LEFT_SIDE   1
  40 #define TOP_SIDE    2
  41 #define RIGHT_SIDE  4
  42 #define BOTTOM_SIDE 8
  43
  44 /* clips a line segment by a rectangular window */
  45 static inline BYTE outCodes(const POINT *p, const RECT *r)
  46 {
  47     BYTE Code = 0;
  48
  49     if(p->y < r->top)
  50         Code |= TOP_SIDE;
  51     else if(p->y >= r->bottom)
  52         Code |= BOTTOM_SIDE;
  53     if(p->x >= r->right)
  54         Code |= RIGHT_SIDE;
  55     else if(p->x < r->left)
  56         Code |= LEFT_SIDE;
  57     return Code;
  58 }
  59
  60 static BOOL ClipLine(const POINT *p1, const POINT *p2, const RECT *r, POINT *pc1, POINT *pc2)
  61 {
  62     BYTE outCode1,outCode2;
  63     int tmp;
  64     BYTE tmpCode;
  65
  66     pc1->x = p1->x; pc1->y = p1->y;
  67     pc2->x = p2->x; pc2->y = p2->y;
  68     while(TRUE)
  69     {
  70         outCode1 = outCodes(pc1, r);
  71         outCode2 = outCodes(pc2, r);
  72         if(outCode1 & outCode2)
  73             return FALSE;
  74         if(!outCode1 && !outCode2)
  75             return TRUE;
  76         if(!outCode1)
  77         {
  78             tmp = pc1->x; pc1->x = pc2->x; pc2->x = tmp;
  79             tmp = pc1->y; pc1->y = pc2->y; pc2->y = tmp;
  80             tmpCode = outCode1; outCode1 = outCode2; outCode2 = tmpCode;
  81         }
  82         if(outCode1 & TOP_SIDE)
  83         {
  84             pc1->x += MulDiv(pc2->x - pc1->x, r->top - pc1->y, pc2->y - pc1->y);
  85             pc1->y = r->top;
  86         }
  87         else if(outCode1 & BOTTOM_SIDE)
  88         {
  89             pc1->x += MulDiv(pc2->x - pc1->x, r->bottom - 1 - pc1->y, pc2->y - pc1->y);
  90             pc1->y = r->bottom - 1;
  91         }
  92         else if(outCode1 & RIGHT_SIDE)
  93         {
  94             pc1->y += MulDiv(pc2->y - pc1->y, r->right - 1 - pc1->x, pc2->x - pc1->x);
  95             pc1->x = r->right - 1;
  96         }
  97         else if(outCode1 & LEFT_SIDE)
  98         {
  99             pc1->y += MulDiv(pc2->y - pc1->y, r->left - pc1->x, pc2->x - pc1->x);
 100             pc1->x = r->left;
 101         }
 102     }
 103 }
 104
 105 /* Clips a polygon by an horizontal/vertical line
 106    which indicates the side :
 107 */
 108 static inline BOOL PointInside(const POINT *p, const RECT *r, BYTE side)
 109 {
 110         switch(side)
 111     {
 112                 case 1: /* left */
 113                         return p->x >= r->left;
 114                 case 2: /* top */
 115                         return p->y >= r->top;
 116                 case 4: /* right */
 117                         return p->x < r->right;
 118                 case 8: /* bottom */
 119                         return p->y < r->bottom;
 120         default:
 121             return FALSE;
 122         }
 123 }
 124
 125 static inline void SideIntersect(const POINT *p1, const POINT *p2, const RECT *r, BYTE side, POINT *inters)
 126 {
 127         switch( side )
 128     {
 129                 case LEFT_SIDE: /* left */
 130             inters->x = r->left;
 131             inters->y = MulDiv(p2->y - p1->y, r->left - p1->x, p2->x - p1->x) + p1->y;
 132                         break;
 133                 case TOP_SIDE: /* top */
 134             inters->x = MulDiv(p2->x - p1->x, r->top - p1->y, p2->y - p1->y) + p1->x;
 135             inters->y = r->bottom;
 136                         break;
 137                 case RIGHT_SIDE: /* right */
 138             inters->x = r->right - 1;
 139             inters->y = MulDiv(p2->y - p1->y, r->right - 1 - p1->x, p2->x - p1->x) + p1->y;
 140                         break;
 141                 case BOTTOM_SIDE: /* bottom */
 142             inters->x = MulDiv(p2->x - p1->x, r->bottom - 1 - p1->y, p2->y - p1->y) + p1->x;
 143             inters->y = r->bottom - 1;
 144                         break;
 145         default:
 146             break;
 147         }
 148 }
 149
 150
 151 static BOOL ClipPolygonBySide(const POINT *pt, int count, const RECT *r, BYTE side, POINT **clipped, int *clippedCount)
 152 {
 153         int iPoint;
 154         const POINT *p1, *p2;
 155     POINT *pOut;
 156
 157     if(!(*clipped = HeapAlloc(GetProcessHeap(), 0, sizeof(POINT) * count * 2)))
 158         return FALSE;
 159     pOut = *clipped;
 160     *clippedCount = 0;
 161
 162         p1 = pt + count - 1;
 163     p2 = pt;
 164         for(iPoint = 0 ; iPoint < count ; iPoint++)
 165     {
 166                 if(PointInside(p2, r, side))
 167         {
 168                         /* point p is "inside" */
 169                         if(!PointInside(p1, r, side))
 170             {
 171                                 /* p is "inside" and s is "outside" */
 172                                 SideIntersect(p2, p1, r, side, pOut++);
 173                                 (*clippedCount)++;
 174                         }
 175                         pOut->x = p2->x;
 176             pOut->y = p2->y;
 177             pOut++;
 178             (*clippedCount)++;
 179                 }
 180         else if(PointInside( p1, r, side ))
 181         {
 182                         /* s is "inside" and p is "outside" */
 183                         SideIntersect(p1, p2, r, side, pOut++);
 184                         (*clippedCount)++;
 185                 }
 186                 p1 = p2++;
 187         }
 188     return *clippedCount;
 189 }
 190
 191
 192 /* Clips a polygon by a rectangular window - returns a new polygon */
 193 static BOOL ClipPolygon(const POINT* pt, int count, const RECT *r, POINT **newPt, int *newCount)
 194 {
 195     POINT *pc1, *pc2;
 196     int count1, count2;
 197     BOOL res;
 198
 199     if(!ClipPolygonBySide(pt, count, r, LEFT_SIDE, &pc1, &count1))
 200         return FALSE;
 201     res = ClipPolygonBySide(pc1, count1, r, TOP_SIDE, &pc2, &count2);
 202     HeapFree(GetProcessHeap(), 0, pc1);
 203     if(!res)
 204         return FALSE;
 205     res = ClipPolygonBySide(pc2, count2, r, RIGHT_SIDE, &pc1, &count1);
 206     HeapFree(GetProcessHeap(), 0, pc2);
 207     if(!res)
 208         return FALSE;
 209     res = ClipPolygonBySide(pc1, count1, r, BOTTOM_SIDE, &pc2, &count2);
 210     HeapFree(GetProcessHeap(), 0, pc1);
 211     if(!res)
 212         return FALSE;
 213
 214     *newPt = pc2;
 215     *newCount = count2;
 216     return TRUE;
 217 }
 218
 219 /* Intersects a line given by 2 points with an horizontal scan line at height y */
 220 static BOOL ScanLine(const POINT *p1, const POINT *p2, int ys, POINT *pRes)
 221 {
 222     if(!pRes)
 223         return FALSE;
 224
 225     /* if line lies completely over or under scan line, no intersection */
 226     if((p1->y < ys && p2->y < ys) || (p1->y >= ys && p2->y >= ys))
 227         return FALSE;
 228
 229     /* if line is parallel to x axis, we consider it not intersecting */
 230     if(p1->y == p2->y)
 231         return FALSE;
 232
 233     pRes->x = MulDiv(p2->x - p1->x, ys - p1->y, p2->y - p1->y) + p1->x;
 234     pRes->y = ys;
 235     return TRUE;
 236 }
 237
 238 /* Gets an x-ordered list of intersection points of a scanline at position y
 239    with a polygon/polyline */
 240 static BOOL ScanPolygon(const POINT *pt, int count, int ys, POINT **scans, int *scanCount)
 241 {
 242     const POINT *p1, *p2;
 243     POINT *pDest;
 244     int iPoint;
 245     POINT *ps1, *ps2;
 246     int i, j, tmp;
 247
 248     /* if not at least 2 points, nothing to return */
 249     if(count < 2)
 250         return FALSE;
 251
 252     /* intersections count is AT MOST 'count'; we don't care to
 253        allocate exact memory needed */
 254     *scans = HeapAlloc(GetProcessHeap(), 0, sizeof(POINT)*count);
 255     if(!*scans)
 256         return FALSE;
 257
 258     /* builds unordered intersections */
 259     pDest = *scans;
 260     *scanCount = 0;
 261     p2 = pt;
 262     for(iPoint = 0; iPoint < count-1; iPoint++)
 263     {
 264         p1 = p2;
 265         p2++;
 266         if(ScanLine(p1, p2, ys, pDest))
 267         {
 268             pDest++;
 269             (*scanCount)++;
 270         }
 271     }
 272     p1 = p2;
 273     p2 = pt;
 274     if(ScanLine(p1, p2, ys, pDest))
 275     {
 276         pDest++;
 277         (*scanCount)++;
 278     }
 279
 280     /* now we sort the list -- duped point are left into
 281        as they're needed for the scanline fill algorithm */
 282     for(i = 0, ps1 = *scans; i < *scanCount -1; i++, ps1++)
 283         for(j = i+1, ps2 = ps1+1; j < *scanCount; j++, ps2++)
 284             if(ps2->x < ps1->x)
 285             {
 286                 tmp = ps2->x;
 287                 ps2->x = ps1->x;
 288                 ps1->x = tmp;
 289                 tmp = ps2->y;
 290                 ps2->y = ps1->y;
 291                 ps1->y = tmp;
 292             }
 293
 294     return TRUE;
 295 }
 296
 297 /* gets bounding box of a polygon */
 298 void PolygonBoundingBox(const POINT *pt, int count, RECT *bBox)
 299 {
 300     const POINT *p;
 301     int iPoint;
 302
 303     bBox->left = MAXLONG; bBox->right  = -MAXLONG;
 304     bBox->top  = MAXLONG; bBox->bottom = -MAXLONG;
 305     for(p = pt, iPoint = 0; iPoint < count; iPoint++, p++)
 306     {
 307         if(p->x < bBox->left  ) bBox->left   = p->x;
 308         if(p->x > bBox->right ) bBox->right  = p->x;
 309         if(p->y < bBox->top   ) bBox->top    = p->y;
 310         if(p->y > bBox->bottom) bBox->bottom = p->y;
 311     }
 312 }
 313
 314 /***********************************************************************
 315  *           DIBDRV_Arc
 316  */
 317 BOOL DIBDRV_Arc( DIBDRVPHYSDEV *physDev, int left, int top, int right, int bottom,
 318             int xstart, int ystart, int xend, int yend )
 319 {
 320     BOOL res;
 321
 322     MAYBE(TRACE("physDev:%p, left:%d, top:%d, right:%d, bottom:%d, xstart:%d, ystart:%d, xend:%d, yend:%d\n",
 323           physDev, left, top, right, bottom, xstart, ystart, xend, yend));
 324
 325     if(physDev->hasDIB)
 326     {
 327         /* DIB section selected in, use DIB Engine */
 328         ONCE(FIXME("STUB\n"));
 329         res = TRUE;
 330     }
 331     else
 332     {
 333         /* DDB selected in, use X11 driver */
 334         res = _DIBDRV_GetDisplayDriver()->pArc(physDev->X11PhysDev, left, top, right, bottom,
 335                                                xstart, ystart, xend, yend);
 336     }
 337     return res;
 338 }
 339
 340 /***********************************************************************
 341  *           DIBDRV_Chord
 342  */
 343 BOOL DIBDRV_Chord( DIBDRVPHYSDEV *physDev, int left, int top, int right, int bottom,
 344               int xstart, int ystart, int xend, int yend )
 345 {
 346     BOOL res;
 347
 348     MAYBE(TRACE("physDev:%p, left:%d, top:%d, right:%d, bottom:%d, xstart:%d, ystart:%d, xend:%d, yend:%d\n",
 349           physDev, left, top, right, bottom, xstart, ystart, xend, yend));
 350
 351     if(physDev->hasDIB)
 352     {
 353         /* DIB section selected in, use DIB Engine */
 354         ONCE(FIXME("STUB\n"));
 355         res = TRUE;
 356     }
 357     else
 358     {
 359         /* DDB selected in, use X11 driver */
 360         res = _DIBDRV_GetDisplayDriver()->pChord(physDev->X11PhysDev, left, top, right, bottom,
 361                                                  xstart, ystart, xend, yend);
 362     }
 363     return res;
 364 }
 365
 366 /***********************************************************************
 367  *           DIBDRV_Ellipse
 368  */
 369 BOOL DIBDRV_Ellipse( DIBDRVPHYSDEV *physDev, int left, int top, int right, int bottom )
 370 {
 371     BOOL res;
 372
 373     MAYBE(TRACE("physDev:%p, left:%d, top:%d, right:%d, bottom:%d\n",
 374           physDev, left, top, right, bottom));
 375
 376     if(physDev->hasDIB)
 377     {
 378         /* DIB section selected in, use DIB Engine */
 379         ONCE(FIXME("STUB\n"));
 380         res = TRUE;
 381     }
 382     else
 383     {
 384         /* DDB selected in, use X11 driver */
 385         res = _DIBDRV_GetDisplayDriver()->pEllipse(physDev->X11PhysDev, left, top, right, bottom);
 386     }
 387     return res;
 388 }
 389
 390 /**********************************************************************
 391  *          DIBDRV_ExtFloodFill
 392  */
 393 BOOL DIBDRV_ExtFloodFill( DIBDRVPHYSDEV *physDev, int x, int y, COLORREF color,
 394                      UINT fillType )
 395 {
 396     BOOL res;
 397
 398     MAYBE(TRACE("physDev:%p, x:%d, y:%d, color:%x, fillType:%d\n",
 399           physDev, x, y, color, fillType));
 400
 401     if(physDev->hasDIB)
 402     {
 403         /* DIB section selected in, use DIB Engine */
 404         ONCE(FIXME("STUB\n"));
 405         res = TRUE;
 406     }
 407     else
 408     {
 409         /* DDB selected in, use X11 driver */
 410         res = _DIBDRV_GetDisplayDriver()->pExtFloodFill(physDev->X11PhysDev, x, y, color, fillType);
 411     }
 412     return res;
 413 }
 414
 415 /***********************************************************************
 416  *           DIBDRV_GetDCOrgEx
 417  */
 418 BOOL DIBDRV_GetDCOrgEx( DIBDRVPHYSDEV *physDev, LPPOINT lpp )
 419 {
 420     BOOL res;
 421
 422     MAYBE(TRACE("physDev:%p, lpp:%p\n", physDev, lpp));
 423
 424     if(physDev->hasDIB)
 425     {
 426         /* DIB section selected in, use DIB Engine */
 427         ONCE(FIXME("STUB\n"));
 428         res = TRUE;
 429     }
 430     else
 431     {
 432         /* DDB selected in, use X11 driver */
 433         res = _DIBDRV_GetDisplayDriver()->pGetDCOrgEx(physDev->X11PhysDev, lpp);
 434     }
 435     return res;
 436 }
 437
 438 /***********************************************************************
 439  *           DIBDRV_GetPixel
 440  */
 441 COLORREF DIBDRV_GetPixel( DIBDRVPHYSDEV *physDev, int x, int y )
 442 {
 443     COLORREF res;
 444
 445     MAYBE(TRACE("physDev:%p, x:%d, y:%d\n", physDev, x, y));
 446
 447     if(physDev->hasDIB)
 448     {
 449         res = physDev->physBitmap.funcs->GetPixel(&physDev->physBitmap, x, y);
 450     }
 451     else
 452     {
 453         /* DDB selected in, use X11 driver */
 454         res = _DIBDRV_GetDisplayDriver()->pGetPixel(physDev->X11PhysDev, x, y);
 455     }
 456     return res;
 457 }
 458
 459 /***********************************************************************
 460  *           DIBDRV_LineTo
 461  */
 462 BOOL DIBDRV_LineTo( DIBDRVPHYSDEV *physDev, int x, int y )
 463 {
 464     BOOL res;
 465     POINT curPos;
 466
 467     MAYBE(TRACE("physDev:%p, x:%d, y:%d\n", physDev, x, y));
 468
 469     if(physDev->hasDIB)
 470     {
 471         GetCurrentPositionEx(physDev->hdc, &curPos);
 472
 473         _DIBDRV_ResetDashOrigin(physDev);
 474
 475         if(curPos.y == y)
 476             physDev->penHLine(physDev, curPos.x, x, y);
 477         else if(curPos.x == x)
 478             physDev->penVLine(physDev, x, curPos.y, y);
 479         else
 480             physDev->penLine(physDev, curPos.x, curPos.y, x, y);
 481         res = TRUE;
 482     }
 483     else
 484     {
 485         /* DDB selected in, use X11 driver */
 486         res = _DIBDRV_GetDisplayDriver()->pLineTo(physDev->X11PhysDev, x, y);
 487     }
 488     return res;
 489 }
 490
 491 /***********************************************************************
 492  *           DIBDRV_PaintRgn
 493  */
 494 BOOL DIBDRV_Rectangle( DIBDRVPHYSDEV *physDev, int left, int top, int right, int bottom);
 495 BOOL DIBDRV_PaintRgn( DIBDRVPHYSDEV *physDev, HRGN hrgn )
 496 {
 497     BOOL res = FALSE;
 498     int i;
 499     RECT *rect;
 500     RGNDATA *data;
 501     int size;
 502
 503     MAYBE(TRACE("physDev:%p, hrgn:%p\n", physDev, hrgn));
 504
 505     if(physDev->hasDIB)
 506     {
 507         /* gets needed region data size */
 508         if(!(size = GetRegionData(hrgn, 0, NULL)))
 509             goto fin;
 510
 511         /* allocates buffer and gets actual region data */
 512         if(!(data = HeapAlloc(GetProcessHeap(), 0, size)))
 513             goto fin;
 514         if(!GetRegionData(hrgn, size, data))
 515         {
 516             HeapFree(GetProcessHeap(), 0, data);
 517             goto fin;
 518         }
 519
 520         /* paints the filled rectangles */
 521         rect = (RECT *)data->Buffer;
 522         for(i = 0; i < data->rdh.nCount; i++)
 523         {
 524             DIBDRV_Rectangle( physDev, rect->left, rect->top, rect->right, rect->bottom);
 525             rect++;
 526         }
 527         HeapFree( GetProcessHeap(), 0, data );
 528         res = TRUE;
 529 fin:
 530         ;
 531     }
 532     else
 533     {
 534         /* DDB selected in, use X11 driver */
 535         res = _DIBDRV_GetDisplayDriver()->pPaintRgn(physDev->X11PhysDev, hrgn);
 536     }
 537     return res;
 538 }
 539
 540 /***********************************************************************
 541  *           DIBDRV_Pie
 542  */
 543 BOOL DIBDRV_Pie( DIBDRVPHYSDEV *physDev, int left, int top, int right, int bottom,
 544             int xstart, int ystart, int xend, int yend )
 545 {
 546     BOOL res;
 547
 548     MAYBE(TRACE("physDev:%p, left:%d, top:%d, right:%d, bottom:%d, xstart:%d, ystart:%d, xend:%d, yend:%d\n",
 549           physDev, left, top, right, bottom, xstart, ystart, xend, yend));
 550
 551     if(physDev->hasDIB)
 552     {
 553         /* DIB section selected in, use DIB Engine */
 554         ONCE(FIXME("STUB\n"));
 555         res = TRUE;
 556     }
 557     else
 558     {
 559         /* DDB selected in, use X11 driver */
 560         res = _DIBDRV_GetDisplayDriver()->pPie(physDev->X11PhysDev, left, top, right, bottom,
 561                                                xstart, ystart, xend, yend);
 562     }
 563     return res;
 564 }
 565
 566 /**********************************************************************
 567  *          DIBDRV_Polygon
 568  */
 569 BOOL DIBDRV_Polygon( DIBDRVPHYSDEV *physDev, const POINT* ptw, int count )
 570 {
 571     BOOL res;
 572     POINT *pt;
 573     RECT *r;
 574     int iRec;
 575     POINT *clipped;
 576     int clippedCount;
 577     RECT bBox;
 578     int ys;
 579     POINT *scans;
 580     int scanCount, iScan;
 581     const POINT *p1, *p2;
 582     int iPoint;
 583     POINT pc1, pc2;
 584
 585     MAYBE(TRACE("physDev:%p, pt:%p, count:%d\n", physDev, ptw, count));
 586
 587     if(physDev->hasDIB)
 588     {
 589         /* DIB section selected in, use DIB Engine */
 590
 591         res = FALSE;
 592
 593         /* first converts all points to device coords */
 594         if(!(pt = HeapAlloc(GetProcessHeap(), 0, sizeof(POINT) * count)))
 595             goto fin;
 596         memcpy(pt, ptw, sizeof(POINT) * count);
 597         LPtoDP(physDev->hdc, pt, count);
 598
 599         /* cycle on all current clipping rectangles */
 600         r = physDev->regionRects;
 601         for(iRec = 0; iRec < physDev->regionRectCount; iRec++, r++)
 602         {
 603             /* filled area */
 604             if(ClipPolygon(pt, count, r, &clipped, &clippedCount))
 605             {
 606                 /* gets polygon bounding box -- for ytop and ybottom */
 607                 PolygonBoundingBox(clipped, clippedCount, &bBox);
 608
 609                 /* gets all ordered intersections of polygon with
 610                    current scanline */
 611                 for(ys = bBox.top; ys < bBox.bottom; ys++)
 612                 {
 613                     if(ScanPolygon(clipped, clippedCount, ys, &scans, &scanCount))
 614                     {
 615                         if(scanCount >= 2)
 616                         {
 617                             res = TRUE;
 618                             p1 = scans;
 619                             p2 = p1+1;
 620                             iScan = 0;
 621                             while(iScan < scanCount - 1)
 622                             {
 623                                 physDev->brushHLine(physDev, p1->x, p2->x, ys);
 624                                 p1 +=2;
 625                                 p2 +=2;
 626                                 iScan +=2;
 627                             }
 628                         }
 629                         HeapFree(GetProcessHeap(), 0, scans);
 630                     }
 631                 }
 632                 HeapFree(GetProcessHeap(), 0, clipped);
 633             }
 634
 635             /* perimeter -- don't use PolyLine for speed */
 636             p2 = pt;
 637             for(iPoint = 0; iPoint < count -1; iPoint++)
 638             {
 639                 p1 = p2++;
 640                 if(ClipLine(p1, p2, r, &pc1, &pc2))
 641                 {
 642                     res = TRUE;
 643                     physDev->penLine(physDev, pc1.x, pc1.y, pc2.x, pc2.y);
 644                 }
 645             }
 646             p1 = p2;
 647             p2 = pt;
 648             if(ClipLine(p1, p2, r, &pc1, &pc2))
 649             {
 650                 res = TRUE;
 651                 physDev->penLine(physDev, pc1.x, pc1.y, pc2.x, pc2.y);
 652             }
 653         }
 654
 655         HeapFree(GetProcessHeap(), 0, pt);
 656
 657     }
 658     else
 659     {
 660         /* DDB selected in, use X11 driver */
 661         res = _DIBDRV_GetDisplayDriver()->pPolygon(physDev->X11PhysDev, ptw, count);
 662     }
 663 fin:
 664     return res;
 665 }
 666
 667 /**********************************************************************
 668  *          DIBDRV_Polyline
 669  */
 670 BOOL DIBDRV_Polyline( DIBDRVPHYSDEV *physDev, const POINT* ptw, int count )
 671 {
 672     BOOL res;
 673
 674     MAYBE(TRACE("physDev:%p, pt:%p, count:%d\n", physDev, ptw, count));
 675
 676     if(physDev->hasDIB)
 677     {
 678         /* DIB section selected in, use DIB Engine */
 679         POINT *pt;
 680         RECT *r;
 681         POINT pc1, pc2;
 682         int iRec, iPoint;
 683
 684         if(count < 2)
 685             return FALSE;
 686         res = FALSE;
 687
 688         /* first converts all points to device coords */
 689         if(!(pt = HeapAlloc(GetProcessHeap(), 0, sizeof(POINT) * count)))
 690             return FALSE;
 691         memcpy(pt, ptw, sizeof(POINT) * count);
 692         LPtoDP(physDev->hdc, pt, count);
 693
 694         r = physDev->regionRects;
 695         for(iRec = 0; iRec < physDev->regionRectCount; iRec++)
 696         {
 697             const POINT *p2 = pt, *p1;
 698             for(iPoint = 0; iPoint < count -1; iPoint++)
 699             {
 700                 p1 = p2++;
 701                 if(ClipLine(p1, p2, r, &pc1, &pc2))
 702                 {
 703                     res = TRUE;
 704                     physDev->penLine(physDev, pc1.x, pc1.y, pc2.x, pc2.y);
 705                 }
 706             }
 707             r++;
 708         }
 709
 710         HeapFree(GetProcessHeap(), 0, pt);
 711
 712         return res;
 713     }
 714     else
 715     {
 716         /* DDB selected in, use X11 driver */
 717         res = _DIBDRV_GetDisplayDriver()->pPolyline(physDev->X11PhysDev, ptw, count);
 718     }
 719     return res;
 720 }
 721
 722 /**********************************************************************
 723  *          DIBDRV_PolyPolygon
 724  */
 725 BOOL DIBDRV_PolyPolygon( DIBDRVPHYSDEV *physDev, const POINT* pt, const int* counts, UINT polygons)
 726 {
 727     BOOL res;
 728
 729     MAYBE(TRACE("physDev:%p, pt:%p, counts:%p, polygons:%d\n", physDev, pt, counts, polygons));
 730
 731     if(physDev->hasDIB)
 732     {
 733         /* DIB section selected in, use DIB Engine */
 734         ONCE(FIXME("STUB\n"));
 735         res = TRUE;
 736     }
 737     else
 738     {
 739         /* DDB selected in, use X11 driver */
 740         res = _DIBDRV_GetDisplayDriver()->pPolyPolygon(physDev->X11PhysDev, pt, counts, polygons);
 741     }
 742     return res;
 743 }
 744
 745 /**********************************************************************
 746  *          DIBDRV_PolyPolyline
 747  */
 748 BOOL DIBDRV_PolyPolyline( DIBDRVPHYSDEV *physDev, const POINT* pt, const DWORD* counts,
 749                      DWORD polylines )
 750 {
 751     BOOL res;
 752
 753     MAYBE(TRACE("physDev:%p, pt:%p, counts:%p, polylines:%d\n", physDev, pt, counts, polylines));
 754
 755     if(physDev->hasDIB)
 756     {
 757         /* DIB section selected in, use DIB Engine */
 758         ONCE(FIXME("STUB\n"));
 759         res = TRUE;
 760     }
 761     else
 762     {
 763         /* DDB selected in, use X11 driver */
 764         res = _DIBDRV_GetDisplayDriver()->pPolyPolyline(physDev->X11PhysDev, pt, counts, polylines);
 765     }
 766     return res;
 767 }
 768
 769 /***********************************************************************
 770  *           DIBDRV_Rectangle
 771  */
 772 BOOL DIBDRV_Rectangle( DIBDRVPHYSDEV *physDev, int x1, int y1, int x2, int y2)
 773 {
 774     BOOL res = TRUE;
 775     int i;
 776     DIBDRVBITMAP *bmp = &physDev->physBitmap;
 777
 778     MAYBE(TRACE("physDev:%p, left:%d, top:%d, right:%d, bottom:%d\n", physDev, x1, y1, x2, y2));
 779
 780     if(physDev->hasDIB)
 781     {
 782         OrderInt(&x1, &x2);
 783         OrderInt(&y1, &y2);
 784
 785         /* temporary fix.... should be done by clipping */
 786         if(x1 < 0) x1 = 0;
 787         if(x2 < 0) x2 = 0;
 788         if(y1 < 0) y1 = 0;
 789         if(y2 < 0) y2 = 0;
 790         if(x1 >= bmp->width)  x1 = bmp->width  - 1;
 791         if(y1 >= bmp->height) y1 = bmp->height - 1;
 792         if(x2 >  bmp->width)  x2 = bmp->width;
 793         if(y2 >  bmp->height) y2 = bmp->height ;
 794         if(x1 >= x2 || y1 >= y2)
 795             goto fin;
 796
 797         _DIBDRV_ResetDashOrigin(physDev);
 798
 799         /* particular case where the rectangle
 800            degenerates to a line or a point */
 801         if(x1 >= x2 - 1)
 802         {
 803             physDev->penVLine(physDev, x1, y1, y2);
 804             goto fin;
 805         }
 806         else if (y1 >= y2 -1)
 807         {
 808             physDev->penHLine(physDev, x1, x2, y1);
 809             goto fin;
 810         }
 811
 812         /* Draw the perimeter */
 813         physDev->penHLine(physDev, x1    , x2    , y1   );
 814         physDev->penHLine(physDev, x1    , x2    , y2 - 1);
 815         physDev->penVLine(physDev, x1    , y1 + 1, y2 - 1);
 816         physDev->penVLine(physDev, x2 - 1, y1 + 1, y2 - 1);
 817
 818         /* fill the inside */
 819         if(x2 >= x1 + 2)
 820             for (i = y1 + 1; i < y2 - 1; i++)
 821                 physDev->brushHLine(physDev, x1 + 1, x2 - 1, i);
 822
 823         res = TRUE;
 824 fin:
 825         ;
 826     }
 827     else
 828     {
 829         /* DDB selected in, use X11 driver */
 830         res = _DIBDRV_GetDisplayDriver()->pRectangle(physDev->X11PhysDev, x1, y1, x2, y2);
 831     }
 832     return res;
 833 }
 834
 835 /***********************************************************************
 836  *           DIBDRV_RoundRect
 837  */
 838 BOOL DIBDRV_RoundRect( DIBDRVPHYSDEV *physDev, int left, int top, int right,
 839                   int bottom, int ell_width, int ell_height )
 840 {
 841     BOOL res;
 842
 843     MAYBE(TRACE("physDev:%p, left:%d, top:%d, right:%d, bottom:%d, ell_width:%d, ell_height:%d\n",
 844           physDev, left, top, right, bottom, ell_width, ell_height));
 845
 846     if(physDev->hasDIB)
 847     {
 848         /* DIB section selected in, use DIB Engine */
 849         ONCE(FIXME("STUB\n"));
 850         res = TRUE;
 851     }
 852     else
 853     {
 854         /* DDB selected in, use X11 driver */
 855         res = _DIBDRV_GetDisplayDriver()->pRoundRect(physDev->X11PhysDev, left, top, right, bottom,
 856                                                      ell_width, ell_height);
 857     }
 858     return res;
 859 }
 860
 861 /***********************************************************************
 862  *           DIBDRV_SetPixel
 863  */
 864 COLORREF DIBDRV_SetPixel( DIBDRVPHYSDEV *physDev, int x, int y, COLORREF color )
 865 {
 866     COLORREF res;
 867     DWORD and, xor;
 868
 869     MAYBE(TRACE("physDev:%p, x:%d, y:%d, color:%x\n", physDev, x, y, color));
 870
 871     if(physDev->hasDIB)
 872     {
 873         /* gets previous pixel */
 874         res = physDev->physBitmap.funcs->GetPixel(&physDev->physBitmap, x, y);
 875
 876         /* calculates AND and XOR from color */
 877         _DIBDRV_CalcAndXorMasks(GetROP2(physDev->hdc), color, &and, &xor);
 878
 879         /* sets the pixel */
 880         physDev->physBitmap.funcs->SetPixel(&physDev->physBitmap, x, y, and, xor);
 881     }
 882     else
 883     {
 884         /* DDB selected in, use X11 driver */
 885         res = _DIBDRV_GetDisplayDriver()->pSetPixel(physDev->X11PhysDev, x, y, color);
 886     }
 887     return res;
 888 }
 889
 890 /***********************************************************************
 891  *           DIBDRV_SetDCOrg
 892  */
 893 DWORD DIBDRV_SetDCOrg( DIBDRVPHYSDEV *physDev, int x, int y )
 894 {
 895     DWORD res;
 896
 897     MAYBE(TRACE("physDev:%p, x:%d, y:%d\n", physDev, x, y));
 898
 899     if(physDev->hasDIB)
 900     {
 901         /* DIB section selected in, use DIB Engine */
 902         ONCE(FIXME("STUB\n"));
 903         res = 0;
 904     }
 905     else
 906     {
 907         /* DDB selected in, use X11 driver */
 908         res = _DIBDRV_GetDisplayDriver()->pSetDCOrg(physDev->X11PhysDev, x, y);
 909     }
 910     return res;
 911 }