Removed no longer needed code to fix combo sizing (causes layout problems on Windows)

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

diff --git a/src/common/image.cpp b/src/common/image.cpp
index 43634787ce77bc783c6353a6e2fdd51613abc35b..8d1794a51d84497cbebe6715b97c1b4f2dfdb4d3 100644 (file)
--- a/src/common/image.cpp
+++ b/src/common/image.cpp
@@ -1,5 +1,5 @@
 /////////////////////////////////////////////////////////////////////////////
 /////////////////////////////////////////////////////////////////////////////

-// Name:        image.cpp
+// Name:        src/common/image.cpp

 // Purpose:     wxImage
 // Author:      Robert Roebling
 // RCS-ID:      $Id$
 // Purpose:     wxImage
 // Author:      Robert Roebling
 // RCS-ID:      $Id$


@@ -380,7 +380,7 @@ wxImage wxImage::ShrinkBy( int xFactor , int yFactor ) const
         }
     }
 
         }
     }
 

-    // In case this is a cursor, make sure the hotspot is scalled accordingly:
+    // In case this is a cursor, make sure the hotspot is scaled accordingly:

     if ( HasOption(wxIMAGE_OPTION_CUR_HOTSPOT_X) )
         image.SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_X,
                 (GetOptionInt(wxIMAGE_OPTION_CUR_HOTSPOT_X))/xFactor);
     if ( HasOption(wxIMAGE_OPTION_CUR_HOTSPOT_X) )
         image.SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_X,
                 (GetOptionInt(wxIMAGE_OPTION_CUR_HOTSPOT_X))/xFactor);


@@ -466,7 +466,7 @@ wxImage wxImage::Scale( int width, int height ) const
         y += y_delta;
     }
 
         y += y_delta;
     }
 

-    // In case this is a cursor, make sure the hotspot is scalled accordingly:
+    // In case this is a cursor, make sure the hotspot is scaled accordingly:

     if ( HasOption(wxIMAGE_OPTION_CUR_HOTSPOT_X) )
         image.SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_X,
                 (GetOptionInt(wxIMAGE_OPTION_CUR_HOTSPOT_X)*width)/old_width);
     if ( HasOption(wxIMAGE_OPTION_CUR_HOTSPOT_X) )
         image.SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_X,
                 (GetOptionInt(wxIMAGE_OPTION_CUR_HOTSPOT_X)*width)/old_width);


@@ -1554,7 +1554,13 @@ bool wxImage::LoadFile( wxInputStream& stream, long type, int index )
         return false;
     }
 
         return false;
     }
 

-    return handler->LoadFile(this, stream, true/*verbose*/, index);
+    if (!handler->CanRead(stream))
+    {
+        wxLogError(_("Image file is not of type %d."), type);
+        return false;
+    }
+    else
+        return handler->LoadFile(this, stream, true/*verbose*/, index);

 }
 
 bool wxImage::LoadFile( wxInputStream& stream, const wxString& mimetype, int index )
 }
 
 bool wxImage::LoadFile( wxInputStream& stream, const wxString& mimetype, int index )


@@ -1572,7 +1578,13 @@ bool wxImage::LoadFile( wxInputStream& stream, const wxString& mimetype, int ind
         return false;
     }
 
         return false;
     }
 

-    return handler->LoadFile( this, stream, true/*verbose*/, index );
+    if (!handler->CanRead(stream))
+    {
+        wxLogError(_("Image file is not of type %s."), (const wxChar*) mimetype);
+        return false;
+    }
+    else
+        return handler->LoadFile( this, stream, true/*verbose*/, index );

 }
 
 bool wxImage::SaveFile( wxOutputStream& stream, int type ) const
 }
 
 bool wxImage::SaveFile( wxOutputStream& stream, int type ) const


