wxruby3 0.9.0.pre.rc.2 → 0.9.0

data/rakelib/lib/generate/doc/pg_property.yaml

@@ -0,0 +1,188 @@
+---
+:wxPGProperty.OnCustomPaint.paintdata:
+  :brief:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: ''
+:wxPGProperty.DoGetValidator:
+  :detail:
+    :pre:
+      :detaileddescription:
+        - :pattern: !ruby/regexp /SetPropertyValidator/
+          :subst: '#set_property_validator'
+        - :pattern: !ruby/regexp /In.*most.*situations,.*first.*macro\)\:/
+          :subst: 'In most situations, code like this should work well:'
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+            
+            ```ruby
+              class MyPropertyClass < Wx::PG::IntProperty
+            
+            
+                class << self
+                  def validator
+                    @validator ||= MyValidator.new(...)
+                  end
+                end
+            
+                # ...
+            
+                def do_get_validator
+                  MyPropertyClass.validator
+                end
+            
+                # ...
+            
+              end
+            ```
+:wxPGProperty.ChildChanged:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+            
+            ```ruby
+              class MyProperty < Wx::PG::FlagsProperty
+            
+                def child_changed(thisValue, childIndex, childValue)
+                  # Acquire reference to actual type of data stored in variant
+                  flags = thisValue.object;
+                  case childIndex
+                    when 0
+                      flags.sub_prop1 = childValue.to_i
+                    when 1
+                      flags.sub_prop2 = childValue.to_s
+                    # ...
+                  end
+                  # return altered data
+                  Wx::Variant.new(flags)
+                end
+            
+              end
+            ```
+:wxPGProperty.ChangeFlag:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+            
+            ```ruby
+              enable(false)
+            ```
+:wxPGProperty.SetDefaultValue:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+            
+            ```ruby
+              set_attribute('DefaultValue', value)
+            ```
+:wxPGProperty.wxPGProperty:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+            
+            ```ruby
+              class WxPointProperty < Wx::PG::PGProperty
+            
+                def initialize(label = Wx::PG::PG_LABEL, name = Wx::PG::PG_LABEL, value = Wx::Point.new)
+                  super(label, name)
+            
+                  # should work in pretty much 100% of cases
+                  self.value = value
+            
+                  # add private child properties
+                  add_private_child( Wx::PG::IntProperty.new("X", Wx::PG::PG_LABEL,value.x))
+                  add_private_child( Wx::PG::IntProperty.new("Y", Wx::PG::PG_LABEL,value.y))
+                end
+            
+                # ...
+            
+              end
+            ```
+:wxPGProperty:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /class.*wxColourPropertyValue/
+          :replace: ''
+        - :pattern: !ruby/regexp /virtual.*ColourToString/
+          :replace: | 
+            
+            ```ruby
+              # Override in derived class to customize how colours are translated
+              # to strings.
+              def colour_to_string(col, index) end
+            
+              # Returns index of entry that triggers colour picker dialog
+              # (default is last).
+              def get_custom_colour_index; end
+            
+              # Helper function to show the colour dialog
+              def query_colour_from_user(variant) end
+
+              # Returns colour for given choice.
+              # Default function returns Wx::SystemSettings.get_colour(index).
+              def get_colour(index) end
+            ```
+        - :pattern: !ruby/regexp /WX_PG_DECLARE_VARIANT_DATA.*WX_PG_IMPLEMENT_VARIANT_DATA_DUMMY_EQ/m
+          :replace: ''
+        - :pattern: !ruby/regexp /class.*MyProperty.*:.*public.*wxPGProperty/
+          :replace: | 
+            
+            ``` ruby
+              class MyProperty < Wx::PG::PGProperty
+              
+                  # All arguments of this ctor must have a default value -
+                  # use Wx::PG::PG_LABEL for label and name
+                  def initialize(label = Wx::PG::PG_LABEL, name = Wx::PG::PG_LABEL, value = '')
+                    super(label, name)
+                    # self.value is Wx::Variant
+                    self.value = value
+                  end
+              
+                  def do_get_editor_class
+                    # Determines editor used by property.
+                    # You can replace 'TEXT_CTRL' below with any of these
+                    # builtin-in property editor identifiers: CHOICE, COMBO_BOX,
+                    # TEXT_CTRL_AND_BUTTON, CHOICE_AND_BUTTON, CHECK_BOX, SPIN_CTRL,
+                    # DATE_PICKER_CTRL.
+                    return Wx::PG::PG_EDITOR_TEXT_CTRL
+                  end
+              
+                  def value_to_string(value, argFlags)
+                    # TODO: Convert given property value to a string
+                  end
+              
+                  def string_to_value(variant, text, argFlags)
+                    # TODO: Adapt string to property value.
+                  end
+              
+              protected
+                  # ...
+              end
+            ```
+    :post:
+      - :pattern: !ruby/regexp /==\swxIntProperty.*==\swxUIntProperty/m
+        :subst: |
+          
+          == wxIntProperty
+          
+          It derives from {Wx::PG::NumericProperty} and displays value as a signed long integer.
+          Supported special attributes:
+           
+          - {Wx::PG::PG_ATTR_MIN}, {Wx::PG::PG_ATTR_MAX} to specify acceptable value range.
+          - {Wx::PG::PG_ATTR_SPINCTRL_STEP}, {Wx::PG::PG_ATTR_SPINCTRL_WRAP}, {Wx::PG::PG_ATTR_SPINCTRL_MOTION}: Sets SpinCtrl editor parameters. 
+          
+          == wxUIntProperty
+
+      - :pattern: !ruby/regexp /Since\s\{Wx::PG::PGProperty\}\sderives.*For\sinstance:/m
+        :subst: ''

