Release 960516
[wine] / windows / dce.c
1 /*
2  * USER DCE functions
3  *
4  * Copyright 1993 Alexandre Julliard
5  *
6 static char Copyright[] = "Copyright  Alexandre Julliard, 1993";
7 */
8
9 #include "dce.h"
10 #include "class.h"
11 #include "win.h"
12 #include "gdi.h"
13 #include "user.h"
14 #include "sysmetrics.h"
15 #include "stddebug.h"
16 /* #define DEBUG_DC */
17 #include "debug.h"
18
19 #define NB_DCE    5  /* Number of DCEs created at startup */
20
21 static HANDLE firstDCE = 0;
22 static HDC defaultDCstate = 0;
23
24
25 /***********************************************************************
26  *           DCE_AllocDCE
27  *
28  * Allocate a new DCE.
29  */
30 HANDLE DCE_AllocDCE( DCE_TYPE type )
31 {
32     DCE * dce;
33     HANDLE handle = USER_HEAP_ALLOC( sizeof(DCE) );
34     if (!handle) return 0;
35     dce = (DCE *) USER_HEAP_LIN_ADDR( handle );
36     if (!(dce->hdc = CreateDC( "DISPLAY", NULL, NULL, NULL )))
37     {
38         USER_HEAP_FREE( handle );
39         return 0;
40     }
41     dce->hwndCurrent = 0;
42     dce->type  = type;
43     dce->inUse = (type != DCE_CACHE_DC);
44     dce->xOrigin = 0;
45     dce->yOrigin = 0;
46     dce->hNext = firstDCE;
47     firstDCE = handle;
48     return handle;
49 }
50
51
52 /***********************************************************************
53  *           DCE_FreeDCE
54  */
55 void DCE_FreeDCE( HANDLE hdce )
56 {
57     DCE * dce;
58     HANDLE *handle = &firstDCE;
59
60     if (!(dce = (DCE *) USER_HEAP_LIN_ADDR( hdce ))) return;
61     while (*handle && (*handle != hdce))
62     {
63         DCE * prev = (DCE *) USER_HEAP_LIN_ADDR( *handle );     
64         handle = &prev->hNext;
65     }
66     if (*handle == hdce) *handle = dce->hNext;
67     DeleteDC( dce->hdc );
68     USER_HEAP_FREE( hdce );
69 }
70
71
72 /***********************************************************************
73  *           DCE_Init
74  */
75 void DCE_Init()
76 {
77     int i;
78     HANDLE handle;
79     DCE * dce;
80         
81     for (i = 0; i < NB_DCE; i++)
82     {
83         if (!(handle = DCE_AllocDCE( DCE_CACHE_DC ))) return;
84         dce = (DCE *) USER_HEAP_LIN_ADDR( handle );     
85         if (!defaultDCstate) defaultDCstate = GetDCState( dce->hdc );
86     }
87 }
88
89
90 /***********************************************************************
91  *           DCE_GetVisRect
92  *
93  * Calc the visible rectangle of a window, i.e. the client or
94  * window area clipped by the client area of all ancestors.
95  * Return FALSE if the visible region is empty.
96  */
97 static BOOL DCE_GetVisRect( WND *wndPtr, BOOL clientArea, RECT16 *lprect )
98 {
99     int xoffset, yoffset;
100
101     *lprect = clientArea ? wndPtr->rectClient : wndPtr->rectWindow;
102     xoffset = lprect->left;
103     yoffset = lprect->top;
104
105     if (!(wndPtr->dwStyle & WS_VISIBLE) || (wndPtr->flags & WIN_NO_REDRAW))
106     {
107         SetRectEmpty16( lprect );  /* Clip everything */
108         return FALSE;
109     }
110
111     while (wndPtr->parent)
112     {
113         wndPtr = wndPtr->parent;
114         if (!(wndPtr->dwStyle & WS_VISIBLE) ||
115             (wndPtr->flags & WIN_NO_REDRAW) ||
116             (wndPtr->dwStyle & WS_ICONIC))
117         {
118             SetRectEmpty16( lprect );  /* Clip everything */
119             return FALSE;
120         }
121         xoffset += wndPtr->rectClient.left;
122         yoffset += wndPtr->rectClient.top;
123         OffsetRect16( lprect, wndPtr->rectClient.left,
124                       wndPtr->rectClient.top );
125
126           /* Warning!! we assume that IntersectRect() handles the case */
127           /* where the destination is the same as one of the sources.  */
128         if (!IntersectRect16( lprect, lprect, &wndPtr->rectClient ))
129             return FALSE;  /* Visible rectangle is empty */
130     }
131     OffsetRect16( lprect, -xoffset, -yoffset );
132     return TRUE;
133 }
134
135
136 /***********************************************************************
137  *           DCE_ClipWindows
138  *
139  * Go through the linked list of windows from hwndStart to hwndEnd,
140  * removing from the given region the rectangle of each window offset
141  * by a given amount.  The new region is returned, and the original one
142  * is destroyed.  Used to implement DCX_CLIPSIBLINGS and
143  * DCX_CLIPCHILDREN styles.
144  */
145 static HRGN DCE_ClipWindows( WND *pWndStart, WND *pWndEnd,
146                              HRGN hrgn, int xoffset, int yoffset )
147 {
148     HRGN hrgnNew;
149
150     if (!pWndStart) return hrgn;
151     if (!(hrgnNew = CreateRectRgn( 0, 0, 0, 0 )))
152     {
153         DeleteObject( hrgn );
154         return 0;
155     }
156     for (; pWndStart != pWndEnd; pWndStart = pWndStart->next)
157     {
158         if (!(pWndStart->dwStyle & WS_VISIBLE)) continue;
159         SetRectRgn( hrgnNew, pWndStart->rectWindow.left + xoffset,
160                     pWndStart->rectWindow.top + yoffset,
161                     pWndStart->rectWindow.right + xoffset,
162                     pWndStart->rectWindow.bottom + yoffset );
163         if (!CombineRgn( hrgn, hrgn, hrgnNew, RGN_DIFF )) break;
164     }
165     DeleteObject( hrgnNew );
166     if (pWndStart != pWndEnd)  /* something went wrong */
167     {
168         DeleteObject( hrgn );
169         return 0;
170     }
171     return hrgn;
172 }
173
174
175 /***********************************************************************
176  *           DCE_GetVisRgn
177  *
178  * Return the visible region of a window, i.e. the client or window area
179  * clipped by the client area of all ancestors, and then optionally
180  * by siblings and children.
181  */
182 HRGN DCE_GetVisRgn( HWND hwnd, WORD flags )
183 {
184     RECT16 rect;
185     HRGN hrgn;
186     int xoffset, yoffset;
187     WND *wndPtr = WIN_FindWndPtr( hwnd );
188
189       /* Get visible rectangle and create a region with it */
190
191     if (!DCE_GetVisRect( wndPtr, !(flags & DCX_WINDOW), &rect ))
192     {
193         return CreateRectRgn( 0, 0, 0, 0 );  /* Visible region is empty */
194     }
195     if (!(hrgn = CreateRectRgnIndirect16( &rect ))) return 0;
196
197       /* Clip all children from the visible region */
198
199     if (flags & DCX_CLIPCHILDREN)
200     {
201         if (flags & DCX_WINDOW)
202         {
203             xoffset = wndPtr->rectClient.left - wndPtr->rectWindow.left;
204             yoffset = wndPtr->rectClient.top - wndPtr->rectWindow.top;
205         }
206         else xoffset = yoffset = 0;
207         hrgn = DCE_ClipWindows( wndPtr->child, NULL, hrgn, xoffset, yoffset );
208         if (!hrgn) return 0;
209     }
210
211       /* Clip siblings placed above this window */
212
213     if (flags & DCX_WINDOW)
214     {
215         xoffset = -wndPtr->rectWindow.left;
216         yoffset = -wndPtr->rectWindow.top;
217     }
218     else
219     {
220         xoffset = -wndPtr->rectClient.left;
221         yoffset = -wndPtr->rectClient.top;
222     }
223     if (flags & DCX_CLIPSIBLINGS)
224     {
225         hrgn = DCE_ClipWindows( wndPtr->parent ? wndPtr->parent->child : NULL,
226                                 wndPtr, hrgn, xoffset, yoffset );
227         if (!hrgn) return 0;
228     }
229
230       /* Clip siblings of all ancestors that have the WS_CLIPSIBLINGS style */
231
232     while (wndPtr->dwStyle & WS_CHILD)
233     {
234         wndPtr = wndPtr->parent;
235         xoffset -= wndPtr->rectClient.left;
236         yoffset -= wndPtr->rectClient.top;
237         hrgn = DCE_ClipWindows( wndPtr->parent->child, wndPtr,
238                                 hrgn, xoffset, yoffset );
239         if (!hrgn) return 0;
240     }
241     return hrgn;
242 }
243
244
245 /***********************************************************************
246  *           DCE_SetDrawable
247  *
248  * Set the drawable, origin and dimensions for the DC associated to
249  * a given window.
250  */
251 static void DCE_SetDrawable( WND *wndPtr, DC *dc, WORD flags )
252 {
253     if (!wndPtr)  /* Get a DC for the whole screen */
254     {
255         dc->w.DCOrgX = 0;
256         dc->w.DCOrgY = 0;
257         dc->u.x.drawable = rootWindow;
258         XSetSubwindowMode( display, dc->u.x.gc, IncludeInferiors );
259     }
260     else
261     {
262         if (flags & DCX_WINDOW)
263         {
264             dc->w.DCOrgX  = wndPtr->rectWindow.left;
265             dc->w.DCOrgY  = wndPtr->rectWindow.top;
266         }
267         else
268         {
269             dc->w.DCOrgX  = wndPtr->rectClient.left;
270             dc->w.DCOrgY  = wndPtr->rectClient.top;
271         }
272         while (!wndPtr->window)
273         {
274             wndPtr = wndPtr->parent;
275             dc->w.DCOrgX += wndPtr->rectClient.left;
276             dc->w.DCOrgY += wndPtr->rectClient.top;
277         }
278         dc->w.DCOrgX -= wndPtr->rectWindow.left;
279         dc->w.DCOrgY -= wndPtr->rectWindow.top;
280         dc->u.x.drawable = wndPtr->window;
281     }
282 }
283
284
285 /***********************************************************************
286  *           GetDCEx    (USER.359)
287  */
288 /* Unimplemented flags: DCX_LOCKWINDOWUPDATE
289  */
290 HDC GetDCEx( HWND hwnd, HRGN hrgnClip, DWORD flags )
291 {
292     HANDLE hdce;
293     HRGN hrgnVisible;
294     HDC hdc = 0;
295     DCE * dce;
296     DC * dc;
297     WND * wndPtr;
298     
299     if (hwnd)
300     {
301         if (!(wndPtr = WIN_FindWndPtr( hwnd ))) return 0;
302     }
303     else wndPtr = NULL;
304
305     if (flags & DCX_USESTYLE)
306     {
307         /* Set the flags according to the window style. */
308         /* Not sure if this is the real meaning of the DCX_USESTYLE flag... */
309         flags &= ~(DCX_CACHE | DCX_CLIPCHILDREN |
310                    DCX_CLIPSIBLINGS | DCX_PARENTCLIP);
311         if (wndPtr)
312         {
313             if (!(wndPtr->class->style & (CS_OWNDC | CS_CLASSDC)))
314                 flags |= DCX_CACHE;
315             if (wndPtr->class->style & CS_PARENTDC) flags |= DCX_PARENTCLIP;
316             if (wndPtr->dwStyle & WS_CLIPCHILDREN) flags |= DCX_CLIPCHILDREN;
317             if (wndPtr->dwStyle & WS_CLIPSIBLINGS) flags |= DCX_CLIPSIBLINGS;
318         }
319         else flags |= DCX_CACHE;
320     }
321
322       /* Can only use PARENTCLIP on child windows */
323     if (!wndPtr || !(wndPtr->dwStyle & WS_CHILD)) flags &= ~DCX_PARENTCLIP;
324
325       /* Whole window DC implies using cache DC and not clipping children */
326     if (flags & DCX_WINDOW) flags = (flags & ~DCX_CLIPCHILDREN) | DCX_CACHE;
327
328     if (flags & DCX_CACHE)
329     {
330         for (hdce = firstDCE; (hdce); hdce = dce->hNext)
331         {
332             if (!(dce = (DCE *) USER_HEAP_LIN_ADDR( hdce ))) return 0;
333             if ((dce->type == DCE_CACHE_DC) && (!dce->inUse)) break;
334         }
335     }
336     else hdce = wndPtr->hdce;
337
338     if (!hdce) return 0;
339     dce = (DCE *) USER_HEAP_LIN_ADDR( hdce );
340     dce->hwndCurrent = hwnd;
341     dce->inUse       = TRUE;
342     hdc = dce->hdc;
343     
344       /* Initialize DC */
345     
346     if (!(dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC ))) return 0;
347
348     DCE_SetDrawable( wndPtr, dc, flags );
349     if (hwnd)
350     {
351         if (flags & DCX_PARENTCLIP)  /* Get a VisRgn for the parent */
352         {
353             WND *parentPtr = wndPtr->parent;
354             DWORD newflags = flags & ~(DCX_CLIPSIBLINGS | DCX_CLIPCHILDREN |
355                                        DCX_WINDOW);
356             if (parentPtr->dwStyle & WS_CLIPSIBLINGS)
357                 newflags |= DCX_CLIPSIBLINGS;
358             hrgnVisible = DCE_GetVisRgn( parentPtr->hwndSelf, newflags );
359             if (flags & DCX_WINDOW)
360                 OffsetRgn( hrgnVisible, -wndPtr->rectWindow.left,
361                                         -wndPtr->rectWindow.top );
362             else OffsetRgn( hrgnVisible, -wndPtr->rectClient.left,
363                                          -wndPtr->rectClient.top );
364         }
365         else hrgnVisible = DCE_GetVisRgn( hwnd, flags );
366     }
367     else  /* Get a VisRgn for the whole screen */
368     {
369         hrgnVisible = CreateRectRgn( 0, 0, SYSMETRICS_CXSCREEN,
370                                      SYSMETRICS_CYSCREEN);
371     }
372
373       /* Intersect VisRgn with the given region */
374
375     if ((flags & DCX_INTERSECTRGN) || (flags & DCX_EXCLUDERGN))
376     {
377         CombineRgn( hrgnVisible, hrgnVisible, hrgnClip,
378                     (flags & DCX_INTERSECTRGN) ? RGN_AND : RGN_DIFF );
379     }
380     SelectVisRgn( hdc, hrgnVisible );
381     DeleteObject( hrgnVisible );
382
383     dprintf_dc(stddeb, "GetDCEx(%04x,%04x,0x%lx): returning %04x\n", 
384                hwnd, hrgnClip, flags, hdc);
385     return hdc;
386 }
387
388
389 /***********************************************************************
390  *           GetDC    (USER.66)
391  */
392 HDC GetDC( HWND hwnd )
393 {
394     return GetDCEx( hwnd, 0, DCX_USESTYLE );
395 }
396
397
398 /***********************************************************************
399  *           GetWindowDC    (USER.67)
400  */
401 HDC GetWindowDC( HWND hwnd )
402 {
403     int flags = DCX_CACHE | DCX_WINDOW;
404     if (hwnd)
405     {
406         WND * wndPtr;
407         if (!(wndPtr = WIN_FindWndPtr( hwnd ))) return 0;
408 /*      if (wndPtr->dwStyle & WS_CLIPCHILDREN) flags |= DCX_CLIPCHILDREN; */
409         if (wndPtr->dwStyle & WS_CLIPSIBLINGS) flags |= DCX_CLIPSIBLINGS;
410     }
411     return GetDCEx( hwnd, 0, flags );
412 }
413
414
415 /***********************************************************************
416  *           ReleaseDC    (USER.68)
417  */
418 int ReleaseDC( HWND hwnd, HDC hdc )
419 {
420     HANDLE hdce;
421     DCE * dce = NULL;
422     
423     dprintf_dc(stddeb, "ReleaseDC: %04x %04x\n", hwnd, hdc );
424         
425     for (hdce = firstDCE; (hdce); hdce = dce->hNext)
426     {
427         if (!(dce = (DCE *) USER_HEAP_LIN_ADDR( hdce ))) return 0;
428         if (dce->inUse && (dce->hdc == hdc)) break;
429     }
430     if (!hdce) return 0;
431
432     if (dce->type == DCE_CACHE_DC)
433     {
434         SetDCState( dce->hdc, defaultDCstate );
435         dce->inUse = FALSE;
436     }
437     return 1;
438 }