wxruby3 0.9.1 → 0.9.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8b5236fc5965ca7cb7f44f6ffa69c74af04529217c2ac85178b04b719781407c
-  data.tar.gz: 745d4f4b7b6168a764d47dfa640128666a57922bf90c9d43757a7726ae4d3c75
+  metadata.gz: 94bf5f5a3d4107e4a77c02971756de87b044c3d9edfbedd0b0aa0fe3e95e6ae7
+  data.tar.gz: 83d78771dde19401cbb0e5f915c7eb86903bf76357f1a1d0be4d10edf1f0d4a7
 SHA512:
-  metadata.gz: 613f0bce684a98834ddc99031b1dbe0cb4aa04448d8f88aa20dd1cf71c938d3539e0e26ec46a096373a83fc2c542f73d9163ca0e1be2428c3854a583f3e974da
-  data.tar.gz: 888271b35ed4a18bd776c8249ae5bc83ec51ec7930d1b58954e829da508ceb500fcf14e0340009a0410c2e009a5ffbf99109a5a22a447ca52b00982d722800e3
+  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/swig/common.i

@@ -24,7 +24,7 @@
     }
     else
     {
-      rb_raise(swigex.getError(), swigex.what());
+      rb_exc_raise(rb_exc_new_cstr(swigex.getError(), swigex.what()));
     }
   }
   catch (const std::exception& ex) {

data/lib/wx/aui/aui_tab_ctrl.rb

@@ -0,0 +1,18 @@
+# Copyright (c) 2023 M.J.N. Corino, The Netherlands
+#
+# This software is released under the MIT license.
+
+class Wx::AUI::AuiTabCtrl
+
+  # Convenience method for iterating pages
+  def each_page
+    if block_given?
+      0.upto(get_page_count - 1) do | i |
+        yield get_page(i)
+      end
+    else
+      ::Enumerator.new { |y| each_page { |pg| y << pg } }
+    end
+  end
+
+end

data/lib/wx/aui/auinotebook.rb

@@ -19,8 +19,12 @@ class Wx::AUI::AuiNotebook
 
   # Convenience method for iterating pages
   def each_page
-    0.upto(get_page_count - 1) do | i |
-      yield get_page(i)
+    if block_given?
+      0.upto(get_page_count - 1) do | i |
+        yield get_page(i)
+      end
+    else
+      ::Enumerator.new { |y| each_page { |pg| y << pg } }
     end
   end
 end

data/lib/wx/aui/require.rb

@@ -9,5 +9,6 @@ require_relative './events/evt_list'
 require_relative './auimanager'
 require_relative './auinotebook'
 require_relative './auifloatframe'
+require_relative './aui_tab_ctrl'
 
 Wx::Dialog.setup_dialog_functors(Wx::AUI)

data/lib/wx/core/app.rb

@@ -79,8 +79,8 @@ class Wx::App
   # WxRuby. Such messages usually indicate that the API is being used
   # incorrectly; the file/line reference points to the place in the
   # WxWidgets source code where the assertion was made.
-  define_method(:on_assert_failure) do | file, line, func, condition, message |
-    warn "Wx WARNING: #{message} (#{func}@#{file}:#{line})"
+  def on_assert_failure(file, line, func, condition, message)
+    warn %Q{Wx WARNING: ASSERT #{condition} fired with "#{message}" at (#{func}@#{file}:#{line})}
   end
 
   # For use in development only, of no practical use in production code.

data/lib/wx/core/collapsible_pane.rb

@@ -10,7 +10,7 @@
 
 module Wx
 
-  if Wx.has_feature?(:USE_COLLPANE) && (!Wx.has_feature?(:WXGTK20) || Wx.has_feature?(:WXUNIVERSAL))
+  if Wx.has_feature?(:USE_COLLPANE)
     
     GenericCollapsiblePane = CollapsiblePane
     

data/lib/wx/core/controlwithitems.rb

@@ -11,12 +11,14 @@
 
 class Wx::ControlWithItems
 
-  # Make these Ruby enumerables so find, find_all, map etc are available
-  include Enumerable
-
-  # Passes each valid item index into the passed block
-  def each
-    get_count.times { | i | yield i }
+  # Overload to provide Enumerator without block
+  wx_each_string = instance_method :each_string
+  define_method :each_string do |&block|
+    if block
+      wx_each_string.bind(self).call(&block)
+    else
+      ::Enumerator.new { |y| wx_each_string.bind(self).call { |ln| y << ln } }
+    end
   end
 
   # We need to cache client data in Ruby variables as we cannot access items

data/lib/wx/core/menu.rb

@@ -26,6 +26,16 @@ class Wx::Menu
     end
   end
 
+  # Overload to provide Enumerator without block
+  wx_each_item = instance_method :each_item
+  define_method :each_item do |&block|
+    if block
+      wx_each_item.bind(self).call(&block)
+    else
+      ::Enumerator.new { |y| wx_each_item.bind(self).call { |mi| y << mi } }
+    end
+  end
+
   # In the standard WxWidgets API, the methods append, prepend, insert
   # (and their variants) require a constant integer id as the identifier
   # of the menu item. This is then used in event handling. 

data/lib/wx/core/notebook.rb

@@ -11,8 +11,12 @@
 class Wx::Notebook
   # Convenience method for iterating pages
   def each_page
-    0.upto(get_page_count - 1) do | i |
-      yield get_page(i)
+    if block_given?
+      0.upto(get_page_count - 1) do | i |
+        yield get_page(i)
+      end
+    else
+      ::Enumerator.new { |y| each_page { |pg| y << pg } }
     end
   end
 end

data/lib/wx/core/sizer.rb

@@ -49,4 +49,15 @@ class Wx::Sizer
       insert(idx, *full_args)
     end
   end
+
+  # Overload to provide Enumerator without block
+  wx_each_child = instance_method :each_child
+  define_method :each_child do |&block|
+    if block
+      wx_each_child.bind(self).call(&block)
+    else
+      ::Enumerator.new { |y| wx_each_child.bind(self).call { |c| y << c } }
+    end
+  end
+
 end

data/lib/wx/core/task_bar_button.rb

@@ -0,0 +1,19 @@
+# Copyright (c) 2023 M.J.N. Corino, The Netherlands
+#
+# This software is released under the MIT license.
+
+
+module Wx
+
+  if Wx::PLATFORM == 'WXMSW'
+    class TaskBarButton
+
+      wx_remove_thumb_bar_button = instance_method :remove_thumb_bar_button
+      define_method :remove_thumb_bar_button do |button|
+        button = button.get_id if button.is_a?(Wx::ThumbBarButton)
+        wx_remove_thumb_bar_button.bind(self).call(button)
+      end
+
+    end
+  end
+end

data/lib/wx/core/textctrl.rb

@@ -59,10 +59,20 @@ module Wx
   class TextCtrl
     wx_op_append = instance_method :<<
     define_method :<< do |o|
-      wx_op_append.bind(self).call(o)
+      wx_op_append.bind(self).call(o.to_s)
       self
     end
 
+    # 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
+
     if Wx.has_feature?(:USE_SPELLCHECK)
 
       protected :do_enable_proof_check

data/lib/wx/core/{treectrl.rb → tree_ctrl.rb}

@@ -9,22 +9,41 @@
 # Hierarchical control with items
 
 class Wx::TreeCtrl
-  # Make these ruby enumerables so find, find_all, map etc are available
-  include Enumerable
+
+  # Overload to provide Enumerator without block
+  wx_traverse = instance_method :traverse
+  define_method :traverse do |start_id=nil, &block|
+    if block
+      wx_traverse.bind(self).call(start_id, &block)
+    else
+      ::Enumerator.new { |y| wx_traverse.bind(self).call(start_id) { |c| y << c } }
+    end
+  end
+
   # Iterate over all items
   alias :each :traverse
 
-  # Return the children of +parent+ as an array of TreeItemIDs.
-  def get_children(parent)
-    kids = []
-    kid, _ = get_first_child(parent)
-    return [] unless kid.ok?
-    kids << kid
-
-    while kid = get_next_sibling(kids.last) and kid.ok?
-      kids << kid
+  # Make these ruby enumerables so find, find_all, map etc are available
+  include Enumerable
+
+  # Iterate all children of parent_id
+  def each_item_child(parent_id, &block)
+    if block
+      rc = nil
+      child_id, cookie = get_first_child(parent_id)
+      while child_id && child_id.ok?
+        rc = block.call(child_id)
+        child_id, cookie = get_next_child(parent_id, cookie)
+      end
+      rc
+    else
+      ::Enumerator.new { |y| each_item_child(parent_id) { |child_id| y << child_id } }
     end
-    kids
+  end
+
+  # Return the children of +parent+ as an array of TreeItemIDs.
+  def get_item_children(parent_id)
+    each_item_child(parent_id).to_a
   end
 
   # Returns a Wx::Rect corresponding to the edges of an individual tree

data/lib/wx/core/window.rb

@@ -79,6 +79,16 @@ class Wx::Window
     end
   end
 
+  # Overload to provide Enumerator without block
+  wx_each_child = instance_method :each_child
+  define_method :each_child do |&block|
+    if block
+      wx_each_child.bind(self).call(&block)
+    else
+      ::Enumerator.new { |y| wx_each_child.bind(self).call { |c| y << c } }
+    end
+  end
+
   # implement non-static variants of these
 
   def from_dip(*args)