option for no close button for wxAuiNotebook in aui demo

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

diff --git a/src/common/image.cpp b/src/common/image.cpp
index 6f1a729952a4248961479cfd917279e74ea224b5..3aae548ccc729768825078f9518c43d9189f3639 100644 (file)
--- a/src/common/image.cpp
+++ b/src/common/image.cpp
@@ -30,10 +30,7 @@
 
 #include "wx/filefn.h"
 #include "wx/wfstream.h"
 
 #include "wx/filefn.h"
 #include "wx/wfstream.h"

-
-#if wxUSE_XPM
-    #include "wx/xpmdecod.h"
-#endif
+#include "wx/xpmdecod.h"

 
 // For memcpy
 #include <string.h>
 
 // For memcpy
 #include <string.h>


@@ -51,6 +48,10 @@
     #endif // wxUSE_FILE/wxUSE_FFILE
 #endif // HAS_FILE_STREAMS
 
     #endif // wxUSE_FILE/wxUSE_FFILE
 #endif // HAS_FILE_STREAMS
 

+#if wxUSE_VARIANT
+IMPLEMENT_VARIANT_OBJECT_EXPORTED_SHALLOWCMP(wxImage,WXDLLEXPORT)
+#endif
+

 //-----------------------------------------------------------------------------
 // wxImage
 //-----------------------------------------------------------------------------
 //-----------------------------------------------------------------------------
 // wxImage
 //-----------------------------------------------------------------------------


@@ -161,17 +162,12 @@ wxImage::wxImage( wxInputStream& stream, const wxString& mimetype, int index )
 }
 #endif // wxUSE_STREAMS
 
 }
 #endif // wxUSE_STREAMS
 

-wxImage::wxImage( const char** xpmData )
+wxImage::wxImage(const char* const* xpmData)

 {
     Create(xpmData);
 }
 
 {
     Create(xpmData);
 }
 

-wxImage::wxImage( char** xpmData )
-{
-    Create((const char**) xpmData);
-}
-
-bool wxImage::Create( const char** xpmData )
+bool wxImage::Create(const char* const* xpmData)

 {
 #if wxUSE_XPM
     UnRef();
 {
 #if wxUSE_XPM
     UnRef();


@@ -469,13 +465,7 @@ wxImage wxImage::Scale( int width, int height, int quality ) const
         unsigned char *source_alpha = 0 ;
         unsigned char *target_alpha = 0 ;
 
         unsigned char *source_alpha = 0 ;
         unsigned char *target_alpha = 0 ;
 

-        if (M_IMGDATA->m_hasMask)
-        {
-            image.SetMaskColour( M_IMGDATA->m_maskRed,
-                                M_IMGDATA->m_maskGreen,
-                                M_IMGDATA->m_maskBlue );
-        }
-        else
+        if ( !M_IMGDATA->m_hasMask )

         {
             source_alpha = M_IMGDATA->m_alpha ;
             if ( source_alpha )
         {
             source_alpha = M_IMGDATA->m_alpha ;
             if ( source_alpha )


@@ -514,6 +504,14 @@ wxImage wxImage::Scale( int width, int height, int quality ) const
         }
     }
 
         }
     }
 

+    // If the original image has a mask, apply the mask to the new image
+    if (M_IMGDATA->m_hasMask)
+    {
+        image.SetMaskColour( M_IMGDATA->m_maskRed,
+                            M_IMGDATA->m_maskGreen,
+                            M_IMGDATA->m_maskBlue );
+    }
+

     // 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,
     // 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,


@@ -573,7 +571,7 @@ wxImage wxImage::ResampleBox(int width, int height) const
             averaged_pixels = 0;
             sum_r = sum_g = sum_b = sum_a = 0.0;
 
             averaged_pixels = 0;
             sum_r = sum_g = sum_b = sum_a = 0.0;
 

