wxruby3 1.6.0 → 1.7.0

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

@@ -0,0 +1,232 @@
+# :stopdoc:
+# This file is automatically generated by the WXRuby3 documentation 
+# generator. Do not alter this file.
+# :startdoc:
+
+
+module Wx
+
+  # Enumeration used by {Wx::LayoutAlgorithm}.
+  # 
+  # 
+  # 
+  # @wxrb_require USE_SASH
+  class LayoutOrientation < Wx::Enum
+  
+    # 
+    # 
+    LAYOUT_HORIZONTAL = Wx::LayoutOrientation.new(0)
+    
+    # 
+    # 
+    LAYOUT_VERTICAL = Wx::LayoutOrientation.new(1)
+    
+  end # LayoutOrientation
+  
+  # Enumeration used by {Wx::LayoutAlgorithm}.
+  # 
+  # 
+  # 
+  # @wxrb_require USE_SASH
+  class LayoutAlignment < Wx::Enum
+  
+    # 
+    # 
+    LAYOUT_NONE = Wx::LayoutAlignment.new(0)
+    
+    # 
+    # 
+    LAYOUT_TOP = Wx::LayoutAlignment.new(1)
+    
+    # 
+    # 
+    LAYOUT_LEFT = Wx::LayoutAlignment.new(2)
+    
+    # 
+    # 
+    LAYOUT_RIGHT = Wx::LayoutAlignment.new(3)
+    
+    # 
+    # 
+    LAYOUT_BOTTOM = Wx::LayoutAlignment.new(4)
+    
+  end # LayoutAlignment
+  
+  # 
+  # 
+  EVT_QUERY_LAYOUT_INFO = 10324
+  
+  # 
+  # 
+  EVT_CALCULATE_LAYOUT = 10325
+  
+  # {Wx::SashLayoutWindow} responds to OnCalculateLayout events generated by {Wx::LayoutAlgorithm}.
+  # 
+  # It allows the application to use simple accessors to specify how the window should be laid out, rather than having to respond to events.
+  # The fact that the class derives from {Wx::SashWindow} allows sashes to be used if required, to allow the windows to be user-resizable.
+  # The documentation for {Wx::LayoutAlgorithm} explains the purpose of this class in more detail.
+  # For the window styles see {Wx::SashWindow}.
+  # This class handles the EVT_QUERY_LAYOUT_INFO and EVT_CALCULATE_LAYOUT events for you. However, if you use sashes, see {Wx::SashWindow} for relevant event information. See also {Wx::LayoutAlgorithm} for information about the layout events.
+  # 
+  # Category:  Miscellaneous Windows
+  # @see Wx::LayoutAlgorithm
+  # @see  Wx::SashWindow
+  # @see  Events and Event Handling 
+  # 
+  # 
+  # @wxrb_require USE_SASH
+  class SashLayoutWindow < SashWindow
+  
+    # @overload initialize()
+    #   Default ctor.
+    #   @return [Wx::SashLayoutWindow]
+    # @overload initialize(parent, id, pos=Wx::DEFAULT_POSITION, size=Wx::DEFAULT_SIZE, style=(Wx::CLIP_CHILDREN|wxSW_3D), name=("LAYOUT_WINDOW"))
+    #   Constructs a sash layout 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.
+    #   @param id [Integer]  Window identifier. If -1, will automatically create an identifier.
+    #   @param pos [Array(Integer, Integer), Wx::Point]  Window position. {Wx::DEFAULT_POSITION} is (-1, -1) which indicates that {Wx::SashLayoutWindows} should generate a default position for the window. If using the {Wx::SashLayoutWindow} class directly, supply an actual position.
+    #   @param size [Array(Integer, Integer), Wx::Size]  Window size. {Wx::DEFAULT_SIZE} is (-1, -1) which indicates that {Wx::SashLayoutWindows} should generate a default size for the window.
+    #   @param style [Integer]  Window style. For window styles, please see {Wx::SashLayoutWindow}.
+    #   @param name [String]  Window name.
+    #   @return [Wx::SashLayoutWindow]
+    # @overload initialize(parent, id, pos=Wx::DEFAULT_POSITION, size=Wx::DEFAULT_SIZE, style=(Wx::CLIP_CHILDREN|wxSW_3D), name=("LAYOUT_WINDOW"), &block)
+    #   Constructs a sash layout 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.
+    #   @param id [Integer]  Window identifier. If -1, will automatically create an identifier.
+    #   @param pos [Array(Integer, Integer), Wx::Point]  Window position. {Wx::DEFAULT_POSITION} is (-1, -1) which indicates that {Wx::SashLayoutWindows} should generate a default position for the window. If using the {Wx::SashLayoutWindow} class directly, supply an actual position.
+    #   @param size [Array(Integer, Integer), Wx::Size]  Window size. {Wx::DEFAULT_SIZE} is (-1, -1) which indicates that {Wx::SashLayoutWindows} should generate a default size for the window.
+    #   @param style [Integer]  Window style. For window styles, please see {Wx::SashLayoutWindow}.
+    #   @param name [String]  Window name.
+    #   @yieldparam [Wx::SashLayoutWindow] win new instance
+    #   @return [Wx::SashLayoutWindow]
+    def initialize(*args) end
+    
+    # Initializes a sash layout 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.
+    # @param id [Integer]  Window identifier. If -1, will automatically create an identifier.
+    # @param pos [Array(Integer, Integer), Wx::Point]  Window position. {Wx::DEFAULT_POSITION} is (-1, -1) which indicates that {Wx::SashLayoutWindows} should generate a default position for the window. If using the {Wx::SashLayoutWindow} class directly, supply an actual position.
+    # @param size [Array(Integer, Integer), Wx::Size]  Window size. {Wx::DEFAULT_SIZE} is (-1, -1) which indicates that {Wx::SashLayoutWindows} should generate a default size for the window.
+    # @param style [Integer]  Window style. For window styles, please see {Wx::SashLayoutWindow}.
+    # @param name [String]  Window name.
+    # @return [Boolean]
+    def create(parent, id=Wx::StandardID::ID_ANY, pos=Wx::DEFAULT_POSITION, size=Wx::DEFAULT_SIZE, style=(Wx::CLIP_CHILDREN|wxSW_3D), name=("LAYOUT_WINDOW")) end
+    
+    # Returns the alignment of the window: one of {Wx::LayoutAlignment::LAYOUT_TOP}, {Wx::LayoutAlignment::LAYOUT_LEFT}, {Wx::LayoutAlignment::LAYOUT_RIGHT}, {Wx::LayoutAlignment::LAYOUT_BOTTOM}.
+    # @return [Wx::LayoutAlignment]
+    def get_alignment; end
+    alias_method :alignment, :get_alignment
+    
+    # Returns the orientation of the window: one of {Wx::LayoutOrientation::LAYOUT_HORIZONTAL}, {Wx::LayoutOrientation::LAYOUT_VERTICAL}.
+    # @return [Wx::LayoutOrientation]
+    def get_orientation; end
+    alias_method :orientation, :get_orientation
+    
+    # The default handler for the event that is generated by {Wx::LayoutAlgorithm}.
+    # 
+    # The implementation of this function calls {Wx::CalculateLayoutEvent#set_rect} to shrink the provided size according to how much space this window takes up. For further details, see {Wx::LayoutAlgorithm} and {Wx::CalculateLayoutEvent}.
+    # @param event [Wx::CalculateLayoutEvent] 
+    # @return [void]
+    def on_calculate_layout(event) end
+    
+    # The default handler for the event that is generated by OnCalculateLayout to get size, alignment and orientation information for the window.
+    # 
+    # The implementation of this function uses member variables as set by accessors called by the application.
+    # For further details, see {Wx::LayoutAlgorithm} and {Wx::QueryLayoutInfoEvent}.
+    # @param event [Wx::QueryLayoutInfoEvent] 
+    # @return [void]
+    def on_query_layout_info(event) end
+    
+    # Sets the alignment of the window (which edge of the available parent client area the window is attached to).
+    # 
+    # alignment is one of {Wx::LayoutAlignment::LAYOUT_TOP}, {Wx::LayoutAlignment::LAYOUT_LEFT}, {Wx::LayoutAlignment::LAYOUT_RIGHT}, {Wx::LayoutAlignment::LAYOUT_BOTTOM}.
+    # @param alignment [Wx::LayoutAlignment] 
+    # @return [void]
+    def set_alignment(alignment) end
+    alias_method :alignment=, :set_alignment
+    
+    # Sets the default dimensions of the window.
+    # 
+    # The dimension other than the orientation will be fixed to this value, and the orientation dimension will be ignored and the window stretched to fit the available space.
+    # @param size [Array(Integer, Integer), Wx::Size] 
+    # @return [void]
+    def set_default_size(size) end
+    alias_method :default_size=, :set_default_size
+    
+    # Sets the orientation of the window (the direction the window will stretch in, to fill the available parent client area).
+    # 
+    # orientation is one of {Wx::LayoutOrientation::LAYOUT_HORIZONTAL}, {Wx::LayoutOrientation::LAYOUT_VERTICAL}.
+    # @param orientation [Wx::LayoutOrientation] 
+    # @return [void]
+    def set_orientation(orientation) end
+    alias_method :orientation=, :set_orientation
+    
+  end # SashLayoutWindow
+  
+  # {Wx::LayoutAlgorithm} implements layout of subwindows in MDI or SDI frames.
+  # 
+  # It sends a {Wx::CalculateLayoutEvent} event to children of the frame, asking them for information about their size. For MDI parent frames, the algorithm allocates the remaining space to the MDI client window (which contains the MDI child frames).
+  # For SDI (normal) frames, a 'main' window is specified as taking up the remaining space.
+  # Because the event system is used, this technique can be applied to any windows, which are not necessarily 'aware' of the layout classes (no virtual functions in {Wx::Window} refer to {Wx::LayoutAlgorithm} or its events). However, you may wish to use {Wx::SashLayoutWindow} for your subwindows since this class provides handlers for the required events, and accessors to specify the desired size of the window. The sash behaviour in the base class can be used, optionally, to make the windows user-resizable.
+  # {Wx::LayoutAlgorithm} is typically used in IDE (integrated development environment) applications, where there are several resizable windows in addition to the MDI client window, or other primary editing window. Resizable windows might include toolbars, a project window, and a window for displaying error and warning messages.
+  # When a window receives an OnCalculateLayout event, it should call SetRect in the given event object, to be the old supplied rectangle minus whatever space the window takes up. It should also set its own size accordingly. {Wx::SashLayoutWindow#on_calculate_layout} generates an OnQueryLayoutInfo event which it sends to itself to determine the orientation, alignment and size of the window, which it gets from internal member variables set by the application.
+  # The algorithm works by starting off with a rectangle equal to the whole frame client area. It iterates through the frame children, generating {Wx::LayoutAlgorithm::OnCalculateLayout} events which subtract the window size and return the remaining rectangle for the next window to process. It is assumed (by {Wx::SashLayoutWindow#on_calculate_layout}) that a window stretches the full dimension of the frame client, according to the orientation it specifies. For example, a horizontal window will stretch the full width of the remaining portion of the frame client area. In the other orientation, the window will be fixed to whatever size was specified by {Wx::LayoutAlgorithm::OnQueryLayoutInfo}. An alignment setting will make the window 'stick' to the left, top, right or bottom of the remaining client area. This scheme implies that order of window creation is important. Say you wish to have an extra toolbar at the top of the frame, a project window to the left of the MDI client window, and an output window above the status bar. You should therefore create the windows in this order: toolbar, output window, project window. This ensures that the toolbar and output window take up space at the top and bottom, and then the remaining height in-between is used for the project window.
+  # {Wx::LayoutAlgorithm} is quite independent of the way in which {Wx::LayoutAlgorithm::OnCalculateLayout} chooses to interpret a window's size and alignment. Therefore you could implement a different window class with a new {Wx::LayoutAlgorithm::OnCalculateLayout} event handler, that has a more sophisticated way of laying out the windows. It might allow specification of whether stretching occurs in the specified orientation, for example, rather than always assuming stretching. (This could, and probably should, be added to the existing implementation).
+  # 
+  # <div class="wxrb-note">
+  # <b>Note:</b>
+  # <p>{Wx::LayoutAlgorithm} has nothing to do with {Wx::LayoutConstraints}. It is an alternative way of specifying layouts for which the normal constraint system is unsuitable.
+  # </p>
+  # </div>
+  # 
+  # ### Events emitted by this class
+  # 
+  # The following event-handler methods redirect the events to member method or handler blocks for {Wx::CalculateLayoutEvent} events.
+  # Event handler methods for events emitted by this class:
+  # 
+  # - {Wx::EvtHandler#evt_query_layout_info}(meth = nil, &block): Process a {Wx::EVT_QUERY_LAYOUT_INFO} event, to get size, orientation and alignment from a window. See {Wx::QueryLayoutInfoEvent}. 
+  # 
+  # - {Wx::EvtHandler#evt_calculate_layout}(meth = nil, &block): Process a {Wx::EVT_CALCULATE_LAYOUT} event, which asks the window to take a 'bite' out of a rectangle provided by the algorithm. See {Wx::CalculateLayoutEvent}. 
+  # 
+  # Note that the algorithm object does not respond to events, but itself generates the previous events in order to calculate window sizes.
+  # 
+  # Category:  Window Layout
+  # @see Wx::SashEvent
+  # @see  Wx::SashLayoutWindow
+  # @see  Events and Event Handling 
+  # 
+  # 
+  # @wxrb_require USE_SASH
+  class LayoutAlgorithm < Object
+  
+    # Default constructor.
+    # @return [Wx::LayoutAlgorithm]
+    def initialize; end
+    
+    # Lays out the children of a normal frame.
+    # 
+    # mainWindow is set to occupy the remaining space. This function simply calls {Wx::LayoutAlgorithm#layout_window}.
+    # @param frame [Wx::Frame] 
+    # @param mainWindow [Wx::Window] 
+    # @return [Boolean]
+    def layout_frame(frame, mainWindow=nil) end
+    
+    # Lays out the children of an MDI parent frame.
+    # 
+    # If rect is non-null, the given rectangle will be used as a starting point instead of the frame's client area. The MDI client window is set to occupy the remaining space.
+    # @param frame [Wx::MDIParentFrame] 
+    # @param rect [Wx::Rect] 
+    # @return [Boolean]
+    def layout_mdi_frame(frame, rect=nil) end
+    
+    # Lays out the children of a normal frame or other window.
+    # 
+    # mainWindow is set to occupy the remaining space. If this is not specified, then the last window that responds to a calculate layout event in query mode will get the remaining space (that is, a non-query OnCalculateLayout event will not be sent to this window and the window will be set to the remaining size).
+    # @param parent [Wx::Window] 
+    # @param mainWindow [Wx::Window] 
+    # @return [Boolean]
+    def layout_window(parent, mainWindow=nil) end
+    
+  end # LayoutAlgorithm
+  
+
+end

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

