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

data/rakelib/lib/director/variant.rb

@@ -437,10 +437,6 @@ module WXRuby3
                 return true;
               }
           
-          //#if wxUSE_ANY
-          //    // Converts value to wxAny, if possible. Return true if successful.
-          //    virtual bool GetAsAny(wxAny* WXUNUSED(any)) const { return false; }
-          //#endif
           protected:
               VALUE m_value;
           };
@@ -462,6 +458,21 @@ module WXRuby3
           }
           __HEREDOC
         spec.add_init_code 'wxRuby_AppendMarker(wxRuby_markRbValueVariants);'
+        # ignore GetType (not doc)
+        spec.ignore 'wxVariant::GetType', ignore_doc: false
+        # replace with custom implementation
+        spec.add_extend_code 'wxVariant', <<~__HEREDOC
+          VALUE get_type()
+          {
+            wxString ts = self->GetType();
+            if (ts == WXRBValueVariantData::type_name_)
+            {
+              VALUE klass = CLASS_OF(((WXRBValueVariantData*)self->GetData())->GetValue());
+              return rb_str_new2(rb_class2name(CLASS_OF(klass)));
+            }
+            return WXSTR_TO_RSTR(ts);
+          }
+          __HEREDOC
         # add custom extension methods 'assign' as replacement for operator=
         spec.add_extend_code 'wxVariant', <<~__HEREDOC
           void assign(const wxVariant& v)
@@ -504,6 +515,7 @@ module WXRuby3
             if (ts == wxS("ulonglong")) return ULL2NUM(self->GetULongLong().GetValue());
             if (ts == wxS("double")) return rb_funcall(SWIG_From_double(self->GetDouble()), to_i_id(), 0);
             if (ts == wxS("datetime")) return rb_funcall(wxRuby_wxDateTimeToRuby(self->GetDateTime()), to_i_id(), 0);
+            if (ts == WXRBValueVariantData::type_name_) return rb_funcall(((WXRBValueVariantData*)self->GetData())->GetValue(), to_i_id(), 0);
             rb_raise(rb_eTypeError, "Cannot convert Variant<%s> to Integer", (const char*)ts.ToAscii());
             return Qnil;
           }
@@ -519,6 +531,7 @@ module WXRuby3
             if (ts == wxS("ulonglong")) return rb_funcall(ULL2NUM(self->GetULongLong().GetValue()), to_f_id(), 0);
             if (ts == wxS("double")) return SWIG_From_double(self->GetDouble());
             if (ts == wxS("datetime")) return rb_funcall(wxRuby_wxDateTimeToRuby(self->GetDateTime()), to_f_id(), 0);
+            if (ts == WXRBValueVariantData::type_name_) return rb_funcall(((WXRBValueVariantData*)self->GetData())->GetValue(), to_f_id(), 0);
             rb_raise(rb_eTypeError, "Cannot convert Variant<%s> to Integer", (const char*)ts.ToAscii());
             return Qnil;
           }

data/rakelib/lib/director/window.rb

@@ -132,8 +132,28 @@ module WXRuby3
             'wxWindow::GetTextExtent(const wxString &,int *,int *,int *,int *,const wxFont *)',
             'wxWindow::SendIdleEvents',
             'wxWindow::ClientToScreen(int*,int*)', # no need; prefer the wxPoint version
-            'wxWindow::ScreenToClient(int*,int*)' # no need; prefer the wxPoint version
+            'wxWindow::ScreenToClient(int*,int*)', # no need; prefer the wxPoint version
           ]
+          # redefine these so a nil parent is accepted
+          spec.ignore %w[wxWindow::FindWindowById wxWindow::FindWindowByLabel wxWindow::FindWindowByName], ignore_doc: false
+          # overrule common typemap to allow default NULL
+          spec.map 'wxWindow* find_from_parent' do
+            map_check code: ''
+          end
+          spec.add_extend_code 'wxWindow', <<~__HEREDOC
+            static wxWindow* find_window_by_id(long id, const wxWindow *find_from_parent=0)
+            {
+              return wxWindow::FindWindowById(id, find_from_parent);
+            }
+            static wxWindow* find_window_by_label(const wxString &label, const wxWindow *find_from_parent=0)
+            {
+              return wxWindow::FindWindowByLabel(label, find_from_parent);
+            }
+            static wxWindow* find_window_by_name(const wxString &name, const wxWindow *find_from_parent=0)
+            {
+              return wxWindow::FindWindowByName(name, find_from_parent);
+            }
+            __HEREDOC
           if Config.instance.wx_port == :wxQT
             # protected for wxQT; ignore for now
             spec.ignore 'wxWindow::EnableTouchEvents'
