wxruby3 1.3.0 → 1.4.2

data/rakelib/lib/director/event_handler.rb

@@ -29,45 +29,21 @@ module WXRuby3
           # have TryBefore and TryAfter to handle this much cleaner
           spec.no_proxy 'wxEvtHandler::ProcessEvent'
           spec.regard('wxEvtHandler::ProcessEvent', regard_doc: false) # we provide customized docs
+          # Do not see much use for allowing overrides for these either as wxWidgets do not either
+          spec.no_proxy 'wxEvtHandler::QueueEvent',
+                        'wxEvtHandler::AddPendingEvent'
+          # Do not see much point in allowing/supporting these to be overridden
+          spec.no_proxy 'wxEvtHandler::SetNextHandler',
+                        'wxEvtHandler::SetPreviousHandler'
+          # no doc for set_previous_handler
+          spec.regard('wxEvtHandler::SetPreviousHandler', regard_doc: false)
           # make SWIG aware of these
           spec.regard 'wxEvtHandler::TryBefore', 'wxEvtHandler::TryAfter'
           # Special type mapping for wxEvtHandler::QueueEvent which assumes ownership of the C++ event.
-          # We need to create a shallow copy of the Ruby event instance (copying it's Ruby members if any),
-          # pass linkage of the C++ event to the copy and remove it from the original (input) Ruby
-          # instance (so it can not delete/or reference it anymore); also start tracking the copy
-          # (which effectively removes the tracking for the original).
-          # Queued (pending) events are cleaned up (deleted) by wxWidgets after (failing) handling
-          # which will automatically unlink and un-track them releasing the Ruby instance to be GC-ed.
-          spec.map 'wxEvent *event' => 'Wx::Event' do
-            map_in code: <<~__CODE
-              // get the wrapped wxEvent*
-              wxEvent *wx_ev = (wxEvent*)DATA_PTR($input);
-              // check if this a user defined event
-              if ( wx_ev->GetEventType() > wxEVT_USER_FIRST )
-              {
-                // we need to preserve the Ruby state
-                // create a shallow copy of the Ruby object
-                VALUE r_evt_copy = rb_obj_clone($input);
-                // pass the wxEvent* over to the copy
-                DATA_PTR(r_evt_copy) = wx_ev;
-                // unlink the input
-                DATA_PTR($input) = 0;
-                // track the copy (this overwrites the record for the 
-                // original, effectively untracking it)
-                wxRuby_AddTracking( (void*)wx_ev, r_evt_copy);
-              }
-              else
-              {
-                // std wx event; no need to preserve the Ruby state
-                // simply untrack and unlink the input
-                wxRuby_RemoveTracking( (void*)wx_ev);
-                DATA_PTR($input) = 0;
-                // and just pass on the C++ event                
-              }
-              // Queue the C++ event
-              $1 = wx_ev;
-              __CODE
-          end
+          # We need to disown Ruby with respect to the C++ event object but remain tracking the pair to keep
+          # the Ruby event object alive.
+          spec.disown 'wxEvent *event'
+
           # add special mapping for event filters so we can accept the app instance as well
           # although Wx::App is not derived from Wx::EventFilter in wxRuby (no multiple inheritance)
           spec.map 'wxEventFilter*' => 'Wx::EventFilter,Wx::App' do
@@ -225,6 +201,10 @@ module WXRuby3
             }
             __HEREDOC
           spec.add_header_code <<~__HEREDOC
