wxruby3 0.9.0.pre.beta.10 → 0.9.0.pre.beta.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 392d24963cded73bac9b253b83e6206ed8c1841ea697d6ec0af4d54faaabd79a
-  data.tar.gz: 9715c643d176e5da3c2540f84a2698d551a3cff4d6f28488644d5d9e3d929da3
+  metadata.gz: b577d2fda2fffbd6d2ef1e8f53c6f2542c15e66e50a2d8b843ce7362a3ef5ba3
+  data.tar.gz: 49dbec57d8a01bee05d23d0c995d7e7ac00eeac589f33d4a9b18c47e703483d7
 SHA512:
-  metadata.gz: a833c65595d26722ada2368508ed654861f12bb5936fd3b65d29a5a72ce5dcbbc052930bc7a198e4aaba9547d0d3e73facd4a8f995f4cb65ea051c0817c47335
-  data.tar.gz: f95957c8734b5f02f69977b8b937ec304946b4a8f171d40b25c8be7d70b4eae667878d541b76d49b4f2c8895bbebf191ac7e2b813877a3c67ff47f8687c7288f
+  metadata.gz: 67b9604ae977c9ebb9399de258c0c0452b560a7365325c2ef173e26ba5c97acb63b3de4c8f55a4494d3c2c474df7fde7f301ec81d151d7469576fbb0c6b7594d
+  data.tar.gz: 3ac00b5f4fac949aa8d757be43c092358f294007fda663b68f15094ac287c564469bbd9dd81ecaf3a003b30e13228e012c7e80a0ac3617833d50a290fcafb4a5

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/lib/wx/core/data_object.rb

@@ -1,10 +1,78 @@
-# Provide some default implementations of these to make life easier
-class Wx::DataObject
-  def get_preferred_format(direction)
-    get_all_formats(direction).first
+
+module Wx
+
+  # Provide some default implementations of these to make life easier
+  class DataObject
+    def get_preferred_format(direction)
+      get_all_formats(direction).first
+    end
+
+    def get_format_count(direction)
+      get_all_formats(direction).size
+    end
   end
 
-  def get_format_count(direction)
-    get_all_formats(direction).size
+  class DataObjectSimple
+
+    # implement the overloads which do not require the format arg
+    # using pure Ruby
+
+    wx_get_data_size = instance_method :get_data_size
+    define_method :get_data_size do |format = nil|
+      wx_get_data_size.bind(self).call(format || self.get_format)
+    end
+
+    wx_get_data_here = instance_method :get_data_here
+    define_method :get_data_here do |format = nil|
+      wx_get_data_here.bind(self).call(format || self.get_format)
+    end
+
+    wx_set_data = instance_method :set_data
+    define_method :set_data do |*args|
+      if args.size>1
+        format, buf = args
+      else
+        format = nil
+        buf = args.first
+      end
+      wx_set_data.bind(self).call(format || self.get_format, buf)
+    end
+
   end
+
+  class DataObjectSimpleBase
+
+    # implement these in pure Ruby for optimization
+    def get_data_size(*)
+      self._get_data_size
+    end
+    def get_data_here(*)
+      self._get_data
+    end
+
+    def set_data(*args)
+      if args.size>1
+        _, buf = args
+      else
+        buf = args.first
+      end
+      self._set_data(buf)
+    end
+
+    def _get_data_size
+      (_get_data || '').bytesize
+    end
+    protected :_get_data_size
+
+  end
+
+  class TextDataObject
+
+    # override this to loose the extra terminating 0 we otherwise get
+    def get_data_here(*)
+      self.get_text
+    end
+
+  end
+
 end

data/lib/wx/core/point.rb

@@ -1,4 +1,7 @@
 class Wx::Point
+
+  include Comparable
+
   # More informative output when converted to string
   def to_s
     "#<Wx::Point: (#{x}, #{y})>"
@@ -16,23 +19,26 @@ class Wx::Point
   alias :get_x :x
   alias :get_y :y
 
-  # Compare point values
-  def ==(other)
-    if Wx::Point === other
+  # Correct comparison for Points - same if same x and y
+  def eql?(other)
+    if other.instance_of?(self.class)
       x == other.x and y == other.y
-    elsif Array === other && other.size == 2
-      to_ary == other
     else
-      Kernel.raise TypeError, "Cannot compare Point to #{other}"
+      false
     end
   end
 
-  # Correct comparison for Points - same if same x and y
-  def eql?(other)
+  def hash
+    to_ary.hash
+  end
+
+  def <=>(other)
     if Wx::Point === other
-      x == other.x and y == other.y
+      (x*y) <=> (other.x*other.y)
+    elsif Array === other && other.size == 2
+      (x*y) <=> (other.first.to_i*other.last.to_i)
     else
-      false
+      nil
     end
   end
 
@@ -89,4 +95,9 @@ class Wx::Point
       end
     end
   end
+
+  def to_real_point
+    Wx::RealPoint.new(self.x.to_f, self.y.to_f)
+  end
+  alias :to_real :to_real_point
 end