Adding upstream version 1.2.2.upstream/1.2.2upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 1774 insertions, 0 deletions

diff --git a/src/3rdparty/libuemf/uwmf_endian.c b/src/3rdparty/libuemf/uwmf_endian.c
new file mode 100644
index 0000000..7a047c2
--- /dev/null
+++ b/src/3rdparty/libuemf/uwmf_endian.c
@@ -0,0 +1,1774 @@
+/**
+  @file uwmf_endian.c
+  
+  @brief Functions for converting WMF records between Big Endian and Little Endian byte orders.
+*/
+
+/*
+File:      uwmf_endian.c
+Version:   0.1.5
+Date:      28-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() */
+#include <string.h>
+#include "uwmf.h"
+#include "uwmf_endian.h"
+
+// hide almost everything in this file from Doxygen
+//! \cond
+/* Prototypes for functions used here and defined in uemf_endian.c, but which are not supposed
+to be used in end user code. */
+
+void U_swap2(void *ul, unsigned int count);
+void U_swap4(void *ul, unsigned int count);
+void bitmapinfo_swap(char *Bmi);
+
+/* **********************************************************************************************
+   These functions Swap standard objects used in the WMR records.
+   The low level ones do not append EOL.
+*********************************************************************************************** */
+
+/**
+    \brief Swap U_BITMAP16 object
+    \param b U_BITMAP16 object
+*/
+void bitmap16_swap(
+      char *b
+    ){
+    U_swap2(b,4); /* Type, Width, Height, WidthBytes */
+    /* Planes and BitsPixel are bytes, so no swap needed */
+    /* Bits[] pixel data should already be in order */
+}
+
+/**
+    \brief Swap 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_swap(
+      char *b,
+      int torev
+   ){
+   int Style;
+   if(torev){   Style = *(uint16_t *)(b + offsetof(U_BRUSH,Style)); }
+   U_swap2(b + offsetof(U_BRUSH,Style),1);
+   if(!torev){  Style = *(uint16_t *)(b + offsetof(U_BRUSH,Style)); }
+   /* Color is already in the right order */
+   switch(Style){
+      case U_BS_SOLID:
+         /* no/ignored data field */
+   	 break;
+      case U_BS_NULL:
+         /* no/ignored data field */
+   	 break;
+      case U_BS_PATTERN:
+   	 bitmap16_swap(b + offsetof(U_BRUSH,Data));
+   	 break;
+      case U_BS_DIBPATTERNPT:
+   	 bitmapinfo_swap(b + offsetof(U_BRUSH,Data));
+   	 break;
+      case U_BS_HATCHED:
+         /* no/ignored data field */
+   	 break;
+   }
+}
+
+/**
+    \brief Swap a U_FONT object from pointer.
+    \param lf   U_FONT object
+*/
+void font_swap(
+       char *f
+   ){
+   U_swap2(f + offsetof(U_FONT,Height),5); /*Height, Width, Escapement, Orientation, Weight */
+   /* Other fields are single bytes */
+}
+
+/**
+    \brief Swap a pointer to a U_PALETTE object.
+    \param lp  Pointer to a U_PALETTE object.
+*/
+void palette_swap(
+      char *p
+   ){
+   U_swap2(p + offsetof(U_PALETTE,Start),2); /* Start, NumEntries*/
+   /* PalEntries[1] is byte ordered, so no need to swap */
+}
+
+/**
+    \brief Swap a  U_PEN object.
+    \param p   U_PEN object
+*/
+void pen_swap(
+      char *p
+   ){
+   U_swap2(p + offsetof(U_PEN,Style),3);             /* Style,Widthw[0],Widthw[1] */
+   /* Color already in order  */
+}
+
+/* there are no 
+  void rect16_ltrb_swap()
+  void rect16_brtl_swap()
+because rectangles are swapped using U_swap2 as an array of 4 int16 values.
+*/
+
+
+/**
+    \brief Swap U_REGION object
+    \param rect U_REGION object
+    \param torev
+    PARTIAL IMPLEMENTATION
+*/
+void region_swap(
+      char *reg,
+      int   torev
+    ){
+    int Size;
+    if(torev){  Size = *(int16_t *)(reg + offsetof(U_REGION,Size)); }
+    U_swap2(reg,10); /* ignore1 through sRrect*/
+    if(!torev){ Size = *(int16_t *)(reg + offsetof(U_REGION,Size)); }
+    U_swap2(reg + U_SIZE_REGION, (Size - U_SIZE_REGION)/2); /* aScans */
+}
+
+
+/**
+    \brief Swap U_BITMAPCOREHEADER object
+    \param ch U_BITMAPCOREHEADER object
+*/
+void bitmapcoreheader_swap(
+      char *ch
+    ){
+    U_swap4(ch + offsetof(U_BITMAPCOREHEADER,Size_4), 1);  /* Size_4, may not be aligned  */
+    U_swap2(ch + offsetof(U_BITMAPCOREHEADER,Width),4);    /* Width, Height, Planes, BitCount, */
+}
+
+/**   LogBrushW Object                      WMF PDF 2.2.2.10
+     \brief Swap a U_WLOGBRUSH object.
+     \param lb U_WLOGBRUSH 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_swap(
+      char *lb  
+   ){
+    U_swap2(lb + offsetof(U_WLOGBRUSH,Style),1);
+    /* Color is already in order */
+    U_swap2(lb + offsetof(U_WLOGBRUSH,Hatch),1);
+}
+
+/**
+    \brief Swap U_POLYPOLY object from pointer
+    \param pp PU_POLYPOLY object
+*/
+void polypolygon_swap(
+     char *pp,
+     int torev
+   ){
+   int i,totPoints;
+   uint16_t  nPolys;
+   uint16_t *aPolyCounts;
+   if(torev){  nPolys = *(uint16_t *)(pp + offsetof(U_POLYPOLYGON, nPolys)); }
+   U_swap2(pp + offsetof(U_POLYPOLYGON, nPolys),1);
+   if(!torev){ nPolys = *(uint16_t *)(pp + offsetof(U_POLYPOLYGON, nPolys)); }
+   aPolyCounts =  (uint16_t *)(pp + offsetof(U_POLYPOLYGON, aPolyCounts));
+   if(torev){
+      for(totPoints=0,i=0;i<nPolys; i++){ totPoints += aPolyCounts[i]; }
+   }
+   U_swap2(aPolyCounts,nPolys);
+   if(!torev){
+      for(totPoints=0,i=0;i<nPolys; i++){ totPoints += aPolyCounts[i]; }
+   }
+   U_swap2(&(aPolyCounts[nPolys]),2*totPoints);  /* 2 coords/ point */
+}
+
+/**
+    \brief Swap U_SCAN object
+    \param pp U_SCAN object
+*/
+void scan_swap(
+      char *sc,
+      int torev
+   ){
+   int count;
+   if(torev){  count = *(uint16_t *)sc;  }
+   U_swap2(sc,3); /*count, top, bottom */
+   if(!torev){ count = *(uint16_t *)sc;  }
+   U_swap2(sc + offsetof(U_SCAN,ScanLines),count);
+}
+
+/**
+    \brief Swap a summary of a DIB header
+    A DIB header in an WMF may be either a BitmapCoreHeader or BitmapInfoHeader.
+    \param dh void pointer to DIB header
+*/
+void dibheader_swap(
+      char *dh,
+      int torev
+   ){
+   int Size;
+   memcpy(&Size, dh, 4); /* may not be aligned */
+   if(!torev)U_swap4(&Size,1);
+   if(Size == 0xC){
+       bitmapcoreheader_swap(dh);
+   }
+   else {
+       bitmapinfo_swap(dh);
+   }
+}
+
+/**
+    \brief Swap WMF header object
+    \param head uint8_t pointer to header
+    \returns size of entire header structure
+    
+    If the header is preceded by a placeable struture, Swap that as well.
+*/
+int wmfheader_swap(
+      char *contents,
+      int torev
+    ){
+    uint32_t Key,Size16w;
+    int size=0;
+    Key=*(uint32_t *)(contents + offsetof(U_WMRPLACEABLE,Key));
+    if(!torev)U_swap4(&Key,1);
+    if(Key == 0x9AC6CDD7){
+       U_swap4(contents + offsetof(U_WMRPLACEABLE,Key     ),1);
+       U_swap2(contents + offsetof(U_WMRPLACEABLE,HWmf    ),1);
+       U_swap2(contents + offsetof(U_WMRPLACEABLE,Dst     ),4);
+       U_swap2(contents + offsetof(U_WMRPLACEABLE,Inch    ),1);
+       U_swap4(contents + offsetof(U_WMRPLACEABLE,Reserved),1);
+       U_swap2(contents + offsetof(U_WMRPLACEABLE,Checksum),1);
+       contents += U_SIZE_WMRPLACEABLE;
+       size     += U_SIZE_WMRPLACEABLE;
+    }
+    if(torev){  Size16w = *(uint16_t *)(contents + offsetof(U_WMRHEADER,Size16w)); }
+    U_swap2(contents + offsetof(U_WMRHEADER,Size16w),2);/* Size16w, Version   */
+    if(!torev){ Size16w = *(uint16_t *)(contents + offsetof(U_WMRHEADER,Size16w)); }
+    U_swap4(contents + offsetof(U_WMRHEADER,Sizew   ),1);/* Sizew    */
+    U_swap2(contents + offsetof(U_WMRHEADER,nObjects),1);/* nObjects */
+    U_swap4(contents + offsetof(U_WMRHEADER,maxSize ),1);/* maxSize  */
+    U_swap2(contents + offsetof(U_WMRHEADER,nMembers),1);/* nMembers */
+    size += 2*Size16w;
+    return(size);
+}
+
+
+
+/* **********************************************************************************************
+These functions contain shared code used by various U_WMR*_Swap 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.   
+*********************************************************************************************** */
+
+/* Size16 EVERY record type should call this, directly or indirectly*/
+void U_WMRCORE_SIZE16_swap(char *record, int torev){
+   UNUSED_PARAMETER(torev);
+   U_swap4(record, 1); /* Size16_4 is at offset 0 in U_METARECORD */
+}
+
+
+/* Size16, move to data, Single 32bit followed by array of N16 U_POINT16 */
+void U_WMRCORE_U32_N16_swap(char *record, int N16, int torev){
+   int off=U_SIZE_METARECORD;
+   U_WMRCORE_SIZE16_swap(record, torev);
+   U_swap4(record + off,   1);  off+=4;
+   U_swap2(record + off, N16);
+}
+
+/* Single 16bit nPoints followed by array of nPoints U_POINT16 */
+void U_WMRCORE_U16_N16_swap(char *record, int torev){
+   int nPoints;
+   U_WMRCORE_SIZE16_swap(record, torev);
+   if(torev){  nPoints = *(uint16_t *)(record + offsetof(U_WMRPOLYGON,nPoints)); }
+   U_swap2(record + offsetof(U_WMRPOLYGON,nPoints), 1);
+   if(!torev){ nPoints = *(uint16_t *)(record + offsetof(U_WMRPOLYGON,nPoints)); }
+   U_swap2(record + offsetof(U_WMRPOLYGON,aPoints), 2*nPoints);
+}
+
+/* all records that specify palette objects */
+void U_WMRCORE_PALETTE_swap(char *record, int torev){
+   UNUSED_PARAMETER(torev);
+   U_WMRCORE_SIZE16_swap(record, torev);
+   palette_swap(record + offsetof(U_WMRANIMATEPALETTE,Palette));
+}
+
+/* all records that have N int16 values, unconditionally swapped  */
+void U_WMRCORE_N16_swap(char *record, int N16, int torev){
+   U_WMRCORE_SIZE16_swap(record, torev);
+   U_swap2(record+U_SIZE_METARECORD, N16);
+}
+
+
+/* like floodfill  */
+void U_WMRCORE_U16_CR_2U16_swap(char *record, int torev){
+   int off = U_SIZE_METARECORD;
+   U_WMRCORE_SIZE16_swap(record, torev);
+   U_swap2(record+off,   1);   off += 2 + sizeof(U_COLORREF);
+   U_swap2(record+off,   2);
+}
+
+/* **********************************************************************************************
+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_EMR_* index number.  
+*********************************************************************************************** */
+
+/**
+    \brief Swap a pointer to a U_WMR_whatever record which has not been implemented.
+    \param name       name of this type of record
+    \param contents   pointer to a buffer holding all EMR records
+    \param recnum     number of this record in contents
+    \param off        offset to this record in contents
+*/
+void U_WMRNOTIMPLEMENTED_swap(char *record, int torev){
+   U_WMRCORE_SIZE16_swap(record, torev);
+}
+
+void U_WMREOF_swap(char *record, int torev){
+   U_WMRCORE_SIZE16_swap(record, torev);
+}
+
+void U_WMRSETBKCOLOR_swap(char *record, int torev){
+   U_WMRCORE_SIZE16_swap(record, torev);
+}
+
+void U_WMRSETBKMODE_swap(char *record, int torev){
+   U_WMRCORE_N16_swap(record,1,torev);
+}
+
+void U_WMRSETMAPMODE_swap(char *record, int torev){
+   U_WMRCORE_N16_swap(record,1,torev);
+}
+
+void U_WMRSETROP2_swap(char *record, int torev){
+   U_WMRCORE_N16_swap(record,1,torev);
+}
+
+void U_WMRSETRELABS_swap(char *record, int torev){
+   U_WMRCORE_SIZE16_swap(record, torev);
+}
+
+void U_WMRSETPOLYFILLMODE_swap(char *record, int torev){
+   U_WMRCORE_N16_swap(record,1,torev);
+}
+
+void U_WMRSETSTRETCHBLTMODE_swap(char *record, int torev){
+   U_WMRCORE_N16_swap(record,1,torev);
+}
+
+void U_WMRSETTEXTCHAREXTRA_swap(char *record, int torev){
+   U_WMRCORE_N16_swap(record,1,torev);
+}
+
+void U_WMRSETTEXTCOLOR_swap(char *record, int torev){
+   U_WMRCORE_SIZE16_swap(record, torev);
+}
+
+void U_WMRSETTEXTJUSTIFICATION_swap(char *record, int torev){
+   U_WMRCORE_N16_swap(record,2,torev);
+}
+
+void U_WMRSETWINDOWORG_swap(char *record, int torev){
+   U_WMRCORE_N16_swap(record,2,torev);
+}
+
+void U_WMRSETWINDOWEXT_swap(char *record, int torev){
+   U_WMRCORE_N16_swap(record,2,torev);
+}
+
+void U_WMRSETVIEWPORTORG_swap(char *record, int torev){
+   U_WMRCORE_N16_swap(record,2,torev);
+}
+
+void U_WMRSETVIEWPORTEXT_swap(char *record, int torev){
+   U_WMRCORE_N16_swap(record,2,torev);
+}
+
+void U_WMROFFSETWINDOWORG_swap(char *record, int torev){
+   U_WMRCORE_N16_swap(record,2,torev);
+}
+
+void U_WMRSCALEWINDOWEXT_swap(char *record, int torev){
+   U_WMRCORE_N16_swap(record,4,torev);
+}
+
+void U_WMROFFSETVIEWPORTORG_swap(char *record, int torev){
+   U_WMRCORE_N16_swap(record,2,torev);
+}
+
+void U_WMRSCALEVIEWPORTEXT_swap(char *record, int torev){
+   U_WMRCORE_N16_swap(record,4,torev);
+}
+
+void U_WMRLINETO_swap(char *record, int torev){
+   U_WMRCORE_N16_swap(record,2,torev);
+}
+
+void U_WMRMOVETO_swap(char *record, int torev){
+   U_WMRCORE_N16_swap(record,2,torev);
+}
+
+void U_WMREXCLUDECLIPRECT_swap(char *record, int torev){
+   U_WMRCORE_N16_swap(record,4,torev);
+}
+
+void U_WMRINTERSECTCLIPRECT_swap(char *record, int torev){
+   U_WMRCORE_N16_swap(record,4,torev);
+}
+
+void U_WMRARC_swap(char *record, int torev){
+   U_WMRCORE_N16_swap(record, 8, torev);
+}
+
+void U_WMRELLIPSE_swap(char *record, int torev){
+   U_WMRCORE_N16_swap(record,4,torev);
+}
+
+void U_WMRFLOODFILL_swap(char *record, int torev){
+   U_WMRCORE_U16_CR_2U16_swap(record, torev);
+}
+
+void U_WMRPIE_swap(char *record, int torev){
+   U_WMRCORE_N16_swap(record, 8, torev);
+}
+
+void U_WMRRECTANGLE_swap(char *record, int torev){
+   U_WMRCORE_N16_swap(record,4,torev);
+}
+
+void U_WMRROUNDRECT_swap(char *record, int torev){
+   U_WMRCORE_N16_swap(record,6,torev);
+}
+
+void U_WMRPATBLT_swap(char *record, int torev){
+    U_WMRCORE_U32_N16_swap(record,4,torev);
+}
+
+void U_WMRSAVEDC_swap(char *record, int torev){
+   U_WMRCORE_SIZE16_swap(record, torev);
+}
+
+void U_WMRSETPIXEL_swap(char *record, int torev){
+   int off = U_SIZE_METARECORD + sizeof(U_COLORREF);
+   U_WMRCORE_SIZE16_swap(record, torev);
+   U_swap2(record+off,   2);
+}
+
+void U_WMROFFSETCLIPRGN_swap(char *record, int torev){
+   U_WMRCORE_N16_swap(record,2,torev);
+}
+
+void U_WMRTEXTOUT_swap(char *record, int torev){
+   int  L2;
+   if(torev){  L2 =  *(int16_t *)(record + U_SIZE_METARECORD); } /* Length field */
+   U_WMRCORE_N16_swap(record,1,torev); /* Length */
+   if(!torev){ L2 =  *(int16_t *)(record + U_SIZE_METARECORD); } /* Length field */
+   /* string is in bytes, do not swap that */
+   U_swap2(record + U_SIZE_WMRTEXTOUT + L2, 2); /* y,x */
+}
+
+void U_WMRBITBLT_swap(char *record, int torev){
+   uint32_t Size16;
+   uint8_t xb;
+   memcpy(&Size16, record + offsetof(U_METARECORD,Size16_4), 4);
+   if(!torev)U_swap4(&Size16,1);
+   xb     = *(uint8_t *)(record + offsetof(U_METARECORD,xb));
+   if(U_TEST_NOPX2(Size16,xb)){ /* no bitmap */
+      U_WMRCORE_U32_N16_swap(record,7,torev);
+   }
+   else { /* yes bitmap */
+      U_WMRCORE_U32_N16_swap(record,6,torev);
+      bitmap16_swap(record + offsetof(U_WMRBITBLT_PX,bitmap));
+   }
+}
+
+void U_WMRSTRETCHBLT_swap(char *record, int torev){
+   uint32_t Size16;
+   uint8_t xb;
+   memcpy(&Size16, record + offsetof(U_METARECORD,Size16_4), 4);
+   if(!torev)U_swap4(&Size16,1);
+   xb     = *(uint8_t *)(record + offsetof(U_METARECORD,xb));
+   if(U_TEST_NOPX2(Size16,xb)){ /* no bitmap */
+      U_WMRCORE_U32_N16_swap(record,9,torev);
+   }
+   else { /* yes bitmap */
+      U_WMRCORE_U32_N16_swap(record,8,torev);
+      bitmap16_swap(record + offsetof(U_WMRSTRETCHBLT_PX,bitmap));
+   }
+}
+
+void U_WMRPOLYGON_swap(char *record, int torev){
+   U_WMRCORE_U16_N16_swap(record, torev);
+}
+
+void U_WMRPOLYLINE_swap(char *record, int torev){
+   U_WMRCORE_U16_N16_swap(record, torev);
+}
+
+void U_WMRESCAPE_swap(char *record, int torev){
+   uint16_t  eFunc;
+ 
+   if(torev){  eFunc = *(uint16_t *)(record + offsetof(U_WMRESCAPE,eFunc)); }
+   U_WMRCORE_N16_swap(record,2,torev);
+   if(!torev){ eFunc = *(uint16_t *)(record + offsetof(U_WMRESCAPE,eFunc)); }
+   /* Handle data swapping for three types only, anything else end user code must handle */
+   if((eFunc == U_MFE_SETLINECAP) || (eFunc == U_MFE_SETLINEJOIN) || (eFunc == U_MFE_SETMITERLIMIT)){
+      U_swap4(record + offsetof(U_WMRESCAPE, Data),1);
+   }
+}
+
+void U_WMRRESTOREDC_swap(char *record, int torev){
+   U_WMRCORE_SIZE16_swap(record, torev);
+}
+
+void U_WMRFILLREGION_swap(char *record, int torev){
+   U_WMRCORE_N16_swap(record,2,torev);
+}
+
+void U_WMRFRAMEREGION_swap(char *record, int torev){
+   U_WMRCORE_N16_swap(record,4,torev);
+}
+
+void U_WMRINVERTREGION_swap(char *record, int torev){
+   U_WMRCORE_N16_swap(record,1,torev);
+}
+
+void U_WMRPAINTREGION_swap(char *record, int torev){
+   U_WMRCORE_N16_swap(record,1,torev);
+}
+
+void U_WMRSELECTCLIPREGION_swap(char *record, int torev){
+   U_WMRCORE_N16_swap(record,1,torev);
+}
+
+void U_WMRSELECTOBJECT_swap(char *record, int torev){
+   U_WMRCORE_N16_swap(record,1,torev);
+}
+
+void U_WMRSETTEXTALIGN_swap(char *record, int torev){
+   U_WMRCORE_N16_swap(record,1,torev);
+}
+
+void U_WMRDRAWTEXT_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMRCHORD_swap(char *record, int torev){
+   U_WMRCORE_N16_swap(record, 8, torev);
+}
+
+void U_WMRSETMAPPERFLAGS_swap(char *record, int torev){
+   U_WMRCORE_N16_swap(record,1,torev);
+}
+
+void U_WMREXTTEXTOUT_swap(char *record, int torev){
+   int off,Length,Len2,Opts;
+   U_swap4(record + offsetof(U_WMREXTTEXTOUT,Size16_4),1);
+   if(torev){ 
+      Length = *(int16_t *)( record + offsetof(U_WMREXTTEXTOUT,Length));
+      Opts   = *(uint16_t *)(record + offsetof(U_WMREXTTEXTOUT,Opts));
+   }
+   U_swap2(record + offsetof(U_WMREXTTEXTOUT,y),    4);       /* y,x,Length,Opts*/
+   if(!torev){ 
+      Length = *(int16_t *)( record + offsetof(U_WMREXTTEXTOUT,Length));
+      Opts   = *(uint16_t *)(record + offsetof(U_WMREXTTEXTOUT,Opts));
+   }
+   off = U_SIZE_WMREXTTEXTOUT;
+   if(Opts & (U_ETO_OPAQUE | U_ETO_CLIPPED)){
+      U_swap2(record + off,4); off += 8;
+   }
+   Len2 = (Length & 1 ? Length + 1 : Length);
+   off += Len2;  /* no need to swap string, it is a byte array */
+   U_swap2(record+off,Length);  /* swap the dx array */
+}
+
+void U_WMRSETDIBTODEV_swap(char *record, int torev){
+   U_WMRCORE_N16_swap(record, 9, torev);
+   dibheader_swap(record + offsetof(U_WMRSETDIBTODEV,dib), torev);
+}
+
+void U_WMRSELECTPALETTE_swap(char *record, int torev){
+   U_WMRCORE_N16_swap(record,1,torev);
+}
+
+void U_WMRREALIZEPALETTE_swap(char *record, int torev){
+   U_WMRCORE_SIZE16_swap(record, torev);
+}
+
+void U_WMRANIMATEPALETTE_swap(char *record, int torev){
+   U_WMRCORE_PALETTE_swap(record, torev);
+}
+
+void U_WMRSETPALENTRIES_swap(char *record, int torev){
+   U_WMRCORE_PALETTE_swap(record, torev);
+}
+
+void U_WMRPOLYPOLYGON_swap(char *record, int torev){
+   U_WMRCORE_SIZE16_swap(record, torev);
+   polypolygon_swap(record + offsetof(U_WMRPOLYPOLYGON,PPolygon), torev);
+}
+
+void U_WMRRESIZEPALETTE_swap(char *record, int torev){
+   U_WMRCORE_N16_swap(record,1,torev);
+}
+
+void U_WMR3A_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMR3B_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMR3C_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMR3D_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMR3E_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMR3F_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMRDIBBITBLT_swap(char *record, int torev){
+   uint32_t Size16;
+   uint8_t xb;
+   memcpy(&Size16, record + offsetof(U_METARECORD,Size16_4), 4);
+   if(!torev)U_swap4(&Size16,1);
+   xb     = *(uint8_t *)(record + offsetof(U_METARECORD,xb));
+   if(U_TEST_NOPX2(Size16,xb)){ /* no bitmap */
+      U_WMRCORE_U32_N16_swap(record,7,torev);
+   }
+   else { /* yes bitmap */
+      U_WMRCORE_U32_N16_swap(record,6,torev);
+      dibheader_swap(record + offsetof(U_WMRDIBBITBLT_PX,dib), torev);
+   }
+}
+
+void U_WMRDIBSTRETCHBLT_swap(char *record, int torev){
+   uint32_t Size16;
+   uint8_t xb;
+   memcpy(&Size16, record + offsetof(U_METARECORD,Size16_4), 4);
+   if(!torev)U_swap4(&Size16,1);
+   xb     = *(uint8_t *)(record + offsetof(U_METARECORD,xb));
+   if(U_TEST_NOPX2(Size16,xb)){ /* no bitmap */
+      U_WMRCORE_U32_N16_swap(record,9,torev);
+   }
+   else { /* yes bitmap */
+      U_WMRCORE_U32_N16_swap(record,8,torev);
+      dibheader_swap(record + offsetof(U_WMRDIBSTRETCHBLT_PX,dib), torev);
+   }
+}
+
+void U_WMRDIBCREATEPATTERNBRUSH_swap(char *record, int torev){
+   int Style;
+   if(torev){ Style  = *(uint16_t *)(record + offsetof(U_WMRDIBCREATEPATTERNBRUSH,Style)); }
+   U_WMRCORE_N16_swap(record,2,torev); /* Style and cUsage */
+   if(!torev){ Style  = *(uint16_t *)(record + offsetof(U_WMRDIBCREATEPATTERNBRUSH,Style));  }
+   if(Style == U_BS_PATTERN){
+      bitmap16_swap(record + offsetof(U_WMRDIBCREATEPATTERNBRUSH,Src));
+   }
+   else {
+      dibheader_swap(record + offsetof(U_WMRDIBCREATEPATTERNBRUSH,Src), torev);
+   }
+}
+
+void U_WMRSTRETCHDIB_swap(char *record, int torev){
+   UNUSED_PARAMETER(torev);
+   U_WMRCORE_U32_N16_swap(record,9,torev);
+   dibheader_swap(record + offsetof(U_WMRSTRETCHDIB,dib), torev);
+}
+
+void U_WMR44_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMR45_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMR46_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMR47_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMREXTFLOODFILL_swap(char *record, int torev){
+   U_WMRCORE_U16_CR_2U16_swap(record, torev);
+}
+
+void U_WMR49_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMR4A_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMR4B_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMR4C_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMR4D_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMR4E_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMR4F_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMR50_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMR51_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMR52_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMR53_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMR54_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMR55_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMR56_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMR57_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMR58_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMR59_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMR5A_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMR5B_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMR5C_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMR5D_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMR5E_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMR5F_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMR60_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMR61_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMR62_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMR63_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMR64_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMR65_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMR66_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMR67_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMR68_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMR69_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMR6A_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMR6B_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMR6C_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMR6D_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMR6E_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMR6F_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMR70_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMR71_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMR72_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMR73_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMR74_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMR75_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMR76_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMR77_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMR78_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMR79_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMR7A_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMR7B_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMR7C_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMR7D_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMR7E_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMR7F_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMR80_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMR81_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMR82_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMR83_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMR84_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMR85_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMR86_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMR87_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMR88_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMR89_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMR8A_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMR8B_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMR8C_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMR8D_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMR8E_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMR8F_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMR90_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMR91_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMR92_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMR93_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMR94_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMR95_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMR96_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMR97_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMR98_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMR99_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMR9A_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMR9B_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMR9C_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMR9D_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMR9E_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMR9F_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMRA0_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMRA1_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMRA2_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMRA3_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMRA4_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMRA5_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMRA6_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMRA7_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMRA8_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMRA9_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMRAA_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMRAB_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMRAC_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMRAD_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMRAE_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMRAF_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMRB0_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMRB1_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMRB2_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMRB3_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMRB4_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMRB5_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMRB6_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMRB7_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMRB8_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMRB9_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMRBA_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMRBB_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMRBC_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMRBD_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMRBE_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMRBF_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMRC0_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMRC1_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMRC2_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMRC3_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMRC4_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMRC5_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMRC6_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMRC7_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMRC8_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMRC9_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMRCA_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMRCB_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMRCC_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMRCD_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMRCE_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMRCF_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMRD0_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMRD1_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMRD2_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMRD3_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMRD4_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMRD5_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMRD6_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMRD7_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMRD8_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMRD9_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMRDA_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMRDB_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMRDC_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMRDD_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMRDE_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMRDF_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMRE0_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMRE1_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMRE2_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMRE3_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMRE4_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMRE5_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMRE6_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMRE7_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMRE8_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMRE9_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMREA_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMREB_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMREC_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMRED_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMREE_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMREF_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMRDELETEOBJECT_swap(char *record, int torev){
+   U_WMRCORE_N16_swap(record,1,torev);
+}
+
+void U_WMRF1_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMRF2_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMRF3_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMRF4_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMRF5_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMRF6_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMRCREATEPALETTE_swap(char *record, int torev){
+   U_WMRCORE_PALETTE_swap(record, torev);
+}
+
+void U_WMRF8_swap(char *record, int torev){
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMRCREATEPATTERNBRUSH_swap(char *record, int torev){
+   U_WMRCORE_SIZE16_swap(record, torev);
+   bitmap16_swap(record + U_SIZE_METARECORD);
+   /* pattern array byte order already correct? */
+}
+
+void U_WMRCREATEPENINDIRECT_swap(char *record, int torev){
+   U_WMRCORE_SIZE16_swap(record, torev);
+   pen_swap(record + offsetof(U_WMRCREATEPENINDIRECT,pen));
+}
+
+void U_WMRCREATEFONTINDIRECT_swap(char *record, int torev){
+   U_WMRCORE_SIZE16_swap(record, torev);
+   font_swap(record + offsetof(U_WMRCREATEFONTINDIRECT,font));
+}
+
+void U_WMRCREATEBRUSHINDIRECT_swap(char *record, int torev){
+   U_WMRCORE_SIZE16_swap(record, torev);
+   wlogbrush_swap(record + offsetof(U_WMRCREATEBRUSHINDIRECT,brush));
+}
+
+void U_WMRCREATEBITMAPINDIRECT_swap(char *record, int torev){ /* in Wine, not in WMF PDF */
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMRCREATEBITMAP_swap(char *record, int torev){ /* in Wine, not in WMF PDF */
+   U_WMRNOTIMPLEMENTED_swap(record, torev);
+}
+
+void U_WMRCREATEREGION_swap(char *record, int torev){
+   U_WMRCORE_SIZE16_swap(record, torev);
+   region_swap(record + offsetof(U_WMRCREATEREGION,region), torev);
+}
+//! \endcond
+
+/**
+    \brief Convert an entire WMF in memory from Big Endian to Little Endian (or vice versa).
+    \return 0 on failure, 1 on success
+    \param contents   pointer to the buffer holding the entire EMF in memory
+    \param length     number of bytes in the buffer
+    \param torev      1 for native to reversed, 0 for reversed to native
+    \param onerec     1 if this is operating on a single record instead of an entire file
+    
+    Normally this would be called immediately before writing the data to a file
+    or immediately after reading the data from a file.
+*/
+int U_wmf_endian(char *contents, size_t length, int torev, int onerec){
+    size_t    off=0;
+    uint32_t  OK, Size16;
+    uint8_t   iType;
+    char     *record;
+    int       recnum;
+    int       offset=0;
+
+    record  = contents;
+    if(!onerec){
+       off     = wmfheader_swap(record,torev); fflush(stdout); /* WMF header is not a normal record, handle it separately */
+       record += off;
+       offset  = off;
+    }
+    OK      = 1;
+    recnum  = 1;  /* used when debugging */
+
+    while(OK){
+       if(record > contents + length){ return(0); } // this is most likely a corrupt WMF
+
+       memcpy(&Size16, record + offsetof(U_METARECORD,Size16_4), 4);  /* This may not be aligned */
+       if(!torev){ U_swap4(&Size16,1); }
+       iType  = *(uint8_t *)(record + offsetof(U_METARECORD,iType));
+
+//printf("DEBUG U_wmf_endian before switch record:%d offset:%d type:%d name:%s Size16:%d\n",recnum,offset,iType,U_wmr_names(iType),Size16);fflush(stdout);
+       switch (iType)
+       {
+	  case  U_WMR_EOF:                    U_WMREOF_swap(record, torev);     OK=0;            break;
+	  case  U_WMR_SETBKCOLOR:             U_WMRSETBKCOLOR_swap(record, torev);               break;
+	  case  U_WMR_SETBKMODE:              U_WMRSETBKMODE_swap(record, torev);                break;
+	  case  U_WMR_SETMAPMODE:             U_WMRSETMAPMODE_swap(record, torev);               break;
+	  case  U_WMR_SETROP2:                U_WMRSETROP2_swap(record, torev);                  break;
+	  case  U_WMR_SETRELABS:              U_WMRSETRELABS_swap(record, torev);                break;
+	  case  U_WMR_SETPOLYFILLMODE:        U_WMRSETPOLYFILLMODE_swap(record, torev);          break;
+	  case  U_WMR_SETSTRETCHBLTMODE:      U_WMRSETSTRETCHBLTMODE_swap(record, torev);        break;
+	  case  U_WMR_SETTEXTCHAREXTRA:       U_WMRSETTEXTCHAREXTRA_swap(record, torev);         break;
+	  case  U_WMR_SETTEXTCOLOR:           U_WMRSETTEXTCOLOR_swap(record, torev);             break;
+	  case  U_WMR_SETTEXTJUSTIFICATION:   U_WMRSETTEXTJUSTIFICATION_swap(record, torev);     break;
+	  case  U_WMR_SETWINDOWORG:           U_WMRSETWINDOWORG_swap(record, torev);             break;
+	  case  U_WMR_SETWINDOWEXT:           U_WMRSETWINDOWEXT_swap(record, torev);             break;
+	  case  U_WMR_SETVIEWPORTORG:         U_WMRSETVIEWPORTORG_swap(record, torev);           break;
+	  case  U_WMR_SETVIEWPORTEXT:         U_WMRSETVIEWPORTEXT_swap(record, torev);           break;
+	  case  U_WMR_OFFSETWINDOWORG:        U_WMROFFSETWINDOWORG_swap(record, torev);          break;
+	  case  U_WMR_SCALEWINDOWEXT:         U_WMRSCALEWINDOWEXT_swap(record, torev);           break;
+	  case  U_WMR_OFFSETVIEWPORTORG:      U_WMROFFSETVIEWPORTORG_swap(record, torev);        break;
+	  case  U_WMR_SCALEVIEWPORTEXT:       U_WMRSCALEVIEWPORTEXT_swap(record, torev);         break;
+	  case  U_WMR_LINETO:                 U_WMRLINETO_swap(record, torev);                   break;
+	  case  U_WMR_MOVETO:                 U_WMRMOVETO_swap(record, torev);                   break;
+	  case  U_WMR_EXCLUDECLIPRECT:        U_WMREXCLUDECLIPRECT_swap(record, torev);          break;
+	  case  U_WMR_INTERSECTCLIPRECT:      U_WMRINTERSECTCLIPRECT_swap(record, torev);        break;
+	  case  U_WMR_ARC:                    U_WMRARC_swap(record, torev);                      break;
+	  case  U_WMR_ELLIPSE:                U_WMRELLIPSE_swap(record, torev);                  break;
+	  case  U_WMR_FLOODFILL:              U_WMRFLOODFILL_swap(record, torev);                break;
+	  case  U_WMR_PIE:                    U_WMRPIE_swap(record, torev);                      break;
+	  case  U_WMR_RECTANGLE:              U_WMRRECTANGLE_swap(record, torev);                break;
+	  case  U_WMR_ROUNDRECT:              U_WMRROUNDRECT_swap(record, torev);                break;
+	  case  U_WMR_PATBLT:                 U_WMRPATBLT_swap(record, torev);                   break;
+	  case  U_WMR_SAVEDC:                 U_WMRSAVEDC_swap(record, torev);                   break;
+	  case  U_WMR_SETPIXEL:               U_WMRSETPIXEL_swap(record, torev);                 break;
+	  case  U_WMR_OFFSETCLIPRGN:          U_WMROFFSETCLIPRGN_swap(record, torev);            break;
+	  case  U_WMR_TEXTOUT:                U_WMRTEXTOUT_swap(record, torev);                  break;
+	  case  U_WMR_BITBLT:                 U_WMRBITBLT_swap(record, torev);                   break;
+	  case  U_WMR_STRETCHBLT:             U_WMRSTRETCHBLT_swap(record, torev);               break;
+	  case  U_WMR_POLYGON:                U_WMRPOLYGON_swap(record, torev);                  break;
+	  case  U_WMR_POLYLINE:               U_WMRPOLYLINE_swap(record, torev);                 break;
+	  case  U_WMR_ESCAPE:                 U_WMRESCAPE_swap(record, torev);                   break;
+	  case  U_WMR_RESTOREDC:              U_WMRRESTOREDC_swap(record, torev);                break;
+	  case  U_WMR_FILLREGION:             U_WMRFILLREGION_swap(record, torev);               break;
+	  case  U_WMR_FRAMEREGION:            U_WMRFRAMEREGION_swap(record, torev);              break;
+	  case  U_WMR_INVERTREGION:           U_WMRINVERTREGION_swap(record, torev);             break;
+	  case  U_WMR_PAINTREGION:            U_WMRPAINTREGION_swap(record, torev);              break;
+	  case  U_WMR_SELECTCLIPREGION:       U_WMRSELECTCLIPREGION_swap(record, torev);         break;
+	  case  U_WMR_SELECTOBJECT:           U_WMRSELECTOBJECT_swap(record, torev);             break;
+	  case  U_WMR_SETTEXTALIGN:           U_WMRSETTEXTALIGN_swap(record, torev);             break;
+	  case  U_WMR_DRAWTEXT:               U_WMRDRAWTEXT_swap(record, torev);                 break;
+	  case  U_WMR_CHORD:                  U_WMRCHORD_swap(record, torev);                    break;
+	  case  U_WMR_SETMAPPERFLAGS:         U_WMRSETMAPPERFLAGS_swap(record, torev);           break;
+	  case  U_WMR_EXTTEXTOUT:             U_WMREXTTEXTOUT_swap(record, torev);               break;
+	  case  U_WMR_SETDIBTODEV:            U_WMRSETDIBTODEV_swap(record, torev);              break;
+	  case  U_WMR_SELECTPALETTE:          U_WMRSELECTPALETTE_swap(record, torev);            break;
+	  case  U_WMR_REALIZEPALETTE:         U_WMRREALIZEPALETTE_swap(record, torev);           break;
+	  case  U_WMR_ANIMATEPALETTE:         U_WMRANIMATEPALETTE_swap(record, torev);           break;
+	  case  U_WMR_SETPALENTRIES:          U_WMRSETPALENTRIES_swap(record, torev);            break;
+	  case  U_WMR_POLYPOLYGON:            U_WMRPOLYPOLYGON_swap(record, torev);              break;
+	  case  U_WMR_RESIZEPALETTE:          U_WMRRESIZEPALETTE_swap(record, torev);            break;
+	  case  U_WMR_3A:                     U_WMR3A_swap(record, torev);                       break;
+	  case  U_WMR_3B:                     U_WMR3B_swap(record, torev);                       break;
+	  case  U_WMR_3C:                     U_WMR3C_swap(record, torev);                       break;
+	  case  U_WMR_3D:                     U_WMR3D_swap(record, torev);                       break;
+	  case  U_WMR_3E:                     U_WMR3E_swap(record, torev);                       break;
+	  case  U_WMR_3F:                     U_WMR3F_swap(record, torev);                       break;
+	  case  U_WMR_DIBBITBLT:              U_WMRDIBBITBLT_swap(record, torev);                break;
+	  case  U_WMR_DIBSTRETCHBLT:          U_WMRDIBSTRETCHBLT_swap(record, torev);            break;
+	  case  U_WMR_DIBCREATEPATTERNBRUSH:  U_WMRDIBCREATEPATTERNBRUSH_swap(record, torev);    break;
+	  case  U_WMR_STRETCHDIB:             U_WMRSTRETCHDIB_swap(record, torev);               break;
+	  case  U_WMR_44:                     U_WMR44_swap(record, torev);                       break;
+	  case  U_WMR_45:                     U_WMR45_swap(record, torev);                       break;
+	  case  U_WMR_46:                     U_WMR46_swap(record, torev);                       break;
+	  case  U_WMR_47:                     U_WMR47_swap(record, torev);                       break;
+	  case  U_WMR_EXTFLOODFILL:           U_WMREXTFLOODFILL_swap(record, torev);             break;
+	  case  U_WMR_49:                     U_WMR49_swap(record, torev);                       break;
+	  case  U_WMR_4A:                     U_WMR4A_swap(record, torev);                       break;
+	  case  U_WMR_4B:                     U_WMR4B_swap(record, torev);                       break;
+	  case  U_WMR_4C:                     U_WMR4C_swap(record, torev);                       break;
+	  case  U_WMR_4D:                     U_WMR4D_swap(record, torev);                       break;
+	  case  U_WMR_4E:                     U_WMR4E_swap(record, torev);                       break;
+	  case  U_WMR_4F:                     U_WMR4F_swap(record, torev);                       break;
+	  case  U_WMR_50:                     U_WMR50_swap(record, torev);                       break;
+	  case  U_WMR_51:                     U_WMR51_swap(record, torev);                       break;
+	  case  U_WMR_52:                     U_WMR52_swap(record, torev);                       break;
+	  case  U_WMR_53:                     U_WMR53_swap(record, torev);                       break;
+	  case  U_WMR_54:                     U_WMR54_swap(record, torev);                       break;
+	  case  U_WMR_55:                     U_WMR55_swap(record, torev);                       break;
+	  case  U_WMR_56:                     U_WMR56_swap(record, torev);                       break;
+	  case  U_WMR_57:                     U_WMR57_swap(record, torev);                       break;
+	  case  U_WMR_58:                     U_WMR58_swap(record, torev);                       break;
+	  case  U_WMR_59:                     U_WMR59_swap(record, torev);                       break;
+	  case  U_WMR_5A:                     U_WMR5A_swap(record, torev);                       break;
+	  case  U_WMR_5B:                     U_WMR5B_swap(record, torev);                       break;
+	  case  U_WMR_5C:                     U_WMR5C_swap(record, torev);                       break;
+	  case  U_WMR_5D:                     U_WMR5D_swap(record, torev);                       break;
+	  case  U_WMR_5E:                     U_WMR5E_swap(record, torev);                       break;
+	  case  U_WMR_5F:                     U_WMR5F_swap(record, torev);                       break;
+	  case  U_WMR_60:                     U_WMR60_swap(record, torev);                       break;
+	  case  U_WMR_61:                     U_WMR61_swap(record, torev);                       break;
+	  case  U_WMR_62:                     U_WMR62_swap(record, torev);                       break;
+	  case  U_WMR_63:                     U_WMR63_swap(record, torev);                       break;
+	  case  U_WMR_64:                     U_WMR64_swap(record, torev);                       break;
+	  case  U_WMR_65:                     U_WMR65_swap(record, torev);                       break;
+	  case  U_WMR_66:                     U_WMR66_swap(record, torev);                       break;
+	  case  U_WMR_67:                     U_WMR67_swap(record, torev);                       break;
+	  case  U_WMR_68:                     U_WMR68_swap(record, torev);                       break;
+	  case  U_WMR_69:                     U_WMR69_swap(record, torev);                       break;
+	  case  U_WMR_6A:                     U_WMR6A_swap(record, torev);                       break;
+	  case  U_WMR_6B:                     U_WMR6B_swap(record, torev);                       break;
+	  case  U_WMR_6C:                     U_WMR6C_swap(record, torev);                       break;
+	  case  U_WMR_6D:                     U_WMR6D_swap(record, torev);                       break;
+	  case  U_WMR_6E:                     U_WMR6E_swap(record, torev);                       break;
+	  case  U_WMR_6F:                     U_WMR6F_swap(record, torev);                       break;
+	  case  U_WMR_70:                     U_WMR70_swap(record, torev);                       break;
+	  case  U_WMR_71:                     U_WMR71_swap(record, torev);                       break;
+	  case  U_WMR_72:                     U_WMR72_swap(record, torev);                       break;
+	  case  U_WMR_73:                     U_WMR73_swap(record, torev);                       break;
+	  case  U_WMR_74:                     U_WMR74_swap(record, torev);                       break;
+	  case  U_WMR_75:                     U_WMR75_swap(record, torev);                       break;
+	  case  U_WMR_76:                     U_WMR76_swap(record, torev);                       break;
+	  case  U_WMR_77:                     U_WMR77_swap(record, torev);                       break;
+	  case  U_WMR_78:                     U_WMR78_swap(record, torev);                       break;
+	  case  U_WMR_79:                     U_WMR79_swap(record, torev);                       break;
+	  case  U_WMR_7A:                     U_WMR7A_swap(record, torev);                       break;
+	  case  U_WMR_7B:                     U_WMR7B_swap(record, torev);                       break;
+	  case  U_WMR_7C:                     U_WMR7C_swap(record, torev);                       break;
+	  case  U_WMR_7D:                     U_WMR7D_swap(record, torev);                       break;
+	  case  U_WMR_7E:                     U_WMR7E_swap(record, torev);                       break;
+	  case  U_WMR_7F:                     U_WMR7F_swap(record, torev);                       break;
+	  case  U_WMR_80:                     U_WMR80_swap(record, torev);                       break;
+	  case  U_WMR_81:                     U_WMR81_swap(record, torev);                       break;
+	  case  U_WMR_82:                     U_WMR82_swap(record, torev);                       break;
+	  case  U_WMR_83:                     U_WMR83_swap(record, torev);                       break;
+	  case  U_WMR_84:                     U_WMR84_swap(record, torev);                       break;
+	  case  U_WMR_85:                     U_WMR85_swap(record, torev);                       break;
+	  case  U_WMR_86:                     U_WMR86_swap(record, torev);                       break;
+	  case  U_WMR_87:                     U_WMR87_swap(record, torev);                       break;
+	  case  U_WMR_88:                     U_WMR88_swap(record, torev);                       break;
+	  case  U_WMR_89:                     U_WMR89_swap(record, torev);                       break;
+	  case  U_WMR_8A:                     U_WMR8A_swap(record, torev);                       break;
+	  case  U_WMR_8B:                     U_WMR8B_swap(record, torev);                       break;
+	  case  U_WMR_8C:                     U_WMR8C_swap(record, torev);                       break;
+	  case  U_WMR_8D:                     U_WMR8D_swap(record, torev);                       break;
+	  case  U_WMR_8E:                     U_WMR8E_swap(record, torev);                       break;
+	  case  U_WMR_8F:                     U_WMR8F_swap(record, torev);                       break;
+	  case  U_WMR_90:                     U_WMR90_swap(record, torev);                       break;
+	  case  U_WMR_91:                     U_WMR91_swap(record, torev);                       break;
+	  case  U_WMR_92:                     U_WMR92_swap(record, torev);                       break;
+	  case  U_WMR_93:                     U_WMR93_swap(record, torev);                       break;
+	  case  U_WMR_94:                     U_WMR94_swap(record, torev);                       break;
+	  case  U_WMR_95:                     U_WMR95_swap(record, torev);                       break;
+	  case  U_WMR_96:                     U_WMR96_swap(record, torev);                       break;
+	  case  U_WMR_97:                     U_WMR97_swap(record, torev);                       break;
+	  case  U_WMR_98:                     U_WMR98_swap(record, torev);                       break;
+	  case  U_WMR_99:                     U_WMR99_swap(record, torev);                       break;
+	  case  U_WMR_9A:                     U_WMR9A_swap(record, torev);                       break;
+	  case  U_WMR_9B:                     U_WMR9B_swap(record, torev);                       break;
+	  case  U_WMR_9C:                     U_WMR9C_swap(record, torev);                       break;
+	  case  U_WMR_9D:                     U_WMR9D_swap(record, torev);                       break;
+	  case  U_WMR_9E:                     U_WMR9E_swap(record, torev);                       break;
+	  case  U_WMR_9F:                     U_WMR9F_swap(record, torev);                       break;
+	  case  U_WMR_A0:                     U_WMRA0_swap(record, torev);                       break;
+	  case  U_WMR_A1:                     U_WMRA1_swap(record, torev);                       break;
+	  case  U_WMR_A2:                     U_WMRA2_swap(record, torev);                       break;
+	  case  U_WMR_A3:                     U_WMRA3_swap(record, torev);                       break;
+	  case  U_WMR_A4:                     U_WMRA4_swap(record, torev);                       break;
+	  case  U_WMR_A5:                     U_WMRA5_swap(record, torev);                       break;
+	  case  U_WMR_A6:                     U_WMRA6_swap(record, torev);                       break;
+	  case  U_WMR_A7:                     U_WMRA7_swap(record, torev);                       break;
+	  case  U_WMR_A8:                     U_WMRA8_swap(record, torev);                       break;
+	  case  U_WMR_A9:                     U_WMRA9_swap(record, torev);                       break;
+	  case  U_WMR_AA:                     U_WMRAA_swap(record, torev);                       break;
+	  case  U_WMR_AB:                     U_WMRAB_swap(record, torev);                       break;
+	  case  U_WMR_AC:                     U_WMRAC_swap(record, torev);                       break;
+	  case  U_WMR_AD:                     U_WMRAD_swap(record, torev);                       break;
+	  case  U_WMR_AE:                     U_WMRAE_swap(record, torev);                       break;
+	  case  U_WMR_AF:                     U_WMRAF_swap(record, torev);                       break;
+	  case  U_WMR_B0:                     U_WMRB0_swap(record, torev);                       break;
+	  case  U_WMR_B1:                     U_WMRB1_swap(record, torev);                       break;
+	  case  U_WMR_B2:                     U_WMRB2_swap(record, torev);                       break;
+	  case  U_WMR_B3:                     U_WMRB3_swap(record, torev);                       break;
+	  case  U_WMR_B4:                     U_WMRB4_swap(record, torev);                       break;
+	  case  U_WMR_B5:                     U_WMRB5_swap(record, torev);                       break;
+	  case  U_WMR_B6:                     U_WMRB6_swap(record, torev);                       break;
+	  case  U_WMR_B7:                     U_WMRB7_swap(record, torev);                       break;
+	  case  U_WMR_B8:                     U_WMRB8_swap(record, torev);                       break;
+	  case  U_WMR_B9:                     U_WMRB9_swap(record, torev);                       break;
+	  case  U_WMR_BA:                     U_WMRBA_swap(record, torev);                       break;
+	  case  U_WMR_BB:                     U_WMRBB_swap(record, torev);                       break;
+	  case  U_WMR_BC:                     U_WMRBC_swap(record, torev);                       break;
+	  case  U_WMR_BD:                     U_WMRBD_swap(record, torev);                       break;
+	  case  U_WMR_BE:                     U_WMRBE_swap(record, torev);                       break;
+	  case  U_WMR_BF:                     U_WMRBF_swap(record, torev);                       break;
+	  case  U_WMR_C0:                     U_WMRC0_swap(record, torev);                       break;
+	  case  U_WMR_C1:                     U_WMRC1_swap(record, torev);                       break;
+	  case  U_WMR_C2:                     U_WMRC2_swap(record, torev);                       break;
+	  case  U_WMR_C3:                     U_WMRC3_swap(record, torev);                       break;
+	  case  U_WMR_C4:                     U_WMRC4_swap(record, torev);                       break;
+	  case  U_WMR_C5:                     U_WMRC5_swap(record, torev);                       break;
+	  case  U_WMR_C6:                     U_WMRC6_swap(record, torev);                       break;
+	  case  U_WMR_C7:                     U_WMRC7_swap(record, torev);                       break;
+	  case  U_WMR_C8:                     U_WMRC8_swap(record, torev);                       break;
+	  case  U_WMR_C9:                     U_WMRC9_swap(record, torev);                       break;
+	  case  U_WMR_CA:                     U_WMRCA_swap(record, torev);                       break;
+	  case  U_WMR_CB:                     U_WMRCB_swap(record, torev);                       break;
+	  case  U_WMR_CC:                     U_WMRCC_swap(record, torev);                       break;
+	  case  U_WMR_CD:                     U_WMRCD_swap(record, torev);                       break;
+	  case  U_WMR_CE:                     U_WMRCE_swap(record, torev);                       break;
+	  case  U_WMR_CF:                     U_WMRCF_swap(record, torev);                       break;
+	  case  U_WMR_D0:                     U_WMRD0_swap(record, torev);                       break;
+	  case  U_WMR_D1:                     U_WMRD1_swap(record, torev);                       break;
+	  case  U_WMR_D2:                     U_WMRD2_swap(record, torev);                       break;
+	  case  U_WMR_D3:                     U_WMRD3_swap(record, torev);                       break;
+	  case  U_WMR_D4:                     U_WMRD4_swap(record, torev);                       break;
+	  case  U_WMR_D5:                     U_WMRD5_swap(record, torev);                       break;
+	  case  U_WMR_D6:                     U_WMRD6_swap(record, torev);                       break;
+	  case  U_WMR_D7:                     U_WMRD7_swap(record, torev);                       break;
+	  case  U_WMR_D8:                     U_WMRD8_swap(record, torev);                       break;
+	  case  U_WMR_D9:                     U_WMRD9_swap(record, torev);                       break;
+	  case  U_WMR_DA:                     U_WMRDA_swap(record, torev);                       break;
+	  case  U_WMR_DB:                     U_WMRDB_swap(record, torev);                       break;
+	  case  U_WMR_DC:                     U_WMRDC_swap(record, torev);                       break;
+	  case  U_WMR_DD:                     U_WMRDD_swap(record, torev);                       break;
+	  case  U_WMR_DE:                     U_WMRDE_swap(record, torev);                       break;
+	  case  U_WMR_DF:                     U_WMRDF_swap(record, torev);                       break;
+	  case  U_WMR_E0:                     U_WMRE0_swap(record, torev);                       break;
+	  case  U_WMR_E1:                     U_WMRE1_swap(record, torev);                       break;
+	  case  U_WMR_E2:                     U_WMRE2_swap(record, torev);                       break;
+	  case  U_WMR_E3:                     U_WMRE3_swap(record, torev);                       break;
+	  case  U_WMR_E4:                     U_WMRE4_swap(record, torev);                       break;
+	  case  U_WMR_E5:                     U_WMRE5_swap(record, torev);                       break;
+	  case  U_WMR_E6:                     U_WMRE6_swap(record, torev);                       break;
+	  case  U_WMR_E7:                     U_WMRE7_swap(record, torev);                       break;
+	  case  U_WMR_E8:                     U_WMRE8_swap(record, torev);                       break;
+	  case  U_WMR_E9:                     U_WMRE9_swap(record, torev);                       break;
+	  case  U_WMR_EA:                     U_WMREA_swap(record, torev);                       break;
+	  case  U_WMR_EB:                     U_WMREB_swap(record, torev);                       break;
+	  case  U_WMR_EC:                     U_WMREC_swap(record, torev);                       break;
+	  case  U_WMR_ED:                     U_WMRED_swap(record, torev);                       break;
+	  case  U_WMR_EE:                     U_WMREE_swap(record, torev);                       break;
+	  case  U_WMR_EF:                     U_WMREF_swap(record, torev);                       break;
+	  case  U_WMR_DELETEOBJECT:           U_WMRDELETEOBJECT_swap(record, torev);             break;
+	  case  U_WMR_F1:                     U_WMRF1_swap(record, torev);                       break;
+	  case  U_WMR_F2:                     U_WMRF2_swap(record, torev);                       break;
+	  case  U_WMR_F3:                     U_WMRF3_swap(record, torev);                       break;
+	  case  U_WMR_F4:                     U_WMRF4_swap(record, torev);                       break;
+	  case  U_WMR_F5:                     U_WMRF5_swap(record, torev);                       break;
+	  case  U_WMR_F6:                     U_WMRF6_swap(record, torev);                       break;
+	  case  U_WMR_CREATEPALETTE:          U_WMRCREATEPALETTE_swap(record, torev);            break;
+	  case  U_WMR_F8:                     U_WMRF8_swap(record, torev);                       break;
+	  case  U_WMR_CREATEPATTERNBRUSH:     U_WMRCREATEPATTERNBRUSH_swap(record, torev);       break;
+	  case  U_WMR_CREATEPENINDIRECT:      U_WMRCREATEPENINDIRECT_swap(record, torev);        break;
+	  case  U_WMR_CREATEFONTINDIRECT:     U_WMRCREATEFONTINDIRECT_swap(record, torev);       break;
+	  case  U_WMR_CREATEBRUSHINDIRECT:    U_WMRCREATEBRUSHINDIRECT_swap(record, torev);      break;
+	  case  U_WMR_CREATEBITMAPINDIRECT:   U_WMRCREATEBITMAPINDIRECT_swap(record, torev);     break;
+	  case  U_WMR_CREATEBITMAP:           U_WMRCREATEBITMAP_swap(record, torev);             break;
+	  case  U_WMR_CREATEREGION:           U_WMRCREATEREGION_swap(record, torev);             break;
+	  default:                            U_WMRNOTIMPLEMENTED_swap(record, torev);           break;
+       }  //end of switch
+       if(onerec)break;
+       record += 2*Size16;
+       offset += 2*Size16;
+       recnum++;
+    }  //end of while
+    return(1);
+}
+
+
+#ifdef __cplusplus
+}
+#endif