#include <stdarg.h>
#include "windef.h"
#include "winbase.h"
#include "wingdi.h"
#include "gdi_private.h"

Include dependency graph for metafiledrv.h:

This graph shows which files directly or indirectly include this file:

Classes
struct	METAFILEDRV_PDEVICE

Macros
#define	HANDLE_LIST_INC 20

Functions
BOOL	MFDRV_MetaParam0 (PHYSDEV dev, short func) DECLSPEC_HIDDEN

BOOL	MFDRV_MetaParam1 (PHYSDEV dev, short func, short param1) DECLSPEC_HIDDEN

BOOL	MFDRV_MetaParam2 (PHYSDEV dev, short func, short param1, short param2) DECLSPEC_HIDDEN

BOOL	MFDRV_MetaParam4 (PHYSDEV dev, short func, short param1, short param2, short param3, short param4) DECLSPEC_HIDDEN

BOOL	MFDRV_MetaParam6 (PHYSDEV dev, short func, short param1, short param2, short param3, short param4, short param5, short param6) DECLSPEC_HIDDEN

BOOL	MFDRV_MetaParam8 (PHYSDEV dev, short func, short param1, short param2, short param3, short param4, short param5, short param6, short param7, short param8) DECLSPEC_HIDDEN

BOOL	MFDRV_WriteRecord (PHYSDEV dev, METARECORD *mr, DWORD rlen) DECLSPEC_HIDDEN

UINT	MFDRV_AddHandle (PHYSDEV dev, HGDIOBJ obj) DECLSPEC_HIDDEN

BOOL	MFDRV_RemoveHandle (PHYSDEV dev, UINT index) DECLSPEC_HIDDEN

INT16	MFDRV_CreateBrushIndirect (PHYSDEV dev, HBRUSH hBrush) DECLSPEC_HIDDEN

BOOL	MFDRV_AbortPath (PHYSDEV dev) DECLSPEC_HIDDEN

BOOL	MFDRV_Arc (PHYSDEV dev, INT left, INT top, INT right, INT bottom, INT xstart, INT ystart, INT xend, INT yend) DECLSPEC_HIDDEN

BOOL	MFDRV_BeginPath (PHYSDEV dev) DECLSPEC_HIDDEN

BOOL	MFDRV_Chord (PHYSDEV dev, INT left, INT top, INT right, INT bottom, INT xstart, INT ystart, INT xend, INT yend) DECLSPEC_HIDDEN

BOOL	MFDRV_CloseFigure (PHYSDEV dev) DECLSPEC_HIDDEN

BOOL	MFDRV_DeleteObject (PHYSDEV dev, HGDIOBJ obj) DECLSPEC_HIDDEN

BOOL	MFDRV_Ellipse (PHYSDEV dev, INT left, INT top, INT right, INT bottom) DECLSPEC_HIDDEN

BOOL	MFDRV_EndPath (PHYSDEV dev) DECLSPEC_HIDDEN

INT	MFDRV_ExcludeClipRect (PHYSDEV dev, INT left, INT top, INT right, INT bottom) DECLSPEC_HIDDEN

BOOL	MFDRV_ExtFloodFill (PHYSDEV dev, INT x, INT y, COLORREF color, UINT fillType) DECLSPEC_HIDDEN

INT	MFDRV_ExtSelectClipRgn (PHYSDEV dev, HRGN hrgn, INT mode) DECLSPEC_HIDDEN

BOOL	MFDRV_ExtTextOut (PHYSDEV dev, INT x, INT y, UINT flags, const RECT lprect, LPCWSTR str, UINT count, const INT lpDx) DECLSPEC_HIDDEN

BOOL	MFDRV_FillPath (PHYSDEV dev) DECLSPEC_HIDDEN

BOOL	MFDRV_FillRgn (PHYSDEV dev, HRGN hrgn, HBRUSH hbrush) DECLSPEC_HIDDEN

BOOL	MFDRV_FlattenPath (PHYSDEV dev) DECLSPEC_HIDDEN

BOOL	MFDRV_FrameRgn (PHYSDEV dev, HRGN hrgn, HBRUSH hbrush, INT x, INT y) DECLSPEC_HIDDEN

INT	MFDRV_IntersectClipRect (PHYSDEV dev, INT left, INT top, INT right, INT bottom) DECLSPEC_HIDDEN

BOOL	MFDRV_InvertRgn (PHYSDEV dev, HRGN hrgn) DECLSPEC_HIDDEN

BOOL	MFDRV_LineTo (PHYSDEV dev, INT x, INT y) DECLSPEC_HIDDEN

BOOL	MFDRV_MoveTo (PHYSDEV dev, INT x, INT y) DECLSPEC_HIDDEN

INT	MFDRV_OffsetClipRgn (PHYSDEV dev, INT x, INT y) DECLSPEC_HIDDEN

BOOL	MFDRV_OffsetViewportOrgEx (PHYSDEV dev, INT x, INT y, POINT *pt) DECLSPEC_HIDDEN

BOOL	MFDRV_OffsetWindowOrgEx (PHYSDEV dev, INT x, INT y, POINT *pt) DECLSPEC_HIDDEN

BOOL	MFDRV_PaintRgn (PHYSDEV dev, HRGN hrgn) DECLSPEC_HIDDEN

BOOL	MFDRV_PatBlt (PHYSDEV dev, struct bitblt_coords *dst, DWORD rop) DECLSPEC_HIDDEN

BOOL	MFDRV_Pie (PHYSDEV dev, INT left, INT top, INT right, INT bottom, INT xstart, INT ystart, INT xend, INT yend) DECLSPEC_HIDDEN

BOOL	MFDRV_PolyBezier (PHYSDEV dev, const POINT *pt, DWORD count) DECLSPEC_HIDDEN

BOOL	MFDRV_PolyBezierTo (PHYSDEV dev, const POINT *pt, DWORD count) DECLSPEC_HIDDEN

BOOL	MFDRV_PolyPolygon (PHYSDEV dev, const POINT pt, const INT counts, UINT polygons) DECLSPEC_HIDDEN

BOOL	MFDRV_Polygon (PHYSDEV dev, const POINT *pt, INT count) DECLSPEC_HIDDEN

BOOL	MFDRV_Polyline (PHYSDEV dev, const POINT *pt, INT count) DECLSPEC_HIDDEN

BOOL	MFDRV_Rectangle (PHYSDEV dev, INT left, INT top, INT right, INT bottom) DECLSPEC_HIDDEN

BOOL	MFDRV_RestoreDC (PHYSDEV dev, INT level) DECLSPEC_HIDDEN

BOOL	MFDRV_RoundRect (PHYSDEV dev, INT left, INT top, INT right, INT bottom, INT ell_width, INT ell_height) DECLSPEC_HIDDEN

INT	MFDRV_SaveDC (PHYSDEV dev) DECLSPEC_HIDDEN

BOOL	MFDRV_ScaleViewportExtEx (PHYSDEV dev, INT xNum, INT xDenom, INT yNum, INT yDenom, SIZE *size) DECLSPEC_HIDDEN

BOOL	MFDRV_ScaleWindowExtEx (PHYSDEV dev, INT xNum, INT xDenom, INT yNum, INT yDenom, SIZE *size) DECLSPEC_HIDDEN

HBITMAP	MFDRV_SelectBitmap (PHYSDEV dev, HBITMAP handle) DECLSPEC_HIDDEN

HBRUSH	MFDRV_SelectBrush (PHYSDEV dev, HBRUSH hbrush, const struct brush_pattern *pattern) DECLSPEC_HIDDEN

BOOL	MFDRV_SelectClipPath (PHYSDEV dev, INT iMode) DECLSPEC_HIDDEN

HFONT	MFDRV_SelectFont (PHYSDEV dev, HFONT handle, UINT *aa_flags) DECLSPEC_HIDDEN

HPEN	MFDRV_SelectPen (PHYSDEV dev, HPEN handle, const struct brush_pattern *pattern) DECLSPEC_HIDDEN

HPALETTE	MFDRV_SelectPalette (PHYSDEV dev, HPALETTE hPalette, BOOL bForceBackground) DECLSPEC_HIDDEN

