comctl32/listview: Remove forward declaration and unused parameter from edit box...
[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 "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 || !yNum || !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 }