Tiles!

git-svn-id: https://crawl-ref.svn.sourceforge.net/svnroot/crawl-ref/trunk@3194 c06c8d41-db1a-0410-9941-cceddc491573

1 files changed, 999 insertions, 0 deletions

diff --git a/crawl-ref/source/guic-win.cc b/crawl-ref/source/guic-win.cc
new file mode 100644
index 0000000000..7624f44334
--- /dev/null
+++ b/crawl-ref/source/guic-win.cc
@@ -0,0 +1,999 @@
+// Windows ヘッダー ファイル:
+#include <windows.h>
+#include <commdlg.h>
+#include <commctrl.h>
+
+// C ランタイム ヘッダー ファイル
+#include <stdio.h>
+#include <stdlib.h>
+#include <malloc.h>
+#include <memory.h>
+#include <tchar.h>
+
+// WinClass & RegionClass definitions
+#include "guic.h"
+
+static HINSTANCE hInst;
+static int       nCmdShow;
+
+// colors
+static COLORREF term_pix[MAX_TERM_COL];
+BYTE pix_transparent;
+BYTE pix_black;
+BYTE pix_white;
+BYTE pix_magenta;
+BYTE pix_rimcolor;
+
+RGBQUAD RegionClass::std_palette[256];
+
+bool GuicInit(HINSTANCE h, int nCmd)
+{
+    int i;
+    hInst = h;
+    nCmdShow = nCmd;
+
+    for (i=0; i< MAX_TERM_COL; i++)
+    {
+	int *c = (int *)&term_colors[i];
+        term_pix[i] =PALETTERGB( c[0], c[1], c[2] );
+    }
+    return true;
+}
+
+void GuicDeinit()
+{
+
+}
+
+void WinClass::SysInit()
+{
+    hWnd = NULL;
+}
+
+void WinClass::SysDeinit()
+{}
+
+void RegionClass::SysInit()
+{
+    font = NULL;
+}
+
+void RegionClass::SysDeinit()
+{
+    if (font != NULL && !font_copied) DeleteObject(font);
+}
+
+void RegionClass::sys_flush()
+{}
+
+void TextRegionClass::SysInit(int x, int y, int cx, int cy)
+{
+    dos_char = false;
+}
+
+void TextRegionClass::SysDeinit()
+{}
+
+void TileRegionClass::SysInit(int mx0, int my0, int dx0, int dy0)
+{}
+
+void TileRegionClass::SysDeinit()
+{}
+
+void MapRegionClass::SysInit(int x, int y, int o_x, int o_y)
+{}
+
+void MapRegionClass::SysDeinit()
+{}
+
+void RegionClass::init_font(const char *name, int height)
+{
+    int wid, hgt;
+    LOGFONT lf;
+    HFONT ftmp;
+
+    strcpy(lf.lfFaceName, name);
+    lf.lfHeight        = height;
+    lf.lfWidth         = 0;
+    lf.lfEscapement    = 0;
+    lf.lfOrientation   = lf.lfEscapement;
+    lf.lfWeight        = FW_NORMAL;
+    lf.lfItalic        = FALSE;
+    lf.lfUnderline     = FALSE;
+    lf.lfStrikeOut     = FALSE;
+    lf.lfOutPrecision  = OUT_DEFAULT_PRECIS;
+    lf.lfClipPrecision = CLIP_DEFAULT_PRECIS;
+    lf.lfQuality       = DEFAULT_QUALITY;
+#ifdef JP
+    lf.lfCharSet       = (dos_char) ? OEM_CHARSET:SHIFTJIS_CHARSET;
+    lf.lfPitchAndFamily= FF_DONTCARE|FIXED_PITCH;
+#else
+    lf.lfCharSet       = (dos_char) ? OEM_CHARSET:ANSI_CHARSET;
+    lf.lfPitchAndFamily= FF_MODERN|FIXED_PITCH;
+#endif
+    ftmp = CreateFontIndirect( &lf );
+
+    if (!ftmp)
+    {
+	if (font) return;
+	exit(1);
+    }
+    font = ftmp;
+
+    wid = lf.lfWidth;
+    hgt = lf.lfHeight;
+    /* This part is taken from angband */
+    /* Hack -- Unknown size */
+    if (!wid || !hgt)
+    {
+        HDC hdcDesktop;
+        HFONT hfOld;
+        TEXTMETRIC tm;
+
+        /* all this trouble to get the cell size */
+        hdcDesktop = GetDC(HWND_DESKTOP);
+        hfOld = (HFONT)SelectObject(hdcDesktop, font);
+        GetTextMetrics(hdcDesktop, &tm);
+        SelectObject(hdcDesktop, hfOld);
+        ReleaseDC(HWND_DESKTOP, hdcDesktop);
+
+        /* Font size info */
+        wid = tm.tmAveCharWidth;
+        hgt = tm.tmHeight;
+    }
+
+    fx = dx = wid;
+    fy = dy = hgt;
+}
+
+void RegionClass::change_font(const char *name, int height)
+{
+    if (font != NULL) DeleteObject(font);
+    init_font(name, height);
+}
+
+void RegionClass::copy_font(RegionClass *r)
+{
+    fx = r->fx;
+    fy = r->fy;
+    dx = r->dx;
+    dy = r->dy;
+    font = r->font;
+}
+
+void RegionClass::set_std_palette(RGBQUAD *pPal)
+{
+    int i;
+    for(i=0;i<256;i++)
+    {
+	std_palette[i].rgbRed   = pPal[i].rgbRed  ;
+	std_palette[i].rgbGreen = pPal[i].rgbGreen;
+	std_palette[i].rgbBlue  = pPal[i].rgbBlue ;
+
+        if ( (pPal[i].rgbRed   == 0)
+           &&(pPal[i].rgbGreen == 0)
+           &&(pPal[i].rgbBlue  == 0) )
+            pix_black = i;
+
+        //白(255, 255, 255)の番号を格納
+        if ( (pPal[i].rgbRed   == 255)
+           &&(pPal[i].rgbGreen == 255)
+           &&(pPal[i].rgbBlue  == 255) )
+            pix_white = i;
+
+        //マゼンタ(255, 0, 255)の番号を格納
+        if ( (pPal[i].rgbRed   == 255)
+           &&(pPal[i].rgbGreen == 0  )
+           &&(pPal[i].rgbBlue  == 255) )
+            pix_magenta = i;
+
+        //縁の色(1, 1, 1)の番号を格納
+        if ( (pPal[i].rgbRed   == 1)
+           &&(pPal[i].rgbGreen == 1)
+           &&(pPal[i].rgbBlue  == 1) )
+            pix_rimcolor = i;
+    }
+
+    std_palette[pix_transparent].rgbRed   = 0;
+    std_palette[pix_transparent].rgbGreen = 0;
+    std_palette[pix_transparent].rgbBlue  = 0;
+}
+
+void RegionClass::init_backbuf(RGBQUAD *pPal, int ncolor)
+{
+    int i;
+
+    // first time
+    if (backbuf == NULL)
+    {
+        // alloc for misc info
+        backbuf = (dib_pack *)GlobalAlloc(GPTR, sizeof(dib_pack));
+
+        // alloc for header+palette data
+        backbuf->pDib = (LPBITMAPINFO)GlobalAlloc(GPTR,
+                (sizeof(BITMAPINFO) + 256 * sizeof(RGBQUAD)) );
+
+        // set header data
+        backbuf->pDib->bmiHeader.biSize     = sizeof(BITMAPINFOHEADER);
+        backbuf->pDib->bmiHeader.biPlanes   = 1;
+        backbuf->pDib->bmiHeader.biBitCount = 8;
+        backbuf->pDib->bmiHeader.biCompression=BI_RGB;
+        backbuf->pDib->bmiHeader.biSizeImage=0;
+        backbuf->pDib->bmiHeader.biXPelsPerMeter=0;
+        backbuf->pDib->bmiHeader.biYPelsPerMeter=0;
+        backbuf->pDib->bmiHeader.biClrUsed=0;
+        backbuf->pDib->bmiHeader.biClrImportant=0;
+
+        // set palette data
+        for (i = 0; i < ncolor; i++)
+        {
+            // copy palette from given palette pPal
+            backbuf->pDib->bmiColors[i].rgbRed   = pPal[i].rgbRed  ;
+            backbuf->pDib->bmiColors[i].rgbGreen = pPal[i].rgbGreen;
+            backbuf->pDib->bmiColors[i].rgbBlue  = pPal[i].rgbBlue ;
+        }
+    }
+    // set dimension
+    backbuf->pDib->bmiHeader.biWidth    = mx*dx;
+    backbuf->pDib->bmiHeader.biHeight   = my*dy;
+    backbuf->Width = mx * dx;
+    backbuf->Height= my * dy;
+
+    if (win != NULL)
+    {
+        // this routine should be called after the window is initialized
+        if (win->hWnd != NULL)
+        {
+            HDC hdc1 = GetDC(0);
+            HDC hdc2 = GetDC(win->hWnd);
+	    // alloc a region of the window
+            backbuf->hDib = CreateDIBSection(hdc1, backbuf->pDib,
+		    DIB_RGB_COLORS, (VOID **)&(backbuf->pDibBits), NULL, 0);
+            backbuf->hDC = CreateCompatibleDC(hdc2);
+            SelectObject(backbuf->hDC, backbuf->hDib);
+            ReleaseDC(win->hWnd, hdc2);
+            ReleaseDC(0, hdc1);
+        }
+    }
+    backbuf->pDibZero = (backbuf->pDibBits) 
+	+ (backbuf->Height -1) * backbuf->Width;
+}
+
+void RegionClass::resize_backbuf()
+{
+    int i;
+
+    // discard it for resize
+    if (backbuf->hDC != NULL)  DeleteDC(backbuf->hDC);
+    if (backbuf->hDib != NULL) DeleteObject(backbuf->hDib);
+
+    // set dimension
+    backbuf->pDib->bmiHeader.biWidth    = mx*dx;
+    backbuf->pDib->bmiHeader.biHeight   = my*dy;
+    backbuf->Width = mx * dx;
+    backbuf->Height= my * dy;
+
+    HDC hdc1 = GetDC(0);
+    HDC hdc2 = GetDC(win->hWnd);
+    // alloc a region of the window
+    backbuf->hDib = CreateDIBSection(hdc1, backbuf->pDib,
+	    DIB_RGB_COLORS, (VOID **)&(backbuf->pDibBits), NULL, 0);
+    backbuf->hDC = CreateCompatibleDC(hdc2);
+    SelectObject(backbuf->hDC, backbuf->hDib);
+    ReleaseDC(win->hWnd, hdc2);
+    ReleaseDC(0, hdc1);
+
+    backbuf->pDibZero = (backbuf->pDibBits) 
+	+ (backbuf->Height -1) * backbuf->Width;
+
+    for (i = 0; i< mx*dx*my*dy; i++)
+        *(backbuf->pDibBits + i) = pix_black;
+}
+
+void MapRegionClass::resize_backbuf()
+{
+    RegionClass::resize_backbuf();
+}
+
+void TileRegionClass::resize_backbuf()
+{
+    RegionClass::resize_backbuf();
+}
+
+void TextRegionClass::init_backbuf()
+{
+  /* not use */
+}
+
+void TileRegionClass::init_backbuf(RGBQUAD *pPal)
+{
+    int i;
+    if (!pPal)
+       RegionClass::init_backbuf(std_palette, 256);
+    else
+       RegionClass::init_backbuf(pPal, 256);
+
+    for (i = 0; i< mx*dx*my*dy; i++)
+        *(backbuf->pDibBits + i) = pix_black;
+
+}
+
+void MapRegionClass::init_backbuf()
+{
+//ミニマップ用パレットの作成
+    BYTE black = 0;
+    RGBQUAD scol[MAX_MAP_COL];
+    int i;
+
+    for (i=0; i< MAX_MAP_COL;i++)
+    {
+	scol[i].rgbBlue  = map_colors[i][2];
+	scol[i].rgbGreen = map_colors[i][1];
+	scol[i].rgbRed   = map_colors[i][0];
+	scol[i].rgbReserved = 0;
+    }
+
+    // just resize
+    if (backbuf != NULL)
+        RegionClass::init_backbuf(NULL, 0);
+    else
+        RegionClass::init_backbuf(scol, MAX_MAP_COL);
+
+    for (i = 0; i < MAX_MAP_COL; i++)
+    {
+        //黒(0, 0, 0)の番号を格納
+        if ( (backbuf->pDib->bmiColors[i].rgbRed   == 0)
+           &&(backbuf->pDib->bmiColors[i].rgbGreen == 0)
+           &&(backbuf->pDib->bmiColors[i].rgbBlue  == 0) )
+            black = i;
+    }
+
+    for (i = 0; i< mx*dx*my*dy; i++)
+       *(backbuf->pDibBits + i) = black; //黒で埋める。
+}
+
+// defined to object, not to class
+void TextRegionClass::draw_string(int x, int y, unsigned char *buf,
+           int len, int col)
+{
+    HDC hdc = GetDC(win->hWnd);
+    RECT rc;
+    rc.left = ox + x * dx;
+    rc.right = rc.left + len * dx;
+    rc.top =  oy + y * dy;
+    rc.bottom = rc.top + dy;
+    SelectObject(hdc, font);
+    SetBkColor(hdc, term_pix[col>>4]);
+    SetTextColor(hdc, term_pix[col&0x0f]);
+    ExtTextOut(hdc, rc.left, rc.top,  ETO_CLIPPED, &rc,
+	    (char *)buf, len, NULL);
+    ReleaseDC(win->hWnd, hdc);
+}
+
+void TextRegionClass::draw_cursor(int x, int y)
+{
+    RECT rc;
+    HDC hdc;
+
+    int cx = x - cx_ofs;
+    int cy = y - cy_ofs;
+
+    if(!flag)return;
+
+    hdc =GetDC(win->hWnd);
+    SelectObject(hdc, font);
+
+    rc.left = ox + cx * dx ;
+    rc.right = rc.left + (2 * dx);
+    rc.top =  oy + cy * dy;
+    rc.bottom = rc.top + dy;
+
+    SetBkMode(hdc, TRANSPARENT);
+    SetTextColor(hdc, term_pix[0x0f]);
+    ExtTextOut(hdc, rc.left, rc.top,  ETO_CLIPPED, &rc,
+                           "_ ", 2, NULL);
+    ReleaseDC(win->hWnd, hdc);
+}
+
+void TextRegionClass::erase_cursor(){
+
+    int x0 = cursor_x;
+    int y0 = cursor_y;
+    int adrs = y0 * mx + x0;
+    int col = abuf[adrs];
+
+    if(!flag)return;
+
+    RECT rc;
+    HDC hdc =GetDC(win->hWnd);
+    SelectObject(hdc, font);
+
+    //restore previous cursor cell
+    rc.left = ox + x0 * dx;
+    rc.right= rc.left + (2 * dx);
+    rc.top  = oy + y0 * dy;
+    rc.bottom = rc.top + dy;
+    unsigned char rchar[3];
+
+    SetBkColor(hdc, term_pix[col>>4]);
+    SetTextColor(hdc, term_pix[col&0x0f]);
+    rchar[0] = cbuf[adrs];
+#ifdef JP
+    if ( (rchar[0]&0x80) && !dos_char /*_ismbblead( rchar[0])*/ )
+    {
+        rchar[1] = cbuf[adrs+1];
+        rchar[2] = '\0';
+        ExtTextOut(hdc, rc.left, rc.top,  ETO_CLIPPED, &rc,
+                           (char *)&rchar, 2, NULL);
+    }
+    else
+#endif
+    {
+        rchar[1] = '\0';
+        ExtTextOut(hdc, rc.left, rc.top,  ETO_CLIPPED, &rc,
+                           (char *)&rchar, 1, NULL);
+    }
+    ReleaseDC(win->hWnd, hdc);
+}
+
+
+void WinClass::clear()
+{
+    fillrect(0, 0, wx-1, wy-1, PIX_BLACK);
+}
+
+void RegionClass::clear()
+{
+    fillrect(0, 0, wx-1, wy-1, PIX_BLACK);
+}
+
+void TileRegionClass::clear()
+{
+    RegionClass::clear();
+}
+
+void MapRegionClass::clear()
+{
+    int i;
+
+    for (i=0; i<mx2*my2; i++)
+    {
+        mbuf[i]=PIX_BLACK;
+    }
+    RegionClass::clear();
+}
+
+void TextRegionClass::clear()
+{
+    int i;
+
+    for (i=0; i<mx*my; i++)
+    {
+        cbuf[i]=' ';
+        abuf[i]=0;
+    }
+    RegionClass::clear();
+}
+
+BOOL WinClass::create(const char *name)
+{
+
+    RECT rc;
+    rc.left   = 0;
+    rc.right  = wx;
+    rc.top    = 0;
+    rc.bottom = wy;
+
+    //game_state = STAT_NORMAL;
+
+    if ( GetSystemMetrics(SM_CYSCREEN) < (oy + wy) ) oy =0;
+    if ( GetSystemMetrics(SM_CXSCREEN) < (ox + wx) ) ox =0;
+
+    AdjustWindowRectEx(&rc,
+                       (WS_OVERLAPPED  | WS_SYSMENU |
+                        WS_MINIMIZEBOX | WS_CAPTION |
+                        WS_VISIBLE),
+                       false, 0);
+
+    if (hWnd == NULL)
+    {
+        hWnd = CreateWindowEx(0, "CrawlList",name,
+                          (WS_OVERLAPPED  | WS_SYSMENU |
+                           WS_MINIMIZEBOX | WS_CAPTION |
+                           WS_VISIBLE),
+                           ox, oy, //pos
+                           rc.right - rc.left, rc.bottom - rc.top, //size
+                           HWND_DESKTOP, NULL, hInst, NULL);
+       ShowWindow( hWnd, nCmdShow );
+    }
+    if( !hWnd )
+    {
+       return FALSE;
+    }
+
+   clear();
+
+#if 0
+   // Init pending backbuf of regions
+   std::vector<RegionClass *>::iterator r;
+
+   for (r = regions.begin();r != regions.end();r++)
+   {
+        if ( (*r)->backbuf != NULL)
+        {
+            img_type b = (*r)->backbuf;
+            HDC hdc1 = GetDC(0);
+            HDC hdc2 = GetDC(hWnd);
+            b->hDib = CreateDIBSection(hdc1, b->pDib, DIB_RGB_COLORS,
+                               (VOID **)&(b->pDibBits), NULL, 0);
+            b->hDC = CreateCompatibleDC(hdc2);
+            SelectObject(b->hDC, b->hDib);
+            ReleaseDC(hWnd, hdc2);
+            ReleaseDC(0, hdc1);
+        }
+   }
+#endif
+   return TRUE;
+}
+
+void WinClass::move()
+{
+        SetWindowPos(hWnd, 0, ox, oy, wx, wy, SWP_NOSIZE);
+        UpdateWindow( hWnd );
+}
+
+void WinClass::resize()
+{
+    RECT rc;
+    rc.left   = 0;
+    rc.right  = wx;
+    rc.top    = 0;
+    rc.bottom = wy;
+
+    AdjustWindowRectEx(&rc,
+                       (WS_OVERLAPPED  | WS_SYSMENU |
+                        WS_MINIMIZEBOX | WS_CAPTION |
+                        WS_VISIBLE),
+                       false, 0);
+
+    SetWindowPos(hWnd, 0, ox, oy,
+	    rc.right - rc.left,
+	    rc.bottom - rc.top,
+	    SWP_NOMOVE);
+    UpdateWindow( hWnd );
+}
+
+
+void TileRegionClass::redraw(int x1, int y1, int x2, int y2)
+{
+    if (!flag) return;
+    if (!is_active()) return;
+
+    HDC hdc = GetDC(win->hWnd);
+    BitBlt(hdc, ox, oy, mx*dx, my*dy,
+           backbuf->hDC, 0, 0, SRCCOPY);
+    ReleaseDC(win->hWnd, hdc);
+}
+
+void MapRegionClass::redraw(int x1, int y1, int x2, int y2)
+{
+    if (!flag) return;
+    if (!is_active()) return;
+    HDC hdc =GetDC(win->hWnd);
+    BitBlt(hdc, ox, oy, dx*mx, dy*my,
+           backbuf->hDC, 0, 0, SRCCOPY);
+    ReleaseDC(win->hWnd, hdc);
+}
+
+void MapRegionClass::draw_data(unsigned char *buf){
+    int i, j, x, y, col;
+    int dx2, dy2;
+    static int px = 0;
+    static int py = 0;
+
+    if(!flag)return;
+
+    LPBYTE ppix ,dpix;
+    // 外側、内側の x, y ループでのアドレス増分
+    int inc_x, inc_y, inc_x0, inc_y0;
+    int bufx = mx * dx;
+    int bufy = my * dy;
+
+    bufx = (bufx+3)/4;
+    bufx *=4;
+#define BUF_IDX(x,y, x1, y1) ((x)*dx-(y)*dy*bufx + (x1) - (y1)*bufx)
+#define BUF_IDX_ISO(x,y, x1, y1) ((x-y+my2-1)*dx-(x+y)*dy*bufx + (x1)-(y1)*bufx)
+    // upper left corner
+    LPBYTE pDibBit0 = backbuf->pDibBits + bufx*(bufy-1);
+
+    dx2 = dx;
+    dy2 = dy;
+    ppix  = pDibBit0;
+
+    inc_x = dx;
+    inc_x0 = 1;
+
+    // 上にdy 左に mmapDibX
+    inc_y = - mx2 * inc_x + BUF_IDX(0, 1, 0, 0);
+    // 上に1 左に dx
+    inc_y0 = - dx2 * inc_x0 + BUF_IDX(0, 0, 0, 1);
+
+    // Draw gauge
+	// erase old
+    for (j = 0; j < dy*2; j++)
+	{
+	    *(pDibBit0 + BUF_IDX(px, 0, dx/2, j)) = MAP_BLACK;
+	}
+    for (j = 0; j < dx*2; j++)
+	{
+	    *(pDibBit0 + BUF_IDX(0, py, j, dy/2)) = MAP_BLACK;
+	}
+
+    dpix  = ppix;
+    for (j = 0; j < my2; j++)
+    {
+        for (i = 0; i < mx2; i++)
+        {
+            col=buf[(i+x_margin) + (j+y_margin)*(mx2 + x_margin*2)];
+            if (col == MAP_WHITE)
+            {
+                px = i;
+                py = j;
+            }
+            if ( (col != get_col(i,j)) || force_redraw)
+            {
+                dpix = ppix;
+                for (y=0; y<dy2; y++)
+                {
+                    for (x=0; x<dx2; x++)
+                    {
+                        *dpix = col;
+                        dpix += inc_x0;
+                    }
+                    dpix += inc_y0;
+                }
+                set_col(col, i,j);
+            }
+            ppix += inc_x;
+        }
+        ppix += inc_y;
+    }
+
+	// draw gauge
+    for (j = 0; j < dy*2; j++)
+	{
+	    *(pDibBit0 + BUF_IDX(px, 0, dx/2, j)) = MAP_WHITE;
+	}
+    for (j = 0; j < dx*2; j++)
+	{
+	    *(pDibBit0 + BUF_IDX(0, py, j, dy/2)) = MAP_WHITE;
+	}
+
+    redraw();
+    force_redraw = false;
+}
+
+/* XXXXX
+ * img_type related
+ */
+
+LPBYTE dib_ref_pixel(dib_pack* dib, int x, int y)
+{
+    int w = ((3 + dib->Width)/4)*4;
+    LPBYTE ref = dib->pDibBits + x + (dib->Height -1 -y) * w;
+    return ref;
+}
+
+bool ImgIsTransparentAt(img_type img, int x, int y)
+{
+    if (pix_transparent == *( dib_ref_pixel(img, x, y) )) return true;
+    return false;
+}
+void ImgSetTransparentPix(img_type img)
+{
+    pix_transparent = (BYTE)*(img->pDibZero);
+}
+
+img_type ImgCreateSimple(int wx, int wy)
+{
+    if (wx ==0 || wy == 0) return NULL;
+    dib_pack *ptr = (dib_pack *)GlobalAlloc(GPTR, sizeof(dib_pack));
+
+    ptr->pDibBits = (LPBYTE)GlobalAlloc(GPTR, wx*wy );
+    ptr->pDibZero = ptr->pDibBits + (wy -1)* wx;
+    ptr->Width    = wx;
+    ptr->Height   = wy;
+
+    ptr->pDib = NULL;
+    ptr->hDib = NULL;
+    ptr->hDC  = NULL;
+
+    return ptr;
+}
+
+void ImgDestroy(img_type img)
+{
+    if (!img) return;
+
+    //if (img->pDibBits) GlobalFree(img->pDibBits);
+    if (img->pDib) GlobalFree(img->pDib);
+    if (img->hDC)  DeleteDC  (img->hDC);
+    if (img->hDib) DeleteObject(img->hDib);
+
+    GlobalFree(img);
+}
+
+img_type ImgLoadFile(const char *name)
+{
+    HANDLE fh;
+    DWORD dummy;
+    BITMAPFILEHEADER bmHead;
+    int BitsSize;
+    HDC hdc1;
+    dib_pack *img;
+
+    hdc1 = GetDC(0);
+
+    fh=CreateFile(name, GENERIC_READ,0,NULL,OPEN_EXISTING,
+        FILE_ATTRIBUTE_NORMAL,NULL);
+    if (fh == INVALID_HANDLE_VALUE) return NULL;
+
+    SetFilePointer(fh,0,NULL,FILE_BEGIN);
+
+    if (!ReadFile(fh,&bmHead, sizeof(BITMAPFILEHEADER), &dummy, NULL))
+    return NULL;
+
+    img = (dib_pack *) GlobalAlloc(GPTR, sizeof(dib_pack));
+    if (!img) return  NULL;
+
+    img->pDib = (LPBITMAPINFO)GlobalAlloc(GPTR,
+                (sizeof(BITMAPINFO) + 256 * sizeof(RGBQUAD)) );
+    if (img->pDib == NULL)
+    {
+        GlobalFree(img);
+        return NULL;
+    }
+
+    SetFilePointer(fh, sizeof(BITMAPFILEHEADER), NULL, FILE_BEGIN);
+    if (!ReadFile(fh,img->pDib, sizeof(BITMAPINFOHEADER)+ 256 * sizeof(RGBQUAD),
+             &dummy, NULL))
+    {
+        GlobalFree(img->pDib);
+        GlobalFree(img);
+        return NULL;
+    }
+
+     //DIB作成
+    img->hDib = CreateDIBSection(hdc1, img->pDib, DIB_RGB_COLORS,
+                                (VOID **)&(img->pDibBits), NULL,0);
+    if (img->hDib == NULL)
+    {
+        GlobalFree(img->pDib);
+        GlobalFree(img);
+        return NULL;
+    }
+
+
+    //画像のビット列のサイズ
+    BitsSize = bmHead.bfSize-bmHead.bfOffBits;
+    //ビット配列をポイント
+    SetFilePointer(fh, bmHead.bfOffBits, NULL, FILE_BEGIN);
+
+    //読み込み
+    if (!ReadFile(fh, img->pDibBits, BitsSize, &dummy, NULL))
+    {
+        GlobalFree(img->hDib);
+        GlobalFree(img->pDib);
+        GlobalFree(img);
+        return NULL;
+    }
+
+    CloseHandle(fh); //ファイルを閉じる
+
+    //参照用の構造体に格納
+    img->Width    = img->pDib->bmiHeader.biWidth ;
+    img->Height   = img->pDib->bmiHeader.biHeight;
+    img->pDibZero = img->pDibBits + (img->Height - 1) * img->Width;
+
+    ReleaseDC(0, hdc1);
+    return img;
+}
+
+void ImgClear(img_type img)
+{
+    int i;
+    for (i = 0; i< (img->Width * img->Height); i++)
+        *(img->pDibBits + i) = pix_transparent;
+}
+
+// Copy internal image to another internal image
+void ImgCopy(img_type src,  int sx, int sy, int wx, int wy,
+                    img_type dest, int dx, int dy, int copy)
+{
+    int x, y;
+    BYTE pix;
+
+    if(copy)
+    {
+        for(x=0;x<wx;x++){
+        for(y=0;y<wy;y++){
+            pix = *( dib_ref_pixel(src, sx+x, sy+y) );
+            *( dib_ref_pixel(dest, dx+x, dy+y) ) = pix;
+        }}
+    }
+    else
+    {
+        for(x=0;x<wx;x++){
+        for(y=0;y<wy;y++){
+            pix = *( dib_ref_pixel(src, sx+x, sy+y) );
+            if(pix!=pix_transparent)
+                *( dib_ref_pixel(dest, dx+x, dy+y) ) = pix;
+        }}
+    }
+}
+
+// Copy internal image to another internal image
+void ImgCopyH(img_type src,  int sx, int sy, int wx, int wy,
+                    img_type dest, int dx, int dy, int copy)
+{
+    int x, y;
+    BYTE pix;
+
+    if(copy)
+    {
+        for(x=0;x<wx;x++){
+        for(y=0;y<wy;y++){
+            pix = *( dib_ref_pixel(src, sx+x, sy+y) );
+            if (pix == pix_rimcolor) pix = pix_magenta;
+            *( dib_ref_pixel(dest, dx+x, dy+y) ) = pix;
+        }}
+    }
+    else
+    {
+        for(x=0;x<wx;x++){
+        for(y=0;y<wy;y++){
+            pix = *( dib_ref_pixel(src, sx+x, sy+y) );
+            if (pix == pix_rimcolor) pix = pix_magenta;
+            if(pix!=pix_transparent)    *( dib_ref_pixel(dest, dx+x, dy+y) ) = pix;
+        }}
+    }
+}
+
+
+// Copy internal image to another internal image
+void ImgCopyMasked(img_type src,  int sx, int sy, int wx, int wy,
+                    img_type dest, int dx, int dy, char *mask)
+{
+    int x, y;
+    BYTE pix;
+    int count = 0;
+    for(y=0;y<wy;y++){
+    for(x=0;x<wx;x++){
+        pix = *( dib_ref_pixel(src, sx+x, sy+y) );
+        if (mask[count]==0 && pix != pix_transparent)
+            *( dib_ref_pixel(dest, dx+x, dy+y) ) = pix;
+        count++;
+    }}
+}
+
+// Copy internal image to another internal image
+void ImgCopyMaskedH(img_type src,  int sx, int sy, int wx, int wy,
+                    img_type dest, int dx, int dy, char *mask)
+{
+    int x, y;
+    BYTE pix;
+    int count = 0;
+    for(y=0;y<wy;y++){
+    for(x=0;x<wx;x++){
+        pix = *( dib_ref_pixel(src, sx+x, sy+y) );
+        if (pix == pix_rimcolor) pix = pix_magenta;
+        if (mask[count]==0 && pix != pix_transparent)
+            *( dib_ref_pixel(dest, dx+x, dy+y) ) = pix;
+        count++;
+    }}
+}
+
+void WinClass::fillrect(int left, int top, int right, int bottom, int color)
+{
+    HDC hdc = GetDC(hWnd);
+
+    HBRUSH curbrush;
+    HDC   curbrushhdc = NULL;
+    RECT   currect;
+    curbrush = CreateSolidBrush(term_pix[color]);
+    currect.left  = left;
+    currect.right = right;
+    currect.top   = top;
+    currect.bottom= bottom;
+    SelectObject(curbrushhdc, curbrush);
+    FillRect(hdc, &currect, curbrush);
+    DeleteObject(curbrush);
+    DeleteDC(curbrushhdc);
+
+    ReleaseDC(hWnd, hdc);
+}
+
+
+void TileRegionClass::DrawPanel(int left, int top, int width, int height)
+{
+    framerect(left, top , left + width, top + height, PIX_WHITE);
+    framerect(left + 1, top + 1, left + width, top + height, PIX_DARKGREY);
+    fillrect (left + 1, top + 1, left + width - 1, top + height -1, PIX_LIGHTGREY);
+}
+
+void RegionClass::framerect(int left, int top, int right, int bottom, int color)
+{
+    HDC hdc = GetDC(win->hWnd);
+
+    HBRUSH curbrush;
+    HDC   curbrushhdc = NULL;
+    RECT   currect;
+    curbrush = CreateSolidBrush(term_pix[color]);
+    currect.left  = sx+left;
+    currect.right = sx+right;
+    currect.top   = sy+top;
+    currect.bottom= sy+bottom;
+    SelectObject(curbrushhdc, curbrush);
+    FrameRect(hdc, &currect, curbrush);
+    DeleteObject(curbrush);
+    DeleteDC(curbrushhdc);
+
+    ReleaseDC(win->hWnd, hdc);
+}
+
+void TileRegionClass::framerect(int left, int top, int right, int bottom,
+                    int color)
+{
+    HDC dhdc = backbuf->hDC;
+    HBRUSH curbrush;
+    HDC   curbrushhdc = NULL;
+    RECT   currect;
+    curbrush = CreateSolidBrush(term_pix[color]);
+    currect.left  = left;
+    currect.right = right;
+    currect.top   = top;
+    currect.bottom= bottom;
+    SelectObject(curbrushhdc, curbrush);
+    FrameRect(dhdc, &currect, curbrush);
+    DeleteObject(curbrush);
+    DeleteDC(curbrushhdc);
+}
+
+void RegionClass::fillrect(int left, int top, int right, int bottom, int color)
+{
+    HDC hdc = GetDC(win->hWnd);
+
+    HBRUSH curbrush;
+    HDC   curbrushhdc = NULL;
+    RECT   currect;
+    curbrush = CreateSolidBrush(term_pix[color]);
+    currect.left  = sx+left;
+    currect.right = sx+right;
+    currect.top   = sy+top;
+    currect.bottom= sy+bottom;
+    SelectObject(curbrushhdc, curbrush);
+    FillRect(hdc, &currect, curbrush);
+    DeleteObject(curbrush);
+    DeleteDC(curbrushhdc);
+
+    ReleaseDC(win->hWnd, hdc);
+}
+
+void  TileRegionClass::fillrect(int left, int top, int right, int bottom,
+                    int color)
+{
+    HDC dhdc = backbuf->hDC;
+    HBRUSH curbrush;
+    HDC   curbrushhdc = NULL;
+    RECT   currect;
+    curbrush = CreateSolidBrush(term_pix[color]);
+    currect.left  = left;
+    currect.right = right;
+    currect.top   = top;
+    currect.bottom= bottom;
+    SelectObject(curbrushhdc, curbrush);
+    FillRect(dhdc, &currect, curbrush);
+    DeleteObject(curbrush);
+    DeleteDC(curbrushhdc);
+}
+