[YAROTOWS] Reintegrate the branch. For a brighter future.
[reactos.git] / reactos / subsystems / win32 / win32k / objects / dclife.c
1 /*
2 * COPYRIGHT: See COPYING in the top level directory
3 * PROJECT: ReactOS kernel
4 * PURPOSE: Functions for creation and destruction of DCs
5 * FILE: subsystem/win32/win32k/objects/dclife.c
6 * PROGRAMER: Timo Kreuzer (timo.kreuzer@rectos.org)
7 */
8
9 #include <win32k.h>
10 #include <bugcodes.h>
11
12 #define NDEBUG
13 #include <debug.h>
14
15 //FIXME: windows uses 0x0012009f
16 #define DIRTY_DEFAULT DIRTY_CHARSET|DIRTY_BACKGROUND|DIRTY_TEXT|DIRTY_LINE|DIRTY_FILL
17
18 PSURFACE psurfDefaultBitmap = NULL;
19 PBRUSH pbrDefaultBrush = NULL;
20
21 // FIXME: these should go to floatobj.h or something
22 #define FLOATOBJ_0 {0x00000000, 0x00000000}
23 #define FLOATOBJ_1 {0x40000000, 0x00000002}
24 #define FLOATOBJ_16 {0x40000000, 0x00000006}
25 #define FLOATOBJ_1_16 {0x40000000, 0xfffffffe}
26
27 static const FLOATOBJ gef0 = FLOATOBJ_0;
28 static const FLOATOBJ gef1 = FLOATOBJ_1;
29 static const FLOATOBJ gef16 = FLOATOBJ_16;
30
31 static const MATRIX gmxWorldToDeviceDefault =
32 {
33 FLOATOBJ_16, FLOATOBJ_0,
34 FLOATOBJ_0, FLOATOBJ_16,
35 FLOATOBJ_0, FLOATOBJ_0,
36 0, 0, 0x4b
37 };
38
39 static const MATRIX gmxDeviceToWorldDefault =
40 {
41 FLOATOBJ_1_16, FLOATOBJ_0,
42 FLOATOBJ_0, FLOATOBJ_1_16,
43 FLOATOBJ_0, FLOATOBJ_0,
44 0, 0, 0x53
45 };
46
47 static const MATRIX gmxWorldToPageDefault =
48 {
49 FLOATOBJ_1, FLOATOBJ_0,
50 FLOATOBJ_0, FLOATOBJ_1,
51 FLOATOBJ_0, FLOATOBJ_0,
52 0, 0, 0x63
53 };
54
55 // HACK!! Fix XFORMOBJ then use 1:16 / 16:1
56 #define gmxWorldToDeviceDefault gmxWorldToPageDefault
57 #define gmxDeviceToWorldDefault gmxWorldToPageDefault
58
59 /** Internal functions ********************************************************/
60
61 NTSTATUS
62 InitDcImpl()
63 {
64 psurfDefaultBitmap = SURFACE_ShareLockSurface(StockObjects[DEFAULT_BITMAP]);
65 if (!psurfDefaultBitmap)
66 return STATUS_UNSUCCESSFUL;
67
68 pbrDefaultBrush = BRUSH_ShareLockBrush(StockObjects[BLACK_BRUSH]);
69 if (!pbrDefaultBrush)
70 return STATUS_UNSUCCESSFUL;
71
72 return STATUS_SUCCESS;
73 }
74
75
76 PDC
77 NTAPI
78 DC_AllocDcWithHandle()
79 {
80 PDC pdc;
81 pdc = (PDC)GDIOBJ_AllocObjWithHandle(GDILoObjType_LO_DC_TYPE);
82
83 pdc->pdcattr = &pdc->dcattr;
84
85 return pdc;
86 }
87
88
89 void
90 DC_InitHack(PDC pdc)
91 {
92 TextIntRealizeFont(pdc->pdcattr->hlfntNew,NULL);
93 pdc->pdcattr->iCS_CP = ftGdiGetTextCharsetInfo(pdc,NULL,0);
94
95 /* This should never fail */
96 ASSERT(pdc->dclevel.ppal);
97
98 /* Select regions */
99 pdc->rosdc.hClipRgn = NULL;
100 pdc->rosdc.hGCClipRgn = NULL;
101 }
102
103 VOID
104 NTAPI
105 DC_vInitDc(
106 PDC pdc,
107 DCTYPE dctype,
108 PPDEVOBJ ppdev)
109 {
110 /* Setup some basic fields */
111 pdc->dctype = dctype;
112 pdc->ppdev = ppdev;
113 pdc->dhpdev = ppdev->dhpdev;
114 pdc->hsem = ppdev->hsemDevLock;
115 pdc->flGraphicsCaps = ppdev->devinfo.flGraphicsCaps;
116 pdc->flGraphicsCaps2 = ppdev->devinfo.flGraphicsCaps2;
117 pdc->fs = DC_DIRTY_RAO;
118
119 /* Setup dc attribute */
120 pdc->pdcattr = &pdc->dcattr;
121 pdc->dcattr.pvLDC = NULL;
122 pdc->dcattr.ulDirty_ = DIRTY_DEFAULT;
123 if (ppdev == gppdevPrimary)
124 pdc->dcattr.ulDirty_ |= DC_PRIMARY_DISPLAY;
125
126 /* Setup the DC size */
127 if (dctype == DCTYPE_MEMORY)
128 {
129 /* Memory DCs have a 1 x 1 bitmap by default */
130 pdc->dclevel.sizl.cx = 1;
131 pdc->dclevel.sizl.cy = 1;
132 }
133 else
134 {
135 /* Other DC's are as big as the related PDEV */
136 pdc->dclevel.sizl.cx = ppdev->gdiinfo.ulHorzRes;
137 pdc->dclevel.sizl.cy = ppdev->gdiinfo.ulVertRes;
138 }
139
140 /* Setup Window rect based on DC size */
141 pdc->erclWindow.left = 0;
142 pdc->erclWindow.top = 0;
143 pdc->erclWindow.right = pdc->dclevel.sizl.cx;
144 pdc->erclWindow.bottom = pdc->dclevel.sizl.cy;
145
146 if (dctype == DCTYPE_DIRECT)
147 {
148 /* Direct DCs get the surface from the PDEV */
149 pdc->dclevel.pSurface = PDEVOBJ_pSurface(ppdev);
150
151 pdc->erclBounds.left = 0x7fffffff;
152 pdc->erclBounds.top = 0x7fffffff;
153 pdc->erclBounds.right = 0x80000000;
154 pdc->erclBounds.bottom = 0x80000000;
155 pdc->erclBoundsApp.left = 0xffffffff;
156 pdc->erclBoundsApp.top = 0xfffffffc;
157 pdc->erclBoundsApp.right = 0x00007ffc; // FIXME
158 pdc->erclBoundsApp.bottom = 0x00000333; // FIXME
159 pdc->erclClip = pdc->erclBounds;
160 // pdc->co
161
162 pdc->fs |= DC_SYNCHRONIZEACCESS | DC_ACCUM_APP | DC_PERMANANT | DC_DISPLAY;
163 }
164 else
165 {
166 /* Non-direct DCs don't have a surface by default */
167 pdc->dclevel.pSurface = NULL;
168
169 // FIXME: HACK, because our code expects a surface
170 pdc->dclevel.pSurface = SURFACE_ShareLockSurface(StockObjects[DEFAULT_BITMAP]);
171
172 pdc->erclBounds.left = 0;
173 pdc->erclBounds.top = 0;
174 pdc->erclBounds.right = 0;
175 pdc->erclBounds.bottom = 0;
176 pdc->erclBoundsApp = pdc->erclBounds;
177 pdc->erclClip = pdc->erclWindow;
178 // pdc->co = NULL
179 }
180
181 // pdc->dcattr.VisRectRegion:
182
183 /* Setup coordinate transformation data */
184 pdc->dclevel.mxWorldToDevice = gmxWorldToDeviceDefault;
185 pdc->dclevel.mxDeviceToWorld = gmxDeviceToWorldDefault;
186 pdc->dclevel.mxWorldToPage = gmxWorldToPageDefault;
187 pdc->dclevel.efM11PtoD = gef16;
188 pdc->dclevel.efM22PtoD = gef16;
189 pdc->dclevel.efDxPtoD = gef0;
190 pdc->dclevel.efDyPtoD = gef0;
191 pdc->dclevel.efM11_TWIPS = gef0;
192 pdc->dclevel.efM22_TWIPS = gef0;
193 pdc->dclevel.efPr11 = gef0;
194 pdc->dclevel.efPr22 = gef0;
195 pdc->dcattr.mxWorldToDevice = pdc->dclevel.mxWorldToDevice;
196 pdc->dcattr.mxDeviceToWorld = pdc->dclevel.mxDeviceToWorld;
197 pdc->dcattr.mxWorldToPage = pdc->dclevel.mxWorldToPage;
198 pdc->dcattr.efM11PtoD = pdc->dclevel.efM11PtoD;
199 pdc->dcattr.efM22PtoD = pdc->dclevel.efM22PtoD;
200 pdc->dcattr.efDxPtoD = pdc->dclevel.efDxPtoD;
201 pdc->dcattr.efDyPtoD = pdc->dclevel.efDyPtoD;
202 pdc->dcattr.iMapMode = MM_TEXT;
203 pdc->dcattr.dwLayout = 0;
204 pdc->dcattr.flXform = PAGE_TO_DEVICE_SCALE_IDENTITY |
205 PAGE_TO_DEVICE_IDENTITY |
206 WORLD_TO_PAGE_IDENTITY;
207
208 /* Setup more coordinates */
209 pdc->ptlDCOrig.x = 0;
210 pdc->ptlDCOrig.y = 0;
211 pdc->dcattr.lWindowOrgx = 0;
212 pdc->dcattr.ptlWindowOrg.x = 0;
213 pdc->dcattr.ptlWindowOrg.y = 0;
214 pdc->dcattr.szlWindowExt.cx = 1;
215 pdc->dcattr.szlWindowExt.cy = 1;
216 pdc->dcattr.ptlViewportOrg.x = 0;
217 pdc->dcattr.ptlViewportOrg.y = 0;
218 pdc->dcattr.szlViewportExt.cx = 1;
219 pdc->dcattr.szlViewportExt.cy = 1;
220 pdc->dcattr.szlVirtualDevicePixel.cx = ppdev->gdiinfo.ulHorzRes;
221 pdc->dcattr.szlVirtualDevicePixel.cy = ppdev->gdiinfo.ulVertRes;
222 pdc->dcattr.szlVirtualDeviceMm.cx = ppdev->gdiinfo.ulHorzSize;
223 pdc->dcattr.szlVirtualDeviceMm.cy = ppdev->gdiinfo.ulVertSize;
224 pdc->dcattr.szlVirtualDeviceSize.cx = 0;
225 pdc->dcattr.szlVirtualDeviceSize.cy = 0;
226
227 /* Setup regions */
228 pdc->prgnAPI = NULL;
229 pdc->prgnRao = NULL;
230 /* Allocate a Vis region */
231 pdc->prgnVis = IntSysCreateRectpRgn(0, 0, pdc->dclevel.sizl.cx, pdc->dclevel.sizl.cy);
232 ASSERT(pdc->prgnVis);
233 GDIOBJ_CopyOwnership(pdc->BaseObject.hHmgr, pdc->prgnVis->BaseObject.hHmgr);
234
235 /* Setup palette */
236 pdc->dclevel.hpal = StockObjects[DEFAULT_PALETTE];
237 pdc->dclevel.ppal = PALETTE_ShareLockPalette(pdc->dclevel.hpal);
238
239 /* Setup path */
240 pdc->dclevel.hPath = NULL;
241 pdc->dclevel.flPath = 0;
242 // pdc->dclevel.lapath:
243
244 /* Setup colors */
245 pdc->dcattr.crBackgroundClr = RGB(0xff, 0xff, 0xff);
246 pdc->dcattr.ulBackgroundClr = RGB(0xff, 0xff, 0xff);
247 pdc->dcattr.crForegroundClr = RGB(0, 0, 0);
248 pdc->dcattr.ulForegroundClr = RGB(0, 0, 0);
249 pdc->dcattr.crBrushClr = RGB(0xff, 0xff, 0xff);
250 pdc->dcattr.ulBrushClr = RGB(0xff, 0xff, 0xff);
251 pdc->dcattr.crPenClr = RGB(0, 0, 0);
252 pdc->dcattr.ulPenClr = RGB(0, 0, 0);
253
254 /* Select the default fill and line brush */
255 pdc->dcattr.hbrush = StockObjects[WHITE_BRUSH];
256 pdc->dcattr.hpen = StockObjects[BLACK_PEN];
257 pdc->dclevel.pbrFill = BRUSH_ShareLockBrush(pdc->pdcattr->hbrush);
258 pdc->dclevel.pbrLine = PEN_ShareLockPen(pdc->pdcattr->hpen);
259 pdc->dclevel.ptlBrushOrigin.x = 0;
260 pdc->dclevel.ptlBrushOrigin.y = 0;
261 pdc->dcattr.ptlBrushOrigin = pdc->dclevel.ptlBrushOrigin;
262
263 /* Initialize EBRUSHOBJs */
264 EBRUSHOBJ_vInit(&pdc->eboFill, pdc->dclevel.pbrFill, pdc);
265 EBRUSHOBJ_vInit(&pdc->eboLine, pdc->dclevel.pbrLine, pdc);
266 EBRUSHOBJ_vInit(&pdc->eboText, pbrDefaultBrush, pdc);
267 EBRUSHOBJ_vInit(&pdc->eboBackground, pbrDefaultBrush, pdc);
268
269 /* Setup fill data */
270 pdc->dcattr.jROP2 = R2_COPYPEN;
271 pdc->dcattr.jBkMode = 2;
272 pdc->dcattr.lBkMode = 2;
273 pdc->dcattr.jFillMode = ALTERNATE;
274 pdc->dcattr.lFillMode = 1;
275 pdc->dcattr.jStretchBltMode = 1;
276 pdc->dcattr.lStretchBltMode = 1;
277 pdc->ptlFillOrigin.x = 0;
278 pdc->ptlFillOrigin.y = 0;
279
280 /* Setup drawing position */
281 pdc->dcattr.ptlCurrent.x = 0;
282 pdc->dcattr.ptlCurrent.y = 0;
283 pdc->dcattr.ptfxCurrent.x = 0;
284 pdc->dcattr.ptfxCurrent.y = 0;
285
286 /* Setup ICM data */
287 pdc->dclevel.lIcmMode = 0;
288 pdc->dcattr.lIcmMode = 0;
289 pdc->dcattr.hcmXform = NULL;
290 pdc->dcattr.flIcmFlags = 0;
291 pdc->dcattr.IcmBrushColor = CLR_INVALID;
292 pdc->dcattr.IcmPenColor = CLR_INVALID;
293 pdc->dcattr.pvLIcm = NULL;
294 pdc->dcattr.hColorSpace = NULL; // FIXME: 0189001f
295 pdc->dclevel.pColorSpace = NULL; // FIXME
296 pdc->pClrxFormLnk = NULL;
297 // pdc->dclevel.ca =
298
299 /* Setup font data */
300 pdc->hlfntCur = NULL; // FIXME: 2f0a0cf8
301 pdc->pPFFList = NULL;
302 pdc->flSimulationFlags = 0;
303 pdc->lEscapement = 0;
304 pdc->prfnt = NULL;
305 pdc->dcattr.flFontMapper = 0;
306 pdc->dcattr.flTextAlign = 0;
307 pdc->dcattr.lTextAlign = 0;
308 pdc->dcattr.lTextExtra = 0;
309 pdc->dcattr.lRelAbs = 1;
310 pdc->dcattr.lBreakExtra = 0;
311 pdc->dcattr.cBreak = 0;
312 pdc->dcattr.hlfntNew = StockObjects[SYSTEM_FONT];
313 // pdc->dclevel.pFont = LFONT_ShareLockFont(pdc->dcattr.hlfntNew);
314
315 /* Other stuff */
316 pdc->hdcNext = NULL;
317 pdc->hdcPrev = NULL;
318 pdc->ipfdDevMax = 0x0000ffff;
319 pdc->ulCopyCount = -1;
320 pdc->ptlDoBanding.x = 0;
321 pdc->ptlDoBanding.y = 0;
322 pdc->dclevel.lSaveDepth = 1;
323 pdc->dclevel.hdcSave = NULL;
324 pdc->dcattr.iGraphicsMode = GM_COMPATIBLE;
325 pdc->dcattr.iCS_CP = 0;
326 pdc->pSurfInfo = NULL;
327
328 }
329
330 BOOL
331 INTERNAL_CALL
332 DC_Cleanup(PVOID ObjectBody)
333 {
334 PDC pdc = (PDC)ObjectBody;
335
336 /* Free DC_ATTR */
337 DC_vFreeDcAttr(pdc);
338
339 /* Delete saved DCs */
340 DC_vRestoreDC(pdc, 1);
341
342 /* Deselect dc objects */
343 DC_vSelectSurface(pdc, NULL);
344 DC_vSelectFillBrush(pdc, NULL);
345 DC_vSelectLineBrush(pdc, NULL);
346 DC_vSelectPalette(pdc, NULL);
347
348 /* Cleanup the dc brushes */
349 EBRUSHOBJ_vCleanup(&pdc->eboFill);
350 EBRUSHOBJ_vCleanup(&pdc->eboLine);
351 EBRUSHOBJ_vCleanup(&pdc->eboText);
352 EBRUSHOBJ_vCleanup(&pdc->eboBackground);
353
354 /* Free regions */
355 if (pdc->rosdc.hClipRgn)
356 GreDeleteObject(pdc->rosdc.hClipRgn);
357 if (pdc->prgnVis)
358 REGION_FreeRgnByHandle(pdc->prgnVis->BaseObject.hHmgr);
359 if (pdc->rosdc.hGCClipRgn)
360 GreDeleteObject(pdc->rosdc.hGCClipRgn);
361 if (NULL != pdc->rosdc.CombinedClip)
362 IntEngDeleteClipRegion(pdc->rosdc.CombinedClip);
363
364 PATH_Delete(pdc->dclevel.hPath);
365
366 if(pdc->dclevel.pSurface)
367 SURFACE_ShareUnlockSurface(pdc->dclevel.pSurface);
368
369 PDEVOBJ_vRelease(pdc->ppdev) ;
370
371 return TRUE;
372 }
373
374 BOOL
375 FASTCALL
376 DC_SetOwnership(HDC hDC, PEPROCESS Owner)
377 {
378 INT Index;
379 PGDI_TABLE_ENTRY Entry;
380 PDC pDC;
381 BOOL ret = FALSE;
382
383 if (!GDIOBJ_SetOwnership(hDC, Owner))
384 {
385 DPRINT1("GDIOBJ_SetOwnership failed\n");
386 return FALSE;
387 }
388
389 pDC = DC_LockDc(hDC);
390 if (!pDC)
391 {
392 DPRINT1("Could not lock DC\n");
393 return FALSE;
394 }
395
396 /*
397 System Regions:
398 These regions do not use attribute sections and when allocated, use
399 gdiobj level functions.
400 */
401 if (pDC->rosdc.hClipRgn)
402 { // FIXME! HAX!!!
403 Index = GDI_HANDLE_GET_INDEX(pDC->rosdc.hClipRgn);
404 Entry = &GdiHandleTable->Entries[Index];
405 if (Entry->UserData) FreeObjectAttr(Entry->UserData);
406 Entry->UserData = NULL;
407 //
408 if (!GDIOBJ_SetOwnership(pDC->rosdc.hClipRgn, Owner)) goto leave;
409 }
410 if (pDC->prgnVis)
411 { // FIXME! HAX!!!
412 Index = GDI_HANDLE_GET_INDEX(pDC->prgnVis->BaseObject.hHmgr);
413 Entry = &GdiHandleTable->Entries[Index];
414 if (Entry->UserData) FreeObjectAttr(Entry->UserData);
415 Entry->UserData = NULL;
416 //
417 if (!GDIOBJ_SetOwnership(pDC->prgnVis->BaseObject.hHmgr, Owner)) goto leave;
418 }
419 if (pDC->rosdc.hGCClipRgn)
420 { // FIXME! HAX!!!
421 Index = GDI_HANDLE_GET_INDEX(pDC->rosdc.hGCClipRgn);
422 Entry = &GdiHandleTable->Entries[Index];
423 if (Entry->UserData) FreeObjectAttr(Entry->UserData);
424 Entry->UserData = NULL;
425 //
426 if (!GDIOBJ_SetOwnership(pDC->rosdc.hGCClipRgn, Owner)) goto leave;
427 }
428 if (pDC->dclevel.hPath)
429 {
430 if (!GDIOBJ_SetOwnership(pDC->dclevel.hPath, Owner)) goto leave;
431 }
432 ret = TRUE;
433
434 leave:
435 DC_UnlockDc(pDC);
436
437 return ret;
438 }
439
440
441 int FASTCALL
442 CLIPPING_UpdateGCRegion(DC* Dc);
443
444 static
445 void
446 DC_vUpdateDC(PDC pdc)
447 {
448 HRGN hVisRgn ;
449 PPDEVOBJ ppdev = pdc->ppdev ;
450
451 pdc->dhpdev = ppdev->dhpdev;
452
453 SURFACE_ShareUnlockSurface(pdc->dclevel.pSurface);
454 pdc->dclevel.pSurface = PDEVOBJ_pSurface(ppdev);
455
456 PDEVOBJ_sizl(pdc->ppdev, &pdc->dclevel.sizl);
457 hVisRgn = NtGdiCreateRectRgn(0, 0, pdc->dclevel.sizl.cx, pdc->dclevel.sizl.cy);
458 ASSERT(hVisRgn);
459 GdiSelectVisRgn(pdc->BaseObject.hHmgr, hVisRgn);
460 GreDeleteObject(hVisRgn);
461
462 pdc->flGraphicsCaps = ppdev->devinfo.flGraphicsCaps;
463 pdc->flGraphicsCaps2 = ppdev->devinfo.flGraphicsCaps2;
464
465 /* Mark EBRUSHOBJs as dirty */
466 pdc->pdcattr->ulDirty_ |= DIRTY_DEFAULT ;
467 }
468
469 /* Prepare a blit for up to 2 DCs */
470 /* rc1 and rc2 are the rectangles where we want to draw or
471 * from where we take pixels. */
472 VOID
473 FASTCALL
474 DC_vPrepareDCsForBlit(PDC pdc1,
475 RECT rc1,
476 PDC pdc2,
477 RECT rc2)
478 {
479 PDC pdcFirst, pdcSecond;
480 PRECT prcFirst, prcSecond;
481 /* Lock them in good order */
482 if(pdc2)
483 {
484 if((ULONG_PTR)pdc1->ppdev->hsemDevLock >= (ULONG_PTR)pdc2->ppdev->hsemDevLock)
485 {
486 pdcFirst = pdc1;
487 prcFirst = &rc1;
488 pdcSecond = pdc2;
489 prcSecond = &rc2;
490 }
491 else
492 {
493 pdcFirst = pdc2;
494 prcFirst = &rc2;
495 pdcSecond = pdc1;
496 prcSecond = &rc1;
497 }
498 }
499 else
500 {
501 pdcFirst = pdc1 ;
502 prcFirst = &rc1;
503 pdcSecond = NULL ;
504 }
505
506 if(pdcFirst && pdcFirst->dctype == DCTYPE_DIRECT)
507 {
508 EngAcquireSemaphore(pdcFirst->ppdev->hsemDevLock);
509 MouseSafetyOnDrawStart(pdcFirst->ppdev,
510 prcFirst->left,
511 prcFirst->top,
512 prcFirst->right,
513 prcFirst->bottom) ;
514 /* Update surface if needed */
515 if(pdcFirst->ppdev->pSurface != pdcFirst->dclevel.pSurface)
516 {
517 DC_vUpdateDC(pdcFirst);
518 }
519 }
520 if(pdcSecond && pdcSecond->dctype == DCTYPE_DIRECT)
521 {
522 EngAcquireSemaphore(pdcSecond->ppdev->hsemDevLock);
523 MouseSafetyOnDrawStart(pdcSecond->ppdev,
524 prcSecond->left,
525 prcSecond->top,
526 prcSecond->right,
527 prcSecond->bottom) ;
528 /* Update surface if needed */
529 if(pdcSecond->ppdev->pSurface != pdcSecond->dclevel.pSurface)
530 {
531 DC_vUpdateDC(pdcSecond);
532 }
533 }
534 }
535
536 /* Finishes a blit for one or two DCs */
537 VOID
538 FASTCALL
539 DC_vFinishBlit(PDC pdc1, PDC pdc2)
540 {
541 if(pdc1->dctype == DCTYPE_DIRECT)
542 {
543 MouseSafetyOnDrawEnd(pdc1->ppdev);
544 EngReleaseSemaphore(pdc1->ppdev->hsemDevLock);
545 }
546
547 if(pdc2)
548 {
549 if(pdc2->dctype == DCTYPE_DIRECT)
550 {
551 MouseSafetyOnDrawEnd(pdc2->ppdev);
552 EngReleaseSemaphore(pdc2->ppdev->hsemDevLock);
553 }
554 }
555 }
556
557 HDC
558 NTAPI
559 GreOpenDCW(
560 PUNICODE_STRING pustrDevice,
561 DEVMODEW *pdmInit,
562 PUNICODE_STRING pustrLogAddr,
563 ULONG iType,
564 BOOL bDisplay,
565 HANDLE hspool,
566 VOID *pDriverInfo2,
567 VOID *pUMdhpdev)
568 {
569 PPDEVOBJ ppdev;
570 PDC pdc;
571 HDC hdc;
572
573 DPRINT("GreOpenDCW(%S, iType=%ld)\n",
574 pustrDevice ? pustrDevice->Buffer : NULL, iType);
575
576 /* Get a PDEVOBJ for the device */
577 ppdev = EngpGetPDEV(pustrDevice);
578 if (!ppdev)
579 {
580 DPRINT1("Didn't find a suitable PDEV\n");
581 return NULL;
582 }
583
584 DPRINT("GreOpenDCW - ppdev = %p\n", ppdev);
585
586 pdc = DC_AllocDcWithHandle();
587 if (!pdc)
588 {
589 DPRINT1("Could not Allocate a DC\n");
590 PDEVOBJ_vRelease(ppdev);
591 return NULL;
592 }
593 hdc = pdc->BaseObject.hHmgr;
594
595 /* Lock ppdev and initialize the new DC */
596 DC_vInitDc(pdc, iType, ppdev);
597 /* FIXME: HACK! */
598 DC_InitHack(pdc);
599
600 DC_AllocDcAttr(pdc);
601
602 DC_UnlockDc(pdc);
603
604 DPRINT("returning hdc = %p\n", hdc);
605
606 return hdc;
607 }
608
609 HDC
610 APIENTRY
611 NtGdiOpenDCW(
612 PUNICODE_STRING pustrDevice,
613 DEVMODEW *pdmInit,
614 PUNICODE_STRING pustrLogAddr,
615 ULONG iType,
616 BOOL bDisplay,
617 HANDLE hspool,
618 VOID *pDriverInfo2,
619 VOID *pUMdhpdev)
620 {
621 UNICODE_STRING ustrDevice;
622 WCHAR awcDevice[CCHDEVICENAME];
623 DEVMODEW dmInit;
624 PVOID dhpdev;
625 HDC hdc;
626
627 /* Only if a devicename is given, we need any data */
628 if (pustrDevice)
629 {
630 /* Initialize destination string */
631 RtlInitEmptyUnicodeString(&ustrDevice, awcDevice, sizeof(awcDevice));
632
633 _SEH2_TRY
634 {
635 /* Probe the UNICODE_STRING and the buffer */
636 ProbeForRead(pustrDevice, sizeof(UNICODE_STRING), 1);
637 ProbeForRead(pustrDevice->Buffer, pustrDevice->Length, 1);
638
639 /* Copy the string */
640 RtlCopyUnicodeString(&ustrDevice, pustrDevice);
641
642 if (pdmInit)
643 {
644 /* FIXME: could be larger */
645 ProbeForRead(pdmInit, sizeof(DEVMODEW), 1);
646 RtlCopyMemory(&dmInit, pdmInit, sizeof(DEVMODEW));
647 }
648
649 if (pUMdhpdev)
650 {
651 ProbeForWrite(pUMdhpdev, sizeof(HANDLE), 1);
652 }
653 }
654 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
655 {
656 SetLastNtError(_SEH2_GetExceptionCode());
657 _SEH2_YIELD(return NULL);
658 }
659 _SEH2_END
660 }
661 else
662 {
663 pdmInit = NULL;
664 pUMdhpdev = NULL;
665 }
666
667 /* FIXME: HACK! */
668 if (pustrDevice)
669 {
670 UNICODE_STRING ustrDISPLAY = RTL_CONSTANT_STRING(L"DISPLAY");
671 if (RtlEqualUnicodeString(&ustrDevice, &ustrDISPLAY, TRUE))
672 {
673 pustrDevice = NULL;
674 }
675 }
676
677 /* Call the internal function */
678 hdc = GreOpenDCW(pustrDevice ? &ustrDevice : NULL,
679 pdmInit ? &dmInit : NULL,
680 NULL, // fixme pwszLogAddress
681 iType,
682 bDisplay,
683 hspool,
684 NULL, //FIXME: pDriverInfo2
685 pUMdhpdev ? &dhpdev : NULL);
686
687 /* If we got a HDC and a UM dhpdev is requested,... */
688 if (hdc && pUMdhpdev)
689 {
690 /* Copy dhpdev to caller (FIXME: use dhpdev?? */
691 _SEH2_TRY
692 {
693 /* Pointer was already probed */
694 *(HANDLE*)pUMdhpdev = dhpdev;
695 }
696 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
697 {
698 /* Ignore error */
699 }
700 _SEH2_END
701 }
702
703 return hdc;
704 }
705
706
707 HDC
708 APIENTRY
709 NtGdiCreateCompatibleDC(HDC hdc)
710 {
711 HDC hdcNew;
712 PPDEVOBJ ppdev;
713 PDC pdc, pdcNew;
714
715 DPRINT("NtGdiCreateCompatibleDC(0x%p)\n", hdc);
716
717 /* Did the caller provide a DC? */
718 if (hdc)
719 {
720 /* Yes, try to lock it */
721 pdc = DC_LockDc(hdc);
722 if (!pdc)
723 {
724 DPRINT1("Could not lock source DC %p\n", hdc);
725 return NULL;
726 }
727
728 /* Get the pdev from the DC */
729 ppdev = pdc->ppdev;
730 InterlockedIncrement(&ppdev->cPdevRefs);
731
732 /* Unlock the source DC */
733 DC_UnlockDc(pdc);
734 }
735 else
736 {
737 /* No DC given, get default device */
738 ppdev = EngpGetPDEV(NULL);
739 }
740
741 if (!ppdev)
742 {
743 DPRINT1("Didn't find a suitable PDEV\n");
744 return NULL;
745 }
746
747 /* Allocate a new DC */
748 pdcNew = DC_AllocDcWithHandle();
749 if (!pdcNew)
750 {
751 DPRINT1("Could not allocate a new DC\n");
752 PDEVOBJ_vRelease(ppdev);
753 return NULL;
754 }
755 hdcNew = pdcNew->BaseObject.hHmgr;
756
757 /* Lock ppdev and initialize the new DC */
758 DC_vInitDc(pdcNew, DCTYPE_MEMORY, ppdev);
759 /* FIXME: HACK! */
760 DC_InitHack(pdcNew);
761
762 /* Allocate a dc attribute */
763 DC_AllocDcAttr(pdcNew);
764
765 // HACK!
766 DC_vSelectSurface(pdcNew, psurfDefaultBitmap);
767
768 DC_UnlockDc(pdcNew);
769
770 DPRINT("Leave NtGdiCreateCompatibleDC hdcNew = %p\n", hdcNew);
771
772 return hdcNew;
773 }
774
775 BOOL
776 FASTCALL
777 IntGdiDeleteDC(HDC hDC, BOOL Force)
778 {
779 PDC DCToDelete = DC_LockDc(hDC);
780
781 if (DCToDelete == NULL)
782 {
783 SetLastWin32Error(ERROR_INVALID_HANDLE);
784 return FALSE;
785 }
786
787 if (!Force)
788 {
789 /* Windows permits NtGdiDeleteObjectApp to delete a permanent DC
790 * For some reason, it's still a valid handle, pointing to some kernel data.
791 * Not sure if this is a bug, a feature, some cache stuff... Who knows?
792 * See NtGdiDeleteObjectApp test for details */
793 if (DCToDelete->fs & DC_FLAG_PERMANENT)
794 {
795 DC_UnlockDc(DCToDelete);
796 if(UserReleaseDC(NULL, hDC, FALSE))
797 {
798 /* ReactOs feature : call UserReleaseDC
799 * I don't think windows does it.
800 * Still, complain, no one should ever call DeleteDC
801 * on a window DC */
802 DPRINT1("No, you naughty application!\n");
803 return TRUE;
804 }
805 else
806 {
807 /* This is not a window owned DC.
808 * Force its deletion */
809 return IntGdiDeleteDC(hDC, TRUE);
810 }
811 }
812 }
813
814 DC_UnlockDc(DCToDelete);
815
816 if (!IsObjectDead(hDC))
817 {
818 if (!GDIOBJ_FreeObjByHandle(hDC, GDI_OBJECT_TYPE_DC))
819 {
820 DPRINT1("DC_FreeDC failed\n");
821 }
822 }
823 else
824 {
825 DPRINT1("Attempted to Delete 0x%x currently being destroyed!!!\n", hDC);
826 }
827
828 return TRUE;
829 }
830
831 BOOL
832 APIENTRY
833 NtGdiDeleteObjectApp(HANDLE DCHandle)
834 {
835 /* Complete all pending operations */
836 NtGdiFlushUserBatch();
837
838 if (GDI_HANDLE_IS_STOCKOBJ(DCHandle)) return TRUE;
839
840 if (GDI_HANDLE_GET_TYPE(DCHandle) != GDI_OBJECT_TYPE_DC)
841 return GreDeleteObject((HGDIOBJ) DCHandle);
842
843 if (IsObjectDead((HGDIOBJ)DCHandle)) return TRUE;
844
845 if (!GDIOBJ_OwnedByCurrentProcess(DCHandle))
846 {
847 SetLastWin32Error(ERROR_INVALID_HANDLE);
848 return FALSE;
849 }
850
851 return IntGdiDeleteDC(DCHandle, FALSE);
852 }
853
854 BOOL
855 FASTCALL
856 MakeInfoDC(PDC pdc, BOOL bSet)
857 {
858 PSURFACE pSurface;
859 SIZEL sizl;
860
861 /* Can not be a display DC. */
862 if (pdc->fs & DC_FLAG_DISPLAY) return FALSE;
863 if (bSet)
864 {
865 if (pdc->fs & DC_FLAG_TEMPINFODC || pdc->dctype == DC_TYPE_DIRECT)
866 return FALSE;
867
868 pSurface = pdc->dclevel.pSurface;
869 pdc->fs |= DC_FLAG_TEMPINFODC;
870 pdc->pSurfInfo = pSurface;
871 pdc->dctype = DC_TYPE_INFO;
872 pdc->dclevel.pSurface = NULL;
873
874 PDEVOBJ_sizl(pdc->ppdev, &sizl);
875
876 if ( sizl.cx == pdc->dclevel.sizl.cx &&
877 sizl.cy == pdc->dclevel.sizl.cy )
878 return TRUE;
879
880 pdc->dclevel.sizl.cx = sizl.cx;
881 pdc->dclevel.sizl.cy = sizl.cy;
882 }
883 else
884 {
885 if (!(pdc->fs & DC_FLAG_TEMPINFODC) || pdc->dctype != DC_TYPE_INFO)
886 return FALSE;
887
888 pSurface = pdc->pSurfInfo;
889 pdc->fs &= ~DC_FLAG_TEMPINFODC;
890 pdc->dclevel.pSurface = pSurface;
891 pdc->dctype = DC_TYPE_DIRECT;
892 pdc->pSurfInfo = NULL;
893
894 if ( !pSurface ||
895 (pSurface->SurfObj.sizlBitmap.cx == pdc->dclevel.sizl.cx &&
896 pSurface->SurfObj.sizlBitmap.cy == pdc->dclevel.sizl.cy) )
897 return TRUE;
898
899 pdc->dclevel.sizl.cx = pSurface->SurfObj.sizlBitmap.cx;
900 pdc->dclevel.sizl.cy = pSurface->SurfObj.sizlBitmap.cy;
901 }
902 return IntSetDefaultRegion(pdc);
903 }
904
905 /*
906 * @implemented
907 */
908 BOOL
909 APIENTRY
910 NtGdiMakeInfoDC(
911 IN HDC hdc,
912 IN BOOL bSet)
913 {
914 BOOL Ret;
915 PDC pdc = DC_LockDc(hdc);
916 if (pdc)
917 {
918 Ret = MakeInfoDC(pdc, bSet);
919 DC_UnlockDc(pdc);
920 return Ret;
921 }
922 return FALSE;
923 }
924
925
926 HDC FASTCALL
927 IntGdiCreateDC(
928 PUNICODE_STRING Driver,
929 PUNICODE_STRING pustrDevice,
930 PVOID pUMdhpdev,
931 CONST PDEVMODEW pdmInit,
932 BOOL CreateAsIC)
933 {
934 HDC hdc;
935
936 hdc = GreOpenDCW(pustrDevice,
937 pdmInit,
938 NULL,
939 CreateAsIC ? DCTYPE_INFO :
940 (Driver ? DC_TYPE_DIRECT : DC_TYPE_DIRECT),
941 TRUE,
942 NULL,
943 NULL,
944 pUMdhpdev);
945
946 return hdc;
947 }
948
949 HDC FASTCALL
950 IntGdiCreateDisplayDC(HDEV hDev, ULONG DcType, BOOL EmptyDC)
951 {
952 HDC hDC;
953 UNIMPLEMENTED;
954 ASSERT(FALSE);
955
956 if (DcType == DC_TYPE_MEMORY)
957 hDC = NtGdiCreateCompatibleDC(NULL); // OH~ Yuck! I think I taste vomit in my mouth!
958 else
959 hDC = IntGdiCreateDC(NULL, NULL, NULL, NULL, (DcType == DC_TYPE_INFO));
960
961 return hDC;
962 }
963