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