wxruby3 0.9.0.pre.beta.8

data/rakelib/lib/director/functions.rb

@@ -0,0 +1,284 @@
+###
+# wxRuby3 wxWidgets interface director
+# Copyright (c) M.J.N. Corino, The Netherlands
+###
+
+module WXRuby3
+
+  class Director
+
+    class Functions < Director
+
+      include Typemap::ArrayIntSelections
+
+      def setup
+        super
+        spec.items.clear
+        spec.add_header_code <<~__HEREDOC
+          #include <wx/image.h>
+          #include <wx/app.h>
+          #include <wx/choicdlg.h>
+          #include <wx/numdlg.h>
+          #include <wx/xrc/xmlres.h>
+          #include <wx/utils.h>
+          #include <wx/stockitem.h>
+          #include <wx/aboutdlg.h>
+          
+          // Logging functions - these don't directly wrap the corresponding wx
+          // LogXXX functions because those expect a literal format string and a
+          // list of arguments, rather than a dynamic string. Instead we do the
+          // sprintf in ruby, then pass the composed message directly to the
+          // log. This also avoids format string attacks.
+          
+          // Log a Wx message with the given level to the current Wx log output
+          static VALUE log_generic(int argc, VALUE *argv, VALUE self)
+          {
+            if ( wxLog::IsEnabled() )
+              {
+                wxLogLevel lvl = static_cast<wxLogLevel> (NUM2INT(argv[0]));
+                VALUE log_msg = argc==2 ? argv[1] : rb_f_sprintf(argc-1, &argv[1]);
+                wxLog::OnLog( lvl,
+                              wxString(StringValuePtr(log_msg), wxConvUTF8),
+                              time(NULL) );
+              }
+            return Qnil;
+          }
+          
+          // Log a Wx low prio Message to the current Wx log output
+          static VALUE log_info(int argc, VALUE *argv, VALUE self)
+          {
+            if ( wxLog::IsEnabled() )
+              {
+                VALUE log_msg = argc==1 ? argv[0] : rb_f_sprintf(argc, argv);
+                wxLog::OnLog( wxLOG_Info,
+                              wxString(StringValuePtr(log_msg), wxConvUTF8),
+                              time(NULL) );
+              }
+            return Qnil;
+          }
+          
+          // Log a Wx verbose Message to the current Wx log output
+          static VALUE log_verbose(int argc, VALUE *argv, VALUE self)
+          {
+            if ( wxLog::IsEnabled() && wxLog::GetVerbose () )
+              {
+                VALUE log_msg = argc==1 ? argv[0] : rb_f_sprintf(argc, argv);
+                wxLog::OnLog( wxLOG_Info,
+                              wxString(StringValuePtr(log_msg), wxConvUTF8),
+                              time(NULL) );
+              }
+            return Qnil;
+          }
+          
+          // Log a Wx Message to the current Wx log output
+          static VALUE log_message(int argc, VALUE *argv, VALUE self)
+          {
+            if ( wxLog::IsEnabled() )
+              {
+                VALUE log_msg = argc==1 ? argv[0] : rb_f_sprintf(argc, argv);
+                wxLog::OnLog( wxLOG_Message,
+                              wxString(StringValuePtr(log_msg), wxConvUTF8),
+                              time(NULL) );
+              }
+            return Qnil;
+          }
+          
+          // Log a Wx Warning message to the current Wx log output
+          static VALUE log_warning(int argc, VALUE *argv, VALUE self)
+          {
+            if ( wxLog::IsEnabled() )
+              {
+                VALUE log_msg = argc==1 ? argv[0] : rb_f_sprintf(argc, argv);
+                wxLog::OnLog( wxLOG_Warning,
+                              wxString(StringValuePtr(log_msg), wxConvUTF8),
+                              time(NULL) );
+              }
+            return Qnil;
+          }
+          
+          // Log an error message to the current output
+          static VALUE log_error(int argc, VALUE *argv, VALUE self)
+          {
+            if ( wxLog::IsEnabled() )
+              {
+                VALUE log_msg = argc==1 ? argv[0] : rb_f_sprintf(argc, argv);
+                wxLog::OnLog( wxLOG_Error,
+                              wxString(StringValuePtr(log_msg), wxConvUTF8),
+                              time(NULL) );
+              }
+            return Qnil;
+          }
+
+          // Log a debug message
+          static VALUE log_debug(int argc, VALUE *argv, VALUE self)
+          {
+            if (wxLog::IsLevelEnabled(wxLOG_Debug, wxASCII_STR(wxLOG_COMPONENT)))
+            {
+                VALUE log_msg = argc==1 ? argv[0] : rb_f_sprintf(argc, argv);
+                wxLogDebug(wxString(StringValuePtr(log_msg), wxConvUTF8));
+            }
+            return Qnil;
+          }
+          
+          // Log a Wx Status message - this is directed to the status bar of the
+          // specified window, or the application main window if not specified.
+          // Based on wxWidgets code in src/generic/logg.cpp, WxLogGui::DoLog
+          static VALUE log_status(int argc, VALUE *argv, VALUE self)
+          {
+            if ( ! wxLog::IsEnabled() )
+              return Qnil;
+          
+            VALUE log_msg; // The message to be written
+            wxFrame* log_frame {}; // The frame whose status bar should display the logmsg
+          
+            // To a specific window's status bar
+            if( TYPE(argv[0]) == T_DATA ) {
+              log_msg = rb_f_sprintf(argc-1, &argv[1]);
+              Data_Get_Struct(argv[0], wxFrame, log_frame);
+            }
+            // To the application main window's status bar
+            else {
+              log_msg = rb_f_sprintf(argc, argv);
+              wxWindow* win = wxTheApp->GetTopWindow();
+              // Check the top window is actually a frame, not a dialog
+              if ( win != NULL && win->IsKindOf( CLASSINFO(wxFrame)  ) )
+                log_frame = (wxFrame*)win;
+            }
+          
+            // Finally, display in the status bar if it has one
+            if ( log_frame && log_frame->GetStatusBar() )
+              log_frame->SetStatusText(wxString( StringValuePtr(log_msg), wxConvUTF8));
+          
+            return Qnil;
+          }
+          
+          // Returns the global app object
+          static VALUE get_app(VALUE self)
+          {
+            static WxRuby_ID THE_APP_id("THE_APP");
+
+            return rb_const_get(wxRuby_Core(), THE_APP_id());
+          }
+          
+          // Converts a string XRC id into a Wx id
+          static VALUE
+          xrcid(VALUE self,VALUE str_id)
+          {
+            wxString temp(StringValuePtr(str_id), wxConvUTF8);
+            int ret = wxXmlResource::GetXRCID(temp);
+            return INT2NUM(ret);
+          }
+          
+          
+          // Returns the pointer address of the underlying C++ object as a hex
+          // string - useful for debugging
+          static VALUE
+          cpp_ptr_addr(VALUE self, VALUE obj)
+          {
+            static WxRuby_ID sprintf_id("sprintf");
+
+            size_t ptr = (size_t)DATA_PTR(obj);
+            return rb_funcall( rb_mKernel, sprintf_id(), 2,
+                               rb_str_new2("0x%x"), OFFT2NUM(ptr) );
+          }
+          __HEREDOC
+
+        # All the functions which take a parent argument in this file display
+        # dialogs, so the parent argument can be nil (which is not permitted in
+        # the normal typemap defined in common.rb). So override the standard
+        # typemap and just check that the App has been started.
+        spec.map 'wxWindow* parent' do
+          map_check code: <<~__CODE
+            if ( !wxRuby_IsAppRunning() )
+            { 
+                rb_raise(rb_eRuntimeError,
+                       "Cannot display dialog before App.main_loop has been called");
+            }
+            __CODE
+        end
+        # hardcoded interface declarations
+        spec.add_interface_code <<~__HEREDOC
+          bool wxSafeYield(wxWindow* win = NULL, bool onlyIfNeeded = false);
+          
+          // Mouse / keyboard information
+          wxWindow * wxGetActiveWindow();
+          
+          // Dialog shortcuts
+          VOID_INT wxGetSelectedChoices(wxArrayInt& selections,
+                        const wxString& message,
+                        const wxString& caption,
+                        int n, const wxString *choices,
+                        wxWindow *parent = NULL,
+                        int x = wxDefaultCoord,
+                        int y = wxDefaultCoord,
+                        bool centre = true,
+                        int width = wxCHOICE_WIDTH,
+                        int height = wxCHOICE_HEIGHT);
+          
+          
+          wxString wxFileSelector (const wxString &message,
+                                   const wxString &default_path=wxEmptyString,
+                                   const wxString &default_filename=wxEmptyString,
+                                   const wxString &default_extension=wxEmptyString,
+                                   const wxString &wildcard=wxFileSelectorDefaultWildcardStr,
+                                   int flags=0, wxWindow *parent=NULL, int x=wxDefaultCoord, int y=wxDefaultCoord);
+          
+          wxString wxFileSelectorEx (const wxString &message=wxFileSelectorPromptStr,
+                                     const wxString &default_path=wxEmptyString,
+                                     const wxString &default_filename=wxEmptyString,
+                                     int *indexDefaultExtension=NULL,
+                                     const wxString &wildcard=wxFileSelectorDefaultWildcardStr,
+                                     int flags=0, wxWindow *parent=NULL, int x=wxDefaultCoord, int y=wxDefaultCoord);
+          
+          wxString wxLoadFileSelector (const wxString &what,
+                                       const wxString &extension,
+                                       const wxString &default_name=wxEmptyString,
+                                       wxWindow *parent=NULL);
+          
+          wxString wxSaveFileSelector (const wxString &what,
+                                       const wxString &extension,
+                                       const wxString &default_name=wxEmptyString,
+                                       wxWindow *parent=NULL);
+          
+          // Managing stock ids
+          enum  	wxStockLabelQueryFlag {
+            wxSTOCK_NOFLAGS = 0 ,
+            wxSTOCK_WITH_MNEMONIC = 1 ,
+            wxSTOCK_WITH_ACCELERATOR = 2 ,
+            wxSTOCK_WITHOUT_ELLIPSIS = 4 ,
+            wxSTOCK_FOR_BUTTON = wxSTOCK_WITHOUT_ELLIPSIS | wxSTOCK_WITH_MNEMONIC
+          };
+
+          bool wxIsStockID(wxWindowID id);
+          bool wxIsStockLabel(wxWindowID id, const wxString& label);
+          wxString wxGetStockLabel(wxWindowID id,
+                                   long flags = wxSTOCK_WITH_MNEMONIC);
+          wxAcceleratorEntry wxGetStockAccelerator(wxWindowID id);
+
+          enum wxStockHelpStringClient
+          {
+              wxSTOCK_MENU
+          };
+
+          wxString wxGetStockHelpString(wxWindowID id,
+                                        wxStockHelpStringClient client = wxSTOCK_MENU);
+          __HEREDOC
+        spec.add_init_code <<~__HEREDOC
+          rb_define_module_function(mWxFunctions, "log_generic", VALUEFUNC(log_generic), -1);
+          rb_define_module_function(mWxFunctions, "log_info", VALUEFUNC(log_info), -1);
+          rb_define_module_function(mWxFunctions, "log_verbose", VALUEFUNC(log_verbose), -1);
+          rb_define_module_function(mWxFunctions, "log_message", VALUEFUNC(log_message), -1);
+          rb_define_module_function(mWxFunctions, "log_warning", VALUEFUNC(log_warning), -1);
+          rb_define_module_function(mWxFunctions, "log_status", VALUEFUNC(log_status), -1);
+          rb_define_module_function(mWxFunctions, "log_error", VALUEFUNC(log_error), -1);
+          rb_define_module_function(mWxFunctions, "log_debug", VALUEFUNC(log_debug), -1);
+          rb_define_module_function(mWxFunctions, "get_app", VALUEFUNC(get_app), 0);
+          rb_define_module_function(mWxFunctions, "xrcid", VALUEFUNC(xrcid), 1);
+          rb_define_module_function(mWxFunctions, "ptr_addr", VALUEFUNC(cpp_ptr_addr), 1);
+          __HEREDOC
+      end
+    end # class Functions
+
+  end # class Director
+
+end # module WXRuby3

