wxruby3 0.9.0.pre.beta.1-x64-mingw-ucrt-3.2

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

@@ -0,0 +1,220 @@
+# :stopdoc:
+# This file is automatically generated by the WXRuby3 documentation 
+# generator. Do not alter this file.
+# :startdoc:
+
+
+module Wx
+
+  # 
+  NB_DEFAULT = 0
+  
+  # 
+  NB_TOP = 16
+  
+  # 
+  NB_BOTTOM = 32
+  
+  # 
+  NB_LEFT = 64
+  
+  # 
+  NB_RIGHT = 128
+  
+  # 
+  NB_FIXEDWIDTH = 256
+  
+  # 
+  NB_MULTILINE = 512
+  
+  # 
+  NB_NOPAGETHEME = 1024
+  
+  # 
+  # 
+  NB_HITTEST_NOWHERE = 1
+  
+  # 
+  # 
+  NB_HITTEST_ONICON = 2
+  
+  # 
+  # 
+  NB_HITTEST_ONLABEL = 4
+  
+  # 
+  # 
+  NB_HITTEST_ONITEM = 16
+  
+  # 
+  # 
+  NB_HITTEST_ONPAGE = 8
+  
+  # 
+  # 
+  EVT_NOTEBOOK_PAGE_CHANGED = 10133
+  
+  # 
+  # 
+  EVT_NOTEBOOK_PAGE_CHANGING = 10134
+  
+  # This class represents a notebook control, which manages multiple windows with associated tabs.
+  # To use the class, create a {Wx::Notebook} object and call {Wx::Notebook::AddPage} or {Wx::Notebook#insert_page}, passing a window to be used as the page. Do not explicitly delete the window for a page that is currently managed by {Wx::Notebook}.
+  # <b>{Wx::NotebookPage}</b> is a typedef for {Wx::Window}.
+  # === Styles
+  # 
+  # This class supports the following styles:
+  #  
+  # - {Wx::NB_TOP}: Place tabs on the top side. 
+  # - {Wx::NB_LEFT}: Place tabs on the left side. 
+  # - {Wx::NB_RIGHT}: Place tabs on the right side. 
+  # - {Wx::NB_BOTTOM}: Place tabs under instead of above the notebook pages. 
+  # - {Wx::NB_FIXEDWIDTH}: (Windows only) All tabs will have same width. 
+  # - {Wx::NB_MULTILINE}: (Windows only) There can be several rows of tabs. 
+  # - {Wx::NB_NOPAGETHEME}: (Windows only) Display a solid colour on notebook pages, and not a gradient, which can reduce performance. 
+  # 
+  # The styles {Wx::NB_LEFT}, RIGHT and BOTTOM are not supported under Microsoft Windows when using visual themes.
+  # === Events emitted by this class
+  # 
+  # The following event-handler methods redirect the events to member method or handler blocks for {Wx::BookCtrlEvent} events.
+  # Event handler methods for events emitted by this class:
+  # - {Wx::EvtHandler#evt_notebook_page_changed}(id, meth = nil, &block): The page selection was changed. Processes a {Wx::EVT_NOTEBOOK_PAGE_CHANGED} event. 
+  # - {Wx::EvtHandler#evt_notebook_page_changing}(id, meth = nil, &block): The page selection is about to be changed. Processes a {Wx::EVT_NOTEBOOK_PAGE_CHANGING} event. This event can be vetoed. 
+  # 
+  # == Page backgrounds
+  # 
+  # On Windows, the default theme paints a background on the notebook's pages. If you wish to suppress this theme, for aesthetic or performance reasons, there are three ways of doing it. You can use {Wx::NB_NOPAGETHEME} to disable themed drawing for a particular notebook, you can call {Wx::SystemOptions.set_option} to disable it for the whole application, or you can disable it for individual pages by using {Wx::Notebook#set_background_colour}.
+  # To disable themed pages globally: 
+  # 
+  #   wxSystemOptions::SetOption("msw.notebook.themed-background", 0);
+  # 
+  # Set the value to 1 to enable it again. To give a single page a solid background that more or less fits in with the overall theme, use: 
+  # 
+  #   wxColour col = notebook->GetThemeBackgroundColour();
+  #   if (col.IsOk())
+  #   {
+  #       page->SetBackgroundColour(col);
+  #   }
+  # 
+  # On platforms other than Windows, or if the application is not using Windows themes, {Wx::Notebook#get_theme_background_colour} will return an uninitialised colour object, and the above code will therefore work on all platforms.
+  # === 
+  # 
+  # Category:  Book Controls  <div class='appearance'><span class='appearance'>Appearance:</span><table><tr><td> {Wx::MSW} Appearance
+  #   </td><td> {Wx::GTK} Appearance
+  #   </td><td> {Wx::OSX} Appearance
+  #   </td></tr></table></div>
+  # @see Wx::BookCtrl
+  # @see  Wx::BookCtrlEvent
+  # @see  Wx::ImageList
+  # @see  Notebook Sample 
+  # 
+  # 
+  class Notebook < BookCtrlBase
+  
+    # @overload initialize()
+    #   Constructs a notebook control.
+    #   @return [Notebook]
+    # @overload initialize(parent, id, pos=Wx::DEFAULT_POSITION, size=Wx::DEFAULT_SIZE, style=0, name=Wx::NOTEBOOK_NAME_STR)
+    #   Constructs a notebook control.
+    #   Note that sometimes you can reduce flicker by passing the {Wx::CLIP_CHILDREN} window style.
+    #   @param parent [Wx::Window]  The parent window. Must be non-NULL.
+    #   @param id [Integer]  The window identifier.
+    #   @param pos [Array(Integer, Integer), Wx::Point]  The window position.
+    #   @param size [Array(Integer, Integer), Wx::Size]  The window size.
+    #   @param style [Integer]  The window style. See {Wx::Notebook}.
+    #   @param name [String]  The name of the control.
+    #   @return [Notebook]
+    def initialize(*args) end
+    
+    # Creates a notebook control.
+    # See {Wx::Notebook#notebook} for a description of the parameters.
+    # @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 name [String] 
+    # @return [true,false]
+    def create(parent, id, pos=Wx::DEFAULT_POSITION, size=Wx::DEFAULT_SIZE, style=0, name=Wx::NOTEBOOK_NAME_STR) end
+    
+    # Returns the number of rows in the notebook control.
+    # @return [Integer]
+    def get_row_count; end
+    alias_method :row_count, :get_row_count
+    
+    # If running under Windows and themes are enabled for the application, this function returns a suitable colour for painting the background of a notebook page, and can be passed to {Wx::Notebook#set_background_colour}.
+    # Otherwise, an uninitialised colour will be returned.
+    # @return [Wx::Colour]
+    def get_theme_background_colour; end
+    alias_method :theme_background_colour, :get_theme_background_colour
+    
+    # Sets the amount of space around each page's icon and label, in pixels.
+    # The vertical padding cannot be changed in {Wx::GTK}.
+    # @param padding [Array(Integer, Integer), Wx::Size] 
+    # @return [void]
+    def set_padding(padding) end
+    alias_method :padding=, :set_padding
+    
+    # Returns the image index for the given page.
+    # @param nPage [Integer] 
+    # @return [Integer]
+    def get_page_image(nPage) end
+    alias_method :page_image, :get_page_image
+    
+    # Sets the image index for the given page.
+    # image is an index into the image list which was set with {Wx::Notebook#set_image_list}.
+    # @param page [Integer] 
+    # @param image [Integer] 
+    # @return [true,false]
+    def set_page_image(page, image) end
+    
+    # Returns the string for the given page.
+    # @param nPage [Integer] 
+    # @return [String]
+    def get_page_text(nPage) end
+    alias_method :page_text, :get_page_text
+    
+    # Sets the text for the given page.
+    # @param page [Integer] 
+    # @param text [String] 
+    # @return [true,false]
+    def set_page_text(page, text) end
+    
+    # Returns the currently selected page, or {Wx::NOT_FOUND} if none was selected.
+    # Note that this method may return either the previously or newly selected page when called from the EVT_BOOKCTRL_PAGE_CHANGED handler depending on the platform and so {Wx::BookCtrlEvent#get_selection} should be used instead in this case.
+    # @return [Integer]
+    def get_selection; end
+    alias_method :selection, :get_selection
+    
+    # Sets the selection to the given page, returning the previous selection.
+    # Notice that the call to this function generates the page changing events, use the {Wx::Notebook#change_selection} function if you don't want these events to be generated.
+    # @see Wx::Notebook#get_selection 
+    # @param page [Integer] 
+    # @return [Integer]
+    def set_selection(page) end
+    alias_method :selection=, :set_selection
+    
+    # Changes the selection to the given page, returning the previous selection.
+    # This function behaves as {Wx::Notebook#set_selection} but does not generate the page changing events.
+    # See User Generated Events vs Programmatically Generated Events for more information.
+    # @param page [Integer] 
+    # @return [Integer]
+    def change_selection(page) end
+    
+    # Inserts a new page at the specified position.
+    # true if successful, false otherwise.
+    # 
+    # Do not delete the page, it will be deleted by the book control.
+    # @see Wx::Notebook#add_page 
+    # @param index [Integer]  Specifies the position for the new page.
+    # @param page [Wx::Window]  Specifies the new page.
+    # @param text [String]  Specifies the text for the new page.
+    # @param select [true,false]  Specifies whether the page should be selected.
+    # @param imageId [Integer]  Specifies the optional image index for the new page.
+    # @return [true,false]
+    def insert_page(index, page, text, select=false, imageId=Wx::NO_IMAGE) end
+    
+  end # Notebook
+  
+
+end

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

