wxruby3 0.9.1-x64-mingw-ucrt → 0.9.3-x64-mingw-ucrt

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

@@ -7,8 +7,8 @@
 module Wx
 
   # A grid sizer is a sizer which lays out its children in a two-dimensional table with all table fields having the same size, i.e.
+  # 
   # the width of each field is the width of the widest child, the height of each field is the height of the tallest child.
-  # === 
   # 
   # Category:  Window Layout
   # @see Wx::Sizer
@@ -19,6 +19,7 @@ module Wx
   
     # @overload initialize(cols, vgap, hgap)
     #   {Wx::GridSizer} constructors.
+    #   
     #   Usually only the number of columns in the flex grid sizer needs to be specified using cols argument. The number of rows will be deduced automatically depending on the number of the elements added to the sizer.
     #   If a constructor form with rows parameter is used (and the value of rows argument is not zero, meaning "unspecified") the sizer will check that no more than <code>cols*rows</code> elements are added to it, i.e. that no more than the given number of rows is used. Adding less than maximally allowed number of items is not an error however.
     #   Finally, it is also possible to specify the number of rows and use 0 for cols. In this case, the sizer will use the given fixed number of rows and as many columns as necessary.
@@ -29,6 +30,7 @@ module Wx
     #   @return [Wx::GridSizer]
     # @overload initialize(cols, gap=(Wx::Size.new(0, 0)))
     #   {Wx::GridSizer} constructors.
+    #   
     #   Usually only the number of columns in the flex grid sizer needs to be specified using cols argument. The number of rows will be deduced automatically depending on the number of the elements added to the sizer.
     #   If a constructor form with rows parameter is used (and the value of rows argument is not zero, meaning "unspecified") the sizer will check that no more than <code>cols*rows</code> elements are added to it, i.e. that no more than the given number of rows is used. Adding less than maximally allowed number of items is not an error however.
     #   Finally, it is also possible to specify the number of rows and use 0 for cols. In this case, the sizer will use the given fixed number of rows and as many columns as necessary.
@@ -38,6 +40,7 @@ module Wx
     #   @return [Wx::GridSizer]
     # @overload initialize(rows, cols, vgap, hgap)
     #   {Wx::GridSizer} constructors.
+    #   
     #   Usually only the number of columns in the flex grid sizer needs to be specified using cols argument. The number of rows will be deduced automatically depending on the number of the elements added to the sizer.
     #   If a constructor form with rows parameter is used (and the value of rows argument is not zero, meaning "unspecified") the sizer will check that no more than <code>cols*rows</code> elements are added to it, i.e. that no more than the given number of rows is used. Adding less than maximally allowed number of items is not an error however.
     #   Finally, it is also possible to specify the number of rows and use 0 for cols. In this case, the sizer will use the given fixed number of rows and as many columns as necessary.
@@ -49,6 +52,7 @@ module Wx
     #   @return [Wx::GridSizer]
     # @overload initialize(rows, cols, gap)
     #   {Wx::GridSizer} constructors.
+    #   
     #   Usually only the number of columns in the flex grid sizer needs to be specified using cols argument. The number of rows will be deduced automatically depending on the number of the elements added to the sizer.
     #   If a constructor form with rows parameter is used (and the value of rows argument is not zero, meaning "unspecified") the sizer will check that no more than <code>cols*rows</code> elements are added to it, i.e. that no more than the given number of rows is used. Adding less than maximally allowed number of items is not an error however.
     #   Finally, it is also possible to specify the number of rows and use 0 for cols. In this case, the sizer will use the given fixed number of rows and as many columns as necessary.
@@ -60,24 +64,28 @@ module Wx
     def initialize(*args) end
     
     # Returns the number of columns that has been specified for the sizer.
+    # 
     # Returns zero if the sizer is automatically adjusting the number of columns depending on number of its children. To get the effective number of columns or rows being currently used, see {Wx::GridSizer#get_effective_cols_count}
     # @return [Integer]
     def get_cols; end
     alias_method :cols, :get_cols
     
     # Returns the number of rows that has been specified for the sizer.
