wxruby3 0.9.0.pre.beta.8-x64-mingw-ucrt

data/lib/wx/doc/gen/rbn/ribbon_button_bar_event.rb

@@ -0,0 +1,58 @@
+# :stopdoc:
+# This file is automatically generated by the WXRuby3 documentation 
+# generator. Do not alter this file.
+# :startdoc:
+
+
+module Wx::RBN
+
+  # Event used to indicate various actions relating to a button on a {Wx::RBN::RibbonButtonBar}.
+  # For toggle buttons, {Wx::RBN::RibbonButtonBarEvent#is_checked} can be used to test the state of the button.
+  # See {Wx::RBN::RibbonButtonBar} for available event types.
+  # === 
+  # 
+  # Category:  {Wx::Events}, Ribbon User Interface
+  # @see Wx::RBN::RibbonBar 
+  # 
+  # 
+  class RibbonButtonBarEvent < CommandEvent
+  
+    # Constructor.
+    # @param command_type [Integer] 
+    # @param win_id [Integer] 
+    # @param bar [Wx::RibbonButtonBar] 
+    # @param button [Integer] 
+    # @return [RibbonButtonBarEvent]
+    def initialize(command_type=Wx::EVT_NULL, win_id=0, bar=nil, button=nil) end
+    
+    # Returns the bar which contains the button which the event relates to.
+    # @return [Wx::RibbonButtonBar]
+    def get_bar; end
+    alias_method :bar, :get_bar
+    
+    # Sets the button bar relating to this event.
+    # @param bar [Wx::RibbonButtonBar] 
+    # @return [void]
+    def set_bar(bar) end
+    alias_method :bar=, :set_bar
+    
+    # Returns the button which the event relates to.
+    # @return [Integer]
+    def get_button; end
+    alias_method :button, :get_button
+    
+    # Sets the button relating to this event.
+    # @param bar [Integer] 
+    # @return [void]
+    def set_button(bar) end
+    alias_method :button=, :set_button
+    
+    # Display a popup menu as a result of this (dropdown clicked) event.
+    # @param menu [Wx::Menu] 
+    # @return [true,false]
+    def popup_menu(menu) end
+    
+  end # RibbonButtonBarEvent
+  
+
+end

data/lib/wx/doc/gen/rbn/ribbon_control.rb

