wxruby3 0.9.0.pre.rc.1 → 0.9.0.pre.rc.3

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

@@ -0,0 +1,77 @@
+---
+:wxListCtrl.GetNextItem:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+
+            ```ruby
+              item = -1
+              while (item = list_ctrl.get_next_item(item, Wx::LIST_NEXT_ALL, Wx::LIST_STATE_SELECTED)) != -1
+                # item is selected - do whatever is needed with it
+                Wx.log_message("Item #{item} is selected.")
+              end
+            
+              # alternatively in wxRuby you could do
+              list_ctrl.each_selected do |item|
+                Wx.log_message("Item #{item} is selected.")
+              end
+            ```
+:wxListCtrl.SetItemState:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /item.*wxLIST_STATE_SELECTED.*wxLIST_STATE_SELECTED/
+          :replace: |
+
+            ```ruby
+              list.set_item_state(item, Wx::LIST_STATE_SELECTED, Wx::LIST_STATE_SELECTED)
+            ```
+        - :pattern: !ruby/regexp /item.*0.*wxLIST_STATE_SELECTED/
+          :replace: |
+
+            ```ruby
+              list.set_item_state(item, 0, Wx::LIST_STATE_SELECTED)
+            ```
+:wxListCtrl.GetUpdatedAscendingSortIndicator:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+
+            ```ruby
+              class MyListCtrl
+            
+                def on_col_click(event)
+                  col = event.column
+                  if col == -1
+                     return # clicked outside any column.
+              
+                  ascending = get_updated_ascending_sort_indicator(col)
+                  sort_items(ascending) { |itm1_data, itm2_data, data| ... }
+                  show_sort_indicator(col, ascending)
+                end
+            
+              end
+            ```
+:wxListCtrl:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+
+            ```ruby
+              list = Wx::ListCtrl.new(...)
+              3.times { |i| list.insert_column(i, "Column #{i}") }
+              
+              order = [2, 0, 1]
+              list.set_columns_order(order)
+              
+              # now list.get_columns_order() will return order and
+              # list.get_column_index_from_order(n) will return order[n] and
+              # list.get_column_order() will return 1, 2 and 0 for the column 0,
+              # 1 and 2 respectively
+            ```

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