wxruby3 0.9.0.pre.beta.8

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

@@ -0,0 +1,306 @@
+// wxRuby3 Wx::Enum class embedded implementation
+// Copyright (c) M.J.N. Corino, The Netherlands
+
+VALUE cWxEnum;
+
+// instance variable for Enum class
+static const char * __iv_cEnum_value = "@value";
+
+// Enum class singleton class
+static VALUE cEnum_Singleton;
+// instance variable for Enum class singleton class (hash registry of Enum classes)
+static const char * __iv_Enum_sc_enums = "@enums";
+
+// instance variables for derived Enum class singleton classes
+static const char * __iv_enum_klass_values = "@values";   // hash map of all value instances of derived Enum (by integer value)
+static const char * __iv_enum_klass_values_by_name = "@values_by_name";   // hash map of all value instances of derived Enum
+static const char * __iv_enum_klass_name = "@name";       // unscoped name of derived Enum
+
+static VALUE wx_Enum_initialize(int argc, VALUE *argv, VALUE self)
+{
+  if ((argc < 1) || (argc > 1))
+  {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)", argc); return Qnil;
+  }
+  rb_iv_set(self, __iv_cEnum_value, rb_funcall(argv[0], rb_intern("to_i"), 0, 0));
+  return self;
+}
+
+static VALUE wx_Enum_coerce(int argc, VALUE *argv, VALUE self)
+{
+  if ((argc < 1) || (argc > 1))
+  {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)", argc); return Qnil;
+  }
+  if (!rb_obj_is_kind_of(argv[0], rb_cNumeric))
+  {
+    VALUE str = rb_inspect(argv[0]);
+    rb_raise(rb_eTypeError,
+             "Unable to coerce %s to be compatible with Enum",
+             StringValuePtr(str));
+    return Qnil;
+  }
+  VALUE result = rb_ary_new();
+  rb_ary_push(result, rb_iv_get(self, __iv_cEnum_value));
+  rb_ary_push(result, rb_funcall(argv[0], rb_intern("to_i"), 0, 0));
+  return result;
+}
+
+static VALUE wx_Enum_is_integer(int argc, VALUE *argv, VALUE self)
+{
+  if ((argc < 0) || (argc > 0))
+  {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)", argc); return Qnil;
+  }
+  return Qtrue;
+}
+
+static VALUE wx_Enum_is_real(int argc, VALUE *argv, VALUE self)
+{
+  if ((argc < 0) || (argc > 0))
+  {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)", argc); return Qnil;
+  }
+  return Qfalse;
+}
+
+static VALUE wx_Enum_method_missing(int argc, VALUE *argv, VALUE self)
+{
+  if (argc < 1)
+  {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)", argc); return Qnil;
+  }
+  VALUE value = rb_iv_get(self, __iv_cEnum_value);
+  return rb_funcall2(value, rb_to_id(argv[0]), argc-1, (argv+1));
+}
+
+static VALUE wx_Enum_is_equal(int argc, VALUE *argv, VALUE self)
+{
+  if ((argc < 1) || (argc > 1))
+  {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)", argc); return Qnil;
+  }
+  if (CLASS_OF(self) == CLASS_OF(argv[0]) &&
+        NUM2INT(rb_iv_get(self, __iv_cEnum_value)) == NUM2INT(rb_iv_get(argv[0], __iv_cEnum_value)))
+    return Qtrue;
+  else
+    return Qfalse;
+}
+
+static VALUE wx_Enum_compare(int argc, VALUE *argv, VALUE self)
+{
+  if ((argc < 1) || (argc > 1))
+  {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)", argc); return Qnil;
+  }
+  if (rb_obj_is_kind_of(argv[0], cWxEnum))
+  {
+    return rb_funcall(rb_iv_get(self, __iv_cEnum_value), rb_intern("<=>"), 1, rb_iv_get(argv[0], __iv_cEnum_value), 0);
+  }
+  else if (rb_obj_is_kind_of(argv[0], rb_cNumeric))
+  {
+    return rb_funcall(rb_iv_get(self, __iv_cEnum_value), rb_intern("<=>"), 1, argv[0], 0);
+  }
+  VALUE str = rb_inspect(argv[0]);
+  rb_raise(rb_eArgError,
+           "Failed to compare Enum with %s",
+           StringValuePtr(str));
+  return Qnil;
+}
+
+static VALUE wx_Enum_succ(int argc, VALUE *argv, VALUE self)
+{
+  if ((argc < 0) || (argc > 0))
+  {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)", argc); return Qnil;
+  }
+  return rb_funcall(rb_iv_get(self, __iv_cEnum_value), rb_intern("succ"), 0);
+}
+
+static VALUE wx_Enum_inspect(int argc, VALUE *argv, VALUE self)
+{
+  if ((argc < 0) || (argc > 0))
+  {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)", argc); return Qnil;
+  }
+  VALUE str = rb_str_new2(rb_class2name(CLASS_OF(self)));
+  rb_str_cat2(str, "<");
+  rb_funcall(str,
+             rb_intern("<<"),
+             1,
+             rb_funcall(rb_iv_get(self, __iv_cEnum_value),
+                        rb_intern("to_s"),
+                        0,
+                        0),
+             0);
+  rb_str_cat2(str, ">");
+  return str;
+}
+
+static VALUE wx_Enum_to_int(int argc, VALUE *argv, VALUE self)
+{
+  if ((argc < 0) || (argc > 0))
+  {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)", argc); return Qnil;
+  }
+  return rb_iv_get(self, __iv_cEnum_value);
+}
+
+static VALUE wx_Enum_sc_get_enum_class(int argc, VALUE *argv, VALUE self)
+{
+  if ((argc < 1) || (argc > 1))
+  {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)", argc); return Qnil;
+  }
+  return rb_hash_aref(rb_iv_get(cEnum_Singleton, __iv_Enum_sc_enums), rb_to_symbol(argv[0]));
+}
+
+static VALUE wx_Enum_sc_create_enum_class(int argc, VALUE *argv, VALUE self)
+{
+  if ((argc < 2) || (argc > 2))
+  {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)", argc); return Qnil;
+  }
+  VALUE enum_name = rb_to_symbol(argv[0]);
+  if (TYPE(argv[1]) != T_HASH)
+  {
+    VALUE str = rb_inspect(argv[1]);
+    rb_raise(rb_eArgError,
+             "Invalid enum_values; expected Hash but got %s.",
+             StringValuePtr(str));
+    return Qnil;
+  }
+  ID id_new = rb_intern("new");
+  ID id_to_i = rb_intern("to_i");
+  ID id_const_set = rb_intern("const_set");
+  VALUE enum_klass = rb_funcall(rb_cClass, id_new, 1, cWxEnum, 0);
+  VALUE enum_values = rb_funcall(argv[1], rb_intern("keys"), 0, 0);
+  for (int i=0; i<RARRAY_LEN(enum_values) ;++i)
+  {
+    VALUE enum_value_name = rb_ary_entry(enum_values, i);
+    VALUE enum_value_num = rb_funcall(rb_hash_aref(argv[1], enum_value_name), id_to_i, 0, 0);
+    VALUE enum_value = rb_funcall(enum_klass, id_new, 1, enum_value_num, 0);
+    rb_funcall(enum_klass, id_const_set, 2, enum_value_name, enum_value, 0);
+  }
+  rb_hash_aset(rb_iv_get(cEnum_Singleton, __iv_Enum_sc_enums), enum_name, enum_klass);
+  return enum_klass;
+}
+
+static void wx_setup_Enum_singleton_class()
+{
+  cEnum_Singleton = rb_funcall(cWxEnum, rb_intern("singleton_class"), 0, 0);
+  rb_iv_set(cEnum_Singleton, __iv_Enum_sc_enums, rb_hash_new());
+  rb_define_method(cEnum_Singleton, "create", VALUEFUNC(wx_Enum_sc_create_enum_class), -1);
+  rb_define_singleton_method(cWxEnum, "[]", VALUEFUNC(wx_Enum_sc_get_enum_class), -1);
+}
+
+static void wx_define_Enum_class()
+{
+  cWxEnum = rb_define_class_under(mWxCore, "Enum", rb_cNumeric);
+  rb_define_method(cWxEnum, "initialize", VALUEFUNC(wx_Enum_initialize), -1);
+  rb_define_method(cWxEnum, "coerce", VALUEFUNC(wx_Enum_coerce), -1);
+  rb_define_method(cWxEnum, "integer?", VALUEFUNC(wx_Enum_is_integer), -1);
+  rb_define_method(cWxEnum, "real?", VALUEFUNC(wx_Enum_is_real), -1);
+  rb_define_method(cWxEnum, "method_missing", VALUEFUNC(wx_Enum_method_missing), -1);
+  rb_define_method(cWxEnum, "eql?", VALUEFUNC(wx_Enum_is_equal), -1);
+  rb_define_method(cWxEnum, "<=>", VALUEFUNC(wx_Enum_compare), -1);
+  rb_define_method(cWxEnum, "succ", VALUEFUNC(wx_Enum_succ), -1);
+  rb_define_method(cWxEnum, "inspect", VALUEFUNC(wx_Enum_inspect), -1);
+  rb_define_method(cWxEnum, "to_int", VALUEFUNC(wx_Enum_to_int), -1);
+  rb_define_alias(cWxEnum, "to_i", "to_int");
+  wx_setup_Enum_singleton_class();
+}
+
+WXRB_EXPORT_FLAG VALUE wxRuby_GetEnumClass(const char* enum_class_name_cstr)
+{
+  VALUE enum_hash = rb_iv_get(cEnum_Singleton, __iv_Enum_sc_enums);
+  return rb_hash_aref(enum_hash, rb_str_new2(enum_class_name_cstr));
+}
+
+static VALUE wx_Enum_sc_get_enum_value(int argc, VALUE *argv, VALUE self)
+{
+  if ((argc < 1) || (argc > 1))
+  {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)", argc); return Qnil;
+  }
+  VALUE enum_singleton_klass = rb_funcall(self, rb_intern("singleton_class"), 0, 0);
+  return rb_hash_aref(rb_iv_get(enum_singleton_klass, __iv_enum_klass_values_by_name), rb_to_symbol(argv[0]));
+}
+
+WXRB_EXPORT_FLAG VALUE wxRuby_CreateEnumClass(const char* enum_class_name_cstr)
+{
+  VALUE enum_klass = rb_funcall(rb_cClass, rb_intern("new"), 1, cWxEnum, 0);
+  rb_define_singleton_method(enum_klass, "[]", VALUEFUNC(wx_Enum_sc_get_enum_value), -1);
+  VALUE enum_singleton_klass = rb_funcall(enum_klass, rb_intern("singleton_class"), 0, 0);
+  rb_iv_set(enum_singleton_klass, __iv_enum_klass_values, rb_hash_new());
+  rb_iv_set(enum_singleton_klass, __iv_enum_klass_values_by_name, rb_hash_new());
+  rb_iv_set(enum_singleton_klass, __iv_enum_klass_name, rb_str_new2(enum_class_name_cstr));
+  rb_hash_aset(rb_iv_get(cEnum_Singleton, __iv_Enum_sc_enums),
+               ID2SYM(rb_intern(enum_class_name_cstr)),
+               enum_klass);
+  return enum_klass;
+}
+
+WXRB_EXPORT_FLAG VALUE wxRuby_AddEnumValue(VALUE enum_klass, const char* enum_value_name_cstr, VALUE enum_value_num)
+{
+  VALUE enum_value_name = ID2SYM(rb_intern(enum_value_name_cstr));
+  VALUE enum_value = rb_funcall(enum_klass, rb_intern("new"), 1, enum_value_num, 0);
+  VALUE enum_singleton_klass = rb_funcall(enum_klass, rb_intern("singleton_class"), 0, 0);
+  rb_hash_aset(rb_iv_get(enum_singleton_klass, __iv_enum_klass_values), enum_value_num, enum_value);
+  rb_hash_aset(rb_iv_get(enum_singleton_klass, __iv_enum_klass_values_by_name), enum_value_name, enum_value);
+  rb_funcall(enum_klass, rb_intern("const_set"), 2, enum_value_name, enum_value, 0);
+  return enum_value;
+}
+
+WXRB_EXPORT_FLAG VALUE wxRuby_GetEnumValueObject(const char* enum_wx_class_name_cstr, int enum_val)
+{
+  if (enum_wx_class_name_cstr)
+  {
+    const char *enum_class_name = enum_wx_class_name_cstr;
+    if (strncmp(enum_class_name, "wx", 2) == 0)
+      enum_class_name += 2;
+    VALUE enum_hash = rb_iv_get(cEnum_Singleton, __iv_Enum_sc_enums);
+    VALUE enum_klass = rb_hash_aref(enum_hash, ID2SYM(rb_intern(enum_class_name)));
+    VALUE enum_singleton_klass = rb_funcall(enum_klass, rb_intern("singleton_class"), 0, 0);
+    VALUE enum_values_hash = rb_iv_get(enum_singleton_klass, __iv_enum_klass_values);
+    return rb_hash_aref(enum_values_hash, INT2NUM(enum_val));
+  }
+  return Qnil;
+}
+
+WXRB_EXPORT_FLAG bool wxRuby_GetEnumValue(const char* enum_wx_class_name_cstr, VALUE rb_enum_val, int &c_eval)
+{
+  if (enum_wx_class_name_cstr && rb_obj_is_kind_of(rb_enum_val, cWxEnum))
+  {
+    VALUE enum_singleton_klass = rb_funcall(CLASS_OF(rb_enum_val), rb_intern("singleton_class"), 0, 0);
+    VALUE rb_enum_class_name = rb_iv_get(enum_singleton_klass, __iv_enum_klass_name);
+    const char *enum_class_name = enum_wx_class_name_cstr;
+    if (strncmp(enum_class_name, "wx", 2) == 0)
+      enum_class_name += 2;
+    if (strcmp(enum_class_name, StringValuePtr(rb_enum_class_name)) == 0)
+    {
+      c_eval = NUM2INT(rb_iv_get(rb_enum_val, __iv_cEnum_value));
+      return true;
+    }
+  }
+  return false;
+}
+
+WXRB_EXPORT_FLAG bool wxRuby_IsAnEnum(VALUE rb_val)
+{
+  return rb_obj_is_kind_of(rb_val, cWxEnum);
+}
+
+WXRB_EXPORT_FLAG bool wxRuby_IsEnumValue(const char* enum_wx_class_name_cstr, VALUE rb_enum_val)
+{
+  if (enum_wx_class_name_cstr && rb_obj_is_kind_of(rb_enum_val, cWxEnum))
+  {
+    VALUE enum_singleton_klass = rb_funcall(CLASS_OF(rb_enum_val), rb_intern("singleton_class"), 0, 0);
+    VALUE rb_enum_class_name = rb_iv_get(enum_singleton_klass, __iv_enum_klass_name);
+    const char *enum_class_name = enum_wx_class_name_cstr;
+    if (strncmp(enum_class_name, "wx", 2) == 0)
+      enum_class_name += 2;
+    return (strcmp(enum_class_name, StringValuePtr(rb_enum_class_name)) == 0);
+  }
+  return false;
+}

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

