wxruby3 0.9.0.pre.rc.2 → 0.9.0

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

@@ -0,0 +1,12 @@
+---
+:wxLocale:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: ''
+        - :pattern: !ruby/regexp /.*/
+          :replace: ''
+      :para:
+        - :pattern: !ruby/regexp /If\s+you\s+need\s+to\s+translate\s+a\s+lot\s+of\s+strings.*/
+          :replace: ''

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

@@ -0,0 +1,86 @@
+---
+:wxLog.SetComponentLevel:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+            
+            ```ruby
+              wxLog.set_component_level("wx/net", Wx::LOG_Error)
+            ```
+:wxLog.LogRecord:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+            
+            ```ruby
+              class Wx::LogChain
+            
+                def do_log_record(level, msg, info)
+                   # let the previous logger show it
+                   if m_logOld && is_passing_messages
+                       m_logOld.log_record(level, msg, info)
+                
+                   # and also send it to the new one
+                   if m_logNew && m_logNew != self
+                       m_logNew.log_record(level, msg, info)
+                end
+            
+              end
+            ```
+:wxLogChain:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+            
+            ```ruby
+              logChain = Wx::LogChain.new(Wx::LogStderr.new)
+              
+              # all the log messages are sent to stderr and also processed as usually
+              ...
+            ```
+:wxLogNull:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /wxFile.Open/
+          :replace: |
+            
+            ```ruby
+              mime_type = ... # retrieved from somewhere
+              img = Wx::Image.new
+              Wx::LogNull.no_log do     # suspend logging 
+            
+                
+                # Wx::Image#load_stream will complain if there is no handler for the given mimetype and fail
+                if !img.load_stream(File.open('file.img'), mime_type)
+                  # handle problem
+                end
+            
+              end # old log sink restored
+              
+              Wx.log_message('...') # ok
+            ```
+        - :pattern: !ruby/regexp /wxFile::Exists/
+          :replace: |
+            
+            ```ruby
+              mime_type = ... # retrieved from somewhere
+            
+              # check the condition that makes your code complain
+              if Wx::Image.mime_types.include?(mime_type)
+                img.load_stream(File.open('file.img'), mime_type)
+                ...
+              else
+                # do something else
+                ...
+              end
+            ```
+      :para:
+        - :pattern: !ruby/regexp /thread-safe/
+          :replace: ''

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

@@ -0,0 +1,12 @@
+---
+:wxMDIParentFrame.OnCreateClient:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+            
+            ```ruby
+              frame = MyParentFrame.new
+              frame.create(parent, myParentFrameId, 'My Parent Frame')
+            ```

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

@@ -0,0 +1,42 @@
+---
+:wxMemoryDC:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /\(test_bitmap\);/
+          :replace: |
+            
+            ```ruby
+              Wx::MemoryDC.draw_on(test_bitmap) do |mem_dc|
+                # We can now draw into the memory DC...
+                
+                # Copy from this DC to another DC.
+                old_dc.blit(250, 50, BITMAP_WIDTH, BITMAP_HEIGHT, mem_dc, 0, 0)
+              end
+            ```
+        - :pattern: !ruby/regexp /wxNullBitmap/
+          :replace: ''
+        - :pattern: !ruby/regexp /MyWindow::OnPaint/
+          :replace: |
+            
+            ```ruby
+              class MyWindow
+            
+                def on_paint(_)
+                  bmp = Wx::Bitmap.new
+                  bmp.create_with_dip_size(get_client_size, get_dpi_scale_factor)
+                  Wx::MemoryDC.draw_on(bmp) do |mem_dc|  
+                    ... use mem_dc to draw on the bitmap ...
+                  end
+                  self.paint do |dc|
+                    dc.draw_bitmap(bmp, Wx::Point.new(0, 0))
+                  end
+                end
+            
+              end
+            ```
+      :para:
+        - :pattern: !ruby/regexp /out of the memory DC:/
+          :subst: 'out of the memory DC. Note that when using the `.draw_on` method this will happen automatically when the block returns.'
+        - :pattern: !ruby/regexp /This\s+happens\s+automatically.*goes\s+out\s+of\s+scope\./
+          :replace: ''

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

@@ -0,0 +1,17 @@
+---
+:wxMenu.Append:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /ID_NEW_FILE/
+          :replace: |
+            
+            ```ruby
+              file_menu.append(ID_NEW_FILE, "&New file\tCTRL+N", "Creates a new XYZ document")
+            ```
+        - :pattern: !ruby/regexp /wxID_NEW/
+          :replace: |
+            
+            ```ruby
+              file_menu.append(Wx::ID_NEW, "", "Creates a new XYZ document")
+            ```

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

