wxruby3 0.9.0.pre.rc.3 → 0.9.0

data/rakelib/lib/director/richtext_buffer.rb

@@ -1,43 +1,240 @@
+# Copyright (c) 2023 M.J.N. Corino, The Netherlands
+#
+# This software is released under the MIT license.
+
 ###
 # wxRuby3 wxWidgets interface director
-# Copyright (c) M.J.N. Corino, The Netherlands
 ###
 
+require_relative './richtext_paragraph_layout_box'
+
 module WXRuby3
 
   class Director
 
-    class RichTextBuffer < Director
+    class RichTextBuffer < RichTextParagraphLayoutBox
 
       include Typemap::RichText
-      include Typemap::IOStreams
 
       def setup
-        spec.disable_proxies
-        spec.items.replace %w[
-          wxTextAttrBorder
-          wxTextAttrBorders
-          wxTextBoxAttr
-          wxRichTextAttr
-          wxRichTextBuffer
-          ]
-        spec.gc_as_object 'wxRichTextAttr'
-        spec.gc_as_object 'wxRichTextBuffer'
-        spec.override_inheritance_chain('wxRichTextBuffer', %w[wxObject])
+        super
+        spec.items << 'wxRichTextFontTable' << 'wxRichTextFieldType' << 'wxRichTextFieldTypeStandard' << 'wxRichTextDrawingHandler'
+        spec.make_abstract 'wxRichTextFieldType'
+        spec.no_proxy 'wxRichTextFontTable'
+        spec.include 'wx/richtext/richtextstyles.h'
         spec.ignore %w[
           wxRichTextBuffer::GetBatchedCommand
           wxRichTextBuffer::GetCommandProcessor
+          wxRichTextBuffer::SubmitAction
+          wxRichTextBuffer::GetHandlers
+          wxRichTextBuffer::GetFieldTypes
+          wxRichTextBuffer::GetDrawingHandlers
+          wxRichTextBuffer::GetRenderer
+          wxRichTextBuffer::SetRenderer
           ]
