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