wxruby3 0.9.3 → 0.9.4

data/rakelib/lib/director/persistence_manager.rb

@@ -0,0 +1,410 @@
+# Copyright (c) 2023 M.J.N. Corino, The Netherlands
+#
+# This software is released under the MIT license.
+
+###
+# wxRuby3 wxWidgets interface director
+###
+
+module WXRuby3
+
+  class Director
+
+    class PersistenceManager < Director
+
+      include Typemap::ConfigBase
+
+      def setup
+        super
+        spec.gc_as_marked
+        spec.use_class_implementation 'wxPersistenceManager', 'WxRubyPersistenceManager'
+        spec.ignore 'wxPersistenceManager::Register',
+                    'wxPersistenceManager::Find',
+                    'wxPersistenceManager::Unregister',
+                    'wxPersistenceManager::Save',
+                    'wxPersistenceManager::Restore',
+                    'wxPersistenceManager::SaveAndUnregister',
+                    'wxPersistenceManager::RegisterAndRestore',
+                    ignore_doc: false
+        # doc gen only
+        spec.map 'void *obj' => 'Object', swig: false do
+          map_in code: ''
+        end
+        spec.map 'T *obj' => 'Object', swig: false do
+          map_in code: ''
+        end
+        spec.regard 'wxPersistenceManager::wxPersistenceManager',
+                    'wxPersistenceManager::GetConfig',
+                    'wxPersistenceManager::GetKey'
+        spec.suppress_warning 473, 'wxPersistenceManager::GetConfig'
+        spec.ignore %w[wxCreatePersistentObject wxPersistentRegisterAndRestore]
+        spec.add_header_code <<~__HEREDOC
+          #include "wxruby-Persistence.h"
+
+          // default global wxRuby persistence manager
+          static WxRubyPersistenceManager s_wxruby_persistence_manager {};
+
+          static WxRuby_ID to_f_id("to_f");
+          static WxRuby_ID to_i_id("to_i");
+          static WxRuby_ID to_s_id("to_s");
+          static WxRuby_ID save_value_id("save_value");
+          static WxRuby_ID restore_value_id("save_value");
+          static WxRuby_ID create_po_id("create_persistent_object");
+          
+          #ifdef wxHAS_LONG_LONG_T_DIFFERENT_FROM_LONG
+          #define PO_LONG wxLongLong_t
+          #define PO_NUM2LONG(n) NUM2LL(n)
+          #define PO_LONG2NUM(l) LL2NUM(l)
+          #else
+          #define PO_LONG long
+          #define PO_NUM2LONG(n) NUM2LONG(n)
+          #define PO_LONG2NUM(l) LONG2NUM(l)
+          #endif
+
+          bool WxRubyPersistenceManager::SaveRubyValue(const wxPersistentObject& who, const wxString& name, VALUE value)
+          {
+            Swig::Director* dir = dynamic_cast<Swig::Director*> (this);
+            // is this a user defined Ruby persistence manager with overridden #save_value?
+            if (dir && !wxRuby_IsNativeMethod(dir->swig_get_self(), save_value_id())) 
+            {
+              VALUE rb_who = SWIG_NewPointerObj(SWIG_as_voidptr(&who), SWIGTYPE_p_wxPersistentObject,  0 );
+              return wxRuby_Funcall(dir->swig_get_self(), save_value_id(), 3, rb_who, WXSTR_TO_RSTR(name), value);
+            }
+            else
+            {
+              // just call C++ base implementation
+              return DoSaveRubyValue(who, name, value);
+            }
+          }
+
+          VALUE WxRubyPersistenceManager::RestoreRubyValue(const wxPersistentObject& who, const wxString& name)
+          {
+            Swig::Director* dir = dynamic_cast<Swig::Director*> (this);
+            // is this a user defined Ruby persistence manager with overridden #restore_value?
+            if (dir && !wxRuby_IsNativeMethod(dir->swig_get_self(), restore_value_id())) 
+            {
+              VALUE rb_who = SWIG_NewPointerObj(SWIG_as_voidptr(&who), SWIGTYPE_p_wxPersistentObject,  0 );
+              return wxRuby_Funcall(dir->swig_get_self(), restore_value_id(), 3, rb_who, WXSTR_TO_RSTR(name));
+            }
+            else
+            {
+              // just call C++ base implementation
+              return DoRestoreRubyValue(who, name);
+            }
+          }
+
+          bool WxRubyPersistenceManager::DoSaveRubyValue(const wxPersistentObject& who, const wxString& name, VALUE value)
+          {
+            wxConfigBase* cfg = this->GetConfig();
+            if (!cfg)
+              return false;
+            wxString key = this->GetKey(who, name);
+            switch(TYPE(value))
+            {
+              case T_TRUE:
+              case T_FALSE:
+                return cfg->Write(key, value == Qtrue);
+        
+              case T_FIXNUM:
+              case T_BIGNUM:
+                return cfg->Write(key, PO_NUM2LONG(value));
+        
+              case T_FLOAT:
+                return cfg->Write(key, NUM2DBL(value));
+        
+              case T_STRING:
+                return cfg->Write(key, RSTR_TO_WXSTR(value));
+        
+              default:
+                if (rb_respond_to(value, to_i_id()))
+                {
+                  VALUE ival = rb_funcall(value, to_i_id(), 0);
+                  return cfg->Write(key, PO_NUM2LONG(ival));
+                }
+                else if (rb_respond_to(value, to_f_id()))
+                {
+                  VALUE fval = rb_funcall(value, to_f_id(), 0);
+                  return cfg->Write(key, NUM2DBL(fval));
+                }
+                break;
+            }
+            VALUE sval = rb_funcall(value, to_s_id(), 0);
+            return cfg->Write(key, RSTR_TO_WXSTR(sval));
+          }
+
+          VALUE WxRubyPersistenceManager::DoRestoreRubyValue(const wxPersistentObject& who, const wxString& name)
+          {
+            wxConfigBase* cfg = this->GetConfig();
+            if (!cfg)
+              return Qnil;
+            wxString key = this->GetKey(who, name);
+            wxConfigBase::EntryType vtype = cfg->GetEntryType(key);
+            switch(vtype)
+            {
+              case wxConfigBase::Type_Boolean:
+              {
+                bool v;
+                if (cfg->Read(key, &v))
+                {
+                  return v ? Qtrue : Qfalse;
+                }
+                break;
+              }
+              case wxConfigBase::Type_Integer:
+              {
+                PO_LONG v;
+                if (cfg->Read(key, &v))
+                {
+                  return PO_LONG2NUM(v);
+                }
+                break;
+              }
+              case wxConfigBase::Type_Float:
+              {
+                double v;
+                if (cfg->Read(key, &v))
+                {
+                  return DBL2NUM(v);
+                }
+                break;
+              }
+              case wxConfigBase::Type_String:
+              {
+                wxString v;
+                if (cfg->Read(key, &v))
+                {
+                  return WXSTR_TO_RSTR(v);
+                }
+                break;
+              }
+              default:
+                break;
+            }
+            return Qnil;
+          }
+
+          void WxRubyPersistenceManager::UnregisterPersistentObject(VALUE rb_obj)
+          {
+            WxRubyPersistenceManager* wxrb_pm = 
+              dynamic_cast<WxRubyPersistenceManager*> (&wxPersistenceManager::Get());
+            if (wxrb_pm) wxrb_pm->UnregisterRbPO(rb_obj);
+          } 
+
+          void WxRubyPersistenceManager::GC_markPO()
+          {
+            rb_object_to_rb_po_map_t::iterator it;
+            for( it = rb_object_po_map_.begin(); it != rb_object_po_map_.end(); ++it )
+            {
+              rb_gc_mark(it->first);
+              rb_gc_mark(it->second);
+            }
+          }
+
+          static void wxRuby_markPersistentObjects()
+          {
+            WxRubyPersistenceManager* wxrb_pm = 
+              dynamic_cast<WxRubyPersistenceManager*> (&wxPersistenceManager::Get());
+            if (wxrb_pm) wxrb_pm->GC_markPO();
+          }
+          __HEREDOC
+        spec.add_extend_code 'wxPersistenceManager', <<~__HEREDOC
+          VALUE Register(VALUE obj)
+          {
+            WxRubyPersistenceManager* wxrb_pm = dynamic_cast<WxRubyPersistenceManager*> ($self);
+            VALUE rb_po = rb_funcall(obj, create_po_id(), 0);
+            if (!NIL_P(rb_po) && wxrb_pm)
+            {
+              void* ptr;
+              int res = SWIG_ConvertPtr(rb_po, &ptr, SWIGTYPE_p_wxPersistentObject, SWIG_POINTER_DISOWN);
+              if (!SWIG_IsOK(res)) 
+              {
+                rb_raise(rb_eRuntimeError, "Unable to create Wx::PersistentObject for object"); 
+              }
+              wxPersistentObject* po = reinterpret_cast< wxPersistentObject * >(ptr);
+              if ($self->Register(po->GetObject(), po))
+              {
+                wxrb_pm->RegisterRbPO(obj, rb_po);
+                return rb_po;
+              }
+            }
+            return Qnil;
+          }
+
+          VALUE Register(VALUE obj, VALUE rb_po)
+          {
+            WxRubyPersistenceManager* wxrb_pm = dynamic_cast<WxRubyPersistenceManager*> ($self);
+            if (!NIL_P(rb_po) && wxrb_pm)
+            {
+              void* ptr;
+              int res = SWIG_ConvertPtr(rb_po, &ptr, SWIGTYPE_p_wxPersistentObject, SWIG_POINTER_DISOWN);
+              if (!SWIG_IsOK(res)) 
+              {
+                rb_raise(rb_eRuntimeError, "Unable to create Wx::PersistentObject for object"); 
+              }
+              wxPersistentObject* po = reinterpret_cast< wxPersistentObject * >(ptr);
+              if ($self->Register(po->GetObject(), po))
+              {
+                wxrb_pm->RegisterRbPO(obj, rb_po);
+                return rb_po;
+              }
+            }
+            return Qnil;
+          }
+
+          VALUE Find(VALUE obj)
+          {
+            WxRubyPersistenceManager* wxrb_pm = dynamic_cast<WxRubyPersistenceManager*> ($self);
+            VALUE rb_po = wxrb_pm ? wxrb_pm->FindRbPO(obj) : Qnil;
+            if (!NIL_P(rb_po) && wxrb_pm)
+            { 
+              void* ptr;
+              int res = SWIG_ConvertPtr(rb_po, &ptr, SWIGTYPE_p_wxPersistentObject, 0);
+              if (!SWIG_IsOK(res)) 
+              {
+                rb_raise(rb_eRuntimeError, "Invalid Wx::PersistentObject for object"); 
+              }
+              wxPersistentObject* po = reinterpret_cast< wxPersistentObject * >(ptr);
+              if ($self->Find(po->GetObject()))
+                return rb_po;
+            }
+            return Qnil;
+          }
+
+          void Unregister(VALUE obj)
+          {
+            WxRubyPersistenceManager* wxrb_pm = dynamic_cast<WxRubyPersistenceManager*> ($self);
+            VALUE rb_po = wxrb_pm ? wxrb_pm->FindRbPO(obj) : Qnil;
+            if (!NIL_P(rb_po) && wxrb_pm)
+            { 
+              void* ptr;
+              int res = SWIG_ConvertPtr(rb_po, &ptr, SWIGTYPE_p_wxPersistentObject, 0);
+              if (!SWIG_IsOK(res)) 
+              {
+                rb_raise(rb_eRuntimeError, "Invalid Wx::PersistentObject for object"); 
+              }
+              wxPersistentObject* po = reinterpret_cast< wxPersistentObject * >(ptr);
+              $self->Unregister(po->GetObject());
+            }
+          }
+
+          void Save(VALUE obj)
+          {
+            WxRubyPersistenceManager* wxrb_pm = dynamic_cast<WxRubyPersistenceManager*> ($self);
+            VALUE rb_po = wxrb_pm ? wxrb_pm->FindRbPO(obj) : Qnil;
+            if (!NIL_P(rb_po) && wxrb_pm)
+            { 
+              void* ptr;
+              int res = SWIG_ConvertPtr(rb_po, &ptr, SWIGTYPE_p_wxPersistentObject, 0);
+              if (!SWIG_IsOK(res)) 
+              {
+                rb_raise(rb_eRuntimeError, "Invalid Wx::PersistentObject for object"); 
+              }
+              wxPersistentObject* po = reinterpret_cast< wxPersistentObject * >(ptr);
+              $self->Save(po->GetObject());
+            }
+          }
+
+          bool Restore(VALUE obj)
+          {
+            WxRubyPersistenceManager* wxrb_pm = dynamic_cast<WxRubyPersistenceManager*> ($self);
+            VALUE rb_po = wxrb_pm ? wxrb_pm->FindRbPO(obj) : Qnil;
+            if (!NIL_P(rb_po) && wxrb_pm)
+            { 
+              void* ptr;
+              int res = SWIG_ConvertPtr(rb_po, &ptr, SWIGTYPE_p_wxPersistentObject, 0);
+              if (!SWIG_IsOK(res)) 
+              {
+                rb_raise(rb_eRuntimeError, "Invalid Wx::PersistentObject for object"); 
+              }
+              wxPersistentObject* po = reinterpret_cast< wxPersistentObject * >(ptr);
+              return $self->Restore(po->GetObject());
+            }
+            return false;
+          }
+
+          void SaveAndUnregister(VALUE obj)
+          {
+            WxRubyPersistenceManager* wxrb_pm = dynamic_cast<WxRubyPersistenceManager*> ($self);
+            VALUE rb_po = wxrb_pm ? wxrb_pm->FindRbPO(obj) : Qnil;
+            if (!NIL_P(rb_po) && wxrb_pm)
+            { 
+              void* ptr;
+              int res = SWIG_ConvertPtr(rb_po, &ptr, SWIGTYPE_p_wxPersistentObject, 0);
+              if (!SWIG_IsOK(res)) 
+              {
+                rb_raise(rb_eRuntimeError, "Invalid Wx::PersistentObject for object"); 
+              }
+              wxPersistentObject* po = reinterpret_cast< wxPersistentObject * >(ptr);
+              $self->Save(po->GetObject());
+              $self->Unregister(po->GetObject());
+            }
+          }
+
+          bool RegisterAndRestore(VALUE obj)
+          {
+            WxRubyPersistenceManager* wxrb_pm = dynamic_cast<WxRubyPersistenceManager*> ($self);
+            VALUE rb_po = rb_funcall(obj, create_po_id(), 0);
+            if (!NIL_P(rb_po) && wxrb_pm)
+            {
+              void* ptr;
+              int res = SWIG_ConvertPtr(rb_po, &ptr, SWIGTYPE_p_wxPersistentObject, SWIG_POINTER_DISOWN);
+              if (!SWIG_IsOK(res)) 
+              {
+                rb_raise(rb_eRuntimeError, "Unable to create Wx::PersistentObject for object"); 
+              }
+              wxPersistentObject* po = reinterpret_cast< wxPersistentObject * >(ptr);
+              if ($self->Register(po->GetObject(), po))
+              {
+                wxrb_pm->RegisterRbPO(obj, rb_po);
+                return $self->Restore(po->GetObject());
+              }
+            }
+            return false;
+          }
+
+          bool RegisterAndRestore(VALUE obj, VALUE rb_po)
+          {
+            WxRubyPersistenceManager* wxrb_pm = dynamic_cast<WxRubyPersistenceManager*> ($self);
+            if (!NIL_P(rb_po) && wxrb_pm)
+            {
+              void* ptr;
+              int res = SWIG_ConvertPtr(rb_po, &ptr, SWIGTYPE_p_wxPersistentObject, SWIG_POINTER_DISOWN);
+              if (!SWIG_IsOK(res)) 
+              {
+                rb_raise(rb_eRuntimeError, "Unable to create Wx::PersistentObject for object"); 
+              }
+              wxPersistentObject* po = reinterpret_cast< wxPersistentObject * >(ptr);
+              if ($self->Register(po->GetObject(), po))
+              {
+                wxrb_pm->RegisterRbPO(obj, rb_po);
+                return $self->Restore(po->GetObject());
+              }
+            }
+            return false;
+          }
+          
+          bool SaveValue(const wxPersistentObject& who, const wxString& name, VALUE value)
+          {
+            WxRubyPersistenceManager* wxrb_pm = dynamic_cast<WxRubyPersistenceManager*> ($self);
+            return wxrb_pm ? wxrb_pm->DoSaveRubyValue(who, name, value) : false;
+          } 
+
+          VALUE RestoreValue(const wxPersistentObject& who, const wxString& name)
+          {
+            WxRubyPersistenceManager* wxrb_pm = dynamic_cast<WxRubyPersistenceManager*> ($self);
+            return wxrb_pm ? wxrb_pm->DoRestoreRubyValue(who, name) : Qnil;
+          }
+          __HEREDOC
+        spec.add_init_code <<~__HEREDOC
+          // install the default global wxRuby persistence manager
+          wxPersistenceManager::Set(s_wxruby_persistence_manager);
+          // and the persistent object marker
+          wxRuby_AppendMarker(wxRuby_markPersistentObjects);
+          __HEREDOC
+      end
+
+    end # class PersistenceManager
+
+  end # class Director
+
+end # module WXRuby3

