wxruby3 0.9.0.pre.beta.8

data/rakelib/lib/director/grid_cell_attr.rb

@@ -0,0 +1,53 @@
+###
+# wxRuby3 wxWidgets interface director
+# Copyright (c) M.J.N. Corino, The Netherlands
+###
+
+module WXRuby3
+
+  class Director
+
+    class GridCellAttr < Director
+
+      include Typemap::GridClientData
+
+      def setup
+        super
+        # exposing the mixin wxClientDataContainer/wxSharedClientDataContainer has no real upside
+        # for wxRuby; far easier to just use member variables in derived classes
+        spec.override_inheritance_chain('wxGridCellAttr', [])
+        spec.gc_as_untracked_refcounted('wxGridCellAttr')
+        spec.ignore %w[wxGridCellAttr::IncRef wxGridCellAttr::DecRef]
+        spec.ignore('wxGridCellAttr::GetEditorPtr',
+                    'wxGridCellAttr::GetRendererPtr')
+        # these require wxRuby to take ownership (ref counted)
+        spec.new_object('wxGridCellAttr::Clone',
+                        'wxGridCellAttr::GetEditor',
+                        'wxGridCellAttr::GetRenderer')
+        # type mapping for wxGridCellEditor* return ref
+        spec.map 'wxGridCellEditor*' => 'Wx::GRID::GridCellEditor' do
+          add_header_code 'extern VALUE wxRuby_WrapWxGridCellEditorInRuby(const wxGridCellEditor *wx_gce);',
+                          'extern void wxRuby_RegisterGridCellEditor(wxGridCellEditor* wx_edt, VALUE rb_edt);'
+          map_out code: '$result = wxRuby_WrapWxGridCellEditorInRuby($1);'
+          map_check code: 'wxRuby_RegisterGridCellEditor($1, argv[$argnum-2]);'
+        end
+        # type mapping for wxGridCellRenderer* return ref
+        spec.map 'wxGridCellRenderer*' => 'Wx::GRID::GridCellRenderer' do
+          add_header_code 'extern VALUE wxRuby_WrapWxGridCellRendererInRuby(const wxGridCellRenderer *wx_gcr);',
+                          'extern void wxRuby_RegisterGridCellRenderer(wxGridCellRenderer* wx_rnd, VALUE rb_rnd);'
+          map_out code: '$result = wxRuby_WrapWxGridCellRendererInRuby($1);'
+          map_check code: 'wxRuby_RegisterGridCellRenderer($1, argv[$argnum-2]);'
+        end
+        # argout type mappings
+        spec.map_apply 'int* OUTPUT' => ['int *hAlign', 'int *vAlign', 'int *num_rows', 'int *num_cols']
+        # for docs only
+        spec.map ['int *hAlign', 'int *vAlign', 'int *num_rows', 'int *num_cols'] => 'Integer', swig: false do
+          map_in ignore: true
+          map_argout
+        end
+      end
+    end # class GridCellAttr
+
+  end # class Director
+
+end # module WXRuby3

data/rakelib/lib/director/grid_cell_editor.rb

