wxruby3 0.9.0.pre.rc.2 → 0.9.0.pre.rc.3

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/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_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/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/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)
+            ```

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

@@ -0,0 +1,19 @@
+---
+:wxTextCtrl:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /SetDefaultStyle.*wxRED/
+          :replace: |
+            
+            ```ruby
+              text.set_default_style(Wx::TextAttr.new(Wx::RED))
+              text.append_text("Red text\n")
+              text.set_default_style(Wx::TextAttr.new(Wx::NULL_COLOUR, Wx::LIGHT_GREY))
+              text.append_text("Red on grey text\n")
+              text.set_default_style(Wx::TextAttr.new(Wx::BLUE))
+              text.append_text("Blue on grey text\n")
+            ```
+    :post:
+      - :pattern: !ruby/regexp /==\s+wxTextCtrl\s+and\s+C\+\+\s+Streams.*See\s+\{Wx::StreamToTextRedirector\}\s+for\s+more\s+details\./m
+        :subst: ''