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

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

@@ -471,8 +471,9 @@ 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);
+    # ```
     #  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
     # @see  Wx::ScrollBar
@@ -534,8 +535,9 @@ 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));
+    #   ```
     #    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.
     #   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").
@@ -575,9 +577,10 @@ 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()));
+    #   ```
     #   
     #   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").
     #   @param sz [Array(Integer, Integer), Wx::Size] 
@@ -904,8 +907,9 @@ 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));
+    # ```
     # @see Wx::Window#set_max_size
     # @see  Window Sizing Overview 
     # @param size [Array(Integer, Integer), Wx::Size] 
@@ -926,8 +930,9 @@ 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));
+    # ```
     # @see Wx::Window#set_min_size
     # @see  Window Sizing Overview 
     # @param size [Array(Integer, Integer), Wx::Size] 
@@ -1074,8 +1079,9 @@ 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);
+    #   ```
     #   @see Wx::Window#set_size 
     #   @param x [Integer]  Required x position.
     #   @param y [Integer]  Required y position.
@@ -1084,8 +1090,9 @@ 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);
+    #   ```
     #   @see Wx::Window#set_size 
     #   @param pt [Array(Integer, Integer), Wx::Point]  {Wx::Point} object representing the position.
     #   @param flags [Integer]  See {Wx::Window#set_size} for more info about this parameter.
@@ -1108,8 +1115,9 @@ module Wx
     #   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)
+    #   ```
     #   @see Wx::Window#convert_pixels_to_dialog 
     #   @param pt [Array(Integer, Integer), Wx::Point] 
     #   @return [Wx::Point]
@@ -1300,7 +1308,7 @@ module Wx
     # 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".
     # 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:
@@ -1314,6 +1322,7 @@ module Wx
     #           Create(parent, ...);
     #       }
     #   };
+    # ```
     # @see Wx::Window#set_background_colour
     # @see  Wx::Window#get_foreground_colour
     # @see  Wx::Window#set_transparent
@@ -1468,7 +1477,9 @@ module Wx
     def handle_as_navigation_key(event) end
     
     # Shorthand for:
-    # GetEventHandler()->SafelyProcessEvent(event);
+    # ```
+    #   GetEventHandler()->SafelyProcessEvent(event);
+    # ```
     # @see Wx::Window#process_window_event 
     # @param event [Wx::Event] 
     # @return [true,false]
@@ -1476,8 +1487,9 @@ module Wx
     
     # Convenient wrapper for {Wx::Window#process_event}.
     # This is the same as writing 
-    # 
+    # ```
     #   GetEventHandler()->ProcessEvent(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] 
     # @return [true,false]
@@ -1493,9 +1505,10 @@ 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);
+    # ```
     #  you will end up with the following situation: 
     # 
     # Note that you can use {Wx::Window#pop_event_handler} to remove the event handler.
@@ -1704,10 +1717,11 @@ 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 ...);
+    # ```
     # 
     # 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.
     # @see Wx::Window#is_enabled
@@ -2074,7 +2088,7 @@ module Wx
     # Return the cursor associated with this window.
     # 
     # @see Wx::Window#set_cursor 
-    # @return [void]
+    # @return [Wx::Cursor]
     def get_cursor; end
     alias_method :cursor, :get_cursor
     
@@ -2123,8 +2137,9 @@ 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);
+    # ```
     #  instead of calling it twice in a row as the second call would disable the first gesture.
     # 
     # true if the specified events were enabled or false if the current platform doesn't support touch events.
@@ -2158,6 +2173,7 @@ 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)
     #   {
@@ -2170,6 +2186,7 @@ module Wx
     #               SetTitle(event.GetText());
     #       }
     #   }
+    # ```
     # @param event [Wx::UpdateUIEvent] 
     # @return [void]
     def do_update_window_ui(event) end
@@ -2254,11 +2271,13 @@ 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);
     #   }
+    # ```
     # @see Wx::UpdateUIEvent
     # @see  Wx::Window#do_update_window_ui
     # @see  Wx::Window#on_internal_idle 
@@ -2364,15 +2383,16 @@ module Wx
     # 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.
     #   ... create all the panel children ...
     #   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() {
@@ -2391,6 +2411,7 @@ module Wx
     #   // 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, ...);
+    # ```
     #  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.
     # true if window creation succeeded or false if it failed

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

@@ -21,6 +21,8 @@ module Wx
   # @see  Wx::ScreenDC 
   # 
   # 
+  # 
+  # @note This class is <b>untracked</b> and should not be derived from nor instances extended!
   class WindowDC < DC
   
     # Constructor.

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