-        spec.disown 'wxRichTextFileHandler* handler'
-        spec.ignore(%w[wxRICHTEXT_ALL wxRICHTEXT_NONE wxRICHTEXT_NO_SELECTION])
-        # special typemap for const wxChar wxRichTextLineBreakChar;
-        spec.add_swig_code <<~__HEREDOC
-          %typemap(constcode,noblock=1) const wxChar {
-            %set_constant("$symname", rb_str_new2((const char *)wxString($value).utf8_str()));
+        spec.disown 'wxRichTextFileHandler* handler',
+                    'wxRichTextDrawingHandler *handler',
+                    'wxRichTextFieldType *fieldType'
+        spec.add_extend_code 'wxRichTextBuffer', <<~__HEREDOC
+          static VALUE each_handler()
+          {
+            VALUE rc = Qnil;
+            if (rb_block_given_p())
+            {
+              wxList& handlers = wxRichTextBuffer::GetHandlers();
+              for (wxList::compatibility_iterator node = handlers.GetFirst();
+                    node; node = node->GetNext())
+              {
+                wxRichTextFileHandler *handler = (wxRichTextFileHandler *) node->GetData();
+                rc = rb_yield (SWIG_NewPointerObj(SWIG_as_voidptr(handler), SWIGTYPE_p_wxRichTextFileHandler, 0));
+              }
+            }
+            return rc;  
+          }
+
+          static VALUE each_field_type()
+          {
+            VALUE rc = Qnil;
+            if (rb_block_given_p())
+            {
+              wxRichTextFieldTypeHashMap& map = wxRichTextBuffer::GetFieldTypes();
+              wxRichTextFieldTypeHashMap::const_iterator it = map.begin();
+              for (; it != map.end() ;++it)
+              {
+                wxRichTextFieldType *ft = it->second;
+                rc = rb_yield (SWIG_NewPointerObj(SWIG_as_voidptr(ft), SWIGTYPE_p_wxRichTextFieldType, 0));
+              }
+            }
+            return rc;  
+          }
+
+          static VALUE each_drawing_handler()
+          {
+            VALUE rc = Qnil;
+            if (rb_block_given_p())
+            {
+              wxList& handlers = wxRichTextBuffer::GetDrawingHandlers();
+              for (wxList::compatibility_iterator node = handlers.GetFirst();
+                    node; node = node->GetNext())
+              {
+                wxRichTextDrawingHandler *handler = (wxRichTextDrawingHandler *) node->GetData();
+                rc = rb_yield (SWIG_NewPointerObj(SWIG_as_voidptr(handler), SWIGTYPE_p_wxRichTextDrawingHandler, 0));
+              }
+            }
+            return rc;  
           }
           __HEREDOC
-        spec.do_not_generate(:functions)
-        super
+        spec.add_header_code <<~__HEREDOC
+          // define the richtext buffer marker
+          static void wxRuby_markRichTextBuffer()
+          {
+            // mark any user installed drawing handlers
+            wxList& handlers = wxRichTextBuffer::GetDrawingHandlers();
+            for (wxList::compatibility_iterator node = handlers.GetFirst();
+                  node; node = node->GetNext())
+            {
+              VALUE obj = wxRuby_FindTracking(node->GetData());
+              if (obj && !NIL_P(obj))
+                rb_gc_mark(obj);
+            }
+            // mark any user installed field types
+            wxRichTextFieldTypeHashMap& map = wxRichTextBuffer::GetFieldTypes();
+            wxRichTextFieldTypeHashMap::const_iterator it = map.begin();
+            for (; it != map.end() ;++it)
+            {
+              VALUE obj = wxRuby_FindTracking(it->second);
+              if (obj && !NIL_P(obj))
+                rb_gc_mark(obj);
+            }
+          }
+          __HEREDOC
+        # register the marker at module initialization
+        spec.add_init_code 'wxRuby_AppendMarker(wxRuby_markRichTextBuffer);'
+        # for GetExtWildcard
+        spec.map 'wxArrayInt* types' => 'Array,nil' do
+
+          map_in temp: 'wxArrayInt tmp, VALUE rb_types', code: <<~__CODE
+            rb_types = $input;
+            if (!NIL_P(rb_types)) 
+            {
+              if (TYPE(rb_types) == T_ARRAY)
+              {
+                $1 = &tmp;
+              }
+              else
+              {
+                SWIG_exception_fail(SWIG_TypeError, Ruby_Format_TypeError( "", "Array","$symname", $argnum, $input ));
+              } 
+            }
+            __CODE
+
+          map_argout by_ref: true, code: <<~__CODE
+            if ($1)
+            {
+              for (size_t i = 0; i < $1->GetCount(); i++)
+              {
+                rb_ary_push(rb_types$argnum,INT2NUM( $1->Item(i) ) );
+              }
+            }
+            __CODE
+
+        end
+
+        # for wxRichTextFieldType::GetRangeSize
+        spec.map 'int & descent' => 'Integer' do
+
+          map_in temp: 'int tmp', code: 'tmp = NUM2INT($input); $1 = &tmp;'
+
+          map_argout code: '$result = SWIG_Ruby_AppendOutput($result, INT2NUM(tmp$argnum));'
+
+          map_directorin code: '$input = INT2NUM($1);'
+
+          map_directorargout code: <<~__CODE
+            if(output != Qnil)
+            {
+              $1 = NUM2INT(output);
+            }
+            else
+            {
+              $1 = 0;
+            }
+            __CODE
+
+        end
+
+        # for wxRichTextDrawingHandler::GetVirtualSubobjectAttributes
+        spec.map 'wxArrayInt & positions' => 'Array' do
+
+          map_in temp: 'wxArrayInt tmp, VALUE rb_pos', code: <<~__CODE
+            rb_pos = $input;
+            if (TYPE(rb_pos) == T_ARRAY)
+            {
+              $1 = &tmp;
+            }
+            else
+            {
+              SWIG_exception_fail(SWIG_TypeError, Ruby_Format_TypeError( "", "Array","$symname", $argnum, $input ));
+            } 
+            __CODE
+
+          map_argout by_ref: true, code: <<~__CODE
+            for (size_t i = 0; i < $1->GetCount(); i++)
+            {
+              rb_ary_push(rb_pos$argnum,INT2NUM( $1->Item(i) ) );
+            }
+            __CODE
+
+          map_directorin code: 'VALUE rb_int_arr = $input = rb_ary_new();'
+          map_directorargout code: <<~__CODE
+            for (int i=0; i<RARRAY_LEN(rb_int_arr) ;++i)
+            {
+              $1.Add(NUM2INT(rb_ary_entry(rb_int_arr, i)));
+            }
+            output = Qnil;
+            __CODE
+
+        end
+        spec.map 'wxRichTextAttrArray & attributes' => 'Array' do
+
+          map_in temp: 'wxRichTextAttrArray arr, VALUE rb_arr', code: <<~__CODE
+            if (TYPE($input) == T_ARRAY)
+            {
+              $1 = &arr;
+              rb_arr = $input;
+            }
+            else
+            {
+              rb_raise(rb_eArgError, "Expected an Array for %d", $argnum-1);
+            }
+            __CODE
+
+          map_argout by_ref: true, code: <<~__CODE
+            for (size_t i=0; i<arr$argnum.GetCount() ;++i)
+            {
+              wxRichTextAttr* wx_rta = new wxRichTextAttr(arr$argnum.Item(i));
+              rb_ary_push(rb_arr$argnum, SWIG_NewPointerObj(SWIG_as_voidptr(wx_rta), SWIGTYPE_p_wxRichTextAttr, SWIG_POINTER_OWN));
+            }
+            __CODE
+
+          map_directorin code: 'VALUE rb_attr_arr = $input = rb_ary_new();'
+          map_directorargout code: <<~__CODE
+            for (int i=0; i<RARRAY_LEN(rb_attr_arr) ;++i)
+            {
+              void *ptr;
+              int res = SWIG_ConvertPtr(rb_ary_entry(rb_int_arr, i), &ptr,SWIGTYPE_p_wxRichTextAttr, 0);
+              if (!SWIG_IsOK(res)) 
+              {
+                Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(res)), "in output value of type '""Wx::RTC::RichTextAttr""'");
+              }
+              wxRichTextAttr* wx_att = static_cast< wxRichTextAttr* >(ptr);
+              $1.Add(*wx_att);
+            }
+            output = Qnil;
+            __CODE
+
+        end
+
+        spec.do_not_generate(:typedefs, :variables, :enums, :defines, :functions)
       end
     end # class RichTextBuffer
 

