wxruby3 0.9.0.pre.beta.10 → 0.9.0.pre.beta.13

data/ext/wxruby3/include/wxruby-ScaledDC.h

@@ -0,0 +1,549 @@
+/*
+ * WxRuby3 wxScaledDC class
+ * Derived from wxSFScaledDC class in wxShapeFramework library.
+ * Copyright (c) M.J.N. Corino, The Netherlands
+ */
+/***************************************************************
+ * Name:      ScaledDC.h
+ * Purpose:   Defines scaled DC class
+ * Author:    Michal Bližňák (michal.bliznak@tiscali.cz)
+ * Created:   2008-11-7
+ * Copyright: Michal Bližňák
+ * License:   wxWidgets license (www.wxwidgets.org)
+ * Notes:
+ **************************************************************/
+
+#ifndef _WXRUBY_SCALEDDC_H
+#define _WXRUBY_SCALEDDC_H
+
+#include <wx/graphics.h>
+#include <wx/dc.h>
+#include <math.h>
+#include <wx/dcclient.h>
+
+class wxDCImplWrapper : public wxDCImpl
+{
+public:
+	friend class wxScaledDC;
+	
+	wxDCImplWrapper( wxDCImpl *orig, double scale ) : wxDCImpl( orig->GetOwner() )
+	{
+		m_pOrig = orig;
+		m_nScale = scale;
+	}
+  virtual ~wxDCImplWrapper()
+	{
+	}
+
+  wxDC *GetOwner() const { return m_pOrig->GetOwner(); }
+
+  wxWindow* GetWindow() const { return m_pOrig->GetWindow(); }
+
+  virtual bool IsOk() const { return m_pOrig->IsOk(); }
+
+  // query capabilities
+
+  virtual bool CanDrawBitmap() const { return m_pOrig->CanDrawBitmap(); }
+  virtual bool CanGetTextExtent() const { return m_pOrig->CanGetTextExtent(); }
+
+  // get Cairo context
+  virtual void* GetCairoContext() const
+  {
+    return m_pOrig->GetCairoContext();
+  }
+
+  // query dimension, colour deps, resolution
+
+  virtual void DoGetSize(int *width, int *height) const { m_pOrig->DoGetSize( width, height); }
+  void GetSize(int *width, int *height) const
+  {
+    DoGetSize(width, height);
+    return ;
+  }
+
+  wxSize GetSize() const
+  {
+    int w, h;
+    DoGetSize(&w, &h);
+    return wxSize(w, h);
+  }
+
+  virtual void DoGetSizeMM(int* width, int* height) const { m_pOrig->DoGetSizeMM( width, height); }
+
+  virtual int GetDepth() const { return m_pOrig->GetDepth(); }
+  virtual wxSize GetPPI() const { return m_pOrig->GetPPI(); }
+
+  // Right-To-Left (RTL) modes
+
+  virtual void SetLayoutDirection(wxLayoutDirection dir) { m_pOrig->SetLayoutDirection( dir ); }
+  virtual wxLayoutDirection GetLayoutDirection() const { return m_pOrig->GetLayoutDirection(); }
+
+  // page and document
+
+  virtual bool StartDoc(const wxString& message) { return m_pOrig->StartDoc( message ); }
+  virtual void EndDoc() { return m_pOrig->EndDoc(); }
+
+  virtual void StartPage() { m_pOrig->StartPage(); }
+  virtual void EndPage() { m_pOrig->EndPage(); }
+
+  // flushing the content of this dc immediately eg onto screen
+  virtual void Flush() { m_pOrig->Flush(); }
+
+  // bounding box
+
+  virtual void CalcBoundingBox(wxCoord x, wxCoord y) { m_pOrig->CalcBoundingBox( x, y); }
+
+  wxCoord MinX() const { return m_pOrig->MinX(); }
+  wxCoord MaxX() const { return m_pOrig->MaxX(); }
+  wxCoord MinY() const { return m_pOrig->MinY(); }
+  wxCoord MaxY() const { return m_pOrig->MaxY(); }
+
+  // setters and getters
+
+  virtual void SetFont(const wxFont& font) { m_pOrig->SetFont( font ); }
+  virtual const wxFont& GetFont() const { return m_pOrig->GetFont(); }
+
+  virtual void SetPen(const wxPen& pen) { m_pOrig->SetPen( pen ); }
+  virtual const wxPen& GetPen() const { return m_pOrig->GetPen(); }
+
+  virtual void SetBrush(const wxBrush& brush) { m_pOrig->SetBrush( brush ); }
+  virtual const wxBrush& GetBrush() const { return m_pOrig->GetBrush(); }
+
+  virtual void SetBackground(const wxBrush& brush) { m_pOrig->SetBackground( brush ); }
+  virtual const wxBrush& GetBackground() const { return m_pOrig->GetBackground(); }
+
+  virtual void SetBackgroundMode(int mode) { m_pOrig->SetBackgroundMode( mode ); }
+  virtual int GetBackgroundMode() const { return m_pOrig->GetBackgroundMode(); }
+
+  virtual void SetTextForeground(const wxColour& colour) { m_pOrig->SetTextForeground( colour ); }
+  virtual const wxColour& GetTextForeground() const { return m_pOrig->GetTextForeground(); }
+
+  virtual void SetTextBackground(const wxColour& colour) { m_pOrig->SetTextBackground( colour ); }
+  virtual const wxColour& GetTextBackground() const { return m_pOrig->GetTextBackground(); }
+
+#if wxUSE_PALETTE
+  virtual void SetPalette(const wxPalette& palette) { m_pOrig->SetPalette( palette ); }
+#endif // wxUSE_PALETTE
+
+  // inherit the DC attributes (font and colours) from the given window
+  //
+  // this is called automatically when a window, client or paint DC is
+  // created
+  virtual void InheritAttributes(wxWindow *win) { m_pOrig->InheritAttributes( win ); }
+
+
+  // logical functions
+
+  virtual void SetLogicalFunction(wxRasterOperationMode function) { m_pOrig->SetLogicalFunction( function ); }
+  virtual wxRasterOperationMode GetLogicalFunction() const { return m_pOrig->GetLogicalFunction(); }
+
+  // text measurement
+
+  virtual wxCoord GetCharHeight() const { return m_pOrig->GetCharHeight(); }
+  virtual wxCoord GetCharWidth() const { return m_pOrig->GetCharWidth(); }
+  virtual void DoGetTextExtent(const wxString& string,
+                               wxCoord *x, wxCoord *y,
+                               wxCoord *descent = NULL,
+                               wxCoord *externalLeading = NULL,
+                               const wxFont *theFont = NULL) const { m_pOrig->DoGetTextExtent( string, x, y, descent, externalLeading, theFont ); }
+  virtual void GetMultiLineTextExtent(const wxString& string,
+                                      wxCoord *width,
+                                      wxCoord *height,
+                                      wxCoord *heightLine = NULL,
+                                      const wxFont *font = NULL) const { m_pOrig->GetMultiLineTextExtent( string, width, height, heightLine, font ); }
+  virtual bool DoGetPartialTextExtents(const wxString& text, wxArrayInt& widths) const { return m_pOrig->DoGetPartialTextExtents( text, widths); }
+
+  // clearing
+
+  virtual void Clear() { m_pOrig->Clear(); }
+
+  // clipping
+
+  virtual void DoSetClippingRegion(wxCoord x, wxCoord y,
+                                   wxCoord width, wxCoord height) { m_pOrig->DoSetClippingRegion( x, y, width, height ); }
+
+  // NB: this function works with device coordinates, not the logical ones!
+  virtual void DoSetDeviceClippingRegion(const wxRegion& region) { m_pOrig->DoSetDeviceClippingRegion( region ); }
+
+  virtual bool DoGetClippingRect(wxRect& rect) const { return m_pOrig->DoGetClippingRect(rect); }
+
+  virtual void DestroyClippingRegion() { m_pOrig->DestroyClippingRegion(); }
+
+
+  // coordinates conversions and transforms
+
+  virtual wxCoord DeviceToLogicalX(wxCoord x) const { return m_pOrig->DeviceToLogicalX(x); }
+  virtual wxCoord DeviceToLogicalY(wxCoord y) const { return m_pOrig->DeviceToLogicalY(y); }
+  virtual wxCoord DeviceToLogicalXRel(wxCoord x) const { return m_pOrig->DeviceToLogicalXRel(x); }
+  virtual wxCoord DeviceToLogicalYRel(wxCoord y) const { return m_pOrig->DeviceToLogicalYRel(y); }
+  virtual wxCoord LogicalToDeviceX(wxCoord x) const { return m_pOrig->LogicalToDeviceX(x); }
+  virtual wxCoord LogicalToDeviceY(wxCoord y) const { return m_pOrig->LogicalToDeviceY(y); }
+  virtual wxCoord LogicalToDeviceXRel(wxCoord x) const { return m_pOrig->LogicalToDeviceXRel(x); }
+  virtual wxCoord LogicalToDeviceYRel(wxCoord y) const { return m_pOrig->LogicalToDeviceYRel(y); }
+
+  virtual void SetMapMode(wxMappingMode mode) { m_pOrig->SetMapMode(mode); }
+  virtual wxMappingMode GetMapMode() const { return m_pOrig->GetMapMode(); }
+
+  virtual void SetUserScale(double x, double y) { m_pOrig->SetUserScale( x, y ); }
+  virtual void GetUserScale(double *x, double *y) const { m_pOrig->GetUserScale( x, y ); }
+
+  virtual void SetLogicalScale(double x, double y) { m_pOrig->SetLogicalScale( x, y ); }
+  virtual void GetLogicalScale(double *x, double *y) const { m_pOrig->GetLogicalScale( x, y ); }
+
+  virtual void SetLogicalOrigin(wxCoord x, wxCoord y) { m_pOrig->SetLogicalOrigin( x, y ); }
+  virtual void DoGetLogicalOrigin(wxCoord *x, wxCoord *y) const { m_pOrig->DoGetLogicalOrigin( x, y); }
+
+  virtual void SetDeviceOrigin(wxCoord x, wxCoord y) { m_pOrig->SetDeviceOrigin( x, y ); }
+  virtual void DoGetDeviceOrigin(wxCoord *x, wxCoord *y) const { m_pOrig->DoGetDeviceOrigin( x, y ); }
+
+  virtual void SetDeviceLocalOrigin( wxCoord x, wxCoord y ) { m_pOrig->SetDeviceLocalOrigin( x, y ); }
+
+  virtual void ComputeScaleAndOrigin() { m_pOrig->ComputeScaleAndOrigin(); }
+
+  // this needs to overidden if the axis is inverted
+  virtual void SetAxisOrientation(bool xLeftRight, bool yBottomUp) { m_pOrig->SetAxisOrientation( xLeftRight, yBottomUp); }
+
+  // ---------------------------------------------------------
+  // the actual drawing API
+
+  virtual bool DoFloodFill(wxCoord x, wxCoord y, const wxColour& col,
+                           wxFloodFillStyle style = wxFLOOD_SURFACE)
+	{
+		return m_pOrig->DoFloodFill( ScaleCoord(x), ScaleCoord(y), col, style );
+	}
+
+  virtual void DoGradientFillLinear(const wxRect& rect,
+                                    const wxColour& initialColour,
+                                    const wxColour& destColour,
+                                    wxDirection nDirection = wxEAST)
+	{
+		m_pOrig->DoGradientFillLinear( wxRect( ScaleInt(rect.x), ScaleInt(rect.y), ScaleInt(rect.width), ScaleInt(rect.height)),
+										initialColour, destColour, nDirection );
+	}
+
+  virtual void DoGradientFillConcentric(const wxRect& rect,
+                                      const wxColour& initialColour,
+                                      const wxColour& destColour,
+                                      const wxPoint& circleCenter)
+	{
+		m_pOrig->DoGradientFillConcentric( wxRect( ScaleInt(rect.x), ScaleInt(rect.y), ScaleInt(rect.width), ScaleInt(rect.height)),
+											initialColour, destColour,
+											wxPoint( ScaleInt(circleCenter.x), ScaleInt(circleCenter.y)) );
+	}
+
+  virtual bool DoGetPixel(wxCoord x, wxCoord y, wxColour *col) const
+	{
+		return m_pOrig->DoGetPixel( (wxCoord)ceil((double)x*m_nScale), (wxCoord)ceil((double)y*m_nScale), col );
+	}
+
+  virtual void DoDrawPoint(wxCoord x, wxCoord y)
+	{
+		m_pOrig->DoDrawPoint( ScaleCoord(x), ScaleCoord(y) );
+	}
+  virtual void DoDrawLine(wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2)
+	{
+		m_pOrig->DoDrawLine( ScaleCoord(x1), ScaleCoord(y1), ScaleCoord(x2), ScaleCoord(y2) );
+	}
+
+  virtual void DoDrawArc(wxCoord x1, wxCoord y1,
+                         wxCoord x2, wxCoord y2,
+                         wxCoord xc, wxCoord yc)
+	{
+		m_pOrig->DoDrawArc( ScaleCoord(x1), ScaleCoord(y1),
+							ScaleCoord(x2), ScaleCoord(y2),
+							ScaleCoord(xc), ScaleCoord(yc) );
+	}
+						   
+  virtual void DoDrawCheckMark(wxCoord x, wxCoord y,
+                               wxCoord width, wxCoord height)
+	{
+		m_pOrig->DoDrawCheckMark( ScaleCoord(x), ScaleCoord(y), ScaleCoord(width), ScaleCoord(height) );
+	}
+								 
+  virtual void DoDrawEllipticArc(wxCoord x, wxCoord y, wxCoord w, wxCoord h,
+                                 double sa, double ea)
+	{
+		m_pOrig->DoDrawEllipticArc( ScaleCoord(x), ScaleCoord(y), ScaleCoord(w), ScaleCoord(h), sa, ea );
+	}
+
+  virtual void DoDrawRectangle(wxCoord x, wxCoord y, wxCoord width, wxCoord height)
+	{
+		m_pOrig->DoDrawRectangle( ScaleCoord(x), ScaleCoord(y), ScaleCoord(width), ScaleCoord(height) );
+	}
+	
+    virtual void DoDrawRoundedRectangle(wxCoord x, wxCoord y,
+                                        wxCoord width, wxCoord height,
+                                        double radius)
+	{
+		m_pOrig->DoDrawRoundedRectangle( ScaleCoord(x), ScaleCoord(y), ScaleCoord(width), ScaleCoord(height), radius*m_nScale );
+	}
+	
+  virtual void DoDrawEllipse(wxCoord x, wxCoord y,
+                             wxCoord width, wxCoord height)
+	{
+		m_pOrig->DoDrawEllipse( ScaleCoord(x), ScaleCoord(y), ScaleCoord(width), ScaleCoord(height) );
+	}
+
+  virtual void DoCrossHair(wxCoord x, wxCoord y)
+	{
+		m_pOrig->DoCrossHair( ScaleCoord(x), ScaleCoord(y) );
+	}
+
+  virtual void DoDrawIcon(const wxIcon& icon, wxCoord x, wxCoord y)
+	{
+		m_pOrig->DoDrawIcon( icon, ScaleCoord(x), ScaleCoord(y) );
+	}
+	
+  virtual void DoDrawBitmap(const wxBitmap &bmp, wxCoord x, wxCoord y,
+                            bool useMask = false)
+	{
+		m_pOrig->DoDrawBitmap( bmp, ScaleCoord(x), ScaleCoord(y), useMask );
+	}
+
+  virtual void DoDrawText(const wxString& text, wxCoord x, wxCoord y)
+	{
+    wxFont font = GetFont();
+    wxFont prevfont = font;
+
+    if(font != wxNullFont)
+    {
+      font.SetPointSize(int(font.GetPointSize()*m_nScale));
+      SetFont(font);
+    }
+
+    m_pOrig->DoDrawText( text, ScaleCoord(x), ScaleCoord(y) );
+
+    SetFont(prevfont);
+	}
+	
+  virtual void DoDrawRotatedText(const wxString& text,
+                                 wxCoord x, wxCoord y, double angle)
+	{
+    wxFont font = GetFont();
+    wxFont prevfont = font;
+
+    if(font != wxNullFont)
+    {
+      font.SetPointSize(int(font.GetPointSize()*m_nScale));
+      SetFont(font);
+    }
+		
+		m_pOrig->DoDrawRotatedText( text, ScaleCoord(x), ScaleCoord(y), angle );
+
+    SetFont(prevfont);
+	}
+
+  virtual bool DoBlit(wxCoord xdest, wxCoord ydest,
+                      wxCoord width, wxCoord height,
+                      wxDC *source,
+                      wxCoord xsrc, wxCoord ysrc,
+                      wxRasterOperationMode rop = wxCOPY,
+                      bool useMask = false,
+                      wxCoord xsrcMask = wxDefaultCoord,
+                      wxCoord ysrcMask = wxDefaultCoord)
+	{
+		return m_pOrig->DoBlit( ScaleCoord(xdest), ScaleCoord(ydest),
+								width, height, source, xsrc, ysrc, rop, useMask, xsrcMask, ysrcMask );
+	}
+
+  virtual bool DoStretchBlit(wxCoord xdest, wxCoord ydest,
+                             wxCoord dstWidth, wxCoord dstHeight,
+                             wxDC *source,
+                             wxCoord xsrc, wxCoord ysrc,
+                             wxCoord srcWidth, wxCoord srcHeight,
+                             wxRasterOperationMode rop = wxCOPY,
+                             bool useMask = false,
+                             wxCoord xsrcMask = wxDefaultCoord,
+                             wxCoord ysrcMask = wxDefaultCoord)
+	{
+		return m_pOrig->DoStretchBlit( ScaleCoord(xdest), ScaleCoord(ydest), ScaleCoord(dstWidth), ScaleCoord(dstHeight),
+								source, xsrc, ysrc, srcWidth, srcHeight, rop, useMask, xsrcMask, ysrcMask );
+	}
+
+  virtual wxBitmap DoGetAsBitmap(const wxRect *subrect) const
+	{
+		return m_pOrig->DoGetAsBitmap( subrect );
+	}
+
+#if wxVERSION_NUMBER < 2905
+  virtual void DoDrawLines(int n, wxPoint points[],
+#else
+  virtual void DoDrawLines(int n, const wxPoint points[],
+#endif	
+                           wxCoord xoffset, wxCoord yoffset )
+	{
+    wxPoint *updPoints = new wxPoint[n];
+
+    for(int i = 0; i < n; i++)
+    {
+      (updPoints + i)->x = ScaleInt((points + i)->x);
+      (updPoints + i)->y = ScaleInt((points + i)->y);
+    }
+
+    m_pOrig->DoDrawLines( n, updPoints, ScaleCoord(xoffset), ScaleCoord(yoffset) );
+
+    delete [] updPoints;
+	}
+	
+  virtual void DrawLines(const wxPointList *list,
+                         wxCoord xoffset, wxCoord yoffset )
+	{
+		int i = 0;
+		wxPoint *pts = new wxPoint[list->GetCount()];
+		
+		wxPointList::compatibility_iterator node = list->GetFirst();
+		while( node )
+		{
+			*(pts + i) = *node->GetData();
+			i++;
+			node = node->GetNext();
+		}
+		
+		wxDCImplWrapper::DoDrawLines( i, pts, xoffset, yoffset );
+		
+		delete [] pts;
+	}
+
+#if wxVERSION_NUMBER < 2905
+  virtual void DoDrawPolygon(int n, wxPoint points[],
+#else
+  virtual void DoDrawPolygon(int n, const wxPoint points[],
+#endif
+                         wxCoord xoffset, wxCoord yoffset,
+                         wxPolygonFillMode fillStyle = wxODDEVEN_RULE)
+	{
+    wxPoint *updPoints = new wxPoint[n];
+
+    for(int i = 0; i < n; i++)
+    {
+      (updPoints + i)->x = ScaleInt((points + i)->x);
+      (updPoints + i)->y = ScaleInt((points + i)->y);
+    }
+
+    m_pOrig->DoDrawPolygon(n, updPoints, ScaleCoord(xoffset), ScaleCoord(yoffset), fillStyle);
+
+    delete [] updPoints;
+	}
+	
+  virtual void DoDrawPolyPolygon(int n, const int count[], const wxPoint points[],
+                             wxCoord xoffset, wxCoord yoffset,
+                             wxPolygonFillMode fillStyle)
+	{
+    int nTotalPoints = 0;
+
+    for(int i = 0; i < n; i++)nTotalPoints += count[i];
+
+    wxPoint *updPoints = new wxPoint[nTotalPoints];
+
+    for(int i = 0; i < nTotalPoints; i++)
+    {
+      (updPoints + i)->x = ScaleInt((points + i)->x);
+      (updPoints + i)->y = ScaleInt((points + i)->y);
+    }
+
+    m_pOrig->DoDrawPolyPolygon(n, count, updPoints, ScaleCoord(xoffset), ScaleCoord(yoffset), fillStyle);
+
+    delete [] updPoints;
+	}
+							
+  void DrawPolygon(const wxPointList *list,
+                   wxCoord xoffset, wxCoord yoffset,
+                   wxPolygonFillMode fillStyle )
+	{
+		int i = 0;
+		wxPoint *pts = new wxPoint[list->GetCount()];
+		
+		wxPointList::compatibility_iterator node = list->GetFirst();
+		while( node )
+		{
+			*(pts + i) = *node->GetData();
+			i++;
+			node = node->GetNext();
+		}
+		
+		wxDCImplWrapper::DoDrawPolygon( i, pts, xoffset, yoffset, fillStyle );
+		
+		delete [] pts;
+	}
+
+
+#if wxUSE_SPLINES
+  void DrawSpline(wxCoord x1, wxCoord y1,
+                          wxCoord x2, wxCoord y2,
+                          wxCoord x3, wxCoord y3);
+  void DrawSpline(int n, wxPoint points[]);
+  void DrawSpline(const wxPointList *points) { DoDrawSpline(points); }
+
+  virtual void DoDrawSpline(const wxPointList *points)
+	{
+		wxPoint *pPt;
+		wxPointList updPoints;
+		
+		wxPointList::compatibility_iterator node = points->GetFirst();
+		while( node )
+		{
+			pPt = node->GetData();
+			updPoints.Append( new wxPoint( ScaleInt(pPt->x), ScaleInt(pPt->y)) );
+			node = node->GetNext();
+		}
+		
+		m_pOrig->DoDrawSpline( &updPoints );
+		
+		updPoints.DeleteContents( true );
+		updPoints.Clear();
+	}
+#endif
+
+  // ---------------------------------------------------------
+  // wxMemoryDC Impl API
+
+  virtual void DoSelect(const wxBitmap& bmp) { m_pOrig->DoSelect( bmp ); }
+
+  virtual const wxBitmap& GetSelectedBitmap() const { return m_pOrig->GetSelectedBitmap(); }
+  virtual wxBitmap& GetSelectedBitmap() { return m_pOrig->GetSelectedBitmap(); }
+
+  // ---------------------------------------------------------
+  // wxPrinterDC Impl API
+
+  virtual wxRect GetPaperRect() const { return m_pOrig->GetPaperRect(); }
+
+  virtual int GetResolution() const { return m_pOrig->GetResolution(); }
+
+protected:
+	/*! \brief Pointer to original DC implementation. */
+	wxDCImpl	*m_pOrig;
+	/*! \brief Global graphics scale. */
+	double		m_nScale;
+
+	/**
+	 * \brief Scale given value.
+	 * \param val Value to scale
+	 * \return Scaled value 
+	 */
+  wxCoord ScaleCoord(wxCoord val){return (wxCoord)ceil((double)val*m_nScale);}
+	
+	/**
+	 * \brief Scale given value.
+	 * \param val Value to scale
+	 * \return Scaled value 
+	 */
+  wxCoord ScaleInt(int val){return (int)ceil((double)val*m_nScale);}
+};
+
+/*! \brief Class acts as a wrapper for given DC class and provides modified
+ * drawing functions cooperating with the shape canvas able to draw scaled graphics.
+ * All drawing operations performed by the shapes should be done via this class otherwise
+ * the global scalling capabilities provided by the shape canvas wont be available.
+ * \sa wxSFShapeCanvas
+ */
+class wxScaledDC : public wxDC
+{
+public:
+	wxScaledDC(wxDC& target, double scale)
+	  : wxDC(new wxDCImplWrapper(target.GetImpl(), scale))
+  {}
+	virtual ~wxScaledDC()
+	{}
+};
+
+#endif // _WXRUBY_SCALEDDC_H

data/ext/wxruby3/swig/wx.i

@@ -235,7 +235,7 @@ WXRUBY_EXPORT VALUE wxRuby_WrapWxEventInRuby(wxEvent *wx_event)
   }
 
   // No existing Ruby instance found, so a transitory event object; wrap
-  // without mark or free functions as Wx will deals with deletion
+  // without mark or free functions as Wx will deal with deletion
   rb_event = Data_Wrap_Struct(rb_event_class, 0, 0, 0);
   DATA_PTR(rb_event) = wx_event;
   // do not forget to mark the instance with the mangled swig type name

data/lib/wx/core/array_ext.rb

@@ -0,0 +1,26 @@
+
+module Wx
+
+  # Mixin module providing Array extensions.
+  module ArrayExt
+
+    def to_size
+      w, h = self
+      Wx::Size.new(w || Wx::DEFAULT_COORD, h  || Wx::DEFAULT_COORD)
+    end
+
+    def to_point
+      x, y = self
+      Wx::Point.new(x || Wx::DEFAULT_COORD, y || Wx::DEFAULT_COORD)
+    end
+
+    def to_real_point
+      x, y = self
+      Wx::RealPoint.new(x || Wx::DEFAULT_COORD, y || Wx::DEFAULT_COORD)
+    end
+
+  end
+
+  # extend standard Array class
+  ::Array.include(Wx::ArrayExt)
+end

data/lib/wx/core/art_locator.rb

@@ -0,0 +1,92 @@
+
+module Wx
+
+  module ArtLocator
+
+    ART_FOLDER = 'art'
+
+    class << self
+
+      # This is not put in a constants as cannot retrieve image handler info
+      # before an app has started
+      def art_extensions(art_type)
+        unless @art_extensions
+          @art_extensions = {
+            icon: if Wx::PLATFORM == 'WXMSW'
+                    %w[ico xpm]
+                  elsif Wx::PLATFORM == 'WXGTK'
+                    (%w[xpm]+Image.extensions).uniq
+                  else
+                    (%w[xbm xpm]+Image.extensions).uniq
+                  end,
+            bitmap: if Wx::PLATFORM == 'WXMSW'
+                      (%w[bmp xpm]+Image.extensions).uniq
+                    elsif Wx::PLATFORM == 'WXGTK'
+                      (%w[xpm]+Image.extensions).uniq
+                    else
+                      (%w[xbm xpm]+Image.extensions).uniq
+                    end,
+            cursor: if Wx::PLATFORM == 'WXMSW'
+                      %w[cur ico bmp]
+                    elsif Wx::PLATFORM == 'WXGTK'
+                      []
+                    else
+                      %w[xbm]
+                    end,
+            image: Image.extensions
+          }
+        end
+        @art_extensions[(art_type || :image).to_sym] || []
+      end
+      private :art_extensions
+
+      def art_folder
+        @art_folder ||= ART_FOLDER
+      end
+
+      def art_folder=(name)
+        @art_folder = name ? name.to_s : ART_FOLDER
+      end
+
+      def search_paths
+        @search_paths ||= []
+      end
+      private :search_paths
+
+      def add_search_path(*paths)
+        paths.flatten.each { |p| paths << s.to_s unless paths.include?(s.to_s) }
+      end
+      alias :add_search_paths :add_search_path
+
+      def _find_art(art_name, art_type, art_path, art_section, bmp_type)
+        art_paths = [art_path, File.join(art_path, art_folder)]
+        art_paths << File.join(art_paths.last, art_section) if art_section
+        art_paths << File.join(art_paths.last, art_type.to_s) if art_type
+        art_paths.reverse_each do |sp|
+          (bmp_type ? (Image.handler_extensions[bmp_type] || []) : art_extensions(art_type)).each do |ext|
+            fp = File.join(sp, "#{art_name}.#{ext}")
+            return fp if File.file?(fp)
+          end
+        end
+        nil
+      end
+      private :_find_art
+
+      def find_art(art_name, art_type: nil, art_path: nil, art_section: nil, bmp_type: nil)
+        unless art_path
+          caller_path = caller_locations(1).first.absolute_path
+          art_path = File.dirname(caller_path)
+          art_section ||= File.basename(caller_path, '.*')
+        end
+        bmp_type = nil if bmp_type == Wx::BitmapType::BITMAP_TYPE_ANY
+        unless fp = _find_art(art_name.to_s, art_type, art_path, art_section, bmp_type)
+          search_paths.find { |sp| fp = _find_art(art_name.to_s, art_type, sp, art_section, bmp_type) }
+        end
+        fp
+      end
+
+    end
+
+  end
+
+end

data/lib/wx/core/artprovider.rb

@@ -24,7 +24,7 @@ class Wx::ArtProvider
 
     wx_delete = instance_method(:delete)
     define_method(:delete) do | art_prov |
-      wx_push.bind(self).call(art_prov)
+      wx_delete.bind(self).call(art_prov)
       @__art_provs.delete(art_prov)
     end
   end