data/rakelib/lib/director/persistent_object.rb

@@ -0,0 +1,70 @@
+# Copyright (c) 2023 M.J.N. Corino, The Netherlands
+#
+# This software is released under the MIT license.
+
+###
+# wxRuby3 wxWidgets interface director
+###
+
+module WXRuby3
+
+  class Director
+
+    class PersistentObject < Director
+
+      def setup
+        super
+        spec.gc_as_marked
+        spec.add_header_code <<~__HEREDOC
+          #include "wxruby-Persistence.h"
+
+          WxRubyPersistentObject::WxRubyPersistentObject(VALUE rb_obj)
+            : wxPersistentObject((void*)rb_obj)
+          {}
+
+          WxRubyPersistentObject::~WxRubyPersistentObject()
+          {
+            if (this->GetObject())
+              WxRubyPersistenceManager::UnregisterPersistentObject(
+                reinterpret_cast<VALUE> (this->GetObject()));
+          } 
+          __HEREDOC
+        spec.use_class_implementation 'wxPersistentObject', 'WxRubyPersistentObject'
+        spec.ignore %w[wxPersistentObject::GetObject wxPersistentObject::wxPersistentObject]
+        spec.ignore %w[wxCreatePersistentObject wxPersistentRegisterAndRestore]
+        spec.extend_interface 'wxPersistentObject',
+                              'wxPersistentObject(VALUE rb_obj)',
+                              visibility: 'protected'
+        spec.add_extend_code 'wxPersistentObject', <<~__HEREDOC
+          bool SaveValue(const wxString& name, VALUE value)
+          {
+            WxRubyPersistenceManager* wxrb_pm = dynamic_cast<WxRubyPersistenceManager*> (&wxPersistenceManager::Get());
+            return wxrb_pm ? wxrb_pm->SaveRubyValue(*$self, name, value) : false;
+          }
+          VALUE RestoreValue(const wxString& name)
+          {
+            WxRubyPersistenceManager* wxrb_pm = dynamic_cast<WxRubyPersistenceManager*> (&wxPersistenceManager::Get());
+            return wxrb_pm ? wxrb_pm->RestoreRubyValue(*$self, name) : Qnil;
+          } 
+          __HEREDOC
+        spec.add_extend_code 'wxPersistentObject', <<~__HEREDOC
+          VALUE GetObject()
+          {
+            WxRubyPersistentObject* rpo = dynamic_cast<WxRubyPersistentObject*> ($self);
+            if (rpo)
+            {
+              return reinterpret_cast<VALUE> (rpo->GetObject());
+            } 
+            else
+            {
+              return Qnil;
+            }
+          }
+          __HEREDOC
+        super
+      end
+    end # class PersistentObject
+
+  end # class Director
+
+end # module WXRuby3

