wxruby3 0.9.0.pre.beta.14 → 0.9.0.pre.rc.2

data/rakelib/lib/director/richtext_buffer_data_object.rb

@@ -20,13 +20,11 @@ module WXRuby3
         # we only allow Ruby derivatives from wxDataObject but not of any of the C++ implemented
         # specializations
         spec.no_proxy 'wxRichTextBufferDataObject'
-        spec.add_swig_code <<~__HEREDOC
-            // SWIG gets confused and doesn't realise that various virtual methods
-            // from wxDataObject are implemented fully in this subclass, and so,
-            // believing it to be abstract doesn't provide an allocator for this
-            // class. This undocumented feature overrides this.
-            %feature("notabstract") wxRichTextBufferDataObject;
-        __HEREDOC
+        # SWIG gets confused and doesn't realise that various virtual methods
+        # from wxDataObject are implemented fully in this subclass, and so,
+        # believing it to be abstract doesn't provide an allocator for this
+        # class. This overrides this.
+        spec.make_concrete 'wxRichTextBufferDataObject'
 
         # ignore overrrides (will be available through base class)
         spec.ignore 'wxRichTextBufferDataObject::GetPreferredFormat'

data/rakelib/lib/director/richtext_header_footer_data.rb

@@ -11,7 +11,7 @@ module WXRuby3
 
       def setup
         super
-        spec.gc_as_temporary
+        spec.gc_as_untracked 'wxRichTextHeaderFooterData'
         spec.disable_proxies # fixed and final data structures
       end
     end # class RichTextHeaderFooterData

data/rakelib/lib/director/searchctrl.rb

@@ -0,0 +1,25 @@
+###
+# wxRuby3 wxWidgets interface director
+# Copyright (c) M.J.N. Corino, The Netherlands
+###
+
+require_relative './window'
+
+module WXRuby3
+
+  class Director
+
+    class SearchCtrl < Window
+
+      def setup
+        super
+        # mixin TextEntry
+        spec.include_mixin 'wxSearchCtrl', { 'Wx::TextEntry' => 'wxTextEntryBase' }
+        spec.suppress_warning(473, 'wxSearchCtrl::GetMenu')
+        spec.override_inheritance_chain('wxSearchCtrl', %w[wxControl wxWindow wxEvtHandler wxObject])
+      end
+    end # class SearchCtrl
+
+  end # class Director
+
+end # module WXRuby3

data/rakelib/lib/director/sizer.rb

@@ -15,7 +15,7 @@ module WXRuby3
         case spec.module_name
         when 'wxSizer'
           spec.items << 'wxSizerFlags'
-          spec.gc_as_temporary('wxSizerFlags')
+          spec.gc_as_untracked('wxSizerFlags')
           spec.make_abstract('wxSizer')
           spec.ignore %w[wxSizer::IsShown wxSizer::SetVirtualSizeHints]
           # cannot use these with wxRuby
@@ -44,7 +44,7 @@ module WXRuby3
           spec.suppress_warning(517, 'wxSizer')
         when 'wxGridBagSizer'
           spec.items << 'wxGBSpan' << 'wxGBPosition'
-          spec.gc_as_temporary 'wxGBSpan', 'wxGBPosition'
+          spec.gc_as_untracked 'wxGBSpan', 'wxGBPosition'
           # cannot use this with wxRuby
           spec.ignore 'wxGridBagSizer::Add(wxGBSizerItem *)'
         end

data/rakelib/lib/director/static_box.rb

@@ -13,7 +13,7 @@ module WXRuby3
 
       def setup
         super
-        if Config.instance.wx_port == :wxQT
+        if Config.instance.wx_port == :wxQT || Config.platform == :macosx
           # missing from implementation currently
           spec.ignore 'wxStaticBox::wxStaticBox(wxWindow *, wxWindowID, wxWindow *, const wxPoint &, const wxSize &, long, const wxString &)',
                       'wxStaticBox::Create(wxWindow *, wxWindowID, wxWindow *, const wxPoint &, const wxSize &, long, const wxString &)'

data/rakelib/lib/director/styled_text_ctrl.rb

@@ -14,6 +14,8 @@ module WXRuby3
       def setup
         super
         spec.override_inheritance_chain('wxStyledTextCtrl', %w[wxControl wxWindow wxEvtHandler wxObject])
