wxruby3 0.9.0.pre.beta.8

data/rakelib/lib/director/event.rb

@@ -0,0 +1,171 @@
+###
+# wxRuby3 wxWidgets interface director
+# Copyright (c) M.J.N. Corino, The Netherlands
+###
+
+module WXRuby3
+
+  class Director
+
+    class Event < Director
+
+      def setup
+        if spec.module_name == 'wxEvent'
+          spec.items << 'wxCommandEvent'
+          # To allow instance variables to be attached to custom subclasses of
+          # Wx::Event written in Ruby in a GC-safe, thread-safe way, wrap a
+          # custom C++ subclass of wxEvent as Ruby's Wx::Event.
+          #
+          # Note that this subclass only applies to Event objects created on the
+          # Ruby side - for the large majority of normal event handling, objects
+          # are created C++ side then given a shallow, transient wrapper for
+          # their use in Ruby - see wxRuby_WrapWxEventInRuby in swig/wx.i.
+          #
+          # make Ruby director and wrappers use custom implementation
+          spec.use_class_implementation('wxEvent', 'wxRubyEvent')
+          spec.extend_interface('wxEvent', 'wxEvent(wxEventType commandType = wxEVT_NULL, int id = 0, int prop_level = wxEVENT_PROPAGATE_NONE)')
+          spec.extend_interface('wxEvent', 'virtual wxEvent* Clone() const')
+          spec.ignore %w[wxEvent::Clone wxEvent::GetEventUserData]
+          spec.ignore 'wxEvent::wxEvent(int,wxEventType)'
+          spec.no_proxy 'wxEvent::Clone'
+          spec.add_header_code <<~__HEREDOC
+            // Custom subclass implementation. Provide a constructor, destructor and
+            // clone functions to allow proper linking to a Ruby object.
+            class WXRUBY_EXPORT wxRubyEvent : public wxEvent
+            {
+              public:
+              wxRubyEvent(wxEventType commandType = wxEVT_NULL, 
+                          int id = 0,
+                          int prop_level = wxEVENT_PROPAGATE_NONE) : 
+                wxEvent(id, commandType) {  m_propagationLevel = prop_level; }
+              wxRubyEvent(const wxRubyEvent& ev) :
+                wxEvent(ev) { }
+            
+              // When the C++ side event is destroyed, unlink from the Ruby object
+              // and remove that object from the tracking hash so it can be
+              // collected by GC.
+              virtual ~wxRubyEvent() {
+                SWIG_RubyUnlinkObjects((void*)this);
+                wxRuby_RemoveTracking((void*)this);
+              }
+            
+              // Will be called when add_pending_event is used to queue an event
+              // (often when using Threads), because a clone is queued. So copy the
+              // Wx C++ event, create a shallow (dup) of the Ruby event object, and
+              // add to the tracking hash so that it is GC-protected
+              virtual wxEvent* Clone() const {
+                wxRubyEvent* wx_ev = new wxRubyEvent( *this );
+            
+                VALUE r_obj = SWIG_RubyInstanceFor((void *)this);
+                VALUE r_obj_dup = rb_obj_clone(r_obj);
+            
+                DATA_PTR(r_obj_dup) = wx_ev;
+                wxRuby_AddTracking( (void*)wx_ev, r_obj_dup );
+                return wx_ev;
+              }
+            };
+            __HEREDOC
+          spec.add_extend_code 'wxEvent', <<~__HEREDOC
+            // This class method provides a guaranteed-unique event id that can be
+            // used for custom event types.
+            static VALUE new_user_event_type()
+            {
+              // make sure to get an id offset from the user events base so we can use that to
+              // to check for user defined events  
+              static int s_lastUsedUserEventType = wxEVT_USER_FIRST;
+
+              int event_type_id = ++s_lastUsedUserEventType;
+              return INT2NUM(event_type_id);
+            }
+            __HEREDOC
+          # make Ruby director and wrappers use custom implementation
+          spec.use_class_implementation('wxCommandEvent', 'wxRubyCommandEvent')
+          spec.ignore %w{
+            wxCommandEvent::GetClientObject
+            wxCommandEvent::SetClientObject
+            wxCommandEvent::GetExtraLong
+          }
+          spec.extend_interface('wxCommandEvent', 'virtual wxCommandEvent* Clone() const')
+          spec.no_proxy 'wxCommandEvent::Clone'
+          spec.add_header_code <<~__HEREDOC
+            // Cf wxEvent - has to be written as a C+++ subclass to ensure correct
+            // GC/thread protection of Ruby instance variables when user-written
+            // event classes are queued.
+            //
+            //
+            // FIXME : intermittent errors with CommandEvent losing the tracked
+            // object before handling - though the same code works fine with Wx::Event
+            class WXRUBY_EXPORT wxRubyCommandEvent : public wxCommandEvent
+            {
+            public:
+              wxRubyCommandEvent(wxEventType commandType = wxEVT_NULL, 
+                                 int id = 0) : 
+                wxCommandEvent(commandType, id) { }
+              wxRubyCommandEvent(const wxRubyCommandEvent& cev) :
+                wxCommandEvent(cev) { }
+            
+              // When the C++ side event is destroyed, unlink from the Ruby object
+              // and remove that object from the tracking hash so it can be
+              // collected by GC.
+              virtual ~wxRubyCommandEvent() {
+                SWIG_RubyUnlinkObjects((void*)this);
+                wxRuby_RemoveTracking((void*)this);
+              }
+            
+              // Will be called when add_pending_event is used to queue an event
+              // (often when using Threads), because a clone is queued. So copy the
+              // Wx C++ event, create a shallow (dup) of the Ruby event object, and
+              // add to the tracking hash so that it is GC-protected
+              virtual wxCommandEvent* Clone() const {
+                wxRubyCommandEvent* wx_ev = new wxRubyCommandEvent(*this);
+            
+                VALUE r_obj = SWIG_RubyInstanceFor((void *)this);
+                VALUE r_obj_dup = rb_obj_clone(r_obj);
+            
+                DATA_PTR(r_obj_dup) = wx_ev;
+                wxRuby_AddTracking( (void*)wx_ev, r_obj_dup );
+                return wx_ev;
+              }
+            };
+            __HEREDOC
+          spec.add_wrapper_code <<~__HEREDOC
+            extern VALUE wxRuby_GetDefaultEventClass () {
+              return SwigClassWxEvent.klass;
+            }
+            __HEREDOC
+          spec.ignore 'wxQueueEvent'
+          spec.set_only_for 'wxUSE_HOTKEY', 'wxEVT_HOTKEY'
+          # make sure this event constant definition exists
+          spec.add_swig_code %Q{%constant wxEventType wxEVT_MENU_HIGHLIGHT_ALL = wxEVT_MENU_HIGHLIGHT;}
+          # add event type constant missing from interface defs
+          spec.add_swig_code %Q{%constant wxEventType wxEVT_NC_PAINT = wxEVT_NC_PAINT;}
+        end
+        super
+      end
+
+      def process(gendoc: false)
+        defmod = super
+        spec.items.each do |citem|
+          unless citem == 'wxEvent'
+            def_item = defmod.find_item(citem)
+            if Extractor::ClassDef === def_item
+              if def_item.hierarchy.has_key?('wxEvent')
+                spec.override_inheritance_chain(citem, {'wxEvent' => 'wxEvent'}, 'wxObject')
+              elsif def_item.hierarchy.has_key?('wxCommandEvent')
+                spec.override_inheritance_chain(citem, {'wxCommandEvent' => 'wxEvent'}, 'wxEvent', 'wxObject')
+              elsif def_item.hierarchy.has_key?('wxGestureEvent')
+                spec.override_inheritance_chain(citem, {'wxGestureEvent' => 'wxEvents'}, 'wxEvent', 'wxObject')
+              elsif def_item.hierarchy.has_key?('wxNotifyEvent')
+                spec.override_inheritance_chain(citem, {'wxNotifyEvent' => 'wxEvents'}, {'wxCommandEvent' => 'wxEvent'}, 'wxEvent', 'wxObject')
+              end
+              spec.make_abstract(citem) if citem == 'wxPaintEvent' # doc flaw
+            end
+          end
+        end
+        defmod
+      end
+    end # class Event
+
+  end # class Director
+
+end # module WXRuby3

