git.oblomov.eu Git - wine/blob - 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 "wownt32.h"
  27 #include "gdi_private.h"
  28 #include "wine/debug.h"
  29
  30 WINE_DEFAULT_DEBUG_CHANNEL(dc);
  31
  32
  33 /***********************************************************************
  34  *           MAPPING_FixIsotropic
  35  *
  36  * Fix viewport extensions for isotropic mode.
  37  */
  38 static void MAPPING_FixIsotropic( DC * dc )
  39 {
  40     double xdim = fabs((double)dc->vportExtX * dc->virtual_size.cx /
  41                   (dc->virtual_res.cx * dc->wndExtX));
  42     double ydim = fabs((double)dc->vportExtY * dc->virtual_size.cy /
  43                   (dc->virtual_res.cy * dc->wndExtY));
  44
  45     if (xdim > ydim)
  46     {
  47         INT mincx = (dc->vportExtX >= 0) ? 1 : -1;
  48         dc->vportExtX = floor(dc->vportExtX * ydim / xdim + 0.5);
  49         if (!dc->vportExtX) dc->vportExtX = mincx;
  50     }
  51     else
  52     {
  53         INT mincy = (dc->vportExtY >= 0) ? 1 : -1;
  54         dc->vportExtY = floor(dc->vportExtY * xdim / ydim + 0.5);
  55         if (!dc->vportExtY) dc->vportExtY = mincy;
  56     }
  57 }
  58
  59
  60 /***********************************************************************
  61  *           DPtoLP    (GDI32.@)
  62  */
  63 BOOL WINAPI DPtoLP( HDC hdc, LPPOINT points, INT count )
  64 {
  65     DC * dc = get_dc_ptr( hdc );
  66     if (!dc) return FALSE;
  67
  68     if (dc->vport2WorldValid)
  69     {
  70         while (count--)
  71         {
  72             double x = points->x;
  73             double y = points->y;
  74             points->x = floor( x * dc->xformVport2World.eM11 +
  75                                y * dc->xformVport2World.eM21 +
  76                                dc->xformVport2World.eDx + 0.5 );
  77             points->y = floor( x * dc->xformVport2World.eM12 +
  78                                y * dc->xformVport2World.eM22 +
  79                                dc->xformVport2World.eDy + 0.5 );
  80             points++;
  81         }
  82     }
  83     release_dc_ptr( dc );
  84     return (count < 0);
  85 }
  86
  87
  88 /***********************************************************************
  89  *           LPtoDP    (GDI32.@)
  90  */
  91 BOOL WINAPI LPtoDP( HDC hdc, LPPOINT points, INT count )
  92 {
  93     DC * dc = get_dc_ptr( hdc );
  94     if (!dc) return FALSE;
  95
  96     while (count--)
  97     {
  98         double x = points->x;
  99         double y = points->y;
 100         points->x = floor( x * dc->xformWorld2Vport.eM11 +
 101                            y * dc->xformWorld2Vport.eM21 +
 102                            dc->xformWorld2Vport.eDx + 0.5 );
 103         points->y = floor( x * dc->xformWorld2Vport.eM12 +
 104                            y * dc->xformWorld2Vport.eM22 +
 105                            dc->xformWorld2Vport.eDy + 0.5 );
 106         points++;
 107     }
 108     release_dc_ptr( dc );
 109     return TRUE;
 110 }
 111
 112
 113 /***********************************************************************
 114  *           SetMapMode    (GDI32.@)
 115  */
 116 INT WINAPI SetMapMode( HDC hdc, INT mode )
 117 {
 118     INT ret;
 119     INT horzSize, vertSize, horzRes, vertRes;
 120
 121     DC * dc = get_dc_ptr( hdc );
 122     if (!dc) return 0;
 123     if (dc->funcs->pSetMapMode)
 124     {
 125         if((ret = dc->funcs->pSetMapMode( dc->physDev, mode )) != TRUE)
 126         {
 127             if(ret == GDI_NO_MORE_WORK)
 128                 ret = TRUE;
 129             goto done;
 130         }
 131     }
 132
 133     TRACE("%p %d\n", hdc, mode );
 134
 135     ret = dc->MapMode;
 136
 137     if (mode == dc->MapMode && (mode == MM_ISOTROPIC || mode == MM_ANISOTROPIC))
 138         goto done;
 139
 140     horzSize = dc->virtual_size.cx;
 141     vertSize = dc->virtual_size.cy;
 142     horzRes  = dc->virtual_res.cx;
 143     vertRes  = dc->virtual_res.cy;
 144     switch(mode)
 145     {
 146     case MM_TEXT:
 147         dc->wndExtX   = 1;
 148         dc->wndExtY   = 1;
 149         dc->vportExtX = 1;
 150         dc->vportExtY = 1;
 151         break;
 152     case MM_LOMETRIC:
 153     case MM_ISOTROPIC:
 154         dc->wndExtX   = horzSize * 10;
 155         dc->wndExtY   = vertSize * 10;
 156         dc->vportExtX = horzRes;
 157         dc->vportExtY = -vertRes;
 158         break;
 159     case MM_HIMETRIC:
 160         dc->wndExtX   = horzSize * 100;
 161         dc->wndExtY   = vertSize * 100;
 162         dc->vportExtX = horzRes;
 163         dc->vportExtY = -vertRes;
 164         break;
 165     case MM_LOENGLISH:
 166         dc->wndExtX   = MulDiv(1000, horzSize, 254);
 167         dc->wndExtY   = MulDiv(1000, vertSize, 254);
 168         dc->vportExtX = horzRes;
 169         dc->vportExtY = -vertRes;
 170         break;
 171     case MM_HIENGLISH:
 172         dc->wndExtX   = MulDiv(10000, horzSize, 254);
 173         dc->wndExtY   = MulDiv(10000, vertSize, 254);
 174         dc->vportExtX = horzRes;
 175         dc->vportExtY = -vertRes;
 176         break;
 177     case MM_TWIPS:
 178         dc->wndExtX   = MulDiv(14400, horzSize, 254);
 179         dc->wndExtY   = MulDiv(14400, vertSize, 254);
 180         dc->vportExtX = horzRes;
 181         dc->vportExtY = -vertRes;
 182         break;
 183     case MM_ANISOTROPIC:
 184         break;
 185     default:
 186         goto done;
 187     }
 188     dc->MapMode = mode;
 189     DC_UpdateXforms( dc );
 190  done:
 191     release_dc_ptr( dc );
 192     return ret;
 193 }
 194
 195
 196 /***********************************************************************
 197  *           SetViewportExtEx    (GDI32.@)
 198  */
 199 BOOL WINAPI SetViewportExtEx( HDC hdc, INT x, INT y, LPSIZE size )
 200 {
 201     INT ret = TRUE;
 202     DC * dc = get_dc_ptr( hdc );
 203     if (!dc) return FALSE;
 204     if (dc->funcs->pSetViewportExt)
 205     {
 206         if((ret = dc->funcs->pSetViewportExt( dc->physDev, x, y )) != TRUE)
 207         {
 208             if(ret == GDI_NO_MORE_WORK)
 209                 ret = TRUE;
 210             goto done;
 211         }
 212     }
 213     if (size)
 214     {
 215         size->cx = dc->vportExtX;
 216         size->cy = dc->vportExtY;
 217     }
 218     if ((dc->MapMode != MM_ISOTROPIC) && (dc->MapMode != MM_ANISOTROPIC))
 219         goto done;
 220     if (!x || !y)
 221     {
 222         ret = FALSE;
 223         goto done;
 224     }
 225     dc->vportExtX = x;
 226     dc->vportExtY = y;
 227     if (dc->MapMode == MM_ISOTROPIC) MAPPING_FixIsotropic( dc );
 228     DC_UpdateXforms( dc );
 229  done:
 230     release_dc_ptr( dc );
 231     return ret;
 232 }
 233
 234
 235 /***********************************************************************
 236  *           SetViewportOrgEx    (GDI32.@)
 237  */
 238 BOOL WINAPI SetViewportOrgEx( HDC hdc, INT x, INT y, LPPOINT pt )
 239 {
 240     INT ret = TRUE;
 241     DC * dc = get_dc_ptr( hdc );
 242     if (!dc) return FALSE;
 243     if (dc->funcs->pSetViewportOrg)
 244     {
 245         if((ret = dc->funcs->pSetViewportOrg( dc->physDev, x, y )) != TRUE)
 246         {
 247             if(ret == GDI_NO_MORE_WORK)
 248                 ret = TRUE;
 249             goto done;
 250         }
 251     }
 252     if (pt)
 253     {
 254         pt->x = dc->vportOrgX;
 255         pt->y = dc->vportOrgY;
 256     }
 257     dc->vportOrgX = x;
 258     dc->vportOrgY = y;
 259     DC_UpdateXforms( dc );
 260
 261  done:
 262     release_dc_ptr( dc );
 263     return ret;
 264 }
 265
 266
 267 /***********************************************************************
 268  *           SetWindowExtEx    (GDI32.@)
 269  */
 270 BOOL WINAPI SetWindowExtEx( HDC hdc, INT x, INT y, LPSIZE size )
 271 {
 272     INT ret = TRUE;
 273     DC * dc = get_dc_ptr( hdc );
 274     if (!dc) return FALSE;
 275     if (dc->funcs->pSetWindowExt)
 276     {
 277         if((ret = dc->funcs->pSetWindowExt( dc->physDev, x, y )) != TRUE)
 278         {
 279             if(ret == GDI_NO_MORE_WORK)
 280                 ret = TRUE;
 281             goto done;
 282         }
 283     }
 284     if (size)
 285     {
 286         size->cx = dc->wndExtX;
 287         size->cy = dc->wndExtY;
 288     }
 289     if ((dc->MapMode != MM_ISOTROPIC) && (dc->MapMode != MM_ANISOTROPIC))
 290         goto done;
 291     if (!x || !y)
 292     {
 293         ret = FALSE;
 294         goto done;
 295     }
 296     dc->wndExtX = x;
 297     dc->wndExtY = y;
 298     /* The API docs say that you should call SetWindowExtEx before
 299        SetViewportExtEx. This advice does not imply that Windows
 300        doesn't ensure the isotropic mapping after SetWindowExtEx! */
 301     if (dc->MapMode == MM_ISOTROPIC) MAPPING_FixIsotropic( dc );
 302     DC_UpdateXforms( dc );
 303  done:
 304     release_dc_ptr( dc );
 305     return ret;
 306 }
 307
 308
 309 /***********************************************************************
 310  *           SetWindowOrgEx    (GDI32.@)
 311  */
 312 BOOL WINAPI SetWindowOrgEx( HDC hdc, INT x, INT y, LPPOINT pt )
 313 {
 314     INT ret = TRUE;
 315     DC * dc = get_dc_ptr( hdc );
 316     if (!dc) return FALSE;
 317     if (dc->funcs->pSetWindowOrg)
 318     {
 319         if((ret = dc->funcs->pSetWindowOrg( dc->physDev, x, y )) != TRUE)
 320         {
 321             if(ret == GDI_NO_MORE_WORK)
 322                 ret = TRUE;
 323             goto done;
 324         }
 325     }
 326     if (pt)
 327     {
 328         pt->x = dc->wndOrgX;
 329         pt->y = dc->wndOrgY;
 330     }
 331     dc->wndOrgX = x;
 332     dc->wndOrgY = y;
 333     DC_UpdateXforms( dc );
 334  done:
 335     release_dc_ptr( dc );
 336     return ret;
 337 }
 338
 339
 340 /***********************************************************************
 341  *           OffsetViewportOrgEx    (GDI32.@)
 342  */
 343 BOOL WINAPI OffsetViewportOrgEx( HDC hdc, INT x, INT y, LPPOINT pt)
 344 {
 345     INT ret = TRUE;
 346     DC * dc = get_dc_ptr( hdc );
 347     if (!dc) return FALSE;
 348     if (dc->funcs->pOffsetViewportOrg)
 349     {
 350         if((ret = dc->funcs->pOffsetViewportOrg( dc->physDev, x, y )) != TRUE)
 351         {
 352             if(ret == GDI_NO_MORE_WORK)
 353                 ret = TRUE;
 354             goto done;
 355         }
 356     }
 357     if (pt)
 358     {
 359         pt->x = dc->vportOrgX;
 360         pt->y = dc->vportOrgY;
 361     }
 362     dc->vportOrgX += x;
 363     dc->vportOrgY += y;
 364     DC_UpdateXforms( dc );
 365  done:
 366     release_dc_ptr( dc );
 367     return ret;
 368 }
 369
 370
 371 /***********************************************************************
 372  *           OffsetWindowOrgEx    (GDI32.@)
 373  */
 374 BOOL WINAPI OffsetWindowOrgEx( HDC hdc, INT x, INT y, LPPOINT pt )
 375 {
 376     INT ret = TRUE;
 377     DC * dc = get_dc_ptr( hdc );
 378     if (!dc) return FALSE;
 379     if (dc->funcs->pOffsetWindowOrg)
 380     {
 381         if((ret = dc->funcs->pOffsetWindowOrg( dc->physDev, x, y )) != TRUE)
 382         {
 383             if(ret == GDI_NO_MORE_WORK)
 384                 ret = TRUE;
 385             goto done;
 386         }
 387     }
 388     if (pt)
 389     {
 390         pt->x = dc->wndOrgX;
 391         pt->y = dc->wndOrgY;
 392     }
 393     dc->wndOrgX += x;
 394     dc->wndOrgY += y;
 395     DC_UpdateXforms( dc );
 396  done:
 397     release_dc_ptr( dc );
 398     return ret;
 399 }
 400
 401
 402 /***********************************************************************
 403  *           ScaleViewportExtEx    (GDI32.@)
 404  */
 405 BOOL WINAPI ScaleViewportExtEx( HDC hdc, INT xNum, INT xDenom,
 406                                     INT yNum, INT yDenom, LPSIZE size )
 407 {
 408     INT ret = TRUE;
 409     DC * dc = get_dc_ptr( hdc );
 410     if (!dc) return FALSE;
 411     if (dc->funcs->pScaleViewportExt)
 412     {
 413         if((ret = dc->funcs->pScaleViewportExt( dc->physDev, xNum, xDenom, yNum, yDenom )) != TRUE)
 414         {
 415             if(ret == GDI_NO_MORE_WORK)
 416                 ret = TRUE;
 417             goto done;
 418         }
 419     }
 420     if (size)
 421     {
 422         size->cx = dc->vportExtX;
 423         size->cy = dc->vportExtY;
 424     }
 425     if ((dc->MapMode != MM_ISOTROPIC) && (dc->MapMode != MM_ANISOTROPIC))
 426         goto done;
 427     if (!xNum || !xDenom || !xNum || !yDenom)
 428     {
 429         ret = FALSE;
 430         goto done;
 431     }
 432     dc->vportExtX = (dc->vportExtX * xNum) / xDenom;
 433     dc->vportExtY = (dc->vportExtY * yNum) / yDenom;
 434     if (dc->vportExtX == 0) dc->vportExtX = 1;
 435     if (dc->vportExtY == 0) dc->vportExtY = 1;
 436     if (dc->MapMode == MM_ISOTROPIC) MAPPING_FixIsotropic( dc );
 437     DC_UpdateXforms( dc );
 438  done:
 439     release_dc_ptr( dc );
 440     return ret;
 441 }
 442
 443
 444 /***********************************************************************
 445  *           ScaleWindowExtEx    (GDI32.@)
 446  */
 447 BOOL WINAPI ScaleWindowExtEx( HDC hdc, INT xNum, INT xDenom,
 448                                   INT yNum, INT yDenom, LPSIZE size )
 449 {
 450     INT ret = TRUE;
 451     DC * dc = get_dc_ptr( hdc );
 452     if (!dc) return FALSE;
 453     if (dc->funcs->pScaleWindowExt)
 454     {
 455         if((ret = dc->funcs->pScaleWindowExt( dc->physDev, xNum, xDenom, yNum, yDenom )) != TRUE)
 456         {
 457             if(ret == GDI_NO_MORE_WORK)
 458                 ret = TRUE;
 459             goto done;
 460         }
 461     }
 462     if (size)
 463     {
 464         size->cx = dc->wndExtX;
 465         size->cy = dc->wndExtY;
 466     }
 467     if ((dc->MapMode != MM_ISOTROPIC) && (dc->MapMode != MM_ANISOTROPIC))
 468         goto done;
 469     if (!xNum || !xDenom || !xNum || !yDenom)
 470     {
 471         ret = FALSE;
 472         goto done;
 473     }
 474     dc->wndExtX = (dc->wndExtX * xNum) / xDenom;
 475     dc->wndExtY = (dc->wndExtY * yNum) / yDenom;
 476     if (dc->wndExtX == 0) dc->wndExtX = 1;
 477     if (dc->wndExtY == 0) dc->wndExtY = 1;
 478     if (dc->MapMode == MM_ISOTROPIC) MAPPING_FixIsotropic( dc );
 479     DC_UpdateXforms( dc );
 480  done:
 481     release_dc_ptr( dc );
 482     return ret;
 483 }
 484
 485 /***********************************************************************
 486  *           SetVirtualResolution   (GDI32.@)
 487  *
 488  * Undocumented on msdn.
 489  *
 490  * Changes the values of screen size in pixels and millimeters used by
 491  * the mapping mode functions.
 492  *
 493  * PARAMS
 494  *     hdc       [I] Device context
 495  *     horz_res  [I] Width in pixels  (equivalent to HORZRES device cap).
 496  *     vert_res  [I] Height in pixels (equivalent to VERTRES device cap).
 497  *     horz_size [I] Width in mm      (equivalent to HORZSIZE device cap).
 498  *     vert_size [I] Height in mm     (equivalent to VERTSIZE device cap).
 499  *
 500  * RETURNS
 501  *    TRUE if successful.
 502  *    FALSE if any (but not all) of the last four params are zero.
 503  *
 504  * NOTES
 505  *    This doesn't change the values returned by GetDeviceCaps, just the
 506  *    scaling of the mapping modes.
 507  *
 508  *    Calling with the last four params equal to zero sets the values
 509  *    back to their defaults obtained by calls to GetDeviceCaps.
 510  */
 511 BOOL WINAPI SetVirtualResolution(HDC hdc, DWORD horz_res, DWORD vert_res,
 512                                  DWORD horz_size, DWORD vert_size)
 513 {
 514     DC * dc;
 515     TRACE("(%p %d %d %d %d)\n", hdc, horz_res, vert_res, horz_size, vert_size);
 516
 517     if(horz_res == 0 && vert_res == 0 && horz_size == 0 && vert_size == 0)
 518     {
 519         horz_res  = GetDeviceCaps(hdc, HORZRES);
 520         vert_res  = GetDeviceCaps(hdc, VERTRES);
 521         horz_size = GetDeviceCaps(hdc, HORZSIZE);
 522         vert_size = GetDeviceCaps(hdc, VERTSIZE);
 523     }
 524     else if(horz_res == 0 || vert_res == 0 || horz_size == 0 || vert_size == 0)
 525         return FALSE;
 526
 527     dc = get_dc_ptr( hdc );
 528     if (!dc) return FALSE;
 529
 530     dc->virtual_res.cx  = horz_res;
 531     dc->virtual_res.cy  = vert_res;
 532     dc->virtual_size.cx = horz_size;
 533     dc->virtual_size.cy = vert_size;
 534
 535     release_dc_ptr( dc );
 536     return TRUE;
 537 }