[GDI32]
[reactos.git] / reactos / win32ss / gdi / gdi32 / objects / coord.c
1 /*
2 * COPYRIGHT: See COPYING in the top level directory
3 * PROJECT: ReactOS System Libraries
4 * FILE: dll/gdi32/objects/coord.c
5 * PURPOSE: Functions for coordinate transformation
6 * PROGRAMMER:
7 */
8 #include <precomp.h>
9
10 /* Currently we use a MATRIX inside the DC_ATTR containing the
11 coordinate transformations, while we deal with XFORM structures
12 internally. If we move all coordinate transformation to gdi32,
13 we might as well have an XFORM structure in the DC_ATTR. */
14 void
15 MatrixToXForm(XFORM *pxform, const MATRIX *pmx)
16 {
17 XFORML *pxforml = (XFORML*)pxform;
18 pxforml->eM11 = FOtoF(&pmx->efM11);
19 pxforml->eM12 = FOtoF(&pmx->efM12);
20 pxforml->eM21 = FOtoF(&pmx->efM21);
21 pxforml->eM22 = FOtoF(&pmx->efM22);
22 pxforml->eDx = FOtoF(&pmx->efDx);
23 pxforml->eDy = FOtoF(&pmx->efDy);
24 }
25
26 void
27 GdiTransformPoints2(
28 _In_ XFORM *pxform,
29 _Out_writes_(nCount) PPOINT pptOut,
30 _In_reads_(nCount) PPOINT pptIn,
31 _In_ ULONG nCount)
32 {
33 ULONG i;
34 FLOAT x, y;
35
36 for (i = 0; i < nCount; i++)
37 {
38 x = pptIn[i].x * pxform->eM11 + pptIn[i].y * pxform->eM12 + pxform->eDx;
39 pptOut[i].x = _lrintf(x);
40 y = pptIn[i].x * pxform->eM21 + pptIn[i].y * pxform->eM22 + pxform->eDy;
41 pptOut[i].y = _lrintf(y);
42 }
43 }
44
45 FORCEINLINE
46 void
47 GdiTransformPoints(
48 _In_ MATRIX *pmx,
49 _Out_writes_(nCount) PPOINT pptOut,
50 _In_reads_(nCount) PPOINT pptIn,
51 _In_ ULONG nCount)
52 {
53 XFORM xform;
54
55 MatrixToXForm(&xform, pmx);
56 GdiTransformPoints2(&xform, pptOut, pptIn, nCount);
57 }
58
59 #define MAX_OFFSET 4294967041.0
60 #define _fmul(x,y) (((x) == 0) ? 0 : (x) * (y))
61
62 BOOL
63 WINAPI
64 CombineTransform(
65 _Out_ LPXFORM pxfResult,
66 _In_ const XFORM *pxf1,
67 _In_ const XFORM *pxf2)
68 {
69 XFORM xformTmp;
70
71 /* Check paramters */
72 if (!pxfResult || !pxf1 || !pxf2) return FALSE;
73
74 /* Do matrix multiplication, start with scaling elements */
75 xformTmp.eM11 = (pxf1->eM11 * pxf2->eM11) + (pxf1->eM12 * pxf2->eM21);
76 xformTmp.eM22 = (pxf1->eM21 * pxf2->eM12) + (pxf1->eM22 * pxf2->eM22);
77
78 /* Calculate shear/rotate elements only of they are present */
79 if ((pxf1->eM12 != 0.) || (pxf1->eM21 != 0.) ||
80 (pxf2->eM12 != 0.) || (pxf2->eM21 != 0.))
81 {
82 xformTmp.eM12 = (pxf1->eM11 * pxf2->eM12) + (pxf1->eM12 * pxf2->eM22);
83 xformTmp.eM21 = (pxf1->eM21 * pxf2->eM11) + (pxf1->eM22 * pxf2->eM21);
84 }
85 else
86 {
87 xformTmp.eM12 = 0.;
88 xformTmp.eM21 = 0.;
89 }
90
91 /* Calculate the offset */
92 xformTmp.eDx = _fmul(pxf1->eDx, pxf2->eM11) + _fmul(pxf1->eDy, pxf2->eM21) + pxf2->eDx;
93 xformTmp.eDy = _fmul(pxf1->eDx, pxf2->eM12) + _fmul(pxf1->eDy, pxf2->eM22) + pxf2->eDy;
94
95 /* Check for invalid offset ranges */
96 if ((xformTmp.eDx > MAX_OFFSET) || (xformTmp.eDx < -MAX_OFFSET) ||
97 (xformTmp.eDy > MAX_OFFSET) || (xformTmp.eDy < -MAX_OFFSET))
98 {
99 return FALSE;
100 }
101
102 /* All is ok, return the calculated values */
103 *pxfResult = xformTmp;
104 return TRUE;
105 }
106
107
108 /*
109 * @implemented
110 *
111 */
112 int
113 WINAPI
114 GetMapMode(
115 _In_ HDC hdc)
116 {
117 PDC_ATTR pdcattr;
118
119 /* Get the DC attribute */
120 pdcattr = GdiGetDcAttr(hdc);
121 if (pdcattr == NULL)
122 {
123 SetLastError(ERROR_INVALID_PARAMETER);
124 return 0;
125 }
126
127 /* Return the map mode */
128 return pdcattr->iMapMode;
129 }
130
131 /*
132 * @implemented
133 */
134 INT
135 WINAPI
136 SetMapMode(
137 _In_ HDC hdc,
138 _In_ INT iMode)
139 {
140 PDC_ATTR pdcattr;
141
142 /* Get the DC attribute */
143 pdcattr = GdiGetDcAttr(hdc);
144 if (pdcattr == NULL)
145 {
146 SetLastError(ERROR_INVALID_PARAMETER);
147 return 0;
148 }
149
150 #if 0
151 if (GDI_HANDLE_GET_TYPE(hdc) != GDI_OBJECT_TYPE_DC)
152 {
153 if (GDI_HANDLE_GET_TYPE(hdc) == GDI_OBJECT_TYPE_METADC)
154 return MFDRV_SetMapMode(hdc, iMode);
155 else
156 {
157 SetLastError(ERROR_INVALID_HANDLE);
158 return 0;
159 }
160 }
161 #endif
162
163 /* Force change if Isotropic is set for recompute. */
164 if ((iMode != pdcattr->iMapMode) || (iMode == MM_ISOTROPIC))
165 {
166 pdcattr->ulDirty_ &= ~SLOW_WIDTHS;
167 return GetAndSetDCDWord(hdc, GdiGetSetMapMode, iMode, 0, 0, 0);
168 }
169
170 /* Simply return the old mode, which equals the new mode */
171 return pdcattr->iMapMode;
172 }
173
174
175 BOOL
176 WINAPI
177 DPtoLP(
178 _In_ HDC hdc,
179 _Inout_updates_(nCount) LPPOINT lpPoints,
180 _In_ INT nCount)
181 {
182 #if 0
183 INT i;
184 PDC_ATTR pdcattr;
185
186 /* Get the DC attribute */
187 pdcattr = GdiGetDcAttr(hdc);
188 if (!pdcattr)
189 {
190 SetLastError(ERROR_INVALID_PARAMETER);
191 return FALSE;
192 }
193
194 if (pdcattr->flXform & ANY_XFORM_CHANGES)
195 {
196 GdiFixupTransforms(pdcattr);
197 }
198
199 // FIXME: can this fail on Windows?
200 GdiTransformPoints(&pdcattr->mxDeviceToWorld, lpPoints, lpPoints, nCount);
201
202 return TRUE;
203 #endif
204 return NtGdiTransformPoints(hdc, lpPoints, lpPoints, nCount, GdiDpToLp);
205 }
206
207 BOOL
208 WINAPI
209 LPtoDP(
210 _In_ HDC hdc,
211 _Inout_updates_(nCount) LPPOINT lpPoints,
212 _In_ INT nCount)
213 {
214 #if 0
215 INT i;
216 PDC_ATTR pdcattr;
217
218 /* Get the DC attribute */
219 pdcattr = GdiGetDcAttr(hdc);
220 if (!pdcattr)
221 {
222 SetLastError(ERROR_INVALID_PARAMETER);
223 return FALSE;
224 }
225
226 if (pdcattr->flXform & ANY_XFORM_CHANGES)
227 {
228 GdiFixupTransforms(pdcattr);
229 }
230
231 // FIXME: can this fail on Windows?
232 GdiTransformPoints(&pdcattr->mxWorldToDevice, lpPoints, lpPoints, nCount);
233
234 return TRUE;
235 #endif
236 return NtGdiTransformPoints(hdc, lpPoints, lpPoints, nCount, GdiLpToDp);
237 }
238
239 /*
240 * @implemented
241 *
242 */
243 BOOL
244 WINAPI
245 GetCurrentPositionEx(
246 _In_ HDC hdc,
247 _Out_ LPPOINT lpPoint)
248 {
249 PDC_ATTR pdcattr;
250
251 /* Get the DC attribute */
252 pdcattr = GdiGetDcAttr(hdc);
253 if ((pdcattr == NULL) || (lpPoint == NULL))
254 {
255 SetLastError(ERROR_INVALID_PARAMETER);
256 return FALSE;
257 }
258
259 if (pdcattr->ulDirty_ & DIRTY_PTLCURRENT) // have a hit!
260 {
261 lpPoint->x = pdcattr->ptfxCurrent.x;
262 lpPoint->y = pdcattr->ptfxCurrent.y;
263 DPtoLP(hdc, lpPoint, 1); // reconvert back.
264 pdcattr->ptlCurrent.x = lpPoint->x; // save it
265 pdcattr->ptlCurrent.y = lpPoint->y;
266 pdcattr->ulDirty_ &= ~DIRTY_PTLCURRENT; // clear bit
267 }
268 else
269 {
270 lpPoint->x = pdcattr->ptlCurrent.x;
271 lpPoint->y = pdcattr->ptlCurrent.y;
272 }
273
274 return TRUE;
275 }
276
277 /*
278 * @implemented
279 */
280 BOOL
281 WINAPI
282 GetWorldTransform(
283 _In_ HDC hdc,
284 _Out_ LPXFORM pxform)
285 {
286 #if 0
287 PDC_ATTR pdcattr;
288
289 pdcattr = GdiGetDcAttr(hdc);
290 if (!pdcattr)
291 {
292 SetLastError(ERROR_INVALID_HANDLE);
293 return FALSE;
294 }
295
296 if (pdcattr->flXform & ANY_XFORM_INVALID)
297 {
298 GdiFixupTransforms(pdcattr);
299 }
300
301 MatrixToXForm(pxform, &pdcattr->mxWorldToDevice);
302 #endif
303 return NtGdiGetTransform(hdc, GdiWorldSpaceToPageSpace, pxform);
304 }
305
306
307 BOOL
308 WINAPI
309 SetWorldTransform(
310 _In_ HDC hdc,
311 _Out_ CONST XFORM *pxform)
312 {
313 /* FIXME shall we add undoc #define MWT_SETXFORM 4 ?? */
314 return ModifyWorldTransform(hdc, pxform, MWT_MAX+1);
315 }
316
317
318 BOOL
319 WINAPI
320 ModifyWorldTransform(
321 _In_ HDC hdc,
322 _In_opt_ CONST XFORM *pxform,
323 _In_ DWORD dwMode)
324 {
325 PDC_ATTR pdcattr;
326
327 #if 0
328 // Handle something other than a normal dc object.
329 if (GDI_HANDLE_GET_TYPE(hdc) != GDI_OBJECT_TYPE_DC)
330 {
331 if (GDI_HANDLE_GET_TYPE(hdc) == GDI_OBJECT_TYPE_METADC)
332 return FALSE;
333 else
334 {
335 PLDC pLDC = GdiGetLDC(hdc);
336 if ( !pLDC )
337 {
338 SetLastError(ERROR_INVALID_HANDLE);
339 return FALSE;
340 }
341 if (pLDC->iType == LDC_EMFLDC)
342 {
343 if (dwMode == MWT_MAX+1)
344 if (!EMFDRV_SetWorldTransform(hdc, pxform) ) return FALSE;
345 return EMFDRV_ModifyWorldTransform(hdc, pxform, dwMode); // Ported from wine.
346 }
347 return FALSE;
348 }
349 }
350 #endif
351
352 /* Get the DC attribute */
353 pdcattr = GdiGetDcAttr(hdc);
354 if (pdcattr == NULL)
355 {
356 SetLastError(ERROR_INVALID_PARAMETER);
357 return FALSE;
358 }
359
360 /* Check that graphics mode is GM_ADVANCED */
361 if (pdcattr->iGraphicsMode != GM_ADVANCED)
362 return FALSE;
363
364 /* Call win32k to do the work */
365 return NtGdiModifyWorldTransform(hdc, (LPXFORM)pxform, dwMode);
366 }
367
368 BOOL
369 WINAPI
370 GetViewportExtEx(
371 _In_ HDC hdc,
372 _Out_ LPSIZE lpSize)
373 {
374 PDC_ATTR pdcattr;
375
376 /* Get the DC attribute */
377 pdcattr = GdiGetDcAttr(hdc);
378 if (pdcattr == NULL)
379 {
380 /* Do not set LastError here! */
381 return FALSE;
382 }
383
384 /* Check if we need to update values */
385 if ((pdcattr->flXform & PAGE_EXTENTS_CHANGED) &&
386 (pdcattr->iMapMode == MM_ISOTROPIC))
387 {
388 /* Call win32k to do the work */
389 return NtGdiGetDCPoint(hdc, GdiGetViewPortExt, (PPOINTL)lpSize);
390 }
391
392 /* Nothing to calculate, return the current extension */
393 lpSize->cx = pdcattr->szlViewportExt.cx;
394 lpSize->cy = pdcattr->szlViewportExt.cy;
395
396 return TRUE;
397 }
398
399
400 BOOL
401 WINAPI
402 GetViewportOrgEx(
403 _In_ HDC hdc,
404 _Out_ LPPOINT lpPoint)
405 {
406 PDC_ATTR pdcattr;
407
408 /* Get the DC attribute */
409 pdcattr = GdiGetDcAttr(hdc);
410 if (pdcattr == NULL)
411 {
412 /* Do not set LastError here! */
413 return FALSE;
414 }
415
416 /* Get the current viewport org */
417 lpPoint->x = pdcattr->ptlViewportOrg.x;
418 lpPoint->y = pdcattr->ptlViewportOrg.y;
419
420 /* Handle right-to-left layout */
421 if (pdcattr->dwLayout & LAYOUT_RTL)
422 lpPoint->x = -lpPoint->x;
423
424 return TRUE;
425 }
426
427
428 BOOL
429 WINAPI
430 GetWindowExtEx(
431 _In_ HDC hdc,
432 _Out_ LPSIZE lpSize)
433 {
434 PDC_ATTR pdcattr;
435
436 /* Get the DC attribute */
437 pdcattr = GdiGetDcAttr(hdc);
438 if (pdcattr == NULL)
439 {
440 /* Do not set LastError here! */
441 return FALSE;
442 }
443
444 /* Get the current window extension */
445 lpSize->cx = pdcattr->szlWindowExt.cx;
446 lpSize->cy = pdcattr->szlWindowExt.cy;
447
448 /* Handle right-to-left layout */
449 if (pdcattr->dwLayout & LAYOUT_RTL)
450 lpSize->cx = -lpSize->cx;
451
452 return TRUE;
453 }
454
455
456 BOOL
457 WINAPI
458 GetWindowOrgEx(
459 _In_ HDC hdc,
460 _Out_ LPPOINT lpPoint)
461 {
462 PDC_ATTR pdcattr;
463
464 /* Get the DC attribute */
465 pdcattr = GdiGetDcAttr(hdc);
466 if (pdcattr == NULL)
467 {
468 /* Do not set LastError here! */
469 return FALSE;
470 }
471
472 /* Get the current window origin */
473 lpPoint->x = pdcattr->ptlWindowOrg.x;
474 lpPoint->y = pdcattr->ptlWindowOrg.y;
475
476 return TRUE;
477 }
478
479 /*
480 * @unimplemented
481 */
482 BOOL
483 WINAPI
484 SetViewportExtEx(
485 _In_ HDC hdc,
486 _In_ int nXExtent,
487 _In_ int nYExtent,
488 _Out_opt_ LPSIZE lpSize)
489 {
490 PDC_ATTR pdcattr;
491 #if 0
492 if (GDI_HANDLE_GET_TYPE(hdc) != GDI_OBJECT_TYPE_DC)
493 {
494 if (GDI_HANDLE_GET_TYPE(hdc) == GDI_OBJECT_TYPE_METADC)
495 return MFDRV_SetViewportExtEx();
496 else
497 {
498 PLDC pLDC = GdiGetLDC(hdc);
499 if ( !pLDC )
500 {
501 SetLastError(ERROR_INVALID_HANDLE);
502 return FALSE;
503 }
504 if (pLDC->iType == LDC_EMFLDC)
505 {
506 return EMFDRV_SetViewportExtEx();
507 }
508 }
509 }
510 #endif
511
512 /* Get the DC attribute */
513 pdcattr = GdiGetDcAttr(hdc);
514 if (pdcattr == NULL)
515 {
516 SetLastError(ERROR_INVALID_PARAMETER);
517 return FALSE;
518 }
519
520 /* Check if the caller wants the old extension */
521 if (lpSize)
522 {
523 /* Return the current viewport extension */
524 lpSize->cx = pdcattr->szlViewportExt.cx;
525 lpSize->cy = pdcattr->szlViewportExt.cy;
526 }
527
528 /* Check for trivial case */
529 if ((pdcattr->szlViewportExt.cx == nXExtent) &&
530 (pdcattr->szlViewportExt.cy == nYExtent))
531 return TRUE;
532
533 /* Only change viewport extension if we are in iso or aniso mode */
534 if ((pdcattr->iMapMode == MM_ISOTROPIC) ||
535 (pdcattr->iMapMode == MM_ANISOTROPIC))
536 {
537 if (NtCurrentTeb()->GdiTebBatch.HDC == hdc)
538 {
539 if (pdcattr->ulDirty_ & DC_FONTTEXT_DIRTY)
540 {
541 NtGdiFlush(); // Sync up pdcattr from Kernel space.
542 pdcattr->ulDirty_ &= ~(DC_MODE_DIRTY|DC_FONTTEXT_DIRTY);
543 }
544 }
545
546 /* Set the new viewport extension */
547 pdcattr->szlViewportExt.cx = nXExtent;
548 pdcattr->szlViewportExt.cy = nYExtent;
549
550 /* Handle right-to-left layout */
551 if (pdcattr->dwLayout & LAYOUT_RTL)
552 NtGdiMirrorWindowOrg(hdc);
553
554 /* Update xform flags */
555 pdcattr->flXform |= (PAGE_EXTENTS_CHANGED|INVALIDATE_ATTRIBUTES|DEVICE_TO_WORLD_INVALID);
556 }
557
558 return TRUE;
559 }
560
561 /*
562 * @unimplemented
563 */
564 BOOL
565 WINAPI
566 SetWindowOrgEx(
567 _In_ HDC hdc,
568 _In_ int X,
569 _In_ int Y,
570 _Out_opt_ LPPOINT lpPoint)
571 {
572 #if 0
573 PDC_ATTR pdcattr;
574 #if 0
575 if (GDI_HANDLE_GET_TYPE(hdc) != GDI_OBJECT_TYPE_DC)
576 {
577 if (GDI_HANDLE_GET_TYPE(hdc) == GDI_OBJECT_TYPE_METADC)
578 return MFDRV_SetWindowOrgEx();
579 else
580 {
581 PLDC pLDC = GdiGetLDC(hdc);
582 if ( !pLDC )
583 {
584 SetLastError(ERROR_INVALID_HANDLE);
585 return FALSE;
586 }
587 if (pLDC->iType == LDC_EMFLDC)
588 {
589 return EMFDRV_SetWindowOrgEx();
590 }
591 }
592 }
593 #endif
594 /* Get the DC attribute */
595 pdcattr = GdiGetDcAttr(hdc);
596 if (pdcattr == NULL)
597 {
598 /* Do not set LastError here! */
599 return FALSE;
600 }
601
602 if (lpPoint)
603 {
604 lpPoint->x = pdcattr->ptlWindowOrg.x;
605 lpPoint->y = pdcattr->ptlWindowOrg.y;
606 }
607
608 if ((pdcattr->ptlWindowOrg.x == X) && (pdcattr->ptlWindowOrg.y == Y))
609 return TRUE;
610
611 if (NtCurrentTeb()->GdiTebBatch.HDC == (ULONG)hdc)
612 {
613 if (pdcattr->ulDirty_ & DC_FONTTEXT_DIRTY)
614 {
615 NtGdiFlush(); // Sync up pdcattr from Kernel space.
616 pdcattr->ulDirty_ &= ~(DC_MODE_DIRTY|DC_FONTTEXT_DIRTY);
617 }
618 }
619
620 pdcattr->ptlWindowOrg.x = X;
621 pdcattr->lWindowOrgx = X;
622 pdcattr->ptlWindowOrg.y = Y;
623 if (pdcattr->dwLayout & LAYOUT_RTL) NtGdiMirrorWindowOrg(hdc);
624 pdcattr->flXform |= (PAGE_XLATE_CHANGED|DEVICE_TO_WORLD_INVALID);
625 return TRUE;
626 #endif
627 return NtGdiSetWindowOrgEx(hdc,X,Y,lpPoint);
628 }
629
630 /*
631 * @unimplemented
632 */
633 BOOL
634 WINAPI
635 SetWindowExtEx(
636 _In_ HDC hdc,
637 _In_ INT nXExtent,
638 _In_ INT nYExtent,
639 _Out_opt_ LPSIZE lpSize)
640 {
641 PDC_ATTR pdcattr;
642 ULONG ulType;
643
644 /* Check what type of DC that is */
645 ulType = GDI_HANDLE_GET_TYPE(hdc);
646 switch (ulType)
647 {
648 case GDILoObjType_LO_ALTDC_TYPE:
649 case GDILoObjType_LO_DC_TYPE:
650 /* Handle this in the path below */
651 break;
652 #if 0// FIXME: we don't support this
653 case GDILoObjType_LO_METADC16_TYPE:
654 return MFDRV_SetWindowExtEx(hdc, nXExtent, nYExtent, lpSize);
655
656 case GDILoObjType_LO_METAFILE_TYPE:
657 return EMFDRV_SetWindowExtEx(hdc, nXExtent, nYExtent, lpSize);
658 #endif
659 default:
660 /* Other types are not allowed */
661 SetLastError(ERROR_INVALID_HANDLE);
662 return FALSE;
663 }
664
665 /* Get the DC attr */
666 pdcattr = GdiGetDcAttr(hdc);
667 if (!pdcattr)
668 {
669 /* Set the error value and return failure */
670 SetLastError(ERROR_INVALID_PARAMETER);
671 return FALSE;
672 }
673
674 /* Check if the caller wants the old extension */
675 if (lpSize)
676 {
677 /* Return the current window extension */
678 lpSize->cx = pdcattr->szlWindowExt.cx;
679 lpSize->cy = pdcattr->szlWindowExt.cy;
680
681 /* Handle right-to-left layout */
682 if (pdcattr->dwLayout & LAYOUT_RTL)
683 lpSize->cx = -lpSize->cx;
684 }
685
686 if (pdcattr->dwLayout & LAYOUT_RTL)
687 {
688 NtGdiMirrorWindowOrg(hdc);
689 pdcattr->flXform |= (PAGE_EXTENTS_CHANGED|INVALIDATE_ATTRIBUTES|DEVICE_TO_WORLD_INVALID);
690 }
691 else if ((pdcattr->iMapMode == MM_ISOTROPIC) ||
692 (pdcattr->iMapMode == MM_ANISOTROPIC))
693 {
694 if ((pdcattr->szlWindowExt.cx == nXExtent) &&
695 (pdcattr->szlWindowExt.cy == nYExtent))
696 return TRUE;
697
698 if ((!nXExtent) || (!nYExtent))
699 return FALSE;
700
701 if (NtCurrentTeb()->GdiTebBatch.HDC == hdc)
702 {
703 if (pdcattr->ulDirty_ & DC_FONTTEXT_DIRTY)
704 {
705 NtGdiFlush(); // Sync up Dc_Attr from Kernel space.
706 pdcattr->ulDirty_ &= ~(DC_MODE_DIRTY|DC_FONTTEXT_DIRTY);
707 }
708 }
709
710 pdcattr->szlWindowExt.cx = nXExtent;
711 pdcattr->szlWindowExt.cy = nYExtent;
712 if (pdcattr->dwLayout & LAYOUT_RTL)
713 NtGdiMirrorWindowOrg(hdc);
714
715 pdcattr->flXform |= (PAGE_EXTENTS_CHANGED|INVALIDATE_ATTRIBUTES|DEVICE_TO_WORLD_INVALID);
716 }
717
718 return TRUE;
719 }
720
721 /*
722 * @unimplemented
723 */
724 BOOL
725 WINAPI
726 SetViewportOrgEx(
727 _In_ HDC hdc,
728 _In_ int X,
729 _In_ int Y,
730 _Out_opt_ LPPOINT lpPoint)
731 {
732 #if 0
733 PDC_ATTR pdcattr;
734 #if 0
735 if (GDI_HANDLE_GET_TYPE(hdc) != GDI_OBJECT_TYPE_DC)
736 {
737 if (GDI_HANDLE_GET_TYPE(hdc) == GDI_OBJECT_TYPE_METADC)
738 return MFDRV_SetViewportOrgEx();
739 else
740 {
741 PLDC pLDC = GdiGetLDC(hdc);
742 if ( !pLDC )
743 {
744 SetLastError(ERROR_INVALID_HANDLE);
745 return FALSE;
746 }
747 if (pLDC->iType == LDC_EMFLDC)
748 {
749 return EMFDRV_SetViewportOrgEx();
750 }
751 }
752 }
753 #endif
754
755 /* Get the DC attribute */
756 pdcattr = GdiGetDcAttr(hdc);
757 if (!pdcattr)
758 {
759 /* Do not set LastError here! */
760 return FALSE;
761 }
762
763 if (lpPoint)
764 {
765 lpPoint->x = pdcattr->ptlViewportOrg.x;
766 lpPoint->y = pdcattr->ptlViewportOrg.y;
767 if (pdcattr->dwLayout & LAYOUT_RTL) lpPoint->x = -lpPoint->x;
768 }
769 pdcattr->flXform |= (PAGE_XLATE_CHANGED|DEVICE_TO_WORLD_INVALID);
770 if (pdcattr->dwLayout & LAYOUT_RTL) X = -X;
771 pdcattr->ptlViewportOrg.x = X;
772 pdcattr->ptlViewportOrg.y = Y;
773 return TRUE;
774 #endif
775 return NtGdiSetViewportOrgEx(hdc,X,Y,lpPoint);
776 }
777
778 /*
779 * @implemented
780 */
781 BOOL
782 WINAPI
783 ScaleViewportExtEx(
784 _In_ HDC hdc,
785 _In_ INT xNum,
786 _In_ INT xDenom,
787 _In_ INT yNum,
788 _In_ INT yDenom,
789 _Out_ LPSIZE lpSize)
790 {
791 #if 0
792 if (GDI_HANDLE_GET_TYPE(hdc) != GDI_OBJECT_TYPE_DC)
793 {
794 if (GDI_HANDLE_GET_TYPE(a0) == GDI_OBJECT_TYPE_METADC)
795 return MFDRV_;
796 else
797 {
798 PLDC pLDC = GdiGetLDC(hdc);
799 if ( !pLDC )
800 {
801 SetLastError(ERROR_INVALID_HANDLE);
802 return FALSE;
803 }
804 if (pLDC->iType == LDC_EMFLDC)
805 {
806 return EMFDRV_;
807 }
808 }
809 }
810 #endif
811 if (!GdiGetDcAttr(hdc))
812 {
813 SetLastError(ERROR_INVALID_PARAMETER);
814 return FALSE;
815 }
816
817 return NtGdiScaleViewportExtEx(hdc, xNum, xDenom, yNum, yDenom, lpSize);
818 }
819
820 /*
821 * @implemented
822 */
823 BOOL
824 WINAPI
825 ScaleWindowExtEx(
826 _In_ HDC hdc,
827 _In_ INT xNum,
828 _In_ INT xDenom,
829 _In_ INT yNum,
830 _In_ INT yDenom,
831 _Out_ LPSIZE lpSize)
832 {
833 #if 0
834 if (GDI_HANDLE_GET_TYPE(hdc) != GDI_OBJECT_TYPE_DC)
835 {
836 if (GDI_HANDLE_GET_TYPE(hdc) == GDI_OBJECT_TYPE_METADC)
837 return MFDRV_;
838 else
839 {
840 PLDC pLDC = GdiGetLDC(hdc);
841 if ( !pLDC )
842 {
843 SetLastError(ERROR_INVALID_HANDLE);
844 return FALSE;
845 }
846 if (pLDC->iType == LDC_EMFLDC)
847 {
848 return EMFDRV_;
849 }
850 }
851 }
852 #endif
853
854 if (!GdiGetDcAttr(hdc))
855 {
856 SetLastError(ERROR_INVALID_PARAMETER);
857 return FALSE;
858 }
859
860 return NtGdiScaleWindowExtEx(hdc, xNum, xDenom, yNum, yDenom, lpSize);
861 }
862
863 /*
864 * @implemented
865 */
866 DWORD
867 WINAPI
868 GetLayout(
869 _In_ HDC hdc)
870 {
871 PDC_ATTR pdcattr;
872
873 /* METADC16 is not supported in this API */
874 if (GDI_HANDLE_GET_TYPE(hdc) == GDILoObjType_LO_METADC16_TYPE)
875 {
876 return GDI_ERROR;
877 }
878
879 /* Get the DC attribute */
880 pdcattr = GdiGetDcAttr(hdc);
881 if (!pdcattr)
882 {
883 /* Set the error value and return failure */
884 SetLastError(ERROR_INVALID_PARAMETER);
885 return GDI_ERROR;
886 }
887
888 /* Return the layout */
889 return pdcattr->dwLayout;
890 }
891
892
893 /*
894 * @implemented
895 */
896 DWORD
897 WINAPI
898 SetLayout(
899 _In_ HDC hdc,
900 _In_ DWORD dwLayout)
901 {
902 #if 0
903 if (GDI_HANDLE_GET_TYPE(hdc) != GDI_OBJECT_TYPE_DC)
904 {
905 if (GDI_HANDLE_GET_TYPE(hdc) == GDI_OBJECT_TYPE_METADC)
906 return MFDRV_SetLayout( hdc, dwLayout);
907 else
908 {
909 PLDC pLDC = GdiGetLDC(hdc);
910 if ( !pLDC )
911 {
912 SetLastError(ERROR_INVALID_HANDLE);
913 return 0;
914 }
915 if (pLDC->iType == LDC_EMFLDC)
916 {
917 return EMFDRV_SetLayout( hdc, dwLayout);
918 }
919 }
920 }
921 #endif
922 if (!GdiGetDcAttr(hdc))
923 {
924 SetLastError(ERROR_INVALID_PARAMETER);
925 return GDI_ERROR;
926 }
927
928 return NtGdiSetLayout(hdc, -1, dwLayout);
929 }
930
931 /*
932 * @implemented
933 */
934 DWORD
935 WINAPI
936 SetLayoutWidth(
937 _In_ HDC hdc,
938 _In_ LONG wox,
939 _In_ DWORD dwLayout)
940 {
941 /* Only normal DCs are handled here */
942 if (GDI_HANDLE_GET_TYPE(hdc) != GDILoObjType_LO_DC_TYPE)
943 {
944 return GDI_ERROR;
945 }
946
947 if (!GdiGetDcAttr(hdc))
948 {
949 SetLastError(ERROR_INVALID_PARAMETER);
950 return GDI_ERROR;
951 }
952
953 return NtGdiSetLayout( hdc, wox, dwLayout);
954 }
955
956 /*
957 * @implemented
958 */
959 BOOL
960 WINAPI
961 GetDCOrgEx(
962 _In_ HDC hdc,
963 _Out_ LPPOINT lpPoint)
964 {
965 return NtGdiGetDCPoint(hdc, GdiGetDCOrg, (PPOINTL)lpPoint);
966 }
967
968
969 /*
970 * @implemented
971 */
972 LONG
973 WINAPI
974 GetDCOrg(
975 _In_ HDC hdc)
976 {
977 POINT pt;
978
979 /* Call the new API */
980 if (!GetDCOrgEx(hdc, &pt))
981 return 0;
982
983 /* Return the point in the old way */
984 return(MAKELONG(pt.x, pt.y));
985 }
986
987
988 /*
989 * @implemented
990 *
991 */
992 BOOL
993 WINAPI
994 OffsetViewportOrgEx(
995 _In_ HDC hdc,
996 _In_ int nXOffset,
997 _In_ int nYOffset,
998 _Out_opt_ LPPOINT lpPoint)
999 {
1000 #if 0
1001 PDC_ATTR pdcattr;
1002 #if 0
1003 if (GDI_HANDLE_GET_TYPE(hdc) != GDI_OBJECT_TYPE_DC)
1004 {
1005 if (GDI_HANDLE_GET_TYPE(hdc) == GDI_OBJECT_TYPE_METADC)
1006 return MFDRV_OffsetViewportOrgEx(hdc, nXOffset, nYOffset, lpPoint);
1007 else
1008 {
1009 PLDC pLDC = GdiGetLDC(hdc);
1010 if ( !pLDC )
1011 {
1012 SetLastError(ERROR_INVALID_HANDLE);
1013 return FALSE;
1014 }
1015 if (pLDC->iType == LDC_EMFLDC)
1016 {
1017 return EMFDRV_OffsetWindowOrgEx(hdc, nXOffset, nYOffset, lpPoint);
1018 }
1019 }
1020 }
1021 #endif
1022 /* Get the DC attribute */
1023 pdcattr = GdiGetDcAttr(hdc);
1024 if (!pdcattr)
1025 {
1026 /* Do not set LastError here! */
1027 return FALSE;
1028 }
1029
1030 if (lpPoint)
1031 {
1032 *lpPoint = (POINT)pdcattr->ptlViewportOrg;
1033 if ( pdcattr->dwLayout & LAYOUT_RTL) lpPoint->x = -lpPoint->x;
1034 }
1035
1036 if ( nXOffset || nYOffset != nXOffset )
1037 {
1038 if (NtCurrentTeb()->GdiTebBatch.HDC == (ULONG)hdc)
1039 {
1040 if (pdcattr->ulDirty_ & DC_MODE_DIRTY)
1041 {
1042 NtGdiFlush();
1043 pdcattr->ulDirty_ &= ~DC_MODE_DIRTY;
1044 }
1045 }
1046
1047 pdcattr->flXform |= (PAGE_XLATE_CHANGED|DEVICE_TO_WORLD_INVALID);
1048 if (pdcattr->dwLayout & LAYOUT_RTL) nXOffset = -nXOffset;
1049 pdcattr->ptlViewportOrg.x += nXOffset;
1050 pdcattr->ptlViewportOrg.y += nYOffset;
1051 }
1052 return TRUE;
1053 #endif
1054 return NtGdiOffsetViewportOrgEx(hdc, nXOffset, nYOffset, lpPoint);
1055 }
1056
1057 /*
1058 * @implemented
1059 *
1060 */
1061 BOOL
1062 WINAPI
1063 OffsetWindowOrgEx(
1064 _In_ HDC hdc,
1065 _In_ int nXOffset,
1066 _In_ int nYOffset,
1067 _Out_opt_ LPPOINT lpPoint)
1068 {
1069 #if 0
1070 PDC_ATTR pdcattr;
1071 #if 0
1072 if (GDI_HANDLE_GET_TYPE(hdc) != GDI_OBJECT_TYPE_DC)
1073 {
1074 if (GDI_HANDLE_GET_TYPE(hdc) == GDI_OBJECT_TYPE_METADC)
1075 return MFDRV_OffsetWindowOrgEx(hdc, nXOffset, nYOffset, lpPoint);
1076 else
1077 {
1078 PLDC pLDC = GdiGetLDC(hdc);
1079 if ( !pLDC )
1080 {
1081 SetLastError(ERROR_INVALID_HANDLE);
1082 return FALSE;
1083 }
1084 if (pLDC->iType == LDC_EMFLDC)
1085 {
1086 return EMFDRV_OffsetWindowOrgEx(hdc, nXOffset, nYOffset, lpPoint);
1087 }
1088 }
1089 }
1090 #endif
1091 /* Get the DC attribute */
1092 pdcattr = GdiGetDcAttr(hdc);
1093 if (!pdcattr)
1094 {
1095 /* Do not set LastError here! */
1096 return FALSE;
1097 }
1098
1099 if ( lpPoint )
1100 {
1101 *lpPoint = (POINT)pdcattr->ptlWindowOrg;
1102 lpPoint->x = pdcattr->lWindowOrgx;
1103 }
1104
1105 if ( nXOffset || nYOffset != nXOffset )
1106 {
1107 if (NtCurrentTeb()->GdiTebBatch.HDC == (ULONG)hdc)
1108 {
1109 if (pdcattr->ulDirty_ & DC_MODE_DIRTY)
1110 {
1111 NtGdiFlush();
1112 pdcattr->ulDirty_ &= ~DC_MODE_DIRTY;
1113 }
1114 }
1115
1116 pdcattr->flXform |= (PAGE_XLATE_CHANGED|DEVICE_TO_WORLD_INVALID);
1117 pdcattr->ptlWindowOrg.x += nXOffset;
1118 pdcattr->ptlWindowOrg.y += nYOffset;
1119 pdcattr->lWindowOrgx += nXOffset;
1120 }
1121 return TRUE;
1122 #endif
1123 return NtGdiOffsetWindowOrgEx(hdc, nXOffset, nYOffset, lpPoint);
1124 }
1125