@@ -257,6 +277,22 @@ module WXRuby3
         # update generated code for all windows
         spec.post_processors << :update_window
       end
+
+      def process(gendoc: false)
+        defmod = super
+        if spec.module_name == 'wxWindow'
+          # special processing to ignore the non-static versions of methods FromDIP,ToDIP,FromPhys,ToPhys
+          # as SWIG cannot handle identically named static & non-static methods
+          # will handle that in pure Ruby
+          %w[FromDIP ToDIP FromPhys ToPhys].each do |mtd|
+            if (item = defmod.find("wxWindow::#{mtd}"))
+              item.all.each { |ovl| ovl.ignore(true, ignore_doc: false) unless ovl.is_static }
+            end
+          end
+        end
+        defmod
+      end
+
     end # class Window
 
   end # class Director

data/rakelib/lib/extractor/function.rb

@@ -109,7 +109,7 @@ module WXRuby3
                   else
                     rb_param_name(paramdef.name)
                   end
-            params << { name: pnm, type: arg.type }
+            params << { name: pnm, type: arg.type || xml_trans.type_to_doc(paramdef.type) }
             if paramdef.default
               defexp = rb_constant_expression(paramdef.default, xml_trans.constants_xref_db)
               # in case the default expression dereferences a pointer or passes an address clean it up
@@ -142,7 +142,7 @@ module WXRuby3
         params.each do |p|
           doclns << ('@param '  << p[:name] << ' [' << p[:type] << '] ' << (p[:doc] ? ' '+(p[:doc].split("\n").join("\n  ")) : ''))
         end
-        result = [rb_return_type(type_maps)]
+        result = [rb_return_type(type_maps, xml_trans)]
         result.concat(mapped_ret_args.collect { |mra| mra.type }) if mapped_ret_args
         result.compact! # remove nil values (possible ignored output)
         case result.size
@@ -156,9 +156,9 @@ module WXRuby3
         [rb_decl_name, paramlist, doclns]
       end
 
-      def rb_return_type(type_maps)
-        mapped_type = type_maps.map_output(type)
-        (mapped_type.empty? || mapped_type == 'void') ? nil : mapped_type
+      def rb_return_type(type_maps, xml_trans)
+        mapped_type = type_maps.map_output(type) || xml_trans.type_to_doc(type)
+        mapped_type == 'void' ? nil : mapped_type
       end
 
       def argument_list
@@ -304,9 +304,9 @@ module WXRuby3
         end
       end
 
-      def rb_return_type(type_maps)
+      def rb_return_type(type_maps, xml_trans)
         if is_ctor
-          rb_wx_name(class_name)
+          xml_trans.type_to_doc(class_name)
         else
           super
         end

data/rakelib/lib/extractor/variable.rb

@@ -80,9 +80,9 @@ module WXRuby3
         ignore # ignore all member variables by default (trust on availability of accessor methods)
       end
 
-      def rb_return_type(type_maps)
-        mapped_type = type_maps.map_output(type)
-        (mapped_type.empty? || mapped_type == 'void') ? nil : mapped_type
+      def rb_return_type(type_maps, xml_trans)
+        mapped_type = type_maps.map_output(type) || xml_trans.type_to_doc(type)
+        mapped_type == 'void' ? nil : mapped_type
       end
       private :rb_return_type
 
@@ -97,7 +97,7 @@ module WXRuby3
         doc = []
         # first document the reader
         doc << [var_doc.dup]
-        doc.last << "@return [#{rb_return_type(type_maps)}]"
+        doc.last << "@return [#{rb_return_type(type_maps, xml_trans)}]"
         doc << "def #{is_static ? 'self.' : ''}#{rb_method_name(rb_name || name)}; end"
         # next document the writer (if any)
         unless no_setter
@@ -108,9 +108,9 @@ module WXRuby3
                                 array: false)]
           mapped_args, _ = type_maps.map_input(parms)
           if mapped_args.empty? # something went wrong!