@@ -16,6 +16,8 @@ module Wx
   # @see Wx::BusyCursor 
   # 
   # 
+  # 
+  # @note This class is <b>untracked</b> and should not be derived from nor instances extended!
   class WindowDisabler < ::Object
   
   end # WindowDisabler

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

@@ -42,10 +42,12 @@ module Wx
     # A helper chaining this page with the next one.
     # Notice that this method returns a reference to the next page, so the calls to it can, in turn, be chained:
     # 
+    # ```
     #   wxWizardPageSimple* firstPage = new FirstPage;
     #   (*firstPage).Chain(new SecondPage)
     #               .Chain(new ThirdPage)
     #               .Chain(new LastPage);
+    # ```
     # 
     # This makes this method the simplest way to define the order of changes in fully static wizards, i.e. in those where the order doesn't depend on the choices made by the user in the wizard pages during run-time.
     # 

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

@@ -104,6 +104,8 @@ module Wx
   # @see  Wx::XmlAttribute 
   # 
   # 
+  # 
+  # @note This class is <b>untracked</b> and should not be derived from nor instances extended!
   class XmlNode < ::Object
   
     # @overload initialize(type, name, content=(''), lineNo=-1)
@@ -193,13 +195,17 @@ module Wx
     # Returns the content of the first child node of type {Wx::XmlNodeType::XML_TEXT_NODE} or {Wx::XmlNodeType::XML_CDATA_SECTION_NODE}.
     # This function is very useful since the XML snippet <code>"tagnametagcontent/tagname"</code> is represented by expat with the following tag tree:
     # 
+    # ```
     #   wxXML_ELEMENT_NODE name="tagname", content=""
     #   |-- wxXML_TEXT_NODE name="", content="tagcontent"
+    # ```
     # 
     # or eventually:
     # 
+    # ```
     #   wxXML_ELEMENT_NODE name="tagname", content=""
     #   |-- wxXML_CDATA_SECTION_NODE name="", content="tagcontent"
+    # ```
     # 
     # An empty string is returned if the node has no children of type {Wx::XmlNodeType::XML_TEXT_NODE} or {Wx::XmlNodeType::XML_CDATA_SECTION_NODE}, or if the content of the first child of such types is empty.
     # @return [String]

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

@@ -104,9 +104,10 @@ module Wx
     
     # Loads resources from XML files that match given filemask.
     # Example: 
-    # 
+    # ```
     #   if (!wxXmlResource::Get()->Load("rc/*.xrc"))
     #       wxLogError("Couldn't load resources!");
+    # ```
     # 
     # If {Wx::USE_FILESYS} is enabled, this method understands {Wx::FileSystem} URLs (see Wx::FileSystem#find_first).
     # 
@@ -150,9 +151,11 @@ module Wx
     # parent points to parent window (if any).
     # This form is used to finish creation of an already existing instance (the main reason for this is that you may want to use derived class with a new event table). Example:
     # 
+    # ```
     #   MyDialog dlg;
     #   wxXmlResource::Get()->LoadDialog(&dlg, mainFrame, "my_dialog");
     #   dlg.ShowModal();
+    # ```
     # @param dlg [Wx::Dialog] 
     # @param parent [Wx::Window] 
     # @param name [String] 

data/lib/wx/doc/memory_dc.rb

