wxruby3 0.9.0.pre.rc.2 → 0.9.0.pre.rc.3

data/rakelib/lib/director/log.rb

@@ -10,19 +10,79 @@ module WXRuby3
     class Log < Director
 
       def setup
-        spec.gc_as_object
-        spec.items.concat(%w[wxLogBuffer wxLogChain wxLogGui wxLogStderr wxLogStream wxLogTextCtrl wxLogInterposer wxLogInterposerTemp wxLogWindow])
-        spec.no_proxy(%w[wxLogBuffer wxLogChain wxLogGui wxLogStderr wxLogTextCtrl wxLogInterposer wxLogInterposerTemp wxLogWindow])
+        spec.gc_as_object %w[wxLog wxLogChain wxLogInterposer wxLogInterposerTemp]
+        spec.items.concat(%w[wxLogBuffer wxLogChain wxLogGui wxLogStderr wxLogStream wxLogTextCtrl wxLogInterposer wxLogInterposerTemp wxLogWindow wxLogNull wxLogRecordInfo])
+        spec.no_proxy(%w[wxLogBuffer wxLogGui wxLogStderr wxLogTextCtrl wxLogWindow])
+        spec.force_proxy(%w[wxLogInterposer wxLogInterposerTemp])
+        spec.regard %w[wxLog::DoLogRecord wxLog::DoLogTextAtLevel wxLog::DoLogText]
         spec.ignore 'wxLogBuffer::Flush'
         spec.ignore 'wxLogGui::Flush'
         if Config.instance.features_set?(%w[wxUSE_STD_IOSTREAM])
           spec.ignore 'wxLogStream'
         end
+        # wxLogStderr
+        spec.ignore 'wxLogStderr::wxLogStderr'
+        spec.add_extend_code 'wxLogStderr', <<~__HEREDOC
+          wxLogStderr(int fh=2)
+          {
+            if (fh == 2)
+            { return new wxLogStderr(); }
+            else if (fh == 1)
+            { return new wxLogStderr(stdout); }
+            rb_raise(rb_eArgError, "Expected 1 (for stdout) or 2 (for stderr).");
+          }
+          __HEREDOC
+        # for wxLogChain
+        spec.disown 'wxLog *logger'
+        spec.ignore 'wxLogChain::DetachOldLog' # too much potential trouble
+        # add override decl missing from xml specs
+        spec.extend_interface 'wxLogChain',
+                              'virtual void DoLogRecord(wxLogLevel level, const wxString& msg, const wxLogRecordInfo& info) override',
+                              visibility: 'protected'
+        # wxLogChain and derivatives need to be allocated disowned because new instances of these classes
+        # are installed as ActiveTarget on construction and so wxWidgets has ownership
+        spec.allocate_disowned 'wxLogChain'
+        spec.allocate_disowned 'wxLogInterposer'
+        spec.allocate_disowned 'wxLogInterposerTemp'
+        spec.allocate_disowned 'wxLogWindow'
+        # for ActiveTarget methods
         spec.ignore 'wxLog::SetThreadActiveTarget'
         spec.disown 'wxLog *logtarget'
+        spec.new_object 'wxLog::SetActiveTarget'
         spec.do_not_generate(:functions)
         spec.make_concrete('wxLog')
-        spec.extend_interface('wxLog', '  virtual ~wxLog ();')
+        spec.extend_interface('wxLog', 'virtual ~wxLog ()')
+        spec.gc_as_untracked 'wxLogRecordInfo'
+        spec.add_extend_code 'wxLogRecordInfo', <<~__HEREDOC
+          VALUE filename()
+          {
+            return $self->filename ? WXSTR_TO_RSTR(wxString($self->filename)) : Qnil;
+          }
+          VALUE line()
+          {
+            return INT2NUM($self->line);
+          }
+          VALUE func()
+          {
+            return $self->func ? WXSTR_TO_RSTR(wxString($self->func)) : Qnil;
+          }
+          VALUE component()
+          {
+            return $self->component ? WXSTR_TO_RSTR(wxString($self->component)) : Qnil;
+          }
+          __HEREDOC
+        spec.make_abstract 'wxLogNull'
+        spec.ignore 'wxLogNull::wxLogNull'
+        spec.add_extend_code 'wxLogNull', <<~__HEREDOC__
+          static void no_log()
+          {
+            if (rb_block_given_p ())
+            {
+              wxLogNull noLog;
+              rb_yield(Qnil);
+            }
+          }
+          __HEREDOC__
         super
       end
     end # class Log

