wxruby3 1.7.0 → 1.8.1

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

@@ -0,0 +1,104 @@
+// Copyright (c) 2023 M.J.N. Corino, The Netherlands
+//
+// This software is released under the MIT license.
+
+#ifndef _WXRUBY_SHAREDPTR_H_
+#define _WXRUBY_SHAREDPTR_H_
+
+/*
+  A shared pointer class to wrap wxSharedPtr for derived classes and allowing implicit
+  conversion to wxSharedPtr without loosing reference counting and implicit down casting.
+*/
+#include <wx/sharedptr.h>
+
+template <class T, class Base = T>
+class WxRubySharedPtr
+{
+public:
+  typedef T* ptr_t;
+  typedef wxSharedPtr<Base> shared_ptr_t;
+
+  explicit WxRubySharedPtr( T* ptr = nullptr )
+    : shared_ptr_(ptr)
+  {
+  }
+
+  WxRubySharedPtr(const WxRubySharedPtr& other)
+    : shared_ptr_(other.get_shared())
+  {}
+
+  WxRubySharedPtr(WxRubySharedPtr&& other)
+    : shared_ptr_(std::move (other.get_shared()))
+  {}
+
+#if !defined(SWIG)
+  template<typename _Tp1, typename = typename
+    std::enable_if<std::is_convertible<typename _Tp1::ptr_t, T*>::value>::type>
+  WxRubySharedPtr(const _Tp1& other)
+    : shared_ptr_(other.get_shared())
+  {}
+
+  template<typename _Tp1, typename = typename
+    std::enable_if<std::is_convertible<typename _Tp1::ptr_t, T*>::value>::type>
+  WxRubySharedPtr(_Tp1&& other)
+    : shared_ptr_(std::move(other.get_shared()))
+  {}
+#endif
+
+  WxRubySharedPtr& operator=(const WxRubySharedPtr& other)
+  {
+    this->shared_ptr_ = other.get_shared();
+    return *this;
+  }
+
+  WxRubySharedPtr& operator=( T* ptr )
+  {
+    this->shared_ptr_ = ptr;
+    return *this;
+  }
+
+#if !defined(SWIG)
+  template<typename _Tp1, typename = typename
+    std::enable_if<std::is_convertible<typename _Tp1::ptr_t, T*>::value>::type>
+  WxRubySharedPtr& operator=(const _Tp1& other)
+  {
+    this->shared_ptr_ = other.get_shared();
+    return *this;
+  }
+#endif
+
+  T* operator->()
+  {
+    return const_cast<T*> (this->_get());
+  }
+
+  const T* operator->() const
+  {
+    return this->_get();
+  }
+
+  const T* get() const
+  {
+    return this->_get();
+  }
+
+  void reset( T* ptr = nullptr )
+  {
+    this->shared_ptr_.reset(ptr);
+  }
+
+  shared_ptr_t get_shared() const { return this->shared_ptr_; }
+
+  operator shared_ptr_t() const { return this->get_shared(); }
+
+private:
+
+  const T* _get() const
+  {
+    return dynamic_cast<const T*> (this->shared_ptr_.get());
+  }
+
+  shared_ptr_t shared_ptr_;
+};
+
+#endif

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

@@ -134,6 +134,35 @@ WXRUBY_EXPORT void wxRuby_AppendMarker(WXRBMarkFunction marker);
 WXRUBY_EXPORT VALUE wxRuby_GetTopLevelWindowClass(); // used for wxWindow typemap in typemap.i
 WXRUBY_EXPORT bool GC_IsWindowDeleted(void *ptr);
 
+WXRUBY_EXPORT bool GC_IsObjectOwned(VALUE object);
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+WXRUBY_EXPORT void wxRuby_InitializeTracking();
+WXRUBY_EXPORT void wxRuby_AddTracking(void* ptr, VALUE object);
+WXRUBY_EXPORT VALUE wxRuby_FindTracking(void* ptr);
+WXRUBY_EXPORT void wxRuby_RemoveTracking(void* ptr);
+WXRUBY_EXPORT void wxRuby_UnlinkObject(void* ptr);
+
+#ifdef __cplusplus
+}
+#endif
+
+#include <unordered_map>
+
+typedef std::unordered_map<void*, VALUE>  TGCTrackingValueMap;
+typedef void (* TGCMarkerFunction)(const TGCTrackingValueMap&);
+
+WXRUBY_EXPORT void wxRuby_RegisterTrackingCategory(std::string category, TGCMarkerFunction marker, bool has_data = false);
+WXRUBY_EXPORT void wxRuby_RegisterCategoryValue(const std::string &category, void *ptr, VALUE object);
+WXRUBY_EXPORT void wxRuby_UnregisterCategoryValue(const std::string &category, void *ptr);
+WXRUBY_EXPORT VALUE wxRuby_FindCategoryValue(const std::string &category, void *ptr);
+WXRUBY_EXPORT void wxRuby_UnlinkCategoryValue(const std::string &category, void* ptr);
+
+WXRUBY_EXPORT void wxRuby_MarkTracked();
+
 // Defined in wx.i; getting, setting and using swig_type <-> ruby class
 // mappings
 WXRUBY_EXPORT swig_type_info* wxRuby_GetSwigTypeForClass(VALUE cls);