data/rakelib/lib/director/persistent_window.rb

@@ -0,0 +1,73 @@
+# Copyright (c) 2023 M.J.N. Corino, The Netherlands
+#
+# This software is released under the MIT license.
+
+###
+# wxRuby3 wxWidgets interface director
+###
+
+module WXRuby3
+
+  class Director
+
+    class PersistentWindow < Director
+
+      def setup
+        spec.items << 'wxPersistentTLW' << 'wxPersistentBookCtrl' << 'wxPersistentTreeBookCtrl'
+        if Config.instance.wx_version >= '3.3.0'
+          # before 3.3.0 this was not properly available
+          spec.items << 'wxPersistentComboBox'
+        end
+        super
+        spec.gc_as_marked
+        spec.use_template_as_class('wxPersistentWindow', 'wxPersistentWindowBase')
+        spec.override_inheritance_chain('wxPersistentWindow', %w[wxPersistentObject])
+        spec.ignore 'wxPersistentWindow::wxPersistentWindow',
+                    'wxPersistentWindow::Get',
+                    ignore_doc: false
+        # make ctor protected because of pure virt methods
+        spec.extend_interface 'wxPersistentWindow',
+                              'wxPersistentWindowBase(wxWindow *win)',
+                              visibility: 'protected'
+        spec.add_header_code 'typedef wxWindow WindowType;'
+        spec.add_swig_code 'typedef wxWindow WindowType;'
+        spec.map 'WindowType *' => 'Wx::Window', swig: false do
+          map_in code: ''
+          map_out code: ''
+        end
+        spec.add_extend_code 'wxPersistentWindowBase', <<~__HEREDOC
+          wxWindow * GetObject()
+          {
+            return reinterpret_cast<wxWindow*> ($self->GetObject());
+          }
+        __HEREDOC
+        # wxPersistentTLW
+        spec.override_inheritance_chain('wxPersistentTLW', [{ 'wxPersistentWindowBase' => 'wxPersistentWindow' }, 'wxPersistentObject'])
+        # add method override missing from docs
+        spec.extend_interface 'wxPersistentTLW',
+                              'virtual wxString GetKind() const override'
+        # wxPersistentBookCtrl
+        spec.override_inheritance_chain('wxPersistentBookCtrl', [{ 'wxPersistentWindowBase' => 'wxPersistentWindow' }, 'wxPersistentObject'])
+        # add method override missing from docs
+        spec.extend_interface 'wxPersistentBookCtrl',
+                              'virtual wxString GetKind() const override'
+        # wxPersistentTreeBookCtrl
+        spec.override_inheritance_chain('wxPersistentTreeBookCtrl', ['wxPersistentBookCtrl', { 'wxPersistentWindowBase' => 'wxPersistentWindow' }, 'wxPersistentObject'])
+        # add method override missing from docs
+        spec.extend_interface 'wxPersistentTreeBookCtrl',
+                              'virtual wxString GetKind() const override'
+        spec.do_not_generate :functions, :defines, :typedefs, :variables, :enums
+        if Config.instance.wx_version >= '3.0.0'
+          # wxPersistentComboBox
+          spec.override_inheritance_chain('wxPersistentComboBox', [{ 'wxPersistentWindowBase' => 'wxPersistentWindow' }, 'wxPersistentObject'])
+          # add method override missing from docs
+          spec.extend_interface 'wxPersistentComboBox',
+                                'virtual wxString GetKind() const override'
+        end
+      end
+
+    end
+
+  end
+
+end

