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_win32.c < prev    next >
C/C++ Source or Header  |  2002-11-10  |  8KB  |  302 lines
  1. /* $Header: /pack/cvsroots/wxwindows/wxWindows/src/tiff/tif_win32.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 Win32-specific Routines.  Adapted from tif_unix.c 4/5/95 by
  29.  * Scott Wagner (wagner@itek.com), Itek Graphix, Rochester, NY USA
  30.  */
  31. #include <windows.h>
  32. #include "tiffiop.h"
  33.  
  34. static tsize_t
  35. _tiffReadProc(thandle_t fd, tdata_t buf, tsize_t size)
  36. {
  37.     DWORD dwSizeRead;
  38.     if (!ReadFile(fd, buf, size, &dwSizeRead, NULL))
  39.         return(0);
  40.     return ((tsize_t) dwSizeRead);
  41. }
  42.  
  43. static tsize_t
  44. _tiffWriteProc(thandle_t fd, tdata_t buf, tsize_t size)
  45. {
  46.     DWORD dwSizeWritten;
  47.     if (!WriteFile(fd, buf, size, &dwSizeWritten, NULL))
  48.         return(0);
  49.     return ((tsize_t) dwSizeWritten);
  50. }
  51.  
  52. static toff_t
  53. _tiffSeekProc(thandle_t fd, toff_t off, int whence)
  54. {
  55.     DWORD dwMoveMethod;
  56.     switch(whence)
  57.     {
  58.     case 0:
  59.         dwMoveMethod = FILE_BEGIN;
  60.         break;
  61.     case 1:
  62.         dwMoveMethod = FILE_CURRENT;
  63.         break;
  64.     case 2:
  65.         dwMoveMethod = FILE_END;
  66.         break;
  67.     default:
  68.         dwMoveMethod = FILE_BEGIN;
  69.         break;
  70.     }
  71.     return ((toff_t)SetFilePointer(fd, off, NULL, dwMoveMethod));
  72. }
  73.  
  74. static int
  75. _tiffCloseProc(thandle_t fd)
  76. {
  77.     return (CloseHandle(fd) ? 0 : -1);
  78. }
  79.  
  80. static toff_t
  81. _tiffSizeProc(thandle_t fd)
  82. {
  83.     return ((toff_t)GetFileSize(fd, NULL));
  84. }
  85.  
  86. static int
  87. _tiffDummyMapProc(thandle_t fd, tdata_t* pbase, toff_t* psize)
  88. {
  89.     return (0);
  90. }
  91.  
  92. /*
  93.  * From "Hermann Josef Hill" <lhill@rhein-zeitung.de>:
  94.  *
  95.  * Windows uses both a handle and a pointer for file mapping,
  96.  * but according to the SDK documentation and Richter's book
  97.  * "Advanced Windows Programming" it is safe to free the handle
  98.  * after obtaining the file mapping pointer
  99.  *
  100.  * This removes a nasty OS dependency and cures a problem
  101.  * with Visual C++ 5.0
  102.  */
  103. static int
  104. _tiffMapProc(thandle_t fd, tdata_t* pbase, toff_t* psize)
  105. {
  106.     toff_t size;
  107.     HANDLE hMapFile;
  108.  
  109.     if ((size = _tiffSizeProc(fd)) == (toff_t)-1)
  110.         return (0);
  111.     hMapFile = CreateFileMapping(fd, NULL, PAGE_READONLY, 0, size, NULL);
  112.     if (hMapFile == NULL)
  113.         return (0);
  114.     *pbase = MapViewOfFile(hMapFile, FILE_MAP_READ, 0, 0, 0);
  115.     CloseHandle(hMapFile);
  116.     if (*pbase == NULL)
  117.         return (0);
  118.     *psize = size;
  119.     return(1);
  120. }
  121.  
  122. static void
  123. _tiffDummyUnmapProc(thandle_t fd, tdata_t base, toff_t size)
  124. {
  125. }
  126.  
  127. static void
  128. _tiffUnmapProc(thandle_t fd, tdata_t base, toff_t size)
  129. {
  130.     UnmapViewOfFile(base);
  131. }
  132.  
  133. /*
  134.  * Open a TIFF file descriptor for read/writing.
  135.  * Note that TIFFFdOpen and TIFFOpen recognise the character 'u' in the mode
  136.  * string, which forces the file to be opened unmapped.
  137.  */
  138. TIFF*
  139. TIFFFdOpen(int ifd, const char* name, const char* mode)
  140. {
  141.     TIFF* tif;
  142.     BOOL fSuppressMap = (mode[1] == 'u' || mode[2] == 'u');
  143.  
  144.     tif = TIFFClientOpen(name, mode,
  145.          (thandle_t)ifd,
  146.         _tiffReadProc, _tiffWriteProc,
  147.         _tiffSeekProc, _tiffCloseProc, _tiffSizeProc,
  148.          fSuppressMap ? _tiffDummyMapProc : _tiffMapProc,
  149.          fSuppressMap ? _tiffDummyUnmapProc : _tiffUnmapProc);
  150.     if (tif)
  151.         tif->tif_fd = ifd;
  152.     return (tif);
  153. }
  154.  
  155. /*
  156.  * Open a TIFF file for read/writing.
  157.  */
  158. TIFF*
  159. TIFFOpen(const char* name, const char* mode)
  160. {
  161.     static const char module[] = "TIFFOpen";
  162.     thandle_t fd;
  163.     int m;
  164.     DWORD dwMode;
  165.  
  166.     m = _TIFFgetMode(mode, module);
  167.  
  168.     switch(m)
  169.     {
  170.     case O_RDONLY:
  171.         dwMode = OPEN_EXISTING;
  172.         break;
  173.     case O_RDWR:
  174.         dwMode = OPEN_ALWAYS;
  175.         break;
  176.     case O_RDWR|O_CREAT:
  177.         dwMode = OPEN_ALWAYS;
  178.         break;
  179.     case O_RDWR|O_TRUNC:
  180.         dwMode = CREATE_ALWAYS;
  181.         break;
  182.     case O_RDWR|O_CREAT|O_TRUNC:
  183.         dwMode = CREATE_ALWAYS;
  184.         break;
  185.     default:
  186.         return ((TIFF*)0);
  187.     }
  188.     fd = (thandle_t)CreateFile(name, (m == O_RDONLY) ? GENERIC_READ :
  189.             (GENERIC_READ | GENERIC_WRITE), FILE_SHARE_READ, NULL, dwMode,
  190.             (m == O_RDONLY) ? FILE_ATTRIBUTE_READONLY : FILE_ATTRIBUTE_NORMAL, NULL);
  191.     if (fd == INVALID_HANDLE_VALUE) {
  192.         TIFFError(module, "%s: Cannot open", name);
  193.         return ((TIFF *)0);
  194.     }
  195.     return (TIFFFdOpen((int)fd, name, mode));
  196. }
  197.  
  198. tdata_t
  199. _TIFFmalloc(tsize_t s)
  200. {
  201.     return ((tdata_t)GlobalAlloc(GMEM_FIXED, s));
  202. }
  203.  
  204. void
  205. _TIFFfree(tdata_t p)
  206. {
  207.     GlobalFree(p);
  208.     return;
  209. }
  210.  
  211. tdata_t
  212. _TIFFrealloc(tdata_t p, tsize_t s)
  213. {
  214.     void* pvTmp;
  215.     if ((pvTmp = GlobalReAlloc(p, s, 0)) == NULL) {
  216.         if ((pvTmp = GlobalAlloc(GMEM_FIXED, s)) != NULL) {
  217.             CopyMemory(pvTmp, p, GlobalSize(p));
  218.             GlobalFree(p);
  219.         }
  220.     }
  221.     return ((tdata_t)pvTmp);
  222. }
  223.  
  224. void
  225. _TIFFmemset(void* p, int v, tsize_t c)
  226. {
  227.     FillMemory(p, c, (BYTE)v);
  228. }
  229.  
  230. void
  231. _TIFFmemcpy(void* d, const tdata_t s, tsize_t c)
  232. {
  233.     CopyMemory(d, s, c);
  234. }
  235.  
  236. int
  237. _TIFFmemcmp(const tdata_t p1, const tdata_t p2, tsize_t c)
  238. {
  239.     register const BYTE *pb1 = p1;
  240.     register const BYTE *pb2 = p2;
  241.     register DWORD dwTmp = c;
  242.     register int iTmp;
  243.     for (iTmp = 0; dwTmp-- && !iTmp; iTmp = (int)*pb1++ - (int)*pb2++)
  244.         ;
  245.     return (iTmp);
  246. }
  247.  
  248. static void
  249. Win32WarningHandler(const char* module, const char* fmt, va_list ap)
  250. {
  251. #ifndef TIF_PLATFORM_CONSOLE
  252.     LPTSTR szTitle;
  253.     LPTSTR szTmp;
  254.     LPCTSTR szTitleText = "%s Warning";
  255.     LPCTSTR szDefaultModule = "TIFFLIB";
  256.     szTmp = (module == NULL) ? (LPTSTR)szDefaultModule : (LPTSTR)module;
  257.     if ((szTitle = (LPTSTR)LocalAlloc(LMEM_FIXED, (lstrlen(szTmp) +
  258.             lstrlen(szTitleText) + lstrlen(fmt) + 128)*sizeof(TCHAR))) == NULL)
  259.         return;
  260.     wsprintf(szTitle, szTitleText, szTmp);
  261.     szTmp = szTitle + (lstrlen(szTitle)+2)*sizeof(TCHAR);
  262.     wvsprintf(szTmp, fmt, ap);
  263.     MessageBox(GetFocus(), szTmp, szTitle, MB_OK | MB_ICONINFORMATION);
  264.     LocalFree(szTitle);
  265.     return;
  266. #else
  267.     if (module != NULL)
  268.         fprintf(stderr, "%s: ", module);
  269.     fprintf(stderr, "Warning, ");
  270.     vfprintf(stderr, fmt, ap);
  271.     fprintf(stderr, ".\n");
  272. #endif        
  273. }
  274. TIFFErrorHandler _TIFFwarningHandler = Win32WarningHandler;
  275.  
  276. static void
  277. Win32ErrorHandler(const char* module, const char* fmt, va_list ap)
  278. {
  279. #ifndef TIF_PLATFORM_CONSOLE
  280.     LPTSTR szTitle;
  281.     LPTSTR szTmp;
  282.     LPCTSTR szTitleText = "%s Error";
  283.     LPCTSTR szDefaultModule = "TIFFLIB";
  284.     szTmp = (module == NULL) ? (LPTSTR)szDefaultModule : (LPTSTR)module;
  285.     if ((szTitle = (LPTSTR)LocalAlloc(LMEM_FIXED, (lstrlen(szTmp) +
  286.             lstrlen(szTitleText) + lstrlen(fmt) + 128)*sizeof(TCHAR))) == NULL)
  287.         return;
  288.     wsprintf(szTitle, szTitleText, szTmp);
  289.     szTmp = szTitle + (lstrlen(szTitle)+2)*sizeof(TCHAR);
  290.     wvsprintf(szTmp, fmt, ap);
  291.     MessageBox(GetFocus(), szTmp, szTitle, MB_OK | MB_ICONEXCLAMATION);
  292.     LocalFree(szTitle);
  293.     return;
  294. #else
  295.     if (module != NULL)
  296.         fprintf(stderr, "%s: ", module);
  297.     vfprintf(stderr, fmt, ap);
  298.     fprintf(stderr, ".\n");
  299. #endif        
  300. }
  301. TIFFErrorHandler _TIFFerrorHandler = Win32ErrorHandler;
  302.