@@ -0,0 +1,75 @@
+
+module Wx
+
+  class MemoryDC < Wx::DC
+
+    # Creates a Memory DC and passes that to the given block to draw on.
+    # Automatically unselects any source object of the MemoryDC after the block finishes.
+    # @overload self.draw_on()
+    #   @yieldparam [Wx::MemoryDC] dc
+    # @overload self.draw_on(bitmap)
+    #   @param [Wx::Bitmap]
+    #   @yieldparam [Wx::MemoryDC] dc
+    # @overload self.draw_on(dc)
+    #   @param [Wx::DC]
+    #   @yieldparam [Wx::MemoryDC] dc
+    def self.draw_on(*arg) end
+
+  end
+
+  class BufferedDC < Wx::MemoryDC
+
+    # Creates a Buffered DC and passes that to the given block to draw on.
+    # Destroys the DC after the block returns.
+    # @overload self.draw_on()
+    #   Creates a buffer for the provided dc.
+    #   @yieldparam [Wx::BufferedDC] dc
+    # @overload self.draw_on(tgt, area, style=Wx::BUFFER_CLIENT_AREA)
+    #   Creates a buffer for the provided dc. #init must not be called when using this constructor.
+    #   @param [Wx::DC] tgt The underlying DC: everything drawn to this object will be flushed to this DC when this object is destroyed. You may pass nil in order to just initialize the buffer, and not flush it.
+    #   @param [Wx::Size] area The size of the bitmap to be used for buffering (this bitmap is created internally when it is not given explicitly).
+    #   @param [Integer] style Wx::BUFFER_CLIENT_AREA to indicate that just the client area of the window is buffered, or Wx::BUFFER_VIRTUAL_AREA to indicate that the buffer bitmap covers the virtual area.
+    #   @yieldparam [Wx::BufferedDC] dc
+    # @overload self.draw_on(tgt, buffer=Wx::NULL_BITMAP, style=Wx::BUFFER_CLIENT_AREA)
+    #   Creates a buffer for the provided dc. #init must not be called when using this constructor.
+    #   @param [Wx::DC] tgt The underlying DC: everything drawn to this object will be flushed to this DC when this object is destroyed. You may pass nil in order to just initialize the buffer, and not flush it.
+    #   @param [Wx::Bitmap] buffer Explicitly provided bitmap to be used for buffering: this is the most efficient solution as the bitmap doesn't have to be recreated each time but it also requires more memory as the bitmap is never freed. The bitmap should have appropriate size, anything drawn outside of its bounds is clipped.
+    #   @param [Integer] style Wx::BUFFER_CLIENT_AREA to indicate that just the client area of the window is buffered, or Wx::BUFFER_VIRTUAL_AREA to indicate that the buffer bitmap covers the virtual area.
+    #   @yieldparam [Wx::BufferedDC] dc
+    def self.draw_on(*arg) end
+
+  end
+
+  class BufferedPaintDC < Wx::BufferedDC
+
+    # Creates a Buffered DC and passes that to the given block to draw on.
+    # Destroys the DC after the block returns.
+    # As with Wx::BufferedDC, you may either provide the bitmap to be used for buffering or let this object create one internally (in the latter case, the size of the client part of the window is used).
+    #
+    # Pass W::xBUFFER_CLIENT_AREA for the style parameter to indicate that just the client area of the window is buffered, or Wx::BUFFER_VIRTUAL_AREA to indicate that the buffer bitmap covers the virtual area.
+    # @overload self.draw_on(win, style=Wx::BUFFER_CLIENT_AREA)
+    #   @param [Wx::Window] win The underlying window; everything drawn to this object will be flushed to this window when this object is destroyed.
+    #   @param [Integer] style Wx::BUFFER_CLIENT_AREA to indicate that just the client area of the window is buffered, or Wx::BUFFER_VIRTUAL_AREA to indicate that the buffer bitmap covers the virtual area.
+    #   @yieldparam [Wx::BufferedPaintDC] dc
+    # @overload self.draw_on(win, buffer=Wx::NULL_BITMAP, style=Wx::BUFFER_CLIENT_AREA)
+    #   @param [Wx::Window] win The underlying window; everything drawn to this object will be flushed to this window when this object is destroyed.
+    #   @param [Wx::Bitmap] buffer Explicitly provided bitmap to be used for buffering: this is the most efficient solution as the bitmap doesn't have to be recreated each time but it also requires more memory as the bitmap is never freed. The bitmap should have appropriate size, anything drawn outside of its bounds is clipped.
+    #   @param [Integer] style Wx::BUFFER_CLIENT_AREA to indicate that just the client area of the window is buffered, or Wx::BUFFER_VIRTUAL_AREA to indicate that the buffer bitmap covers the virtual area.
+    #   @yieldparam [Wx::BufferedPaintDC] dc
+    def self.draw_on(*arg) end
+
+  end
+
+  class AutoBufferedPaintDC < Wx::BufferedPaintDC
+
+    # Creates a Buffered DC and passes that to the given block to draw on.
+    # Destroys the DC after the block returns.
+    # Pass a pointer to the window on which you wish to paint.
+    # @note In wxRuby this method mostly exists to be consistent with the other DC classes. It is however recommended to use Wx::Window#paint_buffered instead.
+    # @param [Wx::Window] win The underlying window; everything drawn to this object will be flushed to this window when this object is destroyed.
+    # @yieldparam [Wx::AutoBufferedPaintDC] dc
+    def self.draw_on(win, &block) end
+
+  end
+
+end

data/lib/wx/doc/mirror_dc.rb

@@ -0,0 +1,16 @@
+
+module Wx
+
+  class MirrorDC < Wx::DC
+
+    # Executes the given block providing a temporary (mirror) dc as
+    # it's single argument.
+    # @param [Wx::DC] dc DC to duplicate the (mirrored) drawing on
+    # @param [Boolean] mirror whether to mirror or not
+    # @yieldparam [Wx::MirrorDC] dc the MirrorDC instance to paint on
+    # @return [Object] result of the block
+    def self.draw_on(dc, mirror) end
+
+  end
+
+end