@@ -0,0 +1,43 @@
+---
+:wxMenuItem.SetItemLabel:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+            
+            ```ruby
+              @my_menu_item.set_item_label("My &item\tCTRL+I")
+              @my_menu_item2.set_item_label("Clean && build\tF7")
+              @my_menu_item3.set_item_label("Simple item")
+              @my_menu_item4.set_item_label("Item with &accelerator")
+            ```
+:wxMenuItem.wxMenuItem:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+            
+            ```ruby
+              # use all stock properties:
+              helpMenu.append(wxID_ABOUT)
+              
+              # use the stock label and the stock accelerator but not the stock help string:
+              helpMenu.append(Wx::ID_ABOUT, "", "My custom help string")
+              
+              # use all stock properties except for the bitmap:
+              mymenu = Wx::MenuItem.new(helpMenu, Wx::ID_ABOUT)
+              mymenu.set_bitmap(Wx::ArtProvider.get_bitmap(Wx::ART_WARNING))
+              helpMenu.append(mymenu)
+            ```
+:wxMenuItem.GetLabelText:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+            
+            ```ruby
+              Wx::MenuItem.get_label_text("&Hello\tCtrl-h")
+            ```

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

@@ -0,0 +1,36 @@
+---
+:wxMessageDialog.SetYesNoLabels:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /wxID_SAVE/
+          :replace: |
+            
+            ```ruby
+              Wx.MessageDialog(...) do |dlg|
+                dlg.set_yes_no_labels(Wx::ID_SAVE, "&Don't save")
+              end
+            ```
+        - :pattern: !ruby/regexp /Quit/
+          :replace: |
+            
+            ```ruby
+              Wx.MessageDialog(...) do |dlg|
+                if dlg.set_yes_no_labels("&Quit, "&Don't quit")
+                  dlg.set_message('What do you want to do?')
+                else # buttons have standard "Yes"/"No" values, so rephrase the question
+                  dlg.set_message('Do you really want to quit?')
+              end
+            ```
+:wxMessageBox:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+            
+            ```ruby
+              answer = Wx.message_box("Quit program?", "Confirm",
+                                       Wx::YES_NO | Wx::CANCEL, main_frame)
+              main_frame.close if answer == Wx::YES
+            ```

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

@@ -0,0 +1,14 @@
+---
+:wxNonOwnedWindow.SetShape:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+            
+            ```ruby
+              size = get_size
+              path = Wx::GraphicsRenderer.get_default_renderer.create_path
+              path.add_circle(size.x/2, size.y/2, 30)
+              set_shape(path)
+            ```

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

@@ -0,0 +1,18 @@
+---
+:wxNotebook:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /wxSystemOptions/
+          :replace: |
+            
+            ```ruby
+              Wx::SystemOptions.set_option("msw.notebook.themed-background", 0)
+            ```
+        - :pattern: !ruby/regexp /GetThemeBackgroundColour/
+          :replace: |
+            
+            ```ruby
+              col = notebook.get_theme_background_colour
+              page.set_background_colour(col) if col.ok?
+            ```

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

@@ -0,0 +1,11 @@
+---
+:wxPenInfo:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+            
+            ```ruby
+              pen = Wx::Pen.new(Wx::PenInfo.new(Wx::BLUE).style(Wx::PENSTYLE_DOT).join(Wx::JOIN_BEVEL))  
+            ```

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

@@ -0,0 +1,11 @@
+---
+:wxPGEditor:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+            
+            ```
+              editor = Wx::PG::PropertyGrid.register_editor_class(MyEditorClass.new)
+            ```

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

