home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / wxos2240.zip / wxWindows-2.4.0 / src / tiff / tif_win3.c < prev    next >
C/C++ Source or Header  |  2002-11-10  |  6KB  |  226 lines
  1. /* $Header: /pack/cvsroots/wxwindows/wxWindows/src/tiff/tif_win3.c,v 1.1.6.1 2002/11/10 13:13:58 JS Exp $ */
  2.  
  3. /*
  4.  * Copyright (c) 1988-1997 Sam Leffler
  5.  * Copyright (c) 1991-1997 Silicon Graphics, Inc.
  6.  *
  7.  * Permission to use, copy, modify, distribute, and sell this software and 
  8.  * its documentation for any purpose is hereby granted without fee, provided
  9.  * that (i) the above copyright notices and this permission notice appear in
  10.  * all copies of the software and related documentation, and (ii) the names of
  11.  * Sam Leffler and Silicon Graphics may not be used in any advertising or
  12.  * publicity relating to the software without the specific, prior written
  13.  * permission of Sam Leffler and Silicon Graphics.
  14.  * 
  15.  * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, 
  16.  * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY 
  17.  * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.  
  18.  * 
  19.  * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
  20.  * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
  21.  * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  22.  * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF 
  23.  * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE 
  24.  * OF THIS SOFTWARE.
  25.  */
  26.  
  27. /*
  28.  * TIFF Library Windows 3.x-specific Routines.
  29.  */
  30. #include "tiffiop.h"
  31. #if defined(__WATCOMC__) || defined(__BORLANDC__) || defined(_MSC_VER)
  32. #include <io.h>        /* for open, close, etc. function prototypes */
  33. #endif
  34.  
  35. #include <windows.h>
  36. #include <windowsx.h>
  37. #include <memory.h>
  38.  
  39. static tsize_t 
  40. _tiffReadProc(thandle_t fd, tdata_t buf, tsize_t size)
  41. {
  42.     return (_hread(fd, buf, size));
  43. }
  44.  
  45. static tsize_t
  46. _tiffWriteProc(thandle_t fd, tdata_t buf, tsize_t size)
  47. {
  48.     return (_hwrite(fd, buf, size));
  49. }
  50.  
  51. static toff_t
  52. _tiffSeekProc(thandle_t fd, toff_t off, int whence)
  53. {
  54.     return (_llseek(fd, (off_t) off, whence));
  55. }
  56.  
  57. static int
  58. _tiffCloseProc(thandle_t fd)
  59. {
  60.     return (_lclose(fd));
  61. }
  62.  
  63. #include <sys/stat.h>
  64.  
  65. static toff_t
  66. _tiffSizeProc(thandle_t fd)
  67. {
  68.     struct stat sb;
  69.     return (fstat((int) fd, &sb) < 0 ? 0 : sb.st_size);
  70. }
  71.  
  72. static int
  73. _tiffMapProc(thandle_t fd, tdata_t* pbase, toff_t* psize)
  74. {
  75.     return (0);
  76. }
  77.  
  78. static void
  79. _tiffUnmapProc(thandle_t fd, tdata_t base, toff_t size)
  80. {
  81. }
  82.  
  83. /*
  84.  * Open a TIFF file descriptor for read/writing.
  85.  */
  86. TIFF*
  87. TIFFFdOpen(int fd, const char* name, const char* mode)
  88. {
  89.     TIFF* tif;
  90.  
  91.     tif = TIFFClientOpen(name, mode,
  92.         (thandle_t) fd,
  93.         _tiffReadProc, _tiffWriteProc, _tiffSeekProc, _tiffCloseProc,
  94.         _tiffSizeProc, _tiffMapProc, _tiffUnmapProc);
  95.     if (tif)
  96.         tif->tif_fd = fd;
  97.     return (tif);
  98. }
  99.  
  100. /*
  101.  * Open a TIFF file for read/writing.
  102.  */
  103. TIFF*
  104. TIFFOpen(const char* name, const char* mode)
  105. {
  106.     static const char module[] = "TIFFOpen";
  107.     int m, fd;
  108.     OFSTRUCT of;
  109.     int mm = 0;
  110.  
  111.     m = _TIFFgetMode(mode, module);
  112.     if (m == -1)
  113.         return ((TIFF*)0);
  114.     if (m & O_CREAT) {
  115.         if ((m & O_TRUNC) || OpenFile(name, &of, OF_EXIST) != HFILE_ERROR)
  116.             mm |= OF_CREATE;
  117.     }
  118.     if (m & O_WRONLY)
  119.         mm |= OF_WRITE;
  120.     if (m & O_RDWR)
  121.         mm |= OF_READWRITE;
  122.     fd = OpenFile(name, &of, mm);
  123.     if (fd < 0) {
  124.         TIFFError(module, "%s: Cannot open", name);
  125.         return ((TIFF*)0);
  126.     }
  127.     return (TIFFFdOpen(fd, name, mode));
  128. }
  129.  
  130. tdata_t
  131. _TIFFmalloc(tsize_t s)
  132. {
  133.     return (tdata_t) GlobalAllocPtr(GHND, (DWORD) s);
  134. }
  135.  
  136. void
  137. _TIFFfree(tdata_t p)
  138. {
  139.     GlobalFreePtr(p);
  140. }
  141.  
  142. tdata_t
  143. _TIFFrealloc(tdata_t p, tsize_t s)
  144. {
  145.     return (tdata_t) GlobalReAllocPtr(p, (DWORD) s, GHND);
  146. }
  147.  
  148. void
  149. _TIFFmemset(tdata_t p, int v, tsize_t c)
  150. {
  151.     char* pp = (char*) p;
  152.  
  153.     while (c > 0) {
  154.         tsize_t chunk = 0x10000 - ((uint32) pp & 0xffff);/* What's left in segment */
  155.         if (chunk > 0xff00)                /* No more than 0xff00 */
  156.             chunk = 0xff00;
  157.         if (chunk > c)                    /* No more than needed */
  158.             chunk = c;
  159.         memset(pp, v, chunk);
  160.         pp = (char*) (chunk + (char huge*) pp);
  161.         c -= chunk;
  162.     }
  163. }
  164.  
  165. void
  166. _TIFFmemcpy(tdata_t d, const tdata_t s, tsize_t c)
  167. {
  168.     if (c > 0xFFFF)
  169.         hmemcpy((void _huge*) d, (void _huge*) s, c);
  170.     else
  171.         (void) memcpy(d, s, (size_t) c);
  172. }
  173.  
  174. int
  175. _TIFFmemcmp(const tdata_t d, const tdata_t s, tsize_t c)
  176. {
  177.     char* dd = (char*) d;
  178.     char* ss = (char*) s;
  179.     tsize_t chunks, chunkd, chunk;
  180.     int result;
  181.  
  182.     while (c > 0) {
  183.         chunks = 0x10000 - ((uint32) ss & 0xffff);    /* What's left in segment */
  184.         chunkd = 0x10000 - ((uint32) dd & 0xffff);    /* What's left in segment */
  185.         chunk = c;                    /* Get the largest of     */
  186.         if (chunk > chunks)                /*   c, chunks, chunkd,   */
  187.             chunk = chunks;                /*   0xff00               */
  188.         if (chunk > chunkd)
  189.             chunk = chunkd;
  190.         if (chunk > 0xff00)
  191.             chunk = 0xff00;
  192.         result = memcmp(dd, ss, chunk);
  193.         if (result != 0)
  194.             return (result);
  195.         dd = (char*) (chunk + (char huge*) dd);
  196.         ss = (char*) (chunk + (char huge*) ss);
  197.         c -= chunk;
  198.     }
  199.     return (0);
  200. }
  201.  
  202. static void
  203. win3WarningHandler(const char* module, const char* fmt, va_list ap)
  204. {
  205.     char e[512] = { '\0' };
  206.     if (module != NULL)
  207.         strcat(strcpy(e, module), ":");
  208.     vsprintf(e+strlen(e), fmt, ap);
  209.     strcat(e, ".");
  210.     MessageBox(GetActiveWindow(), e, "LibTIFF Warning",
  211.         MB_OK|MB_ICONEXCLAMATION);
  212. }
  213. TIFFErrorHandler _TIFFwarningHandler = win3WarningHandler;
  214.  
  215. static void
  216. win3ErrorHandler(const char* module, const char* fmt, va_list ap)
  217. {
  218.     char e[512] = { '\0' };
  219.     if (module != NULL)
  220.         strcat(strcpy(e, module), ":");
  221.     vsprintf(e+strlen(e), fmt, ap);
  222.     strcat(e, ".");
  223.     MessageBox(GetActiveWindow(), e, "LibTIFF Error", MB_OK|MB_ICONSTOP);
  224. }
  225. TIFFErrorHandler _TIFFerrorHandler = win3ErrorHandler;
  226.