wrb 2.0.0

data/ext/rwin/rwin.c

@@ -0,0 +1,451 @@
+/*
+# 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"
+#include "shlwapi.h"
+
+VALUE IS_GUIAPP;
+VALUE COMCTL_MAJOR_VERSION;
+VALUE COMCTL_MINOR_VERSION;
+
+HINSTANCE hInstance;
+ATOM RwClassAtom;
+
+AAtree *winlist;
+AAtree *childwinlist;
+AAtree *rsclist;
+
+VALUE internal_encoding, external_encoding, wchar_encoding;
+rb_encoding *rw_internal_enc, *rw_external_enc, *rw_wchar_enc;
+
+/* modules and classes */
+VALUE mRwin;
+VALUE mRwApp;
+VALUE cRwCancelDefWndProc;
+
+/* ruby's global variables */
+VALUE resources;
+
+/* Errors */
+VALUE rw_eResourceNotAliveError;
+VALUE rw_eWindowNotAliveError;
+
+/* Window's global variables */
+HWND   current_hwnd;
+HACCEL current_haccel;
+RwWindow *activewin;
+
+/* Encoding */
+TCHAR* /* front end from Ruby */
+rw_str2tchar(VALUE str){ /* pointer only*/
+    volatile VALUE t = rb_str_encode(str, internal_encoding, 0, Qnil); /* GC_GUARD */
+    return (TCHAR*)RSTRING_PTR(t);
+}
+
+TCHAR* /* pointer and bytesize */
+rw_str2tchar2(VALUE str, size_t *bytesize){
+    volatile VALUE t = rb_str_encode(str, internal_encoding, 0, Qnil); /* GC_GUARD */
+    *bytesize = RSTRING_LEN(t);
+    return (TCHAR*)RSTRING_PTR(t);
+}
+
+WCHAR*
+rw_str2wchar(VALUE str){
+    volatile VALUE w = rb_str_encode(str, wchar_encoding, 0, Qnil);   /* GC_GUARD */
+    return (WCHAR*)RSTRING_PTR(w);
+}
+
+VALUE /* Back end to Ruby */
+rw_encode_external(TCHAR *buff){
+#if UNICODE
+    VALUE str = rb_enc_str_new((char*)buff, wcslen(buff)*sizeof(WCHAR), rw_internal_enc);
+#else
+    VALUE str = rb_enc_str_new((char*)buff, strlen(buff)*sizeof(CHAR), rw_internal_enc);
+#endif
+    return rb_str_encode(str, external_encoding, 0, Qnil);
+}
+
+VALUE /* Back end to Ruby */
+rw_encode_external2(WCHAR *buff, int len){
+    VALUE str = rb_enc_str_new((char*)buff, len, rw_internal_enc);
+    return rb_str_encode(str, external_encoding, 0, Qnil);
+}
+
+/* for converting cygwin path*/
+void
+rwconv2absolute_path(char* dst, char* src){
+#ifdef __CYGWIN__
+    cygwin_conv_path(CCP_POSIX_TO_WIN_A|CCP_ABSOLUTE, src, dst, RW_MAXPATH);
+#else
+    _fullpath(dst, src, RW_MAXPATH);
+#endif
+}
+
+void
+rwconv2absolute_pathW(wchar_t* dst, wchar_t* src){
+#ifdef __CYGWIN__
+    cygwin_conv_path(CCP_POSIX_TO_WIN_W|CCP_ABSOLUTE, src, dst, RW_MAXPATH);
+#else
+    _wfullpath(dst, src, RW_MAXPATH);
+#endif
+}
+
+static VALUE
+rwapp_hinstance(){
+    return INT2NUM((INT_PTR)hInstance);
+}
+
+/* Message loops */
+static VALUE
+rwapp_msgloop(){
+    MSG msg;
+#if RWIN_USEMULTITHREAD    
+   while(TRUE){
+       if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)){
+	   if (msg.message == WM_QUIT) break;
+	   if (!(activewin && TranslateAccelerator(activewin->hwnd, activewin->haccel, &msg))){
+	       TranslateMessage(&msg);
+	       DispatchMessage(&msg);
+	   }
+       } else { /* for Ruby's Thread */
+	   if(!GetQueueStatus(QS_ALLEVENTS)){
+	       rb_thread_call_without_gvl((void*(*)(void*))WaitMessage, 0, RUBY_UBF_IO, 0);
+	   }
+       }
+   }
+#else
+    while(GetMessage(&msg, NULL, 0, 0)){
+	if (!(activewin && TranslateAccelerator(activewin->hwnd, activewin->haccel, &msg))){
+	    TranslateMessage(&msg);
+	    DispatchMessage(&msg);
+	}
+    }
+#endif
+    rb_exit(msg.wParam);
+}
+
+static VALUE
+rwapp_dlgmsgloop(){
+    MSG msg;
+#if RWIN_USEMULTITHREAD    
+    while(TRUE){
+	if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)){
+	    if (msg.message == WM_QUIT) break;
+	    if (!((activewin && TranslateAccelerator(activewin->hwnd,activewin->haccel,&msg)) ||
+		  activewin && IsDialogMessage(activewin->hwnd, &msg))){
+		TranslateMessage(&msg);
+		DispatchMessage(&msg);
+	    }
+	} else { /* for Ruby Thread */
+	    if(!GetQueueStatus(QS_ALLEVENTS)){
+		rb_thread_call_without_gvl((void*(*)(void*))WaitMessage, 0, RUBY_UBF_IO, 0);
+	    }
+	}
+    }
+#else
+    while(GetMessage(&msg, NULL, 0, 0)){
+	if (!((activewin && TranslateAccelerator(activewin->hwnd,activewin->haccel,&msg)) ||
+	      activewin && IsDialogMessage(activewin->hwnd, &msg))){
+	    TranslateMessage(&msg);
+	    DispatchMessage(&msg);
+	}
+    }
+#endif
+    rb_exit(msg.wParam);
+}
+
+/* Prototyping */
+INT_PTR CALLBACK RwDlgProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
+
+static VALUE
+rwapp_automsgloop(){
+    MSG msg;
+#if RWIN_USEMULTITHREAD    
+    while(TRUE){
+	if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)){
+	    if (msg.message==WM_QUIT) break;
+	    if (!((activewin && TranslateAccelerator(activewin->hwnd,activewin->haccel,&msg)) ||
+	      activewin && (INT_PTR)RwDlgProc==GetWindowLongPtr(activewin->hwnd,DWLP_DLGPROC) &&
+		  IsDialogMessage(activewin->hwnd, &msg))){
+		TranslateMessage(&msg);
+		DispatchMessage(&msg);
+	    }
+	} else { /* for Ruby Thread */
+	    if(!GetQueueStatus(QS_ALLEVENTS)){
+		rb_thread_call_without_gvl((void*(*)(void*))WaitMessage, 0, RUBY_UBF_IO, 0);
+	    }
+	}
+    }
+#else
+    while(GetMessage(&msg, NULL, 0, 0)){
+	if (!((activewin && TranslateAccelerator(activewin->hwnd,activewin->haccel,&msg)) ||
+	      activewin && (INT_PTR)RwDlgProc==GetWindowLongPtr(activewin->hwnd,DWLP_DLGPROC) &&
+	      IsDialogMessage(activewin->hwnd, &msg))){
+	    TranslateMessage(&msg);
+	    DispatchMessage(&msg);
+	}
+    }
+#endif
+//    destroy_all_win(0);
+    rb_exit(msg.wParam);
+}
+
+BOOL
+RegisterWndClass(const TCHAR* classname, HICON hIcon,UINT clstyle, HBRUSH hBackGnd, HCURSOR hCursor, WNDPROC wndproc)
+{
+    WNDCLASSEX wc;
+    wc.cbSize = sizeof(WNDCLASSEX);
+    wc.style = clstyle;
+    wc.lpfnWndProc = wndproc;    
+    wc.cbClsExtra = 0;
+    wc.cbWndExtra = DWLP_USER;
+    wc.hInstance = hInstance;
+    wc.hIcon = hIcon;
+    wc.hCursor = hCursor;
+    wc.hbrBackground = hBackGnd;
+    wc.lpszMenuName = NULL;   
+    wc.lpszClassName = classname;
+    wc.hIconSm = 0; 
+    return (RegisterClassEx(&wc));
+}
+
+
+static void
+aa_callback_mark_rw_window(const AAnode *node, void *arg){
+    VALUE wobj = (VALUE)node->val;
+    RwWindow *rw = DATA_PTR(wobj);
+    if(rw->hwnd) rb_gc_mark(wobj);
+}
+
+static void
+aa_callback_mark_rw_rsrc(const AAnode *node, void *arg){
+    VALUE robj = (VALUE)node->val;
+    RwResource *rr = DATA_PTR(robj);
+    // fprintf(stderr, "@%d: type=%d, handle=%p\n", __LINE__,  rr->type, rr->handle);
+    if(rr->handle) rb_gc_mark(robj); /* Bitmap image will be held by Imagelist. */
+//    if(rr->type==RcMenu && rr->handle) rb_gc_mark(robj); /* Menu will be held by another one. */
+}
+
+static void
+mark_rw_window(void *ptr){
+    if (ptr){
+	RwResources *rc = ptr;
+	aaForeach(rc->winlist, aa_callback_mark_rw_window, NULL);
+	aaForeach(rc->childwinlist, aa_callback_mark_rw_window, NULL);
+	aaForeach(rc->rsclist, aa_callback_mark_rw_rsrc, NULL);
+    }
+}
+
+static void
+aa_callback_destroy_win(const AAnode *node, void *arg){
+    HWND hwnd = (HWND)node->key;
+    if (!GetParent(hwnd)){
+	DestroyWindow(hwnd);
+    }
+}
+
+void
+destroy_all_win(int gui){
+    RwResources *rc; 
+    Data_Get_Struct(resources, RwResources, rc);
+    aaForeach(rc->winlist, aa_callback_destroy_win, &gui);
+}
+
+static VALUE
+rwapp_quit_app(VALUE mod){
+    PostQuitMessage(0);
+    return Qnil;
+}
+
+static VALUE
+rwapp_getcursorpos(VALUE mod){
+    VALUE robj;
+    POINT pt;
+    GetCursorPos(&pt);
+    robj = rb_ary_new2(2);
+    rb_ary_store(robj, 0, INT2FIX(pt.x));
+    rb_ary_store(robj, 1, INT2FIX(pt.y));
+    return robj;
+}
+
+/* Cancel DefWindowProc */
+static size_t
+rw_candefwndprc_m_size(const void *ptr){
+    return ptr ? sizeof(RwCancelDefWindowProc) : 0;
+}
+
+const rb_data_type_t
+rw_candefwndprc_d_type = {
+    "CancelDefWindowProc", {NULL, free, rw_candefwndprc_m_size,}, NULL, NULL
+};
+
+static VALUE
+rw_msg_new_and_set_retval(int argc, VALUE *argv, VALUE klass){
+    RwCancelDefWindowProc *rcp;
+    VALUE obj = TypedData_Make_Struct(cRwCancelDefWndProc, RwCancelDefWindowProc, &rw_candefwndprc_d_type, rcp);
+    if (argc>0) {
+	rcp->retval = NIL_P(argv[0]) ? 1 : NUM2ULONG_PTR(argv[0]);
+    }
+    return obj;
+}
+
+static VALUE
+rwapp_get_externalenc(){
+    return external_encoding;
+}
+static VALUE
+rwapp_set_externalenc(VALUE klass, VALUE enc){
+    external_encoding = enc;
+    rw_external_enc = rb_enc_from_index(rb_to_encoding_index(external_encoding));
+    return enc;
+}
+
+static VALUE
+is_unicodep(){
+#ifdef UNICODE
+    return Qtrue;
+#else
+    return Qfalse;
+#endif
+}
+
+static void
+set_rw_gui_app_p(){
+    IMAGE_OPTIONAL_HEADER32 *opt_hdr;
+    IMAGE_DOS_HEADER *dos_hdr = (IMAGE_DOS_HEADER*)hInstance;
+    opt_hdr = (IMAGE_OPTIONAL_HEADER32*)((char*)hInstance + dos_hdr->e_lfanew + sizeof(DWORD) +
+					 sizeof(IMAGE_FILE_HEADER));
+    IS_GUIAPP = (opt_hdr->Subsystem == IMAGE_SUBSYSTEM_WINDOWS_GUI) ? Qtrue : Qfalse;
+}
+
+static void
+set_rw_comctlversion(){
+    DLLVERSIONINFO dvi;
+    HANDLE hdll = LoadLibrary(TEXT("comctl32.dll"));
+    FARPROC pDllGetVersion = (FARPROC)GetProcAddress(hdll, "DllGetVersion");
+    ZeroMemory(&dvi, sizeof(dvi));
+    dvi.cbSize = sizeof(dvi);
+    if (pDllGetVersion && pDllGetVersion(&dvi)==S_OK) {
+	COMCTL_MAJOR_VERSION = INT2FIX(dvi.dwMajorVersion);
+	COMCTL_MINOR_VERSION = INT2FIX(dvi.dwMinorVersion);
+    } else {
+	COMCTL_MAJOR_VERSION = Qnil;
+	COMCTL_MINOR_VERSION = Qnil;
+    }
+}
+
+static VALUE
+rwapp_count_opened_window(){
+    return INT2FIX(aaCount(winlist));
+}
+
+static VALUE
+rwapp_hwnd2ref(VALUE klass, VALUE v_handle){
+    VALUE wobj;
+    int hsearch = NUM2ULONG_PTR(v_handle);
+    if(wobj=Get_childwin(hsearch)) return wobj;
+    if(wobj=Get_win(hsearch)) return wobj;
+    return Qnil;
+}
+
+static VALUE
+rwapp_hrsc2ref(VALUE klass, VALUE v_handle){
+    VALUE wobj;
+    if(wobj=Get_rsc(NUM2ULONG_PTR(v_handle))) return wobj;
+    return Qnil;
+}
+
+/* Initializing */
+void
+Init_rwin(){
+    RwResources *rc;
+    
+    hInstance = GetModuleHandle(NULL);
+    set_rw_gui_app_p();
+    set_rw_comctlversion();
+    
+    resources = Data_Make_Struct(rb_cObject, RwResources, mark_rw_window, -1, rc);
+    rb_global_variable(&resources);
+    
+    activewin = NULL;
+    
+    winlist = newAAtree(NULL);/* destructor is't needed, 'cause Ruby destructs all at shudown */
+    childwinlist = newAAtree(NULL); /* ditto */
+    rsclist = newAAtree(NULL);      /* ditto */
+    rc->winlist = winlist;
+    rc->childwinlist = childwinlist;
+    rc->rsclist = rsclist;
+    
+    external_encoding = rb_enc_from_encoding(rb_default_external_encoding());
+    wchar_encoding = rb_enc_from_encoding(rb_enc_find("UTF-16LE"));
+#ifdef UNICODE
+    internal_encoding = wchar_encoding;
+#else
+    internal_encoding = external_encoding;
+#endif
+    rw_internal_enc = rb_enc_from_index(rb_to_encoding_index(internal_encoding));
+    rw_external_enc = rb_enc_from_index(rb_to_encoding_index(external_encoding));
+    rw_wchar_enc = rb_enc_from_index(rb_to_encoding_index(wchar_encoding));
+    
+    mRwin = rb_define_module("RWin");
+    mRwApp = rb_define_module_under(mRwin, "Application");
+
+    rb_define_const(mRwin, "RW_VERSION", rb_str_new2(RW_VERSION));
+#if UNICODE
+    rb_define_const(mRwin, "UNICODE", Qtrue);
+#else
+    rb_define_const(mRwin, "UNICODE", Qfalse);
+#endif
+    
+#ifdef _WIN64
+    rb_define_const(mRwin, "X64", Qtrue);
+#else
+    rb_define_const(mRwin, "X64", Qfalse);
+#endif
+    
+    rb_define_const(mRwApp, "IS_GUIAPP", IS_GUIAPP);
+    rb_define_const(mRwApp, "COMCTL_MAJOR_VERSION", COMCTL_MAJOR_VERSION);
+    rb_define_const(mRwApp, "COMCTL_MINOR_VERSION", COMCTL_MINOR_VERSION);
+    
+    rw_eResourceNotAliveError = rb_define_class_under(mRwin, "ResourceNotAliveError",
+						      rb_eRuntimeError);
+    rw_eWindowNotAliveError = rb_define_class_under(mRwin, "WindowNotAliveError",
+						    rb_eRuntimeError);
+    
+    rb_define_singleton_method(mRwApp,"hInstance", rwapp_hinstance, 0);
+    rb_define_singleton_method(mRwApp,"msgloop", rwapp_msgloop, 0);
+    rb_define_singleton_method(mRwApp,"dlgmsgloop", rwapp_dlgmsgloop, 0);
+    rb_define_singleton_method(mRwApp,"automsgloop", rwapp_automsgloop, 0);
+    rb_define_singleton_method(mRwApp,"quit!", rwapp_quit_app, 0);
+    rb_define_singleton_method(mRwApp, "GetCursorPos", rwapp_getcursorpos, 0);
+    
+    rb_define_singleton_method(mRwApp,"count_opened_window", rwapp_count_opened_window, 0);
+    rb_define_singleton_method(mRwApp,"hwnd2ref", rwapp_hwnd2ref, 1);
+    rb_define_singleton_method(mRwApp,"hrsc2ref", rwapp_hrsc2ref, 1);
+    
+    cRwCancelDefWndProc = rb_define_class_under(mRwApp, "CancelDefWindowProc", rb_cObject);
+    rb_define_singleton_method(mRwApp, "CancelDefWindowProc", rw_msg_new_and_set_retval, -1);
+    
+    RwClassAtom = RegisterWndClass(RW_CLASS_NAME, LoadIcon(NULL,IDI_APPLICATION),
+				   CS_GLOBALCLASS | CS_HREDRAW | CS_VREDRAW ,
+				   (HBRUSH)(1+COLOR_3DFACE), LoadCursor(NULL, IDC_ARROW),
+				   RwWndProc);
+
+    
+    /* Encoding */
+    rb_define_singleton_method(mRwApp, "external_encoding", rwapp_get_externalenc, 0);
+    rb_define_singleton_method(mRwApp, "external_encoding=", rwapp_set_externalenc, 1);
+    rb_define_singleton_method(mRwApp, "is_unicode?", is_unicodep, 0);
+
+    /* Initialize modules */
+    Init_rw_api();
+    Init_rw_windows();
+    Init_rw_resources();
+    Init_rw_graphics();
+    Init_rw_devices();
+}