UINT	MFDRV_RealizePalette (PHYSDEV dev, HPALETTE hPalette, BOOL primary) DECLSPEC_HIDDEN

COLORREF	MFDRV_SetBkColor (PHYSDEV dev, COLORREF color) DECLSPEC_HIDDEN

INT	MFDRV_SetBkMode (PHYSDEV dev, INT mode) DECLSPEC_HIDDEN

COLORREF	MFDRV_SetDCBrushColor (PHYSDEV dev, COLORREF color) DECLSPEC_HIDDEN

COLORREF	MFDRV_SetDCPenColor (PHYSDEV dev, COLORREF color) DECLSPEC_HIDDEN

INT	MFDRV_SetMapMode (PHYSDEV dev, INT mode) DECLSPEC_HIDDEN

DWORD	MFDRV_SetMapperFlags (PHYSDEV dev, DWORD flags) DECLSPEC_HIDDEN

COLORREF	MFDRV_SetPixel (PHYSDEV dev, INT x, INT y, COLORREF color) DECLSPEC_HIDDEN

INT	MFDRV_SetPolyFillMode (PHYSDEV dev, INT mode) DECLSPEC_HIDDEN

INT	MFDRV_SetROP2 (PHYSDEV dev, INT rop) DECLSPEC_HIDDEN

INT	MFDRV_SetRelAbs (PHYSDEV dev, INT mode) DECLSPEC_HIDDEN

INT	MFDRV_SetStretchBltMode (PHYSDEV dev, INT mode) DECLSPEC_HIDDEN

UINT	MFDRV_SetTextAlign (PHYSDEV dev, UINT align) DECLSPEC_HIDDEN

INT	MFDRV_SetTextCharacterExtra (PHYSDEV dev, INT extra) DECLSPEC_HIDDEN

COLORREF	MFDRV_SetTextColor (PHYSDEV dev, COLORREF color) DECLSPEC_HIDDEN

BOOL	MFDRV_SetTextJustification (PHYSDEV dev, INT extra, INT breaks) DECLSPEC_HIDDEN

BOOL	MFDRV_SetViewportExtEx (PHYSDEV dev, INT x, INT y, SIZE *size) DECLSPEC_HIDDEN

BOOL	MFDRV_SetViewportOrgEx (PHYSDEV dev, INT x, INT y, POINT *pt) DECLSPEC_HIDDEN

BOOL	MFDRV_SetWindowExtEx (PHYSDEV dev, INT x, INT y, SIZE *size) DECLSPEC_HIDDEN

BOOL	MFDRV_SetWindowOrgEx (PHYSDEV dev, INT x, INT y, POINT *pt) DECLSPEC_HIDDEN

BOOL	MFDRV_StretchBlt (PHYSDEV devDst, struct bitblt_coords dst, PHYSDEV devSrc, struct bitblt_coords src, DWORD rop) DECLSPEC_HIDDEN

INT	MFDRV_SetDIBitsToDevice (PHYSDEV dev, INT xDest, INT yDest, DWORD cx, DWORD cy, INT xSrc, INT ySrc, UINT startscan, UINT lines, LPCVOID bits, BITMAPINFO *info, UINT coloruse) DECLSPEC_HIDDEN

INT	MFDRV_StretchDIBits (PHYSDEV dev, INT xDst, INT yDst, INT widthDst, INT heightDst, INT xSrc, INT ySrc, INT widthSrc, INT heightSrc, const void bits, BITMAPINFO info, UINT wUsage, DWORD dwRop) DECLSPEC_HIDDEN

BOOL	MFDRV_StrokeAndFillPath (PHYSDEV dev) DECLSPEC_HIDDEN

BOOL	MFDRV_StrokePath (PHYSDEV dev) DECLSPEC_HIDDEN

BOOL	MFDRV_WidenPath (PHYSDEV dev) DECLSPEC_HIDDEN

Macro Definition Documentation

◆ HANDLE_LIST_INC

#define HANDLE_LIST_INC 20

Definition at line 42 of file metafiledrv.h.

Function Documentation

◆ MFDRV_AbortPath()

BOOL MFDRV_AbortPath ( PHYSDEV dev )

Definition at line 148 of file dc.c.

 {
     return FALSE;
 }

◆ MFDRV_AddHandle()

UINT MFDRV_AddHandle	(	PHYSDEV	dev,
		HGDIOBJ	obj
	)

Definition at line 39 of file objects.c.

 {
     METAFILEDRV_PDEVICE *physDev = (METAFILEDRV_PDEVICE *)dev;
     UINT16 index;
 
     for(index = 0; index < physDev->handles_size; index++)
         if(physDev->handles[index] == 0) break;
     if(index == physDev->handles_size) {
         physDev->handles_size += HANDLE_LIST_INC;
         physDev->handles = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
                                        physDev->handles,
                                        physDev->handles_size * sizeof(physDev->handles[0]));
     }
     physDev->handles[index] = get_full_gdi_handle( obj );
 
     physDev->cur_handles++;
     if(physDev->cur_handles > physDev->mh->mtNoObjects)
         physDev->mh->mtNoObjects++;
 
     return index ; /* index 0 is not reserved for metafiles */
 }

Referenced by MFDRV_CreateBrushIndirect(), MFDRV_CreateFontIndirect(), MFDRV_CreatePalette(), MFDRV_CreatePenIndirect(), and MFDRV_CreateRegion().

◆ MFDRV_Arc()

BOOL MFDRV_Arc	(	PHYSDEV	dev,
		INT	left,
		INT	top,
		INT	right,
		INT	bottom,
		INT	xstart,
		INT	ystart,
		INT	xend,
		INT	yend
	)

Definition at line 53 of file graphics.c.

 {
      return MFDRV_MetaParam8(dev, META_ARC, left, top, right, bottom,
                  xstart, ystart, xend, yend);
 }

◆ MFDRV_BeginPath()

BOOL MFDRV_BeginPath ( PHYSDEV dev )

Definition at line 153 of file dc.c.

 {
     return FALSE;
 }

◆ MFDRV_Chord()

BOOL MFDRV_Chord	(	PHYSDEV	dev,
		INT	left,
		INT	top,
		INT	right,
		INT	bottom,
		INT	xstart,
		INT	ystart,
		INT	xend,
		INT	yend
	)

Definition at line 75 of file graphics.c.

 {
     return MFDRV_MetaParam8(dev, META_CHORD, left, top, right, bottom,
                 xstart, ystart, xend, yend);
 }

◆ MFDRV_CloseFigure()

BOOL MFDRV_CloseFigure ( PHYSDEV dev )

Definition at line 158 of file dc.c.

 {
     return FALSE;
 }

◆ MFDRV_CreateBrushIndirect()

INT16 MFDRV_CreateBrushIndirect	(	PHYSDEV	dev,
		HBRUSH	hBrush
	)

