wxruby3 0.9.0.pre.rc.2-x64-mingw-ucrt → 0.9.0.pre.rc.3-x64-mingw-ucrt

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

@@ -154,62 +154,105 @@ module Wx
   # === Styles
   # 
   # This class supports the following styles:
-  #  
+  # 
   # - {Wx::Border::BORDER_DEFAULT}: The window class will decide the kind of border to show, if any. 
+  # 
   # - {Wx::Border::BORDER_SIMPLE}: Displays a thin border around the window. {Wx::SIMPLE_BORDER} is the old name for this style. 
+  # 
   # - {Wx::Border::BORDER_SUNKEN}: Displays a sunken border. {Wx::SUNKEN_BORDER} is the old name for this style. 
+  # 
   # - {Wx::Border::BORDER_RAISED}: Displays a raised border. {Wx::RAISED_BORDER} is the old name for this style. 
+  # 
   # - {Wx::Border::BORDER_STATIC}: Displays a border suitable for a static control. {Wx::STATIC_BORDER} is the old name for this style. Windows only. 
+  # 
   # - {Wx::Border::BORDER_THEME}: Displays a native border suitable for a control, on the current platform. On Windows, this will be a themed border; on most other platforms a sunken border will be used. For more information for themed borders on Windows, please see Themed borders on Windows. 
+  # 
   # - {Wx::Border::BORDER_NONE}: Displays no border, overriding the default border style for the window. {Wx::NO_BORDER} is the old name for this style. 
+  # 
   # - {Wx::Border::BORDER_DOUBLE}: This style is obsolete and should not be used. 
+  # 
   # - {Wx::TRANSPARENT_WINDOW}: The window is transparent, that is, it will not receive paint events. Windows only. 
+  # 
   # - {Wx::TAB_TRAVERSAL}: This style is used by wxWidgets for the windows supporting TAB navigation among their children, such as {Wx::Dialog} and {Wx::Panel}. It should almost never be used in the application code. 
+  # 
   # - {Wx::WANTS_CHARS}: Use this to indicate that the window wants to get all char/key events for all keys - even for keys like TAB or ENTER which are usually used for dialog navigation and which wouldn't be generated without this style. If you need to use this style in order to get the arrows or etc., but would still like to have normal keyboard navigation take place, you should call Navigate in response to the key events for Tab and Shift-Tab. 
+  # 
   # - {Wx::NO_FULL_REPAINT_ON_RESIZE}: On Windows, this style used to disable repainting the window completely when its size is changed. Since this behaviour is now the default, the style is now obsolete and no longer has an effect. 
+  # 
   # - {Wx::VSCROLL}: Use this style to enable a vertical scrollbar. Notice that this style cannot be used with native controls which don't support scrollbars nor with top-level windows in most ports. 
+  # 
   # - {Wx::HSCROLL}: Use this style to enable a horizontal scrollbar. The same limitations as for {Wx::VSCROLL} apply to this style. 
-  # - {Wx::ALWAYS_SHOW_SB}: If a window has scrollbars, disable them instead of hiding them when they are not needed (i.e. when the size of the window is big enough to not require the scrollbars to navigate it). This style is currently implemented for {Wx::MSW}, {Wx::GTK} and {Wx::Universal} and does nothing on the other platforms. 
+  # 
+  # - {Wx::ALWAYS_SHOW_SB}: If a window has scrollbars, disable them instead of hiding them when they are not needed (i.e. when the size of the window is big enough to not require the scrollbars to navigate it). This style is currently implemented for wxMSW, wxGTK and {Wx::Universal} and does nothing on the other platforms. 
+  # 
   # - {Wx::CLIP_CHILDREN}: Use this style to eliminate flicker caused by the background being repainted, then children being painted over them. Windows only. 
+  # 
   # - {Wx::FULL_REPAINT_ON_RESIZE}: Use this style to force a complete redraw of the window whenever it is resized instead of redrawing just the part of the window affected by resizing. Note that this was the behaviour by default before 2.5.1 release and that if you experience redraw problems with code which previously used to work you may want to try this. Currently this style applies on GTK+ 2 and Windows only, and full repainting is always done on other platforms. 
   # 
   # === Extra Styles
   # 
   # This class supports the following extra styles:
-  #  
+  # 
   # - {Wx::WS_EX_BLOCK_EVENTS}: {Wx::CommandEvents} and the objects of the derived classes are forwarded to the parent window and so on recursively by default. Using this flag for the given window allows blocking this propagation at this window, i.e. prevent the events from being propagated further upwards. Dialogs have this flag on by default for the reasons explained in the Events and Event Handling. 
+  # 
   # - {Wx::WS_EX_TRANSIENT}: Don't use this window as an implicit parent for the other windows: this must be used with transient windows as otherwise there is the risk of creating a dialog/frame with this window as a parent, which would lead to a crash if the parent were destroyed before the child. 
+  # 
   # - {Wx::WS_EX_CONTEXTHELP}: Under Windows, puts a query button on the caption. When pressed, Windows will go into a context-sensitive help mode and wxWidgets will send a {Wx::EVT_HELP} event if the user clicked on an application window. This style cannot be used (because of the underlying native behaviour) together with {Wx::MAXIMIZE_BOX} or {Wx::MINIMIZE_BOX}, so these two styles are automatically turned off if this one is used. 
+  # 
   # - {Wx::WS_EX_PROCESS_IDLE}: This window should always process idle events, even if the mode set by {Wx::IdleEvent.set_mode} is {Wx::IdleMode::IDLE_PROCESS_SPECIFIED}. 
+  # 
   # - {Wx::WS_EX_PROCESS_UI_UPDATES}: This window should always process UI update events, even if the mode set by {Wx::UpdateUIEvent.set_mode} is {Wx::UpdateUIMode::UPDATE_UI_PROCESS_SPECIFIED}. 
   # 
   # === Events emitted by this class
   # 
   # Event handler methods for events emitted by this class:
-  #  
+  # 
   # - {Wx::EvtHandler#EVT_ACTIVATE}(meth = nil, &block): Process a {Wx::EVT_ACTIVATE} event. See {Wx::ActivateEvent}. 
