This commit was manufactured by cvs2svn to create tag 'LIBPNG_1_0_3'.

git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/tags/LIBPNG_1_0_3@14990 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775

src/png/.cvsignore

@@ -0,0 +1,2 @@
+pngM*Data
+pngM5.mcp

src/png/ANNOUNCE

@@ -0,0 +1,53 @@
+
+Libpng 1.0.3 - January 14, 1999
+
+This is a public release of libpng, intended for use in production codes.
+
+Changes since the previous public release (1.0.2):
+
+libpng-1.0.3:
+
+  Replaced and extended code that was removed from png_set_filler() in 1.0.1a.
+  Fixed a bug in png_do_filler() that made it fail to write filler bytes in
+    the left-most pixel of each row (Kevin Bracey).
+  Changed "static pngcharp tIME_string" to "static char tIME_string[30]"
+    in pngtest.c (Duncan Simpson).
+  Fixed a bug in pngtest.c that caused pngtest to try to write a tIME chunk
+    even when no tIME chunk was present in the source file.
+  Fixed a problem in pngrutil.c: gray_to_rgb didn't always work with 16-bit.
+  Fixed a problem in png_read_push_finish_row(), which would not skip some
+    passes that it should skip, for images that are less than 3 pixels high.
+  Interchanged the order of calls to png_do_swap() and png_do_shift()
+    in pngwtran.c (John Cromer).
+  Added #ifdef PNG_DEBUG/#endif surrounding use of PNG_DEBUG in png.h .
+  Changed "bad adaptive filter type" from error to warning in pngrutil.c .
+  Fixed a documentation error about default filtering with 8-bit indexed-color.
+  Separated the PNG_NO_STDIO macro into PNG_NO_STDIO and PNG_NO_CONSOLE_IO
+    (L. Peter Deutsch).
+  Added png_set_rgb_to_gray() and png_get_rgb_to_gray_status() functions.
+  Added png_get_copyright() and png_get_header_version() functions.
+  Revised comments on png_set_progressive_read_fn() in libpng.txt and example.c
+  Added information about debugging in libpng.txt and libpng.3 .
+  Changed "ln -sf" to "ln -s -f" in makefile.s2x, makefile.lnx, and makefile.sco.
+  Removed lines after Dynamic Dependencies" in makefile.aco .
+  Revised makefile.dec to make a shared library (Jeremie Petit).
+  Removed trailing blanks from all files. 
+  Removed misplaced #endif and #ifdef PNG_NO_EXTERN near the end of png.h
+  Added "if" tests to silence complaints about unused png_ptr in png.h and png.c
+  Changed "check_if_png" function in example.c to return true (nonzero) if PNG.
+  Changed libpng.txt to demonstrate png_sig_cmp() instead of png_check_sig()
+    which is obsolete.
+  Added makefile.hux, for Hewlett Packard HPUX 10.20 and 11.00 (Jim Rice)
+  Added a statement of Y2K compliance in png.h, libpng.1, and Y2KINFO.
+
+Send comments/corrections/commendations to
+png-implement@dworkin.wustl.edu or to randeg@alumni.rpi.edu
+
+Glenn R-P
+
+Send comments/corrections/commendations to
+png-implement@dworkin.wustl.edu or to randeg@alumni.rpi.edu
+
+Glenn Randers-Pehrson
+libpng maintainer
+PNG Development Group

src/png/CHANGES

@@ -0,0 +1,389 @@
+CHANGES - changes for libpng
+
+version 0.2
+  added reader into png.h
+  fixed small problems in stub file
+version 0.3
+  added pull reader
+  split up pngwrite.c to several files
+  added pnglib.txt
+  added example.c
+  cleaned up writer, adding a few new tranformations
+  fixed some bugs in writer
+  interfaced with zlib 0.5
+  added K&R support
+  added check for 64 KB blocks for 16 bit machines
+version 0.4
+  cleaned up code and commented code
+  simplified time handling into png_time
+  created png_color_16 and png_color_8 to handle color needs
+  cleaned up color type defines
+  fixed various bugs
+  made various names more consistant
+  interfaced with zlib 0.71
+  cleaned up zTXt reader and writer (using zlib's Reset functions)
+  split transformations into pngrtran.c and pngwtran.c
+version 0.5
+  interfaced with zlib 0.8
+  fixed many reading and writing bugs
+  saved using 3 spaces instead of tabs
+version 0.6
+  added png_large_malloc() and png_large_free()
+  added png_size_t
+  cleaned up some compiler warnings
+  added png_start_read_image()
+version 0.7
+  cleaned up lots of bugs
+  finished dithering and other stuff
+  added test program
+  changed name from pnglib to libpng
+version 0.71 [June, 1995]
+  changed pngtest.png for zlib 0.93
+  fixed error in libpng.txt and example.c
+version 0.8
+  cleaned up some bugs
+  added png_set_filler()
+  split up pngstub.c into pngmem.c, pngio.c, and pngerror.c
+  added #define's to remove unwanted code
+  moved png_info_init() to png.c
+  added old_size into png_realloc()
+  added functions to manually set filtering and compression info
+  changed compression parameters based on image type
+  optimized filter selection code
+  added version info
+  changed external functions passing floats to doubles (k&r problems?)
+  put all the configurable stuff in pngconf.h
+  enabled png_set_shift to work with paletted images on read
+  added png_read_update_info() - updates info structure with
+     transformations
+version 0.81 [August, 1995]
+  incorporated Tim Wegner's medium model code (thanks, Tim)
+version 0.82 [September, 1995]
+  [unspecified changes]
+version 0.85 [December, 1995]
+  added more medium model code (almost everything's a far)
+  added i/o, error, and memory callback functions
+  fixed some bugs (16 bit, 4 bit interlaced, etc.)
+  added first run progressive reader (barely tested)
+version 0.86 [January, 1996]
+  fixed bugs
+  improved documentation
+version 0.87 [January, 1996]
+  fixed medium model bugs
+  fixed other bugs introduced in 0.85 and 0.86
+  added some minor documentation
+version 0.88 [January, 1996]
+  fixed progressive bugs
+  replaced tabs with spaces
+  cleaned up documentation
+  added callbacks for read/write and warning/error functions
+version 0.89 [July, 1996]
+  added new initialization API to make libpng work better with shared libs
+     we now have png_create_read_struct(), png_create_write_struct(),
+     png_create_info_struct(), png_destroy_read_struct(), and
+     png_destroy_write_struct() instead of the separate calls to
+     malloc and png_read_init(), png_info_init(), and png_write_init()
+  changed warning/error callback functions to fix bug - this means you
+     should use the new initialization API if you were using the old
+     png_set_message_fn() calls, and that the old API no longer exists
+     so that people are aware that they need to change their code
+  changed filter selection API to allow selection of multiple filters
+     since it didn't work in previous versions of libpng anyways
+  optimized filter selection code
+  fixed png_set_background() to allow using an arbitrary RGB color for
+     paletted images
+  fixed gamma and background correction for paletted images, so
+     png_correct_palette is not needed unless you are correcting an
+     external palette (you will need to #define PNG_CORRECT_PALETTE_SUPPORTED
+     in pngconf.h) - if nobody uses this, it may disappear in the future.
+  fixed bug with Borland 64K memory allocation (Alexander Lehmann)
+  fixed bug in interlace handling (Smarasderagd, I think)
+  added more error checking for writing and image to reduce invalid files
+  separated read and write functions so that they won't both be linked
+     into a binary when only reading or writing functionality is used
+  new pngtest image also has interlacing and zTXt
+  updated documentation to reflect new API
+version 0.90 [January, 1997]
+  made CRC errors/warnings on critical and ancillary chunks configurable
+  libpng will use the zlib CRC routines by (compile-time) default
+  changed DOS small/medium model memory support - needs zlib 1.04 (Tim Wegner)
+  added external C++ wrapper statements to png.h (Gilles Dauphin)
+  allow PNG file to be read when some or all of file signature has already
+     been read from the beginning of the stream.  ****This affects the size
+     of info_struct and invalidates all programs that use a shared libpng****
+  fixed png_filler() declarations
+  fixed? background color conversions
+  fixed order of error function pointers to match documentation
+  current chunk name is now available in png_struct to reduce the number
+     of nearly identical error messages (will simplify multi-lingual
+     support when available)
+  try to get ready for unknown-chunk callback functions:
+     - previously read critical chunks are flagged, so the chunk handling
+       routines can determine if the chunk is in the right place
+     - all chunk handling routines have the same prototypes, so we will
+       be able to handle all chunks via a callback mechanism
+  try to fix Linux "setjmp" buffer size problems
+version 0.95 [March, 1997]
+  fixed bug in pngwutil.c allocating "up_row" twice and "avg_row" never
+  fixed bug in PNG file signature compares when start != 0
+  changed parameter type of png_set_filler(...filler...) from png_byte
+     to png_uint_32
+  added test for MACOS to ensure that both math.h and fp.h are not #included
+  added macros for libpng to be compiled as a Windows DLL (Andreas Kupries)
+  added "packswap" transformation, which changes the endianness of
+     packed-pixel bytes (Kevin Bracey)
+  added "strip_alpha" transformation, which removes the alpha channel of
+     input images without using it (not neccesarily a good idea)
+  added "swap_alpha" transformation, which puts the alpha channel in front
+     of the color bytes instead of after
+  removed all implicit variable tests which assume NULL == 0 (I think)
+  changed several variables to "png_size_t" to show 16/32-bit limitations
+  added new pCAL chunk read/write support
+  added experimental filter selection weighting (Greg Roelofs)
+  removed old png_set_rgbx() and png_set_xrgb() functions that have been
+     obsolete for about 2 years now (use png_set_filler() instead)
+  added macros to read 16- and 32-bit ints directly from buffer, to be
+     used only on those systems that support it (namely PowerPC and 680x0)
+     With some testing, this may become the default for MACOS/PPC systems.
+  only calculate CRC on data if we are going to use it
+  added macros for zTXt compression type PNG_zTXt_COMPRESSION_???
+  added macros for simple libpng debugging output selectable at compile time
+  removed PNG_READ_END_MODE in progressive reader (Smarasderagd)
+  more description of info_struct in libpng.txt and png.h
+  more instructions in example.c
+  more chunk types tested in pngtest.c
+  renamed pngrcb.c to pngset.c, and all png_read_<chunk> functions to be
+     png_set_<chunk>.  We now have corresponding png_get_<chunk>
+     functions in pngget.c to get infomation in info_ptr.  This isolates
+     the application from the internal organization of png_info_struct
+     (good for shared library implementations).
+version 0.96 [May, 1997]
+  fixed serious bug with < 8bpp images introduced in 0.95
+  fixed 256-color transparency bug (Greg Roelofs)
+  fixed up documentation (Greg Roelofs, Laszlo Nyul)
+  fixed "error" in pngconf.h for Linux setjmp() behaviour
+  fixed DOS medium model support (Tim Wegner)
+  fixed png_check_keyword() for case with error in static string text
+  added read of CRC after IEND chunk for embedded PNGs (Laszlo Nyul)
+  added typecasts to quiet compiler errors
+  added more debugging info
+version 0.97 [January, 1998]
+  removed PNG_USE_OWN_CRC capability
+  relocated png_set_crc_action from pngrutil.c to pngrtran.c
+  fixed typecasts of "new_key", etc. (Andreas Dilger)
+  added RFC 1152 [sic] date support
+  fixed bug in gamma handling of 4-bit grayscale
+  added 2-bit grayscale gamma handling (Glenn R-P)
+  added more typecasts. 65536L becomes (png_uint_32)65536L, etc. (Glenn R-P)
+  minor corrections in libpng.txt
+  added simple sRGB support (Glenn R-P)
+  easier conditional compiling, e.g. define PNG_READ/WRITE_NOT_FULLY_SUPPORTED;
+     all configurable options can be selected from command-line instead
+     of having to edit pngconf.h (Glenn R-P)
+  fixed memory leak in pngwrite.c (free info_ptr->text) (Glenn R-P)
+  added more conditions for png_do_background, to avoid changing
+     black pixels to background when a background is supplied and
+     no pixels are transparent
+  repaired PNG_NO_STDIO behaviour
+  tested NODIV support and made it default behaviour (Greg Roelofs)
+  added "-m" option and PNGTEST_DEBUG_MEMORY to pngtest (John Bowler)
+  regularized version numbering scheme and bumped shared-library major
+     version number to 2 to avoid problems with libpng 0.89 apps (Greg Roelofs)
+version 0.98 [January, 1998]
+  cleaned up some typos in libpng.txt and in code documentation
+  fixed memory leaks in pCAL chunk processing (Glenn R-P and John Bowler)
+  cosmetic change "display_gamma" to "screen_gamma" in pngrtran.c
+  changed recommendation about file_gamma for PC images to .51 from .45,
+     in example.c and libpng.txt, added comments to distinguish between
+     screen_gamma, viewing_gamma, and display_gamma.
+  changed all references to RFC1152 to read RFC1123 and changed the
+     PNG_TIME_RFC1152_SUPPORTED macro to PNG_TIME_RFC1123_SUPPORTED
+  added png_invert_alpha capability (Glenn R-P -- suggestion by Jon Vincent)
+  changed srgb_intent from png_byte to int to avoid compiler bugs
+version 0.99 [January 30, 1998]
+  free info_ptr->text instead of end_info_ptr->text in pngread.c (John Bowler)
+  fixed a longstanding "packswap" bug in pngtrans.c
+  fixed some inconsistencies in pngconf.h that prevented compiling with
+     PNG_READ_GAMMA_SUPPORTED and PNG_READ_hIST_SUPPORTED undefined
+  fixed some typos and made other minor rearrangement of libpng.txt (Andreas)
+  changed recommendation about file_gamma for PC images to .50 from .51 in
+     example.c and libpng.txt, and changed file_gamma for sRGB images to .45
+  added a number of functions to access information from the png structure
+     png_get_image_height(), etc. (Glenn R-P, suggestion by Brad Pettit)
+  added TARGET_MACOS similar to zlib-1.0.8
+  define PNG_ALWAYS_EXTERN when __MWERKS__ && WIN32 are defined
+  added type casting to all png_malloc() function calls
+version 0.99a [January 31, 1998]
+  Added type casts and parentheses to all returns that return a value.(Tim W.)
+version 0.99b [February 4, 1998]
+  Added type cast png_uint_32 on malloc function calls where needed.
+  Changed type of num_hist from png_uint_32 to int (same as num_palette).
+  Added checks for rowbytes overflow, in case png_size_t is less than 32 bits.
+  Renamed makefile.elf to makefile.lnx.
+version 0.99c [February 7, 1998]
+  More type casting.  Removed erroneous overflow test in pngmem.c.
+  Added png_buffered_memcpy() and png_buffered_memset(), apply them to rowbytes.
+  Added UNIX manual pages libpng.3 (incorporating libpng.txt) and  png.5.
+version 0.99d [February 11, 1998]
+  Renamed "far_to_near()" "png_far_to_near()"
+  Revised libpng.3
+  Version 99c "buffered" operations didn't work as intended.  Replaced them
+    with png_memcpy_check() and png_memset_check().
+  Added many "if (png_ptr == NULL) return" to quell compiler warnings about
+    unused png_ptr, mostly in pngget.c and pngset.c.
+  Check for overlength tRNS chunk present when indexed-color PLTE is read.
+  Cleaned up spelling errors in libpng.3/libpng.txt
+  Corrected a problem with png_get_tRNS() which returned undefined trans array
+version 0.99e [February 28, 1998]
+  Corrected png_get_tRNS() again.
+  Add parentheses for easier reading of pngget.c, fixed "||" should be "&&".
+  Touched up example.c to make more of it compileable, although the entire
+    file still can't be compiled (Willem van Schaik)
+  Fixed a bug in png_do_shift() (Bryan Tsai)
+  Added a space in png.h prototype for png_write_chunk_start()
+  Replaced pngtest.png with one created with zlib 1.1.1
+  Changed pngtest to report PASS even when file size is different (Jean-loup G.)
+  Corrected some logic errors in png_do_invert_alpha() (Chris Patterson)
+version 0.99f [March 5, 1998]
+  Corrected a bug in pngpread() introduced in version 99c (Kevin Bracey)
+  Moved makefiles into a "scripts" directory, and added INSTALL instruction file
+  Added makefile.os2 and pngos2.def (A. Zabolotny) and makefile.s2x (W. Sebok)
+  Added pointers to "note on libpng versions" in makefile.lnx and README
+  Added row callback feature when reading and writing nonprogressive rows
+     and added a test of this feature in pngtest.c
+  Added user transform callbacks, with test of the feature in pngtest.c
+version 0.99g [March 6, 1998, morning]
+  Minor changes to pngtest.c to suppress compiler warnings.
+  Removed "beta" language from documentation.
+version 0.99h [March 6, 1998, evening]
+  Minor changes to previous minor changes to pngtest.c
+  Changed PNG_READ_NOT_FULLY_SUPPORTED to PNG_READ_TRANSFORMS_NOT_SUPPORTED
+  and added PNG_PROGRESSIVE_READ_NOT_SUPPORTED macro
+version 1.00 [March 7, 1998]
+  Changed several typedefs in pngrutil.c
+  Added makefile.wat (Pawel Mrochen), updated makefile.tc3 (Willem van Schaik)
+  replaced "while(1)" with "for(;;)"
+  added PNGARG() to prototypes in pngtest.c and removed some prototypes
+  updated some of the makefiles (Tom Lane)
+  changed some typedefs (s_start, etc.) in pngrutil.c
+  fixed dimensions of "short_months" array in pngwrite.c
+  Replaced ansi2knr.c with the one from jpeg-v6
+version 1.0.0 [March 8, 1998]
+  Changed name from 1.00 to 1.0.0 (Adam Costello)
+  Added smakefile.ppc (with SCOPTIONS.ppc) for Amiga PPC (Andreas Kleinert)
+version 1.0.0a [March 9, 1998]
+  Fixed three bugs in pngrtran.c to make gamma+background handling consistent
+  (Greg Roelofs)
+  Changed format of the PNG_LIBPNG_VER integer to xyyzz instead of xyz
+  for major, minor, and bugfix releases.  This is 10001. (Adam Costello,
+  Tom Lane)
+  Make months range from 1-12 in png_convert_to_rfc1123
+version 1.0.0b [March 13, 1998]
+  Quieted compiler complaints about two empty "for" loops in pngrutil.c
+  Minor changes to makefile.s2x
+  Removed #ifdef/#endif around a png_free() in pngread.c
+version 1.0.1 [March 14, 1998]
+  Changed makefile.s2x to reduce security risk of using a relative pathname
+  Fixed some typos in the documentation (Greg).
+  Fixed a problem with value of "channels" returned by png_read_update_info()
+version 1.0.1a [April 21, 1998]
+  Optimized Paeth calculations by replacing abs() function calls with intrinsics
+  plus other loop optimizations. Improves avg decoding speed by about 20%.
+  Commented out i386istic "align" compiler flags in makefile.lnx.
+  Reduced the default warning level in some makefiles, to make them consistent.
+  Removed references to IJG and JPEG in the ansi2knr.c copyright statement.
+  Fixed a bug in png_do_strip_filler with XXRRGGBB => RRGGBB transformation.
+  Added grayscale and 16-bit capability to png_do_read_filler().
+  Fixed a bug in pngset.c, introduced in version 0.99c, that sets rowbytes
+    too large when writing an image with bit_depth < 8 (Bob Dellaca).
+  Corrected some bugs in the experimental weighted filtering heuristics.
+  Moved a misplaced pngrutil code block that truncates tRNS if it has more
+    than num_palette entries -- test was done before num_palette was defined.
+  Fixed a png_convert_to_rfc1123() bug that converts day 31 to 0 (Steve Eddins).
+  Changed compiler flags in makefile.wat for better optimization (Pawel Mrochen).
+version 1.0.1b [May 2, 1998]
+  Relocated png_do_gray_to_rgb() within png_do_read_transformations() (Greg).
+  Relocated the png_composite macros from pngrtran.c to png.h (Greg).
+  Added makefile.sco (contributed by Mike Hopkirk).
+  Fixed two bugs (missing definitions of "istop") introduced in libpng-1.0.1a.
+  Fixed a bug in pngrtran.c that would set channels=5 under some circumstances.
+  More work on the Paeth-filtering, achieving imperceptible speedup (A Kleinert).
+  More work on loop optimization which may help when compiled with C++ compilers.
+  Added warnings when people try to use transforms they've defined out.
+  Collapsed 4 "i" and "c" loops into single "i" loops in pngrtran and pngwtran.
+  Revised paragraph about png_set_expand() in libpng.txt and libpng.3 (Greg)
+version 1.0.1c [May 11, 1998]
+  Fixed a bug in pngrtran.c (introduced in libpng-1.0.1a) where the masks for
+    filler bytes should have been 0xff instead of 0xf.
+  Added max_pixel_depth=32 in pngrutil.c when using FILLER with palette images.
+  Moved PNG_WRITE_WEIGHTED_FILTER_SUPPORTED and PNG_WRITE_FLUSH_SUPPORTED
+    out of the PNG_WRITE_TRANSFORMS_NOT_SUPPORTED block of pngconf.h
+  Added "PNG_NO_WRITE_TRANSFORMS" etc., as alternatives for *_NOT_SUPPORTED,
+    for consistency, in pngconf.h
+  Added individual "ifndef PNG_NO_[CAPABILITY]" in pngconf.h to make it easier
+    to remove unwanted capabilities via the compile line
+  Made some corrections to grammar (which, it's) in documentation (Greg).
+  Corrected example.c, use of row_pointers in png_write_image().
+version 1.0.1d [May 24, 1998]
+  Corrected several statements that used side effects illegally in pngrutil.c
+    and pngtrans.c, that were introduced in version 1.0.1b
+  Revised png_read_rows() to avoid repeated if-testing for NULL (A Kleinert)
+  More corrections to example.c, use of row_pointers in png_write_image()
+    and png_read_rows().
+  Added pngdll.mak and pngdef.pas to scripts directory, contributed by
+    Bob Dellaca, to make a png32bd.dll with Borland C++ 4.5
+  Fixed error in example.c with png_set_text: num_text is 3, not 2 (Guido V.)
+  Changed several loops from count-down to count-up, for consistency.
+version 1.0.1e [June 6, 1998]
+  Revised libpng.txt and libpng.3 description of png_set_read|write_fn(), and
+    added warnings when people try to set png_read_fn and png_write_fn in
+    the same structure.
+  Added a test such that png_do_gamma will be done when num_trans==0
+    for truecolor images that have defined a background.  This corrects an
+    error that was introduced in libpng-0.90 that can cause gamma processing
+    to be skipped.
+  Added tests in png.h to include "trans" and "trans_values" in structures
+    when PNG_READ_BACKGROUND_SUPPORTED or PNG_READ_EXPAND_SUPPORTED is defined.
+  Add png_free(png_ptr->time_buffer) in png_destroy_read_struct()
+  Moved png_convert_to_rfc_1123() from pngwrite.c to png.c
+  Added capability for user-provided malloc_fn() and free_fn() functions,
+    and revised pngtest.c to demonstrate their use, replacing the
+    PNGTEST_DEBUG_MEM feature.
+  Added makefile.w32, for Microsoft C++ 4.0 and later (Tim Wegner).
+version 1.0.2 [June 14, 1998]
+  Fixed two bugs in makefile.bor .
+version 1.0.2a [December 30, 1998]
+  Replaced and extended code that was removed from png_set_filler() in 1.0.1a.
+  Fixed a bug in png_do_filler() that made it fail to write filler bytes in
+    the left-most pixel of each row (Kevin Bracey).
+  Changed "static pngcharp tIME_string" to "static char tIME_string[30]"
+    in pngtest.c (Duncan Simpson).
+  Fixed a bug in pngtest.c that caused pngtest to try to write a tIME chunk
+    even when no tIME chunk was present in the source file.
+  Fixed a problem in pngrutil.c: gray_to_rgb didn't always work with 16-bit.
+  Fixed a problem in png_read_push_finish_row(), which would not skip some
+    passes that it should skip, for images that are less than 3 pixels high.
+  Interchanged the order of calls to png_do_swap() and png_do_shift()
+    in pngwtran.c (John Cromer).
+  Added #ifdef PNG_DEBUG/#endif surrounding use of PNG_DEBUG in png.h .
+  Changed "bad adaptive filter type" from error to warning in pngrutil.c .
+  Fixed a documentation error about default filtering with 8-bit indexed-color.
+  Separated the PNG_NO_STDIO macro into PNG_NO_STDIO and PNG_NO_CONSOLE_IO
+    (L. Peter Deutsch).
+  Added png_set_rgb_to_gray() and png_get_rgb_to_gray_status() functions.
+  Added png_get_copyright() and png_get_header_version() functions.
+  Revised comments on png_set_progressive_read_fn() in libpng.txt and example.c
+  Added information about debugging in libpng.txt and libpng.3 .
+  Changed "ln -sf" to "ln -s -f" in makefile.s2x, makefile.lnx, and makefile.sco.
+  Removed lines after Dynamic Dependencies" in makefile.aco .
+  Revised makefile.dec to make a shared library (Jeremie Petit).
+  Removed trailing blanks from all files. 
+version 1.0.2a [January 6, 1999]
+  Removed misplaced #endif and #ifdef PNG_NO_EXTERN near the end of png.h
+  Added "if" tests to silence complaints about unused png_ptr in png.h and png.c
+  Changed "check_if_png" function in example.c to return true (nonzero) if PNG.
+  Changed libpng.txt to demonstrate png_sig_cmp() instead of png_check_sig()
+    which is obsolete.
+version 1.0.3 [January 14, 1999]
+  Added makefile.hux, for Hewlett Packard HPUX 10.20 and 11.00 (Jim Rice)
+  Added a statement of Y2K compliance in png.h, libpng.1, and Y2KINFO.

src/png/INSTALL

@@ -0,0 +1,91 @@
+
+Installing libpng version 1.0.3 - January 14, 1999
+
+Before installing libpng, you must first install zlib.  zlib
+can usually be found wherever you got libpng.  zlib can be
+placed in another directory, at the same level as libpng.
+Note that your system might already have a preinstalled
+zlib, but you will still need to have access to the
+zlib.h and zconf.h include files that correspond to the
+version of zlib that's installed.
+
+You can rename the directories that you downloaded (they
+might be called "libpng-1.0.3" or "lpng103" and "zlib-1.1.3"
+or "zlib113") so that you have directories called "zlib" and "libpng".
+
+Your directory structure should look like this:
+
+   ..       (the parent directory)
+      libpng  (this directory)
+          INSTALL (this file)
+          README
+          *.h
+          *.c
+          scripts
+             makefile.*
+          pngtest.png
+          etc.
+      zlib
+          README
+          *.h
+          *.c
+          contrib
+          etc.
+
+First enter the zlib directory and follow the instructions
+in zlib/README.  Then come back here and choose the
+appropriate makefile.sys in the scripts directory.
+The files that are presently available in the scripts directory
+include
+
+      descrip.mms   =>  VMS makefile for MMS or MMK
+      makefile.std  =>  Generic UNIX makefile
+      makefile.knr  =>  Archaic UNIX Makefile that converts files with ansi2knr
+      makefile.dec  =>  DEC Alpha UNIX makefile
+      makefile.hux  =>  HPUX (10.20 and 11.00) makefile
+      makefile.sgi  =>  Silicon Graphics IRIX makefile
+      makefile.sun  =>  Sun makefile
+      makefile.s2x  =>  Solaris 2.X makefile (gcc, creates libpng.so.2.1.0)
+      makefile.lnx  =>  Linux/ELF makefile (gcc, creates libpng.so.2.1.0)
+      makefile.mip  =>  MIPS makefile
+      makefile.aco  =>  Acorn makefile
+      makefile.ama  =>  Amiga makefile
+      smakefile.ppc =>  AMIGA smakefile for SAS C V6.58/7.00 PPC compiler
+                        (Requires SCOPTIONS, copied from scripts/SCOPTIONS.ppc)
+      makefile.atr  =>  Atari makefile
+      makefile.bor  =>  Borland makefile
+      build.bat     =>  MS-DOS batch file for Borland compiler
+      makefile.dj2  =>  DJGPP 2 makefile
+      makefile.msc  =>  Microsoft C makefile
+      makefile.w32  =>  makefile for Microsoft Visual C++ 4.0 and later
+      makefile.tc3  =>  Turbo C 3.0 makefile
+      makefile.os2  =>  OS/2 Makefile (gcc and emx, requires pngos2.def)
+      pngos2.def    =>  OS/2 module definition file used by makefile.os2
+      makefile.wat  =>  Watcom 10a+ Makefile, 32-bit flat memory model
+      makevms.com   =>  VMS build script
+      pngdll.mak    =>  To make a png32bd.dll with Borland C++ 4.5
+      pngdef.pas    =>  Defines for a png32bd.dll with Borland C++ 4.5
+
+Copy the file (or files) that you need from the
+scripts directory into this directory, for example
+
+   MSDOS example: copy scripts\makefile.msd makefile
+   UNIX example:    cp scripts/makefile.std makefile
+
+Read the makefile to see if you need to change any source or
+target directories to match your preferences.
+
+Then read pngconf.h to see if you want to make any configuration
+changes.
+
+Then just run "make test" which will create the libpng library in
+this directory and run a quick test that reads the "pngtest.png"
+file and writes a "pngout.png" file that should be identical to it.
+
+Most of the makefiles will allow you to run "make install" to
+put the library in its final resting place (if you want to
+do that, run "make install" in the zlib directory first if necessary).
+
+Further information can be found in the README and libpng.txt
+files, in the individual makefiles, and in png.h, and the manual
+pages libpng.3 and png.5.

src/png/MAKEFILE.VA

@@ -0,0 +1,138 @@
+#
+# File:      makefile.vc
+# Author:    David Webster
+# Created:   1999
+# Updated:
+# Copyright: c) 1993, AIAI, University of Edinburgh
+#
+# "%W% %G%"
+#
+# Makefile : Builds os2png.lib library for OS/2 3.0/4.0
+
+# Suffixes
+OBJSUFF=obj
+SRCSUFF=cpp
+
+OS2FLAGS=/c /W2 /DOS232 /D__VISAGECPP__ /Ss /Q /N100
+OS2LINKFLAGS=/BASE:0x00010000 /PMTYPE:PM /NOE /NOD /ALIGN:16
+OS2LIBFLAGS=/NOL /NOE
+OS2LIBS=CPPOM30.lib CPPOOC3.LIB OS2386.LIB
+
+!if "$(WXMAKINGDLL)" != "0"
+EXTRADLLFLAGS=/DWXMAKINGDLL=1 /Ge- /D__OS2DLL__
+EXTRALNKFLAGS=/DLL
+!endif
+
+# Change WXDIR or WXWIN to wherever wxWindows is found
+WXDIR = $(WXWIN)
+
+OS2PNGDIR=$(WXDIR)\src\png
+OS2PNGINC=$(WINPNGDIR)
+OS2PNGLIB=$(WXDIR)\lib\os2png.lib
+!if "$(WXMAKINGDLL)" != "1"
+OS2PNGLIB=$(WXDIR)\lib\os2png.lib
+!else
+OS2PNGLIB=$(WXDIR)\lib\os2png.dll
+!endif
+INC=-I$(WXDIR)\src\zlib -I$(OS2PNGINC)
+
+!ifndef FINAL
+FINAL=0
+!endif
+
+!if "$(NOPCH)" == "1"
+PCH=
+PRECOMP=
+MAKEPRECOMP=
+!else
+PCH=$(WXLIBNAME).pch
+PRECOMP=/Si$(PCH)
+MAKEPRECOMP=/Fi$(PCH)
+!endif
+
+!if "$(FINAL)" == "0"
+!if "$(WXMAKINGDLL)" == "1"
+D=DebugOS2DLL
+!else
+D=DebugOS2
+!endif
+OPT =
+DEBUG_FLAGS= /Ti /D__WXDEBUG__ #/Fb
+LINK_DEBUG_FLAGS=/DEBUG
+CRTFLAG=/Gm /Gd
+!else
+# /O1 - smallest code
+# /O2 - fastest code
+!if "$(WXMAKINGDLL)" == "1"
+D=RelseOS2DLL
+!else
+D=RelseOS2
+!endif
+OPT = /O+ /Oc /G5
+DEBUG_FLAGS=
+LINK_DEBUG_FLAGS=/RELEASE
+CRTFLAG=/Gm /Gd
+!endif
+
+!if [md $(OS2PNGDIR)\$D]
+!endif
+
+CPPFLAGS=$(OS2FLAGS) $(EXTRADLLFLAGS) $(DEBUG_FLAGS) $(PRECOMP) $(INC) $(OPT) $(CRTFLAG)
+LINKFKAGS=$(OS2LINKFLAGS) $(EXTRALNKFLAGS)
+LIBS=..\\..\\lib\os2zlibd.lib
+
+{..\png}.c{..\png\$D}.obj:
+    @echo $<
+    icc @<<
+$(CPPFLAGS) /Fo$@ /Tp $<
+<<
+
+OBJECTS = \
+  ..\png\$D\png.obj \
+  ..\png\$D\pngread.obj \
+  ..\png\$D\pngrtran.obj \
+  ..\png\$D\pngrutil.obj \
+  ..\png\$D\pngpread.obj \
+  ..\png\$D\pngtrans.obj \
+  ..\png\$D\pngwrite.obj \
+  ..\png\$D\pngwtran.obj \
+  ..\png\$D\pngwutil.obj \
+  ..\png\$D\pngerror.obj \
+  ..\png\$D\pngmem.obj \
+  ..\png\$D\pngwio.obj \
+  ..\png\$D\pngrio.obj \
+  ..\png\$D\pngget.obj \
+  ..\png\$D\pngset.obj
+
+all:  $(OS2PNGLIB)
+
+!if "$(WXMAKINGDLL)" != "1"
+
+$(WXDIR)\lib\os2png.lib: $(OBJECTS)
+ touch $(WXDIR)\lib\os2png.lib
+ del $(WXDIR)\lib\os2png.lib
+ ilib $(OS2LIBFLAGS) $@ @<<
+    $**;
+<<
+
+!else
+
+# Update the dynamic link library
+$(WXDIR)\lib\os2png.dll: $(OBJECTS)
+    icc @<<
+    /B" $(LINKFLAGS)" /Fe$@
+    $(LIBS)
+    $(OBJECTS)
+    $(WXDIR)\src\os2\os2png.def
+<<
+    implib $(WXDIR)\lib\os2pngd.lib $(WXDIR)\src\os2\os2png.def
+
+!endif
+
+clean:
+        del      $(OS2PNGLIB)
+        erase /N $(OS2PNGDIR)\$D
+        rd       $(OS2PNGDIR)\$D
+
+cleanall:     clean
+

src/png/README

@@ -0,0 +1,198 @@
+README for libpng 1.0.3 - January 14, 1999 (shared library 2.1)
+See the note about version numbers near the top of png.h
+
+See INSTALL for instructions on how to install libpng.
+
+This is the first official release of libpng.  Don't let the fact that
+it's the first release fool you.  The libpng library has been in
+extensive use and testing for about two and a half years.  However, it's
+finally gotten to the stage where there haven't been significant
+changes to the API in some time, and people have a bad feeling about
+libraries with versions < 1.0.
+
+****
+Note that some of the changes to the png_info structure render this
+version of the library binary incompatible with libpng-0.89 or
+earlier versions if you are using a shared library.  The type of the
+"filler" parameter for png_set_filler() has changed from png_byte to
+png_uint_32, which will affect shared-library applications that use
+this function.
+
+To avoid problems with changes to the internals of png_info_struct,
+new APIs have been made available in 0.95 to avoid direct application
+access to info_ptr.  These functions are the png_set_<chunk> and
+png_get_<chunk> functions.  These functions should be used when
+accessing/storing the info_struct data, rather than manipulating it
+directly, to avoid such problems in the future.
+
+It is important to note that the APIs do not make current programs
+that access the info struct directly incompatible with the new
+library.  However, it is strongly suggested that new programs use
+the new APIs (as shown in example.c), and older programs be converted
+to the new format, to facilitate upgrades in the future.
+****
+
+Additions since 0.90 include the ability to compile libpng as a
+Windows DLL, and new APIs for accessing data in the info struct.
+Experimental functions include the ability to set weighting and cost
+factors for row filter selection, direct reads of integers from buffers
+on big-endian processors that support misaligned data access, faster
+methods of doing alpha composition, and more accurate 16->8 bit color
+conversion.
+
+The additions since 0.89 include the ability to read from a PNG stream
+which has had some (or all) of the signature bytes read by the calling
+application.  This also allows the reading of embedded PNG streams that
+do not have the PNG file signature.  As well, it is now possible to set
+the library action on the detection of chunk CRC errors.  It is possible
+to set different actions based on whether the CRC error occurred in a
+critical or an ancillary chunk.
+
+The changes made to the library, and bugs fixed are based on discussions
+on the PNG implementation mailing list <png-implement@dworking.wustl.edu>
+and not on material submitted to Guy.
+
+For a detailed description on using libpng, read libpng.txt.  For
+examples of libpng in a program, see example.c and pngtest.c.  For usage
+information and restrictions (what little they are) on libpng, see
+png.h.  For a description on using zlib (the compression library used by
+libpng) and zlib's restrictions, see zlib.h
+
+I have included a general makefile, as well as several machine and
+compiler specific ones, but you may have to modify one for your own needs.
+
+You should use zlib 1.0.4 or later to run this, but it MAY work with
+versions as old as zlib 0.95.  Even so, there are bugs in older zlib
+versions which can cause the output of invalid compression streams for
+some images.  You will definitely need zlib 1.0.4 or later if you are
+taking advantage of the MS-DOS "far" structure allocation for the small
+and medium memory models.  You should also note that zlib is a
+compression library that is useful for more things than just PNG files.
+You can use zlib as a drop-in replacement for fread() and fwrite() if
+you are so inclined.
+
+zlib should be available at the same place that libpng is.
+If not, it should be at ftp.uu.net in /graphics/png
+Eventually, it will be at ftp.uu.net in /pub/archiving/zip/zlib
+
+You may also want a copy of the PNG specification.  It is available
+as an RFC and a W3C Recommendation.  Failing
+these resources you can try ftp.uu.net in the /graphics/png directory.
+
+This code is currently being archived at ftp.uu.net in the
+/graphics/png directory, and on CompuServe, Lib 20 (PNG SUPPORT)
+at GO GRAPHSUP.  If you can't find it in any of those places,
+e-mail me, and I'll help you find it.
+
+If you have any code changes, requests, problems, etc., please e-mail
+them to me.  Also, I'd appreciate any make files or project files,
+and any modifications you needed to make to get libpng to compile,
+along with a #define variable to tell what compiler/system you are on.
+If you needed to add transformations to libpng, or wish libpng would
+provide the image in a different way, drop me a note (and code, if
+possible), so I can consider supporting the transformation.
+Finally, if you get any warning messages when compiling libpng
+(note: not zlib), and they are easy to fix, I'd appreciate the
+fix.  Please mention "libpng" somewhere in the subject line.  Thanks.
+
+This release was created and will be supported by myself (of course
+based in a large way on Guy's and Andreas' earlier work), and the PNG group.
+
+randeg@alumni.rpi.edu
+png-implement@dworkin.wustl.edu
+
+You can't reach Guy, the original libpng author, at the addresses
+given in previous versions of this document.  He and Andreas will read mail
+addressed to the png-implement list, however.
+
+Please do not send general questions about PNG.  Send them to
+the address in the specification (png-group@w3.org).  At the same
+time, please do not send libpng questions to that address, send them to me
+or to png-implement@dworkin.wustl.edu.  I'll
+get them in the end anyway.  If you have a question about something
+in the PNG specification that is related to using libpng, send it
+to me.  Send me any questions that start with "I was using libpng,
+and ...".  If in doubt, send questions to me.  I'll bounce them
+to others, if necessary.
+
+Please do not send suggestions on how to change PNG.  We have
+been discussing PNG for three years now, and it is official and
+finished.  If you have suggestions for libpng, however, I'll
+gladly listen.  Even if your suggestion is not used for version
+1.0, it may be used later.
+
+Files in this distribution:
+
+      CHANGES       =>  Description of changes between libpng versions
+      README        =>  This file
+      TODO          =>  Things not implemented in the current library
+      ansi2knr.1    =>  Manual page for ansi2knr
+      ansi2knr.c    =>  Converts files to K&R style function declarations
+      build.bat     =>  MS-DOS batch file for Borland compiler
+      descrip.mms   =>  VMS project file
+      example.c     =>  Example code for using libpng functions
+      libpng.3      =>  manual page for libpng
+      libpng.txt    =>  Description of libpng and its functions
+      libpngpf.3    =>  manual page for libpng's private functions
+      png.5         =>  manual page for the PNG format
+      png.c         =>  Basic interface functions common to library
+      png.h         =>  Library function and interface declarations
+      pngconf.h     =>  System specific library configuration
+      pngerror.c    =>  Error/warning message I/O functions
+      pngget.c      =>  Functions for retrieving info from struct
+      pngmem.c      =>  Memory handling functions
+      pngpread.c    =>  Progressive reading functions
+      pngread.c     =>  Read data/helper high-level functions
+      pngrio.c      =>  Lowest-level data read I/O functions
+      pngrtran.c    =>  Read data transformation functions
+      pngrutil.c    =>  Read data utility functions
+      pngset.c      =>  Functions for storing data into the info_struct
+      pngtest.c     =>  Library test program
+      pngtest.png   =>  Library test sample image
+      pngtrans.c    =>  Common data transformation functions
+      pngwio.c      =>  Lowest-level write I/O functions
+      pngwrite.c    =>  High-level write functions
+      pngwtran.c    =>  Write data transformations
+      pngwutil.c    =>  Write utility functions
+      scripts       =>  Directory containing scripts for building libpng:
+        descrip.mms   =>  VMS makefile for MMS or MMK
+        makefile.std  =>  Generic UNIX makefile
+        makefile.knr  =>  Archaic UNIX Makefile that converts files with ansi2knr
+        makefile.dec  =>  DEC Alpha UNIX makefile
+        makefile.hux  =>  HPUX (10.20 and 11.00) makefile
+        makefile.sgi  =>  Silicon Graphics IRIX makefile
+        makefile.sun  =>  Sun makefile
+        makefile.s2x  =>  Solaris 2.X makefile (gcc, creates libpng.so.2.1.0)
+        makefile.lnx  =>  Linux/ELF makefile (gcc, creates libpng.so.2.1.0)
+        makefile.mip  =>  MIPS makefile
+        makefile.aco  =>  Acorn makefile
+        makefile.ama  =>  Amiga makefile
+        smakefile.ppc =>  AMIGA smakefile for SAS C V6.58/7.00 PPC compiler
+                          (Requires SCOPTIONS, copied from scripts/SCOPTIONS.ppc)
+        makefile.atr  =>  Atari makefile
+        makefile.bor  =>  Borland makefile
+        build.bat     =>  MS-DOS batch file for Borland compiler
+        makefile.dj2  =>  DJGPP 2 makefile
+        makefile.msc  =>  Microsoft C makefile
+        makefile.w32  =>  makefile for Microsoft Visual C++ 4.0 and later
+        makefile.tc3  =>  Turbo C 3.0 makefile
+        makefile.os2  =>  OS/2 Makefile (gcc and emx, requires pngos2.def)
+        makefile.wat  =>  Watcom 10a+ Makefile, 32-bit flat memory model
+        pngos2.def    =>  OS/2 module definition file used by makefile.os2
+        makevms.com   =>  VMS build script
+        pngdll.mak    =>  To make a png32bd.dll with Borland C++ 4.5
+        pngdef.pas    =>  Defines for a png32bd.dll with Borland C++ 4.5
+
+Good luck, and happy coding.
+
+-Glenn Randers-Pehrson
+ Internet: randeg@alumni.rpi.edu
+ Web: http://www.rpi.edu/~randeg/index.html
+
+-Andreas Eric Dilger
+ Internet: adilger@enel.ucalgary.ca
+ Web: http://www-mddsp.enel.ucalgary.ca/People/adilger/
+
+-Guy Eric Schalnat
+ (formerly of Group 42, Inc)
+ Internet: gschal@infinet.com

src/png/TODO

@@ -0,0 +1,24 @@
+TODO - list of things to do for libpng:
+
+Final bug fixes.
+Fix problem with C++ and EXTERN "C".
+Better C++ wrapper/full C++ implementation?
+Keep up with public chunks.
+sPLT chunk handling.
+cHRM transformation.
+Support for application-defined chunk handlers.
+Improve setjmp/longjmp usage or remove it in favor of returning error codes.
+High-level API for reading images.
+Add "grayscale->palette" transformation and "palette->grayscale" detection.
+Color to gray transformation.
+Improved dithering.
+Multi-lingual error and warning message support.
+Complete sRGB transformation (presently it simply uses gamma=0.45455).
+Man pages for function calls.
+Better documentation.
+Better filter selection
+   (counting huffman bits/precompression?  filter inertia?  filter costs?).
+Optional palette (sPLT) creation.
+Histogram creation.
+Text conversion between different code pages (Latin-1 -> Mac and DOS).
+Improve API by hiding the info_ptr.

src/png/Y2KINFO

@@ -0,0 +1,52 @@
+   Y2K compliance in libpng:
+   =========================
+      
+      January 13, 1999
+      
+      Since the PNG Development group is an ad-hoc body, we can't make
+      an official declaration.
+      
+      This is your unofficial assurance that libpng from version 0.81 and
+      upward are Y2K compliant.  It is my belief that earlier versions were
+      also Y2K compliant.
+      
+      Libpng only has three year fields.  One is a 2-byte unsigned integer
+      that will hold years up to 65535.  The other two hold the date in text
+      format, and will hold years up to 9999.
+      
+      The integer is
+          "png_uint_16 year" in png_time_struct.
+      
+      The strings are
+          "png_charp time_buffer" in png_struct and
+          "near_time_buffer", which is a local character string in png.c.
+      
+      There are seven time-related functions:
+
+          png_convert_to_rfc_1123() in png.c 
+            (formerly png_convert_to_rfc_1152() in error)
+          png_convert_from_struct_tm() in pngwrite.c, called in pngwrite.c
+          png_convert_from_time_t() in pngwrite.c
+          png_get_tIME() in pngget.c
+          png_handle_tIME() in pngrutil.c, called in pngread.c
+          png_set_tIME() in pngset.c
+          png_write_tIME() in pngwutil.c, called in pngwrite.c
+      
+      All appear to handle dates properly in a Y2K environment.  The 
+      png_convert_from_time_t() function calls gmtime() to convert from system
+      clock time, which returns (year - 1900), which we properly convert to
+      the full 4-digit year.  There is a possibility that applications using
+      libpng are not passing 4-digit years into the png_convert_to_rfc_1123()
+      function, or incorrectly passing only a 2-digit year instead of
+      "year - 1900" into the png_convert_from_struct_tm() function, but this
+      is not under our control.  The libpng documentation has always stated
+      that it works with 4-digit years, and the APIs have been documented as
+      such.
+      
+      The tIME chunk itself is also Y2K compliant.  It uses a 2-byte unsigned
+      integer to hold the year, and can hold years as large as 65535.
+      
+      
+         Glenn Randers-Pehrson
+         libpng maintainer
+         PNG Development Group

src/png/ansi2knr.1

@@ -0,0 +1,36 @@
+.TH ANSI2KNR 1 "19 Jan 1996"
+.SH NAME
+ansi2knr \- convert ANSI C to Kernighan & Ritchie C
+.SH SYNOPSIS
+.I ansi2knr
+[--varargs] input_file [output_file]
+.SH DESCRIPTION
+If no output_file is supplied, output goes to stdout.
+.br
+There are no error messages.
+.sp
+.I ansi2knr
+recognizes function definitions by seeing a non-keyword identifier at the left
+margin, followed by a left parenthesis, with a right parenthesis as the last
+character on the line, and with a left brace as the first token on the
+following line (ignoring possible intervening comments).  It will recognize a
+multi-line header provided that no intervening line ends with a left or right
+brace or a semicolon.  These algorithms ignore whitespace and comments, except
+that the function name must be the first thing on the line.
+.sp
+The following constructs will confuse it:
+.br
+     - Any other construct that starts at the left margin and follows the
+above syntax (such as a macro or function call).
+.br
+     - Some macros that tinker with the syntax of the function header.
+.sp
+The --varargs switch is obsolete, and is recognized only for
+backwards compatibility.  The present version of
+.I ansi2knr
+will always attempt to convert a ... argument to va_alist and va_dcl.
+.SH AUTHOR
+L. Peter Deutsch <ghost@aladdin.com> wrote the original ansi2knr and
+continues to maintain the current version; most of the code in the current
+version is his work.  ansi2knr also includes contributions by Francois
+Pinard <pinard@iro.umontreal.ca> and Jim Avera <jima@netcom.com>.

src/png/ansi2knr.c

@@ -0,0 +1,695 @@
+/* ansi2knr.c */
+
+/* Convert ANSI C function definitions to K&R ("traditional C") syntax
+Copyright (C) 1989 Aladdin Enterprises.  All rights reserved.
+Copyright (C) 1988 Richard M. Stallman
+
+ansi2knr is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY.  No author or distributor accepts responsibility to anyone for the
+consequences of using it or for whether it serves any particular purpose or
+works at all, unless he says so in writing.  Refer to the GNU General Public
+License (the "GPL") for full details.
+
+Everyone is granted permission to copy, modify and redistribute ansi2knr,
+but only under the conditions described in the GPL.  A copy of this license
+is supposed to have been given to you along with ansi2knr so you can know
+your rights and responsibilities.  It should be in a file named COPYLEFT.
+[In the LIBPNG distribution, the GPL appears below, not in a separate file.]
+Among other things, the copyright notice and this notice must be preserved
+on all copies.
+
+We explicitly state here what we believe is already implied by the GPL: if
+the ansi2knr program is distributed as a separate source file and a
+separate executable file which are aggregated on a storage medium together
+with another program, this in itself does not bring the other program under
+the GPL, nor does the mere fact that such a program or the procedures for
+constructing it invoke the ansi2knr executable bring any other part of the
+program under the GPL.
+*/
+
+/*
+---------- Here is the GNU GPL file COPYLEFT, referred to above ----------
+----- These terms do NOT apply to the LIBPNG software itself; see README ------
+
+		    GHOSTSCRIPT GENERAL PUBLIC LICENSE
+		    (Clarified 11 Feb 1988)
+
+ Copyright (C) 1988 Richard M. Stallman
+ Everyone is permitted to copy and distribute verbatim copies of this
+ license, but changing it is not allowed.  You can also use this wording
+ to make the terms for other programs.
+
+  The license agreements of most software companies keep you at the
+mercy of those companies.  By contrast, our general public license is
+intended to give everyone the right to share Ghostscript.  To make sure
+that you get the rights we want you to have, we need to make
+restrictions that forbid anyone to deny you these rights or to ask you
+to surrender the rights.  Hence this license agreement.
+
+  Specifically, we want to make sure that you have the right to give
+away copies of Ghostscript, that you receive source code or else can get
+it if you want it, that you can change Ghostscript or use pieces of it
+in new free programs, and that you know you can do these things.
+
+  To make sure that everyone has such rights, we have to forbid you to
+deprive anyone else of these rights.  For example, if you distribute
+copies of Ghostscript, you must give the recipients all the rights that
+you have.  You must make sure that they, too, receive or can get the
+source code.  And you must tell them their rights.
+
+  Also, for our own protection, we must make certain that everyone finds
+out that there is no warranty for Ghostscript.  If Ghostscript is
+modified by someone else and passed on, we want its recipients to know
+that what they have is not what we distributed, so that any problems
+introduced by others will not reflect on our reputation.
+
+  Therefore we (Richard M. Stallman and the Free Software Foundation,
+Inc.) make the following terms which say what you must do to be allowed
+to distribute or change Ghostscript.
+
+
+			COPYING POLICIES
+
+  1. You may copy and distribute verbatim copies of Ghostscript source
+code as you receive it, in any medium, provided that you conspicuously
+and appropriately publish on each copy a valid copyright and license
+notice "Copyright (C) 1989 Aladdin Enterprises.  All rights reserved.
+Distributed by Free Software Foundation, Inc." (or with whatever year is
+appropriate); keep intact the notices on all files that refer to this
+License Agreement and to the absence of any warranty; and give any other
+recipients of the Ghostscript program a copy of this License Agreement
+along with the program.  You may charge a distribution fee for the
+physical act of transferring a copy.
+
+  2. You may modify your copy or copies of Ghostscript or any portion of
+it, and copy and distribute such modifications under the terms of
+Paragraph 1 above, provided that you also do the following:
+
+    a) cause the modified files to carry prominent notices stating
+    that you changed the files and the date of any change; and
+
+    b) cause the whole of any work that you distribute or publish,
+    that in whole or in part contains or is a derivative of Ghostscript
+    or any part thereof, to be licensed at no charge to all third
+    parties on terms identical to those contained in this License
+    Agreement (except that you may choose to grant more extensive
+    warranty protection to some or all third parties, at your option).
+
+    c) You may charge a distribution fee for the physical act of
+    transferring a copy, and you may at your option offer warranty
+    protection in exchange for a fee.
+
+Mere aggregation of another unrelated program with this program (or its
+derivative) on a volume of a storage or distribution medium does not bring
+the other program under the scope of these terms.
+
+  3. You may copy and distribute Ghostscript (or a portion or derivative
+of it, under Paragraph 2) in object code or executable form under the
+terms of Paragraphs 1 and 2 above provided that you also do one of the
+following:
+
+    a) accompany it with the complete corresponding machine-readable
+    source code, which must be distributed under the terms of
+    Paragraphs 1 and 2 above; or,
+
+    b) accompany it with a written offer, valid for at least three
+    years, to give any third party free (except for a nominal
+    shipping charge) a complete machine-readable copy of the
+    corresponding source code, to be distributed under the terms of
+    Paragraphs 1 and 2 above; or,
+
+    c) accompany it with the information you received as to where the
+    corresponding source code may be obtained.  (This alternative is
+    allowed only for noncommercial distribution and only if you
+    received the program in object code or executable form alone.)
+
+For an executable file, complete source code means all the source code for
+all modules it contains; but, as a special exception, it need not include
+source code for modules which are standard libraries that accompany the
+operating system on which the executable file runs.
+
+  4. You may not copy, sublicense, distribute or transfer Ghostscript
+except as expressly provided under this License Agreement.  Any attempt
+otherwise to copy, sublicense, distribute or transfer Ghostscript is
+void and your rights to use the program under this License agreement
+shall be automatically terminated.  However, parties who have received
+computer software programs from you with this License Agreement will not
+have their licenses terminated so long as such parties remain in full
+compliance.
+
+  5. If you wish to incorporate parts of Ghostscript into other free
+programs whose distribution conditions are different, write to the Free
+Software Foundation at 675 Mass Ave, Cambridge, MA 02139.  We have not
+yet worked out a simple rule that can be stated here, but we will often
+permit this.  We will be guided by the two goals of preserving the free
+status of all derivatives of our free software and of promoting the
+sharing and reuse of software.
+
+Your comments and suggestions about our licensing policies and our
+software are welcome!  Please contact the Free Software Foundation,
+Inc., 675 Mass Ave, Cambridge, MA 02139, or call (617) 876-3296.
+
+		       NO WARRANTY
+
+  BECAUSE GHOSTSCRIPT IS LICENSED FREE OF CHARGE, WE PROVIDE ABSOLUTELY
+NO WARRANTY, TO THE EXTENT PERMITTED BY APPLICABLE STATE LAW.  EXCEPT
+WHEN OTHERWISE STATED IN WRITING, FREE SOFTWARE FOUNDATION, INC, RICHARD
+M. STALLMAN, ALADDIN ENTERPRISES, L. PETER DEUTSCH, AND/OR OTHER PARTIES
+PROVIDE GHOSTSCRIPT "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER
+EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE
+ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF GHOSTSCRIPT IS WITH
+YOU.  SHOULD GHOSTSCRIPT PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL
+NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW WILL RICHARD M.
+STALLMAN, THE FREE SOFTWARE FOUNDATION, INC., L. PETER DEUTSCH, ALADDIN
+ENTERPRISES, AND/OR ANY OTHER PARTY WHO MAY MODIFY AND REDISTRIBUTE
+GHOSTSCRIPT AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING
+ANY LOST PROFITS, LOST MONIES, OR OTHER SPECIAL, INCIDENTAL OR
+CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE
+(INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED
+INACCURATE OR LOSSES SUSTAINED BY THIRD PARTIES OR A FAILURE OF THE
+PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS) GHOSTSCRIPT, EVEN IF YOU
+HAVE BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES, OR FOR ANY CLAIM
+BY ANY OTHER PARTY.
+
+-------------------- End of file COPYLEFT ------------------------------
+*/
+
+/*
+ * Usage:
+	ansi2knr input_file [output_file]
+ * If no output_file is supplied, output goes to stdout.
+ * There are no error messages.
+ *
+ * ansi2knr recognizes function definitions by seeing a non-keyword
+ * identifier at the left margin, followed by a left parenthesis,
+ * with a right parenthesis as the last character on the line,
+ * and with a left brace as the first token on the following line
+ * (ignoring possible intervening comments).
+ * It will recognize a multi-line header provided that no intervening
+ * line ends with a left or right brace or a semicolon.
+ * These algorithms ignore whitespace and comments, except that
+ * the function name must be the first thing on the line.
+ * The following constructs will confuse it:
+ *	- Any other construct that starts at the left margin and
+ *	    follows the above syntax (such as a macro or function call).
+ *	- Some macros that tinker with the syntax of the function header.
+ */
+
+/*
+ * The original and principal author of ansi2knr is L. Peter Deutsch
+ * <ghost@aladdin.com>.  Other authors are noted in the change history
+ * that follows (in reverse chronological order):
+	lpd 96-01-21 added code to cope with not HAVE_CONFIG_H and with
+		compilers that don't understand void, as suggested by
+		Tom Lane
+	lpd 96-01-15 changed to require that the first non-comment token
+		on the line following a function header be a left brace,
+		to reduce sensitivity to macros, as suggested by Tom Lane
+		<tgl@sss.pgh.pa.us>
+	lpd 95-06-22 removed #ifndefs whose sole purpose was to define
+		undefined preprocessor symbols as 0; changed all #ifdefs
+		for configuration symbols to #ifs
+	lpd 95-04-05 changed copyright notice to make it clear that
+		including ansi2knr in a program does not bring the entire
+		program under the GPL
+	lpd 94-12-18 added conditionals for systems where ctype macros
+		don't handle 8-bit characters properly, suggested by
+		Francois Pinard <pinard@iro.umontreal.ca>;
+		removed --varargs switch (this is now the default)
+	lpd 94-10-10 removed CONFIG_BROKETS conditional
+	lpd 94-07-16 added some conditionals to help GNU `configure',
+		suggested by Francois Pinard <pinard@iro.umontreal.ca>;
+		properly erase prototype args in function parameters,
+		contributed by Jim Avera <jima@netcom.com>;
+		correct error in writeblanks (it shouldn't erase EOLs)
+	lpd 89-xx-xx original version
+ */
+
+/* Most of the conditionals here are to make ansi2knr work with */
+/* or without the GNU configure machinery. */
+
+#if HAVE_CONFIG_H
+# include <config.h>
+#endif
+
+#include <stdio.h>
+#include <ctype.h>
+
+#if HAVE_CONFIG_H
+
+/*
+   For properly autoconfiguring ansi2knr, use AC_CONFIG_HEADER(config.h).
+   This will define HAVE_CONFIG_H and so, activate the following lines.
+ */
+
+# if STDC_HEADERS || HAVE_STRING_H
+#  include <string.h>
+# else
+#  include <strings.h>
+# endif
+
+#else /* not HAVE_CONFIG_H */
+
+/* Otherwise do it the hard way */
+
+# ifdef BSD
+#  include <strings.h>
+# else
+#  ifdef VMS
+    extern int strlen(), strncmp();
+#  else
+#   include <string.h>
+#  endif
+# endif
+
+#endif /* not HAVE_CONFIG_H */
+
+#if STDC_HEADERS
+# include <stdlib.h>
+#else
+/*
+   malloc and free should be declared in stdlib.h,
+   but if you've got a K&R compiler, they probably aren't.
+ */
+# ifdef MSDOS
+#  include <malloc.h>
+# else
+#  ifdef VMS
+     extern char *malloc();
+     extern void free();
+#  else
+     extern char *malloc();
+     extern int free();
+#  endif
+# endif
+
+#endif
+
+/*
+ * The ctype macros don't always handle 8-bit characters correctly.
+ * Compensate for this here.
+ */
+#ifdef isascii
+#  undef HAVE_ISASCII		/* just in case */
+#  define HAVE_ISASCII 1
+#else
+#endif
+#if STDC_HEADERS || !HAVE_ISASCII
+#  define is_ascii(c) 1
+#else
+#  define is_ascii(c) isascii(c)
+#endif
+
+#define is_space(c) (is_ascii(c) && isspace(c))
+#define is_alpha(c) (is_ascii(c) && isalpha(c))
+#define is_alnum(c) (is_ascii(c) && isalnum(c))
+
+/* Scanning macros */
+#define isidchar(ch) (is_alnum(ch) || (ch) == '_')
+#define isidfirstchar(ch) (is_alpha(ch) || (ch) == '_')
+
+/* Forward references */
+char *skipspace();
+int writeblanks();
+int test1();
+int convert1();
+
+/* The main program */
+int
+main(argc, argv)
+    int argc;
+    char *argv[];
+{	FILE *in, *out;
+#define bufsize 5000			/* arbitrary size */
+	char *buf;
+	char *line;
+	char *more;
+	/*
+	 * In previous versions, ansi2knr recognized a --varargs switch.
+	 * If this switch was supplied, ansi2knr would attempt to convert
+	 * a ... argument to va_alist and va_dcl; if this switch was not
+	 * supplied, ansi2knr would simply drop any such arguments.
+	 * Now, ansi2knr always does this conversion, and we only
+	 * check for this switch for backward compatibility.
+	 */
+	int convert_varargs = 1;
+
+	if ( argc > 1 && argv[1][0] == '-' )
+	  {	if ( !strcmp(argv[1], "--varargs") )
+		  {	convert_varargs = 1;
+			argc--;
+			argv++;
+		  }
+		else
+		  {	fprintf(stderr, "Unrecognized switch: %s\n", argv[1]);
+			exit(1);
+		  }
+	  }
+	switch ( argc )
+	   {
+	default:
+		printf("Usage: ansi2knr input_file [output_file]\n");
+		exit(0);
+	case 2:
+		out = stdout;
+		break;
+	case 3:
+		out = fopen(argv[2], "w");
+		if ( out == NULL )
+		   {	fprintf(stderr, "Cannot open output file %s\n", argv[2]);
+			exit(1);
+		   }
+	   }
+	in = fopen(argv[1], "r");
+	if ( in == NULL )
+	   {	fprintf(stderr, "Cannot open input file %s\n", argv[1]);
+		exit(1);
+	   }
+	fprintf(out, "#line 1 \"%s\"\n", argv[1]);
+	buf = malloc(bufsize);
+	line = buf;
+	while ( fgets(line, (unsigned)(buf + bufsize - line), in) != NULL )
+	   {
+test:		line += strlen(line);
+		switch ( test1(buf) )
+		   {
+		case 2:			/* a function header */
+			convert1(buf, out, 1, convert_varargs);
+			break;
+		case 1:			/* a function */
+			/* Check for a { at the start of the next line. */
+			more = ++line;
+f:			if ( line >= buf + (bufsize - 1) ) /* overflow check */
+			  goto wl;
+			if ( fgets(line, (unsigned)(buf + bufsize - line), in) == NULL )
+			  goto wl;
+			switch ( *skipspace(more, 1) )
+			  {
+			  case '{':
+			    /* Definitely a function header. */
+			    convert1(buf, out, 0, convert_varargs);
+			    fputs(more, out);
+			    break;
+			  case 0:
+			    /* The next line was blank or a comment: */
+			    /* keep scanning for a non-comment. */
+			    line += strlen(line);
+			    goto f;
+			  default:
+			    /* buf isn't a function header, but */
+			    /* more might be. */
+			    fputs(buf, out);
+			    strcpy(buf, more);
+			    line = buf;
+			    goto test;
+			  }
+			break;
+		case -1:		/* maybe the start of a function */
+			if ( line != buf + (bufsize - 1) ) /* overflow check */
+			  continue;
+			/* falls through */
+		default:		/* not a function */
+wl:			fputs(buf, out);
+			break;
+		   }
+		line = buf;
+	   }
+	if ( line != buf )
+	  fputs(buf, out);
+	free(buf);
+	fclose(out);
+	fclose(in);
+	return 0;
+}
+
+/* Skip over space and comments, in either direction. */
+char *
+skipspace(p, dir)
+    register char *p;
+    register int dir;			/* 1 for forward, -1 for backward */
+{	for ( ; ; )
+	   {	while ( is_space(*p) )
+		  p += dir;
+		if ( !(*p == '/' && p[dir] == '*') )
+		  break;
+		p += dir;  p += dir;
+		while ( !(*p == '*' && p[dir] == '/') )
+		   {	if ( *p == 0 )
+			  return p;	/* multi-line comment?? */
+			p += dir;
+		   }
+		p += dir;  p += dir;
+	   }
+	return p;
+}
+
+/*
+ * Write blanks over part of a string.
+ * Don't overwrite end-of-line characters.
+ */
+int
+writeblanks(start, end)
+    char *start;
+    char *end;
+{	char *p;
+	for ( p = start; p < end; p++ )
+	  if ( *p != '\r' && *p != '\n' )
+	    *p = ' ';
+	return 0;
+}
+
+/*
+ * Test whether the string in buf is a function definition.
+ * The string may contain and/or end with a newline.
+ * Return as follows:
+ *	0 - definitely not a function definition;
+ *	1 - definitely a function definition;
+ *	2 - definitely a function prototype (NOT USED);
+ *	-1 - may be the beginning of a function definition,
+ *		append another line and look again.
+ * The reason we don't attempt to convert function prototypes is that
+ * Ghostscript's declaration-generating macros look too much like
+ * prototypes, and confuse the algorithms.
+ */
+int
+test1(buf)
+    char *buf;
+{	register char *p = buf;
+	char *bend;
+	char *endfn;
+	int contin;
+
+	if ( !isidfirstchar(*p) )
+	  return 0;		/* no name at left margin */
+	bend = skipspace(buf + strlen(buf) - 1, -1);
+	switch ( *bend )
+	   {
+	   case ';': contin = 0 /*2*/; break;
+	   case ')': contin = 1; break;
+	   case '{': return 0;		/* not a function */
+	   case '}': return 0;		/* not a function */
+	   default: contin = -1;
+	   }
+	while ( isidchar(*p) )
+	  p++;
+	endfn = p;
+	p = skipspace(p, 1);
+	if ( *p++ != '(' )
+	  return 0;		/* not a function */
+	p = skipspace(p, 1);
+	if ( *p == ')' )
+	  return 0;		/* no parameters */
+	/* Check that the apparent function name isn't a keyword. */
+	/* We only need to check for keywords that could be followed */
+	/* by a left parenthesis (which, unfortunately, is most of them). */
+	   {	static char *words[] =
+		   {	"asm", "auto", "case", "char", "const", "double",
+			"extern", "float", "for", "if", "int", "long",
+			"register", "return", "short", "signed", "sizeof",
+			"static", "switch", "typedef", "unsigned",
+			"void", "volatile", "while", 0
+		   };
+		char **key = words;
+		char *kp;
+		int len = endfn - buf;
+
+		while ( (kp = *key) != 0 )
+		   {	if ( strlen(kp) == len && !strncmp(kp, buf, len) )
+			  return 0;	/* name is a keyword */
+			key++;
+		   }
+	   }
+	return contin;
+}
+
+/* Convert a recognized function definition or header to K&R syntax. */
+int
+convert1(buf, out, header, convert_varargs)
+    char *buf;
+    FILE *out;
+    int header;			/* Boolean */
+    int convert_varargs;	/* Boolean */
+{	char *endfn;
+	register char *p;
+	char **breaks;
+	unsigned num_breaks = 2;	/* for testing */
+	char **btop;
+	char **bp;
+	char **ap;
+	char *vararg = 0;
+
+	/* Pre-ANSI implementations don't agree on whether strchr */
+	/* is called strchr or index, so we open-code it here. */
+	for ( endfn = buf; *(endfn++) != '('; )
+	  ;
+top:	p = endfn;
+	breaks = (char **)malloc(sizeof(char *) * num_breaks * 2);
+	if ( breaks == 0 )
+	   {	/* Couldn't allocate break table, give up */
+		fprintf(stderr, "Unable to allocate break table!\n");
+		fputs(buf, out);
+		return -1;
+	   }
+	btop = breaks + num_breaks * 2 - 2;
+	bp = breaks;
+	/* Parse the argument list */
+	do
+	   {	int level = 0;
+		char *lp = NULL;
+		char *rp;
+		char *end = NULL;
+
+		if ( bp >= btop )
+		   {	/* Filled up break table. */
+			/* Allocate a bigger one and start over. */
+			free((char *)breaks);
+			num_breaks <<= 1;
+			goto top;
+		   }
+		*bp++ = p;
+		/* Find the end of the argument */
+		for ( ; end == NULL; p++ )
+		   {	switch(*p)
+			   {
+			   case ',':
+				if ( !level ) end = p;
+				break;
+			   case '(':
+				if ( !level ) lp = p;
+				level++;
+				break;
+			   case ')':
+				if ( --level < 0 ) end = p;
+				else rp = p;
+				break;
+			   case '/':
+				p = skipspace(p, 1) - 1;
+				break;
+			   default:
+				;
+			   }
+		   }
+		/* Erase any embedded prototype parameters. */
+		if ( lp )
+		  writeblanks(lp + 1, rp);
+		p--;			/* back up over terminator */
+		/* Find the name being declared. */
+		/* This is complicated because of procedure and */
+		/* array modifiers. */
+		for ( ; ; )
+		   {	p = skipspace(p - 1, -1);
+			switch ( *p )
+			   {
+			   case ']':	/* skip array dimension(s) */
+			   case ')':	/* skip procedure args OR name */
+			   {	int level = 1;
+				while ( level )
+				 switch ( *--p )
+				   {
+				   case ']': case ')': level++; break;
+				   case '[': case '(': level--; break;
+				   case '/': p = skipspace(p, -1) + 1; break;
+				   default: ;
+				   }
+			   }
+				if ( *p == '(' && *skipspace(p + 1, 1) == '*' )
+				   {	/* We found the name being declared */
+					while ( !isidfirstchar(*p) )
+					  p = skipspace(p, 1) + 1;
+					goto found;
+				   }
+				break;
+			   default:
+				goto found;
+			   }
+		   }
+found:		if ( *p == '.' && p[-1] == '.' && p[-2] == '.' )
+		  {	if ( convert_varargs )
+			  {	*bp++ = "va_alist";
+				vararg = p-2;
+			  }
+			else
+			  {	p++;
+				if ( bp == breaks + 1 )	/* sole argument */
+				  writeblanks(breaks[0], p);
+				else
+				  writeblanks(bp[-1] - 1, p);
+				bp--;
+			  }
+		   }
+		else
+		   {	while ( isidchar(*p) ) p--;
+			*bp++ = p+1;
+		   }
+		p = end;
+	   }
+	while ( *p++ == ',' );
+	*bp = p;
+	/* Make a special check for 'void' arglist */
+	if ( bp == breaks+2 )
+	   {	p = skipspace(breaks[0], 1);
+		if ( !strncmp(p, "void", 4) )
+		   {	p = skipspace(p+4, 1);
+			if ( p == breaks[2] - 1 )
+			   {	bp = breaks;	/* yup, pretend arglist is empty */
+				writeblanks(breaks[0], p + 1);
+			   }
+		   }
+	   }
+	/* Put out the function name and left parenthesis. */
+	p = buf;
+	while ( p != endfn ) putc(*p, out), p++;
+	/* Put out the declaration. */
+	if ( header )
+	  {	fputs(");", out);
+		for ( p = breaks[0]; *p; p++ )
+		  if ( *p == '\r' || *p == '\n' )
+		    putc(*p, out);
+	  }
+	else
+	  {	for ( ap = breaks+1; ap < bp; ap += 2 )
+		  {	p = *ap;
+			while ( isidchar(*p) )
+			  putc(*p, out), p++;
+			if ( ap < bp - 1 )
+			  fputs(", ", out);
+		  }
+		fputs(")  ", out);
+		/* Put out the argument declarations */
+		for ( ap = breaks+2; ap <= bp; ap += 2 )
+		  (*ap)[-1] = ';';
+		if ( vararg != 0 )
+		  {	*vararg = 0;
+			fputs(breaks[0], out);		/* any prior args */
+			fputs("va_dcl", out);		/* the final arg */
+			fputs(bp[0], out);
+		  }
+		else
+		  fputs(breaks[0], out);
+	  }
+	free((char *)breaks);
+	return 0;
+}

src/png/example.c

@@ -0,0 +1,702 @@
+
+/* example.c - an example of using libpng */
+
+/* This is an example of how to use libpng to read and write PNG files.
+ * The file libpng.txt is much more verbose then this.  If you have not
+ * read it, do so first.  This was designed to be a starting point of an
+ * implementation.  This is not officially part of libpng, and therefore
+ * does not require a copyright notice.
+ *
+ * This file does not currently compile, because it is missing certain
+ * parts, like allocating memory to hold an image.  You will have to
+ * supply these parts to get it to compile.  For an example of a minimal
+ * working PNG reader/writer, see pngtest.c, included in this distribution.
+ */
+
+#include "png.h"
+
+/* Check to see if a file is a PNG file using png_sig_cmp().  png_sig_cmp()
+ * returns zero if the image is a PNG and nonzero if it isn't a PNG.
+ *
+ * The function check_if_png() shown here, but not used, returns nonzero (true)
+ * if the file can be opened and is a PNG, 0 (false) otherwise.
+ *
+ * If this call is successful, and you are going to keep the file open,
+ * you should call png_set_sig_bytes(png_ptr, PNG_BYTES_TO_CHECK); once
+ * you have created the png_ptr, so that libpng knows your application
+ * has read that many bytes from the start of the file.  Make sure you
+ * don't call png_set_sig_bytes() with more than 8 bytes read or give it
+ * an incorrect number of bytes read, or you will either have read too
+ * many bytes (your fault), or you are telling libpng to read the wrong
+ * number of magic bytes (also your fault).
+ *
+ * Many applications already read the first 2 or 4 bytes from the start
+ * of the image to determine the file type, so it would be easiest just
+ * to pass the bytes to png_sig_cmp() or even skip that if you know
+ * you have a PNG file, and call png_set_sig_bytes().
+ */
+#define PNG_BYTES_TO_CHECK 4
+int check_if_png(char *file_name, FILE **fp)
+{
+   char buf[PNG_BYTES_TO_CHECK];
+
+   /* Open the prospective PNG file. */
+   if ((*fp = fopen(file_name, "rb")) != NULL);
+      return 0;
+
+   /* Read in some of the signature bytes */
+   if (fread(buf, 1, PNG_BYTES_TO_CHECK, *fp) != PNG_BYTES_TO_CHECK)
+      return 0;
+
+   /* Compare the first PNG_BYTES_TO_CHECK bytes of the signature.
+      Return nonzero (true) if they match */
+
+   return(!png_sig_cmp(buf, (png_size_t)0, PNG_BYTES_TO_CHECK));
+}
+
+/* Read a PNG file.  You may want to return an error code if the read
+ * fails (depending upon the failure).  There are two "prototypes" given
+ * here - one where we are given the filename, and we need to open the
+ * file, and the other where we are given an open file (possibly with
+ * some or all of the magic bytes read - see comments above).
+ */
+#ifdef open_file /* prototype 1 */
+void read_png(char *file_name)  /* We need to open the file */
+{
+   png_structp png_ptr;
+   png_infop info_ptr;
+   unsigned int sig_read = 0;
+   png_uint_32 width, height;
+   int bit_depth, color_type, interlace_type;
+   FILE *fp;
+
+   if ((fp = fopen(file_name, "rb")) == NULL)
+      return;
+#else no_open_file /* prototype 2 */
+void read_png(FILE *fp, unsigned int sig_read)  /* file is already open */
+{
+   png_structp png_ptr;
+   png_infop info_ptr;
+   png_uint_32 width, height;
+   int bit_depth, color_type, interlace_type;
+#endif no_open_file /* only use one prototype! */
+
+   /* Create and initialize the png_struct with the desired error handler
+    * functions.  If you want to use the default stderr and longjump method,
+    * you can supply NULL for the last three parameters.  We also supply the
+    * the compiler header file version, so that we know if the application
+    * was compiled with a compatible version of the library.  REQUIRED
+    */
+   png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING,
+      png_voidp user_error_ptr, user_error_fn, user_warning_fn);
+
+   if (png_ptr == NULL)
+   {
+      fclose(fp);
+      return;
+   }
+
+   /* Allocate/initialize the memory for image information.  REQUIRED. */
+   info_ptr = png_create_info_struct(png_ptr);
+   if (info_ptr == NULL)
+   {
+      fclose(fp);
+      png_destroy_read_struct(&png_ptr, (png_infopp)NULL, (png_infopp)NULL);
+      return;
+   }
+
+   /* Set error handling if you are using the setjmp/longjmp method (this is
+    * the normal method of doing things with libpng).  REQUIRED unless you
+    * set up your own error handlers in the png_create_read_struct() earlier.
+    */
+   if (setjmp(png_ptr->jmpbuf))
+   {
+      /* Free all of the memory associated with the png_ptr and info_ptr */
+      png_destroy_read_struct(&png_ptr, &info_ptr, (png_infopp)NULL);
+      fclose(fp);
+      /* If we get here, we had a problem reading the file */
+      return;
+   }
+
+   /* One of the following I/O initialization methods is REQUIRED */
+#ifdef streams /* PNG file I/O method 1 */
+   /* Set up the input control if you are using standard C streams */
+   png_init_io(png_ptr, fp);
+
+#else no_streams /* PNG file I/O method 2 */
+   /* If you are using replacement read functions, instead of calling
+    * png_init_io() here you would call:
+    */
+   png_set_read_fn(png_ptr, (void *)user_io_ptr, user_read_fn);
+   /* where user_io_ptr is a structure you want available to the callbacks */
+#endif no_streams /* Use only one I/O method! */
+
+   /* If we have already read some of the signature */
+   png_set_sig_bytes(png_ptr, sig_read);
+
+   /* The call to png_read_info() gives us all of the information from the
+    * PNG file before the first IDAT (image data chunk).  REQUIRED
+    */
+   png_read_info(png_ptr, info_ptr);
+
+   png_get_IHDR(png_ptr, info_ptr, &width, &height, &bit_depth, &color_type,
+       &interlace_type, NULL, NULL);
+
+/**** Set up the data transformations you want.  Note that these are all
+ **** optional.  Only call them if you want/need them.  Many of the
+ **** transformations only work on specific types of images, and many
+ **** are mutually exclusive.
+ ****/
+
+   /* tell libpng to strip 16 bit/color files down to 8 bits/color */
+   png_set_strip_16(png_ptr);
+
+   /* Strip alpha bytes from the input data without combining with th
+    * background (not recommended).
+    */
+   png_set_strip_alpha(png_ptr);
+
+   /* Extract multiple pixels with bit depths of 1, 2, and 4 from a single
+    * byte into separate bytes (useful for paletted and grayscale images).
+    */
+   png_set_packing(png_ptr);
+
+   /* Change the order of packed pixels to least significant bit first
+    * (not useful if you are using png_set_packing). */
+   png_set_packswap(png_ptr);
+
+   /* Expand paletted colors into true RGB triplets */
+   if (color_type == PNG_COLOR_TYPE_PALETTE)
+      png_set_expand(png_ptr);
+
+   /* Expand grayscale images to the full 8 bits from 1, 2, or 4 bits/pixel */
+   if (color_type == PNG_COLOR_TYPE_GRAY && bit_depth < 8)
+      png_set_expand(png_ptr);
+
+   /* Expand paletted or RGB images with transparency to full alpha channels
+    * so the data will be available as RGBA quartets.
+    */
+   if (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS))
+      png_set_expand(png_ptr);
+
+   /* Set the background color to draw transparent and alpha images over.
+    * It is possible to set the red, green, and blue components directly
+    * for paletted images instead of supplying a palette index.  Note that
+    * even if the PNG file supplies a background, you are not required to
+    * use it - you should use the (solid) application background if it has one.
+    */
+
+   png_color_16 my_background, *image_background;
+
+   if (png_get_bKGD(png_ptr, info_ptr, &image_background))
+      png_set_background(png_ptr, image_background,
+                         PNG_BACKGROUND_GAMMA_FILE, 1, 1.0);
+   else
+      png_set_background(png_ptr, &my_background,
+                         PNG_BACKGROUND_GAMMA_SCREEN, 0, 1.0);
+
+   /* Some suggestions as to how to get a screen gamma value */
+
+   /* Note that screen gamma is (display_gamma/viewing_gamma) */
+   if (/* We have a user-defined screen gamma value */)
+   {
+      screen_gamma = user-defined screen_gamma;
+   }
+   /* This is one way that applications share the same screen gamma value */
+   else if ((gamma_str = getenv("SCREEN_GAMMA")) != NULL)
+   {
+      screen_gamma = atof(gamma_str);
+   }
+   /* If we don't have another value */
+   else
+   {
+      screen_gamma = 2.2;  /* A good guess for a PC monitors in a dimly
+                              lit room */
+      screen_gamma = 1.7 or 1.0;  /* A good guess for Mac systems */
+   }
+
+   /* Tell libpng to handle the gamma conversion for you.  The second call
+    * is a good guess for PC generated images, but it should be configurable
+    * by the user at run time by the user.  It is strongly suggested that
+    * your application support gamma correction.
+    */
+
+   int intent;
+
+   if (png_get_sRGB(png_ptr, info_ptr, &intent))
+      png_set_sRGB(png_ptr, intent, 0);
+   else
+   {
+      double image_gamma;
+      if (png_get_gAMA(png_ptr, info_ptr, &image_gamma))
+         png_set_gamma(png_ptr, screen_gamma, image_gamma);
+      else
+         png_set_gamma(png_ptr, screen_gamma, 0.45455);
+   }
+
+   /* Dither RGB files down to 8 bit palette or reduce palettes
+    * to the number of colors available on your screen.
+    */
+   if (color_type & PNG_COLOR_MASK_COLOR)
+   {
+      png_uint_32 num_palette;
+      png_colorp palette;
+
+      /* This reduces the image to the application supplied palette */
+      if (/* we have our own palette */)
+      {
+         /* An array of colors to which the image should be dithered */
+         png_color std_color_cube[MAX_SCREEN_COLORS];
+
+         png_set_dither(png_ptr, std_color_cube, MAX_SCREEN_COLORS,
+            MAX_SCREEN_COLORS, NULL, 0);
+      }
+      /* This reduces the image to the palette supplied in the file */
+      else if (png_get_PLTE(png_ptr, info_ptr, &palette, &num_palette))
+      {
+         png_color16p histogram;
+
+         png_get_hIST(png_ptr, info_ptr, &histogram);
+
+         png_set_dither(png_ptr, palette, num_palette,
+                        max_screen_colors, histogram, 0);
+      }
+   }
+
+   /* invert monocrome files to have 0 as white and 1 as black */
+   png_set_invert_mono(png_ptr);
+
+   /* If you want to shift the pixel values from the range [0,255] or
+    * [0,65535] to the original [0,7] or [0,31], or whatever range the
+    * colors were originally in:
+    */
+   if (png_get_valid(png_ptr, info_ptr, PNG_INFO_sBIT))
+   {
+      png_color8p sig_bit;
+
+      png_get_sBIT(png_ptr, info_ptr, &sig_bit);
+      png_set_shift(png_ptr, sig_bit);
+   }
+
+   /* flip the RGB pixels to BGR (or RGBA to BGRA) */
+   png_set_bgr(png_ptr);
+
+   /* swap the RGBA or GA data to ARGB or AG (or BGRA to ABGR) */
+   png_set_swap_alpha(png_ptr);
+
+   /* swap bytes of 16 bit files to least significant byte first */
+   png_set_swap(png_ptr);
+
+   /* Add filler (or alpha) byte (before/after each RGB triplet) */
+   png_set_filler(png_ptr, 0xff, PNG_FILLER_AFTER);
+
+   /* Turn on interlace handling.  REQUIRED if you are not using
+    * png_read_image().  To see how to handle interlacing passes,
+    * see the png_read_row() method below:
+    */
+   number_passes = png_set_interlace_handling(png_ptr);
+
+   /* Optional call to gamma correct and add the background to the palette
+    * and update info structure.  REQUIRED if you are expecting libpng to
+    * update the palette for you (ie you selected such a transform above).
+    */
+   png_read_update_info(png_ptr, info_ptr);
+
+   /* Allocate the memory to hold the image using the fields of info_ptr. */
+
+   /* The easiest way to read the image: */
+   png_bytep row_pointers[height];
+
+   for (row = 0; row < height; row++)
+   {
+      row_pointers[row] = malloc(png_get_rowbytes(png_ptr, info_ptr));
+   }
+
+   /* Now it's time to read the image.  One of these methods is REQUIRED */
+#ifdef entire /* Read the entire image in one go */
+   png_read_image(png_ptr, row_pointers);
+
+#else no_entire /* Read the image one or more scanlines at a time */
+   /* The other way to read images - deal with interlacing: */
+
+   for (pass = 0; pass < number_passes; pass++)
+   {
+#ifdef single /* Read the image a single row at a time */
+      for (y = 0; y < height; y++)
+      {
+         png_read_rows(png_ptr, &row_pointers[y], NULL, 1);
+      }
+
+#else no_single /* Read the image several rows at a time */
+      for (y = 0; y < height; y += number_of_rows)
+      {
+#ifdef sparkle /* Read the image using the "sparkle" effect. */
+         png_read_rows(png_ptr, &row_pointers[y], NULL, number_of_rows);
+
+         png_read_rows(png_ptr, NULL, row_pointers[y], number_of_rows);
+#else no_sparkle /* Read the image using the "rectangle" effect */
+         png_read_rows(png_ptr, NULL, &row_pointers[y], number_of_rows);
+#endif no_sparkle /* use only one of these two methods */
+      }
+
+      /* if you want to display the image after every pass, do
+         so here */
+#endif no_single /* use only one of these two methods */
+   }
+#endif no_entire /* use only one of these two methods */
+
+   /* read rest of file, and get additional chunks in info_ptr - REQUIRED */
+   png_read_end(png_ptr, info_ptr);
+
+   /* clean up after the read, and free any memory allocated - REQUIRED */
+   png_destroy_read_struct(&png_ptr, &info_ptr, (png_infopp)NULL);
+
+   /* close the file */
+   fclose(fp);
+
+   /* that's it */
+   return;
+}
+
+/* progressively read a file */
+
+int
+initialize_png_reader(png_structp *png_ptr, png_infop *info_ptr)
+{
+   /* Create and initialize the png_struct with the desired error handler
+    * functions.  If you want to use the default stderr and longjump method,
+    * you can supply NULL for the last three parameters.  We also check that
+    * the library version is compatible in case we are using dynamically
+    * linked libraries.
+    */
+   *png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING,
+       png_voidp user_error_ptr, user_error_fn, user_warning_fn);
+
+   if (*png_ptr == NULL)
+   {
+      *info_ptr = NULL;
+      return ERROR;
+   }
+
+   *info_ptr = png_create_info_struct(png_ptr);
+
+   if (*info_ptr == NULL)
+   {
+      png_destroy_read_struct(png_ptr, info_ptr, (png_infopp)NULL);
+      return ERROR;
+   }
+
+   if (setjmp((*png_ptr)->jmpbuf))
+   {
+      png_destroy_read_struct(png_ptr, info_ptr, (png_infopp)NULL);
+      return ERROR;
+   }
+
+   /* This one's new.  You will need to provide all three
+    * function callbacks, even if you aren't using them all.
+    * If you aren't using all functions, you can specify NULL
+    * parameters.  Even when all three functions are NULL,
+    * you need to call png_set_progressive_read_fn().
+    * These functions shouldn't be dependent on global or
+    * static variables if you are decoding several images
+    * simultaneously.  You should store stream specific data
+    * in a separate struct, given as the second parameter,
+    * and retrieve the pointer from inside the callbacks using
+    * the function png_get_progressive_ptr(png_ptr).
+    */
+   png_set_progressive_read_fn(*png_ptr, (void *)stream_data,
+      info_callback, row_callback, end_callback);
+
+   return OK;
+}
+
+int
+process_data(png_structp *png_ptr, png_infop *info_ptr,
+   png_bytep buffer, png_uint_32 length)
+{
+   if (setjmp((*png_ptr)->jmpbuf))
+   {
+      /* Free the png_ptr and info_ptr memory on error */
+      png_destroy_read_struct(png_ptr, info_ptr, (png_infopp)NULL);
+      return ERROR;
+   }
+
+   /* This one's new also.  Simply give it chunks of data as
+    * they arrive from the data stream (in order, of course).
+    * On Segmented machines, don't give it any more than 64K.
+    * The library seems to run fine with sizes of 4K, although
+    * you can give it much less if necessary (I assume you can
+    * give it chunks of 1 byte, but I haven't tried with less
+    * than 256 bytes yet).  When this function returns, you may
+    * want to display any rows that were generated in the row
+    * callback, if you aren't already displaying them there.
+    */
+   png_process_data(*png_ptr, *info_ptr, buffer, length);
+   return OK;
+}
+
+info_callback(png_structp png_ptr, png_infop info)
+{
+/* do any setup here, including setting any of the transformations
+ * mentioned in the Reading PNG files section.  For now, you _must_
+ * call either png_start_read_image() or png_read_update_info()
+ * after all the transformations are set (even if you don't set
+ * any).  You may start getting rows before png_process_data()
+ * returns, so this is your last chance to prepare for that.
+ */
+}
+
+row_callback(png_structp png_ptr, png_bytep new_row,
+   png_uint_32 row_num, int pass)
+{
+/* this function is called for every row in the image.  If the
+ * image is interlacing, and you turned on the interlace handler,
+ * this function will be called for every row in every pass.
+ * Some of these rows will not be changed from the previous pass.
+ * When the row is not changed, the new_row variable will be NULL.
+ * The rows and passes are called in order, so you don't really
+ * need the row_num and pass, but I'm supplying them because it
+ * may make your life easier.
+ *
+ * For the non-NULL rows of interlaced images, you must call
+ * png_progressive_combine_row() passing in the row and the
+ * old row.  You can call this function for NULL rows (it will
+ * just return) and for non-interlaced images (it just does the
+ * memcpy for you) if it will make the code easier.  Thus, you
+ * can just do this for all cases:
+ */
+
+   png_progressive_combine_row(png_ptr, old_row, new_row);
+
+/* where old_row is what was displayed for previous rows.  Note
+ * that the first pass (pass == 0 really) will completely cover
+ * the old row, so the rows do not have to be initialized.  After
+ * the first pass (and only for interlaced images), you will have
+ * to pass the current row, and the function will combine the
+ * old row and the new row.
+ */
+}
+
+end_callback(png_structp png_ptr, png_infop info)
+{
+/* this function is called when the whole image has been read,
+ * including any chunks after the image (up to and including
+ * the IEND).  You will usually have the same info chunk as you
+ * had in the header, although some data may have been added
+ * to the comments and time fields.
+ *
+ * Most people won't do much here, perhaps setting a flag that
+ * marks the image as finished.
+ */
+}
+
+/* write a png file */
+void write_png(char *file_name /* , ... other image information ... */)
+{
+   FILE *fp;
+   png_structp png_ptr;
+   png_infop info_ptr;
+
+   /* open the file */
+   fp = fopen(file_name, "wb");
+   if (fp == NULL)
+      return;
+
+   /* Create and initialize the png_struct with the desired error handler
+    * functions.  If you want to use the default stderr and longjump method,
+    * you can supply NULL for the last three parameters.  We also check that
+    * the library version is compatible with the one used at compile time,
+    * in case we are using dynamically linked libraries.  REQUIRED.
+    */
+   png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING,
+      png_voidp user_error_ptr, user_error_fn, user_warning_fn);
+
+   if (png_ptr == NULL)
+   {
+      fclose(fp);
+      return;
+   }
+
+   /* Allocate/initialize the image information data.  REQUIRED */
+   info_ptr = png_create_info_struct(png_ptr);
+   if (info_ptr == NULL)
+   {
+      fclose(fp);
+      png_destroy_write_struct(&png_ptr,  (png_infopp)NULL);
+      return;
+   }
+
+   /* Set error handling.  REQUIRED if you aren't supplying your own
+    * error hadnling functions in the png_create_write_struct() call.
+    */
+   if (setjmp(png_ptr->jmpbuf))
+   {
+      /* If we get here, we had a problem reading the file */
+      fclose(fp);
+      png_destroy_write_struct(&png_ptr,  (png_infopp)NULL);
+      return;
+   }
+
+   /* One of the following I/O initialization functions is REQUIRED */
+#ifdef streams /* I/O initialization method 1 */
+   /* set up the output control if you are using standard C streams */
+   png_init_io(png_ptr, fp);
+#else no_streams /* I/O initialization method 2 */
+   /* If you are using replacement read functions, instead of calling
+    * png_init_io() here you would call */
+   png_set_write_fn(png_ptr, (void *)user_io_ptr, user_write_fn,
+      user_IO_flush_function);
+   /* where user_io_ptr is a structure you want available to the callbacks */
+#endif no_streams /* only use one initialization method */
+
+   /* Set the image information here.  Width and height are up to 2^31,
+    * bit_depth is one of 1, 2, 4, 8, or 16, but valid values also depend on
+    * the color_type selected. color_type is one of PNG_COLOR_TYPE_GRAY,
+    * PNG_COLOR_TYPE_GRAY_ALPHA, PNG_COLOR_TYPE_PALETTE, PNG_COLOR_TYPE_RGB,
+    * or PNG_COLOR_TYPE_RGB_ALPHA.  interlace is either PNG_INTERLACE_NONE or
+    * PNG_INTERLACE_ADAM7, and the compression_type and filter_type MUST
+    * currently be PNG_COMPRESSION_TYPE_BASE and PNG_FILTER_TYPE_BASE. REQUIRED
+    */
+   png_set_IHDR(png_ptr, info_ptr, width, height, bit_depth, PNG_COLOR_TYPE_???,
+      PNG_INTERLACE_????, PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE);
+
+   /* set the palette if there is one.  REQUIRED for indexed-color images */
+   palette = (png_colorp)png_malloc(png_ptr, 256 * sizeof (png_color));
+   /* ... set palette colors ... */
+   png_set_PLTE(png_ptr, info_ptr, palette, 256);
+
+   /* optional significant bit chunk */
+   /* if we are dealing with a grayscale image then */
+   sig_bit.gray = true_bit_depth;
+   /* otherwise, if we are dealing with a color image then */
+   sig_bit.red = true_red_bit_depth;
+   sig_bit.green = true_green_bit_depth;
+   sig_bit.blue = true_blue_bit_depth;
+   /* if the image has an alpha channel then */
+   sig_bit.alpha = true_alpha_bit_depth;
+   png_set_sBIT(png_ptr, info_ptr, sig_bit);
+
+
+   /* Optional gamma chunk is strongly suggested if you have any guess
+    * as to the correct gamma of the image.
+    */
+   png_set_gAMA(png_ptr, info_ptr, gamma);
+
+   /* Optionally write comments into the image */
+   text_ptr[0].key = "Title";
+   text_ptr[0].text = "Mona Lisa";
+   text_ptr[0].compression = PNG_TEXT_COMPRESSION_NONE;
+   text_ptr[1].key = "Author";
+   text_ptr[1].text = "Leonardo DaVinci";
+   text_ptr[1].compression = PNG_TEXT_COMPRESSION_NONE;
+   text_ptr[2].key = "Description";
+   text_ptr[2].text = "<long text>";
+   text_ptr[2].compression = PNG_TEXT_COMPRESSION_zTXt;
+   png_set_text(png_ptr, info_ptr, text_ptr, 3);
+
+   /* other optional chunks like cHRM, bKGD, tRNS, tIME, oFFs, pHYs, */
+   /* note that if sRGB is present the cHRM chunk must be ignored
+    * on read and must be written in accordance with the sRGB profile */
+
+   /* Write the file header information.  REQUIRED */
+   png_write_info(png_ptr, info_ptr);
+
+   /* Once we write out the header, the compression type on the text
+    * chunks gets changed to PNG_TEXT_COMPRESSION_NONE_WR or
+    * PNG_TEXT_COMPRESSION_zTXt_WR, so it doesn't get written out again
+    * at the end.
+    */
+
+   /* set up the transformations you want.  Note that these are
+    * all optional.  Only call them if you want them.
+    */
+
+   /* invert monocrome pixels */
+   png_set_invert_mono(png_ptr);
+
+   /* Shift the pixels up to a legal bit depth and fill in
+    * as appropriate to correctly scale the image.
+    */
+   png_set_shift(png_ptr, &sig_bit);
+
+   /* pack pixels into bytes */
+   png_set_packing(png_ptr);
+
+   /* swap location of alpha bytes from ARGB to RGBA */
+   png_set_swap_alpha(png_ptr);
+
+   /* Get rid of filler (OR ALPHA) bytes, pack XRGB/RGBX/ARGB/RGBA into
+    * RGB (4 channels -> 3 channels). The second parameter is not used.
+    */
+   png_set_filler(png_ptr, 0, PNG_FILLER_BEFORE);
+
+   /* flip BGR pixels to RGB */
+   png_set_bgr(png_ptr);
+
+   /* swap bytes of 16-bit files to most significant byte first */
+   png_set_swap(png_ptr);
+
+   /* swap bits of 1, 2, 4 bit packed pixel formats */
+   png_set_packswap(png_ptr);
+
+   /* turn on interlace handling if you are not using png_write_image() */
+   if (interlacing)
+      number_passes = png_set_interlace_handling(png_ptr);
+   else
+      number_passes = 1;
+
+   /* The easiest way to write the image (you may have a different memory
+    * layout, however, so choose what fits your needs best).  You need to
+    * use the first method if you aren't handling interlacing yourself.
+    */
+   png_uint_32 k, height, width;
+   png_byte image[height][width];
+   png_bytep row_pointers[height];
+   for (k = 0; k < height; k++)
+     row_pointers[k] = image + k*width;
+
+   /* One of the following output methods is REQUIRED */
+#ifdef entire /* write out the entire image data in one call */
+   png_write_image(png_ptr, row_pointers);
+
+   /* the other way to write the image - deal with interlacing */
+
+#else no_entire /* write out the image data by one or more scanlines */
+   /* The number of passes is either 1 for non-interlaced images,
+    * or 7 for interlaced images.
+    */
+   for (pass = 0; pass < number_passes; pass++)
+   {
+      /* Write a few rows at a time. */
+      png_write_rows(png_ptr, &row_pointers[first_row], number_of_rows);
+
+      /* If you are only writing one row at a time, this works */
+      for (y = 0; y < height; y++)
+      {
+         png_write_rows(png_ptr, &row_pointers[y], 1);
+      }
+   }
+#endif no_entire /* use only one output method */
+
+   /* You can write optional chunks like tEXt, zTXt, and tIME at the end
+    * as well.
+    */
+
+   /* It is REQUIRED to call this to finish writing the rest of the file */
+   png_write_end(png_ptr, info_ptr);
+
+   /* if you malloced the palette, free it here */
+   free(info_ptr->palette);
+
+   /* if you allocated any text comments, free them here */
+
+   /* clean up after the write, and free any memory allocated */
+   png_destroy_write_struct(&png_ptr, (png_infopp)NULL);
+
+   /* close the file */
+   fclose(fp);
+
+   /* that's it */
+   return;
+}
+

src/png/libpngpf.3

@@ -0,0 +1,347 @@
+.TH LIBPNGPF 3 "January 14, 1999"
+.SH NAME
+libpng \- Portable Network Graphics (PNG) Reference Library 1.0.3 - January 14, 1999
+(private functions)
+.SH SYNOPSIS
+#include <png.h>
+
+void png_build_gamma_table (png_structp png_ptr);
+
+void png_build_grayscale_palette (int bit_depth, png_colorp
+palette);
+
+void png_calculate_crc (png_structp png_ptr, png_bytep ptr,
+png_size_t length);
+void png_check_chunk_name (png_structp png_ptr, png_bytep
+chunk_name);
+
+png_size_t png_check_keyword (png_structp png_ptr, png_charp
+key, png_charpp new_key);
+
+void png_combine_row (png_structp png_ptr, png_bytep row, int
+mask);
+
+void png_correct_palette (png_structp png_ptr, png_colorp
+palette, int num_palette);
+
+int png_crc_error (png_structp png_ptr);
+
+int png_crc_finish (png_structp png_ptr, png_uint_32 skip);
+
+void png_crc_read (png_structp png_ptr, png_bytep buf,
+png_size_t length);
+
+png_voidp png_create_struct (int type, png_malloc_ptr malloc_fn);
+
+png_voidp png_create_struct_2 (int type);
+
+void png_destroy_struct (png_voidp struct_ptr);
+
+void png_destroy_struct_2 (png_voidp struct_ptr, png_free_ptr
+free_fn);
+
+void png_do_background (png_row_infop row_info, png_bytep row,
+png_color_16p trans_values, png_color_16p background,
+png_color_16p background_1, png_bytep gamma_table, png_bytep
+gamma_from_1, png_bytep gamma_to_1, png_uint_16pp gamma_16,
+png_uint_16pp gamma_16_from_1, png_uint_16pp gamma_16_to_1, int
+gamma_shift);
+
+void png_do_bgr (png_row_infop row_info, png_bytep row);
+
+void png_do_chop (png_row_infop row_info, png_bytep row);
+
+void png_do_dither (png_row_infop row_info, png_bytep row,
+png_bytep palette_lookup, png_bytep dither_lookup);
+
+void png_do_expand (png_row_infop row_info, png_bytep row,
+png_color_16p trans_value);
+
+void png_do_expand_palette (png_row_infop row_info, png_bytep
+row, png_colorp palette, png_bytep trans, int num_trans);
+
+void png_do_gamma (png_row_infop row_info, png_bytep row,
+png_bytep gamma_table, png_uint_16pp gamma_16_table, int
+gamma_shift);
+
+void png_do_gray_to_rgb (png_row_infop row_info, png_bytep
+row);
+
+void png_do_invert (png_row_infop row_info, png_bytep row);
+
+void png_do_pack (png_row_infop row_info, png_bytep row,
+png_uint_32 bit_depth);
+
+void png_do_packswap (png_row_infop row_info, png_bytep row);
+
+void png_do_read_filler (png_row_infop row_info, png_bytep row,
+png_uint_32 filler, png_uint_32 flags);
+
+void png_do_read_interlace (png_row_infop row_info, png_bytep
+row, int pass, png_uint_32 transformations);
+
+void png_do_read_invert_alpha (png_row_infop row_info,
+png_bytep row);
+
+void png_do_read_swap_alpha (png_row_infop row_info, png_bytep
+row);
+
+void png_do_read_transformations (png_structp png_ptr);
+
+int png_do_rgb_to_gray (png_row_infop row_info, png_bytep
+row);
+
+void png_do_shift (png_row_infop row_info, png_bytep row,
+png_color_8p bit_depth);
+
+void png_do_strip_filler (png_row_infop row_info, png_bytep
+row, png_uint_32 flags);
+
+void png_do_swap (png_row_infop row_info, png_bytep row);
+
+void png_do_unpack (png_row_infop row_info, png_bytep row);
+
+void png_do_unshift (png_row_infop row_info, png_bytep row,
+png_color_8p sig_bits);
+
+void png_do_write_interlace (png_row_infop row_info, png_bytep
+row, int pass);
+
+void png_do_write_invert_alpha (png_row_infop row_info,
+png_bytep row);
+
+void png_do_write_swap_alpha (png_row_infop row_info, png_bytep
+row);
+
+void png_do_write_transformations (png_structp png_ptr);
+
+void *png_far_to_near (png_structp png_ptr,png_voidp ptr,
+int check);
+
+void png_flush (png_structp png_ptr);
+
+png_int_32 png_get_int_32 (png_bytep buf);
+
+png_uint_16 png_get_uint_16 (png_bytep buf);
+
+png_uint_32 png_get_uint_32 (png_bytep buf);
+
+void png_handle_bKGD (png_structp png_ptr, png_infop info_ptr,
+png_uint_32 length);
+
+void png_handle_cHRM (png_structp png_ptr, png_infop info_ptr,
+png_uint_32 length);
+
+void png_handle_gAMA (png_structp png_ptr, png_infop info_ptr,
+png_uint_32 length);
+
+void png_handle_hIST (png_structp png_ptr, png_infop info_ptr,
+png_uint_32 length);
+
+void png_handle_IEND (png_structp png_ptr, png_infop info_ptr,
+png_uint_32 length);
+
+void png_handle_IHDR (png_structp png_ptr, png_infop info_ptr,
+png_uint_32 length);
+
+void png_handle_oFFs (png_structp png_ptr, png_infop info_ptr,
+png_uint_32 length);
+
+void png_handle_pCAL (png_structp png_ptr, png_infop info_ptr,
+png_uint_32 length);
+
+void png_handle_pHYs (png_structp png_ptr, png_infop info_ptr,
+png_uint_32 length);
+
+void png_handle_PLTE (png_structp png_ptr, png_infop info_ptr,
+png_uint_32 length);
+
+void png_handle_sBIT (png_structp png_ptr, png_infop info_ptr,
+png_uint_32 length);
+
+void png_handle_sRGB (png_structp png_ptr, png_infop info_ptr,
+png_uint_32 length);
+
+void png_handle_tEXt (png_structp png_ptr, png_infop info_ptr,
+png_uint_32 length);
+
+void png_handle_tIME (png_structp png_ptr, png_infop info_ptr,
+png_uint_32 length);
+
+void png_handle_tRNS (png_structp png_ptr, png_infop info_ptr,
+png_uint_32 length);
+
+void png_handle_unknown (png_structp png_ptr, png_infop
+info_ptr, png_uint_32 length);
+
+void png_handle_zTXt (png_structp png_ptr, png_infop info_ptr,
+png_uint_32 length);
+
+void png_info_destroy (png_structp png_ptr, png_infop
+info_ptr);
+
+void png_init_read_transformations (png_structp png_ptr);
+
+void png_process_IDAT_data (png_structp png_ptr, png_bytep
+buffer, png_size_t buffer_length);
+
+void png_process_some_data (png_structp png_ptr, png_infop
+info_ptr);
+
+void png_push_check_crc (png_structp png_ptr);
+
+void png_push_crc_finish (png_structp png_ptr);
+
+void png_push_crc_skip (png_structp png_ptr, png_uint_32
+length);
+
+void png_push_fill_buffer (png_structp png_ptr, png_bytep
+buffer, png_size_t length);
+
+void png_push_handle_tEXt (png_structp png_ptr, png_infop
+info_ptr, png_uint_32 length);
+
+void png_push_handle_unknown (png_structp png_ptr, png_infop
+info_ptr, png_uint_32 length);
+
+void png_push_handle_zTXt (png_structp png_ptr, png_infop
+info_ptr, png_uint_32 length);
+
+void png_push_have_end (png_structp png_ptr, png_infop
+info_ptr);
+
+void png_push_have_info (png_structp png_ptr, png_infop
+info_ptr);
+
+void png_push_have_row (png_structp png_ptr, png_bytep row);
+
+void png_push_process_row (png_structp png_ptr);
+
+void png_push_read_chunk (png_structp png_ptr, png_infop
+info_ptr);
+
+void png_push_read_end (png_structp png_ptr, png_infop
+info_ptr);
+
+void png_push_read_IDAT (png_structp png_ptr);
+
+void png_push_read_sig (png_structp png_ptr, png_infop
+info_ptr);
+
+void png_push_read_tEXt (png_structp png_ptr, png_infop
+info_ptr);
+
+void png_push_read_zTXt (png_structp png_ptr, png_infop
+info_ptr);
+
+void png_push_restore_buffer (png_structp png_ptr, png_bytep
+buffer, png_size_t buffer_length);
+
+void png_push_save_buffer (png_structp png_ptr);
+
+void png_read_data (png_structp png_ptr, png_bytep data,
+png_size_t length);
+
+void png_read_filter_row (png_structp png_ptr, png_row_infop
+row_info, png_bytep row, png_bytep prev_row, int filter);
+
+void png_read_finish_row (png_structp png_ptr);
+
+void png_read_init (png_structp png_ptr);
+
+void png_read_push_finish_row (png_structp png_ptr);
+
+void png_read_start_row (png_structp png_ptr);
+
+void png_read_transform_info (png_structp png_ptr, png_infop
+info_ptr);
+
+void png_reset_crc (png_structp png_ptr);
+
+void png_save_int_32 (png_bytep buf, png_int_32 i);
+
+void png_save_uint_16 (png_bytep buf, unsigned int i);
+
+void png_save_uint_32 (png_bytep buf, png_uint_32 i);
+
+void png_write_bKGD (png_structp png_ptr, png_color_16p values,
+int color_type);
+
+void png_write_cHRM (png_structp png_ptr, double white_x,
+double white_y, double red_x, double red_y, double green_x,
+double green_y, double blue_x, double blue_y);
+
+void png_write_data (png_structp png_ptr, png_bytep data,
+png_size_t length);
+void png_write_filtered_row (png_structp png_ptr, png_bytep
+filtered_row);
+
+void png_write_find_filter (png_structp png_ptr, png_row_infop
+row_info);
+
+void png_write_finish_row (png_structp png_ptr);
+
+void png_write_gAMA (png_structp png_ptr, double file_gamma);
+
+void png_write_hIST (png_structp png_ptr, png_uint_16p hist,
+int num_hist);
+
+void png_write_init (png_structp png_ptr);
+
+void png_write_IDAT (png_structp png_ptr, png_bytep data,
+png_size_t length);
+
+void png_write_IEND (png_structp png_ptr);
+
+void png_write_IHDR (png_structp png_ptr, png_uint_32 width,
+png_uint_32 height, int bit_depth, int color_type, int
+compression_type, int filter_type, int interlace_type);
+
+void png_write_oFFs (png_structp png_ptr, png_uint_32 x_offset,
+png_uint_32 y_offset, int unit_type);
+
+void png_write_pCAL (png_structp png_ptr, png_charp purpose,
+png_int_32 X0, png_int_32 X1, int type, int nparams, png_charp
+units, png_charpp params);
+
+void png_write_pHYs (png_structp png_ptr, png_uint_32
+x_pixels_per_unit, png_uint_32 y_pixels_per_unit, int
+unit_type);
+
+void png_write_PLTE (png_structp png_ptr, png_colorp palette,
+png_uint_32 num_pal);
+
+void png_write_sBIT (png_structp png_ptr, png_color_8p sbit,
+int color_type);
+
+void png_write_sig (png_structp png_ptr);
+
+void png_write_sRGB (png_structp png_ptr, int intent);
+
+void png_write_start_row (png_structp png_ptr);
+
+void png_write_tEXt (png_structp png_ptr, png_charp key,
+png_charp text, png_size_t text_len);
+
+void png_write_tIME (png_structp png_ptr, png_timep mod_time);
+
+void png_write_tRNS (png_structp png_ptr, png_bytep trans,
+png_color_16p values, int number, int color_type);
+
+void png_write_zTXt (png_structp png_ptr, png_charp key,
+png_charp text, png_size_t text_len, int compression);
+
+voidpf png_zalloc (voidpf png_ptr, uInt items, uInt size);
+
+void png_zfree (voidpf png_ptr, voidpf ptr);
+
+.SH DESCRIPTION
+The functions listed above are used privately by libpng
+and are not recommended for use by applications.  They
+are listed alphabetically here as an aid to libpng maintainers.
+See png.h for more information on these functions.
+
+.SH SEE ALSO
+libpng(3), png(5)
+.SH AUTHOR
+Glenn Randers-Pehrson

src/png/makefile.b32

@@ -0,0 +1,21 @@
+#
+# File:		makefile.b32
+# Author:	Julian Smart
+# Created:	1993
+# Updated:	
+# Copyright:
+#
+# "%W% %G%"
+#
+# Makefile : Builds PNG library (BC++ 32-bit)
+
+# WXWIN and BCCDIR are set by parent make
+
+LIBTARGET =..\..\lib\winpng.lib
+
+OBJECTS = png.obj pngread.obj pngrtran.obj pngrutil.obj \
+          pngpread.obj pngtrans.obj pngwrite.obj pngwtran.obj pngwutil.obj \
+          pngerror.obj pngmem.obj pngwio.obj pngrio.obj pngget.obj pngset.obj
+
+!include $(WXWIN)\src\makelib.b32
+

src/png/makefile.bcc

@@ -0,0 +1,92 @@
+#
+# File:		makefile.bcc
+# Author:	Julian Smart
+# Created:	1993
+# Updated:	
+# Copyright:
+#
+# "%W% %G%"
+#
+# Makefile : Builds PNG library (BC++ 16-bit) 
+
+# WXWIN and BCCDIR are set by parent make
+
+WXDIR = $(WXWIN)
+!include $(WXDIR)\src\makebcc.env
+
+WINPNGLIB = ..\..\lib\winpng.lib
+
+WXLIBDIR = $(WXDIR)\lib
+WXINC = $(WXDIR)\include\msw
+WXLIB = $(WXLIBDIR)\wx.lib 
+
+!if "$(FINAL)" == "0"
+OPT = -Od
+DEBUG_FLAGS= -v
+!else
+OPT = -Od
+DEBUG_FLAGS =
+!endif
+CPPFLAGS=$(DEBUG_FLAGS) $(OPT) @$(CFG)
+
+OBJECTS = png.obj pngread.obj pngrtran.obj pngrutil.obj \
+ pngpread.obj pngtrans.obj pngwrite.obj pngwtran.obj pngwutil.obj \
+ pngerror.obj pngmem.obj pngwio.obj pngrio.obj pngget.obj pngset.obj
+
+all: $(WINPNGLIB)
+
+$(WINPNGLIB): $(OBJECTS) 
+        erase $(WINPNGLIB)
+	tlib $(WINPNGLIB) /P512 @&&!
+-+$(OBJECTS:.obj =.obj -+) 
+!
+
+.$(SRCSUFF).obj:
+	bcc $(CPPFLAGS) -c {$< }
+
+.c.obj:
+	bcc $(CPPFLAGS) -P- -c {$< }
+
+$(CFG): makefile.bcc
+	copy &&!
+-H=$(WXDIR)\src\msw\borland.pch
+-2
+-P
+-d
+-w-hid
+-w-par
+-w-pia
+-w-aus
+-w-rch
+-ml
+-Od
+-WE
+-Fs-
+-Vf
+-Ff=4
+-I$(WXINC);$(BCCDIR)\include;$(WXDIR)/src/png;$(WXDIR)/src/zlib;$(WXDIR)/src/xpm
+-I$(WXDIR)\include\wx\msw\gnuwin32
+-L$(BCCDIR)\lib
+-D__WXWIN__
+-D__WXMSW__
+-D__WINDOWS__
+-D__WIN16__
+! $(CFG)
+!if "$(BOR_VER)" == "3.1"
+	echo -Ff=4 >>$(CFG)
+!elif "$(BOR_VER)" == "4"
+	echo -Ff=512 >>$(CFG)
+	echo -dc >>$(CFG)
+!else
+	echo -Ff=512 >>$(CFG)
+	echo -dc >>$(CFG)
+!endif
+
+clean:
+        -erase *.obj
+        -erase *.exe
+        -erase *.res
+        -erase *.map
+        -erase *.rws
+        -erase $(WINPNGLIB)
+

src/png/makefile.dos

@@ -0,0 +1,77 @@
+#
+# File:		makefile.dos
+# Author:	Julian Smart
+# Created:	1993
+# Updated:	
+# Copyright:	(c) 1993, AIAI, University of Edinburgh
+#
+# "%W% %G%"
+#
+# Makefile : Builds winpng.lib library for Windows 3.1
+
+# Change WXDIR or WXWIN to wherever wxWindows is found
+WXDIR = $(WXWIN)
+WXLIB = $(WXDIR)\lib\wx.lib
+WXINC = $(WXDIR)\include
+
+WINPNGDIR = $(WXDIR)\src\png
+WINPNGINC = $(WINPNGDIR)
+WINPNGLIB = ..\..\lib\winpng.lib
+
+INC = /I..\zlib
+
+LIBS=$(WXLIB) $(WINPNGLIB) libw llibcew commdlg ddeml shell # ctl3d
+
+# Set this to nothing if your compiler is MS C++ 7
+ZOPTION=
+
+!ifndef FINAL
+FINAL=0
+!endif
+
+PRECOMP=/YuWX.H 
+
+!if "$(FINAL)" == "0"
+OPT = /Od
+CPPFLAGS= /AL /W4 /Gt4 /Zi $(ZOPTION) /G2sw $(OPT) /D__WXMSW__ $(INC)
+CFLAGS= /AL /W4 /Gt4 /Zi /G2sw /Od /D__WXMSW__ $(INC)
+LINKFLAGS=/NOD /CO /ONERROR:NOEXE
+!else
+# /Ox for real FINAL version
+OPT = /Ox
+CPPFLAGS= /AL /W4 /Gt4 /Zi /Os /G2sw $(OPT) /D__WXMSW__ $(INC)
+CFLAGS= /AL /W4 /Gt4 /Zi /Os /G2sw /D__WXMSW__ $(INC)
+LINKFLAGS=/NOD /ONERROR:NOEXE
+!endif
+
+OBJECTS = png.obj pngread.obj pngrtran.obj pngrutil.obj \
+ pngpread.obj pngtrans.obj pngwrite.obj pngwtran.obj pngwutil.obj \
+ pngerror.obj pngmem.obj pngwio.obj pngrio.obj pngget.obj pngset.obj
+
+all:    $(WINPNGLIB)
+
+wx:
+        cd $(WXDIR)\src
+        nmake -f makefile.dos $(WXLIB) FINAL=$(FINAL)
+
+$(WINPNGLIB):      $(OBJECTS)
+        erase $(WINPNGLIB)
+        lib /PAGESIZE:128 @<<
+$(WINPNGLIB)
+y
+$(OBJECTS)
+nul
+;
+<<
+
+.c.obj:
+  cl $(CFLAGS) /c $*.c
+
+clean:
+        -erase *.obj
+        -erase *.exe
+        -erase *.lib
+        -erase *.sbr
+        -erase *.pdb
+
+cleanall:	clean

src/png/makefile.unx

@@ -0,0 +1,30 @@
+#
+# File:		makefile.unx
+# Author:	Julian Smart
+# Created:	1998
+# Updated:	
+# Copyright:	(c) 1998
+#
+#
+# Makefile for PNG library, Unix
+
+include ../make.env
+
+TARGETLIB=../../lib/libpng.a
+
+LIB_C_SRC = png.c pngread.c pngrtran.c pngrutil.c \
+ pngpread.c pngtrans.c pngwrite.c pngwtran.c pngwutil.c \
+ pngerror.c pngmem.c pngwio.c pngrio.c pngget.c pngset.c
+
+all:    $(TARGETLIB)
+
+# Define library objects
+OBJECTS=\
+ $(LIB_C_SRC:.c=.o)
+
+$(TARGETLIB) : $(OBJECTS)
+	ar $(AROPTIONS) $@ $(OBJECTS)
+	$(RANLIB) $@
+
+clean:
+	rm -f $(OBJECTS) $(TARGETLIB)

src/png/makefile.vc

@@ -0,0 +1,31 @@
+
+!if "$(FINAL)" == "1"
+LIBTARGET=$(WXDIR)\lib\png.lib
+!else if "$(FINAL)" == "hybrid"
+LIBTARGET=$(WXDIR)\lib\pngh.lib
+!else
+LIBTARGET=$(WXDIR)\lib\pngd.lib
+!endif
+
+OBJECTS = $D\png.obj \
+          $D\pngread.obj \
+          $D\pngrtran.obj \
+          $D\pngrutil.obj \
+          $D\pngpread.obj \
+          $D\pngtrans.obj \
+          $D\pngwrite.obj \
+          $D\pngwtran.obj \
+          $D\pngwutil.obj \
+          $D\pngerror.obj \
+          $D\pngmem.obj \
+          $D\pngwio.obj \
+          $D\pngrio.obj \
+          $D\pngget.obj \
+          $D\pngset.obj
+
+
+
+# Pull in standard variable definitions
+
+!include ..\makelib.vc
+

src/png/makefile.wat

@@ -0,0 +1,37 @@
+#!/binb/wmake.exe
+#
+# File:		makefile.wat
+# Author:	Julian Smart
+# Created:	1998
+#
+# Makefile : Builds PNG library for Watcom C++, WIN32
+
+WXDIR = ..\..
+EXTRACPPFLAGS=-i=..\zlib
+
+!include $(WXDIR)\src\makewat.env
+
+WXLIB = $(WXDIR)\lib
+
+LIBTARGET   = $(WXLIB)\png.lib
+
+OBJECTS = png.obj pngread.obj pngrtran.obj pngrutil.obj &
+ pngpread.obj pngtrans.obj pngwrite.obj pngwtran.obj pngwutil.obj &
+ pngerror.obj pngmem.obj pngwio.obj pngrio.obj pngget.obj pngset.obj
+
+all:        $(OBJECTS) $(LIBTARGET)
+
+$(LIBTARGET) : $(OBJECTS)
+    %create tmp.lbc
+    @for %i in ( $(OBJECTS) ) do @%append tmp.lbc +%i
+    wlib /b /c /n /p=512 $^@ @tmp.lbc
+
+clean:   .SYMBOLIC
+    -erase *.obj
+    -erase $(LIBTARGET)
+    -erase *.pch
+    -erase *.err
+    -erase *.lbc
+
+cleanall:   clean
+

src/png/png.5

@@ -0,0 +1,44 @@
+.TH PNG 5 "January 14, 1999"
+.SH NAME
+png \- Portable Network Graphics (PNG) format
+.SH DESCRIPTION
+PNG (Portable Network Graphics) is an extensible file format for the
+lossless, portable, well-compressed storage of raster images. PNG provides
+a patent-free replacement for GIF and can also replace many
+common uses of TIFF. Indexed-color, grayscale, and truecolor images are
+supported, plus an optional alpha channel. Sample depths range from
+1 to 16 bits.
+.br
+
+PNG is designed to work well in online viewing applications, such as the
+World Wide Web, so it is fully streamable with a progressive display
+option. PNG is robust, providing both full file integrity checking and
+fast, simple detection of common transmission errors. Also, PNG can store
+gamma and chromaticity data for improved color matching on heterogeneous
+platforms.
+
+.SH "SEE ALSO"
+.IR libpng(3), zlib(3), deflate(5), and zlib(5)
+.LP
+PNG specification:
+RFC 2083
+.IP
+.br
+ftp://ds.internic.net/rfc/rfc2083.txt
+.br
+or (as a W3C Recommendation) at
+.br
+http://www.w3.org/TR/REC-png.html
+.SH AUTHORS
+This man page: Glenn Randers-Pehrson
+.LP
+Portable Network Graphics (PNG) Specification Version 1.0 (October 1, 1996):
+Thomas Boutell and others (png-list@dworkin.wustl.edu).
+.LP
+
+.SH COPYRIGHT NOTICE
+The PNG specification is copyright (c) 1996 Massachussets Institute of
+Technology.  See the specification for conditions of use and distribution.
+.LP
+.\" end of man page
+

src/png/png.c

@@ -0,0 +1,359 @@
+
+/* png.c - location for general purpose libpng functions
+ *
+ * libpng version 1.0.3 - January 14, 1999
+ * Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
+ * Copyright (c) 1996, 1997 Andreas Dilger
+ * Copyright (c) 1998, 1999 Glenn Randers-Pehrson
+ * 
+ */
+
+#define PNG_INTERNAL
+#define PNG_NO_EXTERN
+#include "png.h"
+
+/* Version information for C files.  This had better match the version
+ * string defined in png.h.
+ */
+
+char png_libpng_ver[12] = "1.0.3";
+
+/* Place to hold the signature string for a PNG file. */
+png_byte FARDATA png_sig[8] = {137, 80, 78, 71, 13, 10, 26, 10};
+
+/* Constant strings for known chunk types.  If you need to add a chunk,
+ * add a string holding the name here.  If you want to make the code
+ * portable to EBCDIC machines, use ASCII numbers, not characters.
+ */
+png_byte FARDATA png_IHDR[5] = { 73,  72,  68,  82, '\0'};
+png_byte FARDATA png_IDAT[5] = { 73,  68,  65,  84, '\0'};
+png_byte FARDATA png_IEND[5] = { 73,  69,  78,  68, '\0'};
+png_byte FARDATA png_PLTE[5] = { 80,  76,  84,  69, '\0'};
+png_byte FARDATA png_bKGD[5] = { 98,  75,  71,  68, '\0'};
+png_byte FARDATA png_cHRM[5] = { 99,  72,  82,  77, '\0'};
+png_byte FARDATA png_gAMA[5] = {103,  65,  77,  65, '\0'};
+png_byte FARDATA png_hIST[5] = {104,  73,  83,  84, '\0'};
+png_byte FARDATA png_oFFs[5] = {111,  70,  70, 115, '\0'};
+png_byte FARDATA png_pCAL[5] = {112,  67,  65,  76, '\0'};
+png_byte FARDATA png_pHYs[5] = {112,  72,  89, 115, '\0'};
+png_byte FARDATA png_sBIT[5] = {115,  66,  73,  84, '\0'};
+png_byte FARDATA png_sRGB[5] = {115,  82,  71,  66, '\0'};
+png_byte FARDATA png_tEXt[5] = {116,  69,  88, 116, '\0'};
+png_byte FARDATA png_tIME[5] = {116,  73,  77,  69, '\0'};
+png_byte FARDATA png_tRNS[5] = {116,  82,  78,  83, '\0'};
+png_byte FARDATA png_zTXt[5] = {122,  84,  88, 116, '\0'};
+
+/* arrays to facilitate easy interlacing - use pass (0 - 6) as index */
+
+/* start of interlace block */
+int FARDATA png_pass_start[] = {0, 4, 0, 2, 0, 1, 0};
+
+/* offset to next interlace block */
+int FARDATA png_pass_inc[] = {8, 8, 4, 4, 2, 2, 1};
+
+/* start of interlace block in the y direction */
+int FARDATA png_pass_ystart[] = {0, 0, 4, 0, 2, 0, 1};
+
+/* offset to next interlace block in the y direction */
+int FARDATA png_pass_yinc[] = {8, 8, 8, 4, 4, 2, 2};
+
+/* Width of interlace block.  This is not currently used - if you need
+ * it, uncomment it here and in png.h
+int FARDATA png_pass_width[] = {8, 4, 4, 2, 2, 1, 1};
+*/
+
+/* Height of interlace block.  This is not currently used - if you need
+ * it, uncomment it here and in png.h
+int FARDATA png_pass_height[] = {8, 8, 4, 4, 2, 2, 1};
+*/
+
+/* Mask to determine which pixels are valid in a pass */
+int FARDATA png_pass_mask[] = {0x80, 0x08, 0x88, 0x22, 0xaa, 0x55, 0xff};
+
+/* Mask to determine which pixels to overwrite while displaying */
+int FARDATA png_pass_dsp_mask[] = {0xff, 0x0f, 0xff, 0x33, 0xff, 0x55, 0xff};
+
+
+/* Tells libpng that we have already handled the first "num_bytes" bytes
+ * of the PNG file signature.  If the PNG data is embedded into another
+ * stream we can set num_bytes = 8 so that libpng will not attempt to read
+ * or write any of the magic bytes before it starts on the IHDR.
+ */
+void
+png_set_sig_bytes(png_structp png_ptr, int num_bytes)
+{
+   png_debug(1, "in png_set_sig_bytes\n");
+   if (num_bytes > 8)
+      png_error(png_ptr, "Too many bytes for PNG signature.");
+
+   png_ptr->sig_bytes = num_bytes < 0 ? 0 : num_bytes;
+}
+
+/* Checks whether the supplied bytes match the PNG signature.  We allow
+ * checking less than the full 8-byte signature so that those apps that
+ * already read the first few bytes of a file to determine the file type
+ * can simply check the remaining bytes for extra assurance.  Returns
+ * an integer less than, equal to, or greater than zero if sig is found,
+ * respectively, to be less than, to match, or be greater than the correct
+ * PNG signature (this is the same behaviour as strcmp, memcmp, etc).
+ */
+int
+png_sig_cmp(png_bytep sig, png_size_t start, png_size_t num_to_check)
+{
+   if (num_to_check > 8)
+      num_to_check = 8;
+   else if (num_to_check < 1)
+      return (0);
+
+   if (start > 7)
+      return (0);
+
+   if (start + num_to_check > 8)
+      num_to_check = 8 - start;
+
+   return ((int)(png_memcmp(&sig[start], &png_sig[start], num_to_check)));
+}
+
+/* (Obsolete) function to check signature bytes.  It does not allow one
+ * to check a partial signature.  This function might be removed in the
+ * future - use png_sig_cmp().  Returns true (nonzero) if the file is a PNG.
+ */
+int
+png_check_sig(png_bytep sig, int num)
+{
+  return ((int)!png_sig_cmp(sig, (png_size_t)0, (png_size_t)num));
+}
+
+/* Function to allocate memory for zlib. */
+voidpf
+png_zalloc(voidpf png_ptr, uInt items, uInt size)
+{
+   png_uint_32 num_bytes = (png_uint_32)items * size;
+   png_voidp ptr = (png_voidp)png_malloc((png_structp)png_ptr, num_bytes);
+
+   if (num_bytes > (png_uint_32)0x8000L)
+   {
+      png_memset(ptr, 0, (png_size_t)0x8000L);
+      png_memset((png_bytep)ptr + (png_size_t)0x8000L, 0,
+         (png_size_t)(num_bytes - (png_uint_32)0x8000L));
+   }
+   else
+   {
+      png_memset(ptr, 0, (png_size_t)num_bytes);
+   }
+   return ((voidpf)ptr);
+}
+
+/* function to free memory for zlib */
+void
+png_zfree(voidpf png_ptr, voidpf ptr)
+{
+   png_free((png_structp)png_ptr, (png_voidp)ptr);
+}
+
+/* Reset the CRC variable to 32 bits of 1's.  Care must be taken
+ * in case CRC is > 32 bits to leave the top bits 0.
+ */
+void
+png_reset_crc(png_structp png_ptr)
+{
+   png_ptr->crc = crc32(0, Z_NULL, 0);
+}
+
+/* Calculate the CRC over a section of data.  We can only pass as
+ * much data to this routine as the largest single buffer size.  We
+ * also check that this data will actually be used before going to the
+ * trouble of calculating it.
+ */
+void
+png_calculate_crc(png_structp png_ptr, png_bytep ptr, png_size_t length)
+{
+   int need_crc = 1;
+
+   if (png_ptr->chunk_name[0] & 0x20)                     /* ancillary */
+   {
+      if ((png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_MASK) ==
+          (PNG_FLAG_CRC_ANCILLARY_USE | PNG_FLAG_CRC_ANCILLARY_NOWARN))
+         need_crc = 0;
+   }
+   else                                                    /* critical */
+   {
+      if (png_ptr->flags & PNG_FLAG_CRC_CRITICAL_IGNORE)
+         need_crc = 0;
+   }
+
+   if (need_crc)
+      png_ptr->crc = crc32(png_ptr->crc, ptr, (uInt)length);
+}
+
+/* Allocate the memory for an info_struct for the application.  We don't
+ * really need the png_ptr, but it could potentially be useful in the
+ * future.  This should be used in favour of malloc(sizeof(png_info))
+ * and png_info_init() so that applications that want to use a shared
+ * libpng don't have to be recompiled if png_info changes size.
+ */
+png_infop
+png_create_info_struct(png_structp png_ptr)
+{
+   png_infop info_ptr;
+
+   png_debug(1, "in png_create_info_struct\n");
+   if(png_ptr == NULL) return (NULL);
+#ifdef PNG_USER_MEM_SUPPORTED
+   if ((info_ptr = (png_infop)png_create_struct_2(PNG_STRUCT_INFO,
+      png_ptr->malloc_fn)) != NULL)
+#else
+   if ((info_ptr = (png_infop)png_create_struct(PNG_STRUCT_INFO)) != NULL)
+#endif
+   {
+      png_info_init(info_ptr);
+   }
+
+   return (info_ptr);
+}
+
+/* This function frees the memory associated with a single info struct.
+ * Normally, one would use either png_destroy_read_struct() or
+ * png_destroy_write_struct() to free an info struct, but this may be
+ * useful for some applications.
+ */
+void
+png_destroy_info_struct(png_structp png_ptr, png_infopp info_ptr_ptr)
+{
+   png_infop info_ptr = NULL;
+
+   png_debug(1, "in png_destroy_info_struct\n");
+   if (info_ptr_ptr != NULL)
+      info_ptr = *info_ptr_ptr;
+
+   if (info_ptr != NULL)
+   {
+      png_info_destroy(png_ptr, info_ptr);
+
+#ifdef PNG_USER_MEM_SUPPORTED
+      png_destroy_struct_2((png_voidp)info_ptr, png_ptr->free_fn);
+#else
+      png_destroy_struct((png_voidp)info_ptr);
+#endif
+      *info_ptr_ptr = (png_infop)NULL;
+   }
+}
+
+/* Initialize the info structure.  This is now an internal function (0.89)
+ * and applications using it are urged to use png_create_info_struct()
+ * instead.
+ */
+void
+png_info_init(png_infop info_ptr)
+{
+   png_debug(1, "in png_info_init\n");
+   /* set everything to 0 */
+   png_memset(info_ptr, 0, sizeof (png_info));
+}
+
+/* This is an internal routine to free any memory that the info struct is
+ * pointing to before re-using it or freeing the struct itself.  Recall
+ * that png_free() checks for NULL pointers for us.
+ */
+void
+png_info_destroy(png_structp png_ptr, png_infop info_ptr)
+{
+#if defined(PNG_READ_tEXt_SUPPORTED) || defined(PNG_READ_zTXt_SUPPORTED)
+   png_debug(1, "in png_info_destroy\n");
+   if (info_ptr->text != NULL)
+   {
+      int i;
+      for (i = 0; i < info_ptr->num_text; i++)
+      {
+         png_free(png_ptr, info_ptr->text[i].key);
+      }
+      png_free(png_ptr, info_ptr->text);
+   }
+#endif
+#if defined(PNG_READ_pCAL_SUPPORTED)
+   png_free(png_ptr, info_ptr->pcal_purpose);
+   png_free(png_ptr, info_ptr->pcal_units);
+   if (info_ptr->pcal_params != NULL)
+   {
+      int i;
+      for (i = 0; i < (int)info_ptr->pcal_nparams; i++)
+      {
+         png_free(png_ptr, info_ptr->pcal_params[i]);
+      }
+      png_free(png_ptr, info_ptr->pcal_params);
+   }
+#endif
+
+   png_info_init(info_ptr);
+}
+
+/* This function returns a pointer to the io_ptr associated with the user
+ * functions.  The application should free any memory associated with this
+ * pointer before png_write_destroy() or png_read_destroy() are called.
+ */
+png_voidp
+png_get_io_ptr(png_structp png_ptr)
+{
+   return (png_ptr->io_ptr);
+}
+
+#if !defined(PNG_NO_STDIO)
+/* Initialize the default input/output functions for the PNG file.  If you
+ * use your own read or write routines, you can call either png_set_read_fn()
+ * or png_set_write_fn() instead of png_init_io().
+ */
+void
+png_init_io(png_structp png_ptr, FILE *fp)
+{
+   png_debug(1, "in png_init_io\n");
+   png_ptr->io_ptr = (png_voidp)fp;
+}
+#endif
+
+#if defined(PNG_TIME_RFC1123_SUPPORTED)
+/* Convert the supplied time into an RFC 1123 string suitable for use in
+ * a "Creation Time" or other text-based time string.
+ */
+png_charp
+png_convert_to_rfc1123(png_structp png_ptr, png_timep ptime)
+{
+   static PNG_CONST char short_months[12][4] =
+        {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
+         "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
+
+   if (png_ptr->time_buffer == NULL)
+   {
+      png_ptr->time_buffer = (png_charp)png_malloc(png_ptr, (png_uint_32)(29*
+         sizeof(char)));
+   }
+
+#ifdef USE_FAR_KEYWORD
+   {
+      char near_time_buf[29];
+      sprintf(near_time_buf, "%d %s %d %02d:%02d:%02d +0000",
+               ptime->day % 32, short_months[(ptime->month - 1) % 12],
+               ptime->year, ptime->hour % 24, ptime->minute % 60,
+               ptime->second % 61);
+      png_memcpy(png_ptr->time_buffer, near_time_buf,
+      29*sizeof(char));
+   }
+#else
+   sprintf(png_ptr->time_buffer, "%d %s %d %02d:%02d:%02d +0000",
+               ptime->day % 32, short_months[(ptime->month - 1) % 12],
+               ptime->year, ptime->hour % 24, ptime->minute % 60,
+               ptime->second % 61);
+#endif
+   return ((png_charp)png_ptr->time_buffer);
+}
+#endif /* PNG_TIME_RFC1123_SUPPORTED */
+
+png_charp
+png_get_copyright(png_structp png_ptr)
+{
+   if(png_ptr == NULL)
+     /* silence compiler warning about unused png_ptr */ ;
+   return("\n libpng version 1.0.3 - January 14, 1999\n\
+   Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.\n\
+   Copyright (c) 1996, 1997 Andreas Dilger\n\
+   Copyright (c) 1998, 1999, Glenn Randers-Pehrson\n");
+}

src/png/png.dsp

@@ -0,0 +1,160 @@
+# Microsoft Developer Studio Project File - Name="png" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Static Library" 0x0104
+
+CFG=png - Win32 Debug
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE 
+!MESSAGE NMAKE /f "PngVC.mak".
+!MESSAGE 
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE 
+!MESSAGE NMAKE /f "PngVC.mak" CFG="png - Win32 Debug"
+!MESSAGE 
+!MESSAGE Possible choices for configuration are:
+!MESSAGE 
+!MESSAGE "png - Win32 Release" (based on "Win32 (x86) Static Library")
+!MESSAGE "png - Win32 Debug" (based on "Win32 (x86) Static Library")
+!MESSAGE 
+
+# Begin Project
+# PROP AllowPerConfigDependencies 0
+# PROP Scc_ProjName "PngVC"
+# PROP Scc_LocalPath "."
+CPP=cl.exe
+RSC=rc.exe
+
+!IF  "$(CFG)" == "png - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "Release"
+# PROP BASE Intermediate_Dir "Release"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "Release"
+# PROP Intermediate_Dir "Release"
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_MBCS" /D "_LIB" /YX /FD /c
+# ADD CPP /nologo /MD /W1 /O1 /I "..\zlib" /D "WIN32" /D "_WINDOWS" /D "__WINDOWS__" /D "__WXMSW__" /D "__WIN95__" /D "__WIN32__" /D WINVER=0x0400 /D "STRICT" /YX /FD /c
+# ADD BASE RSC /l 0x809 /d "NDEBUG"
+# ADD RSC /l 0x809 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LIB32=link.exe -lib
+# ADD BASE LIB32 /nologo
+# ADD LIB32 /nologo /out:"..\..\lib\png.lib"
+
+!ELSEIF  "$(CFG)" == "png - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "Debug"
+# PROP BASE Intermediate_Dir "Debug"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "Debug"
+# PROP Intermediate_Dir "Debug"
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_MBCS" /D "_LIB" /YX /FD /GZ /c
+# ADD CPP /nologo /MDd /W1 /Gm /Zi /Od /I "..\zlib" /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "__WINDOWS__" /D "__WXMSW__" /D "__WXDEBUG__" /D "__WIN95__" /D "__WIN32__" /D WINVER=0x0400 /D "STRICT" /YX /FD /GZ /c
+# ADD BASE RSC /l 0x809 /d "_DEBUG"
+# ADD RSC /l 0x809 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LIB32=link.exe -lib
+# ADD BASE LIB32 /nologo
+# ADD LIB32 /nologo /out:"..\..\lib\pngd.lib"
+
+!ENDIF 
+
+# Begin Target
+
+# Name "png - Win32 Release"
+# Name "png - Win32 Debug"
+# Begin Group "Source Files"
+
+# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
+# Begin Source File
+
+SOURCE=.\png.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\pngerror.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\pngget.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\pngmem.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\pngpread.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\pngread.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\pngrio.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\pngrtran.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\pngrutil.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\pngset.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\pngtrans.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\pngwio.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\pngwrite.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\pngwtran.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\pngwutil.c
+# End Source File
+# End Group
+# Begin Group "Header Files"
+
+# PROP Default_Filter "h;hpp;hxx;hm;inl"
+# Begin Source File
+
+SOURCE=.\png.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\pngconf.h
+# End Source File
+# End Group
+# End Target
+# End Project

src/png/png.dsw

@@ -0,0 +1,29 @@
+Microsoft Developer Studio Workspace File, Format Version 6.00
+# WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE!
+
+###############################################################################
+
+Project: "png"=.\PngVC.dsp - Package Owner=<4>
+
+Package=<5>
+{{{
+}}}
+
+Package=<4>
+{{{
+}}}
+
+###############################################################################
+
+Global:
+
+Package=<5>
+{{{
+}}}
+
+Package=<3>
+{{{
+}}}
+
+###############################################################################
+

src/png/pngconf.h

@@ -0,0 +1,705 @@
+
+/* pngconf.h - machine configurable file for libpng
+ *
+ * libpng 1.0.3 - January 14, 1999
+ * For conditions of distribution and use, see copyright notice in png.h
+ * Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
+ * Copyright (c) 1996, 1997 Andreas Dilger
+ * Copyright (c) 1998, 1999 Glenn Randers-Pehrson
+ */
+
+/* Any machine specific code is near the front of this file, so if you
+ * are configuring libpng for a machine, you may want to read the section
+ * starting here down to where it starts to typedef png_color, png_text,
+ * and png_info.
+ */
+
+#ifndef PNGCONF_H
+#define PNGCONF_H
+
+
+/* This is the size of the compression buffer, and thus the size of
+ * an IDAT chunk.  Make this whatever size you feel is best for your
+ * machine.  One of these will be allocated per png_struct.  When this
+ * is full, it writes the data to the disk, and does some other
+ * calculations.  Making this an extremely small size will slow
+ * the library down, but you may want to experiment to determine
+ * where it becomes significant, if you are concerned with memory
+ * usage.  Note that zlib allocates at least 32Kb also.  For readers,
+ * this describes the size of the buffer available to read the data in.
+ * Unless this gets smaller than the size of a row (compressed),
+ * it should not make much difference how big this is.
+ */
+
+#ifndef PNG_ZBUF_SIZE
+#define PNG_ZBUF_SIZE 8192
+#endif
+
+/* If you are running on a machine where you cannot allocate more
+ * than 64K of memory at once, uncomment this.  While libpng will not
+ * normally need that much memory in a chunk (unless you load up a very
+ * large file), zlib needs to know how big of a chunk it can use, and
+ * libpng thus makes sure to check any memory allocation to verify it
+ * will fit into memory.
+#define PNG_MAX_MALLOC_64K
+ */
+#if defined(MAXSEG_64K) && !defined(PNG_MAX_MALLOC_64K)
+#define PNG_MAX_MALLOC_64K
+#endif
+
+/* This protects us against compilers that run on a windowing system
+ * and thus don't have or would rather us not use the stdio types:
+ * stdin, stdout, and stderr.  The only one currently used is stderr
+ * in png_error() and png_warning().  #defining PNG_NO_CONSOLE_IO will
+ * prevent these from being compiled and used. #defining PNG_NO_STDIO
+ * will also prevent these, plus will prevent the entire set of stdio
+ * macros and functions (FILE *, printf, etc.) from being compiled and used,
+ * unless PNG_DEBUG has been #defined.
+ *
+ * #define PNG_NO_CONSOLE_IO
+ * #define PNG_NO_STDIO
+ */
+
+#ifdef PNG_DEBUG
+#  if (PNG_DEBUG > 0)
+#    include <stdio.h>
+#  endif
+#else
+#  ifdef PNG_NO_STDIO
+#    ifndef PNG_NO_CONSOLE_IO
+#      define PNG_NO_CONSOLE_IO
+#    endif
+#  else
+#    include <stdio.h>
+#  endif
+#endif
+
+/* This macro protects us against machines that don't have function
+ * prototypes (ie K&R style headers).  If your compiler does not handle
+ * function prototypes, define this macro and use the included ansi2knr.
+ * I've always been able to use _NO_PROTO as the indicator, but you may
+ * need to drag the empty declaration out in front of here, or change the
+ * ifdef to suit your own needs.
+ */
+#ifndef PNGARG
+
+#ifdef OF /* zlib prototype munger */
+#define PNGARG(arglist) OF(arglist)
+#else
+
+#ifdef _NO_PROTO
+#define PNGARG(arglist) ()
+#else
+#define PNGARG(arglist) arglist
+#endif /* _NO_PROTO */
+
+#endif /* OF */
+
+#endif /* PNGARG */
+
+/* Try to determine if we are compiling on a Mac.  Note that testing for
+ * just __MWERKS__ is not good enough, because the Codewarrior is now used
+ * on non-Mac platforms.
+ */
+#ifndef MACOS
+#if (defined(__MWERKS__) && defined(macintosh)) || defined(applec) || \
+    defined(THINK_C) || defined(__SC__) || defined(TARGET_OS_MAC)
+#define MACOS
+#endif
+#endif
+
+/* enough people need this for various reasons to include it here */
+#if !defined(MACOS) && !defined(RISCOS)
+#include <sys/types.h>
+#endif
+
+/* This is an attempt to force a single setjmp behaviour on Linux.  If
+ * the X config stuff didn't define _BSD_SOURCE we wouldn't need this.
+ */
+#ifdef __linux__
+#ifdef _BSD_SOURCE
+#define _PNG_SAVE_BSD_SOURCE
+#undef _BSD_SOURCE
+#endif
+#ifdef _SETJMP_H
+__png.h__ already includes setjmp.h
+__dont__ include it again
+#endif
+#endif /* __linux__ */
+
+/* include setjmp.h for error handling */
+#include <setjmp.h>
+
+#ifdef __linux__
+#ifdef _PNG_SAVE_BSD_SOURCE
+#define _BSD_SOURCE
+#undef _PNG_SAVE_BSD_SOURCE
+#endif
+#endif /* __linux__ */
+
+#ifdef BSD
+#include <strings.h>
+#else
+#include <string.h>
+#endif
+
+/* Other defines for things like memory and the like can go here.  */
+#ifdef PNG_INTERNAL
+#include <stdlib.h>
+
+/* The functions exported by PNG_EXTERN are PNG_INTERNAL functions, which
+ * aren't usually used outside the library (as far as I know), so it is
+ * debatable if they should be exported at all.  In the future, when it is
+ * possible to have run-time registry of chunk-handling functions, some of
+ * these will be made available again.
+#define PNG_EXTERN extern
+ */
+#define PNG_EXTERN
+
+/* Other defines specific to compilers can go here.  Try to keep
+ * them inside an appropriate ifdef/endif pair for portability.
+ */
+
+#if defined(MACOS)
+/* We need to check that <math.h> hasn't already been included earlier
+ * as it seems it doesn't agree with <fp.h>, yet we should really use
+ * <fp.h> if possible.
+ */
+#if !defined(__MATH_H__) && !defined(__MATH_H) && !defined(__cmath__)
+#include <fp.h>
+#endif
+#else
+#include <math.h>
+#endif
+
+/* Codewarrior on NT has linking problems without this. */
+#if defined(__MWERKS__) && defined(WIN32)
+#define PNG_ALWAYS_EXTERN
+#endif
+
+/* For some reason, Borland C++ defines memcmp, etc. in mem.h, not
+ * stdlib.h like it should (I think).  Or perhaps this is a C++
+ * "feature"?
+ */
+#ifdef __TURBOC__
+#include <mem.h>
+#include "alloc.h"
+#endif
+
+#ifdef _MSC_VER
+#include <malloc.h>
+#endif
+
+/* This controls how fine the dithering gets.  As this allocates
+ * a largish chunk of memory (32K), those who are not as concerned
+ * with dithering quality can decrease some or all of these.
+ */
+#ifndef PNG_DITHER_RED_BITS
+#define PNG_DITHER_RED_BITS 5
+#endif
+#ifndef PNG_DITHER_GREEN_BITS
+#define PNG_DITHER_GREEN_BITS 5
+#endif
+#ifndef PNG_DITHER_BLUE_BITS
+#define PNG_DITHER_BLUE_BITS 5
+#endif
+
+/* This controls how fine the gamma correction becomes when you
+ * are only interested in 8 bits anyway.  Increasing this value
+ * results in more memory being used, and more pow() functions
+ * being called to fill in the gamma tables.  Don't set this value
+ * less then 8, and even that may not work (I haven't tested it).
+ */
+
+#ifndef PNG_MAX_GAMMA_8
+#define PNG_MAX_GAMMA_8 11
+#endif
+
+/* This controls how much a difference in gamma we can tolerate before
+ * we actually start doing gamma conversion.
+ */
+#ifndef PNG_GAMMA_THRESHOLD
+#define PNG_GAMMA_THRESHOLD 0.05
+#endif
+
+#endif /* PNG_INTERNAL */
+
+/* The following uses const char * instead of char * for error
+ * and warning message functions, so some compilers won't complain.
+ * If you do not want to use const, define PNG_NO_CONST here.
+ */
+
+#ifndef PNG_NO_CONST
+#  define PNG_CONST const
+#else
+#  define PNG_CONST
+#endif
+
+/* The following defines give you the ability to remove code from the
+ * library that you will not be using.  I wish I could figure out how to
+ * automate this, but I can't do that without making it seriously hard
+ * on the users.  So if you are not using an ability, change the #define
+ * to and #undef, and that part of the library will not be compiled.  If
+ * your linker can't find a function, you may want to make sure the
+ * ability is defined here.  Some of these depend upon some others being
+ * defined.  I haven't figured out all the interactions here, so you may
+ * have to experiment awhile to get everything to compile.  If you are
+ * creating or using a shared library, you probably shouldn't touch this,
+ * as it will affect the size of the structures, and this will cause bad
+ * things to happen if the library and/or application ever change.
+ */
+
+/* Any transformations you will not be using can be undef'ed here */
+
+/* GR-P, 0.96a: Set "*TRANSFORMS_SUPPORTED as default but allow user
+   to turn it off with "*TRANSFORMS_NOT_SUPPORTED" or *PNG_NO_*_TRANSFORMS
+   on the compile line, then pick and choose which ones to define without
+   having to edit this file. It is safe to use the *TRANSFORMS_NOT_SUPPORTED
+   if you only want to have a png-compliant reader/writer but don't need
+   any of the extra transformations.  This saves about 80 kbytes in a
+   typical installation of the library. (PNG_NO_* form added in version
+   1.0.1c, for consistency)
+ */
+
+
+#if !defined(PNG_READ_TRANSFORMS_NOT_SUPPORTED) && \
+    !defined(PNG_NO_READ_TRANSFORMS)
+#define PNG_READ_TRANSFORMS_SUPPORTED
+#endif
+#if !defined(PNG_WRITE_TRANSFORMS_NOT_SUPPORTED) && \
+    !defined(PNG_NO_WRITE_TRANSFORMS)
+#define PNG_WRITE_TRANSFORMS_SUPPORTED
+#endif
+
+#ifdef PNG_READ_TRANSFORMS_SUPPORTED
+#ifndef PNG_NO_READ_EXPAND
+#define PNG_READ_EXPAND_SUPPORTED
+#endif
+#ifndef PNG_NO_READ_SHIFT
+#define PNG_READ_SHIFT_SUPPORTED
+#endif
+#ifndef PNG_NO_READ_PACK
+#define PNG_READ_PACK_SUPPORTED
+#endif
+#ifndef PNG_NO_READ_BGR
+#define PNG_READ_BGR_SUPPORTED
+#endif
+#ifndef PNG_NO_READ_SWAP
+#define PNG_READ_SWAP_SUPPORTED
+#endif
+#ifndef PNG_NO_READ_PACKSWAP
+#define PNG_READ_PACKSWAP_SUPPORTED
+#endif
+#ifndef PNG_NO_READ_INVERT
+#define PNG_READ_INVERT_SUPPORTED
+#endif
+#ifndef PNG_NO_READ_DITHER
+#define PNG_READ_DITHER_SUPPORTED
+#endif
+#ifndef PNG_NO_READ_BACKGROUND
+#define PNG_READ_BACKGROUND_SUPPORTED
+#endif
+#ifndef PNG_NO_READ_16_TO_8
+#define PNG_READ_16_TO_8_SUPPORTED
+#endif
+#ifndef PNG_NO_READ_FILLER
+#define PNG_READ_FILLER_SUPPORTED
+#endif
+#ifndef PNG_NO_READ_GAMMA
+#define PNG_READ_GAMMA_SUPPORTED
+#endif
+#ifndef PNG_NO_READ_GRAY_TO_RGB
+#define PNG_READ_GRAY_TO_RGB_SUPPORTED
+#endif
+#ifndef PNG_NO_READ_SWAP_ALPHA
+#define PNG_READ_SWAP_ALPHA_SUPPORTED
+#endif
+#ifndef PNG_NO_READ_INVERT_ALPHA
+#define PNG_READ_INVERT_ALPHA_SUPPORTED
+#endif
+#ifndef PNG_NO_READ_STRIP_ALPHA
+#define PNG_READ_STRIP_ALPHA_SUPPORTED
+#endif
+#ifndef PNG_NO_READ_USER_TRANSFORM
+#define PNG_READ_USER_TRANSFORM_SUPPORTED
+#endif
+#ifndef PNG_NO_READ_RGB_TO_GRAY
+#define PNG_READ_RGB_TO_GRAY_SUPPORTED
+#endif
+#endif /* PNG_READ_TRANSFORMS_SUPPORTED */
+
+#if !defined(PNG_NO_PROGRESSIVE_READ) && \
+ !defined(PNG_PROGRESSIVE_READ_NOT_SUPPORTED) /* if you don't do progressive   */
+#define PNG_PROGRESSIVE_READ_SUPPORTED       /* reading.  This is not talking */
+#endif                               /* about interlacing capability!  You'll */
+              /* still have interlacing unless you change the following line: */
+#define PNG_READ_INTERLACING_SUPPORTED /* required for PNG-compliant decoders */
+
+#ifndef PNG_NO_READ_COMPOSITED_NODIV
+#define PNG_READ_COMPOSITE_NODIV_SUPPORTED    /* well tested on Intel and SGI */
+#endif
+
+#ifdef PNG_WRITE_TRANSFORMS_SUPPORTED
+#ifndef PNG_NO_WRITE_SHIFT
+#define PNG_WRITE_SHIFT_SUPPORTED
+#endif
+#ifndef PNG_NO_WRITE_PACK
+#define PNG_WRITE_PACK_SUPPORTED
+#endif
+#ifndef PNG_NO_WRITE_BGR
+#define PNG_WRITE_BGR_SUPPORTED
+#endif
+#ifndef PNG_NO_WRITE_SWAP
+#define PNG_WRITE_SWAP_SUPPORTED
+#endif
+#ifndef PNG_NO_WRITE_PACKSWAP
+#define PNG_WRITE_PACKSWAP_SUPPORTED
+#endif
+#ifndef PNG_NO_WRITE_INVERT
+#define PNG_WRITE_INVERT_SUPPORTED
+#endif
+#ifndef PNG_NO_WRITE_FILLER
+#define PNG_WRITE_FILLER_SUPPORTED  /* This is the same as WRITE_STRIP_ALPHA */
+#endif
+#ifndef PNG_NO_WRITE_SWAP_ALPHA
+#define PNG_WRITE_SWAP_ALPHA_SUPPORTED
+#endif
+#ifndef PNG_NO_WRITE_INVERT_ALPHA
+#define PNG_WRITE_INVERT_ALPHA_SUPPORTED
+#endif
+#ifndef PNG_NO_WRITE_USER_TRANSFORM
+#define PNG_WRITE_USER_TRANSFORM_SUPPORTED
+#endif
+#endif /* PNG_WRITE_TRANSFORMS_SUPPORTED */
+
+#define PNG_WRITE_INTERLACING_SUPPORTED  /* not required for PNG-compliant
+                                            encoders, but can cause trouble
+                                            if left undefined */
+
+#ifndef PNG_NO_WRITE_WEIGHTED_FILTER
+#define PNG_WRITE_WEIGHTED_FILTER_SUPPORTED
+#endif
+
+#ifndef PNG_NO_WRITE_FLUSH
+#define PNG_WRITE_FLUSH_SUPPORTED
+#endif
+
+#ifndef PNG_NO_STDIO
+#define PNG_TIME_RFC1123_SUPPORTED
+#endif
+
+/* This adds extra functions in pngget.c for accessing data from the
+ * info pointer (added in version 0.99)
+ * png_get_image_width()
+ * png_get_image_height()
+ * png_get_bit_depth()
+ * png_get_color_type()
+ * png_get_compression_type()
+ * png_get_filter_type()
+ * png_get_interlace_type()
+ * png_get_pixel_aspect_ratio()
+ * png_get_pixels_per_meter()
+ * png_get_x_offset_pixels()
+ * png_get_y_offset_pixels()
+ * png_get_x_offset_microns()
+ * png_get_y_offset_microns()
+ */
+#ifndef PNG_NO_EASY_ACCESS
+#define PNG_EASY_ACCESS_SUPPORTED
+#endif
+
+/* These are currently experimental features, define them if you want */
+
+/* very little testing */
+/*
+#define PNG_READ_16_TO_8_ACCURATE_SCALE_SUPPORTED
+#define PNG_USER_MEM_SUPPORTED
+*/
+
+/* This is only for PowerPC big-endian and 680x0 systems */
+/* some testing */
+/*
+#define PNG_READ_BIG_ENDIAN_SUPPORTED
+*/
+
+/* These functions are turned off by default, as they will be phased out. */
+/*
+#define  PNG_USELESS_TESTS_SUPPORTED
+#define  PNG_CORRECT_PALETTE_SUPPORTED
+*/
+
+/* Any chunks you are not interested in, you can undef here.  The
+ * ones that allocate memory may be expecially important (hIST,
+ * tEXt, zTXt, tRNS, pCAL).  Others will just save time and make png_info
+ * a bit smaller.
+ */
+
+#if !defined(PNG_READ_ANCILLARY_CHUNKS_NOT_SUPPORTED) && \
+    !defined(PNG_NO_READ_ANCILLARY_CHUNKS)
+#define PNG_READ_ANCILLARY_CHUNKS_SUPPORTED
+#endif
+#if !defined(PNG_WRITE_ANCILLARY_CHUNKS_NOT_SUPPORTED) && \
+    !defined(PNG_NO_WRITE_ANCILLARY_CHUNKS)
+#define PNG_WRITE_ANCILLARY_CHUNKS_SUPPORTED
+#endif
+
+#ifdef PNG_READ_ANCILLARY_CHUNKS_SUPPORTED
+#ifndef PNG_NO_READ_bKGD
+#define PNG_READ_bKGD_SUPPORTED
+#endif
+#ifndef PNG_NO_READ_cHRM
+#define PNG_READ_cHRM_SUPPORTED
+#endif
+#ifndef PNG_NO_READ_gAMA
+#define PNG_READ_gAMA_SUPPORTED
+#endif
+#ifndef PNG_NO_READ_hIST
+#define PNG_READ_hIST_SUPPORTED
+#endif
+#ifndef PNG_NO_READ_oFFs
+#define PNG_READ_oFFs_SUPPORTED
+#endif
+#ifndef PNG_NO_READ_pCAL
+#define PNG_READ_pCAL_SUPPORTED
+#endif
+#ifndef PNG_NO_READ_pHYs
+#define PNG_READ_pHYs_SUPPORTED
+#endif
+#ifndef PNG_NO_READ_sBIT
+#define PNG_READ_sBIT_SUPPORTED
+#endif
+#ifndef PNG_NO_READ_sRGB
+#define PNG_READ_sRGB_SUPPORTED
+#endif
+#ifndef PNG_NO_READ_tEXt
+#define PNG_READ_tEXt_SUPPORTED
+#endif
+#ifndef PNG_NO_READ_tIME
+#define PNG_READ_tIME_SUPPORTED
+#endif
+#ifndef PNG_NO_READ_tRNS
+#define PNG_READ_tRNS_SUPPORTED
+#endif
+#ifndef PNG_NO_READ_zTXt
+#define PNG_READ_zTXt_SUPPORTED
+#endif
+#ifndef PNG_NO_READ_OPT_PLTE
+#define PNG_READ_OPT_PLTE_SUPPORTED /* only affects support of the optional */
+#endif                              /* PLTE chunk in RGB and RGBA images */
+#endif /* PNG_READ_ANCILLARY_CHUNKS_SUPPORTED */
+
+#ifdef PNG_WRITE_ANCILLARY_CHUNKS_SUPPORTED
+#ifndef PNG_NO_WRITE_bKGD
+#define PNG_WRITE_bKGD_SUPPORTED
+#endif
+#ifndef PNG_NO_WRITE_cHRM
+#define PNG_WRITE_cHRM_SUPPORTED
+#endif
+#ifndef PNG_NO_WRITE_gAMA
+#define PNG_WRITE_gAMA_SUPPORTED
+#endif
+#ifndef PNG_NO_WRITE_hIST
+#define PNG_WRITE_hIST_SUPPORTED
+#endif
+#ifndef PNG_NO_WRITE_oFFs
+#define PNG_WRITE_oFFs_SUPPORTED
+#endif
+#ifndef PNG_NO_WRITE_pCAL
+#define PNG_WRITE_pCAL_SUPPORTED
+#endif
+#ifndef PNG_NO_WRITE_pHYs
+#define PNG_WRITE_pHYs_SUPPORTED
+#endif
+#ifndef PNG_NO_WRITE_sBIT
+#define PNG_WRITE_sBIT_SUPPORTED
+#endif
+#ifndef PNG_NO_WRITE_sRGB
+#define PNG_WRITE_sRGB_SUPPORTED
+#endif
+#ifndef PNG_NO_WRITE_tEXt
+#define PNG_WRITE_tEXt_SUPPORTED
+#endif
+#ifndef PNG_NO_WRITE_tIME
+#define PNG_WRITE_tIME_SUPPORTED
+#endif
+#ifndef PNG_NO_WRITE_tRNS
+#define PNG_WRITE_tRNS_SUPPORTED
+#endif
+#ifndef PNG_NO_WRITE_zTXt
+#define PNG_WRITE_zTXt_SUPPORTED
+#endif
+#endif /* PNG_WRITE_ANCILLARY_CHUNKS_SUPPORTED */
+
+/* need the time information for reading tIME chunks */
+#if defined(PNG_READ_tIME_SUPPORTED) || defined(PNG_WRITE_tIME_SUPPORTED)
+#include <time.h>
+#endif
+
+/* Some typedefs to get us started.  These should be safe on most of the
+ * common platforms.  The typedefs should be at least as large as the
+ * numbers suggest (a png_uint_32 must be at least 32 bits long), but they
+ * don't have to be exactly that size.  Some compilers dislike passing
+ * unsigned shorts as function parameters, so you may be better off using
+ * unsigned int for png_uint_16.  Likewise, for 64-bit systems, you may
+ * want to have unsigned int for png_uint_32 instead of unsigned long.
+ */
+
+typedef unsigned long png_uint_32;
+typedef long png_int_32;
+typedef unsigned short png_uint_16;
+typedef short png_int_16;
+typedef unsigned char png_byte;
+
+/* This is usually size_t.  It is typedef'ed just in case you need it to
+   change (I'm not sure if you will or not, so I thought I'd be safe) */
+typedef size_t png_size_t;
+
+/* The following is needed for medium model support.  It cannot be in the
+ * PNG_INTERNAL section.  Needs modification for other compilers besides
+ * MSC.  Model independent support declares all arrays and pointers to be
+ * large using the far keyword.  The zlib version used must also support
+ * model independent data.  As of version zlib 1.0.4, the necessary changes
+ * have been made in zlib.  The USE_FAR_KEYWORD define triggers other
+ * changes that are needed. (Tim Wegner)
+ */
+
+/* Separate compiler dependencies (problem here is that zlib.h always
+   defines FAR. (SJT) */
+#ifdef __BORLANDC__
+#if defined(__LARGE__) || defined(__HUGE__) || defined(__COMPACT__)
+#define LDATA 1
+#else
+#define LDATA 0
+#endif
+
+#if !defined(__WIN32__) && !defined(__FLAT__)
+#define PNG_MAX_MALLOC_64K
+#if (LDATA != 1)
+#ifndef FAR
+#define FAR __far
+#endif
+#define USE_FAR_KEYWORD
+#endif   /* LDATA != 1 */
+
+/* Possibly useful for moving data out of default segment.
+ * Uncomment it if you want. Could also define FARDATA as
+ * const if your compiler supports it. (SJT)
+#  define FARDATA FAR
+ */
+#endif  /* __WIN32__, __FLAT__ */
+
+#endif   /* __BORLANDC__ */
+
+
+/* Suggest testing for specific compiler first before testing for
+ * FAR.  The Watcom compiler defines both __MEDIUM__ and M_I86MM,
+ * making reliance oncertain keywords suspect. (SJT)
+ */
+
+/* MSC Medium model */
+#if defined(FAR)
+#  if defined(M_I86MM)
+#     define USE_FAR_KEYWORD
+#     define FARDATA FAR
+#     include <dos.h>
+#  endif
+#endif
+
+/* SJT: default case */
+#ifndef FAR
+#   define FAR
+#endif
+
+/* At this point FAR is always defined */
+#ifndef FARDATA
+#define FARDATA
+#endif
+
+/* Add typedefs for pointers */
+typedef void            FAR * png_voidp;
+typedef png_byte        FAR * png_bytep;
+typedef png_uint_32     FAR * png_uint_32p;
+typedef png_int_32      FAR * png_int_32p;
+typedef png_uint_16     FAR * png_uint_16p;
+typedef png_int_16      FAR * png_int_16p;
+typedef PNG_CONST char  FAR * png_const_charp;
+typedef char            FAR * png_charp;
+typedef double          FAR * png_doublep;
+
+/* Pointers to pointers; i.e. arrays */
+typedef png_byte        FAR * FAR * png_bytepp;
+typedef png_uint_32     FAR * FAR * png_uint_32pp;
+typedef png_int_32      FAR * FAR * png_int_32pp;
+typedef png_uint_16     FAR * FAR * png_uint_16pp;
+typedef png_int_16      FAR * FAR * png_int_16pp;
+typedef PNG_CONST char  FAR * FAR * png_const_charpp;
+typedef char            FAR * FAR * png_charpp;
+typedef double          FAR * FAR * png_doublepp;
+
+/* Pointers to pointers to pointers; i.e. pointer to array */
+typedef char            FAR * FAR * FAR * png_charppp;
+
+/* libpng typedefs for types in zlib. If zlib changes
+ * or another compression library is used, then change these.
+ * Eliminates need to change all the source files.
+ */
+typedef charf *         png_zcharp;
+typedef charf * FAR *   png_zcharpp;
+typedef z_stream FAR *  png_zstreamp;
+
+/* allow for compilation as dll under MS Windows */
+#ifdef __WIN32DLL__
+#define PNG_EXPORT(type,symbol) __declspec(dllexport) type symbol
+#endif
+
+/* allow for compilation as dll with BORLAND C++ 5.0 */
+#if defined(__BORLANDC__) && defined(_Windows) && defined(__DLL__)
+#   define PNG_EXPORT(type,symbol) type _export symbol
+#endif
+
+/* allow for compilation as shared lib under BeOS */
+#ifdef __BEOSDLL__
+#define PNG_EXPORT(type,symbol) __declspec(export) type symbol
+#endif
+
+#ifndef PNG_EXPORT
+#define PNG_EXPORT(type,symbol) type symbol
+#endif
+
+
+/* User may want to use these so not in PNG_INTERNAL. Any library functions
+ * that are passed far data must be model independent.
+ */
+
+#if defined(USE_FAR_KEYWORD)  /* memory model independent fns */
+/* use this to make far-to-near assignments */
+#   define CHECK   1
+#   define NOCHECK 0
+#   define CVT_PTR(ptr) (png_far_to_near(png_ptr,ptr,CHECK))
+#   define CVT_PTR_NOCHECK(ptr) (png_far_to_near(png_ptr,ptr,NOCHECK))
+#   define png_strcpy _fstrcpy
+#   define png_strlen _fstrlen
+#   define png_memcmp _fmemcmp      /* SJT: added */
+#   define png_memcpy _fmemcpy
+#   define png_memset _fmemset
+#else /* use the usual functions */
+#   define CVT_PTR(ptr)         (ptr)
+#   define CVT_PTR_NOCHECK(ptr) (ptr)
+#   define png_strcpy strcpy
+#   define png_strlen strlen
+#   define png_memcmp memcmp     /* SJT: added */
+#   define png_memcpy memcpy
+#   define png_memset memset
+#endif
+/* End of memory model independent support */
+
+/* Just a double check that someone hasn't tried to define something
+ * contradictory.
+ */
+#if (PNG_ZBUF_SIZE > 65536) && defined(PNG_MAX_MALLOC_64K)
+#undef PNG_ZBUF_SIZE
+#define PNG_ZBUF_SIZE 65536
+#endif
+
+#endif /* PNGCONF_H */
+

src/png/pngerror.c

@@ -0,0 +1,172 @@
+
+/* pngerror.c - stub functions for i/o and memory allocation
+ *
+ * libpng 1.0.3 - January 14, 1999
+ * For conditions of distribution and use, see copyright notice in png.h
+ * Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
+ * Copyright (c) 1996, 1997 Andreas Dilger
+ * Copyright (c) 1998, 1999 Glenn Randers-Pehrson
+ *
+ * This file provides a location for all error handling.  Users who
+ * need special error handling are expected to write replacement functions
+ * and use png_set_error_fn() to use those functions.  See the instructions
+ * at each function.
+ */
+
+#define PNG_INTERNAL
+#include "png.h"
+
+static void png_default_error PNGARG((png_structp png_ptr,
+                                      png_const_charp message));
+static void png_default_warning PNGARG((png_structp png_ptr,
+                                        png_const_charp message));
+
+/* This function is called whenever there is a fatal error.  This function
+ * should not be changed.  If there is a need to handle errors differently,
+ * you should supply a replacement error function and use png_set_error_fn()
+ * to replace the error function at run-time.
+ */
+void
+png_error(png_structp png_ptr, png_const_charp message)
+{
+   if (png_ptr->error_fn != NULL)
+      (*(png_ptr->error_fn))(png_ptr, message);
+
+   /* if the following returns or doesn't exist, use the default function,
+      which will not return */
+   png_default_error(png_ptr, message);
+}
+
+/* This function is called whenever there is a non-fatal error.  This function
+ * should not be changed.  If there is a need to handle warnings differently,
+ * you should supply a replacement warning function and use
+ * png_set_error_fn() to replace the warning function at run-time.
+ */
+void
+png_warning(png_structp png_ptr, png_const_charp message)
+{
+   if (png_ptr->warning_fn != NULL)
+      (*(png_ptr->warning_fn))(png_ptr, message);
+   else
+      png_default_warning(png_ptr, message);
+}
+
+/* These utilities are used internally to build an error message that relates
+ * to the current chunk.  The chunk name comes from png_ptr->chunk_name,
+ * this is used to prefix the message.  The message is limited in length
+ * to 63 bytes, the name characters are output as hex digits wrapped in []
+ * if the character is invalid.
+ */
+#define isnonalpha(c) ((c) < 41 || (c) > 122 || ((c) > 90 && (c) < 97))
+static PNG_CONST char png_digit[16] = {
+   '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'
+};
+
+static void
+png_format_buffer(png_structp png_ptr, png_charp buffer, png_const_charp message)
+{
+   int iout = 0, iin = 0;
+
+   while (iin < 4) {
+      int c = png_ptr->chunk_name[iin++];
+      if (isnonalpha(c)) {
+         buffer[iout++] = '[';
+         buffer[iout++] = png_digit[(c & 0xf0) >> 4];
+         buffer[iout++] = png_digit[c & 0xf];
+         buffer[iout++] = ']';
+      } else {
+         buffer[iout++] = c;
+      }
+   }
+
+   if (message == NULL)
+      buffer[iout] = 0;
+   else {
+      buffer[iout++] = ':';
+      buffer[iout++] = ' ';
+      png_memcpy(buffer+iout, message, 64);
+      buffer[iout+63] = 0;
+   }
+}
+
+void
+png_chunk_error(png_structp png_ptr, png_const_charp message)
+{
+   char msg[16+64];
+   png_format_buffer(png_ptr, msg, message);
+   png_error(png_ptr, msg);
+}
+
+void
+png_chunk_warning(png_structp png_ptr, png_const_charp message)
+{
+   char msg[16+64];
+   png_format_buffer(png_ptr, msg, message);
+   png_warning(png_ptr, msg);
+}
+
+/* This is the default error handling function.  Note that replacements for
+ * this function MUST NOT RETURN, or the program will likely crash.  This
+ * function is used by default, or if the program supplies NULL for the
+ * error function pointer in png_set_error_fn().
+ */
+static void
+png_default_error(png_structp png_ptr, png_const_charp message)
+{
+#ifndef PNG_NO_CONSOLE_IO
+   fprintf(stderr, "libpng error: %s\n", message);
+#endif
+
+#ifdef USE_FAR_KEYWORD
+   {
+      jmp_buf jmpbuf;
+      png_memcpy(jmpbuf,png_ptr->jmpbuf,sizeof(jmp_buf));
+      longjmp(jmpbuf, 1);
+   }
+#else
+   longjmp(png_ptr->jmpbuf, 1);
+#endif
+}
+
+/* This function is called when there is a warning, but the library thinks
+ * it can continue anyway.  Replacement functions don't have to do anything
+ * here if you don't want them to.  In the default configuration, png_ptr is
+ * not used, but it is passed in case it may be useful.
+ */
+static void
+png_default_warning(png_structp png_ptr, png_const_charp message)
+{
+#ifndef PNG_NO_CONSOLE_IO
+   fprintf(stderr, "libpng warning: %s\n", message);
+#endif
+   if (png_ptr == NULL)
+      return;
+}
+
+/* This function is called when the application wants to use another method
+ * of handling errors and warnings.  Note that the error function MUST NOT
+ * return to the calling routine or serious problems will occur.  The return
+ * method used in the default routine calls longjmp(png_ptr->jmpbuf, 1)
+ */
+void
+png_set_error_fn(png_structp png_ptr, png_voidp error_ptr,
+   png_error_ptr error_fn, png_error_ptr warning_fn)
+{
+   png_ptr->error_ptr = error_ptr;
+   png_ptr->error_fn = error_fn;
+   png_ptr->warning_fn = warning_fn;
+}
+
+
+/* This function returns a pointer to the error_ptr associated with the user
+ * functions.  The application should free any memory associated with this
+ * pointer before png_write_destroy and png_read_destroy are called.
+ */
+png_voidp
+png_get_error_ptr(png_structp png_ptr)
+{
+   return ((png_voidp)png_ptr->error_ptr);
+}
+
+
+

src/png/pngget.c

@@ -0,0 +1,650 @@
+
+/* pngget.c - retrieval of values from info struct
+ *
+ * libpng 1.0.3 - January 14, 1999
+ * For conditions of distribution and use, see copyright notice in png.h
+ * Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
+ * Copyright (c) 1996, 1997 Andreas Dilger
+ * Copyright (c) 1998, 1999 Glenn Randers-Pehrson
+ */
+
+#define PNG_INTERNAL
+#include "png.h"
+
+png_uint_32
+png_get_valid(png_structp png_ptr, png_infop info_ptr, png_uint_32 flag)
+{
+   if (png_ptr != NULL && info_ptr != NULL)
+      return(info_ptr->valid & flag);
+   else
+      return(0);
+}
+
+png_uint_32
+png_get_rowbytes(png_structp png_ptr, png_infop info_ptr)
+{
+   if (png_ptr != NULL && info_ptr != NULL)
+      return(info_ptr->rowbytes);
+   else
+      return(0);
+}
+
+#ifdef PNG_EASY_ACCESS_SUPPORTED
+/* easy access to info, added in libpng-0.99 */
+png_uint_32
+png_get_image_width(png_structp png_ptr, png_infop info_ptr)
+{
+   if (png_ptr != NULL && info_ptr != NULL)
+   {
+      return info_ptr->width;
+   }
+   return (0);
+}
+
+png_uint_32
+png_get_image_height(png_structp png_ptr, png_infop info_ptr)
+{
+   if (png_ptr != NULL && info_ptr != NULL)
+   {
+      return info_ptr->height;
+   }
+   return (0);
+}
+
+png_byte
+png_get_bit_depth(png_structp png_ptr, png_infop info_ptr)
+{
+   if (png_ptr != NULL && info_ptr != NULL)
+   {
+      return info_ptr->bit_depth;
+   }
+   return (0);
+}
+
+png_byte
+png_get_color_type(png_structp png_ptr, png_infop info_ptr)
+{
+   if (png_ptr != NULL && info_ptr != NULL)
+   {
+      return info_ptr->color_type;
+   }
+   return (0);
+}
+
+png_byte
+png_get_filter_type(png_structp png_ptr, png_infop info_ptr)
+{
+   if (png_ptr != NULL && info_ptr != NULL)
+   {
+      return info_ptr->filter_type;
+   }
+   return (0);
+}
+
+png_byte
+png_get_interlace_type(png_structp png_ptr, png_infop info_ptr)
+{
+   if (png_ptr != NULL && info_ptr != NULL)
+   {
+      return info_ptr->interlace_type;
+   }
+   return (0);
+}
+
+png_byte
+png_get_compression_type(png_structp png_ptr, png_infop info_ptr)
+{
+   if (png_ptr != NULL && info_ptr != NULL)
+   {
+      return info_ptr->compression_type;
+   }
+   return (0);
+}
+
+png_uint_32
+png_get_x_pixels_per_meter(png_structp png_ptr, png_infop info_ptr)
+{
+#if defined(PNG_READ_pHYs_SUPPORTED) || defined(PNG_WRITE_pHYs_SUPPORTED)
+   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_pHYs))
+   {
+      png_debug1(1, "in %s retrieval function\n", "png_get_x_pixels_per_meter");
+      if(info_ptr->phys_unit_type != PNG_RESOLUTION_METER)
+          return (0);
+      else return (info_ptr->x_pixels_per_unit);
+   }
+   else
+#endif
+   return (0);
+}
+
+png_uint_32
+png_get_y_pixels_per_meter(png_structp png_ptr, png_infop info_ptr)
+{
+#if defined(PNG_READ_pHYs_SUPPORTED) || defined(PNG_WRITE_pHYs_SUPPORTED)
+   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_pHYs))
+   {
+      png_debug1(1, "in %s retrieval function\n", "png_get_y_pixels_per_meter");
+      if(info_ptr->phys_unit_type != PNG_RESOLUTION_METER)
+          return (0);
+      else return (info_ptr->y_pixels_per_unit);
+   }
+   else
+#endif
+   return (0);
+}
+
+png_uint_32
+png_get_pixels_per_meter(png_structp png_ptr, png_infop info_ptr)
+{
+#if defined(PNG_READ_pHYs_SUPPORTED) || defined(PNG_WRITE_pHYs_SUPPORTED)
+   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_pHYs))
+   {
+      png_debug1(1, "in %s retrieval function\n", "png_get_pixels_per_meter");
+      if(info_ptr->phys_unit_type != PNG_RESOLUTION_METER ||
+         info_ptr->x_pixels_per_unit != info_ptr->y_pixels_per_unit)
+          return (0);
+      else return (info_ptr->x_pixels_per_unit);
+   }
+   else
+#endif
+   return (0);
+}
+
+float
+png_get_pixel_aspect_ratio(png_structp png_ptr, png_infop info_ptr)
+   {
+#if defined(PNG_READ_pHYs_SUPPORTED) || defined(PNG_WRITE_pHYs_SUPPORTED)
+   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_pHYs))
+   {
+      png_debug1(1, "in %s retrieval function\n", "png_get_aspect_ratio");
+      if (info_ptr->x_pixels_per_unit == 0)
+         return ((float)0.0);
+      else
+         return ((float)info_ptr->y_pixels_per_unit
+            /(float)info_ptr->x_pixels_per_unit);
+   }
+   else
+#endif
+      return ((float)0.0);
+}
+
+png_uint_32
+png_get_x_offset_microns(png_structp png_ptr, png_infop info_ptr)
+{
+#if defined(PNG_READ_oFFs_SUPPORTED) || defined(PNG_WRITE_oFFs_SUPPORTED)
+   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_oFFs))
+   {
+      png_debug1(1, "in %s retrieval function\n", "png_get_x_offset_microns");
+      if(info_ptr->offset_unit_type != PNG_OFFSET_MICROMETER)
+          return (0);
+      else return (info_ptr->x_offset);
+   }
+   else
+#endif
+   return (0);
+}
+
+png_uint_32
+png_get_y_offset_microns(png_structp png_ptr, png_infop info_ptr)
+{
+#if defined(PNG_READ_oFFs_SUPPORTED) || defined(PNG_WRITE_oFFs_SUPPORTED)
+   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_oFFs))
+   {
+      png_debug1(1, "in %s retrieval function\n", "png_get_y_offset_microns");
+      if(info_ptr->offset_unit_type != PNG_OFFSET_MICROMETER)
+          return (0);
+      else return (info_ptr->y_offset);
+   }
+   else
+#endif
+   return (0);
+}
+
+png_uint_32
+png_get_x_offset_pixels(png_structp png_ptr, png_infop info_ptr)
+{
+#if defined(PNG_READ_oFFs_SUPPORTED) || defined(PNG_WRITE_oFFs_SUPPORTED)
+   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_oFFs))
+   {
+      png_debug1(1, "in %s retrieval function\n", "png_get_x_offset_microns");
+      if(info_ptr->offset_unit_type != PNG_OFFSET_PIXEL)
+          return (0);
+      else return (info_ptr->x_offset);
+   }
+   else
+#endif
+   return (0);
+}
+
+png_uint_32
+png_get_y_offset_pixels(png_structp png_ptr, png_infop info_ptr)
+{
+#if defined(PNG_READ_oFFs_SUPPORTED) || defined(PNG_WRITE_oFFs_SUPPORTED)
+   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_oFFs))
+   {
+      png_debug1(1, "in %s retrieval function\n", "png_get_y_offset_microns");
+      if(info_ptr->offset_unit_type != PNG_OFFSET_PIXEL)
+          return (0);
+      else return (info_ptr->y_offset);
+   }
+   else
+#endif
+   return (0);
+}
+
+#ifdef PNG_INCH_CONVERSIONS
+png_uint_32
+png_get_pixels_per_inch(png_structp png_ptr, png_infop info_ptr)
+{
+   return ((png_uint_32)((float)png_get_pixels_per_meter(png_ptr, info_ptr)
+     *.03937 +.5)
+}
+
+png_uint_32
+png_get_x_pixels_per_inch(png_structp png_ptr, png_infop info_ptr)
+{
+   return ((png_uint_32)((float)png_get_x_pixels_per_meter(png_ptr, info_ptr)
+     *.03937 +.5)
+}
+
+png_uint_32
+png_get_y_pixels_per_inch(png_structp png_ptr, png_infop info_ptr)
+{
+   return ((png_uint_32)((float)png_get_y_pixels_per_meter(png_ptr, info_ptr)
+     *.03937 +.5)
+}
+
+float
+png_get_x_offset_inches(png_structp png_ptr, png_infop info_ptr)
+{
+   return ((float)png_get_x_offset_microns(png_ptr, info_ptr)
+     *.03937/1000000. +.5)
+}
+
+float
+png_get_y_offset_inches(png_structp png_ptr, png_infop info_ptr)
+{
+   return ((float)png_get_y_offset_microns(png_ptr, info_ptr)
+     *.03937/1000000. +.5)
+}
+
+#if defined(PNG_READ_pHYs_SUPPORTED)
+png_uint_32
+png_get_pHYs_dpi(png_structp png_ptr, png_infop info_ptr,
+   png_uint_32 *res_x, png_uint_32 *res_y, int *unit_type)
+{
+   png_uint_32 retval = 0;
+
+   if (png_ptr != NULL && info_ptr != NULL && info_ptr->valid & PNG_INFO_pHYs)
+   {
+      png_debug1(1, "in %s retrieval function\n", "pHYs");
+      if (res_x != NULL)
+      {
+         *res_x = info_ptr->x_pixels_per_unit;
+         retval |= PNG_INFO_pHYs;
+      }
+      if (res_y != NULL)
+      {
+         *res_y = info_ptr->y_pixels_per_unit;
+         retval |= PNG_INFO_pHYs;
+      }
+      if (unit_type != NULL)
+      {
+         *unit_type = (int)info_ptr->phys_unit_type;
+         retval |= PNG_INFO_pHYs;
+         if(unit_type == 1)
+         {
+            if (res_x != NULL) *res_x = (png_uint_32)(*res_x * 39.37 + .50);
+            if (res_y != NULL) *res_y = (png_uint_32)(*res_y * 39.37 + .50);
+         }
+      }
+   }
+   return (retval);
+}
+#endif /* PNG_READ_pHYs_SUPPORTED */
+#endif  /* PNG_INCH_CONVERSIONS */
+
+/* png_get_channels really belongs in here, too, but it's been around longer */
+
+#endif  /* PNG_EASY_ACCESS_SUPPORTED */
+
+png_byte
+png_get_channels(png_structp png_ptr, png_infop info_ptr)
+{
+   if (png_ptr != NULL && info_ptr != NULL)
+      return(info_ptr->channels);
+   else
+      return (0);
+}
+
+png_bytep
+png_get_signature(png_structp png_ptr, png_infop info_ptr)
+{
+   if (png_ptr != NULL && info_ptr != NULL)
+      return(info_ptr->signature);
+   else
+      return (NULL);
+}
+
+#if defined(PNG_READ_bKGD_SUPPORTED)
+png_uint_32
+png_get_bKGD(png_structp png_ptr, png_infop info_ptr,
+   png_color_16p *background)
+{
+   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_bKGD)
+      && background != NULL)
+   {
+      png_debug1(1, "in %s retrieval function\n", "bKGD");
+      *background = &(info_ptr->background);
+      return (PNG_INFO_bKGD);
+   }
+   return (0);
+}
+#endif
+
+#if defined(PNG_READ_cHRM_SUPPORTED)
+png_uint_32
+png_get_cHRM(png_structp png_ptr, png_infop info_ptr,
+   double *white_x, double *white_y, double *red_x, double *red_y,
+   double *green_x, double *green_y, double *blue_x, double *blue_y)
+{
+   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_cHRM))
+   {
+      png_debug1(1, "in %s retrieval function\n", "cHRM");
+      if (white_x != NULL)
+         *white_x = (double)info_ptr->x_white;
+      if (white_y != NULL)
+         *white_y = (double)info_ptr->y_white;
+      if (red_x != NULL)
+         *red_x = (double)info_ptr->x_red;
+      if (red_y != NULL)
+         *red_y = (double)info_ptr->y_red;
+      if (green_x != NULL)
+         *green_x = (double)info_ptr->x_green;
+      if (green_y != NULL)
+         *green_y = (double)info_ptr->y_green;
+      if (blue_x != NULL)
+         *blue_x = (double)info_ptr->x_blue;
+      if (blue_y != NULL)
+         *blue_y = (double)info_ptr->y_blue;
+      return (PNG_INFO_cHRM);
+   }
+   return (0);
+}
+#endif
+
+#if defined(PNG_READ_gAMA_SUPPORTED)
+png_uint_32
+png_get_gAMA(png_structp png_ptr, png_infop info_ptr, double *file_gamma)
+{
+   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_gAMA)
+      && file_gamma != NULL)
+   {
+      png_debug1(1, "in %s retrieval function\n", "gAMA");
+      *file_gamma = (double)info_ptr->gamma;
+      return (PNG_INFO_gAMA);
+   }
+   return (0);
+}
+#endif
+
+#if defined(PNG_READ_sRGB_SUPPORTED)
+png_uint_32
+png_get_sRGB(png_structp png_ptr, png_infop info_ptr, int *file_srgb_intent)
+{
+   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_sRGB)
+      && file_srgb_intent != NULL)
+   {
+      png_debug1(1, "in %s retrieval function\n", "sRGB");
+      *file_srgb_intent = (int)info_ptr->srgb_intent;
+      return (PNG_INFO_sRGB);
+   }
+   return (0);
+}
+#endif
+
+#if defined(PNG_READ_hIST_SUPPORTED)
+png_uint_32
+png_get_hIST(png_structp png_ptr, png_infop info_ptr, png_uint_16p *hist)
+{
+   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_hIST)
+      && hist != NULL)
+   {
+      png_debug1(1, "in %s retrieval function\n", "hIST");
+      *hist = info_ptr->hist;
+      return (PNG_INFO_hIST);
+   }
+   return (0);
+}
+#endif
+
+png_uint_32
+png_get_IHDR(png_structp png_ptr, png_infop info_ptr,
+   png_uint_32 *width, png_uint_32 *height, int *bit_depth,
+   int *color_type, int *interlace_type, int *compression_type,
+   int *filter_type)
+
+{
+   if (png_ptr != NULL && info_ptr != NULL && width != NULL && height != NULL &&
+      bit_depth != NULL && color_type != NULL)
+   {
+      int pixel_depth, channels;
+      png_uint_32 rowbytes_per_pixel;
+
+      png_debug1(1, "in %s retrieval function\n", "IHDR");
+      *width = info_ptr->width;
+      *height = info_ptr->height;
+      *bit_depth = info_ptr->bit_depth;
+      *color_type = info_ptr->color_type;
+      if (compression_type != NULL)
+         *compression_type = info_ptr->compression_type;
+      if (filter_type != NULL)
+         *filter_type = info_ptr->filter_type;
+      if (interlace_type != NULL)
+         *interlace_type = info_ptr->interlace_type;
+
+      /* check for potential overflow of rowbytes */
+      if (*color_type == PNG_COLOR_TYPE_PALETTE)
+         channels = 1;
+      else if (*color_type & PNG_COLOR_MASK_COLOR)
+         channels = 3;
+      else
+         channels = 1;
+      if (*color_type & PNG_COLOR_MASK_ALPHA)
+         channels++;
+      pixel_depth = *bit_depth * channels;
+      rowbytes_per_pixel = (pixel_depth + 7) >> 3;
+      if ((*width > (png_uint_32)2147483647L/rowbytes_per_pixel))
+      {
+         png_warning(png_ptr,
+            "Width too large for libpng to process image data.");
+      }
+      return (1);
+   }
+   return (0);
+}
+
+#if defined(PNG_READ_oFFs_SUPPORTED)
+png_uint_32
+png_get_oFFs(png_structp png_ptr, png_infop info_ptr,
+   png_uint_32 *offset_x, png_uint_32 *offset_y, int *unit_type)
+{
+   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_oFFs)
+      && offset_x != NULL && offset_y != NULL && unit_type != NULL)
+   {
+      png_debug1(1, "in %s retrieval function\n", "oFFs");
+      *offset_x = info_ptr->x_offset;
+      *offset_y = info_ptr->y_offset;
+      *unit_type = (int)info_ptr->offset_unit_type;
+      return (PNG_INFO_oFFs);
+   }
+   return (0);
+}
+#endif
+
+#if defined(PNG_READ_pCAL_SUPPORTED)
+png_uint_32
+png_get_pCAL(png_structp png_ptr, png_infop info_ptr,
+   png_charp *purpose, png_int_32 *X0, png_int_32 *X1, int *type, int *nparams,
+   png_charp *units, png_charpp *params)
+{
+   if (png_ptr != NULL && info_ptr != NULL && info_ptr->valid & PNG_INFO_pCAL &&
+      purpose != NULL && X0 != NULL && X1 != NULL && type != NULL &&
+      nparams != NULL && units != NULL && params != NULL)
+   {
+      png_debug1(1, "in %s retrieval function\n", "pCAL");
+      *purpose = info_ptr->pcal_purpose;
+      *X0 = info_ptr->pcal_X0;
+      *X1 = info_ptr->pcal_X1;
+      *type = (int)info_ptr->pcal_type;
+      *nparams = (int)info_ptr->pcal_nparams;
+      *units = info_ptr->pcal_units;
+      *params = info_ptr->pcal_params;
+      return (PNG_INFO_pCAL);
+   }
+   return (0);
+}
+#endif
+
+#if defined(PNG_READ_pHYs_SUPPORTED)
+png_uint_32
+png_get_pHYs(png_structp png_ptr, png_infop info_ptr,
+   png_uint_32 *res_x, png_uint_32 *res_y, int *unit_type)
+{
+   png_uint_32 retval = 0;
+
+   if (png_ptr != NULL && info_ptr != NULL && info_ptr->valid & PNG_INFO_pHYs)
+   {
+      png_debug1(1, "in %s retrieval function\n", "pHYs");
+      if (res_x != NULL)
+      {
+         *res_x = info_ptr->x_pixels_per_unit;
+         retval |= PNG_INFO_pHYs;
+      }
+      if (res_y != NULL)
+      {
+         *res_y = info_ptr->y_pixels_per_unit;
+         retval |= PNG_INFO_pHYs;
+      }
+      if (unit_type != NULL)
+      {
+         *unit_type = (int)info_ptr->phys_unit_type;
+         retval |= PNG_INFO_pHYs;
+      }
+   }
+   return (retval);
+}
+#endif
+
+png_uint_32
+png_get_PLTE(png_structp png_ptr, png_infop info_ptr, png_colorp *palette,
+   int *num_palette)
+{
+   if (png_ptr != NULL && info_ptr != NULL && info_ptr->valid & PNG_INFO_PLTE &&
+       palette != NULL)
+   {
+      png_debug1(1, "in %s retrieval function\n", "PLTE");
+      *palette = info_ptr->palette;
+      *num_palette = info_ptr->num_palette;
+      png_debug1(3, "num_palette = %d\n", *num_palette);
+      return (PNG_INFO_PLTE);
+   }
+   return (0);
+}
+
+#if defined(PNG_READ_sBIT_SUPPORTED)
+png_uint_32
+png_get_sBIT(png_structp png_ptr, png_infop info_ptr, png_color_8p *sig_bit)
+{
+   if (png_ptr != NULL && info_ptr != NULL && info_ptr->valid & PNG_INFO_sBIT &&
+       sig_bit != NULL)
+   {
+      png_debug1(1, "in %s retrieval function\n", "sBIT");
+      *sig_bit = &(info_ptr->sig_bit);
+      return (PNG_INFO_sBIT);
+   }
+   return (0);
+}
+#endif
+
+#if defined(PNG_READ_tEXt_SUPPORTED) || defined(PNG_READ_zTXt_SUPPORTED)
+png_uint_32
+png_get_text(png_structp png_ptr, png_infop info_ptr, png_textp *text_ptr,
+   int *num_text)
+{
+   if (png_ptr != NULL && info_ptr != NULL && info_ptr->num_text > 0)
+   {
+      png_debug1(1, "in %s retrieval function\n",
+         (png_ptr->chunk_name[0] == '\0' ? "text"
+             : (png_const_charp)png_ptr->chunk_name));
+      if (text_ptr != NULL)
+         *text_ptr = info_ptr->text;
+      if (num_text != NULL)
+         *num_text = info_ptr->num_text;
+      return ((png_uint_32)info_ptr->num_text);
+   }
+   return(0);
+}
+#endif
+
+#if defined(PNG_READ_tIME_SUPPORTED)
+png_uint_32
+png_get_tIME(png_structp png_ptr, png_infop info_ptr, png_timep *mod_time)
+{
+   if (png_ptr != NULL && info_ptr != NULL && info_ptr->valid & PNG_INFO_tIME &&
+       mod_time != NULL)
+   {
+      png_debug1(1, "in %s retrieval function\n", "tIME");
+      *mod_time = &(info_ptr->mod_time);
+      return (PNG_INFO_tIME);
+   }
+   return (0);
+}
+#endif
+
+#if defined(PNG_READ_tRNS_SUPPORTED)
+png_uint_32
+png_get_tRNS(png_structp png_ptr, png_infop info_ptr,
+   png_bytep *trans, int *num_trans, png_color_16p *trans_values)
+{
+   png_uint_32 retval = 0;
+   if (png_ptr != NULL && info_ptr != NULL && info_ptr->valid & PNG_INFO_tRNS)
+   {
+      png_debug1(1, "in %s retrieval function\n", "tRNS");
+      if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
+      {
+          if (trans != NULL)
+          {
+             *trans = info_ptr->trans;
+             retval |= PNG_INFO_tRNS;
+          }
+          if (trans_values != NULL)
+             *trans_values = &(info_ptr->trans_values);
+      }
+      else /* if (info_ptr->color_type != PNG_COLOR_TYPE_PALETTE) */
+      {
+          if (trans_values != NULL)
+          {
+             *trans_values = &(info_ptr->trans_values);
+             retval |= PNG_INFO_tRNS;
+          }
+          if(trans != NULL)
+             *trans = NULL;
+      }
+      if(num_trans != NULL)
+      {
+         *num_trans = info_ptr->num_trans;
+         retval |= PNG_INFO_tRNS;
+      }
+   }
+   return (retval);
+}
+#endif
+
+#if defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)
+png_byte
+png_get_rgb_to_gray_status (png_structp png_ptr)
+{
+   return png_ptr->rgb_to_gray_status;
+}
+#endif

src/png/pngmem.c

@@ -0,0 +1,511 @@
+
+/* pngmem.c - stub functions for memory allocation
+ *
+ * libpng 1.0.3 - January 14, 1999
+ * For conditions of distribution and use, see copyright notice in png.h
+ * Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
+ * Copyright (c) 1996, 1997 Andreas Dilger
+ * Copyright (c) 1998, 1999 Glenn Randers-Pehrson
+ *
+ * This file provides a location for all memory allocation.  Users who
+ * need special memory handling are expected to supply replacement
+ * functions for png_malloc() and png_free(), and to use
+ * png_create_read_struct_2() and png_create_write_struct_2() to
+ * identify the replacement functions.
+ */
+
+#define PNG_INTERNAL
+#include "png.h"
+
+/* Borland DOS special memory handler */
+#if defined(__TURBOC__) && !defined(_Windows) && !defined(__FLAT__)
+/* if you change this, be sure to change the one in png.h also */
+
+/* Allocate memory for a png_struct.  The malloc and memset can be replaced
+   by a single call to calloc() if this is thought to improve performance. */
+png_voidp
+png_create_struct(int type)
+{
+#ifdef PNG_USER_MEM_SUPPORTED
+   return (png_create_struct_2(type, NULL));
+}
+
+/* Alternate version of png_create_struct, for use with user-defined malloc. */
+png_voidp
+png_create_struct_2(int type, png_malloc_ptr malloc_fn)
+{
+#endif /* PNG_USER_MEM_SUPPORTED */
+   png_size_t size;
+   png_voidp struct_ptr;
+
+   if (type == PNG_STRUCT_INFO)
+     size = sizeof(png_info);
+   else if (type == PNG_STRUCT_PNG)
+     size = sizeof(png_struct);
+   else
+     return ((png_voidp)NULL);
+
+#ifdef PNG_USER_MEM_SUPPORTED
+   if(malloc_fn != NULL)
+   {
+      if ((struct_ptr = (*(malloc_fn))(NULL, size)) != NULL)
+         png_memset(struct_ptr, 0, size);
+         return (struct_ptr);
+   }
+#endif /* PNG_USER_MEM_SUPPORTED */
+   if ((struct_ptr = (png_voidp)farmalloc(size)) != NULL)
+   {
+      png_memset(struct_ptr, 0, size);
+   }
+   return (struct_ptr);
+}
+
+
+/* Free memory allocated by a png_create_struct() call */
+void
+png_destroy_struct(png_voidp struct_ptr)
+{
+#ifdef PNG_USER_MEM_SUPPORTED
+   png_destroy_struct_2(struct_ptr, (png_free_ptr)NULL);
+}
+
+/* Free memory allocated by a png_create_struct() call */
+void
+png_destroy_struct_2(png_voidp struct_ptr, png_free_ptr free_fn)
+{
+#endif
+   if (struct_ptr != NULL)
+   {
+#ifdef PNG_USER_MEM_SUPPORTED
+      if(free_fn != NULL)
+      {
+         png_struct dummy_struct;
+         png_structp png_ptr = &dummy_struct;
+         (*(free_fn))(png_ptr, struct_ptr);
+         struct_ptr = NULL;
+         return;
+      }
+#endif /* PNG_USER_MEM_SUPPORTED */
+      farfree (struct_ptr);
+      struct_ptr = NULL;
+   }
+}
+
+/* Allocate memory.  For reasonable files, size should never exceed
+ * 64K.  However, zlib may allocate more then 64K if you don't tell
+ * it not to.  See zconf.h and png.h for more information. zlib does
+ * need to allocate exactly 64K, so whatever you call here must
+ * have the ability to do that.
+ *
+ * Borland seems to have a problem in DOS mode for exactly 64K.
+ * It gives you a segment with an offset of 8 (perhaps to store its
+ * memory stuff).  zlib doesn't like this at all, so we have to
+ * detect and deal with it.  This code should not be needed in
+ * Windows or OS/2 modes, and only in 16 bit mode.  This code has
+ * been updated by Alexander Lehmann for version 0.89 to waste less
+ * memory.
+ *
+ * Note that we can't use png_size_t for the "size" declaration,
+ * since on some systems a png_size_t is a 16-bit quantity, and as a
+ * result, we would be truncating potentially larger memory requests
+ * (which should cause a fatal error) and introducing major problems.
+ */
+png_voidp
+png_malloc(png_structp png_ptr, png_uint_32 size)
+{
+#ifndef PNG_USER_MEM_SUPPORTED
+   png_voidp ret;
+#endif
+   if (png_ptr == NULL || size == 0)
+      return ((png_voidp)NULL);
+
+#ifdef PNG_USER_MEM_SUPPORTED
+   if(png_ptr->malloc_fn != NULL)
+       return ((png_voidp)(*(png_ptr->malloc_fn))(png_ptr, size));
+   else
+       return png_malloc_default(png_ptr, size);
+}
+
+png_voidp
+png_malloc_default(png_structp png_ptr, png_uint_32 size)
+{
+   png_voidp ret;
+#endif /* PNG_USER_MEM_SUPPORTED */
+
+#ifdef PNG_MAX_MALLOC_64K
+   if (size > (png_uint_32)65536L)
+      png_error(png_ptr, "Cannot Allocate > 64K");
+#endif
+
+   if (size == (png_uint_32)65536L)
+   {
+      if (png_ptr->offset_table == NULL)
+      {
+         /* try to see if we need to do any of this fancy stuff */
+         ret = farmalloc(size);
+         if (ret == NULL || ((png_size_t)ret & 0xffff))
+         {
+            int num_blocks;
+            png_uint_32 total_size;
+            png_bytep table;
+            int i;
+            png_byte huge * hptr;
+
+            if (ret != NULL)
+            {
+               farfree(ret);
+               ret = NULL;
+            }
+
+            num_blocks = (int)(1 << (png_ptr->zlib_window_bits - 14));
+            if (num_blocks < 1)
+               num_blocks = 1;
+            if (png_ptr->zlib_mem_level >= 7)
+               num_blocks += (int)(1 << (png_ptr->zlib_mem_level - 7));
+            else
+               num_blocks++;
+
+            total_size = ((png_uint_32)65536L) * (png_uint_32)num_blocks+16;
+
+            table = farmalloc(total_size);
+
+            if (table == NULL)
+            {
+               png_error(png_ptr, "Out Of Memory."); /* Note "O" and "M" */
+            }
+
+            if ((png_size_t)table & 0xfff0)
+            {
+               png_error(png_ptr, "Farmalloc didn't return normalized pointer");
+            }
+
+            png_ptr->offset_table = table;
+            png_ptr->offset_table_ptr = farmalloc(num_blocks *
+               sizeof (png_bytep));
+
+            if (png_ptr->offset_table_ptr == NULL)
+            {
+               png_error(png_ptr, "Out Of memory.");
+            }
+
+            hptr = (png_byte huge *)table;
+            if ((png_size_t)hptr & 0xf)
+            {
+               hptr = (png_byte huge *)((long)(hptr) & 0xfffffff0L);
+               hptr += 16L;
+            }
+            for (i = 0; i < num_blocks; i++)
+            {
+               png_ptr->offset_table_ptr[i] = (png_bytep)hptr;
+               hptr += (png_uint_32)65536L;
+            }
+
+            png_ptr->offset_table_number = num_blocks;
+            png_ptr->offset_table_count = 0;
+            png_ptr->offset_table_count_free = 0;
+         }
+      }
+
+      if (png_ptr->offset_table_count >= png_ptr->offset_table_number)
+         png_error(png_ptr, "Out of Memory.");
+
+      ret = png_ptr->offset_table_ptr[png_ptr->offset_table_count++];
+   }
+   else
+      ret = farmalloc(size);
+
+   if (ret == NULL)
+   {
+      png_error(png_ptr, "Out of memory."); /* Note "o" and "m" */
+   }
+
+   return (ret);
+}
+
+/* free a pointer allocated by png_malloc().  In the default
+   configuration, png_ptr is not used, but is passed in case it
+   is needed.  If ptr is NULL, return without taking any action. */
+void
+png_free(png_structp png_ptr, png_voidp ptr)
+{
+   if (png_ptr == NULL || ptr == NULL)
+      return;
+
+#ifdef PNG_USER_MEM_SUPPORTED
+   if (png_ptr->free_fn != NULL)
+   {
+      (*(png_ptr->free_fn))(png_ptr, ptr);
+      ptr = NULL;
+      return;
+   }
+   else png_free_default(png_ptr, ptr);
+}
+
+void
+png_free_default(png_structp png_ptr, png_voidp ptr)
+{
+#endif /* PNG_USER_MEM_SUPPORTED */
+
+   if (png_ptr->offset_table != NULL)
+   {
+      int i;
+
+      for (i = 0; i < png_ptr->offset_table_count; i++)
+      {
+         if (ptr == png_ptr->offset_table_ptr[i])
+         {
+            ptr = NULL;
+            png_ptr->offset_table_count_free++;
+            break;
+         }
+      }
+      if (png_ptr->offset_table_count_free == png_ptr->offset_table_count)
+      {
+         farfree(png_ptr->offset_table);
+         farfree(png_ptr->offset_table_ptr);
+         png_ptr->offset_table = NULL;
+         png_ptr->offset_table_ptr = NULL;
+      }
+   }
+
+   if (ptr != NULL)
+   {
+      farfree(ptr);
+      ptr = NULL;
+   }
+}
+
+#else /* Not the Borland DOS special memory handler */
+
+/* Allocate memory for a png_struct or a png_info.  The malloc and
+   memset can be replaced by a single call to calloc() if this is thought
+   to improve performance noticably.*/
+png_voidp
+png_create_struct(int type)
+{
+#ifdef PNG_USER_MEM_SUPPORTED
+   return (png_create_struct_2(type, NULL));
+}
+
+/* Allocate memory for a png_struct or a png_info.  The malloc and
+   memset can be replaced by a single call to calloc() if this is thought
+   to improve performance noticably.*/
+png_voidp
+png_create_struct_2(int type, png_malloc_ptr malloc_fn)
+{
+#endif /* PNG_USER_MEM_SUPPORTED */
+   png_size_t size;
+   png_voidp struct_ptr;
+
+   if (type == PNG_STRUCT_INFO)
+      size = sizeof(png_info);
+   else if (type == PNG_STRUCT_PNG)
+      size = sizeof(png_struct);
+   else
+      return ((png_voidp)NULL);
+
+#ifdef PNG_USER_MEM_SUPPORTED
+   if(malloc_fn != NULL)
+   {
+      if ((struct_ptr = (*(malloc_fn))(NULL, size)) != NULL)
+         png_memset(struct_ptr, 0, size);
+      return (struct_ptr);
+   }
+#endif /* PNG_USER_MEM_SUPPORTED */
+
+#if defined(__TURBOC__) && !defined(__FLAT__)
+   if ((struct_ptr = (png_voidp)farmalloc(size)) != NULL)
+#else
+# if defined(_MSC_VER) && defined(MAXSEG_64K)
+   if ((struct_ptr = (png_voidp)halloc(size,1)) != NULL)
+# else
+   if ((struct_ptr = (png_voidp)malloc(size)) != NULL)
+# endif
+#endif
+   {
+      png_memset(struct_ptr, 0, size);
+   }
+
+   return (struct_ptr);
+}
+
+
+/* Free memory allocated by a png_create_struct() call */
+void
+png_destroy_struct(png_voidp struct_ptr)
+{
+#ifdef PNG_USER_MEM_SUPPORTED
+   png_destroy_struct_2(struct_ptr, (png_free_ptr)NULL);
+}
+
+/* Free memory allocated by a png_create_struct() call */
+void
+png_destroy_struct_2(png_voidp struct_ptr, png_free_ptr free_fn)
+{
+#endif /* PNG_USER_MEM_SUPPORTED */
+   if (struct_ptr != NULL)
+   {
+#ifdef PNG_USER_MEM_SUPPORTED
+      if(free_fn != NULL)
+      {
+         png_struct dummy_struct;
+         png_structp png_ptr = &dummy_struct;
+         (*(free_fn))(png_ptr, struct_ptr);
+         struct_ptr = NULL;
+         return;
+      }
+#endif /* PNG_USER_MEM_SUPPORTED */
+#if defined(__TURBOC__) && !defined(__FLAT__)
+      farfree(struct_ptr);
+      struct_ptr = NULL;
+#else
+# if defined(_MSC_VER) && defined(MAXSEG_64K)
+      hfree(struct_ptr);
+      struct_ptr = NULL;
+# else
+      free(struct_ptr);
+      struct_ptr = NULL;
+# endif
+#endif
+   }
+}
+
+
+/* Allocate memory.  For reasonable files, size should never exceed
+   64K.  However, zlib may allocate more then 64K if you don't tell
+   it not to.  See zconf.h and png.h for more information.  zlib does
+   need to allocate exactly 64K, so whatever you call here must
+   have the ability to do that. */
+
+png_voidp
+png_malloc(png_structp png_ptr, png_uint_32 size)
+{
+#ifndef PNG_USER_MEM_SUPPORTED
+   png_voidp ret;
+#endif
+   if (png_ptr == NULL || size == 0)
+      return ((png_voidp)NULL);
+
+#ifdef PNG_USER_MEM_SUPPORTED
+   if(png_ptr->malloc_fn != NULL)
+       return ((png_voidp)(*(png_ptr->malloc_fn))(png_ptr, size));
+   else
+       return (png_malloc_default(png_ptr, size));
+}
+png_voidp
+png_malloc_default(png_structp png_ptr, png_uint_32 size)
+{
+   png_voidp ret;
+#endif /* PNG_USER_MEM_SUPPORTED */
+
+#ifdef PNG_MAX_MALLOC_64K
+   if (size > (png_uint_32)65536L)
+      png_error(png_ptr, "Cannot Allocate > 64K");
+#endif
+
+#if defined(__TURBOC__) && !defined(__FLAT__)
+   ret = farmalloc(size);
+#else
+# if defined(_MSC_VER) && defined(MAXSEG_64K)
+   ret = halloc(size, 1);
+# else
+   ret = malloc((size_t)size);
+# endif
+#endif
+
+   if (ret == NULL)
+   {
+      png_error(png_ptr, "Out of Memory");
+   }
+
+   return (ret);
+}
+
+/* Free a pointer allocated by png_malloc().  If ptr is NULL, return
+   without taking any action. */
+void
+png_free(png_structp png_ptr, png_voidp ptr)
+{
+   if (png_ptr == NULL || ptr == NULL)
+      return;
+
+#ifdef PNG_USER_MEM_SUPPORTED
+   if (png_ptr->free_fn != NULL)
+   {
+      (*(png_ptr->free_fn))(png_ptr, ptr);
+      ptr = NULL;
+      return;
+   }
+   else png_free_default(png_ptr, ptr);
+}
+void
+png_free_default(png_structp png_ptr, png_voidp ptr)
+{
+#endif /* PNG_USER_MEM_SUPPORTED */
+
+#if defined(__TURBOC__) && !defined(__FLAT__)
+   farfree(ptr);
+   ptr = NULL;
+#else
+# if defined(_MSC_VER) && defined(MAXSEG_64K)
+   hfree(ptr);
+   ptr = NULL;
+# else
+   free(ptr);
+   ptr = NULL;
+# endif
+#endif
+}
+
+#endif /* Not Borland DOS special memory handler */
+
+png_voidp
+png_memcpy_check (png_structp png_ptr, png_voidp s1, png_voidp s2,
+   png_uint_32 length)
+{
+   png_size_t size;
+
+   size = (png_size_t)length;
+   if ((png_uint_32)size != length)
+      png_error(png_ptr,"Overflow in png_memcpy_check.");
+
+   return(png_memcpy (s1, s2, size));
+}
+
+png_voidp
+png_memset_check (png_structp png_ptr, png_voidp s1, int value,
+   png_uint_32 length)
+{
+   png_size_t size;
+
+   size = (png_size_t)length;
+   if ((png_uint_32)size != length)
+      png_error(png_ptr,"Overflow in png_memset_check.");
+
+   return (png_memset (s1, value, size));
+
+}
+
+#ifdef PNG_USER_MEM_SUPPORTED
+/* This function is called when the application wants to use another method
+ * of allocating and freeing memory.
+ */
+void
+png_set_mem_fn(png_structp png_ptr, png_voidp mem_ptr, png_malloc_ptr
+  malloc_fn, png_free_ptr free_fn)
+{
+   png_ptr->mem_ptr = mem_ptr;
+   png_ptr->malloc_fn = malloc_fn;
+   png_ptr->free_fn = free_fn;
+}
+
+/* This function returns a pointer to the mem_ptr associated with the user
+ * functions.  The application should free any memory associated with this
+ * pointer before png_write_destroy and png_read_destroy are called.
+ */
+png_voidp
+png_get_mem_ptr(png_structp png_ptr)
+{
+   return ((png_voidp)png_ptr->mem_ptr);
+}
+#endif /* PNG_USER_MEM_SUPPORTED */

src/png/pngread.c

@@ -0,0 +1,885 @@
+
+/* pngread.c - read a PNG file
+ *
+ * libpng 1.0.3 - January 14, 1999
+ * For conditions of distribution and use, see copyright notice in png.h
+ * Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
+ * Copyright (c) 1996, 1997 Andreas Dilger
+ * Copyright (c) 1998, 1999 Glenn Randers-Pehrson
+ *
+ * This file contains routines that an application calls directly to
+ * read a PNG file or stream.
+ */
+
+#define PNG_INTERNAL
+#include "png.h"
+
+/* Create a PNG structure for reading, and allocate any memory needed. */
+png_structp
+png_create_read_struct(png_const_charp user_png_ver, png_voidp error_ptr,
+   png_error_ptr error_fn, png_error_ptr warn_fn)
+{
+
+#ifdef PNG_USER_MEM_SUPPORTED
+   return (png_create_read_struct_2(user_png_ver, error_ptr, error_fn,
+      warn_fn, NULL, NULL, NULL));
+}
+
+/* Alternate create PNG structure for reading, and allocate any memory needed. */
+png_structp
+png_create_read_struct_2(png_const_charp user_png_ver, png_voidp error_ptr,
+   png_error_ptr error_fn, png_error_ptr warn_fn, png_voidp mem_ptr,
+   png_malloc_ptr malloc_fn, png_free_ptr free_fn)
+{
+#endif /* PNG_USER_MEM_SUPPORTED */
+
+   png_structp png_ptr;
+#ifdef USE_FAR_KEYWORD
+   jmp_buf jmpbuf;
+#endif
+   png_debug(1, "in png_create_read_struct\n");
+#ifdef PNG_USER_MEM_SUPPORTED
+   if ((png_ptr = (png_structp)png_create_struct_2(PNG_STRUCT_PNG,
+      (png_malloc_ptr)malloc_fn)) == NULL)
+#else
+   if ((png_ptr = (png_structp)png_create_struct(PNG_STRUCT_PNG)) == NULL)
+#endif
+   {
+      return (png_structp)NULL;
+   }
+#ifdef USE_FAR_KEYWORD
+   if (setjmp(jmpbuf))
+#else
+   if (setjmp(png_ptr->jmpbuf))
+#endif
+   {
+      png_free(png_ptr, png_ptr->zbuf);
+      png_destroy_struct(png_ptr);
+      return (png_structp)NULL;
+   }
+#ifdef USE_FAR_KEYWORD
+   png_memcpy(png_ptr->jmpbuf,jmpbuf,sizeof(jmp_buf));
+#endif
+
+#ifdef PNG_USER_MEM_SUPPORTED
+   png_set_mem_fn(png_ptr, mem_ptr, malloc_fn, free_fn);
+#endif /* PNG_USER_MEM_SUPPORTED */
+
+   png_set_error_fn(png_ptr, error_ptr, error_fn, warn_fn);
+
+   /* Libpng 0.90 and later are binary incompatible with libpng 0.89, so
+    * we must recompile any applications that use any older library version.
+    * For versions after libpng 1.0, we will be compatible, so we need
+    * only check the first digit.
+    */
+   if (user_png_ver == NULL || user_png_ver[0] != png_libpng_ver[0] ||
+       (user_png_ver[0] == '0' && user_png_ver[2] < '9'))
+   {
+      png_error(png_ptr,
+         "Incompatible libpng version in application and library");
+   }
+
+   /* initialize zbuf - compression buffer */
+   png_ptr->zbuf_size = PNG_ZBUF_SIZE;
+   png_ptr->zbuf = (png_bytep)png_malloc(png_ptr,
+     (png_uint_32)png_ptr->zbuf_size);
+   png_ptr->zstream.zalloc = png_zalloc;
+   png_ptr->zstream.zfree = png_zfree;
+   png_ptr->zstream.opaque = (voidpf)png_ptr;
+
+   switch (inflateInit(&png_ptr->zstream))
+   {
+     case Z_OK: /* Do nothing */ break;
+     case Z_MEM_ERROR:
+     case Z_STREAM_ERROR: png_error(png_ptr, "zlib memory error"); break;
+     case Z_VERSION_ERROR: png_error(png_ptr, "zlib version error"); break;
+     default: png_error(png_ptr, "Unknown zlib error");
+   }
+
+   png_ptr->zstream.next_out = png_ptr->zbuf;
+   png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;
+
+   png_set_read_fn(png_ptr, NULL, NULL);
+
+   return (png_ptr);
+}
+
+/* Initialize PNG structure for reading, and allocate any memory needed.
+   This interface is deprecated in favour of the png_create_read_struct(),
+   and it will eventually disappear. */
+void
+png_read_init(png_structp png_ptr)
+{
+   jmp_buf tmp_jmp;  /* to save current jump buffer */
+
+   png_debug(1, "in png_read_init\n");
+   /* save jump buffer and error functions */
+   png_memcpy(tmp_jmp, png_ptr->jmpbuf, sizeof (jmp_buf));
+
+   /* reset all variables to 0 */
+   png_memset(png_ptr, 0, sizeof (png_struct));
+
+   /* restore jump buffer */
+   png_memcpy(png_ptr->jmpbuf, tmp_jmp, sizeof (jmp_buf));
+
+   /* initialize zbuf - compression buffer */
+   png_ptr->zbuf_size = PNG_ZBUF_SIZE;
+   png_ptr->zbuf = (png_bytep)png_malloc(png_ptr,
+     (png_uint_32)png_ptr->zbuf_size);
+   png_ptr->zstream.zalloc = png_zalloc;
+   png_ptr->zstream.zfree = png_zfree;
+   png_ptr->zstream.opaque = (voidpf)png_ptr;
+
+   switch (inflateInit(&png_ptr->zstream))
+   {
+     case Z_OK: /* Do nothing */ break;
+     case Z_MEM_ERROR:
+     case Z_STREAM_ERROR: png_error(png_ptr, "zlib memory"); break;
+     case Z_VERSION_ERROR: png_error(png_ptr, "zlib version"); break;
+     default: png_error(png_ptr, "Unknown zlib error");
+   }
+
+   png_ptr->zstream.next_out = png_ptr->zbuf;
+   png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;
+
+   png_set_read_fn(png_ptr, NULL, NULL);
+}
+
+/* Read the information before the actual image data.  This has been
+ * changed in v0.90 to allow reading a file that already has the magic
+ * bytes read from the stream.  You can tell libpng how many bytes have
+ * been read from the beginning of the stream (up to the maximum of 8)
+ * via png_set_sig_bytes(), and we will only check the remaining bytes
+ * here.  The application can then have access to the signature bytes we
+ * read if it is determined that this isn't a valid PNG file.
+ */
+void
+png_read_info(png_structp png_ptr, png_infop info_ptr)
+{
+   png_debug(1, "in png_read_info\n");
+   /* save jump buffer and error functions */
+   /* If we haven't checked all of the PNG signature bytes, do so now. */
+   if (png_ptr->sig_bytes < 8)
+   {
+      png_size_t num_checked = png_ptr->sig_bytes,
+                 num_to_check = 8 - num_checked;
+
+      png_read_data(png_ptr, &(info_ptr->signature[num_checked]), num_to_check);
+      png_ptr->sig_bytes = 8;
+
+      if (png_sig_cmp(info_ptr->signature, num_checked, num_to_check))
+      {
+         if (num_checked < 4 &&
+             png_sig_cmp(info_ptr->signature, num_checked, num_to_check - 4))
+            png_error(png_ptr, "Not a PNG file");
+         else
+            png_error(png_ptr, "PNG file corrupted by ASCII conversion");
+      }
+   }
+
+   for(;;)
+   {
+      png_byte chunk_length[4];
+      png_uint_32 length;
+
+      png_read_data(png_ptr, chunk_length, 4);
+      length = png_get_uint_32(chunk_length);
+
+      png_reset_crc(png_ptr);
+      png_crc_read(png_ptr, png_ptr->chunk_name, 4);
+
+      png_debug1(0, "Reading %s chunk.\n", png_ptr->chunk_name);
+
+      /* This should be a binary subdivision search or a hash for
+       * matching the chunk name rather than a linear search.
+       */
+      if (!png_memcmp(png_ptr->chunk_name, png_IHDR, 4))
+         png_handle_IHDR(png_ptr, info_ptr, length);
+      else if (!png_memcmp(png_ptr->chunk_name, png_PLTE, 4))
+         png_handle_PLTE(png_ptr, info_ptr, length);
+      else if (!png_memcmp(png_ptr->chunk_name, png_IEND, 4))
+         png_handle_IEND(png_ptr, info_ptr, length);
+      else if (!png_memcmp(png_ptr->chunk_name, png_IDAT, 4))
+      {
+         if (!(png_ptr->mode & PNG_HAVE_IHDR))
+            png_error(png_ptr, "Missing IHDR before IDAT");
+         else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE &&
+                  !(png_ptr->mode & PNG_HAVE_PLTE))
+            png_error(png_ptr, "Missing PLTE before IDAT");
+
+         png_ptr->idat_size = length;
+         png_ptr->mode |= PNG_HAVE_IDAT;
+         break;
+      }
+#if defined(PNG_READ_bKGD_SUPPORTED)
+      else if (!png_memcmp(png_ptr->chunk_name, png_bKGD, 4))
+         png_handle_bKGD(png_ptr, info_ptr, length);
+#endif
+#if defined(PNG_READ_cHRM_SUPPORTED)
+      else if (!png_memcmp(png_ptr->chunk_name, png_cHRM, 4))
+         png_handle_cHRM(png_ptr, info_ptr, length);
+#endif
+#if defined(PNG_READ_gAMA_SUPPORTED)
+      else if (!png_memcmp(png_ptr->chunk_name, png_gAMA, 4))
+         png_handle_gAMA(png_ptr, info_ptr, length);
+#endif
+#if defined(PNG_READ_hIST_SUPPORTED)
+      else if (!png_memcmp(png_ptr->chunk_name, png_hIST, 4))
+         png_handle_hIST(png_ptr, info_ptr, length);
+#endif
+#if defined(PNG_READ_oFFs_SUPPORTED)
+      else if (!png_memcmp(png_ptr->chunk_name, png_oFFs, 4))
+         png_handle_oFFs(png_ptr, info_ptr, length);
+#endif
+#if defined(PNG_READ_pCAL_SUPPORTED)
+      else if (!png_memcmp(png_ptr->chunk_name, png_pCAL, 4))
+         png_handle_pCAL(png_ptr, info_ptr, length);
+#endif
+#if defined(PNG_READ_pHYs_SUPPORTED)
+      else if (!png_memcmp(png_ptr->chunk_name, png_pHYs, 4))
+         png_handle_pHYs(png_ptr, info_ptr, length);
+#endif
+#if defined(PNG_READ_sBIT_SUPPORTED)
+      else if (!png_memcmp(png_ptr->chunk_name, png_sBIT, 4))
+         png_handle_sBIT(png_ptr, info_ptr, length);
+#endif
+#if defined(PNG_READ_sRGB_SUPPORTED)
+      else if (!png_memcmp(png_ptr->chunk_name, png_sRGB, 4))
+         png_handle_sRGB(png_ptr, info_ptr, length);
+#endif
+#if defined(PNG_READ_tEXt_SUPPORTED)
+      else if (!png_memcmp(png_ptr->chunk_name, png_tEXt, 4))
+         png_handle_tEXt(png_ptr, info_ptr, length);
+#endif
+#if defined(PNG_READ_tIME_SUPPORTED)
+      else if (!png_memcmp(png_ptr->chunk_name, png_tIME, 4))
+         png_handle_tIME(png_ptr, info_ptr, length);
+#endif
+#if defined(PNG_READ_tRNS_SUPPORTED)
+      else if (!png_memcmp(png_ptr->chunk_name, png_tRNS, 4))
+         png_handle_tRNS(png_ptr, info_ptr, length);
+#endif
+#if defined(PNG_READ_zTXt_SUPPORTED)
+      else if (!png_memcmp(png_ptr->chunk_name, png_zTXt, 4))
+         png_handle_zTXt(png_ptr, info_ptr, length);
+#endif
+      else
+         png_handle_unknown(png_ptr, info_ptr, length);
+   }
+}
+
+/* optional call to update the users info_ptr structure */
+void
+png_read_update_info(png_structp png_ptr, png_infop info_ptr)
+{
+   png_debug(1, "in png_read_update_info\n");
+   /* save jump buffer and error functions */
+   if (!(png_ptr->flags & PNG_FLAG_ROW_INIT))
+      png_read_start_row(png_ptr);
+   png_read_transform_info(png_ptr, info_ptr);
+}
+
+/* Initialize palette, background, etc, after transformations
+ * are set, but before any reading takes place.  This allows
+ * the user to obtain a gamma-corrected palette, for example.
+ * If the user doesn't call this, we will do it ourselves.
+ */
+void
+png_start_read_image(png_structp png_ptr)
+{
+   png_debug(1, "in png_start_read_image\n");
+   /* save jump buffer and error functions */
+   if (!(png_ptr->flags & PNG_FLAG_ROW_INIT))
+      png_read_start_row(png_ptr);
+}
+
+void
+png_read_row(png_structp png_ptr, png_bytep row, png_bytep dsp_row)
+{
+   int ret;
+   png_debug2(1, "in png_read_row (row %d, pass %d)\n",
+      png_ptr->row_number, png_ptr->pass);
+   /* save jump buffer and error functions */
+   if (!(png_ptr->flags & PNG_FLAG_ROW_INIT))
+      png_read_start_row(png_ptr);
+   if (png_ptr->row_number == 0 && png_ptr->pass == 0)
+   {
+   /* check for transforms that have been set but were defined out */
+#if defined(PNG_WRITE_INVERT_SUPPORTED) && !defined(PNG_READ_INVERT_SUPPORTED)
+   if (png_ptr->transformations & PNG_INVERT_MONO)
+      png_warning(png_ptr, "PNG_READ_INVERT_SUPPORTED is not defined.");
+#endif
+#if defined(PNG_WRITE_FILLER_SUPPORTED) && !defined(PNG_READ_FILLER_SUPPORTED)
+   if (png_ptr->transformations & PNG_FILLER)
+      png_warning(png_ptr, "PNG_READ_FILLER_SUPPORTED is not defined.");
+#endif
+#if defined(PNG_WRITE_PACKSWAP_SUPPORTED) && !defined(PNG_READ_PACKSWAP_SUPPORTED)
+   if (png_ptr->transformations & PNG_PACKSWAP)
+      png_warning(png_ptr, "PNG_READ_PACKSWAP_SUPPORTED is not defined.");
+#endif
+#if defined(PNG_WRITE_PACK_SUPPORTED) && !defined(PNG_READ_PACK_SUPPORTED)
+   if (png_ptr->transformations & PNG_PACK)
+      png_warning(png_ptr, "PNG_READ_PACK_SUPPORTED is not defined.");
+#endif
+#if defined(PNG_WRITE_SHIFT_SUPPORTED) && !defined(PNG_READ_SHIFT_SUPPORTED)
+   if (png_ptr->transformations & PNG_SHIFT)
+      png_warning(png_ptr, "PNG_READ_SHIFT_SUPPORTED is not defined.");
+#endif
+#if defined(PNG_WRITE_BGR_SUPPORTED) && !defined(PNG_READ_BGR_SUPPORTED)
+   if (png_ptr->transformations & PNG_BGR)
+      png_warning(png_ptr, "PNG_READ_BGR_SUPPORTED is not defined.");
+#endif
+#if defined(PNG_WRITE_SWAP_SUPPORTED) && !defined(PNG_READ_SWAP_SUPPORTED)
+   if (png_ptr->transformations & PNG_SWAP_BYTES)
+      png_warning(png_ptr, "PNG_READ_SWAP_SUPPORTED is not defined.");
+#endif
+   }
+
+#if defined(PNG_READ_INTERLACING_SUPPORTED)
+   /* if interlaced and we do not need a new row, combine row and return */
+   if (png_ptr->interlaced && (png_ptr->transformations & PNG_INTERLACE))
+   {
+      switch (png_ptr->pass)
+      {
+         case 0:
+            if (png_ptr->row_number & 7)
+            {
+               if (dsp_row != NULL)
+                  png_combine_row(png_ptr, dsp_row,
+                     png_pass_dsp_mask[png_ptr->pass]);
+               png_read_finish_row(png_ptr);
+               return;
+            }
+            break;
+         case 1:
+            if ((png_ptr->row_number & 7) || png_ptr->width < 5)
+            {
+               if (dsp_row != NULL)
+                  png_combine_row(png_ptr, dsp_row,
+                     png_pass_dsp_mask[png_ptr->pass]);
+               png_read_finish_row(png_ptr);
+               return;
+            }
+            break;
+         case 2:
+            if ((png_ptr->row_number & 7) != 4)
+            {
+               if (dsp_row != NULL && (png_ptr->row_number & 4))
+                  png_combine_row(png_ptr, dsp_row,
+                     png_pass_dsp_mask[png_ptr->pass]);
+               png_read_finish_row(png_ptr);
+               return;
+            }
+            break;
+         case 3:
+            if ((png_ptr->row_number & 3) || png_ptr->width < 3)
+            {
+               if (dsp_row != NULL)
+                  png_combine_row(png_ptr, dsp_row,
+                     png_pass_dsp_mask[png_ptr->pass]);
+               png_read_finish_row(png_ptr);
+               return;
+            }
+            break;
+         case 4:
+            if ((png_ptr->row_number & 3) != 2)
+            {
+               if (dsp_row != NULL && (png_ptr->row_number & 2))
+                  png_combine_row(png_ptr, dsp_row,
+                     png_pass_dsp_mask[png_ptr->pass]);
+               png_read_finish_row(png_ptr);
+               return;
+            }
+            break;
+         case 5:
+            if ((png_ptr->row_number & 1) || png_ptr->width < 2)
+            {
+               if (dsp_row != NULL)
+                  png_combine_row(png_ptr, dsp_row,
+                     png_pass_dsp_mask[png_ptr->pass]);
+               png_read_finish_row(png_ptr);
+               return;
+            }
+            break;
+         case 6:
+            if (!(png_ptr->row_number & 1))
+            {
+               png_read_finish_row(png_ptr);
+               return;
+            }
+            break;
+      }
+   }
+#endif
+
+   if (!(png_ptr->mode & PNG_HAVE_IDAT))
+      png_error(png_ptr, "Invalid attempt to read row data");
+
+   png_ptr->zstream.next_out = png_ptr->row_buf;
+   png_ptr->zstream.avail_out = (uInt)png_ptr->irowbytes;
+   do
+   {
+      if (!(png_ptr->zstream.avail_in))
+      {
+         while (!png_ptr->idat_size)
+         {
+            png_byte chunk_length[4];
+
+            png_crc_finish(png_ptr, 0);
+
+            png_read_data(png_ptr, chunk_length, 4);
+            png_ptr->idat_size = png_get_uint_32(chunk_length);
+
+            png_reset_crc(png_ptr);
+            png_crc_read(png_ptr, png_ptr->chunk_name, 4);
+            if (png_memcmp(png_ptr->chunk_name, png_IDAT, 4))
+               png_error(png_ptr, "Not enough image data");
+         }
+         png_ptr->zstream.avail_in = (uInt)png_ptr->zbuf_size;
+         png_ptr->zstream.next_in = png_ptr->zbuf;
+         if (png_ptr->zbuf_size > png_ptr->idat_size)
+            png_ptr->zstream.avail_in = (uInt)png_ptr->idat_size;
+         png_crc_read(png_ptr, png_ptr->zbuf,
+            (png_size_t)png_ptr->zstream.avail_in);
+         png_ptr->idat_size -= png_ptr->zstream.avail_in;
+      }
+      ret = inflate(&png_ptr->zstream, Z_PARTIAL_FLUSH);
+      if (ret == Z_STREAM_END)
+      {
+         if (png_ptr->zstream.avail_out || png_ptr->zstream.avail_in ||
+            png_ptr->idat_size)
+            png_error(png_ptr, "Extra compressed data");
+         png_ptr->mode |= PNG_AFTER_IDAT;
+         png_ptr->flags |= PNG_FLAG_ZLIB_FINISHED;
+         break;
+      }
+      if (ret != Z_OK)
+         png_error(png_ptr, png_ptr->zstream.msg ? png_ptr->zstream.msg :
+                   "Decompression error");
+
+   } while (png_ptr->zstream.avail_out);
+
+   png_ptr->row_info.color_type = png_ptr->color_type;
+   png_ptr->row_info.width = png_ptr->iwidth;
+   png_ptr->row_info.channels = png_ptr->channels;
+   png_ptr->row_info.bit_depth = png_ptr->bit_depth;
+   png_ptr->row_info.pixel_depth = png_ptr->pixel_depth;
+   {
+      png_ptr->row_info.rowbytes = ((png_ptr->row_info.width *
+         (png_uint_32)png_ptr->row_info.pixel_depth + 7) >> 3);
+   }
+
+   png_read_filter_row(png_ptr, &(png_ptr->row_info),
+      png_ptr->row_buf + 1, png_ptr->prev_row + 1,
+      (int)(png_ptr->row_buf[0]));
+
+   png_memcpy_check(png_ptr, png_ptr->prev_row, png_ptr->row_buf,
+      png_ptr->rowbytes + 1);
+
+   if (png_ptr->transformations)
+      png_do_read_transformations(png_ptr);
+
+#if defined(PNG_READ_INTERLACING_SUPPORTED)
+   /* blow up interlaced rows to full size */
+   if (png_ptr->interlaced &&
+      (png_ptr->transformations & PNG_INTERLACE))
+   {
+      if (png_ptr->pass < 6)
+         png_do_read_interlace(&(png_ptr->row_info),
+            png_ptr->row_buf + 1, png_ptr->pass, png_ptr->transformations);
+
+      if (dsp_row != NULL)
+         png_combine_row(png_ptr, dsp_row,
+            png_pass_dsp_mask[png_ptr->pass]);
+      if (row != NULL)
+         png_combine_row(png_ptr, row,
+            png_pass_mask[png_ptr->pass]);
+   }
+   else
+#endif
+   {
+      if (row != NULL)
+         png_combine_row(png_ptr, row, 0xff);
+      if (dsp_row != NULL)
+         png_combine_row(png_ptr, dsp_row, 0xff);
+   }
+   png_read_finish_row(png_ptr);
+
+   if (png_ptr->read_row_fn != NULL)
+      (*(png_ptr->read_row_fn))(png_ptr, png_ptr->row_number, png_ptr->pass);
+}
+
+/* Read one or more rows of image data.  If the image is interlaced,
+ * and png_set_interlace_handling() has been called, the rows need to
+ * contain the contents of the rows from the previous pass.  If the
+ * image has alpha or transparency, and png_handle_alpha()[*] has been
+ * called, the rows contents must be initialized to the contents of the
+ * screen.
+ *
+ * "row" holds the actual image, and pixels are placed in it
+ * as they arrive.  If the image is displayed after each pass, it will
+ * appear to "sparkle" in.  "display_row" can be used to display a
+ * "chunky" progressive image, with finer detail added as it becomes
+ * available.  If you do not want this "chunky" display, you may pass
+ * NULL for display_row.  If you do not want the sparkle display, and
+ * you have not called png_handle_alpha(), you may pass NULL for rows.
+ * If you have called png_handle_alpha(), and the image has either an
+ * alpha channel or a transparency chunk, you must provide a buffer for
+ * rows.  In this case, you do not have to provide a display_row buffer
+ * also, but you may.  If the image is not interlaced, or if you have
+ * not called png_set_interlace_handling(), the display_row buffer will
+ * be ignored, so pass NULL to it.
+ *
+ * [*] png_handle_alpha() does not exist yet, as of libpng version 1.0.3.
+ */
+
+void
+png_read_rows(png_structp png_ptr, png_bytepp row,
+   png_bytepp display_row, png_uint_32 num_rows)
+{
+   png_uint_32 i;
+   png_bytepp rp;
+   png_bytepp dp;
+
+   png_debug(1, "in png_read_rows\n");
+   /* save jump buffer and error functions */
+   rp = row;
+   dp = display_row;
+   if (rp != NULL && dp != NULL)
+      for (i = 0; i < num_rows; i++)
+      {
+         png_bytep rptr = *rp++;
+         png_bytep dptr = *dp++;
+
+         png_read_row(png_ptr, rptr, dptr);
+      }
+   else if(rp != NULL)
+      for (i = 0; i < num_rows; i++)
+      {
+         png_bytep rptr = *rp;
+         png_read_row(png_ptr, rptr, NULL);
+         rp++;
+      }
+   else if(dp != NULL)
+      for (i = 0; i < num_rows; i++)
+      {
+         png_bytep dptr = *dp;
+         png_read_row(png_ptr, NULL, dptr);
+         dp++;
+      }
+}
+
+/* Read the entire image.  If the image has an alpha channel or a tRNS
+ * chunk, and you have called png_handle_alpha()[*], you will need to
+ * initialize the image to the current image that PNG will be overlaying.
+ * We set the num_rows again here, in case it was incorrectly set in
+ * png_read_start_row() by a call to png_read_update_info() or
+ * png_start_read_image() if png_set_interlace_handling() wasn't called
+ * prior to either of these functions like it should have been.  You can
+ * only call this function once.  If you desire to have an image for
+ * each pass of a interlaced image, use png_read_rows() instead.
+ *
+ * [*] png_handle_alpha() does not exist yet, as of libpng version 1.0.3.
+ */
+void
+png_read_image(png_structp png_ptr, png_bytepp image)
+{
+   png_uint_32 i,image_height;
+   int pass, j;
+   png_bytepp rp;
+
+   png_debug(1, "in png_read_image\n");
+   /* save jump buffer and error functions */
+   pass = png_set_interlace_handling(png_ptr);
+
+   image_height=png_ptr->height;
+   png_ptr->num_rows = image_height; /* Make sure this is set correctly */
+
+   for (j = 0; j < pass; j++)
+   {
+      rp = image;
+      for (i = 0; i < image_height; i++)
+      {
+         png_read_row(png_ptr, *rp, NULL);
+         rp++;
+      }
+   }
+}
+
+/* Read the end of the PNG file.  Will not read past the end of the
+ * file, will verify the end is accurate, and will read any comments
+ * or time information at the end of the file, if info is not NULL.
+ */
+void
+png_read_end(png_structp png_ptr, png_infop info_ptr)
+{
+   png_byte chunk_length[4];
+   png_uint_32 length;
+
+   png_debug(1, "in png_read_end\n");
+   /* save jump buffer and error functions */
+   png_crc_finish(png_ptr, 0); /* Finish off CRC from last IDAT chunk */
+
+   do
+   {
+      png_read_data(png_ptr, chunk_length, 4);
+      length = png_get_uint_32(chunk_length);
+
+      png_reset_crc(png_ptr);
+      png_crc_read(png_ptr, png_ptr->chunk_name, 4);
+
+      png_debug1(0, "Reading %s chunk.\n", png_ptr->chunk_name);
+
+      if (!png_memcmp(png_ptr->chunk_name, png_IHDR, 4))
+         png_handle_IHDR(png_ptr, info_ptr, length);
+      else if (!png_memcmp(png_ptr->chunk_name, png_IDAT, 4))
+      {
+         /* Zero length IDATs are legal after the last IDAT has been
+          * read, but not after other chunks have been read.
+          */
+         if (length > 0 || png_ptr->mode & PNG_AFTER_IDAT)
+            png_error(png_ptr, "Too many IDAT's found");
+         else
+            png_crc_finish(png_ptr, 0);
+      }
+      else if (!png_memcmp(png_ptr->chunk_name, png_PLTE, 4))
+         png_handle_PLTE(png_ptr, info_ptr, length);
+      else if (!png_memcmp(png_ptr->chunk_name, png_IEND, 4))
+         png_handle_IEND(png_ptr, info_ptr, length);
+#if defined(PNG_READ_bKGD_SUPPORTED)
+      else if (!png_memcmp(png_ptr->chunk_name, png_bKGD, 4))
+         png_handle_bKGD(png_ptr, info_ptr, length);
+#endif
+#if defined(PNG_READ_cHRM_SUPPORTED)
+      else if (!png_memcmp(png_ptr->chunk_name, png_cHRM, 4))
+         png_handle_cHRM(png_ptr, info_ptr, length);
+#endif
+#if defined(PNG_READ_gAMA_SUPPORTED)
+      else if (!png_memcmp(png_ptr->chunk_name, png_gAMA, 4))
+         png_handle_gAMA(png_ptr, info_ptr, length);
+#endif
+#if defined(PNG_READ_hIST_SUPPORTED)
+      else if (!png_memcmp(png_ptr->chunk_name, png_hIST, 4))
+         png_handle_hIST(png_ptr, info_ptr, length);
+#endif
+#if defined(PNG_READ_oFFs_SUPPORTED)
+      else if (!png_memcmp(png_ptr->chunk_name, png_oFFs, 4))
+         png_handle_oFFs(png_ptr, info_ptr, length);
+#endif
+#if defined(PNG_READ_pCAL_SUPPORTED)
+      else if (!png_memcmp(png_ptr->chunk_name, png_pCAL, 4))
+         png_handle_pCAL(png_ptr, info_ptr, length);
+#endif
+#if defined(PNG_READ_pHYs_SUPPORTED)
+      else if (!png_memcmp(png_ptr->chunk_name, png_pHYs, 4))
+         png_handle_pHYs(png_ptr, info_ptr, length);
+#endif
+#if defined(PNG_READ_sBIT_SUPPORTED)
+      else if (!png_memcmp(png_ptr->chunk_name, png_sBIT, 4))
+         png_handle_sBIT(png_ptr, info_ptr, length);
+#endif
+#if defined(PNG_READ_sRGB_SUPPORTED)
+      else if (!png_memcmp(png_ptr->chunk_name, png_sRGB, 4))
+         png_handle_sRGB(png_ptr, info_ptr, length);
+#endif
+#if defined(PNG_READ_tEXt_SUPPORTED)
+      else if (!png_memcmp(png_ptr->chunk_name, png_tEXt, 4))
+         png_handle_tEXt(png_ptr, info_ptr, length);
+#endif
+#if defined(PNG_READ_tIME_SUPPORTED)
+      else if (!png_memcmp(png_ptr->chunk_name, png_tIME, 4))
+         png_handle_tIME(png_ptr, info_ptr, length);
+#endif
+#if defined(PNG_READ_tRNS_SUPPORTED)
+      else if (!png_memcmp(png_ptr->chunk_name, png_tRNS, 4))
+         png_handle_tRNS(png_ptr, info_ptr, length);
+#endif
+#if defined(PNG_READ_zTXt_SUPPORTED)
+      else if (!png_memcmp(png_ptr->chunk_name, png_zTXt, 4))
+         png_handle_zTXt(png_ptr, info_ptr, length);
+#endif
+      else
+         png_handle_unknown(png_ptr, info_ptr, length);
+   } while (!(png_ptr->mode & PNG_HAVE_IEND));
+}
+
+/* free all memory used by the read */
+void
+png_destroy_read_struct(png_structpp png_ptr_ptr, png_infopp info_ptr_ptr,
+   png_infopp end_info_ptr_ptr)
+{
+   png_structp png_ptr = NULL;
+   png_infop info_ptr = NULL, end_info_ptr = NULL;
+#ifdef PNG_USER_MEM_SUPPORTED
+   png_free_ptr free_fn = NULL;
+#endif /* PNG_USER_MEM_SUPPORTED */
+
+   png_debug(1, "in png_destroy_read_struct\n");
+   /* save jump buffer and error functions */
+   if (png_ptr_ptr != NULL)
+      png_ptr = *png_ptr_ptr;
+
+   if (info_ptr_ptr != NULL)
+      info_ptr = *info_ptr_ptr;
+
+   if (end_info_ptr_ptr != NULL)
+      end_info_ptr = *end_info_ptr_ptr;
+
+#ifdef PNG_USER_MEM_SUPPORTED
+   free_fn = png_ptr->free_fn;
+#endif
+
+   png_read_destroy(png_ptr, info_ptr, end_info_ptr);
+
+   if (info_ptr != NULL)
+   {
+#if defined(PNG_READ_tEXt_SUPPORTED) || defined(PNG_READ_zTXt_SUPPORTED)
+      png_free(png_ptr, info_ptr->text);
+#endif
+
+#ifdef PNG_USER_MEM_SUPPORTED
+      png_destroy_struct_2((png_voidp)info_ptr, free_fn);
+#else
+      png_destroy_struct((png_voidp)info_ptr);
+#endif
+      *info_ptr_ptr = (png_infop)NULL;
+   }
+
+   if (end_info_ptr != NULL)
+   {
+#if defined(PNG_READ_tEXt_SUPPORTED) || defined(PNG_READ_zTXt_SUPPORTED)
+      png_free(png_ptr, end_info_ptr->text);
+#endif
+#ifdef PNG_USER_MEM_SUPPORTED
+      png_destroy_struct_2((png_voidp)end_info_ptr, free_fn);
+#else
+      png_destroy_struct((png_voidp)end_info_ptr);
+#endif
+      *end_info_ptr_ptr = (png_infop)NULL;
+   }
+
+   if (png_ptr != NULL)
+   {
+#ifdef PNG_USER_MEM_SUPPORTED
+      png_destroy_struct_2((png_voidp)png_ptr, free_fn);
+#else
+      png_destroy_struct((png_voidp)png_ptr);
+#endif
+      *png_ptr_ptr = (png_structp)NULL;
+   }
+}
+
+/* free all memory used by the read (old method) */
+void
+png_read_destroy(png_structp png_ptr, png_infop info_ptr, png_infop end_info_ptr)
+{
+   jmp_buf tmp_jmp;
+   png_error_ptr error_fn;
+   png_error_ptr warning_fn;
+   png_voidp error_ptr;
+#ifdef PNG_USER_MEM_SUPPORTED
+   png_free_ptr free_fn;
+#endif
+
+   png_debug(1, "in png_read_destroy\n");
+   /* save jump buffer and error functions */
+   if (info_ptr != NULL)
+      png_info_destroy(png_ptr, info_ptr);
+
+   if (end_info_ptr != NULL)
+      png_info_destroy(png_ptr, end_info_ptr);
+
+   png_free(png_ptr, png_ptr->zbuf);
+   png_free(png_ptr, png_ptr->row_buf);
+   png_free(png_ptr, png_ptr->prev_row);
+#if defined(PNG_READ_DITHER_SUPPORTED)
+   png_free(png_ptr, png_ptr->palette_lookup);
+   png_free(png_ptr, png_ptr->dither_index);
+#endif
+#if defined(PNG_READ_GAMMA_SUPPORTED)
+   png_free(png_ptr, png_ptr->gamma_table);
+#endif
+#if defined(PNG_READ_BACKGROUND_SUPPORTED)
+   png_free(png_ptr, png_ptr->gamma_from_1);
+   png_free(png_ptr, png_ptr->gamma_to_1);
+#endif
+   if (png_ptr->flags & PNG_FLAG_FREE_PALETTE)
+      png_zfree(png_ptr, png_ptr->palette);
+   if (png_ptr->flags & PNG_FLAG_FREE_TRANS)
+      png_free(png_ptr, png_ptr->trans);
+#if defined(PNG_READ_hIST_SUPPORTED)
+   if (png_ptr->flags & PNG_FLAG_FREE_HIST)
+      png_free(png_ptr, png_ptr->hist);
+#endif
+#if defined(PNG_READ_GAMMA_SUPPORTED)
+   if (png_ptr->gamma_16_table != NULL)
+   {
+      int i;
+      int istop = (1 << (8 - png_ptr->gamma_shift));
+      for (i = 0; i < istop; i++)
+      {
+         png_free(png_ptr, png_ptr->gamma_16_table[i]);
+      }
+   png_free(png_ptr, png_ptr->gamma_16_table);
+   }
+#if defined(PNG_READ_BACKGROUND_SUPPORTED)
+   if (png_ptr->gamma_16_from_1 != NULL)
+   {
+      int i;
+      int istop = (1 << (8 - png_ptr->gamma_shift));
+      for (i = 0; i < istop; i++)
+      {
+         png_free(png_ptr, png_ptr->gamma_16_from_1[i]);
+      }
+   png_free(png_ptr, png_ptr->gamma_16_from_1);
+   }
+   if (png_ptr->gamma_16_to_1 != NULL)
+   {
+      int i;
+      int istop = (1 << (8 - png_ptr->gamma_shift));
+      for (i = 0; i < istop; i++)
+      {
+         png_free(png_ptr, png_ptr->gamma_16_to_1[i]);
+      }
+   png_free(png_ptr, png_ptr->gamma_16_to_1);
+   }
+#endif
+#endif
+#if defined(PNG_TIME_RFC1123_SUPPORTED)
+   png_free(png_ptr, png_ptr->time_buffer);
+#endif /* PNG_TIME_RFC1123_SUPPORTED */
+
+   inflateEnd(&png_ptr->zstream);
+#ifdef PNG_PROGRESSIVE_READ_SUPPORTED
+   png_free(png_ptr, png_ptr->save_buffer);
+#endif
+
+   /* Save the important info out of the png_struct, in case it is
+    * being used again.
+    */
+   png_memcpy(tmp_jmp, png_ptr->jmpbuf, sizeof (jmp_buf));
+
+   error_fn = png_ptr->error_fn;
+   warning_fn = png_ptr->warning_fn;
+   error_ptr = png_ptr->error_ptr;
+#ifdef PNG_USER_MEM_SUPPORTED
+   free_fn = png_ptr->free_fn;
+#endif
+
+   png_memset(png_ptr, 0, sizeof (png_struct));
+
+   png_ptr->error_fn = error_fn;
+   png_ptr->warning_fn = warning_fn;
+   png_ptr->error_ptr = error_ptr;
+#ifdef PNG_USER_MEM_SUPPORTED
+   png_ptr->free_fn = free_fn;
+#endif
+
+   png_memcpy(png_ptr->jmpbuf, tmp_jmp, sizeof (jmp_buf));
+}
+
+void
+png_set_read_status_fn(png_structp png_ptr, png_read_status_ptr read_row_fn)
+{
+   png_ptr->read_row_fn = read_row_fn;
+}

src/png/pngrio.c

@@ -0,0 +1,156 @@
+
+/* pngrio.c - functions for data input
+ *
+ * libpng 1.0.3 - January 14, 1999
+ * For conditions of distribution and use, see copyright notice in png.h
+ * Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
+ * Copyright (c) 1996, 1997 Andreas Dilger
+ * Copyright (c) 1998, 1999 Glenn Randers-Pehrson
+ *
+ * This file provides a location for all input.  Users who need
+ * special handling are expected to write a function that has the same
+ * arguments as this and performs a similar function, but that possibly
+ * has a different input method.  Note that you shouldn't change this
+ * function, but rather write a replacement function and then make
+ * libpng use it at run time with png_set_read_fn(...).
+ */
+
+#define PNG_INTERNAL
+#include "png.h"
+
+/* Read the data from whatever input you are using.  The default routine
+   reads from a file pointer.  Note that this routine sometimes gets called
+   with very small lengths, so you should implement some kind of simple
+   buffering if you are using unbuffered reads.  This should never be asked
+   to read more then 64K on a 16 bit machine. */
+void
+png_read_data(png_structp png_ptr, png_bytep data, png_size_t length)
+{
+   png_debug1(4,"reading %d bytes\n", length);
+   if (png_ptr->read_data_fn != NULL)
+      (*(png_ptr->read_data_fn))(png_ptr, data, length);
+   else
+      png_error(png_ptr, "Call to NULL read function");
+}
+
+#if !defined(PNG_NO_STDIO)
+/* This is the function that does the actual reading of data.  If you are
+   not reading from a standard C stream, you should create a replacement
+   read_data function and use it at run time with png_set_read_fn(), rather
+   than changing the library. */
+#ifndef USE_FAR_KEYWORD
+#ifdef __VISAGECPP__
+static void _Optlink
+png_default_read_data(png_structp png_ptr, png_bytep data, png_size_t length)
+#else
+static void
+png_default_read_data(png_structp png_ptr, png_bytep data, png_size_t length)
+#endif
+{
+   png_size_t check;
+
+   /* fread() returns 0 on error, so it is OK to store this in a png_size_t
+    * instead of an int, which is what fread() actually returns.
+    */
+   check = (png_size_t)fread(data, (png_size_t)1, length,
+      (FILE *)png_ptr->io_ptr);
+
+   if (check != length)
+   {
+      png_error(png_ptr, "Read Error");
+   }
+}
+#else
+/* this is the model-independent version. Since the standard I/O library
+   can't handle far buffers in the medium and small models, we have to copy
+   the data.
+*/
+
+#define NEAR_BUF_SIZE 1024
+#define MIN(a,b) (a <= b ? a : b)
+
+static void
+png_default_read_data(png_structp png_ptr, png_bytep data, png_size_t length)
+{
+   int check;
+   png_byte *n_data;
+   FILE *io_ptr;
+
+   /* Check if data really is near. If so, use usual code. */
+   n_data = (png_byte *)CVT_PTR_NOCHECK(data);
+   io_ptr = (FILE *)CVT_PTR(png_ptr->io_ptr);
+   if ((png_bytep)n_data == data)
+   {
+      check = fread(n_data, 1, length, io_ptr);
+   }
+   else
+   {
+      png_byte buf[NEAR_BUF_SIZE];
+      png_size_t read, remaining, err;
+      check = 0;
+      remaining = length;
+      do
+      {
+         read = MIN(NEAR_BUF_SIZE, remaining);
+         err = fread(buf, (png_size_t)1, read, io_ptr);
+         png_memcpy(data, buf, read); /* copy far buffer to near buffer */
+         if(err != read)
+            break;
+         else
+            check += err;
+         data += read;
+         remaining -= read;
+      }
+      while (remaining != 0);
+   }
+   if ((png_uint_32)check != (png_uint_32)length)
+   {
+      png_error(png_ptr, "read Error");
+   }
+}
+#endif
+#endif
+
+/* This function allows the application to supply a new input function
+   for libpng if standard C streams aren't being used.
+
+   This function takes as its arguments:
+   png_ptr      - pointer to a png input data structure
+   io_ptr       - pointer to user supplied structure containing info about
+                  the input functions.  May be NULL.
+   read_data_fn - pointer to a new input function that takes as its
+                  arguments a pointer to a png_struct, a pointer to
+                  a location where input data can be stored, and a 32-bit
+                  unsigned int that is the number of bytes to be read.
+                  To exit and output any fatal error messages the new write
+                  function should call png_error(png_ptr, "Error msg"). */
+void
+png_set_read_fn(png_structp png_ptr, png_voidp io_ptr,
+   png_rw_ptr read_data_fn)
+{
+   png_ptr->io_ptr = io_ptr;
+
+#if !defined(PNG_NO_STDIO)
+   if (read_data_fn != NULL)
+      png_ptr->read_data_fn = read_data_fn;
+   else
+      png_ptr->read_data_fn = png_default_read_data;
+#else
+   png_ptr->read_data_fn = read_data_fn;
+#endif
+
+   /* It is an error to write to a read device */
+   if (png_ptr->write_data_fn != NULL)
+   {
+      png_ptr->write_data_fn = NULL;
+      png_warning(png_ptr,
+         "It's an error to set both read_data_fn and write_data_fn in the ");
+      png_warning(png_ptr,
+         "same structure.  Resetting write_data_fn to NULL.");
+   }
+
+#if defined(PNG_WRITE_FLUSH_SUPPORTED)
+   png_ptr->output_flush_fn = NULL;
+#endif /* PNG_WRITE_FLUSH_SUPPORTED */
+}
+

src/png/pngset.c

@@ -0,0 +1,380 @@
+
+/* pngset.c - storage of image information into info struct
+ *
+ * libpng 1.0.3 - January 14, 1999
+ * For conditions of distribution and use, see copyright notice in png.h
+ * Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
+ * Copyright (c) 1996, 1997 Andreas Dilger
+ * Copyright (c) 1998, 1999 Glenn Randers-Pehrson
+ *
+ * The functions here are used during reads to store data from the file
+ * into the info struct, and during writes to store application data
+ * into the info struct for writing into the file.  This abstracts the
+ * info struct and allows us to change the structure in the future.
+ */
+
+#define PNG_INTERNAL
+#include "png.h"
+
+#if defined(PNG_READ_bKGD_SUPPORTED) || defined(PNG_WRITE_bKGD_SUPPORTED)
+void
+png_set_bKGD(png_structp png_ptr, png_infop info_ptr, png_color_16p background)
+{
+   png_debug1(1, "in %s storage function\n", "bKGD");
+   if (png_ptr == NULL || info_ptr == NULL)
+      return;
+
+   png_memcpy(&(info_ptr->background), background, sizeof(png_color_16));
+   info_ptr->valid |= PNG_INFO_bKGD;
+}
+#endif
+
+#if defined(PNG_READ_cHRM_SUPPORTED) || defined(PNG_WRITE_cHRM_SUPPORTED)
+void
+png_set_cHRM(png_structp png_ptr, png_infop info_ptr,
+   double white_x, double white_y, double red_x, double red_y,
+   double green_x, double green_y, double blue_x, double blue_y)
+{
+   png_debug1(1, "in %s storage function\n", "cHRM");
+   if (png_ptr == NULL || info_ptr == NULL)
+      return;
+
+   info_ptr->x_white = (float)white_x;
+   info_ptr->y_white = (float)white_y;
+   info_ptr->x_red   = (float)red_x;
+   info_ptr->y_red   = (float)red_y;
+   info_ptr->x_green = (float)green_x;
+   info_ptr->y_green = (float)green_y;
+   info_ptr->x_blue  = (float)blue_x;
+   info_ptr->y_blue  = (float)blue_y;
+   info_ptr->valid |= PNG_INFO_cHRM;
+}
+#endif
+
+#if defined(PNG_READ_gAMA_SUPPORTED) || defined(PNG_WRITE_gAMA_SUPPORTED)
+void
+png_set_gAMA(png_structp png_ptr, png_infop info_ptr, double file_gamma)
+{
+   png_debug1(1, "in %s storage function\n", "gAMA");
+   if (png_ptr == NULL || info_ptr == NULL)
+      return;
+
+   info_ptr->gamma = (float)file_gamma;
+   info_ptr->valid |= PNG_INFO_gAMA;
+}
+#endif
+
+#if defined(PNG_READ_hIST_SUPPORTED) || defined(PNG_WRITE_hIST_SUPPORTED)
+void
+png_set_hIST(png_structp png_ptr, png_infop info_ptr, png_uint_16p hist)
+{
+   png_debug1(1, "in %s storage function\n", "hIST");
+   if (png_ptr == NULL || info_ptr == NULL)
+      return;
+
+   info_ptr->hist = hist;
+   info_ptr->valid |= PNG_INFO_hIST;
+}
+#endif
+
+void
+png_set_IHDR(png_structp png_ptr, png_infop info_ptr,
+   png_uint_32 width, png_uint_32 height, int bit_depth,
+   int color_type, int interlace_type, int compression_type,
+   int filter_type)
+{
+   int rowbytes_per_pixel;
+   png_debug1(1, "in %s storage function\n", "IHDR");
+   if (png_ptr == NULL || info_ptr == NULL)
+      return;
+
+   info_ptr->width = width;
+   info_ptr->height = height;
+   info_ptr->bit_depth = (png_byte)bit_depth;
+   info_ptr->color_type =(png_byte) color_type;
+   info_ptr->compression_type = (png_byte)compression_type;
+   info_ptr->filter_type = (png_byte)filter_type;
+   info_ptr->interlace_type = (png_byte)interlace_type;
+   if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
+      info_ptr->channels = 1;
+   else if (info_ptr->color_type & PNG_COLOR_MASK_COLOR)
+      info_ptr->channels = 3;
+   else
+      info_ptr->channels = 1;
+   if (info_ptr->color_type & PNG_COLOR_MASK_ALPHA)
+      info_ptr->channels++;
+   info_ptr->pixel_depth = (png_byte)(info_ptr->channels * info_ptr->bit_depth);
+
+   /* check for overflow */
+   rowbytes_per_pixel = (info_ptr->pixel_depth + 7) >> 3;
+   if (( width > (png_uint_32)2147483647L/rowbytes_per_pixel))
+   {
+      png_warning(png_ptr,
+         "Width too large to process image data; rowbytes will overflow.");
+      info_ptr->rowbytes = (png_size_t)0;
+   }
+   else
+      info_ptr->rowbytes = (info_ptr->width * info_ptr->pixel_depth + 7) >> 3;
+}
+
+#if defined(PNG_READ_oFFs_SUPPORTED) || defined(PNG_WRITE_oFFs_SUPPORTED)
+void
+png_set_oFFs(png_structp png_ptr, png_infop info_ptr,
+   png_uint_32 offset_x, png_uint_32 offset_y, int unit_type)
+{
+   png_debug1(1, "in %s storage function\n", "oFFs");
+   if (png_ptr == NULL || info_ptr == NULL)
+      return;
+
+   info_ptr->x_offset = offset_x;
+   info_ptr->y_offset = offset_y;
+   info_ptr->offset_unit_type = (png_byte)unit_type;
+   info_ptr->valid |= PNG_INFO_oFFs;
+}
+#endif
+
+#if defined(PNG_READ_pCAL_SUPPORTED) || defined(PNG_WRITE_pCAL_SUPPORTED)
+void
+png_set_pCAL(png_structp png_ptr, png_infop info_ptr,
+   png_charp purpose, png_int_32 X0, png_int_32 X1, int type, int nparams,
+   png_charp units, png_charpp params)
+{
+   png_uint_32 length;
+   int i;
+
+   png_debug1(1, "in %s storage function\n", "pCAL");
+   if (png_ptr == NULL || info_ptr == NULL)
+      return;
+
+   length = png_strlen(purpose) + 1;
+   png_debug1(3, "allocating purpose for info (%d bytes)\n", length);
+   info_ptr->pcal_purpose = (png_charp)png_malloc(png_ptr, length);
+   png_memcpy(info_ptr->pcal_purpose, purpose, (png_size_t)length);
+
+   png_debug(3, "storing X0, X1, type, and nparams in info\n");
+   info_ptr->pcal_X0 = X0;
+   info_ptr->pcal_X1 = X1;
+   info_ptr->pcal_type = (png_byte)type;
+   info_ptr->pcal_nparams = (png_byte)nparams;
+
+   length = png_strlen(units) + 1;
+   png_debug1(3, "allocating units for info (%d bytes)\n", length);
+   info_ptr->pcal_units = (png_charp)png_malloc(png_ptr, length);
+   png_memcpy(info_ptr->pcal_units, units, (png_size_t)length);
+
+   info_ptr->pcal_params = (png_charpp)png_malloc(png_ptr,
+      (png_uint_32)((nparams + 1) * sizeof(png_charp)));
+   info_ptr->pcal_params[nparams] = NULL;
+
+   for (i = 0; i < nparams; i++)
+   {
+      length = png_strlen(params[i]) + 1;
+      png_debug2(3, "allocating parameter %d for info (%d bytes)\n", i, length);
+      info_ptr->pcal_params[i] = (png_charp)png_malloc(png_ptr, length);
+      png_memcpy(info_ptr->pcal_params[i], params[i], (png_size_t)length);
+   }
+
+   info_ptr->valid |= PNG_INFO_pCAL;
+}
+#endif
+
+#if defined(PNG_READ_pHYs_SUPPORTED) || defined(PNG_WRITE_pHYs_SUPPORTED)
+void
+png_set_pHYs(png_structp png_ptr, png_infop info_ptr,
+   png_uint_32 res_x, png_uint_32 res_y, int unit_type)
+{
+   png_debug1(1, "in %s storage function\n", "pHYs");
+   if (png_ptr == NULL || info_ptr == NULL)
+      return;
+
+   info_ptr->x_pixels_per_unit = res_x;
+   info_ptr->y_pixels_per_unit = res_y;
+   info_ptr->phys_unit_type = (png_byte)unit_type;
+   info_ptr->valid |= PNG_INFO_pHYs;
+}
+#endif
+
+void
+png_set_PLTE(png_structp png_ptr, png_infop info_ptr,
+   png_colorp palette, int num_palette)
+{
+   png_debug1(1, "in %s storage function\n", "PLTE");
+   if (png_ptr == NULL || info_ptr == NULL)
+      return;
+
+   info_ptr->palette = palette;
+   info_ptr->num_palette = (png_uint_16)num_palette;
+   info_ptr->valid |= PNG_INFO_PLTE;
+}
+
+#if defined(PNG_READ_sBIT_SUPPORTED) || defined(PNG_WRITE_sBIT_SUPPORTED)
+void
+png_set_sBIT(png_structp png_ptr, png_infop info_ptr,
+   png_color_8p sig_bit)
+{
+   png_debug1(1, "in %s storage function\n", "sBIT");
+   if (png_ptr == NULL || info_ptr == NULL)
+      return;
+
+   png_memcpy(&(info_ptr->sig_bit), sig_bit, sizeof (png_color_8));
+   info_ptr->valid |= PNG_INFO_sBIT;
+}
+#endif
+
+#if defined(PNG_READ_sRGB_SUPPORTED) || defined(PNG_WRITE_sRGB_SUPPORTED)
+void
+png_set_sRGB(png_structp png_ptr, png_infop info_ptr, int intent)
+{
+   png_debug1(1, "in %s storage function\n", "sRGB");
+   if (png_ptr == NULL || info_ptr == NULL)
+      return;
+
+   info_ptr->srgb_intent = (png_byte)intent;
+   info_ptr->valid |= PNG_INFO_sRGB;
+}
+void
+png_set_sRGB_gAMA_and_cHRM(png_structp png_ptr, png_infop info_ptr,
+   int intent)
+{
+#if defined(PNG_READ_gAMA_SUPPORTED) || defined(PNG_WRITE_gAMA_SUPPORTED)
+   float file_gamma;
+#endif
+#if defined(PNG_READ_cHRM_SUPPORTED) || defined(PNG_WRITE_cHRM_SUPPORTED)
+   float white_x, white_y, red_x, red_y, green_x, green_y, blue_x, blue_y;
+#endif
+   png_debug1(1, "in %s storage function\n", "sRGB_gAMA_and_cHRM");
+   if (png_ptr == NULL || info_ptr == NULL)
+      return;
+
+   png_set_sRGB(png_ptr, info_ptr, intent);
+
+#if defined(PNG_READ_gAMA_SUPPORTED) || defined(PNG_WRITE_gAMA_SUPPORTED)
+   file_gamma = (float).45;
+   png_set_gAMA(png_ptr, info_ptr, file_gamma);
+#endif
+
+#if defined(PNG_READ_cHRM_SUPPORTED) || defined(PNG_WRITE_cHRM_SUPPORTED)
+   white_x = (float).3127;
+   white_y = (float).3290;
+   red_x   = (float).64;
+   red_y   = (float).33;
+   green_x = (float).30;
+   green_y = (float).60;
+   blue_x  = (float).15;
+   blue_y  = (float).06;
+
+   png_set_cHRM(png_ptr, info_ptr,
+      white_x, white_y, red_x, red_y, green_x, green_y, blue_x, blue_y);
+
+#endif
+}
+#endif
+
+#if defined(PNG_READ_tEXt_SUPPORTED) || defined(PNG_WRITE_tEXt_SUPPORTED) || \
+    defined(PNG_READ_zTXt_SUPPORTED) || defined(PNG_WRITE_zTXt_SUPPORTED)
+void
+png_set_text(png_structp png_ptr, png_infop info_ptr, png_textp text_ptr,
+   int num_text)
+{
+   int i;
+
+   png_debug1(1, "in %s storage function\n", (png_ptr->chunk_name[0] == '\0' ?
+      "text" : (png_const_charp)png_ptr->chunk_name));
+
+   if (png_ptr == NULL || info_ptr == NULL || num_text == 0)
+      return;
+
+   /* Make sure we have enough space in the "text" array in info_struct
+    * to hold all of the incoming text_ptr objects.
+    */
+   if (info_ptr->num_text + num_text > info_ptr->max_text)
+   {
+      if (info_ptr->text != NULL)
+      {
+         png_textp old_text;
+         int old_max;
+
+         old_max = info_ptr->max_text;
+         info_ptr->max_text = info_ptr->num_text + num_text + 8;
+         old_text = info_ptr->text;
+         info_ptr->text = (png_textp)png_malloc(png_ptr,
+            (png_uint_32)(info_ptr->max_text * sizeof (png_text)));
+         png_memcpy(info_ptr->text, old_text, (png_size_t)(old_max *
+            sizeof(png_text)));
+         png_free(png_ptr, old_text);
+      }
+      else
+      {
+         info_ptr->max_text = num_text + 8;
+         info_ptr->num_text = 0;
+         info_ptr->text = (png_textp)png_malloc(png_ptr,
+            (png_uint_32)(info_ptr->max_text * sizeof (png_text)));
+      }
+      png_debug1(3, "allocated %d entries for info_ptr->text\n",
+         info_ptr->max_text);
+   }
+
+   for (i = 0; i < num_text; i++)
+   {
+      png_textp textp = &(info_ptr->text[info_ptr->num_text]);
+
+      if (text_ptr[i].text == NULL)
+         text_ptr[i].text = (png_charp)"";
+
+      if (text_ptr[i].text[0] == '\0')
+      {
+         textp->text_length = 0;
+         textp->compression = PNG_TEXT_COMPRESSION_NONE;
+      }
+      else
+      {
+         textp->text_length = png_strlen(text_ptr[i].text);
+         textp->compression = text_ptr[i].compression;
+      }
+      textp->text = text_ptr[i].text;
+      textp->key = text_ptr[i].key;
+      info_ptr->num_text++;
+      png_debug1(3, "transferred text chunk %d\n", info_ptr->num_text);
+   }
+}
+#endif
+
+#if defined(PNG_READ_tIME_SUPPORTED) || defined(PNG_WRITE_tIME_SUPPORTED)
+void
+png_set_tIME(png_structp png_ptr, png_infop info_ptr, png_timep mod_time)
+{
+   png_debug1(1, "in %s storage function\n", "tIME");
+   if (png_ptr == NULL || info_ptr == NULL)
+      return;
+
+   png_memcpy(&(info_ptr->mod_time), mod_time, sizeof (png_time));
+   info_ptr->valid |= PNG_INFO_tIME;
+}
+#endif
+
+#if defined(PNG_READ_tRNS_SUPPORTED) || defined(PNG_WRITE_tRNS_SUPPORTED)
+void
+png_set_tRNS(png_structp png_ptr, png_infop info_ptr,
+   png_bytep trans, int num_trans, png_color_16p trans_values)
+{
+   png_debug1(1, "in %s storage function\n", "tRNS");
+   if (png_ptr == NULL || info_ptr == NULL)
+      return;
+
+   if (trans != NULL)
+   {
+      info_ptr->trans = trans;
+   }
+
+   if (trans_values != NULL)
+   {
+      png_memcpy(&(info_ptr->trans_values), trans_values,
+         sizeof(png_color_16));
+      if (num_trans == 0)
+        num_trans = 1;
+   }
+   info_ptr->num_trans = (png_uint_16)num_trans;
+   info_ptr->valid |= PNG_INFO_tRNS;
+}
+#endif
+

src/png/pngtrans.c

@@ -0,0 +1,572 @@
+
+/* pngtrans.c - transforms the data in a row (used by both readers and writers)
+ *
+ * libpng 1.0.3 - January 14, 1999
+ * For conditions of distribution and use, see copyright notice in png.h
+ * Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
+ * Copyright (c) 1996, 1997 Andreas Dilger
+ * Copyright (c) 1998, 1999 Glenn Randers-Pehrson
+ */
+
+#define PNG_INTERNAL
+#include "png.h"
+
+#if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED)
+/* turn on bgr to rgb mapping */
+void
+png_set_bgr(png_structp png_ptr)
+{
+   png_debug(1, "in png_set_bgr\n");
+   png_ptr->transformations |= PNG_BGR;
+}
+#endif
+
+#if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED)
+/* turn on 16 bit byte swapping */
+void
+png_set_swap(png_structp png_ptr)
+{
+   png_debug(1, "in png_set_swap\n");
+   if (png_ptr->bit_depth == 16)
+      png_ptr->transformations |= PNG_SWAP_BYTES;
+}
+#endif
+
+#if defined(PNG_READ_PACK_SUPPORTED) || defined(PNG_WRITE_PACK_SUPPORTED)
+/* turn on pixel packing */
+void
+png_set_packing(png_structp png_ptr)
+{
+   png_debug(1, "in png_set_packing\n");
+   if (png_ptr->bit_depth < 8)
+   {
+      png_ptr->transformations |= PNG_PACK;
+      png_ptr->usr_bit_depth = 8;
+   }
+}
+#endif
+
+#if defined(PNG_READ_PACKSWAP_SUPPORTED)||defined(PNG_WRITE_PACKSWAP_SUPPORTED)
+/* turn on packed pixel swapping */
+void
+png_set_packswap(png_structp png_ptr)
+{
+   png_debug(1, "in png_set_packswap\n");
+   if (png_ptr->bit_depth < 8)
+      png_ptr->transformations |= PNG_PACKSWAP;
+}
+#endif
+
+#if defined(PNG_READ_SHIFT_SUPPORTED) || defined(PNG_WRITE_SHIFT_SUPPORTED)
+void
+png_set_shift(png_structp png_ptr, png_color_8p true_bits)
+{
+   png_debug(1, "in png_set_shift\n");
+   png_ptr->transformations |= PNG_SHIFT;
+   png_ptr->shift = *true_bits;
+}
+#endif
+
+#if defined(PNG_READ_INTERLACING_SUPPORTED) || \
+    defined(PNG_WRITE_INTERLACING_SUPPORTED)
+int
+png_set_interlace_handling(png_structp png_ptr)
+{
+   png_debug(1, "in png_set_interlace handling\n");
+   if (png_ptr->interlaced)
+   {
+      png_ptr->transformations |= PNG_INTERLACE;
+      return (7);
+   }
+
+   return (1);
+}
+#endif
+
+#if defined(PNG_READ_FILLER_SUPPORTED) || defined(PNG_WRITE_FILLER_SUPPORTED)
+/* Add a filler byte on read, or remove a filler or alpha byte on write.
+ * The filler type has changed in v0.95 to allow future 2-byte fillers
+ * for 48-bit input data, as well as to avoid problems with some compilers
+ * that don't like bytes as parameters.
+ */
+void
+png_set_filler(png_structp png_ptr, png_uint_32 filler, int filler_loc)
+{
+   png_debug(1, "in png_set_filler\n");
+   png_ptr->transformations |= PNG_FILLER;
+   png_ptr->filler = (png_byte)filler;
+   if (filler_loc == PNG_FILLER_AFTER)
+      png_ptr->flags |= PNG_FLAG_FILLER_AFTER;
+   else
+      png_ptr->flags &= ~PNG_FLAG_FILLER_AFTER;
+
+   /* This should probably go in the "do_filler" routine.
+    * I attempted to do that in libpng-1.0.1a but that caused problems
+    * so I restored it in libpng-1.0.2a
+   */
+
+   if (png_ptr->color_type == PNG_COLOR_TYPE_RGB)
+   {
+      png_ptr->usr_channels = 4;
+   }
+
+   /* Also I added this in libpng-1.0.2a (what happens when we expand
+    * a less-than-8-bit grayscale to GA? */
+
+   if (png_ptr->color_type == PNG_COLOR_TYPE_GRAY && png_ptr->bit_depth >= 8)
+   {
+      png_ptr->usr_channels = 2;
+   }
+}
+#endif
+
+#if defined(PNG_READ_SWAP_ALPHA_SUPPORTED) || \
+    defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED)
+void
+png_set_swap_alpha(png_structp png_ptr)
+{
+   png_debug(1, "in png_set_swap_alpha\n");
+   png_ptr->transformations |= PNG_SWAP_ALPHA;
+}
+#endif
+
+#if defined(PNG_READ_INVERT_ALPHA_SUPPORTED) || \
+    defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED)
+void
+png_set_invert_alpha(png_structp png_ptr)
+{
+   png_debug(1, "in png_set_invert_alpha\n");
+   png_ptr->transformations |= PNG_INVERT_ALPHA;
+}
+#endif
+
+#if defined(PNG_READ_INVERT_SUPPORTED) || defined(PNG_WRITE_INVERT_SUPPORTED)
+void
+png_set_invert_mono(png_structp png_ptr)
+{
+   png_debug(1, "in png_set_invert_mono\n");
+   png_ptr->transformations |= PNG_INVERT_MONO;
+}
+
+/* invert monochrome grayscale data */
+void
+png_do_invert(png_row_infop row_info, png_bytep row)
+{
+   png_debug(1, "in png_do_invert\n");
+   if (row_info->bit_depth == 1 &&
+#if defined(PNG_USELESS_TESTS_SUPPORTED)
+       row != NULL && row_info != NULL &&
+#endif
+       row_info->color_type == PNG_COLOR_TYPE_GRAY)
+   {
+      png_bytep rp = row;
+      png_uint_32 i;
+      png_uint_32 istop = row_info->rowbytes;
+
+      for (i = 0; i < istop; i++)
+      {
+         *rp = (png_byte)(~(*rp));
+         rp++;
+      }
+   }
+}
+#endif
+
+#if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED)
+/* swaps byte order on 16 bit depth images */
+void
+png_do_swap(png_row_infop row_info, png_bytep row)
+{
+   png_debug(1, "in png_do_swap\n");
+   if (
+#if defined(PNG_USELESS_TESTS_SUPPORTED)
+       row != NULL && row_info != NULL &&
+#endif
+       row_info->bit_depth == 16)
+   {
+      png_bytep rp = row;
+      png_uint_32 i;
+      png_uint_32 istop= row_info->width * row_info->channels;
+
+      for (i = 0; i < istop; i++, rp += 2)
+      {
+         png_byte t = *rp;
+         *rp = *(rp + 1);
+         *(rp + 1) = t;
+      }
+   }
+}
+#endif
+
+#if defined(PNG_READ_PACKSWAP_SUPPORTED)||defined(PNG_WRITE_PACKSWAP_SUPPORTED)
+static png_byte onebppswaptable[256] = {
+   0x00, 0x80, 0x40, 0xC0, 0x20, 0xA0, 0x60, 0xE0,
+   0x10, 0x90, 0x50, 0xD0, 0x30, 0xB0, 0x70, 0xF0,
+   0x08, 0x88, 0x48, 0xC8, 0x28, 0xA8, 0x68, 0xE8,
+   0x18, 0x98, 0x58, 0xD8, 0x38, 0xB8, 0x78, 0xF8,
+   0x04, 0x84, 0x44, 0xC4, 0x24, 0xA4, 0x64, 0xE4,
+   0x14, 0x94, 0x54, 0xD4, 0x34, 0xB4, 0x74, 0xF4,
+   0x0C, 0x8C, 0x4C, 0xCC, 0x2C, 0xAC, 0x6C, 0xEC,
+   0x1C, 0x9C, 0x5C, 0xDC, 0x3C, 0xBC, 0x7C, 0xFC,
+   0x02, 0x82, 0x42, 0xC2, 0x22, 0xA2, 0x62, 0xE2,
+   0x12, 0x92, 0x52, 0xD2, 0x32, 0xB2, 0x72, 0xF2,
+   0x0A, 0x8A, 0x4A, 0xCA, 0x2A, 0xAA, 0x6A, 0xEA,
+   0x1A, 0x9A, 0x5A, 0xDA, 0x3A, 0xBA, 0x7A, 0xFA,
+   0x06, 0x86, 0x46, 0xC6, 0x26, 0xA6, 0x66, 0xE6,
+   0x16, 0x96, 0x56, 0xD6, 0x36, 0xB6, 0x76, 0xF6,
+   0x0E, 0x8E, 0x4E, 0xCE, 0x2E, 0xAE, 0x6E, 0xEE,
+   0x1E, 0x9E, 0x5E, 0xDE, 0x3E, 0xBE, 0x7E, 0xFE,
+   0x01, 0x81, 0x41, 0xC1, 0x21, 0xA1, 0x61, 0xE1,
+   0x11, 0x91, 0x51, 0xD1, 0x31, 0xB1, 0x71, 0xF1,
+   0x09, 0x89, 0x49, 0xC9, 0x29, 0xA9, 0x69, 0xE9,
+   0x19, 0x99, 0x59, 0xD9, 0x39, 0xB9, 0x79, 0xF9,
+   0x05, 0x85, 0x45, 0xC5, 0x25, 0xA5, 0x65, 0xE5,
+   0x15, 0x95, 0x55, 0xD5, 0x35, 0xB5, 0x75, 0xF5,
+   0x0D, 0x8D, 0x4D, 0xCD, 0x2D, 0xAD, 0x6D, 0xED,
+   0x1D, 0x9D, 0x5D, 0xDD, 0x3D, 0xBD, 0x7D, 0xFD,
+   0x03, 0x83, 0x43, 0xC3, 0x23, 0xA3, 0x63, 0xE3,
+   0x13, 0x93, 0x53, 0xD3, 0x33, 0xB3, 0x73, 0xF3,
+   0x0B, 0x8B, 0x4B, 0xCB, 0x2B, 0xAB, 0x6B, 0xEB,
+   0x1B, 0x9B, 0x5B, 0xDB, 0x3B, 0xBB, 0x7B, 0xFB,
+   0x07, 0x87, 0x47, 0xC7, 0x27, 0xA7, 0x67, 0xE7,
+   0x17, 0x97, 0x57, 0xD7, 0x37, 0xB7, 0x77, 0xF7,
+   0x0F, 0x8F, 0x4F, 0xCF, 0x2F, 0xAF, 0x6F, 0xEF,
+   0x1F, 0x9F, 0x5F, 0xDF, 0x3F, 0xBF, 0x7F, 0xFF
+};
+
+static png_byte twobppswaptable[256] = {
+   0x00, 0x40, 0x80, 0xC0, 0x10, 0x50, 0x90, 0xD0,
+   0x20, 0x60, 0xA0, 0xE0, 0x30, 0x70, 0xB0, 0xF0,
+   0x04, 0x44, 0x84, 0xC4, 0x14, 0x54, 0x94, 0xD4,
+   0x24, 0x64, 0xA4, 0xE4, 0x34, 0x74, 0xB4, 0xF4,
+   0x08, 0x48, 0x88, 0xC8, 0x18, 0x58, 0x98, 0xD8,
+   0x28, 0x68, 0xA8, 0xE8, 0x38, 0x78, 0xB8, 0xF8,
+   0x0C, 0x4C, 0x8C, 0xCC, 0x1C, 0x5C, 0x9C, 0xDC,
+   0x2C, 0x6C, 0xAC, 0xEC, 0x3C, 0x7C, 0xBC, 0xFC,
+   0x01, 0x41, 0x81, 0xC1, 0x11, 0x51, 0x91, 0xD1,
+   0x21, 0x61, 0xA1, 0xE1, 0x31, 0x71, 0xB1, 0xF1,
+   0x05, 0x45, 0x85, 0xC5, 0x15, 0x55, 0x95, 0xD5,
+   0x25, 0x65, 0xA5, 0xE5, 0x35, 0x75, 0xB5, 0xF5,
+   0x09, 0x49, 0x89, 0xC9, 0x19, 0x59, 0x99, 0xD9,
+   0x29, 0x69, 0xA9, 0xE9, 0x39, 0x79, 0xB9, 0xF9,
+   0x0D, 0x4D, 0x8D, 0xCD, 0x1D, 0x5D, 0x9D, 0xDD,
+   0x2D, 0x6D, 0xAD, 0xED, 0x3D, 0x7D, 0xBD, 0xFD,
+   0x02, 0x42, 0x82, 0xC2, 0x12, 0x52, 0x92, 0xD2,
+   0x22, 0x62, 0xA2, 0xE2, 0x32, 0x72, 0xB2, 0xF2,
+   0x06, 0x46, 0x86, 0xC6, 0x16, 0x56, 0x96, 0xD6,
+   0x26, 0x66, 0xA6, 0xE6, 0x36, 0x76, 0xB6, 0xF6,
+   0x0A, 0x4A, 0x8A, 0xCA, 0x1A, 0x5A, 0x9A, 0xDA,
+   0x2A, 0x6A, 0xAA, 0xEA, 0x3A, 0x7A, 0xBA, 0xFA,
+   0x0E, 0x4E, 0x8E, 0xCE, 0x1E, 0x5E, 0x9E, 0xDE,
+   0x2E, 0x6E, 0xAE, 0xEE, 0x3E, 0x7E, 0xBE, 0xFE,
+   0x03, 0x43, 0x83, 0xC3, 0x13, 0x53, 0x93, 0xD3,
+   0x23, 0x63, 0xA3, 0xE3, 0x33, 0x73, 0xB3, 0xF3,
+   0x07, 0x47, 0x87, 0xC7, 0x17, 0x57, 0x97, 0xD7,
+   0x27, 0x67, 0xA7, 0xE7, 0x37, 0x77, 0xB7, 0xF7,
+   0x0B, 0x4B, 0x8B, 0xCB, 0x1B, 0x5B, 0x9B, 0xDB,
+   0x2B, 0x6B, 0xAB, 0xEB, 0x3B, 0x7B, 0xBB, 0xFB,
+   0x0F, 0x4F, 0x8F, 0xCF, 0x1F, 0x5F, 0x9F, 0xDF,
+   0x2F, 0x6F, 0xAF, 0xEF, 0x3F, 0x7F, 0xBF, 0xFF
+};
+
+static png_byte fourbppswaptable[256] = {
+   0x00, 0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x70,
+   0x80, 0x90, 0xA0, 0xB0, 0xC0, 0xD0, 0xE0, 0xF0,
+   0x01, 0x11, 0x21, 0x31, 0x41, 0x51, 0x61, 0x71,
+   0x81, 0x91, 0xA1, 0xB1, 0xC1, 0xD1, 0xE1, 0xF1,
+   0x02, 0x12, 0x22, 0x32, 0x42, 0x52, 0x62, 0x72,
+   0x82, 0x92, 0xA2, 0xB2, 0xC2, 0xD2, 0xE2, 0xF2,
+   0x03, 0x13, 0x23, 0x33, 0x43, 0x53, 0x63, 0x73,
+   0x83, 0x93, 0xA3, 0xB3, 0xC3, 0xD3, 0xE3, 0xF3,
+   0x04, 0x14, 0x24, 0x34, 0x44, 0x54, 0x64, 0x74,
+   0x84, 0x94, 0xA4, 0xB4, 0xC4, 0xD4, 0xE4, 0xF4,
+   0x05, 0x15, 0x25, 0x35, 0x45, 0x55, 0x65, 0x75,
+   0x85, 0x95, 0xA5, 0xB5, 0xC5, 0xD5, 0xE5, 0xF5,
+   0x06, 0x16, 0x26, 0x36, 0x46, 0x56, 0x66, 0x76,
+   0x86, 0x96, 0xA6, 0xB6, 0xC6, 0xD6, 0xE6, 0xF6,
+   0x07, 0x17, 0x27, 0x37, 0x47, 0x57, 0x67, 0x77,
+   0x87, 0x97, 0xA7, 0xB7, 0xC7, 0xD7, 0xE7, 0xF7,
+   0x08, 0x18, 0x28, 0x38, 0x48, 0x58, 0x68, 0x78,
+   0x88, 0x98, 0xA8, 0xB8, 0xC8, 0xD8, 0xE8, 0xF8,
+   0x09, 0x19, 0x29, 0x39, 0x49, 0x59, 0x69, 0x79,
+   0x89, 0x99, 0xA9, 0xB9, 0xC9, 0xD9, 0xE9, 0xF9,
+   0x0A, 0x1A, 0x2A, 0x3A, 0x4A, 0x5A, 0x6A, 0x7A,
+   0x8A, 0x9A, 0xAA, 0xBA, 0xCA, 0xDA, 0xEA, 0xFA,
+   0x0B, 0x1B, 0x2B, 0x3B, 0x4B, 0x5B, 0x6B, 0x7B,
+   0x8B, 0x9B, 0xAB, 0xBB, 0xCB, 0xDB, 0xEB, 0xFB,
+   0x0C, 0x1C, 0x2C, 0x3C, 0x4C, 0x5C, 0x6C, 0x7C,
+   0x8C, 0x9C, 0xAC, 0xBC, 0xCC, 0xDC, 0xEC, 0xFC,
+   0x0D, 0x1D, 0x2D, 0x3D, 0x4D, 0x5D, 0x6D, 0x7D,
+   0x8D, 0x9D, 0xAD, 0xBD, 0xCD, 0xDD, 0xED, 0xFD,
+   0x0E, 0x1E, 0x2E, 0x3E, 0x4E, 0x5E, 0x6E, 0x7E,
+   0x8E, 0x9E, 0xAE, 0xBE, 0xCE, 0xDE, 0xEE, 0xFE,
+   0x0F, 0x1F, 0x2F, 0x3F, 0x4F, 0x5F, 0x6F, 0x7F,
+   0x8F, 0x9F, 0xAF, 0xBF, 0xCF, 0xDF, 0xEF, 0xFF
+};
+
+/* swaps pixel packing order within bytes */
+void
+png_do_packswap(png_row_infop row_info, png_bytep row)
+{
+   png_debug(1, "in png_do_packswap\n");
+   if (
+#if defined(PNG_USELESS_TESTS_SUPPORTED)
+       row != NULL && row_info != NULL &&
+#endif
+       row_info->bit_depth < 8)
+   {
+      png_bytep rp, end, table;
+
+      end = row + row_info->rowbytes;
+
+      if (row_info->bit_depth == 1)
+         table = onebppswaptable;
+      else if (row_info->bit_depth == 2)
+         table = twobppswaptable;
+      else if (row_info->bit_depth == 4)
+         table = fourbppswaptable;
+      else
+         return;
+
+      for (rp = row; rp < end; rp++)
+         *rp = table[*rp];
+   }
+}
+#endif /* PNG_READ_PACKSWAP_SUPPORTED or PNG_WRITE_PACKSWAP_SUPPORTED */
+
+#if defined(PNG_WRITE_FILLER_SUPPORTED) || \
+    defined(PNG_READ_STRIP_ALPHA_SUPPORTED)
+/* remove filler or alpha byte(s) */
+void
+png_do_strip_filler(png_row_infop row_info, png_bytep row, png_uint_32 flags)
+{
+   png_debug(1, "in png_do_strip_filler\n");
+#if defined(PNG_USELESS_TESTS_SUPPORTED)
+   if (row != NULL && row_info != NULL)
+#endif
+   {
+/*
+      if (row_info->color_type == PNG_COLOR_TYPE_RGB ||
+          row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
+*/
+      png_bytep sp=row;
+      png_bytep dp=row;
+      png_uint_32 row_width=row_info->width;
+      png_uint_32 i;
+
+      if (row_info->channels == 4)
+      {
+         if (row_info->bit_depth == 8)
+         {
+            /* This converts from RGBX or RGBA to RGB */
+            if (flags & PNG_FLAG_FILLER_AFTER)
+            {
+               dp+=3; sp+=4;
+               for (i = 1; i < row_width; i++)
+               {
+                  *dp++ = *sp++;
+                  *dp++ = *sp++;
+                  *dp++ = *sp++;
+                  sp++;
+               }
+            }
+            /* This converts from XRGB or ARGB to RGB */
+            else
+            {
+               for (i = 0; i < row_width; i++)
+               {
+                  sp++;
+                  *dp++ = *sp++;
+                  *dp++ = *sp++;
+                  *dp++ = *sp++;
+               }
+            }
+            row_info->pixel_depth = 24;
+            row_info->rowbytes = row_width * 3;
+         }
+         else /* if (row_info->bit_depth == 16) */
+         {
+            if (flags & PNG_FLAG_FILLER_AFTER)
+            {
+               /* This converts from RRGGBBXX or RRGGBBAA to RRGGBB */
+               sp += 8; dp += 6;
+               for (i = 1; i < row_width; i++)
+               {
+                  /* This could be (although memcpy is probably slower):
+                  png_memcpy(dp, sp, 6);
+                  sp += 8;
+                  dp += 6;
+                  */
+                  *dp++ = *sp++;
+                  *dp++ = *sp++;
+                  *dp++ = *sp++;
+                  *dp++ = *sp++;
+                  *dp++ = *sp++;
+                  *dp++ = *sp++;
+                  sp += 2;
+               }
+            }
+            else
+            {
+               /* This converts from XXRRGGBB or AARRGGBB to RRGGBB */
+               for (i = 0; i < row_width; i++)
+               {
+                  /* This could be (although memcpy is probably slower):
+                  png_memcpy(dp, sp, 6);
+                  sp += 8;
+                  dp += 6;
+                  */
+                  sp+=2;
+                  *dp++ = *sp++;
+                  *dp++ = *sp++;
+                  *dp++ = *sp++;
+                  *dp++ = *sp++;
+                  *dp++ = *sp++;
+                  *dp++ = *sp++;
+               }
+            }
+            row_info->pixel_depth = 48;
+            row_info->rowbytes = row_width * 6;
+         }
+         row_info->channels = 3;
+         row_info->color_type &= ~PNG_COLOR_MASK_ALPHA;
+      }
+/*
+      else if (row_info->color_type == PNG_COLOR_TYPE_GRAY ||
+               row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
+*/
+      else if (row_info->channels == 2)
+      {
+         if (row_info->bit_depth == 8)
+         {
+            /* This converts from GX or GA to G */
+            if (flags & PNG_FLAG_FILLER_AFTER)
+            {
+               for (i = 0; i < row_width; i++)
+               {
+                  *dp++ = *sp++;
+                  sp++;
+               }
+            }
+            /* This converts from XG or AG to G */
+            else
+            {
+               for (i = 0; i < row_width; i++)
+               {
+                  sp++;
+                  *dp++ = *sp++;
+               }
+            }
+            row_info->pixel_depth = 8;
+            row_info->rowbytes = row_width;
+         }
+         else /* if (row_info->bit_depth == 16) */
+         {
+            if (flags & PNG_FLAG_FILLER_AFTER)
+            {
+               /* This converts from GGXX or GGAA to GG */
+               sp += 4; dp += 2;
+               for (i = 1; i < row_width; i++)
+               {
+                  *dp++ = *sp++;
+                  *dp++ = *sp++;
+                  sp += 2;
+               }
+            }
+            else
+            {
+               /* This converts from XXGG or AAGG to GG */
+               for (i = 0; i < row_width; i++)
+               {
+                  sp += 2;
+                  *dp++ = *sp++;
+                  *dp++ = *sp++;
+               }
+            }
+            row_info->pixel_depth = 16;
+            row_info->rowbytes = row_width * 2;
+         }
+         row_info->channels = 1;
+         row_info->color_type &= ~PNG_COLOR_MASK_ALPHA;
+      }
+   }
+}
+#endif
+
+#if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED)
+/* swaps red and blue bytes within a pixel */
+void
+png_do_bgr(png_row_infop row_info, png_bytep row)
+{
+   png_debug(1, "in png_do_bgr\n");
+   if (
+#if defined(PNG_USELESS_TESTS_SUPPORTED)
+       row != NULL && row_info != NULL &&
+#endif
+       (row_info->color_type & PNG_COLOR_MASK_COLOR))
+   {
+      png_uint_32 row_width = row_info->width;
+      if (row_info->bit_depth == 8)
+      {
+         if (row_info->color_type == PNG_COLOR_TYPE_RGB)
+         {
+            png_bytep rp;
+            png_uint_32 i;
+
+            for (i = 0, rp = row; i < row_width; i++, rp += 3)
+            {
+               png_byte save = *rp;
+               *rp = *(rp + 2);
+               *(rp + 2) = save;
+            }
+         }
+         else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
+         {
+            png_bytep rp;
+            png_uint_32 i;
+
+            for (i = 0, rp = row; i < row_width; i++, rp += 4)
+            {
+               png_byte save = *rp;
+               *rp = *(rp + 2);
+               *(rp + 2) = save;
+            }
+         }
+      }
+      else if (row_info->bit_depth == 16)
+      {
+         if (row_info->color_type == PNG_COLOR_TYPE_RGB)
+         {
+            png_bytep rp;
+            png_uint_32 i;
+
+            for (i = 0, rp = row; i < row_width; i++, rp += 6)
+            {
+               png_byte save = *rp;
+               *rp = *(rp + 4);
+               *(rp + 4) = save;
+               save = *(rp + 1);
+               *(rp + 1) = *(rp + 5);
+               *(rp + 5) = save;
+            }
+         }
+         else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
+         {
+            png_bytep rp;
+            png_uint_32 i;
+
+            for (i = 0, rp = row; i < row_width; i++, rp += 8)
+            {
+               png_byte save = *rp;
+               *rp = *(rp + 4);
+               *(rp + 4) = save;
+               save = *(rp + 1);
+               *(rp + 1) = *(rp + 5);
+               *(rp + 5) = save;
+            }
+         }
+      }
+   }
+}
+#endif /* PNG_READ_BGR_SUPPORTED or PNG_WRITE_BGR_SUPPORTED */
+

src/png/pngwio.c

@@ -0,0 +1,228 @@
+
+/* pngwio.c - functions for data output
+ *
+ * libpng 1.0.3 - January 14, 1999
+ * For conditions of distribution and use, see copyright notice in png.h
+ * Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
+ * Copyright (c) 1996, 1997 Andreas Dilger
+ * Copyright (c) 1998, 1999 Glenn Randers-Pehrson
+ *
+ * This file provides a location for all output.  Users who need
+ * special handling are expected to write functions that have the same
+ * arguments as these and perform similar functions, but that possibly
+ * use different output methods.  Note that you shouldn't change these
+ * functions, but rather write replacement functions and then change
+ * them at run time with png_set_write_fn(...).
+ */
+
+#define PNG_INTERNAL
+#include "png.h"
+
+/* Write the data to whatever output you are using.  The default routine
+   writes to a file pointer.  Note that this routine sometimes gets called
+   with very small lengths, so you should implement some kind of simple
+   buffering if you are using unbuffered writes.  This should never be asked
+   to write more than 64K on a 16 bit machine.  */
+
+void
+png_write_data(png_structp png_ptr, png_bytep data, png_size_t length)
+{
+   if (png_ptr->write_data_fn != NULL )
+      (*(png_ptr->write_data_fn))(png_ptr, data, length);
+   else
+      png_error(png_ptr, "Call to NULL write function");
+}
+
+#if !defined(PNG_NO_STDIO)
+/* This is the function that does the actual writing of data.  If you are
+   not writing to a standard C stream, you should create a replacement
+   write_data function and use it at run time with png_set_write_fn(), rather
+   than changing the library. */
+#ifndef USE_FAR_KEYWORD
+#ifdef __VISAGECPP__
+static void _Optlink
+png_default_write_data(png_structp png_ptr, png_bytep data, png_size_t length)
+#else
+static void
+png_default_write_data(png_structp png_ptr, png_bytep data, png_size_t length)
+#endif
+{
+   png_uint_32 check;
+
+   check = fwrite(data, 1, length, (FILE *)(png_ptr->io_ptr));
+   if (check != length)
+   {
+      png_error(png_ptr, "Write Error");
+   }
+}
+#else
+/* this is the model-independent version. Since the standard I/O library
+   can't handle far buffers in the medium and small models, we have to copy
+   the data.
+*/
+
+#define NEAR_BUF_SIZE 1024
+#define MIN(a,b) (a <= b ? a : b)
+
+#ifdef __VISAGECPP__
+static void _Optlink
+png_default_write_data(png_structp png_ptr, png_bytep data, png_size_t length)
+#else
+static void
+png_default_write_data(png_structp png_ptr, png_bytep data, png_size_t length)
+#endif
+{
+   png_uint_32 check;
+   png_byte *near_data;  /* Needs to be "png_byte *" instead of "png_bytep" */
+   FILE *io_ptr;
+
+   /* Check if data really is near. If so, use usual code. */
+   near_data = (png_byte *)CVT_PTR_NOCHECK(data);
+   io_ptr = (FILE *)CVT_PTR(png_ptr->io_ptr);
+   if ((png_bytep)near_data == data)
+   {
+      check = fwrite(near_data, 1, length, io_ptr);
+   }
+   else
+   {
+      png_byte buf[NEAR_BUF_SIZE];
+      png_size_t written, remaining, err;
+      check = 0;
+      remaining = length;
+      do
+      {
+         written = MIN(NEAR_BUF_SIZE, remaining);
+         png_memcpy(buf, data, written); /* copy far buffer to near buffer */
+         err = fwrite(buf, 1, written, io_ptr);
+         if (err != written)
+            break;
+         else
+            check += err;
+         data += written;
+         remaining -= written;
+      }
+      while (remaining != 0);
+   }
+   if (check != length)
+   {
+      png_error(png_ptr, "Write Error");
+   }
+}
+
+#endif
+#endif
+
+/* This function is called to output any data pending writing (normally
+   to disk).  After png_flush is called, there should be no data pending
+   writing in any buffers. */
+#if defined(PNG_WRITE_FLUSH_SUPPORTED)
+void
+png_flush(png_structp png_ptr)
+{
+   if (png_ptr->output_flush_fn != NULL)
+      (*(png_ptr->output_flush_fn))(png_ptr);
+}
+
+#if !defined(PNG_NO_STDIO)
+#ifdef __VISAGECPP__
+static void _Optlink
+png_default_flush(png_structp png_ptr)
+#else
+static void
+png_default_flush(png_structp png_ptr)
+#endif
+{
+   FILE *io_ptr;
+   io_ptr = (FILE *)CVT_PTR((png_ptr->io_ptr));
+   if (io_ptr != NULL)
+      fflush(io_ptr);
+}
+#endif
+#endif
+
+/* This function allows the application to supply new output functions for
+   libpng if standard C streams aren't being used.
+
+   This function takes as its arguments:
+   png_ptr       - pointer to a png output data structure
+   io_ptr        - pointer to user supplied structure containing info about
+                   the output functions.  May be NULL.
+   write_data_fn - pointer to a new output function that takes as its
+                   arguments a pointer to a png_struct, a pointer to
+                   data to be written, and a 32-bit unsigned int that is
+                   the number of bytes to be written.  The new write
+                   function should call png_error(png_ptr, "Error msg")
+                   to exit and output any fatal error messages.
+   flush_data_fn - pointer to a new flush function that takes as its
+                   arguments a pointer to a png_struct.  After a call to
+                   the flush function, there should be no data in any buffers
+                   or pending transmission.  If the output method doesn't do
+                   any buffering of ouput, a function prototype must still be
+                   supplied although it doesn't have to do anything.  If
+                   PNG_WRITE_FLUSH_SUPPORTED is not defined at libpng compile
+                   time, output_flush_fn will be ignored, although it must be
+                   supplied for compatibility. */
+void
+png_set_write_fn(png_structp png_ptr, png_voidp io_ptr,
+   png_rw_ptr write_data_fn, png_flush_ptr output_flush_fn)
+{
+   png_ptr->io_ptr = io_ptr;
+
+#if !defined(PNG_NO_STDIO)
+   if (write_data_fn != NULL)
+      png_ptr->write_data_fn = write_data_fn;
+   else
+      png_ptr->write_data_fn = png_default_write_data;
+#else
+   png_ptr->write_data_fn = write_data_fn;
+#endif
+
+#if defined(PNG_WRITE_FLUSH_SUPPORTED)
+#if !defined(PNG_NO_STDIO)
+   if (output_flush_fn != NULL)
+      png_ptr->output_flush_fn = output_flush_fn;
+   else
+      png_ptr->output_flush_fn = png_default_flush;
+#else
+   png_ptr->output_flush_fn = output_flush_fn;
+#endif
+#endif /* PNG_WRITE_FLUSH_SUPPORTED */
+
+   /* It is an error to read while writing a png file */
+   if (png_ptr->read_data_fn != NULL)
+   {
+      png_ptr->read_data_fn = NULL;
+      png_warning(png_ptr,
+         "Attempted to set both read_data_fn and write_data_fn in");
+      png_warning(png_ptr,
+         "the same structure.  Resetting read_data_fn to NULL.");
+   }
+}
+
+#if defined(USE_FAR_KEYWORD)
+#if defined(_MSC_VER)
+void *png_far_to_near(png_structp png_ptr,png_voidp ptr, int check)
+{
+   void *near_ptr;
+   void FAR *far_ptr;
+   FP_OFF(near_ptr) = FP_OFF(ptr);
+   far_ptr = (void FAR *)near_ptr;
+   if(check != 0)
+      if(FP_SEG(ptr) != FP_SEG(far_ptr))
+         png_error(png_ptr,"segment lost in conversion");
+   return(near_ptr);
+}
+#  else
+void *png_far_to_near(png_structp png_ptr,png_voidp ptr, int check)
+{
+   void *near_ptr;
+   void FAR *far_ptr;
+   near_ptr = (void FAR *)ptr;
+   far_ptr = (void FAR *)near_ptr;
+   if(check != 0)
+      if(far_ptr != ptr)
+         png_error(png_ptr,"segment lost in conversion");
+   return(near_ptr);
+}
+#   endif
+#   endif

src/png/pngwtran.c

@@ -0,0 +1,497 @@
+
+/* pngwtran.c - transforms the data in a row for PNG writers
+ *
+ * libpng 1.0.3 - January 14, 1999
+ * For conditions of distribution and use, see copyright notice in png.h
+ * Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
+ * Copyright (c) 1996, 1997 Andreas Dilger
+ * Copyright (c) 1998, 1999 Glenn Randers-Pehrson
+ */
+
+#define PNG_INTERNAL
+#include "png.h"
+
+/* Transform the data according to the user's wishes.  The order of
+ * transformations is significant.
+ */
+void
+png_do_write_transformations(png_structp png_ptr)
+{
+   png_debug(1, "in png_do_write_transformations\n");
+
+#if defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED)
+   if (png_ptr->transformations & PNG_USER_TRANSFORM)
+      if(png_ptr->write_user_transform_fn != NULL)
+        (*(png_ptr->write_user_transform_fn)) /* user write transform function */
+          (png_ptr,                    /* png_ptr */
+           &(png_ptr->row_info),       /* row_info:     */
+             /*  png_uint_32 width;          width of row */
+             /*  png_uint_32 rowbytes;       number of bytes in row */
+             /*  png_byte color_type;        color type of pixels */
+             /*  png_byte bit_depth;         bit depth of samples */
+             /*  png_byte channels;          number of channels (1-4) */
+             /*  png_byte pixel_depth;       bits per pixel (depth*channels) */
+           png_ptr->row_buf + 1);      /* start of pixel data for row */
+#endif
+#if defined(PNG_WRITE_FILLER_SUPPORTED)
+   if (png_ptr->transformations & PNG_FILLER)
+      png_do_strip_filler(&(png_ptr->row_info), png_ptr->row_buf + 1,
+         png_ptr->flags);
+#endif
+#if defined(PNG_WRITE_PACKSWAP_SUPPORTED)
+   if (png_ptr->transformations & PNG_PACKSWAP)
+      png_do_packswap(&(png_ptr->row_info), png_ptr->row_buf + 1);
+#endif
+#if defined(PNG_WRITE_PACK_SUPPORTED)
+   if (png_ptr->transformations & PNG_PACK)
+      png_do_pack(&(png_ptr->row_info), png_ptr->row_buf + 1,
+         (png_uint_32)png_ptr->bit_depth);
+#endif
+#if defined(PNG_WRITE_SWAP_SUPPORTED)
+   if (png_ptr->transformations & PNG_SWAP_BYTES)
+      png_do_swap(&(png_ptr->row_info), png_ptr->row_buf + 1);
+#endif
+#if defined(PNG_WRITE_SHIFT_SUPPORTED)
+   if (png_ptr->transformations & PNG_SHIFT)
+      png_do_shift(&(png_ptr->row_info), png_ptr->row_buf + 1,
+         &(png_ptr->shift));
+#endif
+#if defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED)
+   if (png_ptr->transformations & PNG_INVERT_ALPHA)
+      png_do_write_invert_alpha(&(png_ptr->row_info), png_ptr->row_buf + 1);
+#endif
+#if defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED)
+   if (png_ptr->transformations & PNG_SWAP_ALPHA)
+      png_do_write_swap_alpha(&(png_ptr->row_info), png_ptr->row_buf + 1);
+#endif
+#if defined(PNG_WRITE_BGR_SUPPORTED)
+   if (png_ptr->transformations & PNG_BGR)
+      png_do_bgr(&(png_ptr->row_info), png_ptr->row_buf + 1);
+#endif
+#if defined(PNG_WRITE_INVERT_SUPPORTED)
+   if (png_ptr->transformations & PNG_INVERT_MONO)
+      png_do_invert(&(png_ptr->row_info), png_ptr->row_buf + 1);
+#endif
+}
+
+#if defined(PNG_WRITE_PACK_SUPPORTED)
+/* Pack pixels into bytes.  Pass the true bit depth in bit_depth.  The
+ * row_info bit depth should be 8 (one pixel per byte).  The channels
+ * should be 1 (this only happens on grayscale and paletted images).
+ */
+void
+png_do_pack(png_row_infop row_info, png_bytep row, png_uint_32 bit_depth)
+{
+   png_debug(1, "in png_do_pack\n");
+   if (row_info->bit_depth == 8 &&
+#if defined(PNG_USELESS_TESTS_SUPPORTED)
+       row != NULL && row_info != NULL &&
+#endif
+      row_info->channels == 1)
+   {
+      switch ((int)bit_depth)
+      {
+         case 1:
+         {
+            png_bytep sp, dp;
+            int mask, v;
+            png_uint_32 i;
+            png_uint_32 row_width = row_info->width;
+
+            sp = row;
+            dp = row;
+            mask = 0x80;
+            v = 0;
+
+            for (i = 0; i < row_width; i++)
+            {
+               if (*sp != 0)
+                  v |= mask;
+               sp++;
+               if (mask > 1)
+                  mask >>= 1;
+               else
+               {
+                  mask = 0x80;
+                  *dp = (png_byte)v;
+                  dp++;
+                  v = 0;
+               }
+            }
+            if (mask != 0x80)
+               *dp = (png_byte)v;
+            break;
+         }
+         case 2:
+         {
+            png_bytep sp, dp;
+            int shift, v;
+            png_uint_32 i;
+            png_uint_32 row_width = row_info->width;
+
+            sp = row;
+            dp = row;
+            shift = 6;
+            v = 0;
+            for (i = 0; i < row_width; i++)
+            {
+               png_byte value;
+
+               value = (png_byte)(*sp & 0x3);
+               v |= (value << shift);
+               if (shift == 0)
+               {
+                  shift = 6;
+                  *dp = (png_byte)v;
+                  dp++;
+                  v = 0;
+               }
+               else
+                  shift -= 2;
+               sp++;
+            }
+            if (shift != 6)
+               *dp = (png_byte)v;
+            break;
+         }
+         case 4:
+         {
+            png_bytep sp, dp;
+            int shift, v;
+            png_uint_32 i;
+            png_uint_32 row_width = row_info->width;
+
+            sp = row;
+            dp = row;
+            shift = 4;
+            v = 0;
+            for (i = 0; i < row_width; i++)
+            {
+               png_byte value;
+
+               value = (png_byte)(*sp & 0xf);
+               v |= (value << shift);
+
+               if (shift == 0)
+               {
+                  shift = 4;
+                  *dp = (png_byte)v;
+                  dp++;
+                  v = 0;
+               }
+               else
+                  shift -= 4;
+
+               sp++;
+            }
+            if (shift != 4)
+               *dp = (png_byte)v;
+            break;
+         }
+      }
+      row_info->bit_depth = (png_byte)bit_depth;
+      row_info->pixel_depth = (png_byte)(bit_depth * row_info->channels);
+      row_info->rowbytes =
+         ((row_info->width * row_info->pixel_depth + 7) >> 3);
+   }
+}
+#endif
+
+#if defined(PNG_WRITE_SHIFT_SUPPORTED)
+/* Shift pixel values to take advantage of whole range.  Pass the
+ * true number of bits in bit_depth.  The row should be packed
+ * according to row_info->bit_depth.  Thus, if you had a row of
+ * bit depth 4, but the pixels only had values from 0 to 7, you
+ * would pass 3 as bit_depth, and this routine would translate the
+ * data to 0 to 15.
+ */
+void
+png_do_shift(png_row_infop row_info, png_bytep row, png_color_8p bit_depth)
+{
+   png_debug(1, "in png_do_shift\n");
+#if defined(PNG_USELESS_TESTS_SUPPORTED)
+   if (row != NULL && row_info != NULL &&
+#else
+   if (
+#endif
+      row_info->color_type != PNG_COLOR_TYPE_PALETTE)
+   {
+      int shift_start[4], shift_dec[4];
+      int channels = 0;
+
+      if (row_info->color_type & PNG_COLOR_MASK_COLOR)
+      {
+         shift_start[channels] = row_info->bit_depth - bit_depth->red;
+         shift_dec[channels] = bit_depth->red;
+         channels++;
+         shift_start[channels] = row_info->bit_depth - bit_depth->green;
+         shift_dec[channels] = bit_depth->green;
+         channels++;
+         shift_start[channels] = row_info->bit_depth - bit_depth->blue;
+         shift_dec[channels] = bit_depth->blue;
+         channels++;
+      }
+      else
+      {
+         shift_start[channels] = row_info->bit_depth - bit_depth->gray;
+         shift_dec[channels] = bit_depth->gray;
+         channels++;
+      }
+      if (row_info->color_type & PNG_COLOR_MASK_ALPHA)
+      {
+         shift_start[channels] = row_info->bit_depth - bit_depth->alpha;
+         shift_dec[channels] = bit_depth->alpha;
+         channels++;
+      }
+
+      /* with low row depths, could only be grayscale, so one channel */
+      if (row_info->bit_depth < 8)
+      {
+         png_bytep bp = row;
+         png_uint_32 i;
+         png_byte mask;
+         png_uint_32 row_bytes = row_info->rowbytes;
+
+         if (bit_depth->gray == 1 && row_info->bit_depth == 2)
+            mask = 0x55;
+         else if (row_info->bit_depth == 4 && bit_depth->gray == 3)
+            mask = 0x11;
+         else
+            mask = 0xff;
+
+         for (i = 0; i < row_bytes; i++, bp++)
+         {
+            png_uint_16 v;
+            int j;
+
+            v = *bp;
+            *bp = 0;
+            for (j = shift_start[0]; j > -shift_dec[0]; j -= shift_dec[0])
+            {
+               if (j > 0)
+                  *bp |= (png_byte)((v << j) & 0xff);
+               else
+                  *bp |= (png_byte)((v >> (-j)) & mask);
+            }
+         }
+      }
+      else if (row_info->bit_depth == 8)
+      {
+         png_bytep bp = row;
+         png_uint_32 i;
+         png_uint_32 istop = channels * row_info->width;
+
+         for (i = 0; i < istop; i++, bp++)
+         {
+
+            png_uint_16 v;
+            int j;
+            int c = (int)(i%channels);
+
+            v = *bp;
+            *bp = 0;
+            for (j = shift_start[c]; j > -shift_dec[c]; j -= shift_dec[c])
+            {
+               if (j > 0)
+                  *bp |= (png_byte)((v << j) & 0xff);
+               else
+                  *bp |= (png_byte)((v >> (-j)) & 0xff);
+            }
+         }
+      }
+      else
+      {
+         png_bytep bp;
+         png_uint_32 i;
+         png_uint_32 istop = channels * row_info->width;
+
+         for (bp = row, i = 0; i < istop; i++)
+         {
+            int c = (int)(i%channels);
+            png_uint_16 value, v;
+            int j;
+
+            v = ((png_uint_16)(*bp) << 8) + *(bp + 1);
+            value = 0;
+            for (j = shift_start[c]; j > -shift_dec[c]; j -= shift_dec[c])
+            {
+               if (j > 0)
+                  value |= (png_uint_16)((v << j) & (png_uint_16)0xffff);
+               else
+                  value |= (png_uint_16)((v >> (-j)) & (png_uint_16)0xffff);
+            }
+            *bp++ = (png_byte)(value >> 8);
+            *bp++ = (png_byte)(value & 0xff);
+         }
+      }
+   }
+}
+#endif
+
+#if defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED)
+void
+png_do_write_swap_alpha(png_row_infop row_info, png_bytep row)
+{
+   png_debug(1, "in png_do_write_swap_alpha\n");
+#if defined(PNG_USELESS_TESTS_SUPPORTED)
+   if (row != NULL && row_info != NULL)
+#endif
+   {
+      if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
+      {
+         /* This converts from ARGB to RGBA */
+         if (row_info->bit_depth == 8)
+         {
+            png_bytep sp, dp;
+            png_uint_32 i;
+            png_uint_32 row_width = row_info->width;
+            for (i = 0, sp = dp = row; i < row_width; i++)
+            {
+               png_byte save = *(sp++);
+               *(dp++) = *(sp++);
+               *(dp++) = *(sp++);
+               *(dp++) = *(sp++);
+               *(dp++) = save;
+            }
+         }
+         /* This converts from AARRGGBB to RRGGBBAA */
+         else
+         {
+            png_bytep sp, dp;
+            png_uint_32 i;
+            png_uint_32 row_width = row_info->width;
+
+            for (i = 0, sp = dp = row; i < row_width; i++)
+            {
+               png_byte save[2];
+               save[0] = *(sp++);
+               save[1] = *(sp++);
+               *(dp++) = *(sp++);
+               *(dp++) = *(sp++);
+               *(dp++) = *(sp++);
+               *(dp++) = *(sp++);
+               *(dp++) = *(sp++);
+               *(dp++) = *(sp++);
+               *(dp++) = save[0];
+               *(dp++) = save[1];
+            }
+         }
+      }
+      else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
+      {
+         /* This converts from AG to GA */
+         if (row_info->bit_depth == 8)
+         {
+            png_bytep sp, dp;
+            png_uint_32 i;
+            png_uint_32 row_width = row_info->width;
+
+            for (i = 0, sp = dp = row; i < row_width; i++)
+            {
+               png_byte save = *(sp++);
+               *(dp++) = *(sp++);
+               *(dp++) = save;
+            }
+         }
+         /* This converts from AAGG to GGAA */
+         else
+         {
+            png_bytep sp, dp;
+            png_uint_32 i;
+            png_uint_32 row_width = row_info->width;
+
+            for (i = 0, sp = dp = row; i < row_width; i++)
+            {
+               png_byte save[2];
+               save[0] = *(sp++);
+               save[1] = *(sp++);
+               *(dp++) = *(sp++);
+               *(dp++) = *(sp++);
+               *(dp++) = save[0];
+               *(dp++) = save[1];
+            }
+         }
+      }
+   }
+}
+#endif
+
+#if defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED)
+void
+png_do_write_invert_alpha(png_row_infop row_info, png_bytep row)
+{
+   png_debug(1, "in png_do_write_invert_alpha\n");
+#if defined(PNG_USELESS_TESTS_SUPPORTED)
+   if (row != NULL && row_info != NULL)
+#endif
+   {
+      if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
+      {
+         /* This inverts the alpha channel in RGBA */
+         if (row_info->bit_depth == 8)
+         {
+            png_bytep sp, dp;
+            png_uint_32 i;
+            png_uint_32 row_width = row_info->width;
+            for (i = 0, sp = dp = row; i < row_width; i++)
+            {
+               *(dp++) = *(sp++);
+               *(dp++) = *(sp++);
+               *(dp++) = *(sp++);
+               *(dp++) = 255 - *(sp++);
+            }
+         }
+         /* This inverts the alpha channel in RRGGBBAA */
+         else
+         {
+            png_bytep sp, dp;
+            png_uint_32 i;
+            png_uint_32 row_width = row_info->width;
+
+            for (i = 0, sp = dp = row; i < row_width; i++)
+            {
+               *(dp++) = *(sp++);
+               *(dp++) = *(sp++);
+               *(dp++) = *(sp++);
+               *(dp++) = *(sp++);
+               *(dp++) = *(sp++);
+               *(dp++) = *(sp++);
+               *(dp++) = 255 - *(sp++);
+               *(dp++) = 255 - *(sp++);
+            }
+         }
+      }
+      else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
+      {
+         /* This inverts the alpha channel in GA */
+         if (row_info->bit_depth == 8)
+         {
+            png_bytep sp, dp;
+            png_uint_32 i;
+            png_uint_32 row_width = row_info->width;
+
+            for (i = 0, sp = dp = row; i < row_width; i++)
+            {
+               *(dp++) = *(sp++);
+               *(dp++) = 255 - *(sp++);
+            }
+         }
+         /* This inverts the alpha channel in GGAA */
+         else
+         {
+            png_bytep sp, dp;
+            png_uint_32 i;
+            png_uint_32 row_width = row_info->width;
+
+            for (i = 0, sp = dp = row; i < row_width; i++)
+            {
+               *(dp++) = *(sp++);
+               *(dp++) = *(sp++);
+               *(dp++) = 255 - *(sp++);
+               *(dp++) = 255 - *(sp++);
+            }
+         }
+      }
+   }
+}
+#endif

src/png/scripts/SCOPTIONS.ppc

@@ -0,0 +1,7 @@
+OPTIMIZE
+OPTPEEP
+OPTTIME
+OPTSCHED
+AUTOREGISTER
+PARMS=REGISTERS
+INCLUDEDIR=hlp:ppc/include

src/png/scripts/build.bat

@@ -0,0 +1,2 @@
+make -fmakefile.bor -B -DMODEL=m %1 %2 %3 libpng >buildm.out
+make -fmakefile.bor -B -DMODEL=l %1 %2 %3 libpng >buildl.out

src/png/scripts/descrip.mms

@@ -0,0 +1,52 @@
+
+cc_defs = /inc=$(ZLIBSRC)
+c_deb = 
+
+.ifdef __DECC__
+pref = /prefix=all
+.endif
+
+
+
+OBJS = png.obj, pngset.obj, pngget.obj, pngrutil.obj, pngtrans.obj,\
+	pngwutil.obj, pngread.obj, pngmem.obj, pngwrite.obj, pngrtran.obj,\
+	pngwtran.obj, pngrio.obj, pngwio.obj, pngerror.obj, pngpread.obj
+
+
+CFLAGS= $(C_DEB) $(CC_DEFS) $(PREF)
+
+all : pngtest.exe libpng.olb
+		@ write sys$output " pngtest available"
+
+libpng.olb : libpng.olb($(OBJS))
+	@ write sys$output " Libpng available"
+
+
+pngtest.exe : pngtest.obj libpng.olb
+              link pngtest,libpng.olb/lib,$(ZLIBSRC)libz.olb/lib
+
+test : pngtest.exe
+   run pngtest
+
+clean :
+	delete *.obj;*,*.exe;*
+
+
+# Other dependencies.
+png.obj : png.h, pngconf.h
+pngpread.obj : png.h, pngconf.h
+pngset.obj : png.h, pngconf.h
+pngget.obj : png.h, pngconf.h
+pngread.obj : png.h, pngconf.h
+pngrtran.obj : png.h, pngconf.h
+pngrutil.obj : png.h, pngconf.h
+pngerror.obj : png.h, pngconf.h
+pngmem.obj : png.h, pngconf.h
+pngrio.obj : png.h, pngconf.h
+pngwio.obj : png.h, pngconf.h
+pngtest.obj : png.h, pngconf.h
+pngtrans.obj : png.h, pngconf.h
+pngwrite.obj : png.h, pngconf.h
+pngwtran.obj : png.h, pngconf.h
+pngwutil.obj : png.h, pngconf.h
+

src/png/scripts/makefile.aco

@@ -0,0 +1,221 @@
+# Project:   libpng
+
+
+# Toolflags:
+CCflags = -c -depend !Depend -IC:,Zlib: -g -throwback  -DRISCOS  -fnah 
+C++flags = -c -depend !Depend -IC: -throwback
+Linkflags = -aif -c++ -o $@
+ObjAsmflags = -throwback -NoCache -depend !Depend
+CMHGflags = 
+LibFileflags = -c -l -o $@ 
+Squeezeflags = -o $@
+
+
+# Final targets:
+@.libpng-lib:   @.o.png @.o.pngerror @.o.pngrio @.o.pngwio @.o.pngmem \
+        @.o.pngpread @.o.pngset @.o.pngget @.o.pngread @.o.pngrtran \
+        @.o.pngrutil @.o.pngtrans @.o.pngwrite @.o.pngwtran @.o.pngwutil 
+        LibFile $(LibFileflags) @.o.png @.o.pngerror @.o.pngrio @.o.pngrtran \
+        @.o.pngmem @.o.pngpread @.o.pngset @.o.pngget @.o.pngread @.o.pngwio \
+        @.o.pngrutil @.o.pngtrans  @.o.pngwrite @.o.pngwtran @.o.pngwutil 
+@.mm-libpng-lib:   @.mm.png @.mm.pngerror @.mm.pngrio @.mm.pngwio @.mm.pngmem \
+        @.mm.pngpread @.mm.pngset @.mm.pngget @.mm.pngread @.mm.pngrtran \
+        @.mm.pngrutil @.mm.pngtrans @.mm.pngwrite @.mm.pngwtran @.mm.pngwutil 
+        LibFile $(LibFileflags) @.mm.png @.mm.pngerror @.mm.pngrio \
+        @.mm.pngwio @.mm.pngmem @.mm.pngpread @.mm.pngset @.mm.pngget \
+        @.mm.pngread @.mm.pngrtran @.mm.pngrutil @.mm.pngtrans @.mm.pngwrite \
+        @.mm.pngwtran @.mm.pngwutil 
+
+
+# User-editable dependencies:
+# (C) Copyright 1997 Tom Tanner
+Test: @.pngtest 
+        <Prefix$Dir>.pngtest
+        @remove <Prefix$Dir>.pngtest
+
+#It would be nice if you could stop "make" listing from here on!
+@.pngtest:   @.o.pngtest @.libpng-lib C:o.Stubs Zlib:zlib_lib 
+        Link $(Linkflags) @.o.pngtest @.libpng-lib C:o.Stubs Zlib:zlib_lib 
+
+.SUFFIXES: .o .mm .c
+
+.c.mm:
+        MemCheck.CC cc $(ccflags) -o $@ LibPng:$<
+.c.o:
+        cc $(ccflags) -o $@ $<
+
+
+# Static dependencies:
+
+
+# Dynamic dependencies:
+o.pngtest:	c.pngtest
+o.pngtest:	h.png
+o.pngtest:	Zlib:h.zlib
+o.pngtest:	Zlib:h.zconf
+o.pngtest:	h.pngconf
+mm.png:		LibPng:c.png
+mm.png:		LibPng:h.png
+mm.png:		Zlib:h.zlib
+mm.png:		Zlib:h.zconf
+mm.png:		LibPng:h.pngconf
+mm.png:		MemCheck:ANSI.h.stdio
+mm.pngerror:	LibPng:c.pngerror
+mm.pngerror:	LibPng:h.png
+mm.pngerror:	Zlib:h.zlib
+mm.pngerror:	Zlib:h.zconf
+mm.pngerror:	LibPng:h.pngconf
+mm.pngerror:	MemCheck:ANSI.h.stdio
+mm.pngrio:	LibPng:c.pngrio
+mm.pngrio:	LibPng:h.png
+mm.pngrio:	Zlib:h.zlib
+mm.pngrio:	Zlib:h.zconf
+mm.pngrio:	LibPng:h.pngconf
+mm.pngrio:	MemCheck:ANSI.h.stdio
+mm.pngwio:	LibPng:c.pngwio
+mm.pngwio:	LibPng:h.png
+mm.pngwio:	Zlib:h.zlib
+mm.pngwio:	Zlib:h.zconf
+mm.pngwio:	LibPng:h.pngconf
+mm.pngwio:	MemCheck:ANSI.h.stdio
+mm.pngmem:	LibPng:c.pngmem
+mm.pngmem:	LibPng:h.png
+mm.pngmem:	Zlib:h.zlib
+mm.pngmem:	Zlib:h.zconf
+mm.pngmem:	LibPng:h.pngconf
+mm.pngmem:	MemCheck:ANSI.h.stdio
+mm.pngpread:	LibPng:c.pngpread
+mm.pngpread:	LibPng:h.png
+mm.pngpread:	Zlib:h.zlib
+mm.pngpread:	Zlib:h.zconf
+mm.pngpread:	LibPng:h.pngconf
+mm.pngpread:	MemCheck:ANSI.h.stdio
+mm.pngset:	LibPng:c.pngset
+mm.pngset:	LibPng:h.png
+mm.pngset:	Zlib:h.zlib
+mm.pngset:	Zlib:h.zconf
+mm.pngset:	LibPng:h.pngconf
+mm.pngset:	MemCheck:ANSI.h.stdio
+mm.pngget:	LibPng:c.pngget
+mm.pngget:	LibPng:h.png
+mm.pngget:	Zlib:h.zlib
+mm.pngget:	Zlib:h.zconf
+mm.pngget:	LibPng:h.pngconf
+mm.pngget:	MemCheck:ANSI.h.stdio
+mm.pngread:	LibPng:c.pngread
+mm.pngread:	LibPng:h.png
+mm.pngread:	Zlib:h.zlib
+mm.pngread:	Zlib:h.zconf
+mm.pngread:	LibPng:h.pngconf
+mm.pngread:	MemCheck:ANSI.h.stdio
+mm.pngrtran:	LibPng:c.pngrtran
+mm.pngrtran:	LibPng:h.png
+mm.pngrtran:	Zlib:h.zlib
+mm.pngrtran:	Zlib:h.zconf
+mm.pngrtran:	LibPng:h.pngconf
+mm.pngrtran:	MemCheck:ANSI.h.stdio
+mm.pngrutil:	LibPng:c.pngrutil
+mm.pngrutil:	LibPng:h.png
+mm.pngrutil:	Zlib:h.zlib
+mm.pngrutil:	Zlib:h.zconf
+mm.pngrutil:	LibPng:h.pngconf
+mm.pngrutil:	MemCheck:ANSI.h.stdio
+mm.pngtrans:	LibPng:c.pngtrans
+mm.pngtrans:	LibPng:h.png
+mm.pngtrans:	Zlib:h.zlib
+mm.pngtrans:	Zlib:h.zconf
+mm.pngtrans:	LibPng:h.pngconf
+mm.pngtrans:	MemCheck:ANSI.h.stdio
+mm.pngwrite:	LibPng:c.pngwrite
+mm.pngwrite:	LibPng:h.png
+mm.pngwrite:	Zlib:h.zlib
+mm.pngwrite:	Zlib:h.zconf
+mm.pngwrite:	LibPng:h.pngconf
+mm.pngwrite:	MemCheck:ANSI.h.stdio
+mm.pngwtran:	LibPng:c.pngwtran
+mm.pngwtran:	LibPng:h.png
+mm.pngwtran:	Zlib:h.zlib
+mm.pngwtran:	Zlib:h.zconf
+mm.pngwtran:	LibPng:h.pngconf
+mm.pngwtran:	MemCheck:ANSI.h.stdio
+mm.pngwutil:	LibPng:c.pngwutil
+mm.pngwutil:	LibPng:h.png
+mm.pngwutil:	Zlib:h.zlib
+mm.pngwutil:	Zlib:h.zconf
+mm.pngwutil:	LibPng:h.pngconf
+mm.pngwutil:	MemCheck:ANSI.h.stdio
+o.png:		c.png
+o.png:		h.png
+o.png:		Zlib:h.zlib
+o.png:		Zlib:h.zconf
+o.png:		h.pngconf
+o.pngerror:	c.pngerror
+o.pngerror:	h.png
+o.pngerror:	Zlib:h.zlib
+o.pngerror:	Zlib:h.zconf
+o.pngerror:	h.pngconf
+o.pngrio:	c.pngrio
+o.pngrio:	h.png
+o.pngrio:	Zlib:h.zlib
+o.pngrio:	Zlib:h.zconf
+o.pngrio:	h.pngconf
+o.pngwio:	c.pngwio
+o.pngwio:	h.png
+o.pngwio:	Zlib:h.zlib
+o.pngwio:	Zlib:h.zconf
+o.pngwio:	h.pngconf
+o.pngmem:	c.pngmem
+o.pngmem:	h.png
+o.pngmem:	Zlib:h.zlib
+o.pngmem:	Zlib:h.zconf
+o.pngmem:	h.pngconf
+o.pngpread:	c.pngpread
+o.pngpread:	h.png
+o.pngpread:	Zlib:h.zlib
+o.pngpread:	Zlib:h.zconf
+o.pngpread:	h.pngconf
+o.pngset:	c.pngset
+o.pngset:	h.png
+o.pngset:	Zlib:h.zlib
+o.pngset:	Zlib:h.zconf
+o.pngset:	h.pngconf
+o.pngget:	c.pngget
+o.pngget:	h.png
+o.pngget:	Zlib:h.zlib
+o.pngget:	Zlib:h.zconf
+o.pngget:	h.pngconf
+o.pngread:	c.pngread
+o.pngread:	h.png
+o.pngread:	Zlib:h.zlib
+o.pngread:	Zlib:h.zconf
+o.pngread:	h.pngconf
+o.pngrtran:	c.pngrtran
+o.pngrtran:	h.png
+o.pngrtran:	Zlib:h.zlib
+o.pngrtran:	Zlib:h.zconf
+o.pngrtran:	h.pngconf
+o.pngrutil:	c.pngrutil
+o.pngrutil:	h.png
+o.pngrutil:	Zlib:h.zlib
+o.pngrutil:	Zlib:h.zconf
+o.pngrutil:	h.pngconf
+o.pngtrans:	c.pngtrans
+o.pngtrans:	h.png
+o.pngtrans:	Zlib:h.zlib
+o.pngtrans:	Zlib:h.zconf
+o.pngtrans:	h.pngconf
+o.pngwrite:	c.pngwrite
+o.pngwrite:	h.png
+o.pngwrite:	Zlib:h.zlib
+o.pngwrite:	Zlib:h.zconf
+o.pngwrite:	h.pngconf
+o.pngwtran:	c.pngwtran
+o.pngwtran:	h.png
+o.pngwtran:	Zlib:h.zlib
+o.pngwtran:	Zlib:h.zconf
+o.pngwtran:	h.pngconf
+o.pngwutil:	c.pngwutil
+o.pngwutil:	h.png
+o.pngwutil:	Zlib:h.zlib
+o.pngwutil:	Zlib:h.zconf
+o.pngwutil:	h.pngconf

src/png/scripts/makefile.ama

@@ -0,0 +1,42 @@
+# Commodore Amiga Makefile
+# makefile for libpng and SAS C V6.55 compiler
+# Copyright (C) 1995 Wolf Faust
+
+#compiler
+CC=sc
+#compiler flags
+# WARNING: a bug in V6.51 causes bad code with OPTGO
+#          So use V6.55 or set NOOPTGO!!!!!!!!!
+CFLAGS= NOSTKCHK PARMS=REG OPTIMIZE OPTGO OPTPEEP OPTINLOCAL OPTINL\
+        OPTLOOP OPTRDEP=4 OPTDEP=4 OPTCOMP=4 DEFINE=PNG_INTERNAL
+#linker flags
+LDFLAGS= SD ND BATCH
+#link libs
+LDLIBS= libpng.lib libgz.lib LIB:scm.lib LIB:sc.lib Lib:amiga.lib
+# linker
+LN= slink
+# file deletion command
+RM= delete quiet
+# library (.lib) file creation command
+AR= oml
+# make directory command
+MKDIR= makedir
+
+OBJS = png.o pngset.o pngget.o pngrutil.o pngtrans.o pngwutil.o pngpread.o \
+pngread.o pngerror.o pngwrite.o pngrtran.o pngwtran.o pngrio.o pngwio.o pngmem.o
+
+all: libpng.lib pngtest
+
+libpng.lib: $(OBJS)
+-$(RM) libpng.lib
+$(AR) libpng.lib r $(OBJS)
+
+pngtest: pngtest.o libpng.lib
+$(LN) <WITH <
+$(LDFLAGS)
+TO pngtest
+FROM LIB:c.o pngtest.o
+LIB $(LDLIBS)
+<
+
+

src/png/scripts/makefile.atr

@@ -0,0 +1,31 @@
+# makefile for libpng
+# Copyright (C) 1995 Guy Eric Schalnat, Group 42, Inc.
+# For conditions of distribution and use, see copyright notice in png.h
+# modified for LC56/ATARI assumes libz.lib is in same dir and uses default
+# rules for library management
+#
+CFLAGS=-I..\zlib -O
+LBR = png.lib
+LDFLAGS=-lpng -lz -lm
+
+# where make install puts libpng.a and png.h
+
+OBJS = $(LBR)(png.o) $(LBR)(pngset.o) $(LBR)(pngget.o) $(LBR)(pngrutil.o)\
+	$(LBR)(pngtrans.o) $(LBR)(pngwutil.o)\
+	$(LBR)(pngread.o) $(LBR)(pngerror.o) $(LBR)(pngwrite.o)\
+	$(LBR)(pngrtran.o) $(LBR)(pngwtran.o)\
+	$(LBR)(pngmem.o) $(LBR)(pngrio.o) $(LBR)(pngwio.o) $(LBR)(pngpread.o)
+
+all: $(LBR) pngtest.ttp
+
+$(LBR): $(OBJS)
+
+pngtest.ttp: pngtest.o $(LBR)
+	$(CC) $(CFLAGS) $(LDFLAGS) -o$@ pngtest.o
+
+install: libpng.a
+	-@mkdir $(prefix)/include
+	-@mkdir $(prefix)/lib
+	cp png.h $(prefix)/include
+	cp pngconf.h $(prefix)/include
+	chmod 644 $(prefix)/include/p

src/png/scripts/makefile.bor

@@ -0,0 +1,168 @@
+# Makefile for libpng
+# Borland C++ 4.5 (Note: All modules are compiled in C mode)
+# Will work with C++ 4.02 also
+# To build the library, do: 
+#       "make -fmakefile.bor -DMODEL=m"
+# or:   "make -fmakefile.bor -DMODEL=l"
+#
+# ------------- Borland C++ 4.5 -------------
+
+### Absolutely necessary for this makefile to work
+.AUTODEPEND
+
+## Useful user options
+
+# Usually defined in builtins.mak or the environment
+# Currently unused.
+!ifndef BCROOT
+BCROOT=N:\BC45
+!endif
+
+# Where zlib.h and zconf.h and zlib.lib are
+ZLIB_PATH=..\zlib
+
+!ifndef MODEL
+MODEL=l
+!endif
+
+#TARGET_CPU=3
+# 2 = 286, 3 = 386, etc.
+!ifndef TARGET_CPU
+TARGET_CPU=2
+!endif
+
+
+# Use this if you don't want Borland's fancy exception handling.
+NOEHLIB=noeh$(MODEL).lib
+
+!ifdef DEBUG
+CDEBUG=-v
+LDEBUG=-v
+!else
+CDEBUG=
+LDEBUG=
+!endif
+
+# STACKOFLOW=1
+!ifdef STACKOFLOW
+CDEBUG=$(CDEBUG) -N
+LDEBUG=$(LDEBUG) -N
+!endif
+
+
+## Compiler, linker, and lib stuff
+CC=bcc
+LD=bcc
+LIB=tlib
+
+MODELARG=-m$(MODEL)
+
+# -X- turns on dependency generation in the object file
+# -w  sets all warnings on
+# -O2 optimize for speed
+# -Z  global optimization
+CFLAGS=-O2 -Z -X- -w -I$(ZLIB_PATH) -$(TARGET_CPU) $(MODELARG) $(CDEBUG)
+
+# -M  generate map file
+LDFLAGS=-M $(LDEBUG)
+
+O=obj
+
+## variables
+OBJS = \
+ png.$(O) \
+ pngerror.$(O) \
+ pngmem.$(O) \
+ pngpread.$(O) \
+ pngset.$(O) \
+ pngget.$(O) \
+ pngread.$(O) \
+ pngrio.$(O) \
+ pngrtran.$(O) \
+ pngrutil.$(O) \
+ pngtrans.$(O) \
+ pngwrite.$(O) \
+ pngwtran.$(O) \
+ pngwio.$(O) \
+ pngwutil.$(O)
+
+LIBOBJS = \
+ +png.$(O) \
+ +pngerror.$(O) \
+ +pngmem.$(O) \
+ +pngpread.$(O) \
+ +pngread.$(O) \
+ +pngset.$(O) \
+ +pngget.$(O) \
+ +pngrio.$(O) \
+ +pngrtran.$(O) \
+ +pngrutil.$(O) \
+ +pngtrans.$(O) \
+ +pngwrite.$(O) \
+ +pngwtran.$(O) \
+ +pngwio.$(O)
+ +pngwutil.$(O)
+
+LIBNAME=libpng$(MODEL).lib
+
+
+## Implicit rules
+# Braces let make "batch" calls to the compiler,
+# 2 calls instead of 12; space is important.
+.c.obj:
+	$(CC) $(CFLAGS) -c {$*.c }
+
+.c.exe:
+	$(CC) $(CFLAGS) $(LDFLAGS) $*.c
+
+
+## Major targets
+libpng: $(LIBNAME)
+
+pngtest: pngtest$(MODEL).exe
+
+test:
+	pngtest$(MODEL)
+
+
+## Minor Targets
+
+png.obj: png.c
+pngset.obj: pngset.c
+pngget.obj: pngget.c
+pngread.obj: pngread.c
+pngpread.obj: pngpread.c
+pngrtran.obj: pngrtran.c
+pngrutil.obj: pngrutil.c
+pngerror.obj: pngerror.c
+pngmem.obj: pngmem.c
+pngrio.obj: pngrio.c
+pngwio.obj: pngwio.c
+pngtrans.obj: pngtrans.c
+pngwrite.obj: pngwrite.c
+pngwtran.obj: pngwtran.c
+pngwutil.obj: pngwutil.c
+
+
+$(LIBNAME): $(OBJS)
+	-del $(LIBNAME)
+        $(LIB) $(LIBNAME) @&&|
+$(LIBOBJS), libpng$(MODEL)
+|
+
+
+pngtest$(MODEL).obj: pngtest.c
+	$(CC) $(CFLAGS) -opngtest$(MODEL) -c pngtest.c
+
+pngtest$(MODEL).exe: pngtest$(MODEL).obj
+	$(CC) $(MODELARG) $(LDFLAGS) -L$(ZLIB_PATH) pngtest$(MODEL).obj $(LIBNAME) zlib$(MODEL).lib $(NOEHLIB)
+
+
+# Clean up anything else you want
+clean:
+	-del *.obj
+	-del *.lib
+	-del *.lst
+
+
+# End of makefile for libpng

src/png/scripts/makefile.dec

@@ -0,0 +1,68 @@
+# makefile for libpng on DEC Alpha Unix
+# Copyright (C) 1995 Guy Eric Schalnat, Group 42, Inc.
+# For conditions of distribution and use, see copyright notice in png.h
+
+# Where the zlib library and include files are located
+#ZLIBLIB=/usr/local/lib
+#ZLIBINC=/usr/local/include
+ZLIBLIB=../zlib
+ZLIBINC=../zlib
+
+CC=cc
+CFLAGS=-std -w1 -I$(ZLIBINC) -O # -g -DPNG_DEBUG=1
+LDFLAGS=-L. -L$(ZLIBLIB) -lpng -lz -lm
+
+#RANLIB=echo
+RANLIB=ranlib
+
+# where make install puts libpng.a and png.h
+prefix=/usr/local
+
+OBJS = png.o pngset.o pngget.o pngrutil.o pngtrans.o pngwutil.o \
+	pngread.o pngrio.o pngwio.o pngwrite.o pngrtran.o \
+	pngwtran.o pngmem.o pngerror.o pngpread.o
+
+all: libpng.a pngtest
+
+libpng.a: $(OBJS)
+	ar rc $@  $(OBJS)
+	$(RANLIB) $@
+
+pngtest: pngtest.o libpng.a
+	$(CC) -o pngtest $(CFLAGS) pngtest.o $(LDFLAGS)
+
+test: pngtest
+	./pngtest
+
+install: libpng.a
+	-@mkdir $(prefix)/include
+	-@mkdir $(prefix)/lib
+	cp png.h $(prefix)/include
+	cp pngconf.h $(prefix)/include
+	chmod 644 $(prefix)/include/png.h
+	chmod 644 $(prefix)/include/pngconf.h
+	cp libpng.a $(prefix)/lib
+	chmod 644 $(prefix)/lib/libpng.a
+
+clean:
+	rm -f *.o libpng.a pngtest pngout.png
+
+# DO NOT DELETE THIS LINE -- make depend depends on it.
+
+png.o: png.h pngconf.h
+pngerror.o: png.h pngconf.h
+pngrio.o: png.h pngconf.h
+pngwio.o: png.h pngconf.h
+pngmem.o: png.h pngconf.h
+pngset.o: png.h pngconf.h
+pngget.o: png.h pngconf.h
+pngread.o: png.h pngconf.h
+pngrtran.o: png.h pngconf.h
+pngrutil.o: png.h pngconf.h
+pngtest.o: png.h pngconf.h
+pngtrans.o: png.h pngconf.h
+pngwrite.o: png.h pngconf.h
+pngwtran.o: png.h pngconf.h
+pngwutil.o: png.h pngconf.h
+pngpread.o: png.h pngconf.h
+

src/png/scripts/makefile.dj2

@@ -0,0 +1,52 @@
+# DJGPP (DOS gcc) makefile for libpng
+# Copyright (C) 1995 Guy Eric Schalnat, Group 42, Inc.
+# For conditions of distribution and use, see copyright notice in png.h
+
+CC=gcc
+CFLAGS=-I../zlib -O
+LDFLAGS=-L. -L../zlib/ -lpng -lz -lm
+
+RANLIB=ranlib
+
+# where make install puts libpng.a and png.h
+#prefix=/usr/local
+prefix=.
+
+OBJS = png.o pngset.o pngget.o pngrutil.o pngtrans.o pngwutil.o \
+	pngread.o pngrio.o pngwio.o pngwrite.o pngrtran.o pngwtran.o \
+	pngmem.o pngerror.o pngpread.o
+
+all: libpng.a pngtest
+
+libpng.a: $(OBJS)
+	ar rc $@  $(OBJS)
+	$(RANLIB) $@
+
+pngtest: pngtest.o libpng.a
+	$(CC) -o pngtest $(CFLAGS) pngtest.o $(LDFLAGS)
+	coff2exe pngtest
+
+test: pngtest
+	./pngtest
+clean:
+	rm -f *.o libpng.a pngtest pngout.png
+
+# DO NOT DELETE THIS LINE -- make depend depends on it.
+
+png.o: png.h pngconf.h
+pngerror.o: png.h pngconf.h
+pngrio.o: png.h pngconf.h
+pngwio.o: png.h pngconf.h
+pngmem.o: png.h pngconf.h
+pngset.o: png.h pngconf.h
+pngget.o: png.h pngconf.h
+pngread.o: png.h pngconf.h
+pngpread.o: png.h pngconf.h
+pngrtran.o: png.h pngconf.h
+pngrutil.o: png.h pngconf.h
+pngtest.o: png.h pngconf.h
+pngtrans.o: png.h pngconf.h
+pngwrite.o: png.h pngconf.h
+pngwtran.o: png.h pngconf.h
+pngwutil.o: png.h pngconf.h
+

src/png/scripts/makefile.knr

@@ -0,0 +1,73 @@
+# makefile for libpng
+# Copyright (C) 1995 Guy Eric Schalnat, Group 42, Inc.
+# For conditions of distribution and use, see copyright notice in png.h
+
+CC=cc
+CFLAGS=-I../zlib -O
+LDFLAGS=-L. -L../zlib/ -lpng -lz -lm
+# flags for ansi2knr
+ANSI2KNRFLAGS=
+
+RANLIB=ranlib
+#RANLIB=echo
+
+# where make install puts libpng.a and png.h
+prefix=/usr/local
+
+OBJS = png.o pngset.o pngget.o pngrutil.o pngtrans.o pngwutil.o \
+	pngread.o pngrio.o pngwio.o pngwrite.o pngrtran.o \
+	pngwtran.o pngmem.o pngerror.o pngpread.o
+
+all: ansi2knr libpng.a pngtest
+
+# general rule to allow ansi2knr to work
+.c.o:
+	./ansi2knr $*.c T$*.c
+	$(CC) $(CFLAGS) -c T$*.c
+	rm -f T$*.c $*.o
+	mv T$*.o $*.o
+
+ansi2knr: ansi2knr.c
+	$(CC) $(CFLAGS) $(ANSI2KNRFLAGS) -o ansi2knr ansi2knr.c
+
+libpng.a: ansi2knr $(OBJS)
+	ar rc $@  $(OBJS)
+	$(RANLIB) $@
+
+pngtest: pngtest.o libpng.a
+	$(CC) -o pngtest $(CFLAGS) pngtest.o $(LDFLAGS)
+
+test: pngtest
+	./pngtest
+
+install: libpng.a
+	-@mkdir $(prefix)/include
+	-@mkdir $(prefix)/lib
+	cp png.h $(prefix)/include
+	cp pngconf.h $(prefix)/include
+	chmod 644 $(prefix)/include/png.h
+	chmod 644 $(prefix)/include/pngconf.h
+	cp libpng.a $(prefix)/lib
+	chmod 644 $(prefix)/lib/libpng.a
+
+clean:
+	rm -f *.o libpng.a pngtest pngout.png ansi2knr
+
+# DO NOT DELETE THIS LINE -- make depend depends on it.
+
+png.o: png.h pngconf.h
+pngerror.o: png.h pngconf.h
+pngrio.o: png.h pngconf.h
+pngwio.o: png.h pngconf.h
+pngmem.o: png.h pngconf.h
+pngset.o: png.h pngconf.h
+pngget.o: png.h pngconf.h
+pngread.o: png.h pngconf.h
+pngpread.o: png.h pngconf.h
+pngrtran.o: png.h pngconf.h
+pngrutil.o: png.h pngconf.h
+pngtest.o: png.h pngconf.h
+pngtrans.o: png.h pngconf.h
+pngwrite.o: png.h pngconf.h
+pngwtran.o: png.h pngconf.h
+pngwutil.o: png.h pngconf.h

src/png/scripts/makefile.lnx

@@ -0,0 +1,99 @@
+# makefile for libpng on Linux ELF with gcc
+# Copyright (C) 1996, 1997 Andreas Dilger
+# Copyright (C) 1998 Greg Roelofs
+# For conditions of distribution and use, see copyright notice in png.h
+
+CC=gcc
+
+# Where the zlib library and include files are located
+#ZLIBLIB=/usr/local/lib
+#ZLIBINC=/usr/local/include
+ZLIBLIB=../zlib
+ZLIBINC=../zlib
+
+WARNMORE=-Wwrite-strings -Wpointer-arith -Wshadow \
+         -Wmissing-declarations -Wtraditional -Wcast-align \
+         -Wstrict-prototypes -Wmissing-prototypes #-Wconversion
+CFLAGS=-I$(ZLIBINC) -Wall -O3 -funroll-loops -malign-loops=2 \
+       -malign-functions=2 #$(WARNMORE) -g -DPNG_DEBUG=5
+LDFLAGS=-L. -Wl,-rpath,. -L$(ZLIBLIB) -Wl,-rpath,$(ZLIBLIB) -lpng -lz -lm
+
+RANLIB=ranlib
+#RANLIB=echo
+
+# read libpng.txt or png.h to see why PNGMAJ is 2.  You should not
+# have to change it.
+PNGMAJ = 2
+PNGMIN = 1.0
+PNGVER = $(PNGMAJ).$(PNGMIN)
+
+# where make install puts libpng.a, libpng.so*, and png.h
+prefix=/usr/local
+INCPATH=$(prefix)/include
+LIBPATH=$(prefix)/lib
+
+OBJS = png.o pngset.o pngget.o pngrutil.o pngtrans.o pngwutil.o \
+       pngread.o pngrio.o pngwio.o pngwrite.o pngrtran.o \
+       pngwtran.o pngmem.o pngerror.o pngpread.o
+
+OBJSDLL = $(OBJS:.o=.pic.o)
+
+.SUFFIXES:      .c .o .pic.o
+
+.c.pic.o:
+	$(CC) -c $(CFLAGS) -fPIC -o $@ $*.c
+
+all: libpng.a libpng.so pngtest
+
+libpng.a: $(OBJS)
+	ar rc $@ $(OBJS)
+	$(RANLIB) $@
+
+libpng.so: libpng.so.$(PNGMAJ)
+	ln -sf libpng.so.$(PNGMAJ) libpng.so
+
+libpng.so.$(PNGMAJ): libpng.so.$(PNGVER)
+	ln -sf libpng.so.$(PNGVER) libpng.so.$(PNGMAJ)
+
+libpng.so.$(PNGVER): $(OBJSDLL)
+	$(CC) -shared -Wl,-soname,libpng.so.$(PNGMAJ) -o libpng.so.$(PNGVER) \
+	 $(OBJSDLL)
+
+pngtest: pngtest.o libpng.so
+	$(CC) -o pngtest $(CFLAGS) pngtest.o $(LDFLAGS)
+
+test: pngtest
+	./pngtest
+
+install: libpng.a libpng.so.$(PNGVER)
+	-@mkdir $(INCPATH) $(LIBPATH)
+	cp png.h pngconf.h $(INCPATH)
+	chmod 644 $(INCPATH)/png.h $(INCPATH)/pngconf.h
+	cp libpng.a libpng.so.$(PNGVER) $(LIBPATH)
+	chmod 755 $(LIBPATH)/libpng.so.$(PNGVER)
+	-@/bin/rm -f $(LIBPATH)/libpng.so.$(PNGMAJ) $(LIBPATH)/libpng.so
+	(cd $(LIBPATH); ln -sf libpng.so.$(PNGVER) libpng.so.$(PNGMAJ); \
+	 ln -sf libpng.so.$(PNGMAJ) libpng.so)
+
+clean:
+	/bin/rm -f *.o libpng.a libpng.so* pngtest pngout.png
+
+# DO NOT DELETE THIS LINE -- make depend depends on it.
+
+png.o png.pic.o: png.h pngconf.h
+pngerror.o pngerror.pic.o: png.h pngconf.h
+pngrio.o pngrio.pic.o: png.h pngconf.h
+pngwio.o pngwio.pic.o: png.h pngconf.h
+pngmem.o pngmem.pic.o: png.h pngconf.h
+pngset.o pngset.pic.o: png.h pngconf.h
+pngget.o pngget.pic.o: png.h pngconf.h
+pngread.o pngread.pic.o: png.h pngconf.h
+pngrtran.o pngrtran.pic.o: png.h pngconf.h
+pngrutil.o pngrutil.pic.o: png.h pngconf.h
+pngtrans.o pngtrans.pic.o: png.h pngconf.h
+pngwrite.o pngwrite.pic.o: png.h pngconf.h
+pngwtran.o pngwtran.pic.o: png.h pngconf.h
+pngwutil.o pngwutil.pic.o: png.h pngconf.h
+pngpread.o pngpread.pic.o: png.h pngconf.h
+
+pngtest.o: png.h pngconf.h

src/png/scripts/makefile.mip

@@ -0,0 +1,62 @@
+# makefile for libpng
+# Copyright (C) 1995 Guy Eric Schalnat, Group 42, Inc.
+# For conditions of distribution and use, see copyright notice in png.h
+
+CC=cc
+CFLAGS=-I../zlib -O -systype sysv -DSYSV -w -Dmips
+#CFLAGS=-O
+LDFLAGS=-L. -L../zlib/ -lpng -lz -lm
+
+#RANLIB=ranlib
+RANLIB=echo
+
+# where make install puts libpng.a and png.h
+prefix=/usr/local
+
+OBJS = png.o pngset.o pngget.o pngrutil.o pngtrans.o pngwutil.o \
+	pngread.o pngrio.o pngwio.o pngwrite.o pngrtran.o \
+	pngwtran.o pngmem.o pngerror.o pngpread.o
+
+all: libpng.a pngtest
+
+libpng.a: $(OBJS)
+	ar rc $@  $(OBJS)
+	$(RANLIB) $@
+
+pngtest: pngtest.o libpng.a
+	$(CC) -o pngtest $(CFLAGS) pngtest.o $(LDFLAGS)
+
+test: pngtest
+	./pngtest
+
+install: libpng.a
+	-@mkdir $(prefix)/include
+	-@mkdir $(prefix)/lib
+	cp png.h $(prefix)/include
+	cp pngconf.h $(prefix)/include
+	chmod 644 $(prefix)/include/png.h
+	chmod 644 $(prefix)/include/pngconf.h
+	cp libpng.a $(prefix)/lib
+	chmod 644 $(prefix)/lib/libpng.a
+
+clean:
+	rm -f *.o libpng.a pngtest pngout.png
+
+# DO NOT DELETE THIS LINE -- make depend depends on it.
+
+png.o: png.h pngconf.h
+pngerror.o: png.h pngconf.h
+pngrio.o: png.h pngconf.h
+pngwio.o: png.h pngconf.h
+pngmem.o: png.h pngconf.h
+pngset.o: png.h pngconf.h
+pngget.o: png.h pngconf.h
+pngread.o: png.h pngconf.h
+pngpread.o: png.h pngconf.h
+pngrtran.o: png.h pngconf.h
+pngrutil.o: png.h pngconf.h
+pngtest.o: png.h pngconf.h
+pngtrans.o: png.h pngconf.h
+pngwrite.o: png.h pngconf.h
+pngwtran.o: png.h pngconf.h
+pngwutil.o: png.h pngconf.h

src/png/scripts/makefile.msc

@@ -0,0 +1,86 @@
+# makefile for libpng
+# Copyright (C) 1995 Guy Eric Schalnat, Group 42, Inc.
+# For conditions of distribution and use, see copyright notice in png.h
+# Assumes that zlib.lib, zconf.h, and zlib.h have been copied to ..\zlib
+
+# ------------- Microsoft C 5.1 and later -------------
+MODEL=-AL
+CFLAGS=-Oait -Gs -nologo -W3 $(MODEL) -I..\zlib
+#-Ox generates bad code with MSC 5.1
+CC=cl
+LD=link
+LDFLAGS=/e/st:0x1500/noe 
+O=.obj
+
+#uncomment next to put error messages in a file
+ERRFILE= >> pngerrs
+
+# variables
+OBJS1 = png$(O) pngset$(O) pngget$(O) pngrutil$(O) pngtrans$(O) pngwutil$(O)
+OBJS2 = pngmem$(O) pngpread$(O) pngread$(O) pngerror$(O) pngwrite$(O)
+OBJS3 = pngrtran$(O) pngwtran$(O) pngrio$(O) pngwio$(O)
+
+all: libpng.lib
+
+png$(O): png.h pngconf.h
+		  $(CC) -c $(CFLAGS) $*.c $(ERRFILE)
+
+pngset$(O): png.h pngconf.h
+        $(CC) -c $(CFLAGS) $*.c $(ERRFILE)
+
+pngget$(O): png.h pngconf.h
+        $(CC) -c $(CFLAGS) $*.c $(ERRFILE)
+
+pngread$(O): png.h pngconf.h
+        $(CC) -c $(CFLAGS) $*.c $(ERRFILE)
+
+pngpread$(O): png.h pngconf.h
+		  $(CC) -c $(CFLAGS) $*.c $(ERRFILE)
+
+pngrtran$(O): png.h pngconf.h
+        $(CC) -c $(CFLAGS) $*.c $(ERRFILE)
+
+pngrutil$(O): png.h pngconf.h
+        $(CC) -c $(CFLAGS) $*.c $(ERRFILE)
+
+pngerror$(O): png.h pngconf.h
+        $(CC) -c $(CFLAGS) $*.c $(ERRFILE)
+
+pngmem$(O): png.h pngconf.h
+        $(CC) -c $(CFLAGS) $*.c $(ERRFILE)
+
+pngrio$(O): png.h pngconf.h
+        $(CC) -c $(CFLAGS) $*.c $(ERRFILE)
+
+pngwio$(O): png.h pngconf.h
+        $(CC) -c $(CFLAGS) $*.c $(ERRFILE)
+
+pngtest$(O): png.h pngconf.h
+        $(CC) -c $(CFLAGS) $*.c $(ERRFILE)
+
+pngtrans$(O): png.h pngconf.h
+        $(CC) -c $(CFLAGS) $*.c $(ERRFILE)
+
+pngwrite$(O): png.h pngconf.h
+        $(CC) -c $(CFLAGS) $*.c $(ERRFILE)
+
+pngwtran$(O): png.h pngconf.h
+        $(CC) -c $(CFLAGS) $*.c $(ERRFILE)
+
+pngwutil$(O): png.h pngconf.h
+        $(CC) -c $(CFLAGS) $*.c $(ERRFILE)
+
+libpng.lib: $(OBJS1) $(OBJS2) $(OBJS3)
+        del libpng.lib
+	lib libpng $(OBJS1);
+	lib libpng $(OBJS2);
+	lib libpng $(OBJS3);
+
+pngtest.exe: pngtest.obj libpng.lib 
+	$(LD) $(LDFLAGS) pngtest.obj,,,libpng.lib ..\zlib\zlib.lib ;
+
+test: pngtest.exe
+	pngtest
+
+# End of makefile for libpng
+

src/png/scripts/makefile.os2

@@ -0,0 +1,69 @@
+# makefile for libpng on OS/2 with gcc
+# For conditions of distribution and use, see copyright notice in png.h
+
+# Related files: pngos2.def
+
+CC=gcc -Zomf -s
+
+# Where the zlib library and include files are located
+ZLIBLIB=../zlib
+ZLIBINC=../zlib
+
+WARNMORE=-Wwrite-strings -Wpointer-arith -Wshadow \
+         -Wmissing-declarations -Wtraditional -Wcast-align \
+         -Wstrict-prototypes -Wmissing-prototypes #-Wconversion
+CFLAGS=-I$(ZLIBINC) -Wall -O6 -funroll-loops -malign-loops=2 \
+       -malign-functions=2 #$(WARNMORE) -g -DPNG_DEBUG=5
+LDFLAGS=-L. -L$(ZLIBLIB) -lpng -lzdll -Zcrtdll
+AR=emxomfar
+
+PNGLIB=png.lib
+IMPLIB=emximp
+SHAREDLIB=png.dll
+SHAREDLIBIMP=pngdll.lib
+
+OBJS = png.o pngset.o pngget.o pngrutil.o pngtrans.o pngwutil.o \
+       pngread.o pngrio.o pngwio.o pngwrite.o pngrtran.o \
+       pngwtran.o pngmem.o pngerror.o pngpread.o
+
+.SUFFIXES:      .c .o
+
+all: $(PNGLIB) $(SHAREDLIB) $(SHAREDLIBIMP)
+
+$(PNGLIB): $(OBJS)
+	$(AR) rc $@ $(OBJS)
+
+$(SHAREDLIB): $(OBJS) pngos2.def
+	$(CC) $(LDFLAGS) -Zdll -o $@ $^
+
+$(SHAREDLIBIMP): pngos2.def
+	$(IMPLIB) -o $@ $^
+
+pngtest.exe: pngtest.o png.dll pngdll.lib
+	$(CC) -o $@ $(CFLAGS) $< $(LDFLAGS)
+
+test: pngtest.exe
+	./pngtest.exe
+
+clean:
+	rm -f *.o $(PNGLIB) png.dll pngdll.lib pngtest.exe pngout.png
+
+# DO NOT DELETE THIS LINE -- make depend depends on it.
+
+png.o png.pic.o: png.h pngconf.h
+pngerror.o pngerror.pic.o: png.h pngconf.h
+pngrio.o pngrio.pic.o: png.h pngconf.h
+pngwio.o pngwio.pic.o: png.h pngconf.h
+pngmem.o pngmem.pic.o: png.h pngconf.h
+pngset.o pngset.pic.o: png.h pngconf.h
+pngget.o pngget.pic.o: png.h pngconf.h
+pngread.o pngread.pic.o: png.h pngconf.h
+pngrtran.o pngrtran.pic.o: png.h pngconf.h
+pngrutil.o pngrutil.pic.o: png.h pngconf.h
+pngtrans.o pngtrans.pic.o: png.h pngconf.h
+pngwrite.o pngwrite.pic.o: png.h pngconf.h
+pngwtran.o pngwtran.pic.o: png.h pngconf.h
+pngwutil.o pngwutil.pic.o: png.h pngconf.h
+pngpread.o pngpread.pic.o: png.h pngconf.h
+
+pngtest.o: png.h pngconf.h

src/png/scripts/makefile.s2x

@@ -0,0 +1,104 @@
+# makefile for libpng on Solaris 2.x with gcc
+# Contributed by William L. Sebok, based on makefile.lnx
+# Copyright (C) 1996, 1997 Andreas Dilger
+# Copyright (C) 1998 Greg Roelofs
+# For conditions of distribution and use, see copyright notice in png.h
+
+CC=gcc
+
+# Where the zlib library and include files are located
+# Changing these to ../zlib poses a security risk.  If you want
+# to have zlib in an adjacent directory, specify the full path instead of "..".
+#ZLIBLIB=../zlib
+#ZLIBINC=../zlib
+
+ZLIBLIB=/usr/local/lib
+ZLIBINC=/usr/local/include
+
+
+WARNMORE=-Wwrite-strings -Wpointer-arith -Wshadow \
+         -Wmissing-declarations -Wtraditional -Wcast-align \
+         -Wstrict-prototypes -Wmissing-prototypes #-Wconversion
+CFLAGS=-I$(ZLIBINC) -Wall -O3 \
+      #$(WARNMORE) -g -DPNG_DEBUG=5
+LDFLAGS=-L. -R. -L$(ZLIBLIB) -R$(ZLIBLIB) -lpng -lz -lm
+
+#RANLIB=ranlib
+RANLIB=echo
+
+# read libpng.txt or png.h to see why PNGMAJ is 2.  You should not
+# have to change it.
+PNGMAJ = 2
+PNGMIN = 1.0
+PNGVER = $(PNGMAJ).$(PNGMIN)
+
+# where make install puts libpng.a, libpng.so*, and png.h
+prefix=/usr/local
+INCPATH=$(prefix)/include
+LIBPATH=$(prefix)/lib
+
+OBJS = png.o pngset.o pngget.o pngrutil.o pngtrans.o pngwutil.o \
+       pngread.o pngrio.o pngwio.o pngwrite.o pngrtran.o \
+       pngwtran.o pngmem.o pngerror.o pngpread.o
+
+OBJSDLL = $(OBJS:.o=.pic.o)
+
+.SUFFIXES:      .c .o .pic.o
+
+.c.pic.o:
+	$(CC) -c $(CFLAGS) -fPIC -o $@ $*.c
+
+all: libpng.a libpng.so pngtest
+
+libpng.a: $(OBJS)
+	ar rc $@ $(OBJS)
+	$(RANLIB) $@
+
+libpng.so: libpng.so.$(PNGMAJ)
+	ln -sf libpng.so.$(PNGMAJ) libpng.so
+
+libpng.so.$(PNGMAJ): libpng.so.$(PNGVER)
+	ln -sf libpng.so.$(PNGVER) libpng.so.$(PNGMAJ)
+
+libpng.so.$(PNGVER): $(OBJSDLL)
+	$(LD) -G -L$(ZLIBLIB) -R$(ZLIBLIB) -h libpng.so.$(PNGMAJ) \
+	 -o libpng.so.$(PNGVER) $(OBJSDLL) -lz
+
+pngtest: pngtest.o libpng.so
+	$(CC) -o pngtest $(CFLAGS) pngtest.o $(LDFLAGS)
+
+test: pngtest
+	./pngtest
+
+install: libpng.a libpng.so.$(PNGVER)
+	-@mkdir $(INCPATH) $(LIBPATH)
+	cp png.h pngconf.h $(INCPATH)
+	chmod 644 $(INCPATH)/png.h $(INCPATH)/pngconf.h
+	cp libpng.a libpng.so.$(PNGVER) $(LIBPATH)
+	chmod 755 $(LIBPATH)/libpng.so.$(PNGVER)
+	-@/bin/rm -f $(LIBPATH)/libpng.so.$(PNGMAJ) $(LIBPATH)/libpng.so
+	(cd $(LIBPATH); ln -sf libpng.so.$(PNGVER) libpng.so.$(PNGMAJ); \
+	 ln -sf libpng.so.$(PNGMAJ) libpng.so)
+
+clean:
+	/bin/rm -f *.o libpng.a libpng.so* pngtest pngout.png
+
+# DO NOT DELETE THIS LINE -- make depend depends on it.
+
+png.o png.pic.o: png.h pngconf.h
+pngerror.o pngerror.pic.o: png.h pngconf.h
+pngrio.o pngrio.pic.o: png.h pngconf.h
+pngwio.o pngwio.pic.o: png.h pngconf.h
+pngmem.o pngmem.pic.o: png.h pngconf.h
+pngset.o pngset.pic.o: png.h pngconf.h
+pngget.o pngget.pic.o: png.h pngconf.h
+pngread.o pngread.pic.o: png.h pngconf.h
+pngrtran.o pngrtran.pic.o: png.h pngconf.h
+pngrutil.o pngrutil.pic.o: png.h pngconf.h
+pngtrans.o pngtrans.pic.o: png.h pngconf.h
+pngwrite.o pngwrite.pic.o: png.h pngconf.h
+pngwtran.o pngwtran.pic.o: png.h pngconf.h
+pngwutil.o pngwutil.pic.o: png.h pngconf.h
+pngpread.o pngpread.pic.o: png.h pngconf.h
+
+pngtest.o: png.h pngconf.h

src/png/scripts/makefile.sgi

@@ -0,0 +1,69 @@
+# makefile for libpng
+# Copyright (C) 1995 Guy Eric Schalnat, Group 42, Inc.
+# For conditions of distribution and use, see copyright notice in png.h
+
+# Where the zlib library and include files are located
+#ZLIBLIB=/usr/local/lib
+#ZLIBINC=/usr/local/include
+ZLIBLIB=../zlib
+ZLIBINC=../zlib
+
+CC=cc
+
+CFLAGS=-I$(ZLIBINC) -O -fullwarn # -g -DPNG_DEBUG=1
+LDFLAGS=-L. -L$(ZLIBLIB) -lpng -lz -lm
+
+RANLIB=echo
+#RANLIB=ranlib
+
+# where make install puts libpng.a and png.h
+prefix=/usr/local
+
+OBJS = png.o pngset.o pngget.o pngrutil.o pngtrans.o pngwutil.o \
+	pngread.o pngrio.o pngwio.o pngwrite.o pngrtran.o \
+	pngwtran.o pngmem.o pngerror.o pngpread.o
+
+all: libpng.a pngtest
+
+libpng.a: $(OBJS)
+	ar rc $@  $(OBJS)
+	$(RANLIB) $@
+
+pngtest: pngtest.o libpng.a
+	$(CC) -o pngtest $(CFLAGS) pngtest.o $(LDFLAGS)
+
+test: pngtest
+	./pngtest
+
+install: libpng.a
+	-@mkdir $(prefix)/include
+	-@mkdir $(prefix)/lib
+	cp png.h $(prefix)/include
+	cp pngconf.h $(prefix)/include
+	chmod 644 $(prefix)/include/png.h
+	chmod 644 $(prefix)/include/pngconf.h
+	cp libpng.a $(prefix)/lib
+	chmod 644 $(prefix)/lib/libpng.a
+
+clean:
+	rm -f *.o libpng.a pngtest pngout.png
+
+# DO NOT DELETE THIS LINE -- make depend depends on it.
+
+png.o: png.h pngconf.h
+pngerror.o: png.h pngconf.h
+pngrio.o: png.h pngconf.h
+pngwio.o: png.h pngconf.h
+pngmem.o: png.h pngconf.h
+pngset.o: png.h pngconf.h
+pngget.o: png.h pngconf.h
+pngread.o: png.h pngconf.h
+pngrtran.o: png.h pngconf.h
+pngrutil.o: png.h pngconf.h
+pngtest.o: png.h pngconf.h
+pngtrans.o: png.h pngconf.h
+pngwrite.o: png.h pngconf.h
+pngwtran.o: png.h pngconf.h
+pngwutil.o: png.h pngconf.h
+pngpread.o: png.h pngconf.h
+

src/png/scripts/makefile.std

@@ -0,0 +1,68 @@
+# makefile for libpng
+# Copyright (C) 1995 Guy Eric Schalnat, Group 42, Inc.
+# For conditions of distribution and use, see copyright notice in png.h
+
+# Where the zlib library and include files are located
+#ZLIBLIB=/usr/local/lib
+#ZLIBINC=/usr/local/include
+ZLIBLIB=../zlib
+ZLIBINC=../zlib
+
+CC=cc
+CFLAGS=-I$(ZLIBINC) -O # -g -DPNG_DEBUG=1
+LDFLAGS=-L. -L$(ZLIBLIB) -lpng -lz -lm
+
+#RANLIB=echo
+RANLIB=ranlib
+
+# where make install puts libpng.a and png.h
+prefix=/usr/local
+
+OBJS = png.o pngset.o pngget.o pngrutil.o pngtrans.o pngwutil.o \
+	pngread.o pngrio.o pngwio.o pngwrite.o pngrtran.o \
+	pngwtran.o pngmem.o pngerror.o pngpread.o
+
+all: libpng.a pngtest
+
+libpng.a: $(OBJS)
+	ar rc $@  $(OBJS)
+	$(RANLIB) $@
+
+pngtest: pngtest.o libpng.a
+	$(CC) -o pngtest $(CFLAGS) pngtest.o $(LDFLAGS)
+
+test: pngtest
+	./pngtest
+
+install: libpng.a
+	-@mkdir $(prefix)/include
+	-@mkdir $(prefix)/lib
+	cp png.h $(prefix)/include
+	cp pngconf.h $(prefix)/include
+	chmod 644 $(prefix)/include/png.h
+	chmod 644 $(prefix)/include/pngconf.h
+	cp libpng.a $(prefix)/lib
+	chmod 644 $(prefix)/lib/libpng.a
+
+clean:
+	rm -f *.o libpng.a pngtest pngout.png
+
+# DO NOT DELETE THIS LINE -- make depend depends on it.
+
+png.o: png.h pngconf.h
+pngerror.o: png.h pngconf.h
+pngrio.o: png.h pngconf.h
+pngwio.o: png.h pngconf.h
+pngmem.o: png.h pngconf.h
+pngset.o: png.h pngconf.h
+pngget.o: png.h pngconf.h
+pngread.o: png.h pngconf.h
+pngrtran.o: png.h pngconf.h
+pngrutil.o: png.h pngconf.h
+pngtest.o: png.h pngconf.h
+pngtrans.o: png.h pngconf.h
+pngwrite.o: png.h pngconf.h
+pngwtran.o: png.h pngconf.h
+pngwutil.o: png.h pngconf.h
+pngpread.o: png.h pngconf.h
+

src/png/scripts/makefile.sun

@@ -0,0 +1,72 @@
+# makefile for libpng
+# Copyright (C) 1995 Guy Eric Schalnat, Group 42, Inc.
+# For conditions of distribution and use, see copyright notice in png.h
+
+# Where the zlib library and include files are located
+#ZLIBLIB=/usr/local/lib
+#ZLIBINC=/usr/local/include
+ZLIBLIB=../zlib
+ZLIBINC=../zlib
+
+
+WARNMORE=-Wwrite-strings -Wpointer-arith -Wshadow -Wconversion \
+         -Wmissing-declarations -Wtraditional -Wcast-align \
+         -Wstrict-prototypes -Wmissing-prototypes
+CC=gcc
+CFLAGS=-I$(ZLIBINC) -O $(WARNMORE) -DPNG_DEBUG=4
+LDFLAGS=-L. -L$(ZLIBLIB) -lpng -lz -lm
+
+RANLIB=ranlib
+#RANLIB=echo
+
+# where make install puts libpng.a and png.h
+prefix=/usr/local
+
+OBJS = png.o pngset.o pngget.o pngrutil.o pngtrans.o pngwutil.o \
+	pngread.o pngrio.o pngwio.o pngwrite.o pngrtran.o \
+	pngwtran.o pngmem.o pngerror.o pngpread.o
+
+all: libpng.a pngtest
+
+libpng.a: $(OBJS)
+	ar rc $@  $(OBJS)
+	$(RANLIB) $@
+
+pngtest: pngtest.o libpng.a
+	$(CC) -o pngtest $(CFLAGS) pngtest.o $(LDFLAGS)
+
+test: pngtest
+	./pngtest
+
+install: libpng.a
+	-@mkdir $(prefix)/include
+	-@mkdir $(prefix)/lib
+	cp png.h $(prefix)/include
+	cp pngconf.h $(prefix)/include
+	chmod 644 $(prefix)/include/png.h
+	chmod 644 $(prefix)/include/pngconf.h
+	cp libpng.a $(prefix)/lib
+	chmod 644 $(prefix)/lib/libpng.a
+
+clean:
+	rm -f *.o libpng.a pngtest pngout.png
+
+# DO NOT DELETE THIS LINE -- make depend depends on it.
+
+png.o: png.h pngconf.h
+pngerror.o: png.h pngconf.h
+pngrio.o: png.h pngconf.h
+pngwio.o: png.h pngconf.h
+pngmem.o: png.h pngconf.h
+pngset.o: png.h pngconf.h
+pngget.o: png.h pngconf.h
+pngread.o: png.h pngconf.h
+pngrtran.o: png.h pngconf.h
+pngrutil.o: png.h pngconf.h
+pngtest.o: png.h pngconf.h
+pngtrans.o: png.h pngconf.h
+pngwrite.o: png.h pngconf.h
+pngwtran.o: png.h pngconf.h
+pngwutil.o: png.h pngconf.h
+pngpread.o: png.h pngconf.h
+

src/png/scripts/makefile.tc3

@@ -0,0 +1,82 @@
+# Makefile for libpng
+# TurboC++ 3.0 (Note: All modules are compiled in C mode)
+
+# To use, do "make -fmakefile.tc3"
+
+# ------------- Turbo C++ 3.0 -------------
+MODEL=-ml
+CFLAGS=-O2 -Z $(MODEL) -I..\zlib
+CC=tcc
+LD=tcc
+LIB=tlib
+LDFLAGS=$(MODEL) -L..\zlib
+O=.obj
+E=.exe
+
+# variables
+OBJS1 = png$(O) pngset$(O) pngget$(O) pngrutil$(O) pngtrans$(O) pngwutil$(O)
+OBJS2 = pngmem$(O) pngpread$(O) pngread$(O) pngerror$(O) pngwrite$(O)
+OBJS3 = pngrtran$(O) pngwtran$(O) pngrio$(O) pngwio$(O)
+OBJSL1 = +png$(O) +pngset$(O) +pngget$(O) +pngrutil$(O) +pngtrans$(O)
+OBJSL2 = +pngwutil$(O) +pngmem$(O) +pngpread$(O) +pngread$(O) +pngerror$(O)
+OBJSL3 = +pngwrite$(O) +pngrtran$(O) +pngwtran$(O) +pngrio$(O) +pngwio$(O)
+
+all: libpng.lib pngtest.exe
+
+png$(O): png.h pngconf.h
+		  $(CC) -c $(CFLAGS) $*.c
+
+pngset$(O): png.h pngconf.h
+		  $(CC) -c $(CFLAGS) $*.c
+
+pngget$(O): png.h pngconf.h
+		  $(CC) -c $(CFLAGS) $*.c
+
+pngread$(O): png.h pngconf.h
+		  $(CC) -c $(CFLAGS) $*.c
+
+pngpread$(O): png.h pngconf.h
+		  $(CC) -c $(CFLAGS) $*.c
+
+pngrtran$(O): png.h pngconf.h
+		  $(CC) -c $(CFLAGS) $*.c
+
+pngrutil$(O): png.h pngconf.h
+		  $(CC) -c $(CFLAGS) $*.c
+
+pngerror$(O): png.h pngconf.h
+        $(CC) -c $(CFLAGS) $*.c
+
+pngmem$(O): png.h pngconf.h
+        $(CC) -c $(CFLAGS) $*.c
+
+pngrio$(O): png.h pngconf.h
+        $(CC) -c $(CFLAGS) $*.c
+
+pngwio$(O): png.h pngconf.h
+        $(CC) -c $(CFLAGS) $*.c
+
+pngtest$(O): png.h pngconf.h
+        $(CC) -c $(CFLAGS) $*.c
+
+pngtrans$(O): png.h pngconf.h
+        $(CC) -c $(CFLAGS) $*.c
+
+pngwrite$(O): png.h pngconf.h
+        $(CC) -c $(CFLAGS) $*.c
+
+pngwtran$(O): png.h pngconf.h
+        $(CC) -c $(CFLAGS) $*.c
+
+pngwutil$(O): png.h pngconf.h
+        $(CC) -c $(CFLAGS) $*.c
+
+libpng.lib: $(OBJS1) $(OBJS2) $(OBJS3)
+        $(LIB) libpng +$(OBJSL1)
+        $(LIB) libpng +$(OBJSL2)
+        $(LIB) libpng +$(OBJSL3)
+
+pngtest$(E): pngtest$(O) libpng.lib
+        $(CC) $(LDFLAGS) pngtest.obj libpng.lib zlib.lib
+
+# End of makefile for libpng

src/png/scripts/makefile.wat

@@ -0,0 +1,88 @@
+# Makefile for libpng
+# Watcom 10a and later 32-bit protected mode flat memory model
+
+# Adapted by Pawel Mrochen, based on makefile.msc
+# For conditions of distribution and use, see copyright notice in png.h
+# Assumes that zlib.lib, zconf.h, and zlib.h have been copied to ..\zlib
+
+# To use, do "wmake -f makefile.wat"
+
+# ------------- Watcom 10a and later -------------
+MODEL=-mf
+CFLAGS= $(MODEL) -fpi87 -fp5 -5r -oaeilmnrt -s -zp4 -i=..\zlib
+CC=wcc386
+LD=wcl386
+LIB=wlib -b -c
+LDFLAGS=
+O=.obj
+
+#uncomment next to put error messages in a file
+#ERRFILE= >> pngerrs
+
+# variables
+OBJS1 = png$(O) pngset$(O) pngget$(O) pngrutil$(O) pngtrans$(O) pngwutil$(O)
+OBJS2 = pngmem$(O) pngpread$(O) pngread$(O) pngerror$(O) pngwrite$(O)
+OBJS3 = pngrtran$(O) pngwtran$(O) pngrio$(O) pngwio$(O)
+
+all: test
+
+png$(O): png.h pngconf.h
+	$(CC) $(CFLAGS) $*.c $(ERRFILE)
+
+pngset$(O): png.h pngconf.h
+	$(CC) $(CFLAGS) $*.c $(ERRFILE)
+
+pngget$(O): png.h pngconf.h
+	$(CC) $(CFLAGS) $*.c $(ERRFILE)
+
+pngread$(O): png.h pngconf.h
+	$(CC) $(CFLAGS) $*.c $(ERRFILE)
+
+pngpread$(O): png.h pngconf.h
+	$(CC) $(CFLAGS) $*.c $(ERRFILE)
+
+pngrtran$(O): png.h pngconf.h
+	$(CC) $(CFLAGS) $*.c $(ERRFILE)
+
+pngrutil$(O): png.h pngconf.h
+	$(CC) $(CFLAGS) $*.c $(ERRFILE)
+
+pngerror$(O): png.h pngconf.h
+	$(CC) $(CFLAGS) $*.c $(ERRFILE)
+
+pngmem$(O): png.h pngconf.h
+	$(CC) $(CFLAGS) $*.c $(ERRFILE)
+
+pngrio$(O): png.h pngconf.h
+	$(CC) $(CFLAGS) $*.c $(ERRFILE)
+
+pngwio$(O): png.h pngconf.h
+	$(CC) $(CFLAGS) $*.c $(ERRFILE)
+
+pngtest$(O): png.h pngconf.h
+	$(CC) $(CFLAGS) $*.c $(ERRFILE)
+
+pngtrans$(O): png.h pngconf.h
+	$(CC) $(CFLAGS) $*.c $(ERRFILE)
+
+pngwrite$(O): png.h pngconf.h
+	$(CC) $(CFLAGS) $*.c $(ERRFILE)
+
+pngwtran$(O): png.h pngconf.h
+	$(CC) $(CFLAGS) $*.c $(ERRFILE)
+
+pngwutil$(O): png.h pngconf.h
+	$(CC) $(CFLAGS) $*.c $(ERRFILE)
+
+libpng.lib: $(OBJS1) $(OBJS2) $(OBJS3)
+	$(LIB) -n libpng.lib +$(OBJS1)
+	$(LIB) libpng.lib +$(OBJS2)
+	$(LIB) libpng.lib +$(OBJS3)
+
+pngtest.exe: pngtest.obj libpng.lib
+	$(LD) $(LDFLAGS) pngtest.obj libpng.lib ..\zlib\zlib.lib
+
+test: pngtest.exe
+	pngtest
+
+# End of makefile for libpng

src/png/scripts/makevms.com

@@ -0,0 +1,125 @@
+$! make libpng under VMS
+$!
+$!
+$! Look for the compiler used
+$!
+$ zlibsrc = "[-.zlib]"
+$ ccopt="/include=''zlibsrc'"
+$ if f$getsyi("HW_MODEL").ge.1024
+$ then
+$  ccopt = "/prefix=all"+ccopt
+$  comp  = "__decc__=1"
+$  if f$trnlnm("SYS").eqs."" then define sys sys$library:
+$ else
+$  if f$search("SYS$SYSTEM:DECC$COMPILER.EXE").eqs.""
+$   then
+$    if f$trnlnm("SYS").eqs."" then define sys sys$library:
+$    if f$search("SYS$SYSTEM:VAXC.EXE").eqs.""
+$     then
+$      comp  = "__gcc__=1"
+$      CC :== GCC
+$     else
+$      comp = "__vaxc__=1"
+$     endif
+$   else
+$    if f$trnlnm("SYS").eqs."" then define sys decc$library_include:
+$    ccopt = "/decc/prefix=all"+ccopt
+$    comp  = "__decc__=1"
+$  endif
+$ endif
+$!
+$! Build the thing plain or with mms
+$!
+$ write sys$output "Compiling Libpng sources ..."
+$ if f$search("SYS$SYSTEM:MMS.EXE").eqs.""
+$  then
+$   dele pngtest.obj;*
+$   CALL MAKE png.OBJ "cc ''CCOPT' png" -
+                png.c png.h pngconf.h   
+$   CALL MAKE pngpread.OBJ "cc ''CCOPT' pngpread" -
+					 pngpread.c png.h pngconf.h
+$   CALL MAKE pngset.OBJ "cc ''CCOPT' pngset" -
+                pngset.c png.h pngconf.h
+$   CALL MAKE pngget.OBJ "cc ''CCOPT' pngget" -
+                pngget.c png.h pngconf.h
+$   CALL MAKE pngread.OBJ "cc ''CCOPT' pngread" -
+                pngread.c png.h pngconf.h
+$   CALL MAKE pngpread.OBJ "cc ''CCOPT' pngpread" -
+					 pngpread.c png.h pngconf.h
+$   CALL MAKE pngrtran.OBJ "cc ''CCOPT' pngrtran" -
+                pngrtran.c png.h pngconf.h
+$   CALL MAKE pngrutil.OBJ "cc ''CCOPT' pngrutil" -
+                pngrutil.c png.h pngconf.h
+$   CALL MAKE pngerror.OBJ "cc ''CCOPT' pngerror" -
+                pngerror.c png.h pngconf.h
+$   CALL MAKE pngmem.OBJ "cc ''CCOPT' pngmem" -
+                pngmem.c png.h pngconf.h
+$   CALL MAKE pngrio.OBJ "cc ''CCOPT' pngrio" -
+                pngrio.c png.h pngconf.h
+$   CALL MAKE pngwio.OBJ "cc ''CCOPT' pngwio" -
+                pngwio.c png.h pngconf.h
+$   CALL MAKE pngtrans.OBJ "cc ''CCOPT' pngtrans" -
+                pngtrans.c png.h pngconf.h
+$   CALL MAKE pngwrite.OBJ "cc ''CCOPT' pngwrite" -
+                pngwrite.c png.h pngconf.h
+$   CALL MAKE pngwtran.OBJ "cc ''CCOPT' pngwtran" -
+                pngwtran.c png.h pngconf.h
+$   CALL MAKE pngwutil.OBJ "cc ''CCOPT' pngwutil" -
+                pngwutil.c png.h pngconf.h
+$   write sys$output "Building Libpng ..."
+$   CALL MAKE libpng.OLB "lib/crea libpng.olb *.obj" *.OBJ
+$   write sys$output "Building pngtest..."
+$   CALL MAKE pngtest.OBJ "cc ''CCOPT' pngtest" -
+                pngtest.c png.h pngconf.h
+$   call make pngtest.exe - 
+                "LINK pngtest,libpng.olb/lib,''zlibsrc'libgz.olb/lib" - 
+                pngtest.obj libpng.olb
+$   write sys$output "Testing Libpng..."
+$   run pngtest
+$  else
+$   mms/macro=('comp',zlibsrc='zlibsrc')
+$  endif
+$ write sys$output "Libpng build completed"
+$ exit
+$!
+$!
+$MAKE: SUBROUTINE   !SUBROUTINE TO CHECK DEPENDENCIES
+$ V = 'F$Verify(0)
+$! P1 = What we are trying to make
+$! P2 = Command to make it
+$! P3 - P8  What it depends on
+$
+$ If F$Search(P1) .Eqs. "" Then Goto Makeit
+$ Time = F$CvTime(F$File(P1,"RDT"))
+$arg=3
+$Loop:
+$       Argument = P'arg
+$       If Argument .Eqs. "" Then Goto Exit
+$       El=0
+$Loop2:
+$       File = F$Element(El," ",Argument)
+$       If File .Eqs. " " Then Goto Endl
+$       AFile = ""
+$Loop3:
+$       OFile = AFile
+$       AFile = F$Search(File)
+$       If AFile .Eqs. "" .Or. AFile .Eqs. OFile Then Goto NextEl
+$       If F$CvTime(F$File(AFile,"RDT")) .Ges. Time Then Goto Makeit
+$       Goto Loop3
+$NextEL:
+$       El = El + 1
+$       Goto Loop2
+$EndL:
+$ arg=arg+1
+$ If arg .Le. 8 Then Goto Loop
+$ Goto Exit
+$
+$Makeit:
+$ VV=F$VERIFY(0)
+$ write sys$output P2
+$ 'P2
+$ VV='F$Verify(VV)
+$Exit:
+$ If V Then Set Verify
+$ENDSUBROUTINE
+

src/png/scripts/pngos2.def

@@ -0,0 +1,286 @@
+;----------------------------------------
+; PNGLIB module definition file for OS/2
+;----------------------------------------
+
+LIBRARY		PNG
+DESCRIPTION	"PNG image compression library for OS/2"
+CODE		PRELOAD MOVEABLE DISCARDABLE
+DATA		PRELOAD MOVEABLE MULTIPLE
+
+EXPORTS
+  png_set_sig_bytes
+  png_sig_cmp
+  png_check_sig
+  png_create_read_struct
+  png_create_write_struct
+  png_write_chunk
+  png_write_chunk_start
+  png_write_chunk_data
+  png_write_chunk_end
+  png_create_info_struct
+  png_info_init
+  png_write_info
+  png_read_info
+  png_convert_to_rfc1123
+  png_convert_from_struct_tm
+  png_convert_from_time_t
+  png_set_expand
+  png_set_bgr
+  png_set_gray_to_rgb
+; png_set_rgb_to_gray
+  png_build_grayscale_palette
+  png_set_strip_alpha
+  png_set_swap_alpha
+  png_set_invert_alpha
+  png_set_filler
+  png_set_swap
+  png_set_packing
+  png_set_packswap
+  png_set_shift
+  png_set_interlace_handling
+  png_set_invert_mono
+  png_set_background
+  png_set_strip_16
+  png_set_dither
+  png_set_gamma
+  png_set_flush
+  png_write_flush
+  png_start_read_image
+  png_read_update_info
+  png_read_rows
+  png_read_row
+  png_read_image
+  png_write_row
+  png_write_rows
+  png_write_image
+  png_write_end
+  png_read_end
+  png_destroy_info_struct
+  png_destroy_read_struct
+  png_read_destroy
+  png_destroy_write_struct
+; png_write_destroy_info
+  png_write_destroy
+  png_set_crc_action
+  png_set_filter
+  png_set_filter_heuristics
+  png_set_compression_level
+  png_set_compression_mem_level
+  png_set_compression_strategy
+  png_set_compression_window_bits
+  png_set_compression_method
+  png_init_io
+  png_set_error_fn
+  png_get_error_ptr
+  png_set_write_fn
+  png_set_read_fn
+  png_set_write_status_fn
+  png_set_read_status_fn
+  png_get_io_ptr
+  png_set_progressive_read_fn
+  png_set_read_status_fn
+  png_set_read_user_transform_fn
+  png_set_write_status_fn
+  png_set_write_user_transform_fn
+  png_get_progressive_ptr
+  png_process_data
+  png_progressive_combine_row
+  png_malloc
+  png_free
+  png_memcpy_check
+  png_memset_check
+; png_debug_malloc
+; png_debug_free
+; png_far_to_near
+  png_error
+  png_chunk_error
+  png_warning
+  png_chunk_warning
+  png_get_valid
+  png_get_rowbytes
+  png_get_channels
+  png_get_image_width
+  png_get_image_height
+  png_get_bit_depth
+  png_get_color_type
+  png_get_filter_type
+  png_get_interlace_type
+  png_get_compression_type
+  png_get_pixels_per_meter
+  png_get_pixel_aspect_ratio
+  png_get_x_offset_pixels
+  png_get_y_offset_pixels
+  png_get_x_offset_microns
+  png_get_y_offset_microns
+  png_get_signature
+  png_get_bKGD
+  png_set_bKGD
+  png_get_cHRM
+  png_set_cHRM
+  png_get_gAMA
+  png_set_gAMA
+  png_get_hIST
+  png_set_hIST
+  png_get_IHDR
+  png_set_IHDR
+  png_get_oFFs
+  png_set_oFFs
+  png_get_pCAL
+  png_set_pCAL
+  png_get_pHYs
+  png_set_pHYs
+  png_get_PLTE
+  png_set_PLTE
+  png_get_sBIT
+  png_set_sBIT
+  png_get_sRGB
+  png_set_sRGB
+  png_set_sRGB_gAMA_and_cHRM
+  png_get_text
+  png_set_text
+  png_get_tIME
+  png_set_tIME
+  png_get_tRNS
+  png_set_tRNS
+
+  png_create_struct
+  png_destroy_struct
+  png_info_destroy
+  png_zalloc
+  png_zfree
+  png_reset_crc
+  png_write_data
+  png_read_data
+  png_crc_read
+  png_crc_finish
+  png_crc_error
+  png_calculate_crc
+  png_flush
+  png_save_uint_32
+  png_save_int_32
+  png_save_uint_16
+  png_write_sig
+  png_write_IHDR
+  png_write_PLTE
+  png_write_IDAT
+  png_write_IEND
+  png_write_gAMA
+  png_write_sBIT
+  png_write_cHRM
+  png_write_sRGB
+  png_write_tRNS
+  png_write_bKGD
+  png_write_hIST
+  png_check_keyword
+  png_write_tEXt
+  png_write_zTXt
+  png_write_oFFs
+  png_write_pCAL
+  png_write_pHYs
+  png_write_tIME
+  png_write_finish_row
+  png_write_start_row
+  png_build_gamma_table
+  png_combine_row
+  png_do_read_interlace
+  png_do_write_interlace
+  png_read_filter_row
+  png_write_find_filter
+  png_write_filtered_row
+  png_read_finish_row
+  png_read_start_row
+  png_read_transform_info
+  png_do_read_filler
+  png_do_read_swap_alpha
+  png_do_write_swap_alpha
+  png_do_read_invert_alpha
+  png_do_write_invert_alpha
+  png_do_strip_filler
+  png_do_swap
+  png_do_packswap
+; png_do_rgb_to_gray
+  png_do_gray_to_rgb
+  png_do_unpack
+  png_do_unshift
+  png_do_invert
+  png_do_chop
+  png_do_dither
+; png_correct_palette
+  png_do_bgr
+  png_do_pack
+  png_do_shift
+  png_do_background
+  png_do_gamma
+  png_do_expand_palette
+  png_do_expand
+  png_handle_IHDR
+  png_handle_PLTE
+  png_handle_IEND
+  png_handle_gAMA
+  png_handle_sBIT
+  png_handle_cHRM
+  png_handle_sRGB
+  png_handle_tRNS
+  png_handle_bKGD
+  png_handle_hIST
+  png_handle_oFFs
+  png_handle_pCAL
+  png_handle_pHYs
+  png_handle_tIME
+  png_handle_tEXt
+  png_handle_zTXt
+  png_handle_unknown
+  png_check_chunk_name
+  png_do_read_transformations
+  png_do_write_transformations
+  png_init_read_transformations
+  png_push_read_chunk
+  png_push_read_sig
+; png_push_check_crc
+  png_push_crc_skip
+  png_push_crc_finish
+  png_push_fill_buffer
+  png_push_save_buffer
+  png_push_restore_buffer
+  png_push_read_IDAT
+  png_process_IDAT_data
+  png_push_process_row
+  png_push_handle_unknown
+  png_push_have_info
+  png_push_have_end
+  png_push_have_row
+; png_push_read_end
+  png_process_some_data
+  png_read_push_finish_row
+  png_push_handle_tEXt
+  png_push_read_tEXt
+  png_push_handle_zTXt
+  png_push_read_zTXt
+
+  png_libpng_ver
+  png_pass_start
+  png_pass_inc
+  png_pass_ystart
+  png_pass_yinc
+  png_pass_mask
+  png_pass_dsp_mask
+; png_pass_width
+; png_pass_height
+
+  png_IHDR
+  png_IDAT
+  png_IEND
+  png_PLTE
+  png_bKGD
+  png_cHRM
+  png_gAMA
+  png_hIST
+  png_oFFs
+  png_pCAL
+  png_pHYs
+  png_sBIT
+  png_sRGB
+  png_tEXt
+  png_tIME
+  png_tRNS
+  png_zTXt

src/png/scripts/smakefile.ppc

@@ -0,0 +1,29 @@
+# Amiga powerUP (TM) Makefile
+# makefile for libpng and SAS C V6.58/7.00 PPC compiler
+# Copyright (C) 1998 by Andreas R. Kleinert
+
+CC       = scppc
+CFLAGS   = NOSTKCHK NOSINT OPTIMIZE OPTGO OPTPEEP OPTINLOCAL OPTINL IDIR /zlib \
+           OPTLOOP OPTRDEP=8 OPTDEP=8 OPTCOMP=8
+LIBNAME  = libpng.a
+AR       = ppc-amigaos-ar
+AR_FLAGS = cr
+RANLIB   = ppc-amigaos-ranlib
+LDFLAGS  = -r -o
+LDLIBS   =  ../zlib/libzip.a LIB:scppc.a
+LN       = ppc-amigaos-ld
+RM       = delete quiet
+MKDIR    = makedir
+
+OBJS = png.o pngset.o pngget.o pngrutil.o pngtrans.o pngwutil.o pngread.o \
+pngerror.o pngpread.o pngwrite.o pngrtran.o pngwtran.o pngrio.o pngwio.o pngmem.o
+
+all: $(LIBNAME) pngtest
+
+$(LIBNAME): $(OBJS)
+            $(AR) $(AR_FLAGS) $@ $(OBJS)
+            $(RANLIB) $@
+
+pngtest: pngtest.o $(LIBNAME)
+        $(LN) $(LDFLAGS) pngtest LIB:c_ppc.o pngtest.o $(LIBNAME) $(LDLIBS) \
+LIB:end.o

wxPython/.cvsignore

@@ -1,9 +0,0 @@
-.emacs.desktop
-MANIFEST
-build
-build.local
-dist
-licence
-s.bat
-temp
-update.log

wxPython/BUILD.osx.txt

@@ -1,68 +0,0 @@
-Building wxPython on Mac OS X
------------------------------
-
-NOTE:  OS X support is HIGHLY EXPERIMENTAL at this time.  Most things
-       don't work correctly (or at all) yet.
-
-These are the steps I have used for building wxPython on Mac OS X 10.1
-with the Apple Developer Tools, a.k.a the Darwin version.  I assume
-that you know your way around a command line and that you know how to
-get things from various CVS repositories as needed.
-
-
-1. Python 2.2 is required.  Get the source from www.python.org and
-   build Python.app and install it as described in the Mac/OSX/README
-   file.
-
-2. You may want to make a symlink or two in /usr/local/bin so that
-   this version of Python can be found from the command line.  For
-   example:
-
-        cd /usr/local/bin
-	sudo ln -s /Library/Frameworks/Python.framework/Versions/2.2/bin/python2.2 python2.2
-        sudo ln -s python2.2 python
-
-3. In a wxWindows CVS tree make a build directory.
-
-	cd ~/proj/wxWindows	# or wherever you put it
-	mkdir build
-
-4. Run configure from that build directory.
-
-        cd build
-	../configure --with-mac --with-opengl --enable-debug
-
-5. Make and install wxMac.
-
-	make
-	sudo make install
-
-6. Build wxPython for testing (without installing it.)
-
-	cd ../wxPython
-	python setup.py IN_CVS_TREE=1 build_ext --inplace --debug
-
-7. Test.  The easiest way to do this from the CVS tree (witout having
-   to reinstall after every build) is to make a symlink in the demo
-   directory to the wxPython package dir, and then run stuff directly
-   from the demo.
-
-	cd demo
-	ln -s ../wxPython .
-
-8. Now just navigate in the Finder to the demo directory and double
-   click demo.py, or simple.py, or whatever you want to run.  Or from
-   a command line you can run it this way:
-
-        open -a Python demo.py
-
-9. Figure out what's wrong, figure out how to fix it, and then send
-   the patches to me.  <wink>
-
---Robin
-
-
-
-
-
-

wxPython/BUILD.unix.txt

@@ -1,289 +0,0 @@
-Building wxPython on Unix or Unix-like Systems
-----------------------------------------------
-
-The basic steps for building wxPython for Unix or Unix-like systems
-are:
-
-     1. Compile and/or install glib and gtk+
-     2. Compile and/or install wxGTK
-     3. Compile and install wxPython
-
-We'll go into more detail of each of these steps below, but first a
-few bits of background information on tools.
-
-I use a tool called SWIG (http://www.swig.org) to help generate the
-C++ sources used in the wxPython extension module.  However you don't
-need to have SWIG unless you want to modify the *.i files.  If you do
-you'll want to have version 1.1-883 of SWIG and you'll need to apply
-the patches and updates in wxPython/SWIG and rebuild it.  Then you'll
-need to change a flag in the setup.py script as described below so the
-wxPython build process will use SWIG if needed.
-
-I use the new Python Distutils tool to build wxPython.  It is included
-with Python 2.0, but if you want to use Python 1.5.2 or 1.6 then
-you'll need to download and install Distutils 1.0 from
-http://www.python.org/sigs/distutils-sig/
-
-I usually use RedHat Linux when working on the wxGTK version of
-wxPython, but I occasionally build and test on Solaris and I hope to
-be able to add some other platforms soon.  The compiler I use is
-whatever comes with the current version of RedHat I am using.  I find
-that there are less portability problems with the RPMs if I don't try
-using the latest and greatest compilers all the time.  On the other
-platforms I usually stick with as recent a version of GCC that I can
-find pre-built for that platform.
-
-Okay, now on the the fun stuff...
-
-
-1. Compile and/or install glib and gtk+
----------------------------------------
-
-A. First of all, check and see if you've already got glib/gtk+ on your
-   system, all the Linux distributions I know of come with it, at
-   least as an option.  Look for libglib.* and libgtk.* in your system's
-   standard library directories.  You'll also need the headers and
-   config scripts in order to build things that use glib/gtk.  Try
-   running gtk-config:
-
-	   gtk-config --version
-
-   If you have version 1.2.5 or better then you're all set.  You can
-   skip to step #2.
-
-B. If your system has a binary package mechanism, (RPMs, debs,
-   whatever...) check and see if binaries for glib abd gtk+ are
-   available.  Be sure to get the runtime library package as well as
-   the development package, if they are separate.  Install them with
-   your package tool, and skip to step #2.
-
-C. If all else fails, you can get the source code for glib and gtk+ at
-   http://www.gtk.org/.  Fetch the latest of each in the 1.2.x
-   series.  Compile and install each of them like this:
-
-	    gzip -d [package].tar.gz | tar xvf -
-	    cd [package]
-	    ./configure
-	    make
-	    make install
-
-   The last step will probably have to be done as root.  Also, if your
-   system needs anything done to update the dynamic loader for shared
-   libraries, (such as running ldconfig on Linux) then do it after
-   each library is installed.
-
-
-
-2. Compile and/or install wxGTK
--------------------------------
-
-A. You can find the sources and RPMs for wxGTK at
-   ftp://wesley.informatik.uni-freiburg.de/pub/linux/wxxt/source/, or
-   just follow the download links from http://wxwindows.org/.  You can
-   also check out a current snapshot of the sources from the CVS
-   server.  (Some information about annonymous CVS access is at
-   http://wxwindows.org/cvs.htm.)  The advantage of using CVS is that
-   you can easily update as soon as the developers check in new
-   sources or fixes.  The advantage of using a released version is
-   that it usually has had more testing done.  You can decide which
-   method is best for you.
-
-B. You'll usually want to use a version of wxGTK that has the same
-   version number as the wxPython sources you are using.  (Another
-   advantage of using CVS is that you'll get both at the same time.)
-
-C. If using the RPMs be sure to get both the wxGTK and wxGTK-devel
-   RPMs (at a minimum) and then install them as root.
-
-	rpm -Uhv wxGTK-2.2.2-0.i386.rpm wxGTK-devel-2.2.2-0.i386.rpm
-
-D. If using the sources (either from the tarball or from CVS) then
-   configure it like this:
-
-	cd wxWindows   # or whatever your top-level directory is called
-	mkdir build
-	cd build
-	../configure --with-gtk
-
-   There are gobs and gobs of options for the configure script, run
-   ../configure --help to see them all.  I'll describe some that I find
-   useful here.
-
-   If you have OpenGL or compatible libraries installed, then add the
-   --with-opengl flag.
-
-   If you are on Solaris and are using a recent version of GCC, then
-   you'll probably want to add the --enable-permissive flag so the
-   compiler won't barf on your broken X11 header files.
-
-   To make a debugging version of wxGTK, add the --enable-debug flag.
-   This sets the -g flag for the compiler and also activates some
-   special debugging code in wxWindows by defining the __WXDEBUG__
-   macro.  You'll get some extra asserts, failure logging, etc.
-
-   To make a static library and not make a shared library, use the
-   --disable-shared and --enable-static flags.
-
-   NOTE: It has been discovered that some pre-built distributions of
-   Python are built with options that can cause incompatibilities
-   between wxPython and wxGTK.  Typically these are things like large
-   file support on the platforms that have it.  This causes some basic
-   types, like off_t, to be typedef'd differently causing the C++
-   method signatures to be incompatible and giving link errors.  The
-   way to fix this is to activate these same settings in the wxGTK
-   build, usually by looking at the flags and options used in
-   compiling wxPython that are different from the options used on
-   wxGTK compiles.  For example, on SuSE doing the following before
-   running wxGTK's configure seems to take care of it:
-
-   export CFLAGS="-D_FILE_OFFSET_BITS=64 -DHAVE_LARGEFILE_SUPPORT"
-   export CXXFLAGS=$CFLAGS
-
-
-E. Now just compile and install.  You need to use GNU make, so if your
-   system has something else get GNU make and build and install it and
-   use it instead of your system's default make command.
-
-       make
-       make install
-
-   The last step will probably have to be done as root.  Also, if your
-   system needs anything done to update the dynamic loader for shared
-   libraries, (such as running ldconfig on Linux) then do it now.
-
-F. You can test your build by changing to one of the directories under
-   build/samples or build/demos, running make and then running the
-   executable that is built.
-
-
-
-3. Compile and install wxPython
--------------------------------
-
-A. You have the same options (and same advantages/disadvantages) for
-   getting the wxPython source, either a released snapshot or from
-   CVS.  The released version file is named wxPython-[version].tar.gz
-   and is available at http://wxpython.org/download.php.  If you want
-   to use CVS you'll find wxPython in the wxWindows CVS tree (see
-   above) in the wxWindows/wxPython directory.
-
-B. As mentioned previouslly, wxPython is built with the standard
-   Python Distutils tool.  If you are using Python 2.0 or later you
-   are all set, otherwise you need to download and install Distutils
-   1.0 from http://www.python.org/sigs/distutils-sig/.
-
-   On Unix systems Distutils figures out what commands and flags to
-   use for the compiler and linker by looking in the Makefile that was
-   used to build Python itself.  Most of the time this works okay.  If
-   it doesn't, there doesn't seem to be a way to override the values
-   that Distutils uses without hacking either Distutils itself, or
-   Python's Makefile.  (Complain to the distutils-sig about this
-   please.)  For example, on a Solaris system I had to edit
-   /usr/local/lib/python1.5/config/Makefile and replace
-
-         LDSHARED=ld -G
-
-   with
-
-         LDSHARED=gcc -G
-
-   This particular problem has been fixed in Python 1.6 and beyond,
-   but there may be similar issues on other platforms.
-
-   While we're on the subject of how Python was built... Since
-   wxPython is a C++ extension some platforms and/or compilers will
-   require that the Python executable was linked with the C++ linker
-   in order for everything to work correctly.  If you build and
-   install Python yourself then this is easy to take care of,
-   otherwise you may have to mess with binary packages or bribe your
-   system administrator...
-
-   In my case on Solaris wxPython applications would core dump on
-   exit.  The core file indicated that the fault happened after
-   _exit() was called and the run-time library was trying to execute
-   cleanup code.  After relinking the Python executable the problem
-   went away.  To build Python to link with the C++ linker do this:
-
-         cd Python-2.0      # wherever the root of the source tree is
-	 rm python          # in case it's still there from an old build
-         make LINKCC=g++    # or whatever your C++ command is
-	 make install
-
-
-C. Change to the root wxPython directory and look at the setup.py
-   file.  This is the script that configures and defines all the
-   information that Distutils needs to build wxPython.  There are some
-   options near the begining of the script that you may want or need
-   to change based on your system and what options you have selected
-   up to this point, (sources from tar.gz or from CVS, etc.)  You can
-   either change these flags directly in setup.py or supply them on
-   the command-line.
-
-	BUILD_GLCANVAS Set to zero if you don't want to build the
-		       Open GL canvas extension module.  If you don't
-		       have OpenGL or compatible libraries then you'll
-		       need to set this to zero.
-
-	     BUILD_OGL Set to zero if you don't want to build the
-		       Object Graphics Library extension module.
-
-  	     BUILD_STC Set to zero if you don't want to build the
-		       wxStyledTextCtrl (the Scintilla wrapper)
-		       extension module.
-
-  	      USE_SWIG If you have edited any of the *.i files you
-		       will need to set this flag to non-zero so SWIG
-		       will be executed to regenerate the wrapper C++
-		       and shadow python files.
-
-	   IN_CVS_TREE If you are using the CVS version of the
-		       wxWindows and wxPython sources then you will
-		       need to set this flag to non-zero.  This is
-		       needed because some source files from the
-		       wxWindows tree are copied to be under the
-		       wxPython tree in order to keep Distutils happy.
-		       With this flag set then setup.py will
-		       automatically keep these copied sources up to
-		       date if the original version is ever updated.
-		       If you are using the tar.gz version of the
-		       Python sources then these copied sources are
-		       already present in your source tree.
-
-
-D. To build and install wxPython you simply need to execute the
-   setup.py script.  If you have more than one version of Python
-   installed, be sure to execute setup.py with the version you want to
-   build wxPython for.  Depending on the permissions on your
-   site-packages directory you may need to be root to run the install
-   command.
-
-	 python setup.py build
-   	 python setup.py install
-
-E. At this point you should be able to change into the wxPython/demo
-   directory and run the demo:
-
-	 python demo.py
-
-F. If you would like to make a test build that doesn't overwrite the
-   installed version of wxPython you can do so with this command
-   instead of the install command above:
-
-	 python setup.py build_ext --inplace
-
-   This will build the wxPython package in the local wxPython
-   directory instead of installing it under your Python installation.
-   To run using this test version just add the base wxPython source
-   directory to the PYTHONPATH:
-
-         export PYTHONPATH=~/projects/wxWindows/wxPython
-	 # or whatever is required for your shell
-	 cd ~/projects/wxWindows/wxPython/demo
-	 python demo.py
-
-
-That's all folks!
-
-
------------------
-robin@alldunn.com

wxPython/BUILD.win32.txt

@@ -1,281 +0,0 @@
-Building wxPython on Win32
---------------------------
-
-
-Building wxPython for use on win32 systems is a fairly simple process
-consisting of just a few steps.  However depending on where you get
-your sources from and what your desired end result is, there are
-several permutations of those steps.  At a high level the basic steps
-are:
-
-     1. Get the wxWindows sources
-     2. Build the wxWindows DLL
-     3. Get the wxPython sources
-     4. Build and Install wxPython
-
-We'll go into more detail of each of these steps below, but first a
-few bits of background information on tools.
-
-I use a tool called SWIG (http://www.swig.org) to help generate the
-C++ sources used in the wxPython extension module.  However you don't
-need to have SWIG unless you want to modify the *.i files.  If you do
-you'll want to have version 1.1-883 of SWIG and you'll need to apply
-the patches and updates in wxPython/SWIG and rebuild it.  Then you'll
-need to change a flag in the setup.py script as described below so the
-wxPython build process will use SWIG if needed.
-
-I use the new Python Distutils tool to build wxPython.  It is included
-with Python 2.0, but if you want to use Python 1.5.2 or 1.6 then
-you'll need to download and install Distutils 1.0 from
-http://www.python.org/sigs/distutils-sig/
-
-I use Microsoft Visual C++ 6.0 (5.0 with the service packs should work
-also) to compile the wxPython C++ sources.  Since I am using Distutils
-it should be easier now to build with other win32 compilers such as
-the free mingw32 or Borland compilers, but I havn't tried them yet.
-If anybody wants to try it I'll take any required patches for the
-setup script and for these instructions.
-
-And now on to the fun stuff...
-
-
-
-1. Get the wxWindows sources
-----------------------------
-
-A. There are a few possible ways to get sources for wxWindows.  You
-   can download a released version from http://wxwindows.org/ or you
-   can get current development sources from the CVS server.  (Some
-   information about annonymous CVS access is at
-   http://wxwindows.org/cvs.htm.)  The advantage of using CVS is that
-   you can easily update as soon as the developers check in new
-   sources or fixes.  The advantage of using a released version is
-   that it usually has had more testing done.  You can decide which
-   method is best for you.
-
-B. You'll usually want to use wxWindows sources that have the same
-   version number as the wxPython sources you are using.  (Another
-   advantage of using CVS is that you'll get both at the same time.)
-
-C. Once you get the sources be sure to put them in a path without a
-   space in it (i.e., NOT c:\Program Files\wx) and set an environment
-   variable named WXWIN to this directory.  For example:
-
-         mkdir \wx2
-         cd \wx2
-         unzip wxMSW-2.2.2.zip
-         set WXWIN=c:\wx2
-
-   You'll probably want to add that last line to your autoexec.bat or
-   System Properties depending on the type of system you are on.
-
-D. Change to the wx2\include\wx\msw directory and copy setup0.h to
-   setup.h and then edit setup.h.  This is how you control which parts
-   of wxWindows are compiled into or left out of the build, simply by
-   turning options on or off.  I have the following differences from
-   the default setup0.h in my setup.h, but you can experiment with
-   other settings if you like:
-
-         wxDIALOG_UNIT_COMPATIBILITY   0
-         wxUSE_GLOBAL_MEMORY_OPERATORS 0
-         wxUSE_DEBUG_NEW_ALWAYS        0
-         wxUSE_CMDLINE_PARSER          0
-         wxUSE_DIALUP_MANAGER          0
-         wxUSE_DYNAMIC_LOADER          0
-         wxUSE_TREELAYOUT              0
-         wxUSE_POSTSCRIPT              1
-
-
-    ** NEW **
-    Be sure that wxUSE_GLCANVAS is defined to be 0 as wxPython now
-    keeps its own copy of the glcanvas sources and expects that it is
-    not in the main library.  This is done to reduce the number of
-    dependant DLLs on the core library and therefore help reduce
-    startup time.
-
-
-
-2. Build the wxWindows DLL
----------------------------
-
-A. Although MSVC project files are provided I always use the makefiles
-   to build wxWindows because by default the flags are compatible with
-   Python, (and I make sure they stay that way.)  You would have to
-   edit the project files a bit to make it work otherwise.
-
-B. There are three different types of wxWindows DLLs that can be
-   produced by the VC makefile simply by providing a flag on the nmake
-   command-line, I call the three types DEBUG, FINAL, and HYBRID.
-   (The last one is brand new, you'll need my version of the 2.2.2
-   sources to get the HYBRID capability.)  Here are some more details:
-
-      DEBUG Specified with "FINAL=0" and produces a DLL named
-            wx[version]d.dll.  This DLL is compiled with full
-            debugging information and with the __WXDEBUG__ set which
-            enables some debugging-only code in wxWindows such as
-            assertions and failure log messages.  The /MDd flag is
-            used which means that it is linked with the debugging
-            version of the C runtime library and also that you must
-            use the debugging version of Python, (python_d.exe and
-            pythonXX_d.dll) which also means that all extensions
-            loaded by Python should also have the _d in the name.
-            With this option you can use the MSVC debugger to trace
-            though the Python interpreter, as well as the code for the
-            wxPython extension and the wxWindows DLL.
-
-      FINAL Specified with "FINAL=1" and produces a DLL named
-            wx[version].dll.  This DLL is compiled with optimizations
-            turned on and without debugging information and without
-            __WXDEBUG__.  The /MD flag is used which means that you
-            can use this version with the standard python.exe.  This
-            is the version that I use when making the binary installer
-            for win32.
-
-     HYBRID Specified with "FINAL=hybrid" and produces a DLL named
-            wx[version]h.dll.  This DLL is almost the same as the
-            DEBUG version except the /MD flag is used which means that
-            you can use the standard python.exe but you still get the
-            debugging info and the __WXDEBUG__ code enabled.  With the
-            debugger you can trace through the the code for the
-            wxPython extension and the wxWindows DLL, but not the
-            Python interpreter.  You might use this version when you
-            want to deploy a wxPython app with the __WXDEBUG__ code
-            enabled.  I use this mode most of the time during
-            development simply because it's easier than having to
-            remember to type python_d all the time.
-
-   Since different DLL names and object file directories are used you
-   can build all three types if you like.
-
-C. Change to the wx2\src\msw directory and type the following command,
-   using the value for FINAL that you want:
-
-         nmake -f makefile.vc dll pch FINAL=hybrid
-
-   Your machine will then crunch away for possibly a long time,
-   depending on your hardware, and when it's done you should have a
-   DLL and some library files in \wx2\lib.
-
-D. You'll either need to add \wx2\lib to the PATH or copy the DLL file
-   to a directory already on the PATH so the DLL can be found at runtime.
-
-E. You can test your build by changing to one of the directories under
-   \wx2\samples or \wx2\demos and typing (using the right FINAL flag):
-
-        nmake -f makefile.vc FINAL=hybrid WXUSINGDLL=1
-
-   and then executing the resulting .exe file.
-
-
-
-3. Get the wxPython sources
----------------------------
-
-A. You have the same options (and same advantages/disadvantages) for
-   getting the wxPython source, either a released snapshot or from
-   CVS.  The released version file is named wxPython-[version].tar.gz
-   and is available at http://wxpython.org/download.php.  You can use
-   WinZip to unpack it if you don't have tar and gzip.  If you want to
-   use CVS you'll find wxPython in the wxWindows CVS tree (see above)
-   in the wxWindows/wxPython directory.
-
-
-
-4. Build and Install wxPython
------------------------------
-
-A. As mentioned previouslly, wxPython is built with the standard
-   Python Distutils tool.  If you are using Python 2.0c1 or later you
-   are all set, otherwise you need to download and install Distutils
-   1.0 from http://www.python.org/sigs/distutils-sig/.
-
-B. Change to the root wxPython directory and look at the setup.py
-   file.  This is the script that configures and defines all the
-   information that Distutils needs to build wxPython.  There are some
-   options near the begining of the script that you may want or need
-   to change based on what options you have selected up to this point,
-   (type of DLL built, sources from tar.gz or from CVS, etc.)  You can
-   either change these flags directly in setup.py or supply them on
-   the command-line.
-
-        BUILD_GLCANVAS Set to zero if you don't want to build the
-                       Open GL canvas extension module.
-
-             BUILD_OGL Set to zero if you don't want to build the
-                       Object Graphics Library extension module.
-
-             BUILD_STC Set to zero if you don't want to build the
-                       wxStyledTextCtrl (the Scintilla wrapper)
-                       extension module.
-
-              USE_SWIG If you have edited any of the *.i files you
-                       will need to set this flag to non-zero so SWIG
-                       will be executed to regenerate the wrapper C++
-                       and shadow python files.
-
-           IN_CVS_TREE If you are using the CVS version of the
-                       wxWindows and wxPython sources then you will
-                       need to set this flag to non-zero.  This is
-                       needed because some source files from the
-                       wxWindows tree are copied to be under the
-                       wxPython tree in order to keep Distutils happy.
-                       With this flag set then setup.py will
-                       automatically keep these copied sources up to
-                       date if the original version is ever updated.
-                       If you are using the tar.gz version of the
-                       Python sources then these copied sources are
-                       already present in your source tree.
-
-
-C. To build and install wxPython you simply need to execute the
-   setup.py script.  If you have more than one version of Python
-   installed, be sure to execute setup.py with the version you want to
-   build wxPython for.
-
-   Depending on what kind of wxWindows DLL you built there are
-   different command-line parameters you'll want to pass to setup (in
-   addition to possibly one or more of the above):
-
-         FINAL:     python setup.py install
-
-         DEBUG:     python setup.py build --debug install
-
-         HYBRID:    python setup.py HYBRID=1 install
-
-   NOTE:  If you get an internal compiler error from MSVC then you
-   need to edit setup.py and add in the /GX- flag that is normally
-   commented out.  Just search for "GX-" and uncomment it so it is put
-   into the cflags list.
-
-
-D. At this point you should be able to change into the wxPython\demo
-   directory and run the demo:
-
-         python demo.py
-
-E. If you would like to make a test build that doesn't overwrite the
-   installed version of wxPython you can do so with one of these
-   commands instead of the install command above:
-
-         FINAL:     python setup.py build_ext --inplace
-
-         DEBUG:     python setup.py build_ext --debug --inplace
-
-         HYBRID:    python setup.py HYBRID=1 build_ext --inplace
-
-   This will build the wxPython package in the local wxPython
-   directory instead of installing it under your Python installation.
-   To run using this test version just add the base wxPython source
-   directory to the PYTHONPATH:
-
-         set PYTHONPATH=c:\wx2\wxPython
-         cd c:\wx2\wxPython\demo
-         python demo.py
-
-
-That's all folks!
-
-
------------------
-robin@alldunn.com
-

wxPython/MANIFEST.in

@@ -1,191 +0,0 @@
-include *.txt
-include my_distutils.py
-## include my_install_data.py
-include licence/*.txt
-include b
-include b.bat
-include MANIFEST.in
-
-include SWIG/*
-exclude SWIG/CVS/*
-
-include demo/*.py
-include demo/bitmaps/*.bmp
-include demo/bitmaps/*.ico
-include demo/bitmaps/*.gif
-include demo/bitmaps/*.png
-include demo/bitmaps/*.jpg
-include demo/bmp_source/*.bmp
-include demo/bmp_source/*.ico
-include demo/bmp_source/*.gif
-include demo/bmp_source/*.png
-include demo/bmp_source/*.jpg
-include demo/*.txt
-include demo/*.xml
-include demo/*.ico
-include demo/data/*.png
-include demo/data/*.htm
-include demo/data/*.html
-include demo/data/*.bmp
-include demo/data/*.txt
-include demo/data/*.i
-include demo/data/*.h
-include demo/data/*.py
-include demo/data/*.wav
-include demo/data/*.wdr
-include demo/data/*.xrc
-include demo/dllwidget/Makefile
-include demo/dllwidget/makefile.*
-include demo/dllwidget/*.cpp
-include demo/dllwidget/*.py
-
-include samples/doodle/*.txt
-include samples/doodle/*.py
-include samples/doodle/*.iss
-include samples/doodle/sample.ddl
-include samples/stxview/*.txt
-include samples/stxview/*.py
-include samples/stxview/*.stx
-include samples/stxview/StructuredText/*.py
-include samples/stxview/StructuredText/*.txt
-include samples/wxProject/*.txt
-include samples/wxProject/*.py
-include samples/StyleEditor/*.py
-include samples/StyleEditor/*.txt
-include samples/StyleEditor/*.cfg
-include samples/pySketch/*.py
-include samples/pySketch/images/*.bmp
-include samples/frogedit/*.py
-
-
-include wxPython/lib/*.py
-include wxPython/lib/*.txt
-include wxPython/lib/editor/*.py
-include wxPython/lib/editor/*.txt
-include wxPython/lib/mixins/*.py
-include wxPython/lib/PyCrust/*.py
-include wxPython/lib/PyCrust/*.txt
-include wxPython/lib/PyCrust/*.ico
-
-exclude wxPython/*
-exclude tests
-
-include src/*.i
-include src/*.py
-include src/*.cpp
-include src/*.c
-include src/*.h
-include src/*.ico
-include src/*.rc
-include src/wxc.pyd.manifest
-
-include src/msw/*.cpp
-include src/msw/*.h
-include src/msw/*.py
-
-include src/gtk/*.cpp
-include src/gtk/*.h
-include src/gtk/*.py
-
-include src/mac/*.cpp
-include src/mac/*.h
-include src/mac/*.py
-
-include tools/*.py
-include tools/XRCed/CHANGES
-include tools/XRCed/TODO
-include tools/XRCed/README
-include tools/XRCed/*.py
-include tools/XRCed/*.xrc
-include tools/XRCed/*.ico
-
-include contrib/glcanvas/*.i
-include contrib/glcanvas/*.py
-include contrib/glcanvas/*.cpp
-include contrib/glcanvas/*.c
-include contrib/glcanvas/*.h
-include contrib/glcanvas/msw/*.cpp
-include contrib/glcanvas/msw/*.h
-include contrib/glcanvas/msw/*.py
-include contrib/glcanvas/gtk/*.cpp
-include contrib/glcanvas/gtk/*.h
-include contrib/glcanvas/gtk/*.py
-include contrib/glcanvas/mac/*.cpp
-include contrib/glcanvas/mac/*.h
-include contrib/glcanvas/mac/*.py
-
-include contrib/ogl/*.txt
-include contrib/ogl/*.i
-include contrib/ogl/*.py
-include contrib/ogl/*.cpp
-include contrib/ogl/*.c
-include contrib/ogl/*.h
-include contrib/ogl/contrib/include/wx/ogl/*.h
-include contrib/ogl/contrib/src/ogl/*.cpp
-
-include contrib/stc/*.txt
-include contrib/stc/*.i
-include contrib/stc/*.py
-include contrib/stc/*.cpp
-include contrib/stc/*.c
-include contrib/stc/msw/*.h
-include contrib/stc/msw/*.cpp
-include contrib/stc/msw/*.py
-include contrib/stc/gtk/*.h
-include contrib/stc/gtk/*.cpp
-include contrib/stc/gtk/*.py
-include contrib/stc/mac/*.h
-include contrib/stc/mac/*.cpp
-include contrib/stc/mac/*.py
-include contrib/stc/contrib/include/wx/stc/*.h
-include contrib/stc/contrib/src/stc/*.h
-include contrib/stc/contrib/src/stc/*.cpp
-include contrib/stc/contrib/src/stc/*.txt
-include contrib/stc/contrib/src/stc/*.py
-include contrib/stc/contrib/src/stc/stc.*.in
-include contrib/stc/contrib/src/stc/scintilla/include/*.h
-include contrib/stc/contrib/src/stc/scintilla/include/*.iface
-include contrib/stc/contrib/src/stc/scintilla/src/*.h
-include contrib/stc/contrib/src/stc/scintilla/src/*.cxx
-include contrib/stc/contrib/src/stc/scintilla/*.txt
-
-include contrib/xrc/*.txt
-include contrib/xrc/*.i
-include contrib/xrc/*.py
-include contrib/xrc/*.cpp
-include contrib/xrc/*.c
-include contrib/xrc/*.h
-include contrib/xrc/contrib/include/wx/xrc/*.h
-include contrib/xrc/contrib/src/xrc/*.cpp
-include contrib/xrc/contrib/src/xrc/*.txt
-include contrib/xrc/contrib/src/xrc/README.EXPAT
-include contrib/xrc/contrib/src/xrc/expat/*.txt
-include contrib/xrc/contrib/src/xrc/expat/xmlparse/*.c
-include contrib/xrc/contrib/src/xrc/expat/xmlparse/*.h
-include contrib/xrc/contrib/src/xrc/expat/xmltok/*.c
-include contrib/xrc/contrib/src/xrc/expat/xmltok/*.h
-
-include contrib/gizmos/*.txt
-include contrib/gizmos/*.i
-include contrib/gizmos/*.py
-include contrib/gizmos/*.cpp
-include contrib/gizmos/*.c
-include contrib/gizmos/*.h
-include contrib/gizmos/contrib/include/wx/gizmos/*.h
-include contrib/gizmos/contrib/src/gizmos/*.cpp
-include contrib/gizmos/contrib/src/gizmos/*.xpm
-include contrib/gizmos/contrib/src/gizmos/*.txt
-
-include contrib/dllwidget/*.txt
-include contrib/dllwidget/*.i
-include contrib/dllwidget/*.py
-include contrib/dllwidget/*.cpp
-include contrib/dllwidget/*.c
-include contrib/dllwidget/*.h
-
-include demo/dllwidget/*.h
-include demo/dllwidget/*.cpp
-include demo/dllwidget/*.py
-include demo/dllwidget/Makefile
-include demo/dllwidget/makefile.*
-

wxPython/README.txt

@@ -1,88 +0,0 @@
-wxPython README
----------------
-
-Welcome to the wonderful world of wxPython!
-
-Once you have installed the wxPython extension module, you can try it
-out by going to the [install dir]\wxPython\demo directory and typing:
-
-    python demo.py
-
-There are also some other sample files there for you to play with and
-learn from.
-
-If you selected to install the documentation then point your browser
-to [install dir]\wxPython\docs\index.htm and you will then be looking
-at the docs for wxWindows.  For the most part you can use the C++ docs
-as most classes and methods are used identically.  Where there are
-differences they are documented with a "wxPython Note."
-
-On Win32 systems the binary self-installer creates a program group on
-the Start Menu that contains a link to running the demo and a link to
-the help file.  To help you save disk space I'm now using Microsoft's
-HTML Help format.  If your system doesn't know what to do with the help
-file, you can install the HTML Help Viewer as part of IE 4+, NT
-Service Pack 4+, or the HTML Workshop at
-
-http://msdn.microsoft.com/library/default.asp?url=/library/en-us/htmlhelp/html/hwMicrosoftHTMLHelpDownloads.asp
-
-For some features, the latest common controls library from microsoft
-is required.  You can get this by installing IE 5.0 or Office 2000.
-You can also get it independently from here:
-
-http://download.microsoft.com/download/platformsdk/Comctl32/5.80.2614.3600/W9XNT4/EN-US/50comupd.exe
-
-Windows 95 users may also need the WinSock 2.0 and OpenGL libraries.
-These can be found at these sites:
-
-
-http://www.microsoft.com/windows95/downloads/contents/wuadmintools/s_wunetworkingtools/w95sockets2/default.asp
-
-http://www.opengl.org/Downloads/Downloads.html
-
-
-
-Getting Help
-------------
-
-Since wxPython is a blending of multiple technologies, help comes from
-multiple sources.  See the http://wxPython.org/ for details on various
-sources of help, but probably the best source is the wxPython-users
-mail list.  You can view the archive or subscribe by going to
-
-       http://lists.wxwindows.org/mailman/listinfo/wxpython-users
-
-Or you can send mail directly to the list using this address:
-
-       wxpython-users@lists.wxwindows.org
-
-
-Other Info
-----------
-
-Please also see the following files in this directory:
-
-       CHANGES.txt     Information about new features, fixes, etc. in
-                       each release.
-
-       BUILD.unix.txt  Instructions for building wxPython on various
-		       Unix-like platforms.
-
-       BUILD.win32.txt Instructions for building wxPython on Windows.
-
-       licence/*       Text of the wxWindows license.
-
-
-
------------------
-Robin Dunn
-robin@alldunn.com
-
-
-
-
-
-
-
-
-

wxPython/SWIG/README.txt

@@ -1,21 +0,0 @@
-
-Some minor tweaks were made to pyexp.swg and typemaps.i to allow
-wxPython to build with Python 1.6.  Just put these in your
-swig_lib/python dir and you'll be all set.  These are from SWIG
-1.1-883.
-
-
-Additionally, there are some patches for SWIG sources that are needed
-for wxPython:
-
-    1. python.cxx.patch, applied to .../Modules/python.cxx file will
-       prevent the out typemap from being used on constructors.
-
-    2. cplus.cxx.patch, applied to .../SWIG/cplus.cxx will prevent
-       some redundant code from being emitted to the extension
-       module.
-
-    3. pycpp.cxx.patch, applied to .../Modules/pycpp.cxx will add
-       support for the addtomethod pragma for renamed constructors.
-
-

wxPython/SWIG/cplus.cxx.patch

@@ -1,37 +0,0 @@
-*** SWIG\cplus.cxx.orig	Fri May 18 13:03:34 2001
---- SWIG\cplus.cxx	Fri May 18 13:07:42 2001
-***************
-*** 839,845 ****
-  
-    if (name) {
-      if (strlen(name)) {
-!       if (strlen(ctype) > 0) {
-  	sprintf(temp,"%s %s", ctype, name);
-  	typeeq_derived(temp,name);       // Map "struct foo" to "foo"
-  	typeeq_derived(name,temp);       // Map "foo" to "struct foo"
---- 839,845 ----
-  
-    if (name) {
-      if (strlen(name)) {
-!       if (strlen(ctype) > 0 && strcmp(ctype, "class") != 0) {
-  	sprintf(temp,"%s %s", ctype, name);
-  	typeeq_derived(temp,name);       // Map "struct foo" to "foo"
-  	typeeq_derived(name,temp);       // Map "foo" to "struct foo"
-***************
-*** 1092,1098 ****
-  
-        // Make a type-equivalence allowing derived classes to be used in functions of the
-  
-!       if (strlen(current_class->classtype) > 0) {
-  	temp1 = "";
-  	temp1 << current_class->classtype << " " << current_class->classname;
-  	temp2 = "";
---- 1092,1099 ----
-  
-        // Make a type-equivalence allowing derived classes to be used in functions of the
-  
-!       if (strlen(current_class->classtype) > 0 &&
-!           strcmp(current_class->classtype, "class") != 0) {
-  	temp1 = "";
-  	temp1 << current_class->classtype << " " << current_class->classname;
-  	temp2 = "";

wxPython/SWIG/pycpp.cxx.patch

@@ -1,22 +0,0 @@
-*** Modules/pycpp.cxx.orig	Fri Oct 12 16:37:36 2001
---- Modules/pycpp.cxx	Fri Oct 12 16:38:20 2001
-***************
-*** 228,235 ****
-        *additional << "def " << realname << "(*_args,**_kwargs):\n";
-        *additional << tab4 << "val = " << class_name << "Ptr(apply("
-  		  << module << "." << name_construct(realname) << ",_args,_kwargs))\n"
-!                   << tab4 << "val.thisown = 1\n"
-! 		  << tab4 << "return val\n\n";
-      }
-      // Patch up the documentation entry
-      if (doc_entry) {
---- 228,236 ----
-        *additional << "def " << realname << "(*_args,**_kwargs):\n";
-        *additional << tab4 << "val = " << class_name << "Ptr(apply("
-  		  << module << "." << name_construct(realname) << ",_args,_kwargs))\n"
-!                   << tab4 << "val.thisown = 1\n";
-!       emitAddPragmas(*additional, realname, tab4);
-!       *additional << tab4 << "return val\n\n";
-      }
-      // Patch up the documentation entry
-      if (doc_entry) {

wxPython/SWIG/pyexp.swg

@@ -1,32 +0,0 @@
-#include <string.h>
-#include <stdlib.h>
-/* Definitions for Windows/Unix exporting */
-#if defined(__WIN32__)
-#   if defined(_MSC_VER)
-#	define SWIGEXPORT(a) __declspec(dllexport) a
-#   else
-#	if defined(__BORLANDC__)
-#	    define SWIGEXPORT(a) a _export
-#	else
-#	    define SWIGEXPORT(a) a
-#	endif
-#   endif
-#else
-#   define SWIGEXPORT(a) a
-#endif
-
-#include "Python.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-extern void SWIG_MakePtr(char *, void *, char *);
-extern void SWIG_RegisterMapping(char *, char *, void *(*)(void *));
-extern char *SWIG_GetPtr(char *, void **, char *);
-extern char *SWIG_GetPtrObj(PyObject *, void **, char *);
-extern void SWIG_addvarlink(PyObject *, char *, PyObject *(*)(void), int (*)(PyObject *));
-extern PyObject *SWIG_newvarlink(void);
-#ifdef __cplusplus
-}
-#endif

wxPython/SWIG/python.cxx.patch

@@ -1,20 +0,0 @@
-*** Modules\python.cxx.orig	Fri May 11 16:04:01 2001
---- Modules\python.cxx	Fri May 11 16:14:08 2001
-***************
-*** 879,885 ****
-    // If there was a result, it was saved in _result.
-    // If the function is a void type, don't do anything.
-  
-!   if ((tm = typemap_lookup("out","python",d,iname,"_result","_resultobj"))) {
-      // Yep.  Use it instead of the default
-      f.code << tm << "\n";
-    } else {
---- 879,886 ----
-    // If there was a result, it was saved in _result.
-    // If the function is a void type, don't do anything.
-  
-!   if ((strncmp(name, "new_", 4) != 0) &&  // don't use the out typemap for constructors
-!       (tm = typemap_lookup("out","python",d,iname,"_result","_resultobj"))) {
-      // Yep.  Use it instead of the default
-      f.code << tm << "\n";
-    } else {

wxPython/SWIG/typemaps.i

@@ -1,564 +0,0 @@
-//
-// SWIG Typemap library
-// Dave Beazley
-// May 5, 1997
-//
-// Python implementation
-//
-// This library provides standard typemaps for modifying SWIG's behavior.
-// With enough entries in this file, I hope that very few people actually
-// ever need to write a typemap.
-//
-// Disclaimer : Unless you really understand how typemaps work, this file
-// probably isn't going to make much sense.
-//
-#ifdef AUTODOC
-%section "Typemap Library (Python)",info,after,pre,nosort,skip=1,chop_left=3,chop_right=0,chop_top=0,chop_bottom=0
-%text %{
-%include typemaps.i
-
-The SWIG typemap library provides a language independent mechanism for
-supporting output arguments, input values, and other C function
-calling mechanisms.  The primary use of the library is to provide a
-better interface to certain C function--especially those involving
-pointers.
-%}
-
-#endif
-
-// ------------------------------------------------------------------------
-// Pointer handling
-//
-// These mappings provide support for input/output arguments and common
-// uses for C/C++ pointers.
-// ------------------------------------------------------------------------
-
-// INPUT typemaps.
-// These remap a C pointer to be an "INPUT" value which is passed by value
-// instead of reference.
-
-
-#ifdef AUTODOC
-%subsection "Input Methods"
-
-%text %{
-The following methods can be applied to turn a pointer into a simple
-"input" value.  That is, instead of passing a pointer to an object,
-you would use a real value instead.
-
-         int            *INPUT
-         short          *INPUT
-         long           *INPUT
-         unsigned int   *INPUT
-         unsigned short *INPUT
-         unsigned long  *INPUT
-         unsigned char  *INPUT
-         float          *INPUT
-         double         *INPUT
-
-To use these, suppose you had a C function like this :
-
-        double fadd(double *a, double *b) {
-               return *a+*b;
-        }
-
-You could wrap it with SWIG as follows :
-
-        %include typemaps.i
-        double fadd(double *INPUT, double *INPUT);
-
-or you can use the %apply directive :
-
-        %include typemaps.i
-        %apply double *INPUT { double *a, double *b };
-        double fadd(double *a, double *b);
-
-%}
-#endif
-
-%typemap(python,in) double *INPUT(double temp)
-{
-  temp = PyFloat_AsDouble($source);
-  $target = &temp;
-}
-
-%typemap(python,in) float  *INPUT(float temp)
-{
-  temp = (float) PyFloat_AsDouble($source);
-  $target = &temp;
-}
-
-%typemap(python,in) int            *INPUT(int temp)
-{
-  temp = (int) PyInt_AsLong($source);
-  $target = &temp;
-}
-
-%typemap(python,in) short          *INPUT(short temp)
-{
-  temp = (short) PyInt_AsLong($source);
-  $target = &temp;
-}
-
-%typemap(python,in) long           *INPUT(long temp)
-{
-  temp = (long) PyInt_AsLong($source);
-  $target = &temp;
-}
-%typemap(python,in) unsigned int   *INPUT(unsigned int temp)
-{
-  temp = (unsigned int) PyInt_AsLong($source);
-  $target = &temp;
-}
-%typemap(python,in) unsigned short *INPUT(unsigned short temp)
-{
-  temp = (unsigned short) PyInt_AsLong($source);
-  $target = &temp;
-}
-%typemap(python,in) unsigned long  *INPUT(unsigned long temp)
-{
-  temp = (unsigned long) PyInt_AsLong($source);
-  $target = &temp;
-}
-%typemap(python,in) unsigned char  *INPUT(unsigned char temp)
-{
-  temp = (unsigned char) PyInt_AsLong($source);
-  $target = &temp;
-}
-
-%typemap(python,in) signed char  *INPUT(signed char temp)
-{
-  temp = (unsigned char) PyInt_AsLong($source);
-  $target = &temp;
-}
-
-// OUTPUT typemaps.   These typemaps are used for parameters that
-// are output only.   The output value is appended to the result as
-// a list element.
-
-#ifdef AUTODOC
-%subsection "Output Methods"
-
-%text %{
-The following methods can be applied to turn a pointer into an "output"
-value.  When calling a function, no input value would be given for
-a parameter, but an output value would be returned.  In the case of
-multiple output values, they are returned in the form of a Python tuple.
-
-         int            *OUTPUT
-         short          *OUTPUT
-         long           *OUTPUT
-         unsigned int   *OUTPUT
-         unsigned short *OUTPUT
-         unsigned long  *OUTPUT
-         unsigned char  *OUTPUT
-         float          *OUTPUT
-         double         *OUTPUT
-
-A Python List can also be returned by using L_OUTPUT instead of OUTPUT.
-
-For example, suppose you were trying to wrap the modf() function in the
-C math library which splits x into integral and fractional parts (and
-returns the integer part in one of its parameters).K:
-
-        double modf(double x, double *ip);
-
-You could wrap it with SWIG as follows :
-
-        %include typemaps.i
-        double modf(double x, double *OUTPUT);
-
-or you can use the %apply directive :
-
-        %include typemaps.i
-        %apply double *OUTPUT { double *ip };
-        double modf(double x, double *ip);
-
-The Python output of the function would be a tuple containing both
-output values.
-%}
-#endif
-
-
-// I don't use this anywhere, get rid of it...
-
-// Helper function for List output
-//  static PyObject* l_output_helper(PyObject* target, PyObject* o) {
-//      PyObject*   o2;
-//      if (!target) {
-//          target = o;
-//      } else if (target == Py_None) {
-//          Py_DECREF(Py_None);
-//          target = o;
-//      } else {
-//          if (!PyList_Check(target)) {
-//              o2 = target;
-//              target = PyList_New(0);
-//              PyList_Append(target, o2);
-//  	    Py_XDECREF(o2);
-//          }
-//          PyList_Append(target,o);
-//  	Py_XDECREF(o);
-//      }
-//      return target;
-//  }
-
-%{
-%}
-
-// Force the argument to be ignored.
-
-%typemap(python,ignore) int            *L_OUTPUT(int temp),
-                        short          *L_OUTPUT(short temp),
-                        long           *L_OUTPUT(long temp),
-                        unsigned int   *L_OUTPUT(unsigned int temp),
-                        unsigned short *L_OUTPUT(unsigned short temp),
-                        unsigned long  *L_OUTPUT(unsigned long temp),
-                        unsigned char  *L_OUTPUT(unsigned char temp),
-                        signed char    *L_OUTPUT(signed char temp),
-                        float          *L_OUTPUT(float temp),
-                        double         *L_OUTPUT(double temp)
-{
-  $target = &temp;
-}
-
-%typemap(python,argout) int            *L_OUTPUT,
-                        short          *L_OUTPUT,
-                        long           *L_OUTPUT,
-                        unsigned int   *L_OUTPUT,
-                        unsigned short *L_OUTPUT,
-                        unsigned long  *L_OUTPUT,
-                        unsigned char  *L_OUTPUT,
-                        signed char    *L_OUTPUT
-{
-    PyObject *o;
-    o = PyInt_FromLong((long) (*$source));
-    l_output_helper($target,o);
-}
-
-%typemap(python,argout) float    *L_OUTPUT,
-                        double   *L_OUTPUT
-{
-    PyObject *o;
-    o = PyFloat_FromDouble((double) (*$source));
-    $target = l_output_helper($target,o);
-}
-
-// These typemaps contributed by Robin Dunn
-//----------------------------------------------------------------------
-//
-// T_OUTPUT typemap (and helper function) to return multiple argouts as
-// a tuple instead of a list.
-//
-// Author: Robin Dunn
-//----------------------------------------------------------------------
-
-%{
-static PyObject* t_output_helper(PyObject* target, PyObject* o) {
-    PyObject*   o2;
-    PyObject*   o3;
-
-    if (!target) {
-        target = o;
-    } else if (target == Py_None) {
-        Py_DECREF(Py_None);
-        target = o;
-    } else {
-        if (!PyTuple_Check(target)) {
-            o2 = target;
-            target = PyTuple_New(1);
-            PyTuple_SetItem(target, 0, o2);
-        }
-        o3 = PyTuple_New(1);
-        PyTuple_SetItem(o3, 0, o);
-
-        o2 = target;
-        target = PySequence_Concat(o2, o3);
-        Py_DECREF(o2);
-        Py_DECREF(o3);
-    }
-    return target;
-}
-%}
-
-// Force the argument to be ignored.
-%typemap(python,ignore) int            *T_OUTPUT(int temp),
-                        short          *T_OUTPUT(short temp),
-                        long           *T_OUTPUT(long temp),
-                        unsigned int   *T_OUTPUT(unsigned int temp),
-                        unsigned short *T_OUTPUT(unsigned short temp),
-                        unsigned long  *T_OUTPUT(unsigned long temp),
-                        unsigned char  *T_OUTPUT(unsigned char temp),
-                        float          *T_OUTPUT(float temp),
-                        double         *T_OUTPUT(double temp)
-{
-  $target = &temp;
-}
-
-%typemap(python,argout) int            *T_OUTPUT,
-                        short          *T_OUTPUT,
-                        long           *T_OUTPUT,
-                        unsigned int   *T_OUTPUT,
-                        unsigned short *T_OUTPUT,
-                        unsigned long  *T_OUTPUT,
-                        unsigned char  *T_OUTPUT
-{
-    PyObject *o;
-    o = PyInt_FromLong((long) (*$source));
-    $target = t_output_helper($target, o);
-}
-
-%typemap(python,argout) float    *T_OUTPUT,
-                        double   *T_OUTPUT
-{
-    PyObject *o;
-    o = PyFloat_FromDouble((double) (*$source));
-    $target = t_output_helper($target, o);
-}
-
-// Set the default output typemap
-
-#ifdef OUTPUT_LIST
-%typemap(python,ignore) int                *OUTPUT = int   *L_OUTPUT;
-%typemap(python,ignore) short              *OUTPUT = short *L_OUTPUT;
-%typemap(python,ignore) long               *OUTPUT = long  *L_OUTPUT;
-%typemap(python,ignore) unsigned           *OUTPUT = unsigned *L_OUTPUT;
-%typemap(python,ignore) unsigned short     *OUTPUT = unsigned short *L_OUTPUT;
-%typemap(python,ignore) unsigned long      *OUTPUT = unsigned long  *L_OUTPUT;
-%typemap(python,ignore) unsigned char      *OUTPUT = unsigned char  *L_OUTPUT;
-%typemap(python,ignore) signed char        *OUTPUT = signed char    *L_OUTPUT;
-%typemap(python,ignore) double             *OUTPUT = double         *L_OUTPUT;
-%typemap(python,ignore) float              *OUTPUT = float          *L_OUTPUT;
-
-%typemap(python,argout) int                *OUTPUT = int   *L_OUTPUT;
-%typemap(python,argout) short              *OUTPUT = short *L_OUTPUT;
-%typemap(python,argout) long               *OUTPUT = long  *L_OUTPUT;
-%typemap(python,argout) unsigned           *OUTPUT = unsigned *L_OUTPUT;
-%typemap(python,argout) unsigned short     *OUTPUT = unsigned short *L_OUTPUT;
-%typemap(python,argout) unsigned long      *OUTPUT = unsigned long  *L_OUTPUT;
-%typemap(python,argout) unsigned char      *OUTPUT = unsigned char  *L_OUTPUT;
-%typemap(python,argout) signed char        *OUTPUT = signed char    *L_OUTPUT;
-%typemap(python,argout) double             *OUTPUT = double         *L_OUTPUT;
-%typemap(python,argout) float              *OUTPUT = float          *L_OUTPUT;
-#else
-%typemap(python,ignore) int                *OUTPUT = int   *T_OUTPUT;
-%typemap(python,ignore) short              *OUTPUT = short *T_OUTPUT;
-%typemap(python,ignore) long               *OUTPUT = long  *T_OUTPUT;
-%typemap(python,ignore) unsigned           *OUTPUT = unsigned *T_OUTPUT;
-%typemap(python,ignore) unsigned short     *OUTPUT = unsigned short *T_OUTPUT;
-%typemap(python,ignore) unsigned long      *OUTPUT = unsigned long  *T_OUTPUT;
-%typemap(python,ignore) unsigned char      *OUTPUT = unsigned char  *T_OUTPUT;
-%typemap(python,ignore) signed char        *OUTPUT = signed char    *T_OUTPUT;
-%typemap(python,ignore) double             *OUTPUT = double         *T_OUTPUT;
-%typemap(python,ignore) float              *OUTPUT = float          *T_OUTPUT;
-
-%typemap(python,argout) int                *OUTPUT = int   *T_OUTPUT;
-%typemap(python,argout) short              *OUTPUT = short *T_OUTPUT;
-%typemap(python,argout) long               *OUTPUT = long  *T_OUTPUT;
-%typemap(python,argout) unsigned           *OUTPUT = unsigned *T_OUTPUT;
-%typemap(python,argout) unsigned short     *OUTPUT = unsigned short *T_OUTPUT;
-%typemap(python,argout) unsigned long      *OUTPUT = unsigned long  *T_OUTPUT;
-%typemap(python,argout) unsigned char      *OUTPUT = unsigned char  *T_OUTPUT;
-%typemap(python,argout) signed char        *OUTPUT = signed char    *T_OUTPUT;
-%typemap(python,argout) double             *OUTPUT = double         *T_OUTPUT;
-%typemap(python,argout) float              *OUTPUT = float          *T_OUTPUT;
-#endif
-
-// INOUT
-// Mappings for an argument that is both an input and output
-// parameter
-
-
-#ifdef AUTODOC
-%subsection "Input/Output Methods"
-
-%text %{
-The following methods can be applied to make a function parameter both
-an input and output value.  This combines the behavior of both the
-"INPUT" and "OUTPUT" methods described earlier.  Output values are
-returned in the form of a Python tuple.  To return a Python list,
-using L_INOUT instead.
-
-         int            *INOUT
-         short          *INOUT
-         long           *INOUT
-         unsigned int   *INOUT
-         unsigned short *INOUT
-         unsigned long  *INOUT
-         unsigned char  *INOUT
-         float          *INOUT
-         double         *INOUT
-
-For example, suppose you were trying to wrap the following function :
-
-        void neg(double *x) {
-             *x = -(*x);
-        }
-
-You could wrap it with SWIG as follows :
-
-        %include typemaps.i
-        void neg(double *INOUT);
-
-or you can use the %apply directive :
-
-        %include typemaps.i
-        %apply double *INOUT { double *x };
-        void neg(double *x);
-
-Unlike C, this mapping does not directly modify the input value (since
-this makes no sense in Python).  Rather, the modified input value shows
-up as the return value of the function.  Thus, to apply this function
-to a Python variable you might do this :
-
-       x = neg(x)
-
-Note : previous versions of SWIG used the symbol 'BOTH' to mark
-input/output arguments.   This is still supported, but will be slowly
-phased out in future releases.
-%}
-
-#endif
-
-%typemap(python,in) int *INOUT = int *INPUT;
-%typemap(python,in) short *INOUT = short *INPUT;
-%typemap(python,in) long *INOUT = long *INPUT;
-%typemap(python,in) unsigned *INOUT = unsigned *INPUT;
-%typemap(python,in) unsigned short *INOUT = unsigned short *INPUT;
-%typemap(python,in) unsigned long *INOUT = unsigned long *INPUT;
-%typemap(python,in) unsigned char *INOUT = unsigned char *INPUT;
-%typemap(python,in) float *INOUT = float *INPUT;
-%typemap(python,in) double *INOUT = double *INPUT;
-
-%typemap(python,argout) int *INOUT = int *OUTPUT;
-%typemap(python,argout) short *INOUT = short *OUTPUT;
-%typemap(python,argout) long *INOUT = long *OUTPUT;
-%typemap(python,argout) unsigned *INOUT = unsigned *OUTPUT;
-%typemap(python,argout) unsigned short *INOUT = unsigned short *OUTPUT;
-%typemap(python,argout) unsigned long *INOUT = unsigned long *OUTPUT;
-%typemap(python,argout) unsigned char *INOUT = unsigned char *OUTPUT;
-%typemap(python,argout) float *INOUT = float *OUTPUT;
-%typemap(python,argout) double *INOUT = double *OUTPUT;
-
-%typemap(python,in) int *T_INOUT = int *INPUT;
-%typemap(python,in) short *T_INOUT = short *INPUT;
-%typemap(python,in) long *T_INOUT = long *INPUT;
-%typemap(python,in) unsigned *T_INOUT = unsigned *INPUT;
-%typemap(python,in) unsigned short *T_INOUT = unsigned short *INPUT;
-%typemap(python,in) unsigned long *T_INOUT = unsigned long *INPUT;
-%typemap(python,in) unsigned char *T_INOUT = unsigned char *INPUT;
-%typemap(python,in) float *T_INOUT = float *INPUT;
-%typemap(python,in) double *T_INOUT = double *INPUT;
-
-%typemap(python,argout) int *T_INOUT = int *T_OUTPUT;
-%typemap(python,argout) short *T_INOUT = short *T_OUTPUT;
-%typemap(python,argout) long *T_INOUT = long *T_OUTPUT;
-%typemap(python,argout) unsigned *T_INOUT = unsigned *T_OUTPUT;
-%typemap(python,argout) unsigned short *T_INOUT = unsigned short *T_OUTPUT;
-%typemap(python,argout) unsigned long *T_INOUT = unsigned long *T_OUTPUT;
-%typemap(python,argout) unsigned char *T_INOUT = unsigned char *T_OUTPUT;
-%typemap(python,argout) float *T_INOUT = float *T_OUTPUT;
-%typemap(python,argout) double *T_INOUT = double *T_OUTPUT;
-
-%typemap(python,in) int *L_INOUT = int *INPUT;
-%typemap(python,in) short *L_INOUT = short *INPUT;
-%typemap(python,in) long *L_INOUT = long *INPUT;
-%typemap(python,in) unsigned *L_INOUT = unsigned *INPUT;
-%typemap(python,in) unsigned short *L_INOUT = unsigned short *INPUT;
-%typemap(python,in) unsigned long *L_INOUT = unsigned long *INPUT;
-%typemap(python,in) unsigned char *L_INOUT = unsigned char *INPUT;
-%typemap(python,in) float *L_INOUT = float *INPUT;
-%typemap(python,in) double *L_INOUT = double *INPUT;
-
-%typemap(python,argout) int *L_INOUT = int *L_OUTPUT;
-%typemap(python,argout) short *L_INOUT = short *L_OUTPUT;
-%typemap(python,argout) long *L_INOUT = long *L_OUTPUT;
-%typemap(python,argout) unsigned *L_INOUT = unsigned *L_OUTPUT;
-%typemap(python,argout) unsigned short *L_INOUT = unsigned short *L_OUTPUT;
-%typemap(python,argout) unsigned long *L_INOUT = unsigned long *L_OUTPUT;
-%typemap(python,argout) unsigned char *L_INOUT = unsigned char *L_OUTPUT;
-%typemap(python,argout) float *L_INOUT = float *L_OUTPUT;
-%typemap(python,argout) double *L_INOUT = double *L_OUTPUT;
-
-// Backwards compatibility
-
-%typemap(python,in) int *BOTH = int *INOUT;
-%typemap(python,in) short *BOTH = short *INOUT;
-%typemap(python,in) long *BOTH = long *INOUT;
-%typemap(python,in) unsigned *BOTH = unsigned *INOUT;
-%typemap(python,in) unsigned short *BOTH = unsigned short *INOUT;
-%typemap(python,in) unsigned long *BOTH = unsigned long *INOUT;
-%typemap(python,in) unsigned char *BOTH = unsigned char *INOUT;
-%typemap(python,in) float *BOTH = float *INOUT;
-%typemap(python,in) double *BOTH = double *INOUT;
-
-%typemap(python,argout) int *BOTH = int *INOUT;
-%typemap(python,argout) short *BOTH = short *INOUT;
-%typemap(python,argout) long *BOTH = long *INOUT;
-%typemap(python,argout) unsigned *BOTH = unsigned *INOUT;
-%typemap(python,argout) unsigned short *BOTH = unsigned short *INOUT;
-%typemap(python,argout) unsigned long *BOTH = unsigned long *INOUT;
-%typemap(python,argout) unsigned char *BOTH = unsigned char *INOUT;
-%typemap(python,argout) float *BOTH = float *INOUT;
-%typemap(python,argout) double *BOTH = double *INOUT;
-
-%typemap(python,in) int *T_BOTH = int *T_INOUT;
-%typemap(python,in) short *T_BOTH = short *T_INOUT;
-%typemap(python,in) long *T_BOTH = long *T_INOUT;
-%typemap(python,in) unsigned *T_BOTH = unsigned *T_INOUT;
-%typemap(python,in) unsigned short *T_BOTH = unsigned short *T_INOUT;
-%typemap(python,in) unsigned long *T_BOTH = unsigned long *T_INOUT;
-%typemap(python,in) unsigned char *T_BOTH = unsigned char *T_INOUT;
-%typemap(python,in) float *T_BOTH = float *T_INOUT;
-%typemap(python,in) double *T_BOTH = double *T_INOUT;
-
-%typemap(python,argout) int *T_BOTH = int *T_INOUT;
-%typemap(python,argout) short *T_BOTH = short *T_INOUT;
-%typemap(python,argout) long *T_BOTH = long *T_INOUT;
-%typemap(python,argout) unsigned *T_BOTH = unsigned *T_INOUT;
-%typemap(python,argout) unsigned short *T_BOTH = unsigned short *T_INOUT;
-%typemap(python,argout) unsigned long *T_BOTH = unsigned long *T_INOUT;
-%typemap(python,argout) unsigned char *T_BOTH = unsigned char *T_INOUT;
-%typemap(python,argout) float *T_BOTH = float *T_INOUT;
-%typemap(python,argout) double *T_BOTH = double *T_INOUT;
-
-// --------------------------------------------------------------------
-// Special types
-//
-// --------------------------------------------------------------------
-
-#ifdef AUTODOC
-%subsection "Special Methods"
-
-%text %{
-The typemaps.i library also provides the following mappings :
-
-PyObject *
-
-      When a PyObject * appears as either an input value or return
-      value of a function, SWIG passes it through unmodified.  Thus,
-      if you want to write a C function that operates on PyObjects,
-      it is easy to write.  For example :
-
-           %include typemaps.i
-           PyObject *spam(PyObject *obj1, int n);
-
-      Unlike normal Python wrapper functions, These functions can
-      use any combination of parameters that you wish.
-
-%}
-
-#endif
-
-
-// If a PyObject * appears as either an argument or a function return
-// value, simply pass it straight through.
-
-%typemap(python,in) PyObject * {
-  $target = $source;
-}
-
-%typemap(python,out) PyObject * {
-  $target = $source;
-}
-

wxPython/b

@@ -1,121 +0,0 @@
-#!/bin/sh
-
-function getpyver {
-    if [ "$1" = "15" ]; then
-	PYVER=1.5
-    elif [ "$1" = "20" ]; then
-	PYVER=2.0
-    elif [ "$1" = "21" ]; then
-	PYVER=2.1
-    elif [ "$1" = "22" ]; then
-	PYVER=2.2
-    else
-	echo You must specify Python version as first parameter.
-        exit
-    fi
-}
-
-getpyver $1
-shift
-
-python$PYVER -c "import sys;print '\n', sys.version, '\n'"
-
-
-SETUP="python$PYVER -u setup.py"
-FLAGS="USE_SWIG=1 IN_CVS_TREE=1" # BUILD_GLCANVAS=0"
-OTHERFLAGS=""
-
-
-
-# "c" --> clean
-if [ "$1" =  "c" ]; then
-    shift
-    CMD="$SETUP $FLAGS $OTHERFLAGS clean"
-    OTHERCMD="rm -f wxPython/*.so"
-
-# "d" --> clean extension modules only
-elif [ "$1" = "d" ]; then
-    shift
-    CMD="rm -f wxPython/*.so"
-
-# "t" --> touch *.i files
-elif [ "$1" = "t" ]; then
-    shift
-    #CMD="set CMD=touch src\*.i; touch contrib\glcanvas\*.i; touch contrib\ogl\*.i; touch contrib\stc\*.i"
-    CMD='find . -name "*.i" | xargs touch'
-
-# "i" --> install
-elif [ "$1" = "i" ]; then
-    shift
-    CMD="$SETUP build $OTHERFLAGS install"
-
-# "s" --> source dist
-elif [ "$1" = "s" ]; then
-    shift
-    CMD="$SETUP $OTHERFLAGS sdist"
-
-# "r" --> rpm dist
-elif [ "$1" = "r" ]; then
-    WXPYVER=`python$PYVER -c "import setup;print setup.VERSION"`
-    for VER in 21 22; do
-	getpyver $VER
-
-	echo "*****************************************************************"
-	echo "*******      Building wxPython for Python $PYVER"
-	echo "*****************************************************************"
-
-	SETUP="python$PYVER -u setup.py"
-
-	# save the original
-	cp setup.py setup.py.save
-
-	# fix up setup.py the way we want...
-	sed "s/BUILD_GLCANVAS = /BUILD_GLCANVAS = 0 #/" < setup.py.save > setup.py.temp
-	sed "s/GL_ONLY = /GL_ONLY = 1 #/" < setup.py.temp > setup.py
-
-	# build wxPython-gl RPM
-	$SETUP $OTHERFLAGS bdist_rpm --binary-only --doc-files README.txt --python=python$PYVER
-			### --requires=python$PYVER
-	rm dist/wxPython-gl*.tar.gz
-
-	# Build wxPython RPM
-	cp setup.py setup.py.temp
-	sed "s/GL_ONLY = /GL_ONLY = 0 #/" < setup.py.temp > setup.py
-	$SETUP $OTHERFLAGS bdist_rpm --binary-only --python=python$PYVER
-			### --requires=python$PYVER
-
-	# put the oringal setup.py back
-	cp setup.py.save setup.py
-	rm setup.py.*
-
-	# rename the binary RPM's
-	mv dist/wxPython-$WXPYVER-1.i386.rpm dist/wxPython-$WXPYVER-1-Py$VER.i386.rpm
-	mv dist/wxPython-gl-$WXPYVER-1.i386.rpm dist/wxPython-gl-$WXPYVER-1-Py$VER.i386.rpm
-
-    done
-
-    # rebuild the source dists without the munched up setup.py
-    $SETUP $OTHERFLAGS bdist_rpm --source-only
-    exit 0
-
-
-# "f" --> FINAL (no debug)
-elif [ "$1" = "f" ]; then
-    shift
-    CMD="$SETUP $FLAGS $OTHERFLAGS build_ext --inplace $*"
-
-# (no command arg) --> normal build for development
-else
-    CMD="$SETUP $FLAGS $OTHERFLAGS build_ext --inplace --debug $*"
-fi
-
-
-echo $CMD
-eval $CMD
-
-
-if [ "$OTHERCMD" != "" ]; then
-    echo $OTHERCMD
-    $OTHERCMD
-fi
-

wxPython/b.bat

@@ -1,119 +0,0 @@
-@echo off
-REM ----------------------------------------------------------------------
-REM Note:  This is a 4NT script
-REM ----------------------------------------------------------------------
-setlocal
-
-set FLAGS=USE_SWIG=1 IN_CVS_TREE=1
-
-
-rem  Use non-default python?
-iff "%1" == "15" .or. "%1" == "20" .or. "%1" == "21" .or. "%1" == "22" then
-	set VER=%1
-	set PYTHON=c:\tools\python%1%\python.exe
-	shift
-else
-	beep
-	echo You must specify Python version as first parameter.
-	quit
-endiff
-set SETUP=%PYTHON% -u setup.py
-
-
-%PYTHON% -c "import sys;print '\n', sys.version, '\n'"
-
-
-rem "c" --> clean
-iff "%1" == "c" then
-	shift
-	set CMD=%SETUP% %FLAGS% clean
-	set OTHERCMD=del wxPython\*.pyd
-
-rem just remove the *.pyd's
-elseiff "%1" == "d" then
-	shift
-	set CMD=del wxPython\*.pyd
-
-rem touch all the *.i files so swig will regenerate
-elseiff "%1" == "t" then
-	shift
-	set CMD=echo Finished!
-	find . -name "*.i" | xargs -l touch
-
-rem "i" --> install
-elseiff "%1" == "i" then
-	shift
-	set CMD=%SETUP% build install
-
-rem "r" --> make installer
-elseiff "%1" == "r" then
-	shift
-	set CMD=%PYTHON% distrib\make_installer.py
-
-rem "s" --> source dist
-elseiff "%1" == "s" then
-	shift
-	set CMD=%SETUP sdist
-
-rem "f" --> FINAL
-elseiff "%1" == "f" then
-	shift
-	set CMD=%SETUP% %FLAGS% FINAL=1 build_ext --inplace %1 %2 %3 %4 %5 %6 %7 %8 %9
-
-rem "h" --> HYBRID
-elseiff "%1" == "h" then
-	shift
-	set CMD=%SETUP% %FLAGS% HYBRID=1 build_ext --inplace %1 %2 %3 %4 %5 %6 %7 %8 %9
-
-rem "a" --> make all installers
-elseiff "%1" == "a" then
-	shift
-	set CMD=echo Finished!
-
-	call b.bat 15 c
-	call b.bat 15 f
-	cd demo
-	p15 encode_bitmaps.py
-	cd -
-	call b.bat 15 r
-	call b.bat 15 c
-	call b.bat 15 h
-	call b.bat 15 r
-
-	call b.bat 21 c
-	call b.bat 21 f
-	call b.bat 21 r
-	call b.bat 21 c
-	call b.bat 21 h
-	call b.bat 21 r
-
-	call b.bat 22 c
-	call b.bat 22 f
-	call b.bat 22 r
-	call b.bat 22 c
-	call b.bat 22 h
-	call b.bat 22 r
-
-
-rem "b" --> both debug and hybrid builds
-elseiff "%1" == "b" then
-	shift
-	set CMD=echo Finished!
-	call b.bat %VER% h
-	call b.bat %VER%
-
-rem (no command arg) --> normal build for development
-else
-	set CMD=%SETUP% %FLAGS% HYBRID=0 build_ext --inplace --debug %1 %2 %3 %4 %5 %6 %7 %8 %9
-endiff
-
-
-
-echo %CMD%
-%CMD%
-
-iff "%OTHERCMD%" != "" then
-	echo %OTHERCMD%
-	%OTHERCMD%
-endiff
-

wxPython/contrib/.cvsignore

@@ -1 +0,0 @@
-update.log

wxPython/contrib/README

@@ -1,3 +0,0 @@
-These sub directories contain add-on modules that are not part of the
-core wxPython, either because of licensing issues, optional code in
-wxWindows, contrib code in wxWindows, or whatever.

wxPython/contrib/dllwidget/dllwidget.cpp

@@ -1,128 +0,0 @@
-/////////////////////////////////////////////////////////////////////////////
-// Name:        dllwidget.cpp
-// Purpose:     Dynamically loadable C++ widget for wxPython
-// Author:      Vaclav Slavik
-// Created:     2001/12/03
-// RCS-ID:      $Id$
-// Copyright:   (c) 2001 Vaclav Slavik
-// Licence:     wxWindows licence
-/////////////////////////////////////////////////////////////////////////////
-
-#ifdef __GNUG__
-#pragma implementation "dllwidget.h"
-#endif
-
-// For compilers that support precompilation, includes "wx.h".
-#include "wx/wxprec.h"
-
-#ifdef __BORLANDC__
-    #pragma hdrstop
-#endif
-
-#include "wx/defs.h"
-#include "wx/dynlib.h"
-#include "wx/sizer.h"
-
-#include "dllwidget.h"
-
-
-IMPLEMENT_ABSTRACT_CLASS(wxDllWidget, wxPanel)
-
-wxDllWidget::wxDllWidget(wxWindow *parent,
-                         wxWindowID id,
-                         const wxString& dllName, const wxString& className,
-                         const wxPoint& pos, const wxSize& size,
-                         long style)
-    : wxPanel(parent, id, pos, size, wxTAB_TRAVERSAL | wxNO_BORDER,
-              className + wxT("_container")),
-    m_widget(NULL), m_lib(NULL), m_controlAdded(FALSE)
-{
-    SetBackgroundColour(wxColour(255, 0, 255));
-    if ( !!className )
-        LoadWidget(dllName, className, style);
-}
-
-wxDllWidget::~wxDllWidget()
-{
-    UnloadWidget();
-}
-
-void wxDllWidget::AddChild(wxWindowBase *child)
-{
-    wxASSERT_MSG( !m_controlAdded, wxT("Couldn't load two widgets into one container!") )
-
-    wxPanel::AddChild(child);
-
-    m_controlAdded = TRUE;
-    wxSizer *sizer = new wxBoxSizer(wxHORIZONTAL);
-    sizer->Add((wxWindow*)child, 1, wxEXPAND);
-    SetSizer(sizer);
-    SetAutoLayout(TRUE);
-    Layout();
-}
-
-
-wxString wxDllWidget::GetDllExt()
-{
-    return wxDllLoader::GetDllExt();
-}
-
-
-typedef WXDLLEXPORT bool (*DLL_WidgetFactory_t)(const wxString& className,
-                                                wxWindow *parent,
-                                                long style,
-                                                wxWindow **classInst,
-                                                wxSendCommandFunc *cmdFunc);
-
-bool wxDllWidget::LoadWidget(const wxString& dll, const wxString& className,
-                             long style)
-{
-    UnloadWidget();
-
-    // Load the dynamic library
-    m_lib = new wxDynamicLibrary(dll);
-    if ( !m_lib->IsLoaded() )
-    {
-        delete m_lib;
-        m_lib = NULL;
-        return FALSE;
-    }
-
-    DLL_WidgetFactory_t factory;
-    factory = (DLL_WidgetFactory_t) m_lib->GetSymbol(wxT("DLL_WidgetFactory"));
-    if ( factory == NULL)
-    {
-        delete m_lib;
-        m_lib = NULL;
-        return FALSE;
-    }
-
-    if ( !factory(className, this, style, &m_widget, &m_cmdFunc) )
-    {
-        delete m_widget;
-        delete m_lib;
-        m_lib = NULL;
-        m_widget = NULL;
-        return FALSE;
-    }
-
-    return TRUE;
-}
-
-void wxDllWidget::UnloadWidget()
-{
-    if ( m_widget )
-    {
-        DestroyChildren();
-        m_widget = NULL;
-        delete m_lib;
-        m_lib = NULL;
-    }
-}
-
-int wxDllWidget::SendCommand(int cmd, const wxString& param)
-{
-    wxASSERT_MSG( m_widget && m_cmdFunc, wxT("Sending command to not loaded widget!"));
-
-    return m_cmdFunc(m_widget, cmd, param);
-}

wxPython/contrib/dllwidget/dllwidget.h

@@ -1,143 +0,0 @@
-/////////////////////////////////////////////////////////////////////////////
-// Name:        dllwidget.h
-// Purpose:     Dynamically loadable C++ widget for wxPython
-// Author:      Vaclav Slavik
-// Created:     2001/12/03
-// RCS-ID:      $Id$
-// Copyright:   (c) 2001 Vaclav Slavik
-// Licence:     wxWindows licence
-/////////////////////////////////////////////////////////////////////////////
-
-#ifdef __GNUG__
-#pragma interface "dllwidget.h"
-#endif
-
-#ifndef __DLLWIDGET_H__
-#define __DLLWIDGET_H__
-
-#include "wx/panel.h"
-
-/*
-
-wxDllWidget can be used to embed a wxWindow implemented in C++ in your
-wxPython application without the need to write a SWIG interface. Widget's code
-is stored in shared library or DLL that exports DLL_WidgetFactory symbol
-and loaded at runtime. All you have to do is to pass the name of DLL and the class
-to create to wxDllWidget's ctor.
-
-Runtime-loadable widget must have HandleCommand method (see the example) that is
-used to communicate with Python app. You call wxDllWidget.SendCommand(cmd,param) from
-Python and it in turn calls HandleCommand of the loaded widget.
-
-You must use DECLARE_DLL_WIDGET, BEGIN_WIDGET_LIBRARY, END_WIDGET_LIBRARY and
-REGISTER_WIDGET macros in your C++ module in order to provide all the meat
-wxDllWidget needs.
-
-Example of use:
-
-    #define CMD_MAKEWHITE     1
-
-    class MyWindow : public wxWindow
-    {
-    public:
-        MyWindow(wxWindow *parent, long style)
-            : wxWindow(parent, -1) {}
-
-        int HandleCommand(int cmd, const wxString& param)
-        {
-            if (cmd == CMD_MAKEWHITE)
-                SetBackgroundColour(*wxWHITE);
-            return 0;
-        }
-    };
-    DECLARE_DLL_WIDGET(MyWindow)
-
-    class MyCanvasWindow : public wxScrolledWindow
-    {
-        ...
-    };
-    DECLARE_DLL_WIDGET(MyCanvasWindow)
-
-    BEGIN_WIDGET_LIBRARY()
-        REGISTER_WIDGET(MyWindow)
-        REGISTER_WIDGET(MyCanvasWindow)
-    END_WIDGET_LIBRARY()
-
-*/
-
-
-
-class WXDLLEXPORT wxDynamicLibrary;
-
-typedef int (*wxSendCommandFunc)(wxWindow *wnd, int cmd, const wxString& param);
-
-class wxDllWidget : public wxPanel
-{
-public:
-    wxDllWidget(wxWindow *parent,
-                wxWindowID id = -1,
-                const wxString& dllName = wxEmptyString,
-                const wxString& className = wxEmptyString,
-                const wxPoint& pos = wxDefaultPosition,
-                const wxSize& size = wxDefaultSize,
-                long style = 0);
-    virtual ~wxDllWidget();
-
-    bool Ok() { return m_widget != NULL; }
-
-    virtual int SendCommand(int cmd, const wxString& param = wxEmptyString);
-    virtual wxWindow* GetWidgetWindow() { return m_widget; }
-
-    virtual void AddChild(wxWindowBase *child);
-
-    static wxString GetDllExt();
-
-
-protected:
-    bool LoadWidget(const wxString& dll, const wxString& className, long style);
-    void UnloadWidget();
-
-protected:
-    wxWindow*           m_widget;
-    wxSendCommandFunc   m_cmdFunc;
-    wxDynamicLibrary*   m_lib;
-    bool                m_controlAdded;
-
-private:
-    DECLARE_ABSTRACT_CLASS(wxDllWidget)
-};
-
-
-#define DECLARE_DLL_WIDGET(widget) \
-    static int SendCommandTo##widget(wxWindow *wnd, int cmd, const wxString& param) \
-    { \
-        return wxStaticCast(wnd, widget)->HandleCommand(cmd, param); \
-    }
-
-
-#define BEGIN_WIDGET_LIBRARY() \
-    extern "C" WXEXPORT bool DLL_WidgetFactory( \
-                const wxString& className, \
-                wxWindow *parent, \
-                long style, \
-                wxWindow **classInst, \
-                wxSendCommandFunc *cmdFunc) \
-    { \
-        wxClassInfo::CleanUpClasses(); \
-        wxClassInfo::InitializeClasses();
-
-
-#define REGISTER_WIDGET(widget) \
-        if ( className == wxT(#widget) ) \
-        { \
-            *classInst = new widget(parent, style); \
-            *cmdFunc = SendCommandTo##widget; \
-            return TRUE; \
-        }
-
-
-#define END_WIDGET_LIBRARY() \
-       return FALSE; \
-    }
-
-#endif // __DLLWIDGET_H__

wxPython/contrib/dllwidget/dllwidget.py

@@ -1,6 +0,0 @@
-# The SWIG module is named dllwidget_ to avoid name clashes, so
-# this stub just imports everything in it so the firendly module
-# name can be used elsewhere.
-
-from dllwidget_ import *
-

wxPython/contrib/dllwidget/dllwidget_.cpp

@@ -1,506 +0,0 @@
-/*
- * FILE : contrib/dllwidget/dllwidget_.cpp
- * 
- * This file was automatically generated by :
- * Simplified Wrapper and Interface Generator (SWIG)
- * Version 1.1 (Build 883)
- * 
- * Portions Copyright (c) 1995-1998
- * The University of Utah and The Regents of the University of California.
- * Permission is granted to distribute this file in any manner provided
- * this notice remains intact.
- * 
- * Do not make changes to this file--changes will be lost!
- *
- */
-
-
-#define SWIGCODE
-/* Implementation : PYTHON */
-
-#define SWIGPYTHON
-#include <string.h>
-#include <stdlib.h>
-/* Definitions for Windows/Unix exporting */
-#if defined(__WIN32__)
-#   if defined(_MSC_VER)
-#	define SWIGEXPORT(a) __declspec(dllexport) a
-#   else
-#	if defined(__BORLANDC__)
-#	    define SWIGEXPORT(a) a _export
-#	else
-#	    define SWIGEXPORT(a) a
-#	endif
-#   endif
-#else
-#   define SWIGEXPORT(a) a
-#endif
-
-#include "Python.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-extern void SWIG_MakePtr(char *, void *, char *);
-extern void SWIG_RegisterMapping(char *, char *, void *(*)(void *));
-extern char *SWIG_GetPtr(char *, void **, char *);
-extern char *SWIG_GetPtrObj(PyObject *, void **, char *);
-extern void SWIG_addvarlink(PyObject *, char *, PyObject *(*)(void), int (*)(PyObject *));
-extern PyObject *SWIG_newvarlink(void);
-#ifdef __cplusplus
-}
-#endif
-#define SWIG_init    initdllwidget_c
-
-#define SWIG_name    "dllwidget_c"
-
-#include "export.h"
-#include "dllwidget.h"
-
-
-static PyObject* t_output_helper(PyObject* target, PyObject* o) {
-    PyObject*   o2;
-    PyObject*   o3;
-
-    if (!target) {
-        target = o;
-    } else if (target == Py_None) {
-        Py_DECREF(Py_None);
-        target = o;
-    } else {
-        if (!PyTuple_Check(target)) {
-            o2 = target;
-            target = PyTuple_New(1);
-            PyTuple_SetItem(target, 0, o2);
-        }
-        o3 = PyTuple_New(1);
-        PyTuple_SetItem(o3, 0, o);
-
-        o2 = target;
-        target = PySequence_Concat(o2, o3);
-        Py_DECREF(o2);
-        Py_DECREF(o3);
-    }
-    return target;
-}
-
-#if PYTHON_API_VERSION >= 1009
-    static char* wxStringErrorMsg = "String or Unicode type required";
-#else
-    static char* wxStringErrorMsg = "String type required";
-#endif
-#ifdef __cplusplus
-extern "C" {
-#endif
-static void *SwigwxDllWidgetTowxPanel(void *ptr) {
-    wxDllWidget *src;
-    wxPanel *dest;
-    src = (wxDllWidget *) ptr;
-    dest = (wxPanel *) src;
-    return (void *) dest;
-}
-
-static void *SwigwxDllWidgetTowxWindow(void *ptr) {
-    wxDllWidget *src;
-    wxWindow *dest;
-    src = (wxDllWidget *) ptr;
-    dest = (wxWindow *) src;
-    return (void *) dest;
-}
-
-static void *SwigwxDllWidgetTowxEvtHandler(void *ptr) {
-    wxDllWidget *src;
-    wxEvtHandler *dest;
-    src = (wxDllWidget *) ptr;
-    dest = (wxEvtHandler *) src;
-    return (void *) dest;
-}
-
-static void *SwigwxDllWidgetTowxObject(void *ptr) {
-    wxDllWidget *src;
-    wxObject *dest;
-    src = (wxDllWidget *) ptr;
-    dest = (wxObject *) src;
-    return (void *) dest;
-}
-
-#define new_wxDllWidget(_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4,_swigarg5,_swigarg6) (new wxDllWidget(_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4,_swigarg5,_swigarg6))
-static PyObject *_wrap_new_wxDllWidget(PyObject *self, PyObject *args, PyObject *kwargs) {
-    PyObject * _resultobj;
-    wxDllWidget * _result;
-    wxWindow * _arg0;
-    wxWindowID  _arg1 = (wxWindowID ) -1;
-    wxString * _arg2 = (wxString *) &wxEmptyString;
-    wxString * _arg3 = (wxString *) &wxEmptyString;
-    wxPoint * _arg4 = (wxPoint *) &wxDefaultPosition;
-    wxSize * _arg5 = (wxSize *) &wxDefaultSize;
-    long  _arg6 = (long ) 0;
-    PyObject * _argo0 = 0;
-    PyObject * _obj2 = 0;
-    PyObject * _obj3 = 0;
-    wxPoint  temp;
-    PyObject * _obj4 = 0;
-    wxSize  temp0;
-    PyObject * _obj5 = 0;
-    char *_kwnames[] = { "parent","id","dllName","className","pos","size","style", NULL };
-    char _ptemp[128];
-
-    self = self;
-    if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|iOOOOl:new_wxDllWidget",_kwnames,&_argo0,&_arg1,&_obj2,&_obj3,&_obj4,&_obj5,&_arg6)) 
-        return NULL;
-    if (_argo0) {
-        if (_argo0 == Py_None) { _arg0 = NULL; }
-        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxWindow_p")) {
-            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of new_wxDllWidget. Expected _wxWindow_p.");
-        return NULL;
-        }
-    }
-    if (_obj2)
-{
-#if PYTHON_API_VERSION >= 1009
-    char* tmpPtr; int tmpSize;
-    if (!PyString_Check(_obj2) && !PyUnicode_Check(_obj2)) {
-        PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
-        return NULL;
-    }
-    if (PyString_AsStringAndSize(_obj2, &tmpPtr, &tmpSize) == -1)
-        return NULL;
-    _arg2 = new wxString(tmpPtr, tmpSize);
-#else
-    if (!PyString_Check(_obj2)) {
-        PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
-        return NULL;
-    }
-    _arg2 = new wxString(PyString_AS_STRING(_obj2), PyString_GET_SIZE(_obj2));
-#endif
-}
-    if (_obj3)
-{
-#if PYTHON_API_VERSION >= 1009
-    char* tmpPtr; int tmpSize;
-    if (!PyString_Check(_obj3) && !PyUnicode_Check(_obj3)) {
-        PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
-        return NULL;
-    }
-    if (PyString_AsStringAndSize(_obj3, &tmpPtr, &tmpSize) == -1)
-        return NULL;
-    _arg3 = new wxString(tmpPtr, tmpSize);
-#else
-    if (!PyString_Check(_obj3)) {
-        PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
-        return NULL;
-    }
-    _arg3 = new wxString(PyString_AS_STRING(_obj3), PyString_GET_SIZE(_obj3));
-#endif
-}
-    if (_obj4)
-{
-    _arg4 = &temp;
-    if (! wxPoint_helper(_obj4, &_arg4))
-        return NULL;
-}
-    if (_obj5)
-{
-    _arg5 = &temp0;
-    if (! wxSize_helper(_obj5, &_arg5))
-        return NULL;
-}
-{
-    PyThreadState* __tstate = wxPyBeginAllowThreads();
-        _result = (wxDllWidget *)new_wxDllWidget(_arg0,_arg1,*_arg2,*_arg3,*_arg4,*_arg5,_arg6);
-
-    wxPyEndAllowThreads(__tstate);
-    if (PyErr_Occurred()) return NULL;
-}    if (_result) {
-        SWIG_MakePtr(_ptemp, (char *) _result,"_wxDllWidget_p");
-        _resultobj = Py_BuildValue("s",_ptemp);
-    } else {
-        Py_INCREF(Py_None);
-        _resultobj = Py_None;
-    }
-{
-    if (_obj2)
-        delete _arg2;
-}
-{
-    if (_obj3)
-        delete _arg3;
-}
-    return _resultobj;
-}
-
-#define wxDllWidget_Ok(_swigobj)  (_swigobj->Ok())
-static PyObject *_wrap_wxDllWidget_Ok(PyObject *self, PyObject *args, PyObject *kwargs) {
-    PyObject * _resultobj;
-    bool  _result;
-    wxDllWidget * _arg0;
-    PyObject * _argo0 = 0;
-    char *_kwnames[] = { "self", NULL };
-
-    self = self;
-    if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxDllWidget_Ok",_kwnames,&_argo0)) 
-        return NULL;
-    if (_argo0) {
-        if (_argo0 == Py_None) { _arg0 = NULL; }
-        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxDllWidget_p")) {
-            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxDllWidget_Ok. Expected _wxDllWidget_p.");
-        return NULL;
-        }
-    }
-{
-    PyThreadState* __tstate = wxPyBeginAllowThreads();
-        _result = (bool )wxDllWidget_Ok(_arg0);
-
-    wxPyEndAllowThreads(__tstate);
-    if (PyErr_Occurred()) return NULL;
-}    _resultobj = Py_BuildValue("i",_result);
-    return _resultobj;
-}
-
-#define wxDllWidget_SendCommand(_swigobj,_swigarg0,_swigarg1)  (_swigobj->SendCommand(_swigarg0,_swigarg1))
-static PyObject *_wrap_wxDllWidget_SendCommand(PyObject *self, PyObject *args, PyObject *kwargs) {
-    PyObject * _resultobj;
-    int  _result;
-    wxDllWidget * _arg0;
-    int  _arg1;
-    wxString * _arg2 = (wxString *) &wxEmptyString;
-    PyObject * _argo0 = 0;
-    PyObject * _obj2 = 0;
-    char *_kwnames[] = { "self","cmd","param", NULL };
-
-    self = self;
-    if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi|O:wxDllWidget_SendCommand",_kwnames,&_argo0,&_arg1,&_obj2)) 
-        return NULL;
-    if (_argo0) {
-        if (_argo0 == Py_None) { _arg0 = NULL; }
-        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxDllWidget_p")) {
-            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxDllWidget_SendCommand. Expected _wxDllWidget_p.");
-        return NULL;
-        }
-    }
-    if (_obj2)
-{
-#if PYTHON_API_VERSION >= 1009
-    char* tmpPtr; int tmpSize;
-    if (!PyString_Check(_obj2) && !PyUnicode_Check(_obj2)) {
-        PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
-        return NULL;
-    }
-    if (PyString_AsStringAndSize(_obj2, &tmpPtr, &tmpSize) == -1)
-        return NULL;
-    _arg2 = new wxString(tmpPtr, tmpSize);
-#else
-    if (!PyString_Check(_obj2)) {
-        PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
-        return NULL;
-    }
-    _arg2 = new wxString(PyString_AS_STRING(_obj2), PyString_GET_SIZE(_obj2));
-#endif
-}
-{
-    PyThreadState* __tstate = wxPyBeginAllowThreads();
-        _result = (int )wxDllWidget_SendCommand(_arg0,_arg1,*_arg2);
-
-    wxPyEndAllowThreads(__tstate);
-    if (PyErr_Occurred()) return NULL;
-}    _resultobj = Py_BuildValue("i",_result);
-{
-    if (_obj2)
-        delete _arg2;
-}
-    return _resultobj;
-}
-
-#define wxDllWidget_GetWidgetWindow(_swigobj)  (_swigobj->GetWidgetWindow())
-static PyObject *_wrap_wxDllWidget_GetWidgetWindow(PyObject *self, PyObject *args, PyObject *kwargs) {
-    PyObject * _resultobj;
-    wxWindow * _result;
-    wxDllWidget * _arg0;
-    PyObject * _argo0 = 0;
-    char *_kwnames[] = { "self", NULL };
-
-    self = self;
-    if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxDllWidget_GetWidgetWindow",_kwnames,&_argo0)) 
-        return NULL;
-    if (_argo0) {
-        if (_argo0 == Py_None) { _arg0 = NULL; }
-        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxDllWidget_p")) {
-            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxDllWidget_GetWidgetWindow. Expected _wxDllWidget_p.");
-        return NULL;
-        }
-    }
-{
-    PyThreadState* __tstate = wxPyBeginAllowThreads();
-        _result = (wxWindow *)wxDllWidget_GetWidgetWindow(_arg0);
-
-    wxPyEndAllowThreads(__tstate);
-    if (PyErr_Occurred()) return NULL;
-}{ _resultobj = wxPyMake_wxObject(_result); }
-    return _resultobj;
-}
-
-static PyObject *_wrap_wxDllWidget_GetDllExt(PyObject *self, PyObject *args, PyObject *kwargs) {
-    PyObject * _resultobj;
-    wxString * _result;
-    char *_kwnames[] = {  NULL };
-
-    self = self;
-    if(!PyArg_ParseTupleAndKeywords(args,kwargs,":wxDllWidget_GetDllExt",_kwnames)) 
-        return NULL;
-{
-    PyThreadState* __tstate = wxPyBeginAllowThreads();
-        _result = new wxString (wxDllWidget::GetDllExt());
-
-    wxPyEndAllowThreads(__tstate);
-    if (PyErr_Occurred()) return NULL;
-}{
-    _resultobj = PyString_FromStringAndSize(_result->c_str(), _result->Len());
-}
-{
-    delete _result;
-}
-    return _resultobj;
-}
-
-static PyMethodDef dllwidget_cMethods[] = {
-	 { "wxDllWidget_GetDllExt", (PyCFunction) _wrap_wxDllWidget_GetDllExt, METH_VARARGS | METH_KEYWORDS },
-	 { "wxDllWidget_GetWidgetWindow", (PyCFunction) _wrap_wxDllWidget_GetWidgetWindow, METH_VARARGS | METH_KEYWORDS },
-	 { "wxDllWidget_SendCommand", (PyCFunction) _wrap_wxDllWidget_SendCommand, METH_VARARGS | METH_KEYWORDS },
-	 { "wxDllWidget_Ok", (PyCFunction) _wrap_wxDllWidget_Ok, METH_VARARGS | METH_KEYWORDS },
-	 { "new_wxDllWidget", (PyCFunction) _wrap_new_wxDllWidget, METH_VARARGS | METH_KEYWORDS },
-	 { NULL, NULL }
-};
-#ifdef __cplusplus
-}
-#endif
-/*
- * This table is used by the pointer type-checker
- */
-static struct { char *n1; char *n2; void *(*pcnv)(void *); } _swig_mapping[] = {
-    { "_signed_long","_long",0},
-    { "_wxPrintQuality","_wxCoord",0},
-    { "_wxPrintQuality","_int",0},
-    { "_wxPrintQuality","_signed_int",0},
-    { "_wxPrintQuality","_unsigned_int",0},
-    { "_wxPrintQuality","_wxWindowID",0},
-    { "_wxPrintQuality","_uint",0},
-    { "_wxPrintQuality","_EBool",0},
-    { "_wxPrintQuality","_size_t",0},
-    { "_wxPrintQuality","_time_t",0},
-    { "_byte","_unsigned_char",0},
-    { "_long","_unsigned_long",0},
-    { "_long","_signed_long",0},
-    { "_size_t","_wxCoord",0},
-    { "_size_t","_wxPrintQuality",0},
-    { "_size_t","_time_t",0},
-    { "_size_t","_unsigned_int",0},
-    { "_size_t","_int",0},
-    { "_size_t","_wxWindowID",0},
-    { "_size_t","_uint",0},
-    { "_wxPanel","_wxDllWidget",SwigwxDllWidgetTowxPanel},
-    { "_uint","_wxCoord",0},
-    { "_uint","_wxPrintQuality",0},
-    { "_uint","_time_t",0},
-    { "_uint","_size_t",0},
-    { "_uint","_unsigned_int",0},
-    { "_uint","_int",0},
-    { "_uint","_wxWindowID",0},
-    { "_wxChar","_char",0},
-    { "_char","_wxChar",0},
-    { "_struct_wxNativeFontInfo","_wxNativeFontInfo",0},
-    { "_EBool","_wxCoord",0},
-    { "_EBool","_wxPrintQuality",0},
-    { "_EBool","_signed_int",0},
-    { "_EBool","_int",0},
-    { "_EBool","_wxWindowID",0},
-    { "_unsigned_long","_long",0},
-    { "_wxNativeFontInfo","_struct_wxNativeFontInfo",0},
-    { "_signed_int","_wxCoord",0},
-    { "_signed_int","_wxPrintQuality",0},
-    { "_signed_int","_EBool",0},
-    { "_signed_int","_wxWindowID",0},
-    { "_signed_int","_int",0},
-    { "_WXTYPE","_wxDateTime_t",0},
-    { "_WXTYPE","_short",0},
-    { "_WXTYPE","_signed_short",0},
-    { "_WXTYPE","_unsigned_short",0},
-    { "_unsigned_short","_wxDateTime_t",0},
-    { "_unsigned_short","_WXTYPE",0},
-    { "_unsigned_short","_short",0},
-    { "_wxObject","_wxDllWidget",SwigwxDllWidgetTowxObject},
-    { "_signed_short","_WXTYPE",0},
-    { "_signed_short","_short",0},
-    { "_unsigned_char","_byte",0},
-    { "_unsigned_int","_wxCoord",0},
-    { "_unsigned_int","_wxPrintQuality",0},
-    { "_unsigned_int","_time_t",0},
-    { "_unsigned_int","_size_t",0},
-    { "_unsigned_int","_uint",0},
-    { "_unsigned_int","_wxWindowID",0},
-    { "_unsigned_int","_int",0},
-    { "_short","_wxDateTime_t",0},
-    { "_short","_WXTYPE",0},
-    { "_short","_unsigned_short",0},
-    { "_short","_signed_short",0},
-    { "_wxWindowID","_wxCoord",0},
-    { "_wxWindowID","_wxPrintQuality",0},
-    { "_wxWindowID","_time_t",0},
-    { "_wxWindowID","_size_t",0},
-    { "_wxWindowID","_EBool",0},
-    { "_wxWindowID","_uint",0},
-    { "_wxWindowID","_int",0},
-    { "_wxWindowID","_signed_int",0},
-    { "_wxWindowID","_unsigned_int",0},
-    { "_int","_wxCoord",0},
-    { "_int","_wxPrintQuality",0},
-    { "_int","_time_t",0},
-    { "_int","_size_t",0},
-    { "_int","_EBool",0},
-    { "_int","_uint",0},
-    { "_int","_wxWindowID",0},
-    { "_int","_unsigned_int",0},
-    { "_int","_signed_int",0},
-    { "_wxDateTime_t","_unsigned_short",0},
-    { "_wxDateTime_t","_short",0},
-    { "_wxDateTime_t","_WXTYPE",0},
-    { "_time_t","_wxCoord",0},
-    { "_time_t","_wxPrintQuality",0},
-    { "_time_t","_unsigned_int",0},
-    { "_time_t","_int",0},
-    { "_time_t","_wxWindowID",0},
-    { "_time_t","_uint",0},
-    { "_time_t","_size_t",0},
-    { "_wxCoord","_int",0},
-    { "_wxCoord","_signed_int",0},
-    { "_wxCoord","_unsigned_int",0},
-    { "_wxCoord","_wxWindowID",0},
-    { "_wxCoord","_uint",0},
-    { "_wxCoord","_EBool",0},
-    { "_wxCoord","_size_t",0},
-    { "_wxCoord","_time_t",0},
-    { "_wxCoord","_wxPrintQuality",0},
-    { "_wxEvtHandler","_wxDllWidget",SwigwxDllWidgetTowxEvtHandler},
-    { "_wxWindow","_wxDllWidget",SwigwxDllWidgetTowxWindow},
-{0,0,0}};
-
-static PyObject *SWIG_globals;
-#ifdef __cplusplus
-extern "C" 
-#endif
-SWIGEXPORT(void) initdllwidget_c() {
-	 PyObject *m, *d;
-	 SWIG_globals = SWIG_newvarlink();
-	 m = Py_InitModule("dllwidget_c", dllwidget_cMethods);
-	 d = PyModule_GetDict(m);
-
-
-    wxClassInfo::CleanUpClasses();
-    wxClassInfo::InitializeClasses();
-
-{
-   int i;
-   for (i = 0; _swig_mapping[i].n1; i++)
-        SWIG_RegisterMapping(_swig_mapping[i].n1,_swig_mapping[i].n2,_swig_mapping[i].pcnv);
-}
-}

wxPython/contrib/dllwidget/dllwidget_.i

@@ -1,111 +0,0 @@
-/////////////////////////////////////////////////////////////////////////////
-// Name:        dllwidget_.i
-// Purpose:     Load wx widgets from external DLLs
-//
-// Author:      Robin Dunn
-//
-// Created:     04-Dec-2001
-// RCS-ID:      $Id$
-// Copyright:   (c) 2001 by Total Control Software
-// Licence:     wxWindows license
-/////////////////////////////////////////////////////////////////////////////
-
-%module dllwidget_
-
-
-%{
-#include "export.h"
-#include "dllwidget.h"
-%}
-
-//---------------------------------------------------------------------------
-
-%include typemaps.i
-%include my_typemaps.i
-
-%extern wx.i
-%extern windows.i
-%extern _defs.i
-
-//---------------------------------------------------------------------------
-
-/*
-
-wxDllWidget can be used to embed a wxWindow implemented in C++ in your
-wxPython application without the need to write a SWIG interface. Widget's code
-is stored in shared library or DLL that exports DLL_WidgetFactory symbol
-and loaded at runtime. All you have to do is to pass the name of DLL and the class
-to create to wxDllWidget's ctor.
-
-Runtime-loadable widget must have HandleCommand method (see the example) that is
-used to communicate with Python app. You call wxDllWidget.SendCommand(cmd,param) from
-Python and it in turn calls HandleCommand of the loaded widget.
-
-You must use DECLARE_DLL_WIDGET, BEGIN_WIDGET_LIBRARY, END_WIDGET_LIBRARY and
-REGISTER_WIDGET macros in your C++ module in order to provide all the meat
-wxDllWidget needs.
-
-Example of use:
-
-    #define CMD_MAKEWHITE     1
-
-    class MyWindow : public wxWindow
-    {
-    public:
-        MyWindow(wxWindow *parent, long style)
-            : wxWindow(parent, -1) {}
-
-        int HandleCommand(int cmd, const wxString& param)
-        {
-            if (cmd == CMD_MAKEWHITE)
-                SetBackgroundColour(*wxWHITE);
-            return 0;
-        }
-    };
-    DECLARE_DLL_WIDGET(MyWindow)
-
-    class MyCanvasWindow : public wxScrolledWindow
-    {
-        ...
-    };
-    DECLARE_DLL_WIDGET(MyCanvasWindow)
-
-    BEGIN_WIDGET_LIBRARY()
-        REGISTER_WIDGET(MyWindow)
-        REGISTER_WIDGET(MyCanvasWindow)
-    END_WIDGET_LIBRARY()
-
-*/
-
-class wxDllWidget : public wxPanel
-{
-public:
-    wxDllWidget(wxWindow *parent,
-                wxWindowID id = -1,
-                const wxString& dllName = wxEmptyString,
-                const wxString& className = wxEmptyString,
-                const wxPoint& pos = wxDefaultPosition,
-                const wxSize& size = wxDefaultSize,
-                long style = 0);
-
-    %pragma(python) addtomethod = "__init__:self._setOORInfo(self)"
-
-    bool Ok();
-
-    int SendCommand(int cmd, const wxString& param = wxEmptyString);
-    wxWindow* GetWidgetWindow();
-
-    static wxString GetDllExt();
-};
-
-//---------------------------------------------------------------------------
-
-%init %{
-
-    wxClassInfo::CleanUpClasses();
-    wxClassInfo::InitializeClasses();
-
-%}
-
-
-//---------------------------------------------------------------------------

wxPython/contrib/dllwidget/dllwidget_.py

@@ -1,76 +0,0 @@
-# This file was created automatically by SWIG.
-import dllwidget_c
-
-from misc import *
-
-from misc2 import *
-
-from windows import *
-
-from gdi import *
-
-from clip_dnd import *
-
-from events import *
-
-from streams import *
-
-from utils import *
-
-from mdi import *
-
-from frames import *
-
-from stattool import *
-
-from controls import *
-
-from controls2 import *
-
-from windows2 import *
-
-from cmndlgs import *
-
-from windows3 import *
-
-from image import *
-
-from printfw import *
-
-from sizers import *
-
-from filesys import *
-class wxDllWidgetPtr(wxPanelPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def Ok(self, *_args, **_kwargs):
-        val = apply(dllwidget_c.wxDllWidget_Ok,(self,) + _args, _kwargs)
-        return val
-    def SendCommand(self, *_args, **_kwargs):
-        val = apply(dllwidget_c.wxDllWidget_SendCommand,(self,) + _args, _kwargs)
-        return val
-    def GetWidgetWindow(self, *_args, **_kwargs):
-        val = apply(dllwidget_c.wxDllWidget_GetWidgetWindow,(self,) + _args, _kwargs)
-        return val
-    def __repr__(self):
-        return "<C wxDllWidget instance at %s>" % (self.this,)
-class wxDllWidget(wxDllWidgetPtr):
-    def __init__(self,*_args,**_kwargs):
-        self.this = apply(dllwidget_c.new_wxDllWidget,_args,_kwargs)
-        self.thisown = 1
-        self._setOORInfo(self)
-
-
-
-
-
-
-#-------------- FUNCTION WRAPPERS ------------------
-
-wxDllWidget_GetDllExt = dllwidget_c.wxDllWidget_GetDllExt
-
-
-
-#-------------- VARIABLE WRAPPERS ------------------
-

wxPython/contrib/gizmos/.cvsignore

@@ -1 +0,0 @@
-contrib

wxPython/contrib/gizmos/_gizmoextras.py

@@ -1,12 +0,0 @@
-# Stuff these names into the wx namespace so wxPyConstructObject can find them
-
-wx.wxDynamicSashSplitEventPtr       = wxDynamicSashSplitEventPtr
-wx.wxDynamicSashUnifyEventPtr       = wxDynamicSashUnifyEventPtr
-wx.wxDynamicSashWindowPtr           = wxDynamicSashWindowPtr
-
-wx.wxEditableListBoxPtr             = wxEditableListBoxPtr
-
-wx.wxRemotelyScrolledTreeCtrlPtr    = wxRemotelyScrolledTreeCtrlPtr
-wx.wxTreeCompanionWindowPtr         = wxTreeCompanionWindowPtr
-wx.wxThinSplitterWindowPtr          = wxThinSplitterWindowPtr
-wx.wxSplitterScrolledWindowPtr      = wxSplitterScrolledWindowPtr

wxPython/contrib/gizmos/gizmos.i

@@ -1,398 +0,0 @@
-/////////////////////////////////////////////////////////////////////////////
-// Name:        gizmos.i
-// Purpose:     Wrappers for the "gizmo" classes in wx/contrib
-//
-// Author:      Robin Dunn
-//
-// Created:     23-Nov-2001
-// RCS-ID:      $Id$
-// Copyright:   (c) 2001 by Total Control Software
-// Licence:     wxWindows license
-/////////////////////////////////////////////////////////////////////////////
-
-%module gizmos
-
-
-%{
-#include "export.h"
-#include <wx/gizmos/dynamicsash.h>
-#include <wx/gizmos/editlbox.h>
-#include <wx/gizmos/splittree.h>
-#include <wx/gizmos/ledctrl.h>
-%}
-
-//---------------------------------------------------------------------------
-
-%include typemaps.i
-%include my_typemaps.i
-
-%extern wx.i
-%extern windows.i
-%extern _defs.i
-%extern events.i
-%extern controls.i
-
-
-//----------------------------------------------------------------------
-
-enum {
-    wxEVT_DYNAMIC_SASH_SPLIT,
-    wxEVT_DYNAMIC_SASH_UNIFY,
-
-    wxDS_MANAGE_SCROLLBARS,
-    wxDS_DRAG_CORNER,
-};
-
-
-/*
-    wxDynamicSashSplitEvents are sent to your view by wxDynamicSashWindow
-    whenever your view is being split by the user.  It is your
-    responsibility to handle this event by creating a new view window as
-    a child of the wxDynamicSashWindow.  wxDynamicSashWindow will
-    automatically reparent it to the proper place in its window hierarchy.
-*/
-class wxDynamicSashSplitEvent : public wxCommandEvent {
-public:
-    wxDynamicSashSplitEvent(wxObject *target);
-};
-
-
-/*
-    wxDynamicSashUnifyEvents are sent to your view by wxDynamicSashWindow
-    whenever the sash which splits your view and its sibling is being
-    reunified such that your view is expanding to replace its sibling.
-    You needn't do anything with this event if you are allowing
-    wxDynamicSashWindow to manage your view's scrollbars, but it is useful
-    if you are managing the scrollbars yourself so that you can keep
-    the scrollbars' event handlers connected to your view's event handler
-    class.
-*/
-class wxDynamicSashUnifyEvent : public wxCommandEvent {
-public:
-    wxDynamicSashUnifyEvent(wxObject *target);
-};
-
-
-
-/*
-
-    wxDynamicSashWindow
-
-    wxDynamicSashWindow widgets manages the way other widgets are viewed.
-    When a wxDynamicSashWindow is first shown, it will contain one child
-    view, a viewport for that child, and a pair of scrollbars to allow the
-    user to navigate the child view area.  Next to each scrollbar is a small
-    tab.  By clicking on either tab and dragging to the appropriate spot, a
-    user can split the view area into two smaller views separated by a
-    draggable sash.  Later, when the user wishes to reunify the two subviews,
-    the user simply drags the sash to the side of the window.
-    wxDynamicSashWindow will automatically reparent the appropriate child
-    view back up the window hierarchy, and the wxDynamicSashWindow will have
-    only one child view once again.
-
-    As an application developer, you will simply create a wxDynamicSashWindow
-    using either the Create() function or the more complex constructor
-    provided below, and then create a view window whose parent is the
-    wxDynamicSashWindow.  The child should respond to
-    wxDynamicSashSplitEvents -- perhaps with an OnSplit() event handler -- by
-    constructing a new view window whose parent is also the
-    wxDynamicSashWindow.  That's it!  Now your users can dynamically split
-    and reunify the view you provided.
-
-    If you wish to handle the scrollbar events for your view, rather than
-    allowing wxDynamicSashWindow to do it for you, things are a bit more
-    complex.  (You might want to handle scrollbar events yourself, if,
-    for instance, you wish to scroll a subwindow of the view you add to
-    your wxDynamicSashWindow object, rather than scrolling the whole view.)
-    In this case, you will need to construct your wxDynamicSashWindow without
-    the wxDS_MANAGE_SCROLLBARS style and  you will need to use the
-    GetHScrollBar() and GetVScrollBar() methods to retrieve the scrollbar
-    controls and call SetEventHanler() on them to redirect the scrolling
-    events whenever your window is reparented by wxDyanmicSashWindow.
-    You will need to set the scrollbars' event handler at three times:
-
-        *  When your view is created
-        *  When your view receives a wxDynamicSashSplitEvent
-        *  When your view receives a wxDynamicSashUnifyEvent
-
-    See the dynsash_switch sample application for an example which does this.
-
-*/
-
-class wxDynamicSashWindow : public wxWindow {
-public:
-    wxDynamicSashWindow(wxWindow *parent, wxWindowID id,
-                        const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize,
-                        long style = wxCLIP_CHILDREN | wxDS_MANAGE_SCROLLBARS | wxDS_DRAG_CORNER,
-                        const char* name = "dynamicSashWindow");
-    %name(wxPreDynamicSashWindow)wxDynamicSashWindow();
-
-    bool Create(wxWindow *parent, wxWindowID id,
-                const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize,
-                long style = wxCLIP_CHILDREN | wxDS_MANAGE_SCROLLBARS | wxDS_DRAG_CORNER,
-                const char* name = "dynamicSashWindow");
-
-    %pragma(python) addtomethod = "__init__:self._setOORInfo(self)"
-    %pragma(python) addtomethod = "wxPreDynamicSashWindow:val._setOORInfo(val)"
-
-    wxScrollBar *GetHScrollBar(const wxWindow *child) const;
-    wxScrollBar *GetVScrollBar(const wxWindow *child) const;
-};
-
-
-
-//----------------------------------------------------------------------
-// Python functions to act like the event macros
-
-%pragma(python) code = "
-def EVT_DYNAMIC_SASH_SPLIT(win, id, func):
-    win.Connect(id, -1, wxEVT_DYNAMIC_SASH_SPLIT, func)
-
-def EVT_DYNAMIC_SASH_UNIFY(win, id, func):
-    win.Connect(id, -1, wxEVT_DYNAMIC_SASH_UNIFY, func)
-"
-
-//----------------------------------------------------------------------
-//----------------------------------------------------------------------
-
-enum {
-    wxEL_ALLOW_NEW,
-    wxEL_ALLOW_EDIT,
-    wxEL_ALLOW_DELETE,
-};
-
-// This class provides a composite control that lets the
-// user easily enter list of strings
-class wxEditableListBox : public wxPanel
-{
-public:
-    wxEditableListBox(wxWindow *parent, wxWindowID id,
-                      const wxString& label,
-                      const wxPoint& pos = wxDefaultPosition,
-                      const wxSize& size = wxDefaultSize,
-                      long style = wxEL_ALLOW_NEW | wxEL_ALLOW_EDIT | wxEL_ALLOW_DELETE,
-                      const char* name = "editableListBox");
-
-    %pragma(python) addtomethod = "__init__:self._setOORInfo(self)"
-
-    void SetStrings(const wxArrayString& strings);
-
-    //void GetStrings(wxArrayString& strings);
-    %addmethods {
-        PyObject* GetStrings() {
-            wxArrayString strings;
-            self->GetStrings(strings);
-            return wxArrayString2PyList_helper(strings);
-        }
-    }
-};
-
-
-
-//----------------------------------------------------------------------
-
-
-/*
- * wxRemotelyScrolledTreeCtrl
- *
- * This tree control disables its vertical scrollbar and catches scroll
- * events passed by a scrolled window higher in the hierarchy.
- * It also updates the scrolled window vertical scrollbar as appropriate.
- */
-
-%{
-    typedef wxTreeCtrl wxPyTreeCtrl;
-%}
-
-class wxRemotelyScrolledTreeCtrl: public wxPyTreeCtrl
-{
-public:
-    wxRemotelyScrolledTreeCtrl(wxWindow* parent, wxWindowID id,
-                               const wxPoint& pos = wxDefaultPosition,
-                               const wxSize& size = wxDefaultSize,
-                               long style = wxTR_HAS_BUTTONS);
-    %pragma(python) addtomethod = "__init__:self._setOORInfo(self)"
-
-
-    void HideVScrollbar();
-
-    // Adjust the containing wxScrolledWindow's scrollbars appropriately
-    void AdjustRemoteScrollbars();
-
-    // Find the scrolled window that contains this control
-    wxScrolledWindow* GetScrolledWindow() const;
-
-    // Scroll to the given line (in scroll units where each unit is
-    // the height of an item)
-    void ScrollToLine(int posHoriz, int posVert);
-
-    // The companion window is one which will get notified when certain
-    // events happen such as node expansion
-    void SetCompanionWindow(wxWindow* companion);
-    wxWindow* GetCompanionWindow() const;
-};
-
-
-
-/*
- * wxTreeCompanionWindow
- *
- * A window displaying values associated with tree control items.
- */
-
-%{
-class wxPyTreeCompanionWindow: public wxTreeCompanionWindow
-{
-public:
-    wxPyTreeCompanionWindow(wxWindow* parent, wxWindowID id = -1,
-                            const wxPoint& pos = wxDefaultPosition,
-                            const wxSize& size = wxDefaultSize,
-                            long style = 0)
-        : wxTreeCompanionWindow(parent, id, pos, size, style) {}
-
-
-    virtual void DrawItem(wxDC& dc, wxTreeItemId id, const wxRect& rect) {
-        bool found;
-        wxPyBeginBlockThreads();
-        if ((found = wxPyCBH_findCallback(m_myInst, "DrawItem"))) {
-            PyObject* dcobj = wxPyMake_wxObject(&dc);
-            PyObject* idobj = wxPyConstructObject((void*)&id, "wxTreeItemId", FALSE);
-            PyObject* recobj= wxPyConstructObject((void*)&rect, "wxRect", FALSE);
-            wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OOO)", dcobj, idobj, recobj));
-            Py_DECREF(dcobj);
-            Py_DECREF(idobj);
-            Py_DECREF(recobj);
-        }
-        wxPyEndBlockThreads();
-        if (! found)
-            wxTreeCompanionWindow::DrawItem(dc, id, rect);
-    }
-
-    PYPRIVATE;
-};
-%}
-
-
-%name(wxTreeCompanionWindow) class wxPyTreeCompanionWindow: public wxWindow
-{
-public:
-    wxPyTreeCompanionWindow(wxWindow* parent, wxWindowID id = -1,
-                            const wxPoint& pos = wxDefaultPosition,
-                            const wxSize& size = wxDefaultSize,
-                            long style = 0);
-    void _setCallbackInfo(PyObject* self, PyObject* _class);
-    %pragma(python) addtomethod = "__init__:self._setCallbackInfo(self, wxTreeCompanionWindow)"
-    %pragma(python) addtomethod = "__init__:self._setOORInfo(self)"
-
-    wxRemotelyScrolledTreeCtrl* GetTreeCtrl() const;
-    void SetTreeCtrl(wxRemotelyScrolledTreeCtrl* treeCtrl);
-};
-
-
-
-/*
- * wxThinSplitterWindow
- *
- * Implements a splitter with a less obvious sash
- * than the usual one.
- */
-
-class wxThinSplitterWindow: public wxSplitterWindow
-{
-public:
-    wxThinSplitterWindow(wxWindow* parent, wxWindowID id = -1,
-                         const wxPoint& pos = wxDefaultPosition,
-                         const wxSize& size = wxDefaultSize,
-                         long style = wxSP_3D | wxCLIP_CHILDREN);
-    %pragma(python) addtomethod = "__init__:self._setOORInfo(self)"
-
-};
-
-
-/*
- * wxSplitterScrolledWindow
- *
- * This scrolled window is aware of the fact that one of its
- * children is a splitter window. It passes on its scroll events
- * (after some processing) to both splitter children for them
- * scroll appropriately.
- */
-
-class wxSplitterScrolledWindow: public wxScrolledWindow
-{
-public:
-    wxSplitterScrolledWindow(wxWindow* parent, wxWindowID id = -1,
-                             const wxPoint& pos = wxDefaultPosition,
-                             const wxSize& size = wxDefaultSize,
-                             long style = 0);
-    %pragma(python) addtomethod = "__init__:self._setOORInfo(self)"
-};
-
-
-//----------------------------------------------------------------------
-//----------------------------------------------------------------------
-
-
-enum wxLEDValueAlign
-{
-    wxLED_ALIGN_LEFT,
-    wxLED_ALIGN_RIGHT,
-    wxLED_ALIGN_CENTER,
-
-    wxLED_ALIGN_MASK,
-
-    wxLED_DRAW_FADED,
-};
-
-
-class wxLEDNumberCtrl :	public wxControl
-{
-public:
-    // Constructors.
-    wxLEDNumberCtrl(wxWindow *parent, wxWindowID id = -1,
-                    const wxPoint& pos = wxDefaultPosition,
-                    const wxSize& size = wxDefaultSize,
-                    long style =  wxLED_ALIGN_LEFT | wxLED_DRAW_FADED);
-    %name(wxPreLEDNumberCtrl) wxLEDNumberCtrl();
-
-    %pragma(python) addtomethod = "__init__:self._setOORInfo(self)"
-    %pragma(python) addtomethod = "wxPreLEDNumberCtrl:val._setOORInfo(val)"
-
-    // Create functions.
-    bool Create(wxWindow *parent, wxWindowID id = -1,
-                    const wxPoint& pos = wxDefaultPosition,
-                    const wxSize& size = wxDefaultSize,
-                    long style = wxLED_ALIGN_LEFT | wxLED_DRAW_FADED);
-
-    wxLEDValueAlign GetAlignment() const { return m_Alignment; }
-    bool GetDrawFaded() const { return m_DrawFaded; }
-    const wxString &GetValue() const { return m_Value; }
-
-    void SetAlignment(wxLEDValueAlign Alignment, bool Redraw = true);
-    void SetDrawFaded(bool DrawFaded, bool Redraw = true);
-    void SetValue(const wxString &Value, bool Redraw = true);
-
-};
-
-//----------------------------------------------------------------------
-//----------------------------------------------------------------------
-
-%init %{
-
-    wxClassInfo::CleanUpClasses();
-    wxClassInfo::InitializeClasses();
-
-    wxPyPtrTypeMap_Add("wxTreeCompanionWindow", "wxPyTreeCompanionWindow");
-%}
-
-
-%pragma(python) include="_gizmoextras.py";
-
-//----------------------------------------------------------------------
-//----------------------------------------------------------------------
-
-
-
-
-
-

wxPython/contrib/gizmos/gizmos.py

@@ -1,298 +0,0 @@
-# This file was created automatically by SWIG.
-import gizmosc
-
-from misc import *
-
-from misc2 import *
-
-from windows import *
-
-from gdi import *
-
-from clip_dnd import *
-
-from events import *
-
-from streams import *
-
-from utils import *
-
-from mdi import *
-
-from frames import *
-
-from stattool import *
-
-from controls import *
-
-from controls2 import *
-
-from windows2 import *
-
-from cmndlgs import *
-
-from windows3 import *
-
-from image import *
-
-from printfw import *
-
-from sizers import *
-
-from filesys import *
-
-def EVT_DYNAMIC_SASH_SPLIT(win, id, func):
-    win.Connect(id, -1, wxEVT_DYNAMIC_SASH_SPLIT, func)
-
-def EVT_DYNAMIC_SASH_UNIFY(win, id, func):
-    win.Connect(id, -1, wxEVT_DYNAMIC_SASH_UNIFY, func)
-
-class wxDynamicSashSplitEventPtr(wxCommandEventPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def __repr__(self):
-        return "<C wxDynamicSashSplitEvent instance at %s>" % (self.this,)
-class wxDynamicSashSplitEvent(wxDynamicSashSplitEventPtr):
-    def __init__(self,*_args,**_kwargs):
-        self.this = apply(gizmosc.new_wxDynamicSashSplitEvent,_args,_kwargs)
-        self.thisown = 1
-
-
-
-
-class wxDynamicSashUnifyEventPtr(wxCommandEventPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def __repr__(self):
-        return "<C wxDynamicSashUnifyEvent instance at %s>" % (self.this,)
-class wxDynamicSashUnifyEvent(wxDynamicSashUnifyEventPtr):
-    def __init__(self,*_args,**_kwargs):
-        self.this = apply(gizmosc.new_wxDynamicSashUnifyEvent,_args,_kwargs)
-        self.thisown = 1
-
-
-
-
-class wxDynamicSashWindowPtr(wxWindowPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def Create(self, *_args, **_kwargs):
-        val = apply(gizmosc.wxDynamicSashWindow_Create,(self,) + _args, _kwargs)
-        return val
-    def GetHScrollBar(self, *_args, **_kwargs):
-        val = apply(gizmosc.wxDynamicSashWindow_GetHScrollBar,(self,) + _args, _kwargs)
-        if val: val = wxScrollBarPtr(val) 
-        return val
-    def GetVScrollBar(self, *_args, **_kwargs):
-        val = apply(gizmosc.wxDynamicSashWindow_GetVScrollBar,(self,) + _args, _kwargs)
-        if val: val = wxScrollBarPtr(val) 
-        return val
-    def __repr__(self):
-        return "<C wxDynamicSashWindow instance at %s>" % (self.this,)
-class wxDynamicSashWindow(wxDynamicSashWindowPtr):
-    def __init__(self,*_args,**_kwargs):
-        self.this = apply(gizmosc.new_wxDynamicSashWindow,_args,_kwargs)
-        self.thisown = 1
-        self._setOORInfo(self)
-
-
-
-def wxPreDynamicSashWindow(*_args,**_kwargs):
-    val = wxDynamicSashWindowPtr(apply(gizmosc.new_wxPreDynamicSashWindow,_args,_kwargs))
-    val.thisown = 1
-    val._setOORInfo(val)
-    return val
-
-
-class wxEditableListBoxPtr(wxPanelPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def SetStrings(self, *_args, **_kwargs):
-        val = apply(gizmosc.wxEditableListBox_SetStrings,(self,) + _args, _kwargs)
-        return val
-    def GetStrings(self, *_args, **_kwargs):
-        val = apply(gizmosc.wxEditableListBox_GetStrings,(self,) + _args, _kwargs)
-        return val
-    def __repr__(self):
-        return "<C wxEditableListBox instance at %s>" % (self.this,)
-class wxEditableListBox(wxEditableListBoxPtr):
-    def __init__(self,*_args,**_kwargs):
-        self.this = apply(gizmosc.new_wxEditableListBox,_args,_kwargs)
-        self.thisown = 1
-        self._setOORInfo(self)
-
-
-
-
-class wxRemotelyScrolledTreeCtrlPtr(wxTreeCtrlPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def HideVScrollbar(self, *_args, **_kwargs):
-        val = apply(gizmosc.wxRemotelyScrolledTreeCtrl_HideVScrollbar,(self,) + _args, _kwargs)
-        return val
-    def AdjustRemoteScrollbars(self, *_args, **_kwargs):
-        val = apply(gizmosc.wxRemotelyScrolledTreeCtrl_AdjustRemoteScrollbars,(self,) + _args, _kwargs)
-        return val
-    def GetScrolledWindow(self, *_args, **_kwargs):
-        val = apply(gizmosc.wxRemotelyScrolledTreeCtrl_GetScrolledWindow,(self,) + _args, _kwargs)
-        if val: val = wxScrolledWindowPtr(val) 
-        return val
-    def ScrollToLine(self, *_args, **_kwargs):
-        val = apply(gizmosc.wxRemotelyScrolledTreeCtrl_ScrollToLine,(self,) + _args, _kwargs)
-        return val
-    def SetCompanionWindow(self, *_args, **_kwargs):
-        val = apply(gizmosc.wxRemotelyScrolledTreeCtrl_SetCompanionWindow,(self,) + _args, _kwargs)
-        return val
-    def GetCompanionWindow(self, *_args, **_kwargs):
-        val = apply(gizmosc.wxRemotelyScrolledTreeCtrl_GetCompanionWindow,(self,) + _args, _kwargs)
-        return val
-    def __repr__(self):
-        return "<C wxRemotelyScrolledTreeCtrl instance at %s>" % (self.this,)
-class wxRemotelyScrolledTreeCtrl(wxRemotelyScrolledTreeCtrlPtr):
-    def __init__(self,*_args,**_kwargs):
-        self.this = apply(gizmosc.new_wxRemotelyScrolledTreeCtrl,_args,_kwargs)
-        self.thisown = 1
-        self._setOORInfo(self)
-
-
-
-
-class wxTreeCompanionWindowPtr(wxWindowPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def _setCallbackInfo(self, *_args, **_kwargs):
-        val = apply(gizmosc.wxTreeCompanionWindow__setCallbackInfo,(self,) + _args, _kwargs)
-        return val
-    def GetTreeCtrl(self, *_args, **_kwargs):
-        val = apply(gizmosc.wxTreeCompanionWindow_GetTreeCtrl,(self,) + _args, _kwargs)
-        if val: val = wxRemotelyScrolledTreeCtrlPtr(val) 
-        return val
-    def SetTreeCtrl(self, *_args, **_kwargs):
-        val = apply(gizmosc.wxTreeCompanionWindow_SetTreeCtrl,(self,) + _args, _kwargs)
-        return val
-    def __repr__(self):
-        return "<C wxTreeCompanionWindow instance at %s>" % (self.this,)
-class wxTreeCompanionWindow(wxTreeCompanionWindowPtr):
-    def __init__(self,*_args,**_kwargs):
-        self.this = apply(gizmosc.new_wxTreeCompanionWindow,_args,_kwargs)
-        self.thisown = 1
-        self._setCallbackInfo(self, wxTreeCompanionWindow)
-        self._setOORInfo(self)
-
-
-
-
-class wxThinSplitterWindowPtr(wxSplitterWindowPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def __repr__(self):
-        return "<C wxThinSplitterWindow instance at %s>" % (self.this,)
-class wxThinSplitterWindow(wxThinSplitterWindowPtr):
-    def __init__(self,*_args,**_kwargs):
-        self.this = apply(gizmosc.new_wxThinSplitterWindow,_args,_kwargs)
-        self.thisown = 1
-        self._setOORInfo(self)
-
-
-
-
-class wxSplitterScrolledWindowPtr(wxScrolledWindowPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def __repr__(self):
-        return "<C wxSplitterScrolledWindow instance at %s>" % (self.this,)
-class wxSplitterScrolledWindow(wxSplitterScrolledWindowPtr):
-    def __init__(self,*_args,**_kwargs):
-        self.this = apply(gizmosc.new_wxSplitterScrolledWindow,_args,_kwargs)
-        self.thisown = 1
-        self._setOORInfo(self)
-
-
-
-
-class wxLEDNumberCtrlPtr(wxControlPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def Create(self, *_args, **_kwargs):
-        val = apply(gizmosc.wxLEDNumberCtrl_Create,(self,) + _args, _kwargs)
-        return val
-    def GetAlignment(self, *_args, **_kwargs):
-        val = apply(gizmosc.wxLEDNumberCtrl_GetAlignment,(self,) + _args, _kwargs)
-        return val
-    def GetDrawFaded(self, *_args, **_kwargs):
-        val = apply(gizmosc.wxLEDNumberCtrl_GetDrawFaded,(self,) + _args, _kwargs)
-        return val
-    def GetValue(self, *_args, **_kwargs):
-        val = apply(gizmosc.wxLEDNumberCtrl_GetValue,(self,) + _args, _kwargs)
-        return val
-    def SetAlignment(self, *_args, **_kwargs):
-        val = apply(gizmosc.wxLEDNumberCtrl_SetAlignment,(self,) + _args, _kwargs)
-        return val
-    def SetDrawFaded(self, *_args, **_kwargs):
-        val = apply(gizmosc.wxLEDNumberCtrl_SetDrawFaded,(self,) + _args, _kwargs)
-        return val
-    def SetValue(self, *_args, **_kwargs):
-        val = apply(gizmosc.wxLEDNumberCtrl_SetValue,(self,) + _args, _kwargs)
-        return val
-    def __repr__(self):
-        return "<C wxLEDNumberCtrl instance at %s>" % (self.this,)
-class wxLEDNumberCtrl(wxLEDNumberCtrlPtr):
-    def __init__(self,*_args,**_kwargs):
-        self.this = apply(gizmosc.new_wxLEDNumberCtrl,_args,_kwargs)
-        self.thisown = 1
-        self._setOORInfo(self)
-
-
-
-def wxPreLEDNumberCtrl(*_args,**_kwargs):
-    val = wxLEDNumberCtrlPtr(apply(gizmosc.new_wxPreLEDNumberCtrl,_args,_kwargs))
-    val.thisown = 1
-    val._setOORInfo(val)
-    return val
-
-
-
-
-#-------------- FUNCTION WRAPPERS ------------------
-
-
-
-#-------------- VARIABLE WRAPPERS ------------------
-
-wxEVT_DYNAMIC_SASH_SPLIT = gizmosc.wxEVT_DYNAMIC_SASH_SPLIT
-wxEVT_DYNAMIC_SASH_UNIFY = gizmosc.wxEVT_DYNAMIC_SASH_UNIFY
-wxDS_MANAGE_SCROLLBARS = gizmosc.wxDS_MANAGE_SCROLLBARS
-wxDS_DRAG_CORNER = gizmosc.wxDS_DRAG_CORNER
-wxEL_ALLOW_NEW = gizmosc.wxEL_ALLOW_NEW
-wxEL_ALLOW_EDIT = gizmosc.wxEL_ALLOW_EDIT
-wxEL_ALLOW_DELETE = gizmosc.wxEL_ALLOW_DELETE
-wxLED_ALIGN_LEFT = gizmosc.wxLED_ALIGN_LEFT
-wxLED_ALIGN_RIGHT = gizmosc.wxLED_ALIGN_RIGHT
-wxLED_ALIGN_CENTER = gizmosc.wxLED_ALIGN_CENTER
-wxLED_ALIGN_MASK = gizmosc.wxLED_ALIGN_MASK
-wxLED_DRAW_FADED = gizmosc.wxLED_DRAW_FADED
-
-
-#-------------- USER INCLUDE -----------------------
-
-# Stuff these names into the wx namespace so wxPyConstructObject can find them
-
-wx.wxDynamicSashSplitEventPtr       = wxDynamicSashSplitEventPtr
-wx.wxDynamicSashUnifyEventPtr       = wxDynamicSashUnifyEventPtr
-wx.wxDynamicSashWindowPtr           = wxDynamicSashWindowPtr
-
-wx.wxEditableListBoxPtr             = wxEditableListBoxPtr
-
-wx.wxRemotelyScrolledTreeCtrlPtr    = wxRemotelyScrolledTreeCtrlPtr
-wx.wxTreeCompanionWindowPtr         = wxTreeCompanionWindowPtr
-wx.wxThinSplitterWindowPtr          = wxThinSplitterWindowPtr
-wx.wxSplitterScrolledWindowPtr      = wxSplitterScrolledWindowPtr

wxPython/contrib/glcanvas/.cvsignore

@@ -1,14 +0,0 @@
-
-*.exp
-*.lib
-*.obj
-*.pch
-Makefile
-Makefile.pre
-Setup
-build.local
-config.c
-glcanvas.h
-glcanvasc.ilk
-glcanvasc.pyd
-sedscript

wxPython/contrib/glcanvas/glcanvas.i

@@ -1,170 +0,0 @@
-/////////////////////////////////////////////////////////////////////////////
-// Name:        glcanvas.i
-// Purpose:     SWIG definitions for the OpenGL wxWindows classes
-//
-// Author:      Robin Dunn
-//
-// Created:     15-Mar-1999
-// RCS-ID:      $Id$
-// Copyright:   (c) 1998 by Total Control Software
-// Licence:     wxWindows license
-/////////////////////////////////////////////////////////////////////////////
-
-
-%module glcanvas
-
-%{
-#include "export.h"
-#ifdef __WXMSW__
-#include "myglcanvas.h"
-#else
-#include <wx/glcanvas.h>
-#endif
-
-%}
-
-//---------------------------------------------------------------------------
-
-%include typemaps.i
-%include my_typemaps.i
-
-%extern wx.i
-%extern windows.i
-%extern windows2.i
-%extern windows3.i
-%extern frames.i
-%extern _defs.i
-%extern misc.i
-%extern gdi.i
-%extern controls.i
-%extern events.i
-
-
-%pragma(python) code = "import wx"
-
-//---------------------------------------------------------------------------
-
-class wxPalette;
-class wxWindow;
-class wxSize;
-class wxPoint;
-class wxGLCanvas;
-
-//---------------------------------------------------------------------------
-
-class wxGLContext : public wxObject {
-public:
-#ifndef __WXMAC__  //  fix this?
-    wxGLContext(bool isRGB, wxGLCanvas *win,
-                const wxPalette& palette = wxNullPalette);
-#endif
-    ~wxGLContext();
-
-    void SetCurrent();
-    void SetColour(const char *colour);
-    void SwapBuffers();
-
-#ifdef __WXGTK__
-    void SetupPixelFormat();
-    void SetupPalette(const wxPalette& palette);
-    wxPalette CreateDefaultPalette();
-    wxPalette* GetPalette();
-#endif
-
-    wxWindow* GetWindow();
-};
-
-//---------------------------------------------------------------------------
-
-enum {
-    WX_GL_RGBA,              // use true color palette
-    WX_GL_BUFFER_SIZE,       // bits for buffer if not WX_GL_RGBA
-    WX_GL_LEVEL,             // 0 for main buffer, >0 for overlay, <0 for underlay
-    WX_GL_DOUBLEBUFFER,      // use doublebuffer
-    WX_GL_STEREO,            // use stereoscopic display
-    WX_GL_AUX_BUFFERS,       // number of auxiliary buffers
-    WX_GL_MIN_RED,           // use red buffer with most bits (> MIN_RED bits)
-    WX_GL_MIN_GREEN,         // use green buffer with most bits (> MIN_GREEN bits)
-    WX_GL_MIN_BLUE,          // use blue buffer with most bits (> MIN_BLUE bits)
-    WX_GL_MIN_ALPHA,         // use blue buffer with most bits (> MIN_ALPHA bits)
-    WX_GL_DEPTH_SIZE,        // bits for Z-buffer (0,16,32)
-    WX_GL_STENCIL_SIZE,      // bits for stencil buffer
-    WX_GL_MIN_ACCUM_RED,     // use red accum buffer with most bits (> MIN_ACCUM_RED bits)
-    WX_GL_MIN_ACCUM_GREEN,   // use green buffer with most bits (> MIN_ACCUM_GREEN bits)
-    WX_GL_MIN_ACCUM_BLUE,    // use blue buffer with most bits (> MIN_ACCUM_BLUE bits)
-    WX_GL_MIN_ACCUM_ALPHA    // use blue buffer with most bits (> MIN_ACCUM_ALPHA bits)
-};
-
-
-%typemap(python, in) int *attribList (int *temp) {
-    int i;
-    if (PySequence_Check($source)) {
-        int size = PyObject_Length($source);
-        temp = new int[size+1]; // (int*)malloc((size + 1) * sizeof(int));
-        for (i = 0; i < size; i++) {
-            temp[i] = PyInt_AsLong(PySequence_GetItem($source, i));
-        }
-        temp[size] = 0;
-        $target = temp;
-    }
-}
-
-%typemap(python, freearg) int *attribList
-{
-    delete [] $source;
-}
-
-
-
-class wxGLCanvas : public wxWindow {
-public:
-    wxGLCanvas(wxWindow *parent, wxWindowID id = -1,
-               const wxPoint& pos = wxDefaultPosition,
-               const wxSize& size = wxDefaultSize, long style = 0,
-               const char* name = "GLCanvas",
-               int *attribList = NULL,
-               const wxPalette& palette = wxNullPalette);
-
-    %name(wxGLCanvasWithContext)
-        wxGLCanvas( wxWindow *parent,
-                    const wxGLContext *shared = NULL,
-                    wxWindowID id = -1,
-                    const wxPoint& pos = wxDefaultPosition,
-                    const wxSize& size = wxDefaultSize,
-                    long style = 0,
-                    const char* name = "GLCanvas",
-                    int *attribList = NULL,
-                    const wxPalette& palette = wxNullPalette );
-
-//      bool Create(wxWindow *parent, wxWindowID id,
-//                  const wxPoint& pos, const wxSize& size, long style, const wxString& name);
-
-    %pragma(python) addtomethod = "__init__:self._setOORInfo(self)"
-    %pragma(python) addtomethod = "wxGLCanvasWithContext:val._setOORInfo(self)"
-
-    void SetCurrent();
-    void SetColour(const char *colour);
-    void SwapBuffers();
-
-    wxGLContext* GetContext();
-
-#ifdef __WXMSW__
-    void SetupPixelFormat(int *attribList = NULL);
-    void SetupPalette(const wxPalette& palette);
-    wxPalette CreateDefaultPalette();
-    wxPalette* GetPalette();
-#endif
-};
-
-
-//---------------------------------------------------------------------------
-
-%init %{
-
-    wxClassInfo::CleanUpClasses();
-    wxClassInfo::InitializeClasses();
-
-%}
-
-//---------------------------------------------------------------------------
-//---------------------------------------------------------------------------

wxPython/contrib/glcanvas/gtk/.cvsignore

@@ -1,2 +0,0 @@
-*~
-_glcanvas.cpp

wxPython/contrib/glcanvas/gtk/glcanvas.cpp

@@ -1,915 +0,0 @@
-/*
- * FILE : contrib/glcanvas/gtk/glcanvas.cpp
- * 
- * This file was automatically generated by :
- * Simplified Wrapper and Interface Generator (SWIG)
- * Version 1.1 (Build 883)
- * 
- * Portions Copyright (c) 1995-1998
- * The University of Utah and The Regents of the University of California.
- * Permission is granted to distribute this file in any manner provided
- * this notice remains intact.
- * 
- * Do not make changes to this file--changes will be lost!
- *
- */
-
-
-#define SWIGCODE
-/* Implementation : PYTHON */
-
-#define SWIGPYTHON
-#include <string.h>
-#include <stdlib.h>
-/* Definitions for Windows/Unix exporting */
-#if defined(__WIN32__)
-#   if defined(_MSC_VER)
-#	define SWIGEXPORT(a) __declspec(dllexport) a
-#   else
-#	if defined(__BORLANDC__)
-#	    define SWIGEXPORT(a) a _export
-#	else
-#	    define SWIGEXPORT(a) a
-#	endif
-#   endif
-#else
-#   define SWIGEXPORT(a) a
-#endif
-
-#include "Python.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-extern void SWIG_MakePtr(char *, void *, char *);
-extern void SWIG_RegisterMapping(char *, char *, void *(*)(void *));
-extern char *SWIG_GetPtr(char *, void **, char *);
-extern char *SWIG_GetPtrObj(PyObject *, void **, char *);
-extern void SWIG_addvarlink(PyObject *, char *, PyObject *(*)(void), int (*)(PyObject *));
-extern PyObject *SWIG_newvarlink(void);
-#ifdef __cplusplus
-}
-#endif
-#define SWIG_init    initglcanvasc
-
-#define SWIG_name    "glcanvasc"
-
-#include "export.h"
-#ifdef __WXMSW__
-#include "myglcanvas.h"
-#else
-#include <wx/glcanvas.h>
-#endif
-
-
-
-static PyObject* t_output_helper(PyObject* target, PyObject* o) {
-    PyObject*   o2;
-    PyObject*   o3;
-
-    if (!target) {
-        target = o;
-    } else if (target == Py_None) {
-        Py_DECREF(Py_None);
-        target = o;
-    } else {
-        if (!PyTuple_Check(target)) {
-            o2 = target;
-            target = PyTuple_New(1);
-            PyTuple_SetItem(target, 0, o2);
-        }
-        o3 = PyTuple_New(1);
-        PyTuple_SetItem(o3, 0, o);
-
-        o2 = target;
-        target = PySequence_Concat(o2, o3);
-        Py_DECREF(o2);
-        Py_DECREF(o3);
-    }
-    return target;
-}
-
-#if PYTHON_API_VERSION >= 1009
-    static char* wxStringErrorMsg = "String or Unicode type required";
-#else
-    static char* wxStringErrorMsg = "String type required";
-#endif
-#ifdef __cplusplus
-extern "C" {
-#endif
-static void *SwigwxGLContextTowxObject(void *ptr) {
-    wxGLContext *src;
-    wxObject *dest;
-    src = (wxGLContext *) ptr;
-    dest = (wxObject *) src;
-    return (void *) dest;
-}
-
-#define new_wxGLContext(_swigarg0,_swigarg1,_swigarg2) (new wxGLContext(_swigarg0,_swigarg1,_swigarg2))
-static PyObject *_wrap_new_wxGLContext(PyObject *self, PyObject *args, PyObject *kwargs) {
-    PyObject * _resultobj;
-    wxGLContext * _result;
-    bool  _arg0;
-    wxGLCanvas * _arg1;
-    wxPalette * _arg2 = (wxPalette *) &wxNullPalette;
-    int tempbool0;
-    PyObject * _argo1 = 0;
-    PyObject * _argo2 = 0;
-    char *_kwnames[] = { "isRGB","win","palette", NULL };
-    char _ptemp[128];
-
-    self = self;
-    if(!PyArg_ParseTupleAndKeywords(args,kwargs,"iO|O:new_wxGLContext",_kwnames,&tempbool0,&_argo1,&_argo2)) 
-        return NULL;
-    _arg0 = (bool ) tempbool0;
-    if (_argo1) {
-        if (_argo1 == Py_None) { _arg1 = NULL; }
-        else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxGLCanvas_p")) {
-            PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of new_wxGLContext. Expected _wxGLCanvas_p.");
-        return NULL;
-        }
-    }
-    if (_argo2) {
-        if (_argo2 == Py_None) { _arg2 = NULL; }
-        else if (SWIG_GetPtrObj(_argo2,(void **) &_arg2,"_wxPalette_p")) {
-            PyErr_SetString(PyExc_TypeError,"Type error in argument 3 of new_wxGLContext. Expected _wxPalette_p.");
-        return NULL;
-        }
-    }
-{
-    PyThreadState* __tstate = wxPyBeginAllowThreads();
-        _result = (wxGLContext *)new_wxGLContext(_arg0,_arg1,*_arg2);
-
-    wxPyEndAllowThreads(__tstate);
-    if (PyErr_Occurred()) return NULL;
-}    if (_result) {
-        SWIG_MakePtr(_ptemp, (char *) _result,"_wxGLContext_p");
-        _resultobj = Py_BuildValue("s",_ptemp);
-    } else {
-        Py_INCREF(Py_None);
-        _resultobj = Py_None;
-    }
-    return _resultobj;
-}
-
-#define delete_wxGLContext(_swigobj) (delete _swigobj)
-static PyObject *_wrap_delete_wxGLContext(PyObject *self, PyObject *args, PyObject *kwargs) {
-    PyObject * _resultobj;
-    wxGLContext * _arg0;
-    PyObject * _argo0 = 0;
-    char *_kwnames[] = { "self", NULL };
-
-    self = self;
-    if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:delete_wxGLContext",_kwnames,&_argo0)) 
-        return NULL;
-    if (_argo0) {
-        if (_argo0 == Py_None) { _arg0 = NULL; }
-        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGLContext_p")) {
-            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of delete_wxGLContext. Expected _wxGLContext_p.");
-        return NULL;
-        }
-    }
-{
-    PyThreadState* __tstate = wxPyBeginAllowThreads();
-        delete_wxGLContext(_arg0);
-
-    wxPyEndAllowThreads(__tstate);
-    if (PyErr_Occurred()) return NULL;
-}    Py_INCREF(Py_None);
-    _resultobj = Py_None;
-    return _resultobj;
-}
-
-#define wxGLContext_SetCurrent(_swigobj)  (_swigobj->SetCurrent())
-static PyObject *_wrap_wxGLContext_SetCurrent(PyObject *self, PyObject *args, PyObject *kwargs) {
-    PyObject * _resultobj;
-    wxGLContext * _arg0;
-    PyObject * _argo0 = 0;
-    char *_kwnames[] = { "self", NULL };
-
-    self = self;
-    if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGLContext_SetCurrent",_kwnames,&_argo0)) 
-        return NULL;
-    if (_argo0) {
-        if (_argo0 == Py_None) { _arg0 = NULL; }
-        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGLContext_p")) {
-            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGLContext_SetCurrent. Expected _wxGLContext_p.");
-        return NULL;
-        }
-    }
-{
-    PyThreadState* __tstate = wxPyBeginAllowThreads();
-        wxGLContext_SetCurrent(_arg0);
-
-    wxPyEndAllowThreads(__tstate);
-    if (PyErr_Occurred()) return NULL;
-}    Py_INCREF(Py_None);
-    _resultobj = Py_None;
-    return _resultobj;
-}
-
-#define wxGLContext_SetColour(_swigobj,_swigarg0)  (_swigobj->SetColour(_swigarg0))
-static PyObject *_wrap_wxGLContext_SetColour(PyObject *self, PyObject *args, PyObject *kwargs) {
-    PyObject * _resultobj;
-    wxGLContext * _arg0;
-    char * _arg1;
-    PyObject * _argo0 = 0;
-    char *_kwnames[] = { "self","colour", NULL };
-
-    self = self;
-    if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Os:wxGLContext_SetColour",_kwnames,&_argo0,&_arg1)) 
-        return NULL;
-    if (_argo0) {
-        if (_argo0 == Py_None) { _arg0 = NULL; }
-        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGLContext_p")) {
-            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGLContext_SetColour. Expected _wxGLContext_p.");
-        return NULL;
-        }
-    }
-{
-    PyThreadState* __tstate = wxPyBeginAllowThreads();
-        wxGLContext_SetColour(_arg0,_arg1);
-
-    wxPyEndAllowThreads(__tstate);
-    if (PyErr_Occurred()) return NULL;
-}    Py_INCREF(Py_None);
-    _resultobj = Py_None;
-    return _resultobj;
-}
-
-#define wxGLContext_SwapBuffers(_swigobj)  (_swigobj->SwapBuffers())
-static PyObject *_wrap_wxGLContext_SwapBuffers(PyObject *self, PyObject *args, PyObject *kwargs) {
-    PyObject * _resultobj;
-    wxGLContext * _arg0;
-    PyObject * _argo0 = 0;
-    char *_kwnames[] = { "self", NULL };
-
-    self = self;
-    if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGLContext_SwapBuffers",_kwnames,&_argo0)) 
-        return NULL;
-    if (_argo0) {
-        if (_argo0 == Py_None) { _arg0 = NULL; }
-        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGLContext_p")) {
-            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGLContext_SwapBuffers. Expected _wxGLContext_p.");
-        return NULL;
-        }
-    }
-{
-    PyThreadState* __tstate = wxPyBeginAllowThreads();
-        wxGLContext_SwapBuffers(_arg0);
-
-    wxPyEndAllowThreads(__tstate);
-    if (PyErr_Occurred()) return NULL;
-}    Py_INCREF(Py_None);
-    _resultobj = Py_None;
-    return _resultobj;
-}
-
-#define wxGLContext_SetupPixelFormat(_swigobj)  (_swigobj->SetupPixelFormat())
-static PyObject *_wrap_wxGLContext_SetupPixelFormat(PyObject *self, PyObject *args, PyObject *kwargs) {
-    PyObject * _resultobj;
-    wxGLContext * _arg0;
-    PyObject * _argo0 = 0;
-    char *_kwnames[] = { "self", NULL };
-
-    self = self;
-    if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGLContext_SetupPixelFormat",_kwnames,&_argo0)) 
-        return NULL;
-    if (_argo0) {
-        if (_argo0 == Py_None) { _arg0 = NULL; }
-        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGLContext_p")) {
-            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGLContext_SetupPixelFormat. Expected _wxGLContext_p.");
-        return NULL;
-        }
-    }
-{
-    PyThreadState* __tstate = wxPyBeginAllowThreads();
-        wxGLContext_SetupPixelFormat(_arg0);
-
-    wxPyEndAllowThreads(__tstate);
-    if (PyErr_Occurred()) return NULL;
-}    Py_INCREF(Py_None);
-    _resultobj = Py_None;
-    return _resultobj;
-}
-
-#define wxGLContext_SetupPalette(_swigobj,_swigarg0)  (_swigobj->SetupPalette(_swigarg0))
-static PyObject *_wrap_wxGLContext_SetupPalette(PyObject *self, PyObject *args, PyObject *kwargs) {
-    PyObject * _resultobj;
-    wxGLContext * _arg0;
-    wxPalette * _arg1;
-    PyObject * _argo0 = 0;
-    PyObject * _argo1 = 0;
-    char *_kwnames[] = { "self","palette", NULL };
-
-    self = self;
-    if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxGLContext_SetupPalette",_kwnames,&_argo0,&_argo1)) 
-        return NULL;
-    if (_argo0) {
-        if (_argo0 == Py_None) { _arg0 = NULL; }
-        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGLContext_p")) {
-            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGLContext_SetupPalette. Expected _wxGLContext_p.");
-        return NULL;
-        }
-    }
-    if (_argo1) {
-        if (_argo1 == Py_None) { _arg1 = NULL; }
-        else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxPalette_p")) {
-            PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxGLContext_SetupPalette. Expected _wxPalette_p.");
-        return NULL;
-        }
-    }
-{
-    PyThreadState* __tstate = wxPyBeginAllowThreads();
-        wxGLContext_SetupPalette(_arg0,*_arg1);
-
-    wxPyEndAllowThreads(__tstate);
-    if (PyErr_Occurred()) return NULL;
-}    Py_INCREF(Py_None);
-    _resultobj = Py_None;
-    return _resultobj;
-}
-
-#define wxGLContext_CreateDefaultPalette(_swigobj)  (_swigobj->CreateDefaultPalette())
-static PyObject *_wrap_wxGLContext_CreateDefaultPalette(PyObject *self, PyObject *args, PyObject *kwargs) {
-    PyObject * _resultobj;
-    wxPalette * _result;
-    wxGLContext * _arg0;
-    PyObject * _argo0 = 0;
-    char *_kwnames[] = { "self", NULL };
-    char _ptemp[128];
-
-    self = self;
-    if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGLContext_CreateDefaultPalette",_kwnames,&_argo0)) 
-        return NULL;
-    if (_argo0) {
-        if (_argo0 == Py_None) { _arg0 = NULL; }
-        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGLContext_p")) {
-            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGLContext_CreateDefaultPalette. Expected _wxGLContext_p.");
-        return NULL;
-        }
-    }
-{
-    PyThreadState* __tstate = wxPyBeginAllowThreads();
-        _result = new wxPalette (wxGLContext_CreateDefaultPalette(_arg0));
-
-    wxPyEndAllowThreads(__tstate);
-    if (PyErr_Occurred()) return NULL;
-}    SWIG_MakePtr(_ptemp, (void *) _result,"_wxPalette_p");
-    _resultobj = Py_BuildValue("s",_ptemp);
-    return _resultobj;
-}
-
-#define wxGLContext_GetPalette(_swigobj)  (_swigobj->GetPalette())
-static PyObject *_wrap_wxGLContext_GetPalette(PyObject *self, PyObject *args, PyObject *kwargs) {
-    PyObject * _resultobj;
-    wxPalette * _result;
-    wxGLContext * _arg0;
-    PyObject * _argo0 = 0;
-    char *_kwnames[] = { "self", NULL };
-    char _ptemp[128];
-
-    self = self;
-    if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGLContext_GetPalette",_kwnames,&_argo0)) 
-        return NULL;
-    if (_argo0) {
-        if (_argo0 == Py_None) { _arg0 = NULL; }
-        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGLContext_p")) {
-            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGLContext_GetPalette. Expected _wxGLContext_p.");
-        return NULL;
-        }
-    }
-{
-    PyThreadState* __tstate = wxPyBeginAllowThreads();
-        _result = (wxPalette *)wxGLContext_GetPalette(_arg0);
-
-    wxPyEndAllowThreads(__tstate);
-    if (PyErr_Occurred()) return NULL;
-}    if (_result) {
-        SWIG_MakePtr(_ptemp, (char *) _result,"_wxPalette_p");
-        _resultobj = Py_BuildValue("s",_ptemp);
-    } else {
-        Py_INCREF(Py_None);
-        _resultobj = Py_None;
-    }
-    return _resultobj;
-}
-
-#define wxGLContext_GetWindow(_swigobj)  (_swigobj->GetWindow())
-static PyObject *_wrap_wxGLContext_GetWindow(PyObject *self, PyObject *args, PyObject *kwargs) {
-    PyObject * _resultobj;
-    wxWindow * _result;
-    wxGLContext * _arg0;
-    PyObject * _argo0 = 0;
-    char *_kwnames[] = { "self", NULL };
-
-    self = self;
-    if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGLContext_GetWindow",_kwnames,&_argo0)) 
-        return NULL;
-    if (_argo0) {
-        if (_argo0 == Py_None) { _arg0 = NULL; }
-        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGLContext_p")) {
-            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGLContext_GetWindow. Expected _wxGLContext_p.");
-        return NULL;
-        }
-    }
-{
-    PyThreadState* __tstate = wxPyBeginAllowThreads();
-        _result = (wxWindow *)wxGLContext_GetWindow(_arg0);
-
-    wxPyEndAllowThreads(__tstate);
-    if (PyErr_Occurred()) return NULL;
-}{ _resultobj = wxPyMake_wxObject(_result); }
-    return _resultobj;
-}
-
-static void *SwigwxGLCanvasTowxWindow(void *ptr) {
-    wxGLCanvas *src;
-    wxWindow *dest;
-    src = (wxGLCanvas *) ptr;
-    dest = (wxWindow *) src;
-    return (void *) dest;
-}
-
-static void *SwigwxGLCanvasTowxEvtHandler(void *ptr) {
-    wxGLCanvas *src;
-    wxEvtHandler *dest;
-    src = (wxGLCanvas *) ptr;
-    dest = (wxEvtHandler *) src;
-    return (void *) dest;
-}
-
-static void *SwigwxGLCanvasTowxObject(void *ptr) {
-    wxGLCanvas *src;
-    wxObject *dest;
-    src = (wxGLCanvas *) ptr;
-    dest = (wxObject *) src;
-    return (void *) dest;
-}
-
-#define new_wxGLCanvas(_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4,_swigarg5,_swigarg6,_swigarg7) (new wxGLCanvas(_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4,_swigarg5,_swigarg6,_swigarg7))
-static PyObject *_wrap_new_wxGLCanvas(PyObject *self, PyObject *args, PyObject *kwargs) {
-    PyObject * _resultobj;
-    wxGLCanvas * _result;
-    wxWindow * _arg0;
-    wxWindowID  _arg1 = (wxWindowID ) -1;
-    wxPoint * _arg2 = (wxPoint *) &wxDefaultPosition;
-    wxSize * _arg3 = (wxSize *) &wxDefaultSize;
-    long  _arg4 = (long ) 0;
-    char * _arg5 = (char *) "GLCanvas";
-    int * _arg6 = (int *) NULL;
-    wxPalette * _arg7 = (wxPalette *) &wxNullPalette;
-    PyObject * _argo0 = 0;
-    wxPoint  temp;
-    PyObject * _obj2 = 0;
-    wxSize  temp0;
-    PyObject * _obj3 = 0;
-    int * temp1;
-    PyObject * _obj6 = 0;
-    PyObject * _argo7 = 0;
-    char *_kwnames[] = { "parent","id","pos","size","style","name","attribList","palette", NULL };
-    char _ptemp[128];
-
-    self = self;
-    if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|iOOlsOO:new_wxGLCanvas",_kwnames,&_argo0,&_arg1,&_obj2,&_obj3,&_arg4,&_arg5,&_obj6,&_argo7)) 
-        return NULL;
-    if (_argo0) {
-        if (_argo0 == Py_None) { _arg0 = NULL; }
-        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxWindow_p")) {
-            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of new_wxGLCanvas. Expected _wxWindow_p.");
-        return NULL;
-        }
-    }
-    if (_obj2)
-{
-    _arg2 = &temp;
-    if (! wxPoint_helper(_obj2, &_arg2))
-        return NULL;
-}
-    if (_obj3)
-{
-    _arg3 = &temp0;
-    if (! wxSize_helper(_obj3, &_arg3))
-        return NULL;
-}
-    if (_obj6)
-{
-    int i;
-    if (PySequence_Check(_obj6)) {
-        int size = PyObject_Length(_obj6);
-        temp1 = new int[size+1]; // (int*)malloc((size + 1) * sizeof(int));
-        for (i = 0; i < size; i++) {
-            temp1[i] = PyInt_AsLong(PySequence_GetItem(_obj6, i));
-        }
-        temp1[size] = 0;
-        _arg6 = temp1;
-    }
-}
-    if (_argo7) {
-        if (_argo7 == Py_None) { _arg7 = NULL; }
-        else if (SWIG_GetPtrObj(_argo7,(void **) &_arg7,"_wxPalette_p")) {
-            PyErr_SetString(PyExc_TypeError,"Type error in argument 8 of new_wxGLCanvas. Expected _wxPalette_p.");
-        return NULL;
-        }
-    }
-{
-    PyThreadState* __tstate = wxPyBeginAllowThreads();
-        _result = (wxGLCanvas *)new_wxGLCanvas(_arg0,_arg1,*_arg2,*_arg3,_arg4,_arg5,_arg6,*_arg7);
-
-    wxPyEndAllowThreads(__tstate);
-    if (PyErr_Occurred()) return NULL;
-}    if (_result) {
-        SWIG_MakePtr(_ptemp, (char *) _result,"_wxGLCanvas_p");
-        _resultobj = Py_BuildValue("s",_ptemp);
-    } else {
-        Py_INCREF(Py_None);
-        _resultobj = Py_None;
-    }
-{
-    delete [] _arg6;
-}
-    return _resultobj;
-}
-
-#define new_wxGLCanvasWithContext(_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4,_swigarg5,_swigarg6,_swigarg7,_swigarg8) (new wxGLCanvas(_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4,_swigarg5,_swigarg6,_swigarg7,_swigarg8))
-static PyObject *_wrap_new_wxGLCanvasWithContext(PyObject *self, PyObject *args, PyObject *kwargs) {
-    PyObject * _resultobj;
-    wxGLCanvas * _result;
-    wxWindow * _arg0;
-    wxGLContext * _arg1 = (wxGLContext *) NULL;
-    wxWindowID  _arg2 = (wxWindowID ) -1;
-    wxPoint * _arg3 = (wxPoint *) &wxDefaultPosition;
-    wxSize * _arg4 = (wxSize *) &wxDefaultSize;
-    long  _arg5 = (long ) 0;
-    char * _arg6 = (char *) "GLCanvas";
-    int * _arg7 = (int *) NULL;
-    wxPalette * _arg8 = (wxPalette *) &wxNullPalette;
-    PyObject * _argo0 = 0;
-    PyObject * _argo1 = 0;
-    wxPoint  temp;
-    PyObject * _obj3 = 0;
-    wxSize  temp0;
-    PyObject * _obj4 = 0;
-    int * temp1;
-    PyObject * _obj7 = 0;
-    PyObject * _argo8 = 0;
-    char *_kwnames[] = { "parent","shared","id","pos","size","style","name","attribList","palette", NULL };
-    char _ptemp[128];
-
-    self = self;
-    if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|OiOOlsOO:new_wxGLCanvasWithContext",_kwnames,&_argo0,&_argo1,&_arg2,&_obj3,&_obj4,&_arg5,&_arg6,&_obj7,&_argo8)) 
-        return NULL;
-    if (_argo0) {
-        if (_argo0 == Py_None) { _arg0 = NULL; }
-        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxWindow_p")) {
-            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of new_wxGLCanvasWithContext. Expected _wxWindow_p.");
-        return NULL;
-        }
-    }
-    if (_argo1) {
-        if (_argo1 == Py_None) { _arg1 = NULL; }
-        else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxGLContext_p")) {
-            PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of new_wxGLCanvasWithContext. Expected _wxGLContext_p.");
-        return NULL;
-        }
-    }
-    if (_obj3)
-{
-    _arg3 = &temp;
-    if (! wxPoint_helper(_obj3, &_arg3))
-        return NULL;
-}
-    if (_obj4)
-{
-    _arg4 = &temp0;
-    if (! wxSize_helper(_obj4, &_arg4))
-        return NULL;
-}
-    if (_obj7)
-{
-    int i;
-    if (PySequence_Check(_obj7)) {
-        int size = PyObject_Length(_obj7);
-        temp1 = new int[size+1]; // (int*)malloc((size + 1) * sizeof(int));
-        for (i = 0; i < size; i++) {
-            temp1[i] = PyInt_AsLong(PySequence_GetItem(_obj7, i));
-        }
-        temp1[size] = 0;
-        _arg7 = temp1;
-    }
-}
-    if (_argo8) {
-        if (_argo8 == Py_None) { _arg8 = NULL; }
-        else if (SWIG_GetPtrObj(_argo8,(void **) &_arg8,"_wxPalette_p")) {
-            PyErr_SetString(PyExc_TypeError,"Type error in argument 9 of new_wxGLCanvasWithContext. Expected _wxPalette_p.");
-        return NULL;
-        }
-    }
-{
-    PyThreadState* __tstate = wxPyBeginAllowThreads();
-        _result = (wxGLCanvas *)new_wxGLCanvasWithContext(_arg0,_arg1,_arg2,*_arg3,*_arg4,_arg5,_arg6,_arg7,*_arg8);
-
-    wxPyEndAllowThreads(__tstate);
-    if (PyErr_Occurred()) return NULL;
-}    if (_result) {
-        SWIG_MakePtr(_ptemp, (char *) _result,"_wxGLCanvas_p");
-        _resultobj = Py_BuildValue("s",_ptemp);
-    } else {
-        Py_INCREF(Py_None);
-        _resultobj = Py_None;
-    }
-{
-    delete [] _arg7;
-}
-    return _resultobj;
-}
-
-#define wxGLCanvas_SetCurrent(_swigobj)  (_swigobj->SetCurrent())
-static PyObject *_wrap_wxGLCanvas_SetCurrent(PyObject *self, PyObject *args, PyObject *kwargs) {
-    PyObject * _resultobj;
-    wxGLCanvas * _arg0;
-    PyObject * _argo0 = 0;
-    char *_kwnames[] = { "self", NULL };
-
-    self = self;
-    if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGLCanvas_SetCurrent",_kwnames,&_argo0)) 
-        return NULL;
-    if (_argo0) {
-        if (_argo0 == Py_None) { _arg0 = NULL; }
-        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGLCanvas_p")) {
-            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGLCanvas_SetCurrent. Expected _wxGLCanvas_p.");
-        return NULL;
-        }
-    }
-{
-    PyThreadState* __tstate = wxPyBeginAllowThreads();
-        wxGLCanvas_SetCurrent(_arg0);
-
-    wxPyEndAllowThreads(__tstate);
-    if (PyErr_Occurred()) return NULL;
-}    Py_INCREF(Py_None);
-    _resultobj = Py_None;
-    return _resultobj;
-}
-
-#define wxGLCanvas_SetColour(_swigobj,_swigarg0)  (_swigobj->SetColour(_swigarg0))
-static PyObject *_wrap_wxGLCanvas_SetColour(PyObject *self, PyObject *args, PyObject *kwargs) {
-    PyObject * _resultobj;
-    wxGLCanvas * _arg0;
-    char * _arg1;
-    PyObject * _argo0 = 0;
-    char *_kwnames[] = { "self","colour", NULL };
-
-    self = self;
-    if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Os:wxGLCanvas_SetColour",_kwnames,&_argo0,&_arg1)) 
-        return NULL;
-    if (_argo0) {
-        if (_argo0 == Py_None) { _arg0 = NULL; }
-        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGLCanvas_p")) {
-            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGLCanvas_SetColour. Expected _wxGLCanvas_p.");
-        return NULL;
-        }
-    }
-{
-    PyThreadState* __tstate = wxPyBeginAllowThreads();
-        wxGLCanvas_SetColour(_arg0,_arg1);
-
-    wxPyEndAllowThreads(__tstate);
-    if (PyErr_Occurred()) return NULL;
-}    Py_INCREF(Py_None);
-    _resultobj = Py_None;
-    return _resultobj;
-}
-
-#define wxGLCanvas_SwapBuffers(_swigobj)  (_swigobj->SwapBuffers())
-static PyObject *_wrap_wxGLCanvas_SwapBuffers(PyObject *self, PyObject *args, PyObject *kwargs) {
-    PyObject * _resultobj;
-    wxGLCanvas * _arg0;
-    PyObject * _argo0 = 0;
-    char *_kwnames[] = { "self", NULL };
-
-    self = self;
-    if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGLCanvas_SwapBuffers",_kwnames,&_argo0)) 
-        return NULL;
-    if (_argo0) {
-        if (_argo0 == Py_None) { _arg0 = NULL; }
-        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGLCanvas_p")) {
-            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGLCanvas_SwapBuffers. Expected _wxGLCanvas_p.");
-        return NULL;
-        }
-    }
-{
-    PyThreadState* __tstate = wxPyBeginAllowThreads();
-        wxGLCanvas_SwapBuffers(_arg0);
-
-    wxPyEndAllowThreads(__tstate);
-    if (PyErr_Occurred()) return NULL;
-}    Py_INCREF(Py_None);
-    _resultobj = Py_None;
-    return _resultobj;
-}
-
-#define wxGLCanvas_GetContext(_swigobj)  (_swigobj->GetContext())
-static PyObject *_wrap_wxGLCanvas_GetContext(PyObject *self, PyObject *args, PyObject *kwargs) {
-    PyObject * _resultobj;
-    wxGLContext * _result;
-    wxGLCanvas * _arg0;
-    PyObject * _argo0 = 0;
-    char *_kwnames[] = { "self", NULL };
-    char _ptemp[128];
-
-    self = self;
-    if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGLCanvas_GetContext",_kwnames,&_argo0)) 
-        return NULL;
-    if (_argo0) {
-        if (_argo0 == Py_None) { _arg0 = NULL; }
-        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGLCanvas_p")) {
-            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGLCanvas_GetContext. Expected _wxGLCanvas_p.");
-        return NULL;
-        }
-    }
-{
-    PyThreadState* __tstate = wxPyBeginAllowThreads();
-        _result = (wxGLContext *)wxGLCanvas_GetContext(_arg0);
-
-    wxPyEndAllowThreads(__tstate);
-    if (PyErr_Occurred()) return NULL;
-}    if (_result) {
-        SWIG_MakePtr(_ptemp, (char *) _result,"_wxGLContext_p");
-        _resultobj = Py_BuildValue("s",_ptemp);
-    } else {
-        Py_INCREF(Py_None);
-        _resultobj = Py_None;
-    }
-    return _resultobj;
-}
-
-static PyMethodDef glcanvascMethods[] = {
-	 { "wxGLCanvas_GetContext", (PyCFunction) _wrap_wxGLCanvas_GetContext, METH_VARARGS | METH_KEYWORDS },
-	 { "wxGLCanvas_SwapBuffers", (PyCFunction) _wrap_wxGLCanvas_SwapBuffers, METH_VARARGS | METH_KEYWORDS },
-	 { "wxGLCanvas_SetColour", (PyCFunction) _wrap_wxGLCanvas_SetColour, METH_VARARGS | METH_KEYWORDS },
-	 { "wxGLCanvas_SetCurrent", (PyCFunction) _wrap_wxGLCanvas_SetCurrent, METH_VARARGS | METH_KEYWORDS },
-	 { "new_wxGLCanvasWithContext", (PyCFunction) _wrap_new_wxGLCanvasWithContext, METH_VARARGS | METH_KEYWORDS },
-	 { "new_wxGLCanvas", (PyCFunction) _wrap_new_wxGLCanvas, METH_VARARGS | METH_KEYWORDS },
-	 { "wxGLContext_GetWindow", (PyCFunction) _wrap_wxGLContext_GetWindow, METH_VARARGS | METH_KEYWORDS },
-	 { "wxGLContext_GetPalette", (PyCFunction) _wrap_wxGLContext_GetPalette, METH_VARARGS | METH_KEYWORDS },
-	 { "wxGLContext_CreateDefaultPalette", (PyCFunction) _wrap_wxGLContext_CreateDefaultPalette, METH_VARARGS | METH_KEYWORDS },
-	 { "wxGLContext_SetupPalette", (PyCFunction) _wrap_wxGLContext_SetupPalette, METH_VARARGS | METH_KEYWORDS },
-	 { "wxGLContext_SetupPixelFormat", (PyCFunction) _wrap_wxGLContext_SetupPixelFormat, METH_VARARGS | METH_KEYWORDS },
-	 { "wxGLContext_SwapBuffers", (PyCFunction) _wrap_wxGLContext_SwapBuffers, METH_VARARGS | METH_KEYWORDS },
-	 { "wxGLContext_SetColour", (PyCFunction) _wrap_wxGLContext_SetColour, METH_VARARGS | METH_KEYWORDS },
-	 { "wxGLContext_SetCurrent", (PyCFunction) _wrap_wxGLContext_SetCurrent, METH_VARARGS | METH_KEYWORDS },
-	 { "delete_wxGLContext", (PyCFunction) _wrap_delete_wxGLContext, METH_VARARGS | METH_KEYWORDS },
-	 { "new_wxGLContext", (PyCFunction) _wrap_new_wxGLContext, METH_VARARGS | METH_KEYWORDS },
-	 { NULL, NULL }
-};
-#ifdef __cplusplus
-}
-#endif
-/*
- * This table is used by the pointer type-checker
- */
-static struct { char *n1; char *n2; void *(*pcnv)(void *); } _swig_mapping[] = {
-    { "_signed_long","_long",0},
-    { "_wxPrintQuality","_wxCoord",0},
-    { "_wxPrintQuality","_int",0},
-    { "_wxPrintQuality","_signed_int",0},
-    { "_wxPrintQuality","_unsigned_int",0},
-    { "_wxPrintQuality","_wxWindowID",0},
-    { "_wxPrintQuality","_uint",0},
-    { "_wxPrintQuality","_EBool",0},
-    { "_wxPrintQuality","_size_t",0},
-    { "_wxPrintQuality","_time_t",0},
-    { "_byte","_unsigned_char",0},
-    { "_long","_unsigned_long",0},
-    { "_long","_signed_long",0},
-    { "_size_t","_wxCoord",0},
-    { "_size_t","_wxPrintQuality",0},
-    { "_size_t","_time_t",0},
-    { "_size_t","_unsigned_int",0},
-    { "_size_t","_int",0},
-    { "_size_t","_wxWindowID",0},
-    { "_size_t","_uint",0},
-    { "_uint","_wxCoord",0},
-    { "_uint","_wxPrintQuality",0},
-    { "_uint","_time_t",0},
-    { "_uint","_size_t",0},
-    { "_uint","_unsigned_int",0},
-    { "_uint","_int",0},
-    { "_uint","_wxWindowID",0},
-    { "_wxChar","_char",0},
-    { "_char","_wxChar",0},
-    { "_struct_wxNativeFontInfo","_wxNativeFontInfo",0},
-    { "_EBool","_wxCoord",0},
-    { "_EBool","_wxPrintQuality",0},
-    { "_EBool","_signed_int",0},
-    { "_EBool","_int",0},
-    { "_EBool","_wxWindowID",0},
-    { "_unsigned_long","_long",0},
-    { "_wxNativeFontInfo","_struct_wxNativeFontInfo",0},
-    { "_signed_int","_wxCoord",0},
-    { "_signed_int","_wxPrintQuality",0},
-    { "_signed_int","_EBool",0},
-    { "_signed_int","_wxWindowID",0},
-    { "_signed_int","_int",0},
-    { "_WXTYPE","_wxDateTime_t",0},
-    { "_WXTYPE","_short",0},
-    { "_WXTYPE","_signed_short",0},
-    { "_WXTYPE","_unsigned_short",0},
-    { "_unsigned_short","_wxDateTime_t",0},
-    { "_unsigned_short","_WXTYPE",0},
-    { "_unsigned_short","_short",0},
-    { "_wxObject","_wxGLCanvas",SwigwxGLCanvasTowxObject},
-    { "_wxObject","_wxGLContext",SwigwxGLContextTowxObject},
-    { "_signed_short","_WXTYPE",0},
-    { "_signed_short","_short",0},
-    { "_unsigned_char","_byte",0},
-    { "_unsigned_int","_wxCoord",0},
-    { "_unsigned_int","_wxPrintQuality",0},
-    { "_unsigned_int","_time_t",0},
-    { "_unsigned_int","_size_t",0},
-    { "_unsigned_int","_uint",0},
-    { "_unsigned_int","_wxWindowID",0},
-    { "_unsigned_int","_int",0},
-    { "_short","_wxDateTime_t",0},
-    { "_short","_WXTYPE",0},
-    { "_short","_unsigned_short",0},
-    { "_short","_signed_short",0},
-    { "_wxWindowID","_wxCoord",0},
-    { "_wxWindowID","_wxPrintQuality",0},
-    { "_wxWindowID","_time_t",0},
-    { "_wxWindowID","_size_t",0},
-    { "_wxWindowID","_EBool",0},
-    { "_wxWindowID","_uint",0},
-    { "_wxWindowID","_int",0},
-    { "_wxWindowID","_signed_int",0},
-    { "_wxWindowID","_unsigned_int",0},
-    { "_int","_wxCoord",0},
-    { "_int","_wxPrintQuality",0},
-    { "_int","_time_t",0},
-    { "_int","_size_t",0},
-    { "_int","_EBool",0},
-    { "_int","_uint",0},
-    { "_int","_wxWindowID",0},
-    { "_int","_unsigned_int",0},
-    { "_int","_signed_int",0},
-    { "_wxDateTime_t","_unsigned_short",0},
-    { "_wxDateTime_t","_short",0},
-    { "_wxDateTime_t","_WXTYPE",0},
-    { "_time_t","_wxCoord",0},
-    { "_time_t","_wxPrintQuality",0},
-    { "_time_t","_unsigned_int",0},
-    { "_time_t","_int",0},
-    { "_time_t","_wxWindowID",0},
-    { "_time_t","_uint",0},
-    { "_time_t","_size_t",0},
-    { "_wxCoord","_int",0},
-    { "_wxCoord","_signed_int",0},
-    { "_wxCoord","_unsigned_int",0},
-    { "_wxCoord","_wxWindowID",0},
-    { "_wxCoord","_uint",0},
-    { "_wxCoord","_EBool",0},
-    { "_wxCoord","_size_t",0},
-    { "_wxCoord","_time_t",0},
-    { "_wxCoord","_wxPrintQuality",0},
-    { "_wxEvtHandler","_wxGLCanvas",SwigwxGLCanvasTowxEvtHandler},
-    { "_wxWindow","_wxGLCanvas",SwigwxGLCanvasTowxWindow},
-{0,0,0}};
-
-static PyObject *SWIG_globals;
-#ifdef __cplusplus
-extern "C" 
-#endif
-SWIGEXPORT(void) initglcanvasc() {
-	 PyObject *m, *d;
-	 SWIG_globals = SWIG_newvarlink();
-	 m = Py_InitModule("glcanvasc", glcanvascMethods);
-	 d = PyModule_GetDict(m);
-	 PyDict_SetItemString(d,"WX_GL_RGBA", PyInt_FromLong((long) WX_GL_RGBA));
-	 PyDict_SetItemString(d,"WX_GL_BUFFER_SIZE", PyInt_FromLong((long) WX_GL_BUFFER_SIZE));
-	 PyDict_SetItemString(d,"WX_GL_LEVEL", PyInt_FromLong((long) WX_GL_LEVEL));
-	 PyDict_SetItemString(d,"WX_GL_DOUBLEBUFFER", PyInt_FromLong((long) WX_GL_DOUBLEBUFFER));
-	 PyDict_SetItemString(d,"WX_GL_STEREO", PyInt_FromLong((long) WX_GL_STEREO));
-	 PyDict_SetItemString(d,"WX_GL_AUX_BUFFERS", PyInt_FromLong((long) WX_GL_AUX_BUFFERS));
-	 PyDict_SetItemString(d,"WX_GL_MIN_RED", PyInt_FromLong((long) WX_GL_MIN_RED));
-	 PyDict_SetItemString(d,"WX_GL_MIN_GREEN", PyInt_FromLong((long) WX_GL_MIN_GREEN));
-	 PyDict_SetItemString(d,"WX_GL_MIN_BLUE", PyInt_FromLong((long) WX_GL_MIN_BLUE));
-	 PyDict_SetItemString(d,"WX_GL_MIN_ALPHA", PyInt_FromLong((long) WX_GL_MIN_ALPHA));
-	 PyDict_SetItemString(d,"WX_GL_DEPTH_SIZE", PyInt_FromLong((long) WX_GL_DEPTH_SIZE));
-	 PyDict_SetItemString(d,"WX_GL_STENCIL_SIZE", PyInt_FromLong((long) WX_GL_STENCIL_SIZE));
-	 PyDict_SetItemString(d,"WX_GL_MIN_ACCUM_RED", PyInt_FromLong((long) WX_GL_MIN_ACCUM_RED));
-	 PyDict_SetItemString(d,"WX_GL_MIN_ACCUM_GREEN", PyInt_FromLong((long) WX_GL_MIN_ACCUM_GREEN));
-	 PyDict_SetItemString(d,"WX_GL_MIN_ACCUM_BLUE", PyInt_FromLong((long) WX_GL_MIN_ACCUM_BLUE));
-	 PyDict_SetItemString(d,"WX_GL_MIN_ACCUM_ALPHA", PyInt_FromLong((long) WX_GL_MIN_ACCUM_ALPHA));
-
-
-    wxClassInfo::CleanUpClasses();
-    wxClassInfo::InitializeClasses();
-
-{
-   int i;
-   for (i = 0; _swig_mapping[i].n1; i++)
-        SWIG_RegisterMapping(_swig_mapping[i].n1,_swig_mapping[i].n2,_swig_mapping[i].pcnv);
-}
-}

wxPython/contrib/glcanvas/gtk/glcanvas.py

@@ -1,144 +0,0 @@
-# This file was created automatically by SWIG.
-import glcanvasc
-
-from misc import *
-
-from misc2 import *
-
-from windows import *
-
-from gdi import *
-
-from clip_dnd import *
-
-from events import *
-
-from streams import *
-
-from utils import *
-
-from mdi import *
-
-from frames import *
-
-from stattool import *
-
-from controls import *
-
-from controls2 import *
-
-from windows2 import *
-
-from cmndlgs import *
-
-from windows3 import *
-
-from image import *
-
-from printfw import *
-
-from sizers import *
-
-from filesys import *
-import wx
-class wxGLContextPtr(wxObjectPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def __del__(self,glcanvasc=glcanvasc):
-        if self.thisown == 1 :
-            glcanvasc.delete_wxGLContext(self)
-    def SetCurrent(self, *_args, **_kwargs):
-        val = apply(glcanvasc.wxGLContext_SetCurrent,(self,) + _args, _kwargs)
-        return val
-    def SetColour(self, *_args, **_kwargs):
-        val = apply(glcanvasc.wxGLContext_SetColour,(self,) + _args, _kwargs)
-        return val
-    def SwapBuffers(self, *_args, **_kwargs):
-        val = apply(glcanvasc.wxGLContext_SwapBuffers,(self,) + _args, _kwargs)
-        return val
-    def SetupPixelFormat(self, *_args, **_kwargs):
-        val = apply(glcanvasc.wxGLContext_SetupPixelFormat,(self,) + _args, _kwargs)
-        return val
-    def SetupPalette(self, *_args, **_kwargs):
-        val = apply(glcanvasc.wxGLContext_SetupPalette,(self,) + _args, _kwargs)
-        return val
-    def CreateDefaultPalette(self, *_args, **_kwargs):
-        val = apply(glcanvasc.wxGLContext_CreateDefaultPalette,(self,) + _args, _kwargs)
-        if val: val = wxPalettePtr(val) ; val.thisown = 1
-        return val
-    def GetPalette(self, *_args, **_kwargs):
-        val = apply(glcanvasc.wxGLContext_GetPalette,(self,) + _args, _kwargs)
-        if val: val = wxPalettePtr(val) 
-        return val
-    def GetWindow(self, *_args, **_kwargs):
-        val = apply(glcanvasc.wxGLContext_GetWindow,(self,) + _args, _kwargs)
-        return val
-    def __repr__(self):
-        return "<C wxGLContext instance at %s>" % (self.this,)
-class wxGLContext(wxGLContextPtr):
-    def __init__(self,*_args,**_kwargs):
-        self.this = apply(glcanvasc.new_wxGLContext,_args,_kwargs)
-        self.thisown = 1
-
-
-
-
-class wxGLCanvasPtr(wxWindowPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def SetCurrent(self, *_args, **_kwargs):
-        val = apply(glcanvasc.wxGLCanvas_SetCurrent,(self,) + _args, _kwargs)
-        return val
-    def SetColour(self, *_args, **_kwargs):
-        val = apply(glcanvasc.wxGLCanvas_SetColour,(self,) + _args, _kwargs)
-        return val
-    def SwapBuffers(self, *_args, **_kwargs):
-        val = apply(glcanvasc.wxGLCanvas_SwapBuffers,(self,) + _args, _kwargs)
-        return val
-    def GetContext(self, *_args, **_kwargs):
-        val = apply(glcanvasc.wxGLCanvas_GetContext,(self,) + _args, _kwargs)
-        if val: val = wxGLContextPtr(val) 
-        return val
-    def __repr__(self):
-        return "<C wxGLCanvas instance at %s>" % (self.this,)
-class wxGLCanvas(wxGLCanvasPtr):
-    def __init__(self,*_args,**_kwargs):
-        self.this = apply(glcanvasc.new_wxGLCanvas,_args,_kwargs)
-        self.thisown = 1
-        self._setOORInfo(self)
-
-
-
-def wxGLCanvasWithContext(*_args,**_kwargs):
-    val = wxGLCanvasPtr(apply(glcanvasc.new_wxGLCanvasWithContext,_args,_kwargs))
-    val.thisown = 1
-    val._setOORInfo(self)
-    return val
-
-
-
-
-#-------------- FUNCTION WRAPPERS ------------------
-
-
-
-#-------------- VARIABLE WRAPPERS ------------------
-
-WX_GL_RGBA = glcanvasc.WX_GL_RGBA
-WX_GL_BUFFER_SIZE = glcanvasc.WX_GL_BUFFER_SIZE
-WX_GL_LEVEL = glcanvasc.WX_GL_LEVEL
-WX_GL_DOUBLEBUFFER = glcanvasc.WX_GL_DOUBLEBUFFER
-WX_GL_STEREO = glcanvasc.WX_GL_STEREO
-WX_GL_AUX_BUFFERS = glcanvasc.WX_GL_AUX_BUFFERS
-WX_GL_MIN_RED = glcanvasc.WX_GL_MIN_RED
-WX_GL_MIN_GREEN = glcanvasc.WX_GL_MIN_GREEN
-WX_GL_MIN_BLUE = glcanvasc.WX_GL_MIN_BLUE
-WX_GL_MIN_ALPHA = glcanvasc.WX_GL_MIN_ALPHA
-WX_GL_DEPTH_SIZE = glcanvasc.WX_GL_DEPTH_SIZE
-WX_GL_STENCIL_SIZE = glcanvasc.WX_GL_STENCIL_SIZE
-WX_GL_MIN_ACCUM_RED = glcanvasc.WX_GL_MIN_ACCUM_RED
-WX_GL_MIN_ACCUM_GREEN = glcanvasc.WX_GL_MIN_ACCUM_GREEN
-WX_GL_MIN_ACCUM_BLUE = glcanvasc.WX_GL_MIN_ACCUM_BLUE
-WX_GL_MIN_ACCUM_ALPHA = glcanvasc.WX_GL_MIN_ACCUM_ALPHA