data/rakelib/lib/director/richtext_buffer_data_object.rb

@@ -1,6 +1,9 @@
+# Copyright (c) 2023 M.J.N. Corino, The Netherlands
+#
+# This software is released under the MIT license.
+
 ###
 # wxRuby3 wxWidgets interface director
-# Copyright (c) M.J.N. Corino, The Netherlands
 ###
 
 module WXRuby3

data/rakelib/lib/director/richtext_composite_object.rb

@@ -0,0 +1,174 @@
+# Copyright (c) 2023 M.J.N. Corino, The Netherlands
+#
+# This software is released under the MIT license.
+
+###
+# wxRuby3 wxWidgets interface director
+###
+
+require_relative './richtext_object'
+
+module WXRuby3
+
+  class Director
+
+    class RichTextCompositeObject < RichTextObject
+
+      include Typemap::RichText
+
+      def setup
+        super
+        if spec.module_name == 'wxRichTextCompositeObject'
+          spec.items << 'wxRichTextParagraph' << 'wxRichTextLine'
+          spec.gc_as_untracked 'wxRichTextLine'
+          spec.no_proxy 'wxRichTextLine'
+          spec.make_abstract 'wxRichTextCompositeObject'
+          # for AppendChild, InsertChild
+          spec.disown 'wxRichTextObject *child'
+          # RemoveChild needs custom wrapper as we need to re-own any child that
+          # is removed but NOT deleted
+          spec.ignore 'wxRichTextCompositeObject::RemoveChild', ignore_doc: false
+          spec.add_extend_code 'wxRichTextCompositeObject', <<~__HEREDOC
+            bool RemoveChild(VALUE rb_child, bool deleteChild=false)
+            {
+              void *ptr;
+              int res = SWIG_ConvertPtr(rb_child, &ptr,SWIGTYPE_p_wxRichTextObject, 0);
+              if (!SWIG_IsOK(res)) 
+              {
+                rb_raise(rb_eArgError, "Expected Array of Wx::RTC::RichTextObject for child"); 
+              }
+              wxRichTextObject* wx_child = reinterpret_cast< wxRichTextObject * >(ptr);
+              bool rc = $self->RemoveChild(wx_child, deleteChild);
+              if (rc && !deleteChild)
+              {
+                RDATA(rb_child)->dfree = GC_RichTextObjectFreeFunc; // make sure Ruby owns
+              }
+              return rc;
+            }
+            __HEREDOC
+
+          spec.new_object 'wxRichTextLine::Clone'
+
+          spec.map 'const wxRichTextLineVector&' => 'Array<Wx::RTC::RichTextLine' do
+
+            map_out code: <<~__CODE
+              $result = rb_ary_new();
+              for (const wxRichTextLine *wx_rtl : *$1)
+              {
+                rb_ary_push($result, SWIG_NewPointerObj(SWIG_as_voidptr(const_cast<wxRichTextLine*> (wx_rtl)), SWIGTYPE_p_wxRichTextLine, 0));
+              }
+              __CODE
+
+          end
+
+          # create a lightweight, but typesafe, wrapper for wxRichTextFloatCollector
+          spec.add_init_code <<~__HEREDOC
+            // define wxRichTextFloatCollector wrapper class
+            mWxRichTextFloatCollector = rb_define_class_under(mWxRTC, "RichTextFloatCollector", rb_cObject);
+            rb_undef_alloc_func(mWxRichTextFloatCollector);
+            __HEREDOC
+
+          spec.add_header_code <<~__HEREDOC
+            VALUE mWxRichTextFloatCollector;
+  
+            // wxRichTextFloatCollector wrapper class definition and helper functions
+            static size_t __wxRichTextFloatCollector_size(const void* data)
+            {
+              return 0;
+            }
+  
+            #include <ruby/version.h> 
+  
+            static const rb_data_type_t __wxRichTextFloatCollector_type = {
+              "RichTextFloatCollector",
+            #if RUBY_API_VERSION_MAJOR >= 3
+              { NULL, NULL, __wxRichTextFloatCollector_size, 0, 0},
+            #else
+              { NULL, NULL, __wxRichTextFloatCollector_size, 0},
+            #endif 
+              NULL, NULL, RUBY_TYPED_FREE_IMMEDIATELY
+            };
+  
+            extern VALUE _wxRuby_Wrap_wxRichTextFloatCollector(wxRichTextFloatCollector* fc)
+            {
+              if (fc)
+              {
+                void* data = fc;
+                VALUE ret = TypedData_Wrap_Struct(mWxRichTextFloatCollector, &__wxRichTextFloatCollector_type, data);
+                return ret;
+              }
+              else
+                return Qnil;
+            } 
+  
+            extern wxRichTextFloatCollector* _wxRuby_Unwrap_wxRichTextFloatCollector(VALUE rbfc)
+            {
+              if (NIL_P(rbfc))
+                return nullptr;
+              else
+              {
+                void *data = 0;
+                TypedData_Get_Struct(rbfc, void, &__wxRichTextFloatCollector_type, data);
+                return reinterpret_cast<wxRichTextFloatCollector*> (data);
+              }
+            }
+  
+            extern bool _wxRuby_Is_wxRichTextFloatCollector(VALUE rbfc)
+            {
+              return rb_typeddata_is_kind_of(rbfc, &__wxRichTextFloatCollector_type) == 1;
+            } 
+            __HEREDOC
+
+          spec.ignore 'wxRichTextParagraph::MoveToList',
+                      'wxRichTextParagraph::MoveFromList',
+                      ignore_doc: false
+          spec.map 'wxList& list' => 'Array<Wx::RTC::RichTextObject>', swig: false do
+            map_in
+          end
+          spec.add_extend_code 'wxRichTextParagraph', <<~__CODE
+            void move_to_list(wxRichTextObject *wx_rto, VALUE rb_list)
+            {
+              if (TYPE(rb_list) != T_ARRAY)
+              {
+                rb_raise(rb_eArgError, "Expected Array for list");
+              }
+              wxList wx_lst;
+              $self->MoveToList(wx_rto, wx_lst);
+              for (const wxObject* wx_obj : wx_lst)
+              {
+                VALUE rb_rto = wxRuby_RichTextObject2Ruby(dynamic_cast<const wxRichTextObject*> (wx_obj), SWIG_POINTER_OWN);
+                rb_ary_push(rb_list, rb_rto);
+              }
+            }
+    
+            void move_from_list(VALUE rb_list)
+            {
+              if (TYPE(rb_list) != T_ARRAY)
+              {
+                rb_raise(rb_eArgError, "Expected Array for list");
+              }
+              wxList wx_lst;
+              for (int i=0; i<RARRAY_LEN(rb_list) ;++i)
+              {
+                void *ptr;
+                int res = SWIG_ConvertPtr(rb_ary_entry(rb_list, i), &ptr,SWIGTYPE_p_wxRichTextObject, SWIG_POINTER_DISOWN);
+                if (!SWIG_IsOK(res)) 
+                {
+                  rb_raise(rb_eArgError, "Expected Array of Wx::RTC::RichTextObject for list"); 
+                }
+                wxRichTextObject* wx_rto = reinterpret_cast< wxRichTextObject * >(ptr);
+                wx_lst.push_back(wx_rto);
+              }
+              $self->MoveFromList(wx_lst);
+            }
+            __CODE
+
+          spec.do_not_generate(:typedefs, :variables, :enums, :defines, :functions)
+        end
+      end
+
+    end
+
+  end
+
+end