data/rakelib/lib/director/text_entry.rb

@@ -23,6 +23,31 @@ module WXRuby3
         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
+        # for wxTextCompleterSimple::GetCompletions
+        spec.map 'wxArrayString &res' => 'Array<String>' do
+
+          map_in ignore: true, temp: 'wxArrayString tmp', code: '$1 = &tmp;'
+
+          map_argout code: <<~__CODE
+            $result = rb_ary_new();
+            for (size_t i = 0; i < $1->GetCount(); i++)
+            {
+              rb_ary_push($result,WXSTR_TO_RSTR( $1->Item(i) ) );
+            }
+          __CODE
+
+          map_directorargout code: <<~__CODE
+            if (result != Qnil && TYPE(result) == T_ARRAY)
+            {
+              for (int i = 0, n = RARRAY_LEN(result); i < n ;i++)
+              {
+                VALUE rb_comp = rb_ary_entry(result, i);
+                wxString comp = RSTR_TO_WXSTR(rb_comp);
+                $1.Add(comp);
+              }
+            }
+          __CODE
+        end
       end
     end # class TextEntry
 

data/rakelib/lib/director/text_validator.rb

@@ -20,8 +20,8 @@ module WXRuby3
           public:
             WXRubyTextValidator(const wxTextValidator& v) 
               : wxTextValidator(v) {}
-            WXRubyTextValidator(long style=wxFILTER_NONE, wxString *valPtr=NULL) 
-              : wxTextValidator(style, valPtr) {}
+            WXRubyTextValidator(long style=wxFILTER_NONE) 
+              : wxTextValidator(style) {}
             virtual ~WXRubyTextValidator() 
             {
               wxRuby_ReleaseEvtHandlerProcs(this);
@@ -29,6 +29,12 @@ module WXRuby3
           };
         __HEREDOC
         spec.use_class_implementation 'wxTextValidator', 'WXRubyTextValidator'
+        # ignore copy ctor doc
+        spec.regard 'wxTextValidator::wxTextValidator(const wxTextValidator&)', regard_doc: false
+        # ignore this ctor
+        spec.ignore 'wxTextValidator::wxTextValidator(long, wxString*)'
+        # add alternative
+        spec.extend_interface 'wxTextValidator', 'wxTextValidator(long style=wxFILTER_NONE)'
         spec.no_proxy 'wxTextValidator::Clone'
         spec.new_object 'wxTextValidator::Clone'
         # handle clone mapping

data/rakelib/lib/director/variant.rb

@@ -437,10 +437,6 @@ module WXRuby3
                 return true;
               }
           
-          //#if wxUSE_ANY
-          //    // Converts value to wxAny, if possible. Return true if successful.
-          //    virtual bool GetAsAny(wxAny* WXUNUSED(any)) const { return false; }
-          //#endif
           protected:
               VALUE m_value;
           };
@@ -462,6 +458,21 @@ module WXRuby3
           }
           __HEREDOC
         spec.add_init_code 'wxRuby_AppendMarker(wxRuby_markRbValueVariants);'
