wxruby3 0.9.0.pre.beta.14-x64-mingw-ucrt → 0.9.0.pre.rc.2-x64-mingw-ucrt

data/lib/wx/doc/gen/sizer.rb

@@ -222,8 +222,9 @@ module Wx
     
     # This base function adds non-stretchable space to both the horizontal and vertical orientation of the sizer.
     # More readable way of calling: 
-    # 
+    # ```
     #   wxSizer::Add(size, size, 0).
+    # ```
     # @see Wx::BoxSizer#add_spacer 
     # @param size [Integer] 
     # @return [Wx::SizerItem]
@@ -231,8 +232,9 @@ module Wx
     
     # Adds stretchable space to the sizer.
     # More readable way of calling: 
-    # 
+    # ```
     #   wxSizer::Add(0, 0, prop).
+    # ```
     # @param prop [Integer] 
     # @return [Wx::SizerItem]
     def add_stretch_spacer(prop=1) end
@@ -623,7 +625,7 @@ module Wx
     # This method first calls {Wx::Sizer#fit} and then {Wx::TopLevelWindow#set_size_hints} on the window passed to it.
     # This function is only when window is actually a {Wx::TopLevelWindow} such as a {Wx::Frame} or a {Wx::Dialog}, since SetSizeHints only has any effect in these classes. It does nothing in normal windows or controls.
     # Note that window does not need to be the window using this sizer and it is, in fact, common to call this function on the sizer associated with the panel covering the client area of a frame passing it the frame pointer, as this has the desired effect of adjusting the frame size to the size fitting the panel, e.g.: 
-    # 
+    # ```
     #   MyFrame::MyFrame(...) : wxFrame(...)
     #   {
     #       wxPanel* panel = new wxPanel(this);
@@ -636,6 +638,7 @@ module Wx
     #       // frame to fit its contents.
     #       sizer->SetSizeHints(this);
     #   }
+    # ```
     # 
     # This function is also used by {Wx::Window#set_sizer_and_fit} which is commonly invoked in the constructor of {Wx::Dialog}-derived classes, which don't need to use an intermediate panel, see the example in wxBoxSizer overview.
     # @param window [Wx::Window] 
@@ -686,19 +689,25 @@ module Wx
   # Container for sizer items flags providing readable names for them.
   # Normally, when you add an item to a sizer via {Wx::Sizer#add}, you have to specify a lot of flags and parameters which can be unwieldy. This is where {Wx::SizerFlags} comes in: it allows you to specify all parameters using the named methods instead. For example, instead of
   # 
+  # ```
   #   sizer->Add(ctrl, 0, wxEXPAND | wxALL, 10);
+  # ```
   # 
   # you can now write
   # 
+  # ```
   #   sizer->Add(ctrl, wxSizerFlags().Expand().Border(wxALL, 10));
+  # ```
   # 
   # This is more readable and also allows you to create {Wx::SizerFlags} objects which can be reused for several sizer items.
   # 
+  # ```
   #   wxSizerFlags flagsExpand(1);
   #       flagsExpand.Expand().Border(wxALL, 10);
   #   
   #       sizer->Add(ctrl1, flagsExpand);
   #       sizer->Add(ctrl2, flagsExpand);
+  # ```
   # 
   # Note that by specification, all methods of {Wx::SizerFlags} return the {Wx::SizerFlags} object itself to allowing chaining multiple methods calls like in the examples above.
   # === 
@@ -707,6 +716,8 @@ module Wx
   # @see Wx::Sizer 
   # 
   # 
+  # 
+  # @note This class is <b>untracked</b> and should not be derived from nor instances extended!
   class SizerFlags < ::Object
   
     # Creates the {Wx::Sizer} with the proportion specified by proportion.

data/lib/wx/doc/gen/splash_screen.rb

@@ -25,6 +25,7 @@ module Wx
   # Show it in application initialisation, and then either explicitly destroy it or let it time-out.
   # Example usage:
   # 
+  # ```
   #   wxBitmap bitmap;
   #   if (bitmap.LoadFile("splash16.png", wxBITMAP_TYPE_PNG))
   #   {
@@ -34,6 +35,7 @@ module Wx
   #           wxBORDER_SIMPLE|wxSTAY_ON_TOP);
   #   }
   #   wxYield();
+  # ```
   # 
   # === 
   # 

