wxruby3 1.7.0 → 1.8.0

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

@@ -0,0 +1,431 @@
+//Copyright (c) 2023 M.J.N. Corino, The Netherlands
+//
+// This software is released under the MIT license.
+
+#ifndef _WX_SHAREDPTR_H_
+#define _WX_SHAREDPTR_H_
+// wxSharedPtr stub definition to appease older versions of SWIG
+template <class T>
+class wxSharedPtr;
+#endif
+
+// Main user macro for defining shared_ptr typemaps for both const and non-const pointer types
+%define %wx_shared_ptr(TYPE...)
+%feature("smartptr", noblock=1) TYPE { wxSharedPtr< TYPE > }
+SWIG_WXSHARED_PTR_TYPEMAPS(, TYPE)
+SWIG_WXSHARED_PTR_TYPEMAPS(const, TYPE)
+%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_WXSHARED_PTR_TYPEMAPS(CONST, TYPE...)
+
+// %naturalvar is as documented for member variables
+%naturalvar TYPE;
+%naturalvar wxSharedPtr< CONST TYPE >;
+
+// destructor wrapper customisation
+%feature("unref") TYPE
+  %{(void)arg1;
+    delete reinterpret_cast< wxSharedPtr< TYPE > * >(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(wxSharedPtr< TYPE > *), %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, wxSharedPtr< CONST TYPE > *)->get());
+    if (newmem.own & SWIG_CAST_NEW_MEMORY) delete %reinterpret_cast(argp, wxSharedPtr< CONST TYPE > *);
+  }
+}
+%typemap(out) CONST TYPE {
+  wxSharedPtr< CONST TYPE > *smartresult = new wxSharedPtr< CONST TYPE >(new $1_ltype($1));
+  %set_output(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(wxSharedPtr< TYPE > *), SWIG_POINTER_OWN));
+}
+
+%typemap(varin) CONST TYPE {
+  void *argp = 0;
+  swig_ruby_owntype newmem = {0, 0};
+  int res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(wxSharedPtr< TYPE > *), %convertptr_flags, &newmem);
+  if (!SWIG_IsOK(res)) {
+    %variable_fail(res, "$type", "$name");
+  }
+  if (!argp) {
+    %variable_nullref("$type", "$name");
+  } else {
+    $1 = *(%reinterpret_cast(argp, wxSharedPtr< CONST TYPE > *)->get());
+    if (newmem.own & SWIG_CAST_NEW_MEMORY) delete %reinterpret_cast(argp, wxSharedPtr< CONST TYPE > *);
+  }
+}
+%typemap(varout) CONST TYPE {
+  wxSharedPtr< CONST TYPE > *smartresult = new wxSharedPtr< CONST TYPE >(new $1_ltype($1));
+  %set_varoutput(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(wxSharedPtr< TYPE > *), SWIG_POINTER_OWN));
+}
+
+%typemap(directorin,noblock=1) CONST TYPE (wxSharedPtr< CONST TYPE > *smartarg = 0) %{
+  smartarg = new wxSharedPtr< CONST TYPE >(new $1_ltype(SWIG_STD_MOVE($1)));
+  $input = SWIG_NewPointerObj(%as_voidptr(smartarg), $descriptor(wxSharedPtr< TYPE > *), 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(wxSharedPtr< TYPE > *), %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, wxSharedPtr< CONST TYPE > *)->get());
+    if (newmem.own & SWIG_CAST_NEW_MEMORY) delete %reinterpret_cast(swig_argp, wxSharedPtr< CONST TYPE > *);
+  }
+}
+
+// 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, wxSharedPtr< CONST TYPE > tempshared, wxSharedPtr< CONST TYPE > *smartarg = 0) {
+  swig_ruby_owntype newmem = {0, 0};
+  res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(wxSharedPtr< TYPE > *), 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, wxSharedPtr< CONST TYPE > *);
+    delete %reinterpret_cast(argp, wxSharedPtr< CONST TYPE > *);
+    $1 = %const_cast(tempshared.get(), $1_ltype);
+  } else {
+    smartarg = %reinterpret_cast(argp, wxSharedPtr< CONST TYPE > *);
+    $1 = %const_cast((smartarg ? smartarg->get() : 0), $1_ltype);
+  }
+}
+
+%typemap(out, fragment="SWIG_null_deleter") CONST TYPE * {
+  wxSharedPtr< CONST TYPE > *smartresult = $1 ? new wxSharedPtr< CONST TYPE >($1 SWIG_NO_NULL_DELETER_$owner) : 0;
+  %set_output(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(wxSharedPtr< TYPE > *), $owner | SWIG_POINTER_OWN));
+}
+
+%typemap(varin) CONST TYPE * {
+  void *argp = 0;
+  swig_ruby_owntype newmem = {0, 0};
+  int res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(wxSharedPtr< TYPE > *), %convertptr_flags, &newmem);
+  if (!SWIG_IsOK(res)) {
+    %variable_fail(res, "$type", "$name");
+  }
+  wxSharedPtr< CONST TYPE > tempshared;
+  wxSharedPtr< CONST TYPE > *smartarg = 0;
+  if (newmem.own & SWIG_CAST_NEW_MEMORY) {
+    tempshared = *%reinterpret_cast(argp, wxSharedPtr< CONST TYPE > *);
+    delete %reinterpret_cast(argp, wxSharedPtr< CONST TYPE > *);
+    $1 = %const_cast(tempshared.get(), $1_ltype);
+  } else {
+    smartarg = %reinterpret_cast(argp, wxSharedPtr< CONST TYPE > *);
+    $1 = %const_cast((smartarg ? smartarg->get() : 0), $1_ltype);
+  }
+}
+%typemap(varout, fragment="SWIG_null_deleter") CONST TYPE * {
+  wxSharedPtr< CONST TYPE > *smartresult = $1 ? new wxSharedPtr< CONST TYPE >($1 SWIG_NO_NULL_DELETER_0) : 0;
+  %set_varoutput(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(wxSharedPtr< TYPE > *), SWIG_POINTER_OWN));
+}
+
+%typemap(directorin,noblock=1, fragment="SWIG_null_deleter") CONST TYPE * (wxSharedPtr< CONST TYPE > *smartarg = 0) %{
+  smartarg = $1 ? new wxSharedPtr< CONST TYPE >($1 SWIG_NO_NULL_DELETER_0) : 0;
+  $input = SWIG_NewPointerObj(%as_voidptr(smartarg), $descriptor(wxSharedPtr< TYPE > *), 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, wxSharedPtr< CONST TYPE > tempshared) {
+  swig_ruby_owntype newmem = {0, 0};
+  res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(wxSharedPtr< TYPE > *), %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, wxSharedPtr< CONST TYPE > *);
+    delete %reinterpret_cast(argp, wxSharedPtr< CONST TYPE > *);
+    $1 = %const_cast(tempshared.get(), $1_ltype);
+  } else {
+    $1 = %const_cast(%reinterpret_cast(argp, wxSharedPtr< CONST TYPE > *)->get(), $1_ltype);
+  }
+}
+%typemap(out, fragment="SWIG_null_deleter") CONST TYPE & {
+  wxSharedPtr< CONST TYPE > *smartresult = new wxSharedPtr< CONST TYPE >($1 SWIG_NO_NULL_DELETER_$owner);
+  %set_output(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(wxSharedPtr< TYPE > *), SWIG_POINTER_OWN));
+}
+
+%typemap(varin) CONST TYPE & {
+  void *argp = 0;
+  swig_ruby_owntype newmem = {0, 0};
+  int res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(wxSharedPtr< TYPE > *), %convertptr_flags, &newmem);
+  if (!SWIG_IsOK(res)) {
+    %variable_fail(res, "$type", "$name");
+  }
+  wxSharedPtr< CONST TYPE > tempshared;
+  if (!argp) {
+    %variable_nullref("$type", "$name");
+  }
+  if (newmem.own & SWIG_CAST_NEW_MEMORY) {
+    tempshared = *%reinterpret_cast(argp, wxSharedPtr< CONST TYPE > *);
+    delete %reinterpret_cast(argp, wxSharedPtr< CONST TYPE > *);
+    $1 = *%const_cast(tempshared.get(), $1_ltype);
+  } else {
+    $1 = *%const_cast(%reinterpret_cast(argp, wxSharedPtr< CONST TYPE > *)->get(), $1_ltype);
+  }
+}
+%typemap(varout, fragment="SWIG_null_deleter") CONST TYPE & {
+  wxSharedPtr< CONST TYPE > *smartresult = new wxSharedPtr< CONST TYPE >(&$1 SWIG_NO_NULL_DELETER_0);
+  %set_varoutput(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(wxSharedPtr< TYPE > *), SWIG_POINTER_OWN));
+}
+
+%typemap(directorin,noblock=1, fragment="SWIG_null_deleter") CONST TYPE & (wxSharedPtr< CONST TYPE > *smartarg = 0) %{
+  smartarg = new wxSharedPtr< CONST TYPE >(&$1 SWIG_NO_NULL_DELETER_0);
+  $input = SWIG_NewPointerObj(%as_voidptr(smartarg), $descriptor(wxSharedPtr< TYPE > *), 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, wxSharedPtr< CONST TYPE > tempshared) {
+  swig_ruby_owntype newmem = {0, 0};
+  res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(wxSharedPtr< TYPE > *), 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, wxSharedPtr< CONST TYPE > *);
+    delete %reinterpret_cast(argp, wxSharedPtr< CONST TYPE > *);
+    temp = %const_cast(tempshared.get(), $*1_ltype);
+  } else {
+    temp = %const_cast(%reinterpret_cast(argp, wxSharedPtr< CONST TYPE > *)->get(), $*1_ltype);
+  }
+  $1 = &temp;
+}
+%typemap(out, fragment="SWIG_null_deleter") TYPE *CONST& {
+  wxSharedPtr< CONST TYPE > *smartresult = *$1 ? new wxSharedPtr< CONST TYPE >(*$1 SWIG_NO_NULL_DELETER_$owner) : 0;
+  %set_output(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(wxSharedPtr< TYPE > *), 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& (wxSharedPtr< CONST TYPE > *smartarg = 0) %{
+   smartarg = $1 ? new wxSharedPtr< CONST TYPE >($1 SWIG_NO_NULL_DELETER_0) : 0;
+  $input = SWIG_NewPointerObj(%as_voidptr(smartarg), $descriptor(wxSharedPtr< TYPE > *), 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) wxSharedPtr< CONST TYPE > (void *argp, int res = 0) {
+  swig_ruby_owntype newmem = {0, 0};
+  res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(wxSharedPtr< TYPE > *), %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) wxSharedPtr< CONST TYPE > {
+  wxSharedPtr< CONST TYPE > *smartresult = $1 ? new wxSharedPtr< CONST TYPE >($1) : 0;
+  %set_output(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(wxSharedPtr< TYPE > *), SWIG_POINTER_OWN));
+}
+
+%typemap(varin) wxSharedPtr< CONST TYPE > {
+  swig_ruby_owntype newmem = {0, 0};
+  void *argp = 0;
+  int res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(wxSharedPtr< TYPE > *), %convertptr_flags, &newmem);
+  if (!SWIG_IsOK(res)) {
+    %variable_fail(res, "$type", "$name");
+  }
+  $1 = argp ? *(%reinterpret_cast(argp, $&ltype)) : wxSharedPtr< TYPE >();
+  if (newmem.own & SWIG_CAST_NEW_MEMORY) delete %reinterpret_cast(argp, $&ltype);
+}
+%typemap(varout) wxSharedPtr< CONST TYPE > {
+  wxSharedPtr< CONST TYPE > *smartresult = $1 ? new wxSharedPtr< CONST TYPE >($1) : 0;
+  %set_varoutput(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(wxSharedPtr< TYPE > *), SWIG_POINTER_OWN));
+}
+
+%typemap(directorin,noblock=1) wxSharedPtr< CONST TYPE > (wxSharedPtr< CONST TYPE > *smartarg = 0) %{
+  smartarg = $1 ? new wxSharedPtr< CONST TYPE >($1) : 0;
+  $input = SWIG_NewPointerObj(%as_voidptr(smartarg), $descriptor(wxSharedPtr< TYPE > *), SWIG_POINTER_OWN | %newpointer_flags);
+%}
+%typemap(directorout,noblock=1) wxSharedPtr< CONST TYPE > (void *swig_argp, int swig_res = 0) {
+  swig_ruby_owntype newmem = {0, 0};
+  swig_res = SWIG_ConvertPtrAndOwn($input, &swig_argp, $descriptor(wxSharedPtr< TYPE > *), %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) wxSharedPtr< CONST TYPE > & (void *argp, int res = 0, $*1_ltype tempshared) {
+  swig_ruby_owntype newmem = {0, 0};
+  res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(wxSharedPtr< TYPE > *), %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) wxSharedPtr< CONST TYPE > & {
+  wxSharedPtr< CONST TYPE > *smartresult = *$1 ? new wxSharedPtr< CONST TYPE >(*$1) : 0;
+  %set_output(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(wxSharedPtr< TYPE > *), SWIG_POINTER_OWN));
+}
+
+%typemap(varin) wxSharedPtr< CONST TYPE > & %{
+#error "varin typemap not implemented"
+%}
+%typemap(varout) wxSharedPtr< CONST TYPE > & %{
+#error "varout typemap not implemented"
+%}
+
+%typemap(directorin,noblock=1) wxSharedPtr< CONST TYPE > & (wxSharedPtr< CONST TYPE > *smartarg = 0) %{
+  smartarg = $1 ? new wxSharedPtr< CONST TYPE >($1) : 0;
+  $input = SWIG_NewPointerObj(%as_voidptr(smartarg), $descriptor(wxSharedPtr< TYPE > *), SWIG_POINTER_OWN | %newpointer_flags);
+%}
+%typemap(directorout,noblock=1) wxSharedPtr< CONST TYPE > & %{
+#error "directorout typemap for shared_ptr ref not implemented"
+%}
+
+// shared_ptr by pointer
+%typemap(in) wxSharedPtr< CONST TYPE > * (void *argp, int res = 0, $*1_ltype tempshared) {
+  swig_ruby_owntype newmem = {0, 0};
+  res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(wxSharedPtr< TYPE > *), %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) wxSharedPtr< CONST TYPE > * {
+  wxSharedPtr< CONST TYPE > *smartresult = ($1 && *$1) ? new wxSharedPtr< CONST TYPE >(*$1) : 0;
+  %set_output(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(wxSharedPtr< TYPE > *), SWIG_POINTER_OWN));
+  if ($owner) delete $1;
+}
+
+%typemap(varin) wxSharedPtr< CONST TYPE > * %{
+#error "varin typemap not implemented"
+%}
+%typemap(varout) wxSharedPtr< CONST TYPE > * %{
+#error "varout typemap not implemented"
+%}
+
+%typemap(directorin,noblock=1) wxSharedPtr< CONST TYPE > * (wxSharedPtr< CONST TYPE > *smartarg = 0) %{
+  smartarg = ($1 && *$1) ? new wxSharedPtr< CONST TYPE >(*$1) : 0;
+  $input = SWIG_NewPointerObj(%as_voidptr(smartarg), $descriptor(wxSharedPtr< TYPE > *), SWIG_POINTER_OWN | %newpointer_flags);
+%}
+%typemap(directorout,noblock=1) wxSharedPtr< CONST TYPE > * %{
+#error "directorout typemap for pointer to shared_ptr not implemented"
+%}
+
+// shared_ptr by pointer reference
+%typemap(in) wxSharedPtr< CONST TYPE > *& (void *argp, int res = 0, wxSharedPtr< CONST TYPE > tempshared, $*1_ltype temp = 0) {
+  swig_ruby_owntype newmem = {0, 0};
+  res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(wxSharedPtr< TYPE > *), %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) wxSharedPtr< CONST TYPE > *& {
+  wxSharedPtr< CONST TYPE > *smartresult = (*$1 && **$1) ? new wxSharedPtr< CONST TYPE >(**$1) : 0;
+  %set_output(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(wxSharedPtr< TYPE > *), SWIG_POINTER_OWN));
+}
+
+%typemap(varin) wxSharedPtr< CONST TYPE > *& %{
+#error "varin typemap not implemented"
+%}
+%typemap(varout) wxSharedPtr< CONST TYPE > *& %{
+#error "varout typemap not implemented"
+%}
+
+%typemap(directorin,noblock=1) wxSharedPtr< CONST TYPE > *& (wxSharedPtr< CONST TYPE > *smartarg = 0) %{
+  smartarg = ($1 && *$1) ? new wxSharedPtr< CONST TYPE >(*$1) : 0;
+  $input = SWIG_NewPointerObj(%as_voidptr(smartarg), $descriptor(wxSharedPtr< TYPE > *), SWIG_POINTER_OWN | %newpointer_flags);
+%}
+%typemap(directorout,noblock=1) wxSharedPtr< CONST TYPE > *& %{
+#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&,
+                      wxSharedPtr< CONST TYPE >,
+                      wxSharedPtr< CONST TYPE > &,
+                      wxSharedPtr< CONST TYPE > *,
+                      wxSharedPtr< CONST TYPE > *& {
+  int res = SWIG_ConvertPtr($input, 0, $descriptor(wxSharedPtr< TYPE > *), 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() wxSharedPtr< CONST TYPE >;
+
+
+%enddef

data/ext/wxruby3/swig/mark_free_impl.i

@@ -17,30 +17,16 @@
 
 %{
 WXRUBY_TRACE_GUARD(WxRubyTraceMarkSizer, "GC_MARK_SIZER")
-WXRUBY_TRACE_GUARD(WxRubyTraceFreeSizer, "GC_FREE_SIZER")
-WXRUBY_TRACE_GUARD(WxRubyTraceMarkMenubar, "GC_MARK_MENUBAR")
-WXRUBY_TRACE_GUARD(WxRubyTraceMarkMenu, "GC_MARK_MENU")
 WXRUBY_TRACE_GUARD(WxRubyTraceMarkWindow, "GC_MARK_WINDOW")
 WXRUBY_TRACE_GUARD(WxRubyTraceFreeWindow, "GC_FREE_WINDOW")
-WXRUBY_TRACE_GUARD(WxRubyTraceMarkFrame, "GC_MARK_FRAME")
-WXRUBY_TRACE_GUARD(WxRubyTraceFreeNull, "GC_FREE_NULL")
 WXRUBY_TRACE_GUARD(WxRubyTraceFreeRefcounted, "GC_FREE_REFCOUNT")
 
-
-// Code to be run when the ruby object is swept by GC - this only
-// unlinks the C++ object from the ruby VALUE but doesn't delete
-// it because it is still needed and will be managed by WxWidgets.
-WXRUBY_EXPORT void GcNullFreeFunc(void *ptr)
+// Check if a Ruby object is (still) Ruby GC managed in which case it's
+// 'dfree' function pointer should reference a specific free function
+// and not be either 0 or a reference to the SWIG tracking removal function.
+WXRUBY_EXPORT bool GC_IsObjectOwned(VALUE object)
 {
-  WXRUBY_TRACE_IF(WxRubyTraceFreeNull, 2)
-    WXRUBY_TRACE("> GcNullFreeFunc : " << ptr)
-  WXRUBY_TRACE_END
-
-  SWIG_RubyRemoveTracking(ptr);
-
-  WXRUBY_TRACE_IF(WxRubyTraceFreeNull, 2)
-    WXRUBY_TRACE("< GcNullFreeFunc")
-  WXRUBY_TRACE_END
+  return RDATA(object)->dfree != SWIG_RubyRemoveTracking && RDATA(object)->dfree != 0;
 }
 
 // Tests if the window has been signalled as destroyed by a
@@ -124,25 +110,6 @@ WXRUBY_EXPORT void GcRefCountedFreeFunc(void *ptr)
   WXRUBY_TRACE_END
 }
 
-// Code to be run when the ruby object is swept by GC - this checks
-// for unattached sizers and deletes those, only unlinking others
-// as these will be managed by WxWidgets.
-WXRUBY_EXPORT void GcSizerFreeFunc(void *ptr)
-{
-  WXRUBY_TRACE_IF(WxRubyTraceFreeSizer, 2)
-    WXRUBY_TRACE("> GcSizerFreeFunc : " << ptr)
-  WXRUBY_TRACE_END
-
-  wxSizer* wx_szr = (wxSizer*)ptr;
-  // unlink in all cases
-  SWIG_RubyRemoveTracking(ptr);
-  delete wx_szr; // delete unattached sizers
-
-  WXRUBY_TRACE_IF(WxRubyTraceFreeSizer, 2)
-    WXRUBY_TRACE("< GcSizerFreeFunc")
-  WXRUBY_TRACE_END
-}
-
 void GC_mark_SizerBelongingToWindow(wxSizer *wx_sizer, VALUE rb_sizer);
 
 WXRUBY_EXPORT void GC_mark_wxSizer(void* ptr)
@@ -154,10 +121,10 @@ WXRUBY_EXPORT void GC_mark_wxSizer(void* ptr)
   VALUE rb_szr = SWIG_RubyInstanceFor(ptr);
   if (!RB_NIL_P(rb_szr))
   {
-    // as long as the dfree function is still the GCSizeFreeFunc the sizer has not been attached to a window
+    // as long as the dfree function is still the sizer's free function the sizer has not been attached to a window
     // or added to a parent sizer (as that would 'disown' and replace the free function by the tracking removal function)
     // but it may hay have already had child sizers added which need to be marked
-    if (RDATA(rb_szr)->dfree == (void (*)(void *))GcSizerFreeFunc)
+    if (RDATA(rb_szr)->dfree != (void (*)(void *))SWIG_RubyRemoveTracking)
     {
       wxSizer* wx_szr = (wxSizer*)ptr;
 
@@ -225,63 +192,6 @@ void GC_mark_SizerBelongingToWindow(wxSizer *wx_sizer, VALUE rb_sizer)
   WXRUBY_TRACE_END
 }
 
-WXRUBY_EXPORT void GC_mark_attached_wxMenu(void *ptr)
-{
-  WXRUBY_TRACE_IF(WxRubyTraceMarkMenu, 2)
-    WXRUBY_TRACE("> GC_mark_attached_wxMenu : " << ptr)
-  WXRUBY_TRACE_END
-
-  rb_gc_mark(SWIG_RubyInstanceFor(ptr));
-
-  wxMenu *wx_menu = static_cast<wxMenu*> (ptr);
-
-  wxMenuItemList wx_menu_items = wx_menu->GetMenuItems();
-  wxMenuItemList::iterator iter;
-  for (iter = wx_menu_items.begin(); iter != wx_menu_items.end(); ++iter)
-  {
-    wxMenuItem *wx_item = *iter;
-    rb_gc_mark(SWIG_RubyInstanceFor(wx_item) );
-    wxMenu* wx_sub_menu = wx_item->GetSubMenu();
-    if (wx_sub_menu)
-      GC_mark_attached_wxMenu(wx_sub_menu);
-  }
-
-  WXRUBY_TRACE_IF(WxRubyTraceMarkMenu, 2)
-    WXRUBY_TRACE("< GC_mark_attached_wxMenu : " << ptr)
-  WXRUBY_TRACE_END
-}
-
-// Similar to Sizers, MenuBar requires a special mark routine. This is
-// because Wx::Menu is not a subclass of Window so isn't automatically
-// protected in the mark phase by Wx::App. However, the ruby object
-// still must not be destroyed while it is still accessible on screen,
-// because it may still handle events. Rather than a SWIG %markfunc,
-// which can catch destroyed MenuBars linked to an in-scope ruby
-// variable and cause segfaults, MenuBars are always marked via the
-// containing Frame.
-void GC_mark_MenuBarBelongingToFrame(wxMenuBar *wx_menu_bar)
-{
-  WXRUBY_TRACE_IF(WxRubyTraceMarkMenubar, 2)
-    WXRUBY_TRACE("> GC_mark_MenuBarBelongingToFrame : " << wx_menu_bar)
-  WXRUBY_TRACE_END
-
-  rb_gc_mark( SWIG_RubyInstanceFor(wx_menu_bar) );
-
-  WXRUBY_TRACE_IF(WxRubyTraceMarkMenubar, 3)
-    WXRUBY_TRACE("< GC_mark_MenuBarBelongingToFrame : marking " << wx_menu_bar->GetMenuCount() << " menus")
-  WXRUBY_TRACE_END
-
-  // Mark each menu in the menubar in turn
-  for ( size_t i = 0; i < wx_menu_bar->GetMenuCount(); i++ )
-	{
-	  GC_mark_attached_wxMenu(wx_menu_bar->GetMenu(i));
-	}
-
-  WXRUBY_TRACE_IF(WxRubyTraceMarkMenubar, 2)
-    WXRUBY_TRACE("< GC_mark_MenuBarBelongingToFrame : " << wx_menu_bar)
-  WXRUBY_TRACE_END
-}
-
 // Default mark routine for Windows - preserve the main sizer and caret
 // belong to this window
 WXRUBY_EXPORT void GC_mark_wxWindow(void *ptr)
@@ -376,39 +286,4 @@ WXRUBY_EXPORT void GC_mark_wxWindow(void *ptr)
   WXRUBY_TRACE_END
 }
 
-
-WXRUBY_EXPORT void GC_mark_wxFrame(void *ptr)
-{
-  WXRUBY_TRACE_IF(WxRubyTraceMarkFrame, 2)
-    WXRUBY_TRACE("> GC_mark_wxFrame : " << ptr)
-  WXRUBY_TRACE_END
-
-  if ( GC_IsWindowDeleted(ptr) )
-  {
-    WXRUBY_TRACE_IF(WxRubyTraceMarkFrame, 2)
-      WXRUBY_TRACE("< GC_mark_wxFrame : deleted")
-    WXRUBY_TRACE_END
-    return;
-  }
-
-  // Frames are also a subclass of wxWindow, so must do all the marking
-  // of sizers and carets associated with that class
-  GC_mark_wxWindow(ptr);
-
-  wxFrame* wx_frame = (wxFrame*)ptr;
-  // Then mark the MenuBar, if one is associated with this Frame
-
-  wxMenuBar* menu_bar = wx_frame->GetMenuBar();
-  if ( menu_bar )
-  {
-    // as this is an attached menu bar the regular marker will not mark
-    // any menu content as it can't tell if the c++ object has been deleted or not
-    // so we do that here now we know it is still alive
-    GC_mark_MenuBarBelongingToFrame(menu_bar);
-  }
-
-  WXRUBY_TRACE_IF(WxRubyTraceMarkFrame, 2)
-    WXRUBY_TRACE("< GC_mark_wxFrame : " << ptr)
-  WXRUBY_TRACE_END
-}
 %}