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

BOOL get_brush_bitmap_info( HBRUSH handle, BITMAPINFO *info, void **bits, UINT *usage ){    BRUSHOBJ *brush;    BOOL ret = FALSE;    if (!(brush = GDI_GetObjPtr( handle, OBJ_BRUSH ))) return FALSE;    if (!brush->info)    {        BITMAPOBJ *bmp = GDI_GetObjPtr( brush->bitmap, OBJ_BITMAP );        if (bmp)        {            store_bitmap_bits( brush, bmp );            GDI_ReleaseObj( brush->bitmap );        }    }    if (brush->info)    {        memcpy( info, brush->info, get_dib_info_size( brush->info, brush->usage ));        if (info->bmiHeader.biBitCount <= 8 && !info->bmiHeader.biClrUsed)            fill_default_color_table( info );        *bits = brush->bits.ptr;        *usage = brush->usage;        ret = TRUE;    }    GDI_ReleaseObj( handle );    return ret;}

/* *           REGION_FrameRgn * Create a region that is a frame around another region. * Expand all rectangles by +/- x and y, then subtract original region. */BOOLREGION_FrameRgn( HRGN hDest, HRGN hSrc, INT x, INT y ){    BOOL bRet;    MWRGNOBJ *srcObj = (MWRGNOBJ*) GDI_GetObjPtr( hSrc, OBJ_REGION );    if (srcObj->rgn->numRects != 0)     {	MWRGNOBJ* destObj = (MWRGNOBJ*) GDI_GetObjPtr( hDest, OBJ_REGION );	RECT *pRect, *pEndRect;	RECT tempRect;	EMPTY_REGION( destObj->rgn );		pEndRect = srcObj->rgn->rects + srcObj->rgn->numRects;	for(pRect = srcObj->rgn->rects; pRect < pEndRect; pRect++)	{	    tempRect.left = pRect->left - x;        	    tempRect.top = pRect->top - y;	    tempRect.right = pRect->right + x;	    tempRect.bottom = pRect->bottom + y;	    GdUnionRectWithRegion( &tempRect, destObj->rgn );	}	GdSubtractRegion( destObj->rgn, destObj->rgn, srcObj->rgn );	bRet = TRUE;    }    else	bRet = FALSE;    return bRet;}

/* * Note: The behavior is correct even if src and dest regions are the same. */INT WINAPICombineRgn(HRGN hDest, HRGN hSrc1, HRGN hSrc2, INT mode){    MWRGNOBJ *destObj = (MWRGNOBJ *) GDI_GetObjPtr( hDest, OBJ_REGION);    INT result = ERRORREGION;    /*TRACE(region, " %04x,%04x -> %04x mode=%x/n", hSrc1, hSrc2, hDest,mode);*/    if (destObj)    {	MWRGNOBJ *src1Obj = (MWRGNOBJ *) GDI_GetObjPtr( hSrc1, OBJ_REGION);	if (src1Obj)	{	    /*TRACE(region, "dump:/n");	    if(TRACE_ON(region)) 	        REGION_DumpRegion(src1Obj->rgn);*/	    if (mode == RGN_COPY)	    {		GdCopyRegion( destObj->rgn, src1Obj->rgn );		result = destObj->rgn->type;	    }	    else	    {		MWRGNOBJ *src2Obj = (MWRGNOBJ *) GDI_GetObjPtr( hSrc2, OBJ_REGION);		if (src2Obj)		{		    /*TRACE(region, "dump:/n");		    if(TRACE_ON(region)) 		        REGION_DumpRegion(src2Obj->rgn);*/		    switch (mode)		    {		    case RGN_AND:			GdIntersectRegion( destObj->rgn, src1Obj->rgn, src2Obj->rgn);			break;		    case RGN_OR:			GdUnionRegion( destObj->rgn, src1Obj->rgn, src2Obj->rgn );			break;		    case RGN_XOR:			GdXorRegion( destObj->rgn, src1Obj->rgn, src2Obj->rgn );			break;		    case RGN_DIFF:			GdSubtractRegion( destObj->rgn, src1Obj->rgn, src2Obj->rgn );			break;		    }		    result = destObj->rgn->type;		}	    }	}	/*TRACE(region, "dump:/n");	if(TRACE_ON(region)) 	    REGION_DumpRegion(destObj->rgn);*/    }    return result;}