data/lib/wx/doc/prt/printer_dc.rb

@@ -0,0 +1,26 @@
+
+module Wx::PRT
+
+  class PrinterDC < Wx::DC
+
+    # Executes the given block providing a temporary (printer) dc as
+    # it's single argument.
+    # @param [Wx::PRT::PrintData] print_data print_data defining the print settings
+    # @yieldparam [Wx::PrinterDC] dc the PrinterDC instance to paint on
+    # @return [Object] result of the block
+    def self.draw_on(win) end
+
+  end
+
+  class PostScriptDC < Wx::DC
+
+    # Executes the given block providing a temporary (postscript) dc as
+    # it's single argument.
+    # @param [Wx::PRT::PrintData] print_data print_data defining the print settings
+    # @yieldparam [Wx::PostScriptDC] dc the PostScriptDC instance to paint on
+    # @return [Object] result of the block
+    def self.draw_on(win) end
+
+  end
+
+end

data/lib/wx/doc/screen_dc.rb

@@ -1,10 +1,14 @@
 
-class Wx::ScreenDC
+module Wx
 
-  # Executes the given block providing a temporary (screen) dc as
-  # it's single argument.
-  # @yieldparam [Wx::ScreenDC] dc the ScreenDC instance to paint on
-  # @return [Object] result of the block
-  def self.paint; end
+  class ScreenDC < Wx::DC
+
+    # Executes the given block providing a temporary (screen) dc as
+    # it's single argument.
+    # @yieldparam [Wx::ScreenDC] dc the ScreenDC instance to paint on
+    # @return [Object] result of the block
+    def self.draw_on; end
+
+  end
 
 end

data/lib/wx/doc/svg_file_dc.rb

@@ -0,0 +1,20 @@
+
+module Wx
+
+  class SVGFileDC < Wx::DC
+
+    # Executes the given block providing a temporary dc as it's single argument.
+    # Initializes a wxSVGFileDC 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 [String] filename name of file to create
+    # @param [Integer] width width for SVG image
+    # @param [Integer] height height for SVG image
+    # @param [Float] dpi resolution for SVG image
+    # @param [String] title readable name for the SVG document
+    # @yieldparam [Wx::SVGFileDC] dc the SVGFileDC instance to paint on
+    # @return [Object] result of the block
+    def self.draw_on(filename, width=320, height=240, dpi=72, title='') end
+
+  end
+
+end

data/lib/wx/doc/v_list_box.rb

@@ -0,0 +1,9 @@
+
+class Wx::VListBox
+
+  # Iterate selected items. Returns Enumerator if no block given.
+  # @yieldparam [Integer] sel selected item index
+  # @return [Enumerator,Object] if block given returns last return value of block, Enumerator otherwise
+  def each_selected; end
+
+end

data/lib/wx/doc/window_disabler.rb

@@ -0,0 +1,10 @@
+
+class Wx::WindowDisabler
+
+  # Disables all top level windows of the application (maybe with the exception of one of them) in
+  # and enables them back after the given block has returned.
+  # @param [Wx::Window,nil] to_skip window to exclude from disabling
+  # @return [void]
+  def self.disable(to_skip = nil) end
+
+end

data/lib/wx/html/keyword_defs.rb

@@ -10,13 +10,12 @@ Wx::define_keyword_ctors(Wx::HTML::HtmlWindow) do
 end
 
 # wxHtmlListBox 	A listbox showing HTML content
-# wxListBox 	A list of strings for single or multiple selection
-Wx::define_keyword_ctors('ListBox') do
-  wx_ctor_params :id, :pos, :size, :choices => []
-  wx_ctor_params :style
-  wx_ctor_params :validator, :name => 'listBox'
+Wx::define_keyword_ctors(Wx::HTML::HtmlListBox) do
+  wx_ctor_params :id, :pos, :size, :style, :name => 'HtmlListBox'
 end
 
-Wx::define_keyword_ctors('HtmlListBox') do
-  wx_ctor_params :id, :pos, :size, :style, :name => 'HtmlListBoxNameStr'
+Wx::define_keyword_ctors(Wx::HTML::SimpleHtmlListBox) do
+  wx_ctor_params :id, :pos, :size
+  wx_ctor_params :choices => []
+  wx_ctor_params :style, :validator, :name => 'SimpleHtmlListBox'
 end

data/lib/wx/html/require.rb