@@ -0,0 +1,277 @@
+
+#undef _
+
+#include <exception>
+#include <string>
+
+#include <wx/wx.h>
+
+typedef VALUE (*RUBY_INVOKE_FUNC) (VALUE);
+
+namespace Swig {
+  /* Base class for director exceptions */
+  class 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 ="") : swig_error(error), swig_msg(hdr)
+    {
+      if (msg[0])
+      {
+        swig_msg += " ";
+        swig_msg += msg;
+      }
+      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;
+      }
+    }
+  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();
+    }
+  };
+  class DirectorRubyException : public DirectorException
+  {
+  public:
+    DirectorRubyException(const char *exname, const char *msg="")
+      : DirectorException(rb_eRuntimeError, exname, msg)
+    {
+    }
+  };
+}
+
+class WXRuby_RBFuncall
+{
+public:
+  WXRuby_RBFuncall (ID fnid, bool throw_on_ex=true)
+   : fn_id_ (fnid),
+     throw_on_ex_ (throw_on_ex),
+     ex_caught_ (false)
+  {
+  }
+  WXRuby_RBFuncall (const char* fn, bool throw_on_ex=true)
+  : fn_id_ (rb_intern (fn)),
+    throw_on_ex_ (throw_on_ex),
+    ex_caught_ (false)
+  {
+  }
+  ~WXRuby_RBFuncall () {}
+
+  VALUE invoke (VALUE rcvr, VALUE args)
+  {
+    return this->_invoke (FuncArgArray (rcvr, args));
+  }
+  VALUE invoke (VALUE rcvr, int argc, VALUE *args)
+  {
+    return this->_invoke (FuncArgList (rcvr, argc, args));
+  }
+  VALUE invoke (VALUE rcvr)
+  {
+    return this->_invoke (FuncArgList (rcvr, 0, 0));
+  }
+
+  bool has_caught_exception () { return this->ex_caught_; }
+
+  VALUE get_exception () { return rb_gv_get ("$!"); }
+
+  ID id () { return this->fn_id_; }
+
+protected:
+  struct FuncArgs
+  {
+    virtual ~FuncArgs () {}
+    virtual VALUE rb_invoke (ID fnid) const = 0;
+  };
+
+  VALUE _invoke (const FuncArgs& fa)
+  {
+    this->ex_caught_ = false; // reset
+
+    int invoke_state = 0;
+    HelperArgs ha (*this, fa);
+    VALUE result = rb_protect (RUBY_INVOKE_FUNC(WXRuby_RBFuncall::invoke_helper),
+                               (VALUE)&ha,
+                               &invoke_state);
+    if (invoke_state)
+    {
+      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);
+        wxLogDebug("%s : %s", exc_name, StringValuePtr(msg));
+        throw Swig::DirectorRubyException(exc_name, StringValuePtr(msg));
+      }
+      else
+      {
+        this->ex_caught_ = true;
+      }
+    }
+    else
+    {
+      return result;
+    }
+    return Qnil;
+  }
+
+  struct FuncArgArray : public FuncArgs
+  {
+    FuncArgArray (VALUE rcvr, VALUE args)
+     : receiver_ (rcvr), args_ (args) {}
+    virtual ~FuncArgArray () {}
+
+    virtual VALUE rb_invoke (ID fnid) const
+    {
+      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) {}
+    virtual ~FuncArgList () {}
+
+    virtual VALUE rb_invoke (ID fnid) const
+    {
+      return rb_funcall2 (this->receiver_, fnid, this->argc_, this->args_);
+    }
+
+    VALUE receiver_;
+    int argc_;
+    VALUE* args_;
+  };
+
+  VALUE invoke_inner (const FuncArgs& fnargs)
+  {
+    return fnargs.rb_invoke (this->fn_id_);
+  }
+
+  struct HelperArgs
+  {
+    HelperArgs (WXRuby_RBFuncall& c, const FuncArgs& fa)
+     : caller_ (c), fnargs_ (fa) {}
+
+    WXRuby_RBFuncall& caller_;
+    const FuncArgs& fnargs_;
+  };
+
+  static VALUE invoke_helper (VALUE arg)
+  {
+    HelperArgs* ha = reinterpret_cast<HelperArgs*> (arg);
+    return ha->caller_.invoke_inner (ha->fnargs_);
+  }
+
+private:
+  ID      fn_id_;
+  bool    throw_on_ex_;
+  bool    ex_caught_;
+};
+
+WXRB_EXPORT_FLAG VALUE wxRuby_Funcall(VALUE rcvr, ID func, int argc, ...)
+{
+  VALUE *argv;
+  va_list ar;
+
+  if (argc > 0)
+  {
+      long i;
+
+      va_start(ar, argc);
+
+      argv = ALLOCA_N(VALUE, argc);
+
+      for (i = 0; i < argc; i++)
+      {
+          argv[i] = va_arg(ar, VALUE);
+      }
+      va_end(ar);
+  }
+  else
+  {
+      argv = 0;
+  }
+  return WXRuby_RBFuncall(func).invoke(rcvr, argc, argv);
+}
+
+WXRB_EXPORT_FLAG VALUE wxRuby_Funcall(bool& ex_caught, VALUE rcvr, ID func, int argc, ...)
+{
+  VALUE *argv;
+  va_list ar;
+
+  if (argc > 0)
+  {
+      long i;
+
+      va_start(ar, argc);
+
+      argv = ALLOCA_N(VALUE, argc);
+
+      for (i = 0; i < argc; i++)
+      {
+          argv[i] = va_arg(ar, VALUE);
+      }
+      va_end(ar);
+  }
+  else
+  {
+      argv = 0;
+  }
+  WXRuby_RBFuncall wxrb_fn(func, false);
+  VALUE rc = wxrb_fn.invoke(rcvr, argc, argv);
+  if ((ex_caught = wxrb_fn.has_caught_exception ()))
+  {
+    return wxrb_fn.get_exception ();
+  }
+  else
+  {
+    return rc;
+  }
+}
+
+WXRB_EXPORT_FLAG VALUE wxRuby_Funcall(VALUE rcvr, ID func, VALUE args)
+{
+  return WXRuby_RBFuncall(func).invoke(rcvr, args);
+}
+
+WXRB_EXPORT_FLAG VALUE wxRuby_Funcall(bool& ex_caught, VALUE rcvr, ID func, VALUE args)
+{
+  WXRuby_RBFuncall wxrb_fn(func, false);
+  VALUE rc = wxrb_fn.invoke(rcvr, args);
+  if ((ex_caught = wxrb_fn.has_caught_exception ()))
+  {
+    return wxrb_fn.get_exception ();
+  }
+  else
+  {
+    return rc;
+  }
+}

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