+    # 
     # Returns zero if the sizer is automatically adjusting the number of rows depending on number of its children. To get the effective number of columns or rows being currently used, see {Wx::GridSizer#get_effective_rows_count}.
     # @return [Integer]
     def get_rows; end
     alias_method :rows, :get_rows
     
     # Returns the number of columns currently used by the sizer.
+    # 
     # This will depend on the number of children the sizer has if the sizer is automatically adjusting the number of columns/rows.
     # @return [Integer]
     def get_effective_cols_count; end
     alias_method :effective_cols_count, :get_effective_cols_count
     
     # Returns the number of rows currently used by the sizer.
+    # 
     # This will depend on the number of children the sizer has if the sizer is automatically adjusting the number of columns/rows.
     # @return [Integer]
     def get_effective_rows_count; end
@@ -118,11 +126,13 @@ module Wx
     alias_method :v_gap=, :set_v_gap
     
     # This method is abstract and has to be overwritten by any derived class.
+    # 
     # Here, the sizer will do the actual calculation of its children's minimal sizes.
     # @return [Wx::Size]
     def calc_min; end
     
     # Method which must be overridden in the derived sizer classes.
+    # 
     # The implementation should reposition the children using the current total size available to the sizer (m_size) and the size computed by the last call to {Wx::GridSizer#calc_min}.
     # Note that you should never call this method directly, call {Wx::GridSizer#layout} instead if you need to manually update the sizer elements positions. This method is only called by wxWidgets itself.
     # @param minSize [Array(Integer, Integer), Wx::Size] 

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

@@ -7,7 +7,6 @@
 module Wx
 
   # A generic implementation of the GUI event loop.
-  # === 
   # 
   # Category:  Application and Process Management
   # 
@@ -19,12 +18,14 @@ module Wx
     def initialize; end
     
     # Start the event loop, return the exit code when it is finished.
-    # Logically, this method calls {Wx::GUIEventLoop#dispatch} in a loop until it returns false and also takes care of generating idle events during each loop iteration. However not all implementations of this class really implement it like this (e.g. wxGTK does not) so you shouldn't rely on {Wx::GUIEventLoop#dispatch} being called from inside this function.
+    # 
+    # Logically, this method calls {Wx::GUIEventLoop#dispatch} in a loop until it returns false and also takes care of generating idle events during each loop iteration. However not all implementations of this class really implement it like this (e.g. WXGTK does not) so you shouldn't rely on {Wx::GUIEventLoop#dispatch} being called from inside this function.
     # The argument passed to {Wx::GUIEventLoop#exit} which terminated this event loop.
     # @return [Integer]
     def run; end
     
     # Return true if this event loop is currently running.
+    # 
     # Notice that even if this event loop hasn't terminated yet but has just spawned a nested (e.g. modal) event loop, this method would return false.
     # @return [Boolean]
     def is_running; end
@@ -36,6 +37,7 @@ module Wx
     alias_method :ok?, :is_ok
     
     # Exit the currently running loop with the given exit code.
+    # 
     # The loop will exit, i.e. its {Wx::GUIEventLoop#run} method will return, during the next event loop iteration.
     # Notice that this method can only be used if this event loop is the currently running one, i.e. its {Wx::GUIEventLoop#is_running} returns true. If this is not the case, an assert failure is triggered and nothing is done as outer event loops can't be exited from immediately. Use {Wx::GUIEventLoop#schedule_exit} if you'd like to exit this loop even if it doesn't run currently.
     # @param rc [Integer] 
@@ -43,6 +45,7 @@ module Wx
     def exit(rc=0) end
     
     # Schedule an exit from the loop with the given exit code.
