wxruby3 0.9.0.pre.beta.8

data/rakelib/lib/typemap/data_format.rb

@@ -0,0 +1,76 @@
+###
+# wxRuby3 Common typemap definitions
+# Copyright (c) M.J.N. Corino, The Netherlands
+###
+
+require_relative '../core/mapping'
+
+module WXRuby3
+
+  module Typemap
+
+    # Deals with GetAllFormats
+    module DataFormat
+
+      include Typemap::Module
+
+      define do
+        map 'wxDataFormat* formats' => 'Array<Wx::DataFormat>' do
+
+          # ignore argument for Ruby
+          # since an "ignored" typemap is inserted before any other argument conversions we need
+          # we cannot handle any C++ argument setup here; we use the 'check' typemap for that
+          map_in ignore: true, code: ''
+
+          # "misuse" the 'check' typemap to initialize the ignored argument
+          # since this is inserted after any non-ignored arguments have been converted we can use these
+          # here
+          map_check temp: 'std::unique_ptr<wxDataFormat[]> fmts, size_t nfmt', code: <<~__CODE
+            nfmt = arg1->GetFormatCount(arg3);
+            if (nfmt > 0)
+            {
+              fmts = std::make_unique<wxDataFormat[]>(nfmt);
+            }
+            $1 = fmts.get ();
+            __CODE
+
+          # now convert the ignored argument to setup the Ruby style output
+          map_argout code: <<~__CODE
+            VALUE rb_fmt_arr = Qnil;
+            if (nfmt$argnum > 0)
+            {
+              rb_fmt_arr = rb_ary_new ();
+              for (size_t n=0; n<nfmt$argnum ;++n)
+              {
+                wxDataFormat* fmt = &(fmts$argnum.get ()[n]);
+                VALUE rb_fmt = SWIG_NewPointerObj(new wxDataFormat(*fmt), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN |  0 );
+                rb_ary_push (rb_fmt_arr, rb_fmt);
+              }
+            }
+            $result = rb_fmt_arr;
+            __CODE
+
+          # just skip this; nothing to convert
+          map_directorin code: ''
+
+          # handle the Ruby style result
+          map_directorargout code: <<~__CODE
+            for ( size_t i = 0; i < this->GetFormatCount(); i++ )
+            {
+              void* tmp;
+              SWIG_ConvertPtr(rb_ary_entry(result, i),
+                              &tmp,
+              SWIGTYPE_p_wxDataFormat, 0);
+              wxDataFormat* fmt = reinterpret_cast< wxDataFormat* >(tmp);
+              $1[i] = *fmt;
+            }
+            __CODE
+        end
+
+      end # define
+
+    end # DataFormat
+
+  end # Typemap
+
+end # WXRuby3

data/rakelib/lib/typemap/data_object_data.rb

@@ -0,0 +1,99 @@
+###
+# wxRuby3 Common typemap definitions
+# Copyright (c) M.J.N. Corino, The Netherlands
+###
+
+require_relative '../core/mapping'
+
+module WXRuby3
+
+  module Typemap
+
+    # Deals with GetDataHere and SetData
+    module DataObjectData
+
+      include Typemap::Module
+
+      define do
+
+        # For wxDataObject::GetDataHere: the ruby method is passed the DataFormat
+        # for the sought data, and should return either a string containing the
+        # data, or nil if the data cannot be provided for some reason.
+        map 'const wxDataFormat &format, void *buf' do
+          # this is needed for this and all other mappings
+          add_header '#include <wx/dataobj.h>'
+
+          map_in from: {type: 'Wx::DataFormat', index: 0}, temp: 'std::unique_ptr<char[]> data_buf, size_t data_size', code: <<~__CODE
+            void* argp$argnum = NULL;
+            if ( TYPE($input) == T_DATA )
+            {
+              if (SWIG_IsOK(SWIG_ConvertPtr($input, &argp$argnum, $1_descriptor, $argnum-1)) && argp$argnum)
+              {
+                $1 = reinterpret_cast< $1_basetype * >(argp$argnum);
+              }
+            }
+            if (!argp$argnum)
+            {
+              rb_raise(rb_eTypeError, "Expected Wx::DataFormat instance.");
+            }
+            data_size = arg1->GetDataSize(*$1);
+            data_buf = std::make_unique<char[]>(data_size);
+            $2 = data_buf.get ();
+            __CODE
+
+          # ignore C defined return value entirely (also affects directorout)
+          map_out ignore: 'bool'
+
+          map_argout as: {type: 'String', index: 1}, code: <<~__CODE
+            if (result)
+            {
+              $result = rb_str_new( (const char*)data_buf$argnum.get(), data_size$argnum);
+            }
+            else
+              $result = Qnil;
+            __CODE
+
+          # convert the dataformat and ignore the buffer pointer for now
+          map_directorin code: '$input = SWIG_NewPointerObj(SWIG_as_voidptr(&$1), SWIGTYPE_p_wxDataFormat, 0);'
+
+          map_directorargout code: <<~__CODE
+            if (RTEST(result))
+            {
+              if (TYPE(result) == T_STRING)
+              {
+                memcpy(buf, StringValuePtr(result), RSTRING_LEN(result) );
+                c_result = true;
+              }
+              else
+              {
+                Swig::DirectorTypeMismatchException::raise(rb_eTypeError, 
+                                                           "get_data_here should return a string, or nil on failure");
+              }
+            }
+            else
+              c_result = false;
+          __CODE
+
+        end
+
+        # For SetData: the data contents to be set upon the data object is
+        # passed in as a Ruby string; the ruby method should return a true
+        # value if the data could be set successfully, or false/nil if it could
+        # not. This string is marked as tainted.
+        map 'size_t len, const void* buf' do
+
+          map_in from: {type: 'String', index: 1}, code: <<~__CODE
+            $1 = RSTRING_LEN($input);
+            $2 = (void*)StringValuePtr($input);
+            __CODE
+
+          map_directorin code: '$input = rb_external_str_new( (const char *)buf, len );'
+        end
+
+      end # define
+
+    end # DataObjectData
+
+  end # Typemap
+
+end # WXRuby3