@@ -0,0 +1,75 @@
+# :stopdoc:
+# This file is automatically generated by the WXRuby3 documentation 
+# generator. Do not alter this file.
+# :startdoc:
+
+
+module Wx
+
+  # Shows a dialog asking the user for numeric input.
+  # The dialogs title is set to caption, it contains a (possibly) multiline message above the single line prompt and the zone for entering the number.
+  # The number entered must be in the range min to max (both of which should be positive) and value is the initial value of it. If the user enters an invalid value, it is forced to fall into the specified range. If the user cancels the dialog, the function returns -1. If it is important to distinguish between cancelling the dialog and actually entering -1 in it, i.e. if -1 is a valid input value, this convenience function can't be used and {Wx::NumberEntryDialog} should be used directly instead.
+  # Dialog is centered on its parent unless an explicit position is given in pos.
+  # Include file: #include <wx/numdlg.h>
+  # @see Wx::NumberEntryDialog 
+  # @param message [String] 
+  # @param prompt [String] 
+  # @param caption [String] 
+  # @param value [Integer] 
+  # @param min [Integer] 
+  # @param max [Integer] 
+  # @param parent [Wx::Window] 
+  # @param pos [Array(Integer, Integer), Wx::Point] 
+  # @return [Integer]
+  def self.get_number_from_user(message, prompt, caption, value, min=0, max=100, parent=nil, pos=Wx::DEFAULT_POSITION) end
+  
+  # This class represents a dialog that requests a numeric input from the user.
+  # Currently it is implemented as a generic wxWidgets dialog under all platforms.
+  # You can use a convenience {get_number_from_user} function instead of using this dialog.
+  # === 
+  # 
+  # Category:  Common Dialogs
+  # @see wxNumberEntryDialog Overview 
+  # 
+  # 
+  class NumberEntryDialog < Dialog
+  
+    # @overload initialize()
+    #   Default constructor.
+    #   Call {Wx::NumberEntryDialog#create} to really create the dialog later.
+    #   @return [NumberEntryDialog]
+    # @overload initialize(parent, message, prompt, caption, value, min, max, pos=Wx::DEFAULT_POSITION)
+    #   Constructor.
+    #   Use {Wx::NumberEntryDialog#show_modal} to show the dialog.
+    #   See {Wx::NumberEntryDialog#create} method for parameter description.
+    #   @param parent [Wx::Window] 
+    #   @param message [String] 
+    #   @param prompt [String] 
+    #   @param caption [String] 
+    #   @param value [Integer] 
+    #   @param min [Integer] 
+    #   @param max [Integer] 
+    #   @param pos [Array(Integer, Integer), Wx::Point] 
+    #   @return [NumberEntryDialog]
+    def initialize(*args) end
+    
+    # @param parent [Wx::Window]  Parent window.
+    # @param message [String]  Message to show on the dialog.
+    # @param prompt [String]  The prompt of the dialog.
+    # @param caption [String]  The caption of the dialog.
+    # @param value [Integer]  The default value.
+    # @param min [Integer]  The minimal value.
+    # @param max [Integer]  The maximal value.
+    # @param pos [Array(Integer, Integer), Wx::Point]  Dialog position.
+    # @return [true,false]
+    def create(parent, message, prompt, caption, value, min, max, pos=Wx::DEFAULT_POSITION) end
+    
+    # Returns the value that the user has entered if the user has pressed OK, or the original value if the user has pressed Cancel.
+    # @return [Integer]
+    def get_value; end
+    alias_method :value, :get_value
+    
+  end # NumberEntryDialog
+  
+
+end

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