data/rakelib/lib/director/richtext_ctrl.rb

@@ -1,6 +1,9 @@
+# Copyright (c) 2023 M.J.N. Corino, The Netherlands
+#
+# This software is released under the MIT license.
+
 ###
 # wxRuby3 wxWidgets interface director
-# Copyright (c) M.J.N. Corino, The Netherlands
 ###
 
 require_relative './window'
@@ -18,6 +21,20 @@ module WXRuby3
 
       def setup
         super
+        spec.items << 'wxRichTextContextMenuPropertiesInfo' << 'wxCommandProcessor'
+        spec.include 'wx/richtext/richtextstyles.h'
+        spec.gc_as_untracked 'wxRichTextContextMenuPropertiesInfo'
+        spec.no_proxy 'wxCommandProcessor'
+        spec.make_abstract 'wxCommandProcessor'
+        # restrict CommandProcessor functionality so we do not expose wxCommand hierarchy
+        spec.ignore %w[
+          wxCommandProcessor::GetCommands
+          wxCommandProcessor::GetCurrentCommand
+          wxCommandProcessor::Submit
+          wxCommandProcessor::Store
+        ]
+        # mixin TextEntry
+        spec.include_mixin 'wxRichTextCtrl', { 'Wx::TextEntry' => 'wxTextEntryBase' }
         spec.override_inheritance_chain('wxRichTextCtrl', %w[wxControl wxWindow wxEvtHandler wxObject])
         spec.include 'wx/dc.h'
         spec.ignore [
@@ -30,31 +47,167 @@ module WXRuby3
           'wxRichTextCtrl::HitTest(const wxPoint &,long *)',
           'wxRichTextCtrl::SetListStyle(const wxRichTextRange &,wxRichTextListStyleDefinition *,int,int,int)',
           ]
