ReceiveTempSMS
/
Sweden-Number
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Rewrote Escape to avoid calling down to Escape16. 

Replaced Escape by ExtEscape in the DC function table.
This commit is contained in:
Alexandre Julliard 2001-07-29 20:25:14 +00:00
parent b71902952d
commit 9208301d16
16 changed files with 473 additions and 507 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
dlls/gdi/driver.c
View File

@ -69,9 +69,9 @@ static struct graphics_driver *create_driver( HMODULE module )
GET_FUNC(EndPage); GET_FUNC(EndPage);
GET_FUNC(EndPath); GET_FUNC(EndPath);
GET_FUNC(EnumDeviceFonts); GET_FUNC(EnumDeviceFonts);
GET_FUNC(Escape);
GET_FUNC(ExcludeClipRect); GET_FUNC(ExcludeClipRect);
GET_FUNC(ExtDeviceMode); GET_FUNC(ExtDeviceMode);
GET_FUNC(ExtEscape);
GET_FUNC(ExtFloodFill); GET_FUNC(ExtFloodFill);
GET_FUNC(ExtTextOut); GET_FUNC(ExtTextOut);
GET_FUNC(FillPath); GET_FUNC(FillPath);

2
dlls/gdi/gdi.spec
View File

@ -47,7 +47,7 @@ rsrc version16.res
s_word s_word long) StretchBlt16 s_word s_word long) StretchBlt16
36 pascal16 Polygon (word ptr word) Polygon16 36 pascal16 Polygon (word ptr word) Polygon16
37 pascal16 Polyline (word ptr word) Polyline16 37 pascal16 Polyline (word ptr word) Polyline16
38 pascal Escape(word word word segptr segptr) Escape16 38 pascal Escape(word word word segptr ptr) Escape16
39 pascal16 RestoreDC(word s_word) RestoreDC16 39 pascal16 RestoreDC(word s_word) RestoreDC16
40 pascal16 FillRgn(word word word) FillRgn16 40 pascal16 FillRgn(word word word) FillRgn16
41 pascal16 FrameRgn(word word word word word) FrameRgn16 41 pascal16 FrameRgn(word word word word word) FrameRgn16

31
dlls/gdi/printdrv.c
View File