data/rakelib/lib/typemap/datetime.rb

@@ -0,0 +1,64 @@
+###
+# wxRuby3 Common typemap definitions
+# Copyright (c) M.J.N. Corino, The Netherlands
+###
+
+require_relative '../core/mapping'
+
+module WXRuby3
+
+  module Typemap
+
+    # Typemaps for converting between wxDateTime and Ruby's Date and Time
+    # classes. These are used in CalendarCtrl etc
+    module DateTime
+
+      include Typemap::Module
+
+      define do
+
+        map 'wxDateTime&' => 'Time,Date,DateTime' do
+
+          add_header_code <<~__CODE
+            #ifndef __WXRB_DATETIME_HELPERS__
+            #include <wx/datetime.h>
+            
+            WXRB_EXPORT_FLAG VALUE wxRuby_wxDateTimeToRuby(const wxDateTime& dt);
+            
+            WXRB_EXPORT_FLAG wxDateTime* wxRuby_wxDateTimeFromRuby(VALUE ruby_value);
+            #endif
+            __CODE
+
+          # Accepts any Time-like object from Ruby and creates a wxDateTime
+          map_in temp: 'std::unique_ptr<wxDateTime> tmp_dt',
+                 code: 'tmp_dt.reset(wxRuby_wxDateTimeFromRuby($input)); $1 = tmp_dt.get();'
+
+          # Converts a return value of wxDateTime& to a Ruby Time object
+          map_out code: '$result = wxRuby_wxDateTimeToRuby(*$1);'
+
+          map_directorin code: '$input = wxRuby_wxDateTimeToRuby($1);'
+
+          map_typecheck precedence: 'SWIGOBJECT', code: <<~__CODE
+            $1 = rb_obj_is_kind_of($input, rb_cTime) || rb_respond_to($input, rb_intern ("to_time"));
+            __CODE
+        end
+
+        map 'wxDateTime' => 'Time,Date,DateTime' do
+
+          # Converts a return value of wxDateTime to a Ruby Time object
+          map_out code: '$result = wxRuby_wxDateTimeToRuby($1);'
+
+          map_directorout temp: 'std::unique_ptr<wxDateTime> tmp_dt', code: <<~__CODE
+            tmp_dt.reset(wxRuby_wxDateTimeFromRuby($input));
+            $result = *tmp_dt.get();
+            __CODE
+
+        end
+
+      end # define
+
+    end # DateTime
+
+  end # Typemap
+
+end # WXRuby3

data/rakelib/lib/typemap/grid_client_data.rb

