win32ole 1.8.8

data/ext/win32ole/win32ole.h

@@ -0,0 +1,155 @@
+#ifndef WIN32OLE_H
+#define WIN32OLE_H 1
+#include "ruby/ruby.h"
+#include "ruby/st.h"
+#include "ruby/encoding.h"
+
+#define GNUC_OLDER_3_4_4 \
+    ((__GNUC__ < 3) || \
+     ((__GNUC__ <= 3) && (__GNUC_MINOR__ < 4)) || \
+     ((__GNUC__ <= 3) && (__GNUC_MINOR__ <= 4) && (__GNUC_PATCHLEVEL__ <= 4)))
+
+#if (defined(__GNUC__)) && (GNUC_OLDER_3_4_4)
+#ifndef NONAMELESSUNION
+#define NONAMELESSUNION 1
+#endif
+#endif
+
+#include <ctype.h>
+
+#include <windows.h>
+#include <ocidl.h>
+#include <olectl.h>
+#include <ole2.h>
+#if defined(HAVE_TYPE_IMULTILANGUAGE2) || defined(HAVE_TYPE_IMULTILANGUAGE)
+#include <mlang.h>
+#endif
+#include <stdlib.h>
+#include <math.h>
+#ifdef HAVE_STDARG_PROTOTYPES
+#include <stdarg.h>
+#define va_init_list(a,b) va_start(a,b)
+#else
+#include <varargs.h>
+#define va_init_list(a,b) va_start(a)
+#endif
+#include <objidl.h>
+
+#define DOUT fprintf(stderr,"%s(%d)\n", __FILE__, __LINE__)
+#define DOUTS(x) fprintf(stderr,"%s(%d):" #x "=%s\n",__FILE__, __LINE__,x)
+#define DOUTMSG(x) fprintf(stderr, "%s(%d):" #x "\n",__FILE__, __LINE__)
+#define DOUTI(x) fprintf(stderr, "%s(%d):" #x "=%d\n",__FILE__, __LINE__,x)
+#define DOUTD(x) fprintf(stderr, "%s(%d):" #x "=%f\n",__FILE__, __LINE__,x)
+
+#if (defined(__GNUC__)) && (GNUC_OLDER_3_4_4)
+#define V_UNION1(X, Y) ((X)->u.Y)
+#else
+#define V_UNION1(X, Y) ((X)->Y)
+#endif
+
+#if (defined(__GNUC__)) && (GNUC_OLDER_3_4_4)
+#undef V_UNION
+#define V_UNION(X,Y) ((X)->n1.n2.n3.Y)
+
+#undef V_VT
+#define V_VT(X) ((X)->n1.n2.vt)
+
+#undef V_BOOL
+#define V_BOOL(X) V_UNION(X,boolVal)
+#endif
+
+#ifndef V_I1REF
+#define V_I1REF(X) V_UNION(X, pcVal)
+#endif
+
+#ifndef V_UI2REF
+#define V_UI2REF(X) V_UNION(X, puiVal)
+#endif
+
+#ifndef V_INT
+#define V_INT(X) V_UNION(X, intVal)
+#endif
+
+#ifndef V_INTREF
+#define V_INTREF(X) V_UNION(X, pintVal)
+#endif
+
+#ifndef V_UINT
+#define V_UINT(X) V_UNION(X, uintVal)
+#endif
+
+#ifndef V_UINTREF
+#define V_UINTREF(X) V_UNION(X, puintVal)
+#endif
+
+#ifdef HAVE_LONG_LONG
+#define I8_2_NUM LL2NUM
+#define UI8_2_NUM ULL2NUM
+#define NUM2I8  RB_NUM2LL
+#define NUM2UI8 RB_NUM2ULL
+#else
+#define I8_2_NUM RB_INT2NUM
+#define UI8_2_NUM RB_UINT2NUM
+#define NUM2I8  RB_NUM2INT
+#define NUM2UI8 RB_NUM2UINT
+#endif
+
+#define OLE_ADDREF(X) (X) ? ((X)->lpVtbl->AddRef(X)) : 0
+#define OLE_RELEASE(X) (X) ? ((X)->lpVtbl->Release(X)) : 0
+#define OLE_FREE(x) {\
+    if(ole_initialized() == TRUE) {\
+        if(x) {\
+            OLE_RELEASE(x);\
+            (x) = 0;\
+        }\
+    }\
+}
+
+#define OLE_GET_TYPEATTR(X, Y) ((X)->lpVtbl->GetTypeAttr((X), (Y)))
+#define OLE_RELEASE_TYPEATTR(X, Y) ((X)->lpVtbl->ReleaseTypeAttr((X), (Y)))
+
+struct oledata {
+    IDispatch *pDispatch;
+};
+
+VALUE cWIN32OLE;
+LCID cWIN32OLE_lcid;
+
+struct oledata *oledata_get_struct(VALUE obj);
+LPWSTR ole_vstr2wc(VALUE vstr);
+LONG reg_open_key(HKEY hkey, const char *name, HKEY *phkey);
+LONG reg_open_vkey(HKEY hkey, VALUE key, HKEY *phkey);
+VALUE reg_enum_key(HKEY hkey, DWORD i);
+VALUE reg_get_val(HKEY hkey, const char *subkey);
+VALUE reg_get_val2(HKEY hkey, const char *subkey);
+void ole_initialize(void);
+VALUE default_inspect(VALUE self, const char *class_name);
+char *ole_wc2mb(LPWSTR pw);
+VALUE ole_wc2vstr(LPWSTR pw, BOOL isfree);
+
+#define WC2VSTR(x) ole_wc2vstr((x), TRUE)
+
+BOOL ole_initialized(void);
+HRESULT ole_docinfo_from_type(ITypeInfo *pTypeInfo, BSTR *name, BSTR *helpstr, DWORD *helpcontext, BSTR *helpfile);
+VALUE ole_typedesc2val(ITypeInfo *pTypeInfo, TYPEDESC *pTypeDesc, VALUE typedetails);
+VALUE make_inspect(const char *class_name, VALUE detail);
+void ole_val2variant(VALUE val, VARIANT *var);
+void ole_val2variant2(VALUE val, VARIANT *var);
+void ole_val2variant_ex(VALUE val, VARIANT *var, VARTYPE vt);
+VALUE ole_variant2val(VARIANT *pvar);
+HRESULT ole_val_ary2variant_ary(VALUE val, VARIANT *var, VARTYPE vt);
+VOID *val2variant_ptr(VALUE val, VARIANT *var, VARTYPE vt);
+HRESULT typelib_from_val(VALUE obj, ITypeLib **pTypeLib);
+
+#include "win32ole_variant_m.h"
+#include "win32ole_typelib.h"
+#include "win32ole_type.h"
+#include "win32ole_variable.h"
+#include "win32ole_method.h"
+#include "win32ole_param.h"
+#include "win32ole_event.h"
+#include "win32ole_variant.h"
+#include "win32ole_record.h"
+#include "win32ole_error.h"
+
+#endif

data/ext/win32ole/win32ole_error.c