data/rakelib/lib/generate/doc/picker_base.yaml

@@ -0,0 +1,19 @@
+---
+:wxPickerBase.GetPickerCtrl:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+            
+            ```ruby
+              if Wx::PLATFORM == 'WXMSW'
+                # wxMSW is one of the platforms where the generic implementation
+                # of Wx::FilePickerCtrl is used...
+                
+                butt = myFilePickerCtrl.get_picker_ctrl
+                if butt
+                   butt.set_label("Custom browse string")
+                end
+              end
+            ```

data/rakelib/lib/generate/doc/platform_info.yaml

@@ -0,0 +1,15 @@
+---
+:wxPlatformInfo:
+  :detail:
+    :pre:
+      :para:
+        - :pattern: !ruby/regexp /In\s+general\s+however\s+you\s+only\s+need\s+to\s+use\s+the\s+static.*for\s+the\s+current\s+platform:/
+          :subst: 'In general however you only need to use the static {Wx::PlatformInfo.instance} method and then access the various information for the current platform:'
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+            
+            ```ruby
+              Wx.log_message("This application is running under %s.", 
+                             Wx::PlatformInfo.instance.get_operating_system_id_name)
+            ```

data/rakelib/lib/generate/doc/property_grid.yaml

@@ -0,0 +1,23 @@
+---
+:wxPropertyGrid.AddActionTrigger:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+            
+            ```ruby
+              propGrid.add_action_trigger(Wx::PG::PG_ACTION_NEXT_PROPERTY, Wx::K_RETURN)
+              propGrid.dedicate_key(Wx::K_RETURN)
+            ```
+:wxPropertyGrid.MakeColumnEditable:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+            
+            ```ruby
+              # see Wx::PG::PGProperty#change_flag
+              property.change_flag(Wx::PG::PG_PROP_READONLY, true)
+            ```

data/rakelib/lib/generate/doc/property_grid_interface.yaml

@@ -0,0 +1,30 @@
+---
+:wxPropertyGridInterface.Insert:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+            
+            ```ruby
+              # append category
+              my_cat_id = propertygrid.append(Wx::PG::PropertyCategory.new("My Category"))
+              
+              ...
+              
+              # insert into category - using second overload
+              my_item_id_1 = propertygrid.insert(my_cat_id, 0, Wx::PG::StringProperty.new("My String 1"))
+              
+              # insert before to first item - using first overload
+              my_item_id_2 = propertygrid.insert(my_item_id, Wx::PG::StringProperty.new("My String 2"))
+            ```
+:wxPropertyGridInterface.ReplaceProperty:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+            
+            ```ruby
+              pg.replace_property("Flags", Wx::PG::FlagsProperty.new("Flags", Wx::PG::PG_LABEL, newItems))
+            ```

data/rakelib/lib/generate/doc/property_grid_manager.yaml

@@ -0,0 +1,40 @@
+---
+:wxPropertyGridManager:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+            
+            ```ruby
+              pgMan = Wx::PG::PropertyGridManager.new(self, PGID,
+                  Wx::DEFAULT_POSITION, Wx::DEFAULT_SIZE,
+                  # These and other similar styles are automatically
+                  # passed to the embedded wxPropertyGrid.
+                  Wx::PG::PG_BOLD_MODIFIED|Wx::PG::PG_SPLITTER_AUTO_CENTER|
+                  # Include toolbar.
+                  Wx::PG::PG_TOOLBAR |
+                  # Include description box.
+                  Wx::PG::PG_DESCRIPTION |
+                  # Include compactor.
+                  Wx::PG::PG_COMPACTOR |
+                  # Plus defaults.
+                  wxPGMAN_DEFAULT_STYLE)
+              
+              page = pgMan.add_page("First Page")
+              
+              page.append(Wx::PG::PropertyCategory.new("Category A1"))
+              
+              page.append(Wx::PG::IntProperty.new("Number",Wx::PG::PG_LABEL,1))
+              
+              page.append(Wx::PG::ColourProperty.new("Colour",Wx::PG::PG_LABEL,Wx::WHITE))
+              
+              page = pgMan.add_page("Second Page")
+              
+              page.append(Wx::PG::StringProperty.new("Text", Wx::PG::PG_LABEL, "(no text)"))
+              
+              page.append(Wx::PG::FontProperty.new("Font",Wx::PG::PG_LABEL))
+              
+              # Display a header above the grid
+              pgMan.show_header
+            ```