Definition at line 149 of file objects.c.

 {
     DWORD size;
     METARECORD *mr;
     LOGBRUSH logbrush;
     BOOL r;
 
     if (!GetObjectA( hBrush, sizeof(logbrush), &logbrush )) return -1;
 
     switch(logbrush.lbStyle)
     {
     case BS_SOLID:
     case BS_NULL:
     case BS_HATCHED:
         {
         LOGBRUSH16 lb16;
 
         lb16.lbStyle = logbrush.lbStyle;
         lb16.lbColor = logbrush.lbColor;
         lb16.lbHatch = logbrush.lbHatch;
         size = sizeof(METARECORD) + sizeof(LOGBRUSH16) - 2;
         mr = HeapAlloc( GetProcessHeap(), 0, size );
         mr->rdSize = size / 2;
         mr->rdFunction = META_CREATEBRUSHINDIRECT;
         memcpy( mr->rdParm, &lb16, sizeof(LOGBRUSH16));
         break;
     }
     case BS_PATTERN:
     case BS_DIBPATTERN:
         {
 #ifdef __REACTOS__
             char buffer[sizeof(BITMAPINFO) + 255 * sizeof(RGBQUAD)]; // ros
 #else
             char buffer[FIELD_OFFSET( BITMAPINFO, bmiColors[256] )];
 #endif
             BITMAPINFO *dst_info, *src_info = (BITMAPINFO *)buffer;
             DWORD info_size;
             char *dst_ptr;
             void *bits;
             UINT usage;
 
             if (!get_brush_bitmap_info( hBrush, src_info, &bits, &usage )) goto done;
 
             info_size = get_dib_info_size( src_info, usage );
         size = FIELD_OFFSET( METARECORD, rdParm[2] ) + info_size + src_info->bmiHeader.biSizeImage;
 
             if (!(mr = HeapAlloc( GetProcessHeap(), 0, size ))) goto done;
         mr->rdFunction = META_DIBCREATEPATTERNBRUSH;
         mr->rdSize = size / 2;
         mr->rdParm[0] = logbrush.lbStyle;
         mr->rdParm[1] = usage;
             dst_info = (BITMAPINFO *)(mr->rdParm + 2);
             memcpy( dst_info, src_info, info_size );
             if (dst_info->bmiHeader.biClrUsed == 1 << dst_info->bmiHeader.biBitCount)
                 dst_info->bmiHeader.biClrUsed = 0;
             dst_ptr = (char *)dst_info + info_size;
 
             /* always return a bottom-up DIB */
             if (dst_info->bmiHeader.biHeight < 0)
             {
                 int i, width_bytes = get_dib_stride( dst_info->bmiHeader.biWidth,
                                                      dst_info->bmiHeader.biBitCount );
                 dst_info->bmiHeader.biHeight = -dst_info->bmiHeader.biHeight;
                 dst_ptr += (dst_info->bmiHeader.biHeight - 1) * width_bytes;
                 for (i = 0; i < dst_info->bmiHeader.biHeight; i++, dst_ptr -= width_bytes)
                     memcpy( dst_ptr, (char *)bits + i * width_bytes, width_bytes );
             }
             else memcpy( dst_ptr, bits, src_info->bmiHeader.biSizeImage );
         break;
     }
 
     default:
         FIXME("Unknown brush style %x\n", logbrush.lbStyle);
         return 0;
     }
     r = MFDRV_WriteRecord( dev, mr, mr->rdSize * 2);
     HeapFree(GetProcessHeap(), 0, mr);
     if( !r )
         return -1;
 done:
     return MFDRV_AddHandle( dev, hBrush );
 }

Referenced by MFDRV_FillRgn(), MFDRV_FrameRgn(), and MFDRV_SelectBrush().

◆ MFDRV_DeleteObject()

BOOL MFDRV_DeleteObject	(	PHYSDEV	dev,
		HGDIOBJ	obj
	)

Definition at line 98 of file objects.c.

 {
     METARECORD mr;
     METAFILEDRV_PDEVICE *physDev = (METAFILEDRV_PDEVICE *)dev;
     INT16 index;
     BOOL ret = TRUE;
 
     index = MFDRV_FindObject(dev, obj);
     if( index < 0 )
         return FALSE;
 
     mr.rdSize = sizeof mr / 2;
     mr.rdFunction = META_DELETEOBJECT;
     mr.rdParm[0] = index;
 
     if(!MFDRV_WriteRecord( dev, &mr, mr.rdSize*2 ))
         ret = FALSE;
 
     physDev->handles[index] = 0;
     physDev->cur_handles--;
     return ret;
 }

◆ MFDRV_Ellipse()

BOOL MFDRV_Ellipse	(	PHYSDEV	dev,
		INT	left,
		INT	top,
		INT	right,
		INT	bottom
	)

Definition at line 85 of file graphics.c.

 {
     return MFDRV_MetaParam4(dev, META_ELLIPSE, left, top, right, bottom);
 }

◆ MFDRV_EndPath()

BOOL MFDRV_EndPath ( PHYSDEV dev )

Definition at line 163 of file dc.c.

 {
     return FALSE;
 }

◆ MFDRV_ExcludeClipRect()

INT MFDRV_ExcludeClipRect	(	PHYSDEV	dev,
		INT	left,
		INT	top,
		INT	right,
		INT	bottom
	)

Definition at line 78 of file dc.c.

 {
     return MFDRV_MetaParam4( dev, META_EXCLUDECLIPRECT, left, top, right, bottom );
 }

◆ MFDRV_ExtFloodFill()

BOOL MFDRV_ExtFloodFill	(	PHYSDEV	dev,
		INT	x,
		INT	y,
		COLORREF	color,
		UINT	fillType
	)

Definition at line 244 of file graphics.c.

 {
     return MFDRV_MetaParam4(dev,META_FLOODFILL,x,y,HIWORD(color),
                 LOWORD(color));
 }

◆ MFDRV_ExtSelectClipRgn()

INT MFDRV_ExtSelectClipRgn	(	PHYSDEV	dev,
		HRGN	hrgn,
		INT	mode
	)

Definition at line 407 of file graphics.c.

 {
     INT16 iRgn;
     INT ret;
 
     if (mode != RGN_COPY) return ERROR;
     if (!hrgn) return NULLREGION;
     iRgn = MFDRV_CreateRegion( dev, hrgn );
     if(iRgn == -1) return ERROR;
     ret = MFDRV_MetaParam1( dev, META_SELECTOBJECT, iRgn ) ? NULLREGION : ERROR;
     MFDRV_MetaParam1( dev, META_DELETEOBJECT, iRgn );
     MFDRV_RemoveHandle( dev, iRgn );
     return ret;
 }

◆ MFDRV_ExtTextOut()

BOOL MFDRV_ExtTextOut	(	PHYSDEV	dev,
		INT	x,
		INT	y,
		UINT	flags,
		const RECT *	lprect,
		LPCWSTR	str,
		UINT	count,
		const INT *	lpDx
	)

Definition at line 75 of file text.c.

 {
     RECT16  rect16;
     LPINT16 lpdx16 = NULL;
     BOOL    ret;
     unsigned int i, j;
     LPSTR       ascii;
     DWORD len;
     CHARSETINFO csi;
     int charset = GetTextCharset( dev->hdc );
     UINT cp = CP_ACP;
 
     if(TranslateCharsetInfo(ULongToPtr(charset), &csi, TCI_SRCCHARSET))
         cp = csi.ciACP;
     else {
         switch(charset) {
     case OEM_CHARSET:
         cp = GetOEMCP();
         break;
     case DEFAULT_CHARSET:
         cp = GetACP();
         break;
 
     case VISCII_CHARSET:
     case TCVN_CHARSET:
     case KOI8_CHARSET:
     case ISO3_CHARSET:
     case ISO4_CHARSET:
     case ISO10_CHARSET:
     case CELTIC_CHARSET:
       /* FIXME: These have no place here, but because x11drv
          enumerates fonts with these (made up) charsets some apps
          might use them and then the FIXME below would become
          annoying.  Now we could pick the intended codepage for
          each of these, but since it's broken anyway we'll just
          use CP_ACP and hope it'll go away...
       */
         cp = CP_ACP;
         break;
 
 
     default:
         FIXME("Can't find codepage for charset %d\n", charset);
         break;
     }
     }
 
 
     TRACE("cp == %d\n", cp);
     len = WideCharToMultiByte(cp, 0, str, count, NULL, 0, NULL, NULL);
     ascii = HeapAlloc(GetProcessHeap(), 0, len);
     WideCharToMultiByte(cp, 0, str, count, ascii, len, NULL, NULL);
     TRACE("mapped %s -> %s\n", debugstr_wn(str, count), debugstr_an(ascii, len));
 
 
     if (lprect)
     {
         rect16.left   = lprect->left;
         rect16.top    = lprect->top;
         rect16.right  = lprect->right;
         rect16.bottom = lprect->bottom;
     }
 
     if(lpDx) {
         lpdx16 = HeapAlloc( GetProcessHeap(), 0, sizeof(INT16)*len );
     for(i = j = 0; i < len; )
         if(IsDBCSLeadByteEx(cp, ascii[i])) {
             lpdx16[i++] = lpDx[j++];
         lpdx16[i++] = 0;
         } else
             lpdx16[i++] = lpDx[j++];
     }
 
     ret = MFDRV_MetaExtTextOut(dev,x,y,flags,lprect?&rect16:NULL,ascii,len,lpdx16);
     HeapFree( GetProcessHeap(), 0, ascii );
     HeapFree( GetProcessHeap(), 0, lpdx16 );
     return ret;
 }