@@ -0,0 +1,116 @@
+# :stopdoc:
+# This file is automatically generated by the WXRuby3 documentation 
+# generator. Do not alter this file.
+# :startdoc:
+
+
+module Wx::RBN
+
+  # {Wx::RBN::RibbonControl} serves as a base class for all controls which share the ribbon characteristics of having a ribbon art provider, and (optionally) non-continuous resizing.
+  # Despite what the name may imply, it is not the top-level control for creating a ribbon interface - that is {Wx::RBN::RibbonBar}.
+  # Ribbon controls often have a region which is "transparent", and shows the contents of the ribbon page or panel behind it. If implementing a new ribbon control, then it may be useful to realise that this effect is done by the art provider when painting the background of the control, and hence in the paint handler for the new control, you should call a draw background method on the art provider ({Wx::RBN::RibbonArtProvider#draw_button_bar_background} and {Wx::RBN::RibbonArtProvider#draw_tool_bar_background} typically just redraw what is behind the rectangle being painted) if you want transparent regions.
+  # === 
+  # 
+  # Category:  Ribbon User Interface
+  # 
+  class RibbonControl < Control
+  
+    # @overload initialize()
+    #   Constructor.
+    #   @return [RibbonControl]
+    # @overload initialize(parent, id, pos=Wx::DEFAULT_POSITION, size=Wx::DEFAULT_SIZE, style=0, validator=Wx::DEFAULT_VALIDATOR, name=Wx::CONTROL_NAME_STR)
+    #   Constructor.
+    #   If parent is a {Wx::RBN::RibbonControl} with a non-NULL art provider, then the art provider of new control is set to that of parent.
+    #   @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 [RibbonControl]
+    def initialize(*args) end
+    
+    # Set the art provider to be used.
+    # In many cases, setting the art provider will also set the art provider on all child windows which extend {Wx::RBN::RibbonControl}.
+    # In most cases, controls will not take ownership of the given pointer, with the notable exception being {Wx::RBN::RibbonBar#set_art_provider}.
+    # @param art [Wx::RibbonArtProvider] 
+    # @return [void]
+    def set_art_provider(art) end
+    alias_method :art_provider=, :set_art_provider
+    
+    # Get the art provider to be used.
+    # Note that until an art provider has been set in some way, this function may return NULL.
+    # @return [Wx::RBN::RibbonArtProvider]
+    def get_art_provider; end
+    alias_method :art_provider, :get_art_provider
+    
+    # 
+    # true if this window can take any size (greater than its minimum size), false if it can only take certain sizes.
+    # @see Wx::RBN::RibbonControl#get_next_smaller_size 
+    # 
+    # @see Wx::RBN::RibbonControl#get_next_larger_size 
+    # @return [true,false]
+    def is_sizing_continuous; end
+    alias_method :sizing_continuous?, :is_sizing_continuous
+    
+    # @overload get_next_smaller_size(direction)
+    #   If sizing is not continuous, then return a suitable size for the control which is smaller than the current size.
+    #   The current size if there is no smaller size, otherwise a suitable size which is smaller in the given direction(s), and the same as the current size in the other direction (if any).
+    #   @see Wx::RBN::RibbonControl#is_sizing_continuous 
+    #   @param direction [Orientation]  The direction(s) in which the size should reduce.
+    #   @return [Wx::Size]
+    # @overload get_next_smaller_size(direction, relative_to)
+    #   If sizing is not continuous, then return a suitable size for the control which is smaller than the given size.
+    #   relative_to if there is no smaller size, otherwise a suitable size which is smaller in the given direction(s), and the same as relative_to in the other direction (if any).
+    #   @see Wx::RBN::RibbonControl#is_sizing_continuous 
+    #   
+    #   @see Wx::RBN::RibbonControl#do_get_next_smaller_size 
+    #   @param direction [Orientation]  The direction(s) in which the size should reduce.
+    #   @param relative_to [Wx::Size]  The size for which a smaller size should be found.
+    #   @return [Wx::Size]
+    def get_next_smaller_size(*args) end
+    alias_method :next_smaller_size, :get_next_smaller_size
+    
+    # @overload get_next_larger_size(direction)
+    #   If sizing is not continuous, then return a suitable size for the control which is larger than the current size.
+    #   The current size if there is no larger size, otherwise a suitable size which is larger in the given direction(s), and the same as the current size in the other direction (if any).
+    #   @see Wx::RBN::RibbonControl#is_sizing_continuous 
+    #   @param direction [Orientation]  The direction(s) in which the size should increase.
+    #   @return [Wx::Size]
+    # @overload get_next_larger_size(direction, relative_to)
+    #   If sizing is not continuous, then return a suitable size for the control which is larger than the given size.
+    #   relative_to if there is no larger size, otherwise a suitable size which is larger in the given direction(s), and the same as relative_to in the other direction (if any).
+    #   @see Wx::RBN::RibbonControl#is_sizing_continuous 
+    #   
+    #   @see Wx::RBN::RibbonControl#do_get_next_larger_size 
+    #   @param direction [Orientation]  The direction(s) in which the size should increase.
+    #   @param relative_to [Wx::Size]  The size for which a larger size should be found.
+    #   @return [Wx::Size]
+    def get_next_larger_size(*args) end
+    alias_method :next_larger_size, :get_next_larger_size
+    
+    # Perform initial size and layout calculations after children have been added, and/or realize children.
+    # @return [true,false]
+    def realize; end
+    
+    # Alias for {Wx::RBN::RibbonControl#realize}.
+    # @return [true,false]
+    def realise; end
+    
+    # Get the first ancestor which is a {Wx::RBN::RibbonBar} (or derived) or NULL if not having such parent.
+    # @return [Wx::RibbonBar]
+    def get_ancestor_ribbon_bar; end
+    alias_method :ancestor_ribbon_bar, :get_ancestor_ribbon_bar
+    
+    # Finds the best width and height given the parent's width and height.
+    # Used to implement the {Wx::RBN::RibbonPanelOption::RIBBON_PANEL_FLEXIBLE} panel style.
+    # @param parentSize [Array(Integer, Integer), Wx::Size] 
+    # @return [Wx::Size]
+    def get_best_size_for_parent_size(parentSize) end
+    alias_method :best_size_for_parent_size, :get_best_size_for_parent_size
+    
+  end # RibbonControl
+  
+
+end