+        # ignore GetType (not doc)
+        spec.ignore 'wxVariant::GetType', ignore_doc: false
+        # replace with custom implementation
+        spec.add_extend_code 'wxVariant', <<~__HEREDOC
+          VALUE get_type()
+          {
+            wxString ts = self->GetType();
+            if (ts == WXRBValueVariantData::type_name_)
+            {
+              VALUE klass = CLASS_OF(((WXRBValueVariantData*)self->GetData())->GetValue());
+              return rb_str_new2(rb_class2name(CLASS_OF(klass)));
+            }
+            return WXSTR_TO_RSTR(ts);
+          }
+          __HEREDOC
         # add custom extension methods 'assign' as replacement for operator=
         spec.add_extend_code 'wxVariant', <<~__HEREDOC
           void assign(const wxVariant& v)
@@ -504,6 +515,7 @@ module WXRuby3
             if (ts == wxS("ulonglong")) return ULL2NUM(self->GetULongLong().GetValue());
             if (ts == wxS("double")) return rb_funcall(SWIG_From_double(self->GetDouble()), to_i_id(), 0);
             if (ts == wxS("datetime")) return rb_funcall(wxRuby_wxDateTimeToRuby(self->GetDateTime()), to_i_id(), 0);
+            if (ts == WXRBValueVariantData::type_name_) return rb_funcall(((WXRBValueVariantData*)self->GetData())->GetValue(), to_i_id(), 0);
             rb_raise(rb_eTypeError, "Cannot convert Variant<%s> to Integer", (const char*)ts.ToAscii());
             return Qnil;
           }
@@ -519,6 +531,7 @@ module WXRuby3
             if (ts == wxS("ulonglong")) return rb_funcall(ULL2NUM(self->GetULongLong().GetValue()), to_f_id(), 0);
             if (ts == wxS("double")) return SWIG_From_double(self->GetDouble());
             if (ts == wxS("datetime")) return rb_funcall(wxRuby_wxDateTimeToRuby(self->GetDateTime()), to_f_id(), 0);
+            if (ts == WXRBValueVariantData::type_name_) return rb_funcall(((WXRBValueVariantData*)self->GetData())->GetValue(), to_f_id(), 0);
             rb_raise(rb_eTypeError, "Cannot convert Variant<%s> to Integer", (const char*)ts.ToAscii());
             return Qnil;
           }

data/rakelib/lib/extractor/function.rb

@@ -109,7 +109,7 @@ module WXRuby3
                   else
                     rb_param_name(paramdef.name)
                   end
-            params << { name: pnm, type: arg.type }
+            params << { name: pnm, type: arg.type || xml_trans.type_to_doc(paramdef.type) }
             if paramdef.default
               defexp = rb_constant_expression(paramdef.default, xml_trans.constants_xref_db)
               # in case the default expression dereferences a pointer or passes an address clean it up
@@ -142,7 +142,7 @@ module WXRuby3
         params.each do |p|
           doclns << ('@param '  << p[:name] << ' [' << p[:type] << '] ' << (p[:doc] ? ' '+(p[:doc].split("\n").join("\n  ")) : ''))
         end
-        result = [rb_return_type(type_maps)]
+        result = [rb_return_type(type_maps, xml_trans)]
         result.concat(mapped_ret_args.collect { |mra| mra.type }) if mapped_ret_args
         result.compact! # remove nil values (possible ignored output)
         case result.size
@@ -156,9 +156,9 @@ module WXRuby3
         [rb_decl_name, paramlist, doclns]
       end
 
-      def rb_return_type(type_maps)
-        mapped_type = type_maps.map_output(type)
-        (mapped_type.empty? || mapped_type == 'void') ? nil : mapped_type
+      def rb_return_type(type_maps, xml_trans)
+        mapped_type = type_maps.map_output(type) || xml_trans.type_to_doc(type)
+        mapped_type == 'void' ? nil : mapped_type
       end
 
       def argument_list
@@ -304,9 +304,9 @@ module WXRuby3
         end
       end
 
-      def rb_return_type(type_maps)
+      def rb_return_type(type_maps, xml_trans)
         if is_ctor
-          rb_wx_name(class_name)
+          xml_trans.type_to_doc(class_name)
         else
           super
         end

data/rakelib/lib/extractor/variable.rb