@@ -0,0 +1,69 @@
+# :stopdoc:
+# This file is automatically generated by the WXRuby3 documentation 
+# generator. Do not alter this file.
+# :startdoc:
+
+
+module Wx
+
+  # Creates and returns an object of the given class, if the class has been registered with the dynamic class system using DECLARE... and IMPLEMENT... macros.
+  # Include file: #include <wx/object.h>
+  # @param className [String] 
+  # @return [Wx::Object]
+  def self.create_dynamic_object(className) end
+  
+  # This is the root class of many of the wxWidgets classes.
+  # It declares a virtual destructor which ensures that destructors get called for all derived class objects where necessary.
+  # {Wx::Object} is the hub of a dynamic object creation scheme, enabling a program to create instances of a class only knowing its string class name, and to query the class hierarchy.
+  # The class contains optional debugging versions of <b>new</b> and <b>delete</b>, which can help trace memory allocation and deallocation problems.
+  # {Wx::Object} can be used to implement reference counted objects, such as {Wx::Pen}, {Wx::Bitmap} and others (see this list). See {Wx::RefCounter} and Reference Counting for more info about reference counting.
+  # === 
+  # 
+  # Category:  Runtime Type Information (RTTI)
+  # @see Wx::ClassInfo
+  # @see  Wx::Debugging
+  # @see  Reference Counting
+  # @see  wxObjectDataRef
+  # @see  Wx::ObjectDataPtr<T> 
+  # 
+  # 
+  class Object < ::Object
+  
+    # @overload initialize()
+    #   Default ctor; initializes to NULL the internal reference data.
+    #   @return [Object]
+    # @overload initialize(other)
+    #   Copy ctor.
+    #   Sets the internal {Wx::Object::m_refData} pointer to point to the same instance of the {Wx::ObjectRefData}-derived class pointed by other and increments the refcount of {Wx::Object::m_refData}.
+    #   @param other [Wx::Object] 
+    #   @return [Object]
+    def initialize(*args) end
+    
+    # Returns true if this object has the same data pointer as obj.
+    # Notice that true is returned if the data pointers are NULL in both objects.
+    # This function only does a shallow comparison, i.e. it doesn't compare the objects pointed to by the data pointers of these objects.
+    # @see Reference Counting 
+    # @param obj [Wx::Object] 
+    # @return [true,false]
+    def is_same_as(obj) end
+    alias_method :same_as?, :is_same_as
+    
+    # Sets the {Wx::Object::m_refData} pointer.
+    # 
+    # @see Wx::Object#ref
+    # @see  Wx::Object#un_ref
+    # @see  Wx::Object#get_ref_data
+    # @see  Wx::ObjectRefData 
+    # @param data [Wx::ObjectRefData] 
+    # @return [void]
+    def set_ref_data(data) end
+    alias_method :ref_data=, :set_ref_data
+    
+    # This is the same of {Wx::Object#alloc_exclusive} but this method is public.
+    # @return [void]
+    def un_share; end
+    
+  end # Object
+  
+
+end

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