data/rakelib/lib/director/event_handler.rb

@@ -0,0 +1,410 @@
+###
+# wxRuby3 wxWidgets interface director
+# Copyright (c) M.J.N. Corino, The Netherlands
+###
+
+module WXRuby3
+
+  class Director
+
+    class EvtHandler < Director
+
+      def setup
+        super
+        # update generated code for all event handlers
+        spec.post_processors << :update_evthandler
+        if spec.module_name == 'wxEvtHandler'
+          # fully ignore
+          spec.ignore(
+              'wxEvtHandler::Connect',
+              'wxEvtHandler::Disconnect')
+          spec.ignore(%w[wxEVT_HOTKEY])
+          spec.ignore(%w[wxEvtHandler::SetClientData wxEvtHandler::GetClientData
+                         wxEvtHandler::SetClientObject wxEvtHandler::GetClientObject])
+          # Do not see much point in allowing/supporting this to be overridden when we
+          # 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
+          # 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
+          spec.add_runtime_code <<~__HEREDOC
+            static swig_class wxRuby_GetSwigClassWxEvtHandler();
+            WXRUBY_EXPORT VALUE wxRuby_GetEventTypeClassMap();
+
+            class wxRbCallback;
+            static void wxRuby_ReleaseEvtHandlerProc(void* evt_handler, wxRbCallback* proc_cb);
+            
+            // Class which stores the ruby proc associated with an event handler. We
+            // also cache the "call" symbol as this improves speed for event
+            // handlers which are called many times (eg evt_motion)
+            class wxRbCallback : public wxObject 
+            {
+            public:
+                wxRbCallback(VALUE func, void* evh) 
+                  : m_func(func), m_evh(evh) {}
+                wxRbCallback(const wxRbCallback &other) 
+                  : wxObject(), m_func(other.m_func), m_evh(other.m_evh) {}
+                ~wxRbCallback()
+                { wxRuby_ReleaseEvtHandlerProc(m_evh, this); }
+            
+                // This method handles all events on the WxWidgets/C++ side. It link
+                // inspects the event and based on the event's type wraps it in the
+                // appropriate class (the mapping can be found in
+                // lib/wx/classes/evthandler.rb). This wrapped event is then passed
+                // into the ruby proc for handling on the ruby side
+                void EventThunker(wxEvent &event)
+                {
+                  static WxRuby_ID call_id("call");
+
+            #ifdef __WXRB_DEBUG__                
+                  VALUE rb_event = wxRuby_WrapWxEventInRuby(0, &event);
+            #else
+                  VALUE rb_event = wxRuby_WrapWxEventInRuby(&event);
+            #endif
+                  wxRbCallback *cb = (wxRbCallback *)event.m_callbackUserData;
+                  bool ex_caught = false;
+                  VALUE rc = wxRuby_Funcall(ex_caught, cb->m_func, call_id(), 1, rb_event);
+                  if (ex_caught)
+                  {
+            #ifdef __WXRB_DEBUG__                
+                    if (!rb_obj_is_kind_of(rc, rb_eSystemExit) && wxRuby_TraceLevel()>0)
+                    {
+                      wxRuby_PrintException(rc);
+                    }
+            #endif
+                    wxRuby_ExitMainLoop(rc);
+                  }
+                }
+            
+                VALUE m_func;
+                void* m_evh;
+            };
+  
+            // Internally, all event handlers are anonymous ruby Proc objects,
+            // created by EvtHandler#connect. These need to be preserved from Ruby's
+            // GC until the EvtHandler object itself is destroyed. So we keep a hash
+            // which maps C++ pointer addresses of EvtHandlers to lists of
+            // the callback objects created to handle their events.
+            typedef wxVector<wxRbCallback*> EvtHandlerProcList;
+            typedef EvtHandlerProcList* EvtHandlerProcListPtr;
+            WX_DECLARE_VOIDPTR_HASH_MAP(EvtHandlerProcListPtr, PtrToEvtHandlerProcs);
+            PtrToEvtHandlerProcs Evt_Handler_Handlers;
+            
+            // Add a proc to the list of protected handler for an EvtHandler object
+            void wxRuby_ProtectEvtHandlerProc(void* evt_handler, wxRbCallback* proc_cb) 
+            {
+              if (Evt_Handler_Handlers.count(evt_handler) == 0)
+                Evt_Handler_Handlers[evt_handler] = new EvtHandlerProcList();
+              Evt_Handler_Handlers[evt_handler]->push_back(proc_cb);
+            }
+            
+            static void wxRuby_ReleaseEvtHandlerProc(void* evt_handler, wxRbCallback* proc_cb) 
+            {        
+              if (Evt_Handler_Handlers.count(evt_handler) != 0)
+              {
+                EvtHandlerProcList *ehpl = Evt_Handler_Handlers[evt_handler];
+                for (EvtHandlerProcList::iterator itproc = ehpl->begin();
+                     itproc != ehpl->end();
+                     itproc++)
+                {
+                  if (proc_cb == (*itproc))
+                  {
+                    ehpl->erase(itproc);
+                    return;
+                  }
+                }
+              }
+            }
+
+            // Called by App's mark function; protect all currently needed procs
+            void wxRuby_MarkProtectedEvtHandlerProcs() 
+            {
+              PtrToEvtHandlerProcs::iterator it;
+              for( it = Evt_Handler_Handlers.begin(); 
+                   it != Evt_Handler_Handlers.end(); 
+                   ++it )
+              {
+                for (EvtHandlerProcList::iterator itproc = it->second->begin();
+                     itproc != it->second->end();
+                     itproc++)
+                {
+                  rb_gc_mark((*itproc)->m_func);
+                }
+              }
+            }
+            
+            // Called when a Window (or other event handler) is destroyed; allows handler procs associated
+            // with this object to be garbage collected at next run. See
+            // swig/mark_free_impl.i
+            WXRUBY_EXPORT void wxRuby_ReleaseEvtHandlerProcs(void* evt_handler) 
+            {
+              if (Evt_Handler_Handlers.count(evt_handler) != 0)
+              {
+                delete Evt_Handler_Handlers[evt_handler];
+                Evt_Handler_Handlers.erase(evt_handler);
+              }
+            }
+
+            static WxRuby_ID __wxrb_method_id("method");
+            static WxRuby_ID __wxrb_try_before_id("try_before");
+            static WxRuby_ID __wxrb_try_after_id("try_after");
+            static WxRuby_ID __wxrb_source_location_id("source_location");
+
+            WXRUBY_EXPORT bool wxRuby_IsNativeMethod(VALUE object, ID method_id)
+            {
+              return Qnil == rb_funcall(rb_funcall(object, __wxrb_method_id(), 1, ID2SYM(method_id)), 
+                                        __wxrb_source_location_id(), 
+                                        0);
+            }
+            __HEREDOC
+          spec.add_header_code <<~__HEREDOC
+            class RbAsyncProcCallEvent : public wxAsyncMethodCallEvent
+            {
+            public:
+              RbAsyncProcCallEvent(wxObject* evtObj, VALUE call) 
+                : wxAsyncMethodCallEvent(evtObj)
+                , m_rb_call(call)
+              {}
+  
+              RbAsyncProcCallEvent(const RbAsyncProcCallEvent& other)
+                : wxAsyncMethodCallEvent(other)
+                , m_rb_call(other.m_rb_call)
+              {}
+  
+              virtual ~RbAsyncProcCallEvent()
+              {
+                wxRuby_RemoveTracking((void*)this);
+              }
+  
+              virtual wxEvent *Clone() const wxOVERRIDE
+              {
+                return new RbAsyncProcCallEvent(*this);
+              }
+          
+              virtual void Execute() wxOVERRIDE
+              {
+                static WxRuby_ID call_id("call");
+    
+                bool ex_caught = false;
+                VALUE rc;
+                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);
+                }
+                else
+                {
+                  rc = wxRuby_Funcall(ex_caught, m_rb_call, call_id(), (int)0);
+                }
+                if (ex_caught)
+                {
+            #ifdef __WXRB_DEBUG__                
+                  if (!rb_obj_is_kind_of(rc, rb_eSystemExit) && wxRuby_TraceLevel()>0)
+                  {
+                    wxRuby_PrintException(rc);
+                  }
+            #endif
+                  wxRuby_ExitMainLoop(rc);
+                }
+              }
+          
+            private:
+              VALUE m_rb_call;
+            };
+            __HEREDOC
+          spec.add_extend_code 'wxEvtHandler', <<~__HEREDOC
+            // This provides the public Ruby 'connect' method
+            VALUE connect(int firstId, int lastId, wxEventType eventType, VALUE proc)
+            {
+              wxRbCallback* userData = new wxRbCallback(proc, (void *)$self);
+              wxRuby_ProtectEvtHandlerProc((void *)$self, userData);
+          
+              wxObjectEventFunction function = 
+                  (wxObjectEventFunction )&wxRbCallback::EventThunker;
+              $self->Connect(firstId, lastId, eventType, function, userData);
+              return Qtrue;
+            }
+          
+            // Implementation of disconnect, accepting either an EVT_XXX constant
+            // or a symbol name of an event handler method
+            VALUE disconnect(int firstId, 
+                     int lastId = wxID_ANY, 
+                     VALUE evtSpecifier = Qnil)
+            {
+              static WxRuby_ID event_type_for_name_id("event_type_for_name");
+
+              wxEventType event_type;
+            
+              if ( TYPE(evtSpecifier) == T_FIXNUM ) // simply an Integer id
+                event_type = NUM2INT(evtSpecifier);
+              else if ( TYPE(evtSpecifier) == T_NIL ) // Not defined = any type
+                event_type = wxEVT_NULL;
+              else if ( TYPE(evtSpecifier) == T_SYMBOL ) // Symbol handler method
+              {
+                VALUE rb_evt_type = rb_funcall(wxRuby_GetSwigClassWxEvtHandler().klass, 
+                                               event_type_for_name_id(),
+                                               1, evtSpecifier);
+                if ( rb_evt_type != Qnil )
+                  event_type = NUM2INT( rb_evt_type );
+                else
+                {
+                  VALUE msg = rb_inspect(evtSpecifier);
+                  rb_raise(rb_eTypeError, "Unknown event handler %s", 
+                                StringValuePtr(msg));
+                }
+              }
+              else 
+                rb_raise(rb_eTypeError, "Invalid specifier for event type");
+          
+              if ( $self->Disconnect(firstId, lastId, event_type))
+                return Qtrue;
+              else
+                return Qfalse;
+            }
+  
+            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)
+                     ||
+                     rb_obj_is_kind_of(proc, rb_cMethod)))
+              {
+                // create C++ event
+                RbAsyncProcCallEvent * evt = new RbAsyncProcCallEvent(self, call);
+                // track it and the call object
+                wxRuby_AddTracking( (void*)evt, call);
+                // queue it
+                self->QueueEvent(evt);
+              }
+            }
+            __HEREDOC
+          spec.add_wrapper_code <<~__HEREDOC
+            static swig_class wxRuby_GetSwigClassWxEvtHandler() {
+              return SwigClassWxEvtHandler;
+            }     
+  
+            WXRUBY_EXPORT VALUE wxRuby_GetEventTypeClassMap() {
+              VALUE map_name = rb_str_new2("EVENT_TYPE_CLASS_MAP");
+              return rb_const_get(wxRuby_GetSwigClassWxEvtHandler().klass, rb_to_id(map_name)); 
+            }
+            __HEREDOC
+          spec.do_not_generate :typedefs, :variables, :enums, :defines, :functions
+        else
+          spec.items.each do |itm|
+            # Avoid adding unneeded directors
+            spec.no_proxy("#{spec.class_name(itm)}::ProcessEvent") unless /\.h\Z/ =~ itm
+          end
+          spec.add_header_code <<~__HEREDOC
+            static WxRuby_ID __wxrb_try_before_id("try_before");
+            static WxRuby_ID __wxrb_try_after_id("try_after");
+            __HEREDOC
+        end
+      end
+    end # class EvtHandler
+
+  end # class Director
+
+  module SwigRunner
+    class Processor
+
+      # Special post-processor for EvtHandler and derivatives.
+      # This provides both an optimization and extra safe guarding for the
+      # event processing path in wxRuby.
+      # The processor inserts code in the 'TryXXX' methods of the director class which check
+      # for existence of any Ruby implementation of these methods ('try_before' or 'try_after')
+      # in the absence of which a direct call to the wxWidget implementation is made. If there
+      # does exist a Ruby ('override') implementation the method continues and calls the Ruby
+      # method implementation.
+      # The original wxWidget implementations are available in Ruby as 'wx_try_before' and
+      # 'wx_try_after' and can be called from the 'overrides'.
+      # Additionally the inserted code first off checks if the event handler is actually (still)
+      # able to handle events by calling wxRuby_FindTracking() since in wxRuby it is in rare occasions
+      # possible the event handler instance gets garbage collected AFTER the event processing
+      # path has started in which case the C++ and Ruby object are unlinked and any attempts to
+      # access the (originally) associated Ruby object will have bad results (this is especially
+      # true for dialogs which are not cleaned up by wxWidgets but rather garbage collected by Ruby).
+      class UpdateEvthandler < Processor
+
+        def run
+          at_director_method = false
+          director_method_id = nil
+          director_wx_class = nil
+          director_method_line = 0
+
+          prev_line = nil
+
+          update_source(at_end: ->(){ prev_line }) do |line|
+            if at_director_method
+              director_method_line += 1   # update line counter
+              if director_method_line == 4 && line.strip.empty?   # are we at the right spot?
+                code = <<~__CODE     # insert the code update
+                // added by wxRuby3 Processor.update_evthandler
+                // if Ruby object not registered anymore or no Ruby defined method override
+                // reroute directly to C++ method
+                if (Qnil == wxRuby_FindTracking(this) || wxRuby_IsNativeMethod(swig_get_self(), __wxrb_try_#{director_method_id.downcase}_id()))
+                {
+                  return this->#{director_wx_class}::Try#{director_method_id}(event);
+                }
+                __CODE
+                line << "\n  " << code.split("\n").join("\n  ")
+                at_director_method = false  # end of update
+              end
+            elsif /bool\s+SwigDirector_(\w+)::Try(Before|After)\(.*\)\s+{/ =~ line
+              director_wx_class = $1 == 'App' ? 'wxApp' : $1
+              director_method_id = $2     # After or Before method?
+              at_director_method = true   # we're at a director method to be updated
+              director_method_line = 0    # keep track of the method lines
+            end
+
+            result = prev_line
+            prev_line = line
+            result
+          end
+        end
+
+      end # class UpdateEvthandler
+
+    end
+  end
+
+end # module WXRuby3

data/rakelib/lib/director/events.rb

@@ -0,0 +1,39 @@
+###
+# wxRuby3 wxWidgets interface director
+# Copyright (c) M.J.N. Corino, The Netherlands
+###
+
+require_relative './event'
+
+module WXRuby3
+
+  class Director
+
+    class Events < Event
+
+      def setup
+        super
+        spec.items.replace(%w[
+          wxIdleEvent wxNotifyEvent wxScrollEvent wxScrollWinEvent wxMouseEvent wxMouseState
+          wxSetCursorEvent wxGestureEvent wxPanGestureEvent wxZoomGestureEvent wxRotateGestureEvent
+          wxTwoFingerTapEvent wxLongPressEvent wxPressAndTapEvent wxKeyEvent wxKeyboardState
+          wxSizeEvent wxMoveEvent wxPaintEvent wxEraseEvent wxFocusEvent wxActivateEvent
+          wxInitDialogEvent wxMenuEvent wxCloseEvent wxShowEvent wxIconizeEvent wxMaximizeEvent
+          wxFullScreenEvent wxJoystickEvent wxDropFilesEvent wxUpdateUIEvent wxSysColourChangedEvent
+          wxMouseCaptureChangedEvent wxMouseCaptureLostEvent wxDisplayChangedEvent wxDPIChangedEvent
+          wxPaletteChangedEvent wxQueryNewPaletteEvent wxNavigationKeyEvent wxWindowCreateEvent
+          wxWindowDestroyEvent wxHelpEvent wxClipboardTextEvent wxContextMenuEvent wxChildFocusEvent
+          ])
+        spec.fold_bases('wxMouseEvent' => 'wxMouseState', 'wxKeyEvent' => 'wxKeyboardState')
+        spec.set_only_for 'WXWIN_COMPATIBILITY_2_8', 'wxShowEvent::GetShow', 'wxIconizeEvent::Iconized'
+        spec.ignore 'wxKeyEvent::GetPosition(wxCoord *,wxCoord *) const'
+        spec.ignore 'wxMouseState::GetPosition(int *,int *)'
+        spec.ignore 'wxShowEvent::GetShow', 'wxIconizeEvent::Iconized'
+        spec.do_not_generate(:variables, :defines, :enums, :functions)
+      end
+
+    end # class Events
+
+  end # class Director
+
+end # module WXRuby3

data/rakelib/lib/director/file_picker_ctrl.rb

@@ -0,0 +1,22 @@
+###
+# wxRuby3 wxWidgets interface director
+# Copyright (c) M.J.N. Corino, The Netherlands
+###
+
+require_relative './window'
+
+module WXRuby3
+
+  class Director
+
+    class FilePickerCtrl < Window
+
+      def setup
+        super
+        spec.do_not_generate(:variables, :defines, :enums, :functions) # with FileDirPickerEvent
+      end
+    end # class FilePickerCtrl
+
+  end # class Director
+
+end # module WXRuby3

data/rakelib/lib/director/find_dialog_event.rb

@@ -0,0 +1,22 @@
+###
+# wxRuby3 wxWidgets interface director
+# Copyright (c) M.J.N. Corino, The Netherlands
+###
+
+require_relative './event'
+
+module WXRuby3
+
+  class Director
+
+    class FindDialogEvent < Director::Event
+
+      def setup
+        super
+      end
+
+    end # class FindDialogEvent
+
+  end # class Director
+
+end # module WXRuby3

data/rakelib/lib/director/find_replace_data.rb

@@ -0,0 +1,20 @@
+###
+# wxRuby3 wxWidgets interface director
+# Copyright (c) M.J.N. Corino, The Netherlands
+###
+
+module WXRuby3
+
+  class Director
+
+    class FindReplaceData < Director
+
+      def setup
+        super
+        spec.do_not_generate(:variables, :enums)
+      end
+    end # class FindReplaceData
+
+  end # class Director
+
+end # module WXRuby3