data/lib/wx/doc/gen/rbn/ribbon_gallery.rb

@@ -0,0 +1,208 @@
+# :stopdoc:
+# This file is automatically generated by the WXRuby3 documentation 
+# generator. Do not alter this file.
+# :startdoc:
+
+
+module Wx::RBN
+
+  # 
+  # 
+  # 
+  # 
+  class RibbonGalleryButtonState < Wx::Enum
+  
+    # 
+    # 
+    RIBBON_GALLERY_BUTTON_NORMAL = Wx::RBN::RibbonGalleryButtonState.new(0)
+    
+    # 
+    # 
+    RIBBON_GALLERY_BUTTON_HOVERED = Wx::RBN::RibbonGalleryButtonState.new(1)
+    
+    # 
+    # 
+    RIBBON_GALLERY_BUTTON_ACTIVE = Wx::RBN::RibbonGalleryButtonState.new(2)
+    
+    # 
+    # 
+    RIBBON_GALLERY_BUTTON_DISABLED = Wx::RBN::RibbonGalleryButtonState.new(3)
+    
+  end # RibbonGalleryButtonState
+  
+  # 
+  # 
+  EVT_RIBBONGALLERY_HOVER_CHANGED = 10437
+  
+  # 
+  # 
+  EVT_RIBBONGALLERY_SELECTED = 10438
+  
+  # 
+  # 
+  EVT_RIBBONGALLERY_CLICKED = 10439
+  
+  # A ribbon gallery is like a {Wx::ListBox}, but for bitmaps rather than strings.
+  # It displays a collection of bitmaps arranged in a grid and allows the user to choose one. As there are typically more bitmaps in a gallery than can be displayed in the space used for a ribbon, a gallery always has scroll buttons to allow the user to navigate through the entire gallery. It also has an "extension" button, the behaviour of which is outside the scope of the gallery control itself, though it typically displays some kind of dialog related to the gallery.
+  # === Events emitted by this class
+  # 
+  # The following event-handler methods redirect the events to member method or handler blocks for {Wx::RBN::RibbonGalleryEvent} events.
+  # Event handler methods for events emitted by this class:
+  # - {Wx::EvtHandler#evt_ribbongallery_selected}(id, meth = nil, &block): Triggered when the user selects an item from the gallery. Note that the ID is that of the gallery, not of the item. 
+  # - {Wx::EvtHandler#evt_ribbongallery_clicked}(id, meth = nil, &block): Similar to EVT_RIBBONGALLERY_SELECTED but triggered every time a gallery item is clicked, even if it is already selected. Note that the ID of the event is that of the gallery, not of the item, just as above. This event is available since wxWidgets 2.9.2. 
+  # - {Wx::EvtHandler#evt_ribbongallery_hover_changed}(id, meth = nil, &block): Triggered when the item being hovered over by the user changes. The item in the event will be the new item being hovered, or NULL if there is no longer an item being hovered. Note that the ID is that of the gallery, not of the item. 
+  # 
+  # === Events emitted by this class
+  # 
+  # The following event-handler methods redirect the events to member method or handler blocks for {Wx::CommandEvent} events.
+  # Event handler methods for events emitted by this class:
+  # - {Wx::EvtHandler#evt_button}(id, meth = nil, &block): Triggered when the "extension" button of the gallery is pressed. 
+  # 
+  # === 
+  # 
+  # Category:  Ribbon User Interface
+  # 
+  class RibbonGallery < RibbonControl
+  
+    # @overload initialize()
+    #   Default constructor.
+    #   With this constructor, {Wx::RBN::RibbonGallery#create} should be called in order to create the gallery.
+    #   @return [RibbonGallery]
+    # @overload initialize(parent, id=Wx::ID_ANY, pos=Wx::DEFAULT_POSITION, size=Wx::DEFAULT_SIZE, style=0)
+    #   Construct a ribbon gallery with the given parameters.
+    #   @param parent [Wx::Window]  Parent window for the gallery (typically a {Wx::RBN::RibbonPanel}).
+    #   @param id [Integer]  An identifier for the gallery. {Wx::StandardID::ID_ANY} is taken to mean a default.
+    #   @param pos [Array(Integer, Integer), Wx::Point]  Initial position of the gallery.
+    #   @param size [Array(Integer, Integer), Wx::Size]  Initial size of the gallery.
+    #   @param style [Integer]  Gallery style, currently unused.
+    #   @return [RibbonGallery]
+    def initialize(*args) end
+    
+    # Create a gallery in two-step gallery construction.
+    # Should only be called when the default constructor is used, and arguments have the same meaning as in the full constructor.
+    # @param parent [Wx::Window] 
+    # @param id [Integer] 
+    # @param pos [Array(Integer, Integer), Wx::Point] 
+    # @param size [Array(Integer, Integer), Wx::Size] 
+    # @param style [Integer] 
+    # @return [true,false]
+    def create(parent, id=Wx::ID_ANY, pos=Wx::DEFAULT_POSITION, size=Wx::DEFAULT_SIZE, style=0) end
+    
+    # Remove all items from the gallery.
+    # @return [void]
+    def clear; end
+    
+    # Query if the gallery has no items in it.
+    # @return [true,false]
+    def is_empty; end
+    alias_method :empty?, :is_empty
+    
+    # Get the number of items in the gallery.
+    # @return [Integer]
+    def get_count; end
+    alias_method :count, :get_count
+    
+    # Get an item by index.
+    # @param n [Integer] 
+    # @return [Integer]
+    def get_item(n) end
+    alias_method :item, :get_item
+    
+    # @overload append(bitmap, id)
+    #   Add an item to the gallery (with no client data).
+    #   @param bitmap [Wx::Bitmap]  The bitmap to display for the item. Note that all items must have equally sized bitmaps.
+    #   @param id [Integer]  ID number to associate with the item. Not currently used for anything important.
+    #   @return [Integer]
+    # @overload append(bitmap, id, clientData)
+    #   Add an item to the gallery (with simple client data).
+    #   @param bitmap [Wx::Bitmap]  The bitmap to display for the item. Note that all items must have equally sized bitmaps.
+    #   @param id [Integer]  ID number to associate with the item. Not currently used for anything important.
+    #   @param clientData [Object]  An opaque pointer to associate with the item.
+    #   @return [Integer]
+    # @overload append(bitmap, id, clientData)
+    #   Add an item to the gallery (with complex client data)
+    #   @param bitmap [Wx::Bitmap]  The bitmap to display for the item. Note that all items must have equally sized bitmaps.
+    #   @param id [Integer]  ID number to associate with the item. Not currently used for anything important.
+    #   @param clientData [Wx::ClientData]  An object which contains data to associate with the item. The item takes ownership of this pointer, and will delete it when the item client data is changed to something else, or when the item is destroyed.
+    #   @return [Integer]
+    def append(*args) end
+    
+    # Set the client data associated with a gallery item.
+    # @param item [Integer] 
+    # @param data [Object] 
+    # @return [void]
+    def set_item_client_data(item, data) end
+    
+    # Get the client data associated with a gallery item.
+    # @param item [Integer] 
+    # @return [Object]
+    def get_item_client_data(item) end
+    alias_method :item_client_data, :get_item_client_data
+    
+    # Set the selection to the given item, or removes the selection if item == NULL.
+    # Note that this not cause any events to be emitted.
+    # @param item [Integer] 
+    # @return [void]
+    def set_selection(item) end
+    alias_method :selection=, :set_selection
+    
+    # Get the currently selected item, or NULL if there is none.
+    # The selected item is set by {Wx::RBN::RibbonGallery#set_selection}, or by the user clicking on an item.
+    # @return [Integer]
+    def get_selection; end
+    alias_method :selection, :get_selection
+    
+    # Get the currently hovered item, or NULL if there is none.
+    # The hovered item is the item underneath the mouse cursor.
+    # @return [Integer]
+    def get_hovered_item; end
+    alias_method :hovered_item, :get_hovered_item
+    
+    # Get the currently active item, or NULL if there is none.
+    # The active item is the item being pressed by the user, and will thus become the selected item if the user releases the mouse button.
+    # @return [Integer]
+    def get_active_item; end
+    alias_method :active_item, :get_active_item
+    
+    # Get the state of the scroll up button.
+    # @return [RibbonGalleryButtonState]
+    def get_up_button_state; end
+    alias_method :up_button_state, :get_up_button_state
+    
+    # Get the state of the scroll down button.
+    # @return [RibbonGalleryButtonState]
+    def get_down_button_state; end
+    alias_method :down_button_state, :get_down_button_state
+    
+    # Get the state of the "extension" button.
+    # @return [RibbonGalleryButtonState]
+    def get_extension_button_state; end
+    alias_method :extension_button_state, :get_extension_button_state
+    
+    # Query is the mouse is currently hovered over the gallery.
+    # true if the cursor is within the bounds of the gallery (not just hovering over an item), false otherwise.
+    # @return [true,false]
+    def is_hovered; end
+    alias_method :hovered?, :is_hovered
+    
+    # Scroll the gallery contents by some amount.
+    # true if the gallery scrolled at least one pixel in the given direction, false if it did not scroll.
+    # @param lines [Integer]  Positive values scroll toward the end of the gallery, while negative values scroll toward the start.
+    # @return [true,false]
+    def scroll_lines(lines) end
+    
+    # Scroll the gallery contents by some fine-grained amount.
+    # true if the gallery scrolled at least one pixel in the given direction, false if it did not scroll.
+    # @param pixels [Integer]  Positive values scroll toward the end of the gallery, while negative values scroll toward the start.
+    # @return [true,false]
+    def scroll_pixels(pixels) end
+    
+    # Scroll the gallery to ensure that the given item is visible.
+    # @param item [Integer] 
+    # @return [void]
+    def ensure_visible(item) end
+    
+  end # RibbonGallery
+  
+
+end