@@ -0,0 +1,84 @@
+#include "win32ole.h"
+
+static VALUE ole_hresult2msg(HRESULT hr);
+
+static VALUE
+ole_hresult2msg(HRESULT hr)
+{
+    VALUE msg = Qnil;
+    char *p_msg = NULL;
+    char *term = NULL;
+    DWORD dwCount;
+
+    char strhr[100];
+    sprintf(strhr, "    HRESULT error code:0x%08x\n      ", (unsigned)hr);
+    msg = rb_str_new2(strhr);
+    dwCount = FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER |
+                            FORMAT_MESSAGE_FROM_SYSTEM |
+                            FORMAT_MESSAGE_IGNORE_INSERTS,
+                            NULL, hr,
+                            MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US),
+                            (LPTSTR)&p_msg, 0, NULL);
+    if (dwCount == 0) {
+        dwCount = FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER |
+                                FORMAT_MESSAGE_FROM_SYSTEM |
+                                FORMAT_MESSAGE_IGNORE_INSERTS,
+                                NULL, hr, cWIN32OLE_lcid,
+                                (LPTSTR)&p_msg, 0, NULL);
+    }
+    if (dwCount > 0) {
+        term = p_msg + strlen(p_msg);
+        while (p_msg < term) {
+            term--;
+            if (*term == '\r' || *term == '\n')
+                *term = '\0';
+            else break;
+        }
+        if (p_msg[0] != '\0') {
+            rb_str_cat2(msg, p_msg);
+        }
+    }
+    LocalFree(p_msg);
+    return msg;
+}
+
+void
+ole_raise(HRESULT hr, VALUE ecs, const char *fmt, ...)
+{
+    va_list args;
+    VALUE msg;
+    VALUE err_msg;
+    va_init_list(args, fmt);
+    msg = rb_vsprintf(fmt, args);
+    va_end(args);
+
+    err_msg = ole_hresult2msg(hr);
+    if(err_msg != Qnil) {
+        rb_str_cat2(msg, "\n");
+        rb_str_append(msg, err_msg);
+    }
+    rb_exc_raise(rb_exc_new_str(ecs, msg));
+}
+
+void
+Init_win32ole_error(void)
+{
+    /*
+     * Document-class: WIN32OLERuntimeError
+     *
+     * Raised when OLE processing failed.
+     *
+     * EX:
+     *
+     *   obj = WIN32OLE.new("NonExistProgID")
+     *
+     * raises the exception:
+     *
+     *   WIN32OLERuntimeError: unknown OLE server: `NonExistProgID'
+     *       HRESULT error code:0x800401f3
+     *         Invalid class string
+     *
+     */
+    eWIN32OLERuntimeError = rb_define_class("WIN32OLERuntimeError", rb_eRuntimeError);
+    eWIN32OLEQueryInterfaceError = rb_define_class("WIN32OLEQueryInterfaceError", eWIN32OLERuntimeError);
+}

data/ext/win32ole/win32ole_error.h

@@ -0,0 +1,9 @@
+#ifndef WIN32OLE_ERROR_H
+#define WIN32OLE_ERROR_H 1
+
+VALUE eWIN32OLERuntimeError;
+VALUE eWIN32OLEQueryInterfaceError;
+NORETURN(PRINTF_ARGS(void ole_raise(HRESULT hr, VALUE ecs, const char *fmt, ...), 3, 4));
+void Init_win32ole_error(void);
+
+#endif

data/ext/win32ole/win32ole_event.c

