source: trunk/src/user32/dc.cpp@ 1042

Last change on this file since 1042 was 1042, checked in by sandervl, 26 years ago

Cursor fixes + minor change to RedrawWindow
File size: 31.9 KB
Line 
1/* $Id: dc.cpp,v 1.4 1999-09-25 14:15:36 sandervl Exp $ */
2
3/*
4 * DC functions for USER32
5 *
6 * Project Odin Software License can be found in LICENSE.TXT
7 *
8 */
9
10#define INCL_WIN
11#define INCL_GPI
12#define INCL_GREALL
13#define INCL_DEV
14#include <os2.h>
15#include <pmddi.h>
16#include <os2sel.h>
17#include <stdlib.h>
18#include "win32type.h"
19#include <winconst.h>
20#include <wprocess.h>
21#include <misc.h>
22#include <win32wbase.h>
23#include <math.h>
24#include <limits.h>
25#include "oslibwin.h"
26
27#ifndef OPEN32API
28#define OPEN32API _System
29#endif
30
31/*********************/
32typedef struct _tagXFORM
33{
34 FLOAT eM11;
35 FLOAT eM12;
36 FLOAT eM21;
37 FLOAT eM22;
38 FLOAT eDx;
39 FLOAT eDy;
40} XFORM_W, *PXFORM_W, *LPXFORM_W;
41
42typedef struct
43{
44 HDC hdc;
45 BOOL fErase;
46 RECT rcPaint;
47 BOOL fRestore;
48 BOOL IncUpdate;
49 BYTE rgbReserved[32];
50} PAINTSTRUCT_W, *PPAINTSTRUCT_W, *LPPAINTSTRUCT_W;
51
52#define PS_SOLID_W 0x00000000
53#define PS_DASH_W 0x00000001
54#define PS_DOT_W 0x00000002
55#define PS_DASHDOT_W 0x00000003
56#define PS_DASHDOTDOT_W 0x00000004
57#define PS_NULL_W 0x00000005
58#define PS_INSIDEFRAME_W 0x00000006
59#define PS_USERSTYLE_W 0x00000007
60#define PS_ALTERNATE_W 0x00000008
61#define PS_STYLE_MASK_W 0x0000000f
62
63typedef struct
64{
65 UINT lopnStyle;
66 POINT lopnWidth;
67 ULONG lopnColor;
68} LOGPEN_W, *LPLOGPEN_W;
69
70typedef struct tagEXTLOGPEN
71{
72 DWORD elpPenStyle;
73 DWORD elpWidth;
74 DWORD elpBrushStyle;
75 DWORD elpColor;
76 DWORD elpNumEntries;
77 DWORD elpStyleEntry[1];
78} EXTLOGPEN_W, *PEXTLOGPEN_W, *NPEXTLOGPEN_W, *LPEXTLOGPEN_W;
79
80typedef struct
81{
82 UINT lbStyle;
83 ULONG lbColor;
84 INT lbHatch;
85} LOGBRUSH_W, *LPLOGBRUSH_W;
86
87typedef struct _penobject
88{
89 ULONG filler[9];
90 union {
91 struct {
92 PEXTLOGPEN_W pExtLogPen;
93 LOGBRUSH_W logbrush;
94 LOGPEN_W logpen;
95 } ExtPen;
96 struct {
97 LOGPEN_W logpen;
98 } Pen;
99 };
100} tPenObject, *pPenObject;
101
102/* DC Graphics Mode */
103#define GM_COMPATIBLE_W 1
104#define GM_ADVANCED_W 2
105
106#define DCX_WINDOW_W 0x00000001L
107#define DCX_CACHE_W 0x00000002L
108#define DCX_NORESETATTRS_W 0x00000004L
109#define DCX_CLIPCHILDREN_W 0x00000008L
110#define DCX_CLIPSIBLINGS_W 0x00000010L
111#define DCX_PARENTCLIP_W 0x00000020L
112#define DCX_EXCLUDERGN_W 0x00000040L
113#define DCX_INTERSECTRGN_W 0x00000080L
114#define DCX_EXCLUDEUPDATE_W 0x00000100L
115#define DCX_INTERSECTUPDATE_W 0x00000200L
116#define DCX_LOCKWINDOWUPDATE_W 0x00000400L
117#define DCX_VALIDATE_W 0x00200000L
118
119#define RDW_INVALIDATE_W 0x0001
120#define RDW_INTERNALPAINT_W 0x0002
121#define RDW_ERASE_W 0x0004
122#define RDW_VALIDATE_W 0x0008
123#define RDW_NOINTERNALPAINT_W 0x0010
124#define RDW_NOERASE_W 0x0020
125#define RDW_NOCHILDREN_W 0x0040
126#define RDW_ALLCHILDREN_W 0x0080
127#define RDW_UPDATENOW_W 0x0100
128#define RDW_ERASENOW_W 0x0200
129#define RDW_FRAME_W 0x0400
130#define RDW_NOFRAME_W 0x0800
131
132typedef struct _RGNDATAHEADER_W {
133 DWORD dwSize;
134 DWORD iType;
135 DWORD nCount;
136 DWORD nRgnSize;
137 RECT rcBound;
138} RGNDATAHEADER_W, *LPRGNDATAHEADER_W;
139
140typedef struct _RGNDATA_W {
141 RGNDATAHEADER_W rdh;
142 char Buffer[1];
143} RGNDATA_W , *PRGNDATA_W , *LPRGNDATA_W ;
144
145
146/* Xform FLAGS */
147#define MWT_IDENTITY_W 1
148#define MWT_LEFTMULTIPLY_W 2
149#define MWT_RIGHTMULTIPLY_W 3
150
151/* Mapping Modes */
152#define MM_TEXT_W 1
153#define MM_LOMETRIC_W 2
154#define MM_HIMETRIC_W 3
155#define MM_LOENGLISH_W 4
156#define MM_HIENGLISH_W 5
157#define MM_TWIPS_W 6
158#define MM_ISOTROPIC_W 7
159#define MM_ANISOTROPIC_W 8
160
161enum PS_Type { MICRO_CACHED, MICRO, NORMAL };
162enum HDC_Type{ TYPE_0, TYPE_1, TYPE_2, TYPE_3, TYPE_4 };
163
164typedef struct _DCData
165{
166 HDC hdc;
167 HWND hwnd;
168 HPS hps;
169
170 UINT lastBrushHandle;
171 PVOID lastBrushObject;
172 UINT lastPenHandle;
173 pPenObject lastPenObject;
174 UINT lastFontHandle;
175 PVOID lastFontObject;
176 UINT lastBitmapHandle;
177 PVOID lastBitmapObject;
178 UINT lastPaletteHandle;
179 PVOID lastPaletteObject;
180
181 UINT nullBitmapHandle;
182
183 ULONG BkColor;
184 ULONG TextColor;
185 ULONG BkColor_PM;
186 ULONG TextColor_PM;
187
188 int BkMode;
189 ULONG BkMode_PM;
190
191 int ROP2Mode;
192 int ROP2Mode_PM;
193
194 unsigned isMemoryPS:1;
195 unsigned isMetaPS:1;
196 unsigned isPrinter:1;
197 unsigned isFrameWindow:1;
198 unsigned isOD_QUEUED:1;
199 unsigned isOD_INFO:1;
200 unsigned isClient:1;
201 unsigned isClientArea:1;
202 unsigned isLeftLeft:1;
203 unsigned isTopTop:1;
204 unsigned isWideLine:1;
205 unsigned alignUpdateCP:1;
206 unsigned isCacheable:1;
207 unsigned penIsExtPen:1;
208 unsigned isValid:1;
209 unsigned inPath:1;
210 unsigned isStartDoc:1;
211 unsigned resetStockFonts:1;
212 unsigned unused:14;
213
214 ULONG MapMode;
215 HBITMAP bitmapHandle;
216 ULONG bitmapHeight;
217 ULONG bitmapWidth;
218 ULONG hMeta;
219 PVOID pMetaFileObject;
220 int polyFillMode;
221 int arcDirection;
222 int stretchBltMode;
223 int graphicsMode;
224 HRGN hrgnHDC;
225
226 PS_Type psType;
227
228 HDC_Type hdcType;
229 USHORT usFiller;
230 POINTL viewportOrg;
231 double viewportXExt;
232 double viewportYExt;
233 POINTL windowOrg;
234 SIZEL windowExt;
235 HRGN hrgnVis;
236 POINTL ptlOrigin;
237 ULONG printPageHeight;
238 PVOID printerObject;
239
240 LONG taMode;
241 XFORM_W xform;
242
243 INT worldYDeltaFor1Pixel;
244 INT worldXDeltaFor1Pixel;
245 ULONG colorMode;
246 PULONG pLogColorTable;
247
248 ULONG lcidBitfield;
249
250 HWND hwndRealize;
251 ULONG cpeMap;
252
253 LONG lTechnology;
254
255 LONG lWndXExtSave, lWndYExtSave,
256 lVwpXExtSave, lVwpYExtSave;
257
258 int height;
259
260 POINTL brushOrgPoint;
261
262 PVOID pEnhMetaPalette;
263 PVOID lpAbortProc;
264 ULONG HPStoHDCInversionHeight;
265
266 int saveLevel;
267
268 struct _DCData *nextDCData;
269} tDCData, *pDCData;
270
271/*********************/
272
273BOOL APIENTRY GpiEnableYInversion (HPS hps, LONG lHeight);
274LONG APIENTRY GpiQueryYInversion (HPS hps);
275PVOID APIENTRY GpiAllocateDCData (HPS GpiH, ULONG size);
276PVOID APIENTRY GpiQueryDCData (HPS hps);
277HDC OPEN32API HPSToHDC (HWND hwnd, HPS hps, HDC hdc, PVOID);
278void OPEN32API DeleteHDC (HDC hdc);
279BOOL OPEN32API _O32_EndPaint (HWND hwnd, const PAINTSTRUCT_W *lpps);
280int OPEN32API _O32_GetUpdateRgn (HWND hwnd, HRGN hrgn, BOOL erase);
281ULONG OPEN32API _O32_GetRegionData (HRGN hrgn, ULONG count, PRGNDATA_W pData);
282BOOL OPEN32API _O32_DeleteObject (LHANDLE hgdiobj);
283int OPEN32API _O32_ReleaseDC (HWND hwnd, HDC hdc);
284
285#ifndef DEVESC_SETPS
286 #define DEVESC_SETPS 49149L
287#endif
288
289#define FLOAT_TO_FIXED(x) ((FIXED) ((x) * 65536.0))
290#define MICRO_HPS_TO_HDC(x) ((x) & 0xFFFFFFFE)
291
292#define PMRECT_FROM_WINRECT( pmRect, winRect ) \
293{ \
294 (pmRect).xLeft = (winRect).left; \
295 (pmRect).yBottom = (winRect).bottom; \
296 (pmRect).xRight = (winRect).right; \
297 (pmRect).yTop = (winRect).top; \
298}
299
300#define WINRECT_FROM_PMRECT( winRect, pmRect ) \
301{ \
302 (winRect).left = (pmRect).xLeft; \
303 (winRect).top = (pmRect).yTop; \
304 (winRect).right = (pmRect).xRight; \
305 (winRect).bottom = (pmRect).yBottom; \
306}
307
308#define MEM_HPS_MAX 768
309
310const XFORM_W XFORMIdentity = { 1.0, 0.0, 0.0, 1.0, 0, 0 };
311const MATRIXLF matrixlfIdentity = { 0x10000, 0, 0, 0, 0x10000, 0, 0, 0, 0};
312
313BOOL setPageXForm(Win32BaseWindow *wnd, pDCData pHps);
314BOOL changePageXForm(Win32BaseWindow *wnd, pDCData pHps, PPOINTL pValue, int x, int y, PPOINTL pPrev);
315LONG clientHeight(Win32BaseWindow *wnd, HWND hwnd, pDCData pHps);
316
317void TestWideLine (pDCData pHps)
318{
319 const LOGPEN_W *pLogPen;
320
321 pHps->isWideLine = FALSE;
322 pLogPen = pHps->penIsExtPen ?
323 &(pHps->lastPenObject->ExtPen.logpen) :
324 &(pHps->lastPenObject->Pen.logpen);
325
326 if (((pLogPen->lopnStyle & PS_STYLE_MASK_W) != PS_NULL_W) &&
327 (pLogPen->lopnWidth.x > 0))
328 {
329 POINTL aptl[2] = { 0, 0, pLogPen->lopnWidth.x, pLogPen->lopnWidth.x };
330
331 GpiConvert(pHps->hps, CVTC_WORLD, CVTC_DEVICE, 2, aptl);
332
333 ULONG dx = abs(aptl[0].x - aptl[1].x);
334 ULONG dy = abs(aptl[0].y - aptl[1].y);
335
336 pHps->isWideLine = (dx > 1) || (dy > 1);
337 }
338}
339
340void Calculate1PixelDelta(pDCData pHps)
341{
342 POINTL aptl[2] = {0, 0, 1, 1};
343
344 GpiConvert(pHps->hps, CVTC_DEVICE, CVTC_WORLD, 2, aptl);
345 pHps->worldYDeltaFor1Pixel = (int)(aptl[1].y - aptl[0].y);
346 pHps->worldXDeltaFor1Pixel = (int)(aptl[1].x - aptl[0].x); // 171182
347}
348
349//******************************************************************************
350
351int setMapMode(Win32BaseWindow *wnd, pDCData pHps, int mode)
352{
353 int prevMode = 0;
354 ULONG flOptions;
355
356 switch (mode)
357 {
358 case MM_HIENGLISH_W : flOptions = PU_HIENGLISH; break;
359 case MM_LOENGLISH_W : flOptions = PU_LOENGLISH; break;
360 case MM_HIMETRIC_W : flOptions = PU_HIMETRIC ; break;
361 case MM_LOMETRIC_W : flOptions = PU_LOMETRIC ; break;
362 case MM_TEXT_W : flOptions = PU_PELS ; break;
363 case MM_TWIPS_W : flOptions = PU_TWIPS ; break;
364 case MM_ANISOTROPIC_W: flOptions = PU_PELS ; break;
365 case MM_ISOTROPIC_W : flOptions = PU_LOMETRIC ; break;
366 default:
367// SET_ERROR_WIN(ERROR_INVALID_PARAMETER_W);
368 return FALSE;
369 }
370
371 prevMode = pHps->MapMode; /* store previous mode */
372 pHps->MapMode = mode;
373
374 if (mode == MM_TEXT_W)
375 {
376 pHps->viewportXExt =
377 pHps->viewportYExt = 1.0;
378 pHps->windowExt.cx =
379 pHps->windowExt.cy = 1;
380 }
381 else if (mode != MM_ANISOTROPIC_W)
382 {
383 RECTL rectl;
384 SIZEL sizel;
385 ULONG data[3];
386
387 data[0] = flOptions;
388 data[1] = data[2] = 0;
389
390 if (DevEscape(pHps->hdc ? pHps->hdc : pHps->hps, DEVESC_SETPS, 12, (PBYTE)data, 0, 0) == DEVESC_ERROR)
391 {
392// SET_ERROR_LAST();
393 return 0;
394 }
395
396 GpiQueryPageViewport(pHps->hps, &rectl);
397 pHps->viewportXExt = (double)rectl.xRight;
398 pHps->viewportYExt = -(double)rectl.yTop;
399
400 GreGetPageUnits(pHps->hdc? pHps->hdc : pHps->hps, &sizel);
401 pHps->windowExt.cx = sizel.cx;
402 pHps->windowExt.cy = sizel.cy;
403
404 data[0] = PU_PELS;
405 DevEscape(pHps->hdc ? pHps->hdc : pHps->hps, DEVESC_SETPS, 12, (PBYTE)data, 0, 0);
406 }
407
408 if (((prevMode != MM_ISOTROPIC_W) && (prevMode != MM_ANISOTROPIC_W)) &&
409 ((mode == MM_ISOTROPIC_W) || (mode == MM_ANISOTROPIC_W)))
410 {
411 if (pHps->lWndXExtSave && pHps->lWndYExtSave)
412 {
413 changePageXForm (wnd, pHps, (PPOINTL)&pHps->windowExt,
414 pHps->lWndXExtSave, pHps->lWndYExtSave, NULL );
415 pHps->lWndXExtSave = pHps->lWndYExtSave = 0;
416 }
417 if (pHps->lVwpXExtSave && pHps->lVwpYExtSave)
418 {
419 changePageXForm (wnd, pHps, NULL,
420 pHps->lVwpXExtSave, pHps->lVwpYExtSave, NULL );
421 pHps->lVwpXExtSave = pHps->lVwpYExtSave = 0;
422 }
423 }
424
425 setPageXForm(wnd, pHps);
426
427 return prevMode;
428}
429
430BOOL setPageXForm(Win32BaseWindow *wnd, pDCData pHps)
431{
432 MATRIXLF mlf;
433 BOOL rc = TRUE;
434
435 pHps->height = clientHeight(wnd, 0, pHps) - 1;
436
437 double xScale = pHps->viewportXExt / (double)pHps->windowExt.cx;
438 double yScale = pHps->viewportYExt / (double)pHps->windowExt.cy;
439
440 mlf.fxM11 = FLOAT_TO_FIXED(xScale);
441 mlf.fxM12 = 0;
442 mlf.lM13 = 0;
443 mlf.fxM21 = 0;
444 mlf.fxM22 = FLOAT_TO_FIXED(yScale);
445 mlf.lM23 = 0;
446 mlf.lM31 = pHps->viewportOrg.x - (LONG)(pHps->windowOrg.x * xScale);
447 mlf.lM32 = pHps->viewportOrg.y - (LONG)(pHps->windowOrg.y * yScale);
448
449 pHps->isLeftLeft = mlf.fxM11 >= 0;
450 pHps->isTopTop = mlf.fxM22 >= 0;
451
452 BOOL bEnableYInversion = FALSE;
453 if ((mlf.fxM22 > 0) ||
454 ((pHps->graphicsMode == GM_ADVANCED_W) &&
455 ((pHps->MapMode == MM_ANISOTROPIC_W) ||
456 (pHps->MapMode == MM_ISOTROPIC_W))))
457 {
458 bEnableYInversion = TRUE;
459 }
460 else
461 {
462 bEnableYInversion = FALSE;
463 mlf.lM32 = pHps->HPStoHDCInversionHeight + pHps->height - mlf.lM32;
464 mlf.fxM22 = -mlf.fxM22;
465 }
466
467 if (!pHps->isMetaPS)
468// if ((!pHps->isMetaPS) ||
469// (pHps->pMetaFileObject && pHps->pMetaFileObject->isEnhanced()))
470 rc = GpiSetDefaultViewMatrix(pHps->hps, 8, &mlf, TRANSFORM_REPLACE);
471
472 if (bEnableYInversion)
473 GpiEnableYInversion(pHps->hps, pHps->height + pHps->HPStoHDCInversionHeight);
474 else
475 GpiEnableYInversion(pHps->hps, 0);
476
477 TestWideLine(pHps);
478 Calculate1PixelDelta(pHps);
479 return rc;
480}
481
482BOOL changePageXForm(Win32BaseWindow *wnd, pDCData pHps, PPOINTL pValue, int x, int y, PPOINTL pPrev)
483{
484 BOOL result = FALSE;
485
486 if (pValue)
487 {
488 if (pPrev)
489 *pPrev = *pValue;
490
491 if ((pValue->x == x) && (pValue->y == y)) {
492 return TRUE;
493 }
494 pValue->x = x;
495 pValue->y = y;
496 }
497 else
498 {
499 if (pPrev)
500 {
501 pPrev->x = (int)pHps->viewportXExt;
502 pPrev->y = (int)pHps->viewportYExt;
503 }
504 pHps->viewportXExt = (double)x;
505 pHps->viewportYExt = (double)y;
506 }
507
508 if (pHps->MapMode == MM_ISOTROPIC_W)
509 {
510 double xExt = fabs(pHps->viewportXExt);
511 double yExt = fabs(pHps->viewportYExt);
512 double sf = fabs((double)pHps->windowExt.cx / pHps->windowExt.cy);
513
514 if (xExt > (yExt * sf))
515 {
516 xExt = yExt * sf;
517
518 if ((double)LONG_MAX <= xExt) return (result);
519
520 if (pHps->viewportXExt < 0.0)
521 pHps->viewportXExt = -xExt;
522 else
523 pHps->viewportXExt = xExt;
524 }
525 else
526 {
527 yExt = xExt / sf;
528
529 if ((double)LONG_MAX <= yExt) return (result);
530
531 if (pHps->viewportYExt < 0.0)
532 pHps->viewportYExt = -yExt;
533 else
534 pHps->viewportYExt = yExt;
535 }
536 }
537 result = setPageXForm(wnd, pHps);
538
539 return (result);
540}
541
542LONG clientHeight(Win32BaseWindow *wnd, HWND hwnd, pDCData pHps)
543{
544 if ((hwnd == 0) && (pHps != 0))
545 hwnd = pHps->hwnd;
546
547 if ((hwnd != 0) || (pHps == 0))
548 {
549 if (wnd)
550 return (wnd->getWindowHeight());
551 else
552 return OSLibQueryScreenHeight();
553 }
554 else if (pHps->bitmapHandle)
555 {
556 return pHps->bitmapHeight;
557 }
558 else if (pHps->isMetaPS)
559 {
560 return 0;
561 }
562 else if (pHps->isPrinter)
563 {
564 return pHps->printPageHeight;
565 }
566 else
567 {
568 return MEM_HPS_MAX;
569 }
570}
571
572VOID removeClientArea(pDCData pHps)
573{
574 pHps->isClient = FALSE;
575
576 if (pHps->isClientArea)
577 {
578 pHps->isClientArea = FALSE;
579 GreSetupDC(pHps->hps,
580 pHps->hrgnVis,
581 pHps->ptlOrigin.x,
582 pHps->ptlOrigin.y,
583 0,
584 SETUPDC_ORIGIN | SETUPDC_VISRGN | SETUPDC_RECALCCLIP);
585 }
586}
587
588BOOL selectClientArea(Win32BaseWindow *wnd, pDCData pHps, PRECTL prclPaint)
589{
590 RECTL rcl;
591 HRGN hrgnRect;
592 HWND hwnd;
593
594 if (!wnd) return (FALSE);
595
596 pHps->isClient = TRUE;
597 hwnd = pHps->hwnd;
598
599 rcl.xLeft = rcl.yBottom = 0;
600 rcl.xRight = wnd->getWindowWidth();
601 rcl.yTop = wnd->getWindowHeight();
602
603 WinMapWindowPoints(hwnd, HWND_DESKTOP, (PPOINTL) &rcl, 2);
604 pHps->ptlOrigin = *((PPOINTL) &rcl);
605
606 if (pHps->hrgnVis == 0)
607 pHps->hrgnVis = GreCreateRectRegion(pHps->hps, &rcl, 1);
608
609 hrgnRect = GreCreateRectRegion(pHps->hps, &rcl, 1);
610
611 if (!pHps->isClientArea)
612 GreCopyClipRegion(pHps->hps, pHps->hrgnVis, 0, COPYCRGN_VISRGN);
613
614 GreCombineRegion(pHps->hps, hrgnRect, pHps->hrgnVis, hrgnRect, CRGN_AND);
615 GreSetupDC(pHps->hps,
616 hrgnRect,
617 rcl.xLeft,
618 rcl.yBottom,
619 prclPaint,
620 SETUPDC_ORIGIN | SETUPDC_VISRGN | SETUPDC_RECALCCLIP);
621
622 pHps->isClientArea = TRUE;
623 GreDestroyRegion(pHps->hps, hrgnRect);
624
625 return (TRUE);
626}
627
628HDC sendEraseBkgnd (Win32BaseWindow *wnd)
629{
630 BOOL erased;
631 HWND hwnd;
632 HDC hdc;
633 HPS hps;
634 HRGN hrgnUpdate, hrgnOld, hrgnClip, hrgnCombined;
635 RECTL rectl = { 1, 1, 2, 2 };
636
637 hwnd = wnd->getOS2WindowHandle();
638 hps = WinGetPS(hwnd);
639
640 hrgnUpdate = GpiCreateRegion (hps, 1, &rectl);
641 WinQueryUpdateRegion (hwnd, hrgnUpdate);
642 hrgnClip = GpiQueryClipRegion (hps);
643
644 if (hrgnClip == NULLHANDLE)
645 {
646 GpiSetClipRegion (hps, hrgnUpdate, &hrgnOld);
647 }
648 else
649 {
650 hrgnCombined = GpiCreateRegion (hps, 1, &rectl);
651 GpiCombineRegion (hps, hrgnCombined, hrgnClip, hrgnUpdate, CRGN_AND);
652 GpiSetClipRegion (hps, hrgnCombined, &hrgnOld);
653 GpiDestroyRegion (hps, hrgnUpdate);
654 GpiDestroyRegion (hps, hrgnClip);
655 }
656 if (hrgnOld != NULLHANDLE)
657 GpiDestroyRegion (hps, hrgnOld);
658
659 hdc = HPSToHDC (hwnd, hps, NULL, NULL);
660
661 erased = wnd->MsgEraseBackGround (hdc);
662
663 DeleteHDC (hdc);
664 WinReleasePS (hps);
665
666 return erased;
667}
668
669void releaseOwnDC (HDC hps)
670{
671 pDCData pHps = (pDCData)GpiQueryDCData ((HPS)hps);
672
673 if (pHps) {
674 if (pHps->hrgnHDC)
675 GpiDestroyRegion (pHps->hps, pHps->hrgnHDC);
676
677 GpiSetBitmap (pHps->hps, NULL);
678 _O32_DeleteObject (pHps->nullBitmapHandle);
679 GpiDestroyPS(pHps->hps);
680
681 if (pHps->hdc)
682 DevCloseDC(pHps->hdc);
683
684// how can a memory chunk allocated by GpiAllocateDCData freed by delete?
685// delete pHps;
686 }
687}
688
689HDC WIN32API BeginPaint (HWND hWnd, PPAINTSTRUCT_W lpps)
690{
691 HWND hwnd = hWnd ? hWnd : HWND_DESKTOP;
692 pDCData pHps = NULLHANDLE;
693 RECTL rect;
694 HPS hPS_ownDC = NULLHANDLE;
695
696dprintf (("USER32: BeginPaint(%x)", hWnd));
697
698 if ( !lpps )
699 {
700// SET_ERROR_WIN( ERROR_INVALID_PARAMETER_W );
701 return (HDC)NULLHANDLE;
702 }
703
704 USHORT sel = RestoreOS2FS();
705 Win32BaseWindow *wnd = Win32BaseWindow::GetWindowFromHandle(hwnd);
706
707 if ((hwnd != HWND_DESKTOP) && wnd->isOwnDC())
708 {
709 hPS_ownDC = wnd->getOwnDC();
710 pHps = (pDCData)GpiQueryDCData(hPS_ownDC);
711 if (!pHps)
712 {
713// SET_ERROR_LAST();
714 SetFS(sel);
715 return (HDC)NULLHANDLE;
716 }
717 }
718
719 HWND hwndClient = wnd->getOS2WindowHandle();
720 HPS hps = WinBeginPaint(hwndClient, hPS_ownDC, &rect);
721
722 if (!pHps)
723 {
724 HDC hdc = HPSToHDC (hwndClient, hps, NULL, NULL);
725 pHps = (pDCData)GpiQueryDCData(hps);
726 }
727
728 if (wnd->isFrameWindow())
729 {
730// WinSendMsg( hwnd, /* WM_DRAW */ 0x20D, (MPARAM)hps, MPVOID );
731 selectClientArea(wnd, pHps, &rect);
732 }
733
734 if (hPS_ownDC == 0)
735 setMapMode (wnd, pHps, MM_TEXT_W);
736 else
737 setPageXForm (wnd, pHps);
738
739 pHps->hdcType = TYPE_3;
740 lpps->hdc = (HDC)hps;
741
742 if (wnd->isEraseBkgnd())
743 wnd->setEraseBkgnd (FALSE, !wnd->MsgEraseBackGround(lpps->hdc));
744 wnd->setSupressErase (FALSE);
745 lpps->fErase = wnd->isPSErase();
746
747 if (!hPS_ownDC)
748 {
749 long height = wnd->getWindowHeight();
750 rect.yTop = height - rect.yTop;
751 rect.yBottom = height - rect.yBottom;
752 }
753 else
754 {
755 rect.yTop--;
756 rect.yBottom--;
757 GpiConvert(pHps->hps, CVTC_DEVICE, CVTC_WORLD, 2, (PPOINTL)&rect);
758 }
759
760 WINRECT_FROM_PMRECT(lpps->rcPaint, rect);
761
762 SetFS(sel);
763 return (HDC)pHps->hps;
764}
765
766BOOL WIN32API EndPaint (HWND hwnd, const PAINTSTRUCT_W *pPaint)
767{
768dprintf (("USER32: EndPaint(%x)", hwnd));
769
770 if (!pPaint || !pPaint->hdc )
771 return TRUE;
772
773 USHORT sel = RestoreOS2FS();
774 Win32BaseWindow *wnd = Win32BaseWindow::GetWindowFromHandle(hwnd);
775
776 if (!wnd) goto exit;
777
778 if (wnd->isOwnDC())
779 {
780 pDCData pHps = (pDCData)GpiQueryDCData((HPS)pPaint->hdc);
781 if (pHps && (pHps->hdcType == TYPE_3))
782 {
783 removeClientArea (pHps);
784 WinEndPaint (pHps->hps);
785 }
786 }
787 else
788 {
789 _O32_EndPaint (HWND_DESKTOP, pPaint);
790 }
791
792exit:
793 SetFS(sel);
794 return TRUE;
795}
796
797BOOL WIN32API GetUpdateRect (HWND hwnd, LPRECT pRect, BOOL erase)
798{
799 if (hwnd)
800 {
801// SET_ERROR_WIN( ERROR_INVALID_HANDLE_W );
802 return FALSE;
803 }
804
805 RECTL rectl;
806 USHORT sel = RestoreOS2FS();
807 Win32BaseWindow *wnd = Win32BaseWindow::GetWindowFromHandle(hwnd);
808
809 BOOL updateRegionExists = WinQueryUpdateRect (hwnd, pRect ? &rectl : NULL);
810 if (!pRect) {
811 SetFS(sel);
812 return (updateRegionExists);
813 }
814
815 if (updateRegionExists)
816 {
817 if (wnd->isOwnDC())
818 {
819 pDCData pHps = NULL;
820 pHps = (pDCData)GpiQueryDCData(wnd->getOwnDC());
821 if (!pHps)
822 {
823// SET_ERROR_WIN(ERROR_INVALID_HANDLE_W);
824 SetFS(sel);
825 return FALSE;
826 }
827 GpiConvert (pHps->hps, CVTC_DEVICE, CVTC_WORLD, 2, (PPOINTL)&rectl);
828 }
829 else
830 {
831 long height = wnd->getWindowHeight();
832 rectl.yTop = height - rectl.yTop;
833 rectl.yBottom = height - rectl.yBottom;
834 }
835
836 if (pRect)
837 WINRECT_FROM_PMRECT (*pRect, rectl);
838
839 if (erase)
840 sendEraseBkgnd (wnd);
841 }
842 else
843 {
844 if (pRect)
845 pRect->left = pRect->top = pRect->right = pRect->bottom = 0;
846 }
847
848 SetFS(sel);
849 return updateRegionExists;
850}
851
852int WIN32API GetUpdateRgn (HWND hwnd, HRGN hrgn, BOOL erase)
853{
854 USHORT sel = RestoreOS2FS();
855 LONG Complexity;
856
857 Complexity = _O32_GetUpdateRgn (hwnd, hrgn, FALSE);
858 if (erase && (Complexity > NULLREGION_W)) {
859 Win32BaseWindow *wnd = Win32BaseWindow::GetWindowFromHandle(hwnd);
860 sendEraseBkgnd (wnd);
861 }
862
863 SetFS(sel);
864 return Complexity;
865}
866
867// This implementation of GetDCEx supports
868// DCX_WINDOW
869// DCX_CACHE
870// DCX_EXCLUDERGN (complex regions allowed)
871// DCX_INTERSECTRGN (complex regions allowed)
872
873HDC WIN32API GetDCEx (HWND hwnd, HRGN hrgn, ULONG flags)
874{
875 USHORT sel = RestoreOS2FS();
876 Win32BaseWindow *wnd = NULL;
877 HWND hWindow;
878 BOOL success;
879 pDCData pHps = NULL;
880 HPS hps = NULLHANDLE;
881 BOOL drawingAllowed = TRUE;
882 BOOL isWindowOwnDC;
883 BOOL creatingOwnDC = FALSE;
884 PS_Type psType;
885
886 if (hwnd)
887 {
888 wnd = Win32BaseWindow::GetWindowFromHandle(hwnd);
889 if (flags & DCX_WINDOW_W)
890 hWindow = wnd->getOS2FrameWindowHandle();
891 else
892 hWindow = wnd->getOS2WindowHandle();
893 }
894 else
895 hWindow = HWND_DESKTOP;
896
897dprintf (("User32: GetDCEx hwnd %x (%x %x) -> wnd %x", hwnd, hrgn, flags, wnd));
898
899 isWindowOwnDC = (((hWindow == HWND_DESKTOP) ? FALSE : wnd->isOwnDC())
900 && !(flags & DCX_CACHE_W));
901 if (isWindowOwnDC)
902 {
903 hps = wnd->getOwnDC();
904 if (hps)
905 {
906 pDCData pHps = (pDCData)GpiQueryDCData (hps);
907 if (!pHps)
908 goto error;
909
910 if (flags & DCX_WINDOW_W)
911 removeClientArea (pHps);
912 else
913 selectClientArea (wnd, pHps, 0);
914
915 setPageXForm (wnd, pHps);
916
917 pHps->hdcType = TYPE_1;
918 SetFS(sel);
919 return (HDC)hps;
920 }
921 else
922 creatingOwnDC = TRUE;
923 }
924
925 if (isWindowOwnDC)
926 {
927 SIZEL sizel = {0,0};
928 hps = GpiCreatePS (WinQueryAnchorBlock (hWindow),
929 WinOpenWindowDC (hWindow),
930 &sizel, PU_PELS | GPIT_MICRO | GPIA_ASSOC );
931 psType = MICRO;
932 }
933 else
934 {
935 if (hWindow == HWND_DESKTOP)
936 hps = WinGetScreenPS (hWindow);
937 else
938 hps = WinGetPS (hWindow);
939
940 psType = MICRO_CACHED;
941 }
942
943 if (!hps)
944 goto error;
945
946 HPSToHDC (hWindow, hps, NULL, NULL);
947 pHps = (pDCData)GpiQueryDCData (hps);
948
949 if (!(flags & DCX_WINDOW_W)) {
950 if (selectClientArea (wnd, pHps, 0))
951 setMapMode (wnd, pHps, MM_TEXT_W);
952 }
953
954 if ((flags & DCX_EXCLUDERGN_W) || (flags & DCX_INTERSECTRGN_W))
955 {
956 ULONG BytesNeeded;
957 PRGNDATA_W RgnData;
958 PRECTL pr;
959 int i;
960 LONG height = OSLibQueryScreenHeight();
961
962 if (!hrgn)
963 goto error;
964
965 BytesNeeded = _O32_GetRegionData (hrgn, 0, NULL);
966 RgnData = (PRGNDATA_W)_alloca (BytesNeeded);
967 if (RgnData == NULL)
968 goto error;
969 _O32_GetRegionData (hrgn, BytesNeeded, RgnData);
970
971 i = RgnData->rdh.nCount;
972 pr = (PRECTL)(RgnData->Buffer);
973
974 success = TRUE;
975 if (flags & DCX_EXCLUDERGN_W)
976 for (; (i > 0) && success; i--, pr++) {
977 LONG y = pr->yBottom;
978
979 pr->yBottom = height - pr->yTop;
980 pr->yTop = height - y;
981 success &= GpiExcludeClipRectangle (pHps->hps, pr);
982 }
983 else
984 for (; (i > 0) && success; i--, pr++) {
985 LONG y = pr->yBottom;
986
987 pr->yBottom = height - pr->yTop;
988 pr->yTop = height - y;
989 success &= GpiIntersectClipRectangle (pHps->hps, pr);
990 }
991 if (!success)
992 goto error;
993 }
994
995 if (creatingOwnDC)
996 wnd->setOwnDC ((HDC)hps);
997
998 pHps->psType = psType;
999 pHps->hdcType = TYPE_1;
1000 GpiSetDrawControl (hps, DCTL_DISPLAY, drawingAllowed ? DCTL_ON : DCTL_OFF);
1001
1002 SetFS(sel);
1003 return (HDC)pHps->hps;
1004
1005error:
1006 /* Something went wrong; clean up
1007 */
1008 if (pHps)
1009 {
1010 if (pHps->hps)
1011 {
1012 if(pHps->psType == MICRO_CACHED)
1013 WinReleasePS(pHps->hps);
1014 else
1015 GpiDestroyPS(pHps->hps);
1016 }
1017
1018 if (pHps->hdc) DevCloseDC(pHps->hdc);
1019 if (pHps->hrgnHDC) GpiDestroyRegion(pHps->hps, pHps->hrgnHDC);
1020
1021 _O32_DeleteObject (pHps->nullBitmapHandle);
1022 }
1023// SET_ERROR_LAST();
1024 SetFS(sel);
1025 return NULL;
1026}
1027
1028HDC WIN32API GetDC (HWND hwnd)
1029{
1030 return GetDCEx (hwnd, NULL, 0);
1031}
1032
1033HDC WIN32API GetWindowDC (HWND hwnd)
1034{
1035 return GetDCEx (hwnd, NULL, DCX_WINDOW_W);
1036}
1037
1038int WIN32API ReleaseDC (HWND hwnd, HDC hdc)
1039{
1040 USHORT sel = RestoreOS2FS();
1041 BOOL isOwnDC = FALSE;
1042 int rc;
1043
1044 if (hwnd)
1045 {
1046 Win32BaseWindow *wnd = Win32BaseWindow::GetWindowFromHandle (hwnd);
1047 isOwnDC = wnd->isOwnDC();
1048 }
1049 if (isOwnDC)
1050 rc = TRUE;
1051 else
1052 rc = _O32_ReleaseDC (0, hdc);
1053
1054 SetFS(sel);
1055 dprintf(("ReleaseDC %x %x", hwnd, hdc));
1056 return (rc);
1057}
1058
1059BOOL WIN32API UpdateWindow (HWND hwnd)
1060{
1061 if (!hwnd)
1062 return FALSE;
1063
1064 USHORT sel = RestoreOS2FS();
1065 Win32BaseWindow *wnd = Win32BaseWindow::GetWindowFromHandle (hwnd);
1066
1067dprintf (("User32: UpdateWindow hwnd %x -> wnd %x", hwnd, wnd));
1068
1069 if (WinQueryUpdateRect (wnd->getOS2WindowHandle(), NULL))
1070 sendEraseBkgnd (wnd);
1071
1072 wnd->MsgPaint(0);
1073
1074 SetFS(sel);
1075 return (TRUE);
1076}
1077
1078// This implementation of RedrawWindow supports
1079// RDW_ERASE
1080// RDW_NOERASE
1081// RDW_INTERNALPAINT
1082// RDW_NOINTERNALPAINT
1083// RDW_INVALIDATE
1084// RDW_VALIDATE
1085// RDW_ERASENOW
1086// RDW_UPDATENOW
1087
1088BOOL WIN32API RedrawWindow (HWND hwnd, const RECT *pRect, HRGN hrgn, DWORD redraw)
1089{
1090 Win32BaseWindow *wnd;
1091
1092 if (redraw & (RDW_FRAME_W | RDW_NOFRAME_W))
1093 {
1094// SET_ERROR_WIN( ERROR_NOT_SUPPORTED_W );
1095 return FALSE;
1096 }
1097
1098 USHORT sel = RestoreOS2FS();
1099 dprintf(("USER32: RedrawWindow %X, %X %X %X", hwnd, pRect, hrgn, redraw));
1100
1101 if (hwnd == NULLHANDLE) {
1102 hwnd = HWND_DESKTOP;
1103 wnd = Win32BaseWindow::GetWindowFromOS2Handle(OSLIB_HWND_DESKTOP);
1104 }
1105 else
1106 {
1107 wnd = Win32BaseWindow::GetWindowFromHandle (hwnd);
1108
1109 if (!wnd)
1110 {
1111// SET_ERROR_LAST();
1112 SetFS(sel);
1113 return FALSE;
1114 }
1115 hwnd = wnd->getOS2WindowHandle();
1116 }
1117
1118 BOOL IncludeChildren = redraw & RDW_ALLCHILDREN_W ? TRUE : FALSE;
1119 BOOL success = TRUE;
1120 HPS hpsTemp = NULLHANDLE;
1121 HRGN hrgnTemp = NULLHANDLE;
1122 RECTL rectl;
1123
1124 if (redraw & RDW_UPDATENOW_W) redraw &= ~RDW_ERASENOW_W;
1125
1126 if (redraw & RDW_NOERASE_W)
1127 wnd->setEraseBkgnd (FALSE);
1128
1129 if (redraw & RDW_UPDATENOW_W)
1130 wnd->setSupressErase (FALSE);
1131 else if (redraw & RDW_ERASENOW_W)
1132 wnd->setSupressErase (FALSE);
1133#if 0
1134 else
1135 {
1136 QMSG qmsg;
1137 BOOL erase;
1138
1139 erase = (WinPeekMsg (HABX, &qmsg, hwnd, WM_PAINT, WM_PAINT, PM_REMOVE)
1140 && (redraw & RDW_NOERASE_W) == 0);
1141
1142 wnd->setSupressErase (!erase);
1143 }
1144
1145 if (redraw & (RDW_NOINTERNALPAINT_W | RDW_INTERNALPAINT_W))
1146 {
1147 QMSG qmsg;
1148
1149 WinPeekMsg( (HAB)0, &qmsg, hwnd, WM_VIRTUAL_INTERNALPAINT,
1150 WM_VIRTUAL_INTERNALPAINT, PM_REMOVE );
1151 }
1152#endif
1153
1154 if (hrgn)
1155 {
1156 ULONG BytesNeeded;
1157 PRGNDATA_W RgnData;
1158 PRECTL pr;
1159 int i;
1160 LONG height = wnd ? wnd->getWindowHeight() : OSLibQueryScreenHeight();
1161
1162 if (!hrgn)
1163 goto error;
1164
1165 BytesNeeded = _O32_GetRegionData (hrgn, 0, NULL);
1166 RgnData = (PRGNDATA_W)_alloca (BytesNeeded);
1167 if (RgnData == NULL)
1168 goto error;
1169 _O32_GetRegionData (hrgn, BytesNeeded, RgnData);
1170
1171 pr = (PRECTL)(RgnData->Buffer);
1172 for (i = RgnData->rdh.nCount; i > 0; i--, pr++) {
1173 LONG temp = pr->yTop;
1174 pr->yTop = height - pr->yBottom;
1175 pr->yBottom = height - temp;
1176 }
1177
1178 hpsTemp = WinGetScreenPS (HWND_DESKTOP);
1179 hrgnTemp = GpiCreateRegion (hpsTemp, RgnData->rdh.nCount, (PRECTL)(RgnData->Buffer));
1180 if (!hrgnTemp) goto error;
1181 }
1182 else if (pRect)
1183 {
1184 LONG height = wnd ? wnd->getWindowHeight() : OSLibQueryScreenHeight();
1185
1186 PMRECT_FROM_WINRECT (rectl, *pRect);
1187 rectl.yTop = height - rectl.yTop;
1188 rectl.yBottom = height - rectl.yBottom;
1189 }
1190
1191 if (redraw & RDW_INVALIDATE_W)
1192 {
1193 if (redraw & RDW_ERASE_W)
1194 wnd->setEraseBkgnd (TRUE, TRUE);
1195
1196 if (!pRect && !hrgn)
1197 success = WinInvalidateRect (hwnd, NULL, IncludeChildren);
1198 else if (hrgn)
1199 success = WinInvalidateRegion (hwnd, hrgnTemp, IncludeChildren);
1200 else
1201 success = WinInvalidateRect (hwnd, &rectl, IncludeChildren);
1202 if (!success) goto error;
1203 }
1204 else if (redraw & RDW_VALIDATE_W)
1205 {
1206 if (WinQueryUpdateRect (hwnd, NULL))
1207 {
1208 if (!pRect && !hrgn)
1209 success = WinValidateRect (hwnd, NULL, IncludeChildren);
1210 else if (hrgn)
1211 success = WinValidateRegion (hwnd, hrgnTemp, IncludeChildren);
1212 else
1213 success = WinValidateRect (hwnd, &rectl, IncludeChildren);
1214 if (!success) goto error;
1215 }
1216 }
1217
1218 if (WinQueryUpdateRect (hwnd, NULL))
1219 {
1220 if (redraw & RDW_UPDATENOW_W)
1221 wnd->MsgPaint (0, FALSE);
1222
1223 else if ((redraw & RDW_ERASE_W) && (redraw & RDW_ERASENOW_W))
1224 wnd->setEraseBkgnd (FALSE, !sendEraseBkgnd (wnd));
1225 }
1226 else if ((redraw & RDW_INTERNALPAINT_W) && !(redraw & RDW_INVALIDATE_W))
1227 {
1228 if (redraw & RDW_UPDATENOW_W)
1229 wnd->MsgPaint (0, FALSE);
1230// else
1231// WinPostMsg( hwnd, WM_VIRTUAL_INTERNALPAINT, MPVOID, MPVOID );
1232 }
1233
1234error:
1235 /* clean up */
1236 if (hrgnTemp)
1237 GpiDestroyRegion (hpsTemp, hrgnTemp);
1238
1239 if (hpsTemp)
1240 WinReleasePS (hpsTemp);
1241
1242 if ((redraw & RDW_INVALIDATE_W) == 0)
1243 wnd->setSupressErase (FALSE);
1244 else if ((redraw & RDW_ERASENOW_W) == RDW_ERASENOW_W)
1245 wnd->setSupressErase (TRUE);
1246
1247// if (!success)
1248// SET_ERROR_LAST();
1249
1250 SetFS(sel);
1251 return (success);
1252}
1253
1254BOOL WIN32API InvalidateRect (HWND hwnd, const RECT *pRect, BOOL erase)
1255{
1256 USHORT sel = RestoreOS2FS();
1257// Win32BaseWindow *wnd = Win32BaseWindow::GetWindowFromHandle (hwnd);
1258 BOOL result;
1259
1260// todo !!
1261// if ( isFrame without client )
1262// erase = TRUE;
1263
1264 result = RedrawWindow (hwnd, pRect, NULLHANDLE,
1265 RDW_ALLCHILDREN_W | RDW_INVALIDATE_W |
1266 (erase ? RDW_ERASE_W : 0) |
1267 (hwnd == NULLHANDLE ? RDW_UPDATENOW_W : 0));
1268 SetFS(sel);
1269 return (result);
1270}
1271
1272BOOL WIN32API InvalidateRgn (HWND hwnd, HRGN hrgn, BOOL erase)
1273{
1274 USHORT sel = RestoreOS2FS();
1275// Win32BaseWindow *wnd = Win32BaseWindow::GetWindowFromHandle (hwnd);
1276 BOOL result;
1277
1278// todo !!
1279// if ( isFrame without client )
1280// erase = TRUE;
1281
1282 result = RedrawWindow (hwnd, NULL, hrgn,
1283 RDW_ALLCHILDREN_W | RDW_INVALIDATE_W |
1284 (erase ? RDW_ERASE_W : 0) |
1285 (hwnd == NULLHANDLE ? RDW_UPDATENOW_W : 0));
1286 SetFS(sel);
1287 return (result);
1288}
1289
1290//******************************************************************************
1291//******************************************************************************
1292
Note: See TracBrowser for help on using the repository browser.