diff options
Diffstat (limited to 'src/3rdparty/libuemf/uwmf_print.c')
| -rw-r--r-- | src/3rdparty/libuemf/uwmf_print.c | 1635 |
1 files changed, 1635 insertions, 0 deletions
diff --git a/src/3rdparty/libuemf/uwmf_print.c b/src/3rdparty/libuemf/uwmf_print.c new file mode 100644 index 0000000..d6d1b58 --- /dev/null +++ b/src/3rdparty/libuemf/uwmf_print.c @@ -0,0 +1,1635 @@ +/** + @file uwmf_print.c + + @brief Functions for printing WMF records +*/ + +/* +File: uwmf_print.c +Version: 0.0.6 +Date: 21-MAY-2015 +Author: David Mathog, Biology Division, Caltech +email: mathog@caltech.edu +Copyright: 2015 David Mathog and California Institute of Technology (Caltech) +*/ + +#ifdef __cplusplus +extern "C" { +#endif + +#include <stdlib.h> +#include <stdio.h> +#include <stddef.h> /* for offsetof() macro */ +#include <string.h> +#include "uwmf_print.h" + +//! \cond + +#define UNUSED(x) (void)(x) + +/* ********************************************************************************************** + These functions print standard objects used in the WMR records. + The low level ones do not append EOL. +*********************************************************************************************** */ + +/* many of these are implemented in uemf_print.c and not replicated here */ + + + +/** + \brief Print a U_BRUSH object. + \param b U_BRUSH object. + style bColor bHatch + U_BS_SOLID ColorRef Object Not used (bytes present???) + U_BS_NULL ignored ignored (bytes present???). + U_BS_PATTERN ignored Bitmap16 object holding patern + U_BS_DIBPATTERNPT ColorUsage Enum DIB object + U_BS_HATCHED ColorRef Object HatchStyle Enumeration +*/ +void brush_print( + U_BRUSH b + ){ + uint16_t hatch; + U_COLORREF Color; + switch(b.Style){ + case U_BS_SOLID: + memcpy(&Color, &b.Color, sizeof(U_COLORREF)); + printf("Color:"); colorref_print(Color); + break; + case U_BS_NULL: + printf("Null"); + break; + case U_BS_PATTERN: + printf("Pattern:(not shown)"); + break; + case U_BS_DIBPATTERNPT: + printf("DIBPattern:(not shown)"); + break; + case U_BS_HATCHED: + memcpy(&hatch, b.Data, 2); + printf("Hatch:0x%4.4X ", hatch); + break; + } +} + +/** + \brief Print a U_FONT object from a char *pointer. + The U_FONT struct object may not be properly aligned, but all of the fields within it will + OK for alignment. + \param font U_FONT object (as a char * pointer) +*/ +void font_print( + const char *font + ){ + printf("Height:%d ", *(int16_t *)(font + offsetof(U_FONT,Height ))); + printf("Width:%d ", *(int16_t *)(font + offsetof(U_FONT,Width ))); + printf("Escapement:%d ", *(int16_t *)(font + offsetof(U_FONT,Escapement ))); + printf("Orientation:%d ", *(int16_t *)(font + offsetof(U_FONT,Orientation ))); + printf("Weight:%d ", *(int16_t *)(font + offsetof(U_FONT,Weight ))); + printf("Italic:0x%2.2X ", *(uint8_t *)(font + offsetof(U_FONT,Italic ))); + printf("Underline:0x%2.2X ", *(uint8_t *)(font + offsetof(U_FONT,Underline ))); + printf("StrikeOut:0x%2.2X ", *(uint8_t *)(font + offsetof(U_FONT,StrikeOut ))); + printf("CharSet:0x%2.2X ", *(uint8_t *)(font + offsetof(U_FONT,CharSet ))); + printf("OutPrecision:0x%2.2X ", *(uint8_t *)(font + offsetof(U_FONT,OutPrecision ))); + printf("ClipPrecision:0x%2.2X ", *(uint8_t *)(font + offsetof(U_FONT,ClipPrecision ))); + printf("Quality:0x%2.2X ", *(uint8_t *)(font + offsetof(U_FONT,Quality ))); + printf("PitchAndFamily:0x%2.2X ", *(uint8_t *)(font + offsetof(U_FONT,PitchAndFamily))); + printf("FaceName:%s ", (font + offsetof(U_FONT,FaceName ))); +} + + +/** + \brief Print a U_PLTNTRY object. + \param pny U_PLTNTRY object. +*/ +void pltntry_print( + U_PLTNTRY pny + ){ + printf("Value:%u ", pny.Value); + printf("Red:%u ", pny.Red ); + printf("Green:%u ", pny.Green); + printf("Blue:%u ", pny.Blue ); +} + + +/** + \brief Print a pointer to a U_PALETTE object. + \param p Pointer to a U_PALETTE object + \param PalEntries Array of Palette Entries +*/ +void palette_print( + const U_PALETTE *p, + const char *PalEntries + ){ + int i; + U_PLTNTRY pny; + + printf("Start:%X ", p->Start ); + printf("NumEntries:%u ",p->NumEntries ); + if(p->NumEntries && PalEntries){ + for(i=0; i < p->NumEntries; i++, PalEntries += sizeof(U_PLTNTRY)){ + memcpy(&pny, PalEntries, sizeof(U_PLTNTRY)); + printf("%d:",i); pltntry_print(pny); + } + } +} + +/** + \brief Print a U_PEN object. + \param p U_PEN object + uint16_t Style; //!< PenStyle Enumeration + uint16_t Width; //!< Pen Width in object dimensions + uint16_t unused; //!< unused + union { + U_COLORREF Color; //!< Pen color (NOT aligned on 4n byte boundary!) + uint16_t Colorw[2]; //!< reassemble/store the Color value using these, NOT Color. + }; +*/ +void pen_print( + U_PEN p + ){ + U_COLORREF Color; + printf("Style:0x%8.8X " ,p.Style ); + printf("Width:%u " ,p.Widthw[0] ); + memcpy(&Color, &p.Color, sizeof(U_COLORREF)); + printf("Color"); colorref_print(Color); +} + +/** + \brief Print U_RECT16 object + Prints in order left, top, right, bottom + \param rect U_RECT16 object +*/ +void rect16_ltrb_print( + U_RECT16 rect + ){ + printf("LTRB{%d,%d,%d,%d} ",rect.left,rect.top,rect.right,rect.bottom); +} + +/** + \brief Print U_RECT16 object + Some WMF rects use the order bottom, right, top, left. These are passed in using + the same structure as for a normal U_RECT16 so: + position holds + left bottom + top right + right top + bottom left + This is used by WMR_RECTANGLE and many others. + \param rect U_RECT16 object +*/ +void rect16_brtl_print( + U_RECT16 rect + ){ + printf("BRTL{%d,%d,%d,%d} ",rect.bottom,rect.right,rect.top,rect.left); +} + + + +/** + \brief Print U_REGION object from a char * pointer. + \param region U_REGION object +*/ +void region_print( + const char *region + ){ + U_RECT16 rect16; + printf("Type:%d ", *(uint16_t *)(region + offsetof(U_REGION,Type ))); + printf("Size:%d ", *( int16_t *)(region + offsetof(U_REGION,Size ))); + printf("sCount:%d ",*( int16_t *)(region + offsetof(U_REGION,sCount))); + printf("sMax:%d ", *( int16_t *)(region + offsetof(U_REGION,sMax ))); + memcpy(&rect16, (region + offsetof(U_REGION,sRect )), sizeof(U_RECT16)); + printf("sRect: "); rect16_ltrb_print(rect16); +} + + +/** + \brief Print U_BITMAP16 object + \param b U_BITMAP16 object +*/ +void bitmap16_print( + U_BITMAP16 b + ){ + printf("Type:%d ", b.Type ); + printf("Width:%d ", b.Width ); + printf("Height:%d ", b.Height ); + printf("WidthBytes:%d ", b.WidthBytes); + printf("Planes:%d ", b.Planes ); + printf("BitsPixel:%d ", b.BitsPixel ); + printf("BitsBytes:%d ", (((b.Width * b.BitsPixel + 15) >> 4) << 1) * b.Height ); +} + +/** + \brief Print U_BITMAPCOREHEADER object + \param ch U_BITMAPCOREHEADER object +*/ +void bitmapcoreheader_print( + U_BITMAPCOREHEADER ch + ){ + uint32_t Size; + memcpy(&Size, &(ch.Size_4), 4); /* will be aligned, but is in two pieces */ + printf("Size:%d ", Size); + printf("Width:%d ", ch.Width); + printf("Height:%d ", ch.Height); + printf("Planes:%d ", ch.Planes); + printf("BitCount:%d ", ch.BitCount); +} + +/** LogBrushW Object WMF PDF 2.2.2.10 + \brief Print a U_LOGBRUSHW object. + \param lb U_LOGBRUSHW object. + + style Color Hatch + U_BS_SOLID ColorRef Object Not used (bytes present???) + U_BS_NULL ignored ignored (bytes present???). + U_BS_PATTERN ignored not used (Action is not strictly defined) + U_BS_DIBPATTERN ignored not used (Action is not strictly defined) + U_BS_DIBPATTERNPT ignored not used (Action is not strictly defined) + U_BS_HATCHED ColorRef Object HatchStyle Enumeration +*/ +void wlogbrush_print( + const char *lb + ){ + U_COLORREF Color; + uint16_t Style = *(uint16_t *)(lb + offsetof(U_WLOGBRUSH,Style)); + uint16_t Hatch = *(uint16_t *)(lb + offsetof(U_WLOGBRUSH,Hatch)); + memcpy(&Color, lb + offsetof(U_WLOGBRUSH,Color), sizeof(U_COLORREF)); + printf("Style:0x%4.4X ",Style); + switch(Style){ + case U_BS_SOLID: + printf("Color:"); colorref_print(Color); + break; + case U_BS_NULL: + printf("Null"); + break; + case U_BS_PATTERN: + printf("Pattern:(not implemented)"); + break; + case U_BS_DIBPATTERN: + printf("DIBPattern:(not implemented)"); + break; + case U_BS_DIBPATTERNPT: + printf("DIBPatternPt:(not implemented)"); + break; + case U_BS_HATCHED: + printf("Color:"); colorref_print(Color); + printf("Hatch:0x%4.4X ", Hatch); + break; + } +} + + +/** + \brief Print U_POLYPOLY object from pointer + \param nPolys Number of elements in aPolyCounts + \param aPolyCounts Number of points in each poly (sequential) + \param Points pointer to array of U_POINT16 in memory. Probably not aligned. +*/ +void polypolygon_print( + uint16_t nPolys, + const uint16_t *aPolyCounts, + const char *Points + ){ + int i,j; + U_POINT16 pt; + for(i=0; i<nPolys; i++, aPolyCounts++){ + printf(" Polygon[%d]: ",i); + for(j=0; j < *aPolyCounts; j++, Points += sizeof(U_POINT16)){ + memcpy(&pt, Points, sizeof(U_POINT16)); /* may not be aligned */ + point16_print(pt); + } + } +} + +/** + \brief Print U_SCAN object + \param sc U_SCAN object +*/ +void scan_print( + U_SCAN sc + ){ + printf("Count:%d ", sc.count); + printf("Top:%d ", sc.top); + printf("Bottom:%d ", sc.bottom); + printf("data:(not shown)"); +} + +/** + \brief Print a summary of a DIB header + \param dh void pointer to DIB header + A DIB header in an WMF may be either a BitmapCoreHeader or BitmapInfoHeader. +*/ +void dibheader_print(const char *dh, const char *blimit){ + uint32_t Size; + memcpy(&Size, dh, 4); /* may not be aligned */ + if(Size == 0xC ){ + printf("(BitmapCoreHeader) "); + U_BITMAPCOREHEADER bmch; + memcpy(&bmch, dh, sizeof(U_BITMAPCOREHEADER)); /* may not be aligned */ + bitmapcoreheader_print(bmch); + } + else { + printf(" (BitmapInfoHeader) "); + bitmapinfo_print(dh, blimit); /* may not be aligned, called routine must handle it */ + } +} + +/** + \brief Print WMF header object + \returns size of entire header structure + \param contents pointer to the first byte in the buffer holding the entire WMF file in memory + \param blimit pointer to the byte after the last byte in contents + + If the header is preceded by a placeable struture, print that as well. +*/ +int wmfheader_print( + const char *contents, + const char *blimit + ){ + U_WMRPLACEABLE Placeable; + U_WMRHEADER Header; + int size = wmfheader_get(contents, blimit, &Placeable, &Header); + uint32_t utmp4; + U_RECT16 rect16; + uint32_t Key; + memcpy(&Key, contents + offsetof(U_WMRPLACEABLE,Key), 4); + if(Placeable.Key == 0x9AC6CDD7){ + printf("WMF, Placeable: "); + printf("HWmf:%u ", Placeable.HWmf); + memcpy(&rect16, &(Placeable.Dst), sizeof(U_RECT16)); + printf("Box:"); rect16_ltrb_print(rect16); + printf("Inch:%u ", Placeable.Inch); + printf("Checksum:%d ", Placeable.Checksum); + printf("Calculated_Checksum:%d\n",U_16_checksum((int16_t *)contents,10)); + } + else { + printf("WMF, Not Placeable\n"); + } + printf(" RecType:%d\n", Header.iType); + printf(" 16bit words in record:%d\n", Header.Size16w); + printf(" Version:%d\n", Header.version); + memcpy(&utmp4, &(Header.Sizew),4); + printf(" 16bit words in file:%d\n",utmp4); + printf(" Objects:%d\n", Header.nObjects); + memcpy(&utmp4, &(Header.maxSize),4); + printf(" Largest Record:%d\n", utmp4); + printf(" nMembers:%d\n", Header.nMembers); + + return(size); +} + + + +/* ********************************************************************************************** +These functions contain shared code used by various U_WMR*_print functions. These should NEVER be called +by end user code and to further that end prototypes are NOT provided and they are hidden from Doxygen. +*********************************************************************************************** */ + + +void wcore_points_print(uint16_t nPoints, const char *aPoints){ + int i; + U_POINT16 pt; + printf(" Points: "); + for(i=0;i<nPoints; i++){ + memcpy(&pt, aPoints + i*4, sizeof(U_POINT16)); /* aPoints U_POINT16 structure may not be aligned, so copy it out */ + printf("[%d]:",i); point16_print(pt); + } + printf("\n"); +} + + + +/* ********************************************************************************************** +These are the core WMR functions, each creates a particular type of record. +All return these records via a char* pointer, which is NULL if the call failed. +They are listed in order by the corresponding U_WMR_* index number. +*********************************************************************************************** */ + +/** + \brief Print a pointer to a U_WMR_whatever record which has not been implemented. + \param contents pointer to a buffer holding a WMR record +*/ +void U_WMRNOTIMPLEMENTED_print(const char *contents){ + UNUSED(contents); + printf(" Not Implemented!\n"); +} + +void U_WMREOF_print(const char *contents){ + UNUSED(contents); +} + +void U_WMRSETBKCOLOR_print(const char *contents){ + U_COLORREF Color; + int size = U_WMRSETBKCOLOR_get(contents, &Color); + if(size>0){ + printf(" %-15s ","Color:"); colorref_print(Color); printf("\n"); + } +} + +void U_WMRSETBKMODE_print(const char *contents){ + uint16_t iMode; + int size = U_WMRSETBKMODE_get(contents, &iMode); + if(size>0){ + printf(" %-15s 0x%4.4X\n","iMode:", iMode); + } +} + +void U_WMRSETMAPMODE_print(const char *contents){ + uint16_t iMode; + int size = U_WMRSETMAPMODE_get(contents, &iMode); + if(size>0){ + printf(" %-15s 0x%4.4X\n","iMode:", iMode); + } +} + +void U_WMRSETROP2_print(const char *contents){ + uint16_t iMode; + int size = U_WMRSETROP2_get(contents, &iMode); + if(size>0){ + printf(" %-15s 0x%4.4X\n","iMode:", iMode); + } +} + +void U_WMRSETRELABS_print(const char *contents){ + UNUSED(contents); + /* This record type has only the common 6 bytes, so nothing (else) to print */ +} + +void U_WMRSETPOLYFILLMODE_print(const char *contents){ + uint16_t iMode; + int size = U_WMRSETPOLYFILLMODE_get(contents, &iMode); + if(size>0){ + printf(" %-15s 0x%4.4X\n","iMode:", iMode); + } +} + +void U_WMRSETSTRETCHBLTMODE_print(const char *contents){ + uint16_t iMode; + int size = U_WMRSETSTRETCHBLTMODE_get(contents, &iMode); + if(size>0){ + printf(" %-15s 0x%4.4X\n","iMode:", iMode); + } +} + +void U_WMRSETTEXTCHAREXTRA_print(const char *contents){ + uint16_t iMode; + int size = U_WMRSETTEXTCHAREXTRA_get(contents, &iMode); + if(size>0){ + printf(" %-15s 0x%4.4X\n","iMode:", iMode); + } +} + +void U_WMRSETTEXTCOLOR_print(const char *contents){ + U_COLORREF Color; + int size = U_WMRSETTEXTCOLOR_get(contents, &Color); + if(size>0){ + printf(" %-15s ","Color:"); colorref_print(Color); printf("\n"); + } +} + +void U_WMRSETTEXTJUSTIFICATION_print(const char *contents){ + uint16_t Count; + uint16_t Extra; + int size = U_WMRSETTEXTJUSTIFICATION_get(contents, &Count, &Extra); + if(size){ + printf(" %-15s %d\n","Count", Count); + printf(" %-15s %d\n","Extra", Extra); + } +} + +void U_WMRSETWINDOWORG_print(const char *contents){ + U_POINT16 coord; + int size = U_WMRSETWINDOWORG_get(contents, &coord); + if(size){ + printf(" %-15s {%d,%d}\n","X,Y",coord.x, coord.y); + } +} + +void U_WMRSETWINDOWEXT_print(const char *contents){ + U_POINT16 coord; + int size = U_WMRSETWINDOWEXT_get(contents, &coord); + if(size){ + printf(" %-15s {%d,%d}\n","W,H",coord.x, coord.y); + } +} + +void U_WMRSETVIEWPORTORG_print(const char *contents){ + U_POINT16 coord; + int size = U_WMRSETVIEWPORTORG_get(contents, &coord); + if(size){ + printf(" %-15s {%d,%d}\n","X,Y",coord.x, coord.y); + } +} + +void U_WMRSETVIEWPORTEXT_print(const char *contents){ + U_POINT16 coord; + int size = U_WMRSETVIEWPORTEXT_get(contents, &coord); + if(size){ + printf(" %-15s {%d,%d}\n","W,H",coord.x, coord.y); + } +} + +void U_WMROFFSETWINDOWORG_print(const char *contents){ + U_POINT16 coord; + int size = U_WMROFFSETWINDOWORG_get(contents, &coord); + if(size){ + printf(" %-15s {%d,%d}\n","X,Y",coord.x, coord.y); + } +} + +void U_WMRSCALEWINDOWEXT_print(const char *contents){ + U_POINT16 Denom, Num; + int size = U_WMRSCALEWINDOWEXT_get(contents, &Denom, &Num); + if(size > 0){ + printf(" yDenom:%d\n", Denom.y); + printf(" yNum:%d\n", Num.y ); + printf(" xDenom:%d\n", Denom.x); + printf(" xNum:%d\n", Num.x ); + } +} + +void U_WMROFFSETVIEWPORTORG_print(const char *contents){ + U_POINT16 coord; + int size = U_WMROFFSETVIEWPORTORG_get(contents, &coord); + if(size){ + printf(" %-15s {%d,%d}\n","X,Y",coord.x, coord.y); + } +} + +void U_WMRSCALEVIEWPORTEXT_print(const char *contents){ + U_POINT16 Denom, Num; + int size = U_WMRSCALEVIEWPORTEXT_get(contents, &Denom, &Num); + if(size > 0){ + printf(" yDenom:%d\n", Denom.y); + printf(" yNum:%d\n", Num.y ); + printf(" xDenom:%d\n", Denom.x); + printf(" xNum:%d\n", Num.x ); + } +} + +void U_WMRLINETO_print(const char *contents){ + U_POINT16 coord; + int size = U_WMRLINETO_get(contents, &coord); + if(size){ + printf(" %-15s {%d,%d}\n","X,Y",coord.x, coord.y); + } +} + +void U_WMRMOVETO_print(const char *contents){ + U_POINT16 coord; + int size = U_WMRMOVETO_get(contents, &coord); + if(size > 0){ + printf(" %-15s {%d,%d}\n","X,Y",coord.x, coord.y); + } +} + +void U_WMREXCLUDECLIPRECT_print(const char *contents){ + U_RECT16 rect16; + int size = U_WMREXCLUDECLIPRECT_get(contents, &rect16); + if(size > 0){ + printf(" Rect:"); + rect16_ltrb_print(rect16); + printf("\n"); + } +} + +void U_WMRINTERSECTCLIPRECT_print(const char *contents){ + U_RECT16 rect16; + int size = U_WMRINTERSECTCLIPRECT_get(contents, &rect16); + if(size > 0){ + printf(" Rect:"); + rect16_ltrb_print(rect16); + printf("\n"); + } +} + +void U_WMRARC_print(const char *contents){ + U_POINT16 StartArc, EndArc; + U_RECT16 rect16; + int size = U_WMRARC_get(contents, &StartArc, &EndArc, &rect16); + if(size > 0){ + printf(" yRadial2:%d\n", EndArc.y); + printf(" xRadial2:%d\n", EndArc.x); + printf(" yRadial1:%d\n", StartArc.y); + printf(" xRadial1:%d\n", StartArc.x); + printf(" Rect:"); rect16_ltrb_print(rect16); printf("\n"); + } +} + +void U_WMRELLIPSE_print(const char *contents){ + U_RECT16 rect16; + int size = U_WMRELLIPSE_get(contents, &rect16); + if(size > 0){ + printf(" Rect:"); + rect16_ltrb_print(rect16); + printf("\n"); + } +} + +void U_WMRFLOODFILL_print(const char *contents){ + uint16_t Mode; + U_COLORREF Color; + U_POINT16 coord; + int size = U_WMRFLOODFILL_get(contents, &Mode, &Color, &coord); + if(size > 0){ + printf(" Mode 0x%4.4X\n", Mode); + printf(" Color:"); colorref_print(Color); printf("\n"); + printf(" X,Y {%d,%d}\n", coord.x, coord.y); + } +} + +void U_WMRPIE_print(const char *contents){ + U_POINT16 StartArc, EndArc; + U_RECT16 rect16; + int size = U_WMRPIE_get(contents, &StartArc, &EndArc, &rect16); + if(size > 0){ + printf(" yRadial2:%d\n", EndArc.y); + printf(" xRadial2:%d\n", EndArc.x); + printf(" yRadial1:%d\n", StartArc.y); + printf(" xRadial1:%d\n", StartArc.x); + printf(" Rect:"); rect16_ltrb_print(rect16); printf("\n"); + } +} + +void U_WMRRECTANGLE_print(const char *contents){ + U_RECT16 rect16; + int size = U_WMRRECTANGLE_get(contents, &rect16); + if(size > 0){ + printf(" Rect:"); + rect16_ltrb_print(rect16); + printf("\n"); + } +} + +void U_WMRROUNDRECT_print(const char *contents){ + int16_t Height, Width; + U_RECT16 rect16; + int size = U_WMRROUNDRECT_get(contents, &Width, &Height, &rect16); + if(size > 0){ + printf(" Width:%d\n", Width); + printf(" Height:%d\n", Height); + printf(" Rect:"); + rect16_ltrb_print(rect16); + printf("\n"); + } +} + +void U_WMRPATBLT_print(const char *contents){ + uint32_t dwRop3; + U_POINT16 Dst; + U_POINT16 cwh; + int size = U_WMRPATBLT_get(contents, &Dst, &cwh, &dwRop3); + if(size > 0){ + printf(" Rop3:%8.8X\n", dwRop3 ); + printf(" W,H:%d,%d\n", cwh.x, cwh.y ); + printf(" Dst X,Y:{%d,%d}\n", Dst.x, Dst.y ); + } +} + +void U_WMRSAVEDC_print(const char *contents){ + UNUSED(contents); + /* This record type has only the common 6 bytes, so nothing (else) to print */ +} + +void U_WMRSETPIXEL_print(const char *contents){ + U_COLORREF Color; + U_POINT16 coord; + int size = U_WMRSETPIXEL_get(contents, &Color, &coord); + if(size > 0){ + printf(" Color:"); colorref_print(Color); printf("\n"); + printf(" X,Y {%d,%d}\n", coord.x, coord.y); + } +} + +void U_WMROFFSETCLIPRGN_print(const char *contents){ + U_POINT16 coord; + int size = U_WMROFFSETCLIPRGN_get(contents, &coord); + if(size > 0){ + printf(" %-15s {%d,%d}\n","X,Y",coord.x, coord.y); + } +} + +void U_WMRTEXTOUT_print(const char *contents){ + int16_t Length; + const char *string; + U_POINT16 Dst; + int size = U_WMRTEXTOUT_get(contents, &Dst, &Length, &string); + if(size > 0){ + printf(" X,Y:{%d,%d}\n", Dst.x,Dst.y); + printf(" Length:%d\n", Length); + printf(" String:<%.*s>\n", Length, string); /* May not be null terminated */ + } +} + +void U_WMRBITBLT_print(const char *contents){ + uint32_t dwRop3; + U_POINT16 Dst, Src, cwh; + U_BITMAP16 Bm16; + const char *px; + int size = U_WMRBITBLT_get(contents, &Dst, &cwh, &Src, &dwRop3, &Bm16, &px); + if(size > 0){ + printf(" Rop3:%8.8X\n", dwRop3 ); + printf(" Src X,Y:{%d,%d}\n", Src.x, Src.y); + printf(" W,H:%d,%d\n", cwh.x, cwh.y); + printf(" Dst X,Y:{%d,%d}\n", Dst.x, Dst.y); + if(px){ printf(" Bitmap16:"); bitmap16_print(Bm16); printf("\n"); } + else { printf(" Bitmap16: none\n"); } + } +} + +void U_WMRSTRETCHBLT_print(const char *contents){ + uint32_t dwRop3; + U_POINT16 Dst, Src, cDst, cSrc; + U_BITMAP16 Bm16; + const char *px; + int size = U_WMRSTRETCHBLT_get(contents, &Dst, &cDst, &Src, &cSrc, &dwRop3, &Bm16, &px); + if(size > 0){ + printf(" Rop3:%8.8X\n", dwRop3 ); + printf(" Src W,H:%d,%d\n", cSrc.x, cSrc.y); + printf(" Src X,Y:{%d,%d}\n", Src.x, Src.y ); + printf(" Dst W,H:%d,%d\n", cDst.x, cDst.y); + printf(" Dst X,Y:{%d,%d}\n", Dst.x, Dst.y ); + if(px){ printf(" Bitmap16:"); bitmap16_print(Bm16); printf("\n"); } + else { printf(" Bitmap16: none\n"); } + } +} + +void U_WMRPOLYGON_print(const char *contents){ + uint16_t Length; + const char *Data; + int size = U_WMRPOLYGON_get(contents, &Length, &Data); + if(size > 0){ + wcore_points_print(Length, Data); + } +} + +void U_WMRPOLYLINE_print(const char *contents){ + uint16_t Length; + const char *Data; + int size = U_WMRPOLYLINE_get(contents, &Length, &Data); + if(size > 0){ + wcore_points_print(Length, Data); + } +} + +void U_WMRESCAPE_print(const char *contents){ + uint32_t utmp4; + uint16_t Escape; + uint16_t Length; + const char *Data; + int size = U_WMRESCAPE_get(contents, &Escape, &Length, &Data); + if(size > 0){ + printf(" EscType:%s\n",U_wmr_escnames(Escape)); + printf(" nBytes:%d\n",Length); + if((Escape == U_MFE_SETLINECAP) || (Escape == U_MFE_SETLINEJOIN) || (Escape == U_MFE_SETMITERLIMIT)){ + memcpy(&utmp4, Data ,4); + printf(" Data:%d\n", utmp4); + } + else { + printf(" Data: (not shown)\n"); + } + } +} + +void U_WMRRESTOREDC_print(const char *contents){ + UNUSED(contents); + /* This record type has only the common 6 bytes, so nothing (else) to print */ +} + +void U_WMRFILLREGION_print(const char *contents){ + uint16_t Region; + uint16_t Brush; + int size = U_WMRFILLREGION_get(contents, &Region, &Brush); + if(size > 0){ + printf(" %-15s %d\n","Region", Region); + printf(" %-15s %d\n","Brush", Brush); + } +} + +void U_WMRFRAMEREGION_print(const char *contents){ + uint16_t Region; + uint16_t Brush; + int16_t Height; + int16_t Width; + int size = U_WMRFRAMEREGION_get(contents, &Region, &Brush, &Height, &Width); + if(size > 0){ + printf(" Region:%d\n",Region); + printf(" Brush:%d\n", Brush ); + printf(" Height:%d\n",Height); + printf(" Width:%d\n", Width ); + } +} + +void U_WMRINVERTREGION_print(const char *contents){ + uint16_t Region; + int size = U_WMRSETTEXTALIGN_get(contents, &Region); + if(size > 0){ + printf(" %-15s %d\n","Region:", Region); + } +} + +void U_WMRPAINTREGION_print(const char *contents){ + uint16_t Region; + int size = U_WMRPAINTREGION_get(contents, &Region); + if(size>0){ + printf(" %-15s %d\n","Region:", Region); + } +} + +void U_WMRSELECTCLIPREGION_print(const char *contents){ + uint16_t Region; + int size = U_WMRSELECTCLIPREGION_get(contents, &Region); + if(size>0){ + printf(" %-15s %d\n","Region:", Region); + } +} + +void U_WMRSELECTOBJECT_print(const char *contents){ + uint16_t Object; + int size = U_WMRSELECTOBJECT_get(contents, &Object); + if(size>0){ + printf(" %-15s %d\n","Object:", Object); + } +} + +void U_WMRSETTEXTALIGN_print(const char *contents){ + uint16_t iMode; + int size = U_WMRSETTEXTALIGN_get(contents, &iMode); + if(size>0){ + printf(" %-15s 0x%4.4X\n","iMode:", iMode); + } +} + +#define U_WMRDRAWTEXT_print U_WMRNOTIMPLEMENTED_print + +void U_WMRCHORD_print(const char *contents){ + U_POINT16 StartArc, EndArc; + U_RECT16 rect16; + int size = U_WMRCHORD_get(contents, &StartArc, &EndArc, &rect16); + if(size > 0){ + printf(" yRadial2:%d\n", EndArc.y); + printf(" xRadial2:%d\n", EndArc.x); + printf(" yRadial1:%d\n", StartArc.y); + printf(" xRadial1:%d\n", StartArc.x); + printf(" Rect:"); rect16_ltrb_print(rect16); printf("\n"); + } +} + +void U_WMRSETMAPPERFLAGS_print(const char *contents){ + uint32_t Flags4; + int size = U_WMRSETMAPPERFLAGS_get(contents, &Flags4); + if(size > 0){ + printf(" %-15s 0x%8.8X\n","Flags4:", Flags4); + } +} + +void U_WMREXTTEXTOUT_print(const char *contents){ + U_RECT16 rect16; + U_POINT16 Dst; + int16_t Length; + uint16_t Opts; + const int16_t *dx; + const char *string; + int i; + int size = U_WMREXTTEXTOUT_get(contents, &Dst, &Length, &Opts, &string, &dx, &rect16); + if(size > 0){ + printf(" X,Y:{%d,%d}\n", Dst.x, Dst.y); + printf(" Length:%d\n", Length ); + printf(" Opts:%4.4X\n", Opts ); + if(Opts & (U_ETO_OPAQUE | U_ETO_CLIPPED)){ + printf(" Rect:"); rect16_ltrb_print(rect16); printf("\n"); + } + printf(" String:<%.*s>\n",Length, string); + printf(" Dx:"); + for(i=0; i<Length; i++,dx++){ printf("%d:", *dx ); } + printf("\n"); + } +} + +void U_WMRSETDIBTODEV_print(const char *contents){ + uint16_t cUsage; + uint16_t ScanCount; + uint16_t StartScan; + U_POINT16 Dst; + U_POINT16 cwh; + U_POINT16 Src; + const char *dib; + int size = U_WMRSETDIBTODEV_get(contents, &Dst, &cwh, &Src, &cUsage, &ScanCount, &StartScan, &dib); + if(size > 0){ + printf(" cUsage:%d\n", cUsage ); + printf(" ScanCount:%d\n", ScanCount ); + printf(" StartScan:%d\n", StartScan ); + printf(" Src X,Y:{%d,%d}\n", Src.x, Src.y ); + printf(" W,H:%d,%d\n", cwh.x, cwh.y ); + printf(" Dst X,Y:{%d,%d}\n", Dst.x, Dst.y ); + printf(" DIB:"); dibheader_print(dib, dib+size); printf("\n"); + } +} + +void U_WMRSELECTPALETTE_print(const char *contents){ + uint16_t Palette; + int size = U_WMRSELECTPALETTE_get(contents, &Palette); + if(size > 0){ + printf(" %-15s %d\n","Palette:", Palette); + } +} + +void U_WMRREALIZEPALETTE_print(const char *contents){ + UNUSED(contents); + /* This record type has only the common 6 bytes, so nothing (else) to print */ +} + +void U_WMRANIMATEPALETTE_print(const char *contents){ + U_PALETTE Palette; + const char *PalEntries; + int size = U_WMRANIMATEPALETTE_get(contents, &Palette, &PalEntries); + if(size > 0){ + printf(" Palette:"); palette_print(&Palette, PalEntries); printf("\n"); + + } +} + +void U_WMRSETPALENTRIES_print(const char *contents){ + U_PALETTE Palette; + const char *PalEntries; + int size = U_WMRSETPALENTRIES_get(contents, &Palette, &PalEntries); + if(size > 0){ + printf(" Palette:"); palette_print(&Palette, PalEntries); printf("\n"); + } +} + +void U_WMRPOLYPOLYGON_print(const char *contents){ + uint16_t nPolys; + const uint16_t *aPolyCounts; + const char *Points; + int size = U_WMRPOLYPOLYGON_get(contents, &nPolys, &aPolyCounts, &Points); + if(size > 0){ + printf(" Polygons:"); polypolygon_print(nPolys, aPolyCounts, Points); printf("\n"); + } +} + +void U_WMRRESIZEPALETTE_print(const char *contents){ + uint16_t Palette; + int size = U_WMRSELECTCLIPREGION_get(contents, &Palette); + if(size>0){ + printf(" %-15s %d\n","Palette:", Palette); + } +} + +#define U_WMR3A_print U_WMRNOTIMPLEMENTED_print +#define U_WMR3B_print U_WMRNOTIMPLEMENTED_print +#define U_WMR3C_print U_WMRNOTIMPLEMENTED_print +#define U_WMR3D_print U_WMRNOTIMPLEMENTED_print +#define U_WMR3E_print U_WMRNOTIMPLEMENTED_print +#define U_WMR3F_print U_WMRNOTIMPLEMENTED_print + +void U_WMRDIBBITBLT_print(const char *contents){ + U_POINT16 Dst, cwh, Src; + uint32_t dwRop3; + const char *dib; + int size = U_WMRDIBBITBLT_get(contents, &Dst, &cwh, &Src, &dwRop3, &dib); + if(size > 0){ + printf(" Rop3:%8.8X\n", dwRop3 ); + printf(" Src X,Y:{%d,%d}\n", Src.x, Src.x ); + printf(" W,H:%d,%d\n", cwh.x, cwh.y ); + printf(" Dst X,Y:{%d,%d}\n", Dst.x, Dst.y ); + if(dib){ printf(" DIB:"); dibheader_print(dib, dib+size); printf("\n"); } + else { printf(" DIB: none\n"); } + } +} + +void U_WMRDIBSTRETCHBLT_print(const char *contents){ + U_POINT16 Dst, cDst, Src, cSrc; + uint32_t dwRop3; + const char *dib; + int size = U_WMRDIBSTRETCHBLT_get(contents, &Dst, &cDst, &Src, &cSrc, &dwRop3, &dib); + if(size > 0){ + printf(" Rop3:%8.8X\n", dwRop3 ); + printf(" Src W,H:%d,%d\n", cSrc.x, cSrc.y ); + printf(" Src X,Y:{%d,%d}\n", Src.x, Src.x ); + printf(" Dst W,H:%d,%d\n", cDst.x, cDst.y ); + printf(" Dst X,Y:{%d,%d}\n", Dst.x, Dst.y ); + if(dib){ printf(" DIB:"); dibheader_print(dib, dib+size); printf("\n"); } + else { printf(" DIB: none\n"); } + } +} + +void U_WMRDIBCREATEPATTERNBRUSH_print(const char *contents){ + uint16_t Style, cUsage; + const char *TBm16; + const char *dib; + int size = U_WMRDIBCREATEPATTERNBRUSH_get(contents, &Style, &cUsage, &TBm16, &dib); + if(size > 0){ + U_BITMAP16 Bm16; + printf(" Style:%d\n", Style ); + printf(" cUsage:%d\n", cUsage); + if(TBm16){ + memcpy(&Bm16, TBm16, U_SIZE_BITMAP16); + printf(" Src:Bitmap16:"); bitmap16_print(Bm16); printf("\n"); + } + else { /* from DIB */ + printf(" Src:DIB:"); dibheader_print(dib, dib+size); printf("\n"); + } + } +} + +void U_WMRSTRETCHDIB_print(const char *contents){ + U_POINT16 Dst, cDst, Src, cSrc; + uint32_t dwRop3; + uint16_t cUsage; + const char *dib; + int size = U_WMRSTRETCHDIB_get(contents, &Dst, &cDst, &Src, &cSrc, &cUsage, &dwRop3, &dib); + if(size > 0){ + printf(" Rop3:%8.8X\n", dwRop3 ); + printf(" cUsage:%d\n", cUsage ); + printf(" Src W,H:%d,%d\n", cSrc.x, cSrc.y ); + printf(" Src X,Y:{%d,%d}\n", Src.x, Src.x ); + printf(" Dst W,H:%d,%d\n", cDst.x, cDst.y ); + printf(" Dst X,Y:{%d,%d}\n", Dst.x, Dst.y ); + if(dib){ printf(" DIB:"); dibheader_print(dib, dib+size); printf("\n"); } + else { printf(" DIB: none\n"); } + } +} + +#define U_WMR44_print U_WMRNOTIMPLEMENTED_print +#define U_WMR45_print U_WMRNOTIMPLEMENTED_print +#define U_WMR46_print U_WMRNOTIMPLEMENTED_print +#define U_WMR47_print U_WMRNOTIMPLEMENTED_print + +void U_WMREXTFLOODFILL_print(const char *contents){ + uint16_t Mode; + U_COLORREF Color; + U_POINT16 coord; + int size = U_WMREXTFLOODFILL_get(contents, &Mode, &Color, &coord); + if(size > 0){ + printf(" Mode 0x%4.4X\n", Mode); + printf(" Color:"); colorref_print(Color); printf("\n"); + printf(" X,Y {%d,%d}\n", coord.x, coord.y); + } +} + +#define U_WMR49_print U_WMRNOTIMPLEMENTED_print +#define U_WMR4A_print U_WMRNOTIMPLEMENTED_print +#define U_WMR4B_print U_WMRNOTIMPLEMENTED_print +#define U_WMR4C_print U_WMRNOTIMPLEMENTED_print +#define U_WMR4D_print U_WMRNOTIMPLEMENTED_print +#define U_WMR4E_print U_WMRNOTIMPLEMENTED_print +#define U_WMR4F_print U_WMRNOTIMPLEMENTED_print +#define U_WMR50_print U_WMRNOTIMPLEMENTED_print +#define U_WMR51_print U_WMRNOTIMPLEMENTED_print +#define U_WMR52_print U_WMRNOTIMPLEMENTED_print +#define U_WMR53_print U_WMRNOTIMPLEMENTED_print +#define U_WMR54_print U_WMRNOTIMPLEMENTED_print +#define U_WMR55_print U_WMRNOTIMPLEMENTED_print +#define U_WMR56_print U_WMRNOTIMPLEMENTED_print +#define U_WMR57_print U_WMRNOTIMPLEMENTED_print +#define U_WMR58_print U_WMRNOTIMPLEMENTED_print +#define U_WMR59_print U_WMRNOTIMPLEMENTED_print +#define U_WMR5A_print U_WMRNOTIMPLEMENTED_print +#define U_WMR5B_print U_WMRNOTIMPLEMENTED_print +#define U_WMR5C_print U_WMRNOTIMPLEMENTED_print +#define U_WMR5D_print U_WMRNOTIMPLEMENTED_print +#define U_WMR5E_print U_WMRNOTIMPLEMENTED_print +#define U_WMR5F_print U_WMRNOTIMPLEMENTED_print +#define U_WMR60_print U_WMRNOTIMPLEMENTED_print +#define U_WMR61_print U_WMRNOTIMPLEMENTED_print +#define U_WMR62_print U_WMRNOTIMPLEMENTED_print +#define U_WMR63_print U_WMRNOTIMPLEMENTED_print +#define U_WMR64_print U_WMRNOTIMPLEMENTED_print +#define U_WMR65_print U_WMRNOTIMPLEMENTED_print +#define U_WMR66_print U_WMRNOTIMPLEMENTED_print +#define U_WMR67_print U_WMRNOTIMPLEMENTED_print +#define U_WMR68_print U_WMRNOTIMPLEMENTED_print +#define U_WMR69_print U_WMRNOTIMPLEMENTED_print +#define U_WMR6A_print U_WMRNOTIMPLEMENTED_print +#define U_WMR6B_print U_WMRNOTIMPLEMENTED_print +#define U_WMR6C_print U_WMRNOTIMPLEMENTED_print +#define U_WMR6D_print U_WMRNOTIMPLEMENTED_print +#define U_WMR6E_print U_WMRNOTIMPLEMENTED_print +#define U_WMR6F_print U_WMRNOTIMPLEMENTED_print +#define U_WMR70_print U_WMRNOTIMPLEMENTED_print +#define U_WMR71_print U_WMRNOTIMPLEMENTED_print +#define U_WMR72_print U_WMRNOTIMPLEMENTED_print +#define U_WMR73_print U_WMRNOTIMPLEMENTED_print +#define U_WMR74_print U_WMRNOTIMPLEMENTED_print +#define U_WMR75_print U_WMRNOTIMPLEMENTED_print +#define U_WMR76_print U_WMRNOTIMPLEMENTED_print +#define U_WMR77_print U_WMRNOTIMPLEMENTED_print +#define U_WMR78_print U_WMRNOTIMPLEMENTED_print +#define U_WMR79_print U_WMRNOTIMPLEMENTED_print +#define U_WMR7A_print U_WMRNOTIMPLEMENTED_print +#define U_WMR7B_print U_WMRNOTIMPLEMENTED_print +#define U_WMR7C_print U_WMRNOTIMPLEMENTED_print +#define U_WMR7D_print U_WMRNOTIMPLEMENTED_print +#define U_WMR7E_print U_WMRNOTIMPLEMENTED_print +#define U_WMR7F_print U_WMRNOTIMPLEMENTED_print +#define U_WMR80_print U_WMRNOTIMPLEMENTED_print +#define U_WMR81_print U_WMRNOTIMPLEMENTED_print +#define U_WMR82_print U_WMRNOTIMPLEMENTED_print +#define U_WMR83_print U_WMRNOTIMPLEMENTED_print +#define U_WMR84_print U_WMRNOTIMPLEMENTED_print +#define U_WMR85_print U_WMRNOTIMPLEMENTED_print +#define U_WMR86_print U_WMRNOTIMPLEMENTED_print +#define U_WMR87_print U_WMRNOTIMPLEMENTED_print +#define U_WMR88_print U_WMRNOTIMPLEMENTED_print +#define U_WMR89_print U_WMRNOTIMPLEMENTED_print +#define U_WMR8A_print U_WMRNOTIMPLEMENTED_print +#define U_WMR8B_print U_WMRNOTIMPLEMENTED_print +#define U_WMR8C_print U_WMRNOTIMPLEMENTED_print +#define U_WMR8D_print U_WMRNOTIMPLEMENTED_print +#define U_WMR8E_print U_WMRNOTIMPLEMENTED_print +#define U_WMR8F_print U_WMRNOTIMPLEMENTED_print +#define U_WMR90_print U_WMRNOTIMPLEMENTED_print +#define U_WMR91_print U_WMRNOTIMPLEMENTED_print +#define U_WMR92_print U_WMRNOTIMPLEMENTED_print +#define U_WMR93_print U_WMRNOTIMPLEMENTED_print +#define U_WMR94_print U_WMRNOTIMPLEMENTED_print +#define U_WMR95_print U_WMRNOTIMPLEMENTED_print +#define U_WMR96_print U_WMRNOTIMPLEMENTED_print +#define U_WMR97_print U_WMRNOTIMPLEMENTED_print +#define U_WMR98_print U_WMRNOTIMPLEMENTED_print +#define U_WMR99_print U_WMRNOTIMPLEMENTED_print +#define U_WMR9A_print U_WMRNOTIMPLEMENTED_print +#define U_WMR9B_print U_WMRNOTIMPLEMENTED_print +#define U_WMR9C_print U_WMRNOTIMPLEMENTED_print +#define U_WMR9D_print U_WMRNOTIMPLEMENTED_print +#define U_WMR9E_print U_WMRNOTIMPLEMENTED_print +#define U_WMR9F_print U_WMRNOTIMPLEMENTED_print +#define U_WMRA0_print U_WMRNOTIMPLEMENTED_print +#define U_WMRA1_print U_WMRNOTIMPLEMENTED_print +#define U_WMRA2_print U_WMRNOTIMPLEMENTED_print +#define U_WMRA3_print U_WMRNOTIMPLEMENTED_print +#define U_WMRA4_print U_WMRNOTIMPLEMENTED_print +#define U_WMRA5_print U_WMRNOTIMPLEMENTED_print +#define U_WMRA6_print U_WMRNOTIMPLEMENTED_print +#define U_WMRA7_print U_WMRNOTIMPLEMENTED_print +#define U_WMRA8_print U_WMRNOTIMPLEMENTED_print +#define U_WMRA9_print U_WMRNOTIMPLEMENTED_print +#define U_WMRAA_print U_WMRNOTIMPLEMENTED_print +#define U_WMRAB_print U_WMRNOTIMPLEMENTED_print +#define U_WMRAC_print U_WMRNOTIMPLEMENTED_print +#define U_WMRAD_print U_WMRNOTIMPLEMENTED_print +#define U_WMRAE_print U_WMRNOTIMPLEMENTED_print +#define U_WMRAF_print U_WMRNOTIMPLEMENTED_print +#define U_WMRB0_print U_WMRNOTIMPLEMENTED_print +#define U_WMRB1_print U_WMRNOTIMPLEMENTED_print +#define U_WMRB2_print U_WMRNOTIMPLEMENTED_print +#define U_WMRB3_print U_WMRNOTIMPLEMENTED_print +#define U_WMRB4_print U_WMRNOTIMPLEMENTED_print +#define U_WMRB5_print U_WMRNOTIMPLEMENTED_print +#define U_WMRB6_print U_WMRNOTIMPLEMENTED_print +#define U_WMRB7_print U_WMRNOTIMPLEMENTED_print +#define U_WMRB8_print U_WMRNOTIMPLEMENTED_print +#define U_WMRB9_print U_WMRNOTIMPLEMENTED_print +#define U_WMRBA_print U_WMRNOTIMPLEMENTED_print +#define U_WMRBB_print U_WMRNOTIMPLEMENTED_print +#define U_WMRBC_print U_WMRNOTIMPLEMENTED_print +#define U_WMRBD_print U_WMRNOTIMPLEMENTED_print +#define U_WMRBE_print U_WMRNOTIMPLEMENTED_print +#define U_WMRBF_print U_WMRNOTIMPLEMENTED_print +#define U_WMRC0_print U_WMRNOTIMPLEMENTED_print +#define U_WMRC1_print U_WMRNOTIMPLEMENTED_print +#define U_WMRC2_print U_WMRNOTIMPLEMENTED_print +#define U_WMRC3_print U_WMRNOTIMPLEMENTED_print +#define U_WMRC4_print U_WMRNOTIMPLEMENTED_print +#define U_WMRC5_print U_WMRNOTIMPLEMENTED_print +#define U_WMRC6_print U_WMRNOTIMPLEMENTED_print +#define U_WMRC7_print U_WMRNOTIMPLEMENTED_print +#define U_WMRC8_print U_WMRNOTIMPLEMENTED_print +#define U_WMRC9_print U_WMRNOTIMPLEMENTED_print +#define U_WMRCA_print U_WMRNOTIMPLEMENTED_print +#define U_WMRCB_print U_WMRNOTIMPLEMENTED_print +#define U_WMRCC_print U_WMRNOTIMPLEMENTED_print +#define U_WMRCD_print U_WMRNOTIMPLEMENTED_print +#define U_WMRCE_print U_WMRNOTIMPLEMENTED_print +#define U_WMRCF_print U_WMRNOTIMPLEMENTED_print +#define U_WMRD0_print U_WMRNOTIMPLEMENTED_print +#define U_WMRD1_print U_WMRNOTIMPLEMENTED_print +#define U_WMRD2_print U_WMRNOTIMPLEMENTED_print +#define U_WMRD3_print U_WMRNOTIMPLEMENTED_print +#define U_WMRD4_print U_WMRNOTIMPLEMENTED_print +#define U_WMRD5_print U_WMRNOTIMPLEMENTED_print +#define U_WMRD6_print U_WMRNOTIMPLEMENTED_print +#define U_WMRD7_print U_WMRNOTIMPLEMENTED_print +#define U_WMRD8_print U_WMRNOTIMPLEMENTED_print +#define U_WMRD9_print U_WMRNOTIMPLEMENTED_print +#define U_WMRDA_print U_WMRNOTIMPLEMENTED_print +#define U_WMRDB_print U_WMRNOTIMPLEMENTED_print +#define U_WMRDC_print U_WMRNOTIMPLEMENTED_print +#define U_WMRDD_print U_WMRNOTIMPLEMENTED_print +#define U_WMRDE_print U_WMRNOTIMPLEMENTED_print +#define U_WMRDF_print U_WMRNOTIMPLEMENTED_print +#define U_WMRE0_print U_WMRNOTIMPLEMENTED_print +#define U_WMRE1_print U_WMRNOTIMPLEMENTED_print +#define U_WMRE2_print U_WMRNOTIMPLEMENTED_print +#define U_WMRE3_print U_WMRNOTIMPLEMENTED_print +#define U_WMRE4_print U_WMRNOTIMPLEMENTED_print +#define U_WMRE5_print U_WMRNOTIMPLEMENTED_print +#define U_WMRE6_print U_WMRNOTIMPLEMENTED_print +#define U_WMRE7_print U_WMRNOTIMPLEMENTED_print +#define U_WMRE8_print U_WMRNOTIMPLEMENTED_print +#define U_WMRE9_print U_WMRNOTIMPLEMENTED_print +#define U_WMREA_print U_WMRNOTIMPLEMENTED_print +#define U_WMREB_print U_WMRNOTIMPLEMENTED_print +#define U_WMREC_print U_WMRNOTIMPLEMENTED_print +#define U_WMRED_print U_WMRNOTIMPLEMENTED_print +#define U_WMREE_print U_WMRNOTIMPLEMENTED_print +#define U_WMREF_print U_WMRNOTIMPLEMENTED_print + +void U_WMRDELETEOBJECT_print(const char *contents){ + uint16_t Object; + int size = U_WMRDELETEOBJECT_get(contents, &Object); + if(size>0){ + printf(" %-15s %d\n","Object:", Object); + } +} + +#define U_WMRF1_print U_WMRNOTIMPLEMENTED_print +#define U_WMRF2_print U_WMRNOTIMPLEMENTED_print +#define U_WMRF3_print U_WMRNOTIMPLEMENTED_print +#define U_WMRF4_print U_WMRNOTIMPLEMENTED_print +#define U_WMRF5_print U_WMRNOTIMPLEMENTED_print +#define U_WMRF6_print U_WMRNOTIMPLEMENTED_print + +void U_WMRCREATEPALETTE_print(const char *contents){ + U_PALETTE Palette; + const char *PalEntries; + int size = U_WMRCREATEPALETTE_get(contents, &Palette, &PalEntries); + if(size > 0){ + printf(" Palette:"); palette_print(&Palette, PalEntries); printf("\n"); + + } +} + +#define U_WMRF8_print U_WMRNOTIMPLEMENTED_print + +void U_WMRCREATEPATTERNBRUSH_print(const char *contents){ + U_BITMAP16 Bm16; + int pasize; + int i; + const char *Pattern; + + int size = U_WMRCREATEPATTERNBRUSH_get(contents, &Bm16, &pasize, &Pattern); + if(size > 0){ + /* BM16 is truncated, but bitmap16_print does not get into the part that was omitted */ + printf(" BitMap16: "); bitmap16_print(Bm16); printf("\n"); + printf(" Pattern: "); + for(i=0;i<pasize;i++){ + printf("%2.2X ",Pattern[i]); + } + printf("\n"); + } +} + +void U_WMRCREATEPENINDIRECT_print(const char *contents){ + U_PEN pen; + int size = U_WMRCREATEPENINDIRECT_get(contents, &pen); + if(size > 0){ + printf(" Pen:"); pen_print(pen); printf("\n"); + } +} + +void U_WMRCREATEFONTINDIRECT_print(const char *contents){ + const char *font; /* Note, because of possible struct alignment issue have to use char * to reference the data */ + int size = U_WMRCREATEFONTINDIRECT_get(contents, &font); + if(size > 0){ + printf(" Font:"); + font_print(font); + printf("\n"); + } +} + +void U_WMRCREATEBRUSHINDIRECT_print(const char *contents){ + const char *brush; /* Note, because of possible struct alignment issue have to use char * to reference the data */ + int size = U_WMRCREATEBRUSHINDIRECT_get(contents, &brush); + if(size > 0){ + printf(" Brush:"); + wlogbrush_print(brush); + printf("\n"); + } +} + +void U_WMRCREATEBITMAPINDIRECT_print(const char *contents){ /* in Wine, not in WMF PDF */ + U_WMRNOTIMPLEMENTED_print(contents); +} + +void U_WMRCREATEBITMAP_print(const char *contents){ /* in Wine, not in WMF PDF */ + U_WMRNOTIMPLEMENTED_print(contents); +} + +void U_WMRCREATEREGION_print(const char *contents){ + const char *region; /* Note, because of possible struct alignment issue have to use char * to reference the data */ + int size = U_WMRCREATEBRUSHINDIRECT_get(contents, ®ion); + if(size > 0){ + printf(" Brush:"); + printf(" Region: "); region_print(region); printf("\n"); + } +} + +//! \endcond + +/** + \brief Print any record in a wmf + \returns record length for a normal record, 0 for WMREOF, -1 for a bad record + \param contents pointer to a buffer holding all WMR records + \param blimit one byte past the last WMF record in memory. + \param recnum number of this record in contents + \param off offset to this record in contents +*/ +int U_wmf_onerec_print(const char *contents, const char *blimit, int recnum, size_t off){ + + + uint8_t iType; + size_t size; + + contents += off; + + /* Check that the record size is OK, abort if not. + Pointer math might wrap, so check both sides of the range */ + size = U_WMRRECSAFE_get(contents, blimit); + if(!size)return(-1); + + iType = *(uint8_t *)(contents + offsetof(U_METARECORD, iType ) ); + + uint32_t crc; +#if U_BYTE_SWAP + //This is a Big Endian machine, WMF crc values must be calculated on Little Endian form + char *swapbuf=malloc(size); + if(!swapbuf)return(-1); + memcpy(swapbuf,contents,size); + U_wmf_endian(swapbuf,size,1,1); // BE to LE + crc=lu_crc32(swapbuf,size); + free(swapbuf); +#else + crc=lu_crc32(contents,size); +#endif + printf("%-30srecord:%5d type:%-4u offset:%8d rsize:%8u crc32:%8.8X\n", + U_wmr_names(iType), recnum, iType, (int) off, (int) size, crc); + + switch (iType) + { + case U_WMR_EOF: U_WMREOF_print(contents); size=0; break; + case U_WMR_SETBKCOLOR: U_WMRSETBKCOLOR_print(contents); break; + case U_WMR_SETBKMODE: U_WMRSETBKMODE_print(contents); break; + case U_WMR_SETMAPMODE: U_WMRSETMAPMODE_print(contents); break; + case U_WMR_SETROP2: U_WMRSETROP2_print(contents); break; + case U_WMR_SETRELABS: U_WMRSETRELABS_print(contents); break; + case U_WMR_SETPOLYFILLMODE: U_WMRSETPOLYFILLMODE_print(contents); break; + case U_WMR_SETSTRETCHBLTMODE: U_WMRSETSTRETCHBLTMODE_print(contents); break; + case U_WMR_SETTEXTCHAREXTRA: U_WMRSETTEXTCHAREXTRA_print(contents); break; + case U_WMR_SETTEXTCOLOR: U_WMRSETTEXTCOLOR_print(contents); break; + case U_WMR_SETTEXTJUSTIFICATION: U_WMRSETTEXTJUSTIFICATION_print(contents); break; + case U_WMR_SETWINDOWORG: U_WMRSETWINDOWORG_print(contents); break; + case U_WMR_SETWINDOWEXT: U_WMRSETWINDOWEXT_print(contents); break; + case U_WMR_SETVIEWPORTORG: U_WMRSETVIEWPORTORG_print(contents); break; + case U_WMR_SETVIEWPORTEXT: U_WMRSETVIEWPORTEXT_print(contents); break; + case U_WMR_OFFSETWINDOWORG: U_WMROFFSETWINDOWORG_print(contents); break; + case U_WMR_SCALEWINDOWEXT: U_WMRSCALEWINDOWEXT_print(contents); break; + case U_WMR_OFFSETVIEWPORTORG: U_WMROFFSETVIEWPORTORG_print(contents); break; + case U_WMR_SCALEVIEWPORTEXT: U_WMRSCALEVIEWPORTEXT_print(contents); break; + case U_WMR_LINETO: U_WMRLINETO_print(contents); break; + case U_WMR_MOVETO: U_WMRMOVETO_print(contents); break; + case U_WMR_EXCLUDECLIPRECT: U_WMREXCLUDECLIPRECT_print(contents); break; + case U_WMR_INTERSECTCLIPRECT: U_WMRINTERSECTCLIPRECT_print(contents); break; + case U_WMR_ARC: U_WMRARC_print(contents); break; + case U_WMR_ELLIPSE: U_WMRELLIPSE_print(contents); break; + case U_WMR_FLOODFILL: U_WMRFLOODFILL_print(contents); break; + case U_WMR_PIE: U_WMRPIE_print(contents); break; + case U_WMR_RECTANGLE: U_WMRRECTANGLE_print(contents); break; + case U_WMR_ROUNDRECT: U_WMRROUNDRECT_print(contents); break; + case U_WMR_PATBLT: U_WMRPATBLT_print(contents); break; + case U_WMR_SAVEDC: U_WMRSAVEDC_print(contents); break; + case U_WMR_SETPIXEL: U_WMRSETPIXEL_print(contents); break; + case U_WMR_OFFSETCLIPRGN: U_WMROFFSETCLIPRGN_print(contents); break; + case U_WMR_TEXTOUT: U_WMRTEXTOUT_print(contents); break; + case U_WMR_BITBLT: U_WMRBITBLT_print(contents); break; + case U_WMR_STRETCHBLT: U_WMRSTRETCHBLT_print(contents); break; + case U_WMR_POLYGON: U_WMRPOLYGON_print(contents); break; + case U_WMR_POLYLINE: U_WMRPOLYLINE_print(contents); break; + case U_WMR_ESCAPE: U_WMRESCAPE_print(contents); break; + case U_WMR_RESTOREDC: U_WMRRESTOREDC_print(contents); break; + case U_WMR_FILLREGION: U_WMRFILLREGION_print(contents); break; + case U_WMR_FRAMEREGION: U_WMRFRAMEREGION_print(contents); break; + case U_WMR_INVERTREGION: U_WMRINVERTREGION_print(contents); break; + case U_WMR_PAINTREGION: U_WMRPAINTREGION_print(contents); break; + case U_WMR_SELECTCLIPREGION: U_WMRSELECTCLIPREGION_print(contents); break; + case U_WMR_SELECTOBJECT: U_WMRSELECTOBJECT_print(contents); break; + case U_WMR_SETTEXTALIGN: U_WMRSETTEXTALIGN_print(contents); break; + case U_WMR_DRAWTEXT: U_WMRDRAWTEXT_print(contents); break; + case U_WMR_CHORD: U_WMRCHORD_print(contents); break; + case U_WMR_SETMAPPERFLAGS: U_WMRSETMAPPERFLAGS_print(contents); break; + case U_WMR_EXTTEXTOUT: U_WMREXTTEXTOUT_print(contents); break; + case U_WMR_SETDIBTODEV: U_WMRSETDIBTODEV_print(contents); break; + case U_WMR_SELECTPALETTE: U_WMRSELECTPALETTE_print(contents); break; + case U_WMR_REALIZEPALETTE: U_WMRREALIZEPALETTE_print(contents); break; + case U_WMR_ANIMATEPALETTE: U_WMRANIMATEPALETTE_print(contents); break; + case U_WMR_SETPALENTRIES: U_WMRSETPALENTRIES_print(contents); break; + case U_WMR_POLYPOLYGON: U_WMRPOLYPOLYGON_print(contents); break; + case U_WMR_RESIZEPALETTE: U_WMRRESIZEPALETTE_print(contents); break; + case U_WMR_3A: U_WMR3A_print(contents); break; + case U_WMR_3B: U_WMR3B_print(contents); break; + case U_WMR_3C: U_WMR3C_print(contents); break; + case U_WMR_3D: U_WMR3D_print(contents); break; + case U_WMR_3E: U_WMR3E_print(contents); break; + case U_WMR_3F: U_WMR3F_print(contents); break; + case U_WMR_DIBBITBLT: U_WMRDIBBITBLT_print(contents); break; + case U_WMR_DIBSTRETCHBLT: U_WMRDIBSTRETCHBLT_print(contents); break; + case U_WMR_DIBCREATEPATTERNBRUSH: U_WMRDIBCREATEPATTERNBRUSH_print(contents); break; + case U_WMR_STRETCHDIB: U_WMRSTRETCHDIB_print(contents); break; + case U_WMR_44: U_WMR44_print(contents); break; + case U_WMR_45: U_WMR45_print(contents); break; + case U_WMR_46: U_WMR46_print(contents); break; + case U_WMR_47: U_WMR47_print(contents); break; + case U_WMR_EXTFLOODFILL: U_WMREXTFLOODFILL_print(contents); break; + case U_WMR_49: U_WMR49_print(contents); break; + case U_WMR_4A: U_WMR4A_print(contents); break; + case U_WMR_4B: U_WMR4B_print(contents); break; + case U_WMR_4C: U_WMR4C_print(contents); break; + case U_WMR_4D: U_WMR4D_print(contents); break; + case U_WMR_4E: U_WMR4E_print(contents); break; + case U_WMR_4F: U_WMR4F_print(contents); break; + case U_WMR_50: U_WMR50_print(contents); break; + case U_WMR_51: U_WMR51_print(contents); break; + case U_WMR_52: U_WMR52_print(contents); break; + case U_WMR_53: U_WMR53_print(contents); break; + case U_WMR_54: U_WMR54_print(contents); break; + case U_WMR_55: U_WMR55_print(contents); break; + case U_WMR_56: U_WMR56_print(contents); break; + case U_WMR_57: U_WMR57_print(contents); break; + case U_WMR_58: U_WMR58_print(contents); break; + case U_WMR_59: U_WMR59_print(contents); break; + case U_WMR_5A: U_WMR5A_print(contents); break; + case U_WMR_5B: U_WMR5B_print(contents); break; + case U_WMR_5C: U_WMR5C_print(contents); break; + case U_WMR_5D: U_WMR5D_print(contents); break; + case U_WMR_5E: U_WMR5E_print(contents); break; + case U_WMR_5F: U_WMR5F_print(contents); break; + case U_WMR_60: U_WMR60_print(contents); break; + case U_WMR_61: U_WMR61_print(contents); break; + case U_WMR_62: U_WMR62_print(contents); break; + case U_WMR_63: U_WMR63_print(contents); break; + case U_WMR_64: U_WMR64_print(contents); break; + case U_WMR_65: U_WMR65_print(contents); break; + case U_WMR_66: U_WMR66_print(contents); break; + case U_WMR_67: U_WMR67_print(contents); break; + case U_WMR_68: U_WMR68_print(contents); break; + case U_WMR_69: U_WMR69_print(contents); break; + case U_WMR_6A: U_WMR6A_print(contents); break; + case U_WMR_6B: U_WMR6B_print(contents); break; + case U_WMR_6C: U_WMR6C_print(contents); break; + case U_WMR_6D: U_WMR6D_print(contents); break; + case U_WMR_6E: U_WMR6E_print(contents); break; + case U_WMR_6F: U_WMR6F_print(contents); break; + case U_WMR_70: U_WMR70_print(contents); break; + case U_WMR_71: U_WMR71_print(contents); break; + case U_WMR_72: U_WMR72_print(contents); break; + case U_WMR_73: U_WMR73_print(contents); break; + case U_WMR_74: U_WMR74_print(contents); break; + case U_WMR_75: U_WMR75_print(contents); break; + case U_WMR_76: U_WMR76_print(contents); break; + case U_WMR_77: U_WMR77_print(contents); break; + case U_WMR_78: U_WMR78_print(contents); break; + case U_WMR_79: U_WMR79_print(contents); break; + case U_WMR_7A: U_WMR7A_print(contents); break; + case U_WMR_7B: U_WMR7B_print(contents); break; + case U_WMR_7C: U_WMR7C_print(contents); break; + case U_WMR_7D: U_WMR7D_print(contents); break; + case U_WMR_7E: U_WMR7E_print(contents); break; + case U_WMR_7F: U_WMR7F_print(contents); break; + case U_WMR_80: U_WMR80_print(contents); break; + case U_WMR_81: U_WMR81_print(contents); break; + case U_WMR_82: U_WMR82_print(contents); break; + case U_WMR_83: U_WMR83_print(contents); break; + case U_WMR_84: U_WMR84_print(contents); break; + case U_WMR_85: U_WMR85_print(contents); break; + case U_WMR_86: U_WMR86_print(contents); break; + case U_WMR_87: U_WMR87_print(contents); break; + case U_WMR_88: U_WMR88_print(contents); break; + case U_WMR_89: U_WMR89_print(contents); break; + case U_WMR_8A: U_WMR8A_print(contents); break; + case U_WMR_8B: U_WMR8B_print(contents); break; + case U_WMR_8C: U_WMR8C_print(contents); break; + case U_WMR_8D: U_WMR8D_print(contents); break; + case U_WMR_8E: U_WMR8E_print(contents); break; + case U_WMR_8F: U_WMR8F_print(contents); break; + case U_WMR_90: U_WMR90_print(contents); break; + case U_WMR_91: U_WMR91_print(contents); break; + case U_WMR_92: U_WMR92_print(contents); break; + case U_WMR_93: U_WMR93_print(contents); break; + case U_WMR_94: U_WMR94_print(contents); break; + case U_WMR_95: U_WMR95_print(contents); break; + case U_WMR_96: U_WMR96_print(contents); break; + case U_WMR_97: U_WMR97_print(contents); break; + case U_WMR_98: U_WMR98_print(contents); break; + case U_WMR_99: U_WMR99_print(contents); break; + case U_WMR_9A: U_WMR9A_print(contents); break; + case U_WMR_9B: U_WMR9B_print(contents); break; + case U_WMR_9C: U_WMR9C_print(contents); break; + case U_WMR_9D: U_WMR9D_print(contents); break; + case U_WMR_9E: U_WMR9E_print(contents); break; + case U_WMR_9F: U_WMR9F_print(contents); break; + case U_WMR_A0: U_WMRA0_print(contents); break; + case U_WMR_A1: U_WMRA1_print(contents); break; + case U_WMR_A2: U_WMRA2_print(contents); break; + case U_WMR_A3: U_WMRA3_print(contents); break; + case U_WMR_A4: U_WMRA4_print(contents); break; + case U_WMR_A5: U_WMRA5_print(contents); break; + case U_WMR_A6: U_WMRA6_print(contents); break; + case U_WMR_A7: U_WMRA7_print(contents); break; + case U_WMR_A8: U_WMRA8_print(contents); break; + case U_WMR_A9: U_WMRA9_print(contents); break; + case U_WMR_AA: U_WMRAA_print(contents); break; + case U_WMR_AB: U_WMRAB_print(contents); break; + case U_WMR_AC: U_WMRAC_print(contents); break; + case U_WMR_AD: U_WMRAD_print(contents); break; + case U_WMR_AE: U_WMRAE_print(contents); break; + case U_WMR_AF: U_WMRAF_print(contents); break; + case U_WMR_B0: U_WMRB0_print(contents); break; + case U_WMR_B1: U_WMRB1_print(contents); break; + case U_WMR_B2: U_WMRB2_print(contents); break; + case U_WMR_B3: U_WMRB3_print(contents); break; + case U_WMR_B4: U_WMRB4_print(contents); break; + case U_WMR_B5: U_WMRB5_print(contents); break; + case U_WMR_B6: U_WMRB6_print(contents); break; + case U_WMR_B7: U_WMRB7_print(contents); break; + case U_WMR_B8: U_WMRB8_print(contents); break; + case U_WMR_B9: U_WMRB9_print(contents); break; + case U_WMR_BA: U_WMRBA_print(contents); break; + case U_WMR_BB: U_WMRBB_print(contents); break; + case U_WMR_BC: U_WMRBC_print(contents); break; + case U_WMR_BD: U_WMRBD_print(contents); break; + case U_WMR_BE: U_WMRBE_print(contents); break; + case U_WMR_BF: U_WMRBF_print(contents); break; + case U_WMR_C0: U_WMRC0_print(contents); break; + case U_WMR_C1: U_WMRC1_print(contents); break; + case U_WMR_C2: U_WMRC2_print(contents); break; + case U_WMR_C3: U_WMRC3_print(contents); break; + case U_WMR_C4: U_WMRC4_print(contents); break; + case U_WMR_C5: U_WMRC5_print(contents); break; + case U_WMR_C6: U_WMRC6_print(contents); break; + case U_WMR_C7: U_WMRC7_print(contents); break; + case U_WMR_C8: U_WMRC8_print(contents); break; + case U_WMR_C9: U_WMRC9_print(contents); break; + case U_WMR_CA: U_WMRCA_print(contents); break; + case U_WMR_CB: U_WMRCB_print(contents); break; + case U_WMR_CC: U_WMRCC_print(contents); break; + case U_WMR_CD: U_WMRCD_print(contents); break; + case U_WMR_CE: U_WMRCE_print(contents); break; + case U_WMR_CF: U_WMRCF_print(contents); break; + case U_WMR_D0: U_WMRD0_print(contents); break; + case U_WMR_D1: U_WMRD1_print(contents); break; + case U_WMR_D2: U_WMRD2_print(contents); break; + case U_WMR_D3: U_WMRD3_print(contents); break; + case U_WMR_D4: U_WMRD4_print(contents); break; + case U_WMR_D5: U_WMRD5_print(contents); break; + case U_WMR_D6: U_WMRD6_print(contents); break; + case U_WMR_D7: U_WMRD7_print(contents); break; + case U_WMR_D8: U_WMRD8_print(contents); break; + case U_WMR_D9: U_WMRD9_print(contents); break; + case U_WMR_DA: U_WMRDA_print(contents); break; + case U_WMR_DB: U_WMRDB_print(contents); break; + case U_WMR_DC: U_WMRDC_print(contents); break; + case U_WMR_DD: U_WMRDD_print(contents); break; + case U_WMR_DE: U_WMRDE_print(contents); break; + case U_WMR_DF: U_WMRDF_print(contents); break; + case U_WMR_E0: U_WMRE0_print(contents); break; + case U_WMR_E1: U_WMRE1_print(contents); break; + case U_WMR_E2: U_WMRE2_print(contents); break; + case U_WMR_E3: U_WMRE3_print(contents); break; + case U_WMR_E4: U_WMRE4_print(contents); break; + case U_WMR_E5: U_WMRE5_print(contents); break; + case U_WMR_E6: U_WMRE6_print(contents); break; + case U_WMR_E7: U_WMRE7_print(contents); break; + case U_WMR_E8: U_WMRE8_print(contents); break; + case U_WMR_E9: U_WMRE9_print(contents); break; + case U_WMR_EA: U_WMREA_print(contents); break; + case U_WMR_EB: U_WMREB_print(contents); break; + case U_WMR_EC: U_WMREC_print(contents); break; + case U_WMR_ED: U_WMRED_print(contents); break; + case U_WMR_EE: U_WMREE_print(contents); break; + case U_WMR_EF: U_WMREF_print(contents); break; + case U_WMR_DELETEOBJECT: U_WMRDELETEOBJECT_print(contents); break; + case U_WMR_F1: U_WMRF1_print(contents); break; + case U_WMR_F2: U_WMRF2_print(contents); break; + case U_WMR_F3: U_WMRF3_print(contents); break; + case U_WMR_F4: U_WMRF4_print(contents); break; + case U_WMR_F5: U_WMRF5_print(contents); break; + case U_WMR_F6: U_WMRF6_print(contents); break; + case U_WMR_CREATEPALETTE: U_WMRCREATEPALETTE_print(contents); break; + case U_WMR_F8: U_WMRF8_print(contents); break; + case U_WMR_CREATEPATTERNBRUSH: U_WMRCREATEPATTERNBRUSH_print(contents); break; + case U_WMR_CREATEPENINDIRECT: U_WMRCREATEPENINDIRECT_print(contents); break; + case U_WMR_CREATEFONTINDIRECT: U_WMRCREATEFONTINDIRECT_print(contents); break; + case U_WMR_CREATEBRUSHINDIRECT: U_WMRCREATEBRUSHINDIRECT_print(contents); break; + case U_WMR_CREATEBITMAPINDIRECT: U_WMRCREATEBITMAPINDIRECT_print(contents); break; + case U_WMR_CREATEBITMAP: U_WMRCREATEBITMAP_print(contents); break; + case U_WMR_CREATEREGION: U_WMRCREATEREGION_print(contents); break; + default: U_WMRNOTIMPLEMENTED_print(contents); break; + } //end of switch + return(size); +} + + +#ifdef __cplusplus +} +#endif |