@@ -0,0 +1,171 @@
+# :stopdoc:
+# This file is automatically generated by the WXRuby3 documentation 
+# generator. Do not alter this file.
+# :startdoc:
+
+
+module Wx
+
+  # {Wx::SashWindow} allows any of its edges to have a sash which can be dragged to resize the window.
+  # 
+  # The actual content window will be created by the application as a child of {Wx::SashWindow}.
+  # The window (or an ancestor) will be notified of a drag via a {Wx::SashEvent} notification.
+  # ### Styles
+  # 
+  # This class supports the following styles:
+  # 
+  # - {Wx::SW_3D}: Draws a 3D effect sash and border. 
+  # 
+  # - {Wx::SW_3DSASH}: Draws a 3D effect sash. 
+  # 
+  # - {Wx::SW_3DBORDER}: Draws a 3D effect border. 
+  # 
+  # - {Wx::SW_BORDER}: Draws a thin black border. 
+  # 
+  # ### Events emitted by this class
+  # 
+  # The following event-handler methods redirect the events to member method or handler blocks for {Wx::SashEvent} events.
+  # Event handler methods for events emitted by this class:
+  # 
+  # - {Wx::EvtHandler#evt_sash_dragged}(id, meth = nil, &block): Process a {Wx::EVT_SASH_DRAGGED} event, when the user has finished dragging a sash. 
+  # 
+  # - {Wx::EvtHandler#evt_sash_dragged_range}(id1,  id2, meth = nil, &block): Process a {Wx::EVT_SASH_DRAGGED_RANGE} event, when the user has finished dragging a sash. The event handler is called when windows with ids in the given range have their sashes dragged. 
+  # 
+  # Category:  Miscellaneous Windows
+  # @see Wx::SashEvent
+  # @see  Wx::SashLayoutWindow
+  # @see  Events and Event Handling 
+  # 
+  # 
+  # @wxrb_require USE_SASH
+  class SashWindow < Window
+  
+    # @overload initialize()
+    #   Default ctor.
+    #   @return [Wx::SashWindow]
+    # @overload initialize(parent, id, pos=Wx::DEFAULT_POSITION, size=Wx::DEFAULT_SIZE, style=(Wx::CLIP_CHILDREN|wxSW_3D), name=("SASH_WINDOW"))
+    #   Constructs a sash 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.
+    #   @param id [Integer]  Window identifier. If -1, will automatically create an identifier.
+    #   @param pos [Array(Integer, Integer), Wx::Point]  Window position. {Wx::DEFAULT_POSITION} is (-1, -1) which indicates that {Wx::SashWindows} should generate a default position for the window. If using the {Wx::SashWindow} class directly, supply an actual position.
+    #   @param size [Array(Integer, Integer), Wx::Size]  Window size. {Wx::DEFAULT_SIZE} is (-1, -1) which indicates that {Wx::SashWindows} should generate a default size for the window.
+    #   @param style [Integer]  Window style. For window styles, please see {Wx::SashWindow}.
+    #   @param name [String]  Window name.
+    #   @return [Wx::SashWindow]
+    # @overload initialize(parent, id, pos=Wx::DEFAULT_POSITION, size=Wx::DEFAULT_SIZE, style=(Wx::CLIP_CHILDREN|wxSW_3D), name=("SASH_WINDOW"), &block)
+    #   Constructs a sash 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.
+    #   @param id [Integer]  Window identifier. If -1, will automatically create an identifier.
+    #   @param pos [Array(Integer, Integer), Wx::Point]  Window position. {Wx::DEFAULT_POSITION} is (-1, -1) which indicates that {Wx::SashWindows} should generate a default position for the window. If using the {Wx::SashWindow} class directly, supply an actual position.
+    #   @param size [Array(Integer, Integer), Wx::Size]  Window size. {Wx::DEFAULT_SIZE} is (-1, -1) which indicates that {Wx::SashWindows} should generate a default size for the window.
+    #   @param style [Integer]  Window style. For window styles, please see {Wx::SashWindow}.
+    #   @param name [String]  Window name.
+    #   @yieldparam [Wx::SashWindow] win new instance
+    #   @return [Wx::SashWindow]
+    def initialize(*args) end
+    
+    # Gets the maximum window size in the x direction.
+    # @return [Integer]
+    def get_maximum_size_x; end
+    alias_method :maximum_size_x, :get_maximum_size_x
+    
+    # Gets the maximum window size in the y direction.
+    # @return [Integer]
+    def get_maximum_size_y; end
+    alias_method :maximum_size_y, :get_maximum_size_y
+    
+    # Gets the minimum window size in the x direction.
+    # @return [Integer]
+    def get_minimum_size_x; end
+    alias_method :minimum_size_x, :get_minimum_size_x
+    
+    # Gets the minimum window size in the y direction.
+    # @return [Integer]
+    def get_minimum_size_y; end
+    alias_method :minimum_size_y, :get_minimum_size_y
+    
+    # Returns true if a sash is visible on the given edge, false otherwise.
+    # 
+    # 
+    # @see Wx::SashWindow#set_sash_visible 
+    # @param edge [Wx::SashEdgePosition]  Edge. One of {Wx::SashEdgePosition::SASH_TOP}, {Wx::SashEdgePosition::SASH_RIGHT}, {Wx::SashEdgePosition::SASH_BOTTOM}, {Wx::SashEdgePosition::SASH_LEFT}.
+    # @return [Boolean]
+    def get_sash_visible(edge) end
+    alias_method :sash_visible, :get_sash_visible
+    
+    # Sets the maximum window size in the x direction.
+    # @param min [Integer] 
+    # @return [void]
+    def set_maximum_size_x(min) end
+    alias_method :maximum_size_x=, :set_maximum_size_x
+    
+    # Sets the maximum window size in the y direction.
+    # @param min [Integer] 
+    # @return [void]
+    def set_maximum_size_y(min) end
+    alias_method :maximum_size_y=, :set_maximum_size_y
+    
+    # Sets the minimum window size in the x direction.
+    # @param min [Integer] 
+    # @return [void]
+    def set_minimum_size_x(min) end
+    alias_method :minimum_size_x=, :set_minimum_size_x
+    
+    # Sets the minimum window size in the y direction.
+    # @param min [Integer] 
+    # @return [void]
+    def set_minimum_size_y(min) end
+    alias_method :minimum_size_y=, :set_minimum_size_y
+    
+    # Call this function to make a sash visible or invisible on a particular edge.
+    # 
+    # 
+    # @see Wx::SashWindow#get_sash_visible 
+    # @param edge [Wx::SashEdgePosition]  Edge to change. One of {Wx::SashEdgePosition::SASH_TOP}, {Wx::SashEdgePosition::SASH_RIGHT}, {Wx::SashEdgePosition::SASH_BOTTOM}, {Wx::SashEdgePosition::SASH_LEFT}.
+    # @param visible [Boolean]  true to make the sash visible, false to make it invisible.
+    # @return [void]
+    def set_sash_visible(edge, visible) end
+    
+    # Get border size.
+    # @param edge [Wx::SashEdgePosition] 
+    # @return [Integer]
+    def get_edge_margin(edge) end
+    alias_method :edge_margin, :get_edge_margin
+    
+    # Sets the default sash border size.
+    # @param width [Integer] 
+    # @return [void]
+    def set_default_border_size(width) end
+    alias_method :default_border_size=, :set_default_border_size
+    
+    # Gets the default sash border size.
+    # @return [Integer]
+    def get_default_border_size; end
+    alias_method :default_border_size, :get_default_border_size
+    
+    # Sets the additional border size between child and sash window.
+    # @param width [Integer] 
+    # @return [void]
+    def set_extra_border_size(width) end
+    alias_method :extra_border_size=, :set_extra_border_size
+    
+    # Gets the addition border size between child and sash window.
+    # @return [Integer]
+    def get_extra_border_size; end
+    alias_method :extra_border_size, :get_extra_border_size
+    
+    # Tests for x, y over sash.
+    # @param x [Integer] 
+    # @param y [Integer] 
+    # @param tolerance [Integer] 
+    # @return [Wx::SashEdgePosition]
+    def sash_hit_test(x, y, tolerance=2) end
+    
+    # Resizes subwindows.
+    # @return [void]
+    def size_windows; end
+    
+  end # SashWindow
+  
+
+end

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