+        # mixin TextEntry
+        spec.include_mixin 'wxStyledTextCtrl', { 'Wx::TextEntry' => 'wxTextEntryBase' }
         spec.map 'int *', 'long *', as: 'Integer' do
           map_in ignore: true, temp: '$*1_ltype a', code: '$1 = &a;'
           map_argout code: <<~__CODE

data/rakelib/lib/director/text_entry.rb

@@ -12,10 +12,15 @@ module WXRuby3
       def setup
         super
         spec.items << 'wxTextCompleter' << 'wxTextCompleterSimple'
-        spec.gc_as_temporary 'wxTextCompleter', 'wxTextCompleterSimple'
-        spec.gc_as_temporary 'wxTextEntry' # actually no GC control necessary as this is a mixin only
+        spec.gc_as_untracked 'wxTextCompleter', 'wxTextCompleterSimple'
+        spec.gc_as_untracked 'wxTextEntry' # actually no GC control necessary as this is a mixin only
         # turn wxTextEntry into a mixin module
         spec.make_mixin 'wxTextEntry'
+        # !!NOTE!!
+        # This is not very nice but it is the easiest way to work around the problem that
+        # what we actually want as native type is wxTextEntryBase (because of some bad implementation decisions in wxw)
+        # and what is documented is wxTextEntry.
+        spec.add_header_code '#define wxTextEntry wxTextEntryBase'
         spec.disown 'wxTextCompleter *completer' # managed by wxWidgets after passing in
         spec.map_apply 'long * OUTPUT' => 'long *' # for GetSelection
       end

data/rakelib/lib/director/textctrl.rb

@@ -14,7 +14,7 @@ module WXRuby3
       def setup
         super
         # mixin TextEntry
-        spec.include_mixin 'wxTextCtrl', 'Wx::TextEntry'
+        spec.include_mixin 'wxTextCtrl', { 'Wx::TextEntry' => 'wxTextEntryBase' }
         spec.override_inheritance_chain('wxTextCtrl', %w[wxControl wxWindow wxEvtHandler wxObject])
         spec.ignore 'wxTextCtrl::HitTest(const wxPoint &,long *)'
         if Config.instance.wx_port == :wxQT

data/rakelib/lib/director/tree_ctrl.rb

@@ -194,10 +194,13 @@ module WXRuby3
             else // Find the top-left most item, then recurse over it and siblings
             {
               wxTreeItemId base_id = FindFirstRoot(tree_ctrl);
-              // now do recursion
-              RecurseOverTreeIds(tree_ctrl, base_id, *rec_func);
-              while ((base_id = tree_ctrl->GetNextSibling(base_id)).IsOk())
+              if (base_id.IsOk())
+              {
+                // now do recursion
                 RecurseOverTreeIds(tree_ctrl, base_id, *rec_func);
+                while ((base_id = tree_ctrl->GetNextSibling(base_id)).IsOk())
+                  RecurseOverTreeIds(tree_ctrl, base_id, *rec_func);
+              }
               return;
             }
           }

data/rakelib/lib/director/uiaction_simulator.rb

@@ -0,0 +1,20 @@
+###
+# wxRuby3 wxWidgets interface director
+# Copyright (c) M.J.N. Corino, The Netherlands
+###
+
+module WXRuby3
+
+  class Director
+
+    class UIActionSimulator < Director
+
+      def setup
+        super
+        spec.gc_as_untracked # no tracking
+      end
+    end # class UIActionSimulator
+
+  end # class Director
+
+end # module WXRuby3

data/rakelib/lib/director/variant.rb

@@ -15,7 +15,7 @@ module WXRuby3
         super
         # variants are (almost) always returned by value and never transfer ownership
         # so we do not need tracking or special free function
-        spec.gc_as_temporary 'wxVariant'
+        spec.gc_as_untracked 'wxVariant'
         spec.disable_proxies
         # add custom wxVariant extensions so to be
         # able to handle all PGProperty specific value types

data/rakelib/lib/director/vlistbox.rb

@@ -38,6 +38,31 @@ module WXRuby3
         __HEREDOC
         # make Ruby director and wrappers use custom implementation
         spec.use_class_implementation('wxVListBox', 'wxRubyVListBox')