data/lib/wx/doc/gen/static_box.rb

@@ -9,7 +9,7 @@ module Wx
   # A static box is a rectangle drawn around other windows to denote a logical grouping of items.
   # Note that while the previous versions required that windows appearing inside a static box be created as its siblings (i.e. use the same parent as the static box itself), since wxWidgets 2.9.1 it is possible to create them as children of {Wx::StaticBox} itself and doing this is strongly recommended and avoids several different repainting problems that could happen when creating the other windows as siblings of the box.
   # So the recommended way to create static box and the controls inside it is: 
-  # 
+  # ```
   #   void MyFrame::CreateControls()
   #   {
   #       wxPanel *panel = new wxPanel(this);
@@ -18,6 +18,7 @@ module Wx
   #       new wxStaticText(box, wxID_ANY, "This window is a child of the staticbox");
   #       ...
   #   }
+  # ```
   # 
   # Creating the windows with the static box parent (i.e. panel in the example above) as parent still works but can result in refresh and repaint problems.
   # Also note that there is a specialized {Wx::Sizer} class ({Wx::StaticBoxSizer}) which can be used as an easier way to pack items into a static box.
@@ -53,7 +54,7 @@ module Wx
     #   This constructor takes a pointer to an arbitrary window (although usually a {Wx::CheckBox} or a {Wx::RadioButton}) instead of just the usual text label and puts this window at the top of the box at the place where the label would be shown.
     #   The label window must be a non-null, fully created window and will become a child of this {Wx::StaticBox}, i.e. it will be owned by this control and will be deleted when the {Wx::StaticBox} itself is deleted.
     #   An example of creating a {Wx::StaticBox} with window as a label: 
-    #   
+    #   ```
     #     void MyFrame::CreateControls()
     #     {
     #         wxPanel* panel = new wxPanel(this);
@@ -61,6 +62,7 @@ module Wx
     #         wxStaticBox* box = new wxStaticBox(panel, wxID_ANY, checkbox);
     #         ...
     #     }
+    #   ```
     #   
     #   Currently this constructor is only available in {Wx::GTK} and {Wx::MSW}, use {Wx::HAS_WINDOW_LABEL_IN_STATIC_BOX} to check whether it can be used at compile-time.
     #   @param parent [Wx::Window] 
@@ -102,13 +104,14 @@ module Wx
     # Enables or disables the box without affecting its label window, if any.
     # {Wx::StaticBox} overrides {Wx::Window#enable} in order to avoid disabling the control used as a label, if this box is using one. This is done in order to allow using a {Wx::CheckBox}, for example, label and enable or disable the box according to the state of the checkbox: if disabling the box also disabled the checkbox in this situation, it would make it impossible for the user to re-enable the box after disabling it, so the checkbox stays enabled even if <code>box->Enable(false)</code> is called.
     # However with the actual behaviour, implemented in this overridden method, the following code (shown using C++11 only for convenience, this behaviour is not C++11-specific): 
-    # 
+    # ```
     #   auto check = new wxCheckBox(parent, wxID_ANY, "Use the box");
     #   auto box = new wxStaticBox(parent, wxID_ANY, check);
     #   check->Bind(wxEVT_CHECKBOX,
     #               [box](wxCommandEvent& event) {
     #                   box->Enable(event.IsChecked());
     #               });
+    # ```
     #  does work as expected.
     # Please note that overriding {Wx::StaticBox#enable} to not actually disable this window itself has two possibly unexpected consequences:
     # 

data/lib/wx/doc/gen/static_box_sizer.rb

@@ -10,7 +10,7 @@ module Wx
   # The static box may be either created independently or the sizer may create it itself as a convenience. In any case, the sizer owns the {Wx::StaticBox} control and will delete it in the {Wx::StaticBoxSizer} destructor.
   # Note that since wxWidgets 2.9.1 you are strongly encouraged to create the windows which are added to {Wx::StaticBoxSizer} as children of {Wx::StaticBox} itself, see this class documentation for more details.
   # Example of use of this class: 
-  # 
+  # ```
   #   void MyFrame::CreateControls()
   #   {
   #       wxPanel *panel = new wxPanel(this);
@@ -20,6 +20,7 @@ module Wx
   #                                "This window is a child of the staticbox"));
   #       ...
   #   }
+  # ```
   # 
   # === 
   # 