@@ -0,0 +1,55 @@
+###
+# wxRuby3 Grid client data typemap definition
+# Copyright (c) M.J.N. Corino, The Netherlands
+###
+
+require_relative '../core/mapping'
+
+module WXRuby3
+
+  module Typemap
+
+    # Typemaps for converting returned PGCell references to
+    # either the correct wxRuby class
+    module GridClientData
+
+      include Typemap::Module
+
+      define do
+
+        map 'wxClientData *' => 'Object' do
+          add_header_code <<~__CODE
+            #include <wx/clntdata.h>
+            extern void wxRuby_RegisterGridClientData(wxClientData* pcd, VALUE rbval);
+            extern void wxRuby_UnregisterGridClientData(wxClientData* pcd);
+
+            class WXRBGridClientData : public wxClientData
+            {
+            public:
+              WXRBGridClientData() : rb_data(Qnil) { }
+              WXRBGridClientData (VALUE data) : rb_data(data) { wxRuby_RegisterGridClientData(this, data); }
+              virtual ~WXRBGridClientData () { wxRuby_UnregisterGridClientData(this); }
+              VALUE GetData() const { return rb_data; }
+            private:
+              VALUE rb_data;
+            };
+
+            __CODE
+          map_in code: '$1 = new WXRBGridClientData($input);'
+          map_out code: <<~__CODE
+            $result = Qnil;
+            if ($1)
+            {
+              WXRBGridClientData* pgcd = dynamic_cast<WXRBGridClientData*> ($1);
+              if (pgcd) $result = pgcd->GetData();
+            }
+          __CODE
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/rakelib/lib/typemap/grid_coords.rb

@@ -0,0 +1,65 @@
+###
+# wxRuby3 Common typemap definitions
+# Copyright (c) M.J.N. Corino, The Netherlands
+###
+
+require_relative '../core/mapping'
+
+module WXRuby3
+
+  module Typemap
+
+    # Shared typemaps used by Grid classes to map wxGridCellCoords to
+    # simple two-element ruby arrays
+    module GridCoords
+
+      include Typemap::Module
+
+      define do
+
+        map 'wxGridCellCoords' => 'Array(Integer, Integer)' do
+
+          map_in temp: 'int a, b', code: <<~__CODE
+            if ( ! TYPE($input) == T_ARRAY )
+            {
+              rb_raise(rb_eTypeError,
+                       "Grid cell co-ordinates should be passed as [row, col] array");
+            }
+
+            a = NUM2INT( rb_ary_entry($1, 0) );
+            b = NUM2INT( rb_ary_entry($1, 1) );
+            $input = wxGridCellCoords(a,b);
+            __CODE
+
+          map_out code: <<~__CODE
+            $result = rb_ary_new();
+            rb_ary_push($result, INT2NUM($1.GetRow() ));
+            rb_ary_push($result, INT2NUM($1.GetCol() ));
+            __CODE
+
+        end
+
+        # Needed for get_selected_cells, get_selection_block_top_left etc
+        map 'wxGridCellCoordsArray' => 'Array<Array(Integer, Integer)>' do
+
+          map_out code: <<~__CODE
+            $result = rb_ary_new();
+            for (size_t i = 0; i < $1.GetCount(); i++)
+            {
+              wxGridCellCoords coord = $1.Item(i);
+              VALUE rb_coord = rb_ary_new();
+              rb_ary_push(rb_coord, INT2NUM(coord.GetRow()));
+              rb_ary_push(rb_coord, INT2NUM(coord.GetCol()));
+              rb_ary_push($result, rb_coord);
+            }
+            __CODE
+
+        end
+
+      end # define
+
+    end # GridCoords
+
+  end # Typemap
+
+end # WXRuby3

data/rakelib/lib/typemap/html_cell.rb

@@ -0,0 +1,57 @@
+###
+# wxRuby3 HtmlCell typemap definition
+# Copyright (c) M.J.N. Corino, The Netherlands
+###
+
+require_relative '../core/mapping'
+
+module WXRuby3
+
+  module Typemap
+
+    # Typemaps for converting returned HtmlCell references to
+    # either the base Wx::HTML::HtmlCell or Wx::HTML::HtmlContainerCell
+    module HtmlCell
+
+      include Typemap::Module
+
+      define do
+
+        map 'wxHtmlCell*' => 'Wx::HTML::HtmlCell,Wx::HTML::HtmlContainerCell' do
+          map_out code: <<~__CODE
+            // attempt a dynamic cast to wxHtmlContainerCell 
+            wxHtmlContainerCell* con_cell = dynamic_cast<wxHtmlContainerCell*> ($1);
+            if (con_cell)
+            {
+              swig_type_info* swig_type = wxRuby_GetSwigTypeForClass(rb_eval_string("Wx::HTML::HtmlContainerCell"));
+              $result = SWIG_NewPointerObj(con_cell, swig_type, 0);
+            }
+            else
+            {
+              swig_type_info* swig_type = wxRuby_GetSwigTypeForClass(rb_eval_string("Wx::HTML::HtmlCell"));
+              $result = SWIG_NewPointerObj($1, swig_type, 0);
+            }
+            __CODE
+          map_directorin code: <<~__CODE
+            // attempt a dynamic cast to wxHtmlContainerCell 
+            wxHtmlContainerCell* con_cell = dynamic_cast<wxHtmlContainerCell*> ($1);
+            if (con_cell)
+            {
+              swig_type_info* swig_type = wxRuby_GetSwigTypeForClass(rb_eval_string("Wx::HTML::HtmlContainerCell"));
+              $input = SWIG_NewPointerObj(con_cell, swig_type, 0);
+            }
+            else
+            {
+              swig_type_info* swig_type = wxRuby_GetSwigTypeForClass(rb_eval_string("Wx::HTML::HtmlCell"));
+              $input = SWIG_NewPointerObj($1, swig_type, 0);
+            }
+            __CODE
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/rakelib/lib/typemap/io_streams.rb