◆ MFDRV_FillPath()

BOOL MFDRV_FillPath ( PHYSDEV dev )

Definition at line 168 of file dc.c.

 {
     return FALSE;
 }

◆ MFDRV_FillRgn()

BOOL MFDRV_FillRgn	(	PHYSDEV	dev,
		HRGN	hrgn,
		HBRUSH	hbrush
	)

Definition at line 376 of file graphics.c.

 {
     INT16 iRgn, iBrush;
     iRgn = MFDRV_CreateRegion( dev, hrgn );
     if(iRgn == -1)
         return FALSE;
     iBrush = MFDRV_CreateBrushIndirect( dev, hbrush );
     if(!iBrush)
         return FALSE;
     return MFDRV_MetaParam2( dev, META_FILLREGION, iRgn, iBrush );
 }

◆ MFDRV_FlattenPath()

BOOL MFDRV_FlattenPath ( PHYSDEV dev )

Definition at line 173 of file dc.c.

 {
     return FALSE;
 }

◆ MFDRV_FrameRgn()

BOOL MFDRV_FrameRgn	(	PHYSDEV	dev,
		HRGN	hrgn,
		HBRUSH	hbrush,
		INT	x,
		INT	y
	)

Definition at line 391 of file graphics.c.

 {
     INT16 iRgn, iBrush;
     iRgn = MFDRV_CreateRegion( dev, hrgn );
     if(iRgn == -1)
         return FALSE;
     iBrush = MFDRV_CreateBrushIndirect( dev, hbrush );
     if(!iBrush)
         return FALSE;
     return MFDRV_MetaParam4( dev, META_FRAMEREGION, iRgn, iBrush, x, y );
 }

◆ MFDRV_IntersectClipRect()

INT MFDRV_IntersectClipRect	(	PHYSDEV	dev,
		INT	left,
		INT	top,
		INT	right,
		INT	bottom
	)

Definition at line 73 of file dc.c.

 {
     return MFDRV_MetaParam4( dev, META_INTERSECTCLIPRECT, left, top, right, bottom );
 }

◆ MFDRV_InvertRgn()

BOOL MFDRV_InvertRgn	(	PHYSDEV	dev,
		HRGN	hrgn
	)

Definition at line 363 of file graphics.c.

 {
     INT16 index;
     index = MFDRV_CreateRegion( dev, hrgn );
     if(index == -1)
         return FALSE;
     return MFDRV_MetaParam1( dev, META_INVERTREGION, index );
 }

◆ MFDRV_LineTo()

BOOL MFDRV_LineTo	(	PHYSDEV	dev,
		INT	x,
		INT	y
	)

Definition at line 44 of file graphics.c.

 {
      return MFDRV_MetaParam2(dev, META_LINETO, x, y);
 }

◆ MFDRV_MetaParam0()

BOOL MFDRV_MetaParam0	(	PHYSDEV	dev,
		short	func
	)

Definition at line 518 of file init.c.

 {
     char buffer[8];
     METARECORD *mr = (METARECORD *)&buffer;
 
     mr->rdSize = 3;
     mr->rdFunction = func;
     return MFDRV_WriteRecord( dev, mr, mr->rdSize * 2);
 }

Referenced by MFDRV_CloseMetaFile(), and MFDRV_SaveDC().

◆ MFDRV_MetaParam1()

BOOL MFDRV_MetaParam1	(	PHYSDEV	dev,
		short	func,
		short	param1
	)

Definition at line 532 of file init.c.

 {
     char buffer[8];
     METARECORD *mr = (METARECORD *)&buffer;
     WORD *params = mr->rdParm;
 
     mr->rdSize = 4;
     mr->rdFunction = func;
     params[0] = param1;
     return MFDRV_WriteRecord( dev, mr, mr->rdSize * 2);
 }

Referenced by MFDRV_ExtSelectClipRgn(), MFDRV_InvertRgn(), MFDRV_PaintRgn(), MFDRV_RestoreDC(), MFDRV_SetBkMode(), MFDRV_SetMapMode(), MFDRV_SetPolyFillMode(), MFDRV_SetRelAbs(), MFDRV_SetROP2(), MFDRV_SetStretchBltMode(), and MFDRV_SetTextCharacterExtra().

◆ MFDRV_MetaParam2()

BOOL MFDRV_MetaParam2	(	PHYSDEV	dev,
		short	func,
		short	param1,
		short	param2
	)

Definition at line 548 of file init.c.

 {
     char buffer[10];
     METARECORD *mr = (METARECORD *)&buffer;
     WORD *params = mr->rdParm;
 
     mr->rdSize = 5;
     mr->rdFunction = func;
     params[0] = param2;
     params[1] = param1;
     return MFDRV_WriteRecord( dev, mr, mr->rdSize * 2);
 }

Referenced by MFDRV_FillRgn(), MFDRV_LineTo(), MFDRV_MoveTo(), MFDRV_OffsetClipRgn(), MFDRV_OffsetViewportOrgEx(), MFDRV_OffsetWindowOrgEx(), MFDRV_SetBkColor(), MFDRV_SetMapperFlags(), MFDRV_SetTextAlign(), MFDRV_SetTextColor(), MFDRV_SetTextJustification(), MFDRV_SetViewportExtEx(), MFDRV_SetViewportOrgEx(), MFDRV_SetWindowExtEx(), and MFDRV_SetWindowOrgEx().

◆ MFDRV_MetaParam4()

BOOL MFDRV_MetaParam4	(	PHYSDEV	dev,
		short	func,
		short	param1,
		short	param2,
		short	param3,
		short	param4
	)

Definition at line 566 of file init.c.

 {
     char buffer[14];
     METARECORD *mr = (METARECORD *)&buffer;
     WORD *params = mr->rdParm;
 
     mr->rdSize = 7;
     mr->rdFunction = func;
     params[0] = param4;
     params[1] = param3;
     params[2] = param2;
     params[3] = param1;
     return MFDRV_WriteRecord( dev, mr, mr->rdSize * 2);
 }

Referenced by MFDRV_Ellipse(), MFDRV_ExcludeClipRect(), MFDRV_ExtFloodFill(), MFDRV_FrameRgn(), MFDRV_IntersectClipRect(), MFDRV_Rectangle(), MFDRV_ScaleViewportExtEx(), MFDRV_ScaleWindowExtEx(), and MFDRV_SetPixel().

◆ MFDRV_MetaParam6()

BOOL MFDRV_MetaParam6	(	PHYSDEV	dev,
		short	func,
		short	param1,
		short	param2,
		short	param3,
		short	param4,
		short	param5,
		short	param6
	)

Definition at line 587 of file init.c.

 {
     char buffer[18];
     METARECORD *mr = (METARECORD *)&buffer;
     WORD *params = mr->rdParm;
 
     mr->rdSize = 9;
     mr->rdFunction = func;
     params[0] = param6;
     params[1] = param5;
     params[2] = param4;
     params[3] = param3;
     params[4] = param2;
     params[5] = param1;
     return MFDRV_WriteRecord( dev, mr, mr->rdSize * 2);
 }

Referenced by MFDRV_PatBlt(), and MFDRV_RoundRect().

◆ MFDRV_MetaParam8()

BOOL MFDRV_MetaParam8	(	PHYSDEV	dev,
		short	func,
		short	param1,
		short	param2,
		short	param3,
		short	param4,
		short	param5,
		short	param6,
		short	param7,
		short	param8
	)

Definition at line 609 of file init.c.

 {
     char buffer[22];
     METARECORD *mr = (METARECORD *)&buffer;
     WORD *params = mr->rdParm;
 
     mr->rdSize = 11;
     mr->rdFunction = func;
     params[0] = param8;
     params[1] = param7;
     params[2] = param6;
     params[3] = param5;
     params[4] = param4;
     params[5] = param3;
     params[6] = param2;
     params[7] = param1;
     return MFDRV_WriteRecord( dev, mr, mr->rdSize * 2);
 }

Referenced by MFDRV_Arc(), MFDRV_Chord(), and MFDRV_Pie().

◆ MFDRV_MoveTo()

BOOL MFDRV_MoveTo	(	PHYSDEV	dev,
		INT	x,
		INT	y
	)