-            doc.last << "@param val [#{Typemap.wx_type_to_rb(type)}]"
+            doc.last << "@param val [#{xml_trans.type_to_doc(type)}]"
           else
-            doc.last << "@param val [#{mapped_args.first.type}]"
+            doc.last << "@param val [#{mapped_args.first.type || xml_trans.type_to_doc(type)}]"
           end
           doc.last << "@return [void]"
           doc << "def #{is_static ? 'self.' : ''}#{rb_method_name(rb_name || name)}=(val); end"

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

@@ -0,0 +1,21 @@
+---
+:wxAuiManager:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /AddPane/
+          :replace: |
+            
+            ```ruby
+              @text1 = Wx::TextCtrl.new(self, -1)
+              @text2 = Wx::TextCtrl.new(self, -1)
+              @mgr.add_pane(@text1, Wx::LEFT, 'Pane Caption')
+              @mgr.add_pane(@text2, Wx::BOTTOM, 'Pane Caption')
+              @mgr.update
+            ```
+        - :pattern: !ruby/regexp /GetPane/
+          :replace: |
+            
+            ```ruby
+              @mgr.get_pane(@text1).float
+            ```

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

@@ -0,0 +1,16 @@
+---
+:wxContextHelp:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+            
+            ```ruby
+              # puts the application into a 'context-sensitive help mode' for my_window
+              context_help = Wx::ContextHelp.new(my_window)
+              ...
+              ...
+              # ends the 'context-sensitive help mode' for my_window
+              context_help.end_context_help            
+            ```

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

@@ -0,0 +1,27 @@
+---
+:wxEventBlocker:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+            
+            ```ruby
+              class MyWindow
+
+                ...
+            
+                def do_something
+                  # block all events directed to this window
+                  Wx::EventBlocker.blocked_for(self) do
+                    # while we do 1000 function_that_sends_events calls 
+                    1000.times { |i| function_that_sends_events(i) }
+                  end
+                  # old event handler restored; generated event(s) from next call will be processed
+                  function_that_sends_events(0)
+                end
+
+                ... 
+            
+              end
+            ```

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

@@ -0,0 +1,47 @@
+---
+:wxEventFilter:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+            
+            ```ruby
+            # This class allows determining the last time the user has worked with
+            # this application:
+            class LastActivityTimeDetector < Wx::EventFilter
+              def initialize
+                Wx::EvtHandler.add_filter(self)
+        
+                @last = Time.now
+              end
+        
+              def clear
+                Wx::EvtHandler.remove_filter(self)
+              end
+        
+              def filter_event(event)
+                # Update the last user activity
+                t = event.get_event_type
+                case t
+                when Wx::EVT_KEY_DOWN, 
+                     Wx::EVT_MOTION, 
+                     Wx::EVT_LEFT_DOWN,
+                     Wx::EVT_RIGHT_DOWN,
+                     Wx::EVT_MIDDLE_DOWN
+                  @last = Time.now
+                end
+    
+                # Continue processing the event normally as well.
+                Event_Skip
+              end
+        
+              # This function could be called periodically from some timer to
+              # do something (e.g. hide sensitive data or log out from remote
+              # server) if the user has been inactive for some time period.
+              def is_inactive_for?(diff)
+                (Time.now - diff) > @last
+              end
+            
+            end
+            ```

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