@@ -0,0 +1,434 @@
+###
+# wxRuby3 wxWidgets interface director
+# Copyright (c) M.J.N. Corino, The Netherlands
+###
+
+module WXRuby3
+
+  class Director
+
+    class GridCellEditor < Director
+
+      include Typemap::GridClientData
+
+      def setup
+        super
+        spec.gc_as_untracked_refcounted
+        if spec.module_name == 'wxGridCellEditor'
+          spec.post_processors << :fix_gridcelleditor
+          # exposing the mixin wxClientDataContainer/wxSharedClientDataContainer has no real upside
+          # for wxRuby; far easier to just use member variables in derived classes
+          spec.override_inheritance_chain('wxGridCellEditor', [])
+          spec.regard('wxGridCellEditor::~wxGridCellEditor')
+          # add method for correctly wrapping PGEditor output references
+          spec.add_header_code <<~__CODE
+            extern VALUE mWxGRID; // declare external module reference
+            extern VALUE wxRuby_GridCellEditorInstance(wxGridCellEditor* wx_edt);
+            extern void wxRuby_RegisterGridCellEditor(wxGridCellEditor* wx_edt, VALUE rb_edt);
+            extern VALUE wxRuby_WrapWxGridCellEditorInRuby(const wxGridCellEditor *wx_gce)
+            {
+              // If no object was passed to be wrapped.
+              if ( ! wx_gce )
+                return Qnil;
+
+              // check for registered instance
+              VALUE rb_gce = wxRuby_GridCellEditorInstance(const_cast<wxGridCellEditor*> (wx_gce));
+              if (rb_gce && !NIL_P(rb_gce))
+              {
+                return rb_gce;
+              }
+
+              const void *ptr = 0;
+              wxString class_name;
+              if ((ptr = dynamic_cast<const wxGridCellActivatableEditor*> (wx_gce)))
+              {
+                class_name = "GridCellActivatableEditor";
+              }
+              else if ((ptr = dynamic_cast<const wxGridCellBoolEditor*> (wx_gce)))
+              {
+                class_name = "GridCellBoolEditor";
+              }
+              else if ((ptr = dynamic_cast<const wxGridCellEnumEditor*> (wx_gce)))
+              {
+                class_name = "GridCellEnumEditor";
+              }
+              else if ((ptr = dynamic_cast<const wxGridCellChoiceEditor*> (wx_gce)))
+              {
+                class_name = "GridCellChoiceEditor";
+              }
+              else if ((ptr = dynamic_cast<const wxGridCellDateEditor*> (wx_gce)))
+              {
+                class_name = "GridCellDateEditor";
+              }
+              else if ((ptr = dynamic_cast<const wxGridCellFloatEditor*> (wx_gce)))
+              {
+                class_name = "GridCellFloatEditor";
+              }
+              else if ((ptr = dynamic_cast<const wxGridCellNumberEditor*> (wx_gce)))
+              {
+                class_name = "GridCellNumberEditor";
+              }
+              else if ((ptr = dynamic_cast<const wxGridCellAutoWrapStringEditor*> (wx_gce)))
+              {
+                class_name = "GridCellAutoWrapStringEditor";
+              }
+              else if ((ptr = dynamic_cast<const wxGridCellTextEditor*> (wx_gce)))
+              {
+                class_name = "GridCellTextEditor";
+              }
+              VALUE r_class = Qnil;
+              if ( ptr && class_name.Len() > 0 )
+              {
+                wxCharBuffer wx_classname = class_name.mb_str();
+                VALUE r_class_name = rb_intern(wx_classname.data ()); // wxRuby class name (minus 'wx')
+                if (rb_const_defined(mWxGRID, r_class_name))
+                  r_class = rb_const_get(mWxGRID, r_class_name);
+              }
+
+              // If we cannot find the class output a warning and return nil
+              if ( r_class == Qnil )
+              {
+                rb_warn("Error wrapping object; class `%s' is not (yet) supported in wxRuby",
+                        (const char *)class_name.mb_str() );
+                return Qnil;
+              }
+
+              // Otherwise, retrieve the swig type info for this class and wrap it
+              // in Ruby. Make it owned to manage the ref count if GC claims the object. 
+              // wxRuby_GetSwigTypeForClass is defined in wx.i
+              swig_type_info* swig_type = wxRuby_GetSwigTypeForClass(r_class);
+              rb_gce = SWIG_NewPointerObj(const_cast<void*> (ptr), swig_type, 0);
+              wxRuby_RegisterGridCellEditor(const_cast<wxGridCellEditor*> (wx_gce), rb_gce);
+              return rb_gce;
+            }
+          __CODE
+        elsif spec.module_name == 'wxGridCellActivatableEditor'
+          spec.post_processors << :fix_gridcelleditor
+          spec.override_inheritance_chain('wxGridCellActivatableEditor', %w[wxGridCellEditor])
+          spec.no_proxy %w[
+            wxGridCellActivatableEditor::BeginEdit
+            wxGridCellActivatableEditor::Create
+            wxGridCellActivatableEditor::Destroy
+            wxGridCellActivatableEditor::EndEdit
+            wxGridCellActivatableEditor::ApplyEdit
+            wxGridCellActivatableEditor::HandleReturn
+            wxGridCellActivatableEditor::PaintBackground
+            wxGridCellActivatableEditor::Reset
+            wxGridCellActivatableEditor::SetSize
+            wxGridCellActivatableEditor::Show
+            wxGridCellActivatableEditor::StartingClick
+            wxGridCellActivatableEditor::StartingKey
+            wxGridCellActivatableEditor::IsAcceptedKey
+            wxGridCellActivatableEditor::GetValue
+            ]
+        else
+          spec.post_processors << :fix_gridcelleditor
+          case spec.module_name
+          when 'wxGridCellEnumEditor'
+            spec.override_inheritance_chain(spec.module_name, %w[wxGridCellChoiceEditor wxGridCellEditor])
+          when 'wxGridCellAutoWrapStringEditor', 'wxGridCellFloatEditor', 'wxGridCellNumberEditor'
+            spec.override_inheritance_chain(spec.module_name, %w[wxGridCellTextEditor wxGridCellEditor])
+          else
+            spec.override_inheritance_chain(spec.module_name, %w[wxGridCellEditor])
+          end
+          # due to the flawed wxWidgets XML docs we need to explicitly add these here
+          # otherwise the derived editors won't be allocable due to pure virtuals
+          spec.extend_interface spec.module_name,
+            'void BeginEdit(int row, int col, wxGrid *grid)',
+            'wxGridCellEditor * Clone() const',
+            'void Create(wxWindow *parent, wxWindowID id, wxEvtHandler *evtHandler)',
+            'bool EndEdit(int row, int col, const wxGrid *grid, const wxString &oldval, wxString *newval)',
+            'void ApplyEdit(int row, int col, wxGrid *grid)',
+            'void Reset()',
+            'wxString GetValue() const'
+        end
+        unless spec.module_name == 'wxGridCellEditor'
+          # type mapping for Clone return ref
+          spec.map 'wxGridCellEditor*' => 'Wx::GRID::GridCellEditor' do
+            add_header_code 'extern VALUE wxRuby_WrapWxGridCellEditorInRuby(const wxGridCellEditor *wx_gce);'
+            map_out code: '$result = wxRuby_WrapWxGridCellEditorInRuby($1);'
+          end
+        end
+        # handled; can be suppressed
+        spec.suppress_warning(473, "#{spec.module_name}::Clone")
+      end
+
+      # helper methods for custom wrapper to handle wxGridActivationResult and wxGridActivationSource
+      # in wxGridCellEditor::TryActivate as SWIG cannot handle the, admittedly seriously flawed,
+      # wxWidgets interface
+      WRAPPER_HELPERS = <<~__HEREDOC
+            static WxRuby_ID ga_ignore_id("ignore");
+            static WxRuby_ID ga_show_editor_id("show_editor");
+            static WxRuby_ID ga_change_id("change");
+            static WxRuby_ID ga_program_id("program");
+            static WxRuby_ID ga_key_id("key");
+            static WxRuby_ID ga_mouse_id("mouse");
+
+            inline wxGridActivationResult
+            array_to_wxGridActivationResult(VALUE rbarr)
+            {
+              if (rbarr == Qnil || 
+                !(TYPE(rbarr) == T_ARRAY || TYPE(rbarr) == T_SYMBOL))
+              {
+                Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(SWIG_ERROR)), 
+                                                           "in output value of type 'wxGridActivationResult'");
+              }
+              if (TYPE(rbarr) == T_SYMBOL)
+              {
+                if (SYM2ID(rbarr) == ga_ignore_id())
+                  return wxGridActivationResult::DoNothing();
+                else if (SYM2ID(rbarr) == ga_show_editor_id())
+                  return wxGridActivationResult::DoEdit();
+                else
+                  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(SWIG_ERROR)), 
+                                                             "in output value of type 'wxGridActivationResult'");
+              }
+              else
+              {
+                VALUE rbAction = rb_ary_shift(rbarr);
+                VALUE rbStr = rb_ary_shift(rbarr); // could be nil
+                if (rbAction == Qnil || TYPE(rbAction) != T_SYMBOL)
+                {
+                  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(SWIG_ERROR)), 
+                                                             "in output value of type 'wxGridActivationResult'");
+                }
+                else if (SYM2ID(rbAction) == ga_change_id() && rbStr != Qnil)
+                {
+                  return wxGridActivationResult::DoChange(RSTR_TO_WXSTR(rbStr));
+                }
+                else
+                {
+                  if (SYM2ID(rbAction) == ga_ignore_id())
+                    return wxGridActivationResult::DoNothing();
+                  else if (SYM2ID(rbAction) == ga_show_editor_id())
+                    return wxGridActivationResult::DoEdit();
+                  else
+                    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(SWIG_ERROR)), 
+                                                               "in output value of type 'wxGridActivationResult'");
+                }
+              }
+              // silence compiler; should never be reached
+              return wxGridActivationResult::DoNothing();
+            }
+
+            inline VALUE 
+            wxGridActivationResult_to_array(const wxGridActivationResult& result)
+            {
+              VALUE rbresult = rb_ary_new();
+              wxGridActivationResult::Action act = result.GetAction ();
+              switch (act) {
+              case wxGridActivationResult::Ignore:
+                rb_ary_push(rbresult, ga_ignore_id.get_sym());
+                break;
+              case wxGridActivationResult::Change:
+                rb_ary_push(rbresult, ga_change_id.get_sym());
+                rb_ary_push(rbresult, WXSTR_TO_RSTR(result.GetNewValue()));
+                break;
+              case wxGridActivationResult::ShowEditor:
+                rb_ary_push(rbresult, ga_show_editor_id.get_sym());
+                break;
+              }
+              return rbresult;
+            }
+  
+            inline wxGridActivationSource 
+            array_to_wxGridActivationSource(VALUE rbarr, int argnum)
+            {
+              if (rbarr == Qnil || 
+                !(TYPE(rbarr) == T_ARRAY || TYPE(rbarr) == T_SYMBOL))
+              {
+                rb_raise(rb_eArgError, 
+                  "Expected Symbol or Array of Symbol and optional event for %d.", argnum);
+              }
+              if (TYPE(rbarr) == T_SYMBOL)
+              {
+                if (SYM2ID(rbarr) != ga_program_id())
+                  rb_raise(rb_eArgError, 
+                    ":key or :mouse activation sources need an event for %d.", argnum);
+                else
+                  return wxGridActivationSource::FromProgram();
+              }
+              else
+              {
+                VALUE rbOrg = rb_ary_shift(rbarr);
+                VALUE rbEvt = rb_ary_shift(rbarr); // could be nil
+                if (rbOrg == Qnil || TYPE(rbOrg) != T_SYMBOL)
+                {
+                  rb_raise(rb_eArgError, 
+                    "expected Symbol or Array of Symbol and optional event for %d.", argnum);
+                }
+                else if (SYM2ID(rbOrg) == ga_program_id())
+                {
+                  return wxGridActivationSource::FromProgram();
+                }
+                else if (rbEvt != Qnil)
+                {
+                  const wxEvent* evt = (const wxEvent*)DATA_PTR(rbEvt);
+                  if (SYM2ID(rbOrg) == ga_key_id())
+                    return wxGridActivationSource::From(*(const wxKeyEvent*)evt);
+                  else if (SYM2ID(rbOrg) == ga_mouse_id())
+                    return wxGridActivationSource::From(*(const wxMouseEvent*)evt);
+                  rb_raise(rb_eArgError, 
+                    "unknown activation source for %d.", argnum);
+                }
+                else
+                {
+                  rb_raise(rb_eArgError, 
+                    ":key or :mouse activation sources need an event for %d.", argnum);
+                }
+              }
+            }
+
+            inline VALUE 
+            wxGridActivationSource_to_array(const wxGridActivationSource& arg)
+            {
+              VALUE rbresult = rb_ary_new();
+              wxGridActivationSource::Origin org = arg.GetOrigin ();
+              switch (org) {
+              case wxGridActivationSource::Program:
+                rb_ary_push(rbresult, ga_program_id.get_sym());
+                break;
+              case wxGridActivationSource::Key:
+                rb_ary_push(rbresult, ga_key_id.get_sym());
+            #ifdef __WXRB_DEBUG__
+                rb_ary_push(rbresult, wxRuby_WrapWxEventInRuby(0, const_cast<wxKeyEvent*> (&arg.GetKeyEvent())));
+            #else 
+                rb_ary_push(rbresult, wxRuby_WrapWxEventInRuby(const_cast<wxKeyEvent*> (&arg.GetKeyEvent())));
+            #endif 
+                break;
+              case wxGridActivationSource::Mouse:
+                rb_ary_push(rbresult, ga_mouse_id.get_sym());
+            #ifdef __WXRB_DEBUG__
+                rb_ary_push(rbresult, wxRuby_WrapWxEventInRuby(0, const_cast<wxMouseEvent*> (&arg.GetMouseEvent()))); 
+            #else 
+                rb_ary_push(rbresult, wxRuby_WrapWxEventInRuby(const_cast<wxMouseEvent*> (&arg.GetMouseEvent()))); 
+            #endif 
+                break;
+              }
+              return rbresult;
+            }
+
+      __HEREDOC
+
+
+    end # class GridCellEditor
+
+  end # class Director
+
+  module SwigRunner
+    class Processor
+
+      # special post-processor for GridCellEditor
+      class FixGridcelleditor < Processor
+
+        def run
+          skip_lines = false
+          helpers_added = false
+
+          update_source do |line|
+            if skip_lines
+              if /\A}\s*\Z/ =~ line
+                skip_lines = false
+              else
+                line = nil
+              end
+            elsif line["wxGridActivationResult SwigDirector_#{module_name}::TryActivate("]
+              skip_lines = true
+              # append new method implementation
+              line << <<~__METHOD__
+                static WxRuby_ID try_activate_id("try_activate");
+
+                VALUE obj0 = Qnil ;
+                VALUE obj1 = Qnil ;
+                VALUE obj2 = Qnil ;
+                VALUE obj3 = Qnil ;
+                VALUE SWIGUNUSED result;
+                
+                obj0 = SWIG_From_int(static_cast< int >(row));
+                obj1 = SWIG_From_int(static_cast< int >(col));
+                obj2 = SWIG_NewPointerObj(SWIG_as_voidptr(grid), SWIGTYPE_p_wxGrid,  0 );
+                obj3 = wxGridActivationSource_to_array(actSource); 
+                result = rb_funcall(swig_get_self(), try_activate_id(), 4,obj0,obj1,obj2,obj3);
+                return array_to_wxGridActivationResult(result);
+                __METHOD__
+            elsif !helpers_added && line["SwigDirector_#{module_name}::SwigDirector_#{module_name}(VALUE self"]
+              # insert helper methods
+              line = [Director::GridCellEditor::WRAPPER_HELPERS, line]
+              helpers_added = true
+            elsif line["_wrap_#{module_name}_TryActivate(int argc, VALUE *argv, VALUE self) {"]
+              skip_lines = true
+              # append new method implementation
+              line << <<~__METHOD__
+                  #{module_name} *arg1 = (#{module_name} *) 0 ;
+                  int arg2 ;
+                  int arg3 ;
+                  wxGrid *arg4 = (wxGrid *) 0 ;
+                  void *argp1 = 0 ;
+                  int res1 = 0 ;
+                  int val2 ;
+                  int ecode2 = 0 ;
+                  int val3 ;
+                  int ecode3 = 0 ;
+                  void *argp4 = 0 ;
+                  int res4 = 0 ;
+                  Swig::Director *director = 0;
+                  bool upcall = false;
+                  VALUE vresult = Qnil;
+                  
+                  if ((argc < 4) || (argc > 4)) {
+                    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+                  }
+                  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_#{module_name}, 0 |  0 );
+                  if (!SWIG_IsOK(res1)) {
+                    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "#{module_name} *","TryActivate", 1, self )); 
+                  }
+                  arg1 = reinterpret_cast< #{module_name} * >(argp1);
+                  ecode2 = SWIG_AsVal_int(argv[0], &val2);
+                  if (!SWIG_IsOK(ecode2)) {
+                    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","TryActivate", 2, argv[0] ));
+                  } 
+                  arg2 = static_cast< int >(val2);
+                  ecode3 = SWIG_AsVal_int(argv[1], &val3);
+                  if (!SWIG_IsOK(ecode3)) {
+                    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","TryActivate", 3, argv[1] ));
+                  } 
+                  arg3 = static_cast< int >(val3);
+                  res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_wxGrid, 0 |  0 );
+                  if (!SWIG_IsOK(res4)) {
+                    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "wxGrid *","TryActivate", 4, argv[2] )); 
+                  }
+                  arg4 = reinterpret_cast< wxGrid * >(argp4);
+                  director = dynamic_cast<Swig::Director *>(arg1);
+                  upcall = (director && (director->swig_get_self() == self));
+                  try {
+                    if (upcall) {
+                      #{
+                        if module_name == 'wxGridCellActivatableEditor'
+                          'Swig::DirectorPureVirtualException::raise("wxGridCellActivatableEditor::TryActivate");'
+                        else
+                          "vresult = wxGridActivationResult_to_array((arg1)->#{module_name}::TryActivate(arg2,arg3,arg4,array_to_wxGridActivationSource(argv[3], 4)));"
+                        end
+                      }
+                    } else {
+                      vresult = wxGridActivationResult_to_array((arg1)->TryActivate(arg2,arg3,arg4,array_to_wxGridActivationSource(argv[3], 4)));
+                    }
+                  } catch (Swig::DirectorException& e) {
+                    rb_exc_raise(e.getError());
+                    SWIG_fail;
+                  }
+                  return vresult;
+                fail:
+                  return Qnil;
+              __METHOD__
+            end
+
+            line
+          end
+        end
+
+      end # class FixGridcelleditor
+
+    end
+  end
+
+end # module WXRuby3

