wxruby3 0.9.0 → 0.9.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 59678c4c6766131dea4df3bb86f3b441bed72710a917b8d6b0372317f19569e5
-  data.tar.gz: f69f9a17c668284d05adc75adde8e8b5d054a3af261d4ffbf868777226d8e2fe
+  metadata.gz: 94bf5f5a3d4107e4a77c02971756de87b044c3d9edfbedd0b0aa0fe3e95e6ae7
+  data.tar.gz: 83d78771dde19401cbb0e5f915c7eb86903bf76357f1a1d0be4d10edf1f0d4a7
 SHA512:
-  metadata.gz: 8349245892666dd2af662e8239f5d2b5d36ba59938437b5c47376fb8222e88e659aefa67b6551f773e00900440402953550fd53b684193670a53fa3695ff9c34
-  data.tar.gz: 4a827aa4999b34da4a240908edd356435a4b117562ccb2d3b3bb54d5c9358c64ca65c61d78b22f25c3191648b691288e89b109fc6c9666bc22ceef36abe2e39c
+  metadata.gz: f1ac191dac02b350104d6336d38af941126056f30da9d2bffa12d480592216f0059f7cc1e22fa4020898a26faeffbc64d71df09eefd2b3329956c5e70a97b23b
+  data.tar.gz: '08d86fdf568ef0b67d76c670ccd108194342c7c0d97710419f7e98e0c852d8a863540aa3c320052237c27adf1c37f4d92a7c927fb827fcbbc5d05a73789e40e1'

data/.yardopts

@@ -3,6 +3,7 @@
 --charset UTF-8
 --markup markdown
 --readme README.md
+--asset assets
 --title "wxRuby3 API Documentation"
 --output-dir rdoc
 --protected

data/ext/wxruby3/include/wxRubyApp.h

