Added wxOutputStream::PutC()

[wxWidgets.git] / src / common / imagpcx.cpp

diff --git a/src/common/imagpcx.cpp b/src/common/imagpcx.cpp
index f8c036362462c51b42a90070b898492422a9b202..e2036987967d262405557b9c4264aeefa493ec98 100644 (file)
--- a/src/common/imagpcx.cpp
+++ b/src/common/imagpcx.cpp
@@ -20,16 +20,23 @@
 #pragma hdrstop
 #endif
 
 #pragma hdrstop
 #endif
 

+#ifndef WX_PRECOMP
+#  include "wx/defs.h"
+#endif
+
+#if wxUSE_STREAMS && wxUSE_PCX
+

 #include "wx/image.h"
 #include "wx/wfstream.h"
 #include "wx/module.h"
 #include "wx/log.h"
 #include "wx/image.h"
 #include "wx/wfstream.h"
 #include "wx/module.h"
 #include "wx/log.h"

+#include "wx/intl.h"

 
 //-----------------------------------------------------------------------------
 // PCX decoding
 //-----------------------------------------------------------------------------
 
 
 //-----------------------------------------------------------------------------
 // PCX decoding
 //-----------------------------------------------------------------------------
 

-void RLEencode(unsigned char *p, unsigned int size, wxOutputStream& s)
+void RLEencode(unsigned char *WXUNUSED(p), unsigned int WXUNUSED(size), wxOutputStream& WXUNUSED(s))

 {
 }
 
 {
 }
 


@@ -69,31 +76,34 @@ void RLEdecode(unsigned char *p, unsigned int size, wxInputStream& s)
 
 
 /* PCX header */
 
 
 /* PCX header */

-#define HDR_VERSION         1        
+#define HDR_VERSION         1

 #define HDR_ENCODING        2
 #define HDR_BITSPERPIXEL    3
 #define HDR_XMIN            4
 #define HDR_YMIN            6
 #define HDR_ENCODING        2
 #define HDR_BITSPERPIXEL    3
 #define HDR_XMIN            4
 #define HDR_YMIN            6

-#define HDR_XMAX            8 
+#define HDR_XMAX            8

 #define HDR_YMAX            10
 #define HDR_NPLANES         65
 #define HDR_BYTESPERLINE    66
 
 #define HDR_YMAX            10
 #define HDR_NPLANES         65
 #define HDR_BYTESPERLINE    66
 

-/* image formats */
-#define IMAGE_8BIT  0       // 8 bpp, 1 plane (8 bit)
-#define IMAGE_24BIT 1       // 8 bpp, 3 planes (24 bit)
-
-/* error codes */
-#define E_OK        0       // everything was OK
-#define E_FORMATO   1       // error in pcx file format
-#define E_MEMORIA   2       // error allocating memory
-#define E_VERSION   3       // error in pcx version number
+// image formats
+enum {
+    wxPCX_8BIT,             // 8 bpp, 1 plane (8 bit)
+    wxPCX_24BIT             // 8 bpp, 3 planes (24 bit)
+};

 
 

+// error codes
+enum {
+    wxPCX_OK = 0,           // everything was OK
+    wxPCX_INVFORMAT = 1,    // error in pcx file format
+    wxPCX_MEMERR = 2,       // error allocating memory
+    wxPCX_VERERR = 3        // error in pcx version number
+};

 
 // ReadPCX:
 //  Loads a PCX file into the wxImage object pointed by image.
 
 // ReadPCX:
 //  Loads a PCX file into the wxImage object pointed by image.

