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_os2.c < prev    next >
C/C++ Source or Header  |  2002-11-10  |  9KB  |  339 lines
  1. /* $Header: /pack/cvsroots/wxwindows/wxWindows/src/tiff/tif_os2.c,v 1.1.6.1 2002/11/10 13:13:57 JS Exp $ */
  2.  
  3. /*
  4.  * Copyright (c) 1988-1997 Sam Leffler
  5.  * Copyright (c) 1991-1997 Silicon Graphics, Inc.
  6.  *
  7.  * modifed for use with OS/2 by David Webster
  8.  *
  9.  * Permission to use, copy, modify, distribute, and sell this software and
  10.  * its documentation for any purpose is hereby granted without fee, provided
  11.  * that (i) the above copyright notices and this permission notice appear in
  12.  * all copies of the software and related documentation, and (ii) the names of
  13.  * Sam Leffler and Silicon Graphics may not be used in any advertising or
  14.  * publicity relating to the software without the specific, prior written
  15.  * permission of Sam Leffler and Silicon Graphics.
  16.  *
  17.  * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
  18.  * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
  19.  * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
  20.  *
  21.  * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
  22.  * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
  23.  * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  24.  * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF
  25.  * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
  26.  * OF THIS SOFTWARE.
  27.  */
  28.  
  29. /*
  30.  * TIFF Library OS/2-specific Routines.  Adapted from tif_win32.c 2/16/00 by
  31.  * David Webster (dwebster@bhmi.com), Baldwin, Hackett, and Meeks, Inc., Omaha, NE USA
  32.  */
  33. #define INCL_PM
  34. #define INCL_BASE
  35. #include <os2.h>
  36. #include <stdio.h>
  37. #include <stdlib.h>
  38. #include "tiffiop.h"
  39.  
  40. /* Some windows datatypes */
  41.  
  42. typedef ULONG DWORD;
  43. typedef ULONG HANDLE;
  44. typedef PCHAR LPTSTR;
  45. typedef const PCHAR LPCTSTR;
  46. typedef CHAR TCHAR;
  47. #define GlobalAlloc(a,b) malloc(b)
  48. #define LocalAlloc(a,b) malloc(b)
  49. #define GlobalFree(b) free(b)
  50. #define LocalFree(b) free(b)
  51. #define GlobalReAlloc(p, s, t) realloc(p, s)
  52. #define CopyMemory(p, v, s) memcpy(p, v, s)
  53. #define FillMemory(p, c, s) memset(p, c, s)
  54. #define GlobalSize(p) sizeof(p)
  55. #define wsprintf sprintf
  56. #define wvsprintf vsprintf
  57. #define lstrlen strlen
  58.  
  59. static tsize_t LINKAGEMODE
  60. _tiffReadProc(thandle_t fd, tdata_t buf, tsize_t size)
  61. {
  62.     DWORD dwSizeRead;
  63.     if (!DosRead((HFILE)fd, buf, size, &dwSizeRead))
  64.         return(0);
  65.     return ((tsize_t) dwSizeRead);
  66. }
  67.  
  68. static tsize_t LINKAGEMODE
  69. _tiffWriteProc(thandle_t fd, tdata_t buf, tsize_t size)
  70. {
  71.     DWORD dwSizeWritten;
  72.     if (!DosWrite((HFILE)fd, buf, size, &dwSizeWritten))
  73.         return(0);
  74.     return ((tsize_t) dwSizeWritten);
  75. }
  76.  
  77. static toff_t LINKAGEMODE
  78. _tiffSeekProc(thandle_t fd, toff_t off, int whence)
  79. {
  80.     DWORD dwMoveMethod;
  81.     ULONG ibActual;
  82.     switch(whence)
  83.     {
  84.     case 0:
  85.         dwMoveMethod = FILE_BEGIN;
  86.         break;
  87.     case 1:
  88.         dwMoveMethod = FILE_CURRENT;
  89.         break;
  90.     case 2:
  91.         dwMoveMethod = FILE_END;
  92.         break;
  93.     default:
  94.         dwMoveMethod = FILE_BEGIN;
  95.         break;
  96.     }
  97.     DosSetFilePtr((HFILE)fd, off, dwMoveMethod, &ibActual);
  98.  return((toff_t)ibActual);
  99. }
  100.  
  101. static int LINKAGEMODE
  102. _tiffCloseProc(thandle_t fd)
  103. {
  104.     return (DosClose((HFILE)fd) ? 0 : -1);
  105. }
  106.  
  107. static toff_t LINKAGEMODE
  108. _tiffSizeProc(thandle_t fd)
  109. {
  110.    FILESTATUS3    vStatus;
  111.  
  112.    DosQueryFileInfo((HFILE)fd, FIL_STANDARD, &vStatus, sizeof(FILESTATUS3));
  113.    return (vStatus.cbFile);
  114. }
  115.  
  116. static int LINKAGEMODE
  117. _tiffDummyMapProc(thandle_t fd, tdata_t* pbase, toff_t* psize)
  118. {
  119.     return (0);
  120. }
  121.  
  122. /*
  123.  * From "Hermann Josef Hill" <lhill@rhein-zeitung.de>:
  124.  *
  125.  * Windows uses both a handle and a pointer for file mapping,
  126.  * but according to the SDK documentation and Richter's book
  127.  * "Advanced Windows Programming" it is safe to free the handle
  128.  * after obtaining the file mapping pointer
  129.  *
  130.  * This removes a nasty OS dependency and cures a problem
  131.  * with Visual C++ 5.0
  132.  */
  133. static int LINKAGEMODE
  134. _tiffMapProc(thandle_t fd, tdata_t* pbase, toff_t* psize)
  135. {
  136.     return(0);
  137. }
  138.  
  139. static void LINKAGEMODE
  140. _tiffDummyUnmapProc(thandle_t fd, tdata_t base, toff_t size)
  141. {
  142. }
  143.  
  144. static void LINKAGEMODE
  145. _tiffUnmapProc(thandle_t fd, tdata_t base, toff_t size)
  146. {
  147. }
  148.  
  149. /*
  150.  * Open a TIFF file descriptor for read/writing.
  151.  * Note that TIFFFdOpen and TIFFOpen recognise the character 'u' in the mode
  152.  * string, which forces the file to be opened unmapped.
  153.  */
  154. TIFF*
  155. TIFFFdOpen(int ifd, const char* name, const char* mode)
  156. {
  157.     TIFF* tif;
  158.     BOOL fSuppressMap = (mode[1] == 'u' || mode[2] == 'u');
  159.  
  160.     tif = TIFFClientOpen(name, mode,
  161.          (thandle_t)ifd,
  162.         _tiffReadProc, _tiffWriteProc,
  163.         _tiffSeekProc, _tiffCloseProc, _tiffSizeProc,
  164.          fSuppressMap ? _tiffDummyMapProc : _tiffMapProc,
  165.          fSuppressMap ? _tiffDummyUnmapProc : _tiffUnmapProc);
  166.     if (tif)
  167.         tif->tif_fd = ifd;
  168.     return (tif);
  169. }
  170.  
  171. /*
  172.  * Open a TIFF file for read/writing.
  173.  */
  174. TIFF*
  175. TIFFOpen(const char* name, const char* mode)
  176. {
  177.     static const char module[] = "TIFFOpen";
  178.     thandle_t fd;
  179.     int m;
  180.     DWORD dwOpenMode;
  181.  DWORD dwOpenFlags;
  182.  DWORD dwAction;
  183.  APIRET ulrc;
  184.  
  185.     m = _TIFFgetMode(mode, module);
  186.  
  187.     switch(m)
  188.     {
  189.     case O_RDONLY:
  190.         dwOpenMode = OPEN_ACCESS_READONLY;
  191.         dwOpenFlags = OPEN_ACTION_FAIL_IF_NEW;
  192.         break;
  193.     case O_RDWR:
  194.         dwOpenMode = OPEN_ACCESS_READWRITE;
  195.         dwOpenFlags = OPEN_ACTION_FAIL_IF_NEW;
  196.         break;
  197.     case O_RDWR|O_CREAT:
  198.         dwOpenMode = OPEN_ACCESS_READWRITE;
  199.         dwOpenFlags = OPEN_ACTION_CREATE_IF_NEW;
  200.         break;
  201.     case O_RDWR|O_TRUNC:
  202.         dwOpenMode = OPEN_ACCESS_READWRITE;
  203.         dwOpenFlags = OPEN_ACTION_FAIL_IF_NEW | OPEN_ACTION_OPEN_IF_EXISTS;
  204.         break;
  205.     case O_RDWR|O_CREAT|O_TRUNC:
  206.         dwOpenMode = OPEN_ACCESS_READWRITE;
  207.         dwOpenFlags = OPEN_ACTION_CREATE_IF_NEW | OPEN_ACTION_REPLACE_IF_EXISTS;
  208.         break;
  209.     default:
  210.         return ((TIFF*)0);
  211.     }
  212.  ulrc = DosOpen( name, (HFILE*)&fd, &dwAction, FILE_ARCHIVED|FILE_NORMAL
  213.                 ,1000L, dwOpenFlags, dwOpenMode, NULL
  214.                );
  215.     if (fd != NO_ERROR) {
  216.         TIFFError(module, "%s: Cannot open", name);
  217.         return ((TIFF *)0);
  218.     }
  219.     return (TIFFFdOpen((int)fd, name, mode));
  220. }
  221.  
  222. tdata_t
  223. _TIFFmalloc(tsize_t s)
  224. {
  225.     return ((tdata_t)GlobalAlloc(GMEM_FIXED, s));
  226. }
  227.  
  228. void
  229. _TIFFfree(tdata_t p)
  230. {
  231.     GlobalFree(p);
  232.     return;
  233. }
  234.  
  235. tdata_t
  236. _TIFFrealloc(tdata_t p, tsize_t s)
  237. {
  238.     void* pvTmp;
  239.     if ((pvTmp = GlobalReAlloc(p, s, 0)) == NULL) {
  240.         if ((pvTmp = GlobalAlloc(sGMEM_FIXED, s)) != NULL) {
  241.             CopyMemory(pvTmp, p, GlobalSize(p));
  242.             GlobalFree(p);
  243.         }
  244.     }
  245.     return ((tdata_t)pvTmp);
  246. }
  247.  
  248. void
  249. _TIFFmemset(void* p, int v, tsize_t c)
  250. {
  251.     FillMemory(p, c, (BYTE)v);
  252. }
  253.  
  254. void
  255. _TIFFmemcpy(void* d, const tdata_t s, tsize_t c)
  256. {
  257.     CopyMemory(d, s, c);
  258. }
  259.  
  260. int
  261. _TIFFmemcmp(const tdata_t p1, const tdata_t p2, tsize_t c)
  262. {
  263.     register const *pb1 = (const int*)p1;
  264.     register const *pb2 = (const int*)p2;
  265.     register DWORD dwTmp = c;
  266.     register int iTmp;
  267.     for (iTmp = 0; dwTmp-- && !iTmp; iTmp = (int)*pb1++ - (int)*pb2++)
  268.         ;
  269.     return (iTmp);
  270. }
  271.  
  272. static void LINKAGEMODE
  273. Os2WarningHandler(const char* module, const char* fmt, va_list ap)
  274. {
  275. #ifndef TIF_PLATFORM_CONSOLE
  276.     LPTSTR szTitle;
  277.     LPTSTR szTmp;
  278.     LPCTSTR szTitleText = "%s Warning";
  279.     LPCTSTR szDefaultModule = "TIFFLIB";
  280.     szTmp = (module == NULL) ? (LPTSTR)szDefaultModule : (LPTSTR)module;
  281.     if ((szTitle = (LPTSTR)LocalAlloc(LMEM_FIXED, (lstrlen(szTmp) +
  282.             lstrlen(szTitleText) + lstrlen(fmt) + 128)*sizeof(TCHAR))) == NULL)
  283.         return;
  284.     wsprintf(szTitle, szTitleText, szTmp);
  285.     szTmp = szTitle + (lstrlen(szTitle)+2)*sizeof(TCHAR);
  286.     wvsprintf(szTmp, fmt, ap);
  287.     WinMessageBox( HWND_DESKTOP
  288.                ,WinQueryFocus(HWND_DESKTOP)
  289.                ,szTmp
  290.                ,szTitle
  291.                ,0
  292.                ,MB_OK | MB_INFORMATION
  293.               );
  294.     LocalFree(szTitle);
  295.     return;
  296. #else
  297.     if (module != NULL)
  298.         fprintf(stderr, "%s: ", module);
  299.     fprintf(stderr, "Warning, ");
  300.     vfprintf(stderr, fmt, ap);
  301.     fprintf(stderr, ".\n");
  302. #endif
  303. }
  304. TIFFErrorHandler _TIFFwarningHandler = Os2WarningHandler;
  305.  
  306. static void LINKAGEMODE
  307. Os2ErrorHandler(const char* module, const char* fmt, va_list ap)
  308. {
  309. #ifndef TIF_PLATFORM_CONSOLE
  310.     LPTSTR szTitle;
  311.     LPTSTR szTmp;
  312.     LPCTSTR szTitleText = "%s Error";
  313.     LPCTSTR szDefaultModule = "TIFFLIB";
  314.     szTmp = (module == NULL) ? (LPTSTR)szDefaultModule : (LPTSTR)module;
  315.     if ((szTitle = (LPTSTR)LocalAlloc(LMEM_FIXED, (lstrlen(szTmp) +
  316.             lstrlen(szTitleText) + lstrlen(fmt) + 128)*sizeof(TCHAR))) == NULL)
  317.         return;
  318.     wsprintf(szTitle, szTitleText, szTmp);
  319.     szTmp = szTitle + (lstrlen(szTitle)+2)*sizeof(TCHAR);
  320.     wvsprintf(szTmp, fmt, ap);
  321.     WinMessageBox( HWND_DESKTOP
  322.                ,WinQueryFocus(HWND_DESKTOP)
  323.                ,szTmp
  324.                ,szTitle
  325.                ,0
  326.                ,MB_OK | MB_ICONEXCLAMATION
  327.               );
  328.     LocalFree(szTitle);
  329.     return;
  330. #else
  331.     if (module != NULL)
  332.         fprintf(stderr, "%s: ", module);
  333.     vfprintf(stderr, fmt, ap);
  334.     fprintf(stderr, ".\n");
  335. #endif
  336. }
  337. TIFFErrorHandler _TIFFerrorHandler = Os2ErrorHandler;
  338.  
  339.