wxruby3 0.9.0 → 0.9.2

data/lib/wx/rtc/rich_text_ctrl.rb

@@ -0,0 +1,25 @@
+# Copyright (c) 2023 M.J.N. Corino, The Netherlands
+#
+# This software is released under the MIT license.
+
+module Wx
+
+  module RTC
+
+    class RichTextCtrl
+
+      # Overload to provide Enumerator without block
+      wx_each_line = instance_method :each_line
+      define_method :each_line do |&block|
+        if block
+          wx_each_line.bind(self).call(&block)
+        else
+          ::Enumerator.new { |y| wx_each_line.bind(self).call { |ln| y << ln } }
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/wx/rtc/rich_text_paragraph.rb

@@ -0,0 +1,25 @@
+# Copyright (c) 2023 M.J.N. Corino, The Netherlands
+#
+# This software is released under the MIT license.
+
+module Wx
+
+  module RTC
+
+    class RichTextParagraph
+
+      # Overload to provide Enumerator without block
+      wx_each_line = instance_method :each_line
+      define_method :each_line do |&block|
+        if block
+          wx_each_line.bind(self).call(&block)
+        else
+          ::Enumerator.new { |y| wx_each_line.bind(self).call { |ln| y << ln } }
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/wx/stc/require.rb

@@ -6,5 +6,6 @@
 
 require_relative './events/evt_list'
 require_relative './keyword_defs'
+require_relative './styled_text_ctrl'
 
 Wx::Dialog.setup_dialog_functors(Wx::STC)

data/lib/wx/stc/styled_text_ctrl.rb

@@ -0,0 +1,25 @@
+# Copyright (c) 2023 M.J.N. Corino, The Netherlands
+#
+# This software is released under the MIT license.
+
+module Wx
+
+  module STC
+
+    class StyledTextCtrl
+
+      # Overload to provide Enumerator without block
+      wx_each_line = instance_method :each_line
+      define_method :each_line do |&block|
+        if block
+          wx_each_line.bind(self).call(&block)
+        else
+          ::Enumerator.new { |y| wx_each_line.bind(self).call { |ln| y << ln } }
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/wx/version.rb

@@ -3,5 +3,5 @@
 # This software is released under the MIT license.
 
 module Wx
-  WXRUBY_VERSION    = '0.9.0'
+  WXRUBY_VERSION    = '0.9.2'
 end

data/rakelib/lib/config/linux.rb

@@ -65,9 +65,6 @@ module WXRuby3
           # create a .so binary
           @extra_ldflags << '-shared'
 
-          # This class is not available on linux ports (wxGTK/wxQT/wxX11/wxMotif)
-          exclude_module('wxPrinterDC')
-
           unless @wx_path.empty?
             libdirs = @wx_libs.select {|s| s.start_with?('-L')}.collect {|s| s.sub(/^-L/,'')}
             @exec_env['LD_LIBRARY_PATH'] = "#{ENV['LD_LIBRARY_PATH']}:#{dest_dir}:#{libdirs.join(':')}"

data/rakelib/lib/config/macosx.rb

@@ -65,7 +65,7 @@ module WXRuby3
               end
             end
             # some weird thing with this; at least sometimes '--libs all' will not output media library even if feature active
-            if features_set?('wxUSE_MEDIACTRL')
+            if features_set?('USE_MEDIACTRL')
               lib_list = wx_config("--libs media").split(' ')
               until lib_list.empty?
                 s = lib_list.shift

data/rakelib/lib/config/mingw.rb

@@ -35,7 +35,7 @@ module WXRuby3
           end
 
           def debug_command(*args)
-            args.unshift(FileUtils::RUBY)
+            args.unshift(nix_path(FileUtils::RUBY))
             args.unshift('--args')
             args.unshift('gdb')
             args.join(' ')

data/rakelib/lib/config/unixish.rb

@@ -136,7 +136,7 @@ module WXRuby3
         wx_libset = ::Set.new
         wx_libset.merge wx_config("--libs all").split(' ')
         # some weird thing with this; at least sometimes '--libs all' will not output media library even if feature active
-        if features_set?('wxUSE_MEDIACTRL')
+        if features_set?('USE_MEDIACTRL')
           wx_libset.merge wx_config("--libs media").split(' ')
         end
         wx_libset.collect { |s| s.dup }