@@ -0,0 +1,68 @@
+---
+:wxFileDialog:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /MyFrame::OnOpen/
+          :replace: |
+            
+            ```ruby
+            class MyFrame
+              ...
+              def on_open(event)
+                if (...current content has not been saved...)
+                  if Wx.message_box('Current content has not been saved! Proceed?', 'Please confirm',
+                                    Wx::ICON_QUESTION | Wx::YES_NO, self) == Wx::NO
+                    return 
+                  #else: proceed asking to the user the new file to open
+                  end
+                end
+              
+                Wx::FileDialog(self, "Open XYZ file", "", "",
+                                    "XYZ files (*.xyz)|*.xyz", Wx::FD_OPEN|Wx::FD_FILE_MUST_EXIST) do |dlg|
+                  return if dlg.show_modal == Wx::ID_CANCEL # the user changed idea...?
+            
+                  # proceed loading the file chosen by the user
+                  file = File.open(dlg.path, 'r') rescue nil
+                  unless file
+                     Wx.log_error("Cannot open file '#{dlg.path}'.")
+                     return
+                  end
+                  ...
+                end
+              end
+            
+            end
+            ```
+        - :pattern: !ruby/regexp /MyFrame::OnSaveAs/
+          :replace: |
+            
+            ```ruby
+            class MyFrame
+              ...
+              def on_save_as(event)
+                Wx::FileDialog(self, "Save XYZ file", "", "",
+                                    "XYZ files (*.xyz)|*.xyz", Wx::FD_SAVE|Wx::FD_OVERWRITE_PROMPT) do |dlg|
+                  return if dlg.show_modal == Wx::ID_CANCEL # the user changed idea...?
+              
+                  # save the current contents in the file
+                  begin
+                    File.open(dlg.path, 'w+') do |f|
+                      # save to file
+                    end
+                  rescue 
+                    Wx.log_error("Cannot save current contents in file '#{dlg.path}'.")
+                    return
+                  end
+                end
+                ...
+              end
+            
+            end
+            ```
+        - :pattern: !ruby/regexp /wxSystemOptions::SetOption/
+          :replace: |
+            
+            ```ruby
+              Wx::SystemOptions.set_option(Wx::OSX_FILEDIALOG_ALWAYS_SHOW_TYPES, 1)
+            ```

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

@@ -0,0 +1,29 @@
+---
+:wxFont.wxFont:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /wxFontInfo/
+          :replace: |
+            
+            ```ruby
+              font = Wx::Font.new(Wx::FontInfo.new(10).bold().underlined())
+            ```
+        - :pattern: !ruby/regexp /wxFONTFAMILY_DEFAULT/
+          :replace: |
+            
+            ```ruby
+              font = Wx::Font.new(10, Wx::FontFamily::FONTFAMILY_DEFAULT, 
+                                  Wx::FontStyle::FONTSTYLE_NORMAL, 
+                                  Wx::FontWeight::FONTWEIGHT_BOLD, true)
+            ```
+:wxFontInfo:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+            
+            ```ruby
+              font = Wx::Font.new(Wx::FontInfo.new(12).face_name('Helvetica').italic())
+            ```

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

@@ -0,0 +1,23 @@
+---
+:wxFrame:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+            
+            ```ruby
+              Wx::DEFAULT_FRAME_STYLE & ~(Wx::RESIZE_BORDER | Wx::MAXIMIZE_BOX)
+            ```
+:wxFrame.MSWGetTaskBarButton:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+            
+            ```ruby
+              if Wx::PLATFORM == 'WXMSW'
+                #...
+              end
+            ```

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

@@ -0,0 +1,11 @@
+---
+:wxFSFile.wxFSFile:
+  :detail:
+    :pre:
+      :para:
+        - :pattern: !ruby/regexp /It is seldom used by the application programmer/
+          :replace: ''
+
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: ''

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

@@ -0,0 +1,36 @@
+---
+:wxPoint.SetDefaults:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+
+            ```ruby
+              if !pos.is_fully_specified
+                pos.set_defaults(get_default_position)
+              end
+            ```
+:wxPoint.wxPoint:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+
+            ```ruby
+              real_point = ...
+              p = Wx::Point.new(real_point.x.round, real_point.y.round)
+            ```
+:wxSize.SetDefaults:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+
+            ```ruby
+              if !size.is_fully_specified
+                size.set_defaults(get_default_size)
+              end
+            ```

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

@@ -0,0 +1,34 @@
+---
+:wxGraphicsContext:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+
+            ```ruby
+              class MyCanvas < Wx::ScrolledWindow
+            
+                def on_paint(event)
+                   # Create paint DC
+                   self.paint do |dc|
+                     # Create graphics context from it
+                     Wx::GraphicsContext.draw_on(dc) do |gc|
+                         # make a path that contains a circle and some lines
+                         gc.set_pen(Wx::RED_PEN)
+                         path = gc.create_path
+                         path.add_circle(50.0, 50.0, 50.0)
+                         path.move_to_point(0.0, 50.0)
+                         path.add_line_to_point(100.0, 50.0)
+                         path.move_to_point(50.0, 0.0)
+                         path.add_line_to_point(50.0, 100.0)
+                         path.close_sub_path
+                         path.add_rectangle(25.0, 25.0, 50.0, 50.0)
+                  
+                         gc.stroke_path(path)
+                      end
+                    end
+                  end
+                end
+              end
+            ```

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