@@ -0,0 +1,338 @@
+// Copyright (c) 2023 M.J.N. Corino, The Netherlands
+//
+// This software is released under the MIT license.
+
+#include <memory>
+
+/*
+ * WxRuby3 App class
+ */
+
+class wxRubyApp : public wxApp
+{
+private:
+  bool is_running_ = false;
+  VALUE self_ = Qnil;
+public:
+  static wxRubyApp* GetInstance () { return dynamic_cast<wxRubyApp*> (wxApp::GetInstance()); }
+
+  virtual ~wxRubyApp()
+  {
+#ifdef __WXTRACE__
+  std::wcout << "~wxRubyApp" << std::endl;
+#endif
+    // unlink
+    if (this->self_ != Qnil)
+    {
+      DATA_PTR(this->self_) = 0;
+    }
+    this->self_ = Qnil;
+  }
+
+  // special event handler for destruction of windows which is done
+  // automatically by wxWidgets. Tag the object as having been destroyed
+  // by WxWidgets.
+  void OnWindowDestroy(wxWindowDestroyEvent &event)
+  {
+    wxObject* wx_obj = event.GetEventObject();
+#ifdef __WXRB_DEBUG__
+    if (wxRuby_TraceLevel()>0)
+      std::wcout << "<= OnWindowDestroy [" << wx_obj << "]" << std::endl;
+#endif
+    GC_SetWindowDeleted((void *)wx_obj);
+    event.Skip();
+#ifdef __WXRB_DEBUG__
+    if (wxRuby_TraceLevel()>0)
+      std::wcout << "=> OnWindowDestroy [" << wx_obj << "]" << std::endl;
+#endif
+  }
+
+  bool IsRunning() const { return this->is_running_; }
+
+  // When ruby's garbage collection runs, if the app is still active, it
+  // cycles through all currently known SWIG objects and calls this
+  // function on each to preserve still active Wx::Windows, and also
+  // pending Wx::Events which have been queued from the Ruby side (the
+  // only sort of events that will be in the tracking hash.
+  static void markIterate(void* ptr, VALUE rb_obj)
+  {
+    // Check if it's a valid object (sometimes SWIG doesn't return what we're
+    // expecting), a descendant of Wx::Window (but not a Dialog), and if it has not yet been
+    // deleted by WxWidgets; if so, mark it.
+    if ( TYPE(rb_obj) == T_DATA )
+    {
+      if ( rb_obj_is_kind_of(rb_obj, wxRuby_GetWindowClass()) )
+      {
+        rb_gc_mark(rb_obj);
+      }
+      else if (rb_obj_is_kind_of(rb_obj, wxRuby_GetDefaultEventClass()) )
+        rb_gc_mark(rb_obj);
+    }
+    else if (TYPE(rb_obj) == T_ARRAY )
+    {
+      VALUE proc = rb_ary_entry(rb_obj, 0);
+      if (rb_obj_is_kind_of(proc, rb_cProc) || rb_obj_is_kind_of(proc, rb_cMethod))
+      {
+        // keep the async call alive
+        rb_gc_mark(rb_obj);
+      }
+    }
+  }
+
+  // Implements GC protection across wxRuby. Always called because
+  // Wx::THE_APP is a constant so always checked in GC mark phase.
+  static void mark_wxRubyApp(void *ptr)
+  {
+
+#ifdef __WXRB_DEBUG__
+    if (wxRuby_TraceLevel()>0)
+      std::wcout << "=== Starting App GC mark phase" << std::endl;
+#endif
+
+    // If the App has ended, the ruby object will have been unlinked from
+    // the C++ one; this implies that all Windows have already been destroyed
+    // so there is no point trying to mark them, and doing so may cause
+    // errors.
+    if ( !wxRubyApp::GetInstance() || !wxRubyApp::GetInstance()->IsRunning() )
+    {
+#ifdef __WXRB_DEBUG__
+      if (wxRuby_TraceLevel()>0)
+        std::wcout << "=== App not started yet or has ended, skipping mark phase" << std::endl;
+#endif
+      return;
+    }
+
+    // Mark any active (tracked) log target
+    wxLog* curLog = wxLog::GetActiveTarget();
+    VALUE rb_cur_log = wxRuby_FindTracking(curLog);
+    if (!NIL_P(rb_cur_log))
+    {
+      rb_gc_mark(rb_cur_log);
+    }
+
+    // Mark evt handler procs associated with live windows - see
+    // classes/EvtHandler.i
+    wxRuby_MarkProtectedEvtHandlerProcs();
+
+    // run registered markers
+    for (wxVector<WXRBMarkFunction>::iterator it = WXRuby_Mark_List.begin();
+          it != WXRuby_Mark_List.end() ;++it)
+    {
+      (*it) ();
+    }
+
+    // To do the main marking, primarily of Windows, iterate over SWIG's
+    // list of tracked objects
+    wxRuby_IterateTracking(&wxRubyApp::markIterate);
+
+#ifdef __WXRB_DEBUG__
+    if (wxRuby_TraceLevel()>0)
+      std::wcout << "=== App GC mark phase completed" << std::endl;
+#endif
+  }
+
+  // This is the method run when main_loop is called in Ruby
+  // wxEntry calls the C++ App::OnInit method
+  int main_loop()
+  {
+    int rc = 0;
+
+    // There should ever only be only a single App instance running
+    if (rb_const_defined(mWxCore, rb_intern("THE_APP")))
+    {
+      rb_raise(rb_eRuntimeError, "There is already another App instance running");
+      return -1;
+    }
+
+    // Set self reference and global THE_APP constant
+    this->self_ = SWIG_RubyInstanceFor(this);
+    rb_define_const(mWxCore, "THE_APP", this->self_);
+    // Also cache the Ruby App reference on the stack here as after
+    // wxEntry returns the C++ App instance will have been destroyed
+    // and we cannot reference it (or it's members) anymore
+    VALUE the_app = this->self_;
+
+    this->Connect(wxEVT_DESTROY,
+          wxWindowDestroyEventHandler(wxRubyApp::OnWindowDestroy));
+
+#ifdef __WXRB_DEBUG__
+    if (wxRuby_TraceLevel()>0)
+      std::wcout << "Calling wxEntry, this=" << this << std::endl;
+#endif
+
+    // collect ruby app name and arguments array
+    VALUE rb_args = rb_get_argv();
+    int argc = 1 + RARRAY_LEN(rb_args);
+    std::unique_ptr<char*[]> argv_safe = std::make_unique<char*[]> (argc);
+    VALUE sval = rb_gv_get("$0");
+    argv_safe[0] = StringValuePtr(sval);
+    for (int i=0; i<RARRAY_LEN(rb_args) ;++i)
+    {
+      sval = rb_ary_entry(rb_args, i);
+      argv_safe[1+i] = StringValuePtr(sval);
+    }
+    // there is no need to copy the strings as we only need them until
+    // wxEntry returns
+
+#ifdef __WXMSW__
+    wxApp::m_nCmdShow = SW_NORMAL;
+#endif
+    rc = wxEntry(argc, argv_safe.get());
+
+    /*
+      At this point the C++ wxRubyApp instance has been destroyed so take care NOT to reference
+      it or any of it's members anymore but only unroll the callstack.
+     */
+
+#ifdef __WXRB_DEBUG__
+    if (wxRuby_TraceLevel()>0)
+      std::wcout << "returned from wxEntry..." << std::endl;
+#endif
+    rb_gc_start();
+#ifdef __WXRB_DEBUG__
+    if (wxRuby_TraceLevel()>0)
+      std::wcout << "survived gc" << std::endl;
+#endif
+
+    rb_const_remove(mWxCore, rb_intern("THE_APP"));
+
+    VALUE exc = rb_iv_get(the_app, "@exception");
+    if (!NIL_P(exc))
+    {
+      rb_exc_raise(exc);
+    }
+    return rc;
+  }
+
+  // This method initializes the stock objects (Pens, Brushes, Fonts)
+  // before yielding to ruby by calling the App's on_init method.
+  // Note that as of wxWidget 2.8, the stock fonts in particular cannot
+  // be initialized any earlier than this without crashing
+  bool OnInit() override
+  {
+#ifdef __WXRB_DEBUG__
+    if (wxRuby_TraceLevel()>0)
+      std::wcout << "OnInit..." << std::endl;
+#endif
+
+    if (!wxApp::OnInit())
+      return false;
+
+    // Signal that we've started
+    this->is_running_ = true;
+    // Set up the GDI objects
+    Init_wxRubyStockObjects();
+    // Get the ruby representation of the App object, and call the
+    // ruby on_init method to set up the initial window state
+    bool ex_caught = false;
+    VALUE result  = wxRuby_Funcall(ex_caught, this->self_, rb_intern("on_ruby_init"), 0, 0);
+
+    if (ex_caught)
+    {
+#ifdef __WXRB_DEBUG__
+      wxRuby_PrintException(result);
+#endif
+      rb_iv_set(this->self_, "@exception", result);
+      result = Qfalse; // exit app
+    }
+
+    // If on_init return any (ruby) true value, signal to wxWidgets to
+    // enter the main event loop by returning true, else return false
+    // which will make wxWidgets exit.
+    if ( result == Qfalse || result == Qnil )
+    {
+      this->is_running_ = false;
+      return false;
+    }
+    else
+    {
+      return true;
+    }
+  }
+
+  int OnExit() override
+  {
+#ifdef __WXRB_DEBUG__
+    if (wxRuby_TraceLevel()>0)
+      std::wcout << "OnExit..." << std::endl;
+#endif
+
+    // Get the ruby representation of the App object, and call the
+    // ruby on_exit method (if any) for application level cleanup
+    ID on_exit_id = rb_intern("on_exit");
+    if (rb_funcall(this->self_, rb_intern("respond_to?"), 1, ID2SYM(on_exit_id)) == Qtrue)
+    {
+      bool ex_caught = false;
+      VALUE rc = wxRuby_Funcall(ex_caught, this->self_, on_exit_id, 0, 0);
+      if (ex_caught)
+      {
+#ifdef __WXRB_DEBUG__
+        wxRuby_PrintException(rc);
+#endif
+        rb_iv_set(this->self_, "@exception", rc);
+      }
+    }
+
+    // perform wxRuby cleanup
+    _wxRuby_Cleanup();
+
+    // execute base wxWidgets functionality
+    return this->wxApp::OnExit();
+  }
+
+  // actually implemented in ruby in classes/app.rb
+  virtual void OnAssertFailure(const wxChar *file, int line, const wxChar *func, const wxChar *cond, const wxChar *msg) override
+  {
+    if (rb_during_gc() || NIL_P(this->self_))
+    {
+      std::wcerr << file << "(" << line << "): ASSERT " << cond
+                 << (NIL_P(this->self_) ? " fired without THE_APP in " : " fired during GC phase in ")
+                 << func << "() with message [" << msg << "]" << std::endl;
+    }
+    else
+    {
+      VALUE obj0 = Qnil ;
+      VALUE obj1 = Qnil ;
+      VALUE obj2 = Qnil ;
+      VALUE obj3 = Qnil ;
+      VALUE obj4 = Qnil ;
+
+      obj0 = rb_str_new2((const char *)wxString(file).utf8_str());
+      obj1 = INT2NUM(line);
+      obj2 = rb_str_new2((const char *)wxString(func).utf8_str());
+      obj3 = rb_str_new2((const char *)wxString(cond).utf8_str());
+      obj4 = rb_str_new2((const char *)wxString(msg).utf8_str());
+      (void)wxRuby_Funcall(this->self_, rb_intern("on_assert_failure"), 5,obj0,obj1,obj2,obj3,obj4);
+    }
+  }
+
+  void _wxRuby_Cleanup()
+  {
+#ifdef __WXRB_DEBUG__
+    if (wxRuby_TraceLevel()>0)
+      std::wcout << "wxRuby_Cleanup..." << std::endl;
+#endif
+    // Note in a global variable that the App has ended, so that we
+    // can skip any GC marking later
+    this->is_running_ = false;
+
+    // if a Ruby implemented logger has been installed clean that up
+    // before we exit, otherwise let wxWidgets handle things
+    wxLog *oldlog = wxLog::GetActiveTarget();
+    if (wxRuby_FindTracking(oldlog) != Qnil)
+    {
+      oldlog = wxLog::SetActiveTarget(new wxLogStderr);
+    }
+    else
+    {
+      oldlog = 0;
+    }
+    SetTopWindow(0);
+    if ( oldlog )
+    {
+      SWIG_RubyUnlinkObjects(oldlog);
+      SWIG_RubyRemoveTracking(oldlog);
+      delete oldlog;
+    }
+  }
+};