+            static VALUE WxRuby_GetAsyncProcCallEvent_Class();
+            static void GC_mark_AsyncMethodCallEvent(void *ptr);
+            static void free_AsyncMethodCallEvent(void *ptr);
+
             class RbAsyncProcCallEvent : public wxAsyncMethodCallEvent
             {
             public:
@@ -245,7 +225,14 @@ module WXRuby3
   
               virtual wxEvent *Clone() const wxOVERRIDE
               {
-                return new RbAsyncProcCallEvent(*this);
+                RbAsyncProcCallEvent* wx_ev = new RbAsyncProcCallEvent(*this);
+                // Create a new Ruby event object (owned) 
+                VALUE rb_evt = Data_Wrap_Struct(WxRuby_GetAsyncProcCallEvent_Class(), 
+                                                VOIDFUNC(GC_mark_AsyncMethodCallEvent), 
+                                                VOIDFUNC(free_AsyncMethodCallEvent), 
+                                                wx_ev);
+                wxRuby_AddTracking( (void*)wx_ev, rb_evt);
+                return wx_ev;
               }
           
               virtual void Execute() wxOVERRIDE
@@ -257,12 +244,22 @@ module WXRuby3
                 if (TYPE(m_rb_call) == T_ARRAY)
                 {
                   VALUE proc = rb_ary_entry(m_rb_call, 0);
-                  VALUE args = rb_ary_subseq(m_rb_call, 1, RARRAY_LEN(m_rb_call)-1);
-                  rc = wxRuby_Funcall(ex_caught, proc, call_id(), args);
+                  if (RARRAY_LEN(m_rb_call) > 1)
+                  {
+                    VALUE args = rb_ary_subseq(m_rb_call, 1, RARRAY_LEN(m_rb_call)-1);
+                    rc = wxRuby_Funcall(ex_caught, proc, call_id(), args);
+                  }
+                  else
+                  {
+                    rc = wxRuby_Funcall(ex_caught, proc, call_id(), (int)0);
+                  } 
                 }
                 else
                 {
-                  rc = wxRuby_Funcall(ex_caught, m_rb_call, call_id(), (int)0);
+                  // should never happen
+                  VALUE ex = rb_eval_string("x = RuntimeError.new('UNEXPECTED ERROR: Asynchronous Proc Event has invalid call spec!'); x.set_backtrace(caller); x"); 
+                  wxRuby_PrintException(ex);
+                  exit(1);
                 }
                 if (ex_caught)
                 {
@@ -276,9 +273,39 @@ module WXRuby3
                 }
               }
           
+              void GC_Mark()
+              {
+                rb_gc_mark(m_rb_call);
+              }
+
             private:
               VALUE m_rb_call;
             };
+
+            static void GC_mark_AsyncMethodCallEvent(void *ptr)
+            {
+              if (ptr)
+              {
+                RbAsyncProcCallEvent* evt = (RbAsyncProcCallEvent*)ptr;
+                evt->GC_Mark();
+              }
+            }
+
+            static void free_AsyncMethodCallEvent(void *ptr)
+            {
+              RbAsyncProcCallEvent *wx_evt = (RbAsyncProcCallEvent *)ptr;
+              delete wx_evt;
+            }
+
+            static VALUE WxRuby_GetAsyncProcCallEvent_Class()
+            {
+              static VALUE WxRuby_cAsyncProcCallEvent = Qnil;
+              if (WxRuby_cAsyncProcCallEvent == Qnil)
+              {
+                WxRuby_cAsyncProcCallEvent = rb_eval_string("Wx::AsyncProcCallEvent");
+              } 
+              return WxRuby_cAsyncProcCallEvent;
+            }
             __HEREDOC
           spec.add_extend_code 'wxEvtHandler', <<~__HEREDOC
             // This provides the public Ruby 'connect' method