@@ -6,5 +6,6 @@ require_relative './events/evt_list'
 require_relative './keyword_defs'
 require_relative './htmlwindow'
 require_relative './htmlhelpcontroller'
+require_relative './simple_html_listbox'
 
 Wx::Dialog.setup_dialog_functors(Wx::HTML)

data/lib/wx/html/simple_html_listbox.rb

@@ -0,0 +1,105 @@
+
+class Wx::HTML::SimpleHtmlListBox
+
+  # Make this a Ruby enumerable so find, find_all, map etc are available
+  include Enumerable
+
+  # Passes each valid item index into the passed block
+  def each
+    get_count.times { | i | yield i }
+  end
+
+  # We need to cache client data in Ruby variables as we cannot access items
+  # during the GC mark phase as for some platforms (WXMSW at least) that would
+  # involve calling methods that would break in that phase.
+
+  def client_data_store
+    @client_data ||= []
+  end
+  private :client_data_store
+
+  wx_set_client_data = instance_method :set_client_data
+  define_method :set_client_data do |item, data|
+    item = item.to_i
+    wx_set_client_data.bind(self).call(item, data)
+    client_data_store[item] = data
+  end
+
+  def get_client_data(item)
+    client_data_store[item.to_i]
+  end
+
+  wx_append = instance_method :append
+  define_method :append do |item, data=nil|
+    if data
+      if ::Array === item
+        if !(::Array === data)
+          ::Kernel.raise ::TypeError.new("Expected Array for argument 3")
+        elsif data.size != item.size
+          ::Kernel.raise ::ArgumentError.new("item and data array must be equal size")
+        end
+        offs = get_count
+        wx_append.bind(self).call(item)
+        item.size.times { |ix| set_client_data(offs+ix, data[ix]) }
+      else
+        wx_append.bind(self).call(item, data)
+        client_data_store[get_count-1] = data
+      end
+    else
+      wx_append.bind(self).call(item)
+      # no changes to data store
+    end
+  end
+
+  wx_insert = instance_method :insert
+  define_method :insert do |item, pos, data=nil|
+    if data
+      if ::Array === item
+        if !(::Array === data)
+          ::Kernel.raise ::TypeError.new("Expected Array for argument 3")
+        elsif data.size != item.size
+          ::Kernel.raise ::ArgumentError.new("item and data array must be equal size")
+        end
+        wx_insert.bind(self).call(item, pos)
+        client_data_store.insert(pos, *::Array.new(item.size))
+        item.size.times { |ix| set_client_data(pos+ix, data[ix]) }
+      else
+        wx_insert.bind(self).call(item, pos, data)
+        client_data_store.insert(pos, data)
+      end
+    else
+      wx_insert.bind(self).call(item, pos)
+      if ::Array === item
+        client_data_store.insert(pos, *::Array.new(item.size))
+      else
+        client_data_store.insert(pos, nil)
+      end
+    end
+  end
+
+  wx_set = instance_method :set
+  define_method :set do |items, data=nil|
+    if data
+      if !(::Array === data)
+        ::Kernel.raise ::TypeError.new("Expected Array for argument 2")
+      elsif data.size != items.size
+        ::Kernel.raise ::ArgumentError.new("items and data array must be equal size")
+      end
+    end
+    wx_set.bind(self).call(items)
+    client_data_store.clear
+    items.each_with_index { |item, ix| set_client_data(item, data[ix]) }
+  end
+
+  wx_clear = instance_method :clear
+  define_method :clear do
+    wx_clear.bind(self).call
+    client_data_store.clear
+  end
+
+  wx_delete = instance_method :delete
+  define_method :delete do |item|
+    wx_delete.bind(self).call(item.to_i)
+    client_data_store.slice!(item.to_i)
+  end
+end

data/lib/wx/keyword_defs.rb

@@ -296,6 +296,13 @@ Wx::define_keyword_ctors('CheckBox') do
   wx_ctor_params :validator, :name => 'checkBox'
 end
 
+# wxListBox 	A list of strings for single or multiple selection
+Wx::define_keyword_ctors('ListBox') do
+  wx_ctor_params :id, :pos, :size, :choices => []
+  wx_ctor_params :style
+  wx_ctor_params :validator, :name => 'listBox'
+end
+
 # A listbox with a checkbox to the left of each item
 Wx::define_keyword_ctors('CheckListBox') do
   wx_ctor_params :id, :pos, :size, :choices, :style

data/lib/wx/version.rb

@@ -1,3 +1,3 @@
 module Wx
-  WXRUBY_VERSION    = '0.9.0-beta.14'
+  WXRUBY_VERSION    = '0.9.0-rc.1'
 end