diff options
Diffstat (limited to '')
| -rw-r--r-- | src/3rdparty/libuemf/README | 567 |
1 files changed, 567 insertions, 0 deletions
diff --git a/src/3rdparty/libuemf/README b/src/3rdparty/libuemf/README new file mode 100644 index 0000000..4d66bbe --- /dev/null +++ b/src/3rdparty/libuemf/README @@ -0,0 +1,567 @@ +Overview: + +libUEMF is a portable C99 implementation for reading/writing Enhanced Metafile (EMF), +Enhanced Metafile Format Plus (PMF), and Windows Metafile (WMF) files. libUEMF +avoids collisions with Microsoft defined functions and values, so portable programs +which use it and have a Windows version, do not require any conditional logic to +separate the native GDI support from the WMF/EMF/PMF support proviced by libUEMF. To +accomplish this libUEMF does not implement GDI calls. Instead, for each WMR/EMR/PMR +record type, and each object type incorporated into such a record, it provides +corresponding *_set, *_print, and *_swap functions. For PMF and WMF there are also +*_get functions, see below. For example, for the U_EMRBITBLT record there are +corresponding functions: U_EMRBITBLT_set, U_EMRBITBLT_print, and U_EMRBITBLT_swap. A +few additional functions are provided for assembling the EMF in memory, debugging, and +converting the EMF file to/from Little Endian representation. (EMF files' internal +data representation is always Little Endian.) + +This code has been tested on 32 bit Ubuntu (LE), 32 bit Mingw, 64 bit CentOS, and 64 +bit Solaris (BE). + +libUEMF is released under the GPL 2 license, read the file 'COPYING' for more information + +Version 0.2.8, released May 13, 2020. + +To report bugs or provide feedback send email to David Mathog, mathog@caltech.edu. + +-------------------------------------------------------------------------------------------- +Sources: + +EMF file Record structure information has been derived from Mingw, Wine, and libEMF +header files, and from Microsoft's EMF Information pdf, release date March 28,2012, +link from here: + + http://msdn2.microsoft.com/en-us/library/cc230514.aspx + +If the direct link fails the document may be found +by searching the web for: "[MS-EMF]: Enhanced Metafile Format". + +WMF file Record structure information is from some of the same sources, as well as: + http://msdn2.microsoft.com/en-us/library/250370.aspx + +If the direct link fails the document may be found +by searching the web for: "[MS-WMF]: Windows Metafile Format" + +EMF+ file Record structure is from many helpful responses from Microsoft documentation support +and from: + http://msdn.microsoft.com/en-us/library/cc230724.aspx + +If the direct link fails the document may be found +by searching the web for: "[MS-EMFPLUS]: Enhanced Metafile Format Plus Extensions" + + +Files: + +README This file. + +CMakeLists.txt Build instructions for cmake on linux. Not tested on OS X or + Windows. + +COPYING GPL V2 license file. + +DOXYFILE Doxygen configuration file, for generating documentation from the source files. + +testbuild.sh Small bash script to build all programs. Modify as needed for target platform. + +testit.sh Small bash script that generates all test files and compares + them with referencess supplied. This script should be edited + to match your test system before it is run! + +uemf.c Contains the *_set functions needed to construct an EMF file. + Also contains auxilliary functions for debugging and constructing + EMF files in memory. + +uemf.h Definitions and structures for EMF records and objects. + Prototypes for *_set and construction functions. + +uemf_print.c Contains the *_print functions needed to print the contents of EMF records and objects. + +uemf_print.h Prototypes for *_print functions. + +uemf_endian.c Contains the *_swap functions needed to rearrange bytes between Big and Little Endian. + U_emf_endian() is the only function here that user could should call. + +uemf_endian.h Prototype for U_emf_endian() and definitions for Endian type of the local machine. + +uemf_safe.c Contains the *_safe functions for EMF records, which verify that all + offsets and counts stay within the declared size of a record. Also checks that + core record sizes are sane. U_emf_record_safe() is the only _safe function which + user code should call directly, and then ONLY after a previous call to + U_emf_record_sizeok(), which is in the endian file. + +uemf_safe.h Prototype for U_emf_record_safe(). + . +upmf.c Contains the *_set and *_get functions needed to construct or read an EMF+ file. + Also contains auxilliary functions for debugging and constructing + EMF+ files in memory. + +upmf.h Definitions and structures for EMF+ records and objects. + Prototypes for *_set, *_get and construction functions. + +upmf_print.c Contains the *_print functions needed to print the contents of EMF+ records and objects. + +upmf_print.h Prototypes for *_print functions. + + +uwmf.c Contains the *_set and *_get functions needed to construct or read a WMF file. + Also contains auxilliary functions for debugging and constructing + WMF files in memory. + +uwmf.h Definitions and structures for WMF records and objects. + Prototypes for *_set, *_get and construction functions. + +uwmf_print.c Contains the *_print functions needed to print the contents of WMF records and objects. + +uwmf_print.h Prototypes for *_print functions. + +uwmf_endian.c Contains the *_swap functions needed to rearrange bytes between Big and Little Endian. + U_wmf_endian() is the only function here that user could should call. + +uwmf_endian.h Prototype for U_wmf_endian() and definitions for Endian type of the local machine. + + +testbed_emf.c Program used for testing emf functions in libUEMF. Run it like: testbed_emf flags. + Run with no argument to see what the bit flag values are. + It creates a test file "test_libuemf.emf" which should be identical to + test_libuemf_ref.emf. (This file cannot be imported from EMF into PowerPoint + because it contains dotted lines. Use "testbed_emf 1" to generate a file without + any dotted lines. ) + +testbed_pmf.c Program used for testing EMF+ functions in libUEMF. Similar to testbed_emf. + +testbed_wmf.c Program used for testing wmf functions in libUEMF. Similar to testbed_emf. + +test_mapmodes_emf.c + Program used for testing emf functions in libUEMF. Generates one test file + in each MAPMODE, MM_TEXT through MM_ANISOTROPIC, optionally with offsets to the + bounds and with particular Viewport origin. (Bounds offset + Viewport Origin + sets the Window origin.) + +test_mapmodes_wmf.c + Program used for testing wmf functions in libUEMF. Similar to test_mapmodes_emf. + +reademf.c Utility that that reads an EMF file and emits its contents in text form. + Also processes EMF+ files. + Run it like: reademf target_file.emf + +readwmf.c Utility that that reads an WMF file and emits its contents in text form. + Run it like: reademf target_file.wmf + +cutemf.c Utility for removing specific records from an EMF file. + Run it like: cutemf '2,10,12...13' src_file.emf dst_file.emf + +pmfdual2single.c Utility for reducing dual-mode EMF+ file to single mode. Removes all + nonessential EMF records. + Run it like: pmfdual2single dual_mode.emf single_mode.emf + + +test_libuemf_ref.emf + Example output from: testbed_emf 0 +test_libuemf_p_ref.emf + Example output from: testbed_pmf 0 +test_libuemf_ref30.emf + Example output from: testbed_emf 4 +test_libuemf_ref.wmf + Example output from: testbed_wmf 0 + +test_libuemf_ref_emf.txt + Example output from: reademf test_libuemf_ref.emf +test_libuemf_ref_wmf.txt + Example output from: readwmf test_libuemf_ref.wmf + +test_mm_<modes>_ref.emf + Example output from: test_mapmodes_emf -vX 2000 -vY 1000 + +emf-inout.cpp,example +emf-inout.h.example +emf-print.cpp.example +emf-print.h.example + Example code from Inkscape, demonstrates how to integrate libUEMF with another program. + +-------------------------------------------------------------------------------------------- +How to Build: + +In Linux/Unix like environments build and install a shared library and the test and tool +programs: + cd <TOP_DIRECTORY> + #modify the destination in CMakeLists.txt if /usr/local is not acceptable + mkdir build + cd build + make + make install + cd .. + ./testit.sh + rm -rf build + + For simple development work use testbuild.sh to make debug versions without the shared + library. + + (Sparc)[ Solaris 8 and 9 are Big Endian, and to work around some minor incompatibilities with more recent systems, + assuming gcc is installed in /opt/csw and PATH is set correctly to use it] + export CLIBS="-lm -L/opt/csw/lib -liconv" + export CFLAGS="-DSOL8 -DWORDS_BIGENDIAN -std=c99 -pedantic -Wall -g" + + (win32) [This uses _wfopen() instead of fopen(), with filename translation from UTF-8 to + UTF-16LE. This will allow file opens to utilize unicode names. If WIN32 is omitted on Windows + file names must be all ASCII. This works in mingw.] Then compile with: + + export CLIBS="-lm -liconv" + export CFLAGS="-DWIN32 -std=c99 -pedantic -Wall -g" + + gcc $CFLAGS -o cutemf cutemf.c uemf.c uemf_endian.c uemf_utf.c $CLIBS + gcc $CFLAGS -o pmfdual2single pmfdual2single.c uemf.c uemf_endian.c uemf_utf.c upmf.c $CLIBS + gcc $CFLAGS -o reademf reademf.c uemf.c uemf_endian.c uemf_safe.c uemf_print.c uemf_utf.c upmf.c upmf_print.c $CLIBS + gcc $CFLAGS -o readwmf readwmf.c uemf.c uemf_endian.c uemf_safe.c uemf_print.c uemf_utf.c upmf.c upmf_print.c uwmf.c uwmf_endian.c uwmf_print.c $CLIBS + gcc $CFLAGS -o testbed_emf testbed_emf.c uemf.c uemf_endian.c uemf_safe.c uemf_print.c uemf_utf.c upmf.c upmf_print.c $CLIBS + gcc $CFLAGS -o testbed_pmf testbed_pmf.c uemf.c uemf_endian.c uemf_safe.c uemf_utf.c upmf.c $CLIBS + gcc $CFLAGS -o testbed_wmf testbed_wmf.c uemf.c uemf_endian.c uemf_safe.c uemf_print.c uemf_utf.c upmf.c upmf_print.c uwmf.c uwmf_endian.c $CLIBS + gcc $CFLAGS -o test_mapmodes_emf test_mapmodes_emf.c uemf.c uemf_endian.c uemf_safe.c uemf_print.c uemf_utf.c upmf.c upmf_print.c $CLIBS + +Extra debugging on linux may be enabled in testbed for use under Valgrind. To build that way do instead: + + gcc -std=c99 -pedantic -Wall -g -DU_VALGRIND -o testbed_emf testbed_emf.c uemf.c uemf_endian.c uemf_print.c uemf_utf.c -lm + + +and then compile as above for linux. + + +Dependencies: + libiconv (if not built into your compiler) + libpng (in the Inkscape examples) + +-------------------------------------------------------------------------------------------- +Testing + +All modules must also compile without warning under the more restrictive: + + ls -1 *.c \ + | extract -fmt 'gcc -Werror=format-security -Wall -Wformat -Wformat-security -W -Wno-pointer-sign -O2 -c -o deleteme.o [1,]' \ + | execinput + +-------------------------------------------------------------------------------------------- +Using libUEMF: + +To write an EMF file the code first runs two initialization functions: emf_start() and htable_create(). +Then a U_EMRHEADER record is created. This and all subsequent records are appended to the EMF file in +memory with emf_append(). Whichever other EMR records are desired are also added. The last EMR record +added must be the single instance of U_EMREOF. Then the code calls emf_finish(), emf_free(), and +htable_free(). Conversion of byte order on Big Endian machines to Little Endian is carried out +automatically in emf_finish(), if it is required. + +To input an EMF file it is is opened and the data read into a buffer in memory with emf_readdata(). On a +Big Endian machine this will also swap machine dependent byte orders as needed. At that point end user code +generally has to do something with the data in each record. The simplest case is to just print it, as shown +in reademf.c. More typically it must map the operations into its own graphics model, as shown in the +emf32*.*.example files from Inkscape. Basically the processing program needs to enter a loop, processing +one record at a time, pulling the record size and type from the first two uint32_t values present in each +record. It then enters a switch statement with one case for each EMR record type. Each case: statement +will generally define a pointer to that type of data object. Accessing the data from that pointer is +illustrated in the code for the corresponding *_print function. + +While libUEMF implements _print and _swap functions for all supported EMR records, end user code would +never call any of these directly. Instead it should either pass a single EMR record +to U_emf_onerec_print() (see reademf.c) or the entire completed EMF file in memory buffer to U_emf_endian() +(see testbed.c). + +WMF support is similar, except the functions are wmf_start(), wmf_readdata(), and so forth. It is a good +idea to separate end user WMF and EMF generating code into different modules, in order to avoid accidentally +writing EMR records to a WMF file and vice versa. WHile EMF objects are aligned in memory and so may be +accessed using the supplied structs, the ones for WMF files are not usually aligned and so must be accessed +using the supplied *_get functions. (The difference may not be evident on an x86 platform, but on RISC directly +trying to access objects in memory will result in access violations.) + +Things to be aware of in EMF files: + +The usual idea when employing a graphics file type like EMF is to copy a description of the objects in a +drawing from one program to another. Many of the record types in an EMF file can be thought of as objects, +they are lines or shapes or bitmaps or text. However, Microsoft's GDI implements binary and ternary raster +operations (see the descriptions in uemf.h) and most of these operations are not object like, instead they +combine things on the drawing surface. (There is in each case a copy operation which is object like.) +Consequently, EMF files which use these other raster operations are not particularly easy to import as +graphic objects. For instance, when PowerPoint rotates an image and saves it in an EMF the result is not +a single rotated image object. Instead there is an image containing the rotated image, which is followed by +masking operations to make the regions outside of the image transparent. There appears to be no standard +for when and where these subsequent operations will be applied. That is, there is no equivalent of +"begin path" and "end path" to delineate the start and end of such a compound operation. So a program +reading such a file has no easy way of figuring out which previous object is being modified by a subsequent +raster operation. The testbed program provided in this package generates a region which applies all +binary raster operations in vertical slices to two images. The expected result appears in Windows "Preview", +but if that region is imported into PowerPoint and converted to objects within that program the result looks +nothing like what Preview shows. + +Support for U_EMREXTTEXTOUTW is much more common than for U_EMRSMALLTEXT. The latter is easier to use, +since it does not require a Dx array for each text string, but the objects will not import into PowerPoint, +for instance. + +There are two types of dotted/dashed lines. The first uses a set of predefined flags to set the pattern +and the latter is end user user defined. Both are restricted to lines of width 1. These built in types are +problematic as key applications cannot handle them properly. PowerPoint cannot convert either type to its +internal object format. The first form loses the pattern and comes through as solid lines. The second type +is toxic - even a single dotted line of the second type will prevent the entire EMF from being converted. +The safest choice is to avoid these patterned line styles entirely. Convert all dots and dashes to separate +line draws before writing those into the EMF file. libUEMF has no problem reading these records, so code +should accept them for input. + +As with most graphics file formats there is no single object representation of a complex text string (varying +font size, super/sub script, bold, italic,.etc.). Such text must be decomposed into multiple text strings, +each with its own formatting. It is unlikely that a subsequent program reading these records from the EMF +will be able to reassemble them back into a single complex text string. + +If a font used in an EMF file is not present on both the sending and receiving systems text will not look the +same on both. Font substitution is usually silent in most programs, so it may not be evident why the text looks +a little odd. However, if text is simple, that is, consists of just one line of text without size, color, +or other changes, then it will look approximately correct after font substitution. + +Things to be aware of in WMF files: + +WMF graphics are quite limited when compared to EMF graphics. When reading a WMF file it is essential that +end user code always create a specified object, even if that object is just a placeholder with no real +function. If any "create" operation presented by the WMF file is not handled then the object indices used +further along in the WMF file will be off, with very bad results! WMF "regions" are not supported by libUEMF, +however, if an operation creates regions, this type of placeholder must still be created. + +In theory WMF supports mapmodes other than Anisotropic. However, since many programs do not handle +these other modes it is strongly suggested that any WMF files generated use Anisotropic. For this +reason there is no test_mapmodes_wmf program - windows XP preview did not show anything when WMF +files in the other modes were produced. With no positive control there was no way to verify that they +were valid. + +Things to be aware of in EMF+ files: + +EMF+ files are usually stored in files with an ".emf" file extension. In this package EMF+ programs, +functions, and definitions use PMF or PMR to distinguish them from the EMF and WMF material. ("EMF+" +is not an allowed variable or function name in C.) Dual mode EMF+ files contain both EMF and +EMF+ records. HOWEVER, those generated by PowerPoint are defective in that they drop all text +information from the drawing in the EMF+ representation. There is no simple way to line up the +EMF and EMF+ records in their representations to determine which ones correspond to which drawing +object. So it is generally not possible to see which elements are represented in both +representations, or which are missing in one representation. The example file generated by this library +has only EMF+ records plus the few EMF records needed to wrap them. + +Text in EMF+ is placed not from the baseline, as in EMF, but from the upper left corner of the Em square. +Use the utility function U_PMR_drawstring() to draw text onto a baseline. Font +substitutions result in badly placed text because even fonts that look similar on the screen may have +different font metrics. Specifically, font substitutions look worse in EMF+ files than they do +in EMF files. There is no way to embed fonts, or their font information in the EMF+ file. +Consequently the text representation within an EMF+ file is not very portable between systems - it will +only render correctly if the second system has all of the fonts used in the document. The testbed_pmf.c +program contains some metrics for common fonts which may be used with U_PMR_drawstring() +to accurately place text. + + + +-------------------------------------------------------------------------------------------- +History + + (Note, version numbers in files represent the libUEMF release where it was last modified, so not + all files will show the same version numbers in each release.) + +0.2.8 2020-05-13 + Fixed warnings from newer compilers. + Fixed truncation of one string in testbed outputs files, + from 32 to 31 bytes (seen on CentOS 8 with gcc 8.3.1 + but not CentOS 7 with gcc 4.8.5) +0.2.7 2019-10-10 + Added CMakeLists.txt for linux. + Added cmake instructions in README. + Fixed typo in README build instructions. + Error checking added to testit.sh. + Increased max records in cutemf from 10K to 10M. +0.2.6 2019-03-21 + Fixed typo in upmf.c discovered by David Binderman. +0.2.5 2017-01-03 + Fixed a misplaced paren in uemf.h (thanks to Tavmjong Bah for noticing it) + Added more U_SIZE_* definitions in uemf.h for "cores" of record types with final + variable length arrays, such as U_SIZE_EMRNAMEDESCAPE + Removed redundant U_SIZE_BITMAPINFOHEADER definition from uwmf.h +0.2.4 2016-01-26 + Record EXTSELECTCLIPRGN is supposed to be valid when the RgnDataSize is 0 if the RegionMode + is "COPY". Modified safe and print routines so that they would handle this situation. + U_PMR_DrawDriverstring seen for the first time and it crashed reademf. Reason, there was a spurious + "Tension" value in the structure, which offset values in the record. +0.2.3 2015-05-28 + Fixed an assortment of warnings and a couple of bugs flagged by clang static analysis. +0.2.2 2015-04-28 + Added lu_crc32 sums to record information in print statements. Affects only reademf and readwmf. + The point of this exercise is to enable the detection of differences in binary fields + which are not expanded by the print functions. This (re)uses code from Alexander Peslyak. + lu_ in name because crc32 conflicts with other libraries, like png. + Minor changes to some wmf function parameter types. + Minor changes to upmf.c so that it compiles cleanly with clang. + Restrict IS_MEM_UNSAFE 2nd parameter to be int or larger and test for negative values. + Updated the examples from Inkscape. + +0.2.1 2015-04-23 + Bug in safety check on EMREXTCREATEFONTINDIRECTW because it had alternative "standard" record sizes. + Changed warnings on unimplemented EMF record types encounterd in swap or safe from stdout to stderr. + Added memory checking for WMF polyline and polygon records, for the variable part and some others. + Note: U_WMRCREATEREGION_get does not check that the variable part stays within the record. Current + implementation seems to be broken since it does not show up in XP preview. +0.2.0 2015-03-20 + Added UEMF _safe functions to better handle corrupt records, where variable sizes fields might + have been specified to read past the end of memory. These are records with offsets, arrays + with counts, and bitmaps. Also any record which specifies a size smaller than the minimum + for that record type. + Added similar code for EMF+. + These changed the API so the minor version number was bumped by 1. + +0.1.18 2015-01-15 + Pierre-Francois Carpentier sent some EMF examples which used U_EMR_EXTSELECTCLIPRGN, which had + not previously been encountered and showed that the handling of regions was broken. + Added tests for U_EMRFILLRGN, U_EMRFRAMERGN, U_EMRFRAMERGN, U_EMREXTSELECTCLIPRGN to testbed_emf. + +0.1.18 2014-04-28 + Fixed typo in testbed_wmf.c. "include,include" in one place should have been + "exclude,exclude". + +0.1.17 2014-04-25 + Added text clipping tests to testbed_emf.c, testbed_wmf.c, and testbed_pmf.c. + Added option to omit clipping tests in testbed's. + +0.1.16 2014-04-14 + Fixed bug in U_WMRRESTOREDC_set. + Added clipping tests to testbed_wmf.c. + +0.1.15 2014-04-04 + Changed record flags for U_EMRSELECTCLIPPATH record, it consumes a path but does not ALTER (which + forced a premature draw.) + Added U_EMROFFSETCLIPRGN test to testbed_emf.c. + Changed location on dist drawing where clipping appears. + +0.1.14 2014-03-27 + Fixed bug, in U_PMF_RECTN_set() in upmf.c. Never tested. + Fixed a few potential bugs in upmf.c if a null pointer was passed for + certain function arguments. (Previously unhandled cases.) + Fixed bug, operations setting variables that are never read along those + execution paths: upmf_print.c, uemf.c, uwmf.c, uemf_endian.cm upmf.c. + Fixed potential (but very unlikely) memory leaks in upmf.c and uemf_utf.c. + Added test of U_PMF_RECTN_set to testbed_pmf.c. + Changed U_wmr_names() and U_wmr_escnames() to const char* (from char*). + Changed method for suppressing unused parameter warnings. + + +0.1.13 2014-03-21 + Fixed bug, cutemf was messing up the object count (pens, brushes, etc.). + Added cutemf can now take ranges of lines. + Added testbed_emf generates clipping records for rect and path (but not region). + +0.1.12 2014-02-14 + Documentation change, U_WMRCREATEPATTERNBRUSH is obsolete. + Changed wmf_finish() so that it accurately reflects the largest number of objects used, + previously it showed the number of appends, which was much larger. + +0.1.11 2014-01-29 + Fixed bug in uwmf.c (wrong minimum record size on U_WMRTEXTOUT) + Fixed bug in uwmf.c (U_WMRCREATEPATTERNBRUSH not right) + Fixed bug in uwmf_print.c (U_WMRTEXTOUT_print, x,y were reversed) + Added error handling to uemf_utf.c for cases where src is a null pointer. + Added a test of createpatternbrush to testlib_wmf + +0.1.10 2014-01-14 + Slight changes in documentation for uemf.h. + Fixed typo in uemf_endian.c. + Fixed a tiny bug in uemf.c (if memory allocation failed a struct would have + been deleted before the struct itself. + +0.1.9 2013-12-02 + Added U_PMF_DASHEDLINEDATA_set3 (dot/dash pattern from bits in a uint32_t). + Finally was able to make linear gradient gradientfill records work. Updated + testbed_emf.c to include that. + +0.1.8 2013-11-28 + Fixed a bug in U_PMF_REGIONNODEPATH_print(), returned size was 4 too small. + Changed formatting of U_PMF_REGIONNODECHILDNODES_print() output to improve readability + of nested region structures in reademf. + +0.1.7 2013-11-20 + Added EMF+ support. + Converted U_RGA and similar from defines to functions, because the method being used + in the define (from C99) was not exactly compatible with C++ compilation. + Fixed error in test_mapmodes_emf.c where truncation float to integer was used where round + have been, resulting in an off by 1 error on some platforms. + Eliminated PU_W* pointers. + Cleaned up Doxygen comments. + +0.1.6. 2013-04-18 + Added tests which vary background mode, background color, and text color. + Slight modification to testit.sh. + Updated example files. + +0.1.5. 2013-02-13 + Added missing parameter for WMF RESTOREDC_set/get. + Replaced all sizeof() in uwmf.c that referred to UWMF structures with their + U_SIZE_* equivalents. + Added DIB related WMF _get functions. (Which were missing). These are U_BITMAPCOREHEADER_get, + U_BITMAPINFOHEADER_get, wget_dib_params + Added const where appropriate to wmf _get functions. + Added comprehensive cap,join,miter tests to testbeds. + Fixed bug in gradient4_swap(). + Fixed bug in emr_arc_points_common(), used vector where unit vectors were + needed, sometimes flipped direction for arcs/chords. + Fixed bug in U_WMFTEXTOUT_get(). + Changed all dst->Dst and src->Src as call variables in WMF code. + Denigrated htable_*() for emf, these become emf_htable_*(), to match naming convention + used for wmf_table_*(). +0.1.4 2013-02-04 + Added code to handle DIB formats that use clrUsed=0 to mean "maximum number of color entries", + this showed up in several places, including uemf.c and uemf_print.c. + Added some labels to test drawings, slightly rearranged image section, added + PNG and JPG image tests and clrUsed=0 images. + Modified uemf_endian.c to suppress some compiler warnings. + Changed get_DIB_params to return the Compression enumeration. + Fixed a typo in uwmf_print.c. +0.1.3 2013-01-29 Add modes to EMF test programs that changes worldtransform, so + that the resulting test files will exercise rotation transforms. + Added flags indication for testbed programs. + Added test for ROUNDRECT records. Swapped argument orders for those _get/_set operations. +0.1.2 2013-01-25 Fixed bug revealed by newer gcc on Solaris, assignment of aligned 32 bit to unaligned + 16 bit segfaulted. +0.1.1 2013-01-24 Fixed a few compiler warnings under g++, mostly having to do + with signed unsigned comparisons. Eliminated + an unused variable from wmf_finish and two stray lines from U_WMRHEADER_set. + Cleaned up doxygen comments. +0.1.0 2013-01-09 Added WMF functions. + Simplified print functions. Changed output format of reademf slightly, + from U_EMRXXX to U_EMR_XXX - easier to read the new way. +0.0.11 2012-12-04 Moved UTF and related functions out of uemf.c uemf.h and into uemf_utf.c uemf_utf.h. +0.0.10 2012-11-28 Discovered that not enough space was being allocated for some UTF conversions. To be + safe need 4 bytes per glyph + 1 for UTF-8. +0.0.9 2012-09-26 Some "uninitialized variable warnings" for certain versions of + gcc. These were, as far as I could tell, all spurious, but to quiet them + the variables in question were all initialized to 0. + Fixed header related print/swap functions - depending on what type of header there + could be an access violation. + Fixed U_Utf16leToUtf8, could leak memory if the conversion failed. + Fixed sections which were not testing for all types of EMF headers. + Added RGBA_to_RGBA() so that extractions of subsets of bitmaps (offset, different size) + can be handled. + Added cutemf. Utility to remove records from an EMF file. + Added test_mapmodes. Program to generate test files in each MAPMODE. + Added test_mm_(mode)_ref.emf files. These are reference for: + test_mapmodes -vX 2000 -vY 1000 + +0.0.8 2012-09-10 Fixed bug in htable_insert, failed to celear newly added table + slots. Fixed test for EMR_GRADIENTFILL triangle mode (rectangle still produces toxic EMF files.) + Fixed bug in gradientfill_swap on Solaris. + +0.0.7 2012-08-30 Added/fixed tests for hatched, DIB, and mono strokes. + Corrected error in U_EMREXTCREATEPEN_set. + +0.0.6 2012-08-21 Added/fixed tests for hatched, DIB, and mono fills. + +0.0.5 2012-08-08 Minor changes to uemf.c to suppress compiler warnings. Fixed + one bug in SET_CB_FROM_PXBMI macro (which was not triggered in testbed + because all images were the same size). + +0.0.4 2012-07-25 More tests in testbed.c. Found and fixed bugs in + U_POLYPOLYLINE and U_POLYPOLYGON related code. + +0.0.3 2012-07-24 Warnings related to printing size_t on 64 bit Linux. Correct + fix is to use "zd", but gcc -std=c99 does not support that on Solaris 9, + the only available big endian system. So use cast or the size_t to (int) + and stick with %d format specifier. This should be OK as the sizes involved + should not be all that large. + + Bug in core9 affecting U_EMRARC_swap(), and related, on Big Endian. + +0.0.2 2012-07-12 first release + |