@@ -0,0 +1,95 @@
+
+#ifdef __WXMSW__
+
+extern "C"
+{
+    WXDLLIMPEXP_BASE HINSTANCE wxGetInstance();
+}
+
+WXDLLIMPEXP_BASE void wxSetInstance(HINSTANCE hInst);
+
+//----------------------------------------------------------------------
+// This gets run when the DLL is loaded.  We just need to save the
+// instance handle.
+//----------------------------------------------------------------------
+
+extern "C"
+BOOL WINAPI DllMain(
+    HINSTANCE   hinstDLL,    // handle to DLL module
+    DWORD       fdwReason,   // reason for calling function
+    LPVOID      lpvReserved)
+{
+    // If wxRuby is embedded in another (wxWidgets) app then
+    // the instance may already have been set.
+    if (fdwReason==DLL_PROCESS_ATTACH && !wxGetInstance())
+        wxSetInstance(hinstDLL);
+
+    return TRUE;
+}
+
+// Adapted from wxPython
+static void wxRuby_SetActivationContext()
+{
+
+    OSVERSIONINFO info;
+    memset(&info, 0, sizeof(OSVERSIONINFO));
+    info.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
+    GetVersionEx(&info);
+    if (info.dwMajorVersion < 5)
+        return;
+
+    ULONG_PTR cookie = 0;
+    HANDLE h;
+    ACTCTX actctx;
+    TCHAR modulename[MAX_PATH];
+
+    GetModuleFileName(wxGetInstance(), modulename, MAX_PATH);
+    memset(&actctx, 0, sizeof(ACTCTX));
+    actctx.cbSize = sizeof(actctx);
+    actctx.lpSource = modulename;
+#ifdef ISOLATION_AWARE_ENABLED    
+    actctx.lpResourceName = MAKEINTRESOURCE(2);
+#else    
+    actctx.lpResourceName = MAKEINTRESOURCE(1);
+#endif
+    actctx.hModule = wxGetInstance();
+    actctx.dwFlags = ACTCTX_FLAG_HMODULE_VALID | ACTCTX_FLAG_RESOURCE_NAME_VALID;
+
+    h = CreateActCtx(&actctx);
+    if (h == INVALID_HANDLE_VALUE) 
+    {
+        LPTSTR lpMsgBuf;
+        DWORD dw = GetLastError(); 
+
+        FormatMessage(
+            FORMAT_MESSAGE_ALLOCATE_BUFFER | 
+            FORMAT_MESSAGE_FROM_SYSTEM |
+            FORMAT_MESSAGE_IGNORE_INSERTS,
+            NULL,
+            dw,
+            MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
+            (LPTSTR) &lpMsgBuf,
+            0, NULL );
+        ::fprintf(stderr, "Error in CreateActCtx : %s\n", lpMsgBuf);
+        return;
+    }
+
+    if (! ActivateActCtx(h, &cookie))
+    {
+        LPTSTR lpMsgBuf;
+        DWORD dw = GetLastError(); 
+
+        FormatMessage(
+            FORMAT_MESSAGE_ALLOCATE_BUFFER | 
+            FORMAT_MESSAGE_FROM_SYSTEM |
+            FORMAT_MESSAGE_IGNORE_INSERTS,
+            NULL,
+            dw,
+            MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
+            (LPTSTR) &lpMsgBuf,
+            0, NULL );
+        ::fprintf(stderr, "Error in ActivateActCtx : %s\n", lpMsgBuf);
+    }
+}
+
+#endif