@@ -0,0 +1,10 @@
+# :stopdoc:
+# This file is automatically generated by the WXRuby3 documentation 
+# generator. Do not alter this file.
+# :startdoc:
+
+
+module Wx
+
+
+end

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

@@ -0,0 +1,30 @@
+# :stopdoc:
+# This file is automatically generated by the WXRuby3 documentation 
+# generator. Do not alter this file.
+# :startdoc:
+
+
+module Wx
+
+  # Deprecated class for drawing on the screen.
+  # 
+  # Please don't use this class in the new code, as it doesn't work on modern systems any longer and using it is not guaranteed to have any effect at all. Use {Wx::Display} for getting information about the screen and {Wx::Overlay} for temporarily drawing over a window.
+  # A {Wx::ScreenDC} can be used to paint on the screen. This should normally be constructed as a temporary stack object; don't store a {Wx::ScreenDC} object.
+  # When using multiple monitors, {Wx::ScreenDC} corresponds to the entire virtual screen composed of all of them. Notice that coordinates on {Wx::ScreenDC} can be negative in this case, see {Wx::Display#get_geometry} for more.
+  # 
+  # Category:  Device Contexts
+  # @see Wx::DC
+  # @see  Wx::MemoryDC
+  # @see  Wx::PaintDC
+  # @see  Wx::ClientDC
+  # @see  Wx::WindowDC 
+  # 
+  # 
+  # 
+  # @note This class is <b>untracked</b> and should not be derived from nor instances extended!
+  class ScreenDC < DC
+  
+  end # ScreenDC
+  
+
+end

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