data/rakelib/lib/director/static_bitmap.rb

@@ -45,6 +45,10 @@ module WXRuby3
         spec.add_swig_code %Q{typedef wxStaticBitmap::ScaleMode ScaleMode; }
         spec.add_header_code %Q{typedef wxStaticBitmap::ScaleMode ScaleMode; }
         defmod.items << def_genstatbmp
+        # as we already called super before adding wxGenericStaticBitmap the no_proxy settings from the
+        # base Window director are missing; just copy all those set for wxStaticBitmap
+        list = spec.no_proxies.select { |name| name.start_with?('wxStaticBitmap::') }
+        spec.no_proxy(*list.collect { |name| name.sub(/\AwxStaticBitmap::/, 'wxGenericStaticBitmap::')})
         defmod
       end
 

data/rakelib/lib/director/text_entry.rb

@@ -15,7 +15,7 @@ module WXRuby3
       def setup
         super
         spec.items << 'wxTextCompleter' << 'wxTextCompleterSimple'
-        spec.gc_as_untracked 'wxTextCompleter', 'wxTextCompleterSimple'
+        spec.gc_as_marked 'wxTextCompleter', 'wxTextCompleterSimple' # untracked but cached in Ruby
         spec.gc_as_untracked 'wxTextEntry' # actually no GC control necessary as this is a mixin only
         # turn wxTextEntry into a mixin module
         spec.make_mixin 'wxTextEntry'