data/lib/wx/doc/gen/status_bar.rb

@@ -90,8 +90,6 @@ module Wx
     
     # Returns the size and position of a field's internal bounding rectangle.
     # true if the field index is valid, false otherwise.
-    # 
-    # <b>{Wx::Perl} Note:</b> In {Wx::Perl} this function returns a Wx::Rect if the field index is valid, undef otherwise.
     # @see Wx::Rect 
     # @param i [Integer]  The field in question.
     # @return [Array(true,false,Wx::Rect)]
@@ -153,7 +151,6 @@ module Wx
     def push_status_text(string, field=0) end
     
     # Sets the number of fields, and optionally the field widths.
-    # <b>{Wx::Perl} Note:</b> In {Wx::Perl} this function accepts only the number parameter. Use SetStatusWidths to set the field widths.
     # @param number [Integer]  The number of fields. If this is greater than the previous number, then new fields with empty strings will be added to the status bar.
     # @param widths [Array<Integer>]  An array of n integers interpreted in the same way as in {Wx::StatusBar#set_status_widths}.
     # @return [void]
@@ -189,8 +186,6 @@ module Wx
     # For example, to create one fixed width field of width 100 in the right part of the status bar and two more fields which get 66% and 33% of the remaining space correspondingly, you should use an array containing -2, -1 and 100.
     # 
     # The widths of the variable fields are calculated from the total width of all fields, minus the sum of widths of the non-variable fields, divided by the number of variable fields.
-    # 
-    # <b>{Wx::Perl} Note:</b> In {Wx::Perl} this method takes as parameters the field widths.
     # @see Wx::StatusBar#set_fields_count
     # @see  Wx::Frame#set_status_widths 
     # @param widths_field [Array<Integer>]  Contains an array of n integers, each of which is either an absolute status field width in pixels if positive or indicates a variable width field if negative. The special value NULL means that all fields should get the same width.

data/lib/wx/doc/gen/stc/styled_text_ctrl.rb

@@ -25,6 +25,8 @@ module Wx::STC
   # 
   class StyledTextCtrl < Control
   
+    include Wx::TextEntry
+  
     # @overload initialize(parent, id=Wx::StandardID::ID_ANY, pos=Wx::DEFAULT_POSITION, size=Wx::DEFAULT_SIZE, style=0, name=Wx::STCNameStr)
     #   Ctor.
     #   @param parent [Wx::Window] 
@@ -3850,6 +3852,7 @@ module Wx::STC
     # Notice that insertion position is, in general, different from the index of the character the cursor position at in the string returned by {Wx::STC::StyledTextCtrl#get_value}. While this is always the case for the single line controls, multi-line controls can use two characters <code>"\\r\\n"</code> as line separator (this is notably the case under MSW) meaning that indices in the control and its string value are offset by 1 for every line.
     # Hence to correctly get the character at the current cursor position, taking into account that there can be none if the cursor is at the end of the string, you could do the following:
     # 
+    # ```
     #   wxString GetCurrentChar(wxTextCtrl *tc)
     #   {
     #       long pos = tc->GetInsertionPoint();
@@ -3858,6 +3861,7 @@ module Wx::STC
     #   
     #       return tc->GetRange(pos, pos + 1);
     #   }
+    # ```
     # @return [Integer]
     def get_insertion_point; end
     alias_method :insertion_point, :get_insertion_point
@@ -3882,8 +3886,6 @@ module Wx::STC
     
     # Gets the current selection span.
     # If the returned values are equal, there was no selection. Please note that the indices returned may be used with the other {Wx::TextCtrl} methods but don't necessarily represent the correct indices into the string returned by {Wx::STC::StyledTextCtrl#get_value} for multiline controls under Windows (at least,) you should use {Wx::STC::StyledTextCtrl#get_string_selection} to get the selected text.
-    # 
-    # <b>{Wx::Perl} Note:</b> In {Wx::Perl} this method takes no parameters and returns a 2-element list (from, to).
     # @return [Array(Integer, Integer)]
     def get_selection; end
     alias_method :selection, :get_selection
@@ -3968,8 +3970,6 @@ module Wx::STC
     
     # Converts given position to a zero-based column, line number pair.
     # true on success, false on failure (most likely due to a too large position parameter).