+        # make sure protected methods are included
+        spec.regard 'wxVListBox::OnDrawItem',
+                    'wxVListBox::OnMeasureItem',
+                    'wxVListBox::OnDrawSeparator',
+                    'wxVListBox::OnDrawBackground'
+        # ignore these very un-Ruby methods
+        spec.ignore 'wxVListBox::GetFirstSelected',
+                    'wxVListBox::GetNextSelected'
+        # add rubified API (finish in pure Ruby)
+        spec.add_extend_code 'wxVListBox', <<~__HEREDOC
+          VALUE each_selected()
+          {
+            VALUE rc = Qnil;
+            if (rb_block_given_p())
+            {
+              unsigned long cookie;
+              int sel = $self->GetFirstSelected(cookie);
+              for (; sel != wxNOT_FOUND ;sel = $self->GetNextSelected(cookie))
+              {
+                rc = rb_yield (INT2NUM(sel));
+              }
+            }
+            return rc;  
+          }
+          __HEREDOC
       end
     end # class VListBox
 

data/rakelib/lib/director/window.rb

@@ -132,8 +132,28 @@ module WXRuby3
             '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
+            'wxWindow::ScreenToClient(int*,int*)', # no need; prefer the wxPoint version
           ]
+          # redefine these so a nil parent is accepted
+          spec.ignore %w[wxWindow::FindWindowById wxWindow::FindWindowByLabel wxWindow::FindWindowByName], ignore_doc: false
+          # overrule common typemap to allow default NULL
+          spec.map 'wxWindow* find_from_parent' do
+            map_check code: ''
+          end
+          spec.add_extend_code 'wxWindow', <<~__HEREDOC
+            static wxWindow* find_window_by_id(long id, const wxWindow *find_from_parent=0)
+            {
+              return wxWindow::FindWindowById(id, find_from_parent);
+            }
+            static wxWindow* find_window_by_label(const wxString &label, const wxWindow *find_from_parent=0)
+            {
+              return wxWindow::FindWindowByLabel(label, find_from_parent);
+            }
+            static wxWindow* find_window_by_name(const wxString &name, const wxWindow *find_from_parent=0)
+            {
+              return wxWindow::FindWindowByName(name, find_from_parent);
+            }
+            __HEREDOC
           if Config.instance.wx_port == :wxQT
             # protected for wxQT; ignore for now
             spec.ignore 'wxWindow::EnableTouchEvents'
@@ -172,8 +192,6 @@ module WXRuby3
               swig_type_info* swig_type = wxRuby_GetSwigTypeForClass(r_class);
               VALUE rb_dc = SWIG_NewPointerObj(SWIG_as_voidptr(ptr_dc), swig_type, 0);
               rc = rb_yield(rb_dc);
-              SWIG_RubyRemoveTracking((void *)ptr_dc);
-              DATA_PTR(rb_dc) = NULL;
 
               return rc;
             }
@@ -201,16 +219,12 @@ module WXRuby3
                 wxPaintDC dc(ptr);
                 VALUE dcVal = SWIG_NewPointerObj((void *) &dc,SWIGTYPE_p_wxPaintDC, 0);
                 rc = 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);
                 rc = rb_yield(dcVal);
-                SWIG_RubyRemoveTracking((void *) &dc);
-                DATA_PTR(dcVal) = NULL;
               }
           
               return rc;
@@ -263,6 +277,22 @@ module WXRuby3
         # update generated code for all windows
         spec.post_processors << :update_window
       end
+
+      def process(gendoc: false)
+        defmod = super
+        if spec.module_name == 'wxWindow'
+          # special processing to ignore the non-static versions of methods FromDIP,ToDIP,FromPhys,ToPhys
+          # as SWIG cannot handle identically named static & non-static methods
+          # will handle that in pure Ruby
+          %w[FromDIP ToDIP FromPhys ToPhys].each do |mtd|
+            if (item = defmod.find("wxWindow::#{mtd}"))
+              item.all.each { |ovl| ovl.ignore(true, ignore_doc: false) unless ovl.is_static }
+            end
+          end
+        end
+        defmod
+      end
+
     end # class Window
 
   end # class Director

data/rakelib/lib/director/with_images.rb

@@ -11,7 +11,7 @@ module WXRuby3
 
       def setup
         super
-        spec.gc_as_temporary 'wxWithImages' # actually no GC control necessary as this is a mixin only
+        spec.gc_as_untracked '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

data/rakelib/lib/director/xml_node.rb

@@ -12,7 +12,7 @@ module WXRuby3
       def setup
         super
         spec.disable_proxies