data/rakelib/lib/config.rb

@@ -589,7 +589,7 @@ module WXRuby3
           private :any_feature_set?
 
           def features_set?(*featureset)
-            featureset.all? do |feature|
+            featureset.flatten.all? do |feature|
               if AnyOf === feature
                 any_feature_set?(*feature.features)
               else
@@ -615,9 +615,19 @@ module WXRuby3
           def _retrieve_features(wxwidgets_setup_h)
             features = {}
 
-            File.read(wxwidgets_setup_h).scan(/^\s*#define\s+(wx\w+|__\w+__)\s+([01])/) do | define |
-              features[$1] = $2.to_i.zero? ? false : true
-            end if is_configured? && wxwidgets_setup_h
+            if is_configured? && wxwidgets_setup_h
+              File.read(wxwidgets_setup_h).scan(/^\s*#define\s+(wx\w+|__\w+__)\s+([01])/) do | define |
+                feat_val = $2.to_i.zero? ? false : true
+                feat_id = $1.sub(/\Awx/i, '').gsub(/\A__|__\Z/, '')
+                features[feat_id] = feat_val
+              end
+              # make sure correct platform defines are included as well which will not be the case always
+              # (for example __WXMSW__ and __WXOSX__ are not in setup.h)
+              features['WXMSW'] = true if features['GNUWIN32']
+              features['WXOSX'] = true if features['DARWIN']
+              # prior to wxWidgets 3.3 this feature was not set for wxGTK builds
+              features['WXGTK'] = true if features['LINUX'] && !features['WXGTK'] && wx_port == :wxgtk
+            end
 
             features
           end

data/rakelib/lib/core/include/funcall.inc

@@ -11,18 +11,38 @@
 
 typedef VALUE (*RUBY_INVOKE_FUNC) (VALUE);
 
+VALUE rb_exc_set_backtrace(VALUE, VALUE);
+VALUE rb_get_backtrace(VALUE);
+
+namespace Swig
+{
+  class DirectorRubyException : public DirectorException
+  {
+  public:
+    DirectorRubyException(VALUE error, VALUE rcvr, ID fn_id)
+      : DirectorException(Qnil)
+    {
+      VALUE msg = rb_sprintf("Caught exception in SWIG director method for %s#%s", rb_class2name(CLASS_OF(rcvr)), rb_id2name(fn_id));
+      this->swig_msg = StringValuePtr(msg);
+      swig_error = rb_exc_new_str(rb_eRuntimeError, msg);
+      VALUE bt = rb_funcall(error, rb_intern("backtrace"), 0);
+      rb_funcall(swig_error, rb_intern("set_backtrace"), 1, bt);
+    }
+  };
+}
+
 class WXRuby_RBFuncall
 {
 public:
-  WXRuby_RBFuncall (ID fnid, bool abort_on_ex=true)
+  WXRuby_RBFuncall (ID fnid, bool throw_on_ex=true)
    : fn_id_ (fnid),
-     abort_on_ex_ (abort_on_ex),
+     throw_on_ex_ (throw_on_ex),
      ex_caught_ (false)
   {
   }
-  WXRuby_RBFuncall (const char* fn, bool abort_on_ex=true)
+  WXRuby_RBFuncall (const char* fn, bool throw_on_ex=true)
   : fn_id_ (rb_intern (fn)),
-    abort_on_ex_ (abort_on_ex),
+    throw_on_ex_ (throw_on_ex),
     ex_caught_ (false)
   {
   }
@@ -43,15 +63,18 @@ public:
 
   bool has_caught_exception () { return this->ex_caught_; }
 
-  VALUE get_exception () { return rb_gv_get ("$!"); }
+  VALUE get_exception () { return rb_errinfo(); }
 
   ID id () { return this->fn_id_; }
 
 protected:
   struct FuncArgs
   {
+    FuncArgs(VALUE rcvr) : receiver_(rcvr) {}
     virtual ~FuncArgs () {}
     virtual VALUE rb_invoke (ID fnid) const = 0;
+
+    VALUE receiver_;
   };
 
   VALUE _invoke (const FuncArgs& fa)
@@ -65,13 +88,11 @@ protected:
                                &invoke_state);
     if (invoke_state)
     {
-      if (this->abort_on_ex_)
+      if (this->throw_on_ex_)
       {
         // handle exception
         VALUE rexc = this->get_exception ();
-        VALUE msg = rb_eval_string ("$!.message+\"\\n\"+$!.backtrace.join(\"\\n\")");
-        const char *exc_name = rb_obj_classname(rexc);
-        wxLogFatalError("%s : %s", exc_name, StringValuePtr(msg));
+        throw Swig::DirectorRubyException(rexc, fa.receiver_, this->fn_id_);
       }
       else
       {
@@ -88,7 +109,7 @@ protected:
   struct FuncArgArray : public FuncArgs
   {
     FuncArgArray (VALUE rcvr, VALUE args)
-     : receiver_ (rcvr), args_ (args) {}
+     : FuncArgs (rcvr), args_ (args) {}
     virtual ~FuncArgArray () {}
 
     virtual VALUE rb_invoke (ID fnid) const
@@ -96,14 +117,13 @@ protected:
       return rb_apply (this->receiver_, fnid, this->args_);
     }
 
-    VALUE receiver_;
     VALUE args_;
   };
 
   struct FuncArgList : public FuncArgs
   {
     FuncArgList (VALUE rcvr, int argc, VALUE* args)
-     : receiver_ (rcvr), argc_ (argc), args_ (args) {}
+     : FuncArgs (rcvr), argc_ (argc), args_ (args) {}
     virtual ~FuncArgList () {}
 
     virtual VALUE rb_invoke (ID fnid) const
@@ -111,7 +131,6 @@ protected:
       return rb_funcall2 (this->receiver_, fnid, this->argc_, this->args_);
     }
 
-    VALUE receiver_;
     int argc_;
     VALUE* args_;
   };
@@ -138,7 +157,7 @@ protected:
 
 private:
   ID      fn_id_;
-  bool    abort_on_ex_;
+  bool    throw_on_ex_;
   bool    ex_caught_;
 };
 

data/rakelib/lib/core/include/swigdirector.inc

@@ -0,0 +1,384 @@
+// Copyright (c) 2023 M.J.N. Corino, The Netherlands
+//
+// This software is released under the MIT license.
+
+// SWIG director classes
+
+#include <string>
+#include <iostream>
+#include <exception>
+#include <map>
+
+namespace Swig
+{
+
+  /* memory handler */
+  struct WXRB_EXPORT_FLAG GCItem
+  {
+    virtual ~GCItem();
+
+    virtual swig_ruby_owntype get_own() const;
+  };
+
+  GCItem::~GCItem() {}
+
+  swig_ruby_owntype GCItem::get_own() const
+  {
+    swig_ruby_owntype own = {0, 0};
+    return own;
+  }
+
+  struct WXRB_EXPORT_FLAG GCItem_var
+  {
+    GCItem_var(GCItem *item = 0) : _item(item) {}
+
+    GCItem_var& operator=(GCItem *item);
+
+    ~GCItem_var()
+    {
+      delete _item;
+    }
+
+    GCItem *operator->() const
+    {
+      return _item;
+    }
+
+  private:
+    GCItem *_item;
+  };
+
+  GCItem_var& GCItem_var::operator=(GCItem *item)
+  {
+    GCItem *tmp = _item;
+    _item = item;
+    delete tmp;
+    return *this;
+  }
+
+  template <typename Type>
+  struct GCItem_T : GCItem
+  {
+    GCItem_T(Type *ptr) : _ptr(ptr) {}
+
+    virtual ~GCItem_T()
+    {
+      delete _ptr;
+    }
+
+  private:
+    Type *_ptr;
+  };
+
+  struct WXRB_EXPORT_FLAG GCItem_Object : GCItem
+  {
+    GCItem_Object(swig_ruby_owntype own) : _own(own) {}
+
+    virtual ~GCItem_Object() {}
+
+    swig_ruby_owntype get_own() const
+    {
+      return _own;
+    }
+
+  private:
+    swig_ruby_owntype _own;
+  };
+
+  template <typename Type>
+  struct GCArray_T : GCItem
+  {
+    GCArray_T(Type *ptr) : _ptr(ptr) {}
+
+    virtual ~GCArray_T()
+    {
+      delete[] _ptr;
+    }
+
+  private:
+    Type *_ptr;
+  };
+
+  /* body args */
+  struct body_args
+  {
+    VALUE recv;
+    ID id;
+    int argc;
+    VALUE *argv;
+  };
+
+  /* Base class for director exceptions */
+  class WXRB_EXPORT_FLAG DirectorException : public std::exception
+  {
+  protected:
+    VALUE swig_error;
+    std::string swig_msg;
+  protected:
+    DirectorException(VALUE error) : swig_error(error) {}
+
+    DirectorException(VALUE error, const char *hdr, const char *msg ="");
+
+    void setup_error(VALUE error);
+
+  public:
+    virtual ~DirectorException() throw();
+
+    VALUE getType() const
+    {
+      return CLASS_OF(swig_error);
+    }
+
+    VALUE getError() const
+    {
+      return swig_error;
+    }
+
+    /* Deprecated, use what() instead */
+    const std::string& getMessage() const
+    {
+      return swig_msg;
+    }
+
+    const char *what() const throw()
+    {
+      return swig_msg.c_str();
+    }
+  };
+
+  DirectorException::DirectorException(VALUE error, const char *hdr, const char *msg)
+    : swig_msg(hdr)
+  {
+    if (msg[0])
+    {
+      swig_msg += " ";
+      swig_msg += msg;
+    }
+    this->setup_error(error);
+  }
+
+  DirectorException::~DirectorException() throw()
+  {}
+
+
+  void DirectorException::setup_error(VALUE error)
+  {
+    if (swig_msg.size())
+    {
+      VALUE str = rb_str_new(swig_msg.data(), swig_msg.size());
+      swig_error = rb_exc_new3(error, str);
+    }
+    else
+    {
+      swig_error = error;
+    }
+  }
+
+  /* Type mismatch in the return value from a Ruby method call */
+  class WXRB_EXPORT_FLAG DirectorTypeMismatchException : public DirectorException
+  {
+  public:
+    DirectorTypeMismatchException(VALUE error, const char *msg="")
+      : DirectorException(error, "SWIG director type mismatch", msg)
+    {}
+
+    DirectorTypeMismatchException(const char *msg="")
+      : DirectorException(rb_eTypeError, "SWIG director type mismatch", msg)
+    {}
+
+    DirectorTypeMismatchException(VALUE self, const char *method, VALUE error, const char *msg="");
+
+    static inline void raise(VALUE error, const char *msg)
+    {
+      throw DirectorTypeMismatchException(error, msg);
+    }
+
+    static inline void raise(const char *msg)
+    {
+      throw DirectorTypeMismatchException(msg);
+    }
+
+    static inline void raise(VALUE self, const char* method, VALUE error, const char *msg)
+    {
+      throw DirectorTypeMismatchException(self, method, error, msg);
+    }
+  };
+
+
+  DirectorTypeMismatchException::DirectorTypeMismatchException(VALUE self, const char *method, VALUE error, const char *msg)
+    : DirectorException(Qnil)
+  {
+    this->swig_msg = "SWIG director type mismatch ";
+    this->swig_msg += msg;
+    this->swig_msg += " returned from ";
+    this->swig_msg += rb_class2name(CLASS_OF(self));
+    this->swig_msg += "#";
+    this->swig_msg += method;
+    this->setup_error(rb_eTypeError);
+  }
+
+  /* Any Ruby exception that occurs during a director method call */
+  class WXRB_EXPORT_FLAG DirectorMethodException : public DirectorException
+  {
+  public:
+    DirectorMethodException(VALUE error)
+      : DirectorException(error)
+    {}
+
+    DirectorMethodException(const char *msg = "")
+      : DirectorException(rb_eRuntimeError, "SWIG director method error.", msg)
+    {}
+
+    static void raise(VALUE error)
+    {
+      throw DirectorMethodException(error);
+    }
+  };
+
+  /* Attempted to call a pure virtual method via a director method */
+  class WXRB_EXPORT_FLAG DirectorPureVirtualException : public DirectorException
+  {
+  public:
+    DirectorPureVirtualException(const char *msg = "")
+      : DirectorException(rb_eRuntimeError, "SWIG director pure virtual method called", msg)
+    {}
+
+    static void raise(const char *msg)
+    {
+      throw DirectorPureVirtualException(msg);
+    }
+  };
+
+  /* Simple thread abstraction for pthreads on win32 */
+#ifdef __THREAD__
+# define __PTHREAD__
+# if defined(_WIN32) || defined(__WIN32__)
+#  define pthread_mutex_lock EnterCriticalSection
+#  define pthread_mutex_unlock LeaveCriticalSection
+#  define pthread_mutex_t CRITICAL_SECTION
+#  define SWIG_MUTEX_INIT(var) var
+# else
+#  include <pthread.h>
+#  define SWIG_MUTEX_INIT(var) var = PTHREAD_MUTEX_INITIALIZER
+# endif
+#endif
+
+#ifdef  __PTHREAD__
+  struct Guard
+  {
+    pthread_mutex_t *_mutex;
+
+    Guard(pthread_mutex_t &mutex) : _mutex(&mutex)
+    {
+      pthread_mutex_lock(_mutex);
+    }
+
+    ~Guard()
+    {
+      pthread_mutex_unlock(_mutex);
+    }
+  };
+# define SWIG_GUARD(mutex) Guard _guard(mutex)
+#else
+# define SWIG_GUARD(mutex)
+#endif
+
+  /* director base class */
+  class WXRB_EXPORT_FLAG Director
+  {
+  private:
+    /* pointer to the wrapped Ruby object */
+    VALUE swig_self;
+    /* flag indicating whether the object is owned by Ruby or c++ */
+    mutable bool swig_disown_flag;
+
+  public:
+    /* wrap a Ruby object. */
+    Director(VALUE self);
+
+    /* discard our reference at destruction */
+    virtual ~Director();
+
+    /* return a pointer to the wrapped Ruby object */
+    VALUE swig_get_self() const
+    {
+      return swig_self;
+    }
+
+    /* acquire ownership of the wrapped Ruby object (the sense of "disown" is from Ruby) */
+    void swig_disown() const
+    {
+      if (!swig_disown_flag)
+      {
+        swig_disown_flag = true;
+      }
+    }
+
+  /* ownership management */
+  private:
+    typedef std::map<void *, GCItem_var> swig_ownership_map;
+    mutable swig_ownership_map swig_owner;
+#ifdef __PTHREAD__
+    static pthread_mutex_t swig_mutex_own;
+#endif
+
+  public:
+    template <typename Type>
+    void swig_acquire_ownership_array(Type *vptr) const
+    {
+      if (vptr)
+      {
+        SWIG_GUARD(swig_mutex_own);
+        swig_owner[vptr] = new GCArray_T<Type>(vptr);
+      }
+    }
+
+    template <typename Type>
+    void swig_acquire_ownership(Type *vptr)  const
+    {
+      if (vptr)
+      {
+        SWIG_GUARD(swig_mutex_own);
+        swig_owner[vptr] = new GCItem_T<Type>(vptr);
+      }
+    }
+
+    void swig_acquire_ownership_obj(void *vptr, swig_ruby_owntype own) const;
+
+    swig_ruby_owntype swig_release_ownership(void *vptr) const;
+  };
+
+  Director::Director(VALUE self)
+    : swig_self(self), swig_disown_flag(false)
+  {}
+
+  /* discard our reference at destruction */
+  Director::~Director()
+  {}
+
+  void Director::swig_acquire_ownership_obj(void *vptr, swig_ruby_owntype own) const
+  {
+    if (vptr && own.datafree)
+    {
+      SWIG_GUARD(swig_mutex_own);
+      swig_owner[vptr] = new GCItem_Object(own);
+    }
+  }
+
+  swig_ruby_owntype Director::swig_release_ownership(void *vptr) const
+  {
+    swig_ruby_owntype own = {0, 0};
+    if (vptr)
+    {
+      SWIG_GUARD(swig_mutex_own);
+      swig_ownership_map::iterator iter = swig_owner.find(vptr);
+      if (iter != swig_owner.end())
+      {
+        own.datafree = iter->second->get_own().datafree;
+        swig_owner.erase(iter);
+      }
+    }
+    return own;
+  }
+
+}