-    # 
-    # <b>{Wx::Perl} Note:</b> In {Wx::Perl} this function takes only the pos argument and returns a 2-element list (x, y).
     # @see Wx::STC::StyledTextCtrl#xy_to_position 
     # @param pos [Integer]  Position.
     # @return [Array(true,false,Array(Integer, Integer))]
@@ -3983,7 +3983,6 @@ module Wx::STC
     # Finds the row and column of the character at the specified point.
     # If the return code is not {Wx::TextCtrlHitTestResult::TE_HT_UNKNOWN} the row and column of the character closest to this position are returned, otherwise the output parameters are not modified.
     # Please note that this function is currently only implemented in {Wx::Univ}, {Wx::MSW} and {Wx::GTK2} ports and always returns {Wx::TextCtrlHitTestResult::TE_HT_UNKNOWN} in the other ports.
-    # <b>{Wx::Perl} Note:</b> In {Wx::Perl} this function takes only the pt argument and returns a 3-element list (result, col, row).
     # @see Wx::STC::StyledTextCtrl#position_to_xy
     # @see  Wx::STC::StyledTextCtrl#xy_to_position 
     # @param pt [Array(Integer, Integer), Wx::Point]  The position of the point to check, in window device coordinates.

data/lib/wx/doc/gen/svg_file_dc.rb

@@ -43,26 +43,19 @@ module Wx
   # 
   # Category:  Device Contexts
   # 
+  # 
+  # @note This class is <b>untracked</b> and should not be derived from nor instances extended!
   class SVGFileDC < DC
   
-    # Initializes a {Wx::SVGFileDC} with the given filename, width and height at dpi resolution, and an optional title.
-    # The title provides a readable name for the SVG document.
-    # @param filename [String] 
-    # @param width [Integer] 
-    # @param height [Integer] 
-    # @param dpi [Float] 
-    # @param title [String] 
-    # @return [SVGFileDC]
-    def initialize(filename, width=320, height=240, dpi=72, title=(())) end
-    
     # Draws a rectangle the size of the SVG using the {Wx::DC#set_background} brush.
     # @return [void]
     def clear; end
     
     # Replaces the default bitmap handler with handler.
     # By default, an object of {Wx::SVGBitmapFileHandler} class is used as bitmap handler. You may want to replace it with an object of predefined {Wx::SVGBitmapEmbedHandler} class to embed the bitmaps in the generated SVG instead of storing them in separate files like this: 
-    # 
+    # ```
     #   mySVGFileDC->SetBitmapHandler(new wxSVGBitmapEmbedHandler());
+    # ```
     # 
     # or derive your own bitmap handler class and use it if you need to customize the bitmap handling further.
     # @param handler [Wx::SVGBitmapHandler]  The new bitmap handler. If non-NULL, this object takes ownership of this handler and will delete it when it is not needed any more.
@@ -88,6 +81,8 @@ module Wx
   # 
   # Category:  Device Contexts
   # 
+  # 
+  # @note This class is <b>untracked</b> and should not be derived from nor instances extended!
   class SVGBitmapHandler < ::Object
   
     # Writes the bitmap representation as SVG to the given stream.
@@ -111,6 +106,8 @@ module Wx
   # @see Wx::SVGFileDC#set_bitmap_handler.
   # 
   # 
+  # 
+  # @note This class is <b>untracked</b> and should not be derived from nor instances extended!
   class SVGBitmapFileHandler < SVGBitmapHandler
   
     # Create a {Wx::SVGBitmapFileHandler} and specify the location where the file will be saved.
@@ -136,6 +133,8 @@ module Wx
   # @see Wx::SVGFileDC#set_bitmap_handler.
   # 
   # 
+  # 
+  # @note This class is <b>untracked</b> and should not be derived from nor instances extended!
   class SVGBitmapEmbedHandler < SVGBitmapHandler
   
     # Writes the bitmap representation as SVG to the given stream.

data/lib/wx/doc/gen/text_ctrl.rb

@@ -522,33 +522,40 @@ module Wx
   # In either case, if the style doesn't specify some of the attributes (for example you only want to set the text colour but without changing the font nor the text background), the values of the default style will be used for them. If there is no default style, the attributes of the text control itself are used.
   # So the following code correctly describes what it does: the second call to {Wx::TextCtrl#set_default_style} doesn't change the text foreground colour (which stays red) while the last one doesn't change the background colour (which stays grey):
   # 