@ -67,10 +67,12 @@ INT16 WINAPI StartDoc16( HDC16 hdc, const DOCINFO16 *lpdoc )
* and the output data (which is used as a second input parameter).pointing at * 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 whole docinfo structure. This seems to be an undocumented feature of
* the STARTDOC Escape. * 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 WINAPI StartDocA(HDC hdc, const DOCINFOA* doc)
{ {
INT ret; INT ret = 0;
DC *dc = DC_GetDCPtr( hdc ); DC *dc = DC_GetDCPtr( hdc );
TRACE("DocName = '%s' Output = '%s' Datatype = '%s'\n", TRACE("DocName = '%s' Output = '%s' Datatype = '%s'\n",
@ -78,11 +80,7 @@ INT WINAPI StartDocA(HDC hdc, const DOCINFOA* doc)
if(!dc) return SP_ERROR; if(!dc) return SP_ERROR;
if(dc->funcs->pStartDoc) if (dc->funcs->pStartDoc) ret = dc->funcs->pStartDoc( dc, doc );
ret = dc->funcs->pStartDoc( dc, doc );
else
ret = Escape(hdc, STARTDOC, strlen(doc->lpszDocName),
doc->lpszDocName, (LPVOID)doc);
GDI_ReleaseObj( hdc ); GDI_ReleaseObj( hdc );
return ret; return ret;
} }
@ -132,14 +130,11 @@ INT16 WINAPI EndDoc16(HDC16 hdc)
*/ */
INT WINAPI EndDoc(HDC hdc) INT WINAPI EndDoc(HDC hdc)
{ {
INT ret; INT ret = 0;
DC *dc = DC_GetDCPtr( hdc ); DC *dc = DC_GetDCPtr( hdc );
if(!dc) return SP_ERROR; if(!dc) return SP_ERROR;
if(dc->funcs->pEndDoc) if (dc->funcs->pEndDoc) ret = dc->funcs->pEndDoc( dc );
ret = dc->funcs->pEndDoc( dc );
else
ret = Escape(hdc, ENDDOC, 0, 0, 0);
GDI_ReleaseObj( hdc ); GDI_ReleaseObj( hdc );
return ret; return ret;
} }
@ -186,14 +181,11 @@ INT16 WINAPI EndPage16( HDC16 hdc )
*/ */
INT WINAPI EndPage(HDC hdc) INT WINAPI EndPage(HDC hdc)
{ {
INT ret; INT ret = 0;
DC *dc = DC_GetDCPtr( hdc ); DC *dc = DC_GetDCPtr( hdc );
if(!dc) return SP_ERROR; if(!dc) return SP_ERROR;
if(dc->funcs->pEndPage) if (dc->funcs->pEndPage) ret = dc->funcs->pEndPage( dc );
ret = dc->funcs->pEndPage( dc );
else
ret = Escape(hdc, NEWFRAME, 0, 0, 0);
GDI_ReleaseObj( hdc ); GDI_ReleaseObj( hdc );
if (!QueryAbort16( hdc, 0 )) if (!QueryAbort16( hdc, 0 ))
{ {
@ -216,14 +208,11 @@ INT16 WINAPI AbortDoc16(HDC16 hdc)
*/ */
INT WINAPI AbortDoc(HDC hdc) INT WINAPI AbortDoc(HDC hdc)
{ {
INT ret; INT ret = 0;
DC *dc = DC_GetDCPtr( hdc ); DC *dc = DC_GetDCPtr( hdc );
if(!dc) return SP_ERROR; if(!dc) return SP_ERROR;
if(dc->funcs->pAbortDoc) if (dc->funcs->pAbortDoc) ret = dc->funcs->pAbortDoc( dc );
ret = dc->funcs->pAbortDoc( dc );
else
ret = Escape(hdc, ABORTDOC, 0, 0, 0);
GDI_ReleaseObj( hdc ); GDI_ReleaseObj( hdc );
return ret; return ret;
} }

263
dlls/wineps/escape.c
View File

@ -13,63 +13,27 @@
DEFAULT_DEBUG_CHANNEL(psdrv); DEFAULT_DEBUG_CHANNEL(psdrv);
INT PSDRV_Escape( DC *dc, INT nEscape, INT cbInput, /**********************************************************************
SEGPTR lpInData, SEGPTR lpOutData ) * ExtEscape (PSDRV.@)
*/
INT PSDRV_ExtEscape( DC *dc, INT nEscape, INT cbInput, LPCVOID in_data,
INT cbOutput, LPVOID out_data )
{ {
PSDRV_PDEVICE *physDev = (PSDRV_PDEVICE *)dc->physDev; PSDRV_PDEVICE *physDev = (PSDRV_PDEVICE *)dc->physDev;
switch(nEscape) { switch(nEscape)
{
case NEXTBAND: {
RECT16 *r = MapSL(lpOutData);
if(!physDev->job.banding) {
physDev->job.banding = TRUE;
r->left = 0;
r->top = 0;
r->right = physDev->horzRes;
r->bottom = physDev->vertRes;
TRACE("NEXTBAND returning %d,%d - %d,%d\n", r->left,
r->top, r->right, r->bottom );
return 1;
}
r->left = 0;
r->top = 0;
r->right = 0;
r->bottom = 0;
TRACE("NEXTBAND rect to 0,0 - 0,0\n" );
physDev->job.banding = FALSE;
} /* Fall through */
case NEWFRAME:
TRACE("NEWFRAME\n");
if(!physDev->job.hJob) {
FIXME("hJob == 0. Now what?\n");
return SP_ERROR;
}
if(!PSDRV_EndPage( dc ))
return SP_ERROR;
return 1;
case QUERYESCSUPPORT: case QUERYESCSUPPORT:
if(cbInput < 2) { if(cbInput < sizeof(INT))
WARN("cbInput < 2 (=%d) for QUERYESCSUPPORT\n", cbInput); {
WARN("cbInput < sizeof(INT) (=%d) for QUERYESCSUPPORT\n", cbInput);
return 0; return 0;
} else { } else {
UINT16 num = *(UINT16 *)MapSL(lpInData); UINT num = *(UINT *)in_data;
TRACE("QUERYESCSUPPORT for %d\n", num); TRACE("QUERYESCSUPPORT for %d\n", num);
switch(num) { switch(num) {
case NEWFRAME:
case NEXTBAND: case NEXTBAND:
case QUERYESCSUPPORT:
case SETABORTPROC:
case STARTDOC:
case ENDDOC:
case GETPHYSPAGESIZE:
case GETPRINTINGOFFSET:
case GETSCALINGFACTOR:
case SETCOPYCOUNT: case SETCOPYCOUNT:
case GETTECHNOLOGY: case GETTECHNOLOGY:
case SETLINECAP: case SETLINECAP:
@ -88,141 +52,33 @@ INT PSDRV_Escape( DC *dc, INT nEscape, INT cbInput,
} }
} }
case SETABORTPROC: case NEXTBAND:
TRACE("SETABORTPROC\n"); {
return 1; RECT *r = out_data;
if(!physDev->job.banding) {
case STARTDOC: physDev->job.banding = TRUE;
{ r->left = 0;
DOCINFOA doc; r->top = 0;
char *name = NULL; r->right = physDev->horzRes;
INT16 ret; r->bottom = physDev->vertRes;
TRACE("NEXTBAND returning %d,%d - %d,%d\n", r->left, r->top, r->right, r->bottom );
TRACE("STARTDOC\n");
/* lpInData may not be 0 terminated so we must copy it */
if(lpInData) {
name = HeapAlloc( GetProcessHeap(), 0, cbInput+1 );
memcpy(name, MapSL(lpInData), cbInput);
name[cbInput] = '\0';
}
doc.cbSize = sizeof(doc);
doc.lpszDocName = name;
doc.lpszOutput = doc.lpszDatatype = NULL;
doc.fwType = 0;
ret = PSDRV_StartDoc(dc, &doc);
if(name) HeapFree( GetProcessHeap(), 0, name );
if(ret <= 0) return -1;
ret = PSDRV_StartPage(dc);
if(ret <= 0) return -1;
return ret;
}
case ENDDOC:
TRACE("ENDDOC\n");
return PSDRV_EndDoc( dc );
case GETPHYSPAGESIZE:
{
PSDRV_PDEVICE *pdev = (PSDRV_PDEVICE *)(dc->physDev);
POINT16 *p = MapSL(lpOutData);
p->x = p->y = 0;
if ((pdev->Devmode->dmPublic.dmFields & DM_PAPERSIZE) != 0 &&
pdev->Devmode->dmPublic.u1.s1.dmPaperSize != 0)
{
PAGESIZE *page = pdev->pi->ppd->PageSizes;
while (page != NULL)
{
if (page->WinPage ==
pdev->Devmode->dmPublic.u1.s1.dmPaperSize)
break;
page = page->next;
}
if (page == NULL)
{
ERR("No entry for papersize %u in PPD file for '%s'\n",
pdev->Devmode->dmPublic.u1.s1.dmPaperSize,
pdev->pi->FriendlyName);
return 0;
}
TRACE("Found '%s' for paper size %u\n", page->FullName,
pdev->Devmode->dmPublic.u1.s1.dmPaperSize);
p->x = page->PaperDimension->x * physDev->logPixelsX / 72;
p->y = page->PaperDimension->y * physDev->logPixelsY / 72;
TRACE("%fx%f PostScript points = %ix%i device units\n",
page->PaperDimension->x, page->PaperDimension->y,
p->x, p->y);
}
/* These are in tenths of a millimeter */
if ((pdev->Devmode->dmPublic.dmFields & DM_PAPERWIDTH) != 0 &&
pdev->Devmode->dmPublic.u1.s1.dmPaperWidth != 0)
{
p->x = (pdev->Devmode->dmPublic.u1.s1.dmPaperWidth *
physDev->logPixelsX) / 254;
TRACE("dmPaperWidth = %i device units\n", p->x);
}
if ((pdev->Devmode->dmPublic.dmFields & DM_PAPERLENGTH) != 0 &&
pdev->Devmode->dmPublic.u1.s1.dmPaperLength != 0)
{
p->y = (pdev->Devmode->dmPublic.u1.s1.dmPaperLength *
physDev->logPixelsY) / 254;
TRACE("dmPaperLength = %i device units\n", p->y);
}
if (p->x == 0 || p->y == 0)
{
ERR("Paper size not properly set for '%s'\n",
pdev->pi->FriendlyName);
return 0;
}
if ((pdev->Devmode->dmPublic.dmFields & DM_ORIENTATION) != 0 &&
pdev->Devmode->dmPublic.u1.s1.dmOrientation ==
DMORIENT_LANDSCAPE)
{
register INT16 temp = p->y;
p->y = p->x;
p->x = temp;
}
return 1;
}
case GETPRINTINGOFFSET:
{
POINT16 *p = MapSL(lpOutData);
p->x = p->y = 0;
TRACE("GETPRINTINGOFFSET: returning %dx%d\n", p->x, p->y);
return 1;
}
case GETSCALINGFACTOR:
{
POINT16 *p = MapSL(lpOutData);
p->x = p->y = 0;
TRACE("GETSCALINGFACTOR: returning %dx%d\n", p->x, p->y);
return 1; return 1;
} }
r->left = 0;
r->top = 0;
r->right = 0;
r->bottom = 0;
TRACE("NEXTBAND rect to 0,0 - 0,0\n" );
physDev->job.banding = FALSE;
return EndPage( dc->hSelf );
}
case SETCOPYCOUNT: case SETCOPYCOUNT:
{ {
INT16 *NumCopies = MapSL(lpInData); const INT *NumCopies = in_data;
INT16 *ActualCopies = MapSL(lpOutData); INT *ActualCopies = out_data;
if(cbInput != 2) { if(cbInput != sizeof(INT)) {
WARN("cbInput != 2 (=%d) for SETCOPYCOUNT\n", cbInput); WARN("cbInput != sizeof(INT) (=%d) for SETCOPYCOUNT\n", cbInput);
return 0; return 0;
} }
TRACE("SETCOPYCOUNT %d\n", *NumCopies); TRACE("SETCOPYCOUNT %d\n", *NumCopies);
@ -232,7 +88,7 @@ INT PSDRV_Escape( DC *dc, INT nEscape, INT cbInput,
case GETTECHNOLOGY: case GETTECHNOLOGY:
{ {
LPSTR p = MapSL(lpOutData); LPSTR p = out_data;
strcpy(p, "PostScript"); strcpy(p, "PostScript");
*(p + strlen(p) + 1) = '\0'; /* 2 '\0's at end of string */ *(p + strlen(p) + 1) = '\0'; /* 2 '\0's at end of string */
return 1; return 1;
@ -240,33 +96,33 @@ INT PSDRV_Escape( DC *dc, INT nEscape, INT cbInput,
case SETLINECAP: case SETLINECAP:
{ {
INT16 newCap = *(INT16 *)MapSL(lpInData); INT newCap = *(INT *)in_data;
if(cbInput != 2) { if(cbInput != sizeof(INT)) {
WARN("cbInput != 2 (=%d) for SETLINECAP\n", cbInput); WARN("cbInput != sizeof(INT) (=%d) for SETLINECAP\n", cbInput);
return 0; return 0;
} }
TRACE("SETLINECAP %d\n", newCap); TRACE("SETLINECAP %d\n", newCap);
return 0; return 0;
} }
case SETLINEJOIN: case SETLINEJOIN:
{ {
INT16 newJoin = *(INT16 *)MapSL(lpInData); INT newJoin = *(INT *)in_data;
if(cbInput != 2) { if(cbInput != sizeof(INT)) {
WARN("cbInput != 2 (=%d) for SETLINEJOIN\n", cbInput); WARN("cbInput != sizeof(INT) (=%d) for SETLINEJOIN\n", cbInput);
return 0; return 0;
} }
TRACE("SETLINEJOIN %d\n", newJoin); TRACE("SETLINEJOIN %d\n", newJoin);
return 0; return 0;
} }
case SETMITERLIMIT: case SETMITERLIMIT:
{ {
INT16 newLimit = *(INT16 *)MapSL(lpInData); INT newLimit = *(INT *)in_data;
if(cbInput != 2) { if(cbInput != sizeof(INT)) {
WARN("cbInput != 2 (=%d) for SETMITERLIMIT\n", cbInput); WARN("cbInput != sizeof(INT) (=%d) for SETMITERLIMIT\n", cbInput);
return 0; return 0;
} }
TRACE("SETMITERLIMIT %d\n", newLimit); TRACE("SETMITERLIMIT %d\n", newLimit);
return 0; return 0;
} }
@ -292,23 +148,22 @@ INT PSDRV_Escape( DC *dc, INT nEscape, INT cbInput,
case EXT_DEVICE_CAPS: case EXT_DEVICE_CAPS:
{ {
UINT16 cap = *(UINT16 *)MapSL(lpInData); UINT cap = *(UINT *)in_data;
if(cbInput != 2) { if(cbInput != sizeof(UINT)) {
WARN("cbInput != 2 (=%d) for EXT_DEVICE_CAPS\n", WARN("cbInput != sizeof(UINT) (=%d) for EXT_DEVICE_CAPS\n", cbInput);
cbInput);
return 0; return 0;
} }
TRACE("EXT_DEVICE_CAPS %d\n", cap); TRACE("EXT_DEVICE_CAPS %d\n", cap);
return 0; return 0;
} }
case SET_BOUNDS: case SET_BOUNDS:
{ {
RECT16 *r = MapSL(lpInData); const RECT *r = in_data;
if(cbInput != 8) { if(cbInput != sizeof(RECT)) {
WARN("cbInput != 8 (=%d) for SET_BOUNDS\n", cbInput); WARN("cbInput != sizeof(RECT) (=%d) for SET_BOUNDS\n", cbInput);
return 0; return 0;
} }
TRACE("SET_BOUNDS (%d,%d) - (%d,%d)\n", r->left, r->top, TRACE("SET_BOUNDS (%d,%d) - (%d,%d)\n", r->left, r->top,
r->right, r->bottom); r->right, r->bottom);
return 0; return 0;
@ -316,7 +171,7 @@ INT PSDRV_Escape( DC *dc, INT nEscape, INT cbInput,
case EPSPRINTING: case EPSPRINTING:
{ {
UINT16 epsprint = *(UINT16*)MapSL(lpInData); UINT epsprint = *(UINT*)in_data;
/* FIXME: In this mode we do not need to send page intros and page /* FIXME: In this mode we do not need to send page intros and page
* ends according to the doc. But I just ignore that detail * ends according to the doc. But I just ignore that detail
* for now. * for now.
@ -333,7 +188,7 @@ INT PSDRV_Escape( DC *dc, INT nEscape, INT cbInput,
* (Usually we have a WORD before the data counting the size, but * (Usually we have a WORD before the data counting the size, but
* cbInput is just this +2.) * cbInput is just this +2.)
*/ */
return WriteSpool16(physDev->job.hJob,((char*)lpInData)+2,cbInput-2); return WriteSpool16(physDev->job.hJob,((char*)in_data)+2,cbInput-2);
} }
case GETSETPRINTORIENT: case GETSETPRINTORIENT:
@ -342,7 +197,7 @@ INT PSDRV_Escape( DC *dc, INT nEscape, INT cbInput,
* bit LONG value is the orientation. if lpInData is NULL, it * bit LONG value is the orientation. if lpInData is NULL, it
* returns the current orientation. * returns the current orientation.
*/ */
FIXME("GETSETPRINTORIENT not implemented (lpInData %ld)!\n",lpInData); FIXME("GETSETPRINTORIENT not implemented (data %p)!\n",in_data);
return 1; return 1;
} }
default: default:

89
dlls/wineps/init.c
View File

@ -253,6 +253,79 @@ BOOL PSDRV_DeleteDC( DC *dc )
} }
/***********************************************************************
* get_phys_page_size
*
* Helper function to compute PHYSICALWIDTH and PHYSICALHEIGHT dev caps.
*/
static void get_phys_page_size( const PSDRV_PDEVICE *pdev, POINT *p )
{
p->x = p->y = 0;
if ((pdev->Devmode->dmPublic.dmFields & DM_PAPERSIZE) != 0 &&
pdev->Devmode->dmPublic.u1.s1.dmPaperSize != 0)
{
PAGESIZE *page = pdev->pi->ppd->PageSizes;
while (page != NULL)
{
if (page->WinPage == pdev->Devmode->dmPublic.u1.s1.dmPaperSize)
break;
page = page->next;
}
if (page == NULL)
{
ERR("No entry for papersize %u in PPD file for '%s'\n",
pdev->Devmode->dmPublic.u1.s1.dmPaperSize,
pdev->pi->FriendlyName);
return;
}
TRACE("Found '%s' for paper size %u\n", page->FullName,
pdev->Devmode->dmPublic.u1.s1.dmPaperSize);
p->x = page->PaperDimension->x * pdev->logPixelsX / 72;
p->y = page->PaperDimension->y * pdev->logPixelsY / 72;
TRACE("%fx%f PostScript points = %lix%li device units\n",
page->PaperDimension->x, page->PaperDimension->y,
p->x, p->y);
}
/* These are in tenths of a millimeter */
if ((pdev->Devmode->dmPublic.dmFields & DM_PAPERWIDTH) != 0 &&
pdev->Devmode->dmPublic.u1.s1.dmPaperWidth != 0)
{
p->x = (pdev->Devmode->dmPublic.u1.s1.dmPaperWidth *
pdev->logPixelsX) / 254;
TRACE("dmPaperWidth = %li device units\n", p->x);
}
if ((pdev->Devmode->dmPublic.dmFields & DM_PAPERLENGTH) != 0 &&
pdev->Devmode->dmPublic.u1.s1.dmPaperLength != 0)
{
p->y = (pdev->Devmode->dmPublic.u1.s1.dmPaperLength *
pdev->logPixelsY) / 254;
TRACE("dmPaperLength = %li device units\n", p->y);
}
if (p->x == 0 || p->y == 0)
{
ERR("Paper size not properly set for '%s'\n", pdev->pi->FriendlyName);
return;
}
if ((pdev->Devmode->dmPublic.dmFields & DM_ORIENTATION) != 0 &&
pdev->Devmode->dmPublic.u1.s1.dmOrientation == DMORIENT_LANDSCAPE)
{
INT temp = p->y;
p->y = p->x;
p->x = temp;
}
}
/*********************************************************************** /***********************************************************************
* GetDeviceCaps (WINEPS.@) * GetDeviceCaps (WINEPS.@)
*/ */
@ -326,23 +399,15 @@ INT PSDRV_GetDeviceCaps( DC *dc, INT cap )
case COLORRES: case COLORRES:
return 0; return 0;
case PHYSICALWIDTH: case PHYSICALWIDTH:
if (Escape(dc->hSelf, GETPHYSPAGESIZE, 0, NULL, &pt) > 0) return pt.x; get_phys_page_size( physDev, &pt );
return 0; return pt.x;
case PHYSICALHEIGHT: case PHYSICALHEIGHT:
if (Escape(dc->hSelf, GETPHYSPAGESIZE, 0, NULL, &pt) > 0) return pt.y; get_phys_page_size( physDev, &pt );
return 0; return pt.y;
case PHYSICALOFFSETX: case PHYSICALOFFSETX:
if(Escape(dc->hSelf, GETPRINTINGOFFSET, 0, NULL, &pt) > 0) return pt.x;
return 0;
case PHYSICALOFFSETY: case PHYSICALOFFSETY:
if (Escape(dc->hSelf, GETPRINTINGOFFSET, 0, NULL, &pt) > 0) return pt.y;
return 0;
case SCALINGFACTORX: case SCALINGFACTORX:
if (Escape(dc->hSelf, GETSCALINGFACTOR, 0, NULL, &pt) > 0) return pt.x;
return 0;
case SCALINGFACTORY: case SCALINGFACTORY:
if (Escape(dc->hSelf, GETSCALINGFACTOR, 0, NULL, &pt) > 0) return pt.y;
return 0;
case VREFRESH: case VREFRESH:
case DESKTOPVERTRES: case DESKTOPVERTRES:
case DESKTOPHORZRES: case DESKTOPHORZRES:

2
dlls/wineps/wineps.spec
View File

@ -23,8 +23,8 @@ debug_channels (psdrv)
@ cdecl EndDoc(ptr) PSDRV_EndDoc @ cdecl EndDoc(ptr) PSDRV_EndDoc
@ cdecl EndPage(ptr) PSDRV_EndPage @ cdecl EndPage(ptr) PSDRV_EndPage
@ cdecl EnumDeviceFonts(long ptr ptr long) PSDRV_EnumDeviceFonts @ cdecl EnumDeviceFonts(long ptr ptr long) PSDRV_EnumDeviceFonts
@ cdecl Escape(ptr long long long long) PSDRV_Escape
@ cdecl ExtDeviceMode(ptr long ptr ptr ptr ptr ptr long) PSDRV_ExtDeviceMode @ cdecl ExtDeviceMode(ptr long ptr ptr ptr ptr ptr long) PSDRV_ExtDeviceMode
@ cdecl ExtEscape(ptr long long ptr long ptr) PSDRV_ExtEscape
@ cdecl ExtTextOut(ptr long long long ptr ptr long ptr) PSDRV_ExtTextOut @ cdecl ExtTextOut(ptr long long long ptr ptr long ptr) PSDRV_ExtTextOut
@ cdecl GetCharWidth(ptr long long ptr) PSDRV_GetCharWidth @ cdecl GetCharWidth(ptr long long ptr) PSDRV_GetCharWidth
@ cdecl GetDeviceCaps(ptr long) PSDRV_GetDeviceCaps @ cdecl GetDeviceCaps(ptr long) PSDRV_GetDeviceCaps

4
dlls/x11drv/x11ddraw.c
View File

@ -287,10 +287,8 @@ static void X11DRV_DDHAL_SetInfo(void)
(ddraw_fns->lpSetInfo)(&hal_info, FALSE); (ddraw_fns->lpSetInfo)(&hal_info, FALSE);
} }
INT X11DRV_DCICommand(INT cbInput, LPVOID lpInData, LPVOID lpOutData) INT X11DRV_DCICommand(INT cbInput, const DCICMD *lpCmd, LPVOID lpOutData)
{ {
LPDCICMD lpCmd = (LPDCICMD)lpInData;
TRACE("(%d,(%ld,%ld,%ld),%p)\n", cbInput, lpCmd->dwCommand, TRACE("(%d,(%ld,%ld,%ld),%p)\n", cbInput, lpCmd->dwCommand,
lpCmd->dwParam1, lpCmd->dwParam2, lpOutData); lpCmd->dwParam1, lpCmd->dwParam2, lpOutData);

2
dlls/x11drv/x11drv.spec
View File

@ -26,8 +26,8 @@ debug_channels (bitblt bitmap clipboard cursor dinput event font gdi graphics
@ cdecl DescribePixelFormat(ptr long long ptr) X11DRV_DescribePixelFormat @ cdecl DescribePixelFormat(ptr long long ptr) X11DRV_DescribePixelFormat
@ cdecl Ellipse(ptr long long long long) X11DRV_Ellipse @ cdecl Ellipse(ptr long long long long) X11DRV_Ellipse
@ cdecl EnumDeviceFonts(long ptr ptr long) X11DRV_EnumDeviceFonts @ cdecl EnumDeviceFonts(long ptr ptr long) X11DRV_EnumDeviceFonts
@ cdecl Escape(ptr long long long long) X11DRV_Escape
@ cdecl ExtFloodFill(ptr long long long long) X11DRV_ExtFloodFill @ cdecl ExtFloodFill(ptr long long long long) X11DRV_ExtFloodFill
@ cdecl ExtEscape(ptr long long ptr long ptr) X11DRV_ExtEscape
@ cdecl ExtTextOut(ptr long long long ptr ptr long ptr) X11DRV_ExtTextOut @ cdecl ExtTextOut(ptr long long long ptr ptr long ptr) X11DRV_ExtTextOut
@ cdecl GetCharWidth(ptr long long ptr) X11DRV_GetCharWidth @ cdecl GetCharWidth(ptr long long ptr) X11DRV_GetCharWidth
@ cdecl GetDCOrgEx(ptr ptr) X11DRV_GetDCOrgEx @ cdecl GetDCOrgEx(ptr ptr) X11DRV_GetDCOrgEx

2
graphics/enhmetafiledrv/init.c
View File

@ -40,9 +40,9 @@ static const DC_FUNCTIONS EMFDRV_Funcs =
NULL, /* pEndPage */ NULL, /* pEndPage */
EMFDRV_EndPath, /* pEndPath */ EMFDRV_EndPath, /* pEndPath */
NULL, /* pEnumDeviceFonts */ NULL, /* pEnumDeviceFonts */
NULL, /* pEscape */
EMFDRV_ExcludeClipRect, /* pExcludeClipRect */ EMFDRV_ExcludeClipRect, /* pExcludeClipRect */
NULL, /* pExtDeviceMode */ NULL, /* pExtDeviceMode */
NULL, /* pExtEscape */
EMFDRV_ExtFloodFill, /* pExtFloodFill */ EMFDRV_ExtFloodFill, /* pExtFloodFill */
NULL, /* pExtTextOut */ NULL, /* pExtTextOut */
EMFDRV_FillPath, /* pFillPath */ EMFDRV_FillPath, /* pFillPath */

497
graphics/escape.c
View File

@ -2,13 +2,13 @@
* Escape() function. * Escape() function.
* *
* Copyright 1994 Bob Amstadt * Copyright 1994 Bob Amstadt
* Copyright 2001 Alexandre Julliard
*/ */
#include <string.h> #include <string.h>
#include "windef.h" #include "windef.h"
#include "wingdi.h" #include "wingdi.h"
#include "gdi.h" #include "gdi.h"
#include "heap.h"
#include "debugtools.h" #include "debugtools.h"
DEFAULT_DEBUG_CHANNEL(driver); DEFAULT_DEBUG_CHANNEL(driver);
@ -16,231 +16,300 @@ DEFAULT_DEBUG_CHANNEL(driver);
/*********************************************************************** /***********************************************************************
* Escape [GDI.38] * Escape [GDI.38]
*/ */
INT16 WINAPI Escape16( HDC16 hdc, INT16 nEscape, INT16 cbInput, INT16 WINAPI Escape16( HDC16 hdc, INT16 escape, INT16 in_count,
SEGPTR lpszInData, SEGPTR lpvOutData ) SEGPTR in_data, LPVOID out_data )
{ {
INT16 ret = 0; INT ret;
DC * dc = DC_GetDCPtr( hdc );
if (dc) switch(escape)
{ {
if (dc->funcs->pEscape) /* Escape(hdc,CLIP_TO_PATH,LPINT16,NULL) */
{ /* Escape(hdc,DRAFTMODE,LPINT16,NULL) */
if(nEscape == SETABORTPROC) SetAbortProc16(hdc, lpszInData); /* Escape(hdc,ENUMPAPERBINS,LPINT16,LPSTR); */
ret = dc->funcs->pEscape( dc, nEscape, cbInput, lpszInData, lpvOutData ); /* Escape(hdc,EPSPRINTING,LPINT16,NULL) */
} /* Escape(hdc,EXT_DEVICE_CAPS,LPINT16,LPDWORD) */
GDI_ReleaseObj( hdc ); /* Escape(hdc,GETCOLORTABLE,LPINT16,LPDWORD) */
/* Escape(hdc,MOUSETRAILS,LPINT16,NULL) */
/* Escape(hdc,POSTSCRIPT_IGNORE,LPINT16,NULL) */
/* Escape(hdc,QUERYESCSUPPORT,LPINT16,NULL) */
/* Escape(hdc,SET_ARC_DIRECTION,LPINT16,NULL) */
/* Escape(hdc,SET_POLY_MODE,LPINT16,NULL) */
/* Escape(hdc,SET_SCREEN_ANGLE,LPINT16,NULL) */
/* Escape(hdc,SET_SPREAD,LPINT16,NULL) */
case CLIP_TO_PATH:
case DRAFTMODE:
case ENUMPAPERBINS:
case EPSPRINTING:
case EXT_DEVICE_CAPS:
case GETCOLORTABLE:
case MOUSETRAILS:
case POSTSCRIPT_IGNORE:
case QUERYESCSUPPORT:
case SET_ARC_DIRECTION:
case SET_POLY_MODE:
case SET_SCREEN_ANGLE:
case SET_SPREAD:
{
INT16 *ptr = MapSL(in_data);
INT data = *ptr;
return Escape( hdc, escape, sizeof(data), (LPCSTR)&data, out_data );
}
/* Escape(hdc,ENABLEDUPLEX,LPUINT16,NULL) */
case ENABLEDUPLEX:
{
UINT16 *ptr = MapSL(in_data);
UINT data = *ptr;
return Escape( hdc, escape, sizeof(data), (LPCSTR)&data, NULL );
}
/* Escape(hdc,GETPHYSPAGESIZE,NULL,LPPOINT16) */
/* Escape(hdc,GETPRINTINGOFFSET,NULL,LPPOINT16) */
/* Escape(hdc,GETSCALINGFACTOR,NULL,LPPOINT16) */
case GETPHYSPAGESIZE:
case GETPRINTINGOFFSET:
case GETSCALINGFACTOR:
{
POINT16 *ptr = MapSL(in_data);
POINT pt32;
ret = Escape( hdc, escape, 0, NULL, &pt32 );
ptr->x = pt32.x;
ptr->y = pt32.y;
return ret;
}
/* Escape(hdc,ENABLEPAIRKERNING,LPINT16,LPINT16); */
/* Escape(hdc,ENABLERELATIVEWIDTHS,LPINT16,LPINT16); */
/* Escape(hdc,SETCOPYCOUNT,LPINT16,LPINT16) */
/* Escape(hdc,SETKERNTRACK,LPINT16,LPINT16) */
/* Escape(hdc,SETLINECAP,LPINT16,LPINT16) */
/* Escape(hdc,SETLINEJOIN,LPINT16,LPINT16) */
/* Escape(hdc,SETMITERLIMIT,LPINT16,LPINT16) */
case ENABLEPAIRKERNING:
case ENABLERELATIVEWIDTHS:
case SETCOPYCOUNT:
case SETKERNTRACK:
case SETLINECAP:
case SETLINEJOIN:
case SETMITERLIMIT:
{
INT16 *new = MapSL(in_data);
INT16 *old = out_data;
INT out, in = *new;
ret = Escape( hdc, escape, sizeof(in), (LPCSTR)&in, &out );
*old = out;
return ret;
}
/* Escape(hdc,SETABORTPROC,ABORTPROC,NULL); */
case SETABORTPROC:
return SetAbortProc16( hdc, in_data );
/* Escape(hdc,STARTDOC,LPSTR,LPDOCINFO16);
* lpvOutData is actually a pointer to the DocInfo structure and used as
* a second input parameter */
case STARTDOC:
if (out_data)
{
ret = StartDoc16( hdc, out_data );
if (ret > 0) ret = StartPage( hdc );
return ret;
}
return Escape( hdc, escape, in_count, MapSL(in_data), NULL );
/* Escape(hdc,SET_BOUNDS,LPRECT16,NULL); */
/* Escape(hdc,SET_CLIP_BOX,LPRECT16,NULL); */
case SET_BOUNDS:
case SET_CLIP_BOX:
{
RECT16 *rc16 = MapSL(in_data);
RECT rc;
rc.left = rc16->left;
rc.top = rc16->top;
rc.right = rc16->right;
rc.bottom = rc16->bottom;
return Escape( hdc, escape, sizeof(rc), (LPCSTR)&rc, NULL );
}
/* Escape(hdc,NEXTBAND,NULL,LPRECT16); */
case NEXTBAND:
{
RECT rc;
RECT16 *rc16 = MapSL(in_data);
ret = Escape( hdc, escape, 0, NULL, &rc );
rc16->left = rc.left;
rc16->top = rc.top;
rc16->right = rc.right;
rc16->bottom = rc.bottom;
return ret;
}
/* Escape(hdc,ABORTDOC,NULL,NULL); */
/* Escape(hdc,BANDINFO,BANDINFOSTRUCT*,BANDINFOSTRUCT*); */
/* Escape(hdc,BEGIN_PATH,NULL,NULL); */
/* Escape(hdc,DRAWPATTERNRECT,PRECT_STRUCT*,NULL); */
/* Escape(hdc,ENDDOC,NULL,NULL); */
/* Escape(hdc,END_PATH,PATHINFO,NULL); */
/* Escape(hdc,EXTTEXTOUT,EXTTEXT_STRUCT*,NULL); */
/* Escape(hdc,FLUSHOUTPUT,NULL,NULL); */
/* Escape(hdc,GETFACENAME,NULL,LPSTR); */
/* Escape(hdc,GETPAIRKERNTABLE,NULL,KERNPAIR*); */
/* Escape(hdc,GETSETPAPERBINS,BinInfo*,BinInfo*); */
/* Escape(hdc,GETSETPRINTORIENT,ORIENT*,NULL); */
/* Escape(hdc,GETSETSCREENPARAMS,SCREENPARAMS*,SCREENPARAMS*); */
/* Escape(hdc,GETTECHNOLOGY,NULL,LPSTR); */
/* Escape(hdc,GETTRACKKERNTABLE,NULL,KERNTRACK*); */
/* Escape(hdc,MFCOMMENT,LPSTR,NULL); */
/* Escape(hdc,NEWFRAME,NULL,NULL); */
/* Escape(hdc,PASSTHROUGH,LPSTR,NULL); */
/* Escape(hdc,RESTORE_CTM,NULL,NULL); */
/* Escape(hdc,SAVE_CTM,NULL,NULL); */
/* Escape(hdc,SETALLJUSTVALUES,EXTTEXTDATA*,NULL); */
/* Escape(hdc,SETCOLORTABLE,COLORTABLE_STRUCT*,LPDWORD); */
/* Escape(hdc,SET_BACKGROUND_COLOR,LPDWORD,LPDWORD); */
/* Escape(hdc,TRANSFORM_CTM,LPSTR,NULL); */
case ABORTDOC:
case BANDINFO:
case BEGIN_PATH:
case DRAWPATTERNRECT:
case ENDDOC:
case END_PATH:
case EXTTEXTOUT:
case FLUSHOUTPUT:
case GETFACENAME:
case GETPAIRKERNTABLE:
case GETSETPAPERBINS:
case GETSETPRINTORIENT:
case GETSETSCREENPARAMS:
case GETTECHNOLOGY:
case GETTRACKKERNTABLE:
case MFCOMMENT:
case NEWFRAME:
case PASSTHROUGH:
case RESTORE_CTM:
case SAVE_CTM:
case SETALLJUSTVALUES:
case SETCOLORTABLE:
case SET_BACKGROUND_COLOR:
case TRANSFORM_CTM:
/* pass it unmodified to the 32-bit function */
return Escape( hdc, escape, in_count, MapSL(in_data), out_data );
/* Escape(hdc,ENUMPAPERMETRICS,LPINT16,LPRECT16); */
/* Escape(hdc,GETEXTENDEDTEXTMETRICS,LPUINT16,EXTTEXTMETRIC*); */
/* Escape(hdc,GETEXTENTTABLE,LPSTR,LPINT16); */
/* Escape(hdc,GETSETPAPERMETRICS,LPRECT16,LPRECT16); */
/* Escape(hdc,GETVECTORBRUSHSIZE,LPLOGBRUSH16,LPPOINT16); */
/* Escape(hdc,GETVECTORPENSIZE,LPLOGPEN16,LPPOINT16); */
case ENUMPAPERMETRICS:
case GETEXTENDEDTEXTMETRICS:
case GETEXTENTTABLE:
case GETSETPAPERMETRICS:
case GETVECTORBRUSHSIZE:
case GETVECTORPENSIZE:
default:
FIXME("unknown/unsupported 16-bit escape %x (%d,%p,%p\n",
escape, in_count, MapSL(in_data), out_data );
return Escape( hdc, escape, in_count, MapSL(in_data), out_data );
} }
return ret;
} }
/************************************************************************ /************************************************************************
* Escape [GDI32.@] * Escape [GDI32.@]
*/ */
INT WINAPI Escape( HDC hdc, INT nEscape, INT cbInput, INT WINAPI Escape( HDC hdc, INT escape, INT in_count, LPCSTR in_data, LPVOID out_data )
LPCSTR lpszInData, LPVOID lpvOutData )
{ {
SEGPTR segin,segout; INT ret;
INT ret = 0; POINT *pt;
DC * dc = DC_GetDCPtr( hdc );
if (!dc) return 0;
if (!dc->funcs->pEscape) goto done;
segin = (SEGPTR)lpszInData; switch (escape)
segout = (SEGPTR)lpvOutData; {
switch (nEscape) { case ABORTDOC:
/* Escape(hdc,QUERYESCSUPPORT,LPINT,NULL) */ return AbortDoc( hdc );
/* Escape(hdc,CLIP_TO_PATH,LPINT,NULL) */
/* Escape(hdc,EPSPRINTING,LPINT,NULL) */
case QUERYESCSUPPORT:
case CLIP_TO_PATH:
case EPSPRINTING:
{
LPINT16 x = (LPINT16)SEGPTR_NEW(INT16);
*x = *(INT*)lpszInData;
segin = SEGPTR_GET(x);
cbInput = sizeof(INT16);
break;
}
/* Escape(hdc,GETSCALINGFACTOR,NULL,LPPOINT32) */ case ENDDOC:
/* Escape(hdc,GETPHYSPAGESIZE,NULL,LPPOINT32) */ return EndDoc( hdc );
/* Escape(hdc,GETPRINTINGOFFSET,NULL,LPPOINT32) */
case GETPHYSPAGESIZE:
pt = out_data;
pt->x = GetDeviceCaps( hdc, PHYSICALWIDTH );
pt->y = GetDeviceCaps( hdc, PHYSICALHEIGHT );
return 1;
case GETPRINTINGOFFSET:
pt = out_data;
pt->x = GetDeviceCaps( hdc, PHYSICALOFFSETX );
pt->y = GetDeviceCaps( hdc, PHYSICALOFFSETY );
return 1;
case GETSCALINGFACTOR: case GETSCALINGFACTOR:
case GETPHYSPAGESIZE: pt = out_data;
case GETPRINTINGOFFSET: pt->x = GetDeviceCaps( hdc, SCALINGFACTORX );
segout = SEGPTR_GET(SEGPTR_NEW(POINT16)); pt->y = GetDeviceCaps( hdc, SCALINGFACTORY );
cbInput = sizeof(POINT16); return 1;
break;
/* Escape(hdc,EXT_DEVICE_CAPS,LPINT,LPDWORD) */ case NEWFRAME:
case EXT_DEVICE_CAPS: return EndPage( hdc );
{
LPINT16 lpIndex = (LPINT16)SEGPTR_NEW(INT16);
LPDWORD lpCaps = (LPDWORD)SEGPTR_NEW(DWORD);
*lpIndex = *(INT*)lpszInData;
segin = SEGPTR_GET(lpIndex);
segout = SEGPTR_GET(lpCaps);
cbInput = sizeof(INT16);
break;
}
/* Escape(hdc,SETLINECAP,LPINT,LPINT) */
case SETLINECAP:
case SETLINEJOIN:
case SETMITERLIMIT:
{
LPINT16 new = (LPINT16)SEGPTR_NEW(INT16);
LPINT16 old = (LPINT16)SEGPTR_NEW(INT16);
*new = *(INT*)lpszInData;
segin = SEGPTR_GET(new);
segout = SEGPTR_GET(old);
cbInput = sizeof(INT16);
break;
}
/* Escape(hdc,GETTECHNOLOGY,NULL,LPSTR); */
case GETTECHNOLOGY: {
segout = SEGPTR_GET(SEGPTR_ALLOC(200)); /* enough I hope */
break;
}
/* Escape(hdc,ENABLEPAIRKERNING,LPINT16,LPINT16); */
case ENABLEPAIRKERNING: {
LPINT16 enab = SEGPTR_NEW(INT16);
segout = SEGPTR_GET(SEGPTR_NEW(INT16));
segin = SEGPTR_GET(enab);
*enab = *(INT*)lpszInData;
cbInput = sizeof(INT16);
break;
}
/* Escape(hdc,GETFACENAME,NULL,LPSTR); */
case GETFACENAME: {
segout = SEGPTR_GET(SEGPTR_ALLOC(200));
break;
}
/* Escape(hdc,STARTDOC,LPSTR,LPDOCINFOA);
* lpvOutData is actually a pointer to the DocInfo structure and used as
* a second input parameter
*/
case STARTDOC: /* string may not be \0 terminated */
if(lpszInData) {
char *cp = SEGPTR_ALLOC(cbInput);
memcpy(cp, lpszInData, cbInput);
segin = SEGPTR_GET(cp);
} else
segin = 0;
if(lpvOutData) {
DOCINFO16 *lpsegdoc = SEGPTR_NEW(DOCINFO16);
DOCINFOA *lpdoc = lpvOutData;
memset(lpsegdoc, 0, sizeof(*lpsegdoc));
lpsegdoc->cbSize = sizeof(*lpsegdoc);
lpsegdoc->lpszDocName = SEGPTR_GET(SEGPTR_STRDUP(lpdoc->lpszDocName));
lpsegdoc->lpszOutput = SEGPTR_GET(SEGPTR_STRDUP(lpdoc->lpszOutput));
lpsegdoc->lpszDatatype = SEGPTR_GET(SEGPTR_STRDUP(lpdoc->lpszDatatype));
lpsegdoc->fwType = lpdoc->fwType;
segout = SEGPTR_GET(lpsegdoc);
}
break;
case SETABORTPROC: case SETABORTPROC:
SetAbortProc(hdc, (ABORTPROC)lpszInData); return SetAbortProc( hdc, (ABORTPROC)in_data );
break;
/* Escape(hdc,END_PATH,PATHINFO,NULL); */ case STARTDOC:
case END_PATH: {
{ DOCINFOA doc;
BYTE *p = SEGPTR_ALLOC(cbInput); char *name = NULL;
memcpy(p, lpszInData, cbInput);
segin = SEGPTR_GET(p);
break;
}
default: /* in_data may not be 0 terminated so we must copy it */
break; if (in_data)
{
name = HeapAlloc( GetProcessHeap(), 0, in_count+1 );
memcpy( name, in_data, in_count );
name[in_count] = 0;
}
/* out_data is actually a pointer to the DocInfo structure and used as
* a second input parameter */
if (out_data) doc = *(DOCINFOA *)out_data;
else
{
doc.cbSize = sizeof(doc);
doc.lpszOutput = NULL;
doc.lpszDatatype = NULL;
doc.fwType = 0;
}
doc.lpszDocName = name;
ret = StartDocA( hdc, &doc );
if (name) HeapFree( GetProcessHeap(), 0, name );
if (ret > 0) ret = StartPage( hdc );
return ret;
}
}
ret = dc->funcs->pEscape( dc, nEscape, cbInput, segin, segout );
switch(nEscape) {
case QUERYESCSUPPORT: case QUERYESCSUPPORT:
if (ret) {
TRACE("target DC implements Escape %d\n",nEscape); INT *ptr = (INT *)in_data;
SEGPTR_FREE(MapSL(segin)); if (in_count < sizeof(INT)) return 0;
break; switch(*ptr)
{
case SETLINECAP: case ABORTDOC:
case SETLINEJOIN: case ENDDOC:
case SETMITERLIMIT: case GETPHYSPAGESIZE:
*(LPINT)lpvOutData = *(LPINT16)MapSL(segout); case GETPRINTINGOFFSET:
SEGPTR_FREE(MapSL(segin)); case GETSCALINGFACTOR:
SEGPTR_FREE(MapSL(segout)); case NEWFRAME:
break; case QUERYESCSUPPORT:
case GETSCALINGFACTOR: case SETABORTPROC:
case GETPRINTINGOFFSET: case STARTDOC:
case GETPHYSPAGESIZE: { return TRUE;
LPPOINT16 x = MapSL(segout); }
CONV_POINT16TO32(x,(LPPOINT)lpvOutData); break;
SEGPTR_FREE(x); }
break;
}
case EXT_DEVICE_CAPS:
*(LPDWORD)lpvOutData = *(LPDWORD)MapSL(segout);
SEGPTR_FREE(MapSL(segin));
SEGPTR_FREE(MapSL(segout));
break;
case GETTECHNOLOGY: {
LPSTR x=MapSL(segout);
strcpy(lpvOutData,x);
SEGPTR_FREE(x);
break;
}
case ENABLEPAIRKERNING: {
LPINT16 enab = MapSL(segout);
*(LPINT)lpvOutData = *enab;
SEGPTR_FREE(enab);
SEGPTR_FREE(MapSL(segin));
break;
}
case GETFACENAME: {
LPSTR x = (LPSTR)MapSL(segout);
strcpy(lpvOutData,x);
SEGPTR_FREE(x);
break;
}
case STARTDOC: {
DOCINFO16 *doc = MapSL(segout);
SEGPTR_FREE(MapSL(doc->lpszDocName));
SEGPTR_FREE(MapSL(doc->lpszOutput));
SEGPTR_FREE(MapSL(doc->lpszDatatype));
SEGPTR_FREE(doc);
SEGPTR_FREE(MapSL(segin));
break;
} }
case CLIP_TO_PATH: /* if not handled internally, pass it to the driver */
case END_PATH: return ExtEscape( hdc, escape, in_count, in_data, 0, out_data );
SEGPTR_FREE(MapSL(segin));
break;
default:
break;
}
done:
GDI_ReleaseObj( hdc );
return ret;
} }
/****************************************************************************** /******************************************************************************
* ExtEscape [GDI32.@] * ExtEscape [GDI32.@]
* *
@ -257,25 +326,21 @@ INT WINAPI Escape( HDC hdc, INT nEscape, INT cbInput,
* Not implemented: 0 * Not implemented: 0
* Failure: <0 * Failure: <0
*/ */
INT WINAPI ExtEscape( HDC hdc, INT nEscape, INT cbInput, INT WINAPI ExtEscape( HDC hdc, INT nEscape, INT cbInput, LPCSTR lpszInData,
LPCSTR lpszInData, INT cbOutput, LPSTR lpszOutData ) INT cbOutput, LPSTR lpszOutData )
{ {
char *inBuf, *outBuf; INT ret = 0;
INT ret; DC * dc = DC_GetDCPtr( hdc );
if (dc)
inBuf = SEGPTR_ALLOC(cbInput); {
memcpy(inBuf, lpszInData, cbInput); if (dc->funcs->pExtEscape)
outBuf = cbOutput ? SEGPTR_ALLOC(cbOutput) : NULL; ret = dc->funcs->pExtEscape( dc, nEscape, cbInput, lpszInData, cbOutput, lpszOutData );
ret = Escape16( hdc, nEscape, cbInput, SEGPTR_GET(inBuf), GDI_ReleaseObj( hdc );
SEGPTR_GET(outBuf) );
SEGPTR_FREE(inBuf);
if(outBuf) {
memcpy(lpszOutData, outBuf, cbOutput);
SEGPTR_FREE(outBuf);
} }
return ret; return ret;
} }
/******************************************************************* /*******************************************************************
* DrawEscape [GDI32.@] * DrawEscape [GDI32.@]
* *

2
graphics/metafiledrv/init.c
View File

@ -41,9 +41,9 @@ static const DC_FUNCTIONS MFDRV_Funcs =
NULL, /* pEndPage */ NULL, /* pEndPage */
MFDRV_EndPath, /* pEndPath */ MFDRV_EndPath, /* pEndPath */
NULL, /* pEnumDeviceFonts */ NULL, /* pEnumDeviceFonts */
NULL, /* pEscape */
MFDRV_ExcludeClipRect, /* pExcludeClipRect */ MFDRV_ExcludeClipRect, /* pExcludeClipRect */
NULL, /* pExtDeviceMode */ NULL, /* pExtDeviceMode */
NULL, /* pExtEscape */
MFDRV_ExtFloodFill, /* pExtFloodFill */ MFDRV_ExtFloodFill, /* pExtFloodFill */
MFDRV_ExtTextOut, /* pExtTextOut */ MFDRV_ExtTextOut, /* pExtTextOut */
MFDRV_FillPath, /* pFillPath */ MFDRV_FillPath, /* pFillPath */

19
graphics/win16drv/init.c
View File

@ -40,8 +40,8 @@ LPDRAWMODE win16drv_DrawModeP;
static BOOL WIN16DRV_CreateDC( DC *dc, LPCSTR driver, LPCSTR device, static BOOL WIN16DRV_CreateDC( DC *dc, LPCSTR driver, LPCSTR device,
LPCSTR output, const DEVMODEA* initData ); LPCSTR output, const DEVMODEA* initData );
static INT WIN16DRV_GetDeviceCaps( DC *dc, INT cap ); static INT WIN16DRV_GetDeviceCaps( DC *dc, INT cap );
static INT WIN16DRV_Escape( DC *dc, INT nEscape, INT cbInput, static INT WIN16DRV_ExtEscape( DC *dc, INT escape, INT in_count, LPCVOID in_data,
SEGPTR lpInData, SEGPTR lpOutData ); INT out_count, LPVOID out_data );
static const DC_FUNCTIONS WIN16DRV_Funcs = static const DC_FUNCTIONS WIN16DRV_Funcs =
{ {
@ -68,9 +68,9 @@ static const DC_FUNCTIONS WIN16DRV_Funcs =
NULL, /* pEndPage */ NULL, /* pEndPage */
NULL, /* pEndPath */ NULL, /* pEndPath */
WIN16DRV_EnumDeviceFonts, /* pEnumDeviceFonts */ WIN16DRV_EnumDeviceFonts, /* pEnumDeviceFonts */
WIN16DRV_Escape, /* pEscape */
NULL, /* pExcludeClipRect */ NULL, /* pExcludeClipRect */
WIN16DRV_ExtDeviceMode, /* pExtDeviceMode */ WIN16DRV_ExtDeviceMode, /* pExtDeviceMode */
WIN16DRV_ExtEscape, /* pExtEscape */
NULL, /* pExtFloodFill */ NULL, /* pExtFloodFill */
WIN16DRV_ExtTextOut, /* pExtTextOut */ WIN16DRV_ExtTextOut, /* pExtTextOut */
NULL, /* pFillPath */ NULL, /* pFillPath */
@ -319,12 +319,13 @@ static INT WIN16DRV_GetDeviceCaps( DC *dc, INT cap )
} }
/* /***********************************************************************
* Escape (GDI.38) * WIN16DRV_ExtEscape
*/ */
static INT WIN16DRV_Escape( DC *dc, INT nEscape, INT cbInput, static INT WIN16DRV_ExtEscape( DC *dc, INT escape, INT in_count, LPCVOID in_data,
SEGPTR lpInData, SEGPTR lpOutData ) INT out_count, LPVOID out_data )
{ {
#if 0
WIN16DRV_PDEVICE *physDev = (WIN16DRV_PDEVICE *)dc->physDev; WIN16DRV_PDEVICE *physDev = (WIN16DRV_PDEVICE *)dc->physDev;
int nRet = 0; int nRet = 0;
@ -414,6 +415,10 @@ static INT WIN16DRV_Escape( DC *dc, INT nEscape, INT cbInput,
else else
WARN("Escape(nEscape = %04x) - ???\n", nEscape); WARN("Escape(nEscape = %04x) - ???\n", nEscape);
return nRet; return nRet;
#endif
/* FIXME: should convert args to SEGPTR and redo all the above */
FIXME("temporarily broken, please fix\n");
return 0;
} }

54
graphics/x11drv/init.c
View File

@ -263,42 +263,32 @@ INT X11DRV_GetDeviceCaps( DC *dc, INT cap )
/********************************************************************** /**********************************************************************
* X11DRV_Escape * ExtEscape (X11DRV.@)
*/ */
INT X11DRV_Escape( DC *dc, INT nEscape, INT cbInput, SEGPTR lpInData, SEGPTR lpOutData ) INT X11DRV_ExtEscape( DC *dc, INT escape, INT in_count, LPCVOID in_data,
INT out_count, LPVOID out_data )
{ {
switch( nEscape ) switch(escape)
{ {
case QUERYESCSUPPORT: case QUERYESCSUPPORT:
if( lpInData ) if (in_data)
{ {
LPINT16 lpEscape = MapSL(lpInData); switch (*(INT *)in_data)
switch (*lpEscape) {
{ case DCICOMMAND:
case DCICOMMAND: return DD_HAL_VERSION;
return DD_HAL_VERSION; }
} }
} break;
break;
case GETSCALINGFACTOR:
if( lpOutData )
{
LPPOINT16 lppt = MapSL(lpOutData);
lppt->x = lppt->y = 0; /* no device scaling */
return 1;
}
break;
case DCICOMMAND:
if( lpInData )
{
LPDCICMD lpCmd = MapSL(lpInData);
if (lpCmd->dwVersion != DD_VERSION) break;
return X11DRV_DCICommand(cbInput, lpCmd, MapSL(lpOutData));
}
break;
case DCICOMMAND:
if (in_data)
{
const DCICMD *lpCmd = in_data;
if (lpCmd->dwVersion != DD_VERSION) break;
return X11DRV_DCICommand(in_count, lpCmd, out_data);
}
break;
} }
return 0; return 0;
} }

5
include/gdi.h
View File

@ -148,10 +148,9 @@ typedef struct tagDC_FUNCS
INT (*pEndPage)(DC*); INT (*pEndPage)(DC*);
BOOL (*pEndPath)(DC*); BOOL (*pEndPath)(DC*);
BOOL (*pEnumDeviceFonts)(HDC,LPLOGFONTW,DEVICEFONTENUMPROC,LPARAM); BOOL (*pEnumDeviceFonts)(HDC,LPLOGFONTW,DEVICEFONTENUMPROC,LPARAM);
INT (*pEscape)(DC*,INT,INT,SEGPTR,SEGPTR);
INT (*pExcludeClipRect)(DC*,INT,INT,INT,INT); INT (*pExcludeClipRect)(DC*,INT,INT,INT,INT);
INT (*pExtDeviceMode)(LPSTR,HWND,LPDEVMODEA,LPSTR,LPSTR,LPDEVMODEA, INT (*pExtDeviceMode)(LPSTR,HWND,LPDEVMODEA,LPSTR,LPSTR,LPDEVMODEA,LPSTR,DWORD);
LPSTR,DWORD); INT (*pExtEscape)(DC*,INT,INT,LPCVOID,INT,LPVOID);
BOOL (*pExtFloodFill)(DC*,INT,INT,COLORREF,UINT); BOOL (*pExtFloodFill)(DC*,INT,INT,COLORREF,UINT);
BOOL (*pExtTextOut)(DC*,INT,INT,UINT,const RECT*,LPCWSTR,UINT, BOOL (*pExtTextOut)(DC*,INT,INT,UINT,const RECT*,LPCWSTR,UINT,
const INT*); const INT*);

2
include/wine/wingdi16.h
View File

@ -368,7 +368,7 @@ INT16 WINAPI EnumFonts16(HDC16,LPCSTR,FONTENUMPROC16,LPARAM);
BOOL16 WINAPI EnumMetaFile16(HDC16,HMETAFILE16,MFENUMPROC16,LPARAM); BOOL16 WINAPI EnumMetaFile16(HDC16,HMETAFILE16,MFENUMPROC16,LPARAM);
INT16 WINAPI EnumObjects16(HDC16,INT16,GOBJENUMPROC16,LPARAM); INT16 WINAPI EnumObjects16(HDC16,INT16,GOBJENUMPROC16,LPARAM);
BOOL16 WINAPI EqualRgn16(HRGN16,HRGN16); BOOL16 WINAPI EqualRgn16(HRGN16,HRGN16);
INT16 WINAPI Escape16(HDC16,INT16,INT16,SEGPTR,SEGPTR); INT16 WINAPI Escape16(HDC16,INT16,INT16,SEGPTR,LPVOID);
INT16 WINAPI ExcludeClipRect16(HDC16,INT16,INT16,INT16,INT16); INT16 WINAPI ExcludeClipRect16(HDC16,INT16,INT16,INT16,INT16);
INT16 WINAPI ExcludeVisRect16(HDC16,INT16,INT16,INT16,INT16); INT16 WINAPI ExcludeVisRect16(HDC16,INT16,INT16,INT16,INT16);
HPEN16 WINAPI ExtCreatePen16(DWORD,DWORD,const LOGBRUSH16*,DWORD,const DWORD*); HPEN16 WINAPI ExtCreatePen16(DWORD,DWORD,const LOGBRUSH16*,DWORD,const DWORD*);

4
include/x11drv.h
View File

@ -255,8 +255,8 @@ void X11DRV_DIB_CopyDIBSection(DC *dcSrc, DC *dcDst,
DWORD xSrc, DWORD ySrc, DWORD xSrc, DWORD ySrc,
DWORD xDest, DWORD yDest, DWORD xDest, DWORD yDest,
DWORD width, DWORD height); DWORD width, DWORD height);
struct _DCICMD;
extern INT X11DRV_DCICommand(INT cbInput, LPVOID lpInData, LPVOID lpOutData); extern INT X11DRV_DCICommand(INT cbInput, const struct _DCICMD *lpCmd, LPVOID lpOutData);
/************************************************************************** /**************************************************************************
* X11 GDI driver * X11 GDI driver