windows/dce.c

   1 /*
   2  * USER DCE functions
   3  *
   4  * Copyright 1993 Alexandre Julliard
   5  */
   6
   7 static char Copyright[] = "Copyright  Alexandre Julliard, 1993";
   8
   9 #include "dce.h"
  10 #include "class.h"
  11 #include "win.h"
  12 #include "gdi.h"
  13 #include "user.h"
  14 #include "icon.h"
  15
  16
  17 #define NB_DCE    5  /* Number of DCEs created at startup */
  18
  19 extern Display * display;
  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( GMEM_MOVEABLE, sizeof(DCE) );
  34     if (!handle) return 0;
  35     dce = (DCE *) USER_HEAP_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_ADDR( hdce ))) return;
  61     while (*handle && (*handle != hdce))
  62     {
  63         DCE * prev = (DCE *) USER_HEAP_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_ADDR( handle );
  85         if (!defaultDCstate) defaultDCstate = GetDCState( dce->hdc );
  86     }
  87 }
  88
  89
  90 /***********************************************************************
  91  *           DCE_GetVisRect
  92  *
  93  * Return the visible rectangle of a window, i.e. the client or
  94  * window area clipped by the client area of all ancestors.
  95  */
  96 static void DCE_GetVisRect( WND *wndPtr, BOOL clientArea, RECT *lprect )
  97 {
  98     int xoffset, yoffset;
  99
 100     *lprect = clientArea ? wndPtr->rectClient : wndPtr->rectWindow;
 101     xoffset = lprect->left;
 102     yoffset = lprect->top;
 103
 104     while (wndPtr->dwStyle & WS_CHILD)
 105     {
 106         WND *parentPtr = WIN_FindWndPtr( wndPtr->hwndParent );
 107         xoffset += parentPtr->rectClient.left;
 108         yoffset += parentPtr->rectClient.top;
 109         OffsetRect( lprect, parentPtr->rectClient.left,
 110                     parentPtr->rectClient.top );
 111
 112           /* Warning!! we assume that IntersectRect() handles the case */
 113           /* where the destination is the same as one of the sources.  */
 114         IntersectRect( lprect, lprect, &parentPtr->rectClient );
 115         wndPtr = parentPtr;
 116     }
 117     OffsetRect( lprect, -xoffset, -yoffset );
 118 }
 119
 120
 121 /***********************************************************************
 122  *           GetDCEx    (USER.359)
 123  */
 124 /* Unimplemented flags: DCX_CLIPSIBLINGS, DCX_LOCKWINDOWUPDATE, DCX_PARENTCLIP
 125  */
 126 HDC GetDCEx( HWND hwnd, HRGN hrgnClip, DWORD flags )
 127 {
 128     HANDLE hdce;
 129     RECT clipRect;
 130     HDC hdc = 0;
 131     DCE * dce;
 132     DC * dc;
 133     WND * wndPtr;
 134     ICONALLOC   *lpico;
 135
 136     if (hwnd)
 137     {
 138         if (!(wndPtr = WIN_FindWndPtr( hwnd ))) return 0;
 139     }
 140     else wndPtr = NULL;
 141
 142     if (flags & DCX_USESTYLE)
 143     {
 144         /* Not sure if this is the real meaning of the DCX_USESTYLE flag... */
 145         flags &= ~(DCX_CACHE | DCX_CLIPCHILDREN | DCX_CLIPSIBLINGS);
 146         if (wndPtr)
 147         {
 148             if (!(wndPtr->flags & (WIN_CLASS_DC | WIN_OWN_DC)))
 149                 flags |= DCX_CACHE;
 150             if (wndPtr->dwStyle & WS_CLIPCHILDREN) flags |= DCX_CLIPCHILDREN;
 151             if (wndPtr->dwStyle & WS_CLIPSIBLINGS) flags |= DCX_CLIPSIBLINGS;
 152         }
 153         else flags |= DCX_CACHE;
 154     }
 155
 156     if (flags & DCX_CACHE)
 157     {
 158         for (hdce = firstDCE; (hdce); hdce = dce->hNext)
 159         {
 160             if (!(dce = (DCE *) USER_HEAP_ADDR( hdce ))) return 0;
 161             if ((dce->type == DCE_CACHE_DC) && (!dce->inUse)) break;
 162         }
 163     }
 164     else hdce = wndPtr->hdce;
 165
 166     if (!hdce) return 0;
 167     dce = (DCE *) USER_HEAP_ADDR( hdce );
 168     dce->hwndCurrent = hwnd;
 169     dce->inUse       = TRUE;
 170     hdc = dce->hdc;
 171
 172       /* Initialize DC */
 173
 174     if (!(dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC ))) return 0;
 175
 176     if (wndPtr)
 177     {
 178         dc->u.x.drawable = wndPtr->window;
 179         if (flags & DCX_WINDOW)
 180         {
 181             dc->w.DCOrgX  = 0;
 182             dc->w.DCOrgY  = 0;
 183             dc->w.DCSizeX = wndPtr->rectWindow.right - wndPtr->rectWindow.left;
 184             dc->w.DCSizeY = wndPtr->rectWindow.bottom - wndPtr->rectWindow.top;
 185         }
 186         else
 187         {
 188             dc->w.DCOrgX  = wndPtr->rectClient.left - wndPtr->rectWindow.left;
 189             dc->w.DCOrgY  = wndPtr->rectClient.top - wndPtr->rectWindow.top;
 190             dc->w.DCSizeX = wndPtr->rectClient.right - wndPtr->rectClient.left;
 191             dc->w.DCSizeY = wndPtr->rectClient.bottom - wndPtr->rectClient.top;
 192         }
 193
 194         DCE_GetVisRect( wndPtr, !(flags & DCX_WINDOW), &clipRect );
 195         IntersectVisRect( hdc, clipRect.left, clipRect.top,
 196                           clipRect.right, clipRect.bottom );
 197     }
 198     else dc->u.x.drawable = rootWindow;
 199
 200     if (flags & DCX_CLIPCHILDREN)
 201         XSetSubwindowMode( display, dc->u.x.gc, ClipByChildren );
 202     else XSetSubwindowMode( display, dc->u.x.gc, IncludeInferiors);
 203
 204     if ((flags & DCX_INTERSECTRGN) || (flags & DCX_EXCLUDERGN))
 205     {
 206         HRGN hrgn = CreateRectRgn( 0, 0, 0, 0 );
 207         if (hrgn)
 208         {
 209             if (CombineRgn( hrgn, InquireVisRgn(hdc), hrgnClip,
 210                             (flags & DCX_INTERSECTRGN) ? RGN_AND : RGN_DIFF )) {
 211                 SelectVisRgn( hdc, hrgn );
 212             }
 213             DeleteObject( hrgn );
 214         }
 215     }
 216
 217 #ifdef DEBUG_DC
 218     printf( "GetDCEx(%d,%d,0x%x): returning %d\n", hwnd, hrgnClip, flags, hdc);
 219 #endif
 220     return hdc;
 221 }
 222
 223
 224 /***********************************************************************
 225  *           GetDC    (USER.66)
 226  */
 227 HDC GetDC( HWND hwnd )
 228 {
 229     return GetDCEx( hwnd, 0, DCX_USESTYLE );
 230 }
 231
 232
 233 /***********************************************************************
 234  *           GetWindowDC    (USER.67)
 235  */
 236 HDC GetWindowDC( HWND hwnd )
 237 {
 238     int flags = DCX_CACHE | DCX_WINDOW;
 239     if (hwnd)
 240     {
 241         WND * wndPtr;
 242         if (!(wndPtr = WIN_FindWndPtr( hwnd ))) return 0;
 243         if (wndPtr->dwStyle & WS_CLIPCHILDREN) flags |= DCX_CLIPCHILDREN;
 244         if (wndPtr->dwStyle & WS_CLIPSIBLINGS) flags |= DCX_CLIPSIBLINGS;
 245     }
 246     return GetDCEx( hwnd, 0, flags );
 247 }
 248
 249
 250 /***********************************************************************
 251  *           ReleaseDC    (USER.68)
 252  */
 253 int ReleaseDC( HWND hwnd, HDC hdc )
 254 {
 255     HANDLE hdce;
 256     DCE * dce = NULL;
 257
 258 #ifdef DEBUG_DC
 259     printf( "ReleaseDC: %d %d\n", hwnd, hdc );
 260 #endif
 261
 262     for (hdce = firstDCE; (hdce); hdce = dce->hNext)
 263     {
 264         if (!(dce = (DCE *) USER_HEAP_ADDR( hdce ))) return 0;
 265         if (dce->inUse && (dce->hdc == hdc)) break;
 266     }
 267     if (!hdce) return 0;
 268
 269     if (dce->type == DCE_CACHE_DC)
 270     {
 271         SetDCState( dce->hdc, defaultDCstate );
 272         dce->inUse = FALSE;
 273     }
 274     return 1;
 275 }