+  # ```
   #   text->SetDefaultStyle(wxTextAttr(*wxRED));
   #   text->AppendText("Red text\n");
   #   text->SetDefaultStyle(wxTextAttr(wxNullColour, *wxLIGHT_GREY));
   #   text->AppendText("Red on grey text\n");
   #   text->SetDefaultStyle(wxTextAttr(*wxBLUE));
   #   text->AppendText("Blue on grey text\n");
+  # ```
   # 
   # == wxTextCtrl and C++ Streams
   # 
   # This class multiply-inherits from std::streambuf (except for some really old compilers using non-standard iostream library), allowing code such as the following:
   # 
+  # ```
   #   wxTextCtrl *control = new wxTextCtrl(...);
   #   
   #   ostream stream(control)
   #   
   #   stream << 123.456 << " some text\n";
   #   stream.flush();
+  # ```
   # 
   # Note that even if your build of wxWidgets doesn't support this (the symbol {Wx::HAS_TEXT_WINDOW_STREAM} has value of 0 then) you can still use {Wx::TextCtrl} itself in a stream-like manner:
   # 
+  # ```
   #   wxTextCtrl *control = new wxTextCtrl(...);
   #   
   #   *control << 123.456 << " some text\n";
+  # ```
   # 
   # However the possibility to create a std::ostream associated with {Wx::TextCtrl} may be useful if you need to redirect the output of a function taking a std::ostream as parameter to a text control.
   # Another commonly requested need is to redirect std::cout to the text control. This may be done in the following way:
   # 
+  # ```
   #   #include <iostream>
   #   
   #   wxTextCtrl *control = new wxTextCtrl(...);
@@ -560,9 +567,11 @@ module Wx
   #   ...
   #   
   #   std::cout.rdbuf(sbOld);
+  # ```
   # 
   # But wxWidgets provides a convenient class to make it even simpler so instead you may just do
   # 
+  # ```
   #   #include <iostream>
   #   
   #   wxTextCtrl *control = new wxTextCtrl(...);
@@ -571,6 +580,7 @@ module Wx
   #   
   #   // all output to cout goes into the text control until the exit from
   #   // current scope
+  # ```
   # 
   # See {Wx::StreamToTextRedirector} for more details.
   # 
@@ -708,7 +718,6 @@ module Wx
     # Finds the row and column of the character at the specified point.
     # If the return code is not {Wx::TextCtrlHitTestResult::TE_HT_UNKNOWN} the row and column of the character closest to this position are returned, otherwise the output parameters are not modified.
     # Please note that this function is currently only implemented in {Wx::Univ}, {Wx::MSW} and {Wx::GTK} ports and always returns {Wx::TextCtrlHitTestResult::TE_HT_UNKNOWN} in the other ports.
-    # <b>{Wx::Perl} Note:</b> In {Wx::Perl} this function takes only the pt argument and returns a 3-element list (result, col, row).
     # @see Wx::TextCtrl#position_to_xy
     # @see  Wx::TextCtrl#xy_to_position 
     # @param pt [Array(Integer, Integer), Wx::Point]  The position of the point to check, in window device coordinates.
@@ -765,8 +774,6 @@ module Wx
     
     # Converts given position to a zero-based column, line number pair.
     # true on success, false on failure (most likely due to a too large position parameter).
-    # 
-    # <b>{Wx::Perl} Note:</b> In {Wx::Perl} this function takes only the pos argument and returns a 2-element list (x, y).
     # @see Wx::TextCtrl#xy_to_position 
     # @param pos [Integer]  Position.
     # @return [Array(Integer, Integer), nil]

data/lib/wx/doc/gen/text_entry.rb

@@ -135,6 +135,7 @@ module Wx
     # Notice that insertion position is, in general, different from the index of the character the cursor position at in the string returned by {Wx::TextEntry#get_value}. While this is always the case for the single line controls, multi-line controls can use two characters <code>"\\r\\n"</code> as line separator (this is notably the case under MSW) meaning that indices in the control and its string value are offset by 1 for every line.
     # Hence to correctly get the character at the current cursor position, taking into account that there can be none if the cursor is at the end of the string, you could do the following:
     # 
+    # ```
     #   wxString GetCurrentChar(wxTextCtrl *tc)
     #   {
     #       long pos = tc->GetInsertionPoint();
