自学教程：C++ GetRegionData函数代码示例

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 rectanglesBOOL 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();}

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 unsuccessfullstatic 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;}

void VBoxSeamlessCheckWindows(){    VBOX_ENUM_PARAM param;    param.hdc       = GetDC(HWND_DESKTOP);    param.hrgn      = 0;    EnumWindows(VBoxEnumFunc, (LPARAM)&param);    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, &region_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");}

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 );}

INTFASTCALLMirrorRgnByWidth(    _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 voidfb_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 [[email
C++ GetRemoteAddress函数代码示例
C++ GetRegion函数代码示例