@@ -0,0 +1,204 @@
+# :stopdoc:
+# This file is automatically generated by the WXRuby3 documentation 
+# generator. Do not alter this file.
+# :startdoc:
+
+
+module Wx
+
+  # A {Wx::ScrollBar} is a control that represents a horizontal or vertical scrollbar.
+  # 
+  # It is distinct from the two scrollbars that some windows provide automatically, but the two types of scrollbar share the way events are received.
+  # 
+  # <div class="wxrb-remark">
+  # <b>Remark:</b>
+  # <p>A scrollbar has the following main attributes: range, thumb size, page size, and position. The range is the total number of units associated with the view represented by the scrollbar. For a table with 15 columns, the range would be 15. The thumb size is the number of units that are currently visible. For the table example, the window might be sized so that only 5 columns are currently visible, in which case the application would set the thumb size to 5. When the thumb size becomes the same as or greater than the range, the scrollbar will be automatically hidden on most platforms. The page size is the number of units that the scrollbar should scroll by, when 'paging' through the data. This value is normally the same as the thumb size length, because it is natural to assume that the visible window size defines a page. The scrollbar position is the current thumb position. Most applications will find it convenient to provide a function called AdjustScrollbars() which can be called initially, from an OnSize event handler, and whenever the application data changes in size. It will adjust the view, object and page size according to the size of the window and the size of the data.
+  # </p>
+  # </div>
+  # 
+  # ### Styles
+  # 
+  # This class supports the following styles:
+  # 
+  # - {Wx::SB_HORIZONTAL}: Specifies a horizontal scrollbar. 
+  # 
+  # - {Wx::SB_VERTICAL}: Specifies a vertical scrollbar. 
+  # 
+  # ### Events emitted by this class
+  # 
+  # The following event-handler methods redirect the events to member method or handler blocks for {Wx::ScrollEvent} events.
+  # Event handler methods for events emitted by this class: except for this, the macros behave exactly the same. 
+  # 
+  # - {Wx::EvtHandler#evt_scroll}(meth = nil, &block): Process all scroll events. 
+  # 
+  # - {Wx::EvtHandler#evt_scroll_top}(meth = nil, &block): Process {Wx::EVT_SCROLL_TOP} scroll to top or leftmost (minimum) position events. 
+  # 
+  # - {Wx::EvtHandler#evt_scroll_bottom}(meth = nil, &block): Process {Wx::EVT_SCROLL_BOTTOM} scroll to bottom or rightmost (maximum) position events. 
+  # 
+  # - {Wx::EvtHandler#evt_scroll_lineup}(meth = nil, &block): Process {Wx::EVT_SCROLL_LINEUP} line up or left events. 
+  # 
+  # - {Wx::EvtHandler#evt_scroll_linedown}(meth = nil, &block): Process {Wx::EVT_SCROLL_LINEDOWN} line down or right events. 
+  # 
+  # - {Wx::EvtHandler#evt_scroll_pageup}(meth = nil, &block): Process {Wx::EVT_SCROLL_PAGEUP} page up or left events. 
+  # 
+  # - {Wx::EvtHandler#evt_scroll_pagedown}(meth = nil, &block): Process {Wx::EVT_SCROLL_PAGEDOWN} page down or right events. 
+  # 
+  # - {Wx::EvtHandler#evt_scroll_thumbtrack}(meth = nil, &block): Process {Wx::EVT_SCROLL_THUMBTRACK} thumbtrack events (frequent events sent as the user drags the thumbtrack). 
+  # 
+  # - {Wx::EvtHandler#evt_scroll_thumbrelease}(meth = nil, &block): Process {Wx::EVT_SCROLL_THUMBRELEASE} thumb release events. 
+  # 
+  # - {Wx::EvtHandler#evt_scroll_changed}(meth = nil, &block): Process {Wx::EVT_SCROLL_CHANGED} end of scrolling events (MSW only). 
+  # 
+  # - {Wx::EvtHandler#evt_command_scroll}(id, meth = nil, &block): Process all scroll events. 
+  # 
+  # - {Wx::EvtHandler#evt_command_scroll_top}(id, meth = nil, &block): Process {Wx::EVT_SCROLL_TOP} scroll to top or leftmost (minimum) position events. 
+  # 
+  # - {Wx::EvtHandler#evt_command_scroll_bottom}(id, meth = nil, &block): Process {Wx::EVT_SCROLL_BOTTOM} scroll to bottom or rightmost (maximum) position events. 
+  # 
+  # - {Wx::EvtHandler#evt_command_scroll_lineup}(id, meth = nil, &block): Process {Wx::EVT_SCROLL_LINEUP} line up or left events. 
+  # 
+  # - {Wx::EvtHandler#evt_command_scroll_linedown}(id, meth = nil, &block): Process {Wx::EVT_SCROLL_LINEDOWN} line down or right events. 
+  # 
+  # - {Wx::EvtHandler#evt_command_scroll_pageup}(id, meth = nil, &block): Process {Wx::EVT_SCROLL_PAGEUP} page up or left events. 
+  # 
+  # - {Wx::EvtHandler#evt_command_scroll_pagedown}(id, meth = nil, &block): Process {Wx::EVT_SCROLL_PAGEDOWN} page down or right events. 
+  # 
+  # - {Wx::EvtHandler#evt_command_scroll_thumbtrack}(id, meth = nil, &block): Process {Wx::EVT_SCROLL_THUMBTRACK} thumbtrack events (frequent events sent as the user drags the thumbtrack). 
+  # 
+  # - {Wx::EvtHandler#evt_command_scroll_thumbrelease}(meth = nil, &block): Process {Wx::EVT_SCROLL_THUMBRELEASE} thumb release events. 
+  # 
+  # - {Wx::EvtHandler#evt_command_scroll_changed}(meth = nil, &block): Process {Wx::EVT_SCROLL_CHANGED} end of scrolling events (MSW only). 
+  # 
+  # ## The difference between EVT_SCROLL_THUMBRELEASE and EVT_SCROLL_CHANGED
+  # The EVT_SCROLL_THUMBRELEASE event is only emitted when actually dragging the thumb using the mouse and releasing it (This EVT_SCROLL_THUMBRELEASE event is also followed by an EVT_SCROLL_CHANGED event).
+  # The EVT_SCROLL_CHANGED event also occurs when using the keyboard to change the thumb position, and when clicking next to the thumb (In all these cases the EVT_SCROLL_THUMBRELEASE event does not happen).
+  # In short, the EVT_SCROLL_CHANGED event is triggered when scrolling/moving has finished independently of the way it had started. Please see the page_samples_widgets ("Slider" page) to see the difference between EVT_SCROLL_THUMBRELEASE and EVT_SCROLL_CHANGED in action.
+  # 
+  # Category:  {Wx::Controls}  <div class='appearance'><span class='appearance'>Appearance:</span><table><tr><td> WXMSW Appearance
+  #   </td><td> WXGTK Appearance
+  #   </td><td> WXOSX Appearance
+  #   </td></tr></table></div>
+  # @see Scrolled Windows
+  # @see  Events and Event Handling
+  # @see  Wx::Scrolled 
+  # 
+  # 
+  # @wxrb_require USE_SCROLLBAR
+  class ScrollBar < Control
+  
+    # @overload initialize()
+    #   Default constructor.
+    #   @return [Wx::ScrollBar]
+    # @overload initialize(parent, id, pos=Wx::DEFAULT_POSITION, size=Wx::DEFAULT_SIZE, style=Wx::SB_HORIZONTAL, validator=Wx::DEFAULT_VALIDATOR, name=Wx::SCROLL_BAR_NAME_STR)
+    #   Constructor, creating and showing a scrollbar.
+    #   
+    #   
+    #   @see Wx::ScrollBar#create
+    #   @see  Wx::Validator 
+    #   @param parent [Wx::Window]  Parent window. Must be non-null.
+    #   @param id [Integer]  Window identifier. The value {Wx::StandardID::ID_ANY} indicates a default value.
+    #   @param pos [Array(Integer, Integer), Wx::Point]  Window position. If {Wx::DEFAULT_POSITION} is specified then a default position is chosen.
+    #   @param size [Array(Integer, Integer), Wx::Size]  Window size. If {Wx::DEFAULT_SIZE} is specified then a default size is chosen.
+    #   @param style [Integer]  Window style. See {Wx::ScrollBar}.
+    #   @param validator [Wx::Validator]  Window validator.
+    #   @param name [String]  Window name.
+    #   @return [Wx::ScrollBar]
+    # @overload initialize(parent, id, pos=Wx::DEFAULT_POSITION, size=Wx::DEFAULT_SIZE, style=Wx::SB_HORIZONTAL, validator=Wx::DEFAULT_VALIDATOR, name=Wx::SCROLL_BAR_NAME_STR, &block)
+    #   Constructor, creating and showing a scrollbar.
+    #   
+    #   
+    #   @see Wx::ScrollBar#create
+    #   @see  Wx::Validator 
+    #   @param parent [Wx::Window]  Parent window. Must be non-null.
+    #   @param id [Integer]  Window identifier. The value {Wx::StandardID::ID_ANY} indicates a default value.
+    #   @param pos [Array(Integer, Integer), Wx::Point]  Window position. If {Wx::DEFAULT_POSITION} is specified then a default position is chosen.
+    #   @param size [Array(Integer, Integer), Wx::Size]  Window size. If {Wx::DEFAULT_SIZE} is specified then a default size is chosen.
+    #   @param style [Integer]  Window style. See {Wx::ScrollBar}.
+    #   @param validator [Wx::Validator]  Window validator.
+    #   @param name [String]  Window name.
+    #   @yieldparam [Wx::ScrollBar] win new instance
+    #   @return [Wx::ScrollBar]
+    def initialize(*args) end
+    
+    # Scrollbar creation function called by the scrollbar constructor.
+    # 
+    # See {Wx::ScrollBar#initialize} for details.
+    # @param parent [Wx::Window] 
+    # @param id [Integer] 
+    # @param pos [Array(Integer, Integer), Wx::Point] 
+    # @param size [Array(Integer, Integer), Wx::Size] 
+    # @param style [Integer] 
+    # @param validator [Wx::Validator] 
+    # @param name [String] 
+    # @return [Boolean]
+    def create(parent, id, pos=Wx::DEFAULT_POSITION, size=Wx::DEFAULT_SIZE, style=Wx::SB_HORIZONTAL, validator=Wx::DEFAULT_VALIDATOR, name=Wx::SCROLL_BAR_NAME_STR) end
+    
+    # Returns the page size of the scrollbar.
+    # 
+    # This is the number of scroll units that will be scrolled when the user pages up or down. Often it is the same as the thumb size.
+    # @see Wx::ScrollBar#set_scrollbar 
+    # @return [Integer]
+    def get_page_size; end
+    alias_method :page_size, :get_page_size
+    
+    # Returns the length of the scrollbar.
+    # 
+    # 
+    # @see Wx::ScrollBar#set_scrollbar 
+    # @return [Integer]
+    def get_range; end
+    alias_method :range, :get_range
+    
+    # Returns the current position of the scrollbar thumb.
+    # 
+    # 
+    # @see Wx::ScrollBar#set_thumb_position 
+    # @return [Integer]
+    def get_thumb_position; end
+    alias_method :thumb_position, :get_thumb_position
+    
+    # Returns the thumb or 'view' size.
+    # 
+    # 
+    # @see Wx::ScrollBar#set_scrollbar 
+    # @return [Integer]
+    def get_thumb_size; end
+    alias_method :thumb_size, :get_thumb_size
+    
+    # Sets the scrollbar properties.
+    # 
+    # <div class="wxrb-remark">
+    # <b>Remark:</b>
+    # <p>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: 
+    # ```ruby
+    #   scrollbar.set_scrollbar(0, 16, 50, 15)
+    # ```
+    #  The page size is 1 less than the thumb size so that the last line of the previous page will be visible on the next page, to help orient the user. 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 {Wx::ScrollBar#set_scrollbar} call into a function named AdjustScrollbars, which can be called initially and also from a {Wx::SizeEvent} event handler function. 
+    # </p>
+    # </div>
+    # @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.
+    # @param pageSize [Integer]  The size of the page size in scroll units. This is the number of units the scrollbar will scroll when it is paged up or down. Often it is the same as the thumb size.
+    # @param refresh [Boolean]  true to redraw the scrollbar, false otherwise.
+    # @return [void]
+    def set_scrollbar(position, thumbSize, range, pageSize, refresh=true) end
+    
+    # Sets the position of the scrollbar.
+    # 
+    # 
+    # @see Wx::ScrollBar#get_thumb_position 
+    # @param viewStart [Integer]  The position of the scrollbar thumb.
+    # @return [void]
+    def set_thumb_position(viewStart) end
+    alias_method :thumb_position=, :set_thumb_position
+    
+    # Returns true for scrollbars that have the vertical style set.
+    # @return [Boolean]
+    def is_vertical; end
+    alias_method :vertical?, :is_vertical
+    
+  end # ScrollBar
+  
+
+end