+
+bool wxImage::Ok() 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
+ wxImageRefData *data = M_IMGDATA;
+ return data && data->m_ok && data->m_width && data->m_height;
+}
+
+unsigned char *wxImage::GetData() const
+{
+ wxCHECK_MSG( Ok(), (unsigned char *)NULL, wxT("invalid image") );
+
+ return M_IMGDATA->m_data;
+}
+
+void wxImage::SetData( unsigned char *data )
+{
+ wxCHECK_RET( Ok(), wxT("invalid image") );
+
+ wxImageRefData *newRefData = new wxImageRefData();
+
+ newRefData->m_width = M_IMGDATA->m_width;
+ newRefData->m_height = M_IMGDATA->m_height;
+ newRefData->m_data = data;
+ newRefData->m_ok = true;
+ newRefData->m_maskRed = M_IMGDATA->m_maskRed;
+ newRefData->m_maskGreen = M_IMGDATA->m_maskGreen;
+ newRefData->m_maskBlue = M_IMGDATA->m_maskBlue;
+ newRefData->m_hasMask = M_IMGDATA->m_hasMask;
+
+ UnRef();
+
+ m_refData = newRefData;
+}
+
+void wxImage::SetData( unsigned char *data, int new_width, int new_height )
+{
+ wxImageRefData *newRefData = new wxImageRefData();
+
+ if (m_refData)
+ {
+ newRefData->m_width = new_width;
+ newRefData->m_height = new_height;
+ newRefData->m_data = data;
+ newRefData->m_ok = true;
+ newRefData->m_maskRed = M_IMGDATA->m_maskRed;
+ newRefData->m_maskGreen = M_IMGDATA->m_maskGreen;
+ newRefData->m_maskBlue = M_IMGDATA->m_maskBlue;
+ newRefData->m_hasMask = M_IMGDATA->m_hasMask;
+ }
+ else
+ {
+ newRefData->m_width = new_width;
+ newRefData->m_height = new_height;
+ newRefData->m_data = data;
+ newRefData->m_ok = true;
+ }
+
+ UnRef();
+
+ m_refData = newRefData;
+}
+
+// ----------------------------------------------------------------------------
+// alpha channel support
+// ----------------------------------------------------------------------------
+
+void wxImage::SetAlpha(int x, int y, unsigned char alpha)
+{
+ wxCHECK_RET( Ok() && HasAlpha(), wxT("invalid image or no alpha channel") );
+
+ int w = M_IMGDATA->m_width,
+ h = M_IMGDATA->m_height;
+
+ wxCHECK_RET( x >=0 && y >= 0 && x < w && y < h, wxT("invalid image index") );
+
+ M_IMGDATA->m_alpha[y*w + x] = alpha;
+}
+
+unsigned char wxImage::GetAlpha(int x, int y) const
+{
+ wxCHECK_MSG( Ok() && HasAlpha(), 0, wxT("invalid image or no alpha channel") );
+
+ int w = M_IMGDATA->m_width,
+ h = M_IMGDATA->m_height;
+
+ wxCHECK_MSG( x >=0 && y >= 0 && x < w && y < h, 0, wxT("invalid image index") );
+
+ return M_IMGDATA->m_alpha[y*w + x];
+}
+
+void wxImage::SetAlpha( unsigned char *alpha )
+{
+ wxCHECK_RET( Ok(), wxT("invalid image") );
+
+ if ( !alpha )
+ {
+ alpha = (unsigned char *)malloc(M_IMGDATA->m_width*M_IMGDATA->m_height);
+ }
+
+ free(M_IMGDATA->m_alpha);
+ M_IMGDATA->m_alpha = alpha;
+}
+
+unsigned char *wxImage::GetAlpha() const
+{
+ wxCHECK_MSG( Ok(), (unsigned char *)NULL, wxT("invalid image") );
+
+ return M_IMGDATA->m_alpha;
+}
+
+// ----------------------------------------------------------------------------
+// mask support
+// ----------------------------------------------------------------------------
+
+void wxImage::SetMaskColour( unsigned char r, unsigned char g, unsigned char b )
+{
+ wxCHECK_RET( Ok(), wxT("invalid image") );
+
+ M_IMGDATA->m_maskRed = r;
+ M_IMGDATA->m_maskGreen = g;
+ M_IMGDATA->m_maskBlue = b;
+ M_IMGDATA->m_hasMask = true;
+}
+
+unsigned char wxImage::GetMaskRed() const
+{
+ wxCHECK_MSG( Ok(), 0, wxT("invalid image") );
+
+ return M_IMGDATA->m_maskRed;
+}
+
+unsigned char wxImage::GetMaskGreen() const
+{
+ wxCHECK_MSG( Ok(), 0, wxT("invalid image") );
+
+ return M_IMGDATA->m_maskGreen;
+}
+
+unsigned char wxImage::GetMaskBlue() const
+{
+ wxCHECK_MSG( Ok(), 0, wxT("invalid image") );
+
+ return M_IMGDATA->m_maskBlue;
+}
+
+void wxImage::SetMask( bool mask )
+{
+ wxCHECK_RET( Ok(), wxT("invalid image") );
+
+ M_IMGDATA->m_hasMask = mask;
+}
+
+bool wxImage::HasMask() const
+{
+ wxCHECK_MSG( Ok(), false, wxT("invalid image") );
+
+ return M_IMGDATA->m_hasMask;
+}
+
+int wxImage::GetWidth() const
+{
+ wxCHECK_MSG( Ok(), 0, wxT("invalid image") );
+
+ return M_IMGDATA->m_width;
+}
+
+int wxImage::GetHeight() const
+{
+ wxCHECK_MSG( Ok(), 0, wxT("invalid image") );
+
+ return M_IMGDATA->m_height;
+}
+
+bool wxImage::SetMaskFromImage(const wxImage& mask,
+ unsigned char mr, unsigned char mg, unsigned char mb)
+{
+ // check that the images are the same size
+ if ( (M_IMGDATA->m_height != mask.GetHeight() ) || (M_IMGDATA->m_width != mask.GetWidth () ) )
+ {
+ wxLogError( _("Image and mask have different sizes.") );
+ return false;
+ }
+
+ // find unused colour
+ unsigned char r,g,b ;
+ if (!FindFirstUnusedColour(&r, &g, &b))
+ {
+ wxLogError( _("No unused colour in image being masked.") );
+ return false ;
+ }
+
+ unsigned char *imgdata = GetData();
+ unsigned char *maskdata = mask.GetData();
+
+ const int w = GetWidth();
+ const int h = GetHeight();
+
+ for (int j = 0; j < h; j++)
+ {
+ for (int i = 0; i < w; i++)
+ {
+ if ((maskdata[0] == mr) && (maskdata[1] == mg) && (maskdata[2] == mb))
+ {
+ imgdata[0] = r;
+ imgdata[1] = g;
+ imgdata[2] = b;
+ }
+ imgdata += 3;
+ maskdata += 3;
+ }
+ }
+
+ SetMaskColour(r, g, b);
+ SetMask(true);
+
+ return true;
+}
+
+bool wxImage::ConvertAlphaToMask(unsigned char threshold)
+{
+ if (!HasAlpha())
+ return true;
+
+ unsigned char mr, mg, mb;
+ if (!FindFirstUnusedColour(&mr, &mg, &mb))
+ {
+ wxLogError( _("No unused colour in image being masked.") );
+ return false;
+ }
+
+ SetMask(true);
+ SetMaskColour(mr, mg, mb);
+
+ unsigned char *imgdata = GetData();
+ unsigned char *alphadata = GetAlpha();
+
+ int w = GetWidth();
+ int h = GetHeight();
+
+ for (int y = 0; y < h; y++)
+ {
+ for (int x = 0; x < w; x++, imgdata += 3, alphadata++)
+ {
+ if (*alphadata < threshold)
+ {
+ imgdata[0] = mr;
+ imgdata[1] = mg;
+ imgdata[2] = mb;
+ }
+ }
+ }
+
+ free(M_IMGDATA->m_alpha);
+ M_IMGDATA->m_alpha = NULL;
+
+ return true;
+}
+
+#if wxUSE_PALETTE
+
+// Palette functions
+
+bool wxImage::HasPalette() const
+{
+ if (!Ok())
+ return false;
+
+ return M_IMGDATA->m_palette.Ok();
+}
+
+const wxPalette& wxImage::GetPalette() const
+{
+ wxCHECK_MSG( Ok(), wxNullPalette, wxT("invalid image") );
+
+ return M_IMGDATA->m_palette;
+}
+
+void wxImage::SetPalette(const wxPalette& palette)
+{
+ wxCHECK_RET( Ok(), wxT("invalid image") );
+
+ M_IMGDATA->m_palette = palette;
+}
+
+#endif // wxUSE_PALETTE
+
+// Option functions (arbitrary name/value mapping)
+void wxImage::SetOption(const wxString& name, const wxString& value)
+{
+ wxCHECK_RET( Ok(), wxT("invalid image") );
+
+ int idx = M_IMGDATA->m_optionNames.Index(name, false);
+ if (idx == wxNOT_FOUND)
+ {
+ M_IMGDATA->m_optionNames.Add(name);
+ M_IMGDATA->m_optionValues.Add(value);
+ }
+ else
+ {
+ M_IMGDATA->m_optionNames[idx] = name;
+ M_IMGDATA->m_optionValues[idx] = value;
+ }
+}
+
+void wxImage::SetOption(const wxString& name, int value)
+{
+ wxString valStr;
+ valStr.Printf(wxT("%d"), value);
+ SetOption(name, valStr);
+}
+
+wxString wxImage::GetOption(const wxString& name) const
+{
+ wxCHECK_MSG( Ok(), wxEmptyString, wxT("invalid image") );
+
+ int idx = M_IMGDATA->m_optionNames.Index(name, false);
+ if (idx == wxNOT_FOUND)
+ return wxEmptyString;
+ else
+ return M_IMGDATA->m_optionValues[idx];
+}
+
+int wxImage::GetOptionInt(const wxString& name) const
+{
+ wxCHECK_MSG( Ok(), 0, wxT("invalid image") );
+
+ return wxAtoi(GetOption(name));
+}
+
+bool wxImage::HasOption(const wxString& name) const
+{
+ wxCHECK_MSG( Ok(), false, wxT("invalid image") );
+
+ return (M_IMGDATA->m_optionNames.Index(name, false) != wxNOT_FOUND);
+}
+
+bool wxImage::LoadFile( const wxString& filename, long type, int index )
+{
+#if wxUSE_STREAMS
+ if (wxFileExists(filename))
+ {
+ wxFileInputStream stream(filename);
+ wxBufferedInputStream bstream( stream );
+ return LoadFile(bstream, type, index);
+ }
+ else
+ {
+ wxLogError( _("Can't load image from file '%s': file does not exist."), filename.c_str() );
+
+ return false;
+ }
+#else // !wxUSE_STREAMS
+ return false;
+#endif // wxUSE_STREAMS
projects / wxWidgets.git / blobdiff