@@ -333,18 +360,23 @@ module WXRuby3
             void call_after(VALUE call)
             {
               // valid call object?
-              VALUE proc;
-              if (TYPE(call) == T_ARRAY && 
-                    (rb_obj_is_kind_of(proc = rb_ary_entry(call, 0), rb_cProc)
+              VALUE proc = TYPE(call) == T_ARRAY ? rb_ary_entry(call, 0) : Qnil;
+              if (!NIL_P(proc) && 
+                    (rb_obj_is_kind_of(proc, rb_cProc)
                      ||
                      rb_obj_is_kind_of(proc, rb_cMethod)))
               {
                 // create C++ event
                 RbAsyncProcCallEvent * evt = new RbAsyncProcCallEvent(self, call);
+                // Create a new Ruby event object (leave ownership to wxWidgets C++) 
+                VALUE rb_evt = Data_Wrap_Struct(WxRuby_GetAsyncProcCallEvent_Class(), 
+                                                VOIDFUNC(GC_mark_AsyncMethodCallEvent), 
+                                                0, 
+                                                evt);
                 // track it and the call object
-                wxRuby_AddTracking( (void*)evt, call);
-                // queue it
-                self->QueueEvent(evt);
+                wxRuby_AddTracking( (void*)evt, rb_evt);
+                // queue it (wxWidgets takes ownership of C++ event object)
+                self->wxEvtHandler::QueueEvent(evt);
               }
             }
             __HEREDOC
@@ -371,6 +403,10 @@ module WXRuby3
             def_item = defmod.find_item(citem)
             if Extractor::ClassDef === def_item && spec.is_derived_from?(def_item, 'wxEvtHandler')
               spec.no_proxy "#{spec.class_name(citem)}::ProcessEvent"
+              spec.no_proxy "#{spec.class_name(citem)}::QueueEvent"
+              spec.no_proxy "#{spec.class_name(citem)}::AddPendingEvent"
+              spec.no_proxy "#{spec.class_name(citem)}::SetNextHandler"
+              spec.no_proxy "#{spec.class_name(citem)}::SetPreviousHandler"
               is_evt_handler = true
             end
           end

data/rakelib/lib/director/functions.rb

@@ -204,9 +204,6 @@ module WXRuby3
         spec.add_interface_code <<~__HEREDOC
           bool wxSafeYield(wxWindow* win = NULL, bool onlyIfNeeded = false);
           
-          // Mouse / keyboard information
-          wxWindow * wxGetActiveWindow();
-          
           // Dialog shortcuts
           wxString wxFileSelector (const wxString &message,
                                    const wxString &default_path=wxEmptyString,

data/rakelib/lib/director/list_ctrl.rb

@@ -148,7 +148,7 @@ module WXRuby3
             
             wxListCtrl* wx_lc = (wxListCtrl*) ptr;
             
-            // First check if there's ImageLists and mark if found
+            // First check if there are ImageLists and mark if found
             wxImageList* img_list;
             img_list= wx_lc->GetImageList(wxIMAGE_LIST_NORMAL);
             if ( img_list ) rb_gc_mark(SWIG_RubyInstanceFor(img_list));
@@ -161,18 +161,22 @@ module WXRuby3
             if ( wx_lc->GetWindowStyle() & wxLC_VIRTUAL )
               return;
             
-            int count = wx_lc->GetItemCount();
-            if ( count == 0 ) return;
-            
-            for (int i = 0; i < count; ++i)
+            // only mark items if window fully created
+            if (wx_lc->GetId() != wxID_ANY)
             {
-              wxUIntPtr data = wx_lc->GetItemData(i);
-              VALUE object = reinterpret_cast<VALUE> (data);
-              if ( object && object != Qnil ) 
+              int count = wx_lc->GetItemCount();
+              if ( count == 0 ) return;
+              
+              for (int i = 0; i < count; ++i)
               {
-                rb_gc_mark(object);
+                wxUIntPtr data = wx_lc->GetItemData(i);
+                VALUE object = reinterpret_cast<VALUE> (data);
+                if ( object && object != Qnil ) 
+                {
+                  rb_gc_mark(object);
+                }
               }
-            }
+            } 
           }
           __HEREDOC
         spec.add_extend_code 'wxListCtrl', <<~__HEREDOC

data/rakelib/lib/director/locale.rb

@@ -29,6 +29,8 @@ module WXRuby3
           wxLanguageInfo::LayoutDirection
           ]
         spec.ignore_unless('WXMSW', 'wxLanguageInfo::WinLang', 'wxLanguageInfo::WinSublang')
+        # implemented in Ruby
+        spec.ignore 'wxLocale::GetSystemEncodingName'
       end
     end # class Locale
 

data/rakelib/lib/director/num_validator.rb

@@ -370,6 +370,13 @@ module WXRuby3
         spec.new_object 'WXIntegerValidator::Clone',
                         'WXUnsignedValidator::Clone',
                         'WXFloatValidator::Clone'
