#############################################################################
## Name: XS/Image.xs
## Purpose: XS for Wx::Image
## Author: Mattia Barbon
## Modified by:
## Created: 02/12/2000
## RCS-ID: $Id: Image.xs 2626 2009-10-18 22:48:17Z mbarbon $
## Copyright: (c) 2000-2003, 2005-2009 Mattia Barbon
## Licence: This program is free software; you can redistribute it and/or
## modify it under the same terms as Perl itself
#############################################################################
#include <wx/image.h>
#include <wx/bitmap.h>
#include "cpp/streams.h"
#include "cpp/overload.h"
MODULE=Wx PACKAGE=Wx::Image
void
wxImage::new( ... )
PPCODE:
BEGIN_OVERLOAD()
MATCH_VOIDM_REDISP( newNull )
MATCH_REDISP( wxPliOvl_wico, newIcon )
MATCH_REDISP( wxPliOvl_wbmp, newBitmap )
MATCH_REDISP( wxPliOvl_wist_n, newStreamType )
MATCH_REDISP( wxPliOvl_wist_s, newStreamMIME )
MATCH_REDISP_COUNT( wxPliOvl_n_n, newWH, 2 )
MATCH_REDISP( wxPliOvl_n_n_s, newData )
MATCH_REDISP( wxPliOvl_n_n_s_s, newDataAlpha )
MATCH_REDISP( wxPliOvl_s_n, newNameType )
MATCH_REDISP( wxPliOvl_s_s, newNameMIME )
END_OVERLOAD( Wx::Image::new )
wxImage*
newNull( CLASS )
SV* CLASS
CODE:
RETVAL = new wxImage();
OUTPUT:
RETVAL
wxImage*
newWH( CLASS, width, height )
SV* CLASS
int width
int height
CODE:
RETVAL = new wxImage( width, height );
OUTPUT:
RETVAL
wxImage*
newData( CLASS, width, height, dt )
SV* CLASS
int width
int height
SV* dt
PREINIT:
STRLEN len;
unsigned char* data = (unsigned char*)SvPV( dt, len );
unsigned char* newdata;
CODE:
if( len != (STRLEN) width * height * 3 )
{
croak( "not enough data in image constructor" );
}
newdata = (unsigned char*)malloc( width * height * 3 );
memcpy( newdata, data, width * height * 3 );
RETVAL = new wxImage( width, height, newdata );
OUTPUT:
RETVAL
#if WXPERL_W_VERSION_GE( 2, 5, 3 )
wxImage*
newDataAlpha( CLASS, width, height, dt, al )
SV* CLASS
int width
int height
SV* dt
SV* al
PREINIT:
STRLEN len_data, len_alpha;
unsigned char* data = (unsigned char*)SvPV( dt, len_data );
unsigned char* alpha = (unsigned char*)SvPV( al, len_alpha );
CODE:
if( len_data != (STRLEN) width * height * 3 ||
len_alpha != (STRLEN) width * height )
{
croak( "not enough data in image constructor" );
}
unsigned char* newdata = (unsigned char*) malloc( len_data );
memcpy( newdata, data, len_data );
unsigned char* newalpha = (unsigned char*) malloc( len_alpha );
memcpy( newalpha, alpha, len_alpha );
RETVAL = new wxImage( width, height, newdata, newalpha );
OUTPUT:
RETVAL
#endif
wxImage*
newNameType( CLASS, name, type, index = -1 )
SV* CLASS
wxString name
wxBitmapType type
int index
CODE:
RETVAL = new wxImage( name, type, index );
OUTPUT:
RETVAL
wxImage*
newNameMIME( CLASS, name, mimetype, index = -1 )
SV* CLASS
wxString name
wxString mimetype
int index
CODE:
RETVAL = new wxImage( name, mimetype, index );
OUTPUT:
RETVAL
wxImage*
newStreamType( CLASS, stream, type, index = -1 )
SV* CLASS
wxPliInputStream stream
wxBitmapType type
int index
CODE:
RETVAL = new wxImage( stream, type, index );
OUTPUT:
RETVAL
wxImage*
newStreamMIME( CLASS, stream, mime, index = -1 )
SV* CLASS
wxPliInputStream stream
wxString mime
int index
CODE:
RETVAL = new wxImage( stream, mime, index );
OUTPUT:
RETVAL
wxImage*
newBitmap( CLASS, bitmap )
wxBitmap* bitmap
CODE:
RETVAL = new wxImage( bitmap->ConvertToImage() );
OUTPUT: RETVAL
wxImage*
newIcon( CLASS, icon )
wxIcon* icon
CODE:
wxBitmap tmp; tmp.CopyFromIcon( *icon );
RETVAL = new wxImage( tmp.ConvertToImage() );
OUTPUT: RETVAL
static void
wxImage::CLONE()
CODE:
wxPli_thread_sv_clone( aTHX_ CLASS, (wxPliCloneSV)wxPli_detach_object );
## // thread OK
void
wxImage::DESTROY()
CODE:
wxPli_thread_sv_unregister( aTHX_ "Wx::Image", THIS, ST(0) );
delete THIS;
void
AddHandler( handler )
wxImageHandler* handler
CODE:
wxImage::AddHandler( handler );
wxImage*
wxImage::ConvertToMono( r, g, b )
unsigned char r
unsigned char g
unsigned char b
CODE:
RETVAL = new wxImage( THIS->ConvertToMono( r, g, b ) );
OUTPUT:
RETVAL
#if WXPERL_W_VERSION_GE( 2, 5, 3 )
bool
wxImage::ConvertAlphaToMask( threshold = 128 )
unsigned char threshold
#endif
#if WXPERL_W_VERSION_GE( 2, 5, 4 )
bool
wxImage::ConvertColourToAlpha( r, g, b )
unsigned char r
unsigned char g
unsigned char b
#endif
#if WXPERL_W_VERSION_GE( 2, 7, 0 )
wxImage*
wxImage::ConvertToGreyscale()
CODE:
RETVAL = new wxImage( THIS->ConvertToGreyscale() );
OUTPUT:
RETVAL
#endif
wxImage*
wxImage::Copy()
CODE:
RETVAL = new wxImage( THIS->Copy() );
OUTPUT:
RETVAL
void
wxImage::Create( width, height )
int width
int height
void
wxImage::Destroy()
wxImageHandler*
FindHandlerName( name )
wxString name
CODE:
RETVAL = wxImage::FindHandler( name );
OUTPUT:
RETVAL
wxImageHandler*
FindHandlerExtType( extension, type )
wxString extension
wxBitmapType type
CODE:
RETVAL = wxImage::FindHandler( extension, type );
OUTPUT:
RETVAL
wxImageHandler*
FindHandlerType( type )
wxBitmapType type
CODE:
RETVAL = wxImage::FindHandler( type );
OUTPUT:
RETVAL
wxImageHandler*
FindHandlerMime( mime )
wxString mime
CODE:
RETVAL = wxImage::FindHandlerMime( mime );
OUTPUT:
RETVAL
#if WXPERL_W_VERSION_GE( 2, 5, 3 )
void
wxImage::GetAlpha( ... )
PPCODE:
BEGIN_OVERLOAD()
MATCH_VOIDM_REDISP( GetAlphaData )
MATCH_REDISP( wxPliOvl_n_n, GetAlphaXY )
END_OVERLOAD( Wx::Image::GetAlpha )
unsigned char
wxImage::GetAlphaXY( x, y )
int x
int y
CODE:
RETVAL = THIS->GetAlpha( x, y );
OUTPUT: RETVAL
SV*
wxImage::GetAlphaData()
CODE:
unsigned char* alpha = THIS->GetAlpha();
if( alpha == NULL )
XSRETURN_UNDEF;
RETVAL = newSVpvn( (char*) alpha, THIS->GetWidth() * THIS->GetHeight() );
OUTPUT:
RETVAL
#endif
SV*
wxImage::GetData()
CODE:
STRLEN len = THIS->GetWidth() * THIS->GetHeight() * 3;
RETVAL = newSVpvn( (char*)THIS->GetData(), len );
OUTPUT:
RETVAL
unsigned char
wxImage::GetBlue( x, y )
int x
int y
unsigned char
wxImage::GetGreen( x, y )
int x
int y
unsigned char
wxImage::GetRed( x, y )
int x
int y
int
wxImage::GetHeight()
unsigned char
wxImage::GetMaskBlue()
unsigned char
wxImage::GetMaskGreen()
unsigned char
wxImage::GetMaskRed()
wxString
wxImage::GetOption( name )
wxString name
int
wxImage::GetOptionInt( name )
wxString name
wxPalette*
wxImage::GetPalette()
CODE:
RETVAL = new wxPalette( THIS->GetPalette() );
OUTPUT:
RETVAL
wxImage*
wxImage::GetSubImage( rect )
wxRect* rect
CODE:
RETVAL = new wxImage( THIS->GetSubImage( *rect ) );
OUTPUT:
RETVAL
int
wxImage::GetWidth()
#if WXPERL_W_VERSION_GE( 2, 5, 3 )
bool
wxImage::HasAlpha()
#endif
#if WXPERL_W_VERSION_GE( 2, 5, 4 )
void
wxImage::InitAlpha()
#endif
#if WXPERL_W_VERSION_GE( 2, 6, 1 )
bool
wxImage::IsTransparent( x, y, threshold = wxIMAGE_ALPHA_THRESHOLD )
int x
int y
unsigned char threshold
#endif
bool
wxImage::HasMask()
bool
wxImage::HasOption( name )
wxString name
bool
wxImage::HasPalette()
void
InsertHandler( handler )
wxImageHandler* handler
CODE:
wxImage::InsertHandler( handler );
void
wxImage::LoadFile( ... )
PPCODE:
BEGIN_OVERLOAD()
MATCH_REDISP( wxPliOvl_wist_n, LoadStreamType )
MATCH_REDISP( wxPliOvl_wist_s, LoadStreamMIME )
MATCH_REDISP( wxPliOvl_s_n, LoadFileType )
MATCH_REDISP( wxPliOvl_s_s, LoadFileMIME )
END_OVERLOAD( Wx::Image::LoadFile )
bool
wxImage::LoadFileType( name, type, index = -1 )
wxString name
wxBitmapType type
int index
CODE:
RETVAL = THIS->LoadFile( name, type, index );
OUTPUT:
RETVAL
bool
wxImage::LoadFileMIME( name, type, index = -1 )
wxString name
wxString type
int index
CODE:
RETVAL = THIS->LoadFile( name, type, index );
OUTPUT:
RETVAL
bool
wxImage::LoadStreamType( stream, type, index = -1 )
wxPliInputStream stream
wxBitmapType type
int index
CODE:
RETVAL = THIS->LoadFile( stream, type, index );
OUTPUT:
RETVAL
bool
wxImage::LoadStreamMIME( stream, type, index = -1 )
wxPliInputStream stream
wxString type
int index
CODE:
RETVAL = THIS->LoadFile( stream, type, index );
OUTPUT:
RETVAL
bool
wxImage::Ok()
#if WXPERL_W_VERSION_GE( 2, 8, 0 )
bool
wxImage::IsOk()
#endif
void
wxImage::SaveFile( ... )
PPCODE:
BEGIN_OVERLOAD()
MATCH_REDISP( wxPliOvl_wost_n, SaveFileSType )
MATCH_REDISP( wxPliOvl_wost_s, SaveFileSMIME )
MATCH_REDISP( wxPliOvl_s_n, SaveFileType )
MATCH_REDISP( wxPliOvl_s_s, SaveFileMIME )
MATCH_REDISP( wxPliOvl_s, SaveFileOnly )
END_OVERLOAD( Wx::Image::SaveFile )
bool
wxImage::SaveFileOnly( name )
wxString name
CODE:
RETVAL = THIS->SaveFile( name );
OUTPUT:
RETVAL
bool
wxImage::SaveFileType( name, type )
wxString name
wxBitmapType type
CODE:
RETVAL = THIS->SaveFile( name, type );
OUTPUT:
RETVAL
bool
wxImage::SaveFileMIME( name, type )
wxString name
wxString type
CODE:
RETVAL = THIS->SaveFile( name, type );
OUTPUT:
RETVAL
bool
wxImage::SaveStreamType( stream, type )
wxPliOutputStream stream
wxBitmapType type
CODE:
RETVAL = THIS->SaveFile( stream, type );
OUTPUT:
RETVAL
bool
wxImage::SaveStreamMIME( stream, type )
wxPliOutputStream stream
wxString type
CODE:
RETVAL = THIS->SaveFile( stream, type );
OUTPUT:
RETVAL
wxImage*
wxImage::Mirror( horizontally = true )
bool horizontally
CODE:
RETVAL = new wxImage( THIS->Mirror( horizontally ) );
OUTPUT: RETVAL
void
wxImage::Replace( r1, g1, b1, r2, g2, b2 )
unsigned char r1
unsigned char g1
unsigned char b1
unsigned char r2
unsigned char g2
unsigned char b2
#if WXPERL_W_VERSION_GE( 2, 8, 0 )
wxImage*
wxImage::Rescale( width, height, quality = wxIMAGE_QUALITY_NORMAL )
int width
int height
wxImageResizeQuality quality
CODE:
RETVAL = new wxImage( THIS->Rescale( width, height, quality ) );
OUTPUT:
RETVAL
#else
wxImage*
wxImage::Rescale( width, height )
int width
int height
CODE:
RETVAL = new wxImage( THIS->Rescale( width, height ) );
OUTPUT:
RETVAL
#endif
void
wxImage::Rotate( angle, centre, interpolating = true )
double angle
wxPoint centre
bool interpolating
PREINIT:
wxPoint after;
wxImage* result;
PPCODE:
result = new wxImage( THIS->Rotate( angle, centre, interpolating, &after ) );
XPUSHs( wxPli_object_2_sv( aTHX_ sv_newmortal(), result ) );
if( GIMME_V == G_ARRAY ) {
PUSHs( wxPli_non_object_2_sv( aTHX_ sv_newmortal(),
new wxPoint( after ), "Wx::Point" ) );
}
#if WXPERL_W_VERSION_GE( 2, 6, 3 )
void
wxImage::RotateHue( angle )
double angle
#endif
wxImage*
wxImage::Rotate90( clockwise = true )
bool clockwise
CODE:
RETVAL = new wxImage( THIS->Rotate90( clockwise ) );
OUTPUT:
RETVAL
#if WXPERL_W_VERSION_GE( 2, 4, 1 )
wxImage*
wxImage::ShrinkBy( xfactor, yfactor )
int xfactor
int yfactor
CODE:
RETVAL = new wxImage( THIS->ShrinkBy( xfactor, yfactor ) );
OUTPUT: RETVAL
#endif
#if WXPERL_W_VERSION_GE( 2, 8, 0 )
wxImage*
wxImage::Scale( width, height, quality = wxIMAGE_QUALITY_NORMAL )
int width
int height
wxImageResizeQuality quality
CODE:
RETVAL = new wxImage( THIS->Scale( width, height, quality ) );
OUTPUT:
RETVAL
#else
wxImage*
wxImage::Scale( width, height )
int width
int height
CODE:
RETVAL = new wxImage( THIS->Scale( width, height ) );
OUTPUT:
RETVAL
#endif
#if WXPERL_W_VERSION_GE( 2, 5, 3 )
void
wxImage::SetAlpha( ... )
PPCODE:
BEGIN_OVERLOAD()
MATCH_REDISP( wxPliOvl_s, SetAlphaData )
MATCH_REDISP( wxPliOvl_n_n_n, SetAlphaXY )
END_OVERLOAD( Wx::Image::SetAlpha )
void
wxImage::SetAlphaXY( x, y, alpha )
int x
int y
unsigned char alpha
CODE:
THIS->SetAlpha( x, y, alpha );
void
wxImage::SetAlphaData( d )
SV* d
CODE:
STRLEN len;
unsigned char* data = (unsigned char*) SvPV( d, len );
STRLEN imglen = THIS->GetWidth() * THIS->GetHeight();
unsigned char* data_copy = (unsigned char*) malloc( imglen );
memcpy( data_copy, data, len );
THIS->SetAlpha( data_copy );
#endif
void
wxImage::SetData( d )
SV* d
CODE:
STRLEN len;
unsigned char* data = (unsigned char*)SvPV( d, len );
STRLEN imglen = THIS->GetWidth() * THIS->GetHeight() * 3;
unsigned char* data_copy = (unsigned char*)malloc( imglen );
memcpy( data_copy, data, len );
THIS->SetData( data_copy );
void
wxImage::SetMask( hasMask = true )
bool hasMask
void
wxImage::SetMaskColour( red, green, blue )
unsigned char red
unsigned char green
unsigned char blue
void
wxImage::SetOption( name, value )
wxString name
wxString value
void
wxImage::SetOptionInt( name, value )
wxString name
int value
CODE:
THIS->SetOption( name, value );
void
wxImage::SetPalette( palette )
wxPalette* palette
CODE:
THIS->SetPalette( *palette );
#if WXPERL_W_VERSION_GE( 2, 8, 0 )
void
wxImage::SetRGB( ... )
PPCODE:
BEGIN_OVERLOAD()
MATCH_REDISP( wxPliOvl_n_n_n_n_n, SetRGBpixel )
MATCH_REDISP( wxPliOvl_wrec_n_n_n, SetRGBrect )
END_OVERLOAD( Wx::Image::SetRGB )
void
wxImage::SetRGBpixel( x, y, red, green, blue )
int x
int y
unsigned char red
unsigned char green
unsigned char blue
CODE:
THIS->SetRGB( x, y, red, green, blue );
void
wxImage::SetRGBrect( rect, red, green, blue )
wxRect* rect
unsigned char red
unsigned char green
unsigned char blue
CODE:
THIS->SetRGB( *rect, red, green, blue );
#else
void
wxImage::SetRGB( x, y, red, green, blue )
int x
int y
unsigned char red
unsigned char green
unsigned char blue
#endif
#if WXPERL_W_VERSION_GE( 2, 8, 0 )
wxImage*
wxImage::Blur( blurradius )
int blurradius
CODE:
RETVAL = new wxImage( THIS->Blur( blurradius ) );
OUTPUT:
RETVAL
wxImage*
wxImage::BlurHorizontal( blurradius )
int blurradius
CODE:
RETVAL = new wxImage( THIS->BlurHorizontal( blurradius ) );
OUTPUT:
RETVAL
wxImage*
wxImage::BlurVertical( blurradius )
int blurradius
CODE:
RETVAL = new wxImage( THIS->BlurVertical( blurradius ) );
OUTPUT:
RETVAL
bool
wxImage::GetOrFindMaskColour( red, green, blue )
unsigned char* red
unsigned char* green
unsigned char* blue
#endif
MODULE=Wx PACKAGE=Wx::ImageHandler
void
wxImageHandler::Destroy()
CODE:
delete THIS;
int
wxImageHandler::GetImageCount( stream )
wxPliInputStream stream
wxString
wxImageHandler::GetName()
wxString
wxImageHandler::GetExtension()
#if WXPERL_W_VERSION_GE( 2, 9, 0 )
wxBitmapType
wxImageHandler::GetType()
#else
long
wxImageHandler::GetType()
#endif
wxString
wxImageHandler::GetMimeType()
bool
wxImageHandler::LoadFile( image, stream, verbose = true, index = 0 )
wxImage* image
wxPliInputStream stream
bool verbose
int index
bool
wxImageHandler::SaveFile( image, stream )
wxImage* image
wxPliOutputStream stream
void
wxImageHandler::SetName( name )
wxString name
void
wxImageHandler::SetExtension( ext )
wxString ext
void
wxImageHandler::SetMimeType( type )
wxString type
void
wxImageHandler::SetType( type )
wxBitmapType type
MODULE=Wx PACKAGE=Wx::GIFHandler
wxGIFHandler*
wxGIFHandler::new()
MODULE=Wx PACKAGE=Wx::BMPHandler
wxBMPHandler*
wxBMPHandler::new()
MODULE=Wx PACKAGE=Wx::PNMHandler
wxPNMHandler*
wxPNMHandler::new()
MODULE=Wx PACKAGE=Wx::PCXHandler
wxPCXHandler*
wxPCXHandler::new()
MODULE=Wx PACKAGE=Wx::PNGHandler
wxPNGHandler*
wxPNGHandler::new()
MODULE=Wx PACKAGE=Wx::JPEGHandler
wxJPEGHandler*
wxJPEGHandler::new()
#if wxPERL_USE_LIBTIFF && !defined( __WXWINCE__ )
MODULE=Wx PACKAGE=Wx::TIFFHandler
wxTIFFHandler*
wxTIFFHandler::new()
#endif
MODULE=Wx PACKAGE=Wx::XPMHandler
wxXPMHandler*
wxXPMHandler::new()
MODULE=Wx PACKAGE=Wx::IFFHandler
#if wxPERL_USE_IFF
wxIFFHandler*
wxIFFHandler::new()
#endif
#if wxPERL_USE_ICO_CUR
MODULE=Wx PACKAGE=Wx::ICOHandler
wxICOHandler*
wxICOHandler::new()
MODULE=Wx PACKAGE=Wx::CURHandler
wxCURHandler*
wxCURHandler::new()
MODULE=Wx PACKAGE=Wx::ANIHandler
wxANIHandler*
wxANIHandler::new()
#endif
#if wxUSE_TGA
MODULE=Wx PACKAGE=Wx::TGAHandler
wxTGAHandler*
wxTGAHandler::new()
#endif
MODULE=Wx PACKAGE=Wx PREFIX=wx
void
wxInitAllImageHandlers()