graphics/x11drv/clipping.c

   1 /*
   2  * X11DRV clipping functions
   3  *
   4  * Copyright 1998 Huw Davies
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  */
  20
  21 #include "config.h"
  22
  23 #include "ts_xlib.h"
  24
  25 #include <stdio.h>
  26
  27 #include "gdi.h"
  28 #include "x11drv.h"
  29 #include "wine/debug.h"
  30
  31 WINE_DEFAULT_DEBUG_CHANNEL(x11drv);
  32
  33 /***********************************************************************
  34  *           X11DRV_GetRegionData
  35  *
  36  * Calls GetRegionData on the given region and converts the rectangle
  37  * array to XRectangle format. The returned buffer must be freed by
  38  * caller using HeapFree(GetProcessHeap(),...).
  39  * If hdc_lptodp is not 0, the rectangles are converted through LPtoDP.
  40  */
  41 RGNDATA *X11DRV_GetRegionData( HRGN hrgn, HDC hdc_lptodp )
  42 {
  43     RGNDATA *data;
  44     DWORD size;
  45     int i;
  46     RECT *rect, tmp;
  47     XRectangle *xrect;
  48
  49     if (!(size = GetRegionData( hrgn, 0, NULL ))) return NULL;
  50     if (sizeof(XRectangle) > sizeof(RECT))
  51     {
  52         /* add extra size for XRectangle array */
  53         int count = (size - sizeof(RGNDATAHEADER)) / sizeof(RECT);
  54         size += count * (sizeof(XRectangle) - sizeof(RECT));
  55     }
  56     if (!(data = HeapAlloc( GetProcessHeap(), 0, size ))) return NULL;
  57     if (!GetRegionData( hrgn, size, data ))
  58     {
  59         HeapFree( GetProcessHeap(), 0, data );
  60         return NULL;
  61     }
  62
  63     rect = (RECT *)data->Buffer;
  64     xrect = (XRectangle *)data->Buffer;
  65     if (hdc_lptodp)  /* map to device coordinates */
  66     {
  67         LPtoDP( hdc_lptodp, (POINT *)rect, data->rdh.nCount * 2 );
  68         for (i = 0; i < data->rdh.nCount; i++)
  69         {
  70             if (rect[i].right < rect[i].left)
  71             {
  72                 INT tmp = rect[i].right;
  73                 rect[i].right = rect[i].left;
  74                 rect[i].left = tmp;
  75             }
  76             if (rect[i].bottom < rect[i].top)
  77             {
  78                 INT tmp = rect[i].bottom;
  79                 rect[i].bottom = rect[i].top;
  80                 rect[i].top = tmp;
  81             }
  82         }
  83     }
  84
  85     if (sizeof(XRectangle) > sizeof(RECT))
  86     {
  87         /* need to start from the end */
  88         for (i = data->rdh.nCount-1; i >=0; i--)
  89         {
  90             tmp = rect[i];
  91             xrect[i].x      = tmp.left;
  92             xrect[i].y      = tmp.top;
  93             xrect[i].width  = tmp.right - tmp.left;
  94             xrect[i].height = tmp.bottom - tmp.top;
  95         }
  96     }
  97     else
  98     {
  99         for (i = 0; i < data->rdh.nCount; i++)
 100         {
 101             tmp = rect[i];
 102             xrect[i].x      = tmp.left;
 103             xrect[i].y      = tmp.top;
 104             xrect[i].width  = tmp.right - tmp.left;
 105             xrect[i].height = tmp.bottom - tmp.top;
 106         }
 107     }
 108     return data;
 109 }
 110
 111
 112 /***********************************************************************
 113  *           X11DRV_SetDeviceClipping
 114  */
 115 void X11DRV_SetDeviceClipping( X11DRV_PDEVICE *physDev, HRGN hrgn )
 116 {
 117     RGNDATA *data;
 118
 119     if (!(data = X11DRV_GetRegionData( hrgn, 0 ))) return;
 120     TSXSetClipRectangles( gdi_display, physDev->gc, 0, 0,
 121                           (XRectangle *)data->Buffer, data->rdh.nCount, YXBanded );
 122     HeapFree( GetProcessHeap(), 0, data );
 123 }
 124
 125
 126 /***********************************************************************
 127  *           X11DRV_SetDrawable
 128  *
 129  * Set the drawable, clipping mode and origin for a DC.
 130  */
 131 void X11DRV_SetDrawable( HDC hdc, Drawable drawable, int mode, int org_x, int org_y )
 132 {
 133     DC *dc = DC_GetDCPtr( hdc );
 134     if (dc)
 135     {
 136         X11DRV_PDEVICE *physDev = (X11DRV_PDEVICE *)dc->physDev;
 137         /*
 138          * This function change the coordinate system (DCOrgX,DCOrgY)
 139          * values. When it moves the origin, other data like the current clipping
 140          * region will not be moved to that new origin. In the case of DCs that are class
 141          * or window DCs that clipping region might be a valid value from a previous use
 142          * of the DC and changing the origin of the DC without moving the clip region
 143          * results in a clip region that is not placed properly in the DC.
 144          * This code will save the dc origin, let the SetDrawable
 145          * modify the origin and reset the clipping. When the clipping is set,
 146          * it is moved according to the new DC origin.
 147          */
 148         if (dc->hClipRgn) OffsetRgn( dc->hClipRgn, org_x - dc->DCOrgX, org_y - dc->DCOrgY );
 149         dc->DCOrgX = org_x;
 150         dc->DCOrgY = org_y;
 151         physDev->drawable = drawable;
 152         TSXSetSubwindowMode( gdi_display, physDev->gc, mode );
 153         if(physDev->xrender)
 154           X11DRV_XRender_UpdateDrawable( physDev );
 155         GDI_ReleaseObj( hdc );
 156     }
 157 }
 158
 159
 160 /***********************************************************************
 161  *           X11DRV_StartGraphicsExposures
 162  *
 163  * Set the DC in graphics exposures mode
 164  */
 165 void X11DRV_StartGraphicsExposures( HDC hdc )
 166 {
 167     DC *dc = DC_GetDCPtr( hdc );
 168     if (dc)
 169     {
 170         X11DRV_PDEVICE *physDev = (X11DRV_PDEVICE *)dc->physDev;
 171         TSXSetGraphicsExposures( gdi_display, physDev->gc, True );
 172         physDev->exposures = 0;
 173         GDI_ReleaseObj( hdc );
 174     }
 175 }
 176
 177
 178 /***********************************************************************
 179  *           X11DRV_EndGraphicsExposures
 180  *
 181  * End the graphics exposures mode and process the events
 182  */
 183 void X11DRV_EndGraphicsExposures( HDC hdc, HRGN hrgn )
 184 {
 185     HRGN tmp = 0;
 186     DC *dc = DC_GetDCPtr( hdc );
 187
 188     if (dc)
 189     {
 190         XEvent event;
 191         X11DRV_PDEVICE *physDev = (X11DRV_PDEVICE *)dc->physDev;
 192
 193         SetRectRgn( hrgn, 0, 0, 0, 0 );
 194         wine_tsx11_lock();
 195         XSetGraphicsExposures( gdi_display, physDev->gc, False );
 196         if (physDev->exposures)
 197         {
 198             XSync( gdi_display, False );
 199             for (;;)
 200             {
 201                 XWindowEvent( gdi_display, physDev->drawable, ~0, &event );
 202                 if (event.type == NoExpose) break;
 203                 if (event.type == GraphicsExpose)
 204                 {
 205                     int x = event.xgraphicsexpose.x - dc->DCOrgX;
 206                     int y = event.xgraphicsexpose.y - dc->DCOrgY;
 207
 208                     TRACE( "got %d,%d %dx%d count %d\n",
 209                            x, y, event.xgraphicsexpose.width, event.xgraphicsexpose.height,
 210                            event.xgraphicsexpose.count );
 211
 212                     if (!tmp) tmp = CreateRectRgn( 0, 0, 0, 0 );
 213                     SetRectRgn( tmp, x, y,
 214                                 x + event.xgraphicsexpose.width,
 215                                 y + event.xgraphicsexpose.height );
 216                     CombineRgn( hrgn, hrgn, tmp, RGN_OR );
 217                     if (!event.xgraphicsexpose.count) break;
 218                 }
 219                 else
 220                 {
 221                     ERR( "got unexpected event %d\n", event.type );
 222                     break;
 223                 }
 224                 if (tmp) DeleteObject( tmp );
 225             }
 226         }
 227         wine_tsx11_unlock();
 228         GDI_ReleaseObj( hdc );
 229     }
 230 }
 231