data/rakelib/lib/director/gdi_object.rb

@@ -0,0 +1,21 @@
+###
+# wxRuby3 wxWidgets interface director
+# Copyright (c) M.J.N. Corino, The Netherlands
+###
+
+module WXRuby3
+
+  class Director
+
+    class GDIObject < Director
+
+      def setup
+        spec.make_abstract('wxGDIObject')
+        spec.no_proxy('wxGDIObject')
+        super
+      end
+    end # class GDIObject
+
+  end # class Director
+
+end # module WXRuby3

data/rakelib/lib/director/gdicommon.rb

@@ -0,0 +1,94 @@
+###
+# wxRuby3 wxWidgets interface director
+# Copyright (c) M.J.N. Corino, The Netherlands
+###
+
+module WXRuby3
+
+  class Director
+
+    class GDICommon < Director
+
+      def setup
+        spec.items.replace %w{wxPoint wxSize wxRect wxRealPoint wxColourDatabase}
+        # all ctors
+        spec.require_app 'wxColourDatabase'
+        # global functions
+        spec.require_app %w[wxColourDisplay wxDisplayDepth wxSetCursor wxGetClientDisplayRect
+                            wxGetDisplayPPI wxGetDisplaySize wxGetDisplaySizeMM]
+        spec.ignore %w{
+          wxTheColourDatabase
+        }
+        spec.ignore [
+          'wxClientDisplayRect(int *,int *,int *,int *)',
+          'wxDisplaySize(int *,int *)',
+          'wxDisplaySizeMM(int *,int *)',
+          'wxRect::Inflate(wxCoord,wxCoord)',
+          'wxRect::Inflate(wxCoord,wxCoord) const',
+          'wxRect::Deflate(wxCoord,wxCoord)',
+          'wxRect::Deflate(wxCoord,wxCoord) const',
+          'wxRect::Offset(wxCoord,wxCoord)',
+          'wxRect::Intersect(const wxRect &)',
+          'wxRect::Union(const wxRect &)'
+        ]
+        # overrule common wxPoint mapping for wxRect ctor to fix ctor ambiguities here wrt wxSize
+        spec.map 'const wxPoint& topLeft', 'const wxPoint& bottomRight', as: 'Wx::Point' do
+          map_in code: <<~__CODE
+            if ( TYPE($input) == T_DATA )
+            {
+              void* argp$argnum;
+              SWIG_ConvertPtr($input, &argp$argnum, $1_descriptor, 1 );
+              $1 = reinterpret_cast< $1_basetype * >(argp$argnum);
+            }
+            else
+            {
+              rb_raise(rb_eTypeError, "Wrong type for $1_basetype parameter");
+            }
+          __CODE
+          map_typecheck precedence: 'POINTER', code: <<~__CODE
+            void *vptr = 0;
+            $1 = 0;
+            if (TYPE($input) == T_DATA && SWIG_CheckState (SWIG_ConvertPtr ($input, &vptr, $1_descriptor, 0)))
+              $1 = 1;
+          __CODE
+        end
+        spec.map 'wxRect&' => 'Wx::Rect', 'wxSize&' => 'Wx::Size' do
+          map_out code: '$result = self; wxUnusedVar(result);'
+        end
+        spec.regard %w[
+          wxPoint::x wxPoint::y
+          wxRealPoint::x wxRealPoint::y
+          ]
+        spec.set_only_for '__WXGTK__', 'wxStockCursor.wxCURSOR_DEFAULT'
+        spec.set_only_for '__X__', %w{
+          wxStockCursor.wxCURSOR_CROSS_REVERSE
+          wxStockCursor.wxCURSOR_DOUBLE_ARROW
+          wxStockCursor.wxCURSOR_BASED_ARROW_UP
+          wxStockCursor.wxCURSOR_BASED_ARROW_DOWN
+        }
+        spec.set_only_for '__WXMAC__', 'wxStockCursor.wxCURSOR_COPY_ARROW'
+        spec.add_extend_code 'wxRect', <<~__HEREDOC
+          wxRect add(const wxRect &rect) const {
+            return (*(const wxRect*)$self) + rect;
+          }
+          wxRect mul(const wxRect &rect) const {
+            return (*(const wxRect*)$self) * rect;
+          }
+        __HEREDOC
+        spec.swig_import 'swig/classes/include/wxDefs.h'
+        super
+      end
+
+      def process(gendoc: false)
+        defmod = super
+        e = defmod.find('wxBitmapType')
+        e.items.each do |item|
+          item.ignore if item.name.end_with?('_RESOURCE')
+        end
+        defmod
+      end
+    end # class GDICommon
+
+  end # class Director
+
+end # module WXRuby3