-            for ( int j = src_y - scale_factor_y_2 + 1;
+            for ( int j = int(src_y - scale_factor_y/2.0 + 1);

                   j <= int(src_y + scale_factor_y_2);
                   j++ )
             {
                   j <= int(src_y + scale_factor_y_2);
                   j++ )
             {


@@ -581,7 +579,7 @@ wxImage wxImage::ResampleBox(int width, int height) const
                 if ( j < 0 || j > M_IMGDATA->m_height )
                     continue;
 
                 if ( j < 0 || j > M_IMGDATA->m_height )
                     continue;
 

-                for ( int i = src_x - scale_factor_x_2 + 1;
+                for ( int i = int(src_x - scale_factor_x/2.0 + 1);

                       i <= src_x + scale_factor_x_2;
                       i++ )
                 {
                       i <= src_x + scale_factor_x_2;
                       i++ )
                 {


@@ -809,11 +807,11 @@ wxImage wxImage::BlurHorizontal(int blurRadius)
         }
 
         dst = dst_data + y * M_IMGDATA->m_width*3;
         }
 
         dst = dst_data + y * M_IMGDATA->m_width*3;

-        dst[0] = sum_r / blurArea;
-        dst[1] = sum_g / blurArea;
-        dst[2] = sum_b / blurArea;
+        dst[0] = (unsigned char)(sum_r / blurArea);
+        dst[1] = (unsigned char)(sum_g / blurArea);
+        dst[2] = (unsigned char)(sum_b / blurArea);

         if ( src_alpha )
         if ( src_alpha )

-            dst_alpha[y * M_IMGDATA->m_width] = sum_a / blurArea;
+            dst_alpha[y * M_IMGDATA->m_width] = (unsigned char)(sum_a / blurArea);

 
         // Now average the values of the rest of the pixels by just moving the
         // blur radius box along the row
 
         // Now average the values of the rest of the pixels by just moving the
         // blur radius box along the row


@@ -850,12 +848,12 @@ wxImage wxImage::BlurHorizontal(int blurRadius)
                 sum_a += src_alpha[pixel_idx];
 
             // Save off the averaged data
                 sum_a += src_alpha[pixel_idx];
 
             // Save off the averaged data

-            dst = dst_data + x*3 + y*M_IMGDATA->m_width;
-            dst[0] = sum_r / blurArea;
-            dst[1] = sum_g / blurArea;
-            dst[2] = sum_b / blurArea;
+            dst = dst_data + x*3 + y*M_IMGDATA->m_width*3;
+            dst[0] = (unsigned char)(sum_r / blurArea);
+            dst[1] = (unsigned char)(sum_g / blurArea);
+            dst[2] = (unsigned char)(sum_b / blurArea);

             if ( src_alpha )
             if ( src_alpha )

-                dst_alpha[x + y * M_IMGDATA->m_width] = sum_a / blurArea;
+                dst_alpha[x + y * M_IMGDATA->m_width] = (unsigned char)(sum_a / blurArea);

         }
     }
 
         }
     }
 


@@ -927,11 +925,11 @@ wxImage wxImage::BlurVertical(int blurRadius)
         }
 
         dst = dst_data + x*3;
         }
 
         dst = dst_data + x*3;

-        dst[0] = sum_r / blurArea;
-        dst[1] = sum_g / blurArea;
-        dst[2] = sum_b / blurArea;
+        dst[0] = (unsigned char)(sum_r / blurArea);
+        dst[1] = (unsigned char)(sum_g / blurArea);
+        dst[2] = (unsigned char)(sum_b / blurArea);

         if ( src_alpha )
         if ( src_alpha )

-            dst_alpha[x] = sum_a / blurArea;
+            dst_alpha[x] = (unsigned char)(sum_a / blurArea);

 
         // Now average the values of the rest of the pixels by just moving the
         // box along the column from top to bottom
 
         // Now average the values of the rest of the pixels by just moving the
         // box along the column from top to bottom


@@ -969,11 +967,11 @@ wxImage wxImage::BlurVertical(int blurRadius)
 
             // Save off the averaged data
             dst = dst_data + (x + y * M_IMGDATA->m_width) * 3;
 
             // Save off the averaged data
             dst = dst_data + (x + y * M_IMGDATA->m_width) * 3;