data/rakelib/lib/generate/doc/property_sheet_dialog.yaml

@@ -0,0 +1,26 @@
+---
+:wxPropertySheetDialog:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+            
+            ```ruby
+              class MyPropertySheetDialog < Wx::PropertySheetDialog
+            
+                def create(...)
+                   return false if !super
+                
+                   create_buttons(Wx::OK|Wx::CANCEL|Wx::HELP)
+                
+                   # Add page
+                   panel = Wx::Panel.new(get_book_ctrl, ...)
+                   get_book_ctrl.add_page(panel, "General")
+                
+                   layout_dialog
+                   true
+                end
+            
+              end
+            ```

data/rakelib/lib/generate/doc/rich_text_html_handler.yaml

@@ -0,0 +1,11 @@
+---
+:wxRichTextHTMLHandler.SetFontSizeMapping:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+            
+            ```ruby
+              html_handler.set_font_size_mapping([7,9,11,12,14,22,100])
+            ```

data/rakelib/lib/generate/doc/scroll_bar.yaml

@@ -0,0 +1,11 @@
+---
+:wxScrollBar.SetScrollbar:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+            
+            ```ruby
+              scrollbar.set_scrollbar(0, 16, 50, 15)
+            ```

data/rakelib/lib/generate/doc/scrolled_canvas.yaml

@@ -0,0 +1,37 @@
+---
+:wxScrolled.DoPrepareDC:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+            
+            ```ruby
+              class MyWindow < Wx::ScrolledCanvas
+            
+                def on_event(event)
+                  Wx::ClientDC.draw_on(self) do |dc|
+                    do_prepare_dc(dc)
+                  
+                    dc.set_pen(Wx::BLACK_PEN)
+                    pos = event.position
+                    if xpos > -1 && ypos > -1 && event.dragging
+                      dc.draw_line(xpos, ypos, pos.x, pos.y)
+                    end
+                    xpos = pos.x
+                    ypos = pos.y
+                  end
+                end
+            
+              end
+            ```
+:wxScrolled.SetScrollbars:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+            
+            ```ruby
+              window.set_scrollbars(20, 20, 50, 50)
+            ```

data/rakelib/lib/generate/doc/scrolled_control.yaml

@@ -0,0 +1,37 @@
+---
+:wxScrolled.DoPrepareDC:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+            
+            ```ruby
+              class MyWindow < Wx::ScrolledControl
+            
+                def on_event(event)
+                  Wx::ClientDC.draw_on(self) do |dc|
+                    do_prepare_dc(dc)
+                  
+                    dc.set_pen(Wx::BLACK_PEN)
+                    pos = event.position
+                    if xpos > -1 && ypos > -1 && event.dragging
+                      dc.draw_line(xpos, ypos, pos.x, pos.y)
+                    end
+                    xpos = pos.x
+                    ypos = pos.y
+                  end
+                end
+            
+              end
+            ```
+:wxScrolled.SetScrollbars:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+            
+            ```ruby
+              window.set_scrollbars(20, 20, 50, 50)
+            ```

data/rakelib/lib/generate/doc/scrolled_window.yaml

@@ -0,0 +1,37 @@
+---
+:wxScrolled.DoPrepareDC:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+            
+            ```ruby
+              class MyWindow < Wx::ScrolledWindow
+            
+                def on_event(event)
+                  Wx::ClientDC.draw_on(self) do |dc|
+                    do_prepare_dc(dc)
+                  
+                    dc.set_pen(Wx::BLACK_PEN)
+                    pos = event.position
+                    if xpos > -1 && ypos > -1 && event.dragging
+                      dc.draw_line(xpos, ypos, pos.x, pos.y)
+                    end
+                    xpos = pos.x
+                    ypos = pos.y
+                  end
+                end
+            
+              end
+            ```
+:wxScrolled.SetScrollbars:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+            
+            ```ruby
+              window.set_scrollbars(20, 20, 50, 50)
+            ```

data/rakelib/lib/generate/doc/sizer.yaml