+  # 
   # - {Wx::EvtHandler#evt_child_focus}(meth = nil, &block): Process a {Wx::EVT_CHILD_FOCUS} event. See {Wx::ChildFocusEvent}. 
+  # 
   # - {Wx::EvtHandler#evt_context_menu}(meth = nil, &block): A right click (or other context menu command depending on platform) has been detected. See {Wx::ContextMenuEvent}. 
+  # 
   # - {Wx::EvtHandler#evt_help}(id, meth = nil, &block): Process a {Wx::EVT_HELP} event. See {Wx::HelpEvent}. 
+  # 
   # - {Wx::EvtHandler#evt_help_range}(id1,  id2, meth = nil, &block): Process a {Wx::EVT_HELP} event for a range of ids. See {Wx::HelpEvent}. 
+  # 
   # - {Wx::EvtHandler#evt_drop_files}(meth = nil, &block): Process a {Wx::EVT_DROP_FILES} event. See {Wx::DropFilesEvent}. 
+  # 
   # - {Wx::EvtHandler#evt_erase_background}(meth = nil, &block): Process a {Wx::EVT_ERASE_BACKGROUND} event. See {Wx::EraseEvent}. 
+  # 
   # - {Wx::EvtHandler#evt_set_focus}(meth = nil, &block): Process a {Wx::EVT_SET_FOCUS} event. See {Wx::FocusEvent}. 
+  # 
   # - {Wx::EvtHandler#evt_kill_focus}(meth = nil, &block): Process a {Wx::EVT_KILL_FOCUS} event. See {Wx::FocusEvent}. 
+  # 
   # - {Wx::EvtHandler#evt_idle}(meth = nil, &block): Process a {Wx::EVT_IDLE} event. See {Wx::IdleEvent}. 
+  # 
   # - {Wx::EvtHandler}evt_joy_*(meth = nil, &block): Processes joystick events. See {Wx::JoystickEvent}. 
+  # 
   # - {Wx::EvtHandler#evt_key_down}(meth = nil, &block): Process a {Wx::EVT_KEY_DOWN} event (any key has been pressed). See {Wx::KeyEvent}. 
+  # 
   # - {Wx::EvtHandler#evt_key_up}(meth = nil, &block): Process a {Wx::EVT_KEY_UP} event (any key has been released). See {Wx::KeyEvent}. 
+  # 
   # - {Wx::EvtHandler#evt_char}(meth = nil, &block): Process a {Wx::EVT_CHAR} event. See {Wx::KeyEvent}. 
+  # 
   # - {Wx::EvtHandler#evt_char_hook}(meth = nil, &block): Process a {Wx::EVT_CHAR_HOOK} event. See {Wx::KeyEvent}. 
+  # 
   # - {Wx::EvtHandler#evt_mouse_capture_lost}(meth = nil, &block): Process a {Wx::EVT_MOUSE_CAPTURE_LOST} event. See {Wx::MouseCaptureLostEvent}. 
+  # 
   # - {Wx::EvtHandler#evt_mouse_capture_changed}(meth = nil, &block): Process a {Wx::EVT_MOUSE_CAPTURE_CHANGED} event. See {Wx::MouseCaptureChangedEvent}. 
+  # 
   # - {Wx::EvtHandler}evt_mouse_*(meth = nil, &block): See {Wx::MouseEvent}. 
+  # 
   # - {Wx::EvtHandler#evt_paint}(meth = nil, &block): Process a {Wx::EVT_PAINT} event. See {Wx::PaintEvent}. 
+  # 
   # - {Wx::EvtHandler}evt_power_*(meth = nil, &block): The system power state changed. See {Wx::PowerEvent}. 
+  # 
   # - {Wx::EvtHandler}evt_scrollwin_*(meth = nil, &block): Process scroll events. See {Wx::ScrollWinEvent}. 
+  # 
   # - {Wx::EvtHandler#evt_set_cursor}(meth = nil, &block): Process a {Wx::EVT_SET_CURSOR} event. See {Wx::SetCursorEvent}. 
+  # 
   # - {Wx::EvtHandler#evt_size}(meth = nil, &block): Process a {Wx::EVT_SIZE} event. See {Wx::SizeEvent}. 
+  # 
   # - {Wx::EvtHandler#evt_sys_colour_changed}(meth = nil, &block): Process a {Wx::EVT_SYS_COLOUR_CHANGED} event. See {Wx::SysColourChangedEvent}. 
   # 
   # === 
@@ -417,7 +460,7 @@ module Wx
     # Scrolls the window by the given number of lines down (if lines is positive) or up.
     # Returns true if the window was scrolled, false if it was already on top/bottom and nothing was done.
     # 
-    # This function is currently only implemented under MSW and {Wx::TextCtrl} under {Wx::GTK} (it also works for {Wx::Scrolled} classes under all platforms).
+    # This function is currently only implemented under MSW and {Wx::TextCtrl} under wxGTK (it also works for {Wx::Scrolled} classes under all platforms).
     # @see Wx::Window#scroll_pages 
     # @param lines [Integer] 
     # @return [true,false]
@@ -426,7 +469,7 @@ module Wx
     # Scrolls the window by the given number of pages down (if pages is positive) or up.
     # Returns true if the window was scrolled, false if it was already on top/bottom and nothing was done.
     # 
-    # This function is currently only implemented under MSW and {Wx::GTK}.
+    # This function is currently only implemented under MSW and wxGTK.
     # @see Wx::Window#scroll_lines 
     # @param pages [Integer] 
     # @return [true,false]
@@ -436,7 +479,7 @@ module Wx
     # Note that you can often use {Wx::Scrolled} instead of using this function directly.
     # @param dx [Integer]  Amount to scroll horizontally.
     # @param dy [Integer]  Amount to scroll vertically.