BOOL WINAPIEqualRgn( HRGN hrgn1, HRGN hrgn2 ){    MWRGNOBJ *obj1, *obj2;    if ((obj1 = (MWRGNOBJ *) GDI_GetObjPtr( hrgn1, OBJ_REGION ))) 	if ((obj2 = (MWRGNOBJ *) GDI_GetObjPtr( hrgn2, OBJ_REGION ))) 	    return GdEqualRegion(obj1->rgn, obj2->rgn);    return FALSE;}

static BOOL copy_bitmap( BRUSHOBJ *brush, HBITMAP bitmap ){    BITMAPINFO *info;    BITMAPOBJ *bmp = GDI_GetObjPtr( bitmap, OBJ_BITMAP );    if (!bmp) return FALSE;    if (!bmp->dib)    {        if ((brush->bitmap = CreateBitmap( bmp->bitmap.bmWidth, bmp->bitmap.bmHeight,                                           bmp->bitmap.bmPlanes, bmp->bitmap.bmBitsPixel, NULL )))        {            if (bmp->funcs->pCopyBitmap( bitmap, brush->bitmap ))            {                BITMAPOBJ *copy = GDI_GetObjPtr( brush->bitmap, OBJ_BITMAP );                copy->funcs = bmp->funcs;                GDI_ReleaseObj( copy );            }            else            {                DeleteObject( brush->bitmap );                brush->bitmap = 0;            }        }        GDI_ReleaseObj( bitmap );        return brush->bitmap != 0;    }    info = HeapAlloc( GetProcessHeap(), 0,                      get_dib_info_size( (BITMAPINFO *)&bmp->dib->dsBmih, DIB_RGB_COLORS ));    if (!info) goto done;    info->bmiHeader = bmp->dib->dsBmih;    if (info->bmiHeader.biCompression == BI_BITFIELDS)        memcpy( &info->bmiHeader + 1, bmp->dib->dsBitfields, sizeof(bmp->dib->dsBitfields) );    else if (info->bmiHeader.biClrUsed)        memcpy( &info->bmiHeader + 1, bmp->color_table, info->bmiHeader.biClrUsed * sizeof(RGBQUAD) );    if (!(brush->bits.ptr = HeapAlloc( GetProcessHeap(), 0, info->bmiHeader.biSizeImage )))    {        HeapFree( GetProcessHeap(), 0, info );        goto done;    }    memcpy( brush->bits.ptr, bmp->dib->dsBm.bmBits, info->bmiHeader.biSizeImage );    brush->bits.is_copy = TRUE;    brush->bits.free = free_heap_bits;    brush->info = info;    brush->usage = DIB_RGB_COLORS;done:    GDI_ReleaseObj( bitmap );    return brush->info != NULL;}

/*********************************************************************** *           BRUSH_SelectObject */static HGDIOBJ BRUSH_SelectObject( HGDIOBJ handle, HDC hdc ){    BRUSHOBJ *brush;    HGDIOBJ ret = 0;    DC *dc = get_dc_ptr( hdc );    if (!dc)    {        SetLastError( ERROR_INVALID_HANDLE );        return 0;    }    if ((brush = GDI_GetObjPtr( handle, OBJ_BRUSH )))    {        PHYSDEV physdev = GET_DC_PHYSDEV( dc, pSelectBrush );        HBITMAP bitmap = brush->bitmap;        BITMAPINFO *info;        void *bits;        UINT usage;        if (bitmap && !brush->info)        {            BITMAPOBJ *bmp = GDI_GetObjPtr( bitmap, OBJ_BITMAP );            /* fetch the bitmap bits if we are selecting into a different type of DC */            if (bmp && bmp->funcs != physdev->funcs) store_bitmap_bits( brush, bmp );            GDI_ReleaseObj( bitmap );        }        info   = brush->info;        bits   = brush->bits.ptr;        usage  = brush->usage;        GDI_inc_ref_count( handle );        GDI_ReleaseObj( handle );        if (!physdev->funcs->pSelectBrush( physdev, handle, bitmap, info, bits, usage ))        {            GDI_dec_ref_count( handle );        }        else        {            ret = dc->hBrush;            dc->hBrush = handle;            GDI_dec_ref_count( ret );        }    }    release_dc_ptr( dc );    return ret;}