+        # ignore the standard event handlers (doesn't seem useful to export to Ruby since non-virtual)
+        # and removing cleans the interface
+        spec.ignore %w[
+          wxRichTextCtrl::OnDropFiles
+          wxRichTextCtrl::OnCaptureLost
+          wxRichTextCtrl::OnSysColourChanged
+          wxRichTextCtrl::OnCut
+          wxRichTextCtrl::OnCopy
+          wxRichTextCtrl::OnPaste
+          wxRichTextCtrl::OnUndo
+          wxRichTextCtrl::OnRedo
+          wxRichTextCtrl::OnSelectAll
+          wxRichTextCtrl::OnProperties
+          wxRichTextCtrl::OnClear
+          wxRichTextCtrl::OnUpdateCut
+          wxRichTextCtrl::OnUpdateCopy
+          wxRichTextCtrl::OnUpdatePaste
+          wxRichTextCtrl::OnUpdateUndo
+          wxRichTextCtrl::OnUpdateRedo
+          wxRichTextCtrl::OnUpdateSelectAll
+          wxRichTextCtrl::OnUpdateProperties
+          wxRichTextCtrl::OnUpdateClear
+          wxRichTextCtrl::OnContextMenu
+          wxRichTextCtrl::OnPaint
+          wxRichTextCtrl::OnEraseBackground
+          wxRichTextCtrl::OnLeftClick
+          wxRichTextCtrl::OnLeftUp
+          wxRichTextCtrl::OnMoveMouse
+          wxRichTextCtrl::OnLeftDClick
+          wxRichTextCtrl::OnMiddleClick
+          wxRichTextCtrl::OnRightClick
+          wxRichTextCtrl::OnChar
+          wxRichTextCtrl::OnSize
+          wxRichTextCtrl::OnSetFocus
+          wxRichTextCtrl::OnKillFocus
+          wxRichTextCtrl::OnIdle
+          wxRichTextCtrl::OnScroll
+          ]
         # TODO : not supported (yet)
         spec.ignore %w[
-          wxRichTextCtrl::WriteTextBox
-          wxRichTextCtrl::WriteField
-          wxRichTextCtrl::WriteTable
           wxRichTextCtrl::PaintBackground
           wxRichTextCtrl::PaintAboveContent
+          wxRichTextCtrl::LayoutContent
+          wxRichTextCtrl::DoLayoutBuffer
+          wxRichTextCtrl::DoGetValue
+          wxRichTextCtrl::DoSetValue
+          wxRichTextCtrl::DoWriteText
+          wxRichTextCtrl::EnableVerticalScrollbar
+          wxRichTextCtrl::GetVerticalScrollbarEnabled
+          wxRichTextCtrl::SetupScrollbars
+          wxRichTextCtrl::ScrollIntoView
+          wxRichTextCtrl::KeyboardNavigate
+          wxRichTextCtrl::PositionToXY
+          wxRichTextCtrl::XYToPosition
           ]