-    # @param rect [Wx::Rect]  Rectangle to scroll, if it is NULL, the whole window is scrolled (this is always the case under {Wx::GTK} which doesn't support this parameter)
+    # @param rect [Wx::Rect]  Rectangle to scroll, if it is NULL, the whole window is scrolled (this is always the case under wxGTK which doesn't support this parameter)
     # @return [void]
     def scroll_window(dx, dy, rect=nil) end
     
@@ -471,8 +514,8 @@ module Wx
     
     # Sets the scrollbar properties of a built-in scrollbar.
     # Let's say you wish to display 50 lines of text, using the same font. The window is sized so that you can only see 16 lines at a time. You would use: 
-    # ```
-    #   SetScrollbar(wxVERTICAL, 0, 16, 50);
+    # ```ruby
+    #   set_scrollbar(Wx::VERTICAL, 0, 16, 50)
     # ```
     #  Note that with the window at this size, the thumb position can never go above 50 minus 16, or 34. You can determine how many lines are currently visible by dividing the current view size by the character height in pixels. When defining your own scrollbar behaviour, you will always need to recalculate the scrollbar settings when the window size changes. You could therefore put your scrollbar calculations and SetScrollbar call into a function named AdjustScrollbars, which can be called initially and also from your {Wx::SizeEvent} handler function.
     # @see Scrolled Windows
@@ -482,7 +525,7 @@ module Wx
     # @param orientation [Integer]  Determines the scrollbar whose page size is to be set. May be {Wx::Orientation::HORIZONTAL} or {Wx::Orientation::VERTICAL}.
     # @param position [Integer]  The position of the scrollbar in scroll units.
     # @param thumbSize [Integer]  The size of the thumb, or visible portion of the scrollbar, in scroll units.
-    # @param range [Integer]  The maximum position of the scrollbar. Value of -1 can be used to ask for the scrollbar to be shown but in the disabled state: this can be used to avoid removing the scrollbar even when it is not needed (currently this is only implemented in {Wx::MSW} port).
+    # @param range [Integer]  The maximum position of the scrollbar. Value of -1 can be used to ask for the scrollbar to be shown but in the disabled state: this can be used to avoid removing the scrollbar even when it is not needed (currently this is only implemented in wxMSW port).
     # @param refresh [true,false]  true to redraw the scrollbar, false otherwise.
     # @return [void]
     def set_scrollbar(orientation, position, thumbSize, range, refresh=true) end
@@ -535,8 +578,8 @@ module Wx
     # @overload from_dip(sz)
     #   Convert DPI-independent pixel values to the value in pixels appropriate for the current toolkit.
     #   A DPI-independent pixel is just a pixel at the standard 96 DPI resolution. To keep the same physical size at higher resolution, the physical pixel value must be scaled by {Wx::Window#get_dpi_scale_factor} but this scaling may be already done by the underlying toolkit (GTK+, Cocoa, ...) automatically. This method performs the conversion only if it is not already done by the lower level toolkit and so by using it with pixel values you can guarantee that the physical size of the corresponding elements will remain the same in all resolutions under all platforms. For example, instead of creating a bitmap of the hard coded size of 32 pixels you should use 
-    #   ```
-    #     wxBitmap bmp(FromDIP(32, 32));
+    #   ```ruby
+    #     bmp = Wx::Bitmap.new(from_dip(Wx::Size.new(32, 32)))
     #   ```
     #    to avoid using tiny bitmaps on high DPI screens.
     #   Notice that this function is only needed when using hard coded pixel values. It is not necessary if the sizes are already based on the DPI-independent units such as dialog units or if you are relying on the controls automatic best size determination and using sizers to lay out them.
@@ -577,9 +620,9 @@ module Wx
     # @overload to_dip(sz)
     #   Convert pixel values of the current toolkit to DPI-independent pixel values.
     #   A DPI-independent pixel is just a pixel at the standard 96 DPI resolution. To keep the same physical size at higher resolution, the physical pixel value must be scaled by {Wx::Window#get_dpi_scale_factor} but this scaling may be already done by the underlying toolkit (GTK+, Cocoa, ...) automatically. This method performs the conversion only if it is not already done by the lower level toolkit, For example, you may want to use this to store window sizes and positions so that they can be re-used regardless of the display DPI: 
-    #   ```
-    #     wxPoint pt(ToDIP(GetPosition()));
-    #     wxSize size(ToDIP(GetSize()));
+    #   ```ruby
+    #     pt = Wx::Point.new(to_dip(get_position))
+    #     size = Wx::Size.new(to_dip(get_size))
     #   ```
     #   
     #   Also note that if either component of sz has the special value of -1, it is returned unchanged independently of the current DPI, to preserve the special value of -1 in wxWidgets API (it is often used to mean "unspecified").
@@ -809,7 +852,7 @@ module Wx
     # Returns the factor mapping logical pixels of this window to physical pixels.
     # This function can be used to portably determine the number of physical pixels in a window of the given size, by multiplying the window size by the value returned from it. I.e. it returns the factor converting window coordinates to "content view" coordinates, where the view can be just a simple window displaying a {Wx::Bitmap} or {Wx::GLCanvas} or any other kind of window rendering arbitrary "content" on screen.
     # For the platforms not doing any pixel mapping, i.e. where logical and physical pixels are one and the same, this function always returns 1.0 and so using it is, in principle, unnecessary and could be avoided by using preprocessor check for {Wx::HAS_DPI_INDEPENDENT_PIXELS} not being defined, however using this function unconditionally under all platforms is usually simpler and so preferable.
-    # Current behaviour of this function is compatible with wxWidgets 3.0, but different from its behaviour in versions 3.1.0 to 3.1.3, where it returned the same value as {Wx::Window#get_dpi_scale_factor}. Please use the other function if you need to use a scaling factor greater than 1.0 even for the platforms without {Wx::HAS_DPI_INDEPENDENT_PIXELS}, such as {Wx::MSW}.
+    # Current behaviour of this function is compatible with wxWidgets 3.0, but different from its behaviour in versions 3.1.0 to 3.1.3, where it returned the same value as {Wx::Window#get_dpi_scale_factor}. Please use the other function if you need to use a scaling factor greater than 1.0 even for the platforms without {Wx::HAS_DPI_INDEPENDENT_PIXELS}, such as wxMSW.
     # @return [Float]
     def get_content_scale_factor; end
     alias_method :content_scale_factor, :get_content_scale_factor