@@ -143,6 +144,7 @@ module Wx
     #   
     #       return tc->GetRange(pos, pos + 1);
     #   }
+    # ```
     # @return [Integer]
     def get_insertion_point; end
     alias_method :insertion_point, :get_insertion_point
@@ -162,8 +164,6 @@ module Wx
     
     # Gets the current selection span.
     # If the returned values are equal, there was no selection. Please note that the indices returned may be used with the other {Wx::TextCtrl} methods but don't necessarily represent the correct indices into the string returned by {Wx::TextEntry#get_value} for multiline controls under Windows (at least,) you should use {Wx::TextEntry#get_string_selection} to get the selected text.
-    # 
-    # <b>{Wx::Perl} Note:</b> In {Wx::Perl} this method takes no parameters and returns a 2-element list (from, to).
     # @return [Array(Integer,Integer)]
     def get_selection; end
     alias_method :selection, :get_selection
@@ -317,6 +317,8 @@ module Wx
   # Custom completer objects used with {Wx::TextEntry#auto_complete} must derive from this class and implement its pure virtual method returning the completions. You would typically use a custom completer when the total number of completions is too big for performance to be acceptable if all of them need to be returned at once but if they can be generated hierarchically, i.e. only the first component initially, then the second one after the user finished entering the first one and so on.
   # When inheriting from this class you need to implement its two pure virtual methods. This allows returning the results incrementally and may or not be convenient depending on where do they come from. If you prefer to return all the completions at once, you should inherit from {Wx::TextCompleterSimple} instead.
   # 
+  # 
+  # @note This class is <b>untracked</b> and should not be derived from nor instances extended!
   class TextCompleter < ::Object
   
     # Function called to start iteration over the completions for the given prefix.
@@ -341,7 +343,7 @@ module Wx
   # A simpler base class for custom completer objects.
   # This class may be simpler to use than the base {Wx::TextCompleter} as it allows to implement only a single virtual method instead of two of them (at the price of storing all completions in a temporary array).
   # Here is a simple example of a custom completer that completes the names of some chess pieces. Of course, as the total list here has only four items it would have been much simpler to just specify the array containing all the completions in this example but the same approach could be used when the total number of completions is much higher provided the number of possibilities for each word is still relatively small: 
-  # 
+  # ```
   #   class MyTextCompleter : public wxTextCompleterSimple
   #   {
   #   public:
@@ -368,9 +370,12 @@ module Wx
   #   ...
   #   wxTextCtrl *text = ...;
   #   text->AutoComplete(new MyTextCompleter);
+  # ```
   # 
   # ===
   # 
+  # 
+  # @note This class is <b>untracked</b> and should not be derived from nor instances extended!
   class TextCompleterSimple < TextCompleter
   
     # Pure virtual method returning all possible completions for the given prefix.

data/lib/wx/doc/gen/text_entry_dialog.rb

@@ -53,7 +53,7 @@ module Wx
     # @overload set_text_validator(validator)
     #   Associate a validator with the text control used by the dialog.
     #   These methods can be used to limit the user entry to only some characters, e.g. 
-    #   
+    #   ```
     #     wxTextEntryDialog dlg(this, ...);
     #     dlg.SetTextValidator(wxFILTER_ALPHA);
     #     if ( dlg.ShowModal() == wxID_OK )
@@ -61,6 +61,7 @@ module Wx
     #         // We can be certain that this string contains letters only.
     #         wxString value = dlg.GetValue();
     #     }
+    #   ```
     #   
     #   The first overload uses the provided validator which can be of a custom class derived from {Wx::TextValidator} while the second one creates a {Wx::TextValidator} with the specified style.
     #   @param validator [Wx::TextValidator] 
@@ -68,7 +69,7 @@ module Wx
     # @overload set_text_validator(style=Wx::TextValidatorStyle::FILTER_NONE)
     #   Associate a validator with the text control used by the dialog.
     #   These methods can be used to limit the user entry to only some characters, e.g. 
-    #   
+    #   ```
     #     wxTextEntryDialog dlg(this, ...);
     #     dlg.SetTextValidator(wxFILTER_ALPHA);
     #     if ( dlg.ShowModal() == wxID_OK )
@@ -76,6 +77,7 @@ module Wx
     #         // We can be certain that this string contains letters only.
     #         wxString value = dlg.GetValue();
     #     }