+        # this method contains worrisome code and is unclearly documented so I doubt it's usefulness
+        spec.ignore 'wxRichTextCtrl::FindContainerAtPoint'
+        # do not think having these proxied is going to bring much for wxRuby and suppressing them
+        # prevents code bloat
         spec.no_proxy %w[
           wxRichTextCtrl::GetDefaultStyleEx
           wxRichTextCtrl::GetBasicStyle
+          wxRichTextCtrl::WriteField
+          wxRichTextCtrl::WriteTextBox
+          wxRichTextCtrl::WriteTable
+          wxRichTextCtrl::WriteImage
+          wxRichTextCtrl::FindRangeForList
+          wxRichTextCtrl::ProcessMouseMovement
+          wxRichTextCtrl::ProcessBackKey
           ]
         unless Config.instance.features_set?('wxUSE_DATETIME')
           spec.ignore %w[wxRichTextCtrl::GetDragStartTime wxRichTextCtrl::SetDragStartTime]
         end
+        spec.add_header_code 'extern VALUE wxRuby_RichTextObject2Ruby(const wxRichTextObject *wx_rto, int own);'
         spec.swig_import('swig/classes/include/wxTextAttr.h',
+                         'swig/classes/include/wxRichTextObject.h',
+                         'swig/classes/include/wxRichTextCompositeObject.h',
+                         'swig/classes/include/wxRichTextParagraphLayoutBox.h',
                          'swig/classes/include/wxRichTextBuffer.h',
                          append_to_base_imports: true)
         spec.suppress_warning(402, 'wxRichTextAttr')
         # Deal with some output values from TextCtrl methods - PositionToXY
         spec.map_apply 'long * OUTPUT' => 'long *'
+        # DeleteSelectedContent
+        spec.map 'long *newPos' => 'Integer,nil' do
+          map_in ignore: true, temp: 'long tmp', code: '$1 = &tmp;'
+          # ignore C defined return value entirely (also affects directorout)
+          map_out ignore: 'bool'
+          map_argout code: <<~__CODE
+            if (result)
+            {
+              $result = LONG2NUM(tmp$argnum);
+            }
+            else
+              $result = Qnil;
+            __CODE
+          map_directorargout code: <<~__CODE
+            if (RTEST(result))
+            {
+              if (TYPE(result) == T_FIXNUM)
+              {
+                *newPos = NUM2LONG(result);
+                c_result = true;
+              }
+              else
+              {
+                Swig::DirectorTypeMismatchException::raise(rb_eTypeError, 
+                                                           "expected an Integer, or nil on failure");
+              }
+            }
+            else
+              c_result = false;
+          __CODE
+        end
         spec.map_apply 'long * OUTPUT' => [ 'wxTextCoord *col', 'wxTextCoord *row' ]
         # GetViewStart
         spec.map_apply 'int * OUTPUT' => 'int *'
         spec.map_apply 'SWIGTYPE *DISOWN' => 'wxRichTextStyleSheet* styleSheet'