@@ -0,0 +1,12 @@
+---
+:wxGUIEventLoop.Dispatch:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+
+            ```ruby
+              while evt_loop.pending
+                evt_loop.dispatch
+            ```

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

@@ -0,0 +1,24 @@
+---
+:wxHelpController.SetViewer:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+
+            ```ruby
+              @help.set_viewer('kdehelp')
+              @help.set_viewer('gnome-help-browser')
+              @help.set_viewer('netscape', Wx::HELP_NETSCAPE)
+            ```
+:wxHelpController:
+  :detail:
+    :pre:
+      :para:
+        - :pattern: !ruby/regexp /Note\s+that\s+if\s+you\s+use\s+\.zip.*application\s+initialization:/
+          :subst: 'Note that in Ruby the required filesystem handlers for .zip or .htb books are always loaded.'
+        - :pattern: !ruby/regexp / or\s+nothing\s+will\s+be\s+shown\s+in\s+your\s+help\s+window./
+          :subst: ''
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: ''

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

@@ -0,0 +1,11 @@
+---
+:wxIcon.GetIcon:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+
+            ```ruby
+              get_icon(Wx::Size.new(size,size))
+            ```

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

@@ -0,0 +1,87 @@
+---
+:wxImage.Scale:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+
+            ```ruby
+              # get the bitmap from somewhere
+              bmp = ...
+              
+              # rescale it to have size of 32*32
+              if bmp.width != 32 || bmp.height != 32
+                 image = bmp.convert_to_image
+                 bmp = Wx::Bitmap.new(image.scale(32, 32))
+              
+                 # another possibility:
+                 image.rescale(32, 32)
+                 bmp = image.to_bitmap
+              end
+            ```
+:wxImage.LoadFile:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+
+            ```ruby
+              hotspot_x = image.get_option_int(Wx::IMAGE_OPTION_CUR_HOTSPOT_X)
+              hotspot_y = image.get_option_int(Wx::IMAGE_OPTION_CUR_HOTSPOT_Y)
+            ```
+:wxImage.SaveFile:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+
+            ```ruby
+              image.set_option(Wx::IMAGE_OPTION_CUR_HOTSPOT_X, hotspot_x)
+              image.set_option(Wx::IMAGE_OPTION_CUR_HOTSPOT_Y, hotspot_y)
+            ```
+:wxImage.SetLoadFlags:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+
+            ```ruby
+              image = Wx::Image.new
+              image.set_load_flags(image.get_load_flags & ~Wx::Image::Load_Verbose)
+              image.load_file(...)
+            ```
+:wxImage.wxImage:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+
+            ```ruby
+              hotspot_x = image.get_option_int(Wx::IMAGE_OPTION_CUR_HOTSPOT_X)
+              hotspot_y = image.get_option_int(Wx::IMAGE_OPTION_CUR_HOTSPOT_Y)
+            ```
+:wxImage.GetImageExtWildcard:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+
+            ```ruby
+              Wx::FileDialog(self, 'Choose Image', Dir.getwd, '',
+                             'Image Files ' + Wx::Image.get_image_ext_wildcard,
+                             Wx::FD_OPEN) do |file_dlg|
+                # ...
+              end
+            ```
+:wxImage:
+  :detail:
+    :pre:
+      :para:
+        - :pattern: !ruby/regexp /To\s+use\s+other\s+image\s+formats,.*or\s+call\s+.*\./
+          :subst: 'In wxRuby all image handlers are loaded by default at startup by {init_all_image_handlers}.'

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

@@ -0,0 +1,19 @@
+---
+:wxKeyboardState.GetModifiers:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /ControlDown/
+          :replace: |
+
+            ```ruby
+              if control_down && !alt_down && !shift_down && !meta_down
+                ... handle Ctrl-XXX ...
+            ```
+        - :pattern: !ruby/regexp /GetModifiers/
+          :replace: |
+
+            ```ruby
+              if get_modifiers == Wx::MOD_CONTROL
+                ... handle Ctrl-XXX ...
+            ```