data/rakelib/lib/generate/analyzer.rb

@@ -540,53 +540,53 @@ module WXRuby3
           # check the preprocessed definitions
           errors = []
           warnings = []
-          def_items.each do |item|
-            if Extractor::ClassDef === item && !item_ignored(item, doc_gen) &&
+          # select eligible ClassDef
+          cls_items = def_items.select do |item|
+            Extractor::ClassDef === item && !item_ignored(item, doc_gen) &&
               (!item.is_template? || template_as_class?(item.name)) &&
               !is_folded_base?(item.name)
-              intf_class_name = if item.is_template? || template_as_class?(item.name)
-                                  template_class_name(item.name)
-                                else
-                                  item.name
-                                end
-              # this should not happen
-              raise "Missing preprocessed data for class #{intf_class_name}" unless has_class_interface(intf_class_name)
-              # get the class's method registry
-              cls_mtdreg = class_interface_methods(intf_class_name)
-              # check all directly inherited generated methods
-              mtdlist = ::Set.new # remember handled signatures
-              base_list(item).each do |base_name|
-                # get 'real' base name (i.e. take renames into account)
-                base_name = ifspec.classdef_name(base_name)
-                # make sure the base class has been preprocessed
-                get_class_interface(package, base_name, doc_gen) unless has_class_interface(base_name)
-                # generate any required enum typemaps for inherited virtuals
-                gen_base_class_enum_typemaps(base_name, enum_maps)
-                # iterate the base class's method registrations
-                class_interface_methods(base_name).each_pair do |mtdsig, mtdreg|
-                  # only check on methods we have not handled yet
-                  if !mtdlist.include?(mtdsig)
-                    # did we inherit a virtual method that was not proxied in the base
-                    if mtdreg[:virtual] && !mtdreg[:proxy]
-                      # # if we did NOT generate a wrapper override and we do not have the proxy suppressed we're in trouble
-                      # if !cls_mtdreg.has_key?(mtdsig) && has_method_proxy?(item.name, mtdreg[:method])
-                      #   warnings << "* WARNING: disabling proxy for virtual method #{mtdreg[:method].signature} without wrapper implementation in class #{item.name} since it is NOT proxied in base class #{base_name}!"
-                      # els
-                      if cls_mtdreg.has_key?(mtdsig) && !cls_mtdreg[mtdsig][:extension] && !has_method_proxy?(item.name, cls_mtdreg[mtdsig][:method])
-                        # if this is not a custom extension and we do have an override wrapper and no proxy this is unnecessary code bloat
-                        warnings << " * WARNING: Unnecessary override #{mtdreg[:method].signature} in class #{item.name} for non-proxied base in #{base_name}. Ignoring."
-                        cls_mtdreg[mtdsig][:ignore] = true
-                      end
-                      # or did we inherit a virtual method that was proxied in the base
-                      # for which we DO generate a wrapper override
-                    elsif mtdreg[:virtual] && mtdreg[:proxy] && cls_mtdreg.has_key?(mtdsig)
-                      # if we do not have a proxy as well we're in trouble
-                      if !has_method_proxy?(item, mtdreg[:method])
-                        errors << "* ERROR: method #{mtdreg[:method].signature} is NOT proxied with an overriden wrapper implementation in class #{item.name} but is also implemented and proxied in base class #{base_name}!"
-                      end
+          end
+          cls_items.each do |item|
+            intf_class_name = if item.is_template? || template_as_class?(item.name)
+                                template_class_name(item.name)
+                              else
+                                item.name
+                              end
+            # this should not happen
+            raise "Missing preprocessed data for class #{intf_class_name}" unless has_class_interface(intf_class_name)
+            # get the class's method registry
+            cls_mtdreg = class_interface_methods(intf_class_name)
+            # check all directly inherited generated methods
+            mtdlist = ::Set.new # remember handled signatures
+            base_list(item).each do |base_name|
+              # make sure the base class has been preprocessed
+              get_class_interface(package, base_name, doc_gen) unless has_class_interface(base_name)
+              # generate any required enum typemaps for inherited virtuals
+              gen_base_class_enum_typemaps(base_name, enum_maps)
+              # iterate the base class's method registrations
+              class_interface_methods(base_name).each_pair do |mtdsig, mtdreg|
+                # only check on methods we have not handled yet
+                if !mtdlist.include?(mtdsig)
+                  # did we inherit a virtual method that was not proxied in the base
+                  if mtdreg[:virtual] && !mtdreg[:proxy]
+                    # # if we did NOT generate a wrapper override and we do not have the proxy suppressed we're in trouble
+                    # if !cls_mtdreg.has_key?(mtdsig) && has_method_proxy?(item.name, mtdreg[:method])
+                    #   warnings << "* WARNING: disabling proxy for virtual method #{mtdreg[:method].signature} without wrapper implementation in class #{item.name} since it is NOT proxied in base class #{base_name}!"
+                    # els
+                    if cls_mtdreg.has_key?(mtdsig) && !cls_mtdreg[mtdsig][:extension] && !has_method_proxy?(item.name, cls_mtdreg[mtdsig][:method])
+                      # if this is not a custom extension and we do have an override wrapper and no proxy this is unnecessary code bloat
+                      warnings << " * WARNING: Unnecessary override #{mtdreg[:method].signature} in class #{item.name} for non-proxied base in #{base_name}. Ignoring."
+                      cls_mtdreg[mtdsig][:ignore] = true
+                    end
+                    # or did we inherit a virtual method that was proxied in the base
+                    # for which we DO generate a wrapper override
+                  elsif mtdreg[:virtual] && mtdreg[:proxy] && cls_mtdreg.has_key?(mtdsig)
+                    # if we do not have a proxy as well we're in trouble
+                    if !has_method_proxy?(item, mtdreg[:method])
+                      errors << "* ERROR: method #{mtdreg[:method].signature} is NOT proxied with an overriden wrapper implementation in class #{item.name} but is also implemented and proxied in base class #{base_name}!"
                     end
-                    mtdlist << mtdsig
                   end
+                  mtdlist << mtdsig
                 end
               end
             end