@@ -80,9 +80,9 @@ module WXRuby3
         ignore # ignore all member variables by default (trust on availability of accessor methods)
       end
 
-      def rb_return_type(type_maps)
-        mapped_type = type_maps.map_output(type)
-        (mapped_type.empty? || mapped_type == 'void') ? nil : mapped_type
+      def rb_return_type(type_maps, xml_trans)
+        mapped_type = type_maps.map_output(type) || xml_trans.type_to_doc(type)
+        mapped_type == 'void' ? nil : mapped_type
       end
       private :rb_return_type
 
@@ -97,7 +97,7 @@ module WXRuby3
         doc = []
         # first document the reader
         doc << [var_doc.dup]
-        doc.last << "@return [#{rb_return_type(type_maps)}]"
+        doc.last << "@return [#{rb_return_type(type_maps, xml_trans)}]"
         doc << "def #{is_static ? 'self.' : ''}#{rb_method_name(rb_name || name)}; end"
         # next document the writer (if any)
         unless no_setter
@@ -108,9 +108,9 @@ module WXRuby3
                                 array: false)]
           mapped_args, _ = type_maps.map_input(parms)
           if mapped_args.empty? # something went wrong!
-            doc.last << "@param val [#{Typemap.wx_type_to_rb(type)}]"
+            doc.last << "@param val [#{xml_trans.type_to_doc(type)}]"
           else
-            doc.last << "@param val [#{mapped_args.first.type}]"
+            doc.last << "@param val [#{mapped_args.first.type || xml_trans.type_to_doc(type)}]"
           end
           doc.last << "@return [void]"
           doc << "def #{is_static ? 'self.' : ''}#{rb_method_name(rb_name || name)}=(val); end"

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

@@ -0,0 +1,21 @@
+---
+:wxAuiManager:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /AddPane/
+          :replace: |
+            
+            ```ruby
+              @text1 = Wx::TextCtrl.new(self, -1)
+              @text2 = Wx::TextCtrl.new(self, -1)
+              @mgr.add_pane(@text1, Wx::LEFT, 'Pane Caption')
+              @mgr.add_pane(@text2, Wx::BOTTOM, 'Pane Caption')
+              @mgr.update
+            ```
+        - :pattern: !ruby/regexp /GetPane/
+          :replace: |
+            
+            ```ruby
+              @mgr.get_pane(@text1).float
+            ```

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

@@ -0,0 +1,29 @@
+---
+:wxFont.wxFont:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /wxFontInfo/
+          :replace: |
+            
+            ```ruby
+              font = Wx::Font.new(Wx::FontInfo.new(10).bold().underlined())
+            ```
+        - :pattern: !ruby/regexp /wxFONTFAMILY_DEFAULT/
+          :replace: |
+            
+            ```ruby
+              font = Wx::Font.new(10, Wx::FontFamily::FONTFAMILY_DEFAULT, 
+                                  Wx::FontStyle::FONTSTYLE_NORMAL, 
+                                  Wx::FontWeight::FONTWEIGHT_BOLD, true)
+            ```
+:wxFontInfo:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+            
+            ```ruby
+              font = Wx::Font.new(Wx::FontInfo.new(12).face_name('Helvetica').italic())
+            ```

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

@@ -0,0 +1,23 @@
+---
+:wxFrame:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+            
+            ```ruby
+              Wx::DEFAULT_FRAME_STYLE & ~(Wx::RESIZE_BORDER | Wx::MAXIMIZE_BOX)
+            ```
+:wxFrame.MSWGetTaskBarButton:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+            
+            ```ruby
+              if Wx::PLATFORM == 'WXMSW'
+                #...
+              end
+            ```

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

@@ -0,0 +1,11 @@
+---
+:wxFSFile.wxFSFile:
+  :detail:
+    :pre:
+      :para:
+        - :pattern: !ruby/regexp /It is seldom used by the application programmer/
+          :replace: ''
+
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: ''

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

