?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
winepulse: Use GetModuleFileName() instead of hardcoded module filename for registry...
[wine.git] / dlls / win32u / mapping.c
blob65f276e853f649155f8a1955014780196afd6832
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 #if 0
22 #pragma makedep unix
23 #endif
24
25 #include <stdarg.h>
26
27 #include "windef.h"
28 #include "winbase.h"
29 #include "wingdi.h"
30 #include "ntgdi_private.h"
31 #include "wine/debug.h"
32
33 WINE_DEFAULT_DEBUG_CHANNEL(dc);
34
35
36 /* copied from kernelbase */
37 int muldiv( int a, int b, int c )
38 {
39 LONGLONG ret;
40
41 if (!c) return -1;
42
43 /* We want to deal with a positive divisor to simplify the logic. */
44 if (c < 0)
45 {
46 a = -a;
47 c = -c;
48 }
49
50 /* If the result is positive, we "add" to round. else, we subtract to round. */
51 if ((a < 0 && b < 0) || (a >= 0 && b >= 0))
52 ret = (((LONGLONG)a * b) + (c / 2)) / c;
53 else
54 ret = (((LONGLONG)a * b) - (c / 2)) / c;
55
56 if (ret > 2147483647 || ret < -2147483647) return -1;
57 return ret;
58 }
59
60 static SIZE get_dc_virtual_size( DC *dc )
61 {
62 SIZE ret = dc->attr->virtual_size;
63
64 if (!ret.cx)
65 {
66 ret.cx = NtGdiGetDeviceCaps( dc->hSelf, HORZSIZE );
67 ret.cy = NtGdiGetDeviceCaps( dc->hSelf, VERTSIZE );
68 }
69 return ret;
70 }
71
72 static SIZE get_dc_virtual_res( DC *dc )
73 {
74 SIZE ret = dc->attr->virtual_res;
75
76 if (!ret.cx)
77 {
78 ret.cx = NtGdiGetDeviceCaps( dc->hSelf, HORZRES );
79 ret.cy = NtGdiGetDeviceCaps( dc->hSelf, VERTRES );
80 }
81 return ret;
82 }
83
84 /***********************************************************************
85 * MAPPING_FixIsotropic
86 *
87 * Fix viewport extensions for isotropic mode.
88 */
89 static void MAPPING_FixIsotropic( DC * dc )
90 {
91 SIZE virtual_size = get_dc_virtual_size( dc );
92 SIZE virtual_res = get_dc_virtual_res( dc );
93 double xdim = fabs((double)dc->attr->vport_ext.cx * virtual_size.cx /
94 (virtual_res.cx * dc->attr->wnd_ext.cx));
95 double ydim = fabs((double)dc->attr->vport_ext.cy * virtual_size.cy /
96 (virtual_res.cy * dc->attr->wnd_ext.cy));
97
98 if (xdim > ydim)
99 {
100 INT mincx = (dc->attr->vport_ext.cx >= 0) ? 1 : -1;
101 dc->attr->vport_ext.cx = GDI_ROUND( dc->attr->vport_ext.cx * ydim / xdim );
102 if (!dc->attr->vport_ext.cx) dc->attr->vport_ext.cx = mincx;
103 }
104 else
105 {
106 INT mincy = (dc->attr->vport_ext.cy >= 0) ? 1 : -1;
107 dc->attr->vport_ext.cy = GDI_ROUND( dc->attr->vport_ext.cy * xdim / ydim );
108 if (!dc->attr->vport_ext.cy) dc->attr->vport_ext.cy = mincy;
109 }
110 }
111
112
113 BOOL set_map_mode( DC *dc, int mode )
114 {
115 SIZE virtual_size, virtual_res;
116
117 if (mode == dc->attr->map_mode && (mode == MM_ISOTROPIC || mode == MM_ANISOTROPIC))
118 return TRUE;
119
120 switch (mode)
121 {
122 case MM_TEXT:
123 dc->attr->wnd_ext.cx = 1;
124 dc->attr->wnd_ext.cy = 1;
125 dc->attr->vport_ext.cx = 1;
126 dc->attr->vport_ext.cy = 1;
127 break;
128 case MM_LOMETRIC:
129 case MM_ISOTROPIC:
130 virtual_size = get_dc_virtual_size( dc );
131 virtual_res = get_dc_virtual_res( dc );
132 dc->attr->wnd_ext.cx = virtual_size.cx * 10;
133 dc->attr->wnd_ext.cy = virtual_size.cy * 10;
134 dc->attr->vport_ext.cx = virtual_res.cx;
135 dc->attr->vport_ext.cy = -virtual_res.cy;
136 break;
137 case MM_HIMETRIC:
138 virtual_size = get_dc_virtual_size( dc );
139 virtual_res = get_dc_virtual_res( dc );
140 dc->attr->wnd_ext.cx = virtual_size.cx * 100;
141 dc->attr->wnd_ext.cy = virtual_size.cy * 100;
142 dc->attr->vport_ext.cx = virtual_res.cx;
143 dc->attr->vport_ext.cy = -virtual_res.cy;
144 break;
145 case MM_LOENGLISH:
146 virtual_size = get_dc_virtual_size( dc );
147 virtual_res = get_dc_virtual_res( dc );
148 dc->attr->wnd_ext.cx = muldiv(1000, virtual_size.cx, 254);
149 dc->attr->wnd_ext.cy = muldiv(1000, virtual_size.cy, 254);
150 dc->attr->vport_ext.cx = virtual_res.cx;
151 dc->attr->vport_ext.cy = -virtual_res.cy;
152 break;
153 case MM_HIENGLISH:
154 virtual_size = get_dc_virtual_size( dc );
155 virtual_res = get_dc_virtual_res( dc );
156 dc->attr->wnd_ext.cx = muldiv(10000, virtual_size.cx, 254);
157 dc->attr->wnd_ext.cy = muldiv(10000, virtual_size.cy, 254);
158 dc->attr->vport_ext.cx = virtual_res.cx;
159 dc->attr->vport_ext.cy = -virtual_res.cy;
160 break;
161 case MM_TWIPS:
162 virtual_size = get_dc_virtual_size( dc );
163 virtual_res = get_dc_virtual_res( dc );
164 dc->attr->wnd_ext.cx = muldiv(14400, virtual_size.cx, 254);
165 dc->attr->wnd_ext.cy = muldiv(14400, virtual_size.cy, 254);
166 dc->attr->vport_ext.cx = virtual_res.cx;
167 dc->attr->vport_ext.cy = -virtual_res.cy;
168 break;
169 case MM_ANISOTROPIC:
170 break;
171 default:
172 return FALSE;
173 }
174 /* RTL layout is always MM_ANISOTROPIC */
175 if (!(dc->attr->layout & LAYOUT_RTL)) dc->attr->map_mode = mode;
176 DC_UpdateXforms( dc );
177 return TRUE;
178 }
179
180 /***********************************************************************
181 * dp_to_lp
182 *
183 * Internal version of DPtoLP that takes a DC *.
184 */
185 BOOL dp_to_lp( DC *dc, POINT *points, INT count )
186 {
187 if (dc->vport2WorldValid)
188 {
189 while (count--)
190 {
191 double x = points->x;
192 double y = points->y;
193 points->x = GDI_ROUND( x * dc->xformVport2World.eM11 +
194 y * dc->xformVport2World.eM21 +
195 dc->xformVport2World.eDx );
196 points->y = GDI_ROUND( x * dc->xformVport2World.eM12 +
197 y * dc->xformVport2World.eM22 +
198 dc->xformVport2World.eDy );
199 points++;
200 }
201 }
202 return (count < 0);
203 }
204
205 /***********************************************************************
206 * NtGdiTransformPoints (win32u.@)
207 */
208 BOOL WINAPI NtGdiTransformPoints( HDC hdc, const POINT *points_in, POINT *points_out,
209 INT count, UINT mode )
210 {
211 DC *dc = get_dc_ptr( hdc );
212 int i = 0;
213 BOOL ret = FALSE;
214
215 if (!dc) return FALSE;
216
217 switch (mode)
218 {
219 case NtGdiLPtoDP:
220 for (i = 0; i < count; i++)
221 {
222 double x = points_in[i].x;
223 double y = points_in[i].y;
224 points_out[i].x = GDI_ROUND( x * dc->xformWorld2Vport.eM11 +
225 y * dc->xformWorld2Vport.eM21 +
226 dc->xformWorld2Vport.eDx );
227 points_out[i].y = GDI_ROUND( x * dc->xformWorld2Vport.eM12 +
228 y * dc->xformWorld2Vport.eM22 +
229 dc->xformWorld2Vport.eDy );
230 }
231 ret = TRUE;
232 break;
233
234 case NtGdiDPtoLP:
235 if (!dc->vport2WorldValid) break;
236 for (i = 0; i < count; i++)
237 {
238 double x = points_in[i].x;
239 double y = points_in[i].y;
240 points_out[i].x = GDI_ROUND( x * dc->xformVport2World.eM11 +
241 y * dc->xformVport2World.eM21 +
242 dc->xformVport2World.eDx );
243 points_out[i].y = GDI_ROUND( x * dc->xformVport2World.eM12 +
244 y * dc->xformVport2World.eM22 +
245 dc->xformVport2World.eDy );
246 }
247 ret = TRUE;
248 break;
249
250 default:
251 WARN( "invalid mode %x\n", mode );
252 break;
253 }
254
255 release_dc_ptr( dc );
256 return ret;
257 }
258
259
260 /***********************************************************************
261 * lp_to_dp
262 *
263 * Internal version of LPtoDP that takes a DC *.
264 */
265 void lp_to_dp( DC *dc, POINT *points, INT count )
266 {
267 while (count--)
268 {
269 double x = points->x;
270 double y = points->y;
271 points->x = GDI_ROUND( x * dc->xformWorld2Vport.eM11 +
272 y * dc->xformWorld2Vport.eM21 +
273 dc->xformWorld2Vport.eDx );
274 points->y = GDI_ROUND( x * dc->xformWorld2Vport.eM12 +
275 y * dc->xformWorld2Vport.eM22 +
276 dc->xformWorld2Vport.eDy );
277 points++;
278 }
279 }
280
281
282 /***********************************************************************
283 * NtGdiComputeXformCoefficients (win32u.@)
284 */
285 BOOL WINAPI NtGdiComputeXformCoefficients( HDC hdc )
286 {
287 DC *dc;
288
289 if (!(dc = get_dc_ptr( hdc ))) return FALSE;
290 if (dc->attr->map_mode == MM_ISOTROPIC) MAPPING_FixIsotropic( dc );
291 DC_UpdateXforms( dc );
292 release_dc_ptr( dc );
293 return TRUE;
294 }
295
296
297 /***********************************************************************
298 * NtGdiScaleViewportExtEx (win32u.@)
299 */
300 BOOL WINAPI NtGdiScaleViewportExtEx( HDC hdc, INT x_num, INT x_denom,
301 INT y_num, INT y_denom, SIZE *size )
302 {
303 DC *dc;
304
305 if ((!(dc = get_dc_ptr( hdc )))) return FALSE;
306
307 if (size) *size = dc->attr->vport_ext;
308
309 if (dc->attr->map_mode == MM_ISOTROPIC || dc->attr->map_mode == MM_ANISOTROPIC)
310 {
311 if (!x_num || !x_denom || !y_num || !y_denom)
312 {
313 release_dc_ptr( dc );
314 return FALSE;
315 }
316
317 dc->attr->vport_ext.cx = (dc->attr->vport_ext.cx * x_num) / x_denom;
318 dc->attr->vport_ext.cy = (dc->attr->vport_ext.cy * y_num) / y_denom;
319 if (dc->attr->vport_ext.cx == 0) dc->attr->vport_ext.cx = 1;
320 if (dc->attr->vport_ext.cy == 0) dc->attr->vport_ext.cy = 1;
321 if (dc->attr->map_mode == MM_ISOTROPIC) MAPPING_FixIsotropic( dc );
322 DC_UpdateXforms( dc );
323 }
324
325 release_dc_ptr( dc );
326 return TRUE;
327 }
328
329
330 /***********************************************************************
331 * NtGdiScaleWindowExtEx (win32u.@)
332 */
333 BOOL WINAPI NtGdiScaleWindowExtEx( HDC hdc, INT x_num, INT x_denom,
334 INT y_num, INT y_denom, SIZE *size )
335 {
336 DC *dc;
337
338 if ((!(dc = get_dc_ptr( hdc )))) return FALSE;
339
340 if (size) *size = dc->attr->wnd_ext;
341
342 if (dc->attr->map_mode == MM_ISOTROPIC || dc->attr->map_mode == MM_ANISOTROPIC)
343 {
344 if (!x_num || !x_denom || !y_num || !y_denom)
345 {
346 release_dc_ptr( dc );
347 return FALSE;
348 }
349
350 dc->attr->wnd_ext.cx = (dc->attr->wnd_ext.cx * x_num) / x_denom;
351 dc->attr->wnd_ext.cy = (dc->attr->wnd_ext.cy * y_num) / y_denom;
352 if (dc->attr->wnd_ext.cx == 0) dc->attr->wnd_ext.cx = 1;
353 if (dc->attr->wnd_ext.cy == 0) dc->attr->wnd_ext.cy = 1;
354 if (dc->attr->map_mode == MM_ISOTROPIC) MAPPING_FixIsotropic( dc );
355 DC_UpdateXforms( dc );
356 }
357
358 release_dc_ptr( dc );
359 return TRUE;
360 }
361
362
363 /****************************************************************************
364 * NtGdiModifyWorldTransform (win32u.@)
365 */
366 BOOL WINAPI NtGdiModifyWorldTransform( HDC hdc, const XFORM *xform, DWORD mode )
367 {
368 BOOL ret = FALSE;
369 DC *dc;
370
371 if (!xform && mode != MWT_IDENTITY) return FALSE;
372 if ((dc = get_dc_ptr( hdc )))
373 {
374 switch (mode)
375 {
376 case MWT_IDENTITY:
377 dc->xformWorld2Wnd.eM11 = 1.0f;
378 dc->xformWorld2Wnd.eM12 = 0.0f;
379 dc->xformWorld2Wnd.eM21 = 0.0f;
380 dc->xformWorld2Wnd.eM22 = 1.0f;
381 dc->xformWorld2Wnd.eDx = 0.0f;
382 dc->xformWorld2Wnd.eDy = 0.0f;
383 ret = TRUE;
384 break;
385 case MWT_LEFTMULTIPLY:
386 combine_transform( &dc->xformWorld2Wnd, xform, &dc->xformWorld2Wnd );
387 ret = TRUE;
388 break;
389 case MWT_RIGHTMULTIPLY:
390 combine_transform( &dc->xformWorld2Wnd, &dc->xformWorld2Wnd, xform );
391 ret = TRUE;
392 break;
393 case MWT_SET:
394 ret = dc->attr->graphics_mode == GM_ADVANCED &&
395 xform->eM11 * xform->eM22 != xform->eM12 * xform->eM21;
396 if (ret) dc->xformWorld2Wnd = *xform;
397 break;
398 }
399 if (ret) DC_UpdateXforms( dc );
400 release_dc_ptr( dc );
401 }
402 return ret;
403 }
404
405
406 /***********************************************************************
407 * NtGdiSetVirtualResolution (win32u.@)
408 *
409 * Undocumented on msdn.
410 *
411 * Changes the values of screen size in pixels and millimeters used by
412 * the mapping mode functions.
413 *
414 * PARAMS
415 * hdc [I] Device context
416 * horz_res [I] Width in pixels (equivalent to HORZRES device cap).
417 * vert_res [I] Height in pixels (equivalent to VERTRES device cap).
418 * horz_size [I] Width in mm (equivalent to HORZSIZE device cap).
419 * vert_size [I] Height in mm (equivalent to VERTSIZE device cap).
420 *
421 * RETURNS
422 * TRUE if successful.
423 * FALSE if any (but not all) of the last four params are zero.
424 *
425 * NOTES
426 * This doesn't change the values returned by NtGdiGetDeviceCaps, just the
427 * scaling of the mapping modes.
428 *
429 * Calling with the last four params equal to zero sets the values
430 * back to their defaults obtained by calls to NtGdiGetDeviceCaps.
431 */
432 BOOL WINAPI NtGdiSetVirtualResolution( HDC hdc, DWORD horz_res, DWORD vert_res,
433 DWORD horz_size, DWORD vert_size )
434 {
435 DC * dc;
436 TRACE("(%p %d %d %d %d)\n", hdc, (int)horz_res, (int)vert_res, (int)horz_size, (int)vert_size);
437
438 if (!horz_res || !vert_res || !horz_size || !vert_size)
439 {
440 /* they must be all zero */
441 if (horz_res || vert_res || horz_size || vert_size) return FALSE;
442 }
443
444 dc = get_dc_ptr( hdc );
445 if (!dc) return FALSE;
446
447 dc->attr->virtual_res.cx = horz_res;
448 dc->attr->virtual_res.cy = vert_res;
449 dc->attr->virtual_size.cx = horz_size;
450 dc->attr->virtual_size.cy = vert_size;
451
452 release_dc_ptr( dc );
453 return TRUE;
454 }
455
456 void combine_transform( XFORM *result, const XFORM *xform1, const XFORM *xform2 )
457 {
458 XFORM r;
459
460 /* Create the result in a temporary XFORM, since result may be
461 * equal to xform1 or xform2 */
462 r.eM11 = xform1->eM11 * xform2->eM11 + xform1->eM12 * xform2->eM21;
463 r.eM12 = xform1->eM11 * xform2->eM12 + xform1->eM12 * xform2->eM22;
464 r.eM21 = xform1->eM21 * xform2->eM11 + xform1->eM22 * xform2->eM21;
465 r.eM22 = xform1->eM21 * xform2->eM12 + xform1->eM22 * xform2->eM22;
466 r.eDx = xform1->eDx * xform2->eM11 + xform1->eDy * xform2->eM21 + xform2->eDx;
467 r.eDy = xform1->eDx * xform2->eM12 + xform1->eDy * xform2->eM22 + xform2->eDy;
468
469 *result = r;
470 }
Windows API implementation