wxruby3 0.9.0.pre.beta.9 → 0.9.0.pre.beta.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ce9e7bb6763fb08e50024b77b709a9cc94032933960dbdaee1b3a5f90acad71d
-  data.tar.gz: 3d39f6499828d222e038a1bd4880af58befe24f887d2d73534213107f024bf46
+  metadata.gz: b577d2fda2fffbd6d2ef1e8f53c6f2542c15e66e50a2d8b843ce7362a3ef5ba3
+  data.tar.gz: 49dbec57d8a01bee05d23d0c995d7e7ac00eeac589f33d4a9b18c47e703483d7
 SHA512:
-  metadata.gz: a2a56a03af8da3b6fe6dc57192cf151218cd6f6bf2dca613cdfccae1851451fc7ecb75080cb530050e30f438bee6c8990106795218e6cc5601a033517b92b445
-  data.tar.gz: 02b8069fda0d2c3a0237747650f081b1824787d72c9aaad98ce8ef78cbd6cb5a1752bda5e98539ba092bc786854b86e26141fa935c3cd58817290931d0f7c836
+  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/ext/wxruby3/swig/mark_free_impl.i

@@ -340,38 +340,4 @@ WXRUBY_EXPORT void GC_mark_wxEvent(void *ptr)
     std::wcout << "< GC_mark_wxEvent : " <<  ptr << std::endl;
 #endif
 }
-
-// Prevents Ruby's GC sweeping up items that are stored as client data
-// Checks whether the C++ object is still around first...
-WXRUBY_EXPORT void GC_mark_wxControlWithItems(void* ptr)
-{
-#ifdef __WXRB_DEBUG__
-  if (wxRuby_TraceLevel()>1)
-    std::wcout << "> GC_mark_wxControlWithItems : " << ptr << std::endl;
-#endif
-
-  if ( GC_IsWindowDeleted(ptr) )
-	return;
-
-  GC_mark_wxWindow(ptr);
-
-  wxControlWithItems* wx_cwi = (wxControlWithItems*) ptr;
-  int count = wx_cwi->GetCount();
-  if ( count == 0 )
-	return; // Empty control
-  if ( ! wx_cwi->HasClientObjectData() && ! wx_cwi->HasClientUntypedData() )
-	return; // Control containing only strings
-
-  for (int i = 0; i < count; ++i)
-	{
-	  VALUE object = (VALUE) wx_cwi->GetClientData(i);
-	  if ( object && object != Qnil )
-		rb_gc_mark(object);
-	}
-
-#ifdef __WXRB_DEBUG__
-  if (wxRuby_TraceLevel()>1)
-    std::wcout << "< GC_mark_wxControlWithItems : " << ptr << std::endl;
-#endif
-}
 %}

data/ext/wxruby3/swig/wx.i

@@ -263,7 +263,7 @@ const int wxrb_trace_level = 0;
 #ifdef __WXRB_DEBUG__
 WXRUBY_EXPORT int wxRuby_TraceLevel()
 {
-  return _wxrb_trace_level;
+  return wxrb_trace_level;
 }
 #endif
 %}

data/lib/wx/core/bitmap.rb

@@ -25,6 +25,13 @@ class Wx::Bitmap
     new(img, depth)
   end
 
+  # Create a new bitmap from an icon
+  def self.from_icon(icon)
+    bmp = self.new
+    bmp.copy_from_icon(icon)
+    bmp
+  end
+
   # Ruby methods that switch class are conventionally named to_foo
   alias :to_image :convert_to_image
 

data/lib/wx/core/choice.rb

@@ -1,3 +1,6 @@
+
+require_relative './controlwithitems'
+
 class Wx::Choice
   alias :get_item_data :get_client_data
   alias :set_item_data :set_client_data

data/lib/wx/core/combobox.rb

@@ -1,3 +1,6 @@
+
+require_relative './controlwithitems'
+
 class Wx::ComboBox
   alias :get_item_data :get_client_data
   alias :set_item_data :set_client_data