+        # ProcessDelayedImageLoading
+        spec.map_apply 'int * OUTPUT' => 'int & loadCount'
+        # FindRangeForList & FindCaretPositionForCharacterPosition
+        spec.map_apply 'bool * OUTPUT' => ['bool & isNumberedList', 'bool & caretLineStart']
+        spec.map 'wxLongLong' => 'Integer' do
+          map_in code: '$1 = NUM2LL($input);'
+          map_out code: '$result = LL2NUM($1.GetValue());'
+        end
+        # for GetLastPosition
+        spec.map_apply 'long' => 'wxTextPos'
+        # for wxRichTextContextMenuPropertiesInfo::GetObjects/SetObjects
+        spec.map 'const wxRichTextObjectPtrArray &' => 'Array<Wx::RTC::RichTextObject>' do
+
+          map_in temp: 'wxRichTextObjectPtrArray tmp', code: <<~__CODE
+            if (TYPE($input) == T_ARRAY)
+            {
+              for (int i=0; i<RARRAY_LEN($input) ;++i)
+              {
+                void *ptr;
+                int res = SWIG_ConvertPtr(rb_ary_entry($input, i), &ptr, SWIGTYPE_p_wxRichTextObject, 0);
+                if (!SWIG_IsOK(res)) 
+                {
+                  rb_raise(rb_eArgError, "Expected Array of Wx::RTC::RichTextObject for %d", $argnum-1); 
+                }
+                tmp.Add(reinterpret_cast< wxRichTextObject * >(ptr));
+              }
+              $1 = &tmp;
+            }
+            else
+            {
+              rb_raise(rb_eArgError, "Expected Array for %d", $argnum-1);
+            }
+            __CODE
+
+          map_out code: <<~__CODE
+            $result = rb_ary_new();
+            for (size_t i=0; i<$1->GetCount() ;++i)
+            {
+              rb_ary_push($result, wxRuby_RichTextObject2Ruby($1->Item(i), 0));
+            }
+            __CODE
+
+        end
       end
     end # class RichTextCtrl
 

data/rakelib/lib/director/richtext_event.rb

@@ -1,6 +1,9 @@
+# Copyright (c) 2023 M.J.N. Corino, The Netherlands
+#
+# This software is released under the MIT license.
+
 ###
 # wxRuby3 wxWidgets interface director
-# Copyright (c) M.J.N. Corino, The Netherlands
 ###
 
 require_relative './event'

data/rakelib/lib/director/richtext_file_handler.rb

@@ -1,6 +1,9 @@
+# Copyright (c) 2023 M.J.N. Corino, The Netherlands
+#
+# This software is released under the MIT license.
+
 ###
 # wxRuby3 wxWidgets interface director
-# Copyright (c) M.J.N. Corino, The Netherlands
 ###
 
 module WXRuby3
@@ -10,6 +13,7 @@ module WXRuby3
     class RichTextFileHandler < Director
 
       include Typemap::RichText
+      include Typemap::IOStreams
 
       def setup
         super
@@ -26,6 +30,14 @@ module WXRuby3
             wxRichTextXMLHandler::ExportXML
             ]
         when 'wxRichTextHTMLHandler'
+          # identically named instance and class method clash in SWIG
+          spec.ignore 'wxRichTextHTMLHandler::DeleteTemporaryImages()', ignore_doc: true
+          spec.add_extend_code 'wxRichTextHTMLHandler', <<~__CODE
+            bool delete_temporary_images()
+            {
+              return $self->DeleteTemporaryImages();
+            }
+            __CODE
         end
         spec.no_proxy "#{spec.module_name}::LoadFile",
                       "#{spec.module_name}::SaveFile",