开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 打印编程 > 查看源码
tif_win32.c
资源名称：PopFaxPrinter_src_v2.01.zip　[点击查看]
上传用户：looem2003
上传日期：2014-07-20
资源大小：13733k
文件大小：10k
源码类别：

打印编程

开发平台：

Visual C++

tif_win32.c：源码内容
  1. /* $Id: tif_win32.c,v 1.18 2006/02/07 11:03:29 dron Exp $ */
  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.  */
  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 "tiffiop.h"
  32. #include "windows.h"
  33. static tsize_t
  34. _tiffReadProc(thandle_t fd, tdata_t buf, tsize_t size)
  35. {
  36. DWORD dwSizeRead;
  37. if (!ReadFile(fd, buf, size, &dwSizeRead, NULL))
  38. return(0);
  39. return ((tsize_t) dwSizeRead);
  40. }
  42. static tsize_t
  43. _tiffWriteProc(thandle_t fd, tdata_t buf, tsize_t size)
  44. {
  45. DWORD dwSizeWritten;
  46. if (!WriteFile(fd, buf, size, &dwSizeWritten, NULL))
  47. return(0);
  48. return ((tsize_t) dwSizeWritten);
  49. }
  51. static toff_t
  52. _tiffSeekProc(thandle_t fd, toff_t off, int whence)
  53. {
  54. DWORD dwMoveMethod, dwMoveHigh;
  56.         /* we use this as a special code, so avoid accepting it */
  57.         if( off == 0xFFFFFFFF )
  58.             return 0xFFFFFFFF;
  59.         
  60. switch(whence)
  61. {
  62. case SEEK_SET:
  63. dwMoveMethod = FILE_BEGIN;
  64. break;
  65. case SEEK_CUR:
  66. dwMoveMethod = FILE_CURRENT;
  67. break;
  68. case SEEK_END:
  69. dwMoveMethod = FILE_END;
  70. break;
  71. default:
  72. dwMoveMethod = FILE_BEGIN;
  73. break;
  74. }
  75.         dwMoveHigh = 0;
  76. return ((toff_t)SetFilePointer(fd, (LONG) off, (PLONG)&dwMoveHigh,
  77.                                        dwMoveMethod));
  78. }
  80. static int
  81. _tiffCloseProc(thandle_t fd)
  82. {
  83. return (CloseHandle(fd) ? 0 : -1);
  84. }
  86. static toff_t
  87. _tiffSizeProc(thandle_t fd)
  88. {
  89. return ((toff_t)GetFileSize(fd, NULL));
  90. }
  92. #ifdef __BORLANDC__
  93. #pragma argsused
  94. #endif
  95. static int
  96. _tiffDummyMapProc(thandle_t fd, tdata_t* pbase, toff_t* psize)
  97. {
  98. return (0);
  99. }
  101. /*
  102.  * From "Hermann Josef Hill" <lhill@rhein-zeitung.de>:
  103.  *
  104.  * Windows uses both a handle and a pointer for file mapping,
  105.  * but according to the SDK documentation and Richter's book
  106.  * "Advanced Windows Programming" it is safe to free the handle
  107.  * after obtaining the file mapping pointer
  108.  *
  109.  * This removes a nasty OS dependency and cures a problem
  110.  * with Visual C++ 5.0
  111.  */
  112. static int
  113. _tiffMapProc(thandle_t fd, tdata_t* pbase, toff_t* psize)
  114. {
  115. toff_t size;
  116. HANDLE hMapFile;
  118. if ((size = _tiffSizeProc(fd)) == 0xFFFFFFFF)
  119. return (0);
  120. hMapFile = CreateFileMapping(fd, NULL, PAGE_READONLY, 0, size, NULL);
  121. if (hMapFile == NULL)
  122. return (0);
  123. *pbase = MapViewOfFile(hMapFile, FILE_MAP_READ, 0, 0, 0);
  124. CloseHandle(hMapFile);
  125. if (*pbase == NULL)
  126. return (0);
  127. *psize = size;
  128. return(1);
  129. }
  131. #ifdef __BORLANDC__
  132. #pragma argsused
  133. #endif
  134. static void
  135. _tiffDummyUnmapProc(thandle_t fd, tdata_t base, toff_t size)
  136. {
  137. }
  139. static void
  140. _tiffUnmapProc(thandle_t fd, tdata_t base, toff_t size)
  141. {
  142. UnmapViewOfFile(base);
  143. }
  145. /*
  146.  * Open a TIFF file descriptor for read/writing.
  147.  * Note that TIFFFdOpen and TIFFOpen recognise the character 'u' in the mode
  148.  * string, which forces the file to be opened unmapped.
  149.  */
  150. TIFF*
  151. TIFFFdOpen(int ifd, const char* name, const char* mode)
  152. {
  153. TIFF* tif;
  154. BOOL fSuppressMap = (mode[1] == 'u' || (mode[1]!=0 && mode[2] == 'u'));
  156. tif = TIFFClientOpen(name, mode, (thandle_t)ifd,
  157. _tiffReadProc, _tiffWriteProc,
  158. _tiffSeekProc, _tiffCloseProc, _tiffSizeProc,
  159. fSuppressMap ? _tiffDummyMapProc : _tiffMapProc,
  160. fSuppressMap ? _tiffDummyUnmapProc : _tiffUnmapProc);
  161. if (tif)
  162. tif->tif_fd = ifd;
  163. return (tif);
  164. }
  166. /*
  167.  * Open a TIFF file for read/writing.
  168.  */
  169. TIFF*
  170. TIFFOpen(const char* name, const char* mode)
  171. {
  172. static const char module[] = "TIFFOpen";
  173. thandle_t fd;
  174. int m;
  175. DWORD dwMode;
  176. TIFF* tif;
  178. m = _TIFFgetMode(mode, module);
  180. switch(m)
  181. {
  182. case O_RDONLY:
  183. dwMode = OPEN_EXISTING;
  184. break;
  185. case O_RDWR:
  186. dwMode = OPEN_ALWAYS;
  187. break;
  188. case O_RDWR|O_CREAT:
  189. dwMode = OPEN_ALWAYS;
  190. break;
  191. case O_RDWR|O_TRUNC:
  192. dwMode = CREATE_ALWAYS;
  193. break;
  194. case O_RDWR|O_CREAT|O_TRUNC:
  195. dwMode = CREATE_ALWAYS;
  196. break;
  197. default:
  198. return ((TIFF*)0);
  199. }
  200. fd = (thandle_t)CreateFileA(name,
  201. (m == O_RDONLY)?GENERIC_READ:(GENERIC_READ | GENERIC_WRITE),
  202. FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, dwMode,
  203. (m == O_RDONLY)?FILE_ATTRIBUTE_READONLY:FILE_ATTRIBUTE_NORMAL,
  204. NULL);
  205. if (fd == INVALID_HANDLE_VALUE) {
  206. TIFFErrorExt(0, module, "%s: Cannot open", name);
  207. return ((TIFF *)0);
  208. }
  210. tif = TIFFFdOpen((int)fd, name, mode);
  211. if(!tif)
  212. CloseHandle(fd);
  213. return tif;
  214. }
  216. /*
  217.  * Open a TIFF file with a Unicode filename, for read/writing.
  218.  */
  219. TIFF*
  220. TIFFOpenW(const wchar_t* name, const char* mode)
  221. {
  222. static const char module[] = "TIFFOpenW";
  223. thandle_t fd;
  224. int m;
  225. DWORD dwMode;
  226. int mbsize;
  227. char *mbname;
  228. TIFF *tif;
  230. m = _TIFFgetMode(mode, module);
  232. switch(m) {
  233. case O_RDONLY: dwMode = OPEN_EXISTING; break;
  234. case O_RDWR: dwMode = OPEN_ALWAYS;   break;
  235. case O_RDWR|O_CREAT: dwMode = OPEN_ALWAYS;   break;
  236. case O_RDWR|O_TRUNC: dwMode = CREATE_ALWAYS; break;
  237. case O_RDWR|O_CREAT|O_TRUNC: dwMode = CREATE_ALWAYS; break;
  238. default: return ((TIFF*)0);
  239. }
  241. fd = (thandle_t)CreateFileW(name,
  242. (m == O_RDONLY)?GENERIC_READ:(GENERIC_READ|GENERIC_WRITE),
  243. FILE_SHARE_READ, NULL, dwMode,
  244. (m == O_RDONLY)?FILE_ATTRIBUTE_READONLY:FILE_ATTRIBUTE_NORMAL,
  245. NULL);
  246. if (fd == INVALID_HANDLE_VALUE) {
  247. TIFFErrorExt(0, module, "%S: Cannot open", name);
  248. return ((TIFF *)0);
  249. }
  251. mbname = NULL;
  252. mbsize = WideCharToMultiByte(CP_ACP, 0, name, -1, NULL, 0, NULL, NULL);
  253. if (mbsize > 0) {
  254. mbname = (char *)_TIFFmalloc(mbsize);
  255. if (!mbname) {
  256. TIFFErrorExt(0, module,
  257. "Can't allocate space for filename conversion buffer");
  258. return ((TIFF*)0);
  259. }
  261. WideCharToMultiByte(CP_ACP, 0, name, -1, mbname, mbsize,
  262.     NULL, NULL);
  263. }
  265. tif = TIFFFdOpen((int)fd,
  266.  (mbname != NULL) ? mbname : "<unknown>", mode);
  267. if(!tif)
  268. CloseHandle(fd);
  270. _TIFFfree(mbname);
  272. return tif;
  273. }
  275. tdata_t
  276. _TIFFmalloc(tsize_t s)
  277. {
  278. return ((tdata_t)GlobalAlloc(GMEM_FIXED, s));
  279. }
  281. void
  282. _TIFFfree(tdata_t p)
  283. {
  284. GlobalFree(p);
  285. return;
  286. }
  288. tdata_t
  289. _TIFFrealloc(tdata_t p, tsize_t s)
  290. {
  291.         void* pvTmp;
  292.         tsize_t old;
  294.         if(p == NULL)
  295.                 return ((tdata_t)GlobalAlloc(GMEM_FIXED, s));
  297.         old = GlobalSize(p);
  299.         if (old>=s) {
  300.                 if ((pvTmp = GlobalAlloc(GMEM_FIXED, s)) != NULL) {
  301.                 CopyMemory(pvTmp, p, s);
  302.                 GlobalFree(p);
  303.                 }
  304.         } else {
  305.                 if ((pvTmp = GlobalAlloc(GMEM_FIXED, s)) != NULL) {
  306.                 CopyMemory(pvTmp, p, old);
  307.                 GlobalFree(p);
  308.                 }
  309.         }
  310.         return ((tdata_t)pvTmp);
  311. }
  313. void
  314. _TIFFmemset(void* p, int v, tsize_t c)
  315. {
  316. FillMemory(p, c, (BYTE)v);
  317. }
  319. void
  320. _TIFFmemcpy(void* d, const tdata_t s, tsize_t c)
  321. {
  322. CopyMemory(d, s, c);
  323. }
  325. int
  326. _TIFFmemcmp(const tdata_t p1, const tdata_t p2, tsize_t c)
  327. {
  328. register const BYTE *pb1 = (const BYTE *) p1;
  329. register const BYTE *pb2 = (const BYTE *) p2;
  330. register DWORD dwTmp = c;
  331. register int iTmp;
  332. for (iTmp = 0; dwTmp-- && !iTmp; iTmp = (int)*pb1++ - (int)*pb2++)
  333. ;
  334. return (iTmp);
  335. }
  337. static void
  338. Win32WarningHandler(const char* module, const char* fmt, va_list ap)
  339. {
  340. /*
  341. #ifndef TIF_PLATFORM_CONSOLE
  342. LPTSTR szTitle;
  343. LPTSTR szTmp;
  344. LPCTSTR szTitleText = "%s Warning";
  345. LPCTSTR szDefaultModule = "LIBTIFF";
  346. LPCTSTR szTmpModule = (module == NULL) ? szDefaultModule : module;
  347. if ((szTitle = (LPTSTR)LocalAlloc(LMEM_FIXED, (strlen(szTmpModule) +
  348. strlen(szTitleText) + strlen(fmt) + 128)*sizeof(char))) == NULL)
  349. return;
  350. sprintf(szTitle, szTitleText, szTmpModule);
  351. szTmp = szTitle + (strlen(szTitle)+2)*sizeof(char);
  352. vsprintf(szTmp, fmt, ap);
  353. MessageBoxA(GetFocus(), szTmp, szTitle, MB_OK | MB_ICONINFORMATION);
  354. LocalFree(szTitle);
  355. return;
  356. #else
  357. if (module != NULL)
  358. fprintf(stderr, "%s: ", module);
  359. fprintf(stderr, "Warning, ");
  360. vfprintf(stderr, fmt, ap);
  361. fprintf(stderr, ".n");
  362. #endif        
  363. */
  364. }
  365. TIFFErrorHandler _TIFFwarningHandler = Win32WarningHandler;
  367. static void
  368. Win32ErrorHandler(const char* module, const char* fmt, va_list ap)
  369. {
  370.                         /*
  371. #ifndef TIF_PLATFORM_CONSOLE
  372. LPTSTR szTitle;
  373. LPTSTR szTmp;
  374. LPCTSTR szTitleText = "%s Error";
  375. LPCTSTR szDefaultModule = "LIBTIFF";
  376. LPCTSTR szTmpModule = (module == NULL) ? szDefaultModule : module;
  377. if ((szTitle = (LPTSTR)LocalAlloc(LMEM_FIXED, (strlen(szTmpModule) +
  378. strlen(szTitleText) + strlen(fmt) + 128)*sizeof(char))) == NULL)
  379. return;
  380. sprintf(szTitle, szTitleText, szTmpModule);
  381. szTmp = szTitle + (strlen(szTitle)+2)*sizeof(char);
  382. vsprintf(szTmp, fmt, ap);
  383. MessageBoxA(GetFocus(), szTmp, szTitle, MB_OK | MB_ICONEXCLAMATION);
  384. LocalFree(szTitle);
  385. return;
  386. #else
  387. if (module != NULL)
  388. fprintf(stderr, "%s: ", module);
  389. vfprintf(stderr, fmt, ap);
  390. fprintf(stderr, ".n");
  391. #endif        
  392. */
  393. }
  394. TIFFErrorHandler _TIFFerrorHandler = Win32ErrorHandler;
  396. /* vim: set ts=8 sts=8 sw=8 noet: */