data/ext/wxruby3/include/wxruby-Config.h

@@ -456,7 +456,7 @@ protected:
   }
 
 #ifdef wxHAS_LONG_LONG_T_DIFFERENT_FROM_LONG
-  virtual bool DoReadLongLong(const wxString& key, wxLongLong_t *pll) const
+  virtual bool DoReadLongLong(const wxString& key, wxLongLong_t *pll) const override
   {
     wxConfigPathChanger path(this, key);
 
@@ -487,7 +487,7 @@ protected:
   }
 #endif // wxHAS_LONG_LONG_T_DIFFERENT_FROM_LONG
 
-  virtual bool DoReadDouble(const wxString& key, double* val) const
+  virtual bool DoReadDouble(const wxString& key, double* val) const override
   {
     wxConfigPathChanger path(this, key);
 
@@ -517,7 +517,7 @@ protected:
     }
   }
 
-  virtual bool DoReadBool(const wxString& key, bool* val) const
+  virtual bool DoReadBool(const wxString& key, bool* val) const override
   {
     wxConfigPathChanger path(this, key);
 
@@ -637,7 +637,7 @@ protected:
   }
 
 #ifdef wxHAS_LONG_LONG_T_DIFFERENT_FROM_LONG
-  virtual bool DoWriteLongLong(const wxString& key, wxLongLong_t value)
+  virtual bool DoWriteLongLong(const wxString& key, wxLongLong_t value) override
   {
     wxConfigPathChanger     path(this, key);
     wxString                strName = path.Name();
@@ -675,7 +675,7 @@ protected:
   }
 #endif // wxHAS_LONG_LONG_T_DIFFERENT_FROM_LONG
 