@@ -907,8 +950,8 @@ module Wx
     
     # Sets the maximum client size of the window, to indicate to the sizer layout mechanism that this is the maximum possible size of its client area.
     # Note that this method is just a shortcut for: 
-    # ```
-    #   SetMaxSize(ClientToWindowSize(size));
+    # ```ruby
+    #   set_max_size(client_to_window_size(size))
     # ```
     # @see Wx::Window#set_max_size
     # @see  Window Sizing Overview 
@@ -930,8 +973,8 @@ module Wx
     # You may need to call this if you change the window size after construction and before adding to its parent sizer.
     # Note, that just as with {Wx::Window#set_min_size}, calling this method doesn't prevent the program from explicitly making the window smaller than the specified size.
     # Note that this method is just a shortcut for: 
-    # ```
-    #   SetMinSize(ClientToWindowSize(size));
+    # ```ruby
+    #   set_min_size(client_to_window_size(size))
     # ```
     # @see Wx::Window#set_min_size
     # @see  Window Sizing Overview 
@@ -960,7 +1003,13 @@ module Wx
     #   @param width [Integer]  Required width in pixels, or {Wx::DEFAULT_COORD} to indicate that the existing value should be used.
     #   @param height [Integer]  Required height position in pixels, or {Wx::DEFAULT_COORD} to indicate that the existing value should be used.
     #   @param sizeFlags [Integer]  Indicates the interpretation of other parameters. It is a bit list of the following:
-    #     - {Wx::SIZE_AUTO_WIDTH}: a {Wx::DEFAULT_COORD} width value is taken to indicate a wxWidgets-supplied default width.- {Wx::SIZE_AUTO_HEIGHT}: a {Wx::DEFAULT_COORD} height value is taken to indicate a wxWidgets-supplied default height.- {Wx::SIZE_AUTO}: {Wx::DEFAULT_COORD} size values are taken to indicate a wxWidgets-supplied default size.- {Wx::SIZE_USE_EXISTING}: existing dimensions should be used if {Wx::DEFAULT_COORD} values are supplied.- {Wx::SIZE_ALLOW_MINUS_ONE}: allow negative dimensions (i.e. value of {Wx::DEFAULT_COORD}) to be interpreted as real dimensions, not default values.- {Wx::SIZE_FORCE}: normally, if the position and the size of the window are already the same as the parameters of this function, nothing is done. but with this flag a window resize may be forced even in this case (supported in wx 2.6.2 and later and only implemented for MSW and ignored elsewhere currently).
+    #     
+    #     - {Wx::SIZE_AUTO_WIDTH}: a {Wx::DEFAULT_COORD} width value is taken to indicate a wxWidgets-supplied default width.
+    #     - {Wx::SIZE_AUTO_HEIGHT}: a {Wx::DEFAULT_COORD} height value is taken to indicate a wxWidgets-supplied default height.
+    #     - {Wx::SIZE_AUTO}: {Wx::DEFAULT_COORD} size values are taken to indicate a wxWidgets-supplied default size.
+    #     - {Wx::SIZE_USE_EXISTING}: existing dimensions should be used if {Wx::DEFAULT_COORD} values are supplied.
+    #     - {Wx::SIZE_ALLOW_MINUS_ONE}: allow negative dimensions (i.e. value of {Wx::DEFAULT_COORD}) to be interpreted as real dimensions, not default values.
+    #     - {Wx::SIZE_FORCE}: normally, if the position and the size of the window are already the same as the parameters of this function, nothing is done. but with this flag a window resize may be forced even in this case (supported in wx 2.6.2 and later and only implemented for MSW and ignored elsewhere currently).
     #   @return [void]
     # @overload set_size(rect)
     #   Sets the size of the window in pixels.
@@ -1079,8 +1128,8 @@ module Wx
     # @overload move(x, y, flags=Wx::SIZE_USE_EXISTING)
     #   Moves the window to the given position.
     #   Implementations of SetSize can also implicitly implement the {Wx::Window#move} function, which is defined in the base {Wx::Window} class as the call: 
-    #   ```
-    #     SetSize(x, y, wxDefaultCoord, wxDefaultCoord, wxSIZE_USE_EXISTING);
+    #   ```ruby
+    #     set_size(x, y, Wx::DEFAULT_COORD, Wx::DEFAULT_COORD, Wx::SIZE_USE_EXISTING)
     #   ```
     #   @see Wx::Window#set_size 
     #   @param x [Integer]  Required x position.
@@ -1090,8 +1139,8 @@ module Wx
     # @overload move(pt, flags=Wx::SIZE_USE_EXISTING)
     #   Moves the window to the given position.
     #   Implementations of {Wx::Window#set_size} can also implicitly implement the {Wx::Window#move} function, which is defined in the base {Wx::Window} class as the call: 
-    #   ```
-    #     SetSize(x, y, wxDefaultCoord, wxDefaultCoord, wxSIZE_USE_EXISTING);
+    #   ```ruby
+    #     set_size(x, y, Wx::DEFAULT_COORD, Wx::DEFAULT_COORD, Wx::SIZE_USE_EXISTING)
     #   ```
     #   @see Wx::Window#set_size 
     #   @param pt [Array(Integer, Integer), Wx::Point]  {Wx::Point} object representing the position.
@@ -1114,10 +1163,7 @@ module Wx
     # @overload convert_dialog_to_pixels(pt)
     #   Converts a point or size from dialog units to pixels.
     #   For the x dimension, the dialog units are multiplied by the average character width and then divided by 4. For the y dimension, the dialog units are multiplied by the average character height and then divided by 8.