+    # 
     # This method is similar to {Wx::GUIEventLoop#exit} but can be called even if this event loop is not the currently running one  and if it is the active loop, then it works in exactly the same way as {Wx::GUIEventLoop#exit}.
     # The loop will exit as soon as the control flow returns to it, i.e. after any nested loops terminate.
     # @param rc [Integer] 
@@ -50,11 +53,13 @@ module Wx
     def schedule_exit(rc=0) end
     
     # Return true if any events are available.
+    # 
     # If this method returns true, calling {Wx::GUIEventLoop#dispatch} will not block.
     # @return [Boolean]
     def pending; end
     
     # Dispatches the next event in the windowing system event queue.
+    # 
     # Blocks until an event appears if there are none currently (use {Wx::GUIEventLoop#pending} if this is not wanted).
     # This can be used for programming event loops, e.g.
     # 
@@ -70,6 +75,7 @@ module Wx
     def dispatch; end
     
     # Dispatch an event but not wait longer than the specified timeout for it.
+    # 
     # If an event is received before the specified timeout expires, it is processed and the function returns 1 normally or 0 if the event loop should quite. Otherwise, i.e. if the timeout expires, the functions returns -1 without processing any events.
     # 
     # 1 if an event was processed, 0 if the event loop should quit or -1 if the timeout expired.
@@ -86,6 +92,7 @@ module Wx
     def wake_up_idle; end
     
     # This virtual function is called when the application becomes idle and normally just sends {Wx::IdleEvent} to all interested parties.
+    # 
     # It should return true if more idle events are needed, false if not.
     # @return [Boolean]
     def process_idle; end
@@ -96,6 +103,7 @@ module Wx
     alias_method :yielding?, :is_yielding
     
     # Yields control to pending messages in the windowing system.
+    # 
     # This can be useful, for example, when a time-consuming process writes to a text window. Without an occasional yield, the text window will not be updated properly, and on systems with cooperative multitasking, other processes will not respond.
     # Caution should be exercised, however, since yielding may allow the user to perform actions which are not compatible with the current task. Disabling menu items or whole menus during processing can avoid unwanted reentrance of code: see {Wx::SafeYield} for a better function.
     # Note that {Wx::GUIEventLoop#yield} will not flush the message logs. This is intentional as calling {Wx::GUIEventLoop#yield} is usually done to quickly update the screen and popping up a message box dialog may be undesirable. If you do wish to flush the log messages immediately (otherwise it will be done during the next idle loop iteration), call {Wx::Log.flush_active}.
@@ -105,15 +113,17 @@ module Wx
     def yield(onlyIfNeeded=false) end
     
     # Works like {Wx::GUIEventLoop#yield} with onlyIfNeeded == true, except that it allows the caller to specify a mask of the {Wx::EventCategory} values which indicates which events should be processed and which should instead be "delayed" (i.e.
+    # 
     # processed by the main loop later).
     # Note that this is a safer alternative to {Wx::GUIEventLoop#yield} since it ensures that only the events you're interested to will be processed; i.e. this method helps to avoid unwanted reentrancies.
-    # Note that currently only wxMSW and wxGTK do support selective yield of native events coming from the underlying GUI toolkit. wxWidgets events posted using {Wx::EvtHandler#add_pending_event} or {Wx::EvtHandler#queue_event} are instead selectively processed by all ports.
+    # Note that currently only WXMSW and WXGTK do support selective yield of native events coming from the underlying GUI toolkit. wxWidgets events posted using {Wx::EvtHandler#add_pending_event} or {Wx::EvtHandler#queue_event} are instead selectively processed by all ports.
     # @see Wx::Event#get_event_category 
     # @param eventsToProcess [Integer] 
     # @return [Boolean]
     def yield_for(eventsToProcess) end
     
     # Returns true if the given event category is allowed inside a {Wx::GUIEventLoop#yield_for} call (i.e.
+    # 
     # compares the given category against the last mask passed to {Wx::GUIEventLoop#yield_for}).
     # @see Wx::Event#get_event_category 
     # @param cat [Wx::EventCategory]