data/rakelib/lib/director/generic_dirctrl.rb

@@ -0,0 +1,24 @@
+###
+# wxRuby3 wxWidgets interface director
+# Copyright (c) M.J.N. Corino, The Netherlands
+###
+
+module WXRuby3
+
+  class Director
+
+    class GenericDirCtrl < Window
+
+      include Typemap::TreeItemId
+
+      def setup
+        super
+        spec.no_proxy 'wxGenericDirCtrl'
+        spec.do_not_generate(:variables, :defines, :enums, :functions) # already with DirFilterListCtrl
+      end
+
+    end # class GenericDirCtrl
+
+  end # class Director
+
+end # module WXRuby3

data/rakelib/lib/director/graphics_context.rb

@@ -0,0 +1,143 @@
+###
+# wxRuby3 wxWidgets interface director
+# Copyright (c) M.J.N. Corino, The Netherlands
+###
+
+module WXRuby3
+
+  class Director
+
+    class GraphicsContext < Director
+
+      def setup
+        super
+        spec.disable_proxies
+        # these static creators require a running app
+        spec.require_app 'wxGraphicsContext::Create',
+                         'wxGraphicsContext::CreateFromUnknownDC'
+        spec.ignore 'wxGraphicsContext::CreateFromNative',
+                    'wxGraphicsContext::CreateFromNativeWindow',
+                    'wxGraphicsContext::CreateFromNativeHDC',
+                    'wxGraphicsContext::GetNativeContext',
+                    'wxGraphicsContext::Create(const wxEnhMetaFileDC &)'
+        # type mappings
+        # Typemap to fix GraphicsContext#get_text_extent
+        spec.map_apply 'double *OUTPUT' => [ 'wxDouble* width', 'wxDouble* height',
+                                             'wxDouble* descent', 'wxDouble* externalLeading' ]
+        spec.map 'wxDouble* width, wxDouble* height, wxDouble* descent, wxDouble* externalLeading' do
+          map_directorargout code: <<~__CODE
+            if ( (TYPE(result) == T_ARRAY) && (RARRAY_LEN(result) >= 2) )
+            {
+              *$1 = ($*1_ltype)NUM2INT(rb_ary_entry(result,0));
+              *$2 = ($*2_ltype)NUM2INT(rb_ary_entry(result,1));
+              if ( ($3 != NULL ) && RARRAY_LEN(result) >= 3)
+                *$3 = ($*3_ltype)NUM2INT(rb_ary_entry(result,2));
+              if ( ( $4 != NULL ) && RARRAY_LEN(result) >= 4 )
+                *$4 = ($*4_ltype)NUM2INT(rb_ary_entry(result,3));
+            }
+            __CODE
+        end
+        spec.map 'size_t, const wxPoint2DDouble *' => 'Array<Array<Float,Float>>' do
+          map_in from: {type: 'Array<Array<Float,Float>>', index: 1},
+                 temp: 'std::unique_ptr<wxPoint2DDouble[]> tmp_pts',
+                 code: <<~__CODE
+            bool ok = false;
+            if (TYPE($input) == T_ARRAY)
+            {
+              ok = true;
+              tmp_pts = std::make_unique<wxPoint2DDouble[]>(RARRAY_LEN($input));
+              for (int i=0; i<RARRAY_LEN($input) ;++i)
+              {
+                VALUE el = rb_ary_entry($input, i);
+                if (TYPE(el) == T_ARRAY && RARRAY_LEN(el) == 2)
+                {
+                  tmp_pts[i] = wxPoint2DDouble(NUM2DBL(rb_ary_entry(el, 0)), NUM2DBL(rb_ary_entry(el, 1)));
+                }
+                else
+                { ok = false; }
+              }
+              if (ok)
+              {
+                $1 = RARRAY_LEN($input);
+                $2 = tmp_pts.get();
+              }
+            }
+            if (!ok)
+            {
+              rb_raise(rb_eArgError, "Invalid value for %i", $argnum-1);
+            }
+          __CODE
+          map_default code: '$1 = 0; $2 = NULL;'
+          map_typecheck precedence: 5, code: <<~__CODE
+            $1 = false; 
+            if (TYPE($input) == T_ARRAY && RARRAY_LEN($input)>0)
+            {
+              VALUE el = rb_ary_entry($input, 0);
+              if (TYPE(el) == T_ARRAY && RARRAY_LEN(el) == 2)
+              {
+                VALUE pt = rb_ary_entry(el, 0);
+                $1 = TYPE(pt) != T_ARRAY;
+              }
+            }
+          __CODE
+        end
+        spec.map 'size_t, const wxPoint2DDouble *, const wxPoint2DDouble *' do
+          map_in from: {type: 'Array<Array<Array<Float,Float>,Array<Float,Float>>>', index: 0},
+                 temp: ['std::unique_ptr<wxPoint2DDouble[]> tmp_begin', 'std::unique_ptr<wxPoint2DDouble[]> tmp_end'],
+                 code: <<~__CODE
+            bool ok = false;
+            if (TYPE($input) == T_ARRAY)
+            {
+              ok = true;
+              tmp_begin = std::make_unique<wxPoint2DDouble[]>(RARRAY_LEN($input));
+              tmp_end = std::make_unique<wxPoint2DDouble[]>(RARRAY_LEN($input));
+              for (int i=0; i<RARRAY_LEN($input) ;++i)
+              {
+                VALUE el = rb_ary_entry($input, i);
+                if (TYPE(el) == T_ARRAY && RARRAY_LEN(el) == 2)
+                {
+                  VALUE begin_pt = rb_ary_entry(el, 0);
+                  VALUE end_pt = rb_ary_entry(el, 1);
+                  if (TYPE(begin_pt) == T_ARRAY && RARRAY_LEN(begin_pt) == 2 && TYPE(end_pt) == T_ARRAY && RARRAY_LEN(end_pt) == 2)
+                  {
+                    tmp_begin[i] = wxPoint2DDouble(NUM2DBL(rb_ary_entry(begin_pt, 0)), NUM2DBL(rb_ary_entry(begin_pt, 1)));
+                    tmp_end[i] = wxPoint2DDouble(NUM2DBL(rb_ary_entry(end_pt, 0)), NUM2DBL(rb_ary_entry(end_pt, 1)));
+                  }
+                  else
+                  { ok = false; }
+                }
+                else
+                { ok = false; }
+              }
+              if (ok)
+              {
+                $1 = RARRAY_LEN($input);
+                $2 = tmp_begin.get();
+                $3 = tmp_end.get();
+              }
+            }
+            if (!ok)
+            {
+              rb_raise(rb_eArgError, "Invalid value for %i", $argnum-1);
+            }
+            __CODE
+          map_default code: '$1 = 0; $2 = NULL; $3 = NULL;'
+          map_typecheck precedence: 10, code: <<~__CODE
+            $1 = false; 
+            if (TYPE($input) == T_ARRAY && RARRAY_LEN($input)>0)
+            {
+              VALUE el = rb_ary_entry($input, 0);
+              if (TYPE(el) == T_ARRAY && RARRAY_LEN(el) == 2)
+              {
+                VALUE pt = rb_ary_entry(el, 0);
+                $1 = TYPE(pt) == T_ARRAY;
+              }
+            }
+            __CODE
+        end
+      end
+    end # class GraphicsContext
+
+  end # class Director
+
+end # module WXRuby3

