#ifdef __cplusplus

extern "C" {

#endif

#include <stdlib.h>

#include <stdio.h>

#include <string.h>

#include <iconv.h>

#include <wchar.h>

#include <errno.h>

#include <string.h>

#include <limits.h> // for INT_MAX, INT_MIN

#include <math.h> // for U_ROUND()

#include <stddef.h> /* for offsetof() macro */

#if 0

#include <windef.h> //Not actually used, looking for collisions

#include <winnt.h> //Not actually used, looking for collisions

#include <wingdi.h> //Not actually used, looking for collisions

#endif

#include "uemf.h"

void U_swap2(void *ul, unsigned int count);

char *U_emr_names(unsigned int idx){

if(idx<U_EMR_MIN || idx > U_EMR_MAX){ idx = 0; }

static char *U_WMR_NAMES[U_EMR_MAX+1]={

"U_EMR_INVALID",

"U_EMR_HEADER",

"U_EMR_POLYBEZIER",

"U_EMR_POLYGON",

"U_EMR_POLYLINE",

"U_EMR_POLYBEZIERTO",

"U_EMR_POLYLINETO",

"U_EMR_POLYPOLYLINE",

"U_EMR_POLYPOLYGON",

"U_EMR_SETWINDOWEXTEX",

"U_EMR_SETWINDOWORGEX",

"U_EMR_SETVIEWPORTEXTEX",

"U_EMR_SETVIEWPORTORGEX",

"U_EMR_SETBRUSHORGEX",

"U_EMR_EOF",

"U_EMR_SETPIXELV",

"U_EMR_SETMAPPERFLAGS",

"U_EMR_SETMAPMODE",

"U_EMR_SETBKMODE",

"U_EMR_SETPOLYFILLMODE",

"U_EMR_SETROP2",

"U_EMR_SETSTRETCHBLTMODE",

"U_EMR_SETTEXTALIGN",

"U_EMR_SETCOLORADJUSTMENT",

"U_EMR_SETTEXTCOLOR",

"U_EMR_SETBKCOLOR",

"U_EMR_OFFSETCLIPRGN",

"U_EMR_MOVETOEX",

"U_EMR_SETMETARGN",

"U_EMR_EXCLUDECLIPRECT",

"U_EMR_INTERSECTCLIPRECT",

"U_EMR_SCALEVIEWPORTEXTEX",

"U_EMR_SCALEWINDOWEXTEX",

"U_EMR_SAVEDC",

"U_EMR_RESTOREDC",

"U_EMR_SETWORLDTRANSFORM",

"U_EMR_MODIFYWORLDTRANSFORM",

"U_EMR_SELECTOBJECT",

"U_EMR_CREATEPEN",

"U_EMR_CREATEBRUSHINDIRECT",

"U_EMR_DELETEOBJECT",

"U_EMR_ANGLEARC",

"U_EMR_ELLIPSE",

"U_EMR_RECTANGLE",

"U_EMR_ROUNDRECT",

"U_EMR_ARC",

"U_EMR_CHORD",

"U_EMR_PIE",

"U_EMR_SELECTPALETTE",

"U_EMR_CREATEPALETTE",

"U_EMR_SETPALETTEENTRIES",

"U_EMR_RESIZEPALETTE",

"U_EMR_REALIZEPALETTE",

"U_EMR_EXTFLOODFILL",

"U_EMR_LINETO",

"U_EMR_ARCTO",

"U_EMR_POLYDRAW",

"U_EMR_SETARCDIRECTION",

"U_EMR_SETMITERLIMIT",

"U_EMR_BEGINPATH",

"U_EMR_ENDPATH",

"U_EMR_CLOSEFIGURE",

"U_EMR_FILLPATH",

"U_EMR_STROKEANDFILLPATH",

"U_EMR_STROKEPATH",

"U_EMR_FLATTENPATH",

"U_EMR_WIDENPATH",

"U_EMR_SELECTCLIPPATH",

"U_EMR_ABORTPATH",

"U_EMR_UNDEF69",

"U_EMR_COMMENT",

"U_EMR_FILLRGN",

"U_EMR_FRAMERGN",

"U_EMR_INVERTRGN",

"U_EMR_PAINTRGN",

"U_EMR_EXTSELECTCLIPRGN",

"U_EMR_BITBLT",

"U_EMR_STRETCHBLT",

"U_EMR_MASKBLT",

"U_EMR_PLGBLT",

"U_EMR_SETDIBITSTODEVICE",

"U_EMR_STRETCHDIBITS",

"U_EMR_EXTCREATEFONTINDIRECTW",

"U_EMR_EXTTEXTOUTA",

"U_EMR_EXTTEXTOUTW",

"U_EMR_POLYBEZIER16",

"U_EMR_POLYGON16",

"U_EMR_POLYLINE16",

"U_EMR_POLYBEZIERTO16",

"U_EMR_POLYLINETO16",

"U_EMR_POLYPOLYLINE16",

"U_EMR_POLYPOLYGON16",

"U_EMR_POLYDRAW16",

"U_EMR_CREATEMONOBRUSH",

"U_EMR_CREATEDIBPATTERNBRUSHPT",

"U_EMR_EXTCREATEPEN",

"U_EMR_POLYTEXTOUTA",

"U_EMR_POLYTEXTOUTW",

"U_EMR_SETICMMODE",

"U_EMR_CREATECOLORSPACE",

"U_EMR_SETCOLORSPACE",

"U_EMR_DELETECOLORSPACE",

"U_EMR_GLSRECORD",

"U_EMR_GLSBOUNDEDRECORD",

"U_EMR_PIXELFORMAT",

"U_EMR_DRAWESCAPE",

"U_EMR_EXTESCAPE",

"U_EMR_UNDEF107",

"U_EMR_SMALLTEXTOUT",

"U_EMR_FORCEUFIMAPPING",

"U_EMR_NAMEDESCAPE",

"U_EMR_COLORCORRECTPALETTE",

"U_EMR_SETICMPROFILEA",

"U_EMR_SETICMPROFILEW",

"U_EMR_ALPHABLEND",

"U_EMR_SETLAYOUT",

"U_EMR_TRANSPARENTBLT",

"U_EMR_UNDEF117",

"U_EMR_GRADIENTFILL",

"U_EMR_SETLINKEDUFIS",

"U_EMR_SETTEXTJUSTIFICATION",

"U_EMR_COLORMATCHTOTARGETW",

"U_EMR_CREATECOLORSPACEW"

};

return(U_WMR_NAMES[idx]);

}

#define SET_CB_FROM_PXBMI(A,B,C,D,E,F) /* A=Px, B=Bmi, C=cbImage, D=cbImage4, E=cbBmi, F=cbPx */ \

if(A){\

if(!B)return(NULL); /* size is derived from U_BIMAPINFO, but NOT from its size field, go figure*/ \

C = F;\

D = UP4(C); /* pixel array might not be a multiples of 4 bytes*/ \

E = sizeof(U_BITMAPINFOHEADER) + 4 * get_real_color_count((const char *) &(B->bmiHeader)); /* bmiheader + colortable*/ \

}\

else { C = 0; D = 0; E=0; }

#define APPEND_PXBMISRC(A,B,C,D,E,F,G) /* A=record, B=U_EMR,C=cbBmi, D=Bmi, E=Px, F=cbImage, G=cbImage4 */ \

if(C){\

memcpy(A + off, D, C);\

((B *) A)->offBmiSrc = off;\

((B *) A)->cbBmiSrc = C;\

off += C;\

memcpy(A + off, E, F);\

((B *) A)->offBitsSrc = off;\

((B *) A)->cbBitsSrc = F;\

if(G - F){ \

off += F;\

memset(A + off, 0, G - F); \

}\

}\

else {\

((B *) A)->offBmiSrc = 0;\

((B *) A)->cbBmiSrc = 0;\

((B *) A)->offBitsSrc = 0;\

((B *) A)->cbBitsSrc = 0;\

}

#define APPEND_MSKBMISRC(A,B,C,D,E,F,G) /* A=record, B=U_EMR*,C=cbMskBmi, D=MskBmi, E=Msk, F=cbMskImage, G=cbMskImage4 */ \

if(C){\

memcpy(A + off, D, C);\

((B *) A)->offBmiMask = off;\

((B *) A)->cbBmiMask = C;\

off += C;\

memcpy(A + off, Msk, F);\

((B *) A)->offBitsMask = off;\

((B *) A)->cbBitsMask = F;\

if(G - F){ memset(A + off, 0, G - F); }\

}\

else {\

((B *) A)->offBmiMask = 0;\

((B *) A)->cbBmiMask = 0;\

((B *) A)->offBitsMask = 0;\

((B *) A)->cbBitsMask = 0;\

}

int memprobe(

const void *buf,

size_t size

){

int sum=0;

char *ptr=(char *)buf;

for(;size;size--,ptr++){ sum += *ptr; } // read all bytes, trigger valgrind warning if any uninitialized

return(sum);

}

void dumpeht(

char *string,

unsigned int *handle,

EMFHANDLES *eht

){

uint32_t i;

printf("%s\n",string);

printf("sptr: %d peak: %d top: %d\n",eht->sptr,eht->peak,eht->top);

if(handle){

printf("handle: %d \n",*handle);

}

for(i=0;i<=5;i++){

printf("table[%d]: %d\n",i,eht->table[i]);

}

for(i=1;i<=5;i++){

printf("stack[%d]: %d\n",i,eht->stack[i]);

}

}

uint32_t *dx_set(

int32_t height,

uint32_t weight,

uint32_t members

){

uint32_t i, width, *dx;

dx = (uint32_t *) malloc(members * sizeof(uint32_t));

if(dx){

if(U_FW_DONTCARE == weight)weight=U_FW_NORMAL;

width = (uint32_t) U_ROUND(((float) (height > 0 ? height : -height)) * 0.6 * (0.00024*(float) weight + 0.904));

for ( i = 0; i < members; i++ ){ dx[i] = width; }

}

return(dx);

}

uint32_t emr_properties(uint32_t type){

static uint32_t *table=NULL;

uint32_t result = U_EMR_INVALID; // initialized to indicate an error (on a lookup) or nothing (on a memory release)

if(type == U_EMR_INVALID){

if(table)free(table);

table=NULL;

}

else if(type>=1 && type<U_EMR_MAX){

if(!table){

table = (uint32_t *) malloc(sizeof(uint32_t)*(1 + U_EMR_MAX));

if(!table)return(result);

// 0x80 0x40 0x20 0x10 0x08 0x04 0x02 0x01

// Path properties (U_DRAW_*) TEXT ALTERS ONLYTO VISIBLE

// PATH FORCE CLOSED NOTEMPTY

table[ 0] = 0x00; // Does not map to any EMR record

table[ 1] = 0x80; // U_EMRHEADER 1 0 0 0 0 0 0 0

table[ 2] = 0x83; // U_EMRPOLYBEZIER 1 0 0 0 0 0 1 1

table[ 3] = 0x87; // U_EMRPOLYGON 1 0 0 0 0 1 1 1

table[ 4] = 0x83; // U_EMRPOLYLINE 1 0 0 0 0 0 1 1

table[ 5] = 0x8B; // U_EMRPOLYBEZIERTO 1 0 0 0 1 0 1 1

table[ 6] = 0x8B; // U_EMRPOLYLINETO 1 0 0 0 1 0 1 1

table[ 7] = 0x83; // U_EMRPOLYPOLYLINE 1 0 0 0 0 0 1 1

table[ 8] = 0x87; // U_EMRPOLYPOLYGON 1 0 0 0 0 1 1 1

table[ 9] = 0xA0; // U_EMRSETWINDOWEXTEX 1 0 1 0 0 0 0 0

table[ 10] = 0xA0; // U_EMRSETWINDOWORGEX 1 0 1 0 0 0 0 0

table[ 11] = 0xA0; // U_EMRSETVIEWPORTEXTEX 1 0 1 0 0 0 0 0

table[ 12] = 0xA0; // U_EMRSETVIEWPORTORGEX 1 0 1 0 0 0 0 0

table[ 13] = 0xA0; // U_EMRSETBRUSHORGEX 1 0 1 0 0 0 0 0

table[ 14] = 0x82; // U_EMREOF 1 0 1 0 0 0 0 0 Force out any pending draw

table[ 15] = 0x82; // U_EMRSETPIXELV 1 0 0 0 0 0 1 0

table[ 16] = 0xA0; // U_EMRSETMAPPERFLAGS 1 0 1 0 0 0 0 0

table[ 17] = 0xA0; // U_EMRSETMAPMODE 1 0 1 0 0 0 0 0

table[ 18] = 0x20; // U_EMRSETBKMODE 0 0 1 0 0 0 0 0

table[ 19] = 0xA0; // U_EMRSETPOLYFILLMODE 1 0 1 0 0 0 0 0

table[ 20] = 0xA0; // U_EMRSETROP2 1 0 1 0 0 0 0 0

table[ 21] = 0xA0; // U_EMRSETSTRETCHBLTMODE 1 0 1 0 0 0 0 0

table[ 22] = 0x20; // U_EMRSETTEXTALIGN 0 0 1 0 0 0 0 0

table[ 23] = 0xA0; // U_EMRSETCOLORADJUSTMENT 1 0 1 0 0 0 0 0

table[ 24] = 0x20; // U_EMRSETTEXTCOLOR 0 0 1 0 0 0 0 0

table[ 25] = 0x20; // U_EMRSETBKCOLOR 0 0 1 0 0 0 0 0

table[ 26] = 0xA0; // U_EMROFFSETCLIPRGN 1 0 1 0 0 0 0 0

table[ 27] = 0x89; // U_EMRMOVETOEX 1 0 0 0 1 0 0 1

table[ 28] = 0xA0; // U_EMRSETMETARGN 1 0 1 0 0 0 0 0

table[ 29] = 0xA0; // U_EMREXCLUDECLIPRECT 1 0 1 0 0 0 0 0

table[ 30] = 0xA0; // U_EMRINTERSECTCLIPRECT 1 0 1 0 0 0 0 0

table[ 31] = 0xA0; // U_EMRSCALEVIEWPORTEXTEX 1 0 1 0 0 0 0 0

table[ 32] = 0xA0; // U_EMRSCALEWINDOWEXTEX 1 0 1 0 0 0 0 0

table[ 33] = 0xA0; // U_EMRSAVEDC 1 0 1 0 0 0 0 0

table[ 34] = 0xA0; // U_EMRRESTOREDC 1 0 1 0 0 0 0 0

table[ 35] = 0xA0; // U_EMRSETWORLDTRANSFORM 1 0 1 0 0 0 0 0

table[ 36] = 0xA0; // U_EMRMODIFYWORLDTRANSFORM 1 0 1 0 0 0 0 0

table[ 37] = 0x20; // U_EMRSELECTOBJECT 0 0 1 0 0 0 0 0

table[ 38] = 0x20; // U_EMRCREATEPEN 0 0 1 0 0 0 0 0

table[ 39] = 0x20; // U_EMRCREATEBRUSHINDIRECT 0 0 1 0 0 0 0 0

table[ 40] = 0x20; // U_EMRDELETEOBJECT 0 0 1 0 0 0 0 0

table[ 41] = 0x83; // U_EMRANGLEARC 1 0 0 0 0 0 1 1

table[ 42] = 0x87; // U_EMRELLIPSE 1 0 0 0 0 1 1 1

table[ 43] = 0x87; // U_EMRRECTANGLE 1 0 0 0 0 1 1 1

table[ 44] = 0x87; // U_EMRROUNDRECT 1 0 0 0 0 1 1 1

table[ 45] = 0x83; // U_EMRARC 1 0 0 0 0 0 1 1

table[ 46] = 0x87; // U_EMRCHORD 1 0 0 0 0 1 1 1

table[ 47] = 0x87; // U_EMRPIE 1 0 0 0 0 1 1 1

table[ 48] = 0xA0; // U_EMRSELECTPALETTE 1 0 1 0 0 0 0 0

table[ 49] = 0xA0; // U_EMRCREATEPALETTE 1 0 1 0 0 0 0 0

table[ 50] = 0xA0; // U_EMRSETPALETTEENTRIES 1 0 1 0 0 0 0 0

table[ 51] = 0xA0; // U_EMRRESIZEPALETTE 1 0 1 0 0 0 0 0

table[ 52] = 0xA0; // U_EMRREALIZEPALETTE 1 0 1 0 0 0 0 0

table[ 53] = 0x82; // U_EMREXTFLOODFILL 1 0 0 0 0 0 1 0

table[ 54] = 0x8B; // U_EMRLINETO 1 0 0 0 1 0 1 1

table[ 55] = 0x8B; // U_EMRARCTO 1 0 0 0 1 0 1 1

table[ 56] = 0x83; // U_EMRPOLYDRAW 1 0 0 0 0 0 1 1

table[ 57] = 0xA0; // U_EMRSETARCDIRECTION 1 0 1 0 0 0 0 0

table[ 58] = 0xA0; // U_EMRSETMITERLIMIT 1 0 1 0 0 0 0 0

table[ 59] = 0xE0; // U_EMRBEGINPATH 1 1 1 0 0 0 0 0

table[ 60] = 0x80; // U_EMRENDPATH 1 0 0 0 0 0 0 0

table[ 61] = 0x84; // U_EMRCLOSEFIGURE 1 0 0 0 0 1 0 0

table[ 62] = 0x94; // U_EMRFILLPATH 1 0 0 1 0 1 0 0

table[ 63] = 0x94; // U_EMRSTROKEANDFILLPATH 1 0 0 1 0 1 0 0

table[ 64] = 0x90; // U_EMRSTROKEPATH 1 0 0 1 0 0 0 0

table[ 65] = 0xA0; // U_EMRFLATTENPATH 1 0 1 0 0 0 0 0

table[ 66] = 0xA0; // U_EMRWIDENPATH 1 0 1 0 0 0 0 0

table[ 67] = 0xA0; // U_EMRSELECTCLIPPATH 1 0 1 0 0 0 0 0

table[ 68] = 0xA0; // U_EMRABORTPATH 1 0 1 0 0 0 0 0

table[ 69] = 0xA0; // U_EMRUNDEF69 1 0 1 0 0 0 0 0

table[ 70] = 0x00; // U_EMRCOMMENT 0 0 0 0 0 0 0 0

table[ 71] = 0x82; // U_EMRFILLRGN 1 0 0 0 0 0 1 0

table[ 72] = 0x82; // U_EMRFRAMERGN 1 0 0 0 0 0 1 0

table[ 73] = 0x82; // U_EMRINVERTRGN 1 0 0 0 0 0 1 0

table[ 74] = 0x82; // U_EMRPAINTRGN 1 0 0 0 0 0 1 0

table[ 75] = 0xA0; // U_EMREXTSELECTCLIPRGN 1 0 1 0 0 0 0 0

table[ 76] = 0x82; // U_EMRBITBLT 1 0 0 0 0 0 1 0

table[ 77] = 0x82; // U_EMRSTRETCHBLT 1 0 0 0 0 0 1 0

table[ 78] = 0x82; // U_EMRMASKBLT 1 0 0 0 0 0 1 0

table[ 79] = 0x82; // U_EMRPLGBLT 1 0 0 0 0 0 1 0

table[ 80] = 0xA0; // U_EMRSETDIBITSTODEVICE 1 0 1 0 0 0 0 0

table[ 81] = 0xA0; // U_EMRSTRETCHDIBITS 1 0 1 0 0 0 0 0

table[ 82] = 0x20; // U_EMREXTCREATEFONTINDIRECTW 0 0 1 0 0 0 0 0

table[ 83] = 0x02; // U_EMREXTTEXTOUTA 0 0 0 0 0 0 1 0

table[ 84] = 0x02; // U_EMREXTTEXTOUTW 0 0 0 0 0 0 1 0

table[ 85] = 0x83; // U_EMRPOLYBEZIER16 1 0 0 0 0 0 1 1

table[ 86] = 0x83; // U_EMRPOLYGON16 1 0 0 0 0 0 1 1

table[ 87] = 0x83; // U_EMRPOLYLINE16 1 0 0 0 0 0 1 1

table[ 88] = 0x8B; // U_EMRPOLYBEZIERTO16 1 0 0 0 1 0 1 1

table[ 89] = 0x8B; // U_EMRPOLYLINETO16 1 0 0 0 1 0 1 1

table[ 90] = 0x83; // U_EMRPOLYPOLYLINE16 1 0 0 0 0 0 1 1

table[ 91] = 0x87; // U_EMRPOLYPOLYGON16 1 0 0 0 0 1 1 1

table[ 92] = 0x83; // U_EMRPOLYDRAW16 1 0 0 0 0 0 1 1

table[ 93] = 0x80; // U_EMRCREATEMONOBRUSH 1 0 0 0 0 0 0 0 Not selected yet, so no change in drawing conditions

table[ 94] = 0x80; // U_EMRCREATEDIBPATTERNBRUSHPT 1 0 0 0 0 0 0 0 "

table[ 95] = 0x00; // U_EMREXTCREATEPEN 0 0 0 0 0 0 0 0 "

table[ 96] = 0x02; // U_EMRPOLYTEXTOUTA 0 0 0 0 0 0 1 0

table[ 97] = 0x02; // U_EMRPOLYTEXTOUTW 0 0 0 0 0 0 1 0

table[ 98] = 0xA0; // U_EMRSETICMMODE 1 0 1 0 0 0 0 0

table[ 99] = 0xA0; // U_EMRCREATECOLORSPACE 1 0 1 0 0 0 0 0

table[100] = 0xA0; // U_EMRSETCOLORSPACE 1 0 1 0 0 0 0 0

table[101] = 0xA0; // U_EMRDELETECOLORSPACE 1 0 1 0 0 0 0 0

table[102] = 0xA0; // U_EMRGLSRECORD 1 0 1 0 0 0 0 0

table[103] = 0xA0; // U_EMRGLSBOUNDEDRECORD 1 0 1 0 0 0 0 0

table[104] = 0xA0; // U_EMRPIXELFORMAT 1 0 1 0 0 0 0 0

table[105] = 0xA0; // U_EMRDRAWESCAPE 1 0 1 0 0 0 0 0

table[106] = 0xA0; // U_EMREXTESCAPE 1 0 1 0 0 0 0 0

table[107] = 0xA0; // U_EMRUNDEF107 1 0 1 0 0 0 0 0

table[108] = 0x02; // U_EMRSMALLTEXTOUT 0 0 0 0 0 0 1 0

table[109] = 0xA0; // U_EMRFORCEUFIMAPPING 1 0 1 0 0 0 0 0

table[110] = 0xA0; // U_EMRNAMEDESCAPE 1 0 1 0 0 0 0 0

table[111] = 0xA0; // U_EMRCOLORCORRECTPALETTE 1 0 1 0 0 0 0 0

table[112] = 0xA0; // U_EMRSETICMPROFILEA 1 0 1 0 0 0 0 0

table[113] = 0xA0; // U_EMRSETICMPROFILEW 1 0 1 0 0 0 0 0

table[114] = 0x82; // U_EMRALPHABLEND 1 0 0 0 0 0 1 0

table[115] = 0xA0; // U_EMRSETLAYOUT 1 0 1 0 0 0 0 0

table[116] = 0x82; // U_EMRTRANSPARENTBLT 1 0 0 0 0 0 1 0

table[117] = 0xA0; // U_EMRUNDEF117 1 0 1 0 0 0 0 0

table[118] = 0x82; // U_EMRGRADIENTFILL 1 0 0 0 0 0 1 0

table[119] = 0xA0; // U_EMRSETLINKEDUFIS 1 0 1 0 0 0 0 0

table[120] = 0x20; // U_EMRSETTEXTJUSTIFICATION 0 0 1 0 0 0 0 0

table[121] = 0xA0; // U_EMRCOLORMATCHTOTARGETW 1 0 1 0 0 0 0 0

table[122] = 0xA0; // U_EMRCREATECOLORSPACEW 1 0 1 0 0 0 0 0

}

result = table[type];

}

return(result);

}

int emr_arc_points_common(

PU_RECTL rclBox,

PU_POINTL ArcStart,

PU_POINTL ArcEnd,

int *f1,

int f2,

PU_PAIRF center,

PU_PAIRF start,

PU_PAIRF end,

PU_PAIRF size

){

U_PAIRF estart; // EMF start position, defines a radial

U_PAIRF eend; // EMF end position, defines a radial

U_PAIRF vec_estart; // define a unit vector from the center to estart

U_PAIRF vec_eend; // define a unit vector from the center to eend

U_PAIRF radii; // x,y radii of ellipse

U_PAIRF ratio; // intermediate value

float scale, cross;

center->x = ((float)(rclBox->left + rclBox->right ))/2.0;

center->y = ((float)(rclBox->top + rclBox->bottom))/2.0;

size->x = (float)(rclBox->right - rclBox->left );

size->y = (float)(rclBox->bottom - rclBox->top );

estart.x = (float)(ArcStart->x);

estart.y = (float)(ArcStart->y);

eend.x = (float)(ArcEnd->x);

eend.y = (float)(ArcEnd->y);

radii.x = size->x/2.0;

radii.y = size->y/2.0;

vec_estart.x = (estart.x - center->x); // initial vector, not unit length

vec_estart.y = (estart.y - center->y);

scale = sqrt(vec_estart.x*vec_estart.x + vec_estart.y*vec_estart.y);

if(!scale)return(1); // bogus record, has start at center

vec_estart.x /= scale; // now a unit vector

vec_estart.y /= scale;

vec_eend.x = (eend.x - center->x); // initial vector, not unit length

vec_eend.y = (eend.y - center->y);

scale = sqrt(vec_eend.x*vec_eend.x + vec_eend.y*vec_eend.y);

if(!scale)return(2); // bogus record, has end at center

vec_eend.x /= scale; // now a unit vector

vec_eend.y /= scale;

// Find the intersection of the vectors with the ellipse. With no loss of generality

// we can translate the ellipse to the origin, then we just need to find tu (t a factor, u the unit vector)

// that also satisfies (x/Rx)^2 + (y/Ry)^2 = 1. x is t*(ux), y is t*(uy), where ux,uy are the x,y components

// of the unit vector. Substituting gives:

// (t*(ux)/Rx)^2 + (t*(uy)/Ry)^2 = 1

// t^2 = 1/( (ux/Rx)^2 + (uy/Ry)^2 )

// t = sqrt(1/( (ux/Rx)^2 + (uy/Ry)^2 ))

ratio.x = vec_estart.x/radii.x;

ratio.y = vec_estart.y/radii.y;

ratio.x *= ratio.x; // we only use the square

ratio.y *= ratio.y;

scale = 1.0/sqrt(ratio.x + ratio.y);

start->x = center->x + scale * vec_estart.x;

start->y = center->y + scale * vec_estart.y;

ratio.x = vec_eend.x/radii.x;

ratio.y = vec_eend.y/radii.y;

ratio.x *= ratio.x; // we only use the square

ratio.y *= ratio.y;

scale = 1.0/sqrt(ratio.x + ratio.y);

end->x = center->x + scale * vec_eend.x;

end->y = center->y + scale * vec_eend.y;

//lastly figure out if the swept angle is >180 degrees or not, based on the direction of rotation

//and the two unit vectors.

cross = vec_estart.x * vec_eend.y - vec_estart.y * vec_eend.x;

if(!f2){ // counter clockwise rotation

if(cross >=0){ *f1 = 1; }

else { *f1 = 0; }

}

else {

if(cross >=0){ *f1 = 0; }

else { *f1 = 1; }

}

return(0);

}

int emr_arc_points(

PU_ENHMETARECORD record,

int *f1,

int f2,

PU_PAIRF center,

PU_PAIRF start,

PU_PAIRF end,

PU_PAIRF size

){

PU_EMRARC pEmr = (PU_EMRARC) (record);

return emr_arc_points_common(&(pEmr->rclBox), &(pEmr->ptlStart), &(pEmr->ptlEnd), f1, f2, center, start, end, size );

}

int RGBA_to_DIB(

char **px,

uint32_t *cbPx,

PU_RGBQUAD *ct,

int *numCt,

const char *rgba_px,

int w,

int h,

int stride,

uint32_t colortype,

int use_ct,

int invert

){

int bs;

int pad;

int i,j,k;

int istart, iend, iinc;

uint8_t r,g,b,a,tmp8;

char *pxptr;

const char *rptr;

int found;

int usedbytes;

U_RGBQUAD color;

PU_RGBQUAD lct;

int32_t index;

*px=NULL;

*ct=NULL;

*numCt=0;

*cbPx=0;

// sanity checking

if(!w || !h || !stride || !colortype || !rgba_px)return(1);

if(use_ct && colortype >= U_BCBM_COLOR16)return(2); //color tables not used above 16 bit pixels

if(!use_ct && colortype < U_BCBM_COLOR16)return(3); //color tables mandatory for < 16 bit

bs = colortype/8;

if(bs<1){

bs=1;

usedbytes = (w*colortype + 7)/8; // width of line in fully and partially occupied bytes

}

else {

usedbytes = w*bs;

}

pad = UP4(usedbytes) - usedbytes; // DIB rows must be aligned on 4 byte boundaries, they are padded at the end to accomplish this.;

*cbPx = h * (usedbytes + pad); // Rows must start on a 4 byte boundary!

*px = (char *) malloc(*cbPx);

if(!px)return(4);

if(use_ct){

*numCt = 1<< colortype;

if(*numCt >w*h)*numCt=w*h;

lct = (PU_RGBQUAD) malloc(*numCt * sizeof(U_RGBQUAD));

if(!lct)return(5);

*ct = lct;

}

if(invert){

istart = h-1;

iend = -1;

iinc = -1;

}

else {

istart = 0;

iend = h;

iinc = 1;

}

found = 0;

tmp8 = 0;

pxptr = *px;

for(i=istart; i!=iend; i+=iinc){

rptr= rgba_px + i*stride;

for(j=0; j<w; j++){

r = *rptr++;

g = *rptr++;

b = *rptr++;

a = *rptr++;

if(use_ct){

color = U_BGRA(r,g,b,a); // color has order in memory: b,g,r,a

index = -1;

for(lct = *ct, k=0; k<found; k++,lct++){ // Is this color in the table (VERY inefficient if there are a lot of colors!!!)

if(*(uint32_t *)lct != *(uint32_t *) &color)continue;

index =k;

break;

}

if(index==-1){ // add a color

found++;

if(found > *numCt){ // More colors found than are supported by the color table

free(*ct);

free(*px);

*numCt=0;

*cbPx=0;

return(6);

}

index = found - 1;

*lct = color;

}

switch(colortype){

case U_BCBM_MONOCHROME: // 2 colors. bmiColors array has two entries

tmp8 = tmp8 >> 1; // This seems wrong, as it fills from the top of each byte. But it works.

tmp8 |= index << 7;

if(!((j+1) % 8)){

*pxptr++ = tmp8;

tmp8 = 0;

}

break;

case U_BCBM_COLOR4: // 2^4 colors. bmiColors array has 16 entries

tmp8 = tmp8 << 4;

tmp8 |= index;

if(!((j+1) % 2)){

*pxptr++ = tmp8;

tmp8 = 0;

}

break;

case U_BCBM_COLOR8: // 2^8 colors. bmiColors array has 256 entries

tmp8 = index;

*pxptr++ = tmp8;

break;

case U_BCBM_COLOR16: // 2^16 colors. (Several different color methods))

case U_BCBM_COLOR24: // 2^24 colors. bmiColors is not used. Pixels are U_RGBTRIPLE.

case U_BCBM_COLOR32: // 2^32 colors. bmiColors is not used. Pixels are U_RGBQUAD.

case U_BCBM_EXPLICIT: // Derinved from JPG or PNG compressed image or ?

default:

return(7); // This should not be possible, but might happen with memory corruption

}

}

else {

switch(colortype){

case U_BCBM_COLOR16: // 2^16 colors. (Several different color methods))

b /= 8; g /= 8; r /= 8;

// Do it in this way so that the bytes are always stored Little Endian

tmp8 = b;

tmp8 |= g<<5; // least significant 3 bits of green

*pxptr++ = tmp8;

tmp8 = g>>3; // most significant 2 bits of green (there are only 5 bits of data)

tmp8 |= r<<2;

*pxptr++ = tmp8;

break;

case U_BCBM_COLOR24: // 2^24 colors. bmiColors is not used. Pixels are U_RGBTRIPLE.

*pxptr++ = b;

*pxptr++ = g;

*pxptr++ = r;

break;

case U_BCBM_COLOR32: // 2^32 colors. bmiColors is not used. Pixels are U_RGBQUAD.

*pxptr++ = b;

*pxptr++ = g;

*pxptr++ = r;

*pxptr++ = a;

break;

case U_BCBM_MONOCHROME: // 2 colors. bmiColors array has two entries

case U_BCBM_COLOR4: // 2^4 colors. bmiColors array has 16 entries

case U_BCBM_COLOR8: // 2^8 colors. bmiColors array has 256 entries

case U_BCBM_EXPLICIT: // Derinved from JPG or PNG compressed image or ?

default:

return(7); // This should not be possible, but might happen with memory corruption

}

}

}

if( use_ct && colortype == U_BCBM_MONOCHROME && (j % 8) ){

*pxptr++ = tmp8; // Write last few indices

tmp8 = 0;

}

if( use_ct && colortype == U_BCBM_COLOR4 && (j % 2) ){

*pxptr++ = tmp8; // Write last few indices

tmp8 = 0;

}

if(pad){

memset(pxptr,0,pad); // not strictly necessary, but set all bytes so that we can find important unset ones with valgrind

pxptr += pad;

}

}

return(0);

}

int get_real_color_count(

const char *Bmih

){

int Colors, BitCount, Width, Height;

uint32_t utmp4;

uint16_t utmp2;

int32_t tmp4;

char *cBmih = (char *) Bmih;

memcpy(&utmp4, cBmih + offsetof(U_BITMAPINFOHEADER,biClrUsed), 4); Colors = utmp4;

memcpy(&utmp2, cBmih + offsetof(U_BITMAPINFOHEADER,biBitCount), 2); BitCount = utmp2;

memcpy(&tmp4, cBmih + offsetof(U_BITMAPINFOHEADER,biWidth), 4); Width = tmp4;

memcpy(&tmp4, cBmih + offsetof(U_BITMAPINFOHEADER,biHeight), 4); Height = tmp4;

return(get_real_color_icount(Colors, BitCount, Width, Height));

}

int get_real_color_icount(

int Colors,

int BitCount,

int Width,

int Height

){

int area = Width * Height;

if(area < 0){ area = -area; } /* Height might be negative */

if(Colors == 0){

if( BitCount == U_BCBM_MONOCHROME){ Colors = 2; }

else if(BitCount == U_BCBM_COLOR4 ){ Colors = 16; }

else if(BitCount == U_BCBM_COLOR8 ){ Colors = 256; }

if(Colors > area){ Colors = area; }

}

return(Colors);

}

int get_DIB_params(

void *pEmr,

uint32_t offBitsSrc,

uint32_t offBmiSrc,

const char **px,

const U_RGBQUAD **ct,

uint32_t *numCt,

uint32_t *width,

uint32_t *height,

uint32_t *colortype,

uint32_t *invert

){

uint32_t bic;

PU_BITMAPINFO Bmi = (PU_BITMAPINFO)((char *)pEmr + offBmiSrc);

PU_BITMAPINFOHEADER Bmih = &(Bmi->bmiHeader);

/* if biCompression is not U_BI_RGB some or all of the following might not hold real values */

bic = Bmih->biCompression;

*width = Bmih->biWidth;

*colortype = Bmih->biBitCount;

if(Bmih->biHeight < 0){

*height = -Bmih->biHeight;

*invert = 1;

}

else {

*height = Bmih->biHeight;

*invert = 0;

}

if(bic == U_BI_RGB){

*numCt = get_real_color_count((const char *) Bmih);

if( numCt){ *ct = (PU_RGBQUAD) ((char *)Bmi + sizeof(U_BITMAPINFOHEADER)); }

else { *ct = NULL; }

}

else {

*numCt = Bmih->biSizeImage;

*ct = NULL;

}

*px = (char *)((char *)pEmr + offBitsSrc);

return(bic);

}

int DIB_to_RGBA(

const char *px,

const U_RGBQUAD *ct,

int numCt,

char **rgba_px,

int w,

int h,

uint32_t colortype,

int use_ct,

int invert

){

uint32_t cbRgba_px;

int stride;

int bs;

int pad;

int i,j;

int istart, iend, iinc;

uint8_t r,g,b,a,tmp8;

const char *pxptr;

char *rptr;

int usedbytes;

U_RGBQUAD color;

int32_t index;

// sanity checking

if(!w || !h || !colortype || !px)return(1);

if(use_ct && colortype >= U_BCBM_COLOR16)return(2); //color tables not used above 16 bit pixels

if(!use_ct && colortype < U_BCBM_COLOR16)return(3); //color tables mandatory for < 16 bit

if(use_ct && !numCt)return(4); //color table not adequately described

stride = w * 4;

cbRgba_px = stride * h;

bs = colortype/8;

if(bs<1){

bs=1;

usedbytes = (w*colortype + 7)/8; // width of line in fully and partially occupied bytes

}

else {

usedbytes = w*bs;

}

pad = UP4(usedbytes) - usedbytes; // DIB rows must be aligned on 4 byte boundaries, they are padded at the end to accomplish this.;

*rgba_px = (char *) malloc(cbRgba_px);

if(!rgba_px)return(4);

if(invert){

istart = h-1;

iend = -1;

iinc = -1;

}

else {

istart = 0;

iend = h;

iinc = 1;

}

pxptr = px;

tmp8 = 0; // silences a compiler warning, tmp8 always sets when j=0, so never used uninitialized

for(i=istart; i!=iend; i+=iinc){

rptr= *rgba_px + i*stride;

for(j=0; j<w; j++){

if(use_ct){

switch(colortype){

case U_BCBM_MONOCHROME: // 2 colors. bmiColors array has two entries

if(!(j % 8)){ tmp8 = *pxptr++; }

index = 0x80 & tmp8; // This seems wrong, as lowest position is top bit, but it works.

index = index >> 7;

tmp8 = tmp8 << 1;

break;

case U_BCBM_COLOR4: // 2^4 colors. bmiColors array has 16 entries

if(!(j % 2)){ tmp8 = *pxptr++; }

index = 0xF0 & tmp8;

index = index >> 4;

tmp8 = tmp8 << 4;

break;

case U_BCBM_COLOR8: // 2^8 colors. bmiColors array has 256 entries

index = (uint8_t) *pxptr++;;

break;

case U_BCBM_COLOR16: // 2^16 colors. (Several different color methods))

case U_BCBM_COLOR24: // 2^24 colors. bmiColors is not used. Pixels are U_RGBTRIPLE.

case U_BCBM_COLOR32: // 2^32 colors. bmiColors is not used. Pixels are U_RGBQUAD.

case U_BCBM_EXPLICIT: // Derinved from JPG or PNG compressed image or ?

default:

return(7); // This should not be possible, but might happen with memory corruption

}

color = ct[index];

b = U_BGRAGetB(color);

g = U_BGRAGetG(color);

r = U_BGRAGetR(color);

a = U_BGRAGetA(color);

}

else {

switch(colortype){

case U_BCBM_COLOR16: // 2^16 colors. (Several different color methods))

// Do it in this way because the bytes are always stored Little Endian

tmp8 = *pxptr++;

b = (0x1F & tmp8) <<3; // 5 bits of b into the top 5 of 8

g = tmp8 >> 5; // least significant 3 bits of green

tmp8 = *pxptr++;

r = (0x7C & tmp8) << 1; // 5 bits of r into the top 5 of 8

g |= (0x3 & tmp8) << 3; // most significant 2 bits of green (there are only 5 bits of data)

g = g << 3; // restore intensity (have lost 3 bits of accuracy)

a = 0;

break;

case U_BCBM_COLOR24: // 2^24 colors. bmiColors is not used. Pixels are U_RGBTRIPLE.

b = *pxptr++;

g = *pxptr++;

r = *pxptr++;

a = 0;

break;

case U_BCBM_COLOR32: // 2^32 colors. bmiColors is not used. Pixels are U_RGBQUAD.

b = *pxptr++;

g = *pxptr++;

r = *pxptr++;

a = *pxptr++;

break;

case U_BCBM_MONOCHROME: // 2 colors. bmiColors array has two entries

case U_BCBM_COLOR4: // 2^4 colors. bmiColors array has 16 entries

case U_BCBM_COLOR8: // 2^8 colors. bmiColors array has 256 entries

case U_BCBM_EXPLICIT: // Derinved from JPG or PNG compressed image or ?

default:

return(7); // This should not be possible, but might happen with memory corruption

}

}

*rptr++ = r;

*rptr++ = g;

*rptr++ = b;

*rptr++ = a;

}

for(j=0; j<pad; j++){ pxptr++; } // DIB rows are all 4 byte aligned

}

return(0);

}

char *RGBA_to_RGBA(

char *rgba_px,

int w,

int h,

int sl,

int st,

int *eew,

int *eeh

){

int i;

char *sub;

char *sptr;

int ew = *eew;

int eh = *eeh;

// sanity checking

if(w<=0 || h<=0 || ew<=0 || eh<=0 || !rgba_px)return(NULL);

if(sl>w || st >h)return(NULL); // This is hopeless, the start point is outside of the array.

if(sl<0){

if(sl+ew<=0)return(NULL); // This is hopeless, the start point is outside of the array.

ew += sl;

sl = 0;

}

if(st<0){

if(st+eh<=0)return(NULL); // This is hopeless, the start point is outside of the array.

eh += st;

st = 0;

}

if(sl+ew > w)ew=w-sl;

if(st+eh > h)eh=h-st;

if(!sl && !st && (ew == w) && (eh == h)){

sub = rgba_px;

}

else {

sptr = sub = malloc(ew*eh*4);

if(!sub)return(NULL);

for(i=st; i<st+eh; i++){

memcpy(sptr,rgba_px + i*w*4 + sl*4,4*ew);

sptr += 4*ew;

}

free(rgba_px);

}

*eeh = eh;

*eew = ew;

return(sub);

}

char *emr_dup(

const char *emr

){

char *dup;

int irecsize;

if(!emr)return(NULL);

irecsize = ((PU_EMR)emr)->nSize;

dup=malloc(irecsize);

if(dup){ memcpy(dup,emr,irecsize); }

return(dup);

}

int emf_start(

const char *name,

const uint32_t initsize,

const uint32_t chunksize,

EMFTRACK **et

){

FILE *fp;

EMFTRACK *etl=NULL;

if(initsize < 1)return(1);

if(chunksize < 1)return(2);

if(!name)return(3);

etl = (EMFTRACK *) malloc(sizeof(EMFTRACK));

if(!etl)return(4);

etl->buf = malloc(initsize); // no need to zero the memory

if(!etl->buf){

free(etl);

return(5);

}

fp=emf_fopen(name,U_WRITE);

if(!fp){

free(etl->buf);

free(etl);

return(6);

}

etl->fp = fp;

etl->allocated = initsize;

etl->used = 0;

etl->records = 0;

etl->PalEntries = 0;

etl->chunk = chunksize;

*et=etl;

return(0);

}

int emf_finish(

EMFTRACK *et,

EMFHANDLES *eht

){

U_EMRHEADER *record;

if(!et->fp)return(1); // This could happen if something stomps on memory, otherwise should be caught in emf_start

// Set the header fields which were unknown up until this point

record = (U_EMRHEADER *)et->buf;

record->nBytes = et->used;

record->nRecords = et->records;

record->nHandles = eht->peak + 1;

record->nPalEntries = et->PalEntries;

#if U_BYTE_SWAP

//This is a Big Endian machine, EMF data must be Little Endian

U_emf_endian(et->buf,et->used,1);

#endif

if(1 != fwrite(et->buf,et->used,1,et->fp))return(2);

(void) fclose(et->fp);

et->fp=NULL;

return(0);

}

int emf_free(

EMFTRACK **et

){

EMFTRACK *etl;

if(!et)return(1);

etl=*et;

if(!etl)return(2);

free(etl->buf);

free(etl);

*et=NULL;

return(0);

}

FILE *emf_fopen(

const char *filename,

const int mode

){

FILE *fp = NULL;

#ifdef WIN32

uint16_t *fn16;

uint16_t *md16;

if(mode == U_READ){ md16 = U_Utf8ToUtf16le("rb", 0, NULL); }

else { md16 = U_Utf8ToUtf16le("wb", 0, NULL); }

fn16 = U_Utf8ToUtf16le(filename, 0, NULL);

fp = _wfopen(fn16,md16);

free(fn16);

free(md16);

#else

if(mode == U_READ){ fp = fopen(filename,"rb"); }

else { fp = fopen(filename,"wb"); }

#endif

return(fp);

}

int emf_readdata(

const char *filename,

char **contents,

size_t *length

){

FILE *fp;

int status=0;

*contents=NULL;

fp=emf_fopen(filename,U_READ);

if(!fp){ status = 1; }

else {

// read the entire file into memory

fseek(fp, 0, SEEK_END); // move to end

*length = ftell(fp);

rewind(fp);

*contents = (char *) malloc(*length);

if(!*contents){

status = 2;

}

else {

size_t inbytes = fread(*contents,*length,1,fp);

if(inbytes != 1){

free(*contents);

status = 3;

}

else {

#if U_BYTE_SWAP

//This is a Big Endian machine, EMF data is Little Endian

U_emf_endian(*contents,*length,0); // LE to BE

#endif

}

}

fclose(fp);

}

return(status);

}

int emf_append(

U_ENHMETARECORD *rec,

EMFTRACK *et,

int freerec

){

size_t deficit;

#ifdef U_VALGRIND

printf("\nbefore \n");

printf(" probe %d\n",memprobe(rec, U_EMRSIZE(rec)));

printf("after \n");

#endif

if(!rec)return(1);

if(!et)return(2);

if(rec->nSize + et->used > et->allocated){

deficit = rec->nSize + et->used - et->allocated;

if(deficit < et->chunk)deficit = et->chunk;

et->allocated += deficit;

et->buf = realloc(et->buf,et->allocated);

if(!et->buf)return(3);

}

memcpy(et->buf + et->used, rec, rec->nSize);

et->used += rec->nSize;

et->records++;

if(rec->iType == U_EMR_EOF){ et->PalEntries = ((U_EMREOF *)rec)->cbPalEntries; }

if(freerec){ free(rec); }

return(0);

}

int emf_htable_create(

uint32_t initsize,

uint32_t chunksize,

EMFHANDLES **eht

){

EMFHANDLES *ehtl;

unsigned int i;

if(initsize<1)return(1);

if(chunksize<1)return(2);

ehtl = (EMFHANDLES *) malloc(sizeof(EMFHANDLES));

if(!ehtl)return(3);

ehtl->table = malloc(initsize * sizeof(uint32_t));

if(!ehtl->table){

free(ehtl);

return(4);

}

ehtl->stack = malloc(initsize * sizeof(uint32_t));

if(!ehtl->stack){

free(ehtl->table);

free(ehtl);

return(5);

}

memset(ehtl->table , 0, initsize * sizeof(uint32_t)); // zero all slots in the table

for(i=1; i<initsize; i++){ehtl->stack[i]=i;} // preset the stack

ehtl->allocated = initsize;

ehtl->chunk = chunksize;

ehtl->table[0] = 0; // This slot isn't actually ever used

ehtl->stack[0] = 0; // This stack position isn't actually ever used

ehtl->peak = 1;

ehtl->sptr = 1;

ehtl->top = 0;

*eht = ehtl;

return(0);

}

int emf_htable_delete(

uint32_t *ih,

EMFHANDLES *eht

){

if(!eht)return(1);

if(!eht->table)return(2);

if(!eht->stack)return(3);

if(*ih < 1)return(4); // invalid handle

if(!eht->table[*ih])return(5); // requested table position was not in use

eht->table[*ih]=0; // remove handle from table

while(eht->top>0 && !eht->table[eht->top]){ // adjust top

eht->top--;

}

eht->sptr--; // adjust stack

eht->stack[eht->sptr]=*ih; // place handle on stack

*ih=0; // invalidate handle variable, so a second delete will of it is not possible

return(0);

}

int emf_htable_insert(

uint32_t *ih,

EMFHANDLES *eht

){

unsigned int i;

size_t newsize;

if(!eht)return(1);

if(!eht->table)return(2);

if(!eht->stack)return(3);

if(!ih)return(4);

if(eht->sptr >= eht->allocated - 1){ // need to reallocate

newsize=eht->allocated + eht->chunk;

eht->table = realloc(eht->table,newsize * sizeof(uint32_t));

if(!eht->table)return(5);

memset(&eht->table[eht->allocated] , 0, eht->chunk * sizeof(uint32_t)); // zero all NEW slots in the table

eht->stack = realloc(eht->stack,newsize * sizeof(uint32_t));

if(!eht->stack)return(6);

for(i=eht->allocated; i<newsize;i++){ eht->stack[i] = i; } // init all NEW slots in the stack

eht->allocated = newsize;

}

*ih = eht->stack[eht->sptr]; // handle that is inserted

if(eht->table[*ih])return(7);

eht->table[*ih] = *ih; // handle goes into preexisting (but zero) slot in table

eht->stack[eht->sptr] = 0;

if(*ih > eht->top){ eht->top = *ih; }

if(eht->sptr > eht->peak){ eht->peak = eht->sptr; }

eht->sptr++; // next available handle

return(0);

}

int emf_htable_free(

EMFHANDLES **eht

){

EMFHANDLES *ehtl;

if(!eht)return(1);

ehtl = *eht;

if(!ehtl)return(2);

if(!ehtl->table)return(3);

if(!ehtl->stack)return(4);

free(ehtl->table);

free(ehtl->stack);

free(ehtl);

*eht=NULL;

return(0);

}

int device_size(

const int xmm,

const int ymm,

const float dpmm,

U_SIZEL *szlDev,

U_SIZEL *szlMm

){

if(xmm < 0 || ymm < 0 || dpmm < 0)return(1);

szlDev->cx = U_ROUND((float) xmm * dpmm);

szlDev->cy = U_ROUND((float) ymm * dpmm);;

szlMm->cx = xmm;

szlMm->cy = ymm;

return(0);

}

int drawing_size(

const int xmm,

const int ymm,

const float dpmm,

U_RECTL *rclBounds,

U_RECTL *rclFrame

){

if(xmm < 0 || ymm < 0 || dpmm < 0)return(1);

rclBounds->left = 0;

rclBounds->top = 0;

rclBounds->right = U_ROUND((float) xmm * dpmm) - 1; // because coordinate system is 0,0 in upper left, N,M in lower right

rclBounds->bottom = U_ROUND((float) ymm * dpmm) - 1;

rclFrame->left = 0;

rclFrame->top = 0;

rclFrame->right = U_ROUND((float) xmm * 100.) - 1;

rclFrame->bottom = U_ROUND((float) ymm * 100.) - 1;

return(0);

}

U_COLORREF colorref_set(

uint8_t red,

uint8_t green,

uint8_t blue

){

U_COLORREF cr = (U_COLORREF){red , green, blue, 0};

return(cr);

}

U_RECTL rectl_set(

U_POINTL ul,

U_POINTL lr

){

U_RECTL rct;

rct.left = ul.x;

rct.top = ul.y;

rct.right = lr.x;

rct.bottom = lr.y;

return(rct);

}

U_SIZEL sizel_set(

int32_t x,

int32_t y

){

U_SIZEL sz;

sz.cx = x;

sz.cy = y;

return(sz);

}

U_POINTL point32_set(

int32_t x,

int32_t y

){

U_POINTL pt;

pt.x = x;

pt.y = y;

return(pt);

}

U_POINT16 point16_set(

int16_t x,

int16_t y

){

U_POINT16 pt;

pt.x = x;

pt.y = y;

return(pt);

}

U_RECT findbounds(

uint32_t count,

PU_POINT pts,

uint32_t width

){

U_RECT rect={INT32_MAX, INT32_MAX, INT32_MIN, INT32_MIN };

unsigned int i;

for(i=0; i<count;i++,pts++){

if ( pts->x < rect.left ) rect.left = pts->x;

if ( pts->x > rect.right ) rect.right = pts->x;

if ( pts->y < rect.top ) rect.top = pts->y;

if ( pts->y > rect.bottom ) rect.bottom = pts->y;

}

if(width > 0){

rect.left -= width;

rect.right += width;

rect.top += width;

rect.bottom -= width;

}

return(rect);

}

U_RECT findbounds16(

uint32_t count,

PU_POINT16 pts,

uint32_t width

){

U_RECT rect={INT16_MAX, INT16_MAX, INT16_MIN, INT16_MIN };

unsigned int i;

for(i=0; i<count;i++,pts++){

if ( pts->x < rect.left ) rect.left = pts->x;

if ( pts->x > rect.right ) rect.right = pts->x;

if ( pts->y < rect.top ) rect.top = pts->y;

if ( pts->y > rect.bottom ) rect.bottom = pts->y;

}

if(width > 0){

rect.left -= width;

rect.right += width;

rect.top += width;

rect.bottom -= width;

}

return(rect);

}

U_LOGBRUSH logbrush_set(

uint32_t lbStyle,

U_COLORREF lbColor,

int32_t lbHatch

){

U_LOGBRUSH lb;

lb.lbStyle = lbStyle;

lb.lbColor = lbColor;

lb.lbHatch = lbHatch;

return(lb);

}

U_XFORM xform_set(

U_FLOAT eM11,

U_FLOAT eM12,

U_FLOAT eM21,

U_FLOAT eM22,

U_FLOAT eDx,

U_FLOAT eDy

){

U_XFORM xform;

xform.eM11 = eM11;

xform.eM12 = eM12;

xform.eM21 = eM21;

xform.eM22 = eM22;

xform.eDx = eDx;

xform.eDy = eDy;

return(xform);

}

U_XFORM xform_alt_set(

U_FLOAT scale,

U_FLOAT ratio,

U_FLOAT rot,

U_FLOAT axisrot,

U_FLOAT eDx,

U_FLOAT eDy

){

U_XFORM xform;

U_MAT2X2 mat1, mat2;

// angles are in degrees, must be in radians

rot *= (2.0 * U_PI)/360.0;

axisrot *= -(2.0 * U_PI)/360.0;

mat1.M11 = cos(rot); // set up the rotation matrix

mat1.M12 = -sin(rot);

mat1.M21 = sin(rot);

mat1.M22 = cos(rot);

if(ratio!=1.0){ // set scale/ellipticity matrix

mat2.M11 = scale*( cos(axisrot)*cos(axisrot) + ratio*sin(axisrot)*sin(axisrot) );

mat2.M12 = mat2.M21 = scale*( sin(axisrot)*cos(axisrot) * (1.0 - ratio) );

mat2.M22 = scale*( sin(axisrot)*sin(axisrot) + ratio*cos(axisrot)*cos(axisrot) );

}

else { // when the ratio is 1.0 then the major axis angle is ignored and only scale matters

mat2.M11 = scale;

mat2.M12 = 0.0;

mat2.M21 = 0.0;

mat2.M22 = scale;

}

xform.eM11 = mat2.M11 * mat1.M11 + mat2.M12 * mat1.M21;

xform.eM12 = mat2.M11 * mat1.M12 + mat2.M12 * mat1.M22;;

xform.eM21 = mat2.M21 * mat1.M11 + mat2.M22 * mat1.M21;

xform.eM22 = mat2.M21 * mat1.M12 + mat2.M22 * mat1.M22;

xform.eDx = eDx;

xform.eDy = eDy;

return(xform);

}

U_LOGCOLORSPACEA logcolorspacea_set(

int32_t lcsCSType,

int32_t lcsIntent,

U_CIEXYZTRIPLE lcsEndpoints,

U_LCS_GAMMARGB lcsGammaRGB,

char *lcsFilename

){

U_LOGCOLORSPACEA lcsa;

lcsa.lcsSignature = U_LCS_SIGNATURE;

lcsa.lcsVersion = U_LCS_SIGNATURE;

lcsa.lcsSize = sizeof(U_LOGCOLORSPACEA);

lcsa.lcsCSType = lcsCSType;

lcsa.lcsIntent = lcsIntent;

lcsa.lcsEndpoints = lcsEndpoints;

lcsa.lcsGammaRGB = lcsGammaRGB;

memset(lcsa.lcsFilename,0,U_MAX_PATH); // zero out the Filename field

strncpy(lcsa.lcsFilename,lcsFilename,U_MAX_PATH);

return(lcsa);

}

U_LOGCOLORSPACEW logcolorspacew_set(

int32_t lcsCSType,

int32_t lcsIntent,

U_CIEXYZTRIPLE lcsEndpoints,

U_LCS_GAMMARGB lcsGammaRGB,

uint16_t *lcsFilename

){

U_LOGCOLORSPACEW lcsa;

lcsa.lcsSignature = U_LCS_SIGNATURE;

lcsa.lcsVersion = U_LCS_SIGNATURE;

lcsa.lcsSize = sizeof(U_LOGCOLORSPACEW);

lcsa.lcsCSType = lcsCSType;

lcsa.lcsIntent = lcsIntent;

lcsa.lcsEndpoints = lcsEndpoints;

lcsa.lcsGammaRGB = lcsGammaRGB;

wchar16strncpypad(lcsa.lcsFilename,lcsFilename,U_MAX_PATH);

return(lcsa);

}

U_PANOSE panose_set(

uint8_t bFamilyType,

uint8_t bSerifStyle,

uint8_t bWeight,

uint8_t bProportion,

uint8_t bContrast,

uint8_t bStrokeVariation,

uint8_t bArmStyle,

uint8_t bLetterform,

uint8_t bMidline,

uint8_t bXHeight

){

U_PANOSE panose;

panose.bFamilyType = bFamilyType;

panose.bSerifStyle = bSerifStyle;

panose.bWeight = bWeight;

panose.bProportion = bProportion;

panose.bContrast = bContrast;

panose.bStrokeVariation = bStrokeVariation;

panose.bArmStyle = bArmStyle;

panose.bLetterform = bLetterform;

panose.bMidline = bMidline;

panose.bXHeight = bXHeight;

return(panose);

}

U_LOGFONT logfont_set(

int32_t lfHeight,

int32_t lfWidth,

int32_t lfEscapement,

int32_t lfOrientation,

int32_t lfWeight,

uint8_t lfItalic,

uint8_t lfUnderline,

uint8_t lfStrikeOut,

uint8_t lfCharSet,

uint8_t lfOutPrecision,

uint8_t lfClipPrecision,

uint8_t lfQuality,

uint8_t lfPitchAndFamily,

uint16_t *lfFaceName

){

U_LOGFONT lf;

lf.lfHeight = lfHeight;

lf.lfWidth = lfWidth;

lf.lfEscapement = lfEscapement;

lf.lfOrientation = lfOrientation;

lf.lfWeight = lfWeight;

lf.lfItalic = lfItalic;

lf.lfUnderline = lfUnderline;

lf.lfStrikeOut = lfStrikeOut;

lf.lfCharSet = lfCharSet;

lf.lfOutPrecision = lfOutPrecision;

lf.lfClipPrecision = lfClipPrecision;

lf.lfQuality = lfQuality;

lf.lfPitchAndFamily = lfPitchAndFamily;

wchar16strncpypad(lf.lfFaceName, lfFaceName, U_LF_FACESIZE); // pad this one as the intial structure was not set to zero

return(lf);

}

U_LOGFONT_PANOSE logfont_panose_set(

U_LOGFONT elfLogFont,

uint16_t *elfFullName,

uint16_t *elfStyle,

uint32_t elfStyleSize,

U_PANOSE elfPanose

){

U_LOGFONT_PANOSE lfp;

memset(&lfp,0,sizeof(U_LOGFONT_PANOSE)); // all fields zero unless needed. Many should be ignored or must be 0.

wchar16strncpy(lfp.elfFullName, elfFullName, U_LF_FULLFACESIZE);

wchar16strncpy(lfp.elfStyle, elfStyle, U_LF_FACESIZE);

lfp.elfLogFont = elfLogFont;

lfp.elfStyleSize = elfStyleSize;

lfp.elfPanose = elfPanose;

return(lfp);

}

U_BITMAPINFOHEADER bitmapinfoheader_set(

int32_t biWidth,

int32_t biHeight,

uint16_t biPlanes,

uint16_t biBitCount,

uint32_t biCompression,

uint32_t biSizeImage,

int32_t biXPelsPerMeter,

int32_t biYPelsPerMeter,

U_NUM_RGBQUAD biClrUsed,

uint32_t biClrImportant

){

U_BITMAPINFOHEADER Bmi;

Bmi.biSize = sizeof(U_BITMAPINFOHEADER);

Bmi.biWidth = biWidth;

Bmi.biHeight = biHeight;

Bmi.biPlanes = biPlanes;

Bmi.biBitCount = biBitCount;

Bmi.biCompression = biCompression;

Bmi.biSizeImage = biSizeImage;

Bmi.biXPelsPerMeter = biXPelsPerMeter;

Bmi.biYPelsPerMeter = biYPelsPerMeter;

Bmi.biClrUsed = biClrUsed;

Bmi.biClrImportant = biClrImportant;

return(Bmi);

}

PU_BITMAPINFO bitmapinfo_set(

U_BITMAPINFOHEADER BmiHeader,

PU_RGBQUAD BmiColors

){

char *record;

int irecsize;

int cbColors, cbColors4, off;

cbColors = 4*get_real_color_count((char *) &BmiHeader);

cbColors4 = UP4(cbColors);

irecsize = sizeof(U_BITMAPINFOHEADER) + cbColors4;

record = malloc(irecsize);

if(record){

memcpy(record, &BmiHeader, sizeof(U_BITMAPINFOHEADER));

if(cbColors){

off = sizeof(U_BITMAPINFOHEADER);

memcpy(record + off, BmiColors, cbColors);

off += cbColors;

if(cbColors4 - cbColors){ memset(record + off, 0, cbColors4 - cbColors); }

}

}

return((PU_BITMAPINFO) record);

}

PU_EXTLOGPEN extlogpen_set(

uint32_t elpPenStyle,

uint32_t elpWidth,

uint32_t elpBrushStyle,

U_COLORREF elpColor,

int32_t elpHatch,

U_NUM_STYLEENTRY elpNumEntries,

U_STYLEENTRY *elpStyleEntry

){

int irecsize,szSyleArray;

char *record;

if(elpNumEntries){

if(!elpStyleEntry)return(NULL);

szSyleArray = elpNumEntries * sizeof(U_STYLEENTRY);

irecsize = sizeof(U_EXTLOGPEN) + szSyleArray - sizeof(U_STYLEENTRY); // first one is in the record

}

else {

szSyleArray = 0;

irecsize = sizeof(U_EXTLOGPEN);

}

record = malloc(irecsize);

if(record){

((PU_EXTLOGPEN) record)->elpPenStyle = elpPenStyle;

((PU_EXTLOGPEN) record)->elpWidth = elpWidth;

((PU_EXTLOGPEN) record)->elpBrushStyle = elpBrushStyle;

((PU_EXTLOGPEN) record)->elpColor = elpColor;

((PU_EXTLOGPEN) record)->elpHatch = elpHatch;

((PU_EXTLOGPEN) record)->elpNumEntries = elpNumEntries;

if(elpNumEntries){ memcpy(((PU_EXTLOGPEN) record)->elpStyleEntry,elpStyleEntry,szSyleArray); }

else { memset(((PU_EXTLOGPEN) record)->elpStyleEntry,0,sizeof(U_STYLEENTRY)); } // not used, but this stops valgrind warnings

}

return((PU_EXTLOGPEN) record);

}

U_LOGPEN logpen_set(

uint32_t lopnStyle,

U_POINT lopnWidth,

U_COLORREF lopnColor

){

U_LOGPEN lp;

lp.lopnStyle = lopnStyle;

lp.lopnWidth = lopnWidth;

lp.lopnColor = lopnColor;

return(lp);

}

U_LOGPLTNTRY logpltntry_set(

uint8_t peReserved,

uint8_t peRed,

uint8_t peGreen,

uint8_t peBlue

){

U_LOGPLTNTRY lpny;

lpny.peReserved = peReserved;

lpny.peRed = peRed;

lpny.peGreen = peGreen;

lpny.peBlue = peBlue;

return(lpny);

}

PU_LOGPALETTE logpalette_set(

U_NUM_LOGPLTNTRY palNumEntries,

PU_LOGPLTNTRY *palPalEntry

){

PU_LOGPALETTE record;

int cbPalArray,irecsize;

if(palNumEntries == 0 || !palPalEntry)return(NULL);

cbPalArray = palNumEntries * sizeof(U_LOGPLTNTRY);

irecsize = sizeof(U_LOGPALETTE) + cbPalArray - sizeof(U_LOGPLTNTRY);

record = (PU_LOGPALETTE) malloc(irecsize);

if(irecsize){

record->palVersion = U_LP_VERSION;

record->palNumEntries = palNumEntries;

memcpy(record->palPalEntry,palPalEntry,cbPalArray);

}

return(record);

}

U_RGNDATAHEADER rgndataheader_set(

U_NUM_RECTL nCount,

U_RECTL rclBounds

){

U_RGNDATAHEADER rdh;

rdh.dwSize = U_RDH_OBJSIZE;

rdh.iType = U_RDH_RECTANGLES;

rdh.nCount = nCount;

rdh.nRgnSize = nCount * sizeof(U_RECTL); // Size in bytes of retangle array

rdh.rclBounds = rclBounds;

return(rdh);

}

PU_RGNDATA rgndata_set(

U_RGNDATAHEADER rdh,

PU_RECTL Buffer

){

char *record;

int irecsize;

int szRgnArray,off;

if(!Buffer || !rdh.nCount || !rdh.nRgnSize)return(NULL);

szRgnArray = rdh.nRgnSize; // size of the U_RECTL array

irecsize = sizeof(U_RGNDATA) + szRgnArray - sizeof(U_RECTL); // core + array - overlap

record = malloc(irecsize);

if(record){

memcpy(record, &rdh, sizeof(U_RGNDATAHEADER));

off = sizeof(U_RGNDATAHEADER);

memcpy(record + off, Buffer, szRgnArray);

}

return((PU_RGNDATA) record);

}

U_COLORADJUSTMENT coloradjustment_set(

uint16_t Size,

uint16_t Flags,

uint16_t IlluminantIndex,

uint16_t RedGamma,

uint16_t GreenGamma,

uint16_t BlueGamma,

uint16_t ReferenceBlack,

uint16_t ReferenceWhite,

int16_t Contrast,

int16_t Brightness,

int16_t Colorfulness,

int16_t RedGreenTint

){

U_COLORADJUSTMENT ca;

ca.caSize = Size;

ca.caFlags = Flags;

ca.caIlluminantIndex = IlluminantIndex;

ca.caRedGamma = U_MNMX(RedGamma, U_RGB_GAMMA_MIN, U_RGB_GAMMA_MAX);

ca.caGreenGamma = U_MNMX(GreenGamma, U_RGB_GAMMA_MIN, U_RGB_GAMMA_MAX);

ca.caBlueGamma = U_MNMX(BlueGamma, U_RGB_GAMMA_MIN, U_RGB_GAMMA_MAX);

// Next one is different to eliminate compiler warning - U_R_B_MIN is 0 and unsigned

ca.caReferenceBlack = U_MAX( ReferenceBlack, U_REFERENCE_BLACK_MAX);

ca.caReferenceWhite = U_MNMX(ReferenceWhite, U_REFERENCE_WHITE_MIN, U_REFERENCE_WHITE_MAX);

ca.caContrast = U_MNMX(Contrast, U_COLOR_ADJ_MIN, U_COLOR_ADJ_MAX);

ca.caBrightness = U_MNMX(Brightness, U_COLOR_ADJ_MIN, U_COLOR_ADJ_MAX);

ca.caColorfulness = U_MNMX(Colorfulness, U_COLOR_ADJ_MIN, U_COLOR_ADJ_MAX);

ca.caRedGreenTint = U_MNMX(RedGreenTint, U_COLOR_ADJ_MIN, U_COLOR_ADJ_MAX);

return(ca);

}

U_PIXELFORMATDESCRIPTOR pixelformatdescriptor_set(

uint32_t dwFlags,

uint8_t iPixelType,

uint8_t cColorBits,

uint8_t cRedBits,

uint8_t cRedShift,

uint8_t cGreenBits,

uint8_t cGreenShift,

uint8_t cBlueBits,

uint8_t cBlueShift,

uint8_t cAlphaBits,

uint8_t cAlphaShift,

uint8_t cAccumBits,

uint8_t cAccumRedBits,

uint8_t cAccumGreenBits,

uint8_t cAccumBlueBits,

uint8_t cAccumAlphaBits,

uint8_t cDepthBits,

uint8_t cStencilBits,

uint8_t cAuxBuffers,

uint8_t iLayerType,

uint8_t bReserved,

uint32_t dwLayerMask,

uint32_t dwVisibleMask,

uint32_t dwDamageMask

){

U_PIXELFORMATDESCRIPTOR pfd;

pfd.nSize = sizeof(U_PIXELFORMATDESCRIPTOR);

pfd.nVersion = 1;

pfd.dwFlags = dwFlags;

pfd.iPixelType = iPixelType;

pfd.cColorBits = cColorBits;

pfd.cRedBits = cRedBits;

pfd.cRedShift = cRedShift;

pfd.cGreenBits = cGreenBits;

pfd.cGreenShift = cGreenShift;

pfd.cBlueBits = cBlueBits;

pfd.cBlueShift = cBlueShift;

pfd.cAlphaBits = cAlphaBits;

pfd.cAlphaShift = cAlphaShift;

pfd.cAccumBits = cAccumBits;

pfd.cAccumRedBits = cAccumRedBits;

pfd.cAccumGreenBits = cAccumGreenBits;

pfd.cAccumBlueBits = cAccumBlueBits;

pfd.cAccumAlphaBits = cAccumAlphaBits;

pfd.cDepthBits = cDepthBits;

pfd.cStencilBits = cStencilBits;

pfd.cAuxBuffers = cAuxBuffers;

pfd.iLayerType = iLayerType;

pfd.bReserved = bReserved;

pfd.dwLayerMask = dwLayerMask;

pfd.dwVisibleMask = dwVisibleMask;

pfd.dwDamageMask = dwDamageMask;

return(pfd);

}

char *emrtext_set(

U_POINTL ptlReference,

U_NUM_STR NumString,

uint32_t cbChar,

void *String,

uint32_t fOptions,

U_RECTL rcl,

uint32_t *Dx

){

int irecsize,cbDxArray,cbString4,cbString,off;

char *record;

uint32_t *loffDx;

if(!String)return(NULL);

if(!Dx)return(NULL);

cbString = cbChar * NumString; // size of the string in bytes

cbString4 = UP4(cbString); // size of the string buffer

cbDxArray = sizeof(uint32_t)*NumString; // size of Dx array storage

if(fOptions & U_ETO_PDY)cbDxArray += cbDxArray; // of the Dx buffer, here do both X and Y coordinates

irecsize = sizeof(U_EMRTEXT) + sizeof(uint32_t) + cbString4 + cbDxArray; // core structure + offDx + string buf + dx buf

if(!(fOptions & U_ETO_NO_RECT)){ irecsize += sizeof(U_RECTL); } // plus variable U_RECTL, when it is present

record = malloc(irecsize);

if(record){

((PU_EMRTEXT)record)->ptlReference = ptlReference;

((PU_EMRTEXT)record)->nChars = NumString;

// pick up ((PU_EMRTEXT)record)->offString later

((PU_EMRTEXT)record)->fOptions = fOptions;

off = sizeof(U_EMRTEXT); // location where variable pieces will start to be written

if(!(fOptions & U_ETO_NO_RECT)){ // variable field, may or may not be present

memcpy(record + off,&rcl, sizeof(U_RECTL));

off += sizeof(U_RECTL);

}

loffDx = (uint32_t *)(record + off); // offDx will go here, but we do not know with what value yet

off += sizeof(uint32_t);

memcpy(record + off,String,cbString); // copy the string data to its buffer

((PU_EMRTEXT)record)->offString = off; // now save offset in the structure

off += cbString;

if(cbString < cbString4){

memset(record+off,0,cbString4-cbString); // keeps valgrind happy (initialize padding after string)

off += cbString4-cbString;

}

memcpy(record + off, Dx, cbDxArray); // copy the Dx data to its buffer

*loffDx = off; // now save offDx to the structure

}

return(record);

}

char *textcomment_set(

const char *string

){

if(!string)return(NULL);

return(U_EMRCOMMENT_set(1 + strlen(string),string));

}

char *deleteobject_set(

uint32_t *ihObject,

EMFHANDLES *eht

){

uint32_t saveObject=*ihObject;

if(emf_htable_delete(ihObject,eht))return(NULL); // invalid handle or other problem, cannot be deleted

return(U_EMRDELETEOBJECT_set(saveObject));

}

char *selectobject_set(

uint32_t ihObject,

EMFHANDLES *eht

){

if(!(U_STOCK_OBJECT & ihObject)){ // not a stock object, those go straight through

if(ihObject > eht->top)return(NULL); // handle this high is not in the table

if(!eht->table[ihObject])return(NULL); // handle is not in the table, so not active, so cannot be selected

}

return(U_EMRSELECTOBJECT_set(ihObject));

}

char *extcreatepen_set(

uint32_t *ihPen,

EMFHANDLES *eht,

PU_BITMAPINFO Bmi,

const uint32_t cbPx,

char *Px,

PU_EXTLOGPEN elp

){

if(emf_htable_insert(ihPen, eht))return(NULL);

return(U_EMREXTCREATEPEN_set(*ihPen, Bmi, cbPx, Px, elp ));

}

char *createpen_set(

uint32_t *ihPen,

EMFHANDLES *eht,

U_LOGPEN lopn

){

if(emf_htable_insert(ihPen, eht))return(NULL);

return(U_EMRCREATEPEN_set(*ihPen, lopn));

}

char *createbrushindirect_set(

uint32_t *ihBrush,

EMFHANDLES *eht,

U_LOGBRUSH lb

){

if(emf_htable_insert(ihBrush, eht))return(NULL);

return(U_EMRCREATEBRUSHINDIRECT_set(*ihBrush, lb));

}

char *createdibpatternbrushpt_set(

uint32_t *ihBrush,

EMFHANDLES *eht,

const uint32_t iUsage,

PU_BITMAPINFO Bmi,

const uint32_t cbPx,

const char *Px

){

if(emf_htable_insert(ihBrush, eht))return(NULL);

return(U_EMRCREATEDIBPATTERNBRUSHPT_set(*ihBrush, iUsage, Bmi, cbPx, Px));

}

char *createmonobrush_set(

uint32_t *ihBrush,

EMFHANDLES *eht,

const uint32_t iUsage,

PU_BITMAPINFO Bmi,

const uint32_t cbPx,

const char *Px

){

if(emf_htable_insert(ihBrush, eht))return(NULL);

return(U_EMRCREATEMONOBRUSH_set(*ihBrush, iUsage, Bmi, cbPx, Px));

}

char *createcolorspace_set(

uint32_t *ihCS,

EMFHANDLES *eht,

U_LOGCOLORSPACEA lcs

){

if(emf_htable_insert(ihCS, eht))return(NULL);

return(U_EMRCREATECOLORSPACE_set(*ihCS,lcs));

}

char *createcolorspacew_set(

uint32_t *ihCS,

EMFHANDLES *eht,

U_LOGCOLORSPACEW lcs,

uint32_t dwFlags,

U_CBDATA cbData,

uint8_t *Data

){

if(emf_htable_insert(ihCS, eht))return(NULL);

return(U_EMRCREATECOLORSPACEW_set(*ihCS, lcs, dwFlags, cbData, Data));

}

char *extcreatefontindirectw_set(

uint32_t *ihFont,

EMFHANDLES *eht,

const char *elf,

const char *elfw

){

if(emf_htable_insert(ihFont, eht))return(NULL);

return(U_EMREXTCREATEFONTINDIRECTW_set(*ihFont, elf, elfw));

}

char *createpalette_set(

uint32_t *ihPal,

EMFHANDLES *eht,

U_LOGPALETTE lgpl

){

if(emf_htable_insert(ihPal, eht))return(NULL);

return(U_EMRCREATEPALETTE_set(*ihPal, lgpl));

}

char *setpaletteentries_set(

uint32_t *ihPal,