@@ -0,0 +1,162 @@
+###
+# wxRuby3 Common typemap definitions
+# Copyright (c) M.J.N. Corino, The Netherlands
+###
+
+require_relative '../core/mapping'
+
+module WXRuby3
+
+  module Typemap
+
+    # wxInputStream and wxOutputStream are used to allow certain classes in
+    # wxWidgets - for example, wxImage - to read and write data from
+    # arbitrary streams. Rather than expose these classes directly, which
+    # would duplicate ruby's IO/File classes, wxRuby here provides the
+    # ability for any IO-like object implementing "read" to act as an input
+    # stream, and similarly any object implementing "write" to act as an
+    # output stream.
+
+    # So there are two thin classes which translate C++ calls to IO
+    # functions to the equivalent ruby calls, and, the typemaps that
+    # create these wrapper objects as needed.
+    module IOStreams
+
+      include Typemap::Module
+
+      define do
+
+        map 'wxInputStream &' => 'IO,Wx::InputStream' do
+
+          add_header_code <<~__CODE
+            WXRUBY_EXPORT bool wxRuby_IsInputStream(VALUE);
+            WXRUBY_EXPORT bool wxRuby_IsCompatibleInput(VALUE rbis);
+            WXRUBY_EXPORT wxInputStream* wxRuby_RubyToInputStream(VALUE);
+            WXRUBY_EXPORT VALUE wxRuby_RubyFromInputStream(wxInputStream&);
+
+            class WXRUBY_EXPORT wxRubyInputStream : public wxInputStream
+            {
+            public:
+              // Initialize with the readable ruby IO-like object
+              wxRubyInputStream(VALUE rb_io);
+              virtual ~wxRubyInputStream();
+          
+              wxFileOffset GetLength() const wxOVERRIDE;
+
+              bool CanRead() const wxOVERRIDE;  
+              bool Eof() const wxOVERRIDE; 
+              bool Ok() const { return IsOk(); }
+              bool IsOk() const wxOVERRIDE;
+              bool IsSeekable() const wxOVERRIDE;
+
+              VALUE GetRubyIO () { return m_rbio; }
+
+            protected:
+              size_t OnSysRead(void *buffer, size_t bufsize) wxOVERRIDE; 
+              wxFileOffset OnSysSeek(wxFileOffset seek, wxSeekMode mode) wxOVERRIDE;
+              wxFileOffset OnSysTell() const wxOVERRIDE;
+  
+              VALUE m_rbio; // Wrapped ruby object
+              bool m_isIO;
+              bool m_isSeekable;
+            };
+            __CODE
+
+          map_in temp: 'std::unique_ptr<wxRubyInputStream> tmp_ris',
+                 code: <<~__CODE
+            if (wxRuby_IsCompatibleInput($input))
+            {
+              tmp_ris = std::make_unique<wxRubyInputStream>($input); 
+              $1 = tmp_ris.get();
+            }
+            else
+            {
+              $1 = wxRuby_RubyToInputStream($input);
+              if (!$1)
+              {
+                rb_raise(rb_eArgError, "Invalid value for %d expected IO(-like) or Wx::InputStream", $argnum-1);
+              }
+            }
+          __CODE
+
+          map_directorin code: <<~__CODE
+            $input = wxRuby_RubyFromInputStream($1);
+            __CODE
+
+          map_typecheck precedence: 1, code: <<~__CODE
+            $1 = wxRuby_IsCompatibleInput($input) || wxRuby_IsInputStream($input);
+            __CODE
+
+        end
+
+        map 'wxOutputStream &' => 'IO,Wx::OutputStream' do
+
+          add_header_code <<~__CODE
+            WXRUBY_EXPORT bool wxRuby_IsOutputStream(VALUE);
+            WXRUBY_EXPORT bool wxRuby_IsCompatibleOutput(VALUE rbos);
+            WXRUBY_EXPORT wxOutputStream* wxRuby_RubyToOutputStream(VALUE);
+            WXRUBY_EXPORT VALUE wxRuby_RubyFromOutputStream(wxOutputStream&);
+
+            // Allows a ruby IO-like object to be used as a wxOutputStream
+            class WXRUBY_EXPORT wxRubyOutputStream : public wxOutputStream
+            {
+            public:
+              // Initialize with the writeable ruby IO-like object
+              wxRubyOutputStream(VALUE rb_io);
+              virtual ~wxRubyOutputStream(); 
+          
+              wxFileOffset GetLength() const wxOVERRIDE;
+            
+              void Sync() wxOVERRIDE;
+              bool Close() wxOVERRIDE; 
+              bool Ok() const { return IsOk(); }
+              bool IsOk() const wxOVERRIDE;
+              bool IsSeekable() const wxOVERRIDE;
+
+              VALUE GetRubyIO () { return m_rbio; }
+            
+            protected:
+              size_t OnSysWrite(const void *buffer, size_t size) wxOVERRIDE; 
+              wxFileOffset OnSysSeek(wxFileOffset seek, wxSeekMode mode) wxOVERRIDE;
+              wxFileOffset OnSysTell() const wxOVERRIDE;
+
+              VALUE m_rbio; // Wrapped ruby object
+              bool m_isIO;
+              bool m_isSeekable;
+            };
+            __CODE
+
+          map_in temp: 'std::unique_ptr<wxRubyOutputStream> tmp_ros',
+                 code: <<~__CODE
+            if (wxRuby_IsCompatibleOutput($input))
+            {
+              tmp_ros = std::make_unique<wxRubyOutputStream>($input); 
+              $1 = tmp_ros.get();
+            }
+            else
+            {
+              $1 = wxRuby_RubyToOutputStream($input);
+              if (!$1)
+              {
+                rb_raise(rb_eArgError, "Invalid value for %d expected IO(-like) or Wx::OutputStream", $argnum-1);
+              }
+            }
+          __CODE
+
+          map_directorin code: <<~__CODE
+            $input = wxRuby_RubyFromOutputStream($1);
+          __CODE
+
+          map_typecheck precedence: 1, code: <<~__CODE
+            $1 = wxRuby_IsCompatibleOutput($input) || wxRuby_IsOutputStream($input);
+            __CODE
+
+        end
+
+      end # define
+
+    end # Streams
+
+  end # Typemap
+
+end # WXRuby3

