wxruby3 0.9.0.pre.beta.8

data/rakelib/lib/director/vscrolled_window.rb

@@ -0,0 +1,59 @@
+###
+# wxRuby3 wxWidgets interface director
+# Copyright (c) M.J.N. Corino, The Netherlands
+###
+
+require_relative './window'
+
+module WXRuby3
+
+  class Director
+
+    class VScrolledWindow < Window
+
+      def setup
+        super
+        spec.items << 'wxVarVScrollHelper' << 'wxVarScrollHelperBase'
+        spec.override_inheritance_chain('wxVScrolledWindow', %w[wxPanel wxWindow wxEvtHandler wxObject])
+        spec.fold_bases('wxVScrolledWindow' => %w[wxVarVScrollHelper wxVarScrollHelperBase])
+        spec.make_abstract 'wxVScrolledWindow'
+        spec.force_proxy 'wxVScrolledWindow'
+        # provide base implementation for OnGetRowHeight
+        spec.add_header_code <<~__HEREDOC
+          // Custom subclass implementation. 
+          class wxRubyVScrolledWindow : public wxVScrolledWindow
+          {
+          public:
+            wxRubyVScrolledWindow() 
+              : wxVScrolledWindow () {}
+            wxRubyVScrolledWindow(wxWindow *parent, wxWindowID id=wxID_ANY, const wxPoint &pos=wxDefaultPosition, const wxSize &size=wxDefaultSize, long style=0, const wxString &name=wxPanelNameStr)
+              : wxVScrolledWindow(parent, id, pos, size, style, name) {}
+          protected:
+            virtual wxCoord OnGetRowHeight(size_t) const
+            {
+              rb_raise(rb_eNoMethodError, "Not implemented");
+            }
+          };
+        __HEREDOC
+        # make Ruby director and wrappers use custom implementation
+        spec.use_class_implementation('wxVScrolledWindow', 'wxRubyVScrolledWindow')
+        # ignore pure virtual base methods
+        spec.ignore 'wxVarScrollHelperBase::GetNonOrientationTargetSize',
+                    'wxVarScrollHelperBase::GetOrientation',
+                    'wxVarScrollHelperBase::GetOrientationTargetSize',
+                    'wxVarScrollHelperBase::OnGetUnitSize'
+        # extend derived interface with base implementation overrides
+        spec.extend_interface 'wxVScrolledWindow',
+                              'virtual int GetNonOrientationTargetSize() const',
+                              'virtual wxOrientation GetOrientation() const',
+                              'virtual int GetOrientationTargetSize() const'
+        spec.extend_interface 'wxVScrolledWindow',
+                              'virtual wxCoord OnGetUnitSize(size_t unit) const',
+                              visibility: 'protected'
+        spec.suppress_warning(473, 'wxVScrolledWindow::GetTargetWindow')
+      end
+    end # class Panel
+
+  end # class VScrolledWindow
+
+end # module WXRuby3

data/rakelib/lib/director/window.rb