+        %w[WXIntegerValidator WXUnsignedValidator WXFloatValidator].each do |klass|
+          spec.no_proxy "#{klass}::ProcessEvent"
+          spec.no_proxy "#{klass}::QueueEvent"
+          spec.no_proxy "#{klass}::AddPendingEvent"
+          spec.no_proxy "#{klass}::SetNextHandler"
+          spec.no_proxy "#{klass}::SetPreviousHandler"
+        end
         spec.suppress_warning(473,
                               'WXIntegerValidator::Clone',
                               'WXUnsignedValidator::Clone',

data/rakelib/lib/director/pgproperties.rb

@@ -141,7 +141,7 @@ module WXRuby3
           spec.map_apply 'int * OUTPUT' => 'int* pIndex'
         end
         # for UIntProperty and IntProperty
-        if Config.instance.features_set?('USE_LONGLONG')
+        if Config.instance.features_set?('USE_LONGLONG') || Config.instance.wx_version >= '3.3.0'
           # wxLongLong mapping to be considered before considering 'long' (see typecheck precedence)
           spec.map 'const wxLongLong&' => 'Integer' do
             map_in temp: 'wxLongLong tmp', code: <<~__CODE
@@ -162,7 +162,7 @@ module WXRuby3
           end
         else
           spec.ignore 'wxUIntProperty::wxUIntProperty(const wxString &, const wxString &, const wxULongLong &)',
-                      'wxIntProperty::wxUIntProperty(const wxString &, const wxString &, const wxLongLong &)'
+                      'wxIntProperty::wxIntProperty(const wxString &, const wxString &, const wxLongLong &)'
         end
         spec.new_object 'wxArrayStringProperty::CreateEditorDialog'
         spec.suppress_warning(473, 'wxArrayStringProperty::CreateEditorDialog')

data/rakelib/lib/director/property_grid_interface.rb

@@ -39,9 +39,10 @@ module WXRuby3
         spec.extend_interface 'wxPropertyGridInterface',
                               'void SetPropertyValues(const wxVariant &list, const wxPGPropArgCls& defaultCategory = 0)'
         # optionals
-        spec.ignore_unless 'USE_LONGLONG',
-                           'wxPropertyGridInterface::GetPropertyValueAsLongLong',
-                           'wxPropertyGridInterface::GetPropertyValueAsULongLong'
+        unless Config.instance.features_set?('USE_LONGLONG') || Config.instance.wx_version >= '3.3.0'
+          spec.ignore_unless 'wxPropertyGridInterface::GetPropertyValueAsLongLong',
+                             'wxPropertyGridInterface::GetPropertyValueAsULongLong'
+        end
         spec.ignore_unless 'USE_DATETIME', 'wxPropertyGridInterface::GetPropertyValueAsDateTime'
         spec.ignore_unless 'USE_VALIDATORS', 'wxPropertyGridInterface::GetPropertyValidator'
         # fix incorrect XML documentation

data/rakelib/lib/director/textctrl.rb

@@ -24,6 +24,13 @@ module WXRuby3
           spec.ignore 'wxTextCtrl::GTKGetTextBuffer',
                       'wxTextCtrl::GTKGetEditable'
         end
+        if Config.instance.wx_version >= '3.3.0' && Config.instance.wx_port == :wxmsw
+          spec.items << 'wxTextSearch' << 'wxTextSearchResult'
+          spec.regard 'wxTextSearchResult::m_start', 'wxTextSearchResult::m_end'
+          spec.make_readonly 'wxTextSearchResult::m_start', 'wxTextSearchResult::m_end'
+          spec.rename_for_ruby 'start' => 'wxTextSearchResult::m_start',
+                               'end' => 'wxTextSearchResult::m_end'
+        end
         if Config.instance.wx_port == :wxqt
           # not implemented
           spec.ignore 'wxTextCtrl::OnDropFiles'

data/rakelib/lib/director/tip_window.rb

@@ -0,0 +1,34 @@
+# Copyright (c) 2023 M.J.N. Corino, The Netherlands
+#
+# This software is released under the MIT license.
+
+###
+# wxRuby3 wxWidgets interface director
+###
+
+require_relative './window'
+
+module WXRuby3
+
+  class Director
+
+    class TipWindow < Window
+
+      def setup
+        super
+        spec.disable_proxies
+        spec.ignore 'wxTipWindow::SetTipWindowPtr'
+        spec.ignore 'wxTipWindow::wxTipWindow'
+        spec.add_extend_code 'wxTipWindow', <<~__HEREDOC
+          wxTipWindow(wxWindow* parent, const wxString& text, wxCoord maxLength = 100)
+          {
+            return new wxTipWindow(parent, text, maxLength);
+          }   
+          __HEREDOC
+      end
+
+    end
+
+  end
+
+end

data/rakelib/lib/director/variant.rb

@@ -142,7 +142,7 @@ module WXRuby3
                 {
                   return wxVariant(TYPE(rbval) == T_TRUE);
                 }
-          #ifdef wxUSE_LONGLONG
+          #if !defined(wxUSE_LONGLONG) || (wxUSE_LONGLONG == 1)
                 if ((sizeof(long) < 8) && (TYPE(rbval) == T_BIGNUM) && (rb_big_sign(rbval) == 0))
                 {
                   wxLongLong_t ll = rb_big2ll(rbval);
@@ -227,7 +227,7 @@ module WXRuby3
             $1 = rb_obj_is_kind_of($input, rb_const_get(mWxPG, var_ColourPropertyValue_id()));
           __CODE
         end
-        if Config.instance.features_set?('USE_LONGLONG')
+        if Config.instance.features_set?('USE_LONGLONG') || Config.instance.wx_version >= '3.3.0'
           # wxLongLong mapping to be considered before considering 'long' (see typecheck precedence)
           spec.map 'wxLongLong' => 'Integer' do
             map_in code: <<~__CODE

data/rakelib/lib/director/window.rb

@@ -66,7 +66,6 @@ module WXRuby3
             __CODE
           end
           spec.ignore [
-            'wxWindow::PopEventHandler',
             'wxWindow::SetConstraints',
             'wxWindow::GetHandle',
             'wxWindow::GetSize(int *,int *) const', # no need; prefer the wxSize version
@@ -83,6 +82,15 @@ module WXRuby3
             'wxWindow::Raise',
             'wxWindow::Lower'
           ]
+
+          # Event handler chaining methods; pushed handlers always remain owned by Ruby
+          # wxRuby3 will automatically pop any remaining handlers when windows get deleted
+          # also ignore this
+          spec.ignore 'wxWindow::PopEventHandler', ignore_doc: false
+          # and instead add an argument-less version (will use default argument of C++ impl)
+          # as we do want C++ side to delete any popped handler
+          spec.extend_interface 'wxWindow', 'wxEvtHandler *PopEventHandler()'
+
           # no real docs and can't find actual examples of usage; ignore
           spec.ignore 'wxWindow::GetConstraints', 'wxWindow::SetConstraints'
           # redefine these so a nil parent is accepted

data/rakelib/lib/director.rb

@@ -6,7 +6,6 @@
 # wxRuby3 interface Director class
 ###
 
-require 'ostruct'
 require 'set'
 require 'pathname'
 require 'tempfile'

data/rakelib/lib/extractor/function.rb

@@ -49,6 +49,9 @@ module WXRuby3
           @template_params << txt
         end
         @args_string = element.at_xpath('argsstring').text
+        # transform unified initializers to ctor form (SWIG does not like unified initializers)
+        # (also see ParamDef#extract)
+        @args_string.gsub!(/(\w+(::\w+)*)\s*{([^}]*)}/) { |_| "#{$1}(#{$3})"}
         check_deprecated
         element.xpath('param').each do |node|
           p = ParamDef.new(node)
@@ -370,6 +373,8 @@ module WXRuby3
             end
             if element.at_xpath('defval')
               @default = BaseDef.flatten_node(element.at_xpath('defval'))
+              # transform unified initializers to ctor form (SWIG does not like unified initializers)
+              @default.sub!(/(\w+(::\w+)*)\s*{([^}]*)}/) { |_| "#{$1}(#{$3})"}
             end
           end
         rescue Exception