data/rakelib/lib/director/graphics_object.rb

@@ -0,0 +1,69 @@
+###
+# wxRuby3 wxWidgets interface director
+# Copyright (c) M.J.N. Corino, The Netherlands
+###
+
+module WXRuby3
+
+  class Director
+
+    class GraphicsObject < Director
+
+      def setup
+        super
+        spec.items.concat %w[wxGraphicsPen wxGraphicsBrush wxGraphicsPath wxGraphicsFont wxGraphicsMatrix wxGraphicsBitmap]
+        spec.disable_proxies
+        spec.ignore 'wxGraphicsObject::GetRenderer'
+        spec.ignore 'wxGraphicsMatrix::Concat(const wxGraphicsMatrix &)'
+        spec.ignore 'wxGraphicsMatrix::IsEqual(const wxGraphicsMatrix &)'
+        spec.ignore 'wxGraphicsMatrix::GetNativeMatrix'
+        spec.ignore 'wxGraphicsBitmap::GetNativeBitmap'
+        spec.ignore 'wxGraphicsPath::GetNativePath', 'wxGraphicsPath::UnGetNativePath'
+        # Deal with GraphicsMatrix#get method
+        spec.map_apply 'double *OUTPUT' => [ 'wxDouble *a', 'wxDouble *b',
+                                             'wxDouble *c', 'wxDouble *d',
+                                             'wxDouble *tx' , 'wxDouble *ty' ]
+        # type mapping for GraphicsPath wxPoint2DDouble args
+        spec.map 'const wxPoint2DDouble&' => 'Array<Float,Float>' do
+          map_in temp: 'wxPoint2DDouble tmp_pt', code: <<~__CODE
+            if (TYPE($input) == T_ARRAY && RARRAY_LEN($input) == 2)
+            {
+              tmp_pt = wxPoint2DDouble(NUM2DBL(rb_ary_entry($input, 0)),
+                                       NUM2DBL(rb_ary_entry($input, 1)));
+              $1 = &tmp_pt;
+            }
+            else
+            {
+              rb_raise(rb_eTypeError, "Wrong type for %i", $argnum-1);
+            }
+            __CODE
+        end
+        spec.ignore 'wxGraphicsPath::GetBox() const',
+                    'wxGraphicsPath::GetCurrentPoint() const'
+        if Config.platform == :mingw
+          # it seems for WXMSW there is a problem cleaning up GraphicsObjects in GC after
+          # the wxApp has ended (probably because some other wxWidgets cleanup already
+          # forcibly deleted their resources)
+          spec.add_header_code <<~__HEREDOC
+            // special free func is needed to clean up only as long the app still runs
+            // the rest we leave for the system clean up as the process terminates
+            void GC_free_GraphicsObject(wxGraphicsObject *go) 
+            {
+              SWIG_RubyRemoveTracking(go);
+              if ( wxRuby_IsAppRunning() )
+                delete go;
+            }
+          __HEREDOC
+          spec.add_swig_code '%feature("freefunc") wxGraphicsPen "GC_free_GraphicsObject";'
+          spec.add_swig_code '%feature("freefunc") wxGraphicsBrush "GC_free_GraphicsObject";'
+          spec.add_swig_code '%feature("freefunc") wxGraphicsPath "GC_free_GraphicsObject";'
+          spec.add_swig_code '%feature("freefunc") wxGraphicsFont "GC_free_GraphicsObject";'
+          spec.add_swig_code '%feature("freefunc") wxGraphicsMatrix "GC_free_GraphicsObject";'
+          spec.add_swig_code '%feature("freefunc") wxGraphicsBitmap "GC_free_GraphicsObject";'
+        end
+      end
+    end # class GraphicsObject
+
+  end # class Director
+
+end # module WXRuby3