dlls/gdi32/clipping.c

   1 /*
   2  * DC clipping functions
   3  *
   4  * Copyright 1993 Alexandre Julliard
   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 <stdarg.h>
  22 #include <stdlib.h>
  23 #include "windef.h"
  24 #include "winbase.h"
  25 #include "wingdi.h"
  26 #include "ntgdi_private.h"
  27 #include "wine/debug.h"
  28
  29 WINE_DEFAULT_DEBUG_CHANNEL(clipping);
  30
  31
  32 /* return the DC device rectangle if not empty */
  33 static inline BOOL get_dc_device_rect( DC *dc, RECT *rect )
  34 {
  35     *rect = dc->device_rect;
  36     offset_rect( rect, -dc->attr->vis_rect.left, -dc->attr->vis_rect.top );
  37     return !is_rect_empty( rect );
  38 }
  39
  40 /***********************************************************************
  41  *           get_clip_rect
  42  *
  43  * Compute a clip rectangle from its logical coordinates.
  44  */
  45 static inline RECT get_clip_rect( DC * dc, int left, int top, int right, int bottom )
  46 {
  47     RECT rect;
  48
  49     rect.left   = left;
  50     rect.top    = top;
  51     rect.right  = right;
  52     rect.bottom = bottom;
  53     lp_to_dp( dc, (POINT *)&rect, 2 );
  54     if (dc->attr->layout & LAYOUT_RTL)
  55     {
  56         int tmp = rect.left;
  57         rect.left = rect.right + 1;
  58         rect.right = tmp + 1;
  59     }
  60     return rect;
  61 }
  62
  63 /***********************************************************************
  64  *           clip_device_rect
  65  *
  66  * Clip a rectangle to the whole DC surface.
  67  */
  68 BOOL clip_device_rect( DC *dc, RECT *dst, const RECT *src )
  69 {
  70     RECT clip;
  71
  72     if (get_dc_device_rect( dc, &clip )) return intersect_rect( dst, src, &clip );
  73     *dst = *src;
  74     return TRUE;
  75 }
  76
  77 /***********************************************************************
  78  *           clip_visrect
  79  *
  80  * Clip a rectangle to the DC visible rect.
  81  */
  82 BOOL clip_visrect( DC *dc, RECT *dst, const RECT *src )
  83 {
  84     RECT clip;
  85
  86     if (!clip_device_rect( dc, dst, src )) return FALSE;
  87     if (NtGdiGetRgnBox( get_dc_region(dc), &clip )) return intersect_rect( dst, dst, &clip );
  88     return TRUE;
  89 }
  90
  91 /***********************************************************************
  92  *           update_dc_clipping
  93  *
  94  * Update the DC and device clip regions when the ClipRgn or VisRgn have changed.
  95  */
  96 void update_dc_clipping( DC * dc )
  97 {
  98     PHYSDEV physdev = GET_DC_PHYSDEV( dc, pSetDeviceClipping );
  99     HRGN regions[3];
 100     int count = 0;
 101
 102     if (dc->hVisRgn)  regions[count++] = dc->hVisRgn;
 103     if (dc->hClipRgn) regions[count++] = dc->hClipRgn;
 104     if (dc->hMetaRgn) regions[count++] = dc->hMetaRgn;
 105
 106     if (count > 1)
 107     {
 108         if (!dc->region) dc->region = NtGdiCreateRectRgn( 0, 0, 0, 0 );
 109         NtGdiCombineRgn( dc->region, regions[0], regions[1], RGN_AND );
 110         if (count > 2) NtGdiCombineRgn( dc->region, dc->region, regions[2], RGN_AND );
 111     }
 112     else  /* only one region, we don't need the total region */
 113     {
 114         if (dc->region) DeleteObject( dc->region );
 115         dc->region = 0;
 116     }
 117     physdev->funcs->pSetDeviceClipping( physdev, get_dc_region( dc ));
 118 }
 119
 120 /***********************************************************************
 121  *           create_default_clip_region
 122  *
 123  * Create a default clipping region when none already exists.
 124  */
 125 static inline void create_default_clip_region( DC * dc )
 126 {
 127     RECT rect;
 128
 129     if (!get_dc_device_rect( dc, &rect ))
 130     {
 131         rect.left = 0;
 132         rect.top = 0;
 133         rect.right = GetDeviceCaps( dc->hSelf, DESKTOPHORZRES );
 134         rect.bottom = GetDeviceCaps( dc->hSelf, DESKTOPVERTRES );
 135     }
 136     dc->hClipRgn = CreateRectRgnIndirect( &rect );
 137 }
 138
 139
 140 /***********************************************************************
 141  *           null driver fallback implementations
 142  */
 143
 144 INT CDECL nulldrv_ExtSelectClipRgn( PHYSDEV dev, HRGN rgn, INT mode )
 145 {
 146     return ERROR;
 147 }
 148
 149 /******************************************************************************
 150  *              NtGdiExtSelectClipRgn  (win32u.@)
 151  */
 152 INT WINAPI NtGdiExtSelectClipRgn( HDC hdc, HRGN rgn, INT mode )
 153 {
 154     INT ret = ERROR;
 155     DC *dc;
 156
 157     if (!(dc = get_dc_ptr( hdc ))) return ERROR;
 158     update_dc( dc );
 159
 160     if (!rgn)
 161     {
 162         switch (mode)
 163         {
 164         case RGN_COPY:
 165             if (dc->hClipRgn) DeleteObject( dc->hClipRgn );
 166             dc->hClipRgn = 0;
 167             ret = SIMPLEREGION;
 168             break;
 169
 170         case RGN_DIFF:
 171             break;
 172
 173         default:
 174             FIXME("Unimplemented: hrgn NULL in mode: %d\n", mode);
 175             break;
 176         }
 177     }
 178     else
 179     {
 180         HRGN mirrored = 0;
 181
 182         if (dc->attr->layout & LAYOUT_RTL)
 183         {
 184             if (!(mirrored = NtGdiCreateRectRgn( 0, 0, 0, 0 )))
 185             {
 186                 release_dc_ptr( dc );
 187                 return ERROR;
 188             }
 189             mirror_region( mirrored, rgn, dc->attr->vis_rect.right - dc->attr->vis_rect.left );
 190             rgn = mirrored;
 191         }
 192
 193         if (!dc->hClipRgn)
 194             create_default_clip_region( dc );
 195
 196         if (mode == RGN_COPY)
 197             ret = NtGdiCombineRgn( dc->hClipRgn, rgn, 0, mode );
 198         else
 199             ret = NtGdiCombineRgn( dc->hClipRgn, dc->hClipRgn, rgn, mode );
 200
 201         if (mirrored) DeleteObject( mirrored );
 202     }
 203     if (ret != ERROR) update_dc_clipping( dc );
 204     release_dc_ptr( dc );
 205     return ret;
 206 }
 207
 208 INT CDECL nulldrv_ExcludeClipRect( PHYSDEV dev, INT left, INT top, INT right, INT bottom )
 209 {
 210     return ERROR;
 211 }
 212
 213 INT CDECL nulldrv_IntersectClipRect( PHYSDEV dev, INT left, INT top, INT right, INT bottom )
 214 {
 215     return ERROR;
 216 }
 217
 218 INT CDECL nulldrv_OffsetClipRgn( PHYSDEV dev, INT x, INT y )
 219 {
 220     return ERROR;
 221 }
 222
 223 /***********************************************************************
 224  *           __wine_set_visible_region   (GDI32.@)
 225  */
 226 void CDECL __wine_set_visible_region( HDC hdc, HRGN hrgn, const RECT *vis_rect, const RECT *device_rect,
 227                                       struct window_surface *surface )
 228 {
 229     DC * dc;
 230
 231     if (!(dc = get_dc_ptr( hdc ))) return;
 232
 233     TRACE( "%p %p %s %s %p\n", hdc, hrgn,
 234            wine_dbgstr_rect(vis_rect), wine_dbgstr_rect(device_rect), surface );
 235
 236     /* map region to DC coordinates */
 237     NtGdiOffsetRgn( hrgn, -vis_rect->left, -vis_rect->top );
 238
 239     if (dc->hVisRgn) DeleteObject( dc->hVisRgn );
 240     dc->dirty = 0;
 241     dc->attr->vis_rect = *vis_rect;
 242     dc->device_rect = *device_rect;
 243     dc->hVisRgn = hrgn;
 244     dibdrv_set_window_surface( dc, surface );
 245     DC_UpdateXforms( dc );
 246     update_dc_clipping( dc );
 247     release_dc_ptr( dc );
 248 }
 249
 250
 251 /***********************************************************************
 252  *           NtGdiOffsetClipRgn    (win32u.@)
 253  */
 254 INT WINAPI NtGdiOffsetClipRgn( HDC hdc, INT x, INT y )
 255 {
 256     INT ret = NULLREGION;
 257     DC *dc = get_dc_ptr( hdc );
 258
 259     if (!dc) return ERROR;
 260     update_dc( dc );
 261
 262     if (dc->hClipRgn)
 263     {
 264         x = MulDiv( x, dc->attr->vport_ext.cx, dc->attr->wnd_ext.cx );
 265         y = MulDiv( y, dc->attr->vport_ext.cy, dc->attr->wnd_ext.cy );
 266         if (dc->attr->layout & LAYOUT_RTL) x = -x;
 267         ret = NtGdiOffsetRgn( dc->hClipRgn, x, y );
 268         update_dc_clipping( dc );
 269     }
 270     release_dc_ptr( dc );
 271     return ret;
 272 }
 273
 274
 275 /***********************************************************************
 276  *           NtGdiExcludeClipRect    (win32u.@)
 277  */
 278 INT WINAPI NtGdiExcludeClipRect( HDC hdc, INT left, INT top, INT right, INT bottom )
 279 {
 280     INT ret = ERROR;
 281     RECT rect;
 282     HRGN rgn;
 283     DC *dc = get_dc_ptr( hdc );
 284
 285     TRACE("%p %d,%d-%d,%d\n", hdc, left, top, right, bottom );
 286
 287     if (!dc) return ERROR;
 288     update_dc( dc );
 289
 290     rect = get_clip_rect( dc, left, top, right, bottom );
 291
 292     if ((rgn = CreateRectRgnIndirect( &rect )))
 293     {
 294         if (!dc->hClipRgn) create_default_clip_region( dc );
 295         ret = NtGdiCombineRgn( dc->hClipRgn, dc->hClipRgn, rgn, RGN_DIFF );
 296         DeleteObject( rgn );
 297         if (ret != ERROR) update_dc_clipping( dc );
 298     }
 299     release_dc_ptr( dc );
 300     return ret;
 301 }
 302
 303
 304 /***********************************************************************
 305  *           NtGdiIntersectClipRect    (win32u.@)
 306  */
 307 INT WINAPI NtGdiIntersectClipRect( HDC hdc, INT left, INT top, INT right, INT bottom )
 308 {
 309     INT ret = ERROR;
 310     RECT rect;
 311     HRGN rgn;
 312     DC *dc;
 313
 314     if (!(dc = get_dc_ptr( hdc ))) return ERROR;
 315     update_dc( dc );
 316
 317     rect = get_clip_rect( dc, left, top, right, bottom );
 318     if (!dc->hClipRgn)
 319     {
 320         if ((dc->hClipRgn = CreateRectRgnIndirect( &rect )))
 321             ret = SIMPLEREGION;
 322     }
 323     else if ((rgn = CreateRectRgnIndirect( &rect )))
 324     {
 325         ret = NtGdiCombineRgn( dc->hClipRgn, dc->hClipRgn, rgn, RGN_AND );
 326         DeleteObject( rgn );
 327     }
 328     if (ret != ERROR) update_dc_clipping( dc );
 329     release_dc_ptr( dc );
 330     return ret;
 331 }
 332
 333
 334 /***********************************************************************
 335  *           NtGdiPtVisible    (win32u.@)
 336  */
 337 BOOL WINAPI NtGdiPtVisible( HDC hdc, INT x, INT y )
 338 {
 339     POINT pt;
 340     RECT visrect;
 341     BOOL ret;
 342     DC *dc = get_dc_ptr( hdc );
 343
 344     TRACE("%p %d,%d\n", hdc, x, y );
 345     if (!dc) return FALSE;
 346
 347     pt.x = x;
 348     pt.y = y;
 349     lp_to_dp( dc, &pt, 1 );
 350     update_dc( dc );
 351     ret = (!get_dc_device_rect( dc, &visrect ) ||
 352            (pt.x >= visrect.left && pt.x < visrect.right &&
 353             pt.y >= visrect.top && pt.y < visrect.bottom));
 354     if (ret && get_dc_region( dc )) ret = NtGdiPtInRegion( get_dc_region( dc ), pt.x, pt.y );
 355     release_dc_ptr( dc );
 356     return ret;
 357 }
 358
 359
 360 /***********************************************************************
 361  *           NtGdiRectVisible    (win32u.@)
 362  */
 363 BOOL WINAPI NtGdiRectVisible( HDC hdc, const RECT *rect )
 364 {
 365     RECT tmpRect, visrect;
 366     BOOL ret;
 367     DC *dc = get_dc_ptr( hdc );
 368     if (!dc) return FALSE;
 369     TRACE("%p %s\n", hdc, wine_dbgstr_rect( rect ));
 370
 371     tmpRect = *rect;
 372     lp_to_dp( dc, (POINT *)&tmpRect, 2 );
 373     order_rect( &tmpRect );
 374
 375     update_dc( dc );
 376     ret = (!get_dc_device_rect( dc, &visrect ) || intersect_rect( &visrect, &visrect, &tmpRect ));
 377     if (ret && get_dc_region( dc )) ret = NtGdiRectInRegion( get_dc_region( dc ), &tmpRect );
 378     release_dc_ptr( dc );
 379     return ret;
 380 }
 381
 382
 383 /***********************************************************************
 384  *           GetClipBox    (GDI32.@)
 385  */
 386 INT WINAPI GetClipBox( HDC hdc, LPRECT rect )
 387 {
 388     RECT visrect;
 389     INT ret;
 390     DC *dc = get_dc_ptr( hdc );
 391     if (!dc) return ERROR;
 392
 393     update_dc( dc );
 394     if (get_dc_region( dc ))
 395     {
 396         ret = NtGdiGetRgnBox( get_dc_region( dc ), rect );
 397     }
 398     else
 399     {
 400         ret = is_rect_empty( &dc->attr->vis_rect ) ? ERROR : SIMPLEREGION;
 401         *rect = dc->attr->vis_rect;
 402     }
 403
 404     if (get_dc_device_rect( dc, &visrect ) && !intersect_rect( rect, rect, &visrect )) ret = NULLREGION;
 405
 406     if (dc->attr->layout & LAYOUT_RTL)
 407     {
 408         int tmp = rect->left;
 409         rect->left = rect->right - 1;
 410         rect->right = tmp - 1;
 411     }
 412     dp_to_lp( dc, (LPPOINT)rect, 2 );
 413     release_dc_ptr( dc );
 414     TRACE("%p => %d %s\n", hdc, ret, wine_dbgstr_rect( rect ));
 415     return ret;
 416 }
 417
 418
 419 /***********************************************************************
 420  *           GetClipRgn  (GDI32.@)
 421  */
 422 INT WINAPI GetClipRgn( HDC hdc, HRGN hRgn )
 423 {
 424     INT ret = -1;
 425     DC * dc;
 426     if ((dc = get_dc_ptr( hdc )))
 427     {
 428       if( dc->hClipRgn )
 429       {
 430           if (NtGdiCombineRgn( hRgn, dc->hClipRgn, 0, RGN_COPY ) != ERROR)
 431           {
 432               ret = 1;
 433               if (dc->attr->layout & LAYOUT_RTL)
 434                   mirror_region( hRgn, hRgn, dc->attr->vis_rect.right - dc->attr->vis_rect.left );
 435           }
 436       }
 437       else ret = 0;
 438       release_dc_ptr( dc );
 439     }
 440     return ret;
 441 }
 442
 443
 444 /***********************************************************************
 445  *           GetMetaRgn    (GDI32.@)
 446  */
 447 INT WINAPI GetMetaRgn( HDC hdc, HRGN hRgn )
 448 {
 449     INT ret = 0;
 450     DC * dc = get_dc_ptr( hdc );
 451
 452     if (dc)
 453     {
 454         if (dc->hMetaRgn && NtGdiCombineRgn( hRgn, dc->hMetaRgn, 0, RGN_COPY ) != ERROR)
 455         {
 456             ret = 1;
 457             if (dc->attr->layout & LAYOUT_RTL)
 458                 mirror_region( hRgn, hRgn, dc->attr->vis_rect.right - dc->attr->vis_rect.left );
 459         }
 460         release_dc_ptr( dc );
 461     }
 462     return ret;
 463 }
 464
 465
 466 /***********************************************************************
 467  * GetRandomRgn [GDI32.@]
 468  *
 469  * NOTES
 470  *     This function is documented in MSDN online for the case of
 471  *     iCode == SYSRGN (4).
 472  *
 473  *     For iCode == 1 it should return the clip region
 474  *                  2 "    "       "   the meta region
 475  *                  3 "    "       "   the intersection of the clip with
 476  *                                     the meta region (== 'Rao' region).
 477  *
 478  *     See http://www.codeproject.com/gdi/cliprgnguide.asp
 479  */
 480 INT WINAPI GetRandomRgn(HDC hDC, HRGN hRgn, INT iCode)
 481 {
 482     INT ret = 1;
 483     DC *dc = get_dc_ptr( hDC );
 484
 485     if (!dc) return -1;
 486
 487     switch (iCode)
 488     {
 489     case 1:
 490         if (dc->hClipRgn) NtGdiCombineRgn( hRgn, dc->hClipRgn, 0, RGN_COPY );
 491         else ret = 0;
 492         break;
 493     case 2:
 494         if (dc->hMetaRgn) NtGdiCombineRgn( hRgn, dc->hMetaRgn, 0, RGN_COPY );
 495         else ret = 0;
 496         break;
 497     case 3:
 498         if (dc->hClipRgn && dc->hMetaRgn) NtGdiCombineRgn( hRgn, dc->hClipRgn, dc->hMetaRgn, RGN_AND );
 499         else if (dc->hClipRgn) NtGdiCombineRgn( hRgn, dc->hClipRgn, 0, RGN_COPY );
 500         else if (dc->hMetaRgn) NtGdiCombineRgn( hRgn, dc->hMetaRgn, 0, RGN_COPY );
 501         else ret = 0;
 502         break;
 503     case SYSRGN: /* == 4 */
 504         update_dc( dc );
 505         if (dc->hVisRgn)
 506         {
 507             NtGdiCombineRgn( hRgn, dc->hVisRgn, 0, RGN_COPY );
 508             /* On Windows NT/2000, the SYSRGN returned is in screen coordinates */
 509             if (!(GetVersion() & 0x80000000))
 510                 NtGdiOffsetRgn( hRgn, dc->attr->vis_rect.left, dc->attr->vis_rect.top );
 511         }
 512         else if (!is_rect_empty( &dc->device_rect ))
 513             NtGdiSetRectRgn( hRgn, dc->device_rect.left, dc->device_rect.top,
 514                              dc->device_rect.right, dc->device_rect.bottom );
 515         else
 516             ret = 0;
 517         break;
 518     default:
 519         WARN("Unknown code %d\n", iCode);
 520         ret = -1;
 521         break;
 522     }
 523     release_dc_ptr( dc );
 524     return ret;
 525 }
 526
 527
 528 /***********************************************************************
 529  *           SetMetaRgn    (GDI32.@)
 530  */
 531 INT WINAPI SetMetaRgn( HDC hdc )
 532 {
 533     INT ret;
 534     RECT dummy;
 535     DC *dc = get_dc_ptr( hdc );
 536
 537     if (!dc) return ERROR;
 538
 539     if (dc->hClipRgn)
 540     {
 541         if (dc->hMetaRgn)
 542         {
 543             /* the intersection becomes the new meta region */
 544             NtGdiCombineRgn( dc->hMetaRgn, dc->hMetaRgn, dc->hClipRgn, RGN_AND );
 545             DeleteObject( dc->hClipRgn );
 546             dc->hClipRgn = 0;
 547         }
 548         else
 549         {
 550             dc->hMetaRgn = dc->hClipRgn;
 551             dc->hClipRgn = 0;
 552         }
 553     }
 554     /* else nothing to do */
 555
 556     /* Note: no need to call update_dc_clipping, the overall clip region hasn't changed */
 557
 558     ret = NtGdiGetRgnBox( dc->hMetaRgn, &dummy );
 559     release_dc_ptr( dc );
 560     return ret;
 561 }