@@ -0,0 +1,36 @@
+---
+:wxPoint.SetDefaults:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+
+            ```ruby
+              if !pos.is_fully_specified
+                pos.set_defaults(get_default_position)
+              end
+            ```
+:wxPoint.wxPoint:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+
+            ```ruby
+              real_point = ...
+              p = Wx::Point.new(real_point.x.round, real_point.y.round)
+            ```
+:wxSize.SetDefaults:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+
+            ```ruby
+              if !size.is_fully_specified
+                size.set_defaults(get_default_size)
+              end
+            ```

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

@@ -0,0 +1,34 @@
+---
+:wxGraphicsContext:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+
+            ```ruby
+              class MyCanvas < Wx::ScrolledWindow
+            
+                def on_paint(event)
+                   # Create paint DC
+                   self.paint do |dc|
+                     # Create graphics context from it
+                     Wx::GraphicsContext.draw_on(dc) do |gc|
+                         # make a path that contains a circle and some lines
+                         gc.set_pen(Wx::RED_PEN)
+                         path = gc.create_path
+                         path.add_circle(50.0, 50.0, 50.0)
+                         path.move_to_point(0.0, 50.0)
+                         path.add_line_to_point(100.0, 50.0)
+                         path.move_to_point(50.0, 0.0)
+                         path.add_line_to_point(50.0, 100.0)
+                         path.close_sub_path
+                         path.add_rectangle(25.0, 25.0, 50.0, 50.0)
+                  
+                         gc.stroke_path(path)
+                      end
+                    end
+                  end
+                end
+              end
+            ```

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

@@ -0,0 +1,12 @@
+---
+:wxGUIEventLoop.Dispatch:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+
+            ```ruby
+              while evt_loop.pending
+                evt_loop.dispatch
+            ```

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

@@ -0,0 +1,24 @@
+---
+:wxHelpController.SetViewer:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+
+            ```ruby
+              @help.set_viewer('kdehelp')
+              @help.set_viewer('gnome-help-browser')
+              @help.set_viewer('netscape', Wx::HELP_NETSCAPE)
+            ```
+:wxHelpController:
+  :detail:
+    :pre:
+      :para:
+        - :pattern: !ruby/regexp /Note\s+that\s+if\s+you\s+use\s+\.zip.*application\s+initialization:/
+          :subst: 'Note that in Ruby the required filesystem handlers for .zip or .htb books are always loaded.'
+        - :pattern: !ruby/regexp / or\s+nothing\s+will\s+be\s+shown\s+in\s+your\s+help\s+window./
+          :subst: ''
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: ''

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

@@ -0,0 +1,11 @@
+---
+:wxIcon.GetIcon:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+
+            ```ruby
+              get_icon(Wx::Size.new(size,size))
+            ```

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

@@ -0,0 +1,87 @@
+---
+:wxImage.Scale:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+
+            ```ruby
+              # get the bitmap from somewhere
+              bmp = ...
+              
+              # rescale it to have size of 32*32
+              if bmp.width != 32 || bmp.height != 32
+                 image = bmp.convert_to_image
+                 bmp = Wx::Bitmap.new(image.scale(32, 32))
+              
+                 # another possibility:
+                 image.rescale(32, 32)
+                 bmp = image.to_bitmap
+              end
+            ```
+:wxImage.LoadFile:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+
+            ```ruby
+              hotspot_x = image.get_option_int(Wx::IMAGE_OPTION_CUR_HOTSPOT_X)
+              hotspot_y = image.get_option_int(Wx::IMAGE_OPTION_CUR_HOTSPOT_Y)
+            ```
+:wxImage.SaveFile:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+
+            ```ruby
+              image.set_option(Wx::IMAGE_OPTION_CUR_HOTSPOT_X, hotspot_x)
+              image.set_option(Wx::IMAGE_OPTION_CUR_HOTSPOT_Y, hotspot_y)
+            ```
+:wxImage.SetLoadFlags:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+
+            ```ruby
+              image = Wx::Image.new
+              image.set_load_flags(image.get_load_flags & ~Wx::Image::Load_Verbose)
+              image.load_file(...)
+            ```
+:wxImage.wxImage:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+
+            ```ruby
+              hotspot_x = image.get_option_int(Wx::IMAGE_OPTION_CUR_HOTSPOT_X)
+              hotspot_y = image.get_option_int(Wx::IMAGE_OPTION_CUR_HOTSPOT_Y)
+            ```
+:wxImage.GetImageExtWildcard:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+
+            ```ruby
+              Wx::FileDialog(self, 'Choose Image', Dir.getwd, '',
+                             'Image Files ' + Wx::Image.get_image_ext_wildcard,
+                             Wx::FD_OPEN) do |file_dlg|
+                # ...
+              end
+            ```
+:wxImage:
+  :detail:
+    :pre:
+      :para:
+        - :pattern: !ruby/regexp /To\s+use\s+other\s+image\s+formats,.*or\s+call\s+.*\./
+          :subst: 'In wxRuby all image handlers are loaded by default at startup by {init_all_image_handlers}.'

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