Definition at line 36 of file graphics.c.

 {
     return MFDRV_MetaParam2(dev,META_MOVETO,x,y);
 }

◆ MFDRV_OffsetClipRgn()

INT MFDRV_OffsetClipRgn	(	PHYSDEV	dev,
		INT	x,
		INT	y
	)

Definition at line 83 of file dc.c.

 {
     return MFDRV_MetaParam2( dev, META_OFFSETCLIPRGN, x, y );
 }

◆ MFDRV_OffsetViewportOrgEx()

BOOL MFDRV_OffsetViewportOrgEx	(	PHYSDEV	dev,
		INT	x,
		INT	y,
		POINT *	pt
	)

Definition at line 113 of file dc.c.

 {
     return MFDRV_MetaParam2( dev, META_OFFSETVIEWPORTORG, x, y );
 }

◆ MFDRV_OffsetWindowOrgEx()

BOOL MFDRV_OffsetWindowOrgEx	(	PHYSDEV	dev,
		INT	x,
		INT	y,
		POINT *	pt
	)

Definition at line 118 of file dc.c.

 {
     return MFDRV_MetaParam2( dev, META_OFFSETWINDOWORG, x, y );
 }

◆ MFDRV_PaintRgn()

BOOL MFDRV_PaintRgn	(	PHYSDEV	dev,
		HRGN	hrgn
	)

Definition at line 350 of file graphics.c.

 {
     INT16 index;
     index = MFDRV_CreateRegion( dev, hrgn );
     if(index == -1)
         return FALSE;
     return MFDRV_MetaParam1( dev, META_PAINTREGION, index );
 }

◆ MFDRV_PatBlt()

BOOL MFDRV_PatBlt	(	PHYSDEV	dev,
		struct bitblt_coords *	dst,
		DWORD	rop
	)

Definition at line 31 of file bitblt.c.

 {
     MFDRV_MetaParam6( dev, META_PATBLT, dst->log_x, dst->log_y, dst->log_width, dst->log_height,
                       HIWORD(rop), LOWORD(rop) );
     return TRUE;
 }

◆ MFDRV_Pie()

BOOL MFDRV_Pie	(	PHYSDEV	dev,
		INT	left,
		INT	top,
		INT	right,
		INT	bottom,
		INT	xstart,
		INT	ystart,
		INT	xend,
		INT	yend
	)

Definition at line 64 of file graphics.c.

 {
     return MFDRV_MetaParam8(dev, META_PIE, left, top, right, bottom,
                 xstart, ystart, xend, yend);
 }

◆ MFDRV_PolyBezier()

BOOL MFDRV_PolyBezier	(	PHYSDEV	dev,
		const POINT *	pt,
		DWORD	count
	)

Definition at line 428 of file graphics.c.

 {
     return FALSE;
 }

◆ MFDRV_PolyBezierTo()

BOOL MFDRV_PolyBezierTo	(	PHYSDEV	dev,
		const POINT *	pt,
		DWORD	count
	)

Definition at line 438 of file graphics.c.

 {
     return FALSE;
 }

◆ MFDRV_Polygon()

BOOL MFDRV_Polygon	(	PHYSDEV	dev,
		const POINT *	pt,
		INT	count
	)

Definition at line 167 of file graphics.c.

 {
     int i;
     POINTS *pts;
     BOOL ret;
 
     pts = HeapAlloc( GetProcessHeap(), 0, sizeof(POINTS)*count );
     if(!pts) return FALSE;
     for (i=count;i--;)
     {
         pts[i].x = pt[i].x;
         pts[i].y = pt[i].y;
     }
     ret = MFDRV_MetaPoly(dev, META_POLYGON, pts, count);
 
     HeapFree( GetProcessHeap(), 0, pts );
     return ret;
 }

◆ MFDRV_Polyline()

BOOL MFDRV_Polyline	(	PHYSDEV	dev,
		const POINT *	pt,
		INT	count
	)

Definition at line 144 of file graphics.c.

 {
     int i;
     POINTS *pts;
     BOOL ret;
 
     pts = HeapAlloc( GetProcessHeap(), 0, sizeof(POINTS)*count );
     if(!pts) return FALSE;
     for (i=count;i--;)
     {
         pts[i].x = pt[i].x;
         pts[i].y = pt[i].y;
     }
     ret = MFDRV_MetaPoly(dev, META_POLYLINE, pts, count);
 
     HeapFree( GetProcessHeap(), 0, pts );
     return ret;
 }

◆ MFDRV_PolyPolygon()

BOOL MFDRV_PolyPolygon	(	PHYSDEV	dev,
		const POINT *	pt,
		const INT *	counts,
		UINT	polygons
	)

Definition at line 190 of file graphics.c.

 {
     BOOL ret;
     DWORD len;
     METARECORD *mr;
     unsigned int i,j;
     POINTS *pts;
     INT16 totalpoint16 = 0;
     INT16 * pointcounts;
 
     for (i=0;i<polygons;i++) {
          totalpoint16 += counts[i];
     }
 
     /* allocate space for all points */
     pts=HeapAlloc( GetProcessHeap(), 0, sizeof(POINTS) * totalpoint16 );
     pointcounts = HeapAlloc( GetProcessHeap(), 0, sizeof(INT16) * totalpoint16 );
 
     /* copy point counts */
     for (i=0;i<polygons;i++) {
           pointcounts[i] = counts[i];
     }
 
     /* convert all points */
     for (j = totalpoint16; j--;){
         pts[j].x = pt[j].x;
         pts[j].y = pt[j].y;
     }
 
     len = sizeof(METARECORD) + sizeof(WORD) + polygons*sizeof(INT16) + totalpoint16*sizeof(*pts);
 
     if (!(mr = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, len ))) {
          HeapFree( GetProcessHeap(), 0, pts );
          HeapFree( GetProcessHeap(), 0, pointcounts );
          return FALSE;
     }
 
     mr->rdSize = len /2;
     mr->rdFunction = META_POLYPOLYGON;
     *(mr->rdParm) = polygons;
     memcpy(mr->rdParm + 1, pointcounts, polygons*sizeof(INT16));
     memcpy(mr->rdParm + 1+polygons, pts , totalpoint16*sizeof(*pts));
     ret = MFDRV_WriteRecord( dev, mr, mr->rdSize * 2);
 
     HeapFree( GetProcessHeap(), 0, pts );
     HeapFree( GetProcessHeap(), 0, pointcounts );
     HeapFree( GetProcessHeap(), 0, mr);
     return ret;
 }

◆ MFDRV_RealizePalette()

UINT MFDRV_RealizePalette	(	PHYSDEV	dev,
		HPALETTE	hPalette,
		BOOL	primary
	)

Definition at line 449 of file objects.c.

 {
     char buffer[sizeof(METARECORD) - sizeof(WORD)];
     METARECORD *mr = (METARECORD *)&buffer;
 
     mr->rdSize = (sizeof(METARECORD) - sizeof(WORD)) / sizeof(WORD);
     mr->rdFunction = META_REALIZEPALETTE;
 
     if (!(MFDRV_WriteRecord( dev, mr, mr->rdSize * sizeof(WORD)))) return 0;
 
     /* The return value is suppose to be the number of entries
        in the logical palette mapped to the system palette or 0
        if the function failed. Since it's not trivial here to
        get that kind of information and since it's of little
        use in the case of metafiles, we'll always return 1. */
     return 1;
 }

◆ MFDRV_Rectangle()

BOOL MFDRV_Rectangle	(	PHYSDEV	dev,
		INT	left,
		INT	top,
		INT	right,
		INT	bottom
	)

Definition at line 93 of file graphics.c.

 {
     return MFDRV_MetaParam4(dev, META_RECTANGLE, left, top, right, bottom);
 }

◆ MFDRV_RemoveHandle()

BOOL MFDRV_RemoveHandle	(	PHYSDEV	dev,
		UINT	index
	)

Definition at line 64 of file objects.c.

 {
     METAFILEDRV_PDEVICE *physDev = (METAFILEDRV_PDEVICE *)dev;
     BOOL ret = FALSE;
 
     if (index < physDev->handles_size && physDev->handles[index])
     {
         physDev->handles[index] = 0;
         physDev->cur_handles--;
         ret = TRUE;
     }
     return ret;
 }

