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