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