data/rakelib/lib/generate/doc/evt_handler.yaml

@@ -6,23 +6,42 @@
         - :pattern: !ruby/regexp /.*/
           :replace: ''
     :post:
-      - :pattern: !ruby/regexp /This\s+implies\s+that\s+the\s+event\s+should\s+be\s+allocated\s+on\s+the\s+heap\s+and/
-        :subst: 'This implies'
-      - :pattern: !ruby/regexp /\{Wx::EvtHandler#queue_event\}.*For\s+example:/
+      - :pattern: !ruby/regexp /\,\s+i\.e\.\s+it\s+will\s+delete\s+it\s+itself/
         :subst: ''
-      - :pattern: !ruby/regexp /Note.*problem:/
+      - :pattern: !ruby/regexp /This\s+implies\s+that\s+the\s+event\s+should\s+be\s+allocated.*deleted\s+at\s+any\s+moment\)/
+        :subst: "This implies that the event (or any of it's member objects) should not be used/changed after the function returns (as it can be handled and subsequently discarded at any moment)"
+      - :pattern: !ruby/regexp /\{Wx::EvtHandler#queue_event\}.*not\s+used\s+by\s+the\s+calling\s+thread\s+any\s+more\./
+        :subst: ''
+      - :pattern: !ruby/regexp /Care\s+should\s+still\s+be\s+taken\s+to\s+avoid\s+that\s+some\s+fields.*/
+        :subst: ''
+      - :pattern: !ruby/regexp /Example:/
+        :subst: ''
+      - :pattern: !ruby/regexp /Note\s+that\s+if\s+you\s+want\s+to\s+pass\s+more\s+data.*/
+        :subst: ''
+      - :pattern: !ruby/regexp /Reimplemented\s+in.*/
+        :subst: ''
+:wxEvtHandler.AddPendingEvent:
+  :detail:
+    :post:
+      - :pattern: !ruby/regexp /This\s+function\s+is\s+similar\s+to\s+\{Wx::EvtHandler#queue_event\}.*/
+        :subst: 'This function is similar to {Wx::EvtHandler#queue_event}.'
+      - :pattern: !ruby/regexp /A\s+copy\s+of\s+event\s+is\s+made\s+by\s+the\s+function,.*/
+        :subst: 'Other than {Wx::EvtHandler#queue_event} this method creates a (shallow) copy of event before queueing the copied event. In case (user defined) event classes require deep copying of Ruby member object these classes should override the #initialize_clone method (**NOT** #clone as wxRuby3 does not currently support overriding event class #clone methods).'
+      - :pattern: !ruby/regexp /Reimplemented\s+in.*/
         :subst: ''
 :wxEvtHandler.SetNextHandler:
+  :brief:
+    :post:
+      - :pattern: !ruby/regexp /Sets\s+the\s+pointer\s+to\s+the\s+next\s+handler\./
+        :subst: 'Inserts the given handler as the next handler in the chain.'
   :detail:
     :pre:
-      :programlisting:
-        - :pattern: !ruby/regexp /.*/
-          :replace: |
-            
-            ```ruby
-              handlerA.set_next_handler(handlerB)
-              handlerB.set_previous_handler(handlerA)
-            ```
+      :para:
+        - :pattern: !ruby/regexp /See.*ProcessEvent\(\)/
+          :replace:  |
+            In wxRuby this fully handles double linking, i.e. wxRuby will take care of pointing the handler given
+            back to this handler as well. There is no need to call set_previous_handler so this method is not supported 
+            in wxRuby3.
 :wxEvtHandler.TryBefore:
   :detail:
     :pre:

data/rakelib/lib/specs/interfaces.rb

@@ -201,6 +201,7 @@ module WXRuby3
     Director.Spec(pkg, 'wxDragDrop', requirements: %w[USE_DRAG_AND_DROP])
     Director.Spec(pkg, 'wxContextHelpButton', requirements: %w[USE_HELP])
     Director.Spec(pkg, 'wxHelpProvider', requirements: %w[USE_HELP])
+    Director.Spec(pkg, 'wxTipWindow', requirements: %w[USE_HELP])
     Director.Spec(pkg, 'wxHelpController', requirements: %w[USE_HELP])
     Director.Spec(pkg, 'wxExtHelpController', director: Director::HelpController, requirements: %w[USE_HELP])
     Director.Spec(pkg, 'wxTaskBarIconEvent', director: Director::Event, requirements: %w[USE_TASKBARICON])

data/rakelib/lib/typemap/common.rb

@@ -364,7 +364,7 @@ module WXRuby3
               }
           __CODE
           map_directorout code: <<~__CODE
-            if (TYPE($input) != T_ARRAY)
+            if (TYPE($input) == T_ARRAY)
             {
               for (int i = 0; i < RARRAY_LEN($input); i++)
               {
@@ -398,7 +398,7 @@ module WXRuby3
             }
             __CODE
           map_directorout code: <<~__CODE
-            if (TYPE($input) != T_ARRAY)
+            if (TYPE($input) == T_ARRAY)
             {
               for (int i = 0; i < RARRAY_LEN($input); i++)
               {

data/samples/dialogs/dialogs.rb

@@ -167,7 +167,7 @@ module Dialogs
       end
 
       create(parent, -1, "Preferences")
-      create_buttons(Wx::ID_OK|Wx::ID_CANCEL)
+      create_buttons(Wx::OK|Wx::CANCEL)
       book_ctrl.set_images(imgs)
       book_ctrl.add_page(file_panel(book_ctrl), "File", false, img_id1)
       book_ctrl.add_page(cdrom_panel(book_ctrl), "CD ROM", false, img_id2)

data/tests/test_combo_ctrl.rb

@@ -23,6 +23,7 @@ class ComboCtrlCtrlTests < WxRuby::Test::GUITests
     end
 
     def create(parent)
+      GC.start
       # need to finish creating the list view here
       # as calling super here would just call Wx::ComboPopup#create and not Wx::ListView#create
       # we need to use Ruby magic