+    #   ```
     #   
     #   The first overload uses the provided validator which can be of a custom class derived from {Wx::TextValidator} while the second one creates a {Wx::TextValidator} with the specified style.
     #   @param style [TextValidatorStyle] 

data/lib/wx/doc/gen/timer_event.rb

@@ -19,6 +19,7 @@ module Wx
   # {Wx::TimerEvent} object is passed to the event handler of timer events (see {Wx::Timer#set_owner}).
   # For example:
   # 
+  # ```
   #   class MyFrame : public wxFrame
   #   {
   #   public:
@@ -44,6 +45,7 @@ module Wx
   #   {
   #       // do whatever you want to do every second here
   #   }
+  # ```
   # 
   # === 
   # 

data/lib/wx/doc/gen/tool_bar.rb

@@ -96,14 +96,17 @@ module Wx
   # Note that many methods in {Wx::ToolBar} such as {Wx::ToolBar#add_tool} return a <code>wxToolBarToolBase*</code> object. This should be regarded as an opaque handle representing the newly added toolbar item, providing access to its id and position within the toolbar. Changes to the item's state should be made through calls to {Wx::ToolBar} methods, for example {Wx::ToolBar#enable_tool}. Calls to {Wx::ToolBarToolBase} methods (undocumented by purpose) will not change the visible state of the item within the tool bar.
   # After you have added all the tools you need, you must call {Wx::ToolBar#realize} to effectively construct and display the toolbar.
   # <b>{Wx::MSW} note</b>: Note that under {Wx::MSW} toolbar paints tools to reflect system-wide colours. If you use more than 16 colours in your tool bitmaps, you may wish to suppress this behaviour, otherwise system colours in your bitmaps will inadvertently be mapped to system colours. To do this, set the msw.remap system option before creating the toolbar: 
-  # 
+  # ```
   #   wxSystemOptions::SetOption("msw.remap", 0);
+  # ```
   #  If you wish to use 32-bit images (which include an alpha channel for transparency) use: 
-  # 
+  # ```
   #   wxSystemOptions::SetOption("msw.remap", 2);
+  # ```
   #  Then colour remapping is switched off, and a transparent background used. But only use this option under Windows XP with true colour: 
-  # 
+  # ```
   #   if (wxTheApp->GetComCtl32Version() >= 600 && ::wxDisplayDepth() >= 32)
+  # ```
   # 
   # === Styles
   # 
@@ -506,11 +509,12 @@ module Wx
     # It is usually unnecessary to call this function, as the tools will always be made big enough to fit the size of the bitmaps used in them. Moreover, calling it forces {Wx::ToolBar} to scale its images in high DPI using the provided size, instead of letting {Wx::BitmapBundle} used for the tool bitmaps determine the best suitable bitmap size, which may result in suboptimal appearance.
     # If you do call it, it must be done before toolbar is {Wx::ToolBar#realize}'d.
     # Example of using this function to force the bitmaps to be at least 32 pixels wide and tall (at normal DPI): 
-    # 
+    # ```
     #   toolbar->SetToolBitmapSize(FromDIP(wxSize(32, 32)));
     #   toolbar->AddTool(wxID_NEW, "New", wxBitmapBundle::FromXXX(...));
     #   ...
     #   toolbar->Realize();
+    # ```
     # @see Wx::ToolBar#get_tool_bitmap_size
     # @see  Wx::ToolBar#get_tool_size 
     # @param size [Array(Integer, Integer), Wx::Size]  The size of the bitmaps in the toolbar in logical pixels.

data/lib/wx/doc/gen/top_level_window.rb

@@ -164,7 +164,7 @@ module Wx
     # Returns all icons associated with the window, there will be none of them if neither {Wx::TopLevelWindow#set_icon} nor {Wx::TopLevelWindow#set_icons} had been called before.
     # Use {Wx::TopLevelWindow#get_icon} to get the main icon of the window.
     # @see Wx::IconBundle 
-    # @return [void]
+    # @return [Wx::IconBundle]
     def get_icons; end
     alias_method :icons, :get_icons
     
@@ -239,8 +239,9 @@ module Wx
     # Notice that because of the native system limitations the identifiers of the items added to the system menu must be multiples of 16, otherwise no events will be generated for them.
     # The returned pointer must not be deleted, it is owned by the window and will be only deleted when the window itself is destroyed.
     # This function is not available in the other ports by design, any occurrences of it in the portable code must be guarded by 
