void
_cairo_win32_debug_dump_hrgn (HRGN rgn, char *header)
{
RGNDATA *rd;
unsigned int z;
if (header)
fprintf (stderr, "%s\n", header);
if (rgn == NULL) {
fprintf (stderr, " NULL\n");
}
z = GetRegionData(rgn, 0, NULL);
rd = (RGNDATA*) _cairo_malloc (z);
z = GetRegionData(rgn, z, rd);
fprintf (stderr, " %ld rects, bounds: %ld %ld %ld %ld\n",
rd->rdh.nCount,
rd->rdh.rcBound.left,
rd->rdh.rcBound.top,
rd->rdh.rcBound.right - rd->rdh.rcBound.left,
rd->rdh.rcBound.bottom - rd->rdh.rcBound.top);
for (z = 0; z < rd->rdh.nCount; z++) {
RECT r = ((RECT*)rd->Buffer)[z];
fprintf (stderr, " [%d]: [%ld %ld %ld %ld]\n",
z, r.left, r.top, r.right - r.left, r.bottom - r.top);
}
free(rd);
fflush (stderr);
}
// Return all the rectangles
BOOL vncRegion::Rectangles(rectlist &rects)
{
int buffsize;
DWORD x;
RGNDATA *buff;
// If the region is empty then return empty rectangle list
if (region == NULL)
return FALSE;
// Get the size of buffer required
buffsize = GetRegionData(region, NULL, 0);
buff = (RGNDATA *) new BYTE [buffsize];
if (buff == NULL)
return FALSE;
// Now get the region data
if (GetRegionData(region, buffsize, buff))
{
for (x=0; x<(buff->rdh.nCount); x++)
{
// Obtain the rectangles from the list
RECT *rect = (RECT *) (((BYTE *) buff) + sizeof(RGNDATAHEADER) + x * sizeof(RECT));
rects.push_front(*rect);
}
}
// Delete the temporary buffer
delete [] buff;
// Return whether there are any rects!
return !rects.empty();
}
static void getDirtyRects(HWND window, Vector<CGRect>& outRects)
{
ASSERT_ARG(outRects, outRects.isEmpty());
RECT clientRect;
if (!GetClientRect(window, &clientRect))
return;
OwnPtr<HRGN> region(CreateRectRgn(0, 0, 0, 0));
int regionType = GetUpdateRgn(window, region.get(), false);
if (regionType != COMPLEXREGION) {
RECT dirtyRect;
if (GetUpdateRect(window, &dirtyRect, false))
outRects.append(winRectToCGRect(dirtyRect, clientRect));
return;
}
DWORD dataSize = GetRegionData(region.get(), 0, 0);
OwnArrayPtr<unsigned char> regionDataBuffer(new unsigned char[dataSize]);
RGNDATA* regionData = reinterpret_cast<RGNDATA*>(regionDataBuffer.get());
if (!GetRegionData(region.get(), dataSize, regionData))
return;
outRects.resize(regionData->rdh.nCount);
RECT* rect = reinterpret_cast<RECT*>(regionData->Buffer);
for (size_t i = 0; i < outRects.size(); ++i, ++rect)
outRects[i] = winRectToCGRect(*rect, clientRect);
}
void DSObjects::ExtractRects(REGION* pRegion)
{
LPRGNDATA lpRgnData;
DWORD sizeNeeed = GetRegionData((HRGN)pRegion->pOSRegion, 0, NULL);
lpRgnData = (LPRGNDATA)new char[sizeNeeed];
DWORD returnValue = GetRegionData((HRGN)pRegion->pOSRegion, sizeNeeed, lpRgnData);
PN_VECTOR_DELETE(pRegion->rects);
pRegion->numRects = lpRgnData->rdh.nCount;
pRegion->extents.left = lpRgnData->rdh.rcBound.left;
pRegion->extents.top = lpRgnData->rdh.rcBound.top;
pRegion->extents.right = lpRgnData->rdh.rcBound.right;
pRegion->extents.bottom = lpRgnData->rdh.rcBound.bottom;
if(lpRgnData->rdh.nCount)
{
pRegion->rects = new PNxRect[lpRgnData->rdh.nCount];
// now extract the information.
for(int j = 0; j < (int) lpRgnData->rdh.nCount;j++)
{
RECT* pRect = (RECT*)lpRgnData->Buffer;
pRegion->rects[j].left = pRect[j].left;
pRegion->rects[j].top = pRect[j].top;
pRegion->rects[j].right = pRect[j].right;
pRegion->rects[j].bottom = pRect[j].bottom;
}
}
PN_VECTOR_DELETE(lpRgnData);
}
/***********************************************************************
* PSDRV_PaintRgn
*/
BOOL PSDRV_PaintRgn( PHYSDEV dev, HRGN hrgn )
{
RGNDATA *rgndata = NULL;
RECT *pRect;
DWORD size, i;
TRACE("hdc=%p\n", dev->hdc);
size = GetRegionData(hrgn, 0, NULL);
rgndata = HeapAlloc( GetProcessHeap(), 0, size );
if(!rgndata) {
ERR("Can't allocate buffer\n");
return FALSE;
}
GetRegionData(hrgn, size, rgndata);
if (rgndata->rdh.nCount == 0)
goto end;
LPtoDP(dev->hdc, (POINT*)rgndata->Buffer, rgndata->rdh.nCount * 2);
PSDRV_SetClip(dev);
for(i = 0, pRect = (RECT*)rgndata->Buffer; i < rgndata->rdh.nCount; i++, pRect++)
PSDRV_WriteRectangle(dev, pRect->left, pRect->top, pRect->right - pRect->left, pRect->bottom - pRect->top);
PSDRV_Brush(dev, 0);
PSDRV_WriteNewPath(dev);
PSDRV_ResetClip(dev);
end:
HeapFree(GetProcessHeap(), 0, rgndata);
return TRUE;
}
/*********************************************************************
* EMFDRV_FrameRgn
*/
BOOL EMFDRV_FrameRgn( PHYSDEV dev, HRGN hrgn, HBRUSH hbrush, INT width, INT height )
{
EMRFRAMERGN *emr;
DWORD size, rgnsize, index;
BOOL ret;
index = EMFDRV_CreateBrushIndirect( dev, hbrush );
if(!index) return FALSE;
rgnsize = GetRegionData( hrgn, 0, NULL );
size = rgnsize + offsetof(EMRFRAMERGN,RgnData);
emr = HeapAlloc( GetProcessHeap(), 0, size );
GetRegionData( hrgn, rgnsize, (RGNDATA *)&emr->RgnData );
emr->emr.iType = EMR_FRAMERGN;
emr->emr.nSize = size;
emr->rclBounds.left = ((RGNDATA *)&emr->RgnData)->rdh.rcBound.left;
emr->rclBounds.top = ((RGNDATA *)&emr->RgnData)->rdh.rcBound.top;
emr->rclBounds.right = ((RGNDATA *)&emr->RgnData)->rdh.rcBound.right - 1;
emr->rclBounds.bottom = ((RGNDATA *)&emr->RgnData)->rdh.rcBound.bottom - 1;
emr->cbRgnData = rgnsize;
emr->ihBrush = index;
emr->szlStroke.cx = width;
emr->szlStroke.cy = height;
ret = EMFDRV_WriteRecord( dev, &emr->emr );
if(ret)
EMFDRV_UpdateBBox( dev, &emr->rclBounds );
HeapFree( GetProcessHeap(), 0, emr );
return ret;
}
QRegion qt_region_from_HRGN(HRGN rgn)
{
int numBytes = GetRegionData(rgn, 0, 0);
if (numBytes == 0)
return QRegion();
char *buf = new char[numBytes];
if (buf == 0)
return QRegion();
RGNDATA *rd = reinterpret_cast<RGNDATA*>(buf);
if (GetRegionData(rgn, numBytes, rd) == 0) {
delete [] buf;
return QRegion();
}
QRegion region;
RECT *r = reinterpret_cast<RECT*>(rd->Buffer);
for (uint i = 0; i < rd->rdh.nCount; ++i) {
QRect rect;
rect.setCoords(r->left, r->top, r->right - 1, r->bottom - 1);
++r;
region |= rect;
}
delete [] buf;
return region;
}
/*********************************************************************
* EMFDRV_PaintInvertRgn
*
* Helper for EMFDRV_{Paint|Invert}Rgn
*/
static BOOL EMFDRV_PaintInvertRgn( PHYSDEV dev, HRGN hrgn, DWORD iType )
{
EMRINVERTRGN *emr;
DWORD size, rgnsize;
BOOL ret;
rgnsize = GetRegionData( hrgn, 0, NULL );
size = rgnsize + offsetof(EMRINVERTRGN,RgnData);
emr = HeapAlloc( GetProcessHeap(), 0, size );
GetRegionData( hrgn, rgnsize, (RGNDATA *)&emr->RgnData );
emr->emr.iType = iType;
emr->emr.nSize = size;
emr->rclBounds.left = ((RGNDATA *)&emr->RgnData)->rdh.rcBound.left;
emr->rclBounds.top = ((RGNDATA *)&emr->RgnData)->rdh.rcBound.top;
emr->rclBounds.right = ((RGNDATA *)&emr->RgnData)->rdh.rcBound.right - 1;
emr->rclBounds.bottom = ((RGNDATA *)&emr->RgnData)->rdh.rcBound.bottom - 1;
emr->cbRgnData = rgnsize;
ret = EMFDRV_WriteRecord( dev, &emr->emr );
if(ret)
EMFDRV_UpdateBBox( dev, &emr->rclBounds );
HeapFree( GetProcessHeap(), 0, emr );
return ret;
}
///////////////////////////////////////////////////////////////////
// InflateRegion - Inflates a region by the x and y values
// specified in nXInflate and nYInflate
// Creates a new region that represents the inflated region
// (retains the contents of the old region)
// Returns NULL if unsuccessfull
static HRGN InflateRegion(HRGN hRgn, int nXInflate, int nYInflate)
{
// Local Variables
LPRGNDATA lpData; // The RGNDATA structure
LPRECT lpRect; // Pointer to the array of RECT structures
DWORD BufSize; // The amount of memory required
DWORD i; // General index variable
HRGN hRgnNew; // The newly created region
// Get the number of rectangles in the region
BufSize = GetRegionData(hRgn, 0, NULL);
if(BufSize == 0)
return NULL;
// Allocate memory for the RGNDATA structure
lpData = (LPRGNDATA)malloc(BufSize);
// Set the location of the RECT structures
lpRect = (LPRECT)(lpData->Buffer);
// Get the region data
if(!GetRegionData(hRgn, BufSize, lpData))
{
free(lpData);
return NULL;
}
// Expand (or contract) all the rectangles in the data
for(i=0; i<lpData->rdh.nCount; i++)
InflateRect(&lpRect[i], nXInflate, nYInflate);
// Create the new region
hRgnNew = ExtCreateRegion(NULL, lpData->rdh.nCount, lpData);
free((void*)lpData);
return hRgnNew;
}
INT CDECL EMFDRV_ExtSelectClipRgn( PHYSDEV dev, HRGN hrgn, INT mode )
{
EMREXTSELECTCLIPRGN *emr;
DWORD size, rgnsize;
BOOL ret;
if (!hrgn)
{
if (mode != RGN_COPY) return ERROR;
rgnsize = 0;
}
else rgnsize = GetRegionData( hrgn, 0, NULL );
size = rgnsize + offsetof(EMREXTSELECTCLIPRGN,RgnData);
emr = HeapAlloc( GetProcessHeap(), 0, size );
if (rgnsize) GetRegionData( hrgn, rgnsize, (RGNDATA *)&emr->RgnData );
emr->emr.iType = EMR_EXTSELECTCLIPRGN;
emr->emr.nSize = size;
emr->cbRgnData = rgnsize;
emr->iMode = mode;
ret = EMFDRV_WriteRecord( dev, &emr->emr );
HeapFree( GetProcessHeap(), 0, emr );
return ret ? SIMPLEREGION : ERROR;
}
void VBoxSeamlessCheckWindows()
{
VBOX_ENUM_PARAM param;
param.hdc = GetDC(HWND_DESKTOP);
param.hrgn = 0;
EnumWindows(VBoxEnumFunc, (LPARAM)¶m);
if (param.hrgn)
{
DWORD cbSize;
cbSize = GetRegionData(param.hrgn, 0, NULL);
if (cbSize)
{
PVBOXDISPIFESCAPE lpEscapeData = (PVBOXDISPIFESCAPE)malloc(VBOXDISPIFESCAPE_SIZE(cbSize));
if (lpEscapeData)
{
lpEscapeData->escapeCode = VBOXESC_SETVISIBLEREGION;
LPRGNDATA lpRgnData = VBOXDISPIFESCAPE_DATA(lpEscapeData, RGNDATA);
memset(lpRgnData, 0, cbSize);
cbSize = GetRegionData(param.hrgn, cbSize, lpRgnData);
if (cbSize)
{
#ifdef DEBUG
RECT *lpRect = (RECT *)&lpRgnData->Buffer[0];
Log(("VBoxTray: New visible region: \n"));
for (DWORD i=0;i<lpRgnData->rdh.nCount;i++)
{
Log(("VBoxTray: visible rect (%d,%d)(%d,%d)\n", lpRect[i].left, lpRect[i].top, lpRect[i].right, lpRect[i].bottom));
}
#endif
LPRGNDATA lpCtxRgnData = VBOXDISPIFESCAPE_DATA(gCtx.lpEscapeData, RGNDATA);
if ( !gCtx.lpEscapeData
|| (lpCtxRgnData->rdh.dwSize + lpCtxRgnData->rdh.nRgnSize != cbSize)
|| memcmp(lpCtxRgnData, lpRgnData, cbSize))
{
/* send to display driver */
VBoxDispIfEscape(&gCtx.pEnv->dispIf, lpEscapeData, cbSize);
if (gCtx.lpEscapeData)
free(gCtx.lpEscapeData);
gCtx.lpEscapeData = lpEscapeData;
}
else
Log(("VBoxTray: Visible rectangles haven't changed; ignore\n"));
}
if (lpEscapeData != gCtx.lpEscapeData)
free(lpEscapeData);
}
}
DeleteObject(param.hrgn);
}
ReleaseDC(HWND_DESKTOP, param.hdc);
}
void KLogWindow::DumpRegion(const char * mess, HRGN hRgn, bool detail, int p1)
{
if ( mess )
Log(mess, p1);
if ( hRgn==NULL )
Log(" NULL");
else
{
RECT rect;
memset(& rect, 0, sizeof(rect));
switch ( GetRgnBox(hRgn, & rect) )
{
case NULLREGION:
Log(" NULLREGION "); break;
case SIMPLEREGION:
Log(" SIMPLEREGION "); break;
case COMPLEXREGION:
Log(" COMPLEXREGION "); break;
default:
Log(" Error "); break;
}
Log(" RgnBox=[%d, %d, %d, %d) ", rect.left, rect.top, rect.right, rect.bottom);
int size = GetRegionData(hRgn, 0, NULL);
int rectcount = 0;
if ( size )
{
RGNDATA * pRegion = (RGNDATA *) new char[size];
GetRegionData(hRgn, size, pRegion);
const RECT * pRect = (const RECT *) & pRegion->Buffer;
rectcount = pRegion->rdh.nCount;
Log("%d rectangles", rectcount);
if ( detail )
{
Log("\r\n");
for (unsigned i=0; i<pRegion->rdh.nCount; i++)
Log("rect %d [%d, %d, %d, %d)\r\n", i, pRect[i].left, pRect[i].top, pRect[i].right, pRect[i].bottom);
}
delete [] (char *) pRegion;
}
else
Log("0 rectangle");
}
Log("\r\n");
}
static GpStatus get_region_scans_data(GpRegion *region, GpMatrix *matrix, LPRGNDATA *data)
{
GpRegion *region_copy;
GpStatus stat;
HRGN hrgn;
DWORD data_size;
stat = GdipCloneRegion(region, ®ion_copy);
if (stat == Ok)
{
stat = GdipTransformRegion(region_copy, matrix);
if (stat == Ok)
stat = GdipGetRegionHRgn(region_copy, NULL, &hrgn);
if (stat == Ok)
{
if (hrgn)
{
data_size = GetRegionData(hrgn, 0, NULL);
*data = heap_alloc_zero(data_size);
if (*data)
GetRegionData(hrgn, data_size, *data);
else
stat = OutOfMemory;
DeleteObject(hrgn);
}
else
{
data_size = sizeof(RGNDATAHEADER) + sizeof(RECT);
*data = heap_alloc_zero(data_size);
if (*data)
{
(*data)->rdh.dwSize = sizeof(RGNDATAHEADER);
(*data)->rdh.iType = RDH_RECTANGLES;
(*data)->rdh.nCount = 1;
(*data)->rdh.nRgnSize = sizeof(RECT);
(*data)->rdh.rcBound.left = (*data)->rdh.rcBound.top = -0x400000;
(*data)->rdh.rcBound.right = (*data)->rdh.rcBound.bottom = 0x400000;
memcpy((*data)->Buffer, &(*data)->rdh.rcBound, sizeof(RECT));
}
else
stat = OutOfMemory;
}
}
GdipDeleteRegion(region_copy);
}
return stat;
}
static void verify_region(HRGN hrgn, const RECT *rc)
{
union
{
RGNDATA data;
char buf[sizeof(RGNDATAHEADER) + sizeof(RECT)];
} rgn;
const RECT *rect;
DWORD ret;
ret = GetRegionData(hrgn, 0, NULL);
if (IsRectEmpty(rc))
ok(ret == sizeof(rgn.data.rdh), "expected sizeof(rdh), got %u\n", ret);
else
ok(ret == sizeof(rgn.data.rdh) + sizeof(RECT), "expected sizeof(rgn), got %u\n", ret);
if (!ret) return;
ret = GetRegionData(hrgn, sizeof(rgn), &rgn.data);
if (IsRectEmpty(rc))
ok(ret == sizeof(rgn.data.rdh), "expected sizeof(rdh), got %u\n", ret);
else
ok(ret == sizeof(rgn.data.rdh) + sizeof(RECT), "expected sizeof(rgn), got %u\n", ret);
trace("size %u, type %u, count %u, rgn size %u, bound (%d,%d-%d,%d)\n",
rgn.data.rdh.dwSize, rgn.data.rdh.iType,
rgn.data.rdh.nCount, rgn.data.rdh.nRgnSize,
rgn.data.rdh.rcBound.left, rgn.data.rdh.rcBound.top,
rgn.data.rdh.rcBound.right, rgn.data.rdh.rcBound.bottom);
if (rgn.data.rdh.nCount != 0)
{
rect = (const RECT *)rgn.data.Buffer;
trace("rect (%d,%d-%d,%d)\n", rect->left, rect->top, rect->right, rect->bottom);
ok(EqualRect(rect, rc), "rects don't match\n");
}
ok(rgn.data.rdh.dwSize == sizeof(rgn.data.rdh), "expected sizeof(rdh), got %u\n", rgn.data.rdh.dwSize);
ok(rgn.data.rdh.iType == RDH_RECTANGLES, "expected RDH_RECTANGLES, got %u\n", rgn.data.rdh.iType);
if (IsRectEmpty(rc))
{
ok(rgn.data.rdh.nCount == 0, "expected 0, got %u\n", rgn.data.rdh.nCount);
ok(rgn.data.rdh.nRgnSize == 0 ||
broken(rgn.data.rdh.nRgnSize == 168), /* NT4 */
"expected 0, got %u\n", rgn.data.rdh.nRgnSize);
}
else
{
ok(rgn.data.rdh.nCount == 1, "expected 1, got %u\n", rgn.data.rdh.nCount);
ok(rgn.data.rdh.nRgnSize == sizeof(RECT) ||
broken(rgn.data.rdh.nRgnSize == 168), /* NT4 */
"expected sizeof(RECT), got %u\n", rgn.data.rdh.nRgnSize);
}
ok(EqualRect(&rgn.data.rdh.rcBound, rc), "rects don't match\n");
}
QT_BEGIN_NAMESPACE
/*
In Windows versions before Windows Vista CreateRectRgn - when called in a multi-threaded
environment - might return an invalid handle. This function works around this limitation
by verifying the handle with a quick GetRegionData() call and re-creates the region
if necessary.
*/
HRGN qt_tryCreateRegion(QRegion::RegionType type, int left, int top, int right, int bottom)
{
const int tries = 10;
for (int i = 0; i < tries; ++i) {
HRGN region;
switch (type) {
case QRegion::Rectangle:
region = CreateRectRgn(left, top, right, bottom);
break;
case QRegion::Ellipse:
#ifndef Q_OS_WINCE
region = CreateEllipticRgn(left, top, right, bottom);
#endif
break;
}
if (region) {
if (GetRegionData(region, 0, 0))
return region;
else
DeleteObject(region);
}
}
return 0;
}
void EditableMapObject::SetName(string name, int8_t langCode)
{
strings::Trim(name);
if (name.empty())
return;
ASSERT_NOT_EQUAL(StringUtf8Multilang::kDefaultCode, langCode,
("Direct editing of default name is deprecated."));
if (!Editor::Instance().OriginalFeatureHasDefaultName(GetID()))
{
const auto mwmInfo = GetID().m_mwmId.GetInfo();
if (mwmInfo)
{
vector<int8_t> mwmLanguages;
mwmInfo->GetRegionData().GetLanguages(mwmLanguages);
if (CanUseAsDefaultName(langCode, mwmLanguages))
m_name.AddString(StringUtf8Multilang::kDefaultCode, name);
}
}
m_name.AddString(langCode, name);
}
std::string Info::GetBookmarkName()
{
std::string bookmarkName;
auto const mwmInfo = GetID().m_mwmId.GetInfo();
if (mwmInfo)
{
bookmarkName = GetPreferredBookmarkStr(m_bookmarkData.m_customName, mwmInfo->GetRegionData());
if (bookmarkName.empty())
bookmarkName = GetPreferredBookmarkStr(m_bookmarkData.m_name, mwmInfo->GetRegionData());
}
if (bookmarkName.empty())
bookmarkName = GetPreferredBookmarkName(m_bookmarkData);
return bookmarkName;
}
static stubDispatchVisibleRegions(WindowInfo *pWindow)
{
DWORD dwCount;
LPRGNDATA lpRgnData;
dwCount = GetRegionData(pWindow->hVisibleRegion, 0, NULL);
lpRgnData = crAlloc(dwCount);
if (lpRgnData)
{
GetRegionData(pWindow->hVisibleRegion, dwCount, lpRgnData);
crDebug("Dispatched WindowVisibleRegion (%i, cRects=%i)", pWindow->spuWindow, lpRgnData->rdh.nCount);
stub.spuDispatch.WindowVisibleRegion(pWindow->spuWindow, lpRgnData->rdh.nCount, (GLint*) lpRgnData->Buffer);
crFree(lpRgnData);
}
else crWarning("GetRegionData failed, VisibleRegions update failed");
}
void Info::GetPrefferedNames(std::string & primaryName, std::string & secondaryName) const
{
auto const mwmInfo = GetID().m_mwmId.GetInfo();
if (mwmInfo)
{
auto const deviceLang = StringUtf8Multilang::GetLangIndex(languages::GetCurrentNorm());
feature::GetPreferredNames(mwmInfo->GetRegionData(), m_name, deviceLang,
true /* allowTranslit */, primaryName, secondaryName);
}
}
static void dump_region(HRGN hrgn)
{
DWORD i, size;
RGNDATA *data = NULL;
RECT *rect;
if (!hrgn)
{
printf( "(null) region\n" );
return;
}
if (!(size = GetRegionData( hrgn, 0, NULL ))) return;
if (!(data = HeapAlloc( GetProcessHeap(), 0, size ))) return;
GetRegionData( hrgn, size, data );
printf( "%d rects:", data->rdh.nCount );
for (i = 0, rect = (RECT *)data->Buffer; i < data->rdh.nCount; i++, rect++)
printf( " (%d,%d)-(%d,%d)", rect->left, rect->top, rect->right, rect->bottom );
printf( "\n" );
HeapFree( GetProcessHeap(), 0, data );
}
static void dump_region( const char *p, HRGN hrgn)
{
DWORD i, size;
RGNDATA *data = NULL;
RECT *rect;
if (!hrgn) {
TRACE( "%s null region\n", p );
return;
}
if (!(size = GetRegionData( hrgn, 0, NULL ))) {
return;
}
if (!(data = HeapAlloc( GetProcessHeap(), 0, size ))) return;
GetRegionData( hrgn, size, data );
TRACE("%s %d rects:", p, data->rdh.nCount );
for (i = 0, rect = (RECT *)data->Buffer; i<20 && i < data->rdh.nCount; i++, rect++)
TRACE( " %s", wine_dbgstr_rect( rect));
TRACE("\n");
HeapFree( GetProcessHeap(), 0, data );
}
INT
FASTCALL
MirrorRgnByWidth(
_In_ HRGN hrgn,
_In_ INT Width,
_In_ 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;
}
bool GSDevice7::Reset(int w, int h, bool fs)
{
if(!__super::Reset(w, h, fs))
return false;
m_backbuffer = NULL;
DDSURFACEDESC2 desc;
memset(&desc, 0, sizeof(desc));
desc.dwSize = sizeof(desc);
desc.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT;
desc.ddsCaps.dwCaps = DDSCAPS_VIDEOMEMORY | DDSCAPS_3DDEVICE;
desc.dwWidth = w;
desc.dwHeight = h;
if(FAILED(m_dd->CreateSurface(&desc, &m_backbuffer, NULL)))
{
return false;
}
CComPtr<IDirectDrawClipper> clipper;
if(FAILED(m_dd->CreateClipper(0, &clipper, NULL)))
{
return false;
}
{
// ???
HRGN hrgn = CreateRectRgn(0, 0, w, h);
BYTE buff[1024];
GetRegionData(hrgn, sizeof(buff), (RGNDATA*)buff);
DeleteObject(hrgn);
clipper->SetClipList((RGNDATA*)buff, 0);
if(FAILED(m_backbuffer->SetClipper(clipper)))
{
return false;
}
}
return true;
}
/***********************************************************************
* PSDRV_AddClip
*/
void PSDRV_AddClip( PHYSDEV dev, HRGN hrgn )
{
CHAR szArrayName[] = "clippath";
RECT *rect;
RGNDATA *data;
DWORD i, size = GetRegionData(hrgn, 0, NULL);
if (!size) return;
if (!(data = HeapAlloc( GetProcessHeap(), 0, size ))) return;
GetRegionData( hrgn, size, data );
rect = (RECT *)data->Buffer;
switch (data->rdh.nCount)
{
case 0:
/* set an empty clip path. */
PSDRV_WriteRectClip(dev, 0, 0, 0, 0);
break;
case 1:
/* optimize when it is a simple region */
PSDRV_WriteRectClip(dev, rect->left, rect->top,
rect->right - rect->left, rect->bottom - rect->top);
break;
default:
PSDRV_WriteArrayDef(dev, szArrayName, data->rdh.nCount * 4);
for (i = 0; i < data->rdh.nCount; i++, rect++)
{
PSDRV_WriteArrayPut(dev, szArrayName, i * 4, rect->left);
PSDRV_WriteArrayPut(dev, szArrayName, i * 4 + 1, rect->top);
PSDRV_WriteArrayPut(dev, szArrayName, i * 4 + 2, rect->right - rect->left);
PSDRV_WriteArrayPut(dev, szArrayName, i * 4 + 3, rect->bottom - rect->top);
}
PSDRV_WriteRectClip2(dev, szArrayName);
break;
}
HeapFree( GetProcessHeap(), 0, data );
}
HRGN qt_tryCreatePolygonRegion(const QPolygon &a, Qt::FillRule fillRule)
{
const int tries = 10;
for (int i = 0; i < tries; ++i) {
HRGN region = CreatePolygonRgn(reinterpret_cast<const POINT*>(a.data()), a.size(),
fillRule == Qt::OddEvenFill ? ALTERNATE : WINDING);
if (region) {
if (GetRegionData(region, 0, 0))
return region;
else
DeleteObject(region);
}
}
return 0;
}
static HRESULT WINAPI IWineD3DClipperImpl_GetClipList(IWineD3DClipper *iface, const RECT *Rect,
RGNDATA *ClipList, DWORD *Size)
{
IWineD3DClipperImpl *This = (IWineD3DClipperImpl *)iface;
TRACE("(%p,%p,%p,%p)\n", This, Rect, ClipList, Size);
if (This->hWnd)
{
HDC hDC = GetDCEx(This->hWnd, NULL, DCX_WINDOW);
if (hDC)
{
HRGN hRgn = CreateRectRgn(0,0,0,0);
if (GetRandomRgn(hDC, hRgn, SYSRGN))
{
if (GetVersion() & 0x80000000)
{
/* map region to screen coordinates */
POINT org;
GetDCOrgEx( hDC, &org );
OffsetRgn( hRgn, org.x, org.y );
}
if (Rect)
{
HRGN hRgnClip = CreateRectRgn(Rect->left, Rect->top,
Rect->right, Rect->bottom);
CombineRgn(hRgn, hRgn, hRgnClip, RGN_AND);
DeleteObject(hRgnClip);
}
*Size = GetRegionData(hRgn, *Size, ClipList);
}
DeleteObject(hRgn);
ReleaseDC(This->hWnd, hDC);
}
return WINED3D_OK;
}
else
{
static int warned = 0;
if (warned++ < 10)
FIXME("(%p,%p,%p,%p),stub!\n",This,Rect,ClipList,Size);
if (Size) *Size=0;
return WINEDDERR_NOCLIPLIST;
}
}
LOCAL void
fb_copyarea(WINDISPLAY *mod, struct TVRequest *req)
{
WINWINDOW *win = req->tvr_Op.CopyArea.Window;
struct THook *exposehook = (struct THook *)
TGetTag(req->tvr_Op.CopyArea.Tags, TVisual_ExposeHook, TNULL);
TINT *sr = req->tvr_Op.CopyArea.Rect;
TINT dx = req->tvr_Op.CopyArea.DestX - sr[0];
TINT dy = req->tvr_Op.CopyArea.DestY - sr[1];
RECT r;
r.left = sr[4];
r.top = sr[5];
r.right = sr[4] + sr[2];
r.bottom = sr[5] + sr[3];
if (exposehook)
{
RGNDATAHEADER *rdh = (RGNDATAHEADER *) win->fbv_RegionData;
RECT *rd = (RECT *) (rdh + 1);
HRGN updateregion = CreateRectRgn(0, 0, 0, 0);
ScrollDC(win->fbv_HDC, dx, dy, &r, &r, updateregion, NULL);
if (GetRegionData(updateregion, 1024, (LPRGNDATA) rdh))
{
TUINT i;
for (i = 0; i < rdh->nCount; ++i)
TCallHookPkt(exposehook, win, (TTAG) (rd + i));
}
else
{
TDBPRINTF(TDB_WARN,("Regiondata buffer too small\n"));
InvalidateRgn(win->fbv_HWnd, updateregion, FALSE);
}
DeleteObject(updateregion);
}
else
ScrollDC(win->fbv_HDC, dx, dy, &r, &r, NULL, NULL);
win->fbv_Dirty = TTRUE;
}
HRGN qt_tryCreateRegion(QRegion::RegionType type, int left, int top, int right, int bottom)
{
const int tries = 10;
for (int i = 0; i < tries; ++i) {
HRGN region = 0;
switch (type) {
case QRegion::Rectangle:
region = CreateRectRgn(left, top, right, bottom);
break;
case QRegion::Ellipse:
#ifndef Q_OS_WINCE
region = CreateEllipticRgn(left, top, right, bottom);
#endif
break;
}
if (region) {
if (GetRegionData(region, 0, 0))
return region;
else
DeleteObject(region);
}
}
return 0;
}
/******************************************************************************
* GdipCreateRegionHrgn [GDIPLUS.@]
*/
GpStatus WINGDIPAPI GdipCreateRegionHrgn(HRGN hrgn, GpRegion **region)
{
DWORD size;
LPRGNDATA buf;
LPRECT rect;
GpStatus stat;
GpPath* path;
GpRegion* local;
DWORD i;
TRACE("(%p, %p)\n", hrgn, region);
if(!region || !(size = GetRegionData(hrgn, 0, NULL)))
return InvalidParameter;
buf = heap_alloc_zero(size);
if(!buf)
return OutOfMemory;
if(!GetRegionData(hrgn, size, buf)){
heap_free(buf);
return GenericError;
}
if(buf->rdh.nCount == 0){
if((stat = GdipCreateRegion(&local)) != Ok){
heap_free(buf);
return stat;
}
if((stat = GdipSetEmpty(local)) != Ok){
heap_free(buf);
GdipDeleteRegion(local);
return stat;
}
*region = local;
heap_free(buf);
return Ok;
}
if((stat = GdipCreatePath(FillModeAlternate, &path)) != Ok){
heap_free(buf);
return stat;
}
rect = (LPRECT)buf->Buffer;
for(i = 0; i < buf->rdh.nCount; i++){
if((stat = GdipAddPathRectangle(path, (REAL)rect->left, (REAL)rect->top,
(REAL)(rect->right - rect->left), (REAL)(rect->bottom - rect->top))) != Ok){
heap_free(buf);
GdipDeletePath(path);
return stat;
}
rect++;
}
stat = GdipCreateRegionPath(path, region);
heap_free(buf);
GdipDeletePath(path);
return stat;
}
/*****************************************************************************
* IDirectDrawClipper::GetClipList
*
* Retrieve a copy of the clip list
*
* Arguments:
* rect: Rectangle to be used to clip the clip list or NULL for the
* entire clip list.
* clip_list: structure for the resulting copy of the clip list.
* If NULL, fills Size up to the number of bytes necessary to hold
* the entire clip.
* clip_list_size: Size of resulting clip list; size of the buffer at clip_list
* or, if clip_list is NULL, receives the required size of the buffer
* in bytes.
*
* RETURNS
* Either DD_OK or DDERR_*
************************************************************************/
static HRESULT WINAPI ddraw_clipper_GetClipList(IDirectDrawClipper *iface, RECT *rect,
RGNDATA *clip_list, DWORD *clip_list_size)
{
struct ddraw_clipper *clipper = impl_from_IDirectDrawClipper(iface);
HRGN region;
TRACE("iface %p, rect %s, clip_list %p, clip_list_size %p.\n",
iface, wine_dbgstr_rect(rect), clip_list, clip_list_size);
wined3d_mutex_lock();
if (clipper->window)
{
if (!(region = get_window_region(clipper->window)))
{
wined3d_mutex_unlock();
WARN("Failed to get window region.\n");
return E_FAIL;
}
}
else
{
if (!(region = clipper->region))
{
wined3d_mutex_unlock();
WARN("No clip list set.\n");
return DDERR_NOCLIPLIST;
}
}
if (rect)
{
HRGN clip_region;
if (!(clip_region = CreateRectRgnIndirect(rect)))
{
wined3d_mutex_unlock();
ERR("Failed to create region.\n");
if (clipper->window)
DeleteObject(region);
return E_FAIL;
}
if (CombineRgn(clip_region, region, clip_region, RGN_AND) == ERROR)
{
wined3d_mutex_unlock();
ERR("Failed to combine regions.\n");
DeleteObject(clip_region);
if (clipper->window)
DeleteObject(region);
return E_FAIL;
}
if (clipper->window)
DeleteObject(region);
region = clip_region;
}
*clip_list_size = GetRegionData(region, *clip_list_size, clip_list);
if (rect || clipper->window)
DeleteObject(region);
wined3d_mutex_unlock();
return DD_OK;
}