@@ -0,0 +1,78 @@
+---
+:wxPGMultiButton:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /public.*wxPGTextCtrlEditor/
+          :replace: |
+            
+            ```ruby
+              class WxSampleMultiButtonEditor < Wx::PG::PGTextCtrlEditor
+            
+                def initialize
+                  super
+                end
+            
+                def create_controls(propGrid, property, pos, sz)
+                  # Create and populate buttons-subwindow
+                  buttons = Wx::PG::PGMultiButton.new(propGrid, sz)
+              
+                  # Add two regular buttons
+                  buttons.add('...')
+                  buttons.add('A')
+                  # Add a bitmap button
+                  buttons.add(Wx::ArtProvider::get_bitmap(Wx::ART_FOLDER))
+              
+                  # Create the 'primary' editor control (textctrl in this case)
+                  primary, _ = super(propGrid, property, pos, buttons.primary_size)
+              
+                  # Finally, move buttons-subwindow to correct position and make sure
+                  # returned Wx::PG::PGWindowList contains our custom button list.
+                  buttons.finalize(propGrid, pos)
+              
+                  [primary, buttons]
+                end
+            
+                def on_event(propGrid, property, ctrl, event)
+                  if event.event_type == Wx::EVT_BUTTON
+                    buttons = propGrid.get_editor_control_secondary
+                
+                    if event.id == buttons.button_id(0)
+                
+                      # Do something when the first button is pressed
+                      Wx::log_info('First button pressed')
+                      return false # Return false since value did not change
+                    end
+                    if event.id == buttons.get_button_id(1)
+                
+                      # Do something when the second button is pressed
+                      Wx.message_box('Second button pressed')
+                      return false # Return false since value did not change
+                    end
+                    if event.id == buttons.button_id(2)
+                      # Do something when the third button is pressed
+                      Wx.message_box('Third button pressed')
+                      return false # Return false since value did not change
+                    end
+                  end
+                  super(propGrid, property, ctrl, event)
+                end
+            
+              end # class WxSampleMultiButtonEditor
+            ```
+        - :pattern: !ruby/regexp /Register.*editor.*class/
+          :replace: |
+            
+            ```ruby
+              # Register editor class - needs only to be called once
+              @sampleMultiButtonEditor =
+                Wx::PG::PropertyGrid.register_editor_class(WxSampleMultiButtonEditor.new)
+            
+              # ...
+            
+              # Insert the property that will have multiple buttons
+              propGrid.append(Wx::PG::LongStringProperty.new("MultipleButtons", Wx::PG::PG_LABEL))
+            
+              # Change property to use editor created in the previous code segment
+              propGrid.set_property_editor("MultipleButtons", @sampleMultiButtonEditor)            
+            ```

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

@@ -0,0 +1,244 @@
+---
+:wxCursorProperty.OnCustomPaint.paintdata:
+  :brief:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: ''
+:wxImageFileProperty.OnCustomPaint.paintdata:
+  :brief:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: ''
+:wxSystemColourProperty.OnCustomPaint.paintdata:
+  :brief:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: ''
+:wxDirProperty.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::DirProperty
+  
+  
+                class << self
+                  def validator
+                    @validator ||= MyValidator.new(...)
+                  end
+                end
+                
+                # ...
+            
+                def do_get_validator
+                  MyPropertyClass.validator
+                end
+            
+                # ...
+            
+              end
+            ```
+:wxFileProperty.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::FileProperty
+            
+            
+                class << self
+                  def validator
+                    @validator ||= MyValidator.new(...)
+                  end
+                end
+            
+                # ...
+            
+                def do_get_validator
+                  MyPropertyClass.validator
+                end
+            
+                # ...
+            
+              end
+            ```
+:wxFloatProperty.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::FloatProperty
+            
+            
+                class << self
+                  def validator
+                    @validator ||= MyValidator.new(...)
+                  end
+                end
+            
+                # ...
+            
+                def do_get_validator
+                  MyPropertyClass.validator
+                end
+            
+                # ...
+            
+              end
+            ```
+:wxIntProperty.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
+            ```
+:wxUIntProperty.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::UIntProperty
+            
+            
+                class << self
+                  def validator
+                    @validator ||= MyValidator.new(...)
+                  end
+                end
+            
+                # ...
+            
+                def do_get_validator
+                  MyPropertyClass.validator
+                end
+            
+                # ...
+            
+              end
+            ```
+:wxFlagsProperty.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
+            ```
+:wxFontProperty.ChildChanged:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+            
+            ```ruby
+              class WxFontDataProperty < Wx::PG::FontProperty
+            
+                def child_changed(thisValue, childIndex, childValue)
+                  fontData = thisValue.object
+                  fontData.initial_font = fontData.chosen_font
+                  
+                  case childIndex
+                    when 6
+                      col = childValue.colour
+                      fontData.colour = col
+                    else
+                      # Transfer from subset to superset.
+                      font = fontData.chosen_font
+                      variant = Wx::Variant.new(font)
+                      variant = super(variant, childIndex, childValue)
+                      font = variant.font
+                      fontData.chosen_font = font
+                  end
+                  
+                  Wx::Variant.new(fontData)
+                end
+            
+              end
+            ```
+:wxIntProperty:
+  :detail:
+    :replace:
+      :text: |
+        
+        <b>Supported special attributes:</b>
+        - {Wx::PG::PG_ATTR_MIN}, {Wx::PG::PG_ATTR_MAX}, {Wx::PG::PG_ATTR_SPINCTRL_STEP}, {Wx::PG::PG_ATTR_SPINCTRL_WRAP}, {Wx::PG::PG_ATTR_SPINCTRL_MOTION}: like in {Wx::PG::NumericProperty}.