-            dst[0] = sum_r / blurArea;
-            dst[1] = sum_g / blurArea;
-            dst[2] = sum_b / blurArea;
+            dst[0] = (unsigned char)(sum_r / blurArea);
+            dst[1] = (unsigned char)(sum_g / blurArea);
+            dst[2] = (unsigned char)(sum_b / blurArea);

             if ( src_alpha )
             if ( src_alpha )

-                dst_alpha[x + y * M_IMGDATA->m_width] = sum_a / blurArea;
+                dst_alpha[x + y * M_IMGDATA->m_width] = (unsigned char)(sum_a / blurArea);

         }
     }
 
         }
     }
 


@@ -1313,8 +1311,8 @@ void wxImage::Paste( const wxImage &image, int x, int y )
         {
             for (int i = 0; i < width; i+=3)
             {
         {
             for (int i = 0; i < width; i+=3)
             {

-                if ((source_data[i]   != r) &&
-                    (source_data[i+1] != g) &&
+                if ((source_data[i]   != r) ||
+                    (source_data[i+1] != g) ||

                     (source_data[i+2] != b))
                 {
                     memcpy( target_data+i, source_data+i, 3 );
                     (source_data[i+2] != b))
                 {
                     memcpy( target_data+i, source_data+i, 3 );


@@ -1546,7 +1544,7 @@ unsigned char wxImage::GetBlue( int x, int y ) const
     return M_IMGDATA->m_data[pos+2];
 }
 
     return M_IMGDATA->m_data[pos+2];
 }
 

-bool wxImage::Ok() const
+bool wxImage::IsOk() const

 {
     // image of 0 width or height can't be considered ok - at least because it
     // causes crashes in ConvertToBitmap() if we don't catch it in time
 {
     // image of 0 width or height can't be considered ok - at least because it
     // causes crashes in ConvertToBitmap() if we don't catch it in time


@@ -2783,18 +2781,7 @@ unsigned long wxImage::ComputeHistogram( wxImageHistogram &h ) const
  * Rotation code by Carlos Moreno
  */
 
  * Rotation code by Carlos Moreno
  */
 

-// GRG: I've removed wxRotationPoint - we already have wxRealPoint which
-//      does exactly the same thing. And I also got rid of wxRotationPixel
-//      bacause of potential problems in architectures where alignment
-//      is an issue, so I had to rewrite parts of the code.
-
-static const double gs_Epsilon = 1e-10;
-
-static inline int wxCint (double x)
-{
-    return (x > 0) ? (int) (x + 0.5) : (int) (x - 0.5);
-}
-
+static const double wxROTATE_EPSILON = 1e-10;

 
 // Auxiliary function to rotate a point (x,y) with respect to point p0
 // make it inline and use a straight return to facilitate optimization
 
 // Auxiliary function to rotate a point (x,y) with respect to point p0
 // make it inline and use a straight return to facilitate optimization


@@ -2802,15 +2789,19 @@ static inline int wxCint (double x)
 // repeating the time-consuming calls to these functions -- sin/cos can
 // be computed and stored in the calling function.
 
 // repeating the time-consuming calls to these functions -- sin/cos can
 // be computed and stored in the calling function.
 

-inline wxRealPoint rotated_point (const wxRealPoint & p, double cos_angle, double sin_angle, const wxRealPoint & p0)
+static inline wxRealPoint
+wxRotatePoint(const wxRealPoint& p, double cos_angle, double sin_angle,
+              const wxRealPoint& p0)

 {
 {

-    return wxRealPoint (p0.x + (p.x - p0.x) * cos_angle - (p.y - p0.y) * sin_angle,
-                        p0.y + (p.y - p0.y) * cos_angle + (p.x - p0.x) * sin_angle);
+    return wxRealPoint(p0.x + (p.x - p0.x) * cos_angle - (p.y - p0.y) * sin_angle,
+                       p0.y + (p.y - p0.y) * cos_angle + (p.x - p0.x) * sin_angle);

 }
 
 }
 

-inline wxRealPoint rotated_point (double x, double y, double cos_angle, double sin_angle, const wxRealPoint & p0)
+static inline wxRealPoint
+wxRotatePoint(double x, double y, double cos_angle, double sin_angle,
+              const wxRealPoint & p0)

 {
 {

-    return rotated_point (wxRealPoint(x,y), cos_angle, sin_angle, p0);
+    return wxRotatePoint (wxRealPoint(x,y), cos_angle, sin_angle, p0);

 }
 
 wxImage wxImage::Rotate(double angle, const wxPoint & centre_of_rotation, bool interpolating, wxPoint * offset_after_rotation) const
 }
 
 wxImage wxImage::Rotate(double angle, const wxPoint & centre_of_rotation, bool interpolating, wxPoint * offset_after_rotation) const


@@ -2847,10 +2838,10 @@ wxImage wxImage::Rotate(double angle, const wxPoint & centre_of_rotation, bool i
 
     const wxRealPoint p0(centre_of_rotation.x, centre_of_rotation.y);
 
 
     const wxRealPoint p0(centre_of_rotation.x, centre_of_rotation.y);
 

-    wxRealPoint p1 = rotated_point (0, 0, cos_angle, sin_angle, p0);
-    wxRealPoint p2 = rotated_point (0, 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);
+    wxRealPoint p1 = wxRotatePoint (0, 0, cos_angle, sin_angle, p0);
+    wxRealPoint p2 = wxRotatePoint (0, GetHeight(), cos_angle, sin_angle, p0);
+    wxRealPoint p3 = wxRotatePoint (GetWidth(), 0, cos_angle, sin_angle, p0);
+    wxRealPoint p4 = wxRotatePoint (GetWidth(), GetHeight(), cos_angle, sin_angle, p0);

 
     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 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)));


@@ -2907,7 +2898,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 + x1a, y + y1a, cos_angle, -sin_angle, p0);
+                wxRealPoint src = wxRotatePoint (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)


@@ -2919,22 +2910,22 @@ wxImage wxImage::Rotate(double angle, const wxPoint & centre_of_rotation, bool i
 
                     if (0 < src.x && src.x < GetWidth() - 1)
                     {
 
                     if (0 < src.x && src.x < GetWidth() - 1)
                     {

-                        x1 = wxCint(floor(src.x));
-                        x2 = wxCint(ceil(src.x));
+                        x1 = wxRound(floor(src.x));
+                        x2 = wxRound(ceil(src.x));

                     }
                     else    // else means that x is near one of the borders (0 or width-1)
                     {
                     }
                     else    // else means that x is near one of the borders (0 or width-1)
                     {

-                        x1 = x2 = wxCint (src.x);
+                        x1 = x2 = wxRound (src.x);

                     }
 
                     if (0 < src.y && src.y < GetHeight() - 1)
                     {
                     }
 
                     if (0 < src.y && src.y < GetHeight() - 1)
                     {

-                        y1 = wxCint(floor(src.y));
-                        y2 = wxCint(ceil(src.y));
+                        y1 = wxRound(floor(src.y));
+                        y2 = wxRound(ceil(src.y));

                     }
                     else
                     {
                     }
                     else
                     {

-                        y1 = y2 = wxCint (src.y);
+                        y1 = y2 = wxRound (src.y);

                     }
 
                     // get four points and the distances (square of the distance,
                     }
 
                     // get four points and the distances (square of the distance,


@@ -2943,7 +2934,7 @@ wxImage wxImage::Rotate(double angle, const wxPoint & centre_of_rotation, bool i
                     // GRG: Do not calculate the points until they are
                     //      really needed -- this way we can calculate
                     //      just one, instead of four, if d1, d2, d3
                     // GRG: Do not calculate the points until they are
                     //      really needed -- this way we can calculate
                     //      just one, instead of four, if d1, d2, d3

-                    //      or d4 are < gs_Epsilon
+                    //      or d4 are < wxROTATE_EPSILON

 
                     const double d1 = (src.x - x1) * (src.x - x1) + (src.y - y1) * (src.y - y1);
                     const double d2 = (src.x - x2) * (src.x - x2) + (src.y - y1) * (src.y - y1);
 
                     const double d1 = (src.x - x1) * (src.x - x1) + (src.y - y1) * (src.y - y1);
                     const double d2 = (src.x - x2) * (src.x - x2) + (src.y - y1) * (src.y - y1);


@@ -2956,7 +2947,8 @@ wxImage wxImage::Rotate(double angle, const wxPoint & centre_of_rotation, bool i
                     // If the point is exactly at one point of the grid of the source
                     // image, then don't interpolate -- just assign the pixel
 
                     // If the point is exactly at one point of the grid of the source
                     // image, then don't interpolate -- just assign the pixel
 

-                    if (d1 < gs_Epsilon)        // d1,d2,d3,d4 are positive -- no need for abs()
+                    // d1,d2,d3,d4 are positive -- no need for abs()
+                    if (d1 < wxROTATE_EPSILON)

                     {
                         unsigned char *p = data[y1] + (3 * x1);
                         *(dst++) = *(p++);
                     {
                         unsigned char *p = data[y1] + (3 * x1);
                         *(dst++) = *(p++);


@@ -2966,7 +2958,7 @@ wxImage wxImage::Rotate(double angle, const wxPoint & centre_of_rotation, bool i
                         if (has_alpha)
                             *(alpha_dst++) = *(alpha[y1] + x1);
                     }
                         if (has_alpha)
                             *(alpha_dst++) = *(alpha[y1] + x1);
                     }

-                    else if (d2 < gs_Epsilon)
+                    else if (d2 < wxROTATE_EPSILON)

                     {
                         unsigned char *p = data[y1] + (3 * x2);
                         *(dst++) = *(p++);
                     {
                         unsigned char *p = data[y1] + (3 * x2);
                         *(dst++) = *(p++);


@@ -2976,7 +2968,7 @@ wxImage wxImage::Rotate(double angle, const wxPoint & centre_of_rotation, bool i
                         if (has_alpha)
                             *(alpha_dst++) = *(alpha[y1] + x2);
                     }
                         if (has_alpha)
                             *(alpha_dst++) = *(alpha[y1] + x2);
                     }

-                    else if (d3 < gs_Epsilon)
+                    else if (d3 < wxROTATE_EPSILON)

                     {
                         unsigned char *p = data[y2] + (3 * x2);
                         *(dst++) = *(p++);
                     {
                         unsigned char *p = data[y2] + (3 * x2);
                         *(dst++) = *(p++);


@@ -2986,7 +2978,7 @@ wxImage wxImage::Rotate(double angle, const wxPoint & centre_of_rotation, bool i
                         if (has_alpha)
                             *(alpha_dst++) = *(alpha[y2] + x2);
                     }
                         if (has_alpha)
                             *(alpha_dst++) = *(alpha[y2] + x2);
                     }

-                    else if (d4 < gs_Epsilon)
+                    else if (d4 < wxROTATE_EPSILON)

                     {
                         unsigned char *p = data[y2] + (3 * x1);
                         *(dst++) = *(p++);
                     {
                         unsigned char *p = data[y2] + (3 * x1);
                         *(dst++) = *(p++);


@@ -3053,10 +3045,10 @@ 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 + x1a, y + y1a, cos_angle, -sin_angle, p0);
+                wxRealPoint src = wxRotatePoint (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 = wxRound (src.x);      // wxRound rounds to the
+                const int ys = wxRound (src.y);      // closest integer

 
                 if (0 <= xs && xs < GetWidth() &&
                     0 <= ys && ys < GetHeight())
 
                 if (0 <= xs && xs < GetWidth() &&
                     0 <= ys && ys < GetHeight())