wrb 2.0.0

data/ext/rwin/rw_ubfuncs.c

@@ -0,0 +1,281 @@
+/*
+# Project WRB was forked from Project VisualuRuby(temp-name).
+# Author of this project: BANJO Koyu <banjokoyu at gmail.com>
+# The URL of this project: https://bitbucket.org/wrb/
+#
+# This is a ext-library part of WRB.
+*/
+
+#include "rwin.h"
+ULONG_PTR
+rw_call_std_func_0(ULONG_PTR* arg){
+    return ((FARPROC)arg[0])();
+}
+ULONG_PTR
+rw_call_std_func_1(ULONG_PTR* arg){
+    return ((FARPROC)arg[0])(arg[1]);
+}
+ULONG_PTR
+rw_call_std_func_2(ULONG_PTR* arg){
+    return ((FARPROC)arg[0])(arg[1], arg[2]);
+}
+ULONG_PTR
+rw_call_std_func_3(ULONG_PTR* arg){
+    return ((FARPROC)arg[0])(arg[1], arg[2], arg[3]);
+}
+ULONG_PTR
+rw_call_std_func_4(ULONG_PTR* arg){
+    return ((FARPROC)arg[0])(arg[1], arg[2], arg[3], arg[4]);
+}
+ULONG_PTR
+rw_call_std_func_5(ULONG_PTR* arg){
+    return ((FARPROC)arg[0])(arg[1], arg[2], arg[3], arg[4], arg[5]);
+}
+ULONG_PTR
+rw_call_std_func_6(ULONG_PTR* arg){
+    return ((FARPROC)arg[0])(arg[1], arg[2], arg[3], arg[4], arg[5], arg[6]);
+}
+ULONG_PTR
+rw_call_std_func_7(ULONG_PTR* arg){
+    return ((FARPROC)arg[0])(arg[1], arg[2], arg[3], arg[4], arg[5], arg[6], arg[7]);
+}
+ULONG_PTR
+rw_call_std_func_8(ULONG_PTR* arg){
+    return ((FARPROC)arg[0])(arg[1], arg[2], arg[3], arg[4], arg[5], arg[6], arg[7], arg[8]);
+}
+ULONG_PTR
+rw_call_std_func_9(ULONG_PTR* arg){
+    return ((FARPROC)arg[0])(arg[1], arg[2], arg[3], arg[4], arg[5], arg[6], arg[7], arg[8], arg[9]);
+}
+ULONG_PTR
+rw_call_std_func_10(ULONG_PTR* arg){
+    return ((FARPROC)arg[0])(arg[1], arg[2], arg[3], arg[4], arg[5], arg[6], arg[7], arg[8], arg[9], arg[10]);
+}
+ULONG_PTR
+rw_call_std_func_11(ULONG_PTR* arg){
+    return ((FARPROC)arg[0])(arg[1], arg[2], arg[3], arg[4], arg[5], arg[6], arg[7], arg[8], arg[9], arg[10], arg[11]);
+}
+ULONG_PTR
+rw_call_std_func_12(ULONG_PTR* arg){
+    return ((FARPROC)arg[0])(arg[1], arg[2], arg[3], arg[4], arg[5], arg[6], arg[7], arg[8], arg[9], arg[10], arg[11], arg[12]);
+}
+
+#ifdef RWIN_USEMULTITHREAD
+
+ULONG_PTR
+rw_call_without_gvl_0(DWORD thread_id, FARPROC winproc){
+    if(thread_id == GetCurrentThreadId()) {
+	return winproc();
+    }else{
+	ULONG_PTR stdcdata[1]; stdcdata[0] = (ULONG_PTR)winproc;
+	return CALL_NON_GVL_FUNC(rw_call_std_func_0, stdcdata);
+    }
+}
+ULONG_PTR
+rw_call_without_gvl_1(DWORD thread_id, FARPROC winproc, ULONG_PTR arg1){
+    if(thread_id == GetCurrentThreadId())  {
+	return winproc(arg1);
+    }else{
+	ULONG_PTR stdcdata[2]; stdcdata[0] = (ULONG_PTR)winproc;
+	stdcdata[1] = arg1;
+	return CALL_NON_GVL_FUNC(rw_call_std_func_1, stdcdata);
+    }
+}
+ULONG_PTR
+rw_call_without_gvl_2(DWORD thread_id, FARPROC winproc, ULONG_PTR arg1, ULONG_PTR arg2){
+    if(thread_id == GetCurrentThreadId()) {
+	return winproc(arg1, arg2);
+    }else{
+	ULONG_PTR stdcdata[3]; stdcdata[0] = (ULONG_PTR)winproc;
+	stdcdata[1] = arg1; stdcdata[2] = arg2;
+	return CALL_NON_GVL_FUNC(rw_call_std_func_2, stdcdata);
+    }
+}
+ULONG_PTR
+rw_call_without_gvl_3(DWORD thread_id, FARPROC winproc, ULONG_PTR arg1, ULONG_PTR arg2, ULONG_PTR arg3){
+    if(thread_id == GetCurrentThreadId()) {
+	return winproc(arg1, arg2, arg3);
+    }else{
+	ULONG_PTR stdcdata[4]; stdcdata[0] = (ULONG_PTR)winproc;
+	stdcdata[1] = arg1; stdcdata[2] = arg2;
+	stdcdata[3] = arg3; 
+	return CALL_NON_GVL_FUNC(rw_call_std_func_3, stdcdata);
+    }
+}
+ULONG_PTR
+rw_call_without_gvl_4(DWORD thread_id, FARPROC winproc, ULONG_PTR arg1, ULONG_PTR arg2, ULONG_PTR arg3, ULONG_PTR arg4){
+    if(thread_id == GetCurrentThreadId()) {
+	return winproc(arg1, arg2, arg3, arg4);
+    }else{
+	ULONG_PTR stdcdata[5]; stdcdata[0] = (ULONG_PTR)winproc;
+	stdcdata[1] = arg1; stdcdata[2] = arg2;
+	stdcdata[3] = arg3; stdcdata[4] = arg4;
+	return CALL_NON_GVL_FUNC(rw_call_std_func_4, stdcdata);
+    }
+}
+ULONG_PTR
+rw_call_without_gvl_5(DWORD thread_id, FARPROC winproc, ULONG_PTR arg1, ULONG_PTR arg2, ULONG_PTR arg3, ULONG_PTR arg4, ULONG_PTR arg5){
+    if(thread_id == GetCurrentThreadId()) {
+	return winproc(arg1, arg2, arg3, arg4, arg5);
+    }else{
+	ULONG_PTR stdcdata[6]; stdcdata[0] = (ULONG_PTR)winproc;
+	stdcdata[1] = arg1; stdcdata[2] = arg2;
+	stdcdata[3] = arg3; stdcdata[4] = arg4;
+	stdcdata[5] = arg5;
+	return CALL_NON_GVL_FUNC(rw_call_std_func_5, stdcdata);
+    }
+}
+ULONG_PTR
+rw_call_without_gvl_6(DWORD thread_id, FARPROC winproc, ULONG_PTR arg1, ULONG_PTR arg2, ULONG_PTR arg3, ULONG_PTR arg4, ULONG_PTR arg5, ULONG_PTR arg6){
+    if(thread_id == GetCurrentThreadId()) {
+	return winproc(arg1, arg2, arg3, arg4, arg5, arg6);
+    }else{
+	ULONG_PTR stdcdata[7]; stdcdata[0] = (ULONG_PTR)winproc;
+	stdcdata[1] = arg1; stdcdata[2] = arg2;
+	stdcdata[3] = arg3; stdcdata[4] = arg4;
+	stdcdata[5] = arg5; stdcdata[6] = arg6;
+	return CALL_NON_GVL_FUNC(rw_call_std_func_6, stdcdata);
+    }
+}
+ULONG_PTR
+rw_call_without_gvl_7(DWORD thread_id, FARPROC winproc, ULONG_PTR arg1, ULONG_PTR arg2, ULONG_PTR arg3, ULONG_PTR arg4, ULONG_PTR arg5, ULONG_PTR arg6, ULONG_PTR arg7){
+    if(thread_id == GetCurrentThreadId()) {
+	return winproc(arg1, arg2, arg3, arg4, arg5, arg6, arg7);
+    }else{
+	ULONG_PTR stdcdata[8]; stdcdata[0] = (ULONG_PTR)winproc;
+	stdcdata[1] = arg1; stdcdata[2] = arg2;
+	stdcdata[3] = arg3; stdcdata[4] = arg4;
+	stdcdata[5] = arg5; stdcdata[6] = arg6;
+	stdcdata[7] = arg7;
+	return CALL_NON_GVL_FUNC(rw_call_std_func_7, stdcdata);
+    }
+}
+ULONG_PTR
+rw_call_without_gvl_8(DWORD thread_id, FARPROC winproc, ULONG_PTR arg1, ULONG_PTR arg2, ULONG_PTR arg3, ULONG_PTR arg4, ULONG_PTR arg5, ULONG_PTR arg6, ULONG_PTR arg7, ULONG_PTR arg8){
+    if(thread_id == GetCurrentThreadId()) {
+	return winproc(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
+    }else{
+	ULONG_PTR stdcdata[9]; stdcdata[0] = (ULONG_PTR)winproc;
+	stdcdata[1] = arg1; stdcdata[2] = arg2;
+	stdcdata[3] = arg3; stdcdata[4] = arg4;
+	stdcdata[5] = arg5; stdcdata[6] = arg6;
+	stdcdata[7] = arg7; stdcdata[8] = arg8;
+	return CALL_NON_GVL_FUNC(rw_call_std_func_8, stdcdata);
+    }
+}
+ULONG_PTR
+rw_call_without_gvl_9(DWORD thread_id, FARPROC winproc, ULONG_PTR arg1, ULONG_PTR arg2, ULONG_PTR arg3, ULONG_PTR arg4, ULONG_PTR arg5, ULONG_PTR arg6, ULONG_PTR arg7, ULONG_PTR arg8, ULONG_PTR arg9){
+    if(thread_id == GetCurrentThreadId()) {
+	return winproc(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
+    }else{
+	ULONG_PTR stdcdata[10]; stdcdata[0] = (ULONG_PTR)winproc;
+	stdcdata[1] = arg1; stdcdata[2] = arg2;
+	stdcdata[3] = arg3; stdcdata[4] = arg4;
+	stdcdata[5] = arg5; stdcdata[6] = arg6;
+	stdcdata[7] = arg7; stdcdata[8] = arg8;
+	stdcdata[9] = arg9; 
+	return CALL_NON_GVL_FUNC(rw_call_std_func_9, stdcdata);
+    }
+}
+ULONG_PTR
+rw_call_without_gvl_10(DWORD thread_id, FARPROC winproc, ULONG_PTR arg1, ULONG_PTR arg2, ULONG_PTR arg3, ULONG_PTR arg4, ULONG_PTR arg5, ULONG_PTR arg6, ULONG_PTR arg7, ULONG_PTR arg8, ULONG_PTR arg9, ULONG_PTR arg10){
+    if(thread_id == GetCurrentThreadId()) {
+	return winproc(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
+    }else{
+	ULONG_PTR stdcdata[11]; stdcdata[0] = (ULONG_PTR)winproc;
+	stdcdata[1] = arg1; stdcdata[2] = arg2;
+	stdcdata[3] = arg3; stdcdata[4] = arg4;
+	stdcdata[5] = arg5; stdcdata[6] = arg6;
+	stdcdata[7] = arg7; stdcdata[8] = arg8;
+	stdcdata[9] = arg9; stdcdata[10] = arg10;
+	return CALL_NON_GVL_FUNC(rw_call_std_func_10, stdcdata);
+    }
+}
+ULONG_PTR
+rw_call_without_gvl_11(DWORD thread_id, FARPROC winproc, ULONG_PTR arg1, ULONG_PTR arg2, ULONG_PTR arg3, ULONG_PTR arg4, ULONG_PTR arg5, ULONG_PTR arg6, ULONG_PTR arg7, ULONG_PTR arg8, ULONG_PTR arg9, ULONG_PTR arg10, ULONG_PTR arg11){
+    if(thread_id == GetCurrentThreadId()) {
+	return winproc(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11);
+    }else{
+	ULONG_PTR stdcdata[12]; stdcdata[0] = (ULONG_PTR)winproc;
+	stdcdata[1] = arg1; stdcdata[2] = arg2;
+	stdcdata[3] = arg3; stdcdata[4] = arg4;
+	stdcdata[5] = arg5; stdcdata[6] = arg6;
+	stdcdata[7] = arg7; stdcdata[8] = arg8;
+	stdcdata[9] = arg9; stdcdata[10] = arg10;
+	stdcdata[11] = arg11;
+	return CALL_NON_GVL_FUNC(rw_call_std_func_11, stdcdata);
+    }
+}
+ULONG_PTR
+rw_call_without_gvl_12(DWORD thread_id, FARPROC winproc, ULONG_PTR arg1, ULONG_PTR arg2, ULONG_PTR arg3, ULONG_PTR arg4, ULONG_PTR arg5, ULONG_PTR arg6, ULONG_PTR arg7, ULONG_PTR arg8, ULONG_PTR arg9, ULONG_PTR arg10, ULONG_PTR arg11, ULONG_PTR arg12){
+    if(thread_id == GetCurrentThreadId()) {
+	return winproc(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12);
+    }else{
+	ULONG_PTR stdcdata[13]; stdcdata[0] = (ULONG_PTR)winproc;
+	stdcdata[1] = arg1; stdcdata[2] = arg2;
+	stdcdata[3] = arg3; stdcdata[4] = arg4;
+	stdcdata[5] = arg5; stdcdata[6] = arg6;
+	stdcdata[7] = arg7; stdcdata[8] = arg8;
+	stdcdata[9] = arg9; stdcdata[10] = arg10;
+	stdcdata[11] = arg11; stdcdata[12] = arg12;
+	return CALL_NON_GVL_FUNC(rw_call_std_func_12, stdcdata);
+    }
+}
+
+#else
+
+ULONG_PTR
+rw_call_without_gvl_0(DWORD thread_id, FARPROC winproc){
+    return winproc();
+}
+ULONG_PTR
+rw_call_without_gvl_1(DWORD thread_id, FARPROC winproc, ULONG_PTR arg1){
+    return winproc(arg1);
+}
+ULONG_PTR
+rw_call_without_gvl_2(DWORD thread_id, FARPROC winproc, ULONG_PTR arg1, ULONG_PTR arg2){
+    return winproc(arg1, arg2);
+}
+ULONG_PTR
+rw_call_without_gvl_3(DWORD thread_id, FARPROC winproc, ULONG_PTR arg1, ULONG_PTR arg2, ULONG_PTR arg3){
+    return winproc(arg1, arg2, arg3);
+}
+
+ULONG_PTR
+rw_call_without_gvl_4(DWORD thread_id, FARPROC winproc, ULONG_PTR arg1, ULONG_PTR arg2, ULONG_PTR arg3, ULONG_PTR arg4){
+    return winproc(arg1, arg2, arg3, arg4);
+}
+ULONG_PTR
+rw_call_without_gvl_5(DWORD thread_id, FARPROC winproc, ULONG_PTR arg1, ULONG_PTR arg2, ULONG_PTR arg3, ULONG_PTR arg4, ULONG_PTR arg5){
+    return winproc(arg1, arg2, arg3, arg4, arg5);
+}
+ULONG_PTR
+rw_call_without_gvl_6(DWORD thread_id, FARPROC winproc, ULONG_PTR arg1, ULONG_PTR arg2, ULONG_PTR arg3, ULONG_PTR arg4, ULONG_PTR arg5, ULONG_PTR arg6){
+    return winproc(arg1, arg2, arg3, arg4, arg5, arg6);
+}
+ULONG_PTR
+rw_call_without_gvl_7(DWORD thread_id, FARPROC winproc, ULONG_PTR arg1, ULONG_PTR arg2, ULONG_PTR arg3, ULONG_PTR arg4, ULONG_PTR arg5, ULONG_PTR arg6, ULONG_PTR arg7){
+    return winproc(arg1, arg2, arg3, arg4, arg5, arg6, arg7);
+}
+ULONG_PTR
+rw_call_without_gvl_8(DWORD thread_id, FARPROC winproc, ULONG_PTR arg1, ULONG_PTR arg2, ULONG_PTR arg3, ULONG_PTR arg4, ULONG_PTR arg5, ULONG_PTR arg6, ULONG_PTR arg7, ULONG_PTR arg8){
+    return winproc(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
+}
+ULONG_PTR
+rw_call_without_gvl_9(DWORD thread_id, FARPROC winproc, ULONG_PTR arg1, ULONG_PTR arg2, ULONG_PTR arg3, ULONG_PTR arg4, ULONG_PTR arg5, ULONG_PTR arg6, ULONG_PTR arg7, ULONG_PTR arg8, ULONG_PTR arg9){
+    return winproc(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
+}
+ULONG_PTR
+rw_call_without_gvl_10(DWORD thread_id, FARPROC winproc, ULONG_PTR arg1, ULONG_PTR arg2, ULONG_PTR arg3, ULONG_PTR arg4, ULONG_PTR arg5, ULONG_PTR arg6, ULONG_PTR arg7, ULONG_PTR arg8, ULONG_PTR arg9, ULONG_PTR arg10){
+    return winproc(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
+}
+ULONG_PTR
+rw_call_without_gvl_11(DWORD thread_id, FARPROC winproc, ULONG_PTR arg1, ULONG_PTR arg2, ULONG_PTR arg3, ULONG_PTR arg4, ULONG_PTR arg5, ULONG_PTR arg6, ULONG_PTR arg7, ULONG_PTR arg8, ULONG_PTR arg9, ULONG_PTR arg10, ULONG_PTR arg11){
+    return winproc(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11);
+}
+ULONG_PTR
+rw_call_without_gvl_12(DWORD thread_id, FARPROC winproc, ULONG_PTR arg1, ULONG_PTR arg2, ULONG_PTR arg3, ULONG_PTR arg4, ULONG_PTR arg5, ULONG_PTR arg6, ULONG_PTR arg7, ULONG_PTR arg8, ULONG_PTR arg9, ULONG_PTR arg10, ULONG_PTR arg11, ULONG_PTR arg12){
+    return winproc(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12);
+}
+
+#endif

data/ext/rwin/rw_windows.c

@@ -0,0 +1,1936 @@
+/*
+# Project WRB was forked from Project VisualuRuby(temp-name).
+# Author of this project: BANJO Koyu <banjokoyu at gmail.com>
+# The URL of this project: https://bitbucket.org/wrb/
+#
+# This is a ext-library part of WRB.
+*/
+
+#include "rwin.h"
+
+VALUE cRwWindow;
+
+/* TypedData */
+void rw_win_free(void *ptr){
+    RwWindow *rw = ptr;
+    if (rw->hwnd) DestroyWindow(rw->hwnd);
+    if (rw->msgfilter) freeAAtree(rw->msgfilter);
+    if (rw->handler_ids) freeAAtree(rw->handler_ids);
+    if (rw->haccel) DestroyAcceleratorTable(rw->haccel);
+    free(rw);
+}
+
+static size_t
+rwwin_memsize(const void *ptr){
+    return ptr ? sizeof(RwWindow) : 0;
+}
+
+const rb_data_type_t
+rwwin_data_type = {
+    "Window", {NULL, rw_win_free, rwwin_memsize}, NULL, NULL
+};
+
+static VALUE
+alloc_rw_window(VALUE klass){
+    RwWindow *rw;
+    VALUE obj;
+    obj = RwWindow_Data_Make_Struct(klass, rw);
+
+    rw->msgfilter = NULL;
+    rw->handler_ids = NULL;
+    rw->haccel = NULL;
+    return obj;
+}
+
+/*  message handler for RWin::Window  */
+
+static RwBaseHandler*
+create_basehandler(RwMsgHandler *handler, AAtree *senders){
+    RwBaseHandler* basehandler;
+    RW_MALLOC(basehandler, sizeof(RwBaseHandler));
+    basehandler->handler = handler;
+    basehandler->senders = senders;
+    return basehandler;
+}
+
+static void
+free_msghandler(RwMsgHandler *handler){
+    if(handler->arg_template) free(handler->arg_template);
+    free(handler);
+}
+
+static RwMsgHandler*
+alloc_msghandler(ID handler_id, VALUE v_klass, VALUE v_sendto){
+    RwMsgHandler *handler;
+    RW_CALLOC(handler, sizeof(RwMsgHandler));
+    handler->handler_id = handler_id;
+    handler->klass = v_klass;
+    handler->receiver = v_sendto;
+    handler->next = NULL;
+    return handler;
+}
+
+static RwMsgHandler*
+create_msghandler(ID handler_id,  VALUE v_template, VALUE v_klass, VALUE v_sendto){
+    RwMsgHandler *handler;
+    char *arg_template;
+    size_t len;
+    
+    switch (TYPE(v_template)){
+      case T_NIL:
+	handler = alloc_msghandler(handler_id, v_klass, v_sendto);
+	handler->arg_template = NULL;
+	break;
+      case T_STRING:
+	handler = alloc_msghandler(handler_id, v_klass, v_sendto);
+	len = RSTRING_LEN(v_template);
+	if (len > 0) {
+	    arg_template = malloc(len+1);
+	    memcpy(arg_template, RSTRING_PTR(v_template), len);
+	    arg_template[len] = 0;
+	    handler->arg_template = arg_template;
+	}
+	break;
+      default:
+	rb_raise(rb_eArgError, "Template must be a String");
+    }
+    return handler;
+}
+
+static void
+aa_destruct1(void* val){
+    if (val) freeAAtree((AAtree*)val);
+}
+
+static void
+aa_destruct_handler(void* val){
+    RwMsgHandler *handler = val;
+    while(handler){
+	RwMsgHandler *hh = handler;
+	handler = handler->next;
+	free_msghandler(hh);
+    }
+}
+
+static void
+aa_destruct_basehandler(void* val){
+    if (val) { /* delete all msgfilter */
+	RwBaseHandler *basehandler = val;
+	if (basehandler->senders) freeAAtree(basehandler->senders);
+	if (basehandler->handler) aa_destruct_handler(basehandler->handler);
+    }
+}
+
+static void
+rw_msgreceiver_add(VALUE receiver, ID handler_id){
+    AAnode *idnode;
+    RwWindow *rcv;
+    RwWindow_Data_Get_Struct(receiver, rcv);
+    if (!rcv->handler_ids) rcv->handler_ids = newAAtree(NULL);
+    if (idnode=aaSearch(rcv->handler_ids, handler_id)){
+	idnode->num++;
+    } else {
+	aaInsert(rcv->handler_ids, handler_id, 0);
+    }
+}
+
+static RwMsgHandler*
+rw_append_handler(RwMsgHandler *handler, RwMsgHandler *newhandler){
+    RwMsgHandler *next;
+    RwMsgHandler *root = handler;
+    ID handler_id = newhandler->handler_id;
+    VALUE receiver = newhandler->receiver;
+    if (!handler) return newhandler;
+    if(handler->handler_id==handler_id && handler->receiver==receiver){
+	rb_raise(rb_eRuntimeError, "`%s' is already defined.", rb_id2name(handler_id));
+    }
+    while(next = handler->next){
+	if (next->handler_id == handler_id && next->receiver==receiver){
+	    rb_raise(rb_eRuntimeError, "`%s' is already defined in destination.",
+		     rb_id2name(handler_id));
+	}
+	if(handler->next) handler = handler->next;
+    }
+    rw_msgreceiver_add(receiver, newhandler->handler_id);
+    handler->next = newhandler; /* append data at last */	
+    return root;
+}
+
+static void
+add_simple_filter(AAtree *msgfilter, unsigned msg, RwMsgHandler *newhandler){
+    AAnode *node = aaSearch(msgfilter, msg);
+    if (node){
+	if (node->val) {
+	    node->val = rw_append_handler((RwMsgHandler*)(node->val), newhandler);
+	} else {
+	    rw_msgreceiver_add(newhandler->receiver, newhandler->handler_id);
+	    node->val = newhandler;
+	}
+    } else {
+	rw_msgreceiver_add(newhandler->receiver, newhandler->handler_id);
+	aaInsert(msgfilter, msg, newhandler);
+    }
+}
+
+static VALUE
+rwwin_msgtranslator_set(int argc, VALUE *argv, VALUE self){
+    int msg;
+    ID callback_id;
+    RwBaseHandler *basehandler;
+    VALUE v_msg, v_callback, v_template;
+    RwMsgHandler *newhandler;
+    
+    RwWindow *rw = DATA_PTR(self);
+    rb_scan_args(argc, argv, "12", &v_msg, &v_callback, &v_template);
+    msg = FIX2INT(v_msg);
+    callback_id = NIL_P(v_callback) ? Qfalse : rb_to_id(v_callback);
+    if(rw->msgfilter) {
+	AAnode *ndbase = aaSearch(rw->msgfilter, msg);
+	if (ndbase){ /* Node must be empty. */
+	    rb_raise(rb_eRuntimeError, "Already defined handler for msg: %#x", msg);
+	} else {
+	    newhandler = create_msghandler(callback_id, v_template, Qfalse, Qfalse);
+	    basehandler = create_basehandler(newhandler, newAAtree(aa_destruct1));
+	    aaInsert(rw->msgfilter, msg, basehandler);
+	}
+    } else {
+	newhandler = create_msghandler(callback_id, v_template, Qfalse, Qfalse);
+	basehandler = create_basehandler(newhandler, newAAtree(aa_destruct1));
+	rw->msgfilter = newAAtree(aa_destruct_basehandler);
+	aaInsert(rw->msgfilter, msg, basehandler);
+    }
+    return Qnil;
+}
+
+static VALUE
+rwwin_msgtranslator_get(VALUE self, VALUE v_msg){
+    AAnode *node;
+    int msg =  FIX2INT(v_msg);
+    RwWindow *rw = DATA_PTR(self);
+    if (!rw->msgfilter) return Qnil;
+    node = aaSearch(rw->msgfilter, msg);
+    if(node){
+	RwBaseHandler *basehandler = node->val;
+	if (basehandler->senders){
+	    return INT2FIX(basehandler->handler->handler_id);
+	} else {
+	    rb_raise(rb_eRuntimeError, "Already defined handler for msg: %#x", msg);
+	}
+    }
+    return Qnil;
+}
+
+static VALUE
+rwwin_msgfilter_add(int argc, VALUE *argv, VALUE self){
+    RwBaseHandler *basehandler;
+    RwMsgHandler *newhandler;
+    unsigned msg, submsg;
+    ID handler_id;
+    int etc;
+    VALUE v_msg, v_submsg, v_etc, v_handler, v_template, v_sendto, v_klass;
+    
+    RwWindow *rw = DATA_PTR(self);
+    v_sendto = self;
+    v_template = Qnil;
+    v_klass = Qnil;
+     while (NIL_P(argv[argc-1])){ /* reject last nil */
+	argc--;
+    }
+    if (rb_typeddata_is_kind_of(argv[argc-1], &rwwin_data_type)){
+	/* message forwarding (sends message to any target window) */
+	v_sendto = argv[argc-1];
+	argc -= 1;
+    }
+    if (NIL_P(argv[argc-1])) {
+	argc -= 1;
+    } else if (rb_obj_class(argv[argc-1])==rb_cClass &&
+	       (rb_class_inherited_p(argv[argc-1], cRwAPIstruct)==Qtrue ||
+		rb_class_inherited_p(argv[argc-1], cRwCanvas)==Qtrue)){
+	/* lParam is CStruct or Canvas*/
+	v_klass = argv[argc-1];
+	argc -= 1;
+    }
+    if(argc > 3){ /* for WM_COMMAND / WM_NOTIFY (supports message which from Menu)*/
+	rb_scan_args(argc, argv, "41", &v_etc, &v_msg, &v_submsg, &v_handler, &v_template);
+	etc = NUM2INT(v_etc);
+    } else { /* for simple message forwarding*/
+	rb_scan_args(argc, argv, "21", &v_msg, &v_handler, &v_template);
+	v_submsg = Qnil;
+	etc = 0;
+    }
+    
+    msg = NUM2UINT(v_msg);
+    if (!NIL_P(v_submsg)){
+	if(NIL_P(rwwin_msgtranslator_get(self, v_msg))){
+	    rb_raise(rb_eRuntimeError, "Translator of message 0x%x is not defined", msg);
+	}
+    }
+    submsg = NIL_P(v_submsg) ? 0 : NUM2UINT(v_submsg);
+    handler_id = rb_to_id(v_handler);
+    
+    if (!NIL_P(v_template)){ /* check template */
+	int len = RSTRING_LEN(v_template);
+	char* tmpl = RSTRING_PTR(v_template);
+	switch(tmpl[0]){
+	  case 'h': case 'i': case 'x':
+	    break;
+	  case 'c':
+	    if(msg!=WM_PAINT) rb_raise(rb_eRuntimeError, "Template 'c' is only for WM_PAINT");
+	    if (NIL_P(v_klass)){
+		v_klass = cRwCanvas;
+	    } else if(NIL_P(rb_class_inherited_p(cRwCanvas, v_klass))){
+		rb_raise(rb_eRuntimeError, "Need Canvas inherited class for template 'c'");
+	    }
+	    break;
+	  case 's':
+	    rb_raise(rb_eRuntimeError, "Template 's' is only for lParam");
+	  default:
+	    rb_raise(rb_eRuntimeError, "Unknown template `%c' for wParam", tmpl[0]);
+	}
+	if (len>1) switch(tmpl[1]){
+	  case 'h': case 'i': case 'x':
+	    break;
+	  case 's':
+	    if (NIL_P(v_klass) || NIL_P(rb_class_inherited_p(cRwAPIstruct, v_klass))){
+		rb_raise(rb_eRuntimeError, "Need CSruct inherited class for template 's'");
+	    }
+	    break;
+	  default:
+	    rb_raise(rb_eRuntimeError, "Unknown template `%c' for lParam", tmpl[1]);
+	}
+    }
+    
+    newhandler = create_msghandler(handler_id, v_template, v_klass, v_sendto);
+    if (!etc){
+	if(rw->msgfilter) {
+	    AAnode *node = aaSearch(rw->msgfilter, msg);
+	    if (node){
+		basehandler = node->val;
+		if (basehandler->handler){
+		    basehandler->handler = rw_append_handler(basehandler->handler, newhandler);
+		} else {
+		    rw_msgreceiver_add(newhandler->receiver, newhandler->handler_id);
+		    basehandler->handler = newhandler;
+		}
+	    } else {
+		rw_msgreceiver_add(v_sendto, handler_id);
+		basehandler = create_basehandler(newhandler, NULL);
+		aaInsert(rw->msgfilter, msg, basehandler);
+	    }
+	} else {
+	    rw_msgreceiver_add(v_sendto, handler_id);
+	    basehandler = create_basehandler(newhandler, NULL);
+	    rw->msgfilter = newAAtree(aa_destruct_basehandler);
+	    aaInsert(rw->msgfilter, msg, basehandler);
+	}
+    } else {
+	if(rw->msgfilter) {
+	    AAnode *ndbase = aaSearch(rw->msgfilter, msg);
+	    if (ndbase){
+		AAnode *ndsubfilter;
+		RwMsgHandler *subhandler;
+		subhandler = create_msghandler(handler_id, v_template, v_klass, v_sendto);
+		basehandler = ndbase->val;
+		ndsubfilter = aaSearch(basehandler->senders, etc);
+		if (ndsubfilter){ 
+		    add_simple_filter(ndsubfilter->val, submsg, subhandler);
+		} else {
+		    AAtree *subfilter = newAAtree(aa_destruct_handler);
+		    rw_msgreceiver_add(v_sendto, handler_id);
+		    aaInsert(basehandler->senders, etc, subfilter);
+		    aaInsert(subfilter, submsg, subhandler);
+		}
+	    } else {
+		rb_raise(rb_eRuntimeError, "Translator is not defined");
+	    }
+	} else {
+	    rb_raise(rb_eRuntimeError, "Translator is not defined");
+	}
+    }
+    return v_msg;
+}
+
+static AAtree*
+delete_handler_ids(AAtree *tree, ID handler_id){
+    AAnode *nd = aaSearch(tree, handler_id);
+    if (nd) {
+	if(!nd->num) {
+	    aaDelete(tree, handler_id);
+	} else {
+	    nd->num--;
+	}
+    }
+    return tree;
+}
+
+static void*
+delete_msghandler(RwWindow *rw, RwMsgHandler *handler, ID id, VALUE receiver){
+    RwMsgHandler *next;
+    RwMsgHandler *root = handler;
+    if(handler->handler_id == id){
+	if(rw->handler_ids) rw->handler_ids = delete_handler_ids(rw->handler_ids, id);
+	root = handler->next; 
+	free_msghandler(handler);
+    } else {
+	while(next = handler->next){
+	    if (next->handler_id == id && next->receiver==receiver){
+		rw->handler_ids = delete_handler_ids(rw->handler_ids, id);
+		handler->next = next->next;
+		free_msghandler(next);
+		break;
+	    }
+	    handler = handler->next;
+	}
+    }
+    return root;
+}
+
+/*
+static void
+aa_debug_callback(const AAnode *node, void *arg) {
+   fprintf(stderr, "%s key %d, val %d, lv %d\n", (char*)arg, node->key, (int)node->val, node->level);
+}
+*/
+
+
+static void
+aa_delete_handler_id(const AAnode *nd, void *arg){
+    RwMsgHandler *handler = nd->val;
+    AAtree *tree = ((RwWindow*)arg)->handler_ids;// fprintf(stderr, "@439:tree=%x\n",tree);
+    if (!tree) return;
+    while(handler){
+	delete_handler_ids(tree, handler->handler_id);
+	handler = handler->next;
+    }
+}
+
+static void
+aa_aa_delete_id_of_senders(const AAnode *nd, void *arg){
+    aaForeach(nd->val, aa_delete_handler_id, arg);
+}
+
+static VALUE
+rwwin_msgfilter_delete(int argc, VALUE *argv, VALUE self){
+    VALUE v_sendto;
+    AAnode *node;
+    RwBaseHandler *bhandler;
+    RwWindow *rw = DATA_PTR(self);
+    if (!rw->msgfilter) return Qnil;
+    if (argc==1){ // Need to add a case when only one control was given.
+	int msg = NUM2INT(argv[0]);
+	if (node=aaSearch(rw->msgfilter, msg)){
+	    RwBaseHandler *bhandler = node->val;
+	    if(bhandler->handler){
+		RwMsgHandler *hd;
+		while(hd=bhandler->handler){
+		    bhandler->handler = delete_msghandler(rw, bhandler->handler, hd->handler_id,
+							  Qfalse);
+		    rw->handler_ids = delete_handler_ids(rw->handler_ids, hd->handler_id);
+		}
+	    }
+	    if(bhandler->senders) aaForeach(bhandler->senders, aa_aa_delete_id_of_senders, rw);
+	    aaDelete(rw->msgfilter, msg);
+	    return Qtrue;
+	} else {
+	    return Qnil;
+	}
+    }
+    
+    if(argc > 1 && rb_typeddata_is_kind_of(argv[argc-1], &rwwin_data_type)){
+	v_sendto = Qnil;
+	argc--;
+    } else {
+	v_sendto = Qfalse;
+    }
+    if(argc==2){
+	if (TYPE(argv[1])==T_STRING){ /* msg, handler_name */
+	    ID handler_id;
+	    int msg = FIX2INT(argv[0]);
+	    node = aaSearch(rw->msgfilter, msg);
+	    if (!node || !(bhandler=node->val)) return Qnil;
+	    if (!bhandler->handler) return Qnil;
+	    handler_id = rb_to_id(argv[1]);
+	    bhandler->handler = delete_msghandler(rw, bhandler->handler, handler_id, v_sendto);
+	    if (!bhandler->handler && !bhandler->senders) aaDelete(rw->msgfilter, msg);
+	} else { /* idcmd, msg */
+	    AAnode *nd;
+	    int etc;
+	    int msg = FIX2INT(argv[1]);
+	    node = aaSearch(rw->msgfilter, msg);
+	    if (!node) return Qnil;
+	    bhandler = node->val;
+	    etc = FIX2INT(argv[0]);
+	    if(!bhandler->senders) return Qnil;
+	    if(nd = aaSearch(bhandler->senders, etc)){
+		aaForeach(nd->val, aa_delete_handler_id, rw);
+		aaDelete(bhandler->senders, etc);
+	    } else {
+		return Qfalse;
+	    }
+	}
+    } else if(argc==3 || argc==4) { /* 3..4 */
+	AAnode *ndsubfilter;
+	AAnode *ndsubhandler;
+	int etc, submsg;
+	int msg = FIX2INT(argv[1]);
+	node = aaSearch(rw->msgfilter, msg);
+	if (!node) return Qnil;
+	bhandler = node->val;
+	if(!bhandler->senders){
+	    rb_raise(rb_eArgError, "MsgTranslator of message:0x%x is not defined", msg);
+	}
+	etc = FIX2INT(argv[0]);
+	submsg = FIX2INT(argv[2]);
+	ndsubfilter = aaSearch(bhandler->senders, etc);
+	if(!ndsubfilter) return Qnil;
+	ndsubhandler = aaSearch(ndsubfilter->val, submsg);
+	if (!ndsubhandler || !ndsubhandler->val) return Qnil;
+	if(argc==3) {
+	    aaForeach(ndsubfilter->val, aa_delete_handler_id, rw);
+	    aaDelete(ndsubfilter->val, submsg);
+	} else { /* argc == 4 */
+	    RwMsgHandler *subhandler = ndsubhandler->val;
+	    ID sub_id = rb_to_id(argv[3]); //fprintf(stderr, "sub_id=%x\n", sub_id);
+	    ndsubhandler->val = delete_msghandler(rw, subhandler, sub_id, v_sendto);
+	}
+    } else {
+	rb_raise(rb_eArgError, "argments must be 1..5");
+    }
+    return Qtrue;
+}
+
+static VALUE
+search_msghandler(RwWindow *rw, RwMsgHandler *handler, ID id, VALUE receiver){
+    RwMsgHandler *next;
+    if(handler->handler_id == id) return Qtrue;
+    while(next = handler->next){
+	if (next->handler_id == id && next->receiver==receiver) return Qtrue;
+	handler = handler->next;
+    }
+    return Qfalse;
+}
+
+static VALUE
+rwwin_msgfilter_exist_p(int argc, VALUE *argv, VALUE self){
+    int msg, etc;
+    VALUE v_sendto;
+    AAnode *node;
+    RwBaseHandler *bhandler;
+    RwWindow *rw = DATA_PTR(self);
+    if (!rw->msgfilter) return Qfalse;
+    if(argc > 1 && rb_typeddata_is_kind_of(argv[argc-1], &rwwin_data_type)){
+	v_sendto = Qfalse;
+	argc--;
+    } else {
+	v_sendto = Qfalse;
+    }
+    if (argc==1){
+	msg = FIX2INT(argv[0]);
+	return aaSearch(rw->msgfilter, msg) ? Qtrue : Qfalse;
+    }else if(argc==2){
+	if (TYPE(argv[1])==T_STRING){ /* msg, handler_name */
+	    ID handler_id;
+	    msg = FIX2INT(argv[0]);
+	    node = aaSearch(rw->msgfilter, msg);
+	    if (!node || !node->val) return Qfalse;
+	    bhandler = node->val;
+	    if (!bhandler->handler) return Qfalse;
+	    handler_id = rb_to_id(argv[1]);
+	    return search_msghandler(rw, bhandler->handler, handler_id, v_sendto);
+	} else { /* idcmd, msg */
+	    msg = FIX2INT(argv[1]);
+	    node = aaSearch(rw->msgfilter, msg);
+	    if (!node) return Qfalse;
+	    bhandler = node->val; //fprintf(stderr, "@%d\n", __LINE__);
+	    if (!bhandler->senders) return Qfalse; // fprintf(stderr, "@%d, %xll\n", __LINE__, (ULONG_PTR)bhandler->senders);
+	    etc = FIX2INT(argv[0]);
+	    return aaSearch(bhandler->senders, etc) ? Qtrue : Qfalse;
+	}
+    } else if(argc==3 || argc==4) { /* 3..4 */
+	AAnode *ndsubfilter;
+	AAnode *ndsubhandler;
+	int submsg;
+	
+	msg = FIX2INT(argv[1]);
+	node = aaSearch(rw->msgfilter, msg);
+	if (!node) return Qfalse;
+	bhandler = node->val;
+	if(!bhandler->handler||!bhandler->senders) return Qfalse;
+	etc = FIX2INT(argv[0]);
+	submsg = FIX2INT(argv[2]);
+	ndsubfilter = aaSearch(bhandler->senders, etc);
+	if(!ndsubfilter) return Qfalse;
+	ndsubhandler = aaSearch(ndsubfilter->val, submsg);
+	if (!ndsubhandler || !ndsubhandler->val) return Qfalse;
+	if(argc==3) {
+	    return Qtrue;
+	} else { /* argc == 4 */
+	    RwMsgHandler *subhandler = ndsubhandler->val;
+	    ID sub_id = rb_to_id(argv[3]); 
+	    return search_msghandler(rw, subhandler, sub_id, v_sendto);
+	}
+    } else {
+	rb_raise(rb_eArgError, "argments must be 1..5");
+    }
+    return Qfalse;
+}
+
+void
+aa_callback_each_msgfilter(const AAnode *node, void *arg){
+    VALUE ar = (VALUE)arg;
+    rb_ary_push(ar, INT2NUM(node->key));
+}
+
+static VALUE
+rwwin_msgfilter_getfilters(VALUE self){
+    RwWindow *rw = DATA_PTR(self);
+    VALUE ary = rb_ary_new();
+    aaForeach(rw->msgfilter, aa_callback_each_msgfilter, (void*)ary);
+    return ary;
+}
+
+/* prototyping */
+LRESULT CALLBACK RwSubclassProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam, UINT_PTR uIdSubclass, DWORD_PTR dwRefData);
+
+static VALUE
+rwwin_create(int argc,VALUE* argv, VALUE self){
+    TCHAR *classname, *caption;
+    RwWindow *rw = DATA_PTR(self);
+    HWND hparent = NULL;
+    
+    if(TYPE(argv[0])==T_STRING) {
+	classname = rw_str2tchar(argv[0]);
+    } else{
+	rb_raise(rb_eArgError, "1st argument must be class name(String)");
+    }
+    if(TYPE(argv[1])==T_STRING) {
+	caption = rw_str2tchar(argv[1]);
+    } else{
+	rb_raise(rb_eArgError, "2nd argument must be caption(String)");
+    }
+    if (!NIL_P(argv[6])){
+	RwWindow *rwparent;
+	RwWindow_Data_Get_Struct(argv[6], rwparent);
+	hparent = rwparent->hwnd;
+    }
+    rw->hwnd = CreateWindowEx(NUM2UINT(argv[9]),       /* dwExStyle */
+			      classname,
+			      caption,
+			      NUM2UINT(argv[8]),       /* dwStyle */
+			      NUM2INT(argv[2]),        /* x */
+			      NUM2INT(argv[3]),        /* y */
+			      NUM2INT(argv[4]),        /* w */
+			      NUM2INT(argv[5]),        /* h */
+			      hparent,                 /* hParent */
+			      NIL_P(argv[7]) ? 0 : (HMENU)NUM2ULONG_PTR(argv[7]), /* hMenu */
+			      hInstance,
+			      NULL);
+    if(!rw->hwnd){
+	rb_raise(rb_eRuntimeError, "failed to create window(%s)", RSTRING_PTR(argv[0]));
+    }
+    rw->nthread_id = GetCurrentThreadId();
+    if(hparent){
+	Register_childwin(rw->hwnd, self);
+	if(GetClassLong(rw->hwnd, GCW_ATOM)==RwClassAtom){
+	    int id = NIL_P(argv[7]) ? 0 : FIX2INT(argv[7]);
+	    SetWindowSubclass(rw->hwnd, RwSubclassProc, (UINT_PTR)id, (DWORD_PTR)self);
+	}
+    } else {
+	Register_win(rw->hwnd, self);
+	if (GetActiveWindow()==rw->hwnd) activewin = rw;
+    }
+    return self;
+}
+
+static VALUE
+rwwin1_new_from_handle(VALUE klass, VALUE v_handle){
+    RwWindow *rw;
+    VALUE obj;
+    HANDLE handle = (HANDLE)NUM2ULONG_PTR(v_handle);
+    if(!GetParent(handle)) rb_raise(rb_eArgError,
+				    "Handle %#x is not child window", (int)(ULONG_PTR)handle);
+    
+    obj = RwWindow_Data_Make_Struct(klass, rw);
+    rw->hwnd = handle;
+    rw->msgfilter = NULL;
+    rw->handler_ids = NULL;
+    rw->haccel = NULL;
+    Register_childwin(rw->hwnd, obj);
+    return obj;
+}
+
+/* Event handling routines */
+static VALUE
+rw_method_missing(int argc, VALUE *argv, VALUE self){
+    ID method_id = rb_to_id(argv[0]);
+    RwWindow *rw = DATA_PTR(self);
+    if(rw->handler_ids && aaSearch(rw->handler_ids, method_id)) return Qnil;
+    rb_call_super(argc, argv);
+    return Qnil;
+}
+
+/* Keyborad accelarators */
+static VALUE
+rw_set_accelerator(VALUE self, VALUE v_acceltable){
+    int len, i;
+    HACCEL haccel = NULL;
+    ACCEL *paccel = NULL;
+    RwWindow *rw = DATA_PTR(self);
+    if (NIL_P(v_acceltable)){
+	if(rw->haccel) DestroyAcceleratorTable(rw->haccel);
+	rw->haccel = NULL;
+	return Qnil;
+    }
+    if(TYPE(v_acceltable)!=T_ARRAY) rb_raise(rb_eArgError, "Argument must be an Array.");
+    len = RARRAY_LEN(v_acceltable);
+    if(rw->haccel) DestroyAcceleratorTable(rw->haccel);
+    RW_MALLOC(paccel, len*sizeof(ACCEL));
+    for(i=0; i<len; i++){
+	VALUE v_accel = rb_ary_entry(v_acceltable, i);
+	paccel[i].fVirt = FIX2INT(rb_ary_entry(v_accel, 0));
+	paccel[i].key = FIX2INT(rb_ary_entry(v_accel, 1));
+	paccel[i].cmd = FIX2INT(rb_ary_entry(v_accel, 2));
+    }
+    haccel = CreateAcceleratorTable(paccel, len);
+    if(!haccel) rb_raise(rb_eRuntimeError, "CreateAcceleratorTable faled.");
+    rw->haccel = haccel;
+    free(paccel);
+    return INT2FIX(len);
+}
+
+/* Error handling routines */
+void
+rw_abort_program(int state){
+    VALUE bt, bt0, msg;
+    VALUE e = rb_errinfo();
+    char btbuff[4096] = "";
+    int i, len;
+    
+    bt = rb_funcall(e, rb_intern("backtrace"), 0);
+    msg = rb_funcall(e, rb_intern("message"), 0);
+    bt0 = rb_ary_shift(bt);
+    len = RARRAY_LEN(bt);
+    
+    for(i=0; i<len; i++){
+	VALUE btn = rb_ary_entry(bt, i);
+	char* btstr = StringValuePtr(btn);
+	strcat(btbuff, "from: ");
+	strcat(btbuff, btstr);
+	strcat(btbuff, "\n");
+    }
+    
+    if(IS_GUIAPP){
+	char buff[4096];
+	sprintf(buff, "message: %s\n\nat: %s\n%s",
+		StringValuePtr(msg), StringValuePtr(bt0), btbuff);
+	MessageBoxA(NULL, buff, rb_obj_classname(e), 16); 
+	PostQuitMessage(state);
+    } else {
+	fprintf(stderr, "Error occurred during message handling\n%s: %s (%s)\nfrom: %s",
+		StringValuePtr(bt0), StringValuePtr(msg), rb_obj_classname(e), btbuff);
+	PostQuitMessage(state);
+    }
+}
+
+static VALUE
+rw_funcall_0(VALUE args){
+    VALUE *parg = (VALUE*)args;
+    return rb_funcall(parg[0], parg[1], 0);
+}
+
+static VALUE
+rw_funcall_1(VALUE args){
+    VALUE *parg = (VALUE*)args;
+    return rb_funcall(parg[0], parg[1], 1, parg[2]);
+}
+
+static VALUE
+rw_funcall_n(VALUE args){
+    VALUE *parg = (VALUE*)args;
+    return rb_funcall2(parg[0], parg[1], parg[2], &parg[3]);
+}
+
+void
+dispatch_wm_paint_handler(VALUE wobj, RwBaseHandler *basehandler, HDC hdc){
+    RwMsgHandler *handler = basehandler->handler;
+    while(handler){
+	int state = 0;
+	VALUE args[3];
+	args[0] = handler->receiver;
+	args[1] = handler->handler_id;
+	if (handler->arg_template) {
+	    VALUE v_cv = Qfalse;
+	    switch(handler->arg_template[0]){
+	      case 'i':
+		args[2] = ULONG_PTR2NUM((ULONG_PTR)hdc);
+		break;
+	      case 'c':
+		v_cv = rwcvs_new_from_hdc(handler->klass, hdc); 
+		args[2] = v_cv;
+		break;
+	      default:
+		rb_bug("Unkown template: `%c' for WM_PAINT", handler->arg_template[0]);
+	    }
+	    rb_protect(rw_funcall_1, (VALUE)args, &state);
+#if !USE_RGENGC
+	    if(v_gr) rb_gc_force_recycle(v_gr);
+#endif
+	} else {
+	    rb_protect(rw_funcall_0, (VALUE)args, &state);
+	}
+	if (state) rw_abort_program(state);
+	handler = handler->next;
+    }
+}
+
+static int
+setwparam2args(WPARAM wParam, char* template, VALUE* nargs, VALUE* args){
+    if(!*template) return 0;
+    switch(*template){
+      case 'h': /* arg is [(signed)LOWORD, (signed)HIWORD]*/
+	*nargs += 2;
+	args[0] = INT2FIX((short)LOWORD(wParam));
+	args[1] = INT2FIX((short)HIWORD(wParam));
+	return 2;
+      case 'i': /* arg is INT */
+	*nargs += 1;
+	*args = ULONG_PTR2NUM(wParam);
+	return 1;
+      case 'x': /* skip */
+	return 0;
+      default:
+	rb_bug("unknown template: `%c' for wParam", *template);
+	return 0;
+    }
+}
+
+static int
+setlparam2args(LPARAM lParam, char* template, VALUE* nargs, VALUE* args){
+    if(!*template) return 0;
+    switch(*template){
+      case 'h': /* arg is [(signed)LOWORD, (signed)HIWORD]*/
+	*nargs += 2;
+	args[0] = INT2FIX((short)LOWORD(lParam));
+	args[1] = INT2FIX((short)HIWORD(lParam));
+	return 2;
+      case 'i': /* arg is INT */
+	*nargs += 1;
+	*args = LONG_PTR2NUM(lParam);
+	return 1;
+      case 's': /* arg is CStruct */
+	*nargs += 1;
+	return -1;
+      case 'x': /* skip */
+	return 0;
+      default:
+	rb_bug("unknown template: `%c' for lParam", *template);
+	return 0;
+    }
+}
+
+static RwMsgHandler*
+rw_translate_msg(VALUE callto, RwBaseHandler *basehandler, UINT msg, WPARAM *wParam, LPARAM *lParam){
+    VALUE retval = Qnil;
+    VALUE args[4];
+    RwMsgHandler *handler = basehandler->handler;
+    if(basehandler->senders){
+	int state;
+	unsigned idfrom, subfilter;
+	AAnode *node, *subnode;
+	RwMsgHandler *subhandler = NULL;
+	ID callback_id = handler->handler_id;
+	if (!callback_id){
+	    switch(msg){
+	      case WM_COMMAND:
+	      case WM_TIMER:
+		idfrom = LOWORD(*wParam);
+		if(*lParam){ /* from controls */
+		    subfilter = HIWORD(*wParam);
+		} else { /* from menu */
+		    subfilter = HIWORD(*wParam) & 0xfffe; /* mask LSB */
+		}
+		node = aaSearch(basehandler->senders, idfrom);
+		if(node){
+		    subnode = aaSearch((AAtree*)(node->val), subfilter);
+		    if (subnode) subhandler = subnode->val;
+		}
+		return subhandler;
+	      case WM_NOTIFY:
+		idfrom = ((NMHDR*)*lParam)->idFrom;
+		subfilter = ((NMHDR*)*lParam)->code;
+		node = aaSearch(basehandler->senders, idfrom);
+		if(node){
+		    subnode = aaSearch((AAtree*)(node->val), subfilter);
+		    if (subnode) subhandler = subnode->val;
+		}
+		return subhandler;
+	    }
+	} else {
+	    char *template = handler->arg_template;
+	    args[0] = callto;
+	    args[1] = callback_id;
+	    args[2] = 0;
+	    if (template){
+		int n = setwparam2args(*wParam, template, &args[2], &args[3]);
+		n = setlparam2args(*lParam, ++template, &args[2], &args[3+n]);
+	    }
+	    retval = rb_protect(rw_funcall_n, (VALUE)args, &state);
+	    if (state) rw_abort_program(state);
+	    if (TYPE(retval) == T_ARRAY){
+		VALUE v_idfrom, v_subfilter, v_wParam, v_lParam;
+		if (NIL_P(v_idfrom = rb_ary_entry(retval, 0))) return NULL;
+		idfrom = FIX2INT(v_idfrom);
+		if (NIL_P(v_subfilter = rb_ary_entry(retval, 1))) return NULL;
+		subfilter = FIX2INT(v_subfilter);
+		if (! NIL_P(v_wParam = rb_ary_entry(retval, 2))) *wParam = NUM2INT(v_wParam);
+		if (! NIL_P(v_lParam = rb_ary_entry(retval, 3))) *lParam = NUM2INT(v_lParam);
+		node = aaSearch(basehandler->senders, idfrom);
+		if(node){
+		    subnode = aaSearch((AAtree*)(node->val), subfilter);
+		    if (subnode) subhandler = subnode->val;
+		}
+	    }
+	}
+	return subhandler;
+    }
+    return handler;
+}
+
+static int
+dispatch_handler(VALUE wobj, RwBaseHandler *basehandler, UINT msg, WPARAM wParam, LPARAM lParam){
+    VALUE ret = Qnil;
+    RwMsgHandler *handler = rw_translate_msg(wobj, basehandler, msg, &wParam, &lParam);
+    while (handler){
+	int n = 0;
+	int is_struct = 0;
+	int state = 0;
+	VALUE args[8];
+	char *template = handler->arg_template;
+	args[0] = handler->receiver;
+	args[1] = handler->handler_id;
+	args[2] = 0;
+	if (template){
+	    n = setwparam2args(wParam, template, &args[2], &args[3]);
+	    is_struct = setlparam2args(lParam, ++template, &args[2], &args[3+n]);
+	}
+	if (is_struct==-1){ /* lParam to CStruct */
+	    VALUE obj;
+	    if (handler->klass==Qnil) rb_raise(rb_eRuntimeError, "No CStruct given");
+	    obj = cstruct_wrapptr(handler->klass, (char*)lParam, 0);
+	    args[3+n] = obj;
+	    ret = rb_protect(rw_funcall_n, (VALUE)args, &state);
+#if !USE_RGENGC
+	    rb_gc_force_recycle(obj);
+#endif
+	} else {
+	    ret = rb_protect(rw_funcall_n, (VALUE)args, &state);
+	}
+	if (state) rw_abort_program(state);
+	if (ret == cRwCancelDefWndProc){
+	    return 1;
+	} else if (rb_typeddata_is_kind_of(ret, &rw_candefwndprc_d_type)){
+	    RwCancelDefWindowProc *rcp;
+	    TypedData_Get_Struct(ret, RwCancelDefWindowProc, &rw_candefwndprc_d_type, rcp);
+	    if (rcp->retval){
+		return rcp->retval;
+	    }
+	} 
+	handler = handler->next;
+    }
+    return 0;
+}
+
+LRESULT
+do_wm_default(VALUE wobj, UINT *msg, WPARAM *wParam, LPARAM *lParam){
+    RwWindow *rw = DATA_PTR(wobj);
+    LRESULT r = 0;
+    if(rw->msgfilter){
+	AAnode *node = aaSearch(rw->msgfilter, *msg);
+	if (node){
+	    RwBaseHandler *basehandler = node->val;
+	    if(basehandler){
+		r = dispatch_handler(wobj, basehandler, *msg, *wParam, *lParam);
+	    }
+	}
+    }
+    return r;
+}
+
+//void
+//aa_callback_test(const AAnode *node, void *arg){
+//    fprintf(stderr, "[key=%#x, val=%#x], ", (int)node->key, (int)node->val);
+//}
+
+static void
+aa_callback_finalize_resoure(const AAnode *node, void *arg){
+    VALUE obj = (VALUE)node->val;
+    if(rb_typeddata_is_kind_of(obj, &rwimage_data_type)){
+	RwImage *rp;
+	RwImage_Data_Get_Struct(obj, rp);
+	if(rp->himage) GdipDisposeImage(rp->himage);
+	rp->himage = 0;
+    }
+}
+
+static void
+rwwin_finalize(){
+    aaForeach(rsclist, aa_callback_finalize_resoure, NULL);
+    rwgdiplus_shutdown();
+//    PostQuitMessage(0);
+}
+
+
+LRESULT CALLBACK
+RwWndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam){
+    if(GetClassLong(hWnd, GCW_ATOM)==RwClassAtom){
+	VALUE wobj = Get_win(hWnd);
+	if(wobj){
+	    RwWindow *rw = DATA_PTR(wobj);
+	    if (uMsg==WM_PAINT){
+		if (rw->msgfilter) {
+		    AAnode *nd = aaSearch(rw->msgfilter, WM_PAINT);
+		    if (nd) {
+			PAINTSTRUCT ps;
+			RwBaseHandler *basehandler = nd->val;
+			HDC hdc = BeginPaint(rw->hwnd, &ps);
+			dispatch_wm_paint_handler(wobj, basehandler, hdc);
+			EndPaint(rw->hwnd, &ps);
+			return 0;
+		    }
+		}
+		return DefWindowProc(hWnd, uMsg, wParam, lParam);
+	    } else {
+		LRESULT ret;
+		if (uMsg==WM_ACTIVATE) activewin = LOWORD(wParam) ? DATA_PTR(wobj) : NULL;
+		ret=do_wm_default(wobj, &uMsg, &wParam, &lParam);
+		if (ret){
+		    return ret;
+		} 
+	    }
+	}
+	switch (uMsg) {
+ 	  case WM_CREATE:
+	    return 0;
+	  case WM_CLOSE:
+	    DestroyWindow(hWnd);
+	    break;
+	  case WM_DESTROY:
+	    if(wobj){
+		RwWindow *rw = (RwWindow*)DATA_PTR(wobj);
+		if(!GetParent(hWnd)) {
+		    Unregister_win(hWnd);
+		    if(aaCount(winlist)==0) {
+			rwwin_finalize();
+			PostQuitMessage(wParam);
+			return 0;
+		    }
+		} else {
+		    Unregister_childwin(hWnd);
+		}
+		rw->hwnd = NULL;
+	    }
+	    return 0;
+	}
+    }
+    return DefWindowProc(hWnd, uMsg, wParam, lParam);
+}
+
+LRESULT CALLBACK RwSubclassProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam, UINT_PTR uIdSubclass, DWORD_PTR dwRefData){
+    VALUE wobj = (VALUE)dwRefData;
+    RwWindow *rw = (RwWindow*)DATA_PTR(wobj);
+    if (uMsg==WM_PAINT){
+	if (rw->msgfilter) {
+	    AAnode *nd = aaSearch(rw->msgfilter, WM_PAINT);
+	    if (nd) {
+		PAINTSTRUCT ps;
+		RwBaseHandler *basehandler = nd->val;
+		HDC hdc = BeginPaint(rw->hwnd, &ps);
+		dispatch_wm_paint_handler(wobj, basehandler, hdc);
+		EndPaint(rw->hwnd, &ps);
+		return 0;
+	    }
+	}
+    } else {
+	LONG_PTR ret = do_wm_default(wobj, &uMsg, &wParam, &lParam);
+	if (ret) return ret; /* cancel default wndproc */
+	if(uMsg==WM_DESTROY){
+	    Unregister_childwin(hWnd);
+	    rw->hwnd = NULL;
+	}
+    }
+    return DefSubclassProc(hWnd, uMsg, wParam, lParam);
+}
+
+static VALUE
+rwwin_close(VALUE self){
+    int r; //AAnode *nd;
+    RwWindow *rw = DATA_PTR(self);
+    RwCheckWindow(rw);
+    r = DestroyWindow(rw->hwnd);
+    if(rw->hwnd){ /* for child windows (Not received WM_DESTROY) */
+	Unregister_childwin(rw->hwnd);
+	rw->hwnd = NULL;
+    }
+    return r ? Qtrue : Qfalse;
+}
+
+static VALUE
+rwwin_gethandle(VALUE self){
+    RwWindow *rw = DATA_PTR(self);
+    RwCheckWindow(rw);
+    return ULONG_PTR2NUM((ULONG_PTR)rw->hwnd);
+}
+
+static VALUE
+rwwin_alive_p(VALUE self){
+    RwWindow *rw = DATA_PTR(self);
+    return rw->hwnd ? Qtrue : Qfalse;
+}
+
+/*
+static void
+rw_move_core(HWND hwnd, POINT *pt){
+    HWND hparent;
+    if(hparent=GetParent(hwnd)) ClientToScreen(hparent, pt);
+}*/
+
+static VALUE
+rwwin_move(int argc, VALUE * argv, VALUE self){
+    RECT rc;
+    int x, y, w, h;
+    BOOL brepaint = TRUE;
+    RwWindow *rw = DATA_PTR(self);
+    RwCheckWindow(rw);
+    switch(argc){
+      case 5:
+	if(argv[4]==Qfalse) brepaint = FALSE;
+      case 4:
+	x = FIX2INT(argv[0]);
+	y = FIX2INT(argv[1]);
+	w = FIX2INT(argv[2]);
+	h = FIX2INT(argv[3]);
+	break;
+      case 3:
+	if(argv[2]==Qfalse) brepaint = FALSE;
+      case 2:
+	x = FIX2INT(argv[0]);
+	y = FIX2INT(argv[1]);
+	GetWindowRect(rw->hwnd, &rc);
+	w = rc.right - rc.left;
+	h = rc.bottom - rc.top;
+	break;
+      default:
+	rb_raise(rb_eArgError, "Num of arguments must be 2..5");
+    }
+    rw_call_without_gvl_6(rw->nthread_id, (FARPROC)MoveWindow, (ULONG_PTR)rw->hwnd, x, y, w, h, brepaint);
+    return self;
+}
+
+static VALUE
+rwwin_resize(VALUE self, VALUE v_w, VALUE v_h){
+    RECT rc;
+    POINT pos;
+    RwWindow *rw = DATA_PTR(self);
+    RwCheckWindow(rw);
+    GetWindowRect(rw->hwnd, &rc);
+    pos.x = rc.left;
+    pos.y = rc.top;
+    ScreenToClient(GetAncestor(rw->hwnd, GA_PARENT), &pos);
+    rw_call_without_gvl_6(rw->nthread_id, (FARPROC)MoveWindow, (ULONG_PTR)rw->hwnd,
+			  pos.x, pos.y, FIX2INT(v_w), FIX2INT(v_h), TRUE);
+    return self;
+}
+
+static VALUE
+rwwin_refresh(int argc, VALUE *argv, VALUE self){
+    RECT rect;
+    RECT *prect;
+    BOOL bErase;
+    RwWindow *rw = DATA_PTR(self);
+    RwCheckWindow(rw);
+    if(argc<=1){
+	prect = NULL;
+	bErase = (argc==1 && argv[0]==Qfalse) ? FALSE : TRUE;
+    } else if(argc<=5){
+	rect.left   = FIX2INT(argv[0]);
+	rect.top    = FIX2INT(argv[1]);
+	rect.right  = rect.left + FIX2INT(argv[2]);
+	rect.bottom = rect.top + FIX2INT(argv[3]);
+	prect = &rect;
+	bErase = (argc==5 && argv[4]==Qfalse) ? FALSE : TRUE;
+    } else{
+	rb_raise(rb_eArgError, "invalid num of args: %d", argc);
+    }
+    InvalidateRect(rw->hwnd, prect, bErase);
+    return self;
+}
+
+static void
+rw_getclientpos_core(HWND hwnd, RECT *rc){
+    HWND hparent;
+    GetWindowRect(hwnd, rc);
+    if(hparent=GetAncestor(hwnd, GA_PARENT)) ScreenToClient(hparent, (POINT*)rc);
+}
+
+static VALUE
+rwwin_getscreenpos(VALUE self){
+    RECT rc;
+    RwWindow *rw = DATA_PTR(self);
+    RwCheckWindow(rw);
+    GetWindowRect(rw->hwnd, &rc);
+    return rb_ary_new3(2, INT2FIX(rc.left), INT2FIX(rc.top));
+}
+
+static VALUE
+rwwin_getclientpos(VALUE self){
+    RECT rc;
+    RwWindow *rw = DATA_PTR(self);
+    RwCheckWindow(rw);
+    rw_getclientpos_core(rw->hwnd, &rc);
+    return rb_ary_new3(2, INT2FIX(rc.left), INT2FIX(rc.top));
+}
+
+static VALUE
+rwwin_getwndsize(VALUE self){
+    RECT rc;
+    RwWindow *rw = DATA_PTR(self);
+    RwCheckWindow(rw);
+    GetWindowRect(rw->hwnd, &rc);
+    return rb_ary_new3(2, INT2FIX(rc.right - rc.left), INT2FIX(rc.bottom - rc.top));
+}
+
+static VALUE
+rwwin_getclientsize(VALUE self){
+    RECT rc;
+    RwWindow *rw = DATA_PTR(self);
+    RwCheckWindow(rw);
+    GetClientRect(rw->hwnd, &rc);
+    return rb_ary_new3(2, INT2FIX(rc.right), INT2FIX(rc.bottom));
+}
+
+static VALUE
+rwwin_setorder(VALUE self, VALUE v_wndafter){
+    RwWindow *rwafter;
+    HWND hwndafter;
+    RwWindow *rw = DATA_PTR(self);
+    RwCheckWindow(rw);
+    switch(TYPE(v_wndafter)){
+      case T_FIXNUM:
+      case T_BIGNUM:
+	hwndafter = (HWND)NUM2ULONG_PTR(v_wndafter);
+	break;
+      default:
+	RwWindow_Data_Get_Struct(v_wndafter, rwafter);
+	hwndafter = rwafter->hwnd;
+    }
+    SetWindowPos(rw->hwnd, hwndafter, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE);
+    return self;
+}
+
+static VALUE
+rwwin_getcursorpos(VALUE self){
+    VALUE robj;
+    POINT pt;
+    RwWindow *rw = DATA_PTR(self);
+    GetCursorPos(&pt);
+    ScreenToClient(rw->hwnd, &pt);
+    robj = rb_ary_new2(2);
+    rb_ary_store(robj, 0, INT2NUM(pt.x));
+    rb_ary_store(robj, 1, INT2NUM(pt.y));
+    return robj;
+}
+
+/* r/w attributes */
+static VALUE
+rwwin_getcaption(VALUE self){
+    int len;
+    TCHAR *buff;
+    VALUE robj;
+    RwWindow *rw = DATA_PTR(self);
+    RwCheckWindow(rw);
+    len = GetWindowTextLength(rw->hwnd);
+    buff = malloc((len+1)*sizeof(TCHAR));
+    GetWindowText(rw->hwnd, buff, len+1);
+    robj = rw_encode_external(buff);
+    free(buff);
+    return robj;
+}
+
+static VALUE
+rwwin_setcaption(VALUE self, VALUE str){
+    RwWindow *rw = DATA_PTR(self);
+    RwCheckWindow(rw);
+    rw_call_without_gvl_2(rw->nthread_id, (FARPROC)SetWindowText, (ULONG_PTR)rw->hwnd,
+			  (ULONG_PTR)rw_str2tchar(StringValue(str)));
+    return self;
+}
+
+static VALUE
+rwwin_getvisible(VALUE self){
+    int r;
+    RwWindow *rw = DATA_PTR(self);
+    RwCheckWindow(rw);
+    r = rw_call_without_gvl_1(rw->nthread_id, (FARPROC)IsWindowVisible, (ULONG_PTR)rw->hwnd);
+    return r ? Qtrue : Qnil;
+}
+
+static VALUE
+rwwin_setvisible(VALUE self, VALUE v_flag){
+    int swvisible;
+    RwWindow *rw = DATA_PTR(self);
+    RwCheckWindow(rw);
+    switch(TYPE(v_flag)){
+      case T_TRUE:
+	swvisible = SW_SHOW;
+	break;
+      case T_FALSE:
+	swvisible = SW_HIDE;
+	break;
+      case T_FIXNUM:
+      case T_BIGNUM:
+	swvisible = FIX2INT(v_flag);
+	break;
+      default:
+	rb_raise(rb_eTypeError, "Argument must be true or false or Integer");
+    }
+    rw_call_without_gvl_2(rw->nthread_id, (FARPROC)ShowWindow, (ULONG_PTR)rw->hwnd, swvisible);
+    return self;
+}
+
+static VALUE
+rwwin_getidcmd(VALUE self){
+    RwWindow *rw = DATA_PTR(self);
+    RwCheckWindow(rw);
+    return INT2FIX(GetWindowLongPtr(rw->hwnd, GWLP_ID));
+}
+
+static VALUE
+rwwin_setidcmd(VALUE self, VALUE v_id){
+    RwWindow *rw = DATA_PTR(self);
+    RwCheckWindow(rw);
+    SetWindowLongPtr(rw->hwnd, GWLP_ID, FIX2INT(v_id));
+    return self;
+}
+
+static VALUE
+rwwin_getparent(VALUE self){
+    HWND hparent;
+    RwWindow *rw = DATA_PTR(self);
+    RwCheckWindow(rw);
+    if(hparent = GetParent(rw->hwnd)){
+	VALUE pw;
+	if(!(pw = Get_win(hparent))) pw = Get_childwin(hparent);
+	return pw ? pw : Qnil;
+    }
+    return Qnil;
+}
+
+static VALUE
+rwwin_setparent(VALUE self, VALUE v_parent){
+    HWND h_old;
+    RwWindow *rp;
+    RwWindow *rw = DATA_PTR(self);
+    RwCheckWindow(rw);
+    RwWindow_Data_Get_Struct(v_parent, rp);
+    RwCheckWindow(rp);
+    h_old = SetParent(rw->hwnd, rp->hwnd);
+    if(h_old){
+	VALUE pw;
+	if(!(pw = Get_win(h_old))) pw = Get_childwin(h_old);
+	return pw ? pw : Qnil;
+    }else{
+	return Qnil;
+    }
+}
+
+static VALUE
+rwwin_getx(VALUE self){
+    RECT rc;
+    RwWindow *rw = DATA_PTR(self);
+    RwCheckWindow(rw);
+    rw_getclientpos_core(rw->hwnd, &rc);
+    return INT2FIX(rc.left);
+}
+
+static VALUE
+rwwin_gety(VALUE self){
+    RECT rc;
+    RwWindow *rw = DATA_PTR(self);
+    RwCheckWindow(rw);
+    rw_getclientpos_core(rw->hwnd, &rc);
+    return INT2FIX(rc.top);
+}
+
+static VALUE
+rwwin_getw(VALUE self){
+    RECT rc;
+    RwWindow *rw = DATA_PTR(self);
+    RwCheckWindow(rw);
+    GetWindowRect(rw->hwnd, &rc);
+    return INT2FIX(rc.right - rc.left);
+}
+
+static VALUE
+rwwin_geth(VALUE self){
+    RECT rc;
+    RwWindow *rw = DATA_PTR(self);
+    RwCheckWindow(rw);
+    GetWindowRect(rw->hwnd, &rc);
+    return INT2FIX(rc.bottom - rc.top);
+}
+
+static void
+rw_setxy_core(HWND hwnd, POINT *pt, int *w, int *h){
+    RECT rc;
+    GetWindowRect(hwnd, &rc);
+    *w = rc.right - rc.left;
+    *h = rc.bottom - rc.top;
+    pt->x = rc.left;
+    pt->y = rc.top;
+    ScreenToClient(GetAncestor(hwnd, GA_PARENT), pt);
+}
+
+static VALUE
+rwwin_setx(VALUE self, VALUE v_x){
+    int w, h;
+    POINT pt;
+    RwWindow *rw = DATA_PTR(self);
+    RwCheckWindow(rw);
+    rw_setxy_core(rw->hwnd, &pt, &w, &h);
+    rw_call_without_gvl_6(rw->nthread_id, (FARPROC)MoveWindow, (ULONG_PTR)rw->hwnd,
+			  FIX2INT(v_x), pt.y, w, h, FALSE);
+    return v_x;
+}
+
+static VALUE
+rwwin_sety(VALUE self, VALUE v_y){
+    int w, h;
+    POINT pt;
+    RwWindow *rw = DATA_PTR(self);
+    RwCheckWindow(rw);
+    rw_setxy_core(rw->hwnd, &pt, &w, &h);
+    rw_call_without_gvl_6(rw->nthread_id, (FARPROC)MoveWindow, (ULONG_PTR)rw->hwnd,
+			  pt.x, FIX2INT(v_y), w, h, FALSE);
+    return v_y;
+}
+
+static VALUE
+rwwin_setw(VALUE self, VALUE v_w){
+    int w, h;
+    POINT pt;
+    RwWindow *rw = DATA_PTR(self);
+    RwCheckWindow(rw);
+    rw_setxy_core(rw->hwnd, &pt, &w, &h);
+    rw_call_without_gvl_6(rw->nthread_id, (FARPROC)MoveWindow, (ULONG_PTR)rw->hwnd,
+			  pt.x, pt.y, FIX2INT(v_w), h, FALSE);
+    return v_w;
+}
+
+static VALUE
+rwwin_seth(VALUE self, VALUE v_h){
+    int w, h;
+    POINT pt;
+    RwWindow *rw = DATA_PTR(self);
+    RwCheckWindow(rw);
+    rw_setxy_core(rw->hwnd, &pt, &w, &h);
+    rw_call_without_gvl_6(rw->nthread_id, (FARPROC)MoveWindow, (ULONG_PTR)rw->hwnd,
+			  pt.x, pt.y, w, FIX2INT(v_h), FALSE);
+    return v_h;
+}
+
+static VALUE
+rwwin_setsubclass(VALUE self){
+    int id;
+    RwWindow *rw = DATA_PTR(self);
+    RwCheckWindow(rw);
+    id = GetWindowLongPtr(rw->hwnd, GWLP_ID);
+    SetWindowSubclass(rw->hwnd, RwSubclassProc, (UINT_PTR)id, (DWORD_PTR)self);
+    return self;
+}
+
+static VALUE
+rwwin_removesubclass(VALUE self){
+    int id;
+    RwWindow *rw = DATA_PTR(self);
+    RwCheckWindow(rw);
+    id = GetWindowLongPtr(rw->hwnd, GWLP_ID);
+    RemoveWindowSubclass(rw->hwnd, RwSubclassProc, (UINT_PTR)id);
+    return self;
+}
+
+static ULONG_PTR
+rw_get_param(VALUE v_param){
+    switch(TYPE(v_param)) {
+      case T_FIXNUM:
+      case T_BIGNUM:
+	return NUM2ULONG_PTR(v_param);
+      case T_DATA:
+	if (rb_typeddata_is_kind_of(v_param, &cstruct_data_type)){
+	    CStructData *cs;
+	    CStruct_Data_Get_Struct(v_param, cs);
+	    return (ULONG_PTR)cs->dtstr + cs->dtoffset;
+	}
+      case T_STRING:
+	if(rb_enc_get_index(v_param)) {
+	    return (ULONG_PTR)rw_str2tchar(v_param);
+	} else {
+	    return (ULONG_PTR)RSTRING_PTR(v_param);
+	}
+      default:
+	rb_raise(rb_eTypeError, "Invalid type:%s", rb_class2name(rb_class_of(v_param)));
+    }
+}
+
+static VALUE
+rwwin_setfocus(VALUE self){
+    RwWindow *rw = DATA_PTR(self);
+    RwCheckWindow(rw);
+    return SetFocus(rw->hwnd) ? self : Qnil;
+}
+
+static VALUE
+rwwin_setredraw(int argc, VALUE *argv, VALUE self){
+    VALUE v_flag ;//, v_l, v_t, v_r, v_b;
+    int flag;
+    RECT rc;
+    RECT *prc = NULL;
+    RwWindow *rw = DATA_PTR(self);
+    switch(argc){
+      case 0:
+	flag = RDW_ERASE | RDW_FRAME | RDW_INVALIDATE | RDW_ALLCHILDREN;
+	break;
+      case 1:
+	v_flag = argv[0];
+	if (!v_flag) {
+	    flag = FALSE;
+	} else {
+	    flag = (v_flag==Qtrue) ? RDW_ERASE | RDW_FRAME | RDW_INVALIDATE | RDW_ALLCHILDREN :\
+	                             FIX2INT(v_flag);
+	}
+	break;
+      case 4:
+	rc.left = FIX2INT(argv[0]);
+	rc.top = FIX2INT(argv[1]);
+	rc.right = FIX2INT(argv[2]);
+	rc.bottom = FIX2INT(argv[3]);
+	prc = &rc;
+	flag = RDW_ERASE | RDW_FRAME | RDW_INVALIDATE | RDW_ALLCHILDREN;
+	break;
+      case 5:
+	rc.left = FIX2INT(argv[0]);
+	rc.top = FIX2INT(argv[1]);
+	rc.right = FIX2INT(argv[2]);
+	rc.bottom = FIX2INT(argv[3]);
+	prc = &rc;
+	flag = (argv[4]==Qtrue) ? RDW_ERASE | RDW_FRAME | RDW_INVALIDATE | RDW_ALLCHILDREN :\
+	                         FIX2INT(argv[4]);
+	break;
+      default:
+	rb_raise(rb_eArgError, "Num of arguments must be 0, 1, 4 or 5");
+    }
+    SendMessage(rw->hwnd, WM_SETREDRAW, flag, 0);
+    if(flag) RedrawWindow(rw->hwnd, prc, NULL, flag);
+    return self;
+}
+
+
+
+
+static VALUE
+rwwin_sendmessage(VALUE self, VALUE v_msg, VALUE v_wparam, VALUE v_lparam){
+    int r;
+    RwWindow *rw = DATA_PTR(self);
+    RwCheckWindow(rw);
+    r = rw_call_without_gvl_4(rw->nthread_id, (FARPROC)SendMessage, (ULONG_PTR)rw->hwnd,
+			      NUM2UINT(v_msg), rw_get_param(v_wparam), rw_get_param(v_lparam));
+    return INT2NUM(r);
+}
+
+static VALUE
+rwwin_postmessage(VALUE self, VALUE v_msg, VALUE v_wparam, VALUE v_lparam){
+    int r;
+    RwWindow *rw = DATA_PTR(self);
+    RwCheckWindow(rw);
+    r = rw_call_without_gvl_4(rw->nthread_id, (FARPROC)PostMessage, (ULONG_PTR)rw->hwnd,
+			      NUM2UINT(v_msg), rw_get_param(v_wparam), rw_get_param(v_lparam));
+    return r ? Qtrue : Qnil;
+}
+
+static VALUE
+rwwin_getwndlong(VALUE self, VALUE v_idx){
+    RwWindow *rw = DATA_PTR(self);
+    RwCheckWindow(rw);
+    return INT2NUM(GetWindowLongPtr(rw->hwnd, FIX2INT(v_idx)));
+}
+
+static VALUE
+rwwin_setwndlong(VALUE self, VALUE v_idx, VALUE v_arg){
+    RwWindow *rw = DATA_PTR(self);
+    RwCheckWindow(rw);
+    if (SetWindowLongPtr(rw->hwnd, FIX2INT(v_idx), NUM2INT(v_arg))) {
+	rw_call_without_gvl_7(rw->nthread_id, (FARPROC)SetWindowPos, (ULONG_PTR)rw->hwnd, 0, 0,
+			      0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER | SWP_FRAMECHANGED);
+	return Qtrue;
+    }
+    return Qfalse;
+}
+
+static VALUE
+rwwin_setwndpos(VALUE self, VALUE v_insert_after, VALUE v_x, VALUE v_y, VALUE v_w, VALUE v_h, VALUE v_flags){
+    int r, insert_after;
+    RwWindow *rw = DATA_PTR(self);
+    RwCheckWindow(rw);
+    if(rb_typeddata_is_kind_of(v_insert_after, &rwwin_data_type)){
+	RwWindow *wn;
+	RwWindow_Data_Get_Struct(self, wn);
+	RwCheckWindow(wn);
+	insert_after = (ULONG_PTR)wn->hwnd;
+    } else {
+	insert_after = NUM2INT(v_insert_after);
+    }
+    r = rw_call_without_gvl_7(rw->nthread_id, (FARPROC)SetWindowPos, (ULONG_PTR)rw->hwnd,
+			      insert_after, FIX2INT(v_x), FIX2INT(v_y), FIX2INT(v_w),
+			      FIX2INT(v_h), NUM2INT(v_flags));
+    return r ? Qtrue : Qnil;
+}
+
+static VALUE
+rwwin_getwindowrect(VALUE self){
+    RECT rc;
+    RwWindow *rw = DATA_PTR(self);
+    RwCheckWindow(rw);
+    if(GetWindowRect(rw->hwnd, &rc)){
+	CStructData *cs;
+	VALUE v_rect = api_cstruct_new(ccsRECT);
+	CStruct_Data_Get_Struct(v_rect, cs);
+	memcpy(cs->dtstr, &rc, sizeof(RECT)); /* cs->dtoffset is always 0 */
+	return v_rect;
+    } else {
+	return Qfalse;
+    }
+}
+
+static VALUE
+rwwin_setcapture(VALUE self){
+    HWND hWnd;
+    VALUE wobj;
+    RwWindow *rw = DATA_PTR(self);
+    RwCheckWindow(rw);
+    hWnd = SetCapture(rw->hwnd);
+    if(!(wobj = Get_win(hWnd))) wobj = Get_childwin(hWnd);
+    return wobj || Qnil; /* return previous captured window */
+}
+
+static VALUE
+rwwin_releasecapture(VALUE self){
+    int r = ReleaseCapture();
+    return r ? Qtrue : Qfalse;
+}
+
+static VALUE
+rwwin_showwindow(VALUE self, VALUE v_flag){
+    RwWindow *rw = DATA_PTR(self);
+    RwCheckWindow(rw);
+    rw_call_without_gvl_2(rw->nthread_id, (FARPROC)ShowWindow, (ULONG_PTR)rw->hwnd,
+			  FIX2INT(v_flag));
+    return self;
+}
+
+static VALUE
+rwwin_registerhotkey(VALUE self, VALUE v_id, VALUE v_modifiers, VALUE v_vkey){
+    int r;
+    RwWindow *rw = DATA_PTR(self);
+    RwCheckWindow(rw);
+    r = RegisterHotKey(rw->hwnd, NUM2INT(v_id), NUM2UINT(v_modifiers), NUM2UINT(v_vkey));
+    return r ? Qtrue : Qfalse;
+}
+
+static VALUE
+rwwin_unregisterhotkey(VALUE self, VALUE v_id){
+    int r;
+    RwWindow *rw = DATA_PTR(self);
+    RwCheckWindow(rw);
+    r = UnregisterHotKey(rw->hwnd, NUM2INT(v_id));
+    return r ? Qtrue : Qfalse;
+}
+
+static VALUE
+rwwin_client2screen(VALUE self, VALUE v_x, VALUE v_y){
+    VALUE robj;
+    POINT pt;
+    RwWindow *rw = DATA_PTR(self);
+    pt.x = NUM2INT(v_x);
+    pt.y = NUM2INT(v_y);
+    ClientToScreen(rw->hwnd, &pt);
+    robj = rb_ary_new2(2);
+    rb_ary_store(robj, 0, INT2NUM(pt.x));
+    rb_ary_store(robj, 1, INT2NUM(pt.y));
+    return robj;
+}
+
+static VALUE
+rwwin_screen2client(VALUE self, VALUE v_x, VALUE v_y){
+    VALUE robj;
+    POINT pt;
+    RwWindow *rw = DATA_PTR(self);
+    pt.x = NUM2INT(v_x);
+    pt.y = NUM2INT(v_y);
+    ScreenToClient(rw->hwnd, &pt);
+    robj = rb_ary_new2(2);
+    rb_ary_store(robj, 0, INT2NUM(pt.x));
+    rb_ary_store(robj, 1, INT2NUM(pt.y));
+    return robj;
+}
+
+void
+rw_init_RwWindow(){
+    cRwWindow = rb_define_class_under(mRwin, "Window", rb_cData);
+    rb_define_alloc_func(cRwWindow, alloc_rw_window);
+    rb_define_singleton_method(cRwWindow, "new_from_handle", rwwin1_new_from_handle, 1);
+    
+    rb_define_method(cRwWindow, "register_event", rwwin_msgfilter_add, -1);
+    rb_define_method(cRwWindow, "unregister_event", rwwin_msgfilter_delete, -1);
+    rb_define_method(cRwWindow, "event_registered?", rwwin_msgfilter_exist_p, -1);
+    rb_define_method(cRwWindow, "registered_messages", rwwin_msgfilter_getfilters, 0);    
+    rb_define_method(cRwWindow, "set_msgtranslator", rwwin_msgtranslator_set, -1);
+    rb_define_method(cRwWindow, "get_msgtranslator", rwwin_msgtranslator_get, 1);
+    rb_define_method(cRwWindow, "method_missing", rw_method_missing, -1);
+    rb_define_method(cRwWindow, "set_accelerator", rw_set_accelerator, 1);
+    
+    
+    rb_define_method(cRwWindow, "create", rwwin_create, -1);
+    rb_define_method(cRwWindow, "close", rwwin_close, 0);
+    rb_define_method(cRwWindow, "_hwnd", rwwin_gethandle, 0);
+    rb_define_method(cRwWindow, "alive?", rwwin_alive_p, 0);
+    rb_define_method(cRwWindow, "move", rwwin_move, -1);
+    rb_define_method(cRwWindow, "resize", rwwin_resize, 2);
+    rb_define_method(cRwWindow, "refresh", rwwin_refresh, -1);
+    rb_define_method(cRwWindow, "redraw", rwwin_setredraw, -1);
+    rb_define_method(cRwWindow, "screenpos", rwwin_getscreenpos, 0);
+    rb_define_method(cRwWindow, "clientpos", rwwin_getclientpos, 0);
+    rb_define_method(cRwWindow, "windowsize", rwwin_getwndsize, 0);
+    rb_define_method(cRwWindow, "clientsize", rwwin_getclientsize, 0);
+    rb_define_method(cRwWindow, "setorder", rwwin_setorder, 1);
+    rb_define_method(cRwWindow, "cursorPos", rwwin_getcursorpos, 0);
+    
+    /* r/w attributes */
+    rb_define_method(cRwWindow, "caption",rwwin_getcaption, 0);    
+    rb_define_method(cRwWindow, "caption=",rwwin_setcaption, 1);    
+    rb_define_method(cRwWindow, "visible", rwwin_getvisible, 0);
+    rb_define_method(cRwWindow, "visible=", rwwin_setvisible, 1);
+    rb_define_method(cRwWindow, "idcmd", rwwin_getidcmd, 0);
+    rb_define_method(cRwWindow, "idcmd=", rwwin_setidcmd, 1);
+    rb_define_method(cRwWindow, "parent", rwwin_getparent, 0);
+    rb_define_method(cRwWindow, "parent=", rwwin_setparent, 1);
+    rb_define_method(cRwWindow, "x", rwwin_getx, 0);
+    rb_define_method(cRwWindow, "y", rwwin_gety, 0);
+    rb_define_method(cRwWindow, "w", rwwin_getw, 0);
+    rb_define_method(cRwWindow, "h", rwwin_geth, 0);
+    rb_define_method(cRwWindow, "x=", rwwin_setx, 1);
+    rb_define_method(cRwWindow, "y=", rwwin_sety, 1);
+    rb_define_method(cRwWindow, "w=", rwwin_setw, 1);
+    rb_define_method(cRwWindow, "h=", rwwin_seth, 1);
+    
+    /* hook functions */
+    rb_define_method(cRwWindow, "SetWindowSubclass", rwwin_setsubclass, 0);
+    rb_define_method(cRwWindow, "RemoveWindowSubclass", rwwin_removesubclass, 0);
+
+    /* API functions */
+    rb_define_method(cRwWindow, "SetFocus", rwwin_setfocus, 0);
+    rb_define_method(cRwWindow, "SendMessage", rwwin_sendmessage, 3);
+    rb_define_method(cRwWindow, "PostMessage", rwwin_postmessage, 3);
+    rb_define_method(cRwWindow, "GetWindowLong", rwwin_getwndlong, 1);
+    rb_define_method(cRwWindow, "SetWindowLong", rwwin_setwndlong, 2);
+    rb_define_method(cRwWindow, "SetWindowPos", rwwin_setwndpos, 6);
+    rb_define_method(cRwWindow, "GetWindowRect", rwwin_getwindowrect, 0);
+    rb_define_method(cRwWindow, "SetCapture", rwwin_setcapture, 0);
+    rb_define_method(cRwWindow, "ReleaseCapture", rwwin_releasecapture, 0);
+    rb_define_method(cRwWindow, "ShowWindow", rwwin_showwindow, 1);
+    rb_define_method(cRwWindow, "RegisterHotKey", rwwin_registerhotkey, 3);
+    rb_define_method(cRwWindow, "UnregisterHotKey", rwwin_unregisterhotkey, 1);
+    rb_define_method(cRwWindow, "ClientToScreen", rwwin_client2screen, 2);
+    rb_define_method(cRwWindow, "ScreenToClient", rwwin_screen2client, 2);
+}
+
+/* RwDaialog */
+VALUE cRwDialog;
+
+/* TypedData */
+void rw_dlg_free(void *ptr){
+    RwDialog *rd =ptr;
+    if (rd->rwwin.hwnd) DestroyWindow(rd->rwwin.hwnd);
+    if (rd->rwwin.msgfilter) freeAAtree(rd->rwwin.msgfilter);
+    if (rd->rwwin.handler_ids) freeAAtree(rd->rwwin.handler_ids);
+    free(rd);
+}
+
+static size_t
+rwdlg_memsize(const void *ptr){
+    return ptr ? sizeof(RwDialog) : 0;
+}
+
+const rb_data_type_t
+rwdlg_data_type = { /* parent is rwwin_data_type */
+    "Dialog", {NULL, rw_dlg_free, rwdlg_memsize}, &rwwin_data_type, NULL
+};
+
+static VALUE
+alloc_rw_dialog(VALUE klass){
+    RwDialog *rd;
+    VALUE obj;
+    obj = RwDialog_Data_Make_Struct(klass, rd);
+    rd->rwwin.msgfilter = NULL;
+    rd->rwwin.handler_ids = NULL;
+    return obj;
+}
+
+INT_PTR CALLBACK
+RwDlgProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam){
+    VALUE wobj;
+    if(uMsg==WM_INITDIALOG){
+	RwDialog *rd;
+	VALUE dobj = lParam;
+	RwDialog_Data_Get_Struct(dobj, rd);
+	rd->rwwin.hwnd = hWnd;
+	Register_win(hWnd, dobj);
+    }
+    if(wobj = Get_win(hWnd)){
+	RwWindow *rw = DATA_PTR(wobj);
+	if(uMsg == WM_PAINT){
+	    if (rw->msgfilter) {
+		AAnode *nd = aaSearch(rw->msgfilter, WM_PAINT);
+		if (nd) {
+		    PAINTSTRUCT ps;
+		    RwBaseHandler *basehandler = nd->val;
+		    HDC hdc = BeginPaint(rw->hwnd, &ps);
+		    dispatch_wm_paint_handler(wobj, basehandler, hdc);
+		    EndPaint(rw->hwnd, &ps);
+		    return 0;
+		}
+	    }
+	} else {
+	    LRESULT ret;
+	    if (uMsg==WM_ACTIVATE) activewin = LOWORD(wParam) ? rw : NULL;
+	    ret=do_wm_default(wobj, &uMsg, &wParam, &lParam);
+	    if (ret){
+		SetWindowLongPtr(hWnd, DWLP_MSGRESULT, ret);
+		return TRUE; /* skip default dlgdproc */
+	    }
+	}
+
+	switch(uMsg){
+	  case WM_CLOSE:
+	    if(((RwDialog*)rw)->modal) {
+		EndDialog(hWnd, Qfalse);
+		if(aaCount(winlist)==0) rwwin_finalize();
+	    } else {
+		DestroyWindow(hWnd);
+	    }
+	    return TRUE;
+	  case WM_DESTROY:
+	    rw->hwnd = NULL;
+	    Unregister_win(hWnd);
+	    if(aaCount(winlist)==0){
+		rwwin_finalize();
+		PostQuitMessage(wParam);
+		return 0;
+	    }
+	    return TRUE;
+	  default:
+	    break;
+	}
+    } 
+    return 0; 
+}
+
+static VALUE
+rwdialog_create(int argc, VALUE *argv, VALUE self){
+    DLGTEMPLATE *template;
+    VALUE v_parent, v_modal, v_param;
+    INT_PTR ret;
+    HWND hparent = NULL;
+    BOOL template_given = FALSE;
+    RwDialog *rd = DATA_PTR(self);
+    
+    if(rb_typeddata_is_kind_of(argv[2], &cstruct_data_type)) {
+	VALUE v_template;
+	CStructData *cs;
+	rb_scan_args(argc, argv, "31", &v_parent, &v_modal, &v_template, &v_param);
+	CStruct_Data_Get_Struct(v_template, cs);
+	template_given = TRUE;
+	template = (DLGTEMPLATE*)(cs->dtstr + cs->dtoffset);
+    } else { /* create default template */
+	VALUE v_style, v_exstyle;
+	rb_scan_args(argc, argv, "23", &v_parent, &v_modal, &v_style, &v_exstyle, &v_param);
+	RW_CALLOC(template, sizeof(DLGTEMPLATE) + 4);
+	template->style = NIL_P(v_style) ?
+	    (WS_POPUP | WS_BORDER | WS_SYSMENU | WS_CAPTION | DS_MODALFRAME) : NUM2UINT(v_style);
+	template->dwExtendedStyle = NIL_P(v_exstyle) ? 0 : NUM2UINT(v_exstyle);
+	rd->param = v_param;
+    }
+    
+    rd->modal = (!NIL_P(v_modal) && v_modal) ? TRUE : FALSE;
+    if(!NIL_P(v_parent)){
+	RwWindow *rw;
+	RwWindow_Data_Get_Struct(v_parent, rw);
+	hparent = rw->hwnd;
+    }
+    if(rd->modal){
+	ret = DialogBoxIndirectParam(hInstance, template, hparent, RwDlgProc, self);
+	if (ret==-1) rb_raise(rb_eRuntimeError,"create modal dialog failed");
+    } else {
+	HWND hwnd;
+	hwnd = CreateDialogIndirectParam(hInstance, template, hparent, RwDlgProc, self);
+	if (!hwnd) rb_raise(rb_eRuntimeError,"create modeless dialog failed");
+	ShowWindow(hwnd, TRUE);
+	ret = Qnil;
+    }
+    if(!template_given) {
+	free(template);
+    }
+    return (VALUE)ret;
+}
+
+static VALUE
+rwdialog_close(int argc, VALUE *argv, VALUE self){
+    VALUE v_ret;
+    RwWindow *rw;
+    RwDialog *rd = DATA_PTR(self);
+    rw = (RwWindow*)rd;
+    RwCheckWindow(rw);
+    rb_scan_args(argc, argv, "01", &v_ret);
+    if (rd->modal){ //fprintf(stderr, "@%d: v_ret=%lld\n", __LINE__, v_ret); 
+//	return rw_call_without_gvl_2(rw->nthread_id, (FARPROC)EndDialog, (ULONG_PTR)rw->hwnd,
+//				     (ULONG_PTR)v_ret);
+	return EndDialog(rw->hwnd, (INT_PTR)v_ret);
+    } else {
+	DestroyWindow(((RwWindow*)rd)->hwnd);
+	return 0;
+    }
+}
+
+static VALUE
+rwdialog_getparam(VALUE self){
+    RwDialog *rd = DATA_PTR(self);
+    RwCheckWindow((RwWindow*)rd);
+    return rd->param;
+}
+
+static void
+rw_init_RwDialog(){
+    cRwDialog = rb_define_class_under(mRwin, "Dialog", cRwWindow);
+    rb_define_alloc_func(cRwDialog, alloc_rw_dialog);
+    rb_define_method(cRwDialog, "create", rwdialog_create, -1);
+    rb_define_method(cRwDialog, "close", rwdialog_close, -1);
+    rb_define_method(cRwDialog, "param", rwdialog_getparam, 0);
+    
+    rb_undef_method(cRwDialog, "SetWindowSubclass");
+    rb_undef_method(cRwDialog, "RemoveWindowSubclass");
+}
+
+/* Initializing */
+void
+Init_rw_windows(){
+    rw_init_RwWindow();
+    rw_init_RwDialog();
+}