wxruby3 0.9.0.pre.beta.8

data/rakelib/lib/director/font.rb

@@ -0,0 +1,138 @@
+###
+# wxRuby3 wxWidgets interface director
+# Copyright (c) M.J.N. Corino, The Netherlands
+###
+
+module WXRuby3
+
+  class Director
+
+    class Font < Director
+
+      def setup
+        super
+        spec.items << 'wxFontInfo'
+        spec.gc_as_temporary 'wxFontInfo'
+        # all but the default ctor require a running App
+        spec.require_app 'wxFont::wxFont(const wxFont &)',
+                         'wxFont::wxFont(const wxFontInfo &)',
+                         'wxFont::wxFont(int, wxFontFamily, wxFontStyle, wxFontWeight, bool, const wxString &, wxFontEncoding)',
+                         'wxFont::wxFont(const wxSize &, wxFontFamily, wxFontStyle, wxFontWeight, bool, const wxString &, wxFontEncoding)',
+                         'wxFont::wxFont(const wxString &)',
+                         # and these statics
+                         'wxFont::GetDefaultEncoding',
+                         'wxFont::SetDefaultEncoding'
+        spec.rename_for_ruby 'create' => 'wxFont::New'
+        spec.ignore %w[
+          wxFont::SetNativeFontInfo wxFont::GetNativeFontInfo wxFont::operator!=
+          ]
+        spec.ignore 'wxFont::wxFont(const wxNativeFontInfo &)'
+        if Config.instance.wx_port == :wxQT
+          # not implemented
+          spec.ignore 'wxFont::AddPrivateFont'
+        end
+        # ignore stock objects here; need special init in app mainloop
+        spec.ignore %w[
+          wxNORMAL_FONT
+          wxSMALL_FONT
+          wxITALIC_FONT
+          wxSWISS_FONT
+          wxTheFontList
+          ]
+        # for methods altering the font and returning reference to self
+        spec.map 'wxFont &' => 'Wx::Font' do
+          map_out code: '$result = self; wxUnusedVar($1);'
+        end
+        # for methods setting up the fontinfo and returning reference to self
+        spec.map 'wxFontInfo &' => 'Wx::FontInfo' do
+          map_out code: '$result = self; wxUnusedVar($1);'
+        end
+        spec.add_wrapper_code <<~__HEREDOC
+          WXRUBY_EXPORT bool wxRuby_IsRubyFont(VALUE rbfont)
+          {
+            swig_class *sklass_font = (swig_class *) SWIGTYPE_p_wxFont->clientdata;
+            swig_class *sklass_font_info = (swig_class *) SWIGTYPE_p_wxFontInfo->clientdata;
+            return TYPE(rbfont) == T_DATA && 
+                    (rb_obj_is_kind_of(rbfont, sklass_font->klass) || 
+                     rb_obj_is_kind_of(rbfont, sklass_font_info->klass));
+          }
+          WXRUBY_EXPORT wxFont wxRuby_FontFromRuby(VALUE rbfont)
+          {
+            if (TYPE(rbfont) == T_DATA)
+            {
+              void *ptr;
+              swig_class *sklass_font_info = (swig_class *) SWIGTYPE_p_wxFontInfo->clientdata;
+              if (rb_obj_is_kind_of(rbfont, sklass_font_info->klass))
+              {
+                int res = SWIG_ConvertPtr(rbfont, &ptr, SWIGTYPE_p_wxFontInfo, 0);
+                if (SWIG_IsOK(res) && ptr) 
+                {
+                  return wxFont(*reinterpret_cast<wxFontInfo *>(ptr));
+                }
+              }
+              else
+              {
+                int res = SWIG_ConvertPtr(rbfont, &ptr, SWIGTYPE_p_wxFont, 0);
+                if (SWIG_IsOK(res) && ptr) 
+                {
+                  return *reinterpret_cast<wxFont *>(ptr);
+                }
+              }
+            }
+            return wxFont();
+          }
+          WXRUBY_EXPORT VALUE wxRuby_FontToRuby(const wxFont& font)
+          {
+            return SWIG_NewPointerObj(new wxFont(font), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN);
+          }
+          __HEREDOC
+        spec.do_not_generate :functions
+      end
+
+      def generator
+        WXRuby3::FontGenerator.new(self)
+      end
+      protected :generator
+
+    end # class Font
+
+  end # class Director
+
+  class FontGenerator < InterfaceGenerator
+
+    def run
+      # determine Ruby library font root for package
+      rbfont_root = File.join(package.ruby_classes_path, 'font')
+      Stream.transaction do
+        f = CodeStream.new(File.join(rbfont_root, 'encoding.rb'))
+        f << <<~__HEREDOC
+          # --
+          # This file is automatically generated by the WXRuby3 interface generator.
+          # Do not alter this file.
+          # --
+
+          class Wx::Font
+            # String names of the constants provided by C++
+            # (extracted from enum defined in include/wx/fontenc.h)
+            ENCODING_NAMES = %w[
+          __HEREDOC
+        f.indent(2) do
+          def_item('wxFontEncoding').items.each do |item|
+            unless item.name == 'wxFONTENCODING_SYSTEM'
+              const_name = item.name.sub(/\AwxFONTENCODING_/, '')
+              const_name.tr!('_', '-')
+              const_name.sub!(/\AISO/, 'ISO-')
+              f.puts const_name
+            end
+          end
+        end
+        f.indent { f.puts ']' }
+        f.puts 'end'
+      end
+      # make sure to keep this last for the parallel builds synchronize on the *.i files
+      super
+    end
+
+  end
+
+end # module WXRuby3

data/rakelib/lib/director/font_data.rb

@@ -0,0 +1,22 @@
+###
+# wxRuby3 wxWidgets interface director
+# Copyright (c) M.J.N. Corino, The Netherlands
+###
+
+module WXRuby3
+
+  class Director
+
+    class FontData < Director
+
+      def setup
+        super
+        # add copy ctor missing from XML docs
+        spec.extend_interface 'wxFontData',
+                              'wxFontData(const wxFontData & other)'
+      end
+    end # class FontData
+
+  end # class Director
+
+end # module WXRuby3

data/rakelib/lib/director/font_picker_ctrl.rb

@@ -0,0 +1,22 @@
+###
+# wxRuby3 wxWidgets interface director
+# Copyright (c) M.J.N. Corino, The Netherlands
+###
+
+require_relative './window'
+
+module WXRuby3
+
+  class Director
+
+    class FontPickerCtrl < Window
+
+      def setup
+        super
+        spec.do_not_generate(:variables, :defines, :enums, :functions) # with FontPickerEvent
+      end
+    end # class FontPickerCtrl
+
+  end # class Director
+
+end # module WXRuby3

data/rakelib/lib/director/frame.rb

@@ -0,0 +1,74 @@
+###
+# wxRuby3 wxWidgets interface director
+# Copyright (c) M.J.N. Corino, The Netherlands
+###
+
+require_relative './top_level_window'
+
+module WXRuby3
+
+  class Director
+
+    class Frame < TopLevelWindow
+
+      def setup
+        super
+        # only for wxFrame class itself
+        case spec.module_name
+        when 'wxFrame'
+          spec.no_proxy %w[
+            wxFrame::CreateStatusBar
+            wxFrame::CreateToolBar
+            wxFrame::SetMenuBar
+            wxFrame::GetMenuBar
+            wxFrame::SetStatusBar
+            wxFrame::GetStatusBar
+            wxFrame::SetToolBar
+            wxFrame::GetToolBar]
+          spec.ignore %w[
+            wxFrame::OnCreateStatusBar wxFrame::OnCreateToolBar]
+          spec.set_only_for(%w[__WXMSW__ wxUSE_TASKBARBUTTON], 'wxFrame::MSWGetTaskBarButton')
+          # this reimplemented window base method need to be properly wrapped but
+          # is missing from the XML docs
+          spec.extend_interface('wxFrame', 'virtual void OnInternalIdle()')
+          spec.disown 'wxMenuBar *'
+          spec.map 'int n, int * widths' do
+            map_in from: {type: 'Array<Integer>', index: 1},
+                   temp: 'int size, int i, std::unique_ptr<int[]> arr', code: <<~__CODE
+              size = RARRAY_LEN($input);
+              arr.reset(new int[size]);
+              for(i = 0; i < size; i++)
+              {
+                arr.get()[i] = NUM2INT(rb_ary_entry($input,i));
+              }
+              $1 = size;
+              $2 = arr.get();
+              __CODE
+          end
+          # handled; can be suppressed
+          spec.suppress_warning(473,
+                                'wxFrame::CreateStatusBar',
+                                'wxFrame::CreateToolBar',
+                                'wxFrame::GetMenuBar',
+                                'wxFrame::GetStatusBar',
+                                'wxFrame::GetToolBar')
+        else # 'wxMiniFrame', 'wxMDIFrame', 'wxAuiMDIParentFrame'
+          spec.items.each do |cls|
+            spec.no_proxy %W[
+              #{cls}::CreateStatusBar
+              #{cls}::CreateToolBar
+              #{cls}::SetMenuBar
+              #{cls}::GetMenuBar
+              #{cls}::SetStatusBar
+              #{cls}::GetStatusBar
+              #{cls}::SetToolBar
+              #{cls}::GetToolBar
+              ]
+          end
+        end
+      end
+    end # class Frame
+
+  end # class Director
+
+end # module WXRuby3

data/rakelib/lib/director/fs_file.rb

@@ -0,0 +1,353 @@
+###
+# wxRuby3 wxWidgets interface director
+# Copyright (c) M.J.N. Corino, The Netherlands
+###
+
+module WXRuby3
+
+  class Director
+
+    class FSFile < Director
+
+      include Typemap::IOStreams
+
+      def setup
+        super
+        spec.items << 'wxStreamBase' << 'wxInputStream' << 'wxOutputStream'
+        spec.make_abstract 'wxStreamBase'
+        spec.make_abstract 'wxInputStream'
+        spec.make_abstract 'wxOutputStream'
+        spec.no_proxy 'wxStreamBase', 'wxInputStream', 'wxOutputStream'
+        # for FSFile ctor
+        spec.map 'wxInputStream *stream' => 'IO' do
+          map_in code: <<~__CODE
+            if (wxRuby_IsCompatibleInput($input))
+            {
+              $1 = new wxRubyInputStream($input);
+            }
+            else
+            {
+              rb_raise(rb_eArgError, "Invalid value for %d expected IO-like", $argnum-1);
+            }
+          __CODE
+        end
+        spec.new_object 'wxFSFile::DetachStream'
+        # ignore troublesome methods
+        spec.ignore 'wxInputStream::Read(void *, size_t)',
+                    'wxInputStream::ReadAll',
+                    'wxInputStream::Ungetch(const void *, size_t)'
+        # replace with these (except Ungetch)
+        spec.add_extend_code 'wxInputStream', <<~__HEREDOC
+          VALUE Read(size_t size)
+          {
+            std::unique_ptr<char[]> buffer = std::make_unique<char[]>(size);
+            $self->Read(buffer.get(), size);
+            size_t nread = $self->LastRead();
+            return nread>0 ? rb_str_new(buffer.get(), nread) : Qnil;
+          }
+          VALUE ReadAll(size_t size)
+          {
+            std::unique_ptr<char[]> buffer = std::make_unique<char[]>(size);
+            size_t nread = size;
+            if (!$self->ReadAll(buffer.get(), size))
+            {
+              nread = $self->LastRead();
+            }
+            return nread>0 ? rb_str_new(buffer.get(), nread) : Qnil;
+          }
+          __HEREDOC
+        # for Read(wxOutputStream&)
+        spec.map 'wxInputStream&' => 'Wx::InputStream' do
+          map_out code: '$result = self; wxUnusedVar($1);'
+        end
+        # ignore troublesome methods
+        spec.ignore 'wxOutputStream::Write',
+                    'wxOutputStream::WriteAll'
+        # replace with these
+        spec.add_extend_code 'wxOutputStream', <<~__HEREDOC
+          size_t Write(VALUE input)
+          {
+            if (TYPE(input) == T_STRING)
+            {
+              size_t size = RSTRING_LEN(input);
+              void* buffer = RSTRING_PTR(input);
+              $self->Write(buffer, size);
+            }
+            else if (rb_obj_is_kind_of(input, rb_cIO) || wxRuby_IsInputStream(input))
+            {
+              std::unique_ptr<wxInputStream> safe_ris = std::make_unique<wxRubyInputStream>(input);
+              $self->Write(*safe_ris.get());
+            }
+            else
+            {
+              rb_raise(rb_eArgError, "Invalid value for 0; expected String or IO or Wx::InputStream");
+              return 0;
+            }
+            return $self->LastWrite();
+          }
+          size_t WriteAll(VALUE input)
+          {
+            if (TYPE(input) == T_STRING)
+            {
+              size_t size = RSTRING_LEN(input);
+              void* buffer = RSTRING_PTR(input);
+              if ($self->WriteAll(buffer, size))
+              {
+                return size;
+              }
+              return $self->LastWrite();
+            }
+            rb_raise(rb_eArgError, "Invalid value for 0; expected String");
+            return 0;
+          }
+          __HEREDOC
+        # for Write(wxInputStream&)
+        spec.map 'wxOutputStream&' => 'Wx::OutputStream' do
+          map_out code: '$result = self; wxUnusedVar($1);'
+        end
+        # type mappings for ctor and DetachStream/GetStream
+        spec.add_wrapper_code <<~__CODE
+          static WxRuby_ID ios_closed_id("closed?");
+          static WxRuby_ID ios_eof_id("eof");
+          static WxRuby_ID ios_read_id("read");
+          static WxRuby_ID ios_write_id("write");
+          static WxRuby_ID ios_seek_id("seek");
+          static WxRuby_ID ios_tell_id("tell");
+          static WxRuby_ID ios_flush_id("flush");
+          static WxRuby_ID ios_close_id("close");
+
+          // Mapping of wxStreamBase* to Ruby IO VALUE
+          WX_DECLARE_VOIDPTR_HASH_MAP(VALUE,
+                                      WXRBStreamBaseToRbValueHash);
+          static WXRBStreamBaseToRbValueHash Stream_Value_Map;
+
+          static void wxRuby_markRbStreams()
+          {
+            WXRBStreamBaseToRbValueHash::iterator it;
+            for( it = Stream_Value_Map.begin(); it != Stream_Value_Map.end(); ++it )
+            {
+              VALUE obj = it->second;
+              rb_gc_mark(obj);
+            }
+          }
+
+          static void wxRuby_RegisterStream(void* ptr, VALUE rbval)
+          {
+            Stream_Value_Map[ptr] = rbval;
+          }
+
+          static void wxRuby_UnregisterStream(void* ptr)
+          {
+            Stream_Value_Map.erase(ptr);
+          }
+
+          // Implementation for wxRubyInputStream
+          // Allows a ruby IO-like object to be treated as a wxInputStream
+          wxRubyInputStream::wxRubyInputStream(VALUE rb_io) 
+            : wxInputStream()
+          { 
+            m_rbio = rb_io; 
+            m_isIO = rb_obj_is_kind_of(m_rbio, rb_cIO);
+            m_isSeekable = m_isIO || (rb_respond_to(m_rbio, ios_seek_id()) && rb_respond_to(m_rbio, ios_tell_id()));
+            wxRuby_RegisterStream(this, m_rbio);
+          }
+          wxRubyInputStream::~wxRubyInputStream() 
+          {
+            wxRuby_UnregisterStream(this);
+          }
+        
+          wxFileOffset wxRubyInputStream::GetLength() const
+          {
+            if (!m_isSeekable) return wxInvalidOffset;
+
+            wxFileOffset curpos = this->OnSysTell();
+            wxFileOffset endpos = const_cast<wxRubyInputStream*> (this)->OnSysSeek(0, wxFromEnd);
+            const_cast<wxRubyInputStream*> (this)->OnSysSeek(curpos, wxFromStart);
+            return endpos;
+          }
+
+          bool wxRubyInputStream::CanRead() const 
+          {
+            return !( (m_isIO && RTEST(wxRuby_Funcall(m_rbio, ios_closed_id(),0))) || Eof() );
+          }
+          bool wxRubyInputStream::Eof() const 
+          {
+            return m_isIO ? RTEST(wxRuby_Funcall(m_rbio, ios_eof_id(), 0)) : wxInputStream::Eof();
+          }
+          bool wxRubyInputStream::IsSeekable() const { return m_isSeekable; }
+          bool wxRubyInputStream::IsOk() const
+          {
+            return wxInputStream::IsOk() && !(m_isIO && RTEST(wxRuby_Funcall(m_rbio, ios_closed_id(),0)));
+          }
+          size_t wxRubyInputStream::OnSysRead(void *buffer, size_t bufsize) 
+          {
+            VALUE read_data = wxRuby_Funcall(m_rbio, ios_read_id(), 
+                                             1, INT2NUM(bufsize));
+            if (NIL_P(read_data))
+            {
+              m_lasterror = wxSTREAM_EOF;
+              return 0;
+            }
+            memcpy(buffer, RSTRING_PTR(read_data), RSTRING_LEN(read_data));
+            return RSTRING_LEN(read_data);
+          }
+          wxFileOffset wxRubyInputStream::OnSysSeek(wxFileOffset seek, wxSeekMode mode)
+          {
+            if (!m_isSeekable) return wxInvalidOffset;
+            
+            // Seek mode integers happily coincide in Wx and Ruby
+            wxRuby_Funcall(m_rbio, ios_seek_id(), 2, 
+                           INT2NUM(seek), INT2NUM(mode));
+            return this->OnSysTell();
+          }
+          wxFileOffset wxRubyInputStream::OnSysTell() const
+          {
+            if (!m_isSeekable) return wxInvalidOffset;
+
+            return NUM2INT(wxRuby_Funcall(m_rbio, ios_tell_id(), 0));
+          }
+
+          // Implementation for wxRubyOutputStream
+          // Allows a ruby IO-like object to be used as a wxOutputStream
+          wxRubyOutputStream::wxRubyOutputStream(VALUE rb_io)
+            : wxOutputStream() 
+          { 
+            m_rbio = rb_io; 
+            m_isIO = rb_obj_is_kind_of(m_rbio, rb_cIO);
+            m_isSeekable = m_isIO || (rb_respond_to(m_rbio, ios_seek_id()) && rb_respond_to(m_rbio, ios_tell_id()));
+            wxRuby_RegisterStream(this, m_rbio);
+          }
+          wxRubyOutputStream::~wxRubyOutputStream() 
+          {
+            wxRuby_UnregisterStream(this);
+          }
+        
+          wxFileOffset wxRubyOutputStream::GetLength() const
+          {
+            if (!m_isSeekable) return wxInvalidOffset;
+
+            wxFileOffset curpos = this->OnSysTell();
+            wxFileOffset endpos = const_cast<wxRubyOutputStream*> (this)->OnSysSeek(0, wxFromEnd);
+            const_cast<wxRubyOutputStream*> (this)->OnSysSeek(curpos, wxFromStart);
+            return endpos;
+          }
+
+          void wxRubyOutputStream::Sync()
+          {
+            wxOutputStream::Sync();
+            if (m_isIO) wxRuby_Funcall(m_rbio, ios_flush_id(), 0);
+          }
+          bool wxRubyOutputStream::Close() 
+          {
+            if (m_isIO) wxRuby_Funcall(m_rbio, ios_close_id(), 0); // always returns nil
+            return true;
+          }
+          bool wxRubyOutputStream::IsSeekable() const { return m_isSeekable; }
+          bool wxRubyOutputStream::IsOk() const
+          {
+            return wxOutputStream::IsOk() && !(m_isIO && RTEST(wxRuby_Funcall(m_rbio, ios_closed_id(),0)));
+          }
+
+          size_t wxRubyOutputStream::OnSysWrite(const void *buffer, size_t size) 
+          {
+            VALUE write_data = rb_str_new((const char *)buffer, size);
+            VALUE ret_val = wxRuby_Funcall(m_rbio, ios_write_id(), 
+                                           1, write_data);
+            return NUM2INT(ret_val);
+          }
+          wxFileOffset wxRubyOutputStream::OnSysSeek(wxFileOffset seek, wxSeekMode mode)
+          {
+            if (!m_isSeekable) return wxInvalidOffset;
+            
+            // Seek mode integers happily coincide in Wx and Ruby
+            wxRuby_Funcall(m_rbio, ios_seek_id(), 2, 
+                           INT2NUM(seek), INT2NUM(mode));
+            return this->OnSysTell();
+          }
+          wxFileOffset wxRubyOutputStream::OnSysTell() const
+          {
+            if (!m_isSeekable) return wxInvalidOffset;
+            
+            return NUM2INT(wxRuby_Funcall(m_rbio, ios_tell_id(), 0));
+          }
+
+          WXRUBY_EXPORT bool wxRuby_IsInputStream(VALUE rbis)
+          {
+            swig_class *sklass = (swig_class *)SWIGTYPE_p_wxInputStream->clientdata;
+            return (TYPE(rbis) == T_DATA && rb_obj_is_kind_of(rbis, sklass->klass));
+          }
+
+          WXRUBY_EXPORT bool wxRuby_IsCompatibleInput(VALUE rbis)
+          {
+            return rb_obj_is_kind_of(rbis, rb_cIO) || 
+              (!wxRuby_IsInputStream(rbis) && rb_respond_to(rbis, ios_read_id()));
+          }
+          
+          WXRUBY_EXPORT wxInputStream* wxRuby_RubyToInputStream(VALUE rbis)
+          {
+            if (wxRuby_IsInputStream(rbis))
+            {
+              void *ptr;
+              Data_Get_Struct(rbis, void, ptr);
+              return static_cast<wxInputStream*>(ptr);
+            }
+            return 0;
+          }
+
+          WXRUBY_EXPORT VALUE wxRuby_RubyFromInputStream(wxInputStream& is)
+          {
+            wxRubyInputStream* ris = dynamic_cast<wxRubyInputStream*> (&is);
+            if (ris)
+            {
+              return ris->GetRubyIO();
+            }
+            else
+            {
+              return SWIG_Ruby_NewPointerObj(&is, SWIGTYPE_p_wxInputStream, 0);
+            }
+          }
+
+          WXRUBY_EXPORT bool wxRuby_IsOutputStream(VALUE rbos)
+          {
+            swig_class *sklass = (swig_class *)SWIGTYPE_p_wxOutputStream->clientdata;
+            return (TYPE(rbos) == T_DATA && rb_obj_is_kind_of(rbos, sklass->klass));
+          }
+
+          WXRUBY_EXPORT bool wxRuby_IsCompatibleOutput(VALUE rbos)
+          {
+            return rb_obj_is_kind_of(rbos, rb_cIO) || 
+              (!wxRuby_IsOutputStream(rbos) && rb_respond_to(rbos, ios_write_id()));
+          }
+          
+          WXRUBY_EXPORT wxOutputStream* wxRuby_RubyToOutputStream(VALUE rbos)
+          {
+            if (wxRuby_IsOutputStream(rbos))
+            {
+              void *ptr;
+              Data_Get_Struct(rbos, void, ptr);
+              return static_cast<wxOutputStream*>(ptr);
+            }
+            return 0;
+          }
+
+          WXRUBY_EXPORT VALUE wxRuby_RubyFromOutputStream(wxOutputStream& os)
+          {
+            wxRubyOutputStream* ros = dynamic_cast<wxRubyOutputStream*> (&os);
+            if (ros)
+            {
+              return ros->GetRubyIO();
+            }
+            else
+            {
+              return SWIG_Ruby_NewPointerObj(&os, SWIGTYPE_p_wxOutputStream, 0);
+            }
+          }
+          __CODE
+        spec.add_init_code 'wxRuby_AppendMarker(wxRuby_markRbStreams);'
+      end
+
+    end # class FSFile
+
+  end # class Director
+
+end # module WXRuby3