-        spec.gc_as_temporary
+        spec.gc_as_untracked
         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)'

data/rakelib/lib/extractor/function.rb

@@ -91,9 +91,9 @@ module WXRuby3
         # unlink params_doc if any
         params_doc.unlink if params_doc
         # get brief doc
-        doc = xml_trans.to_doc(@brief_doc)
+        doc = xml_trans.to_doc(@brief_doc, item: self)
         # add detailed doc text without params doc
-        doc << xml_trans.to_doc(@detailed_doc)
+        doc << xml_trans.to_doc(@detailed_doc, item: self, desc: :detail)
         # get mapped ruby parameter list
         params = []
         mapped_ret_args = nil
@@ -130,7 +130,9 @@ module WXRuby3
             # look up matching mapped param entry
             if (param = params.detect { |p| p[:name] == pinm })
               # add doc
-              param[:doc] = xml_trans.to_doc(pi.xpath('parameterdescription')).lstrip
+              param[:doc] = xml_trans.to_doc(pi.xpath('parameterdescription'),
+                                             item: "#{name}.#{param[:name]}",
+                                             desc: :brief).lstrip
             end
           end
         end if params_doc

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

@@ -0,0 +1,46 @@
+---
+:wxAboutBox:
+  :detail:
+    :pre:
+      :para:
+        - :pattern: !ruby/regexp /<programlisting>.*MyFrame::ShowSimpleAboutDialog/
+          :replace: |
+            ```ruby
+              def show_simple_about_dialog(event)
+                info = Wx::AboutDialogInfo.new
+                info.name = 'My Program'
+                info.version = '1.2.3 Beta'
+                info.description = 'This program does something great.'
+                info.copyright = '(C) 2007 Me <my@email.addre.ss>'
+                   
+                Wx.about_box(info)
+              end
+            ```
+
+:wxAboutDialogInfo:
+  :detail:
+    :pre:
+      :para:
+        - :pattern: !ruby/regexp /Example of usage:/
+          :replace: |
+            
+            Example of usage:
+            
+            ```ruby
+              def on_about(event)
+                info = Wx::AboutDialogInfo.new
+                info.name = 'MyApp'
+                info.version = MY_APP_VERSION_STRING
+                info.description = 'My wxWidgets-based application!'
+                info.copyright = '(C) 1992-2023'
+                info.add_developer('My Self')
+                   
+                Wx.about_box(info)
+              end
+            ```
+
+    :post:
+      - :pattern: !ruby/regexp /Example of appearance of a simple about dialog:(.|\s)+\<\/table>\<\/div>/
+        :subst: ''
+      - :pattern: !ruby/regexp /And that of a dialog using a web site link,(.|\s)+\<\/table>\<\/div>/
+        :subst: ''

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

@@ -0,0 +1,21 @@
+---
+:wxAcceleratorTable:
+  :detail:
+    :pre:
+      :para:
+        - :pattern: !ruby/regexp /<programlisting>.*/
+          :replace: |
+            ```ruby
+              entries = [
+                  Wx::AcceleratorEntry.new(Wx::ACCEL_CTRL, 'N', ID_NEW_WINDOW),
+                  Wx::AcceleratorEntry.new(Wx::ACCEL_CTRL, 'X', Wx::ID_EXIT),
+                  Wx::AcceleratorEntry.new(Wx::ACCEL_CTRL, 'A', Wx::ID_ABOUT),
+                  Wx::AcceleratorEntry.new(Wx::ACCEL_CTRL, 'N', Wx::ID_CUT)
+                ]
+              frame.accelerator_table = Wx::AcceleratorTable[entries]
+            ```
+:wxAcceleratorEntry.wxAcceleratorEntry.keyCode:
+  :brief:
+    :post:
+      - :pattern: !ruby/regexp /The\s+keycode\s+to\s+be\s+detected/
+        :subst: 'The keycode (or character) to be detected'

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