data/ext/wxruby3/swig/custom/rubytracking.swg

@@ -15,47 +15,33 @@ extern "C" {
 #endif
 
 // Shared custom swig tracking functions
+WXRUBY_EXPORT void wxRuby_InitializeTracking();
 WXRUBY_EXPORT void wxRuby_AddTracking(void* ptr, VALUE object);
 WXRUBY_EXPORT VALUE wxRuby_FindTracking(void* ptr);
 WXRUBY_EXPORT void wxRuby_RemoveTracking(void* ptr);
-WXRUBY_EXPORT void wxRuby_IterateTracking( void(*meth)(void* ptr, VALUE obj) );
 
-/* Setup a Ruby hash table to store Trackings - mostly done in wx.i */
-SWIGRUNTIMEINLINE void SWIG_RubyInitializeTrackings(void) {
-  // no-op
-}
+/* Setup a Ruby hash table to store Trackings */
+#define SWIG_RubyInitializeTrackings()
 
 /* Add a Tracking from a C/C++ struct to a Ruby object */
-SWIGRUNTIMEINLINE void SWIG_RubyAddTracking(void* ptr, VALUE object) {
-  wxRuby_AddTracking(ptr, object);
-}
+#define SWIG_RubyAddTracking wxRuby_AddTracking
 
 /* Get the Ruby object that owns the specified C/C++ struct */
-SWIGRUNTIMEINLINE VALUE SWIG_RubyInstanceFor(void* ptr) {
-  return wxRuby_FindTracking(ptr);
-}
+#define SWIG_RubyInstanceFor wxRuby_FindTracking
 
 /* Remove a Tracking from a C/C++ struct to a Ruby object.  It
    is very important to remove objects once they are destroyed
    since the same memory address may be reused later to create
    a new object. */
-SWIGRUNTIMEINLINE void SWIG_RubyRemoveTracking(void* ptr) {
-  wxRuby_RemoveTracking(ptr);
-}
+#define SWIG_RubyRemoveTracking wxRuby_RemoveTracking
 
 /* This is a helper method that unlinks a Ruby object from its
    underlying C++ object.  This is needed if the lifetime of the
    Ruby object is longer than the C++ object */
-SWIGRUNTIMEINLINE void SWIG_RubyUnlinkObjects(void* ptr) {
-  VALUE object = SWIG_RubyInstanceFor(ptr);
-
-  if (object != Qnil) {
-    DATA_PTR(object) = 0;
-  }
-}
+#define SWIG_RubyUnlinkObjects wxRuby_UnlinkObject
 
 SWIGRUNTIMEINLINE void SWIG_RubyIterateTrackings( void(*meth)(void* ptr, VALUE obj) ) {
-  wxRuby_IterateTracking(meth);
+  // noop
 }
 
 

data/ext/wxruby3/swig/custom/wx_ruby_shared_ptr.i

@@ -0,0 +1,434 @@
+//Copyright (c) 2023 M.J.N. Corino, The Netherlands
+//
+// This software is released under the MIT license.
+
+#ifndef _WXRUBY_SHAREDPTR_H_
+#define _WXRUBY_SHAREDPTR_H_
+template <class T, class Base = T>
+class WxRubySharedPtr;
+#endif
+
+%header %{
+#include <wxruby-SharedPtr.h>
+%}
+
+// Main user macro for defining shared_ptr typemaps for both const and non-const pointer types
+%define %wx_ruby_shared_ptr(TYPE, BASE)
+%feature("smartptr", noblock=1) TYPE { WxRubySharedPtr< TYPE, BASE > }
+SWIG_WXRUBY_SHARED_PTR_TYPEMAPS(, TYPE, BASE)
+SWIG_WXRUBY_SHARED_PTR_TYPEMAPS(const, TYPE, BASE)
+%enddef
+
+%{
+#ifdef __cplusplus
+#ifndef SWIG_STD_MOVE
+#if __cplusplus >=201103L
+# define SWIG_STD_MOVE(OBJ) std::move(OBJ)
+#else
+# define SWIG_STD_MOVE(OBJ) OBJ
+#endif
+#endif
+#endif
+%}
+
+%{
+// Set WXSHARED_PTR_DISOWN to $disown if required, for example
+// #define WXSHARED_PTR_DISOWN $disown
+#if !defined(WXSHARED_PTR_DISOWN)
+#define WXSHARED_PTR_DISOWN 0
+#endif
+%}
+
+// Macro implementing all the customisations for handling the smart pointer
+%define SWIG_WXRUBY_SHARED_PTR_TYPEMAPS(CONST, TYPE, BASE)
+
+// %naturalvar is as documented for member variables
+%naturalvar TYPE;
+%naturalvar WxRubySharedPtr< CONST TYPE, CONST BASE >;
+
+// destructor wrapper customisation
+%feature("unref") TYPE
+  %{(void)arg1;
+    delete reinterpret_cast< WxRubySharedPtr< TYPE, BASE > * >(self);%}
+
+// Typemap customisations...
+
+// plain value
+%typemap(in) CONST TYPE (void *argp, int res = 0) {
+  swig_ruby_owntype newmem = {0, 0};
+  res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(WxRubySharedPtr< TYPE, BASE > *), %convertptr_flags, &newmem);
+  if (!SWIG_IsOK(res)) {
+    %argument_fail(res, "$type", $symname, $argnum);
+  }
+  if (!argp) {
+    %argument_nullref("$type", $symname, $argnum);
+  } else {
+    $1 = *(%reinterpret_cast(argp, WxRubySharedPtr< CONST TYPE, CONST BASE > *)->get());
+    if (newmem.own & SWIG_CAST_NEW_MEMORY) delete %reinterpret_cast(argp, WxRubySharedPtr< CONST TYPE, CONST BASE > *);
+  }
+}
+%typemap(out) CONST TYPE {
+  WxRubySharedPtr< CONST TYPE, CONST BASE > *smartresult = new WxRubySharedPtr< CONST TYPE, CONST BASE >(new $1_ltype($1));
+  %set_output(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(WxRubySharedPtr< TYPE, BASE > *), SWIG_POINTER_OWN));
+}
+
+%typemap(varin) CONST TYPE {
+  void *argp = 0;
+  swig_ruby_owntype newmem = {0, 0};
+  int res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(WxRubySharedPtr< TYPE, BASE > *), %convertptr_flags, &newmem);
+  if (!SWIG_IsOK(res)) {
+    %variable_fail(res, "$type", "$name");
+  }
+  if (!argp) {
+    %variable_nullref("$type", "$name");
+  } else {
+    $1 = *(%reinterpret_cast(argp, WxRubySharedPtr< CONST TYPE, CONST BASE > *)->get());
+    if (newmem.own & SWIG_CAST_NEW_MEMORY) delete %reinterpret_cast(argp, WxRubySharedPtr< CONST TYPE, CONST BASE > *);
+  }
+}
+%typemap(varout) CONST TYPE {
+  WxRubySharedPtr< CONST TYPE, CONST BASE > *smartresult = new WxRubySharedPtr< CONST TYPE, CONST BASE >(new $1_ltype($1));
+  %set_varoutput(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(WxRubySharedPtr< TYPE, BASE > *), SWIG_POINTER_OWN));
+}
+
+%typemap(directorin,noblock=1) CONST TYPE (WxRubySharedPtr< CONST TYPE, CONST BASE > *smartarg = 0) %{
+  smartarg = new WxRubySharedPtr< CONST TYPE, CONST BASE >(new $1_ltype(SWIG_STD_MOVE($1)));
+  $input = SWIG_NewPointerObj(%as_voidptr(smartarg), $descriptor(WxRubySharedPtr< TYPE, BASE > *), SWIG_POINTER_OWN | %newpointer_flags);
+%}
+%typemap(directorout,noblock=1) CONST TYPE (void *swig_argp, int swig_res = 0) {
+  swig_ruby_owntype newmem = {0, 0};
+  swig_res = SWIG_ConvertPtrAndOwn($input, &swig_argp, $descriptor(WxRubySharedPtr< TYPE, BASE > *), %convertptr_flags, &newmem);
+  if (!SWIG_IsOK(swig_res)) {
+    %dirout_fail(swig_res, "$type");
+  }
+  if (!swig_argp) {
+    %dirout_nullref("$type");
+  } else {
+    $result = *(%reinterpret_cast(swig_argp, WxRubySharedPtr< CONST TYPE, CONST BASE > *)->get());
+    if (newmem.own & SWIG_CAST_NEW_MEMORY) delete %reinterpret_cast(swig_argp, WxRubySharedPtr< CONST TYPE, CONST BASE > *);
+  }
+}
+
+// plain pointer
+// Note: $disown not implemented by default as it will lead to a memory leak of the shared_ptr instance
+%typemap(in) CONST TYPE * (void  *argp = 0, int res = 0, WxRubySharedPtr< CONST TYPE, CONST BASE > tempshared, WxRubySharedPtr< CONST TYPE, CONST BASE > *smartarg = 0) {
+  swig_ruby_owntype newmem = {0, 0};
+  res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(WxRubySharedPtr< TYPE, BASE > *), WXSHARED_PTR_DISOWN | %convertptr_flags, &newmem);
+  if (!SWIG_IsOK(res)) {
+    %argument_fail(res, "$type", $symname, $argnum);
+  }
+  if (newmem.own & SWIG_CAST_NEW_MEMORY) {
+    tempshared = *%reinterpret_cast(argp, WxRubySharedPtr< CONST TYPE, CONST BASE > *);
+    delete %reinterpret_cast(argp, WxRubySharedPtr< CONST TYPE, CONST BASE > *);
+    $1 = %const_cast(tempshared.get(), $1_ltype);
+  } else {
+    smartarg = %reinterpret_cast(argp, WxRubySharedPtr< CONST TYPE, CONST BASE > *);
+    $1 = %const_cast((smartarg ? smartarg->get() : 0), $1_ltype);
+  }
+}
+
+%typemap(out, fragment="SWIG_null_deleter") CONST TYPE * {
+  WxRubySharedPtr< CONST TYPE, CONST BASE > *smartresult = $1 ? new WxRubySharedPtr< CONST TYPE, CONST BASE >($1 SWIG_NO_NULL_DELETER_$owner) : 0;
+  %set_output(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(WxRubySharedPtr< TYPE, BASE > *), $owner | SWIG_POINTER_OWN));
+}
+
+%typemap(varin) CONST TYPE * {
+  void *argp = 0;
+  swig_ruby_owntype newmem = {0, 0};
+  int res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(WxRubySharedPtr< TYPE, BASE > *), %convertptr_flags, &newmem);
+  if (!SWIG_IsOK(res)) {
+    %variable_fail(res, "$type", "$name");
+  }
+  WxRubySharedPtr< CONST TYPE, CONST BASE > tempshared;
+  WxRubySharedPtr< CONST TYPE, CONST BASE > *smartarg = 0;
+  if (newmem.own & SWIG_CAST_NEW_MEMORY) {
+    tempshared = *%reinterpret_cast(argp, WxRubySharedPtr< CONST TYPE, CONST BASE > *);
+    delete %reinterpret_cast(argp, WxRubySharedPtr< CONST TYPE, CONST BASE > *);
+    $1 = %const_cast(tempshared.get(), $1_ltype);
+  } else {
+    smartarg = %reinterpret_cast(argp, WxRubySharedPtr< CONST TYPE, CONST BASE > *);
+    $1 = %const_cast((smartarg ? smartarg->get() : 0), $1_ltype);
+  }
+}
+%typemap(varout, fragment="SWIG_null_deleter") CONST TYPE * {
+  WxRubySharedPtr< CONST TYPE, CONST BASE > *smartresult = $1 ? new WxRubySharedPtr< CONST TYPE, CONST BASE >($1 SWIG_NO_NULL_DELETER_0) : 0;
+  %set_varoutput(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(WxRubySharedPtr< TYPE, BASE > *), SWIG_POINTER_OWN));
+}
+
+%typemap(directorin,noblock=1, fragment="SWIG_null_deleter") CONST TYPE * (WxRubySharedPtr< CONST TYPE, CONST BASE > *smartarg = 0) %{
+  smartarg = $1 ? new WxRubySharedPtr< CONST TYPE, CONST BASE >($1 SWIG_NO_NULL_DELETER_0) : 0;
+  $input = SWIG_NewPointerObj(%as_voidptr(smartarg), $descriptor(WxRubySharedPtr< TYPE, BASE > *), SWIG_POINTER_OWN | %newpointer_flags);
+%}
+%typemap(directorout,noblock=1) CONST TYPE * %{
+#error "directorout typemap for plain pointer not implemented"
+%}
+
+// plain reference
+%typemap(in) CONST TYPE & (void  *argp = 0, int res = 0, WxRubySharedPtr< CONST TYPE, CONST BASE > tempshared) {
+  swig_ruby_owntype newmem = {0, 0};
+  res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(WxRubySharedPtr< TYPE, BASE > *), %convertptr_flags, &newmem);
+  if (!SWIG_IsOK(res)) {
+    %argument_fail(res, "$type", $symname, $argnum);
+  }
+  if (!argp) { %argument_nullref("$type", $symname, $argnum); }
+  if (newmem.own & SWIG_CAST_NEW_MEMORY) {
+    tempshared = *%reinterpret_cast(argp, WxRubySharedPtr< CONST TYPE, CONST BASE > *);
+    delete %reinterpret_cast(argp, WxRubySharedPtr< CONST TYPE, CONST BASE > *);
+    $1 = %const_cast(tempshared.get(), $1_ltype);
+  } else {
+    $1 = %const_cast(%reinterpret_cast(argp, WxRubySharedPtr< CONST TYPE, CONST BASE > *)->get(), $1_ltype);
+  }
+}
+%typemap(out, fragment="SWIG_null_deleter") CONST TYPE & {
+  WxRubySharedPtr< CONST TYPE, CONST BASE > *smartresult = new WxRubySharedPtr< CONST TYPE, CONST BASE >($1 SWIG_NO_NULL_DELETER_$owner);
+  %set_output(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(WxRubySharedPtr< TYPE, BASE > *), SWIG_POINTER_OWN));
+}
+
+%typemap(varin) CONST TYPE & {
+  void *argp = 0;
+  swig_ruby_owntype newmem = {0, 0};
+  int res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(WxRubySharedPtr< TYPE, BASE > *), %convertptr_flags, &newmem);
+  if (!SWIG_IsOK(res)) {
+    %variable_fail(res, "$type", "$name");
+  }
+  WxRubySharedPtr< CONST TYPE, CONST BASE > tempshared;
+  if (!argp) {
+    %variable_nullref("$type", "$name");
+  }
+  if (newmem.own & SWIG_CAST_NEW_MEMORY) {
+    tempshared = *%reinterpret_cast(argp, WxRubySharedPtr< CONST TYPE, CONST BASE > *);
+    delete %reinterpret_cast(argp, WxRubySharedPtr< CONST TYPE, CONST BASE > *);
+    $1 = *%const_cast(tempshared.get(), $1_ltype);
+  } else {
+    $1 = *%const_cast(%reinterpret_cast(argp, WxRubySharedPtr< CONST TYPE, CONST BASE > *)->get(), $1_ltype);
+  }
+}
+%typemap(varout, fragment="SWIG_null_deleter") CONST TYPE & {
+  WxRubySharedPtr< CONST TYPE, CONST BASE > *smartresult = new WxRubySharedPtr< CONST TYPE, CONST BASE >(&$1 SWIG_NO_NULL_DELETER_0);
+  %set_varoutput(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(WxRubySharedPtr< TYPE, BASE > *), SWIG_POINTER_OWN));
+}
+
+%typemap(directorin,noblock=1, fragment="SWIG_null_deleter") CONST TYPE & (WxRubySharedPtr< CONST TYPE, CONST BASE > *smartarg = 0) %{
+  smartarg = new WxRubySharedPtr< CONST TYPE, CONST BASE >(&$1 SWIG_NO_NULL_DELETER_0);
+  $input = SWIG_NewPointerObj(%as_voidptr(smartarg), $descriptor(WxRubySharedPtr< TYPE, BASE > *), SWIG_POINTER_OWN | %newpointer_flags);
+%}
+%typemap(directorout,noblock=1) CONST TYPE & %{
+#error "directorout typemap for plain reference not implemented"
+%}
+
+// plain pointer by reference
+// Note: $disown not implemented by default as it will lead to a memory leak of the shared_ptr instance
+%typemap(in) TYPE *CONST& (void  *argp = 0, int res = 0, $*1_ltype temp = 0, WxRubySharedPtr< CONST TYPE, CONST BASE > tempshared) {
+  swig_ruby_owntype newmem = {0, 0};
+  res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(WxRubySharedPtr< TYPE, BASE > *), WXSHARED_PTR_DISOWN | %convertptr_flags, &newmem);
+  if (!SWIG_IsOK(res)) {
+    %argument_fail(res, "$type", $symname, $argnum);
+  }
+  if (newmem.own & SWIG_CAST_NEW_MEMORY) {
+    tempshared = *%reinterpret_cast(argp, WxRubySharedPtr< CONST TYPE, CONST BASE > *);
+    delete %reinterpret_cast(argp, WxRubySharedPtr< CONST TYPE, CONST BASE > *);
+    temp = %const_cast(tempshared.get(), $*1_ltype);
+  } else {
+    temp = %const_cast(%reinterpret_cast(argp, WxRubySharedPtr< CONST TYPE, CONST BASE > *)->get(), $*1_ltype);
+  }
+  $1 = &temp;
+}
+%typemap(out, fragment="SWIG_null_deleter") TYPE *CONST& {
+  WxRubySharedPtr< CONST TYPE, CONST BASE > *smartresult = *$1 ? new WxRubySharedPtr< CONST TYPE, CONST BASE >(*$1 SWIG_NO_NULL_DELETER_$owner) : 0;
+  %set_output(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(WxRubySharedPtr< TYPE, BASE > *), SWIG_POINTER_OWN));
+}
+
+%typemap(varin) TYPE *CONST& %{
+#error "varin typemap not implemented"
+%}
+%typemap(varout) TYPE *CONST& %{
+#error "varout typemap not implemented"
+%}
+
+%typemap(directorin,noblock=1, fragment="SWIG_null_deleter") TYPE *CONST& (WxRubySharedPtr< CONST TYPE, CONST BASE > *smartarg = 0) %{
+   smartarg = $1 ? new WxRubySharedPtr< CONST TYPE, CONST BASE >($1 SWIG_NO_NULL_DELETER_0) : 0;
+  $input = SWIG_NewPointerObj(%as_voidptr(smartarg), $descriptor(WxRubySharedPtr< TYPE, BASE > *), SWIG_POINTER_OWN | %newpointer_flags);
+%}
+%typemap(directorout,noblock=1) TYPE *CONST& %{
+#error "directorout typemap for plain pointer by reference not implemented"
+%}
+
+// shared_ptr by value
+%typemap(in) WxRubySharedPtr< CONST TYPE, CONST BASE > (void *argp, int res = 0) {
+  swig_ruby_owntype newmem = {0, 0};
+  res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(WxRubySharedPtr< TYPE, BASE > *), %convertptr_flags, &newmem);
+  if (!SWIG_IsOK(res)) {
+    %argument_fail(res, "$type", $symname, $argnum);
+  }
+  if (argp) $1 = *(%reinterpret_cast(argp, $&ltype));
+  if (newmem.own & SWIG_CAST_NEW_MEMORY) delete %reinterpret_cast(argp, $&ltype);
+}
+%typemap(out) WxRubySharedPtr< CONST TYPE, CONST BASE > {
+  WxRubySharedPtr< CONST TYPE, CONST BASE > *smartresult = $1 ? new WxRubySharedPtr< CONST TYPE, CONST BASE >($1) : 0;
+  %set_output(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(WxRubySharedPtr< TYPE, BASE > *), SWIG_POINTER_OWN));
+}
+
+%typemap(varin) WxRubySharedPtr< CONST TYPE, CONST BASE > {
+  swig_ruby_owntype newmem = {0, 0};
+  void *argp = 0;
+  int res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(WxRubySharedPtr< TYPE, BASE > *), %convertptr_flags, &newmem);
+  if (!SWIG_IsOK(res)) {
+    %variable_fail(res, "$type", "$name");
+  }
+  $1 = argp ? *(%reinterpret_cast(argp, $&ltype)) : WxRubySharedPtr< TYPE, BASE >();
+  if (newmem.own & SWIG_CAST_NEW_MEMORY) delete %reinterpret_cast(argp, $&ltype);
+}
+%typemap(varout) WxRubySharedPtr< CONST TYPE, CONST BASE > {
+  WxRubySharedPtr< CONST TYPE, CONST BASE > *smartresult = $1 ? new WxRubySharedPtr< CONST TYPE, CONST BASE >($1) : 0;
+  %set_varoutput(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(WxRubySharedPtr< TYPE, BASE > *), SWIG_POINTER_OWN));
+}
+
+%typemap(directorin,noblock=1) WxRubySharedPtr< CONST TYPE, CONST BASE > (WxRubySharedPtr< CONST TYPE, CONST BASE > *smartarg = 0) %{
+  smartarg = $1 ? new WxRubySharedPtr< CONST TYPE, CONST BASE >($1) : 0;
+  $input = SWIG_NewPointerObj(%as_voidptr(smartarg), $descriptor(WxRubySharedPtr< TYPE, BASE > *), SWIG_POINTER_OWN | %newpointer_flags);
+%}
+%typemap(directorout,noblock=1) WxRubySharedPtr< CONST TYPE, CONST BASE > (void *swig_argp, int swig_res = 0) {
+  swig_ruby_owntype newmem = {0, 0};
+  swig_res = SWIG_ConvertPtrAndOwn($input, &swig_argp, $descriptor(WxRubySharedPtr< TYPE, BASE > *), %convertptr_flags, &newmem);
+  if (!SWIG_IsOK(swig_res)) {
+    %dirout_fail(swig_res, "$type");
+  }
+  if (swig_argp) {
+    $result = *(%reinterpret_cast(swig_argp, $&ltype));
+    if (newmem.own & SWIG_CAST_NEW_MEMORY) delete %reinterpret_cast(swig_argp, $&ltype);
+  }
+}
+
+// shared_ptr by reference
+%typemap(in) WxRubySharedPtr< CONST TYPE, CONST BASE > & (void *argp, int res = 0, $*1_ltype tempshared) {
+  swig_ruby_owntype newmem = {0, 0};
+  res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(WxRubySharedPtr< TYPE, BASE > *), %convertptr_flags, &newmem);
+  if (!SWIG_IsOK(res)) {
+    %argument_fail(res, "$type", $symname, $argnum);
+  }
+  if (newmem.own & SWIG_CAST_NEW_MEMORY) {
+    if (argp) tempshared = *%reinterpret_cast(argp, $ltype);
+    delete %reinterpret_cast(argp, $ltype);
+    $1 = &tempshared;
+  } else {
+    $1 = (argp) ? %reinterpret_cast(argp, $ltype) : &tempshared;
+  }
+}
+%typemap(out) WxRubySharedPtr< CONST TYPE, CONST BASE > & {
+  WxRubySharedPtr< CONST TYPE, CONST BASE > *smartresult = *$1 ? new WxRubySharedPtr< CONST TYPE, CONST BASE >(*$1) : 0;
+  %set_output(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(WxRubySharedPtr< TYPE, BASE > *), SWIG_POINTER_OWN));
+}
+
+%typemap(varin) WxRubySharedPtr< CONST TYPE, CONST BASE > & %{
+#error "varin typemap not implemented"
+%}
+%typemap(varout) WxRubySharedPtr< CONST TYPE, CONST BASE > & %{
+#error "varout typemap not implemented"
+%}
+
+%typemap(directorin,noblock=1) WxRubySharedPtr< CONST TYPE, CONST BASE > & (WxRubySharedPtr< CONST TYPE, CONST BASE > *smartarg = 0) %{
+  smartarg = $1 ? new WxRubySharedPtr< CONST TYPE, CONST BASE >($1) : 0;
+  $input = SWIG_NewPointerObj(%as_voidptr(smartarg), $descriptor(WxRubySharedPtr< TYPE, BASE > *), SWIG_POINTER_OWN | %newpointer_flags);
+%}
+%typemap(directorout,noblock=1) WxRubySharedPtr< CONST TYPE, CONST BASE > & %{
+#error "directorout typemap for shared_ptr ref not implemented"
+%}
+
+// shared_ptr by pointer
+%typemap(in) WxRubySharedPtr< CONST TYPE, CONST BASE > * (void *argp, int res = 0, $*1_ltype tempshared) {
+  swig_ruby_owntype newmem = {0, 0};
+  res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(WxRubySharedPtr< TYPE, BASE > *), %convertptr_flags, &newmem);
+  if (!SWIG_IsOK(res)) {
+    %argument_fail(res, "$type", $symname, $argnum);
+  }
+  if (newmem.own & SWIG_CAST_NEW_MEMORY) {
+    if (argp) tempshared = *%reinterpret_cast(argp, $ltype);
+    delete %reinterpret_cast(argp, $ltype);
+    $1 = &tempshared;
+  } else {
+    $1 = (argp) ? %reinterpret_cast(argp, $ltype) : &tempshared;
+  }
+}
+%typemap(out) WxRubySharedPtr< CONST TYPE, CONST BASE > * {
+  WxRubySharedPtr< CONST TYPE, CONST BASE > *smartresult = ($1 && *$1) ? new WxRubySharedPtr< CONST TYPE, CONST BASE >(*$1) : 0;
+  %set_output(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(WxRubySharedPtr< TYPE, BASE > *), SWIG_POINTER_OWN));
+  if ($owner) delete $1;
+}
+
+%typemap(varin) WxRubySharedPtr< CONST TYPE, CONST BASE > * %{
+#error "varin typemap not implemented"
+%}
+%typemap(varout) WxRubySharedPtr< CONST TYPE, CONST BASE > * %{
+#error "varout typemap not implemented"
+%}
+
+%typemap(directorin,noblock=1) WxRubySharedPtr< CONST TYPE, CONST BASE > * (WxRubySharedPtr< CONST TYPE, CONST BASE > *smartarg = 0) %{
+  smartarg = ($1 && *$1) ? new WxRubySharedPtr< CONST TYPE, CONST BASE >(*$1) : 0;
+  $input = SWIG_NewPointerObj(%as_voidptr(smartarg), $descriptor(WxRubySharedPtr< TYPE, BASE > *), SWIG_POINTER_OWN | %newpointer_flags);
+%}
+%typemap(directorout,noblock=1) WxRubySharedPtr< CONST TYPE, CONST BASE > * %{
+#error "directorout typemap for pointer to shared_ptr not implemented"
+%}
+
+// shared_ptr by pointer reference
+%typemap(in) WxRubySharedPtr< CONST TYPE, CONST BASE > *& (void *argp, int res = 0, WxRubySharedPtr< CONST TYPE, CONST BASE > tempshared, $*1_ltype temp = 0) {
+  swig_ruby_owntype newmem = {0, 0};
+  res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(WxRubySharedPtr< TYPE, BASE > *), %convertptr_flags, &newmem);
+  if (!SWIG_IsOK(res)) {
+    %argument_fail(res, "$type", $symname, $argnum);
+  }
+  if (argp) tempshared = *%reinterpret_cast(argp, $*ltype);
+  if (newmem.own & SWIG_CAST_NEW_MEMORY) delete %reinterpret_cast(argp, $*ltype);
+  temp = &tempshared;
+  $1 = &temp;
+}
+%typemap(out) WxRubySharedPtr< CONST TYPE, CONST BASE > *& {
+  WxRubySharedPtr< CONST TYPE, CONST BASE > *smartresult = (*$1 && **$1) ? new WxRubySharedPtr< CONST TYPE, CONST BASE >(**$1) : 0;
+  %set_output(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(WxRubySharedPtr< TYPE, BASE > *), SWIG_POINTER_OWN));
+}
+
+%typemap(varin) WxRubySharedPtr< CONST TYPE, CONST BASE > *& %{
+#error "varin typemap not implemented"
+%}
+%typemap(varout) WxRubySharedPtr< CONST TYPE, CONST BASE > *& %{
+#error "varout typemap not implemented"
+%}
+
+%typemap(directorin,noblock=1) WxRubySharedPtr< CONST TYPE, CONST BASE > *& (WxRubySharedPtr< CONST TYPE, CONST BASE > *smartarg = 0) %{
+  smartarg = ($1 && *$1) ? new WxRubySharedPtr< CONST TYPE, CONST BASE >(*$1) : 0;
+  $input = SWIG_NewPointerObj(%as_voidptr(smartarg), $descriptor(WxRubySharedPtr< TYPE, BASE > *), SWIG_POINTER_OWN | %newpointer_flags);
+%}
+%typemap(directorout,noblock=1) WxRubySharedPtr< CONST TYPE, CONST BASE > *& %{
+#error "directorout typemap for pointer ref to shared_ptr not implemented"
+%}
+
+// Typecheck typemaps
+// Note: SWIG_ConvertPtr with void ** parameter set to 0 instead of using SWIG_ConvertPtrAndOwn, so that the casting
+// function is not called thereby avoiding a possible smart pointer copy constructor call when casting up the inheritance chain.
+%typemap(typecheck, precedence=SWIG_TYPECHECK_POINTER, equivalent="TYPE *", noblock=1)
+                      TYPE CONST,
+                      TYPE CONST &,
+                      TYPE CONST *,
+                      TYPE *CONST&,
+                      WxRubySharedPtr< CONST TYPE, CONST BASE >,
+                      WxRubySharedPtr< CONST TYPE, CONST BASE > &,
+                      WxRubySharedPtr< CONST TYPE, CONST BASE > *,
+                      WxRubySharedPtr< CONST TYPE, CONST BASE > *& {
+  int res = SWIG_ConvertPtr($input, 0, $descriptor(WxRubySharedPtr< TYPE, BASE > *), 0);
+  $1 = SWIG_CheckState(res);
+}
+
+
+// various missing typemaps - If ever used (unlikely) ensure compilation error rather than runtime bug
+%typemap(in) CONST TYPE[], CONST TYPE[ANY], CONST TYPE (CLASS::*) %{
+#error "typemaps for $1_type not available"
+%}
+%typemap(out) CONST TYPE[], CONST TYPE[ANY], CONST TYPE (CLASS::*) %{
+#error "typemaps for $1_type not available"
+%}
+
+
+%template() WxRubySharedPtr< CONST TYPE, CONST BASE >;
+
+
+%enddef