-    # 
+    # ```
     #   #ifdef __WXMSW__ 
+    # ```
     #  preprocessor guards.
     # @return [Wx::Menu]
     def msw_get_system_menu; end
@@ -434,9 +435,11 @@ module Wx
     # This method is specific to {Wx::Universal} port.
     # Use native or custom-drawn decorations for this window only. Notice that to have any effect this method must be called before really creating the window, i.e. two step creation must be used:
     # 
+    # ```
     #   MyFrame *frame = new MyFrame;       // use default ctor
     #   frame->UseNativeDecorations(false); // change from default "true"
     #   frame->Create(parent, title, ...);  // really create the frame
+    # ```
     # @see Wx::TopLevelWindow#use_native_decorations_by_default
     # @see  Wx::TopLevelWindow#is_using_native_decorations 
     # @param native [true,false] 

data/lib/wx/doc/gen/tree_ctrl.rb

@@ -437,7 +437,6 @@ module Wx
     # If textOnly is true, only the rectangle around the item's label will be returned, otherwise the item's image is also taken into account.
     # The return value is true if the rectangle was successfully retrieved or <code></code> false if it was not (in this case rect is not changed)  for example, if the item is currently invisible.
     # Notice that the rectangle coordinates are logical, not physical ones. So, for example, the x coordinate may be negative if the tree has a horizontal scrollbar and its position is not 0.
-    # <b>{Wx::Perl} Note:</b> In {Wx::Perl} this method only takes the item and textOnly parameters and returns a Wx::Rect (or undef).
     # @param item [Wx::TreeItemId] 
     # @param rect [Wx::Rect] 
     # @param textOnly [true,false] 
@@ -504,7 +503,6 @@ module Wx
     alias_method :item_background_colour, :get_item_background_colour
     
     # Returns the tree item data associated with the item.
-    # <b>{Wx::Perl} Note:</b> {Wx::Perl} provides the following shortcut method:
     # - GetPlData(item): returns the Perl data associated with the Wx::TreeItemData. It is just the same as tree->GetItemData(item)->GetData().
     # @see Wx::TreeItemData
     # @param item [Wx::TreeItemId] 
@@ -619,8 +617,6 @@ module Wx
     # flags is a bitlist of the following:
     # 
     # - {Wx::TREE_HITTEST_ABOVE}: Above the client area.- {Wx::TREE_HITTEST_BELOW}: Below the client area.- {Wx::TREE_HITTEST_NOWHERE}: In the client area but below the last item.- {Wx::TREE_HITTEST_ONITEMBUTTON}: On the button associated with an item.- {Wx::TREE_HITTEST_ONITEMICON}: On the bitmap associated with an item.- {Wx::TREE_HITTEST_ONITEMINDENT}: In the indentation associated with an item.- {Wx::TREE_HITTEST_ONITEMLABEL}: On the label (string) associated with an item.- {Wx::TREE_HITTEST_ONITEMRIGHT}: In the area to the right of an item.- {Wx::TREE_HITTEST_ONITEMSTATEICON}: On the state icon for a tree view item that is in a user-defined state.- {Wx::TREE_HITTEST_TOLEFT}: To the right of the client area.- {Wx::TREE_HITTEST_TORIGHT}: To the left of the client area.
-    # 
-    # <b>{Wx::Perl} Note:</b> In {Wx::Perl} this method only takes the point parameter and returns a 2-element list (item, flags).
     # @param point [Array(Integer, Integer), Wx::Point] 
     # @return [Array(Wx::TreeItemId,Integer)]
     def hit_test(point) end
@@ -736,8 +732,6 @@ module Wx
     
     # Sets the item client data.
     # Notice that the client data previously associated with the item (if any) is not freed by this function and so calling this function multiple times for the same item will result in memory leaks unless you delete the old item data pointer yourself.
-    # <b>{Wx::Perl} Note:</b> {Wx::Perl} provides the following shortcut method:
-    # - SetPlData(item, data): sets the Perl data associated with the Wx::TreeItemData. It is just the same as tree->GetItemData(item)->SetData(data).
     # @param item [Wx::TreeItemId] 
     # @param data [Object] 
     # @return [void]