@@ -0,0 +1,69 @@
+---
+:wxSizer.AddSpacer:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+            
+            ```ruby
+              Wx::Sizer::add(size, size, 0)
+            ```
+:wxSizer.AddStretchSpacer:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+            
+            ```ruby
+              Wx::Sizer::add(0, 0, prop)
+            ```
+:wxSizer.SetSizeHints:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+            
+            ```ruby
+              class MyFrame < Wx::Frame 
+                def initialize(...)
+                  super
+                  panel = Wx::Panel.new(self)
+                  sizer = Wx::BoxSizer.new(Wx::VERTICAL)
+                  sizer.add(...)
+                  sizer.add(...)
+                  panel.set_sizer(sizer)
+              
+                  # Use the panel sizer to set the initial and minimal size of the
+                  # frame to fit its contents.
+                  sizer.set_size_hints(this)
+                end
+            ```
+:wxSizerFlags:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /wxEXPAND/
+          :replace: |
+            
+            ```ruby
+              sizer.add(ctrl, 0, Wx::EXPAND | Wx::ALL, 10)
+            ```
+        - :pattern: !ruby/regexp /wxSizerFlags.*\(\)/
+          :replace: |
+            
+            ```ruby
+              sizer.add(ctrl, Wx::SizerFlags.new.expand.border(Wx::ALL, 10))
+            ```
+        - :pattern: !ruby/regexp /flagsExpand/
+          :replace: |
+            
+            ```ruby
+              flagsExpand = Wx::SizerFlags.new(1)
+              flagsExpand.expand.border(Wx::ALL, 10)
+              
+              sizer.add(ctrl1, flagsExpand)
+              sizer.add(ctrl2, flagsExpand)
+            ```

data/rakelib/lib/generate/doc/splash_screen.yaml

@@ -0,0 +1,18 @@
+---
+:wxSplashScreen:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+            
+            ```ruby
+              bitmap Wx::Bitmap.new 
+              if bitmap.load_file("splash16.png", Wx::BITMAP_TYPE_PNG))
+                 splash = Wx::SplashScreen.new(bitmap,
+                     Wx::SPLASH_CENTRE_ON_SCREEN|Wx::SPLASH_TIMEOUT,
+                     6000, nil, -1, Wx::DEFAULT_POSITION, Wx::DEFAULT_SIZE,
+                     Wx::BORDER_SIMPLE|Wx::STAY_ON_TOP)
+              end
+              Wx.get_app.yield
+            ```

data/rakelib/lib/generate/doc/static_box.yaml

@@ -0,0 +1,52 @@
+---
+:wxStaticBox.wxStaticBox:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+            
+            ```ruby
+              class MyFrame < Wx::Frame
+                
+                def create_controls
+                  panel = Wx::Panel.new(self)
+                  checkbox = Wx::CheckBox.new(panel, Wx::ID_ANY, "Box checkbox")
+                  box = Wx::StaticBox.new(panel, Wx::ID_ANY, checkbox)
+                  ...
+                end
+            
+              end
+            ```
+:wxStaticBox.Enable:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+            
+            ```ruby
+              check = Wx::CheckBox.new(parent, Wx::ID_ANY, "Use the box")
+              box = Wx::StaticBox.new(parent, Wx::ID_ANY, check)
+              check.evt_checkbox { |event| box.enable(event.checked? }
+            ```
+:wxStaticBox:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+            
+            ```ruby
+              class MyFrame < Wx::Frame
+            
+                def create_controls
+                  panel = Wx::Panel.new(self)
+                  box = Wx::StaticBox.new(panel, Wx::ID_ANY, 'StaticBox')
+            
+                  Wx::StaticText.new(box, Wx::ID_ANY, "This window is a child of the staticbox")
+                  ...
+                end
+            
+              end
+            ```

data/rakelib/lib/generate/doc/static_box_sizer.yaml

@@ -0,0 +1,22 @@
+---
+:wxStaticBoxSizer:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+            
+            ```ruby
+              class MyFrame < Wx::Frame
+              
+                def create_controls
+                  panel = Wx::Panel.new(self)
+                  ...
+                  sz = Wx::StaticBoxSizer.new(Wx::VERTICAL, panel, "Box")
+                  sz.add(Wx::StaticText.new(sz.get_static_box, Wx::ID_ANY,
+                                            "This window is a child of the staticbox"))
+                  ...
+                end
+            
+              end
+            ```

data/rakelib/lib/generate/doc/styled_text_ctrl.yaml

@@ -0,0 +1,18 @@
+---
+:wxStyledTextCtrl.GetInsertionPoint:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+            
+            ```ruby
+              def get_current_char(tc)
+                pos = tc.insertion_point
+                if pos == tc.last_position
+                  nil
+                else
+                  tc.get_range(pos, pos + 1)
+                end
+              end
+            ```

data/rakelib/lib/generate/doc/svg_file_dc.yaml

@@ -0,0 +1,11 @@
+---
+:wxSVGFileDC.SetBitmapHandler:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+            
+            ```ruby
+              mySVGFileDC.set_bitmap_handler(Wx::SVGBitmapEmbedHandler.new)
+            ```