@@ -0,0 +1,35 @@
+---
+:wxArtProvider:
+  :detail:
+    :pre:
+      :para:
+        - :pattern: !ruby/regexp /<programlisting>.*MyProvider/
+          :replace: |
+            
+            Example:
+            
+            ```ruby
+              class MyArtProvider < Wx::ArtProvider
+                
+                def create_bitmap(id, client, size)
+                  # ... create and return bitmap
+                end
+            
+              end
+            
+              Wx::ArtProvider.push(MyArtProvider.new)
+            ```
+
+        - :pattern: !ruby/regexp /Note\s+that,\s+as\s+usual\s+in\s+wxWidgets\s+API.*/
+          :replace: ''
+        - :pattern: !ruby/regexp /wxNO_IMPLICIT_WXSTRING_ENCODING/
+          :replace: ''
+      :programlisting:
+        - :pattern: !ruby/regexp /ifdef.*__WXGTK__/
+          :replace: |
+            
+            ```ruby
+              if Wx::PLATFORM == 'WXGTK'
+                bmp = Wx::ArtProvider.get_bitmap("gtk-cdrom", Wx::ART_MENU)
+              end
+            ```

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

@@ -0,0 +1,37 @@
+---
+:wxBitmap.wxBitmap:
+  :detail:
+    :pre:
+      :para:
+        - :pattern: !ruby/regexp /<programlisting>.*GetSubBitmap/
+          :replace: |
+            ```ruby
+              newBitmap = oldBitmap.get_sub_bitmap(
+                              Wx::Rect.new(0, 0, oldBitmap.width, oldBitmap.height))
+            ```
+:wxBitmapBundle:
+  :detail:
+    :pre:
+      :para:
+        - :pattern: !ruby/regexp /<programlisting>.*MyFrame::MyFrame/
+          :replace: |
+            ```ruby
+              class MyFrame < Wx::Frame
+                
+                def initialize
+                  super(nil, Wx::ID_ANY, "My frame")
+                  # ...
+                  tool_bar = create_toolBar
+               
+                  bitmaps = [
+                      Wx::Bitmap(:open_32x32, Wx::BitmapType::BITMAP_TYPE_PNG),
+                      Wx::Bitmap(:open_48x48, Wx::BitmapType::BITMAP_TYPE_PNG),
+                      Wx::Bitmap(:open_64x64, Wx::BitmapType::BITMAP_TYPE_PNG)
+                    ]
+             
+                  tool_bar.add_tool(Wx::ID_OPEN, "Open", Wx::BitmapBundle.from_bitmaps(bitmaps))
+                end
+            ```
+
+        - :pattern: !ruby/regexp /For\s+the\s+platforms\s+with\s+resources\s+support/
+          :replace: ''

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

@@ -0,0 +1,15 @@
+---
+:wxBoxSizer.AddSpacer:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /wxBoxSizer::IsVertical/
+          :replace: |
+            
+            ```ruby
+              if box_sizer.vertical?
+                box_sizer.add(0, size, 0)
+              else
+                box_size.add(size, 0, 0)
+              end
+            ```

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