-    #   Dialog units are used for maintaining a dialog's proportions even if the font changes. You can also use these functions programmatically. A convenience macro is defined: 
-    #   ```
-    #     #define wxDLG_UNIT(parent, pt) parent->ConvertDialogToPixels(pt)
-    #   ```
+    #   Dialog units are used for maintaining a dialog's proportions even if the font changes. You can also use these functions programmatically.
     #   @see Wx::Window#convert_pixels_to_dialog 
     #   @param pt [Array(Integer, Integer), Wx::Point] 
     #   @return [Wx::Point]
@@ -1154,7 +1200,7 @@ module Wx
     # Freezes the window or, in other words, prevents any updates from taking place on screen, the window is not redrawn at all.
     # {Wx::Window#thaw} must be called to re-enable window redrawing. Calls to these two functions may be nested but to ensure that the window is properly repainted again, you must thaw it exactly as many times as you froze it.
     # If the window has any children, they are recursively frozen too.
-    # This method is useful for visual appearance optimization (for example, it is a good idea to use it before doing many large text insertions in a row into a {Wx::TextCtrl} under {Wx::GTK}) but is not implemented on all platforms nor for all controls so it is mostly just a hint to wxWidgets and not a mandatory directive.
+    # This method is useful for visual appearance optimization (for example, it is a good idea to use it before doing many large text insertions in a row into a {Wx::TextCtrl} under wxGTK) but is not implemented on all platforms nor for all controls so it is mostly just a hint to wxWidgets and not a mandatory directive.
     # @see Wx::WindowUpdateLocker
     # @see  Wx::Window#thaw
     # @see  Wx::Window#is_frozen 
@@ -1306,22 +1352,19 @@ module Wx
     # Sets the background style of the window.
     # The default background style is {Wx::BackgroundStyle::BG_STYLE_ERASE} which indicates that the window background may be erased in EVT_ERASE_BACKGROUND handler. This is a safe, compatibility default; however you may want to change it to {Wx::BackgroundStyle::BG_STYLE_SYSTEM} if you don't define any erase background event handlers at all, to avoid unnecessary generation of erase background events and always let system erase the background. And you should change the background style to {Wx::BackgroundStyle::BG_STYLE_PAINT} if you define an EVT_PAINT handler which completely overwrites the window background as in this case erasing it previously, either in EVT_ERASE_BACKGROUND handler or in the system default handler, would result in flicker as the background pixels will be repainted twice every time the window is redrawn. Do ensure that the background is entirely erased by your EVT_PAINT handler in this case however as otherwise garbage may be left on screen.
     # Notice that in previous versions of wxWidgets a common way to work around the above mentioned flickering problem was to define an empty EVT_ERASE_BACKGROUND handler. Setting background style to {Wx::BackgroundStyle::BG_STYLE_PAINT} is a simpler and more efficient solution to the same problem.
-    # Under {Wx::GTK} and {Wx::OSX}, you can use {Wx::BackgroundStyle::BG_STYLE_TRANSPARENT} to obtain full transparency of the window background. Note that {Wx::GTK} supports this only since GTK 2.12 with a compositing manager enabled, call {Wx::Window#is_transparent_background_supported} to check whether this is the case, see the example of doing it in the shapedsample".
+    # Under wxGTK and wxOSX, you can use {Wx::BackgroundStyle::BG_STYLE_TRANSPARENT} to obtain full transparency of the window background. Note that wxGTK supports this only since GTK 2.12 with a compositing manager enabled, call {Wx::Window#is_transparent_background_supported} to check whether this is the case, see the example of doing it in the shapedsample".
     # Also, in order for <code>SetBackgroundStyle(wxBG_STYLE_TRANSPARENT)</code> to work, it must be called before {Wx::Window#create}. If you're using your own {Wx::Window}-derived class you should write your code in the following way: 
-    # ```
-    #   class MyWidget : public wxWindow
-    #   {
-    #   public:
-    #       MyWidget(wxWindow* parent, ...)
-    #           : wxWindow() // Use default ctor here!
-    #       {
-    #           // Do this first:
-    #           SetBackgroundStyle(wxBG_STYLE_TRANSPARENT);
-    #   
-    #           // And really create the window afterwards:
-    #           Create(parent, ...);
-    #       }
-    #   };
+    # ```ruby
+    #   class MyWidget < Wx::Window
+    #     def initialize(parent, ...)
+    #       super() # Use default ctor here!
+    #        # Do this first:
+    #        set_background_style(Wx::BG_STYLE_TRANSPARENT)
+    # 
+    #        # And really create the window afterwards:
+    #        create(parent, ...)
+    #     end
+    #   end
     # ```
     # @see Wx::Window#set_background_colour
     # @see  Wx::Window#get_foreground_colour
@@ -1477,8 +1520,8 @@ module Wx
     def handle_as_navigation_key(event) end
     
     # Shorthand for:
-    # ```
-    #   GetEventHandler()->SafelyProcessEvent(event);
+    # ```ruby
+    #   get_event_handler.safely_process_event(event)
     # ```
     # @see Wx::Window#process_window_event 
     # @param event [Wx::Event] 
@@ -1487,8 +1530,8 @@ module Wx
     
     # Convenient wrapper for {Wx::Window#process_event}.
     # This is the same as writing 
-    # ```
-    #   GetEventHandler()->ProcessEvent(event);
+    # ```ruby
+    #   get_event_handler.process_event(event)
     # ```
     #  but more convenient. Notice that {Wx::Window#process_event} itself can't be called for {Wx::Window} objects as it ignores the event handlers associated with the window; use this function instead.
     # @param event [Wx::Event] 
@@ -1505,9 +1548,9 @@ module Wx
     # An event handler is an object that is capable of processing the events sent to a window. By default, the window is its own event handler, but an application may wish to substitute another, for example to allow central implementation of event-handling for a variety of different window classes.
     # {Wx::Window#push_event_handler} allows an application to set up a stack of event handlers, where an event not handled by one event handler is handed to the next one in the chain.
     # E.g. if you have two event handlers A and B and a {Wx::Window} instance W and you call: 
-    # ```
-    #   W->PushEventHandler(A);
-    #   W->PushEventHandler(B);
+    # ```ruby
+    #   W.push_event_handler(A)
+    #   W.push_event_handler(B)
     # ```
     #  you will end up with the following situation: 
     # 