data/rakelib/lib/director/grid_cell_renderer.rb

@@ -0,0 +1,132 @@
+###
+# wxRuby3 wxWidgets interface director
+# Copyright (c) M.J.N. Corino, The Netherlands
+###
+
+module WXRuby3
+
+  class Director
+
+    class GridCellRenderer < Director
+
+      include Typemap::GridClientData
+
+      def setup
+        super
+        spec.gc_as_untracked_refcounted
+        if spec.module_name == 'wxGridCellRenderer'
+          # exposing the mixin wxClientDataContainer/wxSharedClientDataContainer has no real upside
+          # for wxRuby; far easier to just use member variables in derived classes
+          spec.override_inheritance_chain('wxGridCellRenderer', [])
+          spec.regard('wxGridCellRenderer::~wxGridCellRenderer')
+          # add method for correctly wrapping PGEditor output references
+          spec.add_header_code <<~__CODE
+            extern VALUE mWxGRID; // declare external module reference
+            extern VALUE wxRuby_GridCellRendererInstance(wxGridCellRenderer* wx_rnd);
+            extern void wxRuby_RegisterGridCellRenderer(wxGridCellRenderer* wx_rnd, VALUE rb_rnd);
+            extern VALUE wxRuby_WrapWxGridCellRendererInRuby(const wxGridCellRenderer *wx_gcr)
+            {
+              // If no object was passed to be wrapped.
+              if ( ! wx_gcr )
+                return Qnil;
+
+              // check for registered instance
+              VALUE rb_gcr = wxRuby_GridCellRendererInstance(const_cast<wxGridCellRenderer*> (wx_gcr));
+              if (rb_gcr && !NIL_P(rb_gcr))
+              {
+                return rb_gcr;
+              }
+
+              // unregistered renderer must be a standard C++ class renderer
+              const void *ptr = 0;
+              wxString class_name;
+              if ((ptr = dynamic_cast<const wxGridCellBoolRenderer*> (wx_gcr)))
+              {
+                class_name = "GridCellBoolRenderer";
+              }
+              else if ((ptr = dynamic_cast<const wxGridCellFloatRenderer*> (wx_gcr)))
+              {
+                class_name = "GridCellFloatRenderer";
+              }
+              else if ((ptr = dynamic_cast<const wxGridCellAutoWrapStringRenderer*> (wx_gcr)))
+              {
+                class_name = "GridCellAutoWrapStringRenderer";
+              }
+              else if ((ptr = dynamic_cast<const wxGridCellDateTimeRenderer*> (wx_gcr)))
+              {
+                class_name = "GridCellDateTimeRenderer";
+              }
+              else if ((ptr = dynamic_cast<const wxGridCellDateRenderer*> (wx_gcr)))
+              {
+                class_name = "GridCellDateRenderer";
+              }
+              else if ((ptr = dynamic_cast<const wxGridCellEnumRenderer*> (wx_gcr)))
+              {
+                class_name = "GridCellEnumRenderer";
+              }
+              else if ((ptr = dynamic_cast<const wxGridCellNumberRenderer*> (wx_gcr)))
+              {
+                class_name = "GridCellNumberRenderer";
+              }
+              else if ((ptr = dynamic_cast<const wxGridCellStringRenderer*> (wx_gcr)))
+              {
+                class_name = "GridCellStringRenderer";
+              }
+              VALUE r_class = Qnil;
+              if ( ptr && class_name.Len() > 0 )
+              {
+                wxCharBuffer wx_classname = class_name.mb_str();
+                VALUE r_class_name = rb_intern(wx_classname.data ()); // wxRuby class name (minus 'wx')
+                if (rb_const_defined(mWxGRID, r_class_name))
+                  r_class = rb_const_get(mWxGRID, r_class_name);
+              }
+
+              // If we cannot find the class output a warning and return nil
+              if ( r_class == Qnil )
+              {
+                rb_warn("Error wrapping object; class `%s' is not (yet) supported in wxRuby",
+                        (const char *)class_name.mb_str() );
+                return Qnil;
+              }
+
+              // Otherwise, retrieve the swig type info for this class and wrap it
+              // in Ruby. Make it owned to manage the ref count if GC claims the object.
+              // wxRuby_GetSwigTypeForClass is defined in wx.i
+              swig_type_info* swig_type = wxRuby_GetSwigTypeForClass(r_class);
+              rb_gcr = SWIG_NewPointerObj(const_cast<void*> (ptr), swig_type, 0);
+              wxRuby_RegisterGridCellRenderer(const_cast<wxGridCellRenderer*> (wx_gcr), rb_gcr);
+              return rb_gcr;
+            }
+          __CODE
+        else
+          case spec.module_name
+          when 'wxGridCellStringRenderer'
+            spec.override_inheritance_chain('wxGridCellStringRenderer', %w[wxGridCellRenderer])
+          when 'wxGridCellDateTimeRenderer'
+            spec.override_inheritance_chain('wxGridCellDateTimeRenderer', %w[wxGridCellDateRenderer wxGridCellStringRenderer wxGridCellRenderer])
+          else
+            spec.override_inheritance_chain(spec.module_name, %w[wxGridCellStringRenderer wxGridCellRenderer])
+          end
+          # due to the flawed wxWidgets XML docs we need to explicitly add these here
+          # otherwise the derived renderers won't be allocatable due to pure virtuals
+          spec.extend_interface spec.module_name,
+              'virtual wxGridCellRenderer* Clone() const',
+              'virtual void Draw(wxGrid &grid, wxGridCellAttr &attr, wxDC &dc, const wxRect &rect, int row, int col, bool isSelected)',
+              'virtual wxSize GetBestSize(wxGrid &grid, wxGridCellAttr &attr, wxDC &dc, int row, int col)'
+          spec.force_proxy spec.module_name
+        end
+        unless spec.module_name == 'wxGridCellRenderer'
+          # type mapping for Clone return ref
+          spec.map 'wxGridCellRenderer*' => 'Wx::GRID::GridCellRenderer' do
+            add_header_code 'extern VALUE wxRuby_WrapWxGridCellRendererInRuby(const wxGridCellRenderer *wx_gcr);'
+            map_out code: '$result = wxRuby_WrapWxGridCellRendererInRuby($1);'
+          end
+        end
+        # handled; can be suppressed
+        spec.suppress_warning(473, "#{spec.module_name}::Clone")
+      end
+    end # class GridCellRenderer
+
+  end # class Director
+
+end # module WXRuby3