Referenced by MFDRV_ExtSelectClipRgn().

◆ MFDRV_RestoreDC()

BOOL MFDRV_RestoreDC	(	PHYSDEV	dev,
		INT	level
	)

Definition at line 28 of file dc.c.

 {
     return MFDRV_MetaParam1( dev, META_RESTOREDC, level );
 }

◆ MFDRV_RoundRect()

BOOL MFDRV_RoundRect	(	PHYSDEV	dev,
		INT	left,
		INT	top,
		INT	right,
		INT	bottom,
		INT	ell_width,
		INT	ell_height
	)

Definition at line 101 of file graphics.c.

 {
     return MFDRV_MetaParam6(dev, META_ROUNDRECT, left, top, right, bottom,
                 ell_width, ell_height);
 }

◆ MFDRV_SaveDC()

INT MFDRV_SaveDC ( PHYSDEV dev )

Definition at line 23 of file dc.c.

 {
     return MFDRV_MetaParam0( dev, META_SAVEDC );
 }

◆ MFDRV_ScaleViewportExtEx()

BOOL MFDRV_ScaleViewportExtEx	(	PHYSDEV	dev,
		INT	xNum,
		INT	xDenom,
		INT	yNum,
		INT	yDenom,
		SIZE *	size
	)

Definition at line 123 of file dc.c.

 {
     return MFDRV_MetaParam4( dev, META_SCALEVIEWPORTEXT, xNum, xDenom, yNum, yDenom );
 }

◆ MFDRV_ScaleWindowExtEx()

BOOL MFDRV_ScaleWindowExtEx	(	PHYSDEV	dev,
		INT	xNum,
		INT	xDenom,
		INT	yNum,
		INT	yDenom,
		SIZE *	size
	)

Definition at line 128 of file dc.c.

 {
     return MFDRV_MetaParam4( dev, META_SCALEWINDOWEXT, xNum, xDenom, yNum, yDenom );
 }

◆ MFDRV_SelectBitmap()

HBITMAP MFDRV_SelectBitmap	(	PHYSDEV	dev,
		HBITMAP	handle
	)

Definition at line 140 of file objects.c.

 {
     return 0;
 }

◆ MFDRV_SelectBrush()

HBRUSH MFDRV_SelectBrush	(	PHYSDEV	dev,
		HBRUSH	hbrush,
		const struct brush_pattern *	pattern
	)

Definition at line 236 of file objects.c.

 {
     INT16 index;
 
     index = MFDRV_FindObject(dev, hbrush);
     if( index < 0 )
     {
         index = MFDRV_CreateBrushIndirect( dev, hbrush );
         if( index < 0 )
             return 0;
         GDI_hdc_using_object(hbrush, dev->hdc);
     }
     return MFDRV_SelectObject( dev, index ) ? hbrush : 0;
 }

◆ MFDRV_SelectClipPath()

BOOL MFDRV_SelectClipPath	(	PHYSDEV	dev,
		INT	iMode
	)

Definition at line 178 of file dc.c.

 {
     return FALSE;
 }

◆ MFDRV_SelectFont()

HFONT MFDRV_SelectFont	(	PHYSDEV	dev,
		HFONT	handle,
		UINT *	aa_flags
	)

Definition at line 292 of file objects.c.

 {
     LOGFONTW font;
     INT16 index;
 
     *aa_flags = GGO_BITMAP;  /* no point in anti-aliasing on metafiles */
     index = MFDRV_FindObject(dev, hfont);
     if( index < 0 )
     {
         if (!GetObjectW( hfont, sizeof(font), &font ))
             return 0;
         index = MFDRV_CreateFontIndirect(dev, hfont, &font);
         if( index < 0 )
             return 0;
         GDI_hdc_using_object(hfont, dev->hdc);
     }
     return MFDRV_SelectObject( dev, index ) ? hfont : 0;
 }

◆ MFDRV_SelectPalette()

HPALETTE MFDRV_SelectPalette	(	PHYSDEV	dev,
		HPALETTE	hPalette,
		BOOL	bForceBackground
	)

Definition at line 413 of file objects.c.

 {
 #define PALVERSION 0x0300
 
     PLOGPALETTE logPalette;
     WORD        wNumEntries = 0;
     BOOL        creationSucceed;
     int         sizeofPalette;
 
     GetObjectA(hPalette, sizeof(WORD), &wNumEntries);
 
     if (wNumEntries == 0) return 0;
 
     sizeofPalette = sizeof(LOGPALETTE) + ((wNumEntries-1) * sizeof(PALETTEENTRY));
     logPalette = HeapAlloc( GetProcessHeap(), 0, sizeofPalette );
 
     if (logPalette == NULL) return 0;
 
     logPalette->palVersion = PALVERSION;
     logPalette->palNumEntries = wNumEntries;
 
     GetPaletteEntries(hPalette, 0, wNumEntries, logPalette->palPalEntry);
 
     creationSucceed = MFDRV_CreatePalette( dev, hPalette, logPalette, sizeofPalette );
 
     HeapFree( GetProcessHeap(), 0, logPalette );
 
     if (creationSucceed)
         return hPalette;
 
     return 0;
 }

◆ MFDRV_SelectPen()

HPEN MFDRV_SelectPen	(	PHYSDEV	dev,
		HPEN	handle,
		const struct brush_pattern *	pattern
	)

Definition at line 331 of file objects.c.

 {
     LOGPEN16 logpen;
     INT16 index;
 
     index = MFDRV_FindObject(dev, hpen);
     if( index < 0 )
     {
         /* must be an extended pen */
         INT size = GetObjectW( hpen, 0, NULL );
 
         if (!size) return 0;
 
         if (size == sizeof(LOGPEN))
         {
             LOGPEN pen;
 
             GetObjectW( hpen, sizeof(pen), &pen );
             logpen.lopnStyle   = pen.lopnStyle;
             logpen.lopnWidth.x = pen.lopnWidth.x;
             logpen.lopnWidth.y = pen.lopnWidth.y;
             logpen.lopnColor   = pen.lopnColor;
         }
         else  /* must be an extended pen */
         {
             EXTLOGPEN *elp = HeapAlloc( GetProcessHeap(), 0, size );
 
             GetObjectW( hpen, size, elp );
             /* FIXME: add support for user style pens */
             logpen.lopnStyle = elp->elpPenStyle;
             logpen.lopnWidth.x = elp->elpWidth;
             logpen.lopnWidth.y = 0;
             logpen.lopnColor = elp->elpColor;
 
             HeapFree( GetProcessHeap(), 0, elp );
         }
 
         index = MFDRV_CreatePenIndirect( dev, hpen, &logpen );
         if( index < 0 )
             return 0;
         GDI_hdc_using_object(hpen, dev->hdc);
     }
     return MFDRV_SelectObject( dev, index ) ? hpen : 0;
 }

◆ MFDRV_SetBkColor()

COLORREF MFDRV_SetBkColor	(	PHYSDEV	dev,
		COLORREF	color
	)

Definition at line 43 of file dc.c.

 {
     return MFDRV_MetaParam2(dev, META_SETBKCOLOR, HIWORD(color), LOWORD(color)) ? color : CLR_INVALID;
 }

◆ MFDRV_SetBkMode()

INT MFDRV_SetBkMode	(	PHYSDEV	dev,
		INT	mode
	)

Definition at line 38 of file dc.c.

 {
     return MFDRV_MetaParam1( dev, META_SETBKMODE, (WORD)mode) ? mode : 0;
 }

◆ MFDRV_SetDCBrushColor()

COLORREF MFDRV_SetDCBrushColor	(	PHYSDEV	dev,
		COLORREF	color
	)

Definition at line 198 of file dc.c.

 {
     return CLR_INVALID;
 }

◆ MFDRV_SetDCPenColor()

COLORREF MFDRV_SetDCPenColor	(	PHYSDEV	dev,
		COLORREF	color
	)

Definition at line 203 of file dc.c.

 {
     return CLR_INVALID;
 }

◆ MFDRV_SetDIBitsToDevice()