@@ -1717,10 +1760,10 @@ module Wx
     # Enable or disable the window for user input.
     # Note that when a parent window is disabled, all of its children are disabled as well and they are re-enabled again when the parent is.
     # A window can be created initially disabled by calling this method on it before calling {Wx::Window#create} to create the actual underlying window, e.g. 
-    # ```
-    #   wxWindow* w = new MyWindow(); // Note: default ctor is used here.
-    #   w->Enable(false);
-    #   w->Create(parent, ... all the usual non-default ctor arguments ...);
+    # ```ruby
+    #   w = MyWindow.new # Note: default ctor is used here.
+    #   w.enable(false)
+    #   w.create(parent, ... all the usual non-default ctor arguments ...)
     # ```
     # 
     # Returns true if the window has been enabled or disabled, false if nothing was done, i.e. if the window had already been in the specified state.
@@ -1745,7 +1788,7 @@ module Wx
     def show(show=true) end
     
     # This function shows a window, like {Wx::Window#show}, but using a special visual effect if possible.
-    # Currently this function is only implemented in {Wx::MSW} and {Wx::OSX} and does the same thing as {Wx::Window#show} in the other ports.
+    # Currently this function is only implemented in wxMSW and wxOSX and does the same thing as {Wx::Window#show} in the other ports.
     # @see Wx::Window#hide_with_effect 
     # @param effect [ShowEffect]  The effect to use.
     # @param timeout [Integer]  The timeout parameter specifies the time of the animation, in milliseconds. If the default value of 0 is used, the default animation time for the current platform is used.
@@ -1813,7 +1856,7 @@ module Wx
     #   This function shows a popup menu at the given position in this window and returns the selected id.
     #   It can be more convenient than the general purpose {Wx::Window#popup_menu} function for simple menus proposing a choice in a list of strings to the user.
     #   Notice that to avoid unexpected conflicts between the (usually consecutive range of) ids used by the menu passed to this function and the existing EVT_UPDATE_UI() handlers, this function temporarily disables UI updates for the window, so you need to manually disable (or toggle or ...) any items which should be disabled in the menu before showing it.
-    #   The parameter menu is the menu to show. The parameter pos (or the parameters x and y) is the position at which to show the menu in client coordinates. It is recommended to not explicitly specify coordinates when calling this method in response to mouse click, because some of the ports (namely, {Wx::GTK}) can do a better job of positioning the menu in that case.
+    #   The parameter menu is the menu to show. The parameter pos (or the parameters x and y) is the position at which to show the menu in client coordinates. It is recommended to not explicitly specify coordinates when calling this method in response to mouse click, because some of the ports (namely, wxGTK) can do a better job of positioning the menu in that case.
     #   The selected menu item id or {Wx::StandardID::ID_NONE} if none selected or an error occurred.
     #   @param menu [Wx::Menu] 
     #   @param pos [Array(Integer, Integer), Wx::Point] 
@@ -1833,7 +1876,7 @@ module Wx
     #   menu is the menu to pop up.
     #   The position where the menu will appear can be specified either as a {Wx::Point} pos or by two integers (x and y).
     #   Note that this function switches focus to this window before showing the menu.
-    #   Just before the menu is popped up, {Wx::Menu::UpdateUI} is called to ensure that the menu items are in the correct state. The menu does not get deleted by the window. It is recommended to not explicitly specify coordinates when calling PopupMenu in response to mouse click, because some of the ports (namely, {Wx::GTK}) can do a better job of positioning the menu in that case.
+    #   Just before the menu is popped up, {Wx::Menu::UpdateUI} is called to ensure that the menu items are in the correct state. The menu does not get deleted by the window. It is recommended to not explicitly specify coordinates when calling PopupMenu in response to mouse click, because some of the ports (namely, wxGTK) can do a better job of positioning the menu in that case.
     #   @see Wx::Menu 
     #   @param menu [Wx::Menu] 
     #   @param pos [Array(Integer, Integer), Wx::Point] 
@@ -2137,8 +2180,8 @@ module Wx
     
     # Request generation of touch events for this window.
     # Each call to this function supersedes the previous ones, i.e. if you want to receive events for both zoom and rotate gestures, you need to call 
-    # ```
-    #   EnableTouchEvents(wxTOUCH_ZOOM_GESTURE | wxTOUCH_ROTATE_GESTURE);
+    # ```ruby
+    #   enable_touch_events(Wx::TOUCH_ZOOM_GESTURE | Wx::TOUCH_ROTATE_GESTURE)
     # ```
     #  instead of calling it twice in a row as the second call would disable the first gesture.
     # 
@@ -2173,19 +2216,19 @@ module Wx
     # Does the window-specific updating after processing the update event.
     # This function is called by {Wx::Window#update_window_ui} in order to check return values in the {Wx::UpdateUIEvent} and act appropriately. For example, to allow frame and dialog title updating, wxWidgets implements this function as follows:
     # 
-    # ```
-    #   // do the window-specific processing after processing the update event
-    #   void wxTopLevelWindowBase::DoUpdateWindowUI(wxUpdateUIEvent& event)
-    #   {
-    #       if ( event.GetSetEnabled() )
-    #           Enable(event.GetEnabled());
+    # ```ruby
+    #   # do the window-specific processing after processing the update event
+    #   def Wx::TopLevelWindow.do_update_window_ui(event)
+    #     if event.get_set_enabled
+    #       enable(event.get_enabled)
+    #     end
     #   
-    #       if ( event.GetSetText() )
-    #       {
-    #           if ( event.GetText() != GetTitle() )
-    #               SetTitle(event.GetText());
-    #       }
-    #   }
+    #     if event.get_set_text
+    #       if event.get_text != get_title
+    #         set_title(event.get_text)
+    #       end
+    #     end
+    #   end
     # ```
     # @param event [Wx::UpdateUIEvent] 
     # @return [void]
