/******************************************************************************
* GdiAlphaBlend [GDI32.@]
*/
BOOL WINAPI GdiAlphaBlend(HDC hdcDst, int xDst, int yDst, int widthDst, int heightDst,
HDC hdcSrc, int xSrc, int ySrc, int widthSrc, int heightSrc,
BLENDFUNCTION blendFunction)
{
BOOL ret = FALSE;
DC *dcDst, *dcSrc;
TRACE( "%p %d,%d %dx%d -> %p %d,%d %dx%d op=%02x flags=%02x srcconstalpha=%02x alphafmt=%02x\n",
hdcSrc, xSrc, ySrc, widthSrc, heightSrc, hdcDst, xDst, yDst, widthDst, heightDst,
blendFunction.BlendOp, blendFunction.BlendFlags,
blendFunction.SourceConstantAlpha, blendFunction.AlphaFormat );
dcSrc = get_dc_ptr( hdcSrc );
if (!dcSrc) return FALSE;
if ((dcDst = get_dc_ptr( hdcDst )))
{
PHYSDEV src_dev = GET_DC_PHYSDEV( dcSrc, pAlphaBlend );
PHYSDEV dst_dev = GET_DC_PHYSDEV( dcDst, pAlphaBlend );
update_dc( dcSrc );
update_dc( dcDst );
ret = dst_dev->funcs->pAlphaBlend( dst_dev, xDst, yDst, widthDst, heightDst,
src_dev, xSrc, ySrc, widthSrc, heightSrc, blendFunction );
release_dc_ptr( dcDst );
}
release_dc_ptr( dcSrc );
return ret;
}
/***********************************************************************
* StretchBlt (GDI32.@)
*/
BOOL WINAPI StretchBlt( HDC hdcDst, INT xDst, INT yDst, INT widthDst, INT heightDst,
HDC hdcSrc, INT xSrc, INT ySrc, INT widthSrc, INT heightSrc, DWORD rop )
{
BOOL ret = FALSE;
DC *dcDst, *dcSrc;
if (!rop_uses_src( rop )) return PatBlt( hdcDst, xDst, yDst, widthDst, heightDst, rop );
TRACE("%p %d,%d %dx%d -> %p %d,%d %dx%d rop=%06x\n",
hdcSrc, xSrc, ySrc, widthSrc, heightSrc,
hdcDst, xDst, yDst, widthDst, heightDst, rop );
if (!(dcDst = get_dc_ptr( hdcDst ))) return FALSE;
if ((dcSrc = get_dc_ptr( hdcSrc )))
{
PHYSDEV src_dev = GET_DC_PHYSDEV( dcSrc, pStretchBlt );
PHYSDEV dst_dev = GET_DC_PHYSDEV( dcDst, pStretchBlt );
update_dc( dcSrc );
update_dc( dcDst );
ret = dst_dev->funcs->pStretchBlt( dst_dev, xDst, yDst, widthDst, heightDst,
src_dev, xSrc, ySrc, widthSrc, heightSrc, rop );
release_dc_ptr( dcSrc );
}
release_dc_ptr( dcDst );
return ret;
}
/***********************************************************************
* wglMakeContextCurrentARB
*/
static BOOL WINAPI wglMakeContextCurrentARB(HDC hDrawDC, HDC hReadDC, HGLRC hglrc)
{
BOOL ret = FALSE;
PHYSDEV draw_physdev, read_physdev;
DC *DrawDC;
DC *ReadDC;
TRACE("hDrawDC: (%p), hReadDC: (%p) hglrc: (%p)\n", hDrawDC, hReadDC, hglrc);
/* Both hDrawDC and hReadDC need to be valid */
DrawDC = get_dc_ptr( hDrawDC );
if (!DrawDC) return FALSE;
ReadDC = get_dc_ptr( hReadDC );
if (!ReadDC) {
release_dc_ptr( DrawDC );
return FALSE;
}
update_dc( DrawDC );
update_dc( ReadDC );
draw_physdev = GET_DC_PHYSDEV( DrawDC, pwglMakeContextCurrentARB );
read_physdev = GET_DC_PHYSDEV( ReadDC, pwglMakeContextCurrentARB );
if (draw_physdev->funcs == read_physdev->funcs)
ret = draw_physdev->funcs->pwglMakeContextCurrentARB(draw_physdev, read_physdev, hglrc);
release_dc_ptr( DrawDC );
release_dc_ptr( ReadDC );
return ret;
}
/***********************************************************************
* StretchBlt (GDI32.@)
*/
BOOL WINAPI StretchBlt( HDC hdcDst, INT xDst, INT yDst, INT widthDst, INT heightDst,
HDC hdcSrc, INT xSrc, INT ySrc, INT widthSrc, INT heightSrc, DWORD rop )
{
BOOL ret = FALSE;
DC *dcDst, *dcSrc;
if (!rop_uses_src( rop )) return PatBlt( hdcDst, xDst, yDst, widthDst, heightDst, rop );
if (!(dcDst = get_dc_ptr( hdcDst ))) return FALSE;
if ((dcSrc = get_dc_ptr( hdcSrc )))
{
struct bitblt_coords src, dst;
update_dc( dcSrc );
update_dc( dcDst );
src.log_x = xSrc;
src.log_y = ySrc;
src.log_width = widthSrc;
src.log_height = heightSrc;
src.layout = dcSrc->layout;
dst.log_x = xDst;
dst.log_y = yDst;
dst.log_width = widthDst;
dst.log_height = heightDst;
dst.layout = dcDst->layout;
if (rop & NOMIRRORBITMAP)
{
src.layout |= LAYOUT_BITMAPORIENTATIONPRESERVED;
dst.layout |= LAYOUT_BITMAPORIENTATIONPRESERVED;
rop &= ~NOMIRRORBITMAP;
}
ret = !get_vis_rectangles( dcDst, &dst, dcSrc, &src );
TRACE("src %p log=%d,%d %dx%d phys=%d,%d %dx%d vis=%s dst %p log=%d,%d %dx%d phys=%d,%d %dx%d vis=%s rop=%06x\n",
hdcSrc, src.log_x, src.log_y, src.log_width, src.log_height,
src.x, src.y, src.width, src.height, wine_dbgstr_rect(&src.visrect),
hdcDst, dst.log_x, dst.log_y, dst.log_width, dst.log_height,
dst.x, dst.y, dst.width, dst.height, wine_dbgstr_rect(&dst.visrect), rop );
if (!ret)
{
PHYSDEV src_dev = GET_DC_PHYSDEV( dcSrc, pStretchBlt );
PHYSDEV dst_dev = GET_DC_PHYSDEV( dcDst, pStretchBlt );
ret = dst_dev->funcs->pStretchBlt( dst_dev, &dst, src_dev, &src, rop );
}
release_dc_ptr( dcSrc );
}
release_dc_ptr( dcDst );
return ret;
}
/***********************************************************************
* GetClipBox (GDI32.@)
*/
INT WINAPI GetClipBox( HDC hdc, LPRECT rect )
{
RECT visrect;
INT ret;
DC *dc = get_dc_ptr( hdc );
if (!dc) return ERROR;
update_dc( dc );
if (get_dc_region( dc ))
{
ret = GetRgnBox( get_dc_region( dc ), rect );
}
else
{
ret = is_rect_empty( &dc->vis_rect ) ? ERROR : SIMPLEREGION;
*rect = dc->vis_rect;
}
if (get_dc_device_rect( dc, &visrect ) && !intersect_rect( rect, rect, &visrect )) ret = NULLREGION;
if (dc->layout & LAYOUT_RTL)
{
int tmp = rect->left;
rect->left = rect->right - 1;
rect->right = tmp - 1;
}
DPtoLP( hdc, (LPPOINT)rect, 2 );
release_dc_ptr( dc );
TRACE("%p => %d %s\n", hdc, ret, wine_dbgstr_rect( rect ));
return ret;
}
/***********************************************************************
* wglMakeCurrent (OPENGL32.@)
*/
BOOL WINAPI wglMakeCurrent(HDC hdc, HGLRC hglrc)
{
BOOL ret = FALSE;
DC * dc = NULL;
/* When the context hglrc is NULL, the HDC is ignored and can be NULL.
* In that case use the global hDC to get access to the driver. */
if(hglrc == NULL)
{
if( hdc == NULL && !wglGetCurrentContext() )
{
WARN( "Current context is NULL\n");
SetLastError( ERROR_INVALID_HANDLE );
return FALSE;
}
dc = OPENGL_GetDefaultDC();
}
else
dc = get_dc_ptr( hdc );
TRACE("hdc: (%p), hglrc: (%p)\n", hdc, hglrc);
if (dc)
{
PHYSDEV physdev = GET_DC_PHYSDEV( dc, pwglMakeCurrent );
update_dc( dc );
ret = physdev->funcs->pwglMakeCurrent( physdev, hglrc );
release_dc_ptr( dc );
}
return ret;
}
/***********************************************************************
* AngleArc (GDI32.@)
*/
BOOL WINAPI AngleArc(HDC hdc, INT x, INT y, DWORD dwRadius, FLOAT eStartAngle, FLOAT eSweepAngle)
{
PHYSDEV physdev;
BOOL result;
DC *dc;
TRACE( "%p, (%d, %d), %u, %f, %f\n", hdc, x, y, dwRadius, eStartAngle, eSweepAngle );
if( (signed int)dwRadius < 0 )
return FALSE;
dc = get_dc_ptr( hdc );
if(!dc) return FALSE;
update_dc( dc );
physdev = GET_DC_PHYSDEV( dc, pAngleArc );
result = physdev->funcs->pAngleArc( physdev, x, y, dwRadius, eStartAngle, eSweepAngle );
if (result)
{
dc->cur_pos.x = GDI_ROUND( x + cos( (eStartAngle + eSweepAngle) * M_PI / 180 ) * dwRadius );
dc->cur_pos.y = GDI_ROUND( y - sin( (eStartAngle + eSweepAngle) * M_PI / 180 ) * dwRadius );
}
release_dc_ptr( dc );
return result;
}
/***********************************************************************
* IntersectVisRect (GDI.98)
*/
INT16 WINAPI IntersectVisRect16( HDC16 hdc16, INT16 left, INT16 top, INT16 right, INT16 bottom )
{
HRGN tempRgn;
INT16 ret;
POINT pt[2];
HDC hdc = HDC_32( hdc16 );
DC * dc = get_dc_ptr( hdc );
if (!dc) return ERROR;
pt[0].x = left;
pt[0].y = top;
pt[1].x = right;
pt[1].y = bottom;
LPtoDP( hdc, pt, 2 );
TRACE("%p %d,%d - %d,%d\n", hdc, pt[0].x, pt[0].y, pt[1].x, pt[1].y);
if (!(tempRgn = CreateRectRgn( pt[0].x, pt[0].y, pt[1].x, pt[1].y ))) ret = ERROR;
else
{
update_dc( dc );
ret = CombineRgn( dc->hVisRgn, dc->hVisRgn, tempRgn, RGN_AND );
DeleteObject( tempRgn );
}
if (ret != ERROR) CLIPPING_UpdateGCRegion( dc );
release_dc_ptr( dc );
return ret;
}
/******************************************************************************
* GdiGradientFill (GDI32.@)
*/
BOOL WINAPI GdiGradientFill( HDC hdc, TRIVERTEX *vert_array, ULONG nvert,
void *grad_array, ULONG ngrad, ULONG mode )
{
DC *dc;
PHYSDEV physdev;
BOOL ret;
ULONG i;
TRACE("%p vert_array:%p nvert:%d grad_array:%p ngrad:%d\n", hdc, vert_array, nvert, grad_array, ngrad);
if (!vert_array || !nvert || !grad_array || !ngrad || mode > GRADIENT_FILL_TRIANGLE)
{
SetLastError( ERROR_INVALID_PARAMETER );
return FALSE;
}
for (i = 0; i < ngrad * (mode == GRADIENT_FILL_TRIANGLE ? 3 : 2); i++)
if (((ULONG *)grad_array)[i] >= nvert) return FALSE;
if (!(dc = get_dc_ptr( hdc )))
{
SetLastError( ERROR_INVALID_PARAMETER );
return FALSE;
}
update_dc( dc );
physdev = GET_DC_PHYSDEV( dc, pGradientFill );
ret = physdev->funcs->pGradientFill( physdev, vert_array, nvert, grad_array, ngrad, mode );
release_dc_ptr( dc );
return ret;
}
/* CRM_OP_JOIN_OFFERメッセージをcrm_peer_cacheキャッシュに認識されているクラスターメンバーのcrmdプロセスに送信する */
void
do_dc_join_offer_all(long long action,
enum crmd_fsa_cause cause,
enum crmd_fsa_state cur_state,
enum crmd_fsa_input current_input,
fsa_data_t *msg_data)
{
/* reset everyones status back to down or in_ccm in the CIB
*
* any nodes that are active in the CIB but not in the CCM list
* will be seen as offline by the PE anyway
*/
current_join_id++;
initialize_join(TRUE);
/* do_update_cib_nodes(TRUE, __FUNCTION__); */
/* 現在のDCをクリア */
update_dc(NULL);
if(cause == C_HA_MESSAGE && current_input == I_NODE_JOIN) {
crm_info("A new node joined the cluster");
}
/* rm_peer_cacheキャッシュに認識されているクラスターメンバーのcrmdプロセス */
/* にCRM_OP_JOIN_OFFERメッセージを送信する */
g_hash_table_foreach(crm_peer_cache, join_make_offer, NULL);
/* dont waste time by invoking the PE yet; */
/* CRM_OP_JOIN_OFFERメッセージを送信後、welcomed_nodesハッシュテーブルのメンバー数をログで出力 */
crm_info("join-%d: Waiting on %d outstanding join acks",
current_join_id, g_hash_table_size(welcomed_nodes));
}
/* this is kind of a workaround for the fact that we may not be around or
* are otherwise unable to reply when the DC sends out A_DC_JOIN_OFFER_ALL
*/
void
do_cl_join_announce(long long action,
enum crmd_fsa_cause cause,
enum crmd_fsa_state cur_state,
enum crmd_fsa_input current_input, fsa_data_t * msg_data)
{
/* Once we hear from the DC, we can stop the timer
*
* This timer was started either on startup or when a node
* left the CCM list
*/
/* don't announce if we're in one of these states */
if (cur_state != S_PENDING) {
crm_warn("Not announcing cluster join because in state %s",
fsa_state2string(cur_state));
return;
}
if (AM_I_OPERATIONAL) {
/* send as a broadcast */
xmlNode *req = create_request(CRM_OP_JOIN_ANNOUNCE, NULL, NULL,
CRM_SYSTEM_DC, CRM_SYSTEM_CRMD, NULL);
crm_debug("Announcing availability");
update_dc(NULL);
send_cluster_message(NULL, crm_msg_crmd, req, FALSE);
free_xml(req);
} else {
/* Delay announce until we have finished local startup */
crm_warn("Delaying announce of cluster join until local startup is complete");
return;
}
}
/* A_DC_JOIN_OFFER_ALL */
void
do_dc_join_offer_all(long long action,
enum crmd_fsa_cause cause,
enum crmd_fsa_state cur_state,
enum crmd_fsa_input current_input, fsa_data_t * msg_data)
{
/* reset everyone's status back to down or in_ccm in the CIB
*
* any nodes that are active in the CIB but not in the CCM list
* will be seen as offline by the PE anyway
*/
current_join_id++;
initialize_join(TRUE);
/* do_update_cib_nodes(TRUE, __FUNCTION__); */
update_dc(NULL);
if (cause == C_HA_MESSAGE && current_input == I_NODE_JOIN) {
crm_info("A new node joined the cluster");
}
g_hash_table_foreach(crm_peer_cache, join_make_offer, NULL);
/* don't waste time by invoking the PE yet; */
crm_info("join-%d: Waiting on %d outstanding join acks",
current_join_id, crmd_join_phase_count(crm_join_welcomed));
}
/***********************************************************************
* ArcTo (GDI32.@)
*/
BOOL WINAPI ArcTo( HDC hdc,
INT left, INT top,
INT right, INT bottom,
INT xstart, INT ystart,
INT xend, INT yend )
{
double width = abs( right - left ),
height = abs( bottom - top ),
xradius = width/2,
yradius = height/2,
xcenter = right > left ? left+xradius : right+xradius,
ycenter = bottom > top ? top+yradius : bottom+yradius,
angle;
PHYSDEV physdev;
BOOL result;
DC * dc = get_dc_ptr( hdc );
TRACE( "%p, (%d, %d)-(%d, %d), (%d, %d), (%d, %d)\n", hdc, left, top, right, bottom, xstart, ystart, xend, yend );
if(!dc) return FALSE;
update_dc( dc );
physdev = GET_DC_PHYSDEV( dc, pArcTo );
result = physdev->funcs->pArcTo( physdev, left, top, right, bottom, xstart, ystart, xend, yend );
if (result)
{
angle = atan2(((yend-ycenter)/height),
((xend-xcenter)/width));
dc->cur_pos.x = GDI_ROUND( xcenter + (cos( angle ) * xradius) );
dc->cur_pos.y = GDI_ROUND( ycenter + (sin( angle ) * yradius) );
}
release_dc_ptr( dc );
return result;
}
/***********************************************************************
* SetPixelV (GDI32.@)
*/
BOOL WINAPI SetPixelV( HDC hdc, INT x, INT y, COLORREF color )
{
PHYSDEV physdev;
DC * dc = get_dc_ptr( hdc );
if (!dc) return FALSE;
update_dc( dc );
physdev = GET_DC_PHYSDEV( dc, pSetPixel );
physdev->funcs->pSetPixel( physdev, x, y, color );
release_dc_ptr( dc );
return TRUE;
}
/***********************************************************************
* SetPixel (GDI32.@)
*/
COLORREF WINAPI SetPixel( HDC hdc, INT x, INT y, COLORREF color )
{
PHYSDEV physdev;
COLORREF ret;
DC * dc = get_dc_ptr( hdc );
if (!dc) return 0;
update_dc( dc );
physdev = GET_DC_PHYSDEV( dc, pSetPixel );
ret = physdev->funcs->pSetPixel( physdev, x, y, color );
release_dc_ptr( dc );
return ret;
}
/***********************************************************************
* GetPixel (GDI32.@)
*/
COLORREF WINAPI GetPixel( HDC hdc, INT x, INT y )
{
PHYSDEV physdev;
COLORREF ret;
DC * dc = get_dc_ptr( hdc );
if (!dc) return CLR_INVALID;
update_dc( dc );
physdev = GET_DC_PHYSDEV( dc, pGetPixel );
ret = physdev->funcs->pGetPixel( physdev, x, y );
release_dc_ptr( dc );
return ret;
}
/***********************************************************************
* FillRgn (GDI32.@)
*/
BOOL WINAPI FillRgn( HDC hdc, HRGN hrgn, HBRUSH hbrush )
{
PHYSDEV physdev;
BOOL retval;
DC * dc = get_dc_ptr( hdc );
if (!dc) return FALSE;
update_dc( dc );
physdev = GET_DC_PHYSDEV( dc, pFillRgn );
retval = physdev->funcs->pFillRgn( physdev, hrgn, hbrush );
release_dc_ptr( dc );
return retval;
}
/**********************************************************************
* Polygon (GDI32.@)
*/
BOOL WINAPI Polygon( HDC hdc, const POINT* pt, INT count )
{
PHYSDEV physdev;
BOOL ret;
DC * dc = get_dc_ptr( hdc );
if (!dc) return FALSE;
update_dc( dc );
physdev = GET_DC_PHYSDEV( dc, pPolygon );
ret = physdev->funcs->pPolygon( physdev, pt, count );
release_dc_ptr( dc );
return ret;
}
/***********************************************************************
* InvertRgn (GDI32.@)
*/
BOOL WINAPI InvertRgn( HDC hdc, HRGN hrgn )
{
PHYSDEV physdev;
BOOL ret;
DC *dc = get_dc_ptr( hdc );
if (!dc) return FALSE;
update_dc( dc );
physdev = GET_DC_PHYSDEV( dc, pInvertRgn );
ret = physdev->funcs->pInvertRgn( physdev, hrgn );
release_dc_ptr( dc );
return ret;
}
/**********************************************************************
* Polyline (GDI32.@)
*/
BOOL WINAPI Polyline( HDC hdc, const POINT* pt, INT count )
{
BOOL ret = FALSE;
DC * dc = get_dc_ptr( hdc );
if (dc)
{
PHYSDEV physdev = GET_DC_PHYSDEV( dc, pPolyline );
update_dc( dc );
ret = physdev->funcs->pPolyline( physdev, pt, count );
release_dc_ptr( dc );
}
return ret;
}
/***********************************************************************
* PaintRgn (GDI32.@)
*/
BOOL WINAPI PaintRgn( HDC hdc, HRGN hrgn )
{
BOOL ret = FALSE;
DC * dc = get_dc_ptr( hdc );
if (dc)
{
PHYSDEV physdev = GET_DC_PHYSDEV( dc, pPaintRgn );
update_dc( dc );
ret = physdev->funcs->pPaintRgn( physdev, hrgn );
release_dc_ptr( dc );
}
return ret;
}
/**********************************************************************
* ExtFloodFill (GDI32.@)
*/
BOOL WINAPI ExtFloodFill( HDC hdc, INT x, INT y, COLORREF color,
UINT fillType )
{
PHYSDEV physdev;
BOOL ret;
DC * dc = get_dc_ptr( hdc );
if (!dc) return FALSE;
update_dc( dc );
physdev = GET_DC_PHYSDEV( dc, pExtFloodFill );
ret = physdev->funcs->pExtFloodFill( physdev, x, y, color, fillType );
release_dc_ptr( dc );
return ret;
}
/**********************************************************************
* PolyPolyline (GDI32.@)
*/
BOOL WINAPI PolyPolyline( HDC hdc, const POINT* pt, const DWORD* counts,
DWORD polylines )
{
PHYSDEV physdev;
BOOL ret;
DC * dc = get_dc_ptr( hdc );
if (!dc) return FALSE;
update_dc( dc );
physdev = GET_DC_PHYSDEV( dc, pPolyPolyline );
ret = physdev->funcs->pPolyPolyline( physdev, pt, counts, polylines );
release_dc_ptr( dc );
return ret;
}
/***********************************************************************
* FrameRgn (GDI32.@)
*/
BOOL WINAPI FrameRgn( HDC hdc, HRGN hrgn, HBRUSH hbrush,
INT nWidth, INT nHeight )
{
PHYSDEV physdev;
BOOL ret;
DC *dc = get_dc_ptr( hdc );
if (!dc) return FALSE;
update_dc( dc );
physdev = GET_DC_PHYSDEV( dc, pFrameRgn );
ret = physdev->funcs->pFrameRgn( physdev, hrgn, hbrush, nWidth, nHeight );
release_dc_ptr( dc );
return ret;
}
void hp98035_io_card::half_init(void)
{
m_inten = false;
m_intflag = false;
m_irq = false;
update_irq();
m_np_irq = false;
update_dc();
m_clock_1s_div = 0;
m_clock_state = CLOCK_OFF;
m_clock_mux = 0;
regen_clock_image();
}
/***********************************************************************
* Ellipse (GDI32.@)
*/
BOOL WINAPI Ellipse( HDC hdc, INT left, INT top,
INT right, INT bottom )
{
BOOL ret;
PHYSDEV physdev;
DC * dc = get_dc_ptr( hdc );
if (!dc) return FALSE;
update_dc( dc );
physdev = GET_DC_PHYSDEV( dc, pEllipse );
ret = physdev->funcs->pEllipse( physdev, left, top, right, bottom );
release_dc_ptr( dc );
return ret;
}
/***********************************************************************
* OffsetVisRgn (GDI.102)
*/
INT16 WINAPI OffsetVisRgn16( HDC16 hdc16, INT16 x, INT16 y )
{
INT16 retval;
HDC hdc = HDC_32( hdc16 );
DC * dc = get_dc_ptr( hdc );
if (!dc) return ERROR;
TRACE("%p %d,%d\n", hdc, x, y );
update_dc( dc );
retval = OffsetRgn( dc->hVisRgn, x, y );
CLIPPING_UpdateGCRegion( dc );
release_dc_ptr( dc );
return retval;
}
/***********************************************************************
* RoundRect (GDI32.@)
*/
BOOL WINAPI RoundRect( HDC hdc, INT left, INT top, INT right,
INT bottom, INT ell_width, INT ell_height )
{
PHYSDEV physdev;
BOOL ret;
DC *dc = get_dc_ptr( hdc );
if (!dc) return FALSE;
update_dc( dc );
physdev = GET_DC_PHYSDEV( dc, pRoundRect );
ret = physdev->funcs->pRoundRect( physdev, left, top, right, bottom, ell_width, ell_height );
release_dc_ptr( dc );
return ret;
}
/***********************************************************************
* PaintRgn (GDI32.@)
*/
BOOL WINAPI PaintRgn( HDC hdc, HRGN hrgn )
{
PHYSDEV physdev;
BOOL ret;
DC * dc = get_dc_ptr( hdc );
TRACE( "%p, %p\n", hdc, hrgn );
if (!dc) return FALSE;
update_dc( dc );
physdev = GET_DC_PHYSDEV( dc, pPaintRgn );
ret = physdev->funcs->pPaintRgn( physdev, hrgn );
release_dc_ptr( dc );
return ret;
}
/***********************************************************************
* PolyDraw (GDI32.@)
*/
BOOL WINAPI PolyDraw(HDC hdc, const POINT *lppt, const BYTE *lpbTypes,
DWORD cCount)
{
DC *dc = get_dc_ptr( hdc );
PHYSDEV physdev;
BOOL result;
if(!dc) return FALSE;
update_dc( dc );
physdev = GET_DC_PHYSDEV( dc, pPolyDraw );
result = physdev->funcs->pPolyDraw( physdev, lppt, lpbTypes, cCount );
release_dc_ptr( dc );
return result;
}
