Merge to trunk head (r46631)
[reactos.git] / subsystems / win32 / win32k / objects / dcstate.c
1 /*
2 * COPYRIGHT: See COPYING in the top level directory
3 * PROJECT: ReactOS kernel
4 * PURPOSE: Functions for saving and restoring dc states
5 * FILE: subsystem/win32/win32k/objects/dcstate.c
6 * PROGRAMER: Timo Kreuzer (timo.kreuzer@rectos.org)
7 */
8
9 #include <w32k.h>
10
11 #define NDEBUG
12 #include <debug.h>
13
14 VOID
15 FASTCALL
16 DC_vCopyState(PDC pdcSrc, PDC pdcDst, BOOL To)
17 {
18 DPRINT("DC_vCopyState(%p, %p)\n", pdcSrc->BaseObject.hHmgr, pdcDst->BaseObject.hHmgr);
19
20 /* Copy full DC attribute */
21 *pdcDst->pdcattr = *pdcSrc->pdcattr;
22
23 /* Get/SetDCState() don't change hVisRgn field ("Undoc. Windows" p.559). */
24 /* The VisRectRegion field needs to be set to a valid state */
25
26 /* Mark some fields as dirty */
27 pdcDst->pdcattr->ulDirty_ |= 0x0012001f; // Note: Use if, To is FALSE....
28
29 /* Copy DC level */
30 pdcDst->dclevel.pColorSpace = pdcSrc->dclevel.pColorSpace;
31 pdcDst->dclevel.lSaveDepth = pdcSrc->dclevel.lSaveDepth;
32 pdcDst->dclevel.hdcSave = pdcSrc->dclevel.hdcSave;
33 pdcDst->dclevel.laPath = pdcSrc->dclevel.laPath;
34 pdcDst->dclevel.ca = pdcSrc->dclevel.ca;
35 pdcDst->dclevel.mxWorldToDevice = pdcSrc->dclevel.mxWorldToDevice;
36 pdcDst->dclevel.mxDeviceToWorld = pdcSrc->dclevel.mxDeviceToWorld;
37 pdcDst->dclevel.mxWorldToPage = pdcSrc->dclevel.mxWorldToPage;
38 pdcDst->dclevel.efM11PtoD = pdcSrc->dclevel.efM11PtoD;
39 pdcDst->dclevel.efM22PtoD = pdcSrc->dclevel.efM22PtoD;
40 pdcDst->dclevel.sizl = pdcSrc->dclevel.sizl;
41 pdcDst->dclevel.hpal = pdcSrc->dclevel.hpal;
42
43 /* Handle references here correctly */
44 DC_vSelectSurface(pdcDst, pdcSrc->dclevel.pSurface);
45 DC_vSelectFillBrush(pdcDst, pdcSrc->dclevel.pbrFill);
46 DC_vSelectLineBrush(pdcDst, pdcSrc->dclevel.pbrLine);
47 DC_vSelectPalette(pdcDst, pdcSrc->dclevel.ppal);
48
49 // FIXME: handle refs
50 pdcDst->dclevel.plfnt = pdcSrc->dclevel.plfnt;
51
52 /* ROS hacks */
53 if (pdcDst->dctype != DC_TYPE_MEMORY)
54 {
55 pdcDst->rosdc.bitsPerPixel = pdcSrc->rosdc.bitsPerPixel;
56 }
57
58 /* Get/SetDCState() don't change hVisRgn field ("Undoc. Windows" p.559). */
59 if (To) // Copy "To" SaveDC state.
60 {
61 if (pdcSrc->rosdc.hClipRgn)
62 {
63 pdcDst->rosdc.hClipRgn = IntSysCreateRectRgn(0, 0, 0, 0);
64 NtGdiCombineRgn(pdcDst->rosdc.hClipRgn, pdcSrc->rosdc.hClipRgn, 0, RGN_COPY);
65 }
66 // FIXME! Handle prgnMeta!
67 }
68 else // Copy "!To" RestoreDC state.
69 { /* The VisRectRegion field needs to be set to a valid state */
70 GdiExtSelectClipRgn(pdcDst, pdcSrc->rosdc.hClipRgn, RGN_COPY);
71 }
72 }
73
74
75 BOOL FASTCALL
76 IntGdiCleanDC(HDC hDC)
77 {
78 PDC dc;
79 if (!hDC) return FALSE;
80 dc = DC_LockDc(hDC);
81 if (!dc) return FALSE;
82 // Clean the DC
83 if (defaultDCstate) DC_vCopyState(defaultDCstate, dc, FALSE);
84
85 if (dc->dctype != DC_TYPE_MEMORY)
86 {
87 dc->rosdc.bitsPerPixel = defaultDCstate->rosdc.bitsPerPixel;
88 }
89
90 DC_UnlockDc(dc);
91
92 return TRUE;
93 }
94
95
96 BOOL
97 APIENTRY
98 NtGdiResetDC(
99 IN HDC hdc,
100 IN LPDEVMODEW pdm,
101 OUT PBOOL pbBanding,
102 IN OPTIONAL VOID *pDriverInfo2,
103 OUT VOID *ppUMdhpdev)
104 {
105 UNIMPLEMENTED;
106 return 0;
107 }
108
109
110 VOID
111 NTAPI
112 DC_vRestoreDC(
113 IN PDC pdc,
114 INT iSaveLevel)
115 {
116 PEPROCESS pepCurrentProcess;
117 HDC hdcSave;
118 PDC pdcSave;
119
120 ASSERT(iSaveLevel > 0);
121 DPRINT("DC_vRestoreDC(%p, %ld)\n", pdc->BaseObject.hHmgr, iSaveLevel);
122
123 /* Get current process */
124 pepCurrentProcess = PsGetCurrentProcess();
125
126 /* Loop the save levels */
127 while (pdc->dclevel.lSaveDepth > iSaveLevel)
128 {
129 hdcSave = pdc->dclevel.hdcSave;
130 DPRINT("RestoreDC = %p\n", hdcSave);
131
132 /* Set us as the owner */
133 if (!GDIOBJ_SetOwnership(hdcSave, pepCurrentProcess))
134 {
135 /* Could not get ownership. That's bad! */
136 DPRINT1("Could not get ownership of saved DC (%p) for hdc %p!\n",
137 hdcSave, pdc->BaseObject.hHmgr);
138 return;// FALSE;
139 }
140
141 /* Lock the saved dc */
142 pdcSave = DC_LockDc(hdcSave);
143 if (!pdcSave)
144 {
145 /* WTF? Internal error! */
146 DPRINT1("Could not lock the saved DC (%p) for dc %p!\n",
147 hdcSave, pdc->BaseObject.hHmgr);
148 return;// FALSE;
149 }
150
151 /* Remove the saved dc from the queue */
152 pdc->dclevel.hdcSave = pdcSave->dclevel.hdcSave;
153
154 /* Decrement save level */
155 pdc->dclevel.lSaveDepth--;
156
157 /* Is this the state we want? */
158 if (pdc->dclevel.lSaveDepth == iSaveLevel)
159 {
160 /* Copy the state back */
161 DC_vCopyState(pdcSave, pdc, FALSE);
162
163 // Restore Path by removing it, if the Save flag is set.
164 // BeginPath will takecare of the rest.
165 if (pdc->dclevel.hPath && pdc->dclevel.flPath & DCPATH_SAVE)
166 {
167 PATH_Delete(pdc->dclevel.hPath);
168 pdc->dclevel.hPath = 0;
169 pdc->dclevel.flPath &= ~DCPATH_SAVE;
170 }
171 }
172
173 /* Prevent save dc from being restored */
174 pdcSave->dclevel.lSaveDepth = 1;
175
176 /* Unlock it */
177 DC_UnlockDc(pdcSave);
178 /* Delete the saved dc */
179 GreDeleteObject(hdcSave);
180 }
181
182 DPRINT("Leave DC_vRestoreDC()\n");
183 }
184
185
186
187 BOOL
188 APIENTRY
189 NtGdiRestoreDC(
190 HDC hdc,
191 INT iSaveLevel)
192 {
193 PDC pdc;
194
195 DPRINT("NtGdiRestoreDC(%p, %d)\n", hdc, iSaveLevel);
196
197 /* Lock the original DC */
198 pdc = DC_LockDc(hdc);
199 if (!pdc)
200 {
201 SetLastWin32Error(ERROR_INVALID_HANDLE);
202 return FALSE;
203 }
204
205 ASSERT(pdc->dclevel.lSaveDepth > 0);
206
207 /* Negative values are relative to the stack top */
208 if (iSaveLevel < 0)
209 iSaveLevel = pdc->dclevel.lSaveDepth + iSaveLevel;
210
211 /* Check if we have a valid instance */
212 if (iSaveLevel <= 0 || iSaveLevel >= pdc->dclevel.lSaveDepth)
213 {
214 DPRINT("Illegal save level, requested: %ld, current: %ld\n",
215 iSaveLevel, pdc->dclevel.lSaveDepth);
216 DC_UnlockDc(pdc);
217 SetLastWin32Error(ERROR_INVALID_PARAMETER);
218 return FALSE;
219 }
220
221 /* Call the internal function */
222 DC_vRestoreDC(pdc, iSaveLevel);
223
224 DC_UnlockDc(pdc);
225
226 DPRINT("Leave NtGdiRestoreDC\n");
227 return TRUE;
228 }
229
230
231 INT
232 APIENTRY
233 NtGdiSaveDC(
234 HDC hDC)
235 {
236 HDC hdcSave;
237 PDC pdc, pdcSave;
238 INT lSaveDepth;
239
240 DPRINT("NtGdiSaveDC(%p)\n", hDC);
241
242 /* Lock the original dc */
243 pdc = DC_LockDc(hDC);
244 if (pdc == NULL)
245 {
246 DPRINT("Could not lock DC\n");
247 SetLastWin32Error(ERROR_INVALID_HANDLE);
248 return 0;
249 }
250
251 /* Allocate a new dc */
252 pdcSave = DC_AllocDcWithHandle();
253 if (pdcSave == NULL)
254 {
255 DPRINT("Could not allocate a new DC\n");
256 DC_UnlockDc(pdc);
257 return 0;
258 }
259 hdcSave = pdcSave->BaseObject.hHmgr;
260
261 InterlockedIncrement(&pdc->ppdev->cPdevRefs);
262 DC_vInitDc(pdcSave, DCTYPE_MEMORY, pdc->ppdev);
263
264 /* Handle references here correctly */
265 // pdcSrc->dclevel.pSurface = NULL;
266 // pdcSrc->dclevel.pbrFill = NULL;
267 // pdcSrc->dclevel.pbrLine = NULL;
268 // pdcSrc->dclevel.ppal = NULL;
269
270 /* Make it a kernel handle
271 (FIXME: windows handles this different, see wiki)*/
272 GDIOBJ_SetOwnership(hdcSave, NULL);
273
274 /* Copy the current state */
275 DC_vCopyState(pdc, pdcSave, TRUE);
276
277 /* Copy path. FIXME: why this way? */
278 pdcSave->dclevel.hPath = pdc->dclevel.hPath;
279 pdcSave->dclevel.flPath = pdc->dclevel.flPath | DCPATH_SAVESTATE;
280 if (pdcSave->dclevel.hPath) pdcSave->dclevel.flPath |= DCPATH_SAVE;
281
282 /* Set new dc as save dc */
283 pdc->dclevel.hdcSave = hdcSave;
284
285 /* Increase save depth, return old value */
286 lSaveDepth = pdc->dclevel.lSaveDepth++;
287
288 /* Cleanup and return */
289 DC_UnlockDc(pdcSave);
290 DC_UnlockDc(pdc);
291
292 DPRINT("Leave NtGdiSaveDC: %ld, hdcSave = %p\n", lSaveDepth, hdcSave);
293 return lSaveDepth;
294 }
295