@@ -0,0 +1,1277 @@
+#include "win32ole.h"
+
+/*
+ * Document-class: WIN32OLE_EVENT
+ *
+ *   <code>WIN32OLE_EVENT</code> objects controls OLE event.
+ */
+
+RUBY_EXTERN void rb_write_error_str(VALUE mesg);
+
+typedef struct {
+    struct IEventSinkVtbl * lpVtbl;
+} IEventSink, *PEVENTSINK;
+
+typedef struct IEventSinkVtbl IEventSinkVtbl;
+
+struct IEventSinkVtbl {
+    STDMETHOD(QueryInterface)(
+        PEVENTSINK,
+        REFIID,
+        LPVOID *);
+    STDMETHOD_(ULONG, AddRef)(PEVENTSINK);
+    STDMETHOD_(ULONG, Release)(PEVENTSINK);
+
+    STDMETHOD(GetTypeInfoCount)(
+        PEVENTSINK,
+        UINT *);
+    STDMETHOD(GetTypeInfo)(
+        PEVENTSINK,
+        UINT,
+        LCID,
+        ITypeInfo **);
+    STDMETHOD(GetIDsOfNames)(
+        PEVENTSINK,
+        REFIID,
+        OLECHAR **,
+        UINT,
+        LCID,
+        DISPID *);
+    STDMETHOD(Invoke)(
+        PEVENTSINK,
+        DISPID,
+        REFIID,
+        LCID,
+        WORD,
+        DISPPARAMS *,
+        VARIANT *,
+        EXCEPINFO *,
+        UINT *);
+};
+
+typedef struct tagIEVENTSINKOBJ {
+    const IEventSinkVtbl *lpVtbl;
+    DWORD m_cRef;
+    IID m_iid;
+    long  m_event_id;
+    ITypeInfo *pTypeInfo;
+}IEVENTSINKOBJ, *PIEVENTSINKOBJ;
+
+struct oleeventdata {
+    DWORD dwCookie;
+    IConnectionPoint *pConnectionPoint;
+    IDispatch *pDispatch;
+    long event_id;
+};
+
+static VALUE ary_ole_event;
+static ID id_events;
+
+VALUE cWIN32OLE_EVENT;
+
+STDMETHODIMP EVENTSINK_QueryInterface(PEVENTSINK, REFIID, LPVOID*);
+STDMETHODIMP_(ULONG) EVENTSINK_AddRef(PEVENTSINK);
+STDMETHODIMP_(ULONG) EVENTSINK_Release(PEVENTSINK);
+STDMETHODIMP EVENTSINK_GetTypeInfoCount(PEVENTSINK, UINT*);
+STDMETHODIMP EVENTSINK_GetTypeInfo(PEVENTSINK, UINT, LCID, ITypeInfo**);
+STDMETHODIMP EVENTSINK_GetIDsOfNames(PEVENTSINK, REFIID, OLECHAR**, UINT, LCID, DISPID*);
+STDMETHODIMP EVENTSINK_Invoke(PEVENTSINK, DISPID, REFIID, LCID, WORD, DISPPARAMS*, VARIANT*, EXCEPINFO*, UINT*);
+
+static const IEventSinkVtbl vtEventSink = {
+    EVENTSINK_QueryInterface,
+    EVENTSINK_AddRef,
+    EVENTSINK_Release,
+    EVENTSINK_GetTypeInfoCount,
+    EVENTSINK_GetTypeInfo,
+    EVENTSINK_GetIDsOfNames,
+    EVENTSINK_Invoke,
+};
+
+void EVENTSINK_Destructor(PIEVENTSINKOBJ);
+static void ole_val2ptr_variant(VALUE val, VARIANT *var);
+static void hash2ptr_dispparams(VALUE hash, ITypeInfo *pTypeInfo, DISPID dispid, DISPPARAMS *pdispparams);
+static VALUE hash2result(VALUE hash);
+static void ary2ptr_dispparams(VALUE ary, DISPPARAMS *pdispparams);
+static VALUE exec_callback(VALUE arg);
+static VALUE rescue_callback(VALUE arg);
+static HRESULT find_iid(VALUE ole, char *pitf, IID *piid, ITypeInfo **ppTypeInfo);
+static HRESULT find_coclass(ITypeInfo *pTypeInfo, TYPEATTR *pTypeAttr, ITypeInfo **pTypeInfo2, TYPEATTR **pTypeAttr2);
+static HRESULT find_default_source_from_typeinfo(ITypeInfo *pTypeInfo, TYPEATTR *pTypeAttr, ITypeInfo **ppTypeInfo);
+static HRESULT find_default_source(VALUE ole, IID *piid, ITypeInfo **ppTypeInfo);
+static long ole_search_event_at(VALUE ary, VALUE ev);
+static VALUE ole_search_event(VALUE ary, VALUE ev, BOOL  *is_default);
+static VALUE ole_search_handler_method(VALUE handler, VALUE ev, BOOL *is_default_handler);
+static void ole_delete_event(VALUE ary, VALUE ev);
+static void oleevent_free(void *ptr);
+static size_t oleevent_size(const void *ptr);
+static VALUE fev_s_allocate(VALUE klass);
+static VALUE ev_advise(int argc, VALUE *argv, VALUE self);
+static VALUE fev_initialize(int argc, VALUE *argv, VALUE self);
+static void ole_msg_loop(void);
+static VALUE fev_s_msg_loop(VALUE klass);
+static void add_event_call_back(VALUE obj, VALUE event, VALUE data);
+static VALUE ev_on_event(int argc, VALUE *argv, VALUE self, VALUE is_ary_arg);
+static VALUE fev_on_event(int argc, VALUE *argv, VALUE self);
+static VALUE fev_on_event_with_outargs(int argc, VALUE *argv, VALUE self);
+static VALUE fev_off_event(int argc, VALUE *argv, VALUE self);
+static VALUE fev_unadvise(VALUE self);
+static VALUE fev_set_handler(VALUE self, VALUE val);
+static VALUE fev_get_handler(VALUE self);
+static VALUE evs_push(VALUE ev);
+static VALUE evs_delete(long i);
+static VALUE evs_entry(long i);
+static long  evs_length(void);
+
+
+static const rb_data_type_t oleevent_datatype = {
+    "win32ole_event",
+    {NULL, oleevent_free, oleevent_size,},
+    0, 0, RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+STDMETHODIMP EVENTSINK_Invoke(
+    PEVENTSINK pEventSink,
+    DISPID dispid,
+    REFIID riid,
+    LCID lcid,
+    WORD wFlags,
+    DISPPARAMS *pdispparams,
+    VARIANT *pvarResult,
+    EXCEPINFO *pexcepinfo,
+    UINT *puArgErr
+    ) {
+
+    HRESULT hr;
+    BSTR bstr;
+    unsigned int count;
+    unsigned int i;
+    ITypeInfo *pTypeInfo;
+    VARIANT *pvar;
+    VALUE ary, obj, event, args, outargv, ev, result;
+    VALUE handler = Qnil;
+    VALUE arg[3];
+    VALUE mid;
+    VALUE is_outarg = Qfalse;
+    BOOL is_default_handler = FALSE;
+    int state;
+
+    PIEVENTSINKOBJ pEV = (PIEVENTSINKOBJ)pEventSink;
+    pTypeInfo = pEV->pTypeInfo;
+    obj = evs_entry(pEV->m_event_id);
+    if (!rb_obj_is_kind_of(obj, cWIN32OLE_EVENT)) {
+        return NOERROR;
+    }
+
+    ary = rb_ivar_get(obj, id_events);
+    if (NIL_P(ary) || !RB_TYPE_P(ary, T_ARRAY)) {
+        return NOERROR;
+    }
+    hr = pTypeInfo->lpVtbl->GetNames(pTypeInfo, dispid,
+                                     &bstr, 1, &count);
+    if (FAILED(hr)) {
+        return NOERROR;
+    }
+    ev = WC2VSTR(bstr);
+    event = ole_search_event(ary, ev, &is_default_handler);
+    if (RB_TYPE_P(event, T_ARRAY)) {
+        handler = rb_ary_entry(event, 0);
+        mid = rb_intern("call");
+        is_outarg = rb_ary_entry(event, 3);
+    } else {
+        handler = rb_ivar_get(obj, rb_intern("handler"));
+        if (handler == Qnil) {
+            return NOERROR;
+        }
+        mid = ole_search_handler_method(handler, ev, &is_default_handler);
+    }
+    if (handler == Qnil || mid == Qnil) {
+        return NOERROR;
+    }
+
+    args = rb_ary_new();
+    if (is_default_handler) {
+        rb_ary_push(args, ev);
+    }
+
+    /* make argument of event handler */
+    for (i = 0; i < pdispparams->cArgs; ++i) {
+        pvar = &pdispparams->rgvarg[pdispparams->cArgs-i-1];
+        rb_ary_push(args, ole_variant2val(pvar));
+    }
+    outargv = Qnil;
+    if (is_outarg == Qtrue) {
+	outargv = rb_ary_new();
+        rb_ary_push(args, outargv);
+    }
+
+    /*
+     * if exception raised in event callback,
+     * then you receive cfp consistency error.
+     * to avoid this error we use begin rescue end.
+     * and the exception raised then error message print
+     * and exit ruby process by Win32OLE itself.
+     */
+    arg[0] = handler;
+    arg[1] = mid;
+    arg[2] = args;
+    result = rb_protect(exec_callback, (VALUE)arg, &state);
+    if (state != 0) {
+        rescue_callback(Qnil);
+    }
+    if(RB_TYPE_P(result, T_HASH)) {
+        hash2ptr_dispparams(result, pTypeInfo, dispid, pdispparams);
+        result = hash2result(result);
+    }else if (is_outarg == Qtrue && RB_TYPE_P(outargv, T_ARRAY)) {
+        ary2ptr_dispparams(outargv, pdispparams);
+    }
+
+    if (pvarResult) {
+        VariantInit(pvarResult);
+        ole_val2variant(result, pvarResult);
+    }
+
+    return NOERROR;
+}
+
+STDMETHODIMP
+EVENTSINK_QueryInterface(
+    PEVENTSINK pEV,
+    REFIID     iid,
+    LPVOID*    ppv
+    ) {
+    if (IsEqualIID(iid, &IID_IUnknown) ||
+        IsEqualIID(iid, &IID_IDispatch) ||
+        IsEqualIID(iid, &((PIEVENTSINKOBJ)pEV)->m_iid)) {
+        *ppv = pEV;
+    }
+    else {
+        *ppv = NULL;
+        return E_NOINTERFACE;
+    }
+    ((LPUNKNOWN)*ppv)->lpVtbl->AddRef((LPUNKNOWN)*ppv);
+    return NOERROR;
+}
+
+STDMETHODIMP_(ULONG)
+EVENTSINK_AddRef(
+    PEVENTSINK pEV
+    ){
+    PIEVENTSINKOBJ pEVObj = (PIEVENTSINKOBJ)pEV;
+    return ++pEVObj->m_cRef;
+}
+
+STDMETHODIMP_(ULONG) EVENTSINK_Release(
+    PEVENTSINK pEV
+    ) {
+    PIEVENTSINKOBJ pEVObj = (PIEVENTSINKOBJ)pEV;
+    --pEVObj->m_cRef;
+    if(pEVObj->m_cRef != 0)
+        return pEVObj->m_cRef;
+    EVENTSINK_Destructor(pEVObj);
+    return 0;
+}
+
+STDMETHODIMP EVENTSINK_GetTypeInfoCount(
+    PEVENTSINK pEV,
+    UINT *pct
+    ) {
+    *pct = 0;
+    return NOERROR;
+}
+
+STDMETHODIMP EVENTSINK_GetTypeInfo(
+    PEVENTSINK pEV,
+    UINT info,
+    LCID lcid,
+    ITypeInfo **pInfo
+    ) {
+    *pInfo = NULL;
+    return DISP_E_BADINDEX;
+}
+
+STDMETHODIMP EVENTSINK_GetIDsOfNames(
+    PEVENTSINK pEventSink,
+    REFIID riid,
+    OLECHAR **szNames,
+    UINT cNames,
+    LCID lcid,
+    DISPID *pDispID
+    ) {
+    ITypeInfo *pTypeInfo;
+    PIEVENTSINKOBJ pEV = (PIEVENTSINKOBJ)pEventSink;
+    pTypeInfo = pEV->pTypeInfo;
+    if (pTypeInfo) {
+        return pTypeInfo->lpVtbl->GetIDsOfNames(pTypeInfo, szNames, cNames, pDispID);
+    }
+    return DISP_E_UNKNOWNNAME;
+}
+
+PIEVENTSINKOBJ
+EVENTSINK_Constructor(void)
+{
+    PIEVENTSINKOBJ pEv;
+    pEv = ALLOC_N(IEVENTSINKOBJ, 1);
+    if(pEv == NULL) return NULL;
+    pEv->lpVtbl = &vtEventSink;
+    pEv->m_cRef = 0;
+    pEv->m_event_id = 0;
+    pEv->pTypeInfo = NULL;
+    return pEv;
+}
+
+void
+EVENTSINK_Destructor(
+    PIEVENTSINKOBJ pEVObj
+    ) {
+    if(pEVObj != NULL) {
+        OLE_RELEASE(pEVObj->pTypeInfo);
+        free(pEVObj);
+        pEVObj = NULL;
+    }
+}
+
+static void
+ole_val2ptr_variant(VALUE val, VARIANT *var)
+{
+    switch (TYPE(val)) {
+    case T_STRING:
+        if (V_VT(var) == (VT_BSTR | VT_BYREF)) {
+            *V_BSTRREF(var) = ole_vstr2wc(val);
+        }
+        break;
+    case T_FIXNUM:
+        switch(V_VT(var)) {
+        case (VT_UI1 | VT_BYREF) :
+            *V_UI1REF(var) = RB_NUM2CHR(val);
+            break;
+        case (VT_I2 | VT_BYREF) :
+            *V_I2REF(var) = (short)RB_NUM2INT(val);
+            break;
+        case (VT_I4 | VT_BYREF) :
+            *V_I4REF(var) = RB_NUM2INT(val);
+            break;
+        case (VT_R4 | VT_BYREF) :
+            *V_R4REF(var) = (float)RB_NUM2INT(val);
+            break;
+        case (VT_R8 | VT_BYREF) :
+            *V_R8REF(var) = RB_NUM2INT(val);
+            break;
+        default:
+            break;
+        }
+        break;
+    case T_FLOAT:
+        switch(V_VT(var)) {
+        case (VT_I2 | VT_BYREF) :
+            *V_I2REF(var) = (short)RB_NUM2INT(val);
+            break;
+        case (VT_I4 | VT_BYREF) :
+            *V_I4REF(var) = RB_NUM2INT(val);
+            break;
+        case (VT_R4 | VT_BYREF) :
+            *V_R4REF(var) = (float)NUM2DBL(val);
+            break;
+        case (VT_R8 | VT_BYREF) :
+            *V_R8REF(var) = NUM2DBL(val);
+            break;
+        default:
+            break;
+        }
+        break;
+    case T_BIGNUM:
+        if (V_VT(var) == (VT_R8 | VT_BYREF)) {
+            *V_R8REF(var) = rb_big2dbl(val);
+        }
+        break;
+    case T_TRUE:
+        if (V_VT(var) == (VT_BOOL | VT_BYREF)) {
+            *V_BOOLREF(var) = VARIANT_TRUE;
+        }
+        break;
+    case T_FALSE:
+        if (V_VT(var) == (VT_BOOL | VT_BYREF)) {
+            *V_BOOLREF(var) = VARIANT_FALSE;
+        }
+        break;
+    default:
+        break;
+    }
+}
+
+static void
+hash2ptr_dispparams(VALUE hash, ITypeInfo *pTypeInfo, DISPID dispid, DISPPARAMS *pdispparams)
+{
+    BSTR *bstrs;
+    HRESULT hr;
+    UINT len, i;
+    VARIANT *pvar;
+    VALUE val;
+    VALUE key;
+    len = 0;
+    bstrs = ALLOCA_N(BSTR, pdispparams->cArgs + 1);
+    hr = pTypeInfo->lpVtbl->GetNames(pTypeInfo, dispid,
+                                     bstrs, pdispparams->cArgs + 1,
+                                     &len);
+    if (FAILED(hr))
+	return;
+
+    for (i = 0; i < len - 1; i++) {
+	key = WC2VSTR(bstrs[i + 1]);
+        val = rb_hash_aref(hash, RB_UINT2NUM(i));
+	if (val == Qnil)
+	    val = rb_hash_aref(hash, key);
+	if (val == Qnil)
+	    val = rb_hash_aref(hash, rb_str_intern(key));
+        pvar = &pdispparams->rgvarg[pdispparams->cArgs-i-1];
+        ole_val2ptr_variant(val, pvar);
+    }
+}
+
+static VALUE
+hash2result(VALUE hash)
+{
+    VALUE ret = Qnil;
+    ret = rb_hash_aref(hash, rb_str_new2("return"));
+    if (ret == Qnil)
+	ret = rb_hash_aref(hash, rb_str_intern(rb_str_new2("return")));
+    return ret;
+}
+
+static void
+ary2ptr_dispparams(VALUE ary, DISPPARAMS *pdispparams)
+{
+    int i;
+    VALUE v;
+    VARIANT *pvar;
+    for(i = 0; i < RARRAY_LEN(ary) && (unsigned int) i < pdispparams->cArgs; i++) {
+        v = rb_ary_entry(ary, i);
+        pvar = &pdispparams->rgvarg[pdispparams->cArgs-i-1];
+        ole_val2ptr_variant(v, pvar);
+    }
+}
+
+static VALUE
+exec_callback(VALUE arg)
+{
+    VALUE *parg = (VALUE *)arg;
+    VALUE handler = parg[0];
+    VALUE mid = parg[1];
+    VALUE args = parg[2];
+    return rb_apply(handler, mid, args);
+}
+
+static VALUE
+rescue_callback(VALUE arg)
+{
+
+    VALUE error;
+    VALUE e = rb_errinfo();
+    VALUE bt = rb_funcall(e, rb_intern("backtrace"), 0);
+    VALUE msg = rb_funcall(e, rb_intern("message"), 0);
+    bt = rb_ary_entry(bt, 0);
+    error = rb_sprintf("%"PRIsVALUE": %"PRIsVALUE" (%s)\n", bt, msg, rb_obj_classname(e));
+    rb_write_error_str(error);
+    rb_backtrace();
+    ruby_finalize();
+    exit(-1);
+
+    return Qnil;
+}
+
+static HRESULT
+find_iid(VALUE ole, char *pitf, IID *piid, ITypeInfo **ppTypeInfo)
+{
+    HRESULT hr;
+    IDispatch *pDispatch;
+    ITypeInfo *pTypeInfo;
+    ITypeLib *pTypeLib;
+    TYPEATTR *pTypeAttr;
+    HREFTYPE RefType;
+    ITypeInfo *pImplTypeInfo;
+    TYPEATTR *pImplTypeAttr;
+
+    struct oledata *pole = NULL;
+    unsigned int index;
+    unsigned int count;
+    int type;
+    BSTR bstr;
+    char *pstr;
+
+    BOOL is_found = FALSE;
+    LCID    lcid = cWIN32OLE_lcid;
+
+    pole = oledata_get_struct(ole);
+
+    pDispatch = pole->pDispatch;
+
+    hr = pDispatch->lpVtbl->GetTypeInfo(pDispatch, 0, lcid, &pTypeInfo);
+    if (FAILED(hr))
+        return hr;
+
+    hr = pTypeInfo->lpVtbl->GetContainingTypeLib(pTypeInfo,
+                                                 &pTypeLib,
+                                                 &index);
+    OLE_RELEASE(pTypeInfo);
+    if (FAILED(hr))
+        return hr;
+
+    if (!pitf) {
+        hr = pTypeLib->lpVtbl->GetTypeInfoOfGuid(pTypeLib,
+                                                 piid,
+                                                 ppTypeInfo);
+        OLE_RELEASE(pTypeLib);
+        return hr;
+    }
+    count = pTypeLib->lpVtbl->GetTypeInfoCount(pTypeLib);
+    for (index = 0; index < count; index++) {
+        hr = pTypeLib->lpVtbl->GetTypeInfo(pTypeLib,
+                                           index,
+                                           &pTypeInfo);
+        if (FAILED(hr))
+            break;
+        hr = OLE_GET_TYPEATTR(pTypeInfo, &pTypeAttr);
+
+        if(FAILED(hr)) {
+            OLE_RELEASE(pTypeInfo);
+            break;
+        }
+        if(pTypeAttr->typekind == TKIND_COCLASS) {
+            for (type = 0; type < pTypeAttr->cImplTypes; type++) {
+                hr = pTypeInfo->lpVtbl->GetRefTypeOfImplType(pTypeInfo,
+                                                             type,
+                                                             &RefType);
+                if (FAILED(hr))
+                    break;
+                hr = pTypeInfo->lpVtbl->GetRefTypeInfo(pTypeInfo,
+                                                       RefType,
+                                                       &pImplTypeInfo);
+                if (FAILED(hr))
+                    break;
+
+                hr = pImplTypeInfo->lpVtbl->GetDocumentation(pImplTypeInfo,
+                                                             -1,
+                                                             &bstr,
+                                                             NULL, NULL, NULL);
+                if (FAILED(hr)) {
+                    OLE_RELEASE(pImplTypeInfo);
+                    break;
+                }
+                pstr = ole_wc2mb(bstr);
+                if (strcmp(pitf, pstr) == 0) {
+                    hr = pImplTypeInfo->lpVtbl->GetTypeAttr(pImplTypeInfo,
+                                                            &pImplTypeAttr);
+                    if (SUCCEEDED(hr)) {
+                        is_found = TRUE;
+                        *piid = pImplTypeAttr->guid;
+                        if (ppTypeInfo) {
+                            *ppTypeInfo = pImplTypeInfo;
+                            (*ppTypeInfo)->lpVtbl->AddRef((*ppTypeInfo));
+                        }
+                        pImplTypeInfo->lpVtbl->ReleaseTypeAttr(pImplTypeInfo,
+                                                               pImplTypeAttr);
+                    }
+                }
+                free(pstr);
+                OLE_RELEASE(pImplTypeInfo);
+                if (is_found || FAILED(hr))
+                    break;
+            }
+        }
+
+        OLE_RELEASE_TYPEATTR(pTypeInfo, pTypeAttr);
+        OLE_RELEASE(pTypeInfo);
+        if (is_found || FAILED(hr))
+            break;
+    }
+    OLE_RELEASE(pTypeLib);
+    if(!is_found)
+        return E_NOINTERFACE;
+    return hr;
+}
+
+static HRESULT
+find_coclass(
+    ITypeInfo *pTypeInfo,
+    TYPEATTR *pTypeAttr,
+    ITypeInfo **pCOTypeInfo,
+    TYPEATTR **pCOTypeAttr)
+{
+    HRESULT hr = E_NOINTERFACE;
+    ITypeLib *pTypeLib;
+    int count;
+    BOOL found = FALSE;
+    ITypeInfo *pTypeInfo2;
+    TYPEATTR *pTypeAttr2;
+    int flags;
+    int i,j;
+    HREFTYPE href;
+    ITypeInfo *pRefTypeInfo;
+    TYPEATTR *pRefTypeAttr;
+
+    hr = pTypeInfo->lpVtbl->GetContainingTypeLib(pTypeInfo, &pTypeLib, NULL);
+    if (FAILED(hr)) {
+	return hr;
+    }
+    count = pTypeLib->lpVtbl->GetTypeInfoCount(pTypeLib);
+    for (i = 0; i < count && !found; i++) {
+        hr = pTypeLib->lpVtbl->GetTypeInfo(pTypeLib, i, &pTypeInfo2);
+        if (FAILED(hr))
+            continue;
+        hr = OLE_GET_TYPEATTR(pTypeInfo2, &pTypeAttr2);
+        if (FAILED(hr)) {
+            OLE_RELEASE(pTypeInfo2);
+            continue;
+        }
+        if (pTypeAttr2->typekind != TKIND_COCLASS) {
+            OLE_RELEASE_TYPEATTR(pTypeInfo2, pTypeAttr2);
+            OLE_RELEASE(pTypeInfo2);
+            continue;
+        }
+        for (j = 0; j < pTypeAttr2->cImplTypes && !found; j++) {
+            hr = pTypeInfo2->lpVtbl->GetImplTypeFlags(pTypeInfo2, j, &flags);
+            if (FAILED(hr))
+                continue;
+            if (!(flags & IMPLTYPEFLAG_FDEFAULT))
+                continue;
+            hr = pTypeInfo2->lpVtbl->GetRefTypeOfImplType(pTypeInfo2, j, &href);
+            if (FAILED(hr))
+                continue;
+            hr = pTypeInfo2->lpVtbl->GetRefTypeInfo(pTypeInfo2, href, &pRefTypeInfo);
+            if (FAILED(hr))
+                continue;
+            hr = OLE_GET_TYPEATTR(pRefTypeInfo, &pRefTypeAttr);
+            if (FAILED(hr))  {
+                OLE_RELEASE(pRefTypeInfo);
+                continue;
+            }
+            if (IsEqualGUID(&(pTypeAttr->guid), &(pRefTypeAttr->guid))) {
+                found = TRUE;
+            }
+        }
+        if (!found) {
+            OLE_RELEASE_TYPEATTR(pTypeInfo2, pTypeAttr2);
+            OLE_RELEASE(pTypeInfo2);
+        }
+    }
+    OLE_RELEASE(pTypeLib);
+    if (found) {
+        *pCOTypeInfo = pTypeInfo2;
+        *pCOTypeAttr = pTypeAttr2;
+        hr = S_OK;
+    } else {
+        hr = E_NOINTERFACE;
+    }
+    return hr;
+}
+
+static HRESULT
+find_default_source_from_typeinfo(
+    ITypeInfo *pTypeInfo,
+    TYPEATTR *pTypeAttr,
+    ITypeInfo **ppTypeInfo)
+{
+    int i = 0;
+    HRESULT hr = E_NOINTERFACE;
+    int flags;
+    HREFTYPE hRefType;
+    /* Enumerate all implemented types of the COCLASS */
+    for (i = 0; i < pTypeAttr->cImplTypes; i++) {
+        hr = pTypeInfo->lpVtbl->GetImplTypeFlags(pTypeInfo, i, &flags);
+        if (FAILED(hr))
+            continue;
+
+        /*
+           looking for the [default] [source]
+           we just hope that it is a dispinterface :-)
+        */
+        if ((flags & IMPLTYPEFLAG_FDEFAULT) &&
+            (flags & IMPLTYPEFLAG_FSOURCE)) {
+
+            hr = pTypeInfo->lpVtbl->GetRefTypeOfImplType(pTypeInfo,
+                                                         i, &hRefType);
+            if (FAILED(hr))
+                continue;
+            hr = pTypeInfo->lpVtbl->GetRefTypeInfo(pTypeInfo,
+                                                   hRefType, ppTypeInfo);
+            if (SUCCEEDED(hr))
+                break;
+        }
+    }
+    return hr;
+}
+
+static HRESULT
+find_default_source(VALUE ole, IID *piid, ITypeInfo **ppTypeInfo)
+{
+    HRESULT hr;
+    IProvideClassInfo2 *pProvideClassInfo2;
+    IProvideClassInfo *pProvideClassInfo;
+    void *p;
+
+    IDispatch *pDispatch;
+    ITypeInfo *pTypeInfo;
+    ITypeInfo *pTypeInfo2 = NULL;
+    TYPEATTR *pTypeAttr;
+    TYPEATTR *pTypeAttr2 = NULL;
+
+    struct oledata *pole = NULL;
+
+    pole = oledata_get_struct(ole);
+    pDispatch = pole->pDispatch;
+    hr = pDispatch->lpVtbl->QueryInterface(pDispatch,
+                                           &IID_IProvideClassInfo2,
+                                           &p);
+    if (SUCCEEDED(hr)) {
+        pProvideClassInfo2 = p;
+        hr = pProvideClassInfo2->lpVtbl->GetGUID(pProvideClassInfo2,
+                                                 GUIDKIND_DEFAULT_SOURCE_DISP_IID,
+                                                 piid);
+        OLE_RELEASE(pProvideClassInfo2);
+        if (SUCCEEDED(hr)) {
+            hr = find_iid(ole, NULL, piid, ppTypeInfo);
+        }
+    }
+    if (SUCCEEDED(hr)) {
+        return hr;
+    }
+    hr = pDispatch->lpVtbl->QueryInterface(pDispatch,
+            &IID_IProvideClassInfo,
+            &p);
+    if (SUCCEEDED(hr)) {
+        pProvideClassInfo = p;
+        hr = pProvideClassInfo->lpVtbl->GetClassInfo(pProvideClassInfo,
+                                                     &pTypeInfo);
+        OLE_RELEASE(pProvideClassInfo);
+    }
+    if (FAILED(hr)) {
+        hr = pDispatch->lpVtbl->GetTypeInfo(pDispatch, 0, cWIN32OLE_lcid, &pTypeInfo );
+    }
+    if (FAILED(hr))
+        return hr;
+    hr = OLE_GET_TYPEATTR(pTypeInfo, &pTypeAttr);
+    if (FAILED(hr)) {
+        OLE_RELEASE(pTypeInfo);
+        return hr;
+    }
+
+    *ppTypeInfo = 0;
+    hr = find_default_source_from_typeinfo(pTypeInfo, pTypeAttr, ppTypeInfo);
+    if (!*ppTypeInfo) {
+        hr = find_coclass(pTypeInfo, pTypeAttr, &pTypeInfo2, &pTypeAttr2);
+        if (SUCCEEDED(hr)) {
+            hr = find_default_source_from_typeinfo(pTypeInfo2, pTypeAttr2, ppTypeInfo);
+            OLE_RELEASE_TYPEATTR(pTypeInfo2, pTypeAttr2);
+            OLE_RELEASE(pTypeInfo2);
+        }
+    }
+    OLE_RELEASE_TYPEATTR(pTypeInfo, pTypeAttr);
+    OLE_RELEASE(pTypeInfo);
+    /* Now that would be a bad surprise, if we didn't find it, wouldn't it? */
+    if (!*ppTypeInfo) {
+        if (SUCCEEDED(hr))
+            hr = E_UNEXPECTED;
+        return hr;
+    }
+
+    /* Determine IID of default source interface */
+    hr = (*ppTypeInfo)->lpVtbl->GetTypeAttr(*ppTypeInfo, &pTypeAttr);
+    if (SUCCEEDED(hr)) {
+        *piid = pTypeAttr->guid;
+        (*ppTypeInfo)->lpVtbl->ReleaseTypeAttr(*ppTypeInfo, pTypeAttr);
+    }
+    else
+        OLE_RELEASE(*ppTypeInfo);
+
+    return hr;
+}
+
+static long
+ole_search_event_at(VALUE ary, VALUE ev)
+{
+    VALUE event;
+    VALUE event_name;
+    long i, len;
+    long ret = -1;
+    len = RARRAY_LEN(ary);
+    for(i = 0; i < len; i++) {
+        event = rb_ary_entry(ary, i);
+        event_name = rb_ary_entry(event, 1);
+        if(NIL_P(event_name) && NIL_P(ev)) {
+            ret = i;
+            break;
+        }
+        else if (RB_TYPE_P(ev, T_STRING) &&
+                 RB_TYPE_P(event_name, T_STRING) &&
+                 rb_str_cmp(ev, event_name) == 0) {
+            ret = i;
+            break;
+        }
+    }
+    return ret;
+}
+
+static VALUE
+ole_search_event(VALUE ary, VALUE ev, BOOL  *is_default)
+{
+    VALUE event;
+    VALUE def_event;
+    VALUE event_name;
+    int i, len;
+    *is_default = FALSE;
+    def_event = Qnil;
+    len = RARRAY_LEN(ary);
+    for(i = 0; i < len; i++) {
+        event = rb_ary_entry(ary, i);
+        event_name = rb_ary_entry(event, 1);
+        if(NIL_P(event_name)) {
+            *is_default = TRUE;
+            def_event = event;
+        }
+        else if (rb_str_cmp(ev, event_name) == 0) {
+            *is_default = FALSE;
+            return event;
+        }
+    }
+    return def_event;
+}
+
+static VALUE
+ole_search_handler_method(VALUE handler, VALUE ev, BOOL *is_default_handler)
+{
+    VALUE mid;
+
+    *is_default_handler = FALSE;
+    mid = rb_to_id(rb_sprintf("on%"PRIsVALUE, ev));
+    if (rb_respond_to(handler, mid)) {
+        return mid;
+    }
+    mid = rb_intern("method_missing");
+    if (rb_respond_to(handler, mid)) {
+        *is_default_handler = TRUE;
+        return mid;
+    }
+    return Qnil;
+}
+
+static void
+ole_delete_event(VALUE ary, VALUE ev)
+{
+    long at = -1;
+    at = ole_search_event_at(ary, ev);
+    if (at >= 0) {
+        rb_ary_delete_at(ary, at);
+    }
+}
+
+
+static void
+oleevent_free(void *ptr)
+{
+    struct oleeventdata *poleev = ptr;
+    if (poleev->pConnectionPoint) {
+        poleev->pConnectionPoint->lpVtbl->Unadvise(poleev->pConnectionPoint, poleev->dwCookie);
+        OLE_RELEASE(poleev->pConnectionPoint);
+        poleev->pConnectionPoint = NULL;
+    }
+    OLE_RELEASE(poleev->pDispatch);
+    free(poleev);
+}
+
+static size_t
+oleevent_size(const void *ptr)
+{
+    return ptr ? sizeof(struct oleeventdata) : 0;
+}
+
+static VALUE
+fev_s_allocate(VALUE klass)
+{
+    VALUE obj;
+    struct oleeventdata *poleev;
+    obj = TypedData_Make_Struct(klass, struct oleeventdata, &oleevent_datatype, poleev);
+    poleev->dwCookie = 0;
+    poleev->pConnectionPoint = NULL;
+    poleev->event_id = 0;
+    poleev->pDispatch = NULL;
+    return obj;
+}
+
+static VALUE
+ev_advise(int argc, VALUE *argv, VALUE self)
+{
+
+    VALUE ole, itf;
+    struct oledata *pole = NULL;
+    char *pitf;
+    HRESULT hr;
+    IID iid;
+    ITypeInfo *pTypeInfo = 0;
+    IDispatch *pDispatch;
+    IConnectionPointContainer *pContainer;
+    IConnectionPoint *pConnectionPoint;
+    IEVENTSINKOBJ *pIEV;
+    DWORD dwCookie;
+    struct oleeventdata *poleev;
+    void *p;
+
+    rb_scan_args(argc, argv, "11", &ole, &itf);
+
+    if (!rb_obj_is_kind_of(ole, cWIN32OLE)) {
+        rb_raise(rb_eTypeError, "1st parameter must be WIN32OLE object");
+    }
+
+    if(!RB_TYPE_P(itf, T_NIL)) {
+        pitf = StringValuePtr(itf);
+        hr = find_iid(ole, pitf, &iid, &pTypeInfo);
+    }
+    else {
+        hr = find_default_source(ole, &iid, &pTypeInfo);
+    }
+    if (FAILED(hr)) {
+        ole_raise(hr, rb_eRuntimeError, "interface not found");
+    }
+
+    pole = oledata_get_struct(ole);
+    pDispatch = pole->pDispatch;
+    hr = pDispatch->lpVtbl->QueryInterface(pDispatch,
+                                           &IID_IConnectionPointContainer,
+                                           &p);
+    if (FAILED(hr)) {
+        OLE_RELEASE(pTypeInfo);
+        ole_raise(hr, eWIN32OLEQueryInterfaceError,
+                  "failed to query IConnectionPointContainer");
+    }
+    pContainer = p;
+
+    hr = pContainer->lpVtbl->FindConnectionPoint(pContainer,
+                                                 &iid,
+                                                 &pConnectionPoint);
+    OLE_RELEASE(pContainer);
+    if (FAILED(hr)) {
+        OLE_RELEASE(pTypeInfo);
+        ole_raise(hr, eWIN32OLEQueryInterfaceError, "failed to query IConnectionPoint");
+    }
+    pIEV = EVENTSINK_Constructor();
+    pIEV->m_iid = iid;
+    hr = pConnectionPoint->lpVtbl->Advise(pConnectionPoint,
+                                          (IUnknown*)pIEV,
+                                          &dwCookie);
+    if (FAILED(hr)) {
+        ole_raise(hr, eWIN32OLEQueryInterfaceError, "Advise Error");
+    }
+
+    TypedData_Get_Struct(self, struct oleeventdata, &oleevent_datatype, poleev);
+    pIEV->m_event_id = evs_length();
+    pIEV->pTypeInfo = pTypeInfo;
+    poleev->dwCookie = dwCookie;
+    poleev->pConnectionPoint = pConnectionPoint;
+    poleev->event_id = pIEV->m_event_id;
+    poleev->pDispatch = pDispatch;
+    OLE_ADDREF(pDispatch);
+
+    return self;
+}
+
+/*
+ *  call-seq:
+ *     WIN32OLE_EVENT.new(ole, event) #=> WIN32OLE_EVENT object.
+ *
+ *  Returns OLE event object.
+ *  The first argument specifies WIN32OLE object.
+ *  The second argument specifies OLE event name.
+ *     ie = WIN32OLE.new('InternetExplorer.Application')
+ *     ev = WIN32OLE_EVENT.new(ie, 'DWebBrowserEvents')
+ */
+static VALUE
+fev_initialize(int argc, VALUE *argv, VALUE self)
+{
+    ev_advise(argc, argv, self);
+    evs_push(self);
+    rb_ivar_set(self, id_events, rb_ary_new());
+    fev_set_handler(self, Qnil);
+    return self;
+}
+
+static void
+ole_msg_loop(void)
+{
+    MSG msg;
+    while(PeekMessage(&msg,NULL,0,0,PM_REMOVE)) {
+        TranslateMessage(&msg);
+        DispatchMessage(&msg);
+    }
+}
+
+/*
+ *  call-seq:
+ *     WIN32OLE_EVENT.message_loop
+ *
+ *  Translates and dispatches Windows message.
+ */
+static VALUE
+fev_s_msg_loop(VALUE klass)
+{
+    ole_msg_loop();
+    return Qnil;
+}
+
+static void
+add_event_call_back(VALUE obj, VALUE event, VALUE data)
+{
+    VALUE events = rb_ivar_get(obj, id_events);
+    if (NIL_P(events) || !RB_TYPE_P(events, T_ARRAY)) {
+        events = rb_ary_new();
+        rb_ivar_set(obj, id_events, events);
+    }
+    ole_delete_event(events, event);
+    rb_ary_push(events, data);
+}
+
+static VALUE
+ev_on_event(int argc, VALUE *argv, VALUE self, VALUE is_ary_arg)
+{
+    struct oleeventdata *poleev;
+    VALUE event, args, data;
+    TypedData_Get_Struct(self, struct oleeventdata, &oleevent_datatype, poleev);
+    if (poleev->pConnectionPoint == NULL) {
+        rb_raise(eWIN32OLERuntimeError, "IConnectionPoint not found. You must call advise at first.");
+    }
+    rb_scan_args(argc, argv, "01*", &event, &args);
+    if(!NIL_P(event)) {
+        if(!RB_TYPE_P(event, T_STRING) && !RB_TYPE_P(event, T_SYMBOL)) {
+            rb_raise(rb_eTypeError, "wrong argument type (expected String or Symbol)");
+        }
+        if (RB_TYPE_P(event, T_SYMBOL)) {
+            event = rb_sym2str(event);
+        }
+    }
+    data = rb_ary_new3(4, rb_block_proc(), event, args, is_ary_arg);
+    add_event_call_back(self, event, data);
+    return Qnil;
+}
+
+/*
+ *  call-seq:
+ *     WIN32OLE_EVENT#on_event([event]){...}
+ *
+ *  Defines the callback event.
+ *  If argument is omitted, this method defines the callback of all events.
+ *  If you want to modify reference argument in callback, return hash in
+ *  callback. If you want to return value to OLE server as result of callback
+ *  use `return' or :return.
+ *
+ *    ie = WIN32OLE.new('InternetExplorer.Application')
+ *    ev = WIN32OLE_EVENT.new(ie)
+ *    ev.on_event("NavigateComplete") {|url| puts url}
+ *    ev.on_event() {|ev, *args| puts "#{ev} fired"}
+ *
+ *    ev.on_event("BeforeNavigate2") {|*args|
+ *      ...
+ *      # set true to BeforeNavigate reference argument `Cancel'.
+ *      # Cancel is 7-th argument of BeforeNavigate,
+ *      # so you can use 6 as key of hash instead of 'Cancel'.
+ *      # The argument is counted from 0.
+ *      # The hash key of 0 means first argument.)
+ *      {:Cancel => true}  # or {'Cancel' => true} or {6 => true}
+ *    }
+ *
+ *    ev.on_event(...) {|*args|
+ *      {:return => 1, :xxx => yyy}
+ *    }
+ */
+static VALUE
+fev_on_event(int argc, VALUE *argv, VALUE self)
+{
+    return ev_on_event(argc, argv, self, Qfalse);
+}
+
+/*
+ *  call-seq:
+ *     WIN32OLE_EVENT#on_event_with_outargs([event]){...}
+ *
+ *  Defines the callback of event.
+ *  If you want modify argument in callback,
+ *  you could use this method instead of WIN32OLE_EVENT#on_event.
+ *
+ *    ie = WIN32OLE.new('InternetExplorer.Application')
+ *    ev = WIN32OLE_EVENT.new(ie)
+ *    ev.on_event_with_outargs('BeforeNavigate2') {|*args|
+ *      args.last[6] = true
+ *    }
+ */
+static VALUE
+fev_on_event_with_outargs(int argc, VALUE *argv, VALUE self)
+{
+    return ev_on_event(argc, argv, self, Qtrue);
+}
+
+/*
+ *  call-seq:
+ *     WIN32OLE_EVENT#off_event([event])
+ *
+ *  removes the callback of event.
+ *
+ *    ie = WIN32OLE.new('InternetExplorer.Application')
+ *    ev = WIN32OLE_EVENT.new(ie)
+ *    ev.on_event('BeforeNavigate2') {|*args|
+ *      args.last[6] = true
+ *    }
+ *      ...
+ *    ev.off_event('BeforeNavigate2')
+ *      ...
+ */
+static VALUE
+fev_off_event(int argc, VALUE *argv, VALUE self)
+{
+    VALUE event = Qnil;
+    VALUE events;
+
+    rb_scan_args(argc, argv, "01", &event);
+    if(!NIL_P(event)) {
+        if(!RB_TYPE_P(event, T_STRING) && !RB_TYPE_P(event, T_SYMBOL)) {
+            rb_raise(rb_eTypeError, "wrong argument type (expected String or Symbol)");
+        }
+        if (RB_TYPE_P(event, T_SYMBOL)) {
+            event = rb_sym2str(event);
+        }
+    }
+    events = rb_ivar_get(self, id_events);
+    if (NIL_P(events)) {
+        return Qnil;
+    }
+    ole_delete_event(events, event);
+    return Qnil;
+}
+
+/*
+ *  call-seq:
+ *     WIN32OLE_EVENT#unadvise -> nil
+ *
+ *  disconnects OLE server. If this method called, then the WIN32OLE_EVENT object
+ *  does not receive the OLE server event any more.
+ *  This method is trial implementation.
+ *
+ *      ie = WIN32OLE.new('InternetExplorer.Application')
+ *      ev = WIN32OLE_EVENT.new(ie)
+ *      ev.on_event() {...}
+ *         ...
+ *      ev.unadvise
+ *
+ */
+static VALUE
+fev_unadvise(VALUE self)
+{
+    struct oleeventdata *poleev;
+    TypedData_Get_Struct(self, struct oleeventdata, &oleevent_datatype, poleev);
+    if (poleev->pConnectionPoint) {
+        ole_msg_loop();
+        evs_delete(poleev->event_id);
+        poleev->pConnectionPoint->lpVtbl->Unadvise(poleev->pConnectionPoint, poleev->dwCookie);
+        OLE_RELEASE(poleev->pConnectionPoint);
+        poleev->pConnectionPoint = NULL;
+    }
+    OLE_FREE(poleev->pDispatch);
+    return Qnil;
+}
+
+static VALUE
+evs_push(VALUE ev)
+{
+    return rb_ary_push(ary_ole_event, ev);
+}
+
+static VALUE
+evs_delete(long i)
+{
+    rb_ary_store(ary_ole_event, i, Qnil);
+    return Qnil;
+}
+
+static VALUE
+evs_entry(long i)
+{
+    return rb_ary_entry(ary_ole_event, i);
+}
+
+static long
+evs_length(void)
+{
+    return RARRAY_LEN(ary_ole_event);
+}
+
+/*
+ *  call-seq:
+ *     WIN32OLE_EVENT#handler=
+ *
+ *  sets event handler object. If handler object has onXXX
+ *  method according to XXX event, then onXXX method is called
+ *  when XXX event occurs.
+ *
+ *  If handler object has method_missing and there is no
+ *  method according to the event, then method_missing
+ *  called and 1-st argument is event name.
+ *
+ *  If handler object has onXXX method and there is block
+ *  defined by WIN32OLE_EVENT#on_event('XXX'){},
+ *  then block is executed but handler object method is not called
+ *  when XXX event occurs.
+ *
+ *      class Handler
+ *        def onStatusTextChange(text)
+ *          puts "StatusTextChanged"
+ *        end
+ *        def onPropertyChange(prop)
+ *          puts "PropertyChanged"
+ *        end
+ *        def method_missing(ev, *arg)
+ *          puts "other event #{ev}"
+ *        end
+ *      end
+ *
+ *      handler = Handler.new
+ *      ie = WIN32OLE.new('InternetExplorer.Application')
+ *      ev = WIN32OLE_EVENT.new(ie)
+ *      ev.on_event("StatusTextChange") {|*args|
+ *        puts "this block executed."
+ *        puts "handler.onStatusTextChange method is not called."
+ *      }
+ *      ev.handler = handler
+ *
+ */
+static VALUE
+fev_set_handler(VALUE self, VALUE val)
+{
+    return rb_ivar_set(self, rb_intern("handler"), val);
+}
+
+/*
+ *  call-seq:
+ *     WIN32OLE_EVENT#handler
+ *
+ *  returns handler object.
+ *
+ */
+static VALUE
+fev_get_handler(VALUE self)
+{
+    return rb_ivar_get(self, rb_intern("handler"));
+}
+
+void
+Init_win32ole_event(void)
+{
+#undef rb_intern
+    ary_ole_event = rb_ary_new();
+    rb_gc_register_mark_object(ary_ole_event);
+    id_events = rb_intern("events");
+    cWIN32OLE_EVENT = rb_define_class("WIN32OLE_EVENT", rb_cObject);
+    rb_define_singleton_method(cWIN32OLE_EVENT, "message_loop", fev_s_msg_loop, 0);
+    rb_define_alloc_func(cWIN32OLE_EVENT, fev_s_allocate);
+    rb_define_method(cWIN32OLE_EVENT, "initialize", fev_initialize, -1);
+    rb_define_method(cWIN32OLE_EVENT, "on_event", fev_on_event, -1);
+    rb_define_method(cWIN32OLE_EVENT, "on_event_with_outargs", fev_on_event_with_outargs, -1);
+    rb_define_method(cWIN32OLE_EVENT, "off_event", fev_off_event, -1);
+    rb_define_method(cWIN32OLE_EVENT, "unadvise", fev_unadvise, 0);
+    rb_define_method(cWIN32OLE_EVENT, "handler=", fev_set_handler, 1);
+    rb_define_method(cWIN32OLE_EVENT, "handler", fev_get_handler, 0);
+}