@@ -2271,12 +2314,14 @@ module Wx
     # You can call this function from your application to ensure that your UI is up-to-date at this point (as far as your {Wx::UpdateUIEvent} handlers are concerned). This may be necessary if you have called {Wx::UpdateUIEvent.set_mode} or {Wx::UpdateUIEvent.set_update_interval} to limit the overhead that wxWidgets incurs by sending update UI events in idle time. flags should be a bitlist of one or more of the {Wx::UpdateUI} enumeration.
     # If you are calling this function from an OnInternalIdle or OnIdle function, make sure you pass the {Wx::UpdateUI::UPDATE_UI_FROMIDLE} flag, since this tells the window to only update the UI elements that need to be updated in idle time. Some windows update their elements only when necessary, for example when a menu is about to be shown. The following is an example of how to call UpdateWindowUI from an idle function.
     # 
-    # ```
-    #   void MyWindow::OnInternalIdle()
-    #   {
-    #       if (wxUpdateUIEvent::CanUpdate(this))
-    #           UpdateWindowUI(wxUPDATE_UI_FROMIDLE);
-    #   }
+    # ```ruby
+    #   class MyWindow
+    #     ...
+    #     def on_internal_idle
+    #       update_window_ui(Wx::UPDATE_UI_FROMIDLE) if Wx::UpdateUIEvent.can_update(self)
+    #     end
+    #     ...
+    #   end
     # ```
     # @see Wx::UpdateUIEvent
     # @see  Wx::Window#do_update_window_ui
@@ -2367,7 +2412,7 @@ module Wx
     
     # @overload initialize()
     #   Default constructor.
-    #   @return [Window]
+    #   @return [Wx::Window]
     # @overload initialize(parent, id, pos=Wx::DEFAULT_POSITION, size=Wx::DEFAULT_SIZE, style=0, name=Wx::PanelNameStr)
     #   Constructs a window, which can be a child of a frame, dialog or any other non-control window.
     #   @param parent [Wx::Window]  Pointer to a parent window.
@@ -2376,41 +2421,51 @@ module Wx
     #   @param size [Array(Integer, Integer), Wx::Size]  Window size. {Wx::DEFAULT_SIZE} indicates that wxWidgets should generate a default size for the window. If no suitable size can be found, the window will be sized to 20x20 pixels so that the window is visible but obviously not correctly sized.
     #   @param style [Integer]  Window style. For generic window styles, please see {Wx::Window}.
     #   @param name [String]  Window name.
-    #   @return [Window]
+    #   @return [Wx::Window]
     def initialize(*args) end
     
     # Construct the actual window object after creating the C++ object.
     # The non-default constructor of {Wx::Window} class does two things: it initializes the C++ object and it also creates the window object in the underlying graphical toolkit. The {Wx::Window#create} method can be used to perform the second part later, while the default constructor can be used to perform the first part only.
     # Please note that the underlying window must be created exactly once, i.e. if you use the default constructor, which doesn't do this, you must call {Wx::Window#create} before using the window and if you use the non-default constructor, you can not call {Wx::Window#create}, as the underlying window is already created.
     # Note that it is possible and, in fact, useful, to call some methods on the object between creating the C++ object itself and calling {Wx::Window#create} on it, e.g. a common pattern to avoid showing the contents of a window before it is fully initialized is: 
-    # ```
-    #   wxPanel* panel = new wxPanel(); // Note: default constructor used.
-    #   panel->Hide(); // Can be called before actually creating it.
-    #   panel->Create(parent, wxID_ANY, ...); // Won't be shown yet.
+    # ```ruby
+    #   panel = Wx::Panel.new   # Note: default constructor used.
+    #   panel.hide  # Can be called before actually creating it.
+    #   panel.create(parent, Wx::ID_ANY, ...)   # Won't be shown yet.
     #   ... create all the panel children ...
-    #   panel->Show(); // Now everything will be shown at once.
+    #   panel.show  # Now everything will be shown at once.
     # ```
     # 
     # Also note that it is possible to create an object of a derived type and then call {Wx::Window#create} on it: 
-    # ```
-    #   // Suppose we have this function (which would typically be in a
-    #   // different translation unit (file) from the rest of the code).
-    #   wxWindow* MyCreateWindowObjectFunction() {
-    #       return new MyCustomClassDerivingFromWindow();
-    #   }
+    # ```ruby
+    #   # Suppose we have this function (which would typically be in a
+    #   # different file from the rest of the code).
+    #   def my_create_window_object_function
+    #      MyCustomClassDerivingFromWindow.new
+    #   end
     #   
-    #   // Then we can create a window of MyCustomClassDerivingFromWindow
-    #   // class without really knowing about this type, as we would have
-    #   // to do if we wanted to use the non-default constructor, like this:
+    #   # Then we can create a window of MyCustomClassDerivingFromWindow
+    #   # class without really knowing about this type, as we would have
+    #   # to do if we wanted to use the non-default constructor, like this:
     #   
-    #   // First create the C++ object using the factory function.
-    #   wxWindow* window = MyCreateWindowObjectFunction();
+    #   # First create the C++ object using the factory function.
+    #   window = my_create_window_object_function
     #   
-    #   // And now create the underlying window.
-    #   //
-    #   // This calls the base wxWindow::Create() as it is not virtual, so
-    #   // the derived class can't customize this part.
-    #   window->Create(parent, wxID_ANY, ...);
+    #   # And now create the underlying window.
+    #   #
+    #   # This should call the base Wx::Window#create.
+    #   # In C++ (wxWidgets) this method is not virtual and cannot be overloaded
+    #   # so the derived class can't customize this part.
+    #   # In wxRuby however this method can be overloaded as long as the following
+    #   # is kept in mind:
+    #   # 1. the overloaded version will **NOT** be called when using a non-default
+    #   #    constructor (Create will than be called from C++ which will always be 
+    #   #    the base Wx::Window version);
+    #   # 2. when calling the overloaded version from Ruby understand that the window
+    #   #    will not actually be created until after the `super` version has been called.
+    #   # In general it's best not to overload this method but to define a different method
+    #   # if a custom initializer is needed.
+    #   window.create(parent, Wx::ID_ANY, ...)
     # ```
     #  This is notably used by XML Based Resource System (XRC).
     # The parameters of this method have exactly the same meaning as the non-default constructor parameters, please refer to them for their description.

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