@@ -0,0 +1,296 @@
+###
+# wxRuby3 wxWidgets interface director
+# Copyright (c) M.J.N. Corino, The Netherlands
+###
+
+require_relative './event_handler'
+
+module WXRuby3
+
+  class Director
+
+    class Window < EvtHandler
+
+      def setup
+        super
+        # for all wxWindow derived classes (not wxFrame and descendants)
+        spec.items.each do |itm|
+          # Avoid adding unneeded directors
+          spec.no_proxy("#{itm}::AddChild",
+                        "#{itm}::Fit",
+                        "#{itm}::FitInside",
+                        "#{itm}::Freeze",
+                        "#{itm}::GetBackgroundStyle",
+                        "#{itm}::GetCharHeight",
+                        "#{itm}::GetCharWidth",
+                        "#{itm}::GetLabel",
+                        "#{itm}::GetName",
+                        "#{itm}::GetScreenPosition",
+                        "#{itm}::GetScrollPos",
+                        "#{itm}::GetScrollRange",
+                        "#{itm}::GetScrollThumb",
+                        "#{itm}::GetTextExtent",
+                        "#{itm}::HasCapture",
+                        "#{itm}::HasMultiplePages",
+                        "#{itm}::IsDoubleBuffered",
+                        "#{itm}::IsEnabled",
+                        "#{itm}::IsFrozen",
+                        "#{itm}::IsRetained",
+                        "#{itm}::IsShown",
+                        "#{itm}::IsShownOnScreen",
+                        "#{itm}::ReleaseMouse",
+                        "#{itm}::RemoveChild",
+                        "#{itm}::ScrollLines",
+                        "#{itm}::ScrollPages",
+                        "#{itm}::ScrollWindow",
+                        "#{itm}::SetAcceleratorTable",
+                        "#{itm}::SetBackgroundColour",
+                        "#{itm}::SetBackgroundStyle",
+                        "#{itm}::SetCursor",
+                        "#{itm}::SetFocus",
+                        "#{itm}::SetFocusFromKbd",
+                        "#{itm}::SetFont",
+                        "#{itm}::SetForegroundColour",
+                        "#{itm}::SetHelpText",
+                        "#{itm}::SetLabel",
+                        "#{itm}::SetName",
+                        "#{itm}::SetScrollPos",
+                        "#{itm}::SetScrollbar",
+                        "#{itm}::SetThemeEnabled",
+                        "#{itm}::SetThemeEnabled",
+                        "#{itm}::SetValidator",
+                        "#{itm}::SetWindowStyleFlag",
+                        "#{itm}::ShouldInheritColour",
+                        "#{itm}::Thaw",
+                        "#{itm}::Layout",
+                        "#{itm}::InheritAttributes",
+                        "#{itm}::GetDefaultAttributes",
+                        "#{itm}::GetWindowStyleFlag",
+                        "#{itm}::GetDropTarget",
+                        "#{itm}::GetValidator",
+                        "#{itm}::IsTopLevel",
+                        "#{itm}::EnableTouchEvents") unless /\.h\Z/ =~ itm
+        end
+
+        case spec.module_name
+        when 'wxWindow' # only for actual wxWindow class
+          # // Any of these following kind of objects become owned by the window
+          # // when passed into Wx, and so will be deleted automatically; using
+          # // DISOWN resets their %freefunc to avoid deleting the object twice
+          spec.disown 'wxCaret* caret', 'wxSizer* sizer', 'wxToolTip* tip', 'wxDropTarget* target'
+          # do not allow SetSizer and SetSizerAndFit to leave the 'old' sizer unattached alive
+          spec.map 'wxSizer *sizer, bool deleteOld' => 'Wx::Sizer' do
+            map_in code: <<~__CODE
+                int res = SWIG_ConvertPtr($input, SWIG_as_voidptrptr(&$1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN);
+                if (!SWIG_IsOK(res)) {
+                  SWIG_exception_fail(SWIG_ArgError(res), Ruby_Format_TypeError( "", "wxSizer *","SetSizer", 2, $input));
+                }
+                $2 = true; // always delete 'old' sizer
+              __CODE
+          end
+          spec.add_extend_code 'wxWindow', <<~__HEREDOC
+            VALUE SwitchSizer(VALUE new_szr)
+            {
+              wxSizer *new_wx_szr = 0;
+              int res = SWIG_ConvertPtr(new_szr, SWIG_as_voidptrptr(&new_wx_szr), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN);
+              if (!SWIG_IsOK(res)) {
+                SWIG_Error(SWIG_ArgError(res), Ruby_Format_TypeError( "", "wxSizer *","SetSizer", 2, new_szr));
+                return Qnil;
+              }
+              wxSizer* old_szr = self->GetSizer();
+              self->SetSizer(new_wx_szr, false);
+              return SWIG_NewPointerObj(old_szr, SWIGTYPE_p_wxSizer, 1); // return owned wrapper for old sizer
+            }
+            __HEREDOC
+          spec.new_object 'wxWindow::SwitchSizer'
+          # Typemap for GetChildren - casts wxObjects to correct ruby wrappers
+          spec.map 'wxWindowList&' => 'Array<Wx::Window>' do
+            map_out code: <<~__CODE
+              $result = rb_ary_new();
+              wxWindowList::compatibility_iterator node = $1->GetFirst();
+              while (node)
+              {
+                wxObject *obj = node->GetData();
+                rb_ary_push($result, wxRuby_WrapWxObjectInRuby(obj));
+                node = node->GetNext();
+              }
+            __CODE
+          end
+          spec.ignore [
+            'wxWindow::TransferDataFromWindow',
+            'wxWindow::TransferDataToWindow',
+            'wxWindow::GetAccessible',
+            'wxWindow::PopEventHandler',
+            'wxWindow::SetConstraints',
+            'wxWindow::GetHandle',
+            'wxWindow::GetSize(int *,int *) const', # no need; prefer the wxSize version
+            'wxWindow::GetClientSize(int *,int *) const', # no need; prefer the wxSize version
+            'wxWindow::GetVirtualSize(int *,int *) const', # no need; prefer the wxSize version
+            'wxWindow::GetPosition(int *,int *) const', # no need; prefer the wxPoint version
+            'wxWindow::GetScreenPosition(int *,int *) const', # no need; prefer the wxPoint version
+            'wxWindow::FindWindow',
+            'wxWindow::GetTextExtent(const wxString &,int *,int *,int *,int *,const wxFont *)',
+            'wxWindow::SendIdleEvents',
+            'wxWindow::ClientToScreen(int*,int*)', # no need; prefer the wxPoint version
+            'wxWindow::ScreenToClient(int*,int*)' # no need; prefer the wxPoint version
+          ]
+          if Config.instance.wx_port == :wxQT
+            # protected for wxQT; ignore for now
+            spec.ignore 'wxWindow::EnableTouchEvents'
+          end
+          if Config.instance.wx_version >= '3.3.0'
+            spec.set_only_for('__WXMSW__', 'wxWindow::MSWDisableComposited')
+          end
+          spec.set_only_for('wxUSE_ACCESSIBILITY', 'wxWindow::SetAccessible')
+          spec.set_only_for('wxUSE_HOTKEY', %w[wxWindow::RegisterHotKey wxWindow::UnregisterHotKey])
+          spec.ignore('wxWindow::SetSize(int, int)') # not useful as the wxSize variant will also accept an array
+          spec.swig_import %w{
+            swig/classes/include/wxObject.h
+            swig/classes/include/wxEvtHandler.h
+            swig/classes/include/wxDC.h
+            swig/classes/include/wxWindowDC.h
+            swig/classes/include/wxClientDC.h
+            swig/classes/include/wxPaintDC.h
+          }
+          spec.add_wrapper_code <<~__HEREDOC
+            extern VALUE wxRuby_GetWindowClass() {
+              return SwigClassWxWindow.klass;
+            }
+            __HEREDOC
+          spec.add_extend_code 'wxWindow', <<~__HEREDOC
+            // passes a DC for drawing on Window into a passed ruby block, and
+            // ensure that the DC is correctly deleted when drawing is
+            // completed. This is important to avoid entering an endless loop of
+            // paint events. The DC will be a PaintDC if used within a evt_paint handler
+            // (recommended) or else a ClientDC.
+            VALUE paint()
+            {  
+              static WxRuby_ID painting_id("@__painting__");
+
+              if ( ! rb_block_given_p() )
+              rb_raise(rb_eArgError, "No block given for Window#paint");
+          
+              wxWindow *ptr = self;
+              VALUE rb_win = SWIG_RubyInstanceFor(ptr);
+              // see if within an evt_paint block - see classes/window.rb
+              // if so, supply a PaintDC to the block
+              if ( rb_ivar_defined(rb_win, painting_id()) == Qtrue ) 
+              {
+                wxPaintDC dc(ptr);
+                VALUE dcVal = SWIG_NewPointerObj((void *) &dc,SWIGTYPE_p_wxPaintDC, 0);
+                rb_yield(dcVal);
+                SWIG_RubyRemoveTracking((void *) &dc);
+                DATA_PTR(dcVal) = NULL;
+              }
+              else // supply a ClientDC
+              {
+                wxClientDC dc(ptr);
+                VALUE dcVal = SWIG_NewPointerObj((void *) &dc,SWIGTYPE_p_wxClientDC, 0);
+                rb_yield(dcVal);
+                SWIG_RubyRemoveTracking((void *) &dc);
+                DATA_PTR(dcVal) = NULL;
+              }
+          
+              return Qnil;
+            }
+          
+            // Return a window handle as a platform-specific ruby integer
+            VALUE get_handle()
+            {
+              wxWindow *win = self;
+              int64_t handle = (int64_t)win->GetHandle();
+              return LL2NUM(handle);
+            }
+          
+            // Attach a wx Object to an existing Windows handle (MSW only)
+            VALUE associate_handle(int64_t handle)
+            {
+              WXWidget wx_handle = (WXWidget)handle;
+              $self->AssociateHandle(wx_handle);
+              return Qnil;
+            }
+          __HEREDOC
+          spec.override_events 'wxWindow', 'EVT_ACTIVATE' => ['EVT_ACTIVATE', 0, 'wxActivateEvent']
+        when 'wxNonOwnedWindow'
+          spec.no_proxy('wxNonOwnedWindow')
+        when 'wxControl'
+          # add these to the generated interface to be parsed by SWIG
+          # the wxWidgets docs are flawed in this respect that several reimplemented
+          # virtual methods are not documented at the reimplementing class as such
+          # that would cause them missing from the interface which would cause a problem
+          # for a SWIG director redirecting to the Ruby class as the SWIG wrappers
+          # redirect explicitly to the implementation at the same class level as the wrapper
+          # for upcalls
+          spec.extend_interface('wxControl',
+                                'virtual bool ShouldInheritColours() const override',
+                                'virtual void DoUpdateWindowUI(wxUpdateUIEvent& event) override')
+        end
+        # helper for all Window modules
+        spec.add_header_code <<~__HEREDOC
+          static WxRuby_ID __wxrb_on_internal_idle_id("on_internal_idle");
+          __HEREDOC
+        # update generated code for all windows
+        spec.post_processors << :update_window
+      end
+    end # class Window
+
+  end # class Director
+
+  module SwigRunner
+    class Processor
+
+      # Special post-processor for Window and derivatives.
+      # This provides extra safe guarding for the event processing path in wxRuby.
+      # The processor inserts code in the 'OnInternalIdle' methods of the director class which check
+      # for existence of any Ruby implementation of this method ('on_internal_idle')
+      # 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.
+      # Additionally the inserted code first off checks if the window is actually (still)
+      # able to handle events by calling wxRuby_FindTracking() since in wxRuby it seems 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 UpdateWindow < Processor
+
+        def run
+          at_director_method = false
+          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 == 2 && line.strip.empty?   # are we at the right spot?
+                code = <<~__CODE     # insert the code update
+                // added by wxRuby3 Processor.update_window
+                // if Ruby object not registered anymore or no Ruby defined method override
+                // reroute directly to C++ method
+                if (wxRuby_FindTracking(this) == Qnil || wxRuby_IsNativeMethod(swig_get_self(), __wxrb_on_internal_idle_id()))
+                  this->#{director_wx_class}::OnInternalIdle();
+                else
+                __CODE
+                line << "\n  " << code.split("\n").join("\n  ")
+                at_director_method = false  # end of update
+              end
+            elsif /void\s+SwigDirector_(\w+)::OnInternalIdle\(.*\)\s+{/ =~ line
+              director_wx_class = $1
+              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 UpdateWindow
+
+    end
+  end
+
+end # module WXRuby3

data/rakelib/lib/director/window_disabler.rb

@@ -0,0 +1,44 @@
+###
+# wxRuby3 wxWidgets interface director
+# Copyright (c) M.J.N. Corino, The Netherlands
+###
+
+module WXRuby3
+
+  class Director
+
+    class WindowDisabler < Director
+
+      def setup
+        super
+        spec.disable_proxies
+        # scope delimited guard constructs do not work in Ruby
+        # so we'll have to use a block approach to Rubify
+        # remove ctor (essentially make this a namespace/module instead of class)
+        spec.ignore 'wxWindowDisabler::wxWindowDisabler'
+        # add Ruby-style static method
+        spec.add_extend_code 'wxWindowDisabler', <<~__HEREDOC
+          static void disable(wxWindow *to_skip = NULL)
+          {
+            if (rb_block_given_p())
+            {
+              wxWindowDisabler disabler(to_skip);
+              rb_yield(Qnil);
+            }
+            return ;
+          }
+          __HEREDOC
+        spec.ignore %w[
+          wxFindWindowByLabel
+          wxFindWindowByName
+          wxNewId
+          wxUsleep
+          ]
+        spec.ignore 'wxPostDelete' unless Config.instance.wx_version >= '3.3.0'
+        spec.do_not_generate(:variables, :enums, :defines, :functions)
+      end
+    end # class WindowDisabler
+
+  end # class Director
+
+end # module WXRuby3

data/rakelib/lib/director/with_images.rb

@@ -0,0 +1,65 @@
+###
+# wxRuby3 wxWidgets interface director
+# Copyright (c) M.J.N. Corino, The Netherlands
+###
+
+module WXRuby3
+
+  class Director
+
+    class WithImages < Director
+
+      def setup
+        super
+        spec.gc_as_temporary 'wxWithImages' # actually no GC control necessary as this is a mixin only
+        # turn wxWithImages into a mixin module
+        spec.make_mixin 'wxWithImages'
+        # Avoid premature deletion of ImageList providing icons for notebook
+        # tabs; wxRuby takes ownership when the ImageList is assigned,
+        # wxWidgets will delete the ImageList with the Toolbook.
+        spec.map_apply 'SWIGTYPE *DISOWN' => 'wxImageList*'
+        spec.ignore('wxWithImages::@.NO_IMAGE', 'wxWithImages::SetImageList')
+        spec.rename_for_ruby('SetImageList' => 'wxWithImages::AssignImageList')
+        spec.ignore 'wxWithImages::SetImages', ignore_doc: false
+        spec.add_swig_code 'typedef wxBitmapBundle* WxBitmapBundleArray;'
+        spec.add_header_code 'typedef wxVector<wxBitmapBundle> WxBitmapBundleArray;'
+        spec.extend_interface 'wxWithImages', 'void SetImages(const WxBitmapBundleArray& images);'
+        # type mapping for wrapper implementation
+        spec.map 'const WxBitmapBundleArray& images' => 'Array<Wx::Image>' do
+          map_in temp: 'wxVector<wxBitmapBundle> tmp', code: <<~__CODE
+            if ($input != Qnil)
+            {
+              if (TYPE($input) == T_ARRAY)
+              {
+                for (int i=0; i<RARRAY_LEN($input) ;++i)
+                {
+                  void* ptr;
+                  VALUE rb_image = rb_ary_entry($input, i);
+                  int res = SWIG_ConvertPtr(rb_image, &ptr, SWIGTYPE_p_wxBitmapBundle, 0);
+                  if (!SWIG_IsOK(res)) 
+                  {
+                    VALUE msg = rb_inspect(rb_image);
+                    rb_raise(rb_eTypeError, "Expected Wx::ImageBundle at index %d but got %s", i, StringValuePtr(msg));
+                  }
+                  tmp.push_back(*static_cast<wxBitmapBundle*>(ptr));
+                }
+              }
+              else
+              {
+                VALUE msg = rb_inspect($input);
+                rb_raise(rb_eArgError, "Expected Array of Wx::ImageBundle for $argnum but got %s", StringValuePtr(msg));
+              }
+            }
+            $1 = &tmp;
+            __CODE
+        end
+        # doc type map
+        spec.map 'const wxVector<wxBitmapBundle> &images' => 'Array<Wx::Image>', swig: false do
+          map_in
+        end
+      end
+    end # class WithImages
+
+  end # class Director
+
+end # module WXRuby3

data/rakelib/lib/director/wizard_page.rb

@@ -0,0 +1,35 @@
+###
+# wxRuby3 wxWidgets interface director
+# Copyright (c) M.J.N. Corino, The Netherlands
+###
+
+require_relative './window'
+
+module WXRuby3
+
+  class Director
+
+    class WizardPage < Window
+
+      def setup
+        super
+        if spec.module_name == 'wxWizardPage'
+          spec.ignore 'wxWizardPage::wxWizardPage(wxWizard * ,const wxBitmapBundle &)'
+        elsif spec.module_name == 'wxWizardPageSimple'
+          spec.ignore 'wxWizardPageSimple::Chain(wxWizardPageSimple *, wxWizardPageSimple *)'
+          # overrides not documented in XML docs
+          spec.extend_interface 'wxWizardPageSimple',
+                                'virtual wxWizardPage * GetNext() const',
+                                'virtual wxWizardPage * GetPrev() const'
+        end
+        spec.do_not_generate(:variables, :enums, :defines, :functions)
+        # handled; can be suppressed
+        spec.suppress_warning(473,
+                              "#{spec.module_name}::GetNext",
+                              "#{spec.module_name}::GetPrev")
+      end
+    end # class WizardPage
+
+  end # class Director
+
+end # module WXRuby3

data/rakelib/lib/director/xml_node.rb

@@ -0,0 +1,48 @@
+###
+# wxRuby3 wxWidgets interface director
+# Copyright (c) M.J.N. Corino, The Netherlands
+###
+
+module WXRuby3
+
+  class Director
+
+    class XmlNode < Director
+
+      def setup
+        super
+        spec.disable_proxies
+        spec.gc_as_temporary
+        spec.disown 'wxXmlNode *child'
+        # ignore this; only allow adding child node by explicitly calling Add/Insert-child methods (easier on the GC handling and avoids wxXmlAttribute)
+        spec.ignore 'wxXmlNode::wxXmlNode(wxXmlNode *, wxXmlNodeType, const wxString &, const wxString &, wxXmlAttribute *, wxXmlNode *, int)'
+        # avoid wxXmlAttribute
+        spec.ignore 'wxXmlNode::GetAttributes() const' # add alternative returning list of names
+        spec.ignore 'wxXmlNode::AddAttribute(wxXmlAttribute *)'
+        spec.ignore 'wxXmlNode::SetAttributes(wxXmlAttribute *)'
+        spec.ignore 'wxXmlNode::GetAttribute(const wxString &, wxString *) const' # implement pure Ruby alternative
+        # ignore these, we want wxXmlNode mostly (only?) to be able to inspect custom nodes from an XmlResource
+        # NOT to manipulate any nodes
+        spec.ignore('wxXmlNode::SetChildren(wxXmlNode *)')
+        spec.ignore('wxXmlNode::SetParent(wxXmlNode *)')
+        spec.ignore('wxXmlNode::SetNext(wxXmlNode *)')
+        spec.ignore('wxXmlNode::RemoveChild(wxXmlNode *)')
+        spec.add_extend_code 'wxXmlNode', <<~__HEREDOC
+          VALUE GetAttributes()
+          {
+            VALUE result = rb_ary_new();
+            wxXmlAttribute* attptr = self->GetAttributes();
+            while (attptr)
+            {
+              rb_ary_push(result, WXSTR_TO_RSTR(attptr->GetName()));
+              attptr = attptr->GetNext();
+            }
+            return result;
+          }
+          __HEREDOC
+      end
+    end # class XmlNode
+
+  end # class Director
+
+end # module WXRuby3