@@ -0,0 +1,34 @@
+# :stopdoc:
+# This file is automatically generated by the WXRuby3 documentation 
+# generator. Do not alter this file.
+# :startdoc:
+
+
+module Wx
+
+  # A {Wx::PaintDC} must be constructed if an application wishes to paint on the client area of a window from within an EVT_PAINT() event handler.
+  # This should normally be constructed as a temporary stack object; don't store a {Wx::PaintDC} object. If you have an EVT_PAINT() handler, you must create a {Wx::PaintDC} object within it even if you don't actually use it.
+  # Using {Wx::PaintDC} within your EVT_PAINT() handler is important because it automatically sets the clipping area to the damaged area of the window. Attempts to draw outside this area do not appear.
+  # A {Wx::PaintDC} object is initialized to use the same font and colours as the window it is associated with.
+  # === 
+  # 
+  # Category:  Device Contexts
+  # @see Wx::DC
+  # @see  Wx::ClientDC
+  # @see  Wx::MemoryDC
+  # @see  Wx::WindowDC
+  # @see  Wx::ScreenDC 
+  # 
+  # 
+  class PaintDC < ClientDC
+  
+    # Constructor.
+    # Pass a pointer to the window on which you wish to paint.
+    # @param window [Wx::Window] 
+    # @return [PaintDC]
+    def initialize(window) end
+    
+  end # PaintDC
+  
+
+end

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