INT MFDRV_SetDIBitsToDevice	(	PHYSDEV	dev,
		INT	xDest,
		INT	yDest,
		DWORD	cx,
		DWORD	cy,
		INT	xSrc,
		INT	ySrc,
		UINT	startscan,
		UINT	lines,
		LPCVOID	bits,
		BITMAPINFO *	info,
		UINT	coloruse
	)

Definition at line 166 of file bitblt.c.

 {
     DWORD infosize = get_dib_info_size(info, coloruse);
     DWORD len = sizeof(METARECORD) + 8 * sizeof(WORD) + infosize + info->bmiHeader.biSizeImage;
     METARECORD *mr = HeapAlloc( GetProcessHeap(), 0, len );
     if(!mr) return 0;
 
     mr->rdSize = len / 2;
     mr->rdFunction = META_SETDIBTODEV;
     mr->rdParm[0] = coloruse;
     mr->rdParm[1] = lines;
     mr->rdParm[2] = startscan;
     mr->rdParm[3] = (INT16)ySrc;
     mr->rdParm[4] = (INT16)xSrc;
     mr->rdParm[5] = (INT16)cy;
     mr->rdParm[6] = (INT16)cx;
     mr->rdParm[7] = (INT16)yDst;
     mr->rdParm[8] = (INT16)xDst;
     memcpy(mr->rdParm + 9, info, infosize);
     memcpy(mr->rdParm + 9 + infosize / 2, bits, info->bmiHeader.biSizeImage);
     MFDRV_WriteRecord( dev, mr, mr->rdSize * 2 );
     HeapFree( GetProcessHeap(), 0, mr );
     return lines;
 }

◆ MFDRV_SetMapMode()

INT MFDRV_SetMapMode	(	PHYSDEV	dev,
		INT	mode
	)

Definition at line 88 of file dc.c.

 {
     return MFDRV_MetaParam1( dev, META_SETMAPMODE, mode );
 }

◆ MFDRV_SetMapperFlags()

DWORD MFDRV_SetMapperFlags	(	PHYSDEV	dev,
		DWORD	flags
	)

Definition at line 143 of file dc.c.

 {
     return MFDRV_MetaParam2( dev, META_SETMAPPERFLAGS, HIWORD(flags), LOWORD(flags) ) ? flags : GDI_ERROR;
 }

◆ MFDRV_SetPixel()

COLORREF MFDRV_SetPixel	(	PHYSDEV	dev,
		INT	x,
		INT	y,
		COLORREF	color
	)

Definition at line 111 of file graphics.c.

 {
     return MFDRV_MetaParam4(dev, META_SETPIXEL, x, y,HIWORD(color),
                 LOWORD(color));
 }

◆ MFDRV_SetPolyFillMode()

INT MFDRV_SetPolyFillMode	(	PHYSDEV	dev,
		INT	mode
	)

Definition at line 63 of file dc.c.

 {
     return MFDRV_MetaParam1( dev, META_SETPOLYFILLMODE, (WORD)mode) ? mode : 0;
 }

◆ MFDRV_SetRelAbs()

INT MFDRV_SetRelAbs	(	PHYSDEV	dev,
		INT	mode
	)

Definition at line 58 of file dc.c.

 {
     return MFDRV_MetaParam1( dev, META_SETRELABS, (WORD)mode) ? mode : 0;
 }

◆ MFDRV_SetROP2()

INT MFDRV_SetROP2	(	PHYSDEV	dev,
		INT	rop
	)

Definition at line 53 of file dc.c.

 {
     return MFDRV_MetaParam1( dev, META_SETROP2, (WORD)rop) ? rop : 0;
 }

◆ MFDRV_SetStretchBltMode()

INT MFDRV_SetStretchBltMode	(	PHYSDEV	dev,
		INT	mode
	)

Definition at line 68 of file dc.c.

 {
     return MFDRV_MetaParam1( dev, META_SETSTRETCHBLTMODE, (WORD)mode) ? mode : 0;
 }

◆ MFDRV_SetTextAlign()

UINT MFDRV_SetTextAlign	(	PHYSDEV	dev,
		UINT	align
	)

Definition at line 33 of file dc.c.

 {
     return MFDRV_MetaParam2( dev, META_SETTEXTALIGN, HIWORD(align), LOWORD(align)) ? align : GDI_ERROR;
 }

◆ MFDRV_SetTextCharacterExtra()

INT MFDRV_SetTextCharacterExtra	(	PHYSDEV	dev,
		INT	extra
	)

Definition at line 138 of file dc.c.

 {
     return MFDRV_MetaParam1( dev, META_SETTEXTCHAREXTRA, extra ) ? extra : 0x80000000;
 }

◆ MFDRV_SetTextColor()

COLORREF MFDRV_SetTextColor	(	PHYSDEV	dev,
		COLORREF	color
	)

Definition at line 48 of file dc.c.

 {
     return MFDRV_MetaParam2(dev, META_SETTEXTCOLOR, HIWORD(color), LOWORD(color)) ? color : CLR_INVALID;
 }

◆ MFDRV_SetTextJustification()

BOOL MFDRV_SetTextJustification	(	PHYSDEV	dev,
		INT	extra,
		INT	breaks
	)

Definition at line 133 of file dc.c.

 {
     return MFDRV_MetaParam2( dev, META_SETTEXTJUSTIFICATION, extra, breaks );
 }

◆ MFDRV_SetViewportExtEx()

BOOL MFDRV_SetViewportExtEx	(	PHYSDEV	dev,
		INT	x,
		INT	y,
		SIZE *	size
	)

Definition at line 93 of file dc.c.

 {
     return MFDRV_MetaParam2( dev, META_SETVIEWPORTEXT, x, y );
 }

◆ MFDRV_SetViewportOrgEx()

BOOL MFDRV_SetViewportOrgEx	(	PHYSDEV	dev,
		INT	x,
		INT	y,
		POINT *	pt
	)

Definition at line 98 of file dc.c.

 {
     return MFDRV_MetaParam2( dev, META_SETVIEWPORTORG, x, y );
 }

◆ MFDRV_SetWindowExtEx()

BOOL MFDRV_SetWindowExtEx	(	PHYSDEV	dev,
		INT	x,
		INT	y,
		SIZE *	size
	)

Definition at line 103 of file dc.c.

 {
     return MFDRV_MetaParam2( dev, META_SETWINDOWEXT, x, y );
 }

◆ MFDRV_SetWindowOrgEx()

BOOL MFDRV_SetWindowOrgEx	(	PHYSDEV	dev,
		INT	x,
		INT	y,
		POINT *	pt
	)

Definition at line 108 of file dc.c.

 {
     return MFDRV_MetaParam2( dev, META_SETWINDOWORG, x, y );
 }

◆ MFDRV_StretchBlt()

BOOL MFDRV_StretchBlt	(	PHYSDEV	devDst,
		struct bitblt_coords *	dst,
		PHYSDEV	devSrc,
		struct bitblt_coords *	src,
		DWORD	rop
	)