-//  Returns E_OK on success, or an error code otherwise (see
-//  above for error codes)
+//  Returns wxPCX_OK on success, or an error code otherwise
+//  (see above for error codes)

 //
 int ReadPCX(wxImage *image, wxInputStream& stream)
 {
 //
 int ReadPCX(wxImage *image, wxInputStream& stream)
 {


@@ -115,7 +125,7 @@ int ReadPCX(wxImage *image, wxInputStream& stream)
     //
     stream.Read(hdr, 128);
 
     //
     stream.Read(hdr, 128);
 

-    if (hdr[HDR_VERSION] < 5) return E_VERSION;
+    if (hdr[HDR_VERSION] < 5) return wxPCX_VERERR;

 
     // Extract all image info from the PCX header.
     //
 
     // Extract all image info from the PCX header.
     //


@@ -132,23 +142,23 @@ int ReadPCX(wxImage *image, wxInputStream& stream)
     // 8 bits (8 bpp, 1 plane) and 24 bits (8 bpp, 3 planes).
     //
     if ((nplanes == 3) && (bitsperpixel == 8))
     // 8 bits (8 bpp, 1 plane) and 24 bits (8 bpp, 3 planes).
     //
     if ((nplanes == 3) && (bitsperpixel == 8))

-        format = IMAGE_24BIT;
+        format = wxPCX_24BIT;

     else if ((nplanes == 1) && (bitsperpixel == 8))
     else if ((nplanes == 1) && (bitsperpixel == 8))

-        format = IMAGE_8BIT;
+        format = wxPCX_8BIT;

     else
     else

-        return E_FORMATO;
+        return wxPCX_INVFORMAT;

 
 

-    // If the image is of type IMAGE_8BIT, then there is a
+    // If the image is of type wxPCX_8BIT, then there is a

     // palette at the end of the file. Read it now before
     // proceeding.
     //
     // palette at the end of the file. Read it now before
     // proceeding.
     //

-    if (format == IMAGE_8BIT)
+    if (format == wxPCX_8BIT)

     {
         pos = stream.TellI();
         stream.SeekI(-769, wxFromEnd);
 
         if (stream.GetC() != 12)
     {
         pos = stream.TellI();
         stream.SeekI(-769, wxFromEnd);
 
         if (stream.GetC() != 12)

-            return E_FORMATO;
+            return wxPCX_INVFORMAT;

 
         stream.Read(pal, 768);
         stream.SeekI(pos, wxFromStart);
 
         stream.Read(pal, 768);
         stream.SeekI(pos, wxFromStart);


@@ -159,10 +169,10 @@ int ReadPCX(wxImage *image, wxInputStream& stream)
     image->Create(width, height);
 
     if (!image->Ok())
     image->Create(width, height);
 
     if (!image->Ok())

-        return E_MEMORIA;
+        return wxPCX_MEMERR;

 
     if ((p = (unsigned char *) malloc(bytesperline * nplanes)) == NULL)
 
     if ((p = (unsigned char *) malloc(bytesperline * nplanes)) == NULL)

-        return E_MEMORIA;
+        return wxPCX_MEMERR;

 
     // Now start reading the file, line by line, and store
     // the data in the format required by wxImage.
 
     // Now start reading the file, line by line, and store
     // the data in the format required by wxImage.


@@ -178,7 +188,7 @@ int ReadPCX(wxImage *image, wxInputStream& stream)
 
         switch (format)
         {
 
         switch (format)
         {

-            case IMAGE_8BIT:
+            case wxPCX_8BIT:

             {
                 for (i = 0; i < width; i++)
                 {
             {
                 for (i = 0; i < width; i++)
                 {


@@ -188,13 +198,13 @@ int ReadPCX(wxImage *image, wxInputStream& stream)
                 }
                 break;
             }
                 }
                 break;
             }

-            case IMAGE_24BIT:
+            case wxPCX_24BIT:

             {
                 for (i = 0; i < width; i++)
                 {
                     *(dst++) = p[i];
                     *(dst++) = p[i + bytesperline];
             {
                 for (i = 0; i < width; i++)
                 {
                     *(dst++) = p[i];
                     *(dst++) = p[i + bytesperline];

-                    *(dst++) = p[i + 2 * bytesperline]; 
+                    *(dst++) = p[i + 2 * bytesperline];

                 }
                 break;
             }
                 }
                 break;
             }


@@ -203,7 +213,7 @@ int ReadPCX(wxImage *image, wxInputStream& stream)
 
     free(p);
 
 
     free(p);
 

-    return E_OK;
+    return wxPCX_OK;

 }
 
 
 }
 
 


@@ -215,32 +225,30 @@ int ReadPCX(wxImage *image, wxInputStream& stream)
 IMPLEMENT_DYNAMIC_CLASS(wxPCXHandler,wxImageHandler)
 #endif
 
 IMPLEMENT_DYNAMIC_CLASS(wxPCXHandler,wxImageHandler)
 #endif
 

-#if wxUSE_STREAMS
-
-bool wxPCXHandler::LoadFile( wxImage *image, wxInputStream& stream, bool verbose )
+bool wxPCXHandler::LoadFile( wxImage *image, wxInputStream& stream, bool verbose, int WXUNUSED(index) )

 {
     int error;
 
     if (!CanRead(stream))
     {
         if (verbose)
 {
     int error;
 
     if (!CanRead(stream))
     {
         if (verbose)

-            wxLogError(_T("wxPCXHandler: this is not a PCX file"));
+            wxLogError(_("PCX: this is not a PCX file."));

 
         return FALSE;
     }
 
     image->Destroy();
 
 
         return FALSE;
     }
 
     image->Destroy();
 

-    if ((error = ReadPCX(image, stream)) != E_OK)
+    if ((error = ReadPCX(image, stream)) != wxPCX_OK)

     {
         if (verbose)
         {
             switch (error)
             {
     {
         if (verbose)
         {
             switch (error)
             {

-                case E_FORMATO: wxLogError(_T("wxPCXHandler: image format unsupported")); break;
-                case E_MEMORIA: wxLogError(_T("wxPCXHandler: couldn't allocate memory")); break;
-                case E_VERSION: wxLogError(_T("wxPCXHandler: version number too low")); break;
-                default:        wxLogError(_T("wxPCXHandler: unknown error !!!"));
+                case wxPCX_INVFORMAT: wxLogError(_("wxPCXHandler: image format unsupported")); break;
+                case wxPCX_MEMERR:    wxLogError(_("wxPCXHandler: couldn't allocate memory")); break;
+                case wxPCX_VERERR:    wxLogError(_("wxPCXHandler: version number too low")); break;
+                default:              wxLogError(_("wxPCXHandler: unknown error !!!"));

             }
         }
         image->Destroy();
             }
         }
         image->Destroy();


@@ -250,29 +258,23 @@ bool wxPCXHandler::LoadFile( wxImage *image, wxInputStream& stream, bool verbose
     return TRUE;
 }
 
     return TRUE;
 }
 

-bool wxPCXHandler::SaveFile( wxImage *image, wxOutputStream& stream, bool verbose )
+bool wxPCXHandler::SaveFile( wxImage *WXUNUSED(image), wxOutputStream& WXUNUSED(stream), bool verbose )

 {
 {

-    if (verbose)
-        wxLogError(_T("wxPCXHandler::SaveFile still not implemented"));
+    wxFAIL_MSG(wxT("wxPCXHandler::SaveFile still not implemented"));

 
     return FALSE;
 }
 
 
     return FALSE;
 }
 

-bool wxPCXHandler::CanRead( wxInputStream& stream )
+bool wxPCXHandler::DoCanRead( wxInputStream& stream )

 {
     unsigned char c;
 {
     unsigned char c;

-    off_t pos;

 
 

-    pos = stream.TellI();
-    stream.SeekI(0, wxFromStart);

     c = stream.GetC();
     c = stream.GetC();

-    stream.SeekI(pos, wxFromStart);
+    stream.SeekI(-1, wxFromCurrent);

 
     // not very safe, but this is all we can get from PCX header :-(
     return (c == 10);
 }
 
 
     // not very safe, but this is all we can get from PCX header :-(
     return (c == 10);
 }
 

-
-#endif // wxUSE_STREAMS
-
+#endif // wxUSE_STREAMS && wxUSE_PCX