@@ -28,7 +28,7 @@ module Wx
     # Constructor.
     # Pass a pointer to the window on which you wish to paint.
     # @param window [Wx::Window] 
-    # @return [WindowDC]
+    # @return [Wx::WindowDC]
     def initialize(window) end
     
   end # WindowDC

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

@@ -17,7 +17,7 @@ module Wx
   # @note  In wxRuby this is a mixin module instead of a (base) class.
   module WithImages
   
-    # @return [WithImages]
+    # @return [Wx::WithImages]
     def initialize; end
     
     # Return the number of images in this control.

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

@@ -16,12 +16,19 @@ module Wx
   # 
   # The following event-handler methods redirect the events to member method or handler blocks for {Wx::WizardEvent} events.
   # Event handler methods for events emitted by this class:
+  # 
   # - {Wx::EvtHandler#evt_wizard_page_changed}(id, meth = nil, &block): The page has just been changed (this event cannot be vetoed). 
+  # 
   # - {Wx::EvtHandler#evt_wizard_page_changing}(id, meth = nil, &block): The page is being changed (this event can be vetoed). 
+  # 
   # - {Wx::EvtHandler#evt_wizard_before_page_changed}(id, meth = nil, &block): Called after Next is clicked but before GetNext is called. Unlike EVT_WIZARD_CHANGING, the handler for this function can change state that might affect the return value of GetNext. This event can be vetoed. 
+  # 
   # - {Wx::EvtHandler#evt_wizard_page_shown}(id, meth = nil, &block): The page was shown and laid out (this event cannot be vetoed). 
+  # 
   # - {Wx::EvtHandler#evt_wizard_cancel}(id, meth = nil, &block): The user attempted to cancel the wizard (this event may also be vetoed). 
+  # 
   # - {Wx::EvtHandler#evt_wizard_help}(id, meth = nil, &block): The wizard help button was pressed. 
+  # 
   # - {Wx::EvtHandler#evt_wizard_finished}(id, meth = nil, &block): The wizard finished button was pressed. 
   # 
   # == Extended styles
@@ -31,7 +38,7 @@ module Wx
   # === Extra Styles
   # 
   # This class supports the following extra styles:
-  #  
+  # 
   # - {Wx::WIZARD_EX_HELPBUTTON}: Shows a Help button using {Wx::StandardID::ID_HELP}. 
   # 
   # See also {Wx::Dialog} for other extended styles.
@@ -48,7 +55,7 @@ module Wx
     # @overload initialize()
     #   Default constructor.
     #   Use this if you wish to derive from {Wx::Wizard} and then call {Wx::Wizard#create}, for example if you wish to set an extra style with {Wx::Window#set_extra_style} between the two calls.
-    #   @return [Wizard]
+    #   @return [Wx::Wizard]
     # @overload initialize(parent, id=Wx::StandardID::ID_ANY, title=(''), bitmap=(Wx::BitmapBundle.new()), pos=Wx::DEFAULT_POSITION, style=Wx::DEFAULT_DIALOG_STYLE)
     #   Constructor which really creates the wizard  if you use this constructor, you shouldn't call {Wx::Wizard#create}.
     #   Notice that unlike almost all other wxWidgets classes, there is no size parameter in the {Wx::Wizard} constructor because the wizard will have a predefined default size by default. If you want to change this, you should use the {Wx::Wizard#get_page_area_sizer} function.
@@ -58,7 +65,7 @@ module Wx
     #   @param bitmap [Wx::BitmapBundle,Wx::Bitmap,Wx::Icon,Wx::Image]  The default bitmap used in the left side of the wizard. See also {Wx::Wizard#get_bitmap}.
     #   @param pos [Array(Integer, Integer), Wx::Point]  The position of the dialog, it will be centered on the screen by default.
     #   @param style [Integer]  Window style is passed to {Wx::Dialog}.
-    #   @return [Wizard]
+    #   @return [Wx::Wizard]
     def initialize(*args) end
     
     # Creates the wizard dialog.
@@ -159,7 +166,13 @@ module Wx
     # Sets the flags indicating how the wizard or page bitmap should be expanded and positioned to fit the page height.
     # By default, placement is 0 (no expansion is done). placement is a bitlist with the following possible values:
     # 
-    # - <b>{Wx::WIZARD_VALIGN_TOP}:</b> Aligns the bitmap at the top.- <b>{Wx::WIZARD_VALIGN_CENTRE}:</b> Centres the bitmap vertically.- <b>{Wx::WIZARD_VALIGN_BOTTOM}:</b> Aligns the bitmap at the bottom.- <b>{Wx::WIZARD_HALIGN_LEFT}:</b> Left-aligns the bitmap.- <b>{Wx::WIZARD_HALIGN_CENTRE}:</b> Centres the bitmap horizontally.- <b>{Wx::WIZARD_HALIGN_RIGHT}:</b> Right-aligns the bitmap.- <b>{Wx::WIZARD_TILE}:</b> The bitmap will be tiled to fit available space.
+    # - <b>{Wx::WIZARD_VALIGN_TOP}:</b> Aligns the bitmap at the top.
+    # - <b>{Wx::WIZARD_VALIGN_CENTRE}:</b> Centres the bitmap vertically.
+    # - <b>{Wx::WIZARD_VALIGN_BOTTOM}:</b> Aligns the bitmap at the bottom.
+    # - <b>{Wx::WIZARD_HALIGN_LEFT}:</b> Left-aligns the bitmap.
+    # - <b>{Wx::WIZARD_HALIGN_CENTRE}:</b> Centres the bitmap horizontally.
+    # - <b>{Wx::WIZARD_HALIGN_RIGHT}:</b> Right-aligns the bitmap.
+    # - <b>{Wx::WIZARD_TILE}:</b> The bitmap will be tiled to fit available space.
     # 
     # See also {Wx::Wizard#set_minimum_bitmap_width}.
     # @param placement [Integer]