Definition at line 47 of file bitblt.c.

 {
     BOOL ret;
     DWORD len;
     METARECORD *mr;
     BITMAP BM;
 #ifdef STRETCH_VIA_DIB
     LPBITMAPINFOHEADER lpBMI;
     WORD nBPP;
 #endif
     HBITMAP hBitmap = GetCurrentObject(devSrc->hdc, OBJ_BITMAP);
 
     if (devSrc->funcs == devDst->funcs) return FALSE;  /* can't use a metafile DC as source */
 
     if (GetObjectW(hBitmap, sizeof(BITMAP), &BM) != sizeof(BITMAP))
     {
         WARN("bad bitmap object %p passed for hdc %p\n", hBitmap, devSrc->hdc);
         return FALSE;
     }
 #ifdef STRETCH_VIA_DIB
     nBPP = BM.bmPlanes * BM.bmBitsPixel;
     if(nBPP > 8) nBPP = 24; /* FIXME Can't get 16bpp to work for some reason */
     len = sizeof(METARECORD) + 10 * sizeof(INT16)
             + sizeof(BITMAPINFOHEADER) + (nBPP <= 8 ? 1 << nBPP: 0) * sizeof(RGBQUAD)
               + get_dib_stride( BM.bmWidth, nBPP ) * BM.bmHeight;
     if (!(mr = HeapAlloc( GetProcessHeap(), 0, len)))
     return FALSE;
     mr->rdFunction = META_DIBSTRETCHBLT;
     lpBMI=(LPBITMAPINFOHEADER)(mr->rdParm+10);
     lpBMI->biSize      = sizeof(BITMAPINFOHEADER);
     lpBMI->biWidth     = BM.bmWidth;
     lpBMI->biHeight    = BM.bmHeight;
     lpBMI->biPlanes    = 1;
     lpBMI->biBitCount  = nBPP;
     lpBMI->biSizeImage = get_dib_image_size( (BITMAPINFO *)lpBMI );
     lpBMI->biClrUsed   = nBPP <= 8 ? 1 << nBPP : 0;
     lpBMI->biCompression = BI_RGB;
     lpBMI->biXPelsPerMeter = MulDiv(GetDeviceCaps(devSrc->hdc,LOGPIXELSX),3937,100);
     lpBMI->biYPelsPerMeter = MulDiv(GetDeviceCaps(devSrc->hdc,LOGPIXELSY),3937,100);
     lpBMI->biClrImportant  = 0;                          /* 1 meter  = 39.37 inch */
 
     TRACE("MF_StretchBltViaDIB->len = %d  rop=%x  PixYPM=%d Caps=%d\n",
       len,rop,lpBMI->biYPelsPerMeter,GetDeviceCaps(devSrc->hdc, LOGPIXELSY));
 
     if (GetDIBits(devSrc->hdc, hBitmap, 0, (UINT)lpBMI->biHeight,
                   (LPSTR)lpBMI + get_dib_info_size( (BITMAPINFO *)lpBMI, DIB_RGB_COLORS ),
                   (LPBITMAPINFO)lpBMI, DIB_RGB_COLORS))
 #else
     len = sizeof(METARECORD) + 15 * sizeof(INT16) + BM.bmWidthBytes * BM.bmHeight;
     if (!(mr = HeapAlloc( GetProcessHeap(), 0, len )))
     return FALSE;
     mr->rdFunction = META_STRETCHBLT;
     *(mr->rdParm +10) = BM.bmWidth;
     *(mr->rdParm +11) = BM.bmHeight;
     *(mr->rdParm +12) = BM.bmWidthBytes;
     *(mr->rdParm +13) = BM.bmPlanes;
     *(mr->rdParm +14) = BM.bmBitsPixel;
     TRACE("len = %ld  rop=%lx\n", len, rop);
     if (GetBitmapBits( hBitmap, BM.bmWidthBytes * BM.bmHeight, mr->rdParm + 15))
 #endif
     {
       mr->rdSize = len / sizeof(INT16);
       *(mr->rdParm) = LOWORD(rop);
       *(mr->rdParm + 1) = HIWORD(rop);
       *(mr->rdParm + 2) = src->log_height;
       *(mr->rdParm + 3) = src->log_width;
       *(mr->rdParm + 4) = src->log_y;
       *(mr->rdParm + 5) = src->log_x;
       *(mr->rdParm + 6) = dst->log_height;
       *(mr->rdParm + 7) = dst->log_width;
       *(mr->rdParm + 8) = dst->log_y;
       *(mr->rdParm + 9) = dst->log_x;
       ret = MFDRV_WriteRecord( devDst, mr, mr->rdSize * 2);
     }
     else
         ret = FALSE;
     HeapFree( GetProcessHeap(), 0, mr);
     return ret;
 }

◆ MFDRV_StretchDIBits()

INT MFDRV_StretchDIBits	(	PHYSDEV	dev,
		INT	xDst,
		INT	yDst,
		INT	widthDst,
		INT	heightDst,
		INT	xSrc,
		INT	ySrc,
		INT	widthSrc,
		INT	heightSrc,
		const void *	bits,
		BITMAPINFO *	info,
		UINT	wUsage,
		DWORD	dwRop
	)

Definition at line 132 of file bitblt.c.

 {
     DWORD infosize = get_dib_info_size(info, wUsage);
     DWORD len = sizeof(METARECORD) + 10 * sizeof(WORD) + infosize + info->bmiHeader.biSizeImage;
     METARECORD *mr = HeapAlloc( GetProcessHeap(), 0, len );
     if(!mr) return 0;
 
     mr->rdSize = len / 2;
     mr->rdFunction = META_STRETCHDIB;
     mr->rdParm[0] = LOWORD(dwRop);
     mr->rdParm[1] = HIWORD(dwRop);
     mr->rdParm[2] = wUsage;
     mr->rdParm[3] = (INT16)heightSrc;
     mr->rdParm[4] = (INT16)widthSrc;
     mr->rdParm[5] = (INT16)ySrc;
     mr->rdParm[6] = (INT16)xSrc;
     mr->rdParm[7] = (INT16)heightDst;
     mr->rdParm[8] = (INT16)widthDst;
     mr->rdParm[9] = (INT16)yDst;
     mr->rdParm[10] = (INT16)xDst;
     memcpy(mr->rdParm + 11, info, infosize);
     memcpy(mr->rdParm + 11 + infosize / 2, bits, info->bmiHeader.biSizeImage);
     MFDRV_WriteRecord( dev, mr, mr->rdSize * 2 );
     HeapFree( GetProcessHeap(), 0, mr );
     return heightSrc;
 }

◆ MFDRV_StrokeAndFillPath()

BOOL MFDRV_StrokeAndFillPath ( PHYSDEV dev )

Definition at line 183 of file dc.c.

 {
     return FALSE;
 }

◆ MFDRV_StrokePath()

BOOL MFDRV_StrokePath ( PHYSDEV dev )

Definition at line 188 of file dc.c.

 {
     return FALSE;
 }

◆ MFDRV_WidenPath()

BOOL MFDRV_WidenPath ( PHYSDEV dev )

Definition at line 193 of file dc.c.

 {
     return FALSE;
 }

◆ MFDRV_WriteRecord()

BOOL MFDRV_WriteRecord	(	PHYSDEV	dev,
		METARECORD *	mr,
		DWORD	rlen
	)

Definition at line 475 of file init.c.

 {
     DWORD len, size;
     METAHEADER *mh;
     METAFILEDRV_PDEVICE *physDev = (METAFILEDRV_PDEVICE *)dev;
 
     switch(physDev->mh->mtType)
     {
     case METAFILE_MEMORY:
     len = physDev->mh->mtSize * 2 + rlen;
     /* reallocate memory if needed */
         size = HeapSize( GetProcessHeap(), 0, physDev->mh );
         if (len > size)
         {
             /*expand size*/
             size += size / 2 + rlen;
             mh = HeapReAlloc( GetProcessHeap(), 0, physDev->mh, size);
             if (!mh) return FALSE;
             physDev->mh = mh;
             TRACE("Reallocated metafile: new size is %d\n",size);
         }
     memcpy((WORD *)physDev->mh + physDev->mh->mtSize, mr, rlen);
         break;
     case METAFILE_DISK:
         TRACE("Writing record to disk\n");
         if (!WriteFile(physDev->hFile, mr, rlen, NULL, NULL))
         return FALSE;
         break;
     default:
         ERR("Unknown metafile type %d\n", physDev->mh->mtType );
         return FALSE;
     }
 
     physDev->mh->mtSize += rlen / 2;
     physDev->mh->mtMaxRecord = max(physDev->mh->mtMaxRecord, rlen / 2);
     return TRUE;
 }

Referenced by MFDRV_CreateBrushIndirect(), MFDRV_CreateFontIndirect(), MFDRV_CreatePalette(), MFDRV_CreatePenIndirect(), MFDRV_CreateRegion(), MFDRV_DeleteObject(), MFDRV_ExtEscape(), MFDRV_MetaExtTextOut(), MFDRV_MetaParam0(), MFDRV_MetaParam1(), MFDRV_MetaParam2(), MFDRV_MetaParam4(), MFDRV_MetaParam6(), MFDRV_MetaParam8(), MFDRV_MetaPoly(), MFDRV_PolyPolygon(), MFDRV_RealizePalette(), MFDRV_SelectObject(), MFDRV_SetDIBitsToDevice(), MFDRV_StretchBlt(), and MFDRV_StretchDIBits().

Classes

Macros

Functions