@@ -0,0 +1,90 @@
+# :stopdoc:
+# This file is automatically generated by the WXRuby3 documentation 
+# generator. Do not alter this file.
+# :startdoc:
+
+
+module Wx
+
+  # An empty palette.
+  # 
+  NULL_PALETTE = nil
+  
+  # A palette is a table that maps pixel values to RGB colours.
+  # It allows the colours of a low-depth bitmap, for example, to be mapped to the available colours in a display. The notion of palettes is becoming more and more obsolete nowadays and only the MSW port is still using a native palette. All other ports use generic code which is basically just an array of colours.
+  # It is likely that in the future the only use for palettes within wxWidgets will be for representing colour indices from images (such as GIF or PNG). The image handlers for these formats have been modified to create a palette if there is such information in the original image file (usually 256 or less colour images). See {Wx::Image} for more information.
+  # === 
+  # 
+  # Category:  Graphics Device Interface (GDI)
+  # Predefined objects/pointers: {Wx::NULL_PALETTE}
+  # @see Wx::DC#set_palette
+  # @see  Wx::Bitmap 
+  # 
+  # 
+  class Palette < GDIObject
+  
+    # @overload initialize()
+    #   Default constructor.
+    #   @return [Palette]
+    # @overload initialize(palette)
+    #   Copy constructor, uses Reference Counting.
+    #   @param palette [Wx::Palette]  A reference to the palette to copy.
+    #   @return [Palette]
+    # @overload initialize(n, red, green, blue)
+    #   Creates a palette from arrays of size n, one for each red, blue or green component.
+    #   <b>{Wx::Perl} Note:</b> In {Wx::Perl} this method takes as parameters 3 array references (they must be of the same length).
+    #   @see Wx::Palette#create 
+    #   @param n [Integer]  The number of indices in the palette.
+    #   @param red [unsigned char]  An array of red values.
+    #   @param green [unsigned char]  An array of green values.
+    #   @param blue [unsigned char]  An array of blue values.
+    #   @return [Palette]
+    def initialize(*args) end
+    
+    # Creates a palette from arrays of size n, one for each red, blue or green component.
+    # true if the creation was successful, false otherwise.
+    # @see Wx::Palette#palette 
+    # @param n [Integer]  The number of indices in the palette.
+    # @param red [unsigned char]  An array of red values.
+    # @param green [unsigned char]  An array of green values.
+    # @param blue [unsigned char]  An array of blue values.
+    # @return [true,false]
+    def create(n, red, green, blue) end
+    
+    # Returns number of entries in palette.
+    # @return [Integer]
+    def get_colours_count; end
+    alias_method :colours_count, :get_colours_count
+    
+    # Returns a pixel value (index into the palette) for the given RGB values.
+    # The nearest palette index or {Wx::NOT_FOUND} for unexpected errors.
+    # @see Wx::Palette#get_rgb 
+    # @param red [Integer]  Red value.
+    # @param green [Integer]  Green value.
+    # @param blue [Integer]  Blue value.
+    # @return [Integer]
+    def get_pixel(red, green, blue) end
+    alias_method :pixel, :get_pixel
+    
+    # Returns RGB values for a given palette index.
+    # true if the operation was successful.
+    # 
+    # <b>{Wx::Perl} Note:</b> In {Wx::Perl} this method takes only the pixel parameter and returns a 3-element list (or the empty list upon failure).
+    # @see Wx::Palette#get_pixel 
+    # @param pixel [Integer]  The palette index.
+    # @param red [unsigned char]  Receives the red value.
+    # @param green [unsigned char]  Receives the green value.
+    # @param blue [unsigned char]  Receives the blue value.
+    # @return [true,false]
+    def get_rgb(pixel, red, green, blue) end
+    alias_method :rgb, :get_rgb
+    
+    # Returns true if palette data is present.
+    # @return [true,false]
+    def is_ok; end
+    alias_method :ok?, :is_ok
+    
+  end # Palette
+  
+
+end

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

