// // OdEmf.cpp // #include "OdaCommon.h" #ifdef USE_UEMF #undef USE_UEMF #endif #include "OdEmf.h" /////////////////////////////////////////////////////////////////////////////// // Macros //#define takeWmfRecordAndSize(pRecord, size) \ // const OdWmfRecord* pRecord = (const OdWmfRecord*)contents; \ // OdUInt32 size = 2 * (*(const OdUInt32*)pRecord); \ // if (size < sizeof(OdWmfRecord)) \ // return 0; \ // contents += sizeof(OdWmfRecord) #define takeEmfRecordAndSize(pRecord, size) \ const OdEmfObject* pRecord = (const OdEmfObject*)contents; \ OdUInt32 size = pRecord->nSize; \ if (size < sizeof(OdEmfObject)) \ return 0; \ contents += sizeof(OdEmfObject) #define skipType(type) contents += sizeof(type) #define takeType(type) *(const type*)contents, skipType(type) //#define takeString(len) (const char*)contents, contents += (len & 1) ? (len + 1) : len ///////////////////////////////////////////////////////////////////////////// // Notes: Size constants for EMF records not yet defined in OdEmf.h #define OdWmfNotImplementedSize 2048 // records which are documented but not implemented #define OdEmfForceUfiMappingSize (sizeof(OdEmfObject)) #define OdEmfColorCorrectPaletteSize (sizeof(OdEmfObject) + sizeof(OdUInt32) + sizeof(OdUInt32) + sizeof(OdUInt32)) #define OdEmfSetIcmProfileASize (sizeof(OdEmfObject) + sizeof(OdUInt32) + sizeof(OdUInt32) + sizeof(OdUInt32)) #define OdEmfSetIcmProfileWSize (sizeof(OdEmfObject) + sizeof(OdUInt32) + sizeof(OdUInt32) + sizeof(OdUInt32)) #define OdEmfSetLinkedUfisSize (sizeof(OdEmfObject)) #define OdEmfSetTextJustificationSize (sizeof(OdEmfObject) + sizeof(OdUInt32) + sizeof(OdUInt32)) static void swap4(void *ul, unsigned int count = 1) { for (OdUInt8* cl = (OdUInt8*)ul; count; count--, cl += 4) { OdUInt8 ctmp = cl[0]; cl[0] = cl[3]; cl[3] = ctmp; ctmp = cl[1]; cl[1] = cl[2]; cl[2] = ctmp; } } ///////////////////////////////////////////////////////////////////////////// // Checks the declared size of a record for consistency // Return 0 on failure, 1 on success // record pointer to the start of the EMF record in memory // blimit pointer to one byte after the EMF record in memory // nSize number of bytes in the record, read from the record // iType type of the record, read from the record // torev 1 for native to reversed, 0 for reversed to native // // Normally this would be called immediately after reading the data from a file. // Verifies that the declared size is consistent with this type of record. int getEmfRecordSize(const char* record, const char* blimit, OdUInt32* nSize, OdUInt32* iType, int torev) { OdUInt32 rsize=0; if (!nSize || !iType) return 0; // Check that COMMON data in record can be touched without an access violation. If it cannot be // this is either a corrupt EMF or one engineered to cause a buffer overflow. Pointer math // could wrap so check both sides of the range, and fail any indications of such a wrap. if (record + sizeof(OdEmfObject) > blimit) return 0; OdEmfMetaRecord* pEmr = (OdEmfMetaRecord*)(record); *iType = pEmr->iType; *nSize = pEmr->nSize; if (!torev) { swap4(iType); swap4(nSize); } // Check that the FULL record size is OK, abort if not. if (record + *nSize > blimit) return 0; switch (*iType) { // next line, ancient EMF files used a smaller header, to be safe, test for that case _EMR_HEADER: rsize = OdEmfHeaderSizeMin; break; case _EMR_POLYBEZIER: rsize = OdEmfPolybezierSize; break; case _EMR_POLYGON: rsize = OdEmfPolygonSize; break; case _EMR_POLYLINE: rsize = OdEmfPolylineSize; break; case _EMR_POLYBEZIERTO: rsize = OdEmfPolyBezierToSize; break; case _EMR_POLYLINETO: rsize = OdEmfPolyLineToSize; break; case _EMR_POLYPOLYLINE: rsize = OdEmfPolyPolylineSize; break; case _EMR_POLYPOLYGON: rsize = OdEmfPolyPolygonSize; break; case _EMR_SETWINDOWEXTEX: rsize = OdEmfSetWindowExtSize; break; case _EMR_SETWINDOWORGEX: rsize = OdEmfSetWindowOrgSize; break; case _EMR_SETVIEWPORTEXTEX: rsize = OdEmfSetViewportExtSize; break; case _EMR_SETVIEWPORTORGEX: rsize = OdEmfSetViewportOrgSize; break; case _EMR_SETBRUSHORGEX: rsize = OdEmfSetBrushOrgSize; break; case _EMR_EOF: rsize = OdEmfEofSize; break; case _EMR_SETPIXELV: rsize = OdEmfSetPixelVSize; break; case _EMR_SETMAPPERFLAGS: rsize = OdEmfSetMapperFlagsSize; break; case _EMR_SETMAPMODE: rsize = OdEmfSetMapModeSize; break; case _EMR_SETBKMODE: rsize = OdEmfSetBkModeSize; break; case _EMR_SETPOLYFILLMODE: rsize = OdEmfSetPolyFillModeSize; break; case _EMR_SETROP2: rsize = OdEmfSetRop2Size; break; case _EMR_SETSTRETCHBLTMODE: rsize = OdEmfSetStretchBltModeSize; break; case _EMR_SETTEXTALIGN: rsize = OdEmfSetTextAlignSize; break; case _EMR_SETCOLORADJUSTMENT: rsize = OdEmfSetColorAdjustmentSize; break; case _EMR_SETTEXTCOLOR: rsize = OdEmfSetTextColorSize; break; case _EMR_SETBKCOLOR: rsize = OdEmfSetBkColorSize; break; case _EMR_OFFSETCLIPRGN: rsize = OdEmfOffsetClipRgnSize; break; case _EMR_MOVETOEX: rsize = OdEmfMoveToExSize; break; case _EMR_SETMETARGN: rsize = OdEmfSetMetaRgnSize; break; case _EMR_EXCLUDECLIPRECT: rsize = OdEmfExcludeClipRectSize; break; case _EMR_INTERSECTCLIPRECT: rsize = OdEmfIntersectClipRectSize; break; case _EMR_SCALEVIEWPORTEXTEX: rsize = OdEmfScaleViewportExtExSize; break; case _EMR_SCALEWINDOWEXTEX: rsize = OdEmfScaleWindowExtExSize; break; case _EMR_SAVEDC: rsize = OdEmfSaveDcSize; break; case _EMR_RESTOREDC: rsize = OdEmfRestoreDcSize; break; case _EMR_SETWORLDTRANSFORM: rsize = OdEmfSetWorldTransformSize; break; case _EMR_MODIFYWORLDTRANSFORM: rsize = OdEmfModifyWorldTransformSize; break; case _EMR_SELECTOBJECT: rsize = OdEmfSelectObjectSize; break; case _EMR_CREATEPEN: rsize = OdEmfCreatePenSize; break; case _EMR_CREATEBRUSHINDIRECT: rsize = OdEmfCreateBrushIndirectSize; break; case _EMR_DELETEOBJECT: rsize = OdEmfDeleteObjectSize; break; case _EMR_ANGLEARC: rsize = OdEmfAngleArcSize; break; case _EMR_ELLIPSE: rsize = OdEmfEllipseSize; break; case _EMR_RECTANGLE: rsize = OdEmfRectangleSize; break; case _EMR_ROUNDRECT: rsize = OdEmfRoundRectSize; break; case _EMR_ARC: rsize = OdEmfArcSize; break; case _EMR_CHORD: rsize = OdEmfChordSize; break; case _EMR_PIE: rsize = OdEmfPieSize; break; case _EMR_SELECTPALETTE: rsize = OdEmfSelectPaletteSize; break; case _EMR_CREATEPALETTE: rsize = OdEmfCreatePaletteSize; break; case _EMR_SETPALETTEENTRIES: rsize = OdEmfSetPaletteEntriesSize; break; case _EMR_RESIZEPALETTE: rsize = OdEmfResizePaletteSize; break; case _EMR_REALIZEPALETTE: rsize = OdEmfRealizePaletteSize; break; case _EMR_EXTFLOODFILL: rsize = OdEmfExtFloodFillSize; break; case _EMR_LINETO: rsize = OdEmfLineToSize; break; case _EMR_ARCTO: rsize = OdEmfArcToSize; break; case _EMR_POLYDRAW: rsize = OdEmfPolyDrawSize; break; case _EMR_SETARCDIRECTION: rsize = OdEmfSetArcDirectionSize; break; case _EMR_SETMITERLIMIT: rsize = OdEmfSetMiterLimitSize; break; case _EMR_BEGINPATH: rsize = OdEmfBeginPathSize; break; case _EMR_ENDPATH: rsize = OdEmfEndPathSize; break; case _EMR_CLOSEFIGURE: rsize = OdEmfCloseFigureSize; break; case _EMR_FILLPATH: rsize = OdEmfFillPathSize; break; case _EMR_STROKEANDFILLPATH: rsize = OdEmfStrokeAndFillPathSize; break; case _EMR_STROKEPATH: rsize = OdEmfStrokePathSize; break; case _EMR_FLATTENPATH: rsize = OdEmfFlattenPathSize; break; case _EMR_WIDENPATH: rsize = OdEmfWidenPathSize; break; case _EMR_SELECTCLIPPATH: rsize = OdEmfSelectClipPathSize; break; case _EMR_ABORTPATH: rsize = OdEmfAbortPathSize; break; case _EMR_UNDEF69: rsize = OdEmfUndef69Size; break; case _EMR_COMMENT: rsize = OdEmfCommentSize; break; case _EMR_FILLRGN: rsize = OdEmfFillRgnSize; break; case _EMR_FRAMERGN: rsize = OdEmfFrameRgnSize; break; case _EMR_INVERTRGN: rsize = OdEmfInvertRgnSize; break; case _EMR_PAINTRGN: rsize = OdEmfPaintRgnSize; break; case _EMR_EXTSELECTCLIPRGN: rsize = OdEmfExtSelectClipRgnSize; break; case _EMR_BITBLT: rsize = OdEmfBitBltSize; break; case _EMR_STRETCHBLT: rsize = OdEmfStretchBltSize; break; case _EMR_MASKBLT: rsize = OdEmfMaskBltSize; break; case _EMR_PLGBLT: rsize = OdEmfPlgBltSize; break; case _EMR_SETDIBITSTODEVICE: rsize = OdEmfSetDibitsToDeviceSize; break; case _EMR_STRETCHDIBITS: rsize = OdEmfStretchDibitsSize; break; case _EMR_EXTCREATEFONTINDIRECTW: rsize = OdEmfExtCreateFontIndirectWSize; break; case _EMR_EXTTEXTOUTA: rsize = OdEmfExtTextOutASize; break; case _EMR_EXTTEXTOUTW: rsize = OdEmfExtTextOutWSize; break; case _EMR_POLYBEZIER16: rsize = OdEmfPolyBezier16Size; break; case _EMR_POLYGON16: rsize = OdEmfPolygon16Size; break; case _EMR_POLYLINE16: rsize = OdEmfPolyline16Size; break; case _EMR_POLYBEZIERTO16: rsize = OdEmfPolyBezierTo16Size; break; case _EMR_POLYLINETO16: rsize = OdEmfPolylineTo16Size; break; case _EMR_POLYPOLYLINE16: rsize = OdEmfPolyPolyline16Size; break; case _EMR_POLYPOLYGON16: rsize = OdEmfPolyPolygon16Size; break; case _EMR_POLYDRAW16: rsize = OdEmfPolyDraw16Size; break; case _EMR_CREATEMONOBRUSH: rsize = OdEmfCreateMonoBrushSize; break; case _EMR_CREATEDIBPATTERNBRUSHPT: rsize = OdEmfCreateDibPatternBrushPtSize; break; case _EMR_EXTCREATEPEN: rsize = OdEmfExtCreatePenSize; break; case _EMR_POLYTEXTOUTA: rsize = OdEmfPolyTextOutASize; break; case _EMR_POLYTEXTOUTW: rsize = OdEmfPolyTextOutWSize; break; case _EMR_SETICMMODE: rsize = OdEmfSetIcmModeSize; break; case _EMR_CREATECOLORSPACE: rsize = OdEmfCreateColorSpaceSize; break; case _EMR_SETCOLORSPACE: rsize = OdEmfSetColorSpaceSize; break; case _EMR_DELETECOLORSPACE: rsize = OdEmfDeleteColorSpaceSize; break; case _EMR_GLSRECORD: rsize = OdEmfGlsRecordSize; break; case _EMR_GLSBOUNDEDRECORD: rsize = OdEmfGlsBoundedRecordSize; break; case _EMR_PIXELFORMAT: rsize = OdEmfPixelFormatSize; break; case _EMR_DRAWESCAPE: rsize = OdEmfDrawEscapeSize; break; case _EMR_EXTESCAPE: rsize = OdEmfExtEscapeSize; break; case _EMR_UNDEF107: rsize = OdEmfUndef107Size; break; case _EMR_SMALLTEXTOUT: rsize = OdEmfSmallTextOutSize; break; case _EMR_NAMEDESCAPE: rsize = OdEmfNamedEscapeSize; break; case _EMR_ALPHABLEND: rsize = OdEmfAlphaBlendSize; break; case _EMR_SETLAYOUT: rsize = OdEmfSetLayoutSize; break; case _EMR_TRANSPARENTBLT: rsize = OdEmfTransparentBltSize; break; case _EMR_UNDEF117: rsize = OdEmfUndef117Size; break; case _EMR_GRADIENTFILL: rsize = OdEmfGradientFillSize; break; case _EMR_COLORMATCHTOTARGETW: rsize = OdEmfColorMatchToTargetWSize; break; case _EMR_CREATECOLORSPACEW: rsize = OdEmfCreateColorSpaceWSize; break; default: ODA_FAIL_ONCE(); rsize = OdWmfNotImplementedSize; break; } //end of switch // record's declared size must be more than the minimum size for this type of record if (*nSize < rsize) return 0; return 1; } static OdUInt32* emr_properties_table = NULL; int getEmfProperties(OdUInt32 type) { OdUInt32 result = (OdUInt32) _EMR_INVALID; if (type == _EMR_INVALID) { if (emr_properties_table) free(emr_properties_table); emr_properties_table = NULL; return result; } if (type >= 1 && type < _EMR_MAX) { if (!emr_properties_table) { emr_properties_table = (OdUInt32*)malloc(sizeof(OdUInt32) * (1 + _EMR_MAX)); if (!emr_properties_table) return result; for (int i = 0; i <= _EMR_MAX; i++) emr_properties_table[i] = 0x00; emr_properties_table[1] = 0x80; // _EMR_HEADER emr_properties_table[2] = 0x83; // _EMR_POLYBEZIER emr_properties_table[3] = 0x87; // _EMR_POLYGON emr_properties_table[4] = 0x83; // _EMR_POLYLINE emr_properties_table[5] = 0x8B; // _EMR_POLYBEZIERTO emr_properties_table[6] = 0x8B; // _EMR_POLYLINETO emr_properties_table[7] = 0x83; // _EMR_POLYPOLYLINE emr_properties_table[8] = 0x87; // _EMR_POLYPOLYGON emr_properties_table[9] = 0xA0; // _EMR_SETWINDOWEXTEX emr_properties_table[10] = 0xA0; // _EMR_SETWINDOWORGEX emr_properties_table[11] = 0xA0; // _EMR_SETVIEWPORTEXTEX emr_properties_table[12] = 0xA0; // _EMR_SETVIEWPORTORGEX emr_properties_table[13] = 0xA0; // _EMR_SETBRUSHORGEX emr_properties_table[14] = 0x82; // _EMR_EOF emr_properties_table[15] = 0x82; // _EMR_SETPIXELV emr_properties_table[16] = 0xA0; // _EMR_SETMAPPERFLAGS emr_properties_table[17] = 0xA0; // _EMR_SETMAPMODE emr_properties_table[18] = 0x20; // _EMR_SETBKMODE emr_properties_table[19] = 0xA0; // _EMR_SETPOLYFILLMODE emr_properties_table[20] = 0xA0; // _EMR_SETROP2 emr_properties_table[21] = 0xA0; // _EMR_SETSTRETCHBLTMODE emr_properties_table[22] = 0x20; // _EMR_SETTEXTALIGN emr_properties_table[23] = 0xA0; // _EMR_SETCOLORADJUSTMENT emr_properties_table[24] = 0x20; // _EMR_SETTEXTCOLOR emr_properties_table[25] = 0x20; // _EMR_SETBKCOLOR emr_properties_table[26] = 0xA0; // _EMR_OFFSETCLIPRGN emr_properties_table[27] = 0x89; // _EMR_MOVETOEX emr_properties_table[28] = 0xA0; // _EMR_SETMETARGN emr_properties_table[29] = 0xA0; // _EMR_EXCLUDECLIPRECT emr_properties_table[30] = 0xA0; // _EMR_INTERSECTCLIPRECT emr_properties_table[31] = 0xA0; // _EMR_SCALEVIEWPORTEXTEX emr_properties_table[32] = 0xA0; // _EMR_SCALEWINDOWEXTEX emr_properties_table[33] = 0xA0; // _EMR_SAVEDC emr_properties_table[34] = 0xA0; // _EMR_RESTOREDC emr_properties_table[35] = 0xA0; // _EMR_SETWORLDTRANSFORM emr_properties_table[36] = 0xA0; // _EMR_MODIFYWORLDTRANSFORM emr_properties_table[37] = 0xA0; // _EMR_SELECTOBJECT emr_properties_table[38] = 0x21; // _EMR_CREATEPEN emr_properties_table[39] = 0x21; // _EMR_CREATEBRUSHINDIRECT emr_properties_table[40] = 0x20; // _EMR_DELETEOBJECT } result = emr_properties_table[type]; } return result; } int getEmfDibParams(const char* record, OdUInt32 offBitsSrc, OdUInt32 offBmiSrc, const char** px, const OdWmfQuad** ct, OdUInt32* numCt, OdUInt32* width, OdUInt32* height, OdUInt32* colortype, OdUInt32* invert) { if (!record || !px || !ct || !numCt || !width || !height || !colortype || !invert) return _BI_UNKNOWN; *px = nullptr; *ct = nullptr; *numCt = *width = *height = *colortype = *invert = 0; if (offBitsSrc) *px = record + offBitsSrc; if (offBmiSrc) { const char* contents = record + offBmiSrc; OdUInt32 biSize; OdInt32 biWidth, biHeight; OdUInt16 biBitCount; biSize = takeType(OdUInt32); if (biSize >= 40) { biWidth = takeType(OdInt32); biHeight = takeType(OdInt32); skipType(OdUInt16); biBitCount = takeType(OdUInt16); *width = biWidth; if (biHeight < 0) { *height = -biHeight; *invert = 1; } else { *height = biHeight; *invert = 0; } *colortype = biBitCount; if (*colortype <= 8) { *numCt = 1 << *colortype; *ct = (const OdWmfQuad*)(record + offBmiSrc + biSize); } } } return _BI_RGB; } int getEmfOneRecPrint(const char* contents, const char* blimit, int recnum, OdUInt32 off) { (void)recnum; if (!contents || (blimit && contents >= blimit)) return 0; if (blimit - contents < 8) return 0; OdUInt32 record_size = *(OdUInt32*)(contents + 4); return off + record_size; } static int checkEmfRecordSize(const char* record, OdUInt32 minSize) { const OdEmfObject* pEmr = (const OdEmfObject*)record; if (pEmr->nSize < minSize) return 0; return 1; } int checkEmfRecord(const char *record) { if (!record) return 0; const OdEmfObject* pEmfObject = (const OdEmfObject*)record; if (pEmfObject->nSize < sizeof(OdEmfObject) ) return 0; //return 1; OdUInt32 minSize = 0; switch (pEmfObject->iType) { case _EMR_HEADER: minSize = OdEmfHeaderSizeMin; break; case _EMR_POLYBEZIER: minSize = OdEmfPolybezierSize; break; case _EMR_POLYGON: minSize = OdEmfPolygonSize; break; case _EMR_POLYLINE: minSize = OdEmfPolylineSize; break; case _EMR_POLYBEZIERTO: minSize = OdEmfPolyBezierToSize; break; case _EMR_POLYLINETO: minSize = OdEmfPolyLineToSize; break; case _EMR_POLYPOLYLINE: minSize = OdEmfPolyPolylineSize; break; case _EMR_POLYPOLYGON: minSize = OdEmfPolyPolygonSize; break; case _EMR_SETWINDOWEXTEX: minSize = OdEmfSetWindowExtSize; break; case _EMR_SETWINDOWORGEX: minSize = OdEmfSetWindowOrgSize; break; case _EMR_SETVIEWPORTEXTEX: minSize = OdEmfSetViewportExtSize; break; case _EMR_SETVIEWPORTORGEX: minSize = OdEmfSetViewportOrgSize; break; case _EMR_SETBRUSHORGEX: minSize = OdEmfSetBrushOrgSize; break; case _EMR_EOF: minSize = OdEmfEofSize; break; case _EMR_SETPIXELV: minSize = OdEmfSetPixelVSize; break; case _EMR_SETMAPPERFLAGS: minSize = OdEmfSetMapperFlagsSize; break; case _EMR_SETMAPMODE: minSize = OdEmfSetMapModeSize; break; case _EMR_SETBKMODE: minSize = OdEmfSetBkModeSize; break; case _EMR_SETPOLYFILLMODE: minSize = OdEmfSetPolyFillModeSize; break; case _EMR_SETROP2: minSize = OdEmfSetRop2Size; break; case _EMR_SETSTRETCHBLTMODE: minSize = OdEmfSetStretchBltModeSize; break; case _EMR_SETTEXTALIGN: minSize = OdEmfSetTextAlignSize; break; case _EMR_SETCOLORADJUSTMENT: minSize = OdEmfSetColorAdjustmentSize; break; case _EMR_SETTEXTCOLOR: minSize = OdEmfSetTextColorSize; break; case _EMR_SETBKCOLOR: minSize = OdEmfSetBkColorSize; break; case _EMR_OFFSETCLIPRGN: minSize = OdEmfOffsetClipRgnSize; break; case _EMR_MOVETOEX: minSize = OdEmfMoveToExSize; break; case _EMR_SETMETARGN: minSize = OdEmfSetMetaRgnSize; break; case _EMR_EXCLUDECLIPRECT: minSize = OdEmfExcludeClipRectSize; break; case _EMR_INTERSECTCLIPRECT: minSize = OdEmfIntersectClipRectSize; break; case _EMR_SCALEVIEWPORTEXTEX: minSize = OdEmfScaleViewportExtExSize; break; case _EMR_SCALEWINDOWEXTEX: minSize = OdEmfScaleWindowExtExSize; break; case _EMR_SAVEDC: minSize = OdEmfSaveDcSize; break; case _EMR_RESTOREDC: minSize = OdEmfRestoreDcSize; break; case _EMR_SETWORLDTRANSFORM: minSize = OdEmfSetWorldTransformSize; break; case _EMR_MODIFYWORLDTRANSFORM: minSize = OdEmfModifyWorldTransformSize; break; case _EMR_SELECTOBJECT: minSize = OdEmfSelectObjectSize; break; case _EMR_CREATEPEN: minSize = OdEmfCreatePenSize; break; case _EMR_CREATEBRUSHINDIRECT: minSize = OdEmfCreateBrushIndirectSize; break; case _EMR_DELETEOBJECT: minSize = OdEmfDeleteObjectSize; break; case _EMR_ANGLEARC: minSize = OdEmfAngleArcSize; break; case _EMR_ELLIPSE: minSize = OdEmfEllipseSize; break; case _EMR_RECTANGLE: minSize = OdEmfRectangleSize; break; case _EMR_ROUNDRECT: minSize = OdEmfRoundRectSize; break; case _EMR_ARC: minSize = OdEmfArcSize; break; case _EMR_CHORD: minSize = OdEmfChordSize; break; case _EMR_PIE: minSize = OdEmfPieSize; break; case _EMR_SELECTPALETTE: minSize = OdEmfSelectPaletteSize; break; case _EMR_CREATEPALETTE: minSize = OdEmfCreatePaletteSize; break; case _EMR_SETPALETTEENTRIES: minSize = OdEmfSetPaletteEntriesSize; break; case _EMR_RESIZEPALETTE: minSize = OdEmfResizePaletteSize; break; case _EMR_REALIZEPALETTE: minSize = OdEmfRealizePaletteSize; break; case _EMR_EXTFLOODFILL: minSize = OdEmfExtFloodFillSize; break; case _EMR_LINETO: minSize = OdEmfLineToSize; break; case _EMR_ARCTO: minSize = OdEmfArcToSize; break; case _EMR_POLYDRAW: minSize = OdEmfPolyDrawSize; break; case _EMR_SETARCDIRECTION: minSize = OdEmfSetArcDirectionSize; break; case _EMR_SETMITERLIMIT: minSize = OdEmfSetMiterLimitSize; break; case _EMR_BEGINPATH: minSize = OdEmfBeginPathSize; break; case _EMR_ENDPATH: minSize = OdEmfEndPathSize; break; case _EMR_CLOSEFIGURE: minSize = OdEmfCloseFigureSize; break; case _EMR_FILLPATH: minSize = OdEmfFillPathSize; break; case _EMR_STROKEANDFILLPATH: minSize = OdEmfStrokeAndFillPathSize; break; case _EMR_STROKEPATH: minSize = OdEmfStrokePathSize; break; case _EMR_FLATTENPATH: minSize = OdEmfFlattenPathSize; break; case _EMR_WIDENPATH: minSize = OdEmfWidenPathSize; break; case _EMR_SELECTCLIPPATH: minSize = OdEmfSelectClipPathSize; break; case _EMR_ABORTPATH: minSize = OdEmfAbortPathSize; break; case _EMR_UNDEF69: minSize = OdEmfUndef69Size; break; case _EMR_COMMENT: minSize = OdEmfCommentSize; break; case _EMR_FILLRGN: minSize = OdEmfFillRgnSize; break; case _EMR_FRAMERGN: minSize = OdEmfFrameRgnSize; break; case _EMR_INVERTRGN: minSize = OdEmfInvertRgnSize; break; case _EMR_PAINTRGN: minSize = OdEmfPaintRgnSize; break; case _EMR_EXTSELECTCLIPRGN: minSize = OdEmfExtSelectClipRgnSize; break; case _EMR_BITBLT: minSize = OdEmfBitBltSize; break; case _EMR_STRETCHBLT: minSize = OdEmfStretchBltSize; break; case _EMR_MASKBLT: minSize = OdEmfMaskBltSize; break; case _EMR_PLGBLT: minSize = OdEmfPlgBltSize; break; case _EMR_SETDIBITSTODEVICE: minSize = OdEmfSetDibitsToDeviceSize; break; case _EMR_STRETCHDIBITS: minSize = OdEmfStretchDibitsSize; break; case _EMR_EXTCREATEFONTINDIRECTW: minSize = OdEmfExtCreateFontIndirectWSize; break; case _EMR_EXTTEXTOUTA: minSize = OdEmfExtTextOutASize; break; case _EMR_EXTTEXTOUTW: minSize = OdEmfExtTextOutWSize; break; case _EMR_POLYBEZIER16: minSize = OdEmfPolyBezier16Size; break; case _EMR_POLYGON16: minSize = OdEmfPolygon16Size; break; case _EMR_POLYLINE16: minSize = OdEmfPolyline16Size; break; case _EMR_POLYBEZIERTO16: minSize = OdEmfPolyBezierTo16Size; break; case _EMR_POLYLINETO16: minSize = OdEmfPolylineTo16Size; break; case _EMR_POLYPOLYLINE16: minSize = OdEmfPolyPolyline16Size; break; case _EMR_POLYPOLYGON16: minSize = OdEmfPolyPolygon16Size; break; case _EMR_POLYDRAW16: minSize = OdEmfPolyDraw16Size; break; case _EMR_CREATEMONOBRUSH: minSize = OdEmfCreateMonoBrushSize; break; case _EMR_CREATEDIBPATTERNBRUSHPT: minSize = OdEmfCreateDibPatternBrushPtSize; break; case _EMR_EXTCREATEPEN: minSize = OdEmfExtCreatePenSize; break; case _EMR_POLYTEXTOUTA: minSize = OdEmfPolyTextOutASize; break; case _EMR_POLYTEXTOUTW: minSize = OdEmfPolyTextOutWSize; break; case _EMR_SETICMMODE: minSize = OdEmfSetIcmModeSize; break; case _EMR_CREATECOLORSPACE: minSize = OdEmfCreateColorSpaceSize; break; case _EMR_SETCOLORSPACE: minSize = OdEmfSetColorSpaceSize; break; case _EMR_DELETECOLORSPACE: minSize = OdEmfDeleteColorSpaceSize; break; case _EMR_GLSRECORD: minSize = OdEmfGlsRecordSize; break; case _EMR_GLSBOUNDEDRECORD: minSize = OdEmfGlsBoundedRecordSize; break; case _EMR_PIXELFORMAT: minSize = OdEmfPixelFormatSize; break; case _EMR_DRAWESCAPE: minSize = OdEmfDrawEscapeSize; break; case _EMR_EXTESCAPE: minSize = OdEmfExtEscapeSize; break; case _EMR_UNDEF107: minSize = OdEmfUndef107Size; break; case _EMR_SMALLTEXTOUT: minSize = OdEmfSmallTextOutSize; break; case _EMR_FORCEUFIMAPPING: minSize = OdEmfForceUfiMappingSize; break; case _EMR_NAMEDESCAPE: minSize = OdEmfNamedEscapeSize; break; case _EMR_COLORCORRECTPALETTE: minSize = OdEmfColorCorrectPaletteSize; break; case _EMR_SETICMPROFILEA: minSize = OdEmfSetIcmProfileASize; break; case _EMR_SETICMPROFILEW: minSize = OdEmfSetIcmProfileWSize; break; case _EMR_ALPHABLEND: minSize = OdEmfAlphaBlendSize; break; case _EMR_SETLAYOUT: minSize = OdEmfSetLayoutSize; break; case _EMR_TRANSPARENTBLT: minSize = OdEmfTransparentBltSize; break; case _EMR_UNDEF117: minSize = OdEmfUndef117Size; break; case _EMR_GRADIENTFILL: minSize = OdEmfGradientFillSize; break; case _EMR_SETLINKEDUFIS: minSize = OdEmfSetLinkedUfisSize; break; case _EMR_SETTEXTJUSTIFICATION: minSize = OdEmfSetTextJustificationSize; break; case _EMR_COLORMATCHTOTARGETW: minSize = OdEmfColorMatchToTargetWSize; break; case _EMR_CREATECOLORSPACEW: minSize = OdEmfCreateColorSpaceWSize; break; default: minSize = OdWmfNotImplementedSize; break; } return checkEmfRecordSize(record, minSize); } /////////////////////////////////////////////////////////////////////////////