-  virtual bool DoWriteDouble(const wxString& key, double value)
+  virtual bool DoWriteDouble(const wxString& key, double value) override
   {
     wxConfigPathChanger     path(this, key);
     wxString                strName = path.Name();
@@ -712,7 +712,7 @@ protected:
     return true;
   }
 
-  virtual bool DoWriteBool(const wxString& key, bool value)
+  virtual bool DoWriteBool(const wxString& key, bool value) override
   {
     wxConfigPathChanger     path(this, key);
     wxString                strName = path.Name();

data/ext/wxruby3/include/wxruby-runtime.h

@@ -62,6 +62,9 @@ WXRUBY_EXPORT bool GC_IsWindowDeleted(void *ptr);
 WXRUBY_EXPORT swig_type_info* wxRuby_GetSwigTypeForClass(VALUE cls);
 WXRUBY_EXPORT swig_type_info* wxRuby_GetSwigTypeForClassName(const char* clsname);
 WXRUBY_EXPORT void wxRuby_SetSwigTypeForClass(VALUE cls, swig_type_info* ty);
+// and wx class names -> Ruby class
+WXRUBY_EXPORT void wxRuby_SetRbClassForWxName(const wxString& wx_name, VALUE cls);
+WXRUBY_EXPORT VALUE wxRuby_GetRbClassForWxName(const wxString& wx_name);
 
 // Common wrapping functions
 WXRUBY_EXPORT VALUE wxRuby_WrapWxObjectInRuby(wxObject* obj);

data/ext/wxruby3/swig/common.i

@@ -13,6 +13,28 @@
 %feature("compactdefaultargs");
 %feature("flatnested");
 
+%exception {
+  try {
+    $action
+  }
+  catch (const Swig::DirectorException& swigex) {
+    if (rb_obj_is_kind_of(swigex.getError(), rb_eException))
+    {
+      rb_exc_raise(swigex.getError());
+    }
+    else
+    {
+      rb_exc_raise(rb_exc_new_cstr(swigex.getError(), swigex.what()));
+    }
+  }
+  catch (const std::exception& ex) {
+    rb_raise(rb_eRuntimeError, "Unexpected C++ exception: %s", ex.what());
+  }
+  catch (...) {
+    rb_raise(rb_eRuntimeError, "Unexpected UNKNOWN exception");
+  }
+}
+
 %begin %{
 /*
  * Since SWIG does not provide readily usable export macros