#include "precomp.h"
+#define INRECT(r, x, y) \
+ ( ( ((r).right > x)) && \
+ ( ((r).left <= x)) && \
+ ( ((r).bottom > y)) && \
+ ( ((r).top <= y)) )
+
+static
+INT
+FASTCALL
+ComplexityFromRects( PRECT prc1, PRECT prc2)
+{
+ if ( prc2->left >= prc1->left )
+ {
+ if ( ( prc1->right >= prc2->right) &&
+ ( prc1->top <= prc2->top ) &&
+ ( prc1->bottom <= prc2->bottom ) )
+ return SIMPLEREGION;
+
+ if ( prc2->left > prc1->left )
+ {
+ if ( ( prc1->left >= prc2->right ) ||
+ ( prc1->right <= prc2->left ) ||
+ ( prc1->top >= prc2->bottom ) ||
+ ( prc1->bottom <= prc2->top ) )
+ return COMPLEXREGION;
+ }
+ }
+
+ if ( ( prc2->right < prc1->right ) ||
+ ( prc2->top > prc1->top ) ||
+ ( prc2->bottom < prc1->bottom ) )
+ {
+ if ( ( prc1->left >= prc2->right ) ||
+ ( prc1->right <= prc2->left ) ||
+ ( prc1->top >= prc2->bottom ) ||
+ ( prc1->bottom <= prc2->top ) )
+ return COMPLEXREGION;
+ }
+ else
+ {
+ return NULLREGION;
+ }
+
+ return ERROR;
+}
+
+static
+VOID
+FASTCALL
+SortRects(PRECT pRect, INT nCount)
+{
+ INT i = 0, a = 0, b = 0, c, s;
+ RECT sRect;
+
+ if (nCount > 0)
+ {
+ i = 1; // set index point
+ c = nCount; // set inverse count
+ do
+ {
+ s = i; // set sort count
+ if ( i < nCount )
+ {
+ a = i - 1;
+ b = i;
+ do
+ {
+ if(pRect[b].top != pRect[i].bottom) break;
+ if(pRect[b].left < pRect[a].left)
+ {
+ sRect = pRect[a];
+ pRect[a] = pRect[b];
+ pRect[b] = sRect;
+ }
+ ++s;
+ ++b;
+ } while ( s < nCount );
+ }
+ ++i;
+ } while ( c-- != 1 );
+ }
+}
+
+/*
+ * I thought it was okay to have this in DeleteObject but~ Speed. (jt)
+ */
+BOOL
+FASTCALL
+DeleteRegion( HRGN hRgn )
+{
+#if 0
+ PRGN_ATTR Rgn_Attr;
+
+ if ((GdiGetHandleUserData((HGDIOBJ) hRgn, GDI_OBJECT_TYPE_REGION, (PVOID) &Rgn_Attr)) &&
+ ( Rgn_Attr != NULL ))
+ {
+ PTEB pTeb = NtCurrentTeb();
+ if (pTeb->Win32ThreadInfo != NULL)
+ {
+ if ((pTeb->GdiTebBatch.Offset + sizeof(GDIBSOBJECT)) <= GDIBATCHBUFSIZE)
+ {
+ PGDIBSOBJECT pgO = (PGDIBSOBJECT)(&pTeb->GdiTebBatch.Buffer[0] +
+ pTeb->GdiTebBatch.Offset);
+ pgO->gbHdr.Cmd = GdiBCDelRgn;
+ pgO->gbHdr.Size = sizeof(GDIBSOBJECT);
+ pgO->hgdiobj = (HGDIOBJ)hRgn;
+
+ pTeb->GdiTebBatch.Offset += sizeof(GDIBSOBJECT);
+ pTeb->GdiBatchCount++;
+ if (pTeb->GdiBatchCount >= GDI_BatchLimit) NtGdiFlush();
+ return TRUE;
+ }
+ }
+ }
+#endif
+ return NtGdiDeleteObjectApp((HGDIOBJ) hRgn);
+}
+
+INT
+FASTCALL
+MirrorRgnByWidth(HRGN hRgn, INT Width, HRGN *phRgn)
+{
+ INT cRgnDSize, Ret = 0;
+ PRGNDATA pRgnData;
+
+ cRgnDSize = NtGdiGetRegionData(hRgn, 0, NULL);
+
+ if (cRgnDSize)
+ {
+ pRgnData = LocalAlloc(LMEM_FIXED, cRgnDSize * sizeof(LONG));
+ if (pRgnData)
+ {
+ if ( GetRegionData(hRgn, cRgnDSize, pRgnData) )
+ {
+ HRGN hRgnex;
+ UINT i;
+ INT SaveL = pRgnData->rdh.rcBound.left;
+ pRgnData->rdh.rcBound.left = Width - pRgnData->rdh.rcBound.right;
+ pRgnData->rdh.rcBound.right = Width - SaveL;
+ if (pRgnData->rdh.nCount > 0)
+ {
+ PRECT pRect = (PRECT)&pRgnData->Buffer;
+ for (i = 0; i < pRgnData->rdh.nCount; i++)
+ {
+ SaveL = pRect[i].left;
+ pRect[i].left = Width - pRect[i].right;
+ pRect[i].right = Width - SaveL;
+ }
+ }
+ SortRects((PRECT)&pRgnData->Buffer, pRgnData->rdh.nCount);
+ hRgnex = ExtCreateRegion(NULL, cRgnDSize , pRgnData);
+ if (hRgnex)
+ {
+ if (phRgn) phRgn = (HRGN *)hRgnex;
+ else
+ {
+ CombineRgn(hRgn, hRgnex, 0, RGN_COPY);
+ DeleteObject(hRgnex);
+ }
+ Ret = 1;
+ }
+ }
+ LocalFree(pRgnData);
+ }
+ }
+ return Ret;
+}
+
+INT
+WINAPI
+MirrorRgnDC(HDC hdc, HRGN hRgn, HRGN *phRgn)
+{
+ if (!GdiIsHandleValid((HGDIOBJ) hdc) ||
+ (GDI_HANDLE_GET_TYPE(hdc) != GDI_OBJECT_TYPE_DC)) return 0;
+
+ return MirrorRgnByWidth(hRgn, NtGdiGetDeviceWidth(hdc), phRgn);
+}
+
+/* FUNCTIONS *****************************************************************/
+
+/*
+ * @unimplemented
+ */
+INT
+WINAPI
+CombineRgn(HRGN hDest,
+ HRGN hSrc1,
+ HRGN hSrc2,
+ INT CombineMode)
+{
+ /* FIXME some part should be done in user mode */
+ return NtGdiCombineRgn(hDest, hSrc1, hSrc2, CombineMode);
+}
/*
* @implemented
*/
-int STDCALL
-SelectClipRgn(
- HDC hdc,
- HRGN hrgn
+HRGN
+WINAPI
+CreatePolygonRgn( const POINT * lppt, int cPoints, int fnPolyFillMode)
+{
+ return (HRGN) NtGdiPolyPolyDraw( (HDC) fnPolyFillMode, (PPOINT) lppt, (PULONG) &cPoints, 1, GdiPolyPolyRgn);
+}
+
+/*
+ * @implemented
+ */
+HRGN
+WINAPI
+CreatePolyPolygonRgn( const POINT* lppt,
+ const INT* lpPolyCounts,
+ int nCount,
+ int fnPolyFillMode)
+{
+ return (HRGN) NtGdiPolyPolyDraw( (HDC) fnPolyFillMode, (PPOINT) lppt, (PULONG) lpPolyCounts, (ULONG) nCount, GdiPolyPolyRgn );
+}
+
+/*
+ * @implemented
+ */
+HRGN
+WINAPI
+CreateEllipticRgnIndirect(
+ const RECT *prc
)
{
- return NtGdiExtSelectClipRgn(hdc, hrgn, RGN_COPY);
+ /* Notes if prc is NULL it will crash on All Windows NT I checked 2000/XP/VISTA */
+ return NtGdiCreateEllipticRgn(prc->left, prc->top, prc->right, prc->bottom);
+
}
+/*
+ * @implemented
+ */
+HRGN
+WINAPI
+CreateRectRgn(int x1, int y1, int x2, int y2)
+{
+ PRGN_ATTR pRgn_Attr;
+ HRGN hrgn;
+ int x, y;
+
+ /* Normalize points */
+ x = x1;
+ if ( x1 > x2 )
+ {
+ x1 = x2;
+ x2 = x;
+ }
+
+ y = y1;
+ if ( y1 > y2 )
+ {
+ y1 = y2;
+ y2 = y;
+ }
+
+ if ( (UINT)x1 < 0x80000000 ||
+ (UINT)y1 < 0x80000000 ||
+ (UINT)x2 > 0x7FFFFFFF ||
+ (UINT)y2 > 0x7FFFFFFF )
+ {
+ SetLastError(ERROR_INVALID_PARAMETER);
+ return NULL;
+ }
+//// Remove when Brush/Pen/Rgn Attr is ready!
+ return NtGdiCreateRectRgn(x1,y1,x2,y2);
+////
+ hrgn = hGetPEBHandle(hctRegionHandle, 0);
+
+ if (!hrgn)
+ hrgn = NtGdiCreateRectRgn(0, 0, 1, 1);
+
+ if (!hrgn)
+ return hrgn;
+
+ if (!GdiGetHandleUserData((HGDIOBJ) hrgn, GDI_OBJECT_TYPE_REGION, (PVOID) &pRgn_Attr))
+ {
+ DeleteRegion(hrgn);
+ return NULL;
+ }
+
+ if (( x1 == x2) || (y1 == y2))
+ {
+ pRgn_Attr->Flags = NULLREGION;
+ pRgn_Attr->Rect.left = pRgn_Attr->Rect.top =
+ pRgn_Attr->Rect.right = pRgn_Attr->Rect.bottom = 0;
+ }
+ else
+ {
+ pRgn_Attr->Flags = SIMPLEREGION;
+ pRgn_Attr->Rect.left = x1;
+ pRgn_Attr->Rect.top = y1;
+ pRgn_Attr->Rect.right = x2;
+ pRgn_Attr->Rect.bottom = y2;
+ }
+
+ pRgn_Attr->AttrFlags = (ATTR_RGN_DIRTY|ATTR_RGN_VALID);
+
+ return hrgn;
+}
+
+/*
+ * @implemented
+ */
+HRGN
+WINAPI
+CreateRectRgnIndirect(
+ const RECT *prc
+)
+{
+ /* Notes if prc is NULL it will crash on All Windows NT I checked 2000/XP/VISTA */
+ return CreateRectRgn(prc->left, prc->top, prc->right, prc->bottom);
+
+}
+
+/*
+ * @implemented
+ */
+INT
+WINAPI
+ExcludeClipRect(IN HDC hdc, IN INT xLeft, IN INT yTop, IN INT xRight, IN INT yBottom)
+{
+#if 0
+// Handle something other than a normal dc object.
+ if (GDI_HANDLE_GET_TYPE(hdc) != GDI_OBJECT_TYPE_DC)
+ {
+ if (GDI_HANDLE_GET_TYPE(hdc) == GDI_OBJECT_TYPE_METADC)
+ return MFDRV_ExcludeClipRect( hdc, xLeft, yTop, xRight, yBottom);
+ else
+ {
+ PLDC pLDC = GdiGetLDC(hdc);
+ if ( pLDC )
+ {
+ if (pLDC->iType != LDC_EMFLDC || EMFDRV_ExcludeClipRect( hdc, xLeft, yTop, xRight, yBottom))
+ return NtGdiExcludeClipRect(hdc, xLeft, yTop, xRight, yBottom);
+ }
+ else
+ SetLastError(ERROR_INVALID_HANDLE);
+ return ERROR;
+ }
+ }
+#endif
+ return NtGdiExcludeClipRect(hdc, xLeft, yTop, xRight, yBottom);
+}
+
+/*
+ * @implemented
+ */
+HRGN
+WINAPI
+ExtCreateRegion(
+ CONST XFORM * lpXform,
+ DWORD nCount,
+ CONST RGNDATA * lpRgnData
+ )
+{
+ if (lpRgnData)
+ {
+ if ((!lpXform) && (lpRgnData->rdh.nCount == 1))
+ {
+ PRECT pRect = (PRECT)&lpRgnData->Buffer[0];
+ return CreateRectRgn(pRect->left, pRect->top, pRect->right, pRect->bottom);
+ }
+ return NtGdiExtCreateRegion((LPXFORM) lpXform, nCount,(LPRGNDATA) lpRgnData);
+ }
+ SetLastError(ERROR_INVALID_PARAMETER);
+ return NULL;
+}
+
+/*
+ * @implemented
+ */
+INT
+WINAPI
+ExtSelectClipRgn( IN HDC hdc, IN HRGN hrgn, IN INT iMode)
+{
+ /* FIXME some part need be done on user mode size */
+ return NtGdiExtSelectClipRgn(hdc,hrgn, iMode);
+}
/*
* @implemented
*/
int
-STDCALL
+WINAPI
GetClipRgn(
HDC hdc,
HRGN hrgn
)
{
- return NtGdiGetRandomRgn(hdc, hrgn, 1);
+ INT Ret = NtGdiGetRandomRgn(hdc, hrgn, CLIPRGN);
+// if (Ret)
+// {
+// if(GetLayout(hdc) & LAYOUT_RTL) MirrorRgnDC(hdc,(HRGN)Ret, NULL);
+// }
+ return Ret;
+}
+
+/*
+ * @implemented
+ */
+int
+WINAPI
+GetMetaRgn(HDC hdc,
+ HRGN hrgn)
+{
+ return NtGdiGetRandomRgn(hdc, hrgn, METARGN);
}
+/*
+ * @implemented
+ *
+ */
+DWORD
+WINAPI
+GetRegionData(HRGN hrgn,
+ DWORD nCount,
+ LPRGNDATA lpRgnData)
+{
+ if (!lpRgnData)
+ {
+ nCount = 0;
+ }
-HRGN
-WINAPI
-CreatePolygonRgn( const POINT* Point, int Count, int Mode)
+ return NtGdiGetRegionData(hrgn,nCount,lpRgnData);
+}
+
+/*
+ * @implemented
+ *
+ */
+INT
+WINAPI
+GetRgnBox(HRGN hrgn,
+ LPRECT prcOut)
{
- return CreatePolyPolygonRgn(Point, (const INT*)&Count, 1, Mode);
+ PRGN_ATTR Rgn_Attr;
+
+ if (!GdiGetHandleUserData((HGDIOBJ) hrgn, GDI_OBJECT_TYPE_REGION, (PVOID) &Rgn_Attr))
+ return NtGdiGetRgnBox(hrgn, prcOut);
+
+ if (Rgn_Attr->Flags == NULLREGION)
+ {
+ prcOut->left = 0;
+ prcOut->top = 0;
+ prcOut->right = 0;
+ prcOut->bottom = 0;
+ }
+ else
+ {
+ if (Rgn_Attr->Flags != SIMPLEREGION)
+ return NtGdiGetRgnBox(hrgn, prcOut);
+ /* WARNING! prcOut is never checked newbies! */
+ RtlCopyMemory( prcOut, &Rgn_Attr->Rect, sizeof(RECT));
+ }
+ return Rgn_Attr->Flags;
}
+/*
+ * @implemented
+ */
+INT
+WINAPI
+IntersectClipRect(HDC hdc,
+ int nLeftRect,
+ int nTopRect,
+ int nRightRect,
+ int nBottomRect)
+{
+#if 0
+// Handle something other than a normal dc object.
+ if (GDI_HANDLE_GET_TYPE(hdc) != GDI_OBJECT_TYPE_DC)
+ {
+ if (GDI_HANDLE_GET_TYPE(hdc) == GDI_OBJECT_TYPE_METADC)
+ return MFDRV_IntersectClipRect( hdc, nLeftRect, nTopRect, nRightRect, nBottomRect);
+ else
+ {
+ PLDC pLDC = GdiGetLDC(hdc);
+ if ( pLDC )
+ {
+ if (pLDC->iType != LDC_EMFLDC || EMFDRV_IntersectClipRect( hdc, nLeftRect, nTopRect, nRightRect, nBottomRect))
+ return NtGdiIntersectClipRect(hdc, nLeftRect, nTopRect, nRightRect, nBottomRect);
+ }
+ else
+ SetLastError(ERROR_INVALID_HANDLE);
+ return ERROR;
+ }
+ }
+#endif
+ return NtGdiIntersectClipRect(hdc, nLeftRect, nTopRect, nRightRect, nBottomRect);
+}
-HRGN
+/*
+ * @implemented
+ */
+BOOL
WINAPI
-CreatePolyPolygonRgn( const POINT* Point,
- const INT* Count,
- int inPolygons,
- int Mode)
+MirrorRgn(HWND hwnd, HRGN hrgn)
{
- return (HRGN) NtGdiPolyPolyDraw( (HDC) Mode,
- (PPOINT) Point,
- (PULONG) Count,
- (ULONG) inPolygons,
- GdiPolyPolyRgn );
+ RECT Rect;
+ GetWindowRect(hwnd, &Rect);
+ return MirrorRgnByWidth(hrgn, Rect.right - Rect.left, NULL);
}
-HRGN
+/*
+ * @implemented
+ */
+INT
WINAPI
-CreateEllipticRgnIndirect(
- const RECT *prc
-)
+OffsetClipRgn(HDC hdc,
+ int nXOffset,
+ int nYOffset)
{
- if (prc)
+#if 0
+// Handle something other than a normal dc object.
+ if (GDI_HANDLE_GET_TYPE(hdc) != GDI_OBJECT_TYPE_DC)
+ {
+ if (GDI_HANDLE_GET_TYPE(hdc) == GDI_OBJECT_TYPE_METADC)
+ return MFDRV_OffsetClipRgn( hdc, nXOffset, nYOffset );
+ else
+ {
+ PLDC pLDC = GdiGetLDC(hdc);
+ if ( !pLDC )
+ {
+ SetLastError(ERROR_INVALID_HANDLE);
+ return ERROR;
+ }
+ if (pLDC->iType == LDC_EMFLDC && !EMFDRV_OffsetClipRgn( hdc, nXOffset, nYOffset ))
+ return ERROR;
+ return NtGdiOffsetClipRgn( hdc, nXOffset, nYOffset);
+ }
+ }
+#endif
+ return NtGdiOffsetClipRgn( hdc, nXOffset, nYOffset);
+}
+
+/*
+ * @implemented
+ *
+ */
+INT
+WINAPI
+OffsetRgn( HRGN hrgn,
+ int nXOffset,
+ int nYOffset)
+{
+ PRGN_ATTR pRgn_Attr;
+ int nLeftRect, nTopRect, nRightRect, nBottomRect;
+
+ if (!GdiGetHandleUserData((HGDIOBJ) hrgn, GDI_OBJECT_TYPE_REGION, (PVOID) &pRgn_Attr))
+ return NtGdiOffsetRgn(hrgn,nXOffset,nYOffset);
+
+ if ( pRgn_Attr->Flags == NULLREGION)
+ return pRgn_Attr->Flags;
+
+ if ( pRgn_Attr->Flags != SIMPLEREGION)
+ return NtGdiOffsetRgn(hrgn,nXOffset,nYOffset);
+
+ nLeftRect = pRgn_Attr->Rect.left;
+ nTopRect = pRgn_Attr->Rect.top;
+ nRightRect = pRgn_Attr->Rect.right;
+ nBottomRect = pRgn_Attr->Rect.bottom;
+
+ if (nLeftRect < nRightRect)
+ {
+ if (nTopRect < nBottomRect)
+ {
+ nLeftRect = nXOffset + nLeftRect;
+ nTopRect = nYOffset + nTopRect;
+ nRightRect = nXOffset + nRightRect;
+ nBottomRect = nYOffset + nBottomRect;
+
+ /* Mask and bit test. */
+ if ( ( nLeftRect & 0xF8000000 &&
+ (nLeftRect & 0xF8000000) != 0x80000000 ) ||
+ ( nTopRect & 0xF8000000 &&
+ (nTopRect & 0xF8000000) != 0x80000000 ) ||
+ ( nRightRect & 0xF8000000 &&
+ (nRightRect & 0xF8000000) != 0x80000000 ) ||
+ ( nBottomRect & 0xF8000000 &&
+ (nBottomRect & 0xF8000000) != 0x80000000 ) )
+ {
+ return ERROR;
+ }
+ else
+ {
+ pRgn_Attr->Rect.top = nTopRect;
+ pRgn_Attr->Rect.left = nLeftRect;
+ pRgn_Attr->Rect.right = nRightRect;
+ pRgn_Attr->Rect.bottom = nBottomRect;
+ pRgn_Attr->AttrFlags |= ATTR_RGN_DIRTY;
+ }
+ }
+ }
+ return pRgn_Attr->Flags;
+}
+
+/*
+ * @implemented
+ */
+BOOL
+WINAPI
+PtInRegion(IN HRGN hrgn,
+ int x,
+ int y)
+{
+ PRGN_ATTR pRgn_Attr;
+
+ if (!GdiGetHandleUserData((HGDIOBJ) hrgn, GDI_OBJECT_TYPE_REGION, (PVOID) &pRgn_Attr))
+ return NtGdiPtInRegion(hrgn,x,y);
+
+ if ( pRgn_Attr->Flags == NULLREGION)
+ return FALSE;
+
+ if ( pRgn_Attr->Flags != SIMPLEREGION)
+ return NtGdiPtInRegion(hrgn,x,y);
+
+ return INRECT( pRgn_Attr->Rect, x, y);
+}
+
+/*
+ * @implemented
+ */
+BOOL
+WINAPI
+RectInRegion(HRGN hrgn,
+ LPCRECT prcl)
+{
+ PRGN_ATTR pRgn_Attr;
+ RECT rc;
+
+ if (!GdiGetHandleUserData((HGDIOBJ) hrgn, GDI_OBJECT_TYPE_REGION, (PVOID) &pRgn_Attr))
+ return NtGdiRectInRegion(hrgn, (LPRECT) prcl);
+
+ if ( pRgn_Attr->Flags == NULLREGION)
+ return FALSE;
+
+ if ( pRgn_Attr->Flags != SIMPLEREGION)
+ return NtGdiRectInRegion(hrgn, (LPRECT) prcl);
+
+ /* swap the coordinates to make right >= left and bottom >= top */
+ /* (region building rectangles are normalized the same way) */
+ if ( prcl->top > prcl->bottom)
{
- return NtGdiCreateEllipticRgn(prc->left, prc->top, prc->right, prc->bottom);
+ rc.top = prcl->bottom;
+ rc.bottom = prcl->top;
}
- return NULL;
+ else
+ {
+ rc.top = prcl->top;
+ rc.bottom = prcl->bottom;
+ }
+ if ( prcl->right < prcl->left)
+ {
+ rc.right = prcl->left;
+ rc.left = prcl->right;
+ }
+ else
+ {
+ rc.right = prcl->right;
+ rc.left = prcl->left;
+ }
+
+ if ( ComplexityFromRects( (PRECT)&pRgn_Attr->Rect, &rc) != COMPLEXREGION )
+ return TRUE;
+
+ return FALSE;
}
-HRGN
-WINAPI
-CreateRectRgnIndirect(
- const RECT *prc
+/*
+ * @implemented
+ */
+int WINAPI
+SelectClipRgn(
+ HDC hdc,
+ HRGN hrgn
)
{
- if (prc)
+ return ExtSelectClipRgn(hdc, hrgn, RGN_COPY);
+}
+
+/*
+ * @implemented
+ */
+BOOL
+WINAPI
+SetRectRgn(HRGN hrgn,
+ int nLeftRect,
+ int nTopRect,
+ int nRightRect,
+ int nBottomRect)
+{
+ PRGN_ATTR Rgn_Attr;
+
+ if (!GdiGetHandleUserData((HGDIOBJ) hrgn, GDI_OBJECT_TYPE_REGION, (PVOID) &Rgn_Attr))
+ return NtGdiSetRectRgn(hrgn, nLeftRect, nTopRect, nRightRect, nBottomRect);
+
+ if ((nLeftRect == nRightRect) || (nTopRect == nBottomRect))
+ {
+ Rgn_Attr->AttrFlags |= ATTR_RGN_DIRTY;
+ Rgn_Attr->Flags = NULLREGION;
+ Rgn_Attr->Rect.left = Rgn_Attr->Rect.top =
+ Rgn_Attr->Rect.right = Rgn_Attr->Rect.bottom = 0;
+ return TRUE;
+ }
+
+ Rgn_Attr->Rect.left = nLeftRect;
+ Rgn_Attr->Rect.top = nTopRect;
+ Rgn_Attr->Rect.right = nRightRect;
+ Rgn_Attr->Rect.bottom = nBottomRect;
+
+ if(nLeftRect > nRightRect)
+ {
+ Rgn_Attr->Rect.left = nRightRect;
+ Rgn_Attr->Rect.right = nLeftRect;
+ }
+ if(nTopRect > nBottomRect)
+ {
+ Rgn_Attr->Rect.top = nBottomRect;
+ Rgn_Attr->Rect.bottom = nTopRect;
+ }
+
+ Rgn_Attr->AttrFlags |= ATTR_RGN_DIRTY ;
+ Rgn_Attr->Flags = SIMPLEREGION;
+ return TRUE;
+}
+
+/*
+ * @implemented
+ */
+int
+WINAPI
+SetMetaRgn( HDC hDC )
+{
+ if (GDI_HANDLE_GET_TYPE(hDC) == GDI_OBJECT_TYPE_DC)
+ return NtGdiSetMetaRgn(hDC);
+#if 0
+ PLDC pLDC = GdiGetLDC(hDC);
+ if ( pLDC && GDI_HANDLE_GET_TYPE(hDC) != GDI_OBJECT_TYPE_METADC )
+ {
+ if (pLDC->iType == LDC_EMFLDC || EMFDRV_SetMetaRgn(hDC))
{
- return NtGdiCreateRectRgn(prc->left,
- prc->top,
- prc->right,
- prc->bottom);
+ return NtGdiSetMetaRgn(hDC);
}
- return NULL;
+ else
+ SetLastError(ERROR_INVALID_HANDLE);
+ }
+#endif
+ return ERROR;
}
+
+
projects / reactos.git / blobdiff