home *** CD-ROM | disk | FTP | other *** search
/ Windows Graphics Programming / Feng_Yuan_Win32_GDI_DirectX.iso / Samples / Chapt_16 / EMFScope / STREAM.CPP < prev    next >
Encoding:
C/C++ Source or Header  |  2000-05-12  |  4.7 KB  |  215 lines
  1. //-----------------------------------------------------------------------------------//
  2. //              Windows Graphics Programming: Win32 GDI and DirectDraw               //
  3. //                             ISBN  0-13-086985-6                                   //
  4. //                                                                                   //
  5. //  Written            by  Yuan, Feng                             www.fengyuan.com   //
  6. //  Copyright (c) 2000 by  Hewlett-Packard Company                www.hp.com         //
  7. //  Published          by  Prentice Hall PTR, Prentice-Hall, Inc. www.phptr.com      //
  8. //                                                                                   //
  9. //  FileName   : stream.cpp                                                             //
  10. //  Description: KInputFile, KOutputFile                                             //
  11. //  Version    : 1.00.000, May 31, 2000                                              //
  12. //-----------------------------------------------------------------------------------//
  13.  
  14. #define STRICT
  15. #include <windows.h>
  16. #include <assert.h>
  17. #include <string.h>
  18.  
  19. #include "Stream.h"
  20.  
  21. BOOL KInputFile::Open(const TCHAR *filename)
  22. {
  23.     m_handle = CreateFile(filename, GENERIC_READ, 0, NULL,
  24.                           OPEN_EXISTING,
  25.                           FILE_ATTRIBUTE_NORMAL, NULL);
  26.     
  27.     if (m_handle==INVALID_HANDLE_VALUE) return FALSE;
  28.             
  29.     m_eof        = FALSE;
  30.     m_bufpos     = 0;
  31.     m_buflen     = 0;
  32.     m_fileoffset = 0;    
  33.  
  34.     return TRUE;
  35. }                           
  36.  
  37.  
  38. void KInputFile::Reset(void)        
  39. {
  40.     m_eof        = FALSE;
  41.     m_bufpos     = 0;
  42.     m_buflen     = 0;
  43.     m_fileoffset = 0;
  44.  
  45.     SetFilePointer(m_handle, 0, 0, FILE_BEGIN);
  46. }
  47.  
  48.  
  49. void KInputFile::Close(void)
  50. {
  51.     if (m_handle!=INVALID_HANDLE_VALUE)
  52.     {
  53.         CloseHandle(m_handle);
  54.  
  55.         m_handle = INVALID_HANDLE_VALUE;
  56.     }
  57. }
  58.  
  59.  
  60. BYTE KInputFile::readbyte(void)
  61. {
  62.     if (m_bufpos >= m_buflen)             // input buffer empty
  63.     {
  64.         if (m_eof)
  65.             return c_EOF;
  66.  
  67.         ReadFile(m_handle, m_buffer, c_bufsize, &m_buflen, NULL); 
  68.         m_fileoffset += m_buflen;
  69.  
  70.         m_bufpos = 0;
  71.         if (m_buflen<=0) 
  72.         {   
  73.             m_eof=TRUE;
  74.             return c_EOF;
  75.         }            
  76.     }
  77.     
  78.     return m_buffer[m_bufpos++]; 
  79. }
  80.  
  81.  
  82. DWORD KInputFile::readdword(void)
  83. {
  84.     DWORD *prslt;
  85.     char   temp[4];
  86.  
  87.     if (m_buflen < m_bufpos + 4 )
  88.     {
  89.         for (int i=0; i<4; i++)
  90.             temp[i] = readbyte();
  91.  
  92.         prslt = (DWORD *)temp;
  93.     }
  94.     else
  95.     {
  96.         prslt = (DWORD *) (& m_buffer[m_bufpos]);
  97.         m_bufpos+= 4;
  98.     }
  99.  
  100.     return *prslt;
  101. }
  102.  
  103.  
  104. int KInputFile::read(char *buffer, int len)
  105. {
  106.     int copied = 0;
  107.  
  108.     while (len)
  109.     {
  110.         int l = m_buflen - m_bufpos;
  111.  
  112.         if (l>0)                // copy from current buffer
  113.         {
  114.             if (l>len)
  115.                 l = len;
  116.  
  117.             if (buffer)
  118.             {
  119.                 memcpy(buffer, & m_buffer[m_bufpos], l);
  120.                 buffer   += l;
  121.             }
  122.     
  123.             copied   += l;
  124.             m_bufpos += l;
  125.             len      -= l;
  126.         }
  127.         else 
  128.         {
  129.             if ( buffer==NULL ) // skipping only
  130.             {
  131.                 m_fileoffset += len;
  132.                 SetFilePointer(m_handle, m_fileoffset, NULL, FILE_BEGIN);    // move pointer
  133.  
  134.                 return copied + len;                                        // m_buffer is still empty
  135.             }
  136.  
  137.             ReadFile(m_handle, m_buffer, c_bufsize, &m_buflen, NULL);        // read a buffer-full of data
  138.             m_fileoffset += m_buflen;
  139.  
  140.             m_bufpos = 0;
  141.             
  142.             if (m_buflen<=0)
  143.             {
  144.                 m_eof = TRUE;
  145.                 break;
  146.             }
  147.         }
  148.     }
  149.  
  150.     return copied;
  151. }
  152.  
  153. /////////////////////////////////////////
  154.  
  155. BOOL KOutputFile::Open(const char far *filename)
  156. {
  157.     m_handle = CreateFile(filename, GENERIC_WRITE, 0, NULL, CREATE_NEW,
  158.                           FILE_ATTRIBUTE_NORMAL, NULL);
  159.  
  160.     if (m_handle==INVALID_HANDLE_VALUE) return FALSE;
  161.             
  162.     m_bufpos = 0;
  163.         
  164.     return TRUE;
  165. }                           
  166.         
  167.  
  168. void KOutputFile::Flush(void)
  169. {   
  170.     if (m_bufpos)
  171.     {
  172.         unsigned long dwWritten;
  173.  
  174.         WriteFile(m_handle, m_buffer, m_bufpos, &dwWritten, NULL);
  175.         m_bufpos = 0;
  176.     }        
  177. }
  178.  
  179. void KOutputFile::Close(void)
  180. {
  181.     if (m_handle!=INVALID_HANDLE_VALUE)
  182.     {
  183.         Flush();
  184.         CloseHandle(m_handle);
  185.         m_handle = INVALID_HANDLE_VALUE;
  186.     }
  187. }
  188.  
  189. void KOutputFile::write(BYTE b)
  190. {   
  191.     if (b=='\n')
  192.     {   m_buffer[m_bufpos++ ] = '\r';
  193.         if (m_bufpos >= c_bufsize)
  194.             Flush();
  195.     }
  196.                 
  197.     m_buffer[m_bufpos++] = b;
  198.     
  199.     if (m_bufpos >= c_bufsize)             // input buffer empty
  200.         Flush();
  201. }
  202.  
  203. void KOutputFile::write(const char far *str)
  204. {
  205.     while (*str)
  206.         write(*str++);
  207. }
  208.  
  209. const char hexmap[] = "0123456789ABCDEF";
  210.  
  211. void KOutputFile::writehex(BYTE b)
  212. {
  213.     write(hexmap[ (b>>4) & 15]);
  214.     write(hexmap[ b      & 15]);
  215. }