@@ -1751,29 +1763,36 @@ wxString wxImage::GetImageExtWildcard()
 
 wxImage::HSVValue wxImage::RGBtoHSV(const RGBValue& rgb)
 {
 
 wxImage::HSVValue wxImage::RGBtoHSV(const RGBValue& rgb)
 {

-    double hue, saturation, value;
-

     const double red = rgb.red / 255.0,
                  green = rgb.green / 255.0,
                  blue = rgb.blue / 255.0;
 
     const double red = rgb.red / 255.0,
                  green = rgb.green / 255.0,
                  blue = rgb.blue / 255.0;
 

+    // find the min and max intensity (and remember which one was it for the
+    // latter)

     double minimumRGB = red;
     double minimumRGB = red;

-    if (green < minimumRGB)
+    if ( green < minimumRGB )

         minimumRGB = green;
         minimumRGB = green;

-
-    if (blue < minimumRGB)
+    if ( blue < minimumRGB )

         minimumRGB = blue;
 
         minimumRGB = blue;
 

+    enum { RED, GREEN, BLUE } chMax = RED;

     double maximumRGB = red;
     double maximumRGB = red;

-    if (green > maximumRGB)
+    if ( green > maximumRGB )
+    {
+        chMax = GREEN;

         maximumRGB = green;
         maximumRGB = green;

-
-    if (blue > maximumRGB)
+    }
+    if ( blue > maximumRGB )
+    {
+        chMax = BLUE;

         maximumRGB = blue;
         maximumRGB = blue;

+    }

 
 

-    value = maximumRGB;
+    const double value = maximumRGB;

 
 

-    if (maximumRGB == minimumRGB)
+    double hue = 0.0, saturation;
+    const double deltaRGB = maximumRGB - minimumRGB;
+    if ( wxIsNullDouble(deltaRGB) )

     {
         // Gray has no color
         hue = 0.0;
     {
         // Gray has no color
         hue = 0.0;


@@ -1781,21 +1800,31 @@ wxImage::HSVValue wxImage::RGBtoHSV(const RGBValue& rgb)
     }
     else
     {
     }
     else
     {

-        double deltaRGB = maximumRGB - minimumRGB;
+        switch ( chMax )
+        {
+            case RED:
+                hue = (green - blue) / deltaRGB;
+                break;

 
 

-        saturation = deltaRGB / maximumRGB;
+            case GREEN:
+                hue = 2.0 + (blue - red) / deltaRGB;
+                break;

 
 

-        if ( red == maximumRGB )
-            hue = (green - blue) / deltaRGB;
-        else if (green == maximumRGB)
-            hue = 2.0 + (blue - red) / deltaRGB;
-        else
-            hue = 4.0 + (red - green) / deltaRGB;
+            case BLUE:
+                hue = 4.0 + (red - green) / deltaRGB;
+                break;
+
+            default:
+                wxFAIL_MSG(wxT("hue not specified"));
+                break;
+        }

 
 

-        hue = hue / 6.0;
+        hue /= 6.0;

 
 

-        if (hue < 0.0)
-            hue = hue + 1.0;
+        if ( hue < 0.0 )
+            hue += 1.0;
+
+        saturation = deltaRGB / maximumRGB;

     }
 
     return HSVValue(hue, saturation, value);
     }
 
     return HSVValue(hue, saturation, value);


@@ -1805,13 +1834,14 @@ wxImage::RGBValue wxImage::HSVtoRGB(const HSVValue& hsv)
 {
     double red, green, blue;
 
 {
     double red, green, blue;
 

-    if ( hsv.saturation == 0.0 )
+    if ( wxIsNullDouble(hsv.saturation) )

     {
     {

-        red = hsv.value; //Grey
+        // Grey
+        red = hsv.value;

         green = hsv.value;
         green = hsv.value;

-        blue = hsv.value; 
+        blue = hsv.value;

     }
     }

-    else
+    else // not grey

     {
         double hue = hsv.hue * 6.0;      // sector 0 to 5
         int i = (int)floor(hue);
     {
         double hue = hsv.hue * 6.0;      // sector 0 to 5
         int i = (int)floor(hue);


@@ -1877,7 +1907,7 @@ void wxImage::RotateHue(double angle)
 
     wxASSERT (angle >= -1.0 && angle <= 1.0);
     count = M_IMGDATA->m_width * M_IMGDATA->m_height;
 
     wxASSERT (angle >= -1.0 && angle <= 1.0);
     count = M_IMGDATA->m_width * M_IMGDATA->m_height;

-    if (count > 0 && angle != 0.0)
+    if ( count > 0 && !wxIsNullDouble(angle) )

     {
         srcBytePtr = M_IMGDATA->m_data;
         dstBytePtr = srcBytePtr;
     {
         srcBytePtr = M_IMGDATA->m_data;
         dstBytePtr = srcBytePtr;


@@ -2161,20 +2191,20 @@ wxImage wxImage::Rotate(double angle, const wxPoint & centre_of_rotation, bool i
     wxRealPoint p3 = rotated_point (GetWidth(), 0, cos_angle, sin_angle, p0);
     wxRealPoint p4 = rotated_point (GetWidth(), GetHeight(), cos_angle, sin_angle, p0);
 
     wxRealPoint p3 = rotated_point (GetWidth(), 0, cos_angle, sin_angle, p0);
     wxRealPoint p4 = rotated_point (GetWidth(), GetHeight(), cos_angle, sin_angle, p0);
 

-    int x1 = (int) floor (wxMin (wxMin(p1.x, p2.x), wxMin(p3.x, p4.x)));
-    int y1 = (int) floor (wxMin (wxMin(p1.y, p2.y), wxMin(p3.y, p4.y)));
-    int x2 = (int) ceil (wxMax (wxMax(p1.x, p2.x), wxMax(p3.x, p4.x)));
-    int y2 = (int) ceil (wxMax (wxMax(p1.y, p2.y), wxMax(p3.y, p4.y)));
+    int x1a = (int) floor (wxMin (wxMin(p1.x, p2.x), wxMin(p3.x, p4.x)));
+    int y1a = (int) floor (wxMin (wxMin(p1.y, p2.y), wxMin(p3.y, p4.y)));
+    int x2a = (int) ceil (wxMax (wxMax(p1.x, p2.x), wxMax(p3.x, p4.x)));
+    int y2a = (int) ceil (wxMax (wxMax(p1.y, p2.y), wxMax(p3.y, p4.y)));

 
     // Create rotated image
 
     // Create rotated image

-    wxImage rotated (x2 - x1 + 1, y2 - y1 + 1, false);
+    wxImage rotated (x2a - x1a + 1, y2a - y1a + 1, false);

     // With alpha channel
     if (has_alpha)
         rotated.SetAlpha();
 
     if (offset_after_rotation != NULL)
     {
     // With alpha channel
     if (has_alpha)
         rotated.SetAlpha();
 
     if (offset_after_rotation != NULL)
     {

-        *offset_after_rotation = wxPoint (x1, y1);
+        *offset_after_rotation = wxPoint (x1a, y1a);

     }
 
     // GRG: The rotated (destination) image is always accessed
     }
 
     // GRG: The rotated (destination) image is always accessed


@@ -2216,7 +2246,7 @@ wxImage wxImage::Rotate(double angle, const wxPoint & centre_of_rotation, bool i
         {
             for (x = 0; x < rotated.GetWidth(); x++)
             {
         {
             for (x = 0; x < rotated.GetWidth(); x++)
             {

-                wxRealPoint src = rotated_point (x + x1, y + y1, cos_angle, -sin_angle, p0);
+                wxRealPoint src = rotated_point (x + x1a, y + y1a, cos_angle, -sin_angle, p0);

 
                 if (-0.25 < src.x && src.x < GetWidth() - 0.75 &&
                     -0.25 < src.y && src.y < GetHeight() - 0.75)
 
                 if (-0.25 < src.x && src.x < GetWidth() - 0.75 &&
                     -0.25 < src.y && src.y < GetHeight() - 0.75)


@@ -2224,8 +2254,6 @@ wxImage wxImage::Rotate(double angle, const wxPoint & centre_of_rotation, bool i
                     // interpolate using the 4 enclosing grid-points.  Those
                     // points can be obtained using floor and ceiling of the
                     // exact coordinates of the point
                     // interpolate using the 4 enclosing grid-points.  Those
                     // points can be obtained using floor and ceiling of the
                     // exact coordinates of the point

-                        // C.M. 2000-02-17:  when the point is near the border, special care is required.
-

                     int x1, y1, x2, y2;
 
                     if (0 < src.x && src.x < GetWidth() - 1)
                     int x1, y1, x2, y2;
 
                     if (0 < src.x && src.x < GetWidth() - 1)


@@ -2275,10 +2303,7 @@ wxImage wxImage::Rotate(double angle, const wxPoint & centre_of_rotation, bool i
                         *(dst++) = *p;
 
                         if (has_alpha)
                         *(dst++) = *p;
 
                         if (has_alpha)

-                        {
-                            unsigned char *p = alpha[y1] + x1;
-                            *(alpha_dst++) = *p;
-                        }
+                            *(alpha_dst++) = *(alpha[y1] + x1);

                     }
                     else if (d2 < gs_Epsilon)
                     {
                     }
                     else if (d2 < gs_Epsilon)
                     {


@@ -2288,10 +2313,7 @@ wxImage wxImage::Rotate(double angle, const wxPoint & centre_of_rotation, bool i
                         *(dst++) = *p;
 
                         if (has_alpha)
                         *(dst++) = *p;
 
                         if (has_alpha)

-                        {
-                            unsigned char *p = alpha[y1] + x2;
-                            *(alpha_dst++) = *p;
-                        }
+                            *(alpha_dst++) = *(alpha[y1] + x2);

                     }
                     else if (d3 < gs_Epsilon)
                     {
                     }
                     else if (d3 < gs_Epsilon)
                     {


@@ -2301,10 +2323,7 @@ wxImage wxImage::Rotate(double angle, const wxPoint & centre_of_rotation, bool i
                         *(dst++) = *p;
 
                         if (has_alpha)
                         *(dst++) = *p;
 
                         if (has_alpha)

-                        {
-                            unsigned char *p = alpha[y2] + x2;
-                            *(alpha_dst++) = *p;
-                        }
+                            *(alpha_dst++) = *(alpha[y2] + x2);

                     }
                     else if (d4 < gs_Epsilon)
                     {
                     }
                     else if (d4 < gs_Epsilon)
                     {


@@ -2314,10 +2333,7 @@ wxImage wxImage::Rotate(double angle, const wxPoint & centre_of_rotation, bool i
                         *(dst++) = *p;
 
                         if (has_alpha)
                         *(dst++) = *p;
 
                         if (has_alpha)

-                        {
-                            unsigned char *p = alpha[y2] + x1;
-                            *(alpha_dst++) = *p;
-                        }
+                            *(alpha_dst++) = *(alpha[y2] + x1);

                     }
                     else
                     {
                     }
                     else
                     {


@@ -2346,10 +2362,10 @@ wxImage wxImage::Rotate(double angle, const wxPoint & centre_of_rotation, bool i
 
                         if (has_alpha)
                         {
 
                         if (has_alpha)
                         {

-                            unsigned char *v1 = alpha[y1] + (x1);
-                            unsigned char *v2 = alpha[y1] + (x2);
-                            unsigned char *v3 = alpha[y2] + (x2);
-                            unsigned char *v4 = alpha[y2] + (x1);
+                            v1 = alpha[y1] + (x1);
+                            v2 = alpha[y1] + (x2);
+                            v3 = alpha[y2] + (x2);
+                            v4 = alpha[y2] + (x1);

 
                             *(alpha_dst++) = (unsigned char)
                                 ( (w1 * *v1 + w2 * *v2 +
 
                             *(alpha_dst++) = (unsigned char)
                                 ( (w1 * *v1 + w2 * *v2 +


@@ -2376,7 +2392,7 @@ wxImage wxImage::Rotate(double angle, const wxPoint & centre_of_rotation, bool i
         {
             for (x = 0; x < rotated.GetWidth(); x++)
             {
         {
             for (x = 0; x < rotated.GetWidth(); x++)
             {

-                wxRealPoint src = rotated_point (x + x1, y + y1, cos_angle, -sin_angle, p0);
+                wxRealPoint src = rotated_point (x + x1a, y + y1a, cos_angle, -sin_angle, p0);

 
                 const int xs = wxCint (src.x);      // wxCint rounds to the
                 const int ys = wxCint (src.y);      // closest integer
 
                 const int xs = wxCint (src.x);      // wxCint rounds to the
                 const int ys = wxCint (src.y);      // closest integer


@@ -2390,10 +2406,7 @@ wxImage wxImage::Rotate(double angle, const wxPoint & centre_of_rotation, bool i
                     *(dst++) = *p;
 
                     if (has_alpha)
                     *(dst++) = *p;
 
                     if (has_alpha)

-                    {
-                        unsigned char *p = alpha[ys] + (xs);
-                        *(alpha_dst++) = *p;
-                    }
+                        *(alpha_dst++) = *(alpha[ys] + (xs));

                 }
                 else
                 {
                 }
                 else
                 {