data/ext/rwin/rwin.h

@@ -0,0 +1,442 @@
+/*
+# 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.
+*/
+
+#ifndef __RWIN_H__
+#define __RWIN_H__
+
+#include <ctype.h>
+#include <wchar.h>
+#include "ruby.h"
+#include <windows.h>
+#include <commctrl.h>
+
+#include "rw_gdiplus.h"
+
+#ifdef __CYGWIN__
+#  include <sys/cygwin.h>
+#endif
+
+#include "ruby/thread.h"
+#include "ruby/encoding.h"
+
+#include "aatree.h"
+
+#ifndef WINVER
+#  define WINVER 0x0580 /* Only for Windows XP and later, will not work on Windows 2000 or 9X */
+#endif
+
+#define RW_VERSION "2.0.0"
+#define RW_MAXPATH 256
+#define RW_CLASS_NAME TEXT("RUBYWIN")
+
+#ifdef _WIN64
+#  define NUM2HANDLE NUM2ULL
+#  define NUM2ULONG_PTR NUM2ULL
+#  define NUM2LONG_PTR NUM2LL
+#  define LONG_PTR2NUM LL2NUM
+#  define ULONG_PTR2NUM ULL2NUM
+#else
+#  define NUM2HANDLE NUM2ULONG
+#  define NUM2ULONG_PTR NUM2ULONG
+#  define NUM2LONG_PTR NUM2LONG
+#  define LONG_PTR2NUM LONG2NUM
+#  define ULONG_PTR2NUM ULONG2NUM
+#endif
+
+#define RW_MALLOC(ptr, size) do{ \
+    ptr = malloc(size); \
+    if(!ptr) rb_raise(rb_eRuntimeError, "failed to allocate memory"); \
+} while(0)
+
+#define RW_CALLOC(ptr, size) do{ \
+    ptr = calloc(size, sizeof(char)); \
+    if(!ptr) rb_raise(rb_eRuntimeError, "failed to allocate memory"); \
+} while(0)
+
+
+/* Global variables */
+extern ATOM RwClassAtom;
+extern HINSTANCE hInstance;
+
+extern AAtree *winlist;
+extern AAtree *childwinlist;
+extern AAtree *rsclist;
+
+/* Ruby's constants */
+extern VALUE IS_GUIAPP;
+extern VALUE COMCTL_MAJOR_VERSION;
+extern VALUE COMCTL_MINOR_VERSION;
+
+/* classes and modules */
+extern VALUE mRwin;
+extern VALUE mRwApp;
+extern VALUE cRwWindow;
+extern VALUE cRwCancelDefWndProc;
+extern VALUE cRwBitmap;
+extern VALUE cRwIcon;
+extern VALUE cRwImage;
+
+extern VALUE cRwCanvas;
+extern VALUE mRwAPI;
+extern VALUE cRwAPIfunc;
+extern VALUE cRwAPIstruct;
+extern VALUE apifunc_class_libs;
+
+/* CStruct constants */
+extern int _id_apistr_class_stsize;
+extern int _id_apistr_class_sttemplate;
+extern int _id_apistr_class_stclasses;
+extern int _id_apistr_class_stargcount;
+
+/* pre-defined classes for CStruct */
+extern VALUE ccsCHAR, ccsWCHAR, ccsTCHAR, ccsBYTE, ccsWORD, ccsDWORD, ccsPOINT, ccsSIZE, ccsRECT;
+extern VALUE ccsLOGBRUSH, ccsLOGFONT, ccsLOGPEN, ccsIMAGEINFO, ccsBITMAPINFO, ccsMENUITEMINFO;
+extern VALUE ccsDEVMODE;
+
+/* Errors */
+extern VALUE rw_eWindowNotAliveError;
+extern VALUE rw_eResourceNotAliveError;
+
+#define Register_win(hwnd, wobj) aaInsert(winlist, (ULONG_PTR)hwnd, (void*)wobj)
+#define Unregister_win(hwnd)     aaDelete(winlist, (ULONG_PTR)hwnd)
+#define Get_win(hwnd)            ((VALUE)aaGetval(winlist, (ULONG_PTR)hwnd))
+
+#define Register_childwin(hwnd, wobj) aaInsert(childwinlist, (ULONG_PTR)hwnd, (void*)wobj)
+#define Unregister_childwin(hwnd)     aaDelete(childwinlist, (ULONG_PTR)hwnd)
+#define Get_childwin(hwnd)            ((VALUE)aaGetval(childwinlist, (ULONG_PTR)hwnd))
+
+#define Register_rsc(handle, rcobj) aaInsert(rsclist, (ULONG_PTR)handle, (void*)rcobj)
+#define Unregister_rsc(handle)      aaDelete(rsclist, (ULONG_PTR)handle)
+#define Get_rsc(handle)             ((VALUE)aaGetval(rsclist, (ULONG_PTR)handle))
+
+/* Structures */
+
+typedef struct {
+    AAtree *winlist;
+    AAtree *childwinlist;
+    AAtree *rsclist;
+} RwResources;
+
+typedef struct {
+    HWND hwnd;
+    AAtree *msgfilter;
+    AAtree *handler_ids;
+    DWORD nthread_id;
+    HACCEL haccel;
+} RwWindow;
+
+typedef struct RwMsgHandler_ {
+    unsigned handler_id;
+    char *arg_template;
+    VALUE klass;
+    VALUE receiver;
+    struct RwMsgHandler_ *next;
+} RwMsgHandler;
+
+typedef struct {
+    RwMsgHandler *handler;
+    AAtree *senders;
+} RwBaseHandler;
+
+#define RwCheckWindow(win) \
+  if(!(win)->hwnd){rb_raise(rw_eWindowNotAliveError, "Window is not alive");}
+
+/* resources */
+
+typedef enum {
+    RcMenu = 0,
+    RcFont,
+    RcIcon,
+    RcCursor,
+    RcBitmap,
+    RcImagelist,
+    RcPen,
+    RcBrush
+} RCTYPE;
+
+typedef struct {
+    RCTYPE type;
+    HANDLE handle;
+} RwResource;
+
+typedef struct {
+    RCTYPE type;
+    HMENU hmenu;
+    HWND hwnd;
+} RwMenu;
+
+typedef struct {
+    RCTYPE type;
+    HFONT hfont;
+    int external;
+} RwFont;
+
+typedef struct {
+    RCTYPE type;
+    HICON hicon;
+    BOOL shared;
+} RwIcon;
+
+typedef struct {
+    RCTYPE type;
+    HCURSOR hcursor;
+    BOOL shared;
+} RwCursor;
+
+typedef struct {
+    RCTYPE type;
+    HBITMAP hbitmap;
+    HBITMAP hddbitmap; /* device dependent bitmap */
+    HDC hdc;
+    BOOL shared;
+} RwBitmap;
+
+typedef struct {
+    RCTYPE type;
+    HIMAGELIST himagelist;
+} RwImagelist;
+
+typedef struct{
+    RCTYPE type;
+    HPEN hpen;
+} RwPen;
+
+typedef struct{
+    RCTYPE type;
+    HBRUSH hbrush;
+} RwBrush;
+
+#define RwCheckResource(rc) \
+  if(!((RwResource*)rc)->handle){rb_raise(rw_eResourceNotAliveError, "Resource is not alive");}
+
+/* device contexts */
+typedef struct {
+    HDC hdc;
+    union {
+	HWND hwnd;
+	HBITMAP hbitmap;
+    };
+    union {
+	HANDLE h_orig;
+	HPEN   hp_orig;
+	HBRUSH hb_orig;
+	HFONT  hf_orig;
+    };
+    double rx;
+    double ry;
+} RwCanvas;
+
+typedef struct {
+    LRESULT retval;
+} RwCancelDefWindowProc;
+
+typedef struct {
+    int   nargs;
+    ULONG_PTR procaddress;
+} CFuncData;
+
+typedef struct {
+    char*  dtstr;
+    int    dtoffset;
+    size_t dtlen;
+    VALUE  dtparent;
+    VALUE* dtreferences;
+    BYTE   dtwrapped;
+    BYTE   bifunc;
+    WORD   prindex; /* index of parent for ArrayPart*/
+} CStructData;
+
+typedef struct {
+    RwWindow rwwin;
+    VALUE param;
+    BOOL modal;
+} RwDialog;
+
+typedef struct{
+    void* himage;
+} RwImage;
+
+/* Global variable for message loop */
+extern RwWindow *activewin;
+
+/* Definitions of TypedData */
+#ifndef HAVE_TYPE_RB_DATA_TYPE_T
+#  error "Need HAVE_TYPE_RB_DATA_TYPE_T"
+#endif
+
+extern const rb_data_type_t cfunc_data_type;
+extern const rb_data_type_t cstruct_data_type;
+extern const rb_data_type_t rwwin_data_type;
+extern const rb_data_type_t rw_candefwndprc_d_type;
+extern const rb_data_type_t rwcanvas_data_type;
+extern const rb_data_type_t rwfont_data_type;
+extern const rb_data_type_t rwicon_data_type;
+extern const rb_data_type_t rwcursor_data_type;
+extern const rb_data_type_t rwbitmap_data_type;
+extern const rb_data_type_t rwpen_data_type;
+extern const rb_data_type_t rwbrush_data_type;
+extern const rb_data_type_t rwimagelist_data_type;
+extern const rb_data_type_t rwmenu_data_type;
+extern const rb_data_type_t rwimage_data_type;
+
+#define CFunc_Data_Make_Struct(obj, sval) \
+          TypedData_Make_Struct(obj, CFuncData, &cfunc_data_type, sval)
+
+#define CFunc_Data_Get_Struct(obj, sval) \
+          TypedData_Get_Struct(obj, CFuncData, &cfunc_data_type, sval)
+
+#define CStruct_Data_Make_Struct(obj, sval) \
+          TypedData_Make_Struct(obj, CStructData, &cstruct_data_type, sval)
+
+#define CStruct_Data_Get_Struct(obj, sval) \
+          TypedData_Get_Struct(obj, CStructData, &cstruct_data_type, sval)
+
+#define RwWindow_Data_Make_Struct(obj, sval) \
+          TypedData_Make_Struct(obj, RwWindow, &rwwin_data_type, sval)
+
+#define RwWindow_Data_Get_Struct(obj, sval) \
+          TypedData_Get_Struct(obj, RwWindow, &rwwin_data_type, sval)
+
+#define RwDialog_Data_Make_Struct(obj, sval) \
+          TypedData_Make_Struct(obj, RwDialog, &rwdlg_data_type, sval)
+
+#define RwDialog_Data_Get_Struct(obj, sval) \
+          TypedData_Get_Struct(obj, RwDialog, &rwdlg_data_type, sval)
+
+#define RwCanvas_Data_Make_Struct(obj, sval) \
+          TypedData_Make_Struct(obj, RwCanvas, &rwcanvas_data_type, sval)
+
+#define RwCanvas_Data_Get_Struct(obj, sval) \
+          TypedData_Get_Struct(obj, RwCanvas, &rwcanvas_data_type, sval)
+
+#define RwFont_Data_Make_Struct(obj, sval) \
+          TypedData_Make_Struct(obj, RwFont, &rwfont_data_type, sval)
+
+#define RwFont_Data_Get_Struct(obj, sval) \
+          TypedData_Get_Struct(obj, RwFont, &rwfont_data_type, sval)
+
+#define RwIcon_Data_Make_Struct(obj, sval) \
+          TypedData_Make_Struct(obj, RwIcon, &rwicon_data_type, sval)
+
+#define RwIcon_Data_Get_Struct(obj, sval) \
+          TypedData_Get_Struct(obj, RwIcon, &rwicon_data_type, sval)
+
+#define RwCursor_Data_Make_Struct(obj, sval) \
+          TypedData_Make_Struct(obj, RwCursor, &rwcursor_data_type, sval)
+
+#define RwCursor_Data_Get_Struct(obj, sval) \
+          TypedData_Get_Struct(obj, RwCursor, &rwcursor_data_type, sval)
+
+#define RwBitmap_Data_Make_Struct(obj, sval) \
+          TypedData_Make_Struct(obj, RwBitmap, &rwbitmap_data_type, sval)
+
+#define RwBitmap_Data_Get_Struct(obj, sval) \
+          TypedData_Get_Struct(obj, RwBitmap, &rwbitmap_data_type, sval)
+
+#define RwPen_Data_Make_Struct(obj, sval) \
+          TypedData_Make_Struct(obj, RwPen, &rwpen_data_type, sval)
+
+#define RwPen_Data_Get_Struct(obj, sval) \
+          TypedData_Get_Struct(obj, RwPen, &rwpen_data_type, sval)
+
+#define RwBrush_Data_Make_Struct(obj, sval) \
+          TypedData_Make_Struct(obj, RwBrush, &rwbrush_data_type, sval)
+
+#define RwBrush_Data_Get_Struct(obj, sval) \
+          TypedData_Get_Struct(obj, RwBrush, &rwbrush_data_type, sval)
+
+#define RwImagelist_Data_Make_Struct(obj, sval) \
+          TypedData_Make_Struct(obj, RwImagelist, &rwimagelist_data_type, sval)
+
+#define RwImagelist_Data_Get_Struct(obj, sval) \
+          TypedData_Get_Struct(obj, RwImagelist, &rwimagelist_data_type, sval)
+
+#define RwMenu_Data_Make_Struct(obj, sval) \
+          TypedData_Make_Struct(obj, RwMenu, &rwmenu_data_type, sval)
+
+#define RwMenu_Data_Get_Struct(obj, sval) \
+          TypedData_Get_Struct(obj, RwMenu, &rwmenu_data_type, sval)
+
+#define RwImage_Data_Make_Struct(obj, sval) \
+          TypedData_Make_Struct(obj, RwImage, &rwimage_data_type, sval)
+
+#define RwImage_Data_Get_Struct(obj, sval) \
+          TypedData_Get_Struct(obj, RwImage, &rwimage_data_type, sval)
+
+/* Encoding */
+extern VALUE internal_encoding, external_encoding, wchar_encoding;
+extern rb_encoding *rw_internal_enc, *rw_external_enc, *rw_wchar_enc;
+
+//inline TCHAR* rw_encode_internal(VALUE str);
+TCHAR *rw_str2tchar(VALUE str);
+WCHAR *rw_str2wchar(VALUE str);
+TCHAR *rw_str2tchar2(VALUE str, size_t* bytesize);
+     
+VALUE rw_encode_external(TCHAR *buff);
+VALUE rw_encode_external2(WCHAR *buff, int len);
+
+/* prototyping */
+// void cst_set_memory_to_struct(CStructData* sdtptr, char *target, const size_t len);
+
+/* Unblocking functions (defined in 'rw_ubfunc.c')*/
+#ifdef RWIN_USEMULTITHREAD
+#  define CALL_NON_GVL_FUNC(apiproc, calldata) \
+      (LONG_PTR)rb_thread_call_without_gvl((void*(*)(void*))apiproc, calldata, RUBY_UBF_IO, 0)
+#else
+#  define CALL_NON_GVL_FUNC(apiproc, calldata) (LONG_PTR)apiproc(calldata)
+#endif
+
+ULONG_PTR rw_call_std_func_0(ULONG_PTR* arg);
+ULONG_PTR rw_call_std_func_1(ULONG_PTR* arg);
+ULONG_PTR rw_call_std_func_2(ULONG_PTR* arg);
+ULONG_PTR rw_call_std_func_3(ULONG_PTR* arg);
+ULONG_PTR rw_call_std_func_4(ULONG_PTR* arg);
+ULONG_PTR rw_call_std_func_5(ULONG_PTR* arg);
+ULONG_PTR rw_call_std_func_6(ULONG_PTR* arg);
+ULONG_PTR rw_call_std_func_7(ULONG_PTR* arg);
+ULONG_PTR rw_call_std_func_8(ULONG_PTR* arg);
+ULONG_PTR rw_call_std_func_9(ULONG_PTR* arg);
+ULONG_PTR rw_call_std_func_10(ULONG_PTR* arg);
+ULONG_PTR rw_call_std_func_11(ULONG_PTR* arg);
+ULONG_PTR rw_call_std_func_12(ULONG_PTR* arg);
+
+ULONG_PTR rw_call_without_gvl_0(DWORD, FARPROC);
+ULONG_PTR rw_call_without_gvl_1(DWORD, FARPROC, ULONG_PTR);
+ULONG_PTR rw_call_without_gvl_2(DWORD, FARPROC, ULONG_PTR, ULONG_PTR);
+ULONG_PTR rw_call_without_gvl_3(DWORD, FARPROC, ULONG_PTR, ULONG_PTR, ULONG_PTR);
+ULONG_PTR rw_call_without_gvl_4(DWORD, FARPROC, ULONG_PTR, ULONG_PTR, ULONG_PTR, ULONG_PTR);
+ULONG_PTR rw_call_without_gvl_5(DWORD, FARPROC, ULONG_PTR, ULONG_PTR, ULONG_PTR, ULONG_PTR, ULONG_PTR);
+ULONG_PTR rw_call_without_gvl_6(DWORD, FARPROC, ULONG_PTR, ULONG_PTR, ULONG_PTR, ULONG_PTR, ULONG_PTR, ULONG_PTR);
+ULONG_PTR rw_call_without_gvl_7(DWORD, FARPROC, ULONG_PTR, ULONG_PTR, ULONG_PTR, ULONG_PTR, ULONG_PTR, ULONG_PTR, ULONG_PTR);
+ULONG_PTR rw_call_without_gvl_8(DWORD, FARPROC, ULONG_PTR, ULONG_PTR, ULONG_PTR, ULONG_PTR, ULONG_PTR, ULONG_PTR, ULONG_PTR, ULONG_PTR);
+ULONG_PTR rw_call_without_gvl_9(DWORD, FARPROC, ULONG_PTR, ULONG_PTR, ULONG_PTR, ULONG_PTR, ULONG_PTR, ULONG_PTR, ULONG_PTR, ULONG_PTR, ULONG_PTR);
+ULONG_PTR rw_call_without_gvl_10(DWORD, FARPROC, ULONG_PTR, ULONG_PTR, ULONG_PTR, ULONG_PTR, ULONG_PTR, ULONG_PTR, ULONG_PTR, ULONG_PTR, ULONG_PTR, ULONG_PTR);
+ULONG_PTR rw_call_without_gvl_11(DWORD, FARPROC, ULONG_PTR, ULONG_PTR, ULONG_PTR, ULONG_PTR, ULONG_PTR, ULONG_PTR, ULONG_PTR, ULONG_PTR, ULONG_PTR, ULONG_PTR, ULONG_PTR);
+ULONG_PTR rw_call_without_gvl_12(DWORD, FARPROC, ULONG_PTR, ULONG_PTR, ULONG_PTR, ULONG_PTR, ULONG_PTR, ULONG_PTR, ULONG_PTR, ULONG_PTR, ULONG_PTR, ULONG_PTR, ULONG_PTR, ULONG_PTR);
+
+/* prototypes */
+LRESULT CALLBACK RwWndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
+void destroy_all_win(int);
+VALUE cstruct_wrapptr(VALUE klass, char* pointer, VALUE parent);
+VALUE rwcvs_new_from_hdc(VALUE klass, HDC hdc);
+void rwgdiplus_shutdown();
+VALUE stream2string(LPSTREAM pstream);
+VALUE api_cstruct_new(VALUE klass);
+void rwconv2absolute_path(char* dst, char* src);
+void rwconv2absolute_pathW(wchar_t* dst, wchar_t* src);
+
+/* prototypes of Initializer */
+void Init_rwin();
+void Init_rw_api();
+void Init_rw_windows();
+void Init_rw_dialog();
+void Init_rw_resources();
+void Init_rw_graphics();
+void Init_rw_devices();
+
+#endif /* __RWIN_H__ */