data/lib/wx/doc/gen/rbn/ribbon_gallery_event.rb

@@ -0,0 +1,51 @@
+# :stopdoc:
+# This file is automatically generated by the WXRuby3 documentation 
+# generator. Do not alter this file.
+# :startdoc:
+
+
+module Wx::RBN
+
+  # 
+  # === 
+  # 
+  # Category:  {Wx::Events}, Ribbon User Interface
+  # @see Wx::RBN::RibbonBar 
+  # 
+  # 
+  class RibbonGalleryEvent < CommandEvent
+  
+    # Constructor.
+    # @param command_type [Integer] 
+    # @param win_id [Integer] 
+    # @param gallery [Wx::RibbonGallery] 
+    # @param item [Integer] 
+    # @return [RibbonGalleryEvent]
+    def initialize(command_type=Wx::EVT_NULL, win_id=0, gallery=nil, item=nil) end
+    
+    # Returns the gallery which the event relates to.
+    # @return [Wx::RibbonGallery]
+    def get_gallery; end
+    alias_method :gallery, :get_gallery
+    
+    # Returns the gallery item which the event relates to, or NULL if it does not relate to an item.
+    # @return [Integer]
+    def get_gallery_item; end
+    alias_method :gallery_item, :get_gallery_item
+    
+    # Sets the gallery relating to this event.
+    # @param gallery [Wx::RibbonGallery] 
+    # @return [void]
+    def set_gallery(gallery) end
+    alias_method :gallery=, :set_gallery
+    
+    # Sets the gallery item relating to this event.
+    # @param item [Integer] 
+    # @return [void]
+    def set_gallery_item(item) end
+    alias_method :gallery_item=, :set_gallery_item
+    
+  end # RibbonGalleryEvent
+  
+
+end