@@ -0,0 +1,74 @@
+---
+:wxBusyInfo:
+  :detail:
+    :pre:
+      :detaileddescription:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+            Normally the main thread should always return to the main loop to continue dispatching events as quickly as possible,
+            hence this class shouldn't be needed. However if the main thread does need to block, this class provides a simple
+            way to at least show this to the user: just call {Wx::BusyInfo.busy} with a block and for the duration of the
+            execution of the block a message window will be shown.
+            For example:
+            ```ruby
+              BusyInfo.busy('Working, please wait...') do
+                100000.times { do_a_calculation }
+              end
+            ```
+          
+            The displayed window is rather plain by default but can be customized by passing {Wx::BusyInfo.busy} an object of
+            {Wx::BusyInfoFlags} class instead of a simple message. Here is an example:
+          
+            ```ruby
+              Wx::BusyInfo.busy(
+                Wx::BusyInfoFlags.new
+                  .parent(self)
+                  .icon(Wx::ArtProvider.get_icon(Wx::ART_PRINT,Wx::ART_OTHER, [128, 128]))
+                  .title("<b>Printing your document</b>")
+                  .text("Please wait...")
+                  .foreground(Wx::WHITE)
+                  .background(Wx::BLACK)
+                  .transparency(4*Wx::ALPHA_OPAQUE/5)) do |bi|
+              end
+            ```
+          
+            This shows that separate title and text can be set, and that simple markup ({Wx::Control#set_label_markup}) can be used in them, and that it's also possible to add an icon and customize the colours and transparency of the window.
+            You may also want to call `Wx.get_app.yield` to refresh the window periodically (in case it had been obscured by other windows, for example) like this:
+            ```ruby
+              Wx::WindowDisabler.disable do
+                BusyInfo.busy('Working, please wait...') do
+                  100000.times do |i| 
+                    do_a_calculation }
+                    Wx.get_app.yield if (i % 1000) == 0
+                  end
+                end
+              end
+            ```
+          
+            but take care to not cause undesirable re-entrance when doing it (see {Wx::App#yield} for more details). The simplest way to do it is to use {Wx::WindowDisabler} class as illustrated in the above example.
+            Note that a {Wx::BusyInfo} is always built with the {Wx::STAY_ON_TOP} window style (see {Wx::Frame} window styles for more info).
+            
+            ===
+          
+            Category:  Common Dialogs
+          
+
+:wxBusyInfoFlags:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+            
+            ```ruby
+              Wx::BusyInfo.busy(
+                Wx::BusyInfoFlags.new
+                  .parent(self)
+                  .icon(Wx::ArtProvider.get_icon(Wx::ART_PRINT,Wx::ART_OTHER, [128, 128]))
+                  .title("<b>Printing your document</b>")
+                  .text("Please wait...")
+                  .foreground(Wx::WHITE)
+                  .background(Wx::BLACK)
+                  .transparency(4*Wx::ALPHA_OPAQUE/5)) do |bi|
+              end
+            ```

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

@@ -0,0 +1,19 @@
+---
+:wxClientDC:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+            
+            ```ruby
+               # Create the initially empty label with the size big enough to show
+               # the given string.
+               text = Wx::ClientDC.draw_on(self) do |dc|
+                         Wx::StaticText.new(
+                                 self, Wx::ID_ANY, "",
+                                 Wx::Point.new,
+                                 dc.get_text_extent("String of max length"),
+                                 Wx::ST_NO_AUTORESIZE)
+                      end
+            ```

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

@@ -0,0 +1,43 @@
+---
+:wxClipboard:
+  :detail:
+    :pre:
+      :detaileddescription:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+            To use the clipboard, you call member functions of the global {Wx::Clipboard} object passed to the block for {Wx::Clipboard.open}.
+            See the {Wx::DataObject} Overview for further information.
+            Call {Wx::Clipboard.open} to get ownership of the (global) clipboard and execute the given block. You now 
+            own the clipboard passed to the given block. Call {Wx::Clipboard#set_data} to put data on the clipboard, or 
+            {Wx::Clipboard#get_data} to retrieve data from the clipboard. The clipboard is closed and ownership 
+            relinquished when the block returns. You should keep the clipboard open only momentarily.
+            For example:
+            
+            ```ruby
+              # Write some text to the clipboard
+              Wx::Clipboard.open do |clip|
+                # This data object is held by the clipboard
+                clip.place(Wx::TextDataObject.new("Some text"))
+                # or alternatively
+                # clip.set_data(Wx::TextDataObject.new("Some text"))
+              end
+            
+              # Read some text
+              data = Wx::TextDataObject.new
+              Wx::Clipboard.open do |clip|
+                 if clip.supported?(Wx::DF_TEXT)
+                   clip.fetch(data) # or clip.get_data(data)
+                 end
+              end
+              Wx.message_box(data.get_text)
+            ```
+            
+            On GTK, the clipboard behavior can vary depending on the configuration of the end-user's machine. In order 
+            for the clipboard data to persist after the window closes, a clipboard manager must be installed. Some 
+            clipboard managers will automatically flush the clipboard after each new piece of data is added, while others 
+            will not. The {Wx::Clipboard#flush} function will force the clipboard manager to flush the data.
+            
+            === 
+            
+            Category:  Clipboard and Drag & Drop
+            @see  Wx::DataObject 

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

@@ -0,0 +1,21 @@
+---
+:wxCollapsiblePane:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+            
+            ```ruby
+              collpane = Wx::CollapsiblePane.new(self, Wx::ID_ANY, "Details:")
+              
+              # add the pane with a zero proportion value to the 'sz' sizer which contains it
+              sz.add(collpane, 0, Wx::GROW|Wx::ALL, 5)
+              
+              #/ now add a test label in the collapsible pane using a sizer to layout it:
+              win = collpane.get_pane
+              pane_sz = Wx::VBoxSizer
+              pane_sz.add(Wx::StaticText.new(win, Wx::ID_ANY, "test!"), 1, Wx::GROW|Wx::ALL, 2)
+              win.set_sizer(pane_sz)
+              pane_sz.set_size_hints(win)
+            ```