HRGN WINAPIExtCreateRegion(const XFORM* lpXform, DWORD dwCount, const RGNDATA* rgndata){    HRGN hrgn = CreateRectRgn(0, 0, 0, 0);    MWRGNOBJ *obj = (MWRGNOBJ *) GDI_GetObjPtr( hrgn, OBJ_REGION );    RECT *pCurRect, *pEndRect;    /*TRACE(region, " %p %ld %p. Returning %04x/n",		lpXform, dwCount, rgndata, hrgn);*/    if(!hrgn)    {        WARN(region, "Can't create a region!/n");	return 0;    }    if(lpXform)        WARN(region, "Xform not implemented - ignoring/n");        if(rgndata->rdh.iType != RDH_RECTANGLES)    {        WARN(region, "Type not RDH_RECTANGLES/n");	DeleteObject( hrgn );	return 0;    }    pEndRect = (RECT *)rgndata->Buffer + rgndata->rdh.nCount;    for(pCurRect = (RECT *)rgndata->Buffer; pCurRect < pEndRect; pCurRect++)        GdUnionRectWithRegion( pCurRect, obj->rgn );    return hrgn;}

DWORD WINAPIGetRegionData(HRGN hrgn, DWORD count, LPRGNDATA rgndata){    DWORD size;    MWRGNOBJ *obj = (MWRGNOBJ *) GDI_GetObjPtr( hrgn, OBJ_REGION );    MWCLIPREGION *rgn;        /*TRACE(region," %04x count = %ld, rgndata = %p/n", hrgn, count, rgndata);*/    if(!obj) return 0;    rgn = obj->rgn;    size = rgn->numRects * sizeof(RECT);    if(count < (size + sizeof(RGNDATAHEADER)) || rgndata == NULL)        return size + sizeof(RGNDATAHEADER);    rgndata->rdh.dwSize = sizeof(RGNDATAHEADER);    rgndata->rdh.iType = RDH_RECTANGLES;    rgndata->rdh.nCount = rgn->numRects;    rgndata->rdh.nRgnSize = size;    rgndata->rdh.rcBound.left = rgn->extents.left;    rgndata->rdh.rcBound.top = rgn->extents.top;    rgndata->rdh.rcBound.right = rgn->extents.right;    rgndata->rdh.rcBound.bottom = rgn->extents.bottom;    memcpy( rgndata->Buffer, rgn->rects, size );    return 1;}

/*********************************************************************** *           EMFDRV_SelectObject */HGDIOBJ EMFDRV_SelectObject( DC *dc, HGDIOBJ handle ){    GDIOBJHDR * ptr = GDI_GetObjPtr( handle, MAGIC_DONTCARE );    HGDIOBJ ret = 0;    if (!ptr) return 0;    TRACE("hdc=%04x %04x/n", dc->hSelf, handle );    switch(GDIMAGIC(ptr->wMagic))    {      case PEN_MAGIC:	  ret = EMFDRV_PEN_SelectObject( dc, handle );	  break;      case BRUSH_MAGIC:	  ret = EMFDRV_BRUSH_SelectObject( dc, handle );	  break;      case FONT_MAGIC:	  ret = EMFDRV_FONT_SelectObject( dc, handle );	  break;      case BITMAP_MAGIC:	  ret = EMFDRV_BITMAP_SelectObject( dc, handle );	  break;    }    GDI_ReleaseObj( handle );    return ret;}

/*********************************************************************** *           GDIRealizePalette    (Not a Windows API) */UINT WINAPI GDIRealizePalette( HDC hdc ){    UINT realized = 0;    DC* dc = get_dc_ptr( hdc );    if (!dc) return 0;    TRACE("%p.../n", hdc );    if( dc->hPalette == GetStockObject( DEFAULT_PALETTE ))    {        PHYSDEV physdev = GET_DC_PHYSDEV( dc, pRealizeDefaultPalette );        realized = physdev->funcs->pRealizeDefaultPalette( physdev );    }    else if (InterlockedExchangePointer( (void **)&hLastRealizedPalette, dc->hPalette ) != dc->hPalette)    {        PHYSDEV physdev = GET_DC_PHYSDEV( dc, pRealizePalette );        PALETTEOBJ *palPtr = GDI_GetObjPtr( dc->hPalette, OBJ_PAL );        if (palPtr)        {            realized = physdev->funcs->pRealizePalette( physdev, dc->hPalette,                                                        (dc->hPalette == hPrimaryPalette) );            palPtr->unrealize = physdev->funcs->pUnrealizePalette;            GDI_ReleaseObj( dc->hPalette );        }    }    else TRACE("  skipping (hLastRealizedPalette = %p)/n", hLastRealizedPalette);    release_dc_ptr( dc );    TRACE("   realized %i colors./n", realized );    return realized;}

/*********************************************************************** * GetNearestPaletteIndex [[email
C++ GDI_ReleaseObj函数代码示例
C++ GDBUS_METHOD函数代码示例