data/rakelib/lib/typemap/pgcell.rb

@@ -0,0 +1,35 @@
+###
+# wxRuby3 PGProperty typemap definition
+# Copyright (c) M.J.N. Corino, The Netherlands
+###
+
+require_relative '../core/mapping'
+
+module WXRuby3
+
+  module Typemap
+
+    # Typemaps for converting returned PGCell references to
+    # either the correct wxRuby class
+    module PGCell
+
+      include Typemap::Module
+
+      define do
+
+        map 'wxPGCell&' => 'Wx::PG::PGCell' do
+          add_header_code <<~__CODE
+            #include <wx/propgrid/property.h>
+            extern VALUE wxRuby_WrapWxPGCellInRuby(const wxPGCell *wx_pc);
+            __CODE
+          map_out code: '$result = wxRuby_WrapWxPGCellInRuby($1);'
+          map_directorin code: '$input = wxRuby_WrapWxPGCellInRuby($1);'
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/rakelib/lib/typemap/pgeditor.rb

@@ -0,0 +1,35 @@
+###
+# wxRuby3 PGProperty typemap definition
+# Copyright (c) M.J.N. Corino, The Netherlands
+###
+
+require_relative '../core/mapping'
+
+module WXRuby3
+
+  module Typemap
+
+    # Typemaps for converting returned PGEditor references to
+    # either the correct wxRuby class
+    module PGEditor
+
+      include Typemap::Module
+
+      define do
+
+        map 'wxPGEditor*' => 'Wx::PG::PGEditor' do
+          add_header_code <<~__CODE
+            #include <wx/propgrid/editors.h>
+            extern VALUE wxRuby_WrapWxPGEditorInRuby(const wxPGEditor *wx_pp);
+            __CODE
+          map_out code: '$result = wxRuby_WrapWxPGEditorInRuby($1);'
+          map_directorin code: '$input = wxRuby_WrapWxPGEditorInRuby($1);'
+        end
+
+      end
+
+    end
+
+  end
+
+end