/***********************************************************************
* ScaleWindowExtEx (GDI32.@)
*/
BOOL WINAPI ScaleWindowExtEx( HDC hdc, INT xNum, INT xDenom,
INT yNum, INT yDenom, LPSIZE size )
{
BOOL ret = TRUE;
DC * dc = DC_GetDCPtr( hdc );
if (!dc) return FALSE;
if (dc->funcs->pScaleWindowExt)
{
ret = dc->funcs->pScaleWindowExt( dc, xNum, xDenom, yNum, yDenom );
goto done;
}
if (size)
{
size->cx = dc->wndExtX;
size->cy = dc->wndExtY;
}
if ((dc->MapMode != MM_ISOTROPIC) && (dc->MapMode != MM_ANISOTROPIC))
goto done;
if (!xNum || !xDenom || !xNum || !yDenom)
{
ret = FALSE;
goto done;
}
dc->wndExtX = (dc->wndExtX * xNum) / xDenom;
dc->wndExtY = (dc->wndExtY * yNum) / yDenom;
if (dc->wndExtX == 0) dc->wndExtX = 1;
if (dc->wndExtY == 0) dc->wndExtY = 1;
if (dc->MapMode == MM_ISOTROPIC) MAPPING_FixIsotropic( dc );
DC_UpdateXforms( dc );
done:
GDI_ReleaseObj( hdc );
return ret;
}
/***********************************************************************
* SetMetaRgn (GDI32.@)
*/
INT WINAPI SetMetaRgn( HDC hdc )
{
INT ret;
RECT dummy;
DC *dc = DC_GetDCPtr( hdc );
if (!dc) return ERROR;
if (dc->hMetaClipRgn)
{
/* the intersection becomes the new meta region */
DeleteObject( dc->hMetaRgn );
DeleteObject( dc->hClipRgn );
dc->hMetaRgn = dc->hMetaClipRgn;
dc->hClipRgn = 0;
dc->hMetaClipRgn = 0;
}
else if (dc->hClipRgn)
{
dc->hMetaRgn = dc->hClipRgn;
dc->hClipRgn = 0;
}
/* else nothing to do */
/* Note: no need to call CLIPPING_UpdateGCRegion, the overall clip region hasn't changed */
ret = GetRgnBox( dc->hMetaRgn, &dummy );
GDI_ReleaseObj( hdc );
return ret;
}
/***********************************************************************
* GetCurrentObject (GDI32.@)
*/
HANDLE WINAPI GetCurrentObject(HDC hdc,UINT type)
{
HANDLE ret = 0;
DC * dc = DC_GetDCPtr( hdc );
if (dc)
{
switch (type) {
case OBJ_PEN:
ret = dc->hPen;
break;
case OBJ_BRUSH:
ret = dc->hBrush;
break;
case OBJ_PAL:
ret = dc->hPalette;
break;
case OBJ_FONT:
ret = dc->hFont;
break;
case OBJ_BITMAP:
ret = dc->hBitmap;
break;
default:
/* the SDK only mentions those above */
FIXME("(%08x,%d): unknown type.\n",hdc,type);
break;
}
GDI_ReleaseObj( hdc );
}
return ret;
}
/*****************************************************************************
* @ [GDI32.104]
*
* This should load the correct driver for lpszDevice and calls this driver's
* DeviceCapabilities proc.
*
* FIXME: convert DeviceCapabilities to unicode in the driver interface
*/
DWORD WINAPI GDI_CallDeviceCapabilities16( LPCSTR lpszDevice, LPCSTR lpszPort,
WORD fwCapability, LPSTR lpszOutput,
LPDEVMODEA lpdm )
{
WCHAR deviceW[300];
WCHAR bufW[300];
char buf[300];
HDC hdc;
DC *dc;
INT ret = -1;
TRACE("(%s, %s, %d, %p, %p)\n", lpszDevice, lpszPort, fwCapability, lpszOutput, lpdm );
if (!lpszDevice) return -1;
if (!MultiByteToWideChar(CP_ACP, 0, lpszDevice, -1, deviceW, 300)) return -1;
if(!DRIVER_GetDriverName( deviceW, bufW, 300 )) return -1;
if (!WideCharToMultiByte(CP_ACP, 0, bufW, -1, buf, 300, NULL, NULL)) return -1;
if (!(hdc = CreateICA( buf, lpszDevice, lpszPort, NULL ))) return -1;
if ((dc = DC_GetDCPtr( hdc )))
{
if (dc->funcs->pDeviceCapabilities)
ret = dc->funcs->pDeviceCapabilities( buf, lpszDevice, lpszPort,
fwCapability, lpszOutput, lpdm );
GDI_ReleaseObj( hdc );
}
DeleteDC( hdc );
return ret;
}
/***********************************************************************
* SetWindowExtEx (GDI32.@)
*/
BOOL WINAPI SetWindowExtEx( HDC hdc, INT x, INT y, LPSIZE size )
{
BOOL ret = TRUE;
DC * dc = DC_GetDCPtr( hdc );
if (!dc) return FALSE;
if (dc->funcs->pSetWindowExt)
{
ret = dc->funcs->pSetWindowExt( dc, x, y );
goto done;
}
if (size)
{
size->cx = dc->wndExtX;
size->cy = dc->wndExtY;
}
if ((dc->MapMode != MM_ISOTROPIC) && (dc->MapMode != MM_ANISOTROPIC))
goto done;
if (!x || !y)
{
ret = FALSE;
goto done;
}
dc->wndExtX = x;
dc->wndExtY = y;
if (dc->MapMode == MM_ISOTROPIC) MAPPING_FixIsotropic( dc );
DC_UpdateXforms( dc );
done:
GDI_ReleaseObj( hdc );
return ret;
}
/**********************************************************************
* SetAbortProc (GDI.381)
*/
INT16 WINAPI SetAbortProc16(HDC16 hdc, ABORTPROC16 abrtprc)
{
DC *dc = DC_GetDCPtr( hdc );
if (!dc) return FALSE;
dc->pAbortProc16 = abrtprc;
GDI_ReleaseObj( hdc );
return SetAbortProc( hdc, call_abort_proc16 );
}
/**********************************************************************
* SetAbortProc (GDI32.@)
*
*/
INT WINAPI SetAbortProc(HDC hdc, ABORTPROC abrtprc)
{
DC *dc = DC_GetDCPtr( hdc );
if (!dc) return FALSE;
dc->pAbortProc = abrtprc;
GDI_ReleaseObj( hdc );
return TRUE;
}
/******************************************************************************
* AbortDoc [GDI32.@]
*/
INT WINAPI AbortDoc(HDC hdc)
{
INT ret = 0;
DC *dc = DC_GetDCPtr( hdc );
if(!dc) return SP_ERROR;
if (dc->funcs->pAbortDoc) ret = dc->funcs->pAbortDoc( dc );
GDI_ReleaseObj( hdc );
return ret;
}
/**********************************************************************
* call_abort_proc16
*/
static BOOL CALLBACK call_abort_proc16( HDC hdc, INT code )
{
ABORTPROC16 proc16;
DC *dc = DC_GetDCPtr( hdc );
if (!dc) return FALSE;
proc16 = dc->pAbortProc16;
GDI_ReleaseObj( hdc );
if (proc16) return PRTDRV_CallTo16_word_ww( (FARPROC16)proc16, hdc, code );
return TRUE;
}
/***********************************************************************
* GetMetaRgn (GDI32.@)
*/
INT WINAPI GetMetaRgn( HDC hdc, HRGN hRgn )
{
INT ret = 0;
DC * dc = DC_GetDCPtr( hdc );
if (dc)
{
if (dc->hMetaRgn && CombineRgn( hRgn, dc->hMetaRgn, 0, RGN_COPY ) != ERROR)
ret = 1;
GDI_ReleaseObj( hdc );
}
return ret;
}
/******************************************************************
* StartPage [GDI32.@]
*
*/
INT WINAPI StartPage(HDC hdc)
{
INT ret = 1;
DC *dc = DC_GetDCPtr( hdc );
if(!dc) return SP_ERROR;
if(dc->funcs->pStartPage)
ret = dc->funcs->pStartPage( dc );
else
FIXME("stub\n");
GDI_ReleaseObj( hdc );
return ret;
}
/******************************************************************************
* ExtEscape [GDI32.@]
*
* Access capabilities of a particular device that are not available through GDI.
*
* PARAMS
* hdc [I] Handle to device context
* nEscape [I] Escape function
* cbInput [I] Number of bytes in input structure
* lpszInData [I] Pointer to input structure
* cbOutput [I] Number of bytes in output structure
* lpszOutData [O] Pointer to output structure
*
* RETURNS
* Success: >0
* Not implemented: 0
* Failure: <0
*/
INT WINAPI ExtEscape( HDC hdc, INT nEscape, INT cbInput, LPCSTR lpszInData,
INT cbOutput, LPSTR lpszOutData )
{
INT ret = 0;
DC * dc = DC_GetDCPtr( hdc );
if (dc)
{
if (dc->funcs->pExtEscape)
ret = dc->funcs->pExtEscape( dc->physDev, nEscape, cbInput, lpszInData, cbOutput, lpszOutData );
GDI_ReleaseObj( hdc );
}
return ret;
}
/******************************************************************
* StartDocA [GDI32.@]
*
* StartDoc calls the STARTDOC Escape with the input data pointing to DocName
* and the output data (which is used as a second input parameter).pointing at
* the whole docinfo structure. This seems to be an undocumented feature of
* the STARTDOC Escape.
*
* Note: we now do it the other way, with the STARTDOC Escape calling StartDoc.
*/
INT WINAPI StartDocA(HDC hdc, const DOCINFOA* doc)
{
INT ret = 0;
DC *dc = DC_GetDCPtr( hdc );
TRACE("DocName = '%s' Output = '%s' Datatype = '%s'\n",
doc->lpszDocName, doc->lpszOutput, doc->lpszDatatype);
if(!dc) return SP_ERROR;
if (dc->funcs->pStartDoc) ret = dc->funcs->pStartDoc( dc, doc );
GDI_ReleaseObj( hdc );
return ret;
}
/***********************************************************************
* GetClipRgn (GDI32.@)
*/
INT WINAPI GetClipRgn( HDC hdc, HRGN hRgn )
{
INT ret = -1;
DC * dc;
if (hRgn && (dc = DC_GetDCPtr( hdc )))
{
if( dc->hClipRgn )
{
if( CombineRgn(hRgn, dc->hClipRgn, 0, RGN_COPY) != ERROR ) ret = 1;
}
else ret = 0;
GDI_ReleaseObj( hdc );
}
return ret;
}
/******************************************************************
* EndPage [GDI32.@]
*
*/
INT WINAPI EndPage(HDC hdc)
{
INT ret = 0;
DC *dc = DC_GetDCPtr( hdc );
if(!dc) return SP_ERROR;
if (dc->funcs->pEndPage) ret = dc->funcs->pEndPage( dc );
GDI_ReleaseObj( hdc );
if (!QueryAbort16( hdc, 0 ))
{
EndDoc( hdc );
ret = 0;
}
return ret;
}
/***********************************************************************
* SelectVisRgn (GDI.105)
*/
INT16 WINAPI SelectVisRgn16( HDC16 hdc16, HRGN16 hrgn )
{
int retval;
HDC hdc = HDC_32( hdc16 );
DC * dc;
if (!hrgn) return ERROR;
if (!(dc = DC_GetDCPtr( hdc ))) return ERROR;
TRACE("%p %04x\n", hdc, hrgn );
dc->flags &= ~DC_DIRTY;
retval = CombineRgn( dc->hVisRgn, HRGN_32(hrgn), 0, RGN_COPY );
CLIPPING_UpdateGCRegion( dc );
GDI_ReleaseObj( hdc );
return retval;
}
/**********************************************************************
* QueryAbort (GDI.155)
*
* Calls the app's AbortProc function if avail.
*
* RETURNS
* TRUE if no AbortProc avail or AbortProc wants to continue printing.
* FALSE if AbortProc wants to abort printing.
*/
BOOL16 WINAPI QueryAbort16(HDC16 hdc, INT16 reserved)
{
BOOL ret = TRUE;
DC *dc = DC_GetDCPtr( hdc );
ABORTPROC abproc;
if(!dc) {
ERR("Invalid hdc %04x\n", hdc);
return FALSE;
}
abproc = dc->pAbortProc;
GDI_ReleaseObj( hdc );
if (abproc)
ret = abproc(hdc, 0);
return ret;
}
/***********************************************************************
* SetWindowOrgEx (GDI32.@)
*/
BOOL WINAPI SetWindowOrgEx( HDC hdc, INT x, INT y, LPPOINT pt )
{
BOOL ret = TRUE;
DC * dc = DC_GetDCPtr( hdc );
if (!dc) return FALSE;
if (dc->funcs->pSetWindowOrg) ret = dc->funcs->pSetWindowOrg( dc, x, y );
else
{
if (pt)
{
pt->x = dc->wndOrgX;
pt->y = dc->wndOrgY;
}
dc->wndOrgX = x;
dc->wndOrgY = y;
DC_UpdateXforms( dc );
}
GDI_ReleaseObj( hdc );
return ret;
}
/***********************************************************************
* OffsetViewportOrgEx (GDI32.@)
*/
BOOL WINAPI OffsetViewportOrgEx( HDC hdc, INT x, INT y, LPPOINT pt)
{
BOOL ret = TRUE;
DC * dc = DC_GetDCPtr( hdc );
if (!dc) return FALSE;
if (dc->funcs->pOffsetViewportOrg)
ret = dc->funcs->pOffsetViewportOrg( dc, x, y );
else
{
if (pt)
{
pt->x = dc->vportOrgX;
pt->y = dc->vportOrgY;
}
dc->vportOrgX += x;
dc->vportOrgY += y;
DC_UpdateXforms( dc );
}
GDI_ReleaseObj( hdc );
return ret;
}
/***********************************************************************
* GetRandomRgn [GDI32.@]
*
* NOTES
* This function is documented in MSDN online for the case of
* iCode == SYSRGN (4).
*
* For iCode == 1 it should return the clip region
* 2 " " " the meta region
* 3 " " " the intersection of the clip with
* the meta region (== 'Rao' region).
*
* See http://www.codeproject.com/gdi/cliprgnguide.asp
*/
INT WINAPI GetRandomRgn(HDC hDC, HRGN hRgn, INT iCode)
{
HRGN rgn;
DC *dc = DC_GetDCPtr( hDC );
if (!dc) return -1;
switch (iCode)
{
case 1:
rgn = dc->hClipRgn;
break;
case 2:
rgn = dc->hMetaRgn;
break;
case 3:
rgn = dc->hMetaClipRgn;
if(!rgn) rgn = dc->hClipRgn;
if(!rgn) rgn = dc->hMetaRgn;
break;
case SYSRGN: /* == 4 */
rgn = dc->hVisRgn;
break;
default:
WARN("Unknown code %d\n", iCode);
GDI_ReleaseObj( hDC );
return -1;
}
if (rgn) CombineRgn( hRgn, rgn, 0, RGN_COPY );
GDI_ReleaseObj( hDC );
/* On Windows NT/2000, the SYSRGN returned is in screen coordinates */
if (iCode == SYSRGN && !(GetVersion() & 0x80000000))
{
POINT org;
GetDCOrgEx( hDC, &org );
OffsetRgn( hRgn, org.x, org.y );
}
return (rgn != 0);
}
/***********************************************************************
* RestoreVisRgn (GDI.130)
*/
INT16 WINAPI RestoreVisRgn16( HDC16 hdc16 )
{
struct saved_visrgn *saved;
HDC hdc = HDC_32( hdc16 );
DC *dc = DC_GetDCPtr( hdc );
INT16 ret = ERROR;
if (!dc) return ERROR;
TRACE("%p\n", hdc );
if (!(saved = dc->saved_visrgn)) goto done;
ret = CombineRgn( dc->hVisRgn, saved->hrgn, 0, RGN_COPY );
dc->saved_visrgn = saved->next;
DeleteObject( saved->hrgn );
HeapFree( GetProcessHeap(), 0, saved );
dc->flags &= ~DC_DIRTY;
CLIPPING_UpdateGCRegion( dc );
done:
GDI_ReleaseObj( hdc );
return ret;
}
/*****************************************************************************
* @ [GDI32.102]
*
* This should load the correct driver for lpszDevice and calls this driver's
* ExtDeviceMode proc.
*
* FIXME: convert ExtDeviceMode to unicode in the driver interface
*/
INT WINAPI GDI_CallExtDeviceMode16( HWND hwnd,
LPDEVMODEA lpdmOutput, LPSTR lpszDevice,
LPSTR lpszPort, LPDEVMODEA lpdmInput,
LPSTR lpszProfile, DWORD fwMode )
{
WCHAR deviceW[300];
WCHAR bufW[300];
char buf[300];
HDC hdc;
DC *dc;
INT ret = -1;
INT (*pExtDeviceMode)(LPSTR,HWND,LPDEVMODEA,LPSTR,LPSTR,LPDEVMODEA,LPSTR,DWORD);
TRACE("(%p, %p, %s, %s, %p, %s, %ld)\n",
hwnd, lpdmOutput, lpszDevice, lpszPort, lpdmInput, lpszProfile, fwMode );
if (!lpszDevice) return -1;
if (!MultiByteToWideChar(CP_ACP, 0, lpszDevice, -1, deviceW, 300)) return -1;
if(!DRIVER_GetDriverName( deviceW, bufW, 300 )) return -1;
if (!WideCharToMultiByte(CP_ACP, 0, bufW, -1, buf, 300, NULL, NULL)) return -1;
if (!(hdc = CreateICA( buf, lpszDevice, lpszPort, NULL ))) return -1;
if ((dc = DC_GetDCPtr( hdc )))
{
pExtDeviceMode = dc->funcs->pExtDeviceMode;
GDI_ReleaseObj( hdc );
if (pExtDeviceMode)
ret = pExtDeviceMode(buf, hwnd, lpdmOutput, lpszDevice, lpszPort,
lpdmInput, lpszProfile, fwMode);
}
DeleteDC( hdc );
return ret;
}
/***********************************************************************
* SetMapMode (GDI32.@)
*/
INT WINAPI SetMapMode( HDC hdc, INT mode )
{
INT prevMode;
INT horzSize, vertSize, horzRes, vertRes;
DC * dc = DC_GetDCPtr( hdc );
if (!dc) return 0;
if (dc->funcs->pSetMapMode)
{
prevMode = dc->funcs->pSetMapMode( dc, mode );
goto done;
}
TRACE("%04x %d\n", hdc, mode );
prevMode = dc->MapMode;
horzSize = GetDeviceCaps( hdc, HORZSIZE );
vertSize = GetDeviceCaps( hdc, VERTSIZE );
horzRes = GetDeviceCaps( hdc, HORZRES );
vertRes = GetDeviceCaps( hdc, VERTRES );
switch(mode)
{
case MM_TEXT:
dc->wndExtX = 1;
dc->wndExtY = 1;
dc->vportExtX = 1;
dc->vportExtY = 1;
break;
case MM_LOMETRIC:
case MM_ISOTROPIC:
dc->wndExtX = horzSize;
dc->wndExtY = vertSize;
dc->vportExtX = horzRes / 10;
dc->vportExtY = vertRes / -10;
break;
case MM_HIMETRIC:
dc->wndExtX = horzSize * 10;
dc->wndExtY = vertSize * 10;
dc->vportExtX = horzRes / 10;
dc->vportExtY = vertRes / -10;
break;
case MM_LOENGLISH:
dc->wndExtX = horzSize;
dc->wndExtY = vertSize;
dc->vportExtX = 254L * horzRes / 1000;
dc->vportExtY = -254L * vertRes / 1000;
break;
case MM_HIENGLISH:
dc->wndExtX = horzSize * 10;
dc->wndExtY = vertSize * 10;
dc->vportExtX = 254L * horzRes / 1000;
dc->vportExtY = -254L * vertRes / 1000;
break;
case MM_TWIPS:
dc->wndExtX = 144L * horzSize / 10;
dc->wndExtY = 144L * vertSize / 10;
dc->vportExtX = 254L * horzRes / 1000;
dc->vportExtY = -254L * vertRes / 1000;
break;
case MM_ANISOTROPIC:
break;
default:
goto done;
}
dc->MapMode = mode;
DC_UpdateXforms( dc );
done:
GDI_ReleaseObj( hdc );
return prevMode;
}