@@ -0,0 +1,19 @@
+---
+:wxKeyboardState.GetModifiers:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /ControlDown/
+          :replace: |
+
+            ```ruby
+              if control_down && !alt_down && !shift_down && !meta_down
+                ... handle Ctrl-XXX ...
+            ```
+        - :pattern: !ruby/regexp /GetModifiers/
+          :replace: |
+
+            ```ruby
+              if get_modifiers == Wx::MOD_CONTROL
+                ... handle Ctrl-XXX ...
+            ```

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

@@ -0,0 +1,77 @@
+---
+:wxListCtrl.GetNextItem:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+
+            ```ruby
+              item = -1
+              while (item = list_ctrl.get_next_item(item, Wx::LIST_NEXT_ALL, Wx::LIST_STATE_SELECTED)) != -1
+                # item is selected - do whatever is needed with it
+                Wx.log_message("Item #{item} is selected.")
+              end
+            
+              # alternatively in wxRuby you could do
+              list_ctrl.each_selected do |item|
+                Wx.log_message("Item #{item} is selected.")
+              end
+            ```
+:wxListCtrl.SetItemState:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /item.*wxLIST_STATE_SELECTED.*wxLIST_STATE_SELECTED/
+          :replace: |
+
+            ```ruby
+              list.set_item_state(item, Wx::LIST_STATE_SELECTED, Wx::LIST_STATE_SELECTED)
+            ```
+        - :pattern: !ruby/regexp /item.*0.*wxLIST_STATE_SELECTED/
+          :replace: |
+
+            ```ruby
+              list.set_item_state(item, 0, Wx::LIST_STATE_SELECTED)
+            ```
+:wxListCtrl.GetUpdatedAscendingSortIndicator:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+
+            ```ruby
+              class MyListCtrl
+            
+                def on_col_click(event)
+                  col = event.column
+                  if col == -1
+                     return # clicked outside any column.
+              
+                  ascending = get_updated_ascending_sort_indicator(col)
+                  sort_items(ascending) { |itm1_data, itm2_data, data| ... }
+                  show_sort_indicator(col, ascending)
+                end
+            
+              end
+            ```
+:wxListCtrl:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+
+            ```ruby
+              list = Wx::ListCtrl.new(...)
+              3.times { |i| list.insert_column(i, "Column #{i}") }
+              
+              order = [2, 0, 1]
+              list.set_columns_order(order)
+              
+              # now list.get_columns_order() will return order and
+              # list.get_column_index_from_order(n) will return order[n] and
+              # list.get_column_order() will return 1, 2 and 0 for the column 0,
+              # 1 and 2 respectively
+            ```

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

@@ -0,0 +1,12 @@
+---
+:wxLocale:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: ''
+        - :pattern: !ruby/regexp /.*/
+          :replace: ''
+      :para:
+        - :pattern: !ruby/regexp /If\s+you\s+need\s+to\s+translate\s+a\s+lot\s+of\s+strings.*/
+          :replace: ''