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