data/lib/wx/doc/gen/rbn/ribbon_page.rb

@@ -0,0 +1,129 @@
+# :stopdoc:
+# This file is automatically generated by the WXRuby3 documentation 
+# generator. Do not alter this file.
+# :startdoc:
+
+
+module Wx::RBN
+
+  # Container for related ribbon panels, and a tab within a ribbon bar.
+  # === 
+  # 
+  # Category:  Ribbon User Interface
+  # @see Wx::RBN::RibbonBar 
+  # 
+  # @see Wx::RBN::RibbonPanel
+  # 
+  # 
+  class RibbonPage < RibbonControl
+  
+    # @overload initialize()
+    #   Default constructor.
+    #   With this constructor, {Wx::RBN::RibbonPage#create} should be called in order to create the ribbon page.
+    #   @return [RibbonPage]
+    # @overload initialize(parent, id=Wx::ID_ANY, label=Wx::EMPTY_STRING, icon=Wx::NULL_BITMAP, style=0)
+    #   Constructs a ribbon page, which must be a child of a ribbon bar.
+    #   @param parent [Wx::RibbonBar]  Pointer to a parent {Wx::RBN::RibbonBar} (unlike most controls, a {Wx::RBN::RibbonPage} can only have {Wx::RBN::RibbonBar} as a parent).
+    #   @param id [Integer]  Window identifier.
+    #   @param label [String]  Label to be used in the {Wx::RBN::RibbonBar}'s tab list for this page (if the ribbon bar is set to display labels).
+    #   @param icon [Wx::Bitmap]  Icon to be used in the {Wx::RBN::RibbonBar}'s tab list for this page (if the ribbon bar is set to display icons).
+    #   @param style [Integer]  Currently unused, should be zero.
+    #   @return [RibbonPage]
+    def initialize(*args) end
+    
+    # Create a ribbon page in two-step ribbon page construction.
+    # Should only be called when the default constructor is used, and arguments have the same meaning as in the full constructor.
+    # @param parent [Wx::RibbonBar] 
+    # @param id [Integer] 
+    # @param label [String] 
+    # @param icon [Wx::Bitmap] 
+    # @param style [Integer] 
+    # @return [true,false]
+    def create(parent, id=Wx::ID_ANY, label=Wx::EMPTY_STRING, icon=Wx::NULL_BITMAP, style=0) end
+    
+    # Set the art provider to be used.
+    # Normally called automatically by {Wx::RBN::RibbonBar} when the page is created, or the art provider changed on the bar.
+    # The new art provider will be propagated to the children of the page.
+    # @param art [Wx::RibbonArtProvider] 
+    # @return [void]
+    def set_art_provider(art) end
+    alias_method :art_provider=, :set_art_provider
+    
+    # Get the icon used for the page in the ribbon bar tab area (only displayed if the ribbon bar is actually showing icons).
+    # @return [Wx::Bitmap]
+    def get_icon; end
+    alias_method :icon, :get_icon
+    
+    # Set the size of the page and the external scroll buttons (if any).
+    # When a page is too small to display all of its children, scroll buttons will appear (and if the page is sized up enough, they will disappear again). Slightly counter-intuitively, these buttons are created as siblings of the page rather than children of the page (to achieve correct cropping and paint ordering of the children and the buttons). When there are no scroll buttons, this function behaves the same as {Wx::RBN::RibbonPage#set_size}, however when there are scroll buttons, it positions them at the edges of the given area, and then calls {Wx::RBN::RibbonPage#set_size} with the remaining area.
+    # This is provided as a separate function to {Wx::RBN::RibbonPage#set_size} rather than within the implementation of {Wx::RBN::RibbonPage#set_size}, as interacting algorithms may not expect {Wx::RBN::RibbonPage#set_size} to also set the size of siblings.
+    # @param x [Integer] 
+    # @param y [Integer] 
+    # @param width [Integer] 
+    # @param height [Integer] 
+    # @return [void]
+    def set_size_with_scroll_button_adjustment(x, y, width, height) end
+    
+    # Expand a rectangle of the page to include external scroll buttons (if any).
+    # When no scroll buttons are shown, has no effect.
+    # @param rect [Wx::Rect]  The rectangle to adjust. The width and height will not be reduced, and the x and y will not be increased.
+    # @return [void]
+    def adjust_rect_to_include_scroll_buttons(rect) end
+    
+    # Dismiss the current externally expanded panel, if there is one.
+    # When a ribbon panel automatically minimises, it can be externally expanded into a floating window. When the user clicks a button in such a panel, the panel should generally re-minimise. Event handlers for buttons on ribbon panels should call this method to achieve this behaviour.
+    # true if a panel was minimised, false otherwise.
+    # @return [true,false]
+    def dismiss_expanded_panel; end
+    
+    # Perform a full re-layout of all panels on the page.
+    # Should be called after panels are added to the page, or the sizing behaviour of a panel on the page changes (i.e. due to children being added to it). Usually called automatically when {Wx::RBN::RibbonBar#realize} is called.
+    # Will invoke {Wx::RBN::RibbonPanel#realize} for all child panels.
+    # @return [true,false]
+    def realize; end
+    
+    # Scroll the page by some amount up / down / left / right.
+    # When the page's children are too big to fit in the onscreen area given to the page, scroll buttons will appear, and the page can be programmatically scrolled. Positive values of lines will scroll right or down, while negative values will scroll up or left (depending on the direction in which panels are stacked). A line is equivalent to a constant number of pixels.
+    # true if the page scrolled at least one pixel in the given direction, false if it did not scroll.
+    # @see Wx::RBN::RibbonPage#get_major_axis 
+    # 
+    # @see Wx::RBN::RibbonPage#scroll_pixels 
+    # 
+    # @see Wx::RBN::RibbonPage#scroll_sections 
+    # @param lines [Integer] 
+    # @return [true,false]
+    def scroll_lines(lines) end
+    
+    # Scroll the page by a set number of pixels up / down / left / right.
+    # When the page's children are too big to fit in the onscreen area given to the page, scroll buttons will appear, and the page can be programmatically scrolled. Positive values of lines will scroll right or down, while negative values will scroll up or left (depending on the direction in which panels are stacked).
+    # true if the page scrolled at least one pixel in the given direction, false if it did not scroll.
+    # @see Wx::RBN::RibbonPage#get_major_axis 
+    # 
+    # @see Wx::RBN::RibbonPage#scroll_lines 
+    # 
+    # @see Wx::RBN::RibbonPage#scroll_sections 
+    # @param pixels [Integer] 
+    # @return [true,false]
+    def scroll_pixels(pixels) end
+    
+    # Scroll the page by an entire child section.
+    # The sections parameter value should be 1 or -1. This will scroll enough to uncover a partially visible child section or totally uncover the next child section that may not be visible at all.
+    # true if the page scrolled at least one pixel in the given direction, false if it did not scroll.
+    # @see Wx::RBN::RibbonPage#scroll_pixels 
+    # 
+    # @see Wx::RBN::RibbonPage#scroll_sections
+    # @param sections [Integer] 
+    # @return [true,false]
+    def scroll_sections(sections) end
+    
+    # Get the direction in which ribbon panels are stacked within the page.
+    # This is controlled by the style of the containing {Wx::RBN::RibbonBar}, meaning that all pages within a bar will have the same major axis. As well as being the direction in which panels are stacked, it is also the axis in which scrolling will occur (when required).
+    # {Wx::Orientation::HORIZONTAL} or {Wx::Orientation::VERTICAL} (never {Wx::Orientation::BOTH}).
+    # @return [Orientation]
+    def get_major_axis; end
+    alias_method :major_axis, :get_major_axis
+    
+  end # RibbonPage
+  
+
+end