dlls/gdi32/mapping.c

   1 /*
   2  * GDI mapping mode 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
  23 #include "windef.h"
  24 #include "winbase.h"
  25 #include "wingdi.h"
  26 #include "gdi_private.h"
  27 #include "wine/debug.h"
  28
  29 WINE_DEFAULT_DEBUG_CHANNEL(dc);
  30
  31
  32 static SIZE get_dc_virtual_size( DC *dc )
  33 {
  34     SIZE ret = dc->virtual_size;
  35
  36     if (!ret.cx)
  37     {
  38         ret.cx = GetDeviceCaps( dc->hSelf, HORZSIZE );
  39         ret.cy = GetDeviceCaps( dc->hSelf, VERTSIZE );
  40     }
  41     return ret;
  42 }
  43
  44 static SIZE get_dc_virtual_res( DC *dc )
  45 {
  46     SIZE ret = dc->virtual_res;
  47
  48     if (!ret.cx)
  49     {
  50         ret.cx = GetDeviceCaps( dc->hSelf, HORZRES );
  51         ret.cy = GetDeviceCaps( dc->hSelf, VERTRES );
  52     }
  53     return ret;
  54 }
  55
  56 /***********************************************************************
  57  *           MAPPING_FixIsotropic
  58  *
  59  * Fix viewport extensions for isotropic mode.
  60  */
  61 static void MAPPING_FixIsotropic( DC * dc )
  62 {
  63     SIZE virtual_size = get_dc_virtual_size( dc );
  64     SIZE virtual_res = get_dc_virtual_res( dc );
  65     double xdim = fabs((double)dc->vport_ext.cx * virtual_size.cx / (virtual_res.cx * dc->wnd_ext.cx));
  66     double ydim = fabs((double)dc->vport_ext.cy * virtual_size.cy / (virtual_res.cy * dc->wnd_ext.cy));
  67
  68     if (xdim > ydim)
  69     {
  70         INT mincx = (dc->vport_ext.cx >= 0) ? 1 : -1;
  71         dc->vport_ext.cx = floor(dc->vport_ext.cx * ydim / xdim + 0.5);
  72         if (!dc->vport_ext.cx) dc->vport_ext.cx = mincx;
  73     }
  74     else
  75     {
  76         INT mincy = (dc->vport_ext.cy >= 0) ? 1 : -1;
  77         dc->vport_ext.cy = floor(dc->vport_ext.cy * xdim / ydim + 0.5);
  78         if (!dc->vport_ext.cy) dc->vport_ext.cy = mincy;
  79     }
  80 }
  81
  82
  83 /***********************************************************************
  84  *           null driver fallback implementations
  85  */
  86
  87 BOOL nulldrv_OffsetViewportOrgEx( PHYSDEV dev, INT x, INT y, POINT *pt )
  88 {
  89     DC *dc = get_nulldrv_dc( dev );
  90
  91     if (pt)
  92         *pt = dc->vport_org;
  93
  94     dc->vport_org.x += x;
  95     dc->vport_org.y += y;
  96     DC_UpdateXforms( dc );
  97     return TRUE;
  98 }
  99
 100 BOOL nulldrv_OffsetWindowOrgEx( PHYSDEV dev, INT x, INT y, POINT *pt )
 101 {
 102     DC *dc = get_nulldrv_dc( dev );
 103
 104     if (pt)
 105         *pt = dc->wnd_org;
 106
 107     dc->wnd_org.x += x;
 108     dc->wnd_org.y += y;
 109     DC_UpdateXforms( dc );
 110     return TRUE;
 111 }
 112
 113 BOOL nulldrv_ScaleViewportExtEx( PHYSDEV dev, INT x_num, INT x_denom, INT y_num, INT y_denom, SIZE *size )
 114 {
 115     DC *dc = get_nulldrv_dc( dev );
 116
 117     if (size)
 118         *size = dc->vport_ext;
 119
 120     if (dc->MapMode != MM_ISOTROPIC && dc->MapMode != MM_ANISOTROPIC) return TRUE;
 121     if (!x_num || !x_denom || !y_num || !y_denom) return FALSE;
 122
 123     dc->vport_ext.cx = (dc->vport_ext.cx * x_num) / x_denom;
 124     dc->vport_ext.cy = (dc->vport_ext.cy * y_num) / y_denom;
 125     if (dc->vport_ext.cx == 0) dc->vport_ext.cx = 1;
 126     if (dc->vport_ext.cy == 0) dc->vport_ext.cy = 1;
 127     if (dc->MapMode == MM_ISOTROPIC) MAPPING_FixIsotropic( dc );
 128     DC_UpdateXforms( dc );
 129     return TRUE;
 130 }
 131
 132 BOOL nulldrv_ScaleWindowExtEx( PHYSDEV dev, INT x_num, INT x_denom, INT y_num, INT y_denom, SIZE *size )
 133 {
 134     DC *dc = get_nulldrv_dc( dev );
 135
 136     if (size)
 137         *size = dc->wnd_ext;
 138
 139     if (dc->MapMode != MM_ISOTROPIC && dc->MapMode != MM_ANISOTROPIC) return TRUE;
 140     if (!x_num || !x_denom || !y_num || !y_denom) return FALSE;
 141
 142     dc->wnd_ext.cx = (dc->wnd_ext.cx * x_num) / x_denom;
 143     dc->wnd_ext.cy = (dc->wnd_ext.cy * y_num) / y_denom;
 144     if (dc->wnd_ext.cx == 0) dc->wnd_ext.cx = 1;
 145     if (dc->wnd_ext.cy == 0) dc->wnd_ext.cy = 1;
 146     if (dc->MapMode == MM_ISOTROPIC) MAPPING_FixIsotropic( dc );
 147     DC_UpdateXforms( dc );
 148     return TRUE;
 149 }
 150
 151 INT nulldrv_SetMapMode( PHYSDEV dev, INT mode )
 152 {
 153     DC *dc = get_nulldrv_dc( dev );
 154     INT ret = dc->MapMode;
 155     SIZE virtual_size, virtual_res;
 156
 157     if (mode == dc->MapMode && (mode == MM_ISOTROPIC || mode == MM_ANISOTROPIC)) return ret;
 158
 159     virtual_size = get_dc_virtual_size( dc );
 160     virtual_res = get_dc_virtual_res( dc );
 161     switch (mode)
 162     {
 163     case MM_TEXT:
 164         dc->wnd_ext.cx   = 1;
 165         dc->wnd_ext.cy   = 1;
 166         dc->vport_ext.cx = 1;
 167         dc->vport_ext.cy = 1;
 168         break;
 169     case MM_LOMETRIC:
 170     case MM_ISOTROPIC:
 171         dc->wnd_ext.cx   = virtual_size.cx * 10;
 172         dc->wnd_ext.cy   = virtual_size.cy * 10;
 173         dc->vport_ext.cx = virtual_res.cx;
 174         dc->vport_ext.cy = -virtual_res.cy;
 175         break;
 176     case MM_HIMETRIC:
 177         dc->wnd_ext.cx   = virtual_size.cx * 100;
 178         dc->wnd_ext.cy   = virtual_size.cy * 100;
 179         dc->vport_ext.cx = virtual_res.cx;
 180         dc->vport_ext.cy = -virtual_res.cy;
 181         break;
 182     case MM_LOENGLISH:
 183         dc->wnd_ext.cx   = MulDiv(1000, virtual_size.cx, 254);
 184         dc->wnd_ext.cy   = MulDiv(1000, virtual_size.cy, 254);
 185         dc->vport_ext.cx = virtual_res.cx;
 186         dc->vport_ext.cy = -virtual_res.cy;
 187         break;
 188     case MM_HIENGLISH:
 189         dc->wnd_ext.cx   = MulDiv(10000, virtual_size.cx, 254);
 190         dc->wnd_ext.cy   = MulDiv(10000, virtual_size.cy, 254);
 191         dc->vport_ext.cx = virtual_res.cx;
 192         dc->vport_ext.cy = -virtual_res.cy;
 193         break;
 194     case MM_TWIPS:
 195         dc->wnd_ext.cx   = MulDiv(14400, virtual_size.cx, 254);
 196         dc->wnd_ext.cy   = MulDiv(14400, virtual_size.cy, 254);
 197         dc->vport_ext.cx = virtual_res.cx;
 198         dc->vport_ext.cy = -virtual_res.cy;
 199         break;
 200     case MM_ANISOTROPIC:
 201         break;
 202     default:
 203         return 0;
 204     }
 205     /* RTL layout is always MM_ANISOTROPIC */
 206     if (!(dc->layout & LAYOUT_RTL)) dc->MapMode = mode;
 207     DC_UpdateXforms( dc );
 208     return ret;
 209 }
 210
 211 BOOL nulldrv_SetViewportExtEx( PHYSDEV dev, INT cx, INT cy, SIZE *size )
 212 {
 213     DC *dc = get_nulldrv_dc( dev );
 214
 215     if (size)
 216         *size = dc->vport_ext;
 217
 218     if (dc->MapMode != MM_ISOTROPIC && dc->MapMode != MM_ANISOTROPIC) return TRUE;
 219     if (!cx || !cy) return FALSE;
 220     dc->vport_ext.cx = cx;
 221     dc->vport_ext.cy = cy;
 222     if (dc->MapMode == MM_ISOTROPIC) MAPPING_FixIsotropic( dc );
 223     DC_UpdateXforms( dc );
 224     return TRUE;
 225 }
 226
 227 BOOL nulldrv_SetViewportOrgEx( PHYSDEV dev, INT x, INT y, POINT *pt )
 228 {
 229     DC *dc = get_nulldrv_dc( dev );
 230
 231     if (pt)
 232         *pt = dc->vport_org;
 233
 234     dc->vport_org.x = x;
 235     dc->vport_org.y = y;
 236     DC_UpdateXforms( dc );
 237     return TRUE;
 238 }
 239
 240 BOOL nulldrv_SetWindowExtEx( PHYSDEV dev, INT cx, INT cy, SIZE *size )
 241 {
 242     DC *dc = get_nulldrv_dc( dev );
 243
 244     if (size)
 245         *size = dc->wnd_ext;
 246
 247     if (dc->MapMode != MM_ISOTROPIC && dc->MapMode != MM_ANISOTROPIC) return TRUE;
 248     if (!cx || !cy) return FALSE;
 249     dc->wnd_ext.cx = cx;
 250     dc->wnd_ext.cy = cy;
 251     /* The API docs say that you should call SetWindowExtEx before
 252        SetViewportExtEx. This advice does not imply that Windows
 253        doesn't ensure the isotropic mapping after SetWindowExtEx! */
 254     if (dc->MapMode == MM_ISOTROPIC) MAPPING_FixIsotropic( dc );
 255     DC_UpdateXforms( dc );
 256     return TRUE;
 257 }
 258
 259 BOOL nulldrv_SetWindowOrgEx( PHYSDEV dev, INT x, INT y, POINT *pt )
 260 {
 261     DC *dc = get_nulldrv_dc( dev );
 262
 263     if (pt)
 264         *pt = dc->wnd_org;
 265
 266     dc->wnd_org.x = x;
 267     dc->wnd_org.y = y;
 268     DC_UpdateXforms( dc );
 269     return TRUE;
 270 }
 271
 272 BOOL nulldrv_ModifyWorldTransform( PHYSDEV dev, const XFORM *xform, DWORD mode )
 273 {
 274     DC *dc = get_nulldrv_dc( dev );
 275
 276     switch (mode)
 277     {
 278     case MWT_IDENTITY:
 279         dc->xformWorld2Wnd.eM11 = 1.0f;
 280         dc->xformWorld2Wnd.eM12 = 0.0f;
 281         dc->xformWorld2Wnd.eM21 = 0.0f;
 282         dc->xformWorld2Wnd.eM22 = 1.0f;
 283         dc->xformWorld2Wnd.eDx  = 0.0f;
 284         dc->xformWorld2Wnd.eDy  = 0.0f;
 285         break;
 286     case MWT_LEFTMULTIPLY:
 287         CombineTransform( &dc->xformWorld2Wnd, xform, &dc->xformWorld2Wnd );
 288         break;
 289     case MWT_RIGHTMULTIPLY:
 290         CombineTransform( &dc->xformWorld2Wnd, &dc->xformWorld2Wnd, xform );
 291         break;
 292     default:
 293         return FALSE;
 294     }
 295     DC_UpdateXforms( dc );
 296     return TRUE;
 297 }
 298
 299 BOOL nulldrv_SetWorldTransform( PHYSDEV dev, const XFORM *xform )
 300 {
 301     DC *dc = get_nulldrv_dc( dev );
 302
 303     dc->xformWorld2Wnd = *xform;
 304     DC_UpdateXforms( dc );
 305     return TRUE;
 306 }
 307
 308 /***********************************************************************
 309  *           dp_to_lp
 310  *
 311  * Internal version of DPtoLP that takes a DC *.
 312  */
 313 BOOL dp_to_lp( DC *dc, POINT *points, INT count )
 314 {
 315     if (dc->vport2WorldValid)
 316     {
 317         while (count--)
 318         {
 319             double x = points->x;
 320             double y = points->y;
 321             points->x = floor( x * dc->xformVport2World.eM11 +
 322                                y * dc->xformVport2World.eM21 +
 323                                dc->xformVport2World.eDx + 0.5 );
 324             points->y = floor( x * dc->xformVport2World.eM12 +
 325                                y * dc->xformVport2World.eM22 +
 326                                dc->xformVport2World.eDy + 0.5 );
 327             points++;
 328         }
 329     }
 330     return (count < 0);
 331 }
 332
 333 /***********************************************************************
 334  *           DPtoLP    (GDI32.@)
 335  */
 336 BOOL WINAPI DPtoLP( HDC hdc, POINT *points, INT count )
 337 {
 338     DC * dc = get_dc_ptr( hdc );
 339     BOOL ret;
 340
 341     if (!dc) return FALSE;
 342
 343     ret = dp_to_lp( dc, points, count );
 344
 345     release_dc_ptr( dc );
 346     return ret;
 347 }
 348
 349
 350 /***********************************************************************
 351  *           lp_to_dp
 352  *
 353  * Internal version of LPtoDP that takes a DC *.
 354  */
 355 void lp_to_dp( DC *dc, POINT *points, INT count )
 356 {
 357     while (count--)
 358     {
 359         double x = points->x;
 360         double y = points->y;
 361         points->x = floor( x * dc->xformWorld2Vport.eM11 +
 362                            y * dc->xformWorld2Vport.eM21 +
 363                            dc->xformWorld2Vport.eDx + 0.5 );
 364         points->y = floor( x * dc->xformWorld2Vport.eM12 +
 365                            y * dc->xformWorld2Vport.eM22 +
 366                            dc->xformWorld2Vport.eDy + 0.5 );
 367         points++;
 368     }
 369 }
 370
 371 /***********************************************************************
 372  *           LPtoDP    (GDI32.@)
 373  */
 374 BOOL WINAPI LPtoDP( HDC hdc, POINT *points, INT count )
 375 {
 376     DC * dc = get_dc_ptr( hdc );
 377     if (!dc) return FALSE;
 378
 379     lp_to_dp( dc, points, count );
 380
 381     release_dc_ptr( dc );
 382     return TRUE;
 383 }
 384
 385
 386 /***********************************************************************
 387  *           SetMapMode    (GDI32.@)
 388  */
 389 INT WINAPI SetMapMode( HDC hdc, INT mode )
 390 {
 391     INT ret = 0;
 392     DC * dc = get_dc_ptr( hdc );
 393
 394     TRACE("%p %d\n", hdc, mode );
 395
 396     if (dc)
 397     {
 398         PHYSDEV physdev = GET_DC_PHYSDEV( dc, pSetMapMode );
 399         ret = physdev->funcs->pSetMapMode( physdev, mode );
 400         release_dc_ptr( dc );
 401     }
 402     return ret;
 403 }
 404
 405
 406 /***********************************************************************
 407  *           SetViewportExtEx    (GDI32.@)
 408  */
 409 BOOL WINAPI SetViewportExtEx( HDC hdc, INT x, INT y, LPSIZE size )
 410 {
 411     BOOL ret = FALSE;
 412     DC * dc = get_dc_ptr( hdc );
 413
 414     if (dc)
 415     {
 416         PHYSDEV physdev = GET_DC_PHYSDEV( dc, pSetViewportExtEx );
 417         ret = physdev->funcs->pSetViewportExtEx( physdev, x, y, size );
 418         release_dc_ptr( dc );
 419     }
 420     return ret;
 421 }
 422
 423
 424 /***********************************************************************
 425  *           SetViewportOrgEx    (GDI32.@)
 426  */
 427 BOOL WINAPI SetViewportOrgEx( HDC hdc, INT x, INT y, LPPOINT pt )
 428 {
 429     BOOL ret = FALSE;
 430     DC * dc = get_dc_ptr( hdc );
 431
 432     if (dc)
 433     {
 434         PHYSDEV physdev = GET_DC_PHYSDEV( dc, pSetViewportOrgEx );
 435         ret = physdev->funcs->pSetViewportOrgEx( physdev, x, y, pt );
 436         release_dc_ptr( dc );
 437     }
 438     return ret;
 439 }
 440
 441
 442 /***********************************************************************
 443  *           SetWindowExtEx    (GDI32.@)
 444  */
 445 BOOL WINAPI SetWindowExtEx( HDC hdc, INT x, INT y, LPSIZE size )
 446 {
 447     BOOL ret = FALSE;
 448     DC * dc = get_dc_ptr( hdc );
 449
 450     if (dc)
 451     {
 452         PHYSDEV physdev = GET_DC_PHYSDEV( dc, pSetWindowExtEx );
 453         ret = physdev->funcs->pSetWindowExtEx( physdev, x, y, size );
 454         release_dc_ptr( dc );
 455     }
 456     return ret;
 457 }
 458
 459
 460 /***********************************************************************
 461  *           SetWindowOrgEx    (GDI32.@)
 462  */
 463 BOOL WINAPI SetWindowOrgEx( HDC hdc, INT x, INT y, LPPOINT pt )
 464 {
 465     BOOL ret = FALSE;
 466     DC * dc = get_dc_ptr( hdc );
 467
 468     if (dc)
 469     {
 470         PHYSDEV physdev = GET_DC_PHYSDEV( dc, pSetWindowOrgEx );
 471         ret = physdev->funcs->pSetWindowOrgEx( physdev, x, y, pt );
 472         release_dc_ptr( dc );
 473     }
 474     return ret;
 475 }
 476
 477
 478 /***********************************************************************
 479  *           OffsetViewportOrgEx    (GDI32.@)
 480  */
 481 BOOL WINAPI OffsetViewportOrgEx( HDC hdc, INT x, INT y, LPPOINT pt)
 482 {
 483     BOOL ret = FALSE;
 484     DC * dc = get_dc_ptr( hdc );
 485
 486     if (dc)
 487     {
 488         PHYSDEV physdev = GET_DC_PHYSDEV( dc, pOffsetViewportOrgEx );
 489         ret = physdev->funcs->pOffsetViewportOrgEx( physdev, x, y, pt );
 490         release_dc_ptr( dc );
 491     }
 492     return ret;
 493 }
 494
 495
 496 /***********************************************************************
 497  *           OffsetWindowOrgEx    (GDI32.@)
 498  */
 499 BOOL WINAPI OffsetWindowOrgEx( HDC hdc, INT x, INT y, LPPOINT pt )
 500 {
 501     BOOL ret = FALSE;
 502     DC * dc = get_dc_ptr( hdc );
 503
 504     if (dc)
 505     {
 506         PHYSDEV physdev = GET_DC_PHYSDEV( dc, pOffsetWindowOrgEx );
 507         ret = physdev->funcs->pOffsetWindowOrgEx( physdev, x, y, pt );
 508         release_dc_ptr( dc );
 509     }
 510     return ret;
 511 }
 512
 513
 514 /***********************************************************************
 515  *           ScaleViewportExtEx    (GDI32.@)
 516  */
 517 BOOL WINAPI ScaleViewportExtEx( HDC hdc, INT xNum, INT xDenom,
 518                                     INT yNum, INT yDenom, LPSIZE size )
 519 {
 520     BOOL ret = FALSE;
 521     DC * dc = get_dc_ptr( hdc );
 522
 523     if (dc)
 524     {
 525         PHYSDEV physdev = GET_DC_PHYSDEV( dc, pScaleViewportExtEx );
 526         ret = physdev->funcs->pScaleViewportExtEx( physdev, xNum, xDenom, yNum, yDenom, size );
 527         release_dc_ptr( dc );
 528     }
 529     return ret;
 530 }
 531
 532
 533 /***********************************************************************
 534  *           ScaleWindowExtEx    (GDI32.@)
 535  */
 536 BOOL WINAPI ScaleWindowExtEx( HDC hdc, INT xNum, INT xDenom,
 537                                   INT yNum, INT yDenom, LPSIZE size )
 538 {
 539     BOOL ret = FALSE;
 540     DC * dc = get_dc_ptr( hdc );
 541
 542     if (dc)
 543     {
 544         PHYSDEV physdev = GET_DC_PHYSDEV( dc, pScaleWindowExtEx );
 545         ret = physdev->funcs->pScaleWindowExtEx( physdev, xNum, xDenom, yNum, yDenom, size );
 546         release_dc_ptr( dc );
 547     }
 548     return ret;
 549 }
 550
 551
 552 /****************************************************************************
 553  *           ModifyWorldTransform   (GDI32.@)
 554  */
 555 BOOL WINAPI ModifyWorldTransform( HDC hdc, const XFORM *xform, DWORD mode )
 556 {
 557     BOOL ret = FALSE;
 558     DC *dc;
 559
 560     if (!xform && mode != MWT_IDENTITY) return FALSE;
 561     if ((dc = get_dc_ptr( hdc )))
 562     {
 563         PHYSDEV physdev = GET_DC_PHYSDEV( dc, pModifyWorldTransform );
 564         if (dc->GraphicsMode == GM_ADVANCED)
 565             ret = physdev->funcs->pModifyWorldTransform( physdev, xform, mode );
 566         release_dc_ptr( dc );
 567     }
 568     return ret;
 569 }
 570
 571
 572 /***********************************************************************
 573  *           SetWorldTransform    (GDI32.@)
 574  */
 575 BOOL WINAPI SetWorldTransform( HDC hdc, const XFORM *xform )
 576 {
 577     BOOL ret = FALSE;
 578     DC *dc;
 579
 580     if (!xform) return FALSE;
 581     /* The transform must conform to (eM11 * eM22 != eM12 * eM21) requirement */
 582     if (xform->eM11 * xform->eM22 == xform->eM12 * xform->eM21) return FALSE;
 583
 584     TRACE("eM11 %f eM12 %f eM21 %f eM22 %f eDx %f eDy %f\n",
 585         xform->eM11, xform->eM12, xform->eM21, xform->eM22, xform->eDx, xform->eDy);
 586
 587     if ((dc = get_dc_ptr( hdc )))
 588     {
 589         PHYSDEV physdev = GET_DC_PHYSDEV( dc, pSetWorldTransform );
 590         if (dc->GraphicsMode == GM_ADVANCED)
 591             ret = physdev->funcs->pSetWorldTransform( physdev, xform );
 592         release_dc_ptr( dc );
 593     }
 594     return ret;
 595 }
 596
 597
 598 /***********************************************************************
 599  *           SetVirtualResolution   (GDI32.@)
 600  *
 601  * Undocumented on msdn.
 602  *
 603  * Changes the values of screen size in pixels and millimeters used by
 604  * the mapping mode functions.
 605  *
 606  * PARAMS
 607  *     hdc       [I] Device context
 608  *     horz_res  [I] Width in pixels  (equivalent to HORZRES device cap).
 609  *     vert_res  [I] Height in pixels (equivalent to VERTRES device cap).
 610  *     horz_size [I] Width in mm      (equivalent to HORZSIZE device cap).
 611  *     vert_size [I] Height in mm     (equivalent to VERTSIZE device cap).
 612  *
 613  * RETURNS
 614  *    TRUE if successful.
 615  *    FALSE if any (but not all) of the last four params are zero.
 616  *
 617  * NOTES
 618  *    This doesn't change the values returned by GetDeviceCaps, just the
 619  *    scaling of the mapping modes.
 620  *
 621  *    Calling with the last four params equal to zero sets the values
 622  *    back to their defaults obtained by calls to GetDeviceCaps.
 623  */
 624 BOOL WINAPI SetVirtualResolution(HDC hdc, DWORD horz_res, DWORD vert_res,
 625                                  DWORD horz_size, DWORD vert_size)
 626 {
 627     DC * dc;
 628     TRACE("(%p %d %d %d %d)\n", hdc, horz_res, vert_res, horz_size, vert_size);
 629
 630     if (!horz_res || !vert_res || !horz_size || !vert_size)
 631     {
 632         /* they must be all zero */
 633         if (horz_res || vert_res || horz_size || vert_size) return FALSE;
 634     }
 635
 636     dc = get_dc_ptr( hdc );
 637     if (!dc) return FALSE;
 638
 639     dc->virtual_res.cx  = horz_res;
 640     dc->virtual_res.cy  = vert_res;
 641     dc->virtual_size.cx = horz_size;
 642     dc->virtual_size.cy = vert_size;
 643
 644     release_dc_ptr( dc );
 645     return TRUE;
 646 }