@@ -0,0 +1,96 @@
+# :stopdoc:
+# This file is automatically generated by the WXRuby3 documentation 
+# generator. Do not alter this file.
+# :startdoc:
+
+
+module Wx
+
+  # A panel is a window on which controls are placed.
+  # It is usually placed within a frame. Its main feature over its parent class {Wx::Window} is code for handling child windows and TAB traversal, which is implemented natively if possible (e.g. in {Wx::GTK}) or by wxWidgets itself otherwise.
+  # Tab traversal is implemented through an otherwise undocumented intermediate {Wx::ControlContainer} class from which any class can derive in addition to the normal {Wx::Window} base class. Please see <code>Wx::/containr.h</code> and <code>Wx::/panel.h</code> to find out how this is achieved.
+  # 
+  # if not all characters are being intercepted by your OnKeyDown or OnChar handler, it may be because you are using the {Wx::TAB_TRAVERSAL} style, which grabs some keypresses for use by child controls.
+  # 
+  # By default, a panel has the same colouring as a dialog.
+  # 
+  # === Events emitted by this class
+  # 
+  # The following event-handler methods redirect the events to member method or handler blocks for {Wx::NavigationKeyEvent} events.
+  # Event handler methods for events emitted by this class:
+  # - {Wx::EvtHandler#evt_navigation_key}(meth = nil, &block): Process a navigation key event. 
+  # 
+  # === 
+  # 
+  # Category:  Miscellaneous Windows
+  # @see Wx::Dialog 
+  # 
+  # 
+  class Panel < Window
+  
+    # @overload initialize()
+    #   Default constructor.
+    #   @return [Panel]
+    # @overload initialize(parent, id=Wx::ID_ANY, pos=Wx::DEFAULT_POSITION, size=Wx::DEFAULT_SIZE, style=Wx::TAB_TRAVERSAL, name=Wx::PANEL_NAME_STR)
+    #   Constructor.
+    #   
+    #   @see Wx::Panel#create 
+    #   @param parent [Wx::Window]  The parent window.
+    #   @param id [Integer]  An identifier for the panel. {Wx::StandardID::ID_ANY} is taken to mean a default.
+    #   @param pos [Array(Integer, Integer), Wx::Point]  The panel position. The value {Wx::DEFAULT_POSITION} indicates a default position, chosen by either the windowing system or wxWidgets, depending on platform.
+    #   @param size [Array(Integer, Integer), Wx::Size]  The panel size. The value {Wx::DEFAULT_SIZE} indicates a default size, chosen by either the windowing system or wxWidgets, depending on platform.
+    #   @param style [Integer]  The window style. See {Wx::Panel}.
+    #   @param name [String]  Window name.
+    #   @return [Panel]
+    def initialize(*args) end
+    
+    # This method is overridden from {Wx::Window#accepts_focus} and returns true only if there is no child window in the panel which can accept the focus.
+    # This is reevaluated each time a child window is added or removed from the panel.
+    # @return [true,false]
+    def accepts_focus; end
+    
+    # Used for two-step panel construction.
+    # See {Wx::Panel#panel} 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 name [String] 
+    # @return [true,false]
+    def create(parent, id=Wx::ID_ANY, pos=Wx::DEFAULT_POSITION, size=Wx::DEFAULT_SIZE, style=Wx::TAB_TRAVERSAL, name=Wx::PANEL_NAME_STR) end
+    
+    # Sends a {Wx::InitDialogEvent}, which in turn transfers data to the dialog via validators.
+    # 
+    # @see Wx::InitDialogEvent 
+    # @return [void]
+    def init_dialog; end
+    
+    # See {Wx::Window#set_auto_layout}: when auto layout is on, this function gets called automatically when the window is resized.
+    # @return [true,false]
+    def layout; end
+    
+    # The default handler for {Wx::EVT_SYS_COLOUR_CHANGED}.
+    # Changes the panel's colour to conform to the current settings. Add an event table entry for your panel class if you wish the behaviour to be different (such as keeping a user-defined background colour). If you do override this function, call {Wx::Event#skip} to propagate the notification to child windows and controls.
+    # @see Wx::SysColourChangedEvent 
+    # @param event [Wx::SysColourChangedEvent]  The colour change event.
+    # @return [void]
+    def on_sys_colour_changed(event) end
+    
+    # Overrides {Wx::Window#set_focus}.
+    # This method uses the (undocumented) mix-in class {Wx::ControlContainer} which manages the focus and TAB logic for controls which usually have child controls.
+    # In practice, if you call this method and the control has at least one child window, the focus will be given to the child window.
+    # @see Wx::FocusEvent
+    # @see  Wx::Window#set_focus 
+    # @return [void]
+    def set_focus; end
+    
+    # In contrast to {Wx::Panel#set_focus} (see above) this will set the focus to the panel even if there are child windows in the panel.
+    # This is only rarely needed.
+    